diff --git a/src/duckdb/extension/core_functions/aggregate/algebraic/avg.cpp b/src/duckdb/extension/core_functions/aggregate/algebraic/avg.cpp
deleted file mode 100644
index f242b2770..000000000
--- a/src/duckdb/extension/core_functions/aggregate/algebraic/avg.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#include "core_functions/aggregate/algebraic_functions.hpp"
-#include "core_functions/aggregate/sum_helpers.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct AvgState {
-	uint64_t count;
-	T value;
-
-	void Initialize() {
-		this->count = 0;
-	}
-
-	void Combine(const AvgState<T> &other) {
-		this->count += other.count;
-		this->value += other.value;
-	}
-};
-
-struct KahanAvgState {
-	uint64_t count;
-	double value;
-	double err;
-
-	void Initialize() {
-		this->count = 0;
-		this->err = 0.0;
-	}
-
-	void Combine(const KahanAvgState &other) {
-		this->count += other.count;
-		KahanAddInternal(other.value, this->value, this->err);
-		KahanAddInternal(other.err, this->value, this->err);
-	}
-};
-
-struct AverageDecimalBindData : public FunctionData {
-	explicit AverageDecimalBindData(double scale) : scale(scale) {
-	}
-
-	double scale;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<AverageDecimalBindData>(scale);
-	};
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<AverageDecimalBindData>();
-		return scale == other.scale;
-	}
-};
-
-struct AverageSetOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.Initialize();
-	}
-	template <class STATE>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.Combine(source);
-	}
-	template <class STATE>
-	static void AddValues(STATE &state, idx_t count) {
-		state.count += count;
-	}
-};
-
-template <class T>
-static T GetAverageDivident(uint64_t count, optional_ptr<FunctionData> bind_data) {
-	T divident = T(count);
-	if (bind_data) {
-		auto &avg_bind_data = bind_data->Cast<AverageDecimalBindData>();
-		divident *= avg_bind_data.scale;
-	}
-	return divident;
-}
-
-struct IntegerAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			double divident = GetAverageDivident<double>(state.count, finalize_data.input.bind_data);
-			target = double(state.value) / divident;
-		}
-	}
-};
-
-struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, AddToHugeint> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			long double divident = GetAverageDivident<long double>(state.count, finalize_data.input.bind_data);
-			target = Hugeint::Cast<long double>(state.value) / divident;
-		}
-	}
-};
-
-struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			long double divident = GetAverageDivident<long double>(state.count, finalize_data.input.bind_data);
-			target = Hugeint::Cast<long double>(state.value) / divident;
-		}
-	}
-};
-
-struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.value / state.count;
-		}
-	}
-};
-
-struct KahanAverageOperation : public BaseSumOperation<AverageSetOperation, KahanAdd> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = (state.value / state.count) + (state.err / state.count);
-		}
-	}
-};
-
-AggregateFunction GetAverageAggregate(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT16: {
-		return AggregateFunction::UnaryAggregate<AvgState<int64_t>, int16_t, double, IntegerAverageOperation>(
-		    LogicalType::SMALLINT, LogicalType::DOUBLE);
-	}
-	case PhysicalType::INT32: {
-		return AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, int32_t, double, IntegerAverageOperationHugeint>(
-		    LogicalType::INTEGER, LogicalType::DOUBLE);
-	}
-	case PhysicalType::INT64: {
-		return AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, int64_t, double, IntegerAverageOperationHugeint>(
-		    LogicalType::BIGINT, LogicalType::DOUBLE);
-	}
-	case PhysicalType::INT128: {
-		return AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, hugeint_t, double, HugeintAverageOperation>(
-		    LogicalType::HUGEINT, LogicalType::DOUBLE);
-	}
-	default:
-		throw InternalException("Unimplemented average aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindDecimalAvg(ClientContext &context, AggregateFunction &function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	function = GetAverageAggregate(decimal_type.InternalType());
-	function.name = "avg";
-	function.arguments[0] = decimal_type;
-	function.return_type = LogicalType::DOUBLE;
-	return make_uniq<AverageDecimalBindData>(
-	    Hugeint::Cast<double>(Hugeint::POWERS_OF_TEN[DecimalType::GetScale(decimal_type)]));
-}
-
-AggregateFunctionSet AvgFun::GetFunctions() {
-	AggregateFunctionSet avg;
-
-	avg.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr,
-	                                  BindDecimalAvg));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT16));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT32));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT64));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT128));
-	avg.AddFunction(AggregateFunction::UnaryAggregate<AvgState<double>, double, double, NumericAverageOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	return avg;
-}
-
-AggregateFunction FAvgFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<KahanAvgState, double, double, KahanAverageOperation>(LogicalType::DOUBLE,
-	                                                                                               LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/algebraic/corr.cpp b/src/duckdb/extension/core_functions/aggregate/algebraic/corr.cpp
deleted file mode 100644
index bf53a5ad3..000000000
--- a/src/duckdb/extension/core_functions/aggregate/algebraic/corr.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "core_functions/aggregate/algebraic_functions.hpp"
-#include "core_functions/aggregate/algebraic/covar.hpp"
-#include "core_functions/aggregate/algebraic/stddev.hpp"
-#include "core_functions/aggregate/algebraic/corr.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-AggregateFunction CorrFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<CorrState, double, double, double, CorrOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/algebraic/covar.cpp b/src/duckdb/extension/core_functions/aggregate/algebraic/covar.cpp
deleted file mode 100644
index fddb9ed28..000000000
--- a/src/duckdb/extension/core_functions/aggregate/algebraic/covar.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "core_functions/aggregate/algebraic_functions.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "core_functions/aggregate/algebraic/covar.hpp"
-
-namespace duckdb {
-
-AggregateFunction CovarPopFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<CovarState, double, double, double, CovarPopOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-AggregateFunction CovarSampFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<CovarState, double, double, double, CovarSampOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/algebraic/stddev.cpp b/src/duckdb/extension/core_functions/aggregate/algebraic/stddev.cpp
deleted file mode 100644
index e9d14ee25..000000000
--- a/src/duckdb/extension/core_functions/aggregate/algebraic/stddev.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "core_functions/aggregate/algebraic_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "core_functions/aggregate/algebraic/stddev.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-AggregateFunction StdDevSampFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevSampOperation>(LogicalType::DOUBLE,
-	                                                                                           LogicalType::DOUBLE);
-}
-
-AggregateFunction StdDevPopFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevPopOperation>(LogicalType::DOUBLE,
-	                                                                                          LogicalType::DOUBLE);
-}
-
-AggregateFunction VarPopFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<StddevState, double, double, VarPopOperation>(LogicalType::DOUBLE,
-	                                                                                       LogicalType::DOUBLE);
-}
-
-AggregateFunction VarSampFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<StddevState, double, double, VarSampOperation>(LogicalType::DOUBLE,
-	                                                                                        LogicalType::DOUBLE);
-}
-
-AggregateFunction StandardErrorOfTheMeanFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<StddevState, double, double, StandardErrorOfTheMeanOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/approx_count.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/approx_count.cpp
deleted file mode 100644
index 37f05b208..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/approx_count.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/types/hyperloglog.hpp"
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "hyperloglog.hpp"
-
-namespace duckdb {
-
-// Algorithms from
-// "New cardinality estimation algorithms for HyperLogLog sketches"
-// Otmar Ertl, arXiv:1702.01284
-struct ApproxDistinctCountState {
-	HyperLogLog hll;
-};
-
-struct ApproxCountDistinctFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		new (&state) STATE();
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.hll.Merge(source.hll);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		target = UnsafeNumericCast<T>(state.hll.Count());
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
-                                                    data_ptr_t state, idx_t count) {
-	D_ASSERT(input_count == 1);
-	auto &input = inputs[0];
-
-	if (count > STANDARD_VECTOR_SIZE) {
-		throw InternalException("ApproxCountDistinct - count must be at most vector size");
-	}
-	Vector hash_vec(LogicalType::HASH, count);
-	VectorOperations::Hash(input, hash_vec, count);
-
-	auto agg_state = reinterpret_cast<ApproxDistinctCountState *>(state);
-	agg_state->hll.Update(input, hash_vec, count);
-}
-
-static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
-                                              Vector &state_vector, idx_t count) {
-	D_ASSERT(input_count == 1);
-	auto &input = inputs[0];
-	UnifiedVectorFormat idata;
-	input.ToUnifiedFormat(count, idata);
-
-	if (count > STANDARD_VECTOR_SIZE) {
-		throw InternalException("ApproxCountDistinct - count must be at most vector size");
-	}
-	Vector hash_vec(LogicalType::HASH, count);
-	VectorOperations::Hash(input, hash_vec, count);
-
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-	const auto states = UnifiedVectorFormat::GetDataNoConst<ApproxDistinctCountState *>(sdata);
-
-	UnifiedVectorFormat hdata;
-	hash_vec.ToUnifiedFormat(count, hdata);
-	const auto *hashes = UnifiedVectorFormat::GetData<hash_t>(hdata);
-	for (idx_t i = 0; i < count; i++) {
-		if (idata.validity.RowIsValid(idata.sel->get_index(i))) {
-			auto agg_state = states[sdata.sel->get_index(i)];
-			const auto hash = hashes[hdata.sel->get_index(i)];
-			agg_state->hll.InsertElement(hash);
-		}
-	}
-}
-
-AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) {
-	auto fun = AggregateFunction(
-	    {input_type}, LogicalTypeId::BIGINT, AggregateFunction::StateSize<ApproxDistinctCountState>,
-	    AggregateFunction::StateInitialize<ApproxDistinctCountState, ApproxCountDistinctFunction>,
-	    ApproxCountDistinctUpdateFunction,
-	    AggregateFunction::StateCombine<ApproxDistinctCountState, ApproxCountDistinctFunction>,
-	    AggregateFunction::StateFinalize<ApproxDistinctCountState, int64_t, ApproxCountDistinctFunction>,
-	    ApproxCountDistinctSimpleUpdateFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-AggregateFunction ApproxCountDistinctFun::GetFunction() {
-	return GetApproxCountDistinctFunction(LogicalType::ANY);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/arg_min_max.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/arg_min_max.cpp
deleted file mode 100644
index 63c112b3c..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/arg_min_max.cpp
+++ /dev/null
@@ -1,742 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/function/aggregate/minmax_n_helpers.hpp"
-
-namespace duckdb {
-
-struct ArgMinMaxStateBase {
-	ArgMinMaxStateBase() : is_initialized(false), arg_null(false) {
-	}
-
-	template <class T>
-	static inline void CreateValue(T &value) {
-	}
-
-	template <class T>
-	static inline void DestroyValue(T &value) {
-	}
-
-	template <class T>
-	static inline void AssignValue(T &target, T new_value) {
-		target = new_value;
-	}
-
-	template <typename T>
-	static inline void ReadValue(Vector &result, T &arg, T &target) {
-		target = arg;
-	}
-
-	bool is_initialized;
-	bool arg_null;
-};
-
-// Out-of-line specialisations
-template <>
-void ArgMinMaxStateBase::CreateValue(string_t &value) {
-	value = string_t(uint32_t(0));
-}
-
-template <>
-void ArgMinMaxStateBase::DestroyValue(string_t &value) {
-	if (!value.IsInlined()) {
-		delete[] value.GetData();
-	}
-}
-
-template <>
-void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value) {
-	DestroyValue(target);
-	if (new_value.IsInlined()) {
-		target = new_value;
-	} else {
-		// non-inlined string, need to allocate space for it
-		auto len = new_value.GetSize();
-		auto ptr = new char[len];
-		memcpy(ptr, new_value.GetData(), len);
-
-		target = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
-	}
-}
-
-template <>
-void ArgMinMaxStateBase::ReadValue(Vector &result, string_t &arg, string_t &target) {
-	target = StringVector::AddStringOrBlob(result, arg);
-}
-
-template <class A, class B>
-struct ArgMinMaxState : public ArgMinMaxStateBase {
-	using ARG_TYPE = A;
-	using BY_TYPE = B;
-
-	ARG_TYPE arg;
-	BY_TYPE value;
-
-	ArgMinMaxState() {
-		CreateValue(arg);
-		CreateValue(value);
-	}
-
-	~ArgMinMaxState() {
-		if (is_initialized) {
-			DestroyValue(arg);
-			DestroyValue(value);
-			is_initialized = false;
-		}
-	}
-};
-
-template <class COMPARATOR, bool IGNORE_NULL>
-struct ArgMinMaxBase {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		new (&state) STATE;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.~STATE();
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Assign(STATE &state, const A_TYPE &x, const B_TYPE &y, const bool x_null) {
-		if (IGNORE_NULL) {
-			STATE::template AssignValue<A_TYPE>(state.arg, x);
-			STATE::template AssignValue<B_TYPE>(state.value, y);
-		} else {
-			state.arg_null = x_null;
-			if (!state.arg_null) {
-				STATE::template AssignValue<A_TYPE>(state.arg, x);
-			}
-			STATE::template AssignValue<B_TYPE>(state.value, y);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &binary) {
-		if (!state.is_initialized) {
-			if (IGNORE_NULL || binary.right_mask.RowIsValid(binary.ridx)) {
-				Assign(state, x, y, !binary.left_mask.RowIsValid(binary.lidx));
-				state.is_initialized = true;
-			}
-		} else {
-			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x, y, binary);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Execute(STATE &state, A_TYPE x_data, B_TYPE y_data, AggregateBinaryInput &binary) {
-		if ((IGNORE_NULL || binary.right_mask.RowIsValid(binary.ridx)) && COMPARATOR::Operation(y_data, state.value)) {
-			Assign(state, x_data, y_data, !binary.left_mask.RowIsValid(binary.lidx));
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.is_initialized) {
-			return;
-		}
-		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
-			Assign(target, source.arg, source.value, source.arg_null);
-			target.is_initialized = true;
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_initialized || state.arg_null) {
-			finalize_data.ReturnNull();
-		} else {
-			STATE::template ReadValue<T>(finalize_data.result, state.arg, target);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return IGNORE_NULL;
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		if (arguments[1]->return_type.InternalType() == PhysicalType::VARCHAR) {
-			ExpressionBinder::PushCollation(context, arguments[1], arguments[1]->return_type);
-		}
-		function.arguments[0] = arguments[0]->return_type;
-		function.return_type = arguments[0]->return_type;
-		return nullptr;
-	}
-};
-
-struct SpecializedGenericArgMinMaxState {
-	static bool CreateExtraState(idx_t count) {
-		// nop extra state
-		return false;
-	}
-
-	static void PrepareData(Vector &by, idx_t count, bool &, UnifiedVectorFormat &result) {
-		by.ToUnifiedFormat(count, result);
-	}
-};
-
-template <OrderType ORDER_TYPE>
-struct GenericArgMinMaxState {
-	static Vector CreateExtraState(idx_t count) {
-		return Vector(LogicalType::BLOB, count);
-	}
-
-	static void PrepareData(Vector &by, idx_t count, Vector &extra_state, UnifiedVectorFormat &result) {
-		OrderModifiers modifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST);
-		CreateSortKeyHelpers::CreateSortKeyWithValidity(by, extra_state, modifiers, count);
-		extra_state.ToUnifiedFormat(count, result);
-	}
-};
-
-template <typename COMPARATOR, bool IGNORE_NULL, OrderType ORDER_TYPE,
-          class UPDATE_TYPE = SpecializedGenericArgMinMaxState>
-struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
-	template <class STATE>
-	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
-		auto &arg = inputs[0];
-		UnifiedVectorFormat adata;
-		arg.ToUnifiedFormat(count, adata);
-
-		using ARG_TYPE = typename STATE::ARG_TYPE;
-		using BY_TYPE = typename STATE::BY_TYPE;
-		auto &by = inputs[1];
-		UnifiedVectorFormat bdata;
-		auto extra_state = UPDATE_TYPE::CreateExtraState(count);
-		UPDATE_TYPE::PrepareData(by, count, extra_state, bdata);
-		const auto bys = UnifiedVectorFormat::GetData<BY_TYPE>(bdata);
-
-		UnifiedVectorFormat sdata;
-		state_vector.ToUnifiedFormat(count, sdata);
-
-		STATE *last_state = nullptr;
-		sel_t assign_sel[STANDARD_VECTOR_SIZE];
-		idx_t assign_count = 0;
-
-		auto states = UnifiedVectorFormat::GetData<STATE *>(sdata);
-		for (idx_t i = 0; i < count; i++) {
-			const auto bidx = bdata.sel->get_index(i);
-			if (!bdata.validity.RowIsValid(bidx)) {
-				continue;
-			}
-			const auto bval = bys[bidx];
-
-			const auto aidx = adata.sel->get_index(i);
-			const auto arg_null = !adata.validity.RowIsValid(aidx);
-			if (IGNORE_NULL && arg_null) {
-				continue;
-			}
-
-			const auto sidx = sdata.sel->get_index(i);
-			auto &state = *states[sidx];
-			if (!state.is_initialized || COMPARATOR::template Operation<BY_TYPE>(bval, state.value)) {
-				STATE::template AssignValue<BY_TYPE>(state.value, bval);
-				state.arg_null = arg_null;
-				// micro-adaptivity: it is common we overwrite the same state repeatedly
-				// e.g. when running arg_max(val, ts) and ts is sorted in ascending order
-				// this check essentially says:
-				// "if we are overriding the same state as the last row, the last write was pointless"
-				// hence we skip the last write altogether
-				if (!arg_null) {
-					if (&state == last_state) {
-						assign_count--;
-					}
-					assign_sel[assign_count++] = UnsafeNumericCast<sel_t>(i);
-					last_state = &state;
-				}
-				state.is_initialized = true;
-			}
-		}
-		if (assign_count == 0) {
-			// no need to assign anything: nothing left to do
-			return;
-		}
-		Vector sort_key(LogicalType::BLOB);
-		auto modifiers = OrderModifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST);
-		// slice with a selection vector and generate sort keys
-		SelectionVector sel(assign_sel);
-		Vector sliced_input(arg, sel, assign_count);
-		CreateSortKeyHelpers::CreateSortKey(sliced_input, assign_count, modifiers, sort_key);
-		auto sort_key_data = FlatVector::GetData<string_t>(sort_key);
-
-		// now assign sort keys
-		for (idx_t i = 0; i < assign_count; i++) {
-			const auto sidx = sdata.sel->get_index(sel.get_index(i));
-			auto &state = *states[sidx];
-			STATE::template AssignValue<ARG_TYPE>(state.arg, sort_key_data[i]);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.is_initialized) {
-			return;
-		}
-		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
-			STATE::template AssignValue<typename STATE::BY_TYPE>(target.value, source.value);
-			target.arg_null = source.arg_null;
-			if (!target.arg_null) {
-				STATE::template AssignValue<typename STATE::ARG_TYPE>(target.arg, source.arg);
-			}
-			target.is_initialized = true;
-		}
-	}
-
-	template <class STATE>
-	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (!state.is_initialized || state.arg_null) {
-			finalize_data.ReturnNull();
-		} else {
-			CreateSortKeyHelpers::DecodeSortKey(state.arg, finalize_data.result, finalize_data.result_idx,
-			                                    OrderModifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST));
-		}
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		if (arguments[1]->return_type.InternalType() == PhysicalType::VARCHAR) {
-			ExpressionBinder::PushCollation(context, arguments[1], arguments[1]->return_type);
-		}
-		function.arguments[0] = arguments[0]->return_type;
-		function.return_type = arguments[0]->return_type;
-		return nullptr;
-	}
-};
-
-template <class OP>
-AggregateFunction GetGenericArgMinMaxFunction() {
-	using STATE = ArgMinMaxState<string_t, string_t>;
-	return AggregateFunction(
-	    {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, AggregateFunction::StateSize<STATE>,
-	    AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>, OP::template Update<STATE>,
-	    AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind,
-	    AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <class OP, class ARG_TYPE, class BY_TYPE>
-AggregateFunction GetVectorArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
-#ifndef DUCKDB_SMALLER_BINARY
-	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
-	return AggregateFunction({type, by_type}, type, AggregateFunction::StateSize<STATE>,
-	                         AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
-	                         OP::template Update<STATE>, AggregateFunction::StateCombine<STATE, OP>,
-	                         AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind,
-	                         AggregateFunction::StateDestroy<STATE, OP>);
-#else
-	auto function = GetGenericArgMinMaxFunction<OP>();
-	function.arguments = {type, by_type};
-	function.return_type = type;
-	return function;
-#endif
-}
-
-#ifndef DUCKDB_SMALLER_BINARY
-template <class OP, class ARG_TYPE>
-AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const LogicalType &type) {
-	switch (by_type.InternalType()) {
-	case PhysicalType::INT32:
-		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, int32_t>(by_type, type);
-	case PhysicalType::INT64:
-		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, int64_t>(by_type, type);
-	case PhysicalType::INT128:
-		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, hugeint_t>(by_type, type);
-	case PhysicalType::DOUBLE:
-		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, double>(by_type, type);
-	case PhysicalType::VARCHAR:
-		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, string_t>(by_type, type);
-	default:
-		throw InternalException("Unimplemented arg_min/arg_max aggregate");
-	}
-}
-#endif
-
-static const vector<LogicalType> ArgMaxByTypes() {
-	vector<LogicalType> types = {LogicalType::INTEGER,   LogicalType::BIGINT,       LogicalType::HUGEINT,
-	                             LogicalType::DOUBLE,    LogicalType::VARCHAR,      LogicalType::DATE,
-	                             LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, LogicalType::BLOB};
-	return types;
-}
-
-template <class OP, class ARG_TYPE>
-void AddVectorArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
-	auto by_types = ArgMaxByTypes();
-	for (const auto &by_type : by_types) {
-#ifndef DUCKDB_SMALLER_BINARY
-		fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(by_type, type));
-#else
-		fun.AddFunction(GetVectorArgMinMaxFunctionInternal<OP, string_t, string_t>(by_type, type));
-#endif
-	}
-}
-
-template <class OP, class ARG_TYPE, class BY_TYPE>
-AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
-#ifndef DUCKDB_SMALLER_BINARY
-	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
-	auto function =
-	    AggregateFunction::BinaryAggregate<STATE, ARG_TYPE, BY_TYPE, ARG_TYPE, OP, AggregateDestructorType::LEGACY>(
-	        type, by_type, type);
-	if (type.InternalType() == PhysicalType::VARCHAR || by_type.InternalType() == PhysicalType::VARCHAR) {
-		function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-	}
-	function.bind = OP::Bind;
-#else
-	auto function = GetGenericArgMinMaxFunction<OP>();
-	function.arguments = {type, by_type};
-	function.return_type = type;
-#endif
-	return function;
-}
-
-#ifndef DUCKDB_SMALLER_BINARY
-template <class OP, class ARG_TYPE>
-AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const LogicalType &type) {
-	switch (by_type.InternalType()) {
-	case PhysicalType::INT32:
-		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, int32_t>(by_type, type);
-	case PhysicalType::INT64:
-		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, int64_t>(by_type, type);
-	case PhysicalType::INT128:
-		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, hugeint_t>(by_type, type);
-	case PhysicalType::DOUBLE:
-		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, double>(by_type, type);
-	case PhysicalType::VARCHAR:
-		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, string_t>(by_type, type);
-	default:
-		throw InternalException("Unimplemented arg_min/arg_max by aggregate");
-	}
-}
-#endif
-
-template <class OP, class ARG_TYPE>
-void AddArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
-	auto by_types = ArgMaxByTypes();
-	for (const auto &by_type : by_types) {
-#ifndef DUCKDB_SMALLER_BINARY
-		fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(by_type, type));
-#else
-		fun.AddFunction(GetArgMinMaxFunctionInternal<OP, string_t, string_t>(by_type, type));
-#endif
-	}
-}
-
-template <class OP>
-static AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type, const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-#ifndef DUCKDB_SMALLER_BINARY
-	switch (type.InternalType()) {
-	case PhysicalType::INT16:
-		return GetArgMinMaxFunctionBy<OP, int16_t>(by_type, type);
-	case PhysicalType::INT32:
-		return GetArgMinMaxFunctionBy<OP, int32_t>(by_type, type);
-	case PhysicalType::INT64:
-		return GetArgMinMaxFunctionBy<OP, int64_t>(by_type, type);
-	default:
-		return GetArgMinMaxFunctionBy<OP, hugeint_t>(by_type, type);
-	}
-#else
-	return GetArgMinMaxFunctionInternal<OP, string_t, string_t>(by_type, type);
-#endif
-}
-
-template <class OP>
-static unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, AggregateFunction &function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	auto by_type = arguments[1]->return_type;
-
-	// To avoid a combinatorial explosion, cast the ordering argument to one from the list
-	auto by_types = ArgMaxByTypes();
-	idx_t best_target = DConstants::INVALID_INDEX;
-	int64_t lowest_cost = NumericLimits<int64_t>::Maximum();
-	for (idx_t i = 0; i < by_types.size(); ++i) {
-		// Before falling back to casting, check for a physical type match for the by_type
-		if (by_types[i].InternalType() == by_type.InternalType()) {
-			lowest_cost = 0;
-			best_target = DConstants::INVALID_INDEX;
-			break;
-		}
-
-		auto cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(by_type, by_types[i]);
-		if (cast_cost < 0) {
-			continue;
-		}
-		if (cast_cost < lowest_cost) {
-			best_target = i;
-		}
-	}
-
-	if (best_target != DConstants::INVALID_INDEX) {
-		by_type = by_types[best_target];
-	}
-
-	auto name = std::move(function.name);
-	function = GetDecimalArgMinMaxFunction<OP>(by_type, decimal_type);
-	function.name = std::move(name);
-	function.return_type = decimal_type;
-	return nullptr;
-}
-
-template <class OP>
-void AddDecimalArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &by_type) {
-	fun.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, by_type}, LogicalTypeId::DECIMAL, nullptr, nullptr,
-	                                  nullptr, nullptr, nullptr, nullptr, BindDecimalArgMinMax<OP>));
-}
-
-template <class OP>
-void AddGenericArgMinMaxFunction(AggregateFunctionSet &fun) {
-	fun.AddFunction(GetGenericArgMinMaxFunction<OP>());
-}
-
-template <class COMPARATOR, bool IGNORE_NULL, OrderType ORDER_TYPE>
-static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
-	using GENERIC_VECTOR_OP = VectorArgMinMaxBase<LessThan, IGNORE_NULL, ORDER_TYPE, GenericArgMinMaxState<ORDER_TYPE>>;
-#ifndef DUCKDB_SMALLER_BINARY
-	using OP = ArgMinMaxBase<COMPARATOR, IGNORE_NULL>;
-	using VECTOR_OP = VectorArgMinMaxBase<COMPARATOR, IGNORE_NULL, ORDER_TYPE>;
-#else
-	using OP = GENERIC_VECTOR_OP;
-	using VECTOR_OP = GENERIC_VECTOR_OP;
-#endif
-	AddArgMinMaxFunctionBy<OP, int32_t>(fun, LogicalType::INTEGER);
-	AddArgMinMaxFunctionBy<OP, int64_t>(fun, LogicalType::BIGINT);
-	AddArgMinMaxFunctionBy<OP, double>(fun, LogicalType::DOUBLE);
-	AddArgMinMaxFunctionBy<OP, string_t>(fun, LogicalType::VARCHAR);
-	AddArgMinMaxFunctionBy<OP, date_t>(fun, LogicalType::DATE);
-	AddArgMinMaxFunctionBy<OP, timestamp_t>(fun, LogicalType::TIMESTAMP);
-	AddArgMinMaxFunctionBy<OP, timestamp_t>(fun, LogicalType::TIMESTAMP_TZ);
-	AddArgMinMaxFunctionBy<OP, string_t>(fun, LogicalType::BLOB);
-
-	auto by_types = ArgMaxByTypes();
-	for (const auto &by_type : by_types) {
-		AddDecimalArgMinMaxFunctionBy<OP>(fun, by_type);
-	}
-
-	AddVectorArgMinMaxFunctionBy<VECTOR_OP, string_t>(fun, LogicalType::ANY);
-
-	// we always use LessThan when using sort keys because the ORDER_TYPE takes care of selecting the lowest or highest
-	AddGenericArgMinMaxFunction<GENERIC_VECTOR_OP>(fun);
-}
-
-//------------------------------------------------------------------------------
-// ArgMinMax(N) Function
-//------------------------------------------------------------------------------
-//------------------------------------------------------------------------------
-// State
-//------------------------------------------------------------------------------
-
-template <class A, class B, class COMPARATOR>
-class ArgMinMaxNState {
-public:
-	using VAL_TYPE = A;
-	using ARG_TYPE = B;
-
-	using V = typename VAL_TYPE::TYPE;
-	using K = typename ARG_TYPE::TYPE;
-
-	BinaryAggregateHeap<K, V, COMPARATOR> heap;
-
-	bool is_initialized = false;
-	void Initialize(idx_t nval) {
-		heap.Initialize(nval);
-		is_initialized = true;
-	}
-};
-
-//------------------------------------------------------------------------------
-// Operation
-//------------------------------------------------------------------------------
-template <class STATE>
-static void ArgMinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
-                             idx_t count) {
-
-	auto &val_vector = inputs[0];
-	auto &arg_vector = inputs[1];
-	auto &n_vector = inputs[2];
-
-	UnifiedVectorFormat val_format;
-	UnifiedVectorFormat arg_format;
-	UnifiedVectorFormat n_format;
-	UnifiedVectorFormat state_format;
-
-	auto val_extra_state = STATE::VAL_TYPE::CreateExtraState(val_vector, count);
-	auto arg_extra_state = STATE::ARG_TYPE::CreateExtraState(arg_vector, count);
-
-	STATE::VAL_TYPE::PrepareData(val_vector, count, val_extra_state, val_format);
-	STATE::ARG_TYPE::PrepareData(arg_vector, count, arg_extra_state, arg_format);
-
-	n_vector.ToUnifiedFormat(count, n_format);
-	state_vector.ToUnifiedFormat(count, state_format);
-
-	auto states = UnifiedVectorFormat::GetData<STATE *>(state_format);
-
-	for (idx_t i = 0; i < count; i++) {
-		const auto arg_idx = arg_format.sel->get_index(i);
-		const auto val_idx = val_format.sel->get_index(i);
-		if (!arg_format.validity.RowIsValid(arg_idx) || !val_format.validity.RowIsValid(val_idx)) {
-			continue;
-		}
-		const auto state_idx = state_format.sel->get_index(i);
-		auto &state = *states[state_idx];
-
-		// Initialize the heap if necessary and add the input to the heap
-		if (!state.is_initialized) {
-			static constexpr int64_t MAX_N = 1000000;
-			const auto nidx = n_format.sel->get_index(i);
-			if (!n_format.validity.RowIsValid(nidx)) {
-				throw InvalidInputException("Invalid input for arg_min/arg_max: n value cannot be NULL");
-			}
-			const auto nval = UnifiedVectorFormat::GetData<int64_t>(n_format)[nidx];
-			if (nval <= 0) {
-				throw InvalidInputException("Invalid input for arg_min/arg_max: n value must be > 0");
-			}
-			if (nval >= MAX_N) {
-				throw InvalidInputException("Invalid input for arg_min/arg_max: n value must be < %d", MAX_N);
-			}
-			state.Initialize(UnsafeNumericCast<idx_t>(nval));
-		}
-
-		// Now add the input to the heap
-		auto arg_val = STATE::ARG_TYPE::Create(arg_format, arg_idx);
-		auto val_val = STATE::VAL_TYPE::Create(val_format, val_idx);
-
-		state.heap.Insert(aggr_input.allocator, arg_val, val_val);
-	}
-}
-
-//------------------------------------------------------------------------------
-// Bind
-//------------------------------------------------------------------------------
-template <class VAL_TYPE, class ARG_TYPE, class COMPARATOR>
-static void SpecializeArgMinMaxNFunction(AggregateFunction &function) {
-	using STATE = ArgMinMaxNState<VAL_TYPE, ARG_TYPE, COMPARATOR>;
-	using OP = MinMaxNOperation;
-
-	function.state_size = AggregateFunction::StateSize<STATE>;
-	function.initialize = AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>;
-	function.combine = AggregateFunction::StateCombine<STATE, OP>;
-	function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-
-	function.finalize = MinMaxNOperation::Finalize<STATE>;
-	function.update = ArgMinMaxNUpdate<STATE>;
-}
-
-template <class VAL_TYPE, class COMPARATOR>
-static void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
-	switch (arg_type) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::VARCHAR:
-		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxStringValue, COMPARATOR>(function);
-		break;
-	case PhysicalType::INT32:
-		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFixedValue<int32_t>, COMPARATOR>(function);
-		break;
-	case PhysicalType::INT64:
-		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFixedValue<int64_t>, COMPARATOR>(function);
-		break;
-	case PhysicalType::FLOAT:
-		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFixedValue<float>, COMPARATOR>(function);
-		break;
-	case PhysicalType::DOUBLE:
-		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFixedValue<double>, COMPARATOR>(function);
-		break;
-#endif
-	default:
-		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFallbackValue, COMPARATOR>(function);
-		break;
-	}
-}
-
-template <class COMPARATOR>
-static void SpecializeArgMinMaxNFunction(PhysicalType val_type, PhysicalType arg_type, AggregateFunction &function) {
-	switch (val_type) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::VARCHAR:
-		SpecializeArgMinMaxNFunction<MinMaxStringValue, COMPARATOR>(arg_type, function);
-		break;
-	case PhysicalType::INT32:
-		SpecializeArgMinMaxNFunction<MinMaxFixedValue<int32_t>, COMPARATOR>(arg_type, function);
-		break;
-	case PhysicalType::INT64:
-		SpecializeArgMinMaxNFunction<MinMaxFixedValue<int64_t>, COMPARATOR>(arg_type, function);
-		break;
-	case PhysicalType::FLOAT:
-		SpecializeArgMinMaxNFunction<MinMaxFixedValue<float>, COMPARATOR>(arg_type, function);
-		break;
-	case PhysicalType::DOUBLE:
-		SpecializeArgMinMaxNFunction<MinMaxFixedValue<double>, COMPARATOR>(arg_type, function);
-		break;
-#endif
-	default:
-		SpecializeArgMinMaxNFunction<MinMaxFallbackValue, COMPARATOR>(arg_type, function);
-		break;
-	}
-}
-
-template <class COMPARATOR>
-unique_ptr<FunctionData> ArgMinMaxNBind(ClientContext &context, AggregateFunction &function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	for (auto &arg : arguments) {
-		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-	}
-
-	const auto val_type = arguments[0]->return_type.InternalType();
-	const auto arg_type = arguments[1]->return_type.InternalType();
-
-	// Specialize the function based on the input types
-	SpecializeArgMinMaxNFunction<COMPARATOR>(val_type, arg_type, function);
-
-	function.return_type = LogicalType::LIST(arguments[0]->return_type);
-	return nullptr;
-}
-
-template <class COMPARATOR>
-static void AddArgMinMaxNFunction(AggregateFunctionSet &set) {
-	AggregateFunction function({LogicalTypeId::ANY, LogicalTypeId::ANY, LogicalType::BIGINT},
-	                           LogicalType::LIST(LogicalType::ANY), nullptr, nullptr, nullptr, nullptr, nullptr,
-	                           nullptr, ArgMinMaxNBind<COMPARATOR>);
-
-	return set.AddFunction(function);
-}
-
-//------------------------------------------------------------------------------
-// Function Registration
-//------------------------------------------------------------------------------
-
-AggregateFunctionSet ArgMinFun::GetFunctions() {
-	AggregateFunctionSet fun;
-	AddArgMinMaxFunctions<LessThan, true, OrderType::ASCENDING>(fun);
-	AddArgMinMaxNFunction<LessThan>(fun);
-	return fun;
-}
-
-AggregateFunctionSet ArgMaxFun::GetFunctions() {
-	AggregateFunctionSet fun;
-	AddArgMinMaxFunctions<GreaterThan, true, OrderType::DESCENDING>(fun);
-	AddArgMinMaxNFunction<GreaterThan>(fun);
-	return fun;
-}
-
-AggregateFunctionSet ArgMinNullFun::GetFunctions() {
-	AggregateFunctionSet fun;
-	AddArgMinMaxFunctions<LessThan, false, OrderType::ASCENDING>(fun);
-	return fun;
-}
-
-AggregateFunctionSet ArgMaxNullFun::GetFunctions() {
-	AggregateFunctionSet fun;
-	AddArgMinMaxFunctions<GreaterThan, false, OrderType::DESCENDING>(fun);
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/bitagg.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/bitagg.cpp
deleted file mode 100644
index 241d25692..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/bitagg.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/aggregate_executor.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct BitState {
-	using TYPE = T;
-	bool is_set;
-	T value;
-};
-
-template <class OP>
-static AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint8_t>, int8_t, int8_t, OP>(type, type);
-	case LogicalTypeId::SMALLINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint16_t>, int16_t, int16_t, OP>(type, type);
-	case LogicalTypeId::INTEGER:
-		return AggregateFunction::UnaryAggregate<BitState<uint32_t>, int32_t, int32_t, OP>(type, type);
-	case LogicalTypeId::BIGINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint64_t>, int64_t, int64_t, OP>(type, type);
-	case LogicalTypeId::HUGEINT:
-		return AggregateFunction::UnaryAggregate<BitState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type);
-	case LogicalTypeId::UTINYINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint8_t>, uint8_t, uint8_t, OP>(type, type);
-	case LogicalTypeId::USMALLINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint16_t>, uint16_t, uint16_t, OP>(type, type);
-	case LogicalTypeId::UINTEGER:
-		return AggregateFunction::UnaryAggregate<BitState<uint32_t>, uint32_t, uint32_t, OP>(type, type);
-	case LogicalTypeId::UBIGINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
-	case LogicalTypeId::UHUGEINT:
-		return AggregateFunction::UnaryAggregate<BitState<uhugeint_t>, uhugeint_t, uhugeint_t, OP>(type, type);
-	default:
-		throw InternalException("Unimplemented bitfield type for unary aggregate");
-	}
-}
-
-struct BitwiseOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		//  If there are no matching rows, returns a null value.
-		state.is_set = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
-		if (!state.is_set) {
-			OP::template Assign<INPUT_TYPE>(state, input);
-			state.is_set = true;
-		} else {
-			OP::template Execute<INPUT_TYPE>(state, input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		OP::template Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE &state, INPUT_TYPE input) {
-		state.value = typename STATE::TYPE(input);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.is_set) {
-			// source is NULL, nothing to do.
-			return;
-		}
-		if (!target.is_set) {
-			// target is NULL, use source value directly.
-			OP::template Assign<typename STATE::TYPE>(target, source.value);
-			target.is_set = true;
-		} else {
-			OP::template Execute<typename STATE::TYPE>(target, source.value);
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_set) {
-			finalize_data.ReturnNull();
-		} else {
-			target = T(state.value);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct BitAndOperation : public BitwiseOperation {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input) {
-		state.value &= typename STATE::TYPE(input);
-		;
-	}
-};
-
-struct BitOrOperation : public BitwiseOperation {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input) {
-		state.value |= typename STATE::TYPE(input);
-		;
-	}
-};
-
-struct BitXorOperation : public BitwiseOperation {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input) {
-		state.value ^= typename STATE::TYPE(input);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-};
-
-struct BitStringBitwiseOperation : public BitwiseOperation {
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.is_set && !state.value.IsInlined()) {
-			delete[] state.value.GetData();
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE &state, INPUT_TYPE input) {
-		D_ASSERT(state.is_set == false);
-		if (input.IsInlined()) {
-			state.value = input;
-		} else { // non-inlined string, need to allocate space for it
-			auto len = input.GetSize();
-			auto ptr = new char[len];
-			memcpy(ptr, input.GetData(), len);
-
-			state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_set) {
-			finalize_data.ReturnNull();
-		} else {
-			target = finalize_data.ReturnString(state.value);
-		}
-	}
-};
-
-struct BitStringAndOperation : public BitStringBitwiseOperation {
-
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input) {
-		Bit::BitwiseAnd(input, state.value, state.value);
-	}
-};
-
-struct BitStringOrOperation : public BitStringBitwiseOperation {
-
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input) {
-		Bit::BitwiseOr(input, state.value, state.value);
-	}
-};
-
-struct BitStringXorOperation : public BitStringBitwiseOperation {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input) {
-		Bit::BitwiseXor(input, state.value, state.value);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-};
-
-AggregateFunctionSet BitAndFun::GetFunctions() {
-	AggregateFunctionSet bit_and;
-	for (auto &type : LogicalType::Integral()) {
-		bit_and.AddFunction(GetBitfieldUnaryAggregate<BitAndOperation>(type));
-	}
-
-	bit_and.AddFunction(
-	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringAndOperation>(
-	        LogicalType::BIT, LogicalType::BIT));
-	return bit_and;
-}
-
-AggregateFunctionSet BitOrFun::GetFunctions() {
-	AggregateFunctionSet bit_or;
-	for (auto &type : LogicalType::Integral()) {
-		bit_or.AddFunction(GetBitfieldUnaryAggregate<BitOrOperation>(type));
-	}
-	bit_or.AddFunction(
-	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringOrOperation>(
-	        LogicalType::BIT, LogicalType::BIT));
-	return bit_or;
-}
-
-AggregateFunctionSet BitXorFun::GetFunctions() {
-	AggregateFunctionSet bit_xor;
-	for (auto &type : LogicalType::Integral()) {
-		bit_xor.AddFunction(GetBitfieldUnaryAggregate<BitXorOperation>(type));
-	}
-	bit_xor.AddFunction(
-	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringXorOperation>(
-	        LogicalType::BIT, LogicalType::BIT));
-	return bit_xor;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/bitstring_agg.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/bitstring_agg.cpp
deleted file mode 100644
index c9e399835..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/bitstring_agg.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/aggregate_executor.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-
-template <class INPUT_TYPE>
-struct BitAggState {
-	bool is_set;
-	string_t value;
-	INPUT_TYPE min;
-	INPUT_TYPE max;
-};
-
-struct BitstringAggBindData : public FunctionData {
-	Value min;
-	Value max;
-
-	BitstringAggBindData() {
-	}
-
-	BitstringAggBindData(Value min, Value max) : min(std::move(min)), max(std::move(max)) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<BitstringAggBindData>(*this);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<BitstringAggBindData>();
-		if (min.IsNull() && other.min.IsNull() && max.IsNull() && other.max.IsNull()) {
-			return true;
-		}
-		if (Value::NotDistinctFrom(min, other.min) && Value::NotDistinctFrom(max, other.max)) {
-			return true;
-		}
-		return false;
-	}
-
-	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                      const AggregateFunction &) {
-		auto &bind_data = bind_data_p->Cast<BitstringAggBindData>();
-		serializer.WriteProperty(100, "min", bind_data.min);
-		serializer.WriteProperty(101, "max", bind_data.max);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &) {
-		Value min;
-		Value max;
-		deserializer.ReadProperty(100, "min", min);
-		deserializer.ReadProperty(101, "max", max);
-		return make_uniq<BitstringAggBindData>(min, max);
-	}
-};
-
-struct BitStringAggOperation {
-	static constexpr const idx_t MAX_BIT_RANGE = 1000000000; // for now capped at 1 billion bits
-
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.is_set = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		auto &bind_agg_data = unary_input.input.bind_data->template Cast<BitstringAggBindData>();
-		if (!state.is_set) {
-			if (bind_agg_data.min.IsNull() || bind_agg_data.max.IsNull()) {
-				throw BinderException(
-				    "Could not retrieve required statistics. Alternatively, try by providing the statistics "
-				    "explicitly: BITSTRING_AGG(col, min, max) ");
-			}
-			state.min = bind_agg_data.min.GetValue<INPUT_TYPE>();
-			state.max = bind_agg_data.max.GetValue<INPUT_TYPE>();
-			if (state.min > state.max) {
-				throw InvalidInputException("Invalid explicit bitstring range: Minimum (%s) > maximum (%s)",
-				                            NumericHelper::ToString(state.min), NumericHelper::ToString(state.max));
-			}
-			idx_t bit_range =
-			    GetRange(bind_agg_data.min.GetValue<INPUT_TYPE>(), bind_agg_data.max.GetValue<INPUT_TYPE>());
-			if (bit_range > MAX_BIT_RANGE) {
-				throw OutOfRangeException(
-				    "The range between min and max value (%s <-> %s) is too large for bitstring aggregation",
-				    NumericHelper::ToString(state.min), NumericHelper::ToString(state.max));
-			}
-			idx_t len = Bit::ComputeBitstringLen(bit_range);
-			auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], UnsafeNumericCast<uint32_t>(len))
-			                                            : string_t(UnsafeNumericCast<uint32_t>(len));
-			Bit::SetEmptyBitString(target, bit_range);
-
-			state.value = target;
-			state.is_set = true;
-		}
-		if (input >= state.min && input <= state.max) {
-			Execute(state, input, bind_agg_data.min.GetValue<INPUT_TYPE>());
-		} else {
-			throw OutOfRangeException("Value %s is outside of provided min and max range (%s <-> %s)",
-			                          NumericHelper::ToString(input), NumericHelper::ToString(state.min),
-			                          NumericHelper::ToString(state.max));
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		OP::template Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-	}
-
-	template <class INPUT_TYPE>
-	static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) {
-		if (min > max) {
-			throw InvalidInputException("Invalid explicit bitstring range: Minimum (%d) > maximum (%d)", min, max);
-		}
-		INPUT_TYPE result;
-		if (!TrySubtractOperator::Operation(max, min, result)) {
-			return NumericLimits<idx_t>::Maximum();
-		}
-		auto val = NumericCast<idx_t>(result);
-		if (val == NumericLimits<idx_t>::Maximum()) {
-			return val;
-		}
-		return val + 1;
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input, INPUT_TYPE min) {
-		Bit::SetBit(state.value, UnsafeNumericCast<idx_t>(input - min), 1);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.is_set) {
-			return;
-		}
-		if (!target.is_set) {
-			Assign(target, source.value);
-			target.is_set = true;
-			target.min = source.min;
-			target.max = source.max;
-		} else {
-			Bit::BitwiseOr(source.value, target.value, target.value);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE &state, INPUT_TYPE input) {
-		D_ASSERT(state.is_set == false);
-		if (input.IsInlined()) {
-			state.value = input;
-		} else { // non-inlined string, need to allocate space for it
-			auto len = input.GetSize();
-			auto ptr = new char[len];
-			memcpy(ptr, input.GetData(), len);
-			state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_set) {
-			finalize_data.ReturnNull();
-		} else {
-			target = StringVector::AddStringOrBlob(finalize_data.result, state.value);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.is_set && !state.value.IsInlined()) {
-			delete[] state.value.GetData();
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-template <>
-void BitStringAggOperation::Execute(BitAggState<hugeint_t> &state, hugeint_t input, hugeint_t min) {
-	idx_t val;
-	if (Hugeint::TryCast(input - min, val)) {
-		Bit::SetBit(state.value, val, 1);
-	} else {
-		throw OutOfRangeException("Range too large for bitstring aggregation");
-	}
-}
-
-template <>
-idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
-	hugeint_t result;
-	if (!TrySubtractOperator::Operation(max, min, result)) {
-		return NumericLimits<idx_t>::Maximum();
-	}
-	idx_t range;
-	if (!Hugeint::TryCast(result + 1, range) || result == NumericLimits<hugeint_t>::Maximum()) {
-		return NumericLimits<idx_t>::Maximum();
-	}
-	return range;
-}
-
-template <>
-void BitStringAggOperation::Execute(BitAggState<uhugeint_t> &state, uhugeint_t input, uhugeint_t min) {
-	idx_t val;
-	if (Uhugeint::TryCast(input - min, val)) {
-		Bit::SetBit(state.value, val, 1);
-	} else {
-		throw OutOfRangeException("Range too large for bitstring aggregation");
-	}
-}
-
-template <>
-idx_t BitStringAggOperation::GetRange(uhugeint_t min, uhugeint_t max) {
-	uhugeint_t result;
-	if (!TrySubtractOperator::Operation(max, min, result)) {
-		return NumericLimits<idx_t>::Maximum();
-	}
-	idx_t range;
-	if (!Uhugeint::TryCast(result + 1, range) || result == NumericLimits<uhugeint_t>::Maximum()) {
-		return NumericLimits<idx_t>::Maximum();
-	}
-	return range;
-}
-
-unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                                   AggregateStatisticsInput &input) {
-
-	if (NumericStats::HasMinMax(input.child_stats[0])) {
-		auto &bind_agg_data = input.bind_data->Cast<BitstringAggBindData>();
-		bind_agg_data.min = NumericStats::Min(input.child_stats[0]);
-		bind_agg_data.max = NumericStats::Max(input.child_stats[0]);
-	}
-	return nullptr;
-}
-
-unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() == 3) {
-		if (!arguments[1]->IsFoldable() || !arguments[2]->IsFoldable()) {
-			throw BinderException("bitstring_agg requires a constant min and max argument");
-		}
-		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		auto max = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
-		Function::EraseArgument(function, arguments, 2);
-		Function::EraseArgument(function, arguments, 1);
-		return make_uniq<BitstringAggBindData>(min, max);
-	}
-	return make_uniq<BitstringAggBindData>();
-}
-
-template <class TYPE>
-static void BindBitString(AggregateFunctionSet &bitstring_agg, const LogicalTypeId &type) {
-	auto function =
-	    AggregateFunction::UnaryAggregateDestructor<BitAggState<TYPE>, TYPE, string_t, BitStringAggOperation>(
-	        type, LogicalType::BIT);
-	function.bind = BindBitstringAgg; // create new a 'BitstringAggBindData'
-	function.serialize = BitstringAggBindData::Serialize;
-	function.deserialize = BitstringAggBindData::Deserialize;
-	function.statistics = BitstringPropagateStats; // stores min and max from column stats in BitstringAggBindData
-	bitstring_agg.AddFunction(function); // uses the BitstringAggBindData to access statistics for creating bitstring
-	function.arguments = {type, type, type};
-	function.statistics = nullptr; // min and max are provided as arguments
-	bitstring_agg.AddFunction(function);
-}
-
-void GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstring_agg) {
-	switch (type.id()) {
-	case LogicalType::TINYINT: {
-		return BindBitString<int8_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::SMALLINT: {
-		return BindBitString<int16_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::INTEGER: {
-		return BindBitString<int32_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::BIGINT: {
-		return BindBitString<int64_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::HUGEINT: {
-		return BindBitString<hugeint_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::UTINYINT: {
-		return BindBitString<uint8_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::USMALLINT: {
-		return BindBitString<uint16_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::UINTEGER: {
-		return BindBitString<uint32_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::UBIGINT: {
-		return BindBitString<uint64_t>(bitstring_agg, type.id());
-	}
-	case LogicalType::UHUGEINT: {
-		return BindBitString<uhugeint_t>(bitstring_agg, type.id());
-	}
-	default:
-		throw InternalException("Unimplemented bitstring aggregate");
-	}
-}
-
-AggregateFunctionSet BitstringAggFun::GetFunctions() {
-	AggregateFunctionSet bitstring_agg("bitstring_agg");
-	for (auto &type : LogicalType::Integral()) {
-		GetBitStringAggregate(type, bitstring_agg);
-	}
-	return bitstring_agg;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/bool.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/bool.cpp
deleted file mode 100644
index 9b781f848..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/bool.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct BoolState {
-	bool empty;
-	bool val;
-};
-
-struct BoolAndFunFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.val = true;
-		state.empty = true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.val = target.val && source.val;
-		target.empty = target.empty && source.empty;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.empty) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		target = state.val;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		state.empty = false;
-		state.val = input && state.val;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct BoolOrFunFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.val = false;
-		state.empty = true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.val = target.val || source.val;
-		target.empty = target.empty && source.empty;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.empty) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		target = state.val;
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		state.empty = false;
-		state.val = input || state.val;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction BoolOrFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolOrFunFunction>(
-	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
-	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	fun.distinct_dependent = AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT;
-	return fun;
-}
-
-AggregateFunction BoolAndFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolAndFunFunction>(
-	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
-	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	fun.distinct_dependent = AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/kurtosis.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/kurtosis.cpp
deleted file mode 100644
index 4f9f6f30c..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/kurtosis.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-struct KurtosisState {
-	idx_t n;
-	double sum;
-	double sum_sqr;
-	double sum_cub;
-	double sum_four;
-};
-
-struct KurtosisFlagBiasCorrection {};
-
-struct KurtosisFlagNoBiasCorrection {};
-
-template <class KURTOSIS_FLAG>
-struct KurtosisOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.n = 0;
-		state.sum = state.sum_sqr = state.sum_cub = state.sum_four = 0.0;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		state.n++;
-		state.sum += input;
-		state.sum_sqr += pow(input, 2);
-		state.sum_cub += pow(input, 3);
-		state.sum_four += pow(input, 4);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (source.n == 0) {
-			return;
-		}
-		target.n += source.n;
-		target.sum += source.sum;
-		target.sum_sqr += source.sum_sqr;
-		target.sum_cub += source.sum_cub;
-		target.sum_four += source.sum_four;
-	}
-
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
-		auto n = (double)state.n;
-		if (n <= 1) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		if (std::is_same<KURTOSIS_FLAG, KurtosisFlagBiasCorrection>::value && n <= 3) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		double temp = 1 / n;
-		//! This is necessary due to linux 32 bits
-		long double temp_aux = 1 / n;
-		if (state.sum_sqr - state.sum * state.sum * temp == 0 ||
-		    state.sum_sqr - state.sum * state.sum * temp_aux == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		double m4 =
-		    temp * (state.sum_four - 4 * state.sum_cub * state.sum * temp +
-		            6 * state.sum_sqr * state.sum * state.sum * temp * temp - 3 * pow(state.sum, 4) * pow(temp, 3));
-
-		double m2 = temp * (state.sum_sqr - state.sum * state.sum * temp);
-		if (m2 <= 0) { // m2 shouldn't be below 0 but floating points are weird
-			finalize_data.ReturnNull();
-			return;
-		}
-		if (std::is_same<KURTOSIS_FLAG, KurtosisFlagNoBiasCorrection>::value) {
-			target = m4 / (m2 * m2) - 3;
-		} else {
-			target = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
-		}
-		if (!Value::DoubleIsFinite(target)) {
-			throw OutOfRangeException("Kurtosis is out of range!");
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction KurtosisFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<KurtosisState, double, double,
-	                                         KurtosisOperation<KurtosisFlagBiasCorrection>>(LogicalType::DOUBLE,
-	                                                                                        LogicalType::DOUBLE);
-}
-
-AggregateFunction KurtosisPopFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<KurtosisState, double, double,
-	                                         KurtosisOperation<KurtosisFlagNoBiasCorrection>>(LogicalType::DOUBLE,
-	                                                                                          LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/product.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/product.cpp
deleted file mode 100644
index 324893f60..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/product.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ProductState {
-	bool empty;
-	double val;
-};
-
-struct ProductFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.val = 1;
-		state.empty = true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.val *= source.val;
-		target.empty = target.empty && source.empty;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.empty) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		target = state.val;
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		if (state.empty) {
-			state.empty = false;
-		}
-		state.val *= input;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction ProductFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<ProductState, double, double, ProductFunction>(
-	    LogicalType(LogicalTypeId::DOUBLE), LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/skew.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/skew.cpp
deleted file mode 100644
index 12f237610..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/skew.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-struct SkewState {
-	size_t n;
-	double sum;
-	double sum_sqr;
-	double sum_cub;
-};
-
-struct SkewnessOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.n = 0;
-		state.sum = state.sum_sqr = state.sum_cub = 0;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		state.n++;
-		state.sum += input;
-		state.sum_sqr += pow(input, 2);
-		state.sum_cub += pow(input, 3);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (source.n == 0) {
-			return;
-		}
-
-		target.n += source.n;
-		target.sum += source.sum;
-		target.sum_sqr += source.sum_sqr;
-		target.sum_cub += source.sum_cub;
-	}
-
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
-		if (state.n <= 2) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		double n = state.n;
-		double temp = 1 / n;
-		auto p = std::pow(temp * (state.sum_sqr - state.sum * state.sum * temp), 3);
-		if (p < 0) {
-			p = 0; // Shouldn't be below 0 but floating points are weird
-		}
-		double div = std::sqrt(p);
-		if (div == 0) {
-			target = NAN;
-			return;
-		}
-		double temp1 = std::sqrt(n * (n - 1)) / (n - 2);
-		target = temp1 * temp *
-		         (state.sum_cub - 3 * state.sum_sqr * state.sum * temp + 2 * pow(state.sum, 3) * temp * temp) / div;
-		if (!Value::DoubleIsFinite(target)) {
-			throw OutOfRangeException("SKEW is out of range!");
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction SkewnessFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<SkewState, double, double, SkewnessOperation>(LogicalType::DOUBLE,
-	                                                                                       LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/string_agg.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/string_agg.cpp
deleted file mode 100644
index b694a2365..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/string_agg.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-struct StringAggState {
-	idx_t size;
-	idx_t alloc_size;
-	char *dataptr;
-};
-
-struct StringAggBindData : public FunctionData {
-	explicit StringAggBindData(string sep_p) : sep(std::move(sep_p)) {
-	}
-
-	string sep;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StringAggBindData>(sep);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<StringAggBindData>();
-		return sep == other.sep;
-	}
-};
-
-struct StringAggFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.dataptr = nullptr;
-		state.alloc_size = 0;
-		state.size = 0;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.dataptr) {
-			finalize_data.ReturnNull();
-		} else {
-			target = StringVector::AddString(finalize_data.result, state.dataptr, state.size);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.dataptr) {
-			delete[] state.dataptr;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	static inline void PerformOperation(StringAggState &state, const char *str, const char *sep, idx_t str_size,
-	                                    idx_t sep_size) {
-		if (!state.dataptr) {
-			// first iteration: allocate space for the string and copy it into the state
-			state.alloc_size = MaxValue<idx_t>(8, NextPowerOfTwo(str_size));
-			state.dataptr = new char[state.alloc_size];
-			state.size = str_size;
-			memcpy(state.dataptr, str, str_size);
-		} else {
-			// subsequent iteration: first check if we have space to place the string and separator
-			idx_t required_size = state.size + str_size + sep_size;
-			if (required_size > state.alloc_size) {
-				// no space! allocate extra space
-				while (state.alloc_size < required_size) {
-					state.alloc_size *= 2;
-				}
-				auto new_data = new char[state.alloc_size];
-				memcpy(new_data, state.dataptr, state.size);
-				delete[] state.dataptr;
-				state.dataptr = new_data;
-			}
-			// copy the separator
-			memcpy(state.dataptr + state.size, sep, sep_size);
-			state.size += sep_size;
-			// copy the string
-			memcpy(state.dataptr + state.size, str, str_size);
-			state.size += str_size;
-		}
-	}
-
-	static inline void PerformOperation(StringAggState &state, string_t str, optional_ptr<FunctionData> data_p) {
-		auto &data = data_p->Cast<StringAggBindData>();
-		PerformOperation(state, str.GetData(), data.sep.c_str(), str.GetSize(), data.sep.size());
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		PerformOperation(state, input, unary_input.input.bind_data);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		if (!source.dataptr) {
-			// source is not set: skip combining
-			return;
-		}
-		PerformOperation(target, string_t(source.dataptr, UnsafeNumericCast<uint32_t>(source.size)),
-		                 aggr_input_data.bind_data);
-	}
-};
-
-unique_ptr<FunctionData> StringAggBind(ClientContext &context, AggregateFunction &function,
-                                       vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() == 1) {
-		// single argument: default to comma
-		return make_uniq<StringAggBindData>(",");
-	}
-	D_ASSERT(arguments.size() == 2);
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("Separator argument to StringAgg must be a constant");
-	}
-	auto separator_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	string separator_string = ",";
-	if (separator_val.IsNull()) {
-		arguments[0] = make_uniq<BoundConstantExpression>(Value(LogicalType::VARCHAR));
-	} else {
-		separator_string = separator_val.ToString();
-	}
-	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_uniq<StringAggBindData>(std::move(separator_string));
-}
-
-static void StringAggSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                               const AggregateFunction &function) {
-	auto bind_data = bind_data_p->Cast<StringAggBindData>();
-	serializer.WriteProperty(100, "separator", bind_data.sep);
-}
-
-unique_ptr<FunctionData> StringAggDeserialize(Deserializer &deserializer, AggregateFunction &bound_function) {
-	auto sep = deserializer.ReadProperty<string>(100, "separator");
-	return make_uniq<StringAggBindData>(std::move(sep));
-}
-
-AggregateFunctionSet StringAggFun::GetFunctions() {
-	AggregateFunctionSet string_agg;
-	AggregateFunction string_agg_param(
-	    {LogicalType::ANY_PARAMS(LogicalType::VARCHAR)}, LogicalType::VARCHAR,
-	    AggregateFunction::StateSize<StringAggState>,
-	    AggregateFunction::StateInitialize<StringAggState, StringAggFunction>,
-	    AggregateFunction::UnaryScatterUpdate<StringAggState, string_t, StringAggFunction>,
-	    AggregateFunction::StateCombine<StringAggState, StringAggFunction>,
-	    AggregateFunction::StateFinalize<StringAggState, string_t, StringAggFunction>,
-	    AggregateFunction::UnaryUpdate<StringAggState, string_t, StringAggFunction>, StringAggBind,
-	    AggregateFunction::StateDestroy<StringAggState, StringAggFunction>);
-	string_agg_param.serialize = StringAggSerialize;
-	string_agg_param.deserialize = StringAggDeserialize;
-	string_agg.AddFunction(string_agg_param);
-	string_agg_param.arguments.emplace_back(LogicalType::VARCHAR);
-	string_agg.AddFunction(string_agg_param);
-	return string_agg;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/distributive/sum.cpp b/src/duckdb/extension/core_functions/aggregate/distributive/sum.cpp
deleted file mode 100644
index be37d5df1..000000000
--- a/src/duckdb/extension/core_functions/aggregate/distributive/sum.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "core_functions/aggregate/sum_helpers.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-struct SumSetOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.Initialize();
-	}
-	template <class STATE>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.Combine(source);
-	}
-	template <class STATE>
-	static void AddValues(STATE &state, idx_t count) {
-		state.isset = true;
-	}
-};
-
-struct IntegerSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			target = Hugeint::Convert(state.value);
-		}
-	}
-};
-
-struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, AddToHugeint> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.value;
-		}
-	}
-};
-
-template <class ADD_OPERATOR>
-struct DoubleSumOperation : public BaseSumOperation<SumSetOperation, ADD_OPERATOR> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.value;
-		}
-	}
-};
-
-using NumericSumOperation = DoubleSumOperation<RegularAdd>;
-using KahanSumOperation = DoubleSumOperation<KahanAdd>;
-
-struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, HugeintAdd> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.value;
-		}
-	}
-};
-
-unique_ptr<FunctionData> SumNoOverflowBind(ClientContext &context, AggregateFunction &function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	throw BinderException("sum_no_overflow is for internal use only!");
-}
-
-void SumNoOverflowSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                            const AggregateFunction &function) {
-	return;
-}
-
-unique_ptr<FunctionData> SumNoOverflowDeserialize(Deserializer &deserializer, AggregateFunction &function) {
-	function.return_type = deserializer.Get<const LogicalType &>();
-	return nullptr;
-}
-
-AggregateFunction GetSumAggregateNoOverflow(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT32: {
-		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int32_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::INTEGER, LogicalType::HUGEINT);
-		function.name = "sum_no_overflow";
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		function.bind = SumNoOverflowBind;
-		function.serialize = SumNoOverflowSerialize;
-		function.deserialize = SumNoOverflowDeserialize;
-		return function;
-	}
-	case PhysicalType::INT64: {
-		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int64_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::BIGINT, LogicalType::HUGEINT);
-		function.name = "sum_no_overflow";
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		function.bind = SumNoOverflowBind;
-		function.serialize = SumNoOverflowSerialize;
-		function.deserialize = SumNoOverflowDeserialize;
-		return function;
-	}
-	default:
-		throw BinderException("Unsupported internal type for sum_no_overflow");
-	}
-}
-
-AggregateFunction GetSumAggregateNoOverflowDecimal() {
-	AggregateFunction aggr({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr, nullptr,
-	                       nullptr, FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr, SumNoOverflowBind);
-	aggr.serialize = SumNoOverflowSerialize;
-	aggr.deserialize = SumNoOverflowDeserialize;
-	return aggr;
-}
-
-unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                             AggregateStatisticsInput &input) {
-	if (input.node_stats && input.node_stats->has_max_cardinality) {
-		auto &numeric_stats = input.child_stats[0];
-		if (!NumericStats::HasMinMax(numeric_stats)) {
-			return nullptr;
-		}
-		auto internal_type = numeric_stats.GetType().InternalType();
-		hugeint_t max_negative;
-		hugeint_t max_positive;
-		switch (internal_type) {
-		case PhysicalType::INT32:
-			max_negative = NumericStats::Min(numeric_stats).GetValueUnsafe<int32_t>();
-			max_positive = NumericStats::Max(numeric_stats).GetValueUnsafe<int32_t>();
-			break;
-		case PhysicalType::INT64:
-			max_negative = NumericStats::Min(numeric_stats).GetValueUnsafe<int64_t>();
-			max_positive = NumericStats::Max(numeric_stats).GetValueUnsafe<int64_t>();
-			break;
-		default:
-			throw InternalException("Unsupported type for propagate sum stats");
-		}
-		auto max_sum_negative = max_negative * Hugeint::Convert(input.node_stats->max_cardinality);
-		auto max_sum_positive = max_positive * Hugeint::Convert(input.node_stats->max_cardinality);
-		if (max_sum_positive >= NumericLimits<int64_t>::Maximum() ||
-		    max_sum_negative <= NumericLimits<int64_t>::Minimum()) {
-			// sum can potentially exceed int64_t bounds: use hugeint sum
-			return nullptr;
-		}
-		// total sum is guaranteed to fit in a single int64: use int64 sum instead of hugeint sum
-		expr.function = GetSumAggregateNoOverflow(internal_type);
-	}
-	return nullptr;
-}
-
-AggregateFunction GetSumAggregate(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL: {
-		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, bool, hugeint_t, IntegerSumOperation>(
-		    LogicalType::BOOLEAN, LogicalType::HUGEINT);
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-	case PhysicalType::INT16: {
-		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int16_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::SMALLINT, LogicalType::HUGEINT);
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-
-	case PhysicalType::INT32: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int32_t, hugeint_t, SumToHugeintOperation>(
-		        LogicalType::INTEGER, LogicalType::HUGEINT);
-		function.statistics = SumPropagateStats;
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-	case PhysicalType::INT64: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int64_t, hugeint_t, SumToHugeintOperation>(
-		        LogicalType::BIGINT, LogicalType::HUGEINT);
-		function.statistics = SumPropagateStats;
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-	case PhysicalType::INT128: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, hugeint_t, hugeint_t, HugeintSumOperation>(
-		        LogicalType::HUGEINT, LogicalType::HUGEINT);
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-	default:
-		throw InternalException("Unimplemented sum aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunction &function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	function = GetSumAggregate(decimal_type.InternalType());
-	function.name = "sum";
-	function.arguments[0] = decimal_type;
-	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
-	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	return nullptr;
-}
-
-AggregateFunctionSet SumFun::GetFunctions() {
-	AggregateFunctionSet sum;
-	// decimal
-	sum.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr,
-	                                  BindDecimalSum));
-	sum.AddFunction(GetSumAggregate(PhysicalType::BOOL));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT16));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT32));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT64));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT128));
-	sum.AddFunction(AggregateFunction::UnaryAggregate<SumState<double>, double, double, NumericSumOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	return sum;
-}
-
-AggregateFunction CountIfFun::GetFunction() {
-	return GetSumAggregate(PhysicalType::BOOL);
-}
-
-AggregateFunctionSet SumNoOverflowFun::GetFunctions() {
-	AggregateFunctionSet sum_no_overflow;
-	sum_no_overflow.AddFunction(GetSumAggregateNoOverflow(PhysicalType::INT32));
-	sum_no_overflow.AddFunction(GetSumAggregateNoOverflow(PhysicalType::INT64));
-	sum_no_overflow.AddFunction(GetSumAggregateNoOverflowDecimal());
-	return sum_no_overflow;
-}
-
-AggregateFunction KahanSumFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<KahanSumState, double, double, KahanSumOperation>(LogicalType::DOUBLE,
-	                                                                                           LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/approx_top_k.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/approx_top_k.cpp
deleted file mode 100644
index 4eb2b9d30..000000000
--- a/src/duckdb/extension/core_functions/aggregate/holistic/approx_top_k.cpp
+++ /dev/null
@@ -1,413 +0,0 @@
-#include "core_functions/aggregate/histogram_helpers.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "duckdb/function/aggregate/sort_key_helpers.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/common/printer.hpp"
-
-namespace duckdb {
-
-struct ApproxTopKString {
-	ApproxTopKString() : str(UINT32_C(0)), hash(0) {
-	}
-	ApproxTopKString(string_t str_p, hash_t hash_p) : str(str_p), hash(hash_p) {
-	}
-
-	string_t str;
-	hash_t hash;
-};
-
-struct ApproxTopKHash {
-	std::size_t operator()(const ApproxTopKString &k) const {
-		return k.hash;
-	}
-};
-
-struct ApproxTopKEquality {
-	bool operator()(const ApproxTopKString &a, const ApproxTopKString &b) const {
-		return Equals::Operation(a.str, b.str);
-	}
-};
-
-template <typename T>
-using approx_topk_map_t = unordered_map<ApproxTopKString, T, ApproxTopKHash, ApproxTopKEquality>;
-
-// approx top k algorithm based on "A parallel space saving algorithm for frequent items and the Hurwitz zeta
-// distribution" arxiv link -  https://arxiv.org/pdf/1401.0702
-// together with the filter extension (Filtered Space-Saving) from "Estimating Top-k Destinations in Data Streams"
-struct ApproxTopKValue {
-	//! The counter
-	idx_t count = 0;
-	//! Index in the values array
-	idx_t index = 0;
-	//! The string value
-	ApproxTopKString str_val;
-	//! Allocated data
-	char *dataptr = nullptr;
-	uint32_t size = 0;
-	uint32_t capacity = 0;
-};
-
-struct InternalApproxTopKState {
-	// the top-k data structure has two components
-	// a list of k values sorted on "count" (i.e. values[0] has the lowest count)
-	// a lookup map: string_t -> idx in "values" array
-	unsafe_unique_array<ApproxTopKValue> stored_values;
-	unsafe_vector<reference<ApproxTopKValue>> values;
-	approx_topk_map_t<reference<ApproxTopKValue>> lookup_map;
-	unsafe_vector<idx_t> filter;
-	idx_t k = 0;
-	idx_t capacity = 0;
-	idx_t filter_mask;
-
-	void Initialize(idx_t kval) {
-		static constexpr idx_t MONITORED_VALUES_RATIO = 3;
-		static constexpr idx_t FILTER_RATIO = 8;
-
-		D_ASSERT(values.empty());
-		D_ASSERT(lookup_map.empty());
-		k = kval;
-		capacity = kval * MONITORED_VALUES_RATIO;
-		stored_values = make_unsafe_uniq_array_uninitialized<ApproxTopKValue>(capacity);
-		values.reserve(capacity);
-
-		// we scale the filter based on the amount of values we are monitoring
-		idx_t filter_size = NextPowerOfTwo(capacity * FILTER_RATIO);
-		filter_mask = filter_size - 1;
-		filter.resize(filter_size);
-	}
-
-	static void CopyValue(ApproxTopKValue &value, const ApproxTopKString &input, AggregateInputData &input_data) {
-		value.str_val.hash = input.hash;
-		if (input.str.IsInlined()) {
-			// no need to copy
-			value.str_val = input;
-			return;
-		}
-		value.size = UnsafeNumericCast<uint32_t>(input.str.GetSize());
-		if (value.size > value.capacity) {
-			// need to re-allocate for this value
-			value.capacity = UnsafeNumericCast<uint32_t>(NextPowerOfTwo(value.size));
-			value.dataptr = char_ptr_cast(input_data.allocator.Allocate(value.capacity));
-		}
-		// copy over the data
-		memcpy(value.dataptr, input.str.GetData(), value.size);
-		value.str_val.str = string_t(value.dataptr, value.size);
-	}
-
-	void InsertOrReplaceEntry(const ApproxTopKString &input, AggregateInputData &aggr_input, idx_t increment = 1) {
-		if (values.size() < capacity) {
-			D_ASSERT(increment > 0);
-			// we can always add this entry
-			auto &val = stored_values[values.size()];
-			val.index = values.size();
-			values.push_back(val);
-		}
-		auto &value = values.back().get();
-		if (value.count > 0) {
-			// the capacity is reached - we need to replace an entry
-
-			// we use the filter as an early out
-			// based on the hash - we find a slot in the filter
-			// instead of monitoring the value immediately, we add to the slot in the filter
-			// ONLY when the value in the filter exceeds the current min value, we start monitoring the value
-			// this speeds up the algorithm as switching monitor values means we need to erase/insert in the hash table
-			auto &filter_value = filter[input.hash & filter_mask];
-			if (filter_value + increment < value.count) {
-				// if the filter has a lower count than the current min count
-				// we can skip adding this entry (for now)
-				filter_value += increment;
-				return;
-			}
-			// the filter exceeds the min value - start monitoring this value
-			// erase the existing entry from the map
-			// and set the filter for the minimum value back to the current minimum value
-			filter[value.str_val.hash & filter_mask] = value.count;
-			lookup_map.erase(value.str_val);
-		}
-		CopyValue(value, input, aggr_input);
-		lookup_map.insert(make_pair(value.str_val, reference<ApproxTopKValue>(value)));
-		IncrementCount(value, increment);
-	}
-
-	void IncrementCount(ApproxTopKValue &value, idx_t increment = 1) {
-		value.count += increment;
-		// maintain sortedness of "values"
-		// swap while we have a higher count than the next entry
-		while (value.index > 0 && values[value.index].get().count > values[value.index - 1].get().count) {
-			// swap the elements around
-			auto &left = values[value.index];
-			auto &right = values[value.index - 1];
-			std::swap(left.get().index, right.get().index);
-			std::swap(left, right);
-		}
-	}
-
-	void Verify() const {
-#ifdef DEBUG
-		if (values.empty()) {
-			D_ASSERT(lookup_map.empty());
-			return;
-		}
-		D_ASSERT(values.size() <= capacity);
-		for (idx_t k = 0; k < values.size(); k++) {
-			auto &val = values[k].get();
-			D_ASSERT(val.count > 0);
-			// verify map exists
-			auto entry = lookup_map.find(val.str_val);
-			D_ASSERT(entry != lookup_map.end());
-			// verify the index is correct
-			D_ASSERT(val.index == k);
-			if (k > 0) {
-				// sortedness
-				D_ASSERT(val.count <= values[k - 1].get().count);
-			}
-		}
-		// verify lookup map does not contain extra entries
-		D_ASSERT(lookup_map.size() == values.size());
-#endif
-	}
-};
-
-struct ApproxTopKState {
-	InternalApproxTopKState *state;
-
-	InternalApproxTopKState &GetState() {
-		if (!state) {
-			state = new InternalApproxTopKState();
-		}
-		return *state;
-	}
-
-	const InternalApproxTopKState &GetState() const {
-		if (!state) {
-			throw InternalException("No state available");
-		}
-		return *state;
-	}
-};
-
-struct ApproxTopKOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.state = nullptr;
-	}
-
-	template <class TYPE, class STATE>
-	static void Operation(STATE &aggr_state, const TYPE &input, AggregateInputData &aggr_input, Vector &top_k_vector,
-	                      idx_t offset, idx_t count) {
-		auto &state = aggr_state.GetState();
-		if (state.values.empty()) {
-			static constexpr int64_t MAX_APPROX_K = 1000000;
-			// not initialized yet - initialize the K value and set all counters to 0
-			UnifiedVectorFormat kdata;
-			top_k_vector.ToUnifiedFormat(count, kdata);
-			auto kidx = kdata.sel->get_index(offset);
-			if (!kdata.validity.RowIsValid(kidx)) {
-				throw InvalidInputException("Invalid input for approx_top_k: k value cannot be NULL");
-			}
-			auto kval = UnifiedVectorFormat::GetData<int64_t>(kdata)[kidx];
-			if (kval <= 0) {
-				throw InvalidInputException("Invalid input for approx_top_k: k value must be > 0");
-			}
-			if (kval >= MAX_APPROX_K) {
-				throw InvalidInputException("Invalid input for approx_top_k: k value must be < %d", MAX_APPROX_K);
-			}
-			state.Initialize(UnsafeNumericCast<idx_t>(kval));
-		}
-		ApproxTopKString topk_string(input, Hash(input));
-		auto entry = state.lookup_map.find(topk_string);
-		if (entry != state.lookup_map.end()) {
-			// the input is monitored - increment the count
-			state.IncrementCount(entry->second.get());
-		} else {
-			// the input is not monitored - replace the first entry with the current entry and increment
-			state.InsertOrReplaceEntry(topk_string, aggr_input);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &aggr_source, STATE &aggr_target, AggregateInputData &aggr_input) {
-		if (!aggr_source.state) {
-			// source state is empty
-			return;
-		}
-		auto &source = aggr_source.GetState();
-		auto &target = aggr_target.GetState();
-		if (source.values.empty()) {
-			// source is empty
-			return;
-		}
-		source.Verify();
-		auto min_source = source.values.back().get().count;
-		idx_t min_target;
-		if (target.values.empty()) {
-			min_target = 0;
-			target.Initialize(source.k);
-		} else {
-			if (source.k != target.k) {
-				throw NotImplementedException("Approx Top K - cannot combine approx_top_K with different k values. "
-				                              "K values must be the same for all entries within the same group");
-			}
-			min_target = target.values.back().get().count;
-		}
-		// for all entries in target
-		// check if they are tracked in source
-		//     if they do - add the tracked count
-		//     if they do not - add the minimum count
-		for (idx_t target_idx = 0; target_idx < target.values.size(); target_idx++) {
-			auto &val = target.values[target_idx].get();
-			auto source_entry = source.lookup_map.find(val.str_val);
-			idx_t increment = min_source;
-			if (source_entry != source.lookup_map.end()) {
-				increment = source_entry->second.get().count;
-			}
-			if (increment == 0) {
-				continue;
-			}
-			target.IncrementCount(val, increment);
-		}
-		// now for each entry in source, if it is not tracked by the target, at the target minimum
-		for (auto &source_entry : source.values) {
-			auto &source_val = source_entry.get();
-			auto target_entry = target.lookup_map.find(source_val.str_val);
-			if (target_entry != target.lookup_map.end()) {
-				// already tracked - no need to add anything
-				continue;
-			}
-			auto new_count = source_val.count + min_target;
-			idx_t increment;
-			if (target.values.size() >= target.capacity) {
-				idx_t current_min = target.values.empty() ? 0 : target.values.back().get().count;
-				D_ASSERT(target.values.size() == target.capacity);
-				// target already has capacity values
-				// check if we should insert this entry
-				if (new_count <= current_min) {
-					// if we do not we can skip this entry
-					continue;
-				}
-				increment = new_count - current_min;
-			} else {
-				// target does not have capacity entries yet
-				// just add this entry with the full count
-				increment = new_count;
-			}
-			target.InsertOrReplaceEntry(source_val.str_val, aggr_input, increment);
-		}
-		// copy over the filter
-		D_ASSERT(source.filter.size() == target.filter.size());
-		for (idx_t filter_idx = 0; filter_idx < source.filter.size(); filter_idx++) {
-			target.filter[filter_idx] += source.filter[filter_idx];
-		}
-		target.Verify();
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		delete state.state;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-template <class T = string_t, class OP = HistogramGenericFunctor>
-static void ApproxTopKUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
-                             idx_t count) {
-	using STATE = ApproxTopKState;
-	auto &input = inputs[0];
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-
-	auto &top_k_vector = inputs[1];
-
-	auto extra_state = OP::CreateExtraState(count);
-	UnifiedVectorFormat input_data;
-	OP::PrepareData(input, count, extra_state, input_data);
-
-	auto states = UnifiedVectorFormat::GetData<STATE *>(sdata);
-	auto data = UnifiedVectorFormat::GetData<T>(input_data);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = input_data.sel->get_index(i);
-		if (!input_data.validity.RowIsValid(idx)) {
-			continue;
-		}
-		auto &state = *states[sdata.sel->get_index(i)];
-		ApproxTopKOperation::Operation<T, STATE>(state, data[idx], aggr_input, top_k_vector, i, count);
-	}
-}
-
-template <class OP = HistogramGenericFunctor>
-static void ApproxTopKFinalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = UnifiedVectorFormat::GetData<ApproxTopKState *>(sdata);
-
-	auto &mask = FlatVector::Validity(result);
-	auto old_len = ListVector::GetListSize(result);
-	idx_t new_entries = 0;
-	// figure out how much space we need
-	for (idx_t i = 0; i < count; i++) {
-		auto &state = states[sdata.sel->get_index(i)]->GetState();
-		if (state.values.empty()) {
-			continue;
-		}
-		// get up to k values for each state
-		// this can be less of fewer unique values were found
-		new_entries += MinValue<idx_t>(state.values.size(), state.k);
-	}
-	// reserve space in the list vector
-	ListVector::Reserve(result, old_len + new_entries);
-	auto list_entries = FlatVector::GetData<list_entry_t>(result);
-	auto &child_data = ListVector::GetEntry(result);
-
-	idx_t current_offset = old_len;
-	for (idx_t i = 0; i < count; i++) {
-		const auto rid = i + offset;
-		auto &state = states[sdata.sel->get_index(i)]->GetState();
-		if (state.values.empty()) {
-			mask.SetInvalid(rid);
-			continue;
-		}
-		auto &list_entry = list_entries[rid];
-		list_entry.offset = current_offset;
-		for (idx_t val_idx = 0; val_idx < MinValue<idx_t>(state.values.size(), state.k); val_idx++) {
-			auto &val = state.values[val_idx].get();
-			D_ASSERT(val.count > 0);
-			OP::template HistogramFinalize<string_t>(val.str_val.str, child_data, current_offset);
-			current_offset++;
-		}
-		list_entry.length = current_offset - list_entry.offset;
-	}
-	D_ASSERT(current_offset == old_len + new_entries);
-	ListVector::SetListSize(result, current_offset);
-	result.Verify(count);
-}
-
-unique_ptr<FunctionData> ApproxTopKBind(ClientContext &context, AggregateFunction &function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	for (auto &arg : arguments) {
-		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-	}
-	if (arguments[0]->return_type.id() == LogicalTypeId::VARCHAR) {
-		function.update = ApproxTopKUpdate<string_t, HistogramStringFunctor>;
-		function.finalize = ApproxTopKFinalize<HistogramStringFunctor>;
-	}
-	function.return_type = LogicalType::LIST(arguments[0]->return_type);
-	return nullptr;
-}
-
-AggregateFunction ApproxTopKFun::GetFunction() {
-	using STATE = ApproxTopKState;
-	using OP = ApproxTopKOperation;
-	return AggregateFunction("approx_top_k", {LogicalTypeId::ANY, LogicalType::BIGINT},
-	                         LogicalType::LIST(LogicalType::ANY), AggregateFunction::StateSize<STATE>,
-	                         AggregateFunction::StateInitialize<STATE, OP>, ApproxTopKUpdate,
-	                         AggregateFunction::StateCombine<STATE, OP>, ApproxTopKFinalize, nullptr, ApproxTopKBind,
-	                         AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/approximate_quantile.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/approximate_quantile.cpp
deleted file mode 100644
index 23d2cf479..000000000
--- a/src/duckdb/extension/core_functions/aggregate/holistic/approximate_quantile.cpp
+++ /dev/null
@@ -1,444 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "t_digest.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <stdlib.h>
-
-namespace duckdb {
-
-struct ApproxQuantileState {
-	duckdb_tdigest::TDigest *h;
-	idx_t pos;
-};
-
-struct ApproximateQuantileBindData : public FunctionData {
-	ApproximateQuantileBindData() {
-	}
-	explicit ApproximateQuantileBindData(float quantile_p) : quantiles(1, quantile_p) {
-	}
-
-	explicit ApproximateQuantileBindData(vector<float> quantiles_p) : quantiles(std::move(quantiles_p)) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<ApproximateQuantileBindData>(quantiles);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<ApproximateQuantileBindData>();
-		//		return quantiles == other.quantiles;
-		if (quantiles != other.quantiles) {
-			return false;
-		}
-		return true;
-	}
-
-	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                      const AggregateFunction &function) {
-		auto &bind_data = bind_data_p->Cast<ApproximateQuantileBindData>();
-		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto result = make_uniq<ApproximateQuantileBindData>();
-		deserializer.ReadProperty(100, "quantiles", result->quantiles);
-		return std::move(result);
-	}
-
-	vector<float> quantiles;
-};
-
-struct ApproxQuantileOperation {
-	using SAVE_TYPE = duckdb_tdigest::Value;
-
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.pos = 0;
-		state.h = nullptr;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(input);
-		if (!Value::DoubleIsFinite(val)) {
-			return;
-		}
-		if (!state.h) {
-			state.h = new duckdb_tdigest::TDigest(100);
-		}
-		state.h->add(val);
-		state.pos++;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (source.pos == 0) {
-			return;
-		}
-		D_ASSERT(source.h);
-		if (!target.h) {
-			target.h = new duckdb_tdigest::TDigest(100);
-		}
-		target.h->merge(source.h);
-		target.pos += source.pos;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.h) {
-			delete state.h;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
-		if (state.pos == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		D_ASSERT(state.h);
-		D_ASSERT(finalize_data.input.bind_data);
-		state.h->compress();
-		auto &bind_data = finalize_data.input.bind_data->template Cast<ApproximateQuantileBindData>();
-		D_ASSERT(bind_data.quantiles.size() == 1);
-		// The result is approximate, so clamp instead of overflowing.
-		const auto source = state.h->quantile(bind_data.quantiles[0]);
-		if (TryCast::Operation(source, target, false)) {
-			return;
-		} else if (source < 0) {
-			target = NumericLimits<TARGET_TYPE>::Minimum();
-		} else {
-			target = NumericLimits<TARGET_TYPE>::Maximum();
-		}
-	}
-};
-
-static AggregateFunction GetApproximateQuantileAggregateFunction(const LogicalType &type) {
-	//	Not binary comparable
-	if (type == LogicalType::TIME_TZ) {
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, dtime_tz_t, dtime_tz_t,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	}
-	switch (type.InternalType()) {
-	case PhysicalType::INT8:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int8_t, int8_t,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int16_t, int16_t,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int32_t, int32_t,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int64_t, int64_t,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	case PhysicalType::INT128:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, hugeint_t, hugeint_t,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	case PhysicalType::FLOAT:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, float, float,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, double, double,
-		                                                   ApproxQuantileScalarOperation>(type, type);
-	default:
-		throw InternalException("Unimplemented quantile aggregate");
-	}
-}
-
-static AggregateFunction GetApproximateQuantileDecimalAggregateFunction(const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::INT8:
-		return GetApproximateQuantileAggregateFunction(LogicalType::TINYINT);
-	case PhysicalType::INT16:
-		return GetApproximateQuantileAggregateFunction(LogicalType::SMALLINT);
-	case PhysicalType::INT32:
-		return GetApproximateQuantileAggregateFunction(LogicalType::INTEGER);
-	case PhysicalType::INT64:
-		return GetApproximateQuantileAggregateFunction(LogicalType::BIGINT);
-	case PhysicalType::INT128:
-		return GetApproximateQuantileAggregateFunction(LogicalType::HUGEINT);
-	default:
-		throw InternalException("Unimplemented quantile decimal aggregate");
-	}
-}
-
-static float CheckApproxQuantile(const Value &quantile_val) {
-	if (quantile_val.IsNull()) {
-		throw BinderException("APPROXIMATE QUANTILE parameter cannot be NULL");
-	}
-	auto quantile = quantile_val.GetValue<float>();
-	if (quantile < 0 || quantile > 1) {
-		throw BinderException("APPROXIMATE QUANTILE can only take parameters in range [0, 1]");
-	}
-
-	return quantile;
-}
-
-unique_ptr<FunctionData> BindApproxQuantile(ClientContext &context, AggregateFunction &function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("APPROXIMATE QUANTILE can only take constant quantile parameters");
-	}
-	Value quantile_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	if (quantile_val.IsNull()) {
-		throw BinderException("APPROXIMATE QUANTILE parameter list cannot be NULL");
-	}
-
-	vector<float> quantiles;
-	switch (quantile_val.type().id()) {
-	case LogicalTypeId::LIST:
-		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckApproxQuantile(element_val));
-		}
-		break;
-	case LogicalTypeId::ARRAY:
-		for (const auto &element_val : ArrayValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckApproxQuantile(element_val));
-		}
-		break;
-	default:
-		quantiles.push_back(CheckApproxQuantile(quantile_val));
-		break;
-	}
-
-	// remove the quantile argument so we can use the unary aggregate
-	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_uniq<ApproximateQuantileBindData>(quantiles);
-}
-
-AggregateFunction ApproxQuantileDecimalFunction(const LogicalType &type) {
-	auto function = GetApproximateQuantileDecimalAggregateFunction(type);
-	function.name = "approx_quantile";
-	function.serialize = ApproximateQuantileBindData::Serialize;
-	function.deserialize = ApproximateQuantileBindData::Deserialize;
-	return function;
-}
-
-unique_ptr<FunctionData> BindApproxQuantileDecimal(ClientContext &context, AggregateFunction &function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindApproxQuantile(context, function, arguments);
-	function = ApproxQuantileDecimalFunction(arguments[0]->return_type);
-	return bind_data;
-}
-
-AggregateFunction GetApproximateQuantileAggregate(const LogicalType &type) {
-	auto fun = GetApproximateQuantileAggregateFunction(type);
-	fun.bind = BindApproxQuantile;
-	fun.serialize = ApproximateQuantileBindData::Serialize;
-	fun.deserialize = ApproximateQuantileBindData::Deserialize;
-	// temporarily push an argument so we can bind the actual quantile
-	fun.arguments.emplace_back(LogicalType::FLOAT);
-	return fun;
-}
-
-template <class CHILD_TYPE>
-struct ApproxQuantileListOperation : public ApproxQuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(STATE &state, RESULT_TYPE &target, AggregateFinalizeData &finalize_data) {
-		if (state.pos == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->template Cast<ApproximateQuantileBindData>();
-
-		auto &result = ListVector::GetEntry(finalize_data.result);
-		auto ridx = ListVector::GetListSize(finalize_data.result);
-		ListVector::Reserve(finalize_data.result, ridx + bind_data.quantiles.size());
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		D_ASSERT(state.h);
-		state.h->compress();
-
-		auto &entry = target;
-		entry.offset = ridx;
-		entry.length = bind_data.quantiles.size();
-		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data.quantiles[q];
-			rdata[ridx + q] = Cast::template Operation<SAVE_TYPE, CHILD_TYPE>(state.h->quantile(quantile));
-		}
-
-		ListVector::SetListSize(finalize_data.result, entry.offset + entry.length);
-	}
-};
-
-template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction ApproxQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
-	LogicalType result_type = LogicalType::LIST(child_type);
-	return AggregateFunction(
-	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>,
-	    nullptr, AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <typename INPUT_TYPE, typename SAVE_TYPE>
-AggregateFunction GetTypedApproxQuantileListAggregateFunction(const LogicalType &type) {
-	using STATE = ApproxQuantileState;
-	using OP = ApproxQuantileListOperation<INPUT_TYPE>;
-	auto fun = ApproxQuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
-	fun.serialize = ApproximateQuantileBindData::Serialize;
-	fun.deserialize = ApproximateQuantileBindData::Deserialize;
-	return fun;
-}
-
-AggregateFunction GetApproxQuantileListAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedApproxQuantileListAggregateFunction<int8_t, int8_t>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedApproxQuantileListAggregateFunction<int16_t, int16_t>(type);
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-		return GetTypedApproxQuantileListAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedApproxQuantileListAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::TIME_TZ:
-		//	Not binary comparable
-		return GetTypedApproxQuantileListAggregateFunction<dtime_tz_t, dtime_tz_t>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedApproxQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-	case LogicalTypeId::FLOAT:
-		return GetTypedApproxQuantileListAggregateFunction<float, float>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedApproxQuantileListAggregateFunction<double, double>(type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedApproxQuantileListAggregateFunction<int16_t, int16_t>(type);
-		case PhysicalType::INT32:
-			return GetTypedApproxQuantileListAggregateFunction<int32_t, int32_t>(type);
-		case PhysicalType::INT64:
-			return GetTypedApproxQuantileListAggregateFunction<int64_t, int64_t>(type);
-		case PhysicalType::INT128:
-			return GetTypedApproxQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-		default:
-			throw NotImplementedException("Unimplemented approximate quantile list decimal aggregate");
-		}
-	default:
-		throw NotImplementedException("Unimplemented approximate quantile list aggregate");
-	}
-}
-
-AggregateFunction ApproxQuantileDecimalListFunction(const LogicalType &type) {
-	auto function = GetApproxQuantileListAggregateFunction(type);
-	function.name = "approx_quantile";
-	function.serialize = ApproximateQuantileBindData::Serialize;
-	function.deserialize = ApproximateQuantileBindData::Deserialize;
-	return function;
-}
-
-unique_ptr<FunctionData> BindApproxQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindApproxQuantile(context, function, arguments);
-	function = ApproxQuantileDecimalListFunction(arguments[0]->return_type);
-	return bind_data;
-}
-
-AggregateFunction GetApproxQuantileListAggregate(const LogicalType &type) {
-	auto fun = GetApproxQuantileListAggregateFunction(type);
-	fun.bind = BindApproxQuantile;
-	fun.serialize = ApproximateQuantileBindData::Serialize;
-	fun.deserialize = ApproximateQuantileBindData::Deserialize;
-	// temporarily push an argument so we can bind the actual quantile
-	auto list_of_float = LogicalType::LIST(LogicalType::FLOAT);
-	fun.arguments.push_back(list_of_float);
-	return fun;
-}
-
-unique_ptr<FunctionData> ApproxQuantileDecimalDeserialize(Deserializer &deserializer, AggregateFunction &function) {
-	auto bind_data = ApproximateQuantileBindData::Deserialize(deserializer, function);
-	auto &return_type = deserializer.Get<const LogicalType &>();
-	if (return_type.id() == LogicalTypeId::LIST) {
-		function = ApproxQuantileDecimalListFunction(function.arguments[0]);
-	} else {
-		function = ApproxQuantileDecimalFunction(function.arguments[0]);
-	}
-	return bind_data;
-}
-
-AggregateFunction GetApproxQuantileDecimal() {
-	// stub function - the actual function is set during bind or deserialize
-	AggregateFunction fun({LogicalTypeId::DECIMAL, LogicalType::FLOAT}, LogicalTypeId::DECIMAL, nullptr, nullptr,
-	                      nullptr, nullptr, nullptr, nullptr, BindApproxQuantileDecimal);
-	fun.serialize = ApproximateQuantileBindData::Serialize;
-	fun.deserialize = ApproxQuantileDecimalDeserialize;
-	return fun;
-}
-
-AggregateFunction GetApproxQuantileDecimalList() {
-	// stub function - the actual function is set during bind or deserialize
-	AggregateFunction fun({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::FLOAT)},
-	                      LogicalType::LIST(LogicalTypeId::DECIMAL), nullptr, nullptr, nullptr, nullptr, nullptr,
-	                      nullptr, BindApproxQuantileDecimalList);
-	fun.serialize = ApproximateQuantileBindData::Serialize;
-	fun.deserialize = ApproxQuantileDecimalDeserialize;
-	return fun;
-}
-
-AggregateFunctionSet ApproxQuantileFun::GetFunctions() {
-	AggregateFunctionSet approx_quantile;
-	approx_quantile.AddFunction(GetApproxQuantileDecimal());
-
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::SMALLINT));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::INTEGER));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::BIGINT));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::HUGEINT));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::DOUBLE));
-
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::DATE));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::TIME));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::TIME_TZ));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::TIMESTAMP));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(LogicalType::TIMESTAMP_TZ));
-
-	// List variants
-	approx_quantile.AddFunction(GetApproxQuantileDecimalList());
-
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::TINYINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::SMALLINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::INTEGER));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::BIGINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::HUGEINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::FLOAT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::DOUBLE));
-
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalType::DATE));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalType::TIME));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalType::TIME_TZ));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalType::TIMESTAMP));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalType::TIMESTAMP_TZ));
-
-	return approx_quantile;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp
deleted file mode 100644
index dedb74297..000000000
--- a/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/abs.hpp"
-#include "core_functions/aggregate/quantile_state.hpp"
-
-namespace duckdb {
-
-struct FrameSet {
-	inline explicit FrameSet(const SubFrames &frames_p) : frames(frames_p) {
-	}
-
-	inline idx_t Size() const {
-		idx_t result = 0;
-		for (const auto &frame : frames) {
-			result += frame.end - frame.start;
-		}
-
-		return result;
-	}
-
-	inline bool Contains(idx_t i) const {
-		for (idx_t f = 0; f < frames.size(); ++f) {
-			const auto &frame = frames[f];
-			if (frame.start <= i && i < frame.end) {
-				return true;
-			}
-		}
-		return false;
-	}
-	const SubFrames &frames;
-};
-
-struct QuantileReuseUpdater {
-	idx_t *index;
-	idx_t j;
-
-	inline QuantileReuseUpdater(idx_t *index, idx_t j) : index(index), j(j) {
-	}
-
-	inline void Neither(idx_t begin, idx_t end) {
-	}
-
-	inline void Left(idx_t begin, idx_t end) {
-	}
-
-	inline void Right(idx_t begin, idx_t end) {
-		for (; begin < end; ++begin) {
-			index[j++] = begin;
-		}
-	}
-
-	inline void Both(idx_t begin, idx_t end) {
-	}
-};
-
-void ReuseIndexes(idx_t *index, const SubFrames &currs, const SubFrames &prevs) {
-
-	//  Copy overlapping indices by scanning the previous set and copying down into holes.
-	//	We copy instead of leaving gaps in case there are fewer values in the current frame.
-	FrameSet prev_set(prevs);
-	FrameSet curr_set(currs);
-	const auto prev_count = prev_set.Size();
-	idx_t j = 0;
-	for (idx_t p = 0; p < prev_count; ++p) {
-		auto idx = index[p];
-
-		//  Shift down into any hole
-		if (j != p) {
-			index[j] = idx;
-		}
-
-		//  Skip overlapping values
-		if (curr_set.Contains(idx)) {
-			++j;
-		}
-	}
-
-	//  Insert new indices
-	if (j > 0) {
-		QuantileReuseUpdater updater(index, j);
-		AggregateExecutor::IntersectFrames(prevs, currs, updater);
-	} else {
-		//  No overlap: overwrite with new values
-		for (const auto &curr : currs) {
-			for (auto idx = curr.start; idx < curr.end; ++idx) {
-				index[j++] = idx;
-			}
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Median Absolute Deviation
-//===--------------------------------------------------------------------===//
-template <typename T, typename R, typename MEDIAN_TYPE>
-struct MadAccessor {
-	using INPUT_TYPE = T;
-	using RESULT_TYPE = R;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const RESULT_TYPE delta = input - UnsafeNumericCast<RESULT_TYPE>(median);
-		return TryAbsOperator::Operation<RESULT_TYPE, RESULT_TYPE>(delta);
-	}
-};
-
-// hugeint_t - double => undefined
-template <>
-struct MadAccessor<hugeint_t, double, double> {
-	using INPUT_TYPE = hugeint_t;
-	using RESULT_TYPE = double;
-	using MEDIAN_TYPE = double;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = Hugeint::Cast<double>(input) - median;
-		return TryAbsOperator::Operation<double, double>(delta);
-	}
-};
-
-// date_t - timestamp_t => interval_t
-template <>
-struct MadAccessor<date_t, interval_t, timestamp_t> {
-	using INPUT_TYPE = date_t;
-	using RESULT_TYPE = interval_t;
-	using MEDIAN_TYPE = timestamp_t;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto dt = Cast::Operation<date_t, timestamp_t>(input);
-		const auto delta = dt - median;
-		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
-	}
-};
-
-// timestamp_t - timestamp_t => int64_t
-template <>
-struct MadAccessor<timestamp_t, interval_t, timestamp_t> {
-	using INPUT_TYPE = timestamp_t;
-	using RESULT_TYPE = interval_t;
-	using MEDIAN_TYPE = timestamp_t;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = input - median;
-		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
-	}
-};
-
-// dtime_t - dtime_t => int64_t
-template <>
-struct MadAccessor<dtime_t, interval_t, dtime_t> {
-	using INPUT_TYPE = dtime_t;
-	using RESULT_TYPE = interval_t;
-	using MEDIAN_TYPE = dtime_t;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = input - median;
-		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
-	}
-};
-
-template <typename MEDIAN_TYPE>
-struct MedianAbsoluteDeviationOperation : QuantileOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.v.empty()) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		using INPUT_TYPE = typename STATE::InputType;
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
-		D_ASSERT(bind_data.quantiles.size() == 1);
-		const auto &q = bind_data.quantiles[0];
-		Interpolator<false> interp(q, state.v.size(), false);
-		const auto med = interp.template Operation<INPUT_TYPE, MEDIAN_TYPE>(state.v.data(), finalize_data.result);
-
-		MadAccessor<INPUT_TYPE, T, MEDIAN_TYPE> accessor(med);
-		target = interp.template Operation<INPUT_TYPE, T>(state.v.data(), finalize_data.result, accessor);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                   const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &frames, Vector &result,
-	                   idx_t ridx) {
-		auto &state = *reinterpret_cast<STATE *>(l_state);
-		auto gstate = reinterpret_cast<const STATE *>(g_state);
-
-		auto &data = state.GetOrCreateWindowCursor(partition);
-		const auto &fmask = partition.filter_mask;
-
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-
-		QuantileIncluded<INPUT_TYPE> included(fmask, data);
-		const auto n = FrameSize(included, frames);
-
-		if (!n) {
-			auto &rmask = FlatVector::Validity(result);
-			rmask.Set(ridx, false);
-			return;
-		}
-
-		//	Compute the median
-		D_ASSERT(aggr_input_data.bind_data);
-		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
-
-		D_ASSERT(bind_data.quantiles.size() == 1);
-		const auto &quantile = bind_data.quantiles[0];
-		auto &window_state = state.GetOrCreateWindowState();
-		MEDIAN_TYPE med;
-		if (gstate && gstate->HasTree()) {
-			med = gstate->GetWindowState().template WindowScalar<MEDIAN_TYPE, false>(data, frames, n, result, quantile);
-		} else {
-			window_state.UpdateSkip(data, frames, included);
-			med = window_state.template WindowScalar<MEDIAN_TYPE, false>(data, frames, n, result, quantile);
-		}
-
-		//  Lazily initialise frame state
-		window_state.SetCount(frames.back().end - frames.front().start);
-		auto index2 = window_state.m.data();
-		D_ASSERT(index2);
-
-		// The replacement trick does not work on the second index because if
-		// the median has changed, the previous order is not correct.
-		// It is probably close, however, and so reuse is helpful.
-		auto &prevs = window_state.prevs;
-		ReuseIndexes(index2, frames, prevs);
-		std::partition(index2, index2 + window_state.count, included);
-
-		Interpolator<false> interp(quantile, n, false);
-
-		// Compute mad from the second index
-		using ID = QuantileIndirect<INPUT_TYPE>;
-		ID indirect(data);
-
-		using MAD = MadAccessor<INPUT_TYPE, RESULT_TYPE, MEDIAN_TYPE>;
-		MAD mad(med);
-
-		using MadIndirect = QuantileComposed<MAD, ID>;
-		MadIndirect mad_indirect(mad, indirect);
-		rdata[ridx] = interp.template Operation<idx_t, RESULT_TYPE, MadIndirect>(index2, result, mad_indirect);
-
-		//	Prev is used by both skip lists and increments
-		prevs = frames;
-	}
-};
-
-unique_ptr<FunctionData> BindMAD(ClientContext &context, AggregateFunction &function,
-                                 vector<unique_ptr<Expression>> &arguments) {
-	return make_uniq<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
-}
-
-template <typename INPUT_TYPE, typename MEDIAN_TYPE, typename TARGET_TYPE>
-AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const LogicalType &input_type,
-                                                                   const LogicalType &target_type) {
-	using STATE = QuantileState<INPUT_TYPE, QuantileStandardType>;
-	using OP = MedianAbsoluteDeviationOperation<MEDIAN_TYPE>;
-	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP,
-	                                                       AggregateDestructorType::LEGACY>(input_type, target_type);
-	fun.bind = BindMAD;
-	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-#ifndef DUCKDB_SMALLER_BINARY
-	fun.window = OP::template Window<STATE, INPUT_TYPE, TARGET_TYPE>;
-	fun.window_init = OP::template WindowInit<STATE, INPUT_TYPE>;
-#endif
-	return fun;
-}
-
-AggregateFunction GetMedianAbsoluteDeviationAggregateFunctionInternal(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::FLOAT:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<float, float, float>(type, type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<double, double, double>(type, type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<int16_t, int16_t, int16_t>(type, type);
-		case PhysicalType::INT32:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<int32_t, int32_t, int32_t>(type, type);
-		case PhysicalType::INT64:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<int64_t, int64_t, int64_t>(type, type);
-		case PhysicalType::INT128:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<hugeint_t, hugeint_t, hugeint_t>(type, type);
-		default:
-			throw NotImplementedException("Unimplemented Median Absolute Deviation DECIMAL aggregate");
-		}
-		break;
-
-	case LogicalTypeId::DATE:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<date_t, timestamp_t, interval_t>(type,
-		                                                                                         LogicalType::INTERVAL);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<timestamp_t, timestamp_t, interval_t>(
-		    type, LogicalType::INTERVAL);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<dtime_t, dtime_t, interval_t>(type,
-		                                                                                      LogicalType::INTERVAL);
-
-	default:
-		throw NotImplementedException("Unimplemented Median Absolute Deviation aggregate");
-	}
-}
-
-AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) {
-	auto result = GetMedianAbsoluteDeviationAggregateFunctionInternal(type);
-	result.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR;
-	return result;
-}
-
-unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &context, AggregateFunction &function,
-                                                            vector<unique_ptr<Expression>> &arguments) {
-	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
-	function.name = "mad";
-	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	return BindMAD(context, function, arguments);
-}
-
-AggregateFunctionSet MadFun::GetFunctions() {
-	AggregateFunctionSet mad("mad");
-	mad.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, nullptr, BindMedianAbsoluteDeviationDecimal));
-
-	const vector<LogicalType> MAD_TYPES = {LogicalType::FLOAT,     LogicalType::DOUBLE, LogicalType::DATE,
-	                                       LogicalType::TIMESTAMP, LogicalType::TIME,   LogicalType::TIMESTAMP_TZ,
-	                                       LogicalType::TIME_TZ};
-	for (const auto &type : MAD_TYPES) {
-		mad.AddFunction(GetMedianAbsoluteDeviationAggregateFunction(type));
-	}
-	return mad;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/mode.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/mode.cpp
deleted file mode 100644
index 8c35fc8c9..000000000
--- a/src/duckdb/extension/core_functions/aggregate/holistic/mode.cpp
+++ /dev/null
@@ -1,573 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/owning_string_map.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/function/aggregate/sort_key_helpers.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include <functional>
-
-// MODE( <expr1> )
-// Returns the most frequent value for the values within expr1.
-// NULL values are ignored. If all the values are NULL, or there are 0 rows, then the function returns NULL.
-
-namespace std {} // namespace std
-
-namespace duckdb {
-
-struct ModeAttr {
-	ModeAttr() : count(0), first_row(std::numeric_limits<idx_t>::max()) {
-	}
-	size_t count;
-	idx_t first_row;
-};
-
-template <class T>
-struct ModeStandard {
-	using MAP_TYPE = unordered_map<T, ModeAttr>;
-
-	static MAP_TYPE *CreateEmpty(ArenaAllocator &) {
-		return new MAP_TYPE();
-	}
-	static MAP_TYPE *CreateEmpty(Allocator &) {
-		return new MAP_TYPE();
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Assign(Vector &result, INPUT_TYPE input) {
-		return RESULT_TYPE(input);
-	}
-};
-
-struct ModeString {
-	using MAP_TYPE = OwningStringMap<ModeAttr>;
-
-	static MAP_TYPE *CreateEmpty(ArenaAllocator &allocator) {
-		return new MAP_TYPE(allocator);
-	}
-	static MAP_TYPE *CreateEmpty(Allocator &allocator) {
-		return new MAP_TYPE(allocator);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Assign(Vector &result, INPUT_TYPE input) {
-		return StringVector::AddStringOrBlob(result, input);
-	}
-};
-
-template <class KEY_TYPE, class TYPE_OP>
-struct ModeState {
-	using Counts = typename TYPE_OP::MAP_TYPE;
-
-	ModeState() {
-	}
-
-	SubFrames prevs;
-	Counts *frequency_map = nullptr;
-	KEY_TYPE *mode = nullptr;
-	size_t nonzero = 0;
-	bool valid = false;
-	size_t count = 0;
-
-	//! The collection being read
-	const ColumnDataCollection *inputs;
-	//! The state used for reading the collection on this thread
-	ColumnDataScanState *scan = nullptr;
-	//! The data chunk paged into into
-	DataChunk page;
-	//! The data pointer
-	const KEY_TYPE *data = nullptr;
-	//! The validity mask
-	const ValidityMask *validity = nullptr;
-
-	~ModeState() {
-		if (frequency_map) {
-			delete frequency_map;
-		}
-		if (mode) {
-			delete mode;
-		}
-		if (scan) {
-			delete scan;
-		}
-	}
-
-	void InitializePage(const WindowPartitionInput &partition) {
-		if (!scan) {
-			scan = new ColumnDataScanState();
-		}
-		if (page.ColumnCount() == 0) {
-			D_ASSERT(partition.inputs);
-			inputs = partition.inputs;
-			D_ASSERT(partition.column_ids.size() == 1);
-			inputs->InitializeScan(*scan, partition.column_ids);
-			inputs->InitializeScanChunk(*scan, page);
-		}
-	}
-
-	inline sel_t RowOffset(idx_t row_idx) const {
-		D_ASSERT(RowIsVisible(row_idx));
-		return UnsafeNumericCast<sel_t>(row_idx - scan->current_row_index);
-	}
-
-	inline bool RowIsVisible(idx_t row_idx) const {
-		return (row_idx < scan->next_row_index && scan->current_row_index <= row_idx);
-	}
-
-	inline idx_t Seek(idx_t row_idx) {
-		if (!RowIsVisible(row_idx)) {
-			D_ASSERT(inputs);
-			inputs->Seek(row_idx, *scan, page);
-			data = FlatVector::GetData<KEY_TYPE>(page.data[0]);
-			validity = &FlatVector::Validity(page.data[0]);
-		}
-		return RowOffset(row_idx);
-	}
-
-	inline const KEY_TYPE &GetCell(idx_t row_idx) {
-		const auto offset = Seek(row_idx);
-		return data[offset];
-	}
-
-	inline bool RowIsValid(idx_t row_idx) {
-		const auto offset = Seek(row_idx);
-		return validity->RowIsValid(offset);
-	}
-
-	void Reset() {
-		if (frequency_map) {
-			frequency_map->clear();
-		}
-		nonzero = 0;
-		count = 0;
-		valid = false;
-	}
-
-	void ModeAdd(idx_t row) {
-		const auto &key = GetCell(row);
-		auto &attr = (*frequency_map)[key];
-		auto new_count = (attr.count += 1);
-		if (new_count == 1) {
-			++nonzero;
-			attr.first_row = row;
-		} else {
-			attr.first_row = MinValue(row, attr.first_row);
-		}
-		if (new_count > count) {
-			valid = true;
-			count = new_count;
-			if (mode) {
-				*mode = key;
-			} else {
-				mode = new KEY_TYPE(key);
-			}
-		}
-	}
-
-	void ModeRm(idx_t frame) {
-		const auto &key = GetCell(frame);
-		auto &attr = (*frequency_map)[key];
-		auto old_count = attr.count;
-		nonzero -= size_t(old_count == 1);
-
-		attr.count -= 1;
-		if (count == old_count && key == *mode) {
-			valid = false;
-		}
-	}
-
-	typename Counts::const_iterator Scan() const {
-		//! Initialize control variables to first variable of the frequency map
-		auto highest_frequency = frequency_map->begin();
-		for (auto i = highest_frequency; i != frequency_map->end(); ++i) {
-			// Tie break with the lowest insert position
-			if (i->second.count > highest_frequency->second.count ||
-			    (i->second.count == highest_frequency->second.count &&
-			     i->second.first_row < highest_frequency->second.first_row)) {
-				highest_frequency = i;
-			}
-		}
-		return highest_frequency;
-	}
-};
-
-template <typename STATE>
-struct ModeIncluded {
-	inline explicit ModeIncluded(const ValidityMask &fmask_p, STATE &state) : fmask(fmask_p), state(state) {
-	}
-
-	inline bool operator()(const idx_t &idx) const {
-		return fmask.RowIsValid(idx) && state.RowIsValid(idx);
-	}
-	const ValidityMask &fmask;
-	STATE &state;
-};
-
-template <typename TYPE_OP>
-struct BaseModeFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		new (&state) STATE();
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Execute(STATE &state, const INPUT_TYPE &key, AggregateInputData &input_data) {
-		if (!state.frequency_map) {
-			state.frequency_map = TYPE_OP::CreateEmpty(input_data.allocator);
-		}
-		auto &i = (*state.frequency_map)[key];
-		++i.count;
-		i.first_row = MinValue<idx_t>(i.first_row, state.count);
-		++state.count;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &key, AggregateUnaryInput &aggr_input) {
-		Execute<INPUT_TYPE, STATE, OP>(state, key, aggr_input.input);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.frequency_map) {
-			return;
-		}
-		if (!target.frequency_map) {
-			// Copy - don't destroy! Otherwise windowing will break.
-			target.frequency_map = new typename STATE::Counts(*source.frequency_map);
-			target.count = source.count;
-			return;
-		}
-		for (auto &val : *source.frequency_map) {
-			auto &i = (*target.frequency_map)[val.first];
-			i.count += val.second.count;
-			i.first_row = MinValue(i.first_row, val.second.first_row);
-		}
-		target.count += source.count;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.~STATE();
-	}
-};
-
-template <typename TYPE_OP>
-struct TypedModeFunction : BaseModeFunction<TYPE_OP> {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &key, AggregateUnaryInput &aggr_input, idx_t count) {
-		if (!state.frequency_map) {
-			state.frequency_map = TYPE_OP::CreateEmpty(aggr_input.input.allocator);
-		}
-		auto &i = (*state.frequency_map)[key];
-		i.count += count;
-		i.first_row = MinValue<idx_t>(i.first_row, state.count);
-		state.count += count;
-	}
-};
-
-template <typename TYPE_OP>
-struct ModeFunction : TypedModeFunction<TYPE_OP> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.frequency_map) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		auto highest_frequency = state.Scan();
-		if (highest_frequency != state.frequency_map->end()) {
-			target = TYPE_OP::template Assign<T, T>(finalize_data.result, highest_frequency->first);
-		} else {
-			finalize_data.ReturnNull();
-		}
-	}
-
-	template <typename STATE, typename INPUT_TYPE>
-	struct UpdateWindowState {
-		STATE &state;
-		ModeIncluded<STATE> &included;
-
-		inline UpdateWindowState(STATE &state, ModeIncluded<STATE> &included) : state(state), included(included) {
-		}
-
-		inline void Neither(idx_t begin, idx_t end) {
-		}
-
-		inline void Left(idx_t begin, idx_t end) {
-			for (; begin < end; ++begin) {
-				if (included(begin)) {
-					state.ModeRm(begin);
-				}
-			}
-		}
-
-		inline void Right(idx_t begin, idx_t end) {
-			for (; begin < end; ++begin) {
-				if (included(begin)) {
-					state.ModeAdd(begin);
-				}
-			}
-		}
-
-		inline void Both(idx_t begin, idx_t end) {
-		}
-	};
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                   const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &frames, Vector &result,
-	                   idx_t rid) {
-		auto &state = *reinterpret_cast<STATE *>(l_state);
-
-		state.InitializePage(partition);
-		const auto &fmask = partition.filter_mask;
-
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
-		auto &prevs = state.prevs;
-		if (prevs.empty()) {
-			prevs.resize(1);
-		}
-
-		ModeIncluded<STATE> included(fmask, state);
-
-		if (!state.frequency_map) {
-			state.frequency_map = TYPE_OP::CreateEmpty(Allocator::DefaultAllocator());
-		}
-		const size_t tau_inverse = 4; // tau==0.25
-		if (state.nonzero <= (state.frequency_map->size() / tau_inverse) || prevs.back().end <= frames.front().start ||
-		    frames.back().end <= prevs.front().start) {
-			state.Reset();
-			// for f ∈ F do
-			for (const auto &frame : frames) {
-				for (auto i = frame.start; i < frame.end; ++i) {
-					if (included(i)) {
-						state.ModeAdd(i);
-					}
-				}
-			}
-		} else {
-			using Updater = UpdateWindowState<STATE, INPUT_TYPE>;
-			Updater updater(state, included);
-			AggregateExecutor::IntersectFrames(prevs, frames, updater);
-		}
-
-		if (!state.valid) {
-			// Rescan
-			auto highest_frequency = state.Scan();
-			if (highest_frequency != state.frequency_map->end()) {
-				*(state.mode) = highest_frequency->first;
-				state.count = highest_frequency->second.count;
-				state.valid = (state.count > 0);
-			}
-		}
-
-		if (state.valid) {
-			rdata[rid] = TYPE_OP::template Assign<INPUT_TYPE, RESULT_TYPE>(result, *state.mode);
-		} else {
-			rmask.Set(rid, false);
-		}
-
-		prevs = frames;
-	}
-};
-
-template <typename TYPE_OP>
-struct ModeFallbackFunction : BaseModeFunction<TYPE_OP> {
-	template <class STATE>
-	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (!state.frequency_map) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		auto highest_frequency = state.Scan();
-		if (highest_frequency != state.frequency_map->end()) {
-			CreateSortKeyHelpers::DecodeSortKey(highest_frequency->first, finalize_data.result,
-			                                    finalize_data.result_idx,
-			                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
-		} else {
-			finalize_data.ReturnNull();
-		}
-	}
-};
-
-AggregateFunction GetFallbackModeFunction(const LogicalType &type) {
-	using STATE = ModeState<string_t, ModeString>;
-	using OP = ModeFallbackFunction<ModeString>;
-	AggregateFunction aggr({type}, type, AggregateFunction::StateSize<STATE>,
-	                       AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
-	                       AggregateSortKeyHelpers::UnaryUpdate<STATE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	                       AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr);
-	aggr.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-	return aggr;
-}
-
-template <typename INPUT_TYPE, typename TYPE_OP = ModeStandard<INPUT_TYPE>>
-AggregateFunction GetTypedModeFunction(const LogicalType &type) {
-	using STATE = ModeState<INPUT_TYPE, TYPE_OP>;
-	using OP = ModeFunction<TYPE_OP>;
-	auto func =
-	    AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, INPUT_TYPE, OP, AggregateDestructorType::LEGACY>(
-	        type, type);
-	func.window = OP::template Window<STATE, INPUT_TYPE, INPUT_TYPE>;
-	return func;
-}
-
-AggregateFunction GetModeAggregate(const LogicalType &type) {
-	switch (type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::INT8:
-		return GetTypedModeFunction<int8_t>(type);
-	case PhysicalType::UINT8:
-		return GetTypedModeFunction<uint8_t>(type);
-	case PhysicalType::INT16:
-		return GetTypedModeFunction<int16_t>(type);
-	case PhysicalType::UINT16:
-		return GetTypedModeFunction<uint16_t>(type);
-	case PhysicalType::INT32:
-		return GetTypedModeFunction<int32_t>(type);
-	case PhysicalType::UINT32:
-		return GetTypedModeFunction<uint32_t>(type);
-	case PhysicalType::INT64:
-		return GetTypedModeFunction<int64_t>(type);
-	case PhysicalType::UINT64:
-		return GetTypedModeFunction<uint64_t>(type);
-	case PhysicalType::INT128:
-		return GetTypedModeFunction<hugeint_t>(type);
-	case PhysicalType::UINT128:
-		return GetTypedModeFunction<uhugeint_t>(type);
-	case PhysicalType::FLOAT:
-		return GetTypedModeFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetTypedModeFunction<double>(type);
-	case PhysicalType::INTERVAL:
-		return GetTypedModeFunction<interval_t>(type);
-	case PhysicalType::VARCHAR:
-		return GetTypedModeFunction<string_t, ModeString>(type);
-#endif
-	default:
-		return GetFallbackModeFunction(type);
-	}
-}
-
-unique_ptr<FunctionData> BindModeAggregate(ClientContext &context, AggregateFunction &function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	function = GetModeAggregate(arguments[0]->return_type);
-	function.name = "mode";
-	return nullptr;
-}
-
-AggregateFunctionSet ModeFun::GetFunctions() {
-	AggregateFunctionSet mode("mode");
-	mode.AddFunction(AggregateFunction({LogicalTypeId::ANY}, LogicalTypeId::ANY, nullptr, nullptr, nullptr, nullptr,
-	                                   nullptr, nullptr, BindModeAggregate));
-	return mode;
-}
-
-//===--------------------------------------------------------------------===//
-// Entropy
-//===--------------------------------------------------------------------===//
-template <class STATE>
-static double FinalizeEntropy(STATE &state) {
-	if (!state.frequency_map) {
-		return 0;
-	}
-	double count = static_cast<double>(state.count);
-	double entropy = 0;
-	for (auto &val : *state.frequency_map) {
-		double val_sec = static_cast<double>(val.second.count);
-		entropy += (val_sec / count) * log2(count / val_sec);
-	}
-	return entropy;
-}
-
-template <typename TYPE_OP>
-struct EntropyFunction : TypedModeFunction<TYPE_OP> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		target = FinalizeEntropy(state);
-	}
-};
-
-template <typename TYPE_OP>
-struct EntropyFallbackFunction : BaseModeFunction<TYPE_OP> {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		target = FinalizeEntropy(state);
-	}
-};
-
-template <typename INPUT_TYPE, typename TYPE_OP = ModeStandard<INPUT_TYPE>>
-AggregateFunction GetTypedEntropyFunction(const LogicalType &type) {
-	using STATE = ModeState<INPUT_TYPE, TYPE_OP>;
-	using OP = EntropyFunction<TYPE_OP>;
-	auto func =
-	    AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, double, OP, AggregateDestructorType::LEGACY>(
-	        type, LogicalType::DOUBLE);
-	func.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return func;
-}
-
-AggregateFunction GetFallbackEntropyFunction(const LogicalType &type) {
-	using STATE = ModeState<string_t, ModeString>;
-	using OP = EntropyFallbackFunction<ModeString>;
-	AggregateFunction func({type}, LogicalType::DOUBLE, AggregateFunction::StateSize<STATE>,
-	                       AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
-	                       AggregateSortKeyHelpers::UnaryUpdate<STATE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	                       AggregateFunction::StateFinalize<STATE, double, OP>, nullptr);
-	func.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-	func.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return func;
-}
-
-AggregateFunction GetEntropyFunction(const LogicalType &type) {
-	switch (type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::UINT16:
-		return GetTypedEntropyFunction<uint16_t>(type);
-	case PhysicalType::UINT32:
-		return GetTypedEntropyFunction<uint32_t>(type);
-	case PhysicalType::UINT64:
-		return GetTypedEntropyFunction<uint64_t>(type);
-	case PhysicalType::INT16:
-		return GetTypedEntropyFunction<int16_t>(type);
-	case PhysicalType::INT32:
-		return GetTypedEntropyFunction<int32_t>(type);
-	case PhysicalType::INT64:
-		return GetTypedEntropyFunction<int64_t>(type);
-	case PhysicalType::FLOAT:
-		return GetTypedEntropyFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetTypedEntropyFunction<double>(type);
-	case PhysicalType::VARCHAR:
-		return GetTypedEntropyFunction<string_t, ModeString>(type);
-#endif
-	default:
-		return GetFallbackEntropyFunction(type);
-	}
-}
-
-unique_ptr<FunctionData> BindEntropyAggregate(ClientContext &context, AggregateFunction &function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	function = GetEntropyFunction(arguments[0]->return_type);
-	function.name = "entropy";
-	return nullptr;
-}
-
-AggregateFunctionSet EntropyFun::GetFunctions() {
-	AggregateFunctionSet entropy("entropy");
-	entropy.AddFunction(AggregateFunction({LogicalTypeId::ANY}, LogicalType::DOUBLE, nullptr, nullptr, nullptr, nullptr,
-	                                      nullptr, nullptr, BindEntropyAggregate));
-	return entropy;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/quantile.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/quantile.cpp
deleted file mode 100644
index 98ca4d5be..000000000
--- a/src/duckdb/extension/core_functions/aggregate/holistic/quantile.cpp
+++ /dev/null
@@ -1,873 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "duckdb/common/enums/quantile_enum.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/abs.hpp"
-#include "core_functions/aggregate/quantile_state.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/function/aggregate/sort_key_helpers.hpp"
-
-namespace duckdb {
-
-template <class INPUT_TYPE>
-struct IndirectLess {
-	inline explicit IndirectLess(const INPUT_TYPE *inputs_p) : inputs(inputs_p) {
-	}
-
-	inline bool operator()(const idx_t &lhi, const idx_t &rhi) const {
-		return inputs[lhi] < inputs[rhi];
-	}
-
-	const INPUT_TYPE *inputs;
-};
-
-template <typename T>
-static inline T QuantileAbs(const T &t) {
-	return AbsOperator::Operation<T, T>(t);
-}
-
-template <>
-inline Value QuantileAbs(const Value &v) {
-	const auto &type = v.type();
-	switch (type.id()) {
-	case LogicalTypeId::DECIMAL: {
-		const auto integral = IntegralValue::Get(v);
-		const auto width = DecimalType::GetWidth(type);
-		const auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(QuantileAbs<int16_t>(Cast::Operation<hugeint_t, int16_t>(integral)), width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(QuantileAbs<int32_t>(Cast::Operation<hugeint_t, int32_t>(integral)), width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(QuantileAbs<int64_t>(Cast::Operation<hugeint_t, int64_t>(integral)), width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(QuantileAbs<hugeint_t>(integral), width, scale);
-		default:
-			throw InternalException("Unknown DECIMAL type");
-		}
-	}
-	default:
-		return Value::DOUBLE(QuantileAbs<double>(v.GetValue<double>()));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Quantile Bind Data
-//===--------------------------------------------------------------------===//
-QuantileBindData::QuantileBindData() {
-}
-
-QuantileBindData::QuantileBindData(const Value &quantile_p)
-    : quantiles(1, QuantileValue(QuantileAbs(quantile_p))), order(1, 0), desc(quantile_p < 0) {
-}
-
-QuantileBindData::QuantileBindData(const vector<Value> &quantiles_p) {
-	vector<Value> normalised;
-	size_t pos = 0;
-	size_t neg = 0;
-	for (idx_t i = 0; i < quantiles_p.size(); ++i) {
-		const auto &q = quantiles_p[i];
-		pos += (q > 0);
-		neg += (q < 0);
-		normalised.emplace_back(QuantileAbs(q));
-		order.push_back(i);
-	}
-	if (pos && neg) {
-		throw BinderException("QUANTILE parameters must have consistent signs");
-	}
-	desc = (neg > 0);
-
-	IndirectLess<Value> lt(normalised.data());
-	std::sort(order.begin(), order.end(), lt);
-
-	for (const auto &q : normalised) {
-		quantiles.emplace_back(QuantileValue(q));
-	}
-}
-
-QuantileBindData::QuantileBindData(const QuantileBindData &other) : order(other.order), desc(other.desc) {
-	for (const auto &q : other.quantiles) {
-		quantiles.emplace_back(q);
-	}
-}
-
-unique_ptr<FunctionData> QuantileBindData::Copy() const {
-	return make_uniq<QuantileBindData>(*this);
-}
-
-bool QuantileBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<QuantileBindData>();
-	return desc == other.desc && quantiles == other.quantiles && order == other.order;
-}
-
-void QuantileBindData::Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                 const AggregateFunction &function) {
-	auto &bind_data = bind_data_p->Cast<QuantileBindData>();
-	vector<Value> raw;
-	for (const auto &q : bind_data.quantiles) {
-		raw.emplace_back(q.val);
-	}
-	serializer.WriteProperty(100, "quantiles", raw);
-	serializer.WriteProperty(101, "order", bind_data.order);
-	serializer.WriteProperty(102, "desc", bind_data.desc);
-}
-
-unique_ptr<FunctionData> QuantileBindData::Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-	auto result = make_uniq<QuantileBindData>();
-	vector<Value> raw;
-	deserializer.ReadProperty(100, "quantiles", raw);
-	deserializer.ReadProperty(101, "order", result->order);
-	deserializer.ReadProperty(102, "desc", result->desc);
-	QuantileSerializationType deserialization_type;
-	deserializer.ReadPropertyWithExplicitDefault(103, "quantile_type", deserialization_type,
-	                                             QuantileSerializationType::NON_DECIMAL);
-
-	if (deserialization_type != QuantileSerializationType::NON_DECIMAL) {
-		deserializer.ReadDeletedProperty<LogicalType>(104, "logical_type");
-	}
-
-	for (const auto &r : raw) {
-		result->quantiles.emplace_back(QuantileValue(r));
-	}
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Interpolation
-//===--------------------------------------------------------------------===//
-template <>
-interval_t CastInterpolation::Cast(const dtime_t &src, Vector &result) {
-	return {0, 0, src.micros};
-}
-
-template <>
-double CastInterpolation::Interpolate(const double &lo, const double d, const double &hi) {
-	return lo * (1.0 - d) + hi * d;
-}
-
-template <>
-dtime_t CastInterpolation::Interpolate(const dtime_t &lo, const double d, const dtime_t &hi) {
-	return dtime_t(std::llround(static_cast<double>(lo.micros) * (1.0 - d) + static_cast<double>(hi.micros) * d));
-}
-
-template <>
-timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d, const timestamp_t &hi) {
-	return timestamp_t(std::llround(static_cast<double>(lo.value) * (1.0 - d) + static_cast<double>(hi.value) * d));
-}
-
-template <>
-hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi) {
-	return Hugeint::Convert(Interpolate(Hugeint::Cast<double>(lo), d, Hugeint::Cast<double>(hi)));
-}
-
-static interval_t MultiplyByDouble(const interval_t &i, const double &d) { // NOLINT
-	D_ASSERT(d >= 0 && d <= 1);
-	return Interval::FromMicro(std::llround(static_cast<double>(Interval::GetMicro(i)) * d));
-}
-
-inline interval_t operator+(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) + Interval::GetMicro(rhs));
-}
-
-inline interval_t operator-(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) - Interval::GetMicro(rhs));
-}
-
-template <>
-interval_t CastInterpolation::Interpolate(const interval_t &lo, const double d, const interval_t &hi) {
-	const interval_t delta = hi - lo;
-	return lo + MultiplyByDouble(delta, d);
-}
-
-template <>
-string_t CastInterpolation::Cast(const string_t &src, Vector &result) {
-	return StringVector::AddStringOrBlob(result, src);
-}
-
-//===--------------------------------------------------------------------===//
-// Scalar Quantile
-//===--------------------------------------------------------------------===//
-template <bool DISCRETE, class TYPE_OP = QuantileStandardType>
-struct QuantileScalarOperation : public QuantileOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.v.empty()) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
-		D_ASSERT(bind_data.quantiles.size() == 1);
-		Interpolator<DISCRETE> interp(bind_data.quantiles[0], state.v.size(), bind_data.desc);
-		target = interp.template Operation<typename STATE::InputType, T>(state.v.data(), finalize_data.result);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                   const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &frames, Vector &result,
-	                   idx_t ridx) {
-		auto &state = *reinterpret_cast<STATE *>(l_state);
-		auto gstate = reinterpret_cast<const STATE *>(g_state);
-
-		auto &data = state.GetOrCreateWindowCursor(partition);
-		const auto &fmask = partition.filter_mask;
-
-		QuantileIncluded<INPUT_TYPE> included(fmask, data);
-		const auto n = FrameSize(included, frames);
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
-
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
-
-		if (!n) {
-			rmask.Set(ridx, false);
-			return;
-		}
-
-		const auto &quantile = bind_data.quantiles[0];
-		if (gstate && gstate->HasTree()) {
-			rdata[ridx] = gstate->GetWindowState().template WindowScalar<RESULT_TYPE, DISCRETE>(data, frames, n, result,
-			                                                                                    quantile);
-		} else {
-			auto &window_state = state.GetOrCreateWindowState();
-
-			//	Update the skip list
-			window_state.UpdateSkip(data, frames, included);
-
-			// Find the position(s) needed
-			rdata[ridx] = window_state.template WindowScalar<RESULT_TYPE, DISCRETE>(data, frames, n, result, quantile);
-
-			//	Save the previous state for next time
-			window_state.prevs = frames;
-		}
-	}
-};
-
-struct QuantileScalarFallback : QuantileOperation {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Execute(STATE &state, const INPUT_TYPE &key, AggregateInputData &input_data) {
-		state.AddElement(key, input_data);
-	}
-
-	template <class STATE>
-	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (state.v.empty()) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
-		D_ASSERT(bind_data.quantiles.size() == 1);
-		Interpolator<true> interp(bind_data.quantiles[0], state.v.size(), bind_data.desc);
-		auto interpolation_result = interp.InterpolateInternal<string_t>(state.v.data());
-		CreateSortKeyHelpers::DecodeSortKey(interpolation_result, finalize_data.result, finalize_data.result_idx,
-		                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Quantile List
-//===--------------------------------------------------------------------===//
-template <class CHILD_TYPE, bool DISCRETE>
-struct QuantileListOperation : QuantileOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.v.empty()) {
-			finalize_data.ReturnNull();
-			return;
-		}
-
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
-
-		auto &result = ListVector::GetEntry(finalize_data.result);
-		auto ridx = ListVector::GetListSize(finalize_data.result);
-		ListVector::Reserve(finalize_data.result, ridx + bind_data.quantiles.size());
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		auto v_t = state.v.data();
-		D_ASSERT(v_t);
-
-		auto &entry = target;
-		entry.offset = ridx;
-		idx_t lower = 0;
-		for (const auto &q : bind_data.order) {
-			const auto &quantile = bind_data.quantiles[q];
-			Interpolator<DISCRETE> interp(quantile, state.v.size(), bind_data.desc);
-			interp.begin = lower;
-			rdata[ridx + q] = interp.template Operation<typename STATE::InputType, CHILD_TYPE>(v_t, result);
-			lower = interp.FRN;
-		}
-		entry.length = bind_data.quantiles.size();
-
-		ListVector::SetListSize(finalize_data.result, entry.offset + entry.length);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                   const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &frames, Vector &list,
-	                   idx_t lidx) {
-		auto &state = *reinterpret_cast<STATE *>(l_state);
-		auto gstate = reinterpret_cast<const STATE *>(g_state);
-
-		auto &data = state.GetOrCreateWindowCursor(partition);
-		const auto &fmask = partition.filter_mask;
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
-
-		QuantileIncluded<INPUT_TYPE> included(fmask, data);
-		const auto n = FrameSize(included, frames);
-
-		// Result is a constant LIST<RESULT_TYPE> with a fixed length
-		if (!n) {
-			auto &lmask = FlatVector::Validity(list);
-			lmask.Set(lidx, false);
-			return;
-		}
-
-		if (gstate && gstate->HasTree()) {
-			gstate->GetWindowState().template WindowList<CHILD_TYPE, DISCRETE>(data, frames, n, list, lidx, bind_data);
-		} else {
-			auto &window_state = state.GetOrCreateWindowState();
-			window_state.UpdateSkip(data, frames, included);
-			window_state.template WindowList<CHILD_TYPE, DISCRETE>(data, frames, n, list, lidx, bind_data);
-			window_state.prevs = frames;
-		}
-	}
-};
-
-struct QuantileListFallback : QuantileOperation {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Execute(STATE &state, const INPUT_TYPE &key, AggregateInputData &input_data) {
-		state.AddElement(key, input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.v.empty()) {
-			finalize_data.ReturnNull();
-			return;
-		}
-
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
-
-		auto &result = ListVector::GetEntry(finalize_data.result);
-		auto ridx = ListVector::GetListSize(finalize_data.result);
-		ListVector::Reserve(finalize_data.result, ridx + bind_data.quantiles.size());
-
-		D_ASSERT(state.v.data());
-
-		auto &entry = target;
-		entry.offset = ridx;
-		idx_t lower = 0;
-		for (const auto &q : bind_data.order) {
-			const auto &quantile = bind_data.quantiles[q];
-			Interpolator<true> interp(quantile, state.v.size(), bind_data.desc);
-			interp.begin = lower;
-			auto interpolation_result = interp.InterpolateInternal<string_t>(state.v.data());
-			CreateSortKeyHelpers::DecodeSortKey(interpolation_result, result, ridx + q,
-			                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
-			lower = interp.FRN;
-		}
-		entry.length = bind_data.quantiles.size();
-
-		ListVector::SetListSize(finalize_data.result, entry.offset + entry.length);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Discrete Quantiles
-//===--------------------------------------------------------------------===//
-template <class OP>
-AggregateFunction GetDiscreteQuantileTemplated(const LogicalType &type) {
-	switch (type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::INT8:
-		return OP::template GetFunction<int8_t>(type);
-	case PhysicalType::INT16:
-		return OP::template GetFunction<int16_t>(type);
-	case PhysicalType::INT32:
-		return OP::template GetFunction<int32_t>(type);
-	case PhysicalType::INT64:
-		return OP::template GetFunction<int64_t>(type);
-	case PhysicalType::INT128:
-		return OP::template GetFunction<hugeint_t>(type);
-	case PhysicalType::FLOAT:
-		return OP::template GetFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return OP::template GetFunction<double>(type);
-	case PhysicalType::INTERVAL:
-		return OP::template GetFunction<interval_t>(type);
-	case PhysicalType::VARCHAR:
-		return OP::template GetFunction<string_t, QuantileStringType>(type);
-#endif
-	default:
-		return OP::GetFallback(type);
-	}
-}
-
-struct ScalarDiscreteQuantile {
-	template <typename INPUT_TYPE, class TYPE_OP = QuantileStandardType>
-	static AggregateFunction GetFunction(const LogicalType &type) {
-		using STATE = QuantileState<INPUT_TYPE, TYPE_OP>;
-		using OP = QuantileScalarOperation<true>;
-		auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, INPUT_TYPE, OP,
-		                                                       AggregateDestructorType::LEGACY>(type, type);
-#ifndef DUCKDB_SMALLER_BINARY
-		fun.window = OP::Window<STATE, INPUT_TYPE, INPUT_TYPE>;
-		fun.window_init = OP::WindowInit<STATE, INPUT_TYPE>;
-#endif
-		return fun;
-	}
-
-	static AggregateFunction GetFallback(const LogicalType &type) {
-		using STATE = QuantileState<string_t, QuantileStringType>;
-		using OP = QuantileScalarFallback;
-
-		AggregateFunction fun({type}, type, AggregateFunction::StateSize<STATE>,
-		                      AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
-		                      AggregateSortKeyHelpers::UnaryUpdate<STATE, OP>,
-		                      AggregateFunction::StateCombine<STATE, OP>,
-		                      AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, nullptr,
-		                      AggregateFunction::StateDestroy<STATE, OP>);
-		return fun;
-	}
-};
-
-template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction QuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) { // NOLINT
-	LogicalType result_type = LogicalType::LIST(child_type);
-	return AggregateFunction(
-	    {input_type}, result_type, AggregateFunction::StateSize<STATE>,
-	    AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
-	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>,
-	    nullptr, AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-struct ListDiscreteQuantile {
-	template <typename INPUT_TYPE, class TYPE_OP = QuantileStandardType>
-	static AggregateFunction GetFunction(const LogicalType &type) {
-		using STATE = QuantileState<INPUT_TYPE, TYPE_OP>;
-		using OP = QuantileListOperation<INPUT_TYPE, true>;
-		auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-#ifndef DUCKDB_SMALLER_BINARY
-		fun.window = OP::template Window<STATE, INPUT_TYPE, list_entry_t>;
-		fun.window_init = OP::template WindowInit<STATE, INPUT_TYPE>;
-#endif
-		return fun;
-	}
-
-	static AggregateFunction GetFallback(const LogicalType &type) {
-		using STATE = QuantileState<string_t, QuantileStringType>;
-		using OP = QuantileListFallback;
-
-		AggregateFunction fun({type}, LogicalType::LIST(type), AggregateFunction::StateSize<STATE>,
-		                      AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
-		                      AggregateSortKeyHelpers::UnaryUpdate<STATE, OP>,
-		                      AggregateFunction::StateCombine<STATE, OP>,
-		                      AggregateFunction::StateFinalize<STATE, list_entry_t, OP>, nullptr, nullptr,
-		                      AggregateFunction::StateDestroy<STATE, OP>);
-		return fun;
-	}
-};
-
-AggregateFunction GetDiscreteQuantile(const LogicalType &type) {
-	return GetDiscreteQuantileTemplated<ScalarDiscreteQuantile>(type);
-}
-
-AggregateFunction GetDiscreteQuantileList(const LogicalType &type) {
-	return GetDiscreteQuantileTemplated<ListDiscreteQuantile>(type);
-}
-
-//===--------------------------------------------------------------------===//
-// Continuous Quantiles
-//===--------------------------------------------------------------------===//
-template <class OP>
-AggregateFunction GetContinuousQuantileTemplated(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return OP::template GetFunction<int8_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::SMALLINT:
-		return OP::template GetFunction<int16_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::INTEGER:
-		return OP::template GetFunction<int32_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::BIGINT:
-		return OP::template GetFunction<int64_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::HUGEINT:
-		return OP::template GetFunction<hugeint_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::FLOAT:
-		return OP::template GetFunction<float, float>(type, type);
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::DOUBLE:
-		return OP::template GetFunction<double, double>(LogicalType::DOUBLE, LogicalType::DOUBLE);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return OP::template GetFunction<int16_t, int16_t>(type, type);
-		case PhysicalType::INT32:
-			return OP::template GetFunction<int32_t, int32_t>(type, type);
-		case PhysicalType::INT64:
-			return OP::template GetFunction<int64_t, int64_t>(type, type);
-		case PhysicalType::INT128:
-			return OP::template GetFunction<hugeint_t, hugeint_t>(type, type);
-		default:
-			throw NotImplementedException("Unimplemented continuous quantile DECIMAL aggregate");
-		}
-	case LogicalTypeId::DATE:
-		return OP::template GetFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-		return OP::template GetFunction<timestamp_t, timestamp_t>(type, type);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return OP::template GetFunction<dtime_t, dtime_t>(type, type);
-	default:
-		throw NotImplementedException("Unimplemented continuous quantile aggregate");
-	}
-}
-
-struct ScalarContinuousQuantile {
-	template <typename INPUT_TYPE, typename TARGET_TYPE>
-	static AggregateFunction GetFunction(const LogicalType &input_type, const LogicalType &target_type) {
-		using STATE = QuantileState<INPUT_TYPE, QuantileStandardType>;
-		using OP = QuantileScalarOperation<false>;
-		auto fun =
-		    AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP,
-		                                                AggregateDestructorType::LEGACY>(input_type, target_type);
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-#ifndef DUCKDB_SMALLER_BINARY
-		fun.window = OP::template Window<STATE, INPUT_TYPE, TARGET_TYPE>;
-		fun.window_init = OP::template WindowInit<STATE, INPUT_TYPE>;
-#endif
-		return fun;
-	}
-};
-
-struct ListContinuousQuantile {
-	template <typename INPUT_TYPE, typename TARGET_TYPE>
-	static AggregateFunction GetFunction(const LogicalType &input_type, const LogicalType &target_type) {
-		using STATE = QuantileState<INPUT_TYPE, QuantileStandardType>;
-		using OP = QuantileListOperation<TARGET_TYPE, false>;
-		auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(input_type, target_type);
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-#ifndef DUCKDB_SMALLER_BINARY
-		fun.window = OP::template Window<STATE, INPUT_TYPE, list_entry_t>;
-		fun.window_init = OP::template WindowInit<STATE, INPUT_TYPE>;
-#endif
-		return fun;
-	}
-};
-
-AggregateFunction GetContinuousQuantile(const LogicalType &type) {
-	return GetContinuousQuantileTemplated<ScalarContinuousQuantile>(type);
-}
-
-AggregateFunction GetContinuousQuantileList(const LogicalType &type) {
-	return GetContinuousQuantileTemplated<ListContinuousQuantile>(type);
-}
-
-//===--------------------------------------------------------------------===//
-// Quantile binding
-//===--------------------------------------------------------------------===//
-static const Value &CheckQuantile(const Value &quantile_val) {
-	if (quantile_val.IsNull()) {
-		throw BinderException("QUANTILE parameter cannot be NULL");
-	}
-	auto quantile = quantile_val.GetValue<double>();
-	if (quantile < -1 || quantile > 1) {
-		throw BinderException("QUANTILE can only take parameters in the range [-1, 1]");
-	}
-	if (Value::IsNan(quantile)) {
-		throw BinderException("QUANTILE parameter cannot be NaN");
-	}
-
-	return quantile_val;
-}
-
-unique_ptr<FunctionData> BindQuantile(ClientContext &context, AggregateFunction &function,
-                                      vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() < 2) {
-		throw BinderException("QUANTILE requires a range argument between [0, 1]");
-	}
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("QUANTILE can only take constant parameters");
-	}
-	Value quantile_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	if (quantile_val.IsNull()) {
-		throw BinderException("QUANTILE argument must not be NULL");
-	}
-	vector<Value> quantiles;
-	switch (quantile_val.type().id()) {
-	case LogicalTypeId::LIST:
-		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckQuantile(element_val));
-		}
-		break;
-	case LogicalTypeId::ARRAY:
-		for (const auto &element_val : ArrayValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckQuantile(element_val));
-		}
-		break;
-	default:
-		quantiles.push_back(CheckQuantile(quantile_val));
-		break;
-	}
-
-	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_uniq<QuantileBindData>(quantiles);
-}
-
-//===--------------------------------------------------------------------===//
-// Function definitions
-//===--------------------------------------------------------------------===//
-static bool CanInterpolate(const LogicalType &type) {
-	if (type.HasAlias()) {
-		return false;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return true;
-	default:
-		return false;
-	}
-}
-
-struct MedianFunction {
-	static AggregateFunction GetAggregate(const LogicalType &type) {
-		auto fun = CanInterpolate(type) ? GetContinuousQuantile(type) : GetDiscreteQuantile(type);
-		fun.name = "median";
-		fun.serialize = QuantileBindData::Serialize;
-		fun.deserialize = Deserialize;
-		return fun;
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto bind_data = QuantileBindData::Deserialize(deserializer, function);
-
-		auto &input_type = function.arguments[0];
-		function = GetAggregate(input_type);
-		return bind_data;
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function = GetAggregate(arguments[0]->return_type);
-		return make_uniq<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
-	}
-};
-
-struct DiscreteQuantileListFunction {
-	static AggregateFunction GetAggregate(const LogicalType &type) {
-		auto fun = GetDiscreteQuantileList(type);
-		fun.name = "quantile_disc";
-		fun.bind = Bind;
-		fun.serialize = QuantileBindData::Serialize;
-		fun.deserialize = Deserialize;
-		// temporarily push an argument so we can bind the actual quantile
-		fun.arguments.emplace_back(LogicalType::LIST(LogicalType::DOUBLE));
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return fun;
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto bind_data = QuantileBindData::Deserialize(deserializer, function);
-
-		auto &input_type = function.arguments[0];
-		function = GetAggregate(input_type);
-		return bind_data;
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function = GetAggregate(arguments[0]->return_type);
-		return BindQuantile(context, function, arguments);
-	}
-};
-
-struct DiscreteQuantileFunction {
-	static AggregateFunction GetAggregate(const LogicalType &type) {
-		auto fun = GetDiscreteQuantile(type);
-		fun.name = "quantile_disc";
-		fun.bind = Bind;
-		fun.serialize = QuantileBindData::Serialize;
-		fun.deserialize = Deserialize;
-		// temporarily push an argument so we can bind the actual quantile
-		fun.arguments.emplace_back(LogicalType::DOUBLE);
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return fun;
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto bind_data = QuantileBindData::Deserialize(deserializer, function);
-		auto &quantile_data = bind_data->Cast<QuantileBindData>();
-
-		auto &input_type = function.arguments[0];
-		if (quantile_data.quantiles.size() == 1) {
-			function = GetAggregate(input_type);
-		} else {
-			function = DiscreteQuantileListFunction::GetAggregate(input_type);
-		}
-		return bind_data;
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function = GetAggregate(arguments[0]->return_type);
-		return BindQuantile(context, function, arguments);
-	}
-};
-
-struct ContinuousQuantileFunction {
-	static AggregateFunction GetAggregate(const LogicalType &type) {
-		auto fun = GetContinuousQuantile(type);
-		fun.name = "quantile_cont";
-		fun.bind = Bind;
-		fun.serialize = QuantileBindData::Serialize;
-		fun.deserialize = Deserialize;
-		// temporarily push an argument so we can bind the actual quantile
-		fun.arguments.emplace_back(LogicalType::DOUBLE);
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return fun;
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto bind_data = QuantileBindData::Deserialize(deserializer, function);
-
-		auto &input_type = function.arguments[0];
-		function = GetAggregate(input_type);
-		return bind_data;
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function = GetAggregate(function.arguments[0].id() == LogicalTypeId::DECIMAL ? arguments[0]->return_type
-		                                                                             : function.arguments[0]);
-		return BindQuantile(context, function, arguments);
-	}
-};
-
-struct ContinuousQuantileListFunction {
-	static AggregateFunction GetAggregate(const LogicalType &type) {
-		auto fun = GetContinuousQuantileList(type);
-		fun.name = "quantile_cont";
-		fun.bind = Bind;
-		fun.serialize = QuantileBindData::Serialize;
-		fun.deserialize = Deserialize;
-		// temporarily push an argument so we can bind the actual quantile
-		auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
-		fun.arguments.push_back(list_of_double);
-		fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return fun;
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto bind_data = QuantileBindData::Deserialize(deserializer, function);
-
-		auto &input_type = function.arguments[0];
-		function = GetAggregate(input_type);
-		return bind_data;
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function = GetAggregate(function.arguments[0].id() == LogicalTypeId::DECIMAL ? arguments[0]->return_type
-		                                                                             : function.arguments[0]);
-		return BindQuantile(context, function, arguments);
-	}
-};
-
-template <class OP>
-AggregateFunction EmptyQuantileFunction(LogicalType input, LogicalType result, const LogicalType &extra_arg) {
-	AggregateFunction fun({std::move(input)}, std::move(result), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                      OP::Bind);
-	if (extra_arg.id() != LogicalTypeId::INVALID) {
-		fun.arguments.push_back(extra_arg);
-	}
-	fun.serialize = QuantileBindData::Serialize;
-	fun.deserialize = OP::Deserialize;
-	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	return fun;
-}
-
-AggregateFunctionSet MedianFun::GetFunctions() {
-	AggregateFunctionSet set("median");
-	set.AddFunction(EmptyQuantileFunction<MedianFunction>(LogicalType::ANY, LogicalType::ANY, LogicalTypeId::INVALID));
-	return set;
-}
-
-AggregateFunctionSet QuantileDiscFun::GetFunctions() {
-	AggregateFunctionSet set("quantile_disc");
-	set.AddFunction(
-	    EmptyQuantileFunction<DiscreteQuantileFunction>(LogicalType::ANY, LogicalType::ANY, LogicalType::DOUBLE));
-	set.AddFunction(EmptyQuantileFunction<DiscreteQuantileListFunction>(LogicalType::ANY, LogicalType::ANY,
-	                                                                    LogicalType::LIST(LogicalType::DOUBLE)));
-	// this function is here for deserialization - it cannot be called by users
-	set.AddFunction(
-	    EmptyQuantileFunction<DiscreteQuantileFunction>(LogicalType::ANY, LogicalType::ANY, LogicalType::INVALID));
-	return set;
-}
-
-vector<LogicalType> GetContinuousQuantileTypes() {
-	return {LogicalType::TINYINT,   LogicalType::SMALLINT, LogicalType::INTEGER,      LogicalType::BIGINT,
-	        LogicalType::HUGEINT,   LogicalType::FLOAT,    LogicalType::DOUBLE,       LogicalType::DATE,
-	        LogicalType::TIMESTAMP, LogicalType::TIME,     LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ};
-}
-
-AggregateFunctionSet QuantileContFun::GetFunctions() {
-	AggregateFunctionSet quantile_cont("quantile_cont");
-	quantile_cont.AddFunction(EmptyQuantileFunction<ContinuousQuantileFunction>(
-	    LogicalTypeId::DECIMAL, LogicalTypeId::DECIMAL, LogicalType::DOUBLE));
-	quantile_cont.AddFunction(EmptyQuantileFunction<ContinuousQuantileListFunction>(
-	    LogicalTypeId::DECIMAL, LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)));
-	for (const auto &type : GetContinuousQuantileTypes()) {
-		quantile_cont.AddFunction(EmptyQuantileFunction<ContinuousQuantileFunction>(type, type, LogicalType::DOUBLE));
-		quantile_cont.AddFunction(
-		    EmptyQuantileFunction<ContinuousQuantileListFunction>(type, type, LogicalType::LIST(LogicalType::DOUBLE)));
-	}
-	return quantile_cont;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/reservoir_quantile.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/reservoir_quantile.cpp
deleted file mode 100644
index 8c332500d..000000000
--- a/src/duckdb/extension/core_functions/aggregate/holistic/reservoir_quantile.cpp
+++ /dev/null
@@ -1,449 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/reservoir_sample.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-#include <algorithm>
-#include <stdlib.h>
-
-namespace duckdb {
-
-template <typename T>
-struct ReservoirQuantileState {
-	T *v;
-	idx_t len;
-	idx_t pos;
-	BaseReservoirSampling *r_samp;
-
-	void Resize(idx_t new_len) {
-		if (new_len <= len) {
-			return;
-		}
-		T *old_v = v;
-		v = (T *)realloc(v, new_len * sizeof(T));
-		if (!v) {
-			free(old_v);
-			throw InternalException("Memory allocation failure");
-		}
-		len = new_len;
-	}
-
-	void ReplaceElement(T &input) {
-		v[r_samp->min_weighted_entry_index] = input;
-		r_samp->ReplaceElement();
-	}
-
-	void FillReservoir(idx_t sample_size, T element) {
-		if (pos < sample_size) {
-			v[pos++] = element;
-			r_samp->InitializeReservoirWeights(pos, len);
-		} else {
-			D_ASSERT(r_samp->next_index_to_sample >= r_samp->num_entries_to_skip_b4_next_sample);
-			if (r_samp->next_index_to_sample == r_samp->num_entries_to_skip_b4_next_sample) {
-				ReplaceElement(element);
-			}
-		}
-	}
-};
-
-struct ReservoirQuantileBindData : public FunctionData {
-	ReservoirQuantileBindData() {
-	}
-	ReservoirQuantileBindData(double quantile_p, idx_t sample_size_p)
-	    : quantiles(1, quantile_p), sample_size(sample_size_p) {
-	}
-
-	ReservoirQuantileBindData(vector<double> quantiles_p, idx_t sample_size_p)
-	    : quantiles(std::move(quantiles_p)), sample_size(sample_size_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<ReservoirQuantileBindData>(quantiles, sample_size);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<ReservoirQuantileBindData>();
-		return quantiles == other.quantiles && sample_size == other.sample_size;
-	}
-
-	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                      const AggregateFunction &function) {
-		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
-		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
-		serializer.WriteProperty(101, "sample_size", bind_data.sample_size);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
-		auto result = make_uniq<ReservoirQuantileBindData>();
-		deserializer.ReadProperty(100, "quantiles", result->quantiles);
-		deserializer.ReadProperty(101, "sample_size", result->sample_size);
-		return std::move(result);
-	}
-
-	vector<double> quantiles;
-	idx_t sample_size;
-};
-
-struct ReservoirQuantileOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.v = nullptr;
-		state.len = 0;
-		state.pos = 0;
-		state.r_samp = nullptr;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		auto &bind_data = unary_input.input.bind_data->template Cast<ReservoirQuantileBindData>();
-		if (state.pos == 0) {
-			state.Resize(bind_data.sample_size);
-		}
-		if (!state.r_samp) {
-			state.r_samp = new BaseReservoirSampling();
-		}
-		D_ASSERT(state.v);
-		state.FillReservoir(bind_data.sample_size, input);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (source.pos == 0) {
-			return;
-		}
-		if (target.pos == 0) {
-			target.Resize(source.len);
-		}
-		if (!target.r_samp) {
-			target.r_samp = new BaseReservoirSampling();
-		}
-		for (idx_t src_idx = 0; src_idx < source.pos; src_idx++) {
-			target.FillReservoir(target.len, source.v[src_idx]);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.v) {
-			free(state.v);
-			state.v = nullptr;
-		}
-		if (state.r_samp) {
-			delete state.r_samp;
-			state.r_samp = nullptr;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct ReservoirQuantileScalarOperation : public ReservoirQuantileOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.pos == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		D_ASSERT(state.v);
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->template Cast<ReservoirQuantileBindData>();
-		auto v_t = state.v;
-		D_ASSERT(bind_data.quantiles.size() == 1);
-		auto offset = (idx_t)((double)(state.pos - 1) * bind_data.quantiles[0]);
-		std::nth_element(v_t, v_t + offset, v_t + state.pos);
-		target = v_t[offset];
-	}
-};
-
-AggregateFunction GetReservoirQuantileAggregateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT8:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int8_t>, int8_t, int8_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::TINYINT,
-		                                                                                     LogicalType::TINYINT);
-
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int16_t>, int16_t, int16_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::SMALLINT,
-		                                                                                     LogicalType::SMALLINT);
-
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int32_t>, int32_t, int32_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::INTEGER,
-		                                                                                     LogicalType::INTEGER);
-
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int64_t>, int64_t, int64_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::BIGINT,
-		                                                                                     LogicalType::BIGINT);
-
-	case PhysicalType::INT128:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<hugeint_t>, hugeint_t, hugeint_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::HUGEINT,
-		                                                                                     LogicalType::HUGEINT);
-	case PhysicalType::FLOAT:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<float>, float, float,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::FLOAT,
-		                                                                                     LogicalType::FLOAT);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<double>, double, double,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::DOUBLE,
-		                                                                                     LogicalType::DOUBLE);
-	default:
-		throw InternalException("Unimplemented reservoir quantile aggregate");
-	}
-}
-
-template <class CHILD_TYPE>
-struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.pos == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-
-		D_ASSERT(finalize_data.input.bind_data);
-		auto &bind_data = finalize_data.input.bind_data->template Cast<ReservoirQuantileBindData>();
-
-		auto &result = ListVector::GetEntry(finalize_data.result);
-		auto ridx = ListVector::GetListSize(finalize_data.result);
-		ListVector::Reserve(finalize_data.result, ridx + bind_data.quantiles.size());
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		auto v_t = state.v;
-		D_ASSERT(v_t);
-
-		auto &entry = target;
-		entry.offset = ridx;
-		entry.length = bind_data.quantiles.size();
-		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data.quantiles[q];
-			auto offset = (idx_t)((double)(state.pos - 1) * quantile);
-			std::nth_element(v_t, v_t + offset, v_t + state.pos);
-			rdata[ridx + q] = v_t[offset];
-		}
-
-		ListVector::SetListSize(finalize_data.result, entry.offset + entry.length);
-	}
-};
-
-template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction ReservoirQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
-	LogicalType result_type = LogicalType::LIST(child_type);
-	return AggregateFunction(
-	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>,
-	    nullptr, AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <typename INPUT_TYPE, typename SAVE_TYPE>
-AggregateFunction GetTypedReservoirQuantileListAggregateFunction(const LogicalType &type) {
-	using STATE = ReservoirQuantileState<SAVE_TYPE>;
-	using OP = ReservoirQuantileListOperation<INPUT_TYPE>;
-	auto fun = ReservoirQuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
-	return fun;
-}
-
-AggregateFunction GetReservoirQuantileListAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedReservoirQuantileListAggregateFunction<int8_t, int8_t>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedReservoirQuantileListAggregateFunction<int16_t, int16_t>(type);
-	case LogicalTypeId::INTEGER:
-		return GetTypedReservoirQuantileListAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::BIGINT:
-		return GetTypedReservoirQuantileListAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedReservoirQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-	case LogicalTypeId::FLOAT:
-		return GetTypedReservoirQuantileListAggregateFunction<float, float>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedReservoirQuantileListAggregateFunction<double, double>(type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedReservoirQuantileListAggregateFunction<int16_t, int16_t>(type);
-		case PhysicalType::INT32:
-			return GetTypedReservoirQuantileListAggregateFunction<int32_t, int32_t>(type);
-		case PhysicalType::INT64:
-			return GetTypedReservoirQuantileListAggregateFunction<int64_t, int64_t>(type);
-		case PhysicalType::INT128:
-			return GetTypedReservoirQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-		default:
-			throw NotImplementedException("Unimplemented reservoir quantile list aggregate");
-		}
-	default:
-		// TODO: Add quantitative temporal types
-		throw NotImplementedException("Unimplemented reservoir quantile list aggregate");
-	}
-}
-
-static double CheckReservoirQuantile(const Value &quantile_val) {
-	if (quantile_val.IsNull()) {
-		throw BinderException("RESERVOIR_QUANTILE QUANTILE parameter cannot be NULL");
-	}
-	auto quantile = quantile_val.GetValue<double>();
-	if (quantile < 0 || quantile > 1) {
-		throw BinderException("RESERVOIR_QUANTILE can only take parameters in the range [0, 1]");
-	}
-	return quantile;
-}
-
-unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, AggregateFunction &function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() >= 2);
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("RESERVOIR_QUANTILE can only take constant quantile parameters");
-	}
-	Value quantile_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	vector<double> quantiles;
-	if (quantile_val.type().id() != LogicalTypeId::LIST) {
-		quantiles.push_back(CheckReservoirQuantile(quantile_val));
-	} else {
-		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckReservoirQuantile(element_val));
-		}
-	}
-
-	if (arguments.size() == 2) {
-		// remove the quantile argument so we can use the unary aggregate
-		if (function.arguments.size() == 2) {
-			Function::EraseArgument(function, arguments, arguments.size() - 1);
-		} else {
-			arguments.pop_back();
-		}
-		return make_uniq<ReservoirQuantileBindData>(quantiles, 8192ULL);
-	}
-	if (!arguments[2]->IsFoldable()) {
-		throw BinderException("RESERVOIR_QUANTILE can only take constant sample size parameters");
-	}
-	Value sample_size_val = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
-	if (sample_size_val.IsNull()) {
-		throw BinderException("Size of the RESERVOIR_QUANTILE sample cannot be NULL");
-	}
-	auto sample_size = sample_size_val.GetValue<int32_t>();
-
-	if (sample_size_val.IsNull() || sample_size <= 0) {
-		throw BinderException("Size of the RESERVOIR_QUANTILE sample must be bigger than 0");
-	}
-
-	// remove the quantile arguments so we can use the unary aggregate
-	if (function.arguments.size() == arguments.size()) {
-		Function::EraseArgument(function, arguments, arguments.size() - 1);
-		Function::EraseArgument(function, arguments, arguments.size() - 1);
-	} else {
-		arguments.pop_back();
-		arguments.pop_back();
-	}
-	return make_uniq<ReservoirQuantileBindData>(quantiles, NumericCast<idx_t>(sample_size));
-}
-
-unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, AggregateFunction &function,
-                                                      vector<unique_ptr<Expression>> &arguments) {
-	function = GetReservoirQuantileAggregateFunction(arguments[0]->return_type.InternalType());
-	auto bind_data = BindReservoirQuantile(context, function, arguments);
-	function.name = "reservoir_quantile";
-	function.serialize = ReservoirQuantileBindData::Serialize;
-	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	return bind_data;
-}
-
-AggregateFunction GetReservoirQuantileAggregate(PhysicalType type) {
-	auto fun = GetReservoirQuantileAggregateFunction(type);
-	fun.bind = BindReservoirQuantile;
-	fun.serialize = ReservoirQuantileBindData::Serialize;
-	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	// temporarily push an argument so we can bind the actual quantile
-	fun.arguments.emplace_back(LogicalType::DOUBLE);
-	return fun;
-}
-
-unique_ptr<FunctionData> BindReservoirQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                          vector<unique_ptr<Expression>> &arguments) {
-	function = GetReservoirQuantileListAggregateFunction(arguments[0]->return_type);
-	auto bind_data = BindReservoirQuantile(context, function, arguments);
-	function.serialize = ReservoirQuantileBindData::Serialize;
-	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	function.name = "reservoir_quantile";
-	return bind_data;
-}
-
-AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
-	auto fun = GetReservoirQuantileListAggregateFunction(type);
-	fun.bind = BindReservoirQuantile;
-	fun.serialize = ReservoirQuantileBindData::Serialize;
-	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	// temporarily push an argument so we can bind the actual quantile
-	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
-	fun.arguments.push_back(list_of_double);
-	return fun;
-}
-
-static void DefineReservoirQuantile(AggregateFunctionSet &set, const LogicalType &type) {
-	//	Four versions: type, scalar/list[, count]
-	auto fun = GetReservoirQuantileAggregate(type.InternalType());
-	set.AddFunction(fun);
-
-	fun.arguments.emplace_back(LogicalType::INTEGER);
-	set.AddFunction(fun);
-
-	// List variants
-	fun = GetReservoirQuantileListAggregate(type);
-	set.AddFunction(fun);
-
-	fun.arguments.emplace_back(LogicalType::INTEGER);
-	set.AddFunction(fun);
-}
-
-static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const vector<LogicalType> &arguments,
-                                                const LogicalType &return_value) {
-	AggregateFunction fun(arguments, return_value, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                      BindReservoirQuantileDecimal);
-	fun.serialize = ReservoirQuantileBindData::Serialize;
-	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	set.AddFunction(fun);
-
-	fun.arguments.emplace_back(LogicalType::INTEGER);
-	set.AddFunction(fun);
-}
-
-AggregateFunctionSet ReservoirQuantileFun::GetFunctions() {
-	AggregateFunctionSet reservoir_quantile;
-
-	// DECIMAL
-	GetReservoirQuantileDecimalFunction(reservoir_quantile, {LogicalTypeId::DECIMAL, LogicalType::DOUBLE},
-	                                    LogicalTypeId::DECIMAL);
-	GetReservoirQuantileDecimalFunction(reservoir_quantile,
-	                                    {LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)},
-	                                    LogicalType::LIST(LogicalTypeId::DECIMAL));
-
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::TINYINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::SMALLINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::INTEGER);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::BIGINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::HUGEINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::FLOAT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::DOUBLE);
-	return reservoir_quantile;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/nested/binned_histogram.cpp b/src/duckdb/extension/core_functions/aggregate/nested/binned_histogram.cpp
deleted file mode 100644
index fc184b8bb..000000000
--- a/src/duckdb/extension/core_functions/aggregate/nested/binned_histogram.cpp
+++ /dev/null
@@ -1,410 +0,0 @@
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "core_functions/aggregate/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "core_functions/aggregate/histogram_helpers.hpp"
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct HistogramBinState {
-	using TYPE = T;
-
-	unsafe_vector<T> *bin_boundaries;
-	unsafe_vector<idx_t> *counts;
-
-	void Initialize() {
-		bin_boundaries = nullptr;
-		counts = nullptr;
-	}
-
-	void Destroy() {
-		if (bin_boundaries) {
-			delete bin_boundaries;
-			bin_boundaries = nullptr;
-		}
-		if (counts) {
-			delete counts;
-			counts = nullptr;
-		}
-	}
-
-	bool IsSet() {
-		return bin_boundaries;
-	}
-
-	template <class OP>
-	void InitializeBins(Vector &bin_vector, idx_t count, idx_t pos, AggregateInputData &aggr_input) {
-		bin_boundaries = new unsafe_vector<T>();
-		counts = new unsafe_vector<idx_t>();
-		UnifiedVectorFormat bin_data;
-		bin_vector.ToUnifiedFormat(count, bin_data);
-		auto bin_counts = UnifiedVectorFormat::GetData<list_entry_t>(bin_data);
-		auto bin_index = bin_data.sel->get_index(pos);
-		auto bin_list = bin_counts[bin_index];
-		if (!bin_data.validity.RowIsValid(bin_index)) {
-			throw BinderException("Histogram bin list cannot be NULL");
-		}
-
-		auto &bin_child = ListVector::GetEntry(bin_vector);
-		auto bin_count = ListVector::GetListSize(bin_vector);
-		UnifiedVectorFormat bin_child_data;
-		auto extra_state = OP::CreateExtraState(bin_count);
-		OP::PrepareData(bin_child, bin_count, extra_state, bin_child_data);
-
-		bin_boundaries->reserve(bin_list.length);
-		for (idx_t i = 0; i < bin_list.length; i++) {
-			auto bin_child_idx = bin_child_data.sel->get_index(bin_list.offset + i);
-			if (!bin_child_data.validity.RowIsValid(bin_child_idx)) {
-				throw BinderException("Histogram bin entry cannot be NULL");
-			}
-			bin_boundaries->push_back(OP::template ExtractValue<T>(bin_child_data, bin_list.offset + i, aggr_input));
-		}
-		// sort the bin boundaries
-		std::sort(bin_boundaries->begin(), bin_boundaries->end());
-		// ensure there are no duplicate bin boundaries
-		for (idx_t i = 1; i < bin_boundaries->size(); i++) {
-			if (Equals::Operation((*bin_boundaries)[i - 1], (*bin_boundaries)[i])) {
-				bin_boundaries->erase_at(i);
-				i--;
-			}
-		}
-
-		counts->resize(bin_list.length + 1);
-	}
-};
-
-struct HistogramBinFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.Initialize();
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.Destroy();
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
-		if (!source.bin_boundaries) {
-			// nothing to combine
-			return;
-		}
-		if (!target.bin_boundaries) {
-			// target does not have bin boundaries - copy everything over
-			target.bin_boundaries = new unsafe_vector<typename STATE::TYPE>();
-			target.counts = new unsafe_vector<idx_t>();
-			*target.bin_boundaries = *source.bin_boundaries;
-			*target.counts = *source.counts;
-		} else {
-			// both source and target have bin boundaries
-			if (*target.bin_boundaries != *source.bin_boundaries) {
-				throw NotImplementedException(
-				    "Histogram - cannot combine histograms with different bin boundaries. "
-				    "Bin boundaries must be the same for all histograms within the same group");
-			}
-			if (target.counts->size() != source.counts->size()) {
-				throw InternalException("Histogram combine - bin boundaries are the same but counts are different");
-			}
-			D_ASSERT(target.counts->size() == source.counts->size());
-			for (idx_t bin_idx = 0; bin_idx < target.counts->size(); bin_idx++) {
-				(*target.counts)[bin_idx] += (*source.counts)[bin_idx];
-			}
-		}
-	}
-};
-
-struct HistogramRange {
-	static constexpr bool EXACT = false;
-
-	template <class T>
-	static idx_t GetBin(T value, const unsafe_vector<T> &bin_boundaries) {
-		auto entry = std::lower_bound(bin_boundaries.begin(), bin_boundaries.end(), value);
-		return UnsafeNumericCast<idx_t>(entry - bin_boundaries.begin());
-	}
-};
-
-struct HistogramExact {
-	static constexpr bool EXACT = true;
-
-	template <class T>
-	static idx_t GetBin(T value, const unsafe_vector<T> &bin_boundaries) {
-		auto entry = std::lower_bound(bin_boundaries.begin(), bin_boundaries.end(), value);
-		if (entry == bin_boundaries.end() || !(*entry == value)) {
-			// entry not found - return last bucket
-			return bin_boundaries.size();
-		}
-		return UnsafeNumericCast<idx_t>(entry - bin_boundaries.begin());
-	}
-};
-
-template <class OP, class T, class HIST>
-static void HistogramBinUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count,
-                                       Vector &state_vector, idx_t count) {
-	auto &input = inputs[0];
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-
-	auto &bin_vector = inputs[1];
-
-	auto extra_state = OP::CreateExtraState(count);
-	UnifiedVectorFormat input_data;
-	OP::PrepareData(input, count, extra_state, input_data);
-
-	auto states = UnifiedVectorFormat::GetData<HistogramBinState<T> *>(sdata);
-	auto data = UnifiedVectorFormat::GetData<T>(input_data);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = input_data.sel->get_index(i);
-		if (!input_data.validity.RowIsValid(idx)) {
-			continue;
-		}
-		auto &state = *states[sdata.sel->get_index(i)];
-		if (!state.IsSet()) {
-			state.template InitializeBins<OP>(bin_vector, count, i, aggr_input);
-		}
-		auto bin_entry = HIST::template GetBin<T>(data[idx], *state.bin_boundaries);
-		++(*state.counts)[bin_entry];
-	}
-}
-
-static bool SupportsOtherBucket(const LogicalType &type) {
-	if (type.HasAlias()) {
-		return false;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::LIST:
-		return true;
-	default:
-		return false;
-	}
-}
-static Value OtherBucketValue(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return Value::MaximumValue(type);
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-		return Value::Infinity(type);
-	case LogicalTypeId::VARCHAR:
-		return Value("");
-	case LogicalTypeId::BLOB:
-		return Value::BLOB("");
-	case LogicalTypeId::STRUCT: {
-		// for structs we can set all child members to NULL
-		auto &child_types = StructType::GetChildTypes(type);
-		child_list_t<Value> child_list;
-		for (auto &child_type : child_types) {
-			child_list.push_back(make_pair(child_type.first, Value(child_type.second)));
-		}
-		return Value::STRUCT(std::move(child_list));
-	}
-	case LogicalTypeId::LIST:
-		return Value::LIST(ListType::GetChildType(type), vector<Value>());
-	default:
-		throw InternalException("Unsupported type for other bucket");
-	}
-}
-
-static void IsHistogramOtherBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input_type = args.data[0].GetType();
-	if (!SupportsOtherBucket(input_type)) {
-		result.Reference(Value::BOOLEAN(false));
-		return;
-	}
-	auto v = OtherBucketValue(input_type);
-	Vector ref(v);
-	VectorOperations::NotDistinctFrom(args.data[0], ref, result, args.size());
-}
-
-template <class OP, class T>
-static void HistogramBinFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
-                                         idx_t offset) {
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = UnifiedVectorFormat::GetData<HistogramBinState<T> *>(sdata);
-
-	auto &mask = FlatVector::Validity(result);
-	auto old_len = ListVector::GetListSize(result);
-	idx_t new_entries = 0;
-	bool supports_other_bucket = SupportsOtherBucket(MapType::KeyType(result.GetType()));
-	// figure out how much space we need
-	for (idx_t i = 0; i < count; i++) {
-		auto &state = *states[sdata.sel->get_index(i)];
-		if (!state.bin_boundaries) {
-			continue;
-		}
-		new_entries += state.bin_boundaries->size();
-		if (state.counts->back() > 0 && supports_other_bucket) {
-			// overflow bucket has entries
-			new_entries++;
-		}
-	}
-	// reserve space in the list vector
-	ListVector::Reserve(result, old_len + new_entries);
-	auto &keys = MapVector::GetKeys(result);
-	auto &values = MapVector::GetValues(result);
-	auto list_entries = FlatVector::GetData<list_entry_t>(result);
-	auto count_entries = FlatVector::GetData<uint64_t>(values);
-
-	idx_t current_offset = old_len;
-	for (idx_t i = 0; i < count; i++) {
-		const auto rid = i + offset;
-		auto &state = *states[sdata.sel->get_index(i)];
-		if (!state.bin_boundaries) {
-			mask.SetInvalid(rid);
-			continue;
-		}
-
-		auto &list_entry = list_entries[rid];
-		list_entry.offset = current_offset;
-		for (idx_t bin_idx = 0; bin_idx < state.bin_boundaries->size(); bin_idx++) {
-			OP::template HistogramFinalize<T>((*state.bin_boundaries)[bin_idx], keys, current_offset);
-			count_entries[current_offset] = (*state.counts)[bin_idx];
-			current_offset++;
-		}
-		if (state.counts->back() > 0 && supports_other_bucket) {
-			// add overflow bucket ("others")
-			// set bin boundary to NULL for overflow bucket
-			keys.SetValue(current_offset, OtherBucketValue(keys.GetType()));
-			count_entries[current_offset] = state.counts->back();
-			current_offset++;
-		}
-		list_entry.length = current_offset - list_entry.offset;
-	}
-	D_ASSERT(current_offset == old_len + new_entries);
-	ListVector::SetListSize(result, current_offset);
-	result.Verify(count);
-}
-
-template <class OP, class T, class HIST>
-static AggregateFunction GetHistogramBinFunction(const LogicalType &type) {
-	using STATE_TYPE = HistogramBinState<T>;
-
-	const char *function_name = HIST::EXACT ? "histogram_exact" : "histogram";
-
-	auto struct_type = LogicalType::MAP(type, LogicalType::UBIGINT);
-	return AggregateFunction(
-	    function_name, {type, LogicalType::LIST(type)}, struct_type, AggregateFunction::StateSize<STATE_TYPE>,
-	    AggregateFunction::StateInitialize<STATE_TYPE, HistogramBinFunction>, HistogramBinUpdateFunction<OP, T, HIST>,
-	    AggregateFunction::StateCombine<STATE_TYPE, HistogramBinFunction>, HistogramBinFinalizeFunction<OP, T>, nullptr,
-	    nullptr, AggregateFunction::StateDestroy<STATE_TYPE, HistogramBinFunction>);
-}
-
-template <class HIST>
-AggregateFunction GetHistogramBinFunction(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::DECIMAL) {
-		return GetHistogramBinFunction<HIST>(LogicalType::DOUBLE);
-	}
-	switch (type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::BOOL:
-		return GetHistogramBinFunction<HistogramFunctor, bool, HIST>(type);
-	case PhysicalType::UINT8:
-		return GetHistogramBinFunction<HistogramFunctor, uint8_t, HIST>(type);
-	case PhysicalType::UINT16:
-		return GetHistogramBinFunction<HistogramFunctor, uint16_t, HIST>(type);
-	case PhysicalType::UINT32:
-		return GetHistogramBinFunction<HistogramFunctor, uint32_t, HIST>(type);
-	case PhysicalType::UINT64:
-		return GetHistogramBinFunction<HistogramFunctor, uint64_t, HIST>(type);
-	case PhysicalType::INT8:
-		return GetHistogramBinFunction<HistogramFunctor, int8_t, HIST>(type);
-	case PhysicalType::INT16:
-		return GetHistogramBinFunction<HistogramFunctor, int16_t, HIST>(type);
-	case PhysicalType::INT32:
-		return GetHistogramBinFunction<HistogramFunctor, int32_t, HIST>(type);
-	case PhysicalType::INT64:
-		return GetHistogramBinFunction<HistogramFunctor, int64_t, HIST>(type);
-	case PhysicalType::FLOAT:
-		return GetHistogramBinFunction<HistogramFunctor, float, HIST>(type);
-	case PhysicalType::DOUBLE:
-		return GetHistogramBinFunction<HistogramFunctor, double, HIST>(type);
-	case PhysicalType::VARCHAR:
-		return GetHistogramBinFunction<HistogramStringFunctor, string_t, HIST>(type);
-#endif
-	default:
-		return GetHistogramBinFunction<HistogramGenericFunctor, string_t, HIST>(type);
-	}
-}
-
-template <class HIST>
-unique_ptr<FunctionData> HistogramBinBindFunction(ClientContext &context, AggregateFunction &function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-	for (auto &arg : arguments) {
-		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-	}
-
-	function = GetHistogramBinFunction<HIST>(arguments[0]->return_type);
-	return nullptr;
-}
-
-AggregateFunction HistogramFun::BinnedHistogramFunction() {
-	return AggregateFunction("histogram", {LogicalType::ANY, LogicalType::LIST(LogicalType::ANY)}, LogicalTypeId::MAP,
-	                         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                         HistogramBinBindFunction<HistogramRange>, nullptr);
-}
-
-AggregateFunction HistogramExactFun::GetFunction() {
-	return AggregateFunction("histogram_exact", {LogicalType::ANY, LogicalType::LIST(LogicalType::ANY)},
-	                         LogicalTypeId::MAP, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                         HistogramBinBindFunction<HistogramExact>, nullptr);
-}
-
-ScalarFunction IsHistogramOtherBinFun::GetFunction() {
-	return ScalarFunction("is_histogram_other_bin", {LogicalType::ANY}, LogicalType::BOOLEAN,
-	                      IsHistogramOtherBinFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/nested/histogram.cpp b/src/duckdb/extension/core_functions/aggregate/nested/histogram.cpp
deleted file mode 100644
index 8a736f235..000000000
--- a/src/duckdb/extension/core_functions/aggregate/nested/histogram.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "core_functions/aggregate/nested_functions.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "core_functions/aggregate/histogram_helpers.hpp"
-#include "duckdb/common/owning_string_map.hpp"
-
-namespace duckdb {
-
-template <class MAP_TYPE>
-struct HistogramFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.hist = nullptr;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &) {
-		if (state.hist) {
-			delete state.hist;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
-		if (!source.hist) {
-			return;
-		}
-		if (!target.hist) {
-			target.hist = MAP_TYPE::CreateEmpty(input_data.allocator);
-		}
-		for (auto &entry : *source.hist) {
-			(*target.hist)[entry.first] += entry.second;
-		}
-	}
-};
-
-template <class TYPE>
-struct DefaultMapType {
-	using MAP_TYPE = TYPE;
-
-	static TYPE *CreateEmpty(ArenaAllocator &) {
-		return new TYPE();
-	}
-};
-
-template <class TYPE>
-struct StringMapType {
-	using MAP_TYPE = TYPE;
-
-	static TYPE *CreateEmpty(ArenaAllocator &allocator) {
-		return new TYPE(allocator);
-	}
-};
-
-template <class OP, class T, class MAP_TYPE>
-static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count,
-                                    Vector &state_vector, idx_t count) {
-
-	D_ASSERT(input_count == 1);
-
-	auto &input = inputs[0];
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-
-	auto extra_state = OP::CreateExtraState(count);
-	UnifiedVectorFormat input_data;
-	OP::PrepareData(input, count, extra_state, input_data);
-
-	auto states = UnifiedVectorFormat::GetData<HistogramAggState<T, typename MAP_TYPE::MAP_TYPE> *>(sdata);
-	auto input_values = UnifiedVectorFormat::GetData<T>(input_data);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = input_data.sel->get_index(i);
-		if (!input_data.validity.RowIsValid(idx)) {
-			continue;
-		}
-		auto &state = *states[sdata.sel->get_index(i)];
-		if (!state.hist) {
-			state.hist = MAP_TYPE::CreateEmpty(aggr_input.allocator);
-		}
-		auto &input_value = input_values[idx];
-		++(*state.hist)[input_value];
-	}
-}
-
-template <class OP, class T, class MAP_TYPE>
-static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
-                                      idx_t offset) {
-	using HIST_STATE = HistogramAggState<T, typename MAP_TYPE::MAP_TYPE>;
-
-	UnifiedVectorFormat sdata;
-	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = UnifiedVectorFormat::GetData<HIST_STATE *>(sdata);
-
-	auto &mask = FlatVector::Validity(result);
-	auto old_len = ListVector::GetListSize(result);
-	idx_t new_entries = 0;
-	// figure out how much space we need
-	for (idx_t i = 0; i < count; i++) {
-		auto &state = *states[sdata.sel->get_index(i)];
-		if (!state.hist) {
-			continue;
-		}
-		new_entries += state.hist->size();
-	}
-	// reserve space in the list vector
-	ListVector::Reserve(result, old_len + new_entries);
-	auto &keys = MapVector::GetKeys(result);
-	auto &values = MapVector::GetValues(result);
-	auto list_entries = FlatVector::GetData<list_entry_t>(result);
-	auto count_entries = FlatVector::GetData<uint64_t>(values);
-
-	idx_t current_offset = old_len;
-	for (idx_t i = 0; i < count; i++) {
-		const auto rid = i + offset;
-		auto &state = *states[sdata.sel->get_index(i)];
-		if (!state.hist) {
-			mask.SetInvalid(rid);
-			continue;
-		}
-
-		auto &list_entry = list_entries[rid];
-		list_entry.offset = current_offset;
-		for (auto &entry : *state.hist) {
-			OP::template HistogramFinalize<T>(entry.first, keys, current_offset);
-			count_entries[current_offset] = entry.second;
-			current_offset++;
-		}
-		list_entry.length = current_offset - list_entry.offset;
-	}
-	D_ASSERT(current_offset == old_len + new_entries);
-	ListVector::SetListSize(result, current_offset);
-	result.Verify(count);
-}
-
-template <class OP, class T, class MAP_TYPE>
-static AggregateFunction GetHistogramFunction(const LogicalType &type) {
-	using STATE_TYPE = HistogramAggState<T, typename MAP_TYPE::MAP_TYPE>;
-	using HIST_FUNC = HistogramFunction<MAP_TYPE>;
-
-	auto struct_type = LogicalType::MAP(type, LogicalType::UBIGINT);
-	return AggregateFunction(
-	    "histogram", {type}, struct_type, AggregateFunction::StateSize<STATE_TYPE>,
-	    AggregateFunction::StateInitialize<STATE_TYPE, HIST_FUNC>, HistogramUpdateFunction<OP, T, MAP_TYPE>,
-	    AggregateFunction::StateCombine<STATE_TYPE, HIST_FUNC>, HistogramFinalizeFunction<OP, T, MAP_TYPE>, nullptr,
-	    nullptr, AggregateFunction::StateDestroy<STATE_TYPE, HIST_FUNC>);
-}
-
-template <class OP, class T, class MAP_TYPE>
-AggregateFunction GetMapTypeInternal(const LogicalType &type) {
-	return GetHistogramFunction<OP, T, MAP_TYPE>(type);
-}
-
-template <class OP, class T, bool IS_ORDERED>
-AggregateFunction GetMapType(const LogicalType &type) {
-	if (IS_ORDERED) {
-		return GetMapTypeInternal<OP, T, DefaultMapType<map<T, idx_t>>>(type);
-	}
-	return GetMapTypeInternal<OP, T, DefaultMapType<unordered_map<T, idx_t>>>(type);
-}
-
-template <class OP, bool IS_ORDERED>
-AggregateFunction GetStringMapType(const LogicalType &type) {
-	if (IS_ORDERED) {
-		return GetMapTypeInternal<OP, string_t, StringMapType<OrderedOwningStringMap<idx_t>>>(type);
-	} else {
-		return GetMapTypeInternal<OP, string_t, StringMapType<OwningStringMap<idx_t>>>(type);
-	}
-}
-
-template <bool IS_ORDERED = true>
-AggregateFunction GetHistogramFunction(const LogicalType &type) {
-	switch (type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::BOOL:
-		return GetMapType<HistogramFunctor, bool, IS_ORDERED>(type);
-	case PhysicalType::UINT8:
-		return GetMapType<HistogramFunctor, uint8_t, IS_ORDERED>(type);
-	case PhysicalType::UINT16:
-		return GetMapType<HistogramFunctor, uint16_t, IS_ORDERED>(type);
-	case PhysicalType::UINT32:
-		return GetMapType<HistogramFunctor, uint32_t, IS_ORDERED>(type);
-	case PhysicalType::UINT64:
-		return GetMapType<HistogramFunctor, uint64_t, IS_ORDERED>(type);
-	case PhysicalType::INT8:
-		return GetMapType<HistogramFunctor, int8_t, IS_ORDERED>(type);
-	case PhysicalType::INT16:
-		return GetMapType<HistogramFunctor, int16_t, IS_ORDERED>(type);
-	case PhysicalType::INT32:
-		return GetMapType<HistogramFunctor, int32_t, IS_ORDERED>(type);
-	case PhysicalType::INT64:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case PhysicalType::FLOAT:
-		return GetMapType<HistogramFunctor, float, IS_ORDERED>(type);
-	case PhysicalType::DOUBLE:
-		return GetMapType<HistogramFunctor, double, IS_ORDERED>(type);
-	case PhysicalType::VARCHAR:
-		return GetStringMapType<HistogramStringFunctor, IS_ORDERED>(type);
-#endif
-	default:
-		return GetStringMapType<HistogramGenericFunctor, IS_ORDERED>(type);
-	}
-}
-
-template <bool IS_ORDERED = true>
-unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, AggregateFunction &function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(arguments.size() == 1);
-
-	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	function = GetHistogramFunction<IS_ORDERED>(arguments[0]->return_type);
-	return make_uniq<VariableReturnBindData>(function.return_type);
-}
-
-AggregateFunctionSet HistogramFun::GetFunctions() {
-	AggregateFunctionSet fun;
-	AggregateFunction histogram_function("histogram", {LogicalType::ANY}, LogicalTypeId::MAP, nullptr, nullptr, nullptr,
-	                                     nullptr, nullptr, nullptr, HistogramBindFunction, nullptr);
-	fun.AddFunction(HistogramFun::BinnedHistogramFunction());
-	fun.AddFunction(histogram_function);
-	return fun;
-}
-
-AggregateFunction HistogramFun::GetHistogramUnorderedMap(LogicalType &type) {
-	return AggregateFunction("histogram", {LogicalType::ANY}, LogicalTypeId::MAP, nullptr, nullptr, nullptr, nullptr,
-	                         nullptr, nullptr, HistogramBindFunction<false>, nullptr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/nested/list.cpp b/src/duckdb/extension/core_functions/aggregate/nested/list.cpp
deleted file mode 100644
index 7b23987d6..000000000
--- a/src/duckdb/extension/core_functions/aggregate/nested/list.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/list_segment.hpp"
-#include "core_functions/aggregate/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-struct ListBindData : public FunctionData {
-	explicit ListBindData(const LogicalType &stype_p);
-	~ListBindData() override;
-
-	LogicalType stype;
-	ListSegmentFunctions functions;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<ListBindData>(stype);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<ListBindData>();
-		return stype == other.stype;
-	}
-};
-
-ListBindData::ListBindData(const LogicalType &stype_p) : stype(stype_p) {
-	// always unnest once because the result vector is of type LIST
-	auto type = ListType::GetChildType(stype_p);
-	GetSegmentDataFunctions(functions, type);
-}
-
-ListBindData::~ListBindData() {
-}
-
-struct ListAggState {
-	LinkedList linked_list;
-};
-
-struct ListFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.linked_list.total_capacity = 0;
-		state.linked_list.first_segment = nullptr;
-		state.linked_list.last_segment = nullptr;
-	}
-	static bool IgnoreNull() {
-		return false;
-	}
-};
-
-static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-                               Vector &state_vector, idx_t count) {
-
-	D_ASSERT(input_count == 1);
-	auto &input = inputs[0];
-	RecursiveUnifiedVectorFormat input_data;
-	Vector::RecursiveToUnifiedFormat(input, count, input_data);
-
-	UnifiedVectorFormat states_data;
-	state_vector.ToUnifiedFormat(count, states_data);
-	auto states = UnifiedVectorFormat::GetData<ListAggState *>(states_data);
-
-	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
-
-	for (idx_t i = 0; i < count; i++) {
-		auto &state = *states[states_data.sel->get_index(i)];
-		aggr_input_data.allocator.AlignNext();
-		list_bind_data.functions.AppendRow(aggr_input_data.allocator, state.linked_list, input_data, i);
-	}
-}
-
-static void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data,
-                               idx_t count) {
-	D_ASSERT(aggr_input_data.combine_type == AggregateCombineType::ALLOW_DESTRUCTIVE);
-
-	UnifiedVectorFormat states_data;
-	states_vector.ToUnifiedFormat(count, states_data);
-	auto states_ptr = UnifiedVectorFormat::GetData<ListAggState *>(states_data);
-
-	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
-	for (idx_t i = 0; i < count; i++) {
-
-		auto &state = *states_ptr[states_data.sel->get_index(i)];
-		if (state.linked_list.total_capacity == 0) {
-			// NULL, no need to append
-			// this can happen when adding a FILTER to the grouping, e.g.,
-			// LIST(i) FILTER (WHERE i <> 3)
-			continue;
-		}
-
-		if (combined_ptr[i]->linked_list.total_capacity == 0) {
-			combined_ptr[i]->linked_list = state.linked_list;
-			continue;
-		}
-
-		// append the linked list
-		combined_ptr[i]->linked_list.last_segment->next = state.linked_list.first_segment;
-		combined_ptr[i]->linked_list.last_segment = state.linked_list.last_segment;
-		combined_ptr[i]->linked_list.total_capacity += state.linked_list.total_capacity;
-	}
-}
-
-static void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                         idx_t offset) {
-
-	UnifiedVectorFormat states_data;
-	states_vector.ToUnifiedFormat(count, states_data);
-	auto states = UnifiedVectorFormat::GetData<ListAggState *>(states_data);
-
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	auto &mask = FlatVector::Validity(result);
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	size_t total_len = ListVector::GetListSize(result);
-
-	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
-
-	// first iterate over all entries and set up the list entries, and get the newly required total length
-	for (idx_t i = 0; i < count; i++) {
-
-		auto &state = *states[states_data.sel->get_index(i)];
-		const auto rid = i + offset;
-		result_data[rid].offset = total_len;
-		if (state.linked_list.total_capacity == 0) {
-			mask.SetInvalid(rid);
-			result_data[rid].length = 0;
-			continue;
-		}
-
-		// set the length and offset of this list in the result vector
-		auto total_capacity = state.linked_list.total_capacity;
-		result_data[rid].length = total_capacity;
-		total_len += total_capacity;
-	}
-
-	// reserve capacity, then iterate over all entries again and copy over the data to the child vector
-	ListVector::Reserve(result, total_len);
-	auto &result_child = ListVector::GetEntry(result);
-	for (idx_t i = 0; i < count; i++) {
-
-		auto &state = *states[states_data.sel->get_index(i)];
-		const auto rid = i + offset;
-		if (state.linked_list.total_capacity == 0) {
-			continue;
-		}
-
-		idx_t current_offset = result_data[rid].offset;
-		list_bind_data.functions.BuildListVector(state.linked_list, result_child, current_offset);
-	}
-
-	ListVector::SetListSize(result, total_len);
-}
-
-static void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data,
-                                idx_t count) {
-
-	//	Can we use destructive combining?
-	if (aggr_input_data.combine_type == AggregateCombineType::ALLOW_DESTRUCTIVE) {
-		ListAbsorbFunction(states_vector, combined, aggr_input_data, count);
-		return;
-	}
-
-	UnifiedVectorFormat states_data;
-	states_vector.ToUnifiedFormat(count, states_data);
-	auto states_ptr = UnifiedVectorFormat::GetData<const ListAggState *>(states_data);
-	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
-
-	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
-	auto result_type = ListType::GetChildType(list_bind_data.stype);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto &source = *states_ptr[states_data.sel->get_index(i)];
-		auto &target = *combined_ptr[i];
-
-		const auto entry_count = source.linked_list.total_capacity;
-		Vector input(result_type, source.linked_list.total_capacity);
-		list_bind_data.functions.BuildListVector(source.linked_list, input, 0);
-
-		RecursiveUnifiedVectorFormat input_data;
-		Vector::RecursiveToUnifiedFormat(input, entry_count, input_data);
-
-		for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
-			aggr_input_data.allocator.AlignNext();
-			list_bind_data.functions.AppendRow(aggr_input_data.allocator, target.linked_list, input_data, entry_idx);
-		}
-	}
-}
-
-unique_ptr<FunctionData> ListBindFunction(ClientContext &context, AggregateFunction &function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() == 1);
-	D_ASSERT(function.arguments.size() == 1);
-
-	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		function.arguments[0] = LogicalTypeId::UNKNOWN;
-		function.return_type = LogicalType::SQLNULL;
-		return nullptr;
-	}
-
-	function.return_type = LogicalType::LIST(arguments[0]->return_type);
-	return make_uniq<ListBindData>(function.return_type);
-}
-
-AggregateFunction ListFun::GetFunction() {
-	auto func =
-	    AggregateFunction({LogicalType::ANY}, LogicalTypeId::LIST, AggregateFunction::StateSize<ListAggState>,
-	                      AggregateFunction::StateInitialize<ListAggState, ListFunction>, ListUpdateFunction,
-	                      ListCombineFunction, ListFinalize, nullptr, ListBindFunction, nullptr, nullptr, nullptr);
-
-	return func;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_avg.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_avg.cpp
deleted file mode 100644
index b4b43af21..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_avg.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-struct RegrState {
-	double sum;
-	size_t count;
-};
-
-struct RegrAvgFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.sum = 0;
-		state.count = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target.sum += source.sum;
-		target.count += source.count;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.sum / (double)state.count;
-		}
-	}
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-struct RegrAvgXFunction : RegrAvgFunction {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		state.sum += x;
-		state.count++;
-	}
-};
-
-struct RegrAvgYFunction : RegrAvgFunction {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		state.sum += y;
-		state.count++;
-	}
-};
-
-AggregateFunction RegrAvgxFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgXFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-AggregateFunction RegrAvgyFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgYFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_count.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_count.cpp
deleted file mode 100644
index 9215fcfb8..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_count.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "core_functions/aggregate/regression/regr_count.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-AggregateFunction RegrCountFun::GetFunction() {
-	auto regr_count = AggregateFunction::BinaryAggregate<size_t, double, double, uint32_t, RegrCountFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::UINTEGER);
-	regr_count.name = "regr_count";
-	regr_count.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return regr_count;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_intercept.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_intercept.cpp
deleted file mode 100644
index e727d2669..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_intercept.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//! AVG(y)-REGR_SLOPE(y,x)*AVG(x)
-
-#include "core_functions/aggregate/regression_functions.hpp"
-#include "core_functions/aggregate/regression/regr_slope.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct RegrInterceptState {
-	size_t count;
-	double sum_x;
-	double sum_y;
-	RegrSlopeState slope;
-};
-
-struct RegrInterceptOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.count = 0;
-		state.sum_x = 0;
-		state.sum_y = 0;
-		RegrSlopeOperation::Initialize<RegrSlopeState>(state.slope);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		state.count++;
-		state.sum_x += x;
-		state.sum_y += y;
-		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(state.slope, y, x, idata);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		target.count += source.count;
-		target.sum_x += source.sum_x;
-		target.sum_y += source.sum_y;
-		RegrSlopeOperation::Combine<RegrSlopeState, OP>(source.slope, target.slope, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		RegrSlopeOperation::Finalize<T, RegrSlopeState>(state.slope, target, finalize_data);
-		if (Value::IsNan(target)) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		auto x_avg = state.sum_x / state.count;
-		auto y_avg = state.sum_y / state.count;
-		target = y_avg - target * x_avg;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction RegrInterceptFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrInterceptState, double, double, double, RegrInterceptOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_r2.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_r2.cpp
deleted file mode 100644
index ba89a8a6e..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_r2.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-// REGR_R2(y, x)
-// Returns the coefficient of determination for non-null pairs in a group.
-// It is computed for non-null pairs using the following formula:
-// null                 if var_pop(x) = 0, else
-// 1                    if var_pop(y) = 0 and var_pop(x) <> 0, else
-// power(corr(y,x), 2)
-
-#include "core_functions/aggregate/algebraic/corr.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-
-namespace duckdb {
-struct RegrR2State {
-	CorrState corr;
-	StddevState var_pop_x;
-	StddevState var_pop_y;
-};
-
-struct RegrR2Operation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		CorrOperation::Initialize<CorrState>(state.corr);
-		STDDevBaseOperation::Initialize<StddevState>(state.var_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(state.var_pop_y);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(state.corr, y, x, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_x, x);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_y, y);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		CorrOperation::Combine<CorrState, OP>(source.corr, target.corr, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, target.var_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, target.var_pop_y, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		auto var_pop_x = state.var_pop_x.count > 1 ? (state.var_pop_x.dsquared / state.var_pop_x.count) : 0;
-		if (!Value::DoubleIsFinite(var_pop_x)) {
-			throw OutOfRangeException("VARPOP(X) is out of range!");
-		}
-		if (var_pop_x == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		auto var_pop_y = state.var_pop_y.count > 1 ? (state.var_pop_y.dsquared / state.var_pop_y.count) : 0;
-		if (!Value::DoubleIsFinite(var_pop_y)) {
-			throw OutOfRangeException("VARPOP(Y) is out of range!");
-		}
-		if (var_pop_y == 0) {
-			target = 1;
-			return;
-		}
-		CorrOperation::Finalize<T, CorrState>(state.corr, target, finalize_data);
-		target = pow(target, 2);
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction RegrR2Fun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrR2State, double, double, double, RegrR2Operation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_slope.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_slope.cpp
deleted file mode 100644
index c58593990..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_slope.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-// REGR_SLOPE(y, x)
-// Returns the slope of the linear regression line for non-null pairs in a group.
-// It is computed for non-null pairs using the following formula:
-// COVAR_POP(x,y) / VAR_POP(x)
-
-//! Input : Any numeric type
-//! Output : Double
-
-#include "core_functions/aggregate/regression/regr_slope.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-
-namespace duckdb {
-
-AggregateFunction RegrSlopeFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrSlopeState, double, double, double, RegrSlopeOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_sxx_syy.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_sxx_syy.cpp
deleted file mode 100644
index 72202c2be..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_sxx_syy.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// REGR_SXX(y, x)
-// Returns REGR_COUNT(y, x) * VAR_POP(x) for non-null pairs.
-// REGR_SYY(y, x)
-// Returns REGR_COUNT(y, x) * VAR_POP(y) for non-null pairs.
-
-#include "core_functions/aggregate/regression/regr_count.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-
-namespace duckdb {
-
-struct RegrSState {
-	size_t count;
-	StddevState var_pop;
-};
-
-struct RegrBaseOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		RegrCountFunction::Initialize<size_t>(state.count);
-		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.var_pop.count == 0) {
-			finalize_data.ReturnNull();
-			return;
-		}
-		auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
-		if (!Value::DoubleIsFinite(var_pop)) {
-			throw OutOfRangeException("VARPOP is out of range!");
-		}
-		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
-		target *= var_pop;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct RegrSXXOperation : RegrBaseOperation {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, y, x, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
-	}
-};
-
-struct RegrSYYOperation : RegrBaseOperation {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, y, x, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
-	}
-};
-
-AggregateFunction RegrSXXFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSXXOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-AggregateFunction RegrSYYFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSYYOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/aggregate/regression/regr_sxy.cpp b/src/duckdb/extension/core_functions/aggregate/regression/regr_sxy.cpp
deleted file mode 100644
index 1ab726e82..000000000
--- a/src/duckdb/extension/core_functions/aggregate/regression/regr_sxy.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// REGR_SXY(y, x)
-// Returns REGR_COUNT(expr1, expr2) * COVAR_POP(expr1, expr2) for non-null pairs.
-
-#include "core_functions/aggregate/regression/regr_count.hpp"
-#include "core_functions/aggregate/algebraic/covar.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct RegrSXyState {
-	size_t count;
-	CovarState cov_pop;
-};
-
-struct RegrSXYOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		RegrCountFunction::Initialize<size_t>(state.count);
-		CovarOperation::Initialize<CovarState>(state.cov_pop);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, y, x, idata);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x, idata);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
-		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		CovarPopOperation::Finalize<T, CovarState>(state.cov_pop, target, finalize_data);
-		auto cov_pop = target;
-		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
-		target *= cov_pop;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction RegrSXYFun::GetFunction() {
-	return AggregateFunction::BinaryAggregate<RegrSXyState, double, double, double, RegrSXYOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/core_functions_extension.cpp b/src/duckdb/extension/core_functions/core_functions_extension.cpp
deleted file mode 100644
index 8bf09b800..000000000
--- a/src/duckdb/extension/core_functions/core_functions_extension.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#define DUCKDB_EXTENSION_MAIN
-#include "core_functions_extension.hpp"
-
-#include "core_functions/function_list.hpp"
-#include "duckdb/main/extension_util.hpp"
-#include "duckdb/function/register_function_list_helper.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-
-namespace duckdb {
-
-template <class T>
-static void FillExtraInfo(const StaticFunctionDefinition &function, T &info) {
-	info.internal = true;
-	FillFunctionDescriptions(function, info);
-	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
-}
-
-void LoadInternal(DuckDB &db) {
-	auto functions = StaticFunctionDefinition::GetFunctionList();
-	for (idx_t i = 0; functions[i].name; i++) {
-		auto &function = functions[i];
-		if (function.get_function || function.get_function_set) {
-			// scalar function
-			ScalarFunctionSet result;
-			if (function.get_function) {
-				result.AddFunction(function.get_function());
-			} else {
-				result = function.get_function_set();
-			}
-			result.name = function.name;
-			CreateScalarFunctionInfo info(result);
-			FillExtraInfo(function, info);
-			ExtensionUtil::RegisterFunction(*db.instance, std::move(info));
-		} else if (function.get_aggregate_function || function.get_aggregate_function_set) {
-			// aggregate function
-			AggregateFunctionSet result;
-			if (function.get_aggregate_function) {
-				result.AddFunction(function.get_aggregate_function());
-			} else {
-				result = function.get_aggregate_function_set();
-			}
-			result.name = function.name;
-			CreateAggregateFunctionInfo info(result);
-			FillExtraInfo(function, info);
-			ExtensionUtil::RegisterFunction(*db.instance, std::move(info));
-		} else {
-			throw InternalException("Do not know how to register function of this type");
-		}
-	}
-}
-
-void CoreFunctionsExtension::Load(DuckDB &db) {
-	LoadInternal(db);
-}
-
-std::string CoreFunctionsExtension::Name() {
-	return "core_functions";
-}
-
-std::string CoreFunctionsExtension::Version() const {
-#ifdef EXT_VERSION_CORE_FUNCTIONS
-	return EXT_VERSION_CORE_FUNCTIONS;
-#else
-	return "";
-#endif
-}
-
-} // namespace duckdb
-
-extern "C" {
-
-DUCKDB_EXTENSION_API void core_functions_init(duckdb::DatabaseInstance &db) {
-	duckdb::DuckDB db_wrapper(db);
-	duckdb::LoadInternal(db_wrapper);
-}
-
-DUCKDB_EXTENSION_API const char *core_functions_version() {
-	return duckdb::DuckDB::LibraryVersion();
-}
-}
-
-#ifndef DUCKDB_EXTENSION_MAIN
-#error DUCKDB_EXTENSION_MAIN not defined
-#endif
diff --git a/src/duckdb/extension/core_functions/function_list.cpp b/src/duckdb/extension/core_functions/function_list.cpp
deleted file mode 100644
index 53d96feb0..000000000
--- a/src/duckdb/extension/core_functions/function_list.cpp
+++ /dev/null
@@ -1,407 +0,0 @@
-#include "core_functions/function_list.hpp"
-#include "core_functions/aggregate/algebraic_functions.hpp"
-#include "core_functions/aggregate/distributive_functions.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-#include "core_functions/aggregate/nested_functions.hpp"
-#include "core_functions/aggregate/regression_functions.hpp"
-#include "core_functions/scalar/bit_functions.hpp"
-#include "core_functions/scalar/blob_functions.hpp"
-#include "core_functions/scalar/date_functions.hpp"
-#include "core_functions/scalar/enum_functions.hpp"
-#include "core_functions/scalar/generic_functions.hpp"
-#include "core_functions/scalar/list_functions.hpp"
-#include "core_functions/scalar/map_functions.hpp"
-#include "core_functions/scalar/math_functions.hpp"
-#include "core_functions/scalar/operators_functions.hpp"
-#include "core_functions/scalar/random_functions.hpp"
-#include "core_functions/scalar/secret_functions.hpp"
-#include "core_functions/scalar/string_functions.hpp"
-#include "core_functions/scalar/struct_functions.hpp"
-#include "core_functions/scalar/union_functions.hpp"
-#include "core_functions/scalar/array_functions.hpp"
-#include "core_functions/scalar/debug_functions.hpp"
-
-namespace duckdb {
-
-// Scalar Function
-#define DUCKDB_SCALAR_FUNCTION_BASE(_PARAM, _NAME)                                                                     \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, _PARAM::GetFunction, nullptr, nullptr, nullptr }
-#define DUCKDB_SCALAR_FUNCTION(_PARAM)       DUCKDB_SCALAR_FUNCTION_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_SCALAR_FUNCTION_ALIAS(_PARAM) DUCKDB_SCALAR_FUNCTION_BASE(_PARAM::ALIAS, _PARAM::Name)
-// Scalar Function Set
-#define DUCKDB_SCALAR_FUNCTION_SET_BASE(_PARAM, _NAME)                                                                 \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, nullptr, _PARAM::GetFunctions, nullptr, nullptr }
-#define DUCKDB_SCALAR_FUNCTION_SET(_PARAM)       DUCKDB_SCALAR_FUNCTION_SET_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_SCALAR_FUNCTION_SET_ALIAS(_PARAM) DUCKDB_SCALAR_FUNCTION_SET_BASE(_PARAM::ALIAS, _PARAM::Name)
-// Aggregate Function
-#define DUCKDB_AGGREGATE_FUNCTION_BASE(_PARAM, _NAME)                                                                  \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, nullptr, nullptr, _PARAM::GetFunction, nullptr }
-#define DUCKDB_AGGREGATE_FUNCTION(_PARAM)       DUCKDB_AGGREGATE_FUNCTION_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_AGGREGATE_FUNCTION_ALIAS(_PARAM) DUCKDB_AGGREGATE_FUNCTION_BASE(_PARAM::ALIAS, _PARAM::Name)
-// Aggregate Function Set
-#define DUCKDB_AGGREGATE_FUNCTION_SET_BASE(_PARAM, _NAME)                                                              \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, nullptr, nullptr, nullptr, _PARAM::GetFunctions }
-#define DUCKDB_AGGREGATE_FUNCTION_SET(_PARAM)       DUCKDB_AGGREGATE_FUNCTION_SET_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(_PARAM) DUCKDB_AGGREGATE_FUNCTION_SET_BASE(_PARAM::ALIAS, _PARAM::Name)
-#define FINAL_FUNCTION                                                                                                 \
-	{ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }
-
-// this list is generated by scripts/generate_functions.py
-static const StaticFunctionDefinition core_functions[] = {
-	DUCKDB_SCALAR_FUNCTION(FactorialOperatorFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitwiseAndFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListHasAnyFunAlias),
-	DUCKDB_SCALAR_FUNCTION(PowOperatorFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListDistanceFunAlias),
-	DUCKDB_SCALAR_FUNCTION_SET(LeftShiftFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListCosineDistanceFunAlias),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListHasAllFunAlias2),
-	DUCKDB_SCALAR_FUNCTION_SET(RightShiftFun),
-	DUCKDB_SCALAR_FUNCTION_SET(AbsOperatorFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListHasAllFunAlias),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(PowOperatorFunAlias),
-	DUCKDB_SCALAR_FUNCTION(StartsWithOperatorFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(AbsFun),
-	DUCKDB_SCALAR_FUNCTION(AcosFun),
-	DUCKDB_SCALAR_FUNCTION(AcoshFun),
-	DUCKDB_SCALAR_FUNCTION_SET(AgeFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(AggregateFun),
-	DUCKDB_SCALAR_FUNCTION(AliasFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ApplyFun),
-	DUCKDB_AGGREGATE_FUNCTION(ApproxCountDistinctFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ApproxQuantileFun),
-	DUCKDB_AGGREGATE_FUNCTION(ApproxTopKFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ArgMaxFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ArgMaxNullFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ArgMinFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ArgMinNullFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(ArgmaxFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(ArgminFun),
-	DUCKDB_AGGREGATE_FUNCTION_ALIAS(ArrayAggFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayAggrFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayAggregateFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayApplyFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayCosineDistanceFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayCosineSimilarityFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayCrossProductFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayDistanceFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayDistinctFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayDotProductFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayFilterFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayGradeUpFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayHasAllFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayHasAnyFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayInnerProductFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayNegativeDotProductFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayNegativeInnerProductFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayReduceFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayReverseSortFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArraySliceFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArraySortFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayTransformFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayUniqueFun),
-	DUCKDB_SCALAR_FUNCTION(ArrayValueFun),
-	DUCKDB_SCALAR_FUNCTION(ASCIIFun),
-	DUCKDB_SCALAR_FUNCTION(AsinFun),
-	DUCKDB_SCALAR_FUNCTION(AsinhFun),
-	DUCKDB_SCALAR_FUNCTION(AtanFun),
-	DUCKDB_SCALAR_FUNCTION(Atan2Fun),
-	DUCKDB_SCALAR_FUNCTION(AtanhFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(AvgFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BarFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(Base64Fun),
-	DUCKDB_SCALAR_FUNCTION_SET(BinFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(BitAndFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitCountFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(BitOrFun),
-	DUCKDB_SCALAR_FUNCTION(BitPositionFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(BitXorFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitStringFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(BitstringAggFun),
-	DUCKDB_AGGREGATE_FUNCTION(BoolAndFun),
-	DUCKDB_AGGREGATE_FUNCTION(BoolOrFun),
-	DUCKDB_SCALAR_FUNCTION(CanCastImplicitlyFun),
-	DUCKDB_SCALAR_FUNCTION(CardinalityFun),
-	DUCKDB_SCALAR_FUNCTION(CbrtFun),
-	DUCKDB_SCALAR_FUNCTION_SET(CeilFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(CeilingFun),
-	DUCKDB_SCALAR_FUNCTION_SET(CenturyFun),
-	DUCKDB_SCALAR_FUNCTION(ChrFun),
-	DUCKDB_AGGREGATE_FUNCTION(CorrFun),
-	DUCKDB_SCALAR_FUNCTION(CosFun),
-	DUCKDB_SCALAR_FUNCTION(CoshFun),
-	DUCKDB_SCALAR_FUNCTION(CotFun),
-	DUCKDB_AGGREGATE_FUNCTION(CountIfFun),
-	DUCKDB_AGGREGATE_FUNCTION_ALIAS(CountifFun),
-	DUCKDB_AGGREGATE_FUNCTION(CovarPopFun),
-	DUCKDB_AGGREGATE_FUNCTION(CovarSampFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentDatabaseFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentQueryFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentSchemaFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentSchemasFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentSettingFun),
-	DUCKDB_SCALAR_FUNCTION(DamerauLevenshteinFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DateDiffFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DatePartFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DateSubFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DateTruncFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(DatediffFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(DatepartFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(DatesubFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(DatetruncFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DayFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DayNameFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DayOfMonthFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DayOfWeekFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DayOfYearFun),
-	DUCKDB_SCALAR_FUNCTION_SET(DecadeFun),
-	DUCKDB_SCALAR_FUNCTION(DecodeFun),
-	DUCKDB_SCALAR_FUNCTION(DegreesFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(Editdist3Fun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ElementAtFun),
-	DUCKDB_SCALAR_FUNCTION(EncodeFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(EntropyFun),
-	DUCKDB_SCALAR_FUNCTION(EnumCodeFun),
-	DUCKDB_SCALAR_FUNCTION(EnumFirstFun),
-	DUCKDB_SCALAR_FUNCTION(EnumLastFun),
-	DUCKDB_SCALAR_FUNCTION(EnumRangeFun),
-	DUCKDB_SCALAR_FUNCTION(EnumRangeBoundaryFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EpochFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EpochMsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EpochNsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EpochUsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EquiWidthBinsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EraFun),
-	DUCKDB_SCALAR_FUNCTION(EvenFun),
-	DUCKDB_SCALAR_FUNCTION(ExpFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(FactorialFun),
-	DUCKDB_AGGREGATE_FUNCTION(FAvgFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(FilterFun),
-	DUCKDB_SCALAR_FUNCTION(ListFlattenFun),
-	DUCKDB_SCALAR_FUNCTION_SET(FloorFun),
-	DUCKDB_SCALAR_FUNCTION(FormatFun),
-	DUCKDB_SCALAR_FUNCTION(FormatreadabledecimalsizeFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(FormatreadablesizeFun),
-	DUCKDB_SCALAR_FUNCTION(FormatBytesFun),
-	DUCKDB_SCALAR_FUNCTION(FromBase64Fun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(FromBinaryFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(FromHexFun),
-	DUCKDB_AGGREGATE_FUNCTION_ALIAS(FsumFun),
-	DUCKDB_SCALAR_FUNCTION(GammaFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(GcdFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(GenRandomUuidFun),
-	DUCKDB_SCALAR_FUNCTION_SET(GenerateSeriesFun),
-	DUCKDB_SCALAR_FUNCTION(GetBitFun),
-	DUCKDB_SCALAR_FUNCTION(GetCurrentTimestampFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(GradeUpFun),
-	DUCKDB_SCALAR_FUNCTION_SET(GreatestFun),
-	DUCKDB_SCALAR_FUNCTION_SET(GreatestCommonDivisorFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(GroupConcatFun),
-	DUCKDB_SCALAR_FUNCTION(HammingFun),
-	DUCKDB_SCALAR_FUNCTION(HashFun),
-	DUCKDB_SCALAR_FUNCTION_SET(HexFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(HistogramFun),
-	DUCKDB_AGGREGATE_FUNCTION(HistogramExactFun),
-	DUCKDB_SCALAR_FUNCTION_SET(HoursFun),
-	DUCKDB_SCALAR_FUNCTION(InSearchPathFun),
-	DUCKDB_SCALAR_FUNCTION(InstrFun),
-	DUCKDB_SCALAR_FUNCTION(IsHistogramOtherBinFun),
-	DUCKDB_SCALAR_FUNCTION_SET(IsFiniteFun),
-	DUCKDB_SCALAR_FUNCTION_SET(IsInfiniteFun),
-	DUCKDB_SCALAR_FUNCTION_SET(IsNanFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ISODayOfWeekFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ISOYearFun),
-	DUCKDB_SCALAR_FUNCTION(JaccardFun),
-	DUCKDB_SCALAR_FUNCTION_SET(JaroSimilarityFun),
-	DUCKDB_SCALAR_FUNCTION_SET(JaroWinklerSimilarityFun),
-	DUCKDB_SCALAR_FUNCTION_SET(JulianDayFun),
-	DUCKDB_AGGREGATE_FUNCTION(KahanSumFun),
-	DUCKDB_AGGREGATE_FUNCTION(KurtosisFun),
-	DUCKDB_AGGREGATE_FUNCTION(KurtosisPopFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LastDayFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(LcmFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LeastFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LeastCommonMultipleFun),
-	DUCKDB_SCALAR_FUNCTION(LeftFun),
-	DUCKDB_SCALAR_FUNCTION(LeftGraphemeFun),
-	DUCKDB_SCALAR_FUNCTION(LevenshteinFun),
-	DUCKDB_SCALAR_FUNCTION(LogGammaFun),
-	DUCKDB_AGGREGATE_FUNCTION(ListFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListAggrFun),
-	DUCKDB_SCALAR_FUNCTION(ListAggregateFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListApplyFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListCosineDistanceFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListCosineSimilarityFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListDistanceFun),
-	DUCKDB_SCALAR_FUNCTION(ListDistinctFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListDotProductFun),
-	DUCKDB_SCALAR_FUNCTION(ListFilterFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListGradeUpFun),
-	DUCKDB_SCALAR_FUNCTION(ListHasAllFun),
-	DUCKDB_SCALAR_FUNCTION(ListHasAnyFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListInnerProductFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListNegativeDotProductFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListNegativeInnerProductFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListPackFun),
-	DUCKDB_SCALAR_FUNCTION(ListReduceFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListReverseSortFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListSliceFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListSortFun),
-	DUCKDB_SCALAR_FUNCTION(ListTransformFun),
-	DUCKDB_SCALAR_FUNCTION(ListUniqueFun),
-	DUCKDB_SCALAR_FUNCTION(ListValueFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(ListaggFun),
-	DUCKDB_SCALAR_FUNCTION(LnFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LogFun),
-	DUCKDB_SCALAR_FUNCTION(Log10Fun),
-	DUCKDB_SCALAR_FUNCTION(Log2Fun),
-	DUCKDB_SCALAR_FUNCTION(LpadFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LtrimFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(MadFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MakeDateFun),
-	DUCKDB_SCALAR_FUNCTION(MakeTimeFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampNsFun),
-	DUCKDB_SCALAR_FUNCTION(MapFun),
-	DUCKDB_SCALAR_FUNCTION(MapConcatFun),
-	DUCKDB_SCALAR_FUNCTION(MapEntriesFun),
-	DUCKDB_SCALAR_FUNCTION(MapExtractFun),
-	DUCKDB_SCALAR_FUNCTION(MapFromEntriesFun),
-	DUCKDB_SCALAR_FUNCTION(MapKeysFun),
-	DUCKDB_SCALAR_FUNCTION(MapValuesFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(MaxByFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(MeanFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(MedianFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MicrosecondsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MillenniumFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MillisecondsFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(MinByFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MinutesFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(MismatchesFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ModeFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MonthFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MonthNameFun),
-	DUCKDB_SCALAR_FUNCTION_SET(NanosecondsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(NextAfterFun),
-	DUCKDB_SCALAR_FUNCTION(NormalizedIntervalFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(NowFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(OrdFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ParseDirnameFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ParseDirpathFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ParseFilenameFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ParsePathFun),
-	DUCKDB_SCALAR_FUNCTION(PiFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(PositionFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(PowFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(PowerFun),
-	DUCKDB_SCALAR_FUNCTION(PrintfFun),
-	DUCKDB_AGGREGATE_FUNCTION(ProductFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(QuantileFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(QuantileContFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(QuantileDiscFun),
-	DUCKDB_SCALAR_FUNCTION_SET(QuarterFun),
-	DUCKDB_SCALAR_FUNCTION(RadiansFun),
-	DUCKDB_SCALAR_FUNCTION(RandomFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListRangeFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ReduceFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrAvgxFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrAvgyFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrCountFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrInterceptFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrR2Fun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrSlopeFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrSXXFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrSXYFun),
-	DUCKDB_AGGREGATE_FUNCTION(RegrSYYFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RepeatFun),
-	DUCKDB_SCALAR_FUNCTION(ReplaceFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(ReservoirQuantileFun),
-	DUCKDB_SCALAR_FUNCTION(ReverseFun),
-	DUCKDB_SCALAR_FUNCTION(RightFun),
-	DUCKDB_SCALAR_FUNCTION(RightGraphemeFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RoundFun),
-	DUCKDB_SCALAR_FUNCTION(RpadFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RtrimFun),
-	DUCKDB_SCALAR_FUNCTION_SET(SecondsFun),
-	DUCKDB_AGGREGATE_FUNCTION(StandardErrorOfTheMeanFun),
-	DUCKDB_SCALAR_FUNCTION(SetBitFun),
-	DUCKDB_SCALAR_FUNCTION(SetseedFun),
-	DUCKDB_SCALAR_FUNCTION_SET(SignFun),
-	DUCKDB_SCALAR_FUNCTION_SET(SignBitFun),
-	DUCKDB_SCALAR_FUNCTION(SinFun),
-	DUCKDB_SCALAR_FUNCTION(SinhFun),
-	DUCKDB_AGGREGATE_FUNCTION(SkewnessFun),
-	DUCKDB_SCALAR_FUNCTION(SqrtFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(StartsWithFun),
-	DUCKDB_SCALAR_FUNCTION(StatsFun),
-	DUCKDB_AGGREGATE_FUNCTION_ALIAS(StddevFun),
-	DUCKDB_AGGREGATE_FUNCTION(StdDevPopFun),
-	DUCKDB_AGGREGATE_FUNCTION(StdDevSampFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(StringAggFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(StrposFun),
-	DUCKDB_SCALAR_FUNCTION(StructInsertFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(SumFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(SumNoOverflowFun),
-	DUCKDB_AGGREGATE_FUNCTION_ALIAS(SumkahanFun),
-	DUCKDB_SCALAR_FUNCTION(TanFun),
-	DUCKDB_SCALAR_FUNCTION(TanhFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TimeBucketFun),
-	DUCKDB_SCALAR_FUNCTION(TimeTZSortKeyFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TimezoneFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TimezoneHourFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TimezoneMinuteFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ToBaseFun),
-	DUCKDB_SCALAR_FUNCTION(ToBase64Fun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ToBinaryFun),
-	DUCKDB_SCALAR_FUNCTION(ToCenturiesFun),
-	DUCKDB_SCALAR_FUNCTION(ToDaysFun),
-	DUCKDB_SCALAR_FUNCTION(ToDecadesFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ToHexFun),
-	DUCKDB_SCALAR_FUNCTION(ToHoursFun),
-	DUCKDB_SCALAR_FUNCTION(ToMicrosecondsFun),
-	DUCKDB_SCALAR_FUNCTION(ToMillenniaFun),
-	DUCKDB_SCALAR_FUNCTION(ToMillisecondsFun),
-	DUCKDB_SCALAR_FUNCTION(ToMinutesFun),
-	DUCKDB_SCALAR_FUNCTION(ToMonthsFun),
-	DUCKDB_SCALAR_FUNCTION(ToQuartersFun),
-	DUCKDB_SCALAR_FUNCTION(ToSecondsFun),
-	DUCKDB_SCALAR_FUNCTION(ToTimestampFun),
-	DUCKDB_SCALAR_FUNCTION(ToWeeksFun),
-	DUCKDB_SCALAR_FUNCTION(ToYearsFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(TransactionTimestampFun),
-	DUCKDB_SCALAR_FUNCTION(TranslateFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TrimFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TruncFun),
-	DUCKDB_SCALAR_FUNCTION(CurrentTransactionIdFun),
-	DUCKDB_SCALAR_FUNCTION(TypeOfFun),
-	DUCKDB_SCALAR_FUNCTION(UnbinFun),
-	DUCKDB_SCALAR_FUNCTION(UnhexFun),
-	DUCKDB_SCALAR_FUNCTION(UnicodeFun),
-	DUCKDB_SCALAR_FUNCTION(UnionExtractFun),
-	DUCKDB_SCALAR_FUNCTION(UnionTagFun),
-	DUCKDB_SCALAR_FUNCTION(UnionValueFun),
-	DUCKDB_SCALAR_FUNCTION(UnpivotListFun),
-	DUCKDB_SCALAR_FUNCTION(UrlDecodeFun),
-	DUCKDB_SCALAR_FUNCTION(UrlEncodeFun),
-	DUCKDB_SCALAR_FUNCTION(UUIDFun),
-	DUCKDB_AGGREGATE_FUNCTION(VarPopFun),
-	DUCKDB_AGGREGATE_FUNCTION(VarSampFun),
-	DUCKDB_AGGREGATE_FUNCTION_ALIAS(VarianceFun),
-	DUCKDB_SCALAR_FUNCTION(VectorTypeFun),
-	DUCKDB_SCALAR_FUNCTION(VersionFun),
-	DUCKDB_SCALAR_FUNCTION_SET(WeekFun),
-	DUCKDB_SCALAR_FUNCTION_SET(WeekDayFun),
-	DUCKDB_SCALAR_FUNCTION_SET(WeekOfYearFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitwiseXorFun),
-	DUCKDB_SCALAR_FUNCTION_SET(YearFun),
-	DUCKDB_SCALAR_FUNCTION_SET(YearWeekFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitwiseOrFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitwiseNotFun),
-	FINAL_FUNCTION
-};
-
-const StaticFunctionDefinition *StaticFunctionDefinition::GetFunctionList() {
-	return core_functions;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/corr.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/corr.hpp
deleted file mode 100644
index 05cdfb145..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/corr.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/algebraic/corr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/aggregate_function.hpp"
-#include "core_functions/aggregate/algebraic/covar.hpp"
-#include "core_functions/aggregate/algebraic/stddev.hpp"
-
-namespace duckdb {
-
-struct CorrState {
-	CovarState cov_pop;
-	StddevState dev_pop_x;
-	StddevState dev_pop_y;
-};
-
-// Returns the correlation coefficient for non-null pairs in a group.
-// CORR(y, x) = COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))
-struct CorrOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		CovarOperation::Initialize<CovarState>(state.cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(state.dev_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(state.dev_pop_y);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.dev_pop_x, x);
-		STDDevBaseOperation::Execute<B_TYPE, StddevState>(state.dev_pop_y, y);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_x, target.dev_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_y, target.dev_pop_y, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.cov_pop.count == 0 || state.dev_pop_x.count == 0 || state.dev_pop_y.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			auto cov = state.cov_pop.co_moment / state.cov_pop.count;
-			auto std_x = state.dev_pop_x.count > 1 ? sqrt(state.dev_pop_x.dsquared / state.dev_pop_x.count) : 0;
-			if (!Value::DoubleIsFinite(std_x)) {
-				throw OutOfRangeException("STDDEV_POP for X is out of range!");
-			}
-			auto std_y = state.dev_pop_y.count > 1 ? sqrt(state.dev_pop_y.dsquared / state.dev_pop_y.count) : 0;
-			if (!Value::DoubleIsFinite(std_y)) {
-				throw OutOfRangeException("STDDEV_POP for Y is out of range!");
-			}
-			target = std_x * std_y != 0 ? cov / (std_x * std_y) : NAN;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/covar.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/covar.hpp
deleted file mode 100644
index 1908dfad1..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/covar.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/algebraic/covar.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// COVAR_POP(y,x)
-
-#pragma once
-
-#include "duckdb/function/aggregate_function.hpp"
-
-namespace duckdb {
-
-struct CovarState {
-	uint64_t count;
-	double meanx;
-	double meany;
-	double co_moment;
-};
-
-struct CovarOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.count = 0;
-		state.meanx = 0;
-		state.meany = 0;
-		state.co_moment = 0;
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		// update running mean and d^2
-		const double n = static_cast<double>(++(state.count));
-
-		const double dx = (x - state.meanx);
-		const double meanx = state.meanx + dx / n;
-
-		const double dy = (y - state.meany);
-		const double meany = state.meany + dy / n;
-
-		//  Schubert and Gertz SSDBM 2018 (4.3)
-		const double C = state.co_moment + dx * (y - meany);
-
-		state.meanx = meanx;
-		state.meany = meany;
-		state.co_moment = C;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (target.count == 0) {
-			target = source;
-		} else if (source.count > 0) {
-			const auto count = target.count + source.count;
-			D_ASSERT(count >= target.count); // This is a check that we are not overflowing
-			const auto target_count = static_cast<double>(target.count);
-			const auto source_count = static_cast<double>(source.count);
-			const auto total_count = static_cast<double>(count);
-			const auto meanx = (source_count * source.meanx + target_count * target.meanx) / total_count;
-			const auto meany = (source_count * source.meany + target_count * target.meany) / total_count;
-
-			//  Schubert and Gertz SSDBM 2018, equation 21
-			const auto deltax = target.meanx - source.meanx;
-			const auto deltay = target.meany - source.meany;
-			target.co_moment =
-			    source.co_moment + target.co_moment + deltax * deltay * source_count * target_count / total_count;
-			target.meanx = meanx;
-			target.meany = meany;
-			target.count = count;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct CovarPopOperation : public CovarOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.co_moment / state.count;
-		}
-	}
-};
-
-struct CovarSampOperation : public CovarOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count < 2) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.co_moment / (state.count - 1);
-		}
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/stddev.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/stddev.hpp
deleted file mode 100644
index bdcafae95..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/stddev.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/algebraic/stddev.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/aggregate_function.hpp"
-#include <ctgmath>
-
-namespace duckdb {
-
-struct StddevState {
-	uint64_t count;  //  n
-	double mean;     //  M1
-	double dsquared; //  M2
-};
-
-// Streaming approximate standard deviation using Welford's
-// method, DOI: 10.2307/1266577
-struct STDDevBaseOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.count = 0;
-		state.mean = 0;
-		state.dsquared = 0;
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, const INPUT_TYPE &input) {
-		// update running mean and d^2
-		state.count++;
-		const double mean_differential = (input - state.mean) / state.count;
-		const double new_mean = state.mean + mean_differential;
-		const double dsquared_increment = (input - new_mean) * (input - state.mean);
-		const double new_dsquared = state.dsquared + dsquared_increment;
-
-		state.mean = new_mean;
-		state.dsquared = new_dsquared;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
-		Execute(state, input);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (target.count == 0) {
-			target = source;
-		} else if (source.count > 0) {
-			const auto count = target.count + source.count;
-			D_ASSERT(count >= target.count); // This is a check that we are not overflowing
-			const double target_count = static_cast<double>(target.count);
-			const double source_count = static_cast<double>(source.count);
-			const double total_count = static_cast<double>(count);
-			const auto mean = (source_count * source.mean + target_count * target.mean) / total_count;
-			const auto delta = source.mean - target.mean;
-			target.dsquared =
-			    source.dsquared + target.dsquared + delta * delta * source_count * target_count / total_count;
-			target.mean = mean;
-			target.count = count;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct VarSampOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count <= 1) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.dsquared / (state.count - 1);
-			if (!Value::DoubleIsFinite(target)) {
-				throw OutOfRangeException("VARSAMP is out of range!");
-			}
-		}
-	}
-};
-
-struct VarPopOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.count > 1 ? (state.dsquared / state.count) : 0;
-			if (!Value::DoubleIsFinite(target)) {
-				throw OutOfRangeException("VARPOP is out of range!");
-			}
-		}
-	}
-};
-
-struct STDDevSampOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count <= 1) {
-			finalize_data.ReturnNull();
-		} else {
-			target = sqrt(state.dsquared / (state.count - 1));
-			if (!Value::DoubleIsFinite(target)) {
-				throw OutOfRangeException("STDDEV_SAMP is out of range!");
-			}
-		}
-	}
-};
-
-struct STDDevPopOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.count > 1 ? sqrt(state.dsquared / state.count) : 0;
-			if (!Value::DoubleIsFinite(target)) {
-				throw OutOfRangeException("STDDEV_POP is out of range!");
-			}
-		}
-	}
-};
-
-struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			target = sqrt(state.dsquared / state.count) / sqrt((state.count));
-			if (!Value::DoubleIsFinite(target)) {
-				throw OutOfRangeException("SEM is out of range!");
-			}
-		}
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic_functions.hpp
deleted file mode 100644
index da08c769a..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic_functions.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/aggregate/algebraic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct AvgFun {
-	static constexpr const char *Name = "avg";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Calculates the average value for all tuples in x.";
-	static constexpr const char *Example = "SUM(x) / COUNT(*)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct MeanFun {
-	using ALIAS = AvgFun;
-
-	static constexpr const char *Name = "mean";
-};
-
-struct CorrFun {
-	static constexpr const char *Name = "corr";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the correlation coefficient for non-null pairs in a group.";
-	static constexpr const char *Example = "COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))";
-
-	static AggregateFunction GetFunction();
-};
-
-struct CovarPopFun {
-	static constexpr const char *Name = "covar_pop";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the population covariance of input values.";
-	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / COUNT(*)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct CovarSampFun {
-	static constexpr const char *Name = "covar_samp";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the sample covariance for non-null pairs in a group.";
-	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / (COUNT(*) - 1)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct FAvgFun {
-	static constexpr const char *Name = "favg";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Calculates the average using a more accurate floating point summation (Kahan Sum)";
-	static constexpr const char *Example = "favg(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct StandardErrorOfTheMeanFun {
-	static constexpr const char *Name = "sem";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the standard error of the mean";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct StdDevPopFun {
-	static constexpr const char *Name = "stddev_pop";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the population standard deviation.";
-	static constexpr const char *Example = "sqrt(var_pop(x))";
-
-	static AggregateFunction GetFunction();
-};
-
-struct StdDevSampFun {
-	static constexpr const char *Name = "stddev_samp";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the sample standard deviation";
-	static constexpr const char *Example = "sqrt(var_samp(x))";
-
-	static AggregateFunction GetFunction();
-};
-
-struct StddevFun {
-	using ALIAS = StdDevSampFun;
-
-	static constexpr const char *Name = "stddev";
-};
-
-struct VarPopFun {
-	static constexpr const char *Name = "var_pop";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the population variance.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct VarSampFun {
-	static constexpr const char *Name = "var_samp";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the sample variance of all input values.";
-	static constexpr const char *Example = "(SUM(x^2) - SUM(x)^2 / COUNT(x)) / (COUNT(x) - 1)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct VarianceFun {
-	using ALIAS = VarSampFun;
-
-	static constexpr const char *Name = "variance";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/distributive_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/distributive_functions.hpp
deleted file mode 100644
index 50c0197a9..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/distributive_functions.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/aggregate/distributive_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ApproxCountDistinctFun {
-	static constexpr const char *Name = "approx_count_distinct";
-	static constexpr const char *Parameters = "any";
-	static constexpr const char *Description = "Computes the approximate count of distinct elements using HyperLogLog.";
-	static constexpr const char *Example = "approx_count_distinct(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct ArgMinFun {
-	static constexpr const char *Name = "arg_min";
-	static constexpr const char *Parameters = "arg,val";
-	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the non-NULL arg expression at that row.";
-	static constexpr const char *Example = "arg_min(A,B)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ArgminFun {
-	using ALIAS = ArgMinFun;
-
-	static constexpr const char *Name = "argmin";
-};
-
-struct MinByFun {
-	using ALIAS = ArgMinFun;
-
-	static constexpr const char *Name = "min_by";
-};
-
-struct ArgMinNullFun {
-	static constexpr const char *Name = "arg_min_null";
-	static constexpr const char *Parameters = "arg,val";
-	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the arg expression at that row.";
-	static constexpr const char *Example = "arg_min_null(A,B)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ArgMaxFun {
-	static constexpr const char *Name = "arg_max";
-	static constexpr const char *Parameters = "arg,val";
-	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the non-NULL arg expression at that row.";
-	static constexpr const char *Example = "arg_max(A,B)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ArgmaxFun {
-	using ALIAS = ArgMaxFun;
-
-	static constexpr const char *Name = "argmax";
-};
-
-struct MaxByFun {
-	using ALIAS = ArgMaxFun;
-
-	static constexpr const char *Name = "max_by";
-};
-
-struct ArgMaxNullFun {
-	static constexpr const char *Name = "arg_max_null";
-	static constexpr const char *Parameters = "arg,val";
-	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the arg expression at that row.";
-	static constexpr const char *Example = "arg_max_null(A,B)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct BitAndFun {
-	static constexpr const char *Name = "bit_and";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the bitwise AND of all bits in a given expression.";
-	static constexpr const char *Example = "bit_and(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct BitOrFun {
-	static constexpr const char *Name = "bit_or";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the bitwise OR of all bits in a given expression.";
-	static constexpr const char *Example = "bit_or(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct BitXorFun {
-	static constexpr const char *Name = "bit_xor";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the bitwise XOR of all bits in a given expression.";
-	static constexpr const char *Example = "bit_xor(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct BitstringAggFun {
-	static constexpr const char *Name = "bitstring_agg";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns a bitstring with bits set for each distinct value.";
-	static constexpr const char *Example = "bitstring_agg(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct BoolAndFun {
-	static constexpr const char *Name = "bool_and";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns TRUE if every input value is TRUE, otherwise FALSE.";
-	static constexpr const char *Example = "bool_and(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct BoolOrFun {
-	static constexpr const char *Name = "bool_or";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns TRUE if any input value is TRUE, otherwise FALSE.";
-	static constexpr const char *Example = "bool_or(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct CountIfFun {
-	static constexpr const char *Name = "count_if";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Counts the total number of TRUE values for a boolean column";
-	static constexpr const char *Example = "count_if(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct CountifFun {
-	using ALIAS = CountIfFun;
-
-	static constexpr const char *Name = "countif";
-};
-
-struct EntropyFun {
-	static constexpr const char *Name = "entropy";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the log-2 entropy of count input-values.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct KahanSumFun {
-	static constexpr const char *Name = "kahan_sum";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Calculates the sum using a more accurate floating point summation (Kahan Sum).";
-	static constexpr const char *Example = "kahan_sum(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct FsumFun {
-	using ALIAS = KahanSumFun;
-
-	static constexpr const char *Name = "fsum";
-};
-
-struct SumkahanFun {
-	using ALIAS = KahanSumFun;
-
-	static constexpr const char *Name = "sumkahan";
-};
-
-struct KurtosisFun {
-	static constexpr const char *Name = "kurtosis";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the excess kurtosis (Fisher’s definition) of all input values, with a bias correction according to the sample size";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct KurtosisPopFun {
-	static constexpr const char *Name = "kurtosis_pop";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the excess kurtosis (Fisher’s definition) of all input values, without bias correction";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct ProductFun {
-	static constexpr const char *Name = "product";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Calculates the product of all tuples in arg.";
-	static constexpr const char *Example = "product(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct SkewnessFun {
-	static constexpr const char *Name = "skewness";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the skewness of all input values.";
-	static constexpr const char *Example = "skewness(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct StringAggFun {
-	static constexpr const char *Name = "string_agg";
-	static constexpr const char *Parameters = "str,arg";
-	static constexpr const char *Description = "Concatenates the column string values with an optional separator.";
-	static constexpr const char *Example = "string_agg(A, '-')";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct GroupConcatFun {
-	using ALIAS = StringAggFun;
-
-	static constexpr const char *Name = "group_concat";
-};
-
-struct ListaggFun {
-	using ALIAS = StringAggFun;
-
-	static constexpr const char *Name = "listagg";
-};
-
-struct SumFun {
-	static constexpr const char *Name = "sum";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Calculates the sum value for all tuples in arg.";
-	static constexpr const char *Example = "sum(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct SumNoOverflowFun {
-	static constexpr const char *Name = "sum_no_overflow";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Internal only. Calculates the sum value for all tuples in arg without overflow checks.";
-	static constexpr const char *Example = "sum_no_overflow(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/histogram_helpers.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/histogram_helpers.hpp
deleted file mode 100644
index 7d73a3caf..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/histogram_helpers.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/histogram_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-
-namespace duckdb {
-
-struct HistogramFunctor {
-	template <class T>
-	static void HistogramFinalize(T value, Vector &result, idx_t offset) {
-		FlatVector::GetData<T>(result)[offset] = value;
-	}
-
-	static bool CreateExtraState(idx_t count) {
-		return false;
-	}
-
-	static void PrepareData(Vector &input, idx_t count, bool &, UnifiedVectorFormat &result) {
-		input.ToUnifiedFormat(count, result);
-	}
-
-	template <class T>
-	static T ExtractValue(UnifiedVectorFormat &bin_data, idx_t offset, AggregateInputData &) {
-		return UnifiedVectorFormat::GetData<T>(bin_data)[bin_data.sel->get_index(offset)];
-	}
-
-	static bool RequiresExtract() {
-		return false;
-	}
-};
-
-struct HistogramStringFunctorBase {
-	template <class T>
-	static T ExtractValue(UnifiedVectorFormat &bin_data, idx_t offset, AggregateInputData &aggr_input) {
-		auto &input_str = UnifiedVectorFormat::GetData<T>(bin_data)[bin_data.sel->get_index(offset)];
-		if (input_str.IsInlined()) {
-			// inlined strings can be inserted directly
-			return input_str;
-		}
-		// if the string is not inlined we need to allocate space for it
-		auto input_str_size = UnsafeNumericCast<uint32_t>(input_str.GetSize());
-		auto string_memory = aggr_input.allocator.Allocate(input_str_size);
-		// copy over the string
-		memcpy(string_memory, input_str.GetData(), input_str_size);
-		// now insert it into the histogram
-		string_t histogram_str(char_ptr_cast(string_memory), input_str_size);
-		return histogram_str;
-	}
-
-	static bool RequiresExtract() {
-		return true;
-	}
-};
-
-struct HistogramStringFunctor : HistogramStringFunctorBase {
-	template <class T>
-	static void HistogramFinalize(T value, Vector &result, idx_t offset) {
-		FlatVector::GetData<string_t>(result)[offset] = StringVector::AddStringOrBlob(result, value);
-	}
-
-	static bool CreateExtraState(idx_t count) {
-		return false;
-	}
-
-	static void PrepareData(Vector &input, idx_t count, bool &, UnifiedVectorFormat &result) {
-		input.ToUnifiedFormat(count, result);
-	}
-};
-
-struct HistogramGenericFunctor : HistogramStringFunctorBase {
-	template <class T>
-	static void HistogramFinalize(T value, Vector &result, idx_t offset) {
-		CreateSortKeyHelpers::DecodeSortKey(value, result, offset,
-		                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
-	}
-
-	static Vector CreateExtraState(idx_t count) {
-		return Vector(LogicalType::BLOB, count);
-	}
-
-	static void PrepareData(Vector &input, idx_t count, Vector &extra_state, UnifiedVectorFormat &result) {
-		OrderModifiers modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-		CreateSortKeyHelpers::CreateSortKey(input, count, modifiers, extra_state);
-		input.Flatten(count);
-		extra_state.Flatten(count);
-		FlatVector::Validity(extra_state).Initialize(FlatVector::Validity(input));
-		extra_state.ToUnifiedFormat(count, result);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/holistic_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/holistic_functions.hpp
deleted file mode 100644
index f8b96a166..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/holistic_functions.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/aggregate/holistic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ApproxQuantileFun {
-	static constexpr const char *Name = "approx_quantile";
-	static constexpr const char *Parameters = "x,pos";
-	static constexpr const char *Description = "Computes the approximate quantile using T-Digest.";
-	static constexpr const char *Example = "approx_quantile(x, 0.5)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct MadFun {
-	static constexpr const char *Name = "mad";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the median absolute deviation for the values within x. NULL values are ignored. Temporal types return a positive INTERVAL.	";
-	static constexpr const char *Example = "mad(x)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct MedianFun {
-	static constexpr const char *Name = "median";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the middle value of the set. NULL values are ignored. For even value counts, quantitative values are averaged and ordinal values return the lower value.";
-	static constexpr const char *Example = "median(x)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ModeFun {
-	static constexpr const char *Name = "mode";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the most frequent value for the values within x. NULL values are ignored.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct QuantileDiscFun {
-	static constexpr const char *Name = "quantile_disc";
-	static constexpr const char *Parameters = "x,pos";
-	static constexpr const char *Description = "Returns the exact quantile number between 0 and 1 . If pos is a LIST of FLOATs, then the result is a LIST of the corresponding exact quantiles.";
-	static constexpr const char *Example = "quantile_disc(x, 0.5)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct QuantileFun {
-	using ALIAS = QuantileDiscFun;
-
-	static constexpr const char *Name = "quantile";
-};
-
-struct QuantileContFun {
-	static constexpr const char *Name = "quantile_cont";
-	static constexpr const char *Parameters = "x,pos";
-	static constexpr const char *Description = "Returns the interpolated quantile number between 0 and 1 . If pos is a LIST of FLOATs, then the result is a LIST of the corresponding interpolated quantiles.	";
-	static constexpr const char *Example = "quantile_cont(x, 0.5)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ReservoirQuantileFun {
-	static constexpr const char *Name = "reservoir_quantile";
-	static constexpr const char *Parameters = "x,quantile,sample_size";
-	static constexpr const char *Description = "Gives the approximate quantile using reservoir sampling, the sample size is optional and uses 8192 as a default size.";
-	static constexpr const char *Example = "reservoir_quantile(A,0.5,1024)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ApproxTopKFun {
-	static constexpr const char *Name = "approx_top_k";
-	static constexpr const char *Parameters = "val,k";
-	static constexpr const char *Description = "Finds the k approximately most occurring values in the data set";
-	static constexpr const char *Example = "approx_top_k(x, 5)";
-
-	static AggregateFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/nested_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/nested_functions.hpp
deleted file mode 100644
index eb83e5e15..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/nested_functions.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/aggregate/nested_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct HistogramFun {
-	static constexpr const char *Name = "histogram";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns a LIST of STRUCTs with the fields bucket and count.";
-	static constexpr const char *Example = "histogram(A)";
-
-	static AggregateFunctionSet GetFunctions();
-	static AggregateFunction GetHistogramUnorderedMap(LogicalType &type);
-	static AggregateFunction BinnedHistogramFunction();
-};
-
-struct HistogramExactFun {
-	static constexpr const char *Name = "histogram_exact";
-	static constexpr const char *Parameters = "arg,bins";
-	static constexpr const char *Description = "Returns a LIST of STRUCTs with the fields bucket and count matching the buckets exactly.";
-	static constexpr const char *Example = "histogram_exact(A, [0, 1, 2])";
-
-	static AggregateFunction GetFunction();
-};
-
-struct ListFun {
-	static constexpr const char *Name = "list";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns a LIST containing all the values of a column.";
-	static constexpr const char *Example = "list(A)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct ArrayAggFun {
-	using ALIAS = ListFun;
-
-	static constexpr const char *Name = "array_agg";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_helpers.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_helpers.hpp
deleted file mode 100644
index 253657f5a..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_helpers.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/quantile_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/quantile_enum.hpp"
-#include "core_functions/aggregate/holistic_functions.hpp"
-
-namespace duckdb {
-
-//	Avoid using naked Values in inner loops...
-struct QuantileValue {
-	explicit QuantileValue(const Value &v) : val(v), dbl(v.GetValue<double>()) {
-		const auto &type = val.type();
-		switch (type.id()) {
-		case LogicalTypeId::DECIMAL: {
-			integral = IntegralValue::Get(v);
-			scaling = Hugeint::POWERS_OF_TEN[DecimalType::GetScale(type)];
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	Value val;
-
-	//	DOUBLE
-	double dbl;
-
-	//	DECIMAL
-	hugeint_t integral;
-	hugeint_t scaling;
-
-	inline bool operator==(const QuantileValue &other) const {
-		return val == other.val;
-	}
-};
-
-struct QuantileBindData : public FunctionData {
-	QuantileBindData();
-	explicit QuantileBindData(const Value &quantile_p);
-	explicit QuantileBindData(const vector<Value> &quantiles_p);
-	QuantileBindData(const QuantileBindData &other);
-
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-
-	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                      const AggregateFunction &function);
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function);
-
-	vector<QuantileValue> quantiles;
-	vector<idx_t> order;
-	bool desc;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_sort_tree.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_sort_tree.hpp
deleted file mode 100644
index a330c0a4b..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_sort_tree.hpp
+++ /dev/null
@@ -1,431 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/quantile_sort_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-#include "core_functions/aggregate/quantile_helpers.hpp"
-#include "duckdb/execution/merge_sort_tree.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/function/window/window_index_tree.hpp"
-#include <algorithm>
-#include <numeric>
-#include <stdlib.h>
-#include <utility>
-
-namespace duckdb {
-
-// Paged access
-template <typename INPUT_TYPE>
-struct QuantileCursor {
-	explicit QuantileCursor(const WindowPartitionInput &partition) : inputs(*partition.inputs) {
-		D_ASSERT(partition.column_ids.size() == 1);
-		inputs.InitializeScan(scan, partition.column_ids);
-		inputs.InitializeScanChunk(scan, page);
-
-		D_ASSERT(partition.all_valid.size() == 1);
-		all_valid = partition.all_valid[0];
-	}
-
-	inline sel_t RowOffset(idx_t row_idx) const {
-		D_ASSERT(RowIsVisible(row_idx));
-		return UnsafeNumericCast<sel_t>(row_idx - scan.current_row_index);
-	}
-
-	inline bool RowIsVisible(idx_t row_idx) const {
-		return (row_idx < scan.next_row_index && scan.current_row_index <= row_idx);
-	}
-
-	inline idx_t Seek(idx_t row_idx) {
-		if (!RowIsVisible(row_idx)) {
-			inputs.Seek(row_idx, scan, page);
-			data = FlatVector::GetData<INPUT_TYPE>(page.data[0]);
-			validity = &FlatVector::Validity(page.data[0]);
-		}
-		return RowOffset(row_idx);
-	}
-
-	inline const INPUT_TYPE &operator[](idx_t row_idx) {
-		const auto offset = Seek(row_idx);
-		return data[offset];
-	}
-
-	inline bool RowIsValid(idx_t row_idx) {
-		const auto offset = Seek(row_idx);
-		return validity->RowIsValid(offset);
-	}
-
-	inline bool AllValid() {
-		return all_valid;
-	}
-
-	//! Windowed paging
-	const ColumnDataCollection &inputs;
-	//! The state used for reading the collection on this thread
-	ColumnDataScanState scan;
-	//! The data chunk paged into into
-	DataChunk page;
-	//! The data pointer
-	const INPUT_TYPE *data = nullptr;
-	//! The validity mask
-	const ValidityMask *validity = nullptr;
-	//! Paged chunks do not track this but it is really necessary for performance
-	bool all_valid;
-};
-
-// Direct access
-template <typename T>
-struct QuantileDirect {
-	using INPUT_TYPE = T;
-	using RESULT_TYPE = T;
-
-	inline const INPUT_TYPE &operator()(const INPUT_TYPE &x) const {
-		return x;
-	}
-};
-
-// Indirect access
-template <typename T>
-struct QuantileIndirect {
-	using INPUT_TYPE = idx_t;
-	using RESULT_TYPE = T;
-	using CURSOR = QuantileCursor<RESULT_TYPE>;
-	CURSOR &data;
-
-	explicit QuantileIndirect(CURSOR &data_p) : data(data_p) {
-	}
-
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		return data[input];
-	}
-};
-
-// Composed access
-template <typename OUTER, typename INNER>
-struct QuantileComposed {
-	using INPUT_TYPE = typename INNER::INPUT_TYPE;
-	using RESULT_TYPE = typename OUTER::RESULT_TYPE;
-
-	const OUTER &outer;
-	const INNER &inner;
-
-	explicit QuantileComposed(const OUTER &outer_p, const INNER &inner_p) : outer(outer_p), inner(inner_p) {
-	}
-
-	inline RESULT_TYPE operator()(const idx_t &input) const {
-		return outer(inner(input));
-	}
-};
-
-// Accessed comparison
-template <typename ACCESSOR>
-struct QuantileCompare {
-	using INPUT_TYPE = typename ACCESSOR::INPUT_TYPE;
-	const ACCESSOR &accessor_l;
-	const ACCESSOR &accessor_r;
-	const bool desc;
-
-	// Single cursor for linear operations
-	explicit QuantileCompare(const ACCESSOR &accessor, bool desc_p)
-	    : accessor_l(accessor), accessor_r(accessor), desc(desc_p) {
-	}
-
-	// Independent cursors for sorting
-	explicit QuantileCompare(const ACCESSOR &accessor_l, const ACCESSOR &accessor_r, bool desc_p)
-	    : accessor_l(accessor_l), accessor_r(accessor_r), desc(desc_p) {
-	}
-
-	inline bool operator()(const INPUT_TYPE &lhs, const INPUT_TYPE &rhs) const {
-		const auto lval = accessor_l(lhs);
-		const auto rval = accessor_r(rhs);
-
-		return desc ? (rval < lval) : (lval < rval);
-	}
-};
-
-struct CastInterpolation {
-	template <class INPUT_TYPE, class TARGET_TYPE>
-	static inline TARGET_TYPE Cast(const INPUT_TYPE &src, Vector &result) {
-		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(src);
-	}
-	template <typename TARGET_TYPE>
-	static inline TARGET_TYPE Interpolate(const TARGET_TYPE &lo, const double d, const TARGET_TYPE &hi) {
-		const auto delta = hi - lo;
-		return LossyNumericCast<TARGET_TYPE>(lo + delta * d);
-	}
-};
-
-template <>
-interval_t CastInterpolation::Cast(const dtime_t &src, Vector &result);
-template <>
-double CastInterpolation::Interpolate(const double &lo, const double d, const double &hi);
-template <>
-dtime_t CastInterpolation::Interpolate(const dtime_t &lo, const double d, const dtime_t &hi);
-template <>
-timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d, const timestamp_t &hi);
-template <>
-hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi);
-template <>
-interval_t CastInterpolation::Interpolate(const interval_t &lo, const double d, const interval_t &hi);
-template <>
-string_t CastInterpolation::Cast(const string_t &src, Vector &result);
-
-// Continuous interpolation
-template <bool DISCRETE>
-struct Interpolator {
-	Interpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
-	    : desc(desc_p), RN((double)(n_p - 1) * q.dbl), FRN(ExactNumericCast<idx_t>(floor(RN))),
-	      CRN(ExactNumericCast<idx_t>(ceil(RN))), begin(0), end(n_p) {
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Interpolate(INPUT_TYPE lidx, INPUT_TYPE hidx, Vector &result, const ACCESSOR &accessor) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		if (lidx == hidx) {
-			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
-		} else {
-			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
-			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(hidx), result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
-		}
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Operation(INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		QuantileCompare<ACCESSOR> comp(accessor, desc);
-		if (CRN == FRN) {
-			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-		} else {
-			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-			std::nth_element(v_t + FRN, v_t + CRN, v_t + end, comp);
-			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
-		}
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE>
-	inline TARGET_TYPE Extract(const INPUT_TYPE *dest, Vector &result) const {
-		if (CRN == FRN) {
-			return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
-		} else {
-			auto lo = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
-			auto hi = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[1], result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
-		}
-	}
-
-	const bool desc;
-	const double RN;
-	const idx_t FRN;
-	const idx_t CRN;
-
-	idx_t begin;
-	idx_t end;
-};
-
-// Discrete "interpolation"
-template <>
-struct Interpolator<true> {
-	static inline idx_t Index(const QuantileValue &q, const idx_t n) {
-		idx_t floored;
-		switch (q.val.type().id()) {
-		case LogicalTypeId::DECIMAL: {
-			//	Integer arithmetic for accuracy
-			const auto integral = q.integral;
-			const auto scaling = q.scaling;
-			const auto scaled_q =
-			    DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(Hugeint::Convert(n), integral);
-			const auto scaled_n =
-			    DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(Hugeint::Convert(n), scaling);
-			floored = Cast::Operation<hugeint_t, idx_t>((scaled_n - scaled_q) / scaling);
-			break;
-		}
-		default:
-			const auto scaled_q = double(n) * q.dbl;
-			floored = LossyNumericCast<idx_t>(floor(double(n) - scaled_q));
-			break;
-		}
-
-		return MaxValue<idx_t>(1, n - floored) - 1;
-	}
-
-	Interpolator(const QuantileValue &q, const idx_t n_p, bool desc_p)
-	    : desc(desc_p), FRN(Index(q, n_p)), CRN(FRN), begin(0), end(n_p) {
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Interpolate(INPUT_TYPE lidx, INPUT_TYPE hidx, Vector &result, const ACCESSOR &accessor) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
-	}
-
-	template <class INPUT_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	typename ACCESSOR::RESULT_TYPE InterpolateInternal(INPUT_TYPE *v_t, const ACCESSOR &accessor = ACCESSOR()) const {
-		QuantileCompare<ACCESSOR> comp(accessor, desc);
-		std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-		return accessor(v_t[FRN]);
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Operation(INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(InterpolateInternal(v_t, accessor), result);
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE>
-	TARGET_TYPE Extract(const INPUT_TYPE *dest, Vector &result) const {
-		return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
-	}
-
-	const bool desc;
-	const idx_t FRN;
-	const idx_t CRN;
-
-	idx_t begin;
-	idx_t end;
-};
-
-template <typename INPUT_TYPE>
-struct QuantileIncluded {
-	using CURSOR_TYPE = QuantileCursor<INPUT_TYPE>;
-
-	inline explicit QuantileIncluded(const ValidityMask &fmask_p, CURSOR_TYPE &dmask_p)
-	    : fmask(fmask_p), dmask(dmask_p) {
-	}
-
-	inline bool operator()(const idx_t &idx) {
-		return fmask.RowIsValid(idx) && dmask.RowIsValid(idx);
-	}
-
-	inline bool AllValid() {
-		return fmask.AllValid() && dmask.AllValid();
-	}
-
-	const ValidityMask &fmask;
-	CURSOR_TYPE &dmask;
-};
-
-struct QuantileSortTree {
-
-	unique_ptr<WindowIndexTree> index_tree;
-
-	QuantileSortTree(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition) {
-		// TODO: Two pass parallel sorting using Build
-		auto &inputs = *partition.inputs;
-		ColumnDataScanState scan;
-		DataChunk sort;
-		inputs.InitializeScan(scan, partition.column_ids);
-		inputs.InitializeScanChunk(scan, sort);
-
-		// Sort on the single argument
-		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
-		auto order_expr = make_uniq<BoundConstantExpression>(Value(sort.GetTypes()[0]));
-		auto order_type = bind_data.desc ? OrderType::DESCENDING : OrderType::ASCENDING;
-		BoundOrderModifier order_bys;
-		order_bys.orders.emplace_back(BoundOrderByNode(order_type, OrderByNullType::NULLS_LAST, std::move(order_expr)));
-		vector<column_t> sort_idx(1, 0);
-		const auto count = partition.count;
-
-		index_tree = make_uniq<WindowIndexTree>(partition.context, order_bys, sort_idx, count);
-		auto index_state = index_tree->GetLocalState();
-		auto &local_state = index_state->Cast<WindowIndexTreeLocalState>();
-
-		//	Build the indirection array by scanning the valid indices
-		const auto &filter_mask = partition.filter_mask;
-		SelectionVector filter_sel(STANDARD_VECTOR_SIZE);
-		while (inputs.Scan(scan, sort)) {
-			const auto row_idx = scan.current_row_index;
-			if (!filter_mask.AllValid() || !partition.all_valid[0]) {
-				auto &key = sort.data[0];
-				auto &validity = FlatVector::Validity(key);
-				idx_t filtered = 0;
-				for (sel_t i = 0; i < sort.size(); ++i) {
-					if (filter_mask.RowIsValid(i + row_idx) && validity.RowIsValid(i)) {
-						filter_sel[filtered++] = i;
-					}
-				}
-				local_state.SinkChunk(sort, row_idx, filter_sel, filtered);
-			} else {
-				local_state.SinkChunk(sort, row_idx, nullptr, 0);
-			}
-		}
-		local_state.Sort();
-	}
-
-	inline idx_t SelectNth(const SubFrames &frames, size_t n) const {
-		return index_tree->SelectNth(frames, n);
-	}
-
-	template <typename INPUT_TYPE, typename RESULT_TYPE, bool DISCRETE>
-	RESULT_TYPE WindowScalar(QuantileCursor<INPUT_TYPE> &data, const SubFrames &frames, const idx_t n, Vector &result,
-	                         const QuantileValue &q) {
-		D_ASSERT(n > 0);
-
-		//	Thread safe and idempotent.
-		index_tree->Build();
-
-		//	Find the interpolated indicies within the frame
-		Interpolator<DISCRETE> interp(q, n, false);
-		const auto lo_data = SelectNth(frames, interp.FRN);
-		auto hi_data = lo_data;
-		if (interp.CRN != interp.FRN) {
-			hi_data = SelectNth(frames, interp.CRN);
-		}
-
-		//	Interpolate indirectly
-		using ID = QuantileIndirect<INPUT_TYPE>;
-		ID indirect(data);
-		return interp.template Interpolate<idx_t, RESULT_TYPE, ID>(lo_data, hi_data, result, indirect);
-	}
-
-	template <typename INPUT_TYPE, typename CHILD_TYPE, bool DISCRETE>
-	void WindowList(QuantileCursor<INPUT_TYPE> &data, const SubFrames &frames, const idx_t n, Vector &list,
-	                const idx_t lidx, const QuantileBindData &bind_data) {
-		D_ASSERT(n > 0);
-
-		//	Thread safe and idempotent.
-		index_tree->Build();
-
-		// Result is a constant LIST<CHILD_TYPE> with a fixed length
-		auto ldata = FlatVector::GetData<list_entry_t>(list);
-		auto &lentry = ldata[lidx];
-		lentry.offset = ListVector::GetListSize(list);
-		lentry.length = bind_data.quantiles.size();
-
-		ListVector::Reserve(list, lentry.offset + lentry.length);
-		ListVector::SetListSize(list, lentry.offset + lentry.length);
-		auto &result = ListVector::GetEntry(list);
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		using ID = QuantileIndirect<INPUT_TYPE>;
-		ID indirect(data);
-		for (const auto &q : bind_data.order) {
-			const auto &quantile = bind_data.quantiles[q];
-			Interpolator<DISCRETE> interp(quantile, n, false);
-
-			const auto lo_data = SelectNth(frames, interp.FRN);
-			auto hi_data = lo_data;
-			if (interp.CRN != interp.FRN) {
-				hi_data = SelectNth(frames, interp.CRN);
-			}
-
-			//	Interpolate indirectly
-			rdata[lentry.offset + q] =
-			    interp.template Interpolate<idx_t, CHILD_TYPE, ID>(lo_data, hi_data, result, indirect);
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_state.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_state.hpp
deleted file mode 100644
index 00f4baf77..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_state.hpp
+++ /dev/null
@@ -1,307 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/quantile_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "core_functions/aggregate/quantile_sort_tree.hpp"
-#include "SkipList.h"
-
-namespace duckdb {
-
-struct QuantileOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		new (&state) STATE();
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &aggr_input) {
-		state.AddElement(input, aggr_input.input);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (source.v.empty()) {
-			return;
-		}
-		target.v.insert(target.v.end(), source.v.begin(), source.v.end());
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &) {
-		state.~STATE();
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE, class INPUT_TYPE>
-	static void WindowInit(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                       data_ptr_t g_state) {
-		D_ASSERT(partition.inputs);
-
-		const auto &stats = partition.stats;
-
-		//	If frames overlap significantly, then use local skip lists.
-		if (stats[0].end <= stats[1].begin) {
-			//	Frames can overlap
-			const auto overlap = double(stats[1].begin - stats[0].end);
-			const auto cover = double(stats[1].end - stats[0].begin);
-			const auto ratio = overlap / cover;
-			if (ratio > .75) {
-				return;
-			}
-		}
-
-		//	Build the tree
-		auto &state = *reinterpret_cast<STATE *>(g_state);
-		auto &window_state = state.GetOrCreateWindowState();
-		window_state.qst = make_uniq<QuantileSortTree>(aggr_input_data, partition);
-	}
-
-	template <class INPUT_TYPE>
-	static idx_t FrameSize(QuantileIncluded<INPUT_TYPE> &included, const SubFrames &frames) {
-		//	Count the number of valid values
-		idx_t n = 0;
-		if (included.AllValid()) {
-			for (const auto &frame : frames) {
-				n += frame.end - frame.start;
-			}
-		} else {
-			//	NULLs or FILTERed values,
-			for (const auto &frame : frames) {
-				for (auto i = frame.start; i < frame.end; ++i) {
-					n += included(i);
-				}
-			}
-		}
-
-		return n;
-	}
-};
-
-template <class T>
-struct SkipLess {
-	inline bool operator()(const T &lhi, const T &rhi) const {
-		return lhi.second < rhi.second;
-	}
-};
-
-template <typename INPUT_TYPE>
-struct WindowQuantileState {
-	// Windowed Quantile merge sort trees
-	unique_ptr<QuantileSortTree> qst;
-
-	// Windowed Quantile skip lists
-	using SkipType = pair<idx_t, INPUT_TYPE>;
-	using SkipListType = duckdb_skiplistlib::skip_list::HeadNode<SkipType, SkipLess<SkipType>>;
-	SubFrames prevs;
-	unique_ptr<SkipListType> s;
-	mutable vector<SkipType> skips;
-
-	// Windowed MAD indirection
-	idx_t count;
-	vector<idx_t> m;
-
-	using IncludedType = QuantileIncluded<INPUT_TYPE>;
-	using CursorType = QuantileCursor<INPUT_TYPE>;
-
-	WindowQuantileState() : count(0) {
-	}
-
-	inline void SetCount(size_t count_p) {
-		count = count_p;
-		if (count >= m.size()) {
-			m.resize(count);
-		}
-	}
-
-	inline SkipListType &GetSkipList(bool reset = false) {
-		if (reset || !s) {
-			s.reset();
-			s = make_uniq<SkipListType>();
-		}
-		return *s;
-	}
-
-	struct SkipListUpdater {
-		SkipListType &skip;
-		CursorType &data;
-		IncludedType &included;
-
-		inline SkipListUpdater(SkipListType &skip, CursorType &data, IncludedType &included)
-		    : skip(skip), data(data), included(included) {
-		}
-
-		inline void Neither(idx_t begin, idx_t end) {
-		}
-
-		inline void Left(idx_t begin, idx_t end) {
-			for (; begin < end; ++begin) {
-				if (included(begin)) {
-					skip.remove(SkipType(begin, data[begin]));
-				}
-			}
-		}
-
-		inline void Right(idx_t begin, idx_t end) {
-			for (; begin < end; ++begin) {
-				if (included(begin)) {
-					skip.insert(SkipType(begin, data[begin]));
-				}
-			}
-		}
-
-		inline void Both(idx_t begin, idx_t end) {
-		}
-	};
-
-	void UpdateSkip(CursorType &data, const SubFrames &frames, IncludedType &included) {
-		//	No overlap, or no data
-		if (!s || prevs.back().end <= frames.front().start || frames.back().end <= prevs.front().start) {
-			auto &skip = GetSkipList(true);
-			for (const auto &frame : frames) {
-				for (auto i = frame.start; i < frame.end; ++i) {
-					if (included(i)) {
-						skip.insert(SkipType(i, data[i]));
-					}
-				}
-			}
-		} else {
-			auto &skip = GetSkipList();
-			SkipListUpdater updater(skip, data, included);
-			AggregateExecutor::IntersectFrames(prevs, frames, updater);
-		}
-	}
-
-	bool HasTree() const {
-		return qst.get();
-	}
-
-	template <typename RESULT_TYPE, bool DISCRETE>
-	RESULT_TYPE WindowScalar(CursorType &data, const SubFrames &frames, const idx_t n, Vector &result,
-	                         const QuantileValue &q) const {
-		D_ASSERT(n > 0);
-		if (qst) {
-			return qst->WindowScalar<INPUT_TYPE, RESULT_TYPE, DISCRETE>(data, frames, n, result, q);
-		} else if (s) {
-			// Find the position(s) needed
-			try {
-				Interpolator<DISCRETE> interp(q, s->size(), false);
-				s->at(interp.FRN, interp.CRN - interp.FRN + 1, skips);
-				array<INPUT_TYPE, 2> dest;
-				dest[0] = skips[0].second;
-				if (skips.size() > 1) {
-					dest[1] = skips[1].second;
-				}
-				return interp.template Extract<INPUT_TYPE, RESULT_TYPE>(dest.data(), result);
-			} catch (const duckdb_skiplistlib::skip_list::IndexError &idx_err) {
-				throw InternalException(idx_err.message());
-			}
-		} else {
-			throw InternalException("No accelerator for scalar QUANTILE");
-		}
-	}
-
-	template <typename CHILD_TYPE, bool DISCRETE>
-	void WindowList(CursorType &data, const SubFrames &frames, const idx_t n, Vector &list, const idx_t lidx,
-	                const QuantileBindData &bind_data) const {
-		D_ASSERT(n > 0);
-		// Result is a constant LIST<CHILD_TYPE> with a fixed length
-		auto ldata = FlatVector::GetData<list_entry_t>(list);
-		auto &lentry = ldata[lidx];
-		lentry.offset = ListVector::GetListSize(list);
-		lentry.length = bind_data.quantiles.size();
-
-		ListVector::Reserve(list, lentry.offset + lentry.length);
-		ListVector::SetListSize(list, lentry.offset + lentry.length);
-		auto &result = ListVector::GetEntry(list);
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		for (const auto &q : bind_data.order) {
-			const auto &quantile = bind_data.quantiles[q];
-			rdata[lentry.offset + q] = WindowScalar<CHILD_TYPE, DISCRETE>(data, frames, n, result, quantile);
-		}
-	}
-};
-
-struct QuantileStandardType {
-	template <class T>
-	static T Operation(T input, AggregateInputData &) {
-		return input;
-	}
-};
-
-struct QuantileStringType {
-	template <class T>
-	static T Operation(T input, AggregateInputData &input_data) {
-		if (input.IsInlined()) {
-			return input;
-		}
-		auto string_data = input_data.allocator.Allocate(input.GetSize());
-		memcpy(string_data, input.GetData(), input.GetSize());
-		return string_t(char_ptr_cast(string_data), UnsafeNumericCast<uint32_t>(input.GetSize()));
-	}
-};
-
-template <typename INPUT_TYPE, class TYPE_OP>
-struct QuantileState {
-	using InputType = INPUT_TYPE;
-	using CursorType = QuantileCursor<INPUT_TYPE>;
-
-	// Regular aggregation
-	vector<INPUT_TYPE> v;
-
-	// Window Quantile State
-	unique_ptr<WindowQuantileState<INPUT_TYPE>> window_state;
-	unique_ptr<CursorType> window_cursor;
-
-	void AddElement(INPUT_TYPE element, AggregateInputData &aggr_input) {
-		v.emplace_back(TYPE_OP::Operation(element, aggr_input));
-	}
-
-	bool HasTree() const {
-		return window_state && window_state->HasTree();
-	}
-	WindowQuantileState<INPUT_TYPE> &GetOrCreateWindowState() {
-		if (!window_state) {
-			window_state = make_uniq<WindowQuantileState<INPUT_TYPE>>();
-		}
-		return *window_state;
-	}
-	WindowQuantileState<INPUT_TYPE> &GetWindowState() {
-		return *window_state;
-	}
-	const WindowQuantileState<INPUT_TYPE> &GetWindowState() const {
-		return *window_state;
-	}
-
-	CursorType &GetOrCreateWindowCursor(const WindowPartitionInput &partition) {
-		if (!window_cursor) {
-			window_cursor = make_uniq<CursorType>(partition);
-		}
-		return *window_cursor;
-	}
-	CursorType &GetWindowCursor() {
-		return *window_cursor;
-	}
-	const CursorType &GetWindowCursor() const {
-		return *window_cursor;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression/regr_count.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression/regr_count.hpp
deleted file mode 100644
index 40366ef6a..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression/regr_count.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/regression/regr_count.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// REGR_COUNT(y, x)
-
-#pragma once
-
-#include "duckdb/function/aggregate_function.hpp"
-#include "core_functions/aggregate/algebraic/covar.hpp"
-#include "core_functions/aggregate/algebraic/stddev.hpp"
-
-namespace duckdb {
-
-struct RegrCountFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target += source;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		target = static_cast<T>(state);
-	}
-	static bool IgnoreNull() {
-		return true;
-	}
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &, const B_TYPE &, AggregateBinaryInput &) {
-		state += 1;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression/regr_slope.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression/regr_slope.hpp
deleted file mode 100644
index d89af040e..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression/regr_slope.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-// REGR_SLOPE(y, x)
-// Returns the slope of the linear regression line for non-null pairs in a group.
-// It is computed for non-null pairs using the following formula:
-// COVAR_POP(x,y) / VAR_POP(x)
-
-//! Input : Any numeric type
-//! Output : Double
-
-#pragma once
-#include "core_functions/aggregate/algebraic/stddev.hpp"
-#include "core_functions/aggregate/algebraic/covar.hpp"
-
-namespace duckdb {
-
-struct RegrSlopeState {
-	CovarState cov_pop;
-	StddevState var_pop;
-};
-
-struct RegrSlopeOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		CovarOperation::Initialize<CovarState>(state.cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (state.cov_pop.count == 0 || state.var_pop.count == 0) {
-			finalize_data.ReturnNull();
-		} else {
-			auto cov = state.cov_pop.co_moment / state.cov_pop.count;
-			auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
-			if (!Value::DoubleIsFinite(var_pop)) {
-				throw OutOfRangeException("VARPOP is out of range!");
-			}
-			target = var_pop != 0 ? cov / var_pop : NAN;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression_functions.hpp
deleted file mode 100644
index e82b9fdff..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression_functions.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/aggregate/regression_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct RegrAvgxFun {
-	static constexpr const char *Name = "regr_avgx";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the average of the independent variable for non-null pairs in a group, where x is the independent variable and y is the dependent variable.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrAvgyFun {
-	static constexpr const char *Name = "regr_avgy";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the average of the dependent variable for non-null pairs in a group, where x is the independent variable and y is the dependent variable.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrCountFun {
-	static constexpr const char *Name = "regr_count";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the number of non-null number pairs in a group.";
-	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / COUNT(*)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrInterceptFun {
-	static constexpr const char *Name = "regr_intercept";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the intercept of the univariate linear regression line for non-null pairs in a group.";
-	static constexpr const char *Example = "AVG(y)-REGR_SLOPE(y,x)*AVG(x)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrR2Fun {
-	static constexpr const char *Name = "regr_r2";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the coefficient of determination for non-null pairs in a group.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrSlopeFun {
-	static constexpr const char *Name = "regr_slope";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the slope of the linear regression line for non-null pairs in a group.";
-	static constexpr const char *Example = "COVAR_POP(x,y) / VAR_POP(x)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrSXXFun {
-	static constexpr const char *Name = "regr_sxx";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "REGR_COUNT(y, x) * VAR_POP(x)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrSXYFun {
-	static constexpr const char *Name = "regr_sxy";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the population covariance of input values";
-	static constexpr const char *Example = "REGR_COUNT(y, x) * COVAR_POP(y, x)";
-
-	static AggregateFunction GetFunction();
-};
-
-struct RegrSYYFun {
-	static constexpr const char *Name = "regr_syy";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "REGR_COUNT(y, x) * VAR_POP(y)";
-
-	static AggregateFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/aggregate/sum_helpers.hpp b/src/duckdb/extension/core_functions/include/core_functions/aggregate/sum_helpers.hpp
deleted file mode 100644
index 562f61ade..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/aggregate/sum_helpers.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/aggregate/sum_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-static inline void KahanAddInternal(double input, double &summed, double &err) {
-	double diff = input - err;
-	double newval = summed + diff;
-	err = (newval - summed) - diff;
-	summed = newval;
-}
-
-template <class T>
-struct SumState {
-	bool isset;
-	T value;
-
-	void Initialize() {
-		this->isset = false;
-	}
-
-	void Combine(const SumState<T> &other) {
-		this->isset = other.isset || this->isset;
-		this->value += other.value;
-	}
-};
-
-struct KahanSumState {
-	bool isset;
-	double value;
-	double err;
-
-	void Initialize() {
-		this->isset = false;
-		this->err = 0.0;
-	}
-
-	void Combine(const KahanSumState &other) {
-		this->isset = other.isset || this->isset;
-		KahanAddInternal(other.value, this->value, this->err);
-		KahanAddInternal(other.err, this->value, this->err);
-	}
-};
-
-struct RegularAdd {
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		state.value += input;
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		state.value += input * int64_t(count);
-	}
-};
-
-struct HugeintAdd {
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		state.value = Hugeint::Add(state.value, input);
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		AddNumber(state, Hugeint::Multiply(input, UnsafeNumericCast<int64_t>(count)));
-	}
-};
-
-struct KahanAdd {
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		KahanAddInternal(input, state.value, state.err);
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		KahanAddInternal(input * count, state.value, state.err);
-	}
-};
-
-struct AddToHugeint {
-	static void AddValue(hugeint_t &result, uint64_t value, int positive) {
-		// integer summation taken from Tim Gubner et al. - Efficient Query Processing
-		// with Optimistically Compressed Hash Tables & Strings in the USSR
-
-		// add the value to the lower part of the hugeint
-		result.lower += value;
-		// now handle overflows
-		int overflow = result.lower < value;
-		// we consider two situations:
-		// (1) input[idx] is positive, and current value is lower than value: overflow
-		// (2) input[idx] is negative, and current value is higher than value: underflow
-		if (!(overflow ^ positive)) {
-			// in the case of an overflow or underflow we either increment or decrement the upper base
-			// positive: +1, negative: -1
-			result.upper += -1 + 2 * positive;
-		}
-	}
-
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		AddValue(state.value, uint64_t(input), input >= 0);
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		// add a constant X number of times
-		// fast path: check if value * count fits into a uint64_t
-		// note that we check if value * VECTOR_SIZE fits in a uint64_t to avoid having to actually do a division
-		// this is still a pretty high number (18014398509481984) so most positive numbers will fit
-		if (input >= 0 && uint64_t(input) < (NumericLimits<uint64_t>::Maximum() / STANDARD_VECTOR_SIZE)) {
-			// if it does just multiply it and add the value
-			uint64_t value = uint64_t(input) * count;
-			AddValue(state.value, value, 1);
-		} else {
-			// if it doesn't fit we have two choices
-			// either we loop over count and add the values individually
-			// or we convert to a hugeint and multiply the hugeint
-			// the problem is that hugeint multiplication is expensive
-			// hence we switch here: with a low count we do the loop
-			// with a high count we do the hugeint multiplication
-			if (count < 8) {
-				for (idx_t i = 0; i < count; i++) {
-					AddValue(state.value, uint64_t(input), input >= 0);
-				}
-			} else {
-				hugeint_t addition = hugeint_t(input) * Hugeint::Convert(count);
-				state.value += addition;
-			}
-		}
-	}
-};
-
-template <class STATEOP, class ADDOP>
-struct BaseSumOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.value = 0;
-		STATEOP::template Initialize<STATE>(state);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		STATEOP::template Combine<STATE>(source, target, aggr_input_data);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
-		STATEOP::template AddValues<STATE>(state, 1);
-		ADDOP::template AddNumber<STATE, INPUT_TYPE>(state, input);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &, idx_t count) {
-		STATEOP::template AddValues<STATE>(state, count);
-		ADDOP::template AddConstant<STATE, INPUT_TYPE>(state, input, count);
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/array_kernels.hpp b/src/duckdb/extension/core_functions/include/core_functions/array_kernels.hpp
deleted file mode 100644
index dd6e29153..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/array_kernels.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#pragma once
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-//-------------------------------------------------------------------------
-// Folding Operations
-//-------------------------------------------------------------------------
-struct InnerProductOp {
-	static constexpr bool ALLOW_EMPTY = true;
-
-	template <class TYPE>
-	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
-
-		TYPE result = 0;
-
-		auto lhs_ptr = lhs_data;
-		auto rhs_ptr = rhs_data;
-
-		for (idx_t i = 0; i < count; i++) {
-			const auto x = *lhs_ptr++;
-			const auto y = *rhs_ptr++;
-			result += x * y;
-		}
-
-		return result;
-	}
-};
-
-struct NegativeInnerProductOp {
-	static constexpr bool ALLOW_EMPTY = true;
-
-	template <class TYPE>
-	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
-		return -InnerProductOp::Operation(lhs_data, rhs_data, count);
-	}
-};
-
-struct CosineSimilarityOp {
-	static constexpr bool ALLOW_EMPTY = false;
-
-	template <class TYPE>
-	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
-
-		TYPE distance = 0;
-		TYPE norm_l = 0;
-		TYPE norm_r = 0;
-
-		auto l_ptr = lhs_data;
-		auto r_ptr = rhs_data;
-
-		for (idx_t i = 0; i < count; i++) {
-			const auto x = *l_ptr++;
-			const auto y = *r_ptr++;
-			distance += x * y;
-			norm_l += x * x;
-			norm_r += y * y;
-		}
-
-		auto similarity = distance / std::sqrt(norm_l * norm_r);
-		return std::max(static_cast<TYPE>(-1.0), std::min(similarity, static_cast<TYPE>(1.0)));
-	}
-};
-
-struct CosineDistanceOp {
-	static constexpr bool ALLOW_EMPTY = false;
-
-	template <class TYPE>
-	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
-		return static_cast<TYPE>(1.0) - CosineSimilarityOp::Operation(lhs_data, rhs_data, count);
-	}
-};
-
-struct DistanceSquaredOp {
-	static constexpr bool ALLOW_EMPTY = true;
-
-	template <class TYPE>
-	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
-
-		TYPE distance = 0;
-
-		auto l_ptr = lhs_data;
-		auto r_ptr = rhs_data;
-
-		for (idx_t i = 0; i < count; i++) {
-			const auto x = *l_ptr++;
-			const auto y = *r_ptr++;
-			const auto diff = x - y;
-			distance += diff * diff;
-		}
-
-		return distance;
-	}
-};
-
-struct DistanceOp {
-	static constexpr bool ALLOW_EMPTY = true;
-
-	template <class TYPE>
-	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
-		return std::sqrt(DistanceSquaredOp::Operation(lhs_data, rhs_data, count));
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/function_list.hpp b/src/duckdb/extension/core_functions/include/core_functions/function_list.hpp
deleted file mode 100644
index 024ca49f8..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/function_list.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/function_list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-
-namespace duckdb {
-
-typedef ScalarFunction (*get_scalar_function_t)();
-typedef ScalarFunctionSet (*get_scalar_function_set_t)();
-typedef AggregateFunction (*get_aggregate_function_t)();
-typedef AggregateFunctionSet (*get_aggregate_function_set_t)();
-
-struct StaticFunctionDefinition {
-	const char *name;
-	const char *parameters;
-	const char *description;
-	const char *example;
-	get_scalar_function_t get_function;
-	get_scalar_function_set_t get_function_set;
-	get_aggregate_function_t get_aggregate_function;
-	get_aggregate_function_set_t get_aggregate_function_set;
-
-	static const StaticFunctionDefinition *GetFunctionList();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/array_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/array_functions.hpp
deleted file mode 100644
index 561643be4..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/array_functions.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/array_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ArrayValueFun {
-	static constexpr const char *Name = "array_value";
-	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Create an ARRAY containing the argument values.";
-	static constexpr const char *Example = "array_value(4, 5, 6)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayCrossProductFun {
-	static constexpr const char *Name = "array_cross_product";
-	static constexpr const char *Parameters = "array, array";
-	static constexpr const char *Description = "Compute the cross product of two arrays of size 3. The array elements can not be NULL.";
-	static constexpr const char *Example = "array_cross_product([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayCosineSimilarityFun {
-	static constexpr const char *Name = "array_cosine_similarity";
-	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the cosine similarity between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_cosine_similarity([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayCosineDistanceFun {
-	static constexpr const char *Name = "array_cosine_distance";
-	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the cosine distance between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_cosine_distance([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayDistanceFun {
-	static constexpr const char *Name = "array_distance";
-	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the distance between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_distance([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayInnerProductFun {
-	static constexpr const char *Name = "array_inner_product";
-	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the inner product between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_inner_product([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayDotProductFun {
-	using ALIAS = ArrayInnerProductFun;
-
-	static constexpr const char *Name = "array_dot_product";
-};
-
-struct ArrayNegativeInnerProductFun {
-	static constexpr const char *Name = "array_negative_inner_product";
-	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the negative inner product between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_negative_inner_product([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayNegativeDotProductFun {
-	using ALIAS = ArrayNegativeInnerProductFun;
-
-	static constexpr const char *Name = "array_negative_dot_product";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/bit_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/bit_functions.hpp
deleted file mode 100644
index e01a2fc58..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/bit_functions.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/bit_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct GetBitFun {
-	static constexpr const char *Name = "get_bit";
-	static constexpr const char *Parameters = "bitstring,index";
-	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0";
-	static constexpr const char *Example = "get_bit('0110010'::BIT, 2)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct SetBitFun {
-	static constexpr const char *Name = "set_bit";
-	static constexpr const char *Parameters = "bitstring,index,new_value";
-	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring";
-	static constexpr const char *Example = "set_bit('0110010'::BIT, 2, 0)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct BitPositionFun {
-	static constexpr const char *Name = "bit_position";
-	static constexpr const char *Parameters = "substring,bitstring";
-	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it is not present. The first (leftmost) bit is indexed 1";
-	static constexpr const char *Example = "bit_position('010'::BIT, '1110101'::BIT)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct BitStringFun {
-	static constexpr const char *Name = "bitstring";
-	static constexpr const char *Parameters = "bitstring,length";
-	static constexpr const char *Description = "Pads the bitstring until the specified length";
-	static constexpr const char *Example = "bitstring('1010'::BIT, 7)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/blob_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/blob_functions.hpp
deleted file mode 100644
index 051e212c1..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/blob_functions.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/blob_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct DecodeFun {
-	static constexpr const char *Name = "decode";
-	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8";
-	static constexpr const char *Example = "decode('\\xC3\\xBC'::BLOB)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EncodeFun {
-	static constexpr const char *Name = "encode";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding";
-	static constexpr const char *Example = "encode('my_string_with_ü')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FromBase64Fun {
-	static constexpr const char *Name = "from_base64";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert a base64 encoded string to a character string";
-	static constexpr const char *Example = "from_base64('QQ==')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToBase64Fun {
-	static constexpr const char *Name = "to_base64";
-	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert a blob to a base64 encoded string";
-	static constexpr const char *Example = "base64('A'::blob)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct Base64Fun {
-	using ALIAS = ToBase64Fun;
-
-	static constexpr const char *Name = "base64";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/date_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/date_functions.hpp
deleted file mode 100644
index 7256502a9..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/date_functions.hpp
+++ /dev/null
@@ -1,603 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/date_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct AgeFun {
-	static constexpr const char *Name = "age";
-	static constexpr const char *Parameters = "timestamp,timestamp";
-	static constexpr const char *Description = "Subtract arguments, resulting in the time difference between the two timestamps";
-	static constexpr const char *Example = "age(TIMESTAMP '2001-04-10', TIMESTAMP '1992-09-20')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct CenturyFun {
-	static constexpr const char *Name = "century";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the century component from a date or timestamp";
-	static constexpr const char *Example = "century(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DateDiffFun {
-	static constexpr const char *Name = "date_diff";
-	static constexpr const char *Parameters = "part,startdate,enddate";
-	static constexpr const char *Description = "The number of partition boundaries between the timestamps";
-	static constexpr const char *Example = "date_diff('hour', TIMESTAMPTZ '1992-09-30 23:59:59', TIMESTAMPTZ '1992-10-01 01:58:00')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DatediffFun {
-	using ALIAS = DateDiffFun;
-
-	static constexpr const char *Name = "datediff";
-};
-
-struct DatePartFun {
-	static constexpr const char *Name = "date_part";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Get subfield (equivalent to extract)";
-	static constexpr const char *Example = "date_part('minute', TIMESTAMP '1992-09-20 20:38:40')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DatepartFun {
-	using ALIAS = DatePartFun;
-
-	static constexpr const char *Name = "datepart";
-};
-
-struct DateSubFun {
-	static constexpr const char *Name = "date_sub";
-	static constexpr const char *Parameters = "part,startdate,enddate";
-	static constexpr const char *Description = "The number of complete partitions between the timestamps";
-	static constexpr const char *Example = "date_sub('hour', TIMESTAMPTZ '1992-09-30 23:59:59', TIMESTAMPTZ '1992-10-01 01:58:00')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DatesubFun {
-	using ALIAS = DateSubFun;
-
-	static constexpr const char *Name = "datesub";
-};
-
-struct DateTruncFun {
-	static constexpr const char *Name = "date_trunc";
-	static constexpr const char *Parameters = "part,timestamp";
-	static constexpr const char *Description = "Truncate to specified precision";
-	static constexpr const char *Example = "date_trunc('hour', TIMESTAMPTZ '1992-09-20 20:38:40')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DatetruncFun {
-	using ALIAS = DateTruncFun;
-
-	static constexpr const char *Name = "datetrunc";
-};
-
-struct DayFun {
-	static constexpr const char *Name = "day";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the day component from a date or timestamp";
-	static constexpr const char *Example = "day(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DayNameFun {
-	static constexpr const char *Name = "dayname";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "The (English) name of the weekday";
-	static constexpr const char *Example = "dayname(TIMESTAMP '1992-03-22')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DayOfMonthFun {
-	static constexpr const char *Name = "dayofmonth";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the dayofmonth component from a date or timestamp";
-	static constexpr const char *Example = "dayofmonth(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DayOfWeekFun {
-	static constexpr const char *Name = "dayofweek";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the dayofweek component from a date or timestamp";
-	static constexpr const char *Example = "dayofweek(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DayOfYearFun {
-	static constexpr const char *Name = "dayofyear";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the dayofyear component from a date or timestamp";
-	static constexpr const char *Example = "dayofyear(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DecadeFun {
-	static constexpr const char *Name = "decade";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the decade component from a date or timestamp";
-	static constexpr const char *Example = "decade(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct EpochFun {
-	static constexpr const char *Name = "epoch";
-	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Extract the epoch component from a temporal type";
-	static constexpr const char *Example = "epoch(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct EpochMsFun {
-	static constexpr const char *Name = "epoch_ms";
-	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Extract the epoch component in milliseconds from a temporal type";
-	static constexpr const char *Example = "epoch_ms(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct EpochUsFun {
-	static constexpr const char *Name = "epoch_us";
-	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Extract the epoch component in microseconds from a temporal type";
-	static constexpr const char *Example = "epoch_us(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct EpochNsFun {
-	static constexpr const char *Name = "epoch_ns";
-	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Extract the epoch component in nanoseconds from a temporal type";
-	static constexpr const char *Example = "epoch_ns(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct EraFun {
-	static constexpr const char *Name = "era";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the era component from a date or timestamp";
-	static constexpr const char *Example = "era(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct GetCurrentTimestampFun {
-	static constexpr const char *Name = "get_current_timestamp";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the current timestamp";
-	static constexpr const char *Example = "get_current_timestamp()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NowFun {
-	using ALIAS = GetCurrentTimestampFun;
-
-	static constexpr const char *Name = "now";
-};
-
-struct TransactionTimestampFun {
-	using ALIAS = GetCurrentTimestampFun;
-
-	static constexpr const char *Name = "transaction_timestamp";
-};
-
-struct HoursFun {
-	static constexpr const char *Name = "hour";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the hour component from a date or timestamp";
-	static constexpr const char *Example = "hour(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ISODayOfWeekFun {
-	static constexpr const char *Name = "isodow";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the isodow component from a date or timestamp";
-	static constexpr const char *Example = "isodow(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ISOYearFun {
-	static constexpr const char *Name = "isoyear";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the isoyear component from a date or timestamp";
-	static constexpr const char *Example = "isoyear(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct JulianDayFun {
-	static constexpr const char *Name = "julian";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the Julian Day number from a date or timestamp";
-	static constexpr const char *Example = "julian(timestamp '2006-01-01 12:00')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct LastDayFun {
-	static constexpr const char *Name = "last_day";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Returns the last day of the month";
-	static constexpr const char *Example = "last_day(TIMESTAMP '1992-03-22 01:02:03.1234')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MakeDateFun {
-	static constexpr const char *Name = "make_date";
-	static constexpr const char *Parameters = "year,month,day\1date-struct::STRUCT(year BIGINT, month BIGINT, day BIGINT)";
-	static constexpr const char *Description = "The date for the given parts\1The date for the given struct.";
-	static constexpr const char *Example = "make_date(1992, 9, 20)\1make_date({'year': 2024, 'month': 11, 'day': 14})";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MakeTimeFun {
-	static constexpr const char *Name = "make_time";
-	static constexpr const char *Parameters = "hour,minute,seconds";
-	static constexpr const char *Description = "The time for the given parts";
-	static constexpr const char *Example = "make_time(13, 34, 27.123456)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MakeTimestampFun {
-	static constexpr const char *Name = "make_timestamp";
-	static constexpr const char *Parameters = "year,month,day,hour,minute,seconds";
-	static constexpr const char *Description = "The timestamp for the given parts";
-	static constexpr const char *Example = "make_timestamp(1992, 9, 20, 13, 34, 27.123456)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MakeTimestampNsFun {
-	static constexpr const char *Name = "make_timestamp_ns";
-	static constexpr const char *Parameters = "nanos";
-	static constexpr const char *Description = "The timestamp for the given nanoseconds since epoch";
-	static constexpr const char *Example = "make_timestamp(1732117793000000000)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MicrosecondsFun {
-	static constexpr const char *Name = "microsecond";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the microsecond component from a date or timestamp";
-	static constexpr const char *Example = "microsecond(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MillenniumFun {
-	static constexpr const char *Name = "millennium";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the millennium component from a date or timestamp";
-	static constexpr const char *Example = "millennium(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MillisecondsFun {
-	static constexpr const char *Name = "millisecond";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the millisecond component from a date or timestamp";
-	static constexpr const char *Example = "millisecond(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MinutesFun {
-	static constexpr const char *Name = "minute";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the minute component from a date or timestamp";
-	static constexpr const char *Example = "minute(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MonthFun {
-	static constexpr const char *Name = "month";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the month component from a date or timestamp";
-	static constexpr const char *Example = "month(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MonthNameFun {
-	static constexpr const char *Name = "monthname";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "The (English) name of the month";
-	static constexpr const char *Example = "monthname(TIMESTAMP '1992-09-20')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct NanosecondsFun {
-	static constexpr const char *Name = "nanosecond";
-	static constexpr const char *Parameters = "tsns";
-	static constexpr const char *Description = "Extract the nanosecond component from a date or timestamp";
-	static constexpr const char *Example = "nanosecond(timestamp_ns '2021-08-03 11:59:44.123456789') => 44123456789";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct NormalizedIntervalFun {
-	static constexpr const char *Name = "normalized_interval";
-	static constexpr const char *Parameters = "interval";
-	static constexpr const char *Description = "Normalizes an INTERVAL to an equivalent interval";
-	static constexpr const char *Example = "normalized_interval(INTERVAL '30 days')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct QuarterFun {
-	static constexpr const char *Name = "quarter";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the quarter component from a date or timestamp";
-	static constexpr const char *Example = "quarter(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SecondsFun {
-	static constexpr const char *Name = "second";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the second component from a date or timestamp";
-	static constexpr const char *Example = "second(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TimeBucketFun {
-	static constexpr const char *Name = "time_bucket";
-	static constexpr const char *Parameters = "bucket_width,timestamp,origin";
-	static constexpr const char *Description = "Truncate TIMESTAMPTZ by the specified interval bucket_width. Buckets are aligned relative to origin TIMESTAMPTZ. The origin defaults to 2000-01-03 00:00:00+00 for buckets that do not include a month or year interval, and to 2000-01-01 00:00:00+00 for month and year buckets";
-	static constexpr const char *Example = "time_bucket(INTERVAL '2 weeks', TIMESTAMP '1992-04-20 15:26:00-07', TIMESTAMP '1992-04-01 00:00:00-07')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TimezoneFun {
-	static constexpr const char *Name = "timezone";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the timezone component from a date or timestamp";
-	static constexpr const char *Example = "timezone(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TimezoneHourFun {
-	static constexpr const char *Name = "timezone_hour";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the timezone_hour component from a date or timestamp";
-	static constexpr const char *Example = "timezone_hour(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TimezoneMinuteFun {
-	static constexpr const char *Name = "timezone_minute";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the timezone_minute component from a date or timestamp";
-	static constexpr const char *Example = "timezone_minute(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TimeTZSortKeyFun {
-	static constexpr const char *Name = "timetz_byte_comparable";
-	static constexpr const char *Parameters = "time_tz";
-	static constexpr const char *Description = "Converts a TIME WITH TIME ZONE to an integer sort key";
-	static constexpr const char *Example = "timetz_byte_comparable('18:18:16.21-07:00'::TIME_TZ)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToCenturiesFun {
-	static constexpr const char *Name = "to_centuries";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a century interval";
-	static constexpr const char *Example = "to_centuries(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToDaysFun {
-	static constexpr const char *Name = "to_days";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a day interval";
-	static constexpr const char *Example = "to_days(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToDecadesFun {
-	static constexpr const char *Name = "to_decades";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a decade interval";
-	static constexpr const char *Example = "to_decades(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToHoursFun {
-	static constexpr const char *Name = "to_hours";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a hour interval";
-	static constexpr const char *Example = "to_hours(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToMicrosecondsFun {
-	static constexpr const char *Name = "to_microseconds";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a microsecond interval";
-	static constexpr const char *Example = "to_microseconds(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToMillenniaFun {
-	static constexpr const char *Name = "to_millennia";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a millenium interval";
-	static constexpr const char *Example = "to_millennia(1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToMillisecondsFun {
-	static constexpr const char *Name = "to_milliseconds";
-	static constexpr const char *Parameters = "double";
-	static constexpr const char *Description = "Construct a millisecond interval";
-	static constexpr const char *Example = "to_milliseconds(5.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToMinutesFun {
-	static constexpr const char *Name = "to_minutes";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a minute interval";
-	static constexpr const char *Example = "to_minutes(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToMonthsFun {
-	static constexpr const char *Name = "to_months";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a month interval";
-	static constexpr const char *Example = "to_months(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToQuartersFun {
-	static constexpr const char *Name = "to_quarters";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a quarter interval";
-	static constexpr const char *Example = "to_quarters(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToSecondsFun {
-	static constexpr const char *Name = "to_seconds";
-	static constexpr const char *Parameters = "double";
-	static constexpr const char *Description = "Construct a second interval";
-	static constexpr const char *Example = "to_seconds(5.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToTimestampFun {
-	static constexpr const char *Name = "to_timestamp";
-	static constexpr const char *Parameters = "sec";
-	static constexpr const char *Description = "Converts secs since epoch to a timestamp with time zone";
-	static constexpr const char *Example = "to_timestamp(1284352323.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToWeeksFun {
-	static constexpr const char *Name = "to_weeks";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a week interval";
-	static constexpr const char *Example = "to_weeks(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ToYearsFun {
-	static constexpr const char *Name = "to_years";
-	static constexpr const char *Parameters = "integer";
-	static constexpr const char *Description = "Construct a year interval";
-	static constexpr const char *Example = "to_years(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct WeekFun {
-	static constexpr const char *Name = "week";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the week component from a date or timestamp";
-	static constexpr const char *Example = "week(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct WeekDayFun {
-	static constexpr const char *Name = "weekday";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the weekday component from a date or timestamp";
-	static constexpr const char *Example = "weekday(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct WeekOfYearFun {
-	static constexpr const char *Name = "weekofyear";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the weekofyear component from a date or timestamp";
-	static constexpr const char *Example = "weekofyear(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct YearFun {
-	static constexpr const char *Name = "year";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the year component from a date or timestamp";
-	static constexpr const char *Example = "year(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct YearWeekFun {
-	static constexpr const char *Name = "yearweek";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the yearweek component from a date or timestamp";
-	static constexpr const char *Example = "yearweek(timestamp '2021-08-03 11:59:44.123456')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/debug_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/debug_functions.hpp
deleted file mode 100644
index ce4debc6d..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/debug_functions.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/debug_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct VectorTypeFun {
-	static constexpr const char *Name = "vector_type";
-	static constexpr const char *Parameters = "col";
-	static constexpr const char *Description = "Returns the VectorType of a given column";
-	static constexpr const char *Example = "vector_type(col)";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/enum_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/enum_functions.hpp
deleted file mode 100644
index 73791f8a5..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/enum_functions.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/enum_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct EnumFirstFun {
-	static constexpr const char *Name = "enum_first";
-	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns the first value of the input enum type";
-	static constexpr const char *Example = "enum_first(NULL::mood)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EnumLastFun {
-	static constexpr const char *Name = "enum_last";
-	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns the last value of the input enum type";
-	static constexpr const char *Example = "enum_last(NULL::mood)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EnumCodeFun {
-	static constexpr const char *Name = "enum_code";
-	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns the numeric value backing the given enum value";
-	static constexpr const char *Example = "enum_code('happy'::mood)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EnumRangeFun {
-	static constexpr const char *Name = "enum_range";
-	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns all values of the input enum type as an array";
-	static constexpr const char *Example = "enum_range(NULL::mood)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EnumRangeBoundaryFun {
-	static constexpr const char *Name = "enum_range_boundary";
-	static constexpr const char *Parameters = "start,end";
-	static constexpr const char *Description = "Returns the range between the two given enum values as an array. The values must be of the same enum type. When the first parameter is NULL, the result starts with the first value of the enum type. When the second parameter is NULL, the result ends with the last value of the enum type";
-	static constexpr const char *Example = "enum_range_boundary(NULL, 'happy'::mood)";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp
deleted file mode 100644
index d874e72a9..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/generic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct AliasFun {
-	static constexpr const char *Name = "alias";
-	static constexpr const char *Parameters = "expr";
-	static constexpr const char *Description = "Returns the name of a given expression";
-	static constexpr const char *Example = "alias(42 + 1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CurrentSettingFun {
-	static constexpr const char *Name = "current_setting";
-	static constexpr const char *Parameters = "setting_name";
-	static constexpr const char *Description = "Returns the current value of the configuration setting";
-	static constexpr const char *Example = "current_setting('access_mode')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct HashFun {
-	static constexpr const char *Name = "hash";
-	static constexpr const char *Parameters = "param";
-	static constexpr const char *Description = "Returns an integer with the hash of the value. Note that this is not a cryptographic hash";
-	static constexpr const char *Example = "hash('🦆')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LeastFun {
-	static constexpr const char *Name = "least";
-	static constexpr const char *Parameters = "arg1, arg2, ...";
-	static constexpr const char *Description = "Returns the lowest value of the set of input parameters";
-	static constexpr const char *Example = "least(42, 84)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct GreatestFun {
-	static constexpr const char *Name = "greatest";
-	static constexpr const char *Parameters = "arg1, arg2, ...";
-	static constexpr const char *Description = "Returns the highest value of the set of input parameters";
-	static constexpr const char *Example = "greatest(42, 84)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StatsFun {
-	static constexpr const char *Name = "stats";
-	static constexpr const char *Parameters = "expression";
-	static constexpr const char *Description = "Returns a string with statistics about the expression. Expression can be a column, constant, or SQL expression";
-	static constexpr const char *Example = "stats(5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct TypeOfFun {
-	static constexpr const char *Name = "typeof";
-	static constexpr const char *Parameters = "expression";
-	static constexpr const char *Description = "Returns the name of the data type of the result of the expression";
-	static constexpr const char *Example = "typeof('abc')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CanCastImplicitlyFun {
-	static constexpr const char *Name = "can_cast_implicitly";
-	static constexpr const char *Parameters = "source_type,target_type";
-	static constexpr const char *Description = "Whether or not we can implicitly cast from the source type to the other type";
-	static constexpr const char *Example = "can_implicitly_cast(NULL::INTEGER, NULL::BIGINT)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CurrentQueryFun {
-	static constexpr const char *Name = "current_query";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the current query as a string";
-	static constexpr const char *Example = "current_query()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CurrentSchemaFun {
-	static constexpr const char *Name = "current_schema";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the name of the currently active schema. Default is main";
-	static constexpr const char *Example = "current_schema()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CurrentSchemasFun {
-	static constexpr const char *Name = "current_schemas";
-	static constexpr const char *Parameters = "include_implicit";
-	static constexpr const char *Description = "Returns list of schemas. Pass a parameter of True to include implicit schemas";
-	static constexpr const char *Example = "current_schemas(true)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CurrentDatabaseFun {
-	static constexpr const char *Name = "current_database";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the name of the currently active database";
-	static constexpr const char *Example = "current_database()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct InSearchPathFun {
-	static constexpr const char *Name = "in_search_path";
-	static constexpr const char *Parameters = "database_name,schema_name";
-	static constexpr const char *Description = "Returns whether or not the database/schema are in the search path";
-	static constexpr const char *Example = "in_search_path('memory', 'main')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CurrentTransactionIdFun {
-	static constexpr const char *Name = "txid_current";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the current transaction’s ID (a BIGINT). It will assign a new one if the current transaction does not have one already";
-	static constexpr const char *Example = "txid_current()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct VersionFun {
-	static constexpr const char *Name = "version";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the currently active version of DuckDB in this format: v0.3.2	";
-	static constexpr const char *Example = "version()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EquiWidthBinsFun {
-	static constexpr const char *Name = "equi_width_bins";
-	static constexpr const char *Parameters = "min,max,bin_count,nice_rounding";
-	static constexpr const char *Description = "Generates bin_count equi-width bins between the min and max. If enabled nice_rounding makes the numbers more readable/less jagged";
-	static constexpr const char *Example = "equi_width_bins(0, 10, 2, true)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct IsHistogramOtherBinFun {
-	static constexpr const char *Name = "is_histogram_other_bin";
-	static constexpr const char *Parameters = "val";
-	static constexpr const char *Description = "Whether or not the provided value is the histogram \"other\" bin (used for values not belonging to any provided bin)";
-	static constexpr const char *Example = "is_histogram_other_bin(v)";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/list_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/list_functions.hpp
deleted file mode 100644
index 2b9318b40..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/list_functions.hpp
+++ /dev/null
@@ -1,390 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/list_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ListFlattenFun {
-	static constexpr const char *Name = "flatten";
-	static constexpr const char *Parameters = "nested_list";
-	static constexpr const char *Description = "Flatten a nested list by one level";
-	static constexpr const char *Example = "flatten([[1, 2, 3], [4, 5]])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ListAggregateFun {
-	static constexpr const char *Name = "list_aggregate";
-	static constexpr const char *Parameters = "list,name";
-	static constexpr const char *Description = "Executes the aggregate function name on the elements of list";
-	static constexpr const char *Example = "list_aggregate([1, 2, NULL], 'min')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayAggregateFun {
-	using ALIAS = ListAggregateFun;
-
-	static constexpr const char *Name = "array_aggregate";
-};
-
-struct ListAggrFun {
-	using ALIAS = ListAggregateFun;
-
-	static constexpr const char *Name = "list_aggr";
-};
-
-struct ArrayAggrFun {
-	using ALIAS = ListAggregateFun;
-
-	static constexpr const char *Name = "array_aggr";
-};
-
-struct AggregateFun {
-	using ALIAS = ListAggregateFun;
-
-	static constexpr const char *Name = "aggregate";
-};
-
-struct ListDistinctFun {
-	static constexpr const char *Name = "list_distinct";
-	static constexpr const char *Parameters = "list";
-	static constexpr const char *Description = "Removes all duplicates and NULLs from a list. Does not preserve the original order";
-	static constexpr const char *Example = "list_distinct([1, 1, NULL, -3, 1, 5])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayDistinctFun {
-	using ALIAS = ListDistinctFun;
-
-	static constexpr const char *Name = "array_distinct";
-};
-
-struct ListUniqueFun {
-	static constexpr const char *Name = "list_unique";
-	static constexpr const char *Parameters = "list";
-	static constexpr const char *Description = "Counts the unique elements of a list";
-	static constexpr const char *Example = "list_unique([1, 1, NULL, -3, 1, 5])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayUniqueFun {
-	using ALIAS = ListUniqueFun;
-
-	static constexpr const char *Name = "array_unique";
-};
-
-struct ListValueFun {
-	static constexpr const char *Name = "list_value";
-	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Create a LIST containing the argument values";
-	static constexpr const char *Example = "list_value(4, 5, 6)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ListPackFun {
-	using ALIAS = ListValueFun;
-
-	static constexpr const char *Name = "list_pack";
-};
-
-struct ListSliceFun {
-	static constexpr const char *Name = "list_slice";
-	static constexpr const char *Parameters = "list,begin,end\1list,begin,end,step";
-	static constexpr const char *Description = "Extract a sublist using slice conventions. Negative values are accepted.\1list_slice with added step feature.";
-	static constexpr const char *Example = "list_slice([4, 5, 6], 2, 3)\2array_slice('DuckDB', 3, 4)\2array_slice('DuckDB', 3, NULL)\2array_slice('DuckDB', 0, -3)\1list_slice([4, 5, 6], 1, 3, 2)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArraySliceFun {
-	using ALIAS = ListSliceFun;
-
-	static constexpr const char *Name = "array_slice";
-};
-
-struct ListSortFun {
-	static constexpr const char *Name = "list_sort";
-	static constexpr const char *Parameters = "list";
-	static constexpr const char *Description = "Sorts the elements of the list";
-	static constexpr const char *Example = "list_sort([3, 6, 1, 2])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArraySortFun {
-	using ALIAS = ListSortFun;
-
-	static constexpr const char *Name = "array_sort";
-};
-
-struct ListGradeUpFun {
-	static constexpr const char *Name = "list_grade_up";
-	static constexpr const char *Parameters = "list";
-	static constexpr const char *Description = "Returns the index of their sorted position.";
-	static constexpr const char *Example = "list_grade_up([3, 6, 1, 2])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayGradeUpFun {
-	using ALIAS = ListGradeUpFun;
-
-	static constexpr const char *Name = "array_grade_up";
-};
-
-struct GradeUpFun {
-	using ALIAS = ListGradeUpFun;
-
-	static constexpr const char *Name = "grade_up";
-};
-
-struct ListReverseSortFun {
-	static constexpr const char *Name = "list_reverse_sort";
-	static constexpr const char *Parameters = "list";
-	static constexpr const char *Description = "Sorts the elements of the list in reverse order";
-	static constexpr const char *Example = "list_reverse_sort([3, 6, 1, 2])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayReverseSortFun {
-	using ALIAS = ListReverseSortFun;
-
-	static constexpr const char *Name = "array_reverse_sort";
-};
-
-struct ListTransformFun {
-	static constexpr const char *Name = "list_transform";
-	static constexpr const char *Parameters = "list,lambda";
-	static constexpr const char *Description = "Returns a list that is the result of applying the lambda function to each element of the input list. See the Lambda Functions section for more details";
-	static constexpr const char *Example = "list_transform([1, 2, 3], x -> x + 1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayTransformFun {
-	using ALIAS = ListTransformFun;
-
-	static constexpr const char *Name = "array_transform";
-};
-
-struct ListApplyFun {
-	using ALIAS = ListTransformFun;
-
-	static constexpr const char *Name = "list_apply";
-};
-
-struct ArrayApplyFun {
-	using ALIAS = ListTransformFun;
-
-	static constexpr const char *Name = "array_apply";
-};
-
-struct ApplyFun {
-	using ALIAS = ListTransformFun;
-
-	static constexpr const char *Name = "apply";
-};
-
-struct ListFilterFun {
-	static constexpr const char *Name = "list_filter";
-	static constexpr const char *Parameters = "list,lambda";
-	static constexpr const char *Description = "Constructs a list from those elements of the input list for which the lambda function returns true";
-	static constexpr const char *Example = "list_filter([3, 4, 5], x -> x > 4)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayFilterFun {
-	using ALIAS = ListFilterFun;
-
-	static constexpr const char *Name = "array_filter";
-};
-
-struct FilterFun {
-	using ALIAS = ListFilterFun;
-
-	static constexpr const char *Name = "filter";
-};
-
-struct ListReduceFun {
-	static constexpr const char *Name = "list_reduce";
-	static constexpr const char *Parameters = "list,lambda";
-	static constexpr const char *Description = "Returns a single value that is the result of applying the lambda function to each element of the input list, starting with the first element and then repeatedly applying the lambda function to the result of the previous application and the next element of the list.";
-	static constexpr const char *Example = "list_reduce([1, 2, 3], (x, y) -> x + y)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayReduceFun {
-	using ALIAS = ListReduceFun;
-
-	static constexpr const char *Name = "array_reduce";
-};
-
-struct ReduceFun {
-	using ALIAS = ListReduceFun;
-
-	static constexpr const char *Name = "reduce";
-};
-
-struct GenerateSeriesFun {
-	static constexpr const char *Name = "generate_series";
-	static constexpr const char *Parameters = "start,stop,step";
-	static constexpr const char *Description = "Create a list of values between start and stop - the stop parameter is inclusive";
-	static constexpr const char *Example = "generate_series(2, 5, 3)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListRangeFun {
-	static constexpr const char *Name = "range";
-	static constexpr const char *Parameters = "start,stop,step";
-	static constexpr const char *Description = "Create a list of values between start and stop - the stop parameter is exclusive";
-	static constexpr const char *Example = "range(2, 5, 3)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListCosineDistanceFun {
-	static constexpr const char *Name = "list_cosine_distance";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Compute the cosine distance between two lists";
-	static constexpr const char *Example = "list_cosine_distance([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListCosineDistanceFunAlias {
-	using ALIAS = ListCosineDistanceFun;
-
-	static constexpr const char *Name = "<=>";
-};
-
-struct ListCosineSimilarityFun {
-	static constexpr const char *Name = "list_cosine_similarity";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Compute the cosine similarity between two lists";
-	static constexpr const char *Example = "list_cosine_similarity([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListDistanceFun {
-	static constexpr const char *Name = "list_distance";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Compute the distance between two lists";
-	static constexpr const char *Example = "list_distance([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListDistanceFunAlias {
-	using ALIAS = ListDistanceFun;
-
-	static constexpr const char *Name = "<->";
-};
-
-struct ListInnerProductFun {
-	static constexpr const char *Name = "list_inner_product";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Compute the inner product between two lists";
-	static constexpr const char *Example = "list_inner_product([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListDotProductFun {
-	using ALIAS = ListInnerProductFun;
-
-	static constexpr const char *Name = "list_dot_product";
-};
-
-struct ListNegativeInnerProductFun {
-	static constexpr const char *Name = "list_negative_inner_product";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Compute the negative inner product between two lists";
-	static constexpr const char *Example = "list_negative_inner_product([1, 2, 3], [1, 2, 3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListNegativeDotProductFun {
-	using ALIAS = ListNegativeInnerProductFun;
-
-	static constexpr const char *Name = "list_negative_dot_product";
-};
-
-struct UnpivotListFun {
-	static constexpr const char *Name = "unpivot_list";
-	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Identical to list_value, but generated as part of unpivot for better error messages";
-	static constexpr const char *Example = "unpivot_list(4, 5, 6)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ListHasAnyFun {
-	static constexpr const char *Name = "list_has_any";
-	static constexpr const char *Parameters = "l1, l2";
-	static constexpr const char *Description = "Returns true if the lists have any element in common. NULLs are ignored.";
-	static constexpr const char *Example = "list_has_any([1, 2, 3], [2, 3, 4])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayHasAnyFun {
-	using ALIAS = ListHasAnyFun;
-
-	static constexpr const char *Name = "array_has_any";
-};
-
-struct ListHasAnyFunAlias {
-	using ALIAS = ListHasAnyFun;
-
-	static constexpr const char *Name = "&&";
-};
-
-struct ListHasAllFun {
-	static constexpr const char *Name = "list_has_all";
-	static constexpr const char *Parameters = "l1, l2";
-	static constexpr const char *Description = "Returns true if all elements of l2 are in l1. NULLs are ignored.";
-	static constexpr const char *Example = "list_has_all([1, 2, 3], [2, 3])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayHasAllFun {
-	using ALIAS = ListHasAllFun;
-
-	static constexpr const char *Name = "array_has_all";
-};
-
-struct ListHasAllFunAlias {
-	using ALIAS = ListHasAllFun;
-
-	static constexpr const char *Name = "@>";
-};
-
-struct ListHasAllFunAlias2 {
-	using ALIAS = ListHasAllFun;
-
-	static constexpr const char *Name = "<@";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/map_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/map_functions.hpp
deleted file mode 100644
index 0998a3156..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/map_functions.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/map_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CardinalityFun {
-	static constexpr const char *Name = "cardinality";
-	static constexpr const char *Parameters = "map";
-	static constexpr const char *Description = "Returns the size of the map (or the number of entries in the map)";
-	static constexpr const char *Example = "cardinality( map([4, 2], ['a', 'b']) );";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MapFun {
-	static constexpr const char *Name = "map";
-	static constexpr const char *Parameters = "keys,values";
-	static constexpr const char *Description = "Creates a map from a set of keys and values";
-	static constexpr const char *Example = "map(['key1', 'key2'], ['val1', 'val2'])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MapEntriesFun {
-	static constexpr const char *Name = "map_entries";
-	static constexpr const char *Parameters = "map";
-	static constexpr const char *Description = "Returns the map entries as a list of keys/values";
-	static constexpr const char *Example = "map_entries(map(['key'], ['val']))";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MapExtractFun {
-	static constexpr const char *Name = "map_extract";
-	static constexpr const char *Parameters = "map,key";
-	static constexpr const char *Description = "Returns a list containing the value for a given key or an empty list if the key is not contained in the map. The type of the key provided in the second parameter must match the type of the map’s keys else an error is returned";
-	static constexpr const char *Example = "map_extract(map(['key'], ['val']), 'key')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ElementAtFun {
-	using ALIAS = MapExtractFun;
-
-	static constexpr const char *Name = "element_at";
-};
-
-struct MapFromEntriesFun {
-	static constexpr const char *Name = "map_from_entries";
-	static constexpr const char *Parameters = "map";
-	static constexpr const char *Description = "Returns a map created from the entries of the array";
-	static constexpr const char *Example = "map_from_entries([{k: 5, v: 'val1'}, {k: 3, v: 'val2'}]);";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MapConcatFun {
-	static constexpr const char *Name = "map_concat";
-	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision the value is taken from the last map with that key";
-	static constexpr const char *Example = "map_concat(map([1,2], ['a', 'b']), map([2,3], ['c', 'd']));";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MapKeysFun {
-	static constexpr const char *Name = "map_keys";
-	static constexpr const char *Parameters = "map";
-	static constexpr const char *Description = "Returns the keys of a map as a list";
-	static constexpr const char *Example = "map_keys(map(['key'], ['val']))";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MapValuesFun {
-	static constexpr const char *Name = "map_values";
-	static constexpr const char *Parameters = "map";
-	static constexpr const char *Description = "Returns the values of a map as a list";
-	static constexpr const char *Example = "map_values(map(['key'], ['val']))";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/math_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/math_functions.hpp
deleted file mode 100644
index 7b8e2befd..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/math_functions.hpp
+++ /dev/null
@@ -1,453 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/math_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct AbsOperatorFun {
-	static constexpr const char *Name = "@";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Absolute value";
-	static constexpr const char *Example = "abs(-17.4)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct AbsFun {
-	using ALIAS = AbsOperatorFun;
-
-	static constexpr const char *Name = "abs";
-};
-
-struct PowOperatorFun {
-	static constexpr const char *Name = "**";
-	static constexpr const char *Parameters = "x,y";
-	static constexpr const char *Description = "Computes x to the power of y";
-	static constexpr const char *Example = "pow(2, 3)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct PowFun {
-	using ALIAS = PowOperatorFun;
-
-	static constexpr const char *Name = "pow";
-};
-
-struct PowerFun {
-	using ALIAS = PowOperatorFun;
-
-	static constexpr const char *Name = "power";
-};
-
-struct PowOperatorFunAlias {
-	using ALIAS = PowOperatorFun;
-
-	static constexpr const char *Name = "^";
-};
-
-struct FactorialOperatorFun {
-	static constexpr const char *Name = "!__postfix";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Factorial of x. Computes the product of the current integer and all integers below it";
-	static constexpr const char *Example = "4!";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FactorialFun {
-	using ALIAS = FactorialOperatorFun;
-
-	static constexpr const char *Name = "factorial";
-};
-
-struct AcosFun {
-	static constexpr const char *Name = "acos";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the arccosine of x";
-	static constexpr const char *Example = "acos(0.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct AsinFun {
-	static constexpr const char *Name = "asin";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the arcsine of x";
-	static constexpr const char *Example = "asin(0.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct AtanFun {
-	static constexpr const char *Name = "atan";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the arctangent of x";
-	static constexpr const char *Example = "atan(0.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct Atan2Fun {
-	static constexpr const char *Name = "atan2";
-	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Computes the arctangent (y, x)";
-	static constexpr const char *Example = "atan2(1.0, 0.0)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct BitCountFun {
-	static constexpr const char *Name = "bit_count";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the number of bits that are set";
-	static constexpr const char *Example = "bit_count(31)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct CbrtFun {
-	static constexpr const char *Name = "cbrt";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the cube root of x";
-	static constexpr const char *Example = "cbrt(8)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CeilFun {
-	static constexpr const char *Name = "ceil";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Rounds the number up";
-	static constexpr const char *Example = "ceil(17.4)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct CeilingFun {
-	using ALIAS = CeilFun;
-
-	static constexpr const char *Name = "ceiling";
-};
-
-struct CosFun {
-	static constexpr const char *Name = "cos";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the cos of x";
-	static constexpr const char *Example = "cos(90)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CotFun {
-	static constexpr const char *Name = "cot";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the cotangent of x";
-	static constexpr const char *Example = "cot(0.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct DegreesFun {
-	static constexpr const char *Name = "degrees";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Converts radians to degrees";
-	static constexpr const char *Example = "degrees(pi())";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EvenFun {
-	static constexpr const char *Name = "even";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Rounds x to next even number by rounding away from zero";
-	static constexpr const char *Example = "even(2.9)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ExpFun {
-	static constexpr const char *Name = "exp";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes e to the power of x";
-	static constexpr const char *Example = "exp(1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FloorFun {
-	static constexpr const char *Name = "floor";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Rounds the number down";
-	static constexpr const char *Example = "floor(17.4)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct IsFiniteFun {
-	static constexpr const char *Name = "isfinite";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns true if the floating point value is finite, false otherwise";
-	static constexpr const char *Example = "isfinite(5.5)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct IsInfiniteFun {
-	static constexpr const char *Name = "isinf";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns true if the floating point value is infinite, false otherwise";
-	static constexpr const char *Example = "isinf('Infinity'::float)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct IsNanFun {
-	static constexpr const char *Name = "isnan";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns true if the floating point value is not a number, false otherwise";
-	static constexpr const char *Example = "isnan('NaN'::FLOAT)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct GammaFun {
-	static constexpr const char *Name = "gamma";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Interpolation of (x-1) factorial (so decimal inputs are allowed)";
-	static constexpr const char *Example = "gamma(5.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct GreatestCommonDivisorFun {
-	static constexpr const char *Name = "greatest_common_divisor";
-	static constexpr const char *Parameters = "x,y";
-	static constexpr const char *Description = "Computes the greatest common divisor of x and y";
-	static constexpr const char *Example = "greatest_common_divisor(42, 57)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct GcdFun {
-	using ALIAS = GreatestCommonDivisorFun;
-
-	static constexpr const char *Name = "gcd";
-};
-
-struct LeastCommonMultipleFun {
-	static constexpr const char *Name = "least_common_multiple";
-	static constexpr const char *Parameters = "x,y";
-	static constexpr const char *Description = "Computes the least common multiple of x and y";
-	static constexpr const char *Example = "least_common_multiple(42, 57)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct LcmFun {
-	using ALIAS = LeastCommonMultipleFun;
-
-	static constexpr const char *Name = "lcm";
-};
-
-struct LogGammaFun {
-	static constexpr const char *Name = "lgamma";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the log of the gamma function";
-	static constexpr const char *Example = "lgamma(2)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LnFun {
-	static constexpr const char *Name = "ln";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the natural logarithm of x";
-	static constexpr const char *Example = "ln(2)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct Log2Fun {
-	static constexpr const char *Name = "log2";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the 2-log of x";
-	static constexpr const char *Example = "log2(8)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct Log10Fun {
-	static constexpr const char *Name = "log10";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the 10-log of x";
-	static constexpr const char *Example = "log10(1000)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LogFun {
-	static constexpr const char *Name = "log";
-	static constexpr const char *Parameters = "b, x";
-	static constexpr const char *Description = "Computes the logarithm of x to base b. b may be omitted, in which case the default 10";
-	static constexpr const char *Example = "log(2, 64)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct NextAfterFun {
-	static constexpr const char *Name = "nextafter";
-	static constexpr const char *Parameters = "x, y";
-	static constexpr const char *Description = "Returns the next floating point value after x in the direction of y";
-	static constexpr const char *Example = "nextafter(1::float, 2::float)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct PiFun {
-	static constexpr const char *Name = "pi";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns the value of pi";
-	static constexpr const char *Example = "pi()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RadiansFun {
-	static constexpr const char *Name = "radians";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Converts degrees to radians";
-	static constexpr const char *Example = "radians(90)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RoundFun {
-	static constexpr const char *Name = "round";
-	static constexpr const char *Parameters = "x,precision";
-	static constexpr const char *Description = "Rounds x to s decimal places";
-	static constexpr const char *Example = "round(42.4332, 2)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SignFun {
-	static constexpr const char *Name = "sign";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the sign of x as -1, 0 or 1";
-	static constexpr const char *Example = "sign(-349)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SignBitFun {
-	static constexpr const char *Name = "signbit";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns whether the signbit is set or not";
-	static constexpr const char *Example = "signbit(-0.0)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SinFun {
-	static constexpr const char *Name = "sin";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the sin of x";
-	static constexpr const char *Example = "sin(90)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct SqrtFun {
-	static constexpr const char *Name = "sqrt";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Returns the square root of x";
-	static constexpr const char *Example = "sqrt(4)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct TanFun {
-	static constexpr const char *Name = "tan";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the tan of x";
-	static constexpr const char *Example = "tan(90)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct TruncFun {
-	static constexpr const char *Name = "trunc";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Truncates the number";
-	static constexpr const char *Example = "trunc(17.4)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct CoshFun {
-	static constexpr const char *Name = "cosh";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the hyperbolic cos of x";
-	static constexpr const char *Example = "cosh(1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct SinhFun {
-	static constexpr const char *Name = "sinh";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the hyperbolic sin of x";
-	static constexpr const char *Example = "sinh(1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct TanhFun {
-	static constexpr const char *Name = "tanh";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the hyperbolic tan of x";
-	static constexpr const char *Example = "tanh(1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct AcoshFun {
-	static constexpr const char *Name = "acosh";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the inverse hyperbolic cos of x";
-	static constexpr const char *Example = "acosh(2.3)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct AsinhFun {
-	static constexpr const char *Name = "asinh";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the inverse hyperbolic sin of x";
-	static constexpr const char *Example = "asinh(0.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct AtanhFun {
-	static constexpr const char *Name = "atanh";
-	static constexpr const char *Parameters = "x";
-	static constexpr const char *Description = "Computes the inverse hyperbolic tan of x";
-	static constexpr const char *Example = "atanh(0.5)";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/operators_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/operators_functions.hpp
deleted file mode 100644
index 3bbfc565a..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/operators_functions.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/operators_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct BitwiseAndFun {
-	static constexpr const char *Name = "&";
-	static constexpr const char *Parameters = "left,right";
-	static constexpr const char *Description = "Bitwise AND";
-	static constexpr const char *Example = "91 & 15";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct BitwiseOrFun {
-	static constexpr const char *Name = "|";
-	static constexpr const char *Parameters = "left,right";
-	static constexpr const char *Description = "Bitwise OR";
-	static constexpr const char *Example = "32 | 3";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct BitwiseNotFun {
-	static constexpr const char *Name = "~";
-	static constexpr const char *Parameters = "input";
-	static constexpr const char *Description = "Bitwise NOT";
-	static constexpr const char *Example = "~15";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct LeftShiftFun {
-	static constexpr const char *Name = "<<";
-	static constexpr const char *Parameters = "input";
-	static constexpr const char *Description = "Bitwise shift left";
-	static constexpr const char *Example = "1 << 4";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct RightShiftFun {
-	static constexpr const char *Name = ">>";
-	static constexpr const char *Parameters = "input";
-	static constexpr const char *Description = "Bitwise shift right";
-	static constexpr const char *Example = "8 >> 2";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct BitwiseXorFun {
-	static constexpr const char *Name = "xor";
-	static constexpr const char *Parameters = "left,right";
-	static constexpr const char *Description = "Bitwise XOR";
-	static constexpr const char *Example = "xor(17, 5)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/random_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/random_functions.hpp
deleted file mode 100644
index 1002f0e44..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/random_functions.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/random_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct RandomFun {
-	static constexpr const char *Name = "random";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns a random number between 0 and 1";
-	static constexpr const char *Example = "random()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct SetseedFun {
-	static constexpr const char *Name = "setseed";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Sets the seed to be used for the random function";
-	static constexpr const char *Example = "setseed(0.42)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct UUIDFun {
-	static constexpr const char *Name = "uuid";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Returns a random UUID similar to this: eeccb8c5-9943-b2bb-bb5e-222f4e14b687";
-	static constexpr const char *Example = "uuid()";
-
-	static ScalarFunction GetFunction();
-};
-
-struct GenRandomUuidFun {
-	using ALIAS = UUIDFun;
-
-	static constexpr const char *Name = "gen_random_uuid";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/secret_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/secret_functions.hpp
deleted file mode 100644
index 17e5614e0..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/secret_functions.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/core_functions/scalar/secret_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct WhichSecretFun {
-	static constexpr const char *Name = "which_secret";
-	static constexpr const char *Parameters = "path,type";
-	static constexpr const char *Description = "Print out the name of the secret that will be used for reading a path";
-	static constexpr const char *Example = "which_secret('s3://some/authenticated/path.csv', 's3')";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/string_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/string_functions.hpp
deleted file mode 100644
index 6a6db36da..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/string_functions.hpp
+++ /dev/null
@@ -1,444 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/string_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct StartsWithOperatorFun {
-	static constexpr const char *Name = "^@";
-	static constexpr const char *Parameters = "string,search_string";
-	static constexpr const char *Description = "Returns true if string begins with search_string";
-	static constexpr const char *Example = "starts_with('abc','a')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct StartsWithFun {
-	using ALIAS = StartsWithOperatorFun;
-
-	static constexpr const char *Name = "starts_with";
-};
-
-struct ASCIIFun {
-	static constexpr const char *Name = "ascii";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Returns an integer that represents the Unicode code point of the first character of the string";
-	static constexpr const char *Example = "ascii('Ω')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct BarFun {
-	static constexpr const char *Name = "bar";
-	static constexpr const char *Parameters = "x,min,max,width";
-	static constexpr const char *Description = "Draws a band whose width is proportional to (x - min) and equal to width characters when x = max. width defaults to 80";
-	static constexpr const char *Example = "bar(5, 0, 20, 10)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct BinFun {
-	static constexpr const char *Name = "bin";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Converts the value to binary representation";
-	static constexpr const char *Example = "bin(42)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ToBinaryFun {
-	using ALIAS = BinFun;
-
-	static constexpr const char *Name = "to_binary";
-};
-
-struct ChrFun {
-	static constexpr const char *Name = "chr";
-	static constexpr const char *Parameters = "code_point";
-	static constexpr const char *Description = "Returns a character which is corresponding the ASCII code value or Unicode code point";
-	static constexpr const char *Example = "chr(65)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct DamerauLevenshteinFun {
-	static constexpr const char *Name = "damerau_levenshtein";
-	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or transpositions) required to change one string to another. Different case is considered different";
-	static constexpr const char *Example = "damerau_levenshtein('hello', 'world')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FormatFun {
-	static constexpr const char *Name = "format";
-	static constexpr const char *Parameters = "format,parameters...";
-	static constexpr const char *Description = "Formats a string using fmt syntax";
-	static constexpr const char *Example = "format('Benchmark \"{}\" took {} seconds', 'CSV', 42)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FormatBytesFun {
-	static constexpr const char *Name = "format_bytes";
-	static constexpr const char *Parameters = "bytes";
-	static constexpr const char *Description = "Converts bytes to a human-readable presentation (e.g. 16000 -> 15.6 KiB)";
-	static constexpr const char *Example = "format_bytes(1000 * 16)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FormatreadablesizeFun {
-	using ALIAS = FormatBytesFun;
-
-	static constexpr const char *Name = "formatReadableSize";
-};
-
-struct FormatreadabledecimalsizeFun {
-	static constexpr const char *Name = "formatReadableDecimalSize";
-	static constexpr const char *Parameters = "bytes";
-	static constexpr const char *Description = "Converts bytes to a human-readable presentation (e.g. 16000 -> 16.0 KB)";
-	static constexpr const char *Example = "format_bytes(1000 * 16)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct HammingFun {
-	static constexpr const char *Name = "hamming";
-	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The number of positions with different characters for 2 strings of equal length. Different case is considered different";
-	static constexpr const char *Example = "hamming('duck','luck')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MismatchesFun {
-	using ALIAS = HammingFun;
-
-	static constexpr const char *Name = "mismatches";
-};
-
-struct HexFun {
-	static constexpr const char *Name = "hex";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Converts the value to hexadecimal representation";
-	static constexpr const char *Example = "hex(42)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ToHexFun {
-	using ALIAS = HexFun;
-
-	static constexpr const char *Name = "to_hex";
-};
-
-struct InstrFun {
-	static constexpr const char *Name = "instr";
-	static constexpr const char *Parameters = "haystack,needle";
-	static constexpr const char *Description = "Returns location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found";
-	static constexpr const char *Example = "instr('test test','es')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct StrposFun {
-	using ALIAS = InstrFun;
-
-	static constexpr const char *Name = "strpos";
-};
-
-struct PositionFun {
-	using ALIAS = InstrFun;
-
-	static constexpr const char *Name = "position";
-};
-
-struct JaccardFun {
-	static constexpr const char *Name = "jaccard";
-	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is considered different. Returns a number between 0 and 1";
-	static constexpr const char *Example = "jaccard('duck','luck')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct JaroSimilarityFun {
-	static constexpr const char *Name = "jaro_similarity";
-	static constexpr const char *Parameters = "str1,str2,score_cutoff";
-	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered different. Returns a number between 0 and 1";
-	static constexpr const char *Example = "jaro_similarity('duck', 'duckdb', 0.5)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct JaroWinklerSimilarityFun {
-	static constexpr const char *Name = "jaro_winkler_similarity";
-	static constexpr const char *Parameters = "str1,str2,score_cutoff";
-	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is considered different. Returns a number between 0 and 1";
-	static constexpr const char *Example = "jaro_winkler_similarity('duck', 'duckdb', 0.5)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct LeftFun {
-	static constexpr const char *Name = "left";
-	static constexpr const char *Parameters = "string,count";
-	static constexpr const char *Description = "Extract the left-most count characters";
-	static constexpr const char *Example = "left('Hello🦆', 2)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LeftGraphemeFun {
-	static constexpr const char *Name = "left_grapheme";
-	static constexpr const char *Parameters = "string,count";
-	static constexpr const char *Description = "Extract the left-most count grapheme clusters";
-	static constexpr const char *Example = "left_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LevenshteinFun {
-	static constexpr const char *Name = "levenshtein";
-	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one string to the other. Different case is considered different";
-	static constexpr const char *Example = "levenshtein('duck','db')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct Editdist3Fun {
-	using ALIAS = LevenshteinFun;
-
-	static constexpr const char *Name = "editdist3";
-};
-
-struct LpadFun {
-	static constexpr const char *Name = "lpad";
-	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description = "Pads the string with the character from the left until it has count characters";
-	static constexpr const char *Example = "lpad('hello', 10, '>')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LtrimFun {
-	static constexpr const char *Name = "ltrim";
-	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description = "Removes any occurrences of any of the characters from the left side of the string";
-	static constexpr const char *Example = "ltrim('>>>>test<<', '><')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ParseDirnameFun {
-	static constexpr const char *Name = "parse_dirname";
-	static constexpr const char *Parameters = "string,separator";
-	static constexpr const char *Description = "Returns the top-level directory name. separator options: system, both_slash (default), forward_slash, backslash";
-	static constexpr const char *Example = "parse_dirname('path/to/file.csv', 'system')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ParseDirpathFun {
-	static constexpr const char *Name = "parse_dirpath";
-	static constexpr const char *Parameters = "string,separator";
-	static constexpr const char *Description = "Returns the head of the path similarly to Python's os.path.dirname. separator options: system, both_slash (default), forward_slash, backslash";
-	static constexpr const char *Example = "parse_dirpath('path/to/file.csv', 'system')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ParseFilenameFun {
-	static constexpr const char *Name = "parse_filename";
-	static constexpr const char *Parameters = "string,trim_extension,separator";
-	static constexpr const char *Description = "Returns the last component of the path similarly to Python's os.path.basename. If trim_extension is true, the file extension will be removed (it defaults to false). separator options: system, both_slash (default), forward_slash, backslash";
-	static constexpr const char *Example = "parse_filename('path/to/file.csv', true, 'forward_slash')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ParsePathFun {
-	static constexpr const char *Name = "parse_path";
-	static constexpr const char *Parameters = "string,separator";
-	static constexpr const char *Description = "Returns a list of the components (directories and filename) in the path similarly to Python's pathlib.PurePath::parts. separator options: system, both_slash (default), forward_slash, backslash";
-	static constexpr const char *Example = "parse_path('path/to/file.csv', 'system')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct PrintfFun {
-	static constexpr const char *Name = "printf";
-	static constexpr const char *Parameters = "format,parameters...";
-	static constexpr const char *Description = "Formats a string using printf syntax";
-	static constexpr const char *Example = "printf('Benchmark \"%s\" took %d seconds', 'CSV', 42)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RepeatFun {
-	static constexpr const char *Name = "repeat";
-	static constexpr const char *Parameters = "string,count";
-	static constexpr const char *Description = "Repeats the string count number of times";
-	static constexpr const char *Example = "repeat('A', 5)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ReplaceFun {
-	static constexpr const char *Name = "replace";
-	static constexpr const char *Parameters = "string,source,target";
-	static constexpr const char *Description = "Replaces any occurrences of the source with target in string";
-	static constexpr const char *Example = "replace('hello', 'l', '-')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ReverseFun {
-	static constexpr const char *Name = "reverse";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Reverses the string";
-	static constexpr const char *Example = "reverse('hello')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RightFun {
-	static constexpr const char *Name = "right";
-	static constexpr const char *Parameters = "string,count";
-	static constexpr const char *Description = "Extract the right-most count characters";
-	static constexpr const char *Example = "right('Hello🦆', 3)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RightGraphemeFun {
-	static constexpr const char *Name = "right_grapheme";
-	static constexpr const char *Parameters = "string,count";
-	static constexpr const char *Description = "Extract the right-most count grapheme clusters";
-	static constexpr const char *Example = "right_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RpadFun {
-	static constexpr const char *Name = "rpad";
-	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description = "Pads the string with the character from the right until it has count characters";
-	static constexpr const char *Example = "rpad('hello', 10, '<')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RtrimFun {
-	static constexpr const char *Name = "rtrim";
-	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description = "Removes any occurrences of any of the characters from the right side of the string";
-	static constexpr const char *Example = "rtrim('>>>>test<<', '><')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TranslateFun {
-	static constexpr const char *Name = "translate";
-	static constexpr const char *Parameters = "string,from,to";
-	static constexpr const char *Description = "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted";
-	static constexpr const char *Example = "translate('12345', '143', 'ax')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct TrimFun {
-	static constexpr const char *Name = "trim";
-	static constexpr const char *Parameters = "string::VARCHAR\1string::VARCHAR,characters::VARCHAR";
-	static constexpr const char *Description = "Removes any spaces from either side of the string.\1Removes any occurrences of any of the characters from either side of the string";
-	static constexpr const char *Example = "trim(' test ')\1trim('>>>>test<<', '><')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct UnbinFun {
-	static constexpr const char *Name = "unbin";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Converts a value from binary representation to a blob";
-	static constexpr const char *Example = "unbin('0110')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FromBinaryFun {
-	using ALIAS = UnbinFun;
-
-	static constexpr const char *Name = "from_binary";
-};
-
-struct UnhexFun {
-	static constexpr const char *Name = "unhex";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Converts a value from hexadecimal representation to a blob";
-	static constexpr const char *Example = "unhex('2A')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct FromHexFun {
-	using ALIAS = UnhexFun;
-
-	static constexpr const char *Name = "from_hex";
-};
-
-struct UnicodeFun {
-	static constexpr const char *Name = "unicode";
-	static constexpr const char *Parameters = "str";
-	static constexpr const char *Description = "Returns the unicode codepoint of the first character of the string";
-	static constexpr const char *Example = "unicode('ü')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct OrdFun {
-	using ALIAS = UnicodeFun;
-
-	static constexpr const char *Name = "ord";
-};
-
-struct ToBaseFun {
-	static constexpr const char *Name = "to_base";
-	static constexpr const char *Parameters = "number,radix,min_length";
-	static constexpr const char *Description = "Converts a value to a string in the given base radix, optionally padding with leading zeros to the minimum length";
-	static constexpr const char *Example = "to_base(42, 16)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct UrlEncodeFun {
-	static constexpr const char *Name = "url_encode";
-	static constexpr const char *Parameters = "input";
-	static constexpr const char *Description = "Escapes the input string by encoding it so that it can be included in a URL query parameter.";
-	static constexpr const char *Example = "url_encode('this string has/ special+ characters>')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct UrlDecodeFun {
-	static constexpr const char *Name = "url_decode";
-	static constexpr const char *Parameters = "input";
-	static constexpr const char *Description = "Unescapes the URL encoded input.";
-	static constexpr const char *Example = "url_decode('this%20string%20is%2BFencoded')";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/struct_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/struct_functions.hpp
deleted file mode 100644
index f921bf434..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/struct_functions.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/struct_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct StructInsertFun {
-	static constexpr const char *Name = "struct_insert";
-	static constexpr const char *Parameters = "struct,any";
-	static constexpr const char *Description = "Adds field(s)/value(s) to an existing STRUCT with the argument values. The entry name(s) will be the bound variable name(s)";
-	static constexpr const char *Example = "struct_insert({'a': 1}, b := 2)";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/union_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/union_functions.hpp
deleted file mode 100644
index 766c12e8f..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions/scalar/union_functions.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions/scalar/union_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct UnionExtractFun {
-	static constexpr const char *Name = "union_extract";
-	static constexpr const char *Parameters = "union,tag";
-	static constexpr const char *Description = "Extract the value with the named tags from the union. NULL if the tag is not currently selected";
-	static constexpr const char *Example = "union_extract(s, 'k')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct UnionTagFun {
-	static constexpr const char *Name = "union_tag";
-	static constexpr const char *Parameters = "union";
-	static constexpr const char *Description = "Retrieve the currently selected tag of the union as an ENUM";
-	static constexpr const char *Example = "union_tag(union_value(k := 'foo'))";
-
-	static ScalarFunction GetFunction();
-};
-
-struct UnionValueFun {
-	static constexpr const char *Name = "union_value";
-	static constexpr const char *Parameters = "tag";
-	static constexpr const char *Description = "Create a single member UNION containing the argument value. The tag of the value will be the bound variable name";
-	static constexpr const char *Example = "union_value(k := 'hello')";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/include/core_functions_extension.hpp b/src/duckdb/extension/core_functions/include/core_functions_extension.hpp
deleted file mode 100644
index e877860f0..000000000
--- a/src/duckdb/extension/core_functions/include/core_functions_extension.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// core_functions_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-
-namespace duckdb {
-
-class CoreFunctionsExtension : public Extension {
-public:
-	void Load(DuckDB &db) override;
-	std::string Name() override;
-	std::string Version() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/lambda_functions.cpp b/src/duckdb/extension/core_functions/lambda_functions.cpp
deleted file mode 100644
index b5549914a..000000000
--- a/src/duckdb/extension/core_functions/lambda_functions.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-#include "duckdb/function/lambda_functions.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Helper functions
-//===--------------------------------------------------------------------===//
-
-//! LambdaExecuteInfo holds information for executing the lambda expression on an input chunk and
-//! a resulting lambda chunk.
-struct LambdaExecuteInfo {
-	LambdaExecuteInfo(ClientContext &context, const Expression &lambda_expr, const DataChunk &args,
-	                  const bool has_index, const Vector &child_vector)
-	    : has_index(has_index) {
-
-		expr_executor = make_uniq<ExpressionExecutor>(context, lambda_expr);
-
-		// get the input types for the input chunk
-		vector<LogicalType> input_types;
-		if (has_index) {
-			input_types.push_back(LogicalType::BIGINT);
-		}
-		input_types.push_back(child_vector.GetType());
-		for (idx_t i = 1; i < args.ColumnCount(); i++) {
-			input_types.push_back(args.data[i].GetType());
-		}
-
-		// get the result types
-		vector<LogicalType> result_types {lambda_expr.return_type};
-
-		// initialize the data chunks
-		input_chunk.InitializeEmpty(input_types);
-		lambda_chunk.Initialize(Allocator::DefaultAllocator(), result_types);
-	};
-
-	//! The expression executor that executes the lambda expression
-	unique_ptr<ExpressionExecutor> expr_executor;
-	//! The input chunk on which we execute the lambda expression
-	DataChunk input_chunk;
-	//! The chunk holding the result of executing the lambda expression
-	DataChunk lambda_chunk;
-	//! True, if this lambda expression expects an index vector in the input chunk
-	bool has_index;
-};
-
-//! A helper struct with information that is specific to the list_filter function
-struct ListFilterInfo {
-	//! The new list lengths after filtering out elements
-	vector<idx_t> entry_lengths;
-	//! The length of the current list
-	idx_t length = 0;
-	//! The offset of the current list
-	idx_t offset = 0;
-	//! The current row index
-	idx_t row_idx = 0;
-	//! The length of the source list
-	idx_t src_length = 0;
-};
-
-//! ListTransformFunctor contains list_transform specific functionality
-struct ListTransformFunctor {
-	static void ReserveNewLengths(vector<idx_t> &, const idx_t) {
-		// NOP
-	}
-	static void PushEmptyList(vector<idx_t> &) {
-		// NOP
-	}
-	//! Sets the list entries of the result vector
-	static void SetResultEntry(list_entry_t *result_entries, idx_t &offset, const list_entry_t &entry,
-	                           const idx_t row_idx, vector<idx_t> &) {
-		result_entries[row_idx].offset = offset;
-		result_entries[row_idx].length = entry.length;
-		offset += entry.length;
-	}
-	//! Appends the lambda vector to the result's child vector
-	static void AppendResult(Vector &result, Vector &lambda_vector, const idx_t elem_cnt, list_entry_t *,
-	                         ListFilterInfo &, LambdaExecuteInfo &) {
-		ListVector::Append(result, lambda_vector, elem_cnt, 0);
-	}
-};
-
-//! ListFilterFunctor contains list_filter specific functionality
-struct ListFilterFunctor {
-	//! Initializes the entry_lengths vector
-	static void ReserveNewLengths(vector<idx_t> &entry_lengths, const idx_t row_count) {
-		entry_lengths.reserve(row_count);
-	}
-	//! Pushes an empty list to the entry_lengths vector
-	static void PushEmptyList(vector<idx_t> &entry_lengths) {
-		entry_lengths.emplace_back(0);
-	}
-	//! Pushes the length of the original list to the entry_lengths vector
-	static void SetResultEntry(list_entry_t *, idx_t &, const list_entry_t &entry, const idx_t,
-	                           vector<idx_t> &entry_lengths) {
-		entry_lengths.push_back(entry.length);
-	}
-	//! Uses the lambda vector to filter the incoming list and to append the filtered list to the result vector
-	static void AppendResult(Vector &result, Vector &lambda_vector, const idx_t elem_cnt, list_entry_t *result_entries,
-	                         ListFilterInfo &info, LambdaExecuteInfo &execute_info) {
-
-		idx_t count = 0;
-		SelectionVector sel(elem_cnt);
-		UnifiedVectorFormat lambda_data;
-		lambda_vector.ToUnifiedFormat(elem_cnt, lambda_data);
-
-		auto lambda_values = UnifiedVectorFormat::GetData<bool>(lambda_data);
-		auto &lambda_validity = lambda_data.validity;
-
-		// compute the new lengths and offsets, and create a selection vector
-		for (idx_t i = 0; i < elem_cnt; i++) {
-			auto entry_idx = lambda_data.sel->get_index(i);
-
-			// set length and offset of empty lists
-			while (info.row_idx < info.entry_lengths.size() && !info.entry_lengths[info.row_idx]) {
-				result_entries[info.row_idx].offset = info.offset;
-				result_entries[info.row_idx].length = 0;
-				info.row_idx++;
-			}
-
-			// found a true value
-			if (lambda_validity.RowIsValid(entry_idx) && lambda_values[entry_idx]) {
-				sel.set_index(count++, i);
-				info.length++;
-			}
-
-			info.src_length++;
-
-			// we traversed the entire source list
-			if (info.entry_lengths[info.row_idx] == info.src_length) {
-				// set the offset and length of the result entry
-				result_entries[info.row_idx].offset = info.offset;
-				result_entries[info.row_idx].length = info.length;
-
-				// reset all other fields
-				info.offset += info.length;
-				info.row_idx++;
-				info.length = 0;
-				info.src_length = 0;
-			}
-		}
-
-		// set length and offset of all remaining empty lists
-		while (info.row_idx < info.entry_lengths.size() && !info.entry_lengths[info.row_idx]) {
-			result_entries[info.row_idx].offset = info.offset;
-			result_entries[info.row_idx].length = 0;
-			info.row_idx++;
-		}
-
-		// slice the input chunk's corresponding vector to get the new lists
-		// and append them to the result
-		idx_t source_list_idx = execute_info.has_index ? 1 : 0;
-		Vector result_lists(execute_info.input_chunk.data[source_list_idx], sel, count);
-		ListVector::Append(result, result_lists, count, 0);
-	}
-};
-
-vector<LambdaFunctions::ColumnInfo> LambdaFunctions::GetColumnInfo(DataChunk &args, const idx_t row_count) {
-	vector<ColumnInfo> data;
-	// skip the input list and then insert all remaining input vectors
-	for (idx_t i = 1; i < args.ColumnCount(); i++) {
-		data.emplace_back(args.data[i]);
-		args.data[i].ToUnifiedFormat(row_count, data.back().format);
-	}
-	return data;
-}
-
-vector<reference<LambdaFunctions::ColumnInfo>>
-LambdaFunctions::GetMutableColumnInfo(vector<LambdaFunctions::ColumnInfo> &data) {
-	vector<reference<ColumnInfo>> inconstant_info;
-	for (auto &entry : data) {
-		if (entry.vector.get().GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			inconstant_info.push_back(entry);
-		}
-	}
-	return inconstant_info;
-}
-
-void ExecuteExpression(const idx_t elem_cnt, const LambdaFunctions::ColumnInfo &column_info,
-                       const vector<LambdaFunctions::ColumnInfo> &column_infos, const Vector &index_vector,
-                       LambdaExecuteInfo &info) {
-
-	info.input_chunk.SetCardinality(elem_cnt);
-	info.lambda_chunk.SetCardinality(elem_cnt);
-
-	// slice the child vector
-	Vector slice(column_info.vector, column_info.sel, elem_cnt);
-
-	// reference the child vector (and the index vector)
-	if (info.has_index) {
-		info.input_chunk.data[0].Reference(index_vector);
-		info.input_chunk.data[1].Reference(slice);
-	} else {
-		info.input_chunk.data[0].Reference(slice);
-	}
-	idx_t slice_offset = info.has_index ? 2 : 1;
-
-	// (slice and) reference the other columns
-	vector<Vector> slices;
-	for (idx_t i = 0; i < column_infos.size(); i++) {
-
-		if (column_infos[i].vector.get().GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// only reference constant vectorsl
-			info.input_chunk.data[i + slice_offset].Reference(column_infos[i].vector);
-
-		} else {
-			// slice inconstant vectors
-			slices.emplace_back(column_infos[i].vector, column_infos[i].sel, elem_cnt);
-			info.input_chunk.data[i + slice_offset].Reference(slices.back());
-		}
-	}
-
-	// execute the lambda expression
-	info.expr_executor->Execute(info.input_chunk, info.lambda_chunk);
-}
-
-//===--------------------------------------------------------------------===//
-// ListLambdaBindData
-//===--------------------------------------------------------------------===//
-
-unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
-	auto lambda_expr_copy = lambda_expr ? lambda_expr->Copy() : nullptr;
-	return make_uniq<ListLambdaBindData>(return_type, std::move(lambda_expr_copy), has_index);
-}
-
-bool ListLambdaBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ListLambdaBindData>();
-	return Expression::Equals(lambda_expr, other.lambda_expr) && return_type == other.return_type &&
-	       has_index == other.has_index;
-}
-
-void ListLambdaBindData::Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                   const ScalarFunction &) {
-	auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
-	serializer.WriteProperty(100, "return_type", bind_data.return_type);
-	serializer.WritePropertyWithDefault(101, "lambda_expr", bind_data.lambda_expr, unique_ptr<Expression>());
-	serializer.WriteProperty(102, "has_index", bind_data.has_index);
-}
-
-unique_ptr<FunctionData> ListLambdaBindData::Deserialize(Deserializer &deserializer, ScalarFunction &) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(100, "return_type");
-	auto lambda_expr = deserializer.ReadPropertyWithExplicitDefault<unique_ptr<Expression>>(101, "lambda_expr",
-	                                                                                        unique_ptr<Expression>());
-	auto has_index = deserializer.ReadProperty<bool>(102, "has_index");
-	return make_uniq<ListLambdaBindData>(return_type, std::move(lambda_expr), has_index);
-}
-
-//===--------------------------------------------------------------------===//
-// LambdaFunctions
-//===--------------------------------------------------------------------===//
-
-LogicalType LambdaFunctions::BindBinaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	switch (parameter_idx) {
-	case 0:
-		return list_child_type;
-	case 1:
-		return LogicalType::BIGINT;
-	default:
-		throw BinderException("This lambda function only supports up to two lambda parameters!");
-	}
-}
-
-LogicalType LambdaFunctions::BindTernaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	switch (parameter_idx) {
-	case 0:
-		return list_child_type;
-	case 1:
-		return list_child_type;
-	case 2:
-		return LogicalType::BIGINT;
-	default:
-		throw BinderException("This lambda function only supports up to three lambda parameters!");
-	}
-}
-
-template <class FUNCTION_FUNCTOR>
-void ExecuteLambda(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	bool result_is_null = false;
-	LambdaFunctions::LambdaInfo info(args, state, result, result_is_null);
-	if (result_is_null) {
-		return;
-	}
-
-	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	auto mutable_column_infos = LambdaFunctions::GetMutableColumnInfo(info.column_infos);
-
-	// special-handling for the child_vector
-	auto child_vector_size = ListVector::GetListSize(args.data[0]);
-	LambdaFunctions::ColumnInfo child_info(*info.child_vector);
-	info.child_vector->ToUnifiedFormat(child_vector_size, child_info.format);
-
-	// get the expression executor
-	LambdaExecuteInfo execute_info(state.GetContext(), *info.lambda_expr, args, info.has_index, *info.child_vector);
-
-	// get list_filter specific info
-	ListFilterInfo list_filter_info;
-	FUNCTION_FUNCTOR::ReserveNewLengths(list_filter_info.entry_lengths, info.row_count);
-
-	// additional index vector
-	Vector index_vector(LogicalType::BIGINT);
-
-	// loop over the child entries and create chunks to be executed by the expression executor
-	idx_t elem_cnt = 0;
-	idx_t offset = 0;
-	for (idx_t row_idx = 0; row_idx < info.row_count; row_idx++) {
-
-		auto list_idx = info.list_column_format.sel->get_index(row_idx);
-		const auto &list_entry = info.list_entries[list_idx];
-
-		// set the result to NULL for this row
-		if (!info.list_column_format.validity.RowIsValid(list_idx)) {
-			info.result_validity->SetInvalid(row_idx);
-			FUNCTION_FUNCTOR::PushEmptyList(list_filter_info.entry_lengths);
-			continue;
-		}
-
-		FUNCTION_FUNCTOR::SetResultEntry(result_entries, offset, list_entry, row_idx, list_filter_info.entry_lengths);
-
-		// empty list, nothing to execute
-		if (list_entry.length == 0) {
-			continue;
-		}
-
-		// iterate the elements of the current list and create the corresponding selection vectors
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			// reached STANDARD_VECTOR_SIZE elements
-			if (elem_cnt == STANDARD_VECTOR_SIZE) {
-
-				execute_info.lambda_chunk.Reset();
-				ExecuteExpression(elem_cnt, child_info, info.column_infos, index_vector, execute_info);
-				auto &lambda_vector = execute_info.lambda_chunk.data[0];
-
-				FUNCTION_FUNCTOR::AppendResult(result, lambda_vector, elem_cnt, result_entries, list_filter_info,
-				                               execute_info);
-				elem_cnt = 0;
-			}
-
-			// FIXME: reuse same selection vector for inconstant rows
-			// adjust indexes for slicing
-			child_info.sel.set_index(elem_cnt, list_entry.offset + child_idx);
-			for (auto &entry : mutable_column_infos) {
-				entry.get().sel.set_index(elem_cnt, row_idx);
-			}
-
-			// set the index vector
-			if (info.has_index) {
-				index_vector.SetValue(elem_cnt, Value::BIGINT(NumericCast<int64_t>(child_idx + 1)));
-			}
-
-			elem_cnt++;
-		}
-	}
-
-	execute_info.lambda_chunk.Reset();
-	ExecuteExpression(elem_cnt, child_info, info.column_infos, index_vector, execute_info);
-	auto &lambda_vector = execute_info.lambda_chunk.data[0];
-
-	FUNCTION_FUNCTOR::AppendResult(result, lambda_vector, elem_cnt, result_entries, list_filter_info, execute_info);
-
-	if (info.is_all_constant && !info.is_volatile) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-unique_ptr<FunctionData> LambdaFunctions::ListLambdaPrepareBind(vector<unique_ptr<Expression>> &arguments,
-                                                                ClientContext &context,
-                                                                ScalarFunction &bound_function) {
-	// NULL list parameter
-	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.arguments[0] = LogicalType::SQLNULL;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<ListLambdaBindData>(bound_function.return_type, nullptr);
-	}
-	// prepared statements
-	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-	D_ASSERT(arguments[0]->return_type.id() == LogicalTypeId::LIST);
-	return nullptr;
-}
-
-unique_ptr<FunctionData> LambdaFunctions::ListLambdaBind(ClientContext &context, ScalarFunction &bound_function,
-                                                         vector<unique_ptr<Expression>> &arguments,
-                                                         const bool has_index) {
-	unique_ptr<FunctionData> bind_data = ListLambdaPrepareBind(arguments, context, bound_function);
-	if (bind_data) {
-		return bind_data;
-	}
-
-	// get the lambda expression and put it in the bind info
-	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
-	auto lambda_expr = std::move(bound_lambda_expr.lambda_expr);
-
-	return make_uniq<ListLambdaBindData>(bound_function.return_type, std::move(lambda_expr), has_index);
-}
-
-void LambdaFunctions::ListTransformFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	ExecuteLambda<ListTransformFunctor>(args, state, result);
-}
-
-void LambdaFunctions::ListFilterFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	ExecuteLambda<ListFilterFunctor>(args, state, result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp b/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp
deleted file mode 100644
index af7d0ee03..000000000
--- a/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp
+++ /dev/null
@@ -1,280 +0,0 @@
-#include "core_functions/scalar/array_functions.hpp"
-#include "core_functions/array_kernels.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> ArrayGenericBinaryBind(ClientContext &context, ScalarFunction &bound_function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-
-	const auto lhs_is_param = arguments[0]->HasParameter();
-	const auto rhs_is_param = arguments[1]->HasParameter();
-
-	if (lhs_is_param && rhs_is_param) {
-		throw ParameterNotResolvedException();
-	}
-
-	const auto &lhs_type = arguments[0]->return_type;
-	const auto &rhs_type = arguments[1]->return_type;
-
-	bound_function.arguments[0] = lhs_is_param ? rhs_type : lhs_type;
-	bound_function.arguments[1] = rhs_is_param ? lhs_type : rhs_type;
-
-	if (bound_function.arguments[0].id() != LogicalTypeId::ARRAY ||
-	    bound_function.arguments[1].id() != LogicalTypeId::ARRAY) {
-		throw InvalidInputException(
-		    StringUtil::Format("%s: Arguments must be arrays of FLOAT or DOUBLE", bound_function.name));
-	}
-
-	const auto lhs_size = ArrayType::GetSize(bound_function.arguments[0]);
-	const auto rhs_size = ArrayType::GetSize(bound_function.arguments[1]);
-
-	if (lhs_size != rhs_size) {
-		throw BinderException("%s: Array arguments must be of the same size", bound_function.name);
-	}
-
-	const auto &lhs_element_type = ArrayType::GetChildType(bound_function.arguments[0]);
-	const auto &rhs_element_type = ArrayType::GetChildType(bound_function.arguments[1]);
-
-	// Resolve common type
-	LogicalType common_type;
-	if (!LogicalType::TryGetMaxLogicalType(context, lhs_element_type, rhs_element_type, common_type)) {
-		throw BinderException("%s: Cannot infer common element type (left = '%s', right = '%s')", bound_function.name,
-		                      lhs_element_type.ToString(), rhs_element_type.ToString());
-	}
-
-	// Ensure it is float or double
-	if (common_type.id() != LogicalTypeId::FLOAT && common_type.id() != LogicalTypeId::DOUBLE) {
-		throw BinderException("%s: Arguments must be arrays of FLOAT or DOUBLE", bound_function.name);
-	}
-
-	// The important part is just that we resolve the size of the input arrays
-	bound_function.arguments[0] = LogicalType::ARRAY(common_type, lhs_size);
-	bound_function.arguments[1] = LogicalType::ARRAY(common_type, rhs_size);
-
-	return nullptr;
-}
-
-//------------------------------------------------------------------------------
-// Element-wise combine functions
-//------------------------------------------------------------------------------
-// Given two arrays of the same size, combine their elements into a single array
-// of the same size as the input arrays.
-
-struct CrossProductOp {
-	template <class TYPE>
-	static void Operation(const TYPE *lhs_data, const TYPE *rhs_data, TYPE *res_data, idx_t size) {
-		D_ASSERT(size == 3);
-
-		auto lx = lhs_data[0];
-		auto ly = lhs_data[1];
-		auto lz = lhs_data[2];
-
-		auto rx = rhs_data[0];
-		auto ry = rhs_data[1];
-		auto rz = rhs_data[2];
-
-		res_data[0] = ly * rz - lz * ry;
-		res_data[1] = lz * rx - lx * rz;
-		res_data[2] = lx * ry - ly * rx;
-	}
-};
-
-template <class TYPE, class OP, idx_t N>
-static void ArrayFixedCombine(DataChunk &args, ExpressionState &state, Vector &result) {
-	const auto &lstate = state.Cast<ExecuteFunctionState>();
-	const auto &expr = lstate.expr.Cast<BoundFunctionExpression>();
-	const auto &func_name = expr.function.name;
-
-	const auto count = args.size();
-	auto &lhs_child = ArrayVector::GetEntry(args.data[0]);
-	auto &rhs_child = ArrayVector::GetEntry(args.data[1]);
-	auto &res_child = ArrayVector::GetEntry(result);
-
-	const auto &lhs_child_validity = FlatVector::Validity(lhs_child);
-	const auto &rhs_child_validity = FlatVector::Validity(rhs_child);
-
-	UnifiedVectorFormat lhs_format;
-	UnifiedVectorFormat rhs_format;
-
-	args.data[0].ToUnifiedFormat(count, lhs_format);
-	args.data[1].ToUnifiedFormat(count, rhs_format);
-
-	auto lhs_data = FlatVector::GetData<TYPE>(lhs_child);
-	auto rhs_data = FlatVector::GetData<TYPE>(rhs_child);
-	auto res_data = FlatVector::GetData<TYPE>(res_child);
-
-	for (idx_t i = 0; i < count; i++) {
-		const auto lhs_idx = lhs_format.sel->get_index(i);
-		const auto rhs_idx = rhs_format.sel->get_index(i);
-
-		if (!lhs_format.validity.RowIsValid(lhs_idx) || !rhs_format.validity.RowIsValid(rhs_idx)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-
-		const auto left_offset = lhs_idx * N;
-		if (!lhs_child_validity.CheckAllValid(left_offset + N, left_offset)) {
-			throw InvalidInputException(StringUtil::Format("%s: left argument can not contain NULL values", func_name));
-		}
-
-		const auto right_offset = rhs_idx * N;
-		if (!rhs_child_validity.CheckAllValid(right_offset + N, right_offset)) {
-			throw InvalidInputException(
-			    StringUtil::Format("%s: right argument can not contain NULL values", func_name));
-		}
-		const auto result_offset = i * N;
-
-		const auto lhs_data_ptr = lhs_data + left_offset;
-		const auto rhs_data_ptr = rhs_data + right_offset;
-		const auto res_data_ptr = res_data + result_offset;
-
-		OP::Operation(lhs_data_ptr, rhs_data_ptr, res_data_ptr, N);
-	}
-
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-//------------------------------------------------------------------------------
-// Generic "fold" function
-//------------------------------------------------------------------------------
-// Given two arrays, combine and reduce their elements into a single scalar value.
-
-template <class TYPE, class OP>
-static void ArrayGenericFold(DataChunk &args, ExpressionState &state, Vector &result) {
-	const auto &lstate = state.Cast<ExecuteFunctionState>();
-	const auto &expr = lstate.expr.Cast<BoundFunctionExpression>();
-	const auto &func_name = expr.function.name;
-
-	const auto count = args.size();
-	auto &lhs_child = ArrayVector::GetEntry(args.data[0]);
-	auto &rhs_child = ArrayVector::GetEntry(args.data[1]);
-
-	const auto &lhs_child_validity = FlatVector::Validity(lhs_child);
-	const auto &rhs_child_validity = FlatVector::Validity(rhs_child);
-
-	UnifiedVectorFormat lhs_format;
-	UnifiedVectorFormat rhs_format;
-
-	args.data[0].ToUnifiedFormat(count, lhs_format);
-	args.data[1].ToUnifiedFormat(count, rhs_format);
-
-	auto lhs_data = FlatVector::GetData<TYPE>(lhs_child);
-	auto rhs_data = FlatVector::GetData<TYPE>(rhs_child);
-	auto res_data = FlatVector::GetData<TYPE>(result);
-
-	const auto array_size = ArrayType::GetSize(args.data[0].GetType());
-	D_ASSERT(array_size == ArrayType::GetSize(args.data[1].GetType()));
-
-	for (idx_t i = 0; i < count; i++) {
-		const auto lhs_idx = lhs_format.sel->get_index(i);
-		const auto rhs_idx = rhs_format.sel->get_index(i);
-
-		if (!lhs_format.validity.RowIsValid(lhs_idx) || !rhs_format.validity.RowIsValid(rhs_idx)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-
-		const auto left_offset = lhs_idx * array_size;
-		if (!lhs_child_validity.CheckAllValid(left_offset + array_size, left_offset)) {
-			throw InvalidInputException(StringUtil::Format("%s: left argument can not contain NULL values", func_name));
-		}
-
-		const auto right_offset = rhs_idx * array_size;
-		if (!rhs_child_validity.CheckAllValid(right_offset + array_size, right_offset)) {
-			throw InvalidInputException(
-			    StringUtil::Format("%s: right argument can not contain NULL values", func_name));
-		}
-
-		const auto lhs_data_ptr = lhs_data + left_offset;
-		const auto rhs_data_ptr = rhs_data + right_offset;
-
-		res_data[i] = OP::Operation(lhs_data_ptr, rhs_data_ptr, array_size);
-	}
-
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-//------------------------------------------------------------------------------
-// Function Registration
-//------------------------------------------------------------------------------
-// Note: In the future we could add a wrapper with a non-type template parameter to specialize for specific array sizes
-// e.g. 256, 512, 1024, 2048 etc. which may allow the compiler to vectorize the loop better. Perhaps something for an
-// extension.
-
-template <class OP>
-static void AddArrayFoldFunction(ScalarFunctionSet &set, const LogicalType &type) {
-	const auto array = LogicalType::ARRAY(type, optional_idx());
-	if (type.id() == LogicalTypeId::FLOAT) {
-		ScalarFunction function({array, array}, type, ArrayGenericFold<float, OP>, ArrayGenericBinaryBind);
-		BaseScalarFunction::SetReturnsError(function);
-		set.AddFunction(function);
-	} else if (type.id() == LogicalTypeId::DOUBLE) {
-		ScalarFunction function({array, array}, type, ArrayGenericFold<double, OP>, ArrayGenericBinaryBind);
-		BaseScalarFunction::SetReturnsError(function);
-		set.AddFunction(function);
-	} else {
-		throw NotImplementedException("Array function not implemented for type %s", type.ToString());
-	}
-}
-
-ScalarFunctionSet ArrayDistanceFun::GetFunctions() {
-	ScalarFunctionSet set("array_distance");
-	for (auto &type : LogicalType::Real()) {
-		AddArrayFoldFunction<DistanceOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ArrayInnerProductFun::GetFunctions() {
-	ScalarFunctionSet set("array_inner_product");
-	for (auto &type : LogicalType::Real()) {
-		AddArrayFoldFunction<InnerProductOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ArrayNegativeInnerProductFun::GetFunctions() {
-	ScalarFunctionSet set("array_negative_inner_product");
-	for (auto &type : LogicalType::Real()) {
-		AddArrayFoldFunction<NegativeInnerProductOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ArrayCosineSimilarityFun::GetFunctions() {
-	ScalarFunctionSet set("array_cosine_similarity");
-	for (auto &type : LogicalType::Real()) {
-		AddArrayFoldFunction<CosineSimilarityOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ArrayCosineDistanceFun::GetFunctions() {
-	ScalarFunctionSet set("array_cosine_distance");
-	for (auto &type : LogicalType::Real()) {
-		AddArrayFoldFunction<CosineDistanceOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ArrayCrossProductFun::GetFunctions() {
-	ScalarFunctionSet set("array_cross_product");
-
-	auto float_array = LogicalType::ARRAY(LogicalType::FLOAT, 3);
-	auto double_array = LogicalType::ARRAY(LogicalType::DOUBLE, 3);
-	set.AddFunction(
-	    ScalarFunction({float_array, float_array}, float_array, ArrayFixedCombine<float, CrossProductOp, 3>));
-	set.AddFunction(
-	    ScalarFunction({double_array, double_array}, double_array, ArrayFixedCombine<double, CrossProductOp, 3>));
-	for (auto &func : set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/array/array_value.cpp b/src/duckdb/extension/core_functions/scalar/array/array_value.cpp
deleted file mode 100644
index e7f715f75..000000000
--- a/src/duckdb/extension/core_functions/scalar/array/array_value.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "core_functions/scalar/array_functions.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/storage/statistics/array_stats.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-static void ArrayValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto array_type = result.GetType();
-
-	D_ASSERT(array_type.id() == LogicalTypeId::ARRAY);
-	D_ASSERT(args.ColumnCount() == ArrayType::GetSize(array_type));
-
-	auto &child_type = ArrayType::GetChildType(array_type);
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-
-	auto num_rows = args.size();
-	auto num_columns = args.ColumnCount();
-
-	auto &child = ArrayVector::GetEntry(result);
-
-	if (num_columns > 1) {
-		// Ensure that the child has a validity mask of the correct size
-		// The SetValue call below expects the validity mask to be initialized
-		auto &child_validity = FlatVector::Validity(child);
-		child_validity.Resize(num_rows * num_columns);
-	}
-
-	for (idx_t i = 0; i < num_rows; i++) {
-		for (idx_t j = 0; j < num_columns; j++) {
-			auto val = args.GetValue(j, i).DefaultCastAs(child_type);
-			child.SetValue((i * num_columns) + j, val);
-		}
-	}
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> ArrayValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.empty()) {
-		throw InvalidInputException("array_value requires at least one argument");
-	}
-
-	// construct return type
-	LogicalType child_type = arguments[0]->return_type;
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		child_type = LogicalType::MaxLogicalType(context, child_type, arguments[i]->return_type);
-	}
-
-	if (arguments.size() > ArrayType::MAX_ARRAY_SIZE) {
-		throw OutOfRangeException("Array size exceeds maximum allowed size");
-	}
-
-	// this is more for completeness reasons
-	bound_function.varargs = child_type;
-	bound_function.return_type = LogicalType::ARRAY(child_type, arguments.size());
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> ArrayValueStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	auto list_stats = ArrayStats::CreateEmpty(expr.return_type);
-	auto &list_child_stats = ArrayStats::GetChildStats(list_stats);
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		list_child_stats.Merge(child_stats[i]);
-	}
-	return list_stats.ToUnique();
-}
-
-ScalarFunction ArrayValueFun::GetFunction() {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("array_value", {}, LogicalTypeId::ARRAY, ArrayValueFunction, ArrayValueBind, nullptr,
-	                   ArrayValueStats);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp b/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp
deleted file mode 100644
index 0dbcb8ebc..000000000
--- a/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#include "core_functions/scalar/bit_functions.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// BitStringFunction
-//===--------------------------------------------------------------------===//
-template <bool FROM_STRING>
-static void BitStringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, int32_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t n) {
-		    if (n < 0) {
-			    throw InvalidInputException("The bitstring length cannot be negative");
-		    }
-		    idx_t input_length;
-		    if (FROM_STRING) {
-			    input_length = input.GetSize();
-		    } else {
-			    input_length = Bit::BitLength(input);
-		    }
-		    if (idx_t(n) < input_length) {
-			    throw InvalidInputException("Length must be equal or larger than input string");
-		    }
-		    idx_t len;
-		    if (FROM_STRING) {
-			    Bit::TryGetBitStringSize(input, len, nullptr); // string verification
-		    }
-
-		    len = Bit::ComputeBitstringLen(UnsafeNumericCast<idx_t>(n));
-		    string_t target = StringVector::EmptyString(result, len);
-		    if (FROM_STRING) {
-			    Bit::BitString(input, UnsafeNumericCast<idx_t>(n), target);
-		    } else {
-			    Bit::ExtendBitString(input, UnsafeNumericCast<idx_t>(n), target);
-		    }
-		    target.Finalize();
-		    return target;
-	    });
-}
-
-ScalarFunctionSet BitStringFun::GetFunctions() {
-	ScalarFunctionSet bitstring;
-	bitstring.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction<true>));
-	bitstring.AddFunction(
-	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction<false>));
-	for (auto &func : bitstring.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return bitstring;
-}
-
-//===--------------------------------------------------------------------===//
-// get_bit
-//===--------------------------------------------------------------------===//
-struct GetBitOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB n) {
-		if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
-			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
-			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
-		}
-		return UnsafeNumericCast<TR>(Bit::GetBit(input, UnsafeNumericCast<idx_t>(n)));
-	}
-};
-
-ScalarFunction GetBitFun::GetFunction() {
-	ScalarFunction func({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
-	                    ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
-	BaseScalarFunction::SetReturnsError(func);
-	return func;
-}
-
-//===--------------------------------------------------------------------===//
-// set_bit
-//===--------------------------------------------------------------------===//
-static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
-	    args.data[0], args.data[1], args.data[2], result, args.size(),
-	    [&](string_t input, int32_t n, int32_t new_value) {
-		    if (new_value != 0 && new_value != 1) {
-			    throw InvalidInputException("The new bit must be 1 or 0");
-		    }
-		    if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
-			    throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
-			                              NumericHelper::ToString(Bit::BitLength(input) - 1));
-		    }
-		    string_t target = StringVector::EmptyString(result, input.GetSize());
-		    memcpy(target.GetDataWriteable(), input.GetData(), input.GetSize());
-		    Bit::SetBit(target, UnsafeNumericCast<idx_t>(n), UnsafeNumericCast<idx_t>(new_value));
-		    return target;
-	    });
-}
-
-ScalarFunction SetBitFun::GetFunction() {
-	ScalarFunction function({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT,
-	                        SetBitOperation);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// bit_position
-//===--------------------------------------------------------------------===//
-struct BitPositionOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA substring, TB input) {
-		if (substring.GetSize() > input.GetSize()) {
-			return 0;
-		}
-		return UnsafeNumericCast<TR>(Bit::BitPosition(substring, input));
-	}
-};
-
-ScalarFunction BitPositionFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::INTEGER,
-	                      ScalarFunction::BinaryFunction<string_t, string_t, int32_t, BitPositionOperator>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/blob/base64.cpp b/src/duckdb/extension/core_functions/scalar/blob/base64.cpp
deleted file mode 100644
index fb903fa80..000000000
--- a/src/duckdb/extension/core_functions/scalar/blob/base64.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "core_functions/scalar/blob_functions.hpp"
-#include "duckdb/common/types/blob.hpp"
-
-namespace duckdb {
-
-struct Base64EncodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto result_str = StringVector::EmptyString(result, Blob::ToBase64Size(input));
-		Blob::ToBase64(input, result_str.GetDataWriteable());
-		result_str.Finalize();
-		return result_str;
-	}
-};
-
-struct Base64DecodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto result_size = Blob::FromBase64Size(input);
-		auto result_blob = StringVector::EmptyString(result, result_size);
-		Blob::FromBase64(input, data_ptr_cast(result_blob.GetDataWriteable()), result_size);
-		result_blob.Finalize();
-		return result_blob;
-	}
-};
-
-static void Base64EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// decode is also a nop cast, but requires verification if the provided string is actually
-	UnaryExecutor::ExecuteString<string_t, string_t, Base64EncodeOperator>(args.data[0], result, args.size());
-}
-
-static void Base64DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// decode is also a nop cast, but requires verification if the provided string is actually
-	UnaryExecutor::ExecuteString<string_t, string_t, Base64DecodeOperator>(args.data[0], result, args.size());
-}
-
-ScalarFunction ToBase64Fun::GetFunction() {
-	return ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, Base64EncodeFunction);
-}
-
-ScalarFunction FromBase64Fun::GetFunction() {
-	ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/blob/encode.cpp b/src/duckdb/extension/core_functions/scalar/blob/encode.cpp
deleted file mode 100644
index 66cedb0b5..000000000
--- a/src/duckdb/extension/core_functions/scalar/blob/encode.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "core_functions/scalar/blob_functions.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-
-namespace duckdb {
-
-static void EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// encode is essentially a nop cast from varchar to blob
-	// we only need to reinterpret the data using the blob type
-	result.Reinterpret(args.data[0]);
-}
-
-struct BlobDecodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		auto input_data = input.GetData();
-		auto input_length = input.GetSize();
-		if (Utf8Proc::Analyze(input_data, input_length) == UnicodeType::INVALID) {
-			throw ConversionException(
-			    "Failure in decode: could not convert blob to UTF8 string, the blob contained invalid UTF8 characters");
-		}
-		return input;
-	}
-};
-
-static void DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// decode is also a nop cast, but requires verification if the provided string is actually
-	UnaryExecutor::Execute<string_t, string_t, BlobDecodeOperator>(args.data[0], result, args.size());
-	StringVector::AddHeapReference(result, args.data[0]);
-}
-
-ScalarFunction EncodeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, EncodeFunction);
-}
-
-ScalarFunction DecodeFun::GetFunction() {
-	ScalarFunction function({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/age.cpp b/src/duckdb/extension/core_functions/scalar/date/age.cpp
deleted file mode 100644
index cf7281f08..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/age.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-
-namespace duckdb {
-
-static void AgeFunctionStandard(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-	//	Subtract argument from current_date (at midnight)
-	//	Theoretically, this should be TZ-sensitive, but since we have to be able to handle
-	//	plain TZ when ICU is not loaded, we implement this in UTC (like everything else)
-	//	To get the PG behaviour, we overload these functions in ICU for TSTZ arguments.
-	auto current_date = Timestamp::FromDatetime(
-	    Timestamp::GetDate(MetaTransaction::Get(state.GetContext()).start_timestamp), dtime_t(0));
-
-	UnaryExecutor::ExecuteWithNulls<timestamp_t, interval_t>(input.data[0], result, input.size(),
-	                                                         [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
-		                                                         if (Timestamp::IsFinite(input)) {
-			                                                         return Interval::GetAge(current_date, input);
-		                                                         } else {
-			                                                         mask.SetInvalid(idx);
-			                                                         return interval_t();
-		                                                         }
-	                                                         });
-}
-
-static void AgeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 2);
-
-	BinaryExecutor::ExecuteWithNulls<timestamp_t, timestamp_t, interval_t>(
-	    input.data[0], input.data[1], result, input.size(),
-	    [&](timestamp_t input1, timestamp_t input2, ValidityMask &mask, idx_t idx) {
-		    if (Timestamp::IsFinite(input1) && Timestamp::IsFinite(input2)) {
-			    return Interval::GetAge(input1, input2);
-		    } else {
-			    mask.SetInvalid(idx);
-			    return interval_t();
-		    }
-	    });
-}
-
-ScalarFunctionSet AgeFun::GetFunctions() {
-	ScalarFunctionSet age("age");
-	age.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::INTERVAL, AgeFunctionStandard));
-	age.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP}, LogicalType::INTERVAL, AgeFunction));
-	return age;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/current.cpp b/src/duckdb/extension/core_functions/scalar/date/current.cpp
deleted file mode 100644
index 3d25ee80a..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/current.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-
-namespace duckdb {
-
-static timestamp_t GetTransactionTimestamp(ExpressionState &state) {
-	return MetaTransaction::Get(state.GetContext()).start_timestamp;
-}
-
-static void CurrentTimestampFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 0);
-	auto ts = GetTransactionTimestamp(state);
-	auto val = Value::TIMESTAMPTZ(timestamp_tz_t(ts));
-	result.Reference(val);
-}
-
-ScalarFunction GetCurrentTimestampFun::GetFunction() {
-	ScalarFunction current_timestamp({}, LogicalType::TIMESTAMP_TZ, CurrentTimestampFunction);
-	current_timestamp.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return current_timestamp;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/date_diff.cpp b/src/duckdb/extension/core_functions/scalar/date/date_diff.cpp
deleted file mode 100644
index c0e4ba1da..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/date_diff.cpp
+++ /dev/null
@@ -1,454 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-// This function is an implementation of the "period-crossing" date difference function from T-SQL
-// https://docs.microsoft.com/en-us/sql/t-sql/functions/datediff-transact-sql?view=sql-server-ver15
-struct DateDiff {
-	template <class TA, class TB, class TR, class OP>
-	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		BinaryExecutor::ExecuteWithNulls<TA, TB, TR>(
-		    left, right, result, count, [&](TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-			    if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-				    return OP::template Operation<TA, TB, TR>(startdate, enddate);
-			    } else {
-				    mask.SetInvalid(idx);
-				    return TR();
-			    }
-		    });
-	}
-
-	//	We need to truncate down, not towards 0
-	static inline int64_t Truncate(int64_t value, int64_t units) {
-		return (value + (value < 0)) / units - (value < 0);
-	}
-	static inline int64_t Diff(int64_t start, int64_t end, int64_t units) {
-		return Truncate(end, units) - Truncate(start, units);
-	}
-
-	struct YearOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) - Date::ExtractYear(startdate);
-		}
-	};
-
-	struct MonthOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			int32_t start_year, start_month, start_day;
-			Date::Convert(startdate, start_year, start_month, start_day);
-			int32_t end_year, end_month, end_day;
-			Date::Convert(enddate, end_year, end_month, end_day);
-
-			return (end_year * 12 + end_month - 1) - (start_year * 12 + start_month - 1);
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return TR(Date::EpochDays(enddate)) - TR(Date::EpochDays(startdate));
-		}
-	};
-
-	struct DecadeOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) / 10 - Date::ExtractYear(startdate) / 10;
-		}
-	};
-
-	struct CenturyOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) / 100 - Date::ExtractYear(startdate) / 100;
-		}
-	};
-
-	struct MilleniumOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) / 1000 - Date::ExtractYear(startdate) / 1000;
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			int32_t start_year, start_month, start_day;
-			Date::Convert(startdate, start_year, start_month, start_day);
-			int32_t end_year, end_month, end_day;
-			Date::Convert(enddate, end_year, end_month, end_day);
-
-			return (end_year * 12 + end_month - 1) / Interval::MONTHS_PER_QUARTER -
-			       (start_year * 12 + start_month - 1) / Interval::MONTHS_PER_QUARTER;
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			//	Weeks do not count Monday crossings, just distance
-			return (enddate.days - startdate.days) / Interval::DAYS_PER_WEEK;
-		}
-	};
-
-	struct ISOYearOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractISOYearNumber(enddate) - Date::ExtractISOYearNumber(startdate);
-		}
-	};
-
-	struct MicrosecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochMicroseconds(enddate) - Date::EpochMicroseconds(startdate);
-		}
-	};
-
-	struct MillisecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochMicroseconds(enddate) / Interval::MICROS_PER_MSEC -
-			       Date::EpochMicroseconds(startdate) / Interval::MICROS_PER_MSEC;
-		}
-	};
-
-	struct SecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) - Date::Epoch(startdate);
-		}
-	};
-
-	struct MinutesOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) / Interval::SECS_PER_MINUTE -
-			       Date::Epoch(startdate) / Interval::SECS_PER_MINUTE;
-		}
-	};
-
-	struct HoursOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) / Interval::SECS_PER_HOUR - Date::Epoch(startdate) / Interval::SECS_PER_HOUR;
-		}
-	};
-};
-
-// TIMESTAMP specialisations
-template <>
-int64_t DateDiff::YearOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return YearOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::MonthOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return MonthOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                         Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::DayOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return DayOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::DecadeOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return DecadeOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                          Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::CenturyOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return CenturyOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                           Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::MilleniumOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return MilleniumOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                             Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::QuarterOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return QuarterOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                           Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::WeekOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return WeekOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::ISOYearOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return ISOYearOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                           Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::MicrosecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	const auto start = Timestamp::GetEpochMicroSeconds(startdate);
-	const auto end = Timestamp::GetEpochMicroSeconds(enddate);
-	return SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(end, start);
-}
-
-template <>
-int64_t DateDiff::MillisecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	D_ASSERT(Timestamp::IsFinite(startdate));
-	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_MSEC);
-}
-
-template <>
-int64_t DateDiff::SecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	D_ASSERT(Timestamp::IsFinite(startdate));
-	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_SEC);
-}
-
-template <>
-int64_t DateDiff::MinutesOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	D_ASSERT(Timestamp::IsFinite(startdate));
-	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_MINUTE);
-}
-
-template <>
-int64_t DateDiff::HoursOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	D_ASSERT(Timestamp::IsFinite(startdate));
-	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_HOUR);
-}
-
-// TIME specialisations
-template <>
-int64_t DateDiff::YearOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"year\" not recognized");
-}
-
-template <>
-int64_t DateDiff::MonthOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"month\" not recognized");
-}
-
-template <>
-int64_t DateDiff::DayOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"day\" not recognized");
-}
-
-template <>
-int64_t DateDiff::DecadeOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"decade\" not recognized");
-}
-
-template <>
-int64_t DateDiff::CenturyOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"century\" not recognized");
-}
-
-template <>
-int64_t DateDiff::MilleniumOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
-}
-
-template <>
-int64_t DateDiff::QuarterOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
-}
-
-template <>
-int64_t DateDiff::WeekOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"week\" not recognized");
-}
-
-template <>
-int64_t DateDiff::ISOYearOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
-}
-
-template <>
-int64_t DateDiff::MicrosecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros - startdate.micros;
-}
-
-template <>
-int64_t DateDiff::MillisecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_MSEC - startdate.micros / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DateDiff::SecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_SEC - startdate.micros / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DateDiff::MinutesOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_MINUTE - startdate.micros / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DateDiff::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_HOUR - startdate.micros / Interval::MICROS_PER_HOUR;
-}
-
-template <typename TA, typename TB, typename TR>
-static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-		return DateDiff::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MONTH:
-		return DateDiff::MonthOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		return DateDiff::DayOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DECADE:
-		return DateDiff::DecadeOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::CENTURY:
-		return DateDiff::CenturyOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLENNIUM:
-		return DateDiff::MilleniumOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::QUARTER:
-		return DateDiff::QuarterOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return DateDiff::WeekOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::ISOYEAR:
-		return DateDiff::ISOYearOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MICROSECONDS:
-		return DateDiff::MicrosecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLISECONDS:
-		return DateDiff::MillisecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return DateDiff::SecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MINUTE:
-		return DateDiff::MinutesOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::HOUR:
-		return DateDiff::HoursOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATEDIFF");
-	}
-}
-
-struct DateDiffTernaryOperator {
-	template <typename TS, typename TA, typename TB, typename TR>
-	static inline TR Operation(TS part, TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-		if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-			return DifferenceDates<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
-		} else {
-			mask.SetInvalid(idx);
-			return TR();
-		}
-	}
-};
-
-template <typename TA, typename TB, typename TR>
-static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::YearOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MONTH:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MonthOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DayOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DECADE:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DecadeOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::CENTURY:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::CenturyOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLENNIUM:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MilleniumOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::QUARTER:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::QuarterOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::WeekOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::ISOYEAR:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::ISOYearOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MicrosecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MillisecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::SecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MINUTE:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MinutesOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::HOUR:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::HoursOperator>(left, right, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATEDIFF");
-	}
-}
-
-template <typename T>
-static void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	auto &part_arg = args.data[0];
-	auto &start_arg = args.data[1];
-	auto &end_arg = args.data[2];
-
-	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Common case of constant part.
-		if (ConstantVector::IsNull(part_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateDiffBinaryExecutor<T, T, int64_t>(type, start_arg, end_arg, result, args.size());
-		}
-	} else {
-		TernaryExecutor::ExecuteWithNulls<string_t, T, T, int64_t>(
-		    part_arg, start_arg, end_arg, result, args.size(),
-		    DateDiffTernaryOperator::Operation<string_t, T, T, int64_t>);
-	}
-}
-
-ScalarFunctionSet DateDiffFun::GetFunctions() {
-	ScalarFunctionSet date_diff("date_diff");
-	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},
-	                                     LogicalType::BIGINT, DateDiffFunction<date_t>));
-	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
-	                                     LogicalType::BIGINT, DateDiffFunction<timestamp_t>));
-	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME, LogicalType::TIME},
-	                                     LogicalType::BIGINT, DateDiffFunction<dtime_t>));
-	return date_diff;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/date_part.cpp b/src/duckdb/extension/core_functions/scalar/date/date_part.cpp
deleted file mode 100644
index 1aeb4550c..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/date_part.cpp
+++ /dev/null
@@ -1,2263 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/date_lookup_cache.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
-	const auto part = GetDatePartSpecifier(specifier);
-	switch (type.id()) {
-	case LogicalType::TIMESTAMP:
-	case LogicalType::TIMESTAMP_TZ:
-		return part;
-	case LogicalType::DATE:
-		switch (part) {
-		case DatePartSpecifier::YEAR:
-		case DatePartSpecifier::MONTH:
-		case DatePartSpecifier::DAY:
-		case DatePartSpecifier::DECADE:
-		case DatePartSpecifier::CENTURY:
-		case DatePartSpecifier::MILLENNIUM:
-		case DatePartSpecifier::DOW:
-		case DatePartSpecifier::ISODOW:
-		case DatePartSpecifier::ISOYEAR:
-		case DatePartSpecifier::WEEK:
-		case DatePartSpecifier::QUARTER:
-		case DatePartSpecifier::DOY:
-		case DatePartSpecifier::YEARWEEK:
-		case DatePartSpecifier::ERA:
-		case DatePartSpecifier::EPOCH:
-		case DatePartSpecifier::JULIAN_DAY:
-			return part;
-		default:
-			break;
-		}
-		break;
-	case LogicalType::TIME:
-	case LogicalType::TIME_TZ:
-		switch (part) {
-		case DatePartSpecifier::MICROSECONDS:
-		case DatePartSpecifier::MILLISECONDS:
-		case DatePartSpecifier::SECOND:
-		case DatePartSpecifier::MINUTE:
-		case DatePartSpecifier::HOUR:
-		case DatePartSpecifier::EPOCH:
-		case DatePartSpecifier::TIMEZONE:
-		case DatePartSpecifier::TIMEZONE_HOUR:
-		case DatePartSpecifier::TIMEZONE_MINUTE:
-			return part;
-		default:
-			break;
-		}
-		break;
-	case LogicalType::INTERVAL:
-		switch (part) {
-		case DatePartSpecifier::YEAR:
-		case DatePartSpecifier::MONTH:
-		case DatePartSpecifier::DAY:
-		case DatePartSpecifier::DECADE:
-		case DatePartSpecifier::CENTURY:
-		case DatePartSpecifier::QUARTER:
-		case DatePartSpecifier::MILLENNIUM:
-		case DatePartSpecifier::MICROSECONDS:
-		case DatePartSpecifier::MILLISECONDS:
-		case DatePartSpecifier::SECOND:
-		case DatePartSpecifier::MINUTE:
-		case DatePartSpecifier::HOUR:
-		case DatePartSpecifier::EPOCH:
-			return part;
-		default:
-			break;
-		}
-		break;
-	default:
-		break;
-	}
-
-	throw NotImplementedException("\"%s\" units \"%s\" not recognized", EnumUtil::ToString(type.id()), specifier);
-}
-
-template <int64_t MIN, int64_t MAX>
-static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseStatistics> &child_stats) {
-	// we can always propagate simple date part statistics
-	// since the min and max can never exceed these bounds
-	auto result = NumericStats::CreateEmpty(LogicalType::BIGINT);
-	result.CopyValidity(child_stats[0]);
-	NumericStats::SetMin(result, Value::BIGINT(MIN));
-	NumericStats::SetMax(result, Value::BIGINT(MAX));
-	return result.ToUnique();
-}
-
-template <class OP>
-struct DateCacheLocalState : public FunctionLocalState {
-	explicit DateCacheLocalState() {
-	}
-
-	DateLookupCache<OP> cache;
-};
-
-template <class OP>
-unique_ptr<FunctionLocalState> InitDateCacheLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                       FunctionData *bind_data) {
-	return make_uniq<DateCacheLocalState<OP>>();
-}
-
-struct DatePart {
-	template <class T, class OP, class TR = int64_t>
-	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats,
-	                                                              const LogicalType &stats_type = LogicalType::BIGINT) {
-		// we can only propagate complex date part stats if the child has stats
-		auto &nstats = child_stats[0];
-		if (!NumericStats::HasMinMax(nstats)) {
-			return nullptr;
-		}
-		// run the operator on both the min and the max, this gives us the [min, max] bound
-		auto min = NumericStats::GetMin<T>(nstats);
-		auto max = NumericStats::GetMax<T>(nstats);
-		if (min > max) {
-			return nullptr;
-		}
-		// Infinities prevent us from computing generic ranges
-		if (!Value::IsFinite(min) || !Value::IsFinite(max)) {
-			return nullptr;
-		}
-		TR min_part = OP::template Operation<T, TR>(min);
-		TR max_part = OP::template Operation<T, TR>(max);
-		auto result = NumericStats::CreateEmpty(stats_type);
-		NumericStats::SetMin(result, Value(min_part));
-		NumericStats::SetMax(result, Value(max_part));
-		result.CopyValidity(child_stats[0]);
-		return result.ToUnique();
-	}
-
-	template <typename OP>
-	struct PartOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input, ValidityMask &mask, idx_t idx, void *dataptr) {
-			if (Value::IsFinite(input)) {
-				return OP::template Operation<TA, TR>(input);
-			} else {
-				mask.SetInvalid(idx);
-				return TR();
-			}
-		}
-	};
-
-	template <class TA, class TR, class OP>
-	static void UnaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() >= 1);
-		using IOP = PartOperator<OP>;
-		UnaryExecutor::GenericExecute<TA, TR, IOP>(input.data[0], result, input.size(), nullptr, true);
-	}
-
-	struct YearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractYear(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, YearOperator>(input.child_stats);
-		}
-	};
-
-	struct MonthOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractMonth(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			// min/max of month operator is [1, 12]
-			return PropagateSimpleDatePartStatistics<1, 12>(input.child_stats);
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractDay(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			// min/max of day operator is [1, 31]
-			return PropagateSimpleDatePartStatistics<1, 31>(input.child_stats);
-		}
-	};
-
-	struct DecadeOperator {
-		// From the PG docs: "The year field divided by 10"
-		template <typename TR>
-		static inline TR DecadeFromYear(TR yyyy) {
-			return yyyy / 10;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return DecadeFromYear(YearOperator::Operation<TA, TR>(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, DecadeOperator>(input.child_stats);
-		}
-	};
-
-	struct CenturyOperator {
-		// From the PG docs:
-		// "The first century starts at 0001-01-01 00:00:00 AD, although they did not know it at the time.
-		// This definition applies to all Gregorian calendar countries.
-		// There is no century number 0, you go from -1 century to 1 century.
-		// If you disagree with this, please write your complaint to: Pope, Cathedral Saint-Peter of Roma, Vatican."
-		// (To be fair, His Holiness had nothing to do with this -
-		// it was the lack of zero in the counting systems of the time...)
-		template <typename TR>
-		static inline TR CenturyFromYear(TR yyyy) {
-			if (yyyy > 0) {
-				return ((yyyy - 1) / 100) + 1;
-			} else {
-				return (yyyy / 100) - 1;
-			}
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return CenturyFromYear(YearOperator::Operation<TA, TR>(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, CenturyOperator>(input.child_stats);
-		}
-	};
-
-	struct MillenniumOperator {
-		// See the century comment
-		template <typename TR>
-		static inline TR MillenniumFromYear(TR yyyy) {
-			if (yyyy > 0) {
-				return ((yyyy - 1) / 1000) + 1;
-			} else {
-				return (yyyy / 1000) - 1;
-			}
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return MillenniumFromYear<TR>(YearOperator::Operation<TA, TR>(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, MillenniumOperator>(input.child_stats);
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TR>
-		static inline TR QuarterFromMonth(TR mm) {
-			return (mm - 1) / Interval::MONTHS_PER_QUARTER + 1;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return QuarterFromMonth(Date::ExtractMonth(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			// min/max of quarter operator is [1, 4]
-			return PropagateSimpleDatePartStatistics<1, 4>(input.child_stats);
-		}
-	};
-
-	struct DayOfWeekOperator {
-		template <class TR>
-		static inline TR DayOfWeekFromISO(TR isodow) {
-			// day of the week (Sunday = 0, Saturday = 6)
-			// turn sunday into 0 by doing mod 7
-			return isodow % 7;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return DayOfWeekFromISO(Date::ExtractISODayOfTheWeek(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 6>(input.child_stats);
-		}
-	};
-
-	struct ISODayOfWeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			// isodow (Monday = 1, Sunday = 7)
-			return Date::ExtractISODayOfTheWeek(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<1, 7>(input.child_stats);
-		}
-	};
-
-	struct DayOfYearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractDayOfTheYear(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<1, 366>(input.child_stats);
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractISOWeekNumber(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<1, 54>(input.child_stats);
-		}
-	};
-
-	struct ISOYearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractISOYearNumber(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, ISOYearOperator>(input.child_stats);
-		}
-	};
-
-	struct YearWeekOperator {
-		template <class TR>
-		static inline TR YearWeekFromParts(TR yyyy, TR ww) {
-			return yyyy * 100 + ((yyyy > 0) ? ww : -ww);
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t yyyy, ww;
-			Date::ExtractISOYearWeek(input, yyyy, ww);
-			return YearWeekFromParts(yyyy, ww);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, YearWeekOperator>(input.child_stats);
-		}
-	};
-
-	struct EpochNanosecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Timestamp::GetEpochNanoSeconds(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochNanosecondsOperator>(input.child_stats);
-		}
-	};
-
-	struct EpochMicrosecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Timestamp::GetEpochMicroSeconds(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochMicrosecondsOperator>(input.child_stats);
-		}
-	};
-
-	struct EpochMillisOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Cast::Operation<TA, TR>(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochMillisOperator>(input.child_stats);
-		}
-
-		static void Inverse(DataChunk &input, ExpressionState &state, Vector &result) {
-			D_ASSERT(input.ColumnCount() == 1);
-
-			UnaryExecutor::Execute<int64_t, timestamp_t>(input.data[0], result, input.size(), [&](int64_t input) {
-				// millisecond amounts provided to epoch_ms should never be considered infinite
-				// instead such values will just throw when converted to microseconds
-				return Timestamp::FromEpochMsPossiblyInfinite(input);
-			});
-		}
-	};
-
-	struct NanosecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return MicrosecondsOperator::Operation<TA, TR>(input) * Interval::NANOS_PER_MICRO;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60000000000>(input.child_stats);
-		}
-	};
-
-	struct MicrosecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60000000>(input.child_stats);
-		}
-	};
-
-	struct MillisecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60000>(input.child_stats);
-		}
-	};
-
-	struct SecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60>(input.child_stats);
-		}
-	};
-
-	struct MinutesOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60>(input.child_stats);
-		}
-	};
-
-	struct HoursOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 24>(input.child_stats);
-		}
-	};
-
-	struct EpochOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return TR(Date::Epoch(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochOperator, double>(input.child_stats, LogicalType::DOUBLE);
-		}
-	};
-
-	struct EraOperator {
-		template <class TR>
-		static inline TR EraFromYear(TR yyyy) {
-			return yyyy > 0 ? 1 : 0;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return EraFromYear(Date::ExtractYear(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 1>(input.child_stats);
-		}
-	};
-
-	struct TimezoneOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			// Regular timestamps are UTC.
-			return 0;
-		}
-
-		template <typename TA, typename TB, typename TR>
-		static TR Operation(TA interval, TB timetz) {
-			auto time = Time::NormalizeTimeTZ(timetz);
-			date_t date(0);
-			time = Interval::Add(time, interval, date);
-			auto offset = UnsafeNumericCast<int32_t>(interval.micros / Interval::MICROS_PER_SEC);
-			return TR(time, offset);
-		}
-
-		template <typename TA, typename TB, typename TR>
-		static void BinaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-			D_ASSERT(input.ColumnCount() == 2);
-			auto &offset = input.data[0];
-			auto &timetz = input.data[1];
-
-			auto func = DatePart::TimezoneOperator::Operation<TA, TB, TR>;
-			BinaryExecutor::Execute<TA, TB, TR>(offset, timetz, result, input.size(), func);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
-		}
-	};
-
-	struct TimezoneHourOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			// Regular timestamps are UTC.
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
-		}
-	};
-
-	struct TimezoneMinuteOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			// Regular timestamps are UTC.
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
-		}
-	};
-
-	struct JulianDayOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Timestamp::GetJulianDay(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, JulianDayOperator, double>(input.child_stats, LogicalType::DOUBLE);
-		}
-	};
-
-	struct StructOperator {
-		using part_codes_t = vector<DatePartSpecifier>;
-		using part_mask_t = uint64_t;
-
-		enum MaskBits : uint8_t {
-			YMD = 1 << 0,
-			DOW = 1 << 1,
-			DOY = 1 << 2,
-			EPOCH = 1 << 3,
-			TIME = 1 << 4,
-			ZONE = 1 << 5,
-			ISO = 1 << 6,
-			JD = 1 << 7
-		};
-
-		static part_mask_t GetMask(const part_codes_t &part_codes) {
-			part_mask_t mask = 0;
-			for (const auto &part_code : part_codes) {
-				switch (part_code) {
-				case DatePartSpecifier::YEAR:
-				case DatePartSpecifier::MONTH:
-				case DatePartSpecifier::DAY:
-				case DatePartSpecifier::DECADE:
-				case DatePartSpecifier::CENTURY:
-				case DatePartSpecifier::MILLENNIUM:
-				case DatePartSpecifier::QUARTER:
-				case DatePartSpecifier::ERA:
-					mask |= YMD;
-					break;
-				case DatePartSpecifier::YEARWEEK:
-				case DatePartSpecifier::WEEK:
-				case DatePartSpecifier::ISOYEAR:
-					mask |= ISO;
-					break;
-				case DatePartSpecifier::DOW:
-				case DatePartSpecifier::ISODOW:
-					mask |= DOW;
-					break;
-				case DatePartSpecifier::DOY:
-					mask |= DOY;
-					break;
-				case DatePartSpecifier::EPOCH:
-					mask |= EPOCH;
-					break;
-				case DatePartSpecifier::JULIAN_DAY:
-					mask |= JD;
-					break;
-				case DatePartSpecifier::MICROSECONDS:
-				case DatePartSpecifier::MILLISECONDS:
-				case DatePartSpecifier::SECOND:
-				case DatePartSpecifier::MINUTE:
-				case DatePartSpecifier::HOUR:
-					mask |= TIME;
-					break;
-				case DatePartSpecifier::TIMEZONE:
-				case DatePartSpecifier::TIMEZONE_HOUR:
-				case DatePartSpecifier::TIMEZONE_MINUTE:
-					mask |= ZONE;
-					break;
-				case DatePartSpecifier::INVALID:
-					throw InternalException("Invalid DatePartSpecifier for STRUCT mask!");
-				}
-			}
-			return mask;
-		}
-
-		template <typename P>
-		static inline P HasPartValue(vector<P> part_values, DatePartSpecifier part) {
-			auto idx = size_t(part);
-			if (IsBigintDatepart(part)) {
-				return part_values[idx - size_t(DatePartSpecifier::BEGIN_BIGINT)];
-			} else {
-				return part_values[idx - size_t(DatePartSpecifier::BEGIN_DOUBLE)];
-			}
-		}
-
-		using bigint_vec = vector<int64_t *>;
-		using double_vec = vector<double *>;
-
-		template <class TA>
-		static inline void Operation(bigint_vec &bigint_values, double_vec &double_values, const TA &input,
-		                             const idx_t idx, const part_mask_t mask) {
-			int64_t *bigint_data;
-			// YMD calculations
-			int32_t yyyy = 1970;
-			int32_t mm = 0;
-			int32_t dd = 1;
-			if (mask & YMD) {
-				Date::Convert(input, yyyy, mm, dd);
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::YEAR);
-				if (bigint_data) {
-					bigint_data[idx] = yyyy;
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::MONTH);
-				if (bigint_data) {
-					bigint_data[idx] = mm;
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DAY);
-				if (bigint_data) {
-					bigint_data[idx] = dd;
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DECADE);
-				if (bigint_data) {
-					bigint_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::CENTURY);
-				if (bigint_data) {
-					bigint_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::MILLENNIUM);
-				if (bigint_data) {
-					bigint_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::QUARTER);
-				if (bigint_data) {
-					bigint_data[idx] = QuarterOperator::QuarterFromMonth(mm);
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ERA);
-				if (bigint_data) {
-					bigint_data[idx] = EraOperator::EraFromYear(yyyy);
-				}
-			}
-
-			// Week calculations
-			if (mask & DOW) {
-				auto isodow = Date::ExtractISODayOfTheWeek(input);
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DOW);
-				if (bigint_data) {
-					bigint_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ISODOW);
-				if (bigint_data) {
-					bigint_data[idx] = isodow;
-				}
-			}
-
-			// ISO calculations
-			if (mask & ISO) {
-				int32_t ww = 0;
-				int32_t iyyy = 0;
-				Date::ExtractISOYearWeek(input, iyyy, ww);
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::WEEK);
-				if (bigint_data) {
-					bigint_data[idx] = ww;
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ISOYEAR);
-				if (bigint_data) {
-					bigint_data[idx] = iyyy;
-				}
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::YEARWEEK);
-				if (bigint_data) {
-					bigint_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
-				}
-			}
-
-			if (mask & EPOCH) {
-				auto double_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
-				if (double_data) {
-					double_data[idx] = double(Date::Epoch(input));
-				}
-			}
-			if (mask & DOY) {
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DOY);
-				if (bigint_data) {
-					bigint_data[idx] = Date::ExtractDayOfTheYear(input);
-				}
-			}
-			if (mask & JD) {
-				auto double_data = HasPartValue(double_values, DatePartSpecifier::JULIAN_DAY);
-				if (double_data) {
-					double_data[idx] = double(Date::ExtractJulianDay(input));
-				}
-			}
-		}
-	};
-};
-
-template <class OP, class T>
-static void DatePartCachedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<DateCacheLocalState<OP>>();
-	UnaryExecutor::ExecuteWithNulls<T, int64_t>(
-	    args.data[0], result, args.size(),
-	    [&](T input, ValidityMask &mask, idx_t idx) { return lstate.cache.ExtractElement(input, mask, idx); });
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(timestamp_t input) {
-	return YearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_YEAR;
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"year\" not recognized");
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(dtime_tz_t input) {
-	return YearOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(timestamp_t input) {
-	return MonthOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(interval_t input) {
-	return input.months % Interval::MONTHS_PER_YEAR;
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"month\" not recognized");
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(dtime_tz_t input) {
-	return MonthOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(timestamp_t input) {
-	return DayOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(interval_t input) {
-	return input.days;
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"day\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(dtime_tz_t input) {
-	return DayOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::DecadeOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_DECADE;
-}
-
-template <>
-int64_t DatePart::DecadeOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"decade\" not recognized");
-}
-
-template <>
-int64_t DatePart::DecadeOperator::Operation(dtime_tz_t input) {
-	return DecadeOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::CenturyOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_CENTURY;
-}
-
-template <>
-int64_t DatePart::CenturyOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"century\" not recognized");
-}
-
-template <>
-int64_t DatePart::CenturyOperator::Operation(dtime_tz_t input) {
-	return CenturyOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::MillenniumOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_MILLENIUM;
-}
-
-template <>
-int64_t DatePart::MillenniumOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
-}
-
-template <>
-int64_t DatePart::MillenniumOperator::Operation(dtime_tz_t input) {
-	return MillenniumOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(timestamp_t input) {
-	return QuarterOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(interval_t input) {
-	return MonthOperator::Operation<interval_t, int64_t>(input) / Interval::MONTHS_PER_QUARTER + 1;
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(dtime_tz_t input) {
-	return QuarterOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(timestamp_t input) {
-	return DayOfWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"dow\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"dow\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(dtime_tz_t input) {
-	return DayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(timestamp_t input) {
-	return ISODayOfWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"isodow\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"isodow\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_tz_t input) {
-	return ISODayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(timestamp_t input) {
-	return DayOfYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"doy\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"doy\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(dtime_tz_t input) {
-	return DayOfYearOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(timestamp_t input) {
-	return WeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"week\" not recognized");
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"week\" not recognized");
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(dtime_tz_t input) {
-	return WeekOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(timestamp_t input) {
-	return ISOYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"isoyear\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(dtime_tz_t input) {
-	return ISOYearOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(timestamp_t input) {
-	return YearWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(interval_t input) {
-	const auto yyyy = YearOperator::Operation<interval_t, int64_t>(input);
-	const auto ww = WeekOperator::Operation<interval_t, int64_t>(input);
-	return YearWeekOperator::YearWeekFromParts<int64_t>(yyyy, ww);
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(dtime_tz_t input) {
-	return YearWeekOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::EpochNanosecondsOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return Timestamp::GetEpochNanoSeconds(input);
-}
-
-template <>
-int64_t DatePart::EpochNanosecondsOperator::Operation(date_t input) {
-	D_ASSERT(Date::IsFinite(input));
-	return Date::EpochNanoseconds(input);
-}
-
-template <>
-int64_t DatePart::EpochNanosecondsOperator::Operation(interval_t input) {
-	return Interval::GetNanoseconds(input);
-}
-
-template <>
-int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_t input) {
-	return input.micros * Interval::NANOS_PER_MICRO;
-}
-
-template <>
-int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_tz_t input) {
-	return DatePart::EpochNanosecondsOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::EpochMicrosecondsOperator::Operation(date_t input) {
-	return Date::EpochMicroseconds(input);
-}
-
-template <>
-int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) {
-	return Interval::GetMicro(input);
-}
-
-template <>
-int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return Cast::Operation<timestamp_t, timestamp_ms_t>(input).value;
-}
-
-template <>
-int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_t input) {
-	return input.micros;
-}
-
-template <>
-int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_tz_t input) {
-	return DatePart::EpochMicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::EpochMillisOperator::Operation(date_t input) {
-	return Date::EpochMilliseconds(input);
-}
-
-template <>
-int64_t DatePart::EpochMillisOperator::Operation(interval_t input) {
-	return Interval::GetMilli(input);
-}
-
-template <>
-int64_t DatePart::EpochMillisOperator::Operation(dtime_t input) {
-	return input.micros / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::EpochMillisOperator::Operation(dtime_tz_t input) {
-	return DatePart::EpochMillisOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::NanosecondsOperator::Operation(timestamp_ns_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		throw ConversionException("Can't get nanoseconds of infinite TIMESTAMP");
-	}
-	date_t date;
-	dtime_t time;
-	int32_t nanos;
-	Timestamp::Convert(input, date, time, nanos);
-	// remove everything but the second & nanosecond part
-	return (time.micros % Interval::MICROS_PER_MINUTE) * Interval::NANOS_PER_MICRO + nanos;
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	auto time = Timestamp::GetTime(input);
-	// remove everything but the second & microsecond part
-	return time.micros % Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(interval_t input) {
-	// remove everything but the second & microsecond part
-	return input.micros % Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(dtime_t input) {
-	// remove everything but the second & microsecond part
-	return input.micros % Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(dtime_tz_t input) {
-	return DatePart::MicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(interval_t input) {
-	return MicrosecondsOperator::Operation<interval_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(dtime_t input) {
-	return MicrosecondsOperator::Operation<dtime_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(dtime_tz_t input) {
-	return DatePart::MillisecondsOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(interval_t input) {
-	return MicrosecondsOperator::Operation<interval_t, int64_t>(input) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(dtime_t input) {
-	return MicrosecondsOperator::Operation<dtime_t, int64_t>(input) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(dtime_tz_t input) {
-	return DatePart::SecondsOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	auto time = Timestamp::GetTime(input);
-	// remove the hour part, and truncate to minutes
-	return (time.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(interval_t input) {
-	// remove the hour part, and truncate to minutes
-	return (input.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(dtime_t input) {
-	// remove the hour part, and truncate to minutes
-	return (input.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(dtime_tz_t input) {
-	return DatePart::MinutesOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return Timestamp::GetTime(input).micros / Interval::MICROS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(interval_t input) {
-	return input.micros / Interval::MICROS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(dtime_t input) {
-	return input.micros / Interval::MICROS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(dtime_tz_t input) {
-	return DatePart::HoursOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-double DatePart::EpochOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return double(Timestamp::GetEpochMicroSeconds(input)) / double(Interval::MICROS_PER_SEC);
-}
-
-template <>
-double DatePart::EpochOperator::Operation(interval_t input) {
-	int64_t interval_years = input.months / Interval::MONTHS_PER_YEAR;
-	int64_t interval_days;
-	interval_days = Interval::DAYS_PER_YEAR * interval_years;
-	interval_days += Interval::DAYS_PER_MONTH * (input.months % Interval::MONTHS_PER_YEAR);
-	interval_days += input.days;
-	int64_t interval_epoch;
-	interval_epoch = interval_days * Interval::SECS_PER_DAY;
-	// we add 0.25 days per year to sort of account for leap days
-	interval_epoch += interval_years * (Interval::SECS_PER_DAY / 4);
-	return double(interval_epoch) + double(input.micros) / double(Interval::MICROS_PER_SEC);
-}
-
-//	TODO: We can't propagate interval statistics because we can't easily compare interval_t for order.
-template <>
-unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<interval_t>(ClientContext &context,
-                                                                                    FunctionStatisticsInput &input) {
-	return nullptr;
-}
-
-template <>
-double DatePart::EpochOperator::Operation(dtime_t input) {
-	return double(input.micros) / double(Interval::MICROS_PER_SEC);
-}
-
-template <>
-double DatePart::EpochOperator::Operation(dtime_tz_t input) {
-	return DatePart::EpochOperator::Operation<dtime_t, double>(input.time());
-}
-
-template <>
-unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context,
-                                                                                 FunctionStatisticsInput &input) {
-	auto result = NumericStats::CreateEmpty(LogicalType::DOUBLE);
-	result.CopyValidity(input.child_stats[0]);
-	NumericStats::SetMin(result, Value::DOUBLE(0));
-	NumericStats::SetMax(result, Value::DOUBLE(Interval::SECS_PER_DAY));
-	return result.ToUnique();
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(timestamp_t input) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	return EraOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"era\" not recognized");
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"era\" not recognized");
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(dtime_tz_t input) {
-	return EraOperator::Operation<dtime_t, int64_t>(input.time());
-}
-
-template <>
-int64_t DatePart::TimezoneOperator::Operation(date_t input) {
-	throw NotImplementedException("\"date\" units \"timezone\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneOperator::Operation(interval_t input) {
-	throw NotImplementedException("\"interval\" units \"timezone\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneOperator::Operation(dtime_tz_t input) {
-	return input.offset();
-}
-
-template <>
-int64_t DatePart::TimezoneHourOperator::Operation(date_t input) {
-	throw NotImplementedException("\"date\" units \"timezone_hour\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneHourOperator::Operation(interval_t input) {
-	throw NotImplementedException("\"interval\" units \"timezone_hour\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneHourOperator::Operation(dtime_tz_t input) {
-	return input.offset() / Interval::SECS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::TimezoneMinuteOperator::Operation(date_t input) {
-	throw NotImplementedException("\"date\" units \"timezone_minute\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneMinuteOperator::Operation(interval_t input) {
-	throw NotImplementedException("\"interval\" units \"timezone_minute\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneMinuteOperator::Operation(dtime_tz_t input) {
-	return (input.offset() / Interval::SECS_PER_MINUTE) % Interval::MINS_PER_HOUR;
-}
-
-template <>
-double DatePart::JulianDayOperator::Operation(date_t input) {
-	return double(Date::ExtractJulianDay(input));
-}
-
-template <>
-double DatePart::JulianDayOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"julian\" not recognized");
-}
-
-template <>
-double DatePart::JulianDayOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"julian\" not recognized");
-}
-
-template <>
-double DatePart::JulianDayOperator::Operation(dtime_tz_t input) {
-	return JulianDayOperator::Operation<dtime_t, double>(input.time());
-}
-
-template <>
-void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const dtime_t &input,
-                                         const idx_t idx, const part_mask_t mask) {
-	int64_t *part_data;
-	if (mask & TIME) {
-		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
-		if (part_data) {
-			part_data[idx] = micros;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
-		if (part_data) {
-			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
-		if (part_data) {
-			part_data[idx] = micros / Interval::MICROS_PER_SEC;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
-		if (part_data) {
-			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
-		if (part_data) {
-			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
-		}
-	}
-
-	if (mask & EPOCH) {
-		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<dtime_t, double>(input);
-		}
-	}
-
-	if (mask & ZONE) {
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE);
-		if (part_data) {
-			part_data[idx] = 0;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_HOUR);
-		if (part_data) {
-			part_data[idx] = 0;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_MINUTE);
-		if (part_data) {
-			part_data[idx] = 0;
-		}
-	}
-}
-
-template <>
-void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const dtime_tz_t &input,
-                                         const idx_t idx, const part_mask_t mask) {
-	int64_t *part_data;
-	if (mask & TIME) {
-		const auto micros = MicrosecondsOperator::Operation<dtime_tz_t, int64_t>(input);
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
-		if (part_data) {
-			part_data[idx] = micros;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
-		if (part_data) {
-			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
-		if (part_data) {
-			part_data[idx] = micros / Interval::MICROS_PER_SEC;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
-		if (part_data) {
-			part_data[idx] = MinutesOperator::Operation<dtime_tz_t, int64_t>(input);
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
-		if (part_data) {
-			part_data[idx] = HoursOperator::Operation<dtime_tz_t, int64_t>(input);
-		}
-	}
-
-	if (mask & EPOCH) {
-		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<dtime_tz_t, double>(input);
-		}
-	}
-
-	if (mask & ZONE) {
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE);
-		if (part_data) {
-			part_data[idx] = TimezoneOperator::Operation<dtime_tz_t, int64_t>(input);
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_HOUR);
-		if (part_data) {
-			part_data[idx] = TimezoneHourOperator::Operation<dtime_tz_t, int64_t>(input);
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_MINUTE);
-		if (part_data) {
-			part_data[idx] = TimezoneMinuteOperator::Operation<dtime_tz_t, int64_t>(input);
-		}
-		return;
-	}
-}
-
-template <>
-void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const timestamp_t &input,
-                                         const idx_t idx, const part_mask_t mask) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	date_t d;
-	dtime_t t;
-	Timestamp::Convert(input, d, t);
-
-	// Both define epoch, and the correct value is the sum.
-	// So mask it out and compute it separately.
-	Operation(bigint_values, double_values, d, idx, mask & ~UnsafeNumericCast<part_mask_t>(EPOCH));
-	Operation(bigint_values, double_values, t, idx, mask & ~UnsafeNumericCast<part_mask_t>(EPOCH));
-
-	if (mask & EPOCH) {
-		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<timestamp_t, double>(input);
-		}
-	}
-
-	if (mask & JD) {
-		auto part_data = HasPartValue(double_values, DatePartSpecifier::JULIAN_DAY);
-		if (part_data) {
-			part_data[idx] = JulianDayOperator::Operation<timestamp_t, double>(input);
-		}
-	}
-}
-
-template <>
-void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const interval_t &input,
-                                         const idx_t idx, const part_mask_t mask) {
-	int64_t *part_data;
-	if (mask & YMD) {
-		const auto mm = input.months % Interval::MONTHS_PER_YEAR;
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::YEAR);
-		if (part_data) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MONTH);
-		if (part_data) {
-			part_data[idx] = mm;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::DAY);
-		if (part_data) {
-			part_data[idx] = input.days;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::DECADE);
-		if (part_data) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::CENTURY);
-		if (part_data) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLENNIUM);
-		if (part_data) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::QUARTER);
-		if (part_data) {
-			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
-		}
-	}
-
-	if (mask & TIME) {
-		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
-		if (part_data) {
-			part_data[idx] = micros;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
-		if (part_data) {
-			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
-		if (part_data) {
-			part_data[idx] = micros / Interval::MICROS_PER_SEC;
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
-		if (part_data) {
-			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
-		if (part_data) {
-			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
-		}
-	}
-
-	if (mask & EPOCH) {
-		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<interval_t, double>(input);
-		}
-	}
-}
-
-template <typename T>
-static int64_t ExtractElement(DatePartSpecifier type, T element) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-		return DatePart::YearOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MONTH:
-		return DatePart::MonthOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DAY:
-		return DatePart::DayOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DECADE:
-		return DatePart::DecadeOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::CENTURY:
-		return DatePart::CenturyOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MILLENNIUM:
-		return DatePart::MillenniumOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::QUARTER:
-		return DatePart::QuarterOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DOW:
-		return DatePart::DayOfWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::ISODOW:
-		return DatePart::ISODayOfWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DOY:
-		return DatePart::DayOfYearOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::WEEK:
-		return DatePart::WeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::ISOYEAR:
-		return DatePart::ISOYearOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::YEARWEEK:
-		return DatePart::YearWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MICROSECONDS:
-		return DatePart::MicrosecondsOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MILLISECONDS:
-		return DatePart::MillisecondsOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::SECOND:
-		return DatePart::SecondsOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MINUTE:
-		return DatePart::MinutesOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::HOUR:
-		return DatePart::HoursOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::ERA:
-		return DatePart::EraOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::TIMEZONE:
-		return DatePart::TimezoneOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::TIMEZONE_HOUR:
-		return DatePart::TimezoneHourOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::TIMEZONE_MINUTE:
-		return DatePart::TimezoneMinuteOperator::template Operation<T, int64_t>(element);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATEPART");
-	}
-}
-
-template <typename T>
-static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto &spec_arg = args.data[0];
-	auto &date_arg = args.data[1];
-
-	BinaryExecutor::ExecuteWithNulls<string_t, T, int64_t>(
-	    spec_arg, date_arg, result, args.size(), [&](string_t specifier, T date, ValidityMask &mask, idx_t idx) {
-		    if (Value::IsFinite(date)) {
-			    return ExtractElement<T>(GetDatePartSpecifier(specifier.GetString()), date);
-		    } else {
-			    mask.SetInvalid(idx);
-			    return int64_t(0);
-		    }
-	    });
-}
-
-static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments) {
-	//	If we are only looking for Julian Days for timestamps,
-	//	then return doubles.
-	if (arguments[0]->HasParameter() || !arguments[0]->IsFoldable()) {
-		return nullptr;
-	}
-
-	Value part_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-	const auto part_name = part_value.ToString();
-	switch (GetDatePartSpecifier(part_name)) {
-	case DatePartSpecifier::JULIAN_DAY:
-		arguments.erase(arguments.begin());
-		bound_function.arguments.erase(bound_function.arguments.begin());
-		bound_function.name = "julian";
-		bound_function.return_type = LogicalType::DOUBLE;
-		switch (arguments[0]->return_type.id()) {
-		case LogicalType::TIMESTAMP:
-		case LogicalType::TIMESTAMP_S:
-		case LogicalType::TIMESTAMP_MS:
-		case LogicalType::TIMESTAMP_NS:
-			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::JulianDayOperator>;
-			bound_function.statistics = DatePart::JulianDayOperator::template PropagateStatistics<timestamp_t>;
-			break;
-		case LogicalType::DATE:
-			bound_function.function = DatePart::UnaryFunction<date_t, double, DatePart::JulianDayOperator>;
-			bound_function.statistics = DatePart::JulianDayOperator::template PropagateStatistics<date_t>;
-			break;
-		default:
-			throw BinderException("%s can only take DATE or TIMESTAMP arguments", bound_function.name);
-		}
-		break;
-	case DatePartSpecifier::EPOCH:
-		arguments.erase(arguments.begin());
-		bound_function.arguments.erase(bound_function.arguments.begin());
-		bound_function.name = "epoch";
-		bound_function.return_type = LogicalType::DOUBLE;
-		switch (arguments[0]->return_type.id()) {
-		case LogicalType::TIMESTAMP:
-		case LogicalType::TIMESTAMP_S:
-		case LogicalType::TIMESTAMP_MS:
-		case LogicalType::TIMESTAMP_NS:
-			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::EpochOperator>;
-			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<timestamp_t>;
-			break;
-		case LogicalType::DATE:
-			bound_function.function = DatePart::UnaryFunction<date_t, double, DatePart::EpochOperator>;
-			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<date_t>;
-			break;
-		case LogicalType::INTERVAL:
-			bound_function.function = DatePart::UnaryFunction<interval_t, double, DatePart::EpochOperator>;
-			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<interval_t>;
-			break;
-		case LogicalType::TIME:
-			bound_function.function = DatePart::UnaryFunction<dtime_t, double, DatePart::EpochOperator>;
-			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_t>;
-			break;
-		case LogicalType::TIME_TZ:
-			bound_function.function = DatePart::UnaryFunction<dtime_tz_t, double, DatePart::EpochOperator>;
-			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_tz_t>;
-			break;
-		default:
-			throw BinderException("%s can only take temporal arguments", bound_function.name);
-		}
-		break;
-	default:
-		break;
-	}
-
-	return nullptr;
-}
-
-template <init_local_state_t DATE_CACHE = nullptr>
-ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
-                                             scalar_function_t interval_func, function_statistics_t date_stats,
-                                             function_statistics_t ts_stats) {
-	ScalarFunctionSet operator_set;
-	operator_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr,
-	                                        nullptr, date_stats, DATE_CACHE));
-	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr,
-	                                        nullptr, ts_stats, DATE_CACHE));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
-	for (auto &func : operator_set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return operator_set;
-}
-
-template <class OP>
-static ScalarFunctionSet GetDatePartFunction() {
-	return GetGenericDatePartFunction(
-	    DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
-	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, OP::template PropagateStatistics<date_t>,
-	    OP::template PropagateStatistics<timestamp_t>);
-}
-
-ScalarFunctionSet GetGenericTimePartFunction(const LogicalType &result_type, scalar_function_t date_func,
-                                             scalar_function_t ts_func, scalar_function_t interval_func,
-                                             scalar_function_t time_func, scalar_function_t timetz_func,
-                                             function_statistics_t date_stats, function_statistics_t ts_stats,
-                                             function_statistics_t time_stats, function_statistics_t timetz_stats) {
-	ScalarFunctionSet operator_set;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, result_type, std::move(date_func), nullptr, nullptr, date_stats));
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, result_type, std::move(ts_func), nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, result_type, std::move(interval_func)));
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIME}, result_type, std::move(time_func), nullptr, nullptr, time_stats));
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIME_TZ}, result_type, std::move(timetz_func), nullptr, nullptr, timetz_stats));
-	return operator_set;
-}
-
-template <class OP, class TR = int64_t>
-static ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = LogicalType::BIGINT) {
-	return GetGenericTimePartFunction(
-	    result_type, DatePart::UnaryFunction<date_t, TR, OP>, DatePart::UnaryFunction<timestamp_t, TR, OP>,
-	    ScalarFunction::UnaryFunction<interval_t, TR, OP>, ScalarFunction::UnaryFunction<dtime_t, TR, OP>,
-	    ScalarFunction::UnaryFunction<dtime_tz_t, TR, OP>, OP::template PropagateStatistics<date_t>,
-	    OP::template PropagateStatistics<timestamp_t>, OP::template PropagateStatistics<dtime_t>,
-	    OP::template PropagateStatistics<dtime_tz_t>);
-}
-
-struct LastDayOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		int32_t yyyy, mm, dd;
-		Date::Convert(input, yyyy, mm, dd);
-		yyyy += (mm / 12);
-		mm %= 12;
-		++mm;
-		return Date::FromDate(yyyy, mm, 1) - 1;
-	}
-};
-
-template <>
-date_t LastDayOperator::Operation(timestamp_t input) {
-	return LastDayOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-struct MonthNameOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Date::MONTH_NAMES[DatePart::MonthOperator::Operation<TA, int64_t>(input) - 1];
-	}
-};
-
-struct DayNameOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Date::DAY_NAMES[DatePart::DayOfWeekOperator::Operation<TA, int64_t>(input)];
-	}
-};
-
-struct StructDatePart {
-	using part_codes_t = vector<DatePartSpecifier>;
-
-	struct BindData : public VariableReturnBindData {
-		part_codes_t part_codes;
-
-		explicit BindData(const LogicalType &stype, const part_codes_t &part_codes_p)
-		    : VariableReturnBindData(stype), part_codes(part_codes_p) {
-		}
-
-		unique_ptr<FunctionData> Copy() const override {
-			return make_uniq<BindData>(stype, part_codes);
-		}
-	};
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		// collect names and deconflict, construct return type
-		if (arguments[0]->HasParameter()) {
-			throw ParameterNotResolvedException();
-		}
-		if (!arguments[0]->IsFoldable()) {
-			throw BinderException("%s can only take constant lists of part names", bound_function.name);
-		}
-
-		case_insensitive_set_t name_collision_set;
-		child_list_t<LogicalType> struct_children;
-		part_codes_t part_codes;
-
-		Value parts_list = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-		if (parts_list.type().id() == LogicalTypeId::LIST) {
-			auto &list_children = ListValue::GetChildren(parts_list);
-			if (list_children.empty()) {
-				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
-			}
-			for (const auto &part_value : list_children) {
-				if (part_value.IsNull()) {
-					throw BinderException("NULL struct entry name in %s", bound_function.name);
-				}
-				const auto part_name = part_value.ToString();
-				const auto part_code = GetDateTypePartSpecifier(part_name, arguments[1]->return_type);
-				if (name_collision_set.find(part_name) != name_collision_set.end()) {
-					throw BinderException("Duplicate struct entry name \"%s\" in %s", part_name, bound_function.name);
-				}
-				name_collision_set.insert(part_name);
-				part_codes.emplace_back(part_code);
-				const auto part_type = IsBigintDatepart(part_code) ? LogicalType::BIGINT : LogicalType::DOUBLE;
-				struct_children.emplace_back(make_pair(part_name, part_type));
-			}
-		} else {
-			throw BinderException("%s can only take constant lists of part names", bound_function.name);
-		}
-
-		Function::EraseArgument(bound_function, arguments, 0);
-		bound_function.return_type = LogicalType::STRUCT(struct_children);
-		return make_uniq<BindData>(bound_function.return_type, part_codes);
-	}
-
-	template <typename INPUT_TYPE>
-	static void Function(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<BindData>();
-		D_ASSERT(args.ColumnCount() == 1);
-
-		const auto count = args.size();
-		Vector &input = args.data[0];
-
-		//	Type counts
-		const auto BIGINT_COUNT = size_t(DatePartSpecifier::BEGIN_DOUBLE) - size_t(DatePartSpecifier::BEGIN_BIGINT);
-		const auto DOUBLE_COUNT = size_t(DatePartSpecifier::BEGIN_INVALID) - size_t(DatePartSpecifier::BEGIN_DOUBLE);
-		DatePart::StructOperator::bigint_vec bigint_values(BIGINT_COUNT, nullptr);
-		DatePart::StructOperator::double_vec double_values(DOUBLE_COUNT, nullptr);
-		const auto part_mask = DatePart::StructOperator::GetMask(info.part_codes);
-
-		auto &child_entries = StructVector::GetEntries(result);
-
-		// The first computer of a part "owns" it
-		// and other requestors just reference the owner
-		vector<size_t> owners(int(DatePartSpecifier::JULIAN_DAY) + 1, child_entries.size());
-		for (size_t col = 0; col < child_entries.size(); ++col) {
-			const auto part_index = size_t(info.part_codes[col]);
-			if (owners[part_index] == child_entries.size()) {
-				owners[part_index] = col;
-			}
-		}
-
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-			if (ConstantVector::IsNull(input)) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				ConstantVector::SetNull(result, false);
-				for (size_t col = 0; col < child_entries.size(); ++col) {
-					auto &child_entry = child_entries[col];
-					ConstantVector::SetNull(*child_entry, false);
-					const auto part_index = size_t(info.part_codes[col]);
-					if (owners[part_index] == col) {
-						if (IsBigintDatepart(info.part_codes[col])) {
-							bigint_values[part_index - size_t(DatePartSpecifier::BEGIN_BIGINT)] =
-							    ConstantVector::GetData<int64_t>(*child_entry);
-						} else {
-							double_values[part_index - size_t(DatePartSpecifier::BEGIN_DOUBLE)] =
-							    ConstantVector::GetData<double>(*child_entry);
-						}
-					}
-				}
-				auto tdata = ConstantVector::GetData<INPUT_TYPE>(input);
-				if (Value::IsFinite(tdata[0])) {
-					DatePart::StructOperator::Operation(bigint_values, double_values, tdata[0], 0, part_mask);
-				} else {
-					for (auto &child_entry : child_entries) {
-						ConstantVector::SetNull(*child_entry, true);
-					}
-				}
-			}
-		} else {
-			UnifiedVectorFormat rdata;
-			input.ToUnifiedFormat(count, rdata);
-
-			const auto &arg_valid = rdata.validity;
-			auto tdata = UnifiedVectorFormat::GetData<INPUT_TYPE>(rdata);
-
-			// Start with a valid flat vector
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto &res_valid = FlatVector::Validity(result);
-			if (res_valid.GetData()) {
-				res_valid.SetAllValid(count);
-			}
-
-			// Start with valid children
-			for (size_t col = 0; col < child_entries.size(); ++col) {
-				auto &child_entry = child_entries[col];
-				child_entry->SetVectorType(VectorType::FLAT_VECTOR);
-				auto &child_validity = FlatVector::Validity(*child_entry);
-				if (child_validity.GetData()) {
-					child_validity.SetAllValid(count);
-				}
-
-				// Pre-multiplex
-				const auto part_index = size_t(info.part_codes[col]);
-				if (owners[part_index] == col) {
-					if (IsBigintDatepart(info.part_codes[col])) {
-						bigint_values[part_index - size_t(DatePartSpecifier::BEGIN_BIGINT)] =
-						    FlatVector::GetData<int64_t>(*child_entry);
-					} else {
-						double_values[part_index - size_t(DatePartSpecifier::BEGIN_DOUBLE)] =
-						    FlatVector::GetData<double>(*child_entry);
-					}
-				}
-			}
-
-			for (idx_t i = 0; i < count; ++i) {
-				const auto idx = rdata.sel->get_index(i);
-				if (arg_valid.RowIsValid(idx)) {
-					if (Value::IsFinite(tdata[idx])) {
-						DatePart::StructOperator::Operation(bigint_values, double_values, tdata[idx], i, part_mask);
-					} else {
-						for (auto &child_entry : child_entries) {
-							FlatVector::Validity(*child_entry).SetInvalid(i);
-						}
-					}
-				} else {
-					res_valid.SetInvalid(i);
-					for (auto &child_entry : child_entries) {
-						FlatVector::Validity(*child_entry).SetInvalid(i);
-					}
-				}
-			}
-		}
-
-		// Reference any duplicate parts
-		for (size_t col = 0; col < child_entries.size(); ++col) {
-			const auto part_index = size_t(info.part_codes[col]);
-			const auto owner = owners[part_index];
-			if (owner != col) {
-				child_entries[col]->Reference(*child_entries[owner]);
-			}
-		}
-
-		result.Verify(count);
-	}
-
-	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                              const ScalarFunction &function) {
-		D_ASSERT(bind_data_p);
-		auto &info = bind_data_p->Cast<BindData>();
-		serializer.WriteProperty(100, "stype", info.stype);
-		serializer.WriteProperty(101, "part_codes", info.part_codes);
-	}
-
-	static unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer, ScalarFunction &bound_function) {
-		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
-		auto part_codes = deserializer.ReadProperty<vector<DatePartSpecifier>>(101, "part_codes");
-		return make_uniq<BindData>(std::move(stype), std::move(part_codes));
-	}
-
-	template <typename INPUT_TYPE>
-	static ScalarFunction GetFunction(const LogicalType &temporal_type) {
-		auto part_type = LogicalType::LIST(LogicalType::VARCHAR);
-		auto result_type = LogicalType::STRUCT({});
-		ScalarFunction result({part_type, temporal_type}, result_type, Function<INPUT_TYPE>, Bind);
-		result.serialize = SerializeFunction;
-		result.deserialize = DeserializeFunction;
-		return result;
-	}
-};
-template <class OP>
-ScalarFunctionSet GetCachedDatepartFunction() {
-	return GetGenericDatePartFunction<InitDateCacheLocalState<OP>>(
-	    DatePartCachedFunction<OP, date_t>, DatePartCachedFunction<OP, timestamp_t>,
-	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, OP::template PropagateStatistics<date_t>,
-	    OP::template PropagateStatistics<timestamp_t>);
-}
-
-ScalarFunctionSet YearFun::GetFunctions() {
-	return GetCachedDatepartFunction<DatePart::YearOperator>();
-}
-
-ScalarFunctionSet MonthFun::GetFunctions() {
-	return GetCachedDatepartFunction<DatePart::MonthOperator>();
-}
-
-ScalarFunctionSet DayFun::GetFunctions() {
-	return GetCachedDatepartFunction<DatePart::DayOperator>();
-}
-
-ScalarFunctionSet DecadeFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DecadeOperator>();
-}
-
-ScalarFunctionSet CenturyFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::CenturyOperator>();
-}
-
-ScalarFunctionSet MillenniumFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::MillenniumOperator>();
-}
-
-ScalarFunctionSet QuarterFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::QuarterOperator>();
-}
-
-ScalarFunctionSet DayOfWeekFun::GetFunctions() {
-	auto set = GetDatePartFunction<DatePart::DayOfWeekOperator>();
-	for (auto &func : set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return set;
-}
-
-ScalarFunctionSet ISODayOfWeekFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::ISODayOfWeekOperator>();
-}
-
-ScalarFunctionSet DayOfYearFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DayOfYearOperator>();
-}
-
-ScalarFunctionSet WeekFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::WeekOperator>();
-}
-
-ScalarFunctionSet ISOYearFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::ISOYearOperator>();
-}
-
-ScalarFunctionSet EraFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::EraOperator>();
-}
-
-ScalarFunctionSet TimezoneFun::GetFunctions() {
-	auto operator_set = GetDatePartFunction<DatePart::TimezoneOperator>();
-
-	//	PG also defines timezone(INTERVAL, TIME_TZ) => TIME_TZ
-	ScalarFunction function({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
-	                        DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>);
-
-	operator_set.AddFunction(function);
-
-	for (auto &func : operator_set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-
-	return operator_set;
-}
-
-ScalarFunctionSet TimezoneHourFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::TimezoneHourOperator>();
-}
-
-ScalarFunctionSet TimezoneMinuteFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::TimezoneMinuteOperator>();
-}
-
-ScalarFunctionSet EpochFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::EpochOperator, double>(LogicalType::DOUBLE);
-}
-
-struct GetEpochNanosOperator {
-	static int64_t Operation(timestamp_ns_t timestamp) {
-		return Timestamp::GetEpochNanoSeconds(timestamp);
-	}
-};
-
-static void ExecuteGetNanosFromTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	auto func = GetEpochNanosOperator::Operation;
-	UnaryExecutor::Execute<timestamp_ns_t, int64_t>(input.data[0], result, input.size(), func);
-}
-
-ScalarFunctionSet EpochNsFun::GetFunctions() {
-	using OP = DatePart::EpochNanosecondsOperator;
-	auto operator_set = GetTimePartFunction<OP>();
-
-	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
-	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
-	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
-
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP_NS}, LogicalType::BIGINT, ExecuteGetNanosFromTimestampNs));
-	return operator_set;
-}
-
-ScalarFunctionSet EpochUsFun::GetFunctions() {
-	using OP = DatePart::EpochMicrosecondsOperator;
-	auto operator_set = GetTimePartFunction<OP>();
-
-	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
-	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
-	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
-	return operator_set;
-}
-
-ScalarFunctionSet EpochMsFun::GetFunctions() {
-	using OP = DatePart::EpochMillisOperator;
-	auto operator_set = GetTimePartFunction<OP>();
-
-	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
-	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
-	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
-
-	//	Legacy inverse BIGINT => TIMESTAMP
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, DatePart::EpochMillisOperator::Inverse));
-
-	return operator_set;
-}
-
-ScalarFunctionSet NanosecondsFun::GetFunctions() {
-	using OP = DatePart::NanosecondsOperator;
-	using TR = int64_t;
-	const LogicalType &result_type = LogicalType::BIGINT;
-	auto operator_set = GetTimePartFunction<OP, TR>();
-
-	auto ns_func = DatePart::UnaryFunction<timestamp_ns_t, TR, OP>;
-	auto ns_stats = OP::template PropagateStatistics<timestamp_ns_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP_NS}, result_type, ns_func, nullptr, nullptr, ns_stats));
-
-	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
-	auto tstz_func = DatePart::UnaryFunction<timestamp_t, TR, OP>;
-	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
-
-	return operator_set;
-}
-
-ScalarFunctionSet MicrosecondsFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::MicrosecondsOperator>();
-}
-
-ScalarFunctionSet MillisecondsFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::MillisecondsOperator>();
-}
-
-ScalarFunctionSet SecondsFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::SecondsOperator>();
-}
-
-ScalarFunctionSet MinutesFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::MinutesOperator>();
-}
-
-ScalarFunctionSet HoursFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::HoursOperator>();
-}
-
-ScalarFunctionSet YearWeekFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::YearWeekOperator>();
-}
-
-ScalarFunctionSet DayOfMonthFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DayOperator>();
-}
-
-ScalarFunctionSet WeekDayFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DayOfWeekOperator>();
-}
-
-ScalarFunctionSet WeekOfYearFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::WeekOperator>();
-}
-
-ScalarFunctionSet LastDayFun::GetFunctions() {
-	ScalarFunctionSet last_day;
-	last_day.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE,
-	                                    DatePart::UnaryFunction<date_t, date_t, LastDayOperator>));
-	last_day.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::DATE,
-	                                    DatePart::UnaryFunction<timestamp_t, date_t, LastDayOperator>));
-	return last_day;
-}
-
-ScalarFunctionSet MonthNameFun::GetFunctions() {
-	ScalarFunctionSet monthname;
-	monthname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
-	                                     DatePart::UnaryFunction<date_t, string_t, MonthNameOperator>));
-	monthname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                     DatePart::UnaryFunction<timestamp_t, string_t, MonthNameOperator>));
-	return monthname;
-}
-
-ScalarFunctionSet DayNameFun::GetFunctions() {
-	ScalarFunctionSet dayname;
-	dayname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
-	                                   DatePart::UnaryFunction<date_t, string_t, DayNameOperator>));
-	dayname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                   DatePart::UnaryFunction<timestamp_t, string_t, DayNameOperator>));
-	return dayname;
-}
-
-ScalarFunctionSet JulianDayFun::GetFunctions() {
-	using OP = DatePart::JulianDayOperator;
-
-	ScalarFunctionSet operator_set;
-	auto date_func = DatePart::UnaryFunction<date_t, double, OP>;
-	auto date_stats = OP::template PropagateStatistics<date_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::DOUBLE, date_func, nullptr, nullptr, date_stats));
-	auto ts_func = DatePart::UnaryFunction<timestamp_t, double, OP>;
-	auto ts_stats = OP::template PropagateStatistics<timestamp_t>;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::DOUBLE, ts_func, nullptr, nullptr, ts_stats));
-
-	return operator_set;
-}
-
-ScalarFunctionSet DatePartFun::GetFunctions() {
-	ScalarFunctionSet date_part;
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::BIGINT,
-	                                     DatePartFunction<date_t>, DatePartBind));
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::BIGINT,
-	                                     DatePartFunction<timestamp_t>, DatePartBind));
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME}, LogicalType::BIGINT,
-	                                     DatePartFunction<dtime_t>, DatePartBind));
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::BIGINT,
-	                                     DatePartFunction<interval_t>, DatePartBind));
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME_TZ}, LogicalType::BIGINT,
-	                                     DatePartFunction<dtime_tz_t>, DatePartBind));
-
-	// struct variants
-	date_part.AddFunction(StructDatePart::GetFunction<date_t>(LogicalType::DATE));
-	date_part.AddFunction(StructDatePart::GetFunction<timestamp_t>(LogicalType::TIMESTAMP));
-	date_part.AddFunction(StructDatePart::GetFunction<dtime_t>(LogicalType::TIME));
-	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
-	date_part.AddFunction(StructDatePart::GetFunction<dtime_tz_t>(LogicalType::TIME_TZ));
-
-	for (auto &func : date_part.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-
-	return date_part;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/date_sub.cpp b/src/duckdb/extension/core_functions/scalar/date/date_sub.cpp
deleted file mode 100644
index acfb2c796..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/date_sub.cpp
+++ /dev/null
@@ -1,454 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-struct DateSub {
-	static int64_t SubtractMicros(timestamp_t startdate, timestamp_t enddate) {
-		const auto start = Timestamp::GetEpochMicroSeconds(startdate);
-		const auto end = Timestamp::GetEpochMicroSeconds(enddate);
-		return SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(end, start);
-	}
-
-	template <class TA, class TB, class TR, class OP>
-	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		BinaryExecutor::ExecuteWithNulls<TA, TB, TR>(
-		    left, right, result, count, [&](TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-			    if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-				    return OP::template Operation<TA, TB, TR>(startdate, enddate);
-			    } else {
-				    mask.SetInvalid(idx);
-				    return TR();
-			    }
-		    });
-	}
-
-	struct MonthOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-
-			if (start_ts > end_ts) {
-				return -MonthOperator::Operation<TA, TB, TR>(end_ts, start_ts);
-			}
-			// The number of complete months depends on whether end_ts is on the last day of the month.
-			date_t end_date;
-			dtime_t end_time;
-			Timestamp::Convert(end_ts, end_date, end_time);
-
-			int32_t yyyy, mm, dd;
-			Date::Convert(end_date, yyyy, mm, dd);
-			const auto end_days = Date::MonthDays(yyyy, mm);
-			if (end_days == dd) {
-				// Now check whether the start day is after the end day
-				date_t start_date;
-				dtime_t start_time;
-				Timestamp::Convert(start_ts, start_date, start_time);
-				Date::Convert(start_date, yyyy, mm, dd);
-				if (dd > end_days || (dd == end_days && start_time < end_time)) {
-					// Move back to the same time on the last day of the (shorter) end month
-					start_date = Date::FromDate(yyyy, mm, end_days);
-					start_ts = Timestamp::FromDatetime(start_date, start_time);
-				}
-			}
-
-			// Our interval difference will now give the correct result.
-			// Note that PG gives different interval subtraction results,
-			// so if we change this we will have to reimplement.
-			return Interval::GetAge(end_ts, start_ts).months;
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_QUARTER;
-		}
-	};
-
-	struct YearOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_YEAR;
-		}
-	};
-
-	struct DecadeOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_DECADE;
-		}
-	};
-
-	struct CenturyOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_CENTURY;
-		}
-	};
-
-	struct MilleniumOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_MILLENIUM;
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate) / Interval::MICROS_PER_DAY;
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate) / Interval::MICROS_PER_WEEK;
-		}
-	};
-
-	struct MicrosecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate);
-		}
-	};
-
-	struct MillisecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate) / Interval::MICROS_PER_MSEC;
-		}
-	};
-
-	struct SecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate) / Interval::MICROS_PER_SEC;
-		}
-	};
-
-	struct MinutesOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate) / Interval::MICROS_PER_MINUTE;
-		}
-	};
-
-	struct HoursOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return SubtractMicros(startdate, enddate) / Interval::MICROS_PER_HOUR;
-		}
-	};
-};
-
-// DATE specialisations
-template <>
-int64_t DateSub::YearOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return YearOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                  Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MonthOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MonthOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                   Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::DayOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return DayOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                 Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::DecadeOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return DecadeOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                    Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::CenturyOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return CenturyOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MilleniumOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MilleniumOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                       Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::QuarterOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return QuarterOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::WeekOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return WeekOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                  Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MicrosecondsOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MicrosecondsOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                          Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MillisecondsOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MillisecondsOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                          Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::SecondsOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return SecondsOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MinutesOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MinutesOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::HoursOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return HoursOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                   Timestamp::FromDatetime(enddate, t0));
-}
-
-// TIME specialisations
-template <>
-int64_t DateSub::YearOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"year\" not recognized");
-}
-
-template <>
-int64_t DateSub::MonthOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"month\" not recognized");
-}
-
-template <>
-int64_t DateSub::DayOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"day\" not recognized");
-}
-
-template <>
-int64_t DateSub::DecadeOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"decade\" not recognized");
-}
-
-template <>
-int64_t DateSub::CenturyOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"century\" not recognized");
-}
-
-template <>
-int64_t DateSub::MilleniumOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
-}
-
-template <>
-int64_t DateSub::QuarterOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
-}
-
-template <>
-int64_t DateSub::WeekOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"week\" not recognized");
-}
-
-template <>
-int64_t DateSub::MicrosecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros - startdate.micros;
-}
-
-template <>
-int64_t DateSub::MillisecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DateSub::SecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DateSub::MinutesOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DateSub::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_HOUR;
-}
-
-template <typename TA, typename TB, typename TR>
-static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-	case DatePartSpecifier::ISOYEAR:
-		return DateSub::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MONTH:
-		return DateSub::MonthOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		return DateSub::DayOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DECADE:
-		return DateSub::DecadeOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::CENTURY:
-		return DateSub::CenturyOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLENNIUM:
-		return DateSub::MilleniumOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::QUARTER:
-		return DateSub::QuarterOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return DateSub::WeekOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MICROSECONDS:
-		return DateSub::MicrosecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLISECONDS:
-		return DateSub::MillisecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return DateSub::SecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MINUTE:
-		return DateSub::MinutesOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::HOUR:
-		return DateSub::HoursOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATESUB");
-	}
-}
-
-struct DateSubTernaryOperator {
-	template <typename TS, typename TA, typename TB, typename TR>
-	static inline TR Operation(TS part, TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-		if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-			return SubtractDateParts<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
-		} else {
-			mask.SetInvalid(idx);
-			return TR();
-		}
-	}
-};
-
-template <typename TA, typename TB, typename TR>
-static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-	case DatePartSpecifier::ISOYEAR:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::YearOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MONTH:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MonthOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::DayOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DECADE:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::DecadeOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::CENTURY:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::CenturyOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLENNIUM:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MilleniumOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::QUARTER:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::QuarterOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::WeekOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MicrosecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MillisecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::SecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MINUTE:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MinutesOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::HOUR:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::HoursOperator>(left, right, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATESUB");
-	}
-}
-
-template <typename T>
-static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	auto &part_arg = args.data[0];
-	auto &start_arg = args.data[1];
-	auto &end_arg = args.data[2];
-
-	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Common case of constant part.
-		if (ConstantVector::IsNull(part_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateSubBinaryExecutor<T, T, int64_t>(type, start_arg, end_arg, result, args.size());
-		}
-	} else {
-		TernaryExecutor::ExecuteWithNulls<string_t, T, T, int64_t>(
-		    part_arg, start_arg, end_arg, result, args.size(),
-		    DateSubTernaryOperator::Operation<string_t, T, T, int64_t>);
-	}
-}
-
-ScalarFunctionSet DateSubFun::GetFunctions() {
-	ScalarFunctionSet date_sub("date_sub");
-	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},
-	                                    LogicalType::BIGINT, DateSubFunction<date_t>));
-	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
-	                                    LogicalType::BIGINT, DateSubFunction<timestamp_t>));
-	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME, LogicalType::TIME},
-	                                    LogicalType::BIGINT, DateSubFunction<dtime_t>));
-	return date_sub;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp b/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp
deleted file mode 100644
index cb54e30de..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp
+++ /dev/null
@@ -1,737 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-struct DateTrunc {
-	template <class TA, class TR, class OP>
-	static inline TR UnaryFunction(TA input) {
-		if (Value::IsFinite(input)) {
-			return OP::template Operation<TA, TR>(input);
-		} else {
-			return Cast::template Operation<TA, TR>(input);
-		}
-	}
-
-	template <class TA, class TR, class OP>
-	static inline void UnaryExecute(Vector &left, Vector &result, idx_t count) {
-		UnaryExecutor::Execute<TA, TR>(left, result, count, UnaryFunction<TA, TR, OP>);
-	}
-
-	struct MillenniumOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate((Date::ExtractYear(input) / 1000) * 1000, 1, 1);
-		}
-	};
-
-	struct CenturyOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate((Date::ExtractYear(input) / 100) * 100, 1, 1);
-		}
-	};
-
-	struct DecadeOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate((Date::ExtractYear(input) / 10) * 10, 1, 1);
-		}
-	};
-
-	struct YearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate(Date::ExtractYear(input), 1, 1);
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t yyyy, mm, dd;
-			Date::Convert(input, yyyy, mm, dd);
-			mm = 1 + (((mm - 1) / 3) * 3);
-			return Date::FromDate(yyyy, mm, 1);
-		}
-	};
-
-	struct MonthOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate(Date::ExtractYear(input), Date::ExtractMonth(input), 1);
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::GetMondayOfCurrentWeek(input);
-		}
-	};
-
-	struct ISOYearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			date_t date = Date::GetMondayOfCurrentWeek(input);
-			date.days -= (Date::ExtractISOWeekNumber(date) - 1) * Interval::DAYS_PER_WEEK;
-
-			return date;
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return input;
-		}
-	};
-
-	struct HourOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, 0, 0, 0));
-		}
-	};
-
-	struct MinuteOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, 0, 0));
-		}
-	};
-
-	struct SecondOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, sec, 0));
-		}
-	};
-
-	struct MillisecondOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			micros -= UnsafeNumericCast<int32_t>(micros % Interval::MICROS_PER_MSEC);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, sec, micros));
-		}
-	};
-
-	struct MicrosecondOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return input;
-		}
-	};
-};
-
-// DATE specialisations
-template <>
-date_t DateTrunc::MillenniumOperator::Operation(timestamp_t input) {
-	return MillenniumOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::MillenniumOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(MillenniumOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::MillenniumOperator::Operation(timestamp_t input) {
-	return MillenniumOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::CenturyOperator::Operation(timestamp_t input) {
-	return CenturyOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::CenturyOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(CenturyOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::CenturyOperator::Operation(timestamp_t input) {
-	return CenturyOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::DecadeOperator::Operation(timestamp_t input) {
-	return DecadeOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::DecadeOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(DecadeOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::DecadeOperator::Operation(timestamp_t input) {
-	return DecadeOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::YearOperator::Operation(timestamp_t input) {
-	return YearOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::YearOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(YearOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::YearOperator::Operation(timestamp_t input) {
-	return YearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::QuarterOperator::Operation(timestamp_t input) {
-	return QuarterOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::QuarterOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(QuarterOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::QuarterOperator::Operation(timestamp_t input) {
-	return QuarterOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::MonthOperator::Operation(timestamp_t input) {
-	return MonthOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::MonthOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(MonthOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::MonthOperator::Operation(timestamp_t input) {
-	return MonthOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::WeekOperator::Operation(timestamp_t input) {
-	return WeekOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::WeekOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(WeekOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::WeekOperator::Operation(timestamp_t input) {
-	return WeekOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
-	return ISOYearOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::ISOYearOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(ISOYearOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
-	return ISOYearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::DayOperator::Operation(timestamp_t input) {
-	return DayOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::DayOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(DayOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::DayOperator::Operation(timestamp_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::HourOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::HourOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::HourOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(HourOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::MinuteOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::MinuteOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::MinuteOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(HourOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::SecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::SecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::SecondOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(DayOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::MillisecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::MillisecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::MillisecondOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(MillisecondOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::MicrosecondOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(MicrosecondOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-// INTERVAL specialisations
-template <>
-interval_t DateTrunc::MillenniumOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_MILLENIUM) * Interval::MONTHS_PER_MILLENIUM;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::CenturyOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_CENTURY) * Interval::MONTHS_PER_CENTURY;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::DecadeOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_DECADE) * Interval::MONTHS_PER_DECADE;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::YearOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_YEAR) * Interval::MONTHS_PER_YEAR;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::QuarterOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_QUARTER) * Interval::MONTHS_PER_QUARTER;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MonthOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::WeekOperator::Operation(interval_t input) {
-	input.micros = 0;
-	input.days = (input.days / Interval::DAYS_PER_WEEK) * Interval::DAYS_PER_WEEK;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::ISOYearOperator::Operation(interval_t input) {
-	return YearOperator::Operation<interval_t, interval_t>(input);
-}
-
-template <>
-interval_t DateTrunc::DayOperator::Operation(interval_t input) {
-	input.micros = 0;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::HourOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_HOUR) * Interval::MICROS_PER_HOUR;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MinuteOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_MINUTE) * Interval::MICROS_PER_MINUTE;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::SecondOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_SEC) * Interval::MICROS_PER_SEC;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MillisecondOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_MSEC) * Interval::MICROS_PER_MSEC;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
-	return input;
-}
-
-template <class TA, class TR>
-static TR TruncateElement(DatePartSpecifier type, TA element) {
-	if (!Value::IsFinite(element)) {
-		return Cast::template Operation<TA, TR>(element);
-	}
-
-	switch (type) {
-	case DatePartSpecifier::MILLENNIUM:
-		return DateTrunc::MillenniumOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::CENTURY:
-		return DateTrunc::CenturyOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::DECADE:
-		return DateTrunc::DecadeOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::YEAR:
-		return DateTrunc::YearOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::QUARTER:
-		return DateTrunc::QuarterOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MONTH:
-		return DateTrunc::MonthOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return DateTrunc::WeekOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::ISOYEAR:
-		return DateTrunc::ISOYearOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		return DateTrunc::DayOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::HOUR:
-		return DateTrunc::HourOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MINUTE:
-		return DateTrunc::MinuteOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return DateTrunc::SecondOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MILLISECONDS:
-		return DateTrunc::MillisecondOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MICROSECONDS:
-		return DateTrunc::MicrosecondOperator::Operation<TA, TR>(element);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATETRUNC");
-	}
-}
-
-struct DateTruncBinaryOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA specifier, TB date) {
-		return TruncateElement<TB, TR>(GetDatePartSpecifier(specifier.GetString()), date);
-	}
-};
-
-template <typename TA, typename TR>
-static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result, idx_t count) {
-	switch (type) {
-	case DatePartSpecifier::MILLENNIUM:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillenniumOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::CENTURY:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::CenturyOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::DECADE:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DecadeOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::YEAR:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::YearOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::QUARTER:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::QuarterOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MONTH:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MonthOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::WeekOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::ISOYEAR:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::ISOYearOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DayOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::HOUR:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::HourOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MINUTE:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MinuteOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::SecondOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillisecondOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MicrosecondOperator>(left, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATETRUNC");
-	}
-}
-
-template <typename TA, typename TR>
-static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto &part_arg = args.data[0];
-	auto &date_arg = args.data[1];
-
-	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Common case of constant part.
-		if (ConstantVector::IsNull(part_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateTruncUnaryExecutor<TA, TR>(type, date_arg, result, args.size());
-		}
-	} else {
-		BinaryExecutor::ExecuteStandard<string_t, TA, TR, DateTruncBinaryOperator>(part_arg, date_arg, result,
-		                                                                           args.size());
-	}
-}
-
-template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &child_stats) {
-	// we can only propagate date stats if the child has stats
-	auto &nstats = child_stats[1];
-	if (!NumericStats::HasMinMax(nstats)) {
-		return nullptr;
-	}
-	// run the operator on both the min and the max, this gives us the [min, max] bound
-	auto min = NumericStats::GetMin<TA>(nstats);
-	auto max = NumericStats::GetMax<TA>(nstats);
-	if (min > max) {
-		return nullptr;
-	}
-
-	// Infinite values are unmodified
-	auto min_part = DateTrunc::UnaryFunction<TA, TR, OP>(min);
-	auto max_part = DateTrunc::UnaryFunction<TA, TR, OP>(max);
-
-	auto min_value = Value::CreateValue(min_part);
-	auto max_value = Value::CreateValue(max_part);
-	auto result = NumericStats::CreateEmpty(min_value.type());
-	NumericStats::SetMin(result, min_value);
-	NumericStats::SetMax(result, max_value);
-	result.CopyValidity(child_stats[0]);
-	return result.ToUnique();
-}
-
-template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-	return DateTruncStatistics<TA, TR, OP>(input.child_stats);
-}
-
-template <typename TA, typename TR>
-static function_statistics_t DateTruncStats(DatePartSpecifier type) {
-	switch (type) {
-	case DatePartSpecifier::MILLENNIUM:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillenniumOperator>;
-	case DatePartSpecifier::CENTURY:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::CenturyOperator>;
-	case DatePartSpecifier::DECADE:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DecadeOperator>;
-	case DatePartSpecifier::YEAR:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::YearOperator>;
-	case DatePartSpecifier::QUARTER:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::QuarterOperator>;
-	case DatePartSpecifier::MONTH:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MonthOperator>;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::WeekOperator>;
-	case DatePartSpecifier::ISOYEAR:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::ISOYearOperator>;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DayOperator>;
-	case DatePartSpecifier::HOUR:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::HourOperator>;
-	case DatePartSpecifier::MINUTE:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MinuteOperator>;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::SecondOperator>;
-	case DatePartSpecifier::MILLISECONDS:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillisecondOperator>;
-	case DatePartSpecifier::MICROSECONDS:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MicrosecondOperator>;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATETRUNC statistics");
-	}
-}
-
-static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[0]->IsFoldable()) {
-		return nullptr;
-	}
-
-	// Rebind to return a date if we are truncating that far
-	Value part_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-	if (part_value.IsNull()) {
-		return nullptr;
-	}
-	const auto part_name = part_value.ToString();
-	const auto part_code = GetDatePartSpecifier(part_name);
-	switch (part_code) {
-	case DatePartSpecifier::MILLENNIUM:
-	case DatePartSpecifier::CENTURY:
-	case DatePartSpecifier::DECADE:
-	case DatePartSpecifier::YEAR:
-	case DatePartSpecifier::QUARTER:
-	case DatePartSpecifier::MONTH:
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-	case DatePartSpecifier::ISOYEAR:
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-	case DatePartSpecifier::JULIAN_DAY:
-		switch (bound_function.arguments[1].id()) {
-		case LogicalType::TIMESTAMP:
-			bound_function.function = DateTruncFunction<timestamp_t, date_t>;
-			bound_function.statistics = DateTruncStats<timestamp_t, date_t>(part_code);
-			break;
-		case LogicalType::DATE:
-			bound_function.function = DateTruncFunction<date_t, date_t>;
-			bound_function.statistics = DateTruncStats<date_t, date_t>(part_code);
-			break;
-		default:
-			throw NotImplementedException("Temporal argument type for DATETRUNC");
-		}
-		bound_function.return_type = LogicalType::DATE;
-		break;
-	default:
-		switch (bound_function.arguments[1].id()) {
-		case LogicalType::TIMESTAMP:
-			bound_function.statistics = DateTruncStats<timestamp_t, timestamp_t>(part_code);
-			break;
-		case LogicalType::DATE:
-			bound_function.statistics = DateTruncStats<date_t, timestamp_t>(part_code);
-			break;
-		default:
-			throw NotImplementedException("Temporal argument type for DATETRUNC");
-		}
-		break;
-	}
-
-	return nullptr;
-}
-
-ScalarFunctionSet DateTruncFun::GetFunctions() {
-	ScalarFunctionSet date_trunc("date_trunc");
-	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<timestamp_t, timestamp_t>, DateTruncBind));
-	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<date_t, timestamp_t>, DateTruncBind));
-	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
-	                                      DateTruncFunction<interval_t, interval_t>));
-	for (auto &func : date_trunc.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return date_trunc;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/epoch.cpp b/src/duckdb/extension/core_functions/scalar/date/epoch.cpp
deleted file mode 100644
index cda3232a4..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/epoch.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-
-namespace duckdb {
-
-struct EpochSecOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE sec) {
-		int64_t result;
-		if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) {
-			throw ConversionException("Epoch seconds out of range for TIMESTAMP WITH TIME ZONE");
-		}
-		return timestamp_t(result);
-	}
-};
-
-static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	UnaryExecutor::Execute<double, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
-}
-
-ScalarFunction ToTimestampFun::GetFunction() {
-	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
-}
-
-struct NormalizedIntervalOperator {
-	template <typename INPUT_TYPE, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return input.Normalize();
-	}
-};
-
-static void NormalizedIntervalFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	UnaryExecutor::Execute<interval_t, interval_t, NormalizedIntervalOperator>(input.data[0], result, input.size());
-}
-
-ScalarFunction NormalizedIntervalFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTERVAL}, LogicalType::INTERVAL, NormalizedIntervalFunction);
-}
-
-struct TimeTZSortKeyOperator {
-	template <typename INPUT_TYPE, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return input.sort_key();
-	}
-};
-
-static void TimeTZSortKeyFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	UnaryExecutor::Execute<dtime_tz_t, uint64_t, TimeTZSortKeyOperator>(input.data[0], result, input.size());
-}
-
-ScalarFunction TimeTZSortKeyFun::GetFunction() {
-	return ScalarFunction({LogicalType::TIME_TZ}, LogicalType::UBIGINT, TimeTZSortKeyFunction);
-}
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp b/src/duckdb/extension/core_functions/scalar/date/make_date.cpp
deleted file mode 100644
index 0fe00a920..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/vector_operations/senary_executor.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-static void MakeDateFromEpoch(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-	result.Reinterpret(input.data[0]);
-}
-
-struct MakeDateOperator {
-	template <typename YYYY, typename MM, typename DD, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) {
-		return Date::FromDate(Cast::Operation<YYYY, int32_t>(yyyy), Cast::Operation<MM, int32_t>(mm),
-		                      Cast::Operation<DD, int32_t>(dd));
-	}
-};
-
-template <typename T>
-static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 3);
-	auto &yyyy = input.data[0];
-	auto &mm = input.data[1];
-	auto &dd = input.data[2];
-
-	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(),
-	                                          MakeDateOperator::Operation<T, T, T, date_t>);
-}
-
-template <typename T>
-static date_t FromDateCast(T year, T month, T day) {
-	date_t result;
-	if (!Date::TryFromDate(Cast::Operation<T, int32_t>(year), Cast::Operation<T, int32_t>(month),
-	                       Cast::Operation<T, int32_t>(day), result)) {
-		throw ConversionException("Date out of range: %d-%d-%d", year, month, day);
-	}
-	return result;
-}
-
-template <typename T>
-static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
-	// this should be guaranteed by the binder
-	D_ASSERT(input.ColumnCount() == 1);
-	auto &vec = input.data[0];
-
-	auto &children = StructVector::GetEntries(vec);
-	D_ASSERT(children.size() == 3);
-	auto &yyyy = *children[0];
-	auto &mm = *children[1];
-	auto &dd = *children[2];
-
-	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(), FromDateCast<T>);
-}
-
-struct MakeTimeOperator {
-	template <typename HH, typename MM, typename SS, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
-
-		auto hh_32 = Cast::Operation<HH, int32_t>(hh);
-		auto mm_32 = Cast::Operation<MM, int32_t>(mm);
-		// Have to check this separately because safe casting of DOUBLE => INT32 can round.
-		int32_t ss_32 = 0;
-		if (ss < 0 || ss > Interval::SECS_PER_MINUTE) {
-			ss_32 = Cast::Operation<SS, int32_t>(ss);
-		} else {
-			ss_32 = LossyNumericCast<int32_t>(ss);
-		}
-		auto micros = LossyNumericCast<int32_t>(std::round((ss - ss_32) * Interval::MICROS_PER_SEC));
-
-		if (!Time::IsValidTime(hh_32, mm_32, ss_32, micros)) {
-			throw ConversionException("Time out of range: %d:%d:%d.%d", hh_32, mm_32, ss_32, micros);
-		}
-		return Time::FromTime(hh_32, mm_32, ss_32, micros);
-	}
-};
-
-template <typename T>
-static void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 3);
-	auto &yyyy = input.data[0];
-	auto &mm = input.data[1];
-	auto &dd = input.data[2];
-
-	TernaryExecutor::Execute<T, T, double, dtime_t>(yyyy, mm, dd, result, input.size(),
-	                                                MakeTimeOperator::Operation<T, T, double, dtime_t>);
-}
-
-struct MakeTimestampOperator {
-	template <typename YYYY, typename MM, typename DD, typename HR, typename MN, typename SS, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd, HR hr, MN mn, SS ss) {
-		const auto d = MakeDateOperator::Operation<YYYY, MM, DD, date_t>(yyyy, mm, dd);
-		const auto t = MakeTimeOperator::Operation<HR, MN, SS, dtime_t>(hr, mn, ss);
-		return Timestamp::FromDatetime(d, t);
-	}
-
-	template <typename T, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(T value) {
-		const auto result = RESULT_TYPE(value);
-		if (!Timestamp::IsFinite(result)) {
-			throw ConversionException("Timestamp microseconds out of range: %ld", value);
-		}
-		return RESULT_TYPE(value);
-	}
-};
-
-template <typename T>
-static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
-	if (input.ColumnCount() == 1) {
-		auto func = MakeTimestampOperator::Operation<T, timestamp_t>;
-		UnaryExecutor::Execute<T, timestamp_t>(input.data[0], result, input.size(), func);
-		return;
-	}
-
-	D_ASSERT(input.ColumnCount() == 6);
-
-	auto func = MakeTimestampOperator::Operation<T, T, T, T, T, double, timestamp_t>;
-	SenaryExecutor::Execute<T, T, T, T, T, double, timestamp_t>(input, result, func);
-}
-
-template <typename T>
-static void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	auto func = MakeTimestampOperator::Operation<T, timestamp_ns_t>;
-	UnaryExecutor::Execute<T, timestamp_ns_t>(input.data[0], result, input.size(), func);
-	return;
-}
-
-ScalarFunctionSet MakeDateFun::GetFunctions() {
-	ScalarFunctionSet make_date("make_date");
-	make_date.AddFunction(ScalarFunction({LogicalType::INTEGER}, LogicalType::DATE, MakeDateFromEpoch));
-	make_date.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                     LogicalType::DATE, ExecuteMakeDate<int64_t>));
-
-	child_list_t<LogicalType> make_date_children {
-	    {"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}};
-	make_date.AddFunction(
-	    ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate<int64_t>));
-	for (auto &func : make_date.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return make_date;
-}
-
-ScalarFunction MakeTimeFun::GetFunction() {
-	ScalarFunction function({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
-	                        ExecuteMakeTime<int64_t>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunctionSet MakeTimestampFun::GetFunctions() {
-	ScalarFunctionSet operator_set("make_timestamp");
-	operator_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
-	                                         LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
-	                                        LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
-
-	for (auto &func : operator_set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return operator_set;
-}
-
-ScalarFunctionSet MakeTimestampNsFun::GetFunctions() {
-	ScalarFunctionSet operator_set("make_timestamp_ns");
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP_NS, ExecuteMakeTimestampNs<int64_t>));
-	return operator_set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp b/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp
deleted file mode 100644
index 726d6b54f..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp
+++ /dev/null
@@ -1,373 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "core_functions/scalar/date_functions.hpp"
-
-namespace duckdb {
-
-struct TimeBucket {
-
-	// Use 2000-01-03 00:00:00 (Monday) as origin when bucket_width is days, hours, ... for TimescaleDB compatibility
-	// There are 10959 days between 1970-01-01 and 2000-01-03
-	constexpr static const int64_t DEFAULT_ORIGIN_MICROS = 10959 * Interval::MICROS_PER_DAY;
-	// Use 2000-01-01 as origin when bucket_width is months, years, ... for TimescaleDB compatibility
-	// There are 360 months between 1970-01-01 and 2000-01-01
-	constexpr static const int32_t DEFAULT_ORIGIN_MONTHS = 360;
-
-	enum struct BucketWidthType : uint8_t { CONVERTIBLE_TO_MICROS, CONVERTIBLE_TO_MONTHS, UNCLASSIFIED };
-
-	static inline BucketWidthType ClassifyBucketWidth(const interval_t bucket_width) {
-		if (bucket_width.months == 0 && Interval::GetMicro(bucket_width) > 0) {
-			return BucketWidthType::CONVERTIBLE_TO_MICROS;
-		} else if (bucket_width.months > 0 && bucket_width.days == 0 && bucket_width.micros == 0) {
-			return BucketWidthType::CONVERTIBLE_TO_MONTHS;
-		} else {
-			return BucketWidthType::UNCLASSIFIED;
-		}
-	}
-
-	static inline BucketWidthType ClassifyBucketWidthErrorThrow(const interval_t bucket_width) {
-		if (bucket_width.months == 0) {
-			int64_t bucket_width_micros = Interval::GetMicro(bucket_width);
-			if (bucket_width_micros <= 0) {
-				throw NotImplementedException("Period must be greater than 0");
-			}
-			return BucketWidthType::CONVERTIBLE_TO_MICROS;
-		} else if (bucket_width.months != 0 && bucket_width.days == 0 && bucket_width.micros == 0) {
-			if (bucket_width.months < 0) {
-				throw NotImplementedException("Period must be greater than 0");
-			}
-			return BucketWidthType::CONVERTIBLE_TO_MONTHS;
-		} else {
-			throw NotImplementedException("Month intervals cannot have day or time component");
-		}
-	}
-
-	template <typename T>
-	static inline int32_t EpochMonths(T ts) {
-		date_t ts_date = Cast::template Operation<T, date_t>(ts);
-		return (Date::ExtractYear(ts_date) - 1970) * 12 + Date::ExtractMonth(ts_date) - 1;
-	}
-
-	static inline timestamp_t WidthConvertibleToMicrosCommon(int64_t bucket_width_micros, int64_t ts_micros,
-	                                                         int64_t origin_micros) {
-		origin_micros %= bucket_width_micros;
-		ts_micros = SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(ts_micros, origin_micros);
-
-		int64_t result_micros = (ts_micros / bucket_width_micros) * bucket_width_micros;
-		if (ts_micros < 0 && ts_micros % bucket_width_micros != 0) {
-			result_micros =
-			    SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(result_micros, bucket_width_micros);
-		}
-		result_micros += origin_micros;
-
-		return Timestamp::FromEpochMicroSeconds(result_micros);
-	}
-
-	static inline date_t WidthConvertibleToMonthsCommon(int32_t bucket_width_months, int32_t ts_months,
-	                                                    int32_t origin_months) {
-		origin_months %= bucket_width_months;
-		ts_months = SubtractOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(ts_months, origin_months);
-
-		int32_t result_months = (ts_months / bucket_width_months) * bucket_width_months;
-		if (ts_months < 0 && ts_months % bucket_width_months != 0) {
-			result_months =
-			    SubtractOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(result_months, bucket_width_months);
-		}
-		result_months += origin_months;
-
-		int32_t year =
-		    (result_months < 0 && result_months % 12 != 0) ? 1970 + result_months / 12 - 1 : 1970 + result_months / 12;
-		int32_t month =
-		    (result_months < 0 && result_months % 12 != 0) ? result_months % 12 + 13 : result_months % 12 + 1;
-
-		return Date::FromDate(year, month, 1);
-	}
-
-	struct WidthConvertibleToMicrosBinaryOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA bucket_width, TB ts) {
-			if (!Value::IsFinite(ts)) {
-				return Cast::template Operation<TB, TR>(ts);
-			}
-			int64_t bucket_width_micros = Interval::GetMicro(bucket_width);
-			int64_t ts_micros = Timestamp::GetEpochMicroSeconds(Cast::template Operation<TB, timestamp_t>(ts));
-			return Cast::template Operation<timestamp_t, TR>(
-			    WidthConvertibleToMicrosCommon(bucket_width_micros, ts_micros, DEFAULT_ORIGIN_MICROS));
-		}
-	};
-
-	struct WidthConvertibleToMonthsBinaryOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA bucket_width, TB ts) {
-			if (!Value::IsFinite(ts)) {
-				return Cast::template Operation<TB, TR>(ts);
-			}
-			int32_t ts_months = EpochMonths(ts);
-			return Cast::template Operation<date_t, TR>(
-			    WidthConvertibleToMonthsCommon(bucket_width.months, ts_months, DEFAULT_ORIGIN_MONTHS));
-		}
-	};
-
-	struct BinaryOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA bucket_width, TB ts) {
-			BucketWidthType bucket_width_type = ClassifyBucketWidthErrorThrow(bucket_width);
-			switch (bucket_width_type) {
-			case BucketWidthType::CONVERTIBLE_TO_MICROS:
-				return WidthConvertibleToMicrosBinaryOperator::Operation<TA, TB, TR>(bucket_width, ts);
-			case BucketWidthType::CONVERTIBLE_TO_MONTHS:
-				return WidthConvertibleToMonthsBinaryOperator::Operation<TA, TB, TR>(bucket_width, ts);
-			default:
-				throw NotImplementedException("Bucket type not implemented for TIME_BUCKET");
-			}
-		}
-	};
-
-	struct OffsetWidthConvertibleToMicrosTernaryOperator {
-		template <class TA, class TB, class TC, class TR>
-		static inline TR Operation(TA bucket_width, TB ts, TC offset) {
-			if (!Value::IsFinite(ts)) {
-				return Cast::template Operation<TB, TR>(ts);
-			}
-			int64_t bucket_width_micros = Interval::GetMicro(bucket_width);
-			int64_t ts_micros = Timestamp::GetEpochMicroSeconds(
-			    Interval::Add(Cast::template Operation<TB, timestamp_t>(ts), Interval::Invert(offset)));
-			return Cast::template Operation<timestamp_t, TR>(Interval::Add(
-			    WidthConvertibleToMicrosCommon(bucket_width_micros, ts_micros, DEFAULT_ORIGIN_MICROS), offset));
-		}
-	};
-
-	struct OffsetWidthConvertibleToMonthsTernaryOperator {
-		template <class TA, class TB, class TC, class TR>
-		static inline TR Operation(TA bucket_width, TB ts, TC offset) {
-			if (!Value::IsFinite(ts)) {
-				return Cast::template Operation<TB, TR>(ts);
-			}
-			int32_t ts_months = EpochMonths(Interval::Add(ts, Interval::Invert(offset)));
-			return Interval::Add(Cast::template Operation<date_t, TR>(WidthConvertibleToMonthsCommon(
-			                         bucket_width.months, ts_months, DEFAULT_ORIGIN_MONTHS)),
-			                     offset);
-		}
-	};
-
-	struct OffsetTernaryOperator {
-		template <class TA, class TB, class TC, class TR>
-		static inline TR Operation(TA bucket_width, TB ts, TC offset) {
-			BucketWidthType bucket_width_type = ClassifyBucketWidthErrorThrow(bucket_width);
-			switch (bucket_width_type) {
-			case BucketWidthType::CONVERTIBLE_TO_MICROS:
-				return OffsetWidthConvertibleToMicrosTernaryOperator::Operation<TA, TB, TC, TR>(bucket_width, ts,
-				                                                                                offset);
-			case BucketWidthType::CONVERTIBLE_TO_MONTHS:
-				return OffsetWidthConvertibleToMonthsTernaryOperator::Operation<TA, TB, TC, TR>(bucket_width, ts,
-				                                                                                offset);
-			default:
-				throw NotImplementedException("Bucket type not implemented for TIME_BUCKET");
-			}
-		}
-	};
-
-	struct OriginWidthConvertibleToMicrosTernaryOperator {
-		template <class TA, class TB, class TC, class TR>
-		static inline TR Operation(TA bucket_width, TB ts, TC origin) {
-			if (!Value::IsFinite(ts)) {
-				return Cast::template Operation<TB, TR>(ts);
-			}
-			int64_t bucket_width_micros = Interval::GetMicro(bucket_width);
-			int64_t ts_micros = Timestamp::GetEpochMicroSeconds(Cast::template Operation<TB, timestamp_t>(ts));
-			int64_t origin_micros = Timestamp::GetEpochMicroSeconds(Cast::template Operation<TB, timestamp_t>(origin));
-			return Cast::template Operation<timestamp_t, TR>(
-			    WidthConvertibleToMicrosCommon(bucket_width_micros, ts_micros, origin_micros));
-		}
-	};
-
-	struct OriginWidthConvertibleToMonthsTernaryOperator {
-		template <class TA, class TB, class TC, class TR>
-		static inline TR Operation(TA bucket_width, TB ts, TC origin) {
-			if (!Value::IsFinite(ts)) {
-				return Cast::template Operation<TB, TR>(ts);
-			}
-			int32_t ts_months = EpochMonths(ts);
-			int32_t origin_months = EpochMonths(origin);
-			return Cast::template Operation<date_t, TR>(
-			    WidthConvertibleToMonthsCommon(bucket_width.months, ts_months, origin_months));
-		}
-	};
-
-	struct OriginTernaryOperator {
-		template <class TA, class TB, class TC, class TR>
-		static inline TR Operation(TA bucket_width, TB ts, TC origin, ValidityMask &mask, idx_t idx) {
-			if (!Value::IsFinite(origin)) {
-				mask.SetInvalid(idx);
-				return TR();
-			}
-			BucketWidthType bucket_width_type = ClassifyBucketWidthErrorThrow(bucket_width);
-			switch (bucket_width_type) {
-			case BucketWidthType::CONVERTIBLE_TO_MICROS:
-				return OriginWidthConvertibleToMicrosTernaryOperator::Operation<TA, TB, TC, TR>(bucket_width, ts,
-				                                                                                origin);
-			case BucketWidthType::CONVERTIBLE_TO_MONTHS:
-				return OriginWidthConvertibleToMonthsTernaryOperator::Operation<TA, TB, TC, TR>(bucket_width, ts,
-				                                                                                origin);
-			default:
-				throw NotImplementedException("Bucket type not implemented for TIME_BUCKET");
-			}
-		}
-	};
-};
-
-template <typename T>
-static void TimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-
-	auto &bucket_width_arg = args.data[0];
-	auto &ts_arg = args.data[1];
-
-	if (bucket_width_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (ConstantVector::IsNull(bucket_width_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			interval_t bucket_width = *ConstantVector::GetData<interval_t>(bucket_width_arg);
-			TimeBucket::BucketWidthType bucket_width_type = TimeBucket::ClassifyBucketWidth(bucket_width);
-			switch (bucket_width_type) {
-			case TimeBucket::BucketWidthType::CONVERTIBLE_TO_MICROS:
-				BinaryExecutor::Execute<interval_t, T, T>(
-				    bucket_width_arg, ts_arg, result, args.size(),
-				    TimeBucket::WidthConvertibleToMicrosBinaryOperator::Operation<interval_t, T, T>);
-				break;
-			case TimeBucket::BucketWidthType::CONVERTIBLE_TO_MONTHS:
-				BinaryExecutor::Execute<interval_t, T, T>(
-				    bucket_width_arg, ts_arg, result, args.size(),
-				    TimeBucket::WidthConvertibleToMonthsBinaryOperator::Operation<interval_t, T, T>);
-				break;
-			case TimeBucket::BucketWidthType::UNCLASSIFIED:
-				BinaryExecutor::Execute<interval_t, T, T>(bucket_width_arg, ts_arg, result, args.size(),
-				                                          TimeBucket::BinaryOperator::Operation<interval_t, T, T>);
-				break;
-			default:
-				throw NotImplementedException("Bucket type not implemented for TIME_BUCKET");
-			}
-		}
-	} else {
-		BinaryExecutor::Execute<interval_t, T, T>(bucket_width_arg, ts_arg, result, args.size(),
-		                                          TimeBucket::BinaryOperator::Operation<interval_t, T, T>);
-	}
-}
-
-template <typename T>
-static void TimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-
-	auto &bucket_width_arg = args.data[0];
-	auto &ts_arg = args.data[1];
-	auto &offset_arg = args.data[2];
-
-	if (bucket_width_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (ConstantVector::IsNull(bucket_width_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			interval_t bucket_width = *ConstantVector::GetData<interval_t>(bucket_width_arg);
-			TimeBucket::BucketWidthType bucket_width_type = TimeBucket::ClassifyBucketWidth(bucket_width);
-			switch (bucket_width_type) {
-			case TimeBucket::BucketWidthType::CONVERTIBLE_TO_MICROS:
-				TernaryExecutor::Execute<interval_t, T, interval_t, T>(
-				    bucket_width_arg, ts_arg, offset_arg, result, args.size(),
-				    TimeBucket::OffsetWidthConvertibleToMicrosTernaryOperator::Operation<interval_t, T, interval_t, T>);
-				break;
-			case TimeBucket::BucketWidthType::CONVERTIBLE_TO_MONTHS:
-				TernaryExecutor::Execute<interval_t, T, interval_t, T>(
-				    bucket_width_arg, ts_arg, offset_arg, result, args.size(),
-				    TimeBucket::OffsetWidthConvertibleToMonthsTernaryOperator::Operation<interval_t, T, interval_t, T>);
-				break;
-			case TimeBucket::BucketWidthType::UNCLASSIFIED:
-				TernaryExecutor::Execute<interval_t, T, interval_t, T>(
-				    bucket_width_arg, ts_arg, offset_arg, result, args.size(),
-				    TimeBucket::OffsetTernaryOperator::Operation<interval_t, T, interval_t, T>);
-				break;
-			default:
-				throw NotImplementedException("Bucket type not implemented for TIME_BUCKET");
-			}
-		}
-	} else {
-		TernaryExecutor::Execute<interval_t, T, interval_t, T>(
-		    bucket_width_arg, ts_arg, offset_arg, result, args.size(),
-		    TimeBucket::OffsetTernaryOperator::Operation<interval_t, T, interval_t, T>);
-	}
-}
-
-template <typename T>
-static void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-
-	auto &bucket_width_arg = args.data[0];
-	auto &ts_arg = args.data[1];
-	auto &origin_arg = args.data[2];
-
-	if (bucket_width_arg.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-	    origin_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (ConstantVector::IsNull(bucket_width_arg) || ConstantVector::IsNull(origin_arg) ||
-		    !Value::IsFinite(*ConstantVector::GetData<T>(origin_arg))) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			interval_t bucket_width = *ConstantVector::GetData<interval_t>(bucket_width_arg);
-			TimeBucket::BucketWidthType bucket_width_type = TimeBucket::ClassifyBucketWidth(bucket_width);
-			switch (bucket_width_type) {
-			case TimeBucket::BucketWidthType::CONVERTIBLE_TO_MICROS:
-				TernaryExecutor::Execute<interval_t, T, T, T>(
-				    bucket_width_arg, ts_arg, origin_arg, result, args.size(),
-				    TimeBucket::OriginWidthConvertibleToMicrosTernaryOperator::Operation<interval_t, T, T, T>);
-				break;
-			case TimeBucket::BucketWidthType::CONVERTIBLE_TO_MONTHS:
-				TernaryExecutor::Execute<interval_t, T, T, T>(
-				    bucket_width_arg, ts_arg, origin_arg, result, args.size(),
-				    TimeBucket::OriginWidthConvertibleToMonthsTernaryOperator::Operation<interval_t, T, T, T>);
-				break;
-			case TimeBucket::BucketWidthType::UNCLASSIFIED:
-				TernaryExecutor::ExecuteWithNulls<interval_t, T, T, T>(
-				    bucket_width_arg, ts_arg, origin_arg, result, args.size(),
-				    TimeBucket::OriginTernaryOperator::Operation<interval_t, T, T, T>);
-				break;
-			default:
-				throw NotImplementedException("Bucket type not implemented for TIME_BUCKET");
-			}
-		}
-	} else {
-		TernaryExecutor::ExecuteWithNulls<interval_t, T, T, T>(
-		    bucket_width_arg, ts_arg, origin_arg, result, args.size(),
-		    TimeBucket::OriginTernaryOperator::Operation<interval_t, T, T, T>);
-	}
-}
-
-ScalarFunctionSet TimeBucketFun::GetFunctions() {
-	ScalarFunctionSet time_bucket;
-	time_bucket.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::DATE}, LogicalType::DATE, TimeBucketFunction<date_t>));
-	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                       TimeBucketFunction<timestamp_t>));
-	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::DATE, LogicalType::INTERVAL},
-	                                       LogicalType::DATE, TimeBucketOffsetFunction<date_t>));
-	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                       LogicalType::TIMESTAMP, TimeBucketOffsetFunction<timestamp_t>));
-	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::DATE, LogicalType::DATE},
-	                                       LogicalType::DATE, TimeBucketOriginFunction<date_t>));
-	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
-	                                       LogicalType::TIMESTAMP, TimeBucketOriginFunction<timestamp_t>));
-	for (auto &func : time_bucket.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return time_bucket;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp b/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp
deleted file mode 100644
index c8d508883..000000000
--- a/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-#include "core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/function/to_interval.hpp"
-
-namespace duckdb {
-
-template <>
-bool TryMultiplyOperator::Operation(double left, int64_t right, int64_t &result) {
-	return TryCast::Operation<double, int64_t>(left * double(right), result);
-}
-
-struct ToMillenniaOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.days = 0;
-		result.micros = 0;
-		if (!TryMultiplyOperator::Operation<TA, int32_t, int32_t>(input, Interval::MONTHS_PER_MILLENIUM,
-		                                                          result.months)) {
-			throw OutOfRangeException("Interval value %s millennia out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-struct ToCenturiesOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.days = 0;
-		result.micros = 0;
-		if (!TryMultiplyOperator::Operation<TA, int32_t, int32_t>(input, Interval::MONTHS_PER_CENTURY, result.months)) {
-			throw OutOfRangeException("Interval value %s centuries out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-struct ToDecadesOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.days = 0;
-		result.micros = 0;
-		if (!TryMultiplyOperator::Operation<TA, int32_t, int32_t>(input, Interval::MONTHS_PER_DECADE, result.months)) {
-			throw OutOfRangeException("Interval value %s decades out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-struct ToYearsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.days = 0;
-		result.micros = 0;
-		if (!TryMultiplyOperator::Operation<int32_t, int32_t, int32_t>(input, Interval::MONTHS_PER_YEAR,
-		                                                               result.months)) {
-			throw OutOfRangeException("Interval value %d years out of range", input);
-		}
-		return result;
-	}
-};
-
-struct ToQuartersOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		if (!TryMultiplyOperator::Operation<int32_t, int32_t, int32_t>(input, Interval::MONTHS_PER_QUARTER,
-		                                                               result.months)) {
-			throw OutOfRangeException("Interval value %d quarters out of range", input);
-		}
-		result.days = 0;
-		result.micros = 0;
-		return result;
-	}
-};
-
-struct ToMonthsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = input;
-		result.days = 0;
-		result.micros = 0;
-		return result;
-	}
-};
-
-struct ToWeeksOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		if (!TryMultiplyOperator::Operation<int32_t, int32_t, int32_t>(input, Interval::DAYS_PER_WEEK, result.days)) {
-			throw OutOfRangeException("Interval value %d weeks out of range", input);
-		}
-		result.micros = 0;
-		return result;
-	}
-};
-
-struct ToDaysOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = input;
-		result.micros = 0;
-		return result;
-	}
-};
-
-struct ToHoursOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<TA, int64_t, int64_t>(input, Interval::MICROS_PER_HOUR, result.micros)) {
-			throw OutOfRangeException("Interval value %s hours out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-struct ToMinutesOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<TA, int64_t, int64_t>(input, Interval::MICROS_PER_MINUTE, result.micros)) {
-			throw OutOfRangeException("Interval value %s minutes out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-struct ToMilliSecondsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<TA, int64_t, int64_t>(input, Interval::MICROS_PER_MSEC, result.micros)) {
-			throw OutOfRangeException("Interval value %s milliseconds out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-struct ToMicroSecondsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		result.micros = input;
-		return result;
-	}
-};
-
-ScalarFunction ToMillenniaFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToCenturiesFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToDecadesFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToYearsFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToQuartersFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToMonthsFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToWeeksFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToDaysFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToHoursFun::GetFunction() {
-	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToMinutesFun::GetFunction() {
-	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToSecondsFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToMillisecondsFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunction ToMicrosecondsFun::GetFunction() {
-	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/debug/vector_type.cpp b/src/duckdb/extension/core_functions/scalar/debug/vector_type.cpp
deleted file mode 100644
index 627d7ac28..000000000
--- a/src/duckdb/extension/core_functions/scalar/debug/vector_type.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "core_functions/scalar/debug_functions.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-static void VectorTypeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	auto data = ConstantVector::GetData<string_t>(result);
-	data[0] = StringVector::AddString(result, EnumUtil::ToString(input.data[0].GetVectorType()));
-}
-
-ScalarFunction VectorTypeFun::GetFunction() {
-	auto vector_type_fun = ScalarFunction("vector_type",        // name of the function
-	                                      {LogicalType::ANY},   // argument list
-	                                      LogicalType::VARCHAR, // return type
-	                                      VectorTypeFunction);
-	vector_type_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return vector_type_fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/enum/enum_functions.cpp b/src/duckdb/extension/core_functions/scalar/enum/enum_functions.cpp
deleted file mode 100644
index a10ec381c..000000000
--- a/src/duckdb/extension/core_functions/scalar/enum/enum_functions.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-#include "core_functions/scalar/enum_functions.hpp"
-
-namespace duckdb {
-
-static void EnumFirstFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto types = input.GetTypes();
-	D_ASSERT(types.size() == 1);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(types[0]);
-	auto val = Value(enum_vector.GetValue(0));
-	result.Reference(val);
-}
-
-static void EnumLastFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto types = input.GetTypes();
-	D_ASSERT(types.size() == 1);
-	auto enum_size = EnumType::GetSize(types[0]);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(types[0]);
-	auto val = Value(enum_vector.GetValue(enum_size - 1));
-	result.Reference(val);
-}
-
-static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto types = input.GetTypes();
-	D_ASSERT(types.size() == 1);
-	auto enum_size = EnumType::GetSize(types[0]);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(types[0]);
-	vector<Value> enum_values;
-	for (idx_t i = 0; i < enum_size; i++) {
-		enum_values.emplace_back(enum_vector.GetValue(i));
-	}
-	auto val = Value::LIST(LogicalType::VARCHAR, enum_values);
-	result.Reference(val);
-}
-
-static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto types = input.GetTypes();
-	D_ASSERT(types.size() == 2);
-	idx_t start, end;
-	auto first_param = input.GetValue(0, 0);
-	auto second_param = input.GetValue(1, 0);
-
-	auto &enum_vector =
-	    first_param.IsNull() ? EnumType::GetValuesInsertOrder(types[1]) : EnumType::GetValuesInsertOrder(types[0]);
-
-	if (first_param.IsNull()) {
-		start = 0;
-	} else {
-		start = first_param.GetValue<uint32_t>();
-	}
-	if (second_param.IsNull()) {
-		end = EnumType::GetSize(types[0]);
-	} else {
-		end = second_param.GetValue<uint32_t>() + 1;
-	}
-	vector<Value> enum_values;
-	for (idx_t i = start; i < end; i++) {
-		enum_values.emplace_back(enum_vector.GetValue(i));
-	}
-	auto val = Value::LIST(LogicalType::VARCHAR, enum_values);
-	result.Reference(val);
-}
-
-static void EnumCodeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	result.Reinterpret(input.data[0]);
-}
-
-static void CheckEnumParameter(const Expression &expr) {
-	if (expr.HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-}
-
-unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	CheckEnumParameter(*arguments[0]);
-	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	return nullptr;
-}
-
-unique_ptr<FunctionData> BindEnumCodeFunction(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	CheckEnumParameter(*arguments[0]);
-	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-
-	auto phy_type = EnumType::GetPhysicalType(arguments[0]->return_type);
-	switch (phy_type) {
-	case PhysicalType::UINT8:
-		bound_function.return_type = LogicalType(LogicalTypeId::UTINYINT);
-		break;
-	case PhysicalType::UINT16:
-		bound_function.return_type = LogicalType(LogicalTypeId::USMALLINT);
-		break;
-	case PhysicalType::UINT32:
-		bound_function.return_type = LogicalType(LogicalTypeId::UINTEGER);
-		break;
-	case PhysicalType::UINT64:
-		bound_function.return_type = LogicalType(LogicalTypeId::UBIGINT);
-		break;
-	default:
-		throw InternalException("Unsupported Enum Internal Type");
-	}
-
-	return nullptr;
-}
-
-unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-	CheckEnumParameter(*arguments[0]);
-	CheckEnumParameter(*arguments[1]);
-	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM && arguments[0]->return_type != LogicalType::SQLNULL) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	if (arguments[1]->return_type.id() != LogicalTypeId::ENUM && arguments[1]->return_type != LogicalType::SQLNULL) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	if (arguments[0]->return_type == LogicalType::SQLNULL && arguments[1]->return_type == LogicalType::SQLNULL) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	if (arguments[0]->return_type.id() == LogicalTypeId::ENUM &&
-	    arguments[1]->return_type.id() == LogicalTypeId::ENUM &&
-	    arguments[0]->return_type != arguments[1]->return_type) {
-		throw BinderException("The parameters need to link to ONLY one enum OR be NULL ");
-	}
-	return nullptr;
-}
-
-ScalarFunction EnumFirstFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, EnumFirstFunction, BindEnumFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-ScalarFunction EnumLastFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, EnumLastFunction, BindEnumFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-ScalarFunction EnumCodeFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::ANY, EnumCodeFunction, BindEnumCodeFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-ScalarFunction EnumRangeFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR), EnumRangeFunction,
-	                          BindEnumFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-ScalarFunction EnumRangeBoundaryFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR),
-	                          EnumRangeBoundaryFunction, BindEnumRangeBoundaryFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/alias.cpp b/src/duckdb/extension/core_functions/scalar/generic/alias.cpp
deleted file mode 100644
index 4edadcaaf..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/alias.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-static void AliasFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	Value v(state.expr.GetAlias().empty() ? func_expr.children[0]->GetName() : state.expr.GetAlias());
-	result.Reference(v);
-}
-
-ScalarFunction AliasFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, AliasFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/binning.cpp b/src/duckdb/extension/core_functions/scalar/generic/binning.cpp
deleted file mode 100644
index 83f7c0700..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/binning.cpp
+++ /dev/null
@@ -1,508 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/generic_executor.hpp"
-#include "core_functions/scalar/generic_functions.hpp"
-
-namespace duckdb {
-
-static hugeint_t GetPreviousPowerOfTen(hugeint_t input) {
-	hugeint_t power_of_ten = 1;
-	while (power_of_ten < input) {
-		power_of_ten *= 10;
-	}
-	return power_of_ten / 10;
-}
-
-enum class NiceRounding { CEILING, ROUND };
-
-hugeint_t RoundToNumber(hugeint_t input, hugeint_t num, NiceRounding rounding) {
-	if (rounding == NiceRounding::ROUND) {
-		return (input + (num / 2)) / num * num;
-	} else {
-		return (input + (num - 1)) / num * num;
-	}
-}
-
-hugeint_t MakeNumberNice(hugeint_t input, hugeint_t step, NiceRounding rounding) {
-	// we consider numbers nice if they are divisible by 2 or 5 times the power-of-ten one lower than the current
-	// e.g. 120 is a nice number because it is divisible by 20
-	//      122 is not a nice number -> we make it nice by turning it into 120 [/20]
-	//      153 is not a nice number -> we make it nice by turning it into 150 [/50]
-	//      1220 is not a nice number -> we turn it into 1200                  [/200]
-	// first figure out the previous power of 10 (i.e. for 67 we return 10)
-	// now the power of ten is the power BELOW the current number
-	// i.e. for 67, it is not 10
-	// now we can get the 2 or 5 divisors
-	hugeint_t power_of_ten = GetPreviousPowerOfTen(step);
-	hugeint_t two = power_of_ten * 2;
-	hugeint_t five = power_of_ten;
-	if (power_of_ten * 3 <= step) {
-		two *= 5;
-	}
-	if (power_of_ten * 2 <= step) {
-		five *= 5;
-	}
-
-	// compute the closest round number by adding the divisor / 2 and truncating
-	// do this for both divisors
-	hugeint_t round_to_two = RoundToNumber(input, two, rounding);
-	hugeint_t round_to_five = RoundToNumber(input, five, rounding);
-	// now pick the closest number of the two (i.e. for 147 we pick 150, not 140)
-	if (AbsValue(input - round_to_two) < AbsValue(input - round_to_five)) {
-		return round_to_two;
-	} else {
-		return round_to_five;
-	}
-}
-
-static double GetPreviousPowerOfTen(double input) {
-	double power_of_ten = 1;
-	if (input < 1) {
-		while (power_of_ten > input) {
-			power_of_ten /= 10;
-		}
-		return power_of_ten;
-	}
-	while (power_of_ten < input) {
-		power_of_ten *= 10;
-	}
-	return power_of_ten / 10;
-}
-
-double RoundToNumber(double input, double num, NiceRounding rounding) {
-	double result;
-	if (rounding == NiceRounding::ROUND) {
-		result = std::round(input / num) * num;
-	} else {
-		result = std::ceil(input / num) * num;
-	}
-	if (!Value::IsFinite(result)) {
-		return input;
-	}
-	return result;
-}
-
-double MakeNumberNice(double input, const double step, NiceRounding rounding) {
-	if (input == 0) {
-		return 0;
-	}
-	// now the power of ten is the power BELOW the current number
-	// i.e. for 67, it is not 10
-	// now we can get the 2 or 5 divisors
-	double power_of_ten = GetPreviousPowerOfTen(step);
-	double two = power_of_ten * 2;
-	double five = power_of_ten;
-	if (power_of_ten * 3 <= step) {
-		two *= 5;
-	}
-	if (power_of_ten * 2 <= step) {
-		five *= 5;
-	}
-
-	double round_to_two = RoundToNumber(input, two, rounding);
-	double round_to_five = RoundToNumber(input, five, rounding);
-	// now pick the closest number of the two (i.e. for 147 we pick 150, not 140)
-	if (AbsValue(input - round_to_two) < AbsValue(input - round_to_five)) {
-		return round_to_two;
-	} else {
-		return round_to_five;
-	}
-}
-
-struct EquiWidthBinsInteger {
-	static constexpr LogicalTypeId LOGICAL_TYPE = LogicalTypeId::BIGINT;
-
-	static vector<PrimitiveType<int64_t>> Operation(const Expression &expr, int64_t input_min, int64_t input_max,
-	                                                idx_t bin_count, bool nice_rounding) {
-		vector<PrimitiveType<int64_t>> result;
-		// to prevent integer truncation from affecting the bin boundaries we calculate them with numbers multiplied by
-		// 1000 we then divide to get the actual boundaries
-		const auto FACTOR = hugeint_t(1000);
-		auto min = hugeint_t(input_min) * FACTOR;
-		auto max = hugeint_t(input_max) * FACTOR;
-
-		const hugeint_t span = max - min;
-		hugeint_t step = span / Hugeint::Convert(bin_count);
-		if (nice_rounding) {
-			// when doing nice rounding we try to make the max/step values nicer
-			hugeint_t new_step = MakeNumberNice(step, step, NiceRounding::ROUND);
-			hugeint_t new_max = RoundToNumber(max, new_step, NiceRounding::CEILING);
-			if (new_max != min && new_step != 0) {
-				max = new_max;
-				step = new_step;
-			}
-			// we allow for more bins when doing nice rounding since the bin count is approximate
-			bin_count *= 2;
-		}
-		for (hugeint_t bin_boundary = max; bin_boundary > min; bin_boundary -= step) {
-			const hugeint_t target_boundary = bin_boundary / FACTOR;
-			int64_t real_boundary = Hugeint::Cast<int64_t>(target_boundary);
-			if (!result.empty()) {
-				if (real_boundary < input_min || result.size() >= bin_count) {
-					// we can never generate input_min
-					break;
-				}
-				if (real_boundary == result.back().val) {
-					// we cannot generate the same value multiple times in a row - skip this step
-					continue;
-				}
-			}
-			result.push_back(real_boundary);
-		}
-		return result;
-	}
-};
-
-struct EquiWidthBinsDouble {
-	static constexpr LogicalTypeId LOGICAL_TYPE = LogicalTypeId::DOUBLE;
-
-	static vector<PrimitiveType<double>> Operation(const Expression &expr, double min, double input_max,
-	                                               idx_t bin_count, bool nice_rounding) {
-		double max = input_max;
-		if (!Value::IsFinite(min) || !Value::IsFinite(max)) {
-			throw InvalidInputException("equi_width_bucket does not support infinite or nan as min/max value");
-		}
-		vector<PrimitiveType<double>> result;
-		const double span = max - min;
-		double step;
-		if (!Value::IsFinite(span)) {
-			// max - min does not fit
-			step = max / static_cast<double>(bin_count) - min / static_cast<double>(bin_count);
-		} else {
-			step = span / static_cast<double>(bin_count);
-		}
-		const double step_power_of_ten = GetPreviousPowerOfTen(step);
-		if (nice_rounding) {
-			// when doing nice rounding we try to make the max/step values nicer
-			step = MakeNumberNice(step, step, NiceRounding::ROUND);
-			max = RoundToNumber(input_max, step, NiceRounding::CEILING);
-			// we allow for more bins when doing nice rounding since the bin count is approximate
-			bin_count *= 2;
-		}
-		if (step == 0) {
-			throw InternalException("step is 0!?");
-		}
-
-		const double round_multiplication = 10 / step_power_of_ten;
-		for (double bin_boundary = max; bin_boundary > min; bin_boundary -= step) {
-			// because floating point addition adds inaccuracies, we add rounding at every step
-			double real_boundary = bin_boundary;
-			if (nice_rounding) {
-				real_boundary = std::round(bin_boundary * round_multiplication) / round_multiplication;
-			}
-			if (!result.empty() && result.back().val == real_boundary) {
-				// skip this step
-				continue;
-			}
-			if (real_boundary <= min || result.size() >= bin_count) {
-				// we can never generate below input_min
-				break;
-			}
-			result.push_back(real_boundary);
-		}
-		return result;
-	}
-};
-
-void NextMonth(int32_t &year, int32_t &month) {
-	month++;
-	if (month == 13) {
-		year++;
-		month = 1;
-	}
-}
-
-void NextDay(int32_t &year, int32_t &month, int32_t &day) {
-	day++;
-	if (!Date::IsValid(year, month, day)) {
-		// day is out of range for month, move to next month
-		NextMonth(year, month);
-		day = 1;
-	}
-}
-
-void NextHour(int32_t &year, int32_t &month, int32_t &day, int32_t &hour) {
-	hour++;
-	if (hour >= 24) {
-		NextDay(year, month, day);
-		hour = 0;
-	}
-}
-
-void NextMinute(int32_t &year, int32_t &month, int32_t &day, int32_t &hour, int32_t &minute) {
-	minute++;
-	if (minute >= 60) {
-		NextHour(year, month, day, hour);
-		minute = 0;
-	}
-}
-
-void NextSecond(int32_t &year, int32_t &month, int32_t &day, int32_t &hour, int32_t &minute, int32_t &sec) {
-	sec++;
-	if (sec >= 60) {
-		NextMinute(year, month, day, hour, minute);
-		sec = 0;
-	}
-}
-
-timestamp_t MakeTimestampNice(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t minute, int32_t sec,
-                              int32_t micros, interval_t step) {
-	// how to make a timestamp nice depends on the step
-	if (step.months >= 12) {
-		// if the step involves one year or more, ceil to months
-		// set time component to 00:00:00.00
-		if (day > 1 || hour > 0 || minute > 0 || sec > 0 || micros > 0) {
-			// move to next month
-			NextMonth(year, month);
-			hour = minute = sec = micros = 0;
-			day = 1;
-		}
-	} else if (step.months > 0 || step.days >= 1) {
-		// if the step involves more than one day, ceil to days
-		if (hour > 0 || minute > 0 || sec > 0 || micros > 0) {
-			NextDay(year, month, day);
-			hour = minute = sec = micros = 0;
-		}
-	} else if (step.days > 0 || step.micros >= Interval::MICROS_PER_HOUR) {
-		// if the step involves more than one hour, ceil to hours
-		if (minute > 0 || sec > 0 || micros > 0) {
-			NextHour(year, month, day, hour);
-			minute = sec = micros = 0;
-		}
-	} else if (step.micros >= Interval::MICROS_PER_MINUTE) {
-		// if the step involves more than one minute, ceil to minutes
-		if (sec > 0 || micros > 0) {
-			NextMinute(year, month, day, hour, minute);
-			sec = micros = 0;
-		}
-	} else if (step.micros >= Interval::MICROS_PER_SEC) {
-		// if the step involves more than one second, ceil to seconds
-		if (micros > 0) {
-			NextSecond(year, month, day, hour, minute, sec);
-			micros = 0;
-		}
-	}
-	return Timestamp::FromDatetime(Date::FromDate(year, month, day), Time::FromTime(hour, minute, sec, micros));
-}
-
-int64_t RoundNumberToDivisor(int64_t number, int64_t divisor) {
-	return (number + (divisor / 2)) / divisor * divisor;
-}
-
-interval_t MakeIntervalNice(interval_t interval) {
-	if (interval.months >= 6) {
-		// if we have more than 6 months, we don't care about days
-		interval.days = 0;
-		interval.micros = 0;
-	} else if (interval.months > 0 || interval.days >= 5) {
-		// if we have any months or more than 5 days, we don't care about micros
-		interval.micros = 0;
-	} else if (interval.days > 0 || interval.micros >= 6 * Interval::MICROS_PER_HOUR) {
-		// if we any days or more than 6 hours, we want micros to be roundable by hours at least
-		interval.micros = RoundNumberToDivisor(interval.micros, Interval::MICROS_PER_HOUR);
-	} else if (interval.micros >= Interval::MICROS_PER_HOUR) {
-		// if we have more than an hour, we want micros to be divisible by quarter hours
-		interval.micros = RoundNumberToDivisor(interval.micros, Interval::MICROS_PER_MINUTE * 15);
-	} else if (interval.micros >= Interval::MICROS_PER_MINUTE * 10) {
-		// if we have more than 10 minutes, we want micros to be divisible by minutes
-		interval.micros = RoundNumberToDivisor(interval.micros, Interval::MICROS_PER_MINUTE);
-	} else if (interval.micros >= Interval::MICROS_PER_MINUTE) {
-		// if we have more than a minute, we want micros to be divisible by quarter minutes
-		interval.micros = RoundNumberToDivisor(interval.micros, Interval::MICROS_PER_SEC * 15);
-	} else if (interval.micros >= Interval::MICROS_PER_SEC * 10) {
-		// if we have more than 10 seconds, we want micros to be divisible by seconds
-		interval.micros = RoundNumberToDivisor(interval.micros, Interval::MICROS_PER_SEC);
-	}
-	return interval;
-}
-
-void GetTimestampComponents(timestamp_t input, int32_t &year, int32_t &month, int32_t &day, int32_t &hour,
-                            int32_t &minute, int32_t &sec, int32_t &micros) {
-	date_t date;
-	dtime_t time;
-
-	Timestamp::Convert(input, date, time);
-	Date::Convert(date, year, month, day);
-	Time::Convert(time, hour, minute, sec, micros);
-}
-
-struct EquiWidthBinsTimestamp {
-	static constexpr LogicalTypeId LOGICAL_TYPE = LogicalTypeId::TIMESTAMP;
-
-	static vector<PrimitiveType<timestamp_t>> Operation(const Expression &expr, timestamp_t input_min,
-	                                                    timestamp_t input_max, idx_t bin_count, bool nice_rounding) {
-		if (!Value::IsFinite(input_min) || !Value::IsFinite(input_max)) {
-			throw InvalidInputException(expr, "equi_width_bucket does not support infinite or nan as min/max value");
-		}
-
-		if (!nice_rounding) {
-			// if we are not doing nice rounding it is pretty simple - just interpolate between the timestamp values
-			auto interpolated_values =
-			    EquiWidthBinsInteger::Operation(expr, input_min.value, input_max.value, bin_count, false);
-
-			vector<PrimitiveType<timestamp_t>> result;
-			for (auto &val : interpolated_values) {
-				result.push_back(timestamp_t(val.val));
-			}
-			return result;
-		}
-		// fetch the components of the timestamps
-		int32_t min_year, min_month, min_day, min_hour, min_minute, min_sec, min_micros;
-		int32_t max_year, max_month, max_day, max_hour, max_minute, max_sec, max_micros;
-		GetTimestampComponents(input_min, min_year, min_month, min_day, min_hour, min_minute, min_sec, min_micros);
-		GetTimestampComponents(input_max, max_year, max_month, max_day, max_hour, max_minute, max_sec, max_micros);
-
-		// get the interval differences per component
-		// note: these can be negative (except for the largest non-zero difference)
-		interval_t interval_diff;
-		interval_diff.months = (max_year - min_year) * Interval::MONTHS_PER_YEAR + (max_month - min_month);
-		interval_diff.days = max_day - min_day;
-		interval_diff.micros = (max_hour - min_hour) * Interval::MICROS_PER_HOUR +
-		                       (max_minute - min_minute) * Interval::MICROS_PER_MINUTE +
-		                       (max_sec - min_sec) * Interval::MICROS_PER_SEC + (max_micros - min_micros);
-
-		double step_months = static_cast<double>(interval_diff.months) / static_cast<double>(bin_count);
-		double step_days = static_cast<double>(interval_diff.days) / static_cast<int32_t>(bin_count);
-		double step_micros = static_cast<double>(interval_diff.micros) / static_cast<double>(bin_count);
-		// since we truncate the months/days, propagate any fractional component to the unit below (i.e. 0.2 months
-		// becomes 6 days)
-		if (step_months > 0) {
-			double overflow_months = step_months - std::floor(step_months);
-			step_days += overflow_months * Interval::DAYS_PER_MONTH;
-		}
-		if (step_days > 0) {
-			double overflow_days = step_days - std::floor(step_days);
-			step_micros += overflow_days * Interval::MICROS_PER_DAY;
-		}
-		interval_t step;
-		step.months = static_cast<int32_t>(step_months);
-		step.days = static_cast<int32_t>(step_days);
-		step.micros = static_cast<int64_t>(step_micros);
-
-		// now we make the max, and the step nice
-		step = MakeIntervalNice(step);
-		timestamp_t timestamp_val =
-		    MakeTimestampNice(max_year, max_month, max_day, max_hour, max_minute, max_sec, max_micros, step);
-		if (step.months <= 0 && step.days <= 0 && step.micros <= 0) {
-			// interval must be at least one microsecond
-			step.months = step.days = 0;
-			step.micros = 1;
-		}
-
-		vector<PrimitiveType<timestamp_t>> result;
-		while (timestamp_val.value >= input_min.value && result.size() < bin_count) {
-			result.push_back(timestamp_val);
-			timestamp_val = SubtractOperator::Operation<timestamp_t, interval_t, timestamp_t>(timestamp_val, step);
-		}
-		return result;
-	}
-};
-
-unique_ptr<FunctionData> BindEquiWidthFunction(ClientContext &, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	// while internally the bins are computed over a unified type
-	// the equi_width_bins function returns the same type as the input MAX
-	LogicalType child_type;
-	switch (arguments[1]->return_type.id()) {
-	case LogicalTypeId::UNKNOWN:
-	case LogicalTypeId::SQLNULL:
-		return nullptr;
-	case LogicalTypeId::DECIMAL:
-		// for decimals we promote to double because
-		child_type = LogicalType::DOUBLE;
-		break;
-	default:
-		child_type = arguments[1]->return_type;
-		break;
-	}
-	bound_function.return_type = LogicalType::LIST(child_type);
-	return nullptr;
-}
-
-template <class T, class OP>
-static void EquiWidthBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	static constexpr int64_t MAX_BIN_COUNT = 1000000;
-	auto &min_arg = args.data[0];
-	auto &max_arg = args.data[1];
-	auto &bin_count = args.data[2];
-	auto &nice_rounding = args.data[3];
-
-	Vector intermediate_result(LogicalType::LIST(OP::LOGICAL_TYPE));
-	GenericExecutor::ExecuteQuaternary<PrimitiveType<T>, PrimitiveType<T>, PrimitiveType<int64_t>, PrimitiveType<bool>,
-	                                   GenericListType<PrimitiveType<T>>>(
-	    min_arg, max_arg, bin_count, nice_rounding, intermediate_result, args.size(),
-	    [&](PrimitiveType<T> min_p, PrimitiveType<T> max_p, PrimitiveType<int64_t> bins_p,
-	        PrimitiveType<bool> nice_rounding_p) {
-		    if (max_p.val < min_p.val) {
-			    throw InvalidInputException(state.expr,
-			                                "Invalid input for bin function - max value is smaller than min value");
-		    }
-		    if (bins_p.val <= 0) {
-			    throw InvalidInputException(state.expr, "Invalid input for bin function - there must be > 0 bins");
-		    }
-		    if (bins_p.val > MAX_BIN_COUNT) {
-			    throw InvalidInputException(state.expr, "Invalid input for bin function - max bin count of %d exceeded",
-			                                MAX_BIN_COUNT);
-		    }
-		    GenericListType<PrimitiveType<T>> result_bins;
-		    if (max_p.val == min_p.val) {
-			    // if max = min return a single bucket
-			    result_bins.values.push_back(max_p.val);
-		    } else {
-			    result_bins.values = OP::Operation(state.expr, min_p.val, max_p.val, static_cast<idx_t>(bins_p.val),
-			                                       nice_rounding_p.val);
-			    // last bin should always be the input max
-			    if (result_bins.values[0].val < max_p.val) {
-				    result_bins.values[0].val = max_p.val;
-			    }
-			    std::reverse(result_bins.values.begin(), result_bins.values.end());
-		    }
-		    return result_bins;
-	    });
-	VectorOperations::DefaultCast(intermediate_result, result, args.size());
-}
-
-static void UnsupportedEquiWidth(DataChunk &args, ExpressionState &state, Vector &) {
-	throw BinderException(state.expr, "Unsupported type \"%s\" for equi_width_bins", args.data[0].GetType());
-}
-
-void EquiWidthBinSerialize(Serializer &, const optional_ptr<FunctionData>, const ScalarFunction &) {
-	return;
-}
-
-unique_ptr<FunctionData> EquiWidthBinDeserialize(Deserializer &deserializer, ScalarFunction &function) {
-	function.return_type = deserializer.Get<const LogicalType &>();
-	return nullptr;
-}
-
-ScalarFunctionSet EquiWidthBinsFun::GetFunctions() {
-	ScalarFunctionSet functions("equi_width_bins");
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BOOLEAN},
-	                   LogicalType::LIST(LogicalType::ANY), EquiWidthBinFunction<int64_t, EquiWidthBinsInteger>,
-	                   BindEquiWidthFunction));
-	functions.AddFunction(ScalarFunction(
-	    {LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::BIGINT, LogicalType::BOOLEAN},
-	    LogicalType::LIST(LogicalType::ANY), EquiWidthBinFunction<double, EquiWidthBinsDouble>, BindEquiWidthFunction));
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::BIGINT, LogicalType::BOOLEAN},
-	                   LogicalType::LIST(LogicalType::ANY), EquiWidthBinFunction<timestamp_t, EquiWidthBinsTimestamp>,
-	                   BindEquiWidthFunction));
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::ANY_PARAMS(LogicalType::ANY, 150), LogicalType::ANY_PARAMS(LogicalType::ANY, 150),
-	                    LogicalType::BIGINT, LogicalType::BOOLEAN},
-	                   LogicalType::LIST(LogicalType::ANY), UnsupportedEquiWidth, BindEquiWidthFunction));
-	for (auto &function : functions.functions) {
-		function.serialize = EquiWidthBinSerialize;
-		function.deserialize = EquiWidthBinDeserialize;
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/can_implicitly_cast.cpp b/src/duckdb/extension/core_functions/scalar/generic/can_implicitly_cast.cpp
deleted file mode 100644
index 5db38d601..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/can_implicitly_cast.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/cast_rules.hpp"
-
-namespace duckdb {
-
-bool CanCastImplicitly(ClientContext &context, const LogicalType &source, const LogicalType &target) {
-	return CastFunctionSet::Get(context).ImplicitCastCost(source, target) >= 0;
-}
-
-static void CanCastImplicitlyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &context = state.GetContext();
-	bool can_cast_implicitly = CanCastImplicitly(context, args.data[0].GetType(), args.data[1].GetType());
-	auto v = Value::BOOLEAN(can_cast_implicitly);
-	result.Reference(v);
-}
-
-unique_ptr<Expression> BindCanCastImplicitlyExpression(FunctionBindExpressionInput &input) {
-	auto &source_type = input.function.children[0]->return_type;
-	auto &target_type = input.function.children[1]->return_type;
-	if (source_type.id() == LogicalTypeId::UNKNOWN || source_type.id() == LogicalTypeId::SQLNULL ||
-	    target_type.id() == LogicalTypeId::UNKNOWN || target_type.id() == LogicalTypeId::SQLNULL) {
-		// parameter - unknown return type
-		return nullptr;
-	}
-	// emit a constant expression
-	return make_uniq<BoundConstantExpression>(
-	    Value::BOOLEAN(CanCastImplicitly(input.context, source_type, target_type)));
-}
-
-ScalarFunction CanCastImplicitlyFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::BOOLEAN, CanCastImplicitlyFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.bind_expression = BindCanCastImplicitlyExpression;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/current_setting.cpp b/src/duckdb/extension/core_functions/scalar/generic/current_setting.cpp
deleted file mode 100644
index b983b27cd..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/current_setting.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "core_functions/scalar/generic_functions.hpp"
-
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/catalog/catalog.hpp"
-namespace duckdb {
-
-struct CurrentSettingBindData : public FunctionData {
-	explicit CurrentSettingBindData(Value value_p) : value(std::move(value_p)) {
-	}
-
-	Value value;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<CurrentSettingBindData>(value);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<CurrentSettingBindData>();
-		return Value::NotDistinctFrom(value, other.value);
-	}
-};
-
-static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<CurrentSettingBindData>();
-	result.Reference(info.value);
-}
-
-unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-
-	auto &key_child = arguments[0];
-	if (key_child->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	if (key_child->return_type.id() != LogicalTypeId::VARCHAR ||
-	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
-		throw ParserException("Key name for current_setting needs to be a constant string");
-	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
-	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	if (key_val.IsNull() || StringValue::Get(key_val).empty()) {
-		throw ParserException("Key name for current_setting needs to be neither NULL nor empty");
-	}
-
-	auto key = StringUtil::Lower(StringValue::Get(key_val));
-	Value val;
-	if (!context.TryGetCurrentSetting(key, val)) {
-		Catalog::AutoloadExtensionByConfigName(context, key);
-		// If autoloader didn't throw, the config is now available
-		context.TryGetCurrentSetting(key, val);
-	}
-
-	bound_function.return_type = val.type();
-	return make_uniq<CurrentSettingBindData>(val);
-}
-
-ScalarFunction CurrentSettingFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::VARCHAR}, LogicalType::ANY, CurrentSettingFunction, CurrentSettingBind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/hash.cpp b/src/duckdb/extension/core_functions/scalar/generic/hash.cpp
deleted file mode 100644
index 184919447..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/hash.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "core_functions/scalar/generic_functions.hpp"
-
-namespace duckdb {
-
-static void HashFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	args.Hash(result);
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-ScalarFunction HashFun::GetFunction() {
-	auto hash_fun = ScalarFunction({LogicalType::ANY}, LogicalType::HASH, HashFunction);
-	hash_fun.varargs = LogicalType::ANY;
-	hash_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return hash_fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/least.cpp b/src/duckdb/extension/core_functions/scalar/generic/least.cpp
deleted file mode 100644
index 40a943101..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/least.cpp
+++ /dev/null
@@ -1,259 +0,0 @@
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct LeastOp {
-	using OP = LessThan;
-
-	static OrderByNullType NullOrdering() {
-		return OrderByNullType::NULLS_LAST;
-	}
-};
-
-struct GreaterOp {
-	using OP = GreaterThan;
-
-	static OrderByNullType NullOrdering() {
-		return OrderByNullType::NULLS_FIRST;
-	}
-};
-
-template <class OP>
-struct LeastOperator {
-	template <class T>
-	static T Operation(T left, T right) {
-		return OP::Operation(left, right) ? left : right;
-	}
-};
-
-struct LeastGreatestSortKeyState : public FunctionLocalState {
-	explicit LeastGreatestSortKeyState(idx_t column_count, OrderByNullType null_ordering)
-	    : intermediate(LogicalType::BLOB), modifiers(OrderType::ASCENDING, null_ordering) {
-		vector<LogicalType> types;
-		// initialize sort key chunk
-		for (idx_t i = 0; i < column_count; i++) {
-			types.push_back(LogicalType::BLOB);
-		}
-		sort_keys.Initialize(Allocator::DefaultAllocator(), types);
-	}
-
-	DataChunk sort_keys;
-	Vector intermediate;
-	OrderModifiers modifiers;
-};
-
-template <class OP>
-unique_ptr<FunctionLocalState> LeastGreatestSortKeyInit(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                        FunctionData *bind_data) {
-	return make_uniq<LeastGreatestSortKeyState>(expr.children.size(), OP::NullOrdering());
-}
-
-template <bool STRING>
-struct StandardLeastGreatest {
-	static constexpr bool IS_STRING = STRING;
-
-	static DataChunk &Prepare(DataChunk &args, ExpressionState &) {
-		return args;
-	}
-
-	static Vector &TargetVector(Vector &result, ExpressionState &) {
-		return result;
-	}
-
-	static void FinalizeResult(idx_t rows, bool result_has_value[], Vector &result, ExpressionState &) {
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < rows; i++) {
-			if (!result_has_value[i]) {
-				result_mask.SetInvalid(i);
-			}
-		}
-	}
-};
-
-struct SortKeyLeastGreatest {
-	static constexpr bool IS_STRING = false;
-
-	static DataChunk &Prepare(DataChunk &args, ExpressionState &state) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<LeastGreatestSortKeyState>();
-		lstate.sort_keys.Reset();
-		for (idx_t c_idx = 0; c_idx < args.ColumnCount(); c_idx++) {
-			CreateSortKeyHelpers::CreateSortKey(args.data[c_idx], args.size(), lstate.modifiers,
-			                                    lstate.sort_keys.data[c_idx]);
-		}
-		lstate.sort_keys.SetCardinality(args.size());
-		return lstate.sort_keys;
-	}
-
-	static Vector &TargetVector(Vector &result, ExpressionState &state) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<LeastGreatestSortKeyState>();
-		return lstate.intermediate;
-	}
-
-	static void FinalizeResult(idx_t rows, bool result_has_value[], Vector &result, ExpressionState &state) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<LeastGreatestSortKeyState>();
-		auto result_keys = FlatVector::GetData<string_t>(lstate.intermediate);
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < rows; i++) {
-			if (!result_has_value[i]) {
-				result_mask.SetInvalid(i);
-			} else {
-				CreateSortKeyHelpers::DecodeSortKey(result_keys[i], result, i, lstate.modifiers);
-			}
-		}
-	}
-};
-
-template <class T, class OP, class BASE_OP = StandardLeastGreatest<false>>
-static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	if (args.ColumnCount() == 1) {
-		// single input: nop
-		result.Reference(args.data[0]);
-		return;
-	}
-	auto &input = BASE_OP::Prepare(args, state);
-	auto &result_vector = BASE_OP::TargetVector(result, state);
-
-	auto result_type = VectorType::CONSTANT_VECTOR;
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			// non-constant input: result is not a constant vector
-			result_type = VectorType::FLAT_VECTOR;
-		}
-		if (BASE_OP::IS_STRING) {
-			// for string vectors we add a reference to the heap of the children
-			StringVector::AddHeapReference(result_vector, input.data[col_idx]);
-		}
-	}
-
-	auto result_data = FlatVector::GetData<T>(result_vector);
-	bool result_has_value[STANDARD_VECTOR_SIZE] {false};
-	// perform the operation column-by-column
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		if (input.data[col_idx].GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    ConstantVector::IsNull(input.data[col_idx])) {
-			// ignore null vector
-			continue;
-		}
-
-		UnifiedVectorFormat vdata;
-		input.data[col_idx].ToUnifiedFormat(input.size(), vdata);
-
-		auto input_data = UnifiedVectorFormat::GetData<T>(vdata);
-		if (!vdata.validity.AllValid()) {
-			// potential new null entries: have to check the null mask
-			for (idx_t i = 0; i < input.size(); i++) {
-				auto vindex = vdata.sel->get_index(i);
-				if (vdata.validity.RowIsValid(vindex)) {
-					// not a null entry: perform the operation and add to new set
-					auto ivalue = input_data[vindex];
-					if (!result_has_value[i] || OP::template Operation<T>(ivalue, result_data[i])) {
-						result_has_value[i] = true;
-						result_data[i] = ivalue;
-					}
-				}
-			}
-		} else {
-			// no new null entries: only need to perform the operation
-			for (idx_t i = 0; i < input.size(); i++) {
-				auto vindex = vdata.sel->get_index(i);
-
-				auto ivalue = input_data[vindex];
-				if (!result_has_value[i] || OP::template Operation<T>(ivalue, result_data[i])) {
-					result_has_value[i] = true;
-					result_data[i] = ivalue;
-				}
-			}
-		}
-	}
-	BASE_OP::FinalizeResult(input.size(), result_has_value, result, state);
-	result.SetVectorType(result_type);
-}
-
-template <class LEAST_GREATER_OP>
-unique_ptr<FunctionData> BindLeastGreatest(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	LogicalType child_type = ExpressionBinder::GetExpressionReturnType(*arguments[0]);
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		auto arg_type = ExpressionBinder::GetExpressionReturnType(*arguments[i]);
-		if (!LogicalType::TryGetMaxLogicalType(context, child_type, arg_type, child_type)) {
-			throw BinderException(arguments[i]->GetQueryLocation(),
-			                      "Cannot combine types of %s and %s - an explicit cast is required",
-			                      child_type.ToString(), arg_type.ToString());
-		}
-	}
-	switch (child_type.id()) {
-	case LogicalTypeId::UNKNOWN:
-		throw ParameterNotResolvedException();
-	case LogicalTypeId::INTEGER_LITERAL:
-		child_type = IntegerLiteral::GetType(child_type);
-		break;
-	case LogicalTypeId::STRING_LITERAL:
-		child_type = LogicalType::VARCHAR;
-		break;
-	default:
-		break;
-	}
-	using OP = typename LEAST_GREATER_OP::OP;
-	switch (child_type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		bound_function.function = LeastGreatestFunction<int8_t, OP>;
-		break;
-	case PhysicalType::INT16:
-		bound_function.function = LeastGreatestFunction<int16_t, OP>;
-		break;
-	case PhysicalType::INT32:
-		bound_function.function = LeastGreatestFunction<int32_t, OP>;
-		break;
-	case PhysicalType::INT64:
-		bound_function.function = LeastGreatestFunction<int64_t, OP>;
-		break;
-	case PhysicalType::INT128:
-		bound_function.function = LeastGreatestFunction<hugeint_t, OP>;
-		break;
-	case PhysicalType::DOUBLE:
-		bound_function.function = LeastGreatestFunction<double, OP>;
-		break;
-	case PhysicalType::VARCHAR:
-		bound_function.function = LeastGreatestFunction<string_t, OP, StandardLeastGreatest<true>>;
-		break;
-#endif
-	default:
-		// fallback with sort keys
-		bound_function.function = LeastGreatestFunction<string_t, OP, SortKeyLeastGreatest>;
-		bound_function.init_local_state = LeastGreatestSortKeyInit<LEAST_GREATER_OP>;
-		break;
-	}
-	bound_function.arguments[0] = child_type;
-	bound_function.varargs = child_type;
-	bound_function.return_type = child_type;
-	return nullptr;
-}
-
-template <class OP>
-ScalarFunction GetLeastGreatestFunction() {
-	return ScalarFunction({LogicalType::ANY}, LogicalType::ANY, nullptr, BindLeastGreatest<OP>, nullptr, nullptr,
-	                      nullptr, LogicalType::ANY, FunctionStability::CONSISTENT,
-	                      FunctionNullHandling::SPECIAL_HANDLING);
-}
-
-template <class OP>
-static ScalarFunctionSet GetLeastGreatestFunctions() {
-	ScalarFunctionSet fun_set;
-	fun_set.AddFunction(GetLeastGreatestFunction<OP>());
-	return fun_set;
-}
-
-ScalarFunctionSet LeastFun::GetFunctions() {
-	return GetLeastGreatestFunctions<LeastOp>();
-}
-
-ScalarFunctionSet GreatestFun::GetFunctions() {
-	return GetLeastGreatestFunctions<GreaterOp>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/stats.cpp b/src/duckdb/extension/core_functions/scalar/generic/stats.cpp
deleted file mode 100644
index ad3f4cd09..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/stats.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct StatsBindData : public FunctionData {
-	explicit StatsBindData(string stats_p = string()) : stats(std::move(stats_p)) {
-	}
-
-	string stats;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StatsBindData>(stats);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<StatsBindData>();
-		return stats == other.stats;
-	}
-};
-
-static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StatsBindData>();
-	if (info.stats.empty()) {
-		info.stats = "No statistics";
-	}
-	Value v(info.stats);
-	result.Reference(v);
-}
-
-unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound_function,
-                                   vector<unique_ptr<Expression>> &arguments) {
-	return make_uniq<StatsBindData>();
-}
-
-static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &bind_data = input.bind_data;
-	auto &info = bind_data->Cast<StatsBindData>();
-	info.stats = child_stats[0].ToString();
-	return nullptr;
-}
-
-ScalarFunction StatsFun::GetFunction() {
-	ScalarFunction stats({LogicalType::ANY}, LogicalType::VARCHAR, StatsFunction, StatsBind, nullptr,
-	                     StatsPropagateStats);
-	stats.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	stats.stability = FunctionStability::VOLATILE;
-	return stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/system_functions.cpp b/src/duckdb/extension/core_functions/scalar/generic/system_functions.cpp
deleted file mode 100644
index 5e4251c0b..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/system_functions.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-// current_query
-static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	Value val(state.GetContext().GetCurrentQuery());
-	result.Reference(val);
-}
-
-// current_schema
-static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	Value val(ClientData::Get(state.GetContext()).catalog_search_path->GetDefault().schema);
-	result.Reference(val);
-}
-
-// current_database
-static void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	Value val(DatabaseManager::GetDefaultDatabase(state.GetContext()));
-	result.Reference(val);
-}
-
-struct CurrentSchemasBindData : public FunctionData {
-	explicit CurrentSchemasBindData(Value result_value) : result(std::move(result_value)) {
-	}
-
-	Value result;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<CurrentSchemasBindData>(result);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<CurrentSchemasBindData>();
-		return Value::NotDistinctFrom(result, other.result);
-	}
-};
-
-static unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->return_type.id() != LogicalTypeId::BOOLEAN) {
-		throw BinderException("current_schemas requires a boolean input");
-	}
-	if (!arguments[0]->IsFoldable()) {
-		throw NotImplementedException("current_schemas requires a constant input");
-	}
-	Value schema_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-	Value result_val;
-	if (schema_value.IsNull()) {
-		// null
-		result_val = Value(LogicalType::LIST(LogicalType::VARCHAR));
-	} else {
-		auto implicit_schemas = BooleanValue::Get(schema_value);
-		vector<Value> schema_list;
-		auto &catalog_search_path = ClientData::Get(context).catalog_search_path;
-		auto &search_path = implicit_schemas ? catalog_search_path->Get() : catalog_search_path->GetSetPaths();
-		std::transform(search_path.begin(), search_path.end(), std::back_inserter(schema_list),
-		               [](const CatalogSearchEntry &s) -> Value { return Value(s.schema); });
-		result_val = Value::LIST(LogicalType::VARCHAR, schema_list);
-	}
-	return make_uniq<CurrentSchemasBindData>(std::move(result_val));
-}
-
-// current_schemas
-static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<CurrentSchemasBindData>();
-	result.Reference(info.result);
-}
-
-// in_search_path
-static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &context = state.GetContext();
-	auto &search_path = ClientData::Get(context).catalog_search_path;
-	BinaryExecutor::Execute<string_t, string_t, bool>(
-	    input.data[0], input.data[1], result, input.size(), [&](string_t db_name, string_t schema_name) {
-		    return search_path->SchemaInSearchPath(context, db_name.GetString(), schema_name.GetString());
-	    });
-}
-
-// txid_current
-static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &context = state.GetContext();
-	auto &catalog = Catalog::GetCatalog(context, DatabaseManager::GetDefaultDatabase(context));
-	auto &transaction = DuckTransaction::Get(context, catalog);
-	auto val = Value::UBIGINT(transaction.start_time);
-	result.Reference(val);
-}
-
-// version
-static void VersionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto val = Value(DuckDB::LibraryVersion());
-	result.Reference(val);
-}
-
-ScalarFunction CurrentQueryFun::GetFunction() {
-	ScalarFunction current_query({}, LogicalType::VARCHAR, CurrentQueryFunction);
-	current_query.stability = FunctionStability::VOLATILE;
-	return current_query;
-}
-
-ScalarFunction CurrentSchemaFun::GetFunction() {
-	ScalarFunction current_schema({}, LogicalType::VARCHAR, CurrentSchemaFunction);
-	current_schema.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return current_schema;
-}
-
-ScalarFunction CurrentDatabaseFun::GetFunction() {
-	ScalarFunction current_database({}, LogicalType::VARCHAR, CurrentDatabaseFunction);
-	current_database.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return current_database;
-}
-
-ScalarFunction CurrentSchemasFun::GetFunction() {
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	ScalarFunction current_schemas({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction,
-	                               CurrentSchemasBind);
-	current_schemas.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return current_schemas;
-}
-
-ScalarFunction InSearchPathFun::GetFunction() {
-	ScalarFunction in_search_path({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                              InSearchPathFunction);
-	in_search_path.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return in_search_path;
-}
-
-ScalarFunction CurrentTransactionIdFun::GetFunction() {
-	ScalarFunction txid_current({}, LogicalType::UBIGINT, TransactionIdCurrent);
-	txid_current.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
-	return txid_current;
-}
-
-ScalarFunction VersionFun::GetFunction() {
-	return ScalarFunction({}, LogicalType::VARCHAR, VersionFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp b/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp
deleted file mode 100644
index 1f7caef84..000000000
--- a/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "core_functions/scalar/generic_functions.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-static void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	Value v(args.data[0].GetType().ToString());
-	result.Reference(v);
-}
-
-unique_ptr<Expression> BindTypeOfFunctionExpression(FunctionBindExpressionInput &input) {
-	auto &return_type = input.function.children[0]->return_type;
-	if (return_type.id() == LogicalTypeId::UNKNOWN || return_type.id() == LogicalTypeId::SQLNULL) {
-		// parameter - unknown return type
-		return nullptr;
-	}
-	// emit a constant expression
-	return make_uniq<BoundConstantExpression>(Value(return_type.ToString()));
-}
-
-ScalarFunction TypeOfFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.bind_expression = BindTypeOfFunctionExpression;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp b/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp
deleted file mode 100644
index 0962b3c2e..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp
+++ /dev/null
@@ -1,460 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/swap.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-struct ListSliceBindData : public FunctionData {
-	ListSliceBindData(const LogicalType &return_type_p, bool begin_is_empty_p, bool end_is_empty_p)
-	    : return_type(return_type_p), begin_is_empty(begin_is_empty_p), end_is_empty(end_is_empty_p) {
-	}
-	~ListSliceBindData() override;
-
-	LogicalType return_type;
-
-	bool begin_is_empty;
-	bool end_is_empty;
-
-public:
-	bool Equals(const FunctionData &other_p) const override;
-	unique_ptr<FunctionData> Copy() const override;
-};
-
-ListSliceBindData::~ListSliceBindData() {
-}
-
-bool ListSliceBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ListSliceBindData>();
-	return return_type == other.return_type && begin_is_empty == other.begin_is_empty &&
-	       end_is_empty == other.end_is_empty;
-}
-
-unique_ptr<FunctionData> ListSliceBindData::Copy() const {
-	return make_uniq<ListSliceBindData>(return_type, begin_is_empty, end_is_empty);
-}
-
-template <typename INDEX_TYPE>
-static idx_t CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) {
-	if (step < 0) {
-		step = AbsValue(step);
-	}
-	if (step == 0 && svalid) {
-		throw InvalidInputException("Slice step cannot be zero");
-	}
-	if (step == 1) {
-		return NumericCast<idx_t>(end - begin);
-	} else if (static_cast<idx_t>(step) >= (end - begin)) {
-		return 1;
-	}
-	if ((end - begin) % UnsafeNumericCast<idx_t>(step) != 0) {
-		return (end - begin) / UnsafeNumericCast<idx_t>(step) + 1;
-	}
-	return (end - begin) / UnsafeNumericCast<idx_t>(step);
-}
-
-struct BlobSliceOperations {
-	static int64_t ValueLength(const string_t &value) {
-		return UnsafeNumericCast<int64_t>(value.GetSize());
-	}
-
-	static string_t SliceValue(Vector &result, string_t input, int64_t begin, int64_t end) {
-		return SubstringASCII(result, input, begin + 1, end - begin);
-	}
-
-	static string_t SliceValueWithSteps(Vector &result, SelectionVector &sel, string_t input, int64_t begin,
-	                                    int64_t end, int64_t step, idx_t &sel_idx) {
-		throw InternalException("Slicing with steps is not supported for strings");
-	}
-};
-
-struct StringSliceOperations {
-	static int64_t ValueLength(const string_t &value) {
-		return Length<string_t, int64_t>(value);
-	}
-
-	static string_t SliceValue(Vector &result, string_t input, int64_t begin, int64_t end) {
-		return SubstringUnicode(result, input, begin + 1, end - begin);
-	}
-
-	static string_t SliceValueWithSteps(Vector &result, SelectionVector &sel, string_t input, int64_t begin,
-	                                    int64_t end, int64_t step, idx_t &sel_idx) {
-		throw InternalException("Slicing with steps is not supported for strings");
-	}
-};
-
-struct ListSliceOperations {
-	static int64_t ValueLength(const list_entry_t &value) {
-		return UnsafeNumericCast<int64_t>(value.length);
-	}
-
-	static list_entry_t SliceValue(Vector &result, list_entry_t input, int64_t begin, int64_t end) {
-		input.offset = UnsafeNumericCast<uint64_t>(UnsafeNumericCast<int64_t>(input.offset) + begin);
-		input.length = UnsafeNumericCast<uint64_t>(end - begin);
-		return input;
-	}
-
-	static list_entry_t SliceValueWithSteps(Vector &result, SelectionVector &sel, list_entry_t input, int64_t begin,
-	                                        int64_t end, int64_t step, idx_t &sel_idx) {
-		if (end - begin == 0) {
-			input.length = 0;
-			input.offset = sel_idx;
-			return input;
-		}
-		input.length = CalculateSliceLength(UnsafeNumericCast<idx_t>(begin), UnsafeNumericCast<idx_t>(end), step, true);
-		idx_t child_idx = input.offset + UnsafeNumericCast<idx_t>(begin);
-		if (step < 0) {
-			child_idx = input.offset + UnsafeNumericCast<idx_t>(end) - 1;
-		}
-		input.offset = sel_idx;
-		for (idx_t i = 0; i < input.length; i++) {
-			sel.set_index(sel_idx, child_idx);
-			child_idx += static_cast<idx_t>(step); // intentional overflow??
-			sel_idx++;
-		}
-		return input;
-	}
-};
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-static void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE length, bool is_min) {
-	if (index < 0) {
-		index = (!is_min) ? index + 1 : index;
-		index = length + index;
-		return;
-	} else if (index > length) {
-		index = length;
-	}
-	return;
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
-	// Clamp offsets
-	begin = (begin != 0 && begin != (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) ? begin - 1 : begin;
-
-	bool is_min = false;
-	if (begin == (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) {
-		begin++;
-		is_min = true;
-	}
-
-	const auto length = OP::ValueLength(value);
-	if (begin < 0 && -begin > length && end < 0 && end < -length) {
-		begin = 0;
-		end = 0;
-		return true;
-	}
-	if (begin < 0 && -begin > length) {
-		begin = 0;
-	}
-	ClampIndex(begin, value, length, is_min);
-	ClampIndex(end, value, length, false);
-	end = MaxValue<INDEX_TYPE>(begin, end);
-
-	return true;
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vector, Vector &end_vector,
-                                 optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel,
-                                 idx_t &sel_idx, optional_ptr<Vector> result_child_vector, bool begin_is_empty,
-                                 bool end_is_empty) {
-
-	// check all this nullness early
-	auto str_valid = !ConstantVector::IsNull(str_vector);
-	auto begin_valid = !ConstantVector::IsNull(begin_vector);
-	auto end_valid = !ConstantVector::IsNull(end_vector);
-	auto step_valid = step_vector && !ConstantVector::IsNull(*step_vector);
-
-	if (!str_valid || !begin_valid || !end_valid || (step_vector && !step_valid)) {
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	auto result_data = ConstantVector::GetData<INPUT_TYPE>(result);
-	auto str_data = ConstantVector::GetData<INPUT_TYPE>(str_vector);
-	auto begin_data = ConstantVector::GetData<INDEX_TYPE>(begin_vector);
-	auto end_data = ConstantVector::GetData<INDEX_TYPE>(end_vector);
-	auto step_data = step_vector ? ConstantVector::GetData<INDEX_TYPE>(*step_vector) : nullptr;
-
-	auto str = str_data[0];
-	auto begin = begin_is_empty ? 0 : begin_data[0];
-	auto end = end_is_empty ? OP::ValueLength(str) : end_data[0];
-	auto step = step_data ? step_data[0] : 1;
-
-	if (step < 0) {
-		swap(begin, end);
-		begin = end_is_empty ? 0 : begin;
-		end = begin_is_empty ? OP::ValueLength(str) : end;
-	}
-
-	// Clamp offsets
-	bool clamp_result = false;
-	if (step_valid || step == 1) {
-		clamp_result = ClampSlice<INPUT_TYPE, INDEX_TYPE, OP>(str, begin, end);
-	}
-
-	idx_t sel_length = 0;
-	bool sel_valid = false;
-	if (step_valid && step != 1 && end - begin > 0) {
-		sel_length =
-		    CalculateSliceLength(UnsafeNumericCast<idx_t>(begin), UnsafeNumericCast<idx_t>(end), step, step_valid);
-		sel.Initialize(sel_length);
-		sel_valid = true;
-	}
-
-	// Try to slice
-	if (!clamp_result) {
-		ConstantVector::SetNull(result, true);
-	} else if (step == 1) {
-		result_data[0] = OP::SliceValue(result, str, begin, end);
-	} else {
-		result_data[0] = OP::SliceValueWithSteps(result, sel, str, begin, end, step, sel_idx);
-	}
-
-	if (sel_valid) {
-		result_child_vector->Slice(sel, sel_length);
-		result_child_vector->Flatten(sel_length);
-		ListVector::SetListSize(result, sel_length);
-	}
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector, Vector &end_vector,
-                             optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
-                             optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
-	UnifiedVectorFormat list_data, begin_data, end_data, step_data;
-	idx_t sel_length = 0;
-
-	list_vector.ToUnifiedFormat(count, list_data);
-	begin_vector.ToUnifiedFormat(count, begin_data);
-	end_vector.ToUnifiedFormat(count, end_data);
-	if (step_vector) {
-		step_vector->ToUnifiedFormat(count, step_data);
-		sel.Initialize(ListVector::GetListSize(list_vector));
-	}
-
-	auto result_data = FlatVector::GetData<INPUT_TYPE>(result);
-	auto &result_mask = FlatVector::Validity(result);
-
-	for (idx_t i = 0; i < count; ++i) {
-		auto list_idx = list_data.sel->get_index(i);
-		auto begin_idx = begin_data.sel->get_index(i);
-		auto end_idx = end_data.sel->get_index(i);
-		auto step_idx = step_vector ? step_data.sel->get_index(i) : 0;
-
-		auto list_valid = list_data.validity.RowIsValid(list_idx);
-		auto begin_valid = begin_data.validity.RowIsValid(begin_idx);
-		auto end_valid = end_data.validity.RowIsValid(end_idx);
-		auto step_valid = step_vector && step_data.validity.RowIsValid(step_idx);
-
-		if (!list_valid || !begin_valid || !end_valid || (step_vector && !step_valid)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-
-		auto sliced = reinterpret_cast<INPUT_TYPE *>(list_data.data)[list_idx];
-		auto begin = begin_is_empty ? 0 : reinterpret_cast<INDEX_TYPE *>(begin_data.data)[begin_idx];
-		auto end = end_is_empty ? OP::ValueLength(sliced) : reinterpret_cast<INDEX_TYPE *>(end_data.data)[end_idx];
-		auto step = step_vector ? reinterpret_cast<INDEX_TYPE *>(step_data.data)[step_idx] : 1;
-
-		if (step < 0) {
-			swap(begin, end);
-			begin = end_is_empty ? 0 : begin;
-			end = begin_is_empty ? OP::ValueLength(sliced) : end;
-		}
-
-		bool clamp_result = false;
-		if (step_valid || step == 1) {
-			clamp_result = ClampSlice<INPUT_TYPE, INDEX_TYPE, OP>(sliced, begin, end);
-		}
-
-		idx_t length = 0;
-		if (end - begin > 0) {
-			length =
-			    CalculateSliceLength(UnsafeNumericCast<idx_t>(begin), UnsafeNumericCast<idx_t>(end), step, step_valid);
-		}
-		sel_length += length;
-
-		if (!clamp_result) {
-			result_mask.SetInvalid(i);
-		} else if (!step_vector) {
-			result_data[i] = OP::SliceValue(result, sliced, begin, end);
-		} else {
-			result_data[i] = OP::SliceValueWithSteps(result, sel, sliced, begin, end, step, sel_idx);
-		}
-	}
-	if (step_vector) {
-		SelectionVector new_sel(sel_length);
-		for (idx_t i = 0; i < sel_length; ++i) {
-			new_sel.set_index(i, sel.get_index(i));
-		}
-		result_child_vector->Slice(new_sel, sel_length);
-		result_child_vector->Flatten(sel_length);
-		ListVector::SetListSize(result, sel_length);
-	}
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-static void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vector, Vector &end_vector,
-                         optional_ptr<Vector> step_vector, const idx_t count, bool begin_is_empty, bool end_is_empty) {
-	optional_ptr<Vector> result_child_vector;
-	if (step_vector) {
-		result_child_vector = &ListVector::GetEntry(result);
-	}
-
-	SelectionVector sel;
-	idx_t sel_idx = 0;
-
-	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		ExecuteConstantSlice<INPUT_TYPE, INDEX_TYPE, OP>(result, list_or_str_vector, begin_vector, end_vector,
-		                                                 step_vector, count, sel, sel_idx, result_child_vector,
-		                                                 begin_is_empty, end_is_empty);
-	} else {
-		ExecuteFlatSlice<INPUT_TYPE, INDEX_TYPE, OP>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
-		                                             count, sel, sel_idx, result_child_vector, begin_is_empty,
-		                                             end_is_empty);
-	}
-	result.Verify(count);
-}
-
-static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
-	D_ASSERT(args.data.size() == 3 || args.data.size() == 4);
-	auto count = args.size();
-
-	Vector &list_or_str_vector = result;
-	// this ensures that we do not change the input chunk
-	VectorOperations::Copy(args.data[0], list_or_str_vector, count, 0, 0);
-
-	if (list_or_str_vector.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	Vector &begin_vector = args.data[1];
-	Vector &end_vector = args.data[2];
-
-	optional_ptr<Vector> step_vector;
-	if (args.ColumnCount() == 4) {
-		step_vector = &args.data[3];
-	}
-
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<ListSliceBindData>();
-	auto begin_is_empty = info.begin_is_empty;
-	auto end_is_empty = info.end_is_empty;
-
-	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
-	switch (result.GetType().id()) {
-	case LogicalTypeId::LIST: {
-		// Share the value dictionary as we are just going to slice it
-		if (list_or_str_vector.GetVectorType() != VectorType::FLAT_VECTOR &&
-		    list_or_str_vector.GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			list_or_str_vector.Flatten(count);
-		}
-		ExecuteSlice<list_entry_t, int64_t, ListSliceOperations>(result, list_or_str_vector, begin_vector, end_vector,
-		                                                         step_vector, count, begin_is_empty, end_is_empty);
-		break;
-	}
-	case LogicalTypeId::BLOB:
-		ExecuteSlice<string_t, int64_t, BlobSliceOperations>(result, list_or_str_vector, begin_vector, end_vector,
-		                                                     step_vector, count, begin_is_empty, end_is_empty);
-		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteSlice<string_t, int64_t, StringSliceOperations>(result, list_or_str_vector, begin_vector, end_vector,
-		                                                       step_vector, count, begin_is_empty, end_is_empty);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented");
-	}
-}
-
-static bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
-	bool is_empty = false;
-	if (param->return_type.id() == LogicalTypeId::LIST) {
-		auto empty_list = make_uniq<BoundConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
-		is_empty = param->Equals(*empty_list);
-		if (!is_empty) {
-			// if the param is not empty, the user has entered a list instead of a BIGINT
-			throw BinderException("The upper and lower bounds of the slice must be a BIGINT");
-		}
-	}
-	return is_empty;
-}
-
-static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() == 3 || arguments.size() == 4);
-	D_ASSERT(bound_function.arguments.size() == 3 || bound_function.arguments.size() == 4);
-
-	switch (arguments[0]->return_type.id()) {
-	case LogicalTypeId::ARRAY: {
-		// Cast to list
-		auto child_type = ArrayType::GetChildType(arguments[0]->return_type);
-		auto target_type = LogicalType::LIST(child_type);
-		arguments[0] = BoundCastExpression::AddCastToType(context, std::move(arguments[0]), target_type);
-		bound_function.return_type = arguments[0]->return_type;
-	} break;
-	case LogicalTypeId::LIST:
-		// The result is the same type
-		bound_function.return_type = arguments[0]->return_type;
-		break;
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
-		// string slice returns a string
-		if (bound_function.arguments.size() == 4) {
-			throw NotImplementedException(
-			    "Slice with steps has not been implemented for string types, you can consider rewriting your query as "
-			    "follows:\n SELECT array_to_string((str_split(string, '')[begin:end:step], '');");
-		}
-		bound_function.return_type = arguments[0]->return_type;
-		for (idx_t i = 1; i < 3; i++) {
-			if (arguments[i]->return_type.id() != LogicalTypeId::LIST) {
-				bound_function.arguments[i] = LogicalType::BIGINT;
-			}
-		}
-		break;
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::UNKNOWN:
-		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
-		bound_function.return_type = LogicalType::SQLNULL;
-		break;
-	default:
-		throw BinderException("ARRAY_SLICE can only operate on LISTs and VARCHARs");
-	}
-
-	bool begin_is_empty = CheckIfParamIsEmpty(arguments[1]);
-	if (!begin_is_empty) {
-		bound_function.arguments[1] = LogicalType::BIGINT;
-	}
-	bool end_is_empty = CheckIfParamIsEmpty(arguments[2]);
-	if (!end_is_empty) {
-		bound_function.arguments[2] = LogicalType::BIGINT;
-	}
-
-	return make_uniq<ListSliceBindData>(bound_function.return_type, begin_is_empty, end_is_empty);
-}
-
-ScalarFunctionSet ListSliceFun::GetFunctions() {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,
-	                   ArraySliceBind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	BaseScalarFunction::SetReturnsError(fun);
-	ScalarFunctionSet set;
-	set.AddFunction(fun);
-	fun.arguments.push_back(LogicalType::BIGINT);
-	set.AddFunction(fun);
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/flatten.cpp b/src/duckdb/extension/core_functions/scalar/list/flatten.cpp
deleted file mode 100644
index 849c20d16..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/flatten.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/list_stats.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-
-	Vector &input = args.data[0];
-	if (input.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.Reference(input);
-		return;
-	}
-
-	idx_t count = args.size();
-
-	// Prepare the result vector
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	// This holds the new offsets and lengths
-	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	// The outermost list in each row
-	UnifiedVectorFormat row_data;
-	input.ToUnifiedFormat(count, row_data);
-	auto row_entries = UnifiedVectorFormat::GetData<list_entry_t>(row_data);
-
-	// The list elements in each row: [HERE, ...]
-	auto &row_lists = ListVector::GetEntry(input);
-	UnifiedVectorFormat row_lists_data;
-	idx_t total_row_lists = ListVector::GetListSize(input);
-	row_lists.ToUnifiedFormat(total_row_lists, row_lists_data);
-	auto row_lists_entries = UnifiedVectorFormat::GetData<list_entry_t>(row_lists_data);
-
-	if (row_lists.GetType().id() == LogicalTypeId::SQLNULL) {
-		for (idx_t row_cnt = 0; row_cnt < count; row_cnt++) {
-			auto row_idx = row_data.sel->get_index(row_cnt);
-			if (!row_data.validity.RowIsValid(row_idx)) {
-				result_validity.SetInvalid(row_cnt);
-				continue;
-			}
-			result_entries[row_cnt].offset = 0;
-			result_entries[row_cnt].length = 0;
-		}
-		if (args.AllConstant()) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-		return;
-	}
-
-	// The actual elements inside each row list: [[HERE, ...], []]
-	// This one becomes the child vector of the result.
-	auto &elem_vector = ListVector::GetEntry(row_lists);
-
-	// We'll use this selection vector to slice the elem_vector.
-	idx_t child_elem_cnt = ListVector::GetListSize(row_lists);
-	SelectionVector sel(child_elem_cnt);
-	idx_t sel_idx = 0;
-
-	// HERE, [[]], ...
-	for (idx_t row_cnt = 0; row_cnt < count; row_cnt++) {
-		auto row_idx = row_data.sel->get_index(row_cnt);
-
-		if (!row_data.validity.RowIsValid(row_idx)) {
-			result_validity.SetInvalid(row_cnt);
-			continue;
-		}
-
-		idx_t list_offset = sel_idx;
-		idx_t list_length = 0;
-
-		// [HERE, [...], ...]
-		auto row_entry = row_entries[row_idx];
-		for (idx_t row_lists_cnt = 0; row_lists_cnt < row_entry.length; row_lists_cnt++) {
-			auto row_lists_idx = row_lists_data.sel->get_index(row_entry.offset + row_lists_cnt);
-
-			// Skip invalid lists
-			if (!row_lists_data.validity.RowIsValid(row_lists_idx)) {
-				continue;
-			}
-
-			// [[HERE, ...], [.., ...]]
-			auto list_entry = row_lists_entries[row_lists_idx];
-			list_length += list_entry.length;
-
-			for (idx_t elem_cnt = 0; elem_cnt < list_entry.length; elem_cnt++) {
-				// offset of the element in the elem_vector.
-				idx_t offset = list_entry.offset + elem_cnt;
-				sel.set_index(sel_idx, offset);
-				sel_idx++;
-			}
-		}
-
-		result_entries[row_cnt].offset = list_offset;
-		result_entries[row_cnt].length = list_length;
-	}
-
-	ListVector::SetListSize(result, sel_idx);
-
-	auto &result_child_vector = ListVector::GetEntry(result);
-	result_child_vector.Slice(elem_vector, sel, sel_idx);
-	result_child_vector.Flatten(sel_idx);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 1);
-
-	if (arguments[0]->return_type.id() == LogicalTypeId::ARRAY) {
-		auto child_type = ArrayType::GetChildType(arguments[0]->return_type);
-		if (child_type.id() == LogicalTypeId::ARRAY) {
-			child_type = LogicalType::LIST(ArrayType::GetChildType(child_type));
-		}
-		arguments[0] =
-		    BoundCastExpression::AddCastToType(context, std::move(arguments[0]), LogicalType::LIST(child_type));
-	} else if (arguments[0]->return_type.id() == LogicalTypeId::LIST) {
-		auto child_type = ListType::GetChildType(arguments[0]->return_type);
-		if (child_type.id() == LogicalTypeId::ARRAY) {
-			child_type = LogicalType::LIST(ArrayType::GetChildType(child_type));
-			arguments[0] =
-			    BoundCastExpression::AddCastToType(context, std::move(arguments[0]), LogicalType::LIST(child_type));
-		}
-	}
-
-	auto &input_type = arguments[0]->return_type;
-	bound_function.arguments[0] = input_type;
-	if (input_type.id() == LogicalTypeId::UNKNOWN) {
-		bound_function.arguments[0] = LogicalType(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-	D_ASSERT(input_type.id() == LogicalTypeId::LIST);
-
-	auto child_type = ListType::GetChildType(input_type);
-	if (child_type.id() == LogicalType::SQLNULL) {
-		bound_function.return_type = input_type;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-	if (child_type.id() == LogicalTypeId::UNKNOWN) {
-		bound_function.arguments[0] = LogicalType(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-	D_ASSERT(child_type.id() == LogicalTypeId::LIST);
-
-	bound_function.return_type = child_type;
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &list_child_stats = ListStats::GetChildStats(child_stats[0]);
-	auto child_copy = list_child_stats.Copy();
-	child_copy.Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-	return child_copy.ToUnique();
-}
-
-ScalarFunction ListFlattenFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
-	                      ListFlattenFunction, ListFlattenBind, nullptr, ListFlattenStats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp b/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp
deleted file mode 100644
index 1b2aab71d..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp
+++ /dev/null
@@ -1,534 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "core_functions/aggregate/nested_functions.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/common/owning_string_map.hpp"
-
-namespace duckdb {
-
-// FIXME: use a local state for each thread to increase performance?
-// FIXME: benchmark the use of simple_update against using update (if applicable)
-
-static unique_ptr<FunctionData> ListAggregatesBindFailure(ScalarFunction &bound_function) {
-	bound_function.arguments[0] = LogicalType::SQLNULL;
-	bound_function.return_type = LogicalType::SQLNULL;
-	return make_uniq<VariableReturnBindData>(LogicalType::SQLNULL);
-}
-
-struct ListAggregatesBindData : public FunctionData {
-	ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p);
-	~ListAggregatesBindData() override;
-
-	LogicalType stype;
-	unique_ptr<Expression> aggr_expr;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<ListAggregatesBindData>(stype, aggr_expr->Copy());
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<ListAggregatesBindData>();
-		return stype == other.stype && aggr_expr->Equals(*other.aggr_expr);
-	}
-	void Serialize(Serializer &serializer) const {
-		serializer.WriteProperty(1, "stype", stype);
-		serializer.WriteProperty(2, "aggr_expr", aggr_expr);
-	}
-	static unique_ptr<ListAggregatesBindData> Deserialize(Deserializer &deserializer) {
-		auto stype = deserializer.ReadProperty<LogicalType>(1, "stype");
-		auto aggr_expr = deserializer.ReadProperty<unique_ptr<Expression>>(2, "aggr_expr");
-		auto result = make_uniq<ListAggregatesBindData>(std::move(stype), std::move(aggr_expr));
-		return result;
-	}
-
-	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                              const ScalarFunction &function) {
-		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p.get());
-		serializer.WritePropertyWithDefault(100, "bind_data", bind_data, (const ListAggregatesBindData *)nullptr);
-	}
-
-	static unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer, ScalarFunction &bound_function) {
-		auto result = deserializer.ReadPropertyWithExplicitDefault<unique_ptr<ListAggregatesBindData>>(
-		    100, "bind_data", unique_ptr<ListAggregatesBindData>(nullptr));
-		if (!result) {
-			return ListAggregatesBindFailure(bound_function);
-		}
-		return std::move(result);
-	}
-};
-
-ListAggregatesBindData::ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p)
-    : stype(stype_p), aggr_expr(std::move(aggr_expr_p)) {
-}
-
-ListAggregatesBindData::~ListAggregatesBindData() {
-}
-
-struct StateVector {
-	StateVector(idx_t count_p, unique_ptr<Expression> aggr_expr_p)
-	    : count(count_p), aggr_expr(std::move(aggr_expr_p)), state_vector(Vector(LogicalType::POINTER, count_p)) {
-	}
-
-	~StateVector() { // NOLINT
-		// destroy objects within the aggregate states
-		auto &aggr = aggr_expr->Cast<BoundAggregateExpression>();
-		if (aggr.function.destructor) {
-			ArenaAllocator allocator(Allocator::DefaultAllocator());
-			AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
-			aggr.function.destructor(state_vector, aggr_input_data, count);
-		}
-	}
-
-	idx_t count;
-	unique_ptr<Expression> aggr_expr;
-	Vector state_vector;
-};
-
-struct FinalizeValueFunctor {
-	template <class T>
-	static void HistogramFinalize(T value, Vector &result, idx_t offset) {
-		FlatVector::GetData<T>(result)[offset] = value;
-	}
-};
-
-struct FinalizeStringValueFunctor {
-	template <class T>
-	static void HistogramFinalize(T value, Vector &result, idx_t offset) {
-		FlatVector::GetData<string_t>(result)[offset] = StringVector::AddStringOrBlob(result, value);
-	}
-};
-
-struct FinalizeGenericValueFunctor {
-	template <class T>
-	static void HistogramFinalize(T value, Vector &result, idx_t offset) {
-		CreateSortKeyHelpers::DecodeSortKey(value, result, offset,
-		                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
-	}
-};
-
-struct AggregateFunctor {
-	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
-	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
-	}
-};
-
-struct DistinctFunctor {
-	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
-	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
-		UnifiedVectorFormat sdata;
-		state_vector.ToUnifiedFormat(count, sdata);
-		auto states = UnifiedVectorFormat::GetData<HistogramAggState<T, MAP_TYPE> *>(sdata);
-
-		auto old_len = ListVector::GetListSize(result);
-		idx_t new_entries = 0;
-		// figure out how much space we need
-		for (idx_t i = 0; i < count; i++) {
-			auto &state = *states[sdata.sel->get_index(i)];
-			if (!state.hist) {
-				continue;
-			}
-			new_entries += state.hist->size();
-		}
-		// reserve space in the list vector
-		ListVector::Reserve(result, old_len + new_entries);
-		auto &child_elements = ListVector::GetEntry(result);
-		auto list_entries = FlatVector::GetData<list_entry_t>(result);
-
-		idx_t current_offset = old_len;
-		for (idx_t i = 0; i < count; i++) {
-			const auto rid = i;
-			auto &state = *states[sdata.sel->get_index(i)];
-			auto &list_entry = list_entries[rid];
-			list_entry.offset = current_offset;
-			if (!state.hist) {
-				list_entry.length = 0;
-				continue;
-			}
-
-			for (auto &entry : *state.hist) {
-				OP::template HistogramFinalize<T>(entry.first, child_elements, current_offset);
-				current_offset++;
-			}
-			list_entry.length = current_offset - list_entry.offset;
-		}
-		D_ASSERT(current_offset == old_len + new_entries);
-		ListVector::SetListSize(result, current_offset);
-		result.Verify(count);
-	}
-};
-
-struct UniqueFunctor {
-	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
-	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
-		UnifiedVectorFormat sdata;
-		state_vector.ToUnifiedFormat(count, sdata);
-		auto states = UnifiedVectorFormat::GetData<HistogramAggState<T, MAP_TYPE> *>(sdata);
-
-		auto result_data = FlatVector::GetData<uint64_t>(result);
-		for (idx_t i = 0; i < count; i++) {
-
-			auto state = states[sdata.sel->get_index(i)];
-
-			if (!state->hist) {
-				result_data[i] = 0;
-				continue;
-			}
-			result_data[i] = state->hist->size();
-		}
-		result.Verify(count);
-	}
-};
-
-template <class FUNCTION_FUNCTOR, bool IS_AGGR = false>
-static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto count = args.size();
-	Vector &lists = args.data[0];
-
-	// set the result vector
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (lists.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	// get the aggregate function
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<ListAggregatesBindData>();
-	auto &aggr = info.aggr_expr->Cast<BoundAggregateExpression>();
-	ArenaAllocator allocator(Allocator::DefaultAllocator());
-	AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
-
-	D_ASSERT(aggr.function.update);
-
-	auto lists_size = ListVector::GetListSize(lists);
-	auto &child_vector = ListVector::GetEntry(lists);
-	child_vector.Flatten(lists_size);
-
-	UnifiedVectorFormat child_data;
-	child_vector.ToUnifiedFormat(lists_size, child_data);
-
-	UnifiedVectorFormat lists_data;
-	lists.ToUnifiedFormat(count, lists_data);
-	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
-
-	// state_buffer holds the state for each list of this chunk
-	idx_t size = aggr.function.state_size(aggr.function);
-	auto state_buffer = make_unsafe_uniq_array_uninitialized<data_t>(size * count);
-
-	// state vector for initialize and finalize
-	StateVector state_vector(count, info.aggr_expr->Copy());
-	auto states = FlatVector::GetData<data_ptr_t>(state_vector.state_vector);
-
-	// state vector of STANDARD_VECTOR_SIZE holds the pointers to the states
-	Vector state_vector_update = Vector(LogicalType::POINTER);
-	auto states_update = FlatVector::GetData<data_ptr_t>(state_vector_update);
-
-	// selection vector pointing to the data
-	SelectionVector sel_vector(STANDARD_VECTOR_SIZE);
-	idx_t states_idx = 0;
-
-	for (idx_t i = 0; i < count; i++) {
-
-		// initialize the state for this list
-		auto state_ptr = state_buffer.get() + size * i;
-		states[i] = state_ptr;
-		aggr.function.initialize(aggr.function, states[i]);
-
-		auto lists_index = lists_data.sel->get_index(i);
-		const auto &list_entry = list_entries[lists_index];
-
-		// nothing to do for this list
-		if (!lists_data.validity.RowIsValid(lists_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		// skip empty list
-		if (list_entry.length == 0) {
-			continue;
-		}
-
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-			// states vector is full, update
-			if (states_idx == STANDARD_VECTOR_SIZE) {
-				// update the aggregate state(s)
-				Vector slice(child_vector, sel_vector, states_idx);
-				aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
-
-				// reset values
-				states_idx = 0;
-			}
-
-			auto source_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			sel_vector.set_index(states_idx, source_idx);
-			states_update[states_idx] = state_ptr;
-			states_idx++;
-		}
-	}
-
-	// update the remaining elements of the last list(s)
-	if (states_idx != 0) {
-		Vector slice(child_vector, sel_vector, states_idx);
-		aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
-	}
-
-	if (IS_AGGR) {
-		// finalize all the aggregate states
-		aggr.function.finalize(state_vector.state_vector, aggr_input_data, result, count, 0);
-
-	} else {
-		// finalize manually to use the map
-		D_ASSERT(aggr.function.arguments.size() == 1);
-		auto key_type = aggr.function.arguments[0];
-
-		switch (key_type.InternalType()) {
-#ifndef DUCKDB_SMALLER_BINARY
-		case PhysicalType::BOOL:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, bool>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT8:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint8_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT16:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint16_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint32_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT8:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int8_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT16:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int16_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::FLOAT:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, float>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::DOUBLE:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, double>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::VARCHAR:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string_t,
-			                                               OwningStringMap<idx_t>>(result, state_vector.state_vector,
-			                                                                       count);
-			break;
-#endif
-		default:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeGenericValueFunctor, string_t,
-			                                               OwningStringMap<idx_t>>(result, state_vector.state_vector,
-			                                                                       count);
-			break;
-		}
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static void ListAggregateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() >= 2);
-	ListAggregatesFunction<AggregateFunctor, true>(args, state, result);
-}
-
-static void ListDistinctFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-	ListAggregatesFunction<DistinctFunctor>(args, state, result);
-}
-
-static void ListUniqueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-	ListAggregatesFunction<UniqueFunctor>(args, state, result);
-}
-
-template <bool IS_AGGR = false>
-static unique_ptr<FunctionData>
-ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_function, const LogicalType &list_child_type,
-                           AggregateFunction &aggr_function, vector<unique_ptr<Expression>> &arguments) {
-
-	// create the child expression and its type
-	vector<unique_ptr<Expression>> children;
-	auto expr = make_uniq<BoundConstantExpression>(Value(list_child_type));
-	children.push_back(std::move(expr));
-	// push any extra arguments into the list aggregate bind
-	if (arguments.size() > 2) {
-		for (idx_t i = 2; i < arguments.size(); i++) {
-			children.push_back(std::move(arguments[i]));
-		}
-		arguments.resize(2);
-	}
-
-	FunctionBinder function_binder(context);
-	auto bound_aggr_function = function_binder.BindAggregateFunction(aggr_function, std::move(children));
-	bound_function.arguments[0] = LogicalType::LIST(bound_aggr_function->function.arguments[0]);
-
-	if (IS_AGGR) {
-		bound_function.return_type = bound_aggr_function->function.return_type;
-	}
-	// check if the aggregate function consumed all the extra input arguments
-	if (bound_aggr_function->children.size() > 1) {
-		throw InvalidInputException(
-		    "Aggregate function %s is not supported for list_aggr: extra arguments were not removed during bind",
-		    bound_aggr_function->ToString());
-	}
-
-	return make_uniq<ListAggregatesBindData>(bound_function.return_type, std::move(bound_aggr_function));
-}
-
-template <bool IS_AGGR = false>
-static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		return ListAggregatesBindFailure(bound_function);
-	}
-
-	bool is_parameter = arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN;
-	LogicalType child_type;
-	if (is_parameter) {
-		child_type = LogicalType::ANY;
-	} else if (arguments[0]->return_type.id() == LogicalTypeId::LIST ||
-	           arguments[0]->return_type.id() == LogicalTypeId::MAP) {
-		child_type = ListType::GetChildType(arguments[0]->return_type);
-	} else {
-		// Unreachable
-		throw InvalidInputException("First argument of list aggregate must be a list, map or array");
-	}
-
-	string function_name = "histogram";
-	if (IS_AGGR) { // get the name of the aggregate function
-		if (!arguments[1]->IsFoldable()) {
-			throw InvalidInputException("Aggregate function name must be a constant");
-		}
-		// get the function name
-		Value function_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		function_name = function_value.ToString();
-	}
-
-	// look up the aggregate function in the catalog
-	auto &func = Catalog::GetSystemCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(context, DEFAULT_SCHEMA,
-	                                                                                        function_name);
-	D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-
-	if (is_parameter) {
-		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return nullptr;
-	}
-
-	// find a matching aggregate function
-	ErrorData error;
-	vector<LogicalType> types;
-	types.push_back(child_type);
-	// push any extra arguments into the type list
-	for (idx_t i = 2; i < arguments.size(); i++) {
-		types.push_back(arguments[i]->return_type);
-	}
-
-	FunctionBinder function_binder(context);
-	auto best_function_idx = function_binder.BindFunction(func.name, func.functions, types, error);
-	if (!best_function_idx.IsValid()) {
-		throw BinderException("No matching aggregate function\n%s", error.Message());
-	}
-
-	// found a matching function, bind it as an aggregate
-	auto best_function = func.functions.GetFunctionByOffset(best_function_idx.GetIndex());
-	if (IS_AGGR) {
-		bound_function.errors = best_function.errors;
-		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, child_type, best_function, arguments);
-	}
-
-	// create the unordered map histogram function
-	D_ASSERT(best_function.arguments.size() == 1);
-	auto aggr_function = HistogramFun::GetHistogramUnorderedMap(child_type);
-	return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, child_type, aggr_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-
-	// the list column and the name of the aggregate function
-	D_ASSERT(bound_function.arguments.size() >= 2);
-	D_ASSERT(arguments.size() >= 2);
-
-	return ListAggregatesBind<true>(context, bound_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListDistinctBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(bound_function.arguments.size() == 1);
-	D_ASSERT(arguments.size() == 1);
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-	bound_function.return_type = arguments[0]->return_type;
-
-	return ListAggregatesBind<>(context, bound_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListUniqueBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(bound_function.arguments.size() == 1);
-	D_ASSERT(arguments.size() == 1);
-	bound_function.return_type = LogicalType::UBIGINT;
-
-	return ListAggregatesBind<>(context, bound_function, arguments);
-}
-
-ScalarFunction ListAggregateFun::GetFunction() {
-	auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
-	                             ListAggregateFunction, ListAggregateBind);
-	BaseScalarFunction::SetReturnsError(result);
-	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	result.varargs = LogicalType::ANY;
-	result.serialize = ListAggregatesBindData::SerializeFunction;
-	result.deserialize = ListAggregatesBindData::DeserializeFunction;
-	return result;
-}
-
-ScalarFunction ListDistinctFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
-	                      ListDistinctFunction, ListDistinctBind);
-}
-
-ScalarFunction ListUniqueFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::UBIGINT, ListUniqueFunction,
-	                      ListUniqueBind);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp b/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp
deleted file mode 100644
index 5c3513b2a..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "core_functions/array_kernels.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-//------------------------------------------------------------------------------
-// Generic "fold" function
-//------------------------------------------------------------------------------
-// Given two lists of the same size, combine and reduce their elements into a
-// single scalar value.
-
-template <class TYPE, class OP>
-static void ListGenericFold(DataChunk &args, ExpressionState &state, Vector &result) {
-	const auto &lstate = state.Cast<ExecuteFunctionState>();
-	const auto &expr = lstate.expr.Cast<BoundFunctionExpression>();
-	const auto &func_name = expr.function.name;
-
-	auto count = args.size();
-
-	auto &lhs_vec = args.data[0];
-	auto &rhs_vec = args.data[1];
-
-	const auto lhs_count = ListVector::GetListSize(lhs_vec);
-	const auto rhs_count = ListVector::GetListSize(rhs_vec);
-
-	auto &lhs_child = ListVector::GetEntry(lhs_vec);
-	auto &rhs_child = ListVector::GetEntry(rhs_vec);
-
-	lhs_child.Flatten(lhs_count);
-	rhs_child.Flatten(rhs_count);
-
-	D_ASSERT(lhs_child.GetVectorType() == VectorType::FLAT_VECTOR);
-	D_ASSERT(rhs_child.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	if (!FlatVector::Validity(lhs_child).CheckAllValid(lhs_count)) {
-		throw InvalidInputException("%s: left argument can not contain NULL values", func_name);
-	}
-
-	if (!FlatVector::Validity(rhs_child).CheckAllValid(rhs_count)) {
-		throw InvalidInputException("%s: right argument can not contain NULL values", func_name);
-	}
-
-	auto lhs_data = FlatVector::GetData<TYPE>(lhs_child);
-	auto rhs_data = FlatVector::GetData<TYPE>(rhs_child);
-
-	BinaryExecutor::ExecuteWithNulls<list_entry_t, list_entry_t, TYPE>(
-	    lhs_vec, rhs_vec, result, count,
-	    [&](const list_entry_t &left, const list_entry_t &right, ValidityMask &mask, idx_t row_idx) {
-		    if (left.length != right.length) {
-			    throw InvalidInputException(
-			        "%s: list dimensions must be equal, got left length '%d' and right length '%d'", func_name,
-			        left.length, right.length);
-		    }
-
-		    if (!OP::ALLOW_EMPTY && left.length == 0) {
-			    mask.SetInvalid(row_idx);
-			    return TYPE();
-		    }
-
-		    return OP::Operation(lhs_data + left.offset, rhs_data + right.offset, left.length);
-	    });
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-//-------------------------------------------------------------------------
-// Function Registration
-//-------------------------------------------------------------------------
-
-template <class OP>
-static void AddListFoldFunction(ScalarFunctionSet &set, const LogicalType &type) {
-	const auto list = LogicalType::LIST(type);
-	if (type.id() == LogicalTypeId::FLOAT) {
-		set.AddFunction(ScalarFunction({list, list}, type, ListGenericFold<float, OP>));
-	} else if (type.id() == LogicalTypeId::DOUBLE) {
-		set.AddFunction(ScalarFunction({list, list}, type, ListGenericFold<double, OP>));
-	} else {
-		throw NotImplementedException("List function not implemented for type %s", type.ToString());
-	}
-}
-
-ScalarFunctionSet ListDistanceFun::GetFunctions() {
-	ScalarFunctionSet set("list_distance");
-	for (auto &type : LogicalType::Real()) {
-		AddListFoldFunction<DistanceOp>(set, type);
-	}
-	for (auto &func : set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return set;
-}
-
-ScalarFunctionSet ListInnerProductFun::GetFunctions() {
-	ScalarFunctionSet set("list_inner_product");
-	for (auto &type : LogicalType::Real()) {
-		AddListFoldFunction<InnerProductOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ListNegativeInnerProductFun::GetFunctions() {
-	ScalarFunctionSet set("list_negative_inner_product");
-	for (auto &type : LogicalType::Real()) {
-		AddListFoldFunction<NegativeInnerProductOp>(set, type);
-	}
-	return set;
-}
-
-ScalarFunctionSet ListCosineSimilarityFun::GetFunctions() {
-	ScalarFunctionSet set("list_cosine_similarity");
-	for (auto &type : LogicalType::Real()) {
-		AddListFoldFunction<CosineSimilarityOp>(set, type);
-	}
-	for (auto &func : set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return set;
-}
-
-ScalarFunctionSet ListCosineDistanceFun::GetFunctions() {
-	ScalarFunctionSet set("list_cosine_distance");
-	for (auto &type : LogicalType::Real()) {
-		AddListFoldFunction<CosineDistanceOp>(set, type);
-	}
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp b/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp
deleted file mode 100644
index 30ac79db1..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-
-#include "duckdb/function/lambda_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> ListFilterBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	// the list column and the bound lambda expression
-	D_ASSERT(arguments.size() == 2);
-	if (arguments[1]->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA) {
-		throw BinderException("Invalid lambda expression!");
-	}
-
-	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
-
-	// try to cast to boolean, if the return type of the lambda filter expression is not already boolean
-	if (bound_lambda_expr.lambda_expr->return_type != LogicalType::BOOLEAN) {
-		auto cast_lambda_expr =
-		    BoundCastExpression::AddCastToType(context, std::move(bound_lambda_expr.lambda_expr), LogicalType::BOOLEAN);
-		bound_lambda_expr.lambda_expr = std::move(cast_lambda_expr);
-	}
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	bound_function.return_type = arguments[0]->return_type;
-	auto has_index = bound_lambda_expr.parameter_count == 2;
-	return LambdaFunctions::ListLambdaBind(context, bound_function, arguments, has_index);
-}
-
-static LogicalType ListFilterBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	return LambdaFunctions::BindBinaryLambda(parameter_idx, list_child_type);
-}
-
-ScalarFunction ListFilterFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::LIST(LogicalType::ANY),
-	                   LambdaFunctions::ListFilterFunction, ListFilterBind, nullptr, nullptr);
-
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.serialize = ListLambdaBindData::Serialize;
-	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.bind_lambda = ListFilterBindLambda;
-
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_has_any_or_all.cpp b/src/duckdb/extension/core_functions/scalar/list/list_has_any_or_all.cpp
deleted file mode 100644
index dd15edc93..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_has_any_or_all.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-#include "duckdb/function/lambda_functions.hpp"
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/common/string_map_set.hpp"
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> ListHasAnyOrAllBind(ClientContext &context, ScalarFunction &bound_function,
-                                                    vector<unique_ptr<Expression>> &arguments) {
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-	arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1]));
-
-	const auto lhs_is_param = arguments[0]->HasParameter();
-	const auto rhs_is_param = arguments[1]->HasParameter();
-
-	if (lhs_is_param && rhs_is_param) {
-		throw ParameterNotResolvedException();
-	}
-
-	const auto &lhs_list = arguments[0]->return_type;
-	const auto &rhs_list = arguments[1]->return_type;
-
-	if (lhs_is_param) {
-		bound_function.arguments[0] = rhs_list;
-		bound_function.arguments[1] = rhs_list;
-		return nullptr;
-	}
-	if (rhs_is_param) {
-		bound_function.arguments[0] = lhs_list;
-		bound_function.arguments[1] = lhs_list;
-		return nullptr;
-	}
-
-	bound_function.arguments[0] = lhs_list;
-	bound_function.arguments[1] = rhs_list;
-
-	const auto &lhs_child = ListType::GetChildType(bound_function.arguments[0]);
-	const auto &rhs_child = ListType::GetChildType(bound_function.arguments[1]);
-
-	if (lhs_child != LogicalType::SQLNULL && rhs_child != LogicalType::SQLNULL && lhs_child != rhs_child) {
-		LogicalType common_child;
-		if (!LogicalType::TryGetMaxLogicalType(context, lhs_child, rhs_child, common_child)) {
-			throw BinderException("'%s' cannot compare lists of different types: '%s' and '%s'", bound_function.name,
-			                      lhs_child.ToString(), rhs_child.ToString());
-		}
-		bound_function.arguments[0] = LogicalType::LIST(common_child);
-		bound_function.arguments[1] = LogicalType::LIST(common_child);
-	}
-
-	return nullptr;
-}
-
-static void ListHasAnyFunction(DataChunk &args, ExpressionState &, Vector &result) {
-
-	auto &l_vec = args.data[0];
-	auto &r_vec = args.data[1];
-
-	if (ListType::GetChildType(l_vec.GetType()) == LogicalType::SQLNULL ||
-	    ListType::GetChildType(r_vec.GetType()) == LogicalType::SQLNULL) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::GetData<bool>(result)[0] = false;
-		return;
-	}
-
-	const auto l_size = ListVector::GetListSize(l_vec);
-	const auto r_size = ListVector::GetListSize(r_vec);
-
-	auto &l_child = ListVector::GetEntry(l_vec);
-	auto &r_child = ListVector::GetEntry(r_vec);
-
-	// Setup unified formats for the list elements
-	UnifiedVectorFormat l_child_format;
-	UnifiedVectorFormat r_child_format;
-
-	l_child.ToUnifiedFormat(l_size, l_child_format);
-	r_child.ToUnifiedFormat(r_size, r_child_format);
-
-	// Create the sort keys for the list elements
-	Vector l_sortkey_vec(LogicalType::BLOB, l_size);
-	Vector r_sortkey_vec(LogicalType::BLOB, r_size);
-
-	const OrderModifiers order_modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-
-	CreateSortKeyHelpers::CreateSortKey(l_child, l_size, order_modifiers, l_sortkey_vec);
-	CreateSortKeyHelpers::CreateSortKey(r_child, r_size, order_modifiers, r_sortkey_vec);
-
-	const auto l_sortkey_ptr = FlatVector::GetData<string_t>(l_sortkey_vec);
-	const auto r_sortkey_ptr = FlatVector::GetData<string_t>(r_sortkey_vec);
-
-	string_set_t set;
-
-	BinaryExecutor::Execute<list_entry_t, list_entry_t, bool>(
-	    l_vec, r_vec, result, args.size(), [&](const list_entry_t &l_list, const list_entry_t &r_list) {
-		    // Short circuit if either list is empty
-		    if (l_list.length == 0 || r_list.length == 0) {
-			    return false;
-		    }
-
-		    auto build_list = l_list;
-		    auto probe_list = r_list;
-
-		    auto build_data = l_sortkey_ptr;
-		    auto probe_data = r_sortkey_ptr;
-
-		    auto build_format = &l_child_format;
-		    auto probe_format = &r_child_format;
-
-		    // Use the smaller list to build the set
-		    if (r_list.length < l_list.length) {
-
-			    build_list = r_list;
-			    probe_list = l_list;
-
-			    build_data = r_sortkey_ptr;
-			    probe_data = l_sortkey_ptr;
-
-			    build_format = &r_child_format;
-			    probe_format = &l_child_format;
-		    }
-
-		    // Reset the set
-		    set.clear();
-
-		    // Build the set
-		    for (auto idx = build_list.offset; idx < build_list.offset + build_list.length; idx++) {
-			    const auto entry_idx = build_format->sel->get_index(idx);
-			    if (build_format->validity.RowIsValid(entry_idx)) {
-				    set.insert(build_data[entry_idx]);
-			    }
-		    }
-		    // Probe the set
-		    for (auto idx = probe_list.offset; idx < probe_list.offset + probe_list.length; idx++) {
-			    const auto entry_idx = probe_format->sel->get_index(idx);
-			    if (probe_format->validity.RowIsValid(entry_idx) && set.find(probe_data[entry_idx]) != set.end()) {
-				    return true;
-			    }
-		    }
-		    return false;
-	    });
-}
-
-static void ListHasAllFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	const auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	const auto swap = func_expr.function.name == "<@";
-
-	auto &l_vec = args.data[swap ? 1 : 0];
-	auto &r_vec = args.data[swap ? 0 : 1];
-
-	if (ListType::GetChildType(l_vec.GetType()) == LogicalType::SQLNULL &&
-	    ListType::GetChildType(r_vec.GetType()) == LogicalType::SQLNULL) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::GetData<bool>(result)[0] = true;
-		return;
-	}
-
-	const auto l_size = ListVector::GetListSize(l_vec);
-	const auto r_size = ListVector::GetListSize(r_vec);
-
-	auto &l_child = ListVector::GetEntry(l_vec);
-	auto &r_child = ListVector::GetEntry(r_vec);
-
-	// Setup unified formats for the list elements
-	UnifiedVectorFormat build_format;
-	UnifiedVectorFormat probe_format;
-
-	l_child.ToUnifiedFormat(l_size, build_format);
-	r_child.ToUnifiedFormat(r_size, probe_format);
-
-	// Create the sort keys for the list elements
-	Vector l_sortkey_vec(LogicalType::BLOB, l_size);
-	Vector r_sortkey_vec(LogicalType::BLOB, r_size);
-
-	const OrderModifiers order_modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-
-	CreateSortKeyHelpers::CreateSortKey(l_child, l_size, order_modifiers, l_sortkey_vec);
-	CreateSortKeyHelpers::CreateSortKey(r_child, r_size, order_modifiers, r_sortkey_vec);
-
-	const auto build_data = FlatVector::GetData<string_t>(l_sortkey_vec);
-	const auto probe_data = FlatVector::GetData<string_t>(r_sortkey_vec);
-
-	string_set_t set;
-
-	BinaryExecutor::Execute<list_entry_t, list_entry_t, bool>(
-	    l_vec, r_vec, result, args.size(), [&](const list_entry_t &build_list, const list_entry_t &probe_list) {
-		    // Short circuit if the probe list is empty
-		    if (probe_list.length == 0) {
-			    return true;
-		    }
-
-		    // Reset the set
-		    set.clear();
-
-		    // Build the set
-		    for (auto idx = build_list.offset; idx < build_list.offset + build_list.length; idx++) {
-			    const auto entry_idx = build_format.sel->get_index(idx);
-			    if (build_format.validity.RowIsValid(entry_idx)) {
-				    set.insert(build_data[entry_idx]);
-			    }
-		    }
-
-		    // Probe the set
-		    for (auto idx = probe_list.offset; idx < probe_list.offset + probe_list.length; idx++) {
-			    const auto entry_idx = probe_format.sel->get_index(idx);
-			    if (probe_format.validity.RowIsValid(entry_idx) && set.find(probe_data[entry_idx]) == set.end()) {
-				    return false;
-			    }
-		    }
-		    return true;
-	    });
-}
-
-ScalarFunction ListHasAnyFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)}, LogicalType::BOOLEAN,
-	                   ListHasAnyFunction, ListHasAnyOrAllBind);
-	return fun;
-}
-
-ScalarFunction ListHasAllFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)}, LogicalType::BOOLEAN,
-	                   ListHasAllFunction, ListHasAnyOrAllBind);
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp b/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp
deleted file mode 100644
index 173b52699..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp
+++ /dev/null
@@ -1,232 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/function/lambda_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct ReduceExecuteInfo {
-	ReduceExecuteInfo(LambdaFunctions::LambdaInfo &info, ClientContext &context)
-	    : left_slice(make_uniq<Vector>(*info.child_vector)) {
-		SelectionVector left_vector(info.row_count);
-		active_rows.Resize(info.row_count);
-		active_rows.SetAllValid(info.row_count);
-
-		left_sel.Initialize(info.row_count);
-		active_rows_sel.Initialize(info.row_count);
-
-		idx_t reduced_row_idx = 0;
-
-		for (idx_t original_row_idx = 0; original_row_idx < info.row_count; original_row_idx++) {
-			auto list_column_format_index = info.list_column_format.sel->get_index(original_row_idx);
-			if (info.list_column_format.validity.RowIsValid(list_column_format_index)) {
-				if (info.list_entries[list_column_format_index].length == 0) {
-					throw ParameterNotAllowedException("Cannot perform list_reduce on an empty input list");
-				}
-				left_vector.set_index(reduced_row_idx, info.list_entries[list_column_format_index].offset);
-				reduced_row_idx++;
-			} else {
-				// Set the row as invalid and remove it from the active rows.
-				FlatVector::SetNull(info.result, original_row_idx, true);
-				active_rows.SetInvalid(original_row_idx);
-			}
-		}
-		left_slice->Slice(left_vector, reduced_row_idx);
-
-		if (info.has_index) {
-			input_types.push_back(LogicalType::BIGINT);
-		}
-		input_types.push_back(left_slice->GetType());
-		input_types.push_back(left_slice->GetType());
-		for (auto &entry : info.column_infos) {
-			input_types.push_back(entry.vector.get().GetType());
-		}
-
-		expr_executor = make_uniq<ExpressionExecutor>(context, *info.lambda_expr);
-	};
-	ValidityMask active_rows;
-	unique_ptr<Vector> left_slice;
-	unique_ptr<ExpressionExecutor> expr_executor;
-	vector<LogicalType> input_types;
-
-	SelectionVector left_sel;
-	SelectionVector active_rows_sel;
-};
-
-static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFunctions::LambdaInfo &info,
-                          DataChunk &result_chunk) {
-	idx_t original_row_idx = 0;
-	idx_t reduced_row_idx = 0;
-	idx_t valid_row_idx = 0;
-
-	// create selection vectors for the left and right slice
-	auto data = execute_info.active_rows.GetData();
-
-	// reset right_sel each iteration to prevent referencing issues
-	SelectionVector right_sel;
-	right_sel.Initialize(info.row_count);
-
-	idx_t bits_per_entry = sizeof(idx_t) * 8;
-	for (idx_t entry_idx = 0; original_row_idx < info.row_count; entry_idx++) {
-		if (data[entry_idx] == 0) {
-			original_row_idx += bits_per_entry;
-			continue;
-		}
-
-		for (idx_t j = 0; entry_idx * bits_per_entry + j < info.row_count; j++) {
-			if (!execute_info.active_rows.RowIsValid(original_row_idx)) {
-				original_row_idx++;
-				continue;
-			}
-			auto list_column_format_index = info.list_column_format.sel->get_index(original_row_idx);
-			if (info.list_entries[list_column_format_index].length > loops + 1) {
-				right_sel.set_index(reduced_row_idx, info.list_entries[list_column_format_index].offset + loops + 1);
-				execute_info.left_sel.set_index(reduced_row_idx, valid_row_idx);
-				execute_info.active_rows_sel.set_index(reduced_row_idx, original_row_idx);
-				reduced_row_idx++;
-
-			} else {
-				execute_info.active_rows.SetInvalid(original_row_idx);
-				auto val = execute_info.left_slice->GetValue(valid_row_idx);
-				info.result.SetValue(original_row_idx, val);
-			}
-
-			original_row_idx++;
-			valid_row_idx++;
-		}
-	}
-
-	if (reduced_row_idx == 0) {
-		return true;
-	}
-
-	// create the index vector
-	Vector index_vector(Value::BIGINT(UnsafeNumericCast<int64_t>(loops + 2)));
-
-	// slice the left and right slice
-	execute_info.left_slice->Slice(*execute_info.left_slice, execute_info.left_sel, reduced_row_idx);
-	Vector right_slice(*info.child_vector, right_sel, reduced_row_idx);
-
-	// create the input chunk
-	DataChunk input_chunk;
-	input_chunk.InitializeEmpty(execute_info.input_types);
-	input_chunk.SetCardinality(reduced_row_idx);
-
-	idx_t slice_offset = info.has_index ? 1 : 0;
-	if (info.has_index) {
-		input_chunk.data[0].Reference(index_vector);
-	}
-	input_chunk.data[slice_offset + 1].Reference(*execute_info.left_slice);
-	input_chunk.data[slice_offset].Reference(right_slice);
-
-	// add the other columns
-	vector<Vector> slices;
-	for (idx_t i = 0; i < info.column_infos.size(); i++) {
-		if (info.column_infos[i].vector.get().GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// only reference constant vectors
-			input_chunk.data[slice_offset + 2 + i].Reference(info.column_infos[i].vector);
-		} else {
-			// slice the other vectors
-			slices.emplace_back(info.column_infos[i].vector, execute_info.active_rows_sel, reduced_row_idx);
-			input_chunk.data[slice_offset + 2 + i].Reference(slices.back());
-		}
-	}
-
-	result_chunk.Reset();
-	result_chunk.SetCardinality(reduced_row_idx);
-	execute_info.expr_executor->Execute(input_chunk, result_chunk);
-
-	// We need to copy the result into left_slice to avoid data loss due to vector.Reference(...).
-	// Otherwise, we only keep the data of the previous iteration alive, not that of previous iterations.
-	execute_info.left_slice = make_uniq<Vector>(result_chunk.data[0].GetType(), reduced_row_idx);
-	VectorOperations::Copy(result_chunk.data[0], *execute_info.left_slice, reduced_row_idx, 0, 0);
-	return false;
-}
-
-void LambdaFunctions::ListReduceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// Initializes the left slice from the list entries, active rows, the expression executor and the input types
-	bool completed = false;
-	LambdaFunctions::LambdaInfo info(args, state, result, completed);
-	if (completed) {
-		return;
-	}
-
-	ReduceExecuteInfo execute_info(info, state.GetContext());
-
-	// Since the left slice references the result chunk, we need to create two result chunks.
-	// This means there is always an empty result chunk for the next iteration,
-	// without the referenced chunk having to be reset until the current iteration is complete.
-	DataChunk odd_result_chunk;
-	odd_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
-
-	DataChunk even_result_chunk;
-	even_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
-
-	// Execute reduce until all rows are finished.
-	idx_t loops = 0;
-	bool end = false;
-	while (!end) {
-		auto &result_chunk = loops % 2 ? odd_result_chunk : even_result_chunk;
-		auto &spare_result_chunk = loops % 2 ? even_result_chunk : odd_result_chunk;
-
-		end = ExecuteReduce(loops, execute_info, info, result_chunk);
-		spare_result_chunk.Reset();
-		loops++;
-	}
-
-	if (info.is_all_constant && !info.is_volatile) {
-		info.result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	// the list column and the bound lambda expression
-	D_ASSERT(arguments.size() == 2);
-	if (arguments[1]->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA) {
-		throw BinderException("Invalid lambda expression!");
-	}
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
-	if (bound_lambda_expr.parameter_count < 2 || bound_lambda_expr.parameter_count > 3) {
-		throw BinderException("list_reduce expects a function with 2 or 3 arguments");
-	}
-	auto has_index = bound_lambda_expr.parameter_count == 3;
-
-	unique_ptr<FunctionData> bind_data = LambdaFunctions::ListLambdaPrepareBind(arguments, context, bound_function);
-	if (bind_data) {
-		return bind_data;
-	}
-
-	auto list_child_type = arguments[0]->return_type;
-	list_child_type = ListType::GetChildType(list_child_type);
-
-	auto cast_lambda_expr =
-	    BoundCastExpression::AddCastToType(context, std::move(bound_lambda_expr.lambda_expr), list_child_type, false);
-	if (!cast_lambda_expr) {
-		throw BinderException("Could not cast lambda expression to list child type");
-	}
-	bound_function.return_type = cast_lambda_expr->return_type;
-	return make_uniq<ListLambdaBindData>(bound_function.return_type, std::move(cast_lambda_expr), has_index);
-}
-
-static LogicalType ListReduceBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	return LambdaFunctions::BindTernaryLambda(parameter_idx, list_child_type);
-}
-
-ScalarFunction ListReduceFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::ANY,
-	                   LambdaFunctions::ListReduceFunction, ListReduceBind, nullptr, nullptr);
-
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.serialize = ListLambdaBindData::Serialize;
-	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.bind_lambda = ListReduceBindLambda;
-
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_sort.cpp b/src/duckdb/extension/core_functions/scalar/list/list_sort.cpp
deleted file mode 100644
index 5ab523d20..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_sort.cpp
+++ /dev/null
@@ -1,416 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/sort/sort.hpp"
-
-namespace duckdb {
-
-struct ListSortBindData : public FunctionData {
-	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, bool is_grade_up,
-	                 const LogicalType &return_type_p, const LogicalType &child_type_p, ClientContext &context_p);
-	~ListSortBindData() override;
-
-	OrderType order_type;
-	OrderByNullType null_order;
-	LogicalType return_type;
-	LogicalType child_type;
-	bool is_grade_up;
-
-	vector<LogicalType> types;
-	vector<LogicalType> payload_types;
-
-	ClientContext &context;
-	RowLayout payload_layout;
-	vector<BoundOrderByNode> orders;
-
-public:
-	bool Equals(const FunctionData &other_p) const override;
-	unique_ptr<FunctionData> Copy() const override;
-};
-
-ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, bool is_grade_up_p,
-                                   const LogicalType &return_type_p, const LogicalType &child_type_p,
-                                   ClientContext &context_p)
-    : order_type(order_type_p), null_order(null_order_p), return_type(return_type_p), child_type(child_type_p),
-      is_grade_up(is_grade_up_p), context(context_p) {
-
-	// get the vector types
-	types.emplace_back(LogicalType::USMALLINT);
-	types.emplace_back(child_type);
-	D_ASSERT(types.size() == 2);
-
-	// get the payload types
-	payload_types.emplace_back(LogicalType::UINTEGER);
-	D_ASSERT(payload_types.size() == 1);
-
-	// initialize the payload layout
-	payload_layout.Initialize(payload_types);
-
-	// get the BoundOrderByNode
-	auto idx_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0U);
-	auto lists_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(child_type, 1U);
-	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(idx_col_expr));
-	orders.emplace_back(order_type, null_order, std::move(lists_col_expr));
-}
-
-unique_ptr<FunctionData> ListSortBindData::Copy() const {
-	return make_uniq<ListSortBindData>(order_type, null_order, is_grade_up, return_type, child_type, context);
-}
-
-bool ListSortBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ListSortBindData>();
-	return order_type == other.order_type && null_order == other.null_order && is_grade_up == other.is_grade_up;
-}
-
-ListSortBindData::~ListSortBindData() {
-}
-
-// create the key_chunk and the payload_chunk and sink them into the local_sort_state
-void SinkDataChunk(Vector *child_vector, SelectionVector &sel, idx_t offset_lists_indices, vector<LogicalType> &types,
-                   vector<LogicalType> &payload_types, Vector &payload_vector, LocalSortState &local_sort_state,
-                   bool &data_to_sort, Vector &lists_indices) {
-
-	// slice the child vector
-	Vector slice(*child_vector, sel, offset_lists_indices);
-
-	// initialize and fill key_chunk
-	DataChunk key_chunk;
-	key_chunk.InitializeEmpty(types);
-	key_chunk.data[0].Reference(lists_indices);
-	key_chunk.data[1].Reference(slice);
-	key_chunk.SetCardinality(offset_lists_indices);
-
-	// initialize and fill key_chunk and payload_chunk
-	DataChunk payload_chunk;
-	payload_chunk.InitializeEmpty(payload_types);
-	payload_chunk.data[0].Reference(payload_vector);
-	payload_chunk.SetCardinality(offset_lists_indices);
-
-	key_chunk.Verify();
-	payload_chunk.Verify();
-
-	// sink
-	key_chunk.Flatten();
-	local_sort_state.SinkChunk(key_chunk, payload_chunk);
-	data_to_sort = true;
-}
-
-static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() >= 1 && args.ColumnCount() <= 3);
-	auto count = args.size();
-	Vector &input_lists = args.data[0];
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (input_lists.GetType().id() == LogicalTypeId::SQLNULL) {
-		result_validity.SetInvalid(0);
-		return;
-	}
-
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<ListSortBindData>();
-
-	// initialize the global and local sorting state
-	auto &buffer_manager = BufferManager::GetBufferManager(info.context);
-	GlobalSortState global_sort_state(buffer_manager, info.orders, info.payload_layout);
-	LocalSortState local_sort_state;
-	local_sort_state.Initialize(global_sort_state, buffer_manager);
-
-	Vector sort_result_vec = info.is_grade_up ? Vector(input_lists.GetType()) : result;
-
-	// this ensures that we do not change the order of the entries in the input chunk
-	VectorOperations::Copy(input_lists, sort_result_vec, count, 0, 0);
-
-	// get the child vector
-	auto lists_size = ListVector::GetListSize(sort_result_vec);
-	auto &child_vector = ListVector::GetEntry(sort_result_vec);
-
-	// get the lists data
-	UnifiedVectorFormat lists_data;
-	sort_result_vec.ToUnifiedFormat(count, lists_data);
-	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
-
-	// create the lists_indices vector, this contains an element for each list's entry,
-	// the element corresponds to the list's index, e.g. for [1, 2, 4], [5, 4]
-	// lists_indices contains [0, 0, 0, 1, 1]
-	Vector lists_indices(LogicalType::USMALLINT);
-	auto lists_indices_data = FlatVector::GetData<uint16_t>(lists_indices);
-
-	// create the payload_vector, this is just a vector containing incrementing integers
-	// this will later be used as the 'new' selection vector of the child_vector, after
-	// rearranging the payload according to the sorting order
-	Vector payload_vector(LogicalType::UINTEGER);
-	auto payload_vector_data = FlatVector::GetData<uint32_t>(payload_vector);
-
-	// selection vector pointing to the data of the child vector,
-	// used for slicing the child_vector correctly
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-
-	idx_t offset_lists_indices = 0;
-	uint32_t incr_payload_count = 0;
-	bool data_to_sort = false;
-
-	for (idx_t i = 0; i < count; i++) {
-		auto lists_index = lists_data.sel->get_index(i);
-		const auto &list_entry = list_entries[lists_index];
-
-		// nothing to do for this list
-		if (!lists_data.validity.RowIsValid(lists_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		// empty list, no sorting required
-		if (list_entry.length == 0) {
-			continue;
-		}
-
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-			// lists_indices vector is full, sink
-			if (offset_lists_indices == STANDARD_VECTOR_SIZE) {
-				SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
-				              local_sort_state, data_to_sort, lists_indices);
-				offset_lists_indices = 0;
-			}
-
-			auto source_idx = list_entry.offset + child_idx;
-			sel.set_index(offset_lists_indices, source_idx);
-			lists_indices_data[offset_lists_indices] = UnsafeNumericCast<uint16_t>(i);
-			payload_vector_data[offset_lists_indices] = NumericCast<uint32_t>(source_idx);
-			offset_lists_indices++;
-			incr_payload_count++;
-		}
-	}
-
-	if (offset_lists_indices != 0) {
-		SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
-		              local_sort_state, data_to_sort, lists_indices);
-	}
-
-	if (info.is_grade_up) {
-		ListVector::Reserve(result, lists_size);
-		ListVector::SetListSize(result, lists_size);
-		auto result_data = ListVector::GetData(result);
-		memcpy(result_data, list_entries, count * sizeof(list_entry_t));
-	}
-
-	if (data_to_sort) {
-		// add local state to global state, which sorts the data
-		global_sort_state.AddLocalState(local_sort_state);
-		global_sort_state.PrepareMergePhase();
-
-		// selection vector that is to be filled with the 'sorted' payload
-		SelectionVector sel_sorted(incr_payload_count);
-		idx_t sel_sorted_idx = 0;
-
-		// scan the sorted row data
-		PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
-		for (;;) {
-			DataChunk result_chunk;
-			result_chunk.Initialize(Allocator::DefaultAllocator(), info.payload_types);
-			result_chunk.SetCardinality(0);
-			scanner.Scan(result_chunk);
-			if (result_chunk.size() == 0) {
-				break;
-			}
-
-			// construct the selection vector with the new order from the result vectors
-			Vector result_vector(result_chunk.data[0]);
-			auto result_data = FlatVector::GetData<uint32_t>(result_vector);
-			auto row_count = result_chunk.size();
-
-			for (idx_t i = 0; i < row_count; i++) {
-				sel_sorted.set_index(sel_sorted_idx, result_data[i]);
-				D_ASSERT(result_data[i] < lists_size);
-				sel_sorted_idx++;
-			}
-		}
-
-		D_ASSERT(sel_sorted_idx == incr_payload_count);
-		if (info.is_grade_up) {
-			auto &result_entry = ListVector::GetEntry(result);
-			auto result_data = ListVector::GetData(result);
-			for (idx_t i = 0; i < count; i++) {
-				if (!result_validity.RowIsValid(i)) {
-					continue;
-				}
-				for (idx_t j = result_data[i].offset; j < result_data[i].offset + result_data[i].length; j++) {
-					auto b = sel_sorted.get_index(j) - result_data[i].offset;
-					result_entry.SetValue(j, Value::BIGINT(UnsafeNumericCast<int64_t>(b + 1)));
-				}
-			}
-		} else {
-			child_vector.Slice(sel_sorted, sel_sorted_idx);
-			child_vector.Flatten(sel_sorted_idx);
-		}
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments, OrderType &order,
-                                             OrderByNullType &null_order) {
-
-	LogicalType child_type;
-	if (arguments[0]->return_type == LogicalTypeId::UNKNOWN) {
-		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
-		bound_function.return_type = LogicalType::SQLNULL;
-		child_type = bound_function.return_type;
-		return make_uniq<ListSortBindData>(order, null_order, false, bound_function.return_type, child_type, context);
-	}
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-	child_type = ListType::GetChildType(arguments[0]->return_type);
-
-	bound_function.arguments[0] = arguments[0]->return_type;
-	bound_function.return_type = arguments[0]->return_type;
-
-	return make_uniq<ListSortBindData>(order, null_order, false, bound_function.return_type, child_type, context);
-}
-
-template <class T>
-static T GetOrder(ClientContext &context, Expression &expr) {
-	if (!expr.IsFoldable()) {
-		throw InvalidInputException("Sorting order must be a constant");
-	}
-	Value order_value = ExpressionExecutor::EvaluateScalar(context, expr);
-	auto order_name = StringUtil::Upper(order_value.ToString());
-	return EnumUtil::FromString<T>(order_name.c_str());
-}
-
-static unique_ptr<FunctionData> ListGradeUpBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
-	auto order = OrderType::ORDER_DEFAULT;
-	auto null_order = OrderByNullType::ORDER_DEFAULT;
-
-	// get the sorting order
-	if (arguments.size() >= 2) {
-		order = GetOrder<OrderType>(context, *arguments[1]);
-	}
-	// get the null sorting order
-	if (arguments.size() == 3) {
-		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
-	}
-	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(order);
-	null_order = config.ResolveNullOrder(order, null_order);
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	bound_function.arguments[0] = arguments[0]->return_type;
-	bound_function.return_type = LogicalType::LIST(LogicalTypeId::BIGINT);
-	auto child_type = ListType::GetChildType(arguments[0]->return_type);
-	return make_uniq<ListSortBindData>(order, null_order, true, bound_function.return_type, child_type, context);
-}
-
-static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
-	auto order = OrderType::ORDER_DEFAULT;
-	auto null_order = OrderByNullType::ORDER_DEFAULT;
-
-	// get the sorting order
-	if (arguments.size() >= 2) {
-		order = GetOrder<OrderType>(context, *arguments[1]);
-	}
-	// get the null sorting order
-	if (arguments.size() == 3) {
-		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
-	}
-	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(order);
-	null_order = config.ResolveNullOrder(order, null_order);
-	return ListSortBind(context, bound_function, arguments, order, null_order);
-}
-
-static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, ScalarFunction &bound_function,
-                                                    vector<unique_ptr<Expression>> &arguments) {
-	auto order = OrderType::ORDER_DEFAULT;
-	auto null_order = OrderByNullType::ORDER_DEFAULT;
-
-	if (arguments.size() == 2) {
-		null_order = GetOrder<OrderByNullType>(context, *arguments[1]);
-	}
-	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(order);
-	switch (order) {
-	case OrderType::ASCENDING:
-		order = OrderType::DESCENDING;
-		break;
-	case OrderType::DESCENDING:
-		order = OrderType::ASCENDING;
-		break;
-	default:
-		throw InternalException("Unexpected order type in list reverse sort");
-	}
-	null_order = config.ResolveNullOrder(order, null_order);
-	return ListSortBind(context, bound_function, arguments, order, null_order);
-}
-
-ScalarFunctionSet ListSortFun::GetFunctions() {
-	// one parameter: list
-	ScalarFunction sort({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY), ListSortFunction,
-	                    ListNormalSortBind);
-
-	// two parameters: list, order
-	ScalarFunction sort_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
-	                          LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListNormalSortBind);
-
-	// three parameters: list, order, null order
-	ScalarFunction sort_orders({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                           LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListNormalSortBind);
-
-	ScalarFunctionSet list_sort;
-	list_sort.AddFunction(sort);
-	list_sort.AddFunction(sort_order);
-	list_sort.AddFunction(sort_orders);
-	return list_sort;
-}
-
-ScalarFunctionSet ListGradeUpFun::GetFunctions() {
-	// one parameter: list
-	ScalarFunction sort({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY), ListSortFunction,
-	                    ListGradeUpBind);
-
-	// two parameters: list, order
-	ScalarFunction sort_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
-	                          LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListGradeUpBind);
-
-	// three parameters: list, order, null order
-	ScalarFunction sort_orders({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                           LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListGradeUpBind);
-
-	ScalarFunctionSet list_grade_up;
-	list_grade_up.AddFunction(sort);
-	list_grade_up.AddFunction(sort_order);
-	list_grade_up.AddFunction(sort_orders);
-	return list_grade_up;
-}
-
-ScalarFunctionSet ListReverseSortFun::GetFunctions() {
-	// one parameter: list
-	ScalarFunction sort_reverse({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
-	                            ListSortFunction, ListReverseSortBind);
-
-	// two parameters: list, null order
-	ScalarFunction sort_reverse_null_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
-	                                       LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListReverseSortBind);
-
-	ScalarFunctionSet list_reverse_sort;
-	list_reverse_sort.AddFunction(sort_reverse);
-	list_reverse_sort.AddFunction(sort_reverse_null_order);
-	return list_reverse_sort;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp b/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp
deleted file mode 100644
index 26c6ad4b3..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-
-#include "duckdb/function/lambda_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> ListTransformBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-
-	// the list column and the bound lambda expression
-	D_ASSERT(arguments.size() == 2);
-	if (arguments[1]->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA) {
-		throw BinderException("Invalid lambda expression!");
-	}
-
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
-	bound_function.return_type = LogicalType::LIST(bound_lambda_expr.lambda_expr->return_type);
-	auto has_index = bound_lambda_expr.parameter_count == 2;
-	return LambdaFunctions::ListLambdaBind(context, bound_function, arguments, has_index);
-}
-
-static LogicalType ListTransformBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	return LambdaFunctions::BindBinaryLambda(parameter_idx, list_child_type);
-}
-
-ScalarFunction ListTransformFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::LIST(LogicalType::ANY),
-	                   LambdaFunctions::ListTransformFunction, ListTransformBind, nullptr, nullptr);
-
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.serialize = ListLambdaBindData::Serialize;
-	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.bind_lambda = ListTransformBindLambda;
-
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/list_value.cpp b/src/duckdb/extension/core_functions/scalar/list/list_value.cpp
deleted file mode 100644
index 01b342ec4..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/list_value.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/storage/statistics/list_stats.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-
-namespace duckdb {
-
-struct ListValueAssign {
-	template <class T>
-	static T Assign(const T &input, Vector &result) {
-		return input;
-	}
-};
-
-struct ListValueStringAssign {
-	template <class T>
-	static T Assign(const T &input, Vector &result) {
-		return StringVector::AddStringOrBlob(result, input);
-	}
-};
-
-template <class T, class OP = ListValueAssign>
-static void TemplatedListValueFunction(DataChunk &args, Vector &result) {
-	idx_t list_size = args.ColumnCount();
-	ListVector::Reserve(result, args.size() * list_size);
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	auto &list_child = ListVector::GetEntry(result);
-	auto child_data = FlatVector::GetData<T>(list_child);
-	auto &child_validity = FlatVector::Validity(list_child);
-
-	auto unified_format = args.ToUnifiedFormat();
-	for (idx_t r = 0; r < args.size(); r++) {
-		for (idx_t c = 0; c < list_size; c++) {
-			auto input_idx = unified_format[c].sel->get_index(r);
-			auto result_idx = r * list_size + c;
-			auto input_data = UnifiedVectorFormat::GetData<T>(unified_format[c]);
-			if (unified_format[c].validity.RowIsValid(input_idx)) {
-				child_data[result_idx] = OP::template Assign<T>(input_data[input_idx], list_child);
-			} else {
-				child_validity.SetInvalid(result_idx);
-			}
-		}
-		result_data[r].offset = r * list_size;
-		result_data[r].length = list_size;
-	}
-	ListVector::SetListSize(result, args.size() * list_size);
-}
-
-static void TemplatedListValueFunctionFallback(DataChunk &args, Vector &result) {
-	auto &child_type = ListType::GetChildType(result.GetType());
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i].offset = ListVector::GetListSize(result);
-		for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-			auto val = args.GetValue(col_idx, i).DefaultCastAs(child_type);
-			ListVector::PushBack(result, val);
-		}
-		result_data[i].length = args.ColumnCount();
-	}
-}
-
-static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	if (args.ColumnCount() == 0) {
-		// no columns - early out - result is a constant empty list
-		auto result_data = FlatVector::GetData<list_entry_t>(result);
-		result_data[0].length = 0;
-		result_data[0].offset = 0;
-		return;
-	}
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-	auto &result_type = ListVector::GetEntry(result).GetType();
-	switch (result_type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedListValueFunction<int8_t>(args, result);
-		break;
-	case PhysicalType::INT16:
-		TemplatedListValueFunction<int16_t>(args, result);
-		break;
-	case PhysicalType::INT32:
-		TemplatedListValueFunction<int32_t>(args, result);
-		break;
-	case PhysicalType::INT64:
-		TemplatedListValueFunction<int64_t>(args, result);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedListValueFunction<uint8_t>(args, result);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedListValueFunction<uint16_t>(args, result);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedListValueFunction<uint32_t>(args, result);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedListValueFunction<uint64_t>(args, result);
-		break;
-	case PhysicalType::INT128:
-		TemplatedListValueFunction<hugeint_t>(args, result);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedListValueFunction<uhugeint_t>(args, result);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedListValueFunction<float>(args, result);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedListValueFunction<double>(args, result);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedListValueFunction<interval_t>(args, result);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedListValueFunction<string_t, ListValueStringAssign>(args, result);
-		break;
-	default: {
-		TemplatedListValueFunctionFallback(args, result);
-		break;
-	}
-	}
-}
-
-template <bool IS_UNPIVOT = false>
-static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	// collect names and deconflict, construct return type
-	LogicalType child_type =
-	    arguments.empty() ? LogicalType::SQLNULL : ExpressionBinder::GetExpressionReturnType(*arguments[0]);
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		auto arg_type = ExpressionBinder::GetExpressionReturnType(*arguments[i]);
-		if (!LogicalType::TryGetMaxLogicalType(context, child_type, arg_type, child_type)) {
-			if (IS_UNPIVOT) {
-				string list_arguments = "Full list: ";
-				idx_t error_index = list_arguments.size();
-				for (idx_t k = 0; k < arguments.size(); k++) {
-					if (k > 0) {
-						list_arguments += ", ";
-					}
-					if (k == i) {
-						error_index = list_arguments.size();
-					}
-					list_arguments += arguments[k]->ToString() + " " + arguments[k]->return_type.ToString();
-				}
-				auto error =
-				    StringUtil::Format("Cannot unpivot columns of types %s and %s - an explicit cast is required",
-				                       child_type.ToString(), arg_type.ToString());
-				throw BinderException(arguments[i]->GetQueryLocation(),
-				                      QueryErrorContext::Format(list_arguments, error, error_index, false));
-			} else {
-				throw BinderException(arguments[i]->GetQueryLocation(),
-				                      "Cannot create a list of types %s and %s - an explicit cast is required",
-				                      child_type.ToString(), arg_type.ToString());
-			}
-		}
-	}
-	child_type = LogicalType::NormalizeType(child_type);
-
-	// this is more for completeness reasons
-	bound_function.varargs = child_type;
-	bound_function.return_type = LogicalType::LIST(child_type);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	auto list_stats = ListStats::CreateEmpty(expr.return_type);
-	auto &list_child_stats = ListStats::GetChildStats(list_stats);
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		list_child_stats.Merge(child_stats[i]);
-	}
-	return list_stats.ToUnique();
-}
-
-ScalarFunction ListValueFun::GetFunction() {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("list_value", {}, LogicalTypeId::LIST, ListValueFunction, ListValueBind, nullptr,
-	                   ListValueStats);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-ScalarFunction UnpivotListFun::GetFunction() {
-	auto fun = ListValueFun::GetFunction();
-	fun.name = "unpivot_list";
-	fun.bind = ListValueBind<true>;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/list/range.cpp b/src/duckdb/extension/core_functions/scalar/list/range.cpp
deleted file mode 100644
index 8c641d13d..000000000
--- a/src/duckdb/extension/core_functions/scalar/list/range.cpp
+++ /dev/null
@@ -1,281 +0,0 @@
-#include "core_functions/scalar/list_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-
-namespace duckdb {
-
-struct NumericRangeInfo {
-	using TYPE = int64_t;
-	using INCREMENT_TYPE = int64_t;
-
-	static int64_t DefaultStart() {
-		return 0;
-	}
-	static int64_t DefaultIncrement() {
-		return 1;
-	}
-
-	static uint64_t ListLength(int64_t start_value, int64_t end_value, int64_t increment_value, bool inclusive_bound) {
-		if (increment_value == 0) {
-			return 0;
-		}
-		if (start_value > end_value && increment_value > 0) {
-			return 0;
-		}
-		if (start_value < end_value && increment_value < 0) {
-			return 0;
-		}
-		hugeint_t total_diff = AbsValue(hugeint_t(end_value) - hugeint_t(start_value));
-		hugeint_t increment = AbsValue(hugeint_t(increment_value));
-		hugeint_t total_values = total_diff / increment;
-		if (total_diff % increment == 0) {
-			if (inclusive_bound) {
-				total_values += 1;
-			}
-		} else {
-			total_values += 1;
-		}
-		if (total_values > NumericLimits<uint32_t>::Maximum()) {
-			throw InvalidInputException("Lists larger than 2^32 elements are not supported");
-		}
-		return Hugeint::Cast<uint64_t>(total_values);
-	}
-
-	static void Increment(int64_t &input, int64_t increment) {
-		input += increment;
-	}
-};
-struct TimestampRangeInfo {
-	using TYPE = timestamp_t;
-	using INCREMENT_TYPE = interval_t;
-
-	static timestamp_t DefaultStart() {
-		throw InternalException("Default start not implemented for timestamp range");
-	}
-	static interval_t DefaultIncrement() {
-		throw InternalException("Default increment not implemented for timestamp range");
-	}
-	static uint64_t ListLength(timestamp_t start_value, timestamp_t end_value, interval_t increment_value,
-	                           bool inclusive_bound) {
-		bool is_positive = increment_value.months > 0 || increment_value.days > 0 || increment_value.micros > 0;
-		bool is_negative = increment_value.months < 0 || increment_value.days < 0 || increment_value.micros < 0;
-		if (!is_negative && !is_positive) {
-			// interval is 0: no result
-			return 0;
-		}
-		// We don't allow infinite bounds because they generate errors or infinite loops
-		if (!Timestamp::IsFinite(start_value) || !Timestamp::IsFinite(end_value)) {
-			throw InvalidInputException("Interval infinite bounds not supported");
-		}
-
-		if (is_negative && is_positive) {
-			// we don't allow a mix of
-			throw InvalidInputException("Interval with mix of negative/positive entries not supported");
-		}
-		if (start_value > end_value && is_positive) {
-			return 0;
-		}
-		if (start_value < end_value && is_negative) {
-			return 0;
-		}
-		uint64_t total_values = 0;
-		if (is_negative) {
-			// negative interval, start_value is going down
-			while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
-				start_value = Interval::Add(start_value, increment_value);
-				total_values++;
-				if (total_values > NumericLimits<uint32_t>::Maximum()) {
-					throw InvalidInputException("Lists larger than 2^32 elements are not supported");
-				}
-			}
-		} else {
-			// positive interval, start_value is going up
-			while (inclusive_bound ? start_value <= end_value : start_value < end_value) {
-				start_value = Interval::Add(start_value, increment_value);
-				total_values++;
-				if (total_values > NumericLimits<uint32_t>::Maximum()) {
-					throw InvalidInputException("Lists larger than 2^32 elements are not supported");
-				}
-			}
-		}
-		return total_values;
-	}
-
-	static void Increment(timestamp_t &input, interval_t increment) {
-		input = Interval::Add(input, increment);
-	}
-};
-
-template <class OP, bool INCLUSIVE_BOUND>
-class RangeInfoStruct {
-public:
-	explicit RangeInfoStruct(DataChunk &args_p) : args(args_p) {
-		switch (args.ColumnCount()) {
-		case 1:
-			args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
-			break;
-		case 2:
-			args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
-			args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
-			break;
-		case 3:
-			args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
-			args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
-			args.data[2].ToUnifiedFormat(args.size(), vdata[2]);
-			break;
-		default:
-			throw InternalException("Unsupported number of parameters for range");
-		}
-	}
-
-	bool RowIsValid(idx_t row_idx) {
-		for (idx_t i = 0; i < args.ColumnCount(); i++) {
-			auto idx = vdata[i].sel->get_index(row_idx);
-			if (!vdata[i].validity.RowIsValid(idx)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	typename OP::TYPE StartListValue(idx_t row_idx) {
-		if (args.ColumnCount() == 1) {
-			return OP::DefaultStart();
-		} else {
-			auto data = (typename OP::TYPE *)vdata[0].data;
-			auto idx = vdata[0].sel->get_index(row_idx);
-			return data[idx];
-		}
-	}
-
-	typename OP::TYPE EndListValue(idx_t row_idx) {
-		idx_t vdata_idx = args.ColumnCount() == 1 ? 0 : 1;
-		auto data = (typename OP::TYPE *)vdata[vdata_idx].data;
-		auto idx = vdata[vdata_idx].sel->get_index(row_idx);
-		return data[idx];
-	}
-
-	typename OP::INCREMENT_TYPE ListIncrementValue(idx_t row_idx) {
-		if (args.ColumnCount() < 3) {
-			return OP::DefaultIncrement();
-		} else {
-			auto data = (typename OP::INCREMENT_TYPE *)vdata[2].data;
-			auto idx = vdata[2].sel->get_index(row_idx);
-			return data[idx];
-		}
-	}
-
-	void GetListValues(idx_t row_idx, typename OP::TYPE &start_value, typename OP::TYPE &end_value,
-	                   typename OP::INCREMENT_TYPE &increment_value) {
-		start_value = StartListValue(row_idx);
-		end_value = EndListValue(row_idx);
-		increment_value = ListIncrementValue(row_idx);
-	}
-
-	uint64_t ListLength(idx_t row_idx) {
-		typename OP::TYPE start_value;
-		typename OP::TYPE end_value;
-		typename OP::INCREMENT_TYPE increment_value;
-		GetListValues(row_idx, start_value, end_value, increment_value);
-		return OP::ListLength(start_value, end_value, increment_value, INCLUSIVE_BOUND);
-	}
-
-private:
-	DataChunk &args;
-	UnifiedVectorFormat vdata[3];
-};
-
-template <class OP, bool INCLUSIVE_BOUND>
-static void ListRangeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	RangeInfoStruct<OP, INCLUSIVE_BOUND> info(args);
-	idx_t args_size = 1;
-	auto result_type = VectorType::CONSTANT_VECTOR;
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			args_size = args.size();
-			result_type = VectorType::FLAT_VECTOR;
-			break;
-		}
-	}
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-	uint64_t total_size = 0;
-	for (idx_t i = 0; i < args_size; i++) {
-		if (!info.RowIsValid(i)) {
-			result_validity.SetInvalid(i);
-			list_data[i].offset = total_size;
-			list_data[i].length = 0;
-		} else {
-			list_data[i].offset = total_size;
-			list_data[i].length = info.ListLength(i);
-			total_size += list_data[i].length;
-		}
-	}
-
-	// now construct the child vector of the list
-	ListVector::Reserve(result, total_size);
-	auto range_data = FlatVector::GetData<typename OP::TYPE>(ListVector::GetEntry(result));
-	idx_t total_idx = 0;
-	for (idx_t i = 0; i < args_size; i++) {
-		typename OP::TYPE start_value = info.StartListValue(i);
-		typename OP::INCREMENT_TYPE increment = info.ListIncrementValue(i);
-
-		typename OP::TYPE range_value = start_value;
-		for (idx_t range_idx = 0; range_idx < list_data[i].length; range_idx++) {
-			if (range_idx > 0) {
-				OP::Increment(range_value, increment);
-			}
-			range_data[total_idx++] = range_value;
-		}
-	}
-
-	ListVector::SetListSize(result, total_size);
-	result.SetVectorType(result_type);
-
-	result.Verify(args.size());
-}
-
-ScalarFunctionSet ListRangeFun::GetFunctions() {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunctionSet range_set;
-	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::LIST(LogicalType::BIGINT),
-	                                     ListRangeFunction<NumericRangeInfo, false>));
-	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT},
-	                                     LogicalType::LIST(LogicalType::BIGINT),
-	                                     ListRangeFunction<NumericRangeInfo, false>));
-	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                     LogicalType::LIST(LogicalType::BIGINT),
-	                                     ListRangeFunction<NumericRangeInfo, false>));
-	range_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                     LogicalType::LIST(LogicalType::TIMESTAMP),
-	                                     ListRangeFunction<TimestampRangeInfo, false>));
-	for (auto &func : range_set.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return range_set;
-}
-
-ScalarFunctionSet GenerateSeriesFun::GetFunctions() {
-	ScalarFunctionSet generate_series;
-	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::LIST(LogicalType::BIGINT),
-	                                           ListRangeFunction<NumericRangeInfo, true>));
-	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT},
-	                                           LogicalType::LIST(LogicalType::BIGINT),
-	                                           ListRangeFunction<NumericRangeInfo, true>));
-	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                           LogicalType::LIST(LogicalType::BIGINT),
-	                                           ListRangeFunction<NumericRangeInfo, true>));
-	generate_series.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                           LogicalType::LIST(LogicalType::TIMESTAMP),
-	                                           ListRangeFunction<TimestampRangeInfo, true>));
-	for (auto &func : generate_series.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return generate_series;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/cardinality.cpp b/src/duckdb/extension/core_functions/scalar/map/cardinality.cpp
deleted file mode 100644
index 9c81223e7..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/cardinality.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "core_functions/scalar/map_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &map = args.data[0];
-	UnifiedVectorFormat map_data;
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<uint64_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	map.ToUnifiedFormat(args.size(), map_data);
-	for (idx_t row = 0; row < args.size(); row++) {
-		auto list_entry = UnifiedVectorFormat::GetData<list_entry_t>(map_data)[map_data.sel->get_index(row)];
-		result_data[row] = list_entry.length;
-		result_validity.Set(row, map_data.validity.RowIsValid(map_data.sel->get_index(row)));
-	}
-
-	if (args.size() == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> CardinalityBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() != 1) {
-		throw BinderException("Cardinality must have exactly one arguments");
-	}
-
-	if (arguments[0]->return_type.id() != LogicalTypeId::MAP) {
-		throw BinderException("Cardinality can only operate on MAPs");
-	}
-
-	bound_function.return_type = LogicalType::UBIGINT;
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction CardinalityFun::GetFunction() {
-	ScalarFunction fun({LogicalType::ANY}, LogicalType::UBIGINT, CardinalityFunction, CardinalityBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/map.cpp b/src/duckdb/extension/core_functions/scalar/map/map.cpp
deleted file mode 100644
index b83a4a081..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/map.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-#include "core_functions/scalar/map_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/value_map.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-static void MapFunctionEmptyInput(Vector &result, const idx_t row_count) {
-	// If no chunk is set in ExpressionExecutor::ExecuteExpression (args.data.empty(), e.g., in SELECT MAP()),
-	// then we always pass a row_count of 1.
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ListVector::SetListSize(result, 0);
-
-	auto result_data = ListVector::GetData(result);
-	result_data[0] = list_entry_t();
-	result.Verify(row_count);
-}
-
-static bool MapIsNull(DataChunk &chunk) {
-	if (chunk.data.empty()) {
-		return false;
-	}
-	D_ASSERT(chunk.data.size() == 2);
-	auto &keys = chunk.data[0];
-	auto &values = chunk.data[1];
-
-	if (keys.GetType().id() == LogicalTypeId::SQLNULL) {
-		return true;
-	}
-	if (values.GetType().id() == LogicalTypeId::SQLNULL) {
-		return true;
-	}
-	return false;
-}
-
-static void MapFunction(DataChunk &args, ExpressionState &, Vector &result) {
-
-	// internal MAP representation
-	// - LIST-vector that contains STRUCTs as child entries
-	// - STRUCTs have exactly two fields, a key-field, and a value-field
-	// - key names are unique
-	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
-
-	if (MapIsNull(args)) {
-		auto &validity = FlatVector::Validity(result);
-		validity.SetInvalid(0);
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		return;
-	}
-
-	auto row_count = args.size();
-
-	// early-out, if no data
-	if (args.data.empty()) {
-		return MapFunctionEmptyInput(result, row_count);
-	}
-
-	auto &keys = args.data[0];
-	auto &values = args.data[1];
-
-	// a LIST vector, where each row contains a LIST of KEYS
-	UnifiedVectorFormat keys_data;
-	keys.ToUnifiedFormat(row_count, keys_data);
-	auto keys_entries = UnifiedVectorFormat::GetData<list_entry_t>(keys_data);
-
-	// the KEYs child vector
-	auto keys_child_vector = ListVector::GetEntry(keys);
-	UnifiedVectorFormat keys_child_data;
-	keys_child_vector.ToUnifiedFormat(ListVector::GetListSize(keys), keys_child_data);
-
-	// a LIST vector, where each row contains a LIST of VALUES
-	UnifiedVectorFormat values_data;
-	values.ToUnifiedFormat(row_count, values_data);
-	auto values_entries = UnifiedVectorFormat::GetData<list_entry_t>(values_data);
-
-	// the VALUEs child vector
-	auto values_child_vector = ListVector::GetEntry(values);
-	UnifiedVectorFormat values_child_data;
-	values_child_vector.ToUnifiedFormat(ListVector::GetListSize(values), values_child_data);
-
-	// a LIST vector, where each row contains a MAP (LIST of STRUCTs)
-	UnifiedVectorFormat result_data;
-	result.ToUnifiedFormat(row_count, result_data);
-	auto result_entries = UnifiedVectorFormat::GetDataNoConst<list_entry_t>(result_data);
-
-	auto &result_validity = FlatVector::Validity(result);
-
-	// get the resulting size of the key/value child lists
-	idx_t result_child_size = 0;
-	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
-		auto keys_idx = keys_data.sel->get_index(row_idx);
-		auto values_idx = values_data.sel->get_index(row_idx);
-		if (!keys_data.validity.RowIsValid(keys_idx) || !values_data.validity.RowIsValid(values_idx)) {
-			continue;
-		}
-		auto keys_entry = keys_entries[keys_idx];
-		result_child_size += keys_entry.length;
-	}
-
-	// we need to slice potential non-flat vectors
-	SelectionVector sel_keys(result_child_size);
-	SelectionVector sel_values(result_child_size);
-	idx_t offset = 0;
-
-	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
-
-		auto keys_idx = keys_data.sel->get_index(row_idx);
-		auto values_idx = values_data.sel->get_index(row_idx);
-		auto result_idx = result_data.sel->get_index(row_idx);
-
-		// NULL MAP
-		if (!keys_data.validity.RowIsValid(keys_idx) || !values_data.validity.RowIsValid(values_idx)) {
-			result_validity.SetInvalid(row_idx);
-			continue;
-		}
-
-		auto keys_entry = keys_entries[keys_idx];
-		auto values_entry = values_entries[values_idx];
-
-		if (keys_entry.length != values_entry.length) {
-			MapVector::EvalMapInvalidReason(MapInvalidReason::NOT_ALIGNED);
-		}
-
-		// set the selection vectors and perform a duplicate key check
-		value_set_t unique_keys;
-		for (idx_t child_idx = 0; child_idx < keys_entry.length; child_idx++) {
-
-			auto key_idx = keys_child_data.sel->get_index(keys_entry.offset + child_idx);
-			auto value_idx = values_child_data.sel->get_index(values_entry.offset + child_idx);
-
-			// NULL check
-			if (!keys_child_data.validity.RowIsValid(key_idx)) {
-				MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_KEY);
-			}
-
-			// unique check
-			auto value = keys_child_vector.GetValue(key_idx);
-			auto unique = unique_keys.insert(value).second;
-			if (!unique) {
-				MapVector::EvalMapInvalidReason(MapInvalidReason::DUPLICATE_KEY);
-			}
-
-			// set selection vectors
-			sel_keys.set_index(offset + child_idx, key_idx);
-			sel_values.set_index(offset + child_idx, value_idx);
-		}
-
-		// keys_entry and values_entry have the same length
-		result_entries[result_idx].length = keys_entry.length;
-		result_entries[result_idx].offset = offset;
-		offset += keys_entry.length;
-	}
-	D_ASSERT(offset == result_child_size);
-
-	auto &result_key_vector = MapVector::GetKeys(result);
-	auto &result_value_vector = MapVector::GetValues(result);
-
-	ListVector::SetListSize(result, offset);
-	result_key_vector.Slice(keys_child_vector, sel_keys, offset);
-	result_key_vector.Flatten(offset);
-	result_value_vector.Slice(values_child_vector, sel_values, offset);
-	result_value_vector.Flatten(offset);
-	FlatVector::Validity(ListVector::GetEntry(result)).Resize(result_child_size);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	result.Verify(row_count);
-}
-
-static unique_ptr<FunctionData> MapBind(ClientContext &, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-
-	if (arguments.size() != 2 && !arguments.empty()) {
-		MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS);
-	}
-
-	bool is_null = false;
-	if (arguments.empty()) {
-		is_null = true;
-	}
-	if (!is_null) {
-		auto key_id = arguments[0]->return_type.id();
-		auto value_id = arguments[1]->return_type.id();
-		if (key_id == LogicalTypeId::SQLNULL || value_id == LogicalTypeId::SQLNULL) {
-			is_null = true;
-		}
-	}
-
-	if (is_null) {
-		bound_function.return_type = LogicalType::MAP(LogicalTypeId::SQLNULL, LogicalTypeId::SQLNULL);
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	// bind a MAP with key-value pairs
-	D_ASSERT(arguments.size() == 2);
-	if (arguments[0]->return_type.id() != LogicalTypeId::LIST) {
-		MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS);
-	}
-	if (arguments[1]->return_type.id() != LogicalTypeId::LIST) {
-		MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS);
-	}
-
-	auto key_type = ListType::GetChildType(arguments[0]->return_type);
-	auto value_type = ListType::GetChildType(arguments[1]->return_type);
-
-	bound_function.return_type = LogicalType::MAP(key_type, value_type);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction MapFun::GetFunction() {
-	ScalarFunction fun({}, LogicalTypeId::MAP, MapFunction, MapBind);
-	fun.varargs = LogicalType::ANY;
-	BaseScalarFunction::SetReturnsError(fun);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/map_concat.cpp b/src/duckdb/extension/core_functions/scalar/map/map_concat.cpp
deleted file mode 100644
index c958f41b9..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/map_concat.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "core_functions/scalar/map_functions.hpp"
-
-namespace duckdb {
-
-namespace {
-
-struct MapKeyIndexPair {
-	MapKeyIndexPair(idx_t map, idx_t key) : map_index(map), key_index(key) {
-	}
-	// The index of the map that this key comes from
-	idx_t map_index;
-	// The index within the maps key_list
-	idx_t key_index;
-};
-
-} // namespace
-
-vector<Value> GetListEntries(vector<Value> keys, vector<Value> values) {
-	D_ASSERT(keys.size() == values.size());
-	vector<Value> entries;
-	for (idx_t i = 0; i < keys.size(); i++) {
-		child_list_t<Value> children;
-		children.emplace_back(make_pair("key", std::move(keys[i])));
-		children.emplace_back(make_pair("value", std::move(values[i])));
-		entries.push_back(Value::STRUCT(std::move(children)));
-	}
-	return entries;
-}
-
-static void MapConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	if (result.GetType().id() == LogicalTypeId::SQLNULL) {
-		// All inputs are NULL, just return NULL
-		auto &validity = FlatVector::Validity(result);
-		validity.SetInvalid(0);
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		return;
-	}
-	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
-	auto count = args.size();
-
-	auto map_count = args.ColumnCount();
-	vector<UnifiedVectorFormat> map_formats(map_count);
-	for (idx_t i = 0; i < map_count; i++) {
-		auto &map = args.data[i];
-		map.ToUnifiedFormat(count, map_formats[i]);
-	}
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-
-	for (idx_t i = 0; i < count; i++) {
-		// Loop through all the maps per list
-		// we cant do better because all the entries of the child vector have to be contiguous
-		// so we cant start the next row before we have finished the one before it
-		auto &result_entry = result_data[i];
-		vector<MapKeyIndexPair> index_to_map;
-		vector<Value> keys_list;
-		bool all_null = true;
-		for (idx_t map_idx = 0; map_idx < map_count; map_idx++) {
-			if (args.data[map_idx].GetType().id() == LogicalTypeId::SQLNULL) {
-				continue;
-			}
-
-			auto &map_format = map_formats[map_idx];
-			auto index = map_format.sel->get_index(i);
-			if (!map_format.validity.RowIsValid(index)) {
-				continue;
-			}
-
-			all_null = false;
-			auto &keys = MapVector::GetKeys(args.data[map_idx]);
-			auto entry = UnifiedVectorFormat::GetData<list_entry_t>(map_format)[index];
-
-			// Update the list for this row
-			for (idx_t list_idx = 0; list_idx < entry.length; list_idx++) {
-				auto key_index = entry.offset + list_idx;
-				auto key = keys.GetValue(key_index);
-				auto entry = std::find(keys_list.begin(), keys_list.end(), key);
-				if (entry == keys_list.end()) {
-					// Result list does not contain this value yet
-					keys_list.push_back(key);
-					index_to_map.emplace_back(map_idx, key_index);
-				} else {
-					// Result list already contains this, update where to find the value at
-					auto distance = std::distance(keys_list.begin(), entry);
-					auto &mapping = *(index_to_map.begin() + distance);
-					mapping.key_index = key_index;
-					mapping.map_index = map_idx;
-				}
-			}
-		}
-
-		result_entry.offset = ListVector::GetListSize(result);
-		result_entry.length = keys_list.size();
-		if (all_null) {
-			D_ASSERT(keys_list.empty() && index_to_map.empty());
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-
-		vector<Value> values_list;
-		D_ASSERT(keys_list.size() == index_to_map.size());
-		// Get the values from the mapping
-		for (auto &mapping : index_to_map) {
-			auto &map = args.data[mapping.map_index];
-			auto &values = MapVector::GetValues(map);
-			values_list.push_back(values.GetValue(mapping.key_index));
-		}
-		D_ASSERT(values_list.size() == keys_list.size());
-		auto list_entries = GetListEntries(std::move(keys_list), std::move(values_list));
-		for (auto &list_entry : list_entries) {
-			ListVector::PushBack(result, list_entry);
-		}
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	result.Verify(count);
-}
-
-static bool IsEmptyMap(const LogicalType &map) {
-	D_ASSERT(map.id() == LogicalTypeId::MAP);
-	auto &key_type = MapType::KeyType(map);
-	auto &value_type = MapType::ValueType(map);
-	return key_type.id() == LogicalType::SQLNULL && value_type.id() == LogicalType::SQLNULL;
-}
-
-static unique_ptr<FunctionData> MapConcatBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-
-	auto arg_count = arguments.size();
-	if (arg_count < 2) {
-		throw InvalidInputException("The provided amount of arguments is incorrect, please provide 2 or more maps");
-	}
-
-	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		// Prepared statement
-		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-
-	LogicalType expected = LogicalType::SQLNULL;
-
-	bool is_null = true;
-	// Check and verify that all the maps are of the same type
-	for (idx_t i = 0; i < arg_count; i++) {
-		auto &arg = arguments[i];
-		auto &map = arg->return_type;
-		if (map.id() == LogicalTypeId::UNKNOWN) {
-			// Prepared statement
-			bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
-			bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-			return nullptr;
-		}
-		if (map.id() == LogicalTypeId::SQLNULL) {
-			// The maps are allowed to be NULL
-			continue;
-		}
-		if (map.id() != LogicalTypeId::MAP) {
-			throw InvalidInputException("MAP_CONCAT only takes map arguments");
-		}
-		is_null = false;
-		if (IsEmptyMap(map)) {
-			// Map is allowed to be empty
-			continue;
-		}
-
-		if (expected.id() == LogicalTypeId::SQLNULL) {
-			expected = map;
-		} else if (map != expected) {
-			throw InvalidInputException(
-			    "'value' type of map differs between arguments, expected '%s', found '%s' instead", expected.ToString(),
-			    map.ToString());
-		}
-	}
-
-	if (expected.id() == LogicalTypeId::SQLNULL && is_null == false) {
-		expected = LogicalType::MAP(LogicalType::SQLNULL, LogicalType::SQLNULL);
-	}
-	bound_function.return_type = expected;
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction MapConcatFun::GetFunction() {
-	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun("map_concat", {}, LogicalTypeId::LIST, MapConcatFunction, MapConcatBind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.varargs = LogicalType::ANY;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/map_entries.cpp b/src/duckdb/extension/core_functions/scalar/map/map_entries.cpp
deleted file mode 100644
index 487fd75fa..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/map_entries.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "core_functions/scalar/map_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-// Reverse of map_from_entries
-static void MapEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto count = args.size();
-
-	auto &map = args.data[0];
-	if (map.GetType().id() == LogicalTypeId::SQLNULL) {
-		// Input is a constant NULL
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	MapUtil::ReinterpretMap(result, map, count);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	result.Verify(count);
-}
-
-static LogicalType CreateReturnType(const LogicalType &map) {
-	auto &key_type = MapType::KeyType(map);
-	auto &value_type = MapType::ValueType(map);
-
-	child_list_t<LogicalType> child_types;
-	child_types.push_back(make_pair("key", key_type));
-	child_types.push_back(make_pair("value", value_type));
-
-	auto row_type = LogicalType::STRUCT(child_types);
-	return LogicalType::LIST(row_type);
-}
-
-static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() != 1) {
-		throw InvalidInputException("Too many arguments provided, only expecting a single map");
-	}
-	auto &map = arguments[0]->return_type;
-
-	if (map.id() == LogicalTypeId::UNKNOWN) {
-		// Prepared statement
-		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-
-	if (map.id() == LogicalTypeId::SQLNULL) {
-		// Input is NULL, output is STRUCT(NULL, NULL)[]
-		auto map_type = LogicalType::MAP(LogicalTypeId::SQLNULL, LogicalTypeId::SQLNULL);
-		bound_function.return_type = CreateReturnType(map_type);
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	if (map.id() != LogicalTypeId::MAP) {
-		throw InvalidInputException("The provided argument is not a map");
-	}
-	bound_function.return_type = CreateReturnType(map);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction MapEntriesFun::GetFunction() {
-	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun({}, LogicalTypeId::LIST, MapEntriesFunction, MapEntriesBind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.varargs = LogicalType::ANY;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/map_extract.cpp b/src/duckdb/extension/core_functions/scalar/map/map_extract.cpp
deleted file mode 100644
index 170f2b7da..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/map_extract.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "core_functions/scalar/map_functions.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/list/contains_or_position.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> MapExtractBind(ClientContext &, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() != 2) {
-		throw BinderException("MAP_EXTRACT must have exactly two arguments");
-	}
-
-	auto &map_type = arguments[0]->return_type;
-	auto &input_type = arguments[1]->return_type;
-
-	if (map_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.return_type = LogicalTypeId::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	if (map_type.id() != LogicalTypeId::MAP) {
-		throw BinderException("MAP_EXTRACT can only operate on MAPs");
-	}
-	auto &value_type = MapType::ValueType(map_type);
-
-	//! Here we have to construct the List Type that will be returned
-	bound_function.return_type = value_type;
-	auto key_type = MapType::KeyType(map_type);
-	if (key_type.id() != LogicalTypeId::SQLNULL && input_type.id() != LogicalTypeId::SQLNULL) {
-		bound_function.arguments[1] = MapType::KeyType(map_type);
-	}
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-static void MapExtractFunc(DataChunk &args, ExpressionState &state, Vector &result) {
-	const auto count = args.size();
-
-	auto &map_vec = args.data[0];
-	auto &arg_vec = args.data[1];
-
-	const auto map_is_null = map_vec.GetType().id() == LogicalTypeId::SQLNULL;
-	const auto arg_is_null = arg_vec.GetType().id() == LogicalTypeId::SQLNULL;
-
-	if (map_is_null || arg_is_null) {
-		// Short-circuit if either the map or the arg is NULL
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		result.Verify(count);
-		return;
-	}
-
-	auto &key_vec = MapVector::GetKeys(map_vec);
-	auto &val_vec = MapVector::GetValues(map_vec);
-
-	// Collect the matching positions
-	Vector pos_vec(LogicalType::INTEGER, count);
-	ListSearchOp<true>(map_vec, key_vec, arg_vec, pos_vec, args.size());
-
-	UnifiedVectorFormat pos_format;
-	UnifiedVectorFormat lst_format;
-
-	pos_vec.ToUnifiedFormat(count, pos_format);
-	map_vec.ToUnifiedFormat(count, lst_format);
-
-	const auto pos_data = UnifiedVectorFormat::GetData<int32_t>(pos_format);
-	const auto inc_list_data = ListVector::GetData(map_vec);
-
-	auto &result_validity = FlatVector::Validity(result);
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		auto lst_idx = lst_format.sel->get_index(row_idx);
-		if (!lst_format.validity.RowIsValid(lst_idx)) {
-			FlatVector::SetNull(result, row_idx, true);
-			continue;
-		}
-
-		const auto pos_idx = pos_format.sel->get_index(row_idx);
-		if (!pos_format.validity.RowIsValid(pos_idx)) {
-			// We didnt find the key in the map, so return NULL
-			result_validity.SetInvalid(row_idx);
-			continue;
-		}
-
-		// Compute the actual position of the value in the map value vector
-		const auto pos = inc_list_data[lst_idx].offset + UnsafeNumericCast<idx_t>(pos_data[pos_idx] - 1);
-		VectorOperations::Copy(val_vec, result, pos + 1, pos, row_idx);
-	}
-
-	if (args.size() == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(count);
-}
-
-ScalarFunction MapExtractFun::GetFunction() {
-	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, MapExtractFunc, MapExtractBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp b/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp
deleted file mode 100644
index edbe1d4fb..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "core_functions/scalar/map_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-static void MapFromEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto count = args.size();
-
-	MapUtil::ReinterpretMap(result, args.data[0], count);
-	MapVector::MapConversionVerify(result, count);
-	result.Verify(count);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> MapFromEntriesBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() != 1) {
-		throw InvalidInputException("The input argument must be a list of structs.");
-	}
-	auto &list = arguments[0]->return_type;
-
-	if (list.id() == LogicalTypeId::UNKNOWN) {
-		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-
-	if (list.id() != LogicalTypeId::LIST) {
-		throw InvalidInputException("The provided argument is not a list of structs");
-	}
-	auto &elem_type = ListType::GetChildType(list);
-	if (elem_type.id() != LogicalTypeId::STRUCT) {
-		throw InvalidInputException("The elements of the list must be structs");
-	}
-	auto &children = StructType::GetChildTypes(elem_type);
-	if (children.size() != 2) {
-		throw InvalidInputException("The provided struct type should only contain 2 fields, a key and a value");
-	}
-
-	bound_function.return_type = LogicalType::MAP(elem_type);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction MapFromEntriesFun::GetFunction() {
-	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun({}, LogicalTypeId::MAP, MapFromEntriesFunction, MapFromEntriesBind);
-	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
-	fun.varargs = LogicalType::ANY;
-	BaseScalarFunction::SetReturnsError(fun);
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp b/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp
deleted file mode 100644
index 6d99a353e..000000000
--- a/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "core_functions/scalar/map_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-static void MapKeyValueFunction(DataChunk &args, ExpressionState &state, Vector &result,
-                                Vector &(*get_child_vector)(Vector &)) {
-	auto &map = args.data[0];
-
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	if (map.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	auto count = args.size();
-	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
-	auto child = get_child_vector(map);
-
-	auto &entries = ListVector::GetEntry(result);
-	entries.Reference(child);
-
-	UnifiedVectorFormat map_data;
-	map.ToUnifiedFormat(count, map_data);
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	FlatVector::SetData(result, map_data.data);
-	FlatVector::SetValidity(result, map_data.validity);
-	auto list_size = ListVector::GetListSize(map);
-	ListVector::SetListSize(result, list_size);
-	if (map.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		result.Slice(*map_data.sel, count);
-	}
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	result.Verify(count);
-}
-
-static void MapKeysFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	MapKeyValueFunction(args, state, result, MapVector::GetKeys);
-}
-
-static void MapValuesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	MapKeyValueFunction(args, state, result, MapVector::GetValues);
-}
-
-static unique_ptr<FunctionData> MapKeyValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments,
-                                                const LogicalType &(*type_func)(const LogicalType &)) {
-	if (arguments.size() != 1) {
-		throw InvalidInputException("Too many arguments provided, only expecting a single map");
-	}
-	auto &map = arguments[0]->return_type;
-
-	if (map.id() == LogicalTypeId::UNKNOWN) {
-		// Prepared statement
-		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-
-	if (map.id() == LogicalTypeId::SQLNULL) {
-		// Input is NULL, output is NULL[]
-		bound_function.return_type = LogicalType::LIST(LogicalTypeId::SQLNULL);
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	if (map.id() != LogicalTypeId::MAP) {
-		throw InvalidInputException("The provided argument is not a map");
-	}
-
-	auto &type = type_func(map);
-
-	bound_function.return_type = LogicalType::LIST(type);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<FunctionData> MapKeysBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	return MapKeyValueBind(context, bound_function, arguments, MapType::KeyType);
-}
-
-static unique_ptr<FunctionData> MapValuesBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	return MapKeyValueBind(context, bound_function, arguments, MapType::ValueType);
-}
-
-ScalarFunction MapKeysFun::GetFunction() {
-	//! the arguments and return types are actually set in the binder function
-	ScalarFunction function({}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind);
-	function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	BaseScalarFunction::SetReturnsError(function);
-	function.varargs = LogicalType::ANY;
-	return function;
-}
-
-ScalarFunction MapValuesFun::GetFunction() {
-	ScalarFunction function({}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind);
-	function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	BaseScalarFunction::SetReturnsError(function);
-	function.varargs = LogicalType::ANY;
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/math/numeric.cpp b/src/duckdb/extension/core_functions/scalar/math/numeric.cpp
deleted file mode 100644
index 47eed7a79..000000000
--- a/src/duckdb/extension/core_functions/scalar/math/numeric.cpp
+++ /dev/null
@@ -1,1469 +0,0 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/operator/abs.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/numeric_binary_operators.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "core_functions/scalar/math_functions.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-#include <cmath>
-#include <cstdint>
-#include <errno.h>
-#include <limits>
-#include <type_traits>
-
-namespace duckdb {
-
-template <class TR, class OP>
-static scalar_function_t GetScalarIntegerUnaryFunctionFixedReturn(const LogicalType &type) {
-	scalar_function_t function;
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		function = &ScalarFunction::UnaryFunction<int8_t, TR, OP>;
-		break;
-	case LogicalTypeId::SMALLINT:
-		function = &ScalarFunction::UnaryFunction<int16_t, TR, OP>;
-		break;
-	case LogicalTypeId::INTEGER:
-		function = &ScalarFunction::UnaryFunction<int32_t, TR, OP>;
-		break;
-	case LogicalTypeId::BIGINT:
-		function = &ScalarFunction::UnaryFunction<int64_t, TR, OP>;
-		break;
-	case LogicalTypeId::HUGEINT:
-		function = &ScalarFunction::UnaryFunction<hugeint_t, TR, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarIntegerUnaryFunctionFixedReturn");
-	}
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// nextafter
-//===--------------------------------------------------------------------===//
-struct NextAfterOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA base, TB exponent) {
-		throw NotImplementedException("Unimplemented type for NextAfter Function");
-	}
-
-	template <class TA, class TB, class TR>
-	static inline double Operation(double input, double approximate_to) {
-		return nextafter(input, approximate_to);
-	}
-	template <class TA, class TB, class TR>
-	static inline float Operation(float input, float approximate_to) {
-		return nextafterf(input, approximate_to);
-	}
-};
-
-ScalarFunctionSet NextAfterFun::GetFunctions() {
-	ScalarFunctionSet next_after_fun;
-	next_after_fun.AddFunction(
-	    ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::BinaryFunction<double, double, double, NextAfterOperator>));
-	next_after_fun.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
-	                                          ScalarFunction::BinaryFunction<float, float, float, NextAfterOperator>));
-	return next_after_fun;
-}
-
-//===--------------------------------------------------------------------===//
-// abs
-//===--------------------------------------------------------------------===//
-static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	auto &lstats = child_stats[0];
-	Value new_min, new_max;
-	bool potential_overflow = true;
-	if (NumericStats::HasMinMax(lstats)) {
-		switch (expr.return_type.InternalType()) {
-		case PhysicalType::INT8:
-			potential_overflow = NumericStats::Min(lstats).GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
-			break;
-		case PhysicalType::INT16:
-			potential_overflow = NumericStats::Min(lstats).GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
-			break;
-		case PhysicalType::INT32:
-			potential_overflow = NumericStats::Min(lstats).GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
-			break;
-		case PhysicalType::INT64:
-			potential_overflow = NumericStats::Min(lstats).GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
-			break;
-		default:
-			return nullptr;
-		}
-	}
-	if (potential_overflow) {
-		new_min = Value(expr.return_type);
-		new_max = Value(expr.return_type);
-	} else {
-		// no potential overflow
-
-		// compute stats
-		auto current_min = NumericStats::Min(lstats).GetValue<int64_t>();
-		auto current_max = NumericStats::Max(lstats).GetValue<int64_t>();
-
-		int64_t min_val, max_val;
-
-		if (current_min < 0 && current_max < 0) {
-			// if both min and max are below zero, then min=abs(cur_max) and max=abs(cur_min)
-			min_val = AbsValue(current_max);
-			max_val = AbsValue(current_min);
-		} else if (current_min < 0) {
-			D_ASSERT(current_max >= 0);
-			// if min is below zero and max is above 0, then min=0 and max=max(cur_max, abs(cur_min))
-			min_val = 0;
-			max_val = MaxValue(AbsValue(current_min), current_max);
-		} else {
-			// if both current_min and current_max are > 0, then the abs is a no-op and can be removed entirely
-			*input.expr_ptr = std::move(input.expr.children[0]);
-			return child_stats[0].ToUnique();
-		}
-		new_min = Value::Numeric(expr.return_type, min_val);
-		new_max = Value::Numeric(expr.return_type, max_val);
-		expr.function.function = ScalarFunction::GetScalarUnaryFunction<AbsOperator>(expr.return_type);
-	}
-	auto stats = NumericStats::CreateEmpty(expr.return_type);
-	NumericStats::SetMin(stats, new_min);
-	NumericStats::SetMax(stats, new_max);
-	stats.CopyValidity(lstats);
-	return stats.ToUnique();
-}
-
-template <class OP>
-unique_ptr<FunctionData> DecimalUnaryOpBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	switch (decimal_type.InternalType()) {
-	case PhysicalType::INT16:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::SMALLINT);
-		break;
-	case PhysicalType::INT32:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::INTEGER);
-		break;
-	case PhysicalType::INT64:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::BIGINT);
-		break;
-	default:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::HUGEINT);
-		break;
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = decimal_type;
-	return nullptr;
-}
-
-ScalarFunctionSet AbsOperatorFun::GetFunctions() {
-	ScalarFunctionSet abs;
-	for (auto &type : LogicalType::Numeric()) {
-		switch (type.id()) {
-		case LogicalTypeId::DECIMAL:
-			abs.AddFunction(ScalarFunction({type}, type, nullptr, DecimalUnaryOpBind<AbsOperator>));
-			break;
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::HUGEINT: {
-			ScalarFunction function({type}, type, ScalarFunction::GetScalarUnaryFunction<TryAbsOperator>(type));
-			function.statistics = PropagateAbsStats;
-			abs.AddFunction(function);
-			break;
-		}
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::NopFunction));
-			break;
-		default:
-			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::GetScalarUnaryFunction<AbsOperator>(type)));
-			break;
-		}
-	}
-	for (auto &func : abs.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return abs;
-}
-
-//===--------------------------------------------------------------------===//
-// bit_count
-//===--------------------------------------------------------------------===//
-struct BitCntOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		using TU = typename std::make_unsigned<TA>::type;
-		TR count = 0;
-		for (auto value = TU(input); value; ++count) {
-			value &= (value - 1);
-		}
-		return count;
-	}
-};
-
-struct HugeIntBitCntOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		using TU = typename std::make_unsigned<int64_t>::type;
-		TR count = 0;
-
-		for (auto value = TU(input.upper); value; ++count) {
-			value &= (value - 1);
-		}
-		for (auto value = TU(input.lower); value; ++count) {
-			value &= (value - 1);
-		}
-		return count;
-	}
-};
-
-struct BitStringBitCntOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		TR count = Bit::BitCount(input);
-		return count;
-	}
-};
-
-ScalarFunctionSet BitCountFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	functions.AddFunction(ScalarFunction({LogicalType::TINYINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int8_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::SMALLINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int16_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::INTEGER}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int32_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int64_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<hugeint_t, int8_t, HugeIntBitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
-	                                     ScalarFunction::UnaryFunction<string_t, idx_t, BitStringBitCntOperator>));
-	return functions;
-}
-
-//===--------------------------------------------------------------------===//
-// sign
-//===--------------------------------------------------------------------===//
-struct SignOperator {
-	template <class TA, class TR>
-	static TR Operation(TA input) {
-		if (input == TA(0)) {
-			return 0;
-		} else if (input > TA(0)) {
-			return 1;
-		} else {
-			return -1;
-		}
-	}
-};
-
-template <>
-int8_t SignOperator::Operation(float input) {
-	if (input == 0 || Value::IsNan(input)) {
-		return 0;
-	} else if (input > 0) {
-		return 1;
-	} else {
-		return -1;
-	}
-}
-
-template <>
-int8_t SignOperator::Operation(double input) {
-	if (input == 0 || Value::IsNan(input)) {
-		return 0;
-	} else if (input > 0) {
-		return 1;
-	} else {
-		return -1;
-	}
-}
-
-ScalarFunctionSet SignFun::GetFunctions() {
-	ScalarFunctionSet sign;
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			continue;
-		} else {
-			sign.AddFunction(
-			    ScalarFunction({type}, LogicalType::TINYINT,
-			                   ScalarFunction::GetScalarUnaryFunctionFixedReturn<int8_t, SignOperator>(type)));
-		}
-	}
-	return sign;
-}
-
-//===--------------------------------------------------------------------===//
-// ceil
-//===--------------------------------------------------------------------===//
-struct CeilOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::ceil(left);
-	}
-};
-
-template <class T, class POWERS_OF_TEN, class OP>
-static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	OP::template Operation<T, POWERS_OF_TEN>(input, DecimalType::GetScale(func_expr.children[0]->return_type), result);
-}
-
-template <class OP>
-unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context, ScalarFunction &bound_function,
-                                                         vector<unique_ptr<Expression>> &arguments) {
-	// ceil essentially removes the scale
-	auto &decimal_type = arguments[0]->return_type;
-	auto scale = DecimalType::GetScale(decimal_type);
-	auto width = DecimalType::GetWidth(decimal_type);
-	if (scale == 0) {
-		bound_function.function = ScalarFunction::NopFunction;
-	} else {
-		switch (decimal_type.InternalType()) {
-		case PhysicalType::INT16:
-			bound_function.function = GenericRoundFunctionDecimal<int16_t, NumericHelper, OP>;
-			break;
-		case PhysicalType::INT32:
-			bound_function.function = GenericRoundFunctionDecimal<int32_t, NumericHelper, OP>;
-			break;
-		case PhysicalType::INT64:
-			bound_function.function = GenericRoundFunctionDecimal<int64_t, NumericHelper, OP>;
-			break;
-		default:
-			bound_function.function = GenericRoundFunctionDecimal<hugeint_t, Hugeint, OP>;
-			break;
-		}
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = LogicalType::DECIMAL(width, 0);
-	return nullptr;
-}
-
-struct CeilDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input <= 0) {
-				// below 0 we floor the number (e.g. -10.5 -> -10)
-				return UnsafeNumericCast<T>(input / power_of_ten);
-			} else {
-				// above 0 we ceil the number
-				return UnsafeNumericCast<T>(((input - 1) / power_of_ten) + 1);
-			}
-		});
-	}
-};
-
-ScalarFunctionSet CeilFun::GetFunctions() {
-	ScalarFunctionSet ceil;
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		if (type.IsIntegral()) {
-			// no ceil for integral numbers
-			continue;
-		}
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			func = ScalarFunction::UnaryFunction<float, float, CeilOperator>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			func = ScalarFunction::UnaryFunction<double, double, CeilOperator>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<CeilDecimalOperator>;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"ceil\"");
-		}
-		ceil.AddFunction(ScalarFunction({type}, type, func, bind_func));
-	}
-	return ceil;
-}
-
-//===--------------------------------------------------------------------===//
-// floor
-//===--------------------------------------------------------------------===//
-struct FloorOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::floor(left);
-	}
-};
-
-struct FloorDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				// below 0 we ceil the number (e.g. -10.5 -> -11)
-				return UnsafeNumericCast<T>(((input + 1) / power_of_ten) - 1);
-			} else {
-				// above 0 we floor the number
-				return UnsafeNumericCast<T>(input / power_of_ten);
-			}
-		});
-	}
-};
-
-ScalarFunctionSet FloorFun::GetFunctions() {
-	ScalarFunctionSet floor;
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		if (type.IsIntegral()) {
-			// no floor for integral numbers
-			continue;
-		}
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			func = ScalarFunction::UnaryFunction<float, float, FloorOperator>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			func = ScalarFunction::UnaryFunction<double, double, FloorOperator>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<FloorDecimalOperator>;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"floor\"");
-		}
-		floor.AddFunction(ScalarFunction({type}, type, func, bind_func));
-	}
-	return floor;
-}
-
-//===--------------------------------------------------------------------===//
-// trunc
-//===--------------------------------------------------------------------===//
-struct TruncOperator {
-	// Integer truncation is a NOP
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::trunc(left);
-	}
-};
-
-struct TruncDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			//	Always floor
-			return UnsafeNumericCast<T>((input / power_of_ten));
-		});
-	}
-};
-
-ScalarFunctionSet TruncFun::GetFunctions() {
-	ScalarFunctionSet trunc;
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		//	Truncation of integers gets generated by some tools (e.g., Tableau/JDBC:Postgres)
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			func = ScalarFunction::UnaryFunction<float, float, TruncOperator>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<TruncDecimalOperator>;
-			break;
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::HUGEINT:
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-		case LogicalTypeId::UHUGEINT:
-			func = ScalarFunction::NopFunction;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"trunc\"");
-		}
-		trunc.AddFunction(ScalarFunction({type}, type, func, bind_func));
-	}
-	return trunc;
-}
-
-//===--------------------------------------------------------------------===//
-// round
-//===--------------------------------------------------------------------===//
-struct RoundOperatorPrecision {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB precision) {
-		double rounded_value;
-		if (precision < 0) {
-			double modifier = std::pow(10, -TA(precision));
-			rounded_value = (std::round(input / modifier)) * modifier;
-			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
-				return 0;
-			}
-		} else {
-			double modifier = std::pow(10, TA(precision));
-			rounded_value = (std::round(input * modifier)) / modifier;
-			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
-				return input;
-			}
-		}
-		return LossyNumericCast<TR>(rounded_value);
-	}
-};
-
-struct RoundOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		double rounded_value = round(input);
-		if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
-			return input;
-		}
-		return LossyNumericCast<TR>(rounded_value);
-	}
-};
-
-struct RoundDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
-		T addition = power_of_ten / 2;
-		// regular round rounds towards the nearest number
-		// in case of a tie we round away from zero
-		// i.e. -10.5 -> -11, 10.5 -> 11
-		// we implement this by adding (positive) or subtracting (negative) 0.5
-		// and then flooring the number
-		// e.g. 10.5 + 0.5 = 11, floor(11) = 11
-		//      10.4 + 0.5 = 10.9, floor(10.9) = 10
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				input -= addition;
-			} else {
-				input += addition;
-			}
-			return UnsafeNumericCast<T>(input / power_of_ten);
-		});
-	}
-};
-
-struct RoundPrecisionFunctionData : public FunctionData {
-	explicit RoundPrecisionFunctionData(int32_t target_scale) : target_scale(target_scale) {
-	}
-
-	int32_t target_scale;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<RoundPrecisionFunctionData>(target_scale);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<RoundPrecisionFunctionData>();
-		return target_scale == other.target_scale;
-	}
-};
-
-template <class T, class POWERS_OF_TEN_CLASS>
-static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
-	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-	if (info.target_scale <= -int32_t(width - source_scale)) {
-		// scale too big for width
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		result.SetValue(0, Value::INTEGER(0));
-		return;
-	}
-	T divide_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]);
-	T multiply_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]);
-	T addition = divide_power_of_ten / 2;
-
-	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-		if (input < 0) {
-			input -= addition;
-		} else {
-			input += addition;
-		}
-		return UnsafeNumericCast<T>(input / divide_power_of_ten * multiply_power_of_ten);
-	});
-}
-
-template <class T, class POWERS_OF_TEN_CLASS>
-static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
-	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-	T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]);
-	T addition = power_of_ten / 2;
-	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-		if (input < 0) {
-			input -= addition;
-		} else {
-			input += addition;
-		}
-		return UnsafeNumericCast<T>(input / power_of_ten);
-	});
-}
-
-unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	auto &decimal_type = arguments[0]->return_type;
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
-	}
-	Value val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]).DefaultCastAs(LogicalType::INTEGER);
-	if (val.IsNull()) {
-		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
-	}
-	// our new precision becomes the round value
-	// e.g. ROUND(DECIMAL(18,3), 1) -> DECIMAL(18,1)
-	// but ONLY if the round value is positive
-	// if it is negative the scale becomes zero
-	// i.e. ROUND(DECIMAL(18,3), -1) -> DECIMAL(18,0)
-	int32_t round_value = IntegerValue::Get(val);
-	uint8_t target_scale;
-	auto width = DecimalType::GetWidth(decimal_type);
-	auto scale = DecimalType::GetScale(decimal_type);
-	if (round_value < 0) {
-		target_scale = 0;
-		switch (decimal_type.InternalType()) {
-		case PhysicalType::INT16:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<int16_t, NumericHelper>;
-			break;
-		case PhysicalType::INT32:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<int32_t, NumericHelper>;
-			break;
-		case PhysicalType::INT64:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<int64_t, NumericHelper>;
-			break;
-		default:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<hugeint_t, Hugeint>;
-			break;
-		}
-	} else {
-		if (round_value >= (int32_t)scale) {
-			// if round_value is bigger than or equal to scale we do nothing
-			bound_function.function = ScalarFunction::NopFunction;
-			target_scale = scale;
-		} else {
-			target_scale = NumericCast<uint8_t>(round_value);
-			switch (decimal_type.InternalType()) {
-			case PhysicalType::INT16:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<int16_t, NumericHelper>;
-				break;
-			case PhysicalType::INT32:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<int32_t, NumericHelper>;
-				break;
-			case PhysicalType::INT64:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<int64_t, NumericHelper>;
-				break;
-			default:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<hugeint_t, Hugeint>;
-				break;
-			}
-		}
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = LogicalType::DECIMAL(width, target_scale);
-	return make_uniq<RoundPrecisionFunctionData>(round_value);
-}
-
-ScalarFunctionSet RoundFun::GetFunctions() {
-	ScalarFunctionSet round;
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t round_prec_func = nullptr;
-		scalar_function_t round_func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		bind_scalar_function_t bind_prec_func = nullptr;
-		if (type.IsIntegral()) {
-			// no round for integral numbers
-			continue;
-		}
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			round_func = ScalarFunction::UnaryFunction<float, float, RoundOperator>;
-			round_prec_func = ScalarFunction::BinaryFunction<float, int32_t, float, RoundOperatorPrecision>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			round_func = ScalarFunction::UnaryFunction<double, double, RoundOperator>;
-			round_prec_func = ScalarFunction::BinaryFunction<double, int32_t, double, RoundOperatorPrecision>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<RoundDecimalOperator>;
-			bind_prec_func = BindDecimalRoundPrecision;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"floor\"");
-		}
-		round.AddFunction(ScalarFunction({type}, type, round_func, bind_func));
-		round.AddFunction(ScalarFunction({type, LogicalType::INTEGER}, type, round_prec_func, bind_prec_func));
-	}
-	return round;
-}
-
-//===--------------------------------------------------------------------===//
-// exp
-//===--------------------------------------------------------------------===//
-struct ExpOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::exp(left);
-	}
-};
-
-ScalarFunction ExpFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, ExpOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// pow
-//===--------------------------------------------------------------------===//
-struct PowOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA base, TB exponent) {
-		return std::pow(base, exponent);
-	}
-};
-
-ScalarFunction PowOperatorFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::BinaryFunction<double, double, double, PowOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// sqrt
-//===--------------------------------------------------------------------===//
-struct SqrtOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take square root of a negative number");
-		}
-		return std::sqrt(input);
-	}
-};
-
-ScalarFunction SqrtFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, SqrtOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// cbrt
-//===--------------------------------------------------------------------===//
-struct CbRtOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::cbrt(left);
-	}
-};
-
-ScalarFunction CbrtFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, CbRtOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// ln
-//===--------------------------------------------------------------------===//
-
-struct LnOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take logarithm of a negative number");
-		}
-		if (input == 0) {
-			throw OutOfRangeException("cannot take logarithm of zero");
-		}
-		return std::log(input);
-	}
-};
-
-ScalarFunction LnFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, LnOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// log
-//===--------------------------------------------------------------------===//
-struct Log10Operator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take logarithm of a negative number");
-		}
-		if (input == 0) {
-			throw OutOfRangeException("cannot take logarithm of zero");
-		}
-		return std::log10(input);
-	}
-};
-
-ScalarFunction Log10Fun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, Log10Operator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// log with base
-//===--------------------------------------------------------------------===//
-struct LogBaseOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA b, TB x) {
-		auto divisor = Log10Operator::Operation<TA, TR>(b);
-		if (divisor == 0) {
-			throw OutOfRangeException("divison by zero in based logarithm");
-		}
-		return Log10Operator::Operation<TB, TR>(x) / divisor;
-	}
-};
-
-ScalarFunctionSet LogFun::GetFunctions() {
-	ScalarFunctionSet funcs;
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                                 ScalarFunction::UnaryFunction<double, double, Log10Operator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                                 ScalarFunction::BinaryFunction<double, double, double, LogBaseOperator>));
-	for (auto &function : funcs.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return funcs;
-}
-
-//===--------------------------------------------------------------------===//
-// log2
-//===--------------------------------------------------------------------===//
-struct Log2Operator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take logarithm of a negative number");
-		}
-		if (input == 0) {
-			throw OutOfRangeException("cannot take logarithm of zero");
-		}
-		return std::log2(input);
-	}
-};
-
-ScalarFunction Log2Fun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, Log2Operator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// pi
-//===--------------------------------------------------------------------===//
-static void PiFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 0);
-	Value pi_value = Value::DOUBLE(PI);
-	result.Reference(pi_value);
-}
-
-ScalarFunction PiFun::GetFunction() {
-	return ScalarFunction({}, LogicalType::DOUBLE, PiFunction);
-}
-
-//===--------------------------------------------------------------------===//
-// degrees
-//===--------------------------------------------------------------------===//
-struct DegreesOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return left * (180 / PI);
-	}
-};
-
-ScalarFunction DegreesFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, DegreesOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// radians
-//===--------------------------------------------------------------------===//
-struct RadiansOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return left * (PI / 180);
-	}
-};
-
-ScalarFunction RadiansFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, RadiansOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// isnan
-//===--------------------------------------------------------------------===//
-struct IsNanOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Value::IsNan(input);
-	}
-};
-
-ScalarFunctionSet IsNanFun::GetFunctions() {
-	ScalarFunctionSet funcs;
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, IsNanOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, IsNanOperator>));
-	return funcs;
-}
-
-//===--------------------------------------------------------------------===//
-// signbit
-//===--------------------------------------------------------------------===//
-struct SignBitOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return std::signbit(input);
-	}
-};
-
-ScalarFunctionSet SignBitFun::GetFunctions() {
-	ScalarFunctionSet funcs;
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, SignBitOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, SignBitOperator>));
-	return funcs;
-}
-
-//===--------------------------------------------------------------------===//
-// isinf
-//===--------------------------------------------------------------------===//
-struct IsInfiniteOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return !Value::IsNan(input) && !Value::IsFinite(input);
-	}
-};
-
-template <>
-bool IsInfiniteOperator::Operation(date_t input) {
-	return !Value::IsFinite(input);
-}
-
-template <>
-bool IsInfiniteOperator::Operation(timestamp_t input) {
-	return !Value::IsFinite(input);
-}
-
-ScalarFunctionSet IsInfiniteFun::GetFunctions() {
-	ScalarFunctionSet funcs("isinf");
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<date_t, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsInfiniteOperator>));
-	return funcs;
-}
-
-//===--------------------------------------------------------------------===//
-// isfinite
-//===--------------------------------------------------------------------===//
-struct IsFiniteOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Value::IsFinite(input);
-	}
-};
-
-ScalarFunctionSet IsFiniteFun::GetFunctions() {
-	ScalarFunctionSet funcs;
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<date_t, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsFiniteOperator>));
-	return funcs;
-}
-
-//===--------------------------------------------------------------------===//
-// sin
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct NoInfiniteDoubleWrapper {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		if (DUCKDB_UNLIKELY(!Value::IsFinite(input))) {
-			if (Value::IsNan(input)) {
-				return input;
-			}
-			throw OutOfRangeException("input value %lf is out of range for numeric function", input);
-		}
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
-	}
-};
-
-struct SinOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return std::sin(input);
-	}
-};
-
-ScalarFunction SinFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<SinOperator>>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// cos
-//===--------------------------------------------------------------------===//
-struct CosOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::cos(input);
-	}
-};
-
-ScalarFunction CosFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<CosOperator>>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// tan
-//===--------------------------------------------------------------------===//
-struct TanOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::tan(input);
-	}
-};
-
-ScalarFunction TanFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<TanOperator>>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// asin
-//===--------------------------------------------------------------------===//
-struct ASinOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < -1 || input > 1) {
-			throw InvalidInputException("ASIN is undefined outside [-1,1]");
-		}
-		return (double)std::asin(input);
-	}
-};
-
-ScalarFunction AsinFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ASinOperator>>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// atan
-//===--------------------------------------------------------------------===//
-struct ATanOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::atan(input);
-	}
-};
-
-ScalarFunction AtanFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, ATanOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// atan2
-//===--------------------------------------------------------------------===//
-struct ATan2 {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return (double)std::atan2(left, right);
-	}
-};
-
-ScalarFunction Atan2Fun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::BinaryFunction<double, double, double, ATan2>);
-}
-
-//===--------------------------------------------------------------------===//
-// acos
-//===--------------------------------------------------------------------===//
-struct ACos {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < -1 || input > 1) {
-			throw InvalidInputException("ACOS is undefined outside [-1,1]");
-		}
-		return (double)std::acos(input);
-	}
-};
-
-ScalarFunction AcosFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ACos>>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// cosh
-//===--------------------------------------------------------------------===//
-struct CoshOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::cosh(input);
-	}
-};
-
-ScalarFunction CoshFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, CoshOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// acosh
-//===--------------------------------------------------------------------===//
-struct AcoshOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::acosh(input);
-	}
-};
-
-ScalarFunction AcoshFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, AcoshOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// sinh
-//===--------------------------------------------------------------------===//
-struct SinhOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::sinh(input);
-	}
-};
-
-ScalarFunction SinhFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, SinhOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// asinh
-//===--------------------------------------------------------------------===//
-struct AsinhOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::asinh(input);
-	}
-};
-
-ScalarFunction AsinhFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, AsinhOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// tanh
-//===--------------------------------------------------------------------===//
-struct TanhOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::tanh(input);
-	}
-};
-
-ScalarFunction TanhFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, TanhOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// atanh
-//===--------------------------------------------------------------------===//
-struct AtanhOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < -1 || input > 1) {
-			throw InvalidInputException("ATANH is undefined outside [-1,1]");
-		}
-		if (input == -1 || input == 1) {
-			return INFINITY;
-		}
-		return (double)std::atanh(input);
-	}
-};
-
-ScalarFunction AtanhFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, AtanhOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// cot
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct NoInfiniteNoZeroDoubleWrapper {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		if (DUCKDB_UNLIKELY(!Value::IsFinite(input))) {
-			if (Value::IsNan(input)) {
-				return input;
-			}
-			throw OutOfRangeException("input value %lf is out of range for numeric function", input);
-		}
-		if (DUCKDB_UNLIKELY((double)input == 0.0 || (double)input == -0.0)) {
-			throw OutOfRangeException("input value %lf is out of range for numeric function cotangent", input);
-		}
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
-	}
-};
-
-struct CotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return 1.0 / (double)std::tan(input);
-	}
-};
-
-ScalarFunction CotFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteNoZeroDoubleWrapper<CotOperator>>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// gamma
-//===--------------------------------------------------------------------===//
-struct GammaOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input == 0) {
-			throw OutOfRangeException("cannot take gamma of zero");
-		}
-		return std::tgamma(input);
-	}
-};
-
-ScalarFunction GammaFun::GetFunction() {
-	auto func = ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                           ScalarFunction::UnaryFunction<double, double, GammaOperator>);
-	BaseScalarFunction::SetReturnsError(func);
-	return func;
-}
-
-//===--------------------------------------------------------------------===//
-// gamma
-//===--------------------------------------------------------------------===//
-struct LogGammaOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input == 0) {
-			throw OutOfRangeException("cannot take log gamma of zero");
-		}
-		return std::lgamma(input);
-	}
-};
-
-ScalarFunction LogGammaFun::GetFunction() {
-	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                        ScalarFunction::UnaryFunction<double, double, LogGammaOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// factorial(), !
-//===--------------------------------------------------------------------===//
-struct FactorialOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		TR ret = 1;
-		for (TA i = 2; i <= left; i++) {
-			if (!TryMultiplyOperator::Operation(ret, TR(i), ret)) {
-				throw OutOfRangeException("Value out of range");
-			}
-		}
-		return ret;
-	}
-};
-
-ScalarFunction FactorialOperatorFun::GetFunction() {
-	ScalarFunction function({LogicalType::INTEGER}, LogicalType::HUGEINT,
-	                        ScalarFunction::UnaryFunction<int32_t, hugeint_t, FactorialOperator>);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// even
-//===--------------------------------------------------------------------===//
-struct EvenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		double value;
-		if (left >= 0) {
-			value = std::ceil(left);
-		} else {
-			value = std::ceil(-left);
-			value = -value;
-		}
-		if (std::floor(value / 2) * 2 != value) {
-			if (left >= 0) {
-				return value += 1;
-			}
-			return value -= 1;
-		}
-		return value;
-	}
-};
-
-ScalarFunction EvenFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, EvenOperator>);
-}
-
-//===--------------------------------------------------------------------===//
-// gcd
-//===--------------------------------------------------------------------===//
-
-// should be replaced with std::gcd in a newer C++ standard
-template <class TA>
-TA GreatestCommonDivisor(TA left, TA right) {
-	TA a = left;
-	TA b = right;
-
-	// This protects the following modulo operations from a corner case,
-	// where we would get a runtime error due to an integer overflow.
-	if ((left == NumericLimits<TA>::Minimum() && right == -1) ||
-	    (left == -1 && right == NumericLimits<TA>::Minimum())) {
-		return 1;
-	}
-
-	while (true) {
-		if (a == 0) {
-			return TryAbsOperator::Operation<TA, TA>(b);
-		}
-		b %= a;
-
-		if (b == 0) {
-			return TryAbsOperator::Operation<TA, TA>(a);
-		}
-		a %= b;
-	}
-}
-
-struct GreatestCommonDivisorOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return GreatestCommonDivisor(left, right);
-	}
-};
-
-ScalarFunctionSet GreatestCommonDivisorFun::GetFunctions() {
-	ScalarFunctionSet funcs;
-	funcs.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
-	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, GreatestCommonDivisorOperator>));
-	funcs.AddFunction(
-	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
-	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, GreatestCommonDivisorOperator>));
-	return funcs;
-}
-
-//===--------------------------------------------------------------------===//
-// lcm
-//===--------------------------------------------------------------------===//
-
-// should be replaced with std::lcm in a newer C++ standard
-struct LeastCommonMultipleOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		if (left == 0 || right == 0) {
-			return 0;
-		}
-		TR result;
-		if (!TryMultiplyOperator::Operation<TA, TB, TR>(left, right / GreatestCommonDivisor(left, right), result)) {
-			throw OutOfRangeException("lcm value is out of range");
-		}
-		return TryAbsOperator::Operation<TR, TR>(result);
-	}
-};
-
-ScalarFunctionSet LeastCommonMultipleFun::GetFunctions() {
-	ScalarFunctionSet funcs;
-
-	funcs.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
-	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, LeastCommonMultipleOperator>));
-	funcs.AddFunction(
-	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
-	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, LeastCommonMultipleOperator>));
-	for (auto &function : funcs.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return funcs;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp b/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp
deleted file mode 100644
index 103e0c2ab..000000000
--- a/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-#include "core_functions/scalar/operators_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/bit.hpp"
-
-namespace duckdb {
-
-template <class OP>
-static scalar_function_t GetScalarIntegerUnaryFunction(const LogicalType &type) {
-	scalar_function_t function;
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		function = &ScalarFunction::UnaryFunction<int8_t, int8_t, OP>;
-		break;
-	case LogicalTypeId::SMALLINT:
-		function = &ScalarFunction::UnaryFunction<int16_t, int16_t, OP>;
-		break;
-	case LogicalTypeId::INTEGER:
-		function = &ScalarFunction::UnaryFunction<int32_t, int32_t, OP>;
-		break;
-	case LogicalTypeId::BIGINT:
-		function = &ScalarFunction::UnaryFunction<int64_t, int64_t, OP>;
-		break;
-	case LogicalTypeId::UTINYINT:
-		function = &ScalarFunction::UnaryFunction<uint8_t, uint8_t, OP>;
-		break;
-	case LogicalTypeId::USMALLINT:
-		function = &ScalarFunction::UnaryFunction<uint16_t, uint16_t, OP>;
-		break;
-	case LogicalTypeId::UINTEGER:
-		function = &ScalarFunction::UnaryFunction<uint32_t, uint32_t, OP>;
-		break;
-	case LogicalTypeId::UBIGINT:
-		function = &ScalarFunction::UnaryFunction<uint64_t, uint64_t, OP>;
-		break;
-	case LogicalTypeId::HUGEINT:
-		function = &ScalarFunction::UnaryFunction<hugeint_t, hugeint_t, OP>;
-		break;
-	case LogicalTypeId::UHUGEINT:
-		function = &ScalarFunction::UnaryFunction<uhugeint_t, uhugeint_t, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarIntegerUnaryFunction");
-	}
-	return function;
-}
-
-template <class OP>
-static scalar_function_t GetScalarIntegerBinaryFunction(const LogicalType &type) {
-	scalar_function_t function;
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		function = &ScalarFunction::BinaryFunction<int8_t, int8_t, int8_t, OP>;
-		break;
-	case LogicalTypeId::SMALLINT:
-		function = &ScalarFunction::BinaryFunction<int16_t, int16_t, int16_t, OP>;
-		break;
-	case LogicalTypeId::INTEGER:
-		function = &ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, OP>;
-		break;
-	case LogicalTypeId::BIGINT:
-		function = &ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, OP>;
-		break;
-	case LogicalTypeId::UTINYINT:
-		function = &ScalarFunction::BinaryFunction<uint8_t, uint8_t, uint8_t, OP>;
-		break;
-	case LogicalTypeId::USMALLINT:
-		function = &ScalarFunction::BinaryFunction<uint16_t, uint16_t, uint16_t, OP>;
-		break;
-	case LogicalTypeId::UINTEGER:
-		function = &ScalarFunction::BinaryFunction<uint32_t, uint32_t, uint32_t, OP>;
-		break;
-	case LogicalTypeId::UBIGINT:
-		function = &ScalarFunction::BinaryFunction<uint64_t, uint64_t, uint64_t, OP>;
-		break;
-	case LogicalTypeId::HUGEINT:
-		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
-		break;
-	case LogicalTypeId::UHUGEINT:
-		function = &ScalarFunction::BinaryFunction<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarIntegerBinaryFunction");
-	}
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// & [bitwise_and]
-//===--------------------------------------------------------------------===//
-struct BitwiseANDOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left & right;
-	}
-};
-
-static void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
-		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
-
-		    Bit::BitwiseAnd(rhs, lhs, target);
-		    return target;
-	    });
-}
-
-ScalarFunctionSet BitwiseAndFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
-	}
-	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseANDOperation));
-	for (auto &function : functions.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-//===--------------------------------------------------------------------===//
-// | [bitwise_or]
-//===--------------------------------------------------------------------===//
-struct BitwiseOROperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left | right;
-	}
-};
-
-static void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
-		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
-
-		    Bit::BitwiseOr(rhs, lhs, target);
-		    return target;
-	    });
-}
-
-ScalarFunctionSet BitwiseOrFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseOROperator>(type)));
-	}
-	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseOROperation));
-	for (auto &function : functions.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-//===--------------------------------------------------------------------===//
-// # [bitwise_xor]
-//===--------------------------------------------------------------------===//
-struct BitwiseXOROperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left ^ right;
-	}
-};
-
-static void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
-		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
-
-		    Bit::BitwiseXor(rhs, lhs, target);
-		    return target;
-	    });
-}
-
-ScalarFunctionSet BitwiseXorFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseXOROperator>(type)));
-	}
-	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseXOROperation));
-	for (auto &function : functions.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-//===--------------------------------------------------------------------===//
-// ~ [bitwise_not]
-//===--------------------------------------------------------------------===//
-struct BitwiseNotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return ~input;
-	}
-};
-
-static void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::Execute<string_t, string_t>(args.data[0], result, args.size(), [&](string_t input) {
-		string_t target = StringVector::EmptyString(result, input.GetSize());
-
-		Bit::BitwiseNot(input, target);
-		return target;
-	});
-}
-
-ScalarFunctionSet BitwiseNotFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction<BitwiseNotOperator>(type)));
-	}
-	functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIT, BitwiseNOTOperation));
-	for (auto &function : functions.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-//===--------------------------------------------------------------------===//
-// << [bitwise_left_shift]
-//===--------------------------------------------------------------------===//
-struct BitwiseShiftLeftOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB shift) {
-		TA max_shift = TA(sizeof(TA) * 8) + (NumericLimits<TA>::IsSigned() ? 0 : 1);
-		if (input < 0) {
-			throw OutOfRangeException("Cannot left-shift negative number %s", NumericHelper::ToString(input));
-		}
-		if (shift < 0) {
-			throw OutOfRangeException("Cannot left-shift by negative number %s", NumericHelper::ToString(shift));
-		}
-		if (shift >= max_shift) {
-			if (input == 0) {
-				return 0;
-			}
-			throw OutOfRangeException("Left-shift value %s is out of range", NumericHelper::ToString(shift));
-		}
-		if (shift == 0) {
-			return input;
-		}
-		TA max_value = UnsafeNumericCast<TA>((TA(1) << (max_shift - shift - 1)));
-		if (input >= max_value) {
-			throw OutOfRangeException("Overflow in left shift (%s << %s)", NumericHelper::ToString(input),
-			                          NumericHelper::ToString(shift));
-		}
-		return UnsafeNumericCast<TR>(input << shift);
-	}
-};
-
-static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, int32_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
-		    auto max_shift = UnsafeNumericCast<int32_t>(Bit::BitLength(input));
-		    if (shift == 0) {
-			    return input;
-		    }
-		    if (shift < 0) {
-			    throw OutOfRangeException("Cannot left-shift by negative number %s", NumericHelper::ToString(shift));
-		    }
-		    string_t target = StringVector::EmptyString(result, input.GetSize());
-
-		    if (shift >= max_shift) {
-			    Bit::SetEmptyBitString(target, input);
-			    return target;
-		    }
-		    Bit::LeftShift(input, UnsafeNumericCast<idx_t>(shift), target);
-		    return target;
-	    });
-}
-
-ScalarFunctionSet LeftShiftFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftLeftOperator>(type)));
-	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftLeftOperation));
-	for (auto &function : functions.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-//===--------------------------------------------------------------------===//
-// >> [bitwise_right_shift]
-//===--------------------------------------------------------------------===//
-template <class T>
-bool RightShiftInRange(T shift) {
-	return shift >= 0 && shift < T(sizeof(T) * 8);
-}
-
-struct BitwiseShiftRightOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB shift) {
-		return RightShiftInRange(shift) ? input >> shift : 0;
-	}
-};
-
-static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, int32_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
-		    auto max_shift = UnsafeNumericCast<int32_t>(Bit::BitLength(input));
-		    if (shift == 0) {
-			    return input;
-		    }
-		    string_t target = StringVector::EmptyString(result, input.GetSize());
-		    if (shift < 0 || shift >= max_shift) {
-			    Bit::SetEmptyBitString(target, input);
-			    return target;
-		    }
-		    Bit::RightShift(input, UnsafeNumericCast<idx_t>(shift), target);
-		    return target;
-	    });
-}
-
-ScalarFunctionSet RightShiftFun::GetFunctions() {
-	ScalarFunctionSet functions;
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftRightOperator>(type)));
-	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftRightOperation));
-	for (auto &function : functions.functions) {
-		BaseScalarFunction::SetReturnsError(function);
-	}
-	return functions;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/random/random.cpp b/src/duckdb/extension/core_functions/scalar/random/random.cpp
deleted file mode 100644
index 3054170ff..000000000
--- a/src/duckdb/extension/core_functions/scalar/random/random.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "core_functions/scalar/random_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/types/uuid.hpp"
-
-namespace duckdb {
-
-struct RandomLocalState : public FunctionLocalState {
-	explicit RandomLocalState(uint64_t seed) : random_engine(0) {
-		random_engine.SetSeed(seed);
-	}
-
-	RandomEngine random_engine;
-};
-
-static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<double>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i] = lstate.random_engine.NextRandom();
-	}
-}
-
-static unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                           FunctionData *bind_data) {
-	auto &random_engine = RandomEngine::Get(state.GetContext());
-	lock_guard<mutex> guard(random_engine.lock);
-	return make_uniq<RandomLocalState>(random_engine.NextRandomInteger64());
-}
-
-ScalarFunction RandomFun::GetFunction() {
-	ScalarFunction random("random", {}, LogicalType::DOUBLE, RandomFunction, nullptr, nullptr, nullptr,
-	                      RandomInitLocalState);
-	random.stability = FunctionStability::VOLATILE;
-	return random;
-}
-
-static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<hugeint_t>(result);
-
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i] = UUID::GenerateRandomUUID(lstate.random_engine);
-	}
-}
-
-ScalarFunction UUIDFun::GetFunction() {
-	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, nullptr, nullptr, nullptr,
-	                             RandomInitLocalState);
-	// generate a random uuid
-	uuid_function.stability = FunctionStability::VOLATILE;
-	return uuid_function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/random/setseed.cpp b/src/duckdb/extension/core_functions/scalar/random/setseed.cpp
deleted file mode 100644
index ca2865284..000000000
--- a/src/duckdb/extension/core_functions/scalar/random/setseed.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "core_functions/scalar/random_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/random_engine.hpp"
-
-namespace duckdb {
-
-struct SetseedBindData : public FunctionData {
-	//! The client context for the function call
-	ClientContext &context;
-
-	explicit SetseedBindData(ClientContext &context) : context(context) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<SetseedBindData>(context);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		return true;
-	}
-};
-
-static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<SetseedBindData>();
-	auto &input = args.data[0];
-	input.Flatten(args.size());
-
-	auto input_seeds = FlatVector::GetData<double>(input);
-	uint32_t half_max = NumericLimits<uint32_t>::Maximum() / 2;
-
-	auto &random_engine = RandomEngine::Get(info.context);
-	for (idx_t i = 0; i < args.size(); i++) {
-		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0 || Value::IsNan(input_seeds[i])) {
-			throw InvalidInputException("SETSEED accepts seed values between -1.0 and 1.0, inclusive");
-		}
-		auto norm_seed = LossyNumericCast<uint32_t>((input_seeds[i] + 1.0) * half_max);
-		random_engine.SetSeed(norm_seed);
-	}
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::SetNull(result, true);
-}
-
-unique_ptr<FunctionData> SetSeedBind(ClientContext &context, ScalarFunction &bound_function,
-                                     vector<unique_ptr<Expression>> &arguments) {
-	return make_uniq<SetseedBindData>(context);
-}
-
-ScalarFunction SetseedFun::GetFunction() {
-	ScalarFunction setseed("setseed", {LogicalType::DOUBLE}, LogicalType::SQLNULL, SetSeedFunction, SetSeedBind);
-	setseed.stability = FunctionStability::VOLATILE;
-	BaseScalarFunction::SetReturnsError(setseed);
-	return setseed;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/ascii.cpp b/src/duckdb/extension/core_functions/scalar/string/ascii.cpp
deleted file mode 100644
index 4083c85de..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/ascii.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "utf8proc.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-struct AsciiOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		auto str = input.GetData();
-		if (Utf8Proc::Analyze(str, input.GetSize()) == UnicodeType::ASCII) {
-			return str[0];
-		}
-		int utf8_bytes = 4;
-		return Utf8Proc::UTF8ToCodepoint(str, utf8_bytes);
-	}
-};
-
-ScalarFunction ASCIIFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                      ScalarFunction::UnaryFunction<string_t, int32_t, AsciiOperator>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/bar.cpp b/src/duckdb/extension/core_functions/scalar/string/bar.cpp
deleted file mode 100644
index 957b8c624..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/bar.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/unicode_bar.hpp"
-#include "duckdb/common/vector_operations/generic_executor.hpp"
-
-namespace duckdb {
-
-static string_t BarScalarFunction(double x, double min, double max, double max_width, string &result) {
-	static const char *FULL_BLOCK = UnicodeBar::FullBlock();
-	static const char *const *PARTIAL_BLOCKS = UnicodeBar::PartialBlocks();
-	static const idx_t PARTIAL_BLOCKS_COUNT = UnicodeBar::PartialBlocksCount();
-
-	if (!Value::IsFinite(max_width)) {
-		throw OutOfRangeException("Max bar width must not be NaN or infinity");
-	}
-	if (max_width < 1) {
-		throw OutOfRangeException("Max bar width must be >= 1");
-	}
-	if (max_width > 1000) {
-		throw OutOfRangeException("Max bar width must be <= 1000");
-	}
-
-	double width;
-
-	if (Value::IsNan(x) || Value::IsNan(min) || Value::IsNan(max) || x <= min) {
-		width = 0;
-	} else if (x >= max) {
-		width = max_width;
-	} else {
-		width = max_width * (x - min) / (max - min);
-	}
-
-	if (!Value::IsFinite(width)) {
-		throw OutOfRangeException("Bar width must not be NaN or infinity");
-	}
-
-	result.clear();
-	idx_t used_blocks = 0;
-
-	auto width_as_int = LossyNumericCast<uint32_t>(width * PARTIAL_BLOCKS_COUNT);
-	idx_t full_blocks_count = (width_as_int / PARTIAL_BLOCKS_COUNT);
-	for (idx_t i = 0; i < full_blocks_count; i++) {
-		used_blocks++;
-		result += FULL_BLOCK;
-	}
-
-	idx_t remaining = width_as_int % PARTIAL_BLOCKS_COUNT;
-
-	if (remaining) {
-		used_blocks++;
-		result += PARTIAL_BLOCKS[remaining];
-	}
-
-	const idx_t integer_max_width = (idx_t)max_width;
-	if (used_blocks < integer_max_width) {
-		result += std::string(integer_max_width - used_blocks, ' ');
-	}
-	return string_t(result);
-}
-
-static void BarFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
-	auto &x_arg = args.data[0];
-	auto &min_arg = args.data[1];
-	auto &max_arg = args.data[2];
-	string buffer;
-
-	if (args.ColumnCount() == 3) {
-		GenericExecutor::ExecuteTernary<PrimitiveType<double>, PrimitiveType<double>, PrimitiveType<double>,
-		                                PrimitiveType<string_t>>(
-		    x_arg, min_arg, max_arg, result, args.size(),
-		    [&](PrimitiveType<double> x, PrimitiveType<double> min, PrimitiveType<double> max) {
-			    return StringVector::AddString(result, BarScalarFunction(x.val, min.val, max.val, 80, buffer));
-		    });
-	} else {
-		auto &width_arg = args.data[3];
-		GenericExecutor::ExecuteQuaternary<PrimitiveType<double>, PrimitiveType<double>, PrimitiveType<double>,
-		                                   PrimitiveType<double>, PrimitiveType<string_t>>(
-		    x_arg, min_arg, max_arg, width_arg, result, args.size(),
-		    [&](PrimitiveType<double> x, PrimitiveType<double> min, PrimitiveType<double> max,
-		        PrimitiveType<double> width) {
-			    return StringVector::AddString(result, BarScalarFunction(x.val, min.val, max.val, width.val, buffer));
-		    });
-	}
-}
-
-ScalarFunctionSet BarFun::GetFunctions() {
-	ScalarFunctionSet bar;
-	bar.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE},
-	                               LogicalType::VARCHAR, BarFunction));
-	bar.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE},
-	                               LogicalType::VARCHAR, BarFunction));
-	return bar;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/chr.cpp b/src/duckdb/extension/core_functions/scalar/string/chr.cpp
deleted file mode 100644
index bca2de6d8..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/chr.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "utf8proc.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-struct ChrOperator {
-	static void GetCodepoint(int32_t input, char c[], int &utf8_bytes) {
-		if (input < 0 || !Utf8Proc::CodepointToUtf8(input, utf8_bytes, &c[0])) {
-			throw InvalidInputException("Invalid UTF8 Codepoint %d", input);
-		}
-	}
-
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		char c[5] = {'\0', '\0', '\0', '\0', '\0'};
-		int utf8_bytes;
-		GetCodepoint(input, c, utf8_bytes);
-		return string_t(&c[0], UnsafeNumericCast<uint32_t>(utf8_bytes));
-	}
-};
-
-#ifdef DUCKDB_DEBUG_NO_INLINE
-// the chr function depends on the data always being inlined (which is always possible, since it outputs max 4 bytes)
-// to enable chr when string inlining is disabled we create a special function here
-static void ChrFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &code_vec = args.data[0];
-
-	char c[5] = {'\0', '\0', '\0', '\0', '\0'};
-	int utf8_bytes;
-	UnaryExecutor::Execute<int32_t, string_t>(code_vec, result, args.size(), [&](int32_t input) {
-		ChrOperator::GetCodepoint(input, c, utf8_bytes);
-		return StringVector::AddString(result, &c[0], UnsafeNumericCast<uint32_t>(utf8_bytes));
-	});
-}
-#endif
-
-ScalarFunction ChrFun::GetFunction() {
-	return ScalarFunction("chr", {LogicalType::INTEGER}, LogicalType::VARCHAR,
-#ifdef DUCKDB_DEBUG_NO_INLINE
-	                      ChrFunction
-#else
-	                      ScalarFunction::UnaryFunction<int32_t, string_t, ChrOperator>
-#endif
-	);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/damerau_levenshtein.cpp b/src/duckdb/extension/core_functions/scalar/string/damerau_levenshtein.cpp
deleted file mode 100644
index 91b0fbd33..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/damerau_levenshtein.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-// Using Lowrance-Wagner (LW) algorithm: https://doi.org/10.1145%2F321879.321880
-// Can't calculate as trivial modification to levenshtein algorithm
-// as we need to potentially know about earlier in the string
-static idx_t DamerauLevenshteinDistance(const string_t &source, const string_t &target) {
-	// costs associated with each type of edit, to aid readability
-	constexpr uint8_t COST_SUBSTITUTION = 1;
-	constexpr uint8_t COST_INSERTION = 1;
-	constexpr uint8_t COST_DELETION = 1;
-	constexpr uint8_t COST_TRANSPOSITION = 1;
-	const auto source_len = source.GetSize();
-	const auto target_len = target.GetSize();
-
-	// If one string is empty, the distance equals the length of the other string
-	// either through target_len insertions
-	// or source_len deletions
-	if (source_len == 0) {
-		return target_len * COST_INSERTION;
-	} else if (target_len == 0) {
-		return source_len * COST_DELETION;
-	}
-
-	const auto source_str = source.GetData();
-	const auto target_str = target.GetData();
-
-	// larger than the largest possible value:
-	const auto inf = source_len * COST_DELETION + target_len * COST_INSERTION + 1;
-	// minimum edit distance from prefix of source string to prefix of target string
-	// same object as H in LW paper (with indices offset by 1)
-	vector<vector<idx_t>> distance(source_len + 2, vector<idx_t>(target_len + 2, inf));
-	// keeps track of the largest string indices of source string matching each character
-	// same as DA in LW paper
-	map<char, idx_t> largest_source_chr_matching;
-
-	// initialise row/column corresponding to zero-length strings
-	// partial string -> empty requires a deletion for each character
-	for (idx_t source_idx = 0; source_idx <= source_len; source_idx++) {
-		distance[source_idx + 1][1] = source_idx * COST_DELETION;
-	}
-	// and empty -> partial string means simply inserting characters
-	for (idx_t target_idx = 1; target_idx <= target_len; target_idx++) {
-		distance[1][target_idx + 1] = target_idx * COST_INSERTION;
-	}
-	// loop through string indices - these are offset by 2 from distance indices
-	for (idx_t source_idx = 0; source_idx < source_len; source_idx++) {
-		// keeps track of the largest string indices of target string matching current source character
-		// same as DB in LW paper
-		idx_t largest_target_chr_matching;
-		largest_target_chr_matching = 0;
-		for (idx_t target_idx = 0; target_idx < target_len; target_idx++) {
-			// correspond to i1 and j1 in LW paper respectively
-			idx_t largest_source_chr_matching_target;
-			idx_t largest_target_chr_matching_source;
-			// cost associated to diagnanl shift in distance matrix
-			// corresponds to d in LW paper
-			uint8_t cost_diagonal_shift;
-			largest_source_chr_matching_target = largest_source_chr_matching[target_str[target_idx]];
-			largest_target_chr_matching_source = largest_target_chr_matching;
-			// if characters match, diagonal move costs nothing and we update our largest target index
-			// otherwise move is substitution and costs as such
-			if (source_str[source_idx] == target_str[target_idx]) {
-				cost_diagonal_shift = 0;
-				largest_target_chr_matching = target_idx + 1;
-			} else {
-				cost_diagonal_shift = COST_SUBSTITUTION;
-			}
-			distance[source_idx + 2][target_idx + 2] = MinValue(
-			    distance[source_idx + 1][target_idx + 1] + cost_diagonal_shift,
-			    MinValue(distance[source_idx + 2][target_idx + 1] + COST_INSERTION,
-			             MinValue(distance[source_idx + 1][target_idx + 2] + COST_DELETION,
-			                      distance[largest_source_chr_matching_target][largest_target_chr_matching_source] +
-			                          (source_idx - largest_source_chr_matching_target) * COST_DELETION +
-			                          COST_TRANSPOSITION +
-			                          (target_idx - largest_target_chr_matching_source) * COST_INSERTION)));
-		}
-		largest_source_chr_matching[source_str[source_idx]] = source_idx + 1;
-	}
-	return distance[source_len + 1][target_len + 1];
-}
-
-static int64_t DamerauLevenshteinScalarFunction(Vector &result, const string_t source, const string_t target) {
-	return (int64_t)DamerauLevenshteinDistance(source, target);
-}
-
-static void DamerauLevenshteinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &source_vec = args.data[0];
-	auto &target_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, int64_t>(
-	    source_vec, target_vec, result, args.size(),
-	    [&](string_t source, string_t target) { return DamerauLevenshteinScalarFunction(result, source, target); });
-}
-
-ScalarFunction DamerauLevenshteinFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                      DamerauLevenshteinFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/format_bytes.cpp b/src/duckdb/extension/core_functions/scalar/string/format_bytes.cpp
deleted file mode 100644
index 46db22f25..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/format_bytes.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-template <int64_t MULTIPLIER>
-static void FormatBytesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::Execute<int64_t, string_t>(args.data[0], result, args.size(), [&](int64_t bytes) {
-		bool is_negative = bytes < 0;
-		idx_t unsigned_bytes;
-		if (bytes < 0) {
-			if (bytes == NumericLimits<int64_t>::Minimum()) {
-				unsigned_bytes = idx_t(NumericLimits<int64_t>::Maximum()) + 1;
-			} else {
-				unsigned_bytes = idx_t(-bytes);
-			}
-		} else {
-			unsigned_bytes = idx_t(bytes);
-		}
-		return StringVector::AddString(result, (is_negative ? "-" : "") +
-		                                           StringUtil::BytesToHumanReadableString(unsigned_bytes, MULTIPLIER));
-	});
-}
-
-ScalarFunction FormatBytesFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, FormatBytesFunction<1024>);
-}
-
-ScalarFunction FormatreadabledecimalsizeFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, FormatBytesFunction<1000>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/hamming.cpp b/src/duckdb/extension/core_functions/scalar/string/hamming.cpp
deleted file mode 100644
index b32a80199..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/hamming.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include <ctype.h>
-#include <algorithm>
-
-namespace duckdb {
-
-static int64_t MismatchesScalarFunction(Vector &result, const string_t str, string_t tgt) {
-	idx_t str_len = str.GetSize();
-	idx_t tgt_len = tgt.GetSize();
-
-	if (str_len != tgt_len) {
-		throw InvalidInputException("Mismatch Function: Strings must be of equal length!");
-	}
-	if (str_len < 1) {
-		throw InvalidInputException("Mismatch Function: Strings must be of length > 0!");
-	}
-
-	idx_t mismatches = 0;
-	auto str_str = str.GetData();
-	auto tgt_str = tgt.GetData();
-
-	for (idx_t idx = 0; idx < str_len; ++idx) {
-		if (str_str[idx] != tgt_str[idx]) {
-			mismatches++;
-		}
-	}
-	return (int64_t)mismatches;
-}
-
-static void MismatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &tgt_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, int64_t>(
-	    str_vec, tgt_vec, result, args.size(),
-	    [&](string_t str, string_t tgt) { return MismatchesScalarFunction(result, str, tgt); });
-}
-
-ScalarFunction HammingFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT, MismatchesFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/hex.cpp b/src/duckdb/extension/core_functions/scalar/string/hex.cpp
deleted file mode 100644
index cbf541e1b..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/hex.cpp
+++ /dev/null
@@ -1,440 +0,0 @@
-#include "duckdb/common/bit_utils.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/blob.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "core_functions/scalar/string_functions.hpp"
-
-namespace duckdb {
-
-static void WriteHexBytes(uint64_t x, char *&output, idx_t buffer_size) {
-	idx_t offset = buffer_size * 4;
-
-	for (; offset >= 4; offset -= 4) {
-		uint8_t byte = (x >> (offset - 4)) & 0x0F;
-		*output = Blob::HEX_TABLE[byte];
-		output++;
-	}
-}
-
-template <class T>
-static void WriteHugeIntHexBytes(T x, char *&output, idx_t buffer_size) {
-	idx_t offset = buffer_size * 4;
-	auto upper = x.upper;
-	auto lower = x.lower;
-
-	for (; offset >= 68; offset -= 4) {
-		uint8_t byte = (upper >> (offset - 68)) & 0x0F;
-		*output = Blob::HEX_TABLE[byte];
-		output++;
-	}
-
-	for (; offset >= 4; offset -= 4) {
-		uint8_t byte = (lower >> (offset - 4)) & 0x0F;
-		*output = Blob::HEX_TABLE[byte];
-		output++;
-	}
-}
-
-static void WriteBinBytes(uint64_t x, char *&output, idx_t buffer_size) {
-	idx_t offset = buffer_size;
-	for (; offset >= 1; offset -= 1) {
-		*output = NumericCast<char>(((x >> (offset - 1)) & 0x01) + '0');
-		output++;
-	}
-}
-
-template <class T>
-static void WriteHugeIntBinBytes(T x, char *&output, idx_t buffer_size) {
-	auto upper = x.upper;
-	auto lower = x.lower;
-	idx_t offset = buffer_size;
-
-	for (; offset >= 65; offset -= 1) {
-		*output = ((upper >> (offset - 65)) & 0x01) + '0';
-		output++;
-	}
-
-	for (; offset >= 1; offset -= 1) {
-		*output = ((lower >> (offset - 1)) & 0x01) + '0';
-		output++;
-	}
-}
-
-struct HexStrOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetData();
-		auto size = input.GetSize();
-
-		// Allocate empty space
-		auto target = StringVector::EmptyString(result, size * 2);
-		auto output = target.GetDataWriteable();
-
-		for (idx_t i = 0; i < size; ++i) {
-			*output = Blob::HEX_TABLE[(data[i] >> 4) & 0x0F];
-			output++;
-			*output = Blob::HEX_TABLE[data[i] & 0x0F];
-			output++;
-		}
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct HexIntegralOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-
-		auto num_leading_zero = CountZeros<uint64_t>::Leading(static_cast<uint64_t>(input));
-		idx_t num_bits_to_check = 64 - num_leading_zero;
-		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
-
-		idx_t buffer_size = (num_bits_to_check + 3) / 4;
-
-		// Special case: All bits are zero
-		if (buffer_size == 0) {
-			auto target = StringVector::EmptyString(result, 1);
-			auto output = target.GetDataWriteable();
-			*output = '0';
-			target.Finalize();
-			return target;
-		}
-
-		D_ASSERT(buffer_size > 0);
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		WriteHexBytes(static_cast<uint64_t>(input), output, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct HexHugeIntOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-
-		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(UnsafeNumericCast<hugeint_t>(input));
-		idx_t buffer_size = sizeof(INPUT_TYPE) * 2 - (num_leading_zero / 4);
-
-		// Special case: All bits are zero
-		if (buffer_size == 0) {
-			auto target = StringVector::EmptyString(result, 1);
-			auto output = target.GetDataWriteable();
-			*output = '0';
-			target.Finalize();
-			return target;
-		}
-
-		D_ASSERT(buffer_size > 0);
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		WriteHugeIntHexBytes<hugeint_t>(input, output, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct HexUhugeIntOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-
-		idx_t num_leading_zero = CountZeros<uhugeint_t>::Leading(UnsafeNumericCast<uhugeint_t>(input));
-		idx_t buffer_size = sizeof(INPUT_TYPE) * 2 - (num_leading_zero / 4);
-
-		// Special case: All bits are zero
-		if (buffer_size == 0) {
-			auto target = StringVector::EmptyString(result, 1);
-			auto output = target.GetDataWriteable();
-			*output = '0';
-			target.Finalize();
-			return target;
-		}
-
-		D_ASSERT(buffer_size > 0);
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		WriteHugeIntHexBytes<uhugeint_t>(input, output, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-template <class INPUT, class OP>
-static void ToHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-	auto &input = args.data[0];
-	idx_t count = args.size();
-	UnaryExecutor::ExecuteString<INPUT, string_t, OP>(input, result, count);
-}
-
-struct BinaryStrOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetData();
-		auto size = input.GetSize();
-
-		// Allocate empty space
-		auto target = StringVector::EmptyString(result, size * 8);
-		auto output = target.GetDataWriteable();
-
-		for (idx_t i = 0; i < size; ++i) {
-			auto byte = static_cast<uint8_t>(data[i]);
-			for (idx_t i = 8; i >= 1; --i) {
-				*output = ((byte >> (i - 1)) & 0x01) + '0';
-				output++;
-			}
-		}
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct BinaryIntegralOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-
-		auto num_leading_zero = CountZeros<uint64_t>::Leading(static_cast<uint64_t>(input));
-		idx_t num_bits_to_check = 64 - num_leading_zero;
-		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
-
-		idx_t buffer_size = num_bits_to_check;
-
-		// Special case: All bits are zero
-		if (buffer_size == 0) {
-			auto target = StringVector::EmptyString(result, 1);
-			auto output = target.GetDataWriteable();
-			*output = '0';
-			target.Finalize();
-			return target;
-		}
-
-		D_ASSERT(buffer_size > 0);
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		WriteBinBytes(static_cast<uint64_t>(input), output, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct BinaryHugeIntOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto num_leading_zero = CountZeros<hugeint_t>::Leading(UnsafeNumericCast<hugeint_t>(input));
-		idx_t buffer_size = sizeof(INPUT_TYPE) * 8 - num_leading_zero;
-
-		// Special case: All bits are zero
-		if (buffer_size == 0) {
-			auto target = StringVector::EmptyString(result, 1);
-			auto output = target.GetDataWriteable();
-			*output = '0';
-			target.Finalize();
-			return target;
-		}
-
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		WriteHugeIntBinBytes<hugeint_t>(input, output, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct BinaryUhugeIntOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto num_leading_zero = CountZeros<hugeint_t>::Leading(UnsafeNumericCast<uhugeint_t>(input));
-		idx_t buffer_size = sizeof(INPUT_TYPE) * 8 - num_leading_zero;
-
-		// Special case: All bits are zero
-		if (buffer_size == 0) {
-			auto target = StringVector::EmptyString(result, 1);
-			auto output = target.GetDataWriteable();
-			*output = '0';
-			target.Finalize();
-			return target;
-		}
-
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		WriteHugeIntBinBytes<uhugeint_t>(input, output, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct FromHexOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetData();
-		auto size = input.GetSize();
-
-		if (size > NumericLimits<uint32_t>::Maximum()) {
-			throw InvalidInputException("Hexadecimal input length larger than 2^32 are not supported");
-		}
-
-		D_ASSERT(size <= NumericLimits<uint32_t>::Maximum());
-		auto buffer_size = (size + 1) / 2;
-
-		// Allocate empty space
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		// Treated as a single byte
-		idx_t i = 0;
-		if (size % 2 != 0) {
-			*output = static_cast<char>(StringUtil::GetHexValue(data[i]));
-			i++;
-			output++;
-		}
-
-		for (; i < size; i += 2) {
-			uint8_t major = StringUtil::GetHexValue(data[i]);
-			uint8_t minor = StringUtil::GetHexValue(data[i + 1]);
-			*output = static_cast<char>((major << 4) | minor);
-			output++;
-		}
-
-		target.Finalize();
-		return target;
-	}
-};
-
-struct FromBinaryOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetData();
-		auto size = input.GetSize();
-
-		if (size > NumericLimits<uint32_t>::Maximum()) {
-			throw InvalidInputException("Binary input length larger than 2^32 are not supported");
-		}
-
-		D_ASSERT(size <= NumericLimits<uint32_t>::Maximum());
-		auto buffer_size = (size + 7) / 8;
-
-		// Allocate empty space
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-
-		// Treated as a single byte
-		idx_t i = 0;
-		if (size % 8 != 0) {
-			uint8_t byte = 0;
-			for (idx_t j = size % 8; j > 0; --j) {
-				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
-				i++;
-			}
-			*output = static_cast<char>(byte); // binary eh
-			output++;
-		}
-
-		while (i < size) {
-			uint8_t byte = 0;
-			for (idx_t j = 8; j > 0; --j) {
-				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
-				i++;
-			}
-			*output = static_cast<char>(byte);
-			output++;
-		}
-
-		target.Finalize();
-		return target;
-	}
-};
-
-template <class INPUT, class OP>
-static void ToBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-	auto &input = args.data[0];
-	idx_t count = args.size();
-	UnaryExecutor::ExecuteString<INPUT, string_t, OP>(input, result, count);
-}
-
-static void FromBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-	D_ASSERT(args.data[0].GetType().InternalType() == PhysicalType::VARCHAR);
-	auto &input = args.data[0];
-	idx_t count = args.size();
-
-	UnaryExecutor::ExecuteString<string_t, string_t, FromBinaryOperator>(input, result, count);
-}
-
-static void FromHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-	D_ASSERT(args.data[0].GetType().InternalType() == PhysicalType::VARCHAR);
-	auto &input = args.data[0];
-	idx_t count = args.size();
-
-	UnaryExecutor::ExecuteString<string_t, string_t, FromHexOperator>(input, result, count);
-}
-
-ScalarFunctionSet HexFun::GetFunctions() {
-	ScalarFunctionSet to_hex;
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::VARINT}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToHexFunction<int64_t, HexIntegralOperator>));
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR, ToHexFunction<uint64_t, HexIntegralOperator>));
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction<hugeint_t, HexHugeIntOperator>));
-	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::UHUGEINT}, LogicalType::VARCHAR, ToHexFunction<uhugeint_t, HexUhugeIntOperator>));
-	return to_hex;
-}
-
-ScalarFunction UnhexFun::GetFunction() {
-	ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-ScalarFunctionSet BinFun::GetFunctions() {
-	ScalarFunctionSet to_binary;
-
-	to_binary.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
-	to_binary.AddFunction(
-	    ScalarFunction({LogicalType::VARINT}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
-	to_binary.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR,
-	                                     ToBinaryFunction<uint64_t, BinaryIntegralOperator>));
-	to_binary.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToBinaryFunction<int64_t, BinaryIntegralOperator>));
-	to_binary.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR,
-	                                     ToBinaryFunction<hugeint_t, BinaryHugeIntOperator>));
-	to_binary.AddFunction(ScalarFunction({LogicalType::UHUGEINT}, LogicalType::VARCHAR,
-	                                     ToBinaryFunction<uhugeint_t, BinaryUhugeIntOperator>));
-	return to_binary;
-}
-
-ScalarFunction UnbinFun::GetFunction() {
-	ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction);
-	BaseScalarFunction::SetReturnsError(function);
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/instr.cpp b/src/duckdb/extension/core_functions/scalar/string/instr.cpp
deleted file mode 100644
index 77539e7c0..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/instr.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "utf8proc.hpp"
-
-namespace duckdb {
-
-struct InstrOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA haystack, TB needle) {
-		int64_t string_position = 0;
-
-		auto location = FindStrInStr(haystack, needle);
-		if (location != DConstants::INVALID_INDEX) {
-			auto len = (utf8proc_ssize_t)location;
-			auto str = reinterpret_cast<const utf8proc_uint8_t *>(haystack.GetData());
-			D_ASSERT(len <= (utf8proc_ssize_t)haystack.GetSize());
-			for (++string_position; len > 0; ++string_position) {
-				utf8proc_int32_t codepoint;
-				auto bytes = utf8proc_iterate(str, len, &codepoint);
-				str += bytes;
-				len -= bytes;
-			}
-		}
-		return string_position;
-	}
-};
-
-struct InstrAsciiOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA haystack, TB needle) {
-		auto location = FindStrInStr(haystack, needle);
-		return UnsafeNumericCast<TR>(location == DConstants::INVALID_INDEX ? 0U : location + 1U);
-	}
-};
-
-static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 2);
-	// can only propagate stats if the children have stats
-	// for strpos, we only care if the FIRST string has unicode or not
-	if (!StringStats::CanContainUnicode(child_stats[0])) {
-		expr.function.function = ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrAsciiOperator>;
-	}
-	return nullptr;
-}
-
-ScalarFunction InstrFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                      ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrOperator>, nullptr, nullptr,
-	                      InStrPropagateStats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/jaccard.cpp b/src/duckdb/extension/core_functions/scalar/string/jaccard.cpp
deleted file mode 100644
index eae31dc9c..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/jaccard.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "core_functions/scalar/string_functions.hpp"
-
-#include <bitset>
-#include <ctype.h>
-
-namespace duckdb {
-
-namespace {
-constexpr size_t MAX_SIZE = std::numeric_limits<unsigned char>::max() + 1;
-}
-
-static inline std::bitset<MAX_SIZE> GetSet(const string_t &str) {
-	std::bitset<MAX_SIZE> array_set;
-
-	idx_t str_len = str.GetSize();
-	auto s = str.GetData();
-
-	for (idx_t pos = 0; pos < str_len; pos++) {
-		array_set.set(static_cast<unsigned char>(s[pos]));
-	}
-	return array_set;
-}
-
-static double JaccardSimilarity(const string_t &str, const string_t &txt) {
-	if (str.GetSize() < 1 || txt.GetSize() < 1) {
-		throw InvalidInputException("Jaccard Function: An argument too short!");
-	}
-	std::bitset<MAX_SIZE> m_str, m_txt;
-
-	m_str = GetSet(str);
-	m_txt = GetSet(txt);
-
-	idx_t size_intersect = (m_str & m_txt).count();
-	idx_t size_union = (m_str | m_txt).count();
-
-	return static_cast<double>(size_intersect) / static_cast<double>(size_union);
-}
-
-static double JaccardScalarFunction(Vector &result, const string_t str, string_t tgt) {
-	return (double)JaccardSimilarity(str, tgt);
-}
-
-static void JaccardFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &tgt_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, double>(
-	    str_vec, tgt_vec, result, args.size(),
-	    [&](string_t str, string_t tgt) { return JaccardScalarFunction(result, str, tgt); });
-}
-
-ScalarFunction JaccardFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaccardFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/jaro_winkler.cpp b/src/duckdb/extension/core_functions/scalar/string/jaro_winkler.cpp
deleted file mode 100644
index 13db07c79..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/jaro_winkler.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "jaro_winkler.hpp"
-
-#include "core_functions/scalar/string_functions.hpp"
-
-namespace duckdb {
-
-static inline double JaroScalarFunction(const string_t &s1, const string_t &s2, const double_t &score_cutoff = 0.0) {
-	auto s1_begin = s1.GetData();
-	auto s2_begin = s2.GetData();
-	return duckdb_jaro_winkler::jaro_similarity(s1_begin, s1_begin + s1.GetSize(), s2_begin, s2_begin + s2.GetSize(),
-	                                            score_cutoff);
-}
-
-static inline double JaroWinklerScalarFunction(const string_t &s1, const string_t &s2,
-                                               const double_t &score_cutoff = 0.0) {
-	auto s1_begin = s1.GetData();
-	auto s2_begin = s2.GetData();
-	return duckdb_jaro_winkler::jaro_winkler_similarity(s1_begin, s1_begin + s1.GetSize(), s2_begin,
-	                                                    s2_begin + s2.GetSize(), 0.1, score_cutoff);
-}
-
-template <class CACHED_SIMILARITY>
-static void CachedFunction(Vector &constant, Vector &other, Vector &result, DataChunk &args) {
-	auto val = constant.GetValue(0);
-	idx_t count = args.size();
-	if (val.IsNull()) {
-		auto &result_validity = FlatVector::Validity(result);
-		result_validity.SetAllInvalid(count);
-		return;
-	}
-
-	auto str_val = StringValue::Get(val);
-	auto cached = CACHED_SIMILARITY(str_val);
-
-	D_ASSERT(args.ColumnCount() == 2 || args.ColumnCount() == 3);
-	if (args.ColumnCount() == 2) {
-		UnaryExecutor::Execute<string_t, double>(other, result, count, [&](const string_t &other_str) {
-			auto other_str_begin = other_str.GetData();
-			return cached.similarity(other_str_begin, other_str_begin + other_str.GetSize());
-		});
-	} else {
-		auto score_cutoff = args.data[2];
-		BinaryExecutor::Execute<string_t, double_t, double>(
-		    other, score_cutoff, result, count, [&](const string_t &other_str, const double_t score_cutoff) {
-			    auto other_str_begin = other_str.GetData();
-			    return cached.similarity(other_str_begin, other_str_begin + other_str.GetSize(), score_cutoff);
-		    });
-	}
-}
-
-template <class CACHED_SIMILARITY, class SIMILARITY_FUNCTION>
-static void TemplatedJaroWinklerFunction(DataChunk &args, Vector &result, SIMILARITY_FUNCTION fun) {
-	bool arg0_constant = args.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR;
-	bool arg1_constant = args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR;
-	if (!(arg0_constant ^ arg1_constant)) {
-		// We can't optimize by caching one of the two strings
-		D_ASSERT(args.ColumnCount() == 2 || args.ColumnCount() == 3);
-		if (args.ColumnCount() == 2) {
-			BinaryExecutor::Execute<string_t, string_t, double>(
-			    args.data[0], args.data[1], result, args.size(),
-			    [&](const string_t &s1, const string_t &s2) { return fun(s1, s2, 0.0); });
-			return;
-		} else {
-			TernaryExecutor::Execute<string_t, string_t, double_t, double>(args.data[0], args.data[1], args.data[2],
-			                                                               result, args.size(), fun);
-			return;
-		}
-	}
-
-	if (arg0_constant) {
-		CachedFunction<CACHED_SIMILARITY>(args.data[0], args.data[1], result, args);
-	} else {
-		CachedFunction<CACHED_SIMILARITY>(args.data[1], args.data[0], result, args);
-	}
-}
-
-static void JaroFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	TemplatedJaroWinklerFunction<duckdb_jaro_winkler::CachedJaroSimilarity<char>>(args, result, JaroScalarFunction);
-}
-
-static void JaroWinklerFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	TemplatedJaroWinklerFunction<duckdb_jaro_winkler::CachedJaroWinklerSimilarity<char>>(args, result,
-	                                                                                     JaroWinklerScalarFunction);
-}
-
-ScalarFunctionSet JaroSimilarityFun::GetFunctions() {
-	ScalarFunctionSet jaro;
-
-	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaroFunction);
-	jaro.AddFunction(fun);
-
-	fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                     JaroFunction);
-	jaro.AddFunction(fun);
-	return jaro;
-}
-
-ScalarFunctionSet JaroWinklerSimilarityFun::GetFunctions() {
-	ScalarFunctionSet jaroWinkler;
-
-	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaroWinklerFunction);
-	jaroWinkler.AddFunction(fun);
-
-	fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                     JaroWinklerFunction);
-	jaroWinkler.AddFunction(fun);
-	return jaroWinkler;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/left_right.cpp b/src/duckdb/extension/core_functions/scalar/string/left_right.cpp
deleted file mode 100644
index b13ff9560..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/left_right.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-
-#include <ctype.h>
-#include <algorithm>
-
-namespace duckdb {
-
-struct LeftRightUnicode {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Length<TA, TR>(input);
-	}
-
-	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
-		return SubstringUnicode(result, input, offset, length);
-	}
-};
-
-struct LeftRightGrapheme {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return GraphemeCount<TA, TR>(input);
-	}
-
-	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
-		return SubstringGrapheme(result, input, offset, length);
-	}
-};
-
-template <class OP>
-static string_t LeftScalarFunction(Vector &result, const string_t str, int64_t pos) {
-	if (pos >= 0) {
-		return OP::Substring(result, str, 1, pos);
-	}
-
-	int64_t num_characters = OP::template Operation<string_t, int64_t>(str);
-	pos = MaxValue<int64_t>(0, num_characters + pos);
-	return OP::Substring(result, str, 1, pos);
-}
-
-template <class OP>
-static void LeftFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &pos_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    str_vec, pos_vec, result, args.size(),
-	    [&](string_t str, int64_t pos) { return LeftScalarFunction<OP>(result, str, pos); });
-}
-
-ScalarFunction LeftFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                      LeftFunction<LeftRightUnicode>);
-}
-
-ScalarFunction LeftGraphemeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                      LeftFunction<LeftRightGrapheme>);
-}
-
-template <class OP>
-static string_t RightScalarFunction(Vector &result, const string_t str, int64_t pos) {
-	int64_t num_characters = OP::template Operation<string_t, int64_t>(str);
-	if (pos >= 0) {
-		int64_t len = MinValue<int64_t>(num_characters, pos);
-		int64_t start = num_characters - len + 1;
-		return OP::Substring(result, str, start, len);
-	}
-
-	int64_t len = 0;
-	if (pos != std::numeric_limits<int64_t>::min()) {
-		len = num_characters - MinValue<int64_t>(num_characters, -pos);
-	}
-	int64_t start = num_characters - len + 1;
-	return OP::Substring(result, str, start, len);
-}
-
-template <class OP>
-static void RightFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &pos_vec = args.data[1];
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    str_vec, pos_vec, result, args.size(),
-	    [&](string_t str, int64_t pos) { return RightScalarFunction<OP>(result, str, pos); });
-}
-
-ScalarFunction RightFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                      RightFunction<LeftRightUnicode>);
-}
-
-ScalarFunction RightGraphemeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                      RightFunction<LeftRightGrapheme>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/levenshtein.cpp b/src/duckdb/extension/core_functions/scalar/string/levenshtein.cpp
deleted file mode 100644
index 24e28b89c..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/levenshtein.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include <ctype.h>
-#include <algorithm>
-
-namespace duckdb {
-
-// See: https://www.kdnuggets.com/2020/10/optimizing-levenshtein-distance-measuring-text-similarity.html
-// And: Iterative 2-row algorithm: https://en.wikipedia.org/wiki/Levenshtein_distance
-// Note: A first implementation using the array algorithm version resulted in an error raised by duckdb
-// (too muach memory usage)
-
-static idx_t LevenshteinDistance(const string_t &txt, const string_t &tgt) {
-	auto txt_len = txt.GetSize();
-	auto tgt_len = tgt.GetSize();
-
-	// If one string is empty, the distance equals the length of the other string
-	if (txt_len == 0) {
-		return tgt_len;
-	} else if (tgt_len == 0) {
-		return txt_len;
-	}
-
-	auto txt_str = txt.GetData();
-	auto tgt_str = tgt.GetData();
-
-	// Create two working vectors
-	vector<idx_t> distances0(tgt_len + 1, 0);
-	vector<idx_t> distances1(tgt_len + 1, 0);
-
-	idx_t cost_substitution = 0;
-	idx_t cost_insertion = 0;
-	idx_t cost_deletion = 0;
-
-	// initialize distances0 vector
-	// edit distance for an empty txt string is just the number of characters to delete from tgt
-	for (idx_t pos_tgt = 0; pos_tgt <= tgt_len; pos_tgt++) {
-		distances0[pos_tgt] = pos_tgt;
-	}
-
-	for (idx_t pos_txt = 0; pos_txt < txt_len; pos_txt++) {
-		// calculate distances1 (current raw distances) from the previous row
-
-		distances1[0] = pos_txt + 1;
-
-		for (idx_t pos_tgt = 0; pos_tgt < tgt_len; pos_tgt++) {
-			cost_deletion = distances0[pos_tgt + 1] + 1;
-			cost_insertion = distances1[pos_tgt] + 1;
-			cost_substitution = distances0[pos_tgt];
-
-			if (txt_str[pos_txt] != tgt_str[pos_tgt]) {
-				cost_substitution += 1;
-			}
-
-			distances1[pos_tgt + 1] = MinValue(cost_deletion, MinValue(cost_substitution, cost_insertion));
-		}
-		// copy distances1 (current row) to distances0 (previous row) for next iteration
-		// since data in distances1 is always invalidated, a swap without copy is more efficient
-		distances0 = distances1;
-	}
-
-	return distances0[tgt_len];
-}
-
-static int64_t LevenshteinScalarFunction(Vector &result, const string_t str, string_t tgt) {
-	return (int64_t)LevenshteinDistance(str, tgt);
-}
-
-static void LevenshteinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &tgt_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, int64_t>(
-	    str_vec, tgt_vec, result, args.size(),
-	    [&](string_t str, string_t tgt) { return LevenshteinScalarFunction(result, str, tgt); });
-}
-
-ScalarFunction LevenshteinFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT, LevenshteinFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/pad.cpp b/src/duckdb/extension/core_functions/scalar/string/pad.cpp
deleted file mode 100644
index 586e1605a..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/pad.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/pair.hpp"
-
-#include "utf8proc.hpp"
-
-namespace duckdb {
-
-static pair<idx_t, idx_t> PadCountChars(const idx_t len, const char *data, const idx_t size) {
-	//  Count how much of str will fit in the output
-	auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-	idx_t nbytes = 0;
-	idx_t nchars = 0;
-	for (; nchars < len && nbytes < size; ++nchars) {
-		utf8proc_int32_t codepoint;
-		auto bytes = utf8proc_iterate(str + nbytes, UnsafeNumericCast<utf8proc_ssize_t>(size - nbytes), &codepoint);
-		D_ASSERT(bytes > 0);
-		nbytes += UnsafeNumericCast<idx_t>(bytes);
-	}
-
-	return pair<idx_t, idx_t>(nbytes, nchars);
-}
-
-static bool InsertPadding(const idx_t len, const string_t &pad, vector<char> &result) {
-	//  Copy the padding until the output is long enough
-	auto data = pad.GetData();
-	auto size = pad.GetSize();
-
-	//  Check whether we need data that we don't have
-	if (len > 0 && size == 0) {
-		return false;
-	}
-
-	//  Insert characters until we have all we need.
-	auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-	idx_t nbytes = 0;
-	for (idx_t nchars = 0; nchars < len; ++nchars) {
-		//  If we are at the end of the pad, flush all of it and loop back
-		if (nbytes >= size) {
-			result.insert(result.end(), data, data + size);
-			nbytes = 0;
-		}
-
-		//  Write the next character
-		utf8proc_int32_t codepoint;
-		auto bytes = utf8proc_iterate(str + nbytes, UnsafeNumericCast<utf8proc_ssize_t>(size - nbytes), &codepoint);
-		D_ASSERT(bytes > 0);
-		nbytes += UnsafeNumericCast<idx_t>(bytes);
-	}
-
-	//  Flush the remaining pad
-	result.insert(result.end(), data, data + nbytes);
-
-	return true;
-}
-
-static string_t LeftPadFunction(const string_t &str, const int32_t len, const string_t &pad, vector<char> &result) {
-	//  Reuse the buffer
-	result.clear();
-
-	// Get information about the base string
-	auto data_str = str.GetData();
-	auto size_str = str.GetSize();
-
-	//  Count how much of str will fit in the output
-	auto written = PadCountChars(UnsafeNumericCast<idx_t>(len), data_str, size_str);
-
-	//  Left pad by the number of characters still needed
-	if (!InsertPadding(UnsafeNumericCast<idx_t>(len) - written.second, pad, result)) {
-		throw InvalidInputException("Insufficient padding in LPAD.");
-	}
-
-	//  Append as much of the original string as fits
-	result.insert(result.end(), data_str, data_str + written.first);
-
-	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
-}
-
-struct LeftPadOperator {
-	static inline string_t Operation(const string_t &str, const int32_t len, const string_t &pad,
-	                                 vector<char> &result) {
-		return LeftPadFunction(str, len, pad, result);
-	}
-};
-
-static string_t RightPadFunction(const string_t &str, const int32_t len, const string_t &pad, vector<char> &result) {
-	//  Reuse the buffer
-	result.clear();
-
-	// Get information about the base string
-	auto data_str = str.GetData();
-	auto size_str = str.GetSize();
-
-	// Count how much of str will fit in the output
-	auto written = PadCountChars(UnsafeNumericCast<idx_t>(len), data_str, size_str);
-
-	//  Append as much of the original string as fits
-	result.insert(result.end(), data_str, data_str + written.first);
-
-	//  Right pad by the number of characters still needed
-	if (!InsertPadding(UnsafeNumericCast<idx_t>(len) - written.second, pad, result)) {
-		throw InvalidInputException("Insufficient padding in RPAD.");
-	};
-
-	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
-}
-
-struct RightPadOperator {
-	static inline string_t Operation(const string_t &str, const int32_t len, const string_t &pad,
-	                                 vector<char> &result) {
-		return RightPadFunction(str, len, pad, result);
-	}
-};
-
-template <class OP>
-static void PadFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vector = args.data[0];
-	auto &len_vector = args.data[1];
-	auto &pad_vector = args.data[2];
-
-	vector<char> buffer;
-	TernaryExecutor::Execute<string_t, int32_t, string_t, string_t>(
-	    str_vector, len_vector, pad_vector, result, args.size(), [&](string_t str, int32_t len, string_t pad) {
-		    len = MaxValue<int32_t>(len, 0);
-		    return StringVector::AddString(result, OP::Operation(str, len, pad, buffer));
-	    });
-}
-
-ScalarFunction LpadFun::GetFunction() {
-	ScalarFunction func({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                    PadFunction<LeftPadOperator>);
-	BaseScalarFunction::SetReturnsError(func);
-	return func;
-}
-
-ScalarFunction RpadFun::GetFunction() {
-	ScalarFunction func({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                    PadFunction<RightPadOperator>);
-	BaseScalarFunction::SetReturnsError(func);
-	return func;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/parse_path.cpp b/src/duckdb/extension/core_functions/scalar/string/parse_path.cpp
deleted file mode 100644
index 9ed926b4a..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/parse_path.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include <iostream>
-
-namespace duckdb {
-
-static string GetSeparator(const string_t &input) {
-	string option = input.GetString();
-
-	// system's path separator
-	auto fs = FileSystem::CreateLocal();
-	auto system_sep = fs->PathSeparator(option);
-
-	string separator;
-	if (option == "system") {
-		separator = system_sep;
-	} else if (option == "forward_slash") {
-		separator = "/";
-	} else if (option == "backslash") {
-		separator = "\\";
-	} else { // both_slash (default)
-		separator = "/\\";
-	}
-	return separator;
-}
-
-struct SplitInput {
-	SplitInput(Vector &result_list, Vector &result_child, idx_t offset)
-	    : result_list(result_list), result_child(result_child), offset(offset) {
-	}
-
-	Vector &result_list;
-	Vector &result_child;
-	idx_t offset;
-
-	void AddSplit(const char *split_data, idx_t split_size, idx_t list_idx) {
-		auto list_entry = offset + list_idx;
-		if (list_entry >= ListVector::GetListCapacity(result_list)) {
-			ListVector::SetListSize(result_list, offset + list_idx);
-			ListVector::Reserve(result_list, ListVector::GetListCapacity(result_list) * 2);
-		}
-		FlatVector::GetData<string_t>(result_child)[list_entry] =
-		    StringVector::AddString(result_child, split_data, split_size);
-	}
-};
-
-static bool IsIdxValid(const idx_t &i, const idx_t &sentence_size) {
-	if (i > sentence_size || i == DConstants::INVALID_INDEX) {
-		return false;
-	}
-	return true;
-}
-
-static idx_t Find(const char *input_data, idx_t input_size, const string &sep_data) {
-	if (sep_data.empty()) {
-		return 0;
-	}
-	auto pos = FindStrInStr(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(&sep_data[0]), 1);
-	// both_slash option
-	if (sep_data.size() > 1) {
-		auto sec_pos =
-		    FindStrInStr(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(&sep_data[1]), 1);
-		// choose the leftmost valid position
-		if (sec_pos != DConstants::INVALID_INDEX && (sec_pos < pos || pos == DConstants::INVALID_INDEX)) {
-			return sec_pos;
-		}
-	}
-	return pos;
-}
-
-static idx_t FindLast(const char *data_ptr, idx_t input_size, const string &sep_data) {
-	idx_t start = 0;
-	while (input_size > 0) {
-		auto pos = Find(data_ptr, input_size, sep_data);
-		if (!IsIdxValid(pos, input_size)) {
-			break;
-		}
-		start += (pos + 1);
-		data_ptr += (pos + 1);
-		input_size -= (pos + 1);
-	}
-	if (start < 1) {
-		return DConstants::INVALID_INDEX;
-	}
-	return start - 1;
-}
-
-static idx_t SplitPath(string_t input, const string &sep, SplitInput &state) {
-	auto input_data = input.GetData();
-	auto input_size = input.GetSize();
-	if (!input_size) {
-		return 0;
-	}
-	idx_t list_idx = 0;
-	while (input_size > 0) {
-		auto pos = Find(input_data, input_size, sep);
-		if (!IsIdxValid(pos, input_size)) {
-			break;
-		}
-
-		D_ASSERT(input_size >= pos);
-		if (pos == 0) {
-			if (list_idx == 0) { // first character in path is separator
-				state.AddSplit(input_data, 1, list_idx);
-				list_idx++;
-				if (input_size == 1) { // special case: the only character in path is a separator
-					return list_idx;
-				}
-			} // else: separator is in the path
-		} else {
-			state.AddSplit(input_data, pos, list_idx);
-			list_idx++;
-		}
-		input_data += (pos + 1);
-		input_size -= (pos + 1);
-	}
-	if (input_size > 0) {
-		state.AddSplit(input_data, input_size, list_idx);
-		list_idx++;
-	}
-	return list_idx;
-}
-
-static void ReadOptionalArgs(DataChunk &args, Vector &sep, Vector &trim, const bool &front_trim) {
-	switch (args.ColumnCount()) {
-	case 1: {
-		// use default values
-		break;
-	}
-	case 2: {
-		UnifiedVectorFormat sec_arg;
-		args.data[1].ToUnifiedFormat(args.size(), sec_arg);
-		if (sec_arg.validity.RowIsValid(0)) { // if not NULL
-			switch (args.data[1].GetType().id()) {
-			case LogicalTypeId::VARCHAR: {
-				sep.Reinterpret(args.data[1]);
-				break;
-			}
-			case LogicalTypeId::BOOLEAN: { // parse_path and parse_driname won't get in here
-				trim.Reinterpret(args.data[1]);
-				break;
-			}
-			default:
-				throw InvalidInputException("Invalid argument type");
-			}
-		}
-		break;
-	}
-	case 3: {
-		if (!front_trim) {
-			// set trim_extension
-			UnifiedVectorFormat sec_arg;
-			args.data[1].ToUnifiedFormat(args.size(), sec_arg);
-			if (sec_arg.validity.RowIsValid(0)) {
-				trim.Reinterpret(args.data[1]);
-			}
-			UnifiedVectorFormat third_arg;
-			args.data[2].ToUnifiedFormat(args.size(), third_arg);
-			if (third_arg.validity.RowIsValid(0)) {
-				sep.Reinterpret(args.data[2]);
-			}
-		} else {
-			throw InvalidInputException("Invalid number of arguments");
-		}
-		break;
-	}
-	default:
-		throw InvalidInputException("Invalid number of arguments");
-	}
-}
-
-template <bool FRONT_TRIM>
-static void TrimPathFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// set default values
-	Vector &path = args.data[0];
-	Vector separator(string_t("default"));
-	Vector trim_extension(Value::BOOLEAN(false));
-	ReadOptionalArgs(args, separator, trim_extension, FRONT_TRIM);
-
-	TernaryExecutor::Execute<string_t, string_t, bool, string_t>(
-	    path, separator, trim_extension, result, args.size(),
-	    [&](string_t &inputs, string_t input_sep, bool trim_extension) {
-		    auto data = inputs.GetData();
-		    auto input_size = inputs.GetSize();
-		    auto sep = GetSeparator(input_sep.GetString());
-
-		    // find the beginning idx and the size of the result string
-		    idx_t begin = 0;
-		    idx_t new_size = input_size;
-		    if (FRONT_TRIM) { // left trim
-			    auto pos = Find(data, input_size, sep);
-			    if (pos == 0) { // path starts with separator
-				    pos = 1;
-			    }
-			    new_size = (IsIdxValid(pos, input_size)) ? pos : 0;
-		    } else { // right trim
-			    auto idx_last_sep = FindLast(data, input_size, sep);
-			    if (IsIdxValid(idx_last_sep, input_size)) {
-				    begin = idx_last_sep + 1;
-			    }
-			    if (trim_extension) {
-				    auto idx_extension_sep = FindLast(data, input_size, ".");
-				    if (begin <= idx_extension_sep && IsIdxValid(idx_extension_sep, input_size)) {
-					    new_size = idx_extension_sep;
-				    }
-			    }
-		    }
-		    // copy the trimmed string
-		    D_ASSERT(begin <= new_size);
-		    auto target = StringVector::EmptyString(result, new_size - begin);
-		    auto output = target.GetDataWriteable();
-		    memcpy(output, data + begin, new_size - begin);
-
-		    target.Finalize();
-		    return target;
-	    });
-}
-
-static void ParseDirpathFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// set default values
-	Vector &path = args.data[0];
-	Vector separator(string_t("default"));
-	Vector trim_extension(false);
-	ReadOptionalArgs(args, separator, trim_extension, true);
-
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    path, separator, result, args.size(), [&](string_t input_path, string_t input_sep) {
-		    auto path = input_path.GetData();
-		    auto path_size = input_path.GetSize();
-		    auto sep = GetSeparator(input_sep.GetString());
-
-		    auto last_sep = FindLast(path, path_size, sep);
-		    if (last_sep == 0 && path_size == 1) {
-			    last_sep = 1;
-		    }
-		    idx_t new_size = (IsIdxValid(last_sep, path_size)) ? last_sep : 0;
-
-		    auto target = StringVector::EmptyString(result, new_size);
-		    auto output = target.GetDataWriteable();
-		    memcpy(output, path, new_size);
-		    target.Finalize();
-		    return StringVector::AddString(result, target);
-	    });
-}
-
-static void ParsePathFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1 || args.ColumnCount() == 2);
-	UnifiedVectorFormat input_data;
-	args.data[0].ToUnifiedFormat(args.size(), input_data);
-	auto inputs = UnifiedVectorFormat::GetData<string_t>(input_data);
-
-	// set the separator
-	string input_sep = "default";
-	if (args.ColumnCount() == 2) {
-		UnifiedVectorFormat sep_data;
-		args.data[1].ToUnifiedFormat(args.size(), sep_data);
-		if (sep_data.validity.RowIsValid(0)) {
-			input_sep = UnifiedVectorFormat::GetData<string_t>(sep_data)->GetString();
-		}
-	}
-	const string sep = GetSeparator(input_sep);
-
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	ListVector::SetListSize(result, 0);
-
-	// set up the list entries
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	auto &child_entry = ListVector::GetEntry(result);
-	auto &result_mask = FlatVector::Validity(result);
-	idx_t total_splits = 0;
-	for (idx_t i = 0; i < args.size(); i++) {
-		auto input_idx = input_data.sel->get_index(i);
-		if (!input_data.validity.RowIsValid(input_idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		SplitInput split_input(result, child_entry, total_splits);
-		auto list_length = SplitPath(inputs[input_idx], sep, split_input);
-		list_data[i].length = list_length;
-		list_data[i].offset = total_splits;
-		total_splits += list_length;
-	}
-	ListVector::SetListSize(result, total_splits);
-	D_ASSERT(ListVector::GetListSize(result) == total_splits);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-ScalarFunctionSet ParseDirnameFun::GetFunctions() {
-	ScalarFunctionSet parse_dirname;
-	ScalarFunction func({LogicalType::VARCHAR}, LogicalType::VARCHAR, TrimPathFunction<true>, nullptr, nullptr, nullptr,
-	                    nullptr, LogicalType::INVALID, FunctionStability::CONSISTENT,
-	                    FunctionNullHandling::SPECIAL_HANDLING);
-	parse_dirname.AddFunction(func);
-	// separator options
-	func.arguments.emplace_back(LogicalType::VARCHAR);
-	parse_dirname.AddFunction(func);
-	return parse_dirname;
-}
-
-ScalarFunctionSet ParseDirpathFun::GetFunctions() {
-	ScalarFunctionSet parse_dirpath;
-	ScalarFunction func({LogicalType::VARCHAR}, LogicalType::VARCHAR, ParseDirpathFunction, nullptr, nullptr, nullptr,
-	                    nullptr, LogicalType::INVALID, FunctionStability::CONSISTENT,
-	                    FunctionNullHandling::SPECIAL_HANDLING);
-	parse_dirpath.AddFunction(func);
-	// separator options
-	func.arguments.emplace_back(LogicalType::VARCHAR);
-	parse_dirpath.AddFunction(func);
-	return parse_dirpath;
-}
-
-ScalarFunctionSet ParseFilenameFun::GetFunctions() {
-	ScalarFunctionSet parse_filename;
-	parse_filename.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, TrimPathFunction<false>,
-	                                          nullptr, nullptr, nullptr, nullptr, LogicalType::INVALID,
-	                                          FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	parse_filename.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR, TrimPathFunction<false>, nullptr, nullptr,
-	    nullptr, nullptr, LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	parse_filename.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::BOOLEAN}, LogicalType::VARCHAR, TrimPathFunction<false>, nullptr, nullptr,
-	    nullptr, nullptr, LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	parse_filename.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::VARCHAR},
-	                                          LogicalType::VARCHAR, TrimPathFunction<false>, nullptr, nullptr, nullptr,
-	                                          nullptr, LogicalType::INVALID, FunctionStability::CONSISTENT,
-	                                          FunctionNullHandling::SPECIAL_HANDLING));
-	return parse_filename;
-}
-
-ScalarFunctionSet ParsePathFun::GetFunctions() {
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	ScalarFunctionSet parse_path;
-	ScalarFunction func({LogicalType::VARCHAR}, varchar_list_type, ParsePathFunction, nullptr, nullptr, nullptr,
-	                    nullptr, LogicalType::INVALID, FunctionStability::CONSISTENT,
-	                    FunctionNullHandling::SPECIAL_HANDLING);
-	parse_path.AddFunction(func);
-	// separator options
-	func.arguments.emplace_back(LogicalType::VARCHAR);
-	parse_path.AddFunction(func);
-	return parse_path;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/printf.cpp b/src/duckdb/extension/core_functions/scalar/string/printf.cpp
deleted file mode 100644
index 1db25b0df..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/printf.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/limits.hpp"
-#include "fmt/format.h"
-#include "fmt/printf.h"
-
-namespace duckdb {
-
-struct FMTPrintf {
-	template <class CTX>
-	static string OP(const char *format_str, vector<duckdb_fmt::basic_format_arg<CTX>> &format_args) {
-		return duckdb_fmt::vsprintf(
-		    format_str, duckdb_fmt::basic_format_args<CTX>(format_args.data(), static_cast<int>(format_args.size())));
-	}
-};
-
-struct FMTFormat {
-	template <class CTX>
-	static string OP(const char *format_str, vector<duckdb_fmt::basic_format_arg<CTX>> &format_args) {
-		return duckdb_fmt::vformat(
-		    format_str, duckdb_fmt::basic_format_args<CTX>(format_args.data(), static_cast<int>(format_args.size())));
-	}
-};
-
-unique_ptr<FunctionData> BindPrintfFunction(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		switch (arguments[i]->return_type.id()) {
-		case LogicalTypeId::BOOLEAN:
-			bound_function.arguments.emplace_back(LogicalType::BOOLEAN);
-			break;
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-			bound_function.arguments.emplace_back(LogicalType::BIGINT);
-			break;
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-			bound_function.arguments.emplace_back(LogicalType::UBIGINT);
-			break;
-		case LogicalTypeId::FLOAT:
-		case LogicalTypeId::DOUBLE:
-			bound_function.arguments.emplace_back(LogicalType::DOUBLE);
-			break;
-		case LogicalTypeId::VARCHAR:
-			bound_function.arguments.push_back(LogicalType::VARCHAR);
-			break;
-		case LogicalTypeId::DECIMAL:
-			// decimal type: add cast to double
-			bound_function.arguments.emplace_back(LogicalType::DOUBLE);
-			break;
-		case LogicalTypeId::UNKNOWN:
-			// parameter: accept any input and rebind later
-			bound_function.arguments.emplace_back(LogicalType::ANY);
-			break;
-		default:
-			// all other types: add cast to string
-			bound_function.arguments.emplace_back(LogicalType::VARCHAR);
-			break;
-		}
-	}
-	return nullptr;
-}
-
-template <class FORMAT_FUN, class CTX>
-static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &format_string = args.data[0];
-	auto &result_validity = FlatVector::Validity(result);
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	result_validity.Initialize(args.size());
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		switch (args.data[i].GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR:
-			if (ConstantVector::IsNull(args.data[i])) {
-				// constant null! result is always NULL regardless of other input
-				result.SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result, true);
-				return;
-			}
-			break;
-		default:
-			// FLAT VECTOR, we can directly OR the nullmask
-			args.data[i].Flatten(args.size());
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			result_validity.Combine(FlatVector::Validity(args.data[i]), args.size());
-			break;
-		}
-	}
-	idx_t count = result.GetVectorType() == VectorType::CONSTANT_VECTOR ? 1 : args.size();
-
-	auto format_data = FlatVector::GetData<string_t>(format_string);
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t idx = 0; idx < count; idx++) {
-		if (result.GetVectorType() == VectorType::FLAT_VECTOR && FlatVector::IsNull(result, idx)) {
-			// this entry is NULL: skip it
-			continue;
-		}
-
-		// first fetch the format string
-		auto fmt_idx = format_string.GetVectorType() == VectorType::CONSTANT_VECTOR ? 0 : idx;
-		auto format_string = format_data[fmt_idx].GetString();
-
-		// now gather all the format arguments
-		vector<duckdb_fmt::basic_format_arg<CTX>> format_args;
-		vector<unsafe_unique_array<data_t>> string_args;
-
-		for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-			auto &col = args.data[col_idx];
-			idx_t arg_idx = col.GetVectorType() == VectorType::CONSTANT_VECTOR ? 0 : idx;
-			switch (col.GetType().id()) {
-			case LogicalTypeId::BOOLEAN: {
-				auto arg_data = FlatVector::GetData<bool>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::TINYINT: {
-				auto arg_data = FlatVector::GetData<int8_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::SMALLINT: {
-				auto arg_data = FlatVector::GetData<int16_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::INTEGER: {
-				auto arg_data = FlatVector::GetData<int32_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::BIGINT: {
-				auto arg_data = FlatVector::GetData<int64_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::UBIGINT: {
-				auto arg_data = FlatVector::GetData<uint64_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::FLOAT: {
-				auto arg_data = FlatVector::GetData<float>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::DOUBLE: {
-				auto arg_data = FlatVector::GetData<double>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::VARCHAR: {
-				auto arg_data = FlatVector::GetData<string_t>(col);
-				auto string_view =
-				    duckdb_fmt::basic_string_view<char>(arg_data[arg_idx].GetData(), arg_data[arg_idx].GetSize());
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(string_view));
-				break;
-			}
-			default:
-				throw InternalException("Unexpected type for printf format");
-			}
-		}
-		// finally actually perform the format
-		string dynamic_result = FORMAT_FUN::template OP<CTX>(format_string.c_str(), format_args);
-		result_data[idx] = StringVector::AddString(result, dynamic_result);
-	}
-}
-
-ScalarFunction PrintfFun::GetFunction() {
-	// duckdb_fmt::printf_context, duckdb_fmt::vsprintf
-	ScalarFunction printf_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                          PrintfFunction<FMTPrintf, duckdb_fmt::printf_context>, BindPrintfFunction);
-	printf_fun.varargs = LogicalType::ANY;
-	BaseScalarFunction::SetReturnsError(printf_fun);
-	return printf_fun;
-}
-
-ScalarFunction FormatFun::GetFunction() {
-	// duckdb_fmt::format_context, duckdb_fmt::vformat
-	ScalarFunction format_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                          PrintfFunction<FMTFormat, duckdb_fmt::format_context>, BindPrintfFunction);
-	format_fun.varargs = LogicalType::ANY;
-	BaseScalarFunction::SetReturnsError(format_fun);
-	return format_fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/repeat.cpp b/src/duckdb/extension/core_functions/scalar/string/repeat.cpp
deleted file mode 100644
index 154634f94..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/repeat.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-
-namespace duckdb {
-
-static void RepeatFunction(DataChunk &args, ExpressionState &, Vector &result) {
-	auto &str_vector = args.data[0];
-	auto &cnt_vector = args.data[1];
-
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    str_vector, cnt_vector, result, args.size(), [&](string_t str, int64_t cnt) {
-		    auto input_str = str.GetData();
-		    auto size_str = str.GetSize();
-		    idx_t copy_count = cnt <= 0 || size_str == 0 ? 0 : UnsafeNumericCast<idx_t>(cnt);
-
-		    idx_t copy_size;
-		    if (TryMultiplyOperator::Operation(size_str, copy_count, copy_size)) {
-			    auto result_str = StringVector::EmptyString(result, copy_size);
-			    auto result_data = result_str.GetDataWriteable();
-			    for (idx_t i = 0; i < copy_count; i++) {
-				    memcpy(result_data + i * size_str, input_str, size_str);
-			    }
-			    result_str.Finalize();
-			    return result_str;
-		    } else {
-			    throw OutOfRangeException(
-			        "Cannot create a string of size: '%d' * '%d', the maximum supported string size is: '%d'", size_str,
-			        copy_count, string_t::MAX_STRING_SIZE);
-		    }
-	    });
-}
-
-unique_ptr<FunctionData> RepeatBindFunction(ClientContext &, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	switch (arguments[0]->return_type.id()) {
-	case LogicalTypeId::UNKNOWN:
-		throw ParameterNotResolvedException();
-	case LogicalTypeId::LIST:
-		break;
-	default:
-		throw NotImplementedException("repeat(list, count) requires a list as parameter");
-	}
-	bound_function.arguments[0] = arguments[0]->return_type;
-	bound_function.return_type = arguments[0]->return_type;
-	return nullptr;
-}
-
-static void RepeatListFunction(DataChunk &args, ExpressionState &, Vector &result) {
-	auto &list_vector = args.data[0];
-	auto &cnt_vector = args.data[1];
-
-	auto &source_child = ListVector::GetEntry(list_vector);
-	auto &result_child = ListVector::GetEntry(result);
-
-	idx_t current_size = ListVector::GetListSize(result);
-	BinaryExecutor::Execute<list_entry_t, int64_t, list_entry_t>(
-	    list_vector, cnt_vector, result, args.size(), [&](list_entry_t list_input, int64_t cnt) {
-		    idx_t copy_count = cnt <= 0 || list_input.length == 0 ? 0 : UnsafeNumericCast<idx_t>(cnt);
-		    idx_t result_length = list_input.length * copy_count;
-		    idx_t new_size = current_size + result_length;
-		    ListVector::Reserve(result, new_size);
-		    list_entry_t result_list;
-		    result_list.offset = current_size;
-		    result_list.length = result_length;
-		    for (idx_t i = 0; i < copy_count; i++) {
-			    // repeat the list contents "cnt" times
-			    VectorOperations::Copy(source_child, result_child, list_input.offset + list_input.length,
-			                           list_input.offset, current_size);
-			    current_size += list_input.length;
-		    }
-		    return result_list;
-	    });
-	ListVector::SetListSize(result, current_size);
-}
-
-ScalarFunctionSet RepeatFun::GetFunctions() {
-	ScalarFunctionSet repeat;
-	for (const auto &type : {LogicalType::VARCHAR, LogicalType::BLOB}) {
-		repeat.AddFunction(ScalarFunction({type, LogicalType::BIGINT}, type, RepeatFunction));
-	}
-	repeat.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT},
-	                                  LogicalType::LIST(LogicalType::ANY), RepeatListFunction, RepeatBindFunction));
-	for (auto &func : repeat.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return repeat;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/replace.cpp b/src/duckdb/extension/core_functions/scalar/string/replace.cpp
deleted file mode 100644
index 4702292c5..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/replace.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-
-#include <string.h>
-#include <ctype.h>
-#include <unordered_map>
-
-namespace duckdb {
-
-static idx_t NextNeedle(const char *input_haystack, idx_t size_haystack, const char *input_needle,
-                        const idx_t size_needle) {
-	// Needle needs something to proceed
-	if (size_needle > 0) {
-		// Haystack should be bigger or equal size to the needle
-		for (idx_t string_position = 0; (size_haystack - string_position) >= size_needle; ++string_position) {
-			// Compare Needle to the Haystack
-			if ((memcmp(input_haystack + string_position, input_needle, size_needle) == 0)) {
-				return string_position;
-			}
-		}
-	}
-	// Did not find the needle
-	return size_haystack;
-}
-
-static string_t ReplaceScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
-                                      vector<char> &result) {
-	// Get information about the needle, the haystack and the "thread"
-	auto input_haystack = haystack.GetData();
-	auto size_haystack = haystack.GetSize();
-
-	auto input_needle = needle.GetData();
-	auto size_needle = needle.GetSize();
-
-	auto input_thread = thread.GetData();
-	auto size_thread = thread.GetSize();
-
-	//  Reuse the buffer
-	result.clear();
-
-	for (;;) {
-		//  Append the non-matching characters
-		auto string_position = NextNeedle(input_haystack, size_haystack, input_needle, size_needle);
-		result.insert(result.end(), input_haystack, input_haystack + string_position);
-		input_haystack += string_position;
-		size_haystack -= string_position;
-
-		//  Stop when we have read the entire haystack
-		if (size_haystack == 0) {
-			break;
-		}
-
-		//  Replace the matching characters
-		result.insert(result.end(), input_thread, input_thread + size_thread);
-		input_haystack += size_needle;
-		size_haystack -= size_needle;
-	}
-
-	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
-}
-
-static void ReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &haystack_vector = args.data[0];
-	auto &needle_vector = args.data[1];
-	auto &thread_vector = args.data[2];
-
-	vector<char> buffer;
-	TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
-	    haystack_vector, needle_vector, thread_vector, result, args.size(),
-	    [&](string_t input_string, string_t needle_string, string_t thread_string) {
-		    return StringVector::AddString(result,
-		                                   ReplaceScalarFunction(input_string, needle_string, thread_string, buffer));
-	    });
-}
-
-ScalarFunction ReplaceFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                      ReplaceFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/reverse.cpp b/src/duckdb/extension/core_functions/scalar/string/reverse.cpp
deleted file mode 100644
index 4ff654909..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/reverse.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <string.h>
-
-namespace duckdb {
-
-//! Fast ASCII string reverse, returns false if the input data is not ascii
-static bool StrReverseASCII(const char *input, idx_t n, char *output) {
-	for (idx_t i = 0; i < n; i++) {
-		if (input[i] & 0x80) {
-			// non-ascii character
-			return false;
-		}
-		output[n - i - 1] = input[i];
-	}
-	return true;
-}
-
-//! Unicode string reverse using grapheme breakers
-static void StrReverseUnicode(const char *input, idx_t n, char *output) {
-	for (auto cluster : Utf8Proc::GraphemeClusters(input, n)) {
-		memcpy(output + n - cluster.end, input + cluster.start, cluster.end - cluster.start);
-	}
-}
-
-struct ReverseOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetData();
-		auto input_length = input.GetSize();
-
-		auto target = StringVector::EmptyString(result, input_length);
-		auto target_data = target.GetDataWriteable();
-		if (!StrReverseASCII(input_data, input_length, target_data)) {
-			StrReverseUnicode(input_data, input_length, target_data);
-		}
-		target.Finalize();
-		return target;
-	}
-};
-
-static void ReverseFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, ReverseOperator>(args.data[0], result, args.size());
-}
-
-ScalarFunction ReverseFun::GetFunction() {
-	return ScalarFunction("reverse", {LogicalType::VARCHAR}, LogicalType::VARCHAR, ReverseFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/starts_with.cpp b/src/duckdb/extension/core_functions/scalar/string/starts_with.cpp
deleted file mode 100644
index 7ef277292..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/starts_with.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-static bool StartsWith(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                       idx_t needle_size) {
-	D_ASSERT(needle_size > 0);
-	if (needle_size > haystack_size) {
-		// needle is bigger than haystack: haystack cannot start with needle
-		return false;
-	}
-	return memcmp(haystack, needle, needle_size) == 0;
-}
-
-static bool StartsWith(const string_t &haystack_s, const string_t &needle_s) {
-
-	auto haystack = const_uchar_ptr_cast(haystack_s.GetData());
-	auto haystack_size = haystack_s.GetSize();
-	auto needle = const_uchar_ptr_cast(needle_s.GetData());
-	auto needle_size = needle_s.GetSize();
-	if (needle_size == 0) {
-		// empty needle: always true
-		return true;
-	}
-	return StartsWith(haystack, haystack_size, needle, needle_size);
-}
-
-struct StartsWithOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return StartsWith(left, right);
-	}
-};
-
-ScalarFunction StartsWithOperatorFun::GetFunction() {
-	ScalarFunction starts_with({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                           ScalarFunction::BinaryFunction<string_t, string_t, bool, StartsWithOperator>);
-	starts_with.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return starts_with;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/to_base.cpp b/src/duckdb/extension/core_functions/scalar/string/to_base.cpp
deleted file mode 100644
index f85f54be9..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/to_base.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-static const char alphabet[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-static unique_ptr<FunctionData> ToBaseBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	// If no min_length is specified, default to 0
-	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
-	if (arguments.size() == 2) {
-		arguments.push_back(make_uniq_base<Expression, BoundConstantExpression>(Value::INTEGER(0)));
-	}
-	return nullptr;
-}
-
-static void ToBaseFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-	auto &radix = args.data[1];
-	auto &min_length = args.data[2];
-	auto count = args.size();
-
-	TernaryExecutor::Execute<int64_t, int32_t, int32_t, string_t>(
-	    input, radix, min_length, result, count, [&](int64_t input, int32_t radix, int32_t min_length) {
-		    if (input < 0) {
-			    throw InvalidInputException("'to_base' number must be greater than or equal to 0");
-		    }
-		    if (radix < 2 || radix > 36) {
-			    throw InvalidInputException("'to_base' radix must be between 2 and 36");
-		    }
-		    if (min_length > 64 || min_length < 0) {
-			    throw InvalidInputException("'to_base' min_length must be between 0 and 64");
-		    }
-
-		    char buf[64];
-		    char *end = buf + sizeof(buf);
-		    char *ptr = end;
-		    do {
-			    *--ptr = alphabet[input % radix];
-			    input /= radix;
-		    } while (input > 0);
-
-		    auto length = end - ptr;
-		    while (length < min_length) {
-			    *--ptr = '0';
-			    length++;
-		    }
-
-		    return StringVector::AddString(result, ptr, UnsafeNumericCast<idx_t>(end - ptr));
-	    });
-}
-
-ScalarFunctionSet ToBaseFun::GetFunctions() {
-	ScalarFunctionSet set("to_base");
-
-	set.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTEGER}, LogicalType::VARCHAR, ToBaseFunction, ToBaseBind));
-	set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::INTEGER, LogicalType::INTEGER},
-	                               LogicalType::VARCHAR, ToBaseFunction, ToBaseBind));
-
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/translate.cpp b/src/duckdb/extension/core_functions/scalar/string/translate.cpp
deleted file mode 100644
index ca661cb3d..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/translate.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "utf8proc.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <string.h>
-#include <ctype.h>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace duckdb {
-
-static string_t TranslateScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
-                                        vector<char> &result) {
-	// Get information about the haystack, the needle and the "thread"
-	auto input_haystack = haystack.GetData();
-	auto size_haystack = haystack.GetSize();
-
-	auto input_needle = needle.GetData();
-	auto size_needle = needle.GetSize();
-
-	auto input_thread = thread.GetData();
-	auto size_thread = thread.GetSize();
-
-	// Reuse the buffer
-	result.clear();
-	result.reserve(size_haystack);
-
-	idx_t i = 0, j = 0;
-	int sz = 0, c_sz = 0;
-
-	// Character to be replaced
-	unordered_map<int32_t, int32_t> to_replace;
-	while (i < size_needle && j < size_thread) {
-		auto codepoint_needle = Utf8Proc::UTF8ToCodepoint(input_needle, sz);
-		input_needle += sz;
-		i += UnsafeNumericCast<idx_t>(sz);
-		auto codepoint_thread = Utf8Proc::UTF8ToCodepoint(input_thread, sz);
-		input_thread += sz;
-		j += UnsafeNumericCast<idx_t>(sz);
-		// Ignore unicode character that is existed in to_replace
-		if (to_replace.count(codepoint_needle) == 0) {
-			to_replace[codepoint_needle] = codepoint_thread;
-		}
-	}
-
-	// Character to be deleted
-	unordered_set<int32_t> to_delete;
-	while (i < size_needle) {
-		auto codepoint_needle = Utf8Proc::UTF8ToCodepoint(input_needle, sz);
-		input_needle += sz;
-		i += UnsafeNumericCast<idx_t>(sz);
-		// Add unicode character that will be deleted
-		if (to_replace.count(codepoint_needle) == 0) {
-			to_delete.insert(codepoint_needle);
-		}
-	}
-
-	char c[5] = {'\0', '\0', '\0', '\0', '\0'};
-	for (i = 0; i < size_haystack; i += UnsafeNumericCast<idx_t>(sz)) {
-		auto codepoint_haystack = Utf8Proc::UTF8ToCodepoint(input_haystack, sz);
-		if (to_replace.count(codepoint_haystack) != 0) {
-			Utf8Proc::CodepointToUtf8(to_replace[codepoint_haystack], c_sz, c);
-			result.insert(result.end(), c, c + c_sz);
-		} else if (to_delete.count(codepoint_haystack) == 0) {
-			result.insert(result.end(), input_haystack, input_haystack + sz);
-		}
-		input_haystack += sz;
-	}
-
-	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
-}
-
-static void TranslateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &haystack_vector = args.data[0];
-	auto &needle_vector = args.data[1];
-	auto &thread_vector = args.data[2];
-
-	vector<char> buffer;
-	TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
-	    haystack_vector, needle_vector, thread_vector, result, args.size(),
-	    [&](string_t input_string, string_t needle_string, string_t thread_string) {
-		    return StringVector::AddString(result,
-		                                   TranslateScalarFunction(input_string, needle_string, thread_string, buffer));
-	    });
-}
-
-ScalarFunction TranslateFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                      TranslateFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/trim.cpp b/src/duckdb/extension/core_functions/scalar/string/trim.cpp
deleted file mode 100644
index 5553d75e3..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/trim.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "utf8proc.hpp"
-
-#include <string.h>
-
-namespace duckdb {
-
-template <bool LTRIM, bool RTRIM>
-struct TrimOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetData();
-		auto size = input.GetSize();
-
-		utf8proc_int32_t codepoint;
-		auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-
-		// Find the first character that is not left trimmed
-		idx_t begin = 0;
-		if (LTRIM) {
-			while (begin < size) {
-				auto bytes =
-				    utf8proc_iterate(str + begin, UnsafeNumericCast<utf8proc_ssize_t>(size - begin), &codepoint);
-				D_ASSERT(bytes > 0);
-				if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-					break;
-				}
-				begin += UnsafeNumericCast<idx_t>(bytes);
-			}
-		}
-
-		// Find the last character that is not right trimmed
-		idx_t end;
-		if (RTRIM) {
-			end = begin;
-			for (auto next = begin; next < size;) {
-				auto bytes = utf8proc_iterate(str + next, UnsafeNumericCast<utf8proc_ssize_t>(size - next), &codepoint);
-				D_ASSERT(bytes > 0);
-				next += UnsafeNumericCast<idx_t>(bytes);
-				if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-					end = next;
-				}
-			}
-		} else {
-			end = size;
-		}
-
-		// Copy the trimmed string
-		auto target = StringVector::EmptyString(result, end - begin);
-		auto output = target.GetDataWriteable();
-		memcpy(output, data + begin, end - begin);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-template <bool LTRIM, bool RTRIM>
-static void UnaryTrimFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, TrimOperator<LTRIM, RTRIM>>(args.data[0], result, args.size());
-}
-
-static void GetIgnoredCodepoints(string_t ignored, unordered_set<utf8proc_int32_t> &ignored_codepoints) {
-	auto dataptr = reinterpret_cast<const utf8proc_uint8_t *>(ignored.GetData());
-	auto size = ignored.GetSize();
-	idx_t pos = 0;
-	while (pos < size) {
-		utf8proc_int32_t codepoint;
-		pos += UnsafeNumericCast<idx_t>(
-		    utf8proc_iterate(dataptr + pos, UnsafeNumericCast<utf8proc_ssize_t>(size - pos), &codepoint));
-		ignored_codepoints.insert(codepoint);
-	}
-}
-
-template <bool LTRIM, bool RTRIM>
-static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    input.data[0], input.data[1], result, input.size(), [&](string_t input, string_t ignored) {
-		    auto data = input.GetData();
-		    auto size = input.GetSize();
-
-		    unordered_set<utf8proc_int32_t> ignored_codepoints;
-		    GetIgnoredCodepoints(ignored, ignored_codepoints);
-
-		    utf8proc_int32_t codepoint;
-		    auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-
-		    // Find the first character that is not left trimmed
-		    idx_t begin = 0;
-		    if (LTRIM) {
-			    while (begin < size) {
-				    auto bytes =
-				        utf8proc_iterate(str + begin, UnsafeNumericCast<utf8proc_ssize_t>(size - begin), &codepoint);
-				    if (ignored_codepoints.find(codepoint) == ignored_codepoints.end()) {
-					    break;
-				    }
-				    begin += UnsafeNumericCast<idx_t>(bytes);
-			    }
-		    }
-
-		    // Find the last character that is not right trimmed
-		    idx_t end;
-		    if (RTRIM) {
-			    end = begin;
-			    for (auto next = begin; next < size;) {
-				    auto bytes =
-				        utf8proc_iterate(str + next, UnsafeNumericCast<utf8proc_ssize_t>(size - next), &codepoint);
-				    D_ASSERT(bytes > 0);
-				    next += UnsafeNumericCast<idx_t>(bytes);
-				    if (ignored_codepoints.find(codepoint) == ignored_codepoints.end()) {
-					    end = next;
-				    }
-			    }
-		    } else {
-			    end = size;
-		    }
-
-		    // Copy the trimmed string
-		    auto target = StringVector::EmptyString(result, end - begin);
-		    auto output = target.GetDataWriteable();
-		    memcpy(output, data + begin, end - begin);
-
-		    target.Finalize();
-		    return target;
-	    });
-}
-
-ScalarFunctionSet TrimFun::GetFunctions() {
-	ScalarFunctionSet trim;
-	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, true>));
-
-	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                BinaryTrimFunction<true, true>));
-	return trim;
-}
-
-ScalarFunctionSet LtrimFun::GetFunctions() {
-	ScalarFunctionSet ltrim;
-	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, false>));
-	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                 BinaryTrimFunction<true, false>));
-	return ltrim;
-}
-
-ScalarFunctionSet RtrimFun::GetFunctions() {
-	ScalarFunctionSet rtrim;
-	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<false, true>));
-
-	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                 BinaryTrimFunction<false, true>));
-	return rtrim;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/unicode.cpp b/src/duckdb/extension/core_functions/scalar/string/unicode.cpp
deleted file mode 100644
index 902c7c5e7..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/unicode.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "core_functions/scalar/string_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "utf8proc.hpp"
-
-#include <string.h>
-
-namespace duckdb {
-
-struct UnicodeOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetData());
-		auto len = input.GetSize();
-		utf8proc_int32_t codepoint;
-		(void)utf8proc_iterate(str, UnsafeNumericCast<utf8proc_ssize_t>(len), &codepoint);
-		return codepoint;
-	}
-};
-
-ScalarFunction UnicodeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                      ScalarFunction::UnaryFunction<string_t, int32_t, UnicodeOperator>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/string/url_encode.cpp b/src/duckdb/extension/core_functions/scalar/string/url_encode.cpp
deleted file mode 100644
index 17b9ad3cc..000000000
--- a/src/duckdb/extension/core_functions/scalar/string/url_encode.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "core_functions/scalar/string_functions.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-struct URLEncodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_str = input.GetData();
-		auto input_size = input.GetSize();
-		idx_t result_length = StringUtil::URLEncodeSize(input_str, input_size);
-		auto result_str = StringVector::EmptyString(result, result_length);
-		StringUtil::URLEncodeBuffer(input_str, input_size, result_str.GetDataWriteable());
-		result_str.Finalize();
-		return result_str;
-	}
-};
-
-static void URLEncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, URLEncodeOperator>(args.data[0], result, args.size());
-}
-
-ScalarFunction UrlEncodeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, URLEncodeFunction);
-}
-
-struct URLDecodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_str = input.GetData();
-		auto input_size = input.GetSize();
-		idx_t result_length = StringUtil::URLDecodeSize(input_str, input_size);
-		auto result_str = StringVector::EmptyString(result, result_length);
-		StringUtil::URLDecodeBuffer(input_str, input_size, result_str.GetDataWriteable());
-		result_str.Finalize();
-		return result_str;
-	}
-};
-
-static void URLDecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, URLDecodeOperator>(args.data[0], result, args.size());
-}
-
-ScalarFunction UrlDecodeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, URLDecodeFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/struct/struct_insert.cpp b/src/duckdb/extension/core_functions/scalar/struct/struct_insert.cpp
deleted file mode 100644
index c83a83e3c..000000000
--- a/src/duckdb/extension/core_functions/scalar/struct/struct_insert.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "core_functions/scalar/struct_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-static void StructInsertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &starting_vec = args.data[0];
-	starting_vec.Verify(args.size());
-
-	auto &starting_child_entries = StructVector::GetEntries(starting_vec);
-	auto &result_child_entries = StructVector::GetEntries(result);
-
-	// Assign the original child entries to the STRUCT.
-	for (idx_t i = 0; i < starting_child_entries.size(); i++) {
-		auto &starting_child = starting_child_entries[i];
-		result_child_entries[i]->Reference(*starting_child);
-	}
-
-	// Assign the new children to the result vector.
-	for (idx_t i = 1; i < args.ColumnCount(); i++) {
-		result_child_entries[starting_child_entries.size() + i - 1]->Reference(args.data[i]);
-	}
-
-	result.Verify(args.size());
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.empty()) {
-		throw InvalidInputException("Missing required arguments for struct_insert function.");
-	}
-	if (LogicalTypeId::STRUCT != arguments[0]->return_type.id()) {
-		throw InvalidInputException("The first argument to struct_insert must be a STRUCT");
-	}
-	if (arguments.size() < 2) {
-		throw InvalidInputException("Can't insert nothing into a STRUCT");
-	}
-
-	case_insensitive_set_t name_collision_set;
-	child_list_t<LogicalType> new_children;
-	auto &existing_children = StructType::GetChildTypes(arguments[0]->return_type);
-
-	for (idx_t i = 0; i < existing_children.size(); i++) {
-		auto &child = existing_children[i];
-		name_collision_set.insert(child.first);
-		new_children.push_back(make_pair(child.first, child.second));
-	}
-
-	// Loop through the additional arguments (name/value pairs)
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		auto &child = arguments[i];
-		if (child->GetAlias().empty()) {
-			throw BinderException("Need named argument for struct insert, e.g., a := b");
-		}
-		if (name_collision_set.find(child->GetAlias()) != name_collision_set.end()) {
-			throw BinderException("Duplicate struct entry name \"%s\"", child->GetAlias());
-		}
-		name_collision_set.insert(child->GetAlias());
-		new_children.push_back(make_pair(child->GetAlias(), arguments[i]->return_type));
-	}
-
-	bound_function.return_type = LogicalType::STRUCT(new_children);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	auto new_stats = StructStats::CreateUnknown(expr.return_type);
-
-	auto existing_count = StructType::GetChildCount(child_stats[0].GetType());
-	auto existing_stats = StructStats::GetChildStats(child_stats[0]);
-	for (idx_t i = 0; i < existing_count; i++) {
-		StructStats::SetChildStats(new_stats, i, existing_stats[i]);
-	}
-
-	auto new_count = StructType::GetChildCount(expr.return_type);
-	auto offset = new_count - child_stats.size();
-	for (idx_t i = 1; i < child_stats.size(); i++) {
-		StructStats::SetChildStats(new_stats, offset + i, child_stats[i]);
-	}
-	return new_stats.ToUnique();
-}
-
-ScalarFunction StructInsertFun::GetFunction() {
-	ScalarFunction fun({}, LogicalTypeId::STRUCT, StructInsertFunction, StructInsertBind, nullptr, StructInsertStats);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.varargs = LogicalType::ANY;
-	fun.serialize = VariableReturnBindData::Serialize;
-	fun.deserialize = VariableReturnBindData::Deserialize;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/union/union_extract.cpp b/src/duckdb/extension/core_functions/scalar/union/union_extract.cpp
deleted file mode 100644
index 2a5371076..000000000
--- a/src/duckdb/extension/core_functions/scalar/union/union_extract.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "core_functions/scalar/union_functions.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-
-namespace duckdb {
-
-struct UnionExtractBindData : public FunctionData {
-	UnionExtractBindData(string key, idx_t index, LogicalType type)
-	    : key(std::move(key)), index(index), type(std::move(type)) {
-	}
-
-	string key;
-	idx_t index;
-	LogicalType type;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<UnionExtractBindData>(key, index, type);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<UnionExtractBindData>();
-		return key == other.key && index == other.index && type == other.type;
-	}
-};
-
-static void UnionExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<UnionExtractBindData>();
-
-	// this should be guaranteed by the binder
-	auto &vec = args.data[0];
-	vec.Verify(args.size());
-
-	D_ASSERT(info.index < UnionType::GetMemberCount(vec.GetType()));
-	auto &member = UnionVector::GetMember(vec, info.index);
-	result.Reference(member);
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	if (arguments[0]->return_type.id() != LogicalTypeId::UNION) {
-		throw BinderException("union_extract can only take a union parameter");
-	}
-	idx_t union_member_count = UnionType::GetMemberCount(arguments[0]->return_type);
-	if (union_member_count == 0) {
-		throw InternalException("Can't extract something from an empty union");
-	}
-	bound_function.arguments[0] = arguments[0]->return_type;
-
-	auto &key_child = arguments[1];
-	if (key_child->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-
-	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
-		throw BinderException("Key name for union_extract needs to be a constant string");
-	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
-	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	auto &key_str = StringValue::Get(key_val);
-	if (key_val.IsNull() || key_str.empty()) {
-		throw BinderException("Key name for union_extract needs to be neither NULL nor empty");
-	}
-	string key = StringUtil::Lower(key_str);
-
-	LogicalType return_type;
-	idx_t key_index = 0;
-	bool found_key = false;
-
-	for (size_t i = 0; i < union_member_count; i++) {
-		auto &member_name = UnionType::GetMemberName(arguments[0]->return_type, i);
-		if (StringUtil::Lower(member_name) == key) {
-			found_key = true;
-			key_index = i;
-			return_type = UnionType::GetMemberType(arguments[0]->return_type, i);
-			break;
-		}
-	}
-
-	if (!found_key) {
-		vector<string> candidates;
-		candidates.reserve(union_member_count);
-		for (idx_t i = 0; i < union_member_count; i++) {
-			candidates.push_back(UnionType::GetMemberName(arguments[0]->return_type, i));
-		}
-		auto closest_settings = StringUtil::TopNJaroWinkler(candidates, key);
-		auto message = StringUtil::CandidatesMessage(closest_settings, "Candidate Entries");
-		throw BinderException("Could not find key \"%s\" in union\n%s", key, message);
-	}
-
-	bound_function.return_type = return_type;
-	return make_uniq<UnionExtractBindData>(key, key_index, return_type);
-}
-
-ScalarFunction UnionExtractFun::GetFunction() {
-	// the arguments and return types are actually set in the binder function
-	return ScalarFunction({LogicalTypeId::UNION, LogicalType::VARCHAR}, LogicalType::ANY, UnionExtractFunction,
-	                      UnionExtractBind, nullptr, nullptr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/union/union_tag.cpp b/src/duckdb/extension/core_functions/scalar/union/union_tag.cpp
deleted file mode 100644
index 173e36d6c..000000000
--- a/src/duckdb/extension/core_functions/scalar/union/union_tag.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "core_functions/scalar/union_functions.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> UnionTagBind(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments) {
-
-	if (arguments.empty()) {
-		throw BinderException("Missing required arguments for union_tag function.");
-	}
-
-	if (LogicalTypeId::UNKNOWN == arguments[0]->return_type.id()) {
-		throw ParameterNotResolvedException();
-	}
-
-	if (LogicalTypeId::UNION != arguments[0]->return_type.id()) {
-		throw BinderException("First argument to union_tag function must be a union type.");
-	}
-
-	if (arguments.size() > 1) {
-		throw BinderException("Too many arguments, union_tag takes at most one argument.");
-	}
-
-	auto member_count = UnionType::GetMemberCount(arguments[0]->return_type);
-	if (member_count == 0) {
-		// this should never happen, empty unions are not allowed
-		throw InternalException("Can't get tags from an empty union");
-	}
-
-	bound_function.arguments[0] = arguments[0]->return_type;
-
-	auto varchar_vector = Vector(LogicalType::VARCHAR, member_count);
-	for (idx_t i = 0; i < member_count; i++) {
-		auto str = string_t(UnionType::GetMemberName(arguments[0]->return_type, i));
-		FlatVector::GetData<string_t>(varchar_vector)[i] =
-		    str.IsInlined() ? str : StringVector::AddString(varchar_vector, str);
-	}
-	auto enum_type = LogicalType::ENUM(varchar_vector, member_count);
-	bound_function.return_type = enum_type;
-
-	return nullptr;
-}
-
-static void UnionTagFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::ENUM);
-	result.Reinterpret(UnionVector::GetTags(args.data[0]));
-}
-
-ScalarFunction UnionTagFun::GetFunction() {
-	return ScalarFunction({LogicalTypeId::UNION}, LogicalTypeId::ANY, UnionTagFunction, UnionTagBind, nullptr,
-	                      nullptr); // TODO: Statistics?
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/union/union_value.cpp b/src/duckdb/extension/core_functions/scalar/union/union_value.cpp
deleted file mode 100644
index 655003da9..000000000
--- a/src/duckdb/extension/core_functions/scalar/union/union_value.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "core_functions/scalar/union_functions.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-
-namespace duckdb {
-
-struct UnionValueBindData : public FunctionData {
-	UnionValueBindData() {
-	}
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<UnionValueBindData>();
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		return true;
-	}
-};
-
-static void UnionValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// Assign the new entries to the result vector
-	UnionVector::GetMember(result, 0).Reference(args.data[0]);
-
-	// Set the result tag vector to a constant value
-	auto &tag_vector = UnionVector::GetTags(result);
-	tag_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::GetData<union_tag_t>(tag_vector)[0] = 0;
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	if (arguments.size() != 1) {
-		throw BinderException("union_value takes exactly one argument");
-	}
-	auto &child = arguments[0];
-
-	if (child->GetAlias().empty()) {
-		throw BinderException("Need named argument for union tag, e.g. UNION_VALUE(a := b)");
-	}
-
-	child_list_t<LogicalType> union_members;
-
-	union_members.push_back(make_pair(child->GetAlias(), child->return_type));
-
-	bound_function.return_type = LogicalType::UNION(std::move(union_members));
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction UnionValueFun::GetFunction() {
-	ScalarFunction fun("union_value", {}, LogicalTypeId::UNION, UnionValueFunction, UnionValueBind, nullptr, nullptr);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.serialize = VariableReturnBindData::Serialize;
-	fun.deserialize = VariableReturnBindData::Deserialize;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/column_reader.cpp b/src/duckdb/extension/parquet/column_reader.cpp
deleted file mode 100644
index 8a2112c35..000000000
--- a/src/duckdb/extension/parquet/column_reader.cpp
+++ /dev/null
@@ -1,1732 +0,0 @@
-#include "column_reader.hpp"
-
-#include "boolean_column_reader.hpp"
-#include "brotli/decode.h"
-#include "callback_column_reader.hpp"
-#include "cast_column_reader.hpp"
-#include "duckdb.hpp"
-#include "expression_column_reader.hpp"
-#include "list_column_reader.hpp"
-#include "lz4.hpp"
-#include "miniz_wrapper.hpp"
-#include "null_column_reader.hpp"
-#include "parquet_decimal_utils.hpp"
-#include "parquet_reader.hpp"
-#include "parquet_timestamp.hpp"
-#include "row_number_column_reader.hpp"
-#include "snappy.h"
-#include "string_column_reader.hpp"
-#include "struct_column_reader.hpp"
-#include "templated_column_reader.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "zstd.h"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/blob.hpp"
-#endif
-
-namespace duckdb {
-
-using duckdb_parquet::CompressionCodec;
-using duckdb_parquet::ConvertedType;
-using duckdb_parquet::Encoding;
-using duckdb_parquet::PageType;
-using duckdb_parquet::Type;
-
-const uint64_t ParquetDecodeUtils::BITPACK_MASKS[] = {0,
-                                                      1,
-                                                      3,
-                                                      7,
-                                                      15,
-                                                      31,
-                                                      63,
-                                                      127,
-                                                      255,
-                                                      511,
-                                                      1023,
-                                                      2047,
-                                                      4095,
-                                                      8191,
-                                                      16383,
-                                                      32767,
-                                                      65535,
-                                                      131071,
-                                                      262143,
-                                                      524287,
-                                                      1048575,
-                                                      2097151,
-                                                      4194303,
-                                                      8388607,
-                                                      16777215,
-                                                      33554431,
-                                                      67108863,
-                                                      134217727,
-                                                      268435455,
-                                                      536870911,
-                                                      1073741823,
-                                                      2147483647,
-                                                      4294967295,
-                                                      8589934591,
-                                                      17179869183,
-                                                      34359738367,
-                                                      68719476735,
-                                                      137438953471,
-                                                      274877906943,
-                                                      549755813887,
-                                                      1099511627775,
-                                                      2199023255551,
-                                                      4398046511103,
-                                                      8796093022207,
-                                                      17592186044415,
-                                                      35184372088831,
-                                                      70368744177663,
-                                                      140737488355327,
-                                                      281474976710655,
-                                                      562949953421311,
-                                                      1125899906842623,
-                                                      2251799813685247,
-                                                      4503599627370495,
-                                                      9007199254740991,
-                                                      18014398509481983,
-                                                      36028797018963967,
-                                                      72057594037927935,
-                                                      144115188075855871,
-                                                      288230376151711743,
-                                                      576460752303423487,
-                                                      1152921504606846975,
-                                                      2305843009213693951,
-                                                      4611686018427387903,
-                                                      9223372036854775807,
-                                                      18446744073709551615ULL};
-
-const uint64_t ParquetDecodeUtils::BITPACK_MASKS_SIZE = sizeof(ParquetDecodeUtils::BITPACK_MASKS) / sizeof(uint64_t);
-
-const uint8_t ParquetDecodeUtils::BITPACK_DLEN = 8;
-
-ColumnReader::ColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t file_idx_p,
-                           idx_t max_define_p, idx_t max_repeat_p)
-    : schema(schema_p), file_idx(file_idx_p), max_define(max_define_p), max_repeat(max_repeat_p), reader(reader),
-      type(std::move(type_p)), page_rows_available(0), dictionary_selection_vector(STANDARD_VECTOR_SIZE),
-      dictionary_size(0) {
-
-	// dummies for Skip()
-	dummy_define.resize(reader.allocator, STANDARD_VECTOR_SIZE);
-	dummy_repeat.resize(reader.allocator, STANDARD_VECTOR_SIZE);
-}
-
-ColumnReader::~ColumnReader() {
-}
-
-Allocator &ColumnReader::GetAllocator() {
-	return reader.allocator;
-}
-
-ParquetReader &ColumnReader::Reader() {
-	return reader;
-}
-
-const LogicalType &ColumnReader::Type() const {
-	return type;
-}
-
-const SchemaElement &ColumnReader::Schema() const {
-	return schema;
-}
-
-optional_ptr<const SchemaElement> ColumnReader::GetParentSchema() const {
-	return parent_schema;
-}
-
-void ColumnReader::SetParentSchema(const SchemaElement &parent_schema_p) {
-	parent_schema = &parent_schema_p;
-}
-
-idx_t ColumnReader::FileIdx() const {
-	return file_idx;
-}
-
-idx_t ColumnReader::MaxDefine() const {
-	return max_define;
-}
-
-idx_t ColumnReader::MaxRepeat() const {
-	return max_repeat;
-}
-
-void ColumnReader::RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) {
-	if (chunk) {
-		uint64_t size = chunk->meta_data.total_compressed_size;
-		transport.RegisterPrefetch(FileOffset(), size, allow_merge);
-	}
-}
-
-uint64_t ColumnReader::TotalCompressedSize() {
-	if (!chunk) {
-		return 0;
-	}
-
-	return chunk->meta_data.total_compressed_size;
-}
-
-// Note: It's not trivial to determine where all Column data is stored. Chunk->file_offset
-// apparently is not the first page of the data. Therefore we determine the address of the first page by taking the
-// minimum of all page offsets.
-idx_t ColumnReader::FileOffset() const {
-	if (!chunk) {
-		throw std::runtime_error("FileOffset called on ColumnReader with no chunk");
-	}
-	auto min_offset = NumericLimits<idx_t>::Maximum();
-	if (chunk->meta_data.__isset.dictionary_page_offset) {
-		min_offset = MinValue<idx_t>(min_offset, chunk->meta_data.dictionary_page_offset);
-	}
-	if (chunk->meta_data.__isset.index_page_offset) {
-		min_offset = MinValue<idx_t>(min_offset, chunk->meta_data.index_page_offset);
-	}
-	min_offset = MinValue<idx_t>(min_offset, chunk->meta_data.data_page_offset);
-
-	return min_offset;
-}
-
-idx_t ColumnReader::GroupRowsAvailable() {
-	return group_rows_available;
-}
-
-unique_ptr<BaseStatistics> ColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
-	return ParquetStatisticsUtils::TransformColumnStatistics(*this, columns);
-}
-
-void ColumnReader::Plain(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, idx_t num_values, // NOLINT
-                         parquet_filter_t *filter, idx_t result_offset, Vector &result) {
-	throw NotImplementedException("Plain");
-}
-
-void ColumnReader::PrepareDeltaLengthByteArray(ResizeableBuffer &buffer) {
-	throw std::runtime_error("DELTA_LENGTH_BYTE_ARRAY encoding is only supported for text or binary data");
-}
-
-void ColumnReader::PrepareDeltaByteArray(ResizeableBuffer &buffer) {
-	throw std::runtime_error("DELTA_BYTE_ARRAY encoding is only supported for text or binary data");
-}
-
-void ColumnReader::DeltaByteArray(uint8_t *defines, idx_t num_values, // NOLINT
-                                  parquet_filter_t &filter, idx_t result_offset, Vector &result) {
-	throw NotImplementedException("DeltaByteArray");
-}
-
-void ColumnReader::PlainReference(shared_ptr<ByteBuffer>, Vector &result) { // NOLINT
-}
-
-void ColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) {
-	D_ASSERT(file_idx < columns.size());
-	chunk = &columns[file_idx];
-	protocol = &protocol_p;
-	D_ASSERT(chunk);
-	D_ASSERT(chunk->__isset.meta_data);
-
-	if (chunk->__isset.file_path) {
-		throw std::runtime_error("Only inlined data files are supported (no references)");
-	}
-
-	// ugh. sometimes there is an extra offset for the dict. sometimes it's wrong.
-	chunk_read_offset = chunk->meta_data.data_page_offset;
-	if (chunk->meta_data.__isset.dictionary_page_offset && chunk->meta_data.dictionary_page_offset >= 4) {
-		// this assumes the data pages follow the dict pages directly.
-		chunk_read_offset = chunk->meta_data.dictionary_page_offset;
-	}
-	group_rows_available = chunk->meta_data.num_values;
-}
-
-void ColumnReader::PrepareRead(parquet_filter_t &filter) {
-	dict_decoder.reset();
-	defined_decoder.reset();
-	bss_decoder.reset();
-	block.reset();
-	PageHeader page_hdr;
-	reader.Read(page_hdr, *protocol);
-	// some basic sanity check
-	if (page_hdr.compressed_page_size < 0 || page_hdr.uncompressed_page_size < 0) {
-		throw std::runtime_error("Page sizes can't be < 0");
-	}
-
-	switch (page_hdr.type) {
-	case PageType::DATA_PAGE_V2:
-		PreparePageV2(page_hdr);
-		PrepareDataPage(page_hdr);
-		break;
-	case PageType::DATA_PAGE:
-		PreparePage(page_hdr);
-		PrepareDataPage(page_hdr);
-		break;
-	case PageType::DICTIONARY_PAGE: {
-		PreparePage(page_hdr);
-		if (page_hdr.dictionary_page_header.num_values < 0) {
-			throw std::runtime_error("Invalid dictionary page header (num_values < 0)");
-		}
-		auto old_dict_size = dictionary_size;
-		// we use the first value in the dictionary to keep a NULL
-		dictionary_size = page_hdr.dictionary_page_header.num_values;
-		if (!dictionary) {
-			dictionary = make_uniq<Vector>(type, dictionary_size + 1);
-		} else if (dictionary_size > old_dict_size) {
-			dictionary->Resize(old_dict_size, dictionary_size + 1);
-		}
-		dictionary_id = reader.file_name + "_" + schema.name + "_" + std::to_string(chunk_read_offset);
-		// we use the first entry as a NULL, dictionary vectors don't have a separate validity mask
-		FlatVector::Validity(*dictionary).SetInvalid(0);
-		PlainReference(block, *dictionary);
-		Plain(block, nullptr, dictionary_size, nullptr, 1, *dictionary);
-		break;
-	}
-	default:
-		break; // ignore INDEX page type and any other custom extensions
-	}
-	ResetPage();
-}
-
-void ColumnReader::ResetPage() {
-}
-
-void ColumnReader::PreparePageV2(PageHeader &page_hdr) {
-	D_ASSERT(page_hdr.type == PageType::DATA_PAGE_V2);
-	auto &trans = reinterpret_cast<ThriftFileTransport &>(*protocol->getTransport());
-
-	AllocateBlock(page_hdr.uncompressed_page_size + 1);
-	bool uncompressed = false;
-	if (page_hdr.data_page_header_v2.__isset.is_compressed && !page_hdr.data_page_header_v2.is_compressed) {
-		uncompressed = true;
-	}
-	if (chunk->meta_data.codec == CompressionCodec::UNCOMPRESSED) {
-		if (page_hdr.compressed_page_size != page_hdr.uncompressed_page_size) {
-			throw std::runtime_error("Page size mismatch");
-		}
-		uncompressed = true;
-	}
-	if (uncompressed) {
-		reader.ReadData(*protocol, block->ptr, page_hdr.compressed_page_size);
-		return;
-	}
-
-	// copy repeats & defines as-is because FOR SOME REASON they are uncompressed
-	auto uncompressed_bytes = page_hdr.data_page_header_v2.repetition_levels_byte_length +
-	                          page_hdr.data_page_header_v2.definition_levels_byte_length;
-	if (uncompressed_bytes > page_hdr.uncompressed_page_size) {
-		throw std::runtime_error("Page header inconsistency, uncompressed_page_size needs to be larger than "
-		                         "repetition_levels_byte_length + definition_levels_byte_length");
-	}
-	trans.read(block->ptr, uncompressed_bytes);
-
-	auto compressed_bytes = page_hdr.compressed_page_size - uncompressed_bytes;
-
-	AllocateCompressed(compressed_bytes);
-	reader.ReadData(*protocol, compressed_buffer.ptr, compressed_bytes);
-
-	DecompressInternal(chunk->meta_data.codec, compressed_buffer.ptr, compressed_bytes, block->ptr + uncompressed_bytes,
-	                   page_hdr.uncompressed_page_size - uncompressed_bytes);
-}
-
-void ColumnReader::AllocateBlock(idx_t size) {
-	if (!block) {
-		block = make_shared_ptr<ResizeableBuffer>(GetAllocator(), size);
-	} else {
-		block->resize(GetAllocator(), size);
-	}
-}
-
-void ColumnReader::AllocateCompressed(idx_t size) {
-	compressed_buffer.resize(GetAllocator(), size);
-}
-
-void ColumnReader::PreparePage(PageHeader &page_hdr) {
-	AllocateBlock(page_hdr.uncompressed_page_size + 1);
-	if (chunk->meta_data.codec == CompressionCodec::UNCOMPRESSED) {
-		if (page_hdr.compressed_page_size != page_hdr.uncompressed_page_size) {
-			throw std::runtime_error("Page size mismatch");
-		}
-		reader.ReadData(*protocol, block->ptr, page_hdr.compressed_page_size);
-		return;
-	}
-
-	AllocateCompressed(page_hdr.compressed_page_size + 1);
-	reader.ReadData(*protocol, compressed_buffer.ptr, page_hdr.compressed_page_size);
-
-	DecompressInternal(chunk->meta_data.codec, compressed_buffer.ptr, page_hdr.compressed_page_size, block->ptr,
-	                   page_hdr.uncompressed_page_size);
-}
-
-void ColumnReader::DecompressInternal(CompressionCodec::type codec, const_data_ptr_t src, idx_t src_size,
-                                      data_ptr_t dst, idx_t dst_size) {
-	switch (codec) {
-	case CompressionCodec::UNCOMPRESSED:
-		throw InternalException("Parquet data unexpectedly uncompressed");
-	case CompressionCodec::GZIP: {
-		MiniZStream s;
-		s.Decompress(const_char_ptr_cast(src), src_size, char_ptr_cast(dst), dst_size);
-		break;
-	}
-	case CompressionCodec::LZ4_RAW: {
-		auto res =
-		    duckdb_lz4::LZ4_decompress_safe(const_char_ptr_cast(src), char_ptr_cast(dst),
-		                                    UnsafeNumericCast<int32_t>(src_size), UnsafeNumericCast<int32_t>(dst_size));
-		if (res != NumericCast<int>(dst_size)) {
-			throw std::runtime_error("LZ4 decompression failure");
-		}
-		break;
-	}
-	case CompressionCodec::SNAPPY: {
-		{
-			size_t uncompressed_size = 0;
-			auto res = duckdb_snappy::GetUncompressedLength(const_char_ptr_cast(src), src_size, &uncompressed_size);
-			if (!res) {
-				throw std::runtime_error("Snappy decompression failure");
-			}
-			if (uncompressed_size != dst_size) {
-				throw std::runtime_error("Snappy decompression failure: Uncompressed data size mismatch");
-			}
-		}
-		auto res = duckdb_snappy::RawUncompress(const_char_ptr_cast(src), src_size, char_ptr_cast(dst));
-		if (!res) {
-			throw std::runtime_error("Snappy decompression failure");
-		}
-		break;
-	}
-	case CompressionCodec::ZSTD: {
-		auto res = duckdb_zstd::ZSTD_decompress(dst, dst_size, src, src_size);
-		if (duckdb_zstd::ZSTD_isError(res) || res != dst_size) {
-			throw std::runtime_error("ZSTD Decompression failure");
-		}
-		break;
-	}
-	case CompressionCodec::BROTLI: {
-		auto state = duckdb_brotli::BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
-		size_t total_out = 0;
-		auto src_size_size_t = NumericCast<size_t>(src_size);
-		auto dst_size_size_t = NumericCast<size_t>(dst_size);
-
-		auto res = duckdb_brotli::BrotliDecoderDecompressStream(state, &src_size_size_t, &src, &dst_size_size_t, &dst,
-		                                                        &total_out);
-		if (res != duckdb_brotli::BROTLI_DECODER_RESULT_SUCCESS) {
-			throw std::runtime_error("Brotli Decompression failure");
-		}
-		duckdb_brotli::BrotliDecoderDestroyInstance(state);
-		break;
-	}
-
-	default: {
-		std::stringstream codec_name;
-		codec_name << codec;
-		throw std::runtime_error("Unsupported compression codec \"" + codec_name.str() +
-		                         "\". Supported options are uncompressed, brotli, gzip, lz4_raw, snappy or zstd");
-	}
-	}
-}
-
-void ColumnReader::PrepareDataPage(PageHeader &page_hdr) {
-	if (page_hdr.type == PageType::DATA_PAGE && !page_hdr.__isset.data_page_header) {
-		throw std::runtime_error("Missing data page header from data page");
-	}
-	if (page_hdr.type == PageType::DATA_PAGE_V2 && !page_hdr.__isset.data_page_header_v2) {
-		throw std::runtime_error("Missing data page header from data page v2");
-	}
-
-	bool is_v1 = page_hdr.type == PageType::DATA_PAGE;
-	bool is_v2 = page_hdr.type == PageType::DATA_PAGE_V2;
-	auto &v1_header = page_hdr.data_page_header;
-	auto &v2_header = page_hdr.data_page_header_v2;
-
-	page_rows_available = is_v1 ? v1_header.num_values : v2_header.num_values;
-	auto page_encoding = is_v1 ? v1_header.encoding : v2_header.encoding;
-
-	if (HasRepeats()) {
-		uint32_t rep_length = is_v1 ? block->read<uint32_t>() : v2_header.repetition_levels_byte_length;
-		block->available(rep_length);
-		repeated_decoder = make_uniq<RleBpDecoder>(block->ptr, rep_length, RleBpDecoder::ComputeBitWidth(max_repeat));
-		block->inc(rep_length);
-	} else if (is_v2 && v2_header.repetition_levels_byte_length > 0) {
-		block->inc(v2_header.repetition_levels_byte_length);
-	}
-
-	if (HasDefines()) {
-		uint32_t def_length = is_v1 ? block->read<uint32_t>() : v2_header.definition_levels_byte_length;
-		block->available(def_length);
-		defined_decoder = make_uniq<RleBpDecoder>(block->ptr, def_length, RleBpDecoder::ComputeBitWidth(max_define));
-		block->inc(def_length);
-	} else if (is_v2 && v2_header.definition_levels_byte_length > 0) {
-		block->inc(v2_header.definition_levels_byte_length);
-	}
-
-	switch (page_encoding) {
-	case Encoding::RLE_DICTIONARY:
-	case Encoding::PLAIN_DICTIONARY: {
-		// where is it otherwise??
-		auto dict_width = block->read<uint8_t>();
-		// TODO somehow dict_width can be 0 ?
-		dict_decoder = make_uniq<RleBpDecoder>(block->ptr, block->len, dict_width);
-		block->inc(block->len);
-		break;
-	}
-	case Encoding::RLE: {
-		if (type.id() != LogicalTypeId::BOOLEAN) {
-			throw std::runtime_error("RLE encoding is only supported for boolean data");
-		}
-		block->inc(sizeof(uint32_t));
-		rle_decoder = make_uniq<RleBpDecoder>(block->ptr, block->len, 1);
-		break;
-	}
-	case Encoding::DELTA_BINARY_PACKED: {
-		dbp_decoder = make_uniq<DbpDecoder>(block->ptr, block->len);
-		block->inc(block->len);
-		break;
-	}
-	case Encoding::DELTA_LENGTH_BYTE_ARRAY: {
-		PrepareDeltaLengthByteArray(*block);
-		break;
-	}
-	case Encoding::DELTA_BYTE_ARRAY: {
-		PrepareDeltaByteArray(*block);
-		break;
-	}
-	case Encoding::BYTE_STREAM_SPLIT: {
-		// Subtract 1 from length as the block is allocated with 1 extra byte,
-		// but the byte stream split encoder needs to know the correct data size.
-		bss_decoder = make_uniq<BssDecoder>(block->ptr, block->len - 1);
-		block->inc(block->len);
-		break;
-	}
-	case Encoding::PLAIN:
-		// nothing to do here, will be read directly below
-		break;
-
-	default:
-		throw std::runtime_error("Unsupported page encoding");
-	}
-}
-
-void ColumnReader::ConvertDictToSelVec(uint32_t *offsets, uint8_t *defines, parquet_filter_t &filter, idx_t read_now,
-                                       idx_t result_offset) {
-	D_ASSERT(read_now <= STANDARD_VECTOR_SIZE);
-	idx_t offset_idx = 0;
-	for (idx_t row_idx = 0; row_idx < read_now; row_idx++) {
-		if (HasDefines() && defines[row_idx + result_offset] != max_define) {
-			dictionary_selection_vector.set_index(row_idx, 0); // dictionary entry 0 is NULL
-			continue;                                          // we don't have a dict entry for NULLs
-		}
-		if (filter.test(row_idx + result_offset)) {
-			auto offset = offsets[offset_idx++];
-			if (offset >= dictionary_size) {
-				throw std::runtime_error("Parquet file is likely corrupted, dictionary offset out of range");
-			}
-			dictionary_selection_vector.set_index(row_idx, offset + 1);
-		} else {
-			dictionary_selection_vector.set_index(row_idx, 0); // just set NULL if the filter excludes this row
-			offset_idx++;
-		}
-	}
-#ifdef DEBUG
-	dictionary_selection_vector.Verify(read_now, dictionary_size + 1);
-#endif
-}
-
-idx_t ColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-                         Vector &result) {
-	// we need to reset the location because multiple column readers share the same protocol
-	auto &trans = reinterpret_cast<ThriftFileTransport &>(*protocol->getTransport());
-	trans.SetLocation(chunk_read_offset);
-
-	// Perform any skips that were not applied yet.
-	if (pending_skips > 0) {
-		ApplyPendingSkips(pending_skips);
-	}
-
-	idx_t result_offset = 0;
-	auto to_read = num_values;
-	D_ASSERT(to_read <= STANDARD_VECTOR_SIZE);
-
-	while (to_read > 0) {
-		while (page_rows_available == 0) {
-			PrepareRead(filter);
-		}
-
-		D_ASSERT(block);
-		auto read_now = MinValue<idx_t>(to_read, page_rows_available);
-
-		D_ASSERT(read_now + result_offset <= STANDARD_VECTOR_SIZE);
-
-		if (HasRepeats()) {
-			D_ASSERT(repeated_decoder);
-			repeated_decoder->GetBatch<uint8_t>(repeat_out + result_offset, read_now);
-		}
-
-		if (HasDefines()) {
-			D_ASSERT(defined_decoder);
-			defined_decoder->GetBatch<uint8_t>(define_out + result_offset, read_now);
-		}
-
-		idx_t null_count = 0;
-
-		if ((dict_decoder || dbp_decoder || rle_decoder || bss_decoder) && HasDefines()) {
-			// we need the null count because the dictionary offsets have no entries for nulls
-			for (idx_t i = result_offset; i < result_offset + read_now; i++) {
-				null_count += (define_out[i] != max_define);
-			}
-		}
-
-		if (result_offset != 0 && result.GetVectorType() != VectorType::FLAT_VECTOR) {
-			result.Flatten(result_offset);
-			result.Resize(result_offset, STANDARD_VECTOR_SIZE);
-		}
-
-		if (dict_decoder) {
-			if ((!dictionary || dictionary_size == 0) && null_count < read_now) {
-				throw std::runtime_error("Parquet file is likely corrupted, missing dictionary");
-			}
-			offset_buffer.resize(reader.allocator, sizeof(uint32_t) * (read_now - null_count));
-			dict_decoder->GetBatch<uint32_t>(offset_buffer.ptr, read_now - null_count);
-			ConvertDictToSelVec(reinterpret_cast<uint32_t *>(offset_buffer.ptr),
-			                    reinterpret_cast<uint8_t *>(define_out), filter, read_now, result_offset);
-			if (result_offset == 0) {
-				result.Dictionary(*dictionary, dictionary_size + 1, dictionary_selection_vector, read_now);
-				DictionaryVector::SetDictionaryId(result, dictionary_id);
-				D_ASSERT(result.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-			} else {
-				D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-				VectorOperations::Copy(*dictionary, result, dictionary_selection_vector, read_now, 0, result_offset);
-			}
-		} else if (dbp_decoder) {
-			// TODO keep this in the state
-			auto read_buf = make_shared_ptr<ResizeableBuffer>();
-
-			switch (schema.type) {
-			case duckdb_parquet::Type::INT32:
-				read_buf->resize(reader.allocator, sizeof(int32_t) * (read_now - null_count));
-				dbp_decoder->GetBatch<int32_t>(read_buf->ptr, read_now - null_count);
-
-				break;
-			case duckdb_parquet::Type::INT64:
-				read_buf->resize(reader.allocator, sizeof(int64_t) * (read_now - null_count));
-				dbp_decoder->GetBatch<int64_t>(read_buf->ptr, read_now - null_count);
-				break;
-
-			default:
-				throw std::runtime_error("DELTA_BINARY_PACKED should only be INT32 or INT64");
-			}
-			// Plain() will put NULLs in the right place
-			Plain(read_buf, define_out, read_now, &filter, result_offset, result);
-		} else if (rle_decoder) {
-			// RLE encoding for boolean
-			D_ASSERT(type.id() == LogicalTypeId::BOOLEAN);
-			auto read_buf = make_shared_ptr<ResizeableBuffer>();
-			read_buf->resize(reader.allocator, sizeof(bool) * (read_now - null_count));
-			rle_decoder->GetBatch<uint8_t>(read_buf->ptr, read_now - null_count);
-			PlainTemplated<bool, TemplatedParquetValueConversion<bool>>(read_buf, define_out, read_now, &filter,
-			                                                            result_offset, result);
-		} else if (byte_array_data) {
-			// DELTA_BYTE_ARRAY or DELTA_LENGTH_BYTE_ARRAY
-			DeltaByteArray(define_out, read_now, filter, result_offset, result);
-		} else if (bss_decoder) {
-			auto read_buf = make_shared_ptr<ResizeableBuffer>();
-
-			switch (schema.type) {
-			case duckdb_parquet::Type::FLOAT:
-				read_buf->resize(reader.allocator, sizeof(float) * (read_now - null_count));
-				bss_decoder->GetBatch<float>(read_buf->ptr, read_now - null_count);
-				break;
-			case duckdb_parquet::Type::DOUBLE:
-				read_buf->resize(reader.allocator, sizeof(double) * (read_now - null_count));
-				bss_decoder->GetBatch<double>(read_buf->ptr, read_now - null_count);
-				break;
-			default:
-				throw std::runtime_error("BYTE_STREAM_SPLIT encoding is only supported for FLOAT or DOUBLE data");
-			}
-
-			Plain(read_buf, define_out, read_now, &filter, result_offset, result);
-		} else {
-			PlainReference(block, result);
-			Plain(block, define_out, read_now, &filter, result_offset, result);
-		}
-
-		result_offset += read_now;
-		page_rows_available -= read_now;
-		to_read -= read_now;
-	}
-	group_rows_available -= num_values;
-	chunk_read_offset = trans.GetLocation();
-
-	return num_values;
-}
-
-void ColumnReader::Skip(idx_t num_values) {
-	pending_skips += num_values;
-}
-
-void ColumnReader::ApplyPendingSkips(idx_t num_values) {
-	pending_skips -= num_values;
-
-	dummy_define.zero();
-	dummy_repeat.zero();
-
-	// TODO this can be optimized, for example we dont actually have to bitunpack offsets
-	Vector base_result(type, nullptr);
-
-	idx_t remaining = num_values;
-	idx_t read = 0;
-
-	while (remaining) {
-		Vector dummy_result(base_result);
-		idx_t to_read = MinValue<idx_t>(remaining, STANDARD_VECTOR_SIZE);
-		read += Read(to_read, none_filter, dummy_define.ptr, dummy_repeat.ptr, dummy_result);
-		remaining -= to_read;
-	}
-
-	if (read != num_values) {
-		throw std::runtime_error("Row count mismatch when skipping rows");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// String Column Reader
-//===--------------------------------------------------------------------===//
-StringColumnReader::StringColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p,
-                                       idx_t schema_idx_p, idx_t max_define_p, idx_t max_repeat_p)
-    : TemplatedColumnReader<string_t, StringParquetValueConversion>(reader, std::move(type_p), schema_p, schema_idx_p,
-                                                                    max_define_p, max_repeat_p) {
-	fixed_width_string_length = 0;
-	if (schema_p.type == Type::FIXED_LEN_BYTE_ARRAY) {
-		D_ASSERT(schema_p.__isset.type_length);
-		fixed_width_string_length = schema_p.type_length;
-	}
-}
-
-uint32_t StringColumnReader::VerifyString(const char *str_data, uint32_t str_len, const bool is_varchar) {
-	if (!is_varchar) {
-		return str_len;
-	}
-	// verify if a string is actually UTF8, and if there are no null bytes in the middle of the string
-	// technically Parquet should guarantee this, but reality is often disappointing
-	UnicodeInvalidReason reason;
-	size_t pos;
-	auto utf_type = Utf8Proc::Analyze(str_data, str_len, &reason, &pos);
-	if (utf_type == UnicodeType::INVALID) {
-		throw InvalidInputException("Invalid string encoding found in Parquet file: value \"" +
-		                            Blob::ToString(string_t(str_data, str_len)) + "\" is not valid UTF8!");
-	}
-	return str_len;
-}
-
-uint32_t StringColumnReader::VerifyString(const char *str_data, uint32_t str_len) {
-	return VerifyString(str_data, str_len, Type() == LogicalTypeId::VARCHAR);
-}
-
-static shared_ptr<ResizeableBuffer> ReadDbpData(Allocator &allocator, ResizeableBuffer &buffer, idx_t &value_count) {
-	auto decoder = make_uniq<DbpDecoder>(buffer.ptr, buffer.len);
-	value_count = decoder->TotalValues();
-	auto result = make_shared_ptr<ResizeableBuffer>();
-	result->resize(allocator, sizeof(uint32_t) * value_count);
-	decoder->GetBatch<uint32_t>(result->ptr, value_count);
-	decoder->Finalize();
-	buffer.inc(buffer.len - decoder->BufferPtr().len);
-	return result;
-}
-
-void StringColumnReader::PrepareDeltaLengthByteArray(ResizeableBuffer &buffer) {
-	idx_t value_count;
-	auto length_buffer = ReadDbpData(reader.allocator, buffer, value_count);
-	if (value_count == 0) {
-		// no values
-		byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, nullptr);
-		return;
-	}
-	auto length_data = reinterpret_cast<uint32_t *>(length_buffer->ptr);
-	byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, value_count);
-	byte_array_count = value_count;
-	delta_offset = 0;
-	auto string_data = FlatVector::GetData<string_t>(*byte_array_data);
-	for (idx_t i = 0; i < value_count; i++) {
-		auto str_len = length_data[i];
-		buffer.available(str_len);
-		string_data[i] = StringVector::EmptyString(*byte_array_data, str_len);
-		auto result_data = string_data[i].GetDataWriteable();
-		memcpy(result_data, buffer.ptr, length_data[i]);
-		buffer.inc(length_data[i]);
-		string_data[i].Finalize();
-	}
-}
-
-void StringColumnReader::PrepareDeltaByteArray(ResizeableBuffer &buffer) {
-	idx_t prefix_count, suffix_count;
-	auto prefix_buffer = ReadDbpData(reader.allocator, buffer, prefix_count);
-	auto suffix_buffer = ReadDbpData(reader.allocator, buffer, suffix_count);
-	if (prefix_count != suffix_count) {
-		throw std::runtime_error("DELTA_BYTE_ARRAY - prefix and suffix counts are different - corrupt file?");
-	}
-	if (prefix_count == 0) {
-		// no values
-		byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, nullptr);
-		return;
-	}
-	auto prefix_data = reinterpret_cast<uint32_t *>(prefix_buffer->ptr);
-	auto suffix_data = reinterpret_cast<uint32_t *>(suffix_buffer->ptr);
-	byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, prefix_count);
-	byte_array_count = prefix_count;
-	delta_offset = 0;
-	auto string_data = FlatVector::GetData<string_t>(*byte_array_data);
-	for (idx_t i = 0; i < prefix_count; i++) {
-		auto str_len = prefix_data[i] + suffix_data[i];
-		buffer.available(suffix_data[i]);
-		string_data[i] = StringVector::EmptyString(*byte_array_data, str_len);
-		auto result_data = string_data[i].GetDataWriteable();
-		if (prefix_data[i] > 0) {
-			if (i == 0 || prefix_data[i] > string_data[i - 1].GetSize()) {
-				throw std::runtime_error("DELTA_BYTE_ARRAY - prefix is out of range - corrupt file?");
-			}
-			memcpy(result_data, string_data[i - 1].GetData(), prefix_data[i]);
-		}
-		memcpy(result_data + prefix_data[i], buffer.ptr, suffix_data[i]);
-		buffer.inc(suffix_data[i]);
-		string_data[i].Finalize();
-	}
-}
-
-void StringColumnReader::DeltaByteArray(uint8_t *defines, idx_t num_values, parquet_filter_t &filter,
-                                        idx_t result_offset, Vector &result) {
-	if (!byte_array_data) {
-		throw std::runtime_error("Internal error - DeltaByteArray called but there was no byte_array_data set");
-	}
-	auto result_ptr = FlatVector::GetData<string_t>(result);
-	auto &result_mask = FlatVector::Validity(result);
-	auto string_data = FlatVector::GetData<string_t>(*byte_array_data);
-	for (idx_t row_idx = 0; row_idx < num_values; row_idx++) {
-		if (HasDefines() && defines[row_idx + result_offset] != max_define) {
-			result_mask.SetInvalid(row_idx + result_offset);
-			continue;
-		}
-		if (filter.test(row_idx + result_offset)) {
-			if (delta_offset >= byte_array_count) {
-				throw IOException("DELTA_BYTE_ARRAY - length mismatch between values and byte array lengths (attempted "
-				                  "read of %d from %d entries) - corrupt file?",
-				                  delta_offset + 1, byte_array_count);
-			}
-			result_ptr[row_idx + result_offset] = string_data[delta_offset++];
-		} else {
-			delta_offset++;
-		}
-	}
-	StringVector::AddHeapReference(result, *byte_array_data);
-}
-
-class ParquetStringVectorBuffer : public VectorBuffer {
-public:
-	explicit ParquetStringVectorBuffer(shared_ptr<ByteBuffer> buffer_p)
-	    : VectorBuffer(VectorBufferType::OPAQUE_BUFFER), buffer(std::move(buffer_p)) {
-	}
-
-private:
-	shared_ptr<ByteBuffer> buffer;
-};
-
-void StringColumnReader::PlainReference(shared_ptr<ByteBuffer> plain_data, Vector &result) {
-	StringVector::AddBuffer(result, make_buffer<ParquetStringVectorBuffer>(std::move(plain_data)));
-}
-
-string_t StringParquetValueConversion::PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-	auto &scr = reader.Cast<StringColumnReader>();
-	uint32_t str_len = scr.fixed_width_string_length == 0 ? plain_data.read<uint32_t>() : scr.fixed_width_string_length;
-	plain_data.available(str_len);
-	auto plain_str = char_ptr_cast(plain_data.ptr);
-	auto actual_str_len = reader.Cast<StringColumnReader>().VerifyString(plain_str, str_len);
-	auto ret_str = string_t(plain_str, actual_str_len);
-	plain_data.inc(str_len);
-	return ret_str;
-}
-
-void StringParquetValueConversion::PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-	auto &scr = reader.Cast<StringColumnReader>();
-	uint32_t str_len = scr.fixed_width_string_length == 0 ? plain_data.read<uint32_t>() : scr.fixed_width_string_length;
-	plain_data.inc(str_len);
-}
-
-bool StringParquetValueConversion::PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-	return true;
-}
-
-string_t StringParquetValueConversion::UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-	return PlainRead(plain_data, reader);
-}
-
-void StringParquetValueConversion::UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-	PlainSkip(plain_data, reader);
-}
-
-//===--------------------------------------------------------------------===//
-// List Column Reader
-//===--------------------------------------------------------------------===//
-idx_t ListColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out,
-                             data_ptr_t repeat_out, Vector &result_out) {
-	idx_t result_offset = 0;
-	auto result_ptr = FlatVector::GetData<list_entry_t>(result_out);
-	auto &result_mask = FlatVector::Validity(result_out);
-
-	if (pending_skips > 0) {
-		ApplyPendingSkips(pending_skips);
-	}
-
-	D_ASSERT(ListVector::GetListSize(result_out) == 0);
-	// if an individual list is longer than STANDARD_VECTOR_SIZE we actually have to loop the child read to fill it
-	bool finished = false;
-	while (!finished) {
-		idx_t child_actual_num_values = 0;
-
-		// check if we have any overflow from a previous read
-		if (overflow_child_count == 0) {
-			// we don't: read elements from the child reader
-			child_defines.zero();
-			child_repeats.zero();
-			// we don't know in advance how many values to read because of the beautiful repetition/definition setup
-			// we just read (up to) a vector from the child column, and see if we have read enough
-			// if we have not read enough, we read another vector
-			// if we have read enough, we leave any unhandled elements in the overflow vector for a subsequent read
-			auto child_req_num_values =
-			    MinValue<idx_t>(STANDARD_VECTOR_SIZE, child_column_reader->GroupRowsAvailable());
-			read_vector.ResetFromCache(read_cache);
-			child_actual_num_values = child_column_reader->Read(child_req_num_values, child_filter, child_defines_ptr,
-			                                                    child_repeats_ptr, read_vector);
-		} else {
-			// we do: use the overflow values
-			child_actual_num_values = overflow_child_count;
-			overflow_child_count = 0;
-		}
-
-		if (child_actual_num_values == 0) {
-			// no more elements available: we are done
-			break;
-		}
-		read_vector.Verify(child_actual_num_values);
-		idx_t current_chunk_offset = ListVector::GetListSize(result_out);
-
-		// hard-won piece of code this, modify at your own risk
-		// the intuition is that we have to only collapse values into lists that are repeated *on this level*
-		// the rest is pretty much handed up as-is as a single-valued list or NULL
-		idx_t child_idx;
-		for (child_idx = 0; child_idx < child_actual_num_values; child_idx++) {
-			if (child_repeats_ptr[child_idx] == max_repeat) {
-				// value repeats on this level, append
-				D_ASSERT(result_offset > 0);
-				result_ptr[result_offset - 1].length++;
-				continue;
-			}
-
-			if (result_offset >= num_values) {
-				// we ran out of output space
-				finished = true;
-				break;
-			}
-			if (child_defines_ptr[child_idx] >= max_define) {
-				// value has been defined down the stack, hence its NOT NULL
-				result_ptr[result_offset].offset = child_idx + current_chunk_offset;
-				result_ptr[result_offset].length = 1;
-			} else if (child_defines_ptr[child_idx] == max_define - 1) {
-				// empty list
-				result_ptr[result_offset].offset = child_idx + current_chunk_offset;
-				result_ptr[result_offset].length = 0;
-			} else {
-				// value is NULL somewhere up the stack
-				result_mask.SetInvalid(result_offset);
-				result_ptr[result_offset].offset = 0;
-				result_ptr[result_offset].length = 0;
-			}
-
-			repeat_out[result_offset] = child_repeats_ptr[child_idx];
-			define_out[result_offset] = child_defines_ptr[child_idx];
-
-			result_offset++;
-		}
-		// actually append the required elements to the child list
-		ListVector::Append(result_out, read_vector, child_idx);
-
-		// we have read more values from the child reader than we can fit into the result for this read
-		// we have to pass everything from child_idx to child_actual_num_values into the next call
-		if (child_idx < child_actual_num_values && result_offset == num_values) {
-			read_vector.Slice(read_vector, child_idx, child_actual_num_values);
-			overflow_child_count = child_actual_num_values - child_idx;
-			read_vector.Verify(overflow_child_count);
-
-			// move values in the child repeats and defines *backward* by child_idx
-			for (idx_t repdef_idx = 0; repdef_idx < overflow_child_count; repdef_idx++) {
-				child_defines_ptr[repdef_idx] = child_defines_ptr[child_idx + repdef_idx];
-				child_repeats_ptr[repdef_idx] = child_repeats_ptr[child_idx + repdef_idx];
-			}
-		}
-	}
-	result_out.Verify(result_offset);
-	return result_offset;
-}
-
-ListColumnReader::ListColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p,
-                                   idx_t schema_idx_p, idx_t max_define_p, idx_t max_repeat_p,
-                                   unique_ptr<ColumnReader> child_column_reader_p)
-    : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p),
-      child_column_reader(std::move(child_column_reader_p)),
-      read_cache(reader.allocator, ListType::GetChildType(Type())), read_vector(read_cache), overflow_child_count(0) {
-
-	child_defines.resize(reader.allocator, STANDARD_VECTOR_SIZE);
-	child_repeats.resize(reader.allocator, STANDARD_VECTOR_SIZE);
-	child_defines_ptr = (uint8_t *)child_defines.ptr;
-	child_repeats_ptr = (uint8_t *)child_repeats.ptr;
-
-	child_filter.set();
-}
-
-void ListColumnReader::ApplyPendingSkips(idx_t num_values) {
-	pending_skips -= num_values;
-
-	auto define_out = unique_ptr<uint8_t[]>(new uint8_t[num_values]);
-	auto repeat_out = unique_ptr<uint8_t[]>(new uint8_t[num_values]);
-
-	idx_t remaining = num_values;
-	idx_t read = 0;
-
-	while (remaining) {
-		Vector result_out(Type());
-		parquet_filter_t filter;
-		idx_t to_read = MinValue<idx_t>(remaining, STANDARD_VECTOR_SIZE);
-		read += Read(to_read, filter, define_out.get(), repeat_out.get(), result_out);
-		remaining -= to_read;
-	}
-
-	if (read != num_values) {
-		throw InternalException("Not all skips done!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Row NumberColumn Reader
-//===--------------------------------------------------------------------===//
-RowNumberColumnReader::RowNumberColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p,
-                                             idx_t schema_idx_p, idx_t max_define_p, idx_t max_repeat_p)
-    : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p) {
-}
-
-unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
-	auto stats = NumericStats::CreateUnknown(type);
-	auto &row_groups = reader.GetFileMetadata()->row_groups;
-	D_ASSERT(row_group_idx_p < row_groups.size());
-	idx_t row_group_offset_min = 0;
-	for (idx_t i = 0; i < row_group_idx_p; i++) {
-		row_group_offset_min += row_groups[i].num_rows;
-	}
-
-	NumericStats::SetMin(stats, Value::BIGINT(UnsafeNumericCast<int64_t>(row_group_offset_min)));
-	NumericStats::SetMax(
-	    stats, Value::BIGINT(UnsafeNumericCast<int64_t>(row_group_offset_min + row_groups[row_group_idx_p].num_rows)));
-	stats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-	return stats.ToUnique();
-}
-
-void RowNumberColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
-                                           TProtocol &protocol_p) {
-	row_group_offset = 0;
-	auto &row_groups = reader.GetFileMetadata()->row_groups;
-	for (idx_t i = 0; i < row_group_idx_p; i++) {
-		row_group_offset += row_groups[i].num_rows;
-	}
-}
-
-idx_t RowNumberColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out,
-                                  data_ptr_t repeat_out, Vector &result) {
-
-	auto data_ptr = FlatVector::GetData<int64_t>(result);
-	for (idx_t i = 0; i < num_values; i++) {
-		data_ptr[i] = UnsafeNumericCast<int64_t>(row_group_offset++);
-	}
-	return num_values;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Column Reader
-//===--------------------------------------------------------------------===//
-CastColumnReader::CastColumnReader(unique_ptr<ColumnReader> child_reader_p, LogicalType target_type_p)
-    : ColumnReader(child_reader_p->Reader(), std::move(target_type_p), child_reader_p->Schema(),
-                   child_reader_p->FileIdx(), child_reader_p->MaxDefine(), child_reader_p->MaxRepeat()),
-      child_reader(std::move(child_reader_p)) {
-	vector<LogicalType> intermediate_types {child_reader->Type()};
-	intermediate_chunk.Initialize(reader.allocator, intermediate_types);
-}
-
-unique_ptr<BaseStatistics> CastColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
-	// casting stats is not supported (yet)
-	return nullptr;
-}
-
-void CastColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
-                                      TProtocol &protocol_p) {
-	child_reader->InitializeRead(row_group_idx_p, columns, protocol_p);
-}
-
-idx_t CastColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out,
-                             data_ptr_t repeat_out, Vector &result) {
-	intermediate_chunk.Reset();
-	auto &intermediate_vector = intermediate_chunk.data[0];
-
-	auto amount = child_reader->Read(num_values, filter, define_out, repeat_out, intermediate_vector);
-	if (!filter.all()) {
-		// work-around for filters: set all values that are filtered to NULL to prevent the cast from failing on
-		// uninitialized data
-		intermediate_vector.Flatten(amount);
-		auto &validity = FlatVector::Validity(intermediate_vector);
-		for (idx_t i = 0; i < amount; i++) {
-			if (!filter.test(i)) {
-				validity.SetInvalid(i);
-			}
-		}
-	}
-	string error_message;
-	bool all_succeeded = VectorOperations::DefaultTryCast(intermediate_vector, result, amount, &error_message);
-	if (!all_succeeded) {
-		string extended_error;
-		if (!reader.table_columns.empty()) {
-			// COPY .. FROM
-			extended_error = StringUtil::Format(
-			    "In file \"%s\" the column \"%s\" has type %s, but we are trying to load it into column ",
-			    reader.file_name, schema.name, intermediate_vector.GetType());
-			if (FileIdx() < reader.table_columns.size()) {
-				extended_error += "\"" + reader.table_columns[FileIdx()] + "\" ";
-			}
-			extended_error += StringUtil::Format("with type %s.", result.GetType());
-			extended_error += "\nThis means the Parquet schema does not match the schema of the table.";
-			extended_error += "\nPossible solutions:";
-			extended_error += "\n* Insert by name instead of by position using \"INSERT INTO tbl BY NAME SELECT * FROM "
-			                  "read_parquet(...)\"";
-			extended_error += "\n* Manually specify which columns to insert using \"INSERT INTO tbl SELECT ... FROM "
-			                  "read_parquet(...)\"";
-		} else {
-			// read_parquet() with multiple files
-			extended_error = StringUtil::Format(
-			    "In file \"%s\" the column \"%s\" has type %s, but we are trying to read it as type %s.",
-			    reader.file_name, schema.name, intermediate_vector.GetType(), result.GetType());
-			extended_error +=
-			    "\nThis can happen when reading multiple Parquet files. The schema information is taken from "
-			    "the first Parquet file by default. Possible solutions:\n";
-			extended_error += "* Enable the union_by_name=True option to combine the schema of all Parquet files "
-			                  "(duckdb.org/docs/data/multiple_files/combining_schemas)\n";
-			extended_error += "* Use a COPY statement to automatically derive types from an existing table.";
-		}
-		throw ConversionException(
-		    "In Parquet reader of file \"%s\": failed to cast column \"%s\" from type %s to %s: %s\n\n%s",
-		    reader.file_name, schema.name, intermediate_vector.GetType(), result.GetType(), error_message,
-		    extended_error);
-	}
-	return amount;
-}
-
-void CastColumnReader::Skip(idx_t num_values) {
-	child_reader->Skip(num_values);
-}
-
-idx_t CastColumnReader::GroupRowsAvailable() {
-	return child_reader->GroupRowsAvailable();
-}
-
-//===--------------------------------------------------------------------===//
-// Expression Column Reader
-//===--------------------------------------------------------------------===//
-ExpressionColumnReader::ExpressionColumnReader(ClientContext &context, unique_ptr<ColumnReader> child_reader_p,
-                                               unique_ptr<Expression> expr_p)
-    : ColumnReader(child_reader_p->Reader(), expr_p->return_type, child_reader_p->Schema(), child_reader_p->FileIdx(),
-                   child_reader_p->MaxDefine(), child_reader_p->MaxRepeat()),
-      child_reader(std::move(child_reader_p)), expr(std::move(expr_p)), executor(context, expr.get()) {
-	vector<LogicalType> intermediate_types {child_reader->Type()};
-	intermediate_chunk.Initialize(reader.allocator, intermediate_types);
-}
-
-unique_ptr<BaseStatistics> ExpressionColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
-	// expression stats is not supported (yet)
-	return nullptr;
-}
-
-void ExpressionColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
-                                            TProtocol &protocol_p) {
-	child_reader->InitializeRead(row_group_idx_p, columns, protocol_p);
-}
-
-idx_t ExpressionColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out,
-                                   data_ptr_t repeat_out, Vector &result) {
-	intermediate_chunk.Reset();
-	auto &intermediate_vector = intermediate_chunk.data[0];
-
-	auto amount = child_reader->Read(num_values, filter, define_out, repeat_out, intermediate_vector);
-	if (!filter.all()) {
-		// work-around for filters: set all values that are filtered to NULL to prevent the cast from failing on
-		// uninitialized data
-		intermediate_vector.Flatten(amount);
-		auto &validity = FlatVector::Validity(intermediate_vector);
-		for (idx_t i = 0; i < amount; i++) {
-			if (!filter[i]) {
-				validity.SetInvalid(i);
-			}
-		}
-	}
-	// Execute the expression
-	intermediate_chunk.SetCardinality(amount);
-	executor.ExecuteExpression(intermediate_chunk, result);
-	return amount;
-}
-
-void ExpressionColumnReader::Skip(idx_t num_values) {
-	child_reader->Skip(num_values);
-}
-
-idx_t ExpressionColumnReader::GroupRowsAvailable() {
-	return child_reader->GroupRowsAvailable();
-}
-
-//===--------------------------------------------------------------------===//
-// Struct Column Reader
-//===--------------------------------------------------------------------===//
-StructColumnReader::StructColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p,
-                                       idx_t schema_idx_p, idx_t max_define_p, idx_t max_repeat_p,
-                                       vector<unique_ptr<ColumnReader>> child_readers_p)
-    : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p),
-      child_readers(std::move(child_readers_p)) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-}
-
-ColumnReader &StructColumnReader::GetChildReader(idx_t child_idx) {
-	if (!child_readers[child_idx]) {
-		throw InternalException("StructColumnReader::GetChildReader(%d) - but this child reader is not set", child_idx);
-	}
-	return *child_readers[child_idx].get();
-}
-
-void StructColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
-                                        TProtocol &protocol_p) {
-	for (auto &child : child_readers) {
-		if (!child) {
-			continue;
-		}
-		child->InitializeRead(row_group_idx_p, columns, protocol_p);
-	}
-}
-
-idx_t StructColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out,
-                               data_ptr_t repeat_out, Vector &result) {
-	auto &struct_entries = StructVector::GetEntries(result);
-	D_ASSERT(StructType::GetChildTypes(Type()).size() == struct_entries.size());
-
-	if (pending_skips > 0) {
-		ApplyPendingSkips(pending_skips);
-	}
-
-	optional_idx read_count;
-	for (idx_t i = 0; i < child_readers.size(); i++) {
-		auto &child = child_readers[i];
-		auto &target_vector = *struct_entries[i];
-		if (!child) {
-			// if we are not scanning this vector - set it to NULL
-			target_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(target_vector, true);
-			continue;
-		}
-		auto child_num_values = child->Read(num_values, filter, define_out, repeat_out, target_vector);
-		if (!read_count.IsValid()) {
-			read_count = child_num_values;
-		} else if (read_count.GetIndex() != child_num_values) {
-			throw std::runtime_error("Struct child row count mismatch");
-		}
-	}
-	if (!read_count.IsValid()) {
-		read_count = num_values;
-	}
-	// set the validity mask for this level
-	auto &validity = FlatVector::Validity(result);
-	for (idx_t i = 0; i < read_count.GetIndex(); i++) {
-		if (define_out[i] < max_define) {
-			validity.SetInvalid(i);
-		}
-	}
-
-	return read_count.GetIndex();
-}
-
-void StructColumnReader::Skip(idx_t num_values) {
-	for (auto &child : child_readers) {
-		if (!child) {
-			continue;
-		}
-		child->Skip(num_values);
-	}
-}
-
-void StructColumnReader::RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) {
-	for (auto &child : child_readers) {
-		if (!child) {
-			continue;
-		}
-		child->RegisterPrefetch(transport, allow_merge);
-	}
-}
-
-uint64_t StructColumnReader::TotalCompressedSize() {
-	uint64_t size = 0;
-	for (auto &child : child_readers) {
-		if (!child) {
-			continue;
-		}
-		size += child->TotalCompressedSize();
-	}
-	return size;
-}
-
-static bool TypeHasExactRowCount(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-		return false;
-	case LogicalTypeId::STRUCT:
-		for (auto &kv : StructType::GetChildTypes(type)) {
-			if (TypeHasExactRowCount(kv.second)) {
-				return true;
-			}
-		}
-		return false;
-	default:
-		return true;
-	}
-}
-
-idx_t StructColumnReader::GroupRowsAvailable() {
-	for (idx_t i = 0; i < child_readers.size(); i++) {
-		if (TypeHasExactRowCount(child_readers[i]->Type())) {
-			return child_readers[i]->GroupRowsAvailable();
-		}
-	}
-	return child_readers[0]->GroupRowsAvailable();
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal Column Reader
-//===--------------------------------------------------------------------===//
-template <class DUCKDB_PHYSICAL_TYPE, bool FIXED_LENGTH>
-struct DecimalParquetValueConversion {
-
-	static DUCKDB_PHYSICAL_TYPE PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		idx_t byte_len;
-		if (FIXED_LENGTH) {
-			byte_len = (idx_t)reader.Schema().type_length; /* sure, type length needs to be a signed int */
-		} else {
-			byte_len = plain_data.read<uint32_t>();
-		}
-		plain_data.available(byte_len);
-		auto res = ParquetDecimalUtils::ReadDecimalValue<DUCKDB_PHYSICAL_TYPE>(const_data_ptr_cast(plain_data.ptr),
-		                                                                       byte_len, reader.Schema());
-
-		plain_data.inc(byte_len);
-		return res;
-	}
-
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		uint32_t decimal_len = FIXED_LENGTH ? reader.Schema().type_length : plain_data.read<uint32_t>();
-		plain_data.inc(decimal_len);
-	}
-
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-		return true;
-	}
-
-	static DUCKDB_PHYSICAL_TYPE UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		return PlainRead(plain_data, reader);
-	}
-
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		PlainSkip(plain_data, reader);
-	}
-};
-
-template <class DUCKDB_PHYSICAL_TYPE, bool FIXED_LENGTH>
-class DecimalColumnReader
-    : public TemplatedColumnReader<DUCKDB_PHYSICAL_TYPE,
-                                   DecimalParquetValueConversion<DUCKDB_PHYSICAL_TYPE, FIXED_LENGTH>> {
-	using BaseType =
-	    TemplatedColumnReader<DUCKDB_PHYSICAL_TYPE, DecimalParquetValueConversion<DUCKDB_PHYSICAL_TYPE, FIXED_LENGTH>>;
-
-public:
-	DecimalColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, // NOLINT
-	                    idx_t file_idx_p, idx_t max_define_p, idx_t max_repeat_p)
-	    : TemplatedColumnReader<DUCKDB_PHYSICAL_TYPE,
-	                            DecimalParquetValueConversion<DUCKDB_PHYSICAL_TYPE, FIXED_LENGTH>>(
-	          reader, std::move(type_p), schema_p, file_idx_p, max_define_p, max_repeat_p) {};
-
-protected:
-};
-
-template <bool FIXED_LENGTH>
-static unique_ptr<ColumnReader> CreateDecimalReaderInternal(ParquetReader &reader, const LogicalType &type_p,
-                                                            const SchemaElement &schema_p, idx_t file_idx_p,
-                                                            idx_t max_define, idx_t max_repeat) {
-	switch (type_p.InternalType()) {
-	case PhysicalType::INT16:
-		return make_uniq<DecimalColumnReader<int16_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                             max_repeat);
-	case PhysicalType::INT32:
-		return make_uniq<DecimalColumnReader<int32_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                             max_repeat);
-	case PhysicalType::INT64:
-		return make_uniq<DecimalColumnReader<int64_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                             max_repeat);
-	case PhysicalType::INT128:
-		return make_uniq<DecimalColumnReader<hugeint_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                               max_repeat);
-	case PhysicalType::DOUBLE:
-		return make_uniq<DecimalColumnReader<double, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                            max_repeat);
-	default:
-		throw InternalException("Unrecognized type for Decimal");
-	}
-}
-
-template <>
-double ParquetDecimalUtils::ReadDecimalValue(const_data_ptr_t pointer, idx_t size,
-                                             const duckdb_parquet::SchemaElement &schema_ele) {
-	double res = 0;
-	bool positive = (*pointer & 0x80) == 0;
-	for (idx_t i = 0; i < size; i += 8) {
-		auto byte_size = MinValue<idx_t>(sizeof(uint64_t), size - i);
-		uint64_t input = 0;
-		auto res_ptr = reinterpret_cast<uint8_t *>(&input);
-		for (idx_t k = 0; k < byte_size; k++) {
-			auto byte = pointer[i + k];
-			res_ptr[sizeof(uint64_t) - k - 1] = positive ? byte : byte ^ 0xFF;
-		}
-		res *= double(NumericLimits<uint64_t>::Maximum()) + 1;
-		res += static_cast<double>(input);
-	}
-	if (!positive) {
-		res += 1;
-		res /= pow(10, schema_ele.scale);
-		return -res;
-	}
-	res /= pow(10, schema_ele.scale);
-	return res;
-}
-
-unique_ptr<ColumnReader> ParquetDecimalUtils::CreateReader(ParquetReader &reader, const LogicalType &type_p,
-                                                           const SchemaElement &schema_p, idx_t file_idx_p,
-                                                           idx_t max_define, idx_t max_repeat) {
-	if (schema_p.__isset.type_length) {
-		return CreateDecimalReaderInternal<true>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	} else {
-		return CreateDecimalReaderInternal<false>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// UUID Column Reader
-//===--------------------------------------------------------------------===//
-struct UUIDValueConversion {
-	static hugeint_t ReadParquetUUID(const_data_ptr_t input) {
-		hugeint_t result;
-		result.lower = 0;
-		uint64_t unsigned_upper = 0;
-		for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-			unsigned_upper <<= 8;
-			unsigned_upper += input[i];
-		}
-		for (idx_t i = sizeof(uint64_t); i < sizeof(hugeint_t); i++) {
-			result.lower <<= 8;
-			result.lower += input[i];
-		}
-		result.upper = static_cast<int64_t>(unsigned_upper ^ (uint64_t(1) << 63));
-		return result;
-	}
-
-	static hugeint_t PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.available(sizeof(hugeint_t));
-		return UnsafePlainRead(plain_data, reader);
-	}
-
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.inc(sizeof(hugeint_t));
-	}
-
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-		return plain_data.check_available(count * sizeof(hugeint_t));
-	}
-
-	static hugeint_t UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		auto res = ReadParquetUUID(const_data_ptr_cast(plain_data.ptr));
-		plain_data.unsafe_inc(sizeof(hugeint_t));
-		return res;
-	}
-
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.unsafe_inc(sizeof(hugeint_t));
-	}
-};
-
-class UUIDColumnReader : public TemplatedColumnReader<hugeint_t, UUIDValueConversion> {
-
-public:
-	UUIDColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t file_idx_p,
-	                 idx_t max_define_p, idx_t max_repeat_p)
-	    : TemplatedColumnReader<hugeint_t, UUIDValueConversion>(reader, std::move(type_p), schema_p, file_idx_p,
-	                                                            max_define_p, max_repeat_p) {};
-};
-
-//===--------------------------------------------------------------------===//
-// Interval Column Reader
-//===--------------------------------------------------------------------===//
-struct IntervalValueConversion {
-	static constexpr const idx_t PARQUET_INTERVAL_SIZE = 12;
-
-	static interval_t ReadParquetInterval(const_data_ptr_t input) {
-		interval_t result;
-		result.months = Load<int32_t>(input);
-		result.days = Load<int32_t>(input + sizeof(uint32_t));
-		result.micros = int64_t(Load<uint32_t>(input + sizeof(uint32_t) * 2)) * 1000;
-		return result;
-	}
-
-	static interval_t PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.available(PARQUET_INTERVAL_SIZE);
-		return UnsafePlainRead(plain_data, reader);
-	}
-
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.inc(PARQUET_INTERVAL_SIZE);
-	}
-
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-		return plain_data.check_available(count * PARQUET_INTERVAL_SIZE);
-	}
-
-	static interval_t UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		auto res = ReadParquetInterval(const_data_ptr_cast(plain_data.ptr));
-		plain_data.unsafe_inc(PARQUET_INTERVAL_SIZE);
-		return res;
-	}
-
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.unsafe_inc(PARQUET_INTERVAL_SIZE);
-	}
-};
-
-class IntervalColumnReader : public TemplatedColumnReader<interval_t, IntervalValueConversion> {
-
-public:
-	IntervalColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t file_idx_p,
-	                     idx_t max_define_p, idx_t max_repeat_p)
-	    : TemplatedColumnReader<interval_t, IntervalValueConversion>(reader, std::move(type_p), schema_p, file_idx_p,
-	                                                                 max_define_p, max_repeat_p) {};
-};
-
-//===--------------------------------------------------------------------===//
-// Create Column Reader
-//===--------------------------------------------------------------------===//
-template <class T>
-unique_ptr<ColumnReader> CreateDecimalReader(ParquetReader &reader, const LogicalType &type_p,
-                                             const SchemaElement &schema_p, idx_t file_idx_p, idx_t max_define,
-                                             idx_t max_repeat) {
-	switch (type_p.InternalType()) {
-	case PhysicalType::INT16:
-		return make_uniq<TemplatedColumnReader<int16_t, TemplatedParquetValueConversion<T>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case PhysicalType::INT32:
-		return make_uniq<TemplatedColumnReader<int32_t, TemplatedParquetValueConversion<T>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case PhysicalType::INT64:
-		return make_uniq<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<T>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	default:
-		throw NotImplementedException("Unimplemented internal type for CreateDecimalReader");
-	}
-}
-
-unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const LogicalType &type_p,
-                                                    const SchemaElement &schema_p, idx_t file_idx_p, idx_t max_define,
-                                                    idx_t max_repeat) {
-	switch (type_p.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return make_uniq<BooleanColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::UTINYINT:
-		return make_uniq<TemplatedColumnReader<uint8_t, TemplatedParquetValueConversion<uint32_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::USMALLINT:
-		return make_uniq<TemplatedColumnReader<uint16_t, TemplatedParquetValueConversion<uint32_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::UINTEGER:
-		return make_uniq<TemplatedColumnReader<uint32_t, TemplatedParquetValueConversion<uint32_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::UBIGINT:
-		return make_uniq<TemplatedColumnReader<uint64_t, TemplatedParquetValueConversion<uint64_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::TINYINT:
-		return make_uniq<TemplatedColumnReader<int8_t, TemplatedParquetValueConversion<int32_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::SMALLINT:
-		return make_uniq<TemplatedColumnReader<int16_t, TemplatedParquetValueConversion<int32_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::INTEGER:
-		return make_uniq<TemplatedColumnReader<int32_t, TemplatedParquetValueConversion<int32_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::BIGINT:
-		return make_uniq<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<int64_t>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::FLOAT:
-		return make_uniq<TemplatedColumnReader<float, TemplatedParquetValueConversion<float>>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::DOUBLE:
-		switch (schema_p.type) {
-		case Type::BYTE_ARRAY:
-		case Type::FIXED_LEN_BYTE_ARRAY:
-			return ParquetDecimalUtils::CreateReader(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		default:
-			return make_uniq<TemplatedColumnReader<double, TemplatedParquetValueConversion<double>>>(
-			    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		}
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		switch (schema_p.type) {
-		case Type::INT96:
-			return make_uniq<CallbackColumnReader<Int96, timestamp_t, ImpalaTimestampToTimestamp>>(
-			    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		case Type::INT64:
-			if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIMESTAMP) {
-				if (schema_p.logicalType.TIMESTAMP.unit.__isset.MILLIS) {
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMsToTimestamp>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.MICROS) {
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMicrosToTimestamp>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.NANOS) {
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampNsToTimestamp>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				}
-			} else if (schema_p.__isset.converted_type) {
-				switch (schema_p.converted_type) {
-				case ConvertedType::TIMESTAMP_MICROS:
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMicrosToTimestamp>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				case ConvertedType::TIMESTAMP_MILLIS:
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMsToTimestamp>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				default:
-					break;
-				}
-			}
-		default:
-			break;
-		}
-		break;
-	case LogicalTypeId::TIMESTAMP_NS:
-		switch (schema_p.type) {
-		case Type::INT96:
-			return make_uniq<CallbackColumnReader<Int96, timestamp_ns_t, ImpalaTimestampToTimestampNS>>(
-			    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		case Type::INT64:
-			if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIMESTAMP) {
-				if (schema_p.logicalType.TIMESTAMP.unit.__isset.MILLIS) {
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampMsToTimestampNs>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.MICROS) {
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampUsToTimestampNs>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.NANOS) {
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampNsToTimestampNs>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				}
-			} else if (schema_p.__isset.converted_type) {
-				switch (schema_p.converted_type) {
-				case ConvertedType::TIMESTAMP_MICROS:
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampUsToTimestampNs>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				case ConvertedType::TIMESTAMP_MILLIS:
-					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampMsToTimestampNs>>(
-					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-				default:
-					break;
-				}
-			}
-		default:
-			break;
-		}
-		break;
-	case LogicalTypeId::DATE:
-		return make_uniq<CallbackColumnReader<int32_t, date_t, ParquetIntToDate>>(reader, type_p, schema_p, file_idx_p,
-		                                                                          max_define, max_repeat);
-	case LogicalTypeId::TIME:
-		if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIME) {
-			if (schema_p.logicalType.TIME.unit.__isset.MILLIS) {
-				return make_uniq<CallbackColumnReader<int32_t, dtime_t, ParquetIntToTimeMs>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			} else if (schema_p.logicalType.TIME.unit.__isset.MICROS) {
-				return make_uniq<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTime>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			} else if (schema_p.logicalType.TIME.unit.__isset.NANOS) {
-				return make_uniq<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTimeNs>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			}
-		} else if (schema_p.__isset.converted_type) {
-			switch (schema_p.converted_type) {
-			case ConvertedType::TIME_MICROS:
-				return make_uniq<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTime>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			case ConvertedType::TIME_MILLIS:
-				return make_uniq<CallbackColumnReader<int32_t, dtime_t, ParquetIntToTimeMs>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			default:
-				break;
-			}
-		}
-		throw NotImplementedException("Unsupported time encoding in Parquet file");
-	case LogicalTypeId::TIME_TZ:
-		if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIME) {
-			if (schema_p.logicalType.TIME.unit.__isset.MILLIS) {
-				return make_uniq<CallbackColumnReader<int32_t, dtime_tz_t, ParquetIntToTimeMsTZ>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			} else if (schema_p.logicalType.TIME.unit.__isset.MICROS) {
-				return make_uniq<CallbackColumnReader<int64_t, dtime_tz_t, ParquetIntToTimeTZ>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			} else if (schema_p.logicalType.TIME.unit.__isset.NANOS) {
-				return make_uniq<CallbackColumnReader<int64_t, dtime_tz_t, ParquetIntToTimeNsTZ>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			}
-		} else if (schema_p.__isset.converted_type) {
-			switch (schema_p.converted_type) {
-			case ConvertedType::TIME_MICROS:
-				return make_uniq<CallbackColumnReader<int64_t, dtime_tz_t, ParquetIntToTimeTZ>>(
-				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-			default:
-				break;
-			}
-		}
-		throw NotImplementedException("Unsupported time encoding in Parquet file");
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
-		return make_uniq<StringColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::DECIMAL:
-		// we have to figure out what kind of int we need
-		switch (schema_p.type) {
-		case Type::INT32:
-			return CreateDecimalReader<int32_t>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		case Type::INT64:
-			return CreateDecimalReader<int64_t>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		case Type::BYTE_ARRAY:
-		case Type::FIXED_LEN_BYTE_ARRAY:
-			return ParquetDecimalUtils::CreateReader(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-		default:
-			throw NotImplementedException("Unrecognized Parquet type for Decimal");
-		}
-		break;
-	case LogicalTypeId::UUID:
-		return make_uniq<UUIDColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::INTERVAL:
-		return make_uniq<IntervalColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	case LogicalTypeId::SQLNULL:
-		return make_uniq<NullColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
-	default:
-		break;
-	}
-	throw NotImplementedException(type_p.ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/column_writer.cpp b/src/duckdb/extension/parquet/column_writer.cpp
deleted file mode 100644
index 677bacf42..000000000
--- a/src/duckdb/extension/parquet/column_writer.cpp
+++ /dev/null
@@ -1,2606 +0,0 @@
-#include "column_writer.hpp"
-
-#include "duckdb.hpp"
-#include "geo_parquet.hpp"
-#include "parquet_dbp_encoder.hpp"
-#include "parquet_dlba_encoder.hpp"
-#include "parquet_rle_bp_decoder.hpp"
-#include "parquet_rle_bp_encoder.hpp"
-#include "parquet_bss_encoder.hpp"
-#include "parquet_statistics.hpp"
-#include "parquet_writer.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#endif
-
-#include "brotli/encode.h"
-#include "lz4.hpp"
-#include "miniz_wrapper.hpp"
-#include "snappy.h"
-#include "zstd.h"
-#include "zstd/common/xxhash.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-using namespace duckdb_parquet; // NOLINT
-using namespace duckdb_miniz;   // NOLINT
-
-using duckdb_parquet::CompressionCodec;
-using duckdb_parquet::ConvertedType;
-using duckdb_parquet::Encoding;
-using duckdb_parquet::FieldRepetitionType;
-using duckdb_parquet::FileMetaData;
-using duckdb_parquet::PageHeader;
-using duckdb_parquet::PageType;
-using ParquetRowGroup = duckdb_parquet::RowGroup;
-using duckdb_parquet::Type;
-
-#define PARQUET_DEFINE_VALID 65535
-
-//===--------------------------------------------------------------------===//
-// ColumnWriterStatistics
-//===--------------------------------------------------------------------===//
-ColumnWriterStatistics::~ColumnWriterStatistics() {
-}
-
-bool ColumnWriterStatistics::HasStats() {
-	return false;
-}
-
-string ColumnWriterStatistics::GetMin() {
-	return string();
-}
-
-string ColumnWriterStatistics::GetMax() {
-	return string();
-}
-
-string ColumnWriterStatistics::GetMinValue() {
-	return string();
-}
-
-string ColumnWriterStatistics::GetMaxValue() {
-	return string();
-}
-
-//===--------------------------------------------------------------------===//
-// RleBpEncoder
-//===--------------------------------------------------------------------===//
-RleBpEncoder::RleBpEncoder(uint32_t bit_width)
-    : byte_width((bit_width + 7) / 8), byte_count(idx_t(-1)), run_count(idx_t(-1)) {
-}
-
-// we always RLE everything (for now)
-void RleBpEncoder::BeginPrepare(uint32_t first_value) {
-	byte_count = 0;
-	run_count = 1;
-	current_run_count = 1;
-	last_value = first_value;
-}
-
-void RleBpEncoder::FinishRun() {
-	// last value, or value has changed
-	// write out the current run
-	byte_count += ParquetDecodeUtils::GetVarintSize(current_run_count << 1) + byte_width;
-	current_run_count = 1;
-	run_count++;
-}
-
-void RleBpEncoder::PrepareValue(uint32_t value) {
-	if (value != last_value) {
-		FinishRun();
-		last_value = value;
-	} else {
-		current_run_count++;
-	}
-}
-
-void RleBpEncoder::FinishPrepare() {
-	FinishRun();
-}
-
-idx_t RleBpEncoder::GetByteCount() {
-	D_ASSERT(byte_count != idx_t(-1));
-	return byte_count;
-}
-
-void RleBpEncoder::BeginWrite(WriteStream &writer, uint32_t first_value) {
-	// start the RLE runs
-	last_value = first_value;
-	current_run_count = 1;
-}
-
-void RleBpEncoder::WriteRun(WriteStream &writer) {
-	// write the header of the run
-	ParquetDecodeUtils::VarintEncode(current_run_count << 1, writer);
-	// now write the value
-	D_ASSERT(last_value >> (byte_width * 8) == 0);
-	switch (byte_width) {
-	case 1:
-		writer.Write<uint8_t>(last_value);
-		break;
-	case 2:
-		writer.Write<uint16_t>(last_value);
-		break;
-	case 3:
-		writer.Write<uint8_t>(last_value & 0xFF);
-		writer.Write<uint8_t>((last_value >> 8) & 0xFF);
-		writer.Write<uint8_t>((last_value >> 16) & 0xFF);
-		break;
-	case 4:
-		writer.Write<uint32_t>(last_value);
-		break;
-	default:
-		throw InternalException("unsupported byte width for RLE encoding");
-	}
-	current_run_count = 1;
-}
-
-void RleBpEncoder::WriteValue(WriteStream &writer, uint32_t value) {
-	if (value != last_value) {
-		WriteRun(writer);
-		last_value = value;
-	} else {
-		current_run_count++;
-	}
-}
-
-void RleBpEncoder::FinishWrite(WriteStream &writer) {
-	WriteRun(writer);
-}
-
-//===--------------------------------------------------------------------===//
-// ColumnWriter
-//===--------------------------------------------------------------------===//
-ColumnWriter::ColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, idx_t max_repeat,
-                           idx_t max_define, bool can_have_nulls)
-    : writer(writer), schema_idx(schema_idx), schema_path(std::move(schema_path_p)), max_repeat(max_repeat),
-      max_define(max_define), can_have_nulls(can_have_nulls) {
-}
-ColumnWriter::~ColumnWriter() {
-}
-
-ColumnWriterState::~ColumnWriterState() {
-}
-
-void ColumnWriter::CompressPage(MemoryStream &temp_writer, size_t &compressed_size, data_ptr_t &compressed_data,
-                                unique_ptr<data_t[]> &compressed_buf) {
-	switch (writer.GetCodec()) {
-	case CompressionCodec::UNCOMPRESSED:
-		compressed_size = temp_writer.GetPosition();
-		compressed_data = temp_writer.GetData();
-		break;
-
-	case CompressionCodec::SNAPPY: {
-		compressed_size = duckdb_snappy::MaxCompressedLength(temp_writer.GetPosition());
-		compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-		duckdb_snappy::RawCompress(const_char_ptr_cast(temp_writer.GetData()), temp_writer.GetPosition(),
-		                           char_ptr_cast(compressed_buf.get()), &compressed_size);
-		compressed_data = compressed_buf.get();
-		D_ASSERT(compressed_size <= duckdb_snappy::MaxCompressedLength(temp_writer.GetPosition()));
-		break;
-	}
-	case CompressionCodec::LZ4_RAW: {
-		compressed_size = duckdb_lz4::LZ4_compressBound(UnsafeNumericCast<int32_t>(temp_writer.GetPosition()));
-		compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-		compressed_size = duckdb_lz4::LZ4_compress_default(
-		    const_char_ptr_cast(temp_writer.GetData()), char_ptr_cast(compressed_buf.get()),
-		    UnsafeNumericCast<int32_t>(temp_writer.GetPosition()), UnsafeNumericCast<int32_t>(compressed_size));
-		compressed_data = compressed_buf.get();
-		break;
-	}
-	case CompressionCodec::GZIP: {
-		MiniZStream s;
-		compressed_size = s.MaxCompressedLength(temp_writer.GetPosition());
-		compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-		s.Compress(const_char_ptr_cast(temp_writer.GetData()), temp_writer.GetPosition(),
-		           char_ptr_cast(compressed_buf.get()), &compressed_size);
-		compressed_data = compressed_buf.get();
-		break;
-	}
-	case CompressionCodec::ZSTD: {
-		compressed_size = duckdb_zstd::ZSTD_compressBound(temp_writer.GetPosition());
-		compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-		compressed_size = duckdb_zstd::ZSTD_compress((void *)compressed_buf.get(), compressed_size,
-		                                             (const void *)temp_writer.GetData(), temp_writer.GetPosition(),
-		                                             UnsafeNumericCast<int32_t>(writer.CompressionLevel()));
-		compressed_data = compressed_buf.get();
-		break;
-	}
-	case CompressionCodec::BROTLI: {
-
-		compressed_size = duckdb_brotli::BrotliEncoderMaxCompressedSize(temp_writer.GetPosition());
-		compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-
-		duckdb_brotli::BrotliEncoderCompress(BROTLI_DEFAULT_QUALITY, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE,
-		                                     temp_writer.GetPosition(), temp_writer.GetData(), &compressed_size,
-		                                     compressed_buf.get());
-		compressed_data = compressed_buf.get();
-
-		break;
-	}
-	default:
-		throw InternalException("Unsupported codec for Parquet Writer");
-	}
-
-	if (compressed_size > idx_t(NumericLimits<int32_t>::Maximum())) {
-		throw InternalException("Parquet writer: %d compressed page size out of range for type integer",
-		                        temp_writer.GetPosition());
-	}
-}
-
-void ColumnWriter::HandleRepeatLevels(ColumnWriterState &state, ColumnWriterState *parent, idx_t count,
-                                      idx_t max_repeat) const {
-	if (!parent) {
-		// no repeat levels without a parent node
-		return;
-	}
-	while (state.repetition_levels.size() < parent->repetition_levels.size()) {
-		state.repetition_levels.push_back(parent->repetition_levels[state.repetition_levels.size()]);
-	}
-}
-
-void ColumnWriter::HandleDefineLevels(ColumnWriterState &state, ColumnWriterState *parent, const ValidityMask &validity,
-                                      const idx_t count, const uint16_t define_value, const uint16_t null_value) const {
-	if (parent) {
-		// parent node: inherit definition level from the parent
-		idx_t vector_index = 0;
-		while (state.definition_levels.size() < parent->definition_levels.size()) {
-			idx_t current_index = state.definition_levels.size();
-			if (parent->definition_levels[current_index] != PARQUET_DEFINE_VALID) {
-				state.definition_levels.push_back(parent->definition_levels[current_index]);
-			} else if (validity.RowIsValid(vector_index)) {
-				state.definition_levels.push_back(define_value);
-			} else {
-				if (!can_have_nulls) {
-					throw IOException("Parquet writer: map key column is not allowed to contain NULL values");
-				}
-				state.null_count++;
-				state.definition_levels.push_back(null_value);
-			}
-			if (parent->is_empty.empty() || !parent->is_empty[current_index]) {
-				vector_index++;
-			}
-		}
-	} else {
-		// no parent: set definition levels only from this validity mask
-		for (idx_t i = 0; i < count; i++) {
-			const auto is_null = !validity.RowIsValid(i);
-			state.definition_levels.emplace_back(is_null ? null_value : define_value);
-			state.null_count += is_null;
-		}
-		if (!can_have_nulls && state.null_count != 0) {
-			throw IOException("Parquet writer: map key column is not allowed to contain NULL values");
-		}
-	}
-}
-
-class ColumnWriterPageState {
-public:
-	virtual ~ColumnWriterPageState() {
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct PageInformation {
-	idx_t offset = 0;
-	idx_t row_count = 0;
-	idx_t empty_count = 0;
-	idx_t estimated_page_size = 0;
-};
-
-struct PageWriteInformation {
-	PageHeader page_header;
-	unique_ptr<MemoryStream> temp_writer;
-	unique_ptr<ColumnWriterPageState> page_state;
-	idx_t write_page_idx = 0;
-	idx_t write_count = 0;
-	idx_t max_write_count = 0;
-	size_t compressed_size;
-	data_ptr_t compressed_data;
-	unique_ptr<data_t[]> compressed_buf;
-};
-
-class BasicColumnWriterState : public ColumnWriterState {
-public:
-	BasicColumnWriterState(duckdb_parquet::RowGroup &row_group, idx_t col_idx)
-	    : row_group(row_group), col_idx(col_idx) {
-		page_info.emplace_back();
-	}
-	~BasicColumnWriterState() override = default;
-
-	duckdb_parquet::RowGroup &row_group;
-	idx_t col_idx;
-	vector<PageInformation> page_info;
-	vector<PageWriteInformation> write_info;
-	unique_ptr<ColumnWriterStatistics> stats_state;
-	idx_t current_page = 0;
-
-	unique_ptr<ParquetBloomFilter> bloom_filter;
-};
-
-//===--------------------------------------------------------------------===//
-// BasicColumnWriter
-// A base class for writing all non-compound types (ex. numerics, strings)
-//===--------------------------------------------------------------------===//
-class BasicColumnWriter : public ColumnWriter {
-public:
-	BasicColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path, idx_t max_repeat,
-	                  idx_t max_define, bool can_have_nulls)
-	    : ColumnWriter(writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls) {
-	}
-
-	~BasicColumnWriter() override = default;
-
-	//! We limit the uncompressed page size to 100MB
-	//! The max size in Parquet is 2GB, but we choose a more conservative limit
-	static constexpr const idx_t MAX_UNCOMPRESSED_PAGE_SIZE = 100000000;
-	//! Dictionary pages must be below 2GB. Unlike data pages, there's only one dictionary page.
-	//! For this reason we go with a much higher, but still a conservative upper bound of 1GB;
-	static constexpr const idx_t MAX_UNCOMPRESSED_DICT_PAGE_SIZE = 1e9;
-	//! If the dictionary has this many entries, we stop creating the dictionary
-	static constexpr const idx_t DICTIONARY_ANALYZE_THRESHOLD = 1e4;
-	//! The maximum size a key entry in an RLE page takes
-	static constexpr const idx_t MAX_DICTIONARY_KEY_SIZE = sizeof(uint32_t);
-	//! The size of encoding the string length
-	static constexpr const idx_t STRING_LENGTH_SIZE = sizeof(uint32_t);
-
-public:
-	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-	void BeginWrite(ColumnWriterState &state) override;
-	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;
-	void FinalizeWrite(ColumnWriterState &state) override;
-
-protected:
-	static void WriteLevels(WriteStream &temp_writer, const unsafe_vector<uint16_t> &levels, idx_t max_value,
-	                        idx_t start_offset, idx_t count);
-
-	virtual duckdb_parquet::Encoding::type GetEncoding(BasicColumnWriterState &state);
-
-	void NextPage(BasicColumnWriterState &state);
-	void FlushPage(BasicColumnWriterState &state);
-
-	//! Initializes the state used to track statistics during writing. Only used for scalar types.
-	virtual unique_ptr<ColumnWriterStatistics> InitializeStatsState();
-
-	//! Initialize the writer for a specific page. Only used for scalar types.
-	virtual unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state);
-
-	//! Flushes the writer for a specific page. Only used for scalar types.
-	virtual void FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state);
-
-	//! Retrieves the row size of a vector at the specified location. Only used for scalar types.
-	virtual idx_t GetRowSize(const Vector &vector, const idx_t index, const BasicColumnWriterState &state) const;
-	//! Writes a (subset of a) vector to the specified serializer. Only used for scalar types.
-	virtual void WriteVector(WriteStream &temp_writer, ColumnWriterStatistics *stats, ColumnWriterPageState *page_state,
-	                         Vector &vector, idx_t chunk_start, idx_t chunk_end) = 0;
-
-	virtual bool HasDictionary(BasicColumnWriterState &state_p) {
-		return false;
-	}
-	//! The number of elements in the dictionary
-	virtual idx_t DictionarySize(BasicColumnWriterState &state_p);
-	void WriteDictionary(BasicColumnWriterState &state, unique_ptr<MemoryStream> temp_writer, idx_t row_count);
-	virtual void FlushDictionary(BasicColumnWriterState &state, ColumnWriterStatistics *stats);
-
-	void SetParquetStatistics(BasicColumnWriterState &state, duckdb_parquet::ColumnChunk &column);
-	void RegisterToRowGroup(duckdb_parquet::RowGroup &row_group);
-};
-
-unique_ptr<ColumnWriterState> BasicColumnWriter::InitializeWriteState(duckdb_parquet::RowGroup &row_group) {
-	auto result = make_uniq<BasicColumnWriterState>(row_group, row_group.columns.size());
-	RegisterToRowGroup(row_group);
-	return std::move(result);
-}
-
-void BasicColumnWriter::RegisterToRowGroup(duckdb_parquet::RowGroup &row_group) {
-	duckdb_parquet::ColumnChunk column_chunk;
-	column_chunk.__isset.meta_data = true;
-	column_chunk.meta_data.codec = writer.GetCodec();
-	column_chunk.meta_data.path_in_schema = schema_path;
-	column_chunk.meta_data.num_values = 0;
-	column_chunk.meta_data.type = writer.GetType(schema_idx);
-	row_group.columns.push_back(std::move(column_chunk));
-}
-
-unique_ptr<ColumnWriterPageState> BasicColumnWriter::InitializePageState(BasicColumnWriterState &state) {
-	return nullptr;
-}
-
-void BasicColumnWriter::FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state) {
-}
-
-void BasicColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<BasicColumnWriterState>();
-	auto &col_chunk = state.row_group.columns[state.col_idx];
-
-	idx_t start = 0;
-	idx_t vcount = parent ? parent->definition_levels.size() - state.definition_levels.size() : count;
-	idx_t parent_index = state.definition_levels.size();
-	auto &validity = FlatVector::Validity(vector);
-	HandleRepeatLevels(state, parent, count, max_repeat);
-	HandleDefineLevels(state, parent, validity, count, max_define, max_define - 1);
-
-	idx_t vector_index = 0;
-	reference<PageInformation> page_info_ref = state.page_info.back();
-	for (idx_t i = start; i < vcount; i++) {
-		auto &page_info = page_info_ref.get();
-		page_info.row_count++;
-		col_chunk.meta_data.num_values++;
-		if (parent && !parent->is_empty.empty() && parent->is_empty[parent_index + i]) {
-			page_info.empty_count++;
-			continue;
-		}
-		if (validity.RowIsValid(vector_index)) {
-			page_info.estimated_page_size += GetRowSize(vector, vector_index, state);
-			if (page_info.estimated_page_size >= MAX_UNCOMPRESSED_PAGE_SIZE) {
-				PageInformation new_info;
-				new_info.offset = page_info.offset + page_info.row_count;
-				state.page_info.push_back(new_info);
-				page_info_ref = state.page_info.back();
-			}
-		}
-		vector_index++;
-	}
-}
-
-duckdb_parquet::Encoding::type BasicColumnWriter::GetEncoding(BasicColumnWriterState &state) {
-	return Encoding::PLAIN;
-}
-
-void BasicColumnWriter::BeginWrite(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<BasicColumnWriterState>();
-
-	// set up the page write info
-	state.stats_state = InitializeStatsState();
-	for (idx_t page_idx = 0; page_idx < state.page_info.size(); page_idx++) {
-		auto &page_info = state.page_info[page_idx];
-		if (page_info.row_count == 0) {
-			D_ASSERT(page_idx + 1 == state.page_info.size());
-			state.page_info.erase_at(page_idx);
-			break;
-		}
-		PageWriteInformation write_info;
-		// set up the header
-		auto &hdr = write_info.page_header;
-		hdr.compressed_page_size = 0;
-		hdr.uncompressed_page_size = 0;
-		hdr.type = PageType::DATA_PAGE;
-		hdr.__isset.data_page_header = true;
-
-		hdr.data_page_header.num_values = UnsafeNumericCast<int32_t>(page_info.row_count);
-		hdr.data_page_header.encoding = GetEncoding(state);
-		hdr.data_page_header.definition_level_encoding = Encoding::RLE;
-		hdr.data_page_header.repetition_level_encoding = Encoding::RLE;
-
-		write_info.temp_writer = make_uniq<MemoryStream>(
-		    MaxValue<idx_t>(NextPowerOfTwo(page_info.estimated_page_size), MemoryStream::DEFAULT_INITIAL_CAPACITY));
-		write_info.write_count = page_info.empty_count;
-		write_info.max_write_count = page_info.row_count;
-		write_info.page_state = InitializePageState(state);
-
-		write_info.compressed_size = 0;
-		write_info.compressed_data = nullptr;
-
-		state.write_info.push_back(std::move(write_info));
-	}
-
-	// start writing the first page
-	NextPage(state);
-}
-
-void BasicColumnWriter::WriteLevels(WriteStream &temp_writer, const unsafe_vector<uint16_t> &levels, idx_t max_value,
-                                    idx_t offset, idx_t count) {
-	if (levels.empty() || count == 0) {
-		return;
-	}
-
-	// write the levels using the RLE-BP encoding
-	auto bit_width = RleBpDecoder::ComputeBitWidth((max_value));
-	RleBpEncoder rle_encoder(bit_width);
-
-	rle_encoder.BeginPrepare(levels[offset]);
-	for (idx_t i = offset + 1; i < offset + count; i++) {
-		rle_encoder.PrepareValue(levels[i]);
-	}
-	rle_encoder.FinishPrepare();
-
-	// start off by writing the byte count as a uint32_t
-	temp_writer.Write<uint32_t>(rle_encoder.GetByteCount());
-	rle_encoder.BeginWrite(temp_writer, levels[offset]);
-	for (idx_t i = offset + 1; i < offset + count; i++) {
-		rle_encoder.WriteValue(temp_writer, levels[i]);
-	}
-	rle_encoder.FinishWrite(temp_writer);
-}
-
-void BasicColumnWriter::NextPage(BasicColumnWriterState &state) {
-	if (state.current_page > 0) {
-		// need to flush the current page
-		FlushPage(state);
-	}
-	if (state.current_page >= state.write_info.size()) {
-		state.current_page = state.write_info.size() + 1;
-		return;
-	}
-	auto &page_info = state.page_info[state.current_page];
-	auto &write_info = state.write_info[state.current_page];
-	state.current_page++;
-
-	auto &temp_writer = *write_info.temp_writer;
-
-	// write the repetition levels
-	WriteLevels(temp_writer, state.repetition_levels, max_repeat, page_info.offset, page_info.row_count);
-
-	// write the definition levels
-	WriteLevels(temp_writer, state.definition_levels, max_define, page_info.offset, page_info.row_count);
-}
-
-void BasicColumnWriter::FlushPage(BasicColumnWriterState &state) {
-	D_ASSERT(state.current_page > 0);
-	if (state.current_page > state.write_info.size()) {
-		return;
-	}
-
-	// compress the page info
-	auto &write_info = state.write_info[state.current_page - 1];
-	auto &temp_writer = *write_info.temp_writer;
-	auto &hdr = write_info.page_header;
-
-	FlushPageState(temp_writer, write_info.page_state.get());
-
-	// now that we have finished writing the data we know the uncompressed size
-	if (temp_writer.GetPosition() > idx_t(NumericLimits<int32_t>::Maximum())) {
-		throw InternalException("Parquet writer: %d uncompressed page size out of range for type integer",
-		                        temp_writer.GetPosition());
-	}
-	hdr.uncompressed_page_size = UnsafeNumericCast<int32_t>(temp_writer.GetPosition());
-
-	// compress the data
-	CompressPage(temp_writer, write_info.compressed_size, write_info.compressed_data, write_info.compressed_buf);
-	hdr.compressed_page_size = UnsafeNumericCast<int32_t>(write_info.compressed_size);
-	D_ASSERT(hdr.uncompressed_page_size > 0);
-	D_ASSERT(hdr.compressed_page_size > 0);
-
-	if (write_info.compressed_buf) {
-		// if the data has been compressed, we no longer need the uncompressed data
-		D_ASSERT(write_info.compressed_buf.get() == write_info.compressed_data);
-		write_info.temp_writer.reset();
-	}
-}
-
-unique_ptr<ColumnWriterStatistics> BasicColumnWriter::InitializeStatsState() {
-	return make_uniq<ColumnWriterStatistics>();
-}
-
-idx_t BasicColumnWriter::GetRowSize(const Vector &vector, const idx_t index,
-                                    const BasicColumnWriterState &state) const {
-	throw InternalException("GetRowSize unsupported for struct/list column writers");
-}
-
-void BasicColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<BasicColumnWriterState>();
-
-	idx_t remaining = count;
-	idx_t offset = 0;
-	while (remaining > 0) {
-		auto &write_info = state.write_info[state.current_page - 1];
-		if (!write_info.temp_writer) {
-			throw InternalException("Writes are not correctly aligned!?");
-		}
-		auto &temp_writer = *write_info.temp_writer;
-		idx_t write_count = MinValue<idx_t>(remaining, write_info.max_write_count - write_info.write_count);
-		D_ASSERT(write_count > 0);
-
-		WriteVector(temp_writer, state.stats_state.get(), write_info.page_state.get(), vector, offset,
-		            offset + write_count);
-
-		write_info.write_count += write_count;
-		if (write_info.write_count == write_info.max_write_count) {
-			NextPage(state);
-		}
-		offset += write_count;
-		remaining -= write_count;
-	}
-}
-
-void BasicColumnWriter::SetParquetStatistics(BasicColumnWriterState &state, duckdb_parquet::ColumnChunk &column_chunk) {
-	if (!state.stats_state) {
-		return;
-	}
-	if (max_repeat == 0) {
-		column_chunk.meta_data.statistics.null_count = NumericCast<int64_t>(state.null_count);
-		column_chunk.meta_data.statistics.__isset.null_count = true;
-		column_chunk.meta_data.__isset.statistics = true;
-	}
-	// set min/max/min_value/max_value
-	// this code is not going to win any beauty contests, but well
-	auto min = state.stats_state->GetMin();
-	if (!min.empty()) {
-		column_chunk.meta_data.statistics.min = std::move(min);
-		column_chunk.meta_data.statistics.__isset.min = true;
-		column_chunk.meta_data.__isset.statistics = true;
-	}
-	auto max = state.stats_state->GetMax();
-	if (!max.empty()) {
-		column_chunk.meta_data.statistics.max = std::move(max);
-		column_chunk.meta_data.statistics.__isset.max = true;
-		column_chunk.meta_data.__isset.statistics = true;
-	}
-	if (state.stats_state->HasStats()) {
-		column_chunk.meta_data.statistics.min_value = state.stats_state->GetMinValue();
-		column_chunk.meta_data.statistics.__isset.min_value = true;
-		column_chunk.meta_data.__isset.statistics = true;
-
-		column_chunk.meta_data.statistics.max_value = state.stats_state->GetMaxValue();
-		column_chunk.meta_data.statistics.__isset.max_value = true;
-		column_chunk.meta_data.__isset.statistics = true;
-	}
-	if (HasDictionary(state)) {
-		column_chunk.meta_data.statistics.distinct_count = UnsafeNumericCast<int64_t>(DictionarySize(state));
-		column_chunk.meta_data.statistics.__isset.distinct_count = true;
-		column_chunk.meta_data.__isset.statistics = true;
-	}
-	for (const auto &write_info : state.write_info) {
-		// only care about data page encodings, data_page_header.encoding is meaningless for dict
-		if (write_info.page_header.type != PageType::DATA_PAGE &&
-		    write_info.page_header.type != PageType::DATA_PAGE_V2) {
-			continue;
-		}
-		column_chunk.meta_data.encodings.push_back(write_info.page_header.data_page_header.encoding);
-	}
-}
-
-void BasicColumnWriter::FinalizeWrite(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<BasicColumnWriterState>();
-	auto &column_chunk = state.row_group.columns[state.col_idx];
-
-	// flush the last page (if any remains)
-	FlushPage(state);
-
-	auto &column_writer = writer.GetWriter();
-	auto start_offset = column_writer.GetTotalWritten();
-	// flush the dictionary
-	if (HasDictionary(state)) {
-		column_chunk.meta_data.statistics.distinct_count = UnsafeNumericCast<int64_t>(DictionarySize(state));
-		column_chunk.meta_data.statistics.__isset.distinct_count = true;
-		column_chunk.meta_data.dictionary_page_offset = UnsafeNumericCast<int64_t>(column_writer.GetTotalWritten());
-		column_chunk.meta_data.__isset.dictionary_page_offset = true;
-		FlushDictionary(state, state.stats_state.get());
-	}
-
-	// record the start position of the pages for this column
-	column_chunk.meta_data.data_page_offset = 0;
-	SetParquetStatistics(state, column_chunk);
-
-	// write the individual pages to disk
-	idx_t total_uncompressed_size = 0;
-	for (auto &write_info : state.write_info) {
-		// set the data page offset whenever we see the *first* data page
-		if (column_chunk.meta_data.data_page_offset == 0 && (write_info.page_header.type == PageType::DATA_PAGE ||
-		                                                     write_info.page_header.type == PageType::DATA_PAGE_V2)) {
-			column_chunk.meta_data.data_page_offset = UnsafeNumericCast<int64_t>(column_writer.GetTotalWritten());
-			;
-		}
-		D_ASSERT(write_info.page_header.uncompressed_page_size > 0);
-		auto header_start_offset = column_writer.GetTotalWritten();
-		writer.Write(write_info.page_header);
-		// total uncompressed size in the column chunk includes the header size (!)
-		total_uncompressed_size += column_writer.GetTotalWritten() - header_start_offset;
-		total_uncompressed_size += write_info.page_header.uncompressed_page_size;
-		writer.WriteData(write_info.compressed_data, write_info.compressed_size);
-	}
-	column_chunk.meta_data.total_compressed_size =
-	    UnsafeNumericCast<int64_t>(column_writer.GetTotalWritten() - start_offset);
-	column_chunk.meta_data.total_uncompressed_size = UnsafeNumericCast<int64_t>(total_uncompressed_size);
-
-	if (state.bloom_filter) {
-		writer.BufferBloomFilter(state.col_idx, std::move(state.bloom_filter));
-	}
-	// which row group is this?
-}
-
-void BasicColumnWriter::FlushDictionary(BasicColumnWriterState &state, ColumnWriterStatistics *stats) {
-	throw InternalException("This page does not have a dictionary");
-}
-
-idx_t BasicColumnWriter::DictionarySize(BasicColumnWriterState &state) {
-	throw InternalException("This page does not have a dictionary");
-}
-
-void BasicColumnWriter::WriteDictionary(BasicColumnWriterState &state, unique_ptr<MemoryStream> temp_writer,
-                                        idx_t row_count) {
-	D_ASSERT(temp_writer);
-	D_ASSERT(temp_writer->GetPosition() > 0);
-
-	// write the dictionary page header
-	PageWriteInformation write_info;
-	// set up the header
-	auto &hdr = write_info.page_header;
-	hdr.uncompressed_page_size = UnsafeNumericCast<int32_t>(temp_writer->GetPosition());
-	hdr.type = PageType::DICTIONARY_PAGE;
-	hdr.__isset.dictionary_page_header = true;
-
-	hdr.dictionary_page_header.encoding = Encoding::PLAIN;
-	hdr.dictionary_page_header.is_sorted = false;
-	hdr.dictionary_page_header.num_values = UnsafeNumericCast<int32_t>(row_count);
-
-	write_info.temp_writer = std::move(temp_writer);
-	write_info.write_count = 0;
-	write_info.max_write_count = 0;
-
-	// compress the contents of the dictionary page
-	CompressPage(*write_info.temp_writer, write_info.compressed_size, write_info.compressed_data,
-	             write_info.compressed_buf);
-	hdr.compressed_page_size = UnsafeNumericCast<int32_t>(write_info.compressed_size);
-
-	// insert the dictionary page as the first page to write for this column
-	state.write_info.insert(state.write_info.begin(), std::move(write_info));
-}
-
-//===--------------------------------------------------------------------===//
-// Standard Column Writer
-//===--------------------------------------------------------------------===//
-template <class SRC, class T, class OP>
-class NumericStatisticsState : public ColumnWriterStatistics {
-public:
-	NumericStatisticsState() : min(NumericLimits<T>::Maximum()), max(NumericLimits<T>::Minimum()) {
-	}
-
-	T min;
-	T max;
-
-public:
-	bool HasStats() override {
-		return min <= max;
-	}
-
-	string GetMin() override {
-		return NumericLimits<SRC>::IsSigned() ? GetMinValue() : string();
-	}
-	string GetMax() override {
-		return NumericLimits<SRC>::IsSigned() ? GetMaxValue() : string();
-	}
-	string GetMinValue() override {
-		return HasStats() ? string(char_ptr_cast(&min), sizeof(T)) : string();
-	}
-	string GetMaxValue() override {
-		return HasStats() ? string(char_ptr_cast(&max), sizeof(T)) : string();
-	}
-};
-
-struct BaseParquetOperator {
-
-	template <class SRC, class TGT>
-	static void WriteToStream(const TGT &input, WriteStream &ser) {
-		ser.WriteData(const_data_ptr_cast(&input), sizeof(TGT));
-	}
-
-	template <class SRC, class TGT>
-	static uint64_t XXHash64(const TGT &target_value) {
-		return duckdb_zstd::XXH64(&target_value, sizeof(target_value), 0);
-	}
-
-	template <class SRC, class TGT>
-	static unique_ptr<ColumnWriterStatistics> InitializeStats() {
-		return nullptr;
-	}
-
-	template <class SRC, class TGT>
-	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
-	}
-};
-
-struct ParquetCastOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return TGT(input);
-	}
-	template <class SRC, class TGT>
-	static unique_ptr<ColumnWriterStatistics> InitializeStats() {
-		return make_uniq<NumericStatisticsState<SRC, TGT, BaseParquetOperator>>();
-	}
-
-	template <class SRC, class TGT>
-	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
-		auto &numeric_stats = (NumericStatisticsState<SRC, TGT, BaseParquetOperator> &)*stats;
-		if (LessThan::Operation(target_value, numeric_stats.min)) {
-			numeric_stats.min = target_value;
-		}
-		if (GreaterThan::Operation(target_value, numeric_stats.max)) {
-			numeric_stats.max = target_value;
-		}
-	}
-};
-
-struct ParquetTimestampNSOperator : public ParquetCastOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return TGT(input);
-	}
-};
-
-struct ParquetTimestampSOperator : public ParquetCastOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return Timestamp::FromEpochSecondsPossiblyInfinite(input).value;
-	}
-};
-
-class StringStatisticsState : public ColumnWriterStatistics {
-	static constexpr const idx_t MAX_STRING_STATISTICS_SIZE = 10000;
-
-public:
-	StringStatisticsState() : has_stats(false), values_too_big(false), min(), max() {
-	}
-
-	bool has_stats;
-	bool values_too_big;
-	string min;
-	string max;
-
-public:
-	bool HasStats() override {
-		return has_stats;
-	}
-
-	void Update(const string_t &val) {
-		if (values_too_big) {
-			return;
-		}
-		auto str_len = val.GetSize();
-		if (str_len > MAX_STRING_STATISTICS_SIZE) {
-			// we avoid gathering stats when individual string values are too large
-			// this is because the statistics are copied into the Parquet file meta data in uncompressed format
-			// ideally we avoid placing several mega or giga-byte long strings there
-			// we put a threshold of 10KB, if we see strings that exceed this threshold we avoid gathering stats
-			values_too_big = true;
-			has_stats = false;
-			min = string();
-			max = string();
-			return;
-		}
-		if (!has_stats || LessThan::Operation(val, string_t(min))) {
-			min = val.GetString();
-		}
-		if (!has_stats || GreaterThan::Operation(val, string_t(max))) {
-			max = val.GetString();
-		}
-		has_stats = true;
-	}
-
-	string GetMin() override {
-		return GetMinValue();
-	}
-	string GetMax() override {
-		return GetMaxValue();
-	}
-	string GetMinValue() override {
-		return HasStats() ? min : string();
-	}
-	string GetMaxValue() override {
-		return HasStats() ? max : string();
-	}
-};
-
-struct ParquetStringOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return input;
-	}
-
-	template <class SRC, class TGT>
-	static unique_ptr<ColumnWriterStatistics> InitializeStats() {
-		return make_uniq<StringStatisticsState>();
-	}
-
-	template <class SRC, class TGT>
-	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
-		auto &string_stats = stats->Cast<StringStatisticsState>();
-		string_stats.Update(target_value);
-	}
-
-	template <class SRC, class TGT>
-	static void WriteToStream(const TGT &target_value, WriteStream &ser) {
-		ser.Write<uint32_t>(target_value.GetSize());
-		ser.WriteData(const_data_ptr_cast(target_value.GetData()), target_value.GetSize());
-	}
-
-	template <class SRC, class TGT>
-	static uint64_t XXHash64(const TGT &target_value) {
-		return duckdb_zstd::XXH64(target_value.GetData(), target_value.GetSize(), 0);
-	}
-};
-
-struct ParquetIntervalTargetType {
-	static constexpr const idx_t PARQUET_INTERVAL_SIZE = 12;
-	data_t bytes[PARQUET_INTERVAL_SIZE];
-};
-
-struct ParquetIntervalOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-
-		if (input.days < 0 || input.months < 0 || input.micros < 0) {
-			throw IOException("Parquet files do not support negative intervals");
-		}
-		TGT result;
-		Store<uint32_t>(input.months, result.bytes);
-		Store<uint32_t>(input.days, result.bytes + sizeof(uint32_t));
-		Store<uint32_t>(input.micros / 1000, result.bytes + sizeof(uint32_t) * 2);
-		return result;
-	}
-
-	template <class SRC, class TGT>
-	static void WriteToStream(const TGT &target_value, WriteStream &ser) {
-		ser.WriteData(target_value.bytes, ParquetIntervalTargetType::PARQUET_INTERVAL_SIZE);
-	}
-
-	template <class SRC, class TGT>
-	static uint64_t XXHash64(const TGT &target_value) {
-		return duckdb_zstd::XXH64(target_value.bytes, ParquetIntervalTargetType::PARQUET_INTERVAL_SIZE, 0);
-	}
-};
-
-struct ParquetUUIDTargetType {
-	static constexpr const idx_t PARQUET_UUID_SIZE = 16;
-	data_t bytes[PARQUET_UUID_SIZE];
-};
-
-struct ParquetUUIDOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		TGT result;
-		uint64_t high_bytes = input.upper ^ (int64_t(1) << 63);
-		uint64_t low_bytes = input.lower;
-		for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-			auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
-			result.bytes[i] = (high_bytes >> shift_count) & 0xFF;
-		}
-		for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-			auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
-			result.bytes[sizeof(uint64_t) + i] = (low_bytes >> shift_count) & 0xFF;
-		}
-		return result;
-	}
-
-	template <class SRC, class TGT>
-	static void WriteToStream(const TGT &target_value, WriteStream &ser) {
-		ser.WriteData(target_value.bytes, ParquetUUIDTargetType::PARQUET_UUID_SIZE);
-	}
-
-	template <class SRC, class TGT>
-	static uint64_t XXHash64(const TGT &target_value) {
-		return duckdb_zstd::XXH64(target_value.bytes, ParquetUUIDTargetType::PARQUET_UUID_SIZE, 0);
-	}
-};
-
-struct ParquetTimeTZOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return input.time().micros;
-	}
-};
-
-struct ParquetHugeintOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return Hugeint::Cast<double>(input);
-	}
-
-	template <class SRC, class TGT>
-	static unique_ptr<ColumnWriterStatistics> InitializeStats() {
-		return make_uniq<ColumnWriterStatistics>();
-	}
-
-	template <class SRC, class TGT>
-	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
-	}
-};
-
-struct ParquetUhugeintOperator : public BaseParquetOperator {
-	template <class SRC, class TGT>
-	static TGT Operation(SRC input) {
-		return Uhugeint::Cast<double>(input);
-	}
-
-	template <class SRC, class TGT>
-	static unique_ptr<ColumnWriterStatistics> InitializeStats() {
-		return make_uniq<ColumnWriterStatistics>();
-	}
-
-	template <class SRC, class TGT>
-	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
-	}
-};
-
-template <class SRC, class TGT, class OP = ParquetCastOperator>
-static void TemplatedWritePlain(Vector &col, ColumnWriterStatistics *stats, const idx_t chunk_start,
-                                const idx_t chunk_end, const ValidityMask &mask, WriteStream &ser) {
-
-	const auto *ptr = FlatVector::GetData<SRC>(col);
-	for (idx_t r = chunk_start; r < chunk_end; r++) {
-		if (!mask.RowIsValid(r)) {
-			continue;
-		}
-		TGT target_value = OP::template Operation<SRC, TGT>(ptr[r]);
-		OP::template HandleStats<SRC, TGT>(stats, target_value);
-		OP::template WriteToStream<SRC, TGT>(target_value, ser);
-	}
-}
-
-template <class T>
-class StandardColumnWriterState : public BasicColumnWriterState {
-public:
-	StandardColumnWriterState(duckdb_parquet::RowGroup &row_group, idx_t col_idx)
-	    : BasicColumnWriterState(row_group, col_idx) {
-	}
-	~StandardColumnWriterState() override = default;
-
-	// analysis state for integer values for DELTA_BINARY_PACKED/DELTA_LENGTH_BYTE_ARRAY
-	idx_t total_value_count = 0;
-	idx_t total_string_size = 0;
-
-	unordered_map<T, uint32_t> dictionary;
-	duckdb_parquet::Encoding::type encoding;
-};
-
-template <class SRC, class TGT>
-class StandardWriterPageState : public ColumnWriterPageState {
-public:
-	explicit StandardWriterPageState(const idx_t total_value_count, const idx_t total_string_size,
-	                                 Encoding::type encoding_p, const unordered_map<SRC, uint32_t> &dictionary_p)
-	    : encoding(encoding_p), dbp_initialized(false), dbp_encoder(total_value_count), dlba_initialized(false),
-	      dlba_encoder(total_value_count, total_string_size), bss_encoder(total_value_count, sizeof(TGT)),
-	      dictionary(dictionary_p), dict_written_value(false),
-	      dict_bit_width(RleBpDecoder::ComputeBitWidth(dictionary.size())), dict_encoder(dict_bit_width) {
-	}
-	duckdb_parquet::Encoding::type encoding;
-
-	bool dbp_initialized;
-	DbpEncoder dbp_encoder;
-
-	bool dlba_initialized;
-	DlbaEncoder dlba_encoder;
-
-	BssEncoder bss_encoder;
-
-	const unordered_map<SRC, uint32_t> &dictionary;
-	bool dict_written_value;
-	uint32_t dict_bit_width;
-	RleBpEncoder dict_encoder;
-};
-
-namespace dbp_encoder {
-
-template <class T>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const T &first_value) {
-	throw InternalException("Can't write type to DELTA_BINARY_PACKED column");
-}
-
-template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const int64_t &first_value) {
-	encoder.BeginWrite(writer, first_value);
-}
-
-template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const int32_t &first_value) {
-	BeginWrite(encoder, writer, UnsafeNumericCast<int64_t>(first_value));
-}
-
-template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const uint64_t &first_value) {
-	encoder.BeginWrite(writer, UnsafeNumericCast<int64_t>(first_value));
-}
-
-template <>
-void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const uint32_t &first_value) {
-	BeginWrite(encoder, writer, UnsafeNumericCast<int64_t>(first_value));
-}
-
-template <class T>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const T &value) {
-	throw InternalException("Can't write type to DELTA_BINARY_PACKED column");
-}
-
-template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const int64_t &value) {
-	encoder.WriteValue(writer, value);
-}
-
-template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const int32_t &value) {
-	WriteValue(encoder, writer, UnsafeNumericCast<int64_t>(value));
-}
-
-template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const uint64_t &value) {
-	encoder.WriteValue(writer, UnsafeNumericCast<int64_t>(value));
-}
-
-template <>
-void WriteValue(DbpEncoder &encoder, WriteStream &writer, const uint32_t &value) {
-	WriteValue(encoder, writer, UnsafeNumericCast<int64_t>(value));
-}
-
-} // namespace dbp_encoder
-
-namespace dlba_encoder {
-
-template <class T>
-void BeginWrite(DlbaEncoder &encoder, WriteStream &writer, const T &first_value) {
-	throw InternalException("Can't write type to DELTA_LENGTH_BYTE_ARRAY column");
-}
-
-template <>
-void BeginWrite(DlbaEncoder &encoder, WriteStream &writer, const string_t &first_value) {
-	encoder.BeginWrite(writer, first_value);
-}
-
-template <class T>
-void WriteValue(DlbaEncoder &encoder, WriteStream &writer, const T &value) {
-	throw InternalException("Can't write type to DELTA_LENGTH_BYTE_ARRAY column");
-}
-
-template <>
-void WriteValue(DlbaEncoder &encoder, WriteStream &writer, const string_t &value) {
-	encoder.WriteValue(writer, value);
-}
-
-// helpers to get size from strings
-template <class SRC>
-static constexpr idx_t GetDlbaStringSize(const SRC &src_value) {
-	return 0;
-}
-
-template <>
-idx_t GetDlbaStringSize(const string_t &src_value) {
-	return src_value.GetSize();
-}
-
-} // namespace dlba_encoder
-
-namespace bss_encoder {
-
-template <class T>
-void WriteValue(BssEncoder &encoder, const T &value) {
-	throw InternalException("Can't write type to BYTE_STREAM_SPLIT column");
-}
-
-template <>
-void WriteValue(BssEncoder &encoder, const float &value) {
-	encoder.WriteValue(value);
-}
-
-template <>
-void WriteValue(BssEncoder &encoder, const double &value) {
-	encoder.WriteValue(value);
-}
-
-} // namespace bss_encoder
-
-template <class SRC, class TGT, class OP = ParquetCastOperator>
-class StandardColumnWriter : public BasicColumnWriter {
-public:
-	StandardColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, // NOLINT
-	                     idx_t max_repeat, idx_t max_define, bool can_have_nulls)
-	    : BasicColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls) {
-	}
-	~StandardColumnWriter() override = default;
-
-public:
-	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override {
-		auto result = make_uniq<StandardColumnWriterState<SRC>>(row_group, row_group.columns.size());
-		result->encoding = Encoding::RLE_DICTIONARY;
-		RegisterToRowGroup(row_group);
-		return std::move(result);
-	}
-
-	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state_p) override {
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-
-		auto result = make_uniq<StandardWriterPageState<SRC, TGT>>(state.total_value_count, state.total_string_size,
-		                                                           state.encoding, state.dictionary);
-		return std::move(result);
-	}
-
-	void FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state_p) override {
-		auto &page_state = state_p->Cast<StandardWriterPageState<SRC, TGT>>();
-		switch (page_state.encoding) {
-		case Encoding::DELTA_BINARY_PACKED:
-			if (!page_state.dbp_initialized) {
-				dbp_encoder::BeginWrite<int64_t>(page_state.dbp_encoder, temp_writer, 0);
-			}
-			page_state.dbp_encoder.FinishWrite(temp_writer);
-			break;
-		case Encoding::RLE_DICTIONARY:
-			D_ASSERT(page_state.dict_bit_width != 0);
-			if (!page_state.dict_written_value) {
-				// all values are null
-				// just write the bit width
-				temp_writer.Write<uint8_t>(page_state.dict_bit_width);
-				return;
-			}
-			page_state.dict_encoder.FinishWrite(temp_writer);
-			break;
-		case Encoding::DELTA_LENGTH_BYTE_ARRAY:
-			if (!page_state.dlba_initialized) {
-				dlba_encoder::BeginWrite<string_t>(page_state.dlba_encoder, temp_writer, string_t(""));
-			}
-			page_state.dlba_encoder.FinishWrite(temp_writer);
-			break;
-		case Encoding::BYTE_STREAM_SPLIT:
-			page_state.bss_encoder.FinishWrite(temp_writer);
-			break;
-		case Encoding::PLAIN:
-			break;
-		default:
-			throw InternalException("Unknown encoding");
-		}
-	}
-
-	Encoding::type GetEncoding(BasicColumnWriterState &state_p) override {
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-		return state.encoding;
-	}
-
-	bool HasAnalyze() override {
-		return true;
-	}
-
-	void Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) override {
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-
-		auto data_ptr = FlatVector::GetData<SRC>(vector);
-		idx_t vector_index = 0;
-		uint32_t new_value_index = state.dictionary.size();
-
-		const bool check_parent_empty = parent && !parent->is_empty.empty();
-		const idx_t parent_index = state.definition_levels.size();
-
-		const idx_t vcount =
-		    check_parent_empty ? parent->definition_levels.size() - state.definition_levels.size() : count;
-
-		const auto &validity = FlatVector::Validity(vector);
-
-		for (idx_t i = 0; i < vcount; i++) {
-			if (check_parent_empty && parent->is_empty[parent_index + i]) {
-				continue;
-			}
-			if (validity.RowIsValid(vector_index)) {
-				const auto &src_value = data_ptr[vector_index];
-				if (state.dictionary.size() <= writer.DictionarySizeLimit()) {
-					if (state.dictionary.find(src_value) == state.dictionary.end()) {
-						state.dictionary[src_value] = new_value_index;
-						new_value_index++;
-					}
-				}
-				state.total_value_count++;
-				state.total_string_size += dlba_encoder::GetDlbaStringSize(src_value);
-			}
-			vector_index++;
-		}
-	}
-
-	void FinalizeAnalyze(ColumnWriterState &state_p) override {
-		const auto type = writer.GetType(schema_idx);
-
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-		if (state.dictionary.size() == 0 || state.dictionary.size() > writer.DictionarySizeLimit()) {
-			// If we aren't doing dictionary encoding, the following encodings are virtually always better than PLAIN
-			switch (type) {
-			case Type::type::INT32:
-			case Type::type::INT64:
-				state.encoding = Encoding::DELTA_BINARY_PACKED;
-				break;
-			case Type::type::BYTE_ARRAY:
-				state.encoding = Encoding::DELTA_LENGTH_BYTE_ARRAY;
-				break;
-			case Type::type::FLOAT:
-			case Type::type::DOUBLE:
-				state.encoding = Encoding::BYTE_STREAM_SPLIT;
-				break;
-			default:
-				state.encoding = Encoding::PLAIN;
-			}
-			state.dictionary.clear();
-		}
-	}
-
-	unique_ptr<ColumnWriterStatistics> InitializeStatsState() override {
-		return OP::template InitializeStats<SRC, TGT>();
-	}
-
-	bool HasDictionary(BasicColumnWriterState &state_p) override {
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-		return state.encoding == Encoding::RLE_DICTIONARY;
-	}
-
-	idx_t DictionarySize(BasicColumnWriterState &state_p) override {
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-		return state.dictionary.size();
-	}
-
-	void WriteVector(WriteStream &temp_writer, ColumnWriterStatistics *stats, ColumnWriterPageState *page_state_p,
-	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &page_state = page_state_p->Cast<StandardWriterPageState<SRC, TGT>>();
-
-		const auto &mask = FlatVector::Validity(input_column);
-		const auto *data_ptr = FlatVector::GetData<SRC>(input_column);
-
-		switch (page_state.encoding) {
-		case Encoding::RLE_DICTIONARY: {
-			for (idx_t r = chunk_start; r < chunk_end; r++) {
-				if (!mask.RowIsValid(r)) {
-					continue;
-				}
-				auto &src_val = data_ptr[r];
-				auto value_index = page_state.dictionary.at(src_val);
-				if (!page_state.dict_written_value) {
-					// first value
-					// write the bit-width as a one-byte entry
-					temp_writer.Write<uint8_t>(page_state.dict_bit_width);
-					// now begin writing the actual value
-					page_state.dict_encoder.BeginWrite(temp_writer, value_index);
-					page_state.dict_written_value = true;
-				} else {
-					page_state.dict_encoder.WriteValue(temp_writer, value_index);
-				}
-			}
-			break;
-		}
-		case Encoding::DELTA_BINARY_PACKED: {
-			idx_t r = chunk_start;
-			if (!page_state.dbp_initialized) {
-				// find first non-null value
-				for (; r < chunk_end; r++) {
-					if (!mask.RowIsValid(r)) {
-						continue;
-					}
-					const TGT target_value = OP::template Operation<SRC, TGT>(data_ptr[r]);
-					OP::template HandleStats<SRC, TGT>(stats, target_value);
-					dbp_encoder::BeginWrite(page_state.dbp_encoder, temp_writer, target_value);
-					page_state.dbp_initialized = true;
-					r++; // skip over
-					break;
-				}
-			}
-
-			for (; r < chunk_end; r++) {
-				if (!mask.RowIsValid(r)) {
-					continue;
-				}
-				const TGT target_value = OP::template Operation<SRC, TGT>(data_ptr[r]);
-				OP::template HandleStats<SRC, TGT>(stats, target_value);
-				dbp_encoder::WriteValue(page_state.dbp_encoder, temp_writer, target_value);
-			}
-			break;
-		}
-		case Encoding::DELTA_LENGTH_BYTE_ARRAY: {
-			idx_t r = chunk_start;
-			if (!page_state.dlba_initialized) {
-				// find first non-null value
-				for (; r < chunk_end; r++) {
-					if (!mask.RowIsValid(r)) {
-						continue;
-					}
-					const TGT target_value = OP::template Operation<SRC, TGT>(data_ptr[r]);
-					OP::template HandleStats<SRC, TGT>(stats, target_value);
-					dlba_encoder::BeginWrite(page_state.dlba_encoder, temp_writer, target_value);
-					page_state.dlba_initialized = true;
-					r++; // skip over
-					break;
-				}
-			}
-
-			for (; r < chunk_end; r++) {
-				if (!mask.RowIsValid(r)) {
-					continue;
-				}
-				const TGT target_value = OP::template Operation<SRC, TGT>(data_ptr[r]);
-				OP::template HandleStats<SRC, TGT>(stats, target_value);
-				dlba_encoder::WriteValue(page_state.dlba_encoder, temp_writer, target_value);
-			}
-			break;
-		}
-		case Encoding::BYTE_STREAM_SPLIT: {
-			for (idx_t r = chunk_start; r < chunk_end; r++) {
-				if (!mask.RowIsValid(r)) {
-					continue;
-				}
-				const TGT target_value = OP::template Operation<SRC, TGT>(data_ptr[r]);
-				OP::template HandleStats<SRC, TGT>(stats, target_value);
-				bss_encoder::WriteValue(page_state.bss_encoder, target_value);
-			}
-			break;
-		}
-		case Encoding::PLAIN: {
-			D_ASSERT(page_state.encoding == Encoding::PLAIN);
-			TemplatedWritePlain<SRC, TGT, OP>(input_column, stats, chunk_start, chunk_end, mask, temp_writer);
-			break;
-		}
-		default:
-			throw InternalException("Unknown encoding");
-		}
-	}
-
-	void FlushDictionary(BasicColumnWriterState &state_p, ColumnWriterStatistics *stats) override {
-		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-
-		D_ASSERT(state.encoding == Encoding::RLE_DICTIONARY);
-
-		// first we need to sort the values in index order
-		auto values = vector<SRC>(state.dictionary.size());
-		for (const auto &entry : state.dictionary) {
-			values[entry.second] = entry.first;
-		}
-
-		state.bloom_filter =
-		    make_uniq<ParquetBloomFilter>(state.dictionary.size(), writer.BloomFilterFalsePositiveRatio());
-
-		// first write the contents of the dictionary page to a temporary buffer
-		auto temp_writer = make_uniq<MemoryStream>(MaxValue<idx_t>(
-		    NextPowerOfTwo(state.dictionary.size() * sizeof(TGT)), MemoryStream::DEFAULT_INITIAL_CAPACITY));
-		for (idx_t r = 0; r < values.size(); r++) {
-			const TGT target_value = OP::template Operation<SRC, TGT>(values[r]);
-			// update the statistics
-			OP::template HandleStats<SRC, TGT>(stats, target_value);
-			// update the bloom filter
-			auto hash = OP::template XXHash64<SRC, TGT>(target_value);
-			state.bloom_filter->FilterInsert(hash);
-			// actually write the dictionary value
-			OP::template WriteToStream<SRC, TGT>(target_value, *temp_writer);
-		}
-		// flush the dictionary page and add it to the to-be-written pages
-		WriteDictionary(state, std::move(temp_writer), values.size());
-		// bloom filter will be queued for writing in ParquetWriter::BufferBloomFilter one level up
-	}
-
-	// TODO this now vastly over-estimates the page size
-	idx_t GetRowSize(const Vector &vector, const idx_t index, const BasicColumnWriterState &state_p) const override {
-		return sizeof(TGT);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Boolean Column Writer
-//===--------------------------------------------------------------------===//
-class BooleanStatisticsState : public ColumnWriterStatistics {
-public:
-	BooleanStatisticsState() : min(true), max(false) {
-	}
-
-	bool min;
-	bool max;
-
-public:
-	bool HasStats() override {
-		return !(min && !max);
-	}
-
-	string GetMin() override {
-		return GetMinValue();
-	}
-	string GetMax() override {
-		return GetMaxValue();
-	}
-	string GetMinValue() override {
-		return HasStats() ? string(const_char_ptr_cast(&min), sizeof(bool)) : string();
-	}
-	string GetMaxValue() override {
-		return HasStats() ? string(const_char_ptr_cast(&max), sizeof(bool)) : string();
-	}
-};
-
-class BooleanWriterPageState : public ColumnWriterPageState {
-public:
-	uint8_t byte = 0;
-	uint8_t byte_pos = 0;
-};
-
-class BooleanColumnWriter : public BasicColumnWriter {
-public:
-	BooleanColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, idx_t max_repeat,
-	                    idx_t max_define, bool can_have_nulls)
-	    : BasicColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls) {
-	}
-	~BooleanColumnWriter() override = default;
-
-public:
-	unique_ptr<ColumnWriterStatistics> InitializeStatsState() override {
-		return make_uniq<BooleanStatisticsState>();
-	}
-
-	void WriteVector(WriteStream &temp_writer, ColumnWriterStatistics *stats_p, ColumnWriterPageState *state_p,
-	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &stats = stats_p->Cast<BooleanStatisticsState>();
-		auto &state = state_p->Cast<BooleanWriterPageState>();
-		auto &mask = FlatVector::Validity(input_column);
-
-		auto *ptr = FlatVector::GetData<bool>(input_column);
-		for (idx_t r = chunk_start; r < chunk_end; r++) {
-			if (mask.RowIsValid(r)) {
-				// only encode if non-null
-				if (ptr[r]) {
-					stats.max = true;
-					state.byte |= 1 << state.byte_pos;
-				} else {
-					stats.min = false;
-				}
-				state.byte_pos++;
-
-				if (state.byte_pos == 8) {
-					temp_writer.Write<uint8_t>(state.byte);
-					state.byte = 0;
-					state.byte_pos = 0;
-				}
-			}
-		}
-	}
-
-	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state) override {
-		return make_uniq<BooleanWriterPageState>();
-	}
-
-	void FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state_p) override {
-		auto &state = state_p->Cast<BooleanWriterPageState>();
-		if (state.byte_pos > 0) {
-			temp_writer.Write<uint8_t>(state.byte);
-			state.byte = 0;
-			state.byte_pos = 0;
-		}
-	}
-
-	idx_t GetRowSize(const Vector &vector, const idx_t index, const BasicColumnWriterState &state) const override {
-		return sizeof(bool);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Decimal Column Writer
-//===--------------------------------------------------------------------===//
-static void WriteParquetDecimal(hugeint_t input, data_ptr_t result) {
-	bool positive = input >= 0;
-	// numbers are stored as two's complement so some muckery is required
-	if (!positive) {
-		input = NumericLimits<hugeint_t>::Maximum() + input + 1;
-	}
-	uint64_t high_bytes = uint64_t(input.upper);
-	uint64_t low_bytes = input.lower;
-
-	for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-		auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
-		result[i] = (high_bytes >> shift_count) & 0xFF;
-	}
-	for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-		auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
-		result[sizeof(uint64_t) + i] = (low_bytes >> shift_count) & 0xFF;
-	}
-	if (!positive) {
-		result[0] |= 0x80;
-	}
-}
-
-class FixedDecimalStatistics : public ColumnWriterStatistics {
-public:
-	FixedDecimalStatistics() : min(NumericLimits<hugeint_t>::Maximum()), max(NumericLimits<hugeint_t>::Minimum()) {
-	}
-
-	hugeint_t min;
-	hugeint_t max;
-
-public:
-	string GetStats(hugeint_t &input) {
-		data_t buffer[16];
-		WriteParquetDecimal(input, buffer);
-		return string(const_char_ptr_cast(buffer), 16);
-	}
-
-	bool HasStats() override {
-		return min <= max;
-	}
-
-	void Update(hugeint_t &val) {
-		if (LessThan::Operation(val, min)) {
-			min = val;
-		}
-		if (GreaterThan::Operation(val, max)) {
-			max = val;
-		}
-	}
-
-	string GetMin() override {
-		return GetMinValue();
-	}
-	string GetMax() override {
-		return GetMaxValue();
-	}
-	string GetMinValue() override {
-		return HasStats() ? GetStats(min) : string();
-	}
-	string GetMaxValue() override {
-		return HasStats() ? GetStats(max) : string();
-	}
-};
-
-class FixedDecimalColumnWriter : public BasicColumnWriter {
-public:
-	FixedDecimalColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, idx_t max_repeat,
-	                         idx_t max_define, bool can_have_nulls)
-	    : BasicColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls) {
-	}
-	~FixedDecimalColumnWriter() override = default;
-
-public:
-	unique_ptr<ColumnWriterStatistics> InitializeStatsState() override {
-		return make_uniq<FixedDecimalStatistics>();
-	}
-
-	void WriteVector(WriteStream &temp_writer, ColumnWriterStatistics *stats_p, ColumnWriterPageState *page_state,
-	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &mask = FlatVector::Validity(input_column);
-		auto *ptr = FlatVector::GetData<hugeint_t>(input_column);
-		auto &stats = stats_p->Cast<FixedDecimalStatistics>();
-
-		data_t temp_buffer[16];
-		for (idx_t r = chunk_start; r < chunk_end; r++) {
-			if (mask.RowIsValid(r)) {
-				stats.Update(ptr[r]);
-				WriteParquetDecimal(ptr[r], temp_buffer);
-				temp_writer.WriteData(temp_buffer, 16);
-			}
-		}
-	}
-
-	idx_t GetRowSize(const Vector &vector, const idx_t index, const BasicColumnWriterState &state) const override {
-		return sizeof(hugeint_t);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// WKB Column Writer
-//===--------------------------------------------------------------------===//
-// Used to store the metadata for a WKB-encoded geometry column when writing
-// GeoParquet files.
-class WKBColumnWriterState final : public StandardColumnWriterState<string_t> {
-public:
-	WKBColumnWriterState(ClientContext &context, duckdb_parquet::RowGroup &row_group, idx_t col_idx)
-	    : StandardColumnWriterState(row_group, col_idx), geo_data(), geo_data_writer(context) {
-	}
-
-	GeoParquetColumnMetadata geo_data;
-	GeoParquetColumnMetadataWriter geo_data_writer;
-};
-
-class WKBColumnWriter final : public StandardColumnWriter<string_t, string_t, ParquetStringOperator> {
-public:
-	WKBColumnWriter(ClientContext &context_p, ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p,
-	                idx_t max_repeat, idx_t max_define, bool can_have_nulls, string name)
-	    : StandardColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls),
-	      column_name(std::move(name)), context(context_p) {
-
-		this->writer.GetGeoParquetData().RegisterGeometryColumn(column_name);
-	}
-
-	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override {
-		auto result = make_uniq<WKBColumnWriterState>(context, row_group, row_group.columns.size());
-		result->encoding = Encoding::RLE_DICTIONARY;
-		RegisterToRowGroup(row_group);
-		return std::move(result);
-	}
-
-	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override {
-		StandardColumnWriter::Write(state, vector, count);
-
-		auto &geo_state = state.Cast<WKBColumnWriterState>();
-		geo_state.geo_data_writer.Update(geo_state.geo_data, vector, count);
-	}
-
-	void FinalizeWrite(ColumnWriterState &state) override {
-		StandardColumnWriter::FinalizeWrite(state);
-
-		// Add the geodata object to the writer
-		const auto &geo_state = state.Cast<WKBColumnWriterState>();
-
-		// Merge this state's geo column data with the writer's geo column data
-		writer.GetGeoParquetData().FlushColumnMeta(column_name, geo_state.geo_data);
-	}
-
-private:
-	string column_name;
-	ClientContext &context;
-};
-
-//===--------------------------------------------------------------------===//
-// Enum Column Writer
-//===--------------------------------------------------------------------===//
-class EnumWriterPageState : public ColumnWriterPageState {
-public:
-	explicit EnumWriterPageState(uint32_t bit_width) : encoder(bit_width), written_value(false) {
-	}
-
-	RleBpEncoder encoder;
-	bool written_value;
-};
-
-class EnumColumnWriter : public BasicColumnWriter {
-public:
-	EnumColumnWriter(ParquetWriter &writer, LogicalType enum_type_p, idx_t schema_idx, vector<string> schema_path_p,
-	                 idx_t max_repeat, idx_t max_define, bool can_have_nulls)
-	    : BasicColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls),
-	      enum_type(std::move(enum_type_p)) {
-		bit_width = RleBpDecoder::ComputeBitWidth(EnumType::GetSize(enum_type));
-	}
-	~EnumColumnWriter() override = default;
-
-	LogicalType enum_type;
-	uint32_t bit_width;
-
-public:
-	unique_ptr<ColumnWriterStatistics> InitializeStatsState() override {
-		return make_uniq<StringStatisticsState>();
-	}
-
-	template <class T>
-	void WriteEnumInternal(WriteStream &temp_writer, Vector &input_column, idx_t chunk_start, idx_t chunk_end,
-	                       EnumWriterPageState &page_state) {
-		auto &mask = FlatVector::Validity(input_column);
-		auto *ptr = FlatVector::GetData<T>(input_column);
-		for (idx_t r = chunk_start; r < chunk_end; r++) {
-			if (mask.RowIsValid(r)) {
-				if (!page_state.written_value) {
-					// first value
-					// write the bit-width as a one-byte entry
-					temp_writer.Write<uint8_t>(bit_width);
-					// now begin writing the actual value
-					page_state.encoder.BeginWrite(temp_writer, ptr[r]);
-					page_state.written_value = true;
-				} else {
-					page_state.encoder.WriteValue(temp_writer, ptr[r]);
-				}
-			}
-		}
-	}
-
-	void WriteVector(WriteStream &temp_writer, ColumnWriterStatistics *stats_p, ColumnWriterPageState *page_state_p,
-	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &page_state = page_state_p->Cast<EnumWriterPageState>();
-		switch (enum_type.InternalType()) {
-		case PhysicalType::UINT8:
-			WriteEnumInternal<uint8_t>(temp_writer, input_column, chunk_start, chunk_end, page_state);
-			break;
-		case PhysicalType::UINT16:
-			WriteEnumInternal<uint16_t>(temp_writer, input_column, chunk_start, chunk_end, page_state);
-			break;
-		case PhysicalType::UINT32:
-			WriteEnumInternal<uint32_t>(temp_writer, input_column, chunk_start, chunk_end, page_state);
-			break;
-		default:
-			throw InternalException("Unsupported internal enum type");
-		}
-	}
-
-	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state) override {
-		return make_uniq<EnumWriterPageState>(bit_width);
-	}
-
-	void FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state_p) override {
-		auto &page_state = state_p->Cast<EnumWriterPageState>();
-		if (!page_state.written_value) {
-			// all values are null
-			// just write the bit width
-			temp_writer.Write<uint8_t>(bit_width);
-			return;
-		}
-		page_state.encoder.FinishWrite(temp_writer);
-	}
-
-	duckdb_parquet::Encoding::type GetEncoding(BasicColumnWriterState &state) override {
-		return Encoding::RLE_DICTIONARY;
-	}
-
-	bool HasDictionary(BasicColumnWriterState &state) override {
-		return true;
-	}
-
-	idx_t DictionarySize(BasicColumnWriterState &state_p) override {
-		return EnumType::GetSize(enum_type);
-	}
-
-	void FlushDictionary(BasicColumnWriterState &state, ColumnWriterStatistics *stats_p) override {
-		auto &stats = stats_p->Cast<StringStatisticsState>();
-		// write the enum values to a dictionary page
-		auto &enum_values = EnumType::GetValuesInsertOrder(enum_type);
-		auto enum_count = EnumType::GetSize(enum_type);
-		auto string_values = FlatVector::GetData<string_t>(enum_values);
-		// first write the contents of the dictionary page to a temporary buffer
-		auto temp_writer = make_uniq<MemoryStream>();
-		for (idx_t r = 0; r < enum_count; r++) {
-			D_ASSERT(!FlatVector::IsNull(enum_values, r));
-			// update the statistics
-			stats.Update(string_values[r]);
-			// write this string value to the dictionary
-			temp_writer->Write<uint32_t>(string_values[r].GetSize());
-			temp_writer->WriteData(const_data_ptr_cast(string_values[r].GetData()), string_values[r].GetSize());
-		}
-		// flush the dictionary page and add it to the to-be-written pages
-		WriteDictionary(state, std::move(temp_writer), enum_count);
-	}
-
-	idx_t GetRowSize(const Vector &vector, const idx_t index, const BasicColumnWriterState &state) const override {
-		return (bit_width + 7) / 8;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Struct Column Writer
-//===--------------------------------------------------------------------===//
-class StructColumnWriter : public ColumnWriter {
-public:
-	StructColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, idx_t max_repeat,
-	                   idx_t max_define, vector<unique_ptr<ColumnWriter>> child_writers_p, bool can_have_nulls)
-	    : ColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls),
-	      child_writers(std::move(child_writers_p)) {
-	}
-	~StructColumnWriter() override = default;
-
-	vector<unique_ptr<ColumnWriter>> child_writers;
-
-public:
-	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override;
-	bool HasAnalyze() override;
-	void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-	void FinalizeAnalyze(ColumnWriterState &state) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-
-	void BeginWrite(ColumnWriterState &state) override;
-	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;
-	void FinalizeWrite(ColumnWriterState &state) override;
-};
-
-class StructColumnWriterState : public ColumnWriterState {
-public:
-	StructColumnWriterState(duckdb_parquet::RowGroup &row_group, idx_t col_idx)
-	    : row_group(row_group), col_idx(col_idx) {
-	}
-	~StructColumnWriterState() override = default;
-
-	duckdb_parquet::RowGroup &row_group;
-	idx_t col_idx;
-	vector<unique_ptr<ColumnWriterState>> child_states;
-};
-
-unique_ptr<ColumnWriterState> StructColumnWriter::InitializeWriteState(duckdb_parquet::RowGroup &row_group) {
-	auto result = make_uniq<StructColumnWriterState>(row_group, row_group.columns.size());
-
-	result->child_states.reserve(child_writers.size());
-	for (auto &child_writer : child_writers) {
-		result->child_states.push_back(child_writer->InitializeWriteState(row_group));
-	}
-	return std::move(result);
-}
-
-bool StructColumnWriter::HasAnalyze() {
-	for (auto &child_writer : child_writers) {
-		if (child_writer->HasAnalyze()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void StructColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<StructColumnWriterState>();
-	auto &child_vectors = StructVector::GetEntries(vector);
-	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		// Need to check again. It might be that just one child needs it but the rest not
-		if (child_writers[child_idx]->HasAnalyze()) {
-			child_writers[child_idx]->Analyze(*state.child_states[child_idx], &state_p, *child_vectors[child_idx],
-			                                  count);
-		}
-	}
-}
-
-void StructColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<StructColumnWriterState>();
-	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		// Need to check again. It might be that just one child needs it but the rest not
-		if (child_writers[child_idx]->HasAnalyze()) {
-			child_writers[child_idx]->FinalizeAnalyze(*state.child_states[child_idx]);
-		}
-	}
-}
-
-void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<StructColumnWriterState>();
-
-	auto &validity = FlatVector::Validity(vector);
-	if (parent) {
-		// propagate empty entries from the parent
-		while (state.is_empty.size() < parent->is_empty.size()) {
-			state.is_empty.push_back(parent->is_empty[state.is_empty.size()]);
-		}
-	}
-	HandleRepeatLevels(state_p, parent, count, max_repeat);
-	HandleDefineLevels(state_p, parent, validity, count, PARQUET_DEFINE_VALID, max_define - 1);
-	auto &child_vectors = StructVector::GetEntries(vector);
-	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		child_writers[child_idx]->Prepare(*state.child_states[child_idx], &state_p, *child_vectors[child_idx], count);
-	}
-}
-
-void StructColumnWriter::BeginWrite(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<StructColumnWriterState>();
-	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		child_writers[child_idx]->BeginWrite(*state.child_states[child_idx]);
-	}
-}
-
-void StructColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<StructColumnWriterState>();
-	auto &child_vectors = StructVector::GetEntries(vector);
-	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		child_writers[child_idx]->Write(*state.child_states[child_idx], *child_vectors[child_idx], count);
-	}
-}
-
-void StructColumnWriter::FinalizeWrite(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<StructColumnWriterState>();
-	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		// we add the null count of the struct to the null count of the children
-		state.child_states[child_idx]->null_count += state_p.null_count;
-		child_writers[child_idx]->FinalizeWrite(*state.child_states[child_idx]);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// List Column Writer
-//===--------------------------------------------------------------------===//
-class ListColumnWriter : public ColumnWriter {
-public:
-	ListColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, idx_t max_repeat,
-	                 idx_t max_define, unique_ptr<ColumnWriter> child_writer_p, bool can_have_nulls)
-	    : ColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls),
-	      child_writer(std::move(child_writer_p)) {
-	}
-	~ListColumnWriter() override = default;
-
-	unique_ptr<ColumnWriter> child_writer;
-
-public:
-	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override;
-	bool HasAnalyze() override;
-	void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-	void FinalizeAnalyze(ColumnWriterState &state) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-
-	void BeginWrite(ColumnWriterState &state) override;
-	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;
-	void FinalizeWrite(ColumnWriterState &state) override;
-};
-
-class ListColumnWriterState : public ColumnWriterState {
-public:
-	ListColumnWriterState(duckdb_parquet::RowGroup &row_group, idx_t col_idx) : row_group(row_group), col_idx(col_idx) {
-	}
-	~ListColumnWriterState() override = default;
-
-	duckdb_parquet::RowGroup &row_group;
-	idx_t col_idx;
-	unique_ptr<ColumnWriterState> child_state;
-	idx_t parent_index = 0;
-};
-
-unique_ptr<ColumnWriterState> ListColumnWriter::InitializeWriteState(duckdb_parquet::RowGroup &row_group) {
-	auto result = make_uniq<ListColumnWriterState>(row_group, row_group.columns.size());
-	result->child_state = child_writer->InitializeWriteState(row_group);
-	return std::move(result);
-}
-
-bool ListColumnWriter::HasAnalyze() {
-	return child_writer->HasAnalyze();
-}
-void ListColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-	auto &list_child = ListVector::GetEntry(vector);
-	auto list_count = ListVector::GetListSize(vector);
-	child_writer->Analyze(*state.child_state, &state_p, list_child, list_count);
-}
-
-void ListColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-	child_writer->FinalizeAnalyze(*state.child_state);
-}
-
-idx_t GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t count) {
-	// returns a consecutive child list that fully flattens and repeats all required elements
-	auto &validity = FlatVector::Validity(list);
-	auto list_entries = FlatVector::GetData<list_entry_t>(list);
-	bool is_consecutive = true;
-	idx_t total_length = 0;
-	for (idx_t c = offset; c < offset + count; c++) {
-		if (!validity.RowIsValid(c)) {
-			continue;
-		}
-		if (list_entries[c].offset != total_length) {
-			is_consecutive = false;
-		}
-		total_length += list_entries[c].length;
-	}
-	if (is_consecutive) {
-		// already consecutive - leave it as-is
-		return total_length;
-	}
-	SelectionVector sel(total_length);
-	idx_t index = 0;
-	for (idx_t c = offset; c < offset + count; c++) {
-		if (!validity.RowIsValid(c)) {
-			continue;
-		}
-		for (idx_t k = 0; k < list_entries[c].length; k++) {
-			sel.set_index(index++, list_entries[c].offset + k);
-		}
-	}
-	result.Slice(sel, total_length);
-	result.Flatten(total_length);
-	return total_length;
-}
-
-void ListColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-
-	auto list_data = FlatVector::GetData<list_entry_t>(vector);
-	auto &validity = FlatVector::Validity(vector);
-
-	// write definition levels and repeats
-	idx_t start = 0;
-	idx_t vcount = parent ? parent->definition_levels.size() - state.parent_index : count;
-	idx_t vector_index = 0;
-	for (idx_t i = start; i < vcount; i++) {
-		idx_t parent_index = state.parent_index + i;
-		if (parent && !parent->is_empty.empty() && parent->is_empty[parent_index]) {
-			state.definition_levels.push_back(parent->definition_levels[parent_index]);
-			state.repetition_levels.push_back(parent->repetition_levels[parent_index]);
-			state.is_empty.push_back(true);
-			continue;
-		}
-		auto first_repeat_level =
-		    parent && !parent->repetition_levels.empty() ? parent->repetition_levels[parent_index] : max_repeat;
-		if (parent && parent->definition_levels[parent_index] != PARQUET_DEFINE_VALID) {
-			state.definition_levels.push_back(parent->definition_levels[parent_index]);
-			state.repetition_levels.push_back(first_repeat_level);
-			state.is_empty.push_back(true);
-		} else if (validity.RowIsValid(vector_index)) {
-			// push the repetition levels
-			if (list_data[vector_index].length == 0) {
-				state.definition_levels.push_back(max_define);
-				state.is_empty.push_back(true);
-			} else {
-				state.definition_levels.push_back(PARQUET_DEFINE_VALID);
-				state.is_empty.push_back(false);
-			}
-			state.repetition_levels.push_back(first_repeat_level);
-			for (idx_t k = 1; k < list_data[vector_index].length; k++) {
-				state.repetition_levels.push_back(max_repeat + 1);
-				state.definition_levels.push_back(PARQUET_DEFINE_VALID);
-				state.is_empty.push_back(false);
-			}
-		} else {
-			if (!can_have_nulls) {
-				throw IOException("Parquet writer: map key column is not allowed to contain NULL values");
-			}
-			state.definition_levels.push_back(max_define - 1);
-			state.repetition_levels.push_back(first_repeat_level);
-			state.is_empty.push_back(true);
-		}
-		vector_index++;
-	}
-	state.parent_index += vcount;
-
-	auto &list_child = ListVector::GetEntry(vector);
-	Vector child_list(list_child);
-	auto child_length = GetConsecutiveChildList(vector, child_list, 0, count);
-	child_writer->Prepare(*state.child_state, &state_p, child_list, child_length);
-}
-
-void ListColumnWriter::BeginWrite(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-	child_writer->BeginWrite(*state.child_state);
-}
-
-void ListColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-
-	auto &list_child = ListVector::GetEntry(vector);
-	Vector child_list(list_child);
-	auto child_length = GetConsecutiveChildList(vector, child_list, 0, count);
-	child_writer->Write(*state.child_state, child_list, child_length);
-}
-
-void ListColumnWriter::FinalizeWrite(ColumnWriterState &state_p) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-	child_writer->FinalizeWrite(*state.child_state);
-}
-
-//===--------------------------------------------------------------------===//
-// Array Column Writer
-//===--------------------------------------------------------------------===//
-class ArrayColumnWriter : public ListColumnWriter {
-public:
-	ArrayColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p, idx_t max_repeat,
-	                  idx_t max_define, unique_ptr<ColumnWriter> child_writer_p, bool can_have_nulls)
-	    : ListColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define,
-	                       std::move(child_writer_p), can_have_nulls) {
-	}
-	~ArrayColumnWriter() override = default;
-
-public:
-	void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;
-};
-
-void ArrayColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-	auto &array_child = ArrayVector::GetEntry(vector);
-	auto array_size = ArrayType::GetSize(vector.GetType());
-	child_writer->Analyze(*state.child_state, &state_p, array_child, array_size * count);
-}
-
-void ArrayColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-
-	auto array_size = ArrayType::GetSize(vector.GetType());
-	auto &validity = FlatVector::Validity(vector);
-
-	// write definition levels and repeats
-	// the main difference between this and ListColumnWriter::Prepare is that we need to make sure to write out
-	// repetition levels and definitions for the child elements of the array even if the array itself is NULL.
-	idx_t start = 0;
-	idx_t vcount = parent ? parent->definition_levels.size() - state.parent_index : count;
-	idx_t vector_index = 0;
-	for (idx_t i = start; i < vcount; i++) {
-		idx_t parent_index = state.parent_index + i;
-		if (parent && !parent->is_empty.empty() && parent->is_empty[parent_index]) {
-			state.definition_levels.push_back(parent->definition_levels[parent_index]);
-			state.repetition_levels.push_back(parent->repetition_levels[parent_index]);
-			state.is_empty.push_back(true);
-			continue;
-		}
-		auto first_repeat_level =
-		    parent && !parent->repetition_levels.empty() ? parent->repetition_levels[parent_index] : max_repeat;
-		if (parent && parent->definition_levels[parent_index] != PARQUET_DEFINE_VALID) {
-			state.definition_levels.push_back(parent->definition_levels[parent_index]);
-			state.repetition_levels.push_back(first_repeat_level);
-			state.is_empty.push_back(false);
-			for (idx_t k = 1; k < array_size; k++) {
-				state.repetition_levels.push_back(max_repeat + 1);
-				state.definition_levels.push_back(parent->definition_levels[parent_index]);
-				state.is_empty.push_back(false);
-			}
-		} else if (validity.RowIsValid(vector_index)) {
-			// push the repetition levels
-			state.definition_levels.push_back(PARQUET_DEFINE_VALID);
-			state.is_empty.push_back(false);
-
-			state.repetition_levels.push_back(first_repeat_level);
-			for (idx_t k = 1; k < array_size; k++) {
-				state.repetition_levels.push_back(max_repeat + 1);
-				state.definition_levels.push_back(PARQUET_DEFINE_VALID);
-				state.is_empty.push_back(false);
-			}
-		} else {
-			state.definition_levels.push_back(max_define - 1);
-			state.repetition_levels.push_back(first_repeat_level);
-			state.is_empty.push_back(false);
-			for (idx_t k = 1; k < array_size; k++) {
-				state.repetition_levels.push_back(max_repeat + 1);
-				state.definition_levels.push_back(max_define - 1);
-				state.is_empty.push_back(false);
-			}
-		}
-		vector_index++;
-	}
-	state.parent_index += vcount;
-
-	auto &array_child = ArrayVector::GetEntry(vector);
-	child_writer->Prepare(*state.child_state, &state_p, array_child, count * array_size);
-}
-
-void ArrayColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = state_p.Cast<ListColumnWriterState>();
-	auto array_size = ArrayType::GetSize(vector.GetType());
-	auto &array_child = ArrayVector::GetEntry(vector);
-	child_writer->Write(*state.child_state, array_child, count * array_size);
-}
-
-// special double/float class to deal with dictionary encoding and NaN equality
-struct double_na_equal {
-	double_na_equal() : val(0) {
-	}
-	explicit double_na_equal(const double val_p) : val(val_p) {
-	}
-	// NOLINTNEXTLINE: allow implicit conversion to double
-	operator double() const {
-		return val;
-	}
-
-	bool operator==(const double &right) const {
-		if (std::isnan(val) && std::isnan(right)) {
-			return true;
-		}
-		return val == right;
-	}
-	double val;
-};
-
-struct float_na_equal {
-	float_na_equal() : val(0) {
-	}
-	explicit float_na_equal(const float val_p) : val(val_p) {
-	}
-	// NOLINTNEXTLINE: allow implicit conversion to float
-	operator float() const {
-		return val;
-	}
-	bool operator==(const float &right) const {
-		if (std::isnan(val) && std::isnan(right)) {
-			return true;
-		}
-		return val == right;
-	}
-	float val;
-};
-
-//===--------------------------------------------------------------------===//
-// Create Column Writer
-//===--------------------------------------------------------------------===//
-
-unique_ptr<ColumnWriter> ColumnWriter::CreateWriterRecursive(ClientContext &context,
-                                                             vector<duckdb_parquet::SchemaElement> &schemas,
-                                                             ParquetWriter &writer, const LogicalType &type,
-                                                             const string &name, vector<string> schema_path,
-                                                             optional_ptr<const ChildFieldIDs> field_ids,
-                                                             idx_t max_repeat, idx_t max_define, bool can_have_nulls) {
-	auto null_type = can_have_nulls ? FieldRepetitionType::OPTIONAL : FieldRepetitionType::REQUIRED;
-	if (!can_have_nulls) {
-		max_define--;
-	}
-	idx_t schema_idx = schemas.size();
-
-	optional_ptr<const FieldID> field_id;
-	optional_ptr<const ChildFieldIDs> child_field_ids;
-	if (field_ids) {
-		auto field_id_it = field_ids->ids->find(name);
-		if (field_id_it != field_ids->ids->end()) {
-			field_id = &field_id_it->second;
-			child_field_ids = &field_id->child_field_ids;
-		}
-	}
-
-	if (type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::UNION) {
-		auto &child_types = StructType::GetChildTypes(type);
-		// set up the schema element for this struct
-		duckdb_parquet::SchemaElement schema_element;
-		schema_element.repetition_type = null_type;
-		schema_element.num_children = UnsafeNumericCast<int32_t>(child_types.size());
-		schema_element.__isset.num_children = true;
-		schema_element.__isset.type = false;
-		schema_element.__isset.repetition_type = true;
-		schema_element.name = name;
-		if (field_id && field_id->set) {
-			schema_element.__isset.field_id = true;
-			schema_element.field_id = field_id->field_id;
-		}
-		schemas.push_back(std::move(schema_element));
-		schema_path.push_back(name);
-
-		// construct the child types recursively
-		vector<unique_ptr<ColumnWriter>> child_writers;
-		child_writers.reserve(child_types.size());
-		for (auto &child_type : child_types) {
-			child_writers.push_back(CreateWriterRecursive(context, schemas, writer, child_type.second, child_type.first,
-			                                              schema_path, child_field_ids, max_repeat, max_define + 1));
-		}
-		return make_uniq<StructColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat, max_define,
-		                                     std::move(child_writers), can_have_nulls);
-	}
-	if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::ARRAY) {
-		auto is_list = type.id() == LogicalTypeId::LIST;
-		auto &child_type = is_list ? ListType::GetChildType(type) : ArrayType::GetChildType(type);
-		// set up the two schema elements for the list
-		// for some reason we only set the converted type in the OPTIONAL element
-		// first an OPTIONAL element
-		duckdb_parquet::SchemaElement optional_element;
-		optional_element.repetition_type = null_type;
-		optional_element.num_children = 1;
-		optional_element.converted_type = ConvertedType::LIST;
-		optional_element.__isset.num_children = true;
-		optional_element.__isset.type = false;
-		optional_element.__isset.repetition_type = true;
-		optional_element.__isset.converted_type = true;
-		optional_element.name = name;
-		if (field_id && field_id->set) {
-			optional_element.__isset.field_id = true;
-			optional_element.field_id = field_id->field_id;
-		}
-		schemas.push_back(std::move(optional_element));
-		schema_path.push_back(name);
-
-		// then a REPEATED element
-		duckdb_parquet::SchemaElement repeated_element;
-		repeated_element.repetition_type = FieldRepetitionType::REPEATED;
-		repeated_element.num_children = 1;
-		repeated_element.__isset.num_children = true;
-		repeated_element.__isset.type = false;
-		repeated_element.__isset.repetition_type = true;
-		repeated_element.name = is_list ? "list" : "array";
-		schemas.push_back(std::move(repeated_element));
-		schema_path.emplace_back(is_list ? "list" : "array");
-
-		auto child_writer = CreateWriterRecursive(context, schemas, writer, child_type, "element", schema_path,
-		                                          child_field_ids, max_repeat + 1, max_define + 2);
-		if (is_list) {
-			return make_uniq<ListColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat, max_define,
-			                                   std::move(child_writer), can_have_nulls);
-		} else {
-			return make_uniq<ArrayColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat, max_define,
-			                                    std::move(child_writer), can_have_nulls);
-		}
-	}
-	if (type.id() == LogicalTypeId::MAP) {
-		// map type
-		// maps are stored as follows:
-		// <map-repetition> group <name> (MAP) {
-		// 	repeated group key_value {
-		// 		required <key-type> key;
-		// 		<value-repetition> <value-type> value;
-		// 	}
-		// }
-		// top map element
-		duckdb_parquet::SchemaElement top_element;
-		top_element.repetition_type = null_type;
-		top_element.num_children = 1;
-		top_element.converted_type = ConvertedType::MAP;
-		top_element.__isset.repetition_type = true;
-		top_element.__isset.num_children = true;
-		top_element.__isset.converted_type = true;
-		top_element.__isset.type = false;
-		top_element.name = name;
-		if (field_id && field_id->set) {
-			top_element.__isset.field_id = true;
-			top_element.field_id = field_id->field_id;
-		}
-		schemas.push_back(std::move(top_element));
-		schema_path.push_back(name);
-
-		// key_value element
-		duckdb_parquet::SchemaElement kv_element;
-		kv_element.repetition_type = FieldRepetitionType::REPEATED;
-		kv_element.num_children = 2;
-		kv_element.__isset.repetition_type = true;
-		kv_element.__isset.num_children = true;
-		kv_element.__isset.type = false;
-		kv_element.name = "key_value";
-		schemas.push_back(std::move(kv_element));
-		schema_path.emplace_back("key_value");
-
-		// construct the child types recursively
-		vector<LogicalType> kv_types {MapType::KeyType(type), MapType::ValueType(type)};
-		vector<string> kv_names {"key", "value"};
-		vector<unique_ptr<ColumnWriter>> child_writers;
-		child_writers.reserve(2);
-		for (idx_t i = 0; i < 2; i++) {
-			// key needs to be marked as REQUIRED
-			bool is_key = i == 0;
-			auto child_writer = CreateWriterRecursive(context, schemas, writer, kv_types[i], kv_names[i], schema_path,
-			                                          child_field_ids, max_repeat + 1, max_define + 2, !is_key);
-
-			child_writers.push_back(std::move(child_writer));
-		}
-		auto struct_writer = make_uniq<StructColumnWriter>(writer, schema_idx, schema_path, max_repeat, max_define,
-		                                                   std::move(child_writers), can_have_nulls);
-		return make_uniq<ListColumnWriter>(writer, schema_idx, schema_path, max_repeat, max_define,
-		                                   std::move(struct_writer), can_have_nulls);
-	}
-	duckdb_parquet::SchemaElement schema_element;
-	schema_element.type = ParquetWriter::DuckDBTypeToParquetType(type);
-	schema_element.repetition_type = null_type;
-	schema_element.__isset.num_children = false;
-	schema_element.__isset.type = true;
-	schema_element.__isset.repetition_type = true;
-	schema_element.name = name;
-	if (field_id && field_id->set) {
-		schema_element.__isset.field_id = true;
-		schema_element.field_id = field_id->field_id;
-	}
-	ParquetWriter::SetSchemaProperties(type, schema_element);
-	schemas.push_back(std::move(schema_element));
-	schema_path.push_back(name);
-	if (type.id() == LogicalTypeId::BLOB && type.GetAlias() == "WKB_BLOB" &&
-	    GeoParquetFileMetadata::IsGeoParquetConversionEnabled(context)) {
-		return make_uniq<WKBColumnWriter>(context, writer, schema_idx, std::move(schema_path), max_repeat, max_define,
-		                                  can_have_nulls, name);
-	}
-
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return make_uniq<BooleanColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat, max_define,
-		                                      can_have_nulls);
-	case LogicalTypeId::TINYINT:
-		return make_uniq<StandardColumnWriter<int8_t, int32_t>>(writer, schema_idx, std::move(schema_path), max_repeat,
-		                                                        max_define, can_have_nulls);
-	case LogicalTypeId::SMALLINT:
-		return make_uniq<StandardColumnWriter<int16_t, int32_t>>(writer, schema_idx, std::move(schema_path), max_repeat,
-		                                                         max_define, can_have_nulls);
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::DATE:
-		return make_uniq<StandardColumnWriter<int32_t, int32_t>>(writer, schema_idx, std::move(schema_path), max_repeat,
-		                                                         max_define, can_have_nulls);
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_MS:
-		return make_uniq<StandardColumnWriter<int64_t, int64_t>>(writer, schema_idx, std::move(schema_path), max_repeat,
-		                                                         max_define, can_have_nulls);
-	case LogicalTypeId::TIME_TZ:
-		return make_uniq<StandardColumnWriter<dtime_tz_t, int64_t, ParquetTimeTZOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::HUGEINT:
-		return make_uniq<StandardColumnWriter<hugeint_t, double, ParquetHugeintOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::UHUGEINT:
-		return make_uniq<StandardColumnWriter<uhugeint_t, double, ParquetUhugeintOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return make_uniq<StandardColumnWriter<int64_t, int64_t, ParquetTimestampNSOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return make_uniq<StandardColumnWriter<int64_t, int64_t, ParquetTimestampSOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::UTINYINT:
-		return make_uniq<StandardColumnWriter<uint8_t, int32_t>>(writer, schema_idx, std::move(schema_path), max_repeat,
-		                                                         max_define, can_have_nulls);
-	case LogicalTypeId::USMALLINT:
-		return make_uniq<StandardColumnWriter<uint16_t, int32_t>>(writer, schema_idx, std::move(schema_path),
-		                                                          max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::UINTEGER:
-		return make_uniq<StandardColumnWriter<uint32_t, uint32_t>>(writer, schema_idx, std::move(schema_path),
-		                                                           max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::UBIGINT:
-		return make_uniq<StandardColumnWriter<uint64_t, uint64_t>>(writer, schema_idx, std::move(schema_path),
-		                                                           max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::FLOAT:
-		return make_uniq<StandardColumnWriter<float_na_equal, float>>(writer, schema_idx, std::move(schema_path),
-		                                                              max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::DOUBLE:
-		return make_uniq<StandardColumnWriter<double_na_equal, double>>(writer, schema_idx, std::move(schema_path),
-		                                                                max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return make_uniq<StandardColumnWriter<int16_t, int32_t>>(writer, schema_idx, std::move(schema_path),
-			                                                         max_repeat, max_define, can_have_nulls);
-		case PhysicalType::INT32:
-			return make_uniq<StandardColumnWriter<int32_t, int32_t>>(writer, schema_idx, std::move(schema_path),
-			                                                         max_repeat, max_define, can_have_nulls);
-		case PhysicalType::INT64:
-			return make_uniq<StandardColumnWriter<int64_t, int64_t>>(writer, schema_idx, std::move(schema_path),
-			                                                         max_repeat, max_define, can_have_nulls);
-		default:
-			return make_uniq<FixedDecimalColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat,
-			                                           max_define, can_have_nulls);
-		}
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
-		return make_uniq<StandardColumnWriter<string_t, string_t, ParquetStringOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::UUID:
-		return make_uniq<StandardColumnWriter<hugeint_t, ParquetUUIDTargetType, ParquetUUIDOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::INTERVAL:
-		return make_uniq<StandardColumnWriter<interval_t, ParquetIntervalTargetType, ParquetIntervalOperator>>(
-		    writer, schema_idx, std::move(schema_path), max_repeat, max_define, can_have_nulls);
-	case LogicalTypeId::ENUM:
-		return make_uniq<EnumColumnWriter>(writer, type, schema_idx, std::move(schema_path), max_repeat, max_define,
-		                                   can_have_nulls);
-	default:
-		throw InternalException("Unsupported type \"%s\" in Parquet writer", type.ToString());
-	}
-}
-
-template <>
-struct NumericLimits<float_na_equal> {
-	static constexpr float Minimum() {
-		return std::numeric_limits<float>::lowest();
-	};
-	static constexpr float Maximum() {
-		return std::numeric_limits<float>::max();
-	};
-	static constexpr bool IsSigned() {
-		return std::is_signed<float>::value;
-	}
-	static constexpr bool IsIntegral() {
-		return std::is_integral<float>::value;
-	}
-};
-
-template <>
-struct NumericLimits<double_na_equal> {
-	static constexpr double Minimum() {
-		return std::numeric_limits<double>::lowest();
-	};
-	static constexpr double Maximum() {
-		return std::numeric_limits<double>::max();
-	};
-	static constexpr bool IsSigned() {
-		return std::is_signed<double>::value;
-	}
-	static constexpr bool IsIntegral() {
-		return std::is_integral<double>::value;
-	}
-};
-
-} // namespace duckdb
-
-namespace std {
-template <>
-struct hash<duckdb::ParquetIntervalTargetType> {
-	size_t operator()(const duckdb::ParquetIntervalTargetType &val) const {
-		return duckdb::Hash(duckdb::const_char_ptr_cast(val.bytes),
-		                    duckdb::ParquetIntervalTargetType::PARQUET_INTERVAL_SIZE);
-	}
-};
-
-template <>
-struct hash<duckdb::ParquetUUIDTargetType> {
-	size_t operator()(const duckdb::ParquetUUIDTargetType &val) const {
-		return duckdb::Hash(duckdb::const_char_ptr_cast(val.bytes), duckdb::ParquetUUIDTargetType::PARQUET_UUID_SIZE);
-	}
-};
-
-template <>
-struct hash<duckdb::float_na_equal> {
-	size_t operator()(const duckdb::float_na_equal &val) const {
-		if (std::isnan(val.val)) {
-			return duckdb::Hash<float>(std::numeric_limits<float>::quiet_NaN());
-		}
-		return duckdb::Hash<float>(val.val);
-	}
-};
-
-template <>
-struct hash<duckdb::double_na_equal> {
-	inline size_t operator()(const duckdb::double_na_equal &val) const {
-		if (std::isnan(val.val)) {
-			return duckdb::Hash<double>(std::numeric_limits<double>::quiet_NaN());
-		}
-		return duckdb::Hash<double>(val.val);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/extension/parquet/geo_parquet.cpp b/src/duckdb/extension/parquet/geo_parquet.cpp
deleted file mode 100644
index ec252a50d..000000000
--- a/src/duckdb/extension/parquet/geo_parquet.cpp
+++ /dev/null
@@ -1,424 +0,0 @@
-
-#include "geo_parquet.hpp"
-
-#include "column_reader.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "expression_column_reader.hpp"
-#include "parquet_reader.hpp"
-#include "yyjson.hpp"
-
-namespace duckdb {
-
-using namespace duckdb_yyjson; // NOLINT
-
-const char *WKBGeometryTypes::ToString(WKBGeometryType type) {
-	switch (type) {
-	case WKBGeometryType::POINT:
-		return "Point";
-	case WKBGeometryType::LINESTRING:
-		return "LineString";
-	case WKBGeometryType::POLYGON:
-		return "Polygon";
-	case WKBGeometryType::MULTIPOINT:
-		return "MultiPoint";
-	case WKBGeometryType::MULTILINESTRING:
-		return "MultiLineString";
-	case WKBGeometryType::MULTIPOLYGON:
-		return "MultiPolygon";
-	case WKBGeometryType::GEOMETRYCOLLECTION:
-		return "GeometryCollection";
-	case WKBGeometryType::POINT_Z:
-		return "Point Z";
-	case WKBGeometryType::LINESTRING_Z:
-		return "LineString Z";
-	case WKBGeometryType::POLYGON_Z:
-		return "Polygon Z";
-	case WKBGeometryType::MULTIPOINT_Z:
-		return "MultiPoint Z";
-	case WKBGeometryType::MULTILINESTRING_Z:
-		return "MultiLineString Z";
-	case WKBGeometryType::MULTIPOLYGON_Z:
-		return "MultiPolygon Z";
-	case WKBGeometryType::GEOMETRYCOLLECTION_Z:
-		return "GeometryCollection Z";
-	default:
-		throw NotImplementedException("Unsupported geometry type");
-	}
-}
-
-//------------------------------------------------------------------------------
-// GeoParquetColumnMetadataWriter
-//------------------------------------------------------------------------------
-GeoParquetColumnMetadataWriter::GeoParquetColumnMetadataWriter(ClientContext &context) {
-	executor = make_uniq<ExpressionExecutor>(context);
-
-	auto &catalog = Catalog::GetSystemCatalog(context);
-
-	// These functions are required to extract the geometry type, ZM flag and bounding box from a WKB blob
-	auto &type_func_set =
-	    catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA, "st_geometrytype")
-	        .Cast<ScalarFunctionCatalogEntry>();
-	auto &flag_func_set = catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA, "st_zmflag")
-	                          .Cast<ScalarFunctionCatalogEntry>();
-	auto &bbox_func_set = catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA, "st_extent")
-	                          .Cast<ScalarFunctionCatalogEntry>();
-
-	auto wkb_type = LogicalType(LogicalTypeId::BLOB);
-	wkb_type.SetAlias("WKB_BLOB");
-
-	auto type_func = type_func_set.functions.GetFunctionByArguments(context, {wkb_type});
-	auto flag_func = flag_func_set.functions.GetFunctionByArguments(context, {wkb_type});
-	auto bbox_func = bbox_func_set.functions.GetFunctionByArguments(context, {wkb_type});
-
-	auto type_type = LogicalType::UTINYINT;
-	auto flag_type = flag_func.return_type;
-	auto bbox_type = bbox_func.return_type;
-
-	vector<unique_ptr<Expression>> type_args;
-	type_args.push_back(make_uniq<BoundReferenceExpression>(wkb_type, 0));
-
-	vector<unique_ptr<Expression>> flag_args;
-	flag_args.push_back(make_uniq<BoundReferenceExpression>(wkb_type, 0));
-
-	vector<unique_ptr<Expression>> bbox_args;
-	bbox_args.push_back(make_uniq<BoundReferenceExpression>(wkb_type, 0));
-
-	type_expr = make_uniq<BoundFunctionExpression>(type_type, type_func, std::move(type_args), nullptr);
-	flag_expr = make_uniq<BoundFunctionExpression>(flag_type, flag_func, std::move(flag_args), nullptr);
-	bbox_expr = make_uniq<BoundFunctionExpression>(bbox_type, bbox_func, std::move(bbox_args), nullptr);
-
-	// Add the expressions to the executor
-	executor->AddExpression(*type_expr);
-	executor->AddExpression(*flag_expr);
-	executor->AddExpression(*bbox_expr);
-
-	// Initialize the input and result chunks
-	// The input chunk should be empty, as we always reference the input vector
-	input_chunk.InitializeEmpty({wkb_type});
-	result_chunk.Initialize(context, {type_type, flag_type, bbox_type});
-}
-
-void GeoParquetColumnMetadataWriter::Update(GeoParquetColumnMetadata &meta, Vector &vector, idx_t count) {
-	input_chunk.Reset();
-	result_chunk.Reset();
-
-	// Reference the vector
-	input_chunk.data[0].Reference(vector);
-	input_chunk.SetCardinality(count);
-
-	// Execute the expression
-	executor->Execute(input_chunk, result_chunk);
-
-	// The first column is the geometry type
-	// The second column is the zm flag
-	// The third column is the bounding box
-
-	UnifiedVectorFormat type_format;
-	UnifiedVectorFormat flag_format;
-	UnifiedVectorFormat bbox_format;
-
-	result_chunk.data[0].ToUnifiedFormat(count, type_format);
-	result_chunk.data[1].ToUnifiedFormat(count, flag_format);
-	result_chunk.data[2].ToUnifiedFormat(count, bbox_format);
-
-	const auto &bbox_components = StructVector::GetEntries(result_chunk.data[2]);
-	D_ASSERT(bbox_components.size() == 4);
-
-	UnifiedVectorFormat xmin_format;
-	UnifiedVectorFormat ymin_format;
-	UnifiedVectorFormat xmax_format;
-	UnifiedVectorFormat ymax_format;
-
-	bbox_components[0]->ToUnifiedFormat(count, xmin_format);
-	bbox_components[1]->ToUnifiedFormat(count, ymin_format);
-	bbox_components[2]->ToUnifiedFormat(count, xmax_format);
-	bbox_components[3]->ToUnifiedFormat(count, ymax_format);
-
-	for (idx_t in_idx = 0; in_idx < count; in_idx++) {
-		const auto type_idx = type_format.sel->get_index(in_idx);
-		const auto flag_idx = flag_format.sel->get_index(in_idx);
-		const auto bbox_idx = bbox_format.sel->get_index(in_idx);
-
-		const auto type_valid = type_format.validity.RowIsValid(type_idx);
-		const auto flag_valid = flag_format.validity.RowIsValid(flag_idx);
-		const auto bbox_valid = bbox_format.validity.RowIsValid(bbox_idx);
-
-		if (!type_valid || !flag_valid || !bbox_valid) {
-			continue;
-		}
-
-		// Update the geometry type
-		const auto flag = UnifiedVectorFormat::GetData<uint8_t>(flag_format)[flag_idx];
-		const auto type = UnifiedVectorFormat::GetData<uint8_t>(type_format)[type_idx];
-		if (flag == 1 || flag == 3) {
-			// M or ZM
-			throw InvalidInputException("Geoparquet does not support geometries with M coordinates");
-		}
-		const auto has_z = flag == 2;
-		auto wkb_type = static_cast<WKBGeometryType>((type + 1) + (has_z ? 1000 : 0));
-		meta.geometry_types.insert(wkb_type);
-
-		// Update the bounding box
-		const auto min_x = UnifiedVectorFormat::GetData<double>(xmin_format)[bbox_idx];
-		const auto min_y = UnifiedVectorFormat::GetData<double>(ymin_format)[bbox_idx];
-		const auto max_x = UnifiedVectorFormat::GetData<double>(xmax_format)[bbox_idx];
-		const auto max_y = UnifiedVectorFormat::GetData<double>(ymax_format)[bbox_idx];
-		meta.bbox.Combine(min_x, max_x, min_y, max_y);
-	}
-}
-
-//------------------------------------------------------------------------------
-// GeoParquetFileMetadata
-//------------------------------------------------------------------------------
-
-unique_ptr<GeoParquetFileMetadata> GeoParquetFileMetadata::TryRead(const duckdb_parquet::FileMetaData &file_meta_data,
-                                                                   const ClientContext &context) {
-
-	// Conversion not enabled, or spatial is not loaded!
-	if (!IsGeoParquetConversionEnabled(context)) {
-		return nullptr;
-	}
-
-	for (auto &kv : file_meta_data.key_value_metadata) {
-		if (kv.key == "geo") {
-			const auto geo_metadata = yyjson_read(kv.value.c_str(), kv.value.size(), 0);
-			if (!geo_metadata) {
-				// Could not parse the JSON
-				return nullptr;
-			}
-
-			try {
-				// Check the root object
-				const auto root = yyjson_doc_get_root(geo_metadata);
-				if (!yyjson_is_obj(root)) {
-					throw InvalidInputException("Geoparquet metadata is not an object");
-				}
-
-				auto result = make_uniq<GeoParquetFileMetadata>();
-
-				// Check and parse the version
-				const auto version_val = yyjson_obj_get(root, "version");
-				if (!yyjson_is_str(version_val)) {
-					throw InvalidInputException("Geoparquet metadata does not have a version");
-				}
-				result->version = yyjson_get_str(version_val);
-				if (StringUtil::StartsWith(result->version, "2")) {
-					// Guard against a breaking future 2.0 version
-					throw InvalidInputException("Geoparquet version %s is not supported", result->version);
-				}
-
-				// Check and parse the primary geometry column
-				const auto primary_geometry_column_val = yyjson_obj_get(root, "primary_column");
-				if (!yyjson_is_str(primary_geometry_column_val)) {
-					throw InvalidInputException("Geoparquet metadata does not have a primary column");
-				}
-				result->primary_geometry_column = yyjson_get_str(primary_geometry_column_val);
-
-				// Check and parse the geometry columns
-				const auto columns_val = yyjson_obj_get(root, "columns");
-				if (!yyjson_is_obj(columns_val)) {
-					throw InvalidInputException("Geoparquet metadata does not have a columns object");
-				}
-
-				// Iterate over all geometry columns
-				yyjson_obj_iter iter = yyjson_obj_iter_with(columns_val);
-				yyjson_val *column_key;
-
-				while ((column_key = yyjson_obj_iter_next(&iter))) {
-					const auto column_val = yyjson_obj_iter_get_val(column_key);
-					const auto column_name = yyjson_get_str(column_key);
-
-					auto &column = result->geometry_columns[column_name];
-
-					if (!yyjson_is_obj(column_val)) {
-						throw InvalidInputException("Geoparquet column '%s' is not an object", column_name);
-					}
-
-					// Parse the encoding
-					const auto encoding_val = yyjson_obj_get(column_val, "encoding");
-					if (!yyjson_is_str(encoding_val)) {
-						throw InvalidInputException("Geoparquet column '%s' does not have an encoding", column_name);
-					}
-					const auto encoding_str = yyjson_get_str(encoding_val);
-					if (strcmp(encoding_str, "WKB") == 0) {
-						column.geometry_encoding = GeoParquetColumnEncoding::WKB;
-					} else {
-						throw InvalidInputException("Geoparquet column '%s' has an unsupported encoding", column_name);
-					}
-
-					// Parse the geometry types
-					const auto geometry_types_val = yyjson_obj_get(column_val, "geometry_types");
-					if (!yyjson_is_arr(geometry_types_val)) {
-						throw InvalidInputException("Geoparquet column '%s' does not have geometry types", column_name);
-					}
-					// We dont care about the geometry types for now.
-
-					// TODO: Parse the bounding box, other metadata that might be useful.
-					// (Only encoding and geometry types are required to be present)
-				}
-
-				// Return the result
-				// Make sure to free the JSON document
-				yyjson_doc_free(geo_metadata);
-				return result;
-
-			} catch (...) {
-				// Make sure to free the JSON document in case of an exception
-				yyjson_doc_free(geo_metadata);
-				throw;
-			}
-		}
-	}
-	return nullptr;
-}
-
-void GeoParquetFileMetadata::FlushColumnMeta(const string &column_name, const GeoParquetColumnMetadata &meta) {
-	// Lock the metadata
-	lock_guard<mutex> glock(write_lock);
-
-	auto &column = geometry_columns[column_name];
-
-	// Combine the metadata
-	column.geometry_types.insert(meta.geometry_types.begin(), meta.geometry_types.end());
-	column.bbox.Combine(meta.bbox);
-}
-
-void GeoParquetFileMetadata::Write(duckdb_parquet::FileMetaData &file_meta_data) const {
-
-	yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
-	yyjson_mut_val *root = yyjson_mut_obj(doc);
-	yyjson_mut_doc_set_root(doc, root);
-
-	// Add the version
-	yyjson_mut_obj_add_strncpy(doc, root, "version", version.c_str(), version.size());
-
-	// Add the primary column
-	yyjson_mut_obj_add_strncpy(doc, root, "primary_column", primary_geometry_column.c_str(),
-	                           primary_geometry_column.size());
-
-	// Add the columns
-	const auto json_columns = yyjson_mut_obj_add_obj(doc, root, "columns");
-
-	for (auto &column : geometry_columns) {
-		const auto column_json = yyjson_mut_obj_add_obj(doc, json_columns, column.first.c_str());
-		yyjson_mut_obj_add_str(doc, column_json, "encoding", "WKB");
-		const auto geometry_types = yyjson_mut_obj_add_arr(doc, column_json, "geometry_types");
-		for (auto &geometry_type : column.second.geometry_types) {
-			const auto type_name = WKBGeometryTypes::ToString(geometry_type);
-			yyjson_mut_arr_add_str(doc, geometry_types, type_name);
-		}
-		const auto bbox = yyjson_mut_obj_add_arr(doc, column_json, "bbox");
-		yyjson_mut_arr_add_real(doc, bbox, column.second.bbox.min_x);
-		yyjson_mut_arr_add_real(doc, bbox, column.second.bbox.min_y);
-		yyjson_mut_arr_add_real(doc, bbox, column.second.bbox.max_x);
-		yyjson_mut_arr_add_real(doc, bbox, column.second.bbox.max_y);
-
-		// If the CRS is present, add it
-		if (!column.second.projjson.empty()) {
-			const auto crs_doc = yyjson_read(column.second.projjson.c_str(), column.second.projjson.size(), 0);
-			if (!crs_doc) {
-				yyjson_mut_doc_free(doc);
-				throw InvalidInputException("Failed to parse CRS JSON");
-			}
-			const auto crs_root = yyjson_doc_get_root(crs_doc);
-			const auto crs_val = yyjson_val_mut_copy(doc, crs_root);
-			const auto crs_key = yyjson_mut_strcpy(doc, "projjson");
-			yyjson_mut_obj_add(column_json, crs_key, crs_val);
-			yyjson_doc_free(crs_doc);
-		}
-	}
-
-	yyjson_write_err err;
-	size_t len;
-	char *json = yyjson_mut_write_opts(doc, 0, nullptr, &len, &err);
-	if (!json) {
-		yyjson_mut_doc_free(doc);
-		throw SerializationException("Failed to write JSON string: %s", err.msg);
-	}
-
-	// Create a string from the JSON
-	duckdb_parquet::KeyValue kv;
-	kv.__set_key("geo");
-	kv.__set_value(string(json, len));
-
-	// Free the JSON and the document
-	free(json);
-	yyjson_mut_doc_free(doc);
-
-	file_meta_data.key_value_metadata.push_back(kv);
-	file_meta_data.__isset.key_value_metadata = true;
-}
-
-bool GeoParquetFileMetadata::IsGeometryColumn(const string &column_name) const {
-	return geometry_columns.find(column_name) != geometry_columns.end();
-}
-
-void GeoParquetFileMetadata::RegisterGeometryColumn(const string &column_name) {
-	lock_guard<mutex> glock(write_lock);
-	if (primary_geometry_column.empty()) {
-		primary_geometry_column = column_name;
-	}
-	geometry_columns[column_name] = GeoParquetColumnMetadata();
-}
-
-bool GeoParquetFileMetadata::IsGeoParquetConversionEnabled(const ClientContext &context) {
-	Value geoparquet_enabled;
-	if (!context.TryGetCurrentSetting("enable_geoparquet_conversion", geoparquet_enabled)) {
-		return false;
-	}
-	if (!geoparquet_enabled.GetValue<bool>()) {
-		// Disabled by setting
-		return false;
-	}
-	if (!context.db->ExtensionIsLoaded("spatial")) {
-		// Spatial extension is not loaded, we cant convert anyway
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ColumnReader> GeoParquetFileMetadata::CreateColumnReader(ParquetReader &reader,
-                                                                    const LogicalType &logical_type,
-                                                                    const SchemaElement &s_ele, idx_t schema_idx_p,
-                                                                    idx_t max_define_p, idx_t max_repeat_p,
-                                                                    ClientContext &context) {
-
-	D_ASSERT(IsGeometryColumn(s_ele.name));
-
-	const auto &column = geometry_columns[s_ele.name];
-
-	// Get the catalog
-	auto &catalog = Catalog::GetSystemCatalog(context);
-
-	// WKB encoding
-	if (logical_type.id() == LogicalTypeId::BLOB && column.geometry_encoding == GeoParquetColumnEncoding::WKB) {
-		// Look for a conversion function in the catalog
-		auto &conversion_func_set =
-		    catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA, "st_geomfromwkb")
-		        .Cast<ScalarFunctionCatalogEntry>();
-		auto conversion_func = conversion_func_set.functions.GetFunctionByArguments(context, {LogicalType::BLOB});
-
-		// Create a bound function call expression
-		auto args = vector<unique_ptr<Expression>>();
-		args.push_back(std::move(make_uniq<BoundReferenceExpression>(LogicalType::BLOB, 0)));
-		auto expr =
-		    make_uniq<BoundFunctionExpression>(conversion_func.return_type, conversion_func, std::move(args), nullptr);
-
-		// Create a child reader
-		auto child_reader =
-		    ColumnReader::CreateReader(reader, logical_type, s_ele, schema_idx_p, max_define_p, max_repeat_p);
-
-		// Create an expression reader that applies the conversion function to the child reader
-		return make_uniq<ExpressionColumnReader>(context, std::move(child_reader), std::move(expr));
-	}
-
-	// Otherwise, unrecognized encoding
-	throw NotImplementedException("Unsupported geometry encoding");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/boolean_column_reader.hpp b/src/duckdb/extension/parquet/include/boolean_column_reader.hpp
deleted file mode 100644
index c37c62098..000000000
--- a/src/duckdb/extension/parquet/include/boolean_column_reader.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// boolean_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-struct BooleanParquetValueConversion;
-
-class BooleanColumnReader : public TemplatedColumnReader<bool, BooleanParquetValueConversion> {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::BOOL;
-
-public:
-	BooleanColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                    idx_t max_define_p, idx_t max_repeat_p)
-	    : TemplatedColumnReader<bool, BooleanParquetValueConversion>(reader, std::move(type_p), schema_p, schema_idx_p,
-	                                                                 max_define_p, max_repeat_p),
-	      byte_pos(0) {};
-
-	uint8_t byte_pos;
-
-	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override {
-		byte_pos = 0;
-		TemplatedColumnReader<bool, BooleanParquetValueConversion>::InitializeRead(row_group_idx_p, columns,
-		                                                                           protocol_p);
-	}
-
-	void ResetPage() override {
-		byte_pos = 0;
-	}
-};
-
-struct BooleanParquetValueConversion {
-	static bool PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.available(1);
-		return UnsafePlainRead(plain_data, reader);
-	}
-
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		PlainRead(plain_data, reader);
-	}
-
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-		return plain_data.check_available((count + 7) / 8);
-	}
-
-	static bool UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		auto &byte_pos = reader.Cast<BooleanColumnReader>().byte_pos;
-		bool ret = (*plain_data.ptr >> byte_pos) & 1;
-		if (++byte_pos == 8) {
-			byte_pos = 0;
-			plain_data.unsafe_inc(1);
-		}
-		return ret;
-	}
-
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		UnsafePlainRead(plain_data, reader);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/callback_column_reader.hpp b/src/duckdb/extension/parquet/include/callback_column_reader.hpp
deleted file mode 100644
index 45c3e726e..000000000
--- a/src/duckdb/extension/parquet/include/callback_column_reader.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// callback_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-#include "parquet_reader.hpp"
-
-namespace duckdb {
-
-template <class PARQUET_PHYSICAL_TYPE, class DUCKDB_PHYSICAL_TYPE,
-          DUCKDB_PHYSICAL_TYPE (*FUNC)(const PARQUET_PHYSICAL_TYPE &input)>
-class CallbackColumnReader
-    : public TemplatedColumnReader<DUCKDB_PHYSICAL_TYPE,
-                                   CallbackParquetValueConversion<PARQUET_PHYSICAL_TYPE, DUCKDB_PHYSICAL_TYPE, FUNC>> {
-	using BaseType =
-	    TemplatedColumnReader<DUCKDB_PHYSICAL_TYPE,
-	                          CallbackParquetValueConversion<PARQUET_PHYSICAL_TYPE, DUCKDB_PHYSICAL_TYPE, FUNC>>;
-
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::INVALID;
-
-public:
-	CallbackColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t file_idx_p,
-	                     idx_t max_define_p, idx_t max_repeat_p)
-	    : TemplatedColumnReader<DUCKDB_PHYSICAL_TYPE,
-	                            CallbackParquetValueConversion<PARQUET_PHYSICAL_TYPE, DUCKDB_PHYSICAL_TYPE, FUNC>>(
-	          reader, std::move(type_p), schema_p, file_idx_p, max_define_p, max_repeat_p) {
-	}
-
-protected:
-	void Dictionary(shared_ptr<ResizeableBuffer> dictionary_data, idx_t num_entries) {
-		BaseType::AllocateDict(num_entries * sizeof(DUCKDB_PHYSICAL_TYPE));
-		auto dict_ptr = (DUCKDB_PHYSICAL_TYPE *)this->dict->ptr;
-		for (idx_t i = 0; i < num_entries; i++) {
-			dict_ptr[i] = FUNC(dictionary_data->read<PARQUET_PHYSICAL_TYPE>());
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/cast_column_reader.hpp b/src/duckdb/extension/parquet/include/cast_column_reader.hpp
deleted file mode 100644
index 640a77bda..000000000
--- a/src/duckdb/extension/parquet/include/cast_column_reader.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// cast_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-//! A column reader that represents a cast over a child reader
-class CastColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::INVALID;
-
-public:
-	CastColumnReader(unique_ptr<ColumnReader> child_reader, LogicalType target_type);
-
-	unique_ptr<ColumnReader> child_reader;
-	DataChunk intermediate_chunk;
-
-public:
-	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) override;
-	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
-
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-	           Vector &result) override;
-
-	void Skip(idx_t num_values) override;
-	idx_t GroupRowsAvailable() override;
-
-	uint64_t TotalCompressedSize() override {
-		return child_reader->TotalCompressedSize();
-	}
-
-	idx_t FileOffset() const override {
-		return child_reader->FileOffset();
-	}
-
-	void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) override {
-		child_reader->RegisterPrefetch(transport, allow_merge);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/column_reader.hpp b/src/duckdb/extension/parquet/include/column_reader.hpp
deleted file mode 100644
index 23d4fc3d4..000000000
--- a/src/duckdb/extension/parquet/include/column_reader.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#include "parquet_bss_decoder.hpp"
-#include "parquet_dbp_decoder.hpp"
-#include "parquet_rle_bp_decoder.hpp"
-#include "parquet_statistics.hpp"
-#include "parquet_types.h"
-#include "resizable_buffer.hpp"
-#include "thrift_tools.hpp"
-#ifndef DUCKDB_AMALGAMATION
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types/vector_cache.hpp"
-#endif
-
-namespace duckdb {
-class ParquetReader;
-
-using duckdb_apache::thrift::protocol::TProtocol;
-
-using duckdb_parquet::ColumnChunk;
-using duckdb_parquet::CompressionCodec;
-using duckdb_parquet::FieldRepetitionType;
-using duckdb_parquet::PageHeader;
-using duckdb_parquet::SchemaElement;
-using duckdb_parquet::Type;
-
-typedef std::bitset<STANDARD_VECTOR_SIZE> parquet_filter_t;
-
-class ColumnReader {
-public:
-	ColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t file_idx_p,
-	             idx_t max_define_p, idx_t max_repeat_p);
-	virtual ~ColumnReader();
-
-public:
-	static unique_ptr<ColumnReader> CreateReader(ParquetReader &reader, const LogicalType &type_p,
-	                                             const SchemaElement &schema_p, idx_t schema_idx_p, idx_t max_define,
-	                                             idx_t max_repeat);
-	virtual void InitializeRead(idx_t row_group_index, const vector<ColumnChunk> &columns, TProtocol &protocol_p);
-	virtual idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-	                   Vector &result_out);
-
-	virtual void Skip(idx_t num_values);
-
-	ParquetReader &Reader();
-	const LogicalType &Type() const;
-	const SchemaElement &Schema() const;
-	optional_ptr<const SchemaElement> GetParentSchema() const;
-	void SetParentSchema(const SchemaElement &parent_schema);
-
-	idx_t FileIdx() const;
-	idx_t MaxDefine() const;
-	idx_t MaxRepeat() const;
-
-	virtual idx_t FileOffset() const;
-	virtual uint64_t TotalCompressedSize();
-	virtual idx_t GroupRowsAvailable();
-
-	// register the range this reader will touch for prefetching
-	virtual void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge);
-
-	virtual unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns);
-
-	template <class VALUE_TYPE, class CONVERSION>
-	void PlainTemplated(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, uint64_t num_values,
-	                    parquet_filter_t *filter, idx_t result_offset, Vector &result) {
-		if (HasDefines()) {
-			if (CONVERSION::PlainAvailable(*plain_data, num_values)) {
-				PlainTemplatedInternal<VALUE_TYPE, CONVERSION, true, true>(*plain_data, defines, num_values, filter,
-				                                                           result_offset, result);
-			} else {
-				PlainTemplatedInternal<VALUE_TYPE, CONVERSION, true, false>(*plain_data, defines, num_values, filter,
-				                                                            result_offset, result);
-			}
-		} else {
-			if (CONVERSION::PlainAvailable(*plain_data, num_values)) {
-				PlainTemplatedInternal<VALUE_TYPE, CONVERSION, false, true>(*plain_data, defines, num_values, filter,
-				                                                            result_offset, result);
-			} else {
-				PlainTemplatedInternal<VALUE_TYPE, CONVERSION, false, false>(*plain_data, defines, num_values, filter,
-				                                                             result_offset, result);
-			}
-		}
-	}
-
-private:
-	template <class VALUE_TYPE, class CONVERSION, bool HAS_DEFINES, bool UNSAFE>
-	void PlainTemplatedInternal(ByteBuffer &plain_data, const uint8_t *__restrict defines, const uint64_t num_values,
-	                            const parquet_filter_t *filter, const idx_t result_offset, Vector &result) {
-		const auto result_ptr = FlatVector::GetData<VALUE_TYPE>(result);
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t row_idx = result_offset; row_idx < result_offset + num_values; row_idx++) {
-			if (HAS_DEFINES && defines && defines[row_idx] != max_define) {
-				result_mask.SetInvalid(row_idx);
-			} else if (!filter || filter->test(row_idx)) {
-				result_ptr[row_idx] =
-				    UNSAFE ? CONVERSION::UnsafePlainRead(plain_data, *this) : CONVERSION::PlainRead(plain_data, *this);
-			} else { // there is still some data there that we have to skip over
-				if (UNSAFE) {
-					CONVERSION::UnsafePlainSkip(plain_data, *this);
-				} else {
-					CONVERSION::PlainSkip(plain_data, *this);
-				}
-			}
-		}
-	}
-
-protected:
-	Allocator &GetAllocator();
-	// readers that use the default Read() need to implement those
-	virtual void Plain(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, idx_t num_values, parquet_filter_t *filter,
-	                   idx_t result_offset, Vector &result);
-	// these are nops for most types, but not for strings
-	virtual void PlainReference(shared_ptr<ByteBuffer>, Vector &result);
-
-	virtual void PrepareDeltaLengthByteArray(ResizeableBuffer &buffer);
-	virtual void PrepareDeltaByteArray(ResizeableBuffer &buffer);
-	virtual void DeltaByteArray(uint8_t *defines, idx_t num_values, parquet_filter_t &filter, idx_t result_offset,
-	                            Vector &result);
-
-	// applies any skips that were registered using Skip()
-	virtual void ApplyPendingSkips(idx_t num_values);
-
-	bool HasDefines() const {
-		return max_define > 0;
-	}
-
-	bool HasRepeats() const {
-		return max_repeat > 0;
-	}
-
-protected:
-	const SchemaElement &schema;
-	optional_ptr<const SchemaElement> parent_schema;
-
-	idx_t file_idx;
-	idx_t max_define;
-	idx_t max_repeat;
-
-	ParquetReader &reader;
-	LogicalType type;
-	unique_ptr<Vector> byte_array_data;
-	idx_t byte_array_count = 0;
-
-	idx_t pending_skips = 0;
-
-	virtual void ResetPage();
-
-private:
-	void AllocateBlock(idx_t size);
-	void AllocateCompressed(idx_t size);
-	void PrepareRead(parquet_filter_t &filter);
-	void PreparePage(PageHeader &page_hdr);
-	void PrepareDataPage(PageHeader &page_hdr);
-	void PreparePageV2(PageHeader &page_hdr);
-	void DecompressInternal(CompressionCodec::type codec, const_data_ptr_t src, idx_t src_size, data_ptr_t dst,
-	                        idx_t dst_size);
-	void ConvertDictToSelVec(uint32_t *offsets, uint8_t *defines, parquet_filter_t &filter, idx_t read_now,
-	                         idx_t result_offset);
-	const ColumnChunk *chunk = nullptr;
-
-	TProtocol *protocol;
-	idx_t page_rows_available;
-	idx_t group_rows_available;
-	idx_t chunk_read_offset;
-
-	shared_ptr<ResizeableBuffer> block;
-
-	ResizeableBuffer compressed_buffer;
-	ResizeableBuffer offset_buffer;
-
-	unique_ptr<RleBpDecoder> dict_decoder;
-	unique_ptr<RleBpDecoder> defined_decoder;
-	unique_ptr<RleBpDecoder> repeated_decoder;
-	unique_ptr<DbpDecoder> dbp_decoder;
-	unique_ptr<RleBpDecoder> rle_decoder;
-	unique_ptr<BssDecoder> bss_decoder;
-
-	// dummies for Skip()
-	parquet_filter_t none_filter;
-	ResizeableBuffer dummy_define;
-	ResizeableBuffer dummy_repeat;
-
-	SelectionVector dictionary_selection_vector;
-	idx_t dictionary_size;
-	unique_ptr<Vector> dictionary;
-	string dictionary_id;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (TARGET::TYPE != PhysicalType::INVALID && type.InternalType() != TARGET::TYPE) {
-			throw InternalException("Failed to cast column reader to type - type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (TARGET::TYPE != PhysicalType::INVALID && type.InternalType() != TARGET::TYPE) {
-			throw InternalException("Failed to cast column reader to type - type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/column_writer.hpp b/src/duckdb/extension/parquet/include/column_writer.hpp
deleted file mode 100644
index b27254f74..000000000
--- a/src/duckdb/extension/parquet/include/column_writer.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// column_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#include "parquet_types.h"
-
-namespace duckdb {
-class MemoryStream;
-class ParquetWriter;
-class ColumnWriterPageState;
-class BasicColumnWriterState;
-struct ChildFieldIDs;
-class ResizeableBuffer;
-class ParquetBloomFilter;
-
-class ColumnWriterState {
-public:
-	virtual ~ColumnWriterState();
-
-	unsafe_vector<uint16_t> definition_levels;
-	unsafe_vector<uint16_t> repetition_levels;
-	vector<bool> is_empty;
-	idx_t null_count = 0;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class ColumnWriterStatistics {
-public:
-	virtual ~ColumnWriterStatistics();
-
-	virtual bool HasStats();
-	virtual string GetMin();
-	virtual string GetMax();
-	virtual string GetMinValue();
-	virtual string GetMaxValue();
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class ColumnWriter {
-
-public:
-	ColumnWriter(ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path, idx_t max_repeat,
-	             idx_t max_define, bool can_have_nulls);
-	virtual ~ColumnWriter();
-
-	ParquetWriter &writer;
-	idx_t schema_idx;
-	vector<string> schema_path;
-	idx_t max_repeat;
-	idx_t max_define;
-	bool can_have_nulls;
-
-public:
-	//! Create the column writer for a specific type recursively
-	static unique_ptr<ColumnWriter>
-	CreateWriterRecursive(ClientContext &context, vector<duckdb_parquet::SchemaElement> &schemas, ParquetWriter &writer,
-	                      const LogicalType &type, const string &name, vector<string> schema_path,
-	                      optional_ptr<const ChildFieldIDs> field_ids, idx_t max_repeat = 0, idx_t max_define = 1,
-	                      bool can_have_nulls = true);
-
-	virtual unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) = 0;
-
-	//! indicates whether the write need to analyse the data before preparing it
-	virtual bool HasAnalyze() {
-		return false;
-	}
-
-	virtual void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) {
-		throw NotImplementedException("Writer does not need analysis");
-	}
-
-	//! Called after all data has been passed to Analyze
-	virtual void FinalizeAnalyze(ColumnWriterState &state) {
-		throw NotImplementedException("Writer does not need analysis");
-	}
-
-	virtual void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) = 0;
-
-	virtual void BeginWrite(ColumnWriterState &state) = 0;
-	virtual void Write(ColumnWriterState &state, Vector &vector, idx_t count) = 0;
-	virtual void FinalizeWrite(ColumnWriterState &state) = 0;
-
-protected:
-	void HandleDefineLevels(ColumnWriterState &state, ColumnWriterState *parent, const ValidityMask &validity,
-	                        const idx_t count, const uint16_t define_value, const uint16_t null_value) const;
-	void HandleRepeatLevels(ColumnWriterState &state_p, ColumnWriterState *parent, idx_t count, idx_t max_repeat) const;
-
-	void CompressPage(MemoryStream &temp_writer, size_t &compressed_size, data_ptr_t &compressed_data,
-	                  unique_ptr<data_t[]> &compressed_buf);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/decode_utils.hpp b/src/duckdb/extension/parquet/include/decode_utils.hpp
deleted file mode 100644
index d6c4a854b..000000000
--- a/src/duckdb/extension/parquet/include/decode_utils.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// decode_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bitpacking.hpp"
-#include "resizable_buffer.hpp"
-
-namespace duckdb {
-
-class ParquetDecodeUtils {
-	//===--------------------------------------------------------------------===//
-	// Bitpacking
-	//===--------------------------------------------------------------------===//
-private:
-	static const uint64_t BITPACK_MASKS[];
-	static const uint64_t BITPACK_MASKS_SIZE;
-	static const uint8_t BITPACK_DLEN;
-
-	static void CheckWidth(const uint8_t width) {
-		if (width >= BITPACK_MASKS_SIZE) {
-			throw InvalidInputException("The width (%d) of the bitpacked data exceeds the supported max width (%d), "
-			                            "the file might be corrupted.",
-			                            width, BITPACK_MASKS_SIZE);
-		}
-	}
-
-public:
-	template <class T>
-	static void BitUnpack(ByteBuffer &src, bitpacking_width_t &bitpack_pos, T *dst, idx_t count,
-	                      const bitpacking_width_t width) {
-		CheckWidth(width);
-		const auto mask = BITPACK_MASKS[width];
-		src.available(count * width / BITPACK_DLEN); // check if buffer has enough space available once
-		if (bitpack_pos == 0 && count >= BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE) {
-			idx_t remainder = count % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-			idx_t aligned_count = count - remainder;
-			BitUnpackAlignedInternal(src, dst, aligned_count, width);
-			dst += aligned_count;
-			count = remainder;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto val = (src.unsafe_get<uint8_t>() >> bitpack_pos) & mask;
-			bitpack_pos += width;
-			while (bitpack_pos > BITPACK_DLEN) {
-				src.unsafe_inc(1);
-				val |= (static_cast<T>(src.unsafe_get<uint8_t>())
-				        << static_cast<T>(BITPACK_DLEN - (bitpack_pos - width))) &
-				       mask;
-				bitpack_pos -= BITPACK_DLEN;
-			}
-			dst[i] = val;
-		}
-	}
-
-	template <class T>
-	static void BitPackAligned(T *src, data_ptr_t dst, const idx_t count, const bitpacking_width_t width) {
-		D_ASSERT(width < BITPACK_MASKS_SIZE);
-		D_ASSERT(count % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE == 0);
-		BitpackingPrimitives::PackBuffer<T, true>(dst, src, count, width);
-	}
-
-	template <class T>
-	static void BitUnpackAlignedInternal(ByteBuffer &src, T *dst, const idx_t count, const bitpacking_width_t width) {
-		for (idx_t i = 0; i < count; i += BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE) {
-			const auto next_read = BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE * width / 8;
-
-			// Buffer for alignment
-			T aligned_data[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
-
-			// Copy over to aligned buffer
-			memcpy(aligned_data, src.ptr, next_read);
-
-			// Unpack
-			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(dst), data_ptr_cast(aligned_data), width, true);
-
-			src.unsafe_inc(next_read);
-			dst += BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-		}
-	}
-
-	template <class T>
-	static void BitUnpackAligned(ByteBuffer &src, T *dst, const idx_t count, const bitpacking_width_t width) {
-		CheckWidth(width);
-		if (count % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE != 0) {
-			throw InvalidInputException("Aligned bitpacking count must be a multiple of %llu",
-			                            BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE);
-		}
-		const auto read_size = count * width / BITPACK_DLEN;
-		src.available(read_size); // check if buffer has enough space available once
-		BitUnpackAlignedInternal(src, dst, count, width);
-	}
-
-	//===--------------------------------------------------------------------===//
-	// Zigzag
-	//===--------------------------------------------------------------------===//
-private:
-	//! https://lemire.me/blog/2022/11/25/making-all-your-integers-positive-with-zigzag-encoding/
-	template <class UNSIGNED>
-	static typename std::enable_if<std::is_unsigned<UNSIGNED>::value, typename std::make_signed<UNSIGNED>::type>::type
-	ZigzagToIntInternal(UNSIGNED x) {
-		return (x >> 1) ^ (-(x & 1));
-	}
-
-	template <typename SIGNED>
-	static typename std::enable_if<std::is_signed<SIGNED>::value, typename std::make_unsigned<SIGNED>::type>::type
-	IntToZigzagInternal(SIGNED x) {
-		using UNSIGNED = typename std::make_unsigned<SIGNED>::type;
-		return (static_cast<UNSIGNED>(x) << 1) ^ static_cast<UNSIGNED>(x >> (sizeof(SIGNED) * 8 - 1));
-	}
-
-public:
-	template <class UNSIGNED>
-	static typename std::enable_if<std::is_unsigned<UNSIGNED>::value, typename std::make_signed<UNSIGNED>::type>::type
-	ZigzagToInt(UNSIGNED x) {
-		auto integer = ZigzagToIntInternal(x);
-		D_ASSERT(x == IntToZigzagInternal(integer)); // test roundtrip
-		return integer;
-	}
-
-	template <typename SIGNED>
-	static typename std::enable_if<std::is_signed<SIGNED>::value, typename std::make_unsigned<SIGNED>::type>::type
-	IntToZigzag(SIGNED x) {
-		auto zigzag = IntToZigzagInternal(x);
-		D_ASSERT(x == ZigzagToIntInternal(zigzag)); // test roundtrip
-		return zigzag;
-	}
-
-	//===--------------------------------------------------------------------===//
-	// Varint
-	//===--------------------------------------------------------------------===//
-public:
-	template <class T>
-	static uint8_t GetVarintSize(T val) {
-		uint8_t res = 0;
-		do {
-			val >>= 7;
-			res++;
-		} while (val != 0);
-		return res;
-	}
-
-	template <class T>
-	static void VarintEncode(T val, WriteStream &ser) {
-		do {
-			uint8_t byte = val & 127;
-			val >>= 7;
-			if (val != 0) {
-				byte |= 128;
-			}
-			ser.Write<uint8_t>(byte);
-		} while (val != 0);
-	}
-
-	template <class T>
-	static T VarintDecode(ByteBuffer &buf) {
-		T result = 0;
-		uint8_t shift = 0;
-		while (true) {
-			auto byte = buf.read<uint8_t>();
-			result |= T(byte & 127) << shift;
-			if ((byte & 128) == 0) {
-				break;
-			}
-			shift += 7;
-			if (shift > sizeof(T) * 8) {
-				throw std::runtime_error("Varint-decoding found too large number");
-			}
-		}
-		return result;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/expression_column_reader.hpp b/src/duckdb/extension/parquet/include/expression_column_reader.hpp
deleted file mode 100644
index c94a816d3..000000000
--- a/src/duckdb/extension/parquet/include/expression_column_reader.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// expression_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-//! A column reader that executes an expression over a child reader
-class ExpressionColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::INVALID;
-
-public:
-	ExpressionColumnReader(ClientContext &context, unique_ptr<ColumnReader> child_reader, unique_ptr<Expression> expr);
-
-	unique_ptr<ColumnReader> child_reader;
-	DataChunk intermediate_chunk;
-	unique_ptr<Expression> expr;
-	ExpressionExecutor executor;
-
-public:
-	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) override;
-	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
-
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-	           Vector &result) override;
-
-	void Skip(idx_t num_values) override;
-	idx_t GroupRowsAvailable() override;
-
-	uint64_t TotalCompressedSize() override {
-		return child_reader->TotalCompressedSize();
-	}
-
-	idx_t FileOffset() const override {
-		return child_reader->FileOffset();
-	}
-
-	void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) override {
-		child_reader->RegisterPrefetch(transport, allow_merge);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/geo_parquet.hpp b/src/duckdb/extension/parquet/include/geo_parquet.hpp
deleted file mode 100644
index 0a9b0966f..000000000
--- a/src/duckdb/extension/parquet/include/geo_parquet.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// geo_parquet.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_writer.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "parquet_types.h"
-
-namespace duckdb {
-
-enum class WKBGeometryType : uint16_t {
-	POINT = 1,
-	LINESTRING = 2,
-	POLYGON = 3,
-	MULTIPOINT = 4,
-	MULTILINESTRING = 5,
-	MULTIPOLYGON = 6,
-	GEOMETRYCOLLECTION = 7,
-
-	POINT_Z = 1001,
-	LINESTRING_Z = 1002,
-	POLYGON_Z = 1003,
-	MULTIPOINT_Z = 1004,
-	MULTILINESTRING_Z = 1005,
-	MULTIPOLYGON_Z = 1006,
-	GEOMETRYCOLLECTION_Z = 1007,
-};
-
-struct WKBGeometryTypes {
-	static const char *ToString(WKBGeometryType type);
-};
-
-struct GeometryBounds {
-	double min_x = NumericLimits<double>::Maximum();
-	double max_x = NumericLimits<double>::Minimum();
-	double min_y = NumericLimits<double>::Maximum();
-	double max_y = NumericLimits<double>::Minimum();
-
-	GeometryBounds() = default;
-
-	void Combine(const GeometryBounds &other) {
-		min_x = std::min(min_x, other.min_x);
-		max_x = std::max(max_x, other.max_x);
-		min_y = std::min(min_y, other.min_y);
-		max_y = std::max(max_y, other.max_y);
-	}
-
-	void Combine(const double &x, const double &y) {
-		min_x = std::min(min_x, x);
-		max_x = std::max(max_x, x);
-		min_y = std::min(min_y, y);
-		max_y = std::max(max_y, y);
-	}
-
-	void Combine(const double &min_x, const double &max_x, const double &min_y, const double &max_y) {
-		this->min_x = std::min(this->min_x, min_x);
-		this->max_x = std::max(this->max_x, max_x);
-		this->min_y = std::min(this->min_y, min_y);
-		this->max_y = std::max(this->max_y, max_y);
-	}
-};
-
-//------------------------------------------------------------------------------
-// GeoParquetMetadata
-//------------------------------------------------------------------------------
-class ParquetReader;
-class ColumnReader;
-class ClientContext;
-class ExpressionExecutor;
-
-enum class GeoParquetColumnEncoding : uint8_t {
-	WKB = 1,
-	POINT,
-	LINESTRING,
-	POLYGON,
-	MULTIPOINT,
-	MULTILINESTRING,
-	MULTIPOLYGON,
-};
-
-struct GeoParquetColumnMetadata {
-	// The encoding of the geometry column
-	GeoParquetColumnEncoding geometry_encoding;
-
-	// The geometry types that are present in the column
-	set<WKBGeometryType> geometry_types;
-
-	// The bounds of the geometry column
-	GeometryBounds bbox;
-
-	// The crs of the geometry column (if any) in PROJJSON format
-	string projjson;
-};
-
-class GeoParquetColumnMetadataWriter {
-	unique_ptr<ExpressionExecutor> executor;
-	DataChunk input_chunk;
-	DataChunk result_chunk;
-
-	unique_ptr<Expression> type_expr;
-	unique_ptr<Expression> flag_expr;
-	unique_ptr<Expression> bbox_expr;
-
-public:
-	explicit GeoParquetColumnMetadataWriter(ClientContext &context);
-	void Update(GeoParquetColumnMetadata &meta, Vector &vector, idx_t count);
-};
-
-class GeoParquetFileMetadata {
-public:
-	// Try to read GeoParquet metadata. Returns nullptr if not found, invalid or the required spatial extension is not
-	// available.
-
-	static unique_ptr<GeoParquetFileMetadata> TryRead(const duckdb_parquet::FileMetaData &file_meta_data,
-	                                                  const ClientContext &context);
-	void Write(duckdb_parquet::FileMetaData &file_meta_data) const;
-
-	void FlushColumnMeta(const string &column_name, const GeoParquetColumnMetadata &meta);
-	const unordered_map<string, GeoParquetColumnMetadata> &GetColumnMeta() const;
-
-	unique_ptr<ColumnReader> CreateColumnReader(ParquetReader &reader, const LogicalType &logical_type,
-	                                            const duckdb_parquet::SchemaElement &s_ele, idx_t schema_idx_p,
-	                                            idx_t max_define_p, idx_t max_repeat_p, ClientContext &context);
-
-	bool IsGeometryColumn(const string &column_name) const;
-	void RegisterGeometryColumn(const string &column_name);
-
-	static bool IsGeoParquetConversionEnabled(const ClientContext &context);
-
-private:
-	mutex write_lock;
-	string version = "1.1.0";
-	string primary_geometry_column;
-	unordered_map<string, GeoParquetColumnMetadata> geometry_columns;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/list_column_reader.hpp b/src/duckdb/extension/parquet/include/list_column_reader.hpp
deleted file mode 100644
index 67565dfbf..000000000
--- a/src/duckdb/extension/parquet/include/list_column_reader.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// list_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-class ListColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::LIST;
-
-public:
-	ListColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                 idx_t max_define_p, idx_t max_repeat_p, unique_ptr<ColumnReader> child_column_reader_p);
-
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-	           Vector &result_out) override;
-
-	void ApplyPendingSkips(idx_t num_values) override;
-
-	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override {
-		child_column_reader->InitializeRead(row_group_idx_p, columns, protocol_p);
-	}
-
-	idx_t GroupRowsAvailable() override {
-		return child_column_reader->GroupRowsAvailable() + overflow_child_count;
-	}
-
-	uint64_t TotalCompressedSize() override {
-		return child_column_reader->TotalCompressedSize();
-	}
-
-	void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) override {
-		child_column_reader->RegisterPrefetch(transport, allow_merge);
-	}
-
-private:
-	unique_ptr<ColumnReader> child_column_reader;
-	ResizeableBuffer child_defines;
-	ResizeableBuffer child_repeats;
-	uint8_t *child_defines_ptr;
-	uint8_t *child_repeats_ptr;
-
-	VectorCache read_cache;
-	Vector read_vector;
-
-	parquet_filter_t child_filter;
-
-	idx_t overflow_child_count;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/null_column_reader.hpp b/src/duckdb/extension/parquet/include/null_column_reader.hpp
deleted file mode 100644
index 6d89c906b..000000000
--- a/src/duckdb/extension/parquet/include/null_column_reader.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// null_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-class NullColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::INVALID;
-
-public:
-	NullColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                 idx_t max_define_p, idx_t max_repeat_p)
-	    : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p) {};
-
-	shared_ptr<ResizeableBuffer> dict;
-
-public:
-	void Plain(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, uint64_t num_values, parquet_filter_t *filter,
-	           idx_t result_offset, Vector &result) override {
-		(void)defines;
-		(void)plain_data;
-		(void)filter;
-
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t row_idx = 0; row_idx < num_values; row_idx++) {
-			result_mask.SetInvalid(row_idx + result_offset);
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_bss_decoder.hpp b/src/duckdb/extension/parquet/include/parquet_bss_decoder.hpp
deleted file mode 100644
index b8cd8d11c..000000000
--- a/src/duckdb/extension/parquet/include/parquet_bss_decoder.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_bss_decoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-#include "parquet_types.h"
-#include "resizable_buffer.hpp"
-
-namespace duckdb {
-
-/// Decoder for the Byte Stream Split encoding
-class BssDecoder {
-public:
-	/// Create a decoder object. buffer/buffer_len is the encoded data.
-	BssDecoder(data_ptr_t buffer, uint32_t buffer_len) : buffer_(buffer, buffer_len), value_offset_(0) {
-	}
-
-public:
-	template <typename T>
-	void GetBatch(data_ptr_t values_target_ptr, uint32_t batch_size) {
-		if (buffer_.len % sizeof(T) != 0) {
-			std::stringstream error;
-			error << "Data buffer size for the BYTE_STREAM_SPLIT encoding (" << buffer_.len
-			      << ") should be a multiple of the type size (" << sizeof(T) << ")";
-			throw std::runtime_error(error.str());
-		}
-		uint32_t num_buffer_values = buffer_.len / sizeof(T);
-
-		buffer_.available((value_offset_ + batch_size) * sizeof(T));
-
-		for (uint32_t byte_offset = 0; byte_offset < sizeof(T); ++byte_offset) {
-			data_ptr_t input_bytes = buffer_.ptr + byte_offset * num_buffer_values + value_offset_;
-			for (uint32_t i = 0; i < batch_size; ++i) {
-				values_target_ptr[byte_offset + i * sizeof(T)] = *(input_bytes + i);
-			}
-		}
-		value_offset_ += batch_size;
-	}
-
-private:
-	ByteBuffer buffer_;
-	uint32_t value_offset_;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp b/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp
deleted file mode 100644
index 80da1726d..000000000
--- a/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_bss_encoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "decode_utils.hpp"
-
-namespace duckdb {
-
-class BssEncoder {
-public:
-	explicit BssEncoder(const idx_t total_value_count_p, const idx_t bit_width_p)
-	    : total_value_count(total_value_count_p), bit_width(bit_width_p), count(0),
-	      buffer(Allocator::DefaultAllocator().Allocate(total_value_count * bit_width + 1)) {
-	}
-
-public:
-	template <class T>
-	void WriteValue(const T &value) {
-		D_ASSERT(sizeof(T) == bit_width);
-		for (idx_t i = 0; i < sizeof(T); i++) {
-			buffer.get()[i * total_value_count + count] = reinterpret_cast<const_data_ptr_t>(&value)[i];
-		}
-		count++;
-	}
-
-	void FinishWrite(WriteStream &writer) {
-		D_ASSERT(count == total_value_count);
-		writer.WriteData(buffer.get(), total_value_count * bit_width);
-	}
-
-private:
-	const idx_t total_value_count;
-	const idx_t bit_width;
-
-	idx_t count;
-	AllocatedData buffer;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_crypto.hpp b/src/duckdb/extension/parquet/include/parquet_crypto.hpp
deleted file mode 100644
index 470648446..000000000
--- a/src/duckdb/extension/parquet/include/parquet_crypto.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_crypto.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "parquet_types.h"
-#include "duckdb/common/encryption_state.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/storage/object_cache.hpp"
-#endif
-
-namespace duckdb {
-
-using duckdb_apache::thrift::TBase;
-using duckdb_apache::thrift::protocol::TProtocol;
-
-class BufferedFileWriter;
-
-class ParquetKeys : public ObjectCacheEntry {
-public:
-	static ParquetKeys &Get(ClientContext &context);
-
-public:
-	void AddKey(const string &key_name, const string &key);
-	bool HasKey(const string &key_name) const;
-	const string &GetKey(const string &key_name) const;
-
-public:
-	static string ObjectType();
-	string GetObjectType() override;
-
-private:
-	unordered_map<string, string> keys;
-};
-
-class ParquetEncryptionConfig {
-public:
-	explicit ParquetEncryptionConfig(ClientContext &context);
-	ParquetEncryptionConfig(ClientContext &context, const Value &arg);
-
-public:
-	static shared_ptr<ParquetEncryptionConfig> Create(ClientContext &context, const Value &arg);
-	const string &GetFooterKey() const;
-
-public:
-	void Serialize(Serializer &serializer) const;
-	static shared_ptr<ParquetEncryptionConfig> Deserialize(Deserializer &deserializer);
-
-private:
-	ClientContext &context;
-	//! Name of the key used for the footer
-	string footer_key;
-	//! Mapping from column name to key name
-	unordered_map<string, string> column_keys;
-};
-
-class ParquetCrypto {
-public:
-	//! Encrypted modules
-	static constexpr idx_t LENGTH_BYTES = 4;
-	static constexpr idx_t NONCE_BYTES = 12;
-	static constexpr idx_t TAG_BYTES = 16;
-
-	//! Block size we encrypt/decrypt
-	static constexpr idx_t CRYPTO_BLOCK_SIZE = 4096;
-	static constexpr idx_t BLOCK_SIZE = 16;
-
-public:
-	//! Decrypt and read a Thrift object from the transport protocol
-	static uint32_t Read(TBase &object, TProtocol &iprot, const string &key, const EncryptionUtil &encryption_util_p);
-	//! Encrypt and write a Thrift object to the transport protocol
-	static uint32_t Write(const TBase &object, TProtocol &oprot, const string &key,
-	                      const EncryptionUtil &encryption_util_p);
-	//! Decrypt and read a buffer
-	static uint32_t ReadData(TProtocol &iprot, const data_ptr_t buffer, const uint32_t buffer_size, const string &key,
-	                         const EncryptionUtil &encryption_util_p);
-	//! Encrypt and write a buffer to a file
-	static uint32_t WriteData(TProtocol &oprot, const const_data_ptr_t buffer, const uint32_t buffer_size,
-	                          const string &key, const EncryptionUtil &encryption_util_p);
-
-public:
-	static void AddKey(ClientContext &context, const FunctionParameters &parameters);
-	static bool ValidKey(const std::string &key);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_dbp_decoder.hpp b/src/duckdb/extension/parquet/include/parquet_dbp_decoder.hpp
deleted file mode 100644
index 4925a0ff9..000000000
--- a/src/duckdb/extension/parquet/include/parquet_dbp_decoder.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_dbp_deccoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "decode_utils.hpp"
-
-namespace duckdb {
-
-class DbpDecoder {
-public:
-	DbpDecoder(const data_ptr_t buffer, const uint32_t buffer_len)
-	    : buffer_(buffer, buffer_len),
-	      //<block size in values> <number of miniblocks in a block> <total value count> <first value>
-	      block_size_in_values(ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_)),
-	      number_of_miniblocks_per_block(ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_)),
-	      number_of_values_in_a_miniblock(block_size_in_values / number_of_miniblocks_per_block),
-	      total_value_count(ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_)),
-	      previous_value(ParquetDecodeUtils::ZigzagToInt(ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_))),
-	      // init state to something sane
-	      is_first_value(true), read_values(0), min_delta(NumericLimits<int64_t>::Maximum()),
-	      miniblock_index(number_of_miniblocks_per_block - 1), list_of_bitwidths_of_miniblocks(nullptr),
-	      miniblock_offset(number_of_values_in_a_miniblock),
-	      unpacked_data_offset(BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE) {
-		if (!(block_size_in_values % number_of_miniblocks_per_block == 0 &&
-		      number_of_values_in_a_miniblock % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE == 0)) {
-			throw InvalidInputException("Parquet file has invalid block sizes for DELTA_BINARY_PACKED");
-		}
-	};
-
-	ByteBuffer BufferPtr() const {
-		return buffer_;
-	}
-
-	uint64_t TotalValues() const {
-		return total_value_count;
-	}
-
-	template <typename T>
-	void GetBatch(const data_ptr_t target_values_ptr, const idx_t batch_size) {
-		if (read_values + batch_size > total_value_count) {
-			throw std::runtime_error("DBP decode did not find enough values");
-		}
-		read_values += batch_size;
-		GetBatchInternal<T>(target_values_ptr, batch_size);
-	}
-
-	void Finalize() {
-		if (miniblock_offset == number_of_values_in_a_miniblock) {
-			return;
-		}
-		auto data = make_unsafe_uniq_array<int64_t>(number_of_values_in_a_miniblock);
-		GetBatchInternal<int64_t>(data_ptr_cast(data.get()), number_of_values_in_a_miniblock - miniblock_offset);
-	}
-
-private:
-	template <typename T>
-	void GetBatchInternal(const data_ptr_t target_values_ptr, const idx_t batch_size) {
-		if (batch_size == 0) {
-			return;
-		}
-
-		auto target_values = reinterpret_cast<T *>(target_values_ptr);
-		idx_t target_values_offset = 0;
-		if (is_first_value) {
-			target_values[0] = static_cast<T>(previous_value);
-			target_values_offset++;
-			is_first_value = false;
-		}
-
-		while (target_values_offset < batch_size) {
-			// Copy over any remaining data
-			const idx_t next = MinValue(batch_size - target_values_offset,
-			                            BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - unpacked_data_offset);
-			if (next != 0) {
-				for (idx_t i = 0; i < next; i++) {
-					auto &target = target_values[target_values_offset + i];
-					const auto &unpacked_value = unpacked_data[unpacked_data_offset + i];
-					target = static_cast<T>(static_cast<uint64_t>(previous_value) + static_cast<uint64_t>(min_delta) +
-					                        unpacked_value);
-					previous_value = static_cast<int64_t>(target);
-				}
-				target_values_offset += next;
-				unpacked_data_offset += next;
-				continue;
-			}
-
-			// Move to next miniblock / block
-			D_ASSERT(unpacked_data_offset == BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE);
-			D_ASSERT(miniblock_index < number_of_miniblocks_per_block);
-			D_ASSERT(miniblock_offset <= number_of_values_in_a_miniblock);
-			if (miniblock_offset == number_of_values_in_a_miniblock) {
-				miniblock_offset = 0;
-				if (++miniblock_index == number_of_miniblocks_per_block) {
-					// <min delta> <list of bitwidths of miniblocks> <miniblocks>
-					min_delta = ParquetDecodeUtils::ZigzagToInt(ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_));
-					buffer_.available(number_of_miniblocks_per_block);
-					list_of_bitwidths_of_miniblocks = buffer_.ptr;
-					buffer_.unsafe_inc(number_of_miniblocks_per_block);
-					miniblock_index = 0;
-				}
-			}
-
-			// Unpack from current miniblock
-			ParquetDecodeUtils::BitUnpackAligned(buffer_, unpacked_data,
-			                                     BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE,
-			                                     list_of_bitwidths_of_miniblocks[miniblock_index]);
-			unpacked_data_offset = 0;
-			miniblock_offset += BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-		}
-	}
-
-private:
-	ByteBuffer buffer_;
-	const idx_t block_size_in_values;
-	const idx_t number_of_miniblocks_per_block;
-	const idx_t number_of_values_in_a_miniblock;
-	const idx_t total_value_count;
-	int64_t previous_value;
-
-	bool is_first_value;
-	idx_t read_values;
-
-	//! Block stuff
-	int64_t min_delta;
-	idx_t miniblock_index;
-	bitpacking_width_t *list_of_bitwidths_of_miniblocks;
-	idx_t miniblock_offset;
-	uint64_t unpacked_data[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
-	idx_t unpacked_data_offset;
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_dbp_encoder.hpp b/src/duckdb/extension/parquet/include/parquet_dbp_encoder.hpp
deleted file mode 100644
index 791d10e08..000000000
--- a/src/duckdb/extension/parquet/include/parquet_dbp_encoder.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_dbp_encoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "decode_utils.hpp"
-
-namespace duckdb {
-
-class DbpEncoder {
-private:
-	static constexpr uint64_t BLOCK_SIZE_IN_VALUES = 2048;
-	static constexpr uint64_t NUMBER_OF_MINIBLOCKS_IN_A_BLOCK = 8;
-	static constexpr uint64_t NUMBER_OF_VALUES_IN_A_MINIBLOCK = BLOCK_SIZE_IN_VALUES / NUMBER_OF_MINIBLOCKS_IN_A_BLOCK;
-
-public:
-	explicit DbpEncoder(const idx_t total_value_count_p) : total_value_count(total_value_count_p), count(0) {
-	}
-
-public:
-	void BeginWrite(WriteStream &writer, const int64_t &first_value) {
-		// <block size in values> <number of miniblocks in a block> <total value count> <first value>
-
-		// the block size is a multiple of 128; it is stored as a ULEB128 int
-		ParquetDecodeUtils::VarintEncode(BLOCK_SIZE_IN_VALUES, writer);
-		// the miniblock count per block is a divisor of the block size such that their quotient,
-		// the number of values in a miniblock, is a multiple of 32
-		static_assert(BLOCK_SIZE_IN_VALUES % NUMBER_OF_MINIBLOCKS_IN_A_BLOCK == 0 &&
-		                  NUMBER_OF_VALUES_IN_A_MINIBLOCK % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE == 0,
-		              "invalid block sizes for DELTA_BINARY_PACKED");
-		// it is stored as a ULEB128 int
-		ParquetDecodeUtils::VarintEncode(NUMBER_OF_MINIBLOCKS_IN_A_BLOCK, writer);
-		// the total value count is stored as a ULEB128 int
-		ParquetDecodeUtils::VarintEncode(total_value_count, writer);
-		// the first value is stored as a zigzag ULEB128 int
-		ParquetDecodeUtils::VarintEncode(ParquetDecodeUtils::IntToZigzag(first_value), writer);
-
-		// initialize
-		if (total_value_count != 0) {
-			count++;
-		}
-		previous_value = first_value;
-
-		min_delta = NumericLimits<int64_t>::Maximum();
-		block_count = 0;
-	}
-
-	void WriteValue(WriteStream &writer, const int64_t &value) {
-		// 1. Compute the differences between consecutive elements. For the first element in the block,
-		// use the last element in the previous block or, in the case of the first block,
-		// use the first value of the whole sequence, stored in the header.
-
-		// Subtractions in steps 1) and 2) may incur signed arithmetic overflow,
-		// and so will the corresponding additions when decoding.
-		// Overflow should be allowed and handled as wrapping around in 2’s complement notation
-		// so that the original values are correctly restituted.
-		// This may require explicit care in some programming languages
-		// (for example by doing all arithmetic in the unsigned domain).
-		const auto delta = static_cast<int64_t>(static_cast<uint64_t>(value) - static_cast<uint64_t>(previous_value));
-		previous_value = value;
-		// Compute the frame of reference (the minimum of the deltas in the block).
-		min_delta = MinValue(min_delta, delta);
-		// append. if block is full, write it out
-		data[block_count++] = delta;
-		if (block_count == BLOCK_SIZE_IN_VALUES) {
-			WriteBlock(writer);
-		}
-	}
-
-	void FinishWrite(WriteStream &writer) {
-		if (count + block_count != total_value_count) {
-			throw InternalException("value count mismatch when writing DELTA_BINARY_PACKED");
-		}
-		if (block_count != 0) {
-			WriteBlock(writer);
-		}
-	}
-
-private:
-	void WriteBlock(WriteStream &writer) {
-		D_ASSERT(count + block_count == total_value_count || block_count == BLOCK_SIZE_IN_VALUES);
-		const auto number_of_miniblocks =
-		    (block_count + NUMBER_OF_VALUES_IN_A_MINIBLOCK - 1) / NUMBER_OF_VALUES_IN_A_MINIBLOCK;
-		for (idx_t miniblock_idx = 0; miniblock_idx < number_of_miniblocks; miniblock_idx++) {
-			for (idx_t i = 0; i < NUMBER_OF_VALUES_IN_A_MINIBLOCK; i++) {
-				const idx_t index = miniblock_idx * NUMBER_OF_VALUES_IN_A_MINIBLOCK + i;
-				auto &value = data[index];
-				if (index < block_count) {
-					// 2. Compute the frame of reference (the minimum of the deltas in the block).
-					// Subtract this min delta from all deltas in the block.
-					// This guarantees that all values are non-negative.
-					D_ASSERT(min_delta <= value);
-					value = static_cast<int64_t>(static_cast<uint64_t>(value) - static_cast<uint64_t>(min_delta));
-				} else {
-					// If there are not enough values to fill the last miniblock, we pad the miniblock
-					// so that its length is always the number of values in a full miniblock multiplied by the bit
-					// width. The values of the padding bits should be zero, but readers must accept paddings consisting
-					// of arbitrary bits as well.
-					value = 0;
-				}
-			}
-		}
-
-		for (idx_t miniblock_idx = 0; miniblock_idx < NUMBER_OF_MINIBLOCKS_IN_A_BLOCK; miniblock_idx++) {
-			auto &width = list_of_bitwidths_of_miniblocks[miniblock_idx];
-			if (miniblock_idx < number_of_miniblocks) {
-				const auto src = &data[miniblock_idx * NUMBER_OF_VALUES_IN_A_MINIBLOCK];
-				width = BitpackingPrimitives::MinimumBitWidth(reinterpret_cast<uint64_t *>(src),
-				                                              NUMBER_OF_VALUES_IN_A_MINIBLOCK);
-				D_ASSERT(width <= sizeof(int64_t) * 8);
-			} else {
-				// If, in the last block, less than <number of miniblocks in a block> miniblocks are needed to store the
-				// values, the bytes storing the bit widths of the unneeded miniblocks are still present, their value
-				// should be zero, but readers must accept arbitrary values as well. There are no additional padding
-				// bytes for the miniblock bodies though, as if their bit widths were 0 (regardless of the actual byte
-				// values). The reader knows when to stop reading by keeping track of the number of values read.
-				width = 0;
-			}
-		}
-
-		// 3. Encode the frame of reference (min delta) as a zigzag ULEB128 int
-		// followed by the bit widths of the miniblocks
-		// and the delta values (minus the min delta) bit-packed per miniblock.
-		// <min delta> <list of bitwidths of miniblocks> <miniblocks>
-
-		// the min delta is a zigzag ULEB128 int (we compute a minimum as we need positive integers for bit packing)
-		ParquetDecodeUtils::VarintEncode(ParquetDecodeUtils::IntToZigzag(min_delta), writer);
-		// the bitwidth of each block is stored as a byte
-		writer.WriteData(list_of_bitwidths_of_miniblocks, NUMBER_OF_MINIBLOCKS_IN_A_BLOCK);
-		// each miniblock is a list of bit packed ints according to the bit width stored at the beginning of the block
-		for (idx_t miniblock_idx = 0; miniblock_idx < number_of_miniblocks; miniblock_idx++) {
-			const auto src = &data[miniblock_idx * NUMBER_OF_VALUES_IN_A_MINIBLOCK];
-			const auto &width = list_of_bitwidths_of_miniblocks[miniblock_idx];
-			memset(data_packed, 0, sizeof(data_packed));
-			ParquetDecodeUtils::BitPackAligned(reinterpret_cast<uint64_t *>(src), data_packed,
-			                                   NUMBER_OF_VALUES_IN_A_MINIBLOCK, width);
-			const auto write_size = NUMBER_OF_VALUES_IN_A_MINIBLOCK * width / 8;
-#ifdef DEBUG
-			// immediately verify that unpacking yields the input data
-			int64_t verification_data[NUMBER_OF_VALUES_IN_A_MINIBLOCK];
-			ByteBuffer byte_buffer(data_ptr_cast(data_packed), write_size);
-			bitpacking_width_t bitpack_pos = 0;
-			ParquetDecodeUtils::BitUnpack(byte_buffer, bitpack_pos, verification_data, NUMBER_OF_VALUES_IN_A_MINIBLOCK,
-			                              width);
-			for (idx_t i = 0; i < NUMBER_OF_VALUES_IN_A_MINIBLOCK; i++) {
-				D_ASSERT(src[i] == verification_data[i]);
-			}
-#endif
-			writer.WriteData(data_packed, write_size);
-		}
-
-		count += block_count;
-
-		min_delta = NumericLimits<int64_t>::Maximum();
-		block_count = 0;
-	}
-
-private:
-	//! Overall fields
-	const idx_t total_value_count;
-	idx_t count;
-	int64_t previous_value;
-
-	//! Block-specific fields
-	int64_t min_delta;
-	int64_t data[BLOCK_SIZE_IN_VALUES];
-	idx_t block_count;
-
-	//! Bitpacking fields
-	bitpacking_width_t list_of_bitwidths_of_miniblocks[NUMBER_OF_MINIBLOCKS_IN_A_BLOCK];
-	data_t data_packed[NUMBER_OF_VALUES_IN_A_MINIBLOCK * sizeof(int64_t)];
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_decimal_utils.hpp b/src/duckdb/extension/parquet/include/parquet_decimal_utils.hpp
deleted file mode 100644
index 119ed5672..000000000
--- a/src/duckdb/extension/parquet/include/parquet_decimal_utils.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_decimal_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-class ParquetDecimalUtils {
-public:
-	template <class PHYSICAL_TYPE>
-	static PHYSICAL_TYPE ReadDecimalValue(const_data_ptr_t pointer, idx_t size, const duckdb_parquet::SchemaElement &) {
-		PHYSICAL_TYPE res = 0;
-
-		auto res_ptr = (uint8_t *)&res;
-		bool positive = (*pointer & 0x80) == 0;
-
-		// numbers are stored as two's complement so some muckery is required
-		for (idx_t i = 0; i < MinValue<idx_t>(size, sizeof(PHYSICAL_TYPE)); i++) {
-			auto byte = *(pointer + (size - i - 1));
-			res_ptr[i] = positive ? byte : byte ^ 0xFF;
-		}
-		// Verify that there are only 0s here
-		if (size > sizeof(PHYSICAL_TYPE)) {
-			for (idx_t i = sizeof(PHYSICAL_TYPE); i < size; i++) {
-				auto byte = *(pointer + (size - i - 1));
-				if (!positive) {
-					byte ^= 0xFF;
-				}
-				if (byte != 0) {
-					throw InvalidInputException("Invalid decimal encoding in Parquet file");
-				}
-			}
-		}
-		if (!positive) {
-			res += 1;
-			return -res;
-		}
-		return res;
-	}
-
-	static unique_ptr<ColumnReader> CreateReader(ParquetReader &reader, const LogicalType &type_p,
-	                                             const SchemaElement &schema_p, idx_t file_idx_p, idx_t max_define,
-	                                             idx_t max_repeat);
-};
-
-template <>
-double ParquetDecimalUtils::ReadDecimalValue(const_data_ptr_t pointer, idx_t size,
-                                             const duckdb_parquet::SchemaElement &schema_ele);
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp b/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp
deleted file mode 100644
index b3cd1aa96..000000000
--- a/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_dlba_encoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "parquet_dbp_encoder.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-
-namespace duckdb {
-
-class DlbaEncoder {
-public:
-	DlbaEncoder(const idx_t total_value_count_p, const idx_t total_string_size_p)
-	    : dbp_encoder(total_value_count_p), total_string_size(total_string_size_p),
-	      buffer(Allocator::DefaultAllocator().Allocate(total_string_size + 1)),
-	      stream(make_unsafe_uniq<MemoryStream>(buffer.get(), buffer.GetSize())) {
-	}
-
-public:
-	void BeginWrite(WriteStream &writer, const string_t &first_value) {
-		dbp_encoder.BeginWrite(writer, UnsafeNumericCast<int64_t>(first_value.GetSize()));
-		stream->WriteData(const_data_ptr_cast(first_value.GetData()), first_value.GetSize());
-	}
-
-	void WriteValue(WriteStream &writer, const string_t &value) {
-		dbp_encoder.WriteValue(writer, UnsafeNumericCast<int64_t>(value.GetSize()));
-		stream->WriteData(const_data_ptr_cast(value.GetData()), value.GetSize());
-	}
-
-	void FinishWrite(WriteStream &writer) {
-		D_ASSERT(stream->GetPosition() == total_string_size);
-		dbp_encoder.FinishWrite(writer);
-		writer.WriteData(buffer.get(), total_string_size);
-	}
-
-private:
-	DbpEncoder dbp_encoder;
-	const idx_t total_string_size;
-	AllocatedData buffer;
-	unsafe_unique_ptr<MemoryStream> stream;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_extension.hpp b/src/duckdb/extension/parquet/include/parquet_extension.hpp
deleted file mode 100644
index 413a104b6..000000000
--- a/src/duckdb/extension/parquet/include/parquet_extension.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===/
-
-#pragma once
-
-#include "duckdb.hpp"
-
-namespace duckdb {
-
-class ParquetExtension : public Extension {
-public:
-	void Load(DuckDB &db) override;
-	std::string Name() override;
-	std::string Version() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_file_metadata_cache.hpp b/src/duckdb/extension/parquet/include/parquet_file_metadata_cache.hpp
deleted file mode 100644
index b7373056f..000000000
--- a/src/duckdb/extension/parquet/include/parquet_file_metadata_cache.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_file_metadata_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/storage/object_cache.hpp"
-#include "geo_parquet.hpp"
-#endif
-#include "parquet_types.h"
-namespace duckdb {
-
-//! ParquetFileMetadataCache
-class ParquetFileMetadataCache : public ObjectCacheEntry {
-public:
-	ParquetFileMetadataCache() : metadata(nullptr) {
-	}
-	ParquetFileMetadataCache(unique_ptr<duckdb_parquet::FileMetaData> file_metadata, time_t r_time,
-	                         unique_ptr<GeoParquetFileMetadata> geo_metadata)
-	    : metadata(std::move(file_metadata)), read_time(r_time), geo_metadata(std::move(geo_metadata)) {
-	}
-
-	~ParquetFileMetadataCache() override = default;
-
-	//! Parquet file metadata
-	unique_ptr<const duckdb_parquet::FileMetaData> metadata;
-
-	//! read time
-	time_t read_time;
-
-	//! GeoParquet metadata
-	unique_ptr<GeoParquetFileMetadata> geo_metadata;
-
-public:
-	static string ObjectType() {
-		return "parquet_metadata";
-	}
-
-	string GetObjectType() override {
-		return ObjectType();
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_metadata.hpp b/src/duckdb/extension/parquet/include/parquet_metadata.hpp
deleted file mode 100644
index 09ecd5afa..000000000
--- a/src/duckdb/extension/parquet/include/parquet_metadata.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_metadata.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "parquet_reader.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-class ParquetMetaDataFunction : public TableFunction {
-public:
-	ParquetMetaDataFunction();
-};
-
-class ParquetSchemaFunction : public TableFunction {
-public:
-	ParquetSchemaFunction();
-};
-
-class ParquetKeyValueMetadataFunction : public TableFunction {
-public:
-	ParquetKeyValueMetadataFunction();
-};
-
-class ParquetFileMetadataFunction : public TableFunction {
-public:
-	ParquetFileMetadataFunction();
-};
-
-class ParquetBloomProbeFunction : public TableFunction {
-public:
-	ParquetBloomProbeFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_reader.hpp b/src/duckdb/extension/parquet/include/parquet_reader.hpp
deleted file mode 100644
index 79de2b4cc..000000000
--- a/src/duckdb/extension/parquet/include/parquet_reader.hpp
+++ /dev/null
@@ -1,226 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/encryption_state.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#endif
-#include "column_reader.hpp"
-#include "parquet_file_metadata_cache.hpp"
-#include "parquet_rle_bp_decoder.hpp"
-#include "parquet_types.h"
-#include "resizable_buffer.hpp"
-
-#include <exception>
-
-namespace duckdb_parquet {
-namespace format {
-class FileMetaData;
-}
-} // namespace duckdb_parquet
-
-namespace duckdb {
-class Allocator;
-class ClientContext;
-class BaseStatistics;
-class TableFilterSet;
-class ParquetEncryptionConfig;
-
-struct ParquetReaderPrefetchConfig {
-	// Percentage of data in a row group span that should be scanned for enabling whole group prefetch
-	static constexpr double WHOLE_GROUP_PREFETCH_MINIMUM_SCAN = 0.95;
-};
-
-struct ParquetReaderScanState {
-	vector<idx_t> group_idx_list;
-	int64_t current_group;
-	idx_t group_offset;
-	unique_ptr<FileHandle> file_handle;
-	unique_ptr<ColumnReader> root_reader;
-	std::unique_ptr<duckdb_apache::thrift::protocol::TProtocol> thrift_file_proto;
-
-	bool finished;
-	SelectionVector sel;
-
-	ResizeableBuffer define_buf;
-	ResizeableBuffer repeat_buf;
-
-	bool prefetch_mode = false;
-	bool current_group_prefetched = false;
-};
-
-struct ParquetColumnDefinition {
-public:
-	static ParquetColumnDefinition FromSchemaValue(ClientContext &context, const Value &column_value);
-
-public:
-	int32_t field_id;
-	string name;
-	LogicalType type;
-	Value default_value;
-
-public:
-	void Serialize(Serializer &serializer) const;
-	static ParquetColumnDefinition Deserialize(Deserializer &deserializer);
-};
-
-struct ParquetOptions {
-	explicit ParquetOptions() {
-	}
-	explicit ParquetOptions(ClientContext &context);
-
-	bool binary_as_string = false;
-	bool file_row_number = false;
-	shared_ptr<ParquetEncryptionConfig> encryption_config;
-	bool debug_use_openssl = true;
-
-	MultiFileReaderOptions file_options;
-	vector<ParquetColumnDefinition> schema;
-	idx_t explicit_cardinality = 0;
-
-public:
-	void Serialize(Serializer &serializer) const;
-	static ParquetOptions Deserialize(Deserializer &deserializer);
-};
-
-struct ParquetUnionData {
-	~ParquetUnionData();
-
-	string file_name;
-	vector<string> names;
-	vector<LogicalType> types;
-	ParquetOptions options;
-	shared_ptr<ParquetFileMetadataCache> metadata;
-	unique_ptr<ParquetReader> reader;
-
-	const string &GetFileName() {
-		return file_name;
-	}
-};
-
-class ParquetReader {
-public:
-	using UNION_READER_DATA = unique_ptr<ParquetUnionData>;
-
-public:
-	ParquetReader(ClientContext &context, string file_name, ParquetOptions parquet_options,
-	              shared_ptr<ParquetFileMetadataCache> metadata = nullptr);
-	~ParquetReader();
-
-	FileSystem &fs;
-	Allocator &allocator;
-	string file_name;
-	vector<LogicalType> return_types;
-	vector<string> names;
-	shared_ptr<ParquetFileMetadataCache> metadata;
-	ParquetOptions parquet_options;
-	MultiFileReaderData reader_data;
-	unique_ptr<ColumnReader> root_reader;
-	shared_ptr<EncryptionUtil> encryption_util;
-
-	//! Index of the file_row_number column
-	idx_t file_row_number_idx = DConstants::INVALID_INDEX;
-	//! Parquet schema for the generated columns
-	vector<duckdb_parquet::SchemaElement> generated_column_schema;
-	//! Table column names - set when using COPY tbl FROM file.parquet
-	vector<string> table_columns;
-
-public:
-	void InitializeScan(ClientContext &context, ParquetReaderScanState &state, vector<idx_t> groups_to_read);
-	void Scan(ParquetReaderScanState &state, DataChunk &output);
-
-	static unique_ptr<ParquetUnionData> StoreUnionReader(unique_ptr<ParquetReader> reader_p, idx_t file_idx) {
-		auto result = make_uniq<ParquetUnionData>();
-		result->file_name = reader_p->file_name;
-		if (file_idx == 0) {
-			result->names = reader_p->names;
-			result->types = reader_p->return_types;
-			result->options = reader_p->parquet_options;
-			result->metadata = reader_p->metadata;
-			result->reader = std::move(reader_p);
-		} else {
-			result->names = std::move(reader_p->names);
-			result->types = std::move(reader_p->return_types);
-			result->options = std::move(reader_p->parquet_options);
-			result->metadata = std::move(reader_p->metadata);
-		}
-		return result;
-	}
-
-	idx_t NumRows();
-	idx_t NumRowGroups();
-
-	const duckdb_parquet::FileMetaData *GetFileMetadata();
-
-	uint32_t Read(duckdb_apache::thrift::TBase &object, TProtocol &iprot);
-	uint32_t ReadData(duckdb_apache::thrift::protocol::TProtocol &iprot, const data_ptr_t buffer,
-	                  const uint32_t buffer_size);
-
-	unique_ptr<BaseStatistics> ReadStatistics(const string &name);
-	static LogicalType DeriveLogicalType(const SchemaElement &s_ele, bool binary_as_string);
-
-	FileHandle &GetHandle() {
-		return *file_handle;
-	}
-
-	const string &GetFileName() {
-		return file_name;
-	}
-	const vector<string> &GetNames() {
-		return names;
-	}
-	const vector<LogicalType> &GetTypes() {
-		return return_types;
-	}
-
-	static unique_ptr<BaseStatistics> ReadStatistics(ClientContext &context, ParquetOptions parquet_options,
-	                                                 shared_ptr<ParquetFileMetadataCache> metadata, const string &name);
-
-private:
-	//! Construct a parquet reader but **do not** open a file, used in ReadStatistics only
-	ParquetReader(ClientContext &context, ParquetOptions parquet_options,
-	              shared_ptr<ParquetFileMetadataCache> metadata);
-
-	void InitializeSchema(ClientContext &context);
-	bool ScanInternal(ParquetReaderScanState &state, DataChunk &output);
-	unique_ptr<ColumnReader> CreateReader(ClientContext &context);
-
-	unique_ptr<ColumnReader> CreateReaderRecursive(ClientContext &context, const vector<ColumnIndex> &indexes,
-	                                               idx_t depth, idx_t max_define, idx_t max_repeat,
-	                                               idx_t &next_schema_idx, idx_t &next_file_idx);
-	const duckdb_parquet::RowGroup &GetGroup(ParquetReaderScanState &state);
-	uint64_t GetGroupCompressedSize(ParquetReaderScanState &state);
-	idx_t GetGroupOffset(ParquetReaderScanState &state);
-	// Group span is the distance between the min page offset and the max page offset plus the max page compressed size
-	uint64_t GetGroupSpan(ParquetReaderScanState &state);
-	void PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t out_col_idx);
-	LogicalType DeriveLogicalType(const SchemaElement &s_ele);
-
-	template <typename... Args>
-	std::runtime_error FormatException(const string fmt_str, Args... params) {
-		return std::runtime_error("Failed to read Parquet file \"" + file_name +
-		                          "\": " + StringUtil::Format(fmt_str, params...));
-	}
-
-private:
-	unique_ptr<FileHandle> file_handle;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_rle_bp_decoder.hpp b/src/duckdb/extension/parquet/include/parquet_rle_bp_decoder.hpp
deleted file mode 100644
index b8dc35b35..000000000
--- a/src/duckdb/extension/parquet/include/parquet_rle_bp_decoder.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_rle_bp_decoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-#include "decode_utils.hpp"
-#include "parquet_types.h"
-#include "resizable_buffer.hpp"
-#include "thrift_tools.hpp"
-
-namespace duckdb {
-
-class RleBpDecoder {
-public:
-	/// Create a decoder object. buffer/buffer_len is the decoded data.
-	/// bit_width is the width of each value (before encoding).
-	RleBpDecoder(data_ptr_t buffer, uint32_t buffer_len, uint32_t bit_width)
-	    : buffer_(buffer, buffer_len), bit_width_(bit_width), current_value_(0), repeat_count_(0), literal_count_(0) {
-		if (bit_width >= 64) {
-			throw std::runtime_error("Decode bit width too large");
-		}
-		byte_encoded_len = ((bit_width_ + 7) / 8);
-		max_val = (uint64_t(1) << bit_width_) - 1;
-	}
-
-	template <typename T>
-	void GetBatch(data_ptr_t values_target_ptr, uint32_t batch_size) {
-		auto values = reinterpret_cast<T *>(values_target_ptr);
-		uint32_t values_read = 0;
-
-		while (values_read < batch_size) {
-			if (repeat_count_ > 0) {
-				int repeat_batch = MinValue(batch_size - values_read, static_cast<uint32_t>(repeat_count_));
-				std::fill_n(values + values_read, repeat_batch, static_cast<T>(current_value_));
-				repeat_count_ -= repeat_batch;
-				values_read += repeat_batch;
-			} else if (literal_count_ > 0) {
-				uint32_t literal_batch = MinValue(batch_size - values_read, static_cast<uint32_t>(literal_count_));
-				ParquetDecodeUtils::BitUnpack<T>(buffer_, bitpack_pos, values + values_read, literal_batch, bit_width_);
-				literal_count_ -= literal_batch;
-				values_read += literal_batch;
-			} else {
-				if (!NextCounts<T>()) {
-					if (values_read != batch_size) {
-						throw std::runtime_error("RLE decode did not find enough values");
-					}
-					return;
-				}
-			}
-		}
-		if (values_read != batch_size) {
-			throw std::runtime_error("RLE decode did not find enough values");
-		}
-	}
-
-	static uint8_t ComputeBitWidth(idx_t val) {
-		if (val == 0) {
-			return 0;
-		}
-		uint8_t ret = 1;
-		while ((((idx_t)1u << (idx_t)ret) - 1) < val) {
-			ret++;
-		}
-		return ret;
-	}
-
-private:
-	ByteBuffer buffer_;
-
-	/// Number of bits needed to encode the value. Must be between 0 and 64.
-	uint32_t bit_width_;
-	uint64_t current_value_;
-	uint32_t repeat_count_;
-	uint32_t literal_count_;
-	uint8_t byte_encoded_len;
-	uint64_t max_val;
-
-	uint8_t bitpack_pos = 0;
-
-	/// Fills literal_count_ and repeat_count_ with next values. Returns false if there
-	/// are no more.
-	template <typename T>
-	bool NextCounts() {
-		// Read the next run's indicator int, it could be a literal or repeated run.
-		// The int is encoded as a vlq-encoded value.
-		if (bitpack_pos != 0) {
-			buffer_.inc(1);
-			bitpack_pos = 0;
-		}
-		auto indicator_value = ParquetDecodeUtils::VarintDecode<uint32_t>(buffer_);
-
-		// lsb indicates if it is a literal run or repeated run
-		bool is_literal = indicator_value & 1;
-		if (is_literal) {
-			literal_count_ = (indicator_value >> 1) * 8;
-		} else {
-			repeat_count_ = indicator_value >> 1;
-			// (ARROW-4018) this is not big-endian compatible, lol
-			current_value_ = 0;
-			for (auto i = 0; i < byte_encoded_len; i++) {
-				current_value_ |= (buffer_.read<uint8_t>() << (i * 8));
-			}
-			// sanity check
-			if (repeat_count_ > 0 && current_value_ > max_val) {
-				throw std::runtime_error("Payload value bigger than allowed. Corrupted file?");
-			}
-		}
-		// TODO complain if we run out of buffer
-		return true;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_rle_bp_encoder.hpp b/src/duckdb/extension/parquet/include/parquet_rle_bp_encoder.hpp
deleted file mode 100644
index 029dd06eb..000000000
--- a/src/duckdb/extension/parquet/include/parquet_rle_bp_encoder.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_rle_bp_encoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "parquet_types.h"
-#include "thrift_tools.hpp"
-#include "resizable_buffer.hpp"
-
-namespace duckdb {
-
-class RleBpEncoder {
-public:
-	explicit RleBpEncoder(uint32_t bit_width);
-
-public:
-	//! NOTE: Prepare is only required if a byte count is required BEFORE writing
-	//! This is the case with e.g. writing repetition/definition levels
-	//! If GetByteCount() is not required, prepare can be safely skipped
-	void BeginPrepare(uint32_t first_value);
-	void PrepareValue(uint32_t value);
-	void FinishPrepare();
-
-	void BeginWrite(WriteStream &writer, uint32_t first_value);
-	void WriteValue(WriteStream &writer, uint32_t value);
-	void FinishWrite(WriteStream &writer);
-
-	idx_t GetByteCount();
-
-private:
-	//! meta information
-	uint32_t byte_width;
-	//! RLE run information
-	idx_t byte_count;
-	idx_t run_count;
-	idx_t current_run_count;
-	uint32_t last_value;
-
-private:
-	void FinishRun();
-	void WriteRun(WriteStream &writer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_statistics.hpp b/src/duckdb/extension/parquet/include/parquet_statistics.hpp
deleted file mode 100644
index ad1f939c8..000000000
--- a/src/duckdb/extension/parquet/include/parquet_statistics.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===/
-
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#endif
-#include "parquet_types.h"
-
-namespace duckdb {
-
-using duckdb_parquet::ColumnChunk;
-using duckdb_parquet::SchemaElement;
-
-struct LogicalType;
-class ColumnReader;
-class ResizeableBuffer;
-
-struct ParquetStatisticsUtils {
-
-	static unique_ptr<BaseStatistics> TransformColumnStatistics(const ColumnReader &reader,
-	                                                            const vector<ColumnChunk> &columns);
-
-	static Value ConvertValue(const LogicalType &type, const duckdb_parquet::SchemaElement &schema_ele,
-	                          const std::string &stats);
-
-	static bool BloomFilterSupported(const LogicalTypeId &type_id);
-
-	static bool BloomFilterExcludes(const TableFilter &filter, const duckdb_parquet::ColumnMetaData &column_meta_data,
-	                                duckdb_apache::thrift::protocol::TProtocol &file_proto, Allocator &allocator);
-
-private:
-	static Value ConvertValueInternal(const LogicalType &type, const duckdb_parquet::SchemaElement &schema_ele,
-	                                  const std::string &stats);
-};
-
-class ParquetBloomFilter {
-	static constexpr const idx_t DEFAULT_BLOCK_COUNT = 32; // 4k filter
-
-public:
-	ParquetBloomFilter(idx_t num_entries, double bloom_filter_false_positive_ratio);
-	ParquetBloomFilter(unique_ptr<ResizeableBuffer> data_p);
-	void FilterInsert(uint64_t x);
-	bool FilterCheck(uint64_t x);
-	void Shrink(idx_t new_block_count);
-	double OneRatio();
-	ResizeableBuffer *Get();
-
-private:
-	unique_ptr<ResizeableBuffer> data;
-	idx_t block_count;
-};
-
-// see https://github.com/apache/parquet-format/blob/master/BloomFilter.md
-
-struct ParquetBloomBlock {
-	struct ParquetBloomMaskResult {
-		uint8_t bit_set[8] = {0};
-	};
-
-	uint32_t block[8] = {0};
-
-	static bool check_bit(uint32_t &x, const uint8_t i) {
-		D_ASSERT(i < 32);
-		return (x >> i) & (uint32_t)1;
-	}
-
-	static void set_bit(uint32_t &x, const uint8_t i) {
-		D_ASSERT(i < 32);
-		x |= (uint32_t)1 << i;
-		D_ASSERT(check_bit(x, i));
-	}
-
-	static ParquetBloomMaskResult Mask(uint32_t x) {
-		static const uint32_t parquet_bloom_salt[8] = {0x47b6137bU, 0x44974d91U, 0x8824ad5bU, 0xa2b7289dU,
-		                                               0x705495c7U, 0x2df1424bU, 0x9efc4947U, 0x5c6bfb31U};
-		ParquetBloomMaskResult result;
-		for (idx_t i = 0; i < 8; i++) {
-			result.bit_set[i] = (x * parquet_bloom_salt[i]) >> 27;
-		}
-		return result;
-	}
-
-	static void BlockInsert(ParquetBloomBlock &b, uint32_t x) {
-		auto masked = Mask(x);
-		for (idx_t i = 0; i < 8; i++) {
-			set_bit(b.block[i], masked.bit_set[i]);
-			D_ASSERT(check_bit(b.block[i], masked.bit_set[i]));
-		}
-	}
-
-	static bool BlockCheck(ParquetBloomBlock &b, uint32_t x) {
-		auto masked = Mask(x);
-		for (idx_t i = 0; i < 8; i++) {
-			if (!check_bit(b.block[i], masked.bit_set[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_support.hpp b/src/duckdb/extension/parquet/include/parquet_support.hpp
deleted file mode 100644
index 91c43fcb4..000000000
--- a/src/duckdb/extension/parquet/include/parquet_support.hpp
+++ /dev/null
@@ -1,621 +0,0 @@
-#pragma once
-
-namespace duckdb {
-
-class StripeStreams {
-public:
-	virtual ~StripeStreams() = default;
-
-	/**
-	 * get column selector for current stripe reading session
-	 * @return column selector will hold column projection info
-	 */
-	virtual const dwio::common::ColumnSelector &getColumnSelector() const = 0;
-
-	// Get row reader options
-	virtual const dwio::common::RowReaderOptclass StripeStreams {
-	public:
-		virtual ~StripeStreams() = default;
-
-		/**
-		 * get column selector for current stripe reading session
-		 * @return column selector will hold column projection info
-		 */
-		virtual const dwio::common::ColumnSelector &getColumnSelector() const = 0;
-
-		// Get row reader options
-		virtual const dwio::common::RowReaderOptions &getRowReaderOptions() const = 0;
-
-		/**
-		 * Get the encoding for the given column for this stripe.
-		 */
-		virtual const proto::ColumnEncoding &getEncoding(const EncodingKey &) const = 0;
-
-		/**
-		 * Get the stream for the given column/kind in this stripe.
-		 * @param streamId stream identifier object
-		 * @param throwIfNotFound fail if a stream is required and not found
-		 * @return the new stream
-		 */
-		virtual unique_ptr<SeekableInputStream> getStream(const StreamIdentifier &si, bool throwIfNotFound) const = 0;
-
-		/**
-		 * visit all streams of given node and execute visitor logic
-		 * return number of streams visited
-		 */
-		virtual uint32_t visitStreamsOfNode(uint32_t node, std::function<void(const StreamInformation &)> visitor)
-		    const = 0;
-
-		/**
-		 * Get the value of useVInts for the given column in this stripe.
-		 * Defaults to true.
-		 * @param streamId stream identifier
-		 */
-		virtual bool getUseVInts(const StreamIdentifier &streamId) const = 0;
-
-		/**
-		 * Get the memory pool for this reader.
-		 */
-		virtual memory::MemoryPool &getMemoryPool() const = 0;
-
-		/**
-		 * Get the RowGroupIndex.
-		 * @return a vector of RowIndex belonging to the stripe
-		 */
-		virtual unique_ptr<proto::RowIndex> getRowGroupIndex(const StreamIdentifier &si) const = 0;
-
-		/**
-		 * Get stride index provider which is used by string dictionary reader to
-		 * get the row index stride index where next() happens
-		 */
-		virtual const StrideIndexProvider &getStrideIndexProvider() const = 0;
-	}
-	ions &getRowReaderOptions() const = 0;
-
-	/**
-	 * Get the encoding for the given column for this stripe.
-	 */
-	virtual const proto::ColumnEncoding &getEncoding(const EncodingKey &) const = 0;
-
-	/**
-	 * Get the stream for the given column/kind in this stripe.
-	 * @param streamId stream identifier object
-	 * @param throwIfNotFound fail if a stream is required and not found
-	 * @return the new stream
-	 */
-	virtual unique_ptr<SeekableInputStream> getStream(const StreamIdentifier &si, bool throwIfNotFound) const = 0;
-
-	/**
-	 * visit all streams of given node and execute visitor logic
-	 * return number of streams visited
-	 */
-	virtual uint32_t visitStreamsOfNode(uint32_t node,
-	                                    std::function<void(const StreamInformation &)> visitor) const = 0;
-
-	/**
-	 * Get the value of useVInts for the given column in this stripe.
-	 * Defaults to true.
-	 * @param streamId stream identifier
-	 */
-	virtual bool getUseVInts(const StreamIdentifier &streamId) const = 0;
-
-	/**
-	 * Get the memory pool for this reader.
-	 */
-	virtual memory::MemoryPool &getMemoryPool() const = 0;
-
-	/**
-	 * Get the RowGroupIndex.
-	 * @return a vector of RowIndex belonging to the stripe
-	 */
-	virtual unique_ptr<proto::RowIndex> getRowGroupIndex(const StreamIdentifier &si) const = 0;
-
-	/**
-	 * Get stride index provider which is used by string dictionary reader to
-	 * get the row index stride index where next() happens
-	 */
-	virtual const StrideIndexProvider &getStrideIndexProvider() const = 0;
-};
-
-class ColumnReader {
-
-public:
-	ColumnReader(const EncodingKey &ek, StripeStreams &stripe);
-
-	virtual ~ColumnReader() = default;
-
-	/**
-	 * Skip number of specified rows.
-	 * @param numValues the number of values to skip
-	 * @return the number of non-null values skipped
-	 */
-	virtual uint64_t skip(uint64_t numValues);
-
-	/**
-	 * Read the next group of values into a RowVector.
-	 * @param numValues the number of values to read
-	 * @param vector to read into
-	 */
-	virtual void next(uint64_t numValues, VectorPtr &result, const uint64_t *nulls = nullptr) = 0;
-};
-
-class SelectiveColumnReader : public ColumnReader {
-public:
-	static constexpr uint64_t kStringBufferSize = 16 * 1024;
-
-	SelectiveColumnReader(const EncodingKey &ek, StripeStreams &stripe, common::ScanSpec *scanSpec);
-
-	/**
-	 * Read the next group of values into a RowVector.
-	 * @param numValues the number of values to read
-	 * @param vector to read into
-	 */
-	void next(uint64_t /*numValues*/, VectorPtr & /*result*/, const uint64_t * /*incomingNulls*/) override {
-		DATALIB_CHECK(false) << "next() is only defined in SelectiveStructColumnReader";
-	}
-
-	// Creates a reader for the given stripe.
-	static unique_ptr<SelectiveColumnReader> build(const std::shared_ptr<const dwio::common::TypeWithId> &requestedType,
-	                                               const std::shared_ptr<const dwio::common::TypeWithId> &dataType,
-	                                               StripeStreams &stripe, common::ScanSpec *scanSpec,
-	                                               uint32_t sequence = 0);
-
-	// Seeks to offset and reads the rows in 'rows' and applies
-	// filters and value processing as given by 'scanSpec supplied at
-	// construction. 'offset' is relative to start of stripe. 'rows' are
-	// relative to 'offset', so that row 0 is the 'offset'th row from
-	// start of stripe. 'rows' is expected to stay constant
-	// between this and the next call to read.
-	virtual void read(vector_size_t offset, RowSet rows, const uint64_t *incomingNulls) = 0;
-
-	// Extracts the values at 'rows' into '*result'. May rewrite or
-	// reallocate '*result'. 'rows' must be the same set or a subset of
-	// 'rows' passed to the last 'read().
-	virtual void getValues(RowSet rows, VectorPtr *result) = 0;
-
-	// Returns the rows that were selected/visited by the last
-	// read(). If 'this' has no filter, returns 'rows' passed to last
-	// read().
-	const RowSet outputRows() const {
-		if (scanSpec_->hasFilter()) {
-			return outputRows_;
-		}
-		return inputRows_;
-	}
-
-	// Advances to 'offset', so that the next item to be read is the
-	// offset-th from the start of stripe.
-	void seekTo(vector_size_t offset, bool readsNullsOnly);
-
-	// The below functions are called from ColumnVisitor to fill the result set.
-	inline void addOutputRow(vector_size_t row) {
-		outputRows_.push_back(row);
-	}
-
-	template <typename T>
-	inline void addNull() {
-		DATALIB_DCHECK(rawResultNulls_ && rawValues_ && (numValues_ + 1) * sizeof(T) < rawSize_);
-
-		anyNulls_ = true;
-		bits::setBit(rawResultNulls_, numValues_);
-		reinterpret_cast<T *>(rawValues_)[numValues_] = T();
-		numValues_++;
-	}
-
-	template <typename T>
-	inline void addValue(const T value) {
-		// @lint-ignore-every HOWTOEVEN ConstantArgumentPassByValue
-		static_assert(std::is_pod<T>::value, "General case of addValue is only for primitive types");
-		DATALIB_DCHECK(rawValues_ && (numValues _ + 1) * sizeof(T) < rawSize_);
-		reinterpret_cast<T *>(rawValues_)[numValues_] = value;
-		numValues_++;
-	}
-
-	void dropResults(vector_size_t count) {
-		outputRows_.resize(outputRows_.size() - count);
-		numValues_ -= count;
-	}
-
-	common::ScanSpec *scanSpec() const {
-		return scanSpec_;
-	}
-
-	auto readOffset() const {
-		return readOffset_;
-	}
-
-	void setReadOffset(vector_size_t readOffset) {
-		readOffset_ = readOffset;
-	}
-
-protected:
-	static constexpr int8_t kNoValueSize = -1;
-
-	template <typename T>
-	void ensureValuesCapacity(vector_size_t numRows);
-
-	void prepareNulls(vector_size_t numRows, bool needNulls);
-
-	template <typename T>
-	void filterNulls(RowSet rows, bool isNull, bool extractValues);
-
-	template <typename T>
-	void prepareRead(vector_size_t offset, RowSet rows, const uint64_t *incomingNulls);
-
-	void setOutputRows(RowSet rows) {
-		outputRows_.resize(rows.size());
-		if (!rows.size()) {
-			return;
-		}
-		memcpy(outputRows_.data(), &rows[0], rows.size() * sizeof(vector_size_t));
-	}
-	template <typename T, typename TVector>
-	void getFlatValues(RowSet rows, VectorPtr *result);
-
-	template <typename T, typename TVector>
-	void compactScalarValues(RowSet rows);
-
-	void addStringValue(folly::StringPiece value);
-
-	// Specification of filters, value extraction, pruning etc. The
-	// spec is assigned at construction and the contents may change at
-	// run time based on adaptation. Owned by caller.
-	common::ScanSpec *const scanSpec_;
-	// Row number after last read row, relative to stripe start.
-	vector_size_t readOffset_ = 0;
-	// The rows to process in read(). References memory supplied by
-	// caller. The values must remain live until the next call to read().
-	RowSet inputRows_;
-	// Rows passing the filter in readWithVisitor. Must stay
-	// constant between consecutive calls to read().
-	vector<vector_size_t> outputRows_;
-	// The row number corresponding to each element in 'values_'
-	vector<vector_size_t> valueRows_;
-	// The set of all nulls in the range of read(). Created when first
-	// needed and then reused. Not returned to callers.
-	BufferPtr nullsInReadRange_;
-	// Nulls buffer for readWithVisitor. Not set if no nulls. 'numValues'
-	// is the index of the first non-set bit.
-	BufferPtr resultNulls_;
-	uint64_t *rawResultNulls_ = nullptr;
-	// Buffer for gathering scalar values in readWithVisitor.
-	BufferPtr values_;
-	// Writable content in 'values'
-	void *rawValues_ = nullptr;
-	vector_size_t numValues_ = 0;
-	// Size of fixed width value in 'rawValues'. For integers, values
-	// are read at 64 bit width and can be compacted or extracted at a
-	// different width.
-	int8_t valueSize_ = kNoValueSize;
-	// Buffers backing the StringViews in 'values' when reading strings.
-	vector<BufferPtr> stringBuffers_;
-	// Writable contents of 'stringBuffers_.back()'.
-	char *rawStringBuffer_ = nullptr;
-	// Total writable bytes in 'rawStringBuffer_'.
-	int32_t rawStringSize_ = 0;
-	// Number of written bytes in 'rawStringBuffer_'.
-	uint32_t rawStringUsed_ = 0;
-
-	// True if last read() added any nulls.
-	bool anyNulls_ = false;
-	// True if all values in scope for last read() are null.
-	bool allNull_ = false;
-};
-
-struct ExtractValues {
-	static constexpr bool kSkipNulls = false;
-
-	bool acceptsNulls() const {
-		return true;
-	}
-
-	template <typename V>
-	void addValue(vector_size_t /*rowIndex*/, V /*value*/) {
-	}
-	void addNull(vector_size_t /*rowIndex*/) {
-	}
-};
-
-class Filter {
-protected:
-	Filter(bool deterministic, bool nullAllowed, FilterKind kind)
-	    : nullAllowed_(nullAllowed), deterministic_(deterministic), kind_(kind) {
-	}
-
-public:
-	virtual ~Filter() = default;
-
-	// Templates parametrized on filter need to know determinism at compile
-	// time. If this is false, deterministic() will be consulted at
-	// runtime.
-	static constexpr bool deterministic = true;
-
-	FilterKind kind() const {
-		return kind_;
-	}
-
-	virtual unique_ptr<Filter> clone() const = 0;
-
-	/**
-	 * A filter becomes non-deterministic when applies to nested column,
-	 * e.g. a[1] > 10 is non-deterministic because > 10 filter applies only to
-	 * some positions, e.g. first entry in a set of entries that correspond to a
-	 * single top-level position.
-	 */
-	virtual bool isDeterministic() const {
-		return deterministic_;
-	}
-
-	/**
-	 * When a filter applied to a nested column fails, the whole top-level
-	 * position should fail. To enable this functionality, the filter keeps track
-	 * of the boundaries of top-level positions and allows the caller to find out
-	 * where the current top-level position started and how far it continues.
-	 * @return number of positions from the start of the current top-level
-	 * position up to the current position (excluding current position)
-	 */
-	virtual int getPrecedingPositionsToFail() const {
-		return 0;
-	}
-
-	/**
-	 * @return number of positions remaining until the end of the current
-	 * top-level position
-	 */
-	virtual int getSucceedingPositionsToFail() const {
-		return 0;
-	}
-
-	virtual bool testNull() const {
-		return nullAllowed_;
-	}
-
-	/**
-	 * Used to apply is [not] null filters to complex types, e.g.
-	 * a[1] is null AND a[3] is not null, where a is an array(array(T)).
-	 *
-	 * In these case, the exact values are not known, but it is known whether they
-	 * are null or not. Furthermore, for some positions only nulls are allowed
-	 * (a[1] is null), for others only non-nulls (a[3] is not null), and for the
-	 * rest both are allowed (a[2] and a[N], where N > 3).
-	 */
-	virtual bool testNonNull() const {
-		DWIO_RAISE("not supported");
-	}
-
-	virtual bool testInt64(int64_t /* unused */) const {
-		DWIO_RAISE("not supported");
-	}
-
-	virtual bool testDouble(double /* unused */) const {
-		DWIO_RAISE("not supported");
-	}
-
-	virtual bool testFloat(float /* unused */) const {
-		DWIO_RAISE("not supported");
-	}
-
-	virtual bool testBool(bool /* unused */) const {
-		DWIO_RAISE("not supported");
-	}
-
-	virtual bool testBytes(const char * /* unused */, int32_t /* unused */) const {
-		DWIO_RAISE("not supported");
-	}
-
-	/**
-	 * Filters like string equality and IN, as well as conditions on cardinality
-	 * of lists and maps can be at least partly decided by looking at lengths
-	 * alone. If this is false, then no further checks are needed. If true,
-	 * eventual filters on the data itself need to be evaluated.
-	 */
-	virtual bool testLength(int32_t /* unused */) const {
-		DWIO_RAISE("not supported");
-	}
-
-protected:
-	const bool nullAllowed_;
-
-private:
-	const bool deterministic_;
-	const FilterKind kind_;
-};
-
-// Template parameter for controlling filtering and action on a set of rows.
-template <typename T, typename TFilter, typename ExtractValues, bool isDense>
-class ColumnVisitor {
-public:
-	using FilterType = TFilter;
-	static constexpr bool dense = isDense;
-	ColumnVisitor(TFilter &filter, SelectiveColumnReader *reader, const RowSet &rows, ExtractValues values)
-	    : filter_(filter), reader_(reader), allowNulls_(!TFilter::deterministic || filter.testNull()), rows_(&rows[0]),
-	      numRows_(rows.size()), rowIndex_(0), values_(values) {
-	}
-
-	bool allowNulls() {
-		if (ExtractValues::kSkipNulls && TFilter::deterministic) {
-			return false;
-		}
-		return allowNulls_ && values_.acceptsNulls();
-	}
-
-	vector_size_t start() {
-		return isDense ? 0 : rowAt(0);
-	}
-
-	// Tests for a null value and processes it. If the value is not
-	// null, returns 0 and has no effect. If the value is null, advances
-	// to the next non-null value in 'rows_'. Returns the number of
-	// values (not including nulls) to skip to get to the next non-null.
-	// If there is no next non-null in 'rows_', sets 'atEnd'. If 'atEnd'
-	// is set and a non-zero skip is returned, the caller must perform
-	// the skip before returning.
-	FOLLY_ALWAYS_INLINE vector_size_t checkAndSkipNulls(const uint64_t *nulls, vector_size_t &current, bool &atEnd) {
-		auto testRow = currentRow();
-		// Check that the caller and the visitor are in sync about current row.
-		DATALIB_DCHECK(current == testRow);
-		uint32_t nullIndex = testRow >> 6;
-		uint64_t nullWord = nulls[nullIndex];
-		if (!nullWord) {
-			return 0;
-		}
-		uint8_t nullBit = testRow & 63;
-		if ((nullWord & (1UL << nullBit)) == 0) {
-			return 0;
-		}
-		// We have a null. We find the next non-null.
-		if (++rowIndex_ >= numRows_) {
-			atEnd = true;
-			return 0;
-		}
-		auto rowOfNullWord = testRow - nullBit;
-		if (isDense) {
-			if (nullBit == 63) {
-				nullBit = 0;
-				rowOfNullWord += 64;
-				nullWord = nulls[++nullIndex];
-			} else {
-				++nullBit;
-				// set all the bits below the row to null.
-				nullWord |= f4d::bits::lowMask(nullBit);
-			}
-			for (;;) {
-				auto nextNonNull = count_trailing_zeros(~nullWord);
-				if (rowOfNullWord + nextNonNull >= numRows_) {
-					// Nulls all the way to the end.
-					atEnd = true;
-					return 0;
-				}
-				if (nextNonNull < 64) {
-					DATALIB_CHECK(rowIndex_ <= rowOfNullWord + nextNonNull);
-					rowIndex_ = rowOfNullWord + nextNonNull;
-					current = currentRow();
-					return 0;
-				}
-				rowOfNullWord += 64;
-				nullWord = nulls[++nullIndex];
-			}
-		} else {
-			// Sparse row numbers. We find the first non-null and count
-			// how many non-nulls on rows not in 'rows_' we skipped.
-			int32_t toSkip = 0;
-			nullWord |= f4d::bits::lowMask(nullBit);
-			for (;;) {
-				testRow = currentRow();
-				while (testRow >= rowOfNullWord + 64) {
-					toSkip += __builtin_popcountll(~nullWord);
-					nullWord = nulls[++nullIndex];
-					rowOfNullWord += 64;
-				}
-				// testRow is inside nullWord. See if non-null.
-				nullBit = testRow & 63;
-				if ((nullWord & (1UL << nullBit)) == 0) {
-					toSkip += __builtin_popcountll(~nullWord & f4d::bits::lowMask(nullBit));
-					current = testRow;
-					return toSkip;
-				}
-				if (++rowIndex_ >= numRows_) {
-					// We end with a null. Add the non-nulls below the final null.
-					toSkip += __builtin_popcountll(~nullWord & f4d::bits::lowMask(testRow - rowOfNullWord));
-					atEnd = true;
-					return toSkip;
-				}
-			}
-		}
-	}
-
-	vector_size_t processNull(bool &atEnd) {
-		vector_size_t previous = currentRow();
-		if (filter_.testNull()) {
-			filterPassedForNull();
-		} else {
-			filterFailed();
-		}
-		if (++rowIndex_ >= numRows_) {
-			atEnd = true;
-			return rows_[numRows_ - 1] - previous;
-		}
-		if (TFilter::deterministic && isDense) {
-			return 0;
-		}
-		return currentRow() - previous - 1;
-	}
-
-	FOLLY_ALWAYS_INLINE vector_size_t process(T value, bool &atEnd) {
-		if (!TFilter::deterministic) {
-			auto previous = currentRow();
-			if (common::applyFilter(filter_, value)) {
-				filterPassed(value);
-			} else {
-				filterFailed();
-			}
-			if (++rowIndex_ >= numRows_) {
-				atEnd = true;
-				return rows_[numRows_ - 1] - previous;
-			}
-			return currentRow() - previous - 1;
-		}
-		// The filter passes or fails and we go to the next row if any.
-		if (common::applyFilter(filter_, value)) {
-			filterPassed(value);
-		} else {
-			filterFailed();
-		}
-		if (++rowIndex_ >= numRows_) {
-			atEnd = true;
-			return 0;
-		}
-		if (isDense) {
-			return 0;
-		}
-		return currentRow() - rows_[rowIndex_ - 1] - 1;
-	}
-
-	inline vector_size_t rowAt(vector_size_t index) {
-		if (isDense) {
-			return index;
-		}
-		return rows_[index];
-	}
-
-	vector_size_t currentRow() {
-		if (isDense) {
-			return rowIndex_;
-		}
-		return rows_[rowIndex_];
-	}
-
-	vector_size_t numRows() {
-		return numRows_;
-	}
-
-	void filterPassed(T value) {
-		addResult(value);
-		if (!std::is_same<TFilter, common::AlwaysTrue>::value) {
-			addOutputRow(currentRow());
-		}
-	}
-
-	inline void filterPassedForNull() {
-		addNull();
-		if (!std::is_same<TFilter, common::AlwaysTrue>::value) {
-			addOutputRow(currentRow());
-		}
-	}
-
-	FOLLY_ALWAYS_INLINE void filterFailed();
-	inline void addResult(T value);
-	inline void addNull();
-	inline void addOutputRow(vector_size_t row);
-
-protected:
-	TFilter &filter_;
-	SelectiveColumnReader *reader_;
-	const bool allowNulls_;
-	const vector_size_t *rows_;
-	vector_size_t numRows_;
-	vector_size_t rowIndex_;
-	ExtractValues values_;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_timestamp.hpp b/src/duckdb/extension/parquet/include/parquet_timestamp.hpp
deleted file mode 100644
index 8631af997..000000000
--- a/src/duckdb/extension/parquet/include/parquet_timestamp.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_timestamp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-
-namespace duckdb {
-
-struct Int96 {
-	uint32_t value[3];
-};
-
-timestamp_t ImpalaTimestampToTimestamp(const Int96 &raw_ts);
-timestamp_ns_t ImpalaTimestampToTimestampNS(const Int96 &raw_ts);
-Int96 TimestampToImpalaTimestamp(timestamp_t &ts);
-
-timestamp_t ParquetTimestampMicrosToTimestamp(const int64_t &raw_ts);
-timestamp_t ParquetTimestampMsToTimestamp(const int64_t &raw_ts);
-timestamp_t ParquetTimestampNsToTimestamp(const int64_t &raw_ts);
-
-timestamp_ns_t ParquetTimestampMsToTimestampNs(const int64_t &raw_ms);
-timestamp_ns_t ParquetTimestampUsToTimestampNs(const int64_t &raw_us);
-timestamp_ns_t ParquetTimestampNsToTimestampNs(const int64_t &raw_ns);
-
-date_t ParquetIntToDate(const int32_t &raw_date);
-dtime_t ParquetIntToTimeMs(const int32_t &raw_time);
-dtime_t ParquetIntToTime(const int64_t &raw_time);
-dtime_t ParquetIntToTimeNs(const int64_t &raw_time);
-
-dtime_tz_t ParquetIntToTimeMsTZ(const int32_t &raw_time);
-dtime_tz_t ParquetIntToTimeTZ(const int64_t &raw_time);
-dtime_tz_t ParquetIntToTimeNsTZ(const int64_t &raw_time);
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/parquet_writer.hpp b/src/duckdb/extension/parquet/include/parquet_writer.hpp
deleted file mode 100644
index e601926b2..000000000
--- a/src/duckdb/extension/parquet/include/parquet_writer.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// parquet_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/encryption_state.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/function/copy_function.hpp"
-#endif
-
-#include "parquet_statistics.hpp"
-#include "column_writer.hpp"
-#include "parquet_types.h"
-#include "geo_parquet.hpp"
-#include "thrift/protocol/TCompactProtocol.h"
-
-namespace duckdb {
-class FileSystem;
-class FileOpener;
-class ParquetEncryptionConfig;
-
-class Serializer;
-class Deserializer;
-
-struct PreparedRowGroup {
-	duckdb_parquet::RowGroup row_group;
-	vector<unique_ptr<ColumnWriterState>> states;
-	vector<shared_ptr<StringHeap>> heaps;
-};
-
-struct FieldID;
-struct ChildFieldIDs {
-	ChildFieldIDs();
-	ChildFieldIDs Copy() const;
-	unique_ptr<case_insensitive_map_t<FieldID>> ids;
-
-	void Serialize(Serializer &serializer) const;
-	static ChildFieldIDs Deserialize(Deserializer &source);
-};
-
-struct FieldID {
-	static constexpr const auto DUCKDB_FIELD_ID = "__duckdb_field_id";
-	FieldID();
-	explicit FieldID(int32_t field_id);
-	FieldID Copy() const;
-	bool set;
-	int32_t field_id;
-	ChildFieldIDs child_field_ids;
-
-	void Serialize(Serializer &serializer) const;
-	static FieldID Deserialize(Deserializer &source);
-};
-
-struct ParquetBloomFilterEntry {
-	unique_ptr<ParquetBloomFilter> bloom_filter;
-	idx_t row_group_idx;
-	idx_t column_idx;
-};
-
-class ParquetWriter {
-public:
-	ParquetWriter(ClientContext &context, FileSystem &fs, string file_name, vector<LogicalType> types,
-	              vector<string> names, duckdb_parquet::CompressionCodec::type codec, ChildFieldIDs field_ids,
-	              const vector<pair<string, string>> &kv_metadata,
-	              shared_ptr<ParquetEncryptionConfig> encryption_config, idx_t dictionary_size_limit,
-	              double bloom_filter_false_positive_ratio, int64_t compression_level, bool debug_use_openssl);
-
-public:
-	void PrepareRowGroup(ColumnDataCollection &buffer, PreparedRowGroup &result);
-	void FlushRowGroup(PreparedRowGroup &row_group);
-	void Flush(ColumnDataCollection &buffer);
-	void Finalize();
-
-	static duckdb_parquet::Type::type DuckDBTypeToParquetType(const LogicalType &duckdb_type);
-	static void SetSchemaProperties(const LogicalType &duckdb_type, duckdb_parquet::SchemaElement &schema_ele);
-
-	duckdb_apache::thrift::protocol::TProtocol *GetProtocol() {
-		return protocol.get();
-	}
-	duckdb_parquet::CompressionCodec::type GetCodec() {
-		return codec;
-	}
-	duckdb_parquet::Type::type GetType(idx_t schema_idx) {
-		return file_meta_data.schema[schema_idx].type;
-	}
-	LogicalType GetSQLType(idx_t schema_idx) const {
-		return sql_types[schema_idx];
-	}
-	BufferedFileWriter &GetWriter() {
-		return *writer;
-	}
-	idx_t FileSize() {
-		lock_guard<mutex> glock(lock);
-		return writer->total_written;
-	}
-	idx_t DictionarySizeLimit() const {
-		return dictionary_size_limit;
-	}
-	double BloomFilterFalsePositiveRatio() const {
-		return bloom_filter_false_positive_ratio;
-	}
-	int64_t CompressionLevel() const {
-		return compression_level;
-	}
-	idx_t NumberOfRowGroups() {
-		lock_guard<mutex> glock(lock);
-		return file_meta_data.row_groups.size();
-	}
-
-	uint32_t Write(const duckdb_apache::thrift::TBase &object);
-	uint32_t WriteData(const const_data_ptr_t buffer, const uint32_t buffer_size);
-
-	GeoParquetFileMetadata &GetGeoParquetData();
-
-	static bool TryGetParquetType(const LogicalType &duckdb_type,
-	                              optional_ptr<duckdb_parquet::Type::type> type = nullptr);
-
-	void BufferBloomFilter(idx_t col_idx, unique_ptr<ParquetBloomFilter> bloom_filter);
-
-private:
-	string file_name;
-	vector<LogicalType> sql_types;
-	vector<string> column_names;
-	duckdb_parquet::CompressionCodec::type codec;
-	ChildFieldIDs field_ids;
-	shared_ptr<ParquetEncryptionConfig> encryption_config;
-	idx_t dictionary_size_limit;
-	double bloom_filter_false_positive_ratio;
-	int64_t compression_level;
-	bool debug_use_openssl;
-	shared_ptr<EncryptionUtil> encryption_util;
-
-	unique_ptr<BufferedFileWriter> writer;
-	std::shared_ptr<duckdb_apache::thrift::protocol::TProtocol> protocol;
-	duckdb_parquet::FileMetaData file_meta_data;
-	std::mutex lock;
-
-	vector<unique_ptr<ColumnWriter>> column_writers;
-
-	unique_ptr<GeoParquetFileMetadata> geoparquet_data;
-	vector<ParquetBloomFilterEntry> bloom_filters;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/resizable_buffer.hpp b/src/duckdb/extension/parquet/include/resizable_buffer.hpp
deleted file mode 100644
index 14658ecee..000000000
--- a/src/duckdb/extension/parquet/include/resizable_buffer.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// resizable_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/allocator.hpp"
-#endif
-
-#include <exception>
-
-namespace duckdb {
-
-class ByteBuffer { // on to the 10 thousandth impl
-public:
-	ByteBuffer() {};
-	ByteBuffer(data_ptr_t ptr, uint64_t len) : ptr(ptr), len(len) {};
-
-	data_ptr_t ptr = nullptr;
-	uint64_t len = 0;
-
-public:
-	void inc(const uint64_t increment) {
-		available(increment);
-		unsafe_inc(increment);
-	}
-
-	void unsafe_inc(const uint64_t increment) {
-		len -= increment;
-		ptr += increment;
-	}
-
-	template <class T>
-	T read() {
-		available(sizeof(T));
-		return unsafe_read<T>();
-	}
-
-	template <class T>
-	T unsafe_read() {
-		T val = unsafe_get<T>();
-		unsafe_inc(sizeof(T));
-		return val;
-	}
-
-	template <class T>
-	T get() {
-		available(sizeof(T));
-		return unsafe_get<T>();
-	}
-
-	template <class T>
-	T unsafe_get() {
-		return Load<T>(ptr);
-	}
-
-	void copy_to(char *dest, const uint64_t len) const {
-		available(len);
-		unsafe_copy_to(dest, len);
-	}
-
-	void unsafe_copy_to(char *dest, const uint64_t len) const {
-		std::memcpy(dest, ptr, len);
-	}
-
-	void zero() const {
-		std::memset(ptr, 0, len);
-	}
-
-	void available(const uint64_t req_len) const {
-		if (!check_available(req_len)) {
-			throw std::runtime_error("Out of buffer");
-		}
-	}
-
-	bool check_available(const uint64_t req_len) const {
-		return req_len <= len;
-	}
-};
-
-class ResizeableBuffer : public ByteBuffer {
-public:
-	ResizeableBuffer() {
-	}
-	ResizeableBuffer(Allocator &allocator, const uint64_t new_size) {
-		resize(allocator, new_size);
-	}
-	void resize(Allocator &allocator, const uint64_t new_size) {
-		len = new_size;
-		if (new_size == 0) {
-			return;
-		}
-		if (new_size > alloc_len) {
-			alloc_len = NextPowerOfTwo(new_size);
-			allocated_data = allocator.Allocate(alloc_len);
-			ptr = allocated_data.get();
-		}
-	}
-
-private:
-	AllocatedData allocated_data;
-	idx_t alloc_len = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/row_number_column_reader.hpp b/src/duckdb/extension/parquet/include/row_number_column_reader.hpp
deleted file mode 100644
index cdd5df1f3..000000000
--- a/src/duckdb/extension/parquet/include/row_number_column_reader.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// row_number_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/limits.hpp"
-#endif
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-//! Reads a file-absolute row number as a virtual column that's not actually stored in the file
-class RowNumberColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::INT64;
-
-public:
-	RowNumberColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                      idx_t max_define_p, idx_t max_repeat_p);
-
-public:
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-	           Vector &result) override;
-
-	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) override;
-
-	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
-
-	void Skip(idx_t num_values) override {
-		row_group_offset += num_values;
-	}
-	idx_t GroupRowsAvailable() override {
-		return NumericLimits<idx_t>::Maximum();
-	};
-	uint64_t TotalCompressedSize() override {
-		return 0;
-	}
-	idx_t FileOffset() const override {
-		return 0;
-	}
-	void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) override {
-	}
-
-private:
-	idx_t row_group_offset;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/string_column_reader.hpp b/src/duckdb/extension/parquet/include/string_column_reader.hpp
deleted file mode 100644
index 2ab96a296..000000000
--- a/src/duckdb/extension/parquet/include/string_column_reader.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// string_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-
-namespace duckdb {
-
-struct StringParquetValueConversion {
-	static string_t PlainRead(ByteBuffer &plain_data, ColumnReader &reader);
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader);
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count);
-	static string_t UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader);
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader);
-};
-
-class StringColumnReader : public TemplatedColumnReader<string_t, StringParquetValueConversion> {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::VARCHAR;
-
-public:
-	StringColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                   idx_t max_define_p, idx_t max_repeat_p);
-	idx_t fixed_width_string_length;
-	idx_t delta_offset = 0;
-
-public:
-	void PrepareDeltaLengthByteArray(ResizeableBuffer &buffer) override;
-	void PrepareDeltaByteArray(ResizeableBuffer &buffer) override;
-	void DeltaByteArray(uint8_t *defines, idx_t num_values, parquet_filter_t &filter, idx_t result_offset,
-	                    Vector &result) override;
-	static uint32_t VerifyString(const char *str_data, uint32_t str_len, const bool isVarchar);
-	uint32_t VerifyString(const char *str_data, uint32_t str_len);
-
-protected:
-	void PlainReference(shared_ptr<ByteBuffer> plain_data, Vector &result) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/struct_column_reader.hpp b/src/duckdb/extension/parquet/include/struct_column_reader.hpp
deleted file mode 100644
index 4a0254695..000000000
--- a/src/duckdb/extension/parquet/include/struct_column_reader.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// struct_column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "templated_column_reader.hpp"
-
-namespace duckdb {
-
-class StructColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::STRUCT;
-
-public:
-	StructColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                   idx_t max_define_p, idx_t max_repeat_p, vector<unique_ptr<ColumnReader>> child_readers_p);
-
-	vector<unique_ptr<ColumnReader>> child_readers;
-
-public:
-	ColumnReader &GetChildReader(idx_t child_idx);
-
-	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
-
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
-	           Vector &result) override;
-
-	void Skip(idx_t num_values) override;
-	idx_t GroupRowsAvailable() override;
-	uint64_t TotalCompressedSize() override;
-	void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/templated_column_reader.hpp b/src/duckdb/extension/parquet/include/templated_column_reader.hpp
deleted file mode 100644
index d85865309..000000000
--- a/src/duckdb/extension/parquet/include/templated_column_reader.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// templated__column_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "column_reader.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-template <class VALUE_TYPE>
-struct TemplatedParquetValueConversion {
-
-	static VALUE_TYPE PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		return plain_data.read<VALUE_TYPE>();
-	}
-
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.inc(sizeof(VALUE_TYPE));
-	}
-
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-		return plain_data.check_available(count * sizeof(VALUE_TYPE));
-	}
-
-	static VALUE_TYPE UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		return plain_data.unsafe_read<VALUE_TYPE>();
-	}
-
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.unsafe_inc(sizeof(VALUE_TYPE));
-	}
-};
-
-template <class VALUE_TYPE, class VALUE_CONVERSION>
-class TemplatedColumnReader : public ColumnReader {
-public:
-	static constexpr const PhysicalType TYPE = PhysicalType::INVALID;
-
-public:
-	TemplatedColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
-	                      idx_t max_define_p, idx_t max_repeat_p)
-	    : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p) {};
-
-	shared_ptr<ResizeableBuffer> dict;
-
-public:
-	void AllocateDict(idx_t size) {
-		if (!dict) {
-			dict = make_shared_ptr<ResizeableBuffer>(GetAllocator(), size);
-		} else {
-			dict->resize(GetAllocator(), size);
-		}
-	}
-
-	void Plain(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, uint64_t num_values, parquet_filter_t *filter,
-	           idx_t result_offset, Vector &result) override {
-		PlainTemplated<VALUE_TYPE, VALUE_CONVERSION>(std::move(plain_data), defines, num_values, filter, result_offset,
-		                                             result);
-	}
-};
-
-template <class PARQUET_PHYSICAL_TYPE, class DUCKDB_PHYSICAL_TYPE,
-          DUCKDB_PHYSICAL_TYPE (*FUNC)(const PARQUET_PHYSICAL_TYPE &input)>
-struct CallbackParquetValueConversion {
-
-	static DUCKDB_PHYSICAL_TYPE PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		return FUNC(plain_data.read<PARQUET_PHYSICAL_TYPE>());
-	}
-
-	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.inc(sizeof(PARQUET_PHYSICAL_TYPE));
-	}
-
-	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
-		return plain_data.check_available(count * sizeof(PARQUET_PHYSICAL_TYPE));
-	}
-
-	static DUCKDB_PHYSICAL_TYPE UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		return FUNC(plain_data.unsafe_read<PARQUET_PHYSICAL_TYPE>());
-	}
-
-	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-		plain_data.unsafe_inc(sizeof(PARQUET_PHYSICAL_TYPE));
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/thrift_tools.hpp b/src/duckdb/extension/parquet/include/thrift_tools.hpp
deleted file mode 100644
index de1eaca34..000000000
--- a/src/duckdb/extension/parquet/include/thrift_tools.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// thrift_tools.hpp
-//
-//
-//===----------------------------------------------------------------------===/
-
-#pragma once
-
-#include <list>
-#include "thrift/protocol/TCompactProtocol.h"
-#include "thrift/transport/TBufferTransports.h"
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/allocator.hpp"
-#endif
-
-namespace duckdb {
-
-// A ReadHead for prefetching data in a specific range
-struct ReadHead {
-	ReadHead(idx_t location, uint64_t size) : location(location), size(size) {};
-	// Hint info
-	idx_t location;
-	uint64_t size;
-
-	// Current info
-	AllocatedData data;
-	bool data_isset = false;
-
-	idx_t GetEnd() const {
-		return size + location;
-	}
-
-	void Allocate(Allocator &allocator) {
-		data = allocator.Allocate(size);
-	}
-};
-
-// Comparator for ReadHeads that are either overlapping, adjacent, or within ALLOW_GAP bytes from each other
-struct ReadHeadComparator {
-	static constexpr uint64_t ALLOW_GAP = 1 << 14; // 16 KiB
-	bool operator()(const ReadHead *a, const ReadHead *b) const {
-		auto a_start = a->location;
-		auto a_end = a->location + a->size;
-		auto b_start = b->location;
-
-		if (a_end <= NumericLimits<idx_t>::Maximum() - ALLOW_GAP) {
-			a_end += ALLOW_GAP;
-		}
-
-		return a_start < b_start && a_end < b_start;
-	}
-};
-
-// Two-step read ahead buffer
-// 1: register all ranges that will be read, merging ranges that are consecutive
-// 2: prefetch all registered ranges
-struct ReadAheadBuffer {
-	ReadAheadBuffer(Allocator &allocator, FileHandle &handle) : allocator(allocator), handle(handle) {
-	}
-
-	// The list of read heads
-	std::list<ReadHead> read_heads;
-	// Set for merging consecutive ranges
-	std::set<ReadHead *, ReadHeadComparator> merge_set;
-
-	Allocator &allocator;
-	FileHandle &handle;
-
-	idx_t total_size = 0;
-
-	// Add a read head to the prefetching list
-	void AddReadHead(idx_t pos, uint64_t len, bool merge_buffers = true) {
-		// Attempt to merge with existing
-		if (merge_buffers) {
-			ReadHead new_read_head {pos, len};
-			auto lookup_set = merge_set.find(&new_read_head);
-			if (lookup_set != merge_set.end()) {
-				auto existing_head = *lookup_set;
-				auto new_start = MinValue<idx_t>(existing_head->location, new_read_head.location);
-				auto new_length = MaxValue<idx_t>(existing_head->GetEnd(), new_read_head.GetEnd()) - new_start;
-				existing_head->location = new_start;
-				existing_head->size = new_length;
-				return;
-			}
-		}
-
-		read_heads.emplace_front(ReadHead(pos, len));
-		total_size += len;
-		auto &read_head = read_heads.front();
-
-		if (merge_buffers) {
-			merge_set.insert(&read_head);
-		}
-
-		if (read_head.GetEnd() > handle.GetFileSize()) {
-			throw std::runtime_error("Prefetch registered for bytes outside file: " + handle.GetPath() +
-			                         ", attempted range: [" + std::to_string(pos) + ", " +
-			                         std::to_string(read_head.GetEnd()) +
-			                         "), file size: " + std::to_string(handle.GetFileSize()));
-		}
-	}
-
-	// Returns the relevant read head
-	ReadHead *GetReadHead(idx_t pos) {
-		for (auto &read_head : read_heads) {
-			if (pos >= read_head.location && pos < read_head.GetEnd()) {
-				return &read_head;
-			}
-		}
-		return nullptr;
-	}
-
-	// Prefetch all read heads
-	void Prefetch() {
-		for (auto &read_head : read_heads) {
-			read_head.Allocate(allocator);
-
-			if (read_head.GetEnd() > handle.GetFileSize()) {
-				throw std::runtime_error("Prefetch registered requested for bytes outside file");
-			}
-
-			handle.Read(read_head.data.get(), read_head.size, read_head.location);
-			read_head.data_isset = true;
-		}
-	}
-};
-
-class ThriftFileTransport : public duckdb_apache::thrift::transport::TVirtualTransport<ThriftFileTransport> {
-public:
-	static constexpr uint64_t PREFETCH_FALLBACK_BUFFERSIZE = 1000000;
-
-	ThriftFileTransport(Allocator &allocator, FileHandle &handle_p, bool prefetch_mode_p)
-	    : handle(handle_p), location(0), allocator(allocator), ra_buffer(ReadAheadBuffer(allocator, handle_p)),
-	      prefetch_mode(prefetch_mode_p) {
-	}
-
-	uint32_t read(uint8_t *buf, uint32_t len) {
-		auto prefetch_buffer = ra_buffer.GetReadHead(location);
-		if (prefetch_buffer != nullptr && location - prefetch_buffer->location + len <= prefetch_buffer->size) {
-			D_ASSERT(location - prefetch_buffer->location + len <= prefetch_buffer->size);
-
-			if (!prefetch_buffer->data_isset) {
-				prefetch_buffer->Allocate(allocator);
-				handle.Read(prefetch_buffer->data.get(), prefetch_buffer->size, prefetch_buffer->location);
-				prefetch_buffer->data_isset = true;
-			}
-			memcpy(buf, prefetch_buffer->data.get() + location - prefetch_buffer->location, len);
-		} else {
-			if (prefetch_mode && len < PREFETCH_FALLBACK_BUFFERSIZE && len > 0) {
-				Prefetch(location, MinValue<uint64_t>(PREFETCH_FALLBACK_BUFFERSIZE, handle.GetFileSize() - location));
-				auto prefetch_buffer_fallback = ra_buffer.GetReadHead(location);
-				D_ASSERT(location - prefetch_buffer_fallback->location + len <= prefetch_buffer_fallback->size);
-				memcpy(buf, prefetch_buffer_fallback->data.get() + location - prefetch_buffer_fallback->location, len);
-			} else {
-				handle.Read(buf, len, location);
-			}
-		}
-		location += len;
-		return len;
-	}
-
-	// Prefetch a single buffer
-	void Prefetch(idx_t pos, uint64_t len) {
-		RegisterPrefetch(pos, len, false);
-		FinalizeRegistration();
-		PrefetchRegistered();
-	}
-
-	// Register a buffer for prefixing
-	void RegisterPrefetch(idx_t pos, uint64_t len, bool can_merge = true) {
-		ra_buffer.AddReadHead(pos, len, can_merge);
-	}
-
-	// Prevents any further merges, should be called before PrefetchRegistered
-	void FinalizeRegistration() {
-		ra_buffer.merge_set.clear();
-	}
-
-	// Prefetch all previously registered ranges
-	void PrefetchRegistered() {
-		ra_buffer.Prefetch();
-	}
-
-	void ClearPrefetch() {
-		ra_buffer.read_heads.clear();
-		ra_buffer.merge_set.clear();
-	}
-
-	void SetLocation(idx_t location_p) {
-		location = location_p;
-	}
-
-	idx_t GetLocation() {
-		return location;
-	}
-	idx_t GetSize() {
-		return handle.file_system.GetFileSize(handle);
-	}
-
-private:
-	FileHandle &handle;
-	idx_t location;
-
-	Allocator &allocator;
-
-	// Multi-buffer prefetch
-	ReadAheadBuffer ra_buffer;
-
-	// Whether the prefetch mode is enabled. In this mode the DirectIO flag of the handle will be set and the parquet
-	// reader will manage the read buffering.
-	bool prefetch_mode;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/include/zstd_file_system.hpp b/src/duckdb/extension/parquet/include/zstd_file_system.hpp
deleted file mode 100644
index 5b132bc8a..000000000
--- a/src/duckdb/extension/parquet/include/zstd_file_system.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// zstd_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/compressed_file_system.hpp"
-#endif
-
-namespace duckdb {
-
-class ZStdFileSystem : public CompressedFileSystem {
-public:
-	unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) override;
-
-	std::string GetName() const override {
-		return "ZStdFileSystem";
-	}
-
-	unique_ptr<StreamWrapper> CreateStream() override;
-	idx_t InBufferSize() override;
-	idx_t OutBufferSize() override;
-
-	static int64_t DefaultCompressionLevel();
-	static int64_t MinimumCompressionLevel();
-	static int64_t MaximumCompressionLevel();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/parquet_crypto.cpp b/src/duckdb/extension/parquet/parquet_crypto.cpp
deleted file mode 100644
index 070c381d7..000000000
--- a/src/duckdb/extension/parquet/parquet_crypto.cpp
+++ /dev/null
@@ -1,420 +0,0 @@
-#include "parquet_crypto.hpp"
-
-#include "mbedtls_wrapper.hpp"
-#include "thrift_tools.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/blob.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-#endif
-
-namespace duckdb {
-
-ParquetKeys &ParquetKeys::Get(ClientContext &context) {
-	auto &cache = ObjectCache::GetObjectCache(context);
-	if (!cache.Get<ParquetKeys>(ParquetKeys::ObjectType())) {
-		cache.Put(ParquetKeys::ObjectType(), make_shared_ptr<ParquetKeys>());
-	}
-	return *cache.Get<ParquetKeys>(ParquetKeys::ObjectType());
-}
-
-void ParquetKeys::AddKey(const string &key_name, const string &key) {
-	keys[key_name] = key;
-}
-
-bool ParquetKeys::HasKey(const string &key_name) const {
-	return keys.find(key_name) != keys.end();
-}
-
-const string &ParquetKeys::GetKey(const string &key_name) const {
-	D_ASSERT(HasKey(key_name));
-	return keys.at(key_name);
-}
-
-string ParquetKeys::ObjectType() {
-	return "parquet_keys";
-}
-
-string ParquetKeys::GetObjectType() {
-	return ObjectType();
-}
-
-ParquetEncryptionConfig::ParquetEncryptionConfig(ClientContext &context_p) : context(context_p) {
-}
-
-ParquetEncryptionConfig::ParquetEncryptionConfig(ClientContext &context_p, const Value &arg)
-    : ParquetEncryptionConfig(context_p) {
-
-	if (arg.type().id() != LogicalTypeId::STRUCT) {
-		throw BinderException("Parquet encryption_config must be of type STRUCT");
-	}
-	const auto &child_types = StructType::GetChildTypes(arg.type());
-	auto &children = StructValue::GetChildren(arg);
-	const auto &keys = ParquetKeys::Get(context);
-	for (idx_t i = 0; i < StructType::GetChildCount(arg.type()); i++) {
-		auto &struct_key = child_types[i].first;
-		if (StringUtil::Lower(struct_key) == "footer_key") {
-			const auto footer_key_name = StringValue::Get(children[i].DefaultCastAs(LogicalType::VARCHAR));
-			if (!keys.HasKey(footer_key_name)) {
-				throw BinderException(
-				    "No key with name \"%s\" exists. Add it with PRAGMA add_parquet_key('<key_name>','<key>');",
-				    footer_key_name);
-			}
-			footer_key = footer_key_name;
-		} else if (StringUtil::Lower(struct_key) == "column_keys") {
-			throw NotImplementedException("Parquet encryption_config column_keys not yet implemented");
-		} else {
-			throw BinderException("Unknown key in encryption_config \"%s\"", struct_key);
-		}
-	}
-}
-
-shared_ptr<ParquetEncryptionConfig> ParquetEncryptionConfig::Create(ClientContext &context, const Value &arg) {
-	return shared_ptr<ParquetEncryptionConfig>(new ParquetEncryptionConfig(context, arg));
-}
-
-const string &ParquetEncryptionConfig::GetFooterKey() const {
-	const auto &keys = ParquetKeys::Get(context);
-	D_ASSERT(!footer_key.empty());
-	D_ASSERT(keys.HasKey(footer_key));
-	return keys.GetKey(footer_key);
-}
-
-using duckdb_apache::thrift::protocol::TCompactProtocolFactoryT;
-using duckdb_apache::thrift::transport::TTransport;
-
-//! Encryption wrapper for a transport protocol
-class EncryptionTransport : public TTransport {
-public:
-	EncryptionTransport(TProtocol &prot_p, const string &key, const EncryptionUtil &encryption_util_p)
-	    : prot(prot_p), trans(*prot.getTransport()), aes(encryption_util_p.CreateEncryptionState()),
-	      allocator(Allocator::DefaultAllocator(), ParquetCrypto::CRYPTO_BLOCK_SIZE) {
-		Initialize(key);
-	}
-
-	bool isOpen() const override {
-		return trans.isOpen();
-	}
-
-	void open() override {
-		trans.open();
-	}
-
-	void close() override {
-		trans.close();
-	}
-
-	void write_virt(const uint8_t *buf, uint32_t len) override {
-		memcpy(allocator.Allocate(len), buf, len);
-	}
-
-	uint32_t Finalize() {
-		// Write length
-		const auto ciphertext_length = allocator.SizeInBytes();
-		const uint32_t total_length = ParquetCrypto::NONCE_BYTES + ciphertext_length + ParquetCrypto::TAG_BYTES;
-
-		trans.write(const_data_ptr_cast(&total_length), ParquetCrypto::LENGTH_BYTES);
-		// Write nonce at beginning of encrypted chunk
-		trans.write(nonce, ParquetCrypto::NONCE_BYTES);
-
-		data_t aes_buffer[ParquetCrypto::CRYPTO_BLOCK_SIZE];
-		auto current = allocator.GetTail();
-
-		// Loop through the whole chunk
-		while (current != nullptr) {
-			for (idx_t pos = 0; pos < current->current_position; pos += ParquetCrypto::CRYPTO_BLOCK_SIZE) {
-				auto next = MinValue<idx_t>(current->current_position - pos, ParquetCrypto::CRYPTO_BLOCK_SIZE);
-				auto write_size =
-				    aes->Process(current->data.get() + pos, next, aes_buffer, ParquetCrypto::CRYPTO_BLOCK_SIZE);
-				trans.write(aes_buffer, write_size);
-			}
-			current = current->prev;
-		}
-
-		// Finalize the last encrypted data
-		data_t tag[ParquetCrypto::TAG_BYTES];
-		auto write_size = aes->Finalize(aes_buffer, 0, tag, ParquetCrypto::TAG_BYTES);
-		trans.write(aes_buffer, write_size);
-		// Write tag for verification
-		trans.write(tag, ParquetCrypto::TAG_BYTES);
-
-		return ParquetCrypto::LENGTH_BYTES + total_length;
-	}
-
-private:
-	void Initialize(const string &key) {
-		// Generate Nonce
-		aes->GenerateRandomData(nonce, ParquetCrypto::NONCE_BYTES);
-		// Initialize Encryption
-		aes->InitializeEncryption(nonce, ParquetCrypto::NONCE_BYTES, &key);
-	}
-
-private:
-	//! Protocol and corresponding transport that we're wrapping
-	TProtocol &prot;
-	TTransport &trans;
-
-	//! AES context and buffers
-	shared_ptr<EncryptionState> aes;
-
-	//! Nonce created by Initialize()
-	data_t nonce[ParquetCrypto::NONCE_BYTES];
-
-	//! Arena Allocator to fully materialize in memory before encrypting
-	ArenaAllocator allocator;
-};
-
-//! Decryption wrapper for a transport protocol
-class DecryptionTransport : public TTransport {
-public:
-	DecryptionTransport(TProtocol &prot_p, const string &key, const EncryptionUtil &encryption_util_p)
-	    : prot(prot_p), trans(*prot.getTransport()), aes(encryption_util_p.CreateEncryptionState()),
-	      read_buffer_size(0), read_buffer_offset(0) {
-		Initialize(key);
-	}
-	uint32_t read_virt(uint8_t *buf, uint32_t len) override {
-		const uint32_t result = len;
-
-		if (len > transport_remaining - ParquetCrypto::TAG_BYTES + read_buffer_size - read_buffer_offset) {
-			throw InvalidInputException("Too many bytes requested from crypto buffer");
-		}
-
-		while (len != 0) {
-			if (read_buffer_offset == read_buffer_size) {
-				ReadBlock(buf);
-			}
-			const auto next = MinValue(read_buffer_size - read_buffer_offset, len);
-			read_buffer_offset += next;
-			buf += next;
-			len -= next;
-		}
-
-		return result;
-	}
-
-	uint32_t Finalize() {
-
-		if (read_buffer_offset != read_buffer_size) {
-			throw InternalException("DecryptionTransport::Finalize was called with bytes remaining in read buffer: \n"
-			                        "read buffer offset: %d, read buffer size: %d",
-			                        read_buffer_offset, read_buffer_size);
-		}
-
-		data_t computed_tag[ParquetCrypto::TAG_BYTES];
-
-		if (aes->IsOpenSSL()) {
-			// For OpenSSL, the obtained tag is an input argument for aes->Finalize()
-			transport_remaining -= trans.read(computed_tag, ParquetCrypto::TAG_BYTES);
-			if (aes->Finalize(read_buffer, 0, computed_tag, ParquetCrypto::TAG_BYTES) != 0) {
-				throw InternalException(
-				    "DecryptionTransport::Finalize was called with bytes remaining in AES context out");
-			}
-		} else {
-			// For mbedtls, computed_tag is an output argument for aes->Finalize()
-			if (aes->Finalize(read_buffer, 0, computed_tag, ParquetCrypto::TAG_BYTES) != 0) {
-				throw InternalException(
-				    "DecryptionTransport::Finalize was called with bytes remaining in AES context out");
-			}
-			VerifyTag(computed_tag);
-		}
-
-		if (transport_remaining != 0) {
-			throw InvalidInputException("Encoded ciphertext length differs from actual ciphertext length");
-		}
-
-		return ParquetCrypto::LENGTH_BYTES + total_bytes;
-	}
-
-	AllocatedData ReadAll() {
-		D_ASSERT(transport_remaining == total_bytes - ParquetCrypto::NONCE_BYTES);
-		auto result = Allocator::DefaultAllocator().Allocate(transport_remaining - ParquetCrypto::TAG_BYTES);
-		read_virt(result.get(), transport_remaining - ParquetCrypto::TAG_BYTES);
-		Finalize();
-		return result;
-	}
-
-private:
-	void Initialize(const string &key) {
-		// Read encoded length (don't add to read_bytes)
-		data_t length_buf[ParquetCrypto::LENGTH_BYTES];
-		trans.read(length_buf, ParquetCrypto::LENGTH_BYTES);
-		total_bytes = Load<uint32_t>(length_buf);
-		transport_remaining = total_bytes;
-		// Read nonce and initialize AES
-		transport_remaining -= trans.read(nonce, ParquetCrypto::NONCE_BYTES);
-		// check whether context is initialized
-		aes->InitializeDecryption(nonce, ParquetCrypto::NONCE_BYTES, &key);
-	}
-
-	void ReadBlock(uint8_t *buf) {
-		// Read from transport into read_buffer at one AES block size offset (up to the tag)
-		read_buffer_size = MinValue(ParquetCrypto::CRYPTO_BLOCK_SIZE, transport_remaining - ParquetCrypto::TAG_BYTES);
-		transport_remaining -= trans.read(read_buffer + ParquetCrypto::BLOCK_SIZE, read_buffer_size);
-
-		// Decrypt from read_buffer + block size into read_buffer start (decryption can trail behind in same buffer)
-#ifdef DEBUG
-		auto size = aes->Process(read_buffer + ParquetCrypto::BLOCK_SIZE, read_buffer_size, buf,
-		                         ParquetCrypto::CRYPTO_BLOCK_SIZE + ParquetCrypto::BLOCK_SIZE);
-		D_ASSERT(size == read_buffer_size);
-#else
-		aes->Process(read_buffer + ParquetCrypto::BLOCK_SIZE, read_buffer_size, buf,
-		             ParquetCrypto::CRYPTO_BLOCK_SIZE + ParquetCrypto::BLOCK_SIZE);
-#endif
-		read_buffer_offset = 0;
-	}
-
-	void VerifyTag(data_t *computed_tag) {
-		data_t read_tag[ParquetCrypto::TAG_BYTES];
-		transport_remaining -= trans.read(read_tag, ParquetCrypto::TAG_BYTES);
-		if (memcmp(computed_tag, read_tag, ParquetCrypto::TAG_BYTES) != 0) {
-			throw InvalidInputException("Computed AES tag differs from read AES tag, are you using the right key?");
-		}
-	}
-
-private:
-	//! Protocol and corresponding transport that we're wrapping
-	TProtocol &prot;
-	TTransport &trans;
-
-	//! AES context and buffers
-	shared_ptr<EncryptionState> aes;
-
-	//! We read/decrypt big blocks at a time
-	data_t read_buffer[ParquetCrypto::CRYPTO_BLOCK_SIZE + ParquetCrypto::BLOCK_SIZE];
-	uint32_t read_buffer_size;
-	uint32_t read_buffer_offset;
-
-	//! Remaining bytes to read, set by Initialize(), decremented by ReadBlock()
-	uint32_t total_bytes;
-	uint32_t transport_remaining;
-	//! Nonce read by Initialize()
-	data_t nonce[ParquetCrypto::NONCE_BYTES];
-};
-
-class SimpleReadTransport : public TTransport {
-public:
-	explicit SimpleReadTransport(data_ptr_t read_buffer_p, uint32_t read_buffer_size_p)
-	    : read_buffer(read_buffer_p), read_buffer_size(read_buffer_size_p), read_buffer_offset(0) {
-	}
-
-	uint32_t read_virt(uint8_t *buf, uint32_t len) override {
-		const auto remaining = read_buffer_size - read_buffer_offset;
-		if (len > remaining) {
-			return remaining;
-		}
-		memcpy(buf, read_buffer + read_buffer_offset, len);
-		read_buffer_offset += len;
-		return len;
-	}
-
-private:
-	const data_ptr_t read_buffer;
-	const uint32_t read_buffer_size;
-	uint32_t read_buffer_offset;
-};
-
-uint32_t ParquetCrypto::Read(TBase &object, TProtocol &iprot, const string &key,
-                             const EncryptionUtil &encryption_util_p) {
-	TCompactProtocolFactoryT<DecryptionTransport> tproto_factory;
-	auto dprot = tproto_factory.getProtocol(std::make_shared<DecryptionTransport>(iprot, key, encryption_util_p));
-	auto &dtrans = reinterpret_cast<DecryptionTransport &>(*dprot->getTransport());
-
-	// We have to read the whole thing otherwise thrift throws an error before we realize we're decryption is wrong
-	auto all = dtrans.ReadAll();
-	TCompactProtocolFactoryT<SimpleReadTransport> tsimple_proto_factory;
-	auto simple_prot =
-	    tsimple_proto_factory.getProtocol(std::make_shared<SimpleReadTransport>(all.get(), all.GetSize()));
-
-	// Read the object
-	object.read(simple_prot.get());
-
-	return ParquetCrypto::LENGTH_BYTES + ParquetCrypto::NONCE_BYTES + all.GetSize() + ParquetCrypto::TAG_BYTES;
-}
-
-uint32_t ParquetCrypto::Write(const TBase &object, TProtocol &oprot, const string &key,
-                              const EncryptionUtil &encryption_util_p) {
-	// Create encryption protocol
-	TCompactProtocolFactoryT<EncryptionTransport> tproto_factory;
-	auto eprot = tproto_factory.getProtocol(std::make_shared<EncryptionTransport>(oprot, key, encryption_util_p));
-	auto &etrans = reinterpret_cast<EncryptionTransport &>(*eprot->getTransport());
-
-	// Write the object in memory
-	object.write(eprot.get());
-
-	// Encrypt and write to oprot
-	return etrans.Finalize();
-}
-
-uint32_t ParquetCrypto::ReadData(TProtocol &iprot, const data_ptr_t buffer, const uint32_t buffer_size,
-                                 const string &key, const EncryptionUtil &encryption_util_p) {
-	// Create decryption protocol
-	TCompactProtocolFactoryT<DecryptionTransport> tproto_factory;
-	auto dprot = tproto_factory.getProtocol(std::make_shared<DecryptionTransport>(iprot, key, encryption_util_p));
-	auto &dtrans = reinterpret_cast<DecryptionTransport &>(*dprot->getTransport());
-
-	// Read buffer
-	dtrans.read(buffer, buffer_size);
-
-	// Verify AES tag and read length
-	return dtrans.Finalize();
-}
-
-uint32_t ParquetCrypto::WriteData(TProtocol &oprot, const const_data_ptr_t buffer, const uint32_t buffer_size,
-                                  const string &key, const EncryptionUtil &encryption_util_p) {
-	// FIXME: we know the size upfront so we could do a streaming write instead of this
-	// Create encryption protocol
-	TCompactProtocolFactoryT<EncryptionTransport> tproto_factory;
-	auto eprot = tproto_factory.getProtocol(std::make_shared<EncryptionTransport>(oprot, key, encryption_util_p));
-	auto &etrans = reinterpret_cast<EncryptionTransport &>(*eprot->getTransport());
-
-	// Write the data in memory
-	etrans.write(buffer, buffer_size);
-
-	// Encrypt and write to oprot
-	return etrans.Finalize();
-}
-
-bool ParquetCrypto::ValidKey(const std::string &key) {
-	switch (key.size()) {
-	case 16:
-	case 24:
-	case 32:
-		return true;
-	default:
-		return false;
-	}
-}
-
-string Base64Decode(const string &key) {
-	auto result_size = Blob::FromBase64Size(key);
-	auto output = duckdb::unique_ptr<unsigned char[]>(new unsigned char[result_size]);
-	Blob::FromBase64(key, output.get(), result_size);
-	string decoded_key(reinterpret_cast<const char *>(output.get()), result_size);
-	return decoded_key;
-}
-
-void ParquetCrypto::AddKey(ClientContext &context, const FunctionParameters &parameters) {
-	const auto &key_name = StringValue::Get(parameters.values[0]);
-	const auto &key = StringValue::Get(parameters.values[1]);
-
-	auto &keys = ParquetKeys::Get(context);
-	if (ValidKey(key)) {
-		keys.AddKey(key_name, key);
-	} else {
-		string decoded_key;
-		try {
-			decoded_key = Base64Decode(key);
-		} catch (const ConversionException &e) {
-			throw InvalidInputException("Invalid AES key. Not a plain AES key NOR a base64 encoded string");
-		}
-		if (!ValidKey(decoded_key)) {
-			throw InvalidInputException(
-			    "Invalid AES key. Must have a length of 128, 192, or 256 bits (16, 24, or 32 bytes)");
-		}
-		keys.AddKey(key_name, decoded_key);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/parquet_extension.cpp b/src/duckdb/extension/parquet/parquet_extension.cpp
deleted file mode 100644
index 500b89919..000000000
--- a/src/duckdb/extension/parquet/parquet_extension.cpp
+++ /dev/null
@@ -1,1758 +0,0 @@
-#define DUCKDB_EXTENSION_MAIN
-
-#include "parquet_extension.hpp"
-
-#include "cast_column_reader.hpp"
-#include "duckdb.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "geo_parquet.hpp"
-#include "parquet_crypto.hpp"
-#include "parquet_metadata.hpp"
-#include "parquet_reader.hpp"
-#include "parquet_writer.hpp"
-#include "struct_column_reader.hpp"
-#include "zstd_file_system.hpp"
-
-#include <fstream>
-#include <iostream>
-#include <numeric>
-#include <string>
-#include <vector>
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/enums/file_compression_type.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/function/pragma_function.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/extension_util.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#endif
-
-namespace duckdb {
-
-struct ParquetReadBindData : public TableFunctionData {
-	shared_ptr<MultiFileList> file_list;
-	unique_ptr<MultiFileReader> multi_file_reader;
-
-	shared_ptr<ParquetReader> initial_reader;
-	atomic<idx_t> chunk_count;
-	vector<string> names;
-	vector<LogicalType> types;
-	//! Table column names - set when using COPY tbl FROM file.parquet
-	vector<string> table_columns;
-
-	// The union readers are created (when parquet union_by_name option is on) during binding
-	// Those readers can be re-used during ParquetParallelStateNext
-	vector<unique_ptr<ParquetUnionData>> union_readers;
-
-	// These come from the initial_reader, but need to be stored in case the initial_reader is removed by a filter
-	idx_t initial_file_cardinality;
-	idx_t initial_file_row_groups;
-	idx_t explicit_cardinality = 0; // can be set to inject exterior cardinality knowledge (e.g. from a data lake)
-	ParquetOptions parquet_options;
-	MultiFileReaderBindData reader_bind;
-
-	void Initialize(shared_ptr<ParquetReader> reader) {
-		initial_reader = std::move(reader);
-		initial_file_cardinality = initial_reader->NumRows();
-		initial_file_row_groups = initial_reader->NumRowGroups();
-		parquet_options = initial_reader->parquet_options;
-	}
-	void Initialize(ClientContext &, unique_ptr<ParquetUnionData> &union_data) {
-		Initialize(std::move(union_data->reader));
-	}
-};
-
-struct ParquetReadLocalState : public LocalTableFunctionState {
-	shared_ptr<ParquetReader> reader;
-	ParquetReaderScanState scan_state;
-	bool is_parallel;
-	idx_t batch_index;
-	idx_t file_index;
-	//! The DataChunk containing all read columns (even columns that are immediately removed)
-	DataChunk all_columns;
-};
-
-enum class ParquetFileState : uint8_t { UNOPENED, OPENING, OPEN, CLOSED };
-
-struct ParquetFileReaderData {
-	// Create data for an unopened file
-	explicit ParquetFileReaderData(const string &file_to_be_opened)
-	    : reader(nullptr), file_state(ParquetFileState::UNOPENED), file_mutex(make_uniq<mutex>()),
-	      file_to_be_opened(file_to_be_opened) {
-	}
-	// Create data for an existing reader
-	explicit ParquetFileReaderData(shared_ptr<ParquetReader> reader_p)
-	    : reader(std::move(reader_p)), file_state(ParquetFileState::OPEN), file_mutex(make_uniq<mutex>()) {
-	}
-	// Create data for an existing reader
-	explicit ParquetFileReaderData(unique_ptr<ParquetUnionData> union_data_p) : file_mutex(make_uniq<mutex>()) {
-		if (union_data_p->reader) {
-			reader = std::move(union_data_p->reader);
-			file_state = ParquetFileState::OPEN;
-		} else {
-			union_data = std::move(union_data_p);
-			file_state = ParquetFileState::UNOPENED;
-		}
-	}
-
-	//! Currently opened reader for the file
-	shared_ptr<ParquetReader> reader;
-	//! Flag to indicate the file is being opened
-	ParquetFileState file_state;
-	//! Mutexes to wait for the file when it is being opened
-	unique_ptr<mutex> file_mutex;
-	//! Parquet options for opening the file
-	unique_ptr<ParquetUnionData> union_data;
-
-	//! (only set when file_state is UNOPENED) the file to be opened
-	string file_to_be_opened;
-};
-
-struct ParquetReadGlobalState : public GlobalTableFunctionState {
-	explicit ParquetReadGlobalState(MultiFileList &file_list_p) : file_list(file_list_p) {
-	}
-	explicit ParquetReadGlobalState(unique_ptr<MultiFileList> owned_file_list_p)
-	    : file_list(*owned_file_list_p), owned_file_list(std::move(owned_file_list_p)) {
-	}
-
-	//! The file list to scan
-	MultiFileList &file_list;
-	//! The scan over the file_list
-	MultiFileListScanData file_list_scan;
-	//! Owned multi file list - if filters have been dynamically pushed into the reader
-	unique_ptr<MultiFileList> owned_file_list;
-
-	unique_ptr<MultiFileReaderGlobalState> multi_file_reader_state;
-
-	mutex lock;
-
-	//! The current set of parquet readers
-	vector<unique_ptr<ParquetFileReaderData>> readers;
-
-	//! Signal to other threads that a file failed to open, letting every thread abort.
-	bool error_opening_file = false;
-
-	//! Index of file currently up for scanning
-	atomic<idx_t> file_index;
-	//! Index of row group within file currently up for scanning
-	idx_t row_group_index;
-	//! Batch index of the next row group to be scanned
-	idx_t batch_index;
-
-	idx_t max_threads;
-	vector<idx_t> projection_ids;
-	vector<LogicalType> scanned_types;
-	vector<ColumnIndex> column_indexes;
-	optional_ptr<TableFilterSet> filters;
-
-	idx_t MaxThreads() const override {
-		return max_threads;
-	}
-
-	bool CanRemoveColumns() const {
-		return !projection_ids.empty();
-	}
-};
-
-struct ParquetWriteBindData : public TableFunctionData {
-	vector<LogicalType> sql_types;
-	vector<string> column_names;
-	duckdb_parquet::CompressionCodec::type codec = duckdb_parquet::CompressionCodec::SNAPPY;
-	vector<pair<string, string>> kv_metadata;
-	idx_t row_group_size = DEFAULT_ROW_GROUP_SIZE;
-	idx_t row_group_size_bytes = NumericLimits<idx_t>::Maximum();
-
-	//! How/Whether to encrypt the data
-	shared_ptr<ParquetEncryptionConfig> encryption_config;
-	bool debug_use_openssl = true;
-
-	//! After how many distinct values should we abandon dictionary compression and bloom filters?
-	idx_t dictionary_size_limit = row_group_size / 100;
-
-	//! What false positive rate are we willing to accept for bloom filters
-	double bloom_filter_false_positive_ratio = 0.01;
-
-	//! After how many row groups to rotate to a new file
-	optional_idx row_groups_per_file;
-
-	ChildFieldIDs field_ids;
-	//! The compression level, higher value is more
-	int64_t compression_level = ZStdFileSystem::DefaultCompressionLevel();
-};
-
-struct ParquetWriteGlobalState : public GlobalFunctionData {
-	unique_ptr<ParquetWriter> writer;
-};
-
-struct ParquetWriteLocalState : public LocalFunctionData {
-	explicit ParquetWriteLocalState(ClientContext &context, const vector<LogicalType> &types)
-	    : buffer(BufferAllocator::Get(context), types) {
-		buffer.InitializeAppend(append_state);
-	}
-
-	ColumnDataCollection buffer;
-	ColumnDataAppendState append_state;
-};
-
-BindInfo ParquetGetBindInfo(const optional_ptr<FunctionData> bind_data) {
-	auto bind_info = BindInfo(ScanType::PARQUET);
-	auto &parquet_bind = bind_data->Cast<ParquetReadBindData>();
-
-	vector<Value> file_path;
-	for (const auto &file : parquet_bind.file_list->Files()) {
-		file_path.emplace_back(file);
-	}
-
-	// LCOV_EXCL_START
-	bind_info.InsertOption("file_path", Value::LIST(LogicalType::VARCHAR, file_path));
-	bind_info.InsertOption("binary_as_string", Value::BOOLEAN(parquet_bind.parquet_options.binary_as_string));
-	bind_info.InsertOption("file_row_number", Value::BOOLEAN(parquet_bind.parquet_options.file_row_number));
-	bind_info.InsertOption("debug_use_openssl", Value::BOOLEAN(parquet_bind.parquet_options.debug_use_openssl));
-	parquet_bind.parquet_options.file_options.AddBatchInfo(bind_info);
-	// LCOV_EXCL_STOP
-	return bind_info;
-}
-
-static void ParseFileRowNumberOption(MultiFileReaderBindData &bind_data, ParquetOptions &options,
-                                     vector<LogicalType> &return_types, vector<string> &names) {
-	if (options.file_row_number) {
-		if (StringUtil::CIFind(names, "file_row_number") != DConstants::INVALID_INDEX) {
-			throw BinderException(
-			    "Using file_row_number option on file with column named file_row_number is not supported");
-		}
-
-		bind_data.file_row_number_idx = names.size();
-		return_types.emplace_back(LogicalType::BIGINT);
-		names.emplace_back("file_row_number");
-	}
-}
-
-static MultiFileReaderBindData BindSchema(ClientContext &context, vector<LogicalType> &return_types,
-                                          vector<string> &names, ParquetReadBindData &result, ParquetOptions &options) {
-	D_ASSERT(!options.schema.empty());
-
-	options.file_options.AutoDetectHivePartitioning(*result.file_list, context);
-
-	auto &file_options = options.file_options;
-	if (file_options.union_by_name || file_options.hive_partitioning) {
-		throw BinderException("Parquet schema cannot be combined with union_by_name=true or hive_partitioning=true");
-	}
-
-	vector<string> schema_col_names;
-	vector<LogicalType> schema_col_types;
-	schema_col_names.reserve(options.schema.size());
-	schema_col_types.reserve(options.schema.size());
-	for (const auto &column : options.schema) {
-		schema_col_names.push_back(column.name);
-		schema_col_types.push_back(column.type);
-	}
-
-	// perform the binding on the obtained set of names + types
-	MultiFileReaderBindData bind_data;
-	result.multi_file_reader->BindOptions(options.file_options, *result.file_list, schema_col_types, schema_col_names,
-	                                      bind_data);
-
-	names = schema_col_names;
-	return_types = schema_col_types;
-	D_ASSERT(names.size() == return_types.size());
-
-	ParseFileRowNumberOption(bind_data, options, return_types, names);
-
-	return bind_data;
-}
-
-static void InitializeParquetReader(ParquetReader &reader, const ParquetReadBindData &bind_data,
-                                    const vector<ColumnIndex> &global_column_ids,
-                                    optional_ptr<TableFilterSet> table_filters, ClientContext &context,
-                                    optional_idx file_idx, optional_ptr<MultiFileReaderGlobalState> reader_state) {
-	auto &parquet_options = bind_data.parquet_options;
-	auto &reader_data = reader.reader_data;
-
-	reader.table_columns = bind_data.table_columns;
-	// Mark the file in the file list we are scanning here
-	reader_data.file_list_idx = file_idx;
-
-	if (bind_data.parquet_options.schema.empty()) {
-		bind_data.multi_file_reader->InitializeReader(
-		    reader, parquet_options.file_options, bind_data.reader_bind, bind_data.types, bind_data.names,
-		    global_column_ids, table_filters, bind_data.file_list->GetFirstFile(), context, reader_state);
-		return;
-	}
-
-	// a fixed schema was supplied, initialize the MultiFileReader settings here so we can read using the schema
-
-	// this deals with hive partitioning and filename=true
-	bind_data.multi_file_reader->FinalizeBind(parquet_options.file_options, bind_data.reader_bind, reader.GetFileName(),
-	                                          reader.GetNames(), bind_data.types, bind_data.names, global_column_ids,
-	                                          reader_data, context, reader_state);
-
-	// create a mapping from field id to column index in file
-	unordered_map<uint32_t, idx_t> field_id_to_column_index;
-	auto &column_readers = reader.root_reader->Cast<StructColumnReader>().child_readers;
-	for (idx_t column_index = 0; column_index < column_readers.size(); column_index++) {
-		auto &column_reader = *column_readers[column_index];
-		auto &column_schema = column_reader.Schema();
-		if (column_schema.__isset.field_id) {
-			field_id_to_column_index[column_schema.field_id] = column_index;
-		} else if (column_reader.GetParentSchema()) {
-			auto &parent_column_schema = *column_reader.GetParentSchema();
-			if (parent_column_schema.__isset.field_id) {
-				field_id_to_column_index[parent_column_schema.field_id] = column_index;
-			}
-		}
-	}
-
-	// loop through the schema definition
-	for (idx_t i = 0; i < global_column_ids.size(); i++) {
-		auto global_column_index = global_column_ids[i].GetPrimaryIndex();
-
-		// check if this is a constant column
-		bool constant = false;
-		for (auto &entry : reader_data.constant_map) {
-			if (entry.column_id == i) {
-				constant = true;
-				break;
-			}
-		}
-		if (constant) {
-			// this column is constant for this file
-			continue;
-		}
-
-		// Handle any generate columns that are not in the schema (currently only file_row_number)
-		if (global_column_index >= parquet_options.schema.size()) {
-			if (bind_data.reader_bind.file_row_number_idx == global_column_index) {
-				reader_data.column_mapping.push_back(i);
-				reader_data.column_ids.push_back(reader.file_row_number_idx);
-			}
-			continue;
-		}
-
-		const auto &column_definition = parquet_options.schema[global_column_index];
-		auto it = field_id_to_column_index.find(column_definition.field_id);
-		if (it == field_id_to_column_index.end()) {
-			// field id not present in file, use default value
-			reader_data.constant_map.emplace_back(i, column_definition.default_value);
-			continue;
-		}
-
-		const auto &local_column_index = it->second;
-		auto &column_reader = column_readers[local_column_index];
-		if (column_reader->Type() != column_definition.type) {
-			// differing types, wrap in a cast column reader
-			reader_data.cast_map[local_column_index] = column_definition.type;
-		}
-
-		reader_data.column_mapping.push_back(i);
-		reader_data.column_ids.push_back(local_column_index);
-	}
-	reader_data.empty_columns = reader_data.column_ids.empty();
-
-	// Finally, initialize the filters
-	bind_data.multi_file_reader->CreateFilterMap(bind_data.types, table_filters, reader_data, reader_state);
-	reader_data.filters = table_filters;
-}
-
-static bool GetBooleanArgument(const pair<string, vector<Value>> &option) {
-	if (option.second.empty()) {
-		return true;
-	}
-	Value boolean_value;
-	string error_message;
-	if (!option.second[0].DefaultTryCastAs(LogicalType::BOOLEAN, boolean_value, &error_message)) {
-		throw InvalidInputException("Unable to cast \"%s\" to BOOLEAN for Parquet option \"%s\"",
-		                            option.second[0].ToString(), option.first);
-	}
-	return BooleanValue::Get(boolean_value);
-}
-
-TablePartitionInfo ParquetGetPartitionInfo(ClientContext &context, TableFunctionPartitionInput &input) {
-	auto &parquet_bind = input.bind_data->Cast<ParquetReadBindData>();
-	return parquet_bind.multi_file_reader->GetPartitionInfo(context, parquet_bind.reader_bind, input);
-}
-
-class ParquetScanFunction {
-public:
-	static TableFunctionSet GetFunctionSet() {
-		TableFunction table_function("parquet_scan", {LogicalType::VARCHAR}, ParquetScanImplementation, ParquetScanBind,
-		                             ParquetScanInitGlobal, ParquetScanInitLocal);
-		table_function.statistics = ParquetScanStats;
-		table_function.cardinality = ParquetCardinality;
-		table_function.table_scan_progress = ParquetProgress;
-		table_function.named_parameters["binary_as_string"] = LogicalType::BOOLEAN;
-		table_function.named_parameters["file_row_number"] = LogicalType::BOOLEAN;
-		table_function.named_parameters["debug_use_openssl"] = LogicalType::BOOLEAN;
-		table_function.named_parameters["compression"] = LogicalType::VARCHAR;
-		table_function.named_parameters["explicit_cardinality"] = LogicalType::UBIGINT;
-		table_function.named_parameters["schema"] =
-		    LogicalType::MAP(LogicalType::INTEGER, LogicalType::STRUCT({{{"name", LogicalType::VARCHAR},
-		                                                                 {"type", LogicalType::VARCHAR},
-		                                                                 {"default_value", LogicalType::VARCHAR}}}));
-		table_function.named_parameters["encryption_config"] = LogicalTypeId::ANY;
-		table_function.get_partition_data = ParquetScanGetPartitionData;
-		table_function.serialize = ParquetScanSerialize;
-		table_function.deserialize = ParquetScanDeserialize;
-		table_function.get_bind_info = ParquetGetBindInfo;
-		table_function.projection_pushdown = true;
-		table_function.filter_pushdown = true;
-		table_function.filter_prune = true;
-		table_function.pushdown_complex_filter = ParquetComplexFilterPushdown;
-		table_function.get_partition_info = ParquetGetPartitionInfo;
-
-		MultiFileReader::AddParameters(table_function);
-
-		return MultiFileReader::CreateFunctionSet(table_function);
-	}
-
-	static unique_ptr<FunctionData> ParquetReadBind(ClientContext &context, CopyInfo &info,
-	                                                vector<string> &expected_names,
-	                                                vector<LogicalType> &expected_types) {
-		D_ASSERT(expected_names.size() == expected_types.size());
-		ParquetOptions parquet_options(context);
-
-		for (auto &option : info.options) {
-			auto loption = StringUtil::Lower(option.first);
-			if (loption == "compression" || loption == "codec" || loption == "row_group_size") {
-				// CODEC/COMPRESSION and ROW_GROUP_SIZE options have no effect on parquet read.
-				// These options are determined from the file.
-				continue;
-			} else if (loption == "binary_as_string") {
-				parquet_options.binary_as_string = GetBooleanArgument(option);
-			} else if (loption == "file_row_number") {
-				parquet_options.file_row_number = GetBooleanArgument(option);
-			} else if (loption == "debug_use_openssl") {
-				parquet_options.debug_use_openssl = GetBooleanArgument(option);
-			} else if (loption == "encryption_config") {
-				if (option.second.size() != 1) {
-					throw BinderException("Parquet encryption_config cannot be empty!");
-				}
-				parquet_options.encryption_config = ParquetEncryptionConfig::Create(context, option.second[0]);
-			} else {
-				throw NotImplementedException("Unsupported option for COPY FROM parquet: %s", option.first);
-			}
-		}
-
-		// TODO: Allow overriding the MultiFileReader for COPY FROM?
-		auto multi_file_reader = MultiFileReader::CreateDefault("ParquetCopy");
-		vector<string> paths = {info.file_path};
-		auto file_list = multi_file_reader->CreateFileList(context, paths);
-
-		return ParquetScanBindInternal(context, std::move(multi_file_reader), std::move(file_list), expected_types,
-		                               expected_names, parquet_options);
-	}
-
-	static unique_ptr<BaseStatistics> ParquetScanStats(ClientContext &context, const FunctionData *bind_data_p,
-	                                                   column_t column_index) {
-		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
-
-		if (IsRowIdColumnId(column_index)) {
-			return nullptr;
-		}
-
-		// NOTE: we do not want to parse the Parquet metadata for the sole purpose of getting column statistics
-		if (bind_data.file_list->GetExpandResult() == FileExpandResult::MULTIPLE_FILES) {
-			// multiple files, no luck!
-			return nullptr;
-		}
-		if (!bind_data.initial_reader) {
-			// no reader
-			return nullptr;
-		}
-		// scanning single parquet file and we have the metadata read already
-		return bind_data.initial_reader->ReadStatistics(bind_data.names[column_index]);
-
-		return nullptr;
-	}
-
-	static unique_ptr<FunctionData> ParquetScanBindInternal(ClientContext &context,
-	                                                        unique_ptr<MultiFileReader> multi_file_reader,
-	                                                        shared_ptr<MultiFileList> file_list,
-	                                                        vector<LogicalType> &return_types, vector<string> &names,
-	                                                        ParquetOptions parquet_options) {
-		auto result = make_uniq<ParquetReadBindData>();
-		result->multi_file_reader = std::move(multi_file_reader);
-		result->file_list = std::move(file_list);
-
-		bool bound_on_first_file = true;
-		if (result->multi_file_reader->Bind(parquet_options.file_options, *result->file_list, result->types,
-		                                    result->names, result->reader_bind)) {
-			result->multi_file_reader->BindOptions(parquet_options.file_options, *result->file_list, result->types,
-			                                       result->names, result->reader_bind);
-			// Enable the parquet file_row_number on the parquet options if the file_row_number_idx was set
-			if (result->reader_bind.file_row_number_idx != DConstants::INVALID_INDEX) {
-				parquet_options.file_row_number = true;
-			}
-			bound_on_first_file = false;
-		} else if (!parquet_options.schema.empty()) {
-			// A schema was supplied: use the schema for binding
-			result->reader_bind = BindSchema(context, result->types, result->names, *result, parquet_options);
-		} else {
-			parquet_options.file_options.AutoDetectHivePartitioning(*result->file_list, context);
-			// Default bind
-			result->reader_bind = result->multi_file_reader->BindReader<ParquetReader>(
-			    context, result->types, result->names, *result->file_list, *result, parquet_options);
-		}
-		if (parquet_options.explicit_cardinality) {
-			auto file_count = result->file_list->GetTotalFileCount();
-			result->explicit_cardinality = parquet_options.explicit_cardinality;
-			result->initial_file_cardinality = result->explicit_cardinality / (file_count ? file_count : 1);
-		}
-		if (return_types.empty()) {
-			// no expected types - just copy the types
-			return_types = result->types;
-			names = result->names;
-		} else {
-			if (return_types.size() != result->types.size()) {
-				auto file_string = bound_on_first_file ? result->file_list->GetFirstFile()
-				                                       : StringUtil::Join(result->file_list->GetPaths(), ",");
-				string extended_error;
-				extended_error = "Table schema: ";
-				for (idx_t col_idx = 0; col_idx < return_types.size(); col_idx++) {
-					if (col_idx > 0) {
-						extended_error += ", ";
-					}
-					extended_error += names[col_idx] + " " + return_types[col_idx].ToString();
-				}
-				extended_error += "\nParquet schema: ";
-				for (idx_t col_idx = 0; col_idx < result->types.size(); col_idx++) {
-					if (col_idx > 0) {
-						extended_error += ", ";
-					}
-					extended_error += result->names[col_idx] + " " + result->types[col_idx].ToString();
-				}
-				extended_error += "\n\nPossible solutions:";
-				extended_error += "\n* Manually specify which columns to insert using \"INSERT INTO tbl SELECT ... "
-				                  "FROM read_parquet(...)\"";
-				throw ConversionException(
-				    "Failed to read file(s) \"%s\" - column count mismatch: expected %d columns but found %d\n%s",
-				    file_string, return_types.size(), result->types.size(), extended_error);
-			}
-			// expected types - overwrite the types we want to read instead
-			result->types = return_types;
-			result->table_columns = names;
-		}
-		result->parquet_options = parquet_options;
-		return std::move(result);
-	}
-
-	static unique_ptr<FunctionData> ParquetScanBind(ClientContext &context, TableFunctionBindInput &input,
-	                                                vector<LogicalType> &return_types, vector<string> &names) {
-		auto multi_file_reader = MultiFileReader::Create(input.table_function);
-
-		ParquetOptions parquet_options(context);
-		for (auto &kv : input.named_parameters) {
-			if (kv.second.IsNull()) {
-				throw BinderException("Cannot use NULL as function argument");
-			}
-			auto loption = StringUtil::Lower(kv.first);
-			if (multi_file_reader->ParseOption(kv.first, kv.second, parquet_options.file_options, context)) {
-				continue;
-			}
-			if (loption == "binary_as_string") {
-				parquet_options.binary_as_string = BooleanValue::Get(kv.second);
-			} else if (loption == "file_row_number") {
-				parquet_options.file_row_number = BooleanValue::Get(kv.second);
-			} else if (loption == "debug_use_openssl") {
-				parquet_options.debug_use_openssl = BooleanValue::Get(kv.second);
-			} else if (loption == "schema") {
-				// Argument is a map that defines the schema
-				const auto &schema_value = kv.second;
-				const auto column_values = ListValue::GetChildren(schema_value);
-				if (column_values.empty()) {
-					throw BinderException("Parquet schema cannot be empty");
-				}
-				parquet_options.schema.reserve(column_values.size());
-				for (idx_t i = 0; i < column_values.size(); i++) {
-					parquet_options.schema.emplace_back(
-					    ParquetColumnDefinition::FromSchemaValue(context, column_values[i]));
-				}
-
-				// cannot be combined with hive_partitioning=true, so we disable auto-detection
-				parquet_options.file_options.auto_detect_hive_partitioning = false;
-			} else if (loption == "explicit_cardinality") {
-				parquet_options.explicit_cardinality = UBigIntValue::Get(kv.second);
-			} else if (loption == "encryption_config") {
-				parquet_options.encryption_config = ParquetEncryptionConfig::Create(context, kv.second);
-			}
-		}
-
-		auto file_list = multi_file_reader->CreateFileList(context, input.inputs[0]);
-		return ParquetScanBindInternal(context, std::move(multi_file_reader), std::move(file_list), return_types, names,
-		                               parquet_options);
-	}
-
-	static double ParquetProgress(ClientContext &context, const FunctionData *bind_data_p,
-	                              const GlobalTableFunctionState *global_state) {
-		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
-		auto &gstate = global_state->Cast<ParquetReadGlobalState>();
-
-		auto total_count = gstate.file_list.GetTotalFileCount();
-		if (total_count == 0) {
-			return 100.0;
-		}
-		if (bind_data.initial_file_cardinality == 0) {
-			return (100.0 * (static_cast<double>(gstate.file_index) + 1.0)) / static_cast<double>(total_count);
-		}
-		auto percentage = MinValue<double>(100.0, (static_cast<double>(bind_data.chunk_count) * STANDARD_VECTOR_SIZE *
-		                                           100.0 / static_cast<double>(bind_data.initial_file_cardinality)));
-		return (percentage + 100.0 * static_cast<double>(gstate.file_index)) / static_cast<double>(total_count);
-	}
-
-	static unique_ptr<LocalTableFunctionState>
-	ParquetScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input, GlobalTableFunctionState *gstate_p) {
-		auto &bind_data = input.bind_data->Cast<ParquetReadBindData>();
-		auto &gstate = gstate_p->Cast<ParquetReadGlobalState>();
-
-		auto result = make_uniq<ParquetReadLocalState>();
-		result->is_parallel = true;
-		result->batch_index = 0;
-
-		if (gstate.CanRemoveColumns()) {
-			result->all_columns.Initialize(context.client, gstate.scanned_types);
-		}
-		if (!ParquetParallelStateNext(context.client, bind_data, *result, gstate)) {
-			return nullptr;
-		}
-		return std::move(result);
-	}
-
-	static unique_ptr<MultiFileList> ParquetDynamicFilterPushdown(ClientContext &context,
-	                                                              const ParquetReadBindData &data,
-	                                                              const vector<column_t> &column_ids,
-	                                                              optional_ptr<TableFilterSet> filters) {
-		if (!filters) {
-			return nullptr;
-		}
-		auto new_list = data.multi_file_reader->DynamicFilterPushdown(
-		    context, *data.file_list, data.parquet_options.file_options, data.names, data.types, column_ids, *filters);
-		return new_list;
-	}
-
-	static unique_ptr<GlobalTableFunctionState> ParquetScanInitGlobal(ClientContext &context,
-	                                                                  TableFunctionInitInput &input) {
-		auto &bind_data = input.bind_data->CastNoConst<ParquetReadBindData>();
-		unique_ptr<ParquetReadGlobalState> result;
-
-		// before instantiating a scan trigger a dynamic filter pushdown if possible
-		auto new_list = ParquetDynamicFilterPushdown(context, bind_data, input.column_ids, input.filters);
-		if (new_list) {
-			result = make_uniq<ParquetReadGlobalState>(std::move(new_list));
-		} else {
-			result = make_uniq<ParquetReadGlobalState>(*bind_data.file_list);
-		}
-		auto &file_list = result->file_list;
-		file_list.InitializeScan(result->file_list_scan);
-
-		result->multi_file_reader_state = bind_data.multi_file_reader->InitializeGlobalState(
-		    context, bind_data.parquet_options.file_options, bind_data.reader_bind, file_list, bind_data.types,
-		    bind_data.names, input.column_indexes);
-		if (file_list.IsEmpty()) {
-			result->readers = {};
-		} else if (!bind_data.union_readers.empty()) {
-			// TODO: confirm we are not changing behaviour by modifying the order here?
-			for (auto &reader : bind_data.union_readers) {
-				if (!reader) {
-					break;
-				}
-				result->readers.push_back(make_uniq<ParquetFileReaderData>(std::move(reader)));
-			}
-			if (result->readers.size() != file_list.GetTotalFileCount()) {
-				// This case happens with recursive CTEs: the first execution the readers have already
-				// been moved out of the bind data.
-				// FIXME: clean up this process and make it more explicit
-				result->readers = {};
-			}
-		} else if (bind_data.initial_reader) {
-			// we can only use the initial reader if it was constructed from the first file
-			if (bind_data.initial_reader->file_name == file_list.GetFirstFile()) {
-				result->readers.push_back(make_uniq<ParquetFileReaderData>(std::move(bind_data.initial_reader)));
-			}
-		}
-
-		// Ensure all readers are initialized and FileListScan is sync with readers list
-		for (auto &reader_data : result->readers) {
-			string file_name;
-			idx_t file_idx = result->file_list_scan.current_file_idx;
-			file_list.Scan(result->file_list_scan, file_name);
-			if (reader_data->union_data) {
-				if (file_name != reader_data->union_data->GetFileName()) {
-					throw InternalException("Mismatch in filename order and union reader order in parquet scan");
-				}
-			} else {
-				D_ASSERT(reader_data->reader);
-				if (file_name != reader_data->reader->file_name) {
-					throw InternalException("Mismatch in filename order and reader order in parquet scan");
-				}
-				InitializeParquetReader(*reader_data->reader, bind_data, input.column_indexes, input.filters, context,
-				                        file_idx, result->multi_file_reader_state);
-			}
-		}
-
-		result->column_indexes = input.column_indexes;
-		result->filters = input.filters.get();
-		result->row_group_index = 0;
-		result->file_index = 0;
-		result->batch_index = 0;
-		result->max_threads = ParquetScanMaxThreads(context, input.bind_data.get());
-
-		bool require_extra_columns =
-		    result->multi_file_reader_state && result->multi_file_reader_state->RequiresExtraColumns();
-		if (input.CanRemoveFilterColumns() || require_extra_columns) {
-			if (!input.projection_ids.empty()) {
-				result->projection_ids = input.projection_ids;
-			} else {
-				result->projection_ids.resize(input.column_indexes.size());
-				iota(begin(result->projection_ids), end(result->projection_ids), 0);
-			}
-
-			const auto table_types = bind_data.types;
-			for (const auto &col_idx : input.column_indexes) {
-				if (col_idx.IsRowIdColumn()) {
-					result->scanned_types.emplace_back(LogicalType::ROW_TYPE);
-				} else {
-					result->scanned_types.push_back(table_types[col_idx.GetPrimaryIndex()]);
-				}
-			}
-		}
-
-		if (require_extra_columns) {
-			for (const auto &column_type : result->multi_file_reader_state->extra_columns) {
-				result->scanned_types.push_back(column_type);
-			}
-		}
-
-		return std::move(result);
-	}
-
-	static OperatorPartitionData ParquetScanGetPartitionData(ClientContext &context,
-	                                                         TableFunctionGetPartitionInput &input) {
-		auto &bind_data = input.bind_data->CastNoConst<ParquetReadBindData>();
-		auto &data = input.local_state->Cast<ParquetReadLocalState>();
-		auto &gstate = input.global_state->Cast<ParquetReadGlobalState>();
-		OperatorPartitionData partition_data(data.batch_index);
-		bind_data.multi_file_reader->GetPartitionData(context, bind_data.reader_bind, data.reader->reader_data,
-		                                              gstate.multi_file_reader_state, input.partition_info,
-		                                              partition_data);
-		return partition_data;
-	}
-
-	static void ParquetScanSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                                 const TableFunction &function) {
-		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
-
-		serializer.WriteProperty(100, "files", bind_data.file_list->GetAllFiles());
-		serializer.WriteProperty(101, "types", bind_data.types);
-		serializer.WriteProperty(102, "names", bind_data.names);
-		serializer.WriteProperty(103, "parquet_options", bind_data.parquet_options);
-		if (serializer.ShouldSerialize(3)) {
-			serializer.WriteProperty(104, "table_columns", bind_data.table_columns);
-		}
-	}
-
-	static unique_ptr<FunctionData> ParquetScanDeserialize(Deserializer &deserializer, TableFunction &function) {
-		auto &context = deserializer.Get<ClientContext &>();
-		auto files = deserializer.ReadProperty<vector<string>>(100, "files");
-		auto types = deserializer.ReadProperty<vector<LogicalType>>(101, "types");
-		auto names = deserializer.ReadProperty<vector<string>>(102, "names");
-		auto parquet_options = deserializer.ReadProperty<ParquetOptions>(103, "parquet_options");
-		auto table_columns =
-		    deserializer.ReadPropertyWithExplicitDefault<vector<string>>(104, "table_columns", vector<string> {});
-
-		vector<Value> file_path;
-		for (auto &path : files) {
-			file_path.emplace_back(path);
-		}
-
-		auto multi_file_reader = MultiFileReader::Create(function);
-		auto file_list = multi_file_reader->CreateFileList(context, Value::LIST(LogicalType::VARCHAR, file_path),
-		                                                   FileGlobOptions::DISALLOW_EMPTY);
-		auto bind_data = ParquetScanBindInternal(context, std::move(multi_file_reader), std::move(file_list), types,
-		                                         names, parquet_options);
-		bind_data->Cast<ParquetReadBindData>().table_columns = std::move(table_columns);
-		return bind_data;
-	}
-
-	static void ParquetScanImplementation(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-		if (!data_p.local_state) {
-			return;
-		}
-		auto &data = data_p.local_state->Cast<ParquetReadLocalState>();
-		auto &gstate = data_p.global_state->Cast<ParquetReadGlobalState>();
-		auto &bind_data = data_p.bind_data->CastNoConst<ParquetReadBindData>();
-
-		bool rowgroup_finished;
-		do {
-			if (gstate.CanRemoveColumns()) {
-				data.all_columns.Reset();
-				data.reader->Scan(data.scan_state, data.all_columns);
-				rowgroup_finished = data.all_columns.size() == 0;
-				bind_data.multi_file_reader->FinalizeChunk(context, bind_data.reader_bind, data.reader->reader_data,
-				                                           data.all_columns, gstate.multi_file_reader_state);
-				output.ReferenceColumns(data.all_columns, gstate.projection_ids);
-			} else {
-				data.reader->Scan(data.scan_state, output);
-				rowgroup_finished = output.size() == 0;
-				bind_data.multi_file_reader->FinalizeChunk(context, bind_data.reader_bind, data.reader->reader_data,
-				                                           output, gstate.multi_file_reader_state);
-			}
-
-			bind_data.chunk_count++;
-			if (output.size() > 0) {
-				return;
-			}
-			if (rowgroup_finished && !ParquetParallelStateNext(context, bind_data, data, gstate)) {
-				return;
-			}
-		} while (true);
-	}
-
-	static unique_ptr<NodeStatistics> ParquetCardinality(ClientContext &context, const FunctionData *bind_data) {
-		auto &data = bind_data->Cast<ParquetReadBindData>();
-		if (data.explicit_cardinality) {
-			return make_uniq<NodeStatistics>(data.explicit_cardinality);
-		}
-		auto file_list_cardinality_estimate = data.file_list->GetCardinality(context);
-		if (file_list_cardinality_estimate) {
-			return file_list_cardinality_estimate;
-		}
-		return make_uniq<NodeStatistics>(MaxValue(data.initial_file_cardinality, (idx_t)1) *
-		                                 data.file_list->GetTotalFileCount());
-	}
-
-	static idx_t ParquetScanMaxThreads(ClientContext &context, const FunctionData *bind_data) {
-		auto &data = bind_data->Cast<ParquetReadBindData>();
-
-		if (data.file_list->GetExpandResult() == FileExpandResult::MULTIPLE_FILES) {
-			return TaskScheduler::GetScheduler(context).NumberOfThreads();
-		}
-
-		return MaxValue(data.initial_file_row_groups, (idx_t)1);
-	}
-
-	// Queries the metadataprovider for another file to scan, updating the files/reader lists in the process.
-	// Returns true if resized
-	static bool ResizeFiles(ParquetReadGlobalState &parallel_state) {
-		string scanned_file;
-		if (!parallel_state.file_list.Scan(parallel_state.file_list_scan, scanned_file)) {
-			return false;
-		}
-
-		// Push the file in the reader data, to be opened later
-		parallel_state.readers.push_back(make_uniq<ParquetFileReaderData>(scanned_file));
-
-		return true;
-	}
-
-	// This function looks for the next available row group. If not available, it will open files from bind_data.files
-	// until there is a row group available for scanning or the files runs out
-	static bool ParquetParallelStateNext(ClientContext &context, const ParquetReadBindData &bind_data,
-	                                     ParquetReadLocalState &scan_data, ParquetReadGlobalState &parallel_state) {
-		unique_lock<mutex> parallel_lock(parallel_state.lock);
-
-		while (true) {
-			if (parallel_state.error_opening_file) {
-				return false;
-			}
-
-			if (parallel_state.file_index >= parallel_state.readers.size() && !ResizeFiles(parallel_state)) {
-				return false;
-			}
-
-			auto &current_reader_data = *parallel_state.readers[parallel_state.file_index];
-			if (current_reader_data.file_state == ParquetFileState::OPEN) {
-				if (parallel_state.row_group_index < current_reader_data.reader->NumRowGroups()) {
-					// The current reader has rowgroups left to be scanned
-					scan_data.reader = current_reader_data.reader;
-					vector<idx_t> group_indexes {parallel_state.row_group_index};
-					scan_data.reader->InitializeScan(context, scan_data.scan_state, group_indexes);
-					scan_data.batch_index = parallel_state.batch_index++;
-					scan_data.file_index = parallel_state.file_index;
-					parallel_state.row_group_index++;
-					return true;
-				} else {
-					// Close current file
-					current_reader_data.file_state = ParquetFileState::CLOSED;
-					current_reader_data.reader = nullptr;
-
-					// Set state to the next file
-					parallel_state.file_index++;
-					parallel_state.row_group_index = 0;
-
-					continue;
-				}
-			}
-
-			if (TryOpenNextFile(context, bind_data, scan_data, parallel_state, parallel_lock)) {
-				continue;
-			}
-
-			// Check if the current file is being opened, in that case we need to wait for it.
-			if (current_reader_data.file_state == ParquetFileState::OPENING) {
-				WaitForFile(parallel_state.file_index, parallel_state, parallel_lock);
-			}
-		}
-	}
-
-	static void ParquetComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
-	                                         vector<unique_ptr<Expression>> &filters) {
-		auto &data = bind_data_p->Cast<ParquetReadBindData>();
-
-		MultiFilePushdownInfo info(get);
-		auto new_list = data.multi_file_reader->ComplexFilterPushdown(context, *data.file_list,
-		                                                              data.parquet_options.file_options, info, filters);
-
-		if (new_list) {
-			data.file_list = std::move(new_list);
-			MultiFileReader::PruneReaders(data, *data.file_list);
-		}
-	}
-
-	//! Wait for a file to become available. Parallel lock should be locked when calling.
-	static void WaitForFile(idx_t file_index, ParquetReadGlobalState &parallel_state,
-	                        unique_lock<mutex> &parallel_lock) {
-		while (true) {
-			// Get pointer to file mutex before unlocking
-			auto &file_mutex = *parallel_state.readers[file_index]->file_mutex;
-
-			// To get the file lock, we first need to release the parallel_lock to prevent deadlocking. Note that this
-			// requires getting the ref to the file mutex pointer with the lock stil held: readers get be resized
-			parallel_lock.unlock();
-			unique_lock<mutex> current_file_lock(file_mutex);
-			parallel_lock.lock();
-
-			// Here we have both locks which means we can stop waiting if:
-			// - the thread opening the file is done and the file is available
-			// - the thread opening the file has failed
-			// - the file was somehow scanned till the end while we were waiting
-			if (parallel_state.file_index >= parallel_state.readers.size() ||
-			    parallel_state.readers[parallel_state.file_index]->file_state != ParquetFileState::OPENING ||
-			    parallel_state.error_opening_file) {
-				return;
-			}
-		}
-	}
-
-	//! Helper function that try to start opening a next file. Parallel lock should be locked when calling.
-	static bool TryOpenNextFile(ClientContext &context, const ParquetReadBindData &bind_data,
-	                            ParquetReadLocalState &scan_data, ParquetReadGlobalState &parallel_state,
-	                            unique_lock<mutex> &parallel_lock) {
-		const auto file_index_limit =
-		    parallel_state.file_index + TaskScheduler::GetScheduler(context).NumberOfThreads();
-
-		for (idx_t i = parallel_state.file_index; i < file_index_limit; i++) {
-			// We check if we can resize files in this loop too otherwise we will only ever open 1 file ahead
-			if (i >= parallel_state.readers.size() && !ResizeFiles(parallel_state)) {
-				return false;
-			}
-
-			auto &current_reader_data = *parallel_state.readers[i];
-			if (current_reader_data.file_state == ParquetFileState::UNOPENED) {
-				current_reader_data.file_state = ParquetFileState::OPENING;
-				auto pq_options = bind_data.parquet_options;
-
-				// Get pointer to file mutex before unlocking
-				auto &current_file_lock = *current_reader_data.file_mutex;
-
-				// Now we switch which lock we are holding, instead of locking the global state, we grab the lock on
-				// the file we are opening. This file lock allows threads to wait for a file to be opened.
-				parallel_lock.unlock();
-				unique_lock<mutex> file_lock(current_file_lock);
-
-				shared_ptr<ParquetReader> reader;
-				try {
-					if (current_reader_data.union_data) {
-						auto &union_data = *current_reader_data.union_data;
-						reader = make_shared_ptr<ParquetReader>(context, union_data.file_name, union_data.options,
-						                                        union_data.metadata);
-					} else {
-						reader =
-						    make_shared_ptr<ParquetReader>(context, current_reader_data.file_to_be_opened, pq_options);
-					}
-					InitializeParquetReader(*reader, bind_data, parallel_state.column_indexes, parallel_state.filters,
-					                        context, i, parallel_state.multi_file_reader_state);
-				} catch (...) {
-					parallel_lock.lock();
-					parallel_state.error_opening_file = true;
-					throw;
-				}
-
-				// Now re-lock the state and add the reader
-				parallel_lock.lock();
-				current_reader_data.reader = std::move(reader);
-				current_reader_data.file_state = ParquetFileState::OPEN;
-
-				return true;
-			}
-		}
-
-		return false;
-	}
-};
-
-static case_insensitive_map_t<LogicalType> GetChildNameToTypeMap(const LogicalType &type) {
-	case_insensitive_map_t<LogicalType> name_to_type_map;
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-		name_to_type_map.emplace("element", ListType::GetChildType(type));
-		break;
-	case LogicalTypeId::MAP:
-		name_to_type_map.emplace("key", MapType::KeyType(type));
-		name_to_type_map.emplace("value", MapType::ValueType(type));
-		break;
-	case LogicalTypeId::STRUCT:
-		for (auto &child_type : StructType::GetChildTypes(type)) {
-			if (child_type.first == FieldID::DUCKDB_FIELD_ID) {
-				throw BinderException("Cannot have column named \"%s\" with FIELD_IDS", FieldID::DUCKDB_FIELD_ID);
-			}
-			name_to_type_map.emplace(child_type);
-		}
-		break;
-	default: // LCOV_EXCL_START
-		throw InternalException("Unexpected type in GetChildNameToTypeMap");
-	} // LCOV_EXCL_STOP
-	return name_to_type_map;
-}
-
-static void GetChildNamesAndTypes(const LogicalType &type, vector<string> &child_names,
-                                  vector<LogicalType> &child_types) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-		child_names.emplace_back("element");
-		child_types.emplace_back(ListType::GetChildType(type));
-		break;
-	case LogicalTypeId::MAP:
-		child_names.emplace_back("key");
-		child_names.emplace_back("value");
-		child_types.emplace_back(MapType::KeyType(type));
-		child_types.emplace_back(MapType::ValueType(type));
-		break;
-	case LogicalTypeId::STRUCT:
-		for (auto &child_type : StructType::GetChildTypes(type)) {
-			child_names.emplace_back(child_type.first);
-			child_types.emplace_back(child_type.second);
-		}
-		break;
-	default: // LCOV_EXCL_START
-		throw InternalException("Unexpected type in GetChildNamesAndTypes");
-	} // LCOV_EXCL_STOP
-}
-
-static void GenerateFieldIDs(ChildFieldIDs &field_ids, idx_t &field_id, const vector<string> &names,
-                             const vector<LogicalType> &sql_types) {
-	D_ASSERT(names.size() == sql_types.size());
-	for (idx_t col_idx = 0; col_idx < names.size(); col_idx++) {
-		const auto &col_name = names[col_idx];
-		auto inserted = field_ids.ids->insert(make_pair(col_name, FieldID(UnsafeNumericCast<int32_t>(field_id++))));
-		D_ASSERT(inserted.second);
-
-		const auto &col_type = sql_types[col_idx];
-		if (col_type.id() != LogicalTypeId::LIST && col_type.id() != LogicalTypeId::MAP &&
-		    col_type.id() != LogicalTypeId::STRUCT) {
-			continue;
-		}
-
-		// Cannot use GetChildNameToTypeMap here because we lose order, and we want to generate depth-first
-		vector<string> child_names;
-		vector<LogicalType> child_types;
-		GetChildNamesAndTypes(col_type, child_names, child_types);
-
-		GenerateFieldIDs(inserted.first->second.child_field_ids, field_id, child_names, child_types);
-	}
-}
-
-static void GetFieldIDs(const Value &field_ids_value, ChildFieldIDs &field_ids,
-                        unordered_set<uint32_t> &unique_field_ids,
-                        const case_insensitive_map_t<LogicalType> &name_to_type_map) {
-	const auto &struct_type = field_ids_value.type();
-	if (struct_type.id() != LogicalTypeId::STRUCT) {
-		throw BinderException(
-		    "Expected FIELD_IDS to be a STRUCT, e.g., {col1: 42, col2: {%s: 43, nested_col: 44}, col3: 44}",
-		    FieldID::DUCKDB_FIELD_ID);
-	}
-	const auto &struct_children = StructValue::GetChildren(field_ids_value);
-	D_ASSERT(StructType::GetChildTypes(struct_type).size() == struct_children.size());
-	for (idx_t i = 0; i < struct_children.size(); i++) {
-		const auto &col_name = StringUtil::Lower(StructType::GetChildName(struct_type, i));
-		if (col_name == FieldID::DUCKDB_FIELD_ID) {
-			continue;
-		}
-
-		auto it = name_to_type_map.find(col_name);
-		if (it == name_to_type_map.end()) {
-			string names;
-			for (const auto &name : name_to_type_map) {
-				if (!names.empty()) {
-					names += ", ";
-				}
-				names += name.first;
-			}
-			throw BinderException(
-			    "Column name \"%s\" specified in FIELD_IDS not found. Consider using WRITE_PARTITION_COLUMNS if this "
-			    "column is a partition column. Available column names: [%s]",
-			    col_name, names);
-		}
-		D_ASSERT(field_ids.ids->find(col_name) == field_ids.ids->end()); // Caught by STRUCT - deduplicates keys
-
-		const auto &child_value = struct_children[i];
-		const auto &child_type = child_value.type();
-		optional_ptr<const Value> field_id_value;
-		optional_ptr<const Value> child_field_ids_value;
-
-		if (child_type.id() == LogicalTypeId::STRUCT) {
-			const auto &nested_children = StructValue::GetChildren(child_value);
-			D_ASSERT(StructType::GetChildTypes(child_type).size() == nested_children.size());
-			for (idx_t nested_i = 0; nested_i < nested_children.size(); nested_i++) {
-				const auto &field_id_or_nested_col = StructType::GetChildName(child_type, nested_i);
-				if (field_id_or_nested_col == FieldID::DUCKDB_FIELD_ID) {
-					field_id_value = &nested_children[nested_i];
-				} else {
-					child_field_ids_value = &child_value;
-				}
-			}
-		} else {
-			field_id_value = &child_value;
-		}
-
-		FieldID field_id;
-		if (field_id_value) {
-			Value field_id_integer_value = field_id_value->DefaultCastAs(LogicalType::INTEGER);
-			const uint32_t field_id_int = IntegerValue::Get(field_id_integer_value);
-			if (!unique_field_ids.insert(field_id_int).second) {
-				throw BinderException("Duplicate field_id %s found in FIELD_IDS", field_id_integer_value.ToString());
-			}
-			field_id = FieldID(UnsafeNumericCast<int32_t>(field_id_int));
-		}
-		auto inserted = field_ids.ids->insert(make_pair(col_name, std::move(field_id)));
-		D_ASSERT(inserted.second);
-
-		if (child_field_ids_value) {
-			const auto &col_type = it->second;
-			if (col_type.id() != LogicalTypeId::LIST && col_type.id() != LogicalTypeId::MAP &&
-			    col_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException("Column \"%s\" with type \"%s\" cannot have a nested FIELD_IDS specification",
-				                      col_name, LogicalTypeIdToString(col_type.id()));
-			}
-
-			GetFieldIDs(*child_field_ids_value, inserted.first->second.child_field_ids, unique_field_ids,
-			            GetChildNameToTypeMap(col_type));
-		}
-	}
-}
-
-unique_ptr<FunctionData> ParquetWriteBind(ClientContext &context, CopyFunctionBindInput &input,
-                                          const vector<string> &names, const vector<LogicalType> &sql_types) {
-	D_ASSERT(names.size() == sql_types.size());
-	bool row_group_size_bytes_set = false;
-	bool compression_level_set = false;
-	auto bind_data = make_uniq<ParquetWriteBindData>();
-	for (auto &option : input.info.options) {
-		const auto loption = StringUtil::Lower(option.first);
-		if (option.second.size() != 1) {
-			// All parquet write options require exactly one argument
-			throw BinderException("%s requires exactly one argument", StringUtil::Upper(loption));
-		}
-		if (loption == "row_group_size" || loption == "chunk_size") {
-			bind_data->row_group_size = option.second[0].GetValue<uint64_t>();
-		} else if (loption == "row_group_size_bytes") {
-			auto roption = option.second[0];
-			if (roption.GetTypeMutable().id() == LogicalTypeId::VARCHAR) {
-				bind_data->row_group_size_bytes = DBConfig::ParseMemoryLimit(roption.ToString());
-			} else {
-				bind_data->row_group_size_bytes = option.second[0].GetValue<uint64_t>();
-			}
-			row_group_size_bytes_set = true;
-		} else if (loption == "row_groups_per_file") {
-			bind_data->row_groups_per_file = option.second[0].GetValue<uint64_t>();
-		} else if (loption == "compression" || loption == "codec") {
-			const auto roption = StringUtil::Lower(option.second[0].ToString());
-			if (roption == "uncompressed") {
-				bind_data->codec = duckdb_parquet::CompressionCodec::UNCOMPRESSED;
-			} else if (roption == "snappy") {
-				bind_data->codec = duckdb_parquet::CompressionCodec::SNAPPY;
-			} else if (roption == "gzip") {
-				bind_data->codec = duckdb_parquet::CompressionCodec::GZIP;
-			} else if (roption == "zstd") {
-				bind_data->codec = duckdb_parquet::CompressionCodec::ZSTD;
-			} else if (roption == "brotli") {
-				bind_data->codec = duckdb_parquet::CompressionCodec::BROTLI;
-			} else if (roption == "lz4" || roption == "lz4_raw") {
-				/* LZ4 is technically another compression scheme, but deprecated and arrow also uses them
-				 * interchangeably */
-				bind_data->codec = duckdb_parquet::CompressionCodec::LZ4_RAW;
-			} else {
-				throw BinderException("Expected %s argument to be either [uncompressed, brotli, gzip, snappy, or zstd]",
-				                      loption);
-			}
-		} else if (loption == "field_ids") {
-			if (option.second[0].type().id() == LogicalTypeId::VARCHAR &&
-			    StringUtil::Lower(StringValue::Get(option.second[0])) == "auto") {
-				idx_t field_id = 0;
-				GenerateFieldIDs(bind_data->field_ids, field_id, names, sql_types);
-			} else {
-				unordered_set<uint32_t> unique_field_ids;
-				case_insensitive_map_t<LogicalType> name_to_type_map;
-				for (idx_t col_idx = 0; col_idx < names.size(); col_idx++) {
-					if (names[col_idx] == FieldID::DUCKDB_FIELD_ID) {
-						throw BinderException("Cannot have a column named \"%s\" when writing FIELD_IDS",
-						                      FieldID::DUCKDB_FIELD_ID);
-					}
-					name_to_type_map.emplace(names[col_idx], sql_types[col_idx]);
-				}
-				GetFieldIDs(option.second[0], bind_data->field_ids, unique_field_ids, name_to_type_map);
-			}
-		} else if (loption == "kv_metadata") {
-			auto &kv_struct = option.second[0];
-			auto &kv_struct_type = kv_struct.type();
-			if (kv_struct_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException("Expected kv_metadata argument to be a STRUCT");
-			}
-			auto values = StructValue::GetChildren(kv_struct);
-			for (idx_t i = 0; i < values.size(); i++) {
-				auto value = values[i];
-				auto key = StructType::GetChildName(kv_struct_type, i);
-				// If the value is a blob, write the raw blob bytes
-				// otherwise, cast to string
-				if (value.type().id() == LogicalTypeId::BLOB) {
-					bind_data->kv_metadata.emplace_back(key, StringValue::Get(value));
-				} else {
-					bind_data->kv_metadata.emplace_back(key, value.ToString());
-				}
-			}
-		} else if (loption == "encryption_config") {
-			bind_data->encryption_config = ParquetEncryptionConfig::Create(context, option.second[0]);
-		} else if (loption == "dictionary_compression_ratio_threshold") {
-			// deprecated, ignore setting
-		} else if (loption == "dictionary_size_limit") {
-			auto val = option.second[0].GetValue<int64_t>();
-			if (val < 0) {
-				throw BinderException("dictionary_size_limit must be greater than 0 or 0 to disable");
-			}
-			bind_data->dictionary_size_limit = val;
-		} else if (loption == "bloom_filter_false_positive_ratio") {
-			auto val = option.second[0].GetValue<double>();
-			if (val <= 0) {
-				throw BinderException("bloom_filter_false_positive_ratio must be greater than 0");
-			}
-			bind_data->bloom_filter_false_positive_ratio = val;
-		} else if (loption == "debug_use_openssl") {
-			auto val = StringUtil::Lower(option.second[0].GetValue<std::string>());
-			if (val == "false") {
-				bind_data->debug_use_openssl = false;
-			} else if (val == "true") {
-				bind_data->debug_use_openssl = true;
-			} else {
-				throw BinderException("Expected debug_use_openssl to be a BOOLEAN");
-			}
-		} else if (loption == "compression_level") {
-			const auto val = option.second[0].GetValue<int64_t>();
-			if (val < ZStdFileSystem::MinimumCompressionLevel() || val > ZStdFileSystem::MaximumCompressionLevel()) {
-				throw BinderException("Compression level must be between %lld and %lld",
-				                      ZStdFileSystem::MinimumCompressionLevel(),
-				                      ZStdFileSystem::MaximumCompressionLevel());
-			}
-			bind_data->compression_level = val;
-			compression_level_set = true;
-		} else {
-			throw NotImplementedException("Unrecognized option for PARQUET: %s", option.first.c_str());
-		}
-	}
-	if (row_group_size_bytes_set) {
-		if (DBConfig::GetConfig(context).options.preserve_insertion_order) {
-			throw BinderException("ROW_GROUP_SIZE_BYTES does not work while preserving insertion order. Use \"SET "
-			                      "preserve_insertion_order=false;\" to disable preserving insertion order.");
-		}
-	}
-
-	if (compression_level_set && bind_data->codec != CompressionCodec::ZSTD) {
-		throw BinderException("Compression level is only supported for the ZSTD compression codec");
-	}
-
-	bind_data->sql_types = sql_types;
-	bind_data->column_names = names;
-	return std::move(bind_data);
-}
-
-unique_ptr<GlobalFunctionData> ParquetWriteInitializeGlobal(ClientContext &context, FunctionData &bind_data,
-                                                            const string &file_path) {
-	auto global_state = make_uniq<ParquetWriteGlobalState>();
-	auto &parquet_bind = bind_data.Cast<ParquetWriteBindData>();
-
-	auto &fs = FileSystem::GetFileSystem(context);
-	global_state->writer = make_uniq<ParquetWriter>(
-	    context, fs, file_path, parquet_bind.sql_types, parquet_bind.column_names, parquet_bind.codec,
-	    parquet_bind.field_ids.Copy(), parquet_bind.kv_metadata, parquet_bind.encryption_config,
-	    parquet_bind.dictionary_size_limit, parquet_bind.bloom_filter_false_positive_ratio,
-	    parquet_bind.compression_level, parquet_bind.debug_use_openssl);
-	return std::move(global_state);
-}
-
-void ParquetWriteSink(ExecutionContext &context, FunctionData &bind_data_p, GlobalFunctionData &gstate,
-                      LocalFunctionData &lstate, DataChunk &input) {
-	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
-	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
-	auto &local_state = lstate.Cast<ParquetWriteLocalState>();
-
-	// append data to the local (buffered) chunk collection
-	local_state.buffer.Append(local_state.append_state, input);
-
-	if (local_state.buffer.Count() >= bind_data.row_group_size ||
-	    local_state.buffer.SizeInBytes() >= bind_data.row_group_size_bytes) {
-		// if the chunk collection exceeds a certain size (rows/bytes) we flush it to the parquet file
-		local_state.append_state.current_chunk_state.handles.clear();
-		global_state.writer->Flush(local_state.buffer);
-		local_state.buffer.InitializeAppend(local_state.append_state);
-	}
-}
-
-void ParquetWriteCombine(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                         LocalFunctionData &lstate) {
-	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
-	auto &local_state = lstate.Cast<ParquetWriteLocalState>();
-	// flush any data left in the local state to the file
-	global_state.writer->Flush(local_state.buffer);
-}
-
-void ParquetWriteFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
-	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
-	// finalize: write any additional metadata to the file here
-	global_state.writer->Finalize();
-}
-
-unique_ptr<LocalFunctionData> ParquetWriteInitializeLocal(ExecutionContext &context, FunctionData &bind_data_p) {
-	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
-	return make_uniq<ParquetWriteLocalState>(context.client, bind_data.sql_types);
-}
-
-// LCOV_EXCL_START
-
-// FIXME: Have these be generated instead
-template <>
-const char *EnumUtil::ToChars<duckdb_parquet::CompressionCodec::type>(duckdb_parquet::CompressionCodec::type value) {
-	switch (value) {
-	case CompressionCodec::UNCOMPRESSED:
-		return "UNCOMPRESSED";
-		break;
-	case CompressionCodec::SNAPPY:
-		return "SNAPPY";
-		break;
-	case CompressionCodec::GZIP:
-		return "GZIP";
-		break;
-	case CompressionCodec::LZO:
-		return "LZO";
-		break;
-	case CompressionCodec::BROTLI:
-		return "BROTLI";
-		break;
-	case CompressionCodec::LZ4:
-		return "LZ4";
-		break;
-	case CompressionCodec::LZ4_RAW:
-		return "LZ4_RAW";
-		break;
-	case CompressionCodec::ZSTD:
-		return "ZSTD";
-		break;
-	default:
-		throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
-	}
-}
-
-template <>
-duckdb_parquet::CompressionCodec::type EnumUtil::FromString<duckdb_parquet::CompressionCodec::type>(const char *value) {
-	if (StringUtil::Equals(value, "UNCOMPRESSED")) {
-		return CompressionCodec::UNCOMPRESSED;
-	}
-	if (StringUtil::Equals(value, "SNAPPY")) {
-		return CompressionCodec::SNAPPY;
-	}
-	if (StringUtil::Equals(value, "GZIP")) {
-		return CompressionCodec::GZIP;
-	}
-	if (StringUtil::Equals(value, "LZO")) {
-		return CompressionCodec::LZO;
-	}
-	if (StringUtil::Equals(value, "BROTLI")) {
-		return CompressionCodec::BROTLI;
-	}
-	if (StringUtil::Equals(value, "LZ4")) {
-		return CompressionCodec::LZ4;
-	}
-	if (StringUtil::Equals(value, "LZ4_RAW")) {
-		return CompressionCodec::LZ4_RAW;
-	}
-	if (StringUtil::Equals(value, "ZSTD")) {
-		return CompressionCodec::ZSTD;
-	}
-	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
-}
-
-static optional_idx SerializeCompressionLevel(const int64_t compression_level) {
-	return compression_level < 0 ? NumericLimits<idx_t>::Maximum() - NumericCast<idx_t>(AbsValue(compression_level))
-	                             : NumericCast<idx_t>(compression_level);
-}
-
-static int64_t DeserializeCompressionLevel(const optional_idx compression_level) {
-	// Was originally an optional_idx, now int64_t, so we still serialize as such
-	if (!compression_level.IsValid()) {
-		return ZStdFileSystem::DefaultCompressionLevel();
-	}
-	if (compression_level.GetIndex() > NumericCast<idx_t>(ZStdFileSystem::MaximumCompressionLevel())) {
-		// restore the negative compression level
-		return -NumericCast<int64_t>(NumericLimits<idx_t>::Maximum() - compression_level.GetIndex());
-	}
-	return NumericCast<int64_t>(compression_level.GetIndex());
-}
-
-static void ParquetCopySerialize(Serializer &serializer, const FunctionData &bind_data_p,
-                                 const CopyFunction &function) {
-	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
-	serializer.WriteProperty(100, "sql_types", bind_data.sql_types);
-	serializer.WriteProperty(101, "column_names", bind_data.column_names);
-	serializer.WriteProperty(102, "codec", bind_data.codec);
-	serializer.WriteProperty(103, "row_group_size", bind_data.row_group_size);
-	serializer.WriteProperty(104, "row_group_size_bytes", bind_data.row_group_size_bytes);
-	serializer.WriteProperty(105, "kv_metadata", bind_data.kv_metadata);
-	serializer.WriteProperty(106, "field_ids", bind_data.field_ids);
-	serializer.WritePropertyWithDefault<shared_ptr<ParquetEncryptionConfig>>(107, "encryption_config",
-	                                                                         bind_data.encryption_config, nullptr);
-
-	// 108 was dictionary_compression_ratio_threshold, but was deleted
-	const auto compression_level = SerializeCompressionLevel(bind_data.compression_level);
-	D_ASSERT(DeserializeCompressionLevel(compression_level) == bind_data.compression_level);
-	serializer.WritePropertyWithDefault<optional_idx>(109, "compression_level", compression_level);
-	serializer.WriteProperty(110, "row_groups_per_file", bind_data.row_groups_per_file);
-	serializer.WriteProperty(111, "debug_use_openssl", bind_data.debug_use_openssl);
-	serializer.WriteProperty(112, "dictionary_size_limit", bind_data.dictionary_size_limit);
-	serializer.WriteProperty(113, "bloom_filter_false_positive_ratio", bind_data.bloom_filter_false_positive_ratio);
-}
-
-static unique_ptr<FunctionData> ParquetCopyDeserialize(Deserializer &deserializer, CopyFunction &function) {
-	auto data = make_uniq<ParquetWriteBindData>();
-	data->sql_types = deserializer.ReadProperty<vector<LogicalType>>(100, "sql_types");
-	data->column_names = deserializer.ReadProperty<vector<string>>(101, "column_names");
-	data->codec = deserializer.ReadProperty<duckdb_parquet::CompressionCodec::type>(102, "codec");
-	data->row_group_size = deserializer.ReadProperty<idx_t>(103, "row_group_size");
-	data->row_group_size_bytes = deserializer.ReadProperty<idx_t>(104, "row_group_size_bytes");
-	data->kv_metadata = deserializer.ReadProperty<vector<pair<string, string>>>(105, "kv_metadata");
-	data->field_ids = deserializer.ReadProperty<ChildFieldIDs>(106, "field_ids");
-	deserializer.ReadPropertyWithExplicitDefault<shared_ptr<ParquetEncryptionConfig>>(107, "encryption_config",
-	                                                                                  data->encryption_config, nullptr);
-	deserializer.ReadDeletedProperty<double>(108, "dictionary_compression_ratio_threshold");
-
-	optional_idx compression_level;
-	deserializer.ReadPropertyWithDefault<optional_idx>(109, "compression_level", compression_level);
-	data->compression_level = DeserializeCompressionLevel(compression_level);
-	D_ASSERT(SerializeCompressionLevel(data->compression_level) == compression_level);
-	data->row_groups_per_file =
-	    deserializer.ReadPropertyWithExplicitDefault<optional_idx>(110, "row_groups_per_file", optional_idx::Invalid());
-	data->debug_use_openssl = deserializer.ReadPropertyWithExplicitDefault<bool>(111, "debug_use_openssl", true);
-	data->dictionary_size_limit =
-	    deserializer.ReadPropertyWithExplicitDefault<idx_t>(112, "dictionary_size_limit", data->row_group_size / 10);
-	data->bloom_filter_false_positive_ratio =
-	    deserializer.ReadPropertyWithExplicitDefault<double>(113, "bloom_filter_false_positive_ratio", 0.01);
-
-	return std::move(data);
-}
-// LCOV_EXCL_STOP
-
-//===--------------------------------------------------------------------===//
-// Execution Mode
-//===--------------------------------------------------------------------===//
-CopyFunctionExecutionMode ParquetWriteExecutionMode(bool preserve_insertion_order, bool supports_batch_index) {
-	if (!preserve_insertion_order) {
-		return CopyFunctionExecutionMode::PARALLEL_COPY_TO_FILE;
-	}
-	if (supports_batch_index) {
-		return CopyFunctionExecutionMode::BATCH_COPY_TO_FILE;
-	}
-	return CopyFunctionExecutionMode::REGULAR_COPY_TO_FILE;
-}
-//===--------------------------------------------------------------------===//
-// Prepare Batch
-//===--------------------------------------------------------------------===//
-struct ParquetWriteBatchData : public PreparedBatchData {
-	PreparedRowGroup prepared_row_group;
-};
-
-unique_ptr<PreparedBatchData> ParquetWritePrepareBatch(ClientContext &context, FunctionData &bind_data,
-                                                       GlobalFunctionData &gstate,
-                                                       unique_ptr<ColumnDataCollection> collection) {
-	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
-	auto result = make_uniq<ParquetWriteBatchData>();
-	global_state.writer->PrepareRowGroup(*collection, result->prepared_row_group);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Flush Batch
-//===--------------------------------------------------------------------===//
-void ParquetWriteFlushBatch(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                            PreparedBatchData &batch_p) {
-	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
-	auto &batch = batch_p.Cast<ParquetWriteBatchData>();
-	global_state.writer->FlushRowGroup(batch.prepared_row_group);
-}
-
-//===--------------------------------------------------------------------===//
-// Desired Batch Size
-//===--------------------------------------------------------------------===//
-idx_t ParquetWriteDesiredBatchSize(ClientContext &context, FunctionData &bind_data_p) {
-	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
-	return bind_data.row_group_size;
-}
-
-//===--------------------------------------------------------------------===//
-// File rotation
-//===--------------------------------------------------------------------===//
-bool ParquetWriteRotateFiles(FunctionData &bind_data_p, const optional_idx &file_size_bytes) {
-	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
-	return file_size_bytes.IsValid() || bind_data.row_groups_per_file.IsValid();
-}
-
-bool ParquetWriteRotateNextFile(GlobalFunctionData &gstate, FunctionData &bind_data_p,
-                                const optional_idx &file_size_bytes) {
-	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
-	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
-	if (file_size_bytes.IsValid() && global_state.writer->FileSize() > file_size_bytes.GetIndex()) {
-		return true;
-	}
-	if (bind_data.row_groups_per_file.IsValid() &&
-	    global_state.writer->NumberOfRowGroups() >= bind_data.row_groups_per_file.GetIndex()) {
-		return true;
-	}
-	return false;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan Replacement
-//===--------------------------------------------------------------------===//
-unique_ptr<TableRef> ParquetScanReplacement(ClientContext &context, ReplacementScanInput &input,
-                                            optional_ptr<ReplacementScanData> data) {
-	auto table_name = ReplacementScan::GetFullPath(input);
-	if (!ReplacementScan::CanReplace(table_name, {"parquet"})) {
-		return nullptr;
-	}
-	auto table_function = make_uniq<TableFunctionRef>();
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_uniq<ConstantExpression>(Value(table_name)));
-	table_function->function = make_uniq<FunctionExpression>("parquet_scan", std::move(children));
-
-	if (!FileSystem::HasGlob(table_name)) {
-		auto &fs = FileSystem::GetFileSystem(context);
-		table_function->alias = fs.ExtractBaseName(table_name);
-	}
-
-	return std::move(table_function);
-}
-
-//===--------------------------------------------------------------------===//
-// Select
-//===--------------------------------------------------------------------===//
-// Helper predicates for ParquetWriteSelect
-static bool IsTypeNotSupported(const LogicalType &type) {
-	if (type.IsNested()) {
-		return false;
-	}
-	return !ParquetWriter::TryGetParquetType(type);
-}
-
-static bool IsTypeLossy(const LogicalType &type) {
-	return type.id() == LogicalTypeId::HUGEINT || type.id() == LogicalTypeId::UHUGEINT;
-}
-
-static vector<unique_ptr<Expression>> ParquetWriteSelect(CopyToSelectInput &input) {
-
-	auto &context = input.context;
-
-	vector<unique_ptr<Expression>> result;
-
-	bool any_change = false;
-
-	for (auto &expr : input.select_list) {
-
-		const auto &type = expr->return_type;
-		const auto &name = expr->GetAlias();
-
-		// Spatial types need to be encoded into WKB when writing GeoParquet.
-		// But dont perform this conversion if this is a EXPORT DATABASE statement
-		if (input.copy_to_type == CopyToType::COPY_TO_FILE && type.id() == LogicalTypeId::BLOB && type.HasAlias() &&
-		    type.GetAlias() == "GEOMETRY" && GeoParquetFileMetadata::IsGeoParquetConversionEnabled(context)) {
-
-			LogicalType wkb_blob_type(LogicalTypeId::BLOB);
-			wkb_blob_type.SetAlias("WKB_BLOB");
-
-			auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(expr), wkb_blob_type, false);
-			cast_expr->SetAlias(name);
-			result.push_back(std::move(cast_expr));
-			any_change = true;
-		}
-		// If this is an EXPORT DATABASE statement, we dont want to write "lossy" types, instead cast them to VARCHAR
-		else if (input.copy_to_type == CopyToType::EXPORT_DATABASE && TypeVisitor::Contains(type, IsTypeLossy)) {
-			// Replace all lossy types with VARCHAR
-			auto new_type = TypeVisitor::VisitReplace(
-			    type, [](const LogicalType &ty) -> LogicalType { return IsTypeLossy(ty) ? LogicalType::VARCHAR : ty; });
-
-			// Cast the column to the new type
-			auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(expr), new_type, false);
-			cast_expr->SetAlias(name);
-			result.push_back(std::move(cast_expr));
-			any_change = true;
-		}
-		// Else look if there is any unsupported type
-		else if (TypeVisitor::Contains(type, IsTypeNotSupported)) {
-			// If there is at least one unsupported type, replace all unsupported types with varchar
-			// and perform a CAST
-			auto new_type = TypeVisitor::VisitReplace(type, [](const LogicalType &ty) -> LogicalType {
-				return IsTypeNotSupported(ty) ? LogicalType::VARCHAR : ty;
-			});
-
-			auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(expr), new_type, false);
-			cast_expr->SetAlias(name);
-			result.push_back(std::move(cast_expr));
-			any_change = true;
-		}
-		// Otherwise, just reference the input column
-		else {
-			result.push_back(std::move(expr));
-		}
-	}
-
-	// If any change was made, return the new expressions
-	// otherwise, return an empty vector to indicate no change and avoid pushing another projection on to the plan
-	if (any_change) {
-		return result;
-	}
-	return {};
-}
-
-void ParquetExtension::Load(DuckDB &db) {
-	auto &db_instance = *db.instance;
-	auto &fs = db.GetFileSystem();
-	fs.RegisterSubSystem(FileCompressionType::ZSTD, make_uniq<ZStdFileSystem>());
-
-	auto scan_fun = ParquetScanFunction::GetFunctionSet();
-	scan_fun.name = "read_parquet";
-	ExtensionUtil::RegisterFunction(db_instance, scan_fun);
-	scan_fun.name = "parquet_scan";
-	ExtensionUtil::RegisterFunction(db_instance, scan_fun);
-
-	// parquet_metadata
-	ParquetMetaDataFunction meta_fun;
-	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(meta_fun));
-
-	// parquet_schema
-	ParquetSchemaFunction schema_fun;
-	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(schema_fun));
-
-	// parquet_key_value_metadata
-	ParquetKeyValueMetadataFunction kv_meta_fun;
-	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(kv_meta_fun));
-
-	// parquet_file_metadata
-	ParquetFileMetadataFunction file_meta_fun;
-	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(file_meta_fun));
-
-	// parquet_bloom_probe
-	ParquetBloomProbeFunction bloom_probe_fun;
-	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(bloom_probe_fun));
-
-	CopyFunction function("parquet");
-	function.copy_to_select = ParquetWriteSelect;
-	function.copy_to_bind = ParquetWriteBind;
-	function.copy_to_initialize_global = ParquetWriteInitializeGlobal;
-	function.copy_to_initialize_local = ParquetWriteInitializeLocal;
-	function.copy_to_sink = ParquetWriteSink;
-	function.copy_to_combine = ParquetWriteCombine;
-	function.copy_to_finalize = ParquetWriteFinalize;
-	function.execution_mode = ParquetWriteExecutionMode;
-	function.copy_from_bind = ParquetScanFunction::ParquetReadBind;
-	function.copy_from_function = scan_fun.functions[0];
-	function.prepare_batch = ParquetWritePrepareBatch;
-	function.flush_batch = ParquetWriteFlushBatch;
-	function.desired_batch_size = ParquetWriteDesiredBatchSize;
-	function.rotate_files = ParquetWriteRotateFiles;
-	function.rotate_next_file = ParquetWriteRotateNextFile;
-	function.serialize = ParquetCopySerialize;
-	function.deserialize = ParquetCopyDeserialize;
-
-	function.extension = "parquet";
-	ExtensionUtil::RegisterFunction(db_instance, function);
-
-	// parquet_key
-	auto parquet_key_fun = PragmaFunction::PragmaCall("add_parquet_key", ParquetCrypto::AddKey,
-	                                                  {LogicalType::VARCHAR, LogicalType::VARCHAR});
-	ExtensionUtil::RegisterFunction(db_instance, parquet_key_fun);
-
-	auto &config = DBConfig::GetConfig(*db.instance);
-	config.replacement_scans.emplace_back(ParquetScanReplacement);
-	config.AddExtensionOption("binary_as_string", "In Parquet files, interpret binary data as a string.",
-	                          LogicalType::BOOLEAN);
-	config.AddExtensionOption("disable_parquet_prefetching", "Disable the prefetching mechanism in Parquet",
-	                          LogicalType::BOOLEAN, Value(false));
-	config.AddExtensionOption("prefetch_all_parquet_files",
-	                          "Use the prefetching mechanism for all types of parquet files", LogicalType::BOOLEAN,
-	                          Value(false));
-	config.AddExtensionOption("parquet_metadata_cache",
-	                          "Cache Parquet metadata - useful when reading the same files multiple times",
-	                          LogicalType::BOOLEAN, Value(false));
-	config.AddExtensionOption(
-	    "enable_geoparquet_conversion",
-	    "Attempt to decode/encode geometry data in/as GeoParquet files if the spatial extension is present.",
-	    LogicalType::BOOLEAN, Value::BOOLEAN(true));
-}
-
-std::string ParquetExtension::Name() {
-	return "parquet";
-}
-
-std::string ParquetExtension::Version() const {
-#ifdef EXT_VERSION_PARQUET
-	return EXT_VERSION_PARQUET;
-#else
-	return "";
-#endif
-}
-
-} // namespace duckdb
-
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
-extern "C" {
-
-DUCKDB_EXTENSION_API void parquet_init(duckdb::DatabaseInstance &db) { // NOLINT
-	duckdb::DuckDB db_wrapper(db);
-	db_wrapper.LoadExtension<duckdb::ParquetExtension>();
-}
-
-DUCKDB_EXTENSION_API const char *parquet_version() { // NOLINT
-	return duckdb::DuckDB::LibraryVersion();
-}
-}
-#endif
-
-#ifndef DUCKDB_EXTENSION_MAIN
-#error DUCKDB_EXTENSION_MAIN not defined
-#endif
diff --git a/src/duckdb/extension/parquet/parquet_metadata.cpp b/src/duckdb/extension/parquet/parquet_metadata.cpp
deleted file mode 100644
index 456c9b3e4..000000000
--- a/src/duckdb/extension/parquet/parquet_metadata.cpp
+++ /dev/null
@@ -1,821 +0,0 @@
-#include "parquet_metadata.hpp"
-
-#include "parquet_statistics.hpp"
-
-#include <sstream>
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/types/blob.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/main/config.hpp"
-#endif
-
-namespace duckdb {
-
-struct ParquetMetaDataBindData : public TableFunctionData {
-	vector<LogicalType> return_types;
-	shared_ptr<MultiFileList> file_list;
-	unique_ptr<MultiFileReader> multi_file_reader;
-};
-
-struct ParquetBloomProbeBindData : public ParquetMetaDataBindData {
-	string probe_column_name;
-	Value probe_constant;
-};
-
-enum class ParquetMetadataOperatorType : uint8_t {
-	META_DATA,
-	SCHEMA,
-	KEY_VALUE_META_DATA,
-	FILE_META_DATA,
-	BLOOM_PROBE
-};
-
-struct ParquetMetaDataOperatorData : public GlobalTableFunctionState {
-	explicit ParquetMetaDataOperatorData(ClientContext &context, const vector<LogicalType> &types)
-	    : collection(context, types) {
-	}
-
-	ColumnDataCollection collection;
-	ColumnDataScanState scan_state;
-
-	MultiFileListScanData file_list_scan;
-	string current_file;
-
-public:
-	static void BindMetaData(vector<LogicalType> &return_types, vector<string> &names);
-	static void BindSchema(vector<LogicalType> &return_types, vector<string> &names);
-	static void BindKeyValueMetaData(vector<LogicalType> &return_types, vector<string> &names);
-	static void BindFileMetaData(vector<LogicalType> &return_types, vector<string> &names);
-	static void BindBloomProbe(vector<LogicalType> &return_types, vector<string> &names);
-
-	void LoadRowGroupMetadata(ClientContext &context, const vector<LogicalType> &return_types, const string &file_path);
-	void LoadSchemaData(ClientContext &context, const vector<LogicalType> &return_types, const string &file_path);
-	void LoadKeyValueMetaData(ClientContext &context, const vector<LogicalType> &return_types, const string &file_path);
-	void LoadFileMetaData(ClientContext &context, const vector<LogicalType> &return_types, const string &file_path);
-	void ExecuteBloomProbe(ClientContext &context, const vector<LogicalType> &return_types, const string &file_path,
-	                       const string &column_name, const Value &probe);
-};
-
-template <class T>
-string ConvertParquetElementToString(T &&entry) {
-	std::stringstream ss;
-	ss << entry;
-	return ss.str();
-}
-
-template <class T>
-string PrintParquetElementToString(T &&entry) {
-	std::stringstream ss;
-	entry.printTo(ss);
-	return ss.str();
-}
-
-template <class T>
-Value ParquetElementString(T &&value, bool is_set) {
-	if (!is_set) {
-		return Value();
-	}
-	return Value(ConvertParquetElementToString(value));
-}
-
-Value ParquetElementStringVal(const string &value, bool is_set) {
-	if (!is_set) {
-		return Value();
-	}
-	return Value(value);
-}
-
-template <class T>
-Value ParquetElementInteger(T &&value, bool is_iset) {
-	if (!is_iset) {
-		return Value();
-	}
-	return Value::INTEGER(value);
-}
-
-template <class T>
-Value ParquetElementBigint(T &&value, bool is_iset) {
-	if (!is_iset) {
-		return Value();
-	}
-	return Value::BIGINT(value);
-}
-
-//===--------------------------------------------------------------------===//
-// Row Group Meta Data
-//===--------------------------------------------------------------------===//
-void ParquetMetaDataOperatorData::BindMetaData(vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("file_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("row_group_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("row_group_num_rows");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("row_group_num_columns");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("row_group_bytes");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("file_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("num_values");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("path_in_schema");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("stats_min");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("stats_max");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("stats_null_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("stats_distinct_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("stats_min_value");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("stats_max_value");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("compression");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("encodings");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("index_page_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("dictionary_page_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("data_page_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("total_compressed_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("total_uncompressed_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("key_value_metadata");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::BLOB, LogicalType::BLOB));
-
-	names.emplace_back("bloom_filter_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("bloom_filter_length");
-	return_types.emplace_back(LogicalType::BIGINT);
-}
-
-Value ConvertParquetStats(const LogicalType &type, const duckdb_parquet::SchemaElement &schema_ele, bool stats_is_set,
-                          const std::string &stats) {
-	if (!stats_is_set) {
-		return Value(LogicalType::VARCHAR);
-	}
-	return ParquetStatisticsUtils::ConvertValue(type, schema_ele, stats).DefaultCastAs(LogicalType::VARCHAR);
-}
-
-void ParquetMetaDataOperatorData::LoadRowGroupMetadata(ClientContext &context, const vector<LogicalType> &return_types,
-                                                       const string &file_path) {
-	collection.Reset();
-	ParquetOptions parquet_options(context);
-	auto reader = make_uniq<ParquetReader>(context, file_path, parquet_options);
-	idx_t count = 0;
-	DataChunk current_chunk;
-	current_chunk.Initialize(context, return_types);
-	auto meta_data = reader->GetFileMetadata();
-	vector<LogicalType> column_types;
-	vector<idx_t> schema_indexes;
-	for (idx_t schema_idx = 0; schema_idx < meta_data->schema.size(); schema_idx++) {
-		auto &schema_element = meta_data->schema[schema_idx];
-		if (schema_element.num_children > 0) {
-			continue;
-		}
-		column_types.push_back(ParquetReader::DeriveLogicalType(schema_element, false));
-		schema_indexes.push_back(schema_idx);
-	}
-
-	for (idx_t row_group_idx = 0; row_group_idx < meta_data->row_groups.size(); row_group_idx++) {
-		auto &row_group = meta_data->row_groups[row_group_idx];
-
-		if (row_group.columns.size() > column_types.size()) {
-			throw InternalException("Too many column in row group: corrupt file?");
-		}
-		for (idx_t col_idx = 0; col_idx < row_group.columns.size(); col_idx++) {
-			auto &column = row_group.columns[col_idx];
-			auto &col_meta = column.meta_data;
-			auto &stats = col_meta.statistics;
-			auto &schema_element = meta_data->schema[schema_indexes[col_idx]];
-			auto &column_type = column_types[col_idx];
-
-			// file_name, LogicalType::VARCHAR
-			current_chunk.SetValue(0, count, file_path);
-
-			// row_group_id, LogicalType::BIGINT
-			current_chunk.SetValue(1, count, Value::BIGINT(UnsafeNumericCast<int64_t>(row_group_idx)));
-
-			// row_group_num_rows, LogicalType::BIGINT
-			current_chunk.SetValue(2, count, Value::BIGINT(row_group.num_rows));
-
-			// row_group_num_columns, LogicalType::BIGINT
-			current_chunk.SetValue(3, count, Value::BIGINT(UnsafeNumericCast<int64_t>(row_group.columns.size())));
-
-			// row_group_bytes, LogicalType::BIGINT
-			current_chunk.SetValue(4, count, Value::BIGINT(row_group.total_byte_size));
-
-			// column_id, LogicalType::BIGINT
-			current_chunk.SetValue(5, count, Value::BIGINT(UnsafeNumericCast<int64_t>(col_idx)));
-
-			// file_offset, LogicalType::BIGINT
-			current_chunk.SetValue(6, count, ParquetElementBigint(column.file_offset, row_group.__isset.file_offset));
-
-			// num_values, LogicalType::BIGINT
-			current_chunk.SetValue(7, count, Value::BIGINT(col_meta.num_values));
-
-			// path_in_schema, LogicalType::VARCHAR
-			current_chunk.SetValue(8, count, StringUtil::Join(col_meta.path_in_schema, ", "));
-
-			// type, LogicalType::VARCHAR
-			current_chunk.SetValue(9, count, ConvertParquetElementToString(col_meta.type));
-
-			// stats_min, LogicalType::VARCHAR
-			current_chunk.SetValue(10, count,
-			                       ConvertParquetStats(column_type, schema_element, stats.__isset.min, stats.min));
-
-			// stats_max, LogicalType::VARCHAR
-			current_chunk.SetValue(11, count,
-			                       ConvertParquetStats(column_type, schema_element, stats.__isset.max, stats.max));
-
-			// stats_null_count, LogicalType::BIGINT
-			current_chunk.SetValue(12, count, ParquetElementBigint(stats.null_count, stats.__isset.null_count));
-
-			// stats_distinct_count, LogicalType::BIGINT
-			current_chunk.SetValue(13, count, ParquetElementBigint(stats.distinct_count, stats.__isset.distinct_count));
-
-			// stats_min_value, LogicalType::VARCHAR
-			current_chunk.SetValue(
-			    14, count, ConvertParquetStats(column_type, schema_element, stats.__isset.min_value, stats.min_value));
-
-			// stats_max_value, LogicalType::VARCHAR
-			current_chunk.SetValue(
-			    15, count, ConvertParquetStats(column_type, schema_element, stats.__isset.max_value, stats.max_value));
-
-			// compression, LogicalType::VARCHAR
-			current_chunk.SetValue(16, count, ConvertParquetElementToString(col_meta.codec));
-
-			// encodings, LogicalType::VARCHAR
-			vector<string> encoding_string;
-			encoding_string.reserve(col_meta.encodings.size());
-			for (auto &encoding : col_meta.encodings) {
-				encoding_string.push_back(ConvertParquetElementToString(encoding));
-			}
-			current_chunk.SetValue(17, count, Value(StringUtil::Join(encoding_string, ", ")));
-
-			// index_page_offset, LogicalType::BIGINT
-			current_chunk.SetValue(
-			    18, count, ParquetElementBigint(col_meta.index_page_offset, col_meta.__isset.index_page_offset));
-
-			// dictionary_page_offset, LogicalType::BIGINT
-			current_chunk.SetValue(
-			    19, count,
-			    ParquetElementBigint(col_meta.dictionary_page_offset, col_meta.__isset.dictionary_page_offset));
-
-			// data_page_offset, LogicalType::BIGINT
-			current_chunk.SetValue(20, count, Value::BIGINT(col_meta.data_page_offset));
-
-			// total_compressed_size, LogicalType::BIGINT
-			current_chunk.SetValue(21, count, Value::BIGINT(col_meta.total_compressed_size));
-
-			// total_uncompressed_size, LogicalType::BIGINT
-			current_chunk.SetValue(22, count, Value::BIGINT(col_meta.total_uncompressed_size));
-
-			// key_value_metadata, LogicalType::MAP(LogicalType::BLOB, LogicalType::BLOB)
-			vector<Value> map_keys, map_values;
-			for (auto &entry : col_meta.key_value_metadata) {
-				map_keys.push_back(Value::BLOB_RAW(entry.key));
-				map_values.push_back(Value::BLOB_RAW(entry.value));
-			}
-			current_chunk.SetValue(
-			    23, count,
-			    Value::MAP(LogicalType::BLOB, LogicalType::BLOB, std::move(map_keys), std::move(map_values)));
-
-			// bloom_filter_offset, LogicalType::BIGINT
-			current_chunk.SetValue(
-			    24, count, ParquetElementBigint(col_meta.bloom_filter_offset, col_meta.__isset.bloom_filter_offset));
-
-			// bloom_filter_length, LogicalType::BIGINT
-			current_chunk.SetValue(
-			    25, count, ParquetElementBigint(col_meta.bloom_filter_length, col_meta.__isset.bloom_filter_length));
-
-			count++;
-			if (count >= STANDARD_VECTOR_SIZE) {
-				current_chunk.SetCardinality(count);
-				collection.Append(current_chunk);
-
-				count = 0;
-				current_chunk.Reset();
-			}
-		}
-	}
-	current_chunk.SetCardinality(count);
-	collection.Append(current_chunk);
-
-	collection.InitializeScan(scan_state);
-}
-
-//===--------------------------------------------------------------------===//
-// Schema Data
-//===--------------------------------------------------------------------===//
-void ParquetMetaDataOperatorData::BindSchema(vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("file_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type_length");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("repetition_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("num_children");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("converted_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("scale");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("precision");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("field_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("logical_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-}
-
-Value ParquetLogicalTypeToString(const duckdb_parquet::LogicalType &type, bool is_set) {
-	if (!is_set) {
-		return Value();
-	}
-	if (type.__isset.STRING) {
-		return Value(PrintParquetElementToString(type.STRING));
-	}
-	if (type.__isset.MAP) {
-		return Value(PrintParquetElementToString(type.MAP));
-	}
-	if (type.__isset.LIST) {
-		return Value(PrintParquetElementToString(type.LIST));
-	}
-	if (type.__isset.ENUM) {
-		return Value(PrintParquetElementToString(type.ENUM));
-	}
-	if (type.__isset.DECIMAL) {
-		return Value(PrintParquetElementToString(type.DECIMAL));
-	}
-	if (type.__isset.DATE) {
-		return Value(PrintParquetElementToString(type.DATE));
-	}
-	if (type.__isset.TIME) {
-		return Value(PrintParquetElementToString(type.TIME));
-	}
-	if (type.__isset.TIMESTAMP) {
-		return Value(PrintParquetElementToString(type.TIMESTAMP));
-	}
-	if (type.__isset.INTEGER) {
-		return Value(PrintParquetElementToString(type.INTEGER));
-	}
-	if (type.__isset.UNKNOWN) {
-		return Value(PrintParquetElementToString(type.UNKNOWN));
-	}
-	if (type.__isset.JSON) {
-		return Value(PrintParquetElementToString(type.JSON));
-	}
-	if (type.__isset.BSON) {
-		return Value(PrintParquetElementToString(type.BSON));
-	}
-	if (type.__isset.UUID) {
-		return Value(PrintParquetElementToString(type.UUID));
-	}
-	return Value();
-}
-
-void ParquetMetaDataOperatorData::LoadSchemaData(ClientContext &context, const vector<LogicalType> &return_types,
-                                                 const string &file_path) {
-	collection.Reset();
-	ParquetOptions parquet_options(context);
-	auto reader = make_uniq<ParquetReader>(context, file_path, parquet_options);
-	idx_t count = 0;
-	DataChunk current_chunk;
-	current_chunk.Initialize(context, return_types);
-	auto meta_data = reader->GetFileMetadata();
-	for (idx_t col_idx = 0; col_idx < meta_data->schema.size(); col_idx++) {
-		auto &column = meta_data->schema[col_idx];
-
-		// file_name, LogicalType::VARCHAR
-		current_chunk.SetValue(0, count, file_path);
-
-		// name, LogicalType::VARCHAR
-		current_chunk.SetValue(1, count, column.name);
-
-		// type, LogicalType::VARCHAR
-		current_chunk.SetValue(2, count, ParquetElementString(column.type, column.__isset.type));
-
-		// type_length, LogicalType::INTEGER
-		current_chunk.SetValue(3, count, ParquetElementInteger(column.type_length, column.__isset.type_length));
-
-		// repetition_type, LogicalType::VARCHAR
-		current_chunk.SetValue(4, count, ParquetElementString(column.repetition_type, column.__isset.repetition_type));
-
-		// num_children, LogicalType::BIGINT
-		current_chunk.SetValue(5, count, ParquetElementBigint(column.num_children, column.__isset.num_children));
-
-		// converted_type, LogicalType::VARCHAR
-		current_chunk.SetValue(6, count, ParquetElementString(column.converted_type, column.__isset.converted_type));
-
-		// scale, LogicalType::BIGINT
-		current_chunk.SetValue(7, count, ParquetElementBigint(column.scale, column.__isset.scale));
-
-		// precision, LogicalType::BIGINT
-		current_chunk.SetValue(8, count, ParquetElementBigint(column.precision, column.__isset.precision));
-
-		// field_id, LogicalType::BIGINT
-		current_chunk.SetValue(9, count, ParquetElementBigint(column.field_id, column.__isset.field_id));
-
-		// logical_type, LogicalType::VARCHAR
-		current_chunk.SetValue(10, count, ParquetLogicalTypeToString(column.logicalType, column.__isset.logicalType));
-
-		count++;
-		if (count >= STANDARD_VECTOR_SIZE) {
-			current_chunk.SetCardinality(count);
-			collection.Append(current_chunk);
-
-			count = 0;
-			current_chunk.Reset();
-		}
-	}
-	current_chunk.SetCardinality(count);
-	collection.Append(current_chunk);
-
-	collection.InitializeScan(scan_state);
-}
-
-//===--------------------------------------------------------------------===//
-// KV Meta Data
-//===--------------------------------------------------------------------===//
-void ParquetMetaDataOperatorData::BindKeyValueMetaData(vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("file_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("key");
-	return_types.emplace_back(LogicalType::BLOB);
-
-	names.emplace_back("value");
-	return_types.emplace_back(LogicalType::BLOB);
-}
-
-void ParquetMetaDataOperatorData::LoadKeyValueMetaData(ClientContext &context, const vector<LogicalType> &return_types,
-                                                       const string &file_path) {
-	collection.Reset();
-	ParquetOptions parquet_options(context);
-	auto reader = make_uniq<ParquetReader>(context, file_path, parquet_options);
-	idx_t count = 0;
-	DataChunk current_chunk;
-	current_chunk.Initialize(context, return_types);
-	auto meta_data = reader->GetFileMetadata();
-
-	for (idx_t col_idx = 0; col_idx < meta_data->key_value_metadata.size(); col_idx++) {
-		auto &entry = meta_data->key_value_metadata[col_idx];
-
-		current_chunk.SetValue(0, count, Value(file_path));
-		current_chunk.SetValue(1, count, Value::BLOB_RAW(entry.key));
-		current_chunk.SetValue(2, count, Value::BLOB_RAW(entry.value));
-
-		count++;
-		if (count >= STANDARD_VECTOR_SIZE) {
-			current_chunk.SetCardinality(count);
-			collection.Append(current_chunk);
-
-			count = 0;
-			current_chunk.Reset();
-		}
-	}
-	current_chunk.SetCardinality(count);
-	collection.Append(current_chunk);
-	collection.InitializeScan(scan_state);
-}
-
-//===--------------------------------------------------------------------===//
-// File Meta Data
-//===--------------------------------------------------------------------===//
-void ParquetMetaDataOperatorData::BindFileMetaData(vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("file_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("created_by");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("num_rows");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("num_row_groups");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("format_version");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("encryption_algorithm");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("footer_signing_key_metadata");
-	return_types.emplace_back(LogicalType::VARCHAR);
-}
-
-void ParquetMetaDataOperatorData::LoadFileMetaData(ClientContext &context, const vector<LogicalType> &return_types,
-                                                   const string &file_path) {
-	collection.Reset();
-	ParquetOptions parquet_options(context);
-	auto reader = make_uniq<ParquetReader>(context, file_path, parquet_options);
-	DataChunk current_chunk;
-	current_chunk.Initialize(context, return_types);
-	auto meta_data = reader->GetFileMetadata();
-
-	//	file_name
-	current_chunk.SetValue(0, 0, Value(file_path));
-	//	created_by
-	current_chunk.SetValue(1, 0, ParquetElementStringVal(meta_data->created_by, meta_data->__isset.created_by));
-	//	num_rows
-	current_chunk.SetValue(2, 0, Value::BIGINT(meta_data->num_rows));
-	//	num_row_groups
-	current_chunk.SetValue(3, 0, Value::BIGINT(UnsafeNumericCast<int64_t>(meta_data->row_groups.size())));
-	//	format_version
-	current_chunk.SetValue(4, 0, Value::BIGINT(meta_data->version));
-	//	encryption_algorithm
-	current_chunk.SetValue(
-	    5, 0, ParquetElementString(meta_data->encryption_algorithm, meta_data->__isset.encryption_algorithm));
-	//	footer_signing_key_metadata
-	current_chunk.SetValue(6, 0,
-	                       ParquetElementStringVal(meta_data->footer_signing_key_metadata,
-	                                               meta_data->__isset.footer_signing_key_metadata));
-	current_chunk.SetCardinality(1);
-	collection.Append(current_chunk);
-	collection.InitializeScan(scan_state);
-}
-
-//===--------------------------------------------------------------------===//
-// Bloom Probe
-//===--------------------------------------------------------------------===//
-void ParquetMetaDataOperatorData::BindBloomProbe(vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("file_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("row_group_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("bloom_filter_excludes");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-}
-
-void ParquetMetaDataOperatorData::ExecuteBloomProbe(ClientContext &context, const vector<LogicalType> &return_types,
-                                                    const string &file_path, const string &column_name,
-                                                    const Value &probe) {
-	collection.Reset();
-	ParquetOptions parquet_options(context);
-	auto reader = make_uniq<ParquetReader>(context, file_path, parquet_options);
-	idx_t count = 0;
-	DataChunk current_chunk;
-	current_chunk.Initialize(context, return_types);
-	auto meta_data = reader->GetFileMetadata();
-
-	optional_idx probe_column_idx;
-	for (idx_t column_idx = 0; column_idx < reader->names.size(); column_idx++) {
-		if (reader->names[column_idx] == column_name) {
-			probe_column_idx = column_idx;
-		}
-	}
-
-	if (!probe_column_idx.IsValid()) {
-		throw InvalidInputException("Column %s not found in %s", column_name, file_path);
-	}
-
-	auto &allocator = Allocator::DefaultAllocator();
-	auto transport = std::make_shared<ThriftFileTransport>(allocator, reader->GetHandle(), false);
-	auto protocol =
-	    make_uniq<duckdb_apache::thrift::protocol::TCompactProtocolT<ThriftFileTransport>>(std::move(transport));
-
-	D_ASSERT(!probe.IsNull());
-	ConstantFilter filter(ExpressionType::COMPARE_EQUAL,
-	                      probe.CastAs(context, reader->GetTypes()[probe_column_idx.GetIndex()]));
-
-	for (idx_t row_group_idx = 0; row_group_idx < meta_data->row_groups.size(); row_group_idx++) {
-		auto &row_group = meta_data->row_groups[row_group_idx];
-		auto &column = row_group.columns[probe_column_idx.GetIndex()];
-
-		auto bloom_excludes =
-		    ParquetStatisticsUtils::BloomFilterExcludes(filter, column.meta_data, *protocol, allocator);
-		current_chunk.SetValue(0, count, Value(file_path));
-		current_chunk.SetValue(1, count, Value::BIGINT(NumericCast<int64_t>(row_group_idx)));
-		current_chunk.SetValue(2, count, Value::BOOLEAN(bloom_excludes));
-
-		count++;
-		if (count >= STANDARD_VECTOR_SIZE) {
-			current_chunk.SetCardinality(count);
-			collection.Append(current_chunk);
-
-			count = 0;
-			current_chunk.Reset();
-		}
-	}
-
-	current_chunk.SetCardinality(count);
-	collection.Append(current_chunk);
-	collection.InitializeScan(scan_state);
-}
-
-//===--------------------------------------------------------------------===//
-// Bind
-//===--------------------------------------------------------------------===//
-template <ParquetMetadataOperatorType TYPE>
-unique_ptr<FunctionData> ParquetMetaDataBind(ClientContext &context, TableFunctionBindInput &input,
-                                             vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<ParquetMetaDataBindData>();
-
-	switch (TYPE) {
-	case ParquetMetadataOperatorType::SCHEMA:
-		ParquetMetaDataOperatorData::BindSchema(return_types, names);
-		break;
-	case ParquetMetadataOperatorType::META_DATA:
-		ParquetMetaDataOperatorData::BindMetaData(return_types, names);
-		break;
-	case ParquetMetadataOperatorType::KEY_VALUE_META_DATA:
-		ParquetMetaDataOperatorData::BindKeyValueMetaData(return_types, names);
-		break;
-	case ParquetMetadataOperatorType::FILE_META_DATA:
-		ParquetMetaDataOperatorData::BindFileMetaData(return_types, names);
-		break;
-	case ParquetMetadataOperatorType::BLOOM_PROBE: {
-		auto probe_bind_data = make_uniq<ParquetBloomProbeBindData>();
-		D_ASSERT(input.inputs.size() == 3);
-		if (input.inputs[1].IsNull() || input.inputs[2].IsNull()) {
-			throw InvalidInputException("Can't have NULL parameters for parquet_bloom_probe");
-		}
-		probe_bind_data->probe_column_name = input.inputs[1].CastAs(context, LogicalType::VARCHAR).GetValue<string>();
-		probe_bind_data->probe_constant = input.inputs[2];
-		result = std::move(probe_bind_data);
-		ParquetMetaDataOperatorData::BindBloomProbe(return_types, names);
-		break;
-	}
-	default:
-		throw InternalException("Unsupported ParquetMetadataOperatorType");
-	}
-
-	result->return_types = return_types;
-	result->multi_file_reader = MultiFileReader::Create(input.table_function);
-	result->file_list = result->multi_file_reader->CreateFileList(context, input.inputs[0]);
-
-	return std::move(result);
-}
-
-template <ParquetMetadataOperatorType TYPE>
-unique_ptr<GlobalTableFunctionState> ParquetMetaDataInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<ParquetMetaDataBindData>();
-
-	auto result = make_uniq<ParquetMetaDataOperatorData>(context, bind_data.return_types);
-
-	bind_data.file_list->InitializeScan(result->file_list_scan);
-	bind_data.file_list->Scan(result->file_list_scan, result->current_file);
-
-	D_ASSERT(!bind_data.file_list->IsEmpty());
-
-	switch (TYPE) {
-	case ParquetMetadataOperatorType::SCHEMA:
-		result->LoadSchemaData(context, bind_data.return_types, bind_data.file_list->GetFirstFile());
-		break;
-	case ParquetMetadataOperatorType::META_DATA:
-		result->LoadRowGroupMetadata(context, bind_data.return_types, bind_data.file_list->GetFirstFile());
-		break;
-	case ParquetMetadataOperatorType::KEY_VALUE_META_DATA:
-		result->LoadKeyValueMetaData(context, bind_data.return_types, bind_data.file_list->GetFirstFile());
-		break;
-	case ParquetMetadataOperatorType::FILE_META_DATA:
-		result->LoadFileMetaData(context, bind_data.return_types, bind_data.file_list->GetFirstFile());
-		break;
-	case ParquetMetadataOperatorType::BLOOM_PROBE: {
-		auto &bloom_probe_bind_data = input.bind_data->Cast<ParquetBloomProbeBindData>();
-		result->ExecuteBloomProbe(context, bind_data.return_types, bind_data.file_list->GetFirstFile(),
-		                          bloom_probe_bind_data.probe_column_name, bloom_probe_bind_data.probe_constant);
-		break;
-	}
-	default:
-		throw InternalException("Unsupported ParquetMetadataOperatorType");
-	}
-
-	return std::move(result);
-}
-
-template <ParquetMetadataOperatorType TYPE>
-void ParquetMetaDataImplementation(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<ParquetMetaDataOperatorData>();
-	auto &bind_data = data_p.bind_data->Cast<ParquetMetaDataBindData>();
-
-	while (true) {
-		if (!data.collection.Scan(data.scan_state, output)) {
-
-			// Try get next file
-			if (!bind_data.file_list->Scan(data.file_list_scan, data.current_file)) {
-				return;
-			}
-
-			switch (TYPE) {
-			case ParquetMetadataOperatorType::SCHEMA:
-				data.LoadSchemaData(context, bind_data.return_types, data.current_file);
-				break;
-			case ParquetMetadataOperatorType::META_DATA:
-				data.LoadRowGroupMetadata(context, bind_data.return_types, data.current_file);
-				break;
-			case ParquetMetadataOperatorType::KEY_VALUE_META_DATA:
-				data.LoadKeyValueMetaData(context, bind_data.return_types, data.current_file);
-				break;
-			case ParquetMetadataOperatorType::FILE_META_DATA:
-				data.LoadFileMetaData(context, bind_data.return_types, data.current_file);
-				break;
-			case ParquetMetadataOperatorType::BLOOM_PROBE: {
-				auto &bloom_probe_bind_data = data_p.bind_data->Cast<ParquetBloomProbeBindData>();
-				data.ExecuteBloomProbe(context, bind_data.return_types, bind_data.file_list->GetFirstFile(),
-				                       bloom_probe_bind_data.probe_column_name, bloom_probe_bind_data.probe_constant);
-				break;
-			}
-			default:
-				throw InternalException("Unsupported ParquetMetadataOperatorType");
-			}
-			continue;
-		}
-		if (output.size() != 0) {
-			return;
-		}
-	}
-}
-
-ParquetMetaDataFunction::ParquetMetaDataFunction()
-    : TableFunction("parquet_metadata", {LogicalType::VARCHAR},
-                    ParquetMetaDataImplementation<ParquetMetadataOperatorType::META_DATA>,
-                    ParquetMetaDataBind<ParquetMetadataOperatorType::META_DATA>,
-                    ParquetMetaDataInit<ParquetMetadataOperatorType::META_DATA>) {
-}
-
-ParquetSchemaFunction::ParquetSchemaFunction()
-    : TableFunction("parquet_schema", {LogicalType::VARCHAR},
-                    ParquetMetaDataImplementation<ParquetMetadataOperatorType::SCHEMA>,
-                    ParquetMetaDataBind<ParquetMetadataOperatorType::SCHEMA>,
-                    ParquetMetaDataInit<ParquetMetadataOperatorType::SCHEMA>) {
-}
-
-ParquetKeyValueMetadataFunction::ParquetKeyValueMetadataFunction()
-    : TableFunction("parquet_kv_metadata", {LogicalType::VARCHAR},
-                    ParquetMetaDataImplementation<ParquetMetadataOperatorType::KEY_VALUE_META_DATA>,
-                    ParquetMetaDataBind<ParquetMetadataOperatorType::KEY_VALUE_META_DATA>,
-                    ParquetMetaDataInit<ParquetMetadataOperatorType::KEY_VALUE_META_DATA>) {
-}
-
-ParquetFileMetadataFunction::ParquetFileMetadataFunction()
-    : TableFunction("parquet_file_metadata", {LogicalType::VARCHAR},
-                    ParquetMetaDataImplementation<ParquetMetadataOperatorType::FILE_META_DATA>,
-                    ParquetMetaDataBind<ParquetMetadataOperatorType::FILE_META_DATA>,
-                    ParquetMetaDataInit<ParquetMetadataOperatorType::FILE_META_DATA>) {
-}
-
-ParquetBloomProbeFunction::ParquetBloomProbeFunction()
-    : TableFunction("parquet_bloom_probe", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::ANY},
-                    ParquetMetaDataImplementation<ParquetMetadataOperatorType::BLOOM_PROBE>,
-                    ParquetMetaDataBind<ParquetMetadataOperatorType::BLOOM_PROBE>,
-                    ParquetMetaDataInit<ParquetMetadataOperatorType::BLOOM_PROBE>) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/parquet_reader.cpp b/src/duckdb/extension/parquet/parquet_reader.cpp
deleted file mode 100644
index 1d2565a2d..000000000
--- a/src/duckdb/extension/parquet/parquet_reader.cpp
+++ /dev/null
@@ -1,1243 +0,0 @@
-#include "parquet_reader.hpp"
-
-#include "boolean_column_reader.hpp"
-#include "callback_column_reader.hpp"
-#include "cast_column_reader.hpp"
-#include "column_reader.hpp"
-#include "duckdb.hpp"
-#include "expression_column_reader.hpp"
-#include "geo_parquet.hpp"
-#include "list_column_reader.hpp"
-#include "parquet_crypto.hpp"
-#include "parquet_file_metadata_cache.hpp"
-#include "parquet_statistics.hpp"
-#include "parquet_timestamp.hpp"
-#include "mbedtls_wrapper.hpp"
-#include "row_number_column_reader.hpp"
-#include "string_column_reader.hpp"
-#include "struct_column_reader.hpp"
-#include "templated_column_reader.hpp"
-#include "thrift_tools.hpp"
-#include "duckdb/main/config.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/encryption_state.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/struct_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/object_cache.hpp"
-#endif
-
-#include <cassert>
-#include <chrono>
-#include <cstring>
-#include <sstream>
-
-namespace duckdb {
-
-using duckdb_parquet::ColumnChunk;
-using duckdb_parquet::ConvertedType;
-using duckdb_parquet::FieldRepetitionType;
-using duckdb_parquet::FileCryptoMetaData;
-using duckdb_parquet::FileMetaData;
-using ParquetRowGroup = duckdb_parquet::RowGroup;
-using duckdb_parquet::SchemaElement;
-using duckdb_parquet::Statistics;
-using duckdb_parquet::Type;
-
-static unique_ptr<duckdb_apache::thrift::protocol::TProtocol>
-CreateThriftFileProtocol(Allocator &allocator, FileHandle &file_handle, bool prefetch_mode) {
-	auto transport = std::make_shared<ThriftFileTransport>(allocator, file_handle, prefetch_mode);
-	return make_uniq<duckdb_apache::thrift::protocol::TCompactProtocolT<ThriftFileTransport>>(std::move(transport));
-}
-
-static shared_ptr<ParquetFileMetadataCache>
-LoadMetadata(ClientContext &context, Allocator &allocator, FileHandle &file_handle,
-             const shared_ptr<const ParquetEncryptionConfig> &encryption_config,
-             const EncryptionUtil &encryption_util) {
-	auto current_time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-
-	auto file_proto = CreateThriftFileProtocol(allocator, file_handle, false);
-	auto &transport = reinterpret_cast<ThriftFileTransport &>(*file_proto->getTransport());
-	auto file_size = transport.GetSize();
-	if (file_size < 12) {
-		throw InvalidInputException("File '%s' too small to be a Parquet file", file_handle.path);
-	}
-
-	ResizeableBuffer buf;
-	buf.resize(allocator, 8);
-	buf.zero();
-
-	transport.SetLocation(file_size - 8);
-	transport.read(buf.ptr, 8);
-
-	bool footer_encrypted;
-	if (memcmp(buf.ptr + 4, "PAR1", 4) == 0) {
-		footer_encrypted = false;
-		if (encryption_config) {
-			throw InvalidInputException("File '%s' is not encrypted, but 'encryption_config' was set",
-			                            file_handle.path);
-		}
-	} else if (memcmp(buf.ptr + 4, "PARE", 4) == 0) {
-		footer_encrypted = true;
-		if (!encryption_config) {
-			throw InvalidInputException("File '%s' is encrypted, but 'encryption_config' was not set",
-			                            file_handle.path);
-		}
-	} else {
-		throw InvalidInputException("No magic bytes found at end of file '%s'", file_handle.path);
-	}
-
-	// read four-byte footer length from just before the end magic bytes
-	auto footer_len = *reinterpret_cast<uint32_t *>(buf.ptr);
-	if (footer_len == 0 || file_size < 12 + footer_len) {
-		throw InvalidInputException("Footer length error in file '%s'", file_handle.path);
-	}
-
-	auto metadata_pos = file_size - (footer_len + 8);
-	transport.SetLocation(metadata_pos);
-	transport.Prefetch(metadata_pos, footer_len);
-
-	auto metadata = make_uniq<FileMetaData>();
-	if (footer_encrypted) {
-		auto crypto_metadata = make_uniq<FileCryptoMetaData>();
-		crypto_metadata->read(file_proto.get());
-		if (crypto_metadata->encryption_algorithm.__isset.AES_GCM_CTR_V1) {
-			throw InvalidInputException("File '%s' is encrypted with AES_GCM_CTR_V1, but only AES_GCM_V1 is supported",
-			                            file_handle.path);
-		}
-		ParquetCrypto::Read(*metadata, *file_proto, encryption_config->GetFooterKey(), encryption_util);
-	} else {
-		metadata->read(file_proto.get());
-	}
-
-	// Try to read the GeoParquet metadata (if present)
-	auto geo_metadata = GeoParquetFileMetadata::TryRead(*metadata, context);
-
-	return make_shared_ptr<ParquetFileMetadataCache>(std::move(metadata), current_time, std::move(geo_metadata));
-}
-
-LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool binary_as_string) {
-	// inner node
-	if (s_ele.type == Type::FIXED_LEN_BYTE_ARRAY && !s_ele.__isset.type_length) {
-		throw IOException("FIXED_LEN_BYTE_ARRAY requires length to be set");
-	}
-	if (s_ele.__isset.logicalType) {
-		if (s_ele.logicalType.__isset.UUID) {
-			if (s_ele.type == Type::FIXED_LEN_BYTE_ARRAY) {
-				return LogicalType::UUID;
-			}
-		} else if (s_ele.logicalType.__isset.TIMESTAMP) {
-			if (s_ele.logicalType.TIMESTAMP.isAdjustedToUTC) {
-				return LogicalType::TIMESTAMP_TZ;
-			} else if (s_ele.logicalType.TIMESTAMP.unit.__isset.NANOS) {
-				return LogicalType::TIMESTAMP_NS;
-			}
-			return LogicalType::TIMESTAMP;
-		} else if (s_ele.logicalType.__isset.TIME) {
-			if (s_ele.logicalType.TIME.isAdjustedToUTC) {
-				return LogicalType::TIME_TZ;
-			}
-			return LogicalType::TIME;
-		}
-	}
-	if (s_ele.__isset.converted_type) {
-		// Legacy NULL type, does no longer exist, but files are still around of course
-		if (static_cast<uint8_t>(s_ele.converted_type) == 24) {
-			return LogicalTypeId::SQLNULL;
-		}
-		switch (s_ele.converted_type) {
-		case ConvertedType::INT_8:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::TINYINT;
-			} else {
-				throw IOException("INT8 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::INT_16:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::SMALLINT;
-			} else {
-				throw IOException("INT16 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::INT_32:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::INTEGER;
-			} else {
-				throw IOException("INT32 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::INT_64:
-			if (s_ele.type == Type::INT64) {
-				return LogicalType::BIGINT;
-			} else {
-				throw IOException("INT64 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::UINT_8:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::UTINYINT;
-			} else {
-				throw IOException("UINT8 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::UINT_16:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::USMALLINT;
-			} else {
-				throw IOException("UINT16 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::UINT_32:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::UINTEGER;
-			} else {
-				throw IOException("UINT32 converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::UINT_64:
-			if (s_ele.type == Type::INT64) {
-				return LogicalType::UBIGINT;
-			} else {
-				throw IOException("UINT64 converted type can only be set for value of Type::INT64");
-			}
-		case ConvertedType::DATE:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::DATE;
-			} else {
-				throw IOException("DATE converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::TIMESTAMP_MICROS:
-		case ConvertedType::TIMESTAMP_MILLIS:
-			if (s_ele.type == Type::INT64) {
-				return LogicalType::TIMESTAMP;
-			} else {
-				throw IOException("TIMESTAMP converted type can only be set for value of Type::INT64");
-			}
-		case ConvertedType::DECIMAL:
-			if (!s_ele.__isset.precision || !s_ele.__isset.scale) {
-				throw IOException("DECIMAL requires a length and scale specifier!");
-			}
-			if (s_ele.precision > DecimalType::MaxWidth()) {
-				return LogicalType::DOUBLE;
-			}
-			switch (s_ele.type) {
-			case Type::BYTE_ARRAY:
-			case Type::FIXED_LEN_BYTE_ARRAY:
-			case Type::INT32:
-			case Type::INT64:
-				return LogicalType::DECIMAL(s_ele.precision, s_ele.scale);
-			default:
-				throw IOException(
-				    "DECIMAL converted type can only be set for value of Type::(FIXED_LEN_)BYTE_ARRAY/INT32/INT64");
-			}
-		case ConvertedType::UTF8:
-		case ConvertedType::ENUM:
-			switch (s_ele.type) {
-			case Type::BYTE_ARRAY:
-			case Type::FIXED_LEN_BYTE_ARRAY:
-				return LogicalType::VARCHAR;
-			default:
-				throw IOException("UTF8 converted type can only be set for Type::(FIXED_LEN_)BYTE_ARRAY");
-			}
-		case ConvertedType::TIME_MILLIS:
-			if (s_ele.type == Type::INT32) {
-				return LogicalType::TIME;
-			} else {
-				throw IOException("TIME_MILLIS converted type can only be set for value of Type::INT32");
-			}
-		case ConvertedType::TIME_MICROS:
-			if (s_ele.type == Type::INT64) {
-				return LogicalType::TIME;
-			} else {
-				throw IOException("TIME_MICROS converted type can only be set for value of Type::INT64");
-			}
-		case ConvertedType::INTERVAL:
-			return LogicalType::INTERVAL;
-		case ConvertedType::JSON:
-			return LogicalType::JSON();
-		case ConvertedType::MAP:
-		case ConvertedType::MAP_KEY_VALUE:
-		case ConvertedType::LIST:
-		case ConvertedType::BSON:
-		default:
-			throw IOException("Unsupported converted type (%d)", (int32_t)s_ele.converted_type);
-		}
-	} else {
-		// no converted type set
-		// use default type for each physical type
-		switch (s_ele.type) {
-		case Type::BOOLEAN:
-			return LogicalType::BOOLEAN;
-		case Type::INT32:
-			return LogicalType::INTEGER;
-		case Type::INT64:
-			return LogicalType::BIGINT;
-		case Type::INT96: // always a timestamp it would seem
-			return LogicalType::TIMESTAMP;
-		case Type::FLOAT:
-			return LogicalType::FLOAT;
-		case Type::DOUBLE:
-			return LogicalType::DOUBLE;
-		case Type::BYTE_ARRAY:
-		case Type::FIXED_LEN_BYTE_ARRAY:
-			if (binary_as_string) {
-				return LogicalType::VARCHAR;
-			}
-			return LogicalType::BLOB;
-		default:
-			return LogicalType::INVALID;
-		}
-	}
-}
-
-LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele) {
-	return DeriveLogicalType(s_ele, parquet_options.binary_as_string);
-}
-
-unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(ClientContext &context,
-                                                              const vector<ColumnIndex> &indexes, idx_t depth,
-                                                              idx_t max_define, idx_t max_repeat,
-                                                              idx_t &next_schema_idx, idx_t &next_file_idx) {
-	auto file_meta_data = GetFileMetadata();
-	D_ASSERT(file_meta_data);
-	D_ASSERT(next_schema_idx < file_meta_data->schema.size());
-	auto &s_ele = file_meta_data->schema[next_schema_idx];
-	auto this_idx = next_schema_idx;
-
-	auto repetition_type = FieldRepetitionType::REQUIRED;
-	if (s_ele.__isset.repetition_type && this_idx > 0) {
-		repetition_type = s_ele.repetition_type;
-	}
-	if (repetition_type != FieldRepetitionType::REQUIRED) {
-		max_define++;
-	}
-	if (repetition_type == FieldRepetitionType::REPEATED) {
-		max_repeat++;
-	}
-
-	// Check for geoparquet spatial types
-	if (depth == 1) {
-		// geoparquet types have to be at the root of the schema, and have to be present in the kv metadata
-		if (metadata->geo_metadata && metadata->geo_metadata->IsGeometryColumn(s_ele.name)) {
-			return metadata->geo_metadata->CreateColumnReader(*this, DeriveLogicalType(s_ele), s_ele, next_file_idx++,
-			                                                  max_define, max_repeat, context);
-		}
-	}
-
-	if (s_ele.__isset.num_children && s_ele.num_children > 0) { // inner node
-		child_list_t<LogicalType> child_types;
-		vector<unique_ptr<ColumnReader>> child_readers;
-		// this type is a nested type - it has child columns specified
-		// create a mapping for which column readers we should create
-		unordered_map<idx_t, vector<ColumnIndex>> required_readers;
-		for (auto &index : indexes) {
-			required_readers.insert(make_pair(index.GetPrimaryIndex(), index.GetChildIndexes()));
-		}
-
-		idx_t c_idx = 0;
-		while (c_idx < (idx_t)s_ele.num_children) {
-			next_schema_idx++;
-
-			auto &child_ele = file_meta_data->schema[next_schema_idx];
-
-			// figure out which child columns we should read of this child column
-			vector<ColumnIndex> child_indexes;
-			auto entry = required_readers.find(c_idx);
-			if (entry != required_readers.end()) {
-				child_indexes = entry->second;
-			}
-			auto child_reader = CreateReaderRecursive(context, child_indexes, depth + 1, max_define, max_repeat,
-			                                          next_schema_idx, next_file_idx);
-			child_types.push_back(make_pair(child_ele.name, child_reader->Type()));
-			if (indexes.empty() || entry != required_readers.end()) {
-				// either (1) indexes is empty, meaning we need to read all child columns, or (2) we need to read this
-				// column
-				child_readers.push_back(std::move(child_reader));
-			} else {
-				// this column was explicitly not required - push an empty child reader here
-				child_readers.push_back(nullptr);
-			}
-
-			c_idx++;
-		}
-		// rename child type entries if there are case-insensitive duplicates by appending _1, _2 etc.
-		// behavior consistent with CSV reader fwiw
-		case_insensitive_map_t<idx_t> name_collision_count;
-		// get header names from CSV
-		for (auto &child_type : child_types) {
-			auto col_name = child_type.first;
-			// avoid duplicate header names
-			while (name_collision_count.find(col_name) != name_collision_count.end()) {
-				name_collision_count[col_name] += 1;
-				col_name = col_name + "_" + to_string(name_collision_count[col_name]);
-			}
-			child_type.first = col_name;
-			name_collision_count[col_name] = 0;
-		}
-
-		D_ASSERT(!child_types.empty());
-		unique_ptr<ColumnReader> result;
-		LogicalType result_type;
-
-		bool is_repeated = repetition_type == FieldRepetitionType::REPEATED;
-		bool is_list = s_ele.__isset.converted_type && s_ele.converted_type == ConvertedType::LIST;
-		bool is_map = s_ele.__isset.converted_type && s_ele.converted_type == ConvertedType::MAP;
-		bool is_map_kv = s_ele.__isset.converted_type && s_ele.converted_type == ConvertedType::MAP_KEY_VALUE;
-		if (!is_map_kv && this_idx > 0) {
-			// check if the parent node of this is a map
-			auto &p_ele = file_meta_data->schema[this_idx - 1];
-			bool parent_is_map = p_ele.__isset.converted_type && p_ele.converted_type == ConvertedType::MAP;
-			bool parent_has_children = p_ele.__isset.num_children && p_ele.num_children == 1;
-			is_map_kv = parent_is_map && parent_has_children;
-		}
-
-		if (is_map_kv) {
-			if (child_types.size() != 2) {
-				throw IOException("MAP_KEY_VALUE requires two children");
-			}
-			if (!is_repeated) {
-				throw IOException("MAP_KEY_VALUE needs to be repeated");
-			}
-			result_type = LogicalType::MAP(std::move(child_types[0].second), std::move(child_types[1].second));
-
-			auto struct_reader =
-			    make_uniq<StructColumnReader>(*this, ListType::GetChildType(result_type), s_ele, this_idx,
-			                                  max_define - 1, max_repeat - 1, std::move(child_readers));
-			return make_uniq<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                   std::move(struct_reader));
-		}
-		if (child_types.size() > 1 || (!is_list && !is_map && !is_repeated)) {
-			result_type = LogicalType::STRUCT(child_types);
-			result = make_uniq<StructColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                       std::move(child_readers));
-		} else {
-			// if we have a struct with only a single type, pull up
-			result_type = child_types[0].second;
-			result = std::move(child_readers[0]);
-		}
-		if (is_repeated) {
-			result_type = LogicalType::LIST(result_type);
-			result = make_uniq<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                     std::move(result));
-		}
-		result->SetParentSchema(s_ele);
-		return result;
-	} else { // leaf node
-		if (!s_ele.__isset.type) {
-			throw InvalidInputException(
-			    "Node has neither num_children nor type set - this violates the Parquet spec (corrupted file)");
-		}
-		if (s_ele.repetition_type == FieldRepetitionType::REPEATED) {
-			const auto derived_type = DeriveLogicalType(s_ele);
-			auto list_type = LogicalType::LIST(derived_type);
-
-			auto element_reader =
-			    ColumnReader::CreateReader(*this, derived_type, s_ele, next_file_idx++, max_define, max_repeat);
-
-			return make_uniq<ListColumnReader>(*this, list_type, s_ele, this_idx, max_define, max_repeat,
-			                                   std::move(element_reader));
-		}
-		// TODO check return value of derive type or should we only do this on read()
-		return ColumnReader::CreateReader(*this, DeriveLogicalType(s_ele), s_ele, next_file_idx++, max_define,
-		                                  max_repeat);
-	}
-}
-
-// TODO we don't need readers for columns we are not going to read ay
-unique_ptr<ColumnReader> ParquetReader::CreateReader(ClientContext &context) {
-	auto file_meta_data = GetFileMetadata();
-	idx_t next_schema_idx = 0;
-	idx_t next_file_idx = 0;
-
-	if (file_meta_data->schema.empty()) {
-		throw IOException("Parquet reader: no schema elements found");
-	}
-	if (file_meta_data->schema[0].num_children == 0) {
-		throw IOException("Parquet reader: root schema element has no children");
-	}
-	auto ret = CreateReaderRecursive(context, reader_data.column_indexes, 0, 0, 0, next_schema_idx, next_file_idx);
-	if (ret->Type().id() != LogicalTypeId::STRUCT) {
-		throw InvalidInputException("Root element of Parquet file must be a struct");
-	}
-	D_ASSERT(next_schema_idx == file_meta_data->schema.size() - 1);
-	D_ASSERT(file_meta_data->row_groups.empty() || next_file_idx == file_meta_data->row_groups[0].columns.size());
-
-	auto &root_struct_reader = ret->Cast<StructColumnReader>();
-	// add casts if required
-	for (auto &entry : reader_data.cast_map) {
-		auto column_idx = entry.first;
-		auto &expected_type = entry.second;
-		auto child_reader = std::move(root_struct_reader.child_readers[column_idx]);
-		auto cast_reader = make_uniq<CastColumnReader>(std::move(child_reader), expected_type);
-		root_struct_reader.child_readers[column_idx] = std::move(cast_reader);
-	}
-	if (parquet_options.file_row_number) {
-		file_row_number_idx = root_struct_reader.child_readers.size();
-
-		generated_column_schema.push_back(SchemaElement());
-		root_struct_reader.child_readers.push_back(make_uniq<RowNumberColumnReader>(
-		    *this, LogicalType::BIGINT, generated_column_schema.back(), next_file_idx, 0, 0));
-	}
-
-	return ret;
-}
-
-void ParquetReader::InitializeSchema(ClientContext &context) {
-	auto file_meta_data = GetFileMetadata();
-
-	if (file_meta_data->__isset.encryption_algorithm) {
-		if (file_meta_data->encryption_algorithm.__isset.AES_GCM_CTR_V1) {
-			throw InvalidInputException("File '%s' is encrypted with AES_GCM_CTR_V1, but only AES_GCM_V1 is supported",
-			                            file_name);
-		}
-	}
-	// check if we like this schema
-	if (file_meta_data->schema.size() < 2) {
-		throw FormatException("Need at least one non-root column in the file");
-	}
-	root_reader = CreateReader(context);
-	auto &root_type = root_reader->Type();
-	auto &child_types = StructType::GetChildTypes(root_type);
-	D_ASSERT(root_type.id() == LogicalTypeId::STRUCT);
-	for (auto &type_pair : child_types) {
-		names.push_back(type_pair.first);
-		return_types.push_back(type_pair.second);
-	}
-
-	// Add generated constant column for row number
-	if (parquet_options.file_row_number) {
-		if (StringUtil::CIFind(names, "file_row_number") != DConstants::INVALID_INDEX) {
-			throw BinderException(
-			    "Using file_row_number option on file with column named file_row_number is not supported");
-		}
-		return_types.emplace_back(LogicalType::BIGINT);
-		names.emplace_back("file_row_number");
-	}
-}
-
-ParquetOptions::ParquetOptions(ClientContext &context) {
-	Value binary_as_string_val;
-	if (context.TryGetCurrentSetting("binary_as_string", binary_as_string_val)) {
-		binary_as_string = binary_as_string_val.GetValue<bool>();
-	}
-}
-
-ParquetColumnDefinition ParquetColumnDefinition::FromSchemaValue(ClientContext &context, const Value &column_value) {
-	ParquetColumnDefinition result;
-	result.field_id = IntegerValue::Get(StructValue::GetChildren(column_value)[0]);
-
-	const auto &column_def = StructValue::GetChildren(column_value)[1];
-	D_ASSERT(column_def.type().id() == LogicalTypeId::STRUCT);
-
-	const auto children = StructValue::GetChildren(column_def);
-	result.name = StringValue::Get(children[0]);
-	result.type = TransformStringToLogicalType(StringValue::Get(children[1]));
-	string error_message;
-	if (!children[2].TryCastAs(context, result.type, result.default_value, &error_message)) {
-		throw BinderException("Unable to cast Parquet schema default_value \"%s\" to %s", children[2].ToString(),
-		                      result.type.ToString());
-	}
-
-	return result;
-}
-
-ParquetReader::ParquetReader(ClientContext &context_p, string file_name_p, ParquetOptions parquet_options_p,
-                             shared_ptr<ParquetFileMetadataCache> metadata_p)
-    : fs(FileSystem::GetFileSystem(context_p)), allocator(BufferAllocator::Get(context_p)),
-      parquet_options(std::move(parquet_options_p)) {
-	file_name = std::move(file_name_p);
-	file_handle = fs.OpenFile(file_name, FileFlags::FILE_FLAGS_READ);
-	if (!file_handle->CanSeek()) {
-		throw NotImplementedException(
-		    "Reading parquet files from a FIFO stream is not supported and cannot be efficiently supported since "
-		    "metadata is located at the end of the file. Write the stream to disk first and read from there instead.");
-	}
-
-	// set pointer to factory method for AES state
-	auto &config = DBConfig::GetConfig(context_p);
-	if (config.encryption_util && parquet_options.debug_use_openssl) {
-		encryption_util = config.encryption_util;
-	} else {
-		encryption_util = make_shared_ptr<duckdb_mbedtls::MbedTlsWrapper::AESGCMStateMBEDTLSFactory>();
-	}
-
-	// If metadata cached is disabled
-	// or if this file has cached metadata
-	// or if the cached version already expired
-	if (!metadata_p) {
-		Value metadata_cache = false;
-		context_p.TryGetCurrentSetting("parquet_metadata_cache", metadata_cache);
-		if (!metadata_cache.GetValue<bool>()) {
-			metadata =
-			    LoadMetadata(context_p, allocator, *file_handle, parquet_options.encryption_config, *encryption_util);
-		} else {
-			auto last_modify_time = fs.GetLastModifiedTime(*file_handle);
-			metadata = ObjectCache::GetObjectCache(context_p).Get<ParquetFileMetadataCache>(file_name);
-			if (!metadata || (last_modify_time + 10 >= metadata->read_time)) {
-				metadata = LoadMetadata(context_p, allocator, *file_handle, parquet_options.encryption_config,
-				                        *encryption_util);
-				ObjectCache::GetObjectCache(context_p).Put(file_name, metadata);
-			}
-		}
-	} else {
-		metadata = std::move(metadata_p);
-	}
-	InitializeSchema(context_p);
-}
-
-ParquetUnionData::~ParquetUnionData() {
-}
-
-ParquetReader::ParquetReader(ClientContext &context_p, ParquetOptions parquet_options_p,
-                             shared_ptr<ParquetFileMetadataCache> metadata_p)
-    : fs(FileSystem::GetFileSystem(context_p)), allocator(BufferAllocator::Get(context_p)),
-      metadata(std::move(metadata_p)), parquet_options(std::move(parquet_options_p)) {
-	InitializeSchema(context_p);
-}
-
-ParquetReader::~ParquetReader() {
-}
-
-const FileMetaData *ParquetReader::GetFileMetadata() {
-	D_ASSERT(metadata);
-	D_ASSERT(metadata->metadata);
-	return metadata->metadata.get();
-}
-
-unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(const string &name) {
-	idx_t file_col_idx;
-	for (file_col_idx = 0; file_col_idx < names.size(); file_col_idx++) {
-		if (names[file_col_idx] == name) {
-			break;
-		}
-	}
-	if (file_col_idx == names.size()) {
-		return nullptr;
-	}
-
-	unique_ptr<BaseStatistics> column_stats;
-	auto file_meta_data = GetFileMetadata();
-	auto &column_reader = root_reader->Cast<StructColumnReader>().GetChildReader(file_col_idx);
-
-	for (idx_t row_group_idx = 0; row_group_idx < file_meta_data->row_groups.size(); row_group_idx++) {
-		auto &row_group = file_meta_data->row_groups[row_group_idx];
-		auto chunk_stats = column_reader.Stats(row_group_idx, row_group.columns);
-		if (!chunk_stats) {
-			return nullptr;
-		}
-		if (!column_stats) {
-			column_stats = std::move(chunk_stats);
-		} else {
-			column_stats->Merge(*chunk_stats);
-		}
-	}
-	return column_stats;
-}
-
-unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(ClientContext &context, ParquetOptions parquet_options,
-                                                         shared_ptr<ParquetFileMetadataCache> metadata,
-                                                         const string &name) {
-	ParquetReader reader(context, std::move(parquet_options), std::move(metadata));
-	return reader.ReadStatistics(name);
-}
-
-uint32_t ParquetReader::Read(duckdb_apache::thrift::TBase &object, TProtocol &iprot) {
-	if (parquet_options.encryption_config) {
-		return ParquetCrypto::Read(object, iprot, parquet_options.encryption_config->GetFooterKey(), *encryption_util);
-	} else {
-		return object.read(&iprot);
-	}
-}
-
-uint32_t ParquetReader::ReadData(duckdb_apache::thrift::protocol::TProtocol &iprot, const data_ptr_t buffer,
-                                 const uint32_t buffer_size) {
-	if (parquet_options.encryption_config) {
-		return ParquetCrypto::ReadData(iprot, buffer, buffer_size, parquet_options.encryption_config->GetFooterKey(),
-		                               *encryption_util);
-	} else {
-		return iprot.getTransport()->read(buffer, buffer_size);
-	}
-}
-
-const ParquetRowGroup &ParquetReader::GetGroup(ParquetReaderScanState &state) {
-	auto file_meta_data = GetFileMetadata();
-	D_ASSERT(state.current_group >= 0 && (idx_t)state.current_group < state.group_idx_list.size());
-	D_ASSERT(state.group_idx_list[state.current_group] < file_meta_data->row_groups.size());
-	return file_meta_data->row_groups[state.group_idx_list[state.current_group]];
-}
-
-uint64_t ParquetReader::GetGroupCompressedSize(ParquetReaderScanState &state) {
-	auto &group = GetGroup(state);
-	auto total_compressed_size = group.total_compressed_size;
-
-	idx_t calc_compressed_size = 0;
-
-	// If the global total_compressed_size is not set, we can still calculate it
-	if (group.total_compressed_size == 0) {
-		for (auto &column_chunk : group.columns) {
-			calc_compressed_size += column_chunk.meta_data.total_compressed_size;
-		}
-	}
-
-	if (total_compressed_size != 0 && calc_compressed_size != 0 &&
-	    (idx_t)total_compressed_size != calc_compressed_size) {
-		throw InvalidInputException("mismatch between calculated compressed size and reported compressed size");
-	}
-
-	return total_compressed_size ? total_compressed_size : calc_compressed_size;
-}
-
-uint64_t ParquetReader::GetGroupSpan(ParquetReaderScanState &state) {
-	auto &group = GetGroup(state);
-	idx_t min_offset = NumericLimits<idx_t>::Maximum();
-	idx_t max_offset = NumericLimits<idx_t>::Minimum();
-
-	for (auto &column_chunk : group.columns) {
-
-		// Set the min offset
-		idx_t current_min_offset = NumericLimits<idx_t>::Maximum();
-		if (column_chunk.meta_data.__isset.dictionary_page_offset) {
-			current_min_offset = MinValue<idx_t>(current_min_offset, column_chunk.meta_data.dictionary_page_offset);
-		}
-		if (column_chunk.meta_data.__isset.index_page_offset) {
-			current_min_offset = MinValue<idx_t>(current_min_offset, column_chunk.meta_data.index_page_offset);
-		}
-		current_min_offset = MinValue<idx_t>(current_min_offset, column_chunk.meta_data.data_page_offset);
-		min_offset = MinValue<idx_t>(current_min_offset, min_offset);
-		max_offset = MaxValue<idx_t>(max_offset, column_chunk.meta_data.total_compressed_size + current_min_offset);
-	}
-
-	return max_offset - min_offset;
-}
-
-idx_t ParquetReader::GetGroupOffset(ParquetReaderScanState &state) {
-	auto &group = GetGroup(state);
-	idx_t min_offset = NumericLimits<idx_t>::Maximum();
-
-	for (auto &column_chunk : group.columns) {
-		if (column_chunk.meta_data.__isset.dictionary_page_offset) {
-			min_offset = MinValue<idx_t>(min_offset, column_chunk.meta_data.dictionary_page_offset);
-		}
-		if (column_chunk.meta_data.__isset.index_page_offset) {
-			min_offset = MinValue<idx_t>(min_offset, column_chunk.meta_data.index_page_offset);
-		}
-		min_offset = MinValue<idx_t>(min_offset, column_chunk.meta_data.data_page_offset);
-	}
-
-	return min_offset;
-}
-
-static FilterPropagateResult CheckParquetStringFilter(BaseStatistics &stats, const Statistics &pq_col_stats,
-                                                      TableFilter &filter) {
-	if (filter.filter_type == TableFilterType::CONSTANT_COMPARISON) {
-		auto &constant_filter = filter.Cast<ConstantFilter>();
-		auto &min_value = pq_col_stats.min_value;
-		auto &max_value = pq_col_stats.max_value;
-		return StringStats::CheckZonemap(const_data_ptr_cast(min_value.c_str()), min_value.size(),
-		                                 const_data_ptr_cast(max_value.c_str()), max_value.size(),
-		                                 constant_filter.comparison_type, StringValue::Get(constant_filter.constant));
-	} else {
-		return filter.CheckStatistics(stats);
-	}
-}
-
-void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t col_idx) {
-	auto &group = GetGroup(state);
-	auto column_id = reader_data.column_ids[col_idx];
-	auto &column_reader = state.root_reader->Cast<StructColumnReader>().GetChildReader(column_id);
-
-	// TODO move this to columnreader too
-	if (reader_data.filters) {
-		auto stats = column_reader.Stats(state.group_idx_list[state.current_group], group.columns);
-		// filters contain output chunk index, not file col idx!
-		auto global_id = reader_data.column_mapping[col_idx];
-		auto filter_entry = reader_data.filters->filters.find(global_id);
-
-		if (stats && filter_entry != reader_data.filters->filters.end()) {
-			auto &filter = *filter_entry->second;
-
-			FilterPropagateResult prune_result;
-			// TODO we might not have stats but STILL a bloom filter so move this up
-			// check the bloom filter if present
-			if (!column_reader.Type().IsNested() &&
-			    ParquetStatisticsUtils::BloomFilterSupported(column_reader.Type().id()) &&
-			    ParquetStatisticsUtils::BloomFilterExcludes(filter, group.columns[column_reader.FileIdx()].meta_data,
-			                                                *state.thrift_file_proto, allocator)) {
-				prune_result = FilterPropagateResult::FILTER_ALWAYS_FALSE;
-			} else if (column_reader.Type().id() == LogicalTypeId::VARCHAR &&
-			           group.columns[column_reader.FileIdx()].meta_data.statistics.__isset.min_value &&
-			           group.columns[column_reader.FileIdx()].meta_data.statistics.__isset.max_value) {
-
-				// our StringStats only store the first 8 bytes of strings (even if Parquet has longer string stats)
-				// however, when reading remote Parquet files, skipping row groups is really important
-				// here, we implement a special case to check the full length for string filters
-				if (filter.filter_type == TableFilterType::CONJUNCTION_AND) {
-					const auto &and_filter = filter.Cast<ConjunctionAndFilter>();
-					auto and_result = FilterPropagateResult::FILTER_ALWAYS_TRUE;
-					for (auto &child_filter : and_filter.child_filters) {
-						auto child_prune_result = CheckParquetStringFilter(
-						    *stats, group.columns[column_reader.FileIdx()].meta_data.statistics, *child_filter);
-						if (child_prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-							and_result = FilterPropagateResult::FILTER_ALWAYS_FALSE;
-							break;
-						} else if (child_prune_result != and_result) {
-							and_result = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-						}
-					}
-					prune_result = and_result;
-				} else {
-					prune_result = CheckParquetStringFilter(
-					    *stats, group.columns[column_reader.FileIdx()].meta_data.statistics, filter);
-				}
-			} else {
-				prune_result = filter.CheckStatistics(*stats);
-			}
-
-			if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-				// this effectively will skip this chunk
-				state.group_offset = group.num_rows;
-				return;
-			}
-		}
-	}
-
-	state.root_reader->InitializeRead(state.group_idx_list[state.current_group], group.columns,
-	                                  *state.thrift_file_proto);
-}
-
-idx_t ParquetReader::NumRows() {
-	return GetFileMetadata()->num_rows;
-}
-
-idx_t ParquetReader::NumRowGroups() {
-	return GetFileMetadata()->row_groups.size();
-}
-
-void ParquetReader::InitializeScan(ClientContext &context, ParquetReaderScanState &state,
-                                   vector<idx_t> groups_to_read) {
-	state.current_group = -1;
-	state.finished = false;
-	state.group_offset = 0;
-	state.group_idx_list = std::move(groups_to_read);
-	state.sel.Initialize(STANDARD_VECTOR_SIZE);
-	if (!state.file_handle || state.file_handle->path != file_handle->path) {
-		auto flags = FileFlags::FILE_FLAGS_READ;
-
-		Value disable_prefetch = false;
-		Value prefetch_all_files = false;
-		context.TryGetCurrentSetting("disable_parquet_prefetching", disable_prefetch);
-		context.TryGetCurrentSetting("prefetch_all_parquet_files", prefetch_all_files);
-		bool should_prefetch = !file_handle->OnDiskFile() || prefetch_all_files.GetValue<bool>();
-		bool can_prefetch = file_handle->CanSeek() && !disable_prefetch.GetValue<bool>();
-
-		if (should_prefetch && can_prefetch) {
-			state.prefetch_mode = true;
-			flags |= FileFlags::FILE_FLAGS_DIRECT_IO;
-		} else {
-			state.prefetch_mode = false;
-		}
-
-		state.file_handle = fs.OpenFile(file_handle->path, flags);
-	}
-
-	state.thrift_file_proto = CreateThriftFileProtocol(allocator, *state.file_handle, state.prefetch_mode);
-	state.root_reader = CreateReader(context);
-	state.define_buf.resize(allocator, STANDARD_VECTOR_SIZE);
-	state.repeat_buf.resize(allocator, STANDARD_VECTOR_SIZE);
-}
-
-void FilterIsNull(Vector &v, parquet_filter_t &filter_mask, idx_t count) {
-	if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto &mask = ConstantVector::Validity(v);
-		if (mask.RowIsValid(0)) {
-			filter_mask.reset();
-		}
-		return;
-	}
-
-	UnifiedVectorFormat unified;
-	v.ToUnifiedFormat(count, unified);
-
-	if (unified.validity.AllValid()) {
-		filter_mask.reset();
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			if (filter_mask.test(i)) {
-				filter_mask.set(i, !unified.validity.RowIsValid(unified.sel->get_index(i)));
-			}
-		}
-	}
-}
-
-void FilterIsNotNull(Vector &v, parquet_filter_t &filter_mask, idx_t count) {
-	if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto &mask = ConstantVector::Validity(v);
-		if (!mask.RowIsValid(0)) {
-			filter_mask.reset();
-		}
-		return;
-	}
-
-	UnifiedVectorFormat unified;
-	v.ToUnifiedFormat(count, unified);
-
-	if (!unified.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			if (filter_mask.test(i)) {
-				filter_mask.set(i, unified.validity.RowIsValid(unified.sel->get_index(i)));
-			}
-		}
-	}
-}
-
-template <class T, class OP>
-void TemplatedFilterOperation(Vector &v, T constant, parquet_filter_t &filter_mask, idx_t count) {
-	if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto v_ptr = ConstantVector::GetData<T>(v);
-		auto &mask = ConstantVector::Validity(v);
-
-		if (mask.RowIsValid(0)) {
-			if (!OP::Operation(v_ptr[0], constant)) {
-				filter_mask.reset();
-			}
-		} else {
-			filter_mask.reset();
-		}
-		return;
-	}
-
-	UnifiedVectorFormat unified;
-	v.ToUnifiedFormat(count, unified);
-	auto data_ptr = UnifiedVectorFormat::GetData<T>(unified);
-
-	if (!unified.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			if (filter_mask.test(i)) {
-				auto idx = unified.sel->get_index(i);
-				bool is_valid = unified.validity.RowIsValid(idx);
-				if (is_valid) {
-					filter_mask.set(i, OP::Operation(data_ptr[idx], constant));
-				} else {
-					filter_mask.set(i, false);
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			if (filter_mask.test(i)) {
-				filter_mask.set(i, OP::Operation(data_ptr[unified.sel->get_index(i)], constant));
-			}
-		}
-	}
-}
-
-template <class T, class OP>
-void TemplatedFilterOperation(Vector &v, const Value &constant, parquet_filter_t &filter_mask, idx_t count) {
-	TemplatedFilterOperation<T, OP>(v, constant.template GetValueUnsafe<T>(), filter_mask, count);
-}
-
-template <class OP>
-static void FilterOperationSwitch(Vector &v, Value &constant, parquet_filter_t &filter_mask, idx_t count) {
-	if (filter_mask.none() || count == 0) {
-		return;
-	}
-	switch (v.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-		TemplatedFilterOperation<bool, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedFilterOperation<uint8_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedFilterOperation<uint16_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedFilterOperation<uint32_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedFilterOperation<uint64_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::INT8:
-		TemplatedFilterOperation<int8_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedFilterOperation<int16_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedFilterOperation<int32_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedFilterOperation<int64_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedFilterOperation<hugeint_t, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedFilterOperation<float, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedFilterOperation<double, OP>(v, constant, filter_mask, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedFilterOperation<string_t, OP>(v, constant, filter_mask, count);
-		break;
-	default:
-		throw NotImplementedException("Unsupported type for filter %s", v.ToString());
-	}
-}
-
-static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter_mask, idx_t count) {
-	switch (filter.filter_type) {
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction = filter.Cast<ConjunctionAndFilter>();
-		for (auto &child_filter : conjunction.child_filters) {
-			ApplyFilter(v, *child_filter, filter_mask, count);
-		}
-		break;
-	}
-	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction = filter.Cast<ConjunctionOrFilter>();
-		parquet_filter_t or_mask;
-		for (auto &child_filter : conjunction.child_filters) {
-			parquet_filter_t child_mask = filter_mask;
-			ApplyFilter(v, *child_filter, child_mask, count);
-			or_mask |= child_mask;
-		}
-		filter_mask &= or_mask;
-		break;
-	}
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = filter.Cast<ConstantFilter>();
-		switch (constant_filter.comparison_type) {
-		case ExpressionType::COMPARE_EQUAL:
-			FilterOperationSwitch<Equals>(v, constant_filter.constant, filter_mask, count);
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-			FilterOperationSwitch<LessThan>(v, constant_filter.constant, filter_mask, count);
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			FilterOperationSwitch<LessThanEquals>(v, constant_filter.constant, filter_mask, count);
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			FilterOperationSwitch<GreaterThan>(v, constant_filter.constant, filter_mask, count);
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			FilterOperationSwitch<GreaterThanEquals>(v, constant_filter.constant, filter_mask, count);
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-			FilterOperationSwitch<NotEquals>(v, constant_filter.constant, filter_mask, count);
-			break;
-		default:
-			throw InternalException("Unsupported comparison for Parquet filter pushdown");
-		}
-		break;
-	}
-	case TableFilterType::IS_NOT_NULL:
-		FilterIsNotNull(v, filter_mask, count);
-		break;
-	case TableFilterType::IS_NULL:
-		FilterIsNull(v, filter_mask, count);
-		break;
-	case TableFilterType::STRUCT_EXTRACT: {
-		auto &struct_filter = filter.Cast<StructFilter>();
-		auto &child = StructVector::GetEntries(v)[struct_filter.child_idx];
-		ApplyFilter(*child, *struct_filter.child_filter, filter_mask, count);
-	}
-	case TableFilterType::OPTIONAL_FILTER: {
-		// we don't execute zone map filters here - we only consider them for zone map pruning
-		// do nothing to the mask.
-		break;
-	}
-	default:
-		D_ASSERT(0);
-		break;
-	}
-}
-
-void ParquetReader::Scan(ParquetReaderScanState &state, DataChunk &result) {
-	while (ScanInternal(state, result)) {
-		if (result.size() > 0) {
-			break;
-		}
-		result.Reset();
-	}
-}
-
-bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &result) {
-	if (state.finished) {
-		return false;
-	}
-
-	// see if we have to switch to the next row group in the parquet file
-	if (state.current_group < 0 || (int64_t)state.group_offset >= GetGroup(state).num_rows) {
-		state.current_group++;
-		state.group_offset = 0;
-
-		auto &trans = reinterpret_cast<ThriftFileTransport &>(*state.thrift_file_proto->getTransport());
-		trans.ClearPrefetch();
-		state.current_group_prefetched = false;
-
-		if ((idx_t)state.current_group == state.group_idx_list.size()) {
-			state.finished = true;
-			return false;
-		}
-
-		uint64_t to_scan_compressed_bytes = 0;
-		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
-			PrepareRowGroupBuffer(state, col_idx);
-
-			auto file_col_idx = reader_data.column_ids[col_idx];
-
-			auto &root_reader = state.root_reader->Cast<StructColumnReader>();
-			to_scan_compressed_bytes += root_reader.GetChildReader(file_col_idx).TotalCompressedSize();
-		}
-
-		auto &group = GetGroup(state);
-		if (state.prefetch_mode && state.group_offset != (idx_t)group.num_rows) {
-			uint64_t total_row_group_span = GetGroupSpan(state);
-
-			double scan_percentage = (double)(to_scan_compressed_bytes) / static_cast<double>(total_row_group_span);
-
-			if (to_scan_compressed_bytes > total_row_group_span) {
-				throw IOException(
-				    "The parquet file '%s' seems to have incorrectly set page offsets. This interferes with DuckDB's "
-				    "prefetching optimization. DuckDB may still be able to scan this file by manually disabling the "
-				    "prefetching mechanism using: 'SET disable_parquet_prefetching=true'.",
-				    file_name);
-			}
-
-			if (!reader_data.filters &&
-			    scan_percentage > ParquetReaderPrefetchConfig::WHOLE_GROUP_PREFETCH_MINIMUM_SCAN) {
-				// Prefetch the whole row group
-				if (!state.current_group_prefetched) {
-					auto total_compressed_size = GetGroupCompressedSize(state);
-					if (total_compressed_size > 0) {
-						trans.Prefetch(GetGroupOffset(state), total_row_group_span);
-					}
-					state.current_group_prefetched = true;
-				}
-			} else {
-				// lazy fetching is when all tuples in a column can be skipped. With lazy fetching the buffer is only
-				// fetched on the first read to that buffer.
-				bool lazy_fetch = reader_data.filters;
-
-				// Prefetch column-wise
-				for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
-					auto file_col_idx = reader_data.column_ids[col_idx];
-					auto &root_reader = state.root_reader->Cast<StructColumnReader>();
-
-					bool has_filter = false;
-					if (reader_data.filters) {
-						auto entry = reader_data.filters->filters.find(reader_data.column_mapping[col_idx]);
-						has_filter = entry != reader_data.filters->filters.end();
-					}
-					root_reader.GetChildReader(file_col_idx).RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
-				}
-
-				trans.FinalizeRegistration();
-
-				if (!lazy_fetch) {
-					trans.PrefetchRegistered();
-				}
-			}
-		}
-		return true;
-	}
-
-	auto this_output_chunk_rows = MinValue<idx_t>(STANDARD_VECTOR_SIZE, GetGroup(state).num_rows - state.group_offset);
-	result.SetCardinality(this_output_chunk_rows);
-
-	if (this_output_chunk_rows == 0) {
-		state.finished = true;
-		return false; // end of last group, we are done
-	}
-
-	// we evaluate simple table filters directly in this scan so we can skip decoding column data that's never going to
-	// be relevant
-	parquet_filter_t filter_mask;
-	filter_mask.set();
-
-	// mask out unused part of bitset
-	for (idx_t i = this_output_chunk_rows; i < STANDARD_VECTOR_SIZE; i++) {
-		filter_mask.set(i, false);
-	}
-
-	state.define_buf.zero();
-	state.repeat_buf.zero();
-
-	auto define_ptr = (uint8_t *)state.define_buf.ptr;
-	auto repeat_ptr = (uint8_t *)state.repeat_buf.ptr;
-
-	auto &root_reader = state.root_reader->Cast<StructColumnReader>();
-
-	if (reader_data.filters) {
-		vector<bool> need_to_read(reader_data.column_ids.size(), true);
-
-		// first load the columns that are used in filters
-		for (auto &filter_col : reader_data.filters->filters) {
-			if (filter_mask.none()) {
-				// if no rows are left we can stop checking filters
-				break;
-			}
-			auto filter_entry = reader_data.filter_map[filter_col.first];
-			if (filter_entry.is_constant) {
-				// this is a constant vector, look for the constant
-				auto &constant = reader_data.constant_map[filter_entry.index].value;
-				Vector constant_vector(constant);
-				ApplyFilter(constant_vector, *filter_col.second, filter_mask, this_output_chunk_rows);
-			} else {
-				auto id = filter_entry.index;
-				auto file_col_idx = reader_data.column_ids[id];
-				auto result_idx = reader_data.column_mapping[id];
-
-				auto &result_vector = result.data[result_idx];
-				auto &child_reader = root_reader.GetChildReader(file_col_idx);
-				child_reader.Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
-				need_to_read[id] = false;
-
-				ApplyFilter(result_vector, *filter_col.second, filter_mask, this_output_chunk_rows);
-			}
-		}
-
-		// we still may have to read some cols
-		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
-			if (!need_to_read[col_idx]) {
-				continue;
-			}
-			auto file_col_idx = reader_data.column_ids[col_idx];
-			if (filter_mask.none()) {
-				root_reader.GetChildReader(file_col_idx).Skip(result.size());
-				continue;
-			}
-			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto &child_reader = root_reader.GetChildReader(file_col_idx);
-			child_reader.Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
-		}
-
-		idx_t sel_size = 0;
-		for (idx_t i = 0; i < this_output_chunk_rows; i++) {
-			if (filter_mask.test(i)) {
-				state.sel.set_index(sel_size++, i);
-			}
-		}
-
-		result.Slice(state.sel, sel_size);
-	} else {
-		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
-			auto file_col_idx = reader_data.column_ids[col_idx];
-			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto &child_reader = root_reader.GetChildReader(file_col_idx);
-			auto rows_read = child_reader.Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
-			if (rows_read != result.size()) {
-				throw InvalidInputException("Mismatch in parquet read for column %llu, expected %llu rows, got %llu",
-				                            file_col_idx, result.size(), rows_read);
-			}
-		}
-	}
-
-	state.group_offset += this_output_chunk_rows;
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/parquet_statistics.cpp b/src/duckdb/extension/parquet/parquet_statistics.cpp
deleted file mode 100644
index 7e4ceac40..000000000
--- a/src/duckdb/extension/parquet/parquet_statistics.cpp
+++ /dev/null
@@ -1,610 +0,0 @@
-#include "parquet_statistics.hpp"
-
-#include "duckdb.hpp"
-#include "parquet_decimal_utils.hpp"
-#include "parquet_timestamp.hpp"
-#include "string_column_reader.hpp"
-#include "struct_column_reader.hpp"
-#include "zstd/common/xxhash.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/types/blob.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#endif
-
-namespace duckdb {
-
-using duckdb_parquet::ConvertedType;
-using duckdb_parquet::Type;
-
-static unique_ptr<BaseStatistics> CreateNumericStats(const LogicalType &type,
-                                                     const duckdb_parquet::SchemaElement &schema_ele,
-                                                     const duckdb_parquet::Statistics &parquet_stats) {
-	auto stats = NumericStats::CreateUnknown(type);
-
-	// for reasons unknown to science, Parquet defines *both* `min` and `min_value` as well as `max` and
-	// `max_value`. All are optional. such elegance.
-	Value min;
-	Value max;
-	if (parquet_stats.__isset.min_value) {
-		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value);
-	} else if (parquet_stats.__isset.min) {
-		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min);
-	} else {
-		min = Value(type);
-	}
-	if (parquet_stats.__isset.max_value) {
-		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value);
-	} else if (parquet_stats.__isset.max) {
-		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max);
-	} else {
-		max = Value(type);
-	}
-	NumericStats::SetMin(stats, min);
-	NumericStats::SetMax(stats, max);
-	return stats.ToUnique();
-}
-
-Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type, const duckdb_parquet::SchemaElement &schema_ele,
-                                           const std::string &stats) {
-	Value result;
-	string error;
-	auto stats_val = ConvertValueInternal(type, schema_ele, stats);
-	if (!stats_val.DefaultTryCastAs(type, result, &error)) {
-		return Value(type);
-	}
-	return result;
-}
-Value ParquetStatisticsUtils::ConvertValueInternal(const LogicalType &type,
-                                                   const duckdb_parquet::SchemaElement &schema_ele,
-                                                   const std::string &stats) {
-	auto stats_data = const_data_ptr_cast(stats.c_str());
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN: {
-		if (stats.size() != sizeof(bool)) {
-			throw InvalidInputException("Incorrect stats size for type BOOLEAN");
-		}
-		return Value::BOOLEAN(Load<bool>(stats_data));
-	}
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-		if (stats.size() != sizeof(uint32_t)) {
-			throw InvalidInputException("Incorrect stats size for type UINTEGER");
-		}
-		return Value::UINTEGER(Load<uint32_t>(stats_data));
-	case LogicalTypeId::UBIGINT:
-		if (stats.size() != sizeof(uint64_t)) {
-			throw InvalidInputException("Incorrect stats size for type UBIGINT");
-		}
-		return Value::UBIGINT(Load<uint64_t>(stats_data));
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-		if (stats.size() != sizeof(int32_t)) {
-			throw InvalidInputException("Incorrect stats size for type INTEGER");
-		}
-		return Value::INTEGER(Load<int32_t>(stats_data));
-	case LogicalTypeId::BIGINT:
-		if (stats.size() != sizeof(int64_t)) {
-			throw InvalidInputException("Incorrect stats size for type BIGINT");
-		}
-		return Value::BIGINT(Load<int64_t>(stats_data));
-	case LogicalTypeId::FLOAT: {
-		if (stats.size() != sizeof(float)) {
-			throw InvalidInputException("Incorrect stats size for type FLOAT");
-		}
-		auto val = Load<float>(stats_data);
-		if (!Value::FloatIsFinite(val)) {
-			return Value();
-		}
-		return Value::FLOAT(val);
-	}
-	case LogicalTypeId::DOUBLE: {
-		switch (schema_ele.type) {
-		case Type::FIXED_LEN_BYTE_ARRAY:
-		case Type::BYTE_ARRAY:
-			// decimals cast to double
-			return Value::DOUBLE(ParquetDecimalUtils::ReadDecimalValue<double>(stats_data, stats.size(), schema_ele));
-		default:
-			break;
-		}
-		if (stats.size() != sizeof(double)) {
-			throw InvalidInputException("Incorrect stats size for type DOUBLE");
-		}
-		auto val = Load<double>(stats_data);
-		if (!Value::DoubleIsFinite(val)) {
-			return Value();
-		}
-		return Value::DOUBLE(val);
-	}
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (schema_ele.type) {
-		case Type::INT32: {
-			if (stats.size() != sizeof(int32_t)) {
-				throw InvalidInputException("Incorrect stats size for type %s", type.ToString());
-			}
-			return Value::DECIMAL(Load<int32_t>(stats_data), width, scale);
-		}
-		case Type::INT64: {
-			if (stats.size() != sizeof(int64_t)) {
-				throw InvalidInputException("Incorrect stats size for type %s", type.ToString());
-			}
-			return Value::DECIMAL(Load<int64_t>(stats_data), width, scale);
-		}
-		case Type::BYTE_ARRAY:
-		case Type::FIXED_LEN_BYTE_ARRAY:
-			switch (type.InternalType()) {
-			case PhysicalType::INT16:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int16_t>(stats_data, stats.size(), schema_ele), width, scale);
-			case PhysicalType::INT32:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int32_t>(stats_data, stats.size(), schema_ele), width, scale);
-			case PhysicalType::INT64:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int64_t>(stats_data, stats.size(), schema_ele), width, scale);
-			case PhysicalType::INT128:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<hugeint_t>(stats_data, stats.size(), schema_ele), width,
-				    scale);
-			default:
-				throw InvalidInputException("Unsupported internal type for decimal");
-			}
-		default:
-			throw InternalException("Unsupported internal type for decimal?..");
-		}
-	}
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
-		if (type.id() == LogicalTypeId::BLOB || !Value::StringIsValid(stats)) {
-			return Value(Blob::ToString(string_t(stats)));
-		}
-		return Value(stats);
-	case LogicalTypeId::DATE:
-		if (stats.size() != sizeof(int32_t)) {
-			throw InvalidInputException("Incorrect stats size for type DATE");
-		}
-		return Value::DATE(date_t(Load<int32_t>(stats_data)));
-	case LogicalTypeId::TIME: {
-		int64_t val;
-		if (stats.size() == sizeof(int32_t)) {
-			val = Load<int32_t>(stats_data);
-		} else if (stats.size() == sizeof(int64_t)) {
-			val = Load<int64_t>(stats_data);
-		} else {
-			throw InvalidInputException("Incorrect stats size for type TIME");
-		}
-		if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIME) {
-			// logical type
-			if (schema_ele.logicalType.TIME.unit.__isset.MILLIS) {
-				return Value::TIME(Time::FromTimeMs(val));
-			} else if (schema_ele.logicalType.TIME.unit.__isset.NANOS) {
-				return Value::TIME(Time::FromTimeNs(val));
-			} else if (schema_ele.logicalType.TIME.unit.__isset.MICROS) {
-				return Value::TIME(dtime_t(val));
-			} else {
-				throw InternalException("Time logicalType is set but unit is not defined");
-			}
-		}
-		if (schema_ele.converted_type == duckdb_parquet::ConvertedType::TIME_MILLIS) {
-			return Value::TIME(Time::FromTimeMs(val));
-		} else {
-			return Value::TIME(dtime_t(val));
-		}
-	}
-	case LogicalTypeId::TIME_TZ: {
-		int64_t val;
-		if (stats.size() == sizeof(int32_t)) {
-			val = Load<int32_t>(stats_data);
-		} else if (stats.size() == sizeof(int64_t)) {
-			val = Load<int64_t>(stats_data);
-		} else {
-			throw InvalidInputException("Incorrect stats size for type TIMETZ");
-		}
-		if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIME) {
-			// logical type
-			if (schema_ele.logicalType.TIME.unit.__isset.MILLIS) {
-				return Value::TIMETZ(ParquetIntToTimeMsTZ(NumericCast<int32_t>(val)));
-			} else if (schema_ele.logicalType.TIME.unit.__isset.MICROS) {
-				return Value::TIMETZ(ParquetIntToTimeTZ(val));
-			} else if (schema_ele.logicalType.TIME.unit.__isset.NANOS) {
-				return Value::TIMETZ(ParquetIntToTimeNsTZ(val));
-			} else {
-				throw InternalException("Time With Time Zone logicalType is set but unit is not defined");
-			}
-		}
-		return Value::TIMETZ(ParquetIntToTimeTZ(val));
-	}
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		timestamp_t timestamp_value;
-		if (schema_ele.type == Type::INT96) {
-			if (stats.size() != sizeof(Int96)) {
-				throw InvalidInputException("Incorrect stats size for type TIMESTAMP");
-			}
-			timestamp_value = ImpalaTimestampToTimestamp(Load<Int96>(stats_data));
-		} else {
-			D_ASSERT(schema_ele.type == Type::INT64);
-			if (stats.size() != sizeof(int64_t)) {
-				throw InvalidInputException("Incorrect stats size for type TIMESTAMP");
-			}
-			auto val = Load<int64_t>(stats_data);
-			if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIMESTAMP) {
-				// logical type
-				if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS) {
-					timestamp_value = Timestamp::FromEpochMs(val);
-				} else if (schema_ele.logicalType.TIMESTAMP.unit.__isset.NANOS) {
-					timestamp_value = Timestamp::FromEpochNanoSeconds(val);
-				} else if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MICROS) {
-					timestamp_value = timestamp_t(val);
-				} else {
-					throw InternalException("Timestamp logicalType is set but unit is not defined");
-				}
-			} else if (schema_ele.converted_type == duckdb_parquet::ConvertedType::TIMESTAMP_MILLIS) {
-				timestamp_value = Timestamp::FromEpochMs(val);
-			} else {
-				timestamp_value = timestamp_t(val);
-			}
-		}
-		if (type.id() == LogicalTypeId::TIMESTAMP_TZ) {
-			return Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_value));
-		}
-		return Value::TIMESTAMP(timestamp_value);
-	}
-	case LogicalTypeId::TIMESTAMP_NS: {
-		timestamp_ns_t timestamp_value;
-		if (schema_ele.type == Type::INT96) {
-			if (stats.size() != sizeof(Int96)) {
-				throw InvalidInputException("Incorrect stats size for type TIMESTAMP_NS");
-			}
-			timestamp_value = ImpalaTimestampToTimestampNS(Load<Int96>(stats_data));
-		} else {
-			D_ASSERT(schema_ele.type == Type::INT64);
-			if (stats.size() != sizeof(int64_t)) {
-				throw InvalidInputException("Incorrect stats size for type TIMESTAMP_NS");
-			}
-			auto val = Load<int64_t>(stats_data);
-			if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIMESTAMP) {
-				// logical type
-				if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS) {
-					timestamp_value = ParquetTimestampMsToTimestampNs(val);
-				} else if (schema_ele.logicalType.TIMESTAMP.unit.__isset.NANOS) {
-					timestamp_value = ParquetTimestampNsToTimestampNs(val);
-				} else if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MICROS) {
-					timestamp_value = ParquetTimestampUsToTimestampNs(val);
-				} else {
-					throw InternalException("Timestamp (NS) logicalType is set but unit is unknown");
-				}
-			} else if (schema_ele.converted_type == duckdb_parquet::ConvertedType::TIMESTAMP_MILLIS) {
-				timestamp_value = ParquetTimestampMsToTimestampNs(val);
-			} else {
-				timestamp_value = ParquetTimestampUsToTimestampNs(val);
-			}
-		}
-		return Value::TIMESTAMPNS(timestamp_value);
-	}
-	default:
-		throw InternalException("Unsupported type for stats %s", type.ToString());
-	}
-}
-
-unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(const ColumnReader &reader,
-                                                                             const vector<ColumnChunk> &columns) {
-
-	// Not supported types
-	if (reader.Type().id() == LogicalTypeId::ARRAY || reader.Type().id() == LogicalTypeId::MAP ||
-	    reader.Type().id() == LogicalTypeId::LIST) {
-		return nullptr;
-	}
-
-	unique_ptr<BaseStatistics> row_group_stats;
-
-	// Structs are handled differently (they dont have stats)
-	if (reader.Type().id() == LogicalTypeId::STRUCT) {
-		auto struct_stats = StructStats::CreateUnknown(reader.Type());
-		auto &struct_reader = reader.Cast<StructColumnReader>();
-		// Recurse into child readers
-		for (idx_t i = 0; i < struct_reader.child_readers.size(); i++) {
-			if (!struct_reader.child_readers[i]) {
-				continue;
-			}
-			auto &child_reader = *struct_reader.child_readers[i];
-			auto child_stats = ParquetStatisticsUtils::TransformColumnStatistics(child_reader, columns);
-			StructStats::SetChildStats(struct_stats, i, std::move(child_stats));
-		}
-		row_group_stats = struct_stats.ToUnique();
-
-		// null count is generic
-		if (row_group_stats) {
-			row_group_stats->Set(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES);
-		}
-		return row_group_stats;
-	}
-
-	// Otherwise, its a standard column with stats
-
-	auto &column_chunk = columns[reader.FileIdx()];
-	if (!column_chunk.__isset.meta_data || !column_chunk.meta_data.__isset.statistics) {
-		// no stats present for row group
-		return nullptr;
-	}
-	auto &parquet_stats = column_chunk.meta_data.statistics;
-
-	auto &type = reader.Type();
-	auto &s_ele = reader.Schema();
-
-	switch (type.id()) {
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::DECIMAL:
-		row_group_stats = CreateNumericStats(type, s_ele, parquet_stats);
-		break;
-	case LogicalTypeId::VARCHAR: {
-		auto string_stats = StringStats::CreateEmpty(type);
-		if (parquet_stats.__isset.min_value) {
-			StringColumnReader::VerifyString(parquet_stats.min_value.c_str(), parquet_stats.min_value.size(), true);
-			StringStats::Update(string_stats, parquet_stats.min_value);
-		} else if (parquet_stats.__isset.min) {
-			StringColumnReader::VerifyString(parquet_stats.min.c_str(), parquet_stats.min.size(), true);
-			StringStats::Update(string_stats, parquet_stats.min);
-		} else {
-			return nullptr;
-		}
-		if (parquet_stats.__isset.max_value) {
-			StringColumnReader::VerifyString(parquet_stats.max_value.c_str(), parquet_stats.max_value.size(), true);
-			StringStats::Update(string_stats, parquet_stats.max_value);
-		} else if (parquet_stats.__isset.max) {
-			StringColumnReader::VerifyString(parquet_stats.max.c_str(), parquet_stats.max.size(), true);
-			StringStats::Update(string_stats, parquet_stats.max);
-		} else {
-			return nullptr;
-		}
-		StringStats::SetContainsUnicode(string_stats);
-		StringStats::ResetMaxStringLength(string_stats);
-		row_group_stats = string_stats.ToUnique();
-		break;
-	}
-	default:
-		// no stats for you
-		break;
-	} // end of type switch
-
-	// null count is generic
-	if (row_group_stats) {
-		row_group_stats->Set(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES);
-		if (parquet_stats.__isset.null_count && parquet_stats.null_count == 0) {
-			row_group_stats->Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-		}
-	}
-	return row_group_stats;
-}
-
-static bool HasFilterConstants(const TableFilter &duckdb_filter) {
-	switch (duckdb_filter.filter_type) {
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = duckdb_filter.Cast<ConstantFilter>();
-		return (constant_filter.comparison_type == ExpressionType::COMPARE_EQUAL && !constant_filter.constant.IsNull());
-	}
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and_filter = duckdb_filter.Cast<ConjunctionAndFilter>();
-		bool child_has_constant = false;
-		for (auto &child_filter : conjunction_and_filter.child_filters) {
-			child_has_constant |= HasFilterConstants(*child_filter);
-		}
-		return child_has_constant;
-	}
-	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction_or_filter = duckdb_filter.Cast<ConjunctionOrFilter>();
-		bool child_has_constant = false;
-		for (auto &child_filter : conjunction_or_filter.child_filters) {
-			child_has_constant |= HasFilterConstants(*child_filter);
-		}
-		return child_has_constant;
-	}
-	default:
-		return false;
-	}
-}
-
-template <class T>
-uint64_t ValueXH64FixedWidth(const Value &constant) {
-	T val = constant.GetValue<T>();
-	return duckdb_zstd::XXH64(&val, sizeof(val), 0);
-}
-
-// TODO we can only this if the parquet representation of the type exactly matches the duckdb rep!
-// TODO TEST THIS!
-// TODO perhaps we can re-use some writer infra here
-static uint64_t ValueXXH64(const Value &constant) {
-	switch (constant.type().InternalType()) {
-	case PhysicalType::UINT8:
-		return ValueXH64FixedWidth<int32_t>(constant);
-	case PhysicalType::INT8:
-		return ValueXH64FixedWidth<int32_t>(constant);
-	case PhysicalType::UINT16:
-		return ValueXH64FixedWidth<int32_t>(constant);
-	case PhysicalType::INT16:
-		return ValueXH64FixedWidth<int32_t>(constant);
-	case PhysicalType::UINT32:
-		return ValueXH64FixedWidth<uint32_t>(constant);
-	case PhysicalType::INT32:
-		return ValueXH64FixedWidth<int32_t>(constant);
-	case PhysicalType::UINT64:
-		return ValueXH64FixedWidth<uint64_t>(constant);
-	case PhysicalType::INT64:
-		return ValueXH64FixedWidth<int64_t>(constant);
-	case PhysicalType::FLOAT:
-		return ValueXH64FixedWidth<float>(constant);
-	case PhysicalType::DOUBLE:
-		return ValueXH64FixedWidth<double>(constant);
-	case PhysicalType::VARCHAR: {
-		auto val = constant.GetValue<string>();
-		return duckdb_zstd::XXH64(val.c_str(), val.length(), 0);
-	}
-	default:
-		return 0;
-	}
-}
-
-static bool ApplyBloomFilter(const TableFilter &duckdb_filter, ParquetBloomFilter &bloom_filter) {
-	switch (duckdb_filter.filter_type) {
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = duckdb_filter.Cast<ConstantFilter>();
-		auto is_compare_equal = constant_filter.comparison_type == ExpressionType::COMPARE_EQUAL;
-		D_ASSERT(!constant_filter.constant.IsNull());
-		auto hash = ValueXXH64(constant_filter.constant);
-		return hash > 0 && !bloom_filter.FilterCheck(hash) && is_compare_equal;
-	}
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and_filter = duckdb_filter.Cast<ConjunctionAndFilter>();
-		bool any_children_true = false;
-		for (auto &child_filter : conjunction_and_filter.child_filters) {
-			any_children_true |= ApplyBloomFilter(*child_filter, bloom_filter);
-		}
-		return any_children_true;
-	}
-	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction_or_filter = duckdb_filter.Cast<ConjunctionOrFilter>();
-		bool all_children_true = true;
-		for (auto &child_filter : conjunction_or_filter.child_filters) {
-			all_children_true &= ApplyBloomFilter(*child_filter, bloom_filter);
-		}
-		return all_children_true;
-	}
-	default:
-		return false;
-	}
-}
-
-bool ParquetStatisticsUtils::BloomFilterSupported(const LogicalTypeId &type_id) {
-	switch (type_id) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool ParquetStatisticsUtils::BloomFilterExcludes(const TableFilter &duckdb_filter,
-                                                 const duckdb_parquet::ColumnMetaData &column_meta_data,
-                                                 TProtocol &file_proto, Allocator &allocator) {
-	if (!HasFilterConstants(duckdb_filter) || !column_meta_data.__isset.bloom_filter_offset ||
-	    column_meta_data.bloom_filter_offset <= 0) {
-		return false;
-	}
-	// TODO check length against file length!
-
-	auto &transport = reinterpret_cast<ThriftFileTransport &>(*file_proto.getTransport());
-	transport.SetLocation(column_meta_data.bloom_filter_offset);
-	if (column_meta_data.__isset.bloom_filter_length && column_meta_data.bloom_filter_length > 0) {
-		transport.Prefetch(column_meta_data.bloom_filter_offset, column_meta_data.bloom_filter_length);
-	}
-
-	duckdb_parquet::BloomFilterHeader filter_header;
-	// TODO the bloom filter could be encrypted, too, so need to double check that this is NOT the case
-	filter_header.read(&file_proto);
-	if (!filter_header.algorithm.__isset.BLOCK || !filter_header.compression.__isset.UNCOMPRESSED ||
-	    !filter_header.hash.__isset.XXHASH) {
-		return false;
-	}
-
-	auto new_buffer = make_uniq<ResizeableBuffer>(allocator, filter_header.numBytes);
-	transport.read(new_buffer->ptr, filter_header.numBytes);
-	ParquetBloomFilter bloom_filter(std::move(new_buffer));
-	return ApplyBloomFilter(duckdb_filter, bloom_filter);
-}
-
-ParquetBloomFilter::ParquetBloomFilter(idx_t num_entries, double bloom_filter_false_positive_ratio) {
-
-	// aim for hit ratio of 0.01%
-	// see http://tfk.mit.edu/pdf/bloom.pdf
-	double f = bloom_filter_false_positive_ratio;
-	double k = 8.0;
-	double n = LossyNumericCast<double>(num_entries);
-	double m = -k * n / std::log(1 - std::pow(f, 1 / k));
-	auto b = MaxValue<idx_t>(NextPowerOfTwo(LossyNumericCast<idx_t>(m / k)) / 32, 1);
-
-	D_ASSERT(b > 0 && IsPowerOfTwo(b));
-
-	data = make_uniq<ResizeableBuffer>(Allocator::DefaultAllocator(), sizeof(ParquetBloomBlock) * b);
-	data->zero();
-	block_count = data->len / sizeof(ParquetBloomBlock);
-	D_ASSERT(data->len % sizeof(ParquetBloomBlock) == 0);
-}
-
-ParquetBloomFilter::ParquetBloomFilter(unique_ptr<ResizeableBuffer> data_p) {
-	D_ASSERT(data_p->len % sizeof(ParquetBloomBlock) == 0);
-	data = std::move(data_p);
-	block_count = data->len / sizeof(ParquetBloomBlock);
-	D_ASSERT(data->len % sizeof(ParquetBloomBlock) == 0);
-}
-
-void ParquetBloomFilter::FilterInsert(uint64_t x) {
-	auto blocks = reinterpret_cast<ParquetBloomBlock *>(data->ptr);
-	uint64_t i = ((x >> 32) * block_count) >> 32;
-	auto &b = blocks[i];
-	ParquetBloomBlock::BlockInsert(b, x);
-}
-
-bool ParquetBloomFilter::FilterCheck(uint64_t x) {
-	auto blocks = reinterpret_cast<ParquetBloomBlock *>(data->ptr);
-	auto i = ((x >> 32) * block_count) >> 32;
-	return ParquetBloomBlock::BlockCheck(blocks[i], x);
-}
-
-// compiler optimizes this into a single instruction (popcnt)
-static uint8_t PopCnt64(uint64_t n) {
-	uint8_t c = 0;
-	for (; n; ++c) {
-		n &= n - 1;
-	}
-	return c;
-}
-
-double ParquetBloomFilter::OneRatio() {
-	auto bloom_ptr = reinterpret_cast<uint64_t *>(data->ptr);
-	idx_t one_count = 0;
-	for (idx_t b_idx = 0; b_idx < data->len / sizeof(uint64_t); ++b_idx) {
-		one_count += PopCnt64(bloom_ptr[b_idx]);
-	}
-	return LossyNumericCast<double>(one_count) / (LossyNumericCast<double>(data->len) * 8.0);
-}
-
-ResizeableBuffer *ParquetBloomFilter::Get() {
-	return data.get();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/parquet_timestamp.cpp b/src/duckdb/extension/parquet/parquet_timestamp.cpp
deleted file mode 100644
index 84c158f19..000000000
--- a/src/duckdb/extension/parquet/parquet_timestamp.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "parquet_timestamp.hpp"
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#endif
-
-namespace duckdb {
-
-// surely they are joking
-static constexpr int64_t JULIAN_TO_UNIX_EPOCH_DAYS = 2440588LL;
-static constexpr int64_t MILLISECONDS_PER_DAY = 86400000LL;
-static constexpr int64_t MICROSECONDS_PER_DAY = MILLISECONDS_PER_DAY * 1000LL;
-static constexpr int64_t NANOSECONDS_PER_MICRO = 1000LL;
-static constexpr int64_t NANOSECONDS_PER_DAY = MICROSECONDS_PER_DAY * 1000LL;
-
-static inline int64_t ImpalaTimestampToDays(const Int96 &impala_timestamp) {
-	return impala_timestamp.value[2] - JULIAN_TO_UNIX_EPOCH_DAYS;
-}
-
-static int64_t ImpalaTimestampToMicroseconds(const Int96 &impala_timestamp) {
-	int64_t days_since_epoch = ImpalaTimestampToDays(impala_timestamp);
-	auto nanoseconds = Load<int64_t>(const_data_ptr_cast(impala_timestamp.value));
-	auto microseconds = nanoseconds / NANOSECONDS_PER_MICRO;
-	return days_since_epoch * MICROSECONDS_PER_DAY + microseconds;
-}
-
-static int64_t ImpalaTimestampToNanoseconds(const Int96 &impala_timestamp) {
-	int64_t days_since_epoch = ImpalaTimestampToDays(impala_timestamp);
-	auto nanoseconds = Load<int64_t>(const_data_ptr_cast(impala_timestamp.value));
-	return days_since_epoch * NANOSECONDS_PER_DAY + nanoseconds;
-}
-
-timestamp_ns_t ImpalaTimestampToTimestampNS(const Int96 &raw_ts) {
-	timestamp_ns_t result;
-	result.value = ImpalaTimestampToNanoseconds(raw_ts);
-	return result;
-}
-
-timestamp_t ImpalaTimestampToTimestamp(const Int96 &raw_ts) {
-	auto impala_us = ImpalaTimestampToMicroseconds(raw_ts);
-	return Timestamp::FromEpochMicroSeconds(impala_us);
-}
-
-Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
-	int32_t hour, min, sec, msec;
-	Time::Convert(Timestamp::GetTime(ts), hour, min, sec, msec);
-	uint64_t ms_since_midnight = hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
-	auto days_since_epoch = Date::Epoch(Timestamp::GetDate(ts)) / int64_t(24 * 60 * 60);
-	// first two uint32 in Int96 are nanoseconds since midnights
-	// last uint32 is number of days since year 4713 BC ("Julian date")
-	Int96 impala_ts;
-	Store<uint64_t>(ms_since_midnight * 1000000, data_ptr_cast(impala_ts.value));
-	impala_ts.value[2] = days_since_epoch + JULIAN_TO_UNIX_EPOCH_DAYS;
-	return impala_ts;
-}
-
-timestamp_t ParquetTimestampMicrosToTimestamp(const int64_t &raw_ts) {
-	return Timestamp::FromEpochMicroSeconds(raw_ts);
-}
-
-timestamp_t ParquetTimestampMsToTimestamp(const int64_t &raw_ts) {
-	timestamp_t input(raw_ts);
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::FromEpochMs(raw_ts);
-}
-
-timestamp_ns_t ParquetTimestampMsToTimestampNs(const int64_t &raw_ms) {
-	timestamp_ns_t input;
-	input.value = raw_ms;
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::TimestampNsFromEpochMillis(raw_ms);
-}
-
-timestamp_ns_t ParquetTimestampUsToTimestampNs(const int64_t &raw_us) {
-	timestamp_ns_t input;
-	input.value = raw_us;
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::TimestampNsFromEpochMicros(raw_us);
-}
-
-timestamp_ns_t ParquetTimestampNsToTimestampNs(const int64_t &raw_ns) {
-	timestamp_ns_t result;
-	result.value = raw_ns;
-	return result;
-}
-
-timestamp_t ParquetTimestampNsToTimestamp(const int64_t &raw_ts) {
-	timestamp_t input(raw_ts);
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::FromEpochNanoSeconds(raw_ts);
-}
-
-date_t ParquetIntToDate(const int32_t &raw_date) {
-	return date_t(raw_date);
-}
-
-template <typename T>
-static T ParquetWrapTime(const T &raw, const T day) {
-	// Special case 24:00:00
-	if (raw == day) {
-		return raw;
-	}
-	const auto modulus = raw % day;
-	return modulus + (modulus < 0) * day;
-}
-
-dtime_t ParquetIntToTimeMs(const int32_t &raw_millis) {
-	return Time::FromTimeMs(raw_millis);
-}
-
-dtime_t ParquetIntToTime(const int64_t &raw_micros) {
-	return dtime_t(raw_micros);
-}
-
-dtime_t ParquetIntToTimeNs(const int64_t &raw_nanos) {
-	return Time::FromTimeNs(raw_nanos);
-}
-
-dtime_tz_t ParquetIntToTimeMsTZ(const int32_t &raw_millis) {
-	const int32_t MSECS_PER_DAY = Interval::MSECS_PER_SEC * Interval::SECS_PER_DAY;
-	const auto millis = ParquetWrapTime(raw_millis, MSECS_PER_DAY);
-	return dtime_tz_t(Time::FromTimeMs(millis), 0);
-}
-
-dtime_tz_t ParquetIntToTimeTZ(const int64_t &raw_micros) {
-	const auto micros = ParquetWrapTime(raw_micros, Interval::MICROS_PER_DAY);
-	return dtime_tz_t(dtime_t(micros), 0);
-}
-
-dtime_tz_t ParquetIntToTimeNsTZ(const int64_t &raw_nanos) {
-	const auto nanos = ParquetWrapTime(raw_nanos, Interval::NANOS_PER_DAY);
-	return dtime_tz_t(Time::FromTimeNs(nanos), 0);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/parquet_writer.cpp b/src/duckdb/extension/parquet/parquet_writer.cpp
deleted file mode 100644
index 883f03069..000000000
--- a/src/duckdb/extension/parquet/parquet_writer.cpp
+++ /dev/null
@@ -1,609 +0,0 @@
-#include "parquet_writer.hpp"
-
-#include "duckdb.hpp"
-#include "mbedtls_wrapper.hpp"
-#include "parquet_crypto.hpp"
-#include "parquet_timestamp.hpp"
-#include "resizable_buffer.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/connection.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#endif
-
-namespace duckdb {
-
-using namespace duckdb_apache::thrift;            // NOLINT
-using namespace duckdb_apache::thrift::protocol;  // NOLINT
-using namespace duckdb_apache::thrift::transport; // NOLINT
-
-using duckdb_parquet::CompressionCodec;
-using duckdb_parquet::ConvertedType;
-using duckdb_parquet::Encoding;
-using duckdb_parquet::FieldRepetitionType;
-using duckdb_parquet::FileCryptoMetaData;
-using duckdb_parquet::FileMetaData;
-using duckdb_parquet::PageHeader;
-using duckdb_parquet::PageType;
-using ParquetRowGroup = duckdb_parquet::RowGroup;
-using duckdb_parquet::Type;
-
-ChildFieldIDs::ChildFieldIDs() : ids(make_uniq<case_insensitive_map_t<FieldID>>()) {
-}
-
-ChildFieldIDs ChildFieldIDs::Copy() const {
-	ChildFieldIDs result;
-	for (const auto &id : *ids) {
-		result.ids->emplace(id.first, id.second.Copy());
-	}
-	return result;
-}
-
-FieldID::FieldID() : set(false) {
-}
-
-FieldID::FieldID(int32_t field_id_p) : set(true), field_id(field_id_p) {
-}
-
-FieldID FieldID::Copy() const {
-	auto result = set ? FieldID(field_id) : FieldID();
-	result.child_field_ids = child_field_ids.Copy();
-	return result;
-}
-
-class MyTransport : public TTransport {
-public:
-	explicit MyTransport(WriteStream &serializer) : serializer(serializer) {
-	}
-
-	bool isOpen() const override {
-		return true;
-	}
-
-	void open() override {
-	}
-
-	void close() override {
-	}
-
-	void write_virt(const uint8_t *buf, uint32_t len) override {
-		serializer.WriteData(const_data_ptr_cast(buf), len);
-	}
-
-private:
-	WriteStream &serializer;
-};
-
-bool ParquetWriter::TryGetParquetType(const LogicalType &duckdb_type, optional_ptr<Type::type> parquet_type_ptr) {
-	Type::type parquet_type;
-	switch (duckdb_type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		parquet_type = Type::BOOLEAN;
-		break;
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::DATE:
-		parquet_type = Type::INT32;
-		break;
-	case LogicalTypeId::BIGINT:
-		parquet_type = Type::INT64;
-		break;
-	case LogicalTypeId::FLOAT:
-		parquet_type = Type::FLOAT;
-		break;
-	case LogicalTypeId::DOUBLE:
-		parquet_type = Type::DOUBLE;
-		break;
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::HUGEINT:
-		parquet_type = Type::DOUBLE;
-		break;
-	case LogicalTypeId::ENUM:
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
-		parquet_type = Type::BYTE_ARRAY;
-		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC:
-		parquet_type = Type::INT64;
-		break;
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-		parquet_type = Type::INT32;
-		break;
-	case LogicalTypeId::UBIGINT:
-		parquet_type = Type::INT64;
-		break;
-	case LogicalTypeId::INTERVAL:
-	case LogicalTypeId::UUID:
-		parquet_type = Type::FIXED_LEN_BYTE_ARRAY;
-		break;
-	case LogicalTypeId::DECIMAL:
-		switch (duckdb_type.InternalType()) {
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-			parquet_type = Type::INT32;
-			break;
-		case PhysicalType::INT64:
-			parquet_type = Type::INT64;
-			break;
-		case PhysicalType::INT128:
-			parquet_type = Type::FIXED_LEN_BYTE_ARRAY;
-			break;
-		default:
-			throw InternalException("Unsupported internal decimal type");
-		}
-		break;
-	default:
-		// Anything that is not supported
-		return false;
-	}
-	if (parquet_type_ptr) {
-		*parquet_type_ptr = parquet_type;
-	}
-	return true;
-}
-
-Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type) {
-	Type::type result;
-	if (TryGetParquetType(duckdb_type, &result)) {
-		return result;
-	}
-	throw NotImplementedException("Unimplemented type for Parquet \"%s\"", duckdb_type.ToString());
-}
-
-void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type, duckdb_parquet::SchemaElement &schema_ele) {
-	if (duckdb_type.IsJSONType()) {
-		schema_ele.converted_type = ConvertedType::JSON;
-		schema_ele.__isset.converted_type = true;
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__set_JSON(duckdb_parquet::JsonType());
-		return;
-	}
-	switch (duckdb_type.id()) {
-	case LogicalTypeId::TINYINT:
-		schema_ele.converted_type = ConvertedType::INT_8;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::SMALLINT:
-		schema_ele.converted_type = ConvertedType::INT_16;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::INTEGER:
-		schema_ele.converted_type = ConvertedType::INT_32;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::BIGINT:
-		schema_ele.converted_type = ConvertedType::INT_64;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::UTINYINT:
-		schema_ele.converted_type = ConvertedType::UINT_8;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::USMALLINT:
-		schema_ele.converted_type = ConvertedType::UINT_16;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::UINTEGER:
-		schema_ele.converted_type = ConvertedType::UINT_32;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::UBIGINT:
-		schema_ele.converted_type = ConvertedType::UINT_64;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::DATE:
-		schema_ele.converted_type = ConvertedType::DATE;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIME:
-		schema_ele.converted_type = ConvertedType::TIME_MICROS;
-		schema_ele.__isset.converted_type = true;
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__isset.TIME = true;
-		schema_ele.logicalType.TIME.isAdjustedToUTC = (duckdb_type.id() == LogicalTypeId::TIME_TZ);
-		schema_ele.logicalType.TIME.unit.__isset.MICROS = true;
-		break;
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-		schema_ele.converted_type = ConvertedType::TIMESTAMP_MICROS;
-		schema_ele.__isset.converted_type = true;
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__isset.TIMESTAMP = true;
-		schema_ele.logicalType.TIMESTAMP.isAdjustedToUTC = (duckdb_type.id() == LogicalTypeId::TIMESTAMP_TZ);
-		schema_ele.logicalType.TIMESTAMP.unit.__isset.MICROS = true;
-		break;
-	case LogicalTypeId::TIMESTAMP_NS:
-		schema_ele.__isset.converted_type = false;
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__isset.TIMESTAMP = true;
-		schema_ele.logicalType.TIMESTAMP.isAdjustedToUTC = false;
-		schema_ele.logicalType.TIMESTAMP.unit.__isset.NANOS = true;
-		break;
-	case LogicalTypeId::TIMESTAMP_MS:
-		schema_ele.converted_type = ConvertedType::TIMESTAMP_MILLIS;
-		schema_ele.__isset.converted_type = true;
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__isset.TIMESTAMP = true;
-		schema_ele.logicalType.TIMESTAMP.isAdjustedToUTC = false;
-		schema_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS = true;
-		break;
-	case LogicalTypeId::ENUM:
-	case LogicalTypeId::VARCHAR:
-		schema_ele.converted_type = ConvertedType::UTF8;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::INTERVAL:
-		schema_ele.type_length = 12;
-		schema_ele.converted_type = ConvertedType::INTERVAL;
-		schema_ele.__isset.type_length = true;
-		schema_ele.__isset.converted_type = true;
-		break;
-	case LogicalTypeId::UUID:
-		schema_ele.type_length = 16;
-		schema_ele.__isset.type_length = true;
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__isset.UUID = true;
-		break;
-	case LogicalTypeId::DECIMAL:
-		schema_ele.converted_type = ConvertedType::DECIMAL;
-		schema_ele.precision = DecimalType::GetWidth(duckdb_type);
-		schema_ele.scale = DecimalType::GetScale(duckdb_type);
-		schema_ele.__isset.converted_type = true;
-		schema_ele.__isset.precision = true;
-		schema_ele.__isset.scale = true;
-		if (duckdb_type.InternalType() == PhysicalType::INT128) {
-			schema_ele.type_length = 16;
-			schema_ele.__isset.type_length = true;
-		}
-		schema_ele.__isset.logicalType = true;
-		schema_ele.logicalType.__isset.DECIMAL = true;
-		schema_ele.logicalType.DECIMAL.precision = schema_ele.precision;
-		schema_ele.logicalType.DECIMAL.scale = schema_ele.scale;
-		break;
-	default:
-		break;
-	}
-}
-
-uint32_t ParquetWriter::Write(const duckdb_apache::thrift::TBase &object) {
-	if (encryption_config) {
-		return ParquetCrypto::Write(object, *protocol, encryption_config->GetFooterKey(), *encryption_util);
-	} else {
-		return object.write(protocol.get());
-	}
-}
-
-uint32_t ParquetWriter::WriteData(const const_data_ptr_t buffer, const uint32_t buffer_size) {
-	if (encryption_config) {
-		return ParquetCrypto::WriteData(*protocol, buffer, buffer_size, encryption_config->GetFooterKey(),
-		                                *encryption_util);
-	} else {
-		protocol->getTransport()->write(buffer, buffer_size);
-		return buffer_size;
-	}
-}
-
-void VerifyUniqueNames(const vector<string> &names) {
-#ifdef DEBUG
-	unordered_set<string> name_set;
-	name_set.reserve(names.size());
-	for (auto &column : names) {
-		auto res = name_set.insert(column);
-		D_ASSERT(res.second == true);
-	}
-	// If there would be duplicates, these sizes would differ
-	D_ASSERT(name_set.size() == names.size());
-#endif
-}
-
-ParquetWriter::ParquetWriter(ClientContext &context, FileSystem &fs, string file_name_p, vector<LogicalType> types_p,
-                             vector<string> names_p, CompressionCodec::type codec, ChildFieldIDs field_ids_p,
-                             const vector<pair<string, string>> &kv_metadata,
-                             shared_ptr<ParquetEncryptionConfig> encryption_config_p, idx_t dictionary_size_limit_p,
-                             double bloom_filter_false_positive_ratio_p, int64_t compression_level_p,
-                             bool debug_use_openssl_p)
-    : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec),
-      field_ids(std::move(field_ids_p)), encryption_config(std::move(encryption_config_p)),
-      dictionary_size_limit(dictionary_size_limit_p),
-      bloom_filter_false_positive_ratio(bloom_filter_false_positive_ratio_p), compression_level(compression_level_p),
-      debug_use_openssl(debug_use_openssl_p) {
-
-	// initialize the file writer
-	writer = make_uniq<BufferedFileWriter>(fs, file_name.c_str(),
-	                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
-	if (encryption_config) {
-		auto &config = DBConfig::GetConfig(context);
-		if (config.encryption_util && debug_use_openssl) {
-			// Use OpenSSL
-			encryption_util = config.encryption_util;
-		} else {
-			encryption_util = make_shared_ptr<duckdb_mbedtls::MbedTlsWrapper::AESGCMStateMBEDTLSFactory>();
-		}
-		// encrypted parquet files start with the string "PARE"
-		writer->WriteData(const_data_ptr_cast("PARE"), 4);
-		// we only support this one for now, not "AES_GCM_CTR_V1"
-		file_meta_data.encryption_algorithm.__isset.AES_GCM_V1 = true;
-	} else {
-		// parquet files start with the string "PAR1"
-		writer->WriteData(const_data_ptr_cast("PAR1"), 4);
-	}
-	TCompactProtocolFactoryT<MyTransport> tproto_factory;
-	protocol = tproto_factory.getProtocol(std::make_shared<MyTransport>(*writer));
-
-	file_meta_data.num_rows = 0;
-	file_meta_data.version = 1;
-
-	file_meta_data.__isset.created_by = true;
-	file_meta_data.created_by =
-	    StringUtil::Format("DuckDB version %s (build %s)", DuckDB::LibraryVersion(), DuckDB::SourceID());
-
-	file_meta_data.schema.resize(1);
-
-	for (auto &kv_pair : kv_metadata) {
-		duckdb_parquet::KeyValue kv;
-		kv.__set_key(kv_pair.first);
-		kv.__set_value(kv_pair.second);
-		file_meta_data.key_value_metadata.push_back(kv);
-		file_meta_data.__isset.key_value_metadata = true;
-	}
-
-	// populate root schema object
-	file_meta_data.schema[0].name = "duckdb_schema";
-	file_meta_data.schema[0].num_children = NumericCast<int32_t>(sql_types.size());
-	file_meta_data.schema[0].__isset.num_children = true;
-	file_meta_data.schema[0].repetition_type = duckdb_parquet::FieldRepetitionType::REQUIRED;
-	file_meta_data.schema[0].__isset.repetition_type = true;
-
-	auto &unique_names = column_names;
-	VerifyUniqueNames(unique_names);
-
-	vector<string> schema_path;
-	for (idx_t i = 0; i < sql_types.size(); i++) {
-		column_writers.push_back(ColumnWriter::CreateWriterRecursive(
-		    context, file_meta_data.schema, *this, sql_types[i], unique_names[i], schema_path, &field_ids));
-	}
-}
-
-void ParquetWriter::PrepareRowGroup(ColumnDataCollection &buffer, PreparedRowGroup &result) {
-	// We write 8 columns at a time so that iterating over ColumnDataCollection is more efficient
-	static constexpr idx_t COLUMNS_PER_PASS = 8;
-
-	// We want these to be in-memory/hybrid so we don't have to copy over strings to the dictionary
-	D_ASSERT(buffer.GetAllocatorType() == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR ||
-	         buffer.GetAllocatorType() == ColumnDataAllocatorType::HYBRID);
-
-	// set up a new row group for this chunk collection
-	auto &row_group = result.row_group;
-	row_group.num_rows = NumericCast<int64_t>(buffer.Count());
-	row_group.total_byte_size = NumericCast<int64_t>(buffer.SizeInBytes());
-	row_group.__isset.file_offset = true;
-
-	auto &states = result.states;
-	// iterate over each of the columns of the chunk collection and write them
-	D_ASSERT(buffer.ColumnCount() == column_writers.size());
-	for (idx_t col_idx = 0; col_idx < buffer.ColumnCount(); col_idx += COLUMNS_PER_PASS) {
-		const auto next = MinValue<idx_t>(buffer.ColumnCount() - col_idx, COLUMNS_PER_PASS);
-		vector<column_t> column_ids;
-		vector<reference<ColumnWriter>> col_writers;
-		vector<unique_ptr<ColumnWriterState>> write_states;
-		for (idx_t i = 0; i < next; i++) {
-			column_ids.emplace_back(col_idx + i);
-			col_writers.emplace_back(*column_writers[column_ids.back()]);
-			write_states.emplace_back(col_writers.back().get().InitializeWriteState(row_group));
-		}
-
-		for (auto &chunk : buffer.Chunks({column_ids})) {
-			for (idx_t i = 0; i < next; i++) {
-				if (col_writers[i].get().HasAnalyze()) {
-					col_writers[i].get().Analyze(*write_states[i], nullptr, chunk.data[i], chunk.size());
-				}
-			}
-		}
-
-		for (idx_t i = 0; i < next; i++) {
-			if (col_writers[i].get().HasAnalyze()) {
-				col_writers[i].get().FinalizeAnalyze(*write_states[i]);
-			}
-		}
-
-		// Reserving these once at the start really pays off
-		for (auto &write_state : write_states) {
-			write_state->definition_levels.reserve(buffer.Count());
-		}
-
-		for (auto &chunk : buffer.Chunks({column_ids})) {
-			for (idx_t i = 0; i < next; i++) {
-				col_writers[i].get().Prepare(*write_states[i], nullptr, chunk.data[i], chunk.size());
-			}
-		}
-
-		for (idx_t i = 0; i < next; i++) {
-			col_writers[i].get().BeginWrite(*write_states[i]);
-		}
-
-		for (auto &chunk : buffer.Chunks({column_ids})) {
-			for (idx_t i = 0; i < next; i++) {
-				col_writers[i].get().Write(*write_states[i], chunk.data[i], chunk.size());
-			}
-		}
-
-		for (auto &write_state : write_states) {
-			states.push_back(std::move(write_state));
-		}
-	}
-	result.heaps = buffer.GetHeapReferences();
-}
-
-// Validation code adapted from Impala
-static void ValidateOffsetInFile(const string &filename, idx_t col_idx, idx_t file_length, idx_t offset,
-                                 const string &offset_name) {
-	if (offset >= file_length) {
-		throw IOException("File '%s': metadata is corrupt. Column %d has invalid "
-		                  "%s (offset=%llu file_size=%llu).",
-		                  filename, col_idx, offset_name, offset, file_length);
-	}
-}
-
-static void ValidateColumnOffsets(const string &filename, idx_t file_length, const ParquetRowGroup &row_group) {
-	for (idx_t i = 0; i < row_group.columns.size(); ++i) {
-		const auto &col_chunk = row_group.columns[i];
-		ValidateOffsetInFile(filename, i, file_length, col_chunk.meta_data.data_page_offset, "data page offset");
-		auto col_start = NumericCast<idx_t>(col_chunk.meta_data.data_page_offset);
-		// The file format requires that if a dictionary page exists, it be before data pages.
-		if (col_chunk.meta_data.__isset.dictionary_page_offset) {
-			ValidateOffsetInFile(filename, i, file_length, col_chunk.meta_data.dictionary_page_offset,
-			                     "dictionary page offset");
-			if (NumericCast<idx_t>(col_chunk.meta_data.dictionary_page_offset) >= col_start) {
-				throw IOException("Parquet file '%s': metadata is corrupt. Dictionary "
-				                  "page (offset=%llu) must come before any data pages (offset=%llu).",
-				                  filename, col_chunk.meta_data.dictionary_page_offset, col_start);
-			}
-			col_start = col_chunk.meta_data.dictionary_page_offset;
-		}
-		auto col_len = NumericCast<idx_t>(col_chunk.meta_data.total_compressed_size);
-		auto col_end = col_start + col_len;
-		if (col_end <= 0 || col_end > file_length) {
-			throw IOException("Parquet file '%s': metadata is corrupt. Column %llu has "
-			                  "invalid column offsets (offset=%llu, size=%llu, file_size=%llu).",
-			                  filename, i, col_start, col_len, file_length);
-		}
-	}
-}
-
-void ParquetWriter::FlushRowGroup(PreparedRowGroup &prepared) {
-	lock_guard<mutex> glock(lock);
-	auto &row_group = prepared.row_group;
-	auto &states = prepared.states;
-	if (states.empty()) {
-		throw InternalException("Attempting to flush a row group with no rows");
-	}
-	row_group.file_offset = NumericCast<int64_t>(writer->GetTotalWritten());
-	for (idx_t col_idx = 0; col_idx < states.size(); col_idx++) {
-		const auto &col_writer = column_writers[col_idx];
-		auto write_state = std::move(states[col_idx]);
-		col_writer->FinalizeWrite(*write_state);
-	}
-	// let's make sure all offsets are ay-okay
-	ValidateColumnOffsets(file_name, writer->GetTotalWritten(), row_group);
-
-	// append the row group to the file meta data
-	file_meta_data.row_groups.push_back(row_group);
-	file_meta_data.num_rows += row_group.num_rows;
-
-	prepared.heaps.clear();
-}
-
-void ParquetWriter::Flush(ColumnDataCollection &buffer) {
-	if (buffer.Count() == 0) {
-		return;
-	}
-
-	PreparedRowGroup prepared_row_group;
-	PrepareRowGroup(buffer, prepared_row_group);
-	buffer.Reset();
-
-	FlushRowGroup(prepared_row_group);
-}
-
-void ParquetWriter::Finalize() {
-
-	// dump the bloom filters right before footer, not if stuff is encrypted
-
-	for (auto &bloom_filter_entry : bloom_filters) {
-		D_ASSERT(!encryption_config);
-		// write nonsense bloom filter header
-		duckdb_parquet::BloomFilterHeader filter_header;
-		auto bloom_filter_bytes = bloom_filter_entry.bloom_filter->Get();
-		filter_header.numBytes = NumericCast<int32_t>(bloom_filter_bytes->len);
-		filter_header.algorithm.__set_BLOCK(duckdb_parquet::SplitBlockAlgorithm());
-		filter_header.compression.__set_UNCOMPRESSED(duckdb_parquet::Uncompressed());
-		filter_header.hash.__set_XXHASH(duckdb_parquet::XxHash());
-
-		// set metadata flags
-		auto &column_chunk =
-		    file_meta_data.row_groups[bloom_filter_entry.row_group_idx].columns[bloom_filter_entry.column_idx];
-
-		column_chunk.meta_data.__isset.bloom_filter_offset = true;
-		column_chunk.meta_data.bloom_filter_offset = NumericCast<int64_t>(writer->GetTotalWritten());
-
-		auto bloom_filter_header_size = Write(filter_header);
-		// write actual data
-		WriteData(bloom_filter_bytes->ptr, bloom_filter_bytes->len);
-
-		column_chunk.meta_data.__isset.bloom_filter_length = true;
-		column_chunk.meta_data.bloom_filter_length =
-		    NumericCast<int32_t>(bloom_filter_header_size + bloom_filter_bytes->len);
-	}
-
-	const auto metadata_start_offset = writer->GetTotalWritten();
-	if (encryption_config) {
-		// Crypto metadata is written unencrypted
-		FileCryptoMetaData crypto_metadata;
-		duckdb_parquet::AesGcmV1 aes_gcm_v1;
-		duckdb_parquet::EncryptionAlgorithm alg;
-		alg.__set_AES_GCM_V1(aes_gcm_v1);
-		crypto_metadata.__set_encryption_algorithm(alg);
-		crypto_metadata.write(protocol.get());
-	}
-
-	// Add geoparquet metadata to the file metadata
-	if (geoparquet_data) {
-		geoparquet_data->Write(file_meta_data);
-	}
-
-	Write(file_meta_data);
-
-	writer->Write<uint32_t>(writer->GetTotalWritten() - metadata_start_offset);
-
-	if (encryption_config) {
-		// encrypted parquet files also end with the string "PARE"
-		writer->WriteData(const_data_ptr_cast("PARE"), 4);
-	} else {
-		// parquet files also end with the string "PAR1"
-		writer->WriteData(const_data_ptr_cast("PAR1"), 4);
-	}
-
-	// flush to disk
-	writer->Close();
-	writer.reset();
-}
-
-GeoParquetFileMetadata &ParquetWriter::GetGeoParquetData() {
-	if (!geoparquet_data) {
-		geoparquet_data = make_uniq<GeoParquetFileMetadata>();
-	}
-	return *geoparquet_data;
-}
-
-void ParquetWriter::BufferBloomFilter(idx_t col_idx, unique_ptr<ParquetBloomFilter> bloom_filter) {
-	if (encryption_config) {
-		return;
-	}
-	ParquetBloomFilterEntry new_entry;
-	new_entry.bloom_filter = std::move(bloom_filter);
-	new_entry.column_idx = col_idx;
-	new_entry.row_group_idx = file_meta_data.row_groups.size();
-	bloom_filters.push_back(std::move(new_entry));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/serialize_parquet.cpp b/src/duckdb/extension/parquet/serialize_parquet.cpp
deleted file mode 100644
index bcb334a45..000000000
--- a/src/duckdb/extension/parquet/serialize_parquet.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "parquet_reader.hpp"
-#include "parquet_crypto.hpp"
-#include "parquet_writer.hpp"
-
-namespace duckdb {
-
-void ChildFieldIDs::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<FieldID>>(100, "ids", ids.operator*());
-}
-
-ChildFieldIDs ChildFieldIDs::Deserialize(Deserializer &deserializer) {
-	ChildFieldIDs result;
-	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<FieldID>>(100, "ids", result.ids.operator*());
-	return result;
-}
-
-void FieldID::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<bool>(100, "set", set);
-	serializer.WritePropertyWithDefault<int32_t>(101, "field_id", field_id);
-	serializer.WriteProperty<ChildFieldIDs>(102, "child_field_ids", child_field_ids);
-}
-
-FieldID FieldID::Deserialize(Deserializer &deserializer) {
-	FieldID result;
-	deserializer.ReadPropertyWithDefault<bool>(100, "set", result.set);
-	deserializer.ReadPropertyWithDefault<int32_t>(101, "field_id", result.field_id);
-	deserializer.ReadProperty<ChildFieldIDs>(102, "child_field_ids", result.child_field_ids);
-	return result;
-}
-
-void ParquetColumnDefinition::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<int32_t>(100, "field_id", field_id);
-	serializer.WritePropertyWithDefault<string>(101, "name", name);
-	serializer.WriteProperty<LogicalType>(103, "type", type);
-	serializer.WriteProperty<Value>(104, "default_value", default_value);
-}
-
-ParquetColumnDefinition ParquetColumnDefinition::Deserialize(Deserializer &deserializer) {
-	ParquetColumnDefinition result;
-	deserializer.ReadPropertyWithDefault<int32_t>(100, "field_id", result.field_id);
-	deserializer.ReadPropertyWithDefault<string>(101, "name", result.name);
-	deserializer.ReadProperty<LogicalType>(103, "type", result.type);
-	deserializer.ReadProperty<Value>(104, "default_value", result.default_value);
-	return result;
-}
-
-void ParquetEncryptionConfig::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(100, "footer_key", footer_key);
-	serializer.WritePropertyWithDefault<unordered_map<string, string>>(101, "column_keys", column_keys);
-}
-
-shared_ptr<ParquetEncryptionConfig> ParquetEncryptionConfig::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<ParquetEncryptionConfig>(new ParquetEncryptionConfig(deserializer.Get<ClientContext &>()));
-	deserializer.ReadPropertyWithDefault<string>(100, "footer_key", result->footer_key);
-	deserializer.ReadPropertyWithDefault<unordered_map<string, string>>(101, "column_keys", result->column_keys);
-	return result;
-}
-
-void ParquetOptions::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<bool>(100, "binary_as_string", binary_as_string);
-	serializer.WritePropertyWithDefault<bool>(101, "file_row_number", file_row_number);
-	serializer.WriteProperty<MultiFileReaderOptions>(102, "file_options", file_options);
-	serializer.WritePropertyWithDefault<vector<ParquetColumnDefinition>>(103, "schema", schema);
-	serializer.WritePropertyWithDefault<shared_ptr<ParquetEncryptionConfig>>(104, "encryption_config", encryption_config, nullptr);
-	serializer.WritePropertyWithDefault<bool>(105, "debug_use_openssl", debug_use_openssl, true);
-	serializer.WritePropertyWithDefault<idx_t>(106, "explicit_cardinality", explicit_cardinality, 0);
-}
-
-ParquetOptions ParquetOptions::Deserialize(Deserializer &deserializer) {
-	ParquetOptions result;
-	deserializer.ReadPropertyWithDefault<bool>(100, "binary_as_string", result.binary_as_string);
-	deserializer.ReadPropertyWithDefault<bool>(101, "file_row_number", result.file_row_number);
-	deserializer.ReadProperty<MultiFileReaderOptions>(102, "file_options", result.file_options);
-	deserializer.ReadPropertyWithDefault<vector<ParquetColumnDefinition>>(103, "schema", result.schema);
-	deserializer.ReadPropertyWithExplicitDefault<shared_ptr<ParquetEncryptionConfig>>(104, "encryption_config", result.encryption_config, nullptr);
-	deserializer.ReadPropertyWithExplicitDefault<bool>(105, "debug_use_openssl", result.debug_use_openssl, true);
-	deserializer.ReadPropertyWithExplicitDefault<idx_t>(106, "explicit_cardinality", result.explicit_cardinality, 0);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/extension/parquet/zstd_file_system.cpp b/src/duckdb/extension/parquet/zstd_file_system.cpp
deleted file mode 100644
index 7204f3607..000000000
--- a/src/duckdb/extension/parquet/zstd_file_system.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-#include "zstd_file_system.hpp"
-
-#include "zstd.h"
-
-namespace duckdb {
-
-struct ZstdStreamWrapper : public StreamWrapper {
-	~ZstdStreamWrapper() override;
-
-	CompressedFile *file = nullptr;
-	duckdb_zstd::ZSTD_DStream *zstd_stream_ptr = nullptr;
-	duckdb_zstd::ZSTD_CStream *zstd_compress_ptr = nullptr;
-	bool writing = false;
-
-public:
-	void Initialize(CompressedFile &file, bool write) override;
-	bool Read(StreamData &stream_data) override;
-	void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer, int64_t nr_bytes) override;
-
-	void Close() override;
-
-	void FlushStream();
-};
-
-ZstdStreamWrapper::~ZstdStreamWrapper() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	try {
-		Close();
-	} catch (...) { // NOLINT: swallow exceptions in destructor
-	}
-}
-
-void ZstdStreamWrapper::Initialize(CompressedFile &file, bool write) {
-	Close();
-	this->file = &file;
-	this->writing = write;
-	if (write) {
-		zstd_compress_ptr = duckdb_zstd::ZSTD_createCStream();
-	} else {
-		zstd_stream_ptr = duckdb_zstd::ZSTD_createDStream();
-	}
-}
-
-bool ZstdStreamWrapper::Read(StreamData &sd) {
-	D_ASSERT(!writing);
-
-	duckdb_zstd::ZSTD_inBuffer in_buffer;
-	duckdb_zstd::ZSTD_outBuffer out_buffer;
-
-	in_buffer.src = sd.in_buff_start;
-	in_buffer.size = sd.in_buff_end - sd.in_buff_start;
-	in_buffer.pos = 0;
-
-	out_buffer.dst = sd.out_buff_start;
-	out_buffer.size = sd.out_buf_size;
-	out_buffer.pos = 0;
-
-	auto res = duckdb_zstd::ZSTD_decompressStream(zstd_stream_ptr, &out_buffer, &in_buffer);
-	if (duckdb_zstd::ZSTD_isError(res)) {
-		throw IOException(duckdb_zstd::ZSTD_getErrorName(res));
-	}
-
-	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;  // NOLINT
-	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;   // NOLINT
-	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos; // NOLINT
-	return false;
-}
-
-void ZstdStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t uncompressed_data,
-                              int64_t uncompressed_size) {
-	D_ASSERT(writing);
-
-	auto remaining = uncompressed_size;
-	while (remaining > 0) {
-		D_ASSERT(sd.out_buff.get() + sd.out_buf_size > sd.out_buff_start);
-		idx_t output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
-
-		duckdb_zstd::ZSTD_inBuffer in_buffer;
-		duckdb_zstd::ZSTD_outBuffer out_buffer;
-
-		in_buffer.src = uncompressed_data;
-		in_buffer.size = remaining;
-		in_buffer.pos = 0;
-
-		out_buffer.dst = sd.out_buff_start;
-		out_buffer.size = output_remaining;
-		out_buffer.pos = 0;
-		auto res =
-		    duckdb_zstd::ZSTD_compressStream2(zstd_compress_ptr, &out_buffer, &in_buffer, duckdb_zstd::ZSTD_e_continue);
-		if (duckdb_zstd::ZSTD_isError(res)) {
-			throw IOException(duckdb_zstd::ZSTD_getErrorName(res));
-		}
-		idx_t input_consumed = in_buffer.pos;
-		idx_t written_to_output = out_buffer.pos;
-		sd.out_buff_start += written_to_output;
-		if (sd.out_buff_start == sd.out_buff.get() + sd.out_buf_size) {
-			// no more output buffer available: flush
-			file.child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
-			sd.out_buff_start = sd.out_buff.get();
-		}
-		uncompressed_data += input_consumed;
-		remaining -= UnsafeNumericCast<int64_t>(input_consumed);
-	}
-}
-
-void ZstdStreamWrapper::FlushStream() {
-	auto &sd = file->stream_data;
-	duckdb_zstd::ZSTD_inBuffer in_buffer;
-	duckdb_zstd::ZSTD_outBuffer out_buffer;
-
-	in_buffer.src = nullptr;
-	in_buffer.size = 0;
-	in_buffer.pos = 0;
-	while (true) {
-		idx_t output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
-
-		out_buffer.dst = sd.out_buff_start;
-		out_buffer.size = output_remaining;
-		out_buffer.pos = 0;
-
-		auto res =
-		    duckdb_zstd::ZSTD_compressStream2(zstd_compress_ptr, &out_buffer, &in_buffer, duckdb_zstd::ZSTD_e_end);
-		if (duckdb_zstd::ZSTD_isError(res)) {
-			throw IOException(duckdb_zstd::ZSTD_getErrorName(res));
-		}
-		idx_t written_to_output = out_buffer.pos;
-		sd.out_buff_start += written_to_output;
-		if (sd.out_buff_start > sd.out_buff.get()) {
-			file->child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
-			sd.out_buff_start = sd.out_buff.get();
-		}
-		if (res == 0) {
-			break;
-		}
-	}
-}
-
-void ZstdStreamWrapper::Close() {
-	if (!zstd_stream_ptr && !zstd_compress_ptr) {
-		return;
-	}
-	if (writing) {
-		FlushStream();
-	}
-	if (zstd_stream_ptr) {
-		duckdb_zstd::ZSTD_freeDStream(zstd_stream_ptr);
-	}
-	if (zstd_compress_ptr) {
-		duckdb_zstd::ZSTD_freeCStream(zstd_compress_ptr);
-	}
-	zstd_stream_ptr = nullptr;
-	zstd_compress_ptr = nullptr;
-}
-
-class ZStdFile : public CompressedFile {
-public:
-	ZStdFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
-	    : CompressedFile(zstd_fs, std::move(child_handle_p), path) {
-		Initialize(write);
-	}
-
-	FileCompressionType GetFileCompressionType() override {
-		return FileCompressionType::ZSTD;
-	}
-
-	ZStdFileSystem zstd_fs;
-};
-
-unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
-	auto path = handle->path;
-	return make_uniq<ZStdFile>(std::move(handle), path, write);
-}
-
-unique_ptr<StreamWrapper> ZStdFileSystem::CreateStream() {
-	return make_uniq<ZstdStreamWrapper>();
-}
-
-idx_t ZStdFileSystem::InBufferSize() {
-	return duckdb_zstd::ZSTD_DStreamInSize();
-}
-
-idx_t ZStdFileSystem::OutBufferSize() {
-	return duckdb_zstd::ZSTD_DStreamOutSize();
-}
-
-int64_t ZStdFileSystem::DefaultCompressionLevel() {
-	return duckdb_zstd::ZSTD_defaultCLevel();
-}
-
-int64_t ZStdFileSystem::MinimumCompressionLevel() {
-	return duckdb_zstd::ZSTD_minCLevel();
-}
-
-int64_t ZStdFileSystem::MaximumCompressionLevel() {
-	return duckdb_zstd::ZSTD_maxCLevel();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog.cpp b/src/duckdb/src/catalog/catalog.cpp
deleted file mode 100644
index 45047f185..000000000
--- a/src/duckdb/src/catalog/catalog.cpp
+++ /dev/null
@@ -1,1091 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/catalog/catalog_entry/list.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/default/default_schemas.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/catalog/default/default_types.hpp"
-#include "duckdb/main/extension_entries.hpp"
-#include "duckdb/main/extension/generated_extension_loader.hpp"
-#include "duckdb/main/connection.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/catalog/similar_catalog_entry.hpp"
-#include "duckdb/storage/database_size.hpp"
-#include <algorithm>
-
-namespace duckdb {
-
-Catalog::Catalog(AttachedDatabase &db) : db(db) {
-}
-
-Catalog::~Catalog() {
-}
-
-DatabaseInstance &Catalog::GetDatabase() {
-	return db.GetDatabase();
-}
-
-AttachedDatabase &Catalog::GetAttached() {
-	return db;
-}
-
-const AttachedDatabase &Catalog::GetAttached() const {
-	return db;
-}
-
-const string &Catalog::GetName() const {
-	return GetAttached().GetName();
-}
-
-idx_t Catalog::GetOid() {
-	return GetAttached().oid;
-}
-
-Catalog &Catalog::GetSystemCatalog(ClientContext &context) {
-	return Catalog::GetSystemCatalog(*context.db);
-}
-
-const string &GetDefaultCatalog(CatalogEntryRetriever &retriever) {
-	return DatabaseManager::GetDefaultDatabase(retriever.GetContext());
-}
-
-optional_ptr<Catalog> Catalog::GetCatalogEntry(CatalogEntryRetriever &retriever, const string &catalog_name) {
-	auto &context = retriever.GetContext();
-	auto &db_manager = DatabaseManager::Get(context);
-	if (catalog_name == TEMP_CATALOG) {
-		return &ClientData::Get(context).temporary_objects->GetCatalog();
-	}
-	if (catalog_name == SYSTEM_CATALOG) {
-		return &GetSystemCatalog(context);
-	}
-	auto entry =
-	    db_manager.GetDatabase(context, IsInvalidCatalog(catalog_name) ? GetDefaultCatalog(retriever) : catalog_name);
-	if (!entry) {
-		return nullptr;
-	}
-	return &entry->GetCatalog();
-}
-
-optional_ptr<Catalog> Catalog::GetCatalogEntry(ClientContext &context, const string &catalog_name) {
-	CatalogEntryRetriever entry_retriever(context);
-	return GetCatalogEntry(entry_retriever, catalog_name);
-}
-
-Catalog &Catalog::GetCatalog(CatalogEntryRetriever &retriever, const string &catalog_name) {
-	auto catalog = Catalog::GetCatalogEntry(retriever, catalog_name);
-	if (!catalog) {
-		throw BinderException("Catalog \"%s\" does not exist!", catalog_name);
-	}
-	return *catalog;
-}
-
-Catalog &Catalog::GetCatalog(ClientContext &context, const string &catalog_name) {
-	CatalogEntryRetriever entry_retriever(context);
-	return GetCatalog(entry_retriever, catalog_name);
-}
-
-//===--------------------------------------------------------------------===//
-// Schema
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateSchema(ClientContext &context, CreateSchemaInfo &info) {
-	return CreateSchema(GetCatalogTransaction(context), info);
-}
-
-CatalogTransaction Catalog::GetCatalogTransaction(ClientContext &context) {
-	return CatalogTransaction(*this, context);
-}
-
-//===--------------------------------------------------------------------===//
-// Table
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateTable(ClientContext &context, BoundCreateTableInfo &info) {
-	return CreateTable(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info) {
-	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(std::move(info));
-	return CreateTable(context, *bound_info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                BoundCreateTableInfo &info) {
-	return schema.CreateTable(transaction, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) {
-	auto &schema = GetSchema(transaction, info.base->schema);
-	return CreateTable(transaction, schema, info);
-}
-
-//===--------------------------------------------------------------------===//
-// View
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateView(CatalogTransaction transaction, CreateViewInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateView(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateView(ClientContext &context, CreateViewInfo &info) {
-	return CreateView(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                               CreateViewInfo &info) {
-	return schema.CreateView(transaction, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Sequence
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateSequence(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateSequence(ClientContext &context, CreateSequenceInfo &info) {
-	return CreateSequence(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                   CreateSequenceInfo &info) {
-	return schema.CreateSequence(transaction, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Type
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateType(CatalogTransaction transaction, CreateTypeInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateType(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateType(ClientContext &context, CreateTypeInfo &info) {
-	return CreateType(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                               CreateTypeInfo &info) {
-	return schema.CreateType(transaction, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Table Function
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateTableFunction(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo &info) {
-	return CreateTableFunction(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                        CreateTableFunctionInfo &info) {
-	return schema.CreateTableFunction(transaction, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateTableFunction(ClientContext &context,
-                                                        optional_ptr<CreateTableFunctionInfo> info) {
-	return CreateTableFunction(context, *info);
-}
-
-//===--------------------------------------------------------------------===//
-// Copy Function
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateCopyFunction(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo &info) {
-	return CreateCopyFunction(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                       CreateCopyFunctionInfo &info) {
-	return schema.CreateCopyFunction(transaction, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Pragma Function
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreatePragmaFunction(CatalogTransaction transaction,
-                                                         CreatePragmaFunctionInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreatePragmaFunction(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo &info) {
-	return CreatePragmaFunction(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                         CreatePragmaFunctionInfo &info) {
-	return schema.CreatePragmaFunction(transaction, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Function
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateFunction(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateFunction(ClientContext &context, CreateFunctionInfo &info) {
-	return CreateFunction(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                   CreateFunctionInfo &info) {
-	return schema.CreateFunction(transaction, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::AddFunction(ClientContext &context, CreateFunctionInfo &info) {
-	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
-	return CreateFunction(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Collation
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	return CreateCollation(transaction, schema, info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateCollation(ClientContext &context, CreateCollationInfo &info) {
-	return CreateCollation(GetCatalogTransaction(context), info);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                                    CreateCollationInfo &info) {
-	return schema.CreateCollation(transaction, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Index
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> Catalog::CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info) {
-	auto &schema = GetSchema(transaction, info.schema);
-	auto &table = schema.GetEntry(transaction, CatalogType::TABLE_ENTRY, info.table)->Cast<TableCatalogEntry>();
-	return schema.CreateIndex(transaction, info, table);
-}
-
-optional_ptr<CatalogEntry> Catalog::CreateIndex(ClientContext &context, CreateIndexInfo &info) {
-	return CreateIndex(GetCatalogTransaction(context), info);
-}
-
-unique_ptr<LogicalOperator> Catalog::BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry,
-                                                       unique_ptr<LogicalOperator> plan,
-                                                       unique_ptr<CreateIndexInfo> create_info,
-                                                       unique_ptr<AlterTableInfo> alter_info) {
-	throw NotImplementedException("BindAlterAddIndex not supported by this catalog");
-}
-
-//===--------------------------------------------------------------------===//
-// Lookup Structures
-//===--------------------------------------------------------------------===//
-struct CatalogLookup {
-	CatalogLookup(Catalog &catalog, string schema_p, string name_p)
-	    : catalog(catalog), schema(std::move(schema_p)), name(std::move(name_p)) {
-	}
-
-	Catalog &catalog;
-	string schema;
-	string name;
-};
-
-//===--------------------------------------------------------------------===//
-// Generic
-//===--------------------------------------------------------------------===//
-void Catalog::DropEntry(ClientContext &context, DropInfo &info) {
-	if (info.type == CatalogType::SCHEMA_ENTRY) {
-		// DROP SCHEMA
-		DropSchema(context, info);
-		return;
-	}
-
-	CatalogEntryRetriever retriever(context);
-	auto lookup = LookupEntry(retriever, info.type, info.schema, info.name, info.if_not_found);
-	if (!lookup.Found()) {
-		return;
-	}
-
-	lookup.schema->DropEntry(context, info);
-}
-
-SchemaCatalogEntry &Catalog::GetSchema(ClientContext &context, const string &name, QueryErrorContext error_context) {
-	return *Catalog::GetSchema(context, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-}
-
-optional_ptr<SchemaCatalogEntry> Catalog::GetSchema(ClientContext &context, const string &schema_name,
-                                                    OnEntryNotFound if_not_found, QueryErrorContext error_context) {
-	return GetSchema(GetCatalogTransaction(context), schema_name, if_not_found, error_context);
-}
-
-SchemaCatalogEntry &Catalog::GetSchema(ClientContext &context, const string &catalog_name, const string &schema_name,
-                                       QueryErrorContext error_context) {
-	return *Catalog::GetSchema(context, catalog_name, schema_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-}
-
-SchemaCatalogEntry &Catalog::GetSchema(CatalogTransaction transaction, const string &name,
-                                       QueryErrorContext error_context) {
-	return *GetSchema(transaction, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-}
-
-//===--------------------------------------------------------------------===//
-// Lookup
-//===--------------------------------------------------------------------===//
-vector<SimilarCatalogEntry> Catalog::SimilarEntriesInSchemas(ClientContext &context, const string &entry_name,
-                                                             CatalogType type,
-                                                             const reference_set_t<SchemaCatalogEntry> &schemas) {
-	vector<SimilarCatalogEntry> results;
-	for (auto schema_ref : schemas) {
-		auto &schema = schema_ref.get();
-		auto transaction = schema.catalog.GetCatalogTransaction(context);
-		auto entry = schema.GetSimilarEntry(transaction, type, entry_name);
-		if (!entry.Found()) {
-			// no similar entry found
-			continue;
-		}
-		if (results.empty() || results[0].score <= entry.score) {
-			if (!results.empty() && results[0].score < entry.score) {
-				results.clear();
-			}
-
-			results.push_back(entry);
-			results.back().schema = &schema;
-		}
-	}
-	return results;
-}
-
-vector<CatalogSearchEntry> GetCatalogEntries(CatalogEntryRetriever &retriever, const string &catalog,
-                                             const string &schema) {
-	auto &context = retriever.GetContext();
-	vector<CatalogSearchEntry> entries;
-	auto &search_path = retriever.GetSearchPath();
-	if (IsInvalidCatalog(catalog) && IsInvalidSchema(schema)) {
-		// no catalog or schema provided - scan the entire search path
-		entries = search_path.Get();
-	} else if (IsInvalidCatalog(catalog)) {
-		auto catalogs = search_path.GetCatalogsForSchema(schema);
-		for (auto &catalog_name : catalogs) {
-			entries.emplace_back(catalog_name, schema);
-		}
-		if (entries.empty()) {
-			auto &default_entry = search_path.GetDefault();
-			if (!IsInvalidCatalog(default_entry.catalog)) {
-				entries.emplace_back(default_entry.catalog, schema);
-			} else {
-				entries.emplace_back(DatabaseManager::GetDefaultDatabase(context), schema);
-			}
-		}
-	} else if (IsInvalidSchema(schema)) {
-		auto schemas = search_path.GetSchemasForCatalog(catalog);
-		for (auto &schema_name : schemas) {
-			entries.emplace_back(catalog, schema_name);
-		}
-		if (entries.empty()) {
-			entries.emplace_back(catalog, DEFAULT_SCHEMA);
-		}
-	} else {
-		// specific catalog and schema provided
-		entries.emplace_back(catalog, schema);
-	}
-	return entries;
-}
-
-void FindMinimalQualification(CatalogEntryRetriever &retriever, const string &catalog_name, const string &schema_name,
-                              bool &qualify_database, bool &qualify_schema) {
-	// check if we can we qualify ONLY the schema
-	bool found = false;
-	auto entries = GetCatalogEntries(retriever, INVALID_CATALOG, schema_name);
-	for (auto &entry : entries) {
-		if (entry.catalog == catalog_name && entry.schema == schema_name) {
-			found = true;
-			break;
-		}
-	}
-	if (found) {
-		qualify_database = false;
-		qualify_schema = true;
-		return;
-	}
-	// check if we can qualify ONLY the catalog
-	found = false;
-	entries = GetCatalogEntries(retriever, catalog_name, INVALID_SCHEMA);
-	for (auto &entry : entries) {
-		if (entry.catalog == catalog_name && entry.schema == schema_name) {
-			found = true;
-			break;
-		}
-	}
-	if (found) {
-		qualify_database = true;
-		qualify_schema = false;
-		return;
-	}
-	// need to qualify both catalog and schema
-	qualify_database = true;
-	qualify_schema = true;
-}
-
-bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) noexcept {
-	string extension_name = ExtensionHelper::ApplyExtensionAlias(original_name);
-	if (context.db->ExtensionIsLoaded(extension_name)) {
-		return true;
-	}
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-	auto &dbconfig = DBConfig::GetConfig(context);
-	if (!dbconfig.options.autoload_known_extensions) {
-		return false;
-	}
-	try {
-		if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
-			return ExtensionHelper::TryAutoLoadExtension(context, extension_name);
-		}
-	} catch (...) {
-		return false;
-	}
-#endif
-	return false;
-}
-
-void Catalog::AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name) {
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-	auto &dbconfig = DBConfig::GetConfig(context);
-	if (dbconfig.options.autoload_known_extensions) {
-		auto extension_name = ExtensionHelper::FindExtensionInEntries(configuration_name, EXTENSION_SETTINGS);
-		if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
-			ExtensionHelper::AutoLoadExtension(context, extension_name);
-			return;
-		}
-	}
-#endif
-
-	throw Catalog::UnrecognizedConfigurationError(context, configuration_name);
-}
-
-static bool IsAutoloadableFunction(CatalogType type) {
-	return (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
-	        type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY);
-}
-
-bool IsTableFunction(CatalogType type) {
-	switch (type) {
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsScalarFunction(CatalogType type) {
-	switch (type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-		return true;
-	default:
-		return false;
-	}
-}
-
-static bool CompareCatalogTypes(CatalogType type_a, CatalogType type_b) {
-	if (type_a == type_b) {
-		// Types are same
-		return true;
-	}
-	if (IsScalarFunction(type_a) && IsScalarFunction(type_b)) {
-		return true;
-	}
-	if (IsTableFunction(type_a) && IsTableFunction(type_b)) {
-		return true;
-	}
-	return false;
-}
-
-bool Catalog::AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name) {
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-	auto &dbconfig = DBConfig::GetConfig(db);
-	if (dbconfig.options.autoload_known_extensions) {
-		string extension_name;
-		if (IsAutoloadableFunction(type)) {
-			auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
-			if (lookup_result.empty()) {
-				return false;
-			}
-			for (auto &function : lookup_result) {
-				auto function_type = function.second;
-				// FIXME: what if there are two functions with the same name, from different extensions?
-				if (CompareCatalogTypes(type, function_type)) {
-					extension_name = function.first;
-					break;
-				}
-			}
-		} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
-			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
-		} else if (type == CatalogType::TYPE_ENTRY) {
-			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
-		} else if (type == CatalogType::COLLATION_ENTRY) {
-			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
-		}
-
-		if (!extension_name.empty() && ExtensionHelper::CanAutoloadExtension(extension_name)) {
-			ExtensionHelper::AutoLoadExtension(db, extension_name);
-			return true;
-		}
-	}
-#endif
-
-	return false;
-}
-
-CatalogException Catalog::UnrecognizedConfigurationError(ClientContext &context, const string &name) {
-	// check if the setting exists in any extensions
-	auto extension_name = ExtensionHelper::FindExtensionInEntries(name, EXTENSION_SETTINGS);
-	if (!extension_name.empty()) {
-		auto error_message = "Setting with name \"" + name + "\" is not in the catalog, but it exists in the " +
-		                     extension_name + " extension.";
-		error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, extension_name);
-		return CatalogException(error_message);
-	}
-	// the setting is not in an extension
-	// get a list of all options
-	vector<string> potential_names = DBConfig::GetOptionNames();
-	for (auto &entry : DBConfig::GetConfig(context).extension_parameters) {
-		potential_names.push_back(entry.first);
-	}
-	throw CatalogException::MissingEntry("configuration parameter", name, potential_names);
-}
-
-CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &retriever, const string &entry_name,
-                                                      CatalogType type,
-                                                      const reference_set_t<SchemaCatalogEntry> &schemas,
-                                                      QueryErrorContext error_context) {
-	auto &context = retriever.GetContext();
-	auto entries = SimilarEntriesInSchemas(context, entry_name, type, schemas);
-
-	reference_set_t<SchemaCatalogEntry> unseen_schemas;
-	auto &db_manager = DatabaseManager::Get(context);
-	auto databases = db_manager.GetDatabases(context);
-	auto &config = DBConfig::GetConfig(context);
-
-	auto max_schema_count = config.GetSetting<CatalogErrorMaxSchemasSetting>(context);
-	for (auto database : databases) {
-		if (unseen_schemas.size() >= max_schema_count) {
-			break;
-		}
-		auto &catalog = database.get().GetCatalog();
-		auto current_schemas = catalog.GetAllSchemas(context);
-		for (auto &current_schema : current_schemas) {
-			if (unseen_schemas.size() >= max_schema_count) {
-				break;
-			}
-			unseen_schemas.insert(current_schema.get());
-		}
-	}
-	// check if the entry exists in any extension
-	string extension_name;
-	if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
-	    type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) {
-		auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
-		do {
-			if (lookup_result.empty()) {
-				break;
-			}
-			vector<string> other_types;
-			string extension_for_error;
-			for (auto &function : lookup_result) {
-				auto function_type = function.second;
-				if (CompareCatalogTypes(type, function_type)) {
-					extension_name = function.first;
-					break;
-				}
-				extension_for_error = function.first;
-				other_types.push_back(CatalogTypeToString(function_type));
-			}
-			if (!extension_name.empty()) {
-				break;
-			}
-			if (other_types.size() == 1) {
-				auto &function_type = other_types[0];
-				auto error =
-				    CatalogException("%s with name \"%s\" is not in the catalog, a function by this name exists "
-				                     "in the %s extension, but it's of a different type, namely %s",
-				                     CatalogTypeToString(type), entry_name, extension_for_error, function_type);
-				return error;
-			} else {
-				D_ASSERT(!other_types.empty());
-				auto list_of_types = StringUtil::Join(other_types, ", ");
-				auto error =
-				    CatalogException("%s with name \"%s\" is not in the catalog, functions with this name exist "
-				                     "in the %s extension, but they are of different types, namely %s",
-				                     CatalogTypeToString(type), entry_name, extension_for_error, list_of_types);
-				return error;
-			}
-		} while (false);
-	} else if (type == CatalogType::TYPE_ENTRY) {
-		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
-	} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
-		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
-	} else if (type == CatalogType::COLLATION_ENTRY) {
-		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
-	}
-
-	// if we found an extension that can handle this catalog entry, create an error hinting the user
-	if (!extension_name.empty()) {
-		auto error_message = CatalogTypeToString(type) + " with name \"" + entry_name +
-		                     "\" is not in the catalog, but it exists in the " + extension_name + " extension.";
-		error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, extension_name);
-		return CatalogException(error_message);
-	}
-
-	// entries in other schemas get a penalty
-	// however, if there is an exact match in another schema, we will always show it
-	static constexpr const double UNSEEN_PENALTY = 0.2;
-	auto unseen_entries = SimilarEntriesInSchemas(context, entry_name, type, unseen_schemas);
-	vector<string> suggestions;
-	if (!unseen_entries.empty() && (unseen_entries[0].score == 1.0 || unseen_entries[0].score - UNSEEN_PENALTY >
-	                                                                      (entries.empty() ? 0.0 : entries[0].score))) {
-		// the closest matching entry requires qualification as it is not in the default search path
-		// check how to minimally qualify this entry
-		for (auto &unseen_entry : unseen_entries) {
-			auto catalog_name = unseen_entry.schema->catalog.GetName();
-			auto schema_name = unseen_entry.schema->name;
-			bool qualify_database;
-			bool qualify_schema;
-			FindMinimalQualification(retriever, catalog_name, schema_name, qualify_database, qualify_schema);
-			suggestions.push_back(unseen_entry.GetQualifiedName(qualify_database, qualify_schema));
-		}
-	} else if (!entries.empty()) {
-		for (auto &entry : entries) {
-			suggestions.push_back(entry.name);
-		}
-	}
-
-	string did_you_mean;
-	std::sort(suggestions.begin(), suggestions.end());
-	if (suggestions.size() > 2) {
-		auto last = suggestions.back();
-		suggestions.pop_back();
-		did_you_mean = StringUtil::Join(suggestions, ", ") + ", or " + last;
-	} else {
-		did_you_mean = StringUtil::Join(suggestions, " or ");
-	}
-
-	return CatalogException::MissingEntry(type, entry_name, did_you_mean, error_context);
-}
-
-CatalogEntryLookup Catalog::TryLookupEntryInternal(CatalogTransaction transaction, CatalogType type,
-                                                   const string &schema, const string &name) {
-	auto schema_entry = GetSchema(transaction, schema, OnEntryNotFound::RETURN_NULL);
-	if (!schema_entry) {
-		return {nullptr, nullptr, ErrorData()};
-	}
-	auto entry = schema_entry->GetEntry(transaction, type, name);
-	if (!entry) {
-		return {schema_entry, nullptr, ErrorData()};
-	}
-	return {schema_entry, entry, ErrorData()};
-}
-
-CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &schema,
-                                           const string &name, OnEntryNotFound if_not_found,
-                                           QueryErrorContext error_context) {
-	auto &context = retriever.GetContext();
-	reference_set_t<SchemaCatalogEntry> schemas;
-	if (IsInvalidSchema(schema)) {
-		// try all schemas for this catalog
-		auto entries = GetCatalogEntries(retriever, GetName(), INVALID_SCHEMA);
-		for (auto &entry : entries) {
-			auto &candidate_schema = entry.schema;
-			auto transaction = GetCatalogTransaction(context);
-			auto result = TryLookupEntryInternal(transaction, type, candidate_schema, name);
-			if (result.Found()) {
-				return result;
-			}
-			if (result.schema) {
-				schemas.insert(*result.schema);
-			}
-		}
-	} else {
-		auto transaction = GetCatalogTransaction(context);
-		auto result = TryLookupEntryInternal(transaction, type, schema, name);
-		if (result.Found()) {
-			return result;
-		}
-		if (result.schema) {
-			schemas.insert(*result.schema);
-		}
-	}
-
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		return {nullptr, nullptr, ErrorData()};
-	} else {
-		auto except = CreateMissingEntryException(retriever, name, type, schemas, error_context);
-		return {nullptr, nullptr, ErrorData(except)};
-	}
-}
-
-CatalogEntryLookup Catalog::LookupEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &schema,
-                                        const string &name, OnEntryNotFound if_not_found,
-                                        QueryErrorContext error_context) {
-	auto res = TryLookupEntry(retriever, type, schema, name, if_not_found, error_context);
-
-	if (res.error.HasError()) {
-		res.error.Throw();
-	}
-
-	return res;
-}
-
-CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, vector<CatalogLookup> &lookups,
-                                           CatalogType type, const string &name, OnEntryNotFound if_not_found,
-                                           QueryErrorContext error_context) {
-	auto &context = retriever.GetContext();
-	reference_set_t<SchemaCatalogEntry> schemas;
-	for (auto &lookup : lookups) {
-		auto transaction = lookup.catalog.GetCatalogTransaction(context);
-		auto result = lookup.catalog.TryLookupEntryInternal(transaction, type, lookup.schema, lookup.name);
-		if (result.Found()) {
-			return result;
-		}
-		if (result.schema) {
-			schemas.insert(*result.schema);
-		}
-	}
-
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		return {nullptr, nullptr, ErrorData()};
-	} else {
-		auto except = CreateMissingEntryException(retriever, name, type, schemas, error_context);
-		return {nullptr, nullptr, ErrorData(except)};
-	}
-}
-
-CatalogEntryLookup Catalog::TryLookupDefaultTable(CatalogEntryRetriever &retriever, CatalogType type,
-                                                  const string &catalog, const string &schema, const string &name,
-                                                  OnEntryNotFound if_not_found, QueryErrorContext error_context) {
-	// Default tables of catalogs can only be accessed by the catalog name directly
-	if (!schema.empty() || !catalog.empty()) {
-		return {nullptr, nullptr, ErrorData()};
-	}
-
-	vector<CatalogLookup> catalog_by_name_lookups;
-	auto catalog_by_name = GetCatalogEntry(retriever, name);
-	if (catalog_by_name && catalog_by_name->HasDefaultTable()) {
-		catalog_by_name_lookups.emplace_back(*catalog_by_name, catalog_by_name->GetDefaultTableSchema(),
-		                                     catalog_by_name->GetDefaultTable());
-	}
-
-	return TryLookupEntry(retriever, catalog_by_name_lookups, type, name, if_not_found, error_context);
-}
-
-static void ThrowDefaultTableAmbiguityException(CatalogEntryLookup &base_lookup, CatalogEntryLookup &default_table,
-                                                const string &name) {
-	auto entry_type = CatalogTypeToString(base_lookup.entry->type);
-	string fully_qualified_name_hint;
-	if (base_lookup.schema) {
-		fully_qualified_name_hint = StringUtil::Format(": '%s.%s.%s'", base_lookup.schema->catalog.GetName(),
-		                                               base_lookup.schema->name, base_lookup.entry->name);
-	}
-	string fully_qualified_catalog_name_hint = StringUtil::Format(
-	    ": '%s.%s.%s'", default_table.schema->catalog.GetName(), default_table.schema->name, default_table.entry->name);
-	throw CatalogException(
-	    "Ambiguity detected for '%s': this could either refer to the '%s' '%s', or the "
-	    "attached catalog '%s' which has a default table. To avoid this error, either detach the catalog and "
-	    "reattach under a different name, or use a fully qualified name for the '%s'%s or for the Catalog "
-	    "Default Table%s.",
-	    name, entry_type, name, name, entry_type, fully_qualified_name_hint, fully_qualified_catalog_name_hint);
-}
-
-CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &catalog,
-                                           const string &schema, const string &name, OnEntryNotFound if_not_found,
-                                           QueryErrorContext error_context) {
-	auto entries = GetCatalogEntries(retriever, catalog, schema);
-	vector<CatalogLookup> lookups;
-	vector<CatalogLookup> final_lookups;
-	lookups.reserve(entries.size());
-	for (auto &entry : entries) {
-		optional_ptr<Catalog> catalog_entry;
-		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-			catalog_entry = Catalog::GetCatalogEntry(retriever, entry.catalog);
-		} else {
-			catalog_entry = &Catalog::GetCatalog(retriever, entry.catalog);
-		}
-		if (!catalog_entry) {
-			return {nullptr, nullptr, ErrorData()};
-		}
-		D_ASSERT(catalog_entry);
-		auto lookup_behavior = catalog_entry->CatalogTypeLookupRule(type);
-		if (lookup_behavior == CatalogLookupBehavior::STANDARD) {
-			lookups.emplace_back(*catalog_entry, entry.schema, name);
-		} else if (lookup_behavior == CatalogLookupBehavior::LOWER_PRIORITY) {
-			final_lookups.emplace_back(*catalog_entry, entry.schema, name);
-		}
-	}
-
-	for (auto &lookup : final_lookups) {
-		lookups.emplace_back(std::move(lookup));
-	}
-
-	// Do the main lookup
-	auto lookup_result = TryLookupEntry(retriever, lookups, type, name, if_not_found, error_context);
-
-	// Special case for tables: we do a second lookup searching for catalogs with default tables that also match this
-	// lookup
-	if (type == CatalogType::TABLE_ENTRY) {
-		auto lookup_result_default_table =
-		    TryLookupDefaultTable(retriever, type, catalog, schema, name, OnEntryNotFound::RETURN_NULL, error_context);
-
-		if (lookup_result_default_table.Found() && lookup_result.Found()) {
-			ThrowDefaultTableAmbiguityException(lookup_result, lookup_result_default_table, name);
-		}
-
-		if (lookup_result_default_table.Found()) {
-			return lookup_result_default_table;
-		}
-	}
-
-	return lookup_result;
-}
-
-optional_ptr<CatalogEntry> Catalog::GetEntry(CatalogEntryRetriever &retriever, CatalogType type,
-                                             const string &schema_name, const string &name,
-                                             OnEntryNotFound if_not_found, QueryErrorContext error_context) {
-	auto lookup_entry = TryLookupEntry(retriever, type, schema_name, name, if_not_found, error_context);
-
-	// Try autoloading extension to resolve lookup
-	if (!lookup_entry.Found()) {
-		if (AutoLoadExtensionByCatalogEntry(*retriever.GetContext().db, type, name)) {
-			lookup_entry = TryLookupEntry(retriever, type, schema_name, name, if_not_found, error_context);
-		}
-	}
-
-	if (lookup_entry.error.HasError()) {
-		lookup_entry.error.Throw();
-	}
-
-	return lookup_entry.entry.get();
-}
-
-optional_ptr<CatalogEntry> Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name,
-                                             const string &name, OnEntryNotFound if_not_found,
-                                             QueryErrorContext error_context) {
-	CatalogEntryRetriever retriever(context);
-	return GetEntry(retriever, type, schema_name, name, if_not_found, error_context);
-}
-
-CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
-                                QueryErrorContext error_context) {
-	return *Catalog::GetEntry(context, type, schema, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-}
-
-optional_ptr<CatalogEntry> Catalog::GetEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &catalog,
-                                             const string &schema, const string &name, OnEntryNotFound if_not_found,
-                                             QueryErrorContext error_context) {
-	auto result = TryLookupEntry(retriever, type, catalog, schema, name, if_not_found, error_context);
-
-	// Try autoloading extension to resolve lookup
-	if (!result.Found()) {
-		if (AutoLoadExtensionByCatalogEntry(*retriever.GetContext().db, type, name)) {
-			result = TryLookupEntry(retriever, type, catalog, schema, name, if_not_found, error_context);
-		}
-	}
-
-	if (result.error.HasError()) {
-		result.error.Throw();
-	}
-
-	if (!result.Found()) {
-		D_ASSERT(if_not_found == OnEntryNotFound::RETURN_NULL);
-		return nullptr;
-	}
-	return result.entry.get();
-}
-optional_ptr<CatalogEntry> Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog,
-                                             const string &schema, const string &name, OnEntryNotFound if_not_found,
-                                             QueryErrorContext error_context) {
-	CatalogEntryRetriever retriever(context);
-	return GetEntry(retriever, type, catalog, schema, name, if_not_found, error_context);
-}
-
-CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog, const string &schema,
-                                const string &name, QueryErrorContext error_context) {
-	return *Catalog::GetEntry(context, type, catalog, schema, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-}
-
-optional_ptr<SchemaCatalogEntry> Catalog::GetSchema(CatalogEntryRetriever &retriever, const string &catalog_name,
-                                                    const string &schema_name, OnEntryNotFound if_not_found,
-                                                    QueryErrorContext error_context) {
-	auto entries = GetCatalogEntries(retriever, catalog_name, schema_name);
-	for (idx_t i = 0; i < entries.size(); i++) {
-		auto on_not_found = i + 1 == entries.size() ? if_not_found : OnEntryNotFound::RETURN_NULL;
-		auto &catalog = Catalog::GetCatalog(retriever, entries[i].catalog);
-		auto result = catalog.GetSchema(retriever.GetContext(), schema_name, on_not_found, error_context);
-		if (result) {
-			return result;
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<SchemaCatalogEntry> Catalog::GetSchema(ClientContext &context, const string &catalog_name,
-                                                    const string &schema_name, OnEntryNotFound if_not_found,
-                                                    QueryErrorContext error_context) {
-	CatalogEntryRetriever retriever(context);
-	return GetSchema(retriever, catalog_name, schema_name, if_not_found, error_context);
-}
-
-vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context) {
-	vector<reference<SchemaCatalogEntry>> schemas;
-	ScanSchemas(context, [&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
-	return schemas;
-}
-
-vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(CatalogEntryRetriever &retriever,
-                                                          const string &catalog_name) {
-	vector<reference<Catalog>> catalogs;
-	if (IsInvalidCatalog(catalog_name)) {
-		reference_set_t<Catalog> inserted_catalogs;
-
-		auto &search_path = retriever.GetSearchPath();
-		for (auto &entry : search_path.Get()) {
-			auto &catalog = Catalog::GetCatalog(retriever, entry.catalog);
-			if (inserted_catalogs.find(catalog) != inserted_catalogs.end()) {
-				continue;
-			}
-			inserted_catalogs.insert(catalog);
-			catalogs.push_back(catalog);
-		}
-	} else {
-		catalogs.push_back(Catalog::GetCatalog(retriever, catalog_name));
-	}
-	vector<reference<SchemaCatalogEntry>> result;
-	for (auto catalog : catalogs) {
-		auto schemas = catalog.get().GetSchemas(retriever.GetContext());
-		result.insert(result.end(), schemas.begin(), schemas.end());
-	}
-	return result;
-}
-
-vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
-	CatalogEntryRetriever retriever(context);
-	return GetSchemas(retriever, catalog_name);
-}
-
-vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &context) {
-	vector<reference<SchemaCatalogEntry>> result;
-
-	auto &db_manager = DatabaseManager::Get(context);
-	auto databases = db_manager.GetDatabases(context);
-	for (auto database : databases) {
-		auto &catalog = database.get().GetCatalog();
-		auto new_schemas = catalog.GetSchemas(context);
-		result.insert(result.end(), new_schemas.begin(), new_schemas.end());
-	}
-	sort(result.begin(), result.end(),
-	     [&](reference<SchemaCatalogEntry> left_p, reference<SchemaCatalogEntry> right_p) {
-		     auto &left = left_p.get();
-		     auto &right = right_p.get();
-		     if (left.catalog.GetName() < right.catalog.GetName()) {
-			     return true;
-		     }
-		     if (left.catalog.GetName() == right.catalog.GetName()) {
-			     return left.name < right.name;
-		     }
-		     return false;
-	     });
-
-	return result;
-}
-
-void Catalog::Alter(CatalogTransaction transaction, AlterInfo &info) {
-	if (transaction.HasContext()) {
-		CatalogEntryRetriever retriever(transaction.GetContext());
-		auto lookup = LookupEntry(retriever, info.GetCatalogType(), info.schema, info.name, info.if_not_found);
-		if (!lookup.Found()) {
-			return;
-		}
-		return lookup.schema->Alter(transaction, info);
-	}
-	D_ASSERT(info.if_not_found == OnEntryNotFound::THROW_EXCEPTION);
-	auto &schema = GetSchema(transaction, info.schema);
-	return schema.Alter(transaction, info);
-}
-
-void Catalog::Alter(ClientContext &context, AlterInfo &info) {
-	Alter(GetCatalogTransaction(context), info);
-}
-
-vector<MetadataBlockInfo> Catalog::GetMetadataInfo(ClientContext &context) {
-	return vector<MetadataBlockInfo>();
-}
-
-optional_ptr<DependencyManager> Catalog::GetDependencyManager() {
-	return nullptr;
-}
-
-//! Whether this catalog has a default table. Catalogs with a default table can be queries by their catalog name
-bool Catalog::HasDefaultTable() const {
-	return !default_table.empty();
-}
-
-void Catalog::SetDefaultTable(const string &schema, const string &name) {
-	default_table = name;
-	default_table_schema = schema;
-}
-
-string Catalog::GetDefaultTable() const {
-	return default_table;
-}
-
-string Catalog::GetDefaultTableSchema() const {
-	return !default_table_schema.empty() ? default_table_schema : DEFAULT_SCHEMA;
-}
-
-void Catalog::Verify() {
-}
-
-bool Catalog::IsSystemCatalog() const {
-	return db.IsSystem();
-}
-
-bool Catalog::IsTemporaryCatalog() const {
-	return db.IsTemporary();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry.cpp
deleted file mode 100644
index d6a96d6ec..000000000
--- a/src/duckdb/src/catalog/catalog_entry.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#include "duckdb/catalog/catalog_entry.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-
-namespace duckdb {
-
-CatalogEntry::CatalogEntry(CatalogType type, string name_p, idx_t oid)
-    : oid(oid), type(type), set(nullptr), name(std::move(name_p)), deleted(false), temporary(false), internal(false),
-      parent(nullptr) {
-}
-
-CatalogEntry::CatalogEntry(CatalogType type, Catalog &catalog, string name_p)
-    : CatalogEntry(type, std::move(name_p), catalog.GetDatabase().GetDatabaseManager().NextOid()) {
-}
-
-CatalogEntry::~CatalogEntry() {
-}
-
-void CatalogEntry::SetAsRoot() {
-}
-
-// LCOV_EXCL_START
-unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
-	throw InternalException("Unsupported alter type for catalog entry!");
-}
-
-unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
-	if (!transaction.context) {
-		throw InternalException("Cannot AlterEntry without client context");
-	}
-	return AlterEntry(*transaction.context, info);
-}
-
-void CatalogEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
-}
-
-unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
-	throw InternalException("Unsupported copy type for catalog entry!");
-}
-
-unique_ptr<CreateInfo> CatalogEntry::GetInfo() const {
-	throw InternalException("Unsupported type for CatalogEntry::GetInfo!");
-}
-
-string CatalogEntry::ToSQL() const {
-	throw InternalException("Unsupported catalog type for ToSQL()");
-}
-
-void CatalogEntry::SetChild(unique_ptr<CatalogEntry> child_p) {
-	child = std::move(child_p);
-	if (child) {
-		child->parent = this;
-	}
-}
-
-unique_ptr<CatalogEntry> CatalogEntry::TakeChild() {
-	if (child) {
-		child->parent = nullptr;
-	}
-	return std::move(child);
-}
-
-bool CatalogEntry::HasChild() const {
-	return child != nullptr;
-}
-bool CatalogEntry::HasParent() const {
-	return parent != nullptr;
-}
-
-CatalogEntry &CatalogEntry::Child() {
-	return *child;
-}
-
-CatalogEntry &CatalogEntry::Parent() {
-	return *parent;
-}
-
-Catalog &CatalogEntry::ParentCatalog() {
-	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
-}
-
-const Catalog &CatalogEntry::ParentCatalog() const {
-	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
-}
-
-SchemaCatalogEntry &CatalogEntry::ParentSchema() {
-	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
-}
-
-const SchemaCatalogEntry &CatalogEntry::ParentSchema() const {
-	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
-}
-// LCOV_EXCL_STOP
-
-void CatalogEntry::Serialize(Serializer &serializer) const {
-	const auto info = GetInfo();
-	info->Serialize(serializer);
-}
-
-unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &deserializer) {
-	return CreateInfo::Deserialize(deserializer);
-}
-
-void CatalogEntry::Verify(Catalog &catalog_p) {
-}
-
-void CatalogEntry::Rollback(CatalogEntry &prev_entry) {
-}
-
-InCatalogEntry::InCatalogEntry(CatalogType type, Catalog &catalog, string name)
-    : CatalogEntry(type, catalog, std::move(name)), catalog(catalog) {
-}
-
-InCatalogEntry::~InCatalogEntry() {
-}
-
-void InCatalogEntry::Verify(Catalog &catalog_p) {
-	D_ASSERT(&catalog_p == &catalog);
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/column_dependency_manager.cpp b/src/duckdb/src/catalog/catalog_entry/column_dependency_manager.cpp
deleted file mode 100644
index b8b2f0e87..000000000
--- a/src/duckdb/src/catalog/catalog_entry/column_dependency_manager.cpp
+++ /dev/null
@@ -1,271 +0,0 @@
-#include "duckdb/catalog/catalog_entry/column_dependency_manager.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-
-namespace duckdb {
-
-ColumnDependencyManager::ColumnDependencyManager() {
-}
-
-ColumnDependencyManager::~ColumnDependencyManager() {
-}
-
-void ColumnDependencyManager::AddGeneratedColumn(const ColumnDefinition &column, const ColumnList &list) {
-	D_ASSERT(column.Generated());
-	vector<string> referenced_columns;
-	column.GetListOfDependencies(referenced_columns);
-	vector<LogicalIndex> indices;
-	for (auto &col : referenced_columns) {
-		if (!list.ColumnExists(col)) {
-			throw BinderException("Column \"%s\" referenced by generated column does not exist", col);
-		}
-		auto &entry = list.GetColumn(col);
-		indices.push_back(entry.Logical());
-	}
-	return AddGeneratedColumn(column.Logical(), indices);
-}
-
-void ColumnDependencyManager::AddGeneratedColumn(LogicalIndex index, const vector<LogicalIndex> &indices, bool root) {
-	if (indices.empty()) {
-		return;
-	}
-	auto &list = dependents_map[index];
-	// Create a link between the dependencies
-	for (auto &dep : indices) {
-		// Add this column as a dependency of the new column
-		list.insert(dep);
-		// Add the new column as a dependent of the column
-		dependencies_map[dep].insert(index);
-		// Inherit the dependencies
-		if (HasDependencies(dep)) {
-			auto &inherited_deps = dependents_map[dep];
-			D_ASSERT(!inherited_deps.empty());
-			for (auto &inherited_dep : inherited_deps) {
-				list.insert(inherited_dep);
-				dependencies_map[inherited_dep].insert(index);
-			}
-		}
-		if (!root) {
-			continue;
-		}
-		direct_dependencies[index].insert(dep);
-	}
-	if (!HasDependents(index)) {
-		return;
-	}
-	auto &dependents = dependencies_map[index];
-	if (dependents.count(index)) {
-		throw InvalidInputException("Circular dependency encountered when resolving generated column expressions");
-	}
-	// Also let the dependents of this generated column inherit the dependencies
-	for (auto &dependent : dependents) {
-		AddGeneratedColumn(dependent, indices, false);
-	}
-}
-
-vector<LogicalIndex> ColumnDependencyManager::RemoveColumn(LogicalIndex index, idx_t column_amount) {
-	// Always add the initial column
-	deleted_columns.insert(index);
-
-	RemoveGeneratedColumn(index);
-	RemoveStandardColumn(index);
-
-	// Clean up the internal list
-	vector<LogicalIndex> new_indices = CleanupInternals(column_amount);
-	D_ASSERT(deleted_columns.empty());
-	return new_indices;
-}
-
-bool ColumnDependencyManager::IsDependencyOf(LogicalIndex gcol, LogicalIndex col) const {
-	auto entry = dependents_map.find(gcol);
-	if (entry == dependents_map.end()) {
-		return false;
-	}
-	auto &list = entry->second;
-	return list.count(col);
-}
-
-bool ColumnDependencyManager::HasDependencies(LogicalIndex index) const {
-	auto entry = dependents_map.find(index);
-	if (entry == dependents_map.end()) {
-		return false;
-	}
-	return true;
-}
-
-const logical_index_set_t &ColumnDependencyManager::GetDependencies(LogicalIndex index) const {
-	auto entry = dependents_map.find(index);
-	D_ASSERT(entry != dependents_map.end());
-	return entry->second;
-}
-
-bool ColumnDependencyManager::HasDependents(LogicalIndex index) const {
-	auto entry = dependencies_map.find(index);
-	if (entry == dependencies_map.end()) {
-		return false;
-	}
-	return true;
-}
-
-const logical_index_set_t &ColumnDependencyManager::GetDependents(LogicalIndex index) const {
-	auto entry = dependencies_map.find(index);
-	D_ASSERT(entry != dependencies_map.end());
-	return entry->second;
-}
-
-void ColumnDependencyManager::RemoveStandardColumn(LogicalIndex index) {
-	if (!HasDependents(index)) {
-		return;
-	}
-	auto dependents = dependencies_map[index];
-	for (auto &gcol : dependents) {
-		// If index is a direct dependency of gcol, remove it from the list
-		if (direct_dependencies.find(gcol) != direct_dependencies.end()) {
-			direct_dependencies[gcol].erase(index);
-		}
-		RemoveGeneratedColumn(gcol);
-	}
-	// Remove this column from the dependencies map
-	dependencies_map.erase(index);
-}
-
-void ColumnDependencyManager::RemoveGeneratedColumn(LogicalIndex index) {
-	deleted_columns.insert(index);
-	if (!HasDependencies(index)) {
-		return;
-	}
-	auto &dependencies = dependents_map[index];
-	for (auto &col : dependencies) {
-		// Remove this generated column from the list of this column
-		auto &col_dependents = dependencies_map[col];
-		D_ASSERT(col_dependents.count(index));
-		col_dependents.erase(index);
-		// If the resulting list is empty, remove the column from the dependencies map altogether
-		if (col_dependents.empty()) {
-			dependencies_map.erase(col);
-		}
-	}
-	// Remove this column from the dependents_map map
-	dependents_map.erase(index);
-}
-
-void ColumnDependencyManager::AdjustSingle(LogicalIndex idx, idx_t offset) {
-	D_ASSERT(idx.index >= offset);
-	LogicalIndex new_idx = LogicalIndex(idx.index - offset);
-	// Adjust this index in the dependents of this column
-	bool has_dependents = HasDependents(idx);
-	bool has_dependencies = HasDependencies(idx);
-
-	if (has_dependents) {
-		auto &dependents = GetDependents(idx);
-		for (auto &dep : dependents) {
-			auto &dep_dependencies = dependents_map[dep];
-			dep_dependencies.erase(idx);
-			D_ASSERT(!dep_dependencies.count(new_idx));
-			dep_dependencies.insert(new_idx);
-		}
-	}
-	if (has_dependencies) {
-		auto &dependencies = GetDependencies(idx);
-		for (auto &dep : dependencies) {
-			auto &dep_dependents = dependencies_map[dep];
-			dep_dependents.erase(idx);
-			D_ASSERT(!dep_dependents.count(new_idx));
-			dep_dependents.insert(new_idx);
-		}
-	}
-	if (has_dependents) {
-		D_ASSERT(!dependencies_map.count(new_idx));
-		dependencies_map[new_idx] = std::move(dependencies_map[idx]);
-		dependencies_map.erase(idx);
-	}
-	if (has_dependencies) {
-		D_ASSERT(!dependents_map.count(new_idx));
-		dependents_map[new_idx] = std::move(dependents_map[idx]);
-		dependents_map.erase(idx);
-	}
-}
-
-vector<LogicalIndex> ColumnDependencyManager::CleanupInternals(idx_t column_amount) {
-	vector<LogicalIndex> to_adjust;
-	D_ASSERT(!deleted_columns.empty());
-	// Get the lowest index that was deleted
-	vector<LogicalIndex> new_indices(column_amount, LogicalIndex(DConstants::INVALID_INDEX));
-	idx_t threshold = deleted_columns.begin()->index;
-
-	idx_t offset = 0;
-	for (idx_t i = 0; i < column_amount; i++) {
-		auto current_index = LogicalIndex(i);
-		auto new_index = LogicalIndex(i - offset);
-		new_indices[i] = new_index;
-		if (deleted_columns.count(current_index)) {
-			offset++;
-			continue;
-		}
-		if (i > threshold && (HasDependencies(current_index) || HasDependents(current_index))) {
-			to_adjust.push_back(current_index);
-		}
-	}
-
-	// Adjust all indices inside the dependency managers internal mappings
-	for (auto &col : to_adjust) {
-		auto offset = col.index - new_indices[col.index].index;
-		AdjustSingle(col, offset);
-	}
-	deleted_columns.clear();
-	return new_indices;
-}
-
-stack<LogicalIndex> ColumnDependencyManager::GetBindOrder(const ColumnList &columns) {
-	stack<LogicalIndex> bind_order;
-	queue<LogicalIndex> to_visit;
-	logical_index_set_t visited;
-
-	for (auto &entry : direct_dependencies) {
-		auto dependent = entry.first;
-		//! Skip the dependents that are also dependencies
-		if (dependencies_map.find(dependent) != dependencies_map.end()) {
-			continue;
-		}
-		bind_order.push(dependent);
-		visited.insert(dependent);
-		for (auto &dependency : direct_dependencies[dependent]) {
-			to_visit.push(dependency);
-		}
-	}
-
-	while (!to_visit.empty()) {
-		auto column = to_visit.front();
-		to_visit.pop();
-
-		//! If this column does not have dependencies, the queue stops getting filled
-		if (direct_dependencies.find(column) == direct_dependencies.end()) {
-			continue;
-		}
-		bind_order.push(column);
-		visited.insert(column);
-
-		for (auto &dependency : direct_dependencies[column]) {
-			to_visit.push(dependency);
-		}
-	}
-
-	// Add generated columns that have no dependencies, but still might need to have their type resolved
-	for (auto &col : columns.Logical()) {
-		// Not a generated column
-		if (!col.Generated()) {
-			continue;
-		}
-		// Already added to the bind_order stack
-		if (visited.count(col.Logical())) {
-			continue;
-		}
-		bind_order.push(col.Logical());
-	}
-
-	return bind_order;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/copy_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/copy_function_catalog_entry.cpp
deleted file mode 100644
index 25544a343..000000000
--- a/src/duckdb/src/catalog/catalog_entry/copy_function_catalog_entry.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-
-namespace duckdb {
-
-CopyFunctionCatalogEntry::CopyFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
-                                                   CreateCopyFunctionInfo &info)
-    : StandardEntry(CatalogType::COPY_FUNCTION_ENTRY, schema, catalog, info.name), function(info.function) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/dependency/dependency_dependent_entry.cpp b/src/duckdb/src/catalog/catalog_entry/dependency/dependency_dependent_entry.cpp
deleted file mode 100644
index 5baaed41a..000000000
--- a/src/duckdb/src/catalog/catalog_entry/dependency/dependency_dependent_entry.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "duckdb/catalog/catalog_entry/dependency/dependency_dependent_entry.hpp"
-
-namespace duckdb {
-
-DependencyDependentEntry::DependencyDependentEntry(Catalog &catalog, const DependencyInfo &info)
-    : DependencyEntry(catalog, DependencyEntryType::DEPENDENT,
-                      MangledDependencyName(DependencyManager::MangleName(info.subject.entry),
-                                            DependencyManager::MangleName(info.dependent.entry)),
-                      info) {
-}
-
-const MangledEntryName &DependencyDependentEntry::EntryMangledName() const {
-	return dependent_name;
-}
-
-const CatalogEntryInfo &DependencyDependentEntry::EntryInfo() const {
-	return dependent.entry;
-}
-
-const MangledEntryName &DependencyDependentEntry::SourceMangledName() const {
-	return subject_name;
-}
-
-const CatalogEntryInfo &DependencyDependentEntry::SourceInfo() const {
-	return subject.entry;
-}
-
-DependencyDependentEntry::~DependencyDependentEntry() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/dependency/dependency_entry.cpp b/src/duckdb/src/catalog/catalog_entry/dependency/dependency_entry.cpp
deleted file mode 100644
index ab425bd98..000000000
--- a/src/duckdb/src/catalog/catalog_entry/dependency/dependency_entry.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-DependencyEntry::DependencyEntry(Catalog &catalog, DependencyEntryType side, const MangledDependencyName &name,
-                                 const DependencyInfo &info)
-    : InCatalogEntry(CatalogType::DEPENDENCY_ENTRY, catalog, name.name),
-      dependent_name(DependencyManager::MangleName(info.dependent.entry)),
-      subject_name(DependencyManager::MangleName(info.subject.entry)), dependent(info.dependent), subject(info.subject),
-      side(side) {
-	D_ASSERT(info.dependent.entry.type != CatalogType::DEPENDENCY_ENTRY);
-	D_ASSERT(info.subject.entry.type != CatalogType::DEPENDENCY_ENTRY);
-	if (catalog.IsTemporaryCatalog()) {
-		temporary = true;
-	}
-}
-
-const MangledEntryName &DependencyEntry::SubjectMangledName() const {
-	return subject_name;
-}
-
-const DependencySubject &DependencyEntry::Subject() const {
-	return subject;
-}
-
-const MangledEntryName &DependencyEntry::DependentMangledName() const {
-	return dependent_name;
-}
-
-const DependencyDependent &DependencyEntry::Dependent() const {
-	return dependent;
-}
-
-DependencyEntry::~DependencyEntry() {
-}
-
-DependencyEntryType DependencyEntry::Side() const {
-	return side;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/dependency/dependency_subject_entry.cpp b/src/duckdb/src/catalog/catalog_entry/dependency/dependency_subject_entry.cpp
deleted file mode 100644
index eb9c7f63a..000000000
--- a/src/duckdb/src/catalog/catalog_entry/dependency/dependency_subject_entry.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp"
-
-namespace duckdb {
-
-DependencySubjectEntry::DependencySubjectEntry(Catalog &catalog, const DependencyInfo &info)
-    : DependencyEntry(catalog, DependencyEntryType::SUBJECT,
-                      MangledDependencyName(DependencyManager::MangleName(info.dependent.entry),
-                                            DependencyManager::MangleName(info.subject.entry)),
-                      info) {
-}
-
-const MangledEntryName &DependencySubjectEntry::EntryMangledName() const {
-	return subject_name;
-}
-
-const CatalogEntryInfo &DependencySubjectEntry::EntryInfo() const {
-	return subject.entry;
-}
-
-const MangledEntryName &DependencySubjectEntry::SourceMangledName() const {
-	return dependent_name;
-}
-
-const CatalogEntryInfo &DependencySubjectEntry::SourceInfo() const {
-	return dependent.entry;
-}
-
-DependencySubjectEntry::~DependencySubjectEntry() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp b/src/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp
deleted file mode 100644
index c70984e53..000000000
--- a/src/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-
-namespace duckdb {
-
-IndexDataTableInfo::IndexDataTableInfo(shared_ptr<DataTableInfo> info_p, const string &index_name_p)
-    : info(std::move(info_p)), index_name(index_name_p) {
-}
-
-void DuckIndexEntry::Rollback(CatalogEntry &) {
-	if (!info) {
-		return;
-	}
-	if (!info->info) {
-		return;
-	}
-	info->info->GetIndexes().RemoveIndex(name);
-}
-
-DuckIndexEntry::DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &create_info,
-                               TableCatalogEntry &table_p)
-    : IndexCatalogEntry(catalog, schema, create_info), initial_index_size(0) {
-
-	auto &table = table_p.Cast<DuckTableEntry>();
-	auto &storage = table.GetStorage();
-	info = make_shared_ptr<IndexDataTableInfo>(storage.GetDataTableInfo(), name);
-}
-
-DuckIndexEntry::DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &create_info,
-                               shared_ptr<IndexDataTableInfo> storage_info)
-    : IndexCatalogEntry(catalog, schema, create_info), info(std::move(storage_info)), initial_index_size(0) {
-}
-
-unique_ptr<CatalogEntry> DuckIndexEntry::Copy(ClientContext &context) const {
-	auto info_copy = GetInfo();
-	auto &cast_info = info_copy->Cast<CreateIndexInfo>();
-
-	auto result = make_uniq<DuckIndexEntry>(catalog, schema, cast_info, info);
-	result->initial_index_size = initial_index_size;
-
-	return std::move(result);
-}
-
-string DuckIndexEntry::GetSchemaName() const {
-	return GetDataTableInfo().GetSchemaName();
-}
-
-string DuckIndexEntry::GetTableName() const {
-	return GetDataTableInfo().GetTableName();
-}
-
-DataTableInfo &DuckIndexEntry::GetDataTableInfo() const {
-	return *info->info;
-}
-
-void DuckIndexEntry::CommitDrop() {
-	D_ASSERT(info);
-	auto &indexes = GetDataTableInfo().GetIndexes();
-	indexes.CommitDrop(name);
-	indexes.RemoveIndex(name);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp b/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp
deleted file mode 100644
index 9f07d4acf..000000000
--- a/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/catalog/default/default_functions.hpp"
-#include "duckdb/catalog/default/default_table_functions.hpp"
-#include "duckdb/catalog/default/default_types.hpp"
-#include "duckdb/catalog/default/default_views.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-
-namespace duckdb {
-
-static void FindForeignKeyInformation(TableCatalogEntry &table, AlterForeignKeyType alter_fk_type,
-                                      vector<unique_ptr<AlterForeignKeyInfo>> &fk_arrays) {
-	auto &constraints = table.GetConstraints();
-	auto &catalog = table.ParentCatalog();
-	auto &name = table.name;
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto &cond = constraints[i];
-		if (cond->type != ConstraintType::FOREIGN_KEY) {
-			continue;
-		}
-		auto &fk = cond->Cast<ForeignKeyConstraint>();
-		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-			AlterEntryData alter_data(catalog.GetName(), fk.info.schema, fk.info.table,
-			                          OnEntryNotFound::THROW_EXCEPTION);
-			fk_arrays.push_back(make_uniq<AlterForeignKeyInfo>(std::move(alter_data), name, fk.pk_columns,
-			                                                   fk.fk_columns, fk.info.pk_keys, fk.info.fk_keys,
-			                                                   alter_fk_type));
-		} else if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE &&
-		           alter_fk_type == AlterForeignKeyType::AFT_DELETE) {
-			throw CatalogException("Could not drop the table because this table is main key table of the table \"%s\"",
-			                       fk.info.table);
-		}
-	}
-}
-
-static void LazyLoadIndexes(ClientContext &context, CatalogEntry &entry) {
-	if (entry.type == CatalogType::TABLE_ENTRY) {
-		auto &table_entry = entry.Cast<TableCatalogEntry>();
-		table_entry.GetStorage().InitializeIndexes(context);
-	} else if (entry.type == CatalogType::INDEX_ENTRY) {
-		auto &index_entry = entry.Cast<IndexCatalogEntry>();
-		auto &table_entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, index_entry.catalog.GetName(),
-		                                      index_entry.GetSchemaName(), index_entry.GetTableName())
-		                        .Cast<TableCatalogEntry>();
-		table_entry.GetStorage().InitializeIndexes(context);
-	}
-}
-
-DuckSchemaEntry::DuckSchemaEntry(Catalog &catalog, CreateSchemaInfo &info)
-    : SchemaCatalogEntry(catalog, info), tables(catalog, make_uniq<DefaultViewGenerator>(catalog, *this)),
-      indexes(catalog), table_functions(catalog, make_uniq<DefaultTableFunctionGenerator>(catalog, *this)),
-      copy_functions(catalog), pragma_functions(catalog),
-      functions(catalog, make_uniq<DefaultFunctionGenerator>(catalog, *this)), sequences(catalog), collations(catalog),
-      types(catalog, make_uniq<DefaultTypeGenerator>(catalog, *this)) {
-}
-
-unique_ptr<CatalogEntry> DuckSchemaEntry::Copy(ClientContext &context) const {
-	auto info_copy = GetInfo();
-	auto &cast_info = info_copy->Cast<CreateSchemaInfo>();
-
-	auto result = make_uniq<DuckSchemaEntry>(catalog, cast_info);
-
-	return std::move(result);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction,
-                                                             unique_ptr<StandardEntry> entry,
-                                                             OnCreateConflict on_conflict,
-                                                             LogicalDependencyList dependencies) {
-	auto entry_name = entry->name;
-	auto entry_type = entry->type;
-	auto result = entry.get();
-
-	if (transaction.context) {
-		auto &meta = MetaTransaction::Get(transaction.GetContext());
-		auto modified_database = meta.ModifiedDatabase();
-		auto &db = ParentCatalog().GetAttached();
-		if (!db.IsTemporary() && !db.IsSystem()) {
-			if (!modified_database || !RefersToSameObject(*modified_database, ParentCatalog().GetAttached())) {
-				throw InternalException(
-				    "DuckSchemaEntry::AddEntryInternal called but this database is not marked as modified");
-			}
-		}
-	}
-	// first find the set for this entry
-	auto &set = GetCatalogSet(entry_type);
-	dependencies.AddDependency(*this);
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		auto old_entry = set.GetEntry(transaction, entry_name);
-		if (old_entry) {
-			return nullptr;
-		}
-	}
-
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		// CREATE OR REPLACE: first try to drop the entry
-		auto old_entry = set.GetEntry(transaction, entry_name);
-		if (old_entry) {
-			if (dependencies.Contains(*old_entry)) {
-				throw CatalogException("CREATE OR REPLACE is not allowed to depend on itself");
-			}
-			if (old_entry->type != entry_type) {
-				throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", entry_name,
-				                       CatalogTypeToString(old_entry->type), CatalogTypeToString(entry_type));
-			}
-			OnDropEntry(transaction, *old_entry);
-			(void)set.DropEntry(transaction, entry_name, false, entry->internal);
-		}
-	}
-	// now try to add the entry
-	if (!set.CreateEntry(transaction, entry_name, std::move(entry), dependencies)) {
-		// entry already exists!
-		if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			throw CatalogException::EntryAlreadyExists(entry_type, entry_name);
-		} else {
-			return nullptr;
-		}
-	}
-	return result;
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) {
-	auto table = make_uniq<DuckTableEntry>(catalog, *this, info);
-
-	// add a foreign key constraint in main key table if there is a foreign key constraint
-	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
-	FindForeignKeyInformation(*table, AlterForeignKeyType::AFT_ADD, fk_arrays);
-	for (idx_t i = 0; i < fk_arrays.size(); i++) {
-		// alter primary key table
-		auto &fk_info = *fk_arrays[i];
-		Alter(transaction, fk_info);
-
-		// make a dependency between this table and referenced table
-		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
-		info.dependencies.AddDependency(*set.GetEntry(transaction, fk_info.name));
-	}
-	for (auto &dep : info.dependencies.Set()) {
-		table->dependencies.AddDependency(dep);
-	}
-
-	auto entry = AddEntryInternal(transaction, std::move(table), info.Base().on_conflict, info.dependencies);
-	if (!entry) {
-		return nullptr;
-	}
-
-	return entry;
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) {
-	if (info.on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
-		// check if the original entry exists
-		auto &catalog_set = GetCatalogSet(info.type);
-		auto current_entry = catalog_set.GetEntry(transaction, info.name);
-		if (current_entry) {
-			// the current entry exists - alter it instead
-			auto alter_info = info.GetAlterInfo();
-			Alter(transaction, *alter_info);
-			return nullptr;
-		}
-	}
-	unique_ptr<StandardEntry> function;
-	switch (info.type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		function = make_uniq_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, *this,
-		                                                                     info.Cast<CreateScalarFunctionInfo>());
-		break;
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-		function = make_uniq_base<StandardEntry, TableFunctionCatalogEntry>(catalog, *this,
-		                                                                    info.Cast<CreateTableFunctionInfo>());
-		break;
-	case CatalogType::MACRO_ENTRY:
-		// create a macro function
-		function = make_uniq_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, *this, info.Cast<CreateMacroInfo>());
-		break;
-
-	case CatalogType::TABLE_MACRO_ENTRY:
-		// create a macro table function
-		function = make_uniq_base<StandardEntry, TableMacroCatalogEntry>(catalog, *this, info.Cast<CreateMacroInfo>());
-		break;
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-		D_ASSERT(info.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-		// create an aggregate function
-		function = make_uniq_base<StandardEntry, AggregateFunctionCatalogEntry>(
-		    catalog, *this, info.Cast<CreateAggregateFunctionInfo>());
-		break;
-	default:
-		throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info.type));
-	}
-	function->internal = info.internal;
-	return AddEntry(transaction, std::move(function), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-                                                     OnCreateConflict on_conflict) {
-	LogicalDependencyList dependencies = entry->dependencies;
-	return AddEntryInternal(transaction, std::move(entry), on_conflict, dependencies);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) {
-	auto sequence = make_uniq<SequenceCatalogEntry>(catalog, *this, info);
-	return AddEntry(transaction, std::move(sequence), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateType(CatalogTransaction transaction, CreateTypeInfo &info) {
-	auto type_entry = make_uniq<TypeCatalogEntry>(catalog, *this, info);
-	return AddEntry(transaction, std::move(type_entry), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateView(CatalogTransaction transaction, CreateViewInfo &info) {
-	auto view = make_uniq<ViewCatalogEntry>(catalog, *this, info);
-	return AddEntry(transaction, std::move(view), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info,
-                                                        TableCatalogEntry &table) {
-	info.dependencies.AddDependency(table);
-
-	// currently, we can not alter PK/FK/UNIQUE constraints
-	// concurrency-safe name checks against other INDEX catalog entries happens in the catalog
-	if (info.on_conflict != OnCreateConflict::IGNORE_ON_CONFLICT &&
-	    !table.GetStorage().IndexNameIsUnique(info.index_name)) {
-		throw CatalogException("An index with the name " + info.index_name + " already exists!");
-	}
-
-	auto index = make_uniq<DuckIndexEntry>(catalog, *this, info, table);
-	auto dependencies = index->dependencies;
-	return AddEntryInternal(transaction, std::move(index), info.on_conflict, dependencies);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) {
-	auto collation = make_uniq<CollateCatalogEntry>(catalog, *this, info);
-	collation->internal = info.internal;
-	return AddEntry(transaction, std::move(collation), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateTableFunction(CatalogTransaction transaction,
-                                                                CreateTableFunctionInfo &info) {
-	auto table_function = make_uniq<TableFunctionCatalogEntry>(catalog, *this, info);
-	table_function->internal = info.internal;
-	return AddEntry(transaction, std::move(table_function), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreateCopyFunction(CatalogTransaction transaction,
-                                                               CreateCopyFunctionInfo &info) {
-	auto copy_function = make_uniq<CopyFunctionCatalogEntry>(catalog, *this, info);
-	copy_function->internal = info.internal;
-	return AddEntry(transaction, std::move(copy_function), info.on_conflict);
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::CreatePragmaFunction(CatalogTransaction transaction,
-                                                                 CreatePragmaFunctionInfo &info) {
-	auto pragma_function = make_uniq<PragmaFunctionCatalogEntry>(catalog, *this, info);
-	pragma_function->internal = info.internal;
-	return AddEntry(transaction, std::move(pragma_function), info.on_conflict);
-}
-
-void DuckSchemaEntry::Alter(CatalogTransaction transaction, AlterInfo &info) {
-	CatalogType type = info.GetCatalogType();
-
-	auto &set = GetCatalogSet(type);
-	if (info.type == AlterType::CHANGE_OWNERSHIP) {
-		if (!set.AlterOwnership(transaction, info.Cast<ChangeOwnershipInfo>())) {
-			throw CatalogException("Couldn't change ownership!");
-		}
-	} else {
-		string name = info.name;
-		if (!set.AlterEntry(transaction, name, info)) {
-			throw CatalogException::MissingEntry(type, name, string());
-		}
-	}
-}
-
-void DuckSchemaEntry::Scan(ClientContext &context, CatalogType type,
-                           const std::function<void(CatalogEntry &)> &callback) {
-	auto &set = GetCatalogSet(type);
-	set.Scan(GetCatalogTransaction(context), callback);
-}
-
-void DuckSchemaEntry::Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) {
-	auto &set = GetCatalogSet(type);
-	set.Scan(callback);
-}
-
-void DuckSchemaEntry::DropEntry(ClientContext &context, DropInfo &info) {
-	auto &set = GetCatalogSet(info.type);
-
-	// first find the entry
-	auto transaction = GetCatalogTransaction(context);
-	auto existing_entry = set.GetEntry(transaction, info.name);
-	if (!existing_entry) {
-		throw InternalException("Failed to drop entry \"%s\" - entry could not be found", info.name);
-	}
-	if (existing_entry->type != info.type) {
-		throw CatalogException("Existing object %s is of type %s, trying to drop type %s", info.name,
-		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info.type));
-	}
-
-	// if this is a index or table with indexes, initialize any unknown index instances
-	LazyLoadIndexes(context, *existing_entry);
-
-	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
-	if (existing_entry->type == CatalogType::TABLE_ENTRY) {
-		// if there is a foreign key constraint, get that information
-		auto &table_entry = existing_entry->Cast<TableCatalogEntry>();
-		FindForeignKeyInformation(table_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
-	}
-
-	OnDropEntry(transaction, *existing_entry);
-	if (!set.DropEntry(transaction, info.name, info.cascade, info.allow_drop_internal)) {
-		throw InternalException("Could not drop element because of an internal error");
-	}
-
-	// remove the foreign key constraint in main key table if main key table's name is valid
-	for (idx_t i = 0; i < fk_arrays.size(); i++) {
-		// alter primary key table
-		Alter(transaction, *fk_arrays[i]);
-	}
-}
-
-void DuckSchemaEntry::OnDropEntry(CatalogTransaction transaction, CatalogEntry &entry) {
-	if (!transaction.transaction) {
-		return;
-	}
-	if (entry.type != CatalogType::TABLE_ENTRY) {
-		return;
-	}
-	// if we have transaction local insertions for this table - clear them
-	auto &table_entry = entry.Cast<TableCatalogEntry>();
-	auto &local_storage = LocalStorage::Get(transaction.transaction->Cast<DuckTransaction>());
-	local_storage.DropTable(table_entry.GetStorage());
-}
-
-optional_ptr<CatalogEntry> DuckSchemaEntry::GetEntry(CatalogTransaction transaction, CatalogType type,
-                                                     const string &name) {
-	return GetCatalogSet(type).GetEntry(transaction, name);
-}
-
-CatalogSet::EntryLookup DuckSchemaEntry::GetEntryDetailed(CatalogTransaction transaction, CatalogType type,
-                                                          const string &name) {
-	return GetCatalogSet(type).GetEntryDetailed(transaction, name);
-}
-
-SimilarCatalogEntry DuckSchemaEntry::GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
-                                                     const string &name) {
-	return GetCatalogSet(type).SimilarEntry(transaction, name);
-}
-
-CatalogSet &DuckSchemaEntry::GetCatalogSet(CatalogType type) {
-	switch (type) {
-	case CatalogType::VIEW_ENTRY:
-	case CatalogType::TABLE_ENTRY:
-		return tables;
-	case CatalogType::INDEX_ENTRY:
-		return indexes;
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return table_functions;
-	case CatalogType::COPY_FUNCTION_ENTRY:
-		return copy_functions;
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-		return pragma_functions;
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-		return functions;
-	case CatalogType::SEQUENCE_ENTRY:
-		return sequences;
-	case CatalogType::COLLATION_ENTRY:
-		return collations;
-	case CatalogType::TYPE_ENTRY:
-		return types;
-	default:
-		throw InternalException("Unsupported catalog type in schema");
-	}
-}
-
-void DuckSchemaEntry::Verify(Catalog &catalog) {
-	InCatalogEntry::Verify(catalog);
-
-	tables.Verify(catalog);
-	indexes.Verify(catalog);
-	table_functions.Verify(catalog);
-	copy_functions.Verify(catalog);
-	pragma_functions.Verify(catalog);
-	functions.Verify(catalog);
-	sequences.Verify(catalog);
-	collations.Verify(catalog);
-	types.Verify(catalog);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp b/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp
deleted file mode 100644
index 4983710d9..000000000
--- a/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp
+++ /dev/null
@@ -1,912 +0,0 @@
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/index_map.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_binder/alter_binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-
-namespace duckdb {
-
-IndexStorageInfo GetIndexInfo(const IndexConstraintType type, const bool v1_0_0_storage, unique_ptr<CreateInfo> &info,
-                              const idx_t id) {
-
-	auto &table_info = info->Cast<CreateTableInfo>();
-	auto constraint_name = EnumUtil::ToString(type) + "_";
-	auto name = constraint_name + table_info.table + "_" + to_string(id);
-	IndexStorageInfo index_info(name);
-	if (!v1_0_0_storage) {
-		index_info.options.emplace("v1_0_0_storage", v1_0_0_storage);
-	}
-	return index_info;
-}
-
-DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
-                               shared_ptr<DataTable> inherited_storage)
-    : TableCatalogEntry(catalog, schema, info.Base()), storage(std::move(inherited_storage)),
-      column_dependency_manager(std::move(info.column_dependency_manager)) {
-
-	if (storage) {
-		if (!info.indexes.empty()) {
-			storage->SetIndexStorageInfo(std::move(info.indexes));
-		}
-		return;
-	}
-
-	// create the physical storage
-	vector<ColumnDefinition> column_defs;
-	for (auto &col_def : columns.Physical()) {
-		column_defs.push_back(col_def.Copy());
-	}
-	storage = make_shared_ptr<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
-	                                     schema.name, name, std::move(column_defs), std::move(info.data));
-
-	// Create the unique indexes for the UNIQUE, PRIMARY KEY, and FOREIGN KEY constraints.
-	idx_t indexes_idx = 0;
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto &constraint = constraints[i];
-		if (constraint->type == ConstraintType::UNIQUE) {
-
-			// UNIQUE constraint: Create a unique index.
-			auto &unique = constraint->Cast<UniqueConstraint>();
-			IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
-			if (unique.is_primary_key) {
-				constraint_type = IndexConstraintType::PRIMARY;
-			}
-
-			auto column_indexes = unique.GetLogicalIndexes(columns);
-			if (info.indexes.empty()) {
-				auto index_info = GetIndexInfo(constraint_type, false, info.base, i);
-				storage->AddIndex(columns, column_indexes, constraint_type, index_info);
-				continue;
-			}
-
-			// We read the index from an old storage version applying a dummy name.
-			if (info.indexes[indexes_idx].name.empty()) {
-				auto name_info = GetIndexInfo(constraint_type, true, info.base, i);
-				info.indexes[indexes_idx].name = name_info.name;
-			}
-
-			// Now we can add the index.
-			storage->AddIndex(columns, column_indexes, constraint_type, info.indexes[indexes_idx++]);
-			continue;
-		}
-
-		if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			// Create a FOREIGN KEY index.
-			auto &bfk = constraint->Cast<ForeignKeyConstraint>();
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
-			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-
-				vector<LogicalIndex> column_indexes;
-				for (const auto &physical_index : bfk.info.fk_keys) {
-					auto &col = columns.GetColumn(physical_index);
-					column_indexes.push_back(col.Logical());
-				}
-
-				if (info.indexes.empty()) {
-					auto constraint_type = IndexConstraintType::FOREIGN;
-					auto index_info = GetIndexInfo(constraint_type, false, info.base, i);
-					storage->AddIndex(columns, column_indexes, constraint_type, index_info);
-					continue;
-				}
-
-				// We read the index from an old storage version applying a dummy name.
-				if (info.indexes[indexes_idx].name.empty()) {
-					auto name_info = GetIndexInfo(IndexConstraintType::FOREIGN, true, info.base, i);
-					info.indexes[indexes_idx].name = name_info.name;
-				}
-
-				// Now we can add the index.
-				storage->AddIndex(columns, column_indexes, IndexConstraintType::FOREIGN, info.indexes[indexes_idx++]);
-			}
-		}
-	}
-
-	if (!info.indexes.empty()) {
-		storage->SetIndexStorageInfo(std::move(info.indexes));
-	}
-}
-
-unique_ptr<BaseStatistics> DuckTableEntry::GetStatistics(ClientContext &context, column_t column_id) {
-	if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-		return nullptr;
-	}
-	auto &column = columns.GetColumn(LogicalIndex(column_id));
-	if (column.Generated()) {
-		return nullptr;
-	}
-	return storage->GetStatistics(context, column.StorageOid());
-}
-
-unique_ptr<BlockingSample> DuckTableEntry::GetSample() {
-	return storage->GetSample();
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
-	if (transaction.HasContext()) {
-		return AlterEntry(transaction.GetContext(), info);
-	}
-	if (info.type != AlterType::ALTER_TABLE) {
-		return CatalogEntry::AlterEntry(transaction, info);
-	}
-
-	auto &table_info = info.Cast<AlterTableInfo>();
-	if (table_info.alter_table_type != AlterTableType::FOREIGN_KEY_CONSTRAINT) {
-		return CatalogEntry::AlterEntry(transaction, info);
-	}
-
-	auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
-	if (foreign_key_constraint_info.type != AlterForeignKeyType::AFT_ADD) {
-		return CatalogEntry::AlterEntry(transaction, info);
-	}
-
-	// We add foreign key constraints without a client context during checkpoint loading.
-	return AddForeignKeyConstraint(nullptr, foreign_key_constraint_info);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
-	D_ASSERT(!internal);
-
-	// Column comments have a special alter type
-	if (info.type == AlterType::SET_COLUMN_COMMENT) {
-		auto &comment_on_column_info = info.Cast<SetColumnCommentInfo>();
-		return SetColumnComment(context, comment_on_column_info);
-	}
-
-	if (info.type != AlterType::ALTER_TABLE) {
-		throw CatalogException("Can only modify table with ALTER TABLE statement");
-	}
-	auto &table_info = info.Cast<AlterTableInfo>();
-	switch (table_info.alter_table_type) {
-	case AlterTableType::RENAME_COLUMN: {
-		auto &rename_info = table_info.Cast<RenameColumnInfo>();
-		return RenameColumn(context, rename_info);
-	}
-	case AlterTableType::RENAME_TABLE: {
-		auto &rename_info = table_info.Cast<RenameTableInfo>();
-		auto copied_table = Copy(context);
-		copied_table->name = rename_info.new_table_name;
-		storage->SetTableName(rename_info.new_table_name);
-		return copied_table;
-	}
-	case AlterTableType::ADD_COLUMN: {
-		auto &add_info = table_info.Cast<AddColumnInfo>();
-		return AddColumn(context, add_info);
-	}
-	case AlterTableType::REMOVE_COLUMN: {
-		auto &remove_info = table_info.Cast<RemoveColumnInfo>();
-		return RemoveColumn(context, remove_info);
-	}
-	case AlterTableType::SET_DEFAULT: {
-		auto &set_default_info = table_info.Cast<SetDefaultInfo>();
-		return SetDefault(context, set_default_info);
-	}
-	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto &change_type_info = table_info.Cast<ChangeColumnTypeInfo>();
-		return ChangeColumnType(context, change_type_info);
-	}
-	case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
-		auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
-		if (foreign_key_constraint_info.type == AlterForeignKeyType::AFT_ADD) {
-			return AddForeignKeyConstraint(context, foreign_key_constraint_info);
-		} else {
-			return DropForeignKeyConstraint(context, foreign_key_constraint_info);
-		}
-	}
-	case AlterTableType::SET_NOT_NULL: {
-		auto &set_not_null_info = table_info.Cast<SetNotNullInfo>();
-		return SetNotNull(context, set_not_null_info);
-	}
-	case AlterTableType::DROP_NOT_NULL: {
-		auto &drop_not_null_info = table_info.Cast<DropNotNullInfo>();
-		return DropNotNull(context, drop_not_null_info);
-	}
-	case AlterTableType::ADD_CONSTRAINT: {
-		auto &add_constraint_info = table_info.Cast<AddConstraintInfo>();
-		return AddConstraint(context, add_constraint_info);
-	}
-	default:
-		throw InternalException("Unrecognized alter table type!");
-	}
-}
-
-void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
-	D_ASSERT(!internal);
-	D_ASSERT(info.type == AlterType::ALTER_TABLE);
-	auto &table_info = info.Cast<AlterTableInfo>();
-	switch (table_info.alter_table_type) {
-	case AlterTableType::RENAME_TABLE: {
-		storage->SetTableName(this->name);
-		break;
-	default:
-		break;
-	}
-	}
-}
-
-static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		if (colref.column_names.back() == info.old_name) {
-			colref.column_names.back() = info.new_name;
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { RenameExpression((ParsedExpression &)child, info); });
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, RenameColumnInfo &info) {
-	auto rename_idx = GetColumnIndex(info.old_name);
-	if (rename_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
-		throw CatalogException("Cannot rename rowid column");
-	}
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	create_info->comment = comment;
-	create_info->tags = tags;
-	for (auto &col : columns.Logical()) {
-		auto copy = col.Copy();
-		if (rename_idx == col.Logical()) {
-			copy.SetName(info.new_name);
-		}
-		if (col.Generated() && column_dependency_manager.IsDependencyOf(col.Logical(), rename_idx)) {
-			RenameExpression(copy.GeneratedExpressionMutable(), info);
-		}
-		create_info->columns.AddColumn(std::move(copy));
-	}
-	for (idx_t c_idx = 0; c_idx < constraints.size(); c_idx++) {
-		auto copy = constraints[c_idx]->Copy();
-		switch (copy->type) {
-		case ConstraintType::NOT_NULL:
-			// NOT NULL constraint: no adjustments necessary
-			break;
-		case ConstraintType::CHECK: {
-			// CHECK constraint: need to rename column references that refer to the renamed column
-			auto &check = copy->Cast<CheckConstraint>();
-			RenameExpression(*check.expression, info);
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			// UNIQUE constraint: possibly need to rename columns
-			auto &unique = copy->Cast<UniqueConstraint>();
-			for (auto &column_name : unique.GetColumnNamesMutable()) {
-				if (column_name == info.old_name) {
-					column_name = info.new_name;
-				}
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			// FOREIGN KEY constraint: possibly need to rename columns
-			auto &fk = copy->Cast<ForeignKeyConstraint>();
-			vector<string> columns = fk.pk_columns;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				columns = fk.fk_columns;
-			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
-					columns.push_back(fk.fk_columns[i]);
-				}
-			}
-			for (idx_t i = 0; i < columns.size(); i++) {
-				if (columns[i] == info.old_name) {
-					throw CatalogException(
-					    "Cannot rename column \"%s\" because this is involved in the foreign key constraint",
-					    info.old_name);
-				}
-			}
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-		create_info->constraints.push_back(std::move(copy));
-	}
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddColumnInfo &info) {
-	auto col_name = info.new_column.GetName();
-
-	// We're checking for the opposite condition (ADD COLUMN IF _NOT_ EXISTS ...).
-	if (info.if_column_not_exists && ColumnExists(col_name)) {
-		return nullptr;
-	}
-
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	create_info->comment = comment;
-	create_info->tags = tags;
-
-	for (auto &col : columns.Logical()) {
-		create_info->columns.AddColumn(col.Copy());
-	}
-	for (auto &constraint : constraints) {
-		create_info->constraints.push_back(constraint->Copy());
-	}
-	auto binder = Binder::CreateBinder(context);
-	binder->BindLogicalType(info.new_column.TypeMutable(), &catalog, schema.name);
-	info.new_column.SetOid(columns.LogicalColumnCount());
-	info.new_column.SetStorageOid(columns.PhysicalColumnCount());
-	auto col = info.new_column.Copy();
-
-	create_info->columns.AddColumn(std::move(col));
-
-	vector<unique_ptr<Expression>> bound_defaults;
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema, bound_defaults);
-	auto new_storage = make_shared_ptr<DataTable>(context, *storage, info.new_column, *bound_defaults.back());
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
-}
-
-void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index,
-                                                   const vector<LogicalIndex> &adjusted_indices,
-                                                   const RemoveColumnInfo &info, CreateTableInfo &create_info,
-                                                   const vector<unique_ptr<BoundConstraint>> &bound_constraints,
-                                                   bool is_generated) {
-	// handle constraints for the new table
-	D_ASSERT(constraints.size() == bound_constraints.size());
-	for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
-		auto &constraint = constraints[constr_idx];
-		auto &bound_constraint = bound_constraints[constr_idx];
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null_constraint = bound_constraint->Cast<BoundNotNullConstraint>();
-			auto not_null_index = columns.PhysicalToLogical(not_null_constraint.index);
-			if (not_null_index != removed_index) {
-				// the constraint is not about this column: we need to copy it
-				// we might need to shift the index back by one though, to account for the removed column
-				auto new_index = adjusted_indices[not_null_index.index];
-				create_info.constraints.push_back(make_uniq<NotNullConstraint>(new_index));
-			}
-			break;
-		}
-		case ConstraintType::CHECK: {
-			// Generated columns can not be part of an index
-			// CHECK constraint
-			auto &bound_check = bound_constraint->Cast<BoundCheckConstraint>();
-			// check if the removed column is part of the check constraint
-			if (is_generated) {
-				// generated columns can not be referenced by constraints, we can just add the constraint back
-				create_info.constraints.push_back(constraint->Copy());
-				break;
-			}
-			auto physical_index = columns.LogicalToPhysical(removed_index);
-			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
-				if (bound_check.bound_columns.size() > 1) {
-					// CHECK constraint that concerns mult
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a CHECK constraint that depends on it",
-					    info.removed_column);
-				} else {
-					// CHECK constraint that ONLY concerns this column, strip the constraint
-				}
-			} else {
-				// check constraint does not concern the removed column: simply re-add it
-				create_info.constraints.push_back(constraint->Copy());
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto copy = constraint->Copy();
-			auto &unique = copy->Cast<UniqueConstraint>();
-			if (unique.HasIndex()) {
-				if (unique.GetIndex() == removed_index) {
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a UNIQUE constraint that depends on it",
-					    info.removed_column);
-				}
-				unique.SetIndex(adjusted_indices[unique.GetIndex().index]);
-			}
-			create_info.constraints.push_back(std::move(copy));
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto copy = constraint->Copy();
-			auto &fk = copy->Cast<ForeignKeyConstraint>();
-			vector<string> columns = fk.pk_columns;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				columns = fk.fk_columns;
-			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
-					columns.push_back(fk.fk_columns[i]);
-				}
-			}
-			for (idx_t i = 0; i < columns.size(); i++) {
-				if (columns[i] == info.removed_column) {
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a FOREIGN KEY constraint that depends on it",
-					    info.removed_column);
-				}
-			}
-			create_info.constraints.push_back(std::move(copy));
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-	}
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, RemoveColumnInfo &info) {
-	auto removed_index = GetColumnIndex(info.removed_column, info.if_column_exists);
-	if (!removed_index.IsValid()) {
-		if (!info.if_column_exists) {
-			throw CatalogException("Cannot drop column: rowid column cannot be dropped");
-		}
-		return nullptr;
-	}
-
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	create_info->comment = comment;
-	create_info->tags = tags;
-
-	logical_index_set_t removed_columns;
-	if (column_dependency_manager.HasDependents(removed_index)) {
-		removed_columns = column_dependency_manager.GetDependents(removed_index);
-	}
-	if (!removed_columns.empty() && !info.cascade) {
-		throw CatalogException("Cannot drop column: column is a dependency of 1 or more generated column(s)");
-	}
-	bool dropped_column_is_generated = false;
-	for (auto &col : columns.Logical()) {
-		if (col.Logical() == removed_index || removed_columns.count(col.Logical())) {
-			if (col.Generated()) {
-				dropped_column_is_generated = true;
-			}
-			continue;
-		}
-		create_info->columns.AddColumn(col.Copy());
-	}
-	if (create_info->columns.empty()) {
-		throw CatalogException("Cannot drop column: table only has one column remaining!");
-	}
-	auto adjusted_indices = column_dependency_manager.RemoveColumn(removed_index, columns.LogicalColumnCount());
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_constraints = binder->BindConstraints(constraints, name, columns);
-
-	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, bound_constraints,
-	                              dropped_column_is_generated);
-
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	if (columns.GetColumn(LogicalIndex(removed_index)).Generated()) {
-		return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-	}
-	auto new_storage =
-	    make_shared_ptr<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->comment = comment;
-	create_info->tags = tags;
-	auto default_idx = GetColumnIndex(info.column_name);
-	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
-		throw CatalogException("Cannot SET DEFAULT for rowid column");
-	}
-
-	// Copy all the columns, changing the value of the one that was specified by 'column_name'
-	for (auto &col : columns.Logical()) {
-		auto copy = col.Copy();
-		if (default_idx == col.Logical()) {
-			// set the default value of this column
-			if (copy.Generated()) {
-				throw BinderException("Cannot SET DEFAULT for generated column \"%s\"", col.Name());
-			}
-			copy.SetDefaultValue(info.expression ? info.expression->Copy() : nullptr);
-		}
-		create_info->columns.AddColumn(std::move(copy));
-	}
-	// Copy all the constraints
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		create_info->constraints.push_back(std::move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetNotNullInfo &info) {
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->comment = comment;
-	create_info->tags = tags;
-	create_info->columns = columns.Copy();
-
-	auto not_null_idx = GetColumnIndex(info.column_name);
-	if (columns.GetColumn(LogicalIndex(not_null_idx)).Generated()) {
-		throw BinderException("Unsupported constraint for generated column!");
-	}
-	bool has_not_null = false;
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = constraint->Cast<NotNullConstraint>();
-			if (not_null.index == not_null_idx) {
-				has_not_null = true;
-			}
-		}
-		create_info->constraints.push_back(std::move(constraint));
-	}
-	if (!has_not_null) {
-		create_info->constraints.push_back(make_uniq<NotNullConstraint>(not_null_idx));
-	}
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-
-	// Early return
-	if (has_not_null) {
-		return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-	}
-
-	// Return with new storage info. Note that we need the bound column index here.
-	auto physical_columns = columns.LogicalToPhysical(LogicalIndex(not_null_idx));
-	auto bound_constraint = make_uniq<BoundNotNullConstraint>(physical_columns);
-	auto new_storage = make_shared_ptr<DataTable>(context, *storage, *bound_constraint);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, DropNotNullInfo &info) {
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->comment = comment;
-	create_info->tags = tags;
-	create_info->columns = columns.Copy();
-
-	auto not_null_idx = GetColumnIndex(info.column_name);
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		// Skip/drop not_null
-		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = constraint->Cast<NotNullConstraint>();
-			if (not_null.index == not_null_idx) {
-				continue;
-			}
-		}
-		create_info->constraints.push_back(std::move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	auto binder = Binder::CreateBinder(context);
-	binder->BindLogicalType(info.target_type, &catalog, schema.name);
-
-	auto change_idx = GetColumnIndex(info.column_name);
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	create_info->comment = comment;
-	create_info->tags = tags;
-
-	// Bind the USING expression.
-	vector<LogicalIndex> bound_columns;
-	AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type);
-	auto expression = info.expression->Copy();
-	auto bound_expression = expr_binder.Bind(expression);
-
-	// Infer the target_type from the USING expression, if not set explicitly.
-	if (info.target_type == LogicalType::UNKNOWN) {
-		info.target_type = bound_expression->return_type;
-	}
-
-	auto bound_constraints = binder->BindConstraints(constraints, name, columns);
-	for (auto &col : columns.Logical()) {
-		auto copy = col.Copy();
-		if (change_idx == col.Logical()) {
-			// set the type of this column
-			if (copy.Generated()) {
-				throw NotImplementedException("Changing types of generated columns is not supported yet");
-			}
-			copy.SetType(info.target_type);
-		}
-		// TODO: check if the generated_expression breaks, only delete it if it does
-		if (copy.Generated() && column_dependency_manager.IsDependencyOf(col.Logical(), change_idx)) {
-			throw BinderException(
-			    "This column is referenced by the generated column \"%s\", so its type can not be changed",
-			    copy.Name());
-		}
-		create_info->columns.AddColumn(std::move(copy));
-	}
-
-	for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
-		auto constraint = constraints[constr_idx]->Copy();
-		switch (constraint->type) {
-		case ConstraintType::CHECK: {
-			auto &bound_check = bound_constraints[constr_idx]->Cast<BoundCheckConstraint>();
-			auto physical_index = columns.LogicalToPhysical(change_idx);
-			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
-				throw BinderException("Cannot change the type of a column that has a CHECK constraint specified");
-			}
-			break;
-		}
-		case ConstraintType::NOT_NULL:
-			break;
-		case ConstraintType::UNIQUE: {
-			auto &bound_unique = bound_constraints[constr_idx]->Cast<BoundUniqueConstraint>();
-			auto physical_index = columns.LogicalToPhysical(change_idx);
-			if (bound_unique.key_set.find(physical_index) != bound_unique.key_set.end()) {
-				throw BinderException(
-				    "Cannot change the type of a column that has a UNIQUE or PRIMARY KEY constraint specified");
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = bound_constraints[constr_idx]->Cast<BoundForeignKeyConstraint>();
-			auto key_set = bfk.pk_key_set;
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				key_set = bfk.fk_key_set;
-			} else if (bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				key_set.insert(bfk.info.fk_keys.begin(), bfk.info.fk_keys.end());
-			}
-			if (key_set.find(columns.LogicalToPhysical(change_idx)) != key_set.end()) {
-				throw BinderException("Cannot change the type of a column that has a FOREIGN KEY constraint specified");
-			}
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-		create_info->constraints.push_back(std::move(constraint));
-	}
-
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-
-	vector<StorageIndex> storage_oids;
-	for (idx_t i = 0; i < bound_columns.size(); i++) {
-		storage_oids.emplace_back(columns.LogicalToPhysical(bound_columns[i]).index);
-	}
-	if (storage_oids.empty()) {
-		storage_oids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
-	}
-
-	auto new_storage =
-	    make_shared_ptr<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(change_idx)).index,
-	                               info.target_type, std::move(storage_oids), *bound_expression);
-	auto result = make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
-	return std::move(result);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::SetColumnComment(ClientContext &context, SetColumnCommentInfo &info) {
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->comment = comment;
-	create_info->tags = tags;
-	auto default_idx = GetColumnIndex(info.column_name);
-	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
-		throw CatalogException("Cannot SET DEFAULT for rowid column");
-	}
-
-	// Copy all the columns, changing the value of the one that was specified by 'column_name'
-	for (auto &col : columns.Logical()) {
-		auto copy = col.Copy();
-		if (default_idx == col.Logical()) {
-			copy.SetComment(info.comment_value);
-		}
-		create_info->columns.AddColumn(std::move(copy));
-	}
-	// Copy all the constraints
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		create_info->constraints.push_back(std::move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(optional_ptr<ClientContext> context,
-                                                                 AlterForeignKeyInfo &info) {
-	D_ASSERT(info.type == AlterForeignKeyType::AFT_ADD);
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	create_info->comment = comment;
-	create_info->tags = tags;
-
-	create_info->columns = columns.Copy();
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		create_info->constraints.push_back(constraints[i]->Copy());
-	}
-	ForeignKeyInfo fk_info;
-	fk_info.type = ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE;
-	fk_info.schema = info.schema;
-	fk_info.table = info.fk_table;
-	fk_info.pk_keys = info.pk_keys;
-	fk_info.fk_keys = info.fk_keys;
-	create_info->constraints.push_back(
-	    make_uniq<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, std::move(fk_info)));
-
-	unique_ptr<BoundCreateTableInfo> bound_create_info;
-	if (context) {
-		auto binder = Binder::CreateBinder(*context);
-		bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	} else {
-		bound_create_info = Binder::BindCreateTableCheckpoint(std::move(create_info), schema);
-	}
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
-	D_ASSERT(info.type == AlterForeignKeyType::AFT_DELETE);
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	create_info->comment = comment;
-	create_info->tags = tags;
-
-	create_info->columns = columns.Copy();
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			ForeignKeyConstraint &fk = constraint->Cast<ForeignKeyConstraint>();
-			if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && fk.info.table == info.fk_table) {
-				continue;
-			}
-		}
-		create_info->constraints.push_back(std::move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-void DuckTableEntry::Rollback(CatalogEntry &prev_entry) {
-	if (prev_entry.type != CatalogType::TABLE_ENTRY) {
-		return;
-	}
-
-	// Rolls back any physical index creation.
-	// FIXME: Currently only works for PKs.
-	// FIXME: Should be changed to work for any index-based constraint.
-
-	auto &table = Cast<DuckTableEntry>();
-	auto &prev_table = prev_entry.Cast<DuckTableEntry>();
-	auto &prev_info = prev_table.GetStorage().GetDataTableInfo();
-	auto &prev_indexes = prev_info->GetIndexes();
-
-	// Find all index-based constraints that exist in rollback_table, but not in table.
-	// Then, remove them.
-
-	unordered_set<string> names;
-	for (const auto &constraint : prev_table.GetConstraints()) {
-		if (constraint->type != ConstraintType::UNIQUE) {
-			continue;
-		}
-		const auto &unique = constraint->Cast<UniqueConstraint>();
-		if (unique.is_primary_key) {
-			auto index_name = unique.GetName(prev_table.name);
-			names.insert(index_name);
-		}
-	}
-
-	for (const auto &constraint : GetConstraints()) {
-		if (constraint->type != ConstraintType::UNIQUE) {
-			continue;
-		}
-		const auto &unique = constraint->Cast<UniqueConstraint>();
-		if (!unique.IsPrimaryKey()) {
-			continue;
-		}
-		auto index_name = unique.GetName(table.name);
-		if (names.find(index_name) == names.end()) {
-			prev_indexes.RemoveIndex(index_name);
-		}
-	}
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::AddConstraint(ClientContext &context, AddConstraintInfo &info) {
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->comment = comment;
-
-	// Copy all columns and constraints to the modified table.
-	create_info->columns = columns.Copy();
-	for (const auto &constraint : constraints) {
-		create_info->constraints.push_back(constraint->Copy());
-	}
-
-	if (info.constraint->type == ConstraintType::UNIQUE) {
-		const auto &unique = info.constraint->Cast<UniqueConstraint>();
-		const auto existing_pk = GetPrimaryKey();
-
-		if (unique.is_primary_key && existing_pk) {
-			auto existing_name = existing_pk->ToString();
-			throw CatalogException("table \"%s\" can have only one primary key: %s", name, existing_name);
-		}
-		create_info->constraints.push_back(info.constraint->Copy());
-
-	} else {
-		throw InternalException("unsupported constraint type in ALTER TABLE statement");
-	}
-
-	// We create a physical table with a new constraint and a new unique index.
-	const auto binder = Binder::CreateBinder(context);
-	const auto bound_constraint = binder->BindConstraint(*info.constraint, create_info->table, create_info->columns);
-	const auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-
-	auto new_storage = make_shared_ptr<DataTable>(context, *storage, *bound_constraint);
-	auto new_entry = make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
-	return std::move(new_entry);
-}
-
-unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
-	auto create_info = make_uniq<CreateTableInfo>(schema, name);
-	create_info->comment = comment;
-	create_info->tags = tags;
-	create_info->columns = columns.Copy();
-
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		create_info->constraints.push_back(std::move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
-}
-
-void DuckTableEntry::SetAsRoot() {
-	storage->SetAsRoot();
-	storage->SetTableName(name);
-}
-
-void DuckTableEntry::CommitAlter(string &column_name) {
-	D_ASSERT(!column_name.empty());
-	optional_idx removed_index;
-	for (auto &col : columns.Logical()) {
-		if (col.Name() == column_name) {
-			// No need to alter storage, removed column is generated column
-			if (col.Generated()) {
-				return;
-			}
-			removed_index = col.Oid();
-			break;
-		}
-	}
-	storage->CommitDropColumn(columns.LogicalToPhysical(LogicalIndex(removed_index.GetIndex())).index);
-}
-
-void DuckTableEntry::CommitDrop() {
-	storage->CommitDropTable();
-}
-
-DataTable &DuckTableEntry::GetStorage() {
-	return *storage;
-}
-
-TableFunction DuckTableEntry::GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) {
-	bind_data = make_uniq<TableScanBindData>(*this);
-	return TableScanFunction::GetFunction();
-}
-
-vector<ColumnSegmentInfo> DuckTableEntry::GetColumnSegmentInfo() {
-	return storage->GetColumnSegmentInfo();
-}
-
-TableStorageInfo DuckTableEntry::GetStorageInfo(ClientContext &context) {
-	return storage->GetStorageInfo();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp
deleted file mode 100644
index 2c5cb9ae7..000000000
--- a/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-
-namespace duckdb {
-
-IndexCatalogEntry::IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info)
-    : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info.index_name), sql(info.sql), options(info.options),
-      index_type(info.index_type), index_constraint_type(info.constraint_type), column_ids(info.column_ids) {
-
-	this->temporary = info.temporary;
-	this->dependencies = info.dependencies;
-	this->comment = info.comment;
-	for (auto &expr : expressions) {
-		D_ASSERT(expr);
-		expressions.push_back(expr->Copy());
-	}
-	for (auto &parsed_expr : info.parsed_expressions) {
-		D_ASSERT(parsed_expr);
-		parsed_expressions.push_back(parsed_expr->Copy());
-	}
-}
-
-unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
-	auto result = make_uniq<CreateIndexInfo>();
-	result->schema = GetSchemaName();
-	result->table = GetTableName();
-
-	result->temporary = temporary;
-	result->sql = sql;
-	result->index_name = name;
-	result->index_type = index_type;
-	result->constraint_type = index_constraint_type;
-	result->column_ids = column_ids;
-	result->dependencies = dependencies;
-
-	for (auto &expr : expressions) {
-		result->expressions.push_back(expr->Copy());
-	}
-	for (auto &expr : parsed_expressions) {
-		result->parsed_expressions.push_back(expr->Copy());
-	}
-
-	result->comment = comment;
-	result->tags = tags;
-
-	return std::move(result);
-}
-
-string IndexCatalogEntry::ToSQL() const {
-	auto info = GetInfo();
-	return info->ToString();
-}
-
-bool IndexCatalogEntry::IsUnique() const {
-	return (index_constraint_type == IndexConstraintType::UNIQUE ||
-	        index_constraint_type == IndexConstraintType::PRIMARY);
-}
-
-bool IndexCatalogEntry::IsPrimary() const {
-	return (index_constraint_type == IndexConstraintType::PRIMARY);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp
deleted file mode 100644
index 6aa9a52c3..000000000
--- a/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/function/scalar_macro_function.hpp"
-
-namespace duckdb {
-
-MacroCatalogEntry::MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
-    : FunctionEntry(
-          (info.macros[0]->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
-          catalog, schema, info),
-      macros(std::move(info.macros)) {
-	this->temporary = info.temporary;
-	this->internal = info.internal;
-	this->dependencies = info.dependencies;
-	this->comment = info.comment;
-	this->tags = info.tags;
-}
-
-ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
-    : MacroCatalogEntry(catalog, schema, info) {
-}
-
-unique_ptr<CatalogEntry> ScalarMacroCatalogEntry::Copy(ClientContext &context) const {
-	auto info_copy = GetInfo();
-	auto &cast_info = info_copy->Cast<CreateMacroInfo>();
-	auto result = make_uniq<ScalarMacroCatalogEntry>(catalog, schema, cast_info);
-	return std::move(result);
-}
-
-TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
-    : MacroCatalogEntry(catalog, schema, info) {
-}
-
-unique_ptr<CatalogEntry> TableMacroCatalogEntry::Copy(ClientContext &context) const {
-	auto info_copy = GetInfo();
-	auto &cast_info = info_copy->Cast<CreateMacroInfo>();
-	auto result = make_uniq<TableMacroCatalogEntry>(catalog, schema, cast_info);
-	return std::move(result);
-}
-
-unique_ptr<CreateInfo> MacroCatalogEntry::GetInfo() const {
-	auto info = make_uniq<CreateMacroInfo>(type);
-	info->catalog = catalog.GetName();
-	info->schema = schema.name;
-	info->name = name;
-	for (auto &function : macros) {
-		info->macros.push_back(function->Copy());
-	}
-	info->dependencies = dependencies;
-	info->comment = comment;
-	info->tags = tags;
-	return std::move(info);
-}
-
-string MacroCatalogEntry::ToSQL() const {
-	auto create_info = GetInfo();
-	return create_info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/pragma_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/pragma_function_catalog_entry.cpp
deleted file mode 100644
index ff247dcb0..000000000
--- a/src/duckdb/src/catalog/catalog_entry/pragma_function_catalog_entry.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-
-namespace duckdb {
-
-PragmaFunctionCatalogEntry::PragmaFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
-                                                       CreatePragmaFunctionInfo &info)
-    : FunctionEntry(CatalogType::PRAGMA_FUNCTION_ENTRY, catalog, schema, info), functions(std::move(info.functions)) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp
deleted file mode 100644
index f983fb762..000000000
--- a/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
-
-namespace duckdb {
-
-ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
-                                                       CreateScalarFunctionInfo &info)
-    : FunctionEntry(CatalogType::SCALAR_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) {
-}
-
-unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
-	if (info.type != AlterType::ALTER_SCALAR_FUNCTION) {
-		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter type");
-	}
-	auto &function_info = info.Cast<AlterScalarFunctionInfo>();
-	if (function_info.alter_scalar_function_type != AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS) {
-		throw InternalException(
-		    "Attempting to alter ScalarFunctionCatalogEntry with unsupported alter scalar function type");
-	}
-	auto &add_overloads = function_info.Cast<AddScalarFunctionOverloadInfo>();
-
-	ScalarFunctionSet new_set = functions;
-	if (!new_set.MergeFunctionSet(add_overloads.new_overloads->functions, true)) {
-		throw BinderException(
-		    "Failed to add new function overloads to function \"%s\": function overload already exists", name);
-	}
-	CreateScalarFunctionInfo new_info(std::move(new_set));
-	new_info.internal = internal;
-	new_info.descriptions = descriptions;
-	new_info.descriptions.insert(new_info.descriptions.end(), add_overloads.new_overloads->descriptions.begin(),
-	                             add_overloads.new_overloads->descriptions.end());
-	return make_uniq<ScalarFunctionCatalogEntry>(catalog, schema, new_info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp
deleted file mode 100644
index ef14221ff..000000000
--- a/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/default/default_schemas.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-SchemaCatalogEntry::SchemaCatalogEntry(Catalog &catalog, CreateSchemaInfo &info)
-    : InCatalogEntry(CatalogType::SCHEMA_ENTRY, catalog, info.schema) {
-	this->internal = info.internal;
-	this->comment = info.comment;
-	this->tags = info.tags;
-}
-
-CatalogTransaction SchemaCatalogEntry::GetCatalogTransaction(ClientContext &context) {
-	return CatalogTransaction(catalog, context);
-}
-
-optional_ptr<CatalogEntry> SchemaCatalogEntry::CreateIndex(ClientContext &context, CreateIndexInfo &info,
-                                                           TableCatalogEntry &table) {
-	return CreateIndex(GetCatalogTransaction(context), info, table);
-}
-
-SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
-                                                        const string &name) {
-	SimilarCatalogEntry result;
-	Scan(transaction.GetContext(), type, [&](CatalogEntry &entry) {
-		auto entry_score = StringUtil::SimilarityRating(entry.name, name);
-		if (entry_score > result.score) {
-			result.score = entry_score;
-			result.name = entry.name;
-		}
-	});
-	return result;
-}
-
-//! This should not be used, it's only implemented to not put the burden of implementing it on every derived class of
-//! SchemaCatalogEntry
-CatalogSet::EntryLookup SchemaCatalogEntry::GetEntryDetailed(CatalogTransaction transaction, CatalogType type,
-                                                             const string &name) {
-	CatalogSet::EntryLookup result;
-	result.result = GetEntry(transaction, type, name);
-	if (!result.result) {
-		result.reason = CatalogSet::EntryLookup::FailureReason::DELETED;
-	} else {
-		result.reason = CatalogSet::EntryLookup::FailureReason::SUCCESS;
-	}
-	return result;
-}
-
-unique_ptr<CreateInfo> SchemaCatalogEntry::GetInfo() const {
-	auto result = make_uniq<CreateSchemaInfo>();
-	result->schema = name;
-	result->comment = comment;
-	result->tags = tags;
-	return std::move(result);
-}
-
-string SchemaCatalogEntry::ToSQL() const {
-	auto create_schema_info = GetInfo();
-	return create_schema_info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp
deleted file mode 100644
index 085048b0a..000000000
--- a/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-#include <algorithm>
-#include <sstream>
-
-namespace duckdb {
-
-SequenceData::SequenceData(CreateSequenceInfo &info)
-    : usage_count(info.usage_count), counter(info.start_value), last_value(info.start_value), increment(info.increment),
-      start_value(info.start_value), min_value(info.min_value), max_value(info.max_value), cycle(info.cycle) {
-}
-
-SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info)
-    : StandardEntry(CatalogType::SEQUENCE_ENTRY, schema, catalog, info.name), data(info) {
-	this->temporary = info.temporary;
-	this->comment = info.comment;
-	this->tags = info.tags;
-}
-
-unique_ptr<CatalogEntry> SequenceCatalogEntry::Copy(ClientContext &context) const {
-	auto info_copy = GetInfo();
-	auto &cast_info = info_copy->Cast<CreateSequenceInfo>();
-
-	auto result = make_uniq<SequenceCatalogEntry>(catalog, schema, cast_info);
-	result->data = GetData();
-
-	return std::move(result);
-}
-
-SequenceData SequenceCatalogEntry::GetData() const {
-	lock_guard<mutex> seqlock(lock);
-	return data;
-}
-
-int64_t SequenceCatalogEntry::CurrentValue() {
-	lock_guard<mutex> seqlock(lock);
-	int64_t result;
-	if (data.usage_count == 0u) {
-		throw SequenceException("currval: sequence is not yet defined in this session");
-	}
-	result = data.last_value;
-	return result;
-}
-
-int64_t SequenceCatalogEntry::NextValue(DuckTransaction &transaction) {
-	lock_guard<mutex> seqlock(lock);
-	int64_t result;
-	result = data.counter;
-	bool overflow = !TryAddOperator::Operation(data.counter, data.increment, data.counter);
-	if (data.cycle) {
-		if (overflow) {
-			data.counter = data.increment < 0 ? data.max_value : data.min_value;
-		} else if (data.counter < data.min_value) {
-			data.counter = data.max_value;
-		} else if (data.counter > data.max_value) {
-			data.counter = data.min_value;
-		}
-	} else {
-		if (result < data.min_value || (overflow && data.increment < 0)) {
-			throw SequenceException("nextval: reached minimum value of sequence \"%s\" (%lld)", name, data.min_value);
-		}
-		if (result > data.max_value || overflow) {
-			throw SequenceException("nextval: reached maximum value of sequence \"%s\" (%lld)", name, data.max_value);
-		}
-	}
-	data.last_value = result;
-	data.usage_count++;
-	if (!temporary) {
-		transaction.PushSequenceUsage(*this, data);
-	}
-	return result;
-}
-
-void SequenceCatalogEntry::ReplayValue(uint64_t v_usage_count, int64_t v_counter) {
-	if (v_usage_count > data.usage_count) {
-		data.usage_count = v_usage_count;
-		data.counter = v_counter;
-	}
-}
-
-unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
-	auto seq_data = GetData();
-
-	auto result = make_uniq<CreateSequenceInfo>();
-	result->catalog = catalog.GetName();
-	result->schema = schema.name;
-	result->name = name;
-	result->usage_count = seq_data.usage_count;
-	result->increment = seq_data.increment;
-	result->min_value = seq_data.min_value;
-	result->max_value = seq_data.max_value;
-	result->start_value = seq_data.counter;
-	result->cycle = seq_data.cycle;
-	result->dependencies = dependencies;
-	result->comment = comment;
-	result->tags = tags;
-	return std::move(result);
-}
-
-string SequenceCatalogEntry::ToSQL() const {
-	auto seq_data = GetData();
-
-	std::stringstream ss;
-	ss << "CREATE SEQUENCE ";
-	ss << name;
-	ss << " INCREMENT BY " << seq_data.increment;
-	ss << " MINVALUE " << seq_data.min_value;
-	ss << " MAXVALUE " << seq_data.max_value;
-	ss << " START " << seq_data.counter;
-	ss << " " << (seq_data.cycle ? "CYCLE" : "NO CYCLE") << ";";
-	return ss.str();
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp
deleted file mode 100644
index 3070b2e30..000000000
--- a/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp
+++ /dev/null
@@ -1,335 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-TableCatalogEntry::TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info)
-    : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info.table), columns(std::move(info.columns)),
-      constraints(std::move(info.constraints)) {
-	this->temporary = info.temporary;
-	this->dependencies = info.dependencies;
-	this->comment = info.comment;
-	this->tags = info.tags;
-}
-
-bool TableCatalogEntry::HasGeneratedColumns() const {
-	return columns.LogicalColumnCount() != columns.PhysicalColumnCount();
-}
-
-LogicalIndex TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exists) const {
-	auto entry = columns.GetColumnIndex(column_name);
-	if (!entry.IsValid()) {
-		if (if_exists) {
-			return entry;
-		}
-		throw BinderException("Table \"%s\" does not have a column with name \"%s\"", name, column_name);
-	}
-	return entry;
-}
-
-unique_ptr<BlockingSample> TableCatalogEntry::GetSample() {
-	return nullptr;
-}
-
-bool TableCatalogEntry::ColumnExists(const string &name) const {
-	return columns.ColumnExists(name);
-}
-
-const ColumnDefinition &TableCatalogEntry::GetColumn(const string &name) const {
-	return columns.GetColumn(name);
-}
-
-vector<LogicalType> TableCatalogEntry::GetTypes() const {
-	vector<LogicalType> types;
-	for (auto &col : columns.Physical()) {
-		types.push_back(col.Type());
-	}
-	return types;
-}
-
-unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
-	auto result = make_uniq<CreateTableInfo>();
-	result->catalog = catalog.GetName();
-	result->schema = schema.name;
-	result->table = name;
-	result->columns = columns.Copy();
-	result->constraints.reserve(constraints.size());
-	result->dependencies = dependencies;
-	std::for_each(constraints.begin(), constraints.end(),
-	              [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
-	result->comment = comment;
-	result->tags = tags;
-	return std::move(result);
-}
-
-string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
-	std::stringstream ss;
-
-	ss << "(";
-
-	// find all columns that have NOT NULL specified, but are NOT primary key columns
-	logical_index_set_t not_null_columns;
-	logical_index_set_t unique_columns;
-	logical_index_set_t pk_columns;
-	unordered_set<string> multi_key_pks;
-	vector<string> extra_constraints;
-	for (auto &constraint : constraints) {
-		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = constraint->Cast<NotNullConstraint>();
-			not_null_columns.insert(not_null.index);
-		} else if (constraint->type == ConstraintType::UNIQUE) {
-			auto &pk = constraint->Cast<UniqueConstraint>();
-			if (pk.HasIndex()) {
-				// no columns specified: single column constraint
-				if (pk.IsPrimaryKey()) {
-					pk_columns.insert(pk.GetIndex());
-				} else {
-					unique_columns.insert(pk.GetIndex());
-				}
-			} else {
-				// multi-column constraint, this constraint needs to go at the end after all columns
-				if (pk.IsPrimaryKey()) {
-					// multi key pk column: insert set of columns into multi_key_pks
-					for (auto &col : pk.GetColumnNames()) {
-						multi_key_pks.insert(col);
-					}
-				}
-				extra_constraints.push_back(constraint->ToString());
-			}
-		} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			auto &fk = constraint->Cast<ForeignKeyConstraint>();
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
-			    fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				extra_constraints.push_back(constraint->ToString());
-			}
-		} else {
-			extra_constraints.push_back(constraint->ToString());
-		}
-	}
-
-	for (auto &column : columns.Logical()) {
-		if (column.Oid() > 0) {
-			ss << ", ";
-		}
-		ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
-		auto &column_type = column.Type();
-		if (column_type.id() != LogicalTypeId::ANY) {
-			ss << column.Type().ToString();
-		}
-		auto extra_type_info = column_type.AuxInfo();
-		if (extra_type_info && extra_type_info->type == ExtraTypeInfoType::STRING_TYPE_INFO) {
-			auto &string_info = extra_type_info->Cast<StringTypeInfo>();
-			if (!string_info.collation.empty()) {
-				ss << " COLLATE " + string_info.collation;
-			}
-		}
-		bool not_null = not_null_columns.find(column.Logical()) != not_null_columns.end();
-		bool is_single_key_pk = pk_columns.find(column.Logical()) != pk_columns.end();
-		bool is_multi_key_pk = multi_key_pks.find(column.Name()) != multi_key_pks.end();
-		bool is_unique = unique_columns.find(column.Logical()) != unique_columns.end();
-		if (column.Generated()) {
-			reference<const ParsedExpression> generated_expression = column.GeneratedExpression();
-			if (column_type.id() != LogicalTypeId::ANY) {
-				// We artificially add a cast if the type is specified, need to strip it
-				auto &expr = generated_expression.get();
-				D_ASSERT(expr.GetExpressionType() == ExpressionType::OPERATOR_CAST);
-				auto &cast_expr = expr.Cast<CastExpression>();
-				D_ASSERT(cast_expr.cast_type.id() == column_type.id());
-				generated_expression = *cast_expr.child;
-			}
-			ss << " GENERATED ALWAYS AS(" << generated_expression.get().ToString() << ")";
-		} else if (column.HasDefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue().ToString() << ")";
-		}
-		if (not_null && !is_single_key_pk && !is_multi_key_pk) {
-			// NOT NULL but not a primary key column
-			ss << " NOT NULL";
-		}
-		if (is_single_key_pk) {
-			// single column pk: insert constraint here
-			ss << " PRIMARY KEY";
-		}
-		if (is_unique) {
-			// single column unique: insert constraint here
-			ss << " UNIQUE";
-		}
-	}
-	// print any extra constraints that still need to be printed
-	for (auto &extra_constraint : extra_constraints) {
-		ss << ", ";
-		ss << extra_constraint;
-	}
-
-	ss << ")";
-	return ss.str();
-}
-
-string TableCatalogEntry::ColumnNamesToSQL(const ColumnList &columns) {
-	if (columns.empty()) {
-		return "";
-	}
-
-	std::stringstream ss;
-	ss << "(";
-
-	for (auto &column : columns.Logical()) {
-		if (column.Oid() > 0) {
-			ss << ", ";
-		}
-		ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
-	}
-	ss << ")";
-	return ss.str();
-}
-
-string TableCatalogEntry::ToSQL() const {
-	auto create_info = GetInfo();
-	return create_info->ToString();
-}
-
-const ColumnList &TableCatalogEntry::GetColumns() const {
-	return columns;
-}
-
-const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) const {
-	return columns.GetColumn(idx);
-}
-
-const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() const {
-	return constraints;
-}
-
-// LCOV_EXCL_START
-DataTable &TableCatalogEntry::GetStorage() {
-	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
-}
-// LCOV_EXCL_STOP
-
-static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-                             physical_index_set_t &bound_columns) {
-	if (bound_columns.size() <= 1) {
-		return;
-	}
-	idx_t found_column_count = 0;
-	physical_index_set_t found_columns;
-	for (idx_t i = 0; i < update.columns.size(); i++) {
-		if (bound_columns.find(update.columns[i]) != bound_columns.end()) {
-			// this column is referenced in the CHECK constraint
-			found_column_count++;
-			found_columns.insert(update.columns[i]);
-		}
-	}
-	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
-		// columns in this CHECK constraint were referenced, but not all were part of the UPDATE
-		// add them to the scan and update set
-		for (auto &check_column_id : bound_columns) {
-			if (found_columns.find(check_column_id) != found_columns.end()) {
-				// column is already projected
-				continue;
-			}
-			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
-			auto &column = table.GetColumns().GetColumn(check_column_id);
-			update.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
-			proj.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(get.table_index, get.GetColumnIds().size())));
-			get.AddColumnId(check_column_id.index);
-			update.columns.push_back(check_column_id);
-		}
-	}
-}
-
-vector<ColumnSegmentInfo> TableCatalogEntry::GetColumnSegmentInfo() {
-	return {};
-}
-
-void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, LogicalProjection &proj,
-                                              LogicalUpdate &update, ClientContext &context) {
-	// check the constraints and indexes of the table to see if we need to project any additional columns
-	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
-	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
-	// if we are only updating one of the two columns we add the other one to the UPDATE set
-	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
-	auto bound_constraints = binder.BindConstraints(constraints, name, columns);
-	for (auto &constraint : bound_constraints) {
-		if (constraint->type == ConstraintType::CHECK) {
-			auto &check = constraint->Cast<BoundCheckConstraint>();
-			// check constraint! check if we need to add any extra columns to the UPDATE clause
-			BindExtraColumns(*this, get, proj, update, check.bound_columns);
-		}
-	}
-	if (update.return_chunk) {
-		physical_index_set_t all_columns;
-		for (auto &column : GetColumns().Physical()) {
-			all_columns.insert(column.Physical());
-		}
-		BindExtraColumns(*this, get, proj, update, all_columns);
-	}
-	// for index updates we always turn any update into an insert and a delete
-	// we thus need all the columns to be available, hence we check if the update touches any index columns
-	// If the returning keyword is used, we need access to the whole row in case the user requests it.
-	// Therefore switch the update to a delete and insert.
-	update.update_is_del_and_insert = false;
-	TableStorageInfo table_storage_info = GetStorageInfo(context);
-	for (auto index : table_storage_info.index_info) {
-		for (auto &column : update.columns) {
-			if (index.column_set.find(column.index) != index.column_set.end()) {
-				update.update_is_del_and_insert = true;
-				break;
-			}
-		}
-	};
-
-	// we also convert any updates on LIST columns into delete + insert
-	for (auto &col_index : update.columns) {
-		auto &column = GetColumns().GetColumn(col_index);
-		if (!column.Type().SupportsRegularUpdate()) {
-			update.update_is_del_and_insert = true;
-			break;
-		}
-	}
-
-	if (update.update_is_del_and_insert) {
-		// the update updates a column required by an index or requires returning the updated rows,
-		// push projections for all columns
-		physical_index_set_t all_columns;
-		for (auto &column : GetColumns().Physical()) {
-			all_columns.insert(column.Physical());
-		}
-		BindExtraColumns(*this, get, proj, update, all_columns);
-	}
-}
-
-optional_ptr<Constraint> TableCatalogEntry::GetPrimaryKey() const {
-	for (const auto &constraint : GetConstraints()) {
-		if (constraint->type == ConstraintType::UNIQUE) {
-			auto &unique = constraint->Cast<UniqueConstraint>();
-			if (unique.IsPrimaryKey()) {
-				return &unique;
-			}
-		}
-	}
-	return nullptr;
-}
-
-bool TableCatalogEntry::HasPrimaryKey() const {
-	return GetPrimaryKey() != nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp
deleted file mode 100644
index 9b80a1d5d..000000000
--- a/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
-
-namespace duckdb {
-
-TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
-                                                     CreateTableFunctionInfo &info)
-    : FunctionEntry(CatalogType::TABLE_FUNCTION_ENTRY, catalog, schema, info), functions(std::move(info.functions)) {
-	D_ASSERT(this->functions.Size() > 0);
-}
-
-unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
-	if (info.type != AlterType::ALTER_TABLE_FUNCTION) {
-		throw InternalException("Attempting to alter TableFunctionCatalogEntry with unsupported alter type");
-	}
-	auto &function_info = info.Cast<AlterTableFunctionInfo>();
-	if (function_info.alter_table_function_type != AlterTableFunctionType::ADD_FUNCTION_OVERLOADS) {
-		throw InternalException(
-		    "Attempting to alter TableFunctionCatalogEntry with unsupported alter table function type");
-	}
-	auto &add_overloads = function_info.Cast<AddTableFunctionOverloadInfo>();
-
-	TableFunctionSet new_set = functions;
-	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {
-		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
-	}
-	CreateTableFunctionInfo new_info(std::move(new_set));
-	return make_uniq<TableFunctionCatalogEntry>(catalog, schema, new_info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp
deleted file mode 100644
index be9c24834..000000000
--- a/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-#include <algorithm>
-#include <sstream>
-
-namespace duckdb {
-
-TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info)
-    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info.name), user_type(info.type),
-      bind_function(info.bind_function) {
-	this->temporary = info.temporary;
-	this->internal = info.internal;
-	this->dependencies = info.dependencies;
-	this->comment = info.comment;
-	this->tags = info.tags;
-}
-
-unique_ptr<CatalogEntry> TypeCatalogEntry::Copy(ClientContext &context) const {
-	auto info_copy = GetInfo();
-	auto &cast_info = info_copy->Cast<CreateTypeInfo>();
-	auto result = make_uniq<TypeCatalogEntry>(catalog, schema, cast_info);
-	return std::move(result);
-}
-
-unique_ptr<CreateInfo> TypeCatalogEntry::GetInfo() const {
-	auto result = make_uniq<CreateTypeInfo>();
-	result->catalog = catalog.GetName();
-	result->schema = schema.name;
-	result->name = name;
-	result->type = user_type;
-	result->dependencies = dependencies;
-	result->comment = comment;
-	result->tags = tags;
-	result->bind_function = bind_function;
-	return std::move(result);
-}
-
-string TypeCatalogEntry::ToSQL() const {
-	std::stringstream ss;
-	ss << "CREATE TYPE ";
-	ss << KeywordHelper::WriteOptionallyQuoted(name);
-	ss << " AS ";
-
-	auto user_type_copy = user_type;
-
-	// Strip off the potential alias so ToString doesn't just output the alias
-	user_type_copy.SetAlias("");
-	D_ASSERT(user_type_copy.GetAlias().empty());
-
-	ss << user_type_copy.ToString();
-	ss << ";";
-	return ss.str();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp
deleted file mode 100644
index 9f029f214..000000000
--- a/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
-#include "duckdb/common/limits.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-void ViewCatalogEntry::Initialize(CreateViewInfo &info) {
-	query = std::move(info.query);
-	this->aliases = info.aliases;
-	this->types = info.types;
-	this->names = info.names;
-	this->temporary = info.temporary;
-	this->sql = info.sql;
-	this->internal = info.internal;
-	this->dependencies = info.dependencies;
-	this->comment = info.comment;
-	this->tags = info.tags;
-	this->column_comments = info.column_comments;
-}
-
-ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info)
-    : StandardEntry(CatalogType::VIEW_ENTRY, schema, catalog, info.view_name) {
-	Initialize(info);
-}
-
-unique_ptr<CreateInfo> ViewCatalogEntry::GetInfo() const {
-	auto result = make_uniq<CreateViewInfo>();
-	result->schema = schema.name;
-	result->view_name = name;
-	result->sql = sql;
-	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-	result->aliases = aliases;
-	result->names = names;
-	result->types = types;
-	result->temporary = temporary;
-	result->dependencies = dependencies;
-	result->comment = comment;
-	result->tags = tags;
-	result->column_comments = column_comments;
-	return std::move(result);
-}
-
-unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
-	D_ASSERT(!internal);
-
-	// Column comments have a special alter type
-	if (info.type == AlterType::SET_COLUMN_COMMENT) {
-		auto &comment_on_column_info = info.Cast<SetColumnCommentInfo>();
-		auto copied_view = Copy(context);
-
-		for (idx_t i = 0; i < names.size(); i++) {
-			const auto &col_name = names[i];
-			if (col_name == comment_on_column_info.column_name) {
-				auto &copied_view_entry = copied_view->Cast<ViewCatalogEntry>();
-
-				// If vector is empty, we need to initialize it on setting here
-				if (copied_view_entry.column_comments.empty()) {
-					copied_view_entry.column_comments = vector<Value>(copied_view_entry.types.size());
-				}
-
-				copied_view_entry.column_comments[i] = comment_on_column_info.comment_value;
-				return copied_view;
-			}
-		}
-		throw BinderException("View \"%s\" does not have a column with name \"%s\"", name,
-		                      comment_on_column_info.column_name);
-	}
-
-	if (info.type != AlterType::ALTER_VIEW) {
-		throw CatalogException("Can only modify view with ALTER VIEW statement");
-	}
-	auto &view_info = info.Cast<AlterViewInfo>();
-	switch (view_info.alter_view_type) {
-	case AlterViewType::RENAME_VIEW: {
-		auto &rename_info = view_info.Cast<RenameViewInfo>();
-		auto copied_view = Copy(context);
-		copied_view->name = rename_info.new_view_name;
-		return copied_view;
-	}
-	default:
-		throw InternalException("Unrecognized alter view type!");
-	}
-}
-
-string ViewCatalogEntry::ToSQL() const {
-	if (sql.empty()) {
-		//! Return empty sql with view name so pragma view_tables don't complain
-		return sql;
-	}
-	auto info = GetInfo();
-	auto result = info->ToString();
-	return result;
-}
-
-unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) const {
-	D_ASSERT(!internal);
-	auto create_info = GetInfo();
-
-	return make_uniq<ViewCatalogEntry>(catalog, schema, create_info->Cast<CreateViewInfo>());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_entry_retriever.cpp b/src/duckdb/src/catalog/catalog_entry_retriever.cpp
deleted file mode 100644
index c37562d72..000000000
--- a/src/duckdb/src/catalog/catalog_entry_retriever.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#include "duckdb/catalog/catalog_entry_retriever.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-LogicalType CatalogEntryRetriever::GetType(Catalog &catalog, const string &schema, const string &name,
-                                           OnEntryNotFound on_entry_not_found) {
-	QueryErrorContext error_context;
-	auto result = GetEntry(CatalogType::TYPE_ENTRY, catalog, schema, name, on_entry_not_found, error_context);
-	if (!result) {
-		return LogicalType::INVALID;
-	}
-	auto &type_entry = result->Cast<TypeCatalogEntry>();
-	return type_entry.user_type;
-}
-
-LogicalType CatalogEntryRetriever::GetType(const string &catalog, const string &schema, const string &name,
-                                           OnEntryNotFound on_entry_not_found) {
-	QueryErrorContext error_context;
-	auto result = GetEntry(CatalogType::TYPE_ENTRY, catalog, schema, name, on_entry_not_found, error_context);
-	if (!result) {
-		return LogicalType::INVALID;
-	}
-	auto &type_entry = result->Cast<TypeCatalogEntry>();
-	return type_entry.user_type;
-}
-
-optional_ptr<CatalogEntry> CatalogEntryRetriever::GetEntry(CatalogType type, const string &catalog,
-                                                           const string &schema, const string &name,
-                                                           OnEntryNotFound on_entry_not_found,
-                                                           QueryErrorContext error_context) {
-	return ReturnAndCallback(Catalog::GetEntry(*this, type, catalog, schema, name, on_entry_not_found, error_context));
-}
-
-optional_ptr<SchemaCatalogEntry> CatalogEntryRetriever::GetSchema(const string &catalog, const string &name,
-                                                                  OnEntryNotFound on_entry_not_found,
-                                                                  QueryErrorContext error_context) {
-	auto result = Catalog::GetSchema(*this, catalog, name, on_entry_not_found, error_context);
-	if (!result) {
-		return result;
-	}
-	if (callback) {
-		// Call the callback if it's set
-		callback(*result);
-	}
-	return result;
-}
-
-optional_ptr<CatalogEntry> CatalogEntryRetriever::GetEntry(CatalogType type, Catalog &catalog, const string &schema,
-                                                           const string &name, OnEntryNotFound on_entry_not_found,
-                                                           QueryErrorContext error_context) {
-	return ReturnAndCallback(catalog.GetEntry(*this, type, schema, name, on_entry_not_found, error_context));
-}
-
-optional_ptr<CatalogEntry> CatalogEntryRetriever::ReturnAndCallback(optional_ptr<CatalogEntry> result) {
-	if (!result) {
-		return result;
-	}
-	if (callback) {
-		// Call the callback if it's set
-		callback(*result);
-	}
-	return result;
-}
-
-void CatalogEntryRetriever::Inherit(const CatalogEntryRetriever &parent) {
-	this->callback = parent.callback;
-	this->search_path = parent.search_path;
-}
-
-CatalogSearchPath &CatalogEntryRetriever::GetSearchPath() {
-	if (search_path) {
-		return *search_path;
-	}
-	return *ClientData::Get(context).catalog_search_path;
-}
-
-void CatalogEntryRetriever::SetSearchPath(vector<CatalogSearchEntry> entries) {
-	vector<CatalogSearchEntry> new_path;
-	for (auto &entry : entries) {
-		if (IsInvalidCatalog(entry.catalog) || entry.catalog == SYSTEM_CATALOG || entry.catalog == TEMP_CATALOG) {
-			continue;
-		}
-		new_path.push_back(std::move(entry));
-	}
-	if (new_path.empty()) {
-		return;
-	}
-
-	// push the set paths from the ClientContext behind the provided paths
-	auto &client_search_path = *ClientData::Get(context).catalog_search_path;
-	auto &set_paths = client_search_path.GetSetPaths();
-	for (auto path : set_paths) {
-		if (IsInvalidCatalog(path.catalog)) {
-			path.catalog = DatabaseManager::GetDefaultDatabase(context);
-		}
-		new_path.push_back(std::move(path));
-	}
-
-	this->search_path = make_shared_ptr<CatalogSearchPath>(context, std::move(new_path));
-}
-
-void CatalogEntryRetriever::SetCallback(catalog_entry_callback_t callback) {
-	this->callback = std::move(callback);
-}
-
-catalog_entry_callback_t CatalogEntryRetriever::GetCallback() {
-	return callback;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_search_path.cpp b/src/duckdb/src/catalog/catalog_search_path.cpp
deleted file mode 100644
index dcf2569d8..000000000
--- a/src/duckdb/src/catalog/catalog_search_path.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/catalog/default/default_schemas.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database_manager.hpp"
-
-namespace duckdb {
-
-CatalogSearchEntry::CatalogSearchEntry(string catalog_p, string schema_p)
-    : catalog(std::move(catalog_p)), schema(std::move(schema_p)) {
-}
-
-string CatalogSearchEntry::ToString() const {
-	if (catalog.empty()) {
-		return WriteOptionallyQuoted(schema);
-	} else {
-		return WriteOptionallyQuoted(catalog) + "." + WriteOptionallyQuoted(schema);
-	}
-}
-
-string CatalogSearchEntry::WriteOptionallyQuoted(const string &input) {
-	for (idx_t i = 0; i < input.size(); i++) {
-		if (input[i] == '.' || input[i] == ',') {
-			return "\"" + input + "\"";
-		}
-	}
-	return input;
-}
-
-string CatalogSearchEntry::ListToString(const vector<CatalogSearchEntry> &input) {
-	string result;
-	for (auto &entry : input) {
-		if (!result.empty()) {
-			result += ",";
-		}
-		result += entry.ToString();
-	}
-	return result;
-}
-
-CatalogSearchEntry CatalogSearchEntry::ParseInternal(const string &input, idx_t &idx) {
-	string catalog;
-	string schema;
-	string entry;
-	bool finished = false;
-normal:
-	for (; idx < input.size(); idx++) {
-		if (input[idx] == '"') {
-			idx++;
-			goto quoted;
-		} else if (input[idx] == '.') {
-			goto separator;
-		} else if (input[idx] == ',') {
-			finished = true;
-			goto separator;
-		}
-		entry += input[idx];
-	}
-	finished = true;
-	goto separator;
-quoted:
-	//! look for another quote
-	for (; idx < input.size(); idx++) {
-		if (input[idx] == '"') {
-			//! unquote
-			idx++;
-			if (idx < input.size() && input[idx] == '"') {
-				// escaped quote
-				entry += input[idx];
-				continue;
-			}
-			goto normal;
-		}
-		entry += input[idx];
-	}
-	throw ParserException("Unterminated quote in qualified name!");
-separator:
-	if (entry.empty()) {
-		throw ParserException("Unexpected dot - empty CatalogSearchEntry");
-	}
-	if (schema.empty()) {
-		// if we parse one entry it is the schema
-		schema = std::move(entry);
-	} else if (catalog.empty()) {
-		// if we parse two entries it is [catalog.schema]
-		catalog = std::move(schema);
-		schema = std::move(entry);
-	} else {
-		throw ParserException("Too many dots - expected [schema] or [catalog.schema] for CatalogSearchEntry");
-	}
-	entry = "";
-	idx++;
-	if (finished) {
-		goto final;
-	}
-	goto normal;
-final:
-	if (schema.empty()) {
-		throw ParserException("Unexpected end of entry - empty CatalogSearchEntry");
-	}
-	return CatalogSearchEntry(std::move(catalog), std::move(schema));
-}
-
-CatalogSearchEntry CatalogSearchEntry::Parse(const string &input) {
-	idx_t pos = 0;
-	auto result = ParseInternal(input, pos);
-	if (pos < input.size()) {
-		throw ParserException("Failed to convert entry \"%s\" to CatalogSearchEntry - expected a single entry", input);
-	}
-	return result;
-}
-
-vector<CatalogSearchEntry> CatalogSearchEntry::ParseList(const string &input) {
-	idx_t pos = 0;
-	vector<CatalogSearchEntry> result;
-	while (pos < input.size()) {
-		auto entry = ParseInternal(input, pos);
-		result.push_back(entry);
-	}
-	return result;
-}
-
-CatalogSearchPath::CatalogSearchPath(ClientContext &context_p, vector<CatalogSearchEntry> entries)
-    : context(context_p) {
-	SetPathsInternal(std::move(entries));
-}
-
-CatalogSearchPath::CatalogSearchPath(ClientContext &context_p) : CatalogSearchPath(context_p, {}) {
-}
-
-void CatalogSearchPath::Reset() {
-	vector<CatalogSearchEntry> empty;
-	SetPathsInternal(empty);
-}
-
-string CatalogSearchPath::GetSetName(CatalogSetPathType set_type) {
-	switch (set_type) {
-	case CatalogSetPathType::SET_SCHEMA:
-		return "SET schema";
-	case CatalogSetPathType::SET_SCHEMAS:
-		return "SET search_path";
-	default:
-		throw InternalException("Unrecognized CatalogSetPathType");
-	}
-}
-
-void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type) {
-	if (set_type != CatalogSetPathType::SET_SCHEMAS && new_paths.size() != 1) {
-		throw CatalogException("%s can set only 1 schema. This has %d", GetSetName(set_type), new_paths.size());
-	}
-	for (auto &path : new_paths) {
-		auto schema_entry = Catalog::GetSchema(context, path.catalog, path.schema, OnEntryNotFound::RETURN_NULL);
-		if (schema_entry) {
-			// we are setting a schema - update the catalog and schema
-			if (path.catalog.empty()) {
-				path.catalog = GetDefault().catalog;
-			}
-			continue;
-		}
-		// only schema supplied - check if this is a catalog instead
-		if (path.catalog.empty()) {
-			auto catalog = Catalog::GetCatalogEntry(context, path.schema);
-			if (catalog) {
-				auto schema = catalog->GetSchema(context, DEFAULT_SCHEMA, OnEntryNotFound::RETURN_NULL);
-				if (schema) {
-					path.catalog = std::move(path.schema);
-					path.schema = schema->name;
-					continue;
-				}
-			}
-		}
-		throw CatalogException("%s: No catalog + schema named \"%s\" found.", GetSetName(set_type), path.ToString());
-	}
-	if (set_type == CatalogSetPathType::SET_SCHEMA) {
-		if (new_paths[0].catalog == TEMP_CATALOG || new_paths[0].catalog == SYSTEM_CATALOG) {
-			throw CatalogException("%s cannot be set to internal schema \"%s\"", GetSetName(set_type),
-			                       new_paths[0].catalog);
-		}
-	}
-	SetPathsInternal(std::move(new_paths));
-}
-
-void CatalogSearchPath::Set(CatalogSearchEntry new_value, CatalogSetPathType set_type) {
-	vector<CatalogSearchEntry> new_paths {std::move(new_value)};
-	Set(std::move(new_paths), set_type);
-}
-
-const vector<CatalogSearchEntry> &CatalogSearchPath::Get() {
-	return paths;
-}
-
-string CatalogSearchPath::GetDefaultSchema(const string &catalog) {
-	for (auto &path : paths) {
-		if (path.catalog == TEMP_CATALOG) {
-			continue;
-		}
-		if (StringUtil::CIEquals(path.catalog, catalog)) {
-			return path.schema;
-		}
-	}
-	return DEFAULT_SCHEMA;
-}
-
-string CatalogSearchPath::GetDefaultCatalog(const string &schema) {
-	if (DefaultSchemaGenerator::IsDefaultSchema(schema)) {
-		return SYSTEM_CATALOG;
-	}
-	for (auto &path : paths) {
-		if (path.catalog == TEMP_CATALOG) {
-			continue;
-		}
-		if (StringUtil::CIEquals(path.schema, schema)) {
-			return path.catalog;
-		}
-	}
-	return INVALID_CATALOG;
-}
-
-vector<string> CatalogSearchPath::GetCatalogsForSchema(const string &schema) {
-	vector<string> schemas;
-	if (DefaultSchemaGenerator::IsDefaultSchema(schema)) {
-		schemas.push_back(SYSTEM_CATALOG);
-	} else {
-		for (auto &path : paths) {
-			if (StringUtil::CIEquals(path.schema, schema)) {
-				schemas.push_back(path.catalog);
-			}
-		}
-	}
-	return schemas;
-}
-
-vector<string> CatalogSearchPath::GetSchemasForCatalog(const string &catalog) {
-	vector<string> schemas;
-	for (auto &path : paths) {
-		if (StringUtil::CIEquals(path.catalog, catalog)) {
-			schemas.push_back(path.schema);
-		}
-	}
-	return schemas;
-}
-
-const CatalogSearchEntry &CatalogSearchPath::GetDefault() {
-	const auto &paths = Get();
-	D_ASSERT(paths.size() >= 2);
-	return paths[1];
-}
-
-void CatalogSearchPath::SetPathsInternal(vector<CatalogSearchEntry> new_paths) {
-	this->set_paths = std::move(new_paths);
-
-	paths.clear();
-	paths.reserve(set_paths.size() + 3);
-	paths.emplace_back(TEMP_CATALOG, DEFAULT_SCHEMA);
-	for (auto &path : set_paths) {
-		paths.push_back(path);
-	}
-	paths.emplace_back(INVALID_CATALOG, DEFAULT_SCHEMA);
-	paths.emplace_back(SYSTEM_CATALOG, DEFAULT_SCHEMA);
-	paths.emplace_back(SYSTEM_CATALOG, "pg_catalog");
-}
-
-bool CatalogSearchPath::SchemaInSearchPath(ClientContext &context, const string &catalog_name,
-                                           const string &schema_name) {
-	for (auto &path : paths) {
-		if (!StringUtil::CIEquals(path.schema, schema_name)) {
-			continue;
-		}
-		if (StringUtil::CIEquals(path.catalog, catalog_name)) {
-			return true;
-		}
-		if (IsInvalidCatalog(path.catalog) &&
-		    StringUtil::CIEquals(catalog_name, DatabaseManager::GetDefaultDatabase(context))) {
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_set.cpp b/src/duckdb/src/catalog/catalog_set.cpp
deleted file mode 100644
index b95f85747..000000000
--- a/src/duckdb/src/catalog/catalog_set.cpp
+++ /dev/null
@@ -1,731 +0,0 @@
-#include "duckdb/catalog/catalog_set.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-
-namespace duckdb {
-
-void CatalogEntryMap::AddEntry(unique_ptr<CatalogEntry> entry) {
-	auto name = entry->name;
-
-	if (entries.find(name) != entries.end()) {
-		throw InternalException("Entry with name \"%s\" already exists", name);
-	}
-	entries.insert(make_pair(name, std::move(entry)));
-}
-
-void CatalogEntryMap::UpdateEntry(unique_ptr<CatalogEntry> catalog_entry) {
-	auto name = catalog_entry->name;
-
-	auto entry = entries.find(name);
-	if (entry == entries.end()) {
-		throw InternalException("Entry with name \"%s\" does not exist", name);
-	}
-
-	auto existing = std::move(entry->second);
-	entry->second = std::move(catalog_entry);
-	entry->second->SetChild(std::move(existing));
-}
-
-case_insensitive_tree_t<unique_ptr<CatalogEntry>> &CatalogEntryMap::Entries() {
-	return entries;
-}
-
-void CatalogEntryMap::DropEntry(CatalogEntry &entry) {
-	auto &name = entry.name;
-	auto chain = GetEntry(name);
-	if (!chain) {
-		throw InternalException("Attempting to drop entry with name \"%s\" but no chain with that name exists", name);
-	}
-	auto child = entry.TakeChild();
-	if (!entry.HasParent()) {
-		// This is the top of the chain
-		D_ASSERT(chain.get() == &entry);
-		auto it = entries.find(name);
-		D_ASSERT(it != entries.end());
-
-		// Remove the entry
-		it->second.reset();
-		if (child) {
-			// Replace it with its child
-			it->second = std::move(child);
-		} else {
-			entries.erase(it);
-		}
-	} else {
-		// Just replace the entry with its child
-		auto &parent = entry.Parent();
-		parent.SetChild(std::move(child));
-	}
-}
-
-optional_ptr<CatalogEntry> CatalogEntryMap::GetEntry(const string &name) {
-	auto entry = entries.find(name);
-	if (entry == entries.end()) {
-		return nullptr;
-	}
-	return entry->second.get();
-}
-
-CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults)
-    : catalog(catalog_p.Cast<DuckCatalog>()), defaults(std::move(defaults)) {
-	D_ASSERT(catalog_p.IsDuckCatalog());
-}
-CatalogSet::~CatalogSet() {
-}
-
-bool CatalogSet::StartChain(CatalogTransaction transaction, const string &name, unique_lock<mutex> &read_lock) {
-	D_ASSERT(!map.GetEntry(name));
-
-	// check if there is a default entry
-	auto entry = CreateDefaultEntry(transaction, name, read_lock);
-	if (entry) {
-		return false;
-	}
-
-	// first create a dummy deleted entry
-	// so other transactions will see that instead of the entry that is to be added.
-	auto dummy_node = make_uniq<InCatalogEntry>(CatalogType::INVALID, catalog, name);
-	dummy_node->timestamp = 0;
-	dummy_node->deleted = true;
-	dummy_node->set = this;
-
-	map.AddEntry(std::move(dummy_node));
-	return true;
-}
-
-bool CatalogSet::VerifyVacancy(CatalogTransaction transaction, CatalogEntry &entry) {
-	if (HasConflict(transaction, entry.timestamp)) {
-		// A transaction that is not visible to our snapshot has already made a change to this entry.
-		// Because of Catalog limitations we can't push our change on this, even if the change was made by another
-		// active transaction that might end up being aborted. So we have to cancel this transaction.
-		throw TransactionException("Catalog write-write conflict on create with \"%s\"", entry.name);
-	}
-	// The entry is visible to our snapshot
-	if (!entry.deleted) {
-		return false;
-	}
-	return true;
-}
-
-static bool IsDependencyEntry(CatalogEntry &entry) {
-	return entry.type == CatalogType::DEPENDENCY_ENTRY;
-}
-
-void CatalogSet::CheckCatalogEntryInvariants(CatalogEntry &value, const string &name) {
-	if (value.internal && !catalog.IsSystemCatalog() && name != DEFAULT_SCHEMA) {
-		throw InternalException("Attempting to create internal entry \"%s\" in non-system catalog - internal entries "
-		                        "can only be created in the system catalog",
-		                        name);
-	}
-	if (!value.internal) {
-		if (!value.temporary && catalog.IsSystemCatalog() && !IsDependencyEntry(value)) {
-			throw InternalException(
-			    "Attempting to create non-internal entry \"%s\" in system catalog - the system catalog "
-			    "can only contain internal entries",
-			    name);
-		}
-		if (value.temporary && !catalog.IsTemporaryCatalog()) {
-			throw InternalException("Attempting to create temporary entry \"%s\" in non-temporary catalog", name);
-		}
-		if (!value.temporary && catalog.IsTemporaryCatalog() && name != DEFAULT_SCHEMA) {
-			throw InvalidInputException("Cannot create non-temporary entry \"%s\" in temporary catalog", name);
-		}
-	}
-}
-
-optional_ptr<CatalogEntry> CatalogSet::CreateCommittedEntry(unique_ptr<CatalogEntry> entry) {
-	auto existing_entry = map.GetEntry(entry->name);
-	if (existing_entry) {
-		// Return null if an entry by that name already exists
-		return nullptr;
-	}
-
-	auto catalog_entry = entry.get();
-
-	entry->set = this;
-	// Give the entry commit id 0, so it is visible to all transactions
-	entry->timestamp = 0;
-	map.AddEntry(std::move(entry));
-
-	return catalog_entry;
-}
-
-bool CatalogSet::CreateEntryInternal(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-                                     unique_lock<mutex> &read_lock, bool should_be_empty) {
-	auto entry_value = map.GetEntry(name);
-	if (!entry_value) {
-		// Add a dummy node to start the chain
-		if (!StartChain(transaction, name, read_lock)) {
-			return false;
-		}
-	} else if (should_be_empty) {
-		// Verify that the entry is deleted, not altered by another transaction
-		if (!VerifyVacancy(transaction, *entry_value)) {
-			return false;
-		}
-	}
-
-	// Finally add the new entry to the chain
-	auto value_ptr = value.get();
-	map.UpdateEntry(std::move(value));
-	// Push the old entry in the undo buffer for this transaction, so it can be restored in the event of failure
-	if (transaction.transaction) {
-		DuckTransactionManager::Get(GetCatalog().GetAttached())
-		    .PushCatalogEntry(*transaction.transaction, value_ptr->Child());
-	}
-	return true;
-}
-
-bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-                             const LogicalDependencyList &dependencies) {
-	CheckCatalogEntryInvariants(*value, name);
-
-	// Mark this entry as being created by the current active transaction
-	value->timestamp = transaction.transaction_id;
-	value->set = this;
-	catalog.GetDependencyManager()->AddObject(transaction, *value, dependencies);
-
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-	// lock this catalog set to disallow reading
-	unique_lock<mutex> read_lock(catalog_lock);
-
-	return CreateEntryInternal(transaction, name, std::move(value), read_lock);
-}
-
-bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-                             const LogicalDependencyList &dependencies) {
-	return CreateEntry(catalog.GetCatalogTransaction(context), name, std::move(value), dependencies);
-}
-
-//! This method is used to retrieve an entry for the purpose of making a new version, through an alter/drop/create
-optional_ptr<CatalogEntry> CatalogSet::GetEntryInternal(CatalogTransaction transaction, const string &name) {
-	auto entry_value = map.GetEntry(name);
-	if (!entry_value) {
-		return nullptr;
-	}
-	auto &catalog_entry = *entry_value;
-
-	// Check if this entry is visible to our snapshot
-	if (HasConflict(transaction, catalog_entry.timestamp)) {
-		// We intend to create a new version of the entry.
-		// Another transaction has already made an edit to this catalog entry, because of limitations in the Catalog we
-		// can't create an edit alongside this even if the other transaction might end up getting aborted. So we have to
-		// abort the transaction.
-		throw TransactionException("Catalog write-write conflict on alter with \"%s\"", catalog_entry.name);
-	}
-	// The entry is visible to our snapshot, check if it's deleted
-	if (catalog_entry.deleted) {
-		return nullptr;
-	}
-	return &catalog_entry;
-}
-
-bool CatalogSet::AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo &info) {
-	// lock the catalog for writing
-	unique_lock<mutex> write_lock(catalog.GetWriteLock());
-
-	auto entry = GetEntryInternal(transaction, info.name);
-	if (!entry) {
-		return false;
-	}
-	optional_ptr<CatalogEntry> owner_entry;
-	auto schema = catalog.GetSchema(transaction, info.owner_schema, OnEntryNotFound::RETURN_NULL);
-	if (schema) {
-		vector<CatalogType> entry_types {CatalogType::TABLE_ENTRY, CatalogType::SEQUENCE_ENTRY};
-		for (auto entry_type : entry_types) {
-			owner_entry = schema->GetEntry(transaction, entry_type, info.owner_name);
-			if (owner_entry) {
-				break;
-			}
-		}
-	}
-	if (!owner_entry) {
-		throw CatalogException("CatalogElement \"%s.%s\" does not exist!", info.owner_schema, info.owner_name);
-	}
-	write_lock.unlock();
-	catalog.GetDependencyManager()->AddOwnership(transaction, *owner_entry, *entry);
-	return true;
-}
-
-bool CatalogSet::RenameEntryInternal(CatalogTransaction transaction, CatalogEntry &old, const string &new_name,
-                                     AlterInfo &alter_info, unique_lock<mutex> &read_lock) {
-	auto &original_name = old.name;
-
-	auto &context = *transaction.context;
-	auto entry_value = map.GetEntry(new_name);
-	if (entry_value) {
-		auto &existing_entry = GetEntryForTransaction(transaction, *entry_value);
-		if (!existing_entry.deleted) {
-			// There exists an entry by this name that is not deleted
-			old.UndoAlter(context, alter_info);
-			throw CatalogException("Could not rename \"%s\" to \"%s\": another entry with this name already exists!",
-			                       original_name, new_name);
-		}
-	}
-
-	// Add a RENAMED_ENTRY before adding a DELETED_ENTRY, this makes it so that when this is committed
-	// we know that this was not a DROP statement.
-	auto renamed_tombstone = make_uniq<InCatalogEntry>(CatalogType::RENAMED_ENTRY, old.ParentCatalog(), original_name);
-	renamed_tombstone->timestamp = transaction.transaction_id;
-	renamed_tombstone->deleted = false;
-	renamed_tombstone->set = this;
-	if (!CreateEntryInternal(transaction, original_name, std::move(renamed_tombstone), read_lock,
-	                         /*should_be_empty = */ false)) {
-		return false;
-	}
-	if (!DropEntryInternal(transaction, original_name, false)) {
-		return false;
-	}
-
-	// Add the renamed entry
-	// Start this off with a RENAMED_ENTRY node, for commit/cleanup/rollback purposes
-	auto renamed_node = make_uniq<InCatalogEntry>(CatalogType::RENAMED_ENTRY, catalog, new_name);
-	renamed_node->timestamp = transaction.transaction_id;
-	renamed_node->deleted = false;
-	renamed_node->set = this;
-	return CreateEntryInternal(transaction, new_name, std::move(renamed_node), read_lock);
-}
-
-bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info) {
-	// If the entry does not exist, we error
-	auto entry = GetEntry(transaction, name);
-	if (!entry) {
-		return false;
-	}
-	if (!alter_info.allow_internal && entry->internal) {
-		throw CatalogException("Cannot alter entry \"%s\" because it is an internal system entry", entry->name);
-	}
-
-	unique_ptr<CatalogEntry> value;
-	if (alter_info.type == AlterType::SET_COMMENT) {
-		// Copy the existing entry; we are only changing metadata here
-		if (!transaction.context) {
-			throw InternalException("Cannot AlterEntry::SET_COMMENT without client context");
-		}
-		value = entry->Copy(*transaction.context);
-		value->comment = alter_info.Cast<SetCommentInfo>().comment_value;
-	} else {
-		// Use the existing entry to create the altered entry
-		value = entry->AlterEntry(transaction, alter_info);
-		if (!value) {
-			// alter failed, but did not result in an error
-			return true;
-		}
-	}
-
-	// lock the catalog for writing
-	unique_lock<mutex> write_lock(catalog.GetWriteLock());
-	// lock this catalog set to disallow reading
-	unique_lock<mutex> read_lock(catalog_lock);
-
-	// fetch the entry again before doing the modification
-	// this will catch any write-write conflicts between transactions
-	entry = GetEntryInternal(transaction, name);
-
-	// Mark this entry as being created by this transaction
-	value->timestamp = transaction.transaction_id;
-	value->set = this;
-
-	if (!StringUtil::CIEquals(value->name, entry->name)) {
-		if (!RenameEntryInternal(transaction, *entry, value->name, alter_info, read_lock)) {
-			return false;
-		}
-	}
-	auto new_entry = value.get();
-	map.UpdateEntry(std::move(value));
-
-	// push the old entry in the undo buffer for this transaction
-	if (transaction.transaction) {
-		// serialize the AlterInfo into a temporary buffer
-		MemoryStream stream;
-		BinarySerializer serializer(stream);
-		serializer.Begin();
-		serializer.WriteProperty(100, "column_name", alter_info.GetColumnName());
-		serializer.WriteProperty(101, "alter_info", &alter_info);
-		serializer.End();
-
-		DuckTransactionManager::Get(GetCatalog().GetAttached())
-		    .PushCatalogEntry(*transaction.transaction, new_entry->Child(), stream.GetData(), stream.GetPosition());
-	}
-
-	read_lock.unlock();
-	write_lock.unlock();
-
-	// Check the dependency manager to verify that there are no conflicting dependencies with this alter
-	catalog.GetDependencyManager()->AlterObject(transaction, *entry, *new_entry, alter_info);
-
-	return true;
-}
-
-bool CatalogSet::DropDependencies(CatalogTransaction transaction, const string &name, bool cascade,
-                                  bool allow_drop_internal) {
-	auto entry = GetEntry(transaction, name);
-	if (!entry) {
-		return false;
-	}
-	if (entry->internal && !allow_drop_internal) {
-		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
-	}
-	// check any dependencies of this object
-	D_ASSERT(entry->ParentCatalog().IsDuckCatalog());
-	auto &duck_catalog = entry->ParentCatalog().Cast<DuckCatalog>();
-	duck_catalog.GetDependencyManager()->DropObject(transaction, *entry, cascade);
-	return true;
-}
-
-bool CatalogSet::DropEntryInternal(CatalogTransaction transaction, const string &name, bool allow_drop_internal) {
-	// lock the catalog for writing
-	// we can only delete an entry that exists
-	auto entry = GetEntryInternal(transaction, name);
-	if (!entry) {
-		return false;
-	}
-	if (entry->internal && !allow_drop_internal) {
-		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
-	}
-
-	// create a new tombstone entry and replace the currently stored one
-	// set the timestamp to the timestamp of the current transaction
-	// and point it at the tombstone node
-	auto value = make_uniq<InCatalogEntry>(CatalogType::DELETED_ENTRY, entry->ParentCatalog(), entry->name);
-	value->timestamp = transaction.transaction_id;
-	value->set = this;
-	value->deleted = true;
-	auto value_ptr = value.get();
-	map.UpdateEntry(std::move(value));
-
-	// push the old entry in the undo buffer for this transaction
-	if (transaction.transaction) {
-		DuckTransactionManager::Get(GetCatalog().GetAttached())
-		    .PushCatalogEntry(*transaction.transaction, value_ptr->Child());
-	}
-	return true;
-}
-
-bool CatalogSet::DropEntry(CatalogTransaction transaction, const string &name, bool cascade, bool allow_drop_internal) {
-	if (!DropDependencies(transaction, name, cascade, allow_drop_internal)) {
-		return false;
-	}
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-	lock_guard<mutex> read_lock(catalog_lock);
-	return DropEntryInternal(transaction, name, allow_drop_internal);
-}
-
-bool CatalogSet::DropEntry(ClientContext &context, const string &name, bool cascade, bool allow_drop_internal) {
-	return DropEntry(catalog.GetCatalogTransaction(context), name, cascade, allow_drop_internal);
-}
-
-//! Verify that the object referenced by the dependency still exists when we commit the dependency
-void CatalogSet::VerifyExistenceOfDependency(transaction_t commit_id, CatalogEntry &entry) {
-	auto &duck_catalog = GetCatalog();
-
-	// Make sure that we don't see any uncommitted changes
-	auto transaction_id = MAX_TRANSACTION_ID;
-	// This will allow us to see all committed changes made before this COMMIT happened
-	auto tx_start_time = commit_id;
-	CatalogTransaction commit_transaction(duck_catalog.GetDatabase(), transaction_id, tx_start_time);
-
-	D_ASSERT(entry.type == CatalogType::DEPENDENCY_ENTRY);
-	auto &dep = entry.Cast<DependencyEntry>();
-	duck_catalog.GetDependencyManager()->VerifyExistence(commit_transaction, dep);
-}
-
-//! Verify that no dependencies creations were committed since our transaction started, that reference the entry we're
-//! dropping
-void CatalogSet::CommitDrop(transaction_t commit_id, transaction_t start_time, CatalogEntry &entry) {
-	auto &duck_catalog = GetCatalog();
-
-	// Make sure that we don't see any uncommitted changes
-	auto transaction_id = MAX_TRANSACTION_ID;
-	// This will allow us to see all committed changes made before this COMMIT happened
-	auto tx_start_time = commit_id;
-	CatalogTransaction commit_transaction(duck_catalog.GetDatabase(), transaction_id, tx_start_time);
-
-	duck_catalog.GetDependencyManager()->VerifyCommitDrop(commit_transaction, start_time, entry);
-}
-
-DuckCatalog &CatalogSet::GetCatalog() {
-	return catalog;
-}
-
-void CatalogSet::CleanupEntry(CatalogEntry &catalog_entry) {
-	// destroy the backed up entry: it is no longer required
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-	lock_guard<mutex> lock(catalog_lock);
-	auto &parent = catalog_entry.Parent();
-	map.DropEntry(catalog_entry);
-	if (parent.deleted && !parent.HasChild() && !parent.HasParent()) {
-		// The entry's parent is a tombstone and the entry had no child
-		// clean up the mapping and the tombstone entry as well
-		D_ASSERT(map.GetEntry(parent.name).get() == &parent);
-		map.DropEntry(parent);
-	}
-}
-
-bool CatalogSet::CreatedByOtherActiveTransaction(CatalogTransaction transaction, transaction_t timestamp) {
-	// True if this transaction is not committed yet and the entry was made by another active (not committed)
-	// transaction
-	return (timestamp >= TRANSACTION_ID_START && timestamp != transaction.transaction_id);
-}
-
-bool CatalogSet::CommittedAfterStarting(CatalogTransaction transaction, transaction_t timestamp) {
-	// The entry has been committed after this transaction started, this is not our source of truth.
-	return (timestamp < TRANSACTION_ID_START && timestamp > transaction.start_time);
-}
-
-bool CatalogSet::HasConflict(CatalogTransaction transaction, transaction_t timestamp) {
-	return CreatedByOtherActiveTransaction(transaction, timestamp) || CommittedAfterStarting(transaction, timestamp);
-}
-
-bool CatalogSet::IsCommitted(transaction_t timestamp) {
-	//! FIXME: `transaction_t` itself should be a class that has these methods
-	return timestamp < TRANSACTION_ID_START;
-}
-
-bool CatalogSet::UseTimestamp(CatalogTransaction transaction, transaction_t timestamp) {
-	if (timestamp == transaction.transaction_id) {
-		// we created this version
-		return true;
-	}
-	if (timestamp < transaction.start_time) {
-		// this version was commited before we started the transaction
-		return true;
-	}
-	return false;
-}
-
-CatalogEntry &CatalogSet::GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current) {
-	bool visible;
-	return GetEntryForTransaction(transaction, current, visible);
-}
-
-CatalogEntry &CatalogSet::GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current, bool &visible) {
-	reference<CatalogEntry> entry(current);
-	while (entry.get().HasChild()) {
-		if (UseTimestamp(transaction, entry.get().timestamp)) {
-			visible = true;
-			return entry.get();
-		}
-		entry = entry.get().Child();
-	}
-	visible = false;
-	return entry.get();
-}
-
-CatalogEntry &CatalogSet::GetCommittedEntry(CatalogEntry &current) {
-	reference<CatalogEntry> entry(current);
-	while (entry.get().HasChild()) {
-		if (entry.get().timestamp < TRANSACTION_ID_START) {
-			// this entry is committed: use it
-			break;
-		}
-		entry = entry.get().Child();
-	}
-	return entry.get();
-}
-
-SimilarCatalogEntry CatalogSet::SimilarEntry(CatalogTransaction transaction, const string &name) {
-	unique_lock<mutex> lock(catalog_lock);
-	CreateDefaultEntries(transaction, lock);
-
-	SimilarCatalogEntry result;
-	for (auto &kv : map.Entries()) {
-		auto entry_score = StringUtil::SimilarityRating(kv.first, name);
-		if (entry_score > result.score) {
-			result.score = entry_score;
-			result.name = kv.first;
-		}
-	}
-	return result;
-}
-
-optional_ptr<CatalogEntry> CatalogSet::CreateDefaultEntry(CatalogTransaction transaction, const string &name,
-                                                          unique_lock<mutex> &read_lock) {
-	// no entry found with this name, check for defaults
-	if (!defaults || defaults->created_all_entries) {
-		// no defaults either: return null
-		return nullptr;
-	}
-	read_lock.unlock();
-	// this catalog set has a default map defined
-	// check if there is a default entry that we can create with this name
-	auto entry = defaults->CreateDefaultEntry(transaction, name);
-
-	read_lock.lock();
-	if (!entry) {
-		// no default entry
-		return nullptr;
-	}
-	// there is a default entry! create it
-	auto result = CreateCommittedEntry(std::move(entry));
-	if (result) {
-		return result;
-	}
-	// we found a default entry, but failed
-	// this means somebody else created the entry first
-	// just retry?
-	read_lock.unlock();
-	return GetEntry(transaction, name);
-}
-
-CatalogSet::EntryLookup CatalogSet::GetEntryDetailed(CatalogTransaction transaction, const string &name) {
-	unique_lock<mutex> read_lock(catalog_lock);
-	auto entry_value = map.GetEntry(name);
-	if (entry_value) {
-		// we found an entry for this name
-		// check the version numbers
-
-		auto &catalog_entry = *entry_value;
-		bool visible;
-		auto &current = GetEntryForTransaction(transaction, catalog_entry, visible);
-		if (current.deleted) {
-			if (!visible) {
-				return EntryLookup {nullptr, EntryLookup::FailureReason::INVISIBLE};
-			} else {
-				return EntryLookup {nullptr, EntryLookup::FailureReason::DELETED};
-			}
-		}
-		D_ASSERT(StringUtil::CIEquals(name, current.name));
-		return EntryLookup {&current, EntryLookup::FailureReason::SUCCESS};
-	}
-	auto default_entry = CreateDefaultEntry(transaction, name, read_lock);
-	if (!default_entry) {
-		return EntryLookup {default_entry, EntryLookup::FailureReason::NOT_PRESENT};
-	}
-	return EntryLookup {default_entry, EntryLookup::FailureReason::SUCCESS};
-}
-
-optional_ptr<CatalogEntry> CatalogSet::GetEntry(CatalogTransaction transaction, const string &name) {
-	auto lookup = GetEntryDetailed(transaction, name);
-	return lookup.result;
-}
-
-optional_ptr<CatalogEntry> CatalogSet::GetEntry(ClientContext &context, const string &name) {
-	return GetEntry(catalog.GetCatalogTransaction(context), name);
-}
-
-void CatalogSet::UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp) {
-	entry.timestamp = timestamp;
-}
-
-void CatalogSet::Undo(CatalogEntry &entry) {
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-	lock_guard<mutex> lock(catalog_lock);
-
-	// entry has to be restored
-	// and entry->parent has to be removed ("rolled back")
-
-	// i.e. we have to place (entry) as (entry->parent) again
-	auto &to_be_removed_node = entry.Parent();
-	to_be_removed_node.Rollback(entry);
-
-	D_ASSERT(StringUtil::CIEquals(entry.name, to_be_removed_node.name));
-	if (!to_be_removed_node.HasParent()) {
-		to_be_removed_node.Child().SetAsRoot();
-	}
-	map.DropEntry(to_be_removed_node);
-
-	if (entry.type == CatalogType::INVALID) {
-		// This was the root of the entry chain
-		map.DropEntry(entry);
-	}
-}
-
-void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &read_lock) {
-	if (!defaults || defaults->created_all_entries) {
-		return;
-	}
-	// this catalog set has a default set defined:
-	auto default_entries = defaults->GetDefaultEntries();
-	for (auto &default_entry : default_entries) {
-		auto entry_value = map.GetEntry(default_entry);
-		if (!entry_value) {
-			// we unlock during the CreateEntry, since it might reference other catalog sets...
-			// specifically for views this can happen since the view will be bound
-			read_lock.unlock();
-			auto entry = defaults->CreateDefaultEntry(transaction, default_entry);
-			if (!entry) {
-				throw InternalException("Failed to create default entry for %s", default_entry);
-			}
-
-			read_lock.lock();
-			CreateCommittedEntry(std::move(entry));
-		}
-	}
-	defaults->created_all_entries = true;
-}
-
-void CatalogSet::Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback) {
-	// lock the catalog set
-	unique_lock<mutex> lock(catalog_lock);
-	CreateDefaultEntries(transaction, lock);
-
-	for (auto &kv : map.Entries()) {
-		auto &entry = *kv.second;
-		auto &entry_for_transaction = GetEntryForTransaction(transaction, entry);
-		if (!entry_for_transaction.deleted) {
-			callback(entry_for_transaction);
-		}
-	}
-}
-
-void CatalogSet::Scan(ClientContext &context, const std::function<void(CatalogEntry &)> &callback) {
-	Scan(catalog.GetCatalogTransaction(context), callback);
-}
-
-void CatalogSet::ScanWithPrefix(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback,
-                                const string &prefix) {
-	// lock the catalog set
-	unique_lock<mutex> lock(catalog_lock);
-	CreateDefaultEntries(transaction, lock);
-
-	auto &entries = map.Entries();
-	auto it = entries.lower_bound(prefix);
-	auto end = entries.upper_bound(prefix + char(255));
-	for (; it != end; it++) {
-		auto &entry = *it->second;
-		auto &entry_for_transaction = GetEntryForTransaction(transaction, entry);
-		if (!entry_for_transaction.deleted) {
-			callback(entry_for_transaction);
-		}
-	}
-}
-
-void CatalogSet::Scan(const std::function<void(CatalogEntry &)> &callback) {
-	// lock the catalog set
-	lock_guard<mutex> lock(catalog_lock);
-	for (auto &kv : map.Entries()) {
-		auto &entry = *kv.second;
-		auto &commited_entry = GetCommittedEntry(entry);
-		if (!commited_entry.deleted) {
-			callback(commited_entry);
-		}
-	}
-}
-
-void CatalogSet::Verify(Catalog &catalog_p) {
-	D_ASSERT(&catalog_p == &catalog);
-	vector<reference<CatalogEntry>> entries;
-	Scan([&](CatalogEntry &entry) { entries.push_back(entry); });
-	for (auto &entry : entries) {
-		entry.get().Verify(catalog_p);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/catalog_transaction.cpp b/src/duckdb/src/catalog/catalog_transaction.cpp
deleted file mode 100644
index fbe100d3a..000000000
--- a/src/duckdb/src/catalog/catalog_transaction.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/catalog/catalog_transaction.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/main/database.hpp"
-
-namespace duckdb {
-
-CatalogTransaction::CatalogTransaction(Catalog &catalog, ClientContext &context) {
-	auto &transaction = Transaction::Get(context, catalog);
-	this->db = &DatabaseInstance::GetDatabase(context);
-	if (!transaction.IsDuckTransaction()) {
-		this->transaction_id = transaction_t(-1);
-		this->start_time = transaction_t(-1);
-	} else {
-		auto &dtransaction = transaction.Cast<DuckTransaction>();
-		this->transaction_id = dtransaction.transaction_id;
-		this->start_time = dtransaction.start_time;
-	}
-	this->transaction = &transaction;
-	this->context = &context;
-}
-
-CatalogTransaction::CatalogTransaction(DatabaseInstance &db, transaction_t transaction_id_p, transaction_t start_time_p)
-    : db(&db), context(nullptr), transaction(nullptr), transaction_id(transaction_id_p), start_time(start_time_p) {
-}
-
-ClientContext &CatalogTransaction::GetContext() {
-	if (!context) {
-		throw InternalException("Attempting to get a context in a CatalogTransaction without a context");
-	}
-	return *context;
-}
-
-CatalogTransaction CatalogTransaction::GetSystemCatalogTransaction(ClientContext &context) {
-	return CatalogTransaction(Catalog::GetSystemCatalog(context), context);
-}
-
-CatalogTransaction CatalogTransaction::GetSystemTransaction(DatabaseInstance &db) {
-	return CatalogTransaction(db, 1, 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/default/default_functions.cpp b/src/duckdb/src/catalog/default/default_functions.cpp
deleted file mode 100644
index 7702bc4e0..000000000
--- a/src/duckdb/src/catalog/default/default_functions.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-#include "duckdb/catalog/default/default_functions.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-
-#include "duckdb/function/scalar_macro_function.hpp"
-
-namespace duckdb {
-
-static const DefaultMacro internal_macros[] = {
-	{DEFAULT_SCHEMA, "current_role", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // user name of current execution context
-	{DEFAULT_SCHEMA, "current_user", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // user name of current execution context
-	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, {{nullptr, nullptr}}, "main.current_database()"},          // name of current database (called "catalog" in the SQL standard)
-	{DEFAULT_SCHEMA, "user", {nullptr}, {{nullptr, nullptr}}, "current_user"},                           // equivalent to current_user
-	{DEFAULT_SCHEMA, "session_user", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // session user name
-	{"pg_catalog", "inet_client_addr", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // address of the remote connection
-	{"pg_catalog", "inet_client_port", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // port of the remote connection
-	{"pg_catalog", "inet_server_addr", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // address of the local connection
-	{"pg_catalog", "inet_server_port", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // port of the local connection
-	{"pg_catalog", "pg_my_temp_schema", {nullptr}, {{nullptr, nullptr}}, "0"},                         // OID of session's temporary schema, or 0 if none
-	{"pg_catalog", "pg_is_other_temp_schema", {"schema_id", nullptr}, {{nullptr, nullptr}}, "false"},  // is schema another session's temporary schema?
-
-	{"pg_catalog", "pg_conf_load_time", {nullptr}, {{nullptr, nullptr}}, "current_timestamp"},         // configuration load time
-	{"pg_catalog", "pg_postmaster_start_time", {nullptr}, {{nullptr, nullptr}}, "current_timestamp"},  // server start time
-
-	{"pg_catalog", "pg_typeof", {"expression", nullptr}, {{nullptr, nullptr}}, "lower(typeof(expression))"},  // get the data type of any value
-
-	{"pg_catalog", "current_database", {nullptr}, {{nullptr, nullptr}}, "system.main.current_database()"},  	    // name of current database (called "catalog" in the SQL standard)
-	{"pg_catalog", "current_query", {nullptr}, {{nullptr, nullptr}}, "system.main.current_query()"},  	        // the currently executing query (NULL if not inside a plpgsql function)
-	{"pg_catalog", "current_schema", {nullptr}, {{nullptr, nullptr}}, "system.main.current_schema()"},  	        // name of current schema
-	{"pg_catalog", "current_schemas", {"include_implicit"}, {{nullptr, nullptr}}, "system.main.current_schemas(include_implicit)"},  	// names of schemas in search path
-
-	// privilege functions
-	{"pg_catalog", "has_any_column_privilege", {"table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for any column of table
-	{"pg_catalog", "has_any_column_privilege", {"user", "table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for any column of table
-	{"pg_catalog", "has_column_privilege", {"table", "column", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for column
-	{"pg_catalog", "has_column_privilege", {"user", "table", "column", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for column
-	{"pg_catalog", "has_database_privilege", {"database", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for database
-	{"pg_catalog", "has_database_privilege", {"user", "database", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for database
-	{"pg_catalog", "has_foreign_data_wrapper_privilege", {"fdw", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for foreign-data wrapper
-	{"pg_catalog", "has_foreign_data_wrapper_privilege", {"user", "fdw", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for foreign-data wrapper
-	{"pg_catalog", "has_function_privilege", {"function", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for function
-	{"pg_catalog", "has_function_privilege", {"user", "function", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for function
-	{"pg_catalog", "has_language_privilege", {"language", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for language
-	{"pg_catalog", "has_language_privilege", {"user", "language", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for language
-	{"pg_catalog", "has_schema_privilege", {"schema", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for schema
-	{"pg_catalog", "has_schema_privilege", {"user", "schema", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for schema
-	{"pg_catalog", "has_sequence_privilege", {"sequence", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for sequence
-	{"pg_catalog", "has_sequence_privilege", {"user", "sequence", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for sequence
-	{"pg_catalog", "has_server_privilege", {"server", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for foreign server
-	{"pg_catalog", "has_server_privilege", {"user", "server", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for foreign server
-	{"pg_catalog", "has_table_privilege", {"table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for table
-	{"pg_catalog", "has_table_privilege", {"user", "table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for table
-	{"pg_catalog", "has_tablespace_privilege", {"tablespace", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for tablespace
-	{"pg_catalog", "has_tablespace_privilege", {"user", "tablespace", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for tablespace
-
-	// various postgres system functions
-	{"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, {{nullptr, nullptr}}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
-	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", nullptr}, {{nullptr, nullptr}}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid//1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
-	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, {{nullptr, nullptr}}, "pg_get_constraintdef(constraint_oid)"},
-	{"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, {{nullptr, nullptr}}, "pg_node_tree"},
-	{"pg_catalog", "format_pg_type", {"logical_type", "type_name", nullptr}, {{nullptr, nullptr}}, "case upper(logical_type) when 'FLOAT' then 'float4' when 'DOUBLE' then 'float8' when 'DECIMAL' then 'numeric' when 'ENUM' then lower(type_name) when 'VARCHAR' then 'varchar' when 'BLOB' then 'bytea' when 'TIMESTAMP' then 'timestamp' when 'TIME' then 'time' when 'TIMESTAMP WITH TIME ZONE' then 'timestamptz' when 'TIME WITH TIME ZONE' then 'timetz' when 'SMALLINT' then 'int2' when 'INTEGER' then 'int4' when 'BIGINT' then 'int8' when 'BOOLEAN' then 'bool' else lower(logical_type) end"},
-	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, {{nullptr, nullptr}}, "(select format_pg_type(logical_type, type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
-	{"pg_catalog", "map_to_pg_oid", {"type_name", nullptr}, {{nullptr, nullptr}}, "case type_name when 'bool' then 16 when 'int16' then 21 when 'int' then 23 when 'bigint' then 20 when 'date' then 1082 when 'time' then 1083 when 'datetime' then 1114 when 'dec' then 1700 when 'float' then 700 when 'double' then 701 when 'bpchar' then 1043 when 'binary' then 17 when 'interval' then 1186 when 'timestamptz' then 1184 when 'timetz' then 1266 when 'bit' then 1560 when 'guid' then 2950 else null end"}, // map duckdb_oid to pg_oid. If no corresponding type, return null
-
-	{"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for role
-	{"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for role
-
-	{"pg_catalog", "col_description", {"table_oid", "column_number", nullptr}, {{nullptr, nullptr}}, "NULL"},   // get comment for a table column
-	{"pg_catalog", "obj_description", {"object_oid", "catalog_name", nullptr}, {{nullptr, nullptr}}, "NULL"},   // get comment for a database object
-	{"pg_catalog", "shobj_description", {"object_oid", "catalog_name", nullptr}, {{nullptr, nullptr}}, "NULL"}, // get comment for a shared database object
-
-	// visibility functions
-	{"pg_catalog", "pg_collation_is_visible", {"collation_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_conversion_is_visible", {"conversion_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_function_is_visible", {"function_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_opclass_is_visible", {"opclass_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_operator_is_visible", {"operator_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_opfamily_is_visible", {"opclass_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_table_is_visible", {"table_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_ts_config_is_visible", {"config_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_ts_dict_is_visible", {"dict_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_ts_parser_is_visible", {"parser_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_ts_template_is_visible", {"template_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-	{"pg_catalog", "pg_type_is_visible", {"type_oid", nullptr}, {{nullptr, nullptr}}, "true"},
-
-	{"pg_catalog", "pg_size_pretty", {"bytes", nullptr}, {{nullptr, nullptr}}, "format_bytes(bytes)"},
-
-	{DEFAULT_SCHEMA, "round_even", {"x", "n", nullptr}, {{nullptr, nullptr}}, "CASE ((abs(x) * power(10, n+1)) % 10) WHEN 5 THEN round(x/2, n) * 2 ELSE round(x, n) END"},
-	{DEFAULT_SCHEMA, "roundbankers", {"x", "n", nullptr}, {{nullptr, nullptr}}, "round_even(x, n)"},
-	{DEFAULT_SCHEMA, "nullif", {"a", "b", nullptr}, {{nullptr, nullptr}}, "CASE WHEN a=b THEN NULL ELSE a END"},
-	{DEFAULT_SCHEMA, "list_append", {"l", "e", nullptr}, {{nullptr, nullptr}}, "list_concat(l, list_value(e))"},
-	{DEFAULT_SCHEMA, "array_append", {"arr", "el", nullptr}, {{nullptr, nullptr}}, "list_append(arr, el)"},
-	{DEFAULT_SCHEMA, "list_prepend", {"e", "l", nullptr}, {{nullptr, nullptr}}, "list_concat(list_value(e), l)"},
-	{DEFAULT_SCHEMA, "array_prepend", {"el", "arr", nullptr}, {{nullptr, nullptr}}, "list_prepend(el, arr)"},
-	{DEFAULT_SCHEMA, "array_pop_back", {"arr", nullptr}, {{nullptr, nullptr}}, "arr[:LEN(arr)-1]"},
-	{DEFAULT_SCHEMA, "array_pop_front", {"arr", nullptr}, {{nullptr, nullptr}}, "arr[2:]"},
-	{DEFAULT_SCHEMA, "array_push_back", {"arr", "e", nullptr}, {{nullptr, nullptr}}, "list_concat(arr, list_value(e))"},
-	{DEFAULT_SCHEMA, "array_push_front", {"arr", "e", nullptr}, {{nullptr, nullptr}}, "list_concat(list_value(e), arr)"},
-	{DEFAULT_SCHEMA, "array_to_string", {"arr", "sep", nullptr}, {{nullptr, nullptr}}, "list_aggr(arr::varchar[], 'string_agg', sep)"},
-	// Test default parameters
-	{DEFAULT_SCHEMA, "array_to_string_comma_default", {"arr", nullptr}, {{"sep", "','"}, {nullptr, nullptr}}, "list_aggr(arr::varchar[], 'string_agg', sep)"},
-
-	{DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, {{nullptr, nullptr}}, "unnest(generate_series(1, array_length(arr, dim)))"},
-	{DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, {{nullptr, nullptr}}, "floor(x/y)"},
-	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, {{nullptr, nullptr}}, "(x-y*floor(x/y))"},
-	{DEFAULT_SCHEMA, "split_part", {"string", "delimiter", "position", nullptr}, {{nullptr, nullptr}}, "if(string IS NOT NULL AND delimiter IS NOT NULL AND position IS NOT NULL, coalesce(string_split(string, delimiter)[position],''), NULL)"},
-	{DEFAULT_SCHEMA, "geomean", {"x", nullptr}, {{nullptr, nullptr}}, "exp(avg(ln(x)))"},
-	{DEFAULT_SCHEMA, "geometric_mean", {"x", nullptr}, {{nullptr, nullptr}}, "geomean(x)"},
-
-	{DEFAULT_SCHEMA, "weighted_avg", {"value", "weight", nullptr}, {{nullptr, nullptr}}, "SUM(value * weight) / SUM(CASE WHEN value IS NOT NULL THEN weight ELSE 0 END)"},
-	{DEFAULT_SCHEMA, "wavg", {"value", "weight", nullptr}, {{nullptr, nullptr}}, "weighted_avg(value, weight)"},
-
-    {DEFAULT_SCHEMA, "list_reverse", {"l", nullptr}, {{nullptr, nullptr}}, "l[:-:-1]"},
-    {DEFAULT_SCHEMA, "array_reverse", {"l", nullptr}, {{nullptr, nullptr}}, "list_reverse(l)"},
-
-    // FIXME implement as actual function if we encounter a lot of performance issues. Complexity now: n * m, with hashing possibly n + m
-    {DEFAULT_SCHEMA, "list_intersect", {"l1", "l2", nullptr}, {{nullptr, nullptr}}, "list_filter(list_distinct(l1), (variable_intersect) -> list_contains(l2, variable_intersect))"},
-    {DEFAULT_SCHEMA, "array_intersect", {"l1", "l2", nullptr}, {{nullptr, nullptr}}, "list_intersect(l1, l2)"},
-
-	// algebraic list aggregates
-	{DEFAULT_SCHEMA, "list_avg", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'avg')"},
-	{DEFAULT_SCHEMA, "list_var_samp", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'var_samp')"},
-	{DEFAULT_SCHEMA, "list_var_pop", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'var_pop')"},
-	{DEFAULT_SCHEMA, "list_stddev_pop", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'stddev_pop')"},
-	{DEFAULT_SCHEMA, "list_stddev_samp", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'stddev_samp')"},
-	{DEFAULT_SCHEMA, "list_sem", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'sem')"},
-
-	// distributive list aggregates
-	{DEFAULT_SCHEMA, "list_approx_count_distinct", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'approx_count_distinct')"},
-	{DEFAULT_SCHEMA, "list_bit_xor", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bit_xor')"},
-	{DEFAULT_SCHEMA, "list_bit_or", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bit_or')"},
-	{DEFAULT_SCHEMA, "list_bit_and", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bit_and')"},
-	{DEFAULT_SCHEMA, "list_bool_and", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bool_and')"},
-	{DEFAULT_SCHEMA, "list_bool_or", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bool_or')"},
-	{DEFAULT_SCHEMA, "list_count", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'count')"},
-	{DEFAULT_SCHEMA, "list_entropy", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'entropy')"},
-	{DEFAULT_SCHEMA, "list_last", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'last')"},
-	{DEFAULT_SCHEMA, "list_first", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'first')"},
-	{DEFAULT_SCHEMA, "list_any_value", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'any_value')"},
-	{DEFAULT_SCHEMA, "list_kurtosis", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'kurtosis')"},
-	{DEFAULT_SCHEMA, "list_kurtosis_pop", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'kurtosis_pop')"},
-	{DEFAULT_SCHEMA, "list_min", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'min')"},
-	{DEFAULT_SCHEMA, "list_max", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'max')"},
-	{DEFAULT_SCHEMA, "list_product", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'product')"},
-	{DEFAULT_SCHEMA, "list_skewness", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'skewness')"},
-	{DEFAULT_SCHEMA, "list_sum", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'sum')"},
-	{DEFAULT_SCHEMA, "list_string_agg", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'string_agg')"},
-
-	// holistic list aggregates
-	{DEFAULT_SCHEMA, "list_mode", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'mode')"},
-	{DEFAULT_SCHEMA, "list_median", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'median')"},
-	{DEFAULT_SCHEMA, "list_mad", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'mad')"},
-
-	// nested list aggregates
-	{DEFAULT_SCHEMA, "list_histogram", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'histogram')"},
-
-	// map functions
-	{DEFAULT_SCHEMA, "map_contains_entry", {"map", "key", "value"}, {{nullptr, nullptr}}, "contains(map_entries(map), {'key': key, 'value': value})"},
-	{DEFAULT_SCHEMA, "map_contains_value", {"map", "value", nullptr}, {{nullptr, nullptr}}, "contains(map_values(map), value)"},
-
-	// date functions
-	{DEFAULT_SCHEMA, "date_add", {"date", "interval", nullptr}, {{nullptr, nullptr}}, "date + interval"},
-	{DEFAULT_SCHEMA, "current_date", {nullptr}, {{nullptr, nullptr}}, "current_timestamp::DATE"},
-	{DEFAULT_SCHEMA, "today", {nullptr}, {{nullptr, nullptr}}, "current_timestamp::DATE"},
-	{DEFAULT_SCHEMA, "get_current_time", {nullptr}, {{nullptr, nullptr}}, "current_timestamp::TIMETZ"},
-
-	// regexp functions
-	{DEFAULT_SCHEMA, "regexp_split_to_table", {"text", "pattern", nullptr}, {{nullptr, nullptr}}, "unnest(string_split_regex(text, pattern))"},
-
-	// storage helper functions
-	{DEFAULT_SCHEMA, "get_block_size", {"db_name"}, {{nullptr, nullptr}}, "(SELECT block_size FROM pragma_database_size() WHERE database_name = db_name)"},
-
-	// string functions
-	{DEFAULT_SCHEMA, "md5_number_upper", {"param"}, {{nullptr, nullptr}}, "((md5_number(param)::bit::varchar)[65:])::bit::uint64"},
-	{DEFAULT_SCHEMA, "md5_number_lower", {"param"}, {{nullptr, nullptr}}, "((md5_number(param)::bit::varchar)[:64])::bit::uint64"},
-
-	{nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}
-	};
-
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(const DefaultMacro &default_macro) {
-	return CreateInternalMacroInfo(array_ptr<const DefaultMacro>(default_macro));
-}
-
-
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(array_ptr<const DefaultMacro> macros) {
-	auto type = CatalogType::MACRO_ENTRY;
-	auto bind_info = make_uniq<CreateMacroInfo>(type);
-	for(auto &default_macro : macros) {
-		// parse the expression
-		auto expressions = Parser::ParseExpressionList(default_macro.macro);
-		D_ASSERT(expressions.size() == 1);
-
-		auto function = make_uniq<ScalarMacroFunction>(std::move(expressions[0]));
-		for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
-			function->parameters.push_back(
-			    make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
-		}
-		for (idx_t named_idx = 0; default_macro.named_parameters[named_idx].name != nullptr; named_idx++) {
-			auto expr_list = Parser::ParseExpressionList(default_macro.named_parameters[named_idx].default_value);
-			if (expr_list.size() != 1) {
-				throw InternalException("Expected a single expression");
-			}
-			function->default_parameters.insert(
-				make_pair(default_macro.named_parameters[named_idx].name, std::move(expr_list[0])));
-		}
-		D_ASSERT(function->type == MacroType::SCALAR_MACRO);
-		bind_info->macros.push_back(std::move(function));
-	}
-	bind_info->schema = macros[0].schema;
-	bind_info->name = macros[0].name;
-	bind_info->temporary = true;
-	bind_info->internal = true;
-	return bind_info;
-}
-
-static bool DefaultFunctionMatches(const DefaultMacro &macro, const string &schema, const string &name) {
-	return macro.schema == schema && macro.name == name;
-}
-
-static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &input_schema, const string &input_name) {
-	auto schema = StringUtil::Lower(input_schema);
-	auto name = StringUtil::Lower(input_name);
-	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
-		if (DefaultFunctionMatches(internal_macros[index], schema, name)) {
-			// found the function! keep on iterating to find all overloads
-			idx_t overload_count;
-			for(overload_count = 1; internal_macros[index + overload_count].name; overload_count++) {
-				if (!DefaultFunctionMatches(internal_macros[index + overload_count], schema, name)) {
-					break;
-				}
-			}
-			return DefaultFunctionGenerator::CreateInternalMacroInfo(array_ptr<const DefaultMacro>(internal_macros + index, overload_count));
-		}
-	}
-	return nullptr;
-}
-
-DefaultFunctionGenerator::DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CatalogEntry> DefaultFunctionGenerator::CreateDefaultEntry(ClientContext &context,
-                                                                      const string &entry_name) {
-	auto info = GetDefaultFunction(schema.name, entry_name);
-	if (info) {
-		return make_uniq_base<CatalogEntry, ScalarMacroCatalogEntry>(catalog, schema, info->Cast<CreateMacroInfo>());
-	}
-	return nullptr;
-}
-
-vector<string> DefaultFunctionGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
-		if (StringUtil::Lower(internal_macros[index].name) != internal_macros[index].name) {
-			throw InternalException("Default macro name %s should be lowercase", internal_macros[index].name);
-		}
-		if (internal_macros[index].schema == schema.name) {
-			result.emplace_back(internal_macros[index].name);
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/default/default_generator.cpp b/src/duckdb/src/catalog/default/default_generator.cpp
deleted file mode 100644
index 2fbb2b646..000000000
--- a/src/duckdb/src/catalog/default/default_generator.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "duckdb/catalog/default/default_generator.hpp"
-#include "duckdb/catalog/catalog_transaction.hpp"
-
-namespace duckdb {
-
-DefaultGenerator::DefaultGenerator(Catalog &catalog) : catalog(catalog), created_all_entries(false) {
-}
-DefaultGenerator::~DefaultGenerator() {
-}
-
-unique_ptr<CatalogEntry> DefaultGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	throw InternalException("CreateDefaultEntry with ClientContext called but not supported in this generator");
-}
-
-unique_ptr<CatalogEntry> DefaultGenerator::CreateDefaultEntry(CatalogTransaction transaction,
-                                                              const string &entry_name) {
-	if (!transaction.context) {
-		// no context - cannot create default entry
-		return nullptr;
-	}
-	return CreateDefaultEntry(*transaction.context, entry_name);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/default/default_schemas.cpp b/src/duckdb/src/catalog/default/default_schemas.cpp
deleted file mode 100644
index 64aaf56d2..000000000
--- a/src/duckdb/src/catalog/default/default_schemas.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/catalog/default/default_schemas.hpp"
-#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-struct DefaultSchema {
-	const char *name;
-};
-
-static const DefaultSchema internal_schemas[] = {{"information_schema"}, {"pg_catalog"}, {nullptr}};
-
-bool DefaultSchemaGenerator::IsDefaultSchema(const string &input_schema) {
-	auto schema = StringUtil::Lower(input_schema);
-	for (idx_t index = 0; internal_schemas[index].name != nullptr; index++) {
-		if (internal_schemas[index].name == schema) {
-			return true;
-		}
-	}
-	return false;
-}
-
-DefaultSchemaGenerator::DefaultSchemaGenerator(Catalog &catalog) : DefaultGenerator(catalog) {
-}
-
-unique_ptr<CatalogEntry> DefaultSchemaGenerator::CreateDefaultEntry(CatalogTransaction transaction,
-                                                                    const string &entry_name) {
-	if (IsDefaultSchema(entry_name)) {
-		CreateSchemaInfo info;
-		info.schema = StringUtil::Lower(entry_name);
-		info.internal = true;
-		return make_uniq_base<CatalogEntry, DuckSchemaEntry>(catalog, info);
-	}
-	return nullptr;
-}
-
-vector<string> DefaultSchemaGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_schemas[index].name != nullptr; index++) {
-		result.emplace_back(internal_schemas[index].name);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/default/default_table_functions.cpp b/src/duckdb/src/catalog/default/default_table_functions.cpp
deleted file mode 100644
index b0755c834..000000000
--- a/src/duckdb/src/catalog/default/default_table_functions.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "duckdb/catalog/default/default_table_functions.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-
-namespace duckdb {
-
-// clang-format off
-static const DefaultTableMacro internal_table_macros[] = {
-	{DEFAULT_SCHEMA, "histogram_values", {"source", "col_name", nullptr}, {{"bin_count", "10"}, {"technique", "'auto'"}, {nullptr, nullptr}},  R"(
-WITH bins AS (
-   SELECT
-      CASE
-      WHEN (NOT (can_cast_implicitly(MIN(col_name), NULL::BIGINT) OR
-            can_cast_implicitly(MIN(col_name), NULL::DOUBLE) OR
-            can_cast_implicitly(MIN(col_name), NULL::TIMESTAMP)) AND technique='auto')
-            OR technique='sample'
-      THEN
-         approx_top_k(col_name, bin_count)
-      WHEN technique='equi-height'
-      THEN
-         quantile(col_name, [x / bin_count::DOUBLE for x in generate_series(1, bin_count)])
-      WHEN technique='equi-width'
-      THEN
-         equi_width_bins(MIN(col_name), MAX(col_name), bin_count, false)
-      WHEN technique='equi-width-nice' OR technique='auto'
-      THEN
-         equi_width_bins(MIN(col_name), MAX(col_name), bin_count, true)
-      ELSE
-         error(concat('Unrecognized technique ', technique))
-      END AS bins
-   FROM query_table(source::VARCHAR)
-   )
-SELECT UNNEST(map_keys(histogram)) AS bin, UNNEST(map_values(histogram)) AS count
-FROM (
-   SELECT CASE
-      WHEN (NOT (can_cast_implicitly(MIN(col_name), NULL::BIGINT) OR
-            can_cast_implicitly(MIN(col_name), NULL::DOUBLE) OR
-            can_cast_implicitly(MIN(col_name), NULL::TIMESTAMP)) AND technique='auto')
-            OR technique='sample'
-      THEN
-            histogram_exact(col_name, bins)
-      ELSE
-            histogram(col_name, bins)
-      END AS histogram
-   FROM query_table(source::VARCHAR), bins
-);
-)"},
-	{DEFAULT_SCHEMA, "histogram", {"source", "col_name", nullptr}, {{"bin_count", "10"}, {"technique", "'auto'"}, {nullptr, nullptr}},  R"(
-SELECT
-   CASE
-   WHEN is_histogram_other_bin(bin)
-   THEN '(other values)'
-   WHEN (NOT (can_cast_implicitly(bin, NULL::BIGINT) OR
-              can_cast_implicitly(bin, NULL::DOUBLE) OR
-              can_cast_implicitly(bin, NULL::TIMESTAMP)) AND technique='auto')
-              OR technique='sample'
-   THEN bin::VARCHAR
-   WHEN row_number() over () = 1
-   THEN concat('x <= ', bin::VARCHAR)
-   ELSE concat(lag(bin::VARCHAR) over (), ' < x <= ', bin::VARCHAR)
-   END AS bin,
-   count,
-   bar(count, 0, max(count) over ()) AS bar
-FROM histogram_values(source, col_name, bin_count := bin_count, technique := technique);
-)"},
-	{nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}
-	};
-// clang-format on
-
-DefaultTableFunctionGenerator::DefaultTableFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CreateMacroInfo>
-DefaultTableFunctionGenerator::CreateInternalTableMacroInfo(const DefaultTableMacro &default_macro,
-                                                            unique_ptr<MacroFunction> function) {
-	for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
-		function->parameters.push_back(make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
-	}
-	for (idx_t named_idx = 0; default_macro.named_parameters[named_idx].name != nullptr; named_idx++) {
-		auto expr_list = Parser::ParseExpressionList(default_macro.named_parameters[named_idx].default_value);
-		if (expr_list.size() != 1) {
-			throw InternalException("Expected a single expression");
-		}
-		function->default_parameters.insert(
-		    make_pair(default_macro.named_parameters[named_idx].name, std::move(expr_list[0])));
-	}
-
-	auto type = CatalogType::TABLE_MACRO_ENTRY;
-	auto bind_info = make_uniq<CreateMacroInfo>(type);
-	bind_info->schema = default_macro.schema;
-	bind_info->name = default_macro.name;
-	bind_info->temporary = true;
-	bind_info->internal = true;
-	bind_info->macros.push_back(std::move(function));
-	return bind_info;
-}
-
-unique_ptr<CreateMacroInfo>
-DefaultTableFunctionGenerator::CreateTableMacroInfo(const DefaultTableMacro &default_macro) {
-	Parser parser;
-	parser.ParseQuery(default_macro.macro);
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw InternalException("Expected a single select statement in CreateTableMacroInfo internal");
-	}
-	auto node = std::move(parser.statements[0]->Cast<SelectStatement>().node);
-
-	auto result = make_uniq<TableMacroFunction>(std::move(node));
-	return CreateInternalTableMacroInfo(default_macro, std::move(result));
-}
-
-static unique_ptr<CreateFunctionInfo> GetDefaultTableFunction(const string &input_schema, const string &input_name) {
-	auto schema = StringUtil::Lower(input_schema);
-	auto name = StringUtil::Lower(input_name);
-	for (idx_t index = 0; internal_table_macros[index].name != nullptr; index++) {
-		if (internal_table_macros[index].schema == schema && internal_table_macros[index].name == name) {
-			return DefaultTableFunctionGenerator::CreateTableMacroInfo(internal_table_macros[index]);
-		}
-	}
-	return nullptr;
-}
-
-unique_ptr<CatalogEntry> DefaultTableFunctionGenerator::CreateDefaultEntry(ClientContext &context,
-                                                                           const string &entry_name) {
-	auto info = GetDefaultTableFunction(schema.name, entry_name);
-	if (info) {
-		return make_uniq_base<CatalogEntry, TableMacroCatalogEntry>(catalog, schema, info->Cast<CreateMacroInfo>());
-	}
-	return nullptr;
-}
-
-vector<string> DefaultTableFunctionGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_table_macros[index].name != nullptr; index++) {
-		if (StringUtil::Lower(internal_table_macros[index].name) != internal_table_macros[index].name) {
-			throw InternalException("Default macro name %s should be lowercase", internal_table_macros[index].name);
-		}
-		if (internal_table_macros[index].schema == schema.name) {
-			result.emplace_back(internal_table_macros[index].name);
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/default/default_types.cpp b/src/duckdb/src/catalog/default/default_types.cpp
deleted file mode 100644
index 23edac049..000000000
--- a/src/duckdb/src/catalog/default/default_types.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/catalog/default/default_types.hpp"
-
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/catalog/default/builtin_types/types.hpp"
-
-namespace duckdb {
-
-LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) {
-	auto &internal_types = BUILTIN_TYPES;
-	for (auto &type : internal_types) {
-		if (StringUtil::CIEquals(name, type.name)) {
-			return type.type;
-		}
-	}
-	return LogicalType::INVALID;
-}
-
-DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CatalogEntry> DefaultTypeGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	if (schema.name != DEFAULT_SCHEMA) {
-		return nullptr;
-	}
-	auto type_id = GetDefaultType(entry_name);
-	if (type_id == LogicalTypeId::INVALID) {
-		return nullptr;
-	}
-	CreateTypeInfo info;
-	info.name = entry_name;
-	info.type = LogicalType(type_id);
-	info.internal = true;
-	info.temporary = true;
-	return make_uniq_base<CatalogEntry, TypeCatalogEntry>(catalog, schema, info);
-}
-
-vector<string> DefaultTypeGenerator::GetDefaultEntries() {
-	vector<string> result;
-	if (schema.name != DEFAULT_SCHEMA) {
-		return result;
-	}
-	auto &internal_types = BUILTIN_TYPES;
-	for (auto &type : internal_types) {
-		result.emplace_back(StringUtil::Lower(type.name));
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/default/default_views.cpp b/src/duckdb/src/catalog/default/default_views.cpp
deleted file mode 100644
index 718696471..000000000
--- a/src/duckdb/src/catalog/default/default_views.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "duckdb/catalog/default/default_views.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-struct DefaultView {
-	const char *schema;
-	const char *name;
-	const char *sql;
-};
-
-static const DefaultView internal_views[] = {
-    {DEFAULT_SCHEMA, "pragma_database_list", "SELECT database_oid AS seq, database_name AS name, path AS file FROM duckdb_databases() WHERE NOT internal ORDER BY 1"},
-    {DEFAULT_SCHEMA, "sqlite_master", "select 'table' \"type\", table_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_tables union all select 'view' \"type\", view_name \"name\", view_name \"tbl_name\", 0 rootpage, sql from duckdb_views union all select 'index' \"type\", index_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_indexes;"},
-    {DEFAULT_SCHEMA, "sqlite_schema", "SELECT * FROM sqlite_master"},
-    {DEFAULT_SCHEMA, "sqlite_temp_master", "SELECT * FROM sqlite_master"},
-    {DEFAULT_SCHEMA, "sqlite_temp_schema", "SELECT * FROM sqlite_master"},
-    {DEFAULT_SCHEMA, "duckdb_constraints", "SELECT * FROM duckdb_constraints()"},
-    {DEFAULT_SCHEMA, "duckdb_columns", "SELECT * FROM duckdb_columns() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_databases", "SELECT * FROM duckdb_databases() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_indexes", "SELECT * FROM duckdb_indexes()"},
-    {DEFAULT_SCHEMA, "duckdb_schemas", "SELECT * FROM duckdb_schemas() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_tables", "SELECT * FROM duckdb_tables() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_types", "SELECT * FROM duckdb_types()"},
-    {DEFAULT_SCHEMA, "duckdb_views", "SELECT * FROM duckdb_views() WHERE NOT internal"},
-    {"pg_catalog", "pg_am", "SELECT 0 oid, 'art' amname, NULL amhandler, 'i' amtype"},
-    {"pg_catalog", "pg_attribute", "SELECT table_oid attrelid, column_name attname, data_type_id atttypid, 0 attstattarget, NULL attlen, column_index attnum, 0 attndims, -1 attcacheoff, case when data_type ilike '%decimal%' then numeric_precision*1000+numeric_scale else -1 end atttypmod, false attbyval, NULL attstorage, NULL attalign, NOT is_nullable attnotnull, column_default IS NOT NULL atthasdef, false atthasmissing, '' attidentity, '' attgenerated, false attisdropped, true attislocal, 0 attinhcount, 0 attcollation, NULL attcompression, NULL attacl, NULL attoptions, NULL attfdwoptions, NULL attmissingval FROM duckdb_columns()"},
-    {"pg_catalog", "pg_attrdef", "SELECT column_index oid, table_oid adrelid, column_index adnum, column_default adbin from duckdb_columns() where column_default is not null;"},
-    {"pg_catalog", "pg_class", "SELECT table_oid oid, table_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, estimated_size::real reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, index_count > 0 relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'r' relkind, column_count relnatts, check_constraint_count relchecks, false relhasoids, has_primary_key relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_tables() UNION ALL SELECT view_oid oid, view_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'v' relkind, column_count relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_views() UNION ALL SELECT sequence_oid oid, sequence_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'S' relkind, 0 relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_sequences() UNION ALL SELECT index_oid oid, index_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, 't' relpersistence, 'i' relkind, NULL relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_indexes()"},
-    {"pg_catalog", "pg_constraint", "SELECT table_oid*1000000+constraint_index oid, constraint_text conname, schema_oid connamespace, CASE constraint_type WHEN 'CHECK' then 'c' WHEN 'UNIQUE' then 'u' WHEN 'PRIMARY KEY' THEN 'p' WHEN 'FOREIGN KEY' THEN 'f' ELSE 'x' END contype, false condeferrable, false condeferred, true convalidated, table_oid conrelid, 0 contypid, 0 conindid, 0 conparentid, 0 confrelid, NULL confupdtype, NULL confdeltype, NULL confmatchtype, true conislocal, 0 coninhcount, false connoinherit, constraint_column_indexes conkey, NULL confkey, NULL conpfeqop, NULL conppeqop, NULL conffeqop, NULL conexclop, expression conbin FROM duckdb_constraints()"},
-	{"pg_catalog", "pg_database", "SELECT database_oid oid, database_name datname FROM duckdb_databases()"},
-    {"pg_catalog", "pg_depend", "SELECT * FROM duckdb_dependencies()"},
-	{"pg_catalog", "pg_description", "SELECT table_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_tables() WHERE NOT internal UNION ALL SELECT table_oid AS objoid, database_oid AS classoid, column_index AS objsubid, comment AS description FROM duckdb_columns() WHERE NOT internal UNION ALL SELECT view_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_views() WHERE NOT internal UNION ALL SELECT index_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_indexes UNION ALL SELECT sequence_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_sequences() UNION ALL SELECT type_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_types() WHERE NOT internal UNION ALL SELECT function_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_functions() WHERE NOT internal;"},
-    {"pg_catalog", "pg_enum", "SELECT NULL oid, a.type_oid enumtypid, list_position(b.labels, a.elabel) enumsortorder, a.elabel enumlabel FROM (SELECT UNNEST(labels) elabel, type_oid FROM duckdb_types() WHERE logical_type='ENUM') a JOIN duckdb_types() b ON a.type_oid=b.type_oid;"},
-    {"pg_catalog", "pg_index", "SELECT index_oid indexrelid, table_oid indrelid, 0 indnatts, 0 indnkeyatts, is_unique indisunique, is_primary indisprimary, false indisexclusion, true indimmediate, false indisclustered, true indisvalid, false indcheckxmin, true indisready, true indislive, false indisreplident, NULL::INT[] indkey, NULL::OID[] indcollation, NULL::OID[] indclass, NULL::INT[] indoption, expressions indexprs, NULL indpred FROM duckdb_indexes()"},
-    {"pg_catalog", "pg_indexes", "SELECT schema_name schemaname, table_name tablename, index_name indexname, NULL \"tablespace\", sql indexdef FROM duckdb_indexes()"},
-    {"pg_catalog", "pg_namespace", "SELECT oid, schema_name nspname, 0 nspowner, NULL nspacl FROM duckdb_schemas()"},
-	{"pg_catalog", "pg_proc", "SELECT f.function_oid oid, function_name proname, s.oid pronamespace,  NULL proowner, NULL prolang, 0 procost, 0 prorows, varargs provariadic,  0 prosupport, CASE function_type WHEN 'aggregate' THEN 'a' ELSE 'f' END prokind, false prosecdef, false proleakproof, false proisstrict, function_type = 'table' proretset,  case (stability) when 'CONSISTENT' then 'i' when 'CONSISTENT_WITHIN_QUERY' then 's' when 'VOLATILE' then 'v' end provolatile, 'u' proparallel, length(parameters)  pronargs, 0 pronargdefaults, return_type prorettype,  parameter_types proargtypes,  NULL proallargtypes, NULL proargmodes, parameters proargnames, NULL proargdefaults, NULL protrftypes, NULL prosrc, NULL probin, macro_definition prosqlbody, NULL proconfig, NULL proacl, function_type = 'aggregate' proisagg,  FROM duckdb_functions() f LEFT JOIN duckdb_schemas() s USING (database_name, schema_name)"},
-    {"pg_catalog", "pg_sequence", "SELECT sequence_oid seqrelid, 0 seqtypid, start_value seqstart, increment_by seqincrement, max_value seqmax, min_value seqmin, 0 seqcache, cycle seqcycle FROM duckdb_sequences()"},
-	{"pg_catalog", "pg_sequences", "SELECT schema_name schemaname, sequence_name sequencename, 'duckdb' sequenceowner, 0 data_type, start_value, min_value, max_value, increment_by, cycle, 0 cache_size, last_value FROM duckdb_sequences()"},
-	{"pg_catalog", "pg_settings", "SELECT name, value setting, description short_desc, CASE WHEN input_type = 'VARCHAR' THEN 'string' WHEN input_type = 'BOOLEAN' THEN 'bool' WHEN input_type IN ('BIGINT', 'UBIGINT') THEN 'integer' ELSE input_type END vartype FROM duckdb_settings()"},
-    {"pg_catalog", "pg_tables", "SELECT schema_name schemaname, table_name tablename, 'duckdb' tableowner, NULL \"tablespace\", index_count > 0 hasindexes, false hasrules, false hastriggers FROM duckdb_tables()"},
-    {"pg_catalog", "pg_tablespace", "SELECT 0 oid, 'pg_default' spcname, 0 spcowner, NULL spcacl, NULL spcoptions"},
-    {"pg_catalog", "pg_type", "SELECT CASE WHEN type_oid IS NULL THEN NULL WHEN logical_type = 'ENUM' AND type_name <> 'enum' THEN type_oid ELSE map_to_pg_oid(type_name) END oid, format_pg_type(logical_type, type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, CASE WHEN logical_type='ENUM' THEN 'e' else 'b' end typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types() WHERE type_oid IS NOT NULL;"},
-    {"pg_catalog", "pg_views", "SELECT schema_name schemaname, view_name viewname, 'duckdb' viewowner, sql definition FROM duckdb_views()"},
-    {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL::INT character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL::INT datetime_precision, NULL::VARCHAR interval_type, NULL::INT interval_precision, NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, NULL::VARCHAR character_set_name, NULL::VARCHAR collation_catalog, NULL::VARCHAR collation_schema, NULL::VARCHAR collation_name, NULL::VARCHAR domain_catalog, NULL::VARCHAR domain_schema, NULL::VARCHAR domain_name, NULL::VARCHAR udt_catalog, NULL::VARCHAR udt_schema, NULL::VARCHAR udt_name, NULL::VARCHAR scope_catalog, NULL::VARCHAR scope_schema, NULL::VARCHAR scope_name, NULL::BIGINT maximum_cardinality, NULL::VARCHAR dtd_identifier, NULL::BOOL is_self_referencing, NULL::BOOL is_identity, NULL::VARCHAR identity_generation, NULL::VARCHAR identity_start, NULL::VARCHAR identity_increment, NULL::VARCHAR identity_maximum, NULL::VARCHAR identity_minimum, NULL::BOOL identity_cycle, NULL::VARCHAR is_generated, NULL::VARCHAR generation_expression, NULL::BOOL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"},
-    {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL::VARCHAR default_character_set_catalog, NULL::VARCHAR default_character_set_schema, NULL::VARCHAR default_character_set_name, sql sql_path FROM duckdb_schemas()"},
-    {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL::VARCHAR self_referencing_column_name, NULL::VARCHAR reference_generation, NULL::VARCHAR user_defined_type_catalog, NULL::VARCHAR user_defined_type_schema, NULL::VARCHAR user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"},
-	{"information_schema", "character_sets", "SELECT NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"},
-	{"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, f.constraint_name constraint_name, c.database_name unique_constraint_catalog, c.schema_name unique_constraint_schema, c.constraint_name unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c, duckdb_constraints() f WHERE f.constraint_type = 'FOREIGN KEY' AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY') AND f.database_oid = c.database_oid AND f.schema_oid = c.schema_oid AND lower(f.referenced_table) = lower(c.table_name) AND [lower(x) for x in f.referenced_column_names] = [lower(x) for x in c.constraint_column_names]"},
-	{"information_schema", "key_column_usage", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, UNNEST(constraint_column_names) column_name, UNNEST(generate_series(1, len(constraint_column_names))) ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN 1 ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"},
-	{"information_schema", "table_constraints", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, CASE constraint_type WHEN 'NOT NULL' THEN 'CHECK' ELSE constraint_type END constraint_type, 'NO' is_deferrable, 'NO' initially_deferred, 'YES' enforced, 'YES' nulls_distinct FROM duckdb_constraints() WHERE constraint_type = 'PRIMARY KEY' OR constraint_type = 'FOREIGN KEY' OR constraint_type = 'UNIQUE' OR constraint_type = 'CHECK' OR constraint_type = 'NOT NULL';"},
-    {"information_schema", "constraint_column_usage", "SELECT database_name AS table_catalog, schema_name AS table_schema, table_name, column_name, database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, constraint_type, constraint_text FROM (SELECT dc.*, UNNEST(dc.constraint_column_names) AS column_name FROM duckdb_constraints() AS dc WHERE constraint_type NOT IN ('NOT NULL') );"},
-    {"information_schema", "constraint_table_usage", "SELECT database_name AS table_catalog, schema_name AS table_schema, table_name, database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, constraint_type FROM duckdb_constraints() WHERE constraint_type NOT IN ('NOT NULL');"},
-    {"information_schema", "check_constraints", "SELECT database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, CASE constraint_type WHEN 'NOT NULL' THEN column_name || ' IS NOT NULL' ELSE constraint_text END AS check_clause FROM (SELECT dc.*, UNNEST(dc.constraint_column_names) AS column_name FROM duckdb_constraints() AS dc WHERE constraint_type IN ('CHECK', 'NOT NULL'));"},
-    {"information_schema", "views", "SELECT database_name AS table_catalog, schema_name AS table_schema, view_name AS table_name, sql AS view_definition, 'NONE' AS check_option, 'NO' AS is_updatable, 'NO' AS is_insertable_into, 'NO' AS is_trigger_updatable, 'NO' AS is_trigger_deletable, 'NO' AS is_trigger_insertable_into FROM duckdb_views();"},
-    {nullptr, nullptr, nullptr}};
-
-static unique_ptr<CreateViewInfo> GetDefaultView(ClientContext &context, const string &input_schema, const string &input_name) {
-	auto schema = StringUtil::Lower(input_schema);
-	auto name = StringUtil::Lower(input_name);
-	for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
-		if (internal_views[index].schema == schema && internal_views[index].name == name) {
-			auto result = make_uniq<CreateViewInfo>();
-			result->schema = schema;
-			result->view_name = name;
-			result->sql = internal_views[index].sql;
-			result->temporary = true;
-			result->internal = true;
-
-			return CreateViewInfo::FromSelect(context, std::move(result));
-		}
-	}
-	return nullptr;
-}
-
-DefaultViewGenerator::DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CatalogEntry> DefaultViewGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	auto info = GetDefaultView(context, schema.name, entry_name);
-	if (info) {
-		return make_uniq_base<CatalogEntry, ViewCatalogEntry>(catalog, schema, *info);
-	}
-	return nullptr;
-}
-
-vector<string> DefaultViewGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
-		if (internal_views[index].schema == schema.name) {
-			result.emplace_back(internal_views[index].name);
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/dependency_catalog_set.cpp b/src/duckdb/src/catalog/dependency_catalog_set.cpp
deleted file mode 100644
index bfb3862a4..000000000
--- a/src/duckdb/src/catalog/dependency_catalog_set.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "duckdb/catalog/dependency_catalog_set.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-
-namespace duckdb {
-
-MangledDependencyName DependencyCatalogSet::ApplyPrefix(const MangledEntryName &name) const {
-	return MangledDependencyName(mangled_name, name);
-}
-
-bool DependencyCatalogSet::CreateEntry(CatalogTransaction transaction, const MangledEntryName &name,
-                                       unique_ptr<CatalogEntry> value) {
-	auto new_name = ApplyPrefix(name);
-	const LogicalDependencyList EMPTY_DEPENDENCIES;
-	return set.CreateEntry(transaction, new_name.name, std::move(value), EMPTY_DEPENDENCIES);
-}
-
-CatalogSet::EntryLookup DependencyCatalogSet::GetEntryDetailed(CatalogTransaction transaction,
-                                                               const MangledEntryName &name) {
-	auto new_name = ApplyPrefix(name);
-	return set.GetEntryDetailed(transaction, new_name.name);
-}
-
-optional_ptr<CatalogEntry> DependencyCatalogSet::GetEntry(CatalogTransaction transaction,
-                                                          const MangledEntryName &name) {
-	auto new_name = ApplyPrefix(name);
-	return set.GetEntry(transaction, new_name.name);
-}
-
-void DependencyCatalogSet::Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback) {
-	set.ScanWithPrefix(
-	    transaction,
-	    [&](CatalogEntry &entry) {
-		    auto &dep = entry.Cast<DependencyEntry>();
-		    auto &from = dep.SourceMangledName();
-		    if (!StringUtil::CIEquals(from.name, mangled_name.name)) {
-			    return;
-		    }
-		    callback(entry);
-	    },
-	    mangled_name.name);
-}
-
-bool DependencyCatalogSet::DropEntry(CatalogTransaction transaction, const MangledEntryName &name, bool cascade,
-                                     bool allow_drop_internal) {
-	auto new_name = ApplyPrefix(name);
-	return set.DropEntry(transaction, new_name.name, cascade, allow_drop_internal);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/dependency_list.cpp b/src/duckdb/src/catalog/dependency_list.cpp
deleted file mode 100644
index 1ef3be15f..000000000
--- a/src/duckdb/src/catalog/dependency_list.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-uint64_t LogicalDependencyHashFunction::operator()(const LogicalDependency &a) const {
-	auto &name = a.entry.name;
-	auto &schema = a.entry.schema;
-	auto &type = a.entry.type;
-	auto &catalog = a.catalog;
-
-	hash_t hash = duckdb::Hash(name.c_str());
-	hash = CombineHash(hash, duckdb::Hash(schema.c_str()));
-	hash = CombineHash(hash, duckdb::Hash(catalog.c_str()));
-	hash = CombineHash(hash, duckdb::Hash<uint8_t>(static_cast<uint8_t>(type)));
-	return hash;
-}
-
-bool LogicalDependencyEquality::operator()(const LogicalDependency &a, const LogicalDependency &b) const {
-	if (a.entry.type != b.entry.type) {
-		return false;
-	}
-	if (a.entry.name != b.entry.name) {
-		return false;
-	}
-	if (a.entry.schema != b.entry.schema) {
-		return false;
-	}
-	if (a.catalog != b.catalog) {
-		return false;
-	}
-	return true;
-}
-
-LogicalDependency::LogicalDependency() : entry(), catalog() {
-}
-
-static string GetSchema(CatalogEntry &entry) {
-	if (entry.type == CatalogType::SCHEMA_ENTRY) {
-		return entry.name;
-	}
-	return entry.ParentSchema().name;
-}
-
-LogicalDependency::LogicalDependency(CatalogEntry &entry) {
-	catalog = INVALID_CATALOG;
-	if (entry.type == CatalogType::DEPENDENCY_ENTRY) {
-		auto &dependency_entry = entry.Cast<DependencyEntry>();
-
-		this->entry = dependency_entry.EntryInfo();
-	} else {
-		this->entry.schema = GetSchema(entry);
-		this->entry.name = entry.name;
-		this->entry.type = entry.type;
-		catalog = entry.ParentCatalog().GetName();
-	}
-}
-
-bool LogicalDependency::operator==(const LogicalDependency &other) const {
-	return other.entry.name == entry.name && other.entry.schema == entry.schema && other.entry.type == entry.type;
-}
-
-void LogicalDependencyList::AddDependency(CatalogEntry &entry) {
-	LogicalDependency dependency(entry);
-	set.insert(dependency);
-}
-
-void LogicalDependencyList::AddDependency(const LogicalDependency &entry) {
-	set.insert(entry);
-}
-
-bool LogicalDependencyList::Contains(CatalogEntry &entry_p) {
-	LogicalDependency logical_entry(entry_p);
-	return set.count(logical_entry);
-}
-
-void LogicalDependencyList::VerifyDependencies(Catalog &catalog, const string &name) {
-	for (auto &dep : set) {
-		if (dep.catalog != catalog.GetName()) {
-			throw DependencyException(
-			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
-			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
-			    name, dep.entry.name, dep.catalog, catalog.GetName());
-		}
-	}
-}
-
-const LogicalDependencyList::create_info_set_t &LogicalDependencyList::Set() const {
-	return set;
-}
-
-bool LogicalDependencyList::operator==(const LogicalDependencyList &other) const {
-	if (set.size() != other.set.size()) {
-		return false;
-	}
-
-	for (auto &entry : set) {
-		if (!other.set.count(entry)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/dependency_manager.cpp b/src/duckdb/src/catalog/dependency_manager.cpp
deleted file mode 100644
index 4fcb4d4d1..000000000
--- a/src/duckdb/src/catalog/dependency_manager.cpp
+++ /dev/null
@@ -1,822 +0,0 @@
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_dependent_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
-#include "duckdb/catalog/dependency_catalog_set.hpp"
-
-namespace duckdb {
-
-static void AssertMangledName(const string &mangled_name, idx_t expected_null_bytes) {
-#ifdef DEBUG
-	idx_t nullbyte_count = 0;
-	for (auto &ch : mangled_name) {
-		nullbyte_count += ch == '\0';
-	}
-	D_ASSERT(nullbyte_count == expected_null_bytes);
-#endif
-}
-
-MangledEntryName::MangledEntryName(const CatalogEntryInfo &info) {
-	auto &type = info.type;
-	auto &schema = info.schema;
-	auto &name = info.name;
-
-	this->name = CatalogTypeToString(type) + '\0' + schema + '\0' + name;
-	AssertMangledName(this->name, 2);
-}
-
-MangledDependencyName::MangledDependencyName(const MangledEntryName &from, const MangledEntryName &to) {
-	this->name = from.name + '\0' + to.name;
-	AssertMangledName(this->name, 5);
-}
-
-DependencyManager::DependencyManager(DuckCatalog &catalog) : catalog(catalog), subjects(catalog), dependents(catalog) {
-}
-
-string DependencyManager::GetSchema(const CatalogEntry &entry) {
-	if (entry.type == CatalogType::SCHEMA_ENTRY) {
-		return entry.name;
-	}
-	return entry.ParentSchema().name;
-}
-
-MangledEntryName DependencyManager::MangleName(const CatalogEntryInfo &info) {
-	return MangledEntryName(info);
-}
-
-MangledEntryName DependencyManager::MangleName(const CatalogEntry &entry) {
-	if (entry.type == CatalogType::DEPENDENCY_ENTRY) {
-		auto &dependency_entry = entry.Cast<DependencyEntry>();
-		return dependency_entry.EntryMangledName();
-	}
-	auto type = entry.type;
-	auto schema = GetSchema(entry);
-	auto name = entry.name;
-	CatalogEntryInfo info {type, schema, name};
-
-	return MangleName(info);
-}
-
-DependencyInfo DependencyInfo::FromSubject(DependencyEntry &dep) {
-	return DependencyInfo {/*dependent = */ dep.Dependent(),
-	                       /*subject = */ dep.Subject()};
-}
-
-DependencyInfo DependencyInfo::FromDependent(DependencyEntry &dep) {
-	return DependencyInfo {/*dependent = */ dep.Dependent(),
-	                       /*subject = */ dep.Subject()};
-}
-
-// ----------- DEPENDENCY_MANAGER -----------
-
-bool DependencyManager::IsSystemEntry(CatalogEntry &entry) const {
-	if (entry.internal) {
-		return true;
-	}
-
-	switch (entry.type) {
-	case CatalogType::DEPENDENCY_ENTRY:
-	case CatalogType::DATABASE_ENTRY:
-	case CatalogType::RENAMED_ENTRY:
-		return true;
-	default:
-		return false;
-	}
-}
-
-CatalogSet &DependencyManager::Dependents() {
-	return dependents;
-}
-
-CatalogSet &DependencyManager::Subjects() {
-	return subjects;
-}
-
-void DependencyManager::ScanSetInternal(CatalogTransaction transaction, const CatalogEntryInfo &info,
-                                        bool scan_subjects, dependency_callback_t &callback) {
-	catalog_entry_set_t other_entries;
-
-	auto cb = [&](CatalogEntry &other) {
-		D_ASSERT(other.type == CatalogType::DEPENDENCY_ENTRY);
-		auto &other_entry = other.Cast<DependencyEntry>();
-#ifdef DEBUG
-		auto side = other_entry.Side();
-		if (scan_subjects) {
-			D_ASSERT(side == DependencyEntryType::SUBJECT);
-		} else {
-			D_ASSERT(side == DependencyEntryType::DEPENDENT);
-		}
-
-#endif
-
-		other_entries.insert(other_entry);
-		callback(other_entry);
-	};
-
-	if (scan_subjects) {
-		DependencyCatalogSet subjects(Subjects(), info);
-		subjects.Scan(transaction, cb);
-	} else {
-		DependencyCatalogSet dependents(Dependents(), info);
-		dependents.Scan(transaction, cb);
-	}
-
-#ifdef DEBUG
-	// Verify some invariants
-	// Every dependency should have a matching dependent in the other set
-	// And vice versa
-	auto mangled_name = MangleName(info);
-
-	if (scan_subjects) {
-		for (auto &entry : other_entries) {
-			auto other_info = GetLookupProperties(entry);
-			DependencyCatalogSet other_dependents(Dependents(), other_info);
-
-			// Verify that the other half of the dependency also exists
-			auto dependent = other_dependents.GetEntryDetailed(transaction, mangled_name);
-			D_ASSERT(dependent.reason != CatalogSet::EntryLookup::FailureReason::NOT_PRESENT);
-		}
-	} else {
-		for (auto &entry : other_entries) {
-			auto other_info = GetLookupProperties(entry);
-			DependencyCatalogSet other_subjects(Subjects(), other_info);
-
-			// Verify that the other half of the dependent also exists
-			auto subject = other_subjects.GetEntryDetailed(transaction, mangled_name);
-			D_ASSERT(subject.reason != CatalogSet::EntryLookup::FailureReason::NOT_PRESENT);
-		}
-	}
-#endif
-}
-
-void DependencyManager::ScanDependents(CatalogTransaction transaction, const CatalogEntryInfo &info,
-                                       dependency_callback_t &callback) {
-	ScanSetInternal(transaction, info, false, callback);
-}
-
-void DependencyManager::ScanSubjects(CatalogTransaction transaction, const CatalogEntryInfo &info,
-                                     dependency_callback_t &callback) {
-	ScanSetInternal(transaction, info, true, callback);
-}
-
-void DependencyManager::RemoveDependency(CatalogTransaction transaction, const DependencyInfo &info) {
-	auto &dependent = info.dependent;
-	auto &subject = info.subject;
-
-	// The dependents of the dependency (target)
-	DependencyCatalogSet dependents(Dependents(), subject.entry);
-	// The subjects of the dependencies of the dependent
-	DependencyCatalogSet subjects(Subjects(), dependent.entry);
-
-	auto dependent_mangled = MangledEntryName(dependent.entry);
-	auto subject_mangled = MangledEntryName(subject.entry);
-
-	auto dependent_p = dependents.GetEntry(transaction, dependent_mangled);
-	if (dependent_p) {
-		// 'dependent' is no longer inhibiting the deletion of 'dependency'
-		dependents.DropEntry(transaction, dependent_mangled, false);
-	}
-	auto subject_p = subjects.GetEntry(transaction, subject_mangled);
-	if (subject_p) {
-		// 'dependency' is no longer required by 'dependent'
-		subjects.DropEntry(transaction, subject_mangled, false);
-	}
-}
-
-void DependencyManager::CreateSubject(CatalogTransaction transaction, const DependencyInfo &info) {
-	auto &from = info.dependent.entry;
-
-	DependencyCatalogSet set(Subjects(), from);
-	auto dep = make_uniq_base<DependencyEntry, DependencySubjectEntry>(catalog, info);
-	auto entry_name = dep->EntryMangledName();
-
-	//! Add to the list of objects that 'dependent' has a dependency on
-	set.CreateEntry(transaction, entry_name, std::move(dep));
-}
-
-void DependencyManager::CreateDependent(CatalogTransaction transaction, const DependencyInfo &info) {
-	auto &from = info.subject.entry;
-
-	DependencyCatalogSet set(Dependents(), from);
-	auto dep = make_uniq_base<DependencyEntry, DependencyDependentEntry>(catalog, info);
-	auto entry_name = dep->EntryMangledName();
-
-	//! Add to the list of object that depend on 'subject'
-	set.CreateEntry(transaction, entry_name, std::move(dep));
-}
-
-void DependencyManager::CreateDependency(CatalogTransaction transaction, DependencyInfo &info) {
-	DependencyCatalogSet subjects(Subjects(), info.dependent.entry);
-	DependencyCatalogSet dependents(Dependents(), info.subject.entry);
-
-	auto subject_mangled = MangleName(info.subject.entry);
-	auto dependent_mangled = MangleName(info.dependent.entry);
-
-	auto &dependent_flags = info.dependent.flags;
-	auto &subject_flags = info.subject.flags;
-
-	auto existing_subject = subjects.GetEntry(transaction, subject_mangled);
-	auto existing_dependent = dependents.GetEntry(transaction, dependent_mangled);
-
-	// Inherit the existing flags and drop the existing entry if present
-	if (existing_subject) {
-		auto &existing = existing_subject->Cast<DependencyEntry>();
-		auto existing_flags = existing.Subject().flags;
-		if (existing_flags != subject_flags) {
-			subject_flags.Apply(existing_flags);
-		}
-		subjects.DropEntry(transaction, subject_mangled, false, false);
-	}
-	if (existing_dependent) {
-		auto &existing = existing_dependent->Cast<DependencyEntry>();
-		auto existing_flags = existing.Dependent().flags;
-		if (existing_flags != dependent_flags) {
-			dependent_flags.Apply(existing_flags);
-		}
-		dependents.DropEntry(transaction, dependent_mangled, false, false);
-	}
-
-	// Create an entry in the dependents map of the object that is the target of the dependency
-	CreateDependent(transaction, info);
-	// Create an entry in the subjects map of the object that is targeting another entry
-	CreateSubject(transaction, info);
-}
-
-void DependencyManager::CreateDependencies(CatalogTransaction transaction, const CatalogEntry &object,
-                                           const LogicalDependencyList &dependencies) {
-	DependencyDependentFlags dependency_flags;
-	if (object.type != CatalogType::INDEX_ENTRY) {
-		// indexes do not require CASCADE to be dropped, they are simply always dropped along with the table
-		dependency_flags.SetBlocking();
-	}
-
-	const auto object_info = GetLookupProperties(object);
-	// check for each object in the sources if they were not deleted yet
-	for (auto &dependency : dependencies.Set()) {
-		if (dependency.catalog != object.ParentCatalog().GetName()) {
-			throw DependencyException(
-			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
-			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
-			    object.name, dependency.entry.name, dependency.catalog, object.ParentCatalog().GetName());
-		}
-	}
-
-	// add the object to the dependents_map of each object that it depends on
-	for (auto &dependency : dependencies.Set()) {
-		DependencyInfo info {/*dependent = */ DependencyDependent {GetLookupProperties(object), dependency_flags},
-		                     /*subject = */ DependencySubject {dependency.entry, DependencySubjectFlags()}};
-		CreateDependency(transaction, info);
-	}
-}
-
-void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry &object,
-                                  const LogicalDependencyList &dependencies) {
-	if (IsSystemEntry(object)) {
-		// Don't do anything for this
-		return;
-	}
-	CreateDependencies(transaction, object, dependencies);
-}
-
-static bool CascadeDrop(bool cascade, const DependencyDependentFlags &flags) {
-	if (cascade) {
-		return true;
-	}
-	if (flags.IsOwnedBy()) {
-		// We are owned by this object, while it exists we can not be dropped without cascade.
-		return false;
-	}
-	return !flags.IsBlocking();
-}
-
-CatalogEntryInfo DependencyManager::GetLookupProperties(const CatalogEntry &entry) {
-	if (entry.type == CatalogType::DEPENDENCY_ENTRY) {
-		auto &dependency_entry = entry.Cast<DependencyEntry>();
-		return dependency_entry.EntryInfo();
-	} else {
-		auto schema = DependencyManager::GetSchema(entry);
-		auto &name = entry.name;
-		auto &type = entry.type;
-		return CatalogEntryInfo {type, schema, name};
-	}
-}
-
-optional_ptr<CatalogEntry> DependencyManager::LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency) {
-	if (dependency.type != CatalogType::DEPENDENCY_ENTRY) {
-		return &dependency;
-	}
-	auto info = GetLookupProperties(dependency);
-
-	auto &type = info.type;
-	auto &schema = info.schema;
-	auto &name = info.name;
-
-	// Lookup the schema
-	auto schema_entry = catalog.GetSchema(transaction, schema, OnEntryNotFound::RETURN_NULL);
-	if (type == CatalogType::SCHEMA_ENTRY || !schema_entry) {
-		// This is a schema entry, perform the callback only providing the schema
-		return reinterpret_cast<CatalogEntry *>(schema_entry.get());
-	}
-	auto entry = schema_entry->GetEntry(transaction, type, name);
-	return entry;
-}
-
-void DependencyManager::CleanupDependencies(CatalogTransaction transaction, CatalogEntry &object) {
-	// Collect the dependencies
-	vector<DependencyInfo> to_remove;
-
-	auto info = GetLookupProperties(object);
-	ScanSubjects(transaction, info,
-	             [&](DependencyEntry &dep) { to_remove.push_back(DependencyInfo::FromSubject(dep)); });
-	ScanDependents(transaction, info,
-	               [&](DependencyEntry &dep) { to_remove.push_back(DependencyInfo::FromDependent(dep)); });
-
-	// Remove the dependency entries
-	for (auto &dep : to_remove) {
-		RemoveDependency(transaction, dep);
-	}
-}
-
-static string EntryToString(CatalogEntryInfo &info) {
-	auto type = info.type;
-	switch (type) {
-	case CatalogType::TABLE_ENTRY: {
-		return StringUtil::Format("table \"%s\"", info.name);
-	}
-	case CatalogType::SCHEMA_ENTRY: {
-		return StringUtil::Format("schema \"%s\"", info.name);
-	}
-	case CatalogType::VIEW_ENTRY: {
-		return StringUtil::Format("view \"%s\"", info.name);
-	}
-	case CatalogType::INDEX_ENTRY: {
-		return StringUtil::Format("index \"%s\"", info.name);
-	}
-	case CatalogType::SEQUENCE_ENTRY: {
-		return StringUtil::Format("index \"%s\"", info.name);
-	}
-	case CatalogType::COLLATION_ENTRY: {
-		return StringUtil::Format("collation \"%s\"", info.name);
-	}
-	case CatalogType::TYPE_ENTRY: {
-		return StringUtil::Format("type \"%s\"", info.name);
-	}
-	case CatalogType::TABLE_FUNCTION_ENTRY: {
-		return StringUtil::Format("table function \"%s\"", info.name);
-	}
-	case CatalogType::SCALAR_FUNCTION_ENTRY: {
-		return StringUtil::Format("scalar function \"%s\"", info.name);
-	}
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
-		return StringUtil::Format("aggregate function \"%s\"", info.name);
-	}
-	case CatalogType::PRAGMA_FUNCTION_ENTRY: {
-		return StringUtil::Format("pragma function \"%s\"", info.name);
-	}
-	case CatalogType::COPY_FUNCTION_ENTRY: {
-		return StringUtil::Format("copy function \"%s\"", info.name);
-	}
-	case CatalogType::MACRO_ENTRY: {
-		return StringUtil::Format("macro function \"%s\"", info.name);
-	}
-	case CatalogType::TABLE_MACRO_ENTRY: {
-		return StringUtil::Format("table macro function \"%s\"", info.name);
-	}
-	case CatalogType::SECRET_ENTRY: {
-		return StringUtil::Format("secret \"%s\"", info.name);
-	}
-	case CatalogType::SECRET_TYPE_ENTRY: {
-		return StringUtil::Format("secret type \"%s\"", info.name);
-	}
-	case CatalogType::SECRET_FUNCTION_ENTRY: {
-		return StringUtil::Format("secret function \"%s\"", info.name);
-	}
-	default:
-		throw InternalException("CatalogType not handled in EntryToString (DependencyManager) for %s",
-		                        CatalogTypeToString(type));
-	};
-}
-
-string DependencyManager::CollectDependents(CatalogTransaction transaction, catalog_entry_set_t &entries,
-                                            CatalogEntryInfo &info) {
-	string result;
-	for (auto &entry : entries) {
-		D_ASSERT(!IsSystemEntry(entry.get()));
-		auto other_info = GetLookupProperties(entry);
-		result += StringUtil::Format("%s depends on %s.\n", EntryToString(other_info), EntryToString(info));
-		catalog_entry_set_t entry_dependents;
-		ScanDependents(transaction, other_info, [&](DependencyEntry &dep) {
-			auto child = LookupEntry(transaction, dep);
-			if (!child) {
-				return;
-			}
-			if (!CascadeDrop(false, dep.Dependent().flags)) {
-				entry_dependents.insert(*child);
-			}
-		});
-		if (!entry_dependents.empty()) {
-			result += CollectDependents(transaction, entry_dependents, other_info);
-		}
-	}
-	return result;
-}
-
-void DependencyManager::VerifyExistence(CatalogTransaction transaction, DependencyEntry &object) {
-	auto &subject = object.Subject();
-
-	CatalogEntryInfo info;
-	if (subject.flags.IsOwnership()) {
-		info = object.SourceInfo();
-	} else {
-		info = object.EntryInfo();
-	}
-
-	auto &type = info.type;
-	auto &schema = info.schema;
-	auto &name = info.name;
-
-	auto &duck_catalog = catalog.Cast<DuckCatalog>();
-	auto &schema_catalog_set = duck_catalog.GetSchemaCatalogSet();
-
-	CatalogSet::EntryLookup lookup_result;
-	lookup_result = schema_catalog_set.GetEntryDetailed(transaction, schema);
-
-	if (type != CatalogType::SCHEMA_ENTRY && lookup_result.result) {
-		auto &schema_entry = lookup_result.result->Cast<SchemaCatalogEntry>();
-		lookup_result = schema_entry.GetEntryDetailed(transaction, type, name);
-	}
-
-	if (lookup_result.reason == CatalogSet::EntryLookup::FailureReason::DELETED) {
-		throw DependencyException("Could not commit creation of dependency, subject \"%s\" has been deleted",
-		                          object.SourceInfo().name);
-	}
-}
-
-void DependencyManager::VerifyCommitDrop(CatalogTransaction transaction, transaction_t start_time,
-                                         CatalogEntry &object) {
-	if (IsSystemEntry(object)) {
-		return;
-	}
-	auto info = GetLookupProperties(object);
-	ScanDependents(transaction, info, [&](DependencyEntry &dep) {
-		auto dep_committed_at = dep.timestamp.load();
-		if (dep_committed_at > start_time) {
-			// In the event of a CASCADE, the dependency drop has not committed yet
-			// so we would be halted by the existence of a dependency we are already dropping unless we check the
-			// timestamp
-			//
-			// Which differentiates between objects that we were already aware of (and will subsequently be dropped) and
-			// objects that were introduced inbetween, which should cause this error:
-			throw DependencyException(
-			    "Could not commit DROP of \"%s\" because a dependency was created after the transaction started",
-			    object.name);
-		}
-	});
-	ScanSubjects(transaction, info, [&](DependencyEntry &dep) {
-		auto dep_committed_at = dep.timestamp.load();
-		if (!dep.Dependent().flags.IsOwnedBy()) {
-			return;
-		}
-		D_ASSERT(dep.Subject().flags.IsOwnership());
-		if (dep_committed_at > start_time) {
-			// Same as above, objects that are owned by the object that is being dropped will be dropped as part of this
-			// transaction. Only objects that were introduced by other transactions, that this transaction could not
-			// see, should cause this error:
-			throw DependencyException(
-			    "Could not commit DROP of \"%s\" because a dependency was created after the transaction started",
-			    object.name);
-		}
-	});
-}
-
-catalog_entry_set_t DependencyManager::CheckDropDependencies(CatalogTransaction transaction, CatalogEntry &object,
-                                                             bool cascade) {
-	if (IsSystemEntry(object)) {
-		// Don't do anything for this
-		return catalog_entry_set_t();
-	}
-
-	catalog_entry_set_t to_drop;
-	catalog_entry_set_t blocking_dependents;
-
-	auto info = GetLookupProperties(object);
-	// Look through all the objects that depend on the 'object'
-	ScanDependents(transaction, info, [&](DependencyEntry &dep) {
-		// It makes no sense to have a schema depend on anything
-		D_ASSERT(dep.EntryInfo().type != CatalogType::SCHEMA_ENTRY);
-		auto entry = LookupEntry(transaction, dep);
-		if (!entry) {
-			return;
-		}
-
-		if (!CascadeDrop(cascade, dep.Dependent().flags)) {
-			// no cascade and there are objects that depend on this object: throw error
-			blocking_dependents.insert(*entry);
-		} else {
-			to_drop.insert(*entry);
-		}
-	});
-	if (!blocking_dependents.empty()) {
-		string error_string =
-		    StringUtil::Format("Cannot drop entry \"%s\" because there are entries that depend on it.\n", object.name);
-		error_string += CollectDependents(transaction, blocking_dependents, info);
-		error_string += "Use DROP...CASCADE to drop all dependents.";
-		throw DependencyException(error_string);
-	}
-
-	// Look through all the entries that 'object' depends on
-	ScanSubjects(transaction, info, [&](DependencyEntry &dep) {
-		auto flags = dep.Subject().flags;
-		if (flags.IsOwnership()) {
-			// We own this object, it should be dropped along with the table
-			auto entry = LookupEntry(transaction, dep);
-			to_drop.insert(*entry);
-		}
-	});
-	return to_drop;
-}
-
-void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade) {
-	if (IsSystemEntry(object)) {
-		// Don't do anything for this
-		return;
-	}
-
-	// Check if there are any entries that block the DROP because they still depend on the object
-	auto to_drop = CheckDropDependencies(transaction, object, cascade);
-	CleanupDependencies(transaction, object);
-
-	for (auto &entry : to_drop) {
-		auto set = entry.get().set;
-		D_ASSERT(set);
-		set->DropEntry(transaction, entry.get().name, cascade);
-	}
-}
-
-void DependencyManager::ReorderEntries(catalog_entry_vector_t &entries, ClientContext &context) {
-	auto transaction = catalog.GetCatalogTransaction(context);
-	// Read all the entries visible to this snapshot
-	ReorderEntries(entries, transaction);
-}
-
-void DependencyManager::ReorderEntries(catalog_entry_vector_t &entries) {
-	// Read all committed entries
-	CatalogTransaction transaction(catalog.GetDatabase(), TRANSACTION_ID_START - 1, TRANSACTION_ID_START - 1);
-	ReorderEntries(entries, transaction);
-}
-
-void DependencyManager::ReorderEntry(CatalogTransaction transaction, CatalogEntry &entry, catalog_entry_set_t &visited,
-                                     catalog_entry_vector_t &order) {
-	auto &catalog_entry = *LookupEntry(transaction, entry);
-	// We use this in CheckpointManager, it has the highest commit ID, allowing us to read any committed data
-	bool allow_internal = transaction.start_time == TRANSACTION_ID_START - 1;
-	if (visited.count(catalog_entry) || (!allow_internal && catalog_entry.internal)) {
-		// Already seen and ordered appropriately
-		return;
-	}
-
-	// Check if there are any entries that this entry depends on, those are written first
-	catalog_entry_vector_t dependents;
-	auto info = GetLookupProperties(entry);
-	ScanSubjects(transaction, info, [&](DependencyEntry &dep) { dependents.push_back(dep); });
-	for (auto &dep : dependents) {
-		ReorderEntry(transaction, dep, visited, order);
-	}
-
-	// Then write the entry
-	visited.insert(catalog_entry);
-	order.push_back(catalog_entry);
-}
-
-void DependencyManager::ReorderEntries(catalog_entry_vector_t &entries, CatalogTransaction transaction) {
-	catalog_entry_vector_t reordered;
-	catalog_entry_set_t visited;
-	for (auto &entry : entries) {
-		ReorderEntry(transaction, entry, visited, reordered);
-	}
-	// If this would fail, that means there are more entries that we somehow reached through the dependency manager
-	// but those entries should not actually be visible to this transaction
-	D_ASSERT(entries.size() == reordered.size());
-	entries.clear();
-	entries = reordered;
-}
-
-void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj,
-                                    AlterInfo &alter_info) {
-	if (IsSystemEntry(new_obj)) {
-		D_ASSERT(IsSystemEntry(old_obj));
-		// Don't do anything for this
-		return;
-	}
-
-	const auto old_info = GetLookupProperties(old_obj);
-	const auto new_info = GetLookupProperties(new_obj);
-
-	vector<DependencyInfo> dependencies;
-	// Other entries that depend on us
-	ScanDependents(transaction, old_info, [&](DependencyEntry &dep) {
-		// It makes no sense to have a schema depend on anything
-		D_ASSERT(dep.EntryInfo().type != CatalogType::SCHEMA_ENTRY);
-
-		bool disallow_alter = true;
-		switch (alter_info.type) {
-		case AlterType::ALTER_TABLE: {
-			auto &alter_table = alter_info.Cast<AlterTableInfo>();
-			switch (alter_table.alter_table_type) {
-			case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
-				// These alters are made as part of a CREATE or DROP table statement when a foreign key column is
-				// present either adding or removing a reference to the referenced primary key table
-				disallow_alter = false;
-				break;
-			}
-			case AlterTableType::ADD_COLUMN: {
-				disallow_alter = false;
-				break;
-			}
-			default:
-				break;
-			}
-			break;
-		}
-		case AlterType::SET_COLUMN_COMMENT:
-		case AlterType::SET_COMMENT: {
-			disallow_alter = false;
-			break;
-		}
-		default:
-			break;
-		}
-		if (disallow_alter) {
-			throw DependencyException("Cannot alter entry \"%s\" because there are entries that "
-			                          "depend on it.",
-			                          old_obj.name);
-		}
-
-		auto dep_info = DependencyInfo::FromDependent(dep);
-		dep_info.subject.entry = new_info;
-		dependencies.emplace_back(dep_info);
-	});
-
-	// Keep old dependencies
-	dependency_set_t dependents;
-	ScanSubjects(transaction, old_info, [&](DependencyEntry &dep) {
-		auto entry = LookupEntry(transaction, dep);
-		if (!entry) {
-			return;
-		}
-
-		auto dep_info = DependencyInfo::FromSubject(dep);
-		dep_info.dependent.entry = new_info;
-		dependencies.emplace_back(dep_info);
-	});
-
-	// FIXME: we should update dependencies in the future
-	// some alters could cause dependencies to change (imagine types of table columns)
-	// or DEFAULT depending on a sequence
-	if (!StringUtil::CIEquals(old_obj.name, new_obj.name)) {
-		// The name has been changed, we need to recreate the dependency links
-		CleanupDependencies(transaction, old_obj);
-	}
-
-	// Reinstate the old dependencies
-	for (auto &dep : dependencies) {
-		CreateDependency(transaction, dep);
-	}
-}
-
-void DependencyManager::Scan(
-    ClientContext &context,
-    const std::function<void(CatalogEntry &, CatalogEntry &, const DependencyDependentFlags &)> &callback) {
-	auto transaction = catalog.GetCatalogTransaction(context);
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-
-	// All the objects registered in the dependency manager
-	catalog_entry_set_t entries;
-	dependents.Scan(transaction, [&](CatalogEntry &set) {
-		auto entry = LookupEntry(transaction, set);
-		entries.insert(*entry);
-	});
-
-	// For every registered entry, get the dependents
-	for (auto &entry : entries) {
-		auto entry_info = GetLookupProperties(entry);
-		// Scan all the dependents of the entry
-		ScanDependents(transaction, entry_info, [&](DependencyEntry &dependent) {
-			auto dep = LookupEntry(transaction, dependent);
-			if (!dep) {
-				return;
-			}
-			auto &dependent_entry = *dep;
-			callback(entry, dependent_entry, dependent.Dependent().flags);
-		});
-	}
-}
-
-void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntry &owner, CatalogEntry &entry) {
-	if (IsSystemEntry(entry) || IsSystemEntry(owner)) {
-		return;
-	}
-
-	// If the owner is already owned by something else, throw an error
-	const auto owner_info = GetLookupProperties(owner);
-	ScanDependents(transaction, owner_info, [&](DependencyEntry &dep) {
-		if (dep.Dependent().flags.IsOwnedBy()) {
-			throw DependencyException("%s can not become the owner, it is already owned by %s", owner.name,
-			                          dep.EntryInfo().name);
-		}
-	});
-
-	// If the entry is the owner of another entry, throw an error
-	auto entry_info = GetLookupProperties(entry);
-	ScanSubjects(transaction, entry_info, [&](DependencyEntry &other) {
-		auto dependent_entry = LookupEntry(transaction, other);
-		if (!dependent_entry) {
-			return;
-		}
-		auto &dep = *dependent_entry;
-
-		auto flags = other.Dependent().flags;
-		if (!flags.IsOwnedBy()) {
-			return;
-		}
-		throw DependencyException("%s already owns %s. Cannot have circular dependencies", entry.name, dep.name);
-	});
-
-	// If the entry is already owned, throw an error
-	ScanDependents(transaction, entry_info, [&](DependencyEntry &other) {
-		auto dependent_entry = LookupEntry(transaction, other);
-		if (!dependent_entry) {
-			return;
-		}
-
-		auto &dep = *dependent_entry;
-		auto flags = other.Subject().flags;
-		if (!flags.IsOwnership()) {
-			return;
-		}
-		if (&dep != &owner) {
-			throw DependencyException("%s is already owned by %s", entry.name, dep.name);
-		}
-	});
-
-	DependencyInfo info {
-	    /*dependent = */ DependencyDependent {GetLookupProperties(owner), DependencyDependentFlags().SetOwnedBy()},
-	    /*subject = */ DependencySubject {GetLookupProperties(entry), DependencySubjectFlags().SetOwnership()}};
-	CreateDependency(transaction, info);
-}
-
-static string FormatString(const MangledEntryName &mangled) {
-	auto input = mangled.name;
-	for (size_t i = 0; i < input.size(); i++) {
-		if (input[i] == '\0') {
-			input[i] = '_';
-		}
-	}
-	return input;
-}
-
-void DependencyManager::PrintSubjects(CatalogTransaction transaction, const CatalogEntryInfo &info) {
-	auto name = MangleName(info);
-	Printer::Print(StringUtil::Format("Subjects of %s", FormatString(name)));
-	auto subjects = DependencyCatalogSet(Subjects(), info);
-	subjects.Scan(transaction, [&](CatalogEntry &dependency) {
-		auto &dep = dependency.Cast<DependencyEntry>();
-		auto &entry_info = dep.EntryInfo();
-		auto type = entry_info.type;
-		auto schema = entry_info.schema;
-		auto name = entry_info.name;
-		Printer::Print(StringUtil::Format("Schema: %s | Name: %s | Type: %s | Dependent type: %s | Subject type: %s",
-		                                  schema, name, CatalogTypeToString(type), dep.Dependent().flags.ToString(),
-		                                  dep.Subject().flags.ToString()));
-	});
-}
-
-void DependencyManager::PrintDependents(CatalogTransaction transaction, const CatalogEntryInfo &info) {
-	auto name = MangleName(info);
-	Printer::Print(StringUtil::Format("Dependents of %s", FormatString(name)));
-	auto dependents = DependencyCatalogSet(Dependents(), info);
-	dependents.Scan(transaction, [&](CatalogEntry &dependent) {
-		auto &dep = dependent.Cast<DependencyEntry>();
-		auto &entry_info = dep.EntryInfo();
-		auto type = entry_info.type;
-		auto schema = entry_info.schema;
-		auto name = entry_info.name;
-		Printer::Print(StringUtil::Format("Schema: %s | Name: %s | Type: %s | Dependent type: %s | Subject type: %s",
-		                                  schema, name, CatalogTypeToString(type), dep.Dependent().flags.ToString(),
-		                                  dep.Subject().flags.ToString()));
-	});
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/duck_catalog.cpp b/src/duckdb/src/catalog/duck_catalog.cpp
deleted file mode 100644
index a55349a74..000000000
--- a/src/duckdb/src/catalog/duck_catalog.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/catalog/default/default_schemas.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/function/function_list.hpp"
-
-namespace duckdb {
-
-DuckCatalog::DuckCatalog(AttachedDatabase &db)
-    : Catalog(db), dependency_manager(make_uniq<DependencyManager>(*this)),
-      schemas(make_uniq<CatalogSet>(*this, IsSystemCatalog() ? make_uniq<DefaultSchemaGenerator>(*this) : nullptr)) {
-}
-
-DuckCatalog::~DuckCatalog() {
-}
-
-void DuckCatalog::Initialize(bool load_builtin) {
-	// first initialize the base system catalogs
-	// these are never written to the WAL
-	// we start these at 1 because deleted entries default to 0
-	auto data = CatalogTransaction::GetSystemTransaction(GetDatabase());
-
-	// create the default schema
-	CreateSchemaInfo info;
-	info.schema = DEFAULT_SCHEMA;
-	info.internal = true;
-	CreateSchema(data, info);
-
-	if (load_builtin) {
-		BuiltinFunctions builtin(data, *this);
-		builtin.Initialize();
-
-		// initialize default functions
-		FunctionList::RegisterFunctions(*this, data);
-	}
-
-	Verify();
-}
-
-bool DuckCatalog::IsDuckCatalog() {
-	return true;
-}
-
-optional_ptr<DependencyManager> DuckCatalog::GetDependencyManager() {
-	return dependency_manager.get();
-}
-
-//===--------------------------------------------------------------------===//
-// Schema
-//===--------------------------------------------------------------------===//
-optional_ptr<CatalogEntry> DuckCatalog::CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo &info) {
-	LogicalDependencyList dependencies;
-
-	if (!info.internal && DefaultSchemaGenerator::IsDefaultSchema(info.schema)) {
-		return nullptr;
-	}
-	auto entry = make_uniq<DuckSchemaEntry>(*this, info);
-	auto result = entry.get();
-	if (!schemas->CreateEntry(transaction, info.schema, std::move(entry), dependencies)) {
-		return nullptr;
-	}
-	return result;
-}
-
-optional_ptr<CatalogEntry> DuckCatalog::CreateSchema(CatalogTransaction transaction, CreateSchemaInfo &info) {
-	D_ASSERT(!info.schema.empty());
-	auto result = CreateSchemaInternal(transaction, info);
-	if (!result) {
-		switch (info.on_conflict) {
-		case OnCreateConflict::ERROR_ON_CONFLICT:
-			throw CatalogException::EntryAlreadyExists(CatalogType::SCHEMA_ENTRY, info.schema);
-		case OnCreateConflict::REPLACE_ON_CONFLICT: {
-			DropInfo drop_info;
-			drop_info.type = CatalogType::SCHEMA_ENTRY;
-			drop_info.catalog = info.catalog;
-			drop_info.name = info.schema;
-			DropSchema(transaction, drop_info);
-			result = CreateSchemaInternal(transaction, info);
-			if (!result) {
-				throw InternalException("Failed to create schema entry in CREATE_OR_REPLACE");
-			}
-			break;
-		}
-		case OnCreateConflict::IGNORE_ON_CONFLICT:
-			break;
-		default:
-			throw InternalException("Unsupported OnCreateConflict for CreateSchema");
-		}
-		return nullptr;
-	}
-	return result;
-}
-
-void DuckCatalog::DropSchema(CatalogTransaction transaction, DropInfo &info) {
-	D_ASSERT(!info.name.empty());
-	if (!schemas->DropEntry(transaction, info.name, info.cascade)) {
-		if (info.if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
-			throw CatalogException::MissingEntry(CatalogType::SCHEMA_ENTRY, info.name, string());
-		}
-	}
-}
-
-void DuckCatalog::DropSchema(ClientContext &context, DropInfo &info) {
-	DropSchema(GetCatalogTransaction(context), info);
-}
-
-void DuckCatalog::ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) {
-	schemas->Scan(GetCatalogTransaction(context),
-	              [&](CatalogEntry &entry) { callback(entry.Cast<SchemaCatalogEntry>()); });
-}
-
-void DuckCatalog::ScanSchemas(std::function<void(SchemaCatalogEntry &)> callback) {
-	schemas->Scan([&](CatalogEntry &entry) { callback(entry.Cast<SchemaCatalogEntry>()); });
-}
-
-CatalogSet &DuckCatalog::GetSchemaCatalogSet() {
-	return *schemas;
-}
-
-optional_ptr<SchemaCatalogEntry> DuckCatalog::GetSchema(CatalogTransaction transaction, const string &schema_name,
-                                                        OnEntryNotFound if_not_found, QueryErrorContext error_context) {
-	D_ASSERT(!schema_name.empty());
-	auto entry = schemas->GetEntry(transaction, schema_name);
-	if (!entry) {
-		if (if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
-			throw CatalogException(error_context, "Schema with name %s does not exist!", schema_name);
-		}
-		return nullptr;
-	}
-	return &entry->Cast<SchemaCatalogEntry>();
-}
-
-DatabaseSize DuckCatalog::GetDatabaseSize(ClientContext &context) {
-	auto &transaction = DuckTransactionManager::Get(db);
-	auto lock = transaction.SharedCheckpointLock();
-	return db.GetStorageManager().GetDatabaseSize();
-}
-
-vector<MetadataBlockInfo> DuckCatalog::GetMetadataInfo(ClientContext &context) {
-	auto &transaction = DuckTransactionManager::Get(db);
-	auto lock = transaction.SharedCheckpointLock();
-	return db.GetStorageManager().GetMetadataInfo();
-}
-
-bool DuckCatalog::InMemory() {
-	return db.GetStorageManager().InMemory();
-}
-
-string DuckCatalog::GetDBPath() {
-	return db.GetStorageManager().GetDBPath();
-}
-
-void DuckCatalog::Verify() {
-#ifdef DEBUG
-	Catalog::Verify();
-	schemas->Verify(*this);
-#endif
-}
-
-optional_idx DuckCatalog::GetCatalogVersion(ClientContext &context) {
-	auto &transaction_manager = DuckTransactionManager::Get(db);
-	auto transaction = GetCatalogTransaction(context);
-	D_ASSERT(transaction.transaction);
-	return transaction_manager.GetCatalogVersion(*transaction.transaction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/catalog/similar_catalog_entry.cpp b/src/duckdb/src/catalog/similar_catalog_entry.cpp
deleted file mode 100644
index d3e3487b9..000000000
--- a/src/duckdb/src/catalog/similar_catalog_entry.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/catalog/similar_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-string SimilarCatalogEntry::GetQualifiedName(bool qualify_catalog, bool qualify_schema) const {
-	D_ASSERT(Found());
-	string result;
-	if (qualify_catalog) {
-		result += schema->catalog.GetName();
-	}
-	if (qualify_schema) {
-		if (!result.empty()) {
-			result += ".";
-		}
-		result += schema->name;
-	}
-	if (!result.empty()) {
-		result += ".";
-	}
-	result += name;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/adbc/adbc.cpp b/src/duckdb/src/common/adbc/adbc.cpp
deleted file mode 100644
index 7323f3b1f..000000000
--- a/src/duckdb/src/common/adbc/adbc.cpp
+++ /dev/null
@@ -1,1351 +0,0 @@
-#include "duckdb/common/adbc/adbc.hpp"
-#include "duckdb/common/adbc/adbc-init.hpp"
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include "duckdb.h"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
-
-#include "duckdb/main/capi/capi_internal.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/main/connection.hpp"
-#endif
-
-#include "duckdb/common/adbc/options.h"
-#include "duckdb/common/adbc/single_batch_array_stream.hpp"
-#include "duckdb/function/table/arrow.hpp"
-
-#include <stdlib.h>
-#include <string.h>
-
-// We must leak the symbols of the init function
-AdbcStatusCode duckdb_adbc_init(int version, void *driver, struct AdbcError *error) {
-	if (!driver) {
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto adbc_driver = static_cast<AdbcDriver *>(driver);
-
-	adbc_driver->DatabaseNew = duckdb_adbc::DatabaseNew;
-	adbc_driver->DatabaseSetOption = duckdb_adbc::DatabaseSetOption;
-	adbc_driver->DatabaseInit = duckdb_adbc::DatabaseInit;
-	adbc_driver->DatabaseRelease = duckdb_adbc::DatabaseRelease;
-	adbc_driver->ConnectionNew = duckdb_adbc::ConnectionNew;
-	adbc_driver->ConnectionSetOption = duckdb_adbc::ConnectionSetOption;
-	adbc_driver->ConnectionInit = duckdb_adbc::ConnectionInit;
-	adbc_driver->ConnectionRelease = duckdb_adbc::ConnectionRelease;
-	adbc_driver->ConnectionGetTableTypes = duckdb_adbc::ConnectionGetTableTypes;
-	adbc_driver->StatementNew = duckdb_adbc::StatementNew;
-	adbc_driver->StatementRelease = duckdb_adbc::StatementRelease;
-	adbc_driver->StatementBind = duckdb_adbc::StatementBind;
-	adbc_driver->StatementBindStream = duckdb_adbc::StatementBindStream;
-	adbc_driver->StatementExecuteQuery = duckdb_adbc::StatementExecuteQuery;
-	adbc_driver->StatementPrepare = duckdb_adbc::StatementPrepare;
-	adbc_driver->StatementSetOption = duckdb_adbc::StatementSetOption;
-	adbc_driver->StatementSetSqlQuery = duckdb_adbc::StatementSetSqlQuery;
-	adbc_driver->ConnectionGetObjects = duckdb_adbc::ConnectionGetObjects;
-	adbc_driver->ConnectionCommit = duckdb_adbc::ConnectionCommit;
-	adbc_driver->ConnectionRollback = duckdb_adbc::ConnectionRollback;
-	adbc_driver->ConnectionReadPartition = duckdb_adbc::ConnectionReadPartition;
-	adbc_driver->StatementExecutePartitions = duckdb_adbc::StatementExecutePartitions;
-	adbc_driver->ConnectionGetInfo = duckdb_adbc::ConnectionGetInfo;
-	adbc_driver->StatementGetParameterSchema = duckdb_adbc::StatementGetParameterSchema;
-	adbc_driver->ConnectionGetTableSchema = duckdb_adbc::ConnectionGetTableSchema;
-	adbc_driver->StatementSetSubstraitPlan = duckdb_adbc::StatementSetSubstraitPlan;
-	return ADBC_STATUS_OK;
-}
-
-namespace duckdb_adbc {
-
-enum class IngestionMode { CREATE = 0, APPEND = 1 };
-
-struct DuckDBAdbcStatementWrapper {
-	duckdb_connection connection;
-	duckdb_arrow result;
-	duckdb_prepared_statement statement;
-	char *ingestion_table_name;
-	char *db_schema;
-	ArrowArrayStream ingestion_stream;
-	IngestionMode ingestion_mode = IngestionMode::CREATE;
-	bool temporary_table = false;
-	uint8_t *substrait_plan;
-	uint64_t plan_length;
-};
-
-static AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArrayStream *out, const char *query,
-                                    struct AdbcError *error) {
-	AdbcStatement statement;
-
-	auto status = StatementNew(connection, &statement, error);
-	if (status != ADBC_STATUS_OK) {
-		StatementRelease(&statement, error);
-		SetError(error, "unable to initialize statement");
-		return status;
-	}
-	status = StatementSetSqlQuery(&statement, query, error);
-	if (status != ADBC_STATUS_OK) {
-		StatementRelease(&statement, error);
-		SetError(error, "unable to initialize statement");
-		return status;
-	}
-	status = StatementExecuteQuery(&statement, out, nullptr, error);
-	if (status != ADBC_STATUS_OK) {
-		StatementRelease(&statement, error);
-		SetError(error, "unable to initialize statement");
-		return status;
-	}
-	StatementRelease(&statement, error);
-	return ADBC_STATUS_OK;
-}
-
-struct DuckDBAdbcDatabaseWrapper {
-	//! The DuckDB Database Configuration
-	duckdb_config config = nullptr;
-	//! The DuckDB Database
-	duckdb_database database = nullptr;
-	//! Path of Disk-Based Database or :memory: database
-	std::string path;
-};
-
-static void EmptyErrorRelease(AdbcError *error) {
-	// The object is valid but doesn't contain any data that needs to be cleaned up
-	// Just set the release to nullptr to indicate that it's no longer valid.
-	error->release = nullptr;
-}
-
-void InitializeADBCError(AdbcError *error) {
-	if (!error) {
-		return;
-	}
-	error->message = nullptr;
-	// Don't set to nullptr, as that indicates that it's invalid
-	error->release = EmptyErrorRelease;
-	std::memset(error->sqlstate, '\0', sizeof(error->sqlstate));
-	error->vendor_code = -1;
-}
-
-AdbcStatusCode CheckResult(const duckdb_state &res, AdbcError *error, const char *error_msg) {
-	if (!error) {
-		// Error should be a non-null pointer
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (res != DuckDBSuccess) {
-		SetError(error, error_msg);
-		return ADBC_STATUS_INTERNAL;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error) {
-	if (!database) {
-		SetError(error, "Missing database object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	database->private_data = nullptr;
-	// you can't malloc a struct with a non-trivial C++ constructor
-	// and std::string has a non-trivial constructor. so we need
-	// to use new and delete rather than malloc and free.
-	auto wrapper = new (std::nothrow) DuckDBAdbcDatabaseWrapper;
-	if (!wrapper) {
-		SetError(error, "Allocation error");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	database->private_data = wrapper;
-	auto res = duckdb_create_config(&wrapper->config);
-	return CheckResult(res, error, "Failed to allocate");
-}
-
-AdbcStatusCode StatementSetSubstraitPlan(struct AdbcStatement *statement, const uint8_t *plan, size_t length,
-                                         struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Statement is not set");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!plan) {
-		SetError(error, "Substrait Plan is not set");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (length == 0) {
-		SetError(error, "Can't execute plan with size = 0");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-	if (wrapper->ingestion_stream.release) {
-		// Release any resources currently held by the ingestion stream before we overwrite it
-		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
-		wrapper->ingestion_stream.release = nullptr;
-	}
-	if (wrapper->statement) {
-		duckdb_destroy_prepare(&wrapper->statement);
-		wrapper->statement = nullptr;
-	}
-	wrapper->substrait_plan = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * length));
-	wrapper->plan_length = length;
-	memcpy(wrapper->substrait_plan, plan, length);
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
-                                 struct AdbcError *error) {
-	if (!database) {
-		SetError(error, "Missing database object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!key) {
-		SetError(error, "Missing key");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto wrapper = static_cast<DuckDBAdbcDatabaseWrapper *>(database->private_data);
-	if (strcmp(key, "path") == 0) {
-		wrapper->path = value;
-		return ADBC_STATUS_OK;
-	}
-	auto res = duckdb_set_config(wrapper->config, key, value);
-
-	return CheckResult(res, error, "Failed to set configuration option");
-}
-
-AdbcStatusCode DatabaseInit(struct AdbcDatabase *database, struct AdbcError *error) {
-	if (!error) {
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!database) {
-		SetError(error, "ADBC Database has an invalid pointer");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	char *errormsg = nullptr;
-	// TODO can we set the database path via option, too? Does not look like it...
-	auto wrapper = static_cast<DuckDBAdbcDatabaseWrapper *>(database->private_data);
-	auto res = duckdb_open_ext(wrapper->path.c_str(), &wrapper->database, wrapper->config, &errormsg);
-	auto adbc_result = CheckResult(res, error, errormsg);
-	if (errormsg) {
-		free(errormsg);
-	}
-	return adbc_result;
-}
-
-AdbcStatusCode DatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error) {
-
-	if (database && database->private_data) {
-		auto wrapper = static_cast<DuckDBAdbcDatabaseWrapper *>(database->private_data);
-
-		duckdb_close(&wrapper->database);
-		duckdb_destroy_config(&wrapper->config);
-		delete wrapper;
-		database->private_data = nullptr;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *connection, const char *catalog, const char *db_schema,
-                                        const char *table_name, struct ArrowSchema *schema, struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Connection is not set");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (db_schema == nullptr || strlen(db_schema) == 0) {
-		// if schema is not set, we use the default schema
-		db_schema = "main";
-	}
-	if (table_name == nullptr) {
-		SetError(error, "AdbcConnectionGetTableSchema: must provide table_name");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	} else if (strlen(table_name) == 0) {
-		SetError(error, "AdbcConnectionGetTableSchema: must provide table_name");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	ArrowArrayStream arrow_stream;
-
-	std::string query = "SELECT * FROM ";
-	if (catalog != nullptr && strlen(catalog) > 0) {
-		query += std::string(catalog) + ".";
-	}
-	query += std::string(db_schema) + ".";
-	query += std::string(table_name) + " LIMIT 0;";
-
-	auto success = QueryInternal(connection, &arrow_stream, query.c_str(), error);
-	if (success != ADBC_STATUS_OK) {
-		return success;
-	}
-	arrow_stream.get_schema(&arrow_stream, schema);
-	arrow_stream.release(&arrow_stream);
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode ConnectionNew(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Missing connection object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	connection->private_data = nullptr;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode ExecuteQuery(duckdb::Connection *conn, const char *query, struct AdbcError *error) {
-	auto res = conn->Query(query);
-	if (res->HasError()) {
-		auto error_message = "Failed to execute query \"" + std::string(query) + "\": " + res->GetError();
-		SetError(error, error_message);
-		return ADBC_STATUS_INTERNAL;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode ConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value,
-                                   struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Connection is not set");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto conn = static_cast<duckdb::Connection *>(connection->private_data);
-	if (strcmp(key, ADBC_CONNECTION_OPTION_AUTOCOMMIT) == 0) {
-		if (strcmp(value, ADBC_OPTION_VALUE_ENABLED) == 0) {
-			if (conn->HasActiveTransaction()) {
-				AdbcStatusCode status = ExecuteQuery(conn, "COMMIT", error);
-				if (status != ADBC_STATUS_OK) {
-					return status;
-				}
-			} else {
-				// no-op
-			}
-		} else if (strcmp(value, ADBC_OPTION_VALUE_DISABLED) == 0) {
-			if (conn->HasActiveTransaction()) {
-				// no-op
-			} else {
-				// begin
-				AdbcStatusCode status = ExecuteQuery(conn, "START TRANSACTION", error);
-				if (status != ADBC_STATUS_OK) {
-					return status;
-				}
-			}
-		} else {
-			auto error_message = "Invalid connection option value " + std::string(key) + "=" + std::string(value);
-			SetError(error, error_message);
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-		return ADBC_STATUS_OK;
-	}
-	auto error_message =
-	    "Unknown connection option " + std::string(key) + "=" + (value ? std::string(value) : "(NULL)");
-	SetError(error, error_message);
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
-                                       size_t serialized_length, struct ArrowArrayStream *out,
-                                       struct AdbcError *error) {
-	SetError(error, "Read Partitions are not supported in DuckDB");
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                          struct AdbcPartitions *partitions, int64_t *rows_affected,
-                                          struct AdbcError *error) {
-	SetError(error, "Execute Partitions are not supported in DuckDB");
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Connection is not set");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto conn = static_cast<duckdb::Connection *>(connection->private_data);
-	if (!conn->HasActiveTransaction()) {
-		SetError(error, "No active transaction, cannot commit");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-
-	AdbcStatusCode status = ExecuteQuery(conn, "COMMIT", error);
-	if (status != ADBC_STATUS_OK) {
-		return status;
-	}
-	return ExecuteQuery(conn, "START TRANSACTION", error);
-}
-
-AdbcStatusCode ConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Connection is not set");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto conn = static_cast<duckdb::Connection *>(connection->private_data);
-	if (!conn->HasActiveTransaction()) {
-		SetError(error, "No active transaction, cannot rollback");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-
-	AdbcStatusCode status = ExecuteQuery(conn, "ROLLBACK", error);
-	if (status != ADBC_STATUS_OK) {
-		return status;
-	}
-	return ExecuteQuery(conn, "START TRANSACTION", error);
-}
-
-enum class AdbcInfoCode : uint32_t {
-	VENDOR_NAME,
-	VENDOR_VERSION,
-	DRIVER_NAME,
-	DRIVER_VERSION,
-	DRIVER_ARROW_VERSION,
-	UNRECOGNIZED // always the last entry of the enum
-};
-
-static AdbcInfoCode ConvertToInfoCode(uint32_t info_code) {
-	switch (info_code) {
-	case 0:
-		return AdbcInfoCode::VENDOR_NAME;
-	case 1:
-		return AdbcInfoCode::VENDOR_VERSION;
-	case 2:
-		return AdbcInfoCode::DRIVER_NAME;
-	case 3:
-		return AdbcInfoCode::DRIVER_VERSION;
-	case 4:
-		return AdbcInfoCode::DRIVER_ARROW_VERSION;
-	default:
-		return AdbcInfoCode::UNRECOGNIZED;
-	}
-}
-
-AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes,
-                                 size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Missing connection object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!connection->private_data) {
-		SetError(error, "Connection is invalid");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!out) {
-		SetError(error, "Output parameter was not provided");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	// If 'info_codes' is NULL, we should output all the info codes we recognize
-	size_t length = info_codes ? info_codes_length : static_cast<size_t>(AdbcInfoCode::UNRECOGNIZED);
-
-	duckdb::string q = R"EOF(
-		select
-			name::UINTEGER as info_name,
-			info::UNION(
-				string_value VARCHAR,
-				bool_value BOOL,
-				int64_value BIGINT,
-				int32_bitmask INTEGER,
-				string_list VARCHAR[],
-				int32_to_int32_list_map MAP(INTEGER, INTEGER[])
-			) as info_value from values
-	)EOF";
-
-	duckdb::string results = "";
-
-	for (size_t i = 0; i < length; i++) {
-		auto code = duckdb::NumericCast<uint32_t>(info_codes ? info_codes[i] : i);
-		auto info_code = ConvertToInfoCode(code);
-		switch (info_code) {
-		case AdbcInfoCode::VENDOR_NAME: {
-			results += "(0, 'duckdb'),";
-			break;
-		}
-		case AdbcInfoCode::VENDOR_VERSION: {
-			results += duckdb::StringUtil::Format("(1, '%s'),", duckdb_library_version());
-			break;
-		}
-		case AdbcInfoCode::DRIVER_NAME: {
-			results += "(2, 'ADBC DuckDB Driver'),";
-			break;
-		}
-		case AdbcInfoCode::DRIVER_VERSION: {
-			// TODO: fill in driver version
-			results += "(3, '(unknown)'),";
-			break;
-		}
-		case AdbcInfoCode::DRIVER_ARROW_VERSION: {
-			// TODO: fill in arrow version
-			results += "(4, '(unknown)'),";
-			break;
-		}
-		case AdbcInfoCode::UNRECOGNIZED: {
-			// Unrecognized codes are not an error, just ignored
-			continue;
-		}
-		default: {
-			// Codes that we have implemented but not handled here are a developer error
-			SetError(error, "Info code recognized but not handled");
-			return ADBC_STATUS_INTERNAL;
-		}
-		}
-	}
-	if (results.empty()) {
-		// Add a group of values so the query parses
-		q += "(NULL, NULL)";
-	} else {
-		q += results;
-	}
-	q += " tbl(name, info)";
-	if (results.empty()) {
-		// Add an impossible where clause to return an empty result set
-		q += " where true = false";
-	}
-	return QueryInternal(connection, out, q.c_str(), error);
-}
-
-AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
-                              struct AdbcError *error) {
-	if (!database) {
-		SetError(error, "Missing database object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!database->private_data) {
-		SetError(error, "Invalid database");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!connection) {
-		SetError(error, "Missing connection object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto database_wrapper = static_cast<DuckDBAdbcDatabaseWrapper *>(database->private_data);
-
-	connection->private_data = nullptr;
-	auto res =
-	    duckdb_connect(database_wrapper->database, reinterpret_cast<duckdb_connection *>(&connection->private_data));
-	return CheckResult(res, error, "Failed to connect to Database");
-}
-
-AdbcStatusCode ConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (connection && connection->private_data) {
-		duckdb_disconnect(reinterpret_cast<duckdb_connection *>(&connection->private_data));
-		connection->private_data = nullptr;
-	}
-	return ADBC_STATUS_OK;
-}
-
-// some stream callbacks
-
-static int get_schema(struct ArrowArrayStream *stream, struct ArrowSchema *out) {
-	if (!stream || !stream->private_data || !out) {
-		return DuckDBError;
-	}
-	return duckdb_query_arrow_schema(static_cast<duckdb_arrow>(stream->private_data),
-	                                 reinterpret_cast<duckdb_arrow_schema *>(&out));
-}
-
-static int get_next(struct ArrowArrayStream *stream, struct ArrowArray *out) {
-	if (!stream || !stream->private_data || !out) {
-		return DuckDBError;
-	}
-	out->release = nullptr;
-
-	return duckdb_query_arrow_array(static_cast<duckdb_arrow>(stream->private_data),
-	                                reinterpret_cast<duckdb_arrow_array *>(&out));
-}
-
-void release(struct ArrowArrayStream *stream) {
-	if (!stream || !stream->release) {
-		return;
-	}
-	if (stream->private_data) {
-		duckdb_destroy_arrow(reinterpret_cast<duckdb_arrow *>(&stream->private_data));
-		stream->private_data = nullptr;
-	}
-	stream->release = nullptr;
-}
-
-const char *get_last_error(struct ArrowArrayStream *stream) {
-	if (!stream) {
-		return nullptr;
-	}
-	return nullptr;
-	// return duckdb_query_arrow_error(stream);
-}
-
-// this is an evil hack, normally we would need a stream factory here, but its probably much easier if the adbc clients
-// just hand over a stream
-
-duckdb::unique_ptr<duckdb::ArrowArrayStreamWrapper> stream_produce(uintptr_t factory_ptr,
-                                                                   duckdb::ArrowStreamParameters &parameters) {
-
-	// TODO this will ignore any projections or filters but since we don't expose the scan it should be sort of fine
-	auto res = duckdb::make_uniq<duckdb::ArrowArrayStreamWrapper>();
-	res->arrow_array_stream = *reinterpret_cast<ArrowArrayStream *>(factory_ptr);
-	return res;
-}
-
-void stream_schema(ArrowArrayStream *stream, ArrowSchema &schema) {
-	stream->get_schema(stream, &schema);
-}
-
-AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, const char *schema,
-                      struct ArrowArrayStream *input, struct AdbcError *error, IngestionMode ingestion_mode,
-                      bool temporary) {
-
-	if (!connection) {
-		SetError(error, "Missing connection object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!input) {
-		SetError(error, "Missing input arrow stream pointer");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!table_name) {
-		SetError(error, "Missing database object name");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (schema && temporary) {
-		// Temporary option is not supported with ADBC_INGEST_OPTION_TARGET_DB_SCHEMA or
-		// ADBC_INGEST_OPTION_TARGET_CATALOG
-		SetError(error, "Temporary option is not supported with schema");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
-
-	auto arrow_scan =
-	    cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(input)),
-	                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_produce)),
-	                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_schema))});
-	try {
-		switch (ingestion_mode) {
-		case IngestionMode::CREATE:
-			if (schema) {
-				arrow_scan->Create(schema, table_name, temporary);
-			} else {
-				arrow_scan->Create(table_name, temporary);
-			}
-			break;
-		case IngestionMode::APPEND: {
-			arrow_scan->CreateView("temp_adbc_view", true, true);
-			std::string query;
-			if (schema) {
-				query = duckdb::StringUtil::Format("insert into \"%s.%s\" select * from temp_adbc_view", schema,
-				                                   table_name);
-			} else {
-				query = duckdb::StringUtil::Format("insert into \"%s\" select * from temp_adbc_view", table_name);
-			}
-			auto result = cconn->Query(query);
-			break;
-		}
-		}
-		// After creating a table, the arrow array stream is released. Hence we must set it as released to avoid
-		// double-releasing it
-		input->release = nullptr;
-	} catch (std::exception &ex) {
-		if (error) {
-			duckdb::ErrorData parsed_error(ex);
-			error->message = strdup(parsed_error.RawMessage().c_str());
-		}
-		return ADBC_STATUS_INTERNAL;
-	} catch (...) {
-		return ADBC_STATUS_INTERNAL;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
-                            struct AdbcError *error) {
-	if (!connection) {
-		SetError(error, "Missing connection object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!connection->private_data) {
-		SetError(error, "Invalid connection object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	statement->private_data = nullptr;
-
-	auto statement_wrapper = static_cast<DuckDBAdbcStatementWrapper *>(malloc(sizeof(DuckDBAdbcStatementWrapper)));
-	if (!statement_wrapper) {
-		SetError(error, "Allocation error");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	statement->private_data = statement_wrapper;
-	statement_wrapper->connection = static_cast<duckdb_connection>(connection->private_data);
-	statement_wrapper->statement = nullptr;
-	statement_wrapper->result = nullptr;
-	statement_wrapper->ingestion_stream.release = nullptr;
-	statement_wrapper->ingestion_table_name = nullptr;
-	statement_wrapper->db_schema = nullptr;
-	statement_wrapper->substrait_plan = nullptr;
-	statement_wrapper->temporary_table = false;
-
-	statement_wrapper->ingestion_mode = IngestionMode::CREATE;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode StatementRelease(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement || !statement->private_data) {
-		return ADBC_STATUS_OK;
-	}
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-	if (wrapper->statement) {
-		duckdb_destroy_prepare(&wrapper->statement);
-		wrapper->statement = nullptr;
-	}
-	if (wrapper->result) {
-		duckdb_destroy_arrow(&wrapper->result);
-		wrapper->result = nullptr;
-	}
-	if (wrapper->ingestion_stream.release) {
-		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
-		wrapper->ingestion_stream.release = nullptr;
-	}
-	if (wrapper->ingestion_table_name) {
-		free(wrapper->ingestion_table_name);
-		wrapper->ingestion_table_name = nullptr;
-	}
-	if (wrapper->db_schema) {
-		free(wrapper->db_schema);
-		wrapper->db_schema = nullptr;
-	}
-	if (wrapper->substrait_plan) {
-		free(wrapper->substrait_plan);
-		wrapper->substrait_plan = nullptr;
-	}
-	free(statement->private_data);
-	statement->private_data = nullptr;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                           struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!schema) {
-		SetError(error, "Missing schema object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-	// TODO: we might want to cache this, but then we need to return a deep copy anyways.., so I'm not sure if that
-	// would be worth the extra management
-	auto res = duckdb_prepared_arrow_schema(wrapper->statement, reinterpret_cast<duckdb_arrow_schema *>(&schema));
-	if (res != DuckDBSuccess) {
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode GetPreparedParameters(duckdb_connection connection, duckdb::unique_ptr<duckdb::QueryResult> &result,
-                                     ArrowArrayStream *input, AdbcError *error) {
-
-	auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
-
-	try {
-		auto arrow_scan =
-		    cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(input)),
-		                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_produce)),
-		                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_schema))});
-		result = arrow_scan->Execute();
-		// After creating a table, the arrow array stream is released. Hence we must set it as released to avoid
-		// double-releasing it
-		input->release = nullptr;
-	} catch (std::exception &ex) {
-		if (error) {
-			::duckdb::ErrorData parsed_error(ex);
-			error->message = strdup(parsed_error.RawMessage().c_str());
-		}
-		return ADBC_STATUS_INTERNAL;
-	} catch (...) {
-		return ADBC_STATUS_INTERNAL;
-	}
-	return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode IngestToTableFromBoundStream(DuckDBAdbcStatementWrapper *statement, AdbcError *error) {
-	// See ADBC_INGEST_OPTION_TARGET_TABLE
-	D_ASSERT(statement->ingestion_stream.release);
-	D_ASSERT(statement->ingestion_table_name);
-
-	// Take the input stream from the statement
-	auto stream = statement->ingestion_stream;
-	statement->ingestion_stream.release = nullptr;
-
-	// Ingest into a table from the bound stream
-	return Ingest(statement->connection, statement->ingestion_table_name, statement->db_schema, &stream, error,
-	              statement->ingestion_mode, statement->temporary_table);
-}
-
-AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
-                                     int64_t *rows_affected, struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-
-	// TODO: Set affected rows, careful with early return
-	if (rows_affected) {
-		*rows_affected = 0;
-	}
-
-	const auto has_stream = wrapper->ingestion_stream.release != nullptr;
-	const auto to_table = wrapper->ingestion_table_name != nullptr;
-
-	if (has_stream && to_table) {
-		return IngestToTableFromBoundStream(wrapper, error);
-	}
-	if (wrapper->substrait_plan != nullptr) {
-		auto plan_str = std::string(reinterpret_cast<const char *>(wrapper->substrait_plan), wrapper->plan_length);
-		duckdb::vector<duckdb::Value> params;
-		params.emplace_back(duckdb::Value::BLOB_RAW(plan_str));
-		duckdb::unique_ptr<duckdb::QueryResult> query_result;
-		try {
-			query_result = reinterpret_cast<duckdb::Connection *>(wrapper->connection)
-			                   ->TableFunction("from_substrait", params)
-			                   ->Execute();
-		} catch (duckdb::Exception &e) {
-			std::string error_msg = "It was not possible to execute substrait query. " + std::string(e.what());
-			SetError(error, error_msg);
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-		auto arrow_wrapper = new duckdb::ArrowResultWrapper();
-		arrow_wrapper->result =
-		    duckdb::unique_ptr_cast<duckdb::QueryResult, duckdb::MaterializedQueryResult>(std::move(query_result));
-		wrapper->result = reinterpret_cast<duckdb_arrow>(arrow_wrapper);
-	} else if (has_stream) {
-		// A stream was bound to the statement, use that to bind parameters
-		duckdb::unique_ptr<duckdb::QueryResult> result;
-		ArrowArrayStream stream = wrapper->ingestion_stream;
-		wrapper->ingestion_stream.release = nullptr;
-		auto adbc_res = GetPreparedParameters(wrapper->connection, result, &stream, error);
-		if (adbc_res != ADBC_STATUS_OK) {
-			return adbc_res;
-		}
-		if (!result) {
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-		duckdb::unique_ptr<duckdb::DataChunk> chunk;
-		auto prepared_statement_params =
-		    reinterpret_cast<duckdb::PreparedStatementWrapper *>(wrapper->statement)->statement->named_param_map.size();
-
-		while ((chunk = result->Fetch()) != nullptr) {
-			if (chunk->size() == 0) {
-				SetError(error, "Please provide a non-empty chunk to be bound");
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-			if (chunk->size() != 1) {
-				// TODO: add support for binding multiple rows
-				SetError(error, "Binding multiple rows at once is not supported yet");
-				return ADBC_STATUS_NOT_IMPLEMENTED;
-			}
-			if (chunk->ColumnCount() > prepared_statement_params) {
-				SetError(error, "Input data has more column than prepared statement has parameters");
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-			duckdb_clear_bindings(wrapper->statement);
-			for (idx_t col_idx = 0; col_idx < chunk->ColumnCount(); col_idx++) {
-				auto val = chunk->GetValue(col_idx, 0);
-				auto duck_val = reinterpret_cast<duckdb_value>(&val);
-				auto res = duckdb_bind_value(wrapper->statement, 1 + col_idx, duck_val);
-				if (res != DuckDBSuccess) {
-					SetError(error, duckdb_prepare_error(wrapper->statement));
-					return ADBC_STATUS_INVALID_ARGUMENT;
-				}
-			}
-
-			auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
-			if (res != DuckDBSuccess) {
-				SetError(error, duckdb_query_arrow_error(wrapper->result));
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-		}
-	} else {
-		auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
-		if (res != DuckDBSuccess) {
-			SetError(error, duckdb_query_arrow_error(wrapper->result));
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-	}
-
-	if (out) {
-		out->private_data = wrapper->result;
-		out->get_schema = get_schema;
-		out->get_next = get_next;
-		out->release = release;
-		out->get_last_error = get_last_error;
-
-		// because we handed out the stream pointer its no longer our responsibility to destroy it in
-		// AdbcStatementRelease, this is now done in release()
-		wrapper->result = nullptr;
-	}
-
-	return ADBC_STATUS_OK;
-}
-
-// this is a nop for us
-AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!query) {
-		SetError(error, "Missing query");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-	if (wrapper->ingestion_stream.release) {
-		// Release any resources currently held by the ingestion stream before we overwrite it
-		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
-		wrapper->ingestion_stream.release = nullptr;
-	}
-	if (wrapper->statement) {
-		duckdb_destroy_prepare(&wrapper->statement);
-		wrapper->statement = nullptr;
-	}
-	auto res = duckdb_prepare(wrapper->connection, query, &wrapper->statement);
-	auto error_msg = duckdb_prepare_error(wrapper->statement);
-	return CheckResult(res, error, error_msg);
-}
-
-AdbcStatusCode StatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schemas,
-                             struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!values) {
-		SetError(error, "Missing values object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!schemas) {
-		SetError(error, "Invalid schemas object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-	if (wrapper->ingestion_stream.release) {
-		// Free the stream that was previously bound
-		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
-	}
-	auto status = BatchToArrayStream(values, schemas, &wrapper->ingestion_stream, error);
-	return status;
-}
-
-AdbcStatusCode StatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *values,
-                                   struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!values) {
-		SetError(error, "Missing values object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-	if (wrapper->ingestion_stream.release) {
-		// Release any resources currently held by the ingestion stream before we overwrite it
-		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
-	}
-	wrapper->ingestion_stream = *values;
-	values->release = nullptr;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
-                                  struct AdbcError *error) {
-	if (!statement) {
-		SetError(error, "Missing statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!statement->private_data) {
-		SetError(error, "Invalid statement object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	if (!key) {
-		SetError(error, "Missing key object");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
-
-	if (strcmp(key, ADBC_INGEST_OPTION_TARGET_TABLE) == 0) {
-		wrapper->ingestion_table_name = strdup(value);
-		wrapper->temporary_table = false;
-		return ADBC_STATUS_OK;
-	}
-	if (strcmp(key, ADBC_INGEST_OPTION_TEMPORARY) == 0) {
-		if (strcmp(value, ADBC_OPTION_VALUE_ENABLED) == 0) {
-			if (wrapper->db_schema) {
-				SetError(error, "Temporary option is not supported with schema");
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-			wrapper->temporary_table = true;
-			return ADBC_STATUS_OK;
-		} else if (strcmp(value, ADBC_OPTION_VALUE_DISABLED) == 0) {
-			wrapper->temporary_table = false;
-			return ADBC_STATUS_OK;
-		} else {
-			SetError(
-			    error,
-			    "ADBC_INGEST_OPTION_TEMPORARY, can only be ADBC_OPTION_VALUE_ENABLED or ADBC_OPTION_VALUE_DISABLED");
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-	}
-
-	if (strcmp(key, ADBC_INGEST_OPTION_TARGET_DB_SCHEMA) == 0) {
-		if (wrapper->temporary_table) {
-			SetError(error, "Temporary option is not supported with schema");
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-		wrapper->db_schema = strdup(value);
-		return ADBC_STATUS_OK;
-	}
-
-	if (strcmp(key, ADBC_INGEST_OPTION_MODE) == 0) {
-		if (strcmp(value, ADBC_INGEST_OPTION_MODE_CREATE) == 0) {
-			wrapper->ingestion_mode = IngestionMode::CREATE;
-			return ADBC_STATUS_OK;
-		} else if (strcmp(value, ADBC_INGEST_OPTION_MODE_APPEND) == 0) {
-			wrapper->ingestion_mode = IngestionMode::APPEND;
-			return ADBC_STATUS_OK;
-		} else {
-			SetError(error, "Invalid ingestion mode");
-			return ADBC_STATUS_INVALID_ARGUMENT;
-		}
-	}
-	std::stringstream ss;
-	ss << "Statement Set Option " << key << " is not yet accepted by DuckDB";
-	SetError(error, ss.str());
-	return ADBC_STATUS_INVALID_ARGUMENT;
-}
-
-AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
-                                    const char *db_schema, const char *table_name, const char **table_type,
-                                    const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error) {
-	if (table_type != nullptr) {
-		SetError(error, "Table types parameter not yet supported");
-		return ADBC_STATUS_NOT_IMPLEMENTED;
-	}
-
-	std::string catalog_filter = catalog ? catalog : "%";
-	std::string db_schema_filter = db_schema ? db_schema : "%";
-	std::string table_name_filter = table_name ? table_name : "%";
-	std::string column_name_filter = column_name ? column_name : "%";
-
-	std::string query;
-	switch (depth) {
-	case ADBC_OBJECT_DEPTH_CATALOGS:
-		// Return metadata on catalogs.
-		query = duckdb::StringUtil::Format(R"(
-				SELECT
-					catalog_name,
-					[]::STRUCT(
-						db_schema_name VARCHAR,
-						db_schema_tables STRUCT(
-							table_name VARCHAR,
-							table_type VARCHAR,
-							table_columns STRUCT(
-								column_name VARCHAR,
-								ordinal_position INTEGER,
-								remarks VARCHAR,
-								xdbc_data_type SMALLINT,
-								xdbc_type_name VARCHAR,
-								xdbc_column_size INTEGER,
-								xdbc_decimal_digits SMALLINT,
-								xdbc_num_prec_radix SMALLINT,
-								xdbc_nullable SMALLINT,
-								xdbc_column_def VARCHAR,
-								xdbc_sql_data_type SMALLINT,
-								xdbc_datetime_sub SMALLINT,
-								xdbc_char_octet_length INTEGER,
-								xdbc_is_nullable VARCHAR,
-								xdbc_scope_catalog VARCHAR,
-								xdbc_scope_schema VARCHAR,
-								xdbc_scope_table VARCHAR,
-								xdbc_is_autoincrement BOOLEAN,
-								xdbc_is_generatedcolumn BOOLEAN
-							)[],
-							table_constraints STRUCT(
-								constraint_name VARCHAR,
-								constraint_type VARCHAR,
-								constraint_column_names VARCHAR[],
-								constraint_column_usage STRUCT(fk_catalog VARCHAR, fk_db_schema VARCHAR, fk_table VARCHAR, fk_column_name VARCHAR)[]
-							)[]
-						)[]
-					)[] catalog_db_schemas
-				FROM
-					information_schema.schemata
-				WHERE catalog_name LIKE '%s'
-				GROUP BY catalog_name
-				)",
-		                                   catalog_filter);
-		break;
-	case ADBC_OBJECT_DEPTH_DB_SCHEMAS:
-		// Return metadata on catalogs and schemas.
-		query = duckdb::StringUtil::Format(R"(
-				WITH db_schemas AS (
-					SELECT
-						catalog_name,
-						schema_name,
-					FROM information_schema.schemata
-					WHERE schema_name LIKE '%s'
-				)
-
-				SELECT
-					catalog_name,
-					LIST({
-						db_schema_name: schema_name,
-						db_schema_tables: []::STRUCT(
-							table_name VARCHAR,
-							table_type VARCHAR,
-							table_columns STRUCT(
-								column_name VARCHAR,
-								ordinal_position INTEGER,
-								remarks VARCHAR,
-								xdbc_data_type SMALLINT,
-								xdbc_type_name VARCHAR,
-								xdbc_column_size INTEGER,
-								xdbc_decimal_digits SMALLINT,
-								xdbc_num_prec_radix SMALLINT,
-								xdbc_nullable SMALLINT,
-								xdbc_column_def VARCHAR,
-								xdbc_sql_data_type SMALLINT,
-								xdbc_datetime_sub SMALLINT,
-								xdbc_char_octet_length INTEGER,
-								xdbc_is_nullable VARCHAR,
-								xdbc_scope_catalog VARCHAR,
-								xdbc_scope_schema VARCHAR,
-								xdbc_scope_table VARCHAR,
-								xdbc_is_autoincrement BOOLEAN,
-								xdbc_is_generatedcolumn BOOLEAN
-							)[],
-							table_constraints STRUCT(
-								constraint_name VARCHAR,
-								constraint_type VARCHAR,
-								constraint_column_names VARCHAR[],
-								constraint_column_usage STRUCT(fk_catalog VARCHAR, fk_db_schema VARCHAR, fk_table VARCHAR, fk_column_name VARCHAR)[]
-							)[]
-						)[],
-					}) FILTER (dbs.schema_name is not null) catalog_db_schemas
-				FROM
-					information_schema.schemata
-				LEFT JOIN db_schemas dbs
-				USING (catalog_name, schema_name)
-				WHERE catalog_name LIKE '%s'
-				GROUP BY catalog_name
-				)",
-		                                   db_schema_filter, catalog_filter);
-		break;
-	case ADBC_OBJECT_DEPTH_TABLES:
-		// Return metadata on catalogs, schemas, and tables.
-		query = duckdb::StringUtil::Format(R"(
-				WITH tables AS (
-					SELECT
-						table_catalog catalog_name,
-						table_schema schema_name,
-						LIST({
-							table_name: table_name,
-							table_type: table_type,
-							table_columns: []::STRUCT(
-								column_name VARCHAR,
-								ordinal_position INTEGER,
-								remarks VARCHAR,
-								xdbc_data_type SMALLINT,
-								xdbc_type_name VARCHAR,
-								xdbc_column_size INTEGER,
-								xdbc_decimal_digits SMALLINT,
-								xdbc_num_prec_radix SMALLINT,
-								xdbc_nullable SMALLINT,
-								xdbc_column_def VARCHAR,
-								xdbc_sql_data_type SMALLINT,
-								xdbc_datetime_sub SMALLINT,
-								xdbc_char_octet_length INTEGER,
-								xdbc_is_nullable VARCHAR,
-								xdbc_scope_catalog VARCHAR,
-								xdbc_scope_schema VARCHAR,
-								xdbc_scope_table VARCHAR,
-								xdbc_is_autoincrement BOOLEAN,
-								xdbc_is_generatedcolumn BOOLEAN
-							)[],
-							table_constraints: []::STRUCT(
-								constraint_name VARCHAR,
-								constraint_type VARCHAR,
-								constraint_column_names VARCHAR[],
-								constraint_column_usage STRUCT(fk_catalog VARCHAR, fk_db_schema VARCHAR, fk_table VARCHAR, fk_column_name VARCHAR)[]
-							)[],
-						}) db_schema_tables
-					FROM information_schema.tables
-					WHERE table_name LIKE '%s'
-					GROUP BY table_catalog, table_schema
-				),
-				db_schemas AS (
-					SELECT
-						catalog_name,
-						schema_name,
-						db_schema_tables,
-					FROM information_schema.schemata
-					LEFT JOIN tables
-					USING (catalog_name, schema_name)
-					WHERE schema_name LIKE '%s'
-				)
-
-				SELECT
-					catalog_name,
-					LIST({
-						db_schema_name: schema_name,
-						db_schema_tables: db_schema_tables,
-					}) FILTER (dbs.schema_name is not null) catalog_db_schemas
-				FROM
-					information_schema.schemata
-				LEFT JOIN db_schemas dbs
-				USING (catalog_name, schema_name)
-				WHERE catalog_name LIKE '%s'
-				GROUP BY catalog_name
-				)",
-		                                   table_name_filter, db_schema_filter, catalog_filter);
-		break;
-	case ADBC_OBJECT_DEPTH_COLUMNS:
-		// Return metadata on catalogs, schemas, tables, and columns.
-		query = duckdb::StringUtil::Format(R"(
-				WITH columns AS (
-					SELECT
-						table_catalog,
-						table_schema,
-						table_name,
-						LIST({
-							column_name: column_name,
-							ordinal_position: ordinal_position,
-							remarks : '',
-							xdbc_data_type: NULL::SMALLINT,
-							xdbc_type_name: NULL::VARCHAR,
-							xdbc_column_size: NULL::INTEGER,
-							xdbc_decimal_digits: NULL::SMALLINT,
-							xdbc_num_prec_radix: NULL::SMALLINT,
-							xdbc_nullable: NULL::SMALLINT,
-							xdbc_column_def: NULL::VARCHAR,
-							xdbc_sql_data_type: NULL::SMALLINT,
-							xdbc_datetime_sub: NULL::SMALLINT,
-							xdbc_char_octet_length: NULL::INTEGER,
-							xdbc_is_nullable: NULL::VARCHAR,
-							xdbc_scope_catalog: NULL::VARCHAR,
-							xdbc_scope_schema: NULL::VARCHAR,
-							xdbc_scope_table: NULL::VARCHAR,
-							xdbc_is_autoincrement: NULL::BOOLEAN,
-							xdbc_is_generatedcolumn: NULL::BOOLEAN,
-						}) table_columns
-					FROM information_schema.columns
-					WHERE column_name LIKE '%s'
-					GROUP BY table_catalog, table_schema, table_name
-				),
-				constraints AS (
-					SELECT
-						table_catalog,
-						table_schema,
-						table_name,
-						LIST(
-							{
-								constraint_name: constraint_name,
-								constraint_type: constraint_type,
-								constraint_column_names: []::VARCHAR[],
-								constraint_column_usage: []::STRUCT(fk_catalog VARCHAR, fk_db_schema VARCHAR, fk_table VARCHAR, fk_column_name VARCHAR)[],
-							}
-						) table_constraints
-					FROM information_schema.table_constraints
-					GROUP BY table_catalog, table_schema, table_name
-				),
-				tables AS (
-					SELECT
-						table_catalog catalog_name,
-						table_schema schema_name,
-						LIST({
-							table_name: table_name,
-							table_type: table_type,
-							table_columns: table_columns,
-							table_constraints: table_constraints,
-						}) db_schema_tables
-					FROM information_schema.tables
-					LEFT JOIN columns
-					USING (table_catalog, table_schema, table_name)
-					LEFT JOIN constraints
-					USING (table_catalog, table_schema, table_name)
-					WHERE table_name LIKE '%s'
-					GROUP BY table_catalog, table_schema
-				),
-				db_schemas AS (
-					SELECT
-						catalog_name,
-						schema_name,
-						db_schema_tables,
-					FROM information_schema.schemata
-					LEFT JOIN tables
-					USING (catalog_name, schema_name)
-					WHERE schema_name LIKE '%s'
-				)
-
-				SELECT
-					catalog_name,
-					LIST({
-						db_schema_name: schema_name,
-						db_schema_tables: db_schema_tables,
-					}) FILTER (dbs.schema_name is not null) catalog_db_schemas
-				FROM
-					information_schema.schemata
-				LEFT JOIN db_schemas dbs
-				USING (catalog_name, schema_name)
-				WHERE catalog_name LIKE '%s'
-				GROUP BY catalog_name
-				)",
-		                                   column_name_filter, table_name_filter, db_schema_filter, catalog_filter);
-		break;
-	default:
-		SetError(error, "Invalid value of Depth");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	return QueryInternal(connection, out, query.c_str(), error);
-}
-
-AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,
-                                       struct AdbcError *error) {
-	const auto q = "SELECT DISTINCT table_type FROM information_schema.tables ORDER BY table_type";
-	return QueryInternal(connection, out, q, error);
-}
-
-} // namespace duckdb_adbc
diff --git a/src/duckdb/src/common/adbc/driver_manager.cpp b/src/duckdb/src/common/adbc/driver_manager.cpp
deleted file mode 100644
index 1d2bc1f23..000000000
--- a/src/duckdb/src/common/adbc/driver_manager.cpp
+++ /dev/null
@@ -1,1624 +0,0 @@
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-// THIS FILE IS GENERATED BY apache/arrow, DO NOT EDIT MANUALLY //
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/adbc/driver_manager.h"
-#include "duckdb/common/adbc/adbc.h"
-#include "duckdb/common/adbc/adbc.hpp"
-
-#include <algorithm>
-#include <array>
-#include <cctype>
-#include <cstring>
-#include <string>
-#include <unordered_map>
-#include <utility>
-
-#if defined(_WIN32)
-#include <windows.h> // Must come first
-
-#include <libloaderapi.h>
-#include <strsafe.h>
-#else
-#include <dlfcn.h>
-#endif // defined(_WIN32)
-
-// Platform-specific helpers
-
-#if defined(_WIN32)
-/// Append a description of the Windows error to the buffer.
-void GetWinError(std::string *buffer) {
-	DWORD rc = GetLastError();
-	LPVOID message;
-
-	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-	              /*lpSource=*/nullptr, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-	              reinterpret_cast<LPSTR>(&message), /*nSize=*/0, /*Arguments=*/nullptr);
-
-	(*buffer) += '(';
-	(*buffer) += std::to_string(rc);
-	(*buffer) += ") ";
-	(*buffer) += reinterpret_cast<char *>(message);
-	LocalFree(message);
-}
-
-#endif // defined(_WIN32)
-
-// Error handling
-
-void ReleaseError(struct AdbcError *error) {
-	if (error) {
-		if (error->message)
-			delete[] error->message;
-		error->message = nullptr;
-		error->release = nullptr;
-	}
-}
-
-void SetError(struct AdbcError *error, const std::string &message) {
-	if (!error)
-		return;
-	if (error->message) {
-		// Append
-		std::string buffer = error->message;
-		buffer.reserve(buffer.size() + message.size() + 1);
-		buffer += '\n';
-		buffer += message;
-		error->release(error);
-
-		error->message = new char[buffer.size() + 1];
-		buffer.copy(error->message, buffer.size());
-		error->message[buffer.size()] = '\0';
-	} else {
-		error->message = new char[message.size() + 1];
-		message.copy(error->message, message.size());
-		error->message[message.size()] = '\0';
-	}
-	error->release = ReleaseError;
-}
-
-// Driver state
-
-/// A driver DLL.
-struct ManagedLibrary {
-	ManagedLibrary() : handle(nullptr) {
-	}
-	ManagedLibrary(ManagedLibrary &&other) : handle(other.handle) {
-		other.handle = nullptr;
-	}
-	ManagedLibrary(const ManagedLibrary &) = delete;
-	ManagedLibrary &operator=(const ManagedLibrary &) = delete;
-	ManagedLibrary &operator=(ManagedLibrary &&other) noexcept {
-		this->handle = other.handle;
-		other.handle = nullptr;
-		return *this;
-	}
-
-	~ManagedLibrary() {
-		Release();
-	}
-
-	void Release() {
-		// TODO(apache/arrow-adbc#204): causes tests to segfault
-		// Need to refcount the driver DLL; also, errors may retain a reference to
-		// release() from the DLL - how to handle this?
-	}
-
-	AdbcStatusCode Load(const char *library, struct AdbcError *error) {
-		std::string error_message;
-#if defined(_WIN32)
-		HMODULE handle = LoadLibraryExA(library, NULL, 0);
-		if (!handle) {
-			error_message += library;
-			error_message += ": LoadLibraryExA() failed: ";
-			GetWinError(&error_message);
-
-			std::string full_driver_name = library;
-			full_driver_name += ".dll";
-			handle = LoadLibraryExA(full_driver_name.c_str(), NULL, 0);
-			if (!handle) {
-				error_message += '\n';
-				error_message += full_driver_name;
-				error_message += ": LoadLibraryExA() failed: ";
-				GetWinError(&error_message);
-			}
-		}
-		if (!handle) {
-			SetError(error, error_message);
-			return ADBC_STATUS_INTERNAL;
-		} else {
-			this->handle = handle;
-		}
-#else
-		const std::string kPlatformLibraryPrefix = "lib";
-#if defined(__APPLE__)
-		const std::string kPlatformLibrarySuffix = ".dylib";
-#else
-		static const std::string kPlatformLibrarySuffix = ".so";
-#endif // defined(__APPLE__)
-
-		void *handle = dlopen(library, RTLD_NOW | RTLD_LOCAL);
-		if (!handle) {
-			error_message = "dlopen() failed: ";
-			error_message += dlerror();
-
-			// If applicable, append the shared library prefix/extension and
-			// try again (this way you don't have to hardcode driver names by
-			// platform in the application)
-			const std::string driver_str = library;
-
-			std::string full_driver_name;
-			if (driver_str.size() < kPlatformLibraryPrefix.size() ||
-			    driver_str.compare(0, kPlatformLibraryPrefix.size(), kPlatformLibraryPrefix) != 0) {
-				full_driver_name += kPlatformLibraryPrefix;
-			}
-			full_driver_name += library;
-			if (driver_str.size() < kPlatformLibrarySuffix.size() ||
-			    driver_str.compare(full_driver_name.size() - kPlatformLibrarySuffix.size(),
-			                       kPlatformLibrarySuffix.size(), kPlatformLibrarySuffix) != 0) {
-				full_driver_name += kPlatformLibrarySuffix;
-			}
-			handle = dlopen(full_driver_name.c_str(), RTLD_NOW | RTLD_LOCAL);
-			if (!handle) {
-				error_message += "\ndlopen() failed: ";
-				error_message += dlerror();
-			}
-		}
-		if (handle) {
-			this->handle = handle;
-		} else {
-			return ADBC_STATUS_INTERNAL;
-		}
-#endif // defined(_WIN32)
-		return ADBC_STATUS_OK;
-	}
-
-	AdbcStatusCode Lookup(const char *name, void **func, struct AdbcError *error) {
-#if defined(_WIN32)
-		void *load_handle = reinterpret_cast<void *>(GetProcAddress(handle, name));
-		if (!load_handle) {
-			std::string message = "GetProcAddress(";
-			message += name;
-			message += ") failed: ";
-			GetWinError(&message);
-			SetError(error, message);
-			return ADBC_STATUS_INTERNAL;
-		}
-#else
-		void *load_handle = dlsym(handle, name);
-		if (!load_handle) {
-			std::string message = "dlsym(";
-			message += name;
-			message += ") failed: ";
-			message += dlerror();
-			SetError(error, message);
-			return ADBC_STATUS_INTERNAL;
-		}
-#endif // defined(_WIN32)
-		*func = load_handle;
-		return ADBC_STATUS_OK;
-	}
-
-#if defined(_WIN32)
-	// The loaded DLL
-	HMODULE handle;
-#else
-	void *handle;
-#endif // defined(_WIN32)
-};
-
-/// Hold the driver DLL and the driver release callback in the driver struct.
-struct ManagerDriverState {
-	// The original release callback
-	AdbcStatusCode (*driver_release)(struct AdbcDriver *driver, struct AdbcError *error);
-
-	ManagedLibrary handle;
-};
-
-/// Unload the driver DLL.
-static AdbcStatusCode ReleaseDriver(struct AdbcDriver *driver, struct AdbcError *error) {
-	AdbcStatusCode status = ADBC_STATUS_OK;
-
-	if (!driver->private_manager)
-		return status;
-	ManagerDriverState *state = reinterpret_cast<ManagerDriverState *>(driver->private_manager);
-
-	if (state->driver_release) {
-		status = state->driver_release(driver, error);
-	}
-	state->handle.Release();
-
-	driver->private_manager = nullptr;
-	delete state;
-	return status;
-}
-
-// ArrowArrayStream wrapper to support AdbcErrorFromArrayStream
-
-struct ErrorArrayStream {
-	struct ArrowArrayStream stream;
-	struct AdbcDriver *private_driver;
-};
-
-void ErrorArrayStreamRelease(struct ArrowArrayStream *stream) {
-	if (stream->release != ErrorArrayStreamRelease || !stream->private_data)
-		return;
-
-	auto *private_data = reinterpret_cast<struct ErrorArrayStream *>(stream->private_data);
-	private_data->stream.release(&private_data->stream);
-	delete private_data;
-	std::memset(stream, 0, sizeof(*stream));
-}
-
-const char *ErrorArrayStreamGetLastError(struct ArrowArrayStream *stream) {
-	if (stream->release != ErrorArrayStreamRelease || !stream->private_data)
-		return nullptr;
-	auto *private_data = reinterpret_cast<struct ErrorArrayStream *>(stream->private_data);
-	return private_data->stream.get_last_error(&private_data->stream);
-}
-
-int ErrorArrayStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *array) {
-	if (stream->release != ErrorArrayStreamRelease || !stream->private_data)
-		return EINVAL;
-	auto *private_data = reinterpret_cast<struct ErrorArrayStream *>(stream->private_data);
-	return private_data->stream.get_next(&private_data->stream, array);
-}
-
-int ErrorArrayStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *schema) {
-	if (stream->release != ErrorArrayStreamRelease || !stream->private_data)
-		return EINVAL;
-	auto *private_data = reinterpret_cast<struct ErrorArrayStream *>(stream->private_data);
-	return private_data->stream.get_schema(&private_data->stream, schema);
-}
-
-// Default stubs
-
-int ErrorGetDetailCount(const struct AdbcError *error) {
-	return 0;
-}
-
-struct AdbcErrorDetail ErrorGetDetail(const struct AdbcError *error, int index) {
-	return {nullptr, nullptr, 0};
-}
-
-const struct AdbcError *ErrorFromArrayStream(struct ArrowArrayStream *stream, AdbcStatusCode *status) {
-	return nullptr;
-}
-
-void ErrorArrayStreamInit(struct ArrowArrayStream *out, struct AdbcDriver *private_driver) {
-	if (!out || !out->release ||
-	    // Don't bother wrapping if driver didn't claim support
-	    private_driver->ErrorFromArrayStream == ErrorFromArrayStream) {
-		return;
-	}
-	struct ErrorArrayStream *private_data = new ErrorArrayStream;
-	private_data->stream = *out;
-	private_data->private_driver = private_driver;
-	out->get_last_error = ErrorArrayStreamGetLastError;
-	out->get_next = ErrorArrayStreamGetNext;
-	out->get_schema = ErrorArrayStreamGetSchema;
-	out->release = ErrorArrayStreamRelease;
-	out->private_data = private_data;
-}
-
-AdbcStatusCode DatabaseGetOption(struct AdbcDatabase *database, const char *key, char *value, size_t *length,
-                                 struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode DatabaseGetOptionBytes(struct AdbcDatabase *database, const char *key, uint8_t *value, size_t *length,
-                                      struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode DatabaseGetOptionInt(struct AdbcDatabase *database, const char *key, int64_t *value,
-                                    struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode DatabaseGetOptionDouble(struct AdbcDatabase *database, const char *key, double *value,
-                                       struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode DatabaseSetOptionBytes(struct AdbcDatabase *database, const char *key, const uint8_t *value,
-                                      size_t length, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode DatabaseSetOptionInt(struct AdbcDatabase *database, const char *key, int64_t value,
-                                    struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode DatabaseSetOptionDouble(struct AdbcDatabase *database, const char *key, double value,
-                                       struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionCancel(struct AdbcConnection *connection, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionGetOption(struct AdbcConnection *connection, const char *key, char *value, size_t *length,
-                                   struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode ConnectionGetOptionBytes(struct AdbcConnection *connection, const char *key, uint8_t *value,
-                                        size_t *length, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode ConnectionGetOptionInt(struct AdbcConnection *connection, const char *key, int64_t *value,
-                                      struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode ConnectionGetOptionDouble(struct AdbcConnection *connection, const char *key, double *value,
-                                         struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode ConnectionGetStatistics(struct AdbcConnection *, const char *, const char *, const char *, char,
-                                       struct ArrowArrayStream *, struct AdbcError *) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionGetStatisticNames(struct AdbcConnection *, struct ArrowArrayStream *, struct AdbcError *) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionSetOptionBytes(struct AdbcConnection *, const char *, const uint8_t *, size_t,
-                                        struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionSetOptionInt(struct AdbcConnection *connection, const char *key, int64_t value,
-                                      struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionSetOptionDouble(struct AdbcConnection *connection, const char *key, double value,
-                                         struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementCancel(struct AdbcStatement *statement, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementExecuteSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                      struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementGetOption(struct AdbcStatement *statement, const char *key, char *value, size_t *length,
-                                  struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode StatementGetOptionBytes(struct AdbcStatement *statement, const char *key, uint8_t *value, size_t *length,
-                                       struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode StatementGetOptionInt(struct AdbcStatement *statement, const char *key, int64_t *value,
-                                     struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode StatementGetOptionDouble(struct AdbcStatement *statement, const char *key, double *value,
-                                        struct AdbcError *error) {
-	return ADBC_STATUS_NOT_FOUND;
-}
-
-AdbcStatusCode StatementSetOptionBytes(struct AdbcStatement *, const char *, const uint8_t *, size_t,
-                                       struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementSetOptionInt(struct AdbcStatement *statement, const char *key, int64_t value,
-                                     struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementSetOptionDouble(struct AdbcStatement *statement, const char *key, double value,
-                                        struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-/// Temporary state while the database is being configured.
-struct TempDatabase {
-	std::unordered_map<std::string, std::string> options;
-	std::unordered_map<std::string, std::string> bytes_options;
-	std::unordered_map<std::string, int64_t> int_options;
-	std::unordered_map<std::string, double> double_options;
-	std::string driver;
-	std::string entrypoint;
-	AdbcDriverInitFunc init_func = nullptr;
-};
-
-/// Temporary state while the database is being configured.
-struct TempConnection {
-	std::unordered_map<std::string, std::string> options;
-	std::unordered_map<std::string, std::string> bytes_options;
-	std::unordered_map<std::string, int64_t> int_options;
-	std::unordered_map<std::string, double> double_options;
-};
-
-static const char kDefaultEntrypoint[] = "AdbcDriverInit";
-
-// Other helpers (intentionally not in an anonymous namespace so they can be tested)
-
-ADBC_EXPORT
-std::string AdbcDriverManagerDefaultEntrypoint(const std::string &driver) {
-	/// - libadbc_driver_sqlite.so.2.0.0 -> AdbcDriverSqliteInit
-	/// - adbc_driver_sqlite.dll -> AdbcDriverSqliteInit
-	/// - proprietary_driver.dll -> AdbcProprietaryDriverInit
-
-	// Potential path -> filename
-	// Treat both \ and / as directory separators on all platforms for simplicity
-	std::string filename;
-	{
-		size_t pos = driver.find_last_of("/\\");
-		if (pos != std::string::npos) {
-			filename = driver.substr(pos + 1);
-		} else {
-			filename = driver;
-		}
-	}
-
-	// Remove all extensions
-	{
-		size_t pos = filename.find('.');
-		if (pos != std::string::npos) {
-			filename = filename.substr(0, pos);
-		}
-	}
-
-	// Remove lib prefix
-	// https://stackoverflow.com/q/1878001/262727
-	if (filename.rfind("lib", 0) == 0) {
-		filename = filename.substr(3);
-	}
-
-	// Split on underscores, hyphens
-	// Capitalize and join
-	std::string entrypoint;
-	entrypoint.reserve(filename.size());
-	size_t pos = 0;
-	while (pos < filename.size()) {
-		size_t prev = pos;
-		pos = filename.find_first_of("-_", pos);
-		// if pos == npos this is the entire filename
-		std::string token = filename.substr(prev, pos - prev);
-		// capitalize first letter
-		token[0] = duckdb::NumericCast<char>(std::toupper(static_cast<unsigned char>(token[0])));
-
-		entrypoint += token;
-
-		if (pos != std::string::npos) {
-			pos++;
-		}
-	}
-
-	if (entrypoint.rfind("Adbc", 0) != 0) {
-		entrypoint = "Adbc" + entrypoint;
-	}
-	entrypoint += "Init";
-
-	return entrypoint;
-}
-
-// Direct implementations of API methods
-
-int AdbcErrorGetDetailCount(const struct AdbcError *error) {
-	if (error->vendor_code == ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA && error->private_data && error->private_driver) {
-		return error->private_driver->ErrorGetDetailCount(error);
-	}
-	return 0;
-}
-
-struct AdbcErrorDetail AdbcErrorGetDetail(const struct AdbcError *error, int index) {
-	if (error->vendor_code == ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA && error->private_data && error->private_driver) {
-		return error->private_driver->ErrorGetDetail(error, index);
-	}
-	return {nullptr, nullptr, 0};
-}
-
-const struct AdbcError *AdbcErrorFromArrayStream(struct ArrowArrayStream *stream, AdbcStatusCode *status) {
-	if (!stream->private_data || stream->release != ErrorArrayStreamRelease) {
-		return nullptr;
-	}
-	auto *private_data = reinterpret_cast<struct ErrorArrayStream *>(stream->private_data);
-	auto *error = private_data->private_driver->ErrorFromArrayStream(&private_data->stream, status);
-	if (error) {
-		const_cast<struct AdbcError *>(error)->private_driver = private_data->private_driver;
-	}
-	return error;
-}
-
-#define INIT_ERROR(ERROR, SOURCE)                                                                                      \
-	if ((ERROR) != nullptr && (ERROR)->vendor_code == ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA) {                           \
-		(ERROR)->private_driver = (SOURCE)->private_driver;                                                            \
-	}
-
-#define WRAP_STREAM(EXPR, OUT, SOURCE)                                                                                 \
-	if (!(OUT)) {                                                                                                      \
-		/* Happens for ExecuteQuery where out is optional */                                                           \
-		return EXPR;                                                                                                   \
-	}                                                                                                                  \
-	AdbcStatusCode status_code = EXPR;                                                                                 \
-	ErrorArrayStreamInit(OUT, (SOURCE)->private_driver);                                                               \
-	return status_code;
-
-AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
-                                 struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionCommit(struct AdbcConnection *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes,
-                                 size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *, int, const char *, const char *, const char *,
-                                    const char **, const char *, struct ArrowArrayStream *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *, const char *, const char *, const char *,
-                                        struct ArrowSchema *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *, struct ArrowArrayStream *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
-                                       size_t serialized_length, struct ArrowArrayStream *out,
-                                       struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionRollback(struct AdbcConnection *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionSetOption(struct AdbcConnection *, const char *, const char *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementBind(struct AdbcStatement *, struct ArrowArray *, struct ArrowSchema *,
-                             struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                          struct AdbcPartitions *partitions, int64_t *rows_affected,
-                                          struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                           struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementPrepare(struct AdbcStatement *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementSetOption(struct AdbcStatement *, const char *, const char *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *, const char *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode StatementSetSubstraitPlan(struct AdbcStatement *, const uint8_t *, size_t, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase *database, struct AdbcError *error) {
-	// Allocate a temporary structure to store options pre-Init
-	database->private_data = new TempDatabase();
-	database->private_driver = nullptr;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase *database, const char *key, char *value, size_t *length,
-                                     struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseGetOption(database, key, value, length, error);
-	}
-	const auto *args = reinterpret_cast<const TempDatabase *>(database->private_data);
-	const std::string *result = nullptr;
-	if (std::strcmp(key, "driver") == 0) {
-		result = &args->driver;
-	} else if (std::strcmp(key, "entrypoint") == 0) {
-		result = &args->entrypoint;
-	} else {
-		const auto it = args->options.find(key);
-		if (it == args->options.end()) {
-			return ADBC_STATUS_NOT_FOUND;
-		}
-		result = &it->second;
-	}
-
-	if (*length <= result->size() + 1) {
-		// Enough space
-		std::memcpy(value, result->c_str(), result->size() + 1);
-	}
-	*length = result->size() + 1;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase *database, const char *key, uint8_t *value,
-                                          size_t *length, struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseGetOptionBytes(database, key, value, length, error);
-	}
-	const auto *args = reinterpret_cast<const TempDatabase *>(database->private_data);
-	const auto it = args->bytes_options.find(key);
-	if (it == args->options.end()) {
-		return ADBC_STATUS_NOT_FOUND;
-	}
-	const std::string &result = it->second;
-
-	if (*length <= result.size()) {
-		// Enough space
-		std::memcpy(value, result.c_str(), result.size());
-	}
-	*length = result.size();
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase *database, const char *key, int64_t *value,
-                                        struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseGetOptionInt(database, key, value, error);
-	}
-	const auto *args = reinterpret_cast<const TempDatabase *>(database->private_data);
-	const auto it = args->int_options.find(key);
-	if (it == args->int_options.end()) {
-		return ADBC_STATUS_NOT_FOUND;
-	}
-	*value = it->second;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase *database, const char *key, double *value,
-                                           struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseGetOptionDouble(database, key, value, error);
-	}
-	const auto *args = reinterpret_cast<const TempDatabase *>(database->private_data);
-	const auto it = args->double_options.find(key);
-	if (it == args->double_options.end()) {
-		return ADBC_STATUS_NOT_FOUND;
-	}
-	*value = it->second;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
-                                     struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseSetOption(database, key, value, error);
-	}
-
-	TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-	if (std::strcmp(key, "driver") == 0) {
-		args->driver = value;
-	} else if (std::strcmp(key, "entrypoint") == 0) {
-		args->entrypoint = value;
-	} else {
-		args->options[key] = value;
-	}
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase *database, const char *key, const uint8_t *value,
-                                          size_t length, struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseSetOptionBytes(database, key, value, length, error);
-	}
-
-	TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-	args->bytes_options[key] = std::string(reinterpret_cast<const char *>(value), length);
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase *database, const char *key, int64_t value,
-                                        struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseSetOptionInt(database, key, value, error);
-	}
-
-	TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-	args->int_options[key] = value;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase *database, const char *key, double value,
-                                           struct AdbcError *error) {
-	if (database->private_driver) {
-		INIT_ERROR(error, database);
-		return database->private_driver->DatabaseSetOptionDouble(database, key, value, error);
-	}
-
-	TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-	args->double_options[key] = value;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDriverManagerDatabaseSetInitFunc(struct AdbcDatabase *database, AdbcDriverInitFunc init_func,
-                                                    struct AdbcError *error) {
-	if (database->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-
-	TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-	args->init_func = init_func;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase *database, struct AdbcError *error) {
-	if (!database->private_data) {
-		SetError(error, "Must call AdbcDatabaseNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-	if (args->init_func) {
-		// Do nothing
-	} else if (args->driver.empty()) {
-		SetError(error, "Must provide 'driver' parameter");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	database->private_driver = new AdbcDriver;
-	std::memset(database->private_driver, 0, sizeof(AdbcDriver));
-	AdbcStatusCode status;
-	// So we don't confuse a driver into thinking it's initialized already
-	database->private_data = nullptr;
-	if (args->init_func) {
-		status = AdbcLoadDriverFromInitFunc(args->init_func, ADBC_VERSION_1_1_0, database->private_driver, error);
-	} else if (!args->entrypoint.empty()) {
-		status = AdbcLoadDriver(args->driver.c_str(), args->entrypoint.c_str(), ADBC_VERSION_1_1_0,
-		                        database->private_driver, error);
-	} else {
-		status = AdbcLoadDriver(args->driver.c_str(), nullptr, ADBC_VERSION_1_1_0, database->private_driver, error);
-	}
-	if (status != ADBC_STATUS_OK) {
-		// Restore private_data so it will be released by AdbcDatabaseRelease
-		database->private_data = args;
-		if (database->private_driver->release) {
-			database->private_driver->release(database->private_driver, error);
-		}
-		delete database->private_driver;
-		database->private_driver = nullptr;
-		return status;
-	}
-	status = database->private_driver->DatabaseNew(database, error);
-	if (status != ADBC_STATUS_OK) {
-		if (database->private_driver->release) {
-			database->private_driver->release(database->private_driver, error);
-		}
-		delete database->private_driver;
-		database->private_driver = nullptr;
-		return status;
-	}
-	auto options = std::move(args->options);
-	auto bytes_options = std::move(args->bytes_options);
-	auto int_options = std::move(args->int_options);
-	auto double_options = std::move(args->double_options);
-	delete args;
-
-	INIT_ERROR(error, database);
-	for (const auto &option : options) {
-		status =
-		    database->private_driver->DatabaseSetOption(database, option.first.c_str(), option.second.c_str(), error);
-		if (status != ADBC_STATUS_OK)
-			break;
-	}
-	for (const auto &option : bytes_options) {
-		status = database->private_driver->DatabaseSetOptionBytes(
-		    database, option.first.c_str(), reinterpret_cast<const uint8_t *>(option.second.data()),
-		    option.second.size(), error);
-		if (status != ADBC_STATUS_OK)
-			break;
-	}
-	for (const auto &option : int_options) {
-		status = database->private_driver->DatabaseSetOptionInt(database, option.first.c_str(), option.second, error);
-		if (status != ADBC_STATUS_OK)
-			break;
-	}
-	for (const auto &option : double_options) {
-		status =
-		    database->private_driver->DatabaseSetOptionDouble(database, option.first.c_str(), option.second, error);
-		if (status != ADBC_STATUS_OK)
-			break;
-	}
-
-	if (status != ADBC_STATUS_OK) {
-		// Release the database
-		std::ignore = database->private_driver->DatabaseRelease(database, error);
-		if (database->private_driver->release) {
-			database->private_driver->release(database->private_driver, error);
-		}
-		delete database->private_driver;
-		database->private_driver = nullptr;
-		// Should be redundant, but ensure that AdbcDatabaseRelease
-		// below doesn't think that it contains a TempDatabase
-		database->private_data = nullptr;
-		return status;
-	}
-	return database->private_driver->DatabaseInit(database, error);
-}
-
-AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error) {
-	if (!database->private_driver) {
-		if (database->private_data) {
-			TempDatabase *args = reinterpret_cast<TempDatabase *>(database->private_data);
-			delete args;
-			database->private_data = nullptr;
-			return ADBC_STATUS_OK;
-		}
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, database);
-	auto status = database->private_driver->DatabaseRelease(database, error);
-	if (database->private_driver->release) {
-		database->private_driver->release(database->private_driver, error);
-	}
-	delete database->private_driver;
-	database->private_data = nullptr;
-	database->private_driver = nullptr;
-	return status;
-}
-
-AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionCancel(connection, error);
-}
-
-AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionCommit(connection, error);
-}
-
-AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes,
-                                     size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	WRAP_STREAM(connection->private_driver->ConnectionGetInfo(connection, info_codes, info_codes_length, out, error),
-	            out, connection);
-}
-
-AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
-                                        const char *db_schema, const char *table_name, const char **table_types,
-                                        const char *column_name, struct ArrowArrayStream *stream,
-                                        struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	WRAP_STREAM(connection->private_driver->ConnectionGetObjects(connection, depth, catalog, db_schema, table_name,
-	                                                             table_types, column_name, stream, error),
-	            stream, connection);
-}
-
-AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection *connection, const char *key, char *value, size_t *length,
-                                       struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, get the saved option
-		const auto *args = reinterpret_cast<const TempConnection *>(connection->private_data);
-		const auto it = args->options.find(key);
-		if (it == args->options.end()) {
-			return ADBC_STATUS_NOT_FOUND;
-		}
-		if (*length >= it->second.size() + 1) {
-			std::memcpy(value, it->second.c_str(), it->second.size() + 1);
-		}
-		*length = it->second.size() + 1;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionGetOption(connection, key, value, length, error);
-}
-
-AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection *connection, const char *key, uint8_t *value,
-                                            size_t *length, struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, get the saved option
-		const auto *args = reinterpret_cast<const TempConnection *>(connection->private_data);
-		const auto it = args->bytes_options.find(key);
-		if (it == args->options.end()) {
-			return ADBC_STATUS_NOT_FOUND;
-		}
-		if (*length >= it->second.size() + 1) {
-			std::memcpy(value, it->second.data(), it->second.size() + 1);
-		}
-		*length = it->second.size() + 1;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionGetOptionBytes(connection, key, value, length, error);
-}
-
-AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection *connection, const char *key, int64_t *value,
-                                          struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, get the saved option
-		const auto *args = reinterpret_cast<const TempConnection *>(connection->private_data);
-		const auto it = args->int_options.find(key);
-		if (it == args->int_options.end()) {
-			return ADBC_STATUS_NOT_FOUND;
-		}
-		*value = it->second;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionGetOptionInt(connection, key, value, error);
-}
-
-AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection *connection, const char *key, double *value,
-                                             struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, get the saved option
-		const auto *args = reinterpret_cast<const TempConnection *>(connection->private_data);
-		const auto it = args->double_options.find(key);
-		if (it == args->double_options.end()) {
-			return ADBC_STATUS_NOT_FOUND;
-		}
-		*value = it->second;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionGetOptionDouble(connection, key, value, error);
-}
-
-AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection *connection, const char *catalog,
-                                           const char *db_schema, const char *table_name, char approximate,
-                                           struct ArrowArrayStream *out, struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	WRAP_STREAM(connection->private_driver->ConnectionGetStatistics(connection, catalog, db_schema, table_name,
-	                                                                approximate == 1, out, error),
-	            out, connection);
-}
-
-AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection *connection, struct ArrowArrayStream *out,
-                                               struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	WRAP_STREAM(connection->private_driver->ConnectionGetStatisticNames(connection, out, error), out, connection);
-}
-
-AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection *connection, const char *catalog,
-                                            const char *db_schema, const char *table_name, struct ArrowSchema *schema,
-                                            struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionGetTableSchema(connection, catalog, db_schema, table_name, schema,
-	                                                            error);
-}
-
-AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *stream,
-                                           struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	WRAP_STREAM(connection->private_driver->ConnectionGetTableTypes(connection, stream, error), stream, connection);
-}
-
-AdbcStatusCode AdbcConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
-                                  struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "Must call AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	} else if (!database->private_driver) {
-		SetError(error, "Database is not initialized");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	TempConnection *args = reinterpret_cast<TempConnection *>(connection->private_data);
-	connection->private_data = nullptr;
-	std::unordered_map<std::string, std::string> options = std::move(args->options);
-	std::unordered_map<std::string, std::string> bytes_options = std::move(args->bytes_options);
-	std::unordered_map<std::string, int64_t> int_options = std::move(args->int_options);
-	std::unordered_map<std::string, double> double_options = std::move(args->double_options);
-	delete args;
-
-	auto status = database->private_driver->ConnectionNew(connection, error);
-	if (status != ADBC_STATUS_OK)
-		return status;
-	connection->private_driver = database->private_driver;
-
-	for (const auto &option : options) {
-		status = database->private_driver->ConnectionSetOption(connection, option.first.c_str(), option.second.c_str(),
-		                                                       error);
-		if (status != ADBC_STATUS_OK)
-			return status;
-	}
-	for (const auto &option : bytes_options) {
-		status = database->private_driver->ConnectionSetOptionBytes(
-		    connection, option.first.c_str(), reinterpret_cast<const uint8_t *>(option.second.data()),
-		    option.second.size(), error);
-		if (status != ADBC_STATUS_OK)
-			return status;
-	}
-	for (const auto &option : int_options) {
-		status =
-		    database->private_driver->ConnectionSetOptionInt(connection, option.first.c_str(), option.second, error);
-		if (status != ADBC_STATUS_OK)
-			return status;
-	}
-	for (const auto &option : double_options) {
-		status =
-		    database->private_driver->ConnectionSetOptionDouble(connection, option.first.c_str(), option.second, error);
-		if (status != ADBC_STATUS_OK)
-			return status;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionInit(connection, database, error);
-}
-
-AdbcStatusCode AdbcConnectionNew(struct AdbcConnection *connection, struct AdbcError *error) {
-	// Allocate a temporary structure to store options pre-Init, because
-	// we don't get access to the database (and hence the driver
-	// function table) until then
-	connection->private_data = new TempConnection;
-	connection->private_driver = nullptr;
-	return ADBC_STATUS_OK;
-}
-
-AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
-                                           size_t serialized_length, struct ArrowArrayStream *out,
-                                           struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	WRAP_STREAM(connection->private_driver->ConnectionReadPartition(connection, serialized_partition, serialized_length,
-	                                                                out, error),
-	            out, connection);
-}
-
-AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection->private_driver) {
-		if (connection->private_data) {
-			TempConnection *args = reinterpret_cast<TempConnection *>(connection->private_data);
-			delete args;
-			connection->private_data = nullptr;
-			return ADBC_STATUS_OK;
-		}
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	auto status = connection->private_driver->ConnectionRelease(connection, error);
-	connection->private_driver = nullptr;
-	return status;
-}
-
-AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionRollback(connection, error);
-}
-
-AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value,
-                                       struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionSetOption: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, save the option
-		TempConnection *args = reinterpret_cast<TempConnection *>(connection->private_data);
-		args->options[key] = value;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionSetOption(connection, key, value, error);
-}
-
-AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection *connection, const char *key, const uint8_t *value,
-                                            size_t length, struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionSetOptionInt: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, save the option
-		TempConnection *args = reinterpret_cast<TempConnection *>(connection->private_data);
-		args->bytes_options[key] = std::string(reinterpret_cast<const char *>(value), length);
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionSetOptionBytes(connection, key, value, length, error);
-}
-
-AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection *connection, const char *key, int64_t value,
-                                          struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionSetOptionInt: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, save the option
-		TempConnection *args = reinterpret_cast<TempConnection *>(connection->private_data);
-		args->int_options[key] = value;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionSetOptionInt(connection, key, value, error);
-}
-
-AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection *connection, const char *key, double value,
-                                             struct AdbcError *error) {
-	if (!connection->private_data) {
-		SetError(error, "AdbcConnectionSetOptionDouble: must AdbcConnectionNew first");
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	if (!connection->private_driver) {
-		// Init not yet called, save the option
-		TempConnection *args = reinterpret_cast<TempConnection *>(connection->private_data);
-		args->double_options[key] = value;
-		return ADBC_STATUS_OK;
-	}
-	INIT_ERROR(error, connection);
-	return connection->private_driver->ConnectionSetOptionDouble(connection, key, value, error);
-}
-
-AdbcStatusCode AdbcStatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schema,
-                                 struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementBind(statement, values, schema, error);
-}
-
-AdbcStatusCode AdbcStatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *stream,
-                                       struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementBindStream(statement, stream, error);
-}
-
-AdbcStatusCode AdbcStatementCancel(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementCancel(statement, error);
-}
-
-// XXX: cpplint gets confused here if declared as 'struct ArrowSchema* schema'
-AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement *statement, ArrowSchema *schema,
-                                              struct AdbcPartitions *partitions, int64_t *rows_affected,
-                                              struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementExecutePartitions(statement, schema, partitions, rows_affected, error);
-}
-
-AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
-                                         int64_t *rows_affected, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	WRAP_STREAM(statement->private_driver->StatementExecuteQuery(statement, out, rows_affected, error), out, statement);
-}
-
-AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                          struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementExecuteSchema(statement, schema, error);
-}
-
-AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement *statement, const char *key, char *value, size_t *length,
-                                      struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementGetOption(statement, key, value, length, error);
-}
-
-AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement *statement, const char *key, uint8_t *value,
-                                           size_t *length, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementGetOptionBytes(statement, key, value, length, error);
-}
-
-AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement *statement, const char *key, int64_t *value,
-                                         struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementGetOptionInt(statement, key, value, error);
-}
-
-AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement *statement, const char *key, double *value,
-                                            struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementGetOptionDouble(statement, key, value, error);
-}
-
-AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                               struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementGetParameterSchema(statement, schema, error);
-}
-
-AdbcStatusCode AdbcStatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
-                                struct AdbcError *error) {
-	if (!connection->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, connection);
-	auto status = connection->private_driver->StatementNew(connection, statement, error);
-	statement->private_driver = connection->private_driver;
-	return status;
-}
-
-AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementPrepare(statement, error);
-}
-
-AdbcStatusCode AdbcStatementRelease(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	auto status = statement->private_driver->StatementRelease(statement, error);
-	statement->private_driver = nullptr;
-	return status;
-}
-
-AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
-                                      struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementSetOption(statement, key, value, error);
-}
-
-AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement *statement, const char *key, const uint8_t *value,
-                                           size_t length, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementSetOptionBytes(statement, key, value, length, error);
-}
-
-AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement *statement, const char *key, int64_t value,
-                                         struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementSetOptionInt(statement, key, value, error);
-}
-
-AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement *statement, const char *key, double value,
-                                            struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementSetOptionDouble(statement, key, value, error);
-}
-
-AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementSetSqlQuery(statement, query, error);
-}
-
-AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement *statement, const uint8_t *plan, size_t length,
-                                             struct AdbcError *error) {
-	if (!statement->private_driver) {
-		return ADBC_STATUS_INVALID_STATE;
-	}
-	INIT_ERROR(error, statement);
-	return statement->private_driver->StatementSetSubstraitPlan(statement, plan, length, error);
-}
-
-const char *AdbcStatusCodeMessage(AdbcStatusCode code) {
-#define CASE(CONSTANT)                                                                                                 \
-	case ADBC_STATUS_##CONSTANT:                                                                                       \
-		return #CONSTANT;
-
-	switch (code) {
-		CASE(OK);
-		CASE(UNKNOWN);
-		CASE(NOT_IMPLEMENTED);
-		CASE(NOT_FOUND);
-		CASE(ALREADY_EXISTS);
-		CASE(INVALID_ARGUMENT);
-		CASE(INVALID_STATE);
-		CASE(INVALID_DATA);
-		CASE(INTEGRITY);
-		CASE(INTERNAL);
-		CASE(IO);
-		CASE(CANCELLED);
-		CASE(TIMEOUT);
-		CASE(UNAUTHENTICATED);
-		CASE(UNAUTHORIZED);
-	default:
-		return "(invalid code)";
-	}
-#undef CASE
-}
-
-AdbcStatusCode AdbcLoadDriver(const char *driver_name, const char *entrypoint, int version, void *raw_driver,
-                              struct AdbcError *error) {
-	AdbcDriverInitFunc init_func;
-	std::string error_message;
-
-	switch (version) {
-	case ADBC_VERSION_1_0_0:
-	case ADBC_VERSION_1_1_0:
-		break;
-	default:
-		SetError(error, "Only ADBC 1.0.0 and 1.1.0 are supported");
-		return ADBC_STATUS_NOT_IMPLEMENTED;
-	}
-
-	if (!raw_driver) {
-		SetError(error, "Must provide non-NULL raw_driver");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-	auto *driver = reinterpret_cast<struct AdbcDriver *>(raw_driver);
-
-	ManagedLibrary library;
-	AdbcStatusCode status = library.Load(driver_name, error);
-	if (status != ADBC_STATUS_OK) {
-		// AdbcDatabaseInit tries to call this if set
-		driver->release = nullptr;
-		return status;
-	}
-
-	void *load_handle = nullptr;
-	if (entrypoint) {
-		status = library.Lookup(entrypoint, &load_handle, error);
-	} else {
-		auto name = AdbcDriverManagerDefaultEntrypoint(driver_name);
-		status = library.Lookup(name.c_str(), &load_handle, error);
-		if (status != ADBC_STATUS_OK) {
-			status = library.Lookup(kDefaultEntrypoint, &load_handle, error);
-		}
-	}
-
-	if (status != ADBC_STATUS_OK) {
-		library.Release();
-		return status;
-	}
-	init_func = reinterpret_cast<AdbcDriverInitFunc>(load_handle);
-
-	status = AdbcLoadDriverFromInitFunc(init_func, version, driver, error);
-	if (status == ADBC_STATUS_OK) {
-		ManagerDriverState *state = new ManagerDriverState;
-		state->driver_release = driver->release;
-		state->handle = std::move(library);
-		driver->release = &ReleaseDriver;
-		driver->private_manager = state;
-	} else {
-		library.Release();
-	}
-	return status;
-}
-
-AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int version, void *raw_driver,
-                                          struct AdbcError *error) {
-	constexpr std::array<int, 2> kSupportedVersions = {
-	    ADBC_VERSION_1_1_0,
-	    ADBC_VERSION_1_0_0,
-	};
-
-	if (!raw_driver) {
-		SetError(error, "Must provide non-NULL raw_driver");
-		return ADBC_STATUS_INVALID_ARGUMENT;
-	}
-
-	switch (version) {
-	case ADBC_VERSION_1_0_0:
-	case ADBC_VERSION_1_1_0:
-		break;
-	default:
-		SetError(error, "Only ADBC 1.0.0 and 1.1.0 are supported");
-		return ADBC_STATUS_NOT_IMPLEMENTED;
-	}
-
-#define FILL_DEFAULT(DRIVER, STUB)                                                                                     \
-	if (!DRIVER->STUB) {                                                                                               \
-		DRIVER->STUB = &STUB;                                                                                          \
-	}
-#define CHECK_REQUIRED(DRIVER, STUB)                                                                                   \
-	if (!DRIVER->STUB) {                                                                                               \
-		SetError(error, "Driver does not implement required function Adbc" #STUB);                                     \
-		return ADBC_STATUS_INTERNAL;                                                                                   \
-	}
-
-	// Starting from the passed version, try each (older) version in
-	// succession with the underlying driver until we find one that's
-	// accepted.
-	AdbcStatusCode result = ADBC_STATUS_NOT_IMPLEMENTED;
-	for (const int try_version : kSupportedVersions) {
-		if (try_version > version)
-			continue;
-		result = init_func(try_version, raw_driver, error);
-		if (result != ADBC_STATUS_NOT_IMPLEMENTED)
-			break;
-	}
-	if (result != ADBC_STATUS_OK) {
-		return result;
-	}
-
-	if (version >= ADBC_VERSION_1_0_0) {
-		auto *driver = reinterpret_cast<struct AdbcDriver *>(raw_driver);
-		CHECK_REQUIRED(driver, DatabaseNew);
-		CHECK_REQUIRED(driver, DatabaseInit);
-		CHECK_REQUIRED(driver, DatabaseRelease);
-		FILL_DEFAULT(driver, DatabaseSetOption);
-
-		CHECK_REQUIRED(driver, ConnectionNew);
-		CHECK_REQUIRED(driver, ConnectionInit);
-		CHECK_REQUIRED(driver, ConnectionRelease);
-		FILL_DEFAULT(driver, ConnectionCommit);
-		FILL_DEFAULT(driver, ConnectionGetInfo);
-		FILL_DEFAULT(driver, ConnectionGetObjects);
-		FILL_DEFAULT(driver, ConnectionGetTableSchema);
-		FILL_DEFAULT(driver, ConnectionGetTableTypes);
-		FILL_DEFAULT(driver, ConnectionReadPartition);
-		FILL_DEFAULT(driver, ConnectionRollback);
-		FILL_DEFAULT(driver, ConnectionSetOption);
-
-		FILL_DEFAULT(driver, StatementExecutePartitions);
-		CHECK_REQUIRED(driver, StatementExecuteQuery);
-		CHECK_REQUIRED(driver, StatementNew);
-		CHECK_REQUIRED(driver, StatementRelease);
-		FILL_DEFAULT(driver, StatementBind);
-		FILL_DEFAULT(driver, StatementGetParameterSchema);
-		FILL_DEFAULT(driver, StatementPrepare);
-		FILL_DEFAULT(driver, StatementSetOption);
-		FILL_DEFAULT(driver, StatementSetSqlQuery);
-		FILL_DEFAULT(driver, StatementSetSubstraitPlan);
-	}
-	if (version >= ADBC_VERSION_1_1_0) {
-		auto *driver = reinterpret_cast<struct AdbcDriver *>(raw_driver);
-		FILL_DEFAULT(driver, ErrorGetDetailCount);
-		FILL_DEFAULT(driver, ErrorGetDetail);
-		FILL_DEFAULT(driver, ErrorFromArrayStream);
-
-		FILL_DEFAULT(driver, DatabaseGetOption);
-		FILL_DEFAULT(driver, DatabaseGetOptionBytes);
-		FILL_DEFAULT(driver, DatabaseGetOptionDouble);
-		FILL_DEFAULT(driver, DatabaseGetOptionInt);
-		FILL_DEFAULT(driver, DatabaseSetOptionBytes);
-		FILL_DEFAULT(driver, DatabaseSetOptionDouble);
-		FILL_DEFAULT(driver, DatabaseSetOptionInt);
-
-		FILL_DEFAULT(driver, ConnectionCancel);
-		FILL_DEFAULT(driver, ConnectionGetOption);
-		FILL_DEFAULT(driver, ConnectionGetOptionBytes);
-		FILL_DEFAULT(driver, ConnectionGetOptionDouble);
-		FILL_DEFAULT(driver, ConnectionGetOptionInt);
-		FILL_DEFAULT(driver, ConnectionGetStatistics);
-		FILL_DEFAULT(driver, ConnectionGetStatisticNames);
-		FILL_DEFAULT(driver, ConnectionSetOptionBytes);
-		FILL_DEFAULT(driver, ConnectionSetOptionDouble);
-		FILL_DEFAULT(driver, ConnectionSetOptionInt);
-
-		FILL_DEFAULT(driver, StatementCancel);
-		FILL_DEFAULT(driver, StatementExecuteSchema);
-		FILL_DEFAULT(driver, StatementGetOption);
-		FILL_DEFAULT(driver, StatementGetOptionBytes);
-		FILL_DEFAULT(driver, StatementGetOptionDouble);
-		FILL_DEFAULT(driver, StatementGetOptionInt);
-		FILL_DEFAULT(driver, StatementSetOptionBytes);
-		FILL_DEFAULT(driver, StatementSetOptionDouble);
-		FILL_DEFAULT(driver, StatementSetOptionInt);
-	}
-
-	return ADBC_STATUS_OK;
-
-#undef FILL_DEFAULT
-#undef CHECK_REQUIRED
-}
diff --git a/src/duckdb/src/common/adbc/nanoarrow/allocator.cpp b/src/duckdb/src/common/adbc/nanoarrow/allocator.cpp
deleted file mode 100644
index cea53b188..000000000
--- a/src/duckdb/src/common/adbc/nanoarrow/allocator.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
-
-namespace duckdb_nanoarrow {
-
-void *ArrowMalloc(int64_t size) {
-	return malloc(size_t(size));
-}
-
-void *ArrowRealloc(void *ptr, int64_t size) {
-	return realloc(ptr, size_t(size));
-}
-
-void ArrowFree(void *ptr) {
-	free(ptr);
-}
-
-static uint8_t *ArrowBufferAllocatorMallocAllocate(struct ArrowBufferAllocator *allocator, int64_t size) {
-	return (uint8_t *)ArrowMalloc(size);
-}
-
-static uint8_t *ArrowBufferAllocatorMallocReallocate(struct ArrowBufferAllocator *allocator, uint8_t *ptr,
-                                                     int64_t old_size, int64_t new_size) {
-	return (uint8_t *)ArrowRealloc(ptr, new_size);
-}
-
-static void ArrowBufferAllocatorMallocFree(struct ArrowBufferAllocator *allocator, uint8_t *ptr, int64_t size) {
-	ArrowFree(ptr);
-}
-
-static struct ArrowBufferAllocator ArrowBufferAllocatorMalloc = {
-    &ArrowBufferAllocatorMallocAllocate, &ArrowBufferAllocatorMallocReallocate, &ArrowBufferAllocatorMallocFree, NULL};
-
-struct ArrowBufferAllocator *ArrowBufferAllocatorDefault() {
-	return &ArrowBufferAllocatorMalloc;
-}
-
-} // namespace duckdb_nanoarrow
diff --git a/src/duckdb/src/common/adbc/nanoarrow/metadata.cpp b/src/duckdb/src/common/adbc/nanoarrow/metadata.cpp
deleted file mode 100644
index cb3009c01..000000000
--- a/src/duckdb/src/common/adbc/nanoarrow/metadata.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
-
-namespace duckdb_nanoarrow {
-
-ArrowErrorCode ArrowMetadataReaderInit(struct ArrowMetadataReader *reader, const char *metadata) {
-	reader->metadata = metadata;
-
-	if (reader->metadata == NULL) {
-		reader->offset = 0;
-		reader->remaining_keys = 0;
-	} else {
-		memcpy(&reader->remaining_keys, reader->metadata, sizeof(int32_t));
-		reader->offset = sizeof(int32_t);
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowMetadataReaderRead(struct ArrowMetadataReader *reader, struct ArrowStringView *key_out,
-                                       struct ArrowStringView *value_out) {
-	if (reader->remaining_keys <= 0) {
-		return EINVAL;
-	}
-
-	int64_t pos = 0;
-
-	int32_t key_size;
-	memcpy(&key_size, reader->metadata + reader->offset + pos, sizeof(int32_t));
-	pos += sizeof(int32_t);
-
-	key_out->data = reader->metadata + reader->offset + pos;
-	key_out->n_bytes = key_size;
-	pos += key_size;
-
-	int32_t value_size;
-	memcpy(&value_size, reader->metadata + reader->offset + pos, sizeof(int32_t));
-	pos += sizeof(int32_t);
-
-	value_out->data = reader->metadata + reader->offset + pos;
-	value_out->n_bytes = value_size;
-	pos += value_size;
-
-	reader->offset += pos;
-	reader->remaining_keys--;
-	return NANOARROW_OK;
-}
-
-int64_t ArrowMetadataSizeOf(const char *metadata) {
-	if (metadata == NULL) {
-		return 0;
-	}
-
-	struct ArrowMetadataReader reader;
-	struct ArrowStringView key;
-	struct ArrowStringView value;
-	ArrowMetadataReaderInit(&reader, metadata);
-
-	int64_t size = sizeof(int32_t);
-	while (ArrowMetadataReaderRead(&reader, &key, &value) == NANOARROW_OK) {
-		size += sizeof(int32_t) + uint64_t(key.n_bytes) + sizeof(int32_t) + uint64_t(value.n_bytes);
-	}
-
-	return size;
-}
-
-ArrowErrorCode ArrowMetadataGetValue(const char *metadata, const char *key, const char *default_value,
-                                     struct ArrowStringView *value_out) {
-	struct ArrowStringView target_key_view = {key, static_cast<int64_t>(strlen(key))};
-	value_out->data = default_value;
-	if (default_value != NULL) {
-		value_out->n_bytes = int64_t(strlen(default_value));
-	} else {
-		value_out->n_bytes = 0;
-	}
-
-	struct ArrowMetadataReader reader;
-	struct ArrowStringView key_view;
-	struct ArrowStringView value;
-	ArrowMetadataReaderInit(&reader, metadata);
-
-	while (ArrowMetadataReaderRead(&reader, &key_view, &value) == NANOARROW_OK) {
-		int key_equal = target_key_view.n_bytes == key_view.n_bytes &&
-		                strncmp(target_key_view.data, key_view.data, size_t(key_view.n_bytes)) == 0;
-		if (key_equal) {
-			value_out->data = value.data;
-			value_out->n_bytes = value.n_bytes;
-			break;
-		}
-	}
-
-	return NANOARROW_OK;
-}
-
-char ArrowMetadataHasKey(const char *metadata, const char *key) {
-	struct ArrowStringView value;
-	ArrowMetadataGetValue(metadata, key, NULL, &value);
-	return value.data != NULL;
-}
-
-} // namespace duckdb_nanoarrow
diff --git a/src/duckdb/src/common/adbc/nanoarrow/schema.cpp b/src/duckdb/src/common/adbc/nanoarrow/schema.cpp
deleted file mode 100644
index 38d1b314f..000000000
--- a/src/duckdb/src/common/adbc/nanoarrow/schema.cpp
+++ /dev/null
@@ -1,475 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
-
-namespace duckdb_nanoarrow {
-
-void ArrowSchemaRelease(struct ArrowSchema *schema) {
-	if (schema->format != NULL)
-		ArrowFree((void *)schema->format);
-	if (schema->name != NULL)
-		ArrowFree((void *)schema->name);
-	if (schema->metadata != NULL)
-		ArrowFree((void *)schema->metadata);
-
-	// This object owns the memory for all the children, but those
-	// children may have been generated elsewhere and might have
-	// their own release() callback.
-	if (schema->children != NULL) {
-		for (int64_t i = 0; i < schema->n_children; i++) {
-			if (schema->children[i] != NULL) {
-				if (schema->children[i]->release != NULL) {
-					schema->children[i]->release(schema->children[i]);
-				}
-
-				ArrowFree(schema->children[i]);
-			}
-		}
-
-		ArrowFree(schema->children);
-	}
-
-	// This object owns the memory for the dictionary but it
-	// may have been generated somewhere else and have its own
-	// release() callback.
-	if (schema->dictionary != NULL) {
-		if (schema->dictionary->release != NULL) {
-			schema->dictionary->release(schema->dictionary);
-		}
-
-		ArrowFree(schema->dictionary);
-	}
-
-	// private data not currently used
-	if (schema->private_data != NULL) {
-		ArrowFree(schema->private_data);
-	}
-
-	schema->release = NULL;
-}
-
-const char *ArrowSchemaFormatTemplate(enum ArrowType data_type) {
-	switch (data_type) {
-	case NANOARROW_TYPE_UNINITIALIZED:
-		return NULL;
-	case NANOARROW_TYPE_NA:
-		return "n";
-	case NANOARROW_TYPE_BOOL:
-		return "b";
-
-	case NANOARROW_TYPE_UINT8:
-		return "C";
-	case NANOARROW_TYPE_INT8:
-		return "c";
-	case NANOARROW_TYPE_UINT16:
-		return "S";
-	case NANOARROW_TYPE_INT16:
-		return "s";
-	case NANOARROW_TYPE_UINT32:
-		return "I";
-	case NANOARROW_TYPE_INT32:
-		return "i";
-	case NANOARROW_TYPE_UINT64:
-		return "L";
-	case NANOARROW_TYPE_INT64:
-		return "l";
-
-	case NANOARROW_TYPE_HALF_FLOAT:
-		return "e";
-	case NANOARROW_TYPE_FLOAT:
-		return "f";
-	case NANOARROW_TYPE_DOUBLE:
-		return "g";
-
-	case NANOARROW_TYPE_STRING:
-		return "u";
-	case NANOARROW_TYPE_LARGE_STRING:
-		return "U";
-	case NANOARROW_TYPE_BINARY:
-		return "z";
-	case NANOARROW_TYPE_LARGE_BINARY:
-		return "Z";
-
-	case NANOARROW_TYPE_DATE32:
-		return "tdD";
-	case NANOARROW_TYPE_DATE64:
-		return "tdm";
-	case NANOARROW_TYPE_INTERVAL_MONTHS:
-		return "tiM";
-	case NANOARROW_TYPE_INTERVAL_DAY_TIME:
-		return "tiD";
-	case NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO:
-		return "tin";
-
-	case NANOARROW_TYPE_LIST:
-		return "+l";
-	case NANOARROW_TYPE_LARGE_LIST:
-		return "+L";
-	case NANOARROW_TYPE_STRUCT:
-		return "+s";
-	case NANOARROW_TYPE_MAP:
-		return "+m";
-
-	default:
-		return NULL;
-	}
-}
-
-ArrowErrorCode ArrowSchemaInit(struct ArrowSchema *schema, enum ArrowType data_type) {
-	schema->format = NULL;
-	schema->name = NULL;
-	schema->metadata = NULL;
-	schema->flags = ARROW_FLAG_NULLABLE;
-	schema->n_children = 0;
-	schema->children = NULL;
-	schema->dictionary = NULL;
-	schema->private_data = NULL;
-	schema->release = &ArrowSchemaRelease;
-
-	// We don't allocate the dictionary because it has to be nullptr
-	// for non-dictionary-encoded arrays.
-
-	// Set the format to a valid format string for data_type
-	const char *template_format = ArrowSchemaFormatTemplate(data_type);
-
-	// If data_type isn't recognized and not explicitly unset
-	if (template_format == NULL && data_type != NANOARROW_TYPE_UNINITIALIZED) {
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	int result = ArrowSchemaSetFormat(schema, template_format);
-	if (result != NANOARROW_OK) {
-		schema->release(schema);
-		return result;
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowSchemaInitFixedSize(struct ArrowSchema *schema, enum ArrowType data_type, int32_t fixed_size) {
-	int result = ArrowSchemaInit(schema, NANOARROW_TYPE_UNINITIALIZED);
-	if (result != NANOARROW_OK) {
-		return result;
-	}
-
-	if (fixed_size <= 0) {
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	char buffer[64];
-	int n_chars;
-	switch (data_type) {
-	case NANOARROW_TYPE_FIXED_SIZE_BINARY:
-		n_chars = snprintf(buffer, sizeof(buffer), "w:%d", (int)fixed_size);
-		break;
-	case NANOARROW_TYPE_FIXED_SIZE_LIST:
-		n_chars = snprintf(buffer, sizeof(buffer), "+w:%d", (int)fixed_size);
-		break;
-	default:
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	buffer[n_chars] = '\0';
-	result = ArrowSchemaSetFormat(schema, buffer);
-	if (result != NANOARROW_OK) {
-		schema->release(schema);
-	}
-
-	return result;
-}
-
-ArrowErrorCode ArrowSchemaInitDecimal(struct ArrowSchema *schema, enum ArrowType data_type, int32_t decimal_precision,
-                                      int32_t decimal_scale) {
-	int result = ArrowSchemaInit(schema, NANOARROW_TYPE_UNINITIALIZED);
-	if (result != NANOARROW_OK) {
-		return result;
-	}
-
-	if (decimal_precision <= 0) {
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	char buffer[64];
-	int n_chars;
-	switch (data_type) {
-	case NANOARROW_TYPE_DECIMAL128:
-		n_chars = snprintf(buffer, sizeof(buffer), "d:%d,%d", decimal_precision, decimal_scale);
-		break;
-	case NANOARROW_TYPE_DECIMAL256:
-		n_chars = snprintf(buffer, sizeof(buffer), "d:%d,%d,256", decimal_precision, decimal_scale);
-		break;
-	default:
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	buffer[n_chars] = '\0';
-
-	result = ArrowSchemaSetFormat(schema, buffer);
-	if (result != NANOARROW_OK) {
-		schema->release(schema);
-		return result;
-	}
-
-	return NANOARROW_OK;
-}
-
-static const char *ArrowTimeUnitString(enum ArrowTimeUnit time_unit) {
-	switch (time_unit) {
-	case NANOARROW_TIME_UNIT_SECOND:
-		return "s";
-	case NANOARROW_TIME_UNIT_MILLI:
-		return "m";
-	case NANOARROW_TIME_UNIT_MICRO:
-		return "u";
-	case NANOARROW_TIME_UNIT_NANO:
-		return "n";
-	default:
-		return NULL;
-	}
-}
-
-ArrowErrorCode ArrowSchemaInitDateTime(struct ArrowSchema *schema, enum ArrowType data_type,
-                                       enum ArrowTimeUnit time_unit, const char *timezone) {
-	int result = ArrowSchemaInit(schema, NANOARROW_TYPE_UNINITIALIZED);
-	if (result != NANOARROW_OK) {
-		return result;
-	}
-
-	const char *time_unit_str = ArrowTimeUnitString(time_unit);
-	if (time_unit_str == NULL) {
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	char buffer[128];
-	int n_chars;
-	switch (data_type) {
-	case NANOARROW_TYPE_TIME32:
-	case NANOARROW_TYPE_TIME64:
-		if (timezone != NULL) {
-			schema->release(schema);
-			return EINVAL;
-		}
-		n_chars = snprintf(buffer, sizeof(buffer), "tt%s", time_unit_str);
-		break;
-	case NANOARROW_TYPE_TIMESTAMP:
-		if (timezone == NULL) {
-			timezone = "";
-		}
-		n_chars = snprintf(buffer, sizeof(buffer), "ts%s:%s", time_unit_str, timezone);
-		break;
-	case NANOARROW_TYPE_DURATION:
-		if (timezone != NULL) {
-			schema->release(schema);
-			return EINVAL;
-		}
-		n_chars = snprintf(buffer, sizeof(buffer), "tD%s", time_unit_str);
-		break;
-	default:
-		schema->release(schema);
-		return EINVAL;
-	}
-
-	if (static_cast<size_t>(n_chars) >= sizeof(buffer)) {
-		schema->release(schema);
-		return ERANGE;
-	}
-
-	buffer[n_chars] = '\0';
-
-	result = ArrowSchemaSetFormat(schema, buffer);
-	if (result != NANOARROW_OK) {
-		schema->release(schema);
-		return result;
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowSchemaSetFormat(struct ArrowSchema *schema, const char *format) {
-	if (schema->format != NULL) {
-		ArrowFree((void *)schema->format);
-	}
-
-	if (format != NULL) {
-		size_t format_size = strlen(format) + 1;
-		schema->format = (const char *)ArrowMalloc(int64_t(format_size));
-		if (schema->format == NULL) {
-			return ENOMEM;
-		}
-
-		memcpy((void *)schema->format, format, format_size);
-	} else {
-		schema->format = NULL;
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowSchemaSetName(struct ArrowSchema *schema, const char *name) {
-	if (schema->name != NULL) {
-		ArrowFree((void *)schema->name);
-	}
-
-	if (name != NULL) {
-		size_t name_size = strlen(name) + 1;
-		schema->name = (const char *)ArrowMalloc(int64_t(name_size));
-		if (schema->name == NULL) {
-			return ENOMEM;
-		}
-
-		memcpy((void *)schema->name, name, name_size);
-	} else {
-		schema->name = NULL;
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowSchemaSetMetadata(struct ArrowSchema *schema, const char *metadata) {
-	if (schema->metadata != NULL) {
-		ArrowFree((void *)schema->metadata);
-	}
-
-	if (metadata != NULL) {
-		auto metadata_size = ArrowMetadataSizeOf(metadata);
-		schema->metadata = (const char *)ArrowMalloc(metadata_size);
-		if (schema->metadata == NULL) {
-			return ENOMEM;
-		}
-
-		memcpy((void *)schema->metadata, metadata, size_t(metadata_size));
-	} else {
-		schema->metadata = NULL;
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowSchemaAllocateChildren(struct ArrowSchema *schema, int64_t n_children) {
-	if (schema->children != NULL) {
-		return EEXIST;
-	}
-
-	if (n_children > 0) {
-		schema->children =
-		    (struct ArrowSchema **)ArrowMalloc(int64_t(uint64_t(n_children) * sizeof(struct ArrowSchema *)));
-
-		if (schema->children == NULL) {
-			return ENOMEM;
-		}
-
-		schema->n_children = n_children;
-
-		memset(schema->children, 0, uint64_t(n_children) * sizeof(struct ArrowSchema *));
-
-		for (int64_t i = 0; i < n_children; i++) {
-			schema->children[i] = (struct ArrowSchema *)ArrowMalloc(sizeof(struct ArrowSchema));
-
-			if (schema->children[i] == NULL) {
-				return ENOMEM;
-			}
-
-			schema->children[i]->release = NULL;
-		}
-	}
-
-	return NANOARROW_OK;
-}
-
-ArrowErrorCode ArrowSchemaAllocateDictionary(struct ArrowSchema *schema) {
-	if (schema->dictionary != NULL) {
-		return EEXIST;
-	}
-
-	schema->dictionary = (struct ArrowSchema *)ArrowMalloc(sizeof(struct ArrowSchema));
-	if (schema->dictionary == NULL) {
-		return ENOMEM;
-	}
-
-	schema->dictionary->release = NULL;
-	return NANOARROW_OK;
-}
-
-int ArrowSchemaDeepCopy(struct ArrowSchema *schema, struct ArrowSchema *schema_out) {
-	int result;
-	result = ArrowSchemaInit(schema_out, NANOARROW_TYPE_NA);
-	if (result != NANOARROW_OK) {
-		return result;
-	}
-
-	result = ArrowSchemaSetFormat(schema_out, schema->format);
-	if (result != NANOARROW_OK) {
-		schema_out->release(schema_out);
-		return result;
-	}
-
-	result = ArrowSchemaSetName(schema_out, schema->name);
-	if (result != NANOARROW_OK) {
-		schema_out->release(schema_out);
-		return result;
-	}
-
-	result = ArrowSchemaSetMetadata(schema_out, schema->metadata);
-	if (result != NANOARROW_OK) {
-		schema_out->release(schema_out);
-		return result;
-	}
-
-	result = ArrowSchemaAllocateChildren(schema_out, schema->n_children);
-	if (result != NANOARROW_OK) {
-		schema_out->release(schema_out);
-		return result;
-	}
-
-	for (int64_t i = 0; i < schema->n_children; i++) {
-		result = ArrowSchemaDeepCopy(schema->children[i], schema_out->children[i]);
-		if (result != NANOARROW_OK) {
-			schema_out->release(schema_out);
-			return result;
-		}
-	}
-
-	if (schema->dictionary != NULL) {
-		result = ArrowSchemaAllocateDictionary(schema_out);
-		if (result != NANOARROW_OK) {
-			schema_out->release(schema_out);
-			return result;
-		}
-
-		result = ArrowSchemaDeepCopy(schema->dictionary, schema_out->dictionary);
-		if (result != NANOARROW_OK) {
-			schema_out->release(schema_out);
-			return result;
-		}
-	}
-
-	return NANOARROW_OK;
-}
-
-} // namespace duckdb_nanoarrow
diff --git a/src/duckdb/src/common/adbc/nanoarrow/single_batch_array_stream.cpp b/src/duckdb/src/common/adbc/nanoarrow/single_batch_array_stream.cpp
deleted file mode 100644
index bddcd4e09..000000000
--- a/src/duckdb/src/common/adbc/nanoarrow/single_batch_array_stream.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/common/adbc/single_batch_array_stream.hpp"
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.h"
-#include "duckdb/common/adbc/adbc.hpp"
-
-#include "duckdb.h"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
-
-#include <errno.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-namespace duckdb_adbc {
-
-using duckdb_nanoarrow::ArrowSchemaDeepCopy;
-
-static const char *SingleBatchArrayStreamGetLastError(struct ArrowArrayStream *stream) {
-	return NULL;
-}
-
-static int SingleBatchArrayStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *batch) {
-	if (!stream || !stream->private_data) {
-		return EINVAL;
-	}
-	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)stream->private_data;
-
-	memcpy(batch, &impl->batch, sizeof(*batch));
-	memset(&impl->batch, 0, sizeof(*batch));
-	return 0;
-}
-
-static int SingleBatchArrayStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *schema) {
-	if (!stream || !stream->private_data) {
-		return EINVAL;
-	}
-	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)stream->private_data;
-
-	return ArrowSchemaDeepCopy(&impl->schema, schema);
-}
-
-static void SingleBatchArrayStreamRelease(struct ArrowArrayStream *stream) {
-	if (!stream || !stream->private_data) {
-		return;
-	}
-	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)stream->private_data;
-	impl->schema.release(&impl->schema);
-	if (impl->batch.release) {
-		impl->batch.release(&impl->batch);
-	}
-	free(impl);
-
-	memset(stream, 0, sizeof(*stream));
-}
-
-AdbcStatusCode BatchToArrayStream(struct ArrowArray *values, struct ArrowSchema *schema,
-                                  struct ArrowArrayStream *stream, struct AdbcError *error) {
-	if (!values->release) {
-		SetError(error, "ArrowArray is not initialized");
-		return ADBC_STATUS_INTERNAL;
-	} else if (!schema->release) {
-		SetError(error, "ArrowSchema is not initialized");
-		return ADBC_STATUS_INTERNAL;
-	} else if (stream->release) {
-		SetError(error, "ArrowArrayStream is already initialized");
-		return ADBC_STATUS_INTERNAL;
-	}
-
-	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)malloc(sizeof(*impl));
-	memcpy(&impl->schema, schema, sizeof(*schema));
-	memcpy(&impl->batch, values, sizeof(*values));
-	memset(schema, 0, sizeof(*schema));
-	memset(values, 0, sizeof(*values));
-	stream->private_data = impl;
-	stream->get_last_error = SingleBatchArrayStreamGetLastError;
-	stream->get_next = SingleBatchArrayStreamGetNext;
-	stream->get_schema = SingleBatchArrayStreamGetSchema;
-	stream->release = SingleBatchArrayStreamRelease;
-
-	return ADBC_STATUS_OK;
-}
-
-} // namespace duckdb_adbc
diff --git a/src/duckdb/src/common/allocator.cpp b/src/duckdb/src/common/allocator.cpp
deleted file mode 100644
index 977087939..000000000
--- a/src/duckdb/src/common/allocator.cpp
+++ /dev/null
@@ -1,343 +0,0 @@
-#include "duckdb/common/allocator.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-
-#include <cstdint>
-
-#ifdef DUCKDB_DEBUG_ALLOCATION
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-#include <execinfo.h>
-#endif
-
-#ifndef USE_JEMALLOC
-#if defined(DUCKDB_EXTENSION_JEMALLOC_LINKED) && DUCKDB_EXTENSION_JEMALLOC_LINKED && !defined(WIN32) &&                \
-    INTPTR_MAX == INT64_MAX
-#define USE_JEMALLOC
-#endif
-#endif
-
-#ifdef USE_JEMALLOC
-#include "jemalloc_extension.hpp"
-#endif
-
-#ifdef __GLIBC__
-#include <malloc.h>
-#endif
-
-namespace duckdb {
-
-AllocatedData::AllocatedData() : allocator(nullptr), pointer(nullptr), allocated_size(0) {
-}
-
-AllocatedData::AllocatedData(Allocator &allocator, data_ptr_t pointer, idx_t allocated_size)
-    : allocator(&allocator), pointer(pointer), allocated_size(allocated_size) {
-	if (!pointer) {
-		throw InternalException("AllocatedData object constructed with nullptr");
-	}
-}
-AllocatedData::~AllocatedData() {
-	Reset();
-}
-
-AllocatedData::AllocatedData(AllocatedData &&other) noexcept
-    : allocator(other.allocator), pointer(nullptr), allocated_size(0) {
-	std::swap(pointer, other.pointer);
-	std::swap(allocated_size, other.allocated_size);
-}
-
-AllocatedData &AllocatedData::operator=(AllocatedData &&other) noexcept {
-	std::swap(allocator, other.allocator);
-	std::swap(pointer, other.pointer);
-	std::swap(allocated_size, other.allocated_size);
-	return *this;
-}
-
-void AllocatedData::Reset() {
-	if (!pointer) {
-		return;
-	}
-	D_ASSERT(allocator);
-	allocator->FreeData(pointer, allocated_size);
-	allocated_size = 0;
-	pointer = nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Info
-//===--------------------------------------------------------------------===//
-struct AllocatorDebugInfo {
-#ifdef DEBUG
-	AllocatorDebugInfo();
-	~AllocatorDebugInfo();
-
-	void AllocateData(data_ptr_t pointer, idx_t size);
-	void FreeData(data_ptr_t pointer, idx_t size);
-	void ReallocateData(data_ptr_t pointer, data_ptr_t new_pointer, idx_t old_size, idx_t new_size);
-
-private:
-	//! The number of bytes that are outstanding (i.e. that have been allocated - but not freed)
-	//! Used for debug purposes
-	atomic<idx_t> allocation_count;
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	mutex pointer_lock;
-	//! Set of active outstanding pointers together with stack traces
-	unordered_map<data_ptr_t, pair<idx_t, string>> pointers;
-#endif
-#endif
-};
-
-PrivateAllocatorData::PrivateAllocatorData() {
-}
-
-PrivateAllocatorData::~PrivateAllocatorData() {
-}
-
-//===--------------------------------------------------------------------===//
-// Allocator
-//===--------------------------------------------------------------------===//
-Allocator::Allocator()
-    : Allocator(Allocator::DefaultAllocate, Allocator::DefaultFree, Allocator::DefaultReallocate, nullptr) {
-}
-
-Allocator::Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
-                     reallocate_function_ptr_t reallocate_function_p, unique_ptr<PrivateAllocatorData> private_data_p)
-    : allocate_function(allocate_function_p), free_function(free_function_p),
-      reallocate_function(reallocate_function_p), private_data(std::move(private_data_p)) {
-	D_ASSERT(allocate_function);
-	D_ASSERT(free_function);
-	D_ASSERT(reallocate_function);
-#ifdef DEBUG
-	if (!private_data) {
-		private_data = make_uniq<PrivateAllocatorData>();
-	}
-	private_data->debug_info = make_uniq<AllocatorDebugInfo>();
-#endif
-}
-
-Allocator::~Allocator() {
-}
-
-data_ptr_t Allocator::AllocateData(idx_t size) {
-	D_ASSERT(size > 0);
-	if (size >= MAXIMUM_ALLOC_SIZE) {
-		D_ASSERT(false);
-		throw InternalException("Requested allocation size of %llu is out of range - maximum allocation size is %llu",
-		                        size, MAXIMUM_ALLOC_SIZE);
-	}
-	auto result = allocate_function(private_data.get(), size);
-#ifdef DEBUG
-	D_ASSERT(private_data);
-	if (private_data->free_type != AllocatorFreeType::DOES_NOT_REQUIRE_FREE) {
-		private_data->debug_info->AllocateData(result, size);
-	}
-#endif
-	if (!result) {
-		throw OutOfMemoryException("Failed to allocate block of %llu bytes (bad allocation)", size);
-	}
-	return result;
-}
-
-void Allocator::FreeData(data_ptr_t pointer, idx_t size) {
-	if (!pointer) {
-		return;
-	}
-	D_ASSERT(size > 0);
-#ifdef DEBUG
-	D_ASSERT(private_data);
-	if (private_data->free_type != AllocatorFreeType::DOES_NOT_REQUIRE_FREE) {
-		private_data->debug_info->FreeData(pointer, size);
-	}
-#endif
-	free_function(private_data.get(), pointer, size);
-}
-
-data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t size) {
-	if (!pointer) {
-		return nullptr;
-	}
-	if (size >= MAXIMUM_ALLOC_SIZE) {
-		D_ASSERT(false);
-		throw InternalException(
-		    "Requested re-allocation size of %llu is out of range - maximum allocation size is %llu", size,
-		    MAXIMUM_ALLOC_SIZE);
-	}
-	auto new_pointer = reallocate_function(private_data.get(), pointer, old_size, size);
-#ifdef DEBUG
-	D_ASSERT(private_data);
-	if (private_data->free_type != AllocatorFreeType::DOES_NOT_REQUIRE_FREE) {
-		private_data->debug_info->ReallocateData(pointer, new_pointer, old_size, size);
-	}
-#endif
-	if (!new_pointer) {
-		throw OutOfMemoryException("Failed to re-allocate block of %llu bytes (bad allocation)", size);
-	}
-	return new_pointer;
-}
-
-data_ptr_t Allocator::DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) {
-#ifdef USE_JEMALLOC
-	return JemallocExtension::Allocate(private_data, size);
-#else
-	auto default_allocate_result = malloc(size);
-	if (!default_allocate_result) {
-		throw std::bad_alloc();
-	}
-	return data_ptr_cast(default_allocate_result);
-#endif
-}
-
-void Allocator::DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
-#ifdef USE_JEMALLOC
-	JemallocExtension::Free(private_data, pointer, size);
-#else
-	free(pointer);
-#endif
-}
-
-data_ptr_t Allocator::DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-                                        idx_t size) {
-#ifdef USE_JEMALLOC
-	return JemallocExtension::Reallocate(private_data, pointer, old_size, size);
-#else
-	return data_ptr_cast(realloc(pointer, size));
-#endif
-}
-
-shared_ptr<Allocator> &Allocator::DefaultAllocatorReference() {
-	static shared_ptr<Allocator> DEFAULT_ALLOCATOR = make_shared_ptr<Allocator>();
-	return DEFAULT_ALLOCATOR;
-}
-
-Allocator &Allocator::DefaultAllocator() {
-	return *DefaultAllocatorReference();
-}
-
-optional_idx Allocator::DecayDelay() {
-#ifdef USE_JEMALLOC
-	return NumericCast<idx_t>(JemallocExtension::DecayDelay());
-#else
-	return optional_idx();
-#endif
-}
-
-bool Allocator::SupportsFlush() {
-#if defined(USE_JEMALLOC) || defined(__GLIBC__)
-	return true;
-#else
-	return false;
-#endif
-}
-
-static void MallocTrim(idx_t pad) {
-#ifdef __GLIBC__
-	static constexpr int64_t TRIM_INTERVAL_MS = 100;
-	static atomic<int64_t> LAST_TRIM_TIMESTAMP_MS {0};
-
-	int64_t last_trim_timestamp_ms = LAST_TRIM_TIMESTAMP_MS.load();
-	auto current_ts = Timestamp::GetCurrentTimestamp();
-	auto current_timestamp_ms = Cast::Operation<timestamp_t, timestamp_ms_t>(current_ts).value;
-
-	if (current_timestamp_ms - last_trim_timestamp_ms < TRIM_INTERVAL_MS) {
-		return; // We trimmed less than TRIM_INTERVAL_MS ago
-	}
-	if (!LAST_TRIM_TIMESTAMP_MS.compare_exchange_strong(last_trim_timestamp_ms, current_timestamp_ms,
-	                                                    std::memory_order_acquire, std::memory_order_relaxed)) {
-		return; // Another thread has updated LAST_TRIM_TIMESTAMP_MS since we loaded it
-	}
-
-	// We succesfully updated LAST_TRIM_TIMESTAMP_MS, we can trim
-	malloc_trim(pad);
-#endif
-}
-
-void Allocator::ThreadFlush(bool allocator_background_threads, idx_t threshold, idx_t thread_count) {
-#ifdef USE_JEMALLOC
-	if (!allocator_background_threads) {
-		JemallocExtension::ThreadFlush(threshold);
-	}
-#endif
-	MallocTrim(thread_count * threshold);
-}
-
-void Allocator::ThreadIdle() {
-#ifdef USE_JEMALLOC
-	JemallocExtension::ThreadIdle();
-#endif
-}
-
-void Allocator::FlushAll() {
-#ifdef USE_JEMALLOC
-	JemallocExtension::FlushAll();
-#endif
-	MallocTrim(0);
-}
-
-void Allocator::SetBackgroundThreads(bool enable) {
-#ifdef USE_JEMALLOC
-	JemallocExtension::SetBackgroundThreads(enable);
-#endif
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Info (extended)
-//===--------------------------------------------------------------------===//
-#ifdef DEBUG
-AllocatorDebugInfo::AllocatorDebugInfo() {
-	allocation_count = 0;
-}
-AllocatorDebugInfo::~AllocatorDebugInfo() {
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	if (allocation_count != 0) {
-		printf("Outstanding allocations found for Allocator\n");
-		for (auto &entry : pointers) {
-			printf("Allocation of size %llu at address %p\n", entry.second.first, (void *)entry.first);
-			printf("Stack trace:\n%s\n", entry.second.second.c_str());
-			printf("\n");
-		}
-	}
-#endif
-	//! Verify that there is no outstanding memory still associated with the batched allocator
-	//! Only works for access to the batched allocator through the batched allocator interface
-	//! If this assertion triggers, enable DUCKDB_DEBUG_ALLOCATION for more information about the allocations
-	D_ASSERT(allocation_count == 0);
-}
-
-void AllocatorDebugInfo::AllocateData(data_ptr_t pointer, idx_t size) {
-	allocation_count += size;
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	lock_guard<mutex> l(pointer_lock);
-	pointers[pointer] = make_pair(size, Exception::GetStackTrace());
-#endif
-}
-
-void AllocatorDebugInfo::FreeData(data_ptr_t pointer, idx_t size) {
-	D_ASSERT(allocation_count >= size);
-	allocation_count -= size;
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	lock_guard<mutex> l(pointer_lock);
-	// verify that the pointer exists
-	D_ASSERT(pointers.find(pointer) != pointers.end());
-	// verify that the stored size matches the passed in size
-	D_ASSERT(pointers[pointer].first == size);
-	// erase the pointer
-	pointers.erase(pointer);
-#endif
-}
-
-void AllocatorDebugInfo::ReallocateData(data_ptr_t pointer, data_ptr_t new_pointer, idx_t old_size, idx_t new_size) {
-	FreeData(pointer, old_size);
-	AllocateData(new_pointer, new_size);
-}
-
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/appender/bool_data.cpp b/src/duckdb/src/common/arrow/appender/bool_data.cpp
deleted file mode 100644
index 78befb603..000000000
--- a/src/duckdb/src/common/arrow/appender/bool_data.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/appender/bool_data.hpp"
-
-namespace duckdb {
-
-void ArrowBoolData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-	auto byte_count = (capacity + 7) / 8;
-	result.GetMainBuffer().reserve(byte_count);
-	(void)AppendValidity; // silence a compiler warning about unused static function
-}
-
-void ArrowBoolData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-	idx_t size = to - from;
-	UnifiedVectorFormat format;
-	input.ToUnifiedFormat(input_size, format);
-	auto &main_buffer = append_data.GetMainBuffer();
-	auto &validity_buffer = append_data.GetValidityBuffer();
-	// we initialize both the validity and the bit set to 1's
-	ResizeValidity(validity_buffer, append_data.row_count + size);
-	ResizeValidity(main_buffer, append_data.row_count + size);
-	auto data = UnifiedVectorFormat::GetData<bool>(format);
-
-	auto result_data = main_buffer.GetData<uint8_t>();
-	auto validity_data = validity_buffer.GetData<uint8_t>();
-	uint8_t current_bit;
-	idx_t current_byte;
-	GetBitPosition(append_data.row_count, current_byte, current_bit);
-	for (idx_t i = from; i < to; i++) {
-		auto source_idx = format.sel->get_index(i);
-		// append the validity mask
-		if (!format.validity.RowIsValid(source_idx)) {
-			SetNull(append_data, validity_data, current_byte, current_bit);
-		} else if (!data[source_idx]) {
-			UnsetBit(result_data, current_byte, current_bit);
-		}
-		NextBit(current_byte, current_bit);
-	}
-	append_data.row_count += size;
-}
-
-void ArrowBoolData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-	result->n_buffers = 2;
-	result->buffers[1] = append_data.GetMainBuffer().data();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/appender/fixed_size_list_data.cpp b/src/duckdb/src/common/arrow/appender/fixed_size_list_data.cpp
deleted file mode 100644
index 172144fd3..000000000
--- a/src/duckdb/src/common/arrow/appender/fixed_size_list_data.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/appender/fixed_size_list_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Arrays
-//===--------------------------------------------------------------------===//
-void ArrowFixedSizeListData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-	auto &child_type = ArrayType::GetChildType(type);
-	auto array_size = ArrayType::GetSize(type);
-	auto child_buffer = ArrowAppender::InitializeChild(child_type, capacity * array_size, result.options);
-	result.child_data.push_back(std::move(child_buffer));
-}
-
-void ArrowFixedSizeListData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to,
-                                    idx_t input_size) {
-	UnifiedVectorFormat format;
-	input.ToUnifiedFormat(input_size, format);
-	idx_t size = to - from;
-	AppendValidity(append_data, format, from, to);
-	input.Flatten(input_size);
-	auto array_size = ArrayType::GetSize(input.GetType());
-	auto &child_vector = ArrayVector::GetEntry(input);
-	auto &child_data = *append_data.child_data[0];
-	child_data.append_vector(child_data, child_vector, from * array_size, to * array_size, size * array_size);
-	append_data.row_count += size;
-}
-
-void ArrowFixedSizeListData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-	result->n_buffers = 1;
-	auto &child_type = ArrayType::GetChildType(type);
-	ArrowAppender::AddChildren(append_data, 1);
-	result->children = append_data.child_pointers.data();
-	result->n_children = 1;
-	append_data.child_arrays[0] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[0]));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/appender/struct_data.cpp b/src/duckdb/src/common/arrow/appender/struct_data.cpp
deleted file mode 100644
index b2afa62d1..000000000
--- a/src/duckdb/src/common/arrow/appender/struct_data.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/appender/struct_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Structs
-//===--------------------------------------------------------------------===//
-void ArrowStructData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-	auto &children = StructType::GetChildTypes(type);
-	for (auto &child : children) {
-		auto child_buffer = ArrowAppender::InitializeChild(child.second, capacity, result.options);
-		result.child_data.push_back(std::move(child_buffer));
-	}
-}
-
-void ArrowStructData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-	UnifiedVectorFormat format;
-	input.ToUnifiedFormat(input_size, format);
-	idx_t size = to - from;
-	AppendValidity(append_data, format, from, to);
-	// append the children of the struct
-	auto &children = StructVector::GetEntries(input);
-	for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
-		auto &child = children[child_idx];
-		auto &child_data = *append_data.child_data[child_idx];
-		child_data.append_vector(child_data, *child, from, to, size);
-	}
-	append_data.row_count += size;
-}
-
-void ArrowStructData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-	result->n_buffers = 1;
-
-	auto &child_types = StructType::GetChildTypes(type);
-	ArrowAppender::AddChildren(append_data, child_types.size());
-	result->children = append_data.child_pointers.data();
-	result->n_children = NumericCast<int64_t>(child_types.size());
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		auto &child_type = child_types[i].second;
-		append_data.child_arrays[i] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[i]));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/appender/union_data.cpp b/src/duckdb/src/common/arrow/appender/union_data.cpp
deleted file mode 100644
index 1e9f4f432..000000000
--- a/src/duckdb/src/common/arrow/appender/union_data.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/appender/union_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Unions
-//===--------------------------------------------------------------------===//
-void ArrowUnionData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-	result.GetMainBuffer().reserve(capacity * sizeof(int8_t));
-
-	for (auto &child : UnionType::CopyMemberTypes(type)) {
-		auto child_buffer = ArrowAppender::InitializeChild(child.second, capacity, result.options);
-		result.child_data.push_back(std::move(child_buffer));
-	}
-	(void)AppendValidity; // silence a compiler warning about unused static functiondep
-}
-
-void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-	UnifiedVectorFormat format;
-	input.ToUnifiedFormat(input_size, format);
-	idx_t size = to - from;
-
-	auto &types_buffer = append_data.GetMainBuffer();
-
-	duckdb::vector<Vector> child_vectors;
-	for (const auto &child : UnionType::CopyMemberTypes(input.GetType())) {
-		child_vectors.emplace_back(child.second, size);
-	}
-
-	for (idx_t input_idx = from; input_idx < to; input_idx++) {
-		const auto &val = input.GetValue(input_idx);
-
-		idx_t tag = 0;
-		Value resolved_value(nullptr);
-		if (!val.IsNull()) {
-			tag = UnionValue::GetTag(val);
-
-			resolved_value = UnionValue::GetValue(val);
-		}
-
-		for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
-			child_vectors[child_idx].SetValue(input_idx, child_idx == tag ? resolved_value : Value(nullptr));
-		}
-		types_buffer.push_back<data_t>(NumericCast<data_t>(tag));
-	}
-
-	for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
-		auto &child_buffer = append_data.child_data[child_idx];
-		auto &child = child_vectors[child_idx];
-		child_buffer->append_vector(*child_buffer, child, from, to, size);
-	}
-	append_data.row_count += size;
-}
-
-void ArrowUnionData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-	result->n_buffers = 1;
-	result->buffers[0] = append_data.GetMainBuffer().data();
-
-	auto &child_types = UnionType::CopyMemberTypes(type);
-	ArrowAppender::AddChildren(append_data, child_types.size());
-	result->children = append_data.child_pointers.data();
-	result->n_children = NumericCast<int64_t>(child_types.size());
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		auto &child_type = child_types[i].second;
-		append_data.child_arrays[i] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[i]));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/arrow_appender.cpp b/src/duckdb/src/common/arrow/arrow_appender.cpp
deleted file mode 100644
index 632bffc66..000000000
--- a/src/duckdb/src/common/arrow/arrow_appender.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/arrow_buffer.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/array.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/function/table/arrow.hpp"
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/appender/list.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// ArrowAppender
-//===--------------------------------------------------------------------===//
-
-ArrowAppender::ArrowAppender(vector<LogicalType> types_p, const idx_t initial_capacity, ClientProperties options)
-    : types(std::move(types_p)) {
-	for (auto &type : types) {
-		auto entry = InitializeChild(type, initial_capacity, options);
-		root_data.push_back(std::move(entry));
-	}
-}
-
-ArrowAppender::~ArrowAppender() {
-}
-
-//! Append a data chunk to the underlying arrow array
-void ArrowAppender::Append(DataChunk &input, idx_t from, idx_t to, idx_t input_size) {
-	D_ASSERT(types == input.GetTypes());
-	D_ASSERT(to >= from);
-	for (idx_t i = 0; i < input.ColumnCount(); i++) {
-		root_data[i]->append_vector(*root_data[i], input.data[i], from, to, input_size);
-	}
-	row_count += to - from;
-}
-
-idx_t ArrowAppender::RowCount() const {
-	return row_count;
-}
-
-void ArrowAppender::ReleaseArray(ArrowArray *array) {
-	if (!array || !array->release) {
-		return;
-	}
-	auto holder = static_cast<ArrowAppendData *>(array->private_data);
-	for (int64_t i = 0; i < array->n_children; i++) {
-		auto child = array->children[i];
-		if (!child->release) {
-			// Child was moved out of the array
-			continue;
-		}
-		child->release(child);
-		D_ASSERT(!child->release);
-	}
-	if (array->dictionary && array->dictionary->release) {
-		array->dictionary->release(array->dictionary);
-	}
-	array->release = nullptr;
-	delete holder;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize Arrow Child
-//===--------------------------------------------------------------------===//
-ArrowArray *ArrowAppender::FinalizeChild(const LogicalType &type, unique_ptr<ArrowAppendData> append_data_p) {
-	auto result = make_uniq<ArrowArray>();
-
-	auto &append_data = *append_data_p;
-	result->private_data = append_data_p.release();
-	result->release = ReleaseArray;
-	result->n_children = 0;
-	result->null_count = 0;
-	result->offset = 0;
-	result->dictionary = nullptr;
-	result->buffers = append_data.buffers.data();
-	result->null_count = NumericCast<int64_t>(append_data.null_count);
-	result->length = NumericCast<int64_t>(append_data.row_count);
-	result->buffers[0] = append_data.GetValidityBuffer().data();
-
-	if (append_data.finalize) {
-		append_data.finalize(append_data, type, result.get());
-	}
-
-	append_data.array = std::move(result);
-	return append_data.array.get();
-}
-
-//! Returns the underlying arrow array
-ArrowArray ArrowAppender::Finalize() {
-	D_ASSERT(root_data.size() == types.size());
-	auto root_holder = make_uniq<ArrowAppendData>(options);
-
-	ArrowArray result;
-	AddChildren(*root_holder, types.size());
-	result.children = root_holder->child_pointers.data();
-	result.n_children = NumericCast<int64_t>(types.size());
-
-	// Configure root array
-	result.length = NumericCast<int64_t>(row_count);
-	result.n_buffers = 1;
-	result.buffers = root_holder->buffers.data(); // there is no actual buffer there since we don't have NULLs
-	result.offset = 0;
-	result.null_count = 0; // needs to be 0
-	result.dictionary = nullptr;
-	root_holder->child_data = std::move(root_data);
-
-	for (idx_t i = 0; i < root_holder->child_data.size(); i++) {
-		root_holder->child_arrays[i] = *ArrowAppender::FinalizeChild(types[i], std::move(root_holder->child_data[i]));
-	}
-
-	// Release ownership to caller
-	result.private_data = root_holder.release();
-	result.release = ArrowAppender::ReleaseArray;
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Initialize Arrow Child
-//===--------------------------------------------------------------------===//
-
-template <class OP>
-static void InitializeAppenderForType(ArrowAppendData &append_data) {
-	append_data.initialize = OP::Initialize;
-	append_data.append_vector = OP::Append;
-	append_data.finalize = OP::Finalize;
-}
-
-static void InitializeFunctionPointers(ArrowAppendData &append_data, const LogicalType &type) {
-	// handle special logical types
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		InitializeAppenderForType<ArrowBoolData>(append_data);
-		break;
-	case LogicalTypeId::TINYINT:
-		InitializeAppenderForType<ArrowScalarData<int8_t>>(append_data);
-		break;
-	case LogicalTypeId::SMALLINT:
-		InitializeAppenderForType<ArrowScalarData<int16_t>>(append_data);
-		break;
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::INTEGER:
-		InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
-		break;
-	case LogicalTypeId::TIME_TZ: {
-		if (append_data.options.arrow_lossless_conversion) {
-			InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
-		} else {
-			InitializeAppenderForType<ArrowScalarData<int64_t, dtime_tz_t, ArrowTimeTzConverter>>(append_data);
-		}
-		break;
-	}
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::BIGINT:
-		InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
-		break;
-	case LogicalTypeId::UUID:
-		if (append_data.options.arrow_lossless_conversion) {
-			InitializeAppenderForType<ArrowScalarData<hugeint_t, hugeint_t, ArrowUUIDBlobConverter>>(append_data);
-		} else {
-			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter>>(append_data);
-			} else {
-				InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter, int32_t>>(append_data);
-			}
-		}
-		break;
-	case LogicalTypeId::HUGEINT:
-		InitializeAppenderForType<ArrowScalarData<hugeint_t>>(append_data);
-		break;
-	case LogicalTypeId::UHUGEINT:
-		InitializeAppenderForType<ArrowScalarData<uhugeint_t>>(append_data);
-		break;
-	case LogicalTypeId::UTINYINT:
-		InitializeAppenderForType<ArrowScalarData<uint8_t>>(append_data);
-		break;
-	case LogicalTypeId::USMALLINT:
-		InitializeAppenderForType<ArrowScalarData<uint16_t>>(append_data);
-		break;
-	case LogicalTypeId::UINTEGER:
-		InitializeAppenderForType<ArrowScalarData<uint32_t>>(append_data);
-		break;
-	case LogicalTypeId::UBIGINT:
-		InitializeAppenderForType<ArrowScalarData<uint64_t>>(append_data);
-		break;
-	case LogicalTypeId::FLOAT:
-		InitializeAppenderForType<ArrowScalarData<float>>(append_data);
-		break;
-	case LogicalTypeId::DOUBLE:
-		InitializeAppenderForType<ArrowScalarData<double>>(append_data);
-		break;
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			InitializeAppenderForType<ArrowScalarData<hugeint_t, int16_t>>(append_data);
-			break;
-		case PhysicalType::INT32:
-			InitializeAppenderForType<ArrowScalarData<hugeint_t, int32_t>>(append_data);
-			break;
-		case PhysicalType::INT64:
-			InitializeAppenderForType<ArrowScalarData<hugeint_t, int64_t>>(append_data);
-			break;
-		case PhysicalType::INT128:
-			InitializeAppenderForType<ArrowScalarData<hugeint_t>>(append_data);
-			break;
-		default:
-			throw InternalException("Unsupported internal decimal type");
-		}
-		break;
-	case LogicalTypeId::VARCHAR:
-		if (append_data.options.produce_arrow_string_view) {
-			InitializeAppenderForType<ArrowVarcharToStringViewData>(append_data);
-		} else {
-			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				InitializeAppenderForType<ArrowVarcharData<>>(append_data);
-			} else {
-				InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, int32_t>>(append_data);
-			}
-		}
-		break;
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
-	case LogicalTypeId::VARINT:
-		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			InitializeAppenderForType<ArrowVarcharData<>>(append_data);
-		} else {
-			InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, int32_t>>(append_data);
-		}
-		break;
-	case LogicalTypeId::ENUM:
-		switch (type.InternalType()) {
-		case PhysicalType::UINT8:
-			InitializeAppenderForType<ArrowEnumData<int8_t>>(append_data);
-			break;
-		case PhysicalType::UINT16:
-			InitializeAppenderForType<ArrowEnumData<int16_t>>(append_data);
-			break;
-		case PhysicalType::UINT32:
-			InitializeAppenderForType<ArrowEnumData<int32_t>>(append_data);
-			break;
-		default:
-			throw InternalException("Unsupported internal enum type");
-		}
-		break;
-	case LogicalTypeId::INTERVAL:
-		InitializeAppenderForType<ArrowScalarData<ArrowInterval, interval_t, ArrowIntervalConverter>>(append_data);
-		break;
-	case LogicalTypeId::UNION:
-		InitializeAppenderForType<ArrowUnionData>(append_data);
-		break;
-	case LogicalTypeId::STRUCT:
-		InitializeAppenderForType<ArrowStructData>(append_data);
-		break;
-	case LogicalTypeId::ARRAY:
-		InitializeAppenderForType<ArrowFixedSizeListData>(append_data);
-		break;
-	case LogicalTypeId::LIST: {
-		if (append_data.options.arrow_use_list_view) {
-			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				InitializeAppenderForType<ArrowListViewData<>>(append_data);
-			} else {
-				InitializeAppenderForType<ArrowListViewData<int32_t>>(append_data);
-			}
-		} else {
-			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				InitializeAppenderForType<ArrowListData<>>(append_data);
-			} else {
-				InitializeAppenderForType<ArrowListData<int32_t>>(append_data);
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::MAP:
-		// Arrow MapArray only supports 32-bit offsets. There is no LargeMapArray type in Arrow.
-		InitializeAppenderForType<ArrowMapData<int32_t>>(append_data);
-		break;
-	default:
-		throw NotImplementedException("Unsupported type in DuckDB -> Arrow Conversion: %s\n", type.ToString());
-	}
-}
-
-unique_ptr<ArrowAppendData> ArrowAppender::InitializeChild(const LogicalType &type, const idx_t capacity,
-                                                           ClientProperties &options) {
-	auto result = make_uniq<ArrowAppendData>(options);
-	InitializeFunctionPointers(*result, type);
-
-	const auto byte_count = (capacity + 7) / 8;
-	result->GetValidityBuffer().reserve(byte_count);
-	result->initialize(*result, type, capacity);
-	return result;
-}
-
-void ArrowAppender::AddChildren(ArrowAppendData &data, const idx_t count) {
-	data.child_pointers.resize(count);
-	data.child_arrays.resize(count);
-	for (idx_t i = 0; i < count; i++) {
-		data.child_pointers[i] = &data.child_arrays[i];
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/arrow_converter.cpp b/src/duckdb/src/common/arrow/arrow_converter.cpp
deleted file mode 100644
index 582daf34b..000000000
--- a/src/duckdb/src/common/arrow/arrow_converter.cpp
+++ /dev/null
@@ -1,432 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/arrow/arrow_converter.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/sel_cache.hpp"
-#include "duckdb/common/types/vector_cache.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/vector.hpp"
-#include <list>
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/schema_metadata.hpp"
-
-namespace duckdb {
-
-void ArrowConverter::ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options) {
-	ArrowAppender appender(input.GetTypes(), input.size(), std::move(options));
-	appender.Append(input, 0, input.size(), input.size());
-	*out_array = appender.Finalize();
-}
-
-unsafe_unique_array<char> AddName(const string &name) {
-	auto name_ptr = make_unsafe_uniq_array<char>(name.size() + 1);
-	for (size_t i = 0; i < name.size(); i++) {
-		name_ptr[i] = name[i];
-	}
-	name_ptr[name.size()] = '\0';
-	return name_ptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Arrow Schema
-//===--------------------------------------------------------------------===//
-struct DuckDBArrowSchemaHolder {
-	// unused in children
-	vector<ArrowSchema> children;
-	// unused in children
-	vector<ArrowSchema *> children_ptrs;
-	//! used for nested structures
-	std::list<vector<ArrowSchema>> nested_children;
-	std::list<vector<ArrowSchema *>> nested_children_ptr;
-	//! This holds strings created to represent decimal types
-	vector<unsafe_unique_array<char>> owned_type_names;
-	vector<unsafe_unique_array<char>> owned_column_names;
-	//! This holds any values created for metadata info
-	vector<unsafe_unique_array<char>> metadata_info;
-};
-
-static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
-	if (!schema || !schema->release) {
-		return;
-	}
-	schema->release = nullptr;
-	auto holder = static_cast<DuckDBArrowSchemaHolder *>(schema->private_data);
-	delete holder;
-}
-
-void InitializeChild(ArrowSchema &child, DuckDBArrowSchemaHolder &root_holder, const string &name = "") {
-	//! Child is cleaned up by parent
-	child.private_data = nullptr;
-	child.release = ReleaseDuckDBArrowSchema;
-
-	// Store the child schema
-	child.flags = ARROW_FLAG_NULLABLE;
-	root_holder.owned_type_names.push_back(AddName(name));
-
-	child.name = root_holder.owned_type_names.back().get();
-	child.n_children = 0;
-	child.children = nullptr;
-	child.metadata = nullptr;
-	child.dictionary = nullptr;
-}
-
-void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                    const ClientProperties &options);
-
-void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                       const ClientProperties &options) {
-	child.format = "+m";
-	//! Map has one child which is a struct
-	child.n_children = 1;
-	root_holder.nested_children.emplace_back();
-	root_holder.nested_children.back().resize(1);
-	root_holder.nested_children_ptr.emplace_back();
-	root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-	InitializeChild(root_holder.nested_children.back()[0], root_holder);
-	child.children = &root_holder.nested_children_ptr.back()[0];
-	child.children[0]->name = "entries";
-	SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options);
-}
-
-void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                    const ClientProperties &options) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		child.format = "b";
-		break;
-	case LogicalTypeId::TINYINT:
-		child.format = "c";
-		break;
-	case LogicalTypeId::SMALLINT:
-		child.format = "s";
-		break;
-	case LogicalTypeId::INTEGER:
-		child.format = "i";
-		break;
-	case LogicalTypeId::BIGINT:
-		child.format = "l";
-		break;
-	case LogicalTypeId::UTINYINT:
-		child.format = "C";
-		break;
-	case LogicalTypeId::USMALLINT:
-		child.format = "S";
-		break;
-	case LogicalTypeId::UINTEGER:
-		child.format = "I";
-		break;
-	case LogicalTypeId::UBIGINT:
-		child.format = "L";
-		break;
-	case LogicalTypeId::FLOAT:
-		child.format = "f";
-		break;
-	case LogicalTypeId::HUGEINT: {
-		if (options.arrow_lossless_conversion) {
-			child.format = "w:16";
-			auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("hugeint");
-			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-			child.metadata = root_holder.metadata_info.back().get();
-		} else {
-			child.format = "d:38,0";
-		}
-		break;
-	}
-	case LogicalTypeId::UHUGEINT: {
-		child.format = "w:16";
-		auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("uhugeint");
-		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-		child.metadata = root_holder.metadata_info.back().get();
-		break;
-	}
-	case LogicalTypeId::VARINT: {
-		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			child.format = "Z";
-		} else {
-			child.format = "z";
-		}
-		auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("varint");
-		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-		child.metadata = root_holder.metadata_info.back().get();
-		break;
-	}
-	case LogicalTypeId::DOUBLE:
-		child.format = "g";
-		break;
-	case LogicalTypeId::UUID: {
-		if (options.arrow_lossless_conversion) {
-			// This is a canonical extension, hence needs the "arrow." prefix
-			child.format = "w:16";
-			auto schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType("arrow.uuid");
-			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-			child.metadata = root_holder.metadata_info.back().get();
-		} else {
-			if (options.produce_arrow_string_view) {
-				child.format = "vu";
-			} else {
-				if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-					child.format = "U";
-				} else {
-					child.format = "u";
-				}
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::VARCHAR:
-		if (type.IsJSONType() && options.arrow_lossless_conversion) {
-			auto schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType("arrow.json");
-			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-			child.metadata = root_holder.metadata_info.back().get();
-		}
-		if (options.produce_arrow_string_view) {
-			child.format = "vu";
-		} else {
-			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				child.format = "U";
-			} else {
-				child.format = "u";
-			}
-		}
-		break;
-	case LogicalTypeId::DATE:
-		child.format = "tdD";
-		break;
-	case LogicalTypeId::TIME_TZ: {
-		if (options.arrow_lossless_conversion) {
-			child.format = "w:8";
-			auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("time_tz");
-			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-			child.metadata = root_holder.metadata_info.back().get();
-		} else {
-			child.format = "ttu";
-		}
-		break;
-	}
-	case LogicalTypeId::TIME:
-		child.format = "ttu";
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		child.format = "tsu:";
-		break;
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		string format = "tsu:" + options.time_zone;
-		root_holder.owned_type_names.push_back(AddName(format));
-		child.format = root_holder.owned_type_names.back().get();
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_SEC:
-		child.format = "tss:";
-		break;
-	case LogicalTypeId::TIMESTAMP_NS:
-		child.format = "tsn:";
-		break;
-	case LogicalTypeId::TIMESTAMP_MS:
-		child.format = "tsm:";
-		break;
-	case LogicalTypeId::INTERVAL:
-		child.format = "tin";
-		break;
-	case LogicalTypeId::DECIMAL: {
-		uint8_t width, scale;
-		type.GetDecimalProperties(width, scale);
-		string format = "d:" + to_string(width) + "," + to_string(scale);
-		root_holder.owned_type_names.push_back(AddName(format));
-		child.format = root_holder.owned_type_names.back().get();
-		break;
-	}
-	case LogicalTypeId::SQLNULL: {
-		child.format = "n";
-		break;
-	}
-	case LogicalTypeId::BLOB:
-		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			child.format = "Z";
-		} else {
-			child.format = "z";
-		}
-		break;
-	case LogicalTypeId::BIT: {
-		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			child.format = "Z";
-		} else {
-			child.format = "z";
-		}
-		if (options.arrow_lossless_conversion) {
-			auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("bit");
-			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
-			child.metadata = root_holder.metadata_info.back().get();
-		}
-		break;
-	}
-	case LogicalTypeId::LIST: {
-		if (options.arrow_use_list_view) {
-			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				child.format = "+vL";
-			} else {
-				child.format = "+vl";
-			}
-		} else {
-			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-				child.format = "+L";
-			} else {
-				child.format = "+l";
-			}
-		}
-		child.n_children = 1;
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(1);
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0], root_holder);
-		child.children = &root_holder.nested_children_ptr.back()[0];
-		child.children[0]->name = "l";
-		SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options);
-		break;
-	}
-	case LogicalTypeId::STRUCT: {
-		child.format = "+s";
-		auto &child_types = StructType::GetChildTypes(type);
-		child.n_children = NumericCast<int64_t>(child_types.size());
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(child_types.size());
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().resize(child_types.size());
-		for (idx_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
-			root_holder.nested_children_ptr.back()[type_idx] = &root_holder.nested_children.back()[type_idx];
-		}
-		child.children = &root_holder.nested_children_ptr.back()[0];
-		for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
-
-			InitializeChild(*child.children[type_idx], root_holder);
-
-			root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
-
-			child.children[type_idx]->name = root_holder.owned_type_names.back().get();
-			SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options);
-		}
-		break;
-	}
-	case LogicalTypeId::ARRAY: {
-		auto array_size = ArrayType::GetSize(type);
-		auto &child_type = ArrayType::GetChildType(type);
-		auto format = "+w:" + to_string(array_size);
-		root_holder.owned_type_names.push_back(AddName(format));
-		child.format = root_holder.owned_type_names.back().get();
-
-		child.n_children = 1;
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(1);
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0], root_holder);
-		child.children = &root_holder.nested_children_ptr.back()[0];
-		SetArrowFormat(root_holder, **child.children, child_type, options);
-		break;
-	}
-	case LogicalTypeId::MAP: {
-		SetArrowMapFormat(root_holder, child, type, options);
-		break;
-	}
-	case LogicalTypeId::UNION: {
-		std::string format = "+us:";
-
-		auto &child_types = UnionType::CopyMemberTypes(type);
-		child.n_children = NumericCast<int64_t>(child_types.size());
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(child_types.size());
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().resize(child_types.size());
-		for (idx_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
-			root_holder.nested_children_ptr.back()[type_idx] = &root_holder.nested_children.back()[type_idx];
-		}
-		child.children = &root_holder.nested_children_ptr.back()[0];
-		for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
-
-			InitializeChild(*child.children[type_idx], root_holder);
-
-			root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
-
-			child.children[type_idx]->name = root_holder.owned_type_names.back().get();
-			SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options);
-
-			format += to_string(type_idx) + ",";
-		}
-
-		format.pop_back();
-
-		root_holder.owned_type_names.push_back(AddName(format));
-		child.format = root_holder.owned_type_names.back().get();
-
-		break;
-	}
-	case LogicalTypeId::ENUM: {
-		// TODO what do we do with pointer enums here?
-		switch (EnumType::GetPhysicalType(type)) {
-		case PhysicalType::UINT8:
-			child.format = "C";
-			break;
-		case PhysicalType::UINT16:
-			child.format = "S";
-			break;
-		case PhysicalType::UINT32:
-			child.format = "I";
-			break;
-		default:
-			throw InternalException("Unsupported Enum Internal Type");
-		}
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(1);
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0], root_holder);
-		child.dictionary = root_holder.nested_children_ptr.back()[0];
-		child.dictionary->format = "u";
-		break;
-	}
-	default:
-		throw NotImplementedException("Unsupported Arrow type " + type.ToString());
-	}
-}
-
-void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vector<LogicalType> &types,
-                                   const vector<string> &names, const ClientProperties &options) {
-	D_ASSERT(out_schema);
-	D_ASSERT(types.size() == names.size());
-	idx_t column_count = types.size();
-	// Allocate as unique_ptr first to cleanup properly on error
-	auto root_holder = make_uniq<DuckDBArrowSchemaHolder>();
-
-	// Allocate the children
-	root_holder->children.resize(column_count);
-	root_holder->children_ptrs.resize(column_count, nullptr);
-	for (size_t i = 0; i < column_count; ++i) {
-		root_holder->children_ptrs[i] = &root_holder->children[i];
-	}
-	out_schema->children = root_holder->children_ptrs.data();
-	out_schema->n_children = NumericCast<int64_t>(column_count);
-
-	// Store the schema
-	out_schema->format = "+s"; // struct apparently
-	out_schema->flags = 0;
-	out_schema->metadata = nullptr;
-	out_schema->name = "duckdb_query_result";
-	out_schema->dictionary = nullptr;
-
-	// Configure all child schemas
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-		root_holder->owned_column_names.push_back(AddName(names[col_idx]));
-		auto &child = root_holder->children[col_idx];
-		InitializeChild(child, *root_holder, names[col_idx]);
-		SetArrowFormat(*root_holder, child, types[col_idx], options);
-	}
-
-	// Release ownership to caller
-	out_schema->private_data = root_holder.release();
-	out_schema->release = ReleaseDuckDBArrowSchema;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/arrow_merge_event.cpp b/src/duckdb/src/common/arrow/arrow_merge_event.cpp
deleted file mode 100644
index 1315ad1ad..000000000
--- a/src/duckdb/src/common/arrow/arrow_merge_event.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "duckdb/common/arrow/arrow_merge_event.hpp"
-#include "duckdb/common/arrow/arrow_util.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Arrow Batch Task
-//===--------------------------------------------------------------------===//
-
-ArrowBatchTask::ArrowBatchTask(ArrowQueryResult &result, vector<idx_t> record_batch_indices, Executor &executor,
-                               shared_ptr<Event> event_p, BatchCollectionChunkScanState scan_state,
-                               vector<string> names, idx_t batch_size)
-    : ExecutorTask(executor, event_p), result(result), record_batch_indices(std::move(record_batch_indices)),
-      event(std::move(event_p)), batch_size(batch_size), names(std::move(names)), scan_state(std::move(scan_state)) {
-}
-
-void ArrowBatchTask::ProduceRecordBatches() {
-	auto &arrays = result.Arrays();
-	auto arrow_options = executor.context.GetClientProperties();
-	for (auto &index : record_batch_indices) {
-		auto &array = arrays[index];
-		D_ASSERT(array);
-		idx_t count;
-		count = ArrowUtil::FetchChunk(scan_state, arrow_options, batch_size, &array->arrow_array);
-		(void)count;
-		D_ASSERT(count != 0);
-	}
-}
-
-TaskExecutionResult ArrowBatchTask::ExecuteTask(TaskExecutionMode mode) {
-	ProduceRecordBatches();
-	event->FinishTask();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Arrow Merge Event
-//===--------------------------------------------------------------------===//
-
-ArrowMergeEvent::ArrowMergeEvent(ArrowQueryResult &result, BatchedDataCollection &batches, Pipeline &pipeline_p)
-    : BasePipelineEvent(pipeline_p), result(result), batches(batches) {
-	record_batch_size = result.BatchSize();
-}
-
-namespace {
-
-struct BatchesForTask {
-	idx_t tuple_count;
-	BatchedChunkIteratorRange batches;
-};
-
-struct BatchesToTaskTransformer {
-public:
-	explicit BatchesToTaskTransformer(BatchedDataCollection &batches) : batches(batches), batch_index(0) {
-		batch_count = batches.BatchCount();
-	}
-	idx_t GetIndex() const {
-		return batch_index;
-	}
-	bool TryGetNextBatchSize(idx_t &tuple_count) {
-		if (batch_index >= batch_count) {
-			return false;
-		}
-		auto internal_index = batches.IndexToBatchIndex(batch_index++);
-		auto tuples_in_batch = batches.BatchSize(internal_index);
-		tuple_count = tuples_in_batch;
-		return true;
-	}
-
-public:
-	BatchedDataCollection &batches;
-	idx_t batch_index;
-	idx_t batch_count;
-};
-
-} // namespace
-
-void ArrowMergeEvent::Schedule() {
-	vector<shared_ptr<Task>> tasks;
-
-	BatchesToTaskTransformer transformer(batches);
-	vector<BatchesForTask> task_data;
-	bool finished = false;
-	// First we convert our list of batches into units of Storage::ROW_GROUP_SIZE tuples each
-	while (!finished) {
-		idx_t tuples_for_task = 0;
-		idx_t start_index = transformer.GetIndex();
-		idx_t end_index = start_index;
-		while (tuples_for_task < DEFAULT_ROW_GROUP_SIZE) {
-			idx_t batch_size;
-			if (!transformer.TryGetNextBatchSize(batch_size)) {
-				finished = true;
-				break;
-			}
-			end_index++;
-			tuples_for_task += batch_size;
-		}
-		if (start_index == end_index) {
-			break;
-		}
-		BatchesForTask batches_for_task;
-		batches_for_task.tuple_count = tuples_for_task;
-		batches_for_task.batches = batches.BatchRange(start_index, end_index);
-		task_data.push_back(batches_for_task);
-	}
-
-	// Now we produce tasks from these units
-	// Every task is given a scan_state created from the range of batches
-	// and a vector of indices indicating the arrays (record batches) they should populate
-	idx_t record_batch_index = 0;
-	for (auto &data : task_data) {
-		const auto tuples = data.tuple_count;
-
-		auto full_batches = tuples / record_batch_size;
-		auto remainder = tuples % record_batch_size;
-		auto total_batches = full_batches + !!remainder;
-
-		vector<idx_t> record_batch_indices(total_batches);
-		for (idx_t i = 0; i < total_batches; i++) {
-			record_batch_indices[i] = record_batch_index++;
-		}
-
-		BatchCollectionChunkScanState scan_state(batches, data.batches, pipeline->executor.context);
-		tasks.push_back(make_uniq<ArrowBatchTask>(result, std::move(record_batch_indices), pipeline->executor,
-		                                          shared_from_this(), std::move(scan_state), result.names,
-		                                          record_batch_size));
-	}
-
-	// Allocate the list of record batches inside the query result
-	{
-		vector<unique_ptr<ArrowArrayWrapper>> arrays;
-		arrays.resize(record_batch_index);
-		for (idx_t i = 0; i < record_batch_index; i++) {
-			arrays[i] = make_uniq<ArrowArrayWrapper>();
-		}
-		result.SetArrowData(std::move(arrays));
-	}
-	D_ASSERT(!tasks.empty());
-	SetTasks(std::move(tasks));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/arrow_query_result.cpp b/src/duckdb/src/common/arrow/arrow_query_result.cpp
deleted file mode 100644
index 396a99944..000000000
--- a/src/duckdb/src/common/arrow/arrow_query_result.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "duckdb/common/arrow/arrow_query_result.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/box_renderer.hpp"
-#include "duckdb/common/arrow/arrow_converter.hpp"
-
-namespace duckdb {
-
-ArrowQueryResult::ArrowQueryResult(StatementType statement_type, StatementProperties properties, vector<string> names_p,
-                                   vector<LogicalType> types_p, ClientProperties client_properties, idx_t batch_size)
-    : QueryResult(QueryResultType::ARROW_RESULT, statement_type, std::move(properties), std::move(types_p),
-                  std::move(names_p), std::move(client_properties)),
-      batch_size(batch_size) {
-}
-
-ArrowQueryResult::ArrowQueryResult(ErrorData error) : QueryResult(QueryResultType::ARROW_RESULT, std::move(error)) {
-}
-
-unique_ptr<DataChunk> ArrowQueryResult::Fetch() {
-	throw NotImplementedException("Can't 'Fetch' from ArrowQueryResult");
-}
-unique_ptr<DataChunk> ArrowQueryResult::FetchRaw() {
-	throw NotImplementedException("Can't 'FetchRaw' from ArrowQueryResult");
-}
-
-string ArrowQueryResult::ToString() {
-	// FIXME: can't throw an exception here as it's used for verification
-	return "";
-}
-
-vector<unique_ptr<ArrowArrayWrapper>> ArrowQueryResult::ConsumeArrays() {
-	if (HasError()) {
-		throw InvalidInputException("Attempting to fetch ArrowArrays from an unsuccessful query result\n: Error %s",
-		                            GetError());
-	}
-	return std::move(arrays);
-}
-
-vector<unique_ptr<ArrowArrayWrapper>> &ArrowQueryResult::Arrays() {
-	if (HasError()) {
-		throw InvalidInputException("Attempting to fetch ArrowArrays from an unsuccessful query result\n: Error %s",
-		                            GetError());
-	}
-	return arrays;
-}
-
-void ArrowQueryResult::SetArrowData(vector<unique_ptr<ArrowArrayWrapper>> arrays) {
-	D_ASSERT(this->arrays.empty());
-	this->arrays = std::move(arrays);
-}
-
-idx_t ArrowQueryResult::BatchSize() const {
-	return batch_size;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/arrow_util.cpp b/src/duckdb/src/common/arrow/arrow_util.cpp
deleted file mode 100644
index 423a6dd2c..000000000
--- a/src/duckdb/src/common/arrow/arrow_util.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "duckdb/common/arrow/arrow_util.hpp"
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-
-namespace duckdb {
-
-bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t batch_size, ArrowArray *out,
-                              idx_t &count, ErrorData &error) {
-	count = 0;
-	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options));
-	auto remaining_tuples_in_chunk = scan_state.RemainingInChunk();
-	if (remaining_tuples_in_chunk) {
-		// We start by scanning the non-finished current chunk
-		idx_t cur_consumption = MinValue(remaining_tuples_in_chunk, batch_size);
-		count += cur_consumption;
-		auto &current_chunk = scan_state.CurrentChunk();
-		appender.Append(current_chunk, scan_state.CurrentOffset(), scan_state.CurrentOffset() + cur_consumption,
-		                current_chunk.size());
-		scan_state.IncreaseOffset(cur_consumption);
-	}
-	while (count < batch_size) {
-		if (!scan_state.LoadNextChunk(error)) {
-			if (scan_state.HasError()) {
-				error = scan_state.GetError();
-			}
-			return false;
-		}
-		if (scan_state.ChunkIsEmpty()) {
-			// The scan was successful, but an empty chunk was returned
-			break;
-		}
-		auto &current_chunk = scan_state.CurrentChunk();
-		if (scan_state.Finished() || current_chunk.size() == 0) {
-			break;
-		}
-		// The amount we still need to append into this chunk
-		auto remaining = batch_size - count;
-
-		// The amount remaining, capped by the amount left in the current chunk
-		auto to_append_to_batch = MinValue(remaining, scan_state.RemainingInChunk());
-		appender.Append(current_chunk, 0, to_append_to_batch, current_chunk.size());
-		count += to_append_to_batch;
-		scan_state.IncreaseOffset(to_append_to_batch);
-	}
-	if (count > 0) {
-		*out = appender.Finalize();
-	}
-	return true;
-}
-
-idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out) {
-	ErrorData error;
-	idx_t result_count;
-	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) {
-		error.Throw();
-	}
-	return result_count;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/arrow_wrapper.cpp b/src/duckdb/src/common/arrow/arrow_wrapper.cpp
deleted file mode 100644
index 2d17076f4..000000000
--- a/src/duckdb/src/common/arrow/arrow_wrapper.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/arrow/arrow_util.hpp"
-#include "duckdb/common/arrow/arrow_converter.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/main/stream_query_result.hpp"
-
-#include "duckdb/common/arrow/result_arrow_wrapper.hpp"
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/chunk_scan_state/query_result.hpp"
-
-namespace duckdb {
-
-ArrowSchemaWrapper::~ArrowSchemaWrapper() {
-	if (arrow_schema.release) {
-		arrow_schema.release(&arrow_schema);
-		D_ASSERT(!arrow_schema.release);
-	}
-}
-
-ArrowArrayWrapper::~ArrowArrayWrapper() {
-	if (arrow_array.release) {
-		arrow_array.release(&arrow_array);
-		D_ASSERT(!arrow_array.release);
-	}
-}
-
-ArrowArrayStreamWrapper::~ArrowArrayStreamWrapper() {
-	if (arrow_array_stream.release) {
-		arrow_array_stream.release(&arrow_array_stream);
-		D_ASSERT(!arrow_array_stream.release);
-	}
-}
-
-void ArrowArrayStreamWrapper::GetSchema(ArrowSchemaWrapper &schema) {
-	D_ASSERT(arrow_array_stream.get_schema);
-	// LCOV_EXCL_START
-	if (arrow_array_stream.get_schema(&arrow_array_stream, &schema.arrow_schema)) {
-		throw InvalidInputException("arrow_scan: get_schema failed(): %s", string(GetError()));
-	}
-	if (!schema.arrow_schema.release) {
-		throw InvalidInputException("arrow_scan: released schema passed");
-	}
-	if (schema.arrow_schema.n_children < 1) {
-		throw InvalidInputException("arrow_scan: empty schema passed");
-	}
-	// LCOV_EXCL_STOP
-}
-
-shared_ptr<ArrowArrayWrapper> ArrowArrayStreamWrapper::GetNextChunk() {
-	auto current_chunk = make_shared_ptr<ArrowArrayWrapper>();
-	if (arrow_array_stream.get_next(&arrow_array_stream, &current_chunk->arrow_array)) { // LCOV_EXCL_START
-		throw InvalidInputException("arrow_scan: get_next failed(): %s", string(GetError()));
-	} // LCOV_EXCL_STOP
-
-	return current_chunk;
-}
-
-const char *ArrowArrayStreamWrapper::GetError() { // LCOV_EXCL_START
-	return arrow_array_stream.get_last_error(&arrow_array_stream);
-} // LCOV_EXCL_STOP
-
-int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out) {
-	if (!stream->release) {
-		return -1;
-	}
-	out->release = nullptr;
-	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
-	if (!my_stream->column_types.empty()) {
-		try {
-			ArrowConverter::ToArrowSchema(out, my_stream->column_types, my_stream->column_names,
-			                              my_stream->result->client_properties);
-		} catch (std::runtime_error &e) {
-			my_stream->last_error = ErrorData(e);
-			return -1;
-		}
-		return 0;
-	}
-
-	auto &result = *my_stream->result;
-	if (result.HasError()) {
-		my_stream->last_error = result.GetErrorObject();
-		return -1;
-	}
-	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = result.Cast<StreamQueryResult>();
-		if (!stream_result.IsOpen()) {
-			my_stream->last_error = ErrorData("Query Stream is closed");
-			return -1;
-		}
-	}
-	if (my_stream->column_types.empty()) {
-		my_stream->column_types = result.types;
-		my_stream->column_names = result.names;
-	}
-	try {
-		ArrowConverter::ToArrowSchema(out, my_stream->column_types, my_stream->column_names,
-		                              my_stream->result->client_properties);
-	} catch (std::runtime_error &e) {
-		my_stream->last_error = ErrorData(e);
-		return -1;
-	}
-	return 0;
-}
-
-int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out) {
-	if (!stream->release) {
-		return -1;
-	}
-	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
-	auto &result = *my_stream->result;
-	auto &scan_state = *my_stream->scan_state;
-	if (result.HasError()) {
-		my_stream->last_error = result.GetErrorObject();
-		return -1;
-	}
-	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = result.Cast<StreamQueryResult>();
-		if (!stream_result.IsOpen()) {
-			// Nothing to output
-			out->release = nullptr;
-			return 0;
-		}
-	}
-	if (my_stream->column_types.empty()) {
-		my_stream->column_types = result.types;
-		my_stream->column_names = result.names;
-	}
-	idx_t result_count;
-	ErrorData error;
-	if (!ArrowUtil::TryFetchChunk(scan_state, result.client_properties, my_stream->batch_size, out, result_count,
-	                              error)) {
-		D_ASSERT(error.HasError());
-		my_stream->last_error = error;
-		return -1;
-	}
-	if (result_count == 0) {
-		// Nothing to output
-		out->release = nullptr;
-	}
-	return 0;
-}
-
-void ResultArrowArrayStreamWrapper::MyStreamRelease(struct ArrowArrayStream *stream) {
-	if (!stream || !stream->release) {
-		return;
-	}
-	stream->release = nullptr;
-	delete reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
-}
-
-const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArrayStream *stream) {
-	if (!stream->release) {
-		return "stream was released";
-	}
-	D_ASSERT(stream->private_data);
-	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
-	return my_stream->last_error.Message().c_str();
-}
-
-ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result_p, idx_t batch_size_p)
-    : result(std::move(result_p)), scan_state(make_uniq<QueryResultChunkScanState>(*result)) {
-	//! We first initialize the private data of the stream
-	stream.private_data = this;
-	//! Ceil Approx_Batch_Size/STANDARD_VECTOR_SIZE
-	if (batch_size_p == 0) {
-		throw std::runtime_error("Approximate Batch Size of Record Batch MUST be higher than 0");
-	}
-	batch_size = batch_size_p;
-	//! We initialize the stream functions
-	stream.get_schema = ResultArrowArrayStreamWrapper::MyStreamGetSchema;
-	stream.get_next = ResultArrowArrayStreamWrapper::MyStreamGetNext;
-	stream.release = ResultArrowArrayStreamWrapper::MyStreamRelease;
-	stream.get_last_error = ResultArrowArrayStreamWrapper::MyStreamGetLastError;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/physical_arrow_batch_collector.cpp b/src/duckdb/src/common/arrow/physical_arrow_batch_collector.cpp
deleted file mode 100644
index 11406c540..000000000
--- a/src/duckdb/src/common/arrow/physical_arrow_batch_collector.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/common/arrow/physical_arrow_batch_collector.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/common/arrow/arrow_query_result.hpp"
-#include "duckdb/common/arrow/arrow_merge_event.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/arrow/physical_arrow_collector.hpp"
-
-namespace duckdb {
-
-unique_ptr<GlobalSinkState> PhysicalArrowBatchCollector::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<ArrowBatchGlobalState>(context, *this);
-}
-
-SinkFinalizeType PhysicalArrowBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                       OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<ArrowBatchGlobalState>();
-
-	auto total_tuple_count = gstate.data.Count();
-	if (total_tuple_count == 0) {
-		// Create the result containing a single empty result conversion
-		gstate.result = make_uniq<ArrowQueryResult>(statement_type, properties, names, types,
-		                                            context.GetClientProperties(), record_batch_size);
-		return SinkFinalizeType::READY;
-	}
-
-	// Already create the final query result
-	gstate.result = make_uniq<ArrowQueryResult>(statement_type, properties, names, types, context.GetClientProperties(),
-	                                            record_batch_size);
-	// Spawn an event that will populate the conversion result
-	auto &arrow_result = gstate.result->Cast<ArrowQueryResult>();
-	auto new_event = make_shared_ptr<ArrowMergeEvent>(arrow_result, gstate.data, pipeline);
-	event.InsertEvent(std::move(new_event));
-
-	return SinkFinalizeType::READY;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/physical_arrow_collector.cpp b/src/duckdb/src/common/arrow/physical_arrow_collector.cpp
deleted file mode 100644
index d82246b4c..000000000
--- a/src/duckdb/src/common/arrow/physical_arrow_collector.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/arrow/physical_arrow_collector.hpp"
-#include "duckdb/common/arrow/physical_arrow_batch_collector.hpp"
-#include "duckdb/common/arrow/arrow_query_result.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalResultCollector> PhysicalArrowCollector::Create(ClientContext &context, PreparedStatementData &data,
-                                                                   idx_t batch_size) {
-	if (!PhysicalPlanGenerator::PreserveInsertionOrder(context, *data.plan)) {
-		// the plan is not order preserving, so we just use the parallel materialized collector
-		return make_uniq_base<PhysicalResultCollector, PhysicalArrowCollector>(data, true, batch_size);
-	} else if (!PhysicalPlanGenerator::UseBatchIndex(context, *data.plan)) {
-		// the plan is order preserving, but we cannot use the batch index: use a single-threaded result collector
-		return make_uniq_base<PhysicalResultCollector, PhysicalArrowCollector>(data, false, batch_size);
-	} else {
-		return make_uniq_base<PhysicalResultCollector, PhysicalArrowBatchCollector>(data, batch_size);
-	}
-}
-
-SinkResultType PhysicalArrowCollector::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<ArrowCollectorLocalState>();
-	// Append to the appender, up to chunk size
-
-	auto count = chunk.size();
-	auto &appender = lstate.appender;
-	D_ASSERT(count != 0);
-
-	idx_t processed = 0;
-	do {
-		if (!appender) {
-			// Create the appender if we haven't started this chunk yet
-			auto properties = context.client.GetClientProperties();
-			D_ASSERT(processed < count);
-			auto initial_capacity = MinValue(record_batch_size, count - processed);
-			appender = make_uniq<ArrowAppender>(types, initial_capacity, properties);
-		}
-
-		// Figure out how much we can still append to this chunk
-		auto row_count = appender->RowCount();
-		D_ASSERT(record_batch_size > row_count);
-		auto to_append = MinValue(record_batch_size - row_count, count - processed);
-
-		// Append and check if the chunk is finished
-		appender->Append(chunk, processed, processed + to_append, count);
-		processed += to_append;
-		row_count = appender->RowCount();
-		if (row_count >= record_batch_size) {
-			lstate.FinishArray();
-		}
-	} while (processed < count);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalArrowCollector::Combine(ExecutionContext &context,
-                                                      OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<ArrowCollectorGlobalState>();
-	auto &lstate = input.local_state.Cast<ArrowCollectorLocalState>();
-	auto &last_appender = lstate.appender;
-	auto &arrays = lstate.finished_arrays;
-	if (arrays.empty() && !last_appender) {
-		// Nothing to do
-		return SinkCombineResultType::FINISHED;
-	}
-	if (last_appender) {
-		// FIXME: we could set these aside and merge them in a finalize event in an effort to create more balanced
-		// chunks out of these remnants
-		lstate.FinishArray();
-	}
-	// Collect all the finished arrays
-	lock_guard<mutex> l(gstate.glock);
-	// Move the arrays from our local state into the global state
-	gstate.chunks.insert(gstate.chunks.end(), std::make_move_iterator(arrays.begin()),
-	                     std::make_move_iterator(arrays.end()));
-	arrays.clear();
-	gstate.tuple_count += lstate.tuple_count;
-	return SinkCombineResultType::FINISHED;
-}
-
-unique_ptr<QueryResult> PhysicalArrowCollector::GetResult(GlobalSinkState &state_p) {
-	auto &gstate = state_p.Cast<ArrowCollectorGlobalState>();
-	return std::move(gstate.result);
-}
-
-unique_ptr<GlobalSinkState> PhysicalArrowCollector::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<ArrowCollectorGlobalState>();
-}
-
-unique_ptr<LocalSinkState> PhysicalArrowCollector::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<ArrowCollectorLocalState>();
-}
-
-SinkFinalizeType PhysicalArrowCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<ArrowCollectorGlobalState>();
-
-	if (gstate.chunks.empty()) {
-		if (gstate.tuple_count != 0) {
-			throw InternalException(
-			    "PhysicalArrowCollector Finalize contains no chunks, but tuple_count is non-zero (%d)",
-			    gstate.tuple_count);
-		}
-		gstate.result = make_uniq<ArrowQueryResult>(statement_type, properties, names, types,
-		                                            context.GetClientProperties(), record_batch_size);
-		return SinkFinalizeType::READY;
-	}
-
-	gstate.result = make_uniq<ArrowQueryResult>(statement_type, properties, names, types, context.GetClientProperties(),
-	                                            record_batch_size);
-	auto &arrow_result = gstate.result->Cast<ArrowQueryResult>();
-	arrow_result.SetArrowData(std::move(gstate.chunks));
-
-	return SinkFinalizeType::READY;
-}
-
-bool PhysicalArrowCollector::ParallelSink() const {
-	return parallel;
-}
-
-bool PhysicalArrowCollector::SinkOrderDependent() const {
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/arrow/schema_metadata.cpp b/src/duckdb/src/common/arrow/schema_metadata.cpp
deleted file mode 100644
index 836f89f2c..000000000
--- a/src/duckdb/src/common/arrow/schema_metadata.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "duckdb/common/arrow/schema_metadata.hpp"
-
-namespace duckdb {
-
-ArrowSchemaMetadata::ArrowSchemaMetadata(const char *metadata) {
-	if (metadata) {
-		// Read the number of key-value pairs (int32)
-		int32_t num_pairs;
-		memcpy(&num_pairs, metadata, sizeof(int32_t));
-		metadata += sizeof(int32_t);
-
-		// Loop through each key-value pair
-		for (int32_t i = 0; i < num_pairs; ++i) {
-			// Read the length of the key (int32)
-			int32_t key_length;
-			memcpy(&key_length, metadata, sizeof(int32_t));
-			metadata += sizeof(int32_t);
-
-			// Read the key
-			std::string key(metadata, static_cast<idx_t>(key_length));
-			metadata += key_length;
-
-			// Read the length of the value (int32)
-			int32_t value_length;
-			memcpy(&value_length, metadata, sizeof(int32_t));
-			metadata += sizeof(int32_t);
-
-			// Read the value
-			const std::string value(metadata, static_cast<idx_t>(value_length));
-			metadata += value_length;
-			schema_metadata_map[key] = value;
-		}
-	}
-	extension_metadata_map = StringUtil::ParseJSONMap(schema_metadata_map[ARROW_METADATA_KEY]);
-}
-
-void ArrowSchemaMetadata::AddOption(const string &key, const string &value) {
-	schema_metadata_map[key] = value;
-}
-string ArrowSchemaMetadata::GetOption(const string &key) const {
-	auto it = schema_metadata_map.find(key);
-	if (it != schema_metadata_map.end()) {
-		return it->second;
-	} else {
-		return "";
-	}
-}
-
-string ArrowSchemaMetadata::GetExtensionName() const {
-	return GetOption(ARROW_EXTENSION_NAME);
-}
-
-ArrowSchemaMetadata ArrowSchemaMetadata::ArrowCanonicalType(const string &extension_name) {
-	ArrowSchemaMetadata metadata;
-	metadata.AddOption(ARROW_EXTENSION_NAME, extension_name);
-	metadata.AddOption(ARROW_METADATA_KEY, "");
-	return metadata;
-}
-
-ArrowSchemaMetadata ArrowSchemaMetadata::DuckDBInternalType(const string &type_name) {
-	ArrowSchemaMetadata metadata;
-	metadata.AddOption(ARROW_EXTENSION_NAME, ARROW_EXTENSION_NON_CANONICAL);
-	// We have to set the metadata key with type_name and vendor_name.
-	metadata.extension_metadata_map["vendor_name"] = "DuckDB";
-	metadata.extension_metadata_map["type_name"] = type_name;
-	metadata.AddOption(ARROW_METADATA_KEY, StringUtil::ToJSONMap(metadata.extension_metadata_map));
-	return metadata;
-}
-
-bool ArrowSchemaMetadata::IsNonCanonicalType(const string &type, const string &vendor) const {
-	if (schema_metadata_map.find(ARROW_EXTENSION_NAME) == schema_metadata_map.end()) {
-		return false;
-	}
-	if (schema_metadata_map.find(ARROW_EXTENSION_NAME)->second != ARROW_EXTENSION_NON_CANONICAL) {
-		return false;
-	}
-	if (extension_metadata_map.find("type_name") == extension_metadata_map.end() ||
-	    extension_metadata_map.find("vendor_name") == extension_metadata_map.end()) {
-		return false;
-	}
-	auto vendor_name = extension_metadata_map.find("vendor_name")->second;
-	auto type_name = extension_metadata_map.find("type_name")->second;
-	return vendor_name == vendor && type_name == type;
-}
-
-bool ArrowSchemaMetadata::HasExtension() const {
-	auto arrow_extension = GetOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME);
-	// FIXME: We are currently ignoring the ogc extensions
-	return !arrow_extension.empty() && !StringUtil::StartsWith(arrow_extension, "ogc");
-}
-
-unsafe_unique_array<char> ArrowSchemaMetadata::SerializeMetadata() const {
-	// First we have to figure out the total size:
-	// 1. number of key-value pairs (int32)
-	idx_t total_size = sizeof(int32_t);
-	for (const auto &option : schema_metadata_map) {
-		// 2. Length of the key and value (2 * int32)
-		total_size += 2 * sizeof(int32_t);
-		// 3. Length of key
-		total_size += option.first.size();
-		// 4. Length of value
-		total_size += option.second.size();
-	}
-	auto metadata_array_ptr = make_unsafe_uniq_array<char>(total_size);
-	auto metadata_ptr = metadata_array_ptr.get();
-	// 1. number of key-value pairs (int32)
-	const idx_t map_size = schema_metadata_map.size();
-	memcpy(metadata_ptr, &map_size, sizeof(int32_t));
-	metadata_ptr += sizeof(int32_t);
-	// Iterate through each key-value pair in the map
-	for (const auto &pair : schema_metadata_map) {
-		const std::string &key = pair.first;
-		idx_t key_size = key.size();
-		// Length of the key (int32)
-		memcpy(metadata_ptr, &key_size, sizeof(int32_t));
-		metadata_ptr += sizeof(int32_t);
-		// Key
-		memcpy(metadata_ptr, key.c_str(), key_size);
-		metadata_ptr += key_size;
-		const std::string &value = pair.second;
-		const idx_t value_size = value.size();
-		// Length of the value (int32)
-		memcpy(metadata_ptr, &value_size, sizeof(int32_t));
-		metadata_ptr += sizeof(int32_t);
-		// Value
-		memcpy(metadata_ptr, value.c_str(), value_size);
-		metadata_ptr += value_size;
-	}
-	return metadata_array_ptr;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/common/assert.cpp b/src/duckdb/src/common/assert.cpp
deleted file mode 100644
index 02f62212e..000000000
--- a/src/duckdb/src/common/assert.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr) {
-#ifdef DISABLE_ASSERTIONS
-	return;
-#endif
-	if (condition) {
-		return;
-	}
-	throw InternalException("Assertion triggered in file \"%s\" on line %d: %s", file, linenr, condition_name);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/bind_helpers.cpp b/src/duckdb/src/common/bind_helpers.cpp
deleted file mode 100644
index b618b797b..000000000
--- a/src/duckdb/src/common/bind_helpers.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#include "duckdb/common/bind_helpers.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include <numeric>
-
-namespace duckdb {
-
-Value ConvertVectorToValue(vector<Value> set) {
-	if (set.empty()) {
-		return Value::LIST(LogicalType::BOOLEAN, std::move(set));
-	}
-	return Value::LIST(std::move(set));
-}
-
-vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &loption) {
-	vector<bool> result;
-
-	if (set.empty()) {
-		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
-	}
-	// list of options: parse the list
-	case_insensitive_map_t<bool> option_map;
-	for (idx_t i = 0; i < set.size(); i++) {
-		option_map[set[i].ToString()] = false;
-	}
-	result.resize(names.size(), false);
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto entry = option_map.find(names[i]);
-		if (entry != option_map.end()) {
-			result[i] = true;
-			entry->second = true;
-		}
-	}
-	for (auto &entry : option_map) {
-		if (!entry.second) {
-			throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
-			                      entry.first.c_str());
-		}
-	}
-	return result;
-}
-
-vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &loption) {
-	vector<bool> result;
-
-	// Only accept a list of arguments
-	if (value.type().id() != LogicalTypeId::LIST) {
-		// Support a single argument if it's '*'
-		if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
-			result.resize(names.size(), true);
-			return result;
-		}
-		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
-	}
-	auto &children = ListValue::GetChildren(value);
-	// accept '*' as single argument
-	if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
-	    children[0].GetValue<string>() == "*") {
-		result.resize(names.size(), true);
-		return result;
-	}
-	return ParseColumnList(children, names, loption);
-}
-
-vector<idx_t> ParseColumnsOrdered(const vector<Value> &set, vector<string> &names, const string &loption) {
-	vector<idx_t> result;
-
-	if (set.empty()) {
-		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
-	}
-
-	// Maps option to bool indicating if its found and the index in the original set
-	case_insensitive_map_t<std::pair<bool, idx_t>> option_map;
-	for (idx_t i = 0; i < set.size(); i++) {
-		option_map[set[i].ToString()] = {false, i};
-	}
-	result.resize(option_map.size());
-
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto entry = option_map.find(names[i]);
-		if (entry != option_map.end()) {
-			result[entry->second.second] = i;
-			entry->second.first = true;
-		}
-	}
-	for (auto &entry : option_map) {
-		if (!entry.second.first) {
-			throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
-			                      entry.first.c_str());
-		}
-	}
-	return result;
-}
-
-vector<idx_t> ParseColumnsOrdered(const Value &value, vector<string> &names, const string &loption) {
-	vector<idx_t> result;
-
-	// Only accept a list of arguments
-	if (value.type().id() != LogicalTypeId::LIST) {
-		// Support a single argument if it's '*'
-		if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
-			result.resize(names.size(), 0);
-			std::iota(std::begin(result), std::end(result), 0);
-			return result;
-		}
-		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
-	}
-	auto &children = ListValue::GetChildren(value);
-	// accept '*' as single argument
-	if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
-	    children[0].GetValue<string>() == "*") {
-		result.resize(names.size(), 0);
-		std::iota(std::begin(result), std::end(result), 0);
-		return result;
-	}
-	return ParseColumnsOrdered(children, names, loption);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/box_renderer.cpp b/src/duckdb/src/common/box_renderer.cpp
deleted file mode 100644
index f85cf622d..000000000
--- a/src/duckdb/src/common/box_renderer.cpp
+++ /dev/null
@@ -1,1092 +0,0 @@
-#include "duckdb/common/box_renderer.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-const idx_t BoxRenderer::SPLIT_COLUMN = idx_t(-1);
-
-//===--------------------------------------------------------------------===//
-// Result Renderer
-//===--------------------------------------------------------------------===//
-BaseResultRenderer::BaseResultRenderer() : value_type(LogicalTypeId::INVALID) {
-}
-
-BaseResultRenderer::~BaseResultRenderer() {
-}
-
-BaseResultRenderer &BaseResultRenderer::operator<<(char c) {
-	RenderLayout(string(1, c));
-	return *this;
-}
-
-BaseResultRenderer &BaseResultRenderer::operator<<(const string &val) {
-	RenderLayout(val);
-	return *this;
-}
-
-void BaseResultRenderer::Render(ResultRenderType render_mode, const string &val) {
-	switch (render_mode) {
-	case ResultRenderType::LAYOUT:
-		RenderLayout(val);
-		break;
-	case ResultRenderType::COLUMN_NAME:
-		RenderColumnName(val);
-		break;
-	case ResultRenderType::COLUMN_TYPE:
-		RenderType(val);
-		break;
-	case ResultRenderType::VALUE:
-		RenderValue(val, value_type);
-		break;
-	case ResultRenderType::NULL_VALUE:
-		RenderNull(val, value_type);
-		break;
-	case ResultRenderType::FOOTER:
-		RenderFooter(val);
-		break;
-	default:
-		throw InternalException("Unsupported type for result renderer");
-	}
-}
-
-void BaseResultRenderer::SetValueType(const LogicalType &type) {
-	value_type = type;
-}
-
-void StringResultRenderer::RenderLayout(const string &text) {
-	result += text;
-}
-
-void StringResultRenderer::RenderColumnName(const string &text) {
-	result += text;
-}
-
-void StringResultRenderer::RenderType(const string &text) {
-	result += text;
-}
-
-void StringResultRenderer::RenderValue(const string &text, const LogicalType &type) {
-	result += text;
-}
-
-void StringResultRenderer::RenderNull(const string &text, const LogicalType &type) {
-	result += text;
-}
-
-void StringResultRenderer::RenderFooter(const string &text) {
-	result += text;
-}
-
-const string &StringResultRenderer::str() {
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Box Renderer
-//===--------------------------------------------------------------------===//
-BoxRenderer::BoxRenderer(BoxRendererConfig config_p) : config(std::move(config_p)) {
-}
-
-string BoxRenderer::ToString(ClientContext &context, const vector<string> &names, const ColumnDataCollection &result) {
-	StringResultRenderer ss;
-	Render(context, names, result, ss);
-	return ss.str();
-}
-
-void BoxRenderer::Print(ClientContext &context, const vector<string> &names, const ColumnDataCollection &result) {
-	Printer::Print(ToString(context, names, result));
-}
-
-void BoxRenderer::RenderValue(BaseResultRenderer &ss, const string &value, idx_t column_width,
-                              ResultRenderType render_mode, ValueRenderAlignment alignment) {
-	auto render_width = Utf8Proc::RenderWidth(value);
-
-	const string *render_value = &value;
-	string small_value;
-	if (render_width > column_width) {
-		// the string is too large to fit in this column!
-		// the size of this column must have been reduced
-		// figure out how much of this value we can render
-		idx_t pos = 0;
-		idx_t current_render_width = config.DOTDOTDOT_LENGTH;
-		while (pos < value.size()) {
-			// check if this character fits...
-			auto char_size = Utf8Proc::RenderWidth(value.c_str(), value.size(), pos);
-			if (current_render_width + char_size >= column_width) {
-				// it doesn't! stop
-				break;
-			}
-			// it does! move to the next character
-			current_render_width += char_size;
-			pos = Utf8Proc::NextGraphemeCluster(value.c_str(), value.size(), pos);
-		}
-		small_value = value.substr(0, pos) + config.DOTDOTDOT;
-		render_value = &small_value;
-		render_width = current_render_width;
-	}
-	auto padding_count = (column_width - render_width) + 2;
-	idx_t lpadding;
-	idx_t rpadding;
-	switch (alignment) {
-	case ValueRenderAlignment::LEFT:
-		lpadding = 1;
-		rpadding = padding_count - 1;
-		break;
-	case ValueRenderAlignment::MIDDLE:
-		lpadding = padding_count / 2;
-		rpadding = padding_count - lpadding;
-		break;
-	case ValueRenderAlignment::RIGHT:
-		lpadding = padding_count - 1;
-		rpadding = 1;
-		break;
-	default:
-		throw InternalException("Unrecognized value renderer alignment");
-	}
-	ss << config.VERTICAL;
-	ss << string(lpadding, ' ');
-	ss.Render(render_mode, *render_value);
-	ss << string(rpadding, ' ');
-}
-
-string BoxRenderer::RenderType(const LogicalType &type) {
-	if (type.HasAlias()) {
-		return StringUtil::Lower(type.ToString());
-	}
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return "int8";
-	case LogicalTypeId::SMALLINT:
-		return "int16";
-	case LogicalTypeId::INTEGER:
-		return "int32";
-	case LogicalTypeId::BIGINT:
-		return "int64";
-	case LogicalTypeId::HUGEINT:
-		return "int128";
-	case LogicalTypeId::UTINYINT:
-		return "uint8";
-	case LogicalTypeId::USMALLINT:
-		return "uint16";
-	case LogicalTypeId::UINTEGER:
-		return "uint32";
-	case LogicalTypeId::UBIGINT:
-		return "uint64";
-	case LogicalTypeId::UHUGEINT:
-		return "uint128";
-	case LogicalTypeId::LIST: {
-		auto child = RenderType(ListType::GetChildType(type));
-		return child + "[]";
-	}
-	default:
-		return StringUtil::Lower(type.ToString());
-	}
-}
-
-ValueRenderAlignment BoxRenderer::TypeAlignment(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-		return ValueRenderAlignment::RIGHT;
-	default:
-		return ValueRenderAlignment::LEFT;
-	}
-}
-
-string BoxRenderer::TryFormatLargeNumber(const string &numeric) {
-	// we only return a readable rendering if the number is > 1 million
-	if (numeric.size() <= 5) {
-		// number too small for sure
-		return string();
-	}
-	// get the number to summarize
-	idx_t number = 0;
-	bool negative = false;
-	idx_t i = 0;
-	if (numeric[0] == '-') {
-		negative = true;
-		i++;
-	}
-	for (; i < numeric.size(); i++) {
-		char c = numeric[i];
-		if (c == '.') {
-			break;
-		}
-		if (c < '0' || c > '9') {
-			// not a number or something funky (e.g. 1.23e7)
-			// we could theoretically summarize numbers with exponents
-			return string();
-		}
-		if (number >= 1000000000000000000ULL) {
-			// number too big
-			return string();
-		}
-		number = number * 10 + static_cast<idx_t>(c - '0');
-	}
-	struct UnitBase {
-		idx_t base;
-		const char *name;
-	};
-	static constexpr idx_t BASE_COUNT = 5;
-	UnitBase bases[] = {{1000000ULL, "million"},
-	                    {1000000000ULL, "billion"},
-	                    {1000000000000ULL, "trillion"},
-	                    {1000000000000000ULL, "quadrillion"},
-	                    {1000000000000000000ULL, "quintillion"}};
-	idx_t base = 0;
-	string unit;
-	for (idx_t i = 0; i < BASE_COUNT; i++) {
-		// round the number according to this base
-		idx_t rounded_number = number + ((bases[i].base / 100ULL) / 2);
-		if (rounded_number >= bases[i].base) {
-			base = bases[i].base;
-			unit = bases[i].name;
-		}
-	}
-	if (unit.empty()) {
-		return string();
-	}
-	number += (base / 100ULL) / 2;
-	idx_t decimal_unit = number / (base / 100ULL);
-	string decimal_str = to_string(decimal_unit);
-	string result;
-	if (negative) {
-		result += "-";
-	}
-	result += decimal_str.substr(0, decimal_str.size() - 2);
-	result += config.decimal_separator == '\0' ? '.' : config.decimal_separator;
-	result += decimal_str.substr(decimal_str.size() - 2, 2);
-	result += " ";
-	result += unit;
-	return result;
-}
-
-list<ColumnDataCollection> BoxRenderer::FetchRenderCollections(ClientContext &context,
-                                                               const ColumnDataCollection &result, idx_t top_rows,
-                                                               idx_t bottom_rows) {
-	auto column_count = result.ColumnCount();
-	vector<LogicalType> varchar_types;
-	for (idx_t c = 0; c < column_count; c++) {
-		varchar_types.emplace_back(LogicalType::VARCHAR);
-	}
-	std::list<ColumnDataCollection> collections;
-	collections.emplace_back(context, varchar_types);
-	collections.emplace_back(context, varchar_types);
-
-	auto &top_collection = collections.front();
-	auto &bottom_collection = collections.back();
-
-	DataChunk fetch_result;
-	fetch_result.Initialize(context, result.Types());
-
-	DataChunk insert_result;
-	insert_result.Initialize(context, varchar_types);
-
-	if (config.large_number_rendering == LargeNumberRendering::FOOTER) {
-		if (config.render_mode != RenderMode::ROWS || result.Count() != 1) {
-			// large number footer can only be constructed (1) if we have a single row, and (2) in ROWS mode
-			config.large_number_rendering = LargeNumberRendering::NONE;
-		}
-	}
-
-	// fetch the top rows from the ColumnDataCollection
-	idx_t chunk_idx = 0;
-	idx_t row_idx = 0;
-	while (row_idx < top_rows) {
-		fetch_result.Reset();
-		insert_result.Reset();
-		// fetch the next chunk
-		result.FetchChunk(chunk_idx, fetch_result);
-		idx_t insert_count = MinValue<idx_t>(fetch_result.size(), top_rows - row_idx);
-
-		// cast all columns to varchar
-		for (idx_t c = 0; c < column_count; c++) {
-			VectorOperations::Cast(context, fetch_result.data[c], insert_result.data[c], insert_count);
-		}
-		insert_result.SetCardinality(insert_count);
-
-		// construct the render collection
-		top_collection.Append(insert_result);
-
-		// if we have are constructing a footer
-		if (config.large_number_rendering == LargeNumberRendering::FOOTER) {
-			D_ASSERT(insert_count == 1);
-			vector<string> readable_numbers;
-			readable_numbers.resize(column_count);
-			bool all_readable = true;
-			for (idx_t c = 0; c < column_count; c++) {
-				if (!result.Types()[c].IsNumeric()) {
-					// not a numeric type - cannot summarize
-					all_readable = false;
-					break;
-				}
-				// add a readable rendering of the value (i.e. "1234567" becomes "1.23 million")
-				// we only add the rendering if the string is big
-				auto numeric_val = insert_result.data[c].GetValue(0).ToString();
-				readable_numbers[c] = TryFormatLargeNumber(numeric_val);
-				if (readable_numbers[c].empty()) {
-					all_readable = false;
-					break;
-				}
-				readable_numbers[c] = "(" + readable_numbers[c] + ")";
-			}
-			insert_result.Reset();
-			if (all_readable) {
-				for (idx_t c = 0; c < column_count; c++) {
-					insert_result.data[c].SetValue(0, Value(readable_numbers[c]));
-				}
-				insert_result.SetCardinality(1);
-				top_collection.Append(insert_result);
-			}
-		}
-
-		chunk_idx++;
-		row_idx += fetch_result.size();
-	}
-
-	// fetch the bottom rows from the ColumnDataCollection
-	row_idx = 0;
-	chunk_idx = result.ChunkCount() - 1;
-	while (row_idx < bottom_rows) {
-		fetch_result.Reset();
-		insert_result.Reset();
-		// fetch the next chunk
-		result.FetchChunk(chunk_idx, fetch_result);
-		idx_t insert_count = MinValue<idx_t>(fetch_result.size(), bottom_rows - row_idx);
-
-		// invert the rows
-		SelectionVector inverted_sel(insert_count);
-		for (idx_t r = 0; r < insert_count; r++) {
-			inverted_sel.set_index(r, fetch_result.size() - r - 1);
-		}
-
-		for (idx_t c = 0; c < column_count; c++) {
-			Vector slice(fetch_result.data[c], inverted_sel, insert_count);
-			VectorOperations::Cast(context, slice, insert_result.data[c], insert_count);
-		}
-		insert_result.SetCardinality(insert_count);
-		// construct the render collection
-		bottom_collection.Append(insert_result);
-
-		chunk_idx--;
-		row_idx += fetch_result.size();
-	}
-	return collections;
-}
-
-list<ColumnDataCollection> BoxRenderer::PivotCollections(ClientContext &context, list<ColumnDataCollection> input,
-                                                         vector<string> &column_names,
-                                                         vector<LogicalType> &result_types, idx_t row_count) {
-	auto &top = input.front();
-	auto &bottom = input.back();
-
-	vector<LogicalType> varchar_types;
-	vector<string> new_names;
-	new_names.emplace_back("Column");
-	new_names.emplace_back("Type");
-	varchar_types.emplace_back(LogicalType::VARCHAR);
-	varchar_types.emplace_back(LogicalType::VARCHAR);
-	for (idx_t r = 0; r < top.Count(); r++) {
-		new_names.emplace_back("Row " + to_string(r + 1));
-		varchar_types.emplace_back(LogicalType::VARCHAR);
-	}
-	for (idx_t r = 0; r < bottom.Count(); r++) {
-		auto row_index = row_count - bottom.Count() + r + 1;
-		new_names.emplace_back("Row " + to_string(row_index));
-		varchar_types.emplace_back(LogicalType::VARCHAR);
-	}
-	//
-	DataChunk row_chunk;
-	row_chunk.Initialize(Allocator::DefaultAllocator(), varchar_types);
-	std::list<ColumnDataCollection> result;
-	result.emplace_back(context, varchar_types);
-	result.emplace_back(context, varchar_types);
-	auto &res_coll = result.front();
-	ColumnDataAppendState append_state;
-	res_coll.InitializeAppend(append_state);
-	for (idx_t c = 0; c < top.ColumnCount(); c++) {
-		vector<column_t> column_ids {c};
-		auto row_index = row_chunk.size();
-		idx_t current_index = 0;
-		row_chunk.SetValue(current_index++, row_index, column_names[c]);
-		row_chunk.SetValue(current_index++, row_index, RenderType(result_types[c]));
-		for (auto &collection : input) {
-			for (auto &chunk : collection.Chunks(column_ids)) {
-				for (idx_t r = 0; r < chunk.size(); r++) {
-					row_chunk.SetValue(current_index++, row_index, chunk.GetValue(0, r));
-				}
-			}
-		}
-		row_chunk.SetCardinality(row_chunk.size() + 1);
-		if (row_chunk.size() == STANDARD_VECTOR_SIZE || c + 1 == top.ColumnCount()) {
-			res_coll.Append(append_state, row_chunk);
-			row_chunk.Reset();
-		}
-	}
-	column_names = std::move(new_names);
-	result_types = std::move(varchar_types);
-	return result;
-}
-
-string BoxRenderer::ConvertRenderValue(const string &input) {
-	string result;
-	result.reserve(input.size());
-	for (idx_t c = 0; c < input.size(); c++) {
-		data_t byte_value = const_data_ptr_cast(input.c_str())[c];
-		if (byte_value < 32) {
-			// ASCII control character
-			result += "\\";
-			switch (input[c]) {
-			case 7:
-				// bell
-				result += 'a';
-				break;
-			case 8:
-				// backspace
-				result += 'b';
-				break;
-			case 9:
-				// tab
-				result += 't';
-				break;
-			case 10:
-				// newline
-				result += 'n';
-				break;
-			case 11:
-				// vertical tab
-				result += 'v';
-				break;
-			case 12:
-				// form feed
-				result += 'f';
-				break;
-			case 13:
-				// cariage return
-				result += 'r';
-				break;
-			case 27:
-				// escape
-				result += 'e';
-				break;
-			default:
-				result += to_string(byte_value);
-				break;
-			}
-		} else {
-			result += input[c];
-		}
-	}
-	return result;
-}
-
-string BoxRenderer::FormatNumber(const string &input) {
-	if (config.large_number_rendering == LargeNumberRendering::ALL) {
-		// when large number rendering is set to ALL, we try to format all numbers as large numbers
-		auto number = TryFormatLargeNumber(input);
-		if (!number.empty()) {
-			return number;
-		}
-	}
-	if (config.decimal_separator == '\0' && config.thousand_separator == '\0') {
-		// no thousand separator
-		return input;
-	}
-	// first check how many digits there are (preceding any decimal point)
-	idx_t character_count = 0;
-	for (auto c : input) {
-		if (!StringUtil::CharacterIsDigit(c)) {
-			break;
-		}
-		character_count++;
-	}
-	// find the position of the first thousand separator
-	idx_t separator_position = character_count % 3 == 0 ? 3 : character_count % 3;
-	// now add the thousand separators
-	string result;
-	for (idx_t c = 0; c < character_count; c++) {
-		if (c == separator_position && config.thousand_separator != '\0') {
-			result += config.thousand_separator;
-			separator_position += 3;
-		}
-		result += input[c];
-	}
-	// add any remaining characters
-	for (idx_t c = character_count; c < input.size(); c++) {
-		if (input[c] == '.' && config.decimal_separator != '\0') {
-			result += config.decimal_separator;
-		} else {
-			result += input[c];
-		}
-	}
-	return result;
-}
-
-string BoxRenderer::ConvertRenderValue(const string &input, const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-		return FormatNumber(input);
-	default:
-		return ConvertRenderValue(input);
-	}
-}
-
-string BoxRenderer::GetRenderValue(BaseResultRenderer &ss, ColumnDataRowCollection &rows, idx_t c, idx_t r,
-                                   const LogicalType &type, ResultRenderType &render_mode) {
-	try {
-		render_mode = ResultRenderType::VALUE;
-		ss.SetValueType(type);
-		auto row = rows.GetValue(c, r);
-		if (row.IsNull()) {
-			render_mode = ResultRenderType::NULL_VALUE;
-			return config.null_value;
-		}
-		return ConvertRenderValue(StringValue::Get(row), type);
-	} catch (std::exception &ex) {
-		return "????INVALID VALUE - " + string(ex.what()) + "?????";
-	}
-}
-
-vector<idx_t> BoxRenderer::ComputeRenderWidths(const vector<string> &names, const vector<LogicalType> &result_types,
-                                               list<ColumnDataCollection> &collections, idx_t min_width,
-                                               idx_t max_width, vector<idx_t> &column_map, idx_t &total_length) {
-	auto column_count = result_types.size();
-
-	vector<idx_t> widths;
-	widths.reserve(column_count);
-	for (idx_t c = 0; c < column_count; c++) {
-		auto name_width = Utf8Proc::RenderWidth(ConvertRenderValue(names[c]));
-		auto type_width = Utf8Proc::RenderWidth(RenderType(result_types[c]));
-		widths.push_back(MaxValue<idx_t>(name_width, type_width));
-	}
-
-	// now iterate over the data in the render collection and find out the true max width
-	for (auto &collection : collections) {
-		for (auto &chunk : collection.Chunks()) {
-			for (idx_t c = 0; c < column_count; c++) {
-				auto string_data = FlatVector::GetData<string_t>(chunk.data[c]);
-				for (idx_t r = 0; r < chunk.size(); r++) {
-					string render_value;
-					if (FlatVector::IsNull(chunk.data[c], r)) {
-						render_value = config.null_value;
-					} else {
-						render_value = ConvertRenderValue(string_data[r].GetString(), result_types[c]);
-					}
-					auto render_width = Utf8Proc::RenderWidth(render_value);
-					widths[c] = MaxValue<idx_t>(render_width, widths[c]);
-				}
-			}
-		}
-	}
-
-	// figure out the total length
-	// we start off with a pipe (|)
-	total_length = 1;
-	for (idx_t c = 0; c < widths.size(); c++) {
-		// each column has a space at the beginning, and a space plus a pipe (|) at the end
-		// hence + 3
-		total_length += widths[c] + 3;
-	}
-	if (total_length < min_width) {
-		// if there are hidden rows we should always display that
-		// stretch up the first column until we have space to show the row count
-		widths[0] += min_width - total_length;
-		total_length = min_width;
-	}
-	// now we need to constrain the length
-	unordered_set<idx_t> pruned_columns;
-	if (total_length > max_width) {
-		// before we remove columns, check if we can just reduce the size of columns
-		for (auto &w : widths) {
-			if (w > config.max_col_width) {
-				auto max_diff = w - config.max_col_width;
-				if (total_length - max_diff <= max_width) {
-					// if we reduce the size of this column we fit within the limits!
-					// reduce the width exactly enough so that the box fits
-					w -= total_length - max_width;
-					total_length = max_width;
-					break;
-				} else {
-					// reducing the width of this column does not make the result fit
-					// reduce the column width by the maximum amount anyway
-					w = config.max_col_width;
-					total_length -= max_diff;
-				}
-			}
-		}
-
-		if (total_length > max_width) {
-			// the total length is still too large
-			// we need to remove columns!
-			// first, we add 6 characters to the total length
-			// this is what we need to add the "..." in the middle
-			total_length += 3 + config.DOTDOTDOT_LENGTH;
-			// now select columns to prune
-			// we select columns in zig-zag order starting from the middle
-			// e.g. if we have 10 columns, we remove #5, then #4, then #6, then #3, then #7, etc
-			int64_t offset = 0;
-			while (total_length > max_width) {
-				auto c = NumericCast<idx_t>(NumericCast<int64_t>(column_count) / 2 + offset);
-				total_length -= widths[c] + 3;
-				pruned_columns.insert(c);
-				if (offset >= 0) {
-					offset = -offset - 1;
-				} else {
-					offset = -offset;
-				}
-			}
-		}
-	}
-
-	bool added_split_column = false;
-	vector<idx_t> new_widths;
-	for (idx_t c = 0; c < column_count; c++) {
-		if (pruned_columns.find(c) == pruned_columns.end()) {
-			column_map.push_back(c);
-			new_widths.push_back(widths[c]);
-		} else {
-			if (!added_split_column) {
-				// "..."
-				column_map.push_back(SPLIT_COLUMN);
-				new_widths.push_back(config.DOTDOTDOT_LENGTH);
-				added_split_column = true;
-			}
-		}
-	}
-	return new_widths;
-}
-
-void BoxRenderer::RenderHeader(const vector<string> &names, const vector<LogicalType> &result_types,
-                               const vector<idx_t> &column_map, const vector<idx_t> &widths,
-                               const vector<idx_t> &boundaries, idx_t total_length, bool has_results,
-                               BaseResultRenderer &ss) {
-	auto column_count = column_map.size();
-	// render the top line
-	ss << config.LTCORNER;
-	idx_t column_index = 0;
-	for (idx_t k = 0; k < total_length - 2; k++) {
-		if (column_index + 1 < column_count && k == boundaries[column_index]) {
-			ss << config.TMIDDLE;
-			column_index++;
-		} else {
-			ss << config.HORIZONTAL;
-		}
-	}
-	ss << config.RTCORNER;
-	ss << '\n';
-
-	// render the header names
-	for (idx_t c = 0; c < column_count; c++) {
-		auto column_idx = column_map[c];
-		string name;
-		ResultRenderType render_mode;
-		if (column_idx == SPLIT_COLUMN) {
-			render_mode = ResultRenderType::LAYOUT;
-			name = config.DOTDOTDOT;
-		} else {
-			render_mode = ResultRenderType::COLUMN_NAME;
-			name = ConvertRenderValue(names[column_idx]);
-		}
-		RenderValue(ss, name, widths[c], render_mode);
-	}
-	ss << config.VERTICAL;
-	ss << '\n';
-
-	// render the types
-	if (config.render_mode == RenderMode::ROWS) {
-		for (idx_t c = 0; c < column_count; c++) {
-			auto column_idx = column_map[c];
-			string type;
-			ResultRenderType render_mode;
-			if (column_idx == SPLIT_COLUMN) {
-				render_mode = ResultRenderType::LAYOUT;
-			} else {
-				render_mode = ResultRenderType::COLUMN_TYPE;
-				type = RenderType(result_types[column_idx]);
-			}
-			RenderValue(ss, type, widths[c], render_mode);
-		}
-		ss << config.VERTICAL;
-		ss << '\n';
-	}
-
-	// render the line under the header
-	ss << config.LMIDDLE;
-	column_index = 0;
-	for (idx_t k = 0; k < total_length - 2; k++) {
-		if (column_index + 1 < column_count && k == boundaries[column_index]) {
-			ss << (has_results ? config.MIDDLE : config.DMIDDLE);
-			column_index++;
-		} else {
-			ss << config.HORIZONTAL;
-		}
-	}
-	ss << config.RMIDDLE;
-	ss << '\n';
-}
-
-void BoxRenderer::RenderValues(const list<ColumnDataCollection> &collections, const vector<idx_t> &column_map,
-                               const vector<idx_t> &widths, const vector<LogicalType> &result_types,
-                               BaseResultRenderer &ss) {
-	auto &top_collection = collections.front();
-	auto &bottom_collection = collections.back();
-	// render the top rows
-	auto top_rows = top_collection.Count();
-	auto bottom_rows = bottom_collection.Count();
-	auto column_count = column_map.size();
-
-	bool large_number_footer = config.large_number_rendering == LargeNumberRendering::FOOTER;
-	vector<ValueRenderAlignment> alignments;
-	if (config.render_mode == RenderMode::ROWS) {
-		for (idx_t c = 0; c < column_count; c++) {
-			auto column_idx = column_map[c];
-			if (column_idx == SPLIT_COLUMN) {
-				alignments.push_back(ValueRenderAlignment::MIDDLE);
-			} else if (large_number_footer && result_types[column_idx].IsNumeric()) {
-				alignments.push_back(ValueRenderAlignment::MIDDLE);
-			} else {
-				alignments.push_back(TypeAlignment(result_types[column_idx]));
-			}
-		}
-	}
-
-	auto rows = top_collection.GetRows();
-	for (idx_t r = 0; r < top_rows; r++) {
-		for (idx_t c = 0; c < column_count; c++) {
-			auto column_idx = column_map[c];
-			string str;
-			ResultRenderType render_mode;
-			if (column_idx == SPLIT_COLUMN) {
-				str = config.DOTDOTDOT;
-				render_mode = ResultRenderType::LAYOUT;
-			} else {
-				str = GetRenderValue(ss, rows, column_idx, r, result_types[column_idx], render_mode);
-			}
-			ValueRenderAlignment alignment;
-			if (config.render_mode == RenderMode::ROWS) {
-				alignment = alignments[c];
-				if (large_number_footer && r == 1) {
-					// render readable numbers with highlighting of a NULL value
-					render_mode = ResultRenderType::NULL_VALUE;
-				}
-			} else {
-				switch (c) {
-				case 0:
-					render_mode = ResultRenderType::COLUMN_NAME;
-					break;
-				case 1:
-					render_mode = ResultRenderType::COLUMN_TYPE;
-					break;
-				default:
-					render_mode = ResultRenderType::VALUE;
-					break;
-				}
-				if (c < 2) {
-					alignment = ValueRenderAlignment::LEFT;
-				} else if (c == SPLIT_COLUMN) {
-					alignment = ValueRenderAlignment::MIDDLE;
-				} else {
-					alignment = ValueRenderAlignment::RIGHT;
-				}
-			}
-			RenderValue(ss, str, widths[c], render_mode, alignment);
-		}
-		ss << config.VERTICAL;
-		ss << '\n';
-	}
-
-	if (bottom_rows > 0) {
-		if (config.render_mode == RenderMode::COLUMNS) {
-			throw InternalException("Columns render mode does not support bottom rows");
-		}
-		// render the bottom rows
-		// first render the divider
-		auto brows = bottom_collection.GetRows();
-		for (idx_t k = 0; k < 3; k++) {
-			for (idx_t c = 0; c < column_count; c++) {
-				auto column_idx = column_map[c];
-				string str;
-				auto alignment = alignments[c];
-				if (alignment == ValueRenderAlignment::MIDDLE || column_idx == SPLIT_COLUMN) {
-					str = config.DOT;
-				} else {
-					// align the dots in the center of the column
-					ResultRenderType render_mode;
-					auto top_value =
-					    GetRenderValue(ss, rows, column_idx, top_rows - 1, result_types[column_idx], render_mode);
-					auto bottom_value =
-					    GetRenderValue(ss, brows, column_idx, bottom_rows - 1, result_types[column_idx], render_mode);
-					auto top_length = MinValue<idx_t>(widths[c], Utf8Proc::RenderWidth(top_value));
-					auto bottom_length = MinValue<idx_t>(widths[c], Utf8Proc::RenderWidth(bottom_value));
-					auto dot_length = MinValue<idx_t>(top_length, bottom_length);
-					if (top_length == 0) {
-						dot_length = bottom_length;
-					} else if (bottom_length == 0) {
-						dot_length = top_length;
-					}
-					if (dot_length > 1) {
-						auto padding = dot_length - 1;
-						idx_t left_padding, right_padding;
-						switch (alignment) {
-						case ValueRenderAlignment::LEFT:
-							left_padding = padding / 2;
-							right_padding = padding - left_padding;
-							break;
-						case ValueRenderAlignment::RIGHT:
-							right_padding = padding / 2;
-							left_padding = padding - right_padding;
-							break;
-						default:
-							throw InternalException("Unrecognized value renderer alignment");
-						}
-						str = string(left_padding, ' ') + config.DOT + string(right_padding, ' ');
-					} else {
-						if (dot_length == 0) {
-							// everything is empty
-							alignment = ValueRenderAlignment::MIDDLE;
-						}
-						str = config.DOT;
-					}
-				}
-				RenderValue(ss, str, widths[c], ResultRenderType::LAYOUT, alignment);
-			}
-			ss << config.VERTICAL;
-			ss << '\n';
-		}
-		// note that the bottom rows are in reverse order
-		for (idx_t r = 0; r < bottom_rows; r++) {
-			for (idx_t c = 0; c < column_count; c++) {
-				auto column_idx = column_map[c];
-				string str;
-				ResultRenderType render_mode;
-				if (column_idx == SPLIT_COLUMN) {
-					str = config.DOTDOTDOT;
-					render_mode = ResultRenderType::LAYOUT;
-				} else {
-					str = GetRenderValue(ss, brows, column_idx, bottom_rows - r - 1, result_types[column_idx],
-					                     render_mode);
-				}
-				RenderValue(ss, str, widths[c], render_mode, alignments[c]);
-			}
-			ss << config.VERTICAL;
-			ss << '\n';
-		}
-	}
-}
-
-void BoxRenderer::RenderRowCount(string row_count_str, string shown_str, const string &column_count_str,
-                                 const vector<idx_t> &boundaries, bool has_hidden_rows, bool has_hidden_columns,
-                                 idx_t total_length, idx_t row_count, idx_t column_count, idx_t minimum_row_length,
-                                 BaseResultRenderer &ss) {
-	// check if we can merge the row_count_str and the shown_str
-	bool display_shown_separately = has_hidden_rows;
-	if (has_hidden_rows && total_length >= row_count_str.size() + shown_str.size() + 5) {
-		// we can!
-		row_count_str += " " + shown_str;
-		shown_str = string();
-		display_shown_separately = false;
-		minimum_row_length = row_count_str.size() + 4;
-	}
-	auto minimum_length = row_count_str.size() + column_count_str.size() + 6;
-	bool render_rows_and_columns = total_length >= minimum_length &&
-	                               ((has_hidden_columns && row_count > 0) || (row_count >= 10 && column_count > 1));
-	bool render_rows = total_length >= minimum_row_length && (row_count == 0 || row_count >= 10);
-	bool render_anything = true;
-	if (!render_rows && !render_rows_and_columns) {
-		render_anything = false;
-	}
-	// render the bottom of the result values, if there are any
-	if (row_count > 0) {
-		ss << (render_anything ? config.LMIDDLE : config.LDCORNER);
-		idx_t column_index = 0;
-		for (idx_t k = 0; k < total_length - 2; k++) {
-			if (column_index + 1 < boundaries.size() && k == boundaries[column_index]) {
-				ss << config.DMIDDLE;
-				column_index++;
-			} else {
-				ss << config.HORIZONTAL;
-			}
-		}
-		ss << (render_anything ? config.RMIDDLE : config.RDCORNER);
-		ss << '\n';
-	}
-	if (!render_anything) {
-		return;
-	}
-
-	if (render_rows_and_columns) {
-		ss << config.VERTICAL;
-		ss << " ";
-		ss.Render(ResultRenderType::FOOTER, row_count_str);
-		ss << string(total_length - row_count_str.size() - column_count_str.size() - 4, ' ');
-		ss.Render(ResultRenderType::FOOTER, column_count_str);
-		ss << " ";
-		ss << config.VERTICAL;
-		ss << '\n';
-	} else if (render_rows) {
-		RenderValue(ss, row_count_str, total_length - 4, ResultRenderType::FOOTER);
-		ss << config.VERTICAL;
-		ss << '\n';
-
-		if (display_shown_separately) {
-			RenderValue(ss, shown_str, total_length - 4, ResultRenderType::FOOTER);
-			ss << config.VERTICAL;
-			ss << '\n';
-		}
-	}
-	// render the bottom line
-	ss << config.LDCORNER;
-	for (idx_t k = 0; k < total_length - 2; k++) {
-		ss << config.HORIZONTAL;
-	}
-	ss << config.RDCORNER;
-	ss << '\n';
-}
-
-void BoxRenderer::Render(ClientContext &context, const vector<string> &names, const ColumnDataCollection &result,
-                         BaseResultRenderer &ss) {
-	if (result.ColumnCount() != names.size()) {
-		throw InternalException("Error in BoxRenderer::Render - unaligned columns and names");
-	}
-	auto max_width = config.max_width;
-	if (max_width == 0) {
-		if (Printer::IsTerminal(OutputStream::STREAM_STDOUT)) {
-			max_width = Printer::TerminalWidth();
-		} else {
-			max_width = 120;
-		}
-	}
-	// we do not support max widths under 80
-	max_width = MaxValue<idx_t>(80, max_width);
-
-	// figure out how many/which rows to render
-	idx_t row_count = result.Count();
-	idx_t rows_to_render = MinValue<idx_t>(row_count, config.max_rows);
-	if (row_count <= config.max_rows + 3) {
-		// hiding rows adds 3 extra rows
-		// so hiding rows makes no sense if we are only slightly over the limit
-		// if we are 1 row over the limit hiding rows will actually increase the number of lines we display!
-		// in this case render all the rows
-		rows_to_render = row_count;
-	}
-	idx_t top_rows;
-	idx_t bottom_rows;
-	if (rows_to_render == row_count) {
-		top_rows = row_count;
-		bottom_rows = 0;
-	} else {
-		top_rows = rows_to_render / 2 + (rows_to_render % 2 != 0 ? 1 : 0);
-		bottom_rows = rows_to_render - top_rows;
-	}
-	auto row_count_str = to_string(row_count) + " rows";
-	bool has_limited_rows = config.limit > 0 && row_count == config.limit;
-	if (has_limited_rows) {
-		row_count_str = "? rows";
-	}
-	string shown_str;
-	bool has_hidden_rows = top_rows < row_count;
-	if (has_hidden_rows) {
-		shown_str = "(";
-		if (has_limited_rows) {
-			shown_str += ">" + to_string(config.limit - 1) + " rows, ";
-		}
-		shown_str += to_string(top_rows + bottom_rows) + " shown)";
-	}
-	auto minimum_row_length = MaxValue<idx_t>(row_count_str.size(), shown_str.size()) + 4;
-
-	// fetch the top and bottom render collections from the result
-	auto collections = FetchRenderCollections(context, result, top_rows, bottom_rows);
-	auto column_names = names;
-	auto result_types = result.Types();
-	if (config.render_mode == RenderMode::COLUMNS) {
-		collections = PivotCollections(context, std::move(collections), column_names, result_types, row_count);
-	}
-
-	// for each column, figure out the width
-	// start off by figuring out the name of the header by looking at the column name and column type
-	idx_t min_width = has_hidden_rows || row_count == 0 ? minimum_row_length : 0;
-	vector<idx_t> column_map;
-	idx_t total_length;
-	auto widths =
-	    ComputeRenderWidths(column_names, result_types, collections, min_width, max_width, column_map, total_length);
-
-	// render boundaries for the individual columns
-	vector<idx_t> boundaries;
-	for (idx_t c = 0; c < widths.size(); c++) {
-		idx_t render_boundary;
-		if (c == 0) {
-			render_boundary = widths[c] + 2;
-		} else {
-			render_boundary = boundaries[c - 1] + widths[c] + 3;
-		}
-		boundaries.push_back(render_boundary);
-	}
-
-	// now begin rendering
-	// first render the header
-	RenderHeader(column_names, result_types, column_map, widths, boundaries, total_length, row_count > 0, ss);
-
-	// render the values, if there are any
-	RenderValues(collections, column_map, widths, result_types, ss);
-
-	// render the row count and column count
-	auto column_count_str = to_string(result.ColumnCount()) + " column";
-	if (result.ColumnCount() > 1) {
-		column_count_str += "s";
-	}
-	bool has_hidden_columns = false;
-	for (auto entry : column_map) {
-		if (entry == SPLIT_COLUMN) {
-			has_hidden_columns = true;
-			break;
-		}
-	}
-	idx_t column_count = column_map.size();
-	if (config.render_mode == RenderMode::COLUMNS) {
-		if (has_hidden_columns) {
-			has_hidden_rows = true;
-			shown_str = " (" + to_string(column_count - 3) + " shown)";
-		} else {
-			shown_str = string();
-		}
-	} else {
-		if (has_hidden_columns) {
-			column_count--;
-			column_count_str += " (" + to_string(column_count) + " shown)";
-		}
-	}
-
-	RenderRowCount(std::move(row_count_str), std::move(shown_str), column_count_str, boundaries, has_hidden_rows,
-	               has_hidden_columns, total_length, row_count, column_count, minimum_row_length, ss);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/cgroups.cpp b/src/duckdb/src/common/cgroups.cpp
deleted file mode 100644
index d7ddd980c..000000000
--- a/src/duckdb/src/common/cgroups.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-#include "duckdb/common/cgroups.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-#include <cinttypes>
-
-namespace duckdb {
-
-optional_idx CGroups::GetMemoryLimit(FileSystem &fs) {
-	// First, try cgroup v2
-	auto cgroup_v2_limit = GetCGroupV2MemoryLimit(fs);
-	if (cgroup_v2_limit.IsValid()) {
-		return cgroup_v2_limit;
-	}
-
-	// If cgroup v2 fails, try cgroup v1
-	return GetCGroupV1MemoryLimit(fs);
-}
-
-optional_idx CGroups::GetCGroupV2MemoryLimit(FileSystem &fs) {
-#if defined(__linux__) && !defined(DUCKDB_WASM)
-	const char *cgroup_self = "/proc/self/cgroup";
-	const char *memory_max = "/sys/fs/cgroup/%s/memory.max";
-
-	if (!fs.FileExists(cgroup_self)) {
-		return optional_idx();
-	}
-
-	string cgroup_path = ReadCGroupPath(fs, cgroup_self);
-	if (cgroup_path.empty()) {
-		return optional_idx();
-	}
-
-	char memory_max_path[256];
-	snprintf(memory_max_path, sizeof(memory_max_path), memory_max, cgroup_path.c_str());
-
-	if (!fs.FileExists(memory_max_path)) {
-		return optional_idx();
-	}
-
-	return ReadCGroupValue(fs, memory_max_path);
-#else
-	return optional_idx();
-#endif
-}
-
-optional_idx CGroups::GetCGroupV1MemoryLimit(FileSystem &fs) {
-#if defined(__linux__) && !defined(DUCKDB_WASM)
-	const char *cgroup_self = "/proc/self/cgroup";
-	const char *memory_limit = "/sys/fs/cgroup/memory/%s/memory.limit_in_bytes";
-
-	if (!fs.FileExists(cgroup_self)) {
-		return optional_idx();
-	}
-
-	string memory_cgroup_path = ReadMemoryCGroupPath(fs, cgroup_self);
-	if (memory_cgroup_path.empty()) {
-		return optional_idx();
-	}
-
-	char memory_limit_path[256];
-	snprintf(memory_limit_path, sizeof(memory_limit_path), memory_limit, memory_cgroup_path.c_str());
-
-	if (!fs.FileExists(memory_limit_path)) {
-		return optional_idx();
-	}
-
-	return ReadCGroupValue(fs, memory_limit_path);
-#else
-	return optional_idx();
-#endif
-}
-
-string CGroups::ReadCGroupPath(FileSystem &fs, const char *cgroup_file) {
-#if defined(__linux__) && !defined(DUCKDB_WASM)
-	auto handle = fs.OpenFile(cgroup_file, FileFlags::FILE_FLAGS_READ);
-	char buffer[1024];
-	auto bytes_read = fs.Read(*handle, buffer, sizeof(buffer) - 1);
-	buffer[bytes_read] = '\0';
-
-	// For cgroup v2, we're looking for a single line with "0::/path"
-	string content(buffer);
-	auto pos = content.find("::");
-	if (pos != string::npos) {
-		// remove trailing \n
-		auto pos2 = content.find('\n', pos + 2);
-		if (pos2 != string::npos) {
-			return content.substr(pos + 2, pos2 - (pos + 2));
-		} else {
-			return content.substr(pos + 2);
-		}
-	}
-#endif
-	return "";
-}
-
-string CGroups::ReadMemoryCGroupPath(FileSystem &fs, const char *cgroup_file) {
-#if defined(__linux__) && !defined(DUCKDB_WASM)
-	auto handle = fs.OpenFile(cgroup_file, FileFlags::FILE_FLAGS_READ);
-	char buffer[1024];
-	auto bytes_read = fs.Read(*handle, buffer, sizeof(buffer) - 1);
-	buffer[bytes_read] = '\0';
-
-	// For cgroup v1, we're looking for a line with "memory:/path"
-	string content(buffer);
-	size_t pos = 0;
-	string line;
-	while ((pos = content.find('\n')) != string::npos) {
-		line = content.substr(0, pos);
-		if (line.find("memory:") == 0) {
-			return line.substr(line.find(':') + 1);
-		}
-		content.erase(0, pos + 1);
-	}
-#endif
-	return "";
-}
-
-optional_idx CGroups::ReadCGroupValue(FileSystem &fs, const char *file_path) {
-#if defined(__linux__) && !defined(DUCKDB_WASM)
-	auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ);
-	char buffer[100];
-	auto bytes_read = fs.Read(*handle, buffer, 99);
-	buffer[bytes_read] = '\0';
-
-	idx_t value;
-	if (TryCast::Operation<string_t, idx_t>(string_t(buffer), value)) {
-		return optional_idx(value);
-	}
-#endif
-	return optional_idx();
-}
-
-idx_t CGroups::GetCPULimit(FileSystem &fs, idx_t physical_cores) {
-#if defined(__linux__) && !defined(DUCKDB_WASM)
-	static constexpr const char *cpu_max = "/sys/fs/cgroup/cpu.max";
-	static constexpr const char *cfs_quota = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
-	static constexpr const char *cfs_period = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
-
-	int64_t quota, period;
-	char byte_buffer[1000];
-	unique_ptr<FileHandle> handle;
-	int64_t read_bytes;
-
-	if (fs.FileExists(cpu_max)) {
-		// cgroup v2
-		handle = fs.OpenFile(cpu_max, FileFlags::FILE_FLAGS_READ);
-		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
-		byte_buffer[read_bytes] = '\0';
-		if (std::sscanf(byte_buffer, "%" SCNd64 " %" SCNd64 "", &quota, &period) != 2) {
-			return physical_cores;
-		}
-	} else if (fs.FileExists(cfs_quota) && fs.FileExists(cfs_period)) {
-		// cgroup v1
-		handle = fs.OpenFile(cfs_quota, FileFlags::FILE_FLAGS_READ);
-		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
-		byte_buffer[read_bytes] = '\0';
-		if (std::sscanf(byte_buffer, "%" SCNd64 "", &quota) != 1) {
-			return physical_cores;
-		}
-
-		handle = fs.OpenFile(cfs_period, FileFlags::FILE_FLAGS_READ);
-		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
-		byte_buffer[read_bytes] = '\0';
-		if (std::sscanf(byte_buffer, "%" SCNd64 "", &period) != 1) {
-			return physical_cores;
-		}
-	} else {
-		// No cgroup quota
-		return physical_cores;
-	}
-	if (quota > 0 && period > 0) {
-		return idx_t(std::ceil((double)quota / (double)period));
-	} else {
-		return physical_cores;
-	}
-#else
-	return physical_cores;
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/checksum.cpp b/src/duckdb/src/common/checksum.cpp
deleted file mode 100644
index 2fbca299e..000000000
--- a/src/duckdb/src/common/checksum.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/types/hash.hpp"
-
-namespace duckdb {
-
-hash_t Checksum(uint64_t x) {
-	return x * UINT64_C(0xbf58476d1ce4e5b9);
-}
-
-uint64_t Checksum(uint8_t *buffer, size_t size) {
-	uint64_t result = 5381;
-	uint64_t *ptr = reinterpret_cast<uint64_t *>(buffer);
-	size_t i;
-	// for efficiency, we first checksum uint64_t values
-	for (i = 0; i < size / 8; i++) {
-		result ^= Checksum(ptr[i]);
-	}
-	if (size - i * 8 > 0) {
-		// the remaining 0-7 bytes we hash using a string hash
-		result ^= Hash(buffer + i * 8, size - i * 8);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/compressed_file_system.cpp b/src/duckdb/src/common/compressed_file_system.cpp
deleted file mode 100644
index ddc325cf1..000000000
--- a/src/duckdb/src/common/compressed_file_system.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-#include "duckdb/common/compressed_file_system.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-StreamWrapper::~StreamWrapper() {
-}
-
-CompressedFile::CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle> child_handle_p, const string &path)
-    : FileHandle(fs, path, child_handle_p->GetFlags()), compressed_fs(fs), child_handle(std::move(child_handle_p)) {
-}
-
-CompressedFile::~CompressedFile() {
-	CompressedFile::Close();
-}
-
-void CompressedFile::Initialize(bool write) {
-	Close();
-
-	this->write = write;
-	stream_data.in_buf_size = compressed_fs.InBufferSize();
-	stream_data.out_buf_size = compressed_fs.OutBufferSize();
-	stream_data.in_buff = make_unsafe_uniq_array<data_t>(stream_data.in_buf_size);
-	stream_data.in_buff_start = stream_data.in_buff.get();
-	stream_data.in_buff_end = stream_data.in_buff.get();
-	stream_data.out_buff = make_unsafe_uniq_array<data_t>(stream_data.out_buf_size);
-	stream_data.out_buff_start = stream_data.out_buff.get();
-	stream_data.out_buff_end = stream_data.out_buff.get();
-
-	stream_wrapper = compressed_fs.CreateStream();
-	stream_wrapper->Initialize(*this, write);
-}
-
-idx_t CompressedFile::GetProgress() {
-	return current_position;
-}
-
-int64_t CompressedFile::ReadData(void *buffer, int64_t remaining) {
-	idx_t total_read = 0;
-	while (true) {
-		// first check if there are input bytes available in the output buffers
-		if (stream_data.out_buff_start != stream_data.out_buff_end) {
-			// there is! copy it into the output buffer
-			auto available =
-			    MinValue<idx_t>(UnsafeNumericCast<idx_t>(remaining),
-			                    UnsafeNumericCast<idx_t>(stream_data.out_buff_end - stream_data.out_buff_start));
-			memcpy(data_ptr_t(buffer) + total_read, stream_data.out_buff_start, available);
-
-			// increment the total read variables as required
-			stream_data.out_buff_start += available;
-			total_read += available;
-			remaining = UnsafeNumericCast<int64_t>(UnsafeNumericCast<idx_t>(remaining) - available);
-			if (remaining == 0) {
-				// done! read enough
-				return UnsafeNumericCast<int64_t>(total_read);
-			}
-		}
-		if (!stream_wrapper) {
-			return UnsafeNumericCast<int64_t>(total_read);
-		}
-		current_position += static_cast<idx_t>(stream_data.in_buff_end - stream_data.in_buff_start);
-		// ran out of buffer: read more data from the child stream
-		stream_data.out_buff_start = stream_data.out_buff.get();
-		stream_data.out_buff_end = stream_data.out_buff.get();
-		D_ASSERT(stream_data.in_buff_start <= stream_data.in_buff_end);
-		D_ASSERT(stream_data.in_buff_end <= stream_data.in_buff_start + stream_data.in_buf_size);
-
-		// read more input when requested and still data in the input stream
-		if (stream_data.refresh && (stream_data.in_buff_end == stream_data.in_buff.get() + stream_data.in_buf_size)) {
-			auto bufrem = stream_data.in_buff_end - stream_data.in_buff_start;
-			// buffer not empty, move remaining bytes to the beginning
-			memmove(stream_data.in_buff.get(), stream_data.in_buff_start, UnsafeNumericCast<size_t>(bufrem));
-			stream_data.in_buff_start = stream_data.in_buff.get();
-			// refill the rest of input buffer
-			auto sz = child_handle->Read(stream_data.in_buff_start + bufrem,
-			                             stream_data.in_buf_size - UnsafeNumericCast<idx_t>(bufrem));
-			stream_data.in_buff_end = stream_data.in_buff_start + bufrem + sz;
-			if (sz <= 0) {
-				stream_wrapper.reset();
-				break;
-			}
-		}
-
-		// read more input if none available
-		if (stream_data.in_buff_start == stream_data.in_buff_end) {
-			// empty input buffer: refill from the start
-			stream_data.in_buff_start = stream_data.in_buff.get();
-			stream_data.in_buff_end = stream_data.in_buff_start;
-			auto sz = child_handle->Read(stream_data.in_buff.get(), stream_data.in_buf_size);
-			if (sz <= 0) {
-				stream_wrapper.reset();
-				break;
-			}
-			stream_data.in_buff_end = stream_data.in_buff_start + sz;
-		}
-
-		auto finished = stream_wrapper->Read(stream_data);
-		if (finished) {
-			stream_wrapper.reset();
-		}
-	}
-	return UnsafeNumericCast<int64_t>(total_read);
-}
-
-int64_t CompressedFile::WriteData(data_ptr_t buffer, int64_t nr_bytes) {
-	stream_wrapper->Write(*this, stream_data, buffer, nr_bytes);
-	return nr_bytes;
-}
-
-void CompressedFile::Close() {
-	if (stream_wrapper) {
-		stream_wrapper->Close();
-		stream_wrapper.reset();
-	}
-	stream_data.in_buff.reset();
-	stream_data.out_buff.reset();
-	stream_data.out_buff_start = nullptr;
-	stream_data.out_buff_end = nullptr;
-	stream_data.in_buff_start = nullptr;
-	stream_data.in_buff_end = nullptr;
-	stream_data.in_buf_size = 0;
-	stream_data.out_buf_size = 0;
-	stream_data.refresh = false;
-}
-
-int64_t CompressedFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = handle.Cast<CompressedFile>();
-	return compressed_file.ReadData(buffer, nr_bytes);
-}
-
-int64_t CompressedFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = handle.Cast<CompressedFile>();
-	return compressed_file.WriteData(data_ptr_cast(buffer), nr_bytes);
-}
-
-void CompressedFileSystem::Reset(FileHandle &handle) {
-	auto &compressed_file = handle.Cast<CompressedFile>();
-	compressed_file.child_handle->Reset();
-	compressed_file.Initialize(compressed_file.write);
-}
-
-int64_t CompressedFileSystem::GetFileSize(FileHandle &handle) {
-	auto &compressed_file = handle.Cast<CompressedFile>();
-	return NumericCast<int64_t>(compressed_file.child_handle->GetFileSize());
-}
-
-bool CompressedFileSystem::OnDiskFile(FileHandle &handle) {
-	auto &compressed_file = handle.Cast<CompressedFile>();
-	return compressed_file.child_handle->OnDiskFile();
-}
-
-bool CompressedFileSystem::CanSeek() {
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/constants.cpp b/src/duckdb/src/common/constants.cpp
deleted file mode 100644
index edafe6b67..000000000
--- a/src/duckdb/src/common/constants.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-
-constexpr const idx_t DConstants::INVALID_INDEX;
-const row_t MAX_ROW_ID = 36028797018960000ULL;       // 2^55
-const row_t MAX_ROW_ID_LOCAL = 72057594037920000ULL; // 2^56
-const column_t COLUMN_IDENTIFIER_ROW_ID = (column_t)-1;
-const double PI = 3.141592653589793;
-
-const transaction_t TRANSACTION_ID_START = 4611686018427388000ULL;                // 2^62
-const transaction_t MAX_TRANSACTION_ID = NumericLimits<transaction_t>::Maximum(); // 2^63
-const transaction_t NOT_DELETED_ID = NumericLimits<transaction_t>::Maximum() - 1; // 2^64 - 1
-const transaction_t MAXIMUM_QUERY_ID = NumericLimits<transaction_t>::Maximum();   // 2^64
-
-bool IsPowerOfTwo(uint64_t v) {
-	return (v & (v - 1)) == 0;
-}
-
-uint64_t NextPowerOfTwo(uint64_t v) {
-	auto v_in = v;
-	if (v < 1) { // this is not strictly right but we seem to rely on it in places
-		return 2;
-	}
-	v--;
-	v |= v >> 1;
-	v |= v >> 2;
-	v |= v >> 4;
-	v |= v >> 8;
-	v |= v >> 16;
-	v |= v >> 32;
-	v++;
-	if (v == 0) {
-		throw OutOfRangeException("Can't find next power of 2 for %llu", v_in);
-	}
-	return v;
-}
-
-uint64_t PreviousPowerOfTwo(uint64_t v) {
-	return NextPowerOfTwo((v / 2) + 1);
-}
-
-bool IsInvalidSchema(const string &str) {
-	return str.empty();
-}
-
-bool IsInvalidCatalog(const string &str) {
-	return str.empty();
-}
-
-bool IsRowIdColumnId(column_t column_id) {
-	return column_id == COLUMN_IDENTIFIER_ROW_ID;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/crypto/md5.cpp b/src/duckdb/src/common/crypto/md5.cpp
deleted file mode 100644
index d0d679c32..000000000
--- a/src/duckdb/src/common/crypto/md5.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
-** This code taken from the SQLite test library.  Originally found on
-** the internet.  The original header comment follows this comment.
-** The code is largerly unchanged, but there have been some modifications.
-*/
-/*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest.  This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- */
-#include "duckdb/common/crypto/md5.hpp"
-#include "mbedtls_wrapper.hpp"
-
-namespace duckdb {
-
-/*
- * Note: this code is harmless on little-endian machines.
- */
-static void ByteReverse(unsigned char *buf, unsigned longs) {
-	uint32_t t;
-	do {
-		t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 | ((unsigned)buf[1] << 8 | buf[0]);
-		*reinterpret_cast<uint32_t *>(buf) = t;
-		buf += 4;
-	} while (--longs);
-}
-/* The four core functions - F1 is optimized somewhat */
-
-/* #define F1(x, y, z) (x & y | ~x & z) */
-#define F1(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) ((x) ^ (y) ^ (z))
-#define F4(x, y, z) ((y) ^ ((x) | ~(z)))
-
-/* This is the central step in the MD5 algorithm. */
-#define MD5STEP(f, w, x, y, z, data, s) ((w) += f(x, y, z) + (data), (w) = (w) << (s) | (w) >> (32 - (s)), (w) += (x))
-
-/*
- * The core of the MD5 algorithm, this alters an existing MD5 hash to
- * reflect the addition of 16 longwords of new data.  MD5Update blocks
- * the data and converts bytes into longwords for this routine.
- */
-static void MD5Transform(uint32_t buf[4], const uint32_t in[16]) {
-	uint32_t a, b, c, d;
-
-	a = buf[0];
-	b = buf[1];
-	c = buf[2];
-	d = buf[3];
-
-	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
-	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
-	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
-	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
-	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
-	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
-	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
-	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
-	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
-	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
-	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
-	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
-	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
-	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
-	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
-	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
-	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
-	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
-	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
-	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
-	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
-	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
-	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
-	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
-	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
-	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
-	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
-	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
-	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
-	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
-	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
-	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
-	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
-	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
-	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
-	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
-	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
-	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
-	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
-	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
-	buf[0] += a;
-	buf[1] += b;
-	buf[2] += c;
-	buf[3] += d;
-}
-
-/*
- * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
- * initialization constants.
- */
-MD5Context::MD5Context() {
-	buf[0] = 0x67452301;
-	buf[1] = 0xefcdab89;
-	buf[2] = 0x98badcfe;
-	buf[3] = 0x10325476;
-	bits[0] = 0;
-	bits[1] = 0;
-}
-
-/*
- * Update context to reflect the concatenation of another buffer full
- * of bytes.
- */
-void MD5Context::MD5Update(const_data_ptr_t input, idx_t len) {
-	uint32_t t;
-
-	/* Update bitcount */
-
-	t = bits[0];
-	bits[0] = t + ((uint32_t)len << 3);
-	if (bits[0] < t) {
-		bits[1]++; /* Carry from low to high */
-	}
-	bits[1] += len >> 29;
-
-	t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
-
-	/* Handle any leading odd-sized chunks */
-
-	if (t) {
-		unsigned char *p = (unsigned char *)in + t;
-
-		t = 64 - t;
-		if (len < t) {
-			memcpy(p, input, len);
-			return;
-		}
-		memcpy(p, input, t);
-		ByteReverse(in, 16);
-		MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
-		input += t;
-		len -= t;
-	}
-
-	/* Process data in 64-byte chunks */
-
-	while (len >= 64) {
-		memcpy(in, input, 64);
-		ByteReverse(in, 16);
-		MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
-		input += 64;
-		len -= 64;
-	}
-
-	/* Handle any remaining bytes of data. */
-	memcpy(in, input, len);
-}
-
-/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
- * 1 0* (64-bit count of bits processed, MSB-first)
- */
-void MD5Context::Finish(data_ptr_t out_digest) {
-	unsigned count;
-	unsigned char *p;
-
-	/* Compute number of bytes mod 64 */
-	count = (bits[0] >> 3) & 0x3F;
-
-	/* Set the first char of padding to 0x80.  This is safe since there is
-	   always at least one byte free */
-	p = in + count;
-	*p++ = 0x80;
-
-	/* Bytes of padding needed to make 64 bytes */
-	count = 64 - 1 - count;
-
-	/* Pad out to 56 mod 64 */
-	if (count < 8) {
-		/* Two lots of padding:  Pad the first block to 64 bytes */
-		memset(p, 0, count);
-		ByteReverse(in, 16);
-		MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
-
-		/* Now fill the next block with 56 bytes */
-		memset(in, 0, 56);
-	} else {
-		/* Pad block to 56 bytes */
-		memset(p, 0, count - 8);
-	}
-	ByteReverse(in, 14);
-
-	/* Append length in bits and transform */
-	(reinterpret_cast<uint32_t *>(in))[14] = bits[0];
-	(reinterpret_cast<uint32_t *>(in))[15] = bits[1];
-
-	MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
-	ByteReverse(reinterpret_cast<unsigned char *>(buf), 4);
-	memcpy(out_digest, buf, 16);
-}
-
-void MD5Context::FinishHex(char *out_digest) {
-	data_t digest[MD5_HASH_LENGTH_BINARY];
-	Finish(digest);
-	duckdb_mbedtls::MbedTlsWrapper::ToBase16(reinterpret_cast<char *>(digest), out_digest, MD5_HASH_LENGTH_BINARY);
-}
-
-string MD5Context::FinishHex() {
-	char digest[MD5_HASH_LENGTH_TEXT];
-	FinishHex(digest);
-	return string(digest, MD5_HASH_LENGTH_TEXT);
-}
-
-void MD5Context::Add(const char *data) {
-	MD5Update(const_data_ptr_cast(data), strlen(data));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/encryption_state.cpp b/src/duckdb/src/common/encryption_state.cpp
deleted file mode 100644
index b6343b630..000000000
--- a/src/duckdb/src/common/encryption_state.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "duckdb/common/encryption_state.hpp"
-
-namespace duckdb {
-
-EncryptionState::EncryptionState() {
-	// abstract class, no implementation needed
-}
-
-EncryptionState::~EncryptionState() {
-}
-
-bool EncryptionState::IsOpenSSL() {
-	throw NotImplementedException("EncryptionState Abstract Class is called");
-}
-
-void EncryptionState::InitializeEncryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, const std::string *key) {
-	throw NotImplementedException("EncryptionState Abstract Class is called");
-}
-
-void EncryptionState::InitializeDecryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, const std::string *key) {
-	throw NotImplementedException("EncryptionState Abstract Class is called");
-}
-
-size_t EncryptionState::Process(duckdb::const_data_ptr_t in, duckdb::idx_t in_len, duckdb::data_ptr_t out,
-                                duckdb::idx_t out_len) {
-	throw NotImplementedException("EncryptionState Abstract Class is called");
-}
-
-size_t EncryptionState::Finalize(duckdb::data_ptr_t out, duckdb::idx_t out_len, duckdb::data_ptr_t tag,
-                                 duckdb::idx_t tag_len) {
-	throw NotImplementedException("EncryptionState Abstract Class is called");
-}
-
-void EncryptionState::GenerateRandomData(duckdb::data_ptr_t data, duckdb::idx_t len) {
-	throw NotImplementedException("EncryptionState Abstract Class is called");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp
deleted file mode 100644
index 1fd91919b..000000000
--- a/src/duckdb/src/common/enum_util.cpp
+++ /dev/null
@@ -1,4240 +0,0 @@
-//-------------------------------------------------------------------------
-// This file is automatically generated by scripts/generate_enum_util.py
-// Do not edit this file manually, your changes will be overwritten
-// If you want to exclude an enum from serialization, add it to the blacklist in the script
-//
-// Note: The generated code will only work properly if the enum is a top level item in the duckdb namespace
-// If the enum is nested in a class, or in another namespace, the generated code will not compile.
-// You should move the enum to the duckdb namespace, manually write a specialization or add it to the blacklist
-//-------------------------------------------------------------------------
-
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/common/box_renderer.hpp"
-#include "duckdb/common/enums/access_mode.hpp"
-#include "duckdb/common/enums/aggregate_handling.hpp"
-#include "duckdb/common/enums/catalog_lookup_behavior.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/common/enums/copy_overwrite_mode.hpp"
-#include "duckdb/common/enums/cte_materialize.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/enums/debug_initialize.hpp"
-#include "duckdb/common/enums/destroy_buffer_upon.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/enums/file_compression_type.hpp"
-#include "duckdb/common/enums/file_glob_options.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/common/enums/function_errors.hpp"
-#include "duckdb/common/enums/index_constraint_type.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
-#include "duckdb/common/enums/metric_type.hpp"
-#include "duckdb/common/enums/on_create_conflict.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/enums/operator_result_type.hpp"
-#include "duckdb/common/enums/optimizer_type.hpp"
-#include "duckdb/common/enums/order_preservation_type.hpp"
-#include "duckdb/common/enums/order_type.hpp"
-#include "duckdb/common/enums/output_type.hpp"
-#include "duckdb/common/enums/pending_execution_result.hpp"
-#include "duckdb/common/enums/physical_operator_type.hpp"
-#include "duckdb/common/enums/prepared_statement_mode.hpp"
-#include "duckdb/common/enums/profiler_format.hpp"
-#include "duckdb/common/enums/quantile_enum.hpp"
-#include "duckdb/common/enums/relation_type.hpp"
-#include "duckdb/common/enums/scan_options.hpp"
-#include "duckdb/common/enums/set_operation_type.hpp"
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/common/enums/set_type.hpp"
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/enums/stream_execution_result.hpp"
-#include "duckdb/common/enums/subquery_type.hpp"
-#include "duckdb/common/enums/tableref_type.hpp"
-#include "duckdb/common/enums/undo_flags.hpp"
-#include "duckdb/common/enums/vector_type.hpp"
-#include "duckdb/common/enums/wal_type.hpp"
-#include "duckdb/common/enums/window_aggregation_mode.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/exception_format_value.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/common/file_open_flags.hpp"
-#include "duckdb/common/multi_file_list.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/sort/partition_state.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/column/column_data_scan_states.hpp"
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/common/types/conflict_manager.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/hyperloglog.hpp"
-#include "duckdb/common/types/row/partitioned_tuple_data.hpp"
-#include "duckdb/common/types/row/tuple_data_states.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state.hpp"
-#include "duckdb/execution/operator/csv_scanner/quote_rules.hpp"
-#include "duckdb/execution/reservoir_sample.hpp"
-#include "duckdb/function/aggregate_state.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/macro_function.hpp"
-#include "duckdb/function/partition_stats.hpp"
-#include "duckdb/function/scalar/compressed_materialization_utils.hpp"
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/function/table/arrow/enum/arrow_datetime_type.hpp"
-#include "duckdb/function/table/arrow/enum/arrow_type_info_type.hpp"
-#include "duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/appender.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/client_properties.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/main/extension.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/secret/secret.hpp"
-#include "duckdb/main/settings.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/task.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/extra_drop_info.hpp"
-#include "duckdb/parser/parsed_data/load_info.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/parser/parsed_data/transaction_info.hpp"
-#include "duckdb/parser/parser_extension.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/parser/simplified_token.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/tableref/showref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/compression/bitpacking.hpp"
-#include "duckdb/storage/magic_bytes.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/temporary_file_manager.hpp"
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-const StringUtil::EnumStringLiteral *GetARTAppendModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ARTAppendMode::DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(ARTAppendMode::IGNORE_DUPLICATES), "IGNORE_DUPLICATES" },
-		{ static_cast<uint32_t>(ARTAppendMode::INSERT_DUPLICATES), "INSERT_DUPLICATES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ARTAppendMode>(ARTAppendMode value) {
-	return StringUtil::EnumToString(GetARTAppendModeValues(), 3, "ARTAppendMode", static_cast<uint32_t>(value));
-}
-
-template<>
-ARTAppendMode EnumUtil::FromString<ARTAppendMode>(const char *value) {
-	return static_cast<ARTAppendMode>(StringUtil::StringToEnum(GetARTAppendModeValues(), 3, "ARTAppendMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetARTConflictTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ARTConflictType::NO_CONFLICT), "NO_CONFLICT" },
-		{ static_cast<uint32_t>(ARTConflictType::CONSTRAINT), "CONSTRAINT" },
-		{ static_cast<uint32_t>(ARTConflictType::TRANSACTION), "TRANSACTION" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ARTConflictType>(ARTConflictType value) {
-	return StringUtil::EnumToString(GetARTConflictTypeValues(), 3, "ARTConflictType", static_cast<uint32_t>(value));
-}
-
-template<>
-ARTConflictType EnumUtil::FromString<ARTConflictType>(const char *value) {
-	return static_cast<ARTConflictType>(StringUtil::StringToEnum(GetARTConflictTypeValues(), 3, "ARTConflictType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAccessModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AccessMode::UNDEFINED), "UNDEFINED" },
-		{ static_cast<uint32_t>(AccessMode::AUTOMATIC), "AUTOMATIC" },
-		{ static_cast<uint32_t>(AccessMode::READ_ONLY), "READ_ONLY" },
-		{ static_cast<uint32_t>(AccessMode::READ_WRITE), "READ_WRITE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AccessMode>(AccessMode value) {
-	return StringUtil::EnumToString(GetAccessModeValues(), 4, "AccessMode", static_cast<uint32_t>(value));
-}
-
-template<>
-AccessMode EnumUtil::FromString<AccessMode>(const char *value) {
-	return static_cast<AccessMode>(StringUtil::StringToEnum(GetAccessModeValues(), 4, "AccessMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAggregateCombineTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AggregateCombineType::PRESERVE_INPUT), "PRESERVE_INPUT" },
-		{ static_cast<uint32_t>(AggregateCombineType::ALLOW_DESTRUCTIVE), "ALLOW_DESTRUCTIVE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AggregateCombineType>(AggregateCombineType value) {
-	return StringUtil::EnumToString(GetAggregateCombineTypeValues(), 2, "AggregateCombineType", static_cast<uint32_t>(value));
-}
-
-template<>
-AggregateCombineType EnumUtil::FromString<AggregateCombineType>(const char *value) {
-	return static_cast<AggregateCombineType>(StringUtil::StringToEnum(GetAggregateCombineTypeValues(), 2, "AggregateCombineType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAggregateDistinctDependentValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AggregateDistinctDependent::DISTINCT_DEPENDENT), "DISTINCT_DEPENDENT" },
-		{ static_cast<uint32_t>(AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT), "NOT_DISTINCT_DEPENDENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AggregateDistinctDependent>(AggregateDistinctDependent value) {
-	return StringUtil::EnumToString(GetAggregateDistinctDependentValues(), 2, "AggregateDistinctDependent", static_cast<uint32_t>(value));
-}
-
-template<>
-AggregateDistinctDependent EnumUtil::FromString<AggregateDistinctDependent>(const char *value) {
-	return static_cast<AggregateDistinctDependent>(StringUtil::StringToEnum(GetAggregateDistinctDependentValues(), 2, "AggregateDistinctDependent", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAggregateHandlingValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AggregateHandling::STANDARD_HANDLING), "STANDARD_HANDLING" },
-		{ static_cast<uint32_t>(AggregateHandling::NO_AGGREGATES_ALLOWED), "NO_AGGREGATES_ALLOWED" },
-		{ static_cast<uint32_t>(AggregateHandling::FORCE_AGGREGATES), "FORCE_AGGREGATES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AggregateHandling>(AggregateHandling value) {
-	return StringUtil::EnumToString(GetAggregateHandlingValues(), 3, "AggregateHandling", static_cast<uint32_t>(value));
-}
-
-template<>
-AggregateHandling EnumUtil::FromString<AggregateHandling>(const char *value) {
-	return static_cast<AggregateHandling>(StringUtil::StringToEnum(GetAggregateHandlingValues(), 3, "AggregateHandling", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAggregateOrderDependentValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AggregateOrderDependent::ORDER_DEPENDENT), "ORDER_DEPENDENT" },
-		{ static_cast<uint32_t>(AggregateOrderDependent::NOT_ORDER_DEPENDENT), "NOT_ORDER_DEPENDENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AggregateOrderDependent>(AggregateOrderDependent value) {
-	return StringUtil::EnumToString(GetAggregateOrderDependentValues(), 2, "AggregateOrderDependent", static_cast<uint32_t>(value));
-}
-
-template<>
-AggregateOrderDependent EnumUtil::FromString<AggregateOrderDependent>(const char *value) {
-	return static_cast<AggregateOrderDependent>(StringUtil::StringToEnum(GetAggregateOrderDependentValues(), 2, "AggregateOrderDependent", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAggregateTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AggregateType::NON_DISTINCT), "NON_DISTINCT" },
-		{ static_cast<uint32_t>(AggregateType::DISTINCT), "DISTINCT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AggregateType>(AggregateType value) {
-	return StringUtil::EnumToString(GetAggregateTypeValues(), 2, "AggregateType", static_cast<uint32_t>(value));
-}
-
-template<>
-AggregateType EnumUtil::FromString<AggregateType>(const char *value) {
-	return static_cast<AggregateType>(StringUtil::StringToEnum(GetAggregateTypeValues(), 2, "AggregateType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAlterForeignKeyTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AlterForeignKeyType::AFT_ADD), "AFT_ADD" },
-		{ static_cast<uint32_t>(AlterForeignKeyType::AFT_DELETE), "AFT_DELETE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value) {
-	return StringUtil::EnumToString(GetAlterForeignKeyTypeValues(), 2, "AlterForeignKeyType", static_cast<uint32_t>(value));
-}
-
-template<>
-AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value) {
-	return static_cast<AlterForeignKeyType>(StringUtil::StringToEnum(GetAlterForeignKeyTypeValues(), 2, "AlterForeignKeyType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAlterScalarFunctionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AlterScalarFunctionType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS), "ADD_FUNCTION_OVERLOADS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value) {
-	return StringUtil::EnumToString(GetAlterScalarFunctionTypeValues(), 2, "AlterScalarFunctionType", static_cast<uint32_t>(value));
-}
-
-template<>
-AlterScalarFunctionType EnumUtil::FromString<AlterScalarFunctionType>(const char *value) {
-	return static_cast<AlterScalarFunctionType>(StringUtil::StringToEnum(GetAlterScalarFunctionTypeValues(), 2, "AlterScalarFunctionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAlterTableFunctionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AlterTableFunctionType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(AlterTableFunctionType::ADD_FUNCTION_OVERLOADS), "ADD_FUNCTION_OVERLOADS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AlterTableFunctionType>(AlterTableFunctionType value) {
-	return StringUtil::EnumToString(GetAlterTableFunctionTypeValues(), 2, "AlterTableFunctionType", static_cast<uint32_t>(value));
-}
-
-template<>
-AlterTableFunctionType EnumUtil::FromString<AlterTableFunctionType>(const char *value) {
-	return static_cast<AlterTableFunctionType>(StringUtil::StringToEnum(GetAlterTableFunctionTypeValues(), 2, "AlterTableFunctionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAlterTableTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AlterTableType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(AlterTableType::RENAME_COLUMN), "RENAME_COLUMN" },
-		{ static_cast<uint32_t>(AlterTableType::RENAME_TABLE), "RENAME_TABLE" },
-		{ static_cast<uint32_t>(AlterTableType::ADD_COLUMN), "ADD_COLUMN" },
-		{ static_cast<uint32_t>(AlterTableType::REMOVE_COLUMN), "REMOVE_COLUMN" },
-		{ static_cast<uint32_t>(AlterTableType::ALTER_COLUMN_TYPE), "ALTER_COLUMN_TYPE" },
-		{ static_cast<uint32_t>(AlterTableType::SET_DEFAULT), "SET_DEFAULT" },
-		{ static_cast<uint32_t>(AlterTableType::FOREIGN_KEY_CONSTRAINT), "FOREIGN_KEY_CONSTRAINT" },
-		{ static_cast<uint32_t>(AlterTableType::SET_NOT_NULL), "SET_NOT_NULL" },
-		{ static_cast<uint32_t>(AlterTableType::DROP_NOT_NULL), "DROP_NOT_NULL" },
-		{ static_cast<uint32_t>(AlterTableType::SET_COLUMN_COMMENT), "SET_COLUMN_COMMENT" },
-		{ static_cast<uint32_t>(AlterTableType::ADD_CONSTRAINT), "ADD_CONSTRAINT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AlterTableType>(AlterTableType value) {
-	return StringUtil::EnumToString(GetAlterTableTypeValues(), 12, "AlterTableType", static_cast<uint32_t>(value));
-}
-
-template<>
-AlterTableType EnumUtil::FromString<AlterTableType>(const char *value) {
-	return static_cast<AlterTableType>(StringUtil::StringToEnum(GetAlterTableTypeValues(), 12, "AlterTableType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAlterTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AlterType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(AlterType::ALTER_TABLE), "ALTER_TABLE" },
-		{ static_cast<uint32_t>(AlterType::ALTER_VIEW), "ALTER_VIEW" },
-		{ static_cast<uint32_t>(AlterType::ALTER_SEQUENCE), "ALTER_SEQUENCE" },
-		{ static_cast<uint32_t>(AlterType::CHANGE_OWNERSHIP), "CHANGE_OWNERSHIP" },
-		{ static_cast<uint32_t>(AlterType::ALTER_SCALAR_FUNCTION), "ALTER_SCALAR_FUNCTION" },
-		{ static_cast<uint32_t>(AlterType::ALTER_TABLE_FUNCTION), "ALTER_TABLE_FUNCTION" },
-		{ static_cast<uint32_t>(AlterType::SET_COMMENT), "SET_COMMENT" },
-		{ static_cast<uint32_t>(AlterType::SET_COLUMN_COMMENT), "SET_COLUMN_COMMENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AlterType>(AlterType value) {
-	return StringUtil::EnumToString(GetAlterTypeValues(), 9, "AlterType", static_cast<uint32_t>(value));
-}
-
-template<>
-AlterType EnumUtil::FromString<AlterType>(const char *value) {
-	return static_cast<AlterType>(StringUtil::StringToEnum(GetAlterTypeValues(), 9, "AlterType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAlterViewTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AlterViewType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(AlterViewType::RENAME_VIEW), "RENAME_VIEW" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AlterViewType>(AlterViewType value) {
-	return StringUtil::EnumToString(GetAlterViewTypeValues(), 2, "AlterViewType", static_cast<uint32_t>(value));
-}
-
-template<>
-AlterViewType EnumUtil::FromString<AlterViewType>(const char *value) {
-	return static_cast<AlterViewType>(StringUtil::StringToEnum(GetAlterViewTypeValues(), 2, "AlterViewType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetAppenderTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(AppenderType::LOGICAL), "LOGICAL" },
-		{ static_cast<uint32_t>(AppenderType::PHYSICAL), "PHYSICAL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<AppenderType>(AppenderType value) {
-	return StringUtil::EnumToString(GetAppenderTypeValues(), 2, "AppenderType", static_cast<uint32_t>(value));
-}
-
-template<>
-AppenderType EnumUtil::FromString<AppenderType>(const char *value) {
-	return static_cast<AppenderType>(StringUtil::StringToEnum(GetAppenderTypeValues(), 2, "AppenderType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetArrowDateTimeTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ArrowDateTimeType::MILLISECONDS), "MILLISECONDS" },
-		{ static_cast<uint32_t>(ArrowDateTimeType::MICROSECONDS), "MICROSECONDS" },
-		{ static_cast<uint32_t>(ArrowDateTimeType::NANOSECONDS), "NANOSECONDS" },
-		{ static_cast<uint32_t>(ArrowDateTimeType::SECONDS), "SECONDS" },
-		{ static_cast<uint32_t>(ArrowDateTimeType::DAYS), "DAYS" },
-		{ static_cast<uint32_t>(ArrowDateTimeType::MONTHS), "MONTHS" },
-		{ static_cast<uint32_t>(ArrowDateTimeType::MONTH_DAY_NANO), "MONTH_DAY_NANO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ArrowDateTimeType>(ArrowDateTimeType value) {
-	return StringUtil::EnumToString(GetArrowDateTimeTypeValues(), 7, "ArrowDateTimeType", static_cast<uint32_t>(value));
-}
-
-template<>
-ArrowDateTimeType EnumUtil::FromString<ArrowDateTimeType>(const char *value) {
-	return static_cast<ArrowDateTimeType>(StringUtil::StringToEnum(GetArrowDateTimeTypeValues(), 7, "ArrowDateTimeType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetArrowOffsetSizeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ArrowOffsetSize::REGULAR), "REGULAR" },
-		{ static_cast<uint32_t>(ArrowOffsetSize::LARGE), "LARGE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ArrowOffsetSize>(ArrowOffsetSize value) {
-	return StringUtil::EnumToString(GetArrowOffsetSizeValues(), 2, "ArrowOffsetSize", static_cast<uint32_t>(value));
-}
-
-template<>
-ArrowOffsetSize EnumUtil::FromString<ArrowOffsetSize>(const char *value) {
-	return static_cast<ArrowOffsetSize>(StringUtil::StringToEnum(GetArrowOffsetSizeValues(), 2, "ArrowOffsetSize", value));
-}
-
-const StringUtil::EnumStringLiteral *GetArrowTypeInfoTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ArrowTypeInfoType::LIST), "LIST" },
-		{ static_cast<uint32_t>(ArrowTypeInfoType::STRUCT), "STRUCT" },
-		{ static_cast<uint32_t>(ArrowTypeInfoType::DATE_TIME), "DATE_TIME" },
-		{ static_cast<uint32_t>(ArrowTypeInfoType::STRING), "STRING" },
-		{ static_cast<uint32_t>(ArrowTypeInfoType::ARRAY), "ARRAY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ArrowTypeInfoType>(ArrowTypeInfoType value) {
-	return StringUtil::EnumToString(GetArrowTypeInfoTypeValues(), 5, "ArrowTypeInfoType", static_cast<uint32_t>(value));
-}
-
-template<>
-ArrowTypeInfoType EnumUtil::FromString<ArrowTypeInfoType>(const char *value) {
-	return static_cast<ArrowTypeInfoType>(StringUtil::StringToEnum(GetArrowTypeInfoTypeValues(), 5, "ArrowTypeInfoType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetArrowVariableSizeTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ArrowVariableSizeType::NORMAL), "NORMAL" },
-		{ static_cast<uint32_t>(ArrowVariableSizeType::FIXED_SIZE), "FIXED_SIZE" },
-		{ static_cast<uint32_t>(ArrowVariableSizeType::SUPER_SIZE), "SUPER_SIZE" },
-		{ static_cast<uint32_t>(ArrowVariableSizeType::VIEW), "VIEW" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ArrowVariableSizeType>(ArrowVariableSizeType value) {
-	return StringUtil::EnumToString(GetArrowVariableSizeTypeValues(), 4, "ArrowVariableSizeType", static_cast<uint32_t>(value));
-}
-
-template<>
-ArrowVariableSizeType EnumUtil::FromString<ArrowVariableSizeType>(const char *value) {
-	return static_cast<ArrowVariableSizeType>(StringUtil::StringToEnum(GetArrowVariableSizeTypeValues(), 4, "ArrowVariableSizeType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetBinderTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(BinderType::REGULAR_BINDER), "REGULAR_BINDER" },
-		{ static_cast<uint32_t>(BinderType::VIEW_BINDER), "VIEW_BINDER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<BinderType>(BinderType value) {
-	return StringUtil::EnumToString(GetBinderTypeValues(), 2, "BinderType", static_cast<uint32_t>(value));
-}
-
-template<>
-BinderType EnumUtil::FromString<BinderType>(const char *value) {
-	return static_cast<BinderType>(StringUtil::StringToEnum(GetBinderTypeValues(), 2, "BinderType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetBindingModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(BindingMode::STANDARD_BINDING), "STANDARD_BINDING" },
-		{ static_cast<uint32_t>(BindingMode::EXTRACT_NAMES), "EXTRACT_NAMES" },
-		{ static_cast<uint32_t>(BindingMode::EXTRACT_REPLACEMENT_SCANS), "EXTRACT_REPLACEMENT_SCANS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<BindingMode>(BindingMode value) {
-	return StringUtil::EnumToString(GetBindingModeValues(), 3, "BindingMode", static_cast<uint32_t>(value));
-}
-
-template<>
-BindingMode EnumUtil::FromString<BindingMode>(const char *value) {
-	return static_cast<BindingMode>(StringUtil::StringToEnum(GetBindingModeValues(), 3, "BindingMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetBitpackingModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(BitpackingMode::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(BitpackingMode::AUTO), "AUTO" },
-		{ static_cast<uint32_t>(BitpackingMode::CONSTANT), "CONSTANT" },
-		{ static_cast<uint32_t>(BitpackingMode::CONSTANT_DELTA), "CONSTANT_DELTA" },
-		{ static_cast<uint32_t>(BitpackingMode::DELTA_FOR), "DELTA_FOR" },
-		{ static_cast<uint32_t>(BitpackingMode::FOR), "FOR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<BitpackingMode>(BitpackingMode value) {
-	return StringUtil::EnumToString(GetBitpackingModeValues(), 6, "BitpackingMode", static_cast<uint32_t>(value));
-}
-
-template<>
-BitpackingMode EnumUtil::FromString<BitpackingMode>(const char *value) {
-	return static_cast<BitpackingMode>(StringUtil::StringToEnum(GetBitpackingModeValues(), 6, "BitpackingMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetBlockStateValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(BlockState::BLOCK_UNLOADED), "BLOCK_UNLOADED" },
-		{ static_cast<uint32_t>(BlockState::BLOCK_LOADED), "BLOCK_LOADED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<BlockState>(BlockState value) {
-	return StringUtil::EnumToString(GetBlockStateValues(), 2, "BlockState", static_cast<uint32_t>(value));
-}
-
-template<>
-BlockState EnumUtil::FromString<BlockState>(const char *value) {
-	return static_cast<BlockState>(StringUtil::StringToEnum(GetBlockStateValues(), 2, "BlockState", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCAPIResultSetTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_NONE), "CAPI_RESULT_TYPE_NONE" },
-		{ static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED), "CAPI_RESULT_TYPE_MATERIALIZED" },
-		{ static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING), "CAPI_RESULT_TYPE_STREAMING" },
-		{ static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED), "CAPI_RESULT_TYPE_DEPRECATED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CAPIResultSetType>(CAPIResultSetType value) {
-	return StringUtil::EnumToString(GetCAPIResultSetTypeValues(), 4, "CAPIResultSetType", static_cast<uint32_t>(value));
-}
-
-template<>
-CAPIResultSetType EnumUtil::FromString<CAPIResultSetType>(const char *value) {
-	return static_cast<CAPIResultSetType>(StringUtil::StringToEnum(GetCAPIResultSetTypeValues(), 4, "CAPIResultSetType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCSVStateValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CSVState::STANDARD), "STANDARD" },
-		{ static_cast<uint32_t>(CSVState::DELIMITER), "DELIMITER" },
-		{ static_cast<uint32_t>(CSVState::DELIMITER_FIRST_BYTE), "DELIMITER_FIRST_BYTE" },
-		{ static_cast<uint32_t>(CSVState::DELIMITER_SECOND_BYTE), "DELIMITER_SECOND_BYTE" },
-		{ static_cast<uint32_t>(CSVState::DELIMITER_THIRD_BYTE), "DELIMITER_THIRD_BYTE" },
-		{ static_cast<uint32_t>(CSVState::RECORD_SEPARATOR), "RECORD_SEPARATOR" },
-		{ static_cast<uint32_t>(CSVState::CARRIAGE_RETURN), "CARRIAGE_RETURN" },
-		{ static_cast<uint32_t>(CSVState::QUOTED), "QUOTED" },
-		{ static_cast<uint32_t>(CSVState::UNQUOTED), "UNQUOTED" },
-		{ static_cast<uint32_t>(CSVState::ESCAPE), "ESCAPE" },
-		{ static_cast<uint32_t>(CSVState::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(CSVState::NOT_SET), "NOT_SET" },
-		{ static_cast<uint32_t>(CSVState::QUOTED_NEW_LINE), "QUOTED_NEW_LINE" },
-		{ static_cast<uint32_t>(CSVState::EMPTY_SPACE), "EMPTY_SPACE" },
-		{ static_cast<uint32_t>(CSVState::COMMENT), "COMMENT" },
-		{ static_cast<uint32_t>(CSVState::STANDARD_NEWLINE), "STANDARD_NEWLINE" },
-		{ static_cast<uint32_t>(CSVState::UNQUOTED_ESCAPE), "UNQUOTED_ESCAPE" },
-		{ static_cast<uint32_t>(CSVState::ESCAPED_RETURN), "ESCAPED_RETURN" },
-		{ static_cast<uint32_t>(CSVState::MAYBE_QUOTED), "MAYBE_QUOTED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CSVState>(CSVState value) {
-	return StringUtil::EnumToString(GetCSVStateValues(), 19, "CSVState", static_cast<uint32_t>(value));
-}
-
-template<>
-CSVState EnumUtil::FromString<CSVState>(const char *value) {
-	return static_cast<CSVState>(StringUtil::StringToEnum(GetCSVStateValues(), 19, "CSVState", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCTEMaterializeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT), "CTE_MATERIALIZE_DEFAULT" },
-		{ static_cast<uint32_t>(CTEMaterialize::CTE_MATERIALIZE_ALWAYS), "CTE_MATERIALIZE_ALWAYS" },
-		{ static_cast<uint32_t>(CTEMaterialize::CTE_MATERIALIZE_NEVER), "CTE_MATERIALIZE_NEVER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CTEMaterialize>(CTEMaterialize value) {
-	return StringUtil::EnumToString(GetCTEMaterializeValues(), 3, "CTEMaterialize", static_cast<uint32_t>(value));
-}
-
-template<>
-CTEMaterialize EnumUtil::FromString<CTEMaterialize>(const char *value) {
-	return static_cast<CTEMaterialize>(StringUtil::StringToEnum(GetCTEMaterializeValues(), 3, "CTEMaterialize", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCatalogLookupBehaviorValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CatalogLookupBehavior::STANDARD), "STANDARD" },
-		{ static_cast<uint32_t>(CatalogLookupBehavior::LOWER_PRIORITY), "LOWER_PRIORITY" },
-		{ static_cast<uint32_t>(CatalogLookupBehavior::NEVER_LOOKUP), "NEVER_LOOKUP" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CatalogLookupBehavior>(CatalogLookupBehavior value) {
-	return StringUtil::EnumToString(GetCatalogLookupBehaviorValues(), 3, "CatalogLookupBehavior", static_cast<uint32_t>(value));
-}
-
-template<>
-CatalogLookupBehavior EnumUtil::FromString<CatalogLookupBehavior>(const char *value) {
-	return static_cast<CatalogLookupBehavior>(StringUtil::StringToEnum(GetCatalogLookupBehaviorValues(), 3, "CatalogLookupBehavior", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCatalogTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CatalogType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(CatalogType::TABLE_ENTRY), "TABLE_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::SCHEMA_ENTRY), "SCHEMA_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::VIEW_ENTRY), "VIEW_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::INDEX_ENTRY), "INDEX_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::PREPARED_STATEMENT), "PREPARED_STATEMENT" },
-		{ static_cast<uint32_t>(CatalogType::SEQUENCE_ENTRY), "SEQUENCE_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::COLLATION_ENTRY), "COLLATION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::TYPE_ENTRY), "TYPE_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::DATABASE_ENTRY), "DATABASE_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::TABLE_FUNCTION_ENTRY), "TABLE_FUNCTION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::SCALAR_FUNCTION_ENTRY), "SCALAR_FUNCTION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::AGGREGATE_FUNCTION_ENTRY), "AGGREGATE_FUNCTION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::PRAGMA_FUNCTION_ENTRY), "PRAGMA_FUNCTION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::COPY_FUNCTION_ENTRY), "COPY_FUNCTION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::MACRO_ENTRY), "MACRO_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::TABLE_MACRO_ENTRY), "TABLE_MACRO_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::DELETED_ENTRY), "DELETED_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::RENAMED_ENTRY), "RENAMED_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::SECRET_ENTRY), "SECRET_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::SECRET_TYPE_ENTRY), "SECRET_TYPE_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::SECRET_FUNCTION_ENTRY), "SECRET_FUNCTION_ENTRY" },
-		{ static_cast<uint32_t>(CatalogType::DEPENDENCY_ENTRY), "DEPENDENCY_ENTRY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CatalogType>(CatalogType value) {
-	return StringUtil::EnumToString(GetCatalogTypeValues(), 23, "CatalogType", static_cast<uint32_t>(value));
-}
-
-template<>
-CatalogType EnumUtil::FromString<CatalogType>(const char *value) {
-	return static_cast<CatalogType>(StringUtil::StringToEnum(GetCatalogTypeValues(), 23, "CatalogType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCheckpointAbortValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CheckpointAbort::NO_ABORT), "NONE" },
-		{ static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE), "BEFORE_TRUNCATE" },
-		{ static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER), "BEFORE_HEADER" },
-		{ static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE), "AFTER_FREE_LIST_WRITE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CheckpointAbort>(CheckpointAbort value) {
-	return StringUtil::EnumToString(GetCheckpointAbortValues(), 4, "CheckpointAbort", static_cast<uint32_t>(value));
-}
-
-template<>
-CheckpointAbort EnumUtil::FromString<CheckpointAbort>(const char *value) {
-	return static_cast<CheckpointAbort>(StringUtil::StringToEnum(GetCheckpointAbortValues(), 4, "CheckpointAbort", value));
-}
-
-const StringUtil::EnumStringLiteral *GetChunkInfoTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ChunkInfoType::CONSTANT_INFO), "CONSTANT_INFO" },
-		{ static_cast<uint32_t>(ChunkInfoType::VECTOR_INFO), "VECTOR_INFO" },
-		{ static_cast<uint32_t>(ChunkInfoType::EMPTY_INFO), "EMPTY_INFO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ChunkInfoType>(ChunkInfoType value) {
-	return StringUtil::EnumToString(GetChunkInfoTypeValues(), 3, "ChunkInfoType", static_cast<uint32_t>(value));
-}
-
-template<>
-ChunkInfoType EnumUtil::FromString<ChunkInfoType>(const char *value) {
-	return static_cast<ChunkInfoType>(StringUtil::StringToEnum(GetChunkInfoTypeValues(), 3, "ChunkInfoType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetColumnDataAllocatorTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR), "BUFFER_MANAGER_ALLOCATOR" },
-		{ static_cast<uint32_t>(ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR), "IN_MEMORY_ALLOCATOR" },
-		{ static_cast<uint32_t>(ColumnDataAllocatorType::HYBRID), "HYBRID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ColumnDataAllocatorType>(ColumnDataAllocatorType value) {
-	return StringUtil::EnumToString(GetColumnDataAllocatorTypeValues(), 3, "ColumnDataAllocatorType", static_cast<uint32_t>(value));
-}
-
-template<>
-ColumnDataAllocatorType EnumUtil::FromString<ColumnDataAllocatorType>(const char *value) {
-	return static_cast<ColumnDataAllocatorType>(StringUtil::StringToEnum(GetColumnDataAllocatorTypeValues(), 3, "ColumnDataAllocatorType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetColumnDataScanPropertiesValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ColumnDataScanProperties::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(ColumnDataScanProperties::ALLOW_ZERO_COPY), "ALLOW_ZERO_COPY" },
-		{ static_cast<uint32_t>(ColumnDataScanProperties::DISALLOW_ZERO_COPY), "DISALLOW_ZERO_COPY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ColumnDataScanProperties>(ColumnDataScanProperties value) {
-	return StringUtil::EnumToString(GetColumnDataScanPropertiesValues(), 3, "ColumnDataScanProperties", static_cast<uint32_t>(value));
-}
-
-template<>
-ColumnDataScanProperties EnumUtil::FromString<ColumnDataScanProperties>(const char *value) {
-	return static_cast<ColumnDataScanProperties>(StringUtil::StringToEnum(GetColumnDataScanPropertiesValues(), 3, "ColumnDataScanProperties", value));
-}
-
-const StringUtil::EnumStringLiteral *GetColumnSegmentTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ColumnSegmentType::TRANSIENT), "TRANSIENT" },
-		{ static_cast<uint32_t>(ColumnSegmentType::PERSISTENT), "PERSISTENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ColumnSegmentType>(ColumnSegmentType value) {
-	return StringUtil::EnumToString(GetColumnSegmentTypeValues(), 2, "ColumnSegmentType", static_cast<uint32_t>(value));
-}
-
-template<>
-ColumnSegmentType EnumUtil::FromString<ColumnSegmentType>(const char *value) {
-	return static_cast<ColumnSegmentType>(StringUtil::StringToEnum(GetColumnSegmentTypeValues(), 2, "ColumnSegmentType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCompressedMaterializationDirectionValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CompressedMaterializationDirection::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(CompressedMaterializationDirection::COMPRESS), "COMPRESS" },
-		{ static_cast<uint32_t>(CompressedMaterializationDirection::DECOMPRESS), "DECOMPRESS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CompressedMaterializationDirection>(CompressedMaterializationDirection value) {
-	return StringUtil::EnumToString(GetCompressedMaterializationDirectionValues(), 3, "CompressedMaterializationDirection", static_cast<uint32_t>(value));
-}
-
-template<>
-CompressedMaterializationDirection EnumUtil::FromString<CompressedMaterializationDirection>(const char *value) {
-	return static_cast<CompressedMaterializationDirection>(StringUtil::StringToEnum(GetCompressedMaterializationDirectionValues(), 3, "CompressedMaterializationDirection", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCompressionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_AUTO), "COMPRESSION_AUTO" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_UNCOMPRESSED), "COMPRESSION_UNCOMPRESSED" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_CONSTANT), "COMPRESSION_CONSTANT" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_RLE), "COMPRESSION_RLE" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_DICTIONARY), "COMPRESSION_DICTIONARY" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_PFOR_DELTA), "COMPRESSION_PFOR_DELTA" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_BITPACKING), "COMPRESSION_BITPACKING" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_FSST), "COMPRESSION_FSST" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_CHIMP), "COMPRESSION_CHIMP" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_PATAS), "COMPRESSION_PATAS" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_ALP), "COMPRESSION_ALP" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_ALPRD), "COMPRESSION_ALPRD" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_ZSTD), "COMPRESSION_ZSTD" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_ROARING), "COMPRESSION_ROARING" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_EMPTY), "COMPRESSION_EMPTY" },
-		{ static_cast<uint32_t>(CompressionType::COMPRESSION_COUNT), "COMPRESSION_COUNT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CompressionType>(CompressionType value) {
-	return StringUtil::EnumToString(GetCompressionTypeValues(), 16, "CompressionType", static_cast<uint32_t>(value));
-}
-
-template<>
-CompressionType EnumUtil::FromString<CompressionType>(const char *value) {
-	return static_cast<CompressionType>(StringUtil::StringToEnum(GetCompressionTypeValues(), 16, "CompressionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCompressionValidityValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CompressionValidity::REQUIRES_VALIDITY), "REQUIRES_VALIDITY" },
-		{ static_cast<uint32_t>(CompressionValidity::NO_VALIDITY_REQUIRED), "NO_VALIDITY_REQUIRED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CompressionValidity>(CompressionValidity value) {
-	return StringUtil::EnumToString(GetCompressionValidityValues(), 2, "CompressionValidity", static_cast<uint32_t>(value));
-}
-
-template<>
-CompressionValidity EnumUtil::FromString<CompressionValidity>(const char *value) {
-	return static_cast<CompressionValidity>(StringUtil::StringToEnum(GetCompressionValidityValues(), 2, "CompressionValidity", value));
-}
-
-const StringUtil::EnumStringLiteral *GetConflictManagerModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ConflictManagerMode::SCAN), "SCAN" },
-		{ static_cast<uint32_t>(ConflictManagerMode::THROW), "THROW" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ConflictManagerMode>(ConflictManagerMode value) {
-	return StringUtil::EnumToString(GetConflictManagerModeValues(), 2, "ConflictManagerMode", static_cast<uint32_t>(value));
-}
-
-template<>
-ConflictManagerMode EnumUtil::FromString<ConflictManagerMode>(const char *value) {
-	return static_cast<ConflictManagerMode>(StringUtil::StringToEnum(GetConflictManagerModeValues(), 2, "ConflictManagerMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetConstraintTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ConstraintType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(ConstraintType::NOT_NULL), "NOT_NULL" },
-		{ static_cast<uint32_t>(ConstraintType::CHECK), "CHECK" },
-		{ static_cast<uint32_t>(ConstraintType::UNIQUE), "UNIQUE" },
-		{ static_cast<uint32_t>(ConstraintType::FOREIGN_KEY), "FOREIGN_KEY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ConstraintType>(ConstraintType value) {
-	return StringUtil::EnumToString(GetConstraintTypeValues(), 5, "ConstraintType", static_cast<uint32_t>(value));
-}
-
-template<>
-ConstraintType EnumUtil::FromString<ConstraintType>(const char *value) {
-	return static_cast<ConstraintType>(StringUtil::StringToEnum(GetConstraintTypeValues(), 5, "ConstraintType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCopyFunctionReturnTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CopyFunctionReturnType::CHANGED_ROWS), "CHANGED_ROWS" },
-		{ static_cast<uint32_t>(CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST), "CHANGED_ROWS_AND_FILE_LIST" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CopyFunctionReturnType>(CopyFunctionReturnType value) {
-	return StringUtil::EnumToString(GetCopyFunctionReturnTypeValues(), 2, "CopyFunctionReturnType", static_cast<uint32_t>(value));
-}
-
-template<>
-CopyFunctionReturnType EnumUtil::FromString<CopyFunctionReturnType>(const char *value) {
-	return static_cast<CopyFunctionReturnType>(StringUtil::StringToEnum(GetCopyFunctionReturnTypeValues(), 2, "CopyFunctionReturnType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCopyOverwriteModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CopyOverwriteMode::COPY_ERROR_ON_CONFLICT), "COPY_ERROR_ON_CONFLICT" },
-		{ static_cast<uint32_t>(CopyOverwriteMode::COPY_OVERWRITE), "COPY_OVERWRITE" },
-		{ static_cast<uint32_t>(CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE), "COPY_OVERWRITE_OR_IGNORE" },
-		{ static_cast<uint32_t>(CopyOverwriteMode::COPY_APPEND), "COPY_APPEND" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CopyOverwriteMode>(CopyOverwriteMode value) {
-	return StringUtil::EnumToString(GetCopyOverwriteModeValues(), 4, "CopyOverwriteMode", static_cast<uint32_t>(value));
-}
-
-template<>
-CopyOverwriteMode EnumUtil::FromString<CopyOverwriteMode>(const char *value) {
-	return static_cast<CopyOverwriteMode>(StringUtil::StringToEnum(GetCopyOverwriteModeValues(), 4, "CopyOverwriteMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetCopyToTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(CopyToType::COPY_TO_FILE), "COPY_TO_FILE" },
-		{ static_cast<uint32_t>(CopyToType::EXPORT_DATABASE), "EXPORT_DATABASE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<CopyToType>(CopyToType value) {
-	return StringUtil::EnumToString(GetCopyToTypeValues(), 2, "CopyToType", static_cast<uint32_t>(value));
-}
-
-template<>
-CopyToType EnumUtil::FromString<CopyToType>(const char *value) {
-	return static_cast<CopyToType>(StringUtil::StringToEnum(GetCopyToTypeValues(), 2, "CopyToType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDataFileTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DataFileType::FILE_DOES_NOT_EXIST), "FILE_DOES_NOT_EXIST" },
-		{ static_cast<uint32_t>(DataFileType::DUCKDB_FILE), "DUCKDB_FILE" },
-		{ static_cast<uint32_t>(DataFileType::SQLITE_FILE), "SQLITE_FILE" },
-		{ static_cast<uint32_t>(DataFileType::PARQUET_FILE), "PARQUET_FILE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DataFileType>(DataFileType value) {
-	return StringUtil::EnumToString(GetDataFileTypeValues(), 4, "DataFileType", static_cast<uint32_t>(value));
-}
-
-template<>
-DataFileType EnumUtil::FromString<DataFileType>(const char *value) {
-	return static_cast<DataFileType>(StringUtil::StringToEnum(GetDataFileTypeValues(), 4, "DataFileType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDateCastResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DateCastResult::SUCCESS), "SUCCESS" },
-		{ static_cast<uint32_t>(DateCastResult::ERROR_INCORRECT_FORMAT), "ERROR_INCORRECT_FORMAT" },
-		{ static_cast<uint32_t>(DateCastResult::ERROR_RANGE), "ERROR_RANGE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DateCastResult>(DateCastResult value) {
-	return StringUtil::EnumToString(GetDateCastResultValues(), 3, "DateCastResult", static_cast<uint32_t>(value));
-}
-
-template<>
-DateCastResult EnumUtil::FromString<DateCastResult>(const char *value) {
-	return static_cast<DateCastResult>(StringUtil::StringToEnum(GetDateCastResultValues(), 3, "DateCastResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDatePartSpecifierValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DatePartSpecifier::YEAR), "YEAR" },
-		{ static_cast<uint32_t>(DatePartSpecifier::MONTH), "MONTH" },
-		{ static_cast<uint32_t>(DatePartSpecifier::DAY), "DAY" },
-		{ static_cast<uint32_t>(DatePartSpecifier::DECADE), "DECADE" },
-		{ static_cast<uint32_t>(DatePartSpecifier::CENTURY), "CENTURY" },
-		{ static_cast<uint32_t>(DatePartSpecifier::MILLENNIUM), "MILLENNIUM" },
-		{ static_cast<uint32_t>(DatePartSpecifier::MICROSECONDS), "MICROSECONDS" },
-		{ static_cast<uint32_t>(DatePartSpecifier::MILLISECONDS), "MILLISECONDS" },
-		{ static_cast<uint32_t>(DatePartSpecifier::SECOND), "SECOND" },
-		{ static_cast<uint32_t>(DatePartSpecifier::MINUTE), "MINUTE" },
-		{ static_cast<uint32_t>(DatePartSpecifier::HOUR), "HOUR" },
-		{ static_cast<uint32_t>(DatePartSpecifier::DOW), "DOW" },
-		{ static_cast<uint32_t>(DatePartSpecifier::ISODOW), "ISODOW" },
-		{ static_cast<uint32_t>(DatePartSpecifier::WEEK), "WEEK" },
-		{ static_cast<uint32_t>(DatePartSpecifier::ISOYEAR), "ISOYEAR" },
-		{ static_cast<uint32_t>(DatePartSpecifier::QUARTER), "QUARTER" },
-		{ static_cast<uint32_t>(DatePartSpecifier::DOY), "DOY" },
-		{ static_cast<uint32_t>(DatePartSpecifier::YEARWEEK), "YEARWEEK" },
-		{ static_cast<uint32_t>(DatePartSpecifier::ERA), "ERA" },
-		{ static_cast<uint32_t>(DatePartSpecifier::TIMEZONE), "TIMEZONE" },
-		{ static_cast<uint32_t>(DatePartSpecifier::TIMEZONE_HOUR), "TIMEZONE_HOUR" },
-		{ static_cast<uint32_t>(DatePartSpecifier::TIMEZONE_MINUTE), "TIMEZONE_MINUTE" },
-		{ static_cast<uint32_t>(DatePartSpecifier::EPOCH), "EPOCH" },
-		{ static_cast<uint32_t>(DatePartSpecifier::JULIAN_DAY), "JULIAN_DAY" },
-		{ static_cast<uint32_t>(DatePartSpecifier::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DatePartSpecifier>(DatePartSpecifier value) {
-	return StringUtil::EnumToString(GetDatePartSpecifierValues(), 25, "DatePartSpecifier", static_cast<uint32_t>(value));
-}
-
-template<>
-DatePartSpecifier EnumUtil::FromString<DatePartSpecifier>(const char *value) {
-	return static_cast<DatePartSpecifier>(StringUtil::StringToEnum(GetDatePartSpecifierValues(), 25, "DatePartSpecifier", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDebugInitializeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DebugInitialize::NO_INITIALIZE), "NO_INITIALIZE" },
-		{ static_cast<uint32_t>(DebugInitialize::DEBUG_ZERO_INITIALIZE), "DEBUG_ZERO_INITIALIZE" },
-		{ static_cast<uint32_t>(DebugInitialize::DEBUG_ONE_INITIALIZE), "DEBUG_ONE_INITIALIZE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DebugInitialize>(DebugInitialize value) {
-	return StringUtil::EnumToString(GetDebugInitializeValues(), 3, "DebugInitialize", static_cast<uint32_t>(value));
-}
-
-template<>
-DebugInitialize EnumUtil::FromString<DebugInitialize>(const char *value) {
-	return static_cast<DebugInitialize>(StringUtil::StringToEnum(GetDebugInitializeValues(), 3, "DebugInitialize", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDefaultOrderByNullTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DefaultOrderByNullType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(DefaultOrderByNullType::NULLS_FIRST), "NULLS_FIRST" },
-		{ static_cast<uint32_t>(DefaultOrderByNullType::NULLS_LAST), "NULLS_LAST" },
-		{ static_cast<uint32_t>(DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC), "NULLS_FIRST_ON_ASC_LAST_ON_DESC" },
-		{ static_cast<uint32_t>(DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC), "NULLS_LAST_ON_ASC_FIRST_ON_DESC" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DefaultOrderByNullType>(DefaultOrderByNullType value) {
-	return StringUtil::EnumToString(GetDefaultOrderByNullTypeValues(), 5, "DefaultOrderByNullType", static_cast<uint32_t>(value));
-}
-
-template<>
-DefaultOrderByNullType EnumUtil::FromString<DefaultOrderByNullType>(const char *value) {
-	return static_cast<DefaultOrderByNullType>(StringUtil::StringToEnum(GetDefaultOrderByNullTypeValues(), 5, "DefaultOrderByNullType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDependencyEntryTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DependencyEntryType::SUBJECT), "SUBJECT" },
-		{ static_cast<uint32_t>(DependencyEntryType::DEPENDENT), "DEPENDENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DependencyEntryType>(DependencyEntryType value) {
-	return StringUtil::EnumToString(GetDependencyEntryTypeValues(), 2, "DependencyEntryType", static_cast<uint32_t>(value));
-}
-
-template<>
-DependencyEntryType EnumUtil::FromString<DependencyEntryType>(const char *value) {
-	return static_cast<DependencyEntryType>(StringUtil::StringToEnum(GetDependencyEntryTypeValues(), 2, "DependencyEntryType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDeprecatedIndexTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DeprecatedIndexType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(DeprecatedIndexType::ART), "ART" },
-		{ static_cast<uint32_t>(DeprecatedIndexType::EXTENSION), "EXTENSION" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DeprecatedIndexType>(DeprecatedIndexType value) {
-	return StringUtil::EnumToString(GetDeprecatedIndexTypeValues(), 3, "DeprecatedIndexType", static_cast<uint32_t>(value));
-}
-
-template<>
-DeprecatedIndexType EnumUtil::FromString<DeprecatedIndexType>(const char *value) {
-	return static_cast<DeprecatedIndexType>(StringUtil::StringToEnum(GetDeprecatedIndexTypeValues(), 3, "DeprecatedIndexType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDestroyBufferUponValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DestroyBufferUpon::BLOCK), "BLOCK" },
-		{ static_cast<uint32_t>(DestroyBufferUpon::EVICTION), "EVICTION" },
-		{ static_cast<uint32_t>(DestroyBufferUpon::UNPIN), "UNPIN" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DestroyBufferUpon>(DestroyBufferUpon value) {
-	return StringUtil::EnumToString(GetDestroyBufferUponValues(), 3, "DestroyBufferUpon", static_cast<uint32_t>(value));
-}
-
-template<>
-DestroyBufferUpon EnumUtil::FromString<DestroyBufferUpon>(const char *value) {
-	return static_cast<DestroyBufferUpon>(StringUtil::StringToEnum(GetDestroyBufferUponValues(), 3, "DestroyBufferUpon", value));
-}
-
-const StringUtil::EnumStringLiteral *GetDistinctTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(DistinctType::DISTINCT), "DISTINCT" },
-		{ static_cast<uint32_t>(DistinctType::DISTINCT_ON), "DISTINCT_ON" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<DistinctType>(DistinctType value) {
-	return StringUtil::EnumToString(GetDistinctTypeValues(), 2, "DistinctType", static_cast<uint32_t>(value));
-}
-
-template<>
-DistinctType EnumUtil::FromString<DistinctType>(const char *value) {
-	return static_cast<DistinctType>(StringUtil::StringToEnum(GetDistinctTypeValues(), 2, "DistinctType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetErrorTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ErrorType::UNSIGNED_EXTENSION), "UNSIGNED_EXTENSION" },
-		{ static_cast<uint32_t>(ErrorType::INVALIDATED_TRANSACTION), "INVALIDATED_TRANSACTION" },
-		{ static_cast<uint32_t>(ErrorType::INVALIDATED_DATABASE), "INVALIDATED_DATABASE" },
-		{ static_cast<uint32_t>(ErrorType::ERROR_COUNT), "ERROR_COUNT" },
-		{ static_cast<uint32_t>(ErrorType::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ErrorType>(ErrorType value) {
-	return StringUtil::EnumToString(GetErrorTypeValues(), 5, "ErrorType", static_cast<uint32_t>(value));
-}
-
-template<>
-ErrorType EnumUtil::FromString<ErrorType>(const char *value) {
-	return static_cast<ErrorType>(StringUtil::StringToEnum(GetErrorTypeValues(), 5, "ErrorType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExceptionFormatValueTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE), "FORMAT_VALUE_TYPE_DOUBLE" },
-		{ static_cast<uint32_t>(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), "FORMAT_VALUE_TYPE_INTEGER" },
-		{ static_cast<uint32_t>(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), "FORMAT_VALUE_TYPE_STRING" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExceptionFormatValueType>(ExceptionFormatValueType value) {
-	return StringUtil::EnumToString(GetExceptionFormatValueTypeValues(), 3, "ExceptionFormatValueType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExceptionFormatValueType EnumUtil::FromString<ExceptionFormatValueType>(const char *value) {
-	return static_cast<ExceptionFormatValueType>(StringUtil::StringToEnum(GetExceptionFormatValueTypeValues(), 3, "ExceptionFormatValueType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExceptionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExceptionType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(ExceptionType::OUT_OF_RANGE), "OUT_OF_RANGE" },
-		{ static_cast<uint32_t>(ExceptionType::CONVERSION), "CONVERSION" },
-		{ static_cast<uint32_t>(ExceptionType::UNKNOWN_TYPE), "UNKNOWN_TYPE" },
-		{ static_cast<uint32_t>(ExceptionType::DECIMAL), "DECIMAL" },
-		{ static_cast<uint32_t>(ExceptionType::MISMATCH_TYPE), "MISMATCH_TYPE" },
-		{ static_cast<uint32_t>(ExceptionType::DIVIDE_BY_ZERO), "DIVIDE_BY_ZERO" },
-		{ static_cast<uint32_t>(ExceptionType::OBJECT_SIZE), "OBJECT_SIZE" },
-		{ static_cast<uint32_t>(ExceptionType::INVALID_TYPE), "INVALID_TYPE" },
-		{ static_cast<uint32_t>(ExceptionType::SERIALIZATION), "SERIALIZATION" },
-		{ static_cast<uint32_t>(ExceptionType::TRANSACTION), "TRANSACTION" },
-		{ static_cast<uint32_t>(ExceptionType::NOT_IMPLEMENTED), "NOT_IMPLEMENTED" },
-		{ static_cast<uint32_t>(ExceptionType::EXPRESSION), "EXPRESSION" },
-		{ static_cast<uint32_t>(ExceptionType::CATALOG), "CATALOG" },
-		{ static_cast<uint32_t>(ExceptionType::PARSER), "PARSER" },
-		{ static_cast<uint32_t>(ExceptionType::PLANNER), "PLANNER" },
-		{ static_cast<uint32_t>(ExceptionType::SCHEDULER), "SCHEDULER" },
-		{ static_cast<uint32_t>(ExceptionType::EXECUTOR), "EXECUTOR" },
-		{ static_cast<uint32_t>(ExceptionType::CONSTRAINT), "CONSTRAINT" },
-		{ static_cast<uint32_t>(ExceptionType::INDEX), "INDEX" },
-		{ static_cast<uint32_t>(ExceptionType::STAT), "STAT" },
-		{ static_cast<uint32_t>(ExceptionType::CONNECTION), "CONNECTION" },
-		{ static_cast<uint32_t>(ExceptionType::SYNTAX), "SYNTAX" },
-		{ static_cast<uint32_t>(ExceptionType::SETTINGS), "SETTINGS" },
-		{ static_cast<uint32_t>(ExceptionType::BINDER), "BINDER" },
-		{ static_cast<uint32_t>(ExceptionType::NETWORK), "NETWORK" },
-		{ static_cast<uint32_t>(ExceptionType::OPTIMIZER), "OPTIMIZER" },
-		{ static_cast<uint32_t>(ExceptionType::NULL_POINTER), "NULL_POINTER" },
-		{ static_cast<uint32_t>(ExceptionType::IO), "IO" },
-		{ static_cast<uint32_t>(ExceptionType::INTERRUPT), "INTERRUPT" },
-		{ static_cast<uint32_t>(ExceptionType::FATAL), "FATAL" },
-		{ static_cast<uint32_t>(ExceptionType::INTERNAL), "INTERNAL" },
-		{ static_cast<uint32_t>(ExceptionType::INVALID_INPUT), "INVALID_INPUT" },
-		{ static_cast<uint32_t>(ExceptionType::OUT_OF_MEMORY), "OUT_OF_MEMORY" },
-		{ static_cast<uint32_t>(ExceptionType::PERMISSION), "PERMISSION" },
-		{ static_cast<uint32_t>(ExceptionType::PARAMETER_NOT_RESOLVED), "PARAMETER_NOT_RESOLVED" },
-		{ static_cast<uint32_t>(ExceptionType::PARAMETER_NOT_ALLOWED), "PARAMETER_NOT_ALLOWED" },
-		{ static_cast<uint32_t>(ExceptionType::DEPENDENCY), "DEPENDENCY" },
-		{ static_cast<uint32_t>(ExceptionType::HTTP), "HTTP" },
-		{ static_cast<uint32_t>(ExceptionType::MISSING_EXTENSION), "MISSING_EXTENSION" },
-		{ static_cast<uint32_t>(ExceptionType::AUTOLOAD), "AUTOLOAD" },
-		{ static_cast<uint32_t>(ExceptionType::SEQUENCE), "SEQUENCE" },
-		{ static_cast<uint32_t>(ExceptionType::INVALID_CONFIGURATION), "INVALID_CONFIGURATION" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExceptionType>(ExceptionType value) {
-	return StringUtil::EnumToString(GetExceptionTypeValues(), 43, "ExceptionType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExceptionType EnumUtil::FromString<ExceptionType>(const char *value) {
-	return static_cast<ExceptionType>(StringUtil::StringToEnum(GetExceptionTypeValues(), 43, "ExceptionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExplainFormatValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExplainFormat::DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(ExplainFormat::TEXT), "TEXT" },
-		{ static_cast<uint32_t>(ExplainFormat::JSON), "JSON" },
-		{ static_cast<uint32_t>(ExplainFormat::HTML), "HTML" },
-		{ static_cast<uint32_t>(ExplainFormat::GRAPHVIZ), "GRAPHVIZ" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExplainFormat>(ExplainFormat value) {
-	return StringUtil::EnumToString(GetExplainFormatValues(), 5, "ExplainFormat", static_cast<uint32_t>(value));
-}
-
-template<>
-ExplainFormat EnumUtil::FromString<ExplainFormat>(const char *value) {
-	return static_cast<ExplainFormat>(StringUtil::StringToEnum(GetExplainFormatValues(), 5, "ExplainFormat", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExplainOutputTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExplainOutputType::ALL), "ALL" },
-		{ static_cast<uint32_t>(ExplainOutputType::OPTIMIZED_ONLY), "OPTIMIZED_ONLY" },
-		{ static_cast<uint32_t>(ExplainOutputType::PHYSICAL_ONLY), "PHYSICAL_ONLY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExplainOutputType>(ExplainOutputType value) {
-	return StringUtil::EnumToString(GetExplainOutputTypeValues(), 3, "ExplainOutputType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExplainOutputType EnumUtil::FromString<ExplainOutputType>(const char *value) {
-	return static_cast<ExplainOutputType>(StringUtil::StringToEnum(GetExplainOutputTypeValues(), 3, "ExplainOutputType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExplainTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExplainType::EXPLAIN_STANDARD), "EXPLAIN_STANDARD" },
-		{ static_cast<uint32_t>(ExplainType::EXPLAIN_ANALYZE), "EXPLAIN_ANALYZE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExplainType>(ExplainType value) {
-	return StringUtil::EnumToString(GetExplainTypeValues(), 2, "ExplainType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExplainType EnumUtil::FromString<ExplainType>(const char *value) {
-	return static_cast<ExplainType>(StringUtil::StringToEnum(GetExplainTypeValues(), 2, "ExplainType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExponentTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExponentType::NONE), "NONE" },
-		{ static_cast<uint32_t>(ExponentType::POSITIVE), "POSITIVE" },
-		{ static_cast<uint32_t>(ExponentType::NEGATIVE), "NEGATIVE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExponentType>(ExponentType value) {
-	return StringUtil::EnumToString(GetExponentTypeValues(), 3, "ExponentType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExponentType EnumUtil::FromString<ExponentType>(const char *value) {
-	return static_cast<ExponentType>(StringUtil::StringToEnum(GetExponentTypeValues(), 3, "ExponentType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExpressionClassValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExpressionClass::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(ExpressionClass::AGGREGATE), "AGGREGATE" },
-		{ static_cast<uint32_t>(ExpressionClass::CASE), "CASE" },
-		{ static_cast<uint32_t>(ExpressionClass::CAST), "CAST" },
-		{ static_cast<uint32_t>(ExpressionClass::COLUMN_REF), "COLUMN_REF" },
-		{ static_cast<uint32_t>(ExpressionClass::COMPARISON), "COMPARISON" },
-		{ static_cast<uint32_t>(ExpressionClass::CONJUNCTION), "CONJUNCTION" },
-		{ static_cast<uint32_t>(ExpressionClass::CONSTANT), "CONSTANT" },
-		{ static_cast<uint32_t>(ExpressionClass::DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(ExpressionClass::FUNCTION), "FUNCTION" },
-		{ static_cast<uint32_t>(ExpressionClass::OPERATOR), "OPERATOR" },
-		{ static_cast<uint32_t>(ExpressionClass::STAR), "STAR" },
-		{ static_cast<uint32_t>(ExpressionClass::SUBQUERY), "SUBQUERY" },
-		{ static_cast<uint32_t>(ExpressionClass::WINDOW), "WINDOW" },
-		{ static_cast<uint32_t>(ExpressionClass::PARAMETER), "PARAMETER" },
-		{ static_cast<uint32_t>(ExpressionClass::COLLATE), "COLLATE" },
-		{ static_cast<uint32_t>(ExpressionClass::LAMBDA), "LAMBDA" },
-		{ static_cast<uint32_t>(ExpressionClass::POSITIONAL_REFERENCE), "POSITIONAL_REFERENCE" },
-		{ static_cast<uint32_t>(ExpressionClass::BETWEEN), "BETWEEN" },
-		{ static_cast<uint32_t>(ExpressionClass::LAMBDA_REF), "LAMBDA_REF" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_AGGREGATE), "BOUND_AGGREGATE" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_CASE), "BOUND_CASE" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_CAST), "BOUND_CAST" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_COLUMN_REF), "BOUND_COLUMN_REF" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_COMPARISON), "BOUND_COMPARISON" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_CONJUNCTION), "BOUND_CONJUNCTION" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_CONSTANT), "BOUND_CONSTANT" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_DEFAULT), "BOUND_DEFAULT" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_FUNCTION), "BOUND_FUNCTION" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_OPERATOR), "BOUND_OPERATOR" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_PARAMETER), "BOUND_PARAMETER" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_REF), "BOUND_REF" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_SUBQUERY), "BOUND_SUBQUERY" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_WINDOW), "BOUND_WINDOW" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_BETWEEN), "BOUND_BETWEEN" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_UNNEST), "BOUND_UNNEST" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_LAMBDA), "BOUND_LAMBDA" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_LAMBDA_REF), "BOUND_LAMBDA_REF" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_EXPRESSION), "BOUND_EXPRESSION" },
-		{ static_cast<uint32_t>(ExpressionClass::BOUND_EXPANDED), "BOUND_EXPANDED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExpressionClass>(ExpressionClass value) {
-	return StringUtil::EnumToString(GetExpressionClassValues(), 40, "ExpressionClass", static_cast<uint32_t>(value));
-}
-
-template<>
-ExpressionClass EnumUtil::FromString<ExpressionClass>(const char *value) {
-	return static_cast<ExpressionClass>(StringUtil::StringToEnum(GetExpressionClassValues(), 40, "ExpressionClass", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExpressionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExpressionType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(ExpressionType::OPERATOR_CAST), "OPERATOR_CAST" },
-		{ static_cast<uint32_t>(ExpressionType::OPERATOR_NOT), "OPERATOR_NOT" },
-		{ static_cast<uint32_t>(ExpressionType::OPERATOR_IS_NULL), "OPERATOR_IS_NULL" },
-		{ static_cast<uint32_t>(ExpressionType::OPERATOR_IS_NOT_NULL), "OPERATOR_IS_NOT_NULL" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_EQUAL), "COMPARE_EQUAL" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_NOTEQUAL), "COMPARE_NOTEQUAL" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_LESSTHAN), "COMPARE_LESSTHAN" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_GREATERTHAN), "COMPARE_GREATERTHAN" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_LESSTHANOREQUALTO), "COMPARE_LESSTHANOREQUALTO" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_GREATERTHANOREQUALTO), "COMPARE_GREATERTHANOREQUALTO" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_IN), "COMPARE_IN" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_NOT_IN), "COMPARE_NOT_IN" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_DISTINCT_FROM), "COMPARE_DISTINCT_FROM" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_BETWEEN), "COMPARE_BETWEEN" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_NOT_BETWEEN), "COMPARE_NOT_BETWEEN" },
-		{ static_cast<uint32_t>(ExpressionType::COMPARE_NOT_DISTINCT_FROM), "COMPARE_NOT_DISTINCT_FROM" },
-		{ static_cast<uint32_t>(ExpressionType::CONJUNCTION_AND), "CONJUNCTION_AND" },
-		{ static_cast<uint32_t>(ExpressionType::CONJUNCTION_OR), "CONJUNCTION_OR" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_CONSTANT), "VALUE_CONSTANT" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_PARAMETER), "VALUE_PARAMETER" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_TUPLE), "VALUE_TUPLE" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_TUPLE_ADDRESS), "VALUE_TUPLE_ADDRESS" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_NULL), "VALUE_NULL" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_VECTOR), "VALUE_VECTOR" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_SCALAR), "VALUE_SCALAR" },
-		{ static_cast<uint32_t>(ExpressionType::VALUE_DEFAULT), "VALUE_DEFAULT" },
-		{ static_cast<uint32_t>(ExpressionType::AGGREGATE), "AGGREGATE" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_AGGREGATE), "BOUND_AGGREGATE" },
-		{ static_cast<uint32_t>(ExpressionType::GROUPING_FUNCTION), "GROUPING_FUNCTION" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_AGGREGATE), "WINDOW_AGGREGATE" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_RANK), "WINDOW_RANK" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_RANK_DENSE), "WINDOW_RANK_DENSE" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_NTILE), "WINDOW_NTILE" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_PERCENT_RANK), "WINDOW_PERCENT_RANK" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_CUME_DIST), "WINDOW_CUME_DIST" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_ROW_NUMBER), "WINDOW_ROW_NUMBER" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_FIRST_VALUE), "WINDOW_FIRST_VALUE" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_LAST_VALUE), "WINDOW_LAST_VALUE" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_LEAD), "WINDOW_LEAD" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_LAG), "WINDOW_LAG" },
-		{ static_cast<uint32_t>(ExpressionType::WINDOW_NTH_VALUE), "WINDOW_NTH_VALUE" },
-		{ static_cast<uint32_t>(ExpressionType::FUNCTION), "FUNCTION" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_FUNCTION), "BOUND_FUNCTION" },
-		{ static_cast<uint32_t>(ExpressionType::CASE_EXPR), "CASE_EXPR" },
-		{ static_cast<uint32_t>(ExpressionType::OPERATOR_NULLIF), "OPERATOR_NULLIF" },
-		{ static_cast<uint32_t>(ExpressionType::OPERATOR_COALESCE), "OPERATOR_COALESCE" },
-		{ static_cast<uint32_t>(ExpressionType::ARRAY_EXTRACT), "ARRAY_EXTRACT" },
-		{ static_cast<uint32_t>(ExpressionType::ARRAY_SLICE), "ARRAY_SLICE" },
-		{ static_cast<uint32_t>(ExpressionType::STRUCT_EXTRACT), "STRUCT_EXTRACT" },
-		{ static_cast<uint32_t>(ExpressionType::ARRAY_CONSTRUCTOR), "ARRAY_CONSTRUCTOR" },
-		{ static_cast<uint32_t>(ExpressionType::ARROW), "ARROW" },
-		{ static_cast<uint32_t>(ExpressionType::SUBQUERY), "SUBQUERY" },
-		{ static_cast<uint32_t>(ExpressionType::STAR), "STAR" },
-		{ static_cast<uint32_t>(ExpressionType::TABLE_STAR), "TABLE_STAR" },
-		{ static_cast<uint32_t>(ExpressionType::PLACEHOLDER), "PLACEHOLDER" },
-		{ static_cast<uint32_t>(ExpressionType::COLUMN_REF), "COLUMN_REF" },
-		{ static_cast<uint32_t>(ExpressionType::FUNCTION_REF), "FUNCTION_REF" },
-		{ static_cast<uint32_t>(ExpressionType::TABLE_REF), "TABLE_REF" },
-		{ static_cast<uint32_t>(ExpressionType::LAMBDA_REF), "LAMBDA_REF" },
-		{ static_cast<uint32_t>(ExpressionType::CAST), "CAST" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_REF), "BOUND_REF" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_COLUMN_REF), "BOUND_COLUMN_REF" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_UNNEST), "BOUND_UNNEST" },
-		{ static_cast<uint32_t>(ExpressionType::COLLATE), "COLLATE" },
-		{ static_cast<uint32_t>(ExpressionType::LAMBDA), "LAMBDA" },
-		{ static_cast<uint32_t>(ExpressionType::POSITIONAL_REFERENCE), "POSITIONAL_REFERENCE" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_LAMBDA_REF), "BOUND_LAMBDA_REF" },
-		{ static_cast<uint32_t>(ExpressionType::BOUND_EXPANDED), "BOUND_EXPANDED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExpressionType>(ExpressionType value) {
-	return StringUtil::EnumToString(GetExpressionTypeValues(), 69, "ExpressionType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExpressionType EnumUtil::FromString<ExpressionType>(const char *value) {
-	return static_cast<ExpressionType>(StringUtil::StringToEnum(GetExpressionTypeValues(), 69, "ExpressionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExtensionABITypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExtensionABIType::UNKNOWN), "UNKNOWN" },
-		{ static_cast<uint32_t>(ExtensionABIType::CPP), "CPP" },
-		{ static_cast<uint32_t>(ExtensionABIType::C_STRUCT), "C_STRUCT" },
-		{ static_cast<uint32_t>(ExtensionABIType::C_STRUCT_UNSTABLE), "C_STRUCT_UNSTABLE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExtensionABIType>(ExtensionABIType value) {
-	return StringUtil::EnumToString(GetExtensionABITypeValues(), 4, "ExtensionABIType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExtensionABIType EnumUtil::FromString<ExtensionABIType>(const char *value) {
-	return static_cast<ExtensionABIType>(StringUtil::StringToEnum(GetExtensionABITypeValues(), 4, "ExtensionABIType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExtensionInstallModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExtensionInstallMode::UNKNOWN), "UNKNOWN" },
-		{ static_cast<uint32_t>(ExtensionInstallMode::REPOSITORY), "REPOSITORY" },
-		{ static_cast<uint32_t>(ExtensionInstallMode::CUSTOM_PATH), "CUSTOM_PATH" },
-		{ static_cast<uint32_t>(ExtensionInstallMode::STATICALLY_LINKED), "STATICALLY_LINKED" },
-		{ static_cast<uint32_t>(ExtensionInstallMode::NOT_INSTALLED), "NOT_INSTALLED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExtensionInstallMode>(ExtensionInstallMode value) {
-	return StringUtil::EnumToString(GetExtensionInstallModeValues(), 5, "ExtensionInstallMode", static_cast<uint32_t>(value));
-}
-
-template<>
-ExtensionInstallMode EnumUtil::FromString<ExtensionInstallMode>(const char *value) {
-	return static_cast<ExtensionInstallMode>(StringUtil::StringToEnum(GetExtensionInstallModeValues(), 5, "ExtensionInstallMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExtensionLoadResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExtensionLoadResult::LOADED_EXTENSION), "LOADED_EXTENSION" },
-		{ static_cast<uint32_t>(ExtensionLoadResult::EXTENSION_UNKNOWN), "EXTENSION_UNKNOWN" },
-		{ static_cast<uint32_t>(ExtensionLoadResult::NOT_LOADED), "NOT_LOADED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExtensionLoadResult>(ExtensionLoadResult value) {
-	return StringUtil::EnumToString(GetExtensionLoadResultValues(), 3, "ExtensionLoadResult", static_cast<uint32_t>(value));
-}
-
-template<>
-ExtensionLoadResult EnumUtil::FromString<ExtensionLoadResult>(const char *value) {
-	return static_cast<ExtensionLoadResult>(StringUtil::StringToEnum(GetExtensionLoadResultValues(), 3, "ExtensionLoadResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExtensionUpdateResultTagValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::UNKNOWN), "UNKNOWN" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::NO_UPDATE_AVAILABLE), "NO_UPDATE_AVAILABLE" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::NOT_A_REPOSITORY), "NOT_A_REPOSITORY" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::NOT_INSTALLED), "NOT_INSTALLED" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::STATICALLY_LOADED), "STATICALLY_LOADED" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::MISSING_INSTALL_INFO), "MISSING_INSTALL_INFO" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::REDOWNLOADED), "REDOWNLOADED" },
-		{ static_cast<uint32_t>(ExtensionUpdateResultTag::UPDATED), "UPDATED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExtensionUpdateResultTag>(ExtensionUpdateResultTag value) {
-	return StringUtil::EnumToString(GetExtensionUpdateResultTagValues(), 8, "ExtensionUpdateResultTag", static_cast<uint32_t>(value));
-}
-
-template<>
-ExtensionUpdateResultTag EnumUtil::FromString<ExtensionUpdateResultTag>(const char *value) {
-	return static_cast<ExtensionUpdateResultTag>(StringUtil::StringToEnum(GetExtensionUpdateResultTagValues(), 8, "ExtensionUpdateResultTag", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExtraDropInfoTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExtraDropInfoType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(ExtraDropInfoType::SECRET_INFO), "SECRET_INFO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExtraDropInfoType>(ExtraDropInfoType value) {
-	return StringUtil::EnumToString(GetExtraDropInfoTypeValues(), 2, "ExtraDropInfoType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExtraDropInfoType EnumUtil::FromString<ExtraDropInfoType>(const char *value) {
-	return static_cast<ExtraDropInfoType>(StringUtil::StringToEnum(GetExtraDropInfoTypeValues(), 2, "ExtraDropInfoType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetExtraTypeInfoTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ExtraTypeInfoType::INVALID_TYPE_INFO), "INVALID_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::GENERIC_TYPE_INFO), "GENERIC_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::DECIMAL_TYPE_INFO), "DECIMAL_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::STRING_TYPE_INFO), "STRING_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::LIST_TYPE_INFO), "LIST_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::STRUCT_TYPE_INFO), "STRUCT_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::ENUM_TYPE_INFO), "ENUM_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::USER_TYPE_INFO), "USER_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), "AGGREGATE_STATE_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::ARRAY_TYPE_INFO), "ARRAY_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::ANY_TYPE_INFO), "ANY_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO), "INTEGER_LITERAL_TYPE_INFO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ExtraTypeInfoType>(ExtraTypeInfoType value) {
-	return StringUtil::EnumToString(GetExtraTypeInfoTypeValues(), 12, "ExtraTypeInfoType", static_cast<uint32_t>(value));
-}
-
-template<>
-ExtraTypeInfoType EnumUtil::FromString<ExtraTypeInfoType>(const char *value) {
-	return static_cast<ExtraTypeInfoType>(StringUtil::StringToEnum(GetExtraTypeInfoTypeValues(), 12, "ExtraTypeInfoType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFileBufferTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FileBufferType::BLOCK), "BLOCK" },
-		{ static_cast<uint32_t>(FileBufferType::MANAGED_BUFFER), "MANAGED_BUFFER" },
-		{ static_cast<uint32_t>(FileBufferType::TINY_BUFFER), "TINY_BUFFER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FileBufferType>(FileBufferType value) {
-	return StringUtil::EnumToString(GetFileBufferTypeValues(), 3, "FileBufferType", static_cast<uint32_t>(value));
-}
-
-template<>
-FileBufferType EnumUtil::FromString<FileBufferType>(const char *value) {
-	return static_cast<FileBufferType>(StringUtil::StringToEnum(GetFileBufferTypeValues(), 3, "FileBufferType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFileCompressionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FileCompressionType::AUTO_DETECT), "AUTO_DETECT" },
-		{ static_cast<uint32_t>(FileCompressionType::UNCOMPRESSED), "UNCOMPRESSED" },
-		{ static_cast<uint32_t>(FileCompressionType::GZIP), "GZIP" },
-		{ static_cast<uint32_t>(FileCompressionType::ZSTD), "ZSTD" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FileCompressionType>(FileCompressionType value) {
-	return StringUtil::EnumToString(GetFileCompressionTypeValues(), 4, "FileCompressionType", static_cast<uint32_t>(value));
-}
-
-template<>
-FileCompressionType EnumUtil::FromString<FileCompressionType>(const char *value) {
-	return static_cast<FileCompressionType>(StringUtil::StringToEnum(GetFileCompressionTypeValues(), 4, "FileCompressionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFileExpandResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FileExpandResult::NO_FILES), "NO_FILES" },
-		{ static_cast<uint32_t>(FileExpandResult::SINGLE_FILE), "SINGLE_FILE" },
-		{ static_cast<uint32_t>(FileExpandResult::MULTIPLE_FILES), "MULTIPLE_FILES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FileExpandResult>(FileExpandResult value) {
-	return StringUtil::EnumToString(GetFileExpandResultValues(), 3, "FileExpandResult", static_cast<uint32_t>(value));
-}
-
-template<>
-FileExpandResult EnumUtil::FromString<FileExpandResult>(const char *value) {
-	return static_cast<FileExpandResult>(StringUtil::StringToEnum(GetFileExpandResultValues(), 3, "FileExpandResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFileGlobOptionsValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FileGlobOptions::DISALLOW_EMPTY), "DISALLOW_EMPTY" },
-		{ static_cast<uint32_t>(FileGlobOptions::ALLOW_EMPTY), "ALLOW_EMPTY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FileGlobOptions>(FileGlobOptions value) {
-	return StringUtil::EnumToString(GetFileGlobOptionsValues(), 2, "FileGlobOptions", static_cast<uint32_t>(value));
-}
-
-template<>
-FileGlobOptions EnumUtil::FromString<FileGlobOptions>(const char *value) {
-	return static_cast<FileGlobOptions>(StringUtil::StringToEnum(GetFileGlobOptionsValues(), 2, "FileGlobOptions", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFileLockTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FileLockType::NO_LOCK), "NO_LOCK" },
-		{ static_cast<uint32_t>(FileLockType::READ_LOCK), "READ_LOCK" },
-		{ static_cast<uint32_t>(FileLockType::WRITE_LOCK), "WRITE_LOCK" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FileLockType>(FileLockType value) {
-	return StringUtil::EnumToString(GetFileLockTypeValues(), 3, "FileLockType", static_cast<uint32_t>(value));
-}
-
-template<>
-FileLockType EnumUtil::FromString<FileLockType>(const char *value) {
-	return static_cast<FileLockType>(StringUtil::StringToEnum(GetFileLockTypeValues(), 3, "FileLockType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFilterPropagateResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FilterPropagateResult::NO_PRUNING_POSSIBLE), "NO_PRUNING_POSSIBLE" },
-		{ static_cast<uint32_t>(FilterPropagateResult::FILTER_ALWAYS_TRUE), "FILTER_ALWAYS_TRUE" },
-		{ static_cast<uint32_t>(FilterPropagateResult::FILTER_ALWAYS_FALSE), "FILTER_ALWAYS_FALSE" },
-		{ static_cast<uint32_t>(FilterPropagateResult::FILTER_TRUE_OR_NULL), "FILTER_TRUE_OR_NULL" },
-		{ static_cast<uint32_t>(FilterPropagateResult::FILTER_FALSE_OR_NULL), "FILTER_FALSE_OR_NULL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FilterPropagateResult>(FilterPropagateResult value) {
-	return StringUtil::EnumToString(GetFilterPropagateResultValues(), 5, "FilterPropagateResult", static_cast<uint32_t>(value));
-}
-
-template<>
-FilterPropagateResult EnumUtil::FromString<FilterPropagateResult>(const char *value) {
-	return static_cast<FilterPropagateResult>(StringUtil::StringToEnum(GetFilterPropagateResultValues(), 5, "FilterPropagateResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetForeignKeyTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE), "FK_TYPE_PRIMARY_KEY_TABLE" },
-		{ static_cast<uint32_t>(ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE), "FK_TYPE_FOREIGN_KEY_TABLE" },
-		{ static_cast<uint32_t>(ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE), "FK_TYPE_SELF_REFERENCE_TABLE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ForeignKeyType>(ForeignKeyType value) {
-	return StringUtil::EnumToString(GetForeignKeyTypeValues(), 3, "ForeignKeyType", static_cast<uint32_t>(value));
-}
-
-template<>
-ForeignKeyType EnumUtil::FromString<ForeignKeyType>(const char *value) {
-	return static_cast<ForeignKeyType>(StringUtil::StringToEnum(GetForeignKeyTypeValues(), 3, "ForeignKeyType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFunctionCollationHandlingValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FunctionCollationHandling::PROPAGATE_COLLATIONS), "PROPAGATE_COLLATIONS" },
-		{ static_cast<uint32_t>(FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS), "PUSH_COMBINABLE_COLLATIONS" },
-		{ static_cast<uint32_t>(FunctionCollationHandling::IGNORE_COLLATIONS), "IGNORE_COLLATIONS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FunctionCollationHandling>(FunctionCollationHandling value) {
-	return StringUtil::EnumToString(GetFunctionCollationHandlingValues(), 3, "FunctionCollationHandling", static_cast<uint32_t>(value));
-}
-
-template<>
-FunctionCollationHandling EnumUtil::FromString<FunctionCollationHandling>(const char *value) {
-	return static_cast<FunctionCollationHandling>(StringUtil::StringToEnum(GetFunctionCollationHandlingValues(), 3, "FunctionCollationHandling", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFunctionErrorsValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FunctionErrors::CANNOT_ERROR), "CANNOT_ERROR" },
-		{ static_cast<uint32_t>(FunctionErrors::CAN_THROW_RUNTIME_ERROR), "CAN_THROW_RUNTIME_ERROR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FunctionErrors>(FunctionErrors value) {
-	return StringUtil::EnumToString(GetFunctionErrorsValues(), 2, "FunctionErrors", static_cast<uint32_t>(value));
-}
-
-template<>
-FunctionErrors EnumUtil::FromString<FunctionErrors>(const char *value) {
-	return static_cast<FunctionErrors>(StringUtil::StringToEnum(GetFunctionErrorsValues(), 2, "FunctionErrors", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFunctionNullHandlingValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FunctionNullHandling::DEFAULT_NULL_HANDLING), "DEFAULT_NULL_HANDLING" },
-		{ static_cast<uint32_t>(FunctionNullHandling::SPECIAL_HANDLING), "SPECIAL_HANDLING" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FunctionNullHandling>(FunctionNullHandling value) {
-	return StringUtil::EnumToString(GetFunctionNullHandlingValues(), 2, "FunctionNullHandling", static_cast<uint32_t>(value));
-}
-
-template<>
-FunctionNullHandling EnumUtil::FromString<FunctionNullHandling>(const char *value) {
-	return static_cast<FunctionNullHandling>(StringUtil::StringToEnum(GetFunctionNullHandlingValues(), 2, "FunctionNullHandling", value));
-}
-
-const StringUtil::EnumStringLiteral *GetFunctionStabilityValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(FunctionStability::CONSISTENT), "CONSISTENT" },
-		{ static_cast<uint32_t>(FunctionStability::VOLATILE), "VOLATILE" },
-		{ static_cast<uint32_t>(FunctionStability::CONSISTENT_WITHIN_QUERY), "CONSISTENT_WITHIN_QUERY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<FunctionStability>(FunctionStability value) {
-	return StringUtil::EnumToString(GetFunctionStabilityValues(), 3, "FunctionStability", static_cast<uint32_t>(value));
-}
-
-template<>
-FunctionStability EnumUtil::FromString<FunctionStability>(const char *value) {
-	return static_cast<FunctionStability>(StringUtil::StringToEnum(GetFunctionStabilityValues(), 3, "FunctionStability", value));
-}
-
-const StringUtil::EnumStringLiteral *GetGateStatusValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(GateStatus::GATE_NOT_SET), "GATE_NOT_SET" },
-		{ static_cast<uint32_t>(GateStatus::GATE_SET), "GATE_SET" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<GateStatus>(GateStatus value) {
-	return StringUtil::EnumToString(GetGateStatusValues(), 2, "GateStatus", static_cast<uint32_t>(value));
-}
-
-template<>
-GateStatus EnumUtil::FromString<GateStatus>(const char *value) {
-	return static_cast<GateStatus>(StringUtil::StringToEnum(GetGateStatusValues(), 2, "GateStatus", value));
-}
-
-const StringUtil::EnumStringLiteral *GetHLLStorageTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(HLLStorageType::HLL_V1), "HLL_V1" },
-		{ static_cast<uint32_t>(HLLStorageType::HLL_V2), "HLL_V2" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<HLLStorageType>(HLLStorageType value) {
-	return StringUtil::EnumToString(GetHLLStorageTypeValues(), 2, "HLLStorageType", static_cast<uint32_t>(value));
-}
-
-template<>
-HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value) {
-	return static_cast<HLLStorageType>(StringUtil::StringToEnum(GetHLLStorageTypeValues(), 2, "HLLStorageType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetIndexConstraintTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(IndexConstraintType::NONE), "NONE" },
-		{ static_cast<uint32_t>(IndexConstraintType::UNIQUE), "UNIQUE" },
-		{ static_cast<uint32_t>(IndexConstraintType::PRIMARY), "PRIMARY" },
-		{ static_cast<uint32_t>(IndexConstraintType::FOREIGN), "FOREIGN" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value) {
-	return StringUtil::EnumToString(GetIndexConstraintTypeValues(), 4, "IndexConstraintType", static_cast<uint32_t>(value));
-}
-
-template<>
-IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value) {
-	return static_cast<IndexConstraintType>(StringUtil::StringToEnum(GetIndexConstraintTypeValues(), 4, "IndexConstraintType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetInsertColumnOrderValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(InsertColumnOrder::INSERT_BY_POSITION), "INSERT_BY_POSITION" },
-		{ static_cast<uint32_t>(InsertColumnOrder::INSERT_BY_NAME), "INSERT_BY_NAME" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<InsertColumnOrder>(InsertColumnOrder value) {
-	return StringUtil::EnumToString(GetInsertColumnOrderValues(), 2, "InsertColumnOrder", static_cast<uint32_t>(value));
-}
-
-template<>
-InsertColumnOrder EnumUtil::FromString<InsertColumnOrder>(const char *value) {
-	return static_cast<InsertColumnOrder>(StringUtil::StringToEnum(GetInsertColumnOrderValues(), 2, "InsertColumnOrder", value));
-}
-
-const StringUtil::EnumStringLiteral *GetInterruptModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(InterruptMode::NO_INTERRUPTS), "NO_INTERRUPTS" },
-		{ static_cast<uint32_t>(InterruptMode::TASK), "TASK" },
-		{ static_cast<uint32_t>(InterruptMode::BLOCKING), "BLOCKING" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<InterruptMode>(InterruptMode value) {
-	return StringUtil::EnumToString(GetInterruptModeValues(), 3, "InterruptMode", static_cast<uint32_t>(value));
-}
-
-template<>
-InterruptMode EnumUtil::FromString<InterruptMode>(const char *value) {
-	return static_cast<InterruptMode>(StringUtil::StringToEnum(GetInterruptModeValues(), 3, "InterruptMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetJoinRefTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(JoinRefType::REGULAR), "REGULAR" },
-		{ static_cast<uint32_t>(JoinRefType::NATURAL), "NATURAL" },
-		{ static_cast<uint32_t>(JoinRefType::CROSS), "CROSS" },
-		{ static_cast<uint32_t>(JoinRefType::POSITIONAL), "POSITIONAL" },
-		{ static_cast<uint32_t>(JoinRefType::ASOF), "ASOF" },
-		{ static_cast<uint32_t>(JoinRefType::DEPENDENT), "DEPENDENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<JoinRefType>(JoinRefType value) {
-	return StringUtil::EnumToString(GetJoinRefTypeValues(), 6, "JoinRefType", static_cast<uint32_t>(value));
-}
-
-template<>
-JoinRefType EnumUtil::FromString<JoinRefType>(const char *value) {
-	return static_cast<JoinRefType>(StringUtil::StringToEnum(GetJoinRefTypeValues(), 6, "JoinRefType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetJoinTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(JoinType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(JoinType::LEFT), "LEFT" },
-		{ static_cast<uint32_t>(JoinType::RIGHT), "RIGHT" },
-		{ static_cast<uint32_t>(JoinType::INNER), "INNER" },
-		{ static_cast<uint32_t>(JoinType::OUTER), "FULL" },
-		{ static_cast<uint32_t>(JoinType::SEMI), "SEMI" },
-		{ static_cast<uint32_t>(JoinType::ANTI), "ANTI" },
-		{ static_cast<uint32_t>(JoinType::MARK), "MARK" },
-		{ static_cast<uint32_t>(JoinType::SINGLE), "SINGLE" },
-		{ static_cast<uint32_t>(JoinType::RIGHT_SEMI), "RIGHT_SEMI" },
-		{ static_cast<uint32_t>(JoinType::RIGHT_ANTI), "RIGHT_ANTI" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<JoinType>(JoinType value) {
-	return StringUtil::EnumToString(GetJoinTypeValues(), 11, "JoinType", static_cast<uint32_t>(value));
-}
-
-template<>
-JoinType EnumUtil::FromString<JoinType>(const char *value) {
-	return static_cast<JoinType>(StringUtil::StringToEnum(GetJoinTypeValues(), 11, "JoinType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetKeywordCategoryValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(KeywordCategory::KEYWORD_RESERVED), "KEYWORD_RESERVED" },
-		{ static_cast<uint32_t>(KeywordCategory::KEYWORD_UNRESERVED), "KEYWORD_UNRESERVED" },
-		{ static_cast<uint32_t>(KeywordCategory::KEYWORD_TYPE_FUNC), "KEYWORD_TYPE_FUNC" },
-		{ static_cast<uint32_t>(KeywordCategory::KEYWORD_COL_NAME), "KEYWORD_COL_NAME" },
-		{ static_cast<uint32_t>(KeywordCategory::KEYWORD_NONE), "KEYWORD_NONE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<KeywordCategory>(KeywordCategory value) {
-	return StringUtil::EnumToString(GetKeywordCategoryValues(), 5, "KeywordCategory", static_cast<uint32_t>(value));
-}
-
-template<>
-KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value) {
-	return static_cast<KeywordCategory>(StringUtil::StringToEnum(GetKeywordCategoryValues(), 5, "KeywordCategory", value));
-}
-
-const StringUtil::EnumStringLiteral *GetLimitNodeTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(LimitNodeType::UNSET), "UNSET" },
-		{ static_cast<uint32_t>(LimitNodeType::CONSTANT_VALUE), "CONSTANT_VALUE" },
-		{ static_cast<uint32_t>(LimitNodeType::CONSTANT_PERCENTAGE), "CONSTANT_PERCENTAGE" },
-		{ static_cast<uint32_t>(LimitNodeType::EXPRESSION_VALUE), "EXPRESSION_VALUE" },
-		{ static_cast<uint32_t>(LimitNodeType::EXPRESSION_PERCENTAGE), "EXPRESSION_PERCENTAGE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<LimitNodeType>(LimitNodeType value) {
-	return StringUtil::EnumToString(GetLimitNodeTypeValues(), 5, "LimitNodeType", static_cast<uint32_t>(value));
-}
-
-template<>
-LimitNodeType EnumUtil::FromString<LimitNodeType>(const char *value) {
-	return static_cast<LimitNodeType>(StringUtil::StringToEnum(GetLimitNodeTypeValues(), 5, "LimitNodeType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetLoadTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(LoadType::LOAD), "LOAD" },
-		{ static_cast<uint32_t>(LoadType::INSTALL), "INSTALL" },
-		{ static_cast<uint32_t>(LoadType::FORCE_INSTALL), "FORCE_INSTALL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<LoadType>(LoadType value) {
-	return StringUtil::EnumToString(GetLoadTypeValues(), 3, "LoadType", static_cast<uint32_t>(value));
-}
-
-template<>
-LoadType EnumUtil::FromString<LoadType>(const char *value) {
-	return static_cast<LoadType>(StringUtil::StringToEnum(GetLoadTypeValues(), 3, "LoadType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetLogicalOperatorTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INVALID), "LOGICAL_INVALID" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PROJECTION), "LOGICAL_PROJECTION" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_FILTER), "LOGICAL_FILTER" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY), "LOGICAL_AGGREGATE_AND_GROUP_BY" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_WINDOW), "LOGICAL_WINDOW" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UNNEST), "LOGICAL_UNNEST" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_LIMIT), "LOGICAL_LIMIT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ORDER_BY), "LOGICAL_ORDER_BY" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_TOP_N), "LOGICAL_TOP_N" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_COPY_TO_FILE), "LOGICAL_COPY_TO_FILE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DISTINCT), "LOGICAL_DISTINCT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_SAMPLE), "LOGICAL_SAMPLE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PIVOT), "LOGICAL_PIVOT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_COPY_DATABASE), "LOGICAL_COPY_DATABASE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_GET), "LOGICAL_GET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CHUNK_GET), "LOGICAL_CHUNK_GET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DELIM_GET), "LOGICAL_DELIM_GET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXPRESSION_GET), "LOGICAL_EXPRESSION_GET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DUMMY_SCAN), "LOGICAL_DUMMY_SCAN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EMPTY_RESULT), "LOGICAL_EMPTY_RESULT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CTE_REF), "LOGICAL_CTE_REF" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_JOIN), "LOGICAL_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DELIM_JOIN), "LOGICAL_DELIM_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_COMPARISON_JOIN), "LOGICAL_COMPARISON_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ANY_JOIN), "LOGICAL_ANY_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CROSS_PRODUCT), "LOGICAL_CROSS_PRODUCT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_POSITIONAL_JOIN), "LOGICAL_POSITIONAL_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ASOF_JOIN), "LOGICAL_ASOF_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DEPENDENT_JOIN), "LOGICAL_DEPENDENT_JOIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UNION), "LOGICAL_UNION" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXCEPT), "LOGICAL_EXCEPT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INTERSECT), "LOGICAL_INTERSECT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), "LOGICAL_RECURSIVE_CTE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE), "LOGICAL_MATERIALIZED_CTE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INSERT), "LOGICAL_INSERT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DELETE), "LOGICAL_DELETE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UPDATE), "LOGICAL_UPDATE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ALTER), "LOGICAL_ALTER" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_TABLE), "LOGICAL_CREATE_TABLE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_INDEX), "LOGICAL_CREATE_INDEX" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE), "LOGICAL_CREATE_SEQUENCE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_VIEW), "LOGICAL_CREATE_VIEW" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA), "LOGICAL_CREATE_SCHEMA" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_MACRO), "LOGICAL_CREATE_MACRO" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DROP), "LOGICAL_DROP" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PRAGMA), "LOGICAL_PRAGMA" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_TRANSACTION), "LOGICAL_TRANSACTION" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_TYPE), "LOGICAL_CREATE_TYPE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ATTACH), "LOGICAL_ATTACH" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DETACH), "LOGICAL_DETACH" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXPLAIN), "LOGICAL_EXPLAIN" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PREPARE), "LOGICAL_PREPARE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXECUTE), "LOGICAL_EXECUTE" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXPORT), "LOGICAL_EXPORT" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_VACUUM), "LOGICAL_VACUUM" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_SET), "LOGICAL_SET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_LOAD), "LOGICAL_LOAD" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_RESET), "LOGICAL_RESET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS), "LOGICAL_UPDATE_EXTENSIONS" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_SECRET), "LOGICAL_CREATE_SECRET" },
-		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR), "LOGICAL_EXTENSION_OPERATOR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value) {
-	return StringUtil::EnumToString(GetLogicalOperatorTypeValues(), 61, "LogicalOperatorType", static_cast<uint32_t>(value));
-}
-
-template<>
-LogicalOperatorType EnumUtil::FromString<LogicalOperatorType>(const char *value) {
-	return static_cast<LogicalOperatorType>(StringUtil::StringToEnum(GetLogicalOperatorTypeValues(), 61, "LogicalOperatorType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetLogicalTypeIdValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(LogicalTypeId::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(LogicalTypeId::SQLNULL), "NULL" },
-		{ static_cast<uint32_t>(LogicalTypeId::UNKNOWN), "UNKNOWN" },
-		{ static_cast<uint32_t>(LogicalTypeId::ANY), "ANY" },
-		{ static_cast<uint32_t>(LogicalTypeId::USER), "USER" },
-		{ static_cast<uint32_t>(LogicalTypeId::BOOLEAN), "BOOLEAN" },
-		{ static_cast<uint32_t>(LogicalTypeId::TINYINT), "TINYINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::SMALLINT), "SMALLINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::INTEGER), "INTEGER" },
-		{ static_cast<uint32_t>(LogicalTypeId::BIGINT), "BIGINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::DATE), "DATE" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIME), "TIME" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_SEC), "TIMESTAMP_S" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_MS), "TIMESTAMP_MS" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIMESTAMP), "TIMESTAMP" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_NS), "TIMESTAMP_NS" },
-		{ static_cast<uint32_t>(LogicalTypeId::DECIMAL), "DECIMAL" },
-		{ static_cast<uint32_t>(LogicalTypeId::FLOAT), "FLOAT" },
-		{ static_cast<uint32_t>(LogicalTypeId::DOUBLE), "DOUBLE" },
-		{ static_cast<uint32_t>(LogicalTypeId::CHAR), "CHAR" },
-		{ static_cast<uint32_t>(LogicalTypeId::VARCHAR), "VARCHAR" },
-		{ static_cast<uint32_t>(LogicalTypeId::BLOB), "BLOB" },
-		{ static_cast<uint32_t>(LogicalTypeId::INTERVAL), "INTERVAL" },
-		{ static_cast<uint32_t>(LogicalTypeId::UTINYINT), "UTINYINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::USMALLINT), "USMALLINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::UINTEGER), "UINTEGER" },
-		{ static_cast<uint32_t>(LogicalTypeId::UBIGINT), "UBIGINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_TZ), "TIMESTAMP WITH TIME ZONE" },
-		{ static_cast<uint32_t>(LogicalTypeId::TIME_TZ), "TIME WITH TIME ZONE" },
-		{ static_cast<uint32_t>(LogicalTypeId::BIT), "BIT" },
-		{ static_cast<uint32_t>(LogicalTypeId::STRING_LITERAL), "STRING_LITERAL" },
-		{ static_cast<uint32_t>(LogicalTypeId::INTEGER_LITERAL), "INTEGER_LITERAL" },
-		{ static_cast<uint32_t>(LogicalTypeId::VARINT), "VARINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::UHUGEINT), "UHUGEINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::HUGEINT), "HUGEINT" },
-		{ static_cast<uint32_t>(LogicalTypeId::POINTER), "POINTER" },
-		{ static_cast<uint32_t>(LogicalTypeId::VALIDITY), "VALIDITY" },
-		{ static_cast<uint32_t>(LogicalTypeId::UUID), "UUID" },
-		{ static_cast<uint32_t>(LogicalTypeId::STRUCT), "STRUCT" },
-		{ static_cast<uint32_t>(LogicalTypeId::LIST), "LIST" },
-		{ static_cast<uint32_t>(LogicalTypeId::MAP), "MAP" },
-		{ static_cast<uint32_t>(LogicalTypeId::TABLE), "TABLE" },
-		{ static_cast<uint32_t>(LogicalTypeId::ENUM), "ENUM" },
-		{ static_cast<uint32_t>(LogicalTypeId::AGGREGATE_STATE), "AGGREGATE_STATE" },
-		{ static_cast<uint32_t>(LogicalTypeId::LAMBDA), "LAMBDA" },
-		{ static_cast<uint32_t>(LogicalTypeId::UNION), "UNION" },
-		{ static_cast<uint32_t>(LogicalTypeId::ARRAY), "ARRAY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<LogicalTypeId>(LogicalTypeId value) {
-	return StringUtil::EnumToString(GetLogicalTypeIdValues(), 47, "LogicalTypeId", static_cast<uint32_t>(value));
-}
-
-template<>
-LogicalTypeId EnumUtil::FromString<LogicalTypeId>(const char *value) {
-	return static_cast<LogicalTypeId>(StringUtil::StringToEnum(GetLogicalTypeIdValues(), 47, "LogicalTypeId", value));
-}
-
-const StringUtil::EnumStringLiteral *GetLookupResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(LookupResultType::LOOKUP_MISS), "LOOKUP_MISS" },
-		{ static_cast<uint32_t>(LookupResultType::LOOKUP_HIT), "LOOKUP_HIT" },
-		{ static_cast<uint32_t>(LookupResultType::LOOKUP_NULL), "LOOKUP_NULL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<LookupResultType>(LookupResultType value) {
-	return StringUtil::EnumToString(GetLookupResultTypeValues(), 3, "LookupResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-LookupResultType EnumUtil::FromString<LookupResultType>(const char *value) {
-	return static_cast<LookupResultType>(StringUtil::StringToEnum(GetLookupResultTypeValues(), 3, "LookupResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetMacroTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(MacroType::VOID_MACRO), "VOID_MACRO" },
-		{ static_cast<uint32_t>(MacroType::TABLE_MACRO), "TABLE_MACRO" },
-		{ static_cast<uint32_t>(MacroType::SCALAR_MACRO), "SCALAR_MACRO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<MacroType>(MacroType value) {
-	return StringUtil::EnumToString(GetMacroTypeValues(), 3, "MacroType", static_cast<uint32_t>(value));
-}
-
-template<>
-MacroType EnumUtil::FromString<MacroType>(const char *value) {
-	return static_cast<MacroType>(StringUtil::StringToEnum(GetMacroTypeValues(), 3, "MacroType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetMapInvalidReasonValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(MapInvalidReason::VALID), "VALID" },
-		{ static_cast<uint32_t>(MapInvalidReason::NULL_KEY), "NULL_KEY" },
-		{ static_cast<uint32_t>(MapInvalidReason::DUPLICATE_KEY), "DUPLICATE_KEY" },
-		{ static_cast<uint32_t>(MapInvalidReason::NOT_ALIGNED), "NOT_ALIGNED" },
-		{ static_cast<uint32_t>(MapInvalidReason::INVALID_PARAMS), "INVALID_PARAMS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<MapInvalidReason>(MapInvalidReason value) {
-	return StringUtil::EnumToString(GetMapInvalidReasonValues(), 5, "MapInvalidReason", static_cast<uint32_t>(value));
-}
-
-template<>
-MapInvalidReason EnumUtil::FromString<MapInvalidReason>(const char *value) {
-	return static_cast<MapInvalidReason>(StringUtil::StringToEnum(GetMapInvalidReasonValues(), 5, "MapInvalidReason", value));
-}
-
-const StringUtil::EnumStringLiteral *GetMemoryTagValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(MemoryTag::BASE_TABLE), "BASE_TABLE" },
-		{ static_cast<uint32_t>(MemoryTag::HASH_TABLE), "HASH_TABLE" },
-		{ static_cast<uint32_t>(MemoryTag::PARQUET_READER), "PARQUET_READER" },
-		{ static_cast<uint32_t>(MemoryTag::CSV_READER), "CSV_READER" },
-		{ static_cast<uint32_t>(MemoryTag::ORDER_BY), "ORDER_BY" },
-		{ static_cast<uint32_t>(MemoryTag::ART_INDEX), "ART_INDEX" },
-		{ static_cast<uint32_t>(MemoryTag::COLUMN_DATA), "COLUMN_DATA" },
-		{ static_cast<uint32_t>(MemoryTag::METADATA), "METADATA" },
-		{ static_cast<uint32_t>(MemoryTag::OVERFLOW_STRINGS), "OVERFLOW_STRINGS" },
-		{ static_cast<uint32_t>(MemoryTag::IN_MEMORY_TABLE), "IN_MEMORY_TABLE" },
-		{ static_cast<uint32_t>(MemoryTag::ALLOCATOR), "ALLOCATOR" },
-		{ static_cast<uint32_t>(MemoryTag::EXTENSION), "EXTENSION" },
-		{ static_cast<uint32_t>(MemoryTag::TRANSACTION), "TRANSACTION" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<MemoryTag>(MemoryTag value) {
-	return StringUtil::EnumToString(GetMemoryTagValues(), 13, "MemoryTag", static_cast<uint32_t>(value));
-}
-
-template<>
-MemoryTag EnumUtil::FromString<MemoryTag>(const char *value) {
-	return static_cast<MemoryTag>(StringUtil::StringToEnum(GetMemoryTagValues(), 13, "MemoryTag", value));
-}
-
-const StringUtil::EnumStringLiteral *GetMetaPipelineTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(MetaPipelineType::REGULAR), "REGULAR" },
-		{ static_cast<uint32_t>(MetaPipelineType::JOIN_BUILD), "JOIN_BUILD" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<MetaPipelineType>(MetaPipelineType value) {
-	return StringUtil::EnumToString(GetMetaPipelineTypeValues(), 2, "MetaPipelineType", static_cast<uint32_t>(value));
-}
-
-template<>
-MetaPipelineType EnumUtil::FromString<MetaPipelineType>(const char *value) {
-	return static_cast<MetaPipelineType>(StringUtil::StringToEnum(GetMetaPipelineTypeValues(), 2, "MetaPipelineType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetMetricsTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(MetricsType::QUERY_NAME), "QUERY_NAME" },
-		{ static_cast<uint32_t>(MetricsType::BLOCKED_THREAD_TIME), "BLOCKED_THREAD_TIME" },
-		{ static_cast<uint32_t>(MetricsType::CPU_TIME), "CPU_TIME" },
-		{ static_cast<uint32_t>(MetricsType::EXTRA_INFO), "EXTRA_INFO" },
-		{ static_cast<uint32_t>(MetricsType::CUMULATIVE_CARDINALITY), "CUMULATIVE_CARDINALITY" },
-		{ static_cast<uint32_t>(MetricsType::OPERATOR_TYPE), "OPERATOR_TYPE" },
-		{ static_cast<uint32_t>(MetricsType::OPERATOR_CARDINALITY), "OPERATOR_CARDINALITY" },
-		{ static_cast<uint32_t>(MetricsType::CUMULATIVE_ROWS_SCANNED), "CUMULATIVE_ROWS_SCANNED" },
-		{ static_cast<uint32_t>(MetricsType::OPERATOR_ROWS_SCANNED), "OPERATOR_ROWS_SCANNED" },
-		{ static_cast<uint32_t>(MetricsType::OPERATOR_TIMING), "OPERATOR_TIMING" },
-		{ static_cast<uint32_t>(MetricsType::RESULT_SET_SIZE), "RESULT_SET_SIZE" },
-		{ static_cast<uint32_t>(MetricsType::LATENCY), "LATENCY" },
-		{ static_cast<uint32_t>(MetricsType::ROWS_RETURNED), "ROWS_RETURNED" },
-		{ static_cast<uint32_t>(MetricsType::OPERATOR_NAME), "OPERATOR_NAME" },
-		{ static_cast<uint32_t>(MetricsType::ALL_OPTIMIZERS), "ALL_OPTIMIZERS" },
-		{ static_cast<uint32_t>(MetricsType::CUMULATIVE_OPTIMIZER_TIMING), "CUMULATIVE_OPTIMIZER_TIMING" },
-		{ static_cast<uint32_t>(MetricsType::PLANNER), "PLANNER" },
-		{ static_cast<uint32_t>(MetricsType::PLANNER_BINDING), "PLANNER_BINDING" },
-		{ static_cast<uint32_t>(MetricsType::PHYSICAL_PLANNER), "PHYSICAL_PLANNER" },
-		{ static_cast<uint32_t>(MetricsType::PHYSICAL_PLANNER_COLUMN_BINDING), "PHYSICAL_PLANNER_COLUMN_BINDING" },
-		{ static_cast<uint32_t>(MetricsType::PHYSICAL_PLANNER_RESOLVE_TYPES), "PHYSICAL_PLANNER_RESOLVE_TYPES" },
-		{ static_cast<uint32_t>(MetricsType::PHYSICAL_PLANNER_CREATE_PLAN), "PHYSICAL_PLANNER_CREATE_PLAN" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_EXPRESSION_REWRITER), "OPTIMIZER_EXPRESSION_REWRITER" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_FILTER_PULLUP), "OPTIMIZER_FILTER_PULLUP" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_FILTER_PUSHDOWN), "OPTIMIZER_FILTER_PUSHDOWN" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_EMPTY_RESULT_PULLUP), "OPTIMIZER_EMPTY_RESULT_PULLUP" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_CTE_FILTER_PUSHER), "OPTIMIZER_CTE_FILTER_PUSHER" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_REGEX_RANGE), "OPTIMIZER_REGEX_RANGE" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_IN_CLAUSE), "OPTIMIZER_IN_CLAUSE" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_JOIN_ORDER), "OPTIMIZER_JOIN_ORDER" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_DELIMINATOR), "OPTIMIZER_DELIMINATOR" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_UNNEST_REWRITER), "OPTIMIZER_UNNEST_REWRITER" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_UNUSED_COLUMNS), "OPTIMIZER_UNUSED_COLUMNS" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_STATISTICS_PROPAGATION), "OPTIMIZER_STATISTICS_PROPAGATION" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_COMMON_SUBEXPRESSIONS), "OPTIMIZER_COMMON_SUBEXPRESSIONS" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_COMMON_AGGREGATE), "OPTIMIZER_COMMON_AGGREGATE" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_COLUMN_LIFETIME), "OPTIMIZER_COLUMN_LIFETIME" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_BUILD_SIDE_PROBE_SIDE), "OPTIMIZER_BUILD_SIDE_PROBE_SIDE" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_LIMIT_PUSHDOWN), "OPTIMIZER_LIMIT_PUSHDOWN" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_TOP_N), "OPTIMIZER_TOP_N" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_COMPRESSED_MATERIALIZATION), "OPTIMIZER_COMPRESSED_MATERIALIZATION" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_DUPLICATE_GROUPS), "OPTIMIZER_DUPLICATE_GROUPS" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_REORDER_FILTER), "OPTIMIZER_REORDER_FILTER" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_SAMPLING_PUSHDOWN), "OPTIMIZER_SAMPLING_PUSHDOWN" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_JOIN_FILTER_PUSHDOWN), "OPTIMIZER_JOIN_FILTER_PUSHDOWN" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_EXTENSION), "OPTIMIZER_EXTENSION" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_MATERIALIZED_CTE), "OPTIMIZER_MATERIALIZED_CTE" },
-		{ static_cast<uint32_t>(MetricsType::OPTIMIZER_SUM_REWRITER), "OPTIMIZER_SUM_REWRITER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<MetricsType>(MetricsType value) {
-	return StringUtil::EnumToString(GetMetricsTypeValues(), 48, "MetricsType", static_cast<uint32_t>(value));
-}
-
-template<>
-MetricsType EnumUtil::FromString<MetricsType>(const char *value) {
-	return static_cast<MetricsType>(StringUtil::StringToEnum(GetMetricsTypeValues(), 48, "MetricsType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetNTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(NType::PREFIX), "PREFIX" },
-		{ static_cast<uint32_t>(NType::LEAF), "LEAF" },
-		{ static_cast<uint32_t>(NType::NODE_4), "NODE_4" },
-		{ static_cast<uint32_t>(NType::NODE_16), "NODE_16" },
-		{ static_cast<uint32_t>(NType::NODE_48), "NODE_48" },
-		{ static_cast<uint32_t>(NType::NODE_256), "NODE_256" },
-		{ static_cast<uint32_t>(NType::LEAF_INLINED), "LEAF_INLINED" },
-		{ static_cast<uint32_t>(NType::NODE_7_LEAF), "NODE_7_LEAF" },
-		{ static_cast<uint32_t>(NType::NODE_15_LEAF), "NODE_15_LEAF" },
-		{ static_cast<uint32_t>(NType::NODE_256_LEAF), "NODE_256_LEAF" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<NType>(NType value) {
-	return StringUtil::EnumToString(GetNTypeValues(), 10, "NType", static_cast<uint32_t>(value));
-}
-
-template<>
-NType EnumUtil::FromString<NType>(const char *value) {
-	return static_cast<NType>(StringUtil::StringToEnum(GetNTypeValues(), 10, "NType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetNewLineIdentifierValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(NewLineIdentifier::SINGLE_N), "SINGLE_N" },
-		{ static_cast<uint32_t>(NewLineIdentifier::CARRY_ON), "CARRY_ON" },
-		{ static_cast<uint32_t>(NewLineIdentifier::NOT_SET), "NOT_SET" },
-		{ static_cast<uint32_t>(NewLineIdentifier::SINGLE_R), "SINGLE_R" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<NewLineIdentifier>(NewLineIdentifier value) {
-	return StringUtil::EnumToString(GetNewLineIdentifierValues(), 4, "NewLineIdentifier", static_cast<uint32_t>(value));
-}
-
-template<>
-NewLineIdentifier EnumUtil::FromString<NewLineIdentifier>(const char *value) {
-	return static_cast<NewLineIdentifier>(StringUtil::StringToEnum(GetNewLineIdentifierValues(), 4, "NewLineIdentifier", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOnConflictActionValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OnConflictAction::THROW), "THROW" },
-		{ static_cast<uint32_t>(OnConflictAction::NOTHING), "NOTHING" },
-		{ static_cast<uint32_t>(OnConflictAction::UPDATE), "UPDATE" },
-		{ static_cast<uint32_t>(OnConflictAction::REPLACE), "REPLACE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OnConflictAction>(OnConflictAction value) {
-	return StringUtil::EnumToString(GetOnConflictActionValues(), 4, "OnConflictAction", static_cast<uint32_t>(value));
-}
-
-template<>
-OnConflictAction EnumUtil::FromString<OnConflictAction>(const char *value) {
-	return static_cast<OnConflictAction>(StringUtil::StringToEnum(GetOnConflictActionValues(), 4, "OnConflictAction", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOnCreateConflictValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OnCreateConflict::ERROR_ON_CONFLICT), "ERROR_ON_CONFLICT" },
-		{ static_cast<uint32_t>(OnCreateConflict::IGNORE_ON_CONFLICT), "IGNORE_ON_CONFLICT" },
-		{ static_cast<uint32_t>(OnCreateConflict::REPLACE_ON_CONFLICT), "REPLACE_ON_CONFLICT" },
-		{ static_cast<uint32_t>(OnCreateConflict::ALTER_ON_CONFLICT), "ALTER_ON_CONFLICT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OnCreateConflict>(OnCreateConflict value) {
-	return StringUtil::EnumToString(GetOnCreateConflictValues(), 4, "OnCreateConflict", static_cast<uint32_t>(value));
-}
-
-template<>
-OnCreateConflict EnumUtil::FromString<OnCreateConflict>(const char *value) {
-	return static_cast<OnCreateConflict>(StringUtil::StringToEnum(GetOnCreateConflictValues(), 4, "OnCreateConflict", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOnEntryNotFoundValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OnEntryNotFound::THROW_EXCEPTION), "THROW_EXCEPTION" },
-		{ static_cast<uint32_t>(OnEntryNotFound::RETURN_NULL), "RETURN_NULL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OnEntryNotFound>(OnEntryNotFound value) {
-	return StringUtil::EnumToString(GetOnEntryNotFoundValues(), 2, "OnEntryNotFound", static_cast<uint32_t>(value));
-}
-
-template<>
-OnEntryNotFound EnumUtil::FromString<OnEntryNotFound>(const char *value) {
-	return static_cast<OnEntryNotFound>(StringUtil::StringToEnum(GetOnEntryNotFoundValues(), 2, "OnEntryNotFound", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOperatorFinalizeResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OperatorFinalizeResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
-		{ static_cast<uint32_t>(OperatorFinalizeResultType::FINISHED), "FINISHED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OperatorFinalizeResultType>(OperatorFinalizeResultType value) {
-	return StringUtil::EnumToString(GetOperatorFinalizeResultTypeValues(), 2, "OperatorFinalizeResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-OperatorFinalizeResultType EnumUtil::FromString<OperatorFinalizeResultType>(const char *value) {
-	return static_cast<OperatorFinalizeResultType>(StringUtil::StringToEnum(GetOperatorFinalizeResultTypeValues(), 2, "OperatorFinalizeResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOperatorResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OperatorResultType::NEED_MORE_INPUT), "NEED_MORE_INPUT" },
-		{ static_cast<uint32_t>(OperatorResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
-		{ static_cast<uint32_t>(OperatorResultType::FINISHED), "FINISHED" },
-		{ static_cast<uint32_t>(OperatorResultType::BLOCKED), "BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OperatorResultType>(OperatorResultType value) {
-	return StringUtil::EnumToString(GetOperatorResultTypeValues(), 4, "OperatorResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-OperatorResultType EnumUtil::FromString<OperatorResultType>(const char *value) {
-	return static_cast<OperatorResultType>(StringUtil::StringToEnum(GetOperatorResultTypeValues(), 4, "OperatorResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOptimizerTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OptimizerType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(OptimizerType::EXPRESSION_REWRITER), "EXPRESSION_REWRITER" },
-		{ static_cast<uint32_t>(OptimizerType::FILTER_PULLUP), "FILTER_PULLUP" },
-		{ static_cast<uint32_t>(OptimizerType::FILTER_PUSHDOWN), "FILTER_PUSHDOWN" },
-		{ static_cast<uint32_t>(OptimizerType::EMPTY_RESULT_PULLUP), "EMPTY_RESULT_PULLUP" },
-		{ static_cast<uint32_t>(OptimizerType::CTE_FILTER_PUSHER), "CTE_FILTER_PUSHER" },
-		{ static_cast<uint32_t>(OptimizerType::REGEX_RANGE), "REGEX_RANGE" },
-		{ static_cast<uint32_t>(OptimizerType::IN_CLAUSE), "IN_CLAUSE" },
-		{ static_cast<uint32_t>(OptimizerType::JOIN_ORDER), "JOIN_ORDER" },
-		{ static_cast<uint32_t>(OptimizerType::DELIMINATOR), "DELIMINATOR" },
-		{ static_cast<uint32_t>(OptimizerType::UNNEST_REWRITER), "UNNEST_REWRITER" },
-		{ static_cast<uint32_t>(OptimizerType::UNUSED_COLUMNS), "UNUSED_COLUMNS" },
-		{ static_cast<uint32_t>(OptimizerType::STATISTICS_PROPAGATION), "STATISTICS_PROPAGATION" },
-		{ static_cast<uint32_t>(OptimizerType::COMMON_SUBEXPRESSIONS), "COMMON_SUBEXPRESSIONS" },
-		{ static_cast<uint32_t>(OptimizerType::COMMON_AGGREGATE), "COMMON_AGGREGATE" },
-		{ static_cast<uint32_t>(OptimizerType::COLUMN_LIFETIME), "COLUMN_LIFETIME" },
-		{ static_cast<uint32_t>(OptimizerType::BUILD_SIDE_PROBE_SIDE), "BUILD_SIDE_PROBE_SIDE" },
-		{ static_cast<uint32_t>(OptimizerType::LIMIT_PUSHDOWN), "LIMIT_PUSHDOWN" },
-		{ static_cast<uint32_t>(OptimizerType::TOP_N), "TOP_N" },
-		{ static_cast<uint32_t>(OptimizerType::COMPRESSED_MATERIALIZATION), "COMPRESSED_MATERIALIZATION" },
-		{ static_cast<uint32_t>(OptimizerType::DUPLICATE_GROUPS), "DUPLICATE_GROUPS" },
-		{ static_cast<uint32_t>(OptimizerType::REORDER_FILTER), "REORDER_FILTER" },
-		{ static_cast<uint32_t>(OptimizerType::SAMPLING_PUSHDOWN), "SAMPLING_PUSHDOWN" },
-		{ static_cast<uint32_t>(OptimizerType::JOIN_FILTER_PUSHDOWN), "JOIN_FILTER_PUSHDOWN" },
-		{ static_cast<uint32_t>(OptimizerType::EXTENSION), "EXTENSION" },
-		{ static_cast<uint32_t>(OptimizerType::MATERIALIZED_CTE), "MATERIALIZED_CTE" },
-		{ static_cast<uint32_t>(OptimizerType::SUM_REWRITER), "SUM_REWRITER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OptimizerType>(OptimizerType value) {
-	return StringUtil::EnumToString(GetOptimizerTypeValues(), 27, "OptimizerType", static_cast<uint32_t>(value));
-}
-
-template<>
-OptimizerType EnumUtil::FromString<OptimizerType>(const char *value) {
-	return static_cast<OptimizerType>(StringUtil::StringToEnum(GetOptimizerTypeValues(), 27, "OptimizerType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOrderByNullTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OrderByNullType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(OrderByNullType::ORDER_DEFAULT), "ORDER_DEFAULT" },
-		{ static_cast<uint32_t>(OrderByNullType::ORDER_DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(OrderByNullType::NULLS_FIRST), "NULLS_FIRST" },
-		{ static_cast<uint32_t>(OrderByNullType::NULLS_FIRST), "NULLS FIRST" },
-		{ static_cast<uint32_t>(OrderByNullType::NULLS_LAST), "NULLS_LAST" },
-		{ static_cast<uint32_t>(OrderByNullType::NULLS_LAST), "NULLS LAST" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OrderByNullType>(OrderByNullType value) {
-	return StringUtil::EnumToString(GetOrderByNullTypeValues(), 7, "OrderByNullType", static_cast<uint32_t>(value));
-}
-
-template<>
-OrderByNullType EnumUtil::FromString<OrderByNullType>(const char *value) {
-	return static_cast<OrderByNullType>(StringUtil::StringToEnum(GetOrderByNullTypeValues(), 7, "OrderByNullType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOrderPreservationTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OrderPreservationType::NO_ORDER), "NO_ORDER" },
-		{ static_cast<uint32_t>(OrderPreservationType::INSERTION_ORDER), "INSERTION_ORDER" },
-		{ static_cast<uint32_t>(OrderPreservationType::FIXED_ORDER), "FIXED_ORDER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OrderPreservationType>(OrderPreservationType value) {
-	return StringUtil::EnumToString(GetOrderPreservationTypeValues(), 3, "OrderPreservationType", static_cast<uint32_t>(value));
-}
-
-template<>
-OrderPreservationType EnumUtil::FromString<OrderPreservationType>(const char *value) {
-	return static_cast<OrderPreservationType>(StringUtil::StringToEnum(GetOrderPreservationTypeValues(), 3, "OrderPreservationType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOrderTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OrderType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(OrderType::ORDER_DEFAULT), "ORDER_DEFAULT" },
-		{ static_cast<uint32_t>(OrderType::ORDER_DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(OrderType::ASCENDING), "ASCENDING" },
-		{ static_cast<uint32_t>(OrderType::ASCENDING), "ASC" },
-		{ static_cast<uint32_t>(OrderType::DESCENDING), "DESCENDING" },
-		{ static_cast<uint32_t>(OrderType::DESCENDING), "DESC" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OrderType>(OrderType value) {
-	return StringUtil::EnumToString(GetOrderTypeValues(), 7, "OrderType", static_cast<uint32_t>(value));
-}
-
-template<>
-OrderType EnumUtil::FromString<OrderType>(const char *value) {
-	return static_cast<OrderType>(StringUtil::StringToEnum(GetOrderTypeValues(), 7, "OrderType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetOutputStreamValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(OutputStream::STREAM_STDOUT), "STREAM_STDOUT" },
-		{ static_cast<uint32_t>(OutputStream::STREAM_STDERR), "STREAM_STDERR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<OutputStream>(OutputStream value) {
-	return StringUtil::EnumToString(GetOutputStreamValues(), 2, "OutputStream", static_cast<uint32_t>(value));
-}
-
-template<>
-OutputStream EnumUtil::FromString<OutputStream>(const char *value) {
-	return static_cast<OutputStream>(StringUtil::StringToEnum(GetOutputStreamValues(), 2, "OutputStream", value));
-}
-
-const StringUtil::EnumStringLiteral *GetParseInfoTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ParseInfoType::ALTER_INFO), "ALTER_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::ATTACH_INFO), "ATTACH_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::COPY_INFO), "COPY_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::CREATE_INFO), "CREATE_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::CREATE_SECRET_INFO), "CREATE_SECRET_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::DETACH_INFO), "DETACH_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::DROP_INFO), "DROP_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::BOUND_EXPORT_DATA), "BOUND_EXPORT_DATA" },
-		{ static_cast<uint32_t>(ParseInfoType::LOAD_INFO), "LOAD_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::PRAGMA_INFO), "PRAGMA_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::SHOW_SELECT_INFO), "SHOW_SELECT_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::TRANSACTION_INFO), "TRANSACTION_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::VACUUM_INFO), "VACUUM_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::COMMENT_ON_INFO), "COMMENT_ON_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::COMMENT_ON_COLUMN_INFO), "COMMENT_ON_COLUMN_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::COPY_DATABASE_INFO), "COPY_DATABASE_INFO" },
-		{ static_cast<uint32_t>(ParseInfoType::UPDATE_EXTENSIONS_INFO), "UPDATE_EXTENSIONS_INFO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value) {
-	return StringUtil::EnumToString(GetParseInfoTypeValues(), 17, "ParseInfoType", static_cast<uint32_t>(value));
-}
-
-template<>
-ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value) {
-	return static_cast<ParseInfoType>(StringUtil::StringToEnum(GetParseInfoTypeValues(), 17, "ParseInfoType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetParserExtensionResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ParserExtensionResultType::PARSE_SUCCESSFUL), "PARSE_SUCCESSFUL" },
-		{ static_cast<uint32_t>(ParserExtensionResultType::DISPLAY_ORIGINAL_ERROR), "DISPLAY_ORIGINAL_ERROR" },
-		{ static_cast<uint32_t>(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), "DISPLAY_EXTENSION_ERROR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value) {
-	return StringUtil::EnumToString(GetParserExtensionResultTypeValues(), 3, "ParserExtensionResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-ParserExtensionResultType EnumUtil::FromString<ParserExtensionResultType>(const char *value) {
-	return static_cast<ParserExtensionResultType>(StringUtil::StringToEnum(GetParserExtensionResultTypeValues(), 3, "ParserExtensionResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPartitionSortStageValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PartitionSortStage::INIT), "INIT" },
-		{ static_cast<uint32_t>(PartitionSortStage::SCAN), "SCAN" },
-		{ static_cast<uint32_t>(PartitionSortStage::PREPARE), "PREPARE" },
-		{ static_cast<uint32_t>(PartitionSortStage::MERGE), "MERGE" },
-		{ static_cast<uint32_t>(PartitionSortStage::SORTED), "SORTED" },
-		{ static_cast<uint32_t>(PartitionSortStage::FINISHED), "FINISHED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PartitionSortStage>(PartitionSortStage value) {
-	return StringUtil::EnumToString(GetPartitionSortStageValues(), 6, "PartitionSortStage", static_cast<uint32_t>(value));
-}
-
-template<>
-PartitionSortStage EnumUtil::FromString<PartitionSortStage>(const char *value) {
-	return static_cast<PartitionSortStage>(StringUtil::StringToEnum(GetPartitionSortStageValues(), 6, "PartitionSortStage", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPartitionedColumnDataTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PartitionedColumnDataType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(PartitionedColumnDataType::RADIX), "RADIX" },
-		{ static_cast<uint32_t>(PartitionedColumnDataType::HIVE), "HIVE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PartitionedColumnDataType>(PartitionedColumnDataType value) {
-	return StringUtil::EnumToString(GetPartitionedColumnDataTypeValues(), 3, "PartitionedColumnDataType", static_cast<uint32_t>(value));
-}
-
-template<>
-PartitionedColumnDataType EnumUtil::FromString<PartitionedColumnDataType>(const char *value) {
-	return static_cast<PartitionedColumnDataType>(StringUtil::StringToEnum(GetPartitionedColumnDataTypeValues(), 3, "PartitionedColumnDataType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPartitionedTupleDataTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PartitionedTupleDataType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(PartitionedTupleDataType::RADIX), "RADIX" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PartitionedTupleDataType>(PartitionedTupleDataType value) {
-	return StringUtil::EnumToString(GetPartitionedTupleDataTypeValues(), 2, "PartitionedTupleDataType", static_cast<uint32_t>(value));
-}
-
-template<>
-PartitionedTupleDataType EnumUtil::FromString<PartitionedTupleDataType>(const char *value) {
-	return static_cast<PartitionedTupleDataType>(StringUtil::StringToEnum(GetPartitionedTupleDataTypeValues(), 2, "PartitionedTupleDataType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPendingExecutionResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PendingExecutionResult::RESULT_READY), "RESULT_READY" },
-		{ static_cast<uint32_t>(PendingExecutionResult::RESULT_NOT_READY), "RESULT_NOT_READY" },
-		{ static_cast<uint32_t>(PendingExecutionResult::EXECUTION_ERROR), "EXECUTION_ERROR" },
-		{ static_cast<uint32_t>(PendingExecutionResult::BLOCKED), "BLOCKED" },
-		{ static_cast<uint32_t>(PendingExecutionResult::NO_TASKS_AVAILABLE), "NO_TASKS_AVAILABLE" },
-		{ static_cast<uint32_t>(PendingExecutionResult::EXECUTION_FINISHED), "EXECUTION_FINISHED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PendingExecutionResult>(PendingExecutionResult value) {
-	return StringUtil::EnumToString(GetPendingExecutionResultValues(), 6, "PendingExecutionResult", static_cast<uint32_t>(value));
-}
-
-template<>
-PendingExecutionResult EnumUtil::FromString<PendingExecutionResult>(const char *value) {
-	return static_cast<PendingExecutionResult>(StringUtil::StringToEnum(GetPendingExecutionResultValues(), 6, "PendingExecutionResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPhysicalOperatorTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PhysicalOperatorType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::ORDER_BY), "ORDER_BY" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::LIMIT), "LIMIT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::STREAMING_LIMIT), "STREAMING_LIMIT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::LIMIT_PERCENT), "LIMIT_PERCENT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::TOP_N), "TOP_N" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::WINDOW), "WINDOW" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::UNNEST), "UNNEST" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::UNGROUPED_AGGREGATE), "UNGROUPED_AGGREGATE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::HASH_GROUP_BY), "HASH_GROUP_BY" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PERFECT_HASH_GROUP_BY), "PERFECT_HASH_GROUP_BY" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PARTITIONED_AGGREGATE), "PARTITIONED_AGGREGATE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::FILTER), "FILTER" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PROJECTION), "PROJECTION" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::COPY_TO_FILE), "COPY_TO_FILE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::BATCH_COPY_TO_FILE), "BATCH_COPY_TO_FILE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::RESERVOIR_SAMPLE), "RESERVOIR_SAMPLE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::STREAMING_SAMPLE), "STREAMING_SAMPLE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::STREAMING_WINDOW), "STREAMING_WINDOW" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PIVOT), "PIVOT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::COPY_DATABASE), "COPY_DATABASE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::TABLE_SCAN), "TABLE_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::DUMMY_SCAN), "DUMMY_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::COLUMN_DATA_SCAN), "COLUMN_DATA_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CHUNK_SCAN), "CHUNK_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::RECURSIVE_CTE_SCAN), "RECURSIVE_CTE_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CTE_SCAN), "CTE_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::DELIM_SCAN), "DELIM_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EXPRESSION_SCAN), "EXPRESSION_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::POSITIONAL_SCAN), "POSITIONAL_SCAN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::BLOCKWISE_NL_JOIN), "BLOCKWISE_NL_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::NESTED_LOOP_JOIN), "NESTED_LOOP_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::HASH_JOIN), "HASH_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CROSS_PRODUCT), "CROSS_PRODUCT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PIECEWISE_MERGE_JOIN), "PIECEWISE_MERGE_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::IE_JOIN), "IE_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::LEFT_DELIM_JOIN), "LEFT_DELIM_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::RIGHT_DELIM_JOIN), "RIGHT_DELIM_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::POSITIONAL_JOIN), "POSITIONAL_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::ASOF_JOIN), "ASOF_JOIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::UNION), "UNION" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::RECURSIVE_CTE), "RECURSIVE_CTE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CTE), "CTE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::INSERT), "INSERT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::BATCH_INSERT), "BATCH_INSERT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::DELETE_OPERATOR), "DELETE_OPERATOR" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::UPDATE), "UPDATE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_TABLE), "CREATE_TABLE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_TABLE_AS), "CREATE_TABLE_AS" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::BATCH_CREATE_TABLE_AS), "BATCH_CREATE_TABLE_AS" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_INDEX), "CREATE_INDEX" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::ALTER), "ALTER" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_SEQUENCE), "CREATE_SEQUENCE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_VIEW), "CREATE_VIEW" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_SCHEMA), "CREATE_SCHEMA" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_MACRO), "CREATE_MACRO" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::DROP), "DROP" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PRAGMA), "PRAGMA" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::TRANSACTION), "TRANSACTION" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_TYPE), "CREATE_TYPE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::ATTACH), "ATTACH" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::DETACH), "DETACH" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EXPLAIN), "EXPLAIN" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EXPLAIN_ANALYZE), "EXPLAIN_ANALYZE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EMPTY_RESULT), "EMPTY_RESULT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EXECUTE), "EXECUTE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::PREPARE), "PREPARE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::VACUUM), "VACUUM" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EXPORT), "EXPORT" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::SET), "SET" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::SET_VARIABLE), "SET_VARIABLE" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::LOAD), "LOAD" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::INOUT_FUNCTION), "INOUT_FUNCTION" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::RESULT_COLLECTOR), "RESULT_COLLECTOR" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::RESET), "RESET" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::EXTENSION), "EXTENSION" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::VERIFY_VECTOR), "VERIFY_VECTOR" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::UPDATE_EXTENSIONS), "UPDATE_EXTENSIONS" },
-		{ static_cast<uint32_t>(PhysicalOperatorType::CREATE_SECRET), "CREATE_SECRET" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PhysicalOperatorType>(PhysicalOperatorType value) {
-	return StringUtil::EnumToString(GetPhysicalOperatorTypeValues(), 79, "PhysicalOperatorType", static_cast<uint32_t>(value));
-}
-
-template<>
-PhysicalOperatorType EnumUtil::FromString<PhysicalOperatorType>(const char *value) {
-	return static_cast<PhysicalOperatorType>(StringUtil::StringToEnum(GetPhysicalOperatorTypeValues(), 79, "PhysicalOperatorType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPhysicalTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PhysicalType::BOOL), "BOOL" },
-		{ static_cast<uint32_t>(PhysicalType::UINT8), "UINT8" },
-		{ static_cast<uint32_t>(PhysicalType::INT8), "INT8" },
-		{ static_cast<uint32_t>(PhysicalType::UINT16), "UINT16" },
-		{ static_cast<uint32_t>(PhysicalType::INT16), "INT16" },
-		{ static_cast<uint32_t>(PhysicalType::UINT32), "UINT32" },
-		{ static_cast<uint32_t>(PhysicalType::INT32), "INT32" },
-		{ static_cast<uint32_t>(PhysicalType::UINT64), "UINT64" },
-		{ static_cast<uint32_t>(PhysicalType::INT64), "INT64" },
-		{ static_cast<uint32_t>(PhysicalType::FLOAT), "FLOAT" },
-		{ static_cast<uint32_t>(PhysicalType::DOUBLE), "DOUBLE" },
-		{ static_cast<uint32_t>(PhysicalType::INTERVAL), "INTERVAL" },
-		{ static_cast<uint32_t>(PhysicalType::LIST), "LIST" },
-		{ static_cast<uint32_t>(PhysicalType::STRUCT), "STRUCT" },
-		{ static_cast<uint32_t>(PhysicalType::ARRAY), "ARRAY" },
-		{ static_cast<uint32_t>(PhysicalType::VARCHAR), "VARCHAR" },
-		{ static_cast<uint32_t>(PhysicalType::UINT128), "UINT128" },
-		{ static_cast<uint32_t>(PhysicalType::INT128), "INT128" },
-		{ static_cast<uint32_t>(PhysicalType::UNKNOWN), "UNKNOWN" },
-		{ static_cast<uint32_t>(PhysicalType::BIT), "BIT" },
-		{ static_cast<uint32_t>(PhysicalType::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PhysicalType>(PhysicalType value) {
-	return StringUtil::EnumToString(GetPhysicalTypeValues(), 21, "PhysicalType", static_cast<uint32_t>(value));
-}
-
-template<>
-PhysicalType EnumUtil::FromString<PhysicalType>(const char *value) {
-	return static_cast<PhysicalType>(StringUtil::StringToEnum(GetPhysicalTypeValues(), 21, "PhysicalType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPragmaTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PragmaType::PRAGMA_STATEMENT), "PRAGMA_STATEMENT" },
-		{ static_cast<uint32_t>(PragmaType::PRAGMA_CALL), "PRAGMA_CALL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PragmaType>(PragmaType value) {
-	return StringUtil::EnumToString(GetPragmaTypeValues(), 2, "PragmaType", static_cast<uint32_t>(value));
-}
-
-template<>
-PragmaType EnumUtil::FromString<PragmaType>(const char *value) {
-	return static_cast<PragmaType>(StringUtil::StringToEnum(GetPragmaTypeValues(), 2, "PragmaType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPreparedParamTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PreparedParamType::AUTO_INCREMENT), "AUTO_INCREMENT" },
-		{ static_cast<uint32_t>(PreparedParamType::POSITIONAL), "POSITIONAL" },
-		{ static_cast<uint32_t>(PreparedParamType::NAMED), "NAMED" },
-		{ static_cast<uint32_t>(PreparedParamType::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PreparedParamType>(PreparedParamType value) {
-	return StringUtil::EnumToString(GetPreparedParamTypeValues(), 4, "PreparedParamType", static_cast<uint32_t>(value));
-}
-
-template<>
-PreparedParamType EnumUtil::FromString<PreparedParamType>(const char *value) {
-	return static_cast<PreparedParamType>(StringUtil::StringToEnum(GetPreparedParamTypeValues(), 4, "PreparedParamType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetPreparedStatementModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(PreparedStatementMode::PREPARE_ONLY), "PREPARE_ONLY" },
-		{ static_cast<uint32_t>(PreparedStatementMode::PREPARE_AND_EXECUTE), "PREPARE_AND_EXECUTE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<PreparedStatementMode>(PreparedStatementMode value) {
-	return StringUtil::EnumToString(GetPreparedStatementModeValues(), 2, "PreparedStatementMode", static_cast<uint32_t>(value));
-}
-
-template<>
-PreparedStatementMode EnumUtil::FromString<PreparedStatementMode>(const char *value) {
-	return static_cast<PreparedStatementMode>(StringUtil::StringToEnum(GetPreparedStatementModeValues(), 2, "PreparedStatementMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetProfilerPrintFormatValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ProfilerPrintFormat::QUERY_TREE), "QUERY_TREE" },
-		{ static_cast<uint32_t>(ProfilerPrintFormat::JSON), "JSON" },
-		{ static_cast<uint32_t>(ProfilerPrintFormat::QUERY_TREE_OPTIMIZER), "QUERY_TREE_OPTIMIZER" },
-		{ static_cast<uint32_t>(ProfilerPrintFormat::NO_OUTPUT), "NO_OUTPUT" },
-		{ static_cast<uint32_t>(ProfilerPrintFormat::HTML), "HTML" },
-		{ static_cast<uint32_t>(ProfilerPrintFormat::GRAPHVIZ), "GRAPHVIZ" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ProfilerPrintFormat>(ProfilerPrintFormat value) {
-	return StringUtil::EnumToString(GetProfilerPrintFormatValues(), 6, "ProfilerPrintFormat", static_cast<uint32_t>(value));
-}
-
-template<>
-ProfilerPrintFormat EnumUtil::FromString<ProfilerPrintFormat>(const char *value) {
-	return static_cast<ProfilerPrintFormat>(StringUtil::StringToEnum(GetProfilerPrintFormatValues(), 6, "ProfilerPrintFormat", value));
-}
-
-const StringUtil::EnumStringLiteral *GetQuantileSerializationTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(QuantileSerializationType::NON_DECIMAL), "NON_DECIMAL" },
-		{ static_cast<uint32_t>(QuantileSerializationType::DECIMAL_DISCRETE), "DECIMAL_DISCRETE" },
-		{ static_cast<uint32_t>(QuantileSerializationType::DECIMAL_DISCRETE_LIST), "DECIMAL_DISCRETE_LIST" },
-		{ static_cast<uint32_t>(QuantileSerializationType::DECIMAL_CONTINUOUS), "DECIMAL_CONTINUOUS" },
-		{ static_cast<uint32_t>(QuantileSerializationType::DECIMAL_CONTINUOUS_LIST), "DECIMAL_CONTINUOUS_LIST" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<QuantileSerializationType>(QuantileSerializationType value) {
-	return StringUtil::EnumToString(GetQuantileSerializationTypeValues(), 5, "QuantileSerializationType", static_cast<uint32_t>(value));
-}
-
-template<>
-QuantileSerializationType EnumUtil::FromString<QuantileSerializationType>(const char *value) {
-	return static_cast<QuantileSerializationType>(StringUtil::StringToEnum(GetQuantileSerializationTypeValues(), 5, "QuantileSerializationType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetQueryNodeTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(QueryNodeType::SELECT_NODE), "SELECT_NODE" },
-		{ static_cast<uint32_t>(QueryNodeType::SET_OPERATION_NODE), "SET_OPERATION_NODE" },
-		{ static_cast<uint32_t>(QueryNodeType::BOUND_SUBQUERY_NODE), "BOUND_SUBQUERY_NODE" },
-		{ static_cast<uint32_t>(QueryNodeType::RECURSIVE_CTE_NODE), "RECURSIVE_CTE_NODE" },
-		{ static_cast<uint32_t>(QueryNodeType::CTE_NODE), "CTE_NODE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<QueryNodeType>(QueryNodeType value) {
-	return StringUtil::EnumToString(GetQueryNodeTypeValues(), 5, "QueryNodeType", static_cast<uint32_t>(value));
-}
-
-template<>
-QueryNodeType EnumUtil::FromString<QueryNodeType>(const char *value) {
-	return static_cast<QueryNodeType>(StringUtil::StringToEnum(GetQueryNodeTypeValues(), 5, "QueryNodeType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetQueryResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(QueryResultType::MATERIALIZED_RESULT), "MATERIALIZED_RESULT" },
-		{ static_cast<uint32_t>(QueryResultType::STREAM_RESULT), "STREAM_RESULT" },
-		{ static_cast<uint32_t>(QueryResultType::PENDING_RESULT), "PENDING_RESULT" },
-		{ static_cast<uint32_t>(QueryResultType::ARROW_RESULT), "ARROW_RESULT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<QueryResultType>(QueryResultType value) {
-	return StringUtil::EnumToString(GetQueryResultTypeValues(), 4, "QueryResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-QueryResultType EnumUtil::FromString<QueryResultType>(const char *value) {
-	return static_cast<QueryResultType>(StringUtil::StringToEnum(GetQueryResultTypeValues(), 4, "QueryResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetQuoteRuleValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(QuoteRule::QUOTES_RFC), "QUOTES_RFC" },
-		{ static_cast<uint32_t>(QuoteRule::QUOTES_OTHER), "QUOTES_OTHER" },
-		{ static_cast<uint32_t>(QuoteRule::NO_QUOTES), "NO_QUOTES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<QuoteRule>(QuoteRule value) {
-	return StringUtil::EnumToString(GetQuoteRuleValues(), 3, "QuoteRule", static_cast<uint32_t>(value));
-}
-
-template<>
-QuoteRule EnumUtil::FromString<QuoteRule>(const char *value) {
-	return static_cast<QuoteRule>(StringUtil::StringToEnum(GetQuoteRuleValues(), 3, "QuoteRule", value));
-}
-
-const StringUtil::EnumStringLiteral *GetRelationTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(RelationType::INVALID_RELATION), "INVALID_RELATION" },
-		{ static_cast<uint32_t>(RelationType::TABLE_RELATION), "TABLE_RELATION" },
-		{ static_cast<uint32_t>(RelationType::PROJECTION_RELATION), "PROJECTION_RELATION" },
-		{ static_cast<uint32_t>(RelationType::FILTER_RELATION), "FILTER_RELATION" },
-		{ static_cast<uint32_t>(RelationType::EXPLAIN_RELATION), "EXPLAIN_RELATION" },
-		{ static_cast<uint32_t>(RelationType::CROSS_PRODUCT_RELATION), "CROSS_PRODUCT_RELATION" },
-		{ static_cast<uint32_t>(RelationType::JOIN_RELATION), "JOIN_RELATION" },
-		{ static_cast<uint32_t>(RelationType::AGGREGATE_RELATION), "AGGREGATE_RELATION" },
-		{ static_cast<uint32_t>(RelationType::SET_OPERATION_RELATION), "SET_OPERATION_RELATION" },
-		{ static_cast<uint32_t>(RelationType::DISTINCT_RELATION), "DISTINCT_RELATION" },
-		{ static_cast<uint32_t>(RelationType::LIMIT_RELATION), "LIMIT_RELATION" },
-		{ static_cast<uint32_t>(RelationType::ORDER_RELATION), "ORDER_RELATION" },
-		{ static_cast<uint32_t>(RelationType::CREATE_VIEW_RELATION), "CREATE_VIEW_RELATION" },
-		{ static_cast<uint32_t>(RelationType::CREATE_TABLE_RELATION), "CREATE_TABLE_RELATION" },
-		{ static_cast<uint32_t>(RelationType::INSERT_RELATION), "INSERT_RELATION" },
-		{ static_cast<uint32_t>(RelationType::VALUE_LIST_RELATION), "VALUE_LIST_RELATION" },
-		{ static_cast<uint32_t>(RelationType::MATERIALIZED_RELATION), "MATERIALIZED_RELATION" },
-		{ static_cast<uint32_t>(RelationType::DELETE_RELATION), "DELETE_RELATION" },
-		{ static_cast<uint32_t>(RelationType::UPDATE_RELATION), "UPDATE_RELATION" },
-		{ static_cast<uint32_t>(RelationType::WRITE_CSV_RELATION), "WRITE_CSV_RELATION" },
-		{ static_cast<uint32_t>(RelationType::WRITE_PARQUET_RELATION), "WRITE_PARQUET_RELATION" },
-		{ static_cast<uint32_t>(RelationType::READ_CSV_RELATION), "READ_CSV_RELATION" },
-		{ static_cast<uint32_t>(RelationType::SUBQUERY_RELATION), "SUBQUERY_RELATION" },
-		{ static_cast<uint32_t>(RelationType::TABLE_FUNCTION_RELATION), "TABLE_FUNCTION_RELATION" },
-		{ static_cast<uint32_t>(RelationType::VIEW_RELATION), "VIEW_RELATION" },
-		{ static_cast<uint32_t>(RelationType::QUERY_RELATION), "QUERY_RELATION" },
-		{ static_cast<uint32_t>(RelationType::DELIM_JOIN_RELATION), "DELIM_JOIN_RELATION" },
-		{ static_cast<uint32_t>(RelationType::DELIM_GET_RELATION), "DELIM_GET_RELATION" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<RelationType>(RelationType value) {
-	return StringUtil::EnumToString(GetRelationTypeValues(), 28, "RelationType", static_cast<uint32_t>(value));
-}
-
-template<>
-RelationType EnumUtil::FromString<RelationType>(const char *value) {
-	return static_cast<RelationType>(StringUtil::StringToEnum(GetRelationTypeValues(), 28, "RelationType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetRenderModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(RenderMode::ROWS), "ROWS" },
-		{ static_cast<uint32_t>(RenderMode::COLUMNS), "COLUMNS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<RenderMode>(RenderMode value) {
-	return StringUtil::EnumToString(GetRenderModeValues(), 2, "RenderMode", static_cast<uint32_t>(value));
-}
-
-template<>
-RenderMode EnumUtil::FromString<RenderMode>(const char *value) {
-	return static_cast<RenderMode>(StringUtil::StringToEnum(GetRenderModeValues(), 2, "RenderMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetResultModifierTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ResultModifierType::LIMIT_MODIFIER), "LIMIT_MODIFIER" },
-		{ static_cast<uint32_t>(ResultModifierType::ORDER_MODIFIER), "ORDER_MODIFIER" },
-		{ static_cast<uint32_t>(ResultModifierType::DISTINCT_MODIFIER), "DISTINCT_MODIFIER" },
-		{ static_cast<uint32_t>(ResultModifierType::LIMIT_PERCENT_MODIFIER), "LIMIT_PERCENT_MODIFIER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ResultModifierType>(ResultModifierType value) {
-	return StringUtil::EnumToString(GetResultModifierTypeValues(), 4, "ResultModifierType", static_cast<uint32_t>(value));
-}
-
-template<>
-ResultModifierType EnumUtil::FromString<ResultModifierType>(const char *value) {
-	return static_cast<ResultModifierType>(StringUtil::StringToEnum(GetResultModifierTypeValues(), 4, "ResultModifierType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSampleMethodValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SampleMethod::SYSTEM_SAMPLE), "System" },
-		{ static_cast<uint32_t>(SampleMethod::BERNOULLI_SAMPLE), "Bernoulli" },
-		{ static_cast<uint32_t>(SampleMethod::RESERVOIR_SAMPLE), "Reservoir" },
-		{ static_cast<uint32_t>(SampleMethod::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SampleMethod>(SampleMethod value) {
-	return StringUtil::EnumToString(GetSampleMethodValues(), 4, "SampleMethod", static_cast<uint32_t>(value));
-}
-
-template<>
-SampleMethod EnumUtil::FromString<SampleMethod>(const char *value) {
-	return static_cast<SampleMethod>(StringUtil::StringToEnum(GetSampleMethodValues(), 4, "SampleMethod", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSampleTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SampleType::BLOCKING_SAMPLE), "BLOCKING_SAMPLE" },
-		{ static_cast<uint32_t>(SampleType::RESERVOIR_SAMPLE), "RESERVOIR_SAMPLE" },
-		{ static_cast<uint32_t>(SampleType::RESERVOIR_PERCENTAGE_SAMPLE), "RESERVOIR_PERCENTAGE_SAMPLE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SampleType>(SampleType value) {
-	return StringUtil::EnumToString(GetSampleTypeValues(), 3, "SampleType", static_cast<uint32_t>(value));
-}
-
-template<>
-SampleType EnumUtil::FromString<SampleType>(const char *value) {
-	return static_cast<SampleType>(StringUtil::StringToEnum(GetSampleTypeValues(), 3, "SampleType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSamplingStateValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SamplingState::RANDOM), "RANDOM" },
-		{ static_cast<uint32_t>(SamplingState::RESERVOIR), "RESERVOIR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SamplingState>(SamplingState value) {
-	return StringUtil::EnumToString(GetSamplingStateValues(), 2, "SamplingState", static_cast<uint32_t>(value));
-}
-
-template<>
-SamplingState EnumUtil::FromString<SamplingState>(const char *value) {
-	return static_cast<SamplingState>(StringUtil::StringToEnum(GetSamplingStateValues(), 2, "SamplingState", value));
-}
-
-const StringUtil::EnumStringLiteral *GetScanTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ScanType::TABLE), "TABLE" },
-		{ static_cast<uint32_t>(ScanType::PARQUET), "PARQUET" },
-		{ static_cast<uint32_t>(ScanType::EXTERNAL), "EXTERNAL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ScanType>(ScanType value) {
-	return StringUtil::EnumToString(GetScanTypeValues(), 3, "ScanType", static_cast<uint32_t>(value));
-}
-
-template<>
-ScanType EnumUtil::FromString<ScanType>(const char *value) {
-	return static_cast<ScanType>(StringUtil::StringToEnum(GetScanTypeValues(), 3, "ScanType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSecretDisplayTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SecretDisplayType::REDACTED), "REDACTED" },
-		{ static_cast<uint32_t>(SecretDisplayType::UNREDACTED), "UNREDACTED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SecretDisplayType>(SecretDisplayType value) {
-	return StringUtil::EnumToString(GetSecretDisplayTypeValues(), 2, "SecretDisplayType", static_cast<uint32_t>(value));
-}
-
-template<>
-SecretDisplayType EnumUtil::FromString<SecretDisplayType>(const char *value) {
-	return static_cast<SecretDisplayType>(StringUtil::StringToEnum(GetSecretDisplayTypeValues(), 2, "SecretDisplayType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSecretPersistTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SecretPersistType::DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(SecretPersistType::TEMPORARY), "TEMPORARY" },
-		{ static_cast<uint32_t>(SecretPersistType::PERSISTENT), "PERSISTENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SecretPersistType>(SecretPersistType value) {
-	return StringUtil::EnumToString(GetSecretPersistTypeValues(), 3, "SecretPersistType", static_cast<uint32_t>(value));
-}
-
-template<>
-SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value) {
-	return static_cast<SecretPersistType>(StringUtil::StringToEnum(GetSecretPersistTypeValues(), 3, "SecretPersistType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSecretSerializationTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SecretSerializationType::CUSTOM), "CUSTOM" },
-		{ static_cast<uint32_t>(SecretSerializationType::KEY_VALUE_SECRET), "KEY_VALUE_SECRET" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SecretSerializationType>(SecretSerializationType value) {
-	return StringUtil::EnumToString(GetSecretSerializationTypeValues(), 2, "SecretSerializationType", static_cast<uint32_t>(value));
-}
-
-template<>
-SecretSerializationType EnumUtil::FromString<SecretSerializationType>(const char *value) {
-	return static_cast<SecretSerializationType>(StringUtil::StringToEnum(GetSecretSerializationTypeValues(), 2, "SecretSerializationType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSequenceInfoValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SequenceInfo::SEQ_START), "SEQ_START" },
-		{ static_cast<uint32_t>(SequenceInfo::SEQ_INC), "SEQ_INC" },
-		{ static_cast<uint32_t>(SequenceInfo::SEQ_MIN), "SEQ_MIN" },
-		{ static_cast<uint32_t>(SequenceInfo::SEQ_MAX), "SEQ_MAX" },
-		{ static_cast<uint32_t>(SequenceInfo::SEQ_CYCLE), "SEQ_CYCLE" },
-		{ static_cast<uint32_t>(SequenceInfo::SEQ_OWN), "SEQ_OWN" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value) {
-	return StringUtil::EnumToString(GetSequenceInfoValues(), 6, "SequenceInfo", static_cast<uint32_t>(value));
-}
-
-template<>
-SequenceInfo EnumUtil::FromString<SequenceInfo>(const char *value) {
-	return static_cast<SequenceInfo>(StringUtil::StringToEnum(GetSequenceInfoValues(), 6, "SequenceInfo", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSetOperationTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SetOperationType::NONE), "NONE" },
-		{ static_cast<uint32_t>(SetOperationType::UNION), "UNION" },
-		{ static_cast<uint32_t>(SetOperationType::EXCEPT), "EXCEPT" },
-		{ static_cast<uint32_t>(SetOperationType::INTERSECT), "INTERSECT" },
-		{ static_cast<uint32_t>(SetOperationType::UNION_BY_NAME), "UNION_BY_NAME" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SetOperationType>(SetOperationType value) {
-	return StringUtil::EnumToString(GetSetOperationTypeValues(), 5, "SetOperationType", static_cast<uint32_t>(value));
-}
-
-template<>
-SetOperationType EnumUtil::FromString<SetOperationType>(const char *value) {
-	return static_cast<SetOperationType>(StringUtil::StringToEnum(GetSetOperationTypeValues(), 5, "SetOperationType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSetScopeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SetScope::AUTOMATIC), "AUTOMATIC" },
-		{ static_cast<uint32_t>(SetScope::LOCAL), "LOCAL" },
-		{ static_cast<uint32_t>(SetScope::SESSION), "SESSION" },
-		{ static_cast<uint32_t>(SetScope::GLOBAL), "GLOBAL" },
-		{ static_cast<uint32_t>(SetScope::VARIABLE), "VARIABLE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SetScope>(SetScope value) {
-	return StringUtil::EnumToString(GetSetScopeValues(), 5, "SetScope", static_cast<uint32_t>(value));
-}
-
-template<>
-SetScope EnumUtil::FromString<SetScope>(const char *value) {
-	return static_cast<SetScope>(StringUtil::StringToEnum(GetSetScopeValues(), 5, "SetScope", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSetTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SetType::SET), "SET" },
-		{ static_cast<uint32_t>(SetType::RESET), "RESET" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SetType>(SetType value) {
-	return StringUtil::EnumToString(GetSetTypeValues(), 2, "SetType", static_cast<uint32_t>(value));
-}
-
-template<>
-SetType EnumUtil::FromString<SetType>(const char *value) {
-	return static_cast<SetType>(StringUtil::StringToEnum(GetSetTypeValues(), 2, "SetType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSettingScopeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SettingScope::GLOBAL), "GLOBAL" },
-		{ static_cast<uint32_t>(SettingScope::LOCAL), "LOCAL" },
-		{ static_cast<uint32_t>(SettingScope::SECRET), "SECRET" },
-		{ static_cast<uint32_t>(SettingScope::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SettingScope>(SettingScope value) {
-	return StringUtil::EnumToString(GetSettingScopeValues(), 4, "SettingScope", static_cast<uint32_t>(value));
-}
-
-template<>
-SettingScope EnumUtil::FromString<SettingScope>(const char *value) {
-	return static_cast<SettingScope>(StringUtil::StringToEnum(GetSettingScopeValues(), 4, "SettingScope", value));
-}
-
-const StringUtil::EnumStringLiteral *GetShowTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ShowType::SUMMARY), "SUMMARY" },
-		{ static_cast<uint32_t>(ShowType::DESCRIBE), "DESCRIBE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ShowType>(ShowType value) {
-	return StringUtil::EnumToString(GetShowTypeValues(), 2, "ShowType", static_cast<uint32_t>(value));
-}
-
-template<>
-ShowType EnumUtil::FromString<ShowType>(const char *value) {
-	return static_cast<ShowType>(StringUtil::StringToEnum(GetShowTypeValues(), 2, "ShowType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSimplifiedTokenTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER), "SIMPLIFIED_TOKEN_IDENTIFIER" },
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_NUMERIC_CONSTANT), "SIMPLIFIED_TOKEN_NUMERIC_CONSTANT" },
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_STRING_CONSTANT), "SIMPLIFIED_TOKEN_STRING_CONSTANT" },
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_OPERATOR), "SIMPLIFIED_TOKEN_OPERATOR" },
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_KEYWORD), "SIMPLIFIED_TOKEN_KEYWORD" },
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_COMMENT), "SIMPLIFIED_TOKEN_COMMENT" },
-		{ static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR), "SIMPLIFIED_TOKEN_ERROR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SimplifiedTokenType>(SimplifiedTokenType value) {
-	return StringUtil::EnumToString(GetSimplifiedTokenTypeValues(), 7, "SimplifiedTokenType", static_cast<uint32_t>(value));
-}
-
-template<>
-SimplifiedTokenType EnumUtil::FromString<SimplifiedTokenType>(const char *value) {
-	return static_cast<SimplifiedTokenType>(StringUtil::StringToEnum(GetSimplifiedTokenTypeValues(), 7, "SimplifiedTokenType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSinkCombineResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SinkCombineResultType::FINISHED), "FINISHED" },
-		{ static_cast<uint32_t>(SinkCombineResultType::BLOCKED), "BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SinkCombineResultType>(SinkCombineResultType value) {
-	return StringUtil::EnumToString(GetSinkCombineResultTypeValues(), 2, "SinkCombineResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-SinkCombineResultType EnumUtil::FromString<SinkCombineResultType>(const char *value) {
-	return static_cast<SinkCombineResultType>(StringUtil::StringToEnum(GetSinkCombineResultTypeValues(), 2, "SinkCombineResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSinkFinalizeTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SinkFinalizeType::READY), "READY" },
-		{ static_cast<uint32_t>(SinkFinalizeType::NO_OUTPUT_POSSIBLE), "NO_OUTPUT_POSSIBLE" },
-		{ static_cast<uint32_t>(SinkFinalizeType::BLOCKED), "BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SinkFinalizeType>(SinkFinalizeType value) {
-	return StringUtil::EnumToString(GetSinkFinalizeTypeValues(), 3, "SinkFinalizeType", static_cast<uint32_t>(value));
-}
-
-template<>
-SinkFinalizeType EnumUtil::FromString<SinkFinalizeType>(const char *value) {
-	return static_cast<SinkFinalizeType>(StringUtil::StringToEnum(GetSinkFinalizeTypeValues(), 3, "SinkFinalizeType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSinkNextBatchTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SinkNextBatchType::READY), "READY" },
-		{ static_cast<uint32_t>(SinkNextBatchType::BLOCKED), "BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SinkNextBatchType>(SinkNextBatchType value) {
-	return StringUtil::EnumToString(GetSinkNextBatchTypeValues(), 2, "SinkNextBatchType", static_cast<uint32_t>(value));
-}
-
-template<>
-SinkNextBatchType EnumUtil::FromString<SinkNextBatchType>(const char *value) {
-	return static_cast<SinkNextBatchType>(StringUtil::StringToEnum(GetSinkNextBatchTypeValues(), 2, "SinkNextBatchType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSinkResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SinkResultType::NEED_MORE_INPUT), "NEED_MORE_INPUT" },
-		{ static_cast<uint32_t>(SinkResultType::FINISHED), "FINISHED" },
-		{ static_cast<uint32_t>(SinkResultType::BLOCKED), "BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SinkResultType>(SinkResultType value) {
-	return StringUtil::EnumToString(GetSinkResultTypeValues(), 3, "SinkResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-SinkResultType EnumUtil::FromString<SinkResultType>(const char *value) {
-	return static_cast<SinkResultType>(StringUtil::StringToEnum(GetSinkResultTypeValues(), 3, "SinkResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSourceResultTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SourceResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
-		{ static_cast<uint32_t>(SourceResultType::FINISHED), "FINISHED" },
-		{ static_cast<uint32_t>(SourceResultType::BLOCKED), "BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SourceResultType>(SourceResultType value) {
-	return StringUtil::EnumToString(GetSourceResultTypeValues(), 3, "SourceResultType", static_cast<uint32_t>(value));
-}
-
-template<>
-SourceResultType EnumUtil::FromString<SourceResultType>(const char *value) {
-	return static_cast<SourceResultType>(StringUtil::StringToEnum(GetSourceResultTypeValues(), 3, "SourceResultType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetStatementReturnTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(StatementReturnType::QUERY_RESULT), "QUERY_RESULT" },
-		{ static_cast<uint32_t>(StatementReturnType::CHANGED_ROWS), "CHANGED_ROWS" },
-		{ static_cast<uint32_t>(StatementReturnType::NOTHING), "NOTHING" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<StatementReturnType>(StatementReturnType value) {
-	return StringUtil::EnumToString(GetStatementReturnTypeValues(), 3, "StatementReturnType", static_cast<uint32_t>(value));
-}
-
-template<>
-StatementReturnType EnumUtil::FromString<StatementReturnType>(const char *value) {
-	return static_cast<StatementReturnType>(StringUtil::StringToEnum(GetStatementReturnTypeValues(), 3, "StatementReturnType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetStatementTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(StatementType::INVALID_STATEMENT), "INVALID_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::SELECT_STATEMENT), "SELECT_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::INSERT_STATEMENT), "INSERT_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::UPDATE_STATEMENT), "UPDATE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::CREATE_STATEMENT), "CREATE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::DELETE_STATEMENT), "DELETE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::PREPARE_STATEMENT), "PREPARE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::EXECUTE_STATEMENT), "EXECUTE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::ALTER_STATEMENT), "ALTER_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::TRANSACTION_STATEMENT), "TRANSACTION_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::COPY_STATEMENT), "COPY_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::ANALYZE_STATEMENT), "ANALYZE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::VARIABLE_SET_STATEMENT), "VARIABLE_SET_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::CREATE_FUNC_STATEMENT), "CREATE_FUNC_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::EXPLAIN_STATEMENT), "EXPLAIN_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::DROP_STATEMENT), "DROP_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::EXPORT_STATEMENT), "EXPORT_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::PRAGMA_STATEMENT), "PRAGMA_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::VACUUM_STATEMENT), "VACUUM_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::CALL_STATEMENT), "CALL_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::SET_STATEMENT), "SET_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::LOAD_STATEMENT), "LOAD_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::RELATION_STATEMENT), "RELATION_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::EXTENSION_STATEMENT), "EXTENSION_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::LOGICAL_PLAN_STATEMENT), "LOGICAL_PLAN_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::ATTACH_STATEMENT), "ATTACH_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::DETACH_STATEMENT), "DETACH_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::MULTI_STATEMENT), "MULTI_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::COPY_DATABASE_STATEMENT), "COPY_DATABASE_STATEMENT" },
-		{ static_cast<uint32_t>(StatementType::UPDATE_EXTENSIONS_STATEMENT), "UPDATE_EXTENSIONS_STATEMENT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<StatementType>(StatementType value) {
-	return StringUtil::EnumToString(GetStatementTypeValues(), 30, "StatementType", static_cast<uint32_t>(value));
-}
-
-template<>
-StatementType EnumUtil::FromString<StatementType>(const char *value) {
-	return static_cast<StatementType>(StringUtil::StringToEnum(GetStatementTypeValues(), 30, "StatementType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetStatisticsTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(StatisticsType::NUMERIC_STATS), "NUMERIC_STATS" },
-		{ static_cast<uint32_t>(StatisticsType::STRING_STATS), "STRING_STATS" },
-		{ static_cast<uint32_t>(StatisticsType::LIST_STATS), "LIST_STATS" },
-		{ static_cast<uint32_t>(StatisticsType::STRUCT_STATS), "STRUCT_STATS" },
-		{ static_cast<uint32_t>(StatisticsType::BASE_STATS), "BASE_STATS" },
-		{ static_cast<uint32_t>(StatisticsType::ARRAY_STATS), "ARRAY_STATS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<StatisticsType>(StatisticsType value) {
-	return StringUtil::EnumToString(GetStatisticsTypeValues(), 6, "StatisticsType", static_cast<uint32_t>(value));
-}
-
-template<>
-StatisticsType EnumUtil::FromString<StatisticsType>(const char *value) {
-	return static_cast<StatisticsType>(StringUtil::StringToEnum(GetStatisticsTypeValues(), 6, "StatisticsType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetStatsInfoValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(StatsInfo::CAN_HAVE_NULL_VALUES), "CAN_HAVE_NULL_VALUES" },
-		{ static_cast<uint32_t>(StatsInfo::CANNOT_HAVE_NULL_VALUES), "CANNOT_HAVE_NULL_VALUES" },
-		{ static_cast<uint32_t>(StatsInfo::CAN_HAVE_VALID_VALUES), "CAN_HAVE_VALID_VALUES" },
-		{ static_cast<uint32_t>(StatsInfo::CANNOT_HAVE_VALID_VALUES), "CANNOT_HAVE_VALID_VALUES" },
-		{ static_cast<uint32_t>(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES), "CAN_HAVE_NULL_AND_VALID_VALUES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<StatsInfo>(StatsInfo value) {
-	return StringUtil::EnumToString(GetStatsInfoValues(), 5, "StatsInfo", static_cast<uint32_t>(value));
-}
-
-template<>
-StatsInfo EnumUtil::FromString<StatsInfo>(const char *value) {
-	return static_cast<StatsInfo>(StringUtil::StringToEnum(GetStatsInfoValues(), 5, "StatsInfo", value));
-}
-
-const StringUtil::EnumStringLiteral *GetStrTimeSpecifierValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME), "ABBREVIATED_WEEKDAY_NAME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::FULL_WEEKDAY_NAME), "FULL_WEEKDAY_NAME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::WEEKDAY_DECIMAL), "WEEKDAY_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_MONTH_PADDED), "DAY_OF_MONTH_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_MONTH), "DAY_OF_MONTH" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::ABBREVIATED_MONTH_NAME), "ABBREVIATED_MONTH_NAME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::FULL_MONTH_NAME), "FULL_MONTH_NAME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::MONTH_DECIMAL_PADDED), "MONTH_DECIMAL_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::MONTH_DECIMAL), "MONTH_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED), "YEAR_WITHOUT_CENTURY_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::YEAR_WITHOUT_CENTURY), "YEAR_WITHOUT_CENTURY" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::YEAR_DECIMAL), "YEAR_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::HOUR_24_PADDED), "HOUR_24_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::HOUR_24_DECIMAL), "HOUR_24_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::HOUR_12_PADDED), "HOUR_12_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::HOUR_12_DECIMAL), "HOUR_12_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::AM_PM), "AM_PM" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::MINUTE_PADDED), "MINUTE_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::MINUTE_DECIMAL), "MINUTE_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::SECOND_PADDED), "SECOND_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::SECOND_DECIMAL), "SECOND_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::MICROSECOND_PADDED), "MICROSECOND_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::MILLISECOND_PADDED), "MILLISECOND_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::UTC_OFFSET), "UTC_OFFSET" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::TZ_NAME), "TZ_NAME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_YEAR_PADDED), "DAY_OF_YEAR_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_YEAR_DECIMAL), "DAY_OF_YEAR_DECIMAL" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST), "WEEK_NUMBER_PADDED_SUN_FIRST" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST), "WEEK_NUMBER_PADDED_MON_FIRST" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::LOCALE_APPROPRIATE_DATE_AND_TIME), "LOCALE_APPROPRIATE_DATE_AND_TIME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::LOCALE_APPROPRIATE_DATE), "LOCALE_APPROPRIATE_DATE" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::LOCALE_APPROPRIATE_TIME), "LOCALE_APPROPRIATE_TIME" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::NANOSECOND_PADDED), "NANOSECOND_PADDED" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::YEAR_ISO), "YEAR_ISO" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::WEEKDAY_ISO), "WEEKDAY_ISO" },
-		{ static_cast<uint32_t>(StrTimeSpecifier::WEEK_NUMBER_ISO), "WEEK_NUMBER_ISO" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<StrTimeSpecifier>(StrTimeSpecifier value) {
-	return StringUtil::EnumToString(GetStrTimeSpecifierValues(), 36, "StrTimeSpecifier", static_cast<uint32_t>(value));
-}
-
-template<>
-StrTimeSpecifier EnumUtil::FromString<StrTimeSpecifier>(const char *value) {
-	return static_cast<StrTimeSpecifier>(StringUtil::StringToEnum(GetStrTimeSpecifierValues(), 36, "StrTimeSpecifier", value));
-}
-
-const StringUtil::EnumStringLiteral *GetStreamExecutionResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(StreamExecutionResult::CHUNK_READY), "CHUNK_READY" },
-		{ static_cast<uint32_t>(StreamExecutionResult::CHUNK_NOT_READY), "CHUNK_NOT_READY" },
-		{ static_cast<uint32_t>(StreamExecutionResult::EXECUTION_ERROR), "EXECUTION_ERROR" },
-		{ static_cast<uint32_t>(StreamExecutionResult::EXECUTION_CANCELLED), "EXECUTION_CANCELLED" },
-		{ static_cast<uint32_t>(StreamExecutionResult::BLOCKED), "BLOCKED" },
-		{ static_cast<uint32_t>(StreamExecutionResult::NO_TASKS_AVAILABLE), "NO_TASKS_AVAILABLE" },
-		{ static_cast<uint32_t>(StreamExecutionResult::EXECUTION_FINISHED), "EXECUTION_FINISHED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<StreamExecutionResult>(StreamExecutionResult value) {
-	return StringUtil::EnumToString(GetStreamExecutionResultValues(), 7, "StreamExecutionResult", static_cast<uint32_t>(value));
-}
-
-template<>
-StreamExecutionResult EnumUtil::FromString<StreamExecutionResult>(const char *value) {
-	return static_cast<StreamExecutionResult>(StringUtil::StringToEnum(GetStreamExecutionResultValues(), 7, "StreamExecutionResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetSubqueryTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(SubqueryType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(SubqueryType::SCALAR), "SCALAR" },
-		{ static_cast<uint32_t>(SubqueryType::EXISTS), "EXISTS" },
-		{ static_cast<uint32_t>(SubqueryType::NOT_EXISTS), "NOT_EXISTS" },
-		{ static_cast<uint32_t>(SubqueryType::ANY), "ANY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<SubqueryType>(SubqueryType value) {
-	return StringUtil::EnumToString(GetSubqueryTypeValues(), 5, "SubqueryType", static_cast<uint32_t>(value));
-}
-
-template<>
-SubqueryType EnumUtil::FromString<SubqueryType>(const char *value) {
-	return static_cast<SubqueryType>(StringUtil::StringToEnum(GetSubqueryTypeValues(), 5, "SubqueryType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTableColumnTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TableColumnType::STANDARD), "STANDARD" },
-		{ static_cast<uint32_t>(TableColumnType::GENERATED), "GENERATED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TableColumnType>(TableColumnType value) {
-	return StringUtil::EnumToString(GetTableColumnTypeValues(), 2, "TableColumnType", static_cast<uint32_t>(value));
-}
-
-template<>
-TableColumnType EnumUtil::FromString<TableColumnType>(const char *value) {
-	return static_cast<TableColumnType>(StringUtil::StringToEnum(GetTableColumnTypeValues(), 2, "TableColumnType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTableFilterTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TableFilterType::CONSTANT_COMPARISON), "CONSTANT_COMPARISON" },
-		{ static_cast<uint32_t>(TableFilterType::IS_NULL), "IS_NULL" },
-		{ static_cast<uint32_t>(TableFilterType::IS_NOT_NULL), "IS_NOT_NULL" },
-		{ static_cast<uint32_t>(TableFilterType::CONJUNCTION_OR), "CONJUNCTION_OR" },
-		{ static_cast<uint32_t>(TableFilterType::CONJUNCTION_AND), "CONJUNCTION_AND" },
-		{ static_cast<uint32_t>(TableFilterType::STRUCT_EXTRACT), "STRUCT_EXTRACT" },
-		{ static_cast<uint32_t>(TableFilterType::OPTIONAL_FILTER), "OPTIONAL_FILTER" },
-		{ static_cast<uint32_t>(TableFilterType::IN_FILTER), "IN_FILTER" },
-		{ static_cast<uint32_t>(TableFilterType::DYNAMIC_FILTER), "DYNAMIC_FILTER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TableFilterType>(TableFilterType value) {
-	return StringUtil::EnumToString(GetTableFilterTypeValues(), 9, "TableFilterType", static_cast<uint32_t>(value));
-}
-
-template<>
-TableFilterType EnumUtil::FromString<TableFilterType>(const char *value) {
-	return static_cast<TableFilterType>(StringUtil::StringToEnum(GetTableFilterTypeValues(), 9, "TableFilterType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTablePartitionInfoValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TablePartitionInfo::NOT_PARTITIONED), "NOT_PARTITIONED" },
-		{ static_cast<uint32_t>(TablePartitionInfo::SINGLE_VALUE_PARTITIONS), "SINGLE_VALUE_PARTITIONS" },
-		{ static_cast<uint32_t>(TablePartitionInfo::OVERLAPPING_PARTITIONS), "OVERLAPPING_PARTITIONS" },
-		{ static_cast<uint32_t>(TablePartitionInfo::DISJOINT_PARTITIONS), "DISJOINT_PARTITIONS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TablePartitionInfo>(TablePartitionInfo value) {
-	return StringUtil::EnumToString(GetTablePartitionInfoValues(), 4, "TablePartitionInfo", static_cast<uint32_t>(value));
-}
-
-template<>
-TablePartitionInfo EnumUtil::FromString<TablePartitionInfo>(const char *value) {
-	return static_cast<TablePartitionInfo>(StringUtil::StringToEnum(GetTablePartitionInfoValues(), 4, "TablePartitionInfo", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTableReferenceTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TableReferenceType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(TableReferenceType::BASE_TABLE), "BASE_TABLE" },
-		{ static_cast<uint32_t>(TableReferenceType::SUBQUERY), "SUBQUERY" },
-		{ static_cast<uint32_t>(TableReferenceType::JOIN), "JOIN" },
-		{ static_cast<uint32_t>(TableReferenceType::TABLE_FUNCTION), "TABLE_FUNCTION" },
-		{ static_cast<uint32_t>(TableReferenceType::EXPRESSION_LIST), "EXPRESSION_LIST" },
-		{ static_cast<uint32_t>(TableReferenceType::CTE), "CTE" },
-		{ static_cast<uint32_t>(TableReferenceType::EMPTY_FROM), "EMPTY" },
-		{ static_cast<uint32_t>(TableReferenceType::PIVOT), "PIVOT" },
-		{ static_cast<uint32_t>(TableReferenceType::SHOW_REF), "SHOW_REF" },
-		{ static_cast<uint32_t>(TableReferenceType::COLUMN_DATA), "COLUMN_DATA" },
-		{ static_cast<uint32_t>(TableReferenceType::DELIM_GET), "DELIM_GET" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TableReferenceType>(TableReferenceType value) {
-	return StringUtil::EnumToString(GetTableReferenceTypeValues(), 12, "TableReferenceType", static_cast<uint32_t>(value));
-}
-
-template<>
-TableReferenceType EnumUtil::FromString<TableReferenceType>(const char *value) {
-	return static_cast<TableReferenceType>(StringUtil::StringToEnum(GetTableReferenceTypeValues(), 12, "TableReferenceType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTableScanTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TableScanType::TABLE_SCAN_REGULAR), "TABLE_SCAN_REGULAR" },
-		{ static_cast<uint32_t>(TableScanType::TABLE_SCAN_COMMITTED_ROWS), "TABLE_SCAN_COMMITTED_ROWS" },
-		{ static_cast<uint32_t>(TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES), "TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES" },
-		{ static_cast<uint32_t>(TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED), "TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED" },
-		{ static_cast<uint32_t>(TableScanType::TABLE_SCAN_LATEST_COMMITTED_ROWS), "TABLE_SCAN_LATEST_COMMITTED_ROWS" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TableScanType>(TableScanType value) {
-	return StringUtil::EnumToString(GetTableScanTypeValues(), 5, "TableScanType", static_cast<uint32_t>(value));
-}
-
-template<>
-TableScanType EnumUtil::FromString<TableScanType>(const char *value) {
-	return static_cast<TableScanType>(StringUtil::StringToEnum(GetTableScanTypeValues(), 5, "TableScanType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTaskExecutionModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TaskExecutionMode::PROCESS_ALL), "PROCESS_ALL" },
-		{ static_cast<uint32_t>(TaskExecutionMode::PROCESS_PARTIAL), "PROCESS_PARTIAL" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TaskExecutionMode>(TaskExecutionMode value) {
-	return StringUtil::EnumToString(GetTaskExecutionModeValues(), 2, "TaskExecutionMode", static_cast<uint32_t>(value));
-}
-
-template<>
-TaskExecutionMode EnumUtil::FromString<TaskExecutionMode>(const char *value) {
-	return static_cast<TaskExecutionMode>(StringUtil::StringToEnum(GetTaskExecutionModeValues(), 2, "TaskExecutionMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTaskExecutionResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TaskExecutionResult::TASK_FINISHED), "TASK_FINISHED" },
-		{ static_cast<uint32_t>(TaskExecutionResult::TASK_NOT_FINISHED), "TASK_NOT_FINISHED" },
-		{ static_cast<uint32_t>(TaskExecutionResult::TASK_ERROR), "TASK_ERROR" },
-		{ static_cast<uint32_t>(TaskExecutionResult::TASK_BLOCKED), "TASK_BLOCKED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TaskExecutionResult>(TaskExecutionResult value) {
-	return StringUtil::EnumToString(GetTaskExecutionResultValues(), 4, "TaskExecutionResult", static_cast<uint32_t>(value));
-}
-
-template<>
-TaskExecutionResult EnumUtil::FromString<TaskExecutionResult>(const char *value) {
-	return static_cast<TaskExecutionResult>(StringUtil::StringToEnum(GetTaskExecutionResultValues(), 4, "TaskExecutionResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTemporaryBufferSizeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TemporaryBufferSize::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S32K), "S32K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S64K), "S64K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S96K), "S96K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S128K), "S128K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S160K), "S160K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S192K), "S192K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::S224K), "S224K" },
-		{ static_cast<uint32_t>(TemporaryBufferSize::DEFAULT), "DEFAULT" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TemporaryBufferSize>(TemporaryBufferSize value) {
-	return StringUtil::EnumToString(GetTemporaryBufferSizeValues(), 9, "TemporaryBufferSize", static_cast<uint32_t>(value));
-}
-
-template<>
-TemporaryBufferSize EnumUtil::FromString<TemporaryBufferSize>(const char *value) {
-	return static_cast<TemporaryBufferSize>(StringUtil::StringToEnum(GetTemporaryBufferSizeValues(), 9, "TemporaryBufferSize", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTemporaryCompressionLevelValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_MINUS_FIVE), "ZSTD_MINUS_FIVE" },
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_MINUS_THREE), "ZSTD_MINUS_THREE" },
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_MINUS_ONE), "ZSTD_MINUS_ONE" },
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::UNCOMPRESSED), "UNCOMPRESSED" },
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_ONE), "ZSTD_ONE" },
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_THREE), "ZSTD_THREE" },
-		{ static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_FIVE), "ZSTD_FIVE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TemporaryCompressionLevel>(TemporaryCompressionLevel value) {
-	return StringUtil::EnumToString(GetTemporaryCompressionLevelValues(), 7, "TemporaryCompressionLevel", static_cast<uint32_t>(value));
-}
-
-template<>
-TemporaryCompressionLevel EnumUtil::FromString<TemporaryCompressionLevel>(const char *value) {
-	return static_cast<TemporaryCompressionLevel>(StringUtil::StringToEnum(GetTemporaryCompressionLevelValues(), 7, "TemporaryCompressionLevel", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTimestampCastResultValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TimestampCastResult::SUCCESS), "SUCCESS" },
-		{ static_cast<uint32_t>(TimestampCastResult::ERROR_INCORRECT_FORMAT), "ERROR_INCORRECT_FORMAT" },
-		{ static_cast<uint32_t>(TimestampCastResult::ERROR_NON_UTC_TIMEZONE), "ERROR_NON_UTC_TIMEZONE" },
-		{ static_cast<uint32_t>(TimestampCastResult::ERROR_RANGE), "ERROR_RANGE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TimestampCastResult>(TimestampCastResult value) {
-	return StringUtil::EnumToString(GetTimestampCastResultValues(), 4, "TimestampCastResult", static_cast<uint32_t>(value));
-}
-
-template<>
-TimestampCastResult EnumUtil::FromString<TimestampCastResult>(const char *value) {
-	return static_cast<TimestampCastResult>(StringUtil::StringToEnum(GetTimestampCastResultValues(), 4, "TimestampCastResult", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTransactionModifierTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER), "TRANSACTION_DEFAULT_MODIFIER" },
-		{ static_cast<uint32_t>(TransactionModifierType::TRANSACTION_READ_ONLY), "TRANSACTION_READ_ONLY" },
-		{ static_cast<uint32_t>(TransactionModifierType::TRANSACTION_READ_WRITE), "TRANSACTION_READ_WRITE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TransactionModifierType>(TransactionModifierType value) {
-	return StringUtil::EnumToString(GetTransactionModifierTypeValues(), 3, "TransactionModifierType", static_cast<uint32_t>(value));
-}
-
-template<>
-TransactionModifierType EnumUtil::FromString<TransactionModifierType>(const char *value) {
-	return static_cast<TransactionModifierType>(StringUtil::StringToEnum(GetTransactionModifierTypeValues(), 3, "TransactionModifierType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTransactionTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TransactionType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(TransactionType::BEGIN_TRANSACTION), "BEGIN_TRANSACTION" },
-		{ static_cast<uint32_t>(TransactionType::COMMIT), "COMMIT" },
-		{ static_cast<uint32_t>(TransactionType::ROLLBACK), "ROLLBACK" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TransactionType>(TransactionType value) {
-	return StringUtil::EnumToString(GetTransactionTypeValues(), 4, "TransactionType", static_cast<uint32_t>(value));
-}
-
-template<>
-TransactionType EnumUtil::FromString<TransactionType>(const char *value) {
-	return static_cast<TransactionType>(StringUtil::StringToEnum(GetTransactionTypeValues(), 4, "TransactionType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetTupleDataPinPropertiesValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(TupleDataPinProperties::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(TupleDataPinProperties::KEEP_EVERYTHING_PINNED), "KEEP_EVERYTHING_PINNED" },
-		{ static_cast<uint32_t>(TupleDataPinProperties::UNPIN_AFTER_DONE), "UNPIN_AFTER_DONE" },
-		{ static_cast<uint32_t>(TupleDataPinProperties::DESTROY_AFTER_DONE), "DESTROY_AFTER_DONE" },
-		{ static_cast<uint32_t>(TupleDataPinProperties::ALREADY_PINNED), "ALREADY_PINNED" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<TupleDataPinProperties>(TupleDataPinProperties value) {
-	return StringUtil::EnumToString(GetTupleDataPinPropertiesValues(), 5, "TupleDataPinProperties", static_cast<uint32_t>(value));
-}
-
-template<>
-TupleDataPinProperties EnumUtil::FromString<TupleDataPinProperties>(const char *value) {
-	return static_cast<TupleDataPinProperties>(StringUtil::StringToEnum(GetTupleDataPinPropertiesValues(), 5, "TupleDataPinProperties", value));
-}
-
-const StringUtil::EnumStringLiteral *GetUndoFlagsValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(UndoFlags::EMPTY_ENTRY), "EMPTY_ENTRY" },
-		{ static_cast<uint32_t>(UndoFlags::CATALOG_ENTRY), "CATALOG_ENTRY" },
-		{ static_cast<uint32_t>(UndoFlags::INSERT_TUPLE), "INSERT_TUPLE" },
-		{ static_cast<uint32_t>(UndoFlags::DELETE_TUPLE), "DELETE_TUPLE" },
-		{ static_cast<uint32_t>(UndoFlags::UPDATE_TUPLE), "UPDATE_TUPLE" },
-		{ static_cast<uint32_t>(UndoFlags::SEQUENCE_VALUE), "SEQUENCE_VALUE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<UndoFlags>(UndoFlags value) {
-	return StringUtil::EnumToString(GetUndoFlagsValues(), 6, "UndoFlags", static_cast<uint32_t>(value));
-}
-
-template<>
-UndoFlags EnumUtil::FromString<UndoFlags>(const char *value) {
-	return static_cast<UndoFlags>(StringUtil::StringToEnum(GetUndoFlagsValues(), 6, "UndoFlags", value));
-}
-
-const StringUtil::EnumStringLiteral *GetUnionInvalidReasonValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(UnionInvalidReason::VALID), "VALID" },
-		{ static_cast<uint32_t>(UnionInvalidReason::TAG_OUT_OF_RANGE), "TAG_OUT_OF_RANGE" },
-		{ static_cast<uint32_t>(UnionInvalidReason::NO_MEMBERS), "NO_MEMBERS" },
-		{ static_cast<uint32_t>(UnionInvalidReason::VALIDITY_OVERLAP), "VALIDITY_OVERLAP" },
-		{ static_cast<uint32_t>(UnionInvalidReason::TAG_MISMATCH), "TAG_MISMATCH" },
-		{ static_cast<uint32_t>(UnionInvalidReason::NULL_TAG), "NULL_TAG" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<UnionInvalidReason>(UnionInvalidReason value) {
-	return StringUtil::EnumToString(GetUnionInvalidReasonValues(), 6, "UnionInvalidReason", static_cast<uint32_t>(value));
-}
-
-template<>
-UnionInvalidReason EnumUtil::FromString<UnionInvalidReason>(const char *value) {
-	return static_cast<UnionInvalidReason>(StringUtil::StringToEnum(GetUnionInvalidReasonValues(), 6, "UnionInvalidReason", value));
-}
-
-const StringUtil::EnumStringLiteral *GetVectorAuxiliaryDataTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(VectorAuxiliaryDataType::ARROW_AUXILIARY), "ARROW_AUXILIARY" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<VectorAuxiliaryDataType>(VectorAuxiliaryDataType value) {
-	return StringUtil::EnumToString(GetVectorAuxiliaryDataTypeValues(), 1, "VectorAuxiliaryDataType", static_cast<uint32_t>(value));
-}
-
-template<>
-VectorAuxiliaryDataType EnumUtil::FromString<VectorAuxiliaryDataType>(const char *value) {
-	return static_cast<VectorAuxiliaryDataType>(StringUtil::StringToEnum(GetVectorAuxiliaryDataTypeValues(), 1, "VectorAuxiliaryDataType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetVectorBufferTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(VectorBufferType::STANDARD_BUFFER), "STANDARD_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::DICTIONARY_BUFFER), "DICTIONARY_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::VECTOR_CHILD_BUFFER), "VECTOR_CHILD_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::STRING_BUFFER), "STRING_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::FSST_BUFFER), "FSST_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::STRUCT_BUFFER), "STRUCT_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::LIST_BUFFER), "LIST_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::MANAGED_BUFFER), "MANAGED_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::OPAQUE_BUFFER), "OPAQUE_BUFFER" },
-		{ static_cast<uint32_t>(VectorBufferType::ARRAY_BUFFER), "ARRAY_BUFFER" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<VectorBufferType>(VectorBufferType value) {
-	return StringUtil::EnumToString(GetVectorBufferTypeValues(), 10, "VectorBufferType", static_cast<uint32_t>(value));
-}
-
-template<>
-VectorBufferType EnumUtil::FromString<VectorBufferType>(const char *value) {
-	return static_cast<VectorBufferType>(StringUtil::StringToEnum(GetVectorBufferTypeValues(), 10, "VectorBufferType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetVectorTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(VectorType::FLAT_VECTOR), "FLAT_VECTOR" },
-		{ static_cast<uint32_t>(VectorType::FSST_VECTOR), "FSST_VECTOR" },
-		{ static_cast<uint32_t>(VectorType::CONSTANT_VECTOR), "CONSTANT_VECTOR" },
-		{ static_cast<uint32_t>(VectorType::DICTIONARY_VECTOR), "DICTIONARY_VECTOR" },
-		{ static_cast<uint32_t>(VectorType::SEQUENCE_VECTOR), "SEQUENCE_VECTOR" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<VectorType>(VectorType value) {
-	return StringUtil::EnumToString(GetVectorTypeValues(), 5, "VectorType", static_cast<uint32_t>(value));
-}
-
-template<>
-VectorType EnumUtil::FromString<VectorType>(const char *value) {
-	return static_cast<VectorType>(StringUtil::StringToEnum(GetVectorTypeValues(), 5, "VectorType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetVerificationTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(VerificationType::ORIGINAL), "ORIGINAL" },
-		{ static_cast<uint32_t>(VerificationType::COPIED), "COPIED" },
-		{ static_cast<uint32_t>(VerificationType::DESERIALIZED), "DESERIALIZED" },
-		{ static_cast<uint32_t>(VerificationType::PARSED), "PARSED" },
-		{ static_cast<uint32_t>(VerificationType::UNOPTIMIZED), "UNOPTIMIZED" },
-		{ static_cast<uint32_t>(VerificationType::NO_OPERATOR_CACHING), "NO_OPERATOR_CACHING" },
-		{ static_cast<uint32_t>(VerificationType::PREPARED), "PREPARED" },
-		{ static_cast<uint32_t>(VerificationType::EXTERNAL), "EXTERNAL" },
-		{ static_cast<uint32_t>(VerificationType::FETCH_ROW_AS_SCAN), "FETCH_ROW_AS_SCAN" },
-		{ static_cast<uint32_t>(VerificationType::INVALID), "INVALID" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<VerificationType>(VerificationType value) {
-	return StringUtil::EnumToString(GetVerificationTypeValues(), 10, "VerificationType", static_cast<uint32_t>(value));
-}
-
-template<>
-VerificationType EnumUtil::FromString<VerificationType>(const char *value) {
-	return static_cast<VerificationType>(StringUtil::StringToEnum(GetVerificationTypeValues(), 10, "VerificationType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetVerifyExistenceTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(VerifyExistenceType::APPEND), "APPEND" },
-		{ static_cast<uint32_t>(VerifyExistenceType::APPEND_FK), "APPEND_FK" },
-		{ static_cast<uint32_t>(VerifyExistenceType::DELETE_FK), "DELETE_FK" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<VerifyExistenceType>(VerifyExistenceType value) {
-	return StringUtil::EnumToString(GetVerifyExistenceTypeValues(), 3, "VerifyExistenceType", static_cast<uint32_t>(value));
-}
-
-template<>
-VerifyExistenceType EnumUtil::FromString<VerifyExistenceType>(const char *value) {
-	return static_cast<VerifyExistenceType>(StringUtil::StringToEnum(GetVerifyExistenceTypeValues(), 3, "VerifyExistenceType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetWALTypeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(WALType::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(WALType::CREATE_TABLE), "CREATE_TABLE" },
-		{ static_cast<uint32_t>(WALType::DROP_TABLE), "DROP_TABLE" },
-		{ static_cast<uint32_t>(WALType::CREATE_SCHEMA), "CREATE_SCHEMA" },
-		{ static_cast<uint32_t>(WALType::DROP_SCHEMA), "DROP_SCHEMA" },
-		{ static_cast<uint32_t>(WALType::CREATE_VIEW), "CREATE_VIEW" },
-		{ static_cast<uint32_t>(WALType::DROP_VIEW), "DROP_VIEW" },
-		{ static_cast<uint32_t>(WALType::CREATE_SEQUENCE), "CREATE_SEQUENCE" },
-		{ static_cast<uint32_t>(WALType::DROP_SEQUENCE), "DROP_SEQUENCE" },
-		{ static_cast<uint32_t>(WALType::SEQUENCE_VALUE), "SEQUENCE_VALUE" },
-		{ static_cast<uint32_t>(WALType::CREATE_MACRO), "CREATE_MACRO" },
-		{ static_cast<uint32_t>(WALType::DROP_MACRO), "DROP_MACRO" },
-		{ static_cast<uint32_t>(WALType::CREATE_TYPE), "CREATE_TYPE" },
-		{ static_cast<uint32_t>(WALType::DROP_TYPE), "DROP_TYPE" },
-		{ static_cast<uint32_t>(WALType::ALTER_INFO), "ALTER_INFO" },
-		{ static_cast<uint32_t>(WALType::CREATE_TABLE_MACRO), "CREATE_TABLE_MACRO" },
-		{ static_cast<uint32_t>(WALType::DROP_TABLE_MACRO), "DROP_TABLE_MACRO" },
-		{ static_cast<uint32_t>(WALType::CREATE_INDEX), "CREATE_INDEX" },
-		{ static_cast<uint32_t>(WALType::DROP_INDEX), "DROP_INDEX" },
-		{ static_cast<uint32_t>(WALType::USE_TABLE), "USE_TABLE" },
-		{ static_cast<uint32_t>(WALType::INSERT_TUPLE), "INSERT_TUPLE" },
-		{ static_cast<uint32_t>(WALType::DELETE_TUPLE), "DELETE_TUPLE" },
-		{ static_cast<uint32_t>(WALType::UPDATE_TUPLE), "UPDATE_TUPLE" },
-		{ static_cast<uint32_t>(WALType::ROW_GROUP_DATA), "ROW_GROUP_DATA" },
-		{ static_cast<uint32_t>(WALType::WAL_VERSION), "WAL_VERSION" },
-		{ static_cast<uint32_t>(WALType::CHECKPOINT), "CHECKPOINT" },
-		{ static_cast<uint32_t>(WALType::WAL_FLUSH), "WAL_FLUSH" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<WALType>(WALType value) {
-	return StringUtil::EnumToString(GetWALTypeValues(), 27, "WALType", static_cast<uint32_t>(value));
-}
-
-template<>
-WALType EnumUtil::FromString<WALType>(const char *value) {
-	return static_cast<WALType>(StringUtil::StringToEnum(GetWALTypeValues(), 27, "WALType", value));
-}
-
-const StringUtil::EnumStringLiteral *GetWindowAggregationModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(WindowAggregationMode::WINDOW), "WINDOW" },
-		{ static_cast<uint32_t>(WindowAggregationMode::COMBINE), "COMBINE" },
-		{ static_cast<uint32_t>(WindowAggregationMode::SEPARATE), "SEPARATE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<WindowAggregationMode>(WindowAggregationMode value) {
-	return StringUtil::EnumToString(GetWindowAggregationModeValues(), 3, "WindowAggregationMode", static_cast<uint32_t>(value));
-}
-
-template<>
-WindowAggregationMode EnumUtil::FromString<WindowAggregationMode>(const char *value) {
-	return static_cast<WindowAggregationMode>(StringUtil::StringToEnum(GetWindowAggregationModeValues(), 3, "WindowAggregationMode", value));
-}
-
-const StringUtil::EnumStringLiteral *GetWindowBoundaryValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(WindowBoundary::INVALID), "INVALID" },
-		{ static_cast<uint32_t>(WindowBoundary::UNBOUNDED_PRECEDING), "UNBOUNDED_PRECEDING" },
-		{ static_cast<uint32_t>(WindowBoundary::UNBOUNDED_FOLLOWING), "UNBOUNDED_FOLLOWING" },
-		{ static_cast<uint32_t>(WindowBoundary::CURRENT_ROW_RANGE), "CURRENT_ROW_RANGE" },
-		{ static_cast<uint32_t>(WindowBoundary::CURRENT_ROW_ROWS), "CURRENT_ROW_ROWS" },
-		{ static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_ROWS), "EXPR_PRECEDING_ROWS" },
-		{ static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_ROWS), "EXPR_FOLLOWING_ROWS" },
-		{ static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_RANGE), "EXPR_PRECEDING_RANGE" },
-		{ static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_RANGE), "EXPR_FOLLOWING_RANGE" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<WindowBoundary>(WindowBoundary value) {
-	return StringUtil::EnumToString(GetWindowBoundaryValues(), 9, "WindowBoundary", static_cast<uint32_t>(value));
-}
-
-template<>
-WindowBoundary EnumUtil::FromString<WindowBoundary>(const char *value) {
-	return static_cast<WindowBoundary>(StringUtil::StringToEnum(GetWindowBoundaryValues(), 9, "WindowBoundary", value));
-}
-
-const StringUtil::EnumStringLiteral *GetWindowExcludeModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(WindowExcludeMode::NO_OTHER), "NO_OTHER" },
-		{ static_cast<uint32_t>(WindowExcludeMode::CURRENT_ROW), "CURRENT_ROW" },
-		{ static_cast<uint32_t>(WindowExcludeMode::GROUP), "GROUP" },
-		{ static_cast<uint32_t>(WindowExcludeMode::TIES), "TIES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<WindowExcludeMode>(WindowExcludeMode value) {
-	return StringUtil::EnumToString(GetWindowExcludeModeValues(), 4, "WindowExcludeMode", static_cast<uint32_t>(value));
-}
-
-template<>
-WindowExcludeMode EnumUtil::FromString<WindowExcludeMode>(const char *value) {
-	return static_cast<WindowExcludeMode>(StringUtil::StringToEnum(GetWindowExcludeModeValues(), 4, "WindowExcludeMode", value));
-}
-
-}
-
diff --git a/src/duckdb/src/common/enums/catalog_type.cpp b/src/duckdb/src/common/enums/catalog_type.cpp
deleted file mode 100644
index 55dbcb41a..000000000
--- a/src/duckdb/src/common/enums/catalog_type.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "duckdb/common/enums/catalog_type.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string CatalogTypeToString(CatalogType type) {
-	switch (type) {
-	case CatalogType::COLLATION_ENTRY:
-		return "Collation";
-	case CatalogType::TYPE_ENTRY:
-		return "Type";
-	case CatalogType::TABLE_ENTRY:
-		return "Table";
-	case CatalogType::SCHEMA_ENTRY:
-		return "Schema";
-	case CatalogType::DATABASE_ENTRY:
-		return "Database";
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-		return "Table Function";
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		return "Scalar Function";
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-		return "Aggregate Function";
-	case CatalogType::COPY_FUNCTION_ENTRY:
-		return "Copy Function";
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-		return "Pragma Function";
-	case CatalogType::MACRO_ENTRY:
-		return "Macro Function";
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return "Table Macro Function";
-	case CatalogType::VIEW_ENTRY:
-		return "View";
-	case CatalogType::INDEX_ENTRY:
-		return "Index";
-	case CatalogType::PREPARED_STATEMENT:
-		return "Prepared Statement";
-	case CatalogType::SEQUENCE_ENTRY:
-		return "Sequence";
-	case CatalogType::SECRET_ENTRY:
-		return "Secret";
-	case CatalogType::SECRET_TYPE_ENTRY:
-		return "Secret Type";
-	case CatalogType::SECRET_FUNCTION_ENTRY:
-		return "Secret Function";
-	case CatalogType::INVALID:
-	case CatalogType::DELETED_ENTRY:
-	case CatalogType::RENAMED_ENTRY:
-	case CatalogType::DEPENDENCY_ENTRY:
-		break;
-	}
-	return "INVALID";
-}
-
-CatalogType CatalogTypeFromString(const string &type) {
-	if (type == "Collation") {
-		return CatalogType::COLLATION_ENTRY;
-	}
-	if (type == "Type") {
-		return CatalogType::TYPE_ENTRY;
-	}
-	if (type == "Table") {
-		return CatalogType::TABLE_ENTRY;
-	}
-	if (type == "Schema") {
-		return CatalogType::SCHEMA_ENTRY;
-	}
-	if (type == "Database") {
-		return CatalogType::DATABASE_ENTRY;
-	}
-	if (type == "Table Function") {
-		return CatalogType::TABLE_FUNCTION_ENTRY;
-	}
-	if (type == "Scalar Function") {
-		return CatalogType::SCALAR_FUNCTION_ENTRY;
-	}
-	if (type == "Aggregate Function") {
-		return CatalogType::AGGREGATE_FUNCTION_ENTRY;
-	}
-	if (type == "Copy Function") {
-		return CatalogType::COPY_FUNCTION_ENTRY;
-	}
-	if (type == "Pragma Function") {
-		return CatalogType::PRAGMA_FUNCTION_ENTRY;
-	}
-	if (type == "Macro Function") {
-		return CatalogType::MACRO_ENTRY;
-	}
-	if (type == "Table Macro Function") {
-		return CatalogType::TABLE_MACRO_ENTRY;
-	}
-	if (type == "View") {
-		return CatalogType::VIEW_ENTRY;
-	}
-	if (type == "Index") {
-		return CatalogType::INDEX_ENTRY;
-	}
-	if (type == "Prepared Statement") {
-		return CatalogType::PREPARED_STATEMENT;
-	}
-	if (type == "Sequence") {
-		return CatalogType::SEQUENCE_ENTRY;
-	}
-	if (type == "INVALID") {
-		return CatalogType::INVALID;
-	}
-	throw InternalException("Unrecognized CatalogType '%s'", type);
-}
-
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/compression_type.cpp b/src/duckdb/src/common/enums/compression_type.cpp
deleted file mode 100644
index 3bc66fe08..000000000
--- a/src/duckdb/src/common/enums/compression_type.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-
-vector<string> ListCompressionTypes(void) {
-	vector<string> compression_types;
-	uint8_t amount_of_compression_options = (uint8_t)CompressionType::COMPRESSION_COUNT;
-	compression_types.reserve(amount_of_compression_options);
-	for (uint8_t i = 0; i < amount_of_compression_options; i++) {
-		compression_types.push_back(CompressionTypeToString((CompressionType)i));
-	}
-	return compression_types;
-}
-
-bool CompressionTypeIsDeprecated(CompressionType compression_type) {
-	const bool is_patas = compression_type == CompressionType::COMPRESSION_PATAS;
-	const bool is_chimp = compression_type == CompressionType::COMPRESSION_CHIMP;
-	return (is_patas || is_chimp);
-}
-
-CompressionType CompressionTypeFromString(const string &str) {
-	auto compression = StringUtil::Lower(str);
-	//! NOTE: this explicitly does not include 'constant' and 'empty validity', these are internal compression functions
-	//! not general purpose
-	if (compression == "uncompressed") {
-		return CompressionType::COMPRESSION_UNCOMPRESSED;
-	} else if (compression == "rle") {
-		return CompressionType::COMPRESSION_RLE;
-	} else if (compression == "dictionary") {
-		return CompressionType::COMPRESSION_DICTIONARY;
-	} else if (compression == "pfor") {
-		return CompressionType::COMPRESSION_PFOR_DELTA;
-	} else if (compression == "bitpacking") {
-		return CompressionType::COMPRESSION_BITPACKING;
-	} else if (compression == "fsst") {
-		return CompressionType::COMPRESSION_FSST;
-	} else if (compression == "chimp") {
-		return CompressionType::COMPRESSION_CHIMP;
-	} else if (compression == "patas") {
-		return CompressionType::COMPRESSION_PATAS;
-	} else if (compression == "zstd") {
-		return CompressionType::COMPRESSION_ZSTD;
-	} else if (compression == "alp") {
-		return CompressionType::COMPRESSION_ALP;
-	} else if (compression == "alprd") {
-		return CompressionType::COMPRESSION_ALPRD;
-	} else if (compression == "roaring") {
-		return CompressionType::COMPRESSION_ROARING;
-	} else {
-		return CompressionType::COMPRESSION_AUTO;
-	}
-}
-
-string CompressionTypeToString(CompressionType type) {
-	switch (type) {
-	case CompressionType::COMPRESSION_AUTO:
-		return "Auto";
-	case CompressionType::COMPRESSION_UNCOMPRESSED:
-		return "Uncompressed";
-	case CompressionType::COMPRESSION_CONSTANT:
-		return "Constant";
-	case CompressionType::COMPRESSION_RLE:
-		return "RLE";
-	case CompressionType::COMPRESSION_DICTIONARY:
-		return "Dictionary";
-	case CompressionType::COMPRESSION_PFOR_DELTA:
-		return "PFOR";
-	case CompressionType::COMPRESSION_BITPACKING:
-		return "BitPacking";
-	case CompressionType::COMPRESSION_FSST:
-		return "FSST";
-	case CompressionType::COMPRESSION_CHIMP:
-		return "Chimp";
-	case CompressionType::COMPRESSION_PATAS:
-		return "Patas";
-	case CompressionType::COMPRESSION_ZSTD:
-		return "ZSTD";
-	case CompressionType::COMPRESSION_ALP:
-		return "ALP";
-	case CompressionType::COMPRESSION_ALPRD:
-		return "ALPRD";
-	case CompressionType::COMPRESSION_ROARING:
-		return "Roaring";
-	case CompressionType::COMPRESSION_EMPTY:
-		return "Empty Validity";
-	default:
-		throw InternalException("Unrecognized compression type!");
-	}
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/date_part_specifier.cpp b/src/duckdb/src/common/enums/date_part_specifier.cpp
deleted file mode 100644
index 032a82165..000000000
--- a/src/duckdb/src/common/enums/date_part_specifier.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-
-namespace duckdb {
-
-bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &result) {
-	auto specifier = StringUtil::Lower(specifier_p);
-	if (specifier == "year" || specifier == "yr" || specifier == "y" || specifier == "years" || specifier == "yrs") {
-		result = DatePartSpecifier::YEAR;
-	} else if (specifier == "month" || specifier == "mon" || specifier == "months" || specifier == "mons") {
-		result = DatePartSpecifier::MONTH;
-	} else if (specifier == "day" || specifier == "days" || specifier == "d" || specifier == "dayofmonth") {
-		result = DatePartSpecifier::DAY;
-	} else if (specifier == "decade" || specifier == "dec" || specifier == "decades" || specifier == "decs") {
-		result = DatePartSpecifier::DECADE;
-	} else if (specifier == "century" || specifier == "cent" || specifier == "centuries" || specifier == "c") {
-		result = DatePartSpecifier::CENTURY;
-	} else if (specifier == "millennium" || specifier == "mil" || specifier == "millenniums" ||
-	           specifier == "millennia" || specifier == "mils" || specifier == "millenium") {
-		result = DatePartSpecifier::MILLENNIUM;
-	} else if (specifier == "microseconds" || specifier == "microsecond" || specifier == "us" || specifier == "usec" ||
-	           specifier == "usecs" || specifier == "usecond" || specifier == "useconds") {
-		result = DatePartSpecifier::MICROSECONDS;
-	} else if (specifier == "milliseconds" || specifier == "millisecond" || specifier == "ms" || specifier == "msec" ||
-	           specifier == "msecs" || specifier == "msecond" || specifier == "mseconds") {
-		result = DatePartSpecifier::MILLISECONDS;
-	} else if (specifier == "second" || specifier == "sec" || specifier == "seconds" || specifier == "secs" ||
-	           specifier == "s") {
-		result = DatePartSpecifier::SECOND;
-	} else if (specifier == "minute" || specifier == "min" || specifier == "minutes" || specifier == "mins" ||
-	           specifier == "m") {
-		result = DatePartSpecifier::MINUTE;
-	} else if (specifier == "hour" || specifier == "hr" || specifier == "hours" || specifier == "hrs" ||
-	           specifier == "h") {
-		result = DatePartSpecifier::HOUR;
-	} else if (specifier == "epoch") {
-		// seconds since 1970-01-01
-		result = DatePartSpecifier::EPOCH;
-	} else if (specifier == "dow" || specifier == "dayofweek" || specifier == "weekday") {
-		// day of the week (Sunday = 0, Saturday = 6)
-		result = DatePartSpecifier::DOW;
-	} else if (specifier == "isodow") {
-		// isodow (Monday = 1, Sunday = 7)
-		result = DatePartSpecifier::ISODOW;
-	} else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
-		// ISO week number
-		result = DatePartSpecifier::WEEK;
-	} else if (specifier == "doy" || specifier == "dayofyear") {
-		// day of the year (1-365/366)
-		result = DatePartSpecifier::DOY;
-	} else if (specifier == "quarter" || specifier == "quarters") {
-		// quarter of the year (1-4)
-		result = DatePartSpecifier::QUARTER;
-	} else if (specifier == "yearweek") {
-		// Combined isoyear and isoweek YYYYWW
-		result = DatePartSpecifier::YEARWEEK;
-	} else if (specifier == "isoyear") {
-		// ISO year (first week of the year may be in previous year)
-		result = DatePartSpecifier::ISOYEAR;
-	} else if (specifier == "era") {
-		result = DatePartSpecifier::ERA;
-	} else if (specifier == "timezone") {
-		result = DatePartSpecifier::TIMEZONE;
-	} else if (specifier == "timezone_hour") {
-		result = DatePartSpecifier::TIMEZONE_HOUR;
-	} else if (specifier == "timezone_minute") {
-		result = DatePartSpecifier::TIMEZONE_MINUTE;
-	} else if (specifier == "julian" || specifier == "jd") {
-		result = DatePartSpecifier::JULIAN_DAY;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-DatePartSpecifier GetDatePartSpecifier(const string &specifier) {
-	DatePartSpecifier result;
-	if (!TryGetDatePartSpecifier(specifier, result)) {
-		throw ConversionException("extract specifier \"%s\" not recognized", specifier);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/expression_type.cpp b/src/duckdb/src/common/enums/expression_type.cpp
deleted file mode 100644
index 105f4dfa7..000000000
--- a/src/duckdb/src/common/enums/expression_type.cpp
+++ /dev/null
@@ -1,334 +0,0 @@
-#include "duckdb/common/enums/expression_type.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-string ExpressionTypeToString(ExpressionType type) {
-	switch (type) {
-	case ExpressionType::OPERATOR_CAST:
-		return "CAST";
-	case ExpressionType::OPERATOR_NOT:
-		return "NOT";
-	case ExpressionType::OPERATOR_IS_NULL:
-		return "IS_NULL";
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		return "IS_NOT_NULL";
-	case ExpressionType::COMPARE_EQUAL:
-		return "EQUAL";
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return "NOTEQUAL";
-	case ExpressionType::COMPARE_LESSTHAN:
-		return "LESSTHAN";
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return "GREATERTHAN";
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return "LESSTHANOREQUALTO";
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return "GREATERTHANOREQUALTO";
-	case ExpressionType::COMPARE_IN:
-		return "IN";
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return "DISTINCT_FROM";
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return "NOT_DISTINCT_FROM";
-	case ExpressionType::CONJUNCTION_AND:
-		return "AND";
-	case ExpressionType::CONJUNCTION_OR:
-		return "OR";
-	case ExpressionType::VALUE_CONSTANT:
-		return "CONSTANT";
-	case ExpressionType::VALUE_PARAMETER:
-		return "PARAMETER";
-	case ExpressionType::VALUE_TUPLE:
-		return "TUPLE";
-	case ExpressionType::VALUE_TUPLE_ADDRESS:
-		return "TUPLE_ADDRESS";
-	case ExpressionType::VALUE_NULL:
-		return "NULL";
-	case ExpressionType::VALUE_VECTOR:
-		return "VECTOR";
-	case ExpressionType::VALUE_SCALAR:
-		return "SCALAR";
-	case ExpressionType::AGGREGATE:
-		return "AGGREGATE";
-	case ExpressionType::WINDOW_AGGREGATE:
-		return "WINDOW_AGGREGATE";
-	case ExpressionType::WINDOW_RANK:
-		return "RANK";
-	case ExpressionType::WINDOW_RANK_DENSE:
-		return "RANK_DENSE";
-	case ExpressionType::WINDOW_PERCENT_RANK:
-		return "PERCENT_RANK";
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		return "ROW_NUMBER";
-	case ExpressionType::WINDOW_FIRST_VALUE:
-		return "FIRST_VALUE";
-	case ExpressionType::WINDOW_LAST_VALUE:
-		return "LAST_VALUE";
-	case ExpressionType::WINDOW_NTH_VALUE:
-		return "NTH_VALUE";
-	case ExpressionType::WINDOW_CUME_DIST:
-		return "CUME_DIST";
-	case ExpressionType::WINDOW_LEAD:
-		return "LEAD";
-	case ExpressionType::WINDOW_LAG:
-		return "LAG";
-	case ExpressionType::WINDOW_NTILE:
-		return "NTILE";
-	case ExpressionType::FUNCTION:
-		return "FUNCTION";
-	case ExpressionType::CASE_EXPR:
-		return "CASE";
-	case ExpressionType::OPERATOR_NULLIF:
-		return "NULLIF";
-	case ExpressionType::OPERATOR_COALESCE:
-		return "COALESCE";
-	case ExpressionType::ARRAY_EXTRACT:
-		return "ARRAY_EXTRACT";
-	case ExpressionType::ARRAY_SLICE:
-		return "ARRAY_SLICE";
-	case ExpressionType::STRUCT_EXTRACT:
-		return "STRUCT_EXTRACT";
-	case ExpressionType::SUBQUERY:
-		return "SUBQUERY";
-	case ExpressionType::STAR:
-		return "STAR";
-	case ExpressionType::PLACEHOLDER:
-		return "PLACEHOLDER";
-	case ExpressionType::COLUMN_REF:
-		return "COLUMN_REF";
-	case ExpressionType::LAMBDA_REF:
-		return "LAMBDA_REF";
-	case ExpressionType::FUNCTION_REF:
-		return "FUNCTION_REF";
-	case ExpressionType::TABLE_REF:
-		return "TABLE_REF";
-	case ExpressionType::CAST:
-		return "CAST";
-	case ExpressionType::COMPARE_NOT_IN:
-		return "COMPARE_NOT_IN";
-	case ExpressionType::COMPARE_BETWEEN:
-		return "COMPARE_BETWEEN";
-	case ExpressionType::COMPARE_NOT_BETWEEN:
-		return "COMPARE_NOT_BETWEEN";
-	case ExpressionType::VALUE_DEFAULT:
-		return "VALUE_DEFAULT";
-	case ExpressionType::BOUND_REF:
-		return "BOUND_REF";
-	case ExpressionType::BOUND_COLUMN_REF:
-		return "BOUND_COLUMN_REF";
-	case ExpressionType::BOUND_FUNCTION:
-		return "BOUND_FUNCTION";
-	case ExpressionType::BOUND_AGGREGATE:
-		return "BOUND_AGGREGATE";
-	case ExpressionType::GROUPING_FUNCTION:
-		return "GROUPING";
-	case ExpressionType::ARRAY_CONSTRUCTOR:
-		return "ARRAY_CONSTRUCTOR";
-	case ExpressionType::TABLE_STAR:
-		return "TABLE_STAR";
-	case ExpressionType::BOUND_UNNEST:
-		return "BOUND_UNNEST";
-	case ExpressionType::COLLATE:
-		return "COLLATE";
-	case ExpressionType::POSITIONAL_REFERENCE:
-		return "POSITIONAL_REFERENCE";
-	case ExpressionType::BOUND_LAMBDA_REF:
-		return "BOUND_LAMBDA_REF";
-	case ExpressionType::LAMBDA:
-		return "LAMBDA";
-	case ExpressionType::ARROW:
-		return "ARROW";
-	case ExpressionType::BOUND_EXPANDED:
-		return "BOUND_EXPANDED";
-	case ExpressionType::INVALID:
-		break;
-	}
-	return "INVALID";
-}
-string ExpressionClassToString(ExpressionClass type) {
-	switch (type) {
-	case ExpressionClass::INVALID:
-		return "INVALID";
-	case ExpressionClass::AGGREGATE:
-		return "AGGREGATE";
-	case ExpressionClass::CASE:
-		return "CASE";
-	case ExpressionClass::CAST:
-		return "CAST";
-	case ExpressionClass::COLUMN_REF:
-		return "COLUMN_REF";
-	case ExpressionClass::LAMBDA_REF:
-		return "LAMBDA_REF";
-	case ExpressionClass::COMPARISON:
-		return "COMPARISON";
-	case ExpressionClass::CONJUNCTION:
-		return "CONJUNCTION";
-	case ExpressionClass::CONSTANT:
-		return "CONSTANT";
-	case ExpressionClass::DEFAULT:
-		return "DEFAULT";
-	case ExpressionClass::FUNCTION:
-		return "FUNCTION";
-	case ExpressionClass::OPERATOR:
-		return "OPERATOR";
-	case ExpressionClass::STAR:
-		return "STAR";
-	case ExpressionClass::SUBQUERY:
-		return "SUBQUERY";
-	case ExpressionClass::WINDOW:
-		return "WINDOW";
-	case ExpressionClass::PARAMETER:
-		return "PARAMETER";
-	case ExpressionClass::COLLATE:
-		return "COLLATE";
-	case ExpressionClass::LAMBDA:
-		return "LAMBDA";
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return "POSITIONAL_REFERENCE";
-	case ExpressionClass::BETWEEN:
-		return "BETWEEN";
-	case ExpressionClass::BOUND_AGGREGATE:
-		return "BOUND_AGGREGATE";
-	case ExpressionClass::BOUND_CASE:
-		return "BOUND_CASE";
-	case ExpressionClass::BOUND_CAST:
-		return "BOUND_CAST";
-	case ExpressionClass::BOUND_COLUMN_REF:
-		return "BOUND_COLUMN_REF";
-	case ExpressionClass::BOUND_COMPARISON:
-		return "BOUND_COMPARISON";
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return "BOUND_CONJUNCTION";
-	case ExpressionClass::BOUND_CONSTANT:
-		return "BOUND_CONSTANT";
-	case ExpressionClass::BOUND_DEFAULT:
-		return "BOUND_DEFAULT";
-	case ExpressionClass::BOUND_FUNCTION:
-		return "BOUND_FUNCTION";
-	case ExpressionClass::BOUND_OPERATOR:
-		return "BOUND_OPERATOR";
-	case ExpressionClass::BOUND_PARAMETER:
-		return "BOUND_PARAMETER";
-	case ExpressionClass::BOUND_REF:
-		return "BOUND_REF";
-	case ExpressionClass::BOUND_SUBQUERY:
-		return "BOUND_SUBQUERY";
-	case ExpressionClass::BOUND_WINDOW:
-		return "BOUND_WINDOW";
-	case ExpressionClass::BOUND_BETWEEN:
-		return "BOUND_BETWEEN";
-	case ExpressionClass::BOUND_UNNEST:
-		return "BOUND_UNNEST";
-	case ExpressionClass::BOUND_LAMBDA:
-		return "BOUND_LAMBDA";
-	case ExpressionClass::BOUND_EXPRESSION:
-		return "BOUND_EXPRESSION";
-	case ExpressionClass::BOUND_EXPANDED:
-		return "BOUND_EXPANDED";
-	default:
-		return "ExpressionClass::!!UNIMPLEMENTED_CASE!!";
-	}
-}
-
-string ExpressionTypeToOperator(ExpressionType type) {
-	switch (type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return "=";
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return "!=";
-	case ExpressionType::COMPARE_LESSTHAN:
-		return "<";
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return ">";
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return "<=";
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return ">=";
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return "IS DISTINCT FROM";
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return "IS NOT DISTINCT FROM";
-	case ExpressionType::CONJUNCTION_AND:
-		return "AND";
-	case ExpressionType::CONJUNCTION_OR:
-		return "OR";
-	default:
-		return "";
-	}
-}
-
-ExpressionType NegateComparisonExpression(ExpressionType type) {
-	ExpressionType negated_type = ExpressionType::INVALID;
-	switch (type) {
-	case ExpressionType::COMPARE_EQUAL:
-		negated_type = ExpressionType::COMPARE_NOTEQUAL;
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		negated_type = ExpressionType::COMPARE_EQUAL;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		negated_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		negated_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		negated_type = ExpressionType::COMPARE_GREATERTHAN;
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		negated_type = ExpressionType::COMPARE_LESSTHAN;
-		break;
-	default:
-		throw InternalException("Unsupported comparison type in negation");
-	}
-	return negated_type;
-}
-
-ExpressionType FlipComparisonExpression(ExpressionType type) {
-	ExpressionType flipped_type = ExpressionType::INVALID;
-	switch (type) {
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-	case ExpressionType::COMPARE_NOTEQUAL:
-	case ExpressionType::COMPARE_EQUAL:
-		flipped_type = type;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		flipped_type = ExpressionType::COMPARE_GREATERTHAN;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		flipped_type = ExpressionType::COMPARE_LESSTHAN;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		flipped_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		flipped_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-		break;
-	default:
-		throw InternalException("Unsupported comparison type in flip");
-	}
-	return flipped_type;
-}
-
-ExpressionType OperatorToExpressionType(const string &op) {
-	if (op == "=" || op == "==") {
-		return ExpressionType::COMPARE_EQUAL;
-	} else if (op == "!=" || op == "<>") {
-		return ExpressionType::COMPARE_NOTEQUAL;
-	} else if (op == "<") {
-		return ExpressionType::COMPARE_LESSTHAN;
-	} else if (op == ">") {
-		return ExpressionType::COMPARE_GREATERTHAN;
-	} else if (op == "<=") {
-		return ExpressionType::COMPARE_LESSTHANOREQUALTO;
-	} else if (op == ">=") {
-		return ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-	}
-	return ExpressionType::INVALID;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/file_compression_type.cpp b/src/duckdb/src/common/enums/file_compression_type.cpp
deleted file mode 100644
index 44066f32c..000000000
--- a/src/duckdb/src/common/enums/file_compression_type.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/common/enums/file_compression_type.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/exception/parser_exception.hpp"
-
-namespace duckdb {
-
-FileCompressionType FileCompressionTypeFromString(const string &input) {
-	auto parameter = StringUtil::Lower(input);
-	if (parameter == "infer" || parameter == "auto") {
-		return FileCompressionType::AUTO_DETECT;
-	} else if (parameter == "gzip") {
-		return FileCompressionType::GZIP;
-	} else if (parameter == "zstd") {
-		return FileCompressionType::ZSTD;
-	} else if (parameter == "uncompressed" || parameter == "none" || parameter.empty()) {
-		return FileCompressionType::UNCOMPRESSED;
-	} else {
-		throw ParserException("Unrecognized file compression type \"%s\"", input);
-	}
-}
-
-string CompressionExtensionFromType(const FileCompressionType type) {
-	switch (type) {
-	case FileCompressionType::GZIP:
-		return ".gz";
-	case FileCompressionType::ZSTD:
-		return ".zst";
-	default:
-		throw NotImplementedException("Compression Extension of file compression type is not implemented");
-	}
-}
-
-bool IsFileCompressed(string path, FileCompressionType type) {
-	auto extension = CompressionExtensionFromType(type);
-	std::size_t question_mark_pos = std::string::npos;
-	if (!StringUtil::StartsWith(path, "\\\\?\\")) {
-		question_mark_pos = path.find('?');
-	}
-	path = path.substr(0, question_mark_pos);
-	if (StringUtil::EndsWith(path, extension)) {
-		return true;
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/join_type.cpp b/src/duckdb/src/common/enums/join_type.cpp
deleted file mode 100644
index 6bfe54892..000000000
--- a/src/duckdb/src/common/enums/join_type.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-bool IsLeftOuterJoin(JoinType type) {
-	return type == JoinType::LEFT || type == JoinType::OUTER;
-}
-
-bool IsRightOuterJoin(JoinType type) {
-	return type == JoinType::OUTER || type == JoinType::RIGHT;
-}
-
-bool PropagatesBuildSide(JoinType type) {
-	return type == JoinType::OUTER || type == JoinType::RIGHT || type == JoinType::RIGHT_ANTI ||
-	       type == JoinType::RIGHT_SEMI;
-}
-
-bool HasInverseJoinType(JoinType type) {
-	return type != JoinType::SINGLE && type != JoinType::MARK;
-}
-
-JoinType InverseJoinType(JoinType type) {
-	D_ASSERT(HasInverseJoinType(type));
-	switch (type) {
-	case JoinType::LEFT:
-		return JoinType::RIGHT;
-	case JoinType::RIGHT:
-		return JoinType::LEFT;
-	case JoinType::INNER:
-		return JoinType::INNER;
-	case JoinType::OUTER:
-		return JoinType::OUTER;
-	case JoinType::SEMI:
-		return JoinType::RIGHT_SEMI;
-	case JoinType::ANTI:
-		return JoinType::RIGHT_ANTI;
-	case JoinType::RIGHT_SEMI:
-		return JoinType::SEMI;
-	case JoinType::RIGHT_ANTI:
-		return JoinType::ANTI;
-	default:
-		throw NotImplementedException("InverseJoinType for JoinType::%s", EnumUtil::ToString(type));
-	}
-}
-
-// **DEPRECATED**: Use EnumUtil directly instead.
-string JoinTypeToString(JoinType type) {
-	return EnumUtil::ToString(type);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/logical_operator_type.cpp b/src/duckdb/src/common/enums/logical_operator_type.cpp
deleted file mode 100644
index 550bea5be..000000000
--- a/src/duckdb/src/common/enums/logical_operator_type.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#include "duckdb/common/enums/logical_operator_type.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Value <--> String Utilities
-//===--------------------------------------------------------------------===//
-// LCOV_EXCL_START
-string LogicalOperatorToString(LogicalOperatorType type) {
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_GET:
-		return "GET";
-	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		return "CHUNK_GET";
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		return "DELIM_GET";
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		return "EMPTY_RESULT";
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		return "EXPRESSION_GET";
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		return "ANY_JOIN";
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		return "ASOF_JOIN";
-	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
-		return "DEPENDENT_JOIN";
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		return "COMPARISON_JOIN";
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return "DELIM_JOIN";
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return "PROJECTION";
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return "FILTER";
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return "AGGREGATE";
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		return "WINDOW";
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		return "UNNEST";
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		return "LIMIT";
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		return "ORDER_BY";
-	case LogicalOperatorType::LOGICAL_TOP_N:
-		return "TOP_N";
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		return "SAMPLE";
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		return "COPY_TO_FILE";
-	case LogicalOperatorType::LOGICAL_COPY_DATABASE:
-		return "COPY_DATABASE";
-	case LogicalOperatorType::LOGICAL_JOIN:
-		return "JOIN";
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return "CROSS_PRODUCT";
-	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		return "POSITIONAL_JOIN";
-	case LogicalOperatorType::LOGICAL_UNION:
-		return "UNION";
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		return "EXCEPT";
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		return "INTERSECT";
-	case LogicalOperatorType::LOGICAL_INSERT:
-		return "INSERT";
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		return "DISTINCT";
-	case LogicalOperatorType::LOGICAL_DELETE:
-		return "DELETE";
-	case LogicalOperatorType::LOGICAL_UPDATE:
-		return "UPDATE";
-	case LogicalOperatorType::LOGICAL_PREPARE:
-		return "PREPARE";
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		return "DUMMY_SCAN";
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		return "CREATE_INDEX";
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		return "CREATE_TABLE";
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		return "CREATE_MACRO";
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		return "EXPLAIN";
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-		return "EXECUTE";
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		return "VACUUM";
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		return "REC_CTE";
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-		return "CTE";
-	case LogicalOperatorType::LOGICAL_CTE_REF:
-		return "CTE_SCAN";
-	case LogicalOperatorType::LOGICAL_ALTER:
-		return "ALTER";
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		return "CREATE_SEQUENCE";
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		return "CREATE_TYPE";
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		return "CREATE_VIEW";
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		return "CREATE_SCHEMA";
-	case LogicalOperatorType::LOGICAL_CREATE_SECRET:
-		return "CREATE_SECRET";
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		return "ATTACH";
-	case LogicalOperatorType::LOGICAL_DETACH:
-		return "DETACH";
-	case LogicalOperatorType::LOGICAL_DROP:
-		return "DROP";
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-		return "PRAGMA";
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		return "TRANSACTION";
-	case LogicalOperatorType::LOGICAL_EXPORT:
-		return "EXPORT";
-	case LogicalOperatorType::LOGICAL_SET:
-		return "SET";
-	case LogicalOperatorType::LOGICAL_RESET:
-		return "RESET";
-	case LogicalOperatorType::LOGICAL_LOAD:
-		return "LOAD";
-	case LogicalOperatorType::LOGICAL_INVALID:
-		break;
-	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		return "CUSTOM_OP";
-	case LogicalOperatorType::LOGICAL_PIVOT:
-		return "PIVOT";
-	case LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS:
-		return "UPDATE_EXTENSIONS";
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/metric_type.cpp b/src/duckdb/src/common/enums/metric_type.cpp
deleted file mode 100644
index 94a75cc1e..000000000
--- a/src/duckdb/src/common/enums/metric_type.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-//-------------------------------------------------------------------------
-//                         DuckDB
-//
-//
-// duckdb/common/enums/metrics_type.hpp
-// 
-// This file is automatically generated by scripts/generate_metric_enums.py
-// Do not edit this file manually, your changes will be overwritten
-//-------------------------------------------------------------------------
-
-#include "duckdb/common/enums/metric_type.hpp"
-namespace duckdb {
-
-profiler_settings_t MetricsUtils::GetOptimizerMetrics() {
-    return {
-        MetricsType::OPTIMIZER_EXPRESSION_REWRITER,
-        MetricsType::OPTIMIZER_FILTER_PULLUP,
-        MetricsType::OPTIMIZER_FILTER_PUSHDOWN,
-        MetricsType::OPTIMIZER_EMPTY_RESULT_PULLUP,
-        MetricsType::OPTIMIZER_CTE_FILTER_PUSHER,
-        MetricsType::OPTIMIZER_REGEX_RANGE,
-        MetricsType::OPTIMIZER_IN_CLAUSE,
-        MetricsType::OPTIMIZER_JOIN_ORDER,
-        MetricsType::OPTIMIZER_DELIMINATOR,
-        MetricsType::OPTIMIZER_UNNEST_REWRITER,
-        MetricsType::OPTIMIZER_UNUSED_COLUMNS,
-        MetricsType::OPTIMIZER_STATISTICS_PROPAGATION,
-        MetricsType::OPTIMIZER_COMMON_SUBEXPRESSIONS,
-        MetricsType::OPTIMIZER_COMMON_AGGREGATE,
-        MetricsType::OPTIMIZER_COLUMN_LIFETIME,
-        MetricsType::OPTIMIZER_BUILD_SIDE_PROBE_SIDE,
-        MetricsType::OPTIMIZER_LIMIT_PUSHDOWN,
-        MetricsType::OPTIMIZER_TOP_N,
-        MetricsType::OPTIMIZER_COMPRESSED_MATERIALIZATION,
-        MetricsType::OPTIMIZER_DUPLICATE_GROUPS,
-        MetricsType::OPTIMIZER_REORDER_FILTER,
-        MetricsType::OPTIMIZER_SAMPLING_PUSHDOWN,
-        MetricsType::OPTIMIZER_JOIN_FILTER_PUSHDOWN,
-        MetricsType::OPTIMIZER_EXTENSION,
-        MetricsType::OPTIMIZER_MATERIALIZED_CTE,
-        MetricsType::OPTIMIZER_SUM_REWRITER,
-    };
-}
-
-profiler_settings_t MetricsUtils::GetPhaseTimingMetrics() {
-    return {
-        MetricsType::ALL_OPTIMIZERS,
-        MetricsType::CUMULATIVE_OPTIMIZER_TIMING,
-        MetricsType::PLANNER,
-        MetricsType::PLANNER_BINDING,
-        MetricsType::PHYSICAL_PLANNER,
-        MetricsType::PHYSICAL_PLANNER_COLUMN_BINDING,
-        MetricsType::PHYSICAL_PLANNER_RESOLVE_TYPES,
-        MetricsType::PHYSICAL_PLANNER_CREATE_PLAN,
-    };
-}
-
-MetricsType MetricsUtils::GetOptimizerMetricByType(OptimizerType type) {
-    switch(type) {
-        case OptimizerType::EXPRESSION_REWRITER:
-            return MetricsType::OPTIMIZER_EXPRESSION_REWRITER;
-        case OptimizerType::FILTER_PULLUP:
-            return MetricsType::OPTIMIZER_FILTER_PULLUP;
-        case OptimizerType::FILTER_PUSHDOWN:
-            return MetricsType::OPTIMIZER_FILTER_PUSHDOWN;
-        case OptimizerType::EMPTY_RESULT_PULLUP:
-            return MetricsType::OPTIMIZER_EMPTY_RESULT_PULLUP;
-        case OptimizerType::CTE_FILTER_PUSHER:
-            return MetricsType::OPTIMIZER_CTE_FILTER_PUSHER;
-        case OptimizerType::REGEX_RANGE:
-            return MetricsType::OPTIMIZER_REGEX_RANGE;
-        case OptimizerType::IN_CLAUSE:
-            return MetricsType::OPTIMIZER_IN_CLAUSE;
-        case OptimizerType::JOIN_ORDER:
-            return MetricsType::OPTIMIZER_JOIN_ORDER;
-        case OptimizerType::DELIMINATOR:
-            return MetricsType::OPTIMIZER_DELIMINATOR;
-        case OptimizerType::UNNEST_REWRITER:
-            return MetricsType::OPTIMIZER_UNNEST_REWRITER;
-        case OptimizerType::UNUSED_COLUMNS:
-            return MetricsType::OPTIMIZER_UNUSED_COLUMNS;
-        case OptimizerType::STATISTICS_PROPAGATION:
-            return MetricsType::OPTIMIZER_STATISTICS_PROPAGATION;
-        case OptimizerType::COMMON_SUBEXPRESSIONS:
-            return MetricsType::OPTIMIZER_COMMON_SUBEXPRESSIONS;
-        case OptimizerType::COMMON_AGGREGATE:
-            return MetricsType::OPTIMIZER_COMMON_AGGREGATE;
-        case OptimizerType::COLUMN_LIFETIME:
-            return MetricsType::OPTIMIZER_COLUMN_LIFETIME;
-        case OptimizerType::BUILD_SIDE_PROBE_SIDE:
-            return MetricsType::OPTIMIZER_BUILD_SIDE_PROBE_SIDE;
-        case OptimizerType::LIMIT_PUSHDOWN:
-            return MetricsType::OPTIMIZER_LIMIT_PUSHDOWN;
-        case OptimizerType::TOP_N:
-            return MetricsType::OPTIMIZER_TOP_N;
-        case OptimizerType::COMPRESSED_MATERIALIZATION:
-            return MetricsType::OPTIMIZER_COMPRESSED_MATERIALIZATION;
-        case OptimizerType::DUPLICATE_GROUPS:
-            return MetricsType::OPTIMIZER_DUPLICATE_GROUPS;
-        case OptimizerType::REORDER_FILTER:
-            return MetricsType::OPTIMIZER_REORDER_FILTER;
-        case OptimizerType::SAMPLING_PUSHDOWN:
-            return MetricsType::OPTIMIZER_SAMPLING_PUSHDOWN;
-        case OptimizerType::JOIN_FILTER_PUSHDOWN:
-            return MetricsType::OPTIMIZER_JOIN_FILTER_PUSHDOWN;
-        case OptimizerType::EXTENSION:
-            return MetricsType::OPTIMIZER_EXTENSION;
-        case OptimizerType::MATERIALIZED_CTE:
-            return MetricsType::OPTIMIZER_MATERIALIZED_CTE;
-        case OptimizerType::SUM_REWRITER:
-            return MetricsType::OPTIMIZER_SUM_REWRITER;
-       default:
-            throw InternalException("OptimizerType %s cannot be converted to a MetricsType", EnumUtil::ToString(type));
-    };
-}
-
-OptimizerType MetricsUtils::GetOptimizerTypeByMetric(MetricsType type) {
-    switch(type) {
-        case MetricsType::OPTIMIZER_EXPRESSION_REWRITER:
-            return OptimizerType::EXPRESSION_REWRITER;
-        case MetricsType::OPTIMIZER_FILTER_PULLUP:
-            return OptimizerType::FILTER_PULLUP;
-        case MetricsType::OPTIMIZER_FILTER_PUSHDOWN:
-            return OptimizerType::FILTER_PUSHDOWN;
-        case MetricsType::OPTIMIZER_EMPTY_RESULT_PULLUP:
-            return OptimizerType::EMPTY_RESULT_PULLUP;
-        case MetricsType::OPTIMIZER_CTE_FILTER_PUSHER:
-            return OptimizerType::CTE_FILTER_PUSHER;
-        case MetricsType::OPTIMIZER_REGEX_RANGE:
-            return OptimizerType::REGEX_RANGE;
-        case MetricsType::OPTIMIZER_IN_CLAUSE:
-            return OptimizerType::IN_CLAUSE;
-        case MetricsType::OPTIMIZER_JOIN_ORDER:
-            return OptimizerType::JOIN_ORDER;
-        case MetricsType::OPTIMIZER_DELIMINATOR:
-            return OptimizerType::DELIMINATOR;
-        case MetricsType::OPTIMIZER_UNNEST_REWRITER:
-            return OptimizerType::UNNEST_REWRITER;
-        case MetricsType::OPTIMIZER_UNUSED_COLUMNS:
-            return OptimizerType::UNUSED_COLUMNS;
-        case MetricsType::OPTIMIZER_STATISTICS_PROPAGATION:
-            return OptimizerType::STATISTICS_PROPAGATION;
-        case MetricsType::OPTIMIZER_COMMON_SUBEXPRESSIONS:
-            return OptimizerType::COMMON_SUBEXPRESSIONS;
-        case MetricsType::OPTIMIZER_COMMON_AGGREGATE:
-            return OptimizerType::COMMON_AGGREGATE;
-        case MetricsType::OPTIMIZER_COLUMN_LIFETIME:
-            return OptimizerType::COLUMN_LIFETIME;
-        case MetricsType::OPTIMIZER_BUILD_SIDE_PROBE_SIDE:
-            return OptimizerType::BUILD_SIDE_PROBE_SIDE;
-        case MetricsType::OPTIMIZER_LIMIT_PUSHDOWN:
-            return OptimizerType::LIMIT_PUSHDOWN;
-        case MetricsType::OPTIMIZER_TOP_N:
-            return OptimizerType::TOP_N;
-        case MetricsType::OPTIMIZER_COMPRESSED_MATERIALIZATION:
-            return OptimizerType::COMPRESSED_MATERIALIZATION;
-        case MetricsType::OPTIMIZER_DUPLICATE_GROUPS:
-            return OptimizerType::DUPLICATE_GROUPS;
-        case MetricsType::OPTIMIZER_REORDER_FILTER:
-            return OptimizerType::REORDER_FILTER;
-        case MetricsType::OPTIMIZER_SAMPLING_PUSHDOWN:
-            return OptimizerType::SAMPLING_PUSHDOWN;
-        case MetricsType::OPTIMIZER_JOIN_FILTER_PUSHDOWN:
-            return OptimizerType::JOIN_FILTER_PUSHDOWN;
-        case MetricsType::OPTIMIZER_EXTENSION:
-            return OptimizerType::EXTENSION;
-        case MetricsType::OPTIMIZER_MATERIALIZED_CTE:
-            return OptimizerType::MATERIALIZED_CTE;
-        case MetricsType::OPTIMIZER_SUM_REWRITER:
-            return OptimizerType::SUM_REWRITER;
-    default:
-            return OptimizerType::INVALID;
-    };
-}
-
-bool MetricsUtils::IsOptimizerMetric(MetricsType type) {
-    switch(type) {
-        case MetricsType::OPTIMIZER_EXPRESSION_REWRITER:
-        case MetricsType::OPTIMIZER_FILTER_PULLUP:
-        case MetricsType::OPTIMIZER_FILTER_PUSHDOWN:
-        case MetricsType::OPTIMIZER_EMPTY_RESULT_PULLUP:
-        case MetricsType::OPTIMIZER_CTE_FILTER_PUSHER:
-        case MetricsType::OPTIMIZER_REGEX_RANGE:
-        case MetricsType::OPTIMIZER_IN_CLAUSE:
-        case MetricsType::OPTIMIZER_JOIN_ORDER:
-        case MetricsType::OPTIMIZER_DELIMINATOR:
-        case MetricsType::OPTIMIZER_UNNEST_REWRITER:
-        case MetricsType::OPTIMIZER_UNUSED_COLUMNS:
-        case MetricsType::OPTIMIZER_STATISTICS_PROPAGATION:
-        case MetricsType::OPTIMIZER_COMMON_SUBEXPRESSIONS:
-        case MetricsType::OPTIMIZER_COMMON_AGGREGATE:
-        case MetricsType::OPTIMIZER_COLUMN_LIFETIME:
-        case MetricsType::OPTIMIZER_BUILD_SIDE_PROBE_SIDE:
-        case MetricsType::OPTIMIZER_LIMIT_PUSHDOWN:
-        case MetricsType::OPTIMIZER_TOP_N:
-        case MetricsType::OPTIMIZER_COMPRESSED_MATERIALIZATION:
-        case MetricsType::OPTIMIZER_DUPLICATE_GROUPS:
-        case MetricsType::OPTIMIZER_REORDER_FILTER:
-        case MetricsType::OPTIMIZER_SAMPLING_PUSHDOWN:
-        case MetricsType::OPTIMIZER_JOIN_FILTER_PUSHDOWN:
-        case MetricsType::OPTIMIZER_EXTENSION:
-        case MetricsType::OPTIMIZER_MATERIALIZED_CTE:
-        case MetricsType::OPTIMIZER_SUM_REWRITER:
-            return true;
-        default:
-            return false;
-    };
-}
-
-bool MetricsUtils::IsPhaseTimingMetric(MetricsType type) {
-    switch(type) {
-        case MetricsType::ALL_OPTIMIZERS:
-        case MetricsType::CUMULATIVE_OPTIMIZER_TIMING:
-        case MetricsType::PLANNER:
-        case MetricsType::PLANNER_BINDING:
-        case MetricsType::PHYSICAL_PLANNER:
-        case MetricsType::PHYSICAL_PLANNER_COLUMN_BINDING:
-        case MetricsType::PHYSICAL_PLANNER_RESOLVE_TYPES:
-        case MetricsType::PHYSICAL_PLANNER_CREATE_PLAN:
-            return true;
-        default:
-            return false;
-    };
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/optimizer_type.cpp b/src/duckdb/src/common/enums/optimizer_type.cpp
deleted file mode 100644
index f2555dc58..000000000
--- a/src/duckdb/src/common/enums/optimizer_type.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "duckdb/common/enums/optimizer_type.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/exception/parser_exception.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-struct DefaultOptimizerType {
-	const char *name;
-	OptimizerType type;
-};
-
-static const DefaultOptimizerType internal_optimizer_types[] = {
-    {"expression_rewriter", OptimizerType::EXPRESSION_REWRITER},
-    {"filter_pullup", OptimizerType::FILTER_PULLUP},
-    {"filter_pushdown", OptimizerType::FILTER_PUSHDOWN},
-    {"empty_result_pullup", OptimizerType::EMPTY_RESULT_PULLUP},
-    {"cte_filter_pusher", OptimizerType::CTE_FILTER_PUSHER},
-    {"regex_range", OptimizerType::REGEX_RANGE},
-    {"in_clause", OptimizerType::IN_CLAUSE},
-    {"join_order", OptimizerType::JOIN_ORDER},
-    {"deliminator", OptimizerType::DELIMINATOR},
-    {"unnest_rewriter", OptimizerType::UNNEST_REWRITER},
-    {"unused_columns", OptimizerType::UNUSED_COLUMNS},
-    {"statistics_propagation", OptimizerType::STATISTICS_PROPAGATION},
-    {"common_subexpressions", OptimizerType::COMMON_SUBEXPRESSIONS},
-    {"common_aggregate", OptimizerType::COMMON_AGGREGATE},
-    {"column_lifetime", OptimizerType::COLUMN_LIFETIME},
-    {"limit_pushdown", OptimizerType::LIMIT_PUSHDOWN},
-    {"top_n", OptimizerType::TOP_N},
-    {"build_side_probe_side", OptimizerType::BUILD_SIDE_PROBE_SIDE},
-    {"compressed_materialization", OptimizerType::COMPRESSED_MATERIALIZATION},
-    {"duplicate_groups", OptimizerType::DUPLICATE_GROUPS},
-    {"reorder_filter", OptimizerType::REORDER_FILTER},
-    {"sampling_pushdown", OptimizerType::SAMPLING_PUSHDOWN},
-    {"join_filter_pushdown", OptimizerType::JOIN_FILTER_PUSHDOWN},
-    {"extension", OptimizerType::EXTENSION},
-    {"materialized_cte", OptimizerType::MATERIALIZED_CTE},
-    {"sum_rewriter", OptimizerType::SUM_REWRITER},
-    {nullptr, OptimizerType::INVALID}};
-
-string OptimizerTypeToString(OptimizerType type) {
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		if (internal_optimizer_types[i].type == type) {
-			return internal_optimizer_types[i].name;
-		}
-	}
-	throw InternalException("Invalid optimizer type");
-}
-
-vector<string> ListAllOptimizers() {
-	vector<string> result;
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		result.push_back(internal_optimizer_types[i].name);
-	}
-	return result;
-}
-
-OptimizerType OptimizerTypeFromString(const string &str) {
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		if (internal_optimizer_types[i].name == str) {
-			return internal_optimizer_types[i].type;
-		}
-	}
-	// optimizer not found, construct candidate list
-	vector<string> optimizer_names;
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		optimizer_names.emplace_back(internal_optimizer_types[i].name);
-	}
-	throw ParserException("Optimizer type \"%s\" not recognized\n%s", str,
-	                      StringUtil::CandidatesErrorMessage(optimizer_names, str, "Candidate optimizers"));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/physical_operator_type.cpp b/src/duckdb/src/common/enums/physical_operator_type.cpp
deleted file mode 100644
index f520cb448..000000000
--- a/src/duckdb/src/common/enums/physical_operator_type.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#include "duckdb/common/enums/physical_operator_type.hpp"
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string PhysicalOperatorToString(PhysicalOperatorType type) {
-	switch (type) {
-	case PhysicalOperatorType::TABLE_SCAN:
-		return "TABLE_SCAN";
-	case PhysicalOperatorType::DUMMY_SCAN:
-		return "DUMMY_SCAN";
-	case PhysicalOperatorType::CHUNK_SCAN:
-		return "CHUNK_SCAN";
-	case PhysicalOperatorType::COLUMN_DATA_SCAN:
-		return "COLUMN_DATA_SCAN";
-	case PhysicalOperatorType::DELIM_SCAN:
-		return "DELIM_SCAN";
-	case PhysicalOperatorType::ORDER_BY:
-		return "ORDER_BY";
-	case PhysicalOperatorType::LIMIT:
-		return "LIMIT";
-	case PhysicalOperatorType::LIMIT_PERCENT:
-		return "LIMIT_PERCENT";
-	case PhysicalOperatorType::STREAMING_LIMIT:
-		return "STREAMING_LIMIT";
-	case PhysicalOperatorType::RESERVOIR_SAMPLE:
-		return "RESERVOIR_SAMPLE";
-	case PhysicalOperatorType::STREAMING_SAMPLE:
-		return "STREAMING_SAMPLE";
-	case PhysicalOperatorType::TOP_N:
-		return "TOP_N";
-	case PhysicalOperatorType::WINDOW:
-		return "WINDOW";
-	case PhysicalOperatorType::STREAMING_WINDOW:
-		return "STREAMING_WINDOW";
-	case PhysicalOperatorType::UNNEST:
-		return "UNNEST";
-	case PhysicalOperatorType::UNGROUPED_AGGREGATE:
-		return "UNGROUPED_AGGREGATE";
-	case PhysicalOperatorType::HASH_GROUP_BY:
-		return "HASH_GROUP_BY";
-	case PhysicalOperatorType::PERFECT_HASH_GROUP_BY:
-		return "PERFECT_HASH_GROUP_BY";
-	case PhysicalOperatorType::PARTITIONED_AGGREGATE:
-		return "PARTITIONED_AGGREGATE";
-	case PhysicalOperatorType::FILTER:
-		return "FILTER";
-	case PhysicalOperatorType::PROJECTION:
-		return "PROJECTION";
-	case PhysicalOperatorType::COPY_TO_FILE:
-		return "COPY_TO_FILE";
-	case PhysicalOperatorType::BATCH_COPY_TO_FILE:
-		return "BATCH_COPY_TO_FILE";
-	case PhysicalOperatorType::LEFT_DELIM_JOIN:
-		return "LEFT_DELIM_JOIN";
-	case PhysicalOperatorType::RIGHT_DELIM_JOIN:
-		return "RIGHT_DELIM_JOIN";
-	case PhysicalOperatorType::BLOCKWISE_NL_JOIN:
-		return "BLOCKWISE_NL_JOIN";
-	case PhysicalOperatorType::NESTED_LOOP_JOIN:
-		return "NESTED_LOOP_JOIN";
-	case PhysicalOperatorType::HASH_JOIN:
-		return "HASH_JOIN";
-	case PhysicalOperatorType::PIECEWISE_MERGE_JOIN:
-		return "PIECEWISE_MERGE_JOIN";
-	case PhysicalOperatorType::IE_JOIN:
-		return "IE_JOIN";
-	case PhysicalOperatorType::ASOF_JOIN:
-		return "ASOF_JOIN";
-	case PhysicalOperatorType::CROSS_PRODUCT:
-		return "CROSS_PRODUCT";
-	case PhysicalOperatorType::POSITIONAL_JOIN:
-		return "POSITIONAL_JOIN";
-	case PhysicalOperatorType::POSITIONAL_SCAN:
-		return "POSITIONAL_SCAN";
-	case PhysicalOperatorType::UNION:
-		return "UNION";
-	case PhysicalOperatorType::INSERT:
-		return "INSERT";
-	case PhysicalOperatorType::BATCH_INSERT:
-		return "BATCH_INSERT";
-	case PhysicalOperatorType::DELETE_OPERATOR:
-		return "DELETE";
-	case PhysicalOperatorType::UPDATE:
-		return "UPDATE";
-	case PhysicalOperatorType::EMPTY_RESULT:
-		return "EMPTY_RESULT";
-	case PhysicalOperatorType::CREATE_TABLE:
-		return "CREATE_TABLE";
-	case PhysicalOperatorType::CREATE_TABLE_AS:
-		return "CREATE_TABLE_AS";
-	case PhysicalOperatorType::BATCH_CREATE_TABLE_AS:
-		return "BATCH_CREATE_TABLE_AS";
-	case PhysicalOperatorType::CREATE_INDEX:
-		return "CREATE_INDEX";
-	case PhysicalOperatorType::EXPLAIN:
-		return "EXPLAIN";
-	case PhysicalOperatorType::EXPLAIN_ANALYZE:
-		return "EXPLAIN_ANALYZE";
-	case PhysicalOperatorType::EXECUTE:
-		return "EXECUTE";
-	case PhysicalOperatorType::VACUUM:
-		return "VACUUM";
-	case PhysicalOperatorType::RECURSIVE_CTE:
-		return "REC_CTE";
-	case PhysicalOperatorType::CTE:
-		return "CTE";
-	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
-		return "REC_CTE_SCAN";
-	case PhysicalOperatorType::CTE_SCAN:
-		return "CTE_SCAN";
-	case PhysicalOperatorType::EXPRESSION_SCAN:
-		return "EXPRESSION_SCAN";
-	case PhysicalOperatorType::ALTER:
-		return "ALTER";
-	case PhysicalOperatorType::CREATE_SEQUENCE:
-		return "CREATE_SEQUENCE";
-	case PhysicalOperatorType::CREATE_VIEW:
-		return "CREATE_VIEW";
-	case PhysicalOperatorType::CREATE_SCHEMA:
-		return "CREATE_SCHEMA";
-	case PhysicalOperatorType::CREATE_MACRO:
-		return "CREATE_MACRO";
-	case PhysicalOperatorType::CREATE_SECRET:
-		return "CREATE_SECRET";
-	case PhysicalOperatorType::DROP:
-		return "DROP";
-	case PhysicalOperatorType::PRAGMA:
-		return "PRAGMA";
-	case PhysicalOperatorType::TRANSACTION:
-		return "TRANSACTION";
-	case PhysicalOperatorType::PREPARE:
-		return "PREPARE";
-	case PhysicalOperatorType::EXPORT:
-		return "EXPORT";
-	case PhysicalOperatorType::SET:
-		return "SET";
-	case PhysicalOperatorType::SET_VARIABLE:
-		return "SET_VARIABLE";
-	case PhysicalOperatorType::RESET:
-		return "RESET";
-	case PhysicalOperatorType::LOAD:
-		return "LOAD";
-	case PhysicalOperatorType::INOUT_FUNCTION:
-		return "INOUT_FUNCTION";
-	case PhysicalOperatorType::CREATE_TYPE:
-		return "CREATE_TYPE";
-	case PhysicalOperatorType::ATTACH:
-		return "ATTACH";
-	case PhysicalOperatorType::DETACH:
-		return "DETACH";
-	case PhysicalOperatorType::RESULT_COLLECTOR:
-		return "RESULT_COLLECTOR";
-	case PhysicalOperatorType::EXTENSION:
-		return "EXTENSION";
-	case PhysicalOperatorType::PIVOT:
-		return "PIVOT";
-	case PhysicalOperatorType::COPY_DATABASE:
-		return "COPY_DATABASE";
-	case PhysicalOperatorType::VERIFY_VECTOR:
-		return "VERIFY_VECTOR";
-	case PhysicalOperatorType::UPDATE_EXTENSIONS:
-		return "UPDATE_EXTENSIONS";
-	case PhysicalOperatorType::INVALID:
-		break;
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/relation_type.cpp b/src/duckdb/src/common/enums/relation_type.cpp
deleted file mode 100644
index 4f58ed7c4..000000000
--- a/src/duckdb/src/common/enums/relation_type.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "duckdb/common/enums/relation_type.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string RelationTypeToString(RelationType type) {
-	switch (type) {
-	case RelationType::TABLE_RELATION:
-		return "TABLE_RELATION";
-	case RelationType::DELIM_GET_RELATION:
-		return "DELIM_GET_RELATION";
-	case RelationType::DELIM_JOIN_RELATION:
-		return "DELIM_JOIN_RELATION";
-	case RelationType::PROJECTION_RELATION:
-		return "PROJECTION_RELATION";
-	case RelationType::FILTER_RELATION:
-		return "FILTER_RELATION";
-	case RelationType::EXPLAIN_RELATION:
-		return "EXPLAIN_RELATION";
-	case RelationType::CROSS_PRODUCT_RELATION:
-		return "CROSS_PRODUCT_RELATION";
-	case RelationType::JOIN_RELATION:
-		return "JOIN_RELATION";
-	case RelationType::AGGREGATE_RELATION:
-		return "AGGREGATE_RELATION";
-	case RelationType::SET_OPERATION_RELATION:
-		return "SET_OPERATION_RELATION";
-	case RelationType::DISTINCT_RELATION:
-		return "DISTINCT_RELATION";
-	case RelationType::LIMIT_RELATION:
-		return "LIMIT_RELATION";
-	case RelationType::ORDER_RELATION:
-		return "ORDER_RELATION";
-	case RelationType::CREATE_VIEW_RELATION:
-		return "CREATE_VIEW_RELATION";
-	case RelationType::CREATE_TABLE_RELATION:
-		return "CREATE_TABLE_RELATION";
-	case RelationType::INSERT_RELATION:
-		return "INSERT_RELATION";
-	case RelationType::VALUE_LIST_RELATION:
-		return "VALUE_LIST_RELATION";
-	case RelationType::MATERIALIZED_RELATION:
-		return "MATERIALIZED_RELATION";
-	case RelationType::DELETE_RELATION:
-		return "DELETE_RELATION";
-	case RelationType::UPDATE_RELATION:
-		return "UPDATE_RELATION";
-	case RelationType::WRITE_CSV_RELATION:
-		return "WRITE_CSV_RELATION";
-	case RelationType::WRITE_PARQUET_RELATION:
-		return "WRITE_PARQUET_RELATION";
-	case RelationType::READ_CSV_RELATION:
-		return "READ_CSV_RELATION";
-	case RelationType::SUBQUERY_RELATION:
-		return "SUBQUERY_RELATION";
-	case RelationType::TABLE_FUNCTION_RELATION:
-		return "TABLE_FUNCTION_RELATION";
-	case RelationType::VIEW_RELATION:
-		return "VIEW_RELATION";
-	case RelationType::QUERY_RELATION:
-		return "QUERY_RELATION";
-	case RelationType::INVALID_RELATION:
-		break;
-	}
-	return "INVALID_RELATION";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/enums/statement_type.cpp b/src/duckdb/src/common/enums/statement_type.cpp
deleted file mode 100644
index 98524b938..000000000
--- a/src/duckdb/src/common/enums/statement_type.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "duckdb/common/enums/statement_type.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string StatementTypeToString(StatementType type) {
-	switch (type) {
-	case StatementType::SELECT_STATEMENT:
-		return "SELECT";
-	case StatementType::INSERT_STATEMENT:
-		return "INSERT";
-	case StatementType::UPDATE_STATEMENT:
-		return "UPDATE";
-	case StatementType::DELETE_STATEMENT:
-		return "DELETE";
-	case StatementType::PREPARE_STATEMENT:
-		return "PREPARE";
-	case StatementType::EXECUTE_STATEMENT:
-		return "EXECUTE";
-	case StatementType::ALTER_STATEMENT:
-		return "ALTER";
-	case StatementType::TRANSACTION_STATEMENT:
-		return "TRANSACTION";
-	case StatementType::COPY_STATEMENT:
-		return "COPY";
-	case StatementType::COPY_DATABASE_STATEMENT:
-		return "COPY_DATABASE";
-	case StatementType::ANALYZE_STATEMENT:
-		return "ANALYZE";
-	case StatementType::VARIABLE_SET_STATEMENT:
-		return "VARIABLE_SET";
-	case StatementType::CREATE_FUNC_STATEMENT:
-		return "CREATE_FUNC";
-	case StatementType::EXPLAIN_STATEMENT:
-		return "EXPLAIN";
-	case StatementType::CREATE_STATEMENT:
-		return "CREATE";
-	case StatementType::DROP_STATEMENT:
-		return "DROP";
-	case StatementType::PRAGMA_STATEMENT:
-		return "PRAGMA";
-	case StatementType::VACUUM_STATEMENT:
-		return "VACUUM";
-	case StatementType::RELATION_STATEMENT:
-		return "RELATION";
-	case StatementType::EXPORT_STATEMENT:
-		return "EXPORT";
-	case StatementType::CALL_STATEMENT:
-		return "CALL";
-	case StatementType::SET_STATEMENT:
-		return "SET";
-	case StatementType::LOAD_STATEMENT:
-		return "LOAD";
-	case StatementType::EXTENSION_STATEMENT:
-		return "EXTENSION";
-	case StatementType::LOGICAL_PLAN_STATEMENT:
-		return "LOGICAL_PLAN";
-	case StatementType::ATTACH_STATEMENT:
-		return "ATTACH";
-	case StatementType::DETACH_STATEMENT:
-		return "DETACH";
-	case StatementType::MULTI_STATEMENT:
-		return "MULTI";
-	case StatementType::UPDATE_EXTENSIONS_STATEMENT:
-		return "UPDATE_EXTENSIONS";
-	case StatementType::INVALID_STATEMENT:
-		break;
-	}
-	return "INVALID";
-}
-
-string StatementReturnTypeToString(StatementReturnType type) {
-	switch (type) {
-	case StatementReturnType::QUERY_RESULT:
-		return "QUERY_RESULT";
-	case StatementReturnType::CHANGED_ROWS:
-		return "CHANGED_ROWS";
-	case StatementReturnType::NOTHING:
-		return "NOTHING";
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-void StatementProperties::RegisterDBRead(Catalog &catalog, ClientContext &context) {
-	auto catalog_identity = CatalogIdentity {catalog.GetOid(), catalog.GetCatalogVersion(context)};
-	D_ASSERT(read_databases.count(catalog.GetName()) == 0 || read_databases[catalog.GetName()] == catalog_identity);
-	read_databases[catalog.GetName()] = catalog_identity;
-}
-
-void StatementProperties::RegisterDBModify(Catalog &catalog, ClientContext &context) {
-	auto catalog_identity = CatalogIdentity {catalog.GetOid(), catalog.GetCatalogVersion(context)};
-	D_ASSERT(modified_databases.count(catalog.GetName()) == 0 ||
-	         modified_databases[catalog.GetName()] == catalog_identity);
-	modified_databases[catalog.GetName()] = catalog_identity;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/error_data.cpp b/src/duckdb/src/common/error_data.cpp
deleted file mode 100644
index 9cca3264c..000000000
--- a/src/duckdb/src/common/error_data.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#include "duckdb/common/error_data.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/stacktrace.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/parser/tableref.hpp"
-
-namespace duckdb {
-
-ErrorData::ErrorData() : initialized(false), type(ExceptionType::INVALID) {
-}
-
-ErrorData::ErrorData(const std::exception &ex) : ErrorData(ex.what()) {
-}
-
-ErrorData::ErrorData(ExceptionType type, const string &message)
-    : initialized(true), type(type), raw_message(SanitizeErrorMessage(message)),
-      final_message(ConstructFinalMessage()) {
-}
-
-ErrorData::ErrorData(const string &message)
-    : initialized(true), type(ExceptionType::INVALID), raw_message(string()), final_message(string()) {
-
-	// parse the constructed JSON
-	if (message.empty() || message[0] != '{') {
-		// not JSON! Use the message as a raw Exception message and leave type as uninitialized
-
-		if (message == std::bad_alloc().what()) {
-			type = ExceptionType::OUT_OF_MEMORY;
-			raw_message = "Allocation failure";
-		} else {
-			raw_message = message;
-		}
-	} else {
-		auto info = StringUtil::ParseJSONMap(message);
-		for (auto &entry : info) {
-			if (entry.first == "exception_type") {
-				type = Exception::StringToExceptionType(entry.second);
-			} else if (entry.first == "exception_message") {
-				raw_message = SanitizeErrorMessage(entry.second);
-			} else {
-				extra_info[entry.first] = entry.second;
-			}
-		}
-	}
-
-	final_message = ConstructFinalMessage();
-}
-
-string ErrorData::SanitizeErrorMessage(string error) {
-	return StringUtil::Replace(std::move(error), string("\0", 1), "\\0");
-}
-
-string ErrorData::ConstructFinalMessage() const {
-	std::string error;
-	if (type != ExceptionType::UNKNOWN_TYPE) {
-		error = Exception::ExceptionTypeToString(type) + " ";
-	}
-	error += "Error: " + raw_message;
-	if (type == ExceptionType::INTERNAL) {
-		error += "\nThis error signals an assertion failure within DuckDB. This usually occurs due to "
-		         "unexpected conditions or errors in the program's logic.\nFor more information, see "
-		         "https://duckdb.org/docs/dev/internal_errors";
-	}
-	return error;
-}
-
-void ErrorData::Throw(const string &prepended_message) const {
-	D_ASSERT(initialized);
-	if (!prepended_message.empty()) {
-		string new_message = prepended_message + raw_message;
-		throw Exception(type, new_message, extra_info);
-	} else {
-		throw Exception(type, raw_message, extra_info);
-	}
-}
-
-const ExceptionType &ErrorData::Type() const {
-	D_ASSERT(initialized);
-	return this->type;
-}
-
-bool ErrorData::operator==(const ErrorData &other) const {
-	if (initialized != other.initialized) {
-		return false;
-	}
-	if (type != other.type) {
-		return false;
-	}
-	return raw_message == other.raw_message;
-}
-
-void ErrorData::ConvertErrorToJSON() {
-	if (raw_message.empty() || raw_message[0] == '{') {
-		// empty or already JSON
-		return;
-	}
-	raw_message = StringUtil::ExceptionToJSONMap(type, raw_message, extra_info);
-	final_message = raw_message;
-}
-
-void ErrorData::FinalizeError() {
-	auto entry = extra_info.find("stack_trace_pointers");
-	if (entry != extra_info.end()) {
-		auto stack_trace = StackTrace::ResolveStacktraceSymbols(entry->second);
-		extra_info["stack_trace"] = std::move(stack_trace);
-		extra_info.erase("stack_trace_pointers");
-	}
-}
-
-void ErrorData::AddErrorLocation(const string &query) {
-	if (!query.empty()) {
-		auto entry = extra_info.find("position");
-		if (entry != extra_info.end()) {
-			raw_message = QueryErrorContext::Format(query, raw_message, std::stoull(entry->second));
-		}
-	}
-	{
-		auto entry = extra_info.find("stack_trace");
-		if (entry != extra_info.end()) {
-			raw_message += "\n\nStack Trace:\n" + entry->second;
-		}
-	}
-	final_message = ConstructFinalMessage();
-}
-
-void ErrorData::AddQueryLocation(optional_idx query_location) {
-	Exception::SetQueryLocation(query_location, extra_info);
-}
-
-void ErrorData::AddQueryLocation(QueryErrorContext error_context) {
-	AddQueryLocation(error_context.query_location);
-}
-
-void ErrorData::AddQueryLocation(const ParsedExpression &ref) {
-	AddQueryLocation(ref.GetQueryLocation());
-}
-
-void ErrorData::AddQueryLocation(const TableRef &ref) {
-	AddQueryLocation(ref.query_location);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/exception.cpp b/src/duckdb/src/common/exception.cpp
deleted file mode 100644
index 991f929f2..000000000
--- a/src/duckdb/src/common/exception.cpp
+++ /dev/null
@@ -1,354 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/exception/list.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/planner/expression.hpp"
-
-#ifdef DUCKDB_CRASH_ON_ASSERT
-#include "duckdb/common/printer.hpp"
-#include <stdio.h>
-#include <stdlib.h>
-#endif
-#include "duckdb/common/stacktrace.hpp"
-
-namespace duckdb {
-
-Exception::Exception(ExceptionType exception_type, const string &message)
-    : std::runtime_error(ToJSON(exception_type, message)) {
-}
-
-Exception::Exception(ExceptionType exception_type, const string &message,
-                     const unordered_map<string, string> &extra_info)
-    : std::runtime_error(ToJSON(exception_type, message, extra_info)) {
-}
-
-string Exception::ToJSON(ExceptionType type, const string &message) {
-	unordered_map<string, string> extra_info;
-	return ToJSON(type, message, extra_info);
-}
-
-string Exception::ToJSON(ExceptionType type, const string &message, const unordered_map<string, string> &extra_info) {
-#ifndef DUCKDB_DEBUG_STACKTRACE
-	// by default we only enable stack traces for internal exceptions
-	if (type == ExceptionType::INTERNAL)
-#endif
-	{
-		auto extended_extra_info = extra_info;
-		extended_extra_info["stack_trace_pointers"] = StackTrace::GetStacktracePointers();
-		return StringUtil::ExceptionToJSONMap(type, message, extended_extra_info);
-	}
-	return StringUtil::ExceptionToJSONMap(type, message, extra_info);
-}
-
-bool Exception::UncaughtException() {
-#if __cplusplus >= 201703L
-	return std::uncaught_exceptions() > 0;
-#else
-	return std::uncaught_exception();
-#endif
-}
-
-bool Exception::InvalidatesTransaction(ExceptionType exception_type) {
-	switch (exception_type) {
-	case ExceptionType::BINDER:
-	case ExceptionType::CATALOG:
-	case ExceptionType::CONNECTION:
-	case ExceptionType::PARAMETER_NOT_ALLOWED:
-	case ExceptionType::PARSER:
-	case ExceptionType::PERMISSION:
-		return false;
-	default:
-		return true;
-	}
-}
-
-bool Exception::InvalidatesDatabase(ExceptionType exception_type) {
-	switch (exception_type) {
-	case ExceptionType::FATAL:
-		return true;
-	default:
-		return false;
-	}
-}
-
-string Exception::GetStackTrace(idx_t max_depth) {
-	return StackTrace::GetStackTrace(max_depth);
-}
-
-string Exception::ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values) {
-#ifdef DEBUG
-	// Verify that we have the required amount of values for the message
-	idx_t parameter_count = 0;
-	for (idx_t i = 0; i + 1 < msg.size(); i++) {
-		if (msg[i] != '%') {
-			continue;
-		}
-		if (msg[i + 1] == '%') {
-			i++;
-			continue;
-		}
-		parameter_count++;
-	}
-	if (parameter_count != values.size()) {
-		throw InternalException("Primary exception: %s\nSecondary exception in ConstructMessageRecursive: Expected %d "
-		                        "parameters, received %d",
-		                        msg.c_str(), parameter_count, values.size());
-	}
-
-#endif
-	return ExceptionFormatValue::Format(msg, values);
-}
-
-struct ExceptionEntry {
-	ExceptionType type;
-	char text[48];
-};
-
-static constexpr ExceptionEntry EXCEPTION_MAP[] = {{ExceptionType::INVALID, "Invalid"},
-                                                   {ExceptionType::OUT_OF_RANGE, "Out of Range"},
-                                                   {ExceptionType::CONVERSION, "Conversion"},
-                                                   {ExceptionType::UNKNOWN_TYPE, "Unknown Type"},
-                                                   {ExceptionType::DECIMAL, "Decimal"},
-                                                   {ExceptionType::MISMATCH_TYPE, "Mismatch Type"},
-                                                   {ExceptionType::DIVIDE_BY_ZERO, "Divide by Zero"},
-                                                   {ExceptionType::OBJECT_SIZE, "Object Size"},
-                                                   {ExceptionType::INVALID_TYPE, "Invalid type"},
-                                                   {ExceptionType::SERIALIZATION, "Serialization"},
-                                                   {ExceptionType::TRANSACTION, "TransactionContext"},
-                                                   {ExceptionType::NOT_IMPLEMENTED, "Not implemented"},
-                                                   {ExceptionType::EXPRESSION, "Expression"},
-                                                   {ExceptionType::CATALOG, "Catalog"},
-                                                   {ExceptionType::PARSER, "Parser"},
-                                                   {ExceptionType::BINDER, "Binder"},
-                                                   {ExceptionType::PLANNER, "Planner"},
-                                                   {ExceptionType::SCHEDULER, "Scheduler"},
-                                                   {ExceptionType::EXECUTOR, "Executor"},
-                                                   {ExceptionType::CONSTRAINT, "Constraint"},
-                                                   {ExceptionType::INDEX, "Index"},
-                                                   {ExceptionType::STAT, "Stat"},
-                                                   {ExceptionType::CONNECTION, "Connection"},
-                                                   {ExceptionType::SYNTAX, "Syntax"},
-                                                   {ExceptionType::SETTINGS, "Settings"},
-                                                   {ExceptionType::OPTIMIZER, "Optimizer"},
-                                                   {ExceptionType::NULL_POINTER, "NullPointer"},
-                                                   {ExceptionType::IO, "IO"},
-                                                   {ExceptionType::INTERRUPT, "INTERRUPT"},
-                                                   {ExceptionType::FATAL, "FATAL"},
-                                                   {ExceptionType::INTERNAL, "INTERNAL"},
-                                                   {ExceptionType::INVALID_INPUT, "Invalid Input"},
-                                                   {ExceptionType::OUT_OF_MEMORY, "Out of Memory"},
-                                                   {ExceptionType::PERMISSION, "Permission"},
-                                                   {ExceptionType::PARAMETER_NOT_RESOLVED, "Parameter Not Resolved"},
-                                                   {ExceptionType::PARAMETER_NOT_ALLOWED, "Parameter Not Allowed"},
-                                                   {ExceptionType::DEPENDENCY, "Dependency"},
-                                                   {ExceptionType::MISSING_EXTENSION, "Missing Extension"},
-                                                   {ExceptionType::HTTP, "HTTP"},
-                                                   {ExceptionType::AUTOLOAD, "Extension Autoloading"},
-                                                   {ExceptionType::SEQUENCE, "Sequence"},
-                                                   {ExceptionType::INVALID_CONFIGURATION, "Invalid Configuration"}};
-
-string Exception::ExceptionTypeToString(ExceptionType type) {
-	for (auto &e : EXCEPTION_MAP) {
-		if (e.type == type) {
-			return e.text;
-		}
-	}
-	return "Unknown";
-}
-
-ExceptionType Exception::StringToExceptionType(const string &type) {
-	for (auto &e : EXCEPTION_MAP) {
-		if (e.text == type) {
-			return e.type;
-		}
-	}
-	return ExceptionType::INVALID;
-}
-
-unordered_map<string, string> Exception::InitializeExtraInfo(const Expression &expr) {
-	return InitializeExtraInfo(expr.GetQueryLocation());
-}
-
-unordered_map<string, string> Exception::InitializeExtraInfo(const ParsedExpression &expr) {
-	return InitializeExtraInfo(expr.GetQueryLocation());
-}
-
-unordered_map<string, string> Exception::InitializeExtraInfo(const QueryErrorContext &error_context) {
-	return InitializeExtraInfo(error_context.query_location);
-}
-
-unordered_map<string, string> Exception::InitializeExtraInfo(const TableRef &ref) {
-	return InitializeExtraInfo(ref.query_location);
-}
-
-unordered_map<string, string> Exception::InitializeExtraInfo(optional_idx error_location) {
-	unordered_map<string, string> result;
-	SetQueryLocation(error_location, result);
-	return result;
-}
-
-unordered_map<string, string> Exception::InitializeExtraInfo(const string &subtype, optional_idx error_location) {
-	unordered_map<string, string> result;
-	result["error_subtype"] = subtype;
-	SetQueryLocation(error_location, result);
-	return result;
-}
-
-void Exception::SetQueryLocation(optional_idx error_location, unordered_map<string, string> &extra_info) {
-	if (error_location.IsValid()) {
-		extra_info["position"] = to_string(error_location.GetIndex());
-	}
-}
-
-InvalidTypeException::InvalidTypeException(PhysicalType type, const string &msg)
-    : Exception(ExceptionType::INVALID_TYPE, "Invalid Type [" + TypeIdToString(type) + "]: " + msg) {
-}
-
-InvalidTypeException::InvalidTypeException(const LogicalType &type, const string &msg)
-    : Exception(ExceptionType::INVALID_TYPE, "Invalid Type [" + type.ToString() + "]: " + msg) {
-}
-
-InvalidTypeException::InvalidTypeException(const string &msg) : Exception(ExceptionType::INVALID_TYPE, msg) {
-}
-
-TypeMismatchException::TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg)
-    : Exception(ExceptionType::MISMATCH_TYPE,
-                "Type " + TypeIdToString(type_1) + " does not match with " + TypeIdToString(type_2) + ". " + msg) {
-}
-
-TypeMismatchException::TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg)
-    : TypeMismatchException(optional_idx(), type_1, type_2, msg) {
-}
-
-TypeMismatchException::TypeMismatchException(optional_idx error_location, const LogicalType &type_1,
-                                             const LogicalType &type_2, const string &msg)
-    : Exception(ExceptionType::MISMATCH_TYPE,
-                "Type " + type_1.ToString() + " does not match with " + type_2.ToString() + ". " + msg,
-                Exception::InitializeExtraInfo(error_location)) {
-}
-
-TypeMismatchException::TypeMismatchException(const string &msg) : Exception(ExceptionType::MISMATCH_TYPE, msg) {
-}
-
-TransactionException::TransactionException(const string &msg) : Exception(ExceptionType::TRANSACTION, msg) {
-}
-
-NotImplementedException::NotImplementedException(const string &msg) : Exception(ExceptionType::NOT_IMPLEMENTED, msg) {
-}
-
-OutOfRangeException::OutOfRangeException(const string &msg) : Exception(ExceptionType::OUT_OF_RANGE, msg) {
-}
-
-OutOfRangeException::OutOfRangeException(const int64_t value, const PhysicalType orig_type, const PhysicalType new_type)
-    : Exception(ExceptionType::OUT_OF_RANGE, "Type " + TypeIdToString(orig_type) + " with value " +
-                                                 to_string((intmax_t)value) +
-                                                 " can't be cast because the value is out of range "
-                                                 "for the destination type " +
-                                                 TypeIdToString(new_type)) {
-}
-
-OutOfRangeException::OutOfRangeException(const double value, const PhysicalType orig_type, const PhysicalType new_type)
-    : Exception(ExceptionType::OUT_OF_RANGE, "Type " + TypeIdToString(orig_type) + " with value " + to_string(value) +
-                                                 " can't be cast because the value is out of range "
-                                                 "for the destination type " +
-                                                 TypeIdToString(new_type)) {
-}
-
-OutOfRangeException::OutOfRangeException(const hugeint_t value, const PhysicalType orig_type,
-                                         const PhysicalType new_type)
-    : Exception(ExceptionType::OUT_OF_RANGE, "Type " + TypeIdToString(orig_type) + " with value " + value.ToString() +
-                                                 " can't be cast because the value is out of range "
-                                                 "for the destination type " +
-                                                 TypeIdToString(new_type)) {
-}
-
-OutOfRangeException::OutOfRangeException(const PhysicalType var_type, const idx_t length)
-    : Exception(ExceptionType::OUT_OF_RANGE,
-                "The value is too long to fit into type " + TypeIdToString(var_type) + "(" + to_string(length) + ")") {
-}
-
-ConnectionException::ConnectionException(const string &msg) : Exception(ExceptionType::CONNECTION, msg) {
-}
-
-PermissionException::PermissionException(const string &msg) : Exception(ExceptionType::PERMISSION, msg) {
-}
-
-SyntaxException::SyntaxException(const string &msg) : Exception(ExceptionType::SYNTAX, msg) {
-}
-
-ExecutorException::ExecutorException(const string &msg) : Exception(ExceptionType::EXECUTOR, msg) {
-}
-
-ConstraintException::ConstraintException(const string &msg) : Exception(ExceptionType::CONSTRAINT, msg) {
-}
-
-DependencyException::DependencyException(const string &msg) : Exception(ExceptionType::DEPENDENCY, msg) {
-}
-
-IOException::IOException(const string &msg) : Exception(ExceptionType::IO, msg) {
-}
-
-IOException::IOException(const string &msg, const unordered_map<string, string> &extra_info)
-    : Exception(ExceptionType::IO, msg, extra_info) {
-}
-
-MissingExtensionException::MissingExtensionException(const string &msg)
-    : Exception(ExceptionType::MISSING_EXTENSION, msg) {
-}
-
-AutoloadException::AutoloadException(const string &extension_name, const string &message)
-    : Exception(ExceptionType::AUTOLOAD,
-                "An error occurred while trying to automatically install the required extension '" + extension_name +
-                    "':\n" + message) {
-}
-
-SerializationException::SerializationException(const string &msg) : Exception(ExceptionType::SERIALIZATION, msg) {
-}
-
-SequenceException::SequenceException(const string &msg) : Exception(ExceptionType::SEQUENCE, msg) {
-}
-
-InterruptException::InterruptException() : Exception(ExceptionType::INTERRUPT, "Interrupted!") {
-}
-
-FatalException::FatalException(ExceptionType type, const string &msg) : Exception(type, msg) {
-}
-
-InternalException::InternalException(const string &msg) : Exception(ExceptionType::INTERNAL, msg) {
-#ifdef DUCKDB_CRASH_ON_ASSERT
-	Printer::Print("ABORT THROWN BY INTERNAL EXCEPTION: " + msg);
-	Printer::Print(StackTrace::GetStackTrace());
-	abort();
-#endif
-}
-
-InvalidInputException::InvalidInputException(const string &msg) : Exception(ExceptionType::INVALID_INPUT, msg) {
-}
-
-InvalidInputException::InvalidInputException(const string &msg, const unordered_map<string, string> &extra_info)
-    : Exception(ExceptionType::INVALID_INPUT, msg, extra_info) {
-}
-
-InvalidConfigurationException::InvalidConfigurationException(const string &msg)
-    : Exception(ExceptionType::INVALID_CONFIGURATION, msg) {
-}
-
-InvalidConfigurationException::InvalidConfigurationException(const string &msg,
-                                                             const unordered_map<string, string> &extra_info)
-    : Exception(ExceptionType::INVALID_CONFIGURATION, msg, extra_info) {
-}
-
-OutOfMemoryException::OutOfMemoryException(const string &msg) : Exception(ExceptionType::OUT_OF_MEMORY, msg) {
-}
-
-ParameterNotAllowedException::ParameterNotAllowedException(const string &msg)
-    : Exception(ExceptionType::PARAMETER_NOT_ALLOWED, msg) {
-}
-
-ParameterNotResolvedException::ParameterNotResolvedException()
-    : Exception(ExceptionType::PARAMETER_NOT_RESOLVED, "Parameter types could not be resolved") {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/exception/binder_exception.cpp b/src/duckdb/src/common/exception/binder_exception.cpp
deleted file mode 100644
index cc4e08722..000000000
--- a/src/duckdb/src/common/exception/binder_exception.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/function.hpp"
-
-namespace duckdb {
-
-BinderException::BinderException(const string &msg) : Exception(ExceptionType::BINDER, msg) {
-}
-
-BinderException::BinderException(const string &msg, const unordered_map<string, string> &extra_info)
-    : Exception(ExceptionType::BINDER, msg, extra_info) {
-}
-
-BinderException BinderException::ColumnNotFound(const string &name, const vector<string> &similar_bindings,
-                                                QueryErrorContext context) {
-	auto extra_info = Exception::InitializeExtraInfo("COLUMN_NOT_FOUND", context.query_location);
-	string candidate_str = StringUtil::CandidatesMessage(similar_bindings, "Candidate bindings");
-	extra_info["name"] = name;
-	if (!similar_bindings.empty()) {
-		extra_info["candidates"] = StringUtil::Join(similar_bindings, ",");
-	}
-	return BinderException(
-	    StringUtil::Format("Referenced column \"%s\" not found in FROM clause!%s", name, candidate_str), extra_info);
-}
-
-BinderException BinderException::NoMatchingFunction(const string &name, const vector<LogicalType> &arguments,
-                                                    const vector<string> &candidates) {
-	auto extra_info = Exception::InitializeExtraInfo("NO_MATCHING_FUNCTION", optional_idx());
-	// no matching function was found, throw an error
-	string call_str = Function::CallToString(name, arguments);
-	string candidate_str;
-	for (auto &candidate : candidates) {
-		candidate_str += "\t" + candidate + "\n";
-	}
-	extra_info["name"] = name;
-	extra_info["call"] = call_str;
-	if (!candidates.empty()) {
-		extra_info["candidates"] = StringUtil::Join(candidates, ",");
-	}
-	return BinderException(
-	    StringUtil::Format("No function matches the given name and argument types '%s'. You might need to add "
-	                       "explicit type casts.\n\tCandidate functions:\n%s",
-	                       call_str, candidate_str),
-	    extra_info);
-}
-
-BinderException BinderException::Unsupported(ParsedExpression &expr, const string &message) {
-	auto extra_info = Exception::InitializeExtraInfo("UNSUPPORTED", expr.GetQueryLocation());
-	return BinderException(message, extra_info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/exception/catalog_exception.cpp b/src/duckdb/src/common/exception/catalog_exception.cpp
deleted file mode 100644
index 2ab210f0e..000000000
--- a/src/duckdb/src/common/exception/catalog_exception.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "duckdb/common/exception/catalog_exception.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-CatalogException::CatalogException(const string &msg) : Exception(ExceptionType::CATALOG, msg) {
-}
-
-CatalogException::CatalogException(const string &msg, const unordered_map<string, string> &extra_info)
-    : Exception(ExceptionType::CATALOG, msg, extra_info) {
-}
-
-CatalogException CatalogException::MissingEntry(CatalogType type, const string &name, const string &suggestion,
-                                                QueryErrorContext context) {
-	string did_you_mean;
-	if (!suggestion.empty()) {
-		did_you_mean = "\nDid you mean \"" + suggestion + "\"?";
-	}
-
-	auto extra_info = Exception::InitializeExtraInfo("MISSING_ENTRY", context.query_location);
-
-	extra_info["name"] = name;
-	extra_info["type"] = CatalogTypeToString(type);
-	if (!suggestion.empty()) {
-		extra_info["candidates"] = suggestion;
-	}
-	return CatalogException(
-	    StringUtil::Format("%s with name %s does not exist!%s", CatalogTypeToString(type), name, did_you_mean),
-	    extra_info);
-}
-
-CatalogException CatalogException::MissingEntry(const string &type, const string &name,
-                                                const vector<string> &suggestions, QueryErrorContext context) {
-	auto extra_info = Exception::InitializeExtraInfo("MISSING_ENTRY", context.query_location);
-	extra_info["error_subtype"] = "MISSING_ENTRY";
-	extra_info["name"] = name;
-	extra_info["type"] = type;
-	if (!suggestions.empty()) {
-		extra_info["candidates"] = StringUtil::Join(suggestions, ", ");
-	}
-	return CatalogException(StringUtil::Format("unrecognized %s \"%s\"\n%s", type, name,
-	                                           StringUtil::CandidatesErrorMessage(suggestions, name, "Did you mean")),
-	                        extra_info);
-}
-
-CatalogException CatalogException::EntryAlreadyExists(CatalogType type, const string &name, QueryErrorContext context) {
-	auto extra_info = Exception::InitializeExtraInfo("ENTRY_ALREADY_EXISTS", optional_idx());
-	extra_info["name"] = name;
-	extra_info["type"] = CatalogTypeToString(type);
-	return CatalogException(StringUtil::Format("%s with name \"%s\" already exists!", CatalogTypeToString(type), name),
-	                        extra_info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/exception/conversion_exception.cpp b/src/duckdb/src/common/exception/conversion_exception.cpp
deleted file mode 100644
index 013dbdb9e..000000000
--- a/src/duckdb/src/common/exception/conversion_exception.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-ConversionException::ConversionException(const PhysicalType orig_type, const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION,
-                "Type " + TypeIdToString(orig_type) + " can't be cast as " + TypeIdToString(new_type)) {
-}
-
-ConversionException::ConversionException(const LogicalType &orig_type, const LogicalType &new_type)
-    : Exception(ExceptionType::CONVERSION,
-                "Type " + orig_type.ToString() + " can't be cast as " + new_type.ToString()) {
-}
-
-ConversionException::ConversionException(const string &msg) : Exception(ExceptionType::CONVERSION, msg) {
-}
-
-ConversionException::ConversionException(optional_idx error_location, const string &msg)
-    : Exception(ExceptionType::CONVERSION, msg, Exception::InitializeExtraInfo(error_location)) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/exception/parser_exception.cpp b/src/duckdb/src/common/exception/parser_exception.cpp
deleted file mode 100644
index f3875da38..000000000
--- a/src/duckdb/src/common/exception/parser_exception.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/common/exception/parser_exception.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-
-namespace duckdb {
-
-ParserException::ParserException(const string &msg) : Exception(ExceptionType::PARSER, msg) {
-}
-
-ParserException::ParserException(const string &msg, const unordered_map<string, string> &extra_info)
-    : Exception(ExceptionType::PARSER, msg, extra_info) {
-}
-
-ParserException ParserException::SyntaxError(const string &query, const string &error_message,
-                                             optional_idx error_location) {
-	return ParserException(error_message, Exception::InitializeExtraInfo("SYNTAX_ERROR", error_location));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/exception_format_value.cpp b/src/duckdb/src/common/exception_format_value.cpp
deleted file mode 100644
index ddef4e10c..000000000
--- a/src/duckdb/src/common/exception_format_value.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/helper.hpp" // defines DUCKDB_EXPLICIT_FALLTHROUGH which fmt will use to annotate
-#include "fmt/format.h"
-#include "fmt/printf.h"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-ExceptionFormatValue::ExceptionFormatValue(double dbl_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE), dbl_val(dbl_val) {
-}
-ExceptionFormatValue::ExceptionFormatValue(int64_t int_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), int_val(int_val) {
-}
-ExceptionFormatValue::ExceptionFormatValue(hugeint_t huge_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Hugeint::ToString(huge_val)) {
-}
-ExceptionFormatValue::ExceptionFormatValue(uhugeint_t uhuge_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Uhugeint::ToString(uhuge_val)) {
-}
-ExceptionFormatValue::ExceptionFormatValue(string str_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(std::move(str_val)) {
-}
-
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value) {
-	return ExceptionFormatValue(TypeIdToString(value));
-}
-template <>
-ExceptionFormatValue
-ExceptionFormatValue::CreateFormatValue(LogicalType value) { // NOLINT: templating requires us to copy value here
-	return ExceptionFormatValue(value.ToString());
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value) {
-	return ExceptionFormatValue(double(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value) {
-	return ExceptionFormatValue(double(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value) {
-	return ExceptionFormatValue(std::move(value));
-}
-
-template <>
-ExceptionFormatValue
-ExceptionFormatValue::CreateFormatValue(SQLString value) { // NOLINT: templating requires us to copy value here
-	return KeywordHelper::WriteQuoted(value.raw_string, '\'');
-}
-
-template <>
-ExceptionFormatValue
-ExceptionFormatValue::CreateFormatValue(SQLIdentifier value) { // NOLINT: templating requires us to copy value here
-	return KeywordHelper::WriteOptionallyQuoted(value.raw_string, '"');
-}
-
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value) {
-	return ExceptionFormatValue(string(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value) {
-	return ExceptionFormatValue(string(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
-	return ExceptionFormatValue(value);
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(uhugeint_t value) {
-	return ExceptionFormatValue(value);
-}
-
-string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionFormatValue> &values) {
-	try {
-		std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
-		for (auto &val : values) {
-			switch (val.type) {
-			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:
-				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.dbl_val));
-				break;
-			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER:
-				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.int_val));
-				break;
-			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING:
-				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.str_val));
-				break;
-			}
-		}
-		return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
-		                                     format_args.data(), static_cast<int>(format_args.size())));
-	} catch (std::exception &ex) { // LCOV_EXCL_START
-		// work-around for oss-fuzz limiting memory which causes issues here
-		if (StringUtil::Contains(ex.what(), "fuzz mode")) {
-			throw InvalidInputException(msg);
-		}
-		throw InternalException(std::string("Primary exception: ") + msg +
-		                        "\nSecondary exception in ExceptionFormatValue: " + ex.what());
-	} // LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/extra_type_info.cpp b/src/duckdb/src/common/extra_type_info.cpp
deleted file mode 100644
index 117f9b0f7..000000000
--- a/src/duckdb/src/common/extra_type_info.cpp
+++ /dev/null
@@ -1,467 +0,0 @@
-#include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/common/extra_type_info/enum_type_info.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/string_map_set.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Extension Type Info
-//===--------------------------------------------------------------------===//
-
-bool ExtensionTypeInfo::Equals(optional_ptr<ExtensionTypeInfo> lhs, optional_ptr<ExtensionTypeInfo> rhs) {
-	// Either both are null, or both are the same, so they are equal
-	if (lhs.get() == rhs.get()) {
-		return true;
-	}
-	// If one is null, then we cant compare them
-	if (lhs == nullptr || rhs == nullptr) {
-		return true;
-	}
-
-	// Both are not null, so we can compare them
-	D_ASSERT(lhs != nullptr && rhs != nullptr);
-
-	// Compare modifiers
-	const auto &lhs_mods = lhs->modifiers;
-	const auto &rhs_mods = rhs->modifiers;
-	const auto common_mods = MinValue(lhs_mods.size(), rhs_mods.size());
-	for (idx_t i = 0; i < common_mods; i++) {
-		// If the types are not strictly equal, they are not equal
-		auto &lhs_val = lhs_mods[i].value;
-		auto &rhs_val = rhs_mods[i].value;
-
-		if (lhs_val.type() != rhs_val.type()) {
-			return false;
-		}
-
-		// If both are null, its fine
-		if (lhs_val.IsNull() && rhs_val.IsNull()) {
-			continue;
-		}
-
-		// If one is null, the other must be null too
-		if (lhs_val.IsNull() != rhs_val.IsNull()) {
-			return false;
-		}
-
-		if (lhs_val != rhs_val) {
-			return false;
-		}
-	}
-
-	// Properties are optional, so only compare those present in both
-	const auto &lhs_props = lhs->properties;
-	const auto &rhs_props = rhs->properties;
-
-	for (const auto &kv : lhs_props) {
-		auto it = rhs_props.find(kv.first);
-		if (it == rhs_props.end()) {
-			// Continue
-			continue;
-		}
-		if (kv.second != it->second) {
-			// Mismatch!
-			return false;
-		}
-	}
-
-	// All ok!
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Extra Type Info
-//===--------------------------------------------------------------------===//
-ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type) : type(type) {
-}
-ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type), alias(std::move(alias)) {
-}
-ExtraTypeInfo::~ExtraTypeInfo() {
-}
-
-ExtraTypeInfo::ExtraTypeInfo(const ExtraTypeInfo &other) : type(other.type), alias(other.alias) {
-	if (other.extension_info) {
-		extension_info = make_uniq<ExtensionTypeInfo>(*other.extension_info);
-	}
-}
-
-ExtraTypeInfo &ExtraTypeInfo::operator=(const ExtraTypeInfo &other) {
-	type = other.type;
-	alias = other.alias;
-	if (other.extension_info) {
-		extension_info = make_uniq<ExtensionTypeInfo>(*other.extension_info);
-	}
-	return *this;
-}
-
-shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Copy() const {
-	return shared_ptr<ExtraTypeInfo>(new ExtraTypeInfo(*this));
-}
-
-bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const {
-	if (type == ExtraTypeInfoType::INVALID_TYPE_INFO || type == ExtraTypeInfoType::STRING_TYPE_INFO ||
-	    type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
-		if (!other_p) {
-			if (!alias.empty()) {
-				return false;
-			}
-			if (extension_info) {
-				return false;
-			}
-			//! We only need to compare aliases when both types have them in this case
-			return true;
-		}
-		if (alias != other_p->alias) {
-			return false;
-		}
-		if (!ExtensionTypeInfo::Equals(extension_info, other_p->extension_info)) {
-			return false;
-		}
-		return true;
-	}
-	if (!other_p) {
-		return false;
-	}
-	if (type != other_p->type) {
-		return false;
-	}
-	if (alias != other_p->alias) {
-		return false;
-	}
-	if (!ExtensionTypeInfo::Equals(extension_info, other_p->extension_info)) {
-		return false;
-	}
-	return EqualsInternal(other_p);
-}
-
-bool ExtraTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	// Do nothing
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal Type Info
-//===--------------------------------------------------------------------===//
-DecimalTypeInfo::DecimalTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::DECIMAL_TYPE_INFO) {
-}
-
-DecimalTypeInfo::DecimalTypeInfo(uint8_t width_p, uint8_t scale_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::DECIMAL_TYPE_INFO), width(width_p), scale(scale_p) {
-	D_ASSERT(width_p >= scale_p);
-}
-
-bool DecimalTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<DecimalTypeInfo>();
-	return width == other.width && scale == other.scale;
-}
-
-shared_ptr<ExtraTypeInfo> DecimalTypeInfo::Copy() const {
-	return make_shared_ptr<DecimalTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// String Type Info
-//===--------------------------------------------------------------------===//
-StringTypeInfo::StringTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::STRING_TYPE_INFO) {
-}
-
-StringTypeInfo::StringTypeInfo(string collation_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::STRING_TYPE_INFO), collation(std::move(collation_p)) {
-}
-
-bool StringTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	// collation info has no impact on equality
-	return true;
-}
-
-shared_ptr<ExtraTypeInfo> StringTypeInfo::Copy() const {
-	return make_shared_ptr<StringTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// List Type Info
-//===--------------------------------------------------------------------===//
-ListTypeInfo::ListTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::LIST_TYPE_INFO) {
-}
-
-ListTypeInfo::ListTypeInfo(LogicalType child_type_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::LIST_TYPE_INFO), child_type(std::move(child_type_p)) {
-}
-
-bool ListTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<ListTypeInfo>();
-	return child_type == other.child_type;
-}
-
-shared_ptr<ExtraTypeInfo> ListTypeInfo::Copy() const {
-	return make_shared_ptr<ListTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// Struct Type Info
-//===--------------------------------------------------------------------===//
-StructTypeInfo::StructTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::STRUCT_TYPE_INFO) {
-}
-
-StructTypeInfo::StructTypeInfo(child_list_t<LogicalType> child_types_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::STRUCT_TYPE_INFO), child_types(std::move(child_types_p)) {
-}
-
-bool StructTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<StructTypeInfo>();
-	return child_types == other.child_types;
-}
-
-shared_ptr<ExtraTypeInfo> StructTypeInfo::Copy() const {
-	return make_shared_ptr<StructTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// Aggregate State Type Info
-//===--------------------------------------------------------------------===//
-AggregateStateTypeInfo::AggregateStateTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO) {
-}
-
-AggregateStateTypeInfo::AggregateStateTypeInfo(aggregate_state_t state_type_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), state_type(std::move(state_type_p)) {
-}
-
-bool AggregateStateTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<AggregateStateTypeInfo>();
-	return state_type.function_name == other.state_type.function_name &&
-	       state_type.return_type == other.state_type.return_type &&
-	       state_type.bound_argument_types == other.state_type.bound_argument_types;
-}
-
-shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::Copy() const {
-	return make_shared_ptr<AggregateStateTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// User Type Info
-//===--------------------------------------------------------------------===//
-UserTypeInfo::UserTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO) {
-}
-
-UserTypeInfo::UserTypeInfo(string name_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)) {
-}
-
-UserTypeInfo::UserTypeInfo(string name_p, vector<Value> modifiers_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)),
-      user_type_modifiers(std::move(modifiers_p)) {
-}
-
-UserTypeInfo::UserTypeInfo(string catalog_p, string schema_p, string name_p, vector<Value> modifiers_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
-      user_type_name(std::move(name_p)), user_type_modifiers(std::move(modifiers_p)) {
-}
-
-bool UserTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<UserTypeInfo>();
-	return other.user_type_name == user_type_name;
-}
-
-shared_ptr<ExtraTypeInfo> UserTypeInfo::Copy() const {
-	return make_shared_ptr<UserTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// Enum Type Info
-//===--------------------------------------------------------------------===//
-PhysicalType EnumTypeInfo::DictType(idx_t size) {
-	if (size <= NumericLimits<uint8_t>::Maximum()) {
-		return PhysicalType::UINT8;
-	} else if (size <= NumericLimits<uint16_t>::Maximum()) {
-		return PhysicalType::UINT16;
-	} else if (size <= NumericLimits<uint32_t>::Maximum()) {
-		return PhysicalType::UINT32;
-	} else {
-		throw InternalException("Enum size must be lower than " + std::to_string(NumericLimits<uint32_t>::Maximum()));
-	}
-}
-
-EnumTypeInfo::EnumTypeInfo(Vector &values_insert_order_p, idx_t dict_size_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), values_insert_order(values_insert_order_p),
-      dict_type(EnumDictType::VECTOR_DICT), dict_size(dict_size_p) {
-}
-
-const EnumDictType &EnumTypeInfo::GetEnumDictType() const {
-	return dict_type;
-}
-
-const Vector &EnumTypeInfo::GetValuesInsertOrder() const {
-	return values_insert_order;
-}
-
-const idx_t &EnumTypeInfo::GetDictSize() const {
-	return dict_size;
-}
-
-LogicalType EnumTypeInfo::CreateType(Vector &ordered_data, idx_t size) {
-	// Generate EnumTypeInfo
-	shared_ptr<ExtraTypeInfo> info;
-	auto enum_internal_type = EnumTypeInfo::DictType(size);
-	switch (enum_internal_type) {
-	case PhysicalType::UINT8:
-		info = make_shared_ptr<EnumTypeInfoTemplated<uint8_t>>(ordered_data, size);
-		break;
-	case PhysicalType::UINT16:
-		info = make_shared_ptr<EnumTypeInfoTemplated<uint16_t>>(ordered_data, size);
-		break;
-	case PhysicalType::UINT32:
-		info = make_shared_ptr<EnumTypeInfoTemplated<uint32_t>>(ordered_data, size);
-		break;
-	default:
-		throw InternalException("Invalid Physical Type for ENUMs");
-	}
-	// Generate Actual Enum Type
-	return LogicalType(LogicalTypeId::ENUM, info);
-}
-
-template <class T>
-int64_t TemplatedGetPos(const string_map_t<T> &map, const string_t &key) {
-	auto it = map.find(key);
-	if (it == map.end()) {
-		return -1;
-	}
-	return it->second;
-}
-
-int64_t EnumType::GetPos(const LogicalType &type, const string_t &key) {
-	auto info = type.AuxInfo();
-	switch (type.InternalType()) {
-	case PhysicalType::UINT8:
-		return TemplatedGetPos(info->Cast<EnumTypeInfoTemplated<uint8_t>>().GetValues(), key);
-	case PhysicalType::UINT16:
-		return TemplatedGetPos(info->Cast<EnumTypeInfoTemplated<uint16_t>>().GetValues(), key);
-	case PhysicalType::UINT32:
-		return TemplatedGetPos(info->Cast<EnumTypeInfoTemplated<uint32_t>>().GetValues(), key);
-	default:
-		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-	}
-}
-
-string_t EnumType::GetString(const LogicalType &type, idx_t pos) {
-	D_ASSERT(pos < EnumType::GetSize(type));
-	return FlatVector::GetData<string_t>(EnumType::GetValuesInsertOrder(type))[pos];
-}
-
-shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto values_count = deserializer.ReadProperty<idx_t>(200, "values_count");
-	auto enum_internal_type = EnumTypeInfo::DictType(values_count);
-	switch (enum_internal_type) {
-	case PhysicalType::UINT8:
-		return EnumTypeInfoTemplated<uint8_t>::Deserialize(deserializer, NumericCast<uint32_t>(values_count));
-	case PhysicalType::UINT16:
-		return EnumTypeInfoTemplated<uint16_t>::Deserialize(deserializer, NumericCast<uint32_t>(values_count));
-	case PhysicalType::UINT32:
-		return EnumTypeInfoTemplated<uint32_t>::Deserialize(deserializer, NumericCast<uint32_t>(values_count));
-	default:
-		throw InternalException("Invalid Physical Type for ENUMs");
-	}
-}
-
-// Equalities are only used in enums with different catalog entries
-bool EnumTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<EnumTypeInfo>();
-	if (dict_type != other.dict_type) {
-		return false;
-	}
-	D_ASSERT(dict_type == EnumDictType::VECTOR_DICT);
-	// We must check if both enums have the same size
-	if (other.dict_size != dict_size) {
-		return false;
-	}
-	auto other_vector_ptr = FlatVector::GetData<string_t>(other.values_insert_order);
-	auto this_vector_ptr = FlatVector::GetData<string_t>(values_insert_order);
-
-	// Now we must check if all strings are the same
-	for (idx_t i = 0; i < dict_size; i++) {
-		if (!Equals::Operation(other_vector_ptr[i], this_vector_ptr[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void EnumTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-
-	// Enums are special in that we serialize their values as a list instead of dumping the whole vector
-	auto strings = FlatVector::GetData<string_t>(values_insert_order);
-	serializer.WriteProperty(200, "values_count", dict_size);
-	serializer.WriteList(201, "values", dict_size,
-	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(strings[i]); });
-}
-
-shared_ptr<ExtraTypeInfo> EnumTypeInfo::Copy() const {
-	Vector values_insert_order_copy(LogicalType::VARCHAR, false, false, 0);
-	values_insert_order_copy.Reference(values_insert_order);
-	return make_shared_ptr<EnumTypeInfo>(values_insert_order_copy, dict_size);
-}
-
-//===--------------------------------------------------------------------===//
-// ArrayTypeInfo
-//===--------------------------------------------------------------------===//
-
-ArrayTypeInfo::ArrayTypeInfo(LogicalType child_type_p, uint32_t size_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::ARRAY_TYPE_INFO), child_type(std::move(child_type_p)), size(size_p) {
-}
-
-bool ArrayTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<ArrayTypeInfo>();
-	return child_type == other.child_type && size == other.size;
-}
-
-shared_ptr<ExtraTypeInfo> ArrayTypeInfo::Copy() const {
-	return make_shared_ptr<ArrayTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// Any Type Info
-//===--------------------------------------------------------------------===//
-AnyTypeInfo::AnyTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::ANY_TYPE_INFO) {
-}
-
-AnyTypeInfo::AnyTypeInfo(LogicalType target_type_p, idx_t cast_score_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::ANY_TYPE_INFO), target_type(std::move(target_type_p)), cast_score(cast_score_p) {
-}
-
-bool AnyTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<AnyTypeInfo>();
-	return target_type == other.target_type && cast_score == other.cast_score;
-}
-
-shared_ptr<ExtraTypeInfo> AnyTypeInfo::Copy() const {
-	return make_shared_ptr<AnyTypeInfo>(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// Integer Literal Type Info
-//===--------------------------------------------------------------------===//
-IntegerLiteralTypeInfo::IntegerLiteralTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO) {
-}
-
-IntegerLiteralTypeInfo::IntegerLiteralTypeInfo(Value constant_value_p)
-    : ExtraTypeInfo(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO), constant_value(std::move(constant_value_p)) {
-	if (constant_value.IsNull()) {
-		throw InternalException("Integer literal cannot be NULL");
-	}
-}
-
-bool IntegerLiteralTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
-	auto &other = other_p->Cast<IntegerLiteralTypeInfo>();
-	return constant_value == other.constant_value;
-}
-
-shared_ptr<ExtraTypeInfo> IntegerLiteralTypeInfo::Copy() const {
-	return make_shared_ptr<IntegerLiteralTypeInfo>(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/file_buffer.cpp b/src/duckdb/src/common/file_buffer.cpp
deleted file mode 100644
index b1b1febb3..000000000
--- a/src/duckdb/src/common/file_buffer.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-#include "duckdb/common/file_buffer.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include <cstring>
-
-namespace duckdb {
-
-FileBuffer::FileBuffer(Allocator &allocator, FileBufferType type, uint64_t user_size)
-    : allocator(allocator), type(type) {
-	Init();
-	if (user_size) {
-		Resize(user_size);
-	}
-}
-
-void FileBuffer::Init() {
-	buffer = nullptr;
-	size = 0;
-	internal_buffer = nullptr;
-	internal_size = 0;
-}
-
-FileBuffer::FileBuffer(FileBuffer &source, FileBufferType type_p) : allocator(source.allocator), type(type_p) {
-	// take over the structures of the source buffer
-	buffer = source.buffer;
-	size = source.size;
-	internal_buffer = source.internal_buffer;
-	internal_size = source.internal_size;
-
-	source.Init();
-}
-
-FileBuffer::~FileBuffer() {
-	if (!internal_buffer) {
-		return;
-	}
-	allocator.FreeData(internal_buffer, internal_size);
-}
-
-void FileBuffer::ReallocBuffer(idx_t new_size) {
-	data_ptr_t new_buffer;
-	if (internal_buffer) {
-		new_buffer = allocator.ReallocateData(internal_buffer, internal_size, new_size);
-	} else {
-		new_buffer = allocator.AllocateData(new_size);
-	}
-
-	// FIXME: should we throw one of our exceptions here?
-	if (!new_buffer) {
-		throw std::bad_alloc();
-	}
-	internal_buffer = new_buffer;
-	internal_size = new_size;
-
-	// The caller must update these.
-	buffer = nullptr;
-	size = 0;
-}
-
-FileBuffer::MemoryRequirement FileBuffer::CalculateMemory(uint64_t user_size) {
-	FileBuffer::MemoryRequirement result;
-
-	if (type == FileBufferType::TINY_BUFFER) {
-		// We never do IO on tiny buffers, so there's no need to add a header or sector-align.
-		result.header_size = 0;
-		result.alloc_size = user_size;
-	} else {
-		result.header_size = Storage::DEFAULT_BLOCK_HEADER_SIZE;
-		result.alloc_size = AlignValue<idx_t, Storage::SECTOR_SIZE>(result.header_size + user_size);
-	}
-	return result;
-}
-
-void FileBuffer::Resize(uint64_t new_size) {
-	auto req = CalculateMemory(new_size);
-	ReallocBuffer(req.alloc_size);
-
-	if (new_size > 0) {
-		buffer = internal_buffer + req.header_size;
-		size = internal_size - req.header_size;
-	}
-}
-
-void FileBuffer::Read(FileHandle &handle, uint64_t location) {
-	D_ASSERT(type != FileBufferType::TINY_BUFFER);
-	handle.Read(internal_buffer, internal_size, location);
-}
-
-void FileBuffer::Write(FileHandle &handle, uint64_t location) {
-	D_ASSERT(type != FileBufferType::TINY_BUFFER);
-	handle.Write(internal_buffer, internal_size, location);
-}
-
-void FileBuffer::Clear() {
-	memset(internal_buffer, 0, internal_size);
-}
-
-void FileBuffer::Initialize(DebugInitialize initialize) {
-	if (initialize == DebugInitialize::NO_INITIALIZE) {
-		return;
-	}
-	uint8_t value = initialize == DebugInitialize::DEBUG_ZERO_INITIALIZE ? 0 : 0xFF;
-	memset(internal_buffer, value, internal_size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/file_system.cpp b/src/duckdb/src/common/file_system.cpp
deleted file mode 100644
index fbcf0cede..000000000
--- a/src/duckdb/src/common/file_system.cpp
+++ /dev/null
@@ -1,662 +0,0 @@
-#include "duckdb/common/file_system.hpp"
-
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/windows.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/common/windows_util.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-
-#include <cstdint>
-#include <cstdio>
-
-#ifndef _WIN32
-#include <dirent.h>
-#include <fcntl.h>
-#include <string.h>
-#include <limits.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#ifdef __MVS__
-#define _XOPEN_SOURCE_EXTENDED 1
-#include <sys/resource.h>
-// enjoy - https://reviews.llvm.org/D92110
-#define PATH_MAX _XOPEN_PATH_MAX
-#endif
-
-#else
-#include <string>
-#include <sysinfoapi.h>
-
-#ifdef __MINGW32__
-// need to manually define this for mingw
-extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG);
-#endif
-
-#undef FILE_CREATE // woo mingw
-#endif
-
-namespace duckdb {
-
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_READ;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_WRITE;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_DIRECT_IO;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_FILE_CREATE;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_FILE_CREATE_NEW;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_APPEND;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_PRIVATE;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_PARALLEL_ACCESS;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_EXCLUSIVE_CREATE;
-constexpr FileOpenFlags FileFlags::FILE_FLAGS_NULL_IF_EXISTS;
-
-void FileOpenFlags::Verify() {
-#ifdef DEBUG
-	bool is_read = flags & FileOpenFlags::FILE_FLAGS_READ;
-	bool is_write = flags & FileOpenFlags::FILE_FLAGS_WRITE;
-	bool is_create =
-	    (flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE) || (flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW);
-	bool is_private = (flags & FileOpenFlags::FILE_FLAGS_PRIVATE);
-	bool null_if_not_exists = flags & FileOpenFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS;
-	bool exclusive_create = flags & FileOpenFlags::FILE_FLAGS_EXCLUSIVE_CREATE;
-	bool null_if_exists = flags & FileOpenFlags::FILE_FLAGS_NULL_IF_EXISTS;
-
-	// require either READ or WRITE (or both)
-	D_ASSERT(is_read || is_write);
-	// CREATE/Append flags require writing
-	D_ASSERT(is_write || !(flags & FileOpenFlags::FILE_FLAGS_APPEND));
-	D_ASSERT(is_write || !(flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE));
-	D_ASSERT(is_write || !(flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW));
-	// cannot combine CREATE and CREATE_NEW flags
-	D_ASSERT(!(flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE && flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW));
-
-	// For is_private can only be set along with a create flag
-	D_ASSERT(!is_private || is_create);
-	// FILE_FLAGS_NULL_IF_NOT_EXISTS cannot be combined with CREATE/CREATE_NEW
-	D_ASSERT(!(null_if_not_exists && is_create));
-	// FILE_FLAGS_EXCLUSIVE_CREATE only can be combined with CREATE/CREATE_NEW
-	D_ASSERT(!exclusive_create || is_create);
-	// FILE_FLAGS_NULL_IF_EXISTS only can be set with EXCLUSIVE_CREATE
-	D_ASSERT(!null_if_exists || exclusive_create);
-#endif
-}
-
-FileSystem::~FileSystem() {
-}
-
-FileSystem &FileSystem::GetFileSystem(ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return *client_data.client_file_system;
-}
-
-bool PathMatched(const string &path, const string &sub_path) {
-	return path.rfind(sub_path, 0) == 0;
-}
-
-#ifndef _WIN32
-
-string FileSystem::GetEnvVariable(const string &name) {
-	const char *env = getenv(name.c_str());
-	if (!env) {
-		return string();
-	}
-	return env;
-}
-
-bool FileSystem::IsPathAbsolute(const string &path) {
-	auto path_separator = PathSeparator(path);
-	return PathMatched(path, path_separator) || StringUtil::StartsWith(path, "file:/");
-}
-
-string FileSystem::PathSeparator(const string &path) {
-	return "/";
-}
-
-void FileSystem::SetWorkingDirectory(const string &path) {
-	if (chdir(path.c_str()) != 0) {
-		throw IOException("Could not change working directory!");
-	}
-}
-
-optional_idx FileSystem::GetAvailableMemory() {
-	errno = 0;
-
-#ifdef __MVS__
-	struct rlimit limit;
-	int rlim_rc = getrlimit(RLIMIT_AS, &limit);
-	idx_t max_memory = MinValue<idx_t>(limit.rlim_max, UINTPTR_MAX);
-#else
-	idx_t max_memory = MinValue<idx_t>((idx_t)sysconf(_SC_PHYS_PAGES) * (idx_t)sysconf(_SC_PAGESIZE), UINTPTR_MAX);
-#endif
-	if (errno != 0) {
-		return optional_idx();
-	}
-	return max_memory;
-}
-
-optional_idx FileSystem::GetAvailableDiskSpace(const string &path) {
-	struct statvfs vfs;
-
-	auto ret = statvfs(path.c_str(), &vfs);
-	if (ret == -1) {
-		return optional_idx();
-	}
-	auto block_size = vfs.f_frsize;
-	// These are the blocks available for creating new files or extending existing ones
-	auto available_blocks = vfs.f_bfree;
-	idx_t available_disk_space = DConstants::INVALID_INDEX;
-	if (!TryMultiplyOperator::Operation(static_cast<idx_t>(block_size), static_cast<idx_t>(available_blocks),
-	                                    available_disk_space)) {
-		return optional_idx();
-	}
-	return available_disk_space;
-}
-
-string FileSystem::GetWorkingDirectory() {
-	auto buffer = make_unsafe_uniq_array<char>(PATH_MAX);
-	char *ret = getcwd(buffer.get(), PATH_MAX);
-	if (!ret) {
-		throw IOException("Could not get working directory!");
-	}
-	return string(buffer.get());
-}
-
-string FileSystem::NormalizeAbsolutePath(const string &path) {
-	D_ASSERT(IsPathAbsolute(path));
-	return path;
-}
-
-#else
-
-string FileSystem::GetEnvVariable(const string &env) {
-	// first convert the environment variable name to the correct encoding
-	auto env_w = WindowsUtil::UTF8ToUnicode(env.c_str());
-	// use _wgetenv to get the value
-	auto res_w = _wgetenv(env_w.c_str());
-	if (!res_w) {
-		// no environment variable of this name found
-		return string();
-	}
-	return WindowsUtil::UnicodeToUTF8(res_w);
-}
-
-static bool StartsWithSingleBackslash(const string &path) {
-	if (path.size() < 2) {
-		return false;
-	}
-	if (path[0] != '/' && path[0] != '\\') {
-		return false;
-	}
-	if (path[1] == '/' || path[1] == '\\') {
-		return false;
-	}
-	return true;
-}
-
-bool FileSystem::IsPathAbsolute(const string &path) {
-	// 1) A single backslash or forward-slash
-	if (StartsWithSingleBackslash(path)) {
-		return true;
-	}
-	// 2) special "long paths" on windows
-	if (PathMatched(path, "\\\\?\\")) {
-		return true;
-	}
-	// 3) a network path
-	if (PathMatched(path, "\\\\")) {
-		return true;
-	}
-	// 4) A disk designator with a backslash (e.g., C:\ or C:/)
-	auto path_aux = path;
-	path_aux.erase(0, 1);
-	if (PathMatched(path_aux, ":\\") || PathMatched(path_aux, ":/")) {
-		return true;
-	}
-	return false;
-}
-
-string FileSystem::NormalizeAbsolutePath(const string &path) {
-	D_ASSERT(IsPathAbsolute(path));
-	auto result = StringUtil::Lower(FileSystem::ConvertSeparators(path));
-	if (StartsWithSingleBackslash(result)) {
-		// Path starts with a single backslash or forward slash
-		// prepend drive letter
-		return GetWorkingDirectory().substr(0, 2) + result;
-	}
-	return result;
-}
-
-string FileSystem::PathSeparator(const string &path) {
-	if (StringUtil::StartsWith(path, "file:")) {
-		return "/";
-	} else {
-		return "\\";
-	}
-}
-
-void FileSystem::SetWorkingDirectory(const string &path) {
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str());
-	if (!SetCurrentDirectoryW(unicode_path.c_str())) {
-		throw IOException("Could not change working directory to \"%s\"", path);
-	}
-}
-
-optional_idx FileSystem::GetAvailableMemory() {
-	ULONGLONG available_memory_kb;
-	if (GetPhysicallyInstalledSystemMemory(&available_memory_kb)) {
-		return MinValue<idx_t>(available_memory_kb * 1000, UINTPTR_MAX);
-	}
-	// fallback: try GlobalMemoryStatusEx
-	MEMORYSTATUSEX mem_state;
-	mem_state.dwLength = sizeof(MEMORYSTATUSEX);
-
-	if (GlobalMemoryStatusEx(&mem_state)) {
-		return MinValue<idx_t>(mem_state.ullTotalPhys, UINTPTR_MAX);
-	}
-	return optional_idx();
-}
-
-optional_idx FileSystem::GetAvailableDiskSpace(const string &path) {
-	ULARGE_INTEGER available_bytes, total_bytes, free_bytes;
-
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str());
-	if (!GetDiskFreeSpaceExW(unicode_path.c_str(), &available_bytes, &total_bytes, &free_bytes)) {
-		return optional_idx();
-	}
-	(void)total_bytes;
-	(void)free_bytes;
-	return NumericCast<idx_t>(available_bytes.QuadPart);
-}
-
-string FileSystem::GetWorkingDirectory() {
-	idx_t count = GetCurrentDirectoryW(0, nullptr);
-	if (count == 0) {
-		throw IOException("Could not get working directory!");
-	}
-	auto buffer = make_unsafe_uniq_array<wchar_t>(count);
-	idx_t ret = GetCurrentDirectoryW(count, buffer.get());
-	if (count != ret + 1) {
-		throw IOException("Could not get working directory!");
-	}
-	return WindowsUtil::UnicodeToUTF8(buffer.get());
-}
-
-#endif
-
-string FileSystem::JoinPath(const string &a, const string &b) {
-	// FIXME: sanitize paths
-	return a.empty() ? b : a + PathSeparator(a) + b;
-}
-
-string FileSystem::ConvertSeparators(const string &path) {
-	auto separator_str = PathSeparator(path);
-	char separator = separator_str[0];
-	if (separator == '/') {
-		// on unix-based systems we only accept / as a separator
-		return path;
-	}
-	// on windows-based systems we accept both
-	return StringUtil::Replace(path, "/", separator_str);
-}
-
-string FileSystem::ExtractName(const string &path) {
-	if (path.empty()) {
-		return string();
-	}
-	auto normalized_path = ConvertSeparators(path);
-	auto sep = PathSeparator(path);
-	auto splits = StringUtil::Split(normalized_path, sep);
-	D_ASSERT(!splits.empty());
-	return splits.back();
-}
-
-string FileSystem::ExtractBaseName(const string &path) {
-	if (path.empty()) {
-		return string();
-	}
-	auto vec = StringUtil::Split(ExtractName(path), ".");
-	D_ASSERT(!vec.empty());
-	return vec[0];
-}
-
-string FileSystem::GetHomeDirectory(optional_ptr<FileOpener> opener) {
-	// read the home_directory setting first, if it is set
-	if (opener) {
-		Value result;
-		if (opener->TryGetCurrentSetting("home_directory", result)) {
-			if (!result.IsNull() && !result.ToString().empty()) {
-				return result.ToString();
-			}
-		}
-	}
-	// fallback to the default home directories for the specified system
-#ifdef DUCKDB_WINDOWS
-	return FileSystem::GetEnvVariable("USERPROFILE");
-#else
-	return FileSystem::GetEnvVariable("HOME");
-#endif
-}
-
-string FileSystem::GetHomeDirectory() {
-	return GetHomeDirectory(nullptr);
-}
-
-string FileSystem::ExpandPath(const string &path, optional_ptr<FileOpener> opener) {
-	if (path.empty()) {
-		return path;
-	}
-	if (path[0] == '~') {
-		return GetHomeDirectory(opener) + path.substr(1);
-	}
-	return path;
-}
-
-string FileSystem::ExpandPath(const string &path) {
-	return FileSystem::ExpandPath(path, nullptr);
-}
-
-// LCOV_EXCL_START
-unique_ptr<FileHandle> FileSystem::OpenFile(const string &path, FileOpenFlags flags, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: OpenFile is not implemented!", GetName());
-}
-
-void FileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	throw NotImplementedException("%s: Read (with location) is not implemented!", GetName());
-}
-
-bool FileSystem::Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) {
-	// This is not a required method. Derived FileSystems may optionally override/implement.
-	return false;
-}
-
-void FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	throw NotImplementedException("%s: Write (with location) is not implemented!", GetName());
-}
-
-int64_t FileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	throw NotImplementedException("%s: Read is not implemented!", GetName());
-}
-
-int64_t FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	throw NotImplementedException("%s: Write is not implemented!", GetName());
-}
-
-int64_t FileSystem::GetFileSize(FileHandle &handle) {
-	throw NotImplementedException("%s: GetFileSize is not implemented!", GetName());
-}
-
-time_t FileSystem::GetLastModifiedTime(FileHandle &handle) {
-	throw NotImplementedException("%s: GetLastModifiedTime is not implemented!", GetName());
-}
-
-FileType FileSystem::GetFileType(FileHandle &handle) {
-	return FileType::FILE_TYPE_INVALID;
-}
-
-void FileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	throw NotImplementedException("%s: Truncate is not implemented!", GetName());
-}
-
-bool FileSystem::DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: DirectoryExists is not implemented!", GetName());
-}
-
-void FileSystem::CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: CreateDirectory is not implemented!", GetName());
-}
-
-void FileSystem::RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: RemoveDirectory is not implemented!", GetName());
-}
-
-bool FileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-                           FileOpener *opener) {
-	throw NotImplementedException("%s: ListFiles is not implemented!", GetName());
-}
-
-void FileSystem::MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: MoveFile is not implemented!", GetName());
-}
-
-bool FileSystem::FileExists(const string &filename, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: FileExists is not implemented!", GetName());
-}
-
-bool FileSystem::IsPipe(const string &filename, optional_ptr<FileOpener> opener) {
-	return false;
-}
-
-void FileSystem::RemoveFile(const string &filename, optional_ptr<FileOpener> opener) {
-	throw NotImplementedException("%s: RemoveFile is not implemented!", GetName());
-}
-
-void FileSystem::FileSync(FileHandle &handle) {
-	throw NotImplementedException("%s: FileSync is not implemented!", GetName());
-}
-
-bool FileSystem::HasGlob(const string &str) {
-	for (idx_t i = 0; i < str.size(); i++) {
-		switch (str[i]) {
-		case '*':
-		case '?':
-		case '[':
-			return true;
-		default:
-			break;
-		}
-	}
-	return false;
-}
-
-vector<string> FileSystem::Glob(const string &path, FileOpener *opener) {
-	throw NotImplementedException("%s: Glob is not implemented!", GetName());
-}
-
-void FileSystem::RegisterSubSystem(unique_ptr<FileSystem> sub_fs) {
-	throw NotImplementedException("%s: Can't register a sub system on a non-virtual file system", GetName());
-}
-
-void FileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> sub_fs) {
-	throw NotImplementedException("%s: Can't register a sub system on a non-virtual file system", GetName());
-}
-
-void FileSystem::UnregisterSubSystem(const string &name) {
-	throw NotImplementedException("%s: Can't unregister a sub system on a non-virtual file system", GetName());
-}
-
-void FileSystem::SetDisabledFileSystems(const vector<string> &names) {
-	throw NotImplementedException("%s: Can't disable file systems on a non-virtual file system", GetName());
-}
-
-vector<string> FileSystem::ListSubSystems() {
-	throw NotImplementedException("%s: Can't list sub systems on a non-virtual file system", GetName());
-}
-
-bool FileSystem::CanHandleFile(const string &fpath) {
-	throw NotImplementedException("%s: CanHandleFile is not implemented!", GetName());
-}
-
-static string LookupExtensionForPattern(const string &pattern) {
-	for (const auto &entry : EXTENSION_FILE_PREFIXES) {
-		if (StringUtil::StartsWith(pattern, entry.name)) {
-			return entry.extension;
-		}
-	}
-	return "";
-}
-
-vector<string> FileSystem::GlobFiles(const string &pattern, ClientContext &context, FileGlobOptions options) {
-	auto result = Glob(pattern);
-	if (result.empty()) {
-		string required_extension = LookupExtensionForPattern(pattern);
-		if (!required_extension.empty() && !context.db->ExtensionIsLoaded(required_extension)) {
-			auto &dbconfig = DBConfig::GetConfig(context);
-			if (!ExtensionHelper::CanAutoloadExtension(required_extension) ||
-			    !dbconfig.options.autoload_known_extensions) {
-				auto error_message =
-				    "File " + pattern + " requires the extension " + required_extension + " to be loaded";
-				error_message =
-				    ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, required_extension);
-				throw MissingExtensionException(error_message);
-			}
-			// an extension is required to read this file, but it is not loaded - try to load it
-			ExtensionHelper::AutoLoadExtension(context, required_extension);
-			// success! glob again
-			// check the extension is loaded just in case to prevent an infinite loop here
-			if (!context.db->ExtensionIsLoaded(required_extension)) {
-				throw InternalException("Extension load \"%s\" did not throw but somehow the extension was not loaded",
-				                        required_extension);
-			}
-			return GlobFiles(pattern, context, options);
-		}
-		if (options == FileGlobOptions::DISALLOW_EMPTY) {
-			throw IOException("No files found that match the pattern \"%s\"", pattern);
-		}
-	}
-	return result;
-}
-
-void FileSystem::Seek(FileHandle &handle, idx_t location) {
-	throw NotImplementedException("%s: Seek is not implemented!", GetName());
-}
-
-void FileSystem::Reset(FileHandle &handle) {
-	handle.Seek(0);
-}
-
-idx_t FileSystem::SeekPosition(FileHandle &handle) {
-	throw NotImplementedException("%s: SeekPosition is not implemented!", GetName());
-}
-
-bool FileSystem::CanSeek() {
-	throw NotImplementedException("%s: CanSeek is not implemented!", GetName());
-}
-
-bool FileSystem::IsManuallySet() {
-	return false;
-}
-
-unique_ptr<FileHandle> FileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
-	throw NotImplementedException("%s: OpenCompressedFile is not implemented!", GetName());
-}
-
-bool FileSystem::OnDiskFile(FileHandle &handle) {
-	throw NotImplementedException("%s: OnDiskFile is not implemented!", GetName());
-}
-// LCOV_EXCL_STOP
-
-FileHandle::FileHandle(FileSystem &file_system, string path_p, FileOpenFlags flags)
-    : file_system(file_system), path(std::move(path_p)), flags(flags) {
-}
-
-FileHandle::~FileHandle() {
-}
-
-int64_t FileHandle::Read(void *buffer, idx_t nr_bytes) {
-	return file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
-}
-
-bool FileHandle::Trim(idx_t offset_bytes, idx_t length_bytes) {
-	return file_system.Trim(*this, offset_bytes, length_bytes);
-}
-
-int64_t FileHandle::Write(void *buffer, idx_t nr_bytes) {
-	return file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
-}
-
-void FileHandle::Read(void *buffer, idx_t nr_bytes, idx_t location) {
-	file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
-}
-
-void FileHandle::Write(void *buffer, idx_t nr_bytes, idx_t location) {
-	file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
-}
-
-void FileHandle::Seek(idx_t location) {
-	file_system.Seek(*this, location);
-}
-
-void FileHandle::Reset() {
-	file_system.Reset(*this);
-}
-
-idx_t FileHandle::SeekPosition() {
-	return file_system.SeekPosition(*this);
-}
-
-bool FileHandle::CanSeek() {
-	return file_system.CanSeek();
-}
-
-FileCompressionType FileHandle::GetFileCompressionType() {
-	return FileCompressionType::UNCOMPRESSED;
-}
-
-bool FileHandle::IsPipe() {
-	return file_system.IsPipe(path);
-}
-
-string FileHandle::ReadLine() {
-	string result;
-	char buffer[1];
-	while (true) {
-		auto tuples_read = UnsafeNumericCast<idx_t>(Read(buffer, 1));
-		if (tuples_read == 0 || buffer[0] == '\n') {
-			return result;
-		}
-		if (buffer[0] != '\r') {
-			result += buffer[0];
-		}
-	}
-}
-
-bool FileHandle::OnDiskFile() {
-	return file_system.OnDiskFile(*this);
-}
-
-idx_t FileHandle::GetFileSize() {
-	return NumericCast<idx_t>(file_system.GetFileSize(*this));
-}
-
-void FileHandle::Sync() {
-	file_system.FileSync(*this);
-}
-
-void FileHandle::Truncate(int64_t new_size) {
-	file_system.Truncate(*this, new_size);
-}
-
-FileType FileHandle::GetType() {
-	return file_system.GetFileType(*this);
-}
-
-idx_t FileHandle::GetProgress() {
-	throw NotImplementedException("GetProgress is not implemented for this file handle");
-}
-
-bool FileSystem::IsRemoteFile(const string &path) {
-	string extension = "";
-	return IsRemoteFile(path, extension);
-}
-
-bool FileSystem::IsRemoteFile(const string &path, string &extension) {
-	for (const auto &entry : EXTENSION_FILE_PREFIXES) {
-		if (StringUtil::StartsWith(path, entry.name)) {
-			extension = entry.extension;
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/filename_pattern.cpp b/src/duckdb/src/common/filename_pattern.cpp
deleted file mode 100644
index 04851ad3f..000000000
--- a/src/duckdb/src/common/filename_pattern.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/common/filename_pattern.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-void FilenamePattern::SetFilenamePattern(const string &pattern) {
-	const string id_format {"{i}"};
-	const string uuid_format {"{uuid}"};
-
-	base = pattern;
-
-	pos = base.find(id_format);
-	uuid = false;
-	if (pos != string::npos) {
-		base = StringUtil::Replace(base, id_format, "");
-		uuid = false;
-	}
-
-	pos = base.find(uuid_format);
-	if (pos != string::npos) {
-		base = StringUtil::Replace(base, uuid_format, "");
-		uuid = true;
-	}
-
-	pos = std::min(pos, (idx_t)base.length());
-}
-
-string FilenamePattern::CreateFilename(FileSystem &fs, const string &path, const string &extension,
-                                       idx_t offset) const {
-	string result(base);
-	string replacement;
-
-	if (uuid) {
-		replacement = UUID::ToString(UUID::GenerateRandomUUID());
-	} else {
-		replacement = std::to_string(offset);
-	}
-	result.insert(pos, replacement);
-	return fs.JoinPath(path, result + "." + extension);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/fsst.cpp b/src/duckdb/src/common/fsst.cpp
deleted file mode 100644
index 1e28ad5ab..000000000
--- a/src/duckdb/src/common/fsst.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/fsst.hpp"
-#include "fsst.h"
-
-namespace duckdb {
-
-string_t FSSTPrimitives::DecompressValue(void *duckdb_fsst_decoder, Vector &result, const char *compressed_string,
-                                         const idx_t compressed_string_len, vector<unsigned char> &decompress_buffer) {
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto fsst_decoder = reinterpret_cast<duckdb_fsst_decoder_t *>(duckdb_fsst_decoder);
-	auto compressed_string_ptr = (unsigned char *)compressed_string; // NOLINT
-	auto decompressed_string_size = duckdb_fsst_decompress(fsst_decoder, compressed_string_len, compressed_string_ptr,
-	                                                       decompress_buffer.size(), decompress_buffer.data());
-
-	D_ASSERT(!decompress_buffer.empty());
-	D_ASSERT(decompressed_string_size <= decompress_buffer.size() - 1);
-	return StringVector::AddStringOrBlob(result, const_char_ptr_cast(decompress_buffer.data()),
-	                                     decompressed_string_size);
-}
-
-string FSSTPrimitives::DecompressValue(void *duckdb_fsst_decoder, const char *compressed_string,
-                                       const idx_t compressed_string_len, vector<unsigned char> &decompress_buffer) {
-
-	auto compressed_string_ptr = (unsigned char *)compressed_string; // NOLINT
-	auto fsst_decoder = reinterpret_cast<duckdb_fsst_decoder_t *>(duckdb_fsst_decoder);
-	auto decompressed_string_size = duckdb_fsst_decompress(fsst_decoder, compressed_string_len, compressed_string_ptr,
-	                                                       decompress_buffer.size(), decompress_buffer.data());
-
-	D_ASSERT(!decompress_buffer.empty());
-	D_ASSERT(decompressed_string_size <= decompress_buffer.size() - 1);
-	return string(char_ptr_cast(decompress_buffer.data()), decompressed_string_size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/gzip_file_system.cpp b/src/duckdb/src/common/gzip_file_system.cpp
deleted file mode 100644
index ee0a21580..000000000
--- a/src/duckdb/src/common/gzip_file_system.cpp
+++ /dev/null
@@ -1,424 +0,0 @@
-#include "duckdb/common/gzip_file_system.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-#include "miniz.hpp"
-#include "miniz_wrapper.hpp"
-
-#include "duckdb/common/limits.hpp"
-
-namespace duckdb {
-
-/*
-
-  0      2 bytes  magic header  0x1f, 0x8b (\037 \213)
-  2      1 byte   compression method
-                     0: store (copied)
-                     1: compress
-                     2: pack
-                     3: lzh
-                     4..7: reserved
-                     8: deflate
-  3      1 byte   flags
-                     bit 0 set: file probably ascii text
-                     bit 1 set: continuation of multi-part gzip file, part number present
-                     bit 2 set: extra field present
-                     bit 3 set: original file name present
-                     bit 4 set: file comment present
-                     bit 5 set: file is encrypted, encryption header present
-                     bit 6,7:   reserved
-  4      4 bytes  file modification time in Unix format
-  8      1 byte   extra flags (depend on compression method)
-  9      1 byte   OS type
-[
-         2 bytes  optional part number (second part=1)
-]?
-[
-         2 bytes  optional extra field length (e)
-        (e)bytes  optional extra field
-]?
-[
-           bytes  optional original file name, zero terminated
-]?
-[
-           bytes  optional file comment, zero terminated
-]?
-[
-        12 bytes  optional encryption header
-]?
-           bytes  compressed data
-         4 bytes  crc32
-         4 bytes  uncompressed input size modulo 2^32
-
- */
-
-static idx_t GZipConsumeString(FileHandle &input) {
-	idx_t size = 1; // terminator
-	char buffer[1];
-	while (input.Read(buffer, 1) == 1) {
-		if (buffer[0] == '\0') {
-			break;
-		}
-		size++;
-	}
-	return size;
-}
-
-struct MiniZStreamWrapper : public StreamWrapper {
-	~MiniZStreamWrapper() override;
-
-	CompressedFile *file = nullptr;
-	unique_ptr<duckdb_miniz::mz_stream> mz_stream_ptr;
-	bool writing = false;
-	duckdb_miniz::mz_ulong crc;
-	idx_t total_size;
-
-public:
-	void Initialize(CompressedFile &file, bool write) override;
-
-	bool Read(StreamData &stream_data) override;
-	void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer, int64_t nr_bytes) override;
-
-	void Close() override;
-
-	void FlushStream();
-};
-
-MiniZStreamWrapper::~MiniZStreamWrapper() {
-	// avoid closing if destroyed during stack unwinding
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	try {
-		MiniZStreamWrapper::Close();
-	} catch (...) { // NOLINT - cannot throw in exception
-	}
-}
-
-void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
-	Close();
-	this->file = &file;
-	mz_stream_ptr = make_uniq<duckdb_miniz::mz_stream>();
-	memset(mz_stream_ptr.get(), 0, sizeof(duckdb_miniz::mz_stream));
-	this->writing = write;
-
-	// TODO use custom alloc/free methods in miniz to throw exceptions on OOM
-	uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
-	if (write) {
-		crc = MZ_CRC32_INIT;
-		total_size = 0;
-
-		MiniZStream::InitializeGZIPHeader(gzip_hdr);
-		file.child_handle->Write(gzip_hdr, GZIP_HEADER_MINSIZE);
-
-		auto ret = mz_deflateInit2(mz_stream_ptr.get(), duckdb_miniz::MZ_DEFAULT_LEVEL, MZ_DEFLATED,
-		                           -MZ_DEFAULT_WINDOW_BITS, 1, 0);
-		if (ret != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to initialize miniz");
-		}
-	} else {
-		idx_t data_start = GZIP_HEADER_MINSIZE;
-		auto read_count = file.child_handle->Read(gzip_hdr, GZIP_HEADER_MINSIZE);
-		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, NumericCast<idx_t>(read_count));
-		// Skip over the extra field if necessary
-		if (gzip_hdr[3] & GZIP_FLAG_EXTRA) {
-			uint8_t gzip_xlen[2];
-			file.child_handle->Seek(data_start);
-			file.child_handle->Read(gzip_xlen, 2);
-			auto xlen = NumericCast<idx_t>((uint8_t)gzip_xlen[0] | (uint8_t)gzip_xlen[1] << 8);
-			data_start += xlen + 2;
-		}
-		// Skip over the file name if necessary
-		if (gzip_hdr[3] & GZIP_FLAG_NAME) {
-			file.child_handle->Seek(data_start);
-			data_start += GZipConsumeString(*file.child_handle);
-		}
-		file.child_handle->Seek(data_start);
-		// stream is now set to beginning of payload data
-		auto ret = duckdb_miniz::mz_inflateInit2(mz_stream_ptr.get(), -MZ_DEFAULT_WINDOW_BITS);
-		if (ret != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to initialize miniz");
-		}
-	}
-}
-
-bool MiniZStreamWrapper::Read(StreamData &sd) {
-	// Handling for the concatenated files
-	if (sd.refresh) {
-		auto available = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
-		if (available <= GZIP_FOOTER_SIZE) {
-			// Only footer is available so we just close and return finished
-			Close();
-			return true;
-		}
-
-		sd.refresh = false;
-		auto body_ptr = sd.in_buff_start + GZIP_FOOTER_SIZE;
-		uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
-		memcpy(gzip_hdr, body_ptr, GZIP_HEADER_MINSIZE);
-		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, GZIP_HEADER_MINSIZE);
-		body_ptr += GZIP_HEADER_MINSIZE;
-		if (gzip_hdr[3] & GZIP_FLAG_EXTRA) {
-			auto xlen = NumericCast<idx_t>((uint8_t)*body_ptr | (uint8_t) * (body_ptr + 1) << 8);
-			body_ptr += xlen + 2;
-			if (GZIP_FOOTER_SIZE + GZIP_HEADER_MINSIZE + 2 + xlen >= GZIP_HEADER_MAXSIZE) {
-				throw InternalException("Extra field resulting in GZIP header larger than defined maximum (%d)",
-				                        GZIP_HEADER_MAXSIZE);
-			}
-		}
-		if (gzip_hdr[3] & GZIP_FLAG_NAME) {
-			char c;
-			do {
-				c = UnsafeNumericCast<char>(*body_ptr);
-				body_ptr++;
-			} while (c != '\0' && body_ptr < sd.in_buff_end);
-			if ((idx_t)(body_ptr - sd.in_buff_start) >= GZIP_HEADER_MAXSIZE) {
-				throw InternalException("Filename resulting in GZIP header larger than defined maximum (%d)",
-				                        GZIP_HEADER_MAXSIZE);
-			}
-		}
-		sd.in_buff_start = body_ptr;
-		if (sd.in_buff_end - sd.in_buff_start < 1) {
-			Close();
-			return true;
-		}
-		duckdb_miniz::mz_inflateEnd(mz_stream_ptr.get());
-		auto sta = duckdb_miniz::mz_inflateInit2(mz_stream_ptr.get(), -MZ_DEFAULT_WINDOW_BITS);
-		if (sta != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to initialize miniz");
-		}
-	}
-
-	// actually decompress
-	mz_stream_ptr->next_in = sd.in_buff_start;
-	D_ASSERT(sd.in_buff_end - sd.in_buff_start < NumericLimits<int32_t>::Maximum());
-	mz_stream_ptr->avail_in = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
-	mz_stream_ptr->next_out = data_ptr_cast(sd.out_buff_end);
-	mz_stream_ptr->avail_out = (uint32_t)((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_end);
-	auto ret = duckdb_miniz::mz_inflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
-	if (ret != duckdb_miniz::MZ_OK && ret != duckdb_miniz::MZ_STREAM_END) {
-		throw IOException("Failed to decode gzip stream: %s", duckdb_miniz::mz_error(ret));
-	}
-	// update pointers following inflate()
-	sd.in_buff_start = (data_ptr_t)mz_stream_ptr->next_in; // NOLINT
-	sd.in_buff_end = sd.in_buff_start + mz_stream_ptr->avail_in;
-	sd.out_buff_end = data_ptr_cast(mz_stream_ptr->next_out);
-	D_ASSERT(sd.out_buff_end + mz_stream_ptr->avail_out == sd.out_buff.get() + sd.out_buf_size);
-
-	// if stream ended, deallocate inflator
-	if (ret == duckdb_miniz::MZ_STREAM_END) {
-		// Concatenated GZIP potentially coming up - refresh input buffer
-		sd.refresh = true;
-	}
-	return false;
-}
-
-void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t uncompressed_data,
-                               int64_t uncompressed_size) {
-	// update the src and the total size
-	crc = duckdb_miniz::mz_crc32(crc, reinterpret_cast<const unsigned char *>(uncompressed_data),
-	                             UnsafeNumericCast<size_t>(uncompressed_size));
-	total_size += UnsafeNumericCast<idx_t>(uncompressed_size);
-
-	auto remaining = uncompressed_size;
-	while (remaining > 0) {
-		auto output_remaining = UnsafeNumericCast<idx_t>((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start);
-
-		mz_stream_ptr->next_in = reinterpret_cast<const unsigned char *>(uncompressed_data);
-		mz_stream_ptr->avail_in = NumericCast<unsigned int>(remaining);
-		mz_stream_ptr->next_out = sd.out_buff_start;
-		mz_stream_ptr->avail_out = NumericCast<unsigned int>(output_remaining);
-
-		auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
-		if (res != duckdb_miniz::MZ_OK) {
-			D_ASSERT(res != duckdb_miniz::MZ_STREAM_END);
-			throw InternalException("Failed to compress GZIP block");
-		}
-		sd.out_buff_start += output_remaining - mz_stream_ptr->avail_out;
-		if (mz_stream_ptr->avail_out == 0) {
-			// no more output buffer available: flush
-			file.child_handle->Write(sd.out_buff.get(),
-			                         UnsafeNumericCast<idx_t>(sd.out_buff_start - sd.out_buff.get()));
-			sd.out_buff_start = sd.out_buff.get();
-		}
-		auto written = UnsafeNumericCast<idx_t>(remaining - mz_stream_ptr->avail_in);
-		uncompressed_data += written;
-		remaining = mz_stream_ptr->avail_in;
-	}
-}
-
-void MiniZStreamWrapper::FlushStream() {
-	auto &sd = file->stream_data;
-	mz_stream_ptr->next_in = nullptr;
-	mz_stream_ptr->avail_in = 0;
-	while (true) {
-		auto output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
-		mz_stream_ptr->next_out = sd.out_buff_start;
-		mz_stream_ptr->avail_out = NumericCast<unsigned int>(output_remaining);
-
-		auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_FINISH);
-		sd.out_buff_start += (output_remaining - mz_stream_ptr->avail_out);
-		if (sd.out_buff_start > sd.out_buff.get()) {
-			file->child_handle->Write(sd.out_buff.get(),
-			                          UnsafeNumericCast<idx_t>(sd.out_buff_start - sd.out_buff.get()));
-			sd.out_buff_start = sd.out_buff.get();
-		}
-		if (res == duckdb_miniz::MZ_STREAM_END) {
-			break;
-		}
-		if (res != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to compress GZIP block");
-		}
-	}
-}
-
-void MiniZStreamWrapper::Close() {
-	if (!mz_stream_ptr) {
-		return;
-	}
-	if (writing) {
-		// flush anything remaining in the stream
-		FlushStream();
-
-		// write the footer
-		unsigned char gzip_footer[MiniZStream::GZIP_FOOTER_SIZE];
-		MiniZStream::InitializeGZIPFooter(gzip_footer, crc, total_size);
-		file->child_handle->Write(gzip_footer, MiniZStream::GZIP_FOOTER_SIZE);
-
-		duckdb_miniz::mz_deflateEnd(mz_stream_ptr.get());
-	} else {
-		duckdb_miniz::mz_inflateEnd(mz_stream_ptr.get());
-	}
-	mz_stream_ptr = nullptr;
-	file = nullptr;
-}
-
-class GZipFile : public CompressedFile {
-public:
-	GZipFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
-	    : CompressedFile(gzip_fs, std::move(child_handle_p), path) {
-		Initialize(write);
-	}
-	FileCompressionType GetFileCompressionType() override {
-		return FileCompressionType::GZIP;
-	}
-	GZipFileSystem gzip_fs;
-};
-
-void GZipFileSystem::VerifyGZIPHeader(uint8_t gzip_hdr[], idx_t read_count) {
-	// check for incorrectly formatted files
-	if (read_count != GZIP_HEADER_MINSIZE) {
-		throw IOException("Input is not a GZIP stream");
-	}
-	if (gzip_hdr[0] != 0x1F || gzip_hdr[1] != 0x8B) { // magic header
-		throw IOException("Input is not a GZIP stream");
-	}
-	if (gzip_hdr[2] != GZIP_COMPRESSION_DEFLATE) { // compression method
-		throw IOException("Unsupported GZIP compression method");
-	}
-	if (gzip_hdr[3] & GZIP_FLAG_UNSUPPORTED) {
-		throw IOException("Unsupported GZIP archive");
-	}
-}
-
-bool GZipFileSystem::CheckIsZip(const char *data, duckdb::idx_t size) {
-	if (size < GZIP_HEADER_MINSIZE) {
-		return false;
-	}
-
-	auto data_ptr = reinterpret_cast<const uint8_t *>(data);
-	if (data_ptr[0] != 0x1F || data_ptr[1] != 0x8B) {
-		return false;
-	}
-
-	if (data_ptr[2] != GZIP_COMPRESSION_DEFLATE) {
-		return false;
-	}
-
-	return true;
-}
-
-string GZipFileSystem::UncompressGZIPString(const string &in) {
-	return UncompressGZIPString(in.data(), in.size());
-}
-
-string GZipFileSystem::UncompressGZIPString(const char *data, idx_t size) {
-	// decompress file
-	auto body_ptr = data;
-
-	auto mz_stream_ptr = make_uniq<duckdb_miniz::mz_stream>();
-	memset(mz_stream_ptr.get(), 0, sizeof(duckdb_miniz::mz_stream));
-
-	uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
-
-	// check for incorrectly formatted files
-
-	// TODO this is mostly the same as gzip_file_system.cpp
-	if (size < GZIP_HEADER_MINSIZE) {
-		throw IOException("Input is not a GZIP stream");
-	}
-	memcpy(gzip_hdr, body_ptr, GZIP_HEADER_MINSIZE);
-	body_ptr += GZIP_HEADER_MINSIZE;
-	GZipFileSystem::VerifyGZIPHeader(gzip_hdr, GZIP_HEADER_MINSIZE);
-
-	if (gzip_hdr[3] & GZIP_FLAG_EXTRA) {
-		throw IOException("Extra field in a GZIP stream unsupported");
-	}
-
-	if (gzip_hdr[3] & GZIP_FLAG_NAME) {
-		char c;
-		do {
-			c = *body_ptr;
-			body_ptr++;
-		} while (c != '\0' && (idx_t)(body_ptr - data) < size);
-	}
-
-	// stream is now set to beginning of payload data
-	auto status = duckdb_miniz::mz_inflateInit2(mz_stream_ptr.get(), -MZ_DEFAULT_WINDOW_BITS);
-	if (status != duckdb_miniz::MZ_OK) {
-		throw InternalException("Failed to initialize miniz");
-	}
-
-	auto bytes_remaining = size - NumericCast<idx_t>(body_ptr - data);
-	mz_stream_ptr->next_in = const_uchar_ptr_cast(body_ptr);
-	mz_stream_ptr->avail_in = NumericCast<unsigned int>(bytes_remaining);
-
-	unsigned char decompress_buffer[BUFSIZ];
-	string decompressed;
-
-	while (status == duckdb_miniz::MZ_OK) {
-		mz_stream_ptr->next_out = decompress_buffer;
-		mz_stream_ptr->avail_out = sizeof(decompress_buffer);
-		status = mz_inflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
-		if (status != duckdb_miniz::MZ_STREAM_END && status != duckdb_miniz::MZ_OK) {
-			throw IOException("Failed to uncompress");
-		}
-		decompressed.append(char_ptr_cast(decompress_buffer), mz_stream_ptr->total_out - decompressed.size());
-	}
-	duckdb_miniz::mz_inflateEnd(mz_stream_ptr.get());
-
-	if (decompressed.empty()) {
-		throw IOException("Failed to uncompress");
-	}
-	return decompressed;
-}
-
-unique_ptr<FileHandle> GZipFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
-	auto path = handle->path;
-	return make_uniq<GZipFile>(std::move(handle), path, write);
-}
-
-unique_ptr<StreamWrapper> GZipFileSystem::CreateStream() {
-	return make_uniq<MiniZStreamWrapper>();
-}
-
-idx_t GZipFileSystem::InBufferSize() {
-	return BUFFER_SIZE;
-}
-
-idx_t GZipFileSystem::OutBufferSize() {
-	return BUFFER_SIZE;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/hive_partitioning.cpp b/src/duckdb/src/common/hive_partitioning.cpp
deleted file mode 100644
index c84d0505d..000000000
--- a/src/duckdb/src/common/hive_partitioning.cpp
+++ /dev/null
@@ -1,413 +0,0 @@
-#include "duckdb/common/hive_partitioning.hpp"
-
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/multi_file_list.hpp"
-
-namespace duckdb {
-
-struct PartitioningColumnValue {
-	explicit PartitioningColumnValue(string value_p) : value(std::move(value_p)) {
-	}
-	PartitioningColumnValue(string key_p, string value_p) : key(std::move(key_p)), value(std::move(value_p)) {
-	}
-
-	string key;
-	string value;
-};
-
-static unordered_map<column_t, PartitioningColumnValue>
-GetKnownColumnValues(const string &filename, const HivePartitioningFilterInfo &filter_info) {
-	unordered_map<column_t, PartitioningColumnValue> result;
-
-	auto &column_map = filter_info.column_map;
-	if (filter_info.filename_enabled) {
-		auto lookup_column_id = column_map.find("filename");
-		if (lookup_column_id != column_map.end()) {
-			result.insert(make_pair(lookup_column_id->second, PartitioningColumnValue(filename)));
-		}
-	}
-
-	if (filter_info.hive_enabled) {
-		auto partitions = HivePartitioning::Parse(filename);
-		for (auto &partition : partitions) {
-			auto lookup_column_id = column_map.find(partition.first);
-			if (lookup_column_id != column_map.end()) {
-				result.insert(
-				    make_pair(lookup_column_id->second, PartitioningColumnValue(partition.first, partition.second)));
-			}
-		}
-	}
-
-	return result;
-}
-
-// Takes an expression and converts a list of known column_refs to constants
-static void ConvertKnownColRefToConstants(ClientContext &context, unique_ptr<Expression> &expr,
-                                          const unordered_map<column_t, PartitioningColumnValue> &known_column_values,
-                                          idx_t table_index) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-
-		// This bound column ref is for another table
-		if (table_index != bound_colref.binding.table_index) {
-			return;
-		}
-
-		auto lookup = known_column_values.find(bound_colref.binding.column_index);
-		if (lookup != known_column_values.end()) {
-			auto &partition_val = lookup->second;
-			Value result_val;
-			if (partition_val.key.empty()) {
-				// filename column - use directly
-				result_val = Value(partition_val.value);
-			} else {
-				// hive partitioning column - cast the value to the target type
-				result_val = HivePartitioning::GetValue(context, partition_val.key, partition_val.value,
-				                                        bound_colref.return_type);
-			}
-			expr = make_uniq<BoundConstantExpression>(std::move(result_val));
-		}
-	} else {
-		ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-			ConvertKnownColRefToConstants(context, child, known_column_values, table_index);
-		});
-	}
-}
-
-string HivePartitioning::Escape(const string &input) {
-	return StringUtil::URLEncode(input);
-}
-
-string HivePartitioning::Unescape(const string &input) {
-	return StringUtil::URLDecode(input);
-}
-
-// matches hive partitions in file name. For example:
-// 	- s3://bucket/var1=value1/bla/bla/var2=value2
-//  - http(s)://domain(:port)/lala/kasdl/var1=value1/?not-a-var=not-a-value
-//  - folder/folder/folder/../var1=value1/etc/.//var2=value2
-std::map<string, string> HivePartitioning::Parse(const string &filename) {
-	idx_t partition_start = 0;
-	idx_t equality_sign = 0;
-	bool candidate_partition = true;
-	std::map<string, string> result;
-	for (idx_t c = 0; c < filename.size(); c++) {
-		if (filename[c] == '?' || filename[c] == '\n') {
-			// get parameter or newline - not a partition
-			candidate_partition = false;
-		}
-		if (filename[c] == '\\' || filename[c] == '/') {
-			// separator
-			if (candidate_partition && equality_sign > partition_start) {
-				// we found a partition with an equality sign
-				string key = filename.substr(partition_start, equality_sign - partition_start);
-				string value = filename.substr(equality_sign + 1, c - equality_sign - 1);
-				result.insert(make_pair(std::move(key), std::move(value)));
-			}
-			partition_start = c + 1;
-			candidate_partition = true;
-		} else if (filename[c] == '=') {
-			if (equality_sign > partition_start) {
-				// multiple equality signs - not a partition
-				candidate_partition = false;
-			}
-			equality_sign = c;
-		}
-	}
-	return result;
-}
-
-Value HivePartitioning::GetValue(ClientContext &context, const string &key, const string &str_val,
-                                 const LogicalType &type) {
-	// Handle nulls
-	if (StringUtil::CIEquals(str_val, "NULL")) {
-		return Value(type);
-	}
-	if (type.id() == LogicalTypeId::VARCHAR) {
-		// for string values we can directly return the type
-		return Value(Unescape(str_val));
-	}
-	if (str_val.empty()) {
-		// empty strings are NULL for non-string types
-		return Value(type);
-	}
-
-	// cast to the target type
-	Value value(Unescape(str_val));
-	if (!value.TryCastAs(context, type)) {
-		throw InvalidInputException("Unable to cast '%s' (from hive partition column '%s') to: '%s'", value.ToString(),
-		                            StringUtil::Upper(key), type.ToString());
-	}
-	return value;
-}
-
-// TODO: this can still be improved by removing the parts of filter expressions that are true for all remaining files.
-//		 currently, only expressions that cannot be evaluated during pushdown are removed.
-void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<string> &files,
-                                              vector<unique_ptr<Expression>> &filters,
-                                              const HivePartitioningFilterInfo &filter_info,
-                                              MultiFilePushdownInfo &info) {
-
-	vector<string> pruned_files;
-	vector<bool> have_preserved_filter(filters.size(), false);
-	vector<unique_ptr<Expression>> pruned_filters;
-	unordered_set<idx_t> filters_applied_to_files;
-	auto table_index = info.table_index;
-
-	if ((!filter_info.filename_enabled && !filter_info.hive_enabled) || filters.empty()) {
-		return;
-	}
-
-	for (idx_t i = 0; i < files.size(); i++) {
-		auto &file = files[i];
-		bool should_prune_file = false;
-		auto known_values = GetKnownColumnValues(file, filter_info);
-
-		for (idx_t j = 0; j < filters.size(); j++) {
-			auto &filter = filters[j];
-			unique_ptr<Expression> filter_copy = filter->Copy();
-			ConvertKnownColRefToConstants(context, filter_copy, known_values, table_index);
-			// Evaluate the filter, if it can be evaluated here, we can not prune this filter
-			Value result_value;
-
-			if (!filter_copy->IsScalar() || !filter_copy->IsFoldable() ||
-			    !ExpressionExecutor::TryEvaluateScalar(context, *filter_copy, result_value)) {
-				// can not be evaluated only with the filename/hive columns added, we can not prune this filter
-				if (!have_preserved_filter[j]) {
-					pruned_filters.emplace_back(filter->Copy());
-					have_preserved_filter[j] = true;
-				}
-			} else if (result_value.IsNull() || !result_value.GetValue<bool>()) {
-				// filter evaluates to false
-				should_prune_file = true;
-				// convert the filter to a table filter.
-				if (filters_applied_to_files.find(j) == filters_applied_to_files.end()) {
-					info.extra_info.file_filters += filter->ToString();
-					filters_applied_to_files.insert(j);
-				}
-			}
-		}
-
-		if (!should_prune_file) {
-			pruned_files.push_back(file);
-		}
-	}
-
-	D_ASSERT(filters.size() >= pruned_filters.size());
-
-	info.extra_info.total_files = files.size();
-	info.extra_info.filtered_files = pruned_files.size();
-
-	filters = std::move(pruned_filters);
-	files = std::move(pruned_files);
-}
-
-void HivePartitionedColumnData::InitializeKeys() {
-	keys.resize(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-		keys[i].values.resize(group_by_columns.size());
-	}
-}
-
-template <class T>
-static inline Value GetHiveKeyValue(const T &val) {
-	return Value::CreateValue<T>(val);
-}
-
-template <class T>
-static inline Value GetHiveKeyValue(const T &val, const LogicalType &type) {
-	auto result = GetHiveKeyValue(val);
-	result.Reinterpret(type);
-	return result;
-}
-
-static inline Value GetHiveKeyNullValue(const LogicalType &type) {
-	Value result;
-	result.Reinterpret(type);
-	return result;
-}
-
-template <class T>
-static void TemplatedGetHivePartitionValues(Vector &input, vector<HivePartitionKey> &keys, const idx_t col_idx,
-                                            const idx_t count) {
-	UnifiedVectorFormat format;
-	input.ToUnifiedFormat(count, format);
-
-	const auto &sel = *format.sel;
-	const auto data = UnifiedVectorFormat::GetData<T>(format);
-	const auto &validity = format.validity;
-
-	const auto &type = input.GetType();
-
-	const auto reinterpret = Value::CreateValue<T>(data[0]).GetTypeMutable() != type;
-	if (reinterpret) {
-		for (idx_t i = 0; i < count; i++) {
-			auto &key = keys[i];
-			const auto idx = sel.get_index(i);
-			if (validity.RowIsValid(idx)) {
-				key.values[col_idx] = GetHiveKeyValue(data[idx], type);
-			} else {
-				key.values[col_idx] = GetHiveKeyNullValue(type);
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto &key = keys[i];
-			const auto idx = sel.get_index(i);
-			if (validity.RowIsValid(idx)) {
-				key.values[col_idx] = GetHiveKeyValue(data[idx]);
-			} else {
-				key.values[col_idx] = GetHiveKeyNullValue(type);
-			}
-		}
-	}
-}
-
-static void GetNestedHivePartitionValues(Vector &input, vector<HivePartitionKey> &keys, const idx_t col_idx,
-                                         const idx_t count) {
-	for (idx_t i = 0; i < count; i++) {
-		auto &key = keys[i];
-		key.values[col_idx] = input.GetValue(i);
-	}
-}
-
-static void GetHivePartitionValuesTypeSwitch(Vector &input, vector<HivePartitionKey> &keys, const idx_t col_idx,
-                                             const idx_t count) {
-	const auto &type = input.GetType();
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		TemplatedGetHivePartitionValues<bool>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::INT8:
-		TemplatedGetHivePartitionValues<int8_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGetHivePartitionValues<int16_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGetHivePartitionValues<int32_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGetHivePartitionValues<int64_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedGetHivePartitionValues<hugeint_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedGetHivePartitionValues<uint8_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedGetHivePartitionValues<uint16_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedGetHivePartitionValues<uint32_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedGetHivePartitionValues<uint64_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedGetHivePartitionValues<uhugeint_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGetHivePartitionValues<float>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGetHivePartitionValues<double>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedGetHivePartitionValues<interval_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedGetHivePartitionValues<string_t>(input, keys, col_idx, count);
-		break;
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-		GetNestedHivePartitionValues(input, keys, col_idx, count);
-		break;
-	default:
-		throw InternalException("Unsupported type for HivePartitionedColumnData::ComputePartitionIndices");
-	}
-}
-
-void HivePartitionedColumnData::ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) {
-	const auto count = input.size();
-
-	input.Hash(group_by_columns, hashes_v);
-	hashes_v.Flatten(count);
-
-	for (idx_t col_idx = 0; col_idx < group_by_columns.size(); col_idx++) {
-		auto &group_by_col = input.data[group_by_columns[col_idx]];
-		GetHivePartitionValuesTypeSwitch(group_by_col, keys, col_idx, count);
-	}
-
-	const auto hashes = FlatVector::GetData<hash_t>(hashes_v);
-	const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
-	for (idx_t i = 0; i < count; i++) {
-		auto &key = keys[i];
-		key.hash = hashes[i];
-		auto lookup = local_partition_map.find(key);
-		if (lookup == local_partition_map.end()) {
-			idx_t new_partition_id = RegisterNewPartition(key, state);
-			partition_indices[i] = new_partition_id;
-		} else {
-			partition_indices[i] = lookup->second;
-		}
-	}
-}
-
-std::map<idx_t, const HivePartitionKey *> HivePartitionedColumnData::GetReverseMap() {
-	std::map<idx_t, const HivePartitionKey *> ret;
-	for (const auto &pair : local_partition_map) {
-		ret[pair.second] = &(pair.first);
-	}
-	return ret;
-}
-
-HivePartitionedColumnData::HivePartitionedColumnData(ClientContext &context, vector<LogicalType> types,
-                                                     vector<idx_t> partition_by_cols,
-                                                     shared_ptr<GlobalHivePartitionState> global_state)
-    : PartitionedColumnData(PartitionedColumnDataType::HIVE, context, std::move(types)),
-      global_state(std::move(global_state)), group_by_columns(std::move(partition_by_cols)),
-      hashes_v(LogicalType::HASH) {
-	InitializeKeys();
-	CreateAllocator();
-}
-
-void HivePartitionedColumnData::AddNewPartition(HivePartitionKey key, idx_t partition_id,
-                                                PartitionedColumnDataAppendState &state) {
-	local_partition_map.emplace(std::move(key), partition_id);
-
-	if (state.partition_append_states.size() <= partition_id) {
-		state.partition_append_states.resize(partition_id + 1);
-		state.partition_buffers.resize(partition_id + 1);
-		partitions.resize(partition_id + 1);
-	}
-	state.partition_append_states[partition_id] = make_uniq<ColumnDataAppendState>();
-	state.partition_buffers[partition_id] = CreatePartitionBuffer();
-	partitions[partition_id] = CreatePartitionCollection(0);
-	partitions[partition_id]->InitializeAppend(*state.partition_append_states[partition_id]);
-}
-
-idx_t HivePartitionedColumnData::RegisterNewPartition(HivePartitionKey key, PartitionedColumnDataAppendState &state) {
-	idx_t partition_id;
-	if (global_state) {
-		// Synchronize Global state with our local state with the newly discovered partition
-		unique_lock<mutex> lck_gstate(global_state->lock);
-
-		// Insert into global map, or return partition if already present
-		auto res = global_state->partition_map.emplace(std::make_pair(key, global_state->partition_map.size()));
-		partition_id = res.first->second;
-	} else {
-		partition_id = local_partition_map.size();
-	}
-	AddNewPartition(std::move(key), partition_id, state);
-	return partition_id;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/http_util.cpp b/src/duckdb/src/common/http_util.cpp
deleted file mode 100644
index 71248367e..000000000
--- a/src/duckdb/src/common/http_util.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/common/http_util.hpp"
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-void HTTPUtil::ParseHTTPProxyHost(string &proxy_value, string &hostname_out, idx_t &port_out, idx_t default_port) {
-	auto sanitized_proxy_value = proxy_value;
-	if (StringUtil::StartsWith(proxy_value, "http://")) {
-		sanitized_proxy_value = proxy_value.substr(7);
-	}
-	auto proxy_split = StringUtil::Split(sanitized_proxy_value, ":");
-	if (proxy_split.size() == 1) {
-		hostname_out = proxy_split[0];
-		port_out = default_port;
-	} else if (proxy_split.size() == 2) {
-		idx_t port;
-		if (!TryCast::Operation<string_t, idx_t>(proxy_split[1], port, false)) {
-			throw InvalidInputException("Failed to parse port from http_proxy '%s'", proxy_value);
-		}
-		hostname_out = proxy_split[0];
-		port_out = port;
-	} else {
-		throw InvalidInputException("Failed to parse http_proxy '%s' into a host and port", proxy_value);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/local_file_system.cpp b/src/duckdb/src/common/local_file_system.cpp
deleted file mode 100644
index 83e242526..000000000
--- a/src/duckdb/src/common/local_file_system.cpp
+++ /dev/null
@@ -1,1451 +0,0 @@
-#include "duckdb/common/local_file_system.hpp"
-
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/windows.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-
-#include <cstdint>
-#include <cstdio>
-#include <sys/stat.h>
-
-#ifndef _WIN32
-#include <dirent.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-#else
-#include "duckdb/common/windows_util.hpp"
-
-#include <io.h>
-#include <string>
-
-#ifdef __MINGW32__
-// need to manually define this for mingw
-extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG);
-extern "C" WINBASEAPI BOOL QueryFullProcessImageNameW(HANDLE, DWORD, LPWSTR, PDWORD);
-#endif
-
-#undef FILE_CREATE // woo mingw
-#endif
-
-// includes for giving a better error message on lock conflicts
-#if defined(__linux__) || defined(__APPLE__)
-#include <pwd.h>
-#endif
-
-#if defined(__linux__)
-// See https://man7.org/linux/man-pages/man2/fallocate.2.html
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE /* See feature_test_macros(7) */
-#endif
-#include <fcntl.h>
-#include <libgen.h>
-// See e.g.:
-// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
-#elif defined(__APPLE__)
-#include <TargetConditionals.h>
-#if not(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
-#include <libproc.h>
-#endif
-#elif defined(_WIN32)
-#include <restartmanager.h>
-#endif
-
-namespace duckdb {
-#ifndef _WIN32
-bool LocalFileSystem::FileExists(const string &filename, optional_ptr<FileOpener> opener) {
-	if (!filename.empty()) {
-		auto normalized_file = NormalizeLocalPath(filename);
-		if (access(normalized_file, 0) == 0) {
-			struct stat status;
-			stat(normalized_file, &status);
-			if (S_ISREG(status.st_mode)) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
-bool LocalFileSystem::IsPipe(const string &filename, optional_ptr<FileOpener> opener) {
-	if (!filename.empty()) {
-		auto normalized_file = NormalizeLocalPath(filename);
-		if (access(normalized_file, 0) == 0) {
-			struct stat status;
-			stat(normalized_file, &status);
-			if (S_ISFIFO(status.st_mode)) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
-#else
-static std::wstring NormalizePathAndConvertToUnicode(const string &path) {
-	string normalized_path_copy;
-	const char *normalized_path;
-	if (StringUtil::StartsWith(path, "file:/")) {
-		normalized_path_copy = LocalFileSystem::NormalizeLocalPath(path);
-		normalized_path_copy = LocalFileSystem().ConvertSeparators(normalized_path_copy);
-		normalized_path = normalized_path_copy.c_str();
-	} else {
-		normalized_path = path.c_str();
-	}
-	return WindowsUtil::UTF8ToUnicode(normalized_path);
-}
-
-bool LocalFileSystem::FileExists(const string &filename, optional_ptr<FileOpener> opener) {
-	auto unicode_path = NormalizePathAndConvertToUnicode(filename);
-	const wchar_t *wpath = unicode_path.c_str();
-	if (_waccess(wpath, 0) == 0) {
-		struct _stati64 status;
-		_wstati64(wpath, &status);
-		if (status.st_mode & S_IFREG) {
-			return true;
-		}
-	}
-	return false;
-}
-bool LocalFileSystem::IsPipe(const string &filename, optional_ptr<FileOpener> opener) {
-	auto unicode_path = NormalizePathAndConvertToUnicode(filename);
-	const wchar_t *wpath = unicode_path.c_str();
-	if (_waccess(wpath, 0) == 0) {
-		struct _stati64 status;
-		_wstati64(wpath, &status);
-		if (status.st_mode & _S_IFCHR) {
-			return true;
-		}
-	}
-	return false;
-}
-#endif
-
-#ifndef _WIN32
-// somehow sometimes this is missing
-#ifndef O_CLOEXEC
-#define O_CLOEXEC 0
-#endif
-
-// Solaris
-#ifndef O_DIRECT
-#define O_DIRECT 0
-#endif
-
-struct UnixFileHandle : public FileHandle {
-public:
-	UnixFileHandle(FileSystem &file_system, string path, int fd, FileOpenFlags flags)
-	    : FileHandle(file_system, std::move(path), flags), fd(fd) {
-	}
-	~UnixFileHandle() override {
-		UnixFileHandle::Close();
-	}
-
-	int fd;
-
-public:
-	void Close() override {
-		if (fd != -1) {
-			close(fd);
-			fd = -1;
-		}
-	};
-};
-
-static FileType GetFileTypeInternal(int fd) { // LCOV_EXCL_START
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		return FileType::FILE_TYPE_INVALID;
-	}
-	switch (s.st_mode & S_IFMT) {
-	case S_IFBLK:
-		return FileType::FILE_TYPE_BLOCKDEV;
-	case S_IFCHR:
-		return FileType::FILE_TYPE_CHARDEV;
-	case S_IFIFO:
-		return FileType::FILE_TYPE_FIFO;
-	case S_IFDIR:
-		return FileType::FILE_TYPE_DIR;
-	case S_IFLNK:
-		return FileType::FILE_TYPE_LINK;
-	case S_IFREG:
-		return FileType::FILE_TYPE_REGULAR;
-	case S_IFSOCK:
-		return FileType::FILE_TYPE_SOCKET;
-	default:
-		return FileType::FILE_TYPE_INVALID;
-	}
-} // LCOV_EXCL_STOP
-
-#if __APPLE__ && !TARGET_OS_IPHONE
-
-static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) {
-	if (pid == getpid()) {
-		return "Lock is already held in current process, likely another DuckDB instance";
-	}
-
-	string process_name, process_owner;
-	// macOS >= 10.7 has PROC_PIDT_SHORTBSDINFO
-#ifdef PROC_PIDT_SHORTBSDINFO
-	// try to find out more about the process holding the lock
-	struct proc_bsdshortinfo proc;
-	if (proc_pidinfo(pid, PROC_PIDT_SHORTBSDINFO, 0, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) ==
-	    PROC_PIDT_SHORTBSDINFO_SIZE) {
-		process_name = proc.pbsi_comm; // only a short version however, let's take it in case proc_pidpath() below fails
-		// try to get actual name of conflicting process owner
-		auto pw = getpwuid(proc.pbsi_uid);
-		if (pw) {
-			process_owner = pw->pw_name;
-		}
-	}
-#else
-	return string();
-#endif
-	// try to get a better process name (full path)
-	char full_exec_path[PROC_PIDPATHINFO_MAXSIZE];
-	if (proc_pidpath(pid, full_exec_path, PROC_PIDPATHINFO_MAXSIZE) > 0) {
-		// somehow could not get the path, lets use some sensible fallback
-		process_name = full_exec_path;
-	}
-	return StringUtil::Format("Conflicting lock is held in %s%s",
-	                          !process_name.empty() ? StringUtil::Format("%s (PID %d)", process_name, pid)
-	                                                : StringUtil::Format("PID %d", pid),
-	                          !process_owner.empty() ? StringUtil::Format(" by user %s", process_owner) : "");
-}
-
-#elif __linux__
-
-static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) {
-	if (pid == getpid()) {
-		return "Lock is already held in current process, likely another DuckDB instance";
-	}
-	string process_name, process_owner;
-
-	try {
-		auto cmdline_file = fs.OpenFile(StringUtil::Format("/proc/%d/cmdline", pid), FileFlags::FILE_FLAGS_READ);
-		auto cmdline = cmdline_file->ReadLine();
-		process_name = basename(const_cast<char *>(cmdline.c_str())); // NOLINT: old C API does not take const
-	} catch (std::exception &) {
-		// ignore
-	}
-
-	// we would like to provide a full path to the executable if possible but we might not have rights
-	{
-		char exe_target[PATH_MAX];
-		memset(exe_target, '\0', PATH_MAX);
-		auto proc_exe_link = StringUtil::Format("/proc/%d/exe", pid);
-		auto readlink_n = readlink(proc_exe_link.c_str(), exe_target, PATH_MAX);
-		if (readlink_n > 0) {
-			process_name = exe_target;
-		}
-	}
-
-	// try to find out who created that process
-	try {
-		auto loginuid_file = fs.OpenFile(StringUtil::Format("/proc/%d/loginuid", pid), FileFlags::FILE_FLAGS_READ);
-		auto uid = std::stoi(loginuid_file->ReadLine());
-		auto pw = getpwuid(uid);
-		if (pw) {
-			process_owner = pw->pw_name;
-		}
-	} catch (std::exception &) {
-		// ignore
-	}
-
-	return StringUtil::Format("Conflicting lock is held in %s%s",
-	                          !process_name.empty() ? StringUtil::Format("%s (PID %d)", process_name, pid)
-	                                                : StringUtil::Format("PID %d", pid),
-	                          !process_owner.empty() ? StringUtil::Format(" by user %s", process_owner) : "");
-}
-
-#else
-static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) {
-	return "";
-}
-#endif
-
-bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) {
-	auto path = FileSystem::ExpandPath(path_p, opener);
-	auto normalized_path = NormalizeLocalPath(path);
-
-	struct stat st;
-
-	if (lstat(normalized_path, &st) != 0) {
-		throw IOException(
-		    "Failed to stat '%s' when checking file permissions, file may be missing or have incorrect permissions",
-		    path.c_str());
-	}
-
-	// If group or other have any permission, the file is not private
-	if (st.st_mode & (S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH)) {
-		return false;
-	}
-
-	return true;
-}
-
-unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, FileOpenFlags flags,
-                                                 optional_ptr<FileOpener> opener) {
-	auto path = FileSystem::ExpandPath(path_p, opener);
-	auto normalized_path = NormalizeLocalPath(path);
-	if (flags.Compression() != FileCompressionType::UNCOMPRESSED) {
-		throw NotImplementedException("Unsupported compression type for default file system");
-	}
-
-	flags.Verify();
-
-	int open_flags = 0;
-	int rc;
-	bool open_read = flags.OpenForReading();
-	bool open_write = flags.OpenForWriting();
-	if (open_read && open_write) {
-		open_flags = O_RDWR;
-	} else if (open_read) {
-		open_flags = O_RDONLY;
-	} else if (open_write) {
-		open_flags = O_WRONLY;
-	} else {
-		throw InternalException("READ, WRITE or both should be specified when opening a file");
-	}
-	if (open_write) {
-		// need Read or Write
-		D_ASSERT(flags.OpenForWriting());
-		open_flags |= O_CLOEXEC;
-		if (flags.CreateFileIfNotExists()) {
-			open_flags |= O_CREAT;
-		} else if (flags.OverwriteExistingFile()) {
-			open_flags |= O_CREAT | O_TRUNC;
-		}
-		if (flags.OpenForAppending()) {
-			open_flags |= O_APPEND;
-		}
-	}
-	if (flags.DirectIO()) {
-#if defined(__sun) && defined(__SVR4)
-		throw InvalidInputException("DIRECT_IO not supported on Solaris");
-#endif
-#if defined(__DARWIN__) || defined(__APPLE__) || defined(__OpenBSD__)
-		// OSX does not have O_DIRECT, instead we need to use fcntl afterwards to support direct IO
-#else
-		open_flags |= O_DIRECT;
-#endif
-	}
-
-	// Determine permissions
-	mode_t filesec;
-	if (flags.CreatePrivateFile()) {
-		open_flags |= O_EXCL; // Ensure we error on existing files or the permissions may not set
-		filesec = 0600;
-	} else {
-		filesec = 0666;
-	}
-
-	if (flags.ExclusiveCreate()) {
-		open_flags |= O_EXCL;
-	}
-
-	// Open the file
-	int fd = open(normalized_path, open_flags, filesec);
-
-	if (fd == -1) {
-		if (flags.ReturnNullIfNotExists() && errno == ENOENT) {
-			return nullptr;
-		}
-		if (flags.ReturnNullIfExists() && errno == EEXIST) {
-			return nullptr;
-		}
-		throw IOException("Cannot open file \"%s\": %s", {{"errno", std::to_string(errno)}}, path, strerror(errno));
-	}
-
-#if defined(__DARWIN__) || defined(__APPLE__)
-	if (flags.DirectIO()) {
-		// OSX requires fcntl for Direct IO
-		rc = fcntl(fd, F_NOCACHE, 1);
-		if (rc == -1) {
-			throw IOException("Could not enable direct IO for file \"%s\": %s", path, strerror(errno));
-		}
-	}
-#endif
-
-	if (flags.Lock() != FileLockType::NO_LOCK) {
-		// set lock on file
-		// but only if it is not an input/output stream
-		auto file_type = GetFileTypeInternal(fd);
-		if (file_type != FileType::FILE_TYPE_FIFO && file_type != FileType::FILE_TYPE_SOCKET) {
-			struct flock fl;
-			memset(&fl, 0, sizeof fl);
-			fl.l_type = flags.Lock() == FileLockType::READ_LOCK ? F_RDLCK : F_WRLCK;
-			fl.l_whence = SEEK_SET;
-			fl.l_start = 0;
-			fl.l_len = 0;
-			rc = fcntl(fd, F_SETLK, &fl);
-			// Retain the original error.
-			int retained_errno = errno;
-			bool has_error = rc == -1;
-			string extended_error;
-			if (has_error) {
-				if (retained_errno == ENOTSUP) {
-					// file lock not supported for this file system
-					if (flags.Lock() == FileLockType::READ_LOCK) {
-						// for read-only, we ignore not-supported errors
-						has_error = false;
-						errno = 0;
-					} else {
-						extended_error = "File locks are not supported for this file system, cannot open the file in "
-						                 "read-write mode. Try opening the file in read-only mode";
-					}
-				}
-			}
-			if (has_error) {
-				if (extended_error.empty()) {
-					// try to find out who is holding the lock using F_GETLK
-					rc = fcntl(fd, F_GETLK, &fl);
-					if (rc == -1) { // fnctl does not want to help us
-						extended_error = strerror(errno);
-					} else {
-						extended_error = AdditionalProcessInfo(*this, fl.l_pid);
-					}
-					if (flags.Lock() == FileLockType::WRITE_LOCK) {
-						// maybe we can get a read lock instead and tell this to the user.
-						fl.l_type = F_RDLCK;
-						rc = fcntl(fd, F_SETLK, &fl);
-						if (rc != -1) { // success!
-							extended_error +=
-							    ". However, you would be able to open this database in read-only mode, e.g. by "
-							    "using the -readonly parameter in the CLI";
-						}
-					}
-				}
-				rc = close(fd);
-				if (rc == -1) {
-					extended_error += ". Also, failed closing file";
-				}
-				extended_error += ". See also https://duckdb.org/docs/connect/concurrency";
-				throw IOException("Could not set lock on file \"%s\": %s", {{"errno", std::to_string(retained_errno)}},
-				                  path, extended_error);
-			}
-		}
-	}
-	return make_uniq<UnixFileHandle>(*this, path, fd, flags);
-}
-
-void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	off_t offset = lseek(fd, UnsafeNumericCast<off_t>(location), SEEK_SET);
-	if (offset == (off_t)-1) {
-		throw IOException("Could not seek to location %lld for file \"%s\": %s", {{"errno", std::to_string(errno)}},
-		                  location, handle.path, strerror(errno));
-	}
-}
-
-idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	off_t position = lseek(fd, 0, SEEK_CUR);
-	if (position == (off_t)-1) {
-		throw IOException("Could not get file position file \"%s\": %s", {{"errno", std::to_string(errno)}},
-		                  handle.path, strerror(errno));
-	}
-	return UnsafeNumericCast<idx_t>(position);
-}
-
-void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	auto read_buffer = char_ptr_cast(buffer);
-	while (nr_bytes > 0) {
-		int64_t bytes_read =
-		    pread(fd, read_buffer, UnsafeNumericCast<size_t>(nr_bytes), UnsafeNumericCast<off_t>(location));
-		if (bytes_read == -1) {
-			throw IOException("Could not read from file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
-			                  strerror(errno));
-		}
-		if (bytes_read == 0) {
-			throw IOException(
-			    "Could not read enough bytes from file \"%s\": attempted to read %llu bytes from location %llu",
-			    handle.path, nr_bytes, location);
-		}
-		read_buffer += bytes_read;
-		nr_bytes -= bytes_read;
-		location += UnsafeNumericCast<idx_t>(bytes_read);
-	}
-}
-
-int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	int64_t bytes_read = read(fd, buffer, UnsafeNumericCast<size_t>(nr_bytes));
-	if (bytes_read == -1) {
-		throw IOException("Could not read from file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
-		                  strerror(errno));
-	}
-	return bytes_read;
-}
-
-void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	auto write_buffer = char_ptr_cast(buffer);
-	while (nr_bytes > 0) {
-		int64_t bytes_written =
-		    pwrite(fd, write_buffer, UnsafeNumericCast<size_t>(nr_bytes), UnsafeNumericCast<off_t>(location));
-		if (bytes_written < 0) {
-			throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
-			                  strerror(errno));
-		}
-		if (bytes_written == 0) {
-			throw IOException("Could not write to file \"%s\" - attempted to write 0 bytes: %s",
-			                  {{"errno", std::to_string(errno)}}, handle.path, strerror(errno));
-		}
-		write_buffer += bytes_written;
-		nr_bytes -= bytes_written;
-		location += UnsafeNumericCast<idx_t>(bytes_written);
-	}
-}
-
-int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	int64_t bytes_written = 0;
-	while (nr_bytes > 0) {
-		auto bytes_to_write = MinValue<idx_t>(idx_t(NumericLimits<int32_t>::Maximum()), idx_t(nr_bytes));
-		int64_t current_bytes_written = write(fd, buffer, bytes_to_write);
-		if (current_bytes_written <= 0) {
-			throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
-			                  strerror(errno));
-		}
-		bytes_written += current_bytes_written;
-		buffer = (void *)(data_ptr_cast(buffer) + current_bytes_written);
-		nr_bytes -= current_bytes_written;
-	}
-	return bytes_written;
-}
-
-bool LocalFileSystem::Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) {
-#if defined(__linux__)
-	// FALLOC_FL_PUNCH_HOLE requires glibc 2.18 or up
-#if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 18)
-	return false;
-#else
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	int res = fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, UnsafeNumericCast<int64_t>(offset_bytes),
-	                    UnsafeNumericCast<int64_t>(length_bytes));
-	return res == 0;
-#endif
-#else
-	return false;
-#endif
-}
-
-int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		throw IOException("Failed to get file size for file \"%s\": %s", {{"errno", std::to_string(errno)}},
-		                  handle.path, strerror(errno));
-	}
-	return s.st_size;
-}
-
-time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		throw IOException("Failed to get last modified time for file \"%s\": %s", {{"errno", std::to_string(errno)}},
-		                  handle.path, strerror(errno));
-	}
-	return s.st_mtime;
-}
-
-FileType LocalFileSystem::GetFileType(FileHandle &handle) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	return GetFileTypeInternal(fd);
-}
-
-void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	if (ftruncate(fd, new_size) != 0) {
-		throw IOException("Could not truncate file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
-		                  strerror(errno));
-	}
-}
-
-bool LocalFileSystem::DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) {
-	if (!directory.empty()) {
-		auto normalized_dir = NormalizeLocalPath(directory);
-		if (access(normalized_dir, 0) == 0) {
-			struct stat status;
-			stat(normalized_dir, &status);
-			if (status.st_mode & S_IFDIR) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
-void LocalFileSystem::CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	struct stat st;
-
-	auto normalized_dir = NormalizeLocalPath(directory);
-	if (stat(normalized_dir, &st) != 0) {
-		/* Directory does not exist. EEXIST for race condition */
-		if (mkdir(normalized_dir, 0755) != 0 && errno != EEXIST) {
-			throw IOException("Failed to create directory \"%s\": %s", {{"errno", std::to_string(errno)}}, directory,
-			                  strerror(errno));
-		}
-	} else if (!S_ISDIR(st.st_mode)) {
-		throw IOException("Failed to create directory \"%s\": path exists but is not a directory!",
-		                  {{"errno", std::to_string(errno)}}, directory);
-	}
-}
-
-int RemoveDirectoryRecursive(const char *path) {
-	DIR *d = opendir(path);
-	idx_t path_len = (idx_t)strlen(path);
-	int r = -1;
-
-	if (d) {
-		struct dirent *p;
-		r = 0;
-		while (!r && (p = readdir(d))) {
-			int r2 = -1;
-			char *buf;
-			idx_t len;
-			/* Skip the names "." and ".." as we don't want to recurse on them. */
-			if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, "..")) {
-				continue;
-			}
-			len = path_len + (idx_t)strlen(p->d_name) + 2;
-			buf = new (std::nothrow) char[len];
-			if (buf) {
-				struct stat statbuf;
-				snprintf(buf, len, "%s/%s", path, p->d_name);
-				if (!stat(buf, &statbuf)) {
-					if (S_ISDIR(statbuf.st_mode)) {
-						r2 = RemoveDirectoryRecursive(buf);
-					} else {
-						r2 = unlink(buf);
-					}
-				}
-				delete[] buf;
-			}
-			r = r2;
-		}
-		closedir(d);
-	}
-	if (!r) {
-		r = rmdir(path);
-	}
-	return r;
-}
-
-void LocalFileSystem::RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	auto normalized_dir = NormalizeLocalPath(directory);
-	RemoveDirectoryRecursive(normalized_dir);
-}
-
-void LocalFileSystem::RemoveFile(const string &filename, optional_ptr<FileOpener> opener) {
-	auto normalized_file = NormalizeLocalPath(filename);
-	if (std::remove(normalized_file) != 0) {
-		throw IOException("Could not remove file \"%s\": %s", {{"errno", std::to_string(errno)}}, filename,
-		                  strerror(errno));
-	}
-}
-
-bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-                                FileOpener *opener) {
-	auto normalized_dir = NormalizeLocalPath(directory);
-	auto dir = opendir(normalized_dir);
-	if (!dir) {
-		return false;
-	}
-
-	// RAII wrapper around DIR to automatically free on exceptions in callback
-	std::unique_ptr<DIR, std::function<void(DIR *)>> dir_unique_ptr(dir, [](DIR *d) { closedir(d); });
-
-	struct dirent *ent;
-	// loop over all files in the directory
-	while ((ent = readdir(dir)) != nullptr) {
-		string name = string(ent->d_name);
-		// skip . .. and empty files
-		if (name.empty() || name == "." || name == "..") {
-			continue;
-		}
-		// now stat the file to figure out if it is a regular file or directory
-		string full_path = JoinPath(normalized_dir, name);
-		struct stat status;
-		auto res = stat(full_path.c_str(), &status);
-		if (res != 0) {
-			continue;
-		}
-		if (!(status.st_mode & S_IFREG) && !(status.st_mode & S_IFDIR)) {
-			// not a file or directory: skip
-			continue;
-		}
-		// invoke callback
-		callback(name, status.st_mode & S_IFDIR);
-	}
-
-	return true;
-}
-
-void LocalFileSystem::FileSync(FileHandle &handle) {
-	int fd = handle.Cast<UnixFileHandle>().fd;
-	if (fsync(fd) != 0) {
-		throw FatalException("fsync failed!");
-	}
-}
-
-void LocalFileSystem::MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) {
-	auto normalized_source = NormalizeLocalPath(source);
-	auto normalized_target = NormalizeLocalPath(target);
-	//! FIXME: rename does not guarantee atomicity or overwriting target file if it exists
-	if (rename(normalized_source, normalized_target) != 0) {
-		throw IOException("Could not rename file!", {{"errno", std::to_string(errno)}});
-	}
-}
-
-std::string LocalFileSystem::GetLastErrorAsString() {
-	return string();
-}
-
-#else
-
-constexpr char PIPE_PREFIX[] = "\\\\.\\pipe\\";
-
-// Returns the last Win32 error, in string format. Returns an empty string if there is no error.
-std::string LocalFileSystem::GetLastErrorAsString() {
-	// Get the error message, if any.
-	DWORD errorMessageID = GetLastError();
-	if (errorMessageID == 0)
-		return std::string(); // No error message has been recorded
-
-	LPSTR messageBuffer = nullptr;
-	idx_t size =
-	    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-	                   NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
-
-	std::string message(messageBuffer, size);
-
-	// Free the buffer.
-	LocalFree(messageBuffer);
-
-	return message;
-}
-
-struct WindowsFileHandle : public FileHandle {
-public:
-	WindowsFileHandle(FileSystem &file_system, string path, HANDLE fd, FileOpenFlags flags)
-	    : FileHandle(file_system, path, flags), position(0), fd(fd) {
-	}
-	~WindowsFileHandle() override {
-		Close();
-	}
-
-	idx_t position;
-	HANDLE fd;
-
-public:
-	void Close() override {
-		if (!fd) {
-			return;
-		}
-		CloseHandle(fd);
-		fd = nullptr;
-	};
-};
-
-static string AdditionalLockInfo(const std::wstring path) {
-	// try to find out if another process is holding the lock
-
-	// init of the somewhat obscure "Windows Restart Manager"
-	// see also https://devblogs.microsoft.com/oldnewthing/20120217-00/?p=8283
-
-	DWORD session, status, reason;
-	WCHAR session_key[CCH_RM_SESSION_KEY + 1] = {0};
-
-	status = RmStartSession(&session, 0, session_key);
-	if (status != ERROR_SUCCESS) {
-		return "";
-	}
-
-	PCWSTR path_ptr = path.c_str();
-	status = RmRegisterResources(session, 1, &path_ptr, 0, NULL, 0, NULL);
-	if (status != ERROR_SUCCESS) {
-		return "";
-	}
-	UINT process_info_size_needed, process_info_size;
-
-	// we first call with nProcInfo = 0 to find out how much to allocate
-	process_info_size = 0;
-	status = RmGetList(session, &process_info_size_needed, &process_info_size, NULL, &reason);
-	if (status != ERROR_MORE_DATA || process_info_size_needed == 0) {
-		return "";
-	}
-
-	// allocate
-	auto process_info_buffer = duckdb::unique_ptr<RM_PROCESS_INFO[]>(new RM_PROCESS_INFO[process_info_size_needed]);
-	auto process_info = process_info_buffer.get();
-
-	// now call again to get actual data
-	process_info_size = process_info_size_needed;
-	status = RmGetList(session, &process_info_size_needed, &process_info_size, process_info, &reason);
-	if (status != ERROR_SUCCESS || process_info_size == 0) {
-		return "";
-	}
-
-	string conflict_string = "File is already open in ";
-
-	for (UINT process_idx = 0; process_idx < process_info_size; process_idx++) {
-		string process_name = WindowsUtil::UnicodeToUTF8(process_info[process_idx].strAppName);
-		auto pid = process_info[process_idx].Process.dwProcessId;
-
-		// find out full path if possible
-		HANDLE process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
-		if (process) {
-			WCHAR full_path[MAX_PATH];
-			DWORD full_path_size = MAX_PATH;
-			if (QueryFullProcessImageNameW(process, 0, full_path, &full_path_size) && full_path_size <= MAX_PATH) {
-				process_name = WindowsUtil::UnicodeToUTF8(full_path);
-			}
-			CloseHandle(process);
-		}
-		conflict_string += StringUtil::Format("\n%s (PID %d)", process_name, pid);
-	}
-
-	RmEndSession(session);
-	return conflict_string;
-}
-
-bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) {
-	// TODO: detect if file is shared in windows
-	return true;
-}
-
-unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, FileOpenFlags flags,
-                                                 optional_ptr<FileOpener> opener) {
-	auto path = FileSystem::ExpandPath(path_p, opener);
-	auto unicode_path = NormalizePathAndConvertToUnicode(path);
-	if (flags.Compression() != FileCompressionType::UNCOMPRESSED) {
-		throw NotImplementedException("Unsupported compression type for default file system");
-	}
-	flags.Verify();
-
-	DWORD desired_access;
-	DWORD share_mode;
-	DWORD creation_disposition = OPEN_EXISTING;
-	DWORD flags_and_attributes = FILE_ATTRIBUTE_NORMAL;
-	bool open_read = flags.OpenForReading();
-	bool open_write = flags.OpenForWriting();
-	if (open_read && open_write) {
-		desired_access = GENERIC_READ | GENERIC_WRITE;
-		share_mode = 0;
-	} else if (open_read) {
-		desired_access = GENERIC_READ;
-		share_mode = FILE_SHARE_READ;
-	} else if (open_write) {
-		desired_access = GENERIC_WRITE;
-		share_mode = 0;
-	} else {
-		throw InternalException("READ, WRITE or both should be specified when opening a file");
-	}
-	if (open_write) {
-		if (flags.CreateFileIfNotExists()) {
-			creation_disposition = OPEN_ALWAYS;
-		} else if (flags.OverwriteExistingFile()) {
-			creation_disposition = CREATE_ALWAYS;
-		}
-	}
-	if (flags.DirectIO()) {
-		flags_and_attributes |= FILE_FLAG_NO_BUFFERING;
-	}
-	HANDLE hFile = CreateFileW(unicode_path.c_str(), desired_access, share_mode, NULL, creation_disposition,
-	                           flags_and_attributes, NULL);
-	if (hFile == INVALID_HANDLE_VALUE) {
-		if (flags.ReturnNullIfNotExists() && GetLastError() == ERROR_FILE_NOT_FOUND) {
-			return nullptr;
-		}
-		auto error = LocalFileSystem::GetLastErrorAsString();
-
-		auto better_error = AdditionalLockInfo(unicode_path);
-		if (!better_error.empty()) {
-			throw IOException(better_error);
-		} else {
-			throw IOException("Cannot open file \"%s\": %s", path.c_str(), error);
-		}
-	}
-	auto handle = make_uniq<WindowsFileHandle>(*this, path.c_str(), hFile, flags);
-	if (flags.OpenForAppending()) {
-		auto file_size = GetFileSize(*handle);
-		SetFilePointer(*handle, file_size);
-	}
-	return std::move(handle);
-}
-
-void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
-	auto &whandle = handle.Cast<WindowsFileHandle>();
-	whandle.position = location;
-	LARGE_INTEGER wlocation;
-	wlocation.QuadPart = location;
-	SetFilePointerEx(whandle.fd, wlocation, NULL, FILE_BEGIN);
-}
-
-idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
-	return handle.Cast<WindowsFileHandle>().position;
-}
-
-static DWORD FSInternalRead(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
-	DWORD bytes_read = 0;
-	OVERLAPPED ov = {};
-	ov.Internal = 0;
-	ov.InternalHigh = 0;
-	ov.Offset = location & 0xFFFFFFFF;
-	ov.OffsetHigh = location >> 32;
-	ov.hEvent = 0;
-	auto rc = ReadFile(hFile, buffer, (DWORD)nr_bytes, &bytes_read, &ov);
-	if (!rc) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Could not read file \"%s\" (error in ReadFile(location: %llu, nr_bytes: %lld)): %s",
-		                  handle.path, location, nr_bytes, error);
-	}
-	return bytes_read;
-}
-
-void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	auto bytes_read = FSInternalRead(handle, hFile, buffer, nr_bytes, location);
-	if (bytes_read != nr_bytes) {
-		throw IOException("Could not read all bytes from file \"%s\": wanted=%lld read=%lld", handle.path, nr_bytes,
-		                  bytes_read);
-	}
-}
-
-int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-	auto &pos = handle.Cast<WindowsFileHandle>().position;
-	auto n = std::min<idx_t>(std::max<idx_t>(GetFileSize(handle), pos) - pos, nr_bytes);
-	auto bytes_read = FSInternalRead(handle, hFile, buffer, n, pos);
-	pos += bytes_read;
-	return bytes_read;
-}
-
-static DWORD FSInternalWrite(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
-	DWORD bytes_written = 0;
-	OVERLAPPED ov = {};
-	ov.Internal = 0;
-	ov.InternalHigh = 0;
-	ov.Offset = location & 0xFFFFFFFF;
-	ov.OffsetHigh = location >> 32;
-	ov.hEvent = 0;
-	auto rc = WriteFile(hFile, buffer, (DWORD)nr_bytes, &bytes_written, &ov);
-	if (!rc) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Could not write file \"%s\" (error in WriteFile): %s", handle.path, error);
-	}
-	return bytes_written;
-}
-
-static int64_t FSWrite(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
-	int64_t bytes_written = 0;
-	while (nr_bytes > 0) {
-		auto bytes_to_write = MinValue<idx_t>(idx_t(NumericLimits<int32_t>::Maximum()), idx_t(nr_bytes));
-		DWORD current_bytes_written = FSInternalWrite(handle, hFile, buffer, bytes_to_write, location);
-		if (current_bytes_written <= 0) {
-			throw IOException("Could not write file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
-			                  strerror(errno));
-		}
-		bytes_written += current_bytes_written;
-		buffer = (void *)(data_ptr_cast(buffer) + current_bytes_written);
-		location += current_bytes_written;
-		nr_bytes -= current_bytes_written;
-	}
-	return bytes_written;
-}
-
-void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-	auto bytes_written = FSWrite(handle, hFile, buffer, nr_bytes, location);
-	if (bytes_written != nr_bytes) {
-		throw IOException("Could not write all bytes from file \"%s\": wanted=%lld wrote=%lld", handle.path, nr_bytes,
-		                  bytes_written);
-	}
-}
-
-int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-	auto &pos = handle.Cast<WindowsFileHandle>().position;
-	auto bytes_written = FSWrite(handle, hFile, buffer, nr_bytes, pos);
-	pos += bytes_written;
-	return bytes_written;
-}
-
-bool LocalFileSystem::Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) {
-	// TODO: Not yet implemented on windows.
-	return false;
-}
-
-int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-	LARGE_INTEGER result;
-	if (!GetFileSizeEx(hFile, &result)) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to get file size for file \"%s\": %s", handle.path, error);
-	}
-	return result.QuadPart;
-}
-
-time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-
-	// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfiletime
-	FILETIME last_write;
-	if (GetFileTime(hFile, nullptr, nullptr, &last_write) == 0) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to get last modified time for file \"%s\": %s", handle.path, error);
-	}
-
-	// https://stackoverflow.com/questions/29266743/what-is-dwlowdatetime-and-dwhighdatetime
-	ULARGE_INTEGER ul;
-	ul.LowPart = last_write.dwLowDateTime;
-	ul.HighPart = last_write.dwHighDateTime;
-	int64_t fileTime64 = ul.QuadPart;
-
-	// fileTime64 contains a 64-bit value representing the number of
-	// 100-nanosecond intervals since January 1, 1601 (UTC).
-	// https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
-
-	// Adapted from: https://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux
-	const auto WINDOWS_TICK = 10000000;
-	const auto SEC_TO_UNIX_EPOCH = 11644473600LL;
-	time_t result = (fileTime64 / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
-	return result;
-}
-
-void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-	// seek to the location
-	SetFilePointer(handle, new_size);
-	// now set the end of file position
-	if (!SetEndOfFile(hFile)) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failure in SetEndOfFile call on file \"%s\": %s", handle.path, error);
-	}
-}
-
-static DWORD WindowsGetFileAttributes(const string &filename) {
-	auto unicode_path = NormalizePathAndConvertToUnicode(filename);
-	return GetFileAttributesW(unicode_path.c_str());
-}
-
-static DWORD WindowsGetFileAttributes(const std::wstring &filename) {
-	return GetFileAttributesW(filename.c_str());
-}
-
-bool LocalFileSystem::DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) {
-	DWORD attrs = WindowsGetFileAttributes(directory);
-	return (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY));
-}
-
-void LocalFileSystem::CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	if (DirectoryExists(directory)) {
-		return;
-	}
-	auto unicode_path = NormalizePathAndConvertToUnicode(directory);
-	if (directory.empty() || !CreateDirectoryW(unicode_path.c_str(), NULL) || !DirectoryExists(directory)) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to create directory \"%s\": %s", directory.c_str(), error);
-	}
-}
-
-static void DeleteDirectoryRecursive(FileSystem &fs, string directory) {
-	fs.ListFiles(directory, [&](const string &fname, bool is_directory) {
-		if (is_directory) {
-			DeleteDirectoryRecursive(fs, fs.JoinPath(directory, fname));
-		} else {
-			fs.RemoveFile(fs.JoinPath(directory, fname));
-		}
-	});
-	auto unicode_path = NormalizePathAndConvertToUnicode(directory);
-	if (!RemoveDirectoryW(unicode_path.c_str())) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to delete directory \"%s\": %s", directory, error);
-	}
-}
-
-void LocalFileSystem::RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	if (FileExists(directory)) {
-		throw IOException("Attempting to delete directory \"%s\", but it is a file and not a directory!", directory);
-	}
-	if (!DirectoryExists(directory)) {
-		return;
-	}
-	DeleteDirectoryRecursive(*this, directory);
-}
-
-void LocalFileSystem::RemoveFile(const string &filename, optional_ptr<FileOpener> opener) {
-	auto unicode_path = NormalizePathAndConvertToUnicode(filename);
-	if (!DeleteFileW(unicode_path.c_str())) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to delete file \"%s\": %s", filename, error);
-	}
-}
-
-bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-                                FileOpener *opener) {
-	string search_dir = JoinPath(directory, "*");
-	auto unicode_path = NormalizePathAndConvertToUnicode(search_dir);
-
-	WIN32_FIND_DATAW ffd;
-	HANDLE hFind = FindFirstFileW(unicode_path.c_str(), &ffd);
-	if (hFind == INVALID_HANDLE_VALUE) {
-		return false;
-	}
-	do {
-		string cFileName = WindowsUtil::UnicodeToUTF8(ffd.cFileName);
-		if (cFileName == "." || cFileName == "..") {
-			continue;
-		}
-		callback(cFileName, ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
-	} while (FindNextFileW(hFind, &ffd) != 0);
-
-	DWORD dwError = GetLastError();
-	if (dwError != ERROR_NO_MORE_FILES) {
-		FindClose(hFind);
-		return false;
-	}
-
-	FindClose(hFind);
-	return true;
-}
-
-void LocalFileSystem::FileSync(FileHandle &handle) {
-	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
-	if (FlushFileBuffers(hFile) == 0) {
-		throw IOException("Could not flush file handle to disk!");
-	}
-}
-
-void LocalFileSystem::MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) {
-	auto source_unicode = NormalizePathAndConvertToUnicode(source);
-	auto target_unicode = NormalizePathAndConvertToUnicode(target);
-
-	if (!MoveFileW(source_unicode.c_str(), target_unicode.c_str())) {
-		throw IOException("Could not move file: %s", GetLastErrorAsString());
-	}
-}
-
-FileType LocalFileSystem::GetFileType(FileHandle &handle) {
-	auto path = handle.Cast<WindowsFileHandle>().path;
-	// pipes in windows are just files in '\\.\pipe\' folder
-	if (strncmp(path.c_str(), PIPE_PREFIX, strlen(PIPE_PREFIX)) == 0) {
-		return FileType::FILE_TYPE_FIFO;
-	}
-	auto normalized_path = NormalizePathAndConvertToUnicode(path);
-	DWORD attrs = WindowsGetFileAttributes(normalized_path);
-	if (attrs != INVALID_FILE_ATTRIBUTES) {
-		if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
-			return FileType::FILE_TYPE_DIR;
-		} else {
-			return FileType::FILE_TYPE_REGULAR;
-		}
-	}
-	return FileType::FILE_TYPE_INVALID;
-}
-#endif
-
-bool LocalFileSystem::CanSeek() {
-	return true;
-}
-
-bool LocalFileSystem::OnDiskFile(FileHandle &handle) {
-	return true;
-}
-
-void LocalFileSystem::Seek(FileHandle &handle, idx_t location) {
-	if (!CanSeek()) {
-		throw IOException("Cannot seek in files of this type");
-	}
-	SetFilePointer(handle, location);
-}
-
-idx_t LocalFileSystem::SeekPosition(FileHandle &handle) {
-	if (!CanSeek()) {
-		throw IOException("Cannot seek in files of this type");
-	}
-	return GetFilePointer(handle);
-}
-
-static bool IsCrawl(const string &glob) {
-	// glob must match exactly
-	return glob == "**";
-}
-static bool HasMultipleCrawl(const vector<string> &splits) {
-	return std::count(splits.begin(), splits.end(), "**") > 1;
-}
-static bool IsSymbolicLink(const string &path) {
-	auto normalized_path = LocalFileSystem::NormalizeLocalPath(path);
-#ifndef _WIN32
-	struct stat status;
-	return (lstat(normalized_path, &status) != -1 && S_ISLNK(status.st_mode));
-#else
-	auto attributes = WindowsGetFileAttributes(path);
-	if (attributes == INVALID_FILE_ATTRIBUTES)
-		return false;
-	return attributes & FILE_ATTRIBUTE_REPARSE_POINT;
-#endif
-}
-
-static void RecursiveGlobDirectories(FileSystem &fs, const string &path, vector<string> &result, bool match_directory,
-                                     bool join_path) {
-
-	fs.ListFiles(path, [&](const string &fname, bool is_directory) {
-		string concat;
-		if (join_path) {
-			concat = fs.JoinPath(path, fname);
-		} else {
-			concat = fname;
-		}
-		if (IsSymbolicLink(concat)) {
-			return;
-		}
-		if (is_directory == match_directory) {
-			result.push_back(concat);
-		}
-		if (is_directory) {
-			RecursiveGlobDirectories(fs, concat, result, match_directory, true);
-		}
-	});
-}
-
-static void GlobFilesInternal(FileSystem &fs, const string &path, const string &glob, bool match_directory,
-                              vector<string> &result, bool join_path) {
-	fs.ListFiles(path, [&](const string &fname, bool is_directory) {
-		if (is_directory != match_directory) {
-			return;
-		}
-		if (Glob(fname.c_str(), fname.size(), glob.c_str(), glob.size())) {
-			if (join_path) {
-				result.push_back(fs.JoinPath(path, fname));
-			} else {
-				result.push_back(fname);
-			}
-		}
-	});
-}
-
-vector<string> LocalFileSystem::FetchFileWithoutGlob(const string &path, FileOpener *opener, bool absolute_path) {
-	vector<string> result;
-	if (FileExists(path, opener) || IsPipe(path, opener)) {
-		result.push_back(path);
-	} else if (!absolute_path) {
-		Value value;
-		if (opener && opener->TryGetCurrentSetting("file_search_path", value)) {
-			auto search_paths_str = value.ToString();
-			vector<std::string> search_paths = StringUtil::Split(search_paths_str, ',');
-			for (const auto &search_path : search_paths) {
-				auto joined_path = JoinPath(search_path, path);
-				if (FileExists(joined_path, opener) || IsPipe(joined_path, opener)) {
-					result.push_back(joined_path);
-				}
-			}
-		}
-	}
-	return result;
-}
-
-// Helper function to handle file:/ URLs
-static idx_t GetFileUrlOffset(const string &path) {
-	if (!StringUtil::StartsWith(path, "file:/")) {
-		return 0;
-	}
-
-	// Url without host: file:/some/path
-	if (path[6] != '/') {
-#ifdef _WIN32
-		return 6;
-#else
-		return 5;
-#endif
-	}
-
-	// Url with empty host: file:///some/path
-	if (path[7] == '/') {
-#ifdef _WIN32
-		return 8;
-#else
-		return 7;
-#endif
-	}
-
-	// Url with localhost: file://localhost/some/path
-	if (path.compare(7, 10, "localhost/") == 0) {
-#ifdef _WIN32
-		return 17;
-#else
-		return 16;
-#endif
-	}
-
-	// unkown file:/ url format
-	return 0;
-}
-
-const char *LocalFileSystem::NormalizeLocalPath(const string &path) {
-	return path.c_str() + GetFileUrlOffset(path);
-}
-
-vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
-	if (path.empty()) {
-		return vector<string>();
-	}
-	// split up the path into separate chunks
-	vector<string> splits;
-
-	bool is_file_url = StringUtil::StartsWith(path, "file:/");
-	idx_t file_url_path_offset = GetFileUrlOffset(path);
-
-	idx_t last_pos = 0;
-	for (idx_t i = file_url_path_offset; i < path.size(); i++) {
-		if (path[i] == '\\' || path[i] == '/') {
-			if (i == last_pos) {
-				// empty: skip this position
-				last_pos = i + 1;
-				continue;
-			}
-			if (splits.empty()) {
-				//				splits.push_back(path.substr(file_url_path_offset, i-file_url_path_offset));
-				splits.push_back(path.substr(0, i));
-			} else {
-				splits.push_back(path.substr(last_pos, i - last_pos));
-			}
-			last_pos = i + 1;
-		}
-	}
-	splits.push_back(path.substr(last_pos, path.size() - last_pos));
-	// handle absolute paths
-	bool absolute_path = false;
-	if (IsPathAbsolute(path)) {
-		// first character is a slash -  unix absolute path
-		absolute_path = true;
-	} else if (StringUtil::Contains(splits[0], ":")) { // TODO: this is weird? shouldn't IsPathAbsolute handle this?
-		// first split has a colon -  windows absolute path
-		absolute_path = true;
-	} else if (splits[0] == "~") {
-		// starts with home directory
-		auto home_directory = GetHomeDirectory(opener);
-		if (!home_directory.empty()) {
-			absolute_path = true;
-			splits[0] = home_directory;
-			D_ASSERT(path[0] == '~');
-			if (!HasGlob(path)) {
-				return Glob(home_directory + path.substr(1));
-			}
-		}
-	}
-	// Check if the path has a glob at all
-	if (!HasGlob(path)) {
-		// no glob: return only the file (if it exists or is a pipe)
-		return FetchFileWithoutGlob(path, opener, absolute_path);
-	}
-	vector<string> previous_directories;
-	if (absolute_path) {
-		// for absolute paths, we don't start by scanning the current directory
-		previous_directories.push_back(splits[0]);
-	} else {
-		// If file_search_path is set, use those paths as the first glob elements
-		Value value;
-		if (opener && opener->TryGetCurrentSetting("file_search_path", value)) {
-			auto search_paths_str = value.ToString();
-			vector<std::string> search_paths = StringUtil::Split(search_paths_str, ',');
-			for (const auto &search_path : search_paths) {
-				previous_directories.push_back(search_path);
-			}
-		}
-	}
-
-	if (HasMultipleCrawl(splits)) {
-		throw IOException("Cannot use multiple \'**\' in one path");
-	}
-
-	idx_t start_index;
-	if (is_file_url) {
-		start_index = 1;
-	} else if (absolute_path) {
-		start_index = 1;
-	} else {
-		start_index = 0;
-	}
-
-	for (idx_t i = start_index ? 1 : 0; i < splits.size(); i++) {
-		bool is_last_chunk = i + 1 == splits.size();
-		bool has_glob = HasGlob(splits[i]);
-		// if it's the last chunk we need to find files, otherwise we find directories
-		// not the last chunk: gather a list of all directories that match the glob pattern
-		vector<string> result;
-		if (!has_glob) {
-			// no glob, just append as-is
-			if (previous_directories.empty()) {
-				result.push_back(splits[i]);
-			} else {
-				if (is_last_chunk) {
-					for (auto &prev_directory : previous_directories) {
-						const string filename = JoinPath(prev_directory, splits[i]);
-						if (FileExists(filename, opener) || DirectoryExists(filename, opener)) {
-							result.push_back(filename);
-						}
-					}
-				} else {
-					for (auto &prev_directory : previous_directories) {
-						result.push_back(JoinPath(prev_directory, splits[i]));
-					}
-				}
-			}
-		} else {
-			if (IsCrawl(splits[i])) {
-				if (!is_last_chunk) {
-					result = previous_directories;
-				}
-				if (previous_directories.empty()) {
-					RecursiveGlobDirectories(*this, ".", result, !is_last_chunk, false);
-				} else {
-					for (auto &prev_dir : previous_directories) {
-						RecursiveGlobDirectories(*this, prev_dir, result, !is_last_chunk, true);
-					}
-				}
-			} else {
-				if (previous_directories.empty()) {
-					// no previous directories: list in the current path
-					GlobFilesInternal(*this, ".", splits[i], !is_last_chunk, result, false);
-				} else {
-					// previous directories
-					// we iterate over each of the previous directories, and apply the glob of the current directory
-					for (auto &prev_directory : previous_directories) {
-						GlobFilesInternal(*this, prev_directory, splits[i], !is_last_chunk, result, true);
-					}
-				}
-			}
-		}
-		if (result.empty()) {
-			// no result found that matches the glob
-			// last ditch effort: search the path as a string literal
-			return FetchFileWithoutGlob(path, opener, absolute_path);
-		}
-		if (is_last_chunk) {
-			return result;
-		}
-		previous_directories = std::move(result);
-	}
-	return vector<string>();
-}
-
-unique_ptr<FileSystem> FileSystem::CreateLocal() {
-	return make_uniq<LocalFileSystem>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/multi_file_list.cpp b/src/duckdb/src/common/multi_file_list.cpp
deleted file mode 100644
index 668a5b363..000000000
--- a/src/duckdb/src/common/multi_file_list.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-#include "duckdb/common/multi_file_reader.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-MultiFilePushdownInfo::MultiFilePushdownInfo(LogicalGet &get)
-    : table_index(get.table_index), column_names(get.names), column_indexes(get.GetColumnIds()),
-      extra_info(get.extra_info) {
-	for (auto &col_id : column_indexes) {
-		column_ids.push_back(col_id.GetPrimaryIndex());
-	}
-}
-
-MultiFilePushdownInfo::MultiFilePushdownInfo(idx_t table_index, const vector<string> &column_names,
-                                             const vector<column_t> &column_ids, ExtraOperatorInfo &extra_info)
-    : table_index(table_index), column_names(column_names), column_ids(column_ids), extra_info(extra_info) {
-}
-
-// Helper method to do Filter Pushdown into a MultiFileList
-bool PushdownInternal(ClientContext &context, const MultiFileReaderOptions &options, MultiFilePushdownInfo &info,
-                      vector<unique_ptr<Expression>> &filters, vector<string> &expanded_files) {
-	HivePartitioningFilterInfo filter_info;
-	for (idx_t i = 0; i < info.column_ids.size(); i++) {
-		if (!IsRowIdColumnId(info.column_ids[i])) {
-			filter_info.column_map.insert({info.column_names[info.column_ids[i]], i});
-		}
-	}
-	filter_info.hive_enabled = options.hive_partitioning;
-	filter_info.filename_enabled = options.filename;
-
-	auto start_files = expanded_files.size();
-	HivePartitioning::ApplyFiltersToFileList(context, expanded_files, filters, filter_info, info);
-
-	if (expanded_files.size() != start_files) {
-		return true;
-	}
-
-	return false;
-}
-
-bool PushdownInternal(ClientContext &context, const MultiFileReaderOptions &options, const vector<string> &names,
-                      const vector<LogicalType> &types, const vector<column_t> &column_ids,
-                      const TableFilterSet &filters, vector<string> &expanded_files) {
-	idx_t table_index = 0;
-	ExtraOperatorInfo extra_info;
-
-	// construct the pushdown info
-	MultiFilePushdownInfo info(table_index, names, column_ids, extra_info);
-
-	// construct the set of expressions from the table filters
-	vector<unique_ptr<Expression>> filter_expressions;
-	for (auto &entry : filters.filters) {
-		auto column_idx = column_ids[entry.first];
-		auto column_ref =
-		    make_uniq<BoundColumnRefExpression>(types[column_idx], ColumnBinding(table_index, entry.first));
-		auto filter_expr = entry.second->ToExpression(*column_ref);
-		filter_expressions.push_back(std::move(filter_expr));
-	}
-
-	// call the original PushdownInternal method
-	return PushdownInternal(context, options, info, filter_expressions, expanded_files);
-}
-
-//===--------------------------------------------------------------------===//
-// MultiFileListIterator
-//===--------------------------------------------------------------------===//
-MultiFileListIterationHelper MultiFileList::Files() {
-	return MultiFileListIterationHelper(*this);
-}
-
-MultiFileListIterationHelper::MultiFileListIterationHelper(MultiFileList &file_list_p) : file_list(file_list_p) {
-}
-
-MultiFileListIterationHelper::MultiFileListIterator::MultiFileListIterator(MultiFileList *file_list_p)
-    : file_list(file_list_p) {
-	if (!file_list) {
-		return;
-	}
-
-	file_list->InitializeScan(file_scan_data);
-	if (!file_list->Scan(file_scan_data, current_file)) {
-		// There is no first file: move iterator to nop state
-		file_list = nullptr;
-		file_scan_data.current_file_idx = DConstants::INVALID_INDEX;
-	}
-}
-
-void MultiFileListIterationHelper::MultiFileListIterator::Next() {
-	if (!file_list) {
-		return;
-	}
-
-	if (!file_list->Scan(file_scan_data, current_file)) {
-		// exhausted collection: move iterator to nop state
-		file_list = nullptr;
-		file_scan_data.current_file_idx = DConstants::INVALID_INDEX;
-	}
-}
-
-MultiFileListIterationHelper::MultiFileListIterator MultiFileListIterationHelper::begin() { // NOLINT: match stl API
-	return MultiFileListIterationHelper::MultiFileListIterator(
-	    file_list.GetExpandResult() == FileExpandResult::NO_FILES ? nullptr : &file_list);
-}
-MultiFileListIterationHelper::MultiFileListIterator MultiFileListIterationHelper::end() { // NOLINT: match stl API
-	return MultiFileListIterationHelper::MultiFileListIterator(nullptr);
-}
-
-MultiFileListIterationHelper::MultiFileListIterator &MultiFileListIterationHelper::MultiFileListIterator::operator++() {
-	Next();
-	return *this;
-}
-
-bool MultiFileListIterationHelper::MultiFileListIterator::operator!=(const MultiFileListIterator &other) const {
-	return file_list != other.file_list || file_scan_data.current_file_idx != other.file_scan_data.current_file_idx;
-}
-
-const string &MultiFileListIterationHelper::MultiFileListIterator::operator*() const {
-	return current_file;
-}
-
-//===--------------------------------------------------------------------===//
-// MultiFileList
-//===--------------------------------------------------------------------===//
-MultiFileList::MultiFileList(vector<string> paths, FileGlobOptions options)
-    : paths(std::move(paths)), glob_options(options) {
-}
-
-MultiFileList::~MultiFileList() {
-}
-
-const vector<string> MultiFileList::GetPaths() const {
-	return paths;
-}
-
-void MultiFileList::InitializeScan(MultiFileListScanData &iterator) {
-	iterator.current_file_idx = 0;
-}
-
-bool MultiFileList::Scan(MultiFileListScanData &iterator, string &result_file) {
-	D_ASSERT(iterator.current_file_idx != DConstants::INVALID_INDEX);
-	auto maybe_file = GetFile(iterator.current_file_idx);
-
-	if (maybe_file.empty()) {
-		D_ASSERT(iterator.current_file_idx >= GetTotalFileCount());
-		return false;
-	}
-
-	result_file = maybe_file;
-	iterator.current_file_idx++;
-	return true;
-}
-
-unique_ptr<MultiFileList> MultiFileList::ComplexFilterPushdown(ClientContext &context,
-                                                               const MultiFileReaderOptions &options,
-                                                               MultiFilePushdownInfo &info,
-                                                               vector<unique_ptr<Expression>> &filters) {
-	// By default the filter pushdown into a multifilelist does nothing
-	return nullptr;
-}
-
-unique_ptr<MultiFileList>
-MultiFileList::DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-                                     const vector<string> &names, const vector<LogicalType> &types,
-                                     const vector<column_t> &column_ids, TableFilterSet &filters) const {
-	// By default the filter pushdown into a multifilelist does nothing
-	return nullptr;
-}
-
-unique_ptr<NodeStatistics> MultiFileList::GetCardinality(ClientContext &context) {
-	return nullptr;
-}
-
-string MultiFileList::GetFirstFile() {
-	return GetFile(0);
-}
-
-bool MultiFileList::IsEmpty() {
-	return GetExpandResult() == FileExpandResult::NO_FILES;
-}
-
-//===--------------------------------------------------------------------===//
-// SimpleMultiFileList
-//===--------------------------------------------------------------------===//
-SimpleMultiFileList::SimpleMultiFileList(vector<string> paths_p)
-    : MultiFileList(std::move(paths_p), FileGlobOptions::ALLOW_EMPTY) {
-}
-
-unique_ptr<MultiFileList> SimpleMultiFileList::ComplexFilterPushdown(ClientContext &context_p,
-                                                                     const MultiFileReaderOptions &options,
-                                                                     MultiFilePushdownInfo &info,
-                                                                     vector<unique_ptr<Expression>> &filters) {
-	if (!options.hive_partitioning && !options.filename) {
-		return nullptr;
-	}
-
-	// FIXME: don't copy list until first file is filtered
-	auto file_copy = paths;
-	auto res = PushdownInternal(context_p, options, info, filters, file_copy);
-
-	if (res) {
-		return make_uniq<SimpleMultiFileList>(file_copy);
-	}
-
-	return nullptr;
-}
-
-unique_ptr<MultiFileList>
-SimpleMultiFileList::DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-                                           const vector<string> &names, const vector<LogicalType> &types,
-                                           const vector<column_t> &column_ids, TableFilterSet &filters) const {
-	if (!options.hive_partitioning && !options.filename) {
-		return nullptr;
-	}
-
-	// FIXME: don't copy list until first file is filtered
-	auto file_copy = paths;
-	auto res = PushdownInternal(context, options, names, types, column_ids, filters, file_copy);
-	if (res) {
-		return make_uniq<SimpleMultiFileList>(file_copy);
-	}
-
-	return nullptr;
-}
-
-vector<string> SimpleMultiFileList::GetAllFiles() {
-	return paths;
-}
-
-FileExpandResult SimpleMultiFileList::GetExpandResult() {
-	if (paths.size() > 1) {
-		return FileExpandResult::MULTIPLE_FILES;
-	} else if (paths.size() == 1) {
-		return FileExpandResult::SINGLE_FILE;
-	}
-
-	return FileExpandResult::NO_FILES;
-}
-
-string SimpleMultiFileList::GetFile(idx_t i) {
-	if (paths.empty() || i >= paths.size()) {
-		return "";
-	}
-
-	return paths[i];
-}
-
-idx_t SimpleMultiFileList::GetTotalFileCount() {
-	return paths.size();
-}
-
-//===--------------------------------------------------------------------===//
-// GlobMultiFileList
-//===--------------------------------------------------------------------===//
-GlobMultiFileList::GlobMultiFileList(ClientContext &context_p, vector<string> paths_p, FileGlobOptions options)
-    : MultiFileList(std::move(paths_p), options), context(context_p), current_path(0) {
-}
-
-unique_ptr<MultiFileList> GlobMultiFileList::ComplexFilterPushdown(ClientContext &context_p,
-                                                                   const MultiFileReaderOptions &options,
-                                                                   MultiFilePushdownInfo &info,
-                                                                   vector<unique_ptr<Expression>> &filters) {
-	lock_guard<mutex> lck(lock);
-
-	// Expand all
-	// FIXME: lazy expansion
-	// FIXME: push down filters into glob
-	while (ExpandNextPath()) {
-	}
-
-	if (!options.hive_partitioning && !options.filename) {
-		return nullptr;
-	}
-	auto res = PushdownInternal(context, options, info, filters, expanded_files);
-	if (res) {
-		return make_uniq<SimpleMultiFileList>(expanded_files);
-	}
-
-	return nullptr;
-}
-
-unique_ptr<MultiFileList>
-GlobMultiFileList::DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-                                         const vector<string> &names, const vector<LogicalType> &types,
-                                         const vector<column_t> &column_ids, TableFilterSet &filters) const {
-	if (!options.hive_partitioning && !options.filename) {
-		return nullptr;
-	}
-	lock_guard<mutex> lck(lock);
-
-	// Expand all paths into a copy
-	// FIXME: lazy expansion and push filters into glob
-	idx_t path_index = current_path;
-	auto file_list = expanded_files;
-	while (ExpandPathInternal(path_index, file_list)) {
-	}
-
-	auto res = PushdownInternal(context, options, names, types, column_ids, filters, file_list);
-	if (res) {
-		return make_uniq<SimpleMultiFileList>(file_list);
-	}
-
-	return nullptr;
-}
-
-vector<string> GlobMultiFileList::GetAllFiles() {
-	lock_guard<mutex> lck(lock);
-	while (ExpandNextPath()) {
-	}
-	return expanded_files;
-}
-
-idx_t GlobMultiFileList::GetTotalFileCount() {
-	lock_guard<mutex> lck(lock);
-	while (ExpandNextPath()) {
-	}
-	return expanded_files.size();
-}
-
-FileExpandResult GlobMultiFileList::GetExpandResult() {
-	// GetFile(1) will ensure at least the first 2 files are expanded if they are available
-	GetFile(1);
-
-	if (expanded_files.size() > 1) {
-		return FileExpandResult::MULTIPLE_FILES;
-	} else if (expanded_files.size() == 1) {
-		return FileExpandResult::SINGLE_FILE;
-	}
-
-	return FileExpandResult::NO_FILES;
-}
-
-string GlobMultiFileList::GetFile(idx_t i) {
-	lock_guard<mutex> lck(lock);
-	return GetFileInternal(i);
-}
-
-string GlobMultiFileList::GetFileInternal(idx_t i) {
-	while (expanded_files.size() <= i) {
-		if (!ExpandNextPath()) {
-			return "";
-		}
-	}
-	D_ASSERT(expanded_files.size() > i);
-	return expanded_files[i];
-}
-
-bool GlobMultiFileList::ExpandPathInternal(idx_t &current_path, vector<string> &result) const {
-	if (current_path >= paths.size()) {
-		return false;
-	}
-
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto glob_files = fs.GlobFiles(paths[current_path], context, glob_options);
-	std::sort(glob_files.begin(), glob_files.end());
-	result.insert(result.end(), glob_files.begin(), glob_files.end());
-
-	current_path++;
-	return true;
-}
-
-bool GlobMultiFileList::ExpandNextPath() {
-	return ExpandPathInternal(current_path, expanded_files);
-}
-
-bool GlobMultiFileList::IsFullyExpanded() const {
-	return current_path == paths.size();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/multi_file_reader.cpp b/src/duckdb/src/common/multi_file_reader.cpp
deleted file mode 100644
index 97eba1014..000000000
--- a/src/duckdb/src/common/multi_file_reader.cpp
+++ /dev/null
@@ -1,618 +0,0 @@
-#include "duckdb/common/multi_file_reader.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-MultiFileReaderGlobalState::~MultiFileReaderGlobalState() {
-}
-
-MultiFileReader::~MultiFileReader() {
-}
-
-unique_ptr<MultiFileReader> MultiFileReader::Create(const TableFunction &table_function) {
-	unique_ptr<MultiFileReader> res;
-	if (table_function.get_multi_file_reader) {
-		res = table_function.get_multi_file_reader(table_function);
-		res->function_name = table_function.name;
-	} else {
-		res = make_uniq<MultiFileReader>();
-		res->function_name = table_function.name;
-	}
-	return res;
-}
-
-unique_ptr<MultiFileReader> MultiFileReader::CreateDefault(const string &function_name) {
-	auto res = make_uniq<MultiFileReader>();
-	res->function_name = function_name;
-	return res;
-}
-
-Value MultiFileReader::CreateValueFromFileList(const vector<string> &file_list) {
-	vector<Value> files;
-	for (auto &file : file_list) {
-		files.push_back(file);
-	}
-	return Value::LIST(LogicalType::VARCHAR, std::move(files));
-}
-
-void MultiFileReader::AddParameters(TableFunction &table_function) {
-	table_function.named_parameters["filename"] = LogicalType::ANY;
-	table_function.named_parameters["hive_partitioning"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["union_by_name"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["hive_types"] = LogicalType::ANY;
-	table_function.named_parameters["hive_types_autocast"] = LogicalType::BOOLEAN;
-}
-
-vector<string> MultiFileReader::ParsePaths(const Value &input) {
-	if (input.IsNull()) {
-		throw ParserException("%s cannot take NULL list as parameter", function_name);
-	}
-
-	if (input.type().id() == LogicalTypeId::VARCHAR) {
-		return {StringValue::Get(input)};
-	} else if (input.type().id() == LogicalTypeId::LIST) {
-		vector<string> paths;
-		for (auto &val : ListValue::GetChildren(input)) {
-			if (val.IsNull()) {
-				throw ParserException("%s reader cannot take NULL input as parameter", function_name);
-			}
-			if (val.type().id() != LogicalTypeId::VARCHAR) {
-				throw ParserException("%s reader can only take a list of strings as a parameter", function_name);
-			}
-			paths.push_back(StringValue::Get(val));
-		}
-		return paths;
-	} else {
-		throw InternalException("Unsupported type for MultiFileReader::ParsePaths called with: '%s'");
-	}
-}
-
-shared_ptr<MultiFileList> MultiFileReader::CreateFileList(ClientContext &context, const vector<string> &paths,
-                                                          FileGlobOptions options) {
-	vector<string> result_files;
-
-	auto res = make_uniq<GlobMultiFileList>(context, paths, options);
-	if (res->GetExpandResult() == FileExpandResult::NO_FILES && options == FileGlobOptions::DISALLOW_EMPTY) {
-		throw IOException("%s needs at least one file to read", function_name);
-	}
-	return std::move(res);
-}
-
-shared_ptr<MultiFileList> MultiFileReader::CreateFileList(ClientContext &context, const Value &input,
-                                                          FileGlobOptions options) {
-	auto paths = ParsePaths(input);
-	return CreateFileList(context, paths, options);
-}
-
-bool MultiFileReader::ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options,
-                                  ClientContext &context) {
-	auto loption = StringUtil::Lower(key);
-	if (loption == "filename") {
-		if (val.type() == LogicalType::VARCHAR) {
-			// If not, we interpret it as the name of the column containing the filename
-			options.filename = true;
-			options.filename_column = StringValue::Get(val);
-		} else {
-			Value boolean_value;
-			string error_message;
-			if (val.DefaultTryCastAs(LogicalType::BOOLEAN, boolean_value, &error_message)) {
-				// If the argument can be cast to boolean, we just interpret it as a boolean
-				options.filename = BooleanValue::Get(boolean_value);
-			}
-		}
-	} else if (loption == "hive_partitioning") {
-		options.hive_partitioning = BooleanValue::Get(val);
-		options.auto_detect_hive_partitioning = false;
-	} else if (loption == "union_by_name") {
-		options.union_by_name = BooleanValue::Get(val);
-	} else if (loption == "hive_types_autocast" || loption == "hive_type_autocast") {
-		options.hive_types_autocast = BooleanValue::Get(val);
-	} else if (loption == "hive_types" || loption == "hive_type") {
-		if (val.type().id() != LogicalTypeId::STRUCT) {
-			throw InvalidInputException(
-			    "'hive_types' only accepts a STRUCT('name':VARCHAR, ...), but '%s' was provided",
-			    val.type().ToString());
-		}
-		// verify that that all the children of the struct value are VARCHAR
-		auto &children = StructValue::GetChildren(val);
-		for (idx_t i = 0; i < children.size(); i++) {
-			const Value &child = children[i];
-			if (child.type().id() != LogicalType::VARCHAR) {
-				throw InvalidInputException("hive_types: '%s' must be a VARCHAR, instead: '%s' was provided",
-				                            StructType::GetChildName(val.type(), i), child.type().ToString());
-			}
-			// for every child of the struct, get the logical type
-			LogicalType transformed_type = TransformStringToLogicalType(child.ToString(), context);
-			const string &name = StructType::GetChildName(val.type(), i);
-			options.hive_types_schema[name] = transformed_type;
-		}
-		D_ASSERT(!options.hive_types_schema.empty());
-	} else {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<MultiFileList> MultiFileReader::ComplexFilterPushdown(ClientContext &context, MultiFileList &files,
-                                                                 const MultiFileReaderOptions &options,
-                                                                 MultiFilePushdownInfo &info,
-                                                                 vector<unique_ptr<Expression>> &filters) {
-	return files.ComplexFilterPushdown(context, options, info, filters);
-}
-
-unique_ptr<MultiFileList> MultiFileReader::DynamicFilterPushdown(ClientContext &context, const MultiFileList &files,
-                                                                 const MultiFileReaderOptions &options,
-                                                                 const vector<string> &names,
-                                                                 const vector<LogicalType> &types,
-                                                                 const vector<column_t> &column_ids,
-                                                                 TableFilterSet &filters) {
-	return files.DynamicFilterPushdown(context, options, names, types, column_ids, filters);
-}
-
-bool MultiFileReader::Bind(MultiFileReaderOptions &options, MultiFileList &files, vector<LogicalType> &return_types,
-                           vector<string> &names, MultiFileReaderBindData &bind_data) {
-	// The Default MultiFileReader can not perform any binding as it uses MultiFileLists with no schema information.
-	return false;
-}
-
-void MultiFileReader::BindOptions(MultiFileReaderOptions &options, MultiFileList &files,
-                                  vector<LogicalType> &return_types, vector<string> &names,
-                                  MultiFileReaderBindData &bind_data) {
-	// Add generated constant column for filename
-	if (options.filename) {
-		if (std::find(names.begin(), names.end(), options.filename_column) != names.end()) {
-			throw BinderException("Option filename adds column \"%s\", but a column with this name is also in the "
-			                      "file. Try setting a different name: filename='<filename column name>'",
-			                      options.filename_column);
-		}
-		bind_data.filename_idx = names.size();
-		return_types.emplace_back(LogicalType::VARCHAR);
-		names.emplace_back(options.filename_column);
-	}
-
-	// Add generated constant columns from hive partitioning scheme
-	if (options.hive_partitioning) {
-		D_ASSERT(files.GetExpandResult() != FileExpandResult::NO_FILES);
-		auto partitions = HivePartitioning::Parse(files.GetFirstFile());
-		// verify that all files have the same hive partitioning scheme
-		for (const auto &file : files.Files()) {
-			auto file_partitions = HivePartitioning::Parse(file);
-			for (auto &part_info : partitions) {
-				if (file_partitions.find(part_info.first) == file_partitions.end()) {
-					string error = "Hive partition mismatch between file \"%s\" and \"%s\": key \"%s\" not found";
-					if (options.auto_detect_hive_partitioning == true) {
-						throw InternalException(error + "(hive partitioning was autodetected)", files.GetFirstFile(),
-						                        file, part_info.first);
-					}
-					throw BinderException(error.c_str(), files.GetFirstFile(), file, part_info.first);
-				}
-			}
-			if (partitions.size() != file_partitions.size()) {
-				string error_msg = "Hive partition mismatch between file \"%s\" and \"%s\"";
-				if (options.auto_detect_hive_partitioning == true) {
-					throw InternalException(error_msg + "(hive partitioning was autodetected)", files.GetFirstFile(),
-					                        file);
-				}
-				throw BinderException(error_msg.c_str(), files.GetFirstFile(), file);
-			}
-		}
-
-		if (!options.hive_types_schema.empty()) {
-			// verify that all hive_types are existing partitions
-			options.VerifyHiveTypesArePartitions(partitions);
-		}
-
-		for (auto &part : partitions) {
-			idx_t hive_partitioning_index;
-			auto lookup = std::find_if(names.begin(), names.end(), [&](const string &col_name) {
-				return StringUtil::CIEquals(col_name, part.first);
-			});
-			if (lookup != names.end()) {
-				// hive partitioning column also exists in file - override
-				auto idx = NumericCast<idx_t>(lookup - names.begin());
-				hive_partitioning_index = idx;
-				return_types[idx] = options.GetHiveLogicalType(part.first);
-			} else {
-				// hive partitioning column does not exist in file - add a new column containing the key
-				hive_partitioning_index = names.size();
-				return_types.emplace_back(options.GetHiveLogicalType(part.first));
-				names.emplace_back(part.first);
-			}
-			bind_data.hive_partitioning_indexes.emplace_back(part.first, hive_partitioning_index);
-		}
-	}
-}
-
-void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, const MultiFileReaderBindData &options,
-                                   const string &filename, const vector<string> &local_names,
-                                   const vector<LogicalType> &global_types, const vector<string> &global_names,
-                                   const vector<ColumnIndex> &global_column_ids, MultiFileReaderData &reader_data,
-                                   ClientContext &context, optional_ptr<MultiFileReaderGlobalState> global_state) {
-
-	// create a map of name -> column index
-	case_insensitive_map_t<idx_t> name_map;
-	if (file_options.union_by_name) {
-		for (idx_t col_idx = 0; col_idx < local_names.size(); col_idx++) {
-			name_map[local_names[col_idx]] = col_idx;
-		}
-	}
-	for (idx_t i = 0; i < global_column_ids.size(); i++) {
-		auto &col_idx = global_column_ids[i];
-		if (col_idx.IsRowIdColumn()) {
-			// row-id
-			reader_data.constant_map.emplace_back(i, Value::BIGINT(42));
-			continue;
-		}
-		auto column_id = col_idx.GetPrimaryIndex();
-		if (column_id == options.filename_idx) {
-			// filename
-			reader_data.constant_map.emplace_back(i, Value(filename));
-			continue;
-		}
-		if (!options.hive_partitioning_indexes.empty()) {
-			// hive partition constants
-			auto partitions = HivePartitioning::Parse(filename);
-			D_ASSERT(partitions.size() == options.hive_partitioning_indexes.size());
-			bool found_partition = false;
-			for (auto &entry : options.hive_partitioning_indexes) {
-				if (column_id == entry.index) {
-					Value value = file_options.GetHivePartitionValue(partitions[entry.value], entry.value, context);
-					reader_data.constant_map.emplace_back(i, value);
-					found_partition = true;
-					break;
-				}
-			}
-			if (found_partition) {
-				continue;
-			}
-		}
-		if (file_options.union_by_name) {
-			auto &global_name = global_names[column_id];
-			auto entry = name_map.find(global_name);
-			bool not_present_in_file = entry == name_map.end();
-			if (not_present_in_file) {
-				// we need to project a column with name \"global_name\" - but it does not exist in the current file
-				// push a NULL value of the specified type
-				reader_data.constant_map.emplace_back(i, Value(global_types[column_id]));
-				continue;
-			}
-		}
-	}
-}
-
-unique_ptr<MultiFileReaderGlobalState>
-MultiFileReader::InitializeGlobalState(ClientContext &context, const MultiFileReaderOptions &file_options,
-                                       const MultiFileReaderBindData &bind_data, const MultiFileList &file_list,
-                                       const vector<LogicalType> &global_types, const vector<string> &global_names,
-                                       const vector<ColumnIndex> &global_column_ids) {
-	// By default, the multifilereader does not require any global state
-	return nullptr;
-}
-
-void MultiFileReader::CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
-                                        const vector<string> &local_names, const vector<LogicalType> &global_types,
-                                        const vector<string> &global_names,
-                                        const vector<ColumnIndex> &global_column_ids, MultiFileReaderData &reader_data,
-                                        const string &initial_file,
-                                        optional_ptr<MultiFileReaderGlobalState> global_state) {
-	D_ASSERT(global_types.size() == global_names.size());
-	D_ASSERT(local_types.size() == local_names.size());
-	// we have expected types: create a map of name -> column index
-	case_insensitive_map_t<idx_t> name_map;
-	for (idx_t col_idx = 0; col_idx < local_names.size(); col_idx++) {
-		name_map[local_names[col_idx]] = col_idx;
-	}
-	for (idx_t i = 0; i < global_column_ids.size(); i++) {
-		// check if this is a constant column
-		bool constant = false;
-		for (auto &entry : reader_data.constant_map) {
-			if (entry.column_id == i) {
-				constant = true;
-				break;
-			}
-		}
-		if (constant) {
-			// this column is constant for this file
-			continue;
-		}
-		// not constant - look up the column in the name map
-		auto &global_idx = global_column_ids[i];
-		auto global_id = global_idx.GetPrimaryIndex();
-		if (global_id >= global_types.size()) {
-			throw InternalException(
-			    "MultiFileReader::CreatePositionalMapping - global_id is out of range in global_types for this file");
-		}
-		auto &global_name = global_names[global_id];
-		auto entry = name_map.find(global_name);
-		if (entry == name_map.end()) {
-			string candidate_names;
-			for (auto &local_name : local_names) {
-				if (!candidate_names.empty()) {
-					candidate_names += ", ";
-				}
-				candidate_names += local_name;
-			}
-			throw IOException(
-			    StringUtil::Format("Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
-			                       "the original file \"%s\", but could not be found in file \"%s\".\nCandidate names: "
-			                       "%s\nIf you are trying to "
-			                       "read files with different schemas, try setting union_by_name=True",
-			                       file_name, global_name, initial_file, file_name, candidate_names));
-		}
-		// we found the column in the local file - check if the types are the same
-		auto local_id = entry->second;
-		D_ASSERT(global_id < global_types.size());
-		D_ASSERT(local_id < local_types.size());
-		auto &global_type = global_types[global_id];
-		auto &local_type = local_types[local_id];
-		ColumnIndex local_index(local_id);
-		if (global_type != local_type) {
-			// the types are not the same - add a cast
-			reader_data.cast_map[local_id] = global_type;
-		} else {
-			local_index = ColumnIndex(local_id, global_idx.GetChildIndexes());
-		}
-		// create the mapping
-		reader_data.column_mapping.push_back(i);
-		reader_data.column_ids.push_back(local_id);
-		reader_data.column_indexes.push_back(std::move(local_index));
-	}
-
-	reader_data.empty_columns = reader_data.column_indexes.empty();
-}
-
-void MultiFileReader::CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
-                                    const vector<string> &local_names, const vector<LogicalType> &global_types,
-                                    const vector<string> &global_names, const vector<ColumnIndex> &global_column_ids,
-                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
-                                    const string &initial_file, const MultiFileReaderBindData &options,
-                                    optional_ptr<MultiFileReaderGlobalState> global_state) {
-	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data,
-	                  initial_file, global_state);
-	CreateFilterMap(global_types, filters, reader_data, global_state);
-}
-
-void MultiFileReader::CreateFilterMap(const vector<LogicalType> &global_types, optional_ptr<TableFilterSet> filters,
-                                      MultiFileReaderData &reader_data,
-                                      optional_ptr<MultiFileReaderGlobalState> global_state) {
-	if (filters) {
-		auto filter_map_size = global_types.size();
-		if (global_state) {
-			filter_map_size += global_state->extra_columns.size();
-		}
-		reader_data.filter_map.resize(filter_map_size);
-
-		for (idx_t c = 0; c < reader_data.column_mapping.size(); c++) {
-			auto map_index = reader_data.column_mapping[c];
-			reader_data.filter_map[map_index].index = c;
-			reader_data.filter_map[map_index].is_constant = false;
-		}
-		for (idx_t c = 0; c < reader_data.constant_map.size(); c++) {
-			auto constant_index = reader_data.constant_map[c].column_id;
-			reader_data.filter_map[constant_index].index = c;
-			reader_data.filter_map[constant_index].is_constant = true;
-		}
-	}
-}
-
-void MultiFileReader::FinalizeChunk(ClientContext &context, const MultiFileReaderBindData &bind_data,
-                                    const MultiFileReaderData &reader_data, DataChunk &chunk,
-                                    optional_ptr<MultiFileReaderGlobalState> global_state) {
-	// reference all the constants set up in MultiFileReader::FinalizeBind
-	for (auto &entry : reader_data.constant_map) {
-		chunk.data[entry.column_id].Reference(entry.value);
-	}
-	chunk.Verify();
-}
-
-void MultiFileReader::GetPartitionData(ClientContext &context, const MultiFileReaderBindData &bind_data,
-                                       const MultiFileReaderData &reader_data,
-                                       optional_ptr<MultiFileReaderGlobalState> global_state,
-                                       const OperatorPartitionInfo &partition_info,
-                                       OperatorPartitionData &partition_data) {
-	for (auto &col : partition_info.partition_columns) {
-		bool found_constant = false;
-		for (auto &constant : reader_data.constant_map) {
-			if (constant.column_id == col) {
-				found_constant = true;
-				partition_data.partition_data.emplace_back(constant.value);
-				break;
-			}
-		}
-		if (!found_constant) {
-			throw InternalException(
-			    "MultiFileReader::GetPartitionData - did not find constant for the given partition");
-		}
-	}
-}
-
-TablePartitionInfo MultiFileReader::GetPartitionInfo(ClientContext &context, const MultiFileReaderBindData &bind_data,
-                                                     TableFunctionPartitionInput &input) {
-	// check if all of the columns are in the hive partition set
-	for (auto &partition_col : input.partition_ids) {
-		// check if this column is in the hive partitioned set
-		bool found = false;
-		for (auto &partition : bind_data.hive_partitioning_indexes) {
-			if (partition.index == partition_col) {
-				found = true;
-				break;
-			}
-		}
-		if (!found) {
-			// the column is not partitioned - hive partitioning alone can't guarantee the groups are partitioned
-			return TablePartitionInfo::NOT_PARTITIONED;
-		}
-	}
-	// if all columns are in the hive partitioning set, we know that each partition will only have a single value
-	// i.e. if the hive partitioning is by (YEAR, MONTH), each partition will have a single unique (YEAR, MONTH)
-	return TablePartitionInfo::SINGLE_VALUE_PARTITIONS;
-}
-
-TableFunctionSet MultiFileReader::CreateFunctionSet(TableFunction table_function) {
-	TableFunctionSet function_set(table_function.name);
-	function_set.AddFunction(table_function);
-	D_ASSERT(table_function.arguments.size() >= 1 && table_function.arguments[0] == LogicalType::VARCHAR);
-	table_function.arguments[0] = LogicalType::LIST(LogicalType::VARCHAR);
-	function_set.AddFunction(std::move(table_function));
-	return function_set;
-}
-
-HivePartitioningIndex::HivePartitioningIndex(string value_p, idx_t index) : value(std::move(value_p)), index(index) {
-}
-
-void MultiFileReaderOptions::AddBatchInfo(BindInfo &bind_info) const {
-	bind_info.InsertOption("filename", Value(filename_column));
-	bind_info.InsertOption("hive_partitioning", Value::BOOLEAN(hive_partitioning));
-	bind_info.InsertOption("auto_detect_hive_partitioning", Value::BOOLEAN(auto_detect_hive_partitioning));
-	bind_info.InsertOption("union_by_name", Value::BOOLEAN(union_by_name));
-	bind_info.InsertOption("hive_types_autocast", Value::BOOLEAN(hive_types_autocast));
-}
-
-void UnionByName::CombineUnionTypes(const vector<string> &col_names, const vector<LogicalType> &sql_types,
-                                    vector<LogicalType> &union_col_types, vector<string> &union_col_names,
-                                    case_insensitive_map_t<idx_t> &union_names_map) {
-	D_ASSERT(col_names.size() == sql_types.size());
-
-	for (idx_t col = 0; col < col_names.size(); ++col) {
-		auto union_find = union_names_map.find(col_names[col]);
-
-		if (union_find != union_names_map.end()) {
-			// given same name , union_col's type must compatible with col's type
-			auto &current_type = union_col_types[union_find->second];
-			auto compatible_type = LogicalType::ForceMaxLogicalType(current_type, sql_types[col]);
-			union_col_types[union_find->second] = compatible_type;
-		} else {
-			union_names_map[col_names[col]] = union_col_names.size();
-			union_col_names.emplace_back(col_names[col]);
-			union_col_types.emplace_back(sql_types[col]);
-		}
-	}
-}
-
-bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(MultiFileList &files, ClientContext &context) {
-	auto first_file = files.GetFirstFile();
-	auto partitions = HivePartitioning::Parse(first_file);
-	if (partitions.empty()) {
-		// no partitions found in first file
-		return false;
-	}
-
-	for (const auto &file : files.Files()) {
-		auto new_partitions = HivePartitioning::Parse(file);
-		if (new_partitions.size() != partitions.size()) {
-			// partition count mismatch
-			return false;
-		}
-		for (auto &part : new_partitions) {
-			auto entry = partitions.find(part.first);
-			if (entry == partitions.end()) {
-				// differing partitions between files
-				return false;
-			}
-		}
-	}
-	return true;
-}
-void MultiFileReaderOptions::AutoDetectHiveTypesInternal(MultiFileList &files, ClientContext &context) {
-	const LogicalType candidates[] = {LogicalType::DATE, LogicalType::TIMESTAMP, LogicalType::BIGINT};
-
-	unordered_map<string, LogicalType> detected_types;
-	for (const auto &file : files.Files()) {
-		auto partitions = HivePartitioning::Parse(file);
-		if (partitions.empty()) {
-			return;
-		}
-
-		for (auto &part : partitions) {
-			const string &name = part.first;
-			if (hive_types_schema.find(name) != hive_types_schema.end()) {
-				// type was explicitly provided by the user
-				continue;
-			}
-			LogicalType detected_type = LogicalType::VARCHAR;
-			Value value(part.second);
-			for (auto &candidate : candidates) {
-				const bool success = value.TryCastAs(context, candidate, true);
-				if (success) {
-					detected_type = candidate;
-					break;
-				}
-			}
-			auto entry = detected_types.find(name);
-			if (entry == detected_types.end()) {
-				// type was not yet detected - insert it
-				detected_types.insert(make_pair(name, std::move(detected_type)));
-			} else {
-				// type was already detected - check if the type matches
-				// if not promote to VARCHAR
-				if (entry->second != detected_type) {
-					entry->second = LogicalType::VARCHAR;
-				}
-			}
-		}
-	}
-	for (auto &entry : detected_types) {
-		hive_types_schema.insert(make_pair(entry.first, std::move(entry.second)));
-	}
-}
-void MultiFileReaderOptions::AutoDetectHivePartitioning(MultiFileList &files, ClientContext &context) {
-	D_ASSERT(files.GetExpandResult() != FileExpandResult::NO_FILES);
-	const bool hp_explicitly_disabled = !auto_detect_hive_partitioning && !hive_partitioning;
-	const bool ht_enabled = !hive_types_schema.empty();
-	if (hp_explicitly_disabled && ht_enabled) {
-		throw InvalidInputException("cannot disable hive_partitioning when hive_types is enabled");
-	}
-	if (ht_enabled && auto_detect_hive_partitioning && !hive_partitioning) {
-		// hive_types flag implies hive_partitioning
-		hive_partitioning = true;
-		auto_detect_hive_partitioning = false;
-	}
-	if (auto_detect_hive_partitioning) {
-		hive_partitioning = AutoDetectHivePartitioningInternal(files, context);
-	}
-	if (hive_partitioning && hive_types_autocast) {
-		AutoDetectHiveTypesInternal(files, context);
-	}
-}
-void MultiFileReaderOptions::VerifyHiveTypesArePartitions(const std::map<string, string> &partitions) const {
-	for (auto &hive_type : hive_types_schema) {
-		if (partitions.find(hive_type.first) == partitions.end()) {
-			throw InvalidInputException("Unknown hive_type: \"%s\" does not appear to be a partition", hive_type.first);
-		}
-	}
-}
-LogicalType MultiFileReaderOptions::GetHiveLogicalType(const string &hive_partition_column) const {
-	if (!hive_types_schema.empty()) {
-		auto it = hive_types_schema.find(hive_partition_column);
-		if (it != hive_types_schema.end()) {
-			return it->second;
-		}
-	}
-	return LogicalType::VARCHAR;
-}
-
-bool MultiFileReaderOptions::AnySet() {
-	return filename || hive_partitioning || union_by_name;
-}
-
-Value MultiFileReaderOptions::GetHivePartitionValue(const string &value, const string &key,
-                                                    ClientContext &context) const {
-	auto it = hive_types_schema.find(key);
-	if (it == hive_types_schema.end()) {
-		return HivePartitioning::GetValue(context, key, value, LogicalType::VARCHAR);
-	}
-	return HivePartitioning::GetValue(context, key, value, it->second);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/opener_file_system.cpp b/src/duckdb/src/common/opener_file_system.cpp
deleted file mode 100644
index 8f55d6898..000000000
--- a/src/duckdb/src/common/opener_file_system.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/common/opener_file_system.hpp"
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-void OpenerFileSystem::VerifyNoOpener(optional_ptr<FileOpener> opener) {
-	if (opener) {
-		throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
-	}
-}
-void OpenerFileSystem::VerifyCanAccessFileInternal(const string &path, FileType type) {
-	auto opener = GetOpener();
-	if (!opener) {
-		return;
-	}
-	auto db = opener->TryGetDatabase();
-	if (!db) {
-		return;
-	}
-	auto &config = db->config;
-	if (!config.CanAccessFile(path, type)) {
-		throw PermissionException("Cannot access %s \"%s\" - file system operations are disabled by configuration",
-		                          type == FileType::FILE_TYPE_DIR ? "directory" : "file", path);
-	}
-}
-
-void OpenerFileSystem::VerifyCanAccessFile(const string &path) {
-	VerifyCanAccessFileInternal(path, FileType::FILE_TYPE_REGULAR);
-}
-
-void OpenerFileSystem::VerifyCanAccessDirectory(const string &path) {
-	VerifyCanAccessFileInternal(path, FileType::FILE_TYPE_DIR);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/operator/cast_operators.cpp b/src/duckdb/src/common/operator/cast_operators.cpp
deleted file mode 100644
index 9742c6087..000000000
--- a/src/duckdb/src/common/operator/cast_operators.cpp
+++ /dev/null
@@ -1,2781 +0,0 @@
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/operator/numeric_cast.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/blob.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types.hpp"
-#include "fast_float/fast_float.h"
-#include "fmt/format.h"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/operator/integer_cast_operator.hpp"
-#include "duckdb/common/operator/double_cast_operator.hpp"
-
-#include <cctype>
-#include <cmath>
-#include <cstdlib>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Cast bool -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(bool input, bool &result, bool strict) {
-	return NumericTryCast::Operation<bool, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, float &result, bool strict) {
-	return NumericTryCast::Operation<bool, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, double &result, bool strict) {
-	return NumericTryCast::Operation<bool, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int8_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int16_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int32_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int64_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast hugeint_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(hugeint_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uhugeint_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uhugeint_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uhugeint_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uhugeint_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint8_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint16_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint32_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint64_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast float -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(float input, bool &result, bool strict) {
-	return NumericTryCast::Operation<float, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<float, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, float &result, bool strict) {
-	return NumericTryCast::Operation<float, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, double &result, bool strict) {
-	return NumericTryCast::Operation<float, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast double -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(double input, bool &result, bool strict) {
-	return NumericTryCast::Operation<double, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<double, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uhugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uhugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, float &result, bool strict) {
-	return NumericTryCast::Operation<double, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, double &result, bool strict) {
-	return NumericTryCast::Operation<double, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast String -> Numeric
-//===--------------------------------------------------------------------===//
-
-template <>
-bool TryCast::Operation(string_t input, bool &result, bool strict) {
-	auto input_data = reinterpret_cast<const char *>(input.GetData());
-	auto input_size = input.GetSize();
-	return TryCastStringBool(input_data, input_size, result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int8_t &result, bool strict) {
-	return TrySimpleIntegerCast<int8_t>(input.GetData(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int16_t &result, bool strict) {
-	return TrySimpleIntegerCast<int16_t>(input.GetData(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int32_t &result, bool strict) {
-	return TrySimpleIntegerCast<int32_t>(input.GetData(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int64_t &result, bool strict) {
-	return TrySimpleIntegerCast<int64_t>(input.GetData(), input.GetSize(), result, strict);
-}
-
-template <>
-bool TryCast::Operation(string_t input, uint8_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint8_t, false>(input.GetData(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, uint16_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint16_t, false>(input.GetData(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, uint32_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint32_t, false>(input.GetData(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, uint64_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint64_t, false>(input.GetData(), input.GetSize(), result, strict);
-}
-
-template <>
-bool TryCast::Operation(string_t input, float &result, bool strict) {
-	return TryDoubleCast<float>(input.GetData(), input.GetSize(), result, strict);
-}
-
-template <>
-bool TryCast::Operation(string_t input, double &result, bool strict) {
-	return TryDoubleCast<double>(input.GetData(), input.GetSize(), result, strict);
-}
-
-template <>
-bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, CastParameters &parameters) {
-	if (!TryDoubleCast<float>(input.GetData(), input.GetSize(), result, parameters.strict, ',')) {
-		HandleCastError::AssignError(StringUtil::Format("Could not cast string to float: \"%s\"", input.GetString()),
-		                             parameters);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, CastParameters &parameters) {
-	if (!TryDoubleCast<double>(input.GetData(), input.GetSize(), result, parameters.strict, ',')) {
-		HandleCastError::AssignError(StringUtil::Format("Could not cast string to double: \"%s\"", input.GetString()),
-		                             parameters);
-		return false;
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Date
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(date_t input, date_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (input == date_t::infinity()) {
-		result = timestamp_t::infinity();
-		return true;
-	} else if (input == date_t::ninfinity()) {
-		result = timestamp_t::ninfinity();
-		return true;
-	}
-	return Timestamp::TryFromDatetime(input, Time::FromTime(0, 0, 0), result);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Time
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(dtime_t input, dtime_tz_t &result, bool strict) {
-	result = dtime_tz_t(input, 0);
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Time With Time Zone (Offset)
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(dtime_tz_t input, dtime_tz_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(dtime_tz_t input, dtime_t &result, bool strict) {
-	result = input.time();
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Timestamps
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(timestamp_t input, date_t &result, bool strict) {
-	result = Timestamp::GetDate(input);
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, dtime_t &result, bool strict) {
-	if (!Timestamp::IsFinite(input)) {
-		return false;
-	}
-	result = Timestamp::GetTime(input);
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, timestamp_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_sec_t input, timestamp_sec_t &result, bool strict) {
-	result.value = input.value;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, timestamp_sec_t &result, bool strict) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	result.value = input.value / Interval::MICROS_PER_SEC;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_ms_t input, timestamp_ms_t &result, bool strict) {
-	result.value = input.value;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, timestamp_ms_t &result, bool strict) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	result.value = input.value / Interval::MICROS_PER_MSEC;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_ns_t input, timestamp_ns_t &result, bool strict) {
-	result.value = input.value;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, timestamp_ns_t &result, bool strict) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	if (!TryMultiplyOperator::Operation(input.value, Interval::NANOS_PER_MSEC, result.value)) {
-		throw ConversionException("Could not convert TIMESTAMP to TIMESTAMP_NS");
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_tz_t input, timestamp_tz_t &result, bool strict) {
-	result.value = input.value;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, timestamp_tz_t &result, bool strict) {
-	result.value = input.value;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, dtime_tz_t &result, bool strict) {
-	if (!Timestamp::IsFinite(input)) {
-		return false;
-	}
-	result = dtime_tz_t(Timestamp::GetTime(input), 0);
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast from Interval
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(interval_t input, interval_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Non-Standard Timestamps
-//===--------------------------------------------------------------------===//
-template <>
-duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_ns_t input, Vector &result) {
-	return StringCast::Operation<timestamp_ns_t>(input, result);
-}
-template <>
-duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(CastTimestampMsToUs::Operation<timestamp_t, timestamp_t>(input), result);
-}
-template <>
-duckdb::string_t CastFromTimestampSec::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input), result);
-}
-
-template <>
-timestamp_t CastTimestampUsToMs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	timestamp_t cast_timestamp(Timestamp::GetEpochRounded(input, Interval::MICROS_PER_MSEC));
-	return cast_timestamp;
-}
-
-template <>
-timestamp_t CastTimestampUsToNs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	timestamp_t cast_timestamp(Timestamp::GetEpochNanoSeconds(input));
-	return cast_timestamp;
-}
-
-template <>
-timestamp_t CastTimestampUsToSec::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	timestamp_t cast_timestamp(Timestamp::GetEpochRounded(input, Interval::MICROS_PER_SEC));
-	return cast_timestamp;
-}
-
-template <>
-timestamp_t CastTimestampMsToUs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::FromEpochMs(input.value);
-}
-
-template <>
-date_t CastTimestampMsToDate::Operation(timestamp_t input) {
-	return Timestamp::GetDate(Timestamp::FromEpochMs(input.value));
-}
-
-template <>
-dtime_t CastTimestampMsToTime::Operation(timestamp_t input) {
-	return Timestamp::GetTime(Timestamp::FromEpochMs(input.value));
-}
-
-template <>
-timestamp_t CastTimestampMsToNs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	auto us = CastTimestampMsToUs::Operation<timestamp_t, timestamp_t>(input);
-	return CastTimestampUsToNs::Operation<timestamp_t, timestamp_t>(us);
-}
-
-template <>
-timestamp_t CastTimestampNsToUs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::FromEpochNanoSeconds(input.value);
-}
-
-template <>
-timestamp_t CastTimestampSecToUs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	return Timestamp::FromEpochSeconds(input.value);
-}
-
-template <>
-date_t CastTimestampNsToDate::Operation(timestamp_t input) {
-	if (input == timestamp_t::infinity()) {
-		return date_t::infinity();
-	} else if (input == timestamp_t::ninfinity()) {
-		return date_t::ninfinity();
-	}
-	const auto us = CastTimestampNsToUs::Operation<timestamp_t, timestamp_t>(input);
-	return Timestamp::GetDate(us);
-}
-
-template <>
-dtime_t CastTimestampNsToTime::Operation(timestamp_t input) {
-	const auto us = CastTimestampNsToUs::Operation<timestamp_t, timestamp_t>(input);
-	return Timestamp::GetTime(us);
-}
-
-template <>
-timestamp_t CastTimestampSecToMs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	auto us = CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input);
-	return CastTimestampUsToMs::Operation<timestamp_t, timestamp_t>(us);
-}
-
-template <>
-timestamp_t CastTimestampSecToNs::Operation(timestamp_t input) {
-	if (!Timestamp::IsFinite(input)) {
-		return input;
-	}
-	auto us = CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input);
-	return CastTimestampUsToNs::Operation<timestamp_t, timestamp_t>(us);
-}
-
-template <>
-date_t CastTimestampSecToDate::Operation(timestamp_t input) {
-	const auto us = CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input);
-	return Timestamp::GetDate(us);
-}
-
-template <>
-dtime_t CastTimestampSecToTime::Operation(timestamp_t input) {
-	const auto us = CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input);
-	return Timestamp::GetTime(us);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Timestamp
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToTimestampNS::Operation(string_t input, timestamp_ns_t &result, bool strict) {
-	return TryCast::Operation<string_t, timestamp_ns_t>(input, result, strict);
-}
-
-template <>
-bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result = CastTimestampUsToMs::Operation<timestamp_t, timestamp_t>(result);
-	return true;
-}
-
-template <>
-bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result = CastTimestampUsToSec::Operation<timestamp_t, timestamp_t>(result);
-	return true;
-}
-
-template <>
-bool TryCastToTimestampNS::Operation(date_t input, timestamp_ns_t &result, bool strict) {
-	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	if (!Timestamp::IsFinite(result)) {
-		return true;
-	}
-	if (!TryMultiplyOperator::Operation(result.value, Interval::NANOS_PER_MICRO, result.value)) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	if (!Timestamp::IsFinite(result)) {
-		return true;
-	}
-	result.value /= Interval::MICROS_PER_MSEC;
-	return true;
-}
-
-template <>
-bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	if (!Timestamp::IsFinite(result)) {
-		return true;
-	}
-	result.value /= Interval::MICROS_PER_MSEC * Interval::MSECS_PER_SEC;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Blob
-//===--------------------------------------------------------------------===//
-template <>
-string_t CastFromBlob::Operation(string_t input, Vector &vector) {
-	idx_t result_size = Blob::GetStringSize(input);
-
-	string_t result = StringVector::EmptyString(vector, result_size);
-	Blob::ToString(input, result.GetDataWriteable());
-	result.Finalize();
-
-	return result;
-}
-
-template <>
-string_t CastFromBlobToBit::Operation(string_t input, Vector &vector) {
-	idx_t result_size = input.GetSize() + 1;
-	if (result_size <= 1) {
-		throw ConversionException("Cannot cast empty BLOB to BIT");
-	}
-	return StringVector::AddStringOrBlob(vector, Bit::BlobToBit(input));
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Bit
-//===--------------------------------------------------------------------===//
-template <>
-string_t CastFromBitToString::Operation(string_t input, Vector &vector) {
-
-	idx_t result_size = Bit::BitLength(input);
-	string_t result = StringVector::EmptyString(vector, result_size);
-	Bit::ToString(input, result.GetDataWriteable());
-	result.Finalize();
-
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Pointer
-//===--------------------------------------------------------------------===//
-template <>
-string_t CastFromPointer::Operation(uintptr_t input, Vector &vector) {
-	std::string s = duckdb_fmt::format("0x{:x}", input);
-	return StringVector::AddString(vector, s);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Blob
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters) {
-	idx_t result_size;
-	if (!Blob::TryGetBlobSize(input, result_size, parameters)) {
-		return false;
-	}
-
-	result = StringVector::EmptyString(result_vector, result_size);
-	Blob::ToBlob(input, data_ptr_cast(result.GetDataWriteable()));
-	result.Finalize();
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Bit
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters) {
-	idx_t result_size;
-	if (!Bit::TryGetBitStringSize(input, result_size, parameters.error_message)) {
-		return false;
-	}
-
-	result = StringVector::EmptyString(result_vector, result_size);
-	Bit::ToBit(input, result);
-	result.Finalize();
-	return true;
-}
-
-template <>
-bool CastFromBitToNumeric::Operation(string_t input, bool &result, CastParameters &parameters) {
-	D_ASSERT(input.GetSize() > 1);
-
-	uint8_t value;
-	bool success = CastFromBitToNumeric::Operation(input, value, parameters);
-	result = (value > 0);
-	return (success);
-}
-
-template <>
-bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, CastParameters &parameters) {
-	D_ASSERT(input.GetSize() > 1);
-
-	if (input.GetSize() - 1 > sizeof(hugeint_t)) {
-		throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s",
-		                          GetTypeId<hugeint_t>());
-	}
-	Bit::BitToNumeric(input, result);
-	return (true);
-}
-
-template <>
-bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, CastParameters &parameters) {
-	D_ASSERT(input.GetSize() > 1);
-
-	if (input.GetSize() - 1 > sizeof(uhugeint_t)) {
-		throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s",
-		                          GetTypeId<uhugeint_t>());
-	}
-	Bit::BitToNumeric(input, result);
-	return (true);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From UUID
-//===--------------------------------------------------------------------===//
-template <>
-string_t CastFromUUID::Operation(hugeint_t input, Vector &vector) {
-	string_t result = StringVector::EmptyString(vector, 36);
-	UUID::ToString(input, result.GetDataWriteable());
-	result.Finalize();
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To UUID
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, CastParameters &parameters) {
-	return UUID::FromString(input.GetString(), result);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Date
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters &parameters) {
-	idx_t pos;
-	bool special = false;
-	switch (Date::TryConvertDate(input.GetData(), input.GetSize(), pos, result, special, parameters.strict)) {
-	case DateCastResult::SUCCESS:
-		break;
-	case DateCastResult::ERROR_INCORRECT_FORMAT:
-		HandleCastError::AssignError(Date::FormatError(input), parameters);
-		return false;
-	case DateCastResult::ERROR_RANGE:
-		HandleCastError::AssignError(Date::RangeError(input), parameters);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, date_t &result, bool strict) {
-	idx_t pos;
-	bool special = false;
-	return Date::TryConvertDate(input.GetData(), input.GetSize(), pos, result, special, strict) ==
-	       DateCastResult::SUCCESS;
-}
-
-template <>
-date_t Cast::Operation(string_t input) {
-	return Date::FromCString(input.GetData(), input.GetSize());
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Time
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, CastParameters &parameters) {
-	if (!TryCast::Operation<string_t, dtime_t>(input, result, parameters.strict)) {
-		HandleCastError::AssignError(Time::ConversionError(input), parameters);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, dtime_t &result, bool strict) {
-	idx_t pos;
-	return Time::TryConvertTime(input.GetData(), input.GetSize(), pos, result, strict);
-}
-
-template <>
-dtime_t Cast::Operation(string_t input) {
-	return Time::FromCString(input.GetData(), input.GetSize());
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To TimeTZ
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, CastParameters &parameters) {
-	if (!TryCast::Operation<string_t, dtime_tz_t>(input, result, parameters.strict)) {
-		HandleCastError::AssignError(Time::ConversionError(input), parameters);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict) {
-	idx_t pos;
-	bool has_offset;
-	return Time::TryConvertTimeTZ(input.GetData(), input.GetSize(), pos, result, has_offset, strict);
-}
-
-template <>
-dtime_tz_t Cast::Operation(string_t input) {
-	dtime_tz_t result;
-	if (!TryCast::Operation(input, result, false)) {
-		throw ConversionException(Time::ConversionError(input));
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Timestamp
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters &parameters) {
-	switch (Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result)) {
-	case TimestampCastResult::SUCCESS:
-		return true;
-	case TimestampCastResult::ERROR_INCORRECT_FORMAT:
-		HandleCastError::AssignError(Timestamp::FormatError(input), parameters);
-		break;
-	case TimestampCastResult::ERROR_NON_UTC_TIMEZONE:
-		HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), parameters);
-		break;
-	case TimestampCastResult::ERROR_RANGE:
-		HandleCastError::AssignError(Timestamp::RangeError(input), parameters);
-		break;
-	}
-	return false;
-}
-
-template <>
-bool TryCast::Operation(string_t input, timestamp_t &result, bool strict) {
-	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result) == TimestampCastResult::SUCCESS;
-}
-
-template <>
-bool TryCast::Operation(string_t input, timestamp_ns_t &result, bool strict) {
-	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result) == TimestampCastResult::SUCCESS;
-}
-
-template <>
-timestamp_t Cast::Operation(string_t input) {
-	return Timestamp::FromCString(input.GetData(), input.GetSize());
-}
-
-template <>
-timestamp_ns_t Cast::Operation(string_t input) {
-	int32_t nanos;
-	const auto ts = Timestamp::FromCString(input.GetData(), input.GetSize(), &nanos);
-	timestamp_ns_t result;
-	if (!Timestamp::TryFromTimestampNanos(ts, nanos, result)) {
-		throw ConversionException(Timestamp::RangeError(input));
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Interval
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastParameters &parameters) {
-	return Interval::FromCString(input.GetData(), input.GetSize(), result, parameters.error_message, parameters.strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast to hugeint / uhugeint
-//===--------------------------------------------------------------------===//
-// parsing hugeint from string is done a bit differently for performance reasons
-// for other integer types we keep track of a single value
-// and multiply that value by 10 for every digit we read
-// however, for hugeints, multiplication is very expensive (>20X as expensive as for int64)
-// for that reason, we parse numbers first into an int64 value
-// when that value is full, we perform a HUGEINT multiplication to flush it into the hugeint
-// this takes the number of HUGEINT multiplications down from [0-38] to [0-2]
-
-template <typename T, typename OP, typename INTERMEDIATE_T>
-struct HugeIntCastData {
-	using ResultType = T;
-	using IntermediateType = INTERMEDIATE_T;
-	using Operation = OP;
-	ResultType result;
-	IntermediateType intermediate;
-	uint8_t digits;
-
-	ResultType decimal;
-	uint16_t decimal_total_digits;
-	ResultType decimal_intermediate;
-	uint16_t decimal_intermediate_digits;
-
-	bool Flush() {
-		if (digits == 0 && intermediate == 0) {
-			return true;
-		}
-		if (result.lower != 0 || result.upper != 0) {
-			if (digits > 38) {
-				return false;
-			}
-			if (!OP::TryMultiply(result, OP::POWERS_OF_TEN[digits], result)) {
-				return false;
-			}
-		}
-		if (!OP::TryAddInPlace(result, ResultType(intermediate))) {
-			return false;
-		}
-		digits = 0;
-		intermediate = 0;
-		return true;
-	}
-
-	bool FlushDecimal() {
-		if (decimal_intermediate_digits == 0 && decimal_intermediate == 0) {
-			return true;
-		}
-		if (decimal.lower != 0 || decimal.upper != 0) {
-			if (decimal_intermediate_digits > 38) {
-				return false;
-			}
-			if (!OP::TryMultiply(decimal, OP::POWERS_OF_TEN[decimal_intermediate_digits], decimal)) {
-				return false;
-			}
-		}
-		if (!OP::TryAddInPlace(decimal, ResultType(decimal_intermediate))) {
-			return false;
-		}
-		decimal_total_digits += decimal_intermediate_digits;
-		decimal_intermediate_digits = 0;
-		decimal_intermediate = 0;
-		return true;
-	}
-};
-
-struct HugeIntegerCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &state, uint8_t digit) {
-		if (NEGATIVE) {
-			if (DUCKDB_UNLIKELY(state.intermediate <
-			                    (NumericLimits<typename T::IntermediateType>::Minimum() + digit) / 10)) {
-				// intermediate is full: need to flush it
-				if (!state.Flush()) {
-					return false;
-				}
-			}
-			state.intermediate = state.intermediate * 10 - digit;
-		} else {
-			if (DUCKDB_UNLIKELY(state.intermediate >
-			                    (NumericLimits<typename T::IntermediateType>::Maximum() - digit) / 10)) {
-				if (!state.Flush()) {
-					return false;
-				}
-			}
-			state.intermediate = state.intermediate * 10 + digit;
-		}
-		state.digits++;
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleHexDigit(T &state, uint8_t digit) {
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleBinaryDigit(T &state, uint8_t digit) {
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int32_t exponent) {
-		using result_t = typename T::ResultType;
-		if (!state.Flush()) {
-			return false;
-		}
-
-		int32_t e = exponent;
-		if (e < -38) {
-			state.result = 0;
-			return true;
-		}
-
-		// Negative Exponent
-		result_t remainder = 0;
-		if (e < 0) {
-			state.result = T::Operation::DivMod(state.result, T::Operation::POWERS_OF_TEN[-e], remainder);
-			if (remainder < 0) {
-				result_t negate_result;
-				if (!T::Operation::TryNegate(remainder, negate_result)) {
-					return false;
-				}
-				remainder = negate_result;
-			}
-			state.decimal = remainder;
-			state.decimal_total_digits = static_cast<uint16_t>(-e);
-			state.decimal_intermediate = 0;
-			state.decimal_intermediate_digits = 0;
-			return Finalize<T, NEGATIVE>(state);
-		}
-
-		// Positive Exponent
-		if (state.result != 0) {
-			if (e > 38 || !TryMultiplyOperator::Operation(state.result, T::Operation::POWERS_OF_TEN[e], state.result)) {
-				return false;
-			}
-		}
-		if (!state.FlushDecimal()) {
-			return false;
-		}
-		if (state.decimal == 0) {
-			return Finalize<T, NEGATIVE>(state);
-		}
-
-		e = exponent - state.decimal_total_digits;
-		if (e < 0) {
-			state.decimal = T::Operation::DivMod(state.decimal, T::Operation::POWERS_OF_TEN[-e], remainder);
-			state.decimal_total_digits -= (exponent);
-		} else {
-			if (e > 38 ||
-			    !TryMultiplyOperator::Operation(state.decimal, T::Operation::POWERS_OF_TEN[e], state.decimal)) {
-				return false;
-			}
-		}
-
-		if (NEGATIVE) {
-			if (!TrySubtractOperator::Operation(state.result, state.decimal, state.result)) {
-				return false;
-			}
-		} else if (!TryAddOperator::Operation(state.result, state.decimal, state.result)) {
-			return false;
-		}
-		state.decimal = remainder;
-		return Finalize<T, NEGATIVE>(state);
-	}
-
-	template <class T, bool NEGATIVE, bool ALLOW_EXPONENT>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		if (!state.Flush()) {
-			return false;
-		}
-		if (DUCKDB_UNLIKELY(state.decimal_intermediate > (NumericLimits<int64_t>::Maximum() - digit) / 10)) {
-			if (!state.FlushDecimal()) {
-				return false;
-			}
-		}
-		state.decimal_intermediate = state.decimal_intermediate * 10 + digit;
-		state.decimal_intermediate_digits++;
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool Finalize(T &state) {
-		using result_t = typename T::ResultType;
-		if (!state.Flush() || !state.FlushDecimal()) {
-			return false;
-		}
-
-		if (state.decimal == 0 || state.decimal_total_digits == 0) {
-			return true;
-		}
-
-		// Get the first (left-most) digit of the decimals
-		while (state.decimal_total_digits > 39) {
-			state.decimal /= T::Operation::POWERS_OF_TEN[39];
-			state.decimal_total_digits -= 39;
-		}
-		D_ASSERT((state.decimal_total_digits - 1) >= 0 && (state.decimal_total_digits - 1) <= 39);
-		state.decimal /= T::Operation::POWERS_OF_TEN[state.decimal_total_digits - 1];
-
-		if (state.decimal >= 5) {
-			if (NEGATIVE) {
-				return TrySubtractOperator::Operation(state.result, result_t(1), state.result);
-			} else {
-				return TryAddOperator::Operation(state.result, result_t(1), state.result);
-			}
-		}
-		return true;
-	}
-};
-
-template <>
-bool TryCast::Operation(string_t input, hugeint_t &result, bool strict) {
-	HugeIntCastData<hugeint_t, Hugeint, int64_t> state {};
-	if (!TryIntegerCast<HugeIntCastData<hugeint_t, Hugeint, int64_t>, true, true, HugeIntegerCastOperation>(
-	        input.GetData(), input.GetSize(), state, strict)) {
-		return false;
-	}
-	result = state.result;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, uhugeint_t &result, bool strict) {
-	HugeIntCastData<uhugeint_t, Uhugeint, uint64_t> state {};
-	if (!TryIntegerCast<HugeIntCastData<uhugeint_t, Uhugeint, uint64_t>, false, true, HugeIntegerCastOperation>(
-	        input.GetData(), input.GetSize(), state, strict)) {
-		return false;
-	}
-	result = state.result;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal String Cast
-//===--------------------------------------------------------------------===//
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryDecimalStringCast<int16_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryDecimalStringCast<int32_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryDecimalStringCast<int64_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryDecimalStringCast<hugeint_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, CastParameters &parameters,
-                                               uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int16_t, ','>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, CastParameters &parameters,
-                                               uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int32_t, ','>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, CastParameters &parameters,
-                                               uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int64_t, ','>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, CastParameters &parameters,
-                                               uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<hugeint_t, ','>(input, result, parameters, width, scale);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int16_t>(input, width, scale, result);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(int32_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int32_t>(input, width, scale, result);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int64_t>(input, width, scale, result);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<hugeint_t>(input, width, scale, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal Casts
-//===--------------------------------------------------------------------===//
-// Decimal <-> Bool
-//===--------------------------------------------------------------------===//
-template <class T, class OP = NumericHelper>
-bool TryCastBoolToDecimal(bool input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	if (width > scale) {
-		result = UnsafeNumericCast<T>(input ? OP::POWERS_OF_TEN[scale] : 0);
-		return true;
-	} else {
-		return TryCast::Operation<bool, T>(input, result);
-	}
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryCastBoolToDecimal<int16_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryCastBoolToDecimal<int32_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryCastBoolToDecimal<int64_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return TryCastBoolToDecimal<hugeint_t, Hugeint>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCast::Operation<int16_t, bool>(input, result);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCast::Operation<int32_t, bool>(input, result);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCast::Operation<int64_t, bool>(input, result);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCast::Operation<hugeint_t, bool>(input, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Numeric -> Decimal Cast
-//===--------------------------------------------------------------------===//
-struct SignedToDecimalOperator {
-	template <class SRC, class DST>
-	static bool Operation(SRC input, DST max_width) {
-		return int64_t(input) >= int64_t(max_width) || int64_t(input) <= int64_t(-max_width);
-	}
-};
-
-struct UnsignedToDecimalOperator {
-	template <class SRC, class DST>
-	static bool Operation(SRC input, DST max_width) {
-		return uint64_t(input) >= uint64_t(max_width);
-	}
-};
-
-template <class SRC, class DST, class OP = SignedToDecimalOperator>
-bool StandardNumericToDecimalCast(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	// check for overflow
-	DST max_width = UnsafeNumericCast<DST>(NumericHelper::POWERS_OF_TEN[width - scale]);
-	if (OP::template Operation<SRC, DST>(input, max_width)) {
-		string error = StringUtil::Format("Could not cast value %d to DECIMAL(%d,%d)", input, width, scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = UnsafeNumericCast<DST>(DST(input) * NumericHelper::POWERS_OF_TEN[scale]);
-	return true;
-}
-
-template <class SRC>
-bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	// check for overflow
-	hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale];
-	hugeint_t hinput = Hugeint::Convert(input);
-	if (hinput >= max_width || hinput <= -max_width) {
-		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", hinput.ToString(), width, scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = hinput * Hugeint::POWERS_OF_TEN[scale];
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int8_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int8_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int16_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int8_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int32_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int8_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int64_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int8_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int16_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int16_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int32_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int64_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int16_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int32_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int16_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int32_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int64_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int32_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int64_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int16_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int32_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int64_t>(input, result, parameters, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int64_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint8_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                 scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                 scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                 scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint8_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint16_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint16_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint32_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint32_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint64_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
-	                                                                                  scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint64_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Hugeint -> Decimal Cast
-//===--------------------------------------------------------------------===//
-template <class DST>
-bool HugeintToDecimalCast(hugeint_t input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	// check for overflow
-	hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale];
-	if (input >= max_width || input <= -max_width) {
-		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = Hugeint::Cast<DST>(input * Hugeint::POWERS_OF_TEN[scale]);
-	return true;
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<int16_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<int32_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<int64_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<hugeint_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Uhugeint -> Decimal Cast
-//===--------------------------------------------------------------------===//
-template <class DST>
-bool UhugeintToDecimalCast(uhugeint_t input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	// check for overflow
-	uhugeint_t max_width = Uhugeint::POWERS_OF_TEN[width - scale];
-	if (input >= max_width) {
-		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = Uhugeint::Cast<DST>(input * Uhugeint::POWERS_OF_TEN[scale]);
-	return true;
-}
-
-template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return UhugeintToDecimalCast<int16_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return UhugeintToDecimalCast<int32_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return UhugeintToDecimalCast<int64_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return UhugeintToDecimalCast<hugeint_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Float/Double -> Decimal Cast
-//===--------------------------------------------------------------------===//
-template <class SRC, class DST>
-bool DoubleToDecimalCast(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	double value = input * NumericHelper::DOUBLE_POWERS_OF_TEN[scale];
-	double roundedValue = round(value);
-	if (roundedValue <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] ||
-	    roundedValue >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) {
-		string error = StringUtil::Format("Could not cast value %f to DECIMAL(%d,%d)", input, width, scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = Cast::Operation<SRC, DST>(static_cast<SRC>(value));
-	return true;
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<float, int16_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<float, int32_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<float, int64_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<float, hugeint_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<double, int16_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<double, int32_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<double, int64_t>(input, result, parameters, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                 uint8_t scale) {
-	return DoubleToDecimalCast<double, hugeint_t>(input, result, parameters, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal -> Numeric Cast
-//===--------------------------------------------------------------------===//
-template <class SRC, class DST>
-bool TryCastDecimalToNumeric(SRC input, DST &result, CastParameters &parameters, uint8_t scale) {
-	// Round away from 0.
-	const auto power = NumericHelper::POWERS_OF_TEN[scale];
-	// https://graphics.stanford.edu/~seander/bithacks.html#ConditionalNegate
-	const auto fNegate = int64_t(input < 0);
-	const auto rounding = ((power ^ -fNegate) + fNegate) / 2;
-	const auto scaled_value = (input + rounding) / power;
-	if (!TryCast::Operation<SRC, DST>(UnsafeNumericCast<SRC>(scaled_value), result)) {
-		string error = StringUtil::Format("Failed to cast decimal value %d to type %s", scaled_value, GetTypeId<DST>());
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	return true;
-}
-
-template <class DST>
-bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, CastParameters &parameters, uint8_t scale) {
-	const auto power = Hugeint::POWERS_OF_TEN[scale];
-	const auto rounding = ((input < 0) ? -power : power) / 2;
-	auto scaled_value = (input + rounding) / power;
-	if (!TryCast::Operation<hugeint_t, DST>(scaled_value, result)) {
-		string error = StringUtil::Format("Failed to cast decimal value %s to type %s",
-		                                  ConvertToString::Operation(scaled_value), GetTypeId<DST>());
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int8_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int8_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int8_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int8_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int8_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int16_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int16_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int16_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int16_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int16_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int32_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int32_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int32_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int32_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int32_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int64_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int64_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int64_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int64_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int64_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint8_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint8_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint8_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint8_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint8_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint16_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint16_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint16_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint16_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint16_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint32_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint32_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint32_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint32_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint32_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint64_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint64_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint64_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint64_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint64_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> hugeint_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, hugeint_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, hugeint_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, hugeint_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<hugeint_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uhugeint_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uhugeint_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uhugeint_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uhugeint_t>(input, result, parameters, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uhugeint_t>(input, result, parameters, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal -> Float/Double Cast
-//===--------------------------------------------------------------------===//
-template <class SRC, class DST>
-static bool IsRepresentableExactly(SRC input, DST);
-
-template <>
-bool IsRepresentableExactly(int16_t input, float dst) {
-	return true;
-}
-
-const int64_t MAX_INT_REPRESENTABLE_IN_FLOAT = 0x001000000LL;
-const int64_t MAX_INT_REPRESENTABLE_IN_DOUBLE = 0x0020000000000000LL;
-
-template <>
-bool IsRepresentableExactly(int32_t input, float dst) {
-	return (input <= MAX_INT_REPRESENTABLE_IN_FLOAT && input >= -MAX_INT_REPRESENTABLE_IN_FLOAT);
-}
-
-template <>
-bool IsRepresentableExactly(int64_t input, float dst) {
-	return (input <= MAX_INT_REPRESENTABLE_IN_FLOAT && input >= -MAX_INT_REPRESENTABLE_IN_FLOAT);
-}
-
-template <>
-bool IsRepresentableExactly(hugeint_t input, float dst) {
-	return (input <= MAX_INT_REPRESENTABLE_IN_FLOAT && input >= -MAX_INT_REPRESENTABLE_IN_FLOAT);
-}
-
-template <>
-bool IsRepresentableExactly(int16_t input, double dst) {
-	return true;
-}
-
-template <>
-bool IsRepresentableExactly(int32_t input, double dst) {
-	return true;
-}
-
-template <>
-bool IsRepresentableExactly(int64_t input, double dst) {
-	return (input <= MAX_INT_REPRESENTABLE_IN_DOUBLE && input >= -MAX_INT_REPRESENTABLE_IN_DOUBLE);
-}
-
-template <>
-bool IsRepresentableExactly(hugeint_t input, double dst) {
-	return (input <= MAX_INT_REPRESENTABLE_IN_DOUBLE && input >= -MAX_INT_REPRESENTABLE_IN_DOUBLE);
-}
-
-template <class SRC>
-static SRC GetPowerOfTen(SRC input, uint8_t scale) {
-	return static_cast<SRC>(NumericHelper::POWERS_OF_TEN[scale]);
-}
-
-template <>
-hugeint_t GetPowerOfTen(hugeint_t input, uint8_t scale) {
-	return Hugeint::POWERS_OF_TEN[scale];
-}
-
-template <class SRC>
-static void GetDivMod(SRC lhs, SRC rhs, SRC &div, SRC &mod) {
-	div = lhs / rhs;
-	mod = lhs % rhs;
-}
-
-template <>
-void GetDivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &div, hugeint_t &mod) {
-	div = Hugeint::DivMod(lhs, rhs, mod);
-}
-
-template <class SRC, class DST>
-bool TryCastDecimalToFloatingPoint(SRC input, DST &result, uint8_t scale) {
-	if (IsRepresentableExactly<SRC, DST>(input, DST(0.0)) || scale == 0) {
-		// Fast path, integer is representable exaclty as a float/double
-		result = Cast::Operation<SRC, DST>(input) / DST(NumericHelper::DOUBLE_POWERS_OF_TEN[scale]);
-		return true;
-	}
-	auto power_of_ten = GetPowerOfTen(input, scale);
-
-	SRC div = 0;
-	SRC mod = 0;
-	GetDivMod(input, power_of_ten, div, mod);
-
-	result = Cast::Operation<SRC, DST>(div) +
-	         Cast::Operation<SRC, DST>(mod) / DST(NumericHelper::DOUBLE_POWERS_OF_TEN[scale]);
-	return true;
-}
-
-// DECIMAL -> FLOAT
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int16_t, float>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int32_t, float>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int64_t, float>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<hugeint_t, float>(input, result, scale);
-}
-
-// DECIMAL -> DOUBLE
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int16_t, double>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int32_t, double>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int64_t, double>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<hugeint_t, double>(input, result, scale);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/operator/convert_to_string.cpp b/src/duckdb/src/common/operator/convert_to_string.cpp
deleted file mode 100644
index 758717759..000000000
--- a/src/duckdb/src/common/operator/convert_to_string.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/common/operator/convert_to_string.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-template <class T>
-string StandardStringCast(T input) {
-	Vector v(LogicalType::VARCHAR);
-	return StringCast::Operation(input, v).GetString();
-}
-
-template <>
-string ConvertToString::Operation(bool input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int8_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int16_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int32_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int64_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint8_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint16_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint32_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint64_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(hugeint_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uhugeint_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(float input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(double input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(interval_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(date_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(dtime_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(timestamp_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(string_t input) {
-	return input.GetString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/operator/string_cast.cpp b/src/duckdb/src/common/operator/string_cast.cpp
deleted file mode 100644
index e152c71bf..000000000
--- a/src/duckdb/src/common/operator/string_cast.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> String
-//===--------------------------------------------------------------------===//
-template <>
-string_t StringCast::Operation(bool input, Vector &vector) {
-	if (input) {
-		return StringVector::AddString(vector, "true", 4);
-	} else {
-		return StringVector::AddString(vector, "false", 5);
-	}
-}
-
-template <>
-string_t StringCast::Operation(int8_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int8_t>(input, vector);
-}
-
-template <>
-string_t StringCast::Operation(int16_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int16_t>(input, vector);
-}
-template <>
-string_t StringCast::Operation(int32_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int32_t>(input, vector);
-}
-
-template <>
-string_t StringCast::Operation(int64_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int64_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint8_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint8_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint16_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint16_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint32_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint32_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint64_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint64_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(hugeint_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<hugeint_t>(input, vector);
-}
-
-template <>
-string_t StringCast::Operation(float input, Vector &vector) {
-	std::string s = duckdb_fmt::format("{}", input);
-	return StringVector::AddString(vector, s);
-}
-
-template <>
-string_t StringCast::Operation(double input, Vector &vector) {
-	std::string s = duckdb_fmt::format("{}", input);
-	return StringVector::AddString(vector, s);
-}
-
-template <>
-string_t StringCast::Operation(interval_t input, Vector &vector) {
-	char buffer[70] = {};
-	idx_t length = IntervalToStringCast::Format(input, buffer);
-	return StringVector::AddString(vector, buffer, length);
-}
-
-template <>
-duckdb::string_t StringCast::Operation(uhugeint_t input, Vector &vector) {
-	return UhugeintToStringCast::Format(input, vector);
-}
-
-template <>
-duckdb::string_t StringCast::Operation(date_t input, Vector &vector) {
-	if (input == date_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
-	} else if (input == date_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
-	}
-	int32_t date[3];
-	Date::Convert(input, date[0], date[1], date[2]);
-
-	idx_t year_length;
-	bool add_bc;
-	idx_t length = DateToStringCast::Length(date, year_length, add_bc);
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	DateToStringCast::Format(data, date, year_length, add_bc);
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
-	int32_t time[4];
-	Time::Convert(input, time[0], time[1], time[2], time[3]);
-
-	char micro_buffer[10] = {};
-	idx_t length = TimeToStringCast::Length(time, micro_buffer);
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	TimeToStringCast::Format(data, length, time, micro_buffer);
-
-	result.Finalize();
-	return result;
-}
-
-template <bool HAS_NANOS>
-duckdb::string_t StringFromTimestamp(timestamp_t input, Vector &vector) {
-	if (input == timestamp_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
-	}
-	if (input == timestamp_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
-	}
-
-	date_t date_entry;
-	dtime_t time_entry;
-	int32_t picos = 0;
-	if (HAS_NANOS) {
-		timestamp_ns_t ns;
-		ns.value = input.value;
-		Timestamp::Convert(ns, date_entry, time_entry, picos);
-		// Use picoseconds so we have 6 digits
-		picos *= 1000;
-	} else {
-		Timestamp::Convert(input, date_entry, time_entry);
-	}
-
-	int32_t date[3], time[4];
-	Date::Convert(date_entry, date[0], date[1], date[2]);
-	Time::Convert(time_entry, time[0], time[1], time[2], time[3]);
-
-	// format for timestamp is DATE TIME (separated by space)
-	idx_t year_length;
-	bool add_bc;
-	char micro_buffer[6] = {};
-	char nano_buffer[6] = {};
-	idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
-	idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
-	idx_t nano_length = 0;
-	if (picos) {
-		//	If there are ps, we need all the µs
-		time_length = 15;
-		nano_length = 6;
-		nano_length -= NumericCast<idx_t>(TimeToStringCast::FormatMicros(picos, nano_buffer));
-	}
-	const idx_t length = date_length + 1 + time_length + nano_length;
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	DateToStringCast::Format(data, date, year_length, add_bc);
-	data += date_length;
-	*data++ = ' ';
-	TimeToStringCast::Format(data, time_length, time, micro_buffer);
-	data += time_length;
-	memcpy(data, nano_buffer, nano_length);
-	D_ASSERT(data + nano_length <= result.GetDataWriteable() + length);
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-duckdb::string_t StringCast::Operation(timestamp_t input, Vector &vector) {
-	return StringFromTimestamp<false>(input, vector);
-}
-
-template <>
-duckdb::string_t StringCast::Operation(timestamp_ns_t input, Vector &vector) {
-	return StringFromTimestamp<true>(input, vector);
-}
-
-template <>
-duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result) {
-	return StringVector::AddStringOrBlob(result, input);
-}
-
-template <>
-string_t StringCastTZ::Operation(dtime_tz_t input, Vector &vector) {
-	int32_t time[4];
-	Time::Convert(input.time(), time[0], time[1], time[2], time[3]);
-
-	char micro_buffer[10] = {};
-	const auto time_length = TimeToStringCast::Length(time, micro_buffer);
-	idx_t length = time_length;
-
-	const auto offset = input.offset();
-	const bool negative = (offset < 0);
-	++length;
-
-	auto ss = std::abs(offset);
-	const auto hh = ss / Interval::SECS_PER_HOUR;
-
-	const auto hh_length = UnsafeNumericCast<idx_t>((hh < 100) ? 2 : NumericHelper::UnsignedLength(uint32_t(hh)));
-	length += hh_length;
-
-	ss %= Interval::SECS_PER_HOUR;
-	const auto mm = ss / Interval::SECS_PER_MINUTE;
-	if (mm) {
-		length += 3;
-	}
-
-	ss %= Interval::SECS_PER_MINUTE;
-	if (ss) {
-		length += 3;
-	}
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	idx_t pos = 0;
-	TimeToStringCast::Format(data + pos, time_length, time, micro_buffer);
-	pos += time_length;
-
-	data[pos++] = negative ? '-' : '+';
-	if (hh < 100) {
-		TimeToStringCast::FormatTwoDigits(data + pos, hh);
-	} else {
-		NumericHelper::FormatUnsigned(hh, data + pos + hh_length);
-	}
-	pos += hh_length;
-
-	if (mm) {
-		data[pos++] = ':';
-		TimeToStringCast::FormatTwoDigits(data + pos, mm);
-		pos += 2;
-	}
-
-	if (ss) {
-		data[pos++] = ':';
-		TimeToStringCast::FormatTwoDigits(data + pos, ss);
-		pos += 2;
-	}
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-string_t StringCastTZ::Operation(timestamp_t input, Vector &vector) {
-	if (input == timestamp_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
-	}
-	if (input == timestamp_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
-	}
-
-	date_t date_entry;
-	dtime_t time_entry;
-	Timestamp::Convert(input, date_entry, time_entry);
-
-	int32_t date[3], time[4];
-	Date::Convert(date_entry, date[0], date[1], date[2]);
-	Time::Convert(time_entry, time[0], time[1], time[2], time[3]);
-
-	// format for timestamptz is DATE TIME+00 (separated by space)
-	idx_t year_length;
-	bool add_bc;
-	char micro_buffer[6] = {};
-	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
-	const idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
-	const idx_t length = date_length + 1 + time_length + 3;
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	idx_t pos = 0;
-	DateToStringCast::Format(data + pos, date, year_length, add_bc);
-	pos += date_length;
-	data[pos++] = ' ';
-	TimeToStringCast::Format(data + pos, time_length, time, micro_buffer);
-	pos += time_length;
-	data[pos++] = '+';
-	data[pos++] = '0';
-	data[pos++] = '0';
-
-	result.Finalize();
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/pipe_file_system.cpp b/src/duckdb/src/common/pipe_file_system.cpp
deleted file mode 100644
index 3345e4987..000000000
--- a/src/duckdb/src/common/pipe_file_system.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/common/pipe_file_system.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-class PipeFile : public FileHandle {
-public:
-	explicit PipeFile(unique_ptr<FileHandle> child_handle_p)
-	    : FileHandle(pipe_fs, child_handle_p->path, child_handle_p->GetFlags()),
-	      child_handle(std::move(child_handle_p)) {
-	}
-
-	PipeFileSystem pipe_fs;
-	unique_ptr<FileHandle> child_handle;
-
-public:
-	int64_t ReadChunk(void *buffer, int64_t nr_bytes);
-	int64_t WriteChunk(void *buffer, int64_t nr_bytes);
-
-	void Close() override {
-	}
-};
-
-int64_t PipeFile::ReadChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Read(buffer, UnsafeNumericCast<idx_t>(nr_bytes));
-}
-int64_t PipeFile::WriteChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Write(buffer, UnsafeNumericCast<idx_t>(nr_bytes));
-}
-
-void PipeFileSystem::Reset(FileHandle &handle) {
-	throw InternalException("Cannot reset pipe file system");
-}
-
-int64_t PipeFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &pipe = handle.Cast<PipeFile>();
-	return pipe.ReadChunk(buffer, nr_bytes);
-}
-
-int64_t PipeFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &pipe = handle.Cast<PipeFile>();
-	return pipe.WriteChunk(buffer, nr_bytes);
-}
-
-int64_t PipeFileSystem::GetFileSize(FileHandle &handle) {
-	return 0;
-}
-
-void PipeFileSystem::FileSync(FileHandle &handle) {
-}
-
-unique_ptr<FileHandle> PipeFileSystem::OpenPipe(unique_ptr<FileHandle> handle) {
-	return make_uniq<PipeFile>(std::move(handle));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/printer.cpp b/src/duckdb/src/common/printer.cpp
deleted file mode 100644
index 0c704b74d..000000000
--- a/src/duckdb/src/common/printer.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/windows_util.hpp"
-#include "duckdb/common/windows.hpp"
-#include <stdio.h>
-
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-#include <io.h>
-#else
-#include <sys/ioctl.h>
-#include <stdio.h>
-#include <unistd.h>
-#endif
-#endif
-
-namespace duckdb {
-
-void Printer::RawPrint(OutputStream stream, const string &str) {
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-	if (IsTerminal(stream)) {
-		// print utf8 to terminal
-		auto unicode = WindowsUtil::UTF8ToMBCS(str.c_str());
-		fprintf(stream == OutputStream::STREAM_STDERR ? stderr : stdout, "%s", unicode.c_str());
-		return;
-	}
-#endif
-	fprintf(stream == OutputStream::STREAM_STDERR ? stderr : stdout, "%s", str.c_str());
-#endif
-}
-
-// LCOV_EXCL_START
-void Printer::Print(OutputStream stream, const string &str) {
-	Printer::RawPrint(stream, str);
-	Printer::RawPrint(stream, "\n");
-}
-void Printer::Flush(OutputStream stream) {
-#ifndef DUCKDB_DISABLE_PRINT
-	fflush(stream == OutputStream::STREAM_STDERR ? stderr : stdout);
-#endif
-}
-
-void Printer::Print(const string &str) {
-	Printer::Print(OutputStream::STREAM_STDERR, str);
-}
-
-bool Printer::IsTerminal(OutputStream stream) {
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-	auto stream_handle = stream == OutputStream::STREAM_STDERR ? STD_ERROR_HANDLE : STD_OUTPUT_HANDLE;
-	return GetFileType(GetStdHandle(stream_handle)) == FILE_TYPE_CHAR;
-#else
-	return isatty(stream == OutputStream::STREAM_STDERR ? 2 : 1);
-#endif
-#else
-	throw InternalException("IsTerminal called while printing is disabled");
-#endif
-}
-
-idx_t Printer::TerminalWidth() {
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-	CONSOLE_SCREEN_BUFFER_INFO csbi;
-	int rows;
-
-	GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
-	rows = csbi.srWindow.Right - csbi.srWindow.Left + 1;
-	return rows;
-#else
-	struct winsize w;
-	ioctl(0, TIOCGWINSZ, &w);
-	return w.ws_col;
-#endif
-#else
-	throw InternalException("TerminalWidth called while printing is disabled");
-#endif
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/progress_bar/progress_bar.cpp b/src/duckdb/src/common/progress_bar/progress_bar.cpp
deleted file mode 100644
index 4a3de66fb..000000000
--- a/src/duckdb/src/common/progress_bar/progress_bar.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp"
-
-namespace duckdb {
-
-void QueryProgress::Initialize() {
-	percentage = -1;
-	rows_processed = 0;
-	total_rows_to_process = 0;
-}
-
-void QueryProgress::Restart() {
-	percentage = 0;
-	rows_processed = 0;
-	total_rows_to_process = 0;
-}
-
-double QueryProgress::GetPercentage() {
-	return percentage;
-}
-uint64_t QueryProgress::GetRowsProcesseed() {
-	return rows_processed;
-}
-uint64_t QueryProgress::GetTotalRowsToProcess() {
-	return total_rows_to_process;
-}
-
-QueryProgress::QueryProgress() {
-	Initialize();
-}
-
-QueryProgress &QueryProgress::operator=(const QueryProgress &other) {
-	if (this != &other) {
-		percentage = other.percentage.load();
-		rows_processed = other.rows_processed.load();
-		total_rows_to_process = other.total_rows_to_process.load();
-	}
-	return *this;
-}
-
-QueryProgress::QueryProgress(const QueryProgress &other) {
-	percentage = other.percentage.load();
-	rows_processed = other.rows_processed.load();
-	total_rows_to_process = other.total_rows_to_process.load();
-}
-
-void ProgressBar::SystemOverrideCheck(ClientConfig &config) {
-	if (config.system_progress_bar_disable_reason != nullptr) {
-		throw InvalidInputException("Could not change the progress bar setting because: '%s'",
-		                            config.system_progress_bar_disable_reason);
-	}
-}
-
-unique_ptr<ProgressBarDisplay> ProgressBar::DefaultProgressBarDisplay() {
-	return make_uniq<TerminalProgressBarDisplay>();
-}
-
-ProgressBar::ProgressBar(Executor &executor, idx_t show_progress_after,
-                         progress_bar_display_create_func_t create_display_func)
-    : executor(executor), show_progress_after(show_progress_after) {
-	if (create_display_func) {
-		display = create_display_func();
-	}
-}
-
-QueryProgress ProgressBar::GetDetailedQueryProgress() {
-	return query_progress;
-}
-
-void ProgressBar::Start() {
-	profiler.Start();
-	query_progress.Initialize();
-	supported = true;
-}
-
-bool ProgressBar::PrintEnabled() const {
-	return display != nullptr;
-}
-
-bool ProgressBar::ShouldPrint(bool final) const {
-	if (!PrintEnabled()) {
-		// Don't print progress at all
-		return false;
-	}
-	if (!supported) {
-		return false;
-	}
-
-	double elapsed_time = -1.0;
-	if (elapsed_time < 0.0) {
-		elapsed_time = profiler.Elapsed();
-	}
-
-	auto sufficient_time_elapsed = elapsed_time > static_cast<double>(show_progress_after) / 1000.0;
-	if (!sufficient_time_elapsed) {
-		// Don't print yet
-		return false;
-	}
-	if (final) {
-		// Print the last completed bar
-		return true;
-	}
-	return query_progress.percentage > -1;
-}
-
-void ProgressBar::Update(bool final) {
-	if (!final && !supported) {
-		return;
-	}
-
-	ProgressData progress;
-	idx_t invalid_pipelines = executor.GetPipelinesProgress(progress);
-
-	double new_percentage = 0.0;
-	if (invalid_pipelines == 0 && progress.IsValid()) {
-		if (progress.total > 1e15) {
-			progress.Normalize(1e15);
-		}
-		query_progress.rows_processed = idx_t(progress.done);
-		query_progress.total_rows_to_process = idx_t(progress.total);
-		new_percentage = progress.ProgressDone() * 100;
-	}
-
-	if (!final && invalid_pipelines > 0) {
-		return;
-	}
-
-	if (new_percentage > query_progress.percentage) {
-		query_progress.percentage = new_percentage;
-	}
-	if (ShouldPrint(final)) {
-		if (final) {
-			FinishProgressBarPrint();
-		} else {
-			PrintProgress(LossyNumericCast<int>(query_progress.percentage.load()));
-		}
-	}
-}
-
-void ProgressBar::PrintProgress(int current_percentage_p) {
-	D_ASSERT(display);
-	display->Update(current_percentage_p);
-}
-
-void ProgressBar::FinishProgressBarPrint() {
-	if (finished) {
-		return;
-	}
-	D_ASSERT(display);
-	display->Finish();
-	finished = true;
-	if (query_progress.percentage == 0) {
-		query_progress.Initialize();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/progress_bar/terminal_progress_bar_display.cpp b/src/duckdb/src/common/progress_bar/terminal_progress_bar_display.cpp
deleted file mode 100644
index 912b8ccce..000000000
--- a/src/duckdb/src/common/progress_bar/terminal_progress_bar_display.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-int32_t TerminalProgressBarDisplay::NormalizePercentage(double percentage) {
-	if (percentage > 100) {
-		return 100;
-	}
-	if (percentage < 0) {
-		return 0;
-	}
-	return int32_t(percentage);
-}
-
-void TerminalProgressBarDisplay::PrintProgressInternal(int32_t percentage) {
-	string result;
-	// we divide the number of blocks by the percentage
-	// 0%   = 0
-	// 100% = PROGRESS_BAR_WIDTH
-	// the percentage determines how many blocks we need to draw
-	double blocks_to_draw = PROGRESS_BAR_WIDTH * (percentage / 100.0);
-	// because of the power of unicode, we can also draw partial blocks
-
-	// render the percentage with some padding to ensure everything stays nicely aligned
-	result = "\r";
-	if (percentage < 100) {
-		result += " ";
-	}
-	if (percentage < 10) {
-		result += " ";
-	}
-	result += to_string(percentage) + "%";
-	result += " ";
-	result += PROGRESS_START;
-	idx_t i;
-	for (i = 0; i < idx_t(blocks_to_draw); i++) {
-		result += PROGRESS_BLOCK;
-	}
-	if (i < PROGRESS_BAR_WIDTH) {
-		// print a partial block based on the percentage of the progress bar remaining
-		idx_t index = idx_t((blocks_to_draw - static_cast<double>(idx_t(blocks_to_draw))) * PARTIAL_BLOCK_COUNT);
-		if (index >= PARTIAL_BLOCK_COUNT) {
-			index = PARTIAL_BLOCK_COUNT - 1;
-		}
-		result += PROGRESS_PARTIAL[index];
-		i++;
-	}
-	for (; i < PROGRESS_BAR_WIDTH; i++) {
-		result += PROGRESS_EMPTY;
-	}
-	result += PROGRESS_END;
-	result += " ";
-
-	Printer::RawPrint(OutputStream::STREAM_STDOUT, result);
-}
-
-void TerminalProgressBarDisplay::Update(double percentage) {
-	auto percentage_int = NormalizePercentage(percentage);
-	if (percentage_int == rendered_percentage) {
-		return;
-	}
-	PrintProgressInternal(percentage_int);
-	Printer::Flush(OutputStream::STREAM_STDOUT);
-	rendered_percentage = percentage_int;
-}
-
-void TerminalProgressBarDisplay::Finish() {
-	PrintProgressInternal(100);
-	Printer::RawPrint(OutputStream::STREAM_STDOUT, "\n");
-	Printer::Flush(OutputStream::STREAM_STDOUT);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/radix_partitioning.cpp b/src/duckdb/src/common/radix_partitioning.cpp
deleted file mode 100644
index 8b091a803..000000000
--- a/src/duckdb/src/common/radix_partitioning.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "duckdb/common/radix_partitioning.hpp"
-
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-
-namespace duckdb {
-
-//! Templated radix partitioning constants, can be templated to the number of radix bits
-template <idx_t radix_bits>
-struct RadixPartitioningConstants {
-public:
-	//! Bitmask of the upper bits starting at the 5th byte
-	static constexpr idx_t NUM_PARTITIONS = RadixPartitioning::NumberOfPartitions(radix_bits);
-	static constexpr idx_t SHIFT = RadixPartitioning::Shift(radix_bits);
-	static constexpr hash_t MASK = RadixPartitioning::Mask(radix_bits);
-
-public:
-	//! Apply bitmask and right shift to get a number between 0 and NUM_PARTITIONS
-	static hash_t ApplyMask(const hash_t hash) {
-		D_ASSERT((hash & MASK) >> SHIFT < NUM_PARTITIONS);
-		return (hash & MASK) >> SHIFT;
-	}
-};
-
-template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE RadixBitsSwitch(const idx_t radix_bits, ARGS &&... args) {
-	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
-	switch (radix_bits) {
-	case 0:
-		return OP::template Operation<0>(std::forward<ARGS>(args)...);
-	case 1:
-		return OP::template Operation<1>(std::forward<ARGS>(args)...);
-	case 2:
-		return OP::template Operation<2>(std::forward<ARGS>(args)...);
-	case 3:
-		return OP::template Operation<3>(std::forward<ARGS>(args)...);
-	case 4:
-		return OP::template Operation<4>(std::forward<ARGS>(args)...);
-	case 5: // LCOV_EXCL_START
-		return OP::template Operation<5>(std::forward<ARGS>(args)...);
-	case 6:
-		return OP::template Operation<6>(std::forward<ARGS>(args)...);
-	case 7:
-		return OP::template Operation<7>(std::forward<ARGS>(args)...);
-	case 8:
-		return OP::template Operation<8>(std::forward<ARGS>(args)...);
-	case 9:
-		return OP::template Operation<9>(std::forward<ARGS>(args)...);
-	case 10:
-		return OP::template Operation<10>(std::forward<ARGS>(args)...);
-	case 11:
-		return OP::template Operation<10>(std::forward<ARGS>(args)...);
-	case 12:
-		return OP::template Operation<10>(std::forward<ARGS>(args)...);
-	default:
-		throw InternalException(
-		    "radix_bits higher than RadixPartitioning::MAX_RADIX_BITS encountered in RadixBitsSwitch");
-	} // LCOV_EXCL_STOP
-}
-
-struct SelectFunctor {
-	template <idx_t radix_bits>
-	static idx_t Operation(Vector &hashes, const SelectionVector *sel, const idx_t count,
-	                       const ValidityMask &partition_mask, SelectionVector *true_sel, SelectionVector *false_sel) {
-		using CONSTANTS = RadixPartitioningConstants<radix_bits>;
-		return UnaryExecutor::Select<hash_t>(
-		    hashes, sel, count,
-		    [&](const hash_t hash) {
-			    const auto partition_idx = CONSTANTS::ApplyMask(hash);
-			    return partition_mask.RowIsValidUnsafe(partition_idx);
-		    },
-		    true_sel, false_sel);
-	}
-};
-
-idx_t RadixPartitioning::Select(Vector &hashes, const SelectionVector *sel, const idx_t count, const idx_t radix_bits,
-                                const ValidityMask &partition_mask, SelectionVector *true_sel,
-                                SelectionVector *false_sel) {
-	return RadixBitsSwitch<SelectFunctor, idx_t>(radix_bits, hashes, sel, count, partition_mask, true_sel, false_sel);
-}
-
-struct ComputePartitionIndicesFunctor {
-	template <idx_t radix_bits>
-	static void Operation(Vector &hashes, Vector &partition_indices, const SelectionVector &append_sel,
-	                      const idx_t append_count) {
-		using CONSTANTS = RadixPartitioningConstants<radix_bits>;
-		if (append_sel.IsSet()) {
-			auto hashes_sliced = Vector(hashes, append_sel, append_count);
-			UnaryExecutor::Execute<hash_t, hash_t>(hashes_sliced, partition_indices, append_count,
-			                                       [&](hash_t hash) { return CONSTANTS::ApplyMask(hash); });
-		} else {
-			UnaryExecutor::Execute<hash_t, hash_t>(hashes, partition_indices, append_count,
-			                                       [&](hash_t hash) { return CONSTANTS::ApplyMask(hash); });
-		}
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Column Data Partitioning
-//===--------------------------------------------------------------------===//
-RadixPartitionedColumnData::RadixPartitionedColumnData(ClientContext &context_p, vector<LogicalType> types_p,
-                                                       idx_t radix_bits_p, idx_t hash_col_idx_p)
-    : PartitionedColumnData(PartitionedColumnDataType::RADIX, context_p, std::move(types_p)), radix_bits(radix_bits_p),
-      hash_col_idx(hash_col_idx_p) {
-	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
-	D_ASSERT(hash_col_idx < types.size());
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	allocators->allocators.reserve(num_partitions);
-	for (idx_t i = 0; i < num_partitions; i++) {
-		CreateAllocator();
-		allocators->allocators.back()->SetPartitionIndex(i);
-	}
-	D_ASSERT(allocators->allocators.size() == num_partitions);
-}
-
-RadixPartitionedColumnData::RadixPartitionedColumnData(const RadixPartitionedColumnData &other)
-    : PartitionedColumnData(other), radix_bits(other.radix_bits), hash_col_idx(other.hash_col_idx) {
-	for (idx_t i = 0; i < RadixPartitioning::NumberOfPartitions(radix_bits); i++) {
-		partitions.emplace_back(CreatePartitionCollection(i));
-	}
-}
-
-RadixPartitionedColumnData::~RadixPartitionedColumnData() {
-}
-
-void RadixPartitionedColumnData::InitializeAppendStateInternal(PartitionedColumnDataAppendState &state) const {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	state.partition_append_states.reserve(num_partitions);
-	state.partition_buffers.reserve(num_partitions);
-	for (idx_t i = 0; i < num_partitions; i++) {
-		state.partition_append_states.emplace_back(make_uniq<ColumnDataAppendState>());
-		partitions[i]->InitializeAppend(*state.partition_append_states[i]);
-		state.partition_buffers.emplace_back(CreatePartitionBuffer());
-	}
-
-	// Initialize fixed-size map
-	state.fixed_partition_entries.resize(RadixPartitioning::NumberOfPartitions(radix_bits));
-}
-
-void RadixPartitionedColumnData::ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) {
-	D_ASSERT(partitions.size() == RadixPartitioning::NumberOfPartitions(radix_bits));
-	D_ASSERT(state.partition_buffers.size() == RadixPartitioning::NumberOfPartitions(radix_bits));
-	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, input.data[hash_col_idx], state.partition_indices,
-	                                                      *FlatVector::IncrementalSelectionVector(), input.size());
-}
-
-//===--------------------------------------------------------------------===//
-// Tuple Data Partitioning
-//===--------------------------------------------------------------------===//
-RadixPartitionedTupleData::RadixPartitionedTupleData(BufferManager &buffer_manager, const TupleDataLayout &layout_p,
-                                                     const idx_t radix_bits_p, const idx_t hash_col_idx_p)
-    : PartitionedTupleData(PartitionedTupleDataType::RADIX, buffer_manager, layout_p.Copy()), radix_bits(radix_bits_p),
-      hash_col_idx(hash_col_idx_p) {
-	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
-	D_ASSERT(hash_col_idx < layout.GetTypes().size());
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	allocators->allocators.reserve(num_partitions);
-	for (idx_t i = 0; i < num_partitions; i++) {
-		CreateAllocator();
-	}
-	D_ASSERT(allocators->allocators.size() == num_partitions);
-	Initialize();
-}
-
-RadixPartitionedTupleData::RadixPartitionedTupleData(const RadixPartitionedTupleData &other)
-    : PartitionedTupleData(other), radix_bits(other.radix_bits), hash_col_idx(other.hash_col_idx) {
-	Initialize();
-}
-
-RadixPartitionedTupleData::~RadixPartitionedTupleData() {
-}
-
-void RadixPartitionedTupleData::Initialize() {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	for (idx_t i = 0; i < num_partitions; i++) {
-		partitions.emplace_back(CreatePartitionCollection(i));
-		partitions.back()->SetPartitionIndex(i);
-	}
-}
-
-void RadixPartitionedTupleData::InitializeAppendStateInternal(PartitionedTupleDataAppendState &state,
-                                                              const TupleDataPinProperties properties) const {
-	// Init pin state per partition
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	state.partition_pin_states.reserve(num_partitions);
-	for (idx_t i = 0; i < num_partitions; i++) {
-		state.partition_pin_states.emplace_back(make_unsafe_uniq<TupleDataPinState>());
-		partitions[i]->InitializeAppend(*state.partition_pin_states[i], properties);
-	}
-
-	// Init single chunk state
-	auto column_count = layout.ColumnCount();
-	vector<column_t> column_ids;
-	column_ids.reserve(column_count);
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-		column_ids.emplace_back(col_idx);
-	}
-	partitions[0]->InitializeChunkState(state.chunk_state, std::move(column_ids));
-
-	// Initialize fixed-size map
-	state.fixed_partition_entries.resize(RadixPartitioning::NumberOfPartitions(radix_bits));
-}
-
-void RadixPartitionedTupleData::ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input,
-                                                        const SelectionVector &append_sel, const idx_t append_count) {
-	D_ASSERT(partitions.size() == RadixPartitioning::NumberOfPartitions(radix_bits));
-	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, input.data[hash_col_idx], state.partition_indices,
-	                                                      append_sel, append_count);
-}
-
-void RadixPartitionedTupleData::ComputePartitionIndices(Vector &row_locations, idx_t count,
-                                                        Vector &partition_indices) const {
-	Vector intermediate(LogicalType::HASH);
-	partitions[0]->Gather(row_locations, *FlatVector::IncrementalSelectionVector(), count, hash_col_idx, intermediate,
-	                      *FlatVector::IncrementalSelectionVector(), nullptr);
-	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, intermediate, partition_indices,
-	                                                      *FlatVector::IncrementalSelectionVector(), count);
-}
-
-void RadixPartitionedTupleData::RepartitionFinalizeStates(PartitionedTupleData &old_partitioned_data,
-                                                          PartitionedTupleData &new_partitioned_data,
-                                                          PartitionedTupleDataAppendState &state,
-                                                          idx_t finished_partition_idx) const {
-	D_ASSERT(old_partitioned_data.GetType() == PartitionedTupleDataType::RADIX &&
-	         new_partitioned_data.GetType() == PartitionedTupleDataType::RADIX);
-	const auto &old_radix_partitions = old_partitioned_data.Cast<RadixPartitionedTupleData>();
-	const auto &new_radix_partitions = new_partitioned_data.Cast<RadixPartitionedTupleData>();
-	const auto old_radix_bits = old_radix_partitions.GetRadixBits();
-	const auto new_radix_bits = new_radix_partitions.GetRadixBits();
-	D_ASSERT(new_radix_bits > old_radix_bits);
-
-	// We take the most significant digits as the partition index
-	// When repartitioning, e.g., partition 0 from "old" goes into the first N partitions in "new"
-	// When partition 0 is done, we can already finalize the append states, unpinning blocks
-	const auto multiplier = RadixPartitioning::NumberOfPartitions(new_radix_bits - old_radix_bits);
-	const auto from_idx = finished_partition_idx * multiplier;
-	const auto to_idx = from_idx + multiplier;
-	auto &partitions = new_partitioned_data.GetPartitions();
-	for (idx_t partition_index = from_idx; partition_index < to_idx; partition_index++) {
-		auto &partition = *partitions[partition_index];
-		auto &partition_pin_state = *state.partition_pin_states[partition_index];
-		partition.FinalizePinState(partition_pin_state);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/random_engine.cpp b/src/duckdb/src/common/random_engine.cpp
deleted file mode 100644
index cf558ea7a..000000000
--- a/src/duckdb/src/common/random_engine.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "pcg_random.hpp"
-
-#ifdef __linux__
-#include <sys/syscall.h>
-#include <unistd.h>
-#else
-#include <random>
-#endif
-namespace duckdb {
-
-struct RandomState {
-	RandomState() {
-	}
-
-	pcg32 pcg;
-};
-
-RandomEngine::RandomEngine(int64_t seed) : random_state(make_uniq<RandomState>()) {
-	if (seed < 0) {
-#ifdef __linux__
-		idx_t random_seed = 0;
-		auto result = syscall(SYS_getrandom, &random_seed, sizeof(random_seed), 0);
-		if (result == -1) {
-			// Something went wrong with the syscall, we use chrono
-			const auto now = std::chrono::high_resolution_clock::now();
-			random_seed = now.time_since_epoch().count();
-		}
-		random_state->pcg.seed(random_seed);
-#else
-		random_state->pcg.seed(pcg_extras::seed_seq_from<std::random_device>());
-#endif
-	} else {
-		random_state->pcg.seed(NumericCast<uint64_t>(seed));
-	}
-}
-
-RandomEngine::~RandomEngine() {
-}
-
-double RandomEngine::NextRandom(double min, double max) {
-	D_ASSERT(max >= min);
-	return min + (NextRandom() * (max - min));
-}
-
-double RandomEngine::NextRandom() {
-	auto uint64 = NextRandomInteger64();
-	return std::ldexp(uint64, -64);
-}
-
-double RandomEngine::NextRandom32(double min, double max) {
-	D_ASSERT(max >= min);
-	return min + (NextRandom32() * (max - min));
-}
-
-double RandomEngine::NextRandom32() {
-	auto uint32 = NextRandomInteger();
-	return std::ldexp(uint32, -32);
-}
-
-uint32_t RandomEngine::NextRandomInteger() {
-	return random_state->pcg();
-}
-
-uint64_t RandomEngine::NextRandomInteger64() {
-	return (static_cast<uint64_t>(NextRandomInteger()) << UINT64_C(32)) | static_cast<uint64_t>(NextRandomInteger());
-}
-
-uint32_t RandomEngine::NextRandomInteger(uint32_t min, uint32_t max) {
-	return min + static_cast<uint32_t>(NextRandom() * double(max - min));
-}
-
-uint32_t RandomEngine::NextRandomInteger32(uint32_t min, uint32_t max) {
-	return min + static_cast<uint32_t>(NextRandom32() * double(max - min));
-}
-
-void RandomEngine::SetSeed(uint64_t seed) {
-	random_state->pcg.seed(seed);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/re2_regex.cpp b/src/duckdb/src/common/re2_regex.cpp
deleted file mode 100644
index e934e105c..000000000
--- a/src/duckdb/src/common/re2_regex.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector.hpp"
-#include <memory>
-
-#include "duckdb/common/re2_regex.hpp"
-#include "re2/re2.h"
-
-namespace duckdb_re2 {
-
-static size_t GetMultibyteCharLength(const char c) {
-	if ((c & 0x80) == 0) {
-		return 1; // 1-byte character (ASCII)
-	} else if ((c & 0xE0) == 0xC0) {
-		return 2; // 2-byte character
-	} else if ((c & 0xF0) == 0xE0) {
-		return 3; // 3-byte character
-	} else if ((c & 0xF8) == 0xF0) {
-		return 4; // 4-byte character
-	} else {
-		return 0; // invalid UTF-8leading byte
-	}
-}
-
-Regex::Regex(const std::string &pattern, RegexOptions options) {
-	RE2::Options o;
-	o.set_case_sensitive(options == RegexOptions::CASE_INSENSITIVE);
-	regex = duckdb::make_shared_ptr<duckdb_re2::RE2>(StringPiece(pattern), o);
-}
-
-bool RegexSearchInternal(const char *input_data, size_t input_size, Match &match, const RE2 &regex, RE2::Anchor anchor,
-                         size_t start, size_t end) {
-	duckdb::vector<StringPiece> target_groups;
-	auto group_count = duckdb::UnsafeNumericCast<size_t>(regex.NumberOfCapturingGroups() + 1);
-	target_groups.resize(group_count);
-	match.groups.clear();
-	if (!regex.Match(StringPiece(input_data, input_size), start, end, anchor, target_groups.data(),
-	                 duckdb::UnsafeNumericCast<int>(group_count))) {
-		return false;
-	}
-	for (auto &group : target_groups) {
-		GroupMatch group_match;
-		group_match.text = group.ToString();
-		group_match.position = group.data() != nullptr ? duckdb::NumericCast<uint32_t>(group.data() - input_data) : 0;
-		match.groups.emplace_back(group_match);
-	}
-	return true;
-}
-
-bool RegexSearch(const std::string &input, Match &match, const Regex &regex) {
-	auto input_sz = input.size();
-	return RegexSearchInternal(input.c_str(), input_sz, match, regex.GetRegex(), RE2::UNANCHORED, 0, input_sz);
-}
-
-bool RegexMatch(const std::string &input, Match &match, const Regex &regex) {
-	auto input_sz = input.size();
-	return RegexSearchInternal(input.c_str(), input_sz, match, regex.GetRegex(), RE2::ANCHOR_BOTH, 0, input_sz);
-}
-
-bool RegexMatch(const char *start, const char *end, Match &match, const Regex &regex) {
-	auto sz = duckdb::UnsafeNumericCast<size_t>(end - start);
-	return RegexSearchInternal(start, sz, match, regex.GetRegex(), RE2::ANCHOR_BOTH, 0, sz);
-}
-
-bool RegexMatch(const std::string &input, const Regex &regex) {
-	Match nop_match;
-	auto input_sz = input.size();
-	return RegexSearchInternal(input.c_str(), input_sz, nop_match, regex.GetRegex(), RE2::ANCHOR_BOTH, 0, input_sz);
-}
-
-duckdb::vector<Match> RegexFindAll(const std::string &input, const Regex &regex) {
-	return RegexFindAll(input.c_str(), input.size(), regex.GetRegex());
-}
-
-duckdb::vector<Match> RegexFindAll(const char *input_data, size_t input_size, const RE2 &regex) {
-	duckdb::vector<Match> matches;
-	size_t position = 0;
-	Match match;
-	while (RegexSearchInternal(input_data, input_size, match, regex, RE2::UNANCHORED, position, input_size)) {
-		if (match.length(0)) {
-			position = match.position(0) + match.length(0);
-		} else { // match.length(0) == 0
-			auto next_char_length = GetMultibyteCharLength(input_data[match.position(0)]);
-			if (!next_char_length) {
-				throw duckdb::InvalidInputException("Invalid UTF-8 leading byte at position " +
-				                                    std::to_string(match.position(0) + 1));
-			}
-			if (match.position(0) + next_char_length < input_size) {
-				position = match.position(0) + next_char_length;
-			} else {
-				matches.emplace_back(match);
-				break;
-			}
-		}
-		matches.emplace_back(match);
-	}
-	return matches;
-}
-
-} // namespace duckdb_re2
diff --git a/src/duckdb/src/common/render_tree.cpp b/src/duckdb/src/common/render_tree.cpp
deleted file mode 100644
index 582d5e1ad..000000000
--- a/src/duckdb/src/common/render_tree.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-#include "duckdb/common/render_tree.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
-
-namespace duckdb {
-
-struct PipelineRenderNode {
-	explicit PipelineRenderNode(const PhysicalOperator &op) : op(op) {
-	}
-
-	const PhysicalOperator &op;
-	unique_ptr<PipelineRenderNode> child;
-};
-
-} // namespace duckdb
-
-namespace {
-
-using duckdb::MaxValue;
-using duckdb::PhysicalDelimJoin;
-using duckdb::PhysicalOperator;
-using duckdb::PhysicalOperatorType;
-using duckdb::PhysicalPositionalScan;
-using duckdb::PipelineRenderNode;
-using duckdb::RenderTreeNode;
-
-class TreeChildrenIterator {
-public:
-	template <class T>
-	static bool HasChildren(const T &op) {
-		return !op.children.empty();
-	}
-	template <class T>
-	static void Iterate(const T &op, const std::function<void(const T &child)> &callback) {
-		for (auto &child : op.children) {
-			callback(*child);
-		}
-	}
-};
-
-template <>
-bool TreeChildrenIterator::HasChildren(const PhysicalOperator &op) {
-	return !op.GetChildren().empty();
-}
-template <>
-void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
-                                   const std::function<void(const PhysicalOperator &child)> &callback) {
-	for (auto &child : op.GetChildren()) {
-		callback(child);
-	}
-}
-
-template <>
-bool TreeChildrenIterator::HasChildren(const PipelineRenderNode &op) {
-	return op.child.get();
-}
-
-template <>
-void TreeChildrenIterator::Iterate(const PipelineRenderNode &op,
-                                   const std::function<void(const PipelineRenderNode &child)> &callback) {
-	if (op.child) {
-		callback(*op.child);
-	}
-}
-
-} // namespace
-
-namespace duckdb {
-
-template <class T>
-static void GetTreeWidthHeight(const T &op, idx_t &width, idx_t &height) {
-	if (!TreeChildrenIterator::HasChildren(op)) {
-		width = 1;
-		height = 1;
-		return;
-	}
-	width = 0;
-	height = 0;
-
-	TreeChildrenIterator::Iterate<T>(op, [&](const T &child) {
-		idx_t child_width, child_height;
-		GetTreeWidthHeight<T>(child, child_width, child_height);
-		width += child_width;
-		height = MaxValue<idx_t>(height, child_height);
-	});
-	height++;
-}
-
-static unique_ptr<RenderTreeNode> CreateNode(const LogicalOperator &op) {
-	return make_uniq<RenderTreeNode>(op.GetName(), op.ParamsToString());
-}
-
-static unique_ptr<RenderTreeNode> CreateNode(const PhysicalOperator &op) {
-	return make_uniq<RenderTreeNode>(op.GetName(), op.ParamsToString());
-}
-
-static unique_ptr<RenderTreeNode> CreateNode(const PipelineRenderNode &op) {
-	return CreateNode(op.op);
-}
-
-static unique_ptr<RenderTreeNode> CreateNode(const ProfilingNode &op) {
-	auto &info = op.GetProfilingInfo();
-	InsertionOrderPreservingMap<string> extra_info;
-	if (info.Enabled(info.settings, MetricsType::EXTRA_INFO)) {
-		extra_info = op.GetProfilingInfo().extra_info;
-	}
-
-	string node_name = "QUERY";
-	if (op.depth > 0) {
-		node_name = info.GetMetricAsString(MetricsType::OPERATOR_TYPE);
-	}
-
-	auto result = make_uniq<RenderTreeNode>(node_name, extra_info);
-	if (info.Enabled(info.settings, MetricsType::OPERATOR_CARDINALITY)) {
-		auto cardinality = info.GetMetricAsString(MetricsType::OPERATOR_CARDINALITY);
-		result->extra_text[RenderTreeNode::CARDINALITY] = cardinality;
-	}
-	if (info.Enabled(info.settings, MetricsType::OPERATOR_TIMING)) {
-		auto value = info.metrics.at(MetricsType::OPERATOR_TIMING).GetValue<double>();
-		string timing = StringUtil::Format("%.2f", value);
-		result->extra_text[RenderTreeNode::TIMING] = timing + "s";
-	}
-	return result;
-}
-
-template <class T>
-static idx_t CreateTreeRecursive(RenderTree &result, const T &op, idx_t x, idx_t y) {
-	auto node = CreateNode(op);
-
-	if (!TreeChildrenIterator::HasChildren(op)) {
-		result.SetNode(x, y, std::move(node));
-		return 1;
-	}
-	idx_t width = 0;
-	// render the children of this node
-	TreeChildrenIterator::Iterate<T>(op, [&](const T &child) {
-		auto child_x = x + width;
-		auto child_y = y + 1;
-		node->AddChildPosition(child_x, child_y);
-		width += CreateTreeRecursive<T>(result, child, child_x, child_y);
-	});
-	result.SetNode(x, y, std::move(node));
-	return width;
-}
-
-template <class T>
-static unique_ptr<RenderTree> CreateTree(const T &op) {
-	idx_t width, height;
-	GetTreeWidthHeight<T>(op, width, height);
-
-	auto result = make_uniq<RenderTree>(width, height);
-
-	// now fill in the tree
-	CreateTreeRecursive<T>(*result, op, 0, 0);
-	return result;
-}
-
-RenderTree::RenderTree(idx_t width_p, idx_t height_p) : width(width_p), height(height_p) {
-	nodes = make_uniq_array<unique_ptr<RenderTreeNode>>((width + 1) * (height + 1));
-}
-
-optional_ptr<RenderTreeNode> RenderTree::GetNode(idx_t x, idx_t y) {
-	if (x >= width || y >= height) {
-		return nullptr;
-	}
-	return nodes[GetPosition(x, y)].get();
-}
-
-bool RenderTree::HasNode(idx_t x, idx_t y) {
-	if (x >= width || y >= height) {
-		return false;
-	}
-	return nodes[GetPosition(x, y)].get() != nullptr;
-}
-
-idx_t RenderTree::GetPosition(idx_t x, idx_t y) {
-	return y * width + x;
-}
-
-void RenderTree::SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node) {
-	nodes[GetPosition(x, y)] = std::move(node);
-}
-
-unique_ptr<RenderTree> RenderTree::CreateRenderTree(const LogicalOperator &op) {
-	return CreateTree<LogicalOperator>(op);
-}
-
-unique_ptr<RenderTree> RenderTree::CreateRenderTree(const PhysicalOperator &op) {
-	return CreateTree<PhysicalOperator>(op);
-}
-
-unique_ptr<RenderTree> RenderTree::CreateRenderTree(const ProfilingNode &op) {
-	return CreateTree<ProfilingNode>(op);
-}
-
-void RenderTree::SanitizeKeyNames() {
-	for (idx_t i = 0; i < width * height; i++) {
-		if (!nodes[i]) {
-			continue;
-		}
-		InsertionOrderPreservingMap<string> new_map;
-		for (auto &entry : nodes[i]->extra_text) {
-			auto key = entry.first;
-			if (StringUtil::StartsWith(key, "__")) {
-				key = StringUtil::Replace(key, "__", "");
-				key = StringUtil::Replace(key, "_", " ");
-				key = StringUtil::Title(key);
-			}
-			auto &value = entry.second;
-			new_map.insert(make_pair(key, value));
-		}
-		nodes[i]->extra_text = std::move(new_map);
-	}
-}
-
-unique_ptr<RenderTree> RenderTree::CreateRenderTree(const Pipeline &pipeline) {
-	auto operators = pipeline.GetOperators();
-	D_ASSERT(!operators.empty());
-	unique_ptr<PipelineRenderNode> node;
-	for (auto &op : operators) {
-		auto new_node = make_uniq<PipelineRenderNode>(op.get());
-		new_node->child = std::move(node);
-		node = std::move(new_node);
-	}
-	return CreateTree<PipelineRenderNode>(*node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_aggregate.cpp b/src/duckdb/src/common/row_operations/row_aggregate.cpp
deleted file mode 100644
index fb433eb5b..000000000
--- a/src/duckdb/src/common/row_operations/row_aggregate.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_operations/row_aggregate.cpp
-//
-//
-//===----------------------------------------------------------------------===//
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-
-namespace duckdb {
-
-void RowOperations::InitializeStates(TupleDataLayout &layout, Vector &addresses, const SelectionVector &sel,
-                                     idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	auto pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	auto &offsets = layout.GetOffsets();
-	auto aggr_idx = layout.ColumnCount();
-
-	for (const auto &aggr : layout.GetAggregates()) {
-		for (idx_t i = 0; i < count; ++i) {
-			auto row_idx = sel.get_index(i);
-			auto row = pointers[row_idx];
-			aggr.function.initialize(aggr.function, row + offsets[aggr_idx]);
-		}
-		++aggr_idx;
-	}
-}
-
-void RowOperations::DestroyStates(RowOperationsState &state, TupleDataLayout &layout, Vector &addresses, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), count);
-	for (const auto &aggr : layout.GetAggregates()) {
-		if (aggr.function.destructor) {
-			AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator);
-			aggr.function.destructor(addresses, aggr_input_data, count);
-		}
-		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses, UnsafeNumericCast<int64_t>(aggr.payload_size), count);
-	}
-}
-
-void RowOperations::UpdateStates(RowOperationsState &state, AggregateObject &aggr, Vector &addresses,
-                                 DataChunk &payload, idx_t arg_idx, idx_t count) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator);
-	aggr.function.update(aggr.child_count == 0 ? nullptr : &payload.data[arg_idx], aggr_input_data, aggr.child_count,
-	                     addresses, count);
-}
-
-void RowOperations::UpdateFilteredStates(RowOperationsState &state, AggregateFilterData &filter_data,
-                                         AggregateObject &aggr, Vector &addresses, DataChunk &payload, idx_t arg_idx) {
-	idx_t count = filter_data.ApplyFilter(payload);
-	if (count == 0) {
-		return;
-	}
-
-	Vector filtered_addresses(addresses, filter_data.true_sel, count);
-	filtered_addresses.Flatten(count);
-
-	UpdateStates(state, aggr, filtered_addresses, filter_data.filtered_payload, arg_idx, count);
-}
-
-void RowOperations::CombineStates(RowOperationsState &state, TupleDataLayout &layout, Vector &sources, Vector &targets,
-                                  idx_t count) {
-	if (count == 0) {
-		return;
-	}
-
-	//	Move to the first aggregate states
-	VectorOperations::AddInPlace(sources, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), count);
-	VectorOperations::AddInPlace(targets, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), count);
-
-	// Keep track of the offset
-	idx_t offset = layout.GetAggrOffset();
-
-	for (auto &aggr : layout.GetAggregates()) {
-		D_ASSERT(aggr.function.combine);
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator,
-		                                   AggregateCombineType::ALLOW_DESTRUCTIVE);
-		aggr.function.combine(sources, targets, aggr_input_data, count);
-
-		// Move to the next aggregate states
-		VectorOperations::AddInPlace(sources, UnsafeNumericCast<int64_t>(aggr.payload_size), count);
-		VectorOperations::AddInPlace(targets, UnsafeNumericCast<int64_t>(aggr.payload_size), count);
-
-		// Increment the offset
-		offset += aggr.payload_size;
-	}
-
-	// Now subtract the offset to get back to the original position
-	VectorOperations::AddInPlace(sources, -UnsafeNumericCast<int64_t>(offset), count);
-	VectorOperations::AddInPlace(targets, -UnsafeNumericCast<int64_t>(offset), count);
-}
-
-void RowOperations::FinalizeStates(RowOperationsState &state, TupleDataLayout &layout, Vector &addresses,
-                                   DataChunk &result, idx_t aggr_idx) {
-	// Copy the addresses
-	Vector addresses_copy(LogicalType::POINTER);
-	VectorOperations::Copy(addresses, addresses_copy, result.size(), 0, 0);
-
-	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses_copy, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), result.size());
-
-	auto &aggregates = layout.GetAggregates();
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &target = result.data[aggr_idx + i];
-		auto &aggr = aggregates[i];
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator);
-		aggr.function.finalize(addresses_copy, aggr_input_data, target, result.size(), 0);
-
-		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses_copy, UnsafeNumericCast<int64_t>(aggr.payload_size), result.size());
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_external.cpp b/src/duckdb/src/common/row_operations/row_external.cpp
deleted file mode 100644
index 161fa7501..000000000
--- a/src/duckdb/src/common/row_operations/row_external.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_operations/row_external.cpp
-//
-//
-//===----------------------------------------------------------------------===//
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-void RowOperations::SwizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count) {
-	const idx_t row_width = layout.GetRowWidth();
-	data_ptr_t heap_row_ptrs[STANDARD_VECTOR_SIZE];
-	idx_t done = 0;
-	while (done != count) {
-		const idx_t next = MinValue<idx_t>(count - done, STANDARD_VECTOR_SIZE);
-		const data_ptr_t row_ptr = base_row_ptr + done * row_width;
-		// Load heap row pointers
-		data_ptr_t heap_ptr_ptr = row_ptr + layout.GetHeapOffset();
-		for (idx_t i = 0; i < next; i++) {
-			heap_row_ptrs[i] = Load<data_ptr_t>(heap_ptr_ptr);
-			heap_ptr_ptr += row_width;
-		}
-		// Loop through the blob columns
-		for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-			auto physical_type = layout.GetTypes()[col_idx].InternalType();
-			if (TypeIsConstantSize(physical_type)) {
-				continue;
-			}
-			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
-			if (physical_type == PhysicalType::VARCHAR) {
-				data_ptr_t string_ptr = col_ptr + string_t::HEADER_SIZE;
-				for (idx_t i = 0; i < next; i++) {
-					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
-						// Overwrite the string pointer with the within-row offset (if not inlined)
-						Store<idx_t>(UnsafeNumericCast<idx_t>(Load<data_ptr_t>(string_ptr) - heap_row_ptrs[i]),
-						             string_ptr);
-					}
-					col_ptr += row_width;
-					string_ptr += row_width;
-				}
-			} else {
-				// Non-varchar blob columns
-				for (idx_t i = 0; i < next; i++) {
-					// Overwrite the column data pointer with the within-row offset
-					Store<idx_t>(UnsafeNumericCast<idx_t>(Load<data_ptr_t>(col_ptr) - heap_row_ptrs[i]), col_ptr);
-					col_ptr += row_width;
-				}
-			}
-		}
-		done += next;
-	}
-}
-
-void RowOperations::SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-                                       const idx_t count, const idx_t base_offset) {
-	const idx_t row_width = layout.GetRowWidth();
-	row_ptr += layout.GetHeapOffset();
-	idx_t cumulative_offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		Store<idx_t>(base_offset + cumulative_offset, row_ptr);
-		cumulative_offset += Load<uint32_t>(heap_base_ptr + cumulative_offset);
-		row_ptr += row_width;
-	}
-}
-
-void RowOperations::CopyHeapAndSwizzle(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-                                       data_ptr_t heap_ptr, const idx_t count) {
-	const auto row_width = layout.GetRowWidth();
-	const auto heap_offset = layout.GetHeapOffset();
-	for (idx_t i = 0; i < count; i++) {
-		// Figure out source and size
-		const auto source_heap_ptr = Load<data_ptr_t>(row_ptr + heap_offset);
-		const auto size = Load<uint32_t>(source_heap_ptr);
-		D_ASSERT(size >= sizeof(uint32_t));
-
-		// Copy and swizzle
-		memcpy(heap_ptr, source_heap_ptr, size);
-		Store<idx_t>(UnsafeNumericCast<idx_t>(heap_ptr - heap_base_ptr), row_ptr + heap_offset);
-
-		// Increment for next iteration
-		row_ptr += row_width;
-		heap_ptr += size;
-	}
-}
-
-void RowOperations::UnswizzleHeapPointer(const RowLayout &layout, const data_ptr_t base_row_ptr,
-                                         const data_ptr_t base_heap_ptr, const idx_t count) {
-	const auto row_width = layout.GetRowWidth();
-	data_ptr_t heap_ptr_ptr = base_row_ptr + layout.GetHeapOffset();
-	for (idx_t i = 0; i < count; i++) {
-		Store<data_ptr_t>(base_heap_ptr + Load<idx_t>(heap_ptr_ptr), heap_ptr_ptr);
-		heap_ptr_ptr += row_width;
-	}
-}
-
-static inline void VerifyUnswizzledString(const RowLayout &layout, const idx_t &col_idx, const data_ptr_t &row_ptr) {
-#ifdef DEBUG
-	if (layout.GetTypes()[col_idx].id() != LogicalTypeId::VARCHAR) {
-		return;
-	}
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	ValidityBytes row_mask(row_ptr, layout.ColumnCount());
-	if (row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-		auto str = Load<string_t>(row_ptr + layout.GetOffsets()[col_idx]);
-		str.Verify();
-	}
-#endif
-}
-
-void RowOperations::UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
-                                      const data_ptr_t base_heap_ptr, const idx_t count) {
-	const idx_t row_width = layout.GetRowWidth();
-	data_ptr_t heap_row_ptrs[STANDARD_VECTOR_SIZE];
-	idx_t done = 0;
-	while (done != count) {
-		const idx_t next = MinValue<idx_t>(count - done, STANDARD_VECTOR_SIZE);
-		const data_ptr_t row_ptr = base_row_ptr + done * row_width;
-		// Restore heap row pointers
-		data_ptr_t heap_ptr_ptr = row_ptr + layout.GetHeapOffset();
-		for (idx_t i = 0; i < next; i++) {
-			heap_row_ptrs[i] = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
-			Store<data_ptr_t>(heap_row_ptrs[i], heap_ptr_ptr);
-			heap_ptr_ptr += row_width;
-		}
-		// Loop through the blob columns
-		for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-			auto physical_type = layout.GetTypes()[col_idx].InternalType();
-			if (TypeIsConstantSize(physical_type)) {
-				continue;
-			}
-			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
-			if (physical_type == PhysicalType::VARCHAR) {
-				data_ptr_t string_ptr = col_ptr + string_t::HEADER_SIZE;
-				for (idx_t i = 0; i < next; i++) {
-					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
-						// Overwrite the string offset with the pointer (if not inlined)
-						Store<data_ptr_t>(heap_row_ptrs[i] + Load<idx_t>(string_ptr), string_ptr);
-						VerifyUnswizzledString(layout, col_idx, row_ptr + i * row_width);
-					}
-					col_ptr += row_width;
-					string_ptr += row_width;
-				}
-			} else {
-				// Non-varchar blob columns
-				for (idx_t i = 0; i < next; i++) {
-					// Overwrite the column data offset with the pointer
-					Store<data_ptr_t>(heap_row_ptrs[i] + Load<idx_t>(col_ptr), col_ptr);
-					col_ptr += row_width;
-				}
-			}
-		}
-		done += next;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_gather.cpp b/src/duckdb/src/common/row_operations/row_gather.cpp
deleted file mode 100644
index 40743279b..000000000
--- a/src/duckdb/src/common/row_operations/row_gather.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-//===--------------------------------------------------------------------===//
-// row_gather.cpp
-// Description: This file contains the implementation of the gather operators
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/constant_operators.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row/row_data_collection.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-template <class T>
-static void TemplatedGatherLoop(Vector &rows, const SelectionVector &row_sel, Vector &col,
-                                const SelectionVector &col_sel, idx_t count, const RowLayout &layout, idx_t col_no,
-                                idx_t build_size) {
-	// Precompute mask indexes
-	const auto &offsets = layout.GetOffsets();
-	const auto col_offset = offsets[col_no];
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	auto data = FlatVector::GetData<T>(col);
-	auto &col_mask = FlatVector::Validity(col);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto row_idx = row_sel.get_index(i);
-		auto row = ptrs[row_idx];
-		auto col_idx = col_sel.get_index(i);
-		data[col_idx] = Load<T>(row + col_offset);
-		ValidityBytes row_mask(row, layout.ColumnCount());
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-			if (build_size > STANDARD_VECTOR_SIZE && col_mask.AllValid()) {
-				//! We need to initialize the mask with the vector size.
-				col_mask.Initialize(build_size);
-			}
-			col_mask.SetInvalid(col_idx);
-		}
-	}
-}
-
-static void GatherVarchar(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-                          idx_t count, const RowLayout &layout, idx_t col_no, idx_t build_size,
-                          data_ptr_t base_heap_ptr) {
-	// Precompute mask indexes
-	const auto &offsets = layout.GetOffsets();
-	const auto col_offset = offsets[col_no];
-	const auto heap_offset = layout.GetHeapOffset();
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	auto data = FlatVector::GetData<string_t>(col);
-	auto &col_mask = FlatVector::Validity(col);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto row_idx = row_sel.get_index(i);
-		auto row = ptrs[row_idx];
-		auto col_idx = col_sel.get_index(i);
-		auto col_ptr = row + col_offset;
-		data[col_idx] = Load<string_t>(col_ptr);
-		ValidityBytes row_mask(row, layout.ColumnCount());
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-			if (build_size > STANDARD_VECTOR_SIZE && col_mask.AllValid()) {
-				//! We need to initialize the mask with the vector size.
-				col_mask.Initialize(build_size);
-			}
-			col_mask.SetInvalid(col_idx);
-		} else if (base_heap_ptr && Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
-			//	Not inline, so unswizzle the copied pointer the pointer
-			auto heap_ptr_ptr = row + heap_offset;
-			auto heap_row_ptr = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
-			auto string_ptr = data_ptr_t(data + col_idx) + string_t::HEADER_SIZE;
-			Store<data_ptr_t>(heap_row_ptr + Load<idx_t>(string_ptr), string_ptr);
-#ifdef DEBUG
-			data[col_idx].Verify();
-#endif
-		}
-	}
-}
-
-static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vector &col,
-                               const SelectionVector &col_sel, idx_t count, const RowLayout &layout, idx_t col_no,
-                               data_ptr_t base_heap_ptr) {
-	const auto &offsets = layout.GetOffsets();
-	const auto col_offset = offsets[col_no];
-	const auto heap_offset = layout.GetHeapOffset();
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-
-	// Build the gather locations
-	auto data_locations = make_unsafe_uniq_array_uninitialized<data_ptr_t>(count);
-	auto mask_locations = make_unsafe_uniq_array_uninitialized<data_ptr_t>(count);
-	for (idx_t i = 0; i < count; i++) {
-		auto row_idx = row_sel.get_index(i);
-		auto row = ptrs[row_idx];
-		mask_locations[i] = row;
-		auto col_ptr = ptrs[row_idx] + col_offset;
-		if (base_heap_ptr) {
-			auto heap_ptr_ptr = row + heap_offset;
-			auto heap_row_ptr = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
-			data_locations[i] = heap_row_ptr + Load<idx_t>(col_ptr);
-		} else {
-			data_locations[i] = Load<data_ptr_t>(col_ptr);
-		}
-	}
-
-	// Deserialise into the selected locations
-	NestedValidity parent_validity(mask_locations.get(), col_no);
-	RowOperations::HeapGather(col, count, col_sel, data_locations.get(), &parent_validity);
-}
-
-void RowOperations::Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-                           const idx_t count, const RowLayout &layout, const idx_t col_no, const idx_t build_size,
-                           data_ptr_t heap_ptr) {
-	D_ASSERT(rows.GetVectorType() == VectorType::FLAT_VECTOR);
-	D_ASSERT(rows.GetType().id() == LogicalTypeId::POINTER); // "Cannot gather from non-pointer type!"
-
-	col.SetVectorType(VectorType::FLAT_VECTOR);
-	switch (col.GetType().InternalType()) {
-	case PhysicalType::UINT8:
-		TemplatedGatherLoop<uint8_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedGatherLoop<uint16_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedGatherLoop<uint32_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedGatherLoop<uint64_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedGatherLoop<uhugeint_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedGatherLoop<int8_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGatherLoop<int16_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGatherLoop<int32_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGatherLoop<int64_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::INT128:
-		TemplatedGatherLoop<hugeint_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGatherLoop<float>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGatherLoop<double>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedGatherLoop<interval_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
-		break;
-	case PhysicalType::VARCHAR:
-		GatherVarchar(rows, row_sel, col, col_sel, count, layout, col_no, build_size, heap_ptr);
-		break;
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT:
-	case PhysicalType::ARRAY:
-		GatherNestedVector(rows, row_sel, col, col_sel, count, layout, col_no, heap_ptr);
-		break;
-	default:
-		throw InternalException("Unimplemented type for RowOperations::Gather");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_heap_gather.cpp b/src/duckdb/src/common/row_operations/row_heap_gather.cpp
deleted file mode 100644
index fa433c64e..000000000
--- a/src/duckdb/src/common/row_operations/row_heap_gather.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-template <class T>
-static void TemplatedHeapGather(Vector &v, const idx_t count, const SelectionVector &sel, data_ptr_t *key_locations) {
-	auto target = FlatVector::GetData<T>(v);
-
-	for (idx_t i = 0; i < count; ++i) {
-		const auto col_idx = sel.get_index(i);
-		target[col_idx] = Load<T>(key_locations[i]);
-		key_locations[i] += sizeof(T);
-	}
-}
-
-static void HeapGatherStringVector(Vector &v, const idx_t vcount, const SelectionVector &sel,
-                                   data_ptr_t *key_locations) {
-	const auto &validity = FlatVector::Validity(v);
-	auto target = FlatVector::GetData<string_t>(v);
-
-	for (idx_t i = 0; i < vcount; i++) {
-		const auto col_idx = sel.get_index(i);
-		if (!validity.RowIsValid(col_idx)) {
-			continue;
-		}
-		auto len = Load<uint32_t>(key_locations[i]);
-		key_locations[i] += sizeof(uint32_t);
-		target[col_idx] = StringVector::AddStringOrBlob(v, string_t(const_char_ptr_cast(key_locations[i]), len));
-		key_locations[i] += len;
-	}
-}
-
-static void HeapGatherStructVector(Vector &v, const idx_t vcount, const SelectionVector &sel,
-                                   data_ptr_t *key_locations) {
-	// struct must have a validitymask for its fields
-	auto &child_types = StructType::GetChildTypes(v.GetType());
-	const idx_t struct_validitymask_size = (child_types.size() + 7) / 8;
-	data_ptr_t struct_validitymask_locations[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < vcount; i++) {
-		// use key_locations as the validitymask, and create struct_key_locations
-		struct_validitymask_locations[i] = key_locations[i];
-		key_locations[i] += struct_validitymask_size;
-	}
-
-	// now deserialize into the struct vectors
-	auto &children = StructVector::GetEntries(v);
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		NestedValidity parent_validity(struct_validitymask_locations, i);
-		RowOperations::HeapGather(*children[i], vcount, sel, key_locations, &parent_validity);
-	}
-}
-
-static void HeapGatherListVector(Vector &v, const idx_t vcount, const SelectionVector &sel, data_ptr_t *key_locations) {
-	const auto &validity = FlatVector::Validity(v);
-
-	auto child_type = ListType::GetChildType(v.GetType());
-	auto list_data = ListVector::GetData(v);
-	data_ptr_t list_entry_locations[STANDARD_VECTOR_SIZE];
-
-	uint64_t entry_offset = ListVector::GetListSize(v);
-	for (idx_t i = 0; i < vcount; i++) {
-		const auto col_idx = sel.get_index(i);
-		if (!validity.RowIsValid(col_idx)) {
-			continue;
-		}
-		// read list length
-		auto entry_remaining = Load<uint64_t>(key_locations[i]);
-		key_locations[i] += sizeof(uint64_t);
-		// set list entry attributes
-		list_data[col_idx].length = entry_remaining;
-		list_data[col_idx].offset = entry_offset;
-		// skip over the validity mask
-		data_ptr_t validitymask_location = key_locations[i];
-		idx_t offset_in_byte = 0;
-		key_locations[i] += (entry_remaining + 7) / 8;
-		// entry sizes
-		data_ptr_t var_entry_size_ptr = nullptr;
-		if (!TypeIsConstantSize(child_type.InternalType())) {
-			var_entry_size_ptr = key_locations[i];
-			key_locations[i] += entry_remaining * sizeof(idx_t);
-		}
-
-		// now read the list data
-		while (entry_remaining > 0) {
-			auto next = MinValue(entry_remaining, (idx_t)STANDARD_VECTOR_SIZE);
-
-			// initialize a new vector to append
-			Vector append_vector(v.GetType());
-			append_vector.SetVectorType(v.GetVectorType());
-
-			auto &list_vec_to_append = ListVector::GetEntry(append_vector);
-
-			// set validity
-			//! Since we are constructing the vector, this will always be a flat vector.
-			auto &append_validity = FlatVector::Validity(list_vec_to_append);
-			for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-				append_validity.Set(entry_idx, *(validitymask_location) & (1 << offset_in_byte));
-				if (++offset_in_byte == 8) {
-					validitymask_location++;
-					offset_in_byte = 0;
-				}
-			}
-
-			// compute entry sizes and set locations where the list entries are
-			if (TypeIsConstantSize(child_type.InternalType())) {
-				// constant size list entries
-				const idx_t type_size = GetTypeIdSize(child_type.InternalType());
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += type_size;
-				}
-			} else {
-				// variable size list entries
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += Load<idx_t>(var_entry_size_ptr);
-					var_entry_size_ptr += sizeof(idx_t);
-				}
-			}
-
-			// now deserialize and add to listvector
-			RowOperations::HeapGather(list_vec_to_append, next, *FlatVector::IncrementalSelectionVector(),
-			                          list_entry_locations, nullptr);
-			ListVector::Append(v, list_vec_to_append, next);
-
-			// update for next iteration
-			entry_remaining -= next;
-			entry_offset += next;
-		}
-	}
-}
-
-static void HeapGatherArrayVector(Vector &v, const idx_t vcount, const SelectionVector &sel,
-                                  data_ptr_t *key_locations) {
-	// Setup
-	auto &child_type = ArrayType::GetChildType(v.GetType());
-	auto array_size = ArrayType::GetSize(v.GetType());
-	auto &child_vector = ArrayVector::GetEntry(v);
-	auto child_type_size = GetTypeIdSize(child_type.InternalType());
-	auto child_type_is_var_size = !TypeIsConstantSize(child_type.InternalType());
-
-	data_ptr_t array_entry_locations[STANDARD_VECTOR_SIZE];
-
-	// array must have a validitymask for its elements
-	auto array_validitymask_size = (array_size + 7) / 8;
-
-	for (idx_t i = 0; i < vcount; i++) {
-		// Setup validity mask
-		data_ptr_t array_validitymask_location = key_locations[i];
-		key_locations[i] += array_validitymask_size;
-
-		NestedValidity parent_validity(array_validitymask_location);
-
-		// The size of each variable size entry is stored after the validity mask
-		// (if the child type is variable size)
-		data_ptr_t var_entry_size_ptr = nullptr;
-		if (child_type_is_var_size) {
-			var_entry_size_ptr = key_locations[i];
-			key_locations[i] += array_size * sizeof(idx_t);
-		}
-
-		// row idx
-		const auto row_idx = sel.get_index(i);
-
-		idx_t array_start = row_idx * array_size;
-		idx_t elem_remaining = array_size;
-
-		while (elem_remaining > 0) {
-			auto chunk_size = MinValue(static_cast<idx_t>(STANDARD_VECTOR_SIZE), elem_remaining);
-
-			SelectionVector array_sel(STANDARD_VECTOR_SIZE);
-
-			if (child_type_is_var_size) {
-				// variable size list entries
-				for (idx_t elem_idx = 0; elem_idx < chunk_size; elem_idx++) {
-					array_entry_locations[elem_idx] = key_locations[i];
-					key_locations[i] += Load<idx_t>(var_entry_size_ptr);
-					var_entry_size_ptr += sizeof(idx_t);
-					array_sel.set_index(elem_idx, array_start + elem_idx);
-				}
-			} else {
-				// constant size list entries
-				for (idx_t elem_idx = 0; elem_idx < chunk_size; elem_idx++) {
-					array_entry_locations[elem_idx] = key_locations[i];
-					key_locations[i] += child_type_size;
-					array_sel.set_index(elem_idx, array_start + elem_idx);
-				}
-			}
-
-			// Pass on this array's validity mask to the child vector
-			RowOperations::HeapGather(child_vector, chunk_size, array_sel, array_entry_locations, &parent_validity);
-
-			elem_remaining -= chunk_size;
-			array_start += chunk_size;
-			parent_validity.OffsetListBy(chunk_size);
-		}
-	}
-}
-
-void RowOperations::HeapGather(Vector &v, const idx_t &vcount, const SelectionVector &sel, data_ptr_t *key_locations,
-                               optional_ptr<NestedValidity> parent_validity) {
-	v.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto &validity = FlatVector::Validity(v);
-	if (parent_validity) {
-		for (idx_t i = 0; i < vcount; i++) {
-			const auto valid = parent_validity->IsValid(i);
-			const auto col_idx = sel.get_index(i);
-			validity.Set(col_idx, valid);
-		}
-	}
-
-	auto type = v.GetType().InternalType();
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedHeapGather<int8_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT16:
-		TemplatedHeapGather<int16_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT32:
-		TemplatedHeapGather<int32_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT64:
-		TemplatedHeapGather<int64_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedHeapGather<uint8_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedHeapGather<uint16_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedHeapGather<uint32_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedHeapGather<uint64_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT128:
-		TemplatedHeapGather<hugeint_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedHeapGather<uhugeint_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedHeapGather<float>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedHeapGather<double>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedHeapGather<interval_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::VARCHAR:
-		HeapGatherStringVector(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::STRUCT:
-		HeapGatherStructVector(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::LIST:
-		HeapGatherListVector(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::ARRAY:
-		HeapGatherArrayVector(v, vcount, sel, key_locations);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented deserialize from row-format");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_heap_scatter.cpp b/src/duckdb/src/common/row_operations/row_heap_scatter.cpp
deleted file mode 100644
index 01cf7b589..000000000
--- a/src/duckdb/src/common/row_operations/row_heap_scatter.cpp
+++ /dev/null
@@ -1,581 +0,0 @@
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-NestedValidity::NestedValidity(data_ptr_t validitymask_location)
-    : list_validity_location(validitymask_location), struct_validity_locations(nullptr), entry_idx(0), idx_in_entry(0),
-      list_validity_offset(0) {
-}
-
-NestedValidity::NestedValidity(data_ptr_t *validitymask_locations, idx_t child_vector_index)
-    : list_validity_location(nullptr), struct_validity_locations(validitymask_locations), entry_idx(0), idx_in_entry(0),
-      list_validity_offset(0) {
-	ValidityBytes::GetEntryIndex(child_vector_index, entry_idx, idx_in_entry);
-}
-
-void NestedValidity::SetInvalid(idx_t idx) {
-	if (list_validity_location) {
-		// Is List
-
-		idx = idx + list_validity_offset;
-
-		idx_t list_entry_idx;
-		idx_t list_idx_in_entry;
-		ValidityBytes::GetEntryIndex(idx, list_entry_idx, list_idx_in_entry);
-		const auto bit = ~(1UL << list_idx_in_entry);
-		list_validity_location[list_entry_idx] &= bit;
-	} else {
-		// Is Struct
-		const auto bit = ~(1UL << idx_in_entry);
-		*(struct_validity_locations[idx] + entry_idx) &= bit;
-	}
-}
-
-void NestedValidity::OffsetListBy(idx_t offset) {
-	list_validity_offset += offset;
-}
-
-bool NestedValidity::IsValid(idx_t idx) {
-	if (list_validity_location) {
-		// Is List
-
-		idx = idx + list_validity_offset;
-
-		idx_t list_entry_idx;
-		idx_t list_idx_in_entry;
-		ValidityBytes::GetEntryIndex(idx, list_entry_idx, list_idx_in_entry);
-		const auto bit = (1UL << list_idx_in_entry);
-		return list_validity_location[list_entry_idx] & bit;
-	} else {
-		// Is Struct
-		const auto bit = (1UL << idx_in_entry);
-		return *(struct_validity_locations[idx] + entry_idx) & bit;
-	}
-}
-
-static void ComputeStringEntrySizes(UnifiedVectorFormat &vdata, idx_t entry_sizes[], const idx_t ser_count,
-                                    const SelectionVector &sel, const idx_t offset) {
-	auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
-	for (idx_t i = 0; i < ser_count; i++) {
-		auto idx = sel.get_index(i);
-		auto str_idx = vdata.sel->get_index(idx + offset);
-		if (vdata.validity.RowIsValid(str_idx)) {
-			entry_sizes[i] += sizeof(uint32_t) + strings[str_idx].GetSize();
-		}
-	}
-}
-
-static void ComputeStructEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-                                    const SelectionVector &sel, idx_t offset) {
-	// obtain child vectors
-	idx_t num_children;
-	auto &children = StructVector::GetEntries(v);
-	num_children = children.size();
-	// add struct validitymask size
-	const idx_t struct_validitymask_size = (num_children + 7) / 8;
-	for (idx_t i = 0; i < ser_count; i++) {
-		entry_sizes[i] += struct_validitymask_size;
-	}
-	// compute size of child vectors
-	for (auto &struct_vector : children) {
-		RowOperations::ComputeEntrySizes(*struct_vector, entry_sizes, vcount, ser_count, sel, offset);
-	}
-}
-
-static void ComputeListEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t ser_count,
-                                  const SelectionVector &sel, idx_t offset) {
-	auto list_data = ListVector::GetData(v);
-	auto &child_vector = ListVector::GetEntry(v);
-	idx_t list_entry_sizes[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < ser_count; i++) {
-		auto idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(idx + offset);
-		if (vdata.validity.RowIsValid(source_idx)) {
-			auto list_entry = list_data[source_idx];
-
-			// make room for list length, list validitymask
-			entry_sizes[i] += sizeof(list_entry.length);
-			entry_sizes[i] += (list_entry.length + 7) / 8;
-
-			// serialize size of each entry (if non-constant size)
-			if (!TypeIsConstantSize(ListType::GetChildType(v.GetType()).InternalType())) {
-				entry_sizes[i] += list_entry.length * sizeof(list_entry.length);
-			}
-
-			// compute size of each the elements in list_entry and sum them
-			auto entry_remaining = list_entry.length;
-			auto entry_offset = list_entry.offset;
-			while (entry_remaining > 0) {
-				// the list entry can span multiple vectors
-				auto next = MinValue((idx_t)STANDARD_VECTOR_SIZE, entry_remaining);
-
-				// compute and add to the total
-				std::fill_n(list_entry_sizes, next, 0);
-				RowOperations::ComputeEntrySizes(child_vector, list_entry_sizes, next, next,
-				                                 *FlatVector::IncrementalSelectionVector(), entry_offset);
-				for (idx_t list_idx = 0; list_idx < next; list_idx++) {
-					entry_sizes[i] += list_entry_sizes[list_idx];
-				}
-
-				// update for next iteration
-				entry_remaining -= next;
-				entry_offset += next;
-			}
-		}
-	}
-}
-
-static void ComputeArrayEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t ser_count,
-                                   const SelectionVector &sel, idx_t offset) {
-
-	auto array_size = ArrayType::GetSize(v.GetType());
-	auto child_vector = ArrayVector::GetEntry(v);
-
-	idx_t array_entry_sizes[STANDARD_VECTOR_SIZE];
-	const idx_t array_validitymask_size = (array_size + 7) / 8;
-
-	for (idx_t i = 0; i < ser_count; i++) {
-
-		// Validity for the array elements
-		entry_sizes[i] += array_validitymask_size;
-
-		// serialize size of each entry (if non-constant size)
-		if (!TypeIsConstantSize(ArrayType::GetChildType(v.GetType()).InternalType())) {
-			entry_sizes[i] += array_size * sizeof(idx_t);
-		}
-
-		auto elem_idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(elem_idx + offset);
-
-		auto array_start = source_idx * array_size;
-		auto elem_remaining = array_size;
-
-		// the array could span multiple vectors, so we divide it into chunks
-		while (elem_remaining > 0) {
-			auto chunk_size = MinValue(static_cast<idx_t>(STANDARD_VECTOR_SIZE), elem_remaining);
-
-			// compute and add to the total
-			std::fill_n(array_entry_sizes, chunk_size, 0);
-			RowOperations::ComputeEntrySizes(child_vector, array_entry_sizes, chunk_size, chunk_size,
-			                                 *FlatVector::IncrementalSelectionVector(), array_start);
-			for (idx_t arr_elem_idx = 0; arr_elem_idx < chunk_size; arr_elem_idx++) {
-				entry_sizes[i] += array_entry_sizes[arr_elem_idx];
-			}
-			// update for next iteration
-			elem_remaining -= chunk_size;
-			array_start += chunk_size;
-		}
-	}
-}
-
-void RowOperations::ComputeEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t vcount,
-                                      idx_t ser_count, const SelectionVector &sel, idx_t offset) {
-	const auto physical_type = v.GetType().InternalType();
-	if (TypeIsConstantSize(physical_type)) {
-		const auto type_size = GetTypeIdSize(physical_type);
-		for (idx_t i = 0; i < ser_count; i++) {
-			entry_sizes[i] += type_size;
-		}
-	} else {
-		switch (physical_type) {
-		case PhysicalType::VARCHAR:
-			ComputeStringEntrySizes(vdata, entry_sizes, ser_count, sel, offset);
-			break;
-		case PhysicalType::STRUCT:
-			ComputeStructEntrySizes(v, entry_sizes, vcount, ser_count, sel, offset);
-			break;
-		case PhysicalType::LIST:
-			ComputeListEntrySizes(v, vdata, entry_sizes, ser_count, sel, offset);
-			break;
-		case PhysicalType::ARRAY:
-			ComputeArrayEntrySizes(v, vdata, entry_sizes, ser_count, sel, offset);
-			break;
-		default:
-			// LCOV_EXCL_START
-			throw NotImplementedException("Column with variable size type %s cannot be serialized to row-format",
-			                              v.GetType().ToString());
-			// LCOV_EXCL_STOP
-		}
-	}
-}
-
-void RowOperations::ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-                                      const SelectionVector &sel, idx_t offset) {
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(vcount, vdata);
-	ComputeEntrySizes(v, vdata, entry_sizes, vcount, ser_count, sel, offset);
-}
-
-template <class T>
-static void TemplatedHeapScatter(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t count,
-                                 data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity,
-                                 idx_t offset) {
-	auto source = UnifiedVectorFormat::GetData<T>(vdata);
-	if (!parent_validity) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx + offset);
-
-			auto target = (T *)key_locations[i];
-			Store<T>(source[source_idx], data_ptr_cast(target));
-			key_locations[i] += sizeof(T);
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx + offset);
-
-			auto target = (T *)key_locations[i];
-			Store<T>(source[source_idx], data_ptr_cast(target));
-			key_locations[i] += sizeof(T);
-
-			// set the validitymask
-			if (!vdata.validity.RowIsValid(source_idx)) {
-				parent_validity->SetInvalid(i);
-			}
-		}
-	}
-}
-
-static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                    data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity,
-                                    idx_t offset) {
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(vcount, vdata);
-
-	auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
-	if (!parent_validity) {
-		for (idx_t i = 0; i < ser_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx + offset);
-			if (vdata.validity.RowIsValid(source_idx)) {
-				auto &string_entry = strings[source_idx];
-				// store string size
-				Store<uint32_t>(NumericCast<uint32_t>(string_entry.GetSize()), key_locations[i]);
-				key_locations[i] += sizeof(uint32_t);
-				// store the string
-				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
-				key_locations[i] += string_entry.GetSize();
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < ser_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx + offset);
-			if (vdata.validity.RowIsValid(source_idx)) {
-				auto &string_entry = strings[source_idx];
-				// store string size
-				Store<uint32_t>(NumericCast<uint32_t>(string_entry.GetSize()), key_locations[i]);
-				key_locations[i] += sizeof(uint32_t);
-				// store the string
-				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
-				key_locations[i] += string_entry.GetSize();
-			} else {
-				// set the validitymask
-				parent_validity->SetInvalid(i);
-			}
-		}
-	}
-}
-
-static void HeapScatterStructVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                    data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity,
-                                    idx_t offset) {
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(vcount, vdata);
-
-	auto &children = StructVector::GetEntries(v);
-	idx_t num_children = children.size();
-
-	// struct must have a validitymask for its fields
-	const idx_t struct_validitymask_size = (num_children + 7) / 8;
-	data_ptr_t struct_validitymask_locations[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < ser_count; i++) {
-		// initialize the struct validity mask
-		struct_validitymask_locations[i] = key_locations[i];
-		memset(struct_validitymask_locations[i], -1, struct_validitymask_size);
-		key_locations[i] += struct_validitymask_size;
-
-		// set whether the whole struct is null
-		auto idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(idx) + offset;
-		if (parent_validity && !vdata.validity.RowIsValid(source_idx)) {
-			parent_validity->SetInvalid(i);
-		}
-	}
-
-	// now serialize the struct vectors
-	for (idx_t i = 0; i < children.size(); i++) {
-		auto &struct_vector = *children[i];
-		NestedValidity struct_validity(struct_validitymask_locations, i);
-		RowOperations::HeapScatter(struct_vector, vcount, sel, ser_count, key_locations, &struct_validity, offset);
-	}
-}
-
-static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                  data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity,
-                                  idx_t offset) {
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(vcount, vdata);
-
-	auto list_data = ListVector::GetData(v);
-	auto &child_vector = ListVector::GetEntry(v);
-
-	UnifiedVectorFormat list_vdata;
-	child_vector.ToUnifiedFormat(ListVector::GetListSize(v), list_vdata);
-	auto child_type = ListType::GetChildType(v.GetType()).InternalType();
-
-	idx_t list_entry_sizes[STANDARD_VECTOR_SIZE];
-	data_ptr_t list_entry_locations[STANDARD_VECTOR_SIZE];
-
-	for (idx_t i = 0; i < ser_count; i++) {
-		auto idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(idx + offset);
-		if (!vdata.validity.RowIsValid(source_idx)) {
-			if (parent_validity) {
-				// set the row validitymask for this column to invalid
-				parent_validity->SetInvalid(i);
-			}
-			continue;
-		}
-		auto list_entry = list_data[source_idx];
-
-		// store list length
-		Store<uint64_t>(list_entry.length, key_locations[i]);
-		key_locations[i] += sizeof(list_entry.length);
-
-		// make room for the validitymask
-		data_ptr_t list_validitymask_location = key_locations[i];
-		idx_t entry_offset_in_byte = 0;
-		idx_t validitymask_size = (list_entry.length + 7) / 8;
-		memset(list_validitymask_location, -1, validitymask_size);
-		key_locations[i] += validitymask_size;
-
-		// serialize size of each entry (if non-constant size)
-		data_ptr_t var_entry_size_ptr = nullptr;
-		if (!TypeIsConstantSize(child_type)) {
-			var_entry_size_ptr = key_locations[i];
-			key_locations[i] += list_entry.length * sizeof(idx_t);
-		}
-
-		auto entry_remaining = list_entry.length;
-		auto entry_offset = list_entry.offset;
-		while (entry_remaining > 0) {
-			// the list entry can span multiple vectors
-			auto next = MinValue((idx_t)STANDARD_VECTOR_SIZE, entry_remaining);
-
-			// serialize list validity
-			for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-				auto list_idx = list_vdata.sel->get_index(entry_idx + entry_offset);
-				if (!list_vdata.validity.RowIsValid(list_idx)) {
-					*(list_validitymask_location) &= ~(1UL << entry_offset_in_byte);
-				}
-				if (++entry_offset_in_byte == 8) {
-					list_validitymask_location++;
-					entry_offset_in_byte = 0;
-				}
-			}
-
-			if (TypeIsConstantSize(child_type)) {
-				// constant size list entries: set list entry locations
-				const idx_t type_size = GetTypeIdSize(child_type);
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += type_size;
-				}
-			} else {
-				// variable size list entries: compute entry sizes and set list entry locations
-				std::fill_n(list_entry_sizes, next, 0);
-				RowOperations::ComputeEntrySizes(child_vector, list_entry_sizes, next, next,
-				                                 *FlatVector::IncrementalSelectionVector(), entry_offset);
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += list_entry_sizes[entry_idx];
-					Store<idx_t>(list_entry_sizes[entry_idx], var_entry_size_ptr);
-					var_entry_size_ptr += sizeof(idx_t);
-				}
-			}
-
-			// now serialize to the locations
-			RowOperations::HeapScatter(child_vector, ListVector::GetListSize(v),
-			                           *FlatVector::IncrementalSelectionVector(), next, list_entry_locations, nullptr,
-			                           entry_offset);
-
-			// update for next iteration
-			entry_remaining -= next;
-			entry_offset += next;
-		}
-	}
-}
-
-static void HeapScatterArrayVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                   data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity,
-                                   idx_t offset) {
-
-	auto &child_vector = ArrayVector::GetEntry(v);
-	auto array_size = ArrayType::GetSize(v.GetType());
-	auto child_type = ArrayType::GetChildType(v.GetType());
-	auto child_type_size = GetTypeIdSize(child_type.InternalType());
-	auto child_type_is_var_size = !TypeIsConstantSize(child_type.InternalType());
-
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(vcount, vdata);
-
-	UnifiedVectorFormat child_vdata;
-	child_vector.ToUnifiedFormat(ArrayVector::GetTotalSize(v), child_vdata);
-
-	data_ptr_t array_entry_locations[STANDARD_VECTOR_SIZE];
-	idx_t array_entry_sizes[STANDARD_VECTOR_SIZE];
-
-	// array must have a validitymask for its elements
-	auto array_validitymask_size = (array_size + 7) / 8;
-
-	for (idx_t i = 0; i < ser_count; i++) {
-		// Set if the whole array itself is null in the parent entry
-		auto source_idx = vdata.sel->get_index(sel.get_index(i) + offset);
-		if (parent_validity && !vdata.validity.RowIsValid(source_idx)) {
-			parent_validity->SetInvalid(i);
-		}
-
-		// Now we can serialize the array itself
-		// Every array starts with a validity mask for the children
-		data_ptr_t array_validitymask_location = key_locations[i];
-		memset(array_validitymask_location, -1, array_validitymask_size);
-		key_locations[i] += array_validitymask_size;
-
-		NestedValidity array_parent_validity(array_validitymask_location);
-
-		// If the array contains variable size entries, we reserve spaces for them here
-		data_ptr_t var_entry_size_ptr = nullptr;
-		if (child_type_is_var_size) {
-			var_entry_size_ptr = key_locations[i];
-			key_locations[i] += array_size * sizeof(idx_t);
-		}
-
-		// Then comes the elements
-		auto array_start = source_idx * array_size;
-		auto elem_remaining = array_size;
-
-		while (elem_remaining > 0) {
-			// the array elements can span multiple vectors, so we divide it into chunks
-			auto chunk_size = MinValue(static_cast<idx_t>(STANDARD_VECTOR_SIZE), elem_remaining);
-
-			// Setup the locations for the elements
-			if (child_type_is_var_size) {
-				// The elements are variable sized
-				std::fill_n(array_entry_sizes, chunk_size, 0);
-				RowOperations::ComputeEntrySizes(child_vector, array_entry_sizes, chunk_size, chunk_size,
-				                                 *FlatVector::IncrementalSelectionVector(), array_start);
-				for (idx_t elem_idx = 0; elem_idx < chunk_size; elem_idx++) {
-					array_entry_locations[elem_idx] = key_locations[i];
-					key_locations[i] += array_entry_sizes[elem_idx];
-
-					// Now store the size of the entry
-					Store<idx_t>(array_entry_sizes[elem_idx], var_entry_size_ptr);
-					var_entry_size_ptr += sizeof(idx_t);
-				}
-			} else {
-				// The elements are constant sized
-				for (idx_t elem_idx = 0; elem_idx < chunk_size; elem_idx++) {
-					array_entry_locations[elem_idx] = key_locations[i];
-					key_locations[i] += child_type_size;
-				}
-			}
-
-			RowOperations::HeapScatter(child_vector, ArrayVector::GetTotalSize(v),
-			                           *FlatVector::IncrementalSelectionVector(), chunk_size, array_entry_locations,
-			                           &array_parent_validity, array_start);
-
-			// update for next iteration
-			elem_remaining -= chunk_size;
-			array_start += chunk_size;
-			array_parent_validity.OffsetListBy(chunk_size);
-		}
-	}
-}
-
-void RowOperations::HeapScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity, idx_t offset) {
-	if (TypeIsConstantSize(v.GetType().InternalType())) {
-		UnifiedVectorFormat vdata;
-		v.ToUnifiedFormat(vcount, vdata);
-		RowOperations::HeapScatterVData(vdata, v.GetType().InternalType(), sel, ser_count, key_locations,
-		                                parent_validity, offset);
-	} else {
-		switch (v.GetType().InternalType()) {
-		case PhysicalType::VARCHAR:
-			HeapScatterStringVector(v, vcount, sel, ser_count, key_locations, parent_validity, offset);
-			break;
-		case PhysicalType::STRUCT:
-			HeapScatterStructVector(v, vcount, sel, ser_count, key_locations, parent_validity, offset);
-			break;
-		case PhysicalType::LIST:
-			HeapScatterListVector(v, vcount, sel, ser_count, key_locations, parent_validity, offset);
-			break;
-		case PhysicalType::ARRAY:
-			HeapScatterArrayVector(v, vcount, sel, ser_count, key_locations, parent_validity, offset);
-			break;
-		default:
-			// LCOV_EXCL_START
-			throw NotImplementedException("Serialization of variable length vector with type %s",
-			                              v.GetType().ToString());
-			// LCOV_EXCL_STOP
-		}
-	}
-}
-
-void RowOperations::HeapScatterVData(UnifiedVectorFormat &vdata, PhysicalType type, const SelectionVector &sel,
-                                     idx_t ser_count, data_ptr_t *key_locations,
-                                     optional_ptr<NestedValidity> parent_validity, idx_t offset) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedHeapScatter<int8_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::INT16:
-		TemplatedHeapScatter<int16_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::INT32:
-		TemplatedHeapScatter<int32_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::INT64:
-		TemplatedHeapScatter<int64_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedHeapScatter<uint8_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedHeapScatter<uint16_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedHeapScatter<uint32_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedHeapScatter<uint64_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::INT128:
-		TemplatedHeapScatter<hugeint_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedHeapScatter<uhugeint_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedHeapScatter<float>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedHeapScatter<double>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedHeapScatter<interval_t>(vdata, sel, ser_count, key_locations, parent_validity, offset);
-		break;
-	default:
-		throw NotImplementedException("FIXME: Serialize to of constant type column to row-format");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_matcher.cpp b/src/duckdb/src/common/row_operations/row_matcher.cpp
deleted file mode 100644
index d08ab9d4e..000000000
--- a/src/duckdb/src/common/row_operations/row_matcher.cpp
+++ /dev/null
@@ -1,434 +0,0 @@
-#include "duckdb/common/row_operations/row_matcher.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = TupleDataLayout::ValidityBytes;
-
-template <bool NO_MATCH_SEL, class T, class OP, bool LHS_ALL_VALID>
-static idx_t TemplatedMatchLoop(const TupleDataVectorFormat &lhs_format, SelectionVector &sel, const idx_t count,
-                                const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, const idx_t col_idx,
-                                SelectionVector *no_match_sel, idx_t &no_match_count) {
-	using COMPARISON_OP = ComparisonOperationWrapper<OP>;
-
-	// LHS
-	const auto &lhs_sel = *lhs_format.unified.sel;
-	const auto lhs_data = UnifiedVectorFormat::GetData<T>(lhs_format.unified);
-	const auto &lhs_validity = lhs_format.unified.validity;
-
-	// RHS
-	const auto rhs_locations = FlatVector::GetData<data_ptr_t>(rhs_row_locations);
-	const auto rhs_offset_in_row = rhs_layout.GetOffsets()[col_idx];
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	idx_t match_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		const auto idx = sel.get_index(i);
-
-		const auto lhs_idx = lhs_sel.get_index(idx);
-		const auto lhs_null = LHS_ALL_VALID ? false : !lhs_validity.RowIsValid(lhs_idx);
-
-		const auto &rhs_location = rhs_locations[idx];
-		const ValidityBytes rhs_mask(rhs_location, rhs_layout.ColumnCount());
-		const auto rhs_null = !rhs_mask.RowIsValid(rhs_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry);
-
-		if (COMPARISON_OP::template Operation<T>(lhs_data[lhs_idx], Load<T>(rhs_location + rhs_offset_in_row), lhs_null,
-		                                         rhs_null)) {
-			sel.set_index(match_count++, idx);
-		} else if (NO_MATCH_SEL) {
-			no_match_sel->set_index(no_match_count++, idx);
-		}
-	}
-	return match_count;
-}
-
-template <bool NO_MATCH_SEL, class T, class OP>
-static idx_t TemplatedMatch(Vector &, const TupleDataVectorFormat &lhs_format, SelectionVector &sel, const idx_t count,
-                            const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, const idx_t col_idx,
-                            const vector<MatchFunction> &, SelectionVector *no_match_sel, idx_t &no_match_count) {
-	if (lhs_format.unified.validity.AllValid()) {
-		return TemplatedMatchLoop<NO_MATCH_SEL, T, OP, true>(lhs_format, sel, count, rhs_layout, rhs_row_locations,
-		                                                     col_idx, no_match_sel, no_match_count);
-	} else {
-		return TemplatedMatchLoop<NO_MATCH_SEL, T, OP, false>(lhs_format, sel, count, rhs_layout, rhs_row_locations,
-		                                                      col_idx, no_match_sel, no_match_count);
-	}
-}
-
-template <bool NO_MATCH_SEL, class OP>
-static idx_t StructMatchEquality(Vector &lhs_vector, const TupleDataVectorFormat &lhs_format, SelectionVector &sel,
-                                 const idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
-                                 const idx_t col_idx, const vector<MatchFunction> &child_functions,
-                                 SelectionVector *no_match_sel, idx_t &no_match_count) {
-	using COMPARISON_OP = ComparisonOperationWrapper<OP>;
-
-	// LHS
-	const auto &lhs_sel = *lhs_format.unified.sel;
-	const auto &lhs_validity = lhs_format.unified.validity;
-
-	// RHS
-	const auto rhs_locations = FlatVector::GetData<data_ptr_t>(rhs_row_locations);
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	idx_t match_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		const auto idx = sel.get_index(i);
-
-		const auto lhs_idx = lhs_sel.get_index(idx);
-		const auto lhs_null = lhs_validity.AllValid() ? false : !lhs_validity.RowIsValid(lhs_idx);
-
-		const auto &rhs_location = rhs_locations[idx];
-		const ValidityBytes rhs_mask(rhs_location, rhs_layout.ColumnCount());
-		const auto rhs_null = !rhs_mask.RowIsValid(rhs_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry);
-
-		// For structs there is no value to compare, here we match NULLs and let recursion do the rest
-		// So we use the comparison only if rhs or LHS is NULL and COMPARE_NULL is true
-		if (!(lhs_null || rhs_null) ||
-		    (COMPARISON_OP::COMPARE_NULL && COMPARISON_OP::template Operation<uint32_t>(0, 0, lhs_null, rhs_null))) {
-			sel.set_index(match_count++, idx);
-		} else if (NO_MATCH_SEL) {
-			no_match_sel->set_index(no_match_count++, idx);
-		}
-	}
-
-	// Create a Vector of pointers to the start of the TupleDataLayout of the STRUCT
-	Vector rhs_struct_row_locations(LogicalType::POINTER);
-	const auto rhs_offset_in_row = rhs_layout.GetOffsets()[col_idx];
-	auto rhs_struct_locations = FlatVector::GetData<data_ptr_t>(rhs_struct_row_locations);
-	for (idx_t i = 0; i < match_count; i++) {
-		const auto idx = sel.get_index(i);
-		rhs_struct_locations[idx] = rhs_locations[idx] + rhs_offset_in_row;
-	}
-
-	// Get the struct layout and struct entries
-	const auto &rhs_struct_layout = rhs_layout.GetStructLayout(col_idx);
-	auto &lhs_struct_vectors = StructVector::GetEntries(lhs_vector);
-	D_ASSERT(rhs_struct_layout.ColumnCount() == lhs_struct_vectors.size());
-
-	for (idx_t struct_col_idx = 0; struct_col_idx < rhs_struct_layout.ColumnCount(); struct_col_idx++) {
-		auto &lhs_struct_vector = *lhs_struct_vectors[struct_col_idx];
-		auto &lhs_struct_format = lhs_format.children[struct_col_idx];
-		const auto &child_function = child_functions[struct_col_idx];
-		match_count = child_function.function(lhs_struct_vector, lhs_struct_format, sel, match_count, rhs_struct_layout,
-		                                      rhs_struct_row_locations, struct_col_idx, child_function.child_functions,
-		                                      no_match_sel, no_match_count);
-	}
-
-	return match_count;
-}
-
-template <typename OP>
-static idx_t SelectComparison(Vector &, Vector &, const SelectionVector &, idx_t, SelectionVector *,
-                              SelectionVector *) {
-	throw NotImplementedException("Unsupported list comparison operand for RowMatcher::GetMatchFunction");
-}
-
-template <>
-idx_t SelectComparison<Equals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<NotEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedNotEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<DistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                     SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctFrom(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<NotDistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NotDistinctFrom(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<GreaterThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                          SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<LessThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                 SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<LessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                       SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <bool NO_MATCH_SEL, class OP>
-static idx_t GenericNestedMatch(Vector &lhs_vector, const TupleDataVectorFormat &, SelectionVector &sel,
-                                const idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
-                                const idx_t col_idx, const vector<MatchFunction> &, SelectionVector *no_match_sel,
-                                idx_t &no_match_count) {
-	const auto &type = rhs_layout.GetTypes()[col_idx];
-
-	// Gather a dense Vector containing the column values being matched
-	Vector key(type);
-	const auto gather_function = TupleDataCollection::GetGatherFunction(type);
-	gather_function.function(rhs_layout, rhs_row_locations, col_idx, sel, count, key,
-	                         *FlatVector::IncrementalSelectionVector(), nullptr, gather_function.child_functions);
-	Vector::Verify(key, *FlatVector::IncrementalSelectionVector(), count);
-
-	// Densify the input column
-	Vector sliced(lhs_vector, sel, count);
-
-	if (NO_MATCH_SEL) {
-		SelectionVector no_match_sel_offset(no_match_sel->data() + no_match_count);
-		auto match_count = SelectComparison<OP>(sliced, key, sel, count, &sel, &no_match_sel_offset);
-		no_match_count += count - match_count;
-		return match_count;
-	}
-	return SelectComparison<OP>(sliced, key, sel, count, &sel, nullptr);
-}
-
-void RowMatcher::Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates) {
-	match_functions.reserve(predicates.size());
-	for (idx_t col_idx = 0; col_idx < predicates.size(); col_idx++) {
-		match_functions.push_back(GetMatchFunction(no_match_sel, layout.GetTypes()[col_idx], predicates[col_idx]));
-	}
-}
-
-void RowMatcher::Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates,
-                            vector<column_t> &columns) {
-
-	// The columns must have the same size as the predicates vector
-	D_ASSERT(columns.size() == predicates.size());
-
-	// The largest column_id must be smaller than the number of types to not cause an out-of-bounds error
-	D_ASSERT(*max_element(columns.begin(), columns.end()) < layout.GetTypes().size());
-
-	match_functions.reserve(predicates.size());
-	for (idx_t idx = 0; idx < predicates.size(); idx++) {
-		column_t col_idx = columns[idx];
-		match_functions.push_back(GetMatchFunction(no_match_sel, layout.GetTypes()[col_idx], predicates[idx]));
-	}
-}
-
-idx_t RowMatcher::Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel,
-                        idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
-                        SelectionVector *no_match_sel, idx_t &no_match_count) {
-	D_ASSERT(!match_functions.empty());
-	for (idx_t col_idx = 0; col_idx < match_functions.size(); col_idx++) {
-		const auto &match_function = match_functions[col_idx];
-		count =
-		    match_function.function(lhs.data[col_idx], lhs_formats[col_idx], sel, count, rhs_layout, rhs_row_locations,
-		                            col_idx, match_function.child_functions, no_match_sel, no_match_count);
-	}
-	return count;
-}
-
-idx_t RowMatcher::Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel,
-                        idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
-                        SelectionVector *no_match_sel, idx_t &no_match_count, const vector<column_t> &columns) {
-	D_ASSERT(!match_functions.empty());
-
-	// The column_ids must have the same size as the match_functions vector
-	D_ASSERT(columns.size() == match_functions.size());
-
-	// The largest column_id must be smaller than the number columns to not cause an out-of-bounds error
-	D_ASSERT(*max_element(columns.begin(), columns.end()) < lhs.ColumnCount());
-
-	for (idx_t fun_idx = 0; fun_idx < match_functions.size(); fun_idx++) {
-		// if we only care about specific columns, we need to use the column_ids to get the correct column index
-		// otherwise, we just use the fun_idx
-		const auto col_idx = columns[fun_idx];
-
-		const auto &match_function = match_functions[fun_idx];
-		count =
-		    match_function.function(lhs.data[col_idx], lhs_formats[col_idx], sel, count, rhs_layout, rhs_row_locations,
-		                            col_idx, match_function.child_functions, no_match_sel, no_match_count);
-	}
-	return count;
-}
-
-MatchFunction RowMatcher::GetMatchFunction(const bool no_match_sel, const LogicalType &type,
-                                           const ExpressionType predicate) {
-	return no_match_sel ? GetMatchFunction<true>(type, predicate) : GetMatchFunction<false>(type, predicate);
-}
-
-template <bool NO_MATCH_SEL>
-MatchFunction RowMatcher::GetMatchFunction(const LogicalType &type, const ExpressionType predicate) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		return GetMatchFunction<NO_MATCH_SEL, bool>(predicate);
-	case PhysicalType::INT8:
-		return GetMatchFunction<NO_MATCH_SEL, int8_t>(predicate);
-	case PhysicalType::INT16:
-		return GetMatchFunction<NO_MATCH_SEL, int16_t>(predicate);
-	case PhysicalType::INT32:
-		return GetMatchFunction<NO_MATCH_SEL, int32_t>(predicate);
-	case PhysicalType::INT64:
-		return GetMatchFunction<NO_MATCH_SEL, int64_t>(predicate);
-	case PhysicalType::INT128:
-		return GetMatchFunction<NO_MATCH_SEL, hugeint_t>(predicate);
-	case PhysicalType::UINT8:
-		return GetMatchFunction<NO_MATCH_SEL, uint8_t>(predicate);
-	case PhysicalType::UINT16:
-		return GetMatchFunction<NO_MATCH_SEL, uint16_t>(predicate);
-	case PhysicalType::UINT32:
-		return GetMatchFunction<NO_MATCH_SEL, uint32_t>(predicate);
-	case PhysicalType::UINT64:
-		return GetMatchFunction<NO_MATCH_SEL, uint64_t>(predicate);
-	case PhysicalType::UINT128:
-		return GetMatchFunction<NO_MATCH_SEL, uhugeint_t>(predicate);
-	case PhysicalType::FLOAT:
-		return GetMatchFunction<NO_MATCH_SEL, float>(predicate);
-	case PhysicalType::DOUBLE:
-		return GetMatchFunction<NO_MATCH_SEL, double>(predicate);
-	case PhysicalType::INTERVAL:
-		return GetMatchFunction<NO_MATCH_SEL, interval_t>(predicate);
-	case PhysicalType::VARCHAR:
-		return GetMatchFunction<NO_MATCH_SEL, string_t>(predicate);
-	case PhysicalType::STRUCT:
-		return GetStructMatchFunction<NO_MATCH_SEL>(type, predicate);
-	case PhysicalType::LIST:
-		return GetListMatchFunction<NO_MATCH_SEL>(predicate);
-	case PhysicalType::ARRAY:
-		// Same logic as for lists
-		return GetListMatchFunction<NO_MATCH_SEL>(predicate);
-	default:
-		throw InternalException("Unsupported PhysicalType for RowMatcher::GetMatchFunction: %s",
-		                        EnumUtil::ToString(type.InternalType()));
-	}
-}
-
-template <bool NO_MATCH_SEL, class T>
-MatchFunction RowMatcher::GetMatchFunction(const ExpressionType predicate) {
-	MatchFunction result;
-	switch (predicate) {
-	case ExpressionType::COMPARE_EQUAL:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, Equals>;
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, NotEquals>;
-		break;
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, DistinctFrom>;
-		break;
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, NotDistinctFrom>;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, GreaterThan>;
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, GreaterThanEquals>;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, LessThan>;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		result.function = TemplatedMatch<NO_MATCH_SEL, T, LessThanEquals>;
-		break;
-	default:
-		throw InternalException("Unsupported ExpressionType for RowMatcher::GetMatchFunction: %s",
-		                        EnumUtil::ToString(predicate));
-	}
-	return result;
-}
-
-template <bool NO_MATCH_SEL>
-MatchFunction RowMatcher::GetStructMatchFunction(const LogicalType &type, const ExpressionType predicate) {
-	// We perform equality conditions like it's just a row, but we cannot perform inequality conditions like a row,
-	// because for equality conditions we need to always loop through all columns, but for inequality conditions,
-	// we need to find the first inequality, so the loop looks very different
-	MatchFunction result;
-	ExpressionType child_predicate = predicate;
-	switch (predicate) {
-	case ExpressionType::COMPARE_EQUAL:
-		result.function = StructMatchEquality<NO_MATCH_SEL, Equals>;
-		child_predicate = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, NotEquals>;
-		return result;
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, DistinctFrom>;
-		return result;
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		result.function = StructMatchEquality<NO_MATCH_SEL, NotDistinctFrom>;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, GreaterThan>;
-		return result;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, GreaterThanEquals>;
-		return result;
-	case ExpressionType::COMPARE_LESSTHAN:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, LessThan>;
-		return result;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, LessThanEquals>;
-		return result;
-	default:
-		throw InternalException("Unsupported ExpressionType for RowMatcher::GetStructMatchFunction: %s",
-		                        EnumUtil::ToString(predicate));
-	}
-
-	result.child_functions.reserve(StructType::GetChildCount(type));
-	for (const auto &child_type : StructType::GetChildTypes(type)) {
-		result.child_functions.push_back(GetMatchFunction<NO_MATCH_SEL>(child_type.second, child_predicate));
-	}
-
-	return result;
-}
-
-template <bool NO_MATCH_SEL>
-MatchFunction RowMatcher::GetListMatchFunction(const ExpressionType predicate) {
-	MatchFunction result;
-	switch (predicate) {
-	case ExpressionType::COMPARE_EQUAL:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, Equals>;
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, NotEquals>;
-		break;
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, DistinctFrom>;
-		break;
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, NotDistinctFrom>;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, GreaterThan>;
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, GreaterThanEquals>;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, LessThan>;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		result.function = GenericNestedMatch<NO_MATCH_SEL, LessThanEquals>;
-		break;
-	default:
-		throw InternalException("Unsupported ExpressionType for RowMatcher::GetListMatchFunction: %s",
-		                        EnumUtil::ToString(predicate));
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_radix_scatter.cpp b/src/duckdb/src/common/row_operations/row_radix_scatter.cpp
deleted file mode 100644
index a85a71997..000000000
--- a/src/duckdb/src/common/row_operations/row_radix_scatter.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/radix.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-template <class T>
-void TemplatedRadixScatter(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
-                           data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
-                           const idx_t offset) {
-	auto source = UnifiedVectorFormat::GetData<T>(vdata);
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-				Radix::EncodeData<T>(key_locations[i] + 1, source[source_idx]);
-				// invert bits if desc
-				if (desc) {
-					for (idx_t s = 1; s < sizeof(T) + 1; s++) {
-						*(key_locations[i] + s) = ~*(key_locations[i] + s);
-					}
-				}
-			} else {
-				key_locations[i][0] = invalid;
-				memset(key_locations[i] + 1, '\0', sizeof(T));
-			}
-			key_locations[i] += sizeof(T) + 1;
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write value
-			Radix::EncodeData<T>(key_locations[i], source[source_idx]);
-			// invert bits if desc
-			if (desc) {
-				for (idx_t s = 0; s < sizeof(T); s++) {
-					*(key_locations[i] + s) = ~*(key_locations[i] + s);
-				}
-			}
-			key_locations[i] += sizeof(T);
-		}
-	}
-}
-
-void RadixScatterStringVector(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
-                              data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
-                              const idx_t prefix_len, idx_t offset) {
-	auto source = UnifiedVectorFormat::GetData<string_t>(vdata);
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-				Radix::EncodeStringDataPrefix(key_locations[i] + 1, source[source_idx], prefix_len);
-				// invert bits if desc
-				if (desc) {
-					for (idx_t s = 1; s < prefix_len + 1; s++) {
-						*(key_locations[i] + s) = ~*(key_locations[i] + s);
-					}
-				}
-			} else {
-				key_locations[i][0] = invalid;
-				memset(key_locations[i] + 1, '\0', prefix_len);
-			}
-			key_locations[i] += prefix_len + 1;
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write value
-			Radix::EncodeStringDataPrefix(key_locations[i], source[source_idx], prefix_len);
-			// invert bits if desc
-			if (desc) {
-				for (idx_t s = 0; s < prefix_len; s++) {
-					*(key_locations[i] + s) = ~*(key_locations[i] + s);
-				}
-			}
-			key_locations[i] += prefix_len;
-		}
-	}
-}
-
-void RadixScatterListVector(Vector &v, UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
-                            data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
-                            const idx_t prefix_len, const idx_t width, const idx_t offset) {
-	auto list_data = ListVector::GetData(v);
-	auto &child_vector = ListVector::GetEntry(v);
-	auto list_size = ListVector::GetListSize(v);
-	child_vector.Flatten(list_size);
-
-	// serialize null values
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			data_ptr_t &key_location = key_locations[i];
-			const data_ptr_t key_location_start = key_location;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				*key_location++ = valid;
-				auto &list_entry = list_data[source_idx];
-				if (list_entry.length > 0) {
-					// denote that the list is not empty with a 1
-					*key_location++ = 1;
-					RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
-					                            key_locations + i, false, true, false, prefix_len, width - 2,
-					                            list_entry.offset);
-				} else {
-					// denote that the list is empty with a 0
-					*key_location++ = 0;
-					// mark rest of bits as empty
-					memset(key_location, '\0', width - 2);
-					key_location += width - 2;
-				}
-				// invert bits if desc
-				if (desc) {
-					// skip over validity byte, handled by nulls first/last
-					for (key_location = key_location_start + 1; key_location < key_location_start + width;
-					     key_location++) {
-						*key_location = ~*key_location;
-					}
-				}
-			} else {
-				*key_location++ = invalid;
-				memset(key_location, '\0', width - 1);
-				key_location += width - 1;
-			}
-			D_ASSERT(key_location == key_location_start + width);
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			auto &list_entry = list_data[source_idx];
-			data_ptr_t &key_location = key_locations[i];
-			const data_ptr_t key_location_start = key_location;
-			if (list_entry.length > 0) {
-				// denote that the list is not empty with a 1
-				*key_location++ = 1;
-				RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
-				                            key_locations + i, false, true, false, prefix_len, width - 1,
-				                            list_entry.offset);
-			} else {
-				// denote that the list is empty with a 0
-				*key_location++ = 0;
-				// mark rest of bits as empty
-				memset(key_location, '\0', width - 1);
-				key_location += width - 1;
-			}
-			// invert bits if desc
-			if (desc) {
-				for (key_location = key_location_start; key_location < key_location_start + width; key_location++) {
-					*key_location = ~*key_location;
-				}
-			}
-			D_ASSERT(key_location == key_location_start + width);
-		}
-	}
-}
-
-void RadixScatterArrayVector(Vector &v, UnifiedVectorFormat &vdata, idx_t vcount, const SelectionVector &sel,
-                             idx_t add_count, data_ptr_t *key_locations, const bool desc, const bool has_null,
-                             const bool nulls_first, const idx_t prefix_len, idx_t width, const idx_t offset) {
-	auto &child_vector = ArrayVector::GetEntry(v);
-	auto array_size = ArrayType::GetSize(v.GetType());
-
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			data_ptr_t &key_location = key_locations[i];
-			const data_ptr_t key_location_start = key_location;
-
-			if (validity.RowIsValid(source_idx)) {
-				*key_location++ = valid;
-
-				auto array_offset = source_idx * array_size;
-				RowOperations::RadixScatter(child_vector, array_size, *FlatVector::IncrementalSelectionVector(), 1,
-				                            key_locations + i, false, true, false, prefix_len, width - 1, array_offset);
-
-				// invert bits if desc
-				if (desc) {
-					// skip over validity byte, handled by nulls first/last
-					for (key_location = key_location_start + 1; key_location < key_location_start + width;
-					     key_location++) {
-						*key_location = ~*key_location;
-					}
-				}
-			} else {
-				*key_location++ = invalid;
-				memset(key_location, '\0', width - 1);
-				key_location += width - 1;
-			}
-			D_ASSERT(key_location == key_location_start + width);
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			data_ptr_t &key_location = key_locations[i];
-			const data_ptr_t key_location_start = key_location;
-
-			auto array_offset = source_idx * array_size;
-			RowOperations::RadixScatter(child_vector, array_size, *FlatVector::IncrementalSelectionVector(), 1,
-			                            key_locations + i, false, true, false, prefix_len, width, array_offset);
-			// invert bits if desc
-			if (desc) {
-				for (key_location = key_location_start; key_location < key_location_start + width; key_location++) {
-					*key_location = ~*key_location;
-				}
-			}
-			D_ASSERT(key_location == key_location_start + width);
-		}
-	}
-}
-
-void RadixScatterStructVector(Vector &v, UnifiedVectorFormat &vdata, idx_t vcount, const SelectionVector &sel,
-                              idx_t add_count, data_ptr_t *key_locations, const bool desc, const bool has_null,
-                              const bool nulls_first, const idx_t prefix_len, idx_t width, const idx_t offset) {
-	// serialize null values
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-			} else {
-				key_locations[i][0] = invalid;
-				memset(key_locations[i] + 1, '\0', width - 1);
-			}
-			key_locations[i]++;
-		}
-		width--;
-	}
-	// serialize the struct
-	auto &child_vector = *StructVector::GetEntries(v)[0];
-	RowOperations::RadixScatter(child_vector, vcount, *FlatVector::IncrementalSelectionVector(), add_count,
-	                            key_locations, false, true, false, prefix_len, width, offset);
-	// invert bits if desc
-	if (desc) {
-		for (idx_t i = 0; i < add_count; i++) {
-			for (idx_t s = 0; s < width; s++) {
-				*(key_locations[i] - width + s) = ~*(key_locations[i] - width + s);
-			}
-		}
-	}
-}
-
-void RowOperations::RadixScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                 data_ptr_t *key_locations, bool desc, bool has_null, bool nulls_first,
-                                 idx_t prefix_len, idx_t width, idx_t offset) {
-#ifdef DEBUG
-	// initialize to verify written width later
-	auto key_locations_copy = make_uniq_array<data_ptr_t>(ser_count);
-	for (idx_t i = 0; i < ser_count; i++) {
-		key_locations_copy[i] = key_locations[i];
-	}
-#endif
-
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(vcount, vdata);
-	switch (v.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedRadixScatter<int8_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::INT16:
-		TemplatedRadixScatter<int16_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::INT32:
-		TemplatedRadixScatter<int32_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::INT64:
-		TemplatedRadixScatter<int64_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedRadixScatter<uint8_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedRadixScatter<uint16_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedRadixScatter<uint32_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedRadixScatter<uint64_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::INT128:
-		TemplatedRadixScatter<hugeint_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedRadixScatter<uhugeint_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedRadixScatter<float>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedRadixScatter<double>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedRadixScatter<interval_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, offset);
-		break;
-	case PhysicalType::VARCHAR:
-		RadixScatterStringVector(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, prefix_len, offset);
-		break;
-	case PhysicalType::LIST:
-		RadixScatterListVector(v, vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, prefix_len, width,
-		                       offset);
-		break;
-	case PhysicalType::STRUCT:
-		RadixScatterStructVector(v, vdata, vcount, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                         prefix_len, width, offset);
-		break;
-	case PhysicalType::ARRAY:
-		RadixScatterArrayVector(v, vdata, vcount, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                        prefix_len, width, offset);
-		break;
-	default:
-		throw NotImplementedException("Cannot ORDER BY column with type %s", v.GetType().ToString());
-	}
-
-#ifdef DEBUG
-	for (idx_t i = 0; i < ser_count; i++) {
-		D_ASSERT(key_locations[i] == key_locations_copy[i] + width);
-	}
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/row_operations/row_scatter.cpp b/src/duckdb/src/common/row_operations/row_scatter.cpp
deleted file mode 100644
index a535e1a27..000000000
--- a/src/duckdb/src/common/row_operations/row_scatter.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-//===--------------------------------------------------------------------===//
-// row_scatter.cpp
-// Description: This file contains the implementation of the row scattering
-//              operators
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/row/row_data_collection.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-#include "duckdb/common/types/selection_vector.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-template <class T>
-static void TemplatedScatter(UnifiedVectorFormat &col, Vector &rows, const SelectionVector &sel, const idx_t count,
-                             const idx_t col_offset, const idx_t col_no, const idx_t col_count) {
-	auto data = UnifiedVectorFormat::GetData<T>(col);
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-
-	if (!col.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto col_idx = col.sel->get_index(idx);
-			auto row = ptrs[idx];
-
-			auto isnull = !col.validity.RowIsValid(col_idx);
-			T store_value = isnull ? NullValue<T>() : data[col_idx];
-			Store<T>(store_value, row + col_offset);
-			if (isnull) {
-				ValidityBytes col_mask(ptrs[idx], col_count);
-				col_mask.SetInvalidUnsafe(col_no);
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto col_idx = col.sel->get_index(idx);
-			auto row = ptrs[idx];
-
-			Store<T>(data[col_idx], row + col_offset);
-		}
-	}
-}
-
-static void ComputeStringEntrySizes(const UnifiedVectorFormat &col, idx_t entry_sizes[], const SelectionVector &sel,
-                                    const idx_t count, const idx_t offset = 0) {
-	auto data = UnifiedVectorFormat::GetData<string_t>(col);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto col_idx = col.sel->get_index(idx) + offset;
-		const auto &str = data[col_idx];
-		if (col.validity.RowIsValid(col_idx) && !str.IsInlined()) {
-			entry_sizes[i] += str.GetSize();
-		}
-	}
-}
-
-static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr_t str_locations[],
-                                const SelectionVector &sel, const idx_t count, const idx_t col_offset,
-                                const idx_t col_no, const idx_t col_count) {
-	auto string_data = UnifiedVectorFormat::GetData<string_t>(col);
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-
-	// Write out zero length to avoid swizzling problems.
-	const string_t null(nullptr, 0);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto col_idx = col.sel->get_index(idx);
-		auto row = ptrs[idx];
-		if (!col.validity.RowIsValid(col_idx)) {
-			ValidityBytes col_mask(row, col_count);
-			col_mask.SetInvalidUnsafe(col_no);
-			Store<string_t>(null, row + col_offset);
-		} else if (string_data[col_idx].IsInlined()) {
-			Store<string_t>(string_data[col_idx], row + col_offset);
-		} else {
-			const auto &str = string_data[col_idx];
-			string_t inserted(const_char_ptr_cast(str_locations[i]), UnsafeNumericCast<uint32_t>(str.GetSize()));
-			memcpy(inserted.GetDataWriteable(), str.GetData(), str.GetSize());
-			str_locations[i] += str.GetSize();
-			inserted.Finalize();
-			Store<string_t>(inserted, row + col_offset);
-		}
-	}
-}
-
-static void ScatterNestedVector(Vector &vec, UnifiedVectorFormat &col, Vector &rows, data_ptr_t data_locations[],
-                                const SelectionVector &sel, const idx_t count, const idx_t col_offset,
-                                const idx_t col_no, const idx_t vcount) {
-	// Store pointers to the data in the row
-	// Do this first because SerializeVector destroys the locations
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	data_ptr_t validitymask_locations[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto row = ptrs[idx];
-		validitymask_locations[i] = row;
-
-		Store<data_ptr_t>(data_locations[i], row + col_offset);
-	}
-
-	// Serialise the data
-	NestedValidity parent_validity(validitymask_locations, col_no);
-	RowOperations::HeapScatter(vec, vcount, sel, count, data_locations, &parent_validity);
-}
-
-void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
-                            RowDataCollection &string_heap, const SelectionVector &sel, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-
-	// Set the validity mask for each row before inserting data
-	idx_t column_count = layout.ColumnCount();
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	for (idx_t i = 0; i < count; ++i) {
-		auto row_idx = sel.get_index(i);
-		auto row = ptrs[row_idx];
-		ValidityBytes(row, column_count).SetAllValid(layout.ColumnCount());
-	}
-
-	const auto vcount = columns.size();
-	auto &offsets = layout.GetOffsets();
-	auto &types = layout.GetTypes();
-
-	// Compute the entry size of the variable size columns
-	vector<BufferHandle> handles;
-	data_ptr_t data_locations[STANDARD_VECTOR_SIZE];
-	if (!layout.AllConstant()) {
-		idx_t entry_sizes[STANDARD_VECTOR_SIZE];
-		std::fill_n(entry_sizes, count, sizeof(uint32_t));
-		for (idx_t col_no = 0; col_no < types.size(); col_no++) {
-			if (TypeIsConstantSize(types[col_no].InternalType())) {
-				continue;
-			}
-
-			auto &vec = columns.data[col_no];
-			auto &col = col_data[col_no];
-			switch (types[col_no].InternalType()) {
-			case PhysicalType::VARCHAR:
-				ComputeStringEntrySizes(col, entry_sizes, sel, count);
-				break;
-			case PhysicalType::LIST:
-			case PhysicalType::STRUCT:
-			case PhysicalType::ARRAY:
-				RowOperations::ComputeEntrySizes(vec, col, entry_sizes, vcount, count, sel);
-				break;
-			default:
-				throw InternalException("Unsupported type for RowOperations::Scatter");
-			}
-		}
-
-		// Build out the buffer space
-		handles = string_heap.Build(count, data_locations, entry_sizes);
-
-		// Serialize information that is needed for swizzling if the computation goes out-of-core
-		const idx_t heap_pointer_offset = layout.GetHeapOffset();
-		for (idx_t i = 0; i < count; i++) {
-			auto row_idx = sel.get_index(i);
-			auto row = ptrs[row_idx];
-			// Pointer to this row in the heap block
-			Store<data_ptr_t>(data_locations[i], row + heap_pointer_offset);
-			// Row size is stored in the heap in front of each row
-			Store<uint32_t>(NumericCast<uint32_t>(entry_sizes[i]), data_locations[i]);
-			data_locations[i] += sizeof(uint32_t);
-		}
-	}
-
-	for (idx_t col_no = 0; col_no < types.size(); col_no++) {
-		auto &vec = columns.data[col_no];
-		auto &col = col_data[col_no];
-		auto col_offset = offsets[col_no];
-
-		switch (types[col_no].InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			TemplatedScatter<int8_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::INT16:
-			TemplatedScatter<int16_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::INT32:
-			TemplatedScatter<int32_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::INT64:
-			TemplatedScatter<int64_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::UINT8:
-			TemplatedScatter<uint8_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::UINT16:
-			TemplatedScatter<uint16_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::UINT32:
-			TemplatedScatter<uint32_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::UINT64:
-			TemplatedScatter<uint64_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::INT128:
-			TemplatedScatter<hugeint_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::UINT128:
-			TemplatedScatter<uhugeint_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::FLOAT:
-			TemplatedScatter<float>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::DOUBLE:
-			TemplatedScatter<double>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::INTERVAL:
-			TemplatedScatter<interval_t>(col, rows, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::VARCHAR:
-			ScatterStringVector(col, rows, data_locations, sel, count, col_offset, col_no, column_count);
-			break;
-		case PhysicalType::LIST:
-		case PhysicalType::STRUCT:
-		case PhysicalType::ARRAY:
-			ScatterNestedVector(vec, col, rows, data_locations, sel, count, col_offset, col_no, vcount);
-			break;
-		default:
-			throw InternalException("Unsupported type for RowOperations::Scatter");
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/serializer/binary_deserializer.cpp b/src/duckdb/src/common/serializer/binary_deserializer.cpp
deleted file mode 100644
index 0fec7bea6..000000000
--- a/src/duckdb/src/common/serializer/binary_deserializer.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-
-namespace duckdb {
-
-//-------------------------------------------------------------------------
-// Nested Type Hooks
-//-------------------------------------------------------------------------
-void BinaryDeserializer::OnPropertyBegin(const field_id_t field_id, const char *) {
-	auto field = NextField();
-	if (field != field_id) {
-		throw SerializationException("Failed to deserialize: field id mismatch, expected: %d, got: %d", field_id,
-		                             field);
-	}
-}
-
-void BinaryDeserializer::OnPropertyEnd() {
-}
-
-bool BinaryDeserializer::OnOptionalPropertyBegin(const field_id_t field_id, const char *s) {
-	auto next_field = PeekField();
-	auto present = next_field == field_id;
-	if (present) {
-		ConsumeField();
-	}
-	return present;
-}
-
-void BinaryDeserializer::OnOptionalPropertyEnd(bool present) {
-}
-
-void BinaryDeserializer::OnObjectBegin() {
-	nesting_level++;
-}
-
-void BinaryDeserializer::OnObjectEnd() {
-	auto next_field = NextField();
-	if (next_field != MESSAGE_TERMINATOR_FIELD_ID) {
-		throw SerializationException("Failed to deserialize: expected end of object, but found field id: %d",
-		                             next_field);
-	}
-	nesting_level--;
-}
-
-idx_t BinaryDeserializer::OnListBegin() {
-	return VarIntDecode<idx_t>();
-}
-
-void BinaryDeserializer::OnListEnd() {
-}
-
-bool BinaryDeserializer::OnNullableBegin() {
-	return ReadBool();
-}
-
-void BinaryDeserializer::OnNullableEnd() {
-}
-
-//-------------------------------------------------------------------------
-// Primitive Types
-//-------------------------------------------------------------------------
-bool BinaryDeserializer::ReadBool() {
-	return static_cast<bool>(ReadPrimitive<uint8_t>());
-}
-
-char BinaryDeserializer::ReadChar() {
-	return ReadPrimitive<char>();
-}
-
-int8_t BinaryDeserializer::ReadSignedInt8() {
-	return VarIntDecode<int8_t>();
-}
-
-uint8_t BinaryDeserializer::ReadUnsignedInt8() {
-	return VarIntDecode<uint8_t>();
-}
-
-int16_t BinaryDeserializer::ReadSignedInt16() {
-	return VarIntDecode<int16_t>();
-}
-
-uint16_t BinaryDeserializer::ReadUnsignedInt16() {
-	return VarIntDecode<uint16_t>();
-}
-
-int32_t BinaryDeserializer::ReadSignedInt32() {
-	return VarIntDecode<int32_t>();
-}
-
-uint32_t BinaryDeserializer::ReadUnsignedInt32() {
-	return VarIntDecode<uint32_t>();
-}
-
-int64_t BinaryDeserializer::ReadSignedInt64() {
-	return VarIntDecode<int64_t>();
-}
-
-uint64_t BinaryDeserializer::ReadUnsignedInt64() {
-	return VarIntDecode<uint64_t>();
-}
-
-float BinaryDeserializer::ReadFloat() {
-	auto value = ReadPrimitive<float>();
-	return value;
-}
-
-double BinaryDeserializer::ReadDouble() {
-	auto value = ReadPrimitive<double>();
-	return value;
-}
-
-string BinaryDeserializer::ReadString() {
-	auto len = VarIntDecode<uint32_t>();
-	if (len == 0) {
-		return string();
-	}
-	auto buffer = make_unsafe_uniq_array_uninitialized<data_t>(len);
-	ReadData(buffer.get(), len);
-	return string(const_char_ptr_cast(buffer.get()), len);
-}
-
-hugeint_t BinaryDeserializer::ReadHugeInt() {
-	auto upper = VarIntDecode<int64_t>();
-	auto lower = VarIntDecode<uint64_t>();
-	return hugeint_t(upper, lower);
-}
-
-uhugeint_t BinaryDeserializer::ReadUhugeInt() {
-	auto upper = VarIntDecode<uint64_t>();
-	auto lower = VarIntDecode<uint64_t>();
-	return uhugeint_t(upper, lower);
-}
-
-void BinaryDeserializer::ReadDataPtr(data_ptr_t &ptr_p, idx_t count) {
-	auto len = VarIntDecode<uint64_t>();
-	if (len != count) {
-		throw SerializationException("Tried to read blob of %d size, but only %d elements are available", count, len);
-	}
-	ReadData(ptr_p, count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/serializer/binary_serializer.cpp b/src/duckdb/src/common/serializer/binary_serializer.cpp
deleted file mode 100644
index 8ec78c905..000000000
--- a/src/duckdb/src/common/serializer/binary_serializer.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-#include "duckdb/common/serializer/binary_serializer.hpp"
-
-#ifdef DEBUG
-#include "duckdb/common/string_util.hpp"
-#endif
-
-namespace duckdb {
-
-void BinarySerializer::OnPropertyBegin(const field_id_t field_id, const char *tag) {
-	// Just write the field id straight up
-	Write<field_id_t>(field_id);
-#ifdef DEBUG
-	// First of check that we are inside an object
-	if (debug_stack.empty()) {
-		throw InternalException("OnPropertyBegin called outside of object");
-	}
-
-	// Check that the tag is unique
-	auto &state = debug_stack.back();
-	auto &seen_field_ids = state.seen_field_ids;
-	auto &seen_field_tags = state.seen_field_tags;
-	auto &seen_fields = state.seen_fields;
-
-	if (seen_field_ids.find(field_id) != seen_field_ids.end() || seen_field_tags.find(tag) != seen_field_tags.end()) {
-		string all_fields;
-		for (auto &field : seen_fields) {
-			all_fields += StringUtil::Format("\"%s\":%d ", field.first, field.second);
-		}
-		throw InternalException("Duplicate field id/tag in field: \"%s\":%d, other fields: %s", tag, field_id,
-		                        all_fields);
-	}
-
-	seen_field_ids.insert(field_id);
-	seen_field_tags.insert(tag);
-	seen_fields.emplace_back(tag, field_id);
-#else
-	(void)tag;
-#endif
-}
-
-void BinarySerializer::OnPropertyEnd() {
-	// Nothing to do here
-}
-
-void BinarySerializer::OnOptionalPropertyBegin(const field_id_t field_id, const char *tag, bool present) {
-	// Dont write anything at all if the property is not present
-	if (present) {
-		OnPropertyBegin(field_id, tag);
-	}
-}
-
-void BinarySerializer::OnOptionalPropertyEnd(bool present) {
-	// Nothing to do here
-}
-
-//-------------------------------------------------------------------------
-// Nested Type Hooks
-//-------------------------------------------------------------------------
-void BinarySerializer::OnObjectBegin() {
-#ifdef DEBUG
-	debug_stack.emplace_back();
-#endif
-}
-
-void BinarySerializer::OnObjectEnd() {
-#ifdef DEBUG
-	debug_stack.pop_back();
-#endif
-	// Write object terminator
-	Write<field_id_t>(MESSAGE_TERMINATOR_FIELD_ID);
-}
-
-void BinarySerializer::OnListBegin(idx_t count) {
-	VarIntEncode(count);
-}
-
-void BinarySerializer::OnListEnd() {
-}
-
-void BinarySerializer::OnNullableBegin(bool present) {
-	WriteValue(present);
-}
-
-void BinarySerializer::OnNullableEnd() {
-}
-
-//-------------------------------------------------------------------------
-// Primitive Types
-//-------------------------------------------------------------------------
-void BinarySerializer::WriteNull() {
-	// This should never be called, optional writes should be handled by OnOptionalBegin
-}
-
-void BinarySerializer::WriteValue(bool value) {
-	Write<uint8_t>(value);
-}
-
-void BinarySerializer::WriteValue(uint8_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(char value) {
-	Write(value);
-}
-
-void BinarySerializer::WriteValue(int8_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(uint16_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(int16_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(uint32_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(int32_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(uint64_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(int64_t value) {
-	VarIntEncode(value);
-}
-
-void BinarySerializer::WriteValue(hugeint_t value) {
-	VarIntEncode(value.upper);
-	VarIntEncode(value.lower);
-}
-
-void BinarySerializer::WriteValue(uhugeint_t value) {
-	VarIntEncode(value.upper);
-	VarIntEncode(value.lower);
-}
-
-void BinarySerializer::WriteValue(float value) {
-	Write(value);
-}
-
-void BinarySerializer::WriteValue(double value) {
-	Write(value);
-}
-
-void BinarySerializer::WriteValue(const string &value) {
-	auto len = NumericCast<uint32_t>(value.length());
-	VarIntEncode(len);
-	WriteData(value.c_str(), len);
-}
-
-void BinarySerializer::WriteValue(const string_t value) {
-	auto len = NumericCast<uint32_t>(value.GetSize());
-	VarIntEncode(len);
-	WriteData(value.GetDataUnsafe(), len);
-}
-
-void BinarySerializer::WriteValue(const char *value) {
-	auto len = NumericCast<uint32_t>(strlen(value));
-	VarIntEncode(len);
-	WriteData(value, len);
-}
-
-void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
-	VarIntEncode(static_cast<uint64_t>(count));
-	WriteData(ptr, count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/serializer/buffered_file_reader.cpp b/src/duckdb/src/common/serializer/buffered_file_reader.cpp
deleted file mode 100644
index 96cd2e080..000000000
--- a/src/duckdb/src/common/serializer/buffered_file_reader.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-
-#include <algorithm>
-#include <cstring>
-
-namespace duckdb {
-
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type,
-                                       optional_ptr<FileOpener> opener)
-    : fs(fs), data(make_unsafe_uniq_array_uninitialized<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0),
-      total_read(0) {
-	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ | lock_type, opener.get());
-	file_size = NumericCast<idx_t>(fs.GetFileSize(*handle));
-}
-
-BufferedFileReader::BufferedFileReader(FileSystem &fs, unique_ptr<FileHandle> handle_p)
-    : fs(fs), data(make_unsafe_uniq_array_uninitialized<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0),
-      handle(std::move(handle_p)), total_read(0) {
-	file_size = NumericCast<idx_t>(fs.GetFileSize(*handle));
-}
-
-void BufferedFileReader::ReadData(data_ptr_t target_buffer, uint64_t read_size) {
-	// first copy anything we can from the buffer
-	data_ptr_t end_ptr = target_buffer + read_size;
-	while (true) {
-		idx_t to_read = MinValue<idx_t>(UnsafeNumericCast<idx_t>(end_ptr - target_buffer), read_data - offset);
-		if (to_read > 0) {
-			memcpy(target_buffer, data.get() + offset, to_read);
-			offset += to_read;
-			target_buffer += to_read;
-		}
-		if (target_buffer < end_ptr) {
-			D_ASSERT(offset == read_data);
-			total_read += read_data;
-			// did not finish reading yet but exhausted buffer
-			// read data into buffer
-			offset = 0;
-			read_data = UnsafeNumericCast<idx_t>(fs.Read(*handle, data.get(), FILE_BUFFER_SIZE));
-			if (read_data == 0) {
-				throw SerializationException("not enough data in file to deserialize result");
-			}
-		} else {
-			return;
-		}
-	}
-}
-
-bool BufferedFileReader::Finished() {
-	return total_read + offset == file_size;
-}
-
-void BufferedFileReader::Seek(uint64_t location) {
-	D_ASSERT(location <= file_size);
-	handle->Seek(location);
-	total_read = location;
-	read_data = offset = 0;
-}
-
-void BufferedFileReader::Reset() {
-	handle->Reset();
-	total_read = 0;
-	read_data = offset = 0;
-}
-
-uint64_t BufferedFileReader::CurrentOffset() {
-	return total_read + offset;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/serializer/buffered_file_writer.cpp b/src/duckdb/src/common/serializer/buffered_file_writer.cpp
deleted file mode 100644
index f0d811921..000000000
--- a/src/duckdb/src/common/serializer/buffered_file_writer.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-// Remove this when we switch C++17: https://stackoverflow.com/a/53350948
-constexpr FileOpenFlags BufferedFileWriter::DEFAULT_OPEN_FLAGS;
-
-BufferedFileWriter::BufferedFileWriter(FileSystem &fs, const string &path_p, FileOpenFlags open_flags)
-    : fs(fs), path(path_p), data(make_unsafe_uniq_array_uninitialized<data_t>(FILE_BUFFER_SIZE)), offset(0),
-      total_written(0) {
-	handle = fs.OpenFile(path, open_flags | FileLockType::WRITE_LOCK);
-}
-
-idx_t BufferedFileWriter::GetFileSize() {
-	return NumericCast<idx_t>(fs.GetFileSize(*handle)) + offset;
-}
-
-idx_t BufferedFileWriter::GetTotalWritten() const {
-	return total_written + offset;
-}
-
-void BufferedFileWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	if (write_size >= (2ULL * FILE_BUFFER_SIZE - offset)) {
-		idx_t to_copy = 0;
-		// Check before performing direct IO if there is some data in the current internal buffer.
-		// If so, then fill the buffer (to avoid to small write operation), flush it and then write
-		// all the remain data directly.
-		// This is to avoid to split a large buffer into N*FILE_BUFFER_SIZE buffers
-		if (offset != 0) {
-			// Some data are still present in the buffer let write them before
-			to_copy = FILE_BUFFER_SIZE - offset;
-			memcpy(data.get() + offset, buffer, to_copy);
-			offset += to_copy;
-			Flush(); // Flush buffer before writing every things else
-		}
-		idx_t remaining_to_write = write_size - to_copy;
-		fs.Write(*handle, const_cast<data_ptr_t>(buffer + to_copy), // NOLINT: wrong API in Write
-		         UnsafeNumericCast<int64_t>(remaining_to_write));
-		total_written += remaining_to_write;
-	} else {
-		// first copy anything we can from the buffer
-		const_data_ptr_t end_ptr = buffer + write_size;
-		while (buffer < end_ptr) {
-			idx_t to_write = MinValue<idx_t>(UnsafeNumericCast<idx_t>((end_ptr - buffer)), FILE_BUFFER_SIZE - offset);
-			D_ASSERT(to_write > 0);
-			memcpy(data.get() + offset, buffer, to_write);
-			offset += to_write;
-			buffer += to_write;
-			if (offset == FILE_BUFFER_SIZE) {
-				Flush();
-			}
-		}
-	}
-}
-
-void BufferedFileWriter::Flush() {
-	if (offset == 0) {
-		return;
-	}
-	fs.Write(*handle, data.get(), UnsafeNumericCast<int64_t>(offset));
-	total_written += offset;
-	offset = 0;
-}
-
-void BufferedFileWriter::Close() {
-	Flush();
-	handle->Close();
-	handle.reset();
-}
-
-void BufferedFileWriter::Sync() {
-	Flush();
-	handle->Sync();
-}
-
-void BufferedFileWriter::Truncate(idx_t size) {
-	auto persistent = NumericCast<idx_t>(fs.GetFileSize(*handle));
-	D_ASSERT(size <= persistent + offset);
-	if (persistent <= size) {
-		// truncating into the pending write buffer.
-		offset = size - persistent;
-	} else {
-		// truncate the physical file on disk
-		handle->Truncate(NumericCast<int64_t>(size));
-		// reset anything written in the buffer
-		offset = 0;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/serializer/memory_stream.cpp b/src/duckdb/src/common/serializer/memory_stream.cpp
deleted file mode 100644
index e5f0455e3..000000000
--- a/src/duckdb/src/common/serializer/memory_stream.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "duckdb/common/serializer/memory_stream.hpp"
-
-namespace duckdb {
-
-MemoryStream::MemoryStream(idx_t capacity) : position(0), capacity(capacity), owns_data(true) {
-	D_ASSERT(capacity != 0 && IsPowerOfTwo(capacity));
-	auto data_malloc_result = malloc(capacity);
-	if (!data_malloc_result) {
-		throw std::bad_alloc();
-	}
-	data = static_cast<data_ptr_t>(data_malloc_result);
-}
-
-MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity)
-    : position(0), capacity(capacity), owns_data(false), data(buffer) {
-}
-
-MemoryStream::~MemoryStream() {
-	if (owns_data) {
-		free(data);
-	}
-}
-
-MemoryStream::MemoryStream(MemoryStream &&other) noexcept {
-	// Move the data from the other stream into this stream
-	data = other.data;
-	position = other.position;
-	capacity = other.capacity;
-	owns_data = other.owns_data;
-
-	// Reset the other stream
-	other.data = nullptr;
-	other.position = 0;
-	other.capacity = 0;
-	other.owns_data = false;
-}
-
-MemoryStream &MemoryStream::operator=(MemoryStream &&other) noexcept {
-	if (this != &other) {
-		// Free the current data
-		if (owns_data) {
-			free(data);
-		}
-
-		// Move the data from the other stream into this stream
-		data = other.data;
-		position = other.position;
-		capacity = other.capacity;
-		owns_data = other.owns_data;
-
-		// Reset the other stream
-		other.data = nullptr;
-		other.position = 0;
-		other.capacity = 0;
-		other.owns_data = false;
-	}
-	return *this;
-}
-
-void MemoryStream::WriteData(const_data_ptr_t source, idx_t write_size) {
-	while (position + write_size > capacity) {
-		if (owns_data) {
-			capacity *= 2;
-			data = static_cast<data_ptr_t>(realloc(data, capacity));
-		} else {
-			throw SerializationException("Failed to serialize: not enough space in buffer to fulfill write request");
-		}
-	}
-	memcpy(data + position, source, write_size);
-	position += write_size;
-}
-
-void MemoryStream::ReadData(data_ptr_t destination, idx_t read_size) {
-	if (position + read_size > capacity) {
-		throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
-	}
-	memcpy(destination, data + position, read_size);
-	position += read_size;
-}
-
-void MemoryStream::Rewind() {
-	position = 0;
-}
-
-void MemoryStream::Release() {
-	owns_data = false;
-}
-
-data_ptr_t MemoryStream::GetData() const {
-	return data;
-}
-
-idx_t MemoryStream::GetPosition() const {
-	return position;
-}
-
-idx_t MemoryStream::GetCapacity() const {
-	return capacity;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/serializer/serializer.cpp b/src/duckdb/src/common/serializer/serializer.cpp
deleted file mode 100644
index 91a7f4772..000000000
--- a/src/duckdb/src/common/serializer/serializer.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-template <>
-void Serializer::WriteValue(const vector<bool> &vec) {
-	auto count = vec.size();
-	OnListBegin(count);
-	for (auto item : vec) {
-		WriteValue(item);
-	}
-	OnListEnd();
-}
-
-template <>
-void Serializer::WritePropertyWithDefault<Value>(const field_id_t field_id, const char *tag, const Value &value,
-                                                 const Value &&default_value) {
-	// If current value is default, don't write it
-	if (!options.serialize_default_values && ValueOperations::NotDistinctFrom(value, default_value)) {
-		OnOptionalPropertyBegin(field_id, tag, false);
-		OnOptionalPropertyEnd(false);
-		return;
-	}
-	OnOptionalPropertyBegin(field_id, tag, true);
-	WriteValue(value);
-	OnOptionalPropertyEnd(true);
-}
-
-void Serializer::List::WriteElement(data_ptr_t ptr, idx_t size) {
-	serializer.WriteDataPtr(ptr, size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/sort/comparators.cpp b/src/duckdb/src/common/sort/comparators.cpp
deleted file mode 100644
index 4df4cccc4..000000000
--- a/src/duckdb/src/common/sort/comparators.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-#include "duckdb/common/sort/comparators.hpp"
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-bool Comparators::TieIsBreakable(const idx_t &tie_col, const data_ptr_t &row_ptr, const SortLayout &sort_layout) {
-	const auto &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	// Check if the blob is NULL
-	ValidityBytes row_mask(row_ptr, sort_layout.column_count);
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-	if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-		// Can't break a NULL tie
-		return false;
-	}
-	auto &row_layout = sort_layout.blob_layout;
-	if (row_layout.GetTypes()[col_idx].InternalType() != PhysicalType::VARCHAR) {
-		// Nested type, must be broken
-		return true;
-	}
-	const auto &tie_col_offset = row_layout.GetOffsets()[col_idx];
-	auto tie_string = Load<string_t>(row_ptr + tie_col_offset);
-	if (tie_string.GetSize() < sort_layout.prefix_lengths[tie_col] && tie_string.GetSize() > 0) {
-		// No need to break the tie - we already compared the full string
-		return false;
-	}
-	return true;
-}
-
-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;
-	data_ptr_t l_ptr_offset = l_ptr;
-	data_ptr_t r_ptr_offset = r_ptr;
-	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, right, sort_layout, external_sort);
-		}
-		if (comp_res != 0) {
-			break;
-		}
-		l_ptr_offset += sort_layout.column_sizes[col_idx];
-		r_ptr_offset += sort_layout.column_sizes[col_idx];
-	}
-	return comp_res;
-}
-
-int Comparators::CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::VARCHAR:
-		return TemplatedCompareVal<string_t>(l_ptr, r_ptr);
-	case PhysicalType::LIST:
-	case PhysicalType::ARRAY:
-	case PhysicalType::STRUCT: {
-		auto l_nested_ptr = Load<data_ptr_t>(l_ptr);
-		auto r_nested_ptr = Load<data_ptr_t>(r_ptr);
-		return CompareValAndAdvance(l_nested_ptr, r_nested_ptr, type, true);
-	}
-	default:
-		throw NotImplementedException("Unimplemented CompareVal for type %s", type.ToString());
-	}
-}
-
-int Comparators::BreakBlobTie(const idx_t &tie_col, const SBScanState &left, const SBScanState &right,
-                              const SortLayout &sort_layout, const bool &external) {
-	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(tie_col, l_data_ptr, sort_layout) && !TieIsBreakable(tie_col, r_data_ptr, sort_layout)) {
-		// Quick check to see if ties can be broken
-		return 0;
-	}
-	// Align the pointers
-	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	const auto &tie_col_offset = sort_layout.blob_layout.GetOffsets()[col_idx];
-	l_data_ptr += tie_col_offset;
-	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 = sort_layout.blob_layout.GetTypes()[col_idx];
-	int result;
-	if (external) {
-		// Store heap pointers
-		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);
-		// Compare
-		result = CompareVal(l_data_ptr, r_data_ptr, type);
-		// Swizzle the pointers back to offsets
-		SwizzleSingleValue(l_data_ptr, l_heap_ptr, type);
-		SwizzleSingleValue(r_data_ptr, r_heap_ptr, type);
-	} else {
-		result = CompareVal(l_data_ptr, r_data_ptr, type);
-	}
-	return order * result;
-}
-
-template <class T>
-int Comparators::TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr) {
-	const auto left_val = Load<T>(left_ptr);
-	const auto right_val = Load<T>(right_ptr);
-	if (Equals::Operation<T>(left_val, right_val)) {
-		return 0;
-	} else if (LessThan::Operation<T>(left_val, right_val)) {
-		return -1;
-	} else {
-		return 1;
-	}
-}
-
-int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type, bool valid) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedCompareAndAdvance<int8_t>(l_ptr, r_ptr);
-	case PhysicalType::INT16:
-		return TemplatedCompareAndAdvance<int16_t>(l_ptr, r_ptr);
-	case PhysicalType::INT32:
-		return TemplatedCompareAndAdvance<int32_t>(l_ptr, r_ptr);
-	case PhysicalType::INT64:
-		return TemplatedCompareAndAdvance<int64_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT8:
-		return TemplatedCompareAndAdvance<uint8_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT16:
-		return TemplatedCompareAndAdvance<uint16_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT32:
-		return TemplatedCompareAndAdvance<uint32_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT64:
-		return TemplatedCompareAndAdvance<uint64_t>(l_ptr, r_ptr);
-	case PhysicalType::INT128:
-		return TemplatedCompareAndAdvance<hugeint_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT128:
-		return TemplatedCompareAndAdvance<uhugeint_t>(l_ptr, r_ptr);
-	case PhysicalType::FLOAT:
-		return TemplatedCompareAndAdvance<float>(l_ptr, r_ptr);
-	case PhysicalType::DOUBLE:
-		return TemplatedCompareAndAdvance<double>(l_ptr, r_ptr);
-	case PhysicalType::INTERVAL:
-		return TemplatedCompareAndAdvance<interval_t>(l_ptr, r_ptr);
-	case PhysicalType::VARCHAR:
-		return CompareStringAndAdvance(l_ptr, r_ptr, valid);
-	case PhysicalType::LIST:
-		return CompareListAndAdvance(l_ptr, r_ptr, ListType::GetChildType(type), valid);
-	case PhysicalType::STRUCT:
-		return CompareStructAndAdvance(l_ptr, r_ptr, StructType::GetChildTypes(type), valid);
-	case PhysicalType::ARRAY:
-		return CompareArrayAndAdvance(l_ptr, r_ptr, ArrayType::GetChildType(type), valid, ArrayType::GetSize(type));
-	default:
-		throw NotImplementedException("Unimplemented CompareValAndAdvance for type %s", type.ToString());
-	}
-}
-
-template <class T>
-int Comparators::TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
-	auto result = TemplatedCompareVal<T>(left_ptr, right_ptr);
-	left_ptr += sizeof(T);
-	right_ptr += sizeof(T);
-	return result;
-}
-
-int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, bool valid) {
-	if (!valid) {
-		return 0;
-	}
-	uint32_t left_string_size = Load<uint32_t>(left_ptr);
-	uint32_t right_string_size = Load<uint32_t>(right_ptr);
-	left_ptr += sizeof(uint32_t);
-	right_ptr += sizeof(uint32_t);
-	auto memcmp_res = memcmp(const_char_ptr_cast(left_ptr), const_char_ptr_cast(right_ptr),
-	                         std::min<uint32_t>(left_string_size, right_string_size));
-
-	left_ptr += left_string_size;
-	right_ptr += right_string_size;
-
-	if (memcmp_res != 0) {
-		return memcmp_res;
-	}
-	if (left_string_size == right_string_size) {
-		return 0;
-	}
-	if (left_string_size < right_string_size) {
-		return -1;
-	}
-	return 1;
-}
-
-int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                         const child_list_t<LogicalType> &types, bool valid) {
-	idx_t count = types.size();
-	// Load validity masks
-	ValidityBytes left_validity(left_ptr, types.size());
-	ValidityBytes right_validity(right_ptr, types.size());
-	left_ptr += (count + 7) / 8;
-	right_ptr += (count + 7) / 8;
-	// Initialize variables
-	bool left_valid;
-	bool right_valid;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	// Compare
-	int comp_res = 0;
-	for (idx_t i = 0; i < count; i++) {
-		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		auto &type = types[i].second;
-		if ((left_valid == right_valid) || TypeIsConstantSize(type.InternalType())) {
-			comp_res = CompareValAndAdvance(left_ptr, right_ptr, types[i].second, left_valid && valid);
-		}
-		if (!left_valid && !right_valid) {
-			comp_res = 0;
-		} else if (!left_valid) {
-			comp_res = 1;
-		} else if (!right_valid) {
-			comp_res = -1;
-		}
-		if (comp_res != 0) {
-			break;
-		}
-	}
-	return comp_res;
-}
-
-int Comparators::CompareArrayAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type,
-                                        bool valid, idx_t array_size) {
-	if (!valid) {
-		return 0;
-	}
-
-	// Load array validity masks
-	ValidityBytes left_validity(left_ptr, array_size);
-	ValidityBytes right_validity(right_ptr, array_size);
-	left_ptr += (array_size + 7) / 8;
-	right_ptr += (array_size + 7) / 8;
-
-	int comp_res = 0;
-	if (TypeIsConstantSize(type.InternalType())) {
-		// Templated code for fixed-size types
-		switch (type.InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			comp_res = TemplatedCompareListLoop<int8_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::INT16:
-			comp_res =
-			    TemplatedCompareListLoop<int16_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::INT32:
-			comp_res =
-			    TemplatedCompareListLoop<int32_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::INT64:
-			comp_res =
-			    TemplatedCompareListLoop<int64_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::UINT8:
-			comp_res =
-			    TemplatedCompareListLoop<uint8_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::UINT16:
-			comp_res =
-			    TemplatedCompareListLoop<uint16_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::UINT32:
-			comp_res =
-			    TemplatedCompareListLoop<uint32_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::UINT64:
-			comp_res =
-			    TemplatedCompareListLoop<uint64_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::INT128:
-			comp_res =
-			    TemplatedCompareListLoop<hugeint_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::FLOAT:
-			comp_res = TemplatedCompareListLoop<float>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::DOUBLE:
-			comp_res = TemplatedCompareListLoop<double>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		case PhysicalType::INTERVAL:
-			comp_res =
-			    TemplatedCompareListLoop<interval_t>(left_ptr, right_ptr, left_validity, right_validity, array_size);
-			break;
-		default:
-			throw NotImplementedException("CompareListAndAdvance for fixed-size type %s", type.ToString());
-		}
-	} else {
-		// Variable-sized array entries
-		bool left_valid;
-		bool right_valid;
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		// Size (in bytes) of all variable-sizes entries is stored before the entries begin,
-		// to make deserialization easier. We need to skip over them
-		left_ptr += array_size * sizeof(idx_t);
-		right_ptr += array_size * sizeof(idx_t);
-		for (idx_t i = 0; i < array_size; i++) {
-			ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-			left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			if (left_valid && right_valid) {
-				switch (type.InternalType()) {
-				case PhysicalType::LIST:
-					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type), left_valid);
-					break;
-				case PhysicalType::ARRAY:
-					comp_res = CompareArrayAndAdvance(left_ptr, right_ptr, ArrayType::GetChildType(type), left_valid,
-					                                  ArrayType::GetSize(type));
-					break;
-				case PhysicalType::VARCHAR:
-					comp_res = CompareStringAndAdvance(left_ptr, right_ptr, left_valid);
-					break;
-				case PhysicalType::STRUCT:
-					comp_res =
-					    CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type), left_valid);
-					break;
-				default:
-					throw NotImplementedException("CompareArrayAndAdvance for variable-size type %s", type.ToString());
-				}
-			} else if (!left_valid && !right_valid) {
-				comp_res = 0;
-			} else if (left_valid) {
-				comp_res = -1;
-			} else {
-				comp_res = 1;
-			}
-			if (comp_res != 0) {
-				break;
-			}
-		}
-	}
-	return comp_res;
-}
-
-int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type,
-                                       bool valid) {
-	if (!valid) {
-		return 0;
-	}
-	// Load list lengths
-	auto left_len = Load<idx_t>(left_ptr);
-	auto right_len = Load<idx_t>(right_ptr);
-	left_ptr += sizeof(idx_t);
-	right_ptr += sizeof(idx_t);
-	// Load list validity masks
-	ValidityBytes left_validity(left_ptr, left_len);
-	ValidityBytes right_validity(right_ptr, right_len);
-	left_ptr += (left_len + 7) / 8;
-	right_ptr += (right_len + 7) / 8;
-	// Compare
-	int comp_res = 0;
-	idx_t count = MinValue(left_len, right_len);
-	if (TypeIsConstantSize(type.InternalType())) {
-		// Templated code for fixed-size types
-		switch (type.InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			comp_res = TemplatedCompareListLoop<int8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT16:
-			comp_res = TemplatedCompareListLoop<int16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT32:
-			comp_res = TemplatedCompareListLoop<int32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT64:
-			comp_res = TemplatedCompareListLoop<int64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT8:
-			comp_res = TemplatedCompareListLoop<uint8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT16:
-			comp_res = TemplatedCompareListLoop<uint16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT32:
-			comp_res = TemplatedCompareListLoop<uint32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT64:
-			comp_res = TemplatedCompareListLoop<uint64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT128:
-			comp_res = TemplatedCompareListLoop<hugeint_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT128:
-			comp_res = TemplatedCompareListLoop<uhugeint_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::FLOAT:
-			comp_res = TemplatedCompareListLoop<float>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::DOUBLE:
-			comp_res = TemplatedCompareListLoop<double>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INTERVAL:
-			comp_res = TemplatedCompareListLoop<interval_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		default:
-			throw NotImplementedException("CompareListAndAdvance for fixed-size type %s", type.ToString());
-		}
-	} else {
-		// Variable-sized list entries
-		bool left_valid;
-		bool right_valid;
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		// Size (in bytes) of all variable-sizes entries is stored before the entries begin,
-		// to make deserialization easier. We need to skip over them
-		left_ptr += left_len * sizeof(idx_t);
-		right_ptr += right_len * sizeof(idx_t);
-		for (idx_t i = 0; i < count; i++) {
-			ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-			left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			if (left_valid && right_valid) {
-				switch (type.InternalType()) {
-				case PhysicalType::LIST:
-					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type), left_valid);
-					break;
-				case PhysicalType::ARRAY:
-					comp_res = CompareArrayAndAdvance(left_ptr, right_ptr, ArrayType::GetChildType(type), left_valid,
-					                                  ArrayType::GetSize(type));
-					break;
-				case PhysicalType::VARCHAR:
-					comp_res = CompareStringAndAdvance(left_ptr, right_ptr, left_valid);
-					break;
-				case PhysicalType::STRUCT:
-					comp_res =
-					    CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type), left_valid);
-					break;
-				default:
-					throw NotImplementedException("CompareListAndAdvance for variable-size type %s", type.ToString());
-				}
-			} else if (!left_valid && !right_valid) {
-				comp_res = 0;
-			} else if (left_valid) {
-				comp_res = -1;
-			} else {
-				comp_res = 1;
-			}
-			if (comp_res != 0) {
-				break;
-			}
-		}
-	}
-	// All values that we looped over were equal
-	if (comp_res == 0 && left_len != right_len) {
-		// Smaller lists first
-		if (left_len < right_len) {
-			comp_res = -1;
-		} else {
-			comp_res = 1;
-		}
-	}
-	return comp_res;
-}
-
-template <class T>
-int Comparators::TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                          const ValidityBytes &left_validity, const ValidityBytes &right_validity,
-                                          const idx_t &count) {
-	int comp_res = 0;
-	bool left_valid;
-	bool right_valid;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	for (idx_t i = 0; i < count; i++) {
-		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		comp_res = TemplatedCompareAndAdvance<T>(left_ptr, right_ptr);
-		if (!left_valid && !right_valid) {
-			comp_res = 0;
-		} else if (!left_valid) {
-			comp_res = 1;
-		} else if (!right_valid) {
-			comp_res = -1;
-		}
-		if (comp_res != 0) {
-			break;
-		}
-	}
-	return comp_res;
-}
-
-void Comparators::UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += string_t::HEADER_SIZE;
-	}
-	Store<data_ptr_t>(heap_ptr + Load<idx_t>(data_ptr), data_ptr);
-}
-
-void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += string_t::HEADER_SIZE;
-	}
-	Store<idx_t>(UnsafeNumericCast<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr), data_ptr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/sort/merge_sorter.cpp b/src/duckdb/src/common/sort/merge_sorter.cpp
deleted file mode 100644
index b36887e66..000000000
--- a/src/duckdb/src/common/sort/merge_sorter.cpp
+++ /dev/null
@@ -1,663 +0,0 @@
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/sort/comparators.hpp"
-#include "duckdb/common/sort/sort.hpp"
-
-namespace duckdb {
-
-MergeSorter::MergeSorter(GlobalSortState &state, BufferManager &buffer_manager)
-    : state(state), buffer_manager(buffer_manager), sort_layout(state.sort_layout) {
-}
-
-void MergeSorter::PerformInMergeRound() {
-	while (true) {
-		{
-			lock_guard<mutex> pair_guard(state.lock);
-			if (state.pair_idx == state.num_pairs) {
-				break;
-			}
-			GetNextPartition();
-		}
-		MergePartition();
-	}
-}
-
-void MergeSorter::MergePartition() {
-	auto &left_block = *left->sb;
-	auto &right_block = *right->sb;
-#ifdef DEBUG
-	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_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_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_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
-	// Set up the write block
-	// Each merge task produces a SortedBlock with exactly state.block_capacity rows or less
-	result->InitializeWrite();
-	// Initialize arrays to store merge data
-	bool left_smaller[STANDARD_VECTOR_SIZE];
-	idx_t next_entry_sizes[STANDARD_VECTOR_SIZE];
-	// Merge loop
-#ifdef DEBUG
-	auto l_count = left->Remaining();
-	auto r_count = right->Remaining();
-#endif
-	while (true) {
-		auto l_remaining = left->Remaining();
-		auto r_remaining = right->Remaining();
-		if (l_remaining + r_remaining == 0) {
-			// Done
-			break;
-		}
-		const idx_t next = MinValue(l_remaining + r_remaining, (idx_t)STANDARD_VECTOR_SIZE);
-		if (l_remaining != 0 && r_remaining != 0) {
-			// Compute the merge (not needed if one side is exhausted)
-			ComputeMerge(next, left_smaller);
-		}
-		// Actually merge the data (radix, blob, and payload)
-		MergeRadix(next, left_smaller);
-		if (!sort_layout.all_constant) {
-			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_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
-	D_ASSERT(result->Count() == l_count + r_count);
-#endif
-}
-
-void MergeSorter::GetNextPartition() {
-	// Create result block
-	state.sorted_blocks_temp[state.pair_idx].push_back(make_uniq<SortedBlock>(buffer_manager, state));
-	result = state.sorted_blocks_temp[state.pair_idx].back().get();
-	// Determine which blocks must be merged
-	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_uniq<SBScanState>(buffer_manager, state);
-	right = make_uniq<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(intersection, l_end, r_end);
-		D_ASSERT(l_end <= l_count);
-		D_ASSERT(r_end <= r_count);
-		D_ASSERT(intersection == l_end + r_end);
-	} else {
-		l_end = l_count;
-		r_end = r_count;
-	}
-	// Create slices of the data that this thread must merge
-	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;
-		state.sorted_blocks[state.pair_idx * 2 + 1] = nullptr;
-		// Advance pair
-		state.pair_idx++;
-		state.l_start = 0;
-		state.r_start = 0;
-	}
-}
-
-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) {
-		return -1;
-	}
-	if (r_idx < state.r_start) {
-		return 1;
-	}
-
-	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;
-
-	int comp_res;
-	if (sort_layout.all_constant) {
-		comp_res = FastMemcmp(l_ptr, r_ptr, sort_layout.comparison_size);
-	} else {
-		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(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
-	// LCOV_EXCL_START
-	if (diagonal >= l_count + r_count) {
-		l_idx = l_count;
-		r_idx = r_count;
-		return;
-	} else if (diagonal == 0) {
-		l_idx = 0;
-		r_idx = 0;
-		return;
-	} else if (l_count == 0) {
-		l_idx = 0;
-		r_idx = diagonal;
-		return;
-	} else if (r_count == 0) {
-		r_idx = 0;
-		l_idx = diagonal;
-		return;
-	}
-	// LCOV_EXCL_STOP
-	// Determine offsets for the binary search
-	const idx_t l_offset = MinValue(l_count, diagonal);
-	const idx_t r_offset = diagonal > l_count ? diagonal - l_count : 0;
-	D_ASSERT(l_offset + r_offset == diagonal);
-	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 li = 0;
-	idx_t ri = search_space - 1;
-	idx_t middle;
-	int comp_res;
-	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(*left, *right, l_idx - 1, r_idx);
-			if (comp_res > 0) {
-				l_idx--;
-				r_idx++;
-			} else {
-				return;
-			}
-			if (l_idx == 0 || r_idx == r_count) {
-				// This case is incredibly difficult to cover as it is dependent on parallelism randomness
-				// But it has been tested extensively during development in a script
-				// LCOV_EXCL_START
-				return;
-				// LCOV_EXCL_STOP
-			} else {
-				break;
-			}
-		}
-		comp_res = CompareUsingGlobalIndex(*left, *right, l_idx, r_idx);
-		if (comp_res > 0) {
-			li = middle + 1;
-		} else {
-			ri = middle - 1;
-		}
-	}
-	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) {
-		l_idx--;
-		r_idx++;
-	} else if (l_min1_r < 0) {
-		l_idx++;
-		r_idx--;
-	}
-}
-
-void MergeSorter::ComputeMerge(const idx_t &count, bool left_smaller[]) {
-	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;
-	// Compute the merge of the next 'count' tuples
-	idx_t compared = 0;
-	while (compared < count) {
-		// Move to the next block (if needed)
-		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
-		left->PinRadix(l.block_idx);
-		l_radix_ptr = left->RadixPtr();
-		right->PinRadix(r.block_idx);
-		r_radix_ptr = right->RadixPtr();
-
-		const idx_t l_count = l_sorted_block.radix_sorting_data[l.block_idx]->count;
-		const idx_t r_count = r_sorted_block.radix_sorting_data[r.block_idx]->count;
-		// 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++) {
-				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_radix_ptr += l_smaller * sort_layout.entry_size;
-				r_radix_ptr += r_smaller * sort_layout.entry_size;
-			}
-		} else {
-			// Pin the blob data
-			left->PinData(*l_sorted_block.blob_sorting_data);
-			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++) {
-				left_smaller[compared] =
-				    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_radix_ptr += l_smaller * sort_layout.entry_size;
-				r_radix_ptr += r_smaller * sort_layout.entry_size;
-			}
-		}
-	}
-	// 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 &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 = nullptr;
-	RowDataBlock *r_block = nullptr;
-
-	data_ptr_t l_ptr;
-	data_ptr_t r_ptr;
-
-	RowDataBlock *result_block = result->radix_sorting_data.back().get();
-	auto result_handle = buffer_manager.Pin(result_block->block);
-	data_ptr_t result_ptr = result_handle.Ptr() + result_block->count * sort_layout.entry_size;
-
-	idx_t copied = 0;
-	while (copied < count) {
-		// Move to the next block (if needed)
-		if (l.block_idx < l_blocks.size() && l.entry_idx == l_blocks[l.block_idx]->count) {
-			// Delete reference to previous block
-			l_blocks[l.block_idx]->block = nullptr;
-			// Advance block
-			l.block_idx++;
-			l.entry_idx = 0;
-		}
-		if (r.block_idx < r_blocks.size() && r.entry_idx == r_blocks[r.block_idx]->count) {
-			// Delete reference to previous block
-			r_blocks[r.block_idx]->block = nullptr;
-			// Advance block
-			r.block_idx++;
-			r.entry_idx = 0;
-		}
-		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
-		idx_t l_count;
-		if (!l_done) {
-			l_block = l_blocks[l.block_idx].get();
-			left->PinRadix(l.block_idx);
-			l_ptr = l.RadixPtr();
-			l_count = l_block->count;
-		} else {
-			l_count = 0;
-		}
-		idx_t r_count;
-		if (!r_done) {
-			r_block = r_blocks[r.block_idx].get();
-			r.PinRadix(r.block_idx);
-			r_ptr = r.RadixPtr();
-			r_count = r_block->count;
-		} else {
-			r_count = 0;
-		}
-		// Copy using computed merge
-		if (!l_done && !r_done) {
-			// Both sides have data - merge
-			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, l.entry_idx, l_count, *result_block, result_ptr, sort_layout.entry_size, copied, count);
-		} else {
-			// Left side is exhausted
-			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[], 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.GetHeapOffset();
-
-	// Left and right row data to merge
-	data_ptr_t l_ptr;
-	data_ptr_t r_ptr;
-	// Accompanying left and right heap data (if needed)
-	data_ptr_t l_heap_ptr;
-	data_ptr_t r_heap_ptr;
-
-	// Result rows to write to
-	RowDataBlock *result_data_block = result_data.data_blocks.back().get();
-	auto result_data_handle = buffer_manager.Pin(result_data_block->block);
-	data_ptr_t result_data_ptr = result_data_handle.Ptr() + result_data_block->count * row_width;
-	// Result heap to write to (if needed)
-	RowDataBlock *result_heap_block = nullptr;
-	BufferHandle result_heap_handle;
-	data_ptr_t result_heap_ptr;
-	if (!layout.AllConstant() && state.external) {
-		result_heap_block = result_data.heap_blocks.back().get();
-		result_heap_handle = buffer_manager.Pin(result_heap_block->block);
-		result_heap_ptr = result_heap_handle.Ptr() + result_heap_block->byte_offset;
-	}
-
-	idx_t copied = 0;
-	while (copied < count) {
-		// Move to new data blocks (if needed)
-		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.block_idx]->block = nullptr;
-			if (!layout.AllConstant() && state.external) {
-				l_data.heap_blocks[l.block_idx]->block = nullptr;
-			}
-			// Advance block
-			l.block_idx++;
-			l.entry_idx = 0;
-		}
-		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.block_idx]->block = nullptr;
-			if (!layout.AllConstant() && state.external) {
-				r_data.heap_blocks[r.block_idx]->block = nullptr;
-			}
-			// Advance block
-			r.block_idx++;
-			r.entry_idx = 0;
-		}
-		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.PinData(l_data);
-			l_ptr = l.DataPtr(l_data);
-		}
-		if (!r_done) {
-			r.PinData(r_data);
-			r_ptr = r.DataPtr(r_data);
-		}
-		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.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.entry_idx, l_count, *result_data_block, result_data_ptr, row_width, copied, count);
-			} else {
-				// Left side is exhausted
-				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.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.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.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
-				MergeRows(l_ptr, l_idx_copy, l_count, r_ptr, r_idx_copy, r_count, *result_data_block,
-				          result_data_ptr_copy, row_width, left_smaller, copied_copy, count);
-				const idx_t merged = copied_copy - copied;
-				// Compute the entry sizes and number of heap bytes that will be copied
-				idx_t copy_bytes = 0;
-				data_ptr_t l_heap_ptr_copy = l_heap_ptr;
-				data_ptr_t r_heap_ptr_copy = r_heap_ptr;
-				for (idx_t i = 0; i < merged; i++) {
-					// Store base heap offset in the row data
-					Store<idx_t>(result_heap_block->byte_offset + copy_bytes, result_data_ptr + heap_pointer_offset);
-					result_data_ptr += row_width;
-					// Compute entry size and add to total
-					const bool &l_smaller = left_smaller[copied + i];
-					const bool r_smaller = !l_smaller;
-					auto &entry_size = next_entry_sizes[copied + i];
-					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(NumericCast<idx_t>(l_heap_ptr_copy - l.BaseHeapPtr(l_data)) + l_smaller * entry_size <=
-					         l_data.heap_blocks[l.block_idx]->byte_offset);
-					D_ASSERT(NumericCast<idx_t>(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;
-				}
-				// Reallocate result heap block size (if needed)
-				if (result_heap_block->byte_offset + copy_bytes > result_heap_block->capacity) {
-					idx_t new_capacity = result_heap_block->byte_offset + copy_bytes;
-					buffer_manager.ReAllocate(result_heap_block->block, new_capacity);
-					result_heap_block->capacity = new_capacity;
-					result_heap_ptr = result_heap_handle.Ptr() + result_heap_block->byte_offset;
-				}
-				D_ASSERT(result_heap_block->byte_offset + copy_bytes <= result_heap_block->capacity);
-				// Now copy the heap data
-				for (idx_t i = 0; i < merged; i++) {
-					const bool &l_smaller = left_smaller[copied + i];
-					const bool r_smaller = !l_smaller;
-					const auto &entry_size = next_entry_sizes[copied + i];
-					memcpy(result_heap_ptr,
-					       reinterpret_cast<data_ptr_t>(l_smaller * CastPointerToValue(l_heap_ptr) +
-					                                    r_smaller * CastPointerToValue(r_heap_ptr)),
-					       entry_size);
-					D_ASSERT(Load<uint32_t>(result_heap_ptr) == entry_size);
-					result_heap_ptr += entry_size;
-					l_heap_ptr += l_smaller * entry_size;
-					r_heap_ptr += r_smaller * entry_size;
-					l.entry_idx += l_smaller;
-					r.entry_idx += r_smaller;
-				}
-				// Update result indices and pointers
-				result_heap_block->count += merged;
-				result_heap_block->byte_offset += copy_bytes;
-				copied += merged;
-			} else if (r_done) {
-				// Right side is exhausted - flush left
-				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.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,
-                            idx_t &r_entry_idx, const idx_t &r_count, RowDataBlock &target_block,
-                            data_ptr_t &target_ptr, const idx_t &entry_size, const bool left_smaller[], idx_t &copied,
-                            const idx_t &count) {
-	const idx_t next = MinValue(count - copied, target_block.capacity - target_block.count);
-	idx_t i;
-	for (i = 0; i < next && l_entry_idx < l_count && r_entry_idx < r_count; i++) {
-		const bool &l_smaller = left_smaller[copied + i];
-		const bool r_smaller = !l_smaller;
-		// Use comparison bool (0 or 1) to copy an entry from either side
-		FastMemcpy(
-		    target_ptr,
-		    reinterpret_cast<data_ptr_t>(l_smaller * CastPointerToValue(l_ptr) + r_smaller * CastPointerToValue(r_ptr)),
-		    entry_size);
-		target_ptr += entry_size;
-		// Use the comparison bool to increment entries and pointers
-		l_entry_idx += l_smaller;
-		r_entry_idx += r_smaller;
-		l_ptr += l_smaller * entry_size;
-		r_ptr += r_smaller * entry_size;
-	}
-	// Update counts
-	target_block.count += i;
-	copied += i;
-}
-
-void MergeSorter::FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
-                            RowDataBlock &target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
-                            const idx_t &count) {
-	// Compute how many entries we can fit
-	idx_t next = MinValue(count - copied, target_block.capacity - target_block.count);
-	next = MinValue(next, source_count - source_entry_idx);
-	// Copy them all in a single memcpy
-	const idx_t copy_bytes = next * entry_size;
-	memcpy(target_ptr, source_ptr, copy_bytes);
-	target_ptr += copy_bytes;
-	source_ptr += copy_bytes;
-	// Update counts
-	source_entry_idx += next;
-	target_block.count += next;
-	copied += next;
-}
-
-void MergeSorter::FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
-                             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) {
-	const idx_t row_width = layout.GetRowWidth();
-	const idx_t heap_pointer_offset = layout.GetHeapOffset();
-	idx_t source_entry_idx_copy = source_entry_idx;
-	data_ptr_t target_data_ptr_copy = target_data_ptr;
-	idx_t copied_copy = copied;
-	// Flush row data
-	FlushRows(source_data_ptr, source_entry_idx_copy, source_count, target_data_block, target_data_ptr_copy, row_width,
-	          copied_copy, count);
-	const idx_t flushed = copied_copy - copied;
-	// Compute the entry sizes and number of heap bytes that will be copied
-	idx_t copy_bytes = 0;
-	data_ptr_t source_heap_ptr_copy = source_heap_ptr;
-	for (idx_t i = 0; i < flushed; i++) {
-		// Store base heap offset in the row data
-		Store<idx_t>(target_heap_block.byte_offset + copy_bytes, target_data_ptr + heap_pointer_offset);
-		target_data_ptr += row_width;
-		// Compute entry size and add to total
-		auto entry_size = Load<uint32_t>(source_heap_ptr_copy);
-		D_ASSERT(entry_size >= sizeof(uint32_t));
-		source_heap_ptr_copy += entry_size;
-		copy_bytes += entry_size;
-	}
-	// Reallocate result heap block size (if needed)
-	if (target_heap_block.byte_offset + copy_bytes > target_heap_block.capacity) {
-		idx_t new_capacity = target_heap_block.byte_offset + copy_bytes;
-		buffer_manager.ReAllocate(target_heap_block.block, new_capacity);
-		target_heap_block.capacity = new_capacity;
-		target_heap_ptr = target_heap_handle.Ptr() + target_heap_block.byte_offset;
-	}
-	D_ASSERT(target_heap_block.byte_offset + copy_bytes <= target_heap_block.capacity);
-	// Copy the heap data in one go
-	memcpy(target_heap_ptr, source_heap_ptr, copy_bytes);
-	target_heap_ptr += copy_bytes;
-	source_heap_ptr += copy_bytes;
-	source_entry_idx += flushed;
-	copied += flushed;
-	// Update result indices and pointers
-	target_heap_block.count += flushed;
-	target_heap_block.byte_offset += copy_bytes;
-	D_ASSERT(target_heap_block.byte_offset <= target_heap_block.capacity);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/sort/partition_state.cpp b/src/duckdb/src/common/sort/partition_state.cpp
deleted file mode 100644
index 9c4379695..000000000
--- a/src/duckdb/src/common/sort/partition_state.cpp
+++ /dev/null
@@ -1,688 +0,0 @@
-#include "duckdb/common/sort/partition_state.hpp"
-
-#include "duckdb/common/types/column/column_data_consumer.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-
-#include <numeric>
-
-namespace duckdb {
-
-PartitionGlobalHashGroup::PartitionGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions,
-                                                   const Orders &orders, const Types &payload_types, bool external)
-    : count(0) {
-
-	RowLayout payload_layout;
-	payload_layout.Initialize(payload_types);
-	global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
-	global_sort->external = external;
-
-	//	Set up a comparator for the partition subset
-	partition_layout = global_sort->sort_layout.GetPrefixComparisonLayout(partitions.size());
-}
-
-void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, OrderMasks &order_masks) {
-	D_ASSERT(count > 0);
-
-	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
-	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
-
-	partition_mask.SetValidUnsafe(0);
-	unordered_map<idx_t, SortLayout> prefixes;
-	for (auto &order_mask : order_masks) {
-		order_mask.second.SetValidUnsafe(0);
-		D_ASSERT(order_mask.first >= partition_layout.column_count);
-		prefixes[order_mask.first] = global_sort->sort_layout.GetPrefixComparisonLayout(order_mask.first);
-	}
-
-	for (++curr; curr.GetIndex() < count; ++curr) {
-		//	Compare the partition subset first because if that differs, then so does the full ordering
-		const auto part_cmp = ComparePartitions(prev, curr);
-
-		if (part_cmp) {
-			partition_mask.SetValidUnsafe(curr.GetIndex());
-			for (auto &order_mask : order_masks) {
-				order_mask.second.SetValidUnsafe(curr.GetIndex());
-			}
-		} else {
-			for (auto &order_mask : order_masks) {
-				if (prev.Compare(curr, prefixes[order_mask.first])) {
-					order_mask.second.SetValidUnsafe(curr.GetIndex());
-				}
-			}
-		}
-		++prev;
-	}
-}
-
-void PartitionGlobalSinkState::GenerateOrderings(Orders &partitions, Orders &orders,
-                                                 const vector<unique_ptr<Expression>> &partition_bys,
-                                                 const Orders &order_bys,
-                                                 const vector<unique_ptr<BaseStatistics>> &partition_stats) {
-
-	// we sort by both 1) partition by expression list and 2) order by expressions
-	const auto partition_cols = partition_bys.size();
-	for (idx_t prt_idx = 0; prt_idx < partition_cols; prt_idx++) {
-		auto &pexpr = partition_bys[prt_idx];
-
-		if (partition_stats.empty() || !partition_stats[prt_idx]) {
-			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(), nullptr);
-		} else {
-			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(),
-			                    partition_stats[prt_idx]->ToUnique());
-		}
-		partitions.emplace_back(orders.back().Copy());
-	}
-
-	for (const auto &order : order_bys) {
-		orders.emplace_back(order.Copy());
-	}
-}
-
-PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
-                                                   const vector<unique_ptr<Expression>> &partition_bys,
-                                                   const vector<BoundOrderByNode> &order_bys,
-                                                   const Types &payload_types,
-                                                   const vector<unique_ptr<BaseStatistics>> &partition_stats,
-                                                   idx_t estimated_cardinality)
-    : context(context), buffer_manager(BufferManager::GetBufferManager(context)), allocator(Allocator::Get(context)),
-      fixed_bits(0), payload_types(payload_types), memory_per_thread(0), max_bits(1), count(0) {
-
-	GenerateOrderings(partitions, orders, partition_bys, order_bys, partition_stats);
-
-	memory_per_thread = PhysicalOperator::GetMaxThreadMemory(context);
-	external = ClientConfig::GetConfig(context).GetSetting<DebugForceExternalSetting>(context);
-
-	const auto thread_pages = PreviousPowerOfTwo(memory_per_thread / (4 * buffer_manager.GetBlockAllocSize()));
-	while (max_bits < 10 && (thread_pages >> max_bits) > 1) {
-		++max_bits;
-	}
-
-	if (!orders.empty()) {
-		if (partitions.empty()) {
-			//	Sort early into a dedicated hash group if we only sort.
-			grouping_types.Initialize(payload_types);
-			auto new_group =
-			    make_uniq<PartitionGlobalHashGroup>(buffer_manager, partitions, orders, payload_types, external);
-			hash_groups.emplace_back(std::move(new_group));
-		} else {
-			auto types = payload_types;
-			types.push_back(LogicalType::HASH);
-			grouping_types.Initialize(types);
-			ResizeGroupingData(estimated_cardinality);
-		}
-	}
-}
-
-bool PartitionGlobalSinkState::HasMergeTasks() const {
-	if (grouping_data) {
-		auto &groups = grouping_data->GetPartitions();
-		return !groups.empty();
-	} else if (!hash_groups.empty()) {
-		D_ASSERT(hash_groups.size() == 1);
-		return hash_groups[0]->count > 0;
-	} else {
-		return false;
-	}
-}
-
-void PartitionGlobalSinkState::SyncPartitioning(const PartitionGlobalSinkState &other) {
-	fixed_bits = other.grouping_data ? other.grouping_data->GetRadixBits() : 0;
-
-	const auto old_bits = grouping_data ? grouping_data->GetRadixBits() : 0;
-	if (fixed_bits != old_bits) {
-		const auto hash_col_idx = payload_types.size();
-		grouping_data = make_uniq<RadixPartitionedTupleData>(buffer_manager, grouping_types, fixed_bits, hash_col_idx);
-	}
-}
-
-unique_ptr<RadixPartitionedTupleData> PartitionGlobalSinkState::CreatePartition(idx_t new_bits) const {
-	const auto hash_col_idx = payload_types.size();
-	return make_uniq<RadixPartitionedTupleData>(buffer_manager, grouping_types, new_bits, hash_col_idx);
-}
-
-void PartitionGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
-	//	Have we started to combine? Then just live with it.
-	if (fixed_bits || (grouping_data && !grouping_data->GetPartitions().empty())) {
-		return;
-	}
-	//	Is the average partition size too large?
-	const idx_t partition_size = DEFAULT_ROW_GROUP_SIZE;
-	const auto bits = grouping_data ? grouping_data->GetRadixBits() : 0;
-	auto new_bits = bits ? bits : 4;
-	while (new_bits < max_bits && (cardinality / RadixPartitioning::NumberOfPartitions(new_bits)) > partition_size) {
-		++new_bits;
-	}
-
-	// Repartition the grouping data
-	if (new_bits != bits) {
-		grouping_data = CreatePartition(new_bits);
-	}
-}
-
-void PartitionGlobalSinkState::SyncLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append) {
-	// We are done if the local_partition is right sized.
-	auto &local_radix = local_partition->Cast<RadixPartitionedTupleData>();
-	const auto new_bits = grouping_data->GetRadixBits();
-	if (local_radix.GetRadixBits() == new_bits) {
-		return;
-	}
-
-	// If the local partition is now too small, flush it and reallocate
-	auto new_partition = CreatePartition(new_bits);
-	local_partition->FlushAppendState(*local_append);
-	local_partition->Repartition(*new_partition);
-
-	local_partition = std::move(new_partition);
-	local_append = make_uniq<PartitionedTupleDataAppendState>();
-	local_partition->InitializeAppendState(*local_append);
-}
-
-void PartitionGlobalSinkState::UpdateLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append) {
-	// Make sure grouping_data doesn't change under us.
-	lock_guard<mutex> guard(lock);
-
-	if (!local_partition) {
-		local_partition = CreatePartition(grouping_data->GetRadixBits());
-		local_append = make_uniq<PartitionedTupleDataAppendState>();
-		local_partition->InitializeAppendState(*local_append);
-		return;
-	}
-
-	// 	Grow the groups if they are too big
-	ResizeGroupingData(count);
-
-	//	Sync local partition to have the same bit count
-	SyncLocalPartition(local_partition, local_append);
-}
-
-void PartitionGlobalSinkState::CombineLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append) {
-	if (!local_partition) {
-		return;
-	}
-	local_partition->FlushAppendState(*local_append);
-
-	// Make sure grouping_data doesn't change under us.
-	// Combine has an internal mutex, so this is single-threaded anyway.
-	lock_guard<mutex> guard(lock);
-	SyncLocalPartition(local_partition, local_append);
-	grouping_data->Combine(*local_partition);
-}
-
-PartitionLocalMergeState::PartitionLocalMergeState(PartitionGlobalSinkState &gstate)
-    : merge_state(nullptr), stage(PartitionSortStage::INIT), finished(true), executor(gstate.context) {
-
-	//	 Set up the sort expression computation.
-	vector<LogicalType> sort_types;
-	for (auto &order : gstate.orders) {
-		auto &oexpr = order.expression;
-		sort_types.emplace_back(oexpr->return_type);
-		executor.AddExpression(*oexpr);
-	}
-	sort_chunk.Initialize(gstate.allocator, sort_types);
-	payload_chunk.Initialize(gstate.allocator, gstate.payload_types);
-}
-
-void PartitionLocalMergeState::Scan() {
-	if (!merge_state->group_data) {
-		//	OVER(ORDER BY...)
-		//	Already sorted
-		return;
-	}
-
-	auto &group_data = *merge_state->group_data;
-	auto &hash_group = *merge_state->hash_group;
-	auto &chunk_state = merge_state->chunk_state;
-	// Copy the data from the group into the sort code.
-	auto &global_sort = *hash_group.global_sort;
-	LocalSortState local_sort;
-	local_sort.Initialize(global_sort, global_sort.buffer_manager);
-
-	TupleDataScanState local_scan;
-	group_data.InitializeScan(local_scan, merge_state->column_ids);
-	while (group_data.Scan(chunk_state, local_scan, payload_chunk)) {
-		sort_chunk.Reset();
-		executor.Execute(payload_chunk, sort_chunk);
-
-		local_sort.SinkChunk(sort_chunk, payload_chunk);
-		if (local_sort.SizeInBytes() > merge_state->memory_per_thread) {
-			local_sort.Sort(global_sort, true);
-		}
-		hash_group.count += payload_chunk.size();
-	}
-
-	global_sort.AddLocalState(local_sort);
-}
-
-//	Per-thread sink state
-PartitionLocalSinkState::PartitionLocalSinkState(ClientContext &context, PartitionGlobalSinkState &gstate_p)
-    : gstate(gstate_p), allocator(Allocator::Get(context)), executor(context) {
-
-	vector<LogicalType> group_types;
-	for (idx_t prt_idx = 0; prt_idx < gstate.partitions.size(); prt_idx++) {
-		auto &pexpr = *gstate.partitions[prt_idx].expression.get();
-		group_types.push_back(pexpr.return_type);
-		executor.AddExpression(pexpr);
-	}
-	sort_cols = gstate.orders.size() + group_types.size();
-
-	if (sort_cols) {
-		auto payload_types = gstate.payload_types;
-		if (!group_types.empty()) {
-			// OVER(PARTITION BY...)
-			group_chunk.Initialize(allocator, group_types);
-			payload_types.emplace_back(LogicalType::HASH);
-		} else {
-			// OVER(ORDER BY...)
-			for (idx_t ord_idx = 0; ord_idx < gstate.orders.size(); ord_idx++) {
-				auto &pexpr = *gstate.orders[ord_idx].expression.get();
-				group_types.push_back(pexpr.return_type);
-				executor.AddExpression(pexpr);
-			}
-			group_chunk.Initialize(allocator, group_types);
-
-			//	Single partition
-			auto &global_sort = *gstate.hash_groups[0]->global_sort;
-			local_sort = make_uniq<LocalSortState>();
-			local_sort->Initialize(global_sort, global_sort.buffer_manager);
-		}
-		// OVER(...)
-		payload_chunk.Initialize(allocator, payload_types);
-	} else {
-		// OVER()
-		payload_layout.Initialize(gstate.payload_types);
-	}
-}
-
-void PartitionLocalSinkState::Hash(DataChunk &input_chunk, Vector &hash_vector) {
-	const auto count = input_chunk.size();
-	D_ASSERT(group_chunk.ColumnCount() > 0);
-
-	// OVER(PARTITION BY...) (hash grouping)
-	group_chunk.Reset();
-	executor.Execute(input_chunk, group_chunk);
-	VectorOperations::Hash(group_chunk.data[0], hash_vector, count);
-	for (idx_t prt_idx = 1; prt_idx < group_chunk.ColumnCount(); ++prt_idx) {
-		VectorOperations::CombineHash(hash_vector, group_chunk.data[prt_idx], count);
-	}
-}
-
-void PartitionLocalSinkState::Sink(DataChunk &input_chunk) {
-	gstate.count += input_chunk.size();
-
-	// OVER()
-	if (sort_cols == 0) {
-		//	No sorts, so build paged row chunks
-		if (!rows) {
-			const auto entry_size = payload_layout.GetRowWidth();
-			const auto block_size = gstate.buffer_manager.GetBlockSize();
-			const auto capacity = MaxValue<idx_t>(STANDARD_VECTOR_SIZE, block_size / entry_size + 1);
-			rows = make_uniq<RowDataCollection>(gstate.buffer_manager, capacity, entry_size);
-			strings = make_uniq<RowDataCollection>(gstate.buffer_manager, block_size, 1U, true);
-		}
-		const auto row_count = input_chunk.size();
-		const auto row_sel = FlatVector::IncrementalSelectionVector();
-		Vector addresses(LogicalType::POINTER);
-		auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
-		const auto prev_rows_blocks = rows->blocks.size();
-		auto handles = rows->Build(row_count, key_locations, nullptr, row_sel);
-		auto input_data = input_chunk.ToUnifiedFormat();
-		RowOperations::Scatter(input_chunk, input_data.get(), payload_layout, addresses, *strings, *row_sel, row_count);
-		// Mark that row blocks contain pointers (heap blocks are pinned)
-		if (!payload_layout.AllConstant()) {
-			D_ASSERT(strings->keep_pinned);
-			for (size_t i = prev_rows_blocks; i < rows->blocks.size(); ++i) {
-				rows->blocks[i]->block->SetSwizzling("PartitionLocalSinkState::Sink");
-			}
-		}
-		return;
-	}
-
-	if (local_sort) {
-		//	OVER(ORDER BY...)
-		group_chunk.Reset();
-		executor.Execute(input_chunk, group_chunk);
-		local_sort->SinkChunk(group_chunk, input_chunk);
-
-		auto &hash_group = *gstate.hash_groups[0];
-		hash_group.count += input_chunk.size();
-
-		if (local_sort->SizeInBytes() > gstate.memory_per_thread) {
-			auto &global_sort = *hash_group.global_sort;
-			local_sort->Sort(global_sort, true);
-		}
-		return;
-	}
-
-	// OVER(...)
-	payload_chunk.Reset();
-	auto &hash_vector = payload_chunk.data.back();
-	Hash(input_chunk, hash_vector);
-	for (idx_t col_idx = 0; col_idx < input_chunk.ColumnCount(); ++col_idx) {
-		payload_chunk.data[col_idx].Reference(input_chunk.data[col_idx]);
-	}
-	payload_chunk.SetCardinality(input_chunk);
-
-	gstate.UpdateLocalPartition(local_partition, local_append);
-	local_partition->Append(*local_append, payload_chunk);
-}
-
-void PartitionLocalSinkState::Combine() {
-	// OVER()
-	if (sort_cols == 0) {
-		// Only one partition again, so need a global lock.
-		lock_guard<mutex> glock(gstate.lock);
-		if (gstate.rows) {
-			if (rows) {
-				gstate.rows->Merge(*rows);
-				gstate.strings->Merge(*strings);
-				rows.reset();
-				strings.reset();
-			}
-		} else {
-			gstate.rows = std::move(rows);
-			gstate.strings = std::move(strings);
-		}
-		return;
-	}
-
-	if (local_sort) {
-		//	OVER(ORDER BY...)
-		auto &hash_group = *gstate.hash_groups[0];
-		auto &global_sort = *hash_group.global_sort;
-		global_sort.AddLocalState(*local_sort);
-		local_sort.reset();
-		return;
-	}
-
-	// OVER(...)
-	gstate.CombineLocalPartition(local_partition, local_append);
-}
-
-PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data_p,
-                                                     hash_t hash_bin)
-    : sink(sink), group_data(std::move(group_data_p)), group_idx(sink.hash_groups.size()),
-      memory_per_thread(sink.memory_per_thread),
-      num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads())),
-      stage(PartitionSortStage::INIT), total_tasks(0), tasks_assigned(0), tasks_completed(0) {
-
-	auto new_group = make_uniq<PartitionGlobalHashGroup>(sink.buffer_manager, sink.partitions, sink.orders,
-	                                                     sink.payload_types, sink.external);
-	sink.hash_groups.emplace_back(std::move(new_group));
-
-	hash_group = sink.hash_groups[group_idx].get();
-	global_sort = sink.hash_groups[group_idx]->global_sort.get();
-
-	sink.bin_groups[hash_bin] = group_idx;
-
-	column_ids.reserve(sink.payload_types.size());
-	for (column_t i = 0; i < sink.payload_types.size(); ++i) {
-		column_ids.emplace_back(i);
-	}
-	group_data->InitializeScan(chunk_state, column_ids);
-}
-
-PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink)
-    : sink(sink), group_idx(0), memory_per_thread(sink.memory_per_thread),
-      num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads())),
-      stage(PartitionSortStage::INIT), total_tasks(0), tasks_assigned(0), tasks_completed(0) {
-
-	const hash_t hash_bin = 0;
-	hash_group = sink.hash_groups[group_idx].get();
-	global_sort = sink.hash_groups[group_idx]->global_sort.get();
-
-	sink.bin_groups[hash_bin] = group_idx;
-}
-
-void PartitionLocalMergeState::Prepare() {
-	merge_state->group_data.reset();
-
-	auto &global_sort = *merge_state->global_sort;
-	global_sort.PrepareMergePhase();
-}
-
-void PartitionLocalMergeState::Merge() {
-	auto &global_sort = *merge_state->global_sort;
-	MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
-	merge_sorter.PerformInMergeRound();
-}
-
-void PartitionLocalMergeState::Sorted() {
-	merge_state->sink.OnSortedPartition(merge_state->group_idx);
-}
-
-void PartitionLocalMergeState::ExecuteTask() {
-	switch (stage) {
-	case PartitionSortStage::SCAN:
-		Scan();
-		break;
-	case PartitionSortStage::PREPARE:
-		Prepare();
-		break;
-	case PartitionSortStage::MERGE:
-		Merge();
-		break;
-	case PartitionSortStage::SORTED:
-		Sorted();
-		break;
-	default:
-		throw InternalException("Unexpected PartitionSortStage in ExecuteTask!");
-	}
-
-	merge_state->CompleteTask();
-	finished = true;
-}
-
-bool PartitionGlobalMergeState::AssignTask(PartitionLocalMergeState &local_state) {
-	lock_guard<mutex> guard(lock);
-
-	if (tasks_assigned >= total_tasks) {
-		return false;
-	}
-
-	local_state.merge_state = this;
-	local_state.stage = stage;
-	local_state.finished = false;
-	tasks_assigned++;
-
-	return true;
-}
-
-void PartitionGlobalMergeState::CompleteTask() {
-	lock_guard<mutex> guard(lock);
-
-	++tasks_completed;
-}
-
-bool PartitionGlobalMergeState::TryPrepareNextStage() {
-	lock_guard<mutex> guard(lock);
-
-	if (tasks_completed < total_tasks) {
-		return false;
-	}
-
-	tasks_assigned = tasks_completed = 0;
-
-	switch (stage) {
-	case PartitionSortStage::INIT:
-		//	If the partitions are unordered, don't scan in parallel
-		//	because it produces non-deterministic orderings.
-		//	This can theoretically happen with ORDER BY,
-		//	but that is something the query should be explicit about.
-		total_tasks = sink.orders.size() > sink.partitions.size() ? num_threads : 1;
-		stage = PartitionSortStage::SCAN;
-		return true;
-
-	case PartitionSortStage::SCAN:
-		total_tasks = 1;
-		stage = PartitionSortStage::PREPARE;
-		return true;
-
-	case PartitionSortStage::PREPARE:
-		if (!(global_sort->sorted_blocks.size() / 2)) {
-			break;
-		}
-		stage = PartitionSortStage::MERGE;
-		global_sort->InitializeMergeRound();
-		total_tasks = num_threads;
-		return true;
-
-	case PartitionSortStage::MERGE:
-		global_sort->CompleteMergeRound(true);
-		if (!(global_sort->sorted_blocks.size() / 2)) {
-			break;
-		}
-		global_sort->InitializeMergeRound();
-		total_tasks = num_threads;
-		return true;
-
-	case PartitionSortStage::SORTED:
-		stage = PartitionSortStage::FINISHED;
-		total_tasks = 0;
-		return false;
-
-	case PartitionSortStage::FINISHED:
-		return false;
-	}
-
-	stage = PartitionSortStage::SORTED;
-	total_tasks = 1;
-
-	return true;
-}
-
-PartitionGlobalMergeStates::PartitionGlobalMergeStates(PartitionGlobalSinkState &sink) {
-	// Schedule all the sorts for maximum thread utilisation
-	if (sink.grouping_data) {
-		auto &partitions = sink.grouping_data->GetPartitions();
-		sink.bin_groups.resize(partitions.size(), partitions.size());
-		for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
-			auto &group_data = partitions[hash_bin];
-			// Prepare for merge sort phase
-			if (group_data->Count()) {
-				auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
-				states.emplace_back(std::move(state));
-			}
-		}
-	} else {
-		//	OVER(ORDER BY...)
-		//	Already sunk into the single global sort, so set up single merge with no data
-		sink.bin_groups.resize(1, 1);
-		auto state = make_uniq<PartitionGlobalMergeState>(sink);
-		states.emplace_back(std::move(state));
-	}
-
-	sink.OnBeginMerge();
-}
-
-class PartitionMergeTask : public ExecutorTask {
-public:
-	PartitionMergeTask(shared_ptr<Event> event_p, ClientContext &context_p, PartitionGlobalMergeStates &hash_groups_p,
-	                   PartitionGlobalSinkState &gstate, const PhysicalOperator &op)
-	    : ExecutorTask(context_p, std::move(event_p), op), local_state(gstate), hash_groups(hash_groups_p) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
-
-private:
-	struct ExecutorCallback : public PartitionGlobalMergeStates::Callback {
-		explicit ExecutorCallback(Executor &executor) : executor(executor) {
-		}
-
-		bool HasError() const override {
-			return executor.HasError();
-		}
-
-		Executor &executor;
-	};
-
-	PartitionLocalMergeState local_state;
-	PartitionGlobalMergeStates &hash_groups;
-};
-
-bool PartitionGlobalMergeStates::ExecuteTask(PartitionLocalMergeState &local_state, Callback &callback) {
-	// Loop until all hash groups are done
-	size_t sorted = 0;
-	while (sorted < states.size()) {
-		// First check if there is an unfinished task for this thread
-		if (callback.HasError()) {
-			return false;
-		}
-		if (!local_state.TaskFinished()) {
-			local_state.ExecuteTask();
-			continue;
-		}
-
-		// Thread is done with its assigned task, try to fetch new work
-		for (auto group = sorted; group < states.size(); ++group) {
-			auto &global_state = states[group];
-			if (global_state->IsFinished()) {
-				// This hash group is done
-				// Update the high water mark of densely completed groups
-				if (sorted == group) {
-					++sorted;
-				}
-				continue;
-			}
-
-			// Try to assign work for this hash group to this thread
-			if (global_state->AssignTask(local_state)) {
-				// We assigned a task to this thread!
-				// Break out of this loop to re-enter the top-level loop and execute the task
-				break;
-			}
-
-			// Hash group global state couldn't assign a task to this thread
-			// Try to prepare the next stage
-			if (!global_state->TryPrepareNextStage()) {
-				// This current hash group is not yet done
-				// But we were not able to assign a task for it to this thread
-				// See if the next hash group is better
-				continue;
-			}
-
-			// We were able to prepare the next stage for this hash group!
-			// Try to assign a task once more
-			if (global_state->AssignTask(local_state)) {
-				// We assigned a task to this thread!
-				// Break out of this loop to re-enter the top-level loop and execute the task
-				break;
-			}
-
-			// We were able to prepare the next merge round,
-			// but we were not able to assign a task for it to this thread
-			// The tasks were assigned to other threads while this thread waited for the lock
-			// Go to the next iteration to see if another hash group has a task
-		}
-	}
-
-	return true;
-}
-
-TaskExecutionResult PartitionMergeTask::ExecuteTask(TaskExecutionMode mode) {
-	ExecutorCallback callback(executor);
-
-	if (!hash_groups.ExecuteTask(local_state, callback)) {
-		return TaskExecutionResult::TASK_ERROR;
-	}
-
-	event->FinishTask();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-void PartitionMergeEvent::Schedule() {
-	auto &context = pipeline->GetClientContext();
-
-	// Schedule tasks equal to the number of threads, which will each merge multiple partitions
-	auto &ts = TaskScheduler::GetScheduler(context);
-	auto num_threads = NumericCast<idx_t>(ts.NumberOfThreads());
-
-	vector<shared_ptr<Task>> merge_tasks;
-	for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-		merge_tasks.emplace_back(make_uniq<PartitionMergeTask>(shared_from_this(), context, merge_states, gstate, op));
-	}
-	SetTasks(std::move(merge_tasks));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/sort/radix_sort.cpp b/src/duckdb/src/common/sort/radix_sort.cpp
deleted file mode 100644
index b193cee61..000000000
--- a/src/duckdb/src/common/sort/radix_sort.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/sort/comparators.hpp"
-#include "duckdb/common/sort/duckdb_pdqsort.hpp"
-#include "duckdb/common/sort/sort.hpp"
-
-namespace duckdb {
-
-//! Calls std::sort on strings that are tied by their prefix after the radix sort
-static void SortTiedBlobs(BufferManager &buffer_manager, const data_ptr_t dataptr, const idx_t &start, const idx_t &end,
-                          const idx_t &tie_col, bool *ties, const data_ptr_t blob_ptr, const SortLayout &sort_layout) {
-	const auto row_width = sort_layout.blob_layout.GetRowWidth();
-	// Locate the first blob row in question
-	data_ptr_t row_ptr = dataptr + start * sort_layout.entry_size;
-	data_ptr_t blob_row_ptr = blob_ptr + Load<uint32_t>(row_ptr + sort_layout.comparison_size) * row_width;
-	if (!Comparators::TieIsBreakable(tie_col, blob_row_ptr, sort_layout)) {
-		// Quick check to see if ties can be broken
-		return;
-	}
-	// Fill pointer array for sorting
-	auto ptr_block = make_unsafe_uniq_array_uninitialized<data_ptr_t>(end - start);
-	auto entry_ptrs = (data_ptr_t *)ptr_block.get();
-	for (idx_t i = start; i < end; i++) {
-		entry_ptrs[i - start] = row_ptr;
-		row_ptr += sort_layout.entry_size;
-	}
-	// Slow pointer-based sorting
-	const int order = sort_layout.order_types[tie_col] == OrderType::DESCENDING ? -1 : 1;
-	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	const auto &tie_col_offset = sort_layout.blob_layout.GetOffsets()[col_idx];
-	auto logical_type = sort_layout.blob_layout.GetTypes()[col_idx];
-	std::sort(entry_ptrs, entry_ptrs + end - start,
-	          [&blob_ptr, &order, &sort_layout, &tie_col_offset, &row_width, &logical_type](const data_ptr_t l,
-	                                                                                        const data_ptr_t r) {
-		          idx_t left_idx = Load<uint32_t>(l + sort_layout.comparison_size);
-		          idx_t right_idx = Load<uint32_t>(r + sort_layout.comparison_size);
-		          data_ptr_t left_ptr = blob_ptr + left_idx * row_width + tie_col_offset;
-		          data_ptr_t right_ptr = blob_ptr + right_idx * row_width + tie_col_offset;
-		          return order * Comparators::CompareVal(left_ptr, right_ptr, logical_type) < 0;
-	          });
-	// Re-order
-	auto temp_block = buffer_manager.GetBufferAllocator().Allocate((end - start) * sort_layout.entry_size);
-	data_ptr_t temp_ptr = temp_block.get();
-	for (idx_t i = 0; i < end - start; i++) {
-		FastMemcpy(temp_ptr, entry_ptrs[i], sort_layout.entry_size);
-		temp_ptr += sort_layout.entry_size;
-	}
-	memcpy(dataptr + start * sort_layout.entry_size, temp_block.get(), (end - start) * sort_layout.entry_size);
-	// Determine if there are still ties (if this is not the last column)
-	if (tie_col < sort_layout.column_count - 1) {
-		data_ptr_t idx_ptr = dataptr + start * sort_layout.entry_size + sort_layout.comparison_size;
-		// Load current entry
-		data_ptr_t current_ptr = blob_ptr + Load<uint32_t>(idx_ptr) * row_width + tie_col_offset;
-		for (idx_t i = 0; i < end - start - 1; i++) {
-			// Load next entry and compare
-			idx_ptr += sort_layout.entry_size;
-			data_ptr_t next_ptr = blob_ptr + Load<uint32_t>(idx_ptr) * row_width + tie_col_offset;
-			ties[start + i] = Comparators::CompareVal(current_ptr, next_ptr, logical_type) == 0;
-			current_ptr = next_ptr;
-		}
-	}
-}
-
-//! Identifies sequences of rows that are tied by the prefix of a blob column, and sorts them
-static void SortTiedBlobs(BufferManager &buffer_manager, SortedBlock &sb, bool *ties, data_ptr_t dataptr,
-                          const idx_t &count, const idx_t &tie_col, const SortLayout &sort_layout) {
-	D_ASSERT(!ties[count - 1]);
-	auto &blob_block = *sb.blob_sorting_data->data_blocks.back();
-	auto blob_handle = buffer_manager.Pin(blob_block.block);
-	const data_ptr_t blob_ptr = blob_handle.Ptr();
-
-	for (idx_t i = 0; i < count; i++) {
-		if (!ties[i]) {
-			continue;
-		}
-		idx_t j;
-		for (j = i + 1; j < count; j++) {
-			if (!ties[j]) {
-				break;
-			}
-		}
-		SortTiedBlobs(buffer_manager, dataptr, i, j + 1, tie_col, ties, blob_ptr, sort_layout);
-		i = j;
-	}
-}
-
-//! Returns whether there are any 'true' values in the ties[] array
-static bool AnyTies(bool ties[], const idx_t &count) {
-	D_ASSERT(!ties[count - 1]);
-	bool any_ties = false;
-	for (idx_t i = 0; i < count - 1; i++) {
-		any_ties = any_ties || ties[i];
-	}
-	return any_ties;
-}
-
-//! Compares subsequent rows to check for ties
-static void ComputeTies(data_ptr_t dataptr, const idx_t &count, const idx_t &col_offset, const idx_t &tie_size,
-                        bool ties[], const SortLayout &sort_layout) {
-	D_ASSERT(!ties[count - 1]);
-	D_ASSERT(col_offset + tie_size <= sort_layout.comparison_size);
-	// Align dataptr
-	dataptr += col_offset;
-	for (idx_t i = 0; i < count - 1; i++) {
-		ties[i] = ties[i] && FastMemcmp(dataptr, dataptr + sort_layout.entry_size, tie_size) == 0;
-		dataptr += sort_layout.entry_size;
-	}
-}
-
-//! Textbook LSD radix sort
-void RadixSortLSD(BufferManager &buffer_manager, const data_ptr_t &dataptr, const idx_t &count, const idx_t &col_offset,
-                  const idx_t &row_width, const idx_t &sorting_size) {
-	auto temp_block = buffer_manager.GetBufferAllocator().Allocate(count * row_width);
-	bool swap = false;
-
-	idx_t counts[SortConstants::VALUES_PER_RADIX];
-	for (idx_t r = 1; r <= sorting_size; r++) {
-		// Init counts to 0
-		memset(counts, 0, sizeof(counts));
-		// Const some values for convenience
-		const data_ptr_t source_ptr = swap ? temp_block.get() : dataptr;
-		const data_ptr_t target_ptr = swap ? dataptr : temp_block.get();
-		const idx_t offset = col_offset + sorting_size - r;
-		// Collect counts
-		data_ptr_t offset_ptr = source_ptr + offset;
-		for (idx_t i = 0; i < count; i++) {
-			counts[*offset_ptr]++;
-			offset_ptr += row_width;
-		}
-		// Compute offsets from counts
-		idx_t max_count = counts[0];
-		for (idx_t val = 1; val < SortConstants::VALUES_PER_RADIX; val++) {
-			max_count = MaxValue<idx_t>(max_count, counts[val]);
-			counts[val] = counts[val] + counts[val - 1];
-		}
-		if (max_count == count) {
-			continue;
-		}
-		// Re-order the data in temporary array
-		data_ptr_t row_ptr = source_ptr + (count - 1) * row_width;
-		for (idx_t i = 0; i < count; i++) {
-			idx_t &radix_offset = --counts[*(row_ptr + offset)];
-			FastMemcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
-			row_ptr -= row_width;
-		}
-		swap = !swap;
-	}
-	// Move data back to original buffer (if it was swapped)
-	if (swap) {
-		memcpy(dataptr, temp_block.get(), count * row_width);
-	}
-}
-
-//! Insertion sort, used when count of values is low
-inline void InsertionSort(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr, const idx_t &count,
-                          const idx_t &col_offset, const idx_t &row_width, const idx_t &total_comp_width,
-                          const idx_t &offset, bool swap) {
-	const data_ptr_t source_ptr = swap ? temp_ptr : orig_ptr;
-	const data_ptr_t target_ptr = swap ? orig_ptr : temp_ptr;
-	if (count > 1) {
-		const idx_t total_offset = col_offset + offset;
-		auto temp_val = make_unsafe_uniq_array_uninitialized<data_t>(row_width);
-		const data_ptr_t val = temp_val.get();
-		const auto comp_width = total_comp_width - offset;
-		for (idx_t i = 1; i < count; i++) {
-			FastMemcpy(val, source_ptr + i * row_width, row_width);
-			idx_t j = i;
-			while (j > 0 &&
-			       FastMemcmp(source_ptr + (j - 1) * row_width + total_offset, val + total_offset, comp_width) > 0) {
-				FastMemcpy(source_ptr + j * row_width, source_ptr + (j - 1) * row_width, row_width);
-				j--;
-			}
-			FastMemcpy(source_ptr + j * row_width, val, row_width);
-		}
-	}
-	if (swap) {
-		memcpy(target_ptr, source_ptr, count * row_width);
-	}
-}
-
-//! MSD radix sort that switches to insertion sort with low bucket sizes
-void RadixSortMSD(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr, const idx_t &count, const idx_t &col_offset,
-                  const idx_t &row_width, const idx_t &comp_width, const idx_t &offset, idx_t locations[], bool swap) {
-	const data_ptr_t source_ptr = swap ? temp_ptr : orig_ptr;
-	const data_ptr_t target_ptr = swap ? orig_ptr : temp_ptr;
-	// Init counts to 0
-	memset(locations, 0, SortConstants::MSD_RADIX_LOCATIONS * sizeof(idx_t));
-	idx_t *counts = locations + 1;
-	// Collect counts
-	const idx_t total_offset = col_offset + offset;
-	data_ptr_t offset_ptr = source_ptr + total_offset;
-	for (idx_t i = 0; i < count; i++) {
-		counts[*offset_ptr]++;
-		offset_ptr += row_width;
-	}
-	// Compute locations from counts
-	idx_t max_count = 0;
-	for (idx_t radix = 0; radix < SortConstants::VALUES_PER_RADIX; radix++) {
-		max_count = MaxValue<idx_t>(max_count, counts[radix]);
-		counts[radix] += locations[radix];
-	}
-	if (max_count != count) {
-		// Re-order the data in temporary array
-		data_ptr_t row_ptr = source_ptr;
-		for (idx_t i = 0; i < count; i++) {
-			const idx_t &radix_offset = locations[*(row_ptr + total_offset)]++;
-			FastMemcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
-			row_ptr += row_width;
-		}
-		swap = !swap;
-	}
-	// Check if done
-	if (offset == comp_width - 1) {
-		if (swap) {
-			memcpy(orig_ptr, temp_ptr, count * row_width);
-		}
-		return;
-	}
-	if (max_count == count) {
-		RadixSortMSD(orig_ptr, temp_ptr, count, col_offset, row_width, comp_width, offset + 1,
-		             locations + SortConstants::MSD_RADIX_LOCATIONS, swap);
-		return;
-	}
-	// Recurse
-	idx_t radix_count = locations[0];
-	for (idx_t radix = 0; radix < SortConstants::VALUES_PER_RADIX; radix++) {
-		const idx_t loc = (locations[radix] - radix_count) * row_width;
-		if (radix_count > SortConstants::INSERTION_SORT_THRESHOLD) {
-			RadixSortMSD(orig_ptr + loc, temp_ptr + loc, radix_count, col_offset, row_width, comp_width, offset + 1,
-			             locations + SortConstants::MSD_RADIX_LOCATIONS, swap);
-		} else if (radix_count != 0) {
-			InsertionSort(orig_ptr + loc, temp_ptr + loc, radix_count, col_offset, row_width, comp_width, offset + 1,
-			              swap);
-		}
-		radix_count = locations[radix + 1] - locations[radix];
-	}
-}
-
-//! Calls different sort functions, depending on the count and sorting sizes
-void RadixSort(BufferManager &buffer_manager, const data_ptr_t &dataptr, const idx_t &count, const idx_t &col_offset,
-               const idx_t &sorting_size, const SortLayout &sort_layout, bool contains_string) {
-
-	if (contains_string) {
-		auto begin = duckdb_pdqsort::PDQIterator(dataptr, sort_layout.entry_size);
-		auto end = begin + count;
-		duckdb_pdqsort::PDQConstants constants(sort_layout.entry_size, col_offset, sorting_size, *end);
-		return duckdb_pdqsort::pdqsort_branchless(begin, begin + count, constants);
-	}
-
-	if (count <= SortConstants::INSERTION_SORT_THRESHOLD) {
-		return InsertionSort(dataptr, nullptr, count, col_offset, sort_layout.entry_size, sorting_size, 0, false);
-	}
-
-	if (sorting_size <= SortConstants::MSD_RADIX_SORT_SIZE_THRESHOLD) {
-		return RadixSortLSD(buffer_manager, dataptr, count, col_offset, sort_layout.entry_size, sorting_size);
-	}
-
-	const auto block_size = buffer_manager.GetBlockSize();
-	auto temp_block =
-	    buffer_manager.Allocate(MemoryTag::ORDER_BY, MaxValue(count * sort_layout.entry_size, block_size));
-	auto pre_allocated_array =
-	    make_unsafe_uniq_array_uninitialized<idx_t>(sorting_size * SortConstants::MSD_RADIX_LOCATIONS);
-	RadixSortMSD(dataptr, temp_block.Ptr(), count, col_offset, sort_layout.entry_size, sorting_size, 0,
-	             pre_allocated_array.get(), false);
-}
-
-//! Identifies sequences of rows that are tied, and calls radix sort on these
-static void SubSortTiedTuples(BufferManager &buffer_manager, const data_ptr_t dataptr, const idx_t &count,
-                              const idx_t &col_offset, const idx_t &sorting_size, bool ties[],
-                              const SortLayout &sort_layout, bool contains_string) {
-	D_ASSERT(!ties[count - 1]);
-	for (idx_t i = 0; i < count; i++) {
-		if (!ties[i]) {
-			continue;
-		}
-		idx_t j;
-		for (j = i + 1; j < count; j++) {
-			if (!ties[j]) {
-				break;
-			}
-		}
-		RadixSort(buffer_manager, dataptr + i * sort_layout.entry_size, j - i + 1, col_offset, sorting_size,
-		          sort_layout, contains_string);
-		i = j;
-	}
-}
-
-void LocalSortState::SortInMemory() {
-	auto &sb = *sorted_blocks.back();
-	auto &block = *sb.radix_sorting_data.back();
-	const auto &count = block.count;
-	auto handle = buffer_manager->Pin(block.block);
-	const auto dataptr = handle.Ptr();
-	// Assign an index to each row
-	data_ptr_t idx_dataptr = dataptr + sort_layout->comparison_size;
-	for (uint32_t i = 0; i < count; i++) {
-		Store<uint32_t>(i, idx_dataptr);
-		idx_dataptr += sort_layout->entry_size;
-	}
-	// Radix sort and break ties until no more ties, or until all columns are sorted
-	idx_t sorting_size = 0;
-	idx_t col_offset = 0;
-	unsafe_unique_array<bool> ties_ptr;
-	bool *ties = nullptr;
-	bool contains_string = false;
-	for (idx_t i = 0; i < sort_layout->column_count; i++) {
-		sorting_size += sort_layout->column_sizes[i];
-		contains_string = contains_string || sort_layout->logical_types[i].InternalType() == PhysicalType::VARCHAR;
-		if (sort_layout->constant_size[i] && i < sort_layout->column_count - 1) {
-			// Add columns to the sorting size until we reach a variable size column, or the last column
-			continue;
-		}
-
-		if (!ties) {
-			// This is the first sort
-			RadixSort(*buffer_manager, dataptr, count, col_offset, sorting_size, *sort_layout, contains_string);
-			ties_ptr = make_unsafe_uniq_array_uninitialized<bool>(count);
-			ties = ties_ptr.get();
-			std::fill_n(ties, count - 1, true);
-			ties[count - 1] = false;
-		} else {
-			// For subsequent sorts, we only have to subsort the tied tuples
-			SubSortTiedTuples(*buffer_manager, dataptr, count, col_offset, sorting_size, ties, *sort_layout,
-			                  contains_string);
-		}
-
-		contains_string = false;
-
-		if (sort_layout->constant_size[i] && i == sort_layout->column_count - 1) {
-			// All columns are sorted, no ties to break because last column is constant size
-			break;
-		}
-
-		ComputeTies(dataptr, count, col_offset, sorting_size, ties, *sort_layout);
-		if (!AnyTies(ties, count)) {
-			// No ties, stop sorting
-			break;
-		}
-
-		if (!sort_layout->constant_size[i]) {
-			SortTiedBlobs(*buffer_manager, sb, ties, dataptr, count, i, *sort_layout);
-			if (!AnyTies(ties, count)) {
-				// No more ties after tie-breaking, stop
-				break;
-			}
-		}
-
-		col_offset += sorting_size;
-		sorting_size = 0;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/sort/sort_state.cpp b/src/duckdb/src/common/sort/sort_state.cpp
deleted file mode 100644
index 386f3498e..000000000
--- a/src/duckdb/src/common/sort/sort_state.cpp
+++ /dev/null
@@ -1,487 +0,0 @@
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/radix.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/sort/sorted_block.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-
-#include <algorithm>
-#include <numeric>
-
-namespace duckdb {
-
-idx_t GetNestedSortingColSize(idx_t &col_size, const LogicalType &type) {
-	auto physical_type = type.InternalType();
-	if (TypeIsConstantSize(physical_type)) {
-		col_size += GetTypeIdSize(physical_type);
-		return 0;
-	} else {
-		switch (physical_type) {
-		case PhysicalType::VARCHAR: {
-			// Nested strings are between 4 and 11 chars long for alignment
-			auto size_before_str = col_size;
-			col_size += 11;
-			col_size -= (col_size - 12) % 8;
-			return col_size - size_before_str;
-		}
-		case PhysicalType::LIST:
-			// Lists get 2 bytes (null and empty list)
-			col_size += 2;
-			return GetNestedSortingColSize(col_size, ListType::GetChildType(type));
-		case PhysicalType::STRUCT:
-			// Structs get 1 bytes (null)
-			col_size++;
-			return GetNestedSortingColSize(col_size, StructType::GetChildType(type, 0));
-		case PhysicalType::ARRAY:
-			// Arrays get 1 bytes (null)
-			col_size++;
-			return GetNestedSortingColSize(col_size, ArrayType::GetChildType(type));
-		default:
-			throw NotImplementedException("Unable to order column with type %s", type.ToString());
-		}
-	}
-}
-
-SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
-    : column_count(orders.size()), all_constant(true), comparison_size(0), entry_size(0) {
-	vector<LogicalType> blob_layout_types;
-	for (idx_t i = 0; i < column_count; i++) {
-		const auto &order = orders[i];
-
-		order_types.push_back(order.type);
-		order_by_null_types.push_back(order.null_order);
-		auto &expr = *order.expression;
-		logical_types.push_back(expr.return_type);
-
-		auto physical_type = expr.return_type.InternalType();
-		constant_size.push_back(TypeIsConstantSize(physical_type));
-
-		if (order.stats) {
-			stats.push_back(order.stats.get());
-			has_null.push_back(stats.back()->CanHaveNull());
-		} else {
-			stats.push_back(nullptr);
-			has_null.push_back(true);
-		}
-
-		idx_t col_size = has_null.back() ? 1 : 0;
-		prefix_lengths.push_back(0);
-		if (!TypeIsConstantSize(physical_type) && physical_type != PhysicalType::VARCHAR) {
-			prefix_lengths.back() = GetNestedSortingColSize(col_size, expr.return_type);
-		} else if (physical_type == PhysicalType::VARCHAR) {
-			idx_t size_before = col_size;
-			if (stats.back() && StringStats::HasMaxStringLength(*stats.back())) {
-				col_size += StringStats::MaxStringLength(*stats.back());
-				if (col_size > 12) {
-					col_size = 12;
-				} else {
-					constant_size.back() = true;
-				}
-			} else {
-				col_size = 12;
-			}
-			prefix_lengths.back() = col_size - size_before;
-		} else {
-			col_size += GetTypeIdSize(physical_type);
-		}
-
-		comparison_size += col_size;
-		column_sizes.push_back(col_size);
-	}
-	entry_size = comparison_size + sizeof(uint32_t);
-
-	// 8-byte alignment
-	if (entry_size % 8 != 0) {
-		// First assign more bytes to strings instead of aligning
-		idx_t bytes_to_fill = 8 - (entry_size % 8);
-		for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-			if (bytes_to_fill == 0) {
-				break;
-			}
-			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx] &&
-			    StringStats::HasMaxStringLength(*stats[col_idx])) {
-				idx_t diff = StringStats::MaxStringLength(*stats[col_idx]) - prefix_lengths[col_idx];
-				if (diff > 0) {
-					// Increase all sizes accordingly
-					idx_t increase = MinValue(bytes_to_fill, diff);
-					column_sizes[col_idx] += increase;
-					prefix_lengths[col_idx] += increase;
-					constant_size[col_idx] = increase == diff;
-					comparison_size += increase;
-					entry_size += increase;
-					bytes_to_fill -= increase;
-				}
-			}
-		}
-		entry_size = AlignValue(entry_size);
-	}
-
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-		all_constant = all_constant && constant_size[col_idx];
-		if (!constant_size[col_idx]) {
-			sorting_to_blob_col[col_idx] = blob_layout_types.size();
-			blob_layout_types.push_back(logical_types[col_idx]);
-		}
-	}
-
-	blob_layout.Initialize(blob_layout_types);
-}
-
-SortLayout SortLayout::GetPrefixComparisonLayout(idx_t num_prefix_cols) const {
-	SortLayout result;
-	result.column_count = num_prefix_cols;
-	result.all_constant = true;
-	result.comparison_size = 0;
-	for (idx_t col_idx = 0; col_idx < num_prefix_cols; col_idx++) {
-		result.order_types.push_back(order_types[col_idx]);
-		result.order_by_null_types.push_back(order_by_null_types[col_idx]);
-		result.logical_types.push_back(logical_types[col_idx]);
-
-		result.all_constant = result.all_constant && constant_size[col_idx];
-		result.constant_size.push_back(constant_size[col_idx]);
-
-		result.comparison_size += column_sizes[col_idx];
-		result.column_sizes.push_back(column_sizes[col_idx]);
-
-		result.prefix_lengths.push_back(prefix_lengths[col_idx]);
-		result.stats.push_back(stats[col_idx]);
-		result.has_null.push_back(has_null[col_idx]);
-	}
-	result.entry_size = entry_size;
-	result.blob_layout = blob_layout;
-	result.sorting_to_blob_col = sorting_to_blob_col;
-	return result;
-}
-
-LocalSortState::LocalSortState() : initialized(false) {
-	if (!Radix::IsLittleEndian()) {
-		throw NotImplementedException("Sorting is not supported on big endian architectures");
-	}
-}
-
-void LocalSortState::Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p) {
-	sort_layout = &global_sort_state.sort_layout;
-	payload_layout = &global_sort_state.payload_layout;
-	buffer_manager = &buffer_manager_p;
-	const auto block_size = buffer_manager->GetBlockSize();
-
-	// Radix sorting data
-	auto entries_per_block = RowDataCollection::EntriesPerBlock(sort_layout->entry_size, block_size);
-	radix_sorting_data = make_uniq<RowDataCollection>(*buffer_manager, entries_per_block, sort_layout->entry_size);
-
-	// Blob sorting data
-	if (!sort_layout->all_constant) {
-		auto blob_row_width = sort_layout->blob_layout.GetRowWidth();
-		entries_per_block = RowDataCollection::EntriesPerBlock(blob_row_width, block_size);
-		blob_sorting_data = make_uniq<RowDataCollection>(*buffer_manager, entries_per_block, blob_row_width);
-		blob_sorting_heap = make_uniq<RowDataCollection>(*buffer_manager, block_size, 1U, true);
-	}
-
-	// Payload data
-	auto payload_row_width = payload_layout->GetRowWidth();
-	entries_per_block = RowDataCollection::EntriesPerBlock(payload_row_width, block_size);
-	payload_data = make_uniq<RowDataCollection>(*buffer_manager, entries_per_block, payload_row_width);
-	payload_heap = make_uniq<RowDataCollection>(*buffer_manager, block_size, 1U, true);
-	initialized = true;
-}
-
-void LocalSortState::SinkChunk(DataChunk &sort, DataChunk &payload) {
-	D_ASSERT(sort.size() == payload.size());
-	// Build and serialize sorting data to radix sortable rows
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	auto handles = radix_sorting_data->Build(sort.size(), data_pointers, nullptr);
-	for (idx_t sort_col = 0; sort_col < sort.ColumnCount(); sort_col++) {
-		bool has_null = sort_layout->has_null[sort_col];
-		bool nulls_first = sort_layout->order_by_null_types[sort_col] == OrderByNullType::NULLS_FIRST;
-		bool desc = sort_layout->order_types[sort_col] == OrderType::DESCENDING;
-		RowOperations::RadixScatter(sort.data[sort_col], sort.size(), sel_ptr, sort.size(), data_pointers, desc,
-		                            has_null, nulls_first, sort_layout->prefix_lengths[sort_col],
-		                            sort_layout->column_sizes[sort_col]);
-	}
-
-	// Also fully serialize blob sorting columns (to be able to break ties
-	if (!sort_layout->all_constant) {
-		DataChunk blob_chunk;
-		blob_chunk.SetCardinality(sort.size());
-		for (idx_t sort_col = 0; sort_col < sort.ColumnCount(); sort_col++) {
-			if (!sort_layout->constant_size[sort_col]) {
-				blob_chunk.data.emplace_back(sort.data[sort_col]);
-			}
-		}
-		handles = blob_sorting_data->Build(blob_chunk.size(), data_pointers, nullptr);
-		auto blob_data = blob_chunk.ToUnifiedFormat();
-		RowOperations::Scatter(blob_chunk, blob_data.get(), sort_layout->blob_layout, addresses, *blob_sorting_heap,
-		                       sel_ptr, blob_chunk.size());
-		D_ASSERT(blob_sorting_heap->keep_pinned);
-	}
-
-	// Finally, serialize payload data
-	handles = payload_data->Build(payload.size(), data_pointers, nullptr);
-	auto input_data = payload.ToUnifiedFormat();
-	RowOperations::Scatter(payload, input_data.get(), *payload_layout, addresses, *payload_heap, sel_ptr,
-	                       payload.size());
-	D_ASSERT(payload_heap->keep_pinned);
-}
-
-idx_t LocalSortState::SizeInBytes() const {
-	idx_t size_in_bytes = radix_sorting_data->SizeInBytes() + payload_data->SizeInBytes();
-	if (!sort_layout->all_constant) {
-		size_in_bytes += blob_sorting_data->SizeInBytes() + blob_sorting_heap->SizeInBytes();
-	}
-	if (!payload_layout->AllConstant()) {
-		size_in_bytes += payload_heap->SizeInBytes();
-	}
-	return size_in_bytes;
-}
-
-void LocalSortState::Sort(GlobalSortState &global_sort_state, bool reorder_heap) {
-	D_ASSERT(radix_sorting_data->count == payload_data->count);
-	if (radix_sorting_data->count == 0) {
-		return;
-	}
-	// Move all data to a single SortedBlock
-	sorted_blocks.emplace_back(make_uniq<SortedBlock>(*buffer_manager, global_sort_state));
-	auto &sb = *sorted_blocks.back();
-	// Fixed-size sorting data
-	auto sorting_block = ConcatenateBlocks(*radix_sorting_data);
-	sb.radix_sorting_data.push_back(std::move(sorting_block));
-	// Variable-size sorting data
-	if (!sort_layout->all_constant) {
-		auto &blob_data = *blob_sorting_data;
-		auto new_block = ConcatenateBlocks(blob_data);
-		sb.blob_sorting_data->data_blocks.push_back(std::move(new_block));
-	}
-	// Payload data
-	auto payload_block = ConcatenateBlocks(*payload_data);
-	sb.payload_data->data_blocks.push_back(std::move(payload_block));
-	// Now perform the actual sort
-	SortInMemory();
-	// Re-order before the merge sort
-	ReOrder(global_sort_state, reorder_heap);
-}
-
-unique_ptr<RowDataBlock> LocalSortState::ConcatenateBlocks(RowDataCollection &row_data) {
-	//	Don't copy and delete if there is only one block.
-	if (row_data.blocks.size() == 1) {
-		auto new_block = std::move(row_data.blocks[0]);
-		row_data.blocks.clear();
-		row_data.count = 0;
-		return new_block;
-	}
-	// Create block with the correct capacity
-	auto &buffer_manager = row_data.buffer_manager;
-	const idx_t &entry_size = row_data.entry_size;
-	idx_t capacity = MaxValue((buffer_manager.GetBlockSize() + entry_size - 1) / entry_size, row_data.count);
-	auto new_block = make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, capacity, entry_size);
-	new_block->count = row_data.count;
-	auto new_block_handle = buffer_manager.Pin(new_block->block);
-	data_ptr_t new_block_ptr = new_block_handle.Ptr();
-	// Copy the data of the blocks into a single block
-	for (idx_t i = 0; i < row_data.blocks.size(); i++) {
-		auto &block = row_data.blocks[i];
-		auto block_handle = buffer_manager.Pin(block->block);
-		memcpy(new_block_ptr, block_handle.Ptr(), block->count * entry_size);
-		new_block_ptr += block->count * entry_size;
-		block.reset();
-	}
-	row_data.blocks.clear();
-	row_data.count = 0;
-	return new_block;
-}
-
-void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
-                             bool reorder_heap) {
-	sd.swizzled = reorder_heap;
-	auto &unordered_data_block = sd.data_blocks.back();
-	const idx_t count = unordered_data_block->count;
-	auto unordered_data_handle = buffer_manager->Pin(unordered_data_block->block);
-	const data_ptr_t unordered_data_ptr = unordered_data_handle.Ptr();
-	// Create new block that will hold re-ordered row data
-	auto ordered_data_block = make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, *buffer_manager,
-	                                                  unordered_data_block->capacity, unordered_data_block->entry_size);
-	ordered_data_block->count = count;
-	auto ordered_data_handle = buffer_manager->Pin(ordered_data_block->block);
-	data_ptr_t ordered_data_ptr = ordered_data_handle.Ptr();
-	// Re-order fixed-size row layout
-	const idx_t row_width = sd.layout.GetRowWidth();
-	const idx_t sorting_entry_size = gstate.sort_layout.entry_size;
-	for (idx_t i = 0; i < count; i++) {
-		auto index = Load<uint32_t>(sorting_ptr);
-		FastMemcpy(ordered_data_ptr, unordered_data_ptr + index * row_width, row_width);
-		ordered_data_ptr += row_width;
-		sorting_ptr += sorting_entry_size;
-	}
-	ordered_data_block->block->SetSwizzling(
-	    sd.layout.AllConstant() || !sd.swizzled ? nullptr : "LocalSortState::ReOrder.ordered_data");
-	// Replace the unordered data block with the re-ordered data block
-	sd.data_blocks.clear();
-	sd.data_blocks.push_back(std::move(ordered_data_block));
-	// Deal with the heap (if necessary)
-	if (!sd.layout.AllConstant() && reorder_heap) {
-		// Swizzle the column pointers to offsets
-		RowOperations::SwizzleColumns(sd.layout, ordered_data_handle.Ptr(), count);
-		sd.data_blocks.back()->block->SetSwizzling(nullptr);
-		// Create a single heap block to store the ordered heap
-		idx_t total_byte_offset =
-		    std::accumulate(heap.blocks.begin(), heap.blocks.end(), (idx_t)0,
-		                    [](idx_t a, const unique_ptr<RowDataBlock> &b) { return a + b->byte_offset; });
-		idx_t heap_block_size = MaxValue(total_byte_offset, buffer_manager->GetBlockSize());
-		auto ordered_heap_block = make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, *buffer_manager, heap_block_size, 1U);
-		ordered_heap_block->count = count;
-		ordered_heap_block->byte_offset = total_byte_offset;
-		auto ordered_heap_handle = buffer_manager->Pin(ordered_heap_block->block);
-		data_ptr_t ordered_heap_ptr = ordered_heap_handle.Ptr();
-		// Fill the heap in order
-		ordered_data_ptr = ordered_data_handle.Ptr();
-		const idx_t heap_pointer_offset = sd.layout.GetHeapOffset();
-		for (idx_t i = 0; i < count; i++) {
-			auto heap_row_ptr = Load<data_ptr_t>(ordered_data_ptr + heap_pointer_offset);
-			auto heap_row_size = Load<uint32_t>(heap_row_ptr);
-			memcpy(ordered_heap_ptr, heap_row_ptr, heap_row_size);
-			ordered_heap_ptr += heap_row_size;
-			ordered_data_ptr += row_width;
-		}
-		// Swizzle the base pointer to the offset of each row in the heap
-		RowOperations::SwizzleHeapPointer(sd.layout, ordered_data_handle.Ptr(), ordered_heap_handle.Ptr(), count);
-		// Move the re-ordered heap to the SortedData, and clear the local heap
-		sd.heap_blocks.push_back(std::move(ordered_heap_block));
-		heap.pinned_blocks.clear();
-		heap.blocks.clear();
-		heap.count = 0;
-	}
-}
-
-void LocalSortState::ReOrder(GlobalSortState &gstate, bool reorder_heap) {
-	auto &sb = *sorted_blocks.back();
-	auto sorting_handle = buffer_manager->Pin(sb.radix_sorting_data.back()->block);
-	const data_ptr_t sorting_ptr = sorting_handle.Ptr() + gstate.sort_layout.comparison_size;
-	// Re-order variable size sorting columns
-	if (!gstate.sort_layout.all_constant) {
-		ReOrder(*sb.blob_sorting_data, sorting_ptr, *blob_sorting_heap, gstate, reorder_heap);
-	}
-	// And the payload
-	ReOrder(*sb.payload_data, sorting_ptr, *payload_heap, gstate, reorder_heap);
-}
-
-GlobalSortState::GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders,
-                                 RowLayout &payload_layout)
-    : buffer_manager(buffer_manager), sort_layout(SortLayout(orders)), payload_layout(payload_layout),
-      block_capacity(0), external(false) {
-}
-
-void GlobalSortState::AddLocalState(LocalSortState &local_sort_state) {
-	if (!local_sort_state.radix_sorting_data) {
-		return;
-	}
-
-	// Sort accumulated data
-	// we only re-order the heap when the data is expected to not fit in memory
-	// re-ordering the heap avoids random access when reading/merging but incurs a significant cost of shuffling data
-	// when data fits in memory, doing random access on reads is cheaper than re-shuffling
-	local_sort_state.Sort(*this, external || !local_sort_state.sorted_blocks.empty());
-
-	// Append local state sorted data to this global state
-	lock_guard<mutex> append_guard(lock);
-	for (auto &sb : local_sort_state.sorted_blocks) {
-		sorted_blocks.push_back(std::move(sb));
-	}
-	auto &payload_heap = local_sort_state.payload_heap;
-	for (idx_t i = 0; i < payload_heap->blocks.size(); i++) {
-		heap_blocks.push_back(std::move(payload_heap->blocks[i]));
-		pinned_blocks.push_back(std::move(payload_heap->pinned_blocks[i]));
-	}
-	if (!sort_layout.all_constant) {
-		auto &blob_heap = local_sort_state.blob_sorting_heap;
-		for (idx_t i = 0; i < blob_heap->blocks.size(); i++) {
-			heap_blocks.push_back(std::move(blob_heap->blocks[i]));
-			pinned_blocks.push_back(std::move(blob_heap->pinned_blocks[i]));
-		}
-	}
-}
-
-void GlobalSortState::PrepareMergePhase() {
-	// Determine if we need to use do an external sort
-	idx_t total_heap_size =
-	    std::accumulate(sorted_blocks.begin(), sorted_blocks.end(), (idx_t)0,
-	                    [](idx_t a, const unique_ptr<SortedBlock> &b) { return a + b->HeapSize(); });
-	if (external || (pinned_blocks.empty() && total_heap_size * 4 > buffer_manager.GetQueryMaxMemory())) {
-		external = true;
-	}
-	// Use the data that we have to determine which partition size to use during the merge
-	if (external && total_heap_size > 0) {
-		// If we have variable size data we need to be conservative, as there might be skew
-		idx_t max_block_size = 0;
-		for (auto &sb : sorted_blocks) {
-			idx_t size_in_bytes = sb->SizeInBytes();
-			if (size_in_bytes > max_block_size) {
-				max_block_size = size_in_bytes;
-				block_capacity = sb->Count();
-			}
-		}
-	} else {
-		for (auto &sb : sorted_blocks) {
-			block_capacity = MaxValue(block_capacity, sb->Count());
-		}
-	}
-	// Unswizzle and pin heap blocks if we can fit everything in memory
-	if (!external) {
-		for (auto &sb : sorted_blocks) {
-			sb->blob_sorting_data->Unswizzle();
-			sb->payload_data->Unswizzle();
-		}
-	}
-}
-
-void GlobalSortState::InitializeMergeRound() {
-	D_ASSERT(sorted_blocks_temp.empty());
-	// If we reverse this list, the blocks that were merged last will be merged first in the next round
-	// These are still in memory, therefore this reduces the amount of read/write to disk!
-	std::reverse(sorted_blocks.begin(), sorted_blocks.end());
-	// Uneven number of blocks - keep one on the side
-	if (sorted_blocks.size() % 2 == 1) {
-		odd_one_out = std::move(sorted_blocks.back());
-		sorted_blocks.pop_back();
-	}
-	// Init merge path path indices
-	pair_idx = 0;
-	num_pairs = sorted_blocks.size() / 2;
-	l_start = 0;
-	r_start = 0;
-	// Allocate room for merge results
-	for (idx_t p_idx = 0; p_idx < num_pairs; p_idx++) {
-		sorted_blocks_temp.emplace_back();
-	}
-}
-
-void GlobalSortState::CompleteMergeRound(bool keep_radix_data) {
-	sorted_blocks.clear();
-	for (auto &sorted_block_vector : sorted_blocks_temp) {
-		sorted_blocks.push_back(make_uniq<SortedBlock>(buffer_manager, *this));
-		sorted_blocks.back()->AppendSortedBlocks(sorted_block_vector);
-	}
-	sorted_blocks_temp.clear();
-	if (odd_one_out) {
-		sorted_blocks.push_back(std::move(odd_one_out));
-		odd_one_out = nullptr;
-	}
-	// Only one block left: Done!
-	if (sorted_blocks.size() == 1 && !keep_radix_data) {
-		sorted_blocks[0]->radix_sorting_data.clear();
-		sorted_blocks[0]->blob_sorting_data = nullptr;
-	}
-}
-void GlobalSortState::Print() {
-	PayloadScanner scanner(*this, false);
-	DataChunk chunk;
-	chunk.Initialize(Allocator::DefaultAllocator(), scanner.GetPayloadTypes());
-	for (;;) {
-		scanner.Scan(chunk);
-		const auto count = chunk.size();
-		if (!count) {
-			break;
-		}
-		chunk.Print();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/sort/sorted_block.cpp b/src/duckdb/src/common/sort/sorted_block.cpp
deleted file mode 100644
index c4766c956..000000000
--- a/src/duckdb/src/common/sort/sorted_block.cpp
+++ /dev/null
@@ -1,387 +0,0 @@
-#include "duckdb/common/sort/sorted_block.hpp"
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/types/row/row_data_collection.hpp"
-
-#include <numeric>
-
-namespace duckdb {
-
-SortedData::SortedData(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager,
-                       GlobalSortState &state)
-    : type(type), layout(layout), swizzled(state.external), buffer_manager(buffer_manager), state(state) {
-}
-
-idx_t SortedData::Count() {
-	idx_t count = std::accumulate(data_blocks.begin(), data_blocks.end(), (idx_t)0,
-	                              [](idx_t a, const unique_ptr<RowDataBlock> &b) { return a + b->count; });
-	if (!layout.AllConstant() && state.external) {
-		D_ASSERT(count == std::accumulate(heap_blocks.begin(), heap_blocks.end(), (idx_t)0,
-		                                  [](idx_t a, const unique_ptr<RowDataBlock> &b) { return a + b->count; }));
-	}
-	return count;
-}
-
-void SortedData::CreateBlock() {
-	const auto block_size = buffer_manager.GetBlockSize();
-	auto capacity = MaxValue((block_size + layout.GetRowWidth() - 1) / layout.GetRowWidth(), state.block_capacity);
-	data_blocks.push_back(make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, capacity, layout.GetRowWidth()));
-	if (!layout.AllConstant() && state.external) {
-		heap_blocks.push_back(make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, block_size, 1U));
-		D_ASSERT(data_blocks.size() == heap_blocks.size());
-	}
-}
-
-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_uniq<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]->Copy());
-		if (!layout.AllConstant() && state.external) {
-			result->heap_blocks.push_back(heap_blocks[i]->Copy());
-		}
-	}
-	// All of the blocks that come before block with idx = start_block_idx can be reset (other references exist)
-	for (idx_t i = 0; i < start_block_index; i++) {
-		data_blocks[i]->block = nullptr;
-		if (!layout.AllConstant() && state.external) {
-			heap_blocks[i]->block = nullptr;
-		}
-	}
-	// Use start and end entry indices to set the boundaries
-	D_ASSERT(end_entry_index <= result->data_blocks.back()->count);
-	result->data_blocks.back()->count = end_entry_index;
-	if (!layout.AllConstant() && state.external) {
-		result->heap_blocks.back()->count = end_entry_index;
-	}
-	return result;
-}
-
-void SortedData::Unswizzle() {
-	if (layout.AllConstant() || !swizzled) {
-		return;
-	}
-	for (idx_t i = 0; i < data_blocks.size(); i++) {
-		auto &data_block = data_blocks[i];
-		auto &heap_block = heap_blocks[i];
-		D_ASSERT(data_block->block->IsSwizzled());
-		auto data_handle_p = buffer_manager.Pin(data_block->block);
-		auto heap_handle_p = buffer_manager.Pin(heap_block->block);
-		RowOperations::UnswizzlePointers(layout, data_handle_p.Ptr(), heap_handle_p.Ptr(), data_block->count);
-		state.heap_blocks.push_back(std::move(heap_block));
-		state.pinned_blocks.push_back(std::move(heap_handle_p));
-	}
-	swizzled = false;
-	heap_blocks.clear();
-}
-
-SortedBlock::SortedBlock(BufferManager &buffer_manager, GlobalSortState &state)
-    : buffer_manager(buffer_manager), state(state), sort_layout(state.sort_layout),
-      payload_layout(state.payload_layout) {
-	blob_sorting_data = make_uniq<SortedData>(SortedDataType::BLOB, sort_layout.blob_layout, buffer_manager, state);
-	payload_data = make_uniq<SortedData>(SortedDataType::PAYLOAD, payload_layout, buffer_manager, state);
-}
-
-idx_t SortedBlock::Count() const {
-	idx_t count = std::accumulate(radix_sorting_data.begin(), radix_sorting_data.end(), (idx_t)0,
-	                              [](idx_t a, const unique_ptr<RowDataBlock> &b) { return a + b->count; });
-	if (!sort_layout.all_constant) {
-		D_ASSERT(count == blob_sorting_data->Count());
-	}
-	D_ASSERT(count == payload_data->Count());
-	return count;
-}
-
-void SortedBlock::InitializeWrite() {
-	CreateBlock();
-	if (!sort_layout.all_constant) {
-		blob_sorting_data->CreateBlock();
-	}
-	payload_data->CreateBlock();
-}
-
-void SortedBlock::CreateBlock() {
-	const auto block_size = buffer_manager.GetBlockSize();
-	auto capacity = MaxValue((block_size + sort_layout.entry_size - 1) / sort_layout.entry_size, state.block_capacity);
-	radix_sorting_data.push_back(
-	    make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, capacity, sort_layout.entry_size));
-}
-
-void SortedBlock::AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks) {
-	D_ASSERT(Count() == 0);
-	for (auto &sb : sorted_blocks) {
-		for (auto &radix_block : sb->radix_sorting_data) {
-			radix_sorting_data.push_back(std::move(radix_block));
-		}
-		if (!sort_layout.all_constant) {
-			for (auto &blob_block : sb->blob_sorting_data->data_blocks) {
-				blob_sorting_data->data_blocks.push_back(std::move(blob_block));
-			}
-			for (auto &heap_block : sb->blob_sorting_data->heap_blocks) {
-				blob_sorting_data->heap_blocks.push_back(std::move(heap_block));
-			}
-		}
-		for (auto &payload_data_block : sb->payload_data->data_blocks) {
-			payload_data->data_blocks.push_back(std::move(payload_data_block));
-		}
-		if (!payload_data->layout.AllConstant()) {
-			for (auto &payload_heap_block : sb->payload_data->heap_blocks) {
-				payload_data->heap_blocks.push_back(std::move(payload_heap_block));
-			}
-		}
-	}
-}
-
-void SortedBlock::GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index) {
-	if (global_idx == Count()) {
-		local_block_index = radix_sorting_data.size() - 1;
-		local_entry_index = radix_sorting_data.back()->count;
-		return;
-	}
-	D_ASSERT(global_idx < Count());
-	local_entry_index = global_idx;
-	for (local_block_index = 0; local_block_index < radix_sorting_data.size(); local_block_index++) {
-		const idx_t &block_count = radix_sorting_data[local_block_index]->count;
-		if (local_entry_index >= block_count) {
-			local_entry_index -= block_count;
-		} else {
-			break;
-		}
-	}
-	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, idx_t &entry_idx) {
-	// Identify blocks/entry indices of this slice
-	idx_t start_block_index;
-	idx_t start_entry_index;
-	GlobalToLocalIndex(start, start_block_index, start_entry_index);
-	idx_t end_block_index;
-	idx_t end_entry_index;
-	GlobalToLocalIndex(end, end_block_index, end_entry_index);
-	// Add the corresponding blocks to the result
-	auto result = make_uniq<SortedBlock>(buffer_manager, state);
-	for (idx_t i = start_block_index; i <= end_block_index; i++) {
-		result->radix_sorting_data.push_back(radix_sorting_data[i]->Copy());
-	}
-	// Reset all blocks that come before block with idx = start_block_idx (slice holds new reference)
-	for (idx_t i = 0; i < start_block_index; i++) {
-		radix_sorting_data[i]->block = nullptr;
-	}
-	// Use start and end entry indices to set the boundaries
-	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, end_block_index, end_entry_index);
-	}
-	// And the payload data
-	result->payload_data = payload_data->CreateSlice(start_block_index, end_block_index, end_entry_index);
-	return result;
-}
-
-idx_t SortedBlock::HeapSize() const {
-	idx_t result = 0;
-	if (!sort_layout.all_constant) {
-		for (auto &block : blob_sorting_data->heap_blocks) {
-			result += block->capacity;
-		}
-	}
-	if (!payload_layout.AllConstant()) {
-		for (auto &block : payload_data->heap_blocks) {
-			result += block->capacity;
-		}
-	}
-	return result;
-}
-
-idx_t SortedBlock::SizeInBytes() const {
-	idx_t bytes = 0;
-	for (idx_t i = 0; i < radix_sorting_data.size(); i++) {
-		bytes += radix_sorting_data[i]->capacity * sort_layout.entry_size;
-		if (!sort_layout.all_constant) {
-			bytes += blob_sorting_data->data_blocks[i]->capacity * sort_layout.blob_layout.GetRowWidth();
-			bytes += blob_sorting_data->heap_blocks[i]->capacity;
-		}
-		bytes += payload_data->data_blocks[i]->capacity * payload_layout.GetRowWidth();
-		if (!payload_layout.AllConstant()) {
-			bytes += payload_data->heap_blocks[i]->capacity;
-		}
-	}
-	return bytes;
-}
-
-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.IsValid() || radix_handle.GetBlockHandle() != block->block) {
-		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.IsValid() || data_handle.GetBlockHandle() != data_block->block) {
-		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.IsValid() || heap_handle.GetBlockHandle() != heap_block->block) {
-		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.GetBlockHandle() == sd.data_blocks[block_idx]->block);
-	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.GetHeapOffset());
-}
-
-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.GetBlockHandle() == sd.heap_blocks[block_idx]->block);
-	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, bool flush_p) {
-	auto count = sorted_data.Count();
-	auto &layout = sorted_data.layout;
-	const auto block_size = global_sort_state.buffer_manager.GetBlockSize();
-
-	// Create collections to put the data into so we can use RowDataCollectionScanner
-	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
-	rows->count = count;
-
-	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
-	if (!sorted_data.layout.AllConstant()) {
-		heap->count = count;
-	}
-
-	if (flush_p) {
-		// If we are flushing, we can just move the data
-		rows->blocks = std::move(sorted_data.data_blocks);
-		if (!layout.AllConstant()) {
-			heap->blocks = std::move(sorted_data.heap_blocks);
-		}
-	} else {
-		// Not flushing, create references to the blocks
-		for (auto &block : sorted_data.data_blocks) {
-			rows->blocks.emplace_back(block->Copy());
-		}
-		if (!layout.AllConstant()) {
-			for (auto &block : sorted_data.heap_blocks) {
-				heap->blocks.emplace_back(block->Copy());
-			}
-		}
-	}
-
-	scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, global_sort_state.external, flush_p);
-}
-
-PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, bool flush_p)
-    : PayloadScanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state, flush_p) {
-}
-
-PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx, bool flush_p) {
-	auto &sorted_data = *global_sort_state.sorted_blocks[0]->payload_data;
-	auto count = sorted_data.data_blocks[block_idx]->count;
-	auto &layout = sorted_data.layout;
-	const auto block_size = global_sort_state.buffer_manager.GetBlockSize();
-
-	// Create collections to put the data into so we can use RowDataCollectionScanner
-	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
-	if (flush_p) {
-		rows->blocks.emplace_back(std::move(sorted_data.data_blocks[block_idx]));
-	} else {
-		rows->blocks.emplace_back(sorted_data.data_blocks[block_idx]->Copy());
-	}
-	rows->count = count;
-
-	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, block_size, 1U);
-	if (!sorted_data.layout.AllConstant() && sorted_data.swizzled) {
-		if (flush_p) {
-			heap->blocks.emplace_back(std::move(sorted_data.heap_blocks[block_idx]));
-		} else {
-			heap->blocks.emplace_back(sorted_data.heap_blocks[block_idx]->Copy());
-		}
-		heap->count = count;
-	}
-
-	scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, global_sort_state.external, flush_p);
-}
-
-void PayloadScanner::Scan(DataChunk &chunk) {
-	scanner->Scan(chunk);
-}
-
-int SBIterator::ComparisonValue(ExpressionType comparison) {
-	switch (comparison) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return -1;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return 0;
-	default:
-		throw InternalException("Unimplemented comparison type for IEJoin!");
-	}
-}
-
-static idx_t GetBlockCountWithEmptyCheck(const GlobalSortState &gss) {
-	D_ASSERT(!gss.sorted_blocks.empty());
-	return gss.sorted_blocks[0]->radix_sorting_data.size();
-}
-
-SBIterator::SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p)
-    : sort_layout(gss.sort_layout), block_count(GetBlockCountWithEmptyCheck(gss)), block_capacity(gss.block_capacity),
-      entry_size(sort_layout.entry_size), all_constant(sort_layout.all_constant), external(gss.external),
-      cmp(ComparisonValue(comparison)), scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
-
-	scan.sb = gss.sorted_blocks[0].get();
-	scan.block_idx = block_count;
-	SetIndex(entry_idx_p);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/stacktrace.cpp b/src/duckdb/src/common/stacktrace.cpp
deleted file mode 100644
index 7a42b35cf..000000000
--- a/src/duckdb/src/common/stacktrace.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include "duckdb/common/stacktrace.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-
-#if defined(__GLIBC__) || defined(__APPLE__)
-#include <execinfo.h>
-#include <cxxabi.h>
-#endif
-
-namespace duckdb {
-
-#if defined(__GLIBC__) || defined(__APPLE__)
-static string UnmangleSymbol(string symbol) {
-	// find the mangled name
-	idx_t mangle_start = symbol.size();
-	idx_t mangle_end = 0;
-	for (idx_t i = 0; i < symbol.size(); ++i) {
-		if (symbol[i] == '_') {
-			mangle_start = i;
-			break;
-		}
-	}
-	for (idx_t i = mangle_start; i < symbol.size(); i++) {
-		if (StringUtil::CharacterIsSpace(symbol[i]) || symbol[i] == ')' || symbol[i] == '+') {
-			mangle_end = i;
-			break;
-		}
-	}
-	if (mangle_start >= mangle_end) {
-		return symbol;
-	}
-	string mangled_symbol = symbol.substr(mangle_start, mangle_end - mangle_start);
-
-	int status;
-	auto demangle_result = abi::__cxa_demangle(mangled_symbol.c_str(), nullptr, nullptr, &status);
-	if (status != 0 || !demangle_result) {
-		return symbol;
-	}
-	string result;
-	result += symbol.substr(0, mangle_start);
-	result += demangle_result;
-	result += symbol.substr(mangle_end);
-	free(demangle_result);
-	return result;
-}
-
-static string CleanupStackTrace(string symbol) {
-#ifdef __APPLE__
-	// structure of frame pointers is [depth] [library] [pointer] [symbol]
-	// we are only interested in [depth] and [symbol]
-
-	// find the depth
-	idx_t start;
-	for (start = 0; start < symbol.size(); start++) {
-		if (!StringUtil::CharacterIsDigit(symbol[start])) {
-			break;
-		}
-	}
-
-	// now scan forward until we find the frame pointer
-	idx_t frame_end = symbol.size();
-	for (idx_t i = start; i + 1 < symbol.size(); ++i) {
-		if (symbol[i] == '0' && symbol[i + 1] == 'x') {
-			idx_t k;
-			for (k = i + 2; k < symbol.size(); ++k) {
-				if (!StringUtil::CharacterIsHex(symbol[k])) {
-					break;
-				}
-			}
-			frame_end = k;
-			break;
-		}
-	}
-	static constexpr idx_t STACK_TRACE_INDENTATION = 8;
-	if (frame_end == symbol.size() || start >= STACK_TRACE_INDENTATION) {
-		// frame pointer not found - just preserve the original frame
-		return symbol;
-	}
-	idx_t space_count = STACK_TRACE_INDENTATION - start;
-	return symbol.substr(0, start) + string(space_count, ' ') + symbol.substr(frame_end, symbol.size() - frame_end);
-#else
-	return symbol;
-#endif
-}
-
-string StackTrace::GetStacktracePointers(idx_t max_depth) {
-	string result;
-	auto callstack = unique_ptr<void *[]>(new void *[max_depth]);
-	int frames = backtrace(callstack.get(), NumericCast<int32_t>(max_depth));
-	// skip two frames (these are always StackTrace::...)
-	for (idx_t i = 2; i < NumericCast<idx_t>(frames); i++) {
-		if (!result.empty()) {
-			result += ";";
-		}
-		result += to_string(CastPointerToValue(callstack[i]));
-	}
-	return result;
-}
-
-string StackTrace::ResolveStacktraceSymbols(const string &pointers) {
-	auto splits = StringUtil::Split(pointers, ";");
-	idx_t frame_count = splits.size();
-	auto callstack = unique_ptr<void *[]>(new void *[frame_count]);
-	for (idx_t i = 0; i < frame_count; i++) {
-		callstack[i] = cast_uint64_to_pointer(StringUtil::ToUnsigned(splits[i]));
-	}
-	string result;
-	char **strs = backtrace_symbols(callstack.get(), NumericCast<int>(frame_count));
-	for (idx_t i = 0; i < frame_count; i++) {
-		result += CleanupStackTrace(UnmangleSymbol(strs[i]));
-		result += "\n";
-	}
-	free(reinterpret_cast<void *>(strs));
-	return "\n" + result;
-}
-
-#else
-string StackTrace::GetStacktracePointers(idx_t max_depth) {
-	return string();
-}
-
-string StackTrace::ResolveStacktraceSymbols(const string &pointers) {
-	return string();
-}
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/string_util.cpp b/src/duckdb/src/common/string_util.cpp
deleted file mode 100644
index f96e3d64e..000000000
--- a/src/duckdb/src/common/string_util.cpp
+++ /dev/null
@@ -1,841 +0,0 @@
-#include "duckdb/common/string_util.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/stack.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/exception/parser_exception.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "jaro_winkler.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <algorithm>
-#include <cctype>
-#include <iomanip>
-#include <memory>
-#include <sstream>
-#include <stdarg.h>
-#include <string.h>
-#include <stack>
-
-#include "yyjson.hpp"
-
-using namespace duckdb_yyjson; // NOLINT
-
-namespace duckdb {
-
-string StringUtil::GenerateRandomName(idx_t length) {
-	RandomEngine engine;
-	std::stringstream ss;
-	for (idx_t i = 0; i < length; i++) {
-		ss << "0123456789abcdef"[engine.NextRandomInteger(0, 15)];
-	}
-	return ss.str();
-}
-
-bool StringUtil::Contains(const string &haystack, const string &needle) {
-	return Find(haystack, needle).IsValid();
-}
-
-optional_idx StringUtil::Find(const string &haystack, const string &needle) {
-	auto index = haystack.find(needle);
-	if (index == string::npos) {
-		return optional_idx();
-	}
-	return optional_idx(index);
-}
-
-bool StringUtil::Contains(const string &haystack, const char &needle_char) {
-	return (haystack.find(needle_char) != string::npos);
-}
-
-idx_t StringUtil::ToUnsigned(const string &str) {
-	return std::stoull(str);
-}
-
-void StringUtil::LTrim(string &str) {
-	auto it = str.begin();
-	while (it != str.end() && CharacterIsSpace(*it)) {
-		it++;
-	}
-	str.erase(str.begin(), it);
-}
-
-// Remove trailing ' ', '\f', '\n', '\r', '\t', '\v'
-void StringUtil::RTrim(string &str) {
-	str.erase(find_if(str.rbegin(), str.rend(), [](char ch) { return ch > 0 && !CharacterIsSpace(ch); }).base(),
-	          str.end());
-}
-
-void StringUtil::RTrim(string &str, const string &chars_to_trim) {
-	str.erase(find_if(str.rbegin(), str.rend(),
-	                  [&chars_to_trim](char ch) { return ch > 0 && chars_to_trim.find(ch) == string::npos; })
-	              .base(),
-	          str.end());
-}
-
-void StringUtil::Trim(string &str) {
-	StringUtil::LTrim(str);
-	StringUtil::RTrim(str);
-}
-
-bool StringUtil::StartsWith(string str, string prefix) {
-	if (prefix.size() > str.size()) {
-		return false;
-	}
-	return equal(prefix.begin(), prefix.end(), str.begin());
-}
-
-bool StringUtil::EndsWith(const string &str, const string &suffix) {
-	if (suffix.size() > str.size()) {
-		return false;
-	}
-	return equal(suffix.rbegin(), suffix.rend(), str.rbegin());
-}
-
-string StringUtil::Repeat(const string &str, idx_t n) {
-	std::ostringstream os;
-	for (idx_t i = 0; i < n; i++) {
-		os << str;
-	}
-	return (os.str());
-}
-
-namespace string_util_internal {
-
-inline void SkipSpaces(const string &str, idx_t &index) {
-	while (index < str.size() && std::isspace(str[index])) {
-		index++;
-	}
-}
-
-inline void ConsumeLetter(const string &str, idx_t &index, char expected) {
-	if (index >= str.size() || str[index] != expected) {
-		throw ParserException("Invalid quoted list: %s", str);
-	}
-
-	index++;
-}
-
-template <typename F>
-inline void TakeWhile(const string &str, idx_t &index, const F &cond, string &taker) {
-	while (index < str.size() && cond(str[index])) {
-		taker.push_back(str[index]);
-		index++;
-	}
-}
-
-inline string TakePossiblyQuotedItem(const string &str, idx_t &index, char delimiter, char quote) {
-	string entry;
-
-	if (str[index] == quote) {
-		index++;
-		TakeWhile(
-		    str, index, [quote](char c) { return c != quote; }, entry);
-		ConsumeLetter(str, index, quote);
-	} else {
-		TakeWhile(
-		    str, index, [delimiter, quote](char c) { return c != delimiter && c != quote && !std::isspace(c); }, entry);
-	}
-
-	return entry;
-}
-
-} // namespace string_util_internal
-
-vector<string> StringUtil::SplitWithQuote(const string &str, char delimiter, char quote) {
-	vector<string> entries;
-	idx_t i = 0;
-
-	string_util_internal::SkipSpaces(str, i);
-	while (i < str.size()) {
-		if (!entries.empty()) {
-			string_util_internal::ConsumeLetter(str, i, delimiter);
-		}
-
-		entries.emplace_back(string_util_internal::TakePossiblyQuotedItem(str, i, delimiter, quote));
-		string_util_internal::SkipSpaces(str, i);
-	}
-
-	return entries;
-}
-
-vector<string> StringUtil::SplitWithParentheses(const string &str, char delimiter, char par_open, char par_close) {
-	vector<string> result;
-	string current;
-	stack<char> parentheses;
-
-	for (size_t i = 0; i < str.size(); ++i) {
-		char ch = str[i];
-
-		// stack to keep track if we are within parentheses
-		if (ch == par_open) {
-			parentheses.push(ch);
-		}
-		if (ch == par_close) {
-			if (!parentheses.empty()) {
-				parentheses.pop();
-			} else {
-				throw InvalidInputException("Incongruent parentheses in string: '%s'", str);
-			}
-		}
-		// split if not within parentheses
-		if (parentheses.empty() && ch == delimiter) {
-			result.push_back(current);
-			current.clear();
-		} else {
-			current += ch;
-		}
-	}
-	// Add the last segment
-	if (!current.empty()) {
-		result.push_back(current);
-	}
-	if (!parentheses.empty()) {
-		throw InvalidInputException("Incongruent parentheses in string: '%s'", str);
-	}
-	return result;
-}
-
-string StringUtil::Join(const vector<string> &input, const string &separator) {
-	return StringUtil::Join(input, input.size(), separator, [](const string &s) { return s; });
-}
-
-string StringUtil::Join(const set<string> &input, const string &separator) {
-	// The result
-	std::string result;
-
-	auto it = input.begin();
-	while (it != input.end()) {
-		result += *it;
-		it++;
-		if (it == input.end()) {
-			break;
-		}
-		result += separator;
-	}
-	return result;
-}
-
-string StringUtil::BytesToHumanReadableString(idx_t bytes, idx_t multiplier) {
-	D_ASSERT(multiplier == 1000 || multiplier == 1024);
-	idx_t array[6] = {};
-	const char *unit[2][6] = {{"bytes", "KiB", "MiB", "GiB", "TiB", "PiB"}, {"bytes", "kB", "MB", "GB", "TB", "PB"}};
-
-	const int sel = (multiplier == 1000);
-
-	array[0] = bytes;
-	for (idx_t i = 1; i < 6; i++) {
-		array[i] = array[i - 1] / multiplier;
-		array[i - 1] %= multiplier;
-	}
-
-	for (idx_t i = 5; i >= 1; i--) {
-		if (array[i]) {
-			// Map 0 -> 0 and (multiplier-1) -> 9
-			idx_t fractional_part = (array[i - 1] * 10) / multiplier;
-			return to_string(array[i]) + "." + to_string(fractional_part) + " " + unit[sel][i];
-		}
-	}
-
-	return to_string(array[0]) + (bytes == 1 ? " byte" : " bytes");
-}
-
-string StringUtil::Upper(const string &str) {
-	string copy(str);
-	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return std::toupper(c); });
-	return (copy);
-}
-
-string StringUtil::Lower(const string &str) {
-	string copy(str);
-	transform(copy.begin(), copy.end(), copy.begin(),
-	          [](unsigned char c) { return StringUtil::CharacterToLower(static_cast<char>(c)); });
-	return (copy);
-}
-
-string StringUtil::Title(const string &str) {
-	string copy;
-	bool first_character = true;
-	for (auto c : str) {
-		bool is_alpha = StringUtil::CharacterIsAlpha(c);
-		if (is_alpha) {
-			if (first_character) {
-				copy += StringUtil::CharacterToUpper(c);
-				first_character = false;
-			} else {
-				copy += StringUtil::CharacterToLower(c);
-			}
-		} else {
-			first_character = true;
-			copy += c;
-		}
-	}
-	return copy;
-}
-
-bool StringUtil::IsLower(const string &str) {
-	return str == Lower(str);
-}
-
-bool StringUtil::IsUpper(const string &str) {
-	return str == Upper(str);
-}
-
-// Jenkins hash function: https://en.wikipedia.org/wiki/Jenkins_hash_function
-uint64_t StringUtil::CIHash(const string &str) {
-	uint32_t hash = 0;
-	for (auto c : str) {
-		hash += static_cast<uint32_t>(StringUtil::CharacterToLower(static_cast<char>(c)));
-		hash += hash << 10;
-		hash ^= hash >> 6;
-	}
-	hash += hash << 3;
-	hash ^= hash >> 11;
-	hash += hash << 15;
-	return hash;
-}
-
-bool StringUtil::CIEquals(const string &l1, const string &l2) {
-	if (l1.size() != l2.size()) {
-		return false;
-	}
-	const auto charmap = ASCII_TO_LOWER_MAP;
-	for (idx_t c = 0; c < l1.size(); c++) {
-		if (charmap[(uint8_t)l1[c]] != charmap[(uint8_t)l2[c]]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool StringUtil::CILessThan(const string &s1, const string &s2) {
-	const auto charmap = ASCII_TO_UPPER_MAP;
-
-	unsigned char u1 {}, u2 {};
-
-	idx_t length = MinValue<idx_t>(s1.length(), s2.length());
-	length += s1.length() != s2.length();
-	for (idx_t i = 0; i < length; i++) {
-		u1 = (unsigned char)s1[i];
-		u2 = (unsigned char)s2[i];
-		if (charmap[u1] != charmap[u2]) {
-			break;
-		}
-	}
-	return (charmap[u1] - charmap[u2]) < 0;
-}
-
-idx_t StringUtil::CIFind(vector<string> &vector, const string &search_string) {
-	for (idx_t i = 0; i < vector.size(); i++) {
-		const auto &string = vector[i];
-		if (CIEquals(string, search_string)) {
-			return i;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-vector<string> StringUtil::Split(const string &str, char delimiter) {
-	std::stringstream ss(str);
-	vector<string> lines;
-	string temp;
-	while (getline(ss, temp, delimiter)) {
-		lines.push_back(temp);
-	}
-	return (lines);
-}
-
-vector<string> StringUtil::Split(const string &input, const string &split) {
-	vector<string> splits;
-
-	idx_t last = 0;
-	idx_t input_len = input.size();
-	idx_t split_len = split.size();
-	while (last <= input_len) {
-		idx_t next = input.find(split, last);
-		if (next == string::npos) {
-			next = input_len;
-		}
-
-		// Push the substring [last, next) on to splits
-		string substr = input.substr(last, next - last);
-		if (!substr.empty()) {
-			splits.push_back(substr);
-		}
-		last = next + split_len;
-	}
-	if (splits.empty()) {
-		splits.push_back(input);
-	}
-	return splits;
-}
-
-string StringUtil::Replace(string source, const string &from, const string &to) {
-	if (from.empty()) {
-		throw InternalException("Invalid argument to StringUtil::Replace - empty FROM");
-	}
-	idx_t start_pos = 0;
-	while ((start_pos = source.find(from, start_pos)) != string::npos) {
-		source.replace(start_pos, from.length(), to);
-		start_pos += to.length(); // In case 'to' contains 'from', like
-		                          // replacing 'x' with 'yx'
-	}
-	return source;
-}
-
-vector<string> StringUtil::TopNStrings(vector<pair<string, double>> scores, idx_t n, double threshold) {
-	if (scores.empty()) {
-		return vector<string>();
-	}
-	sort(scores.begin(), scores.end(), [](const pair<string, double> &a, const pair<string, double> &b) -> bool {
-		return a.second > b.second || (a.second == b.second && a.first.size() < b.first.size());
-	});
-	vector<string> result;
-	result.push_back(scores[0].first);
-	for (idx_t i = 1; i < MinValue<idx_t>(scores.size(), n); i++) {
-		if (scores[i].second < threshold) {
-			break;
-		}
-		result.push_back(scores[i].first);
-	}
-	return result;
-}
-
-static double NormalizeScore(idx_t score, idx_t max_score) {
-	return 1.0 - static_cast<double>(score) / static_cast<double>(max_score);
-}
-
-vector<string> StringUtil::TopNStrings(const vector<pair<string, idx_t>> &scores, idx_t n, idx_t threshold) {
-	// obtain the max score to normalize
-	idx_t max_score = threshold;
-	for (auto &score : scores) {
-		if (score.second > max_score) {
-			max_score = score.second;
-		}
-	}
-
-	// normalize
-	vector<pair<string, double>> normalized_scores;
-	for (auto &score : scores) {
-		normalized_scores.push_back(make_pair(score.first, NormalizeScore(score.second, max_score)));
-	}
-	return TopNStrings(std::move(normalized_scores), n, NormalizeScore(threshold, max_score));
-}
-
-struct LevenshteinArray {
-	LevenshteinArray(idx_t len1, idx_t len2) : len1(len1) {
-		dist = make_unsafe_uniq_array<idx_t>(len1 * len2);
-	}
-
-	idx_t &Score(idx_t i, idx_t j) {
-		return dist[GetIndex(i, j)];
-	}
-
-private:
-	idx_t len1;
-	unsafe_unique_array<idx_t> dist;
-
-	idx_t GetIndex(idx_t i, idx_t j) {
-		return j * len1 + i;
-	}
-};
-
-// adapted from https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
-idx_t StringUtil::LevenshteinDistance(const string &s1_p, const string &s2_p, idx_t not_equal_penalty) {
-	auto s1 = StringUtil::Lower(s1_p);
-	auto s2 = StringUtil::Lower(s2_p);
-	idx_t len1 = s1.size();
-	idx_t len2 = s2.size();
-	if (len1 == 0) {
-		return len2;
-	}
-	if (len2 == 0) {
-		return len1;
-	}
-	LevenshteinArray array(len1 + 1, len2 + 1);
-	array.Score(0, 0) = 0;
-	for (idx_t i = 0; i <= len1; i++) {
-		array.Score(i, 0) = i;
-	}
-	for (idx_t j = 0; j <= len2; j++) {
-		array.Score(0, j) = j;
-	}
-	for (idx_t i = 1; i <= len1; i++) {
-		for (idx_t j = 1; j <= len2; j++) {
-			// d[i][j] = std::min({ d[i - 1][j] + 1,
-			//                      d[i][j - 1] + 1,
-			//                      d[i - 1][j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1) });
-			auto equal = s1[i - 1] == s2[j - 1] ? 0 : not_equal_penalty;
-			idx_t adjacent_score1 = array.Score(i - 1, j) + 1;
-			idx_t adjacent_score2 = array.Score(i, j - 1) + 1;
-			idx_t adjacent_score3 = array.Score(i - 1, j - 1) + equal;
-
-			idx_t t = MinValue<idx_t>(adjacent_score1, adjacent_score2);
-			array.Score(i, j) = MinValue<idx_t>(t, adjacent_score3);
-		}
-	}
-	return array.Score(len1, len2);
-}
-
-idx_t StringUtil::SimilarityScore(const string &s1, const string &s2) {
-	return LevenshteinDistance(s1, s2, 3);
-}
-
-double StringUtil::SimilarityRating(const string &s1, const string &s2) {
-	return duckdb_jaro_winkler::jaro_winkler_similarity(s1.data(), s1.data() + s1.size(), s2.data(),
-	                                                    s2.data() + s2.size());
-}
-
-vector<string> StringUtil::TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n,
-                                           idx_t threshold) {
-	vector<pair<string, idx_t>> scores;
-	scores.reserve(strings.size());
-	for (auto &str : strings) {
-		if (target.size() < str.size()) {
-			scores.emplace_back(str, SimilarityScore(str.substr(0, target.size()), target));
-		} else {
-			scores.emplace_back(str, SimilarityScore(str, target));
-		}
-	}
-	return TopNStrings(scores, n, threshold);
-}
-
-vector<string> StringUtil::TopNJaroWinkler(const vector<string> &strings, const string &target, idx_t n,
-                                           double threshold) {
-	vector<pair<string, double>> scores;
-	scores.reserve(strings.size());
-	for (auto &str : strings) {
-		scores.emplace_back(str, SimilarityRating(str, target));
-	}
-	return TopNStrings(scores, n, threshold);
-}
-
-string StringUtil::CandidatesMessage(const vector<string> &candidates, const string &candidate) {
-	string result_str;
-	if (!candidates.empty()) {
-		result_str = "\n" + candidate + ": ";
-		for (idx_t i = 0; i < candidates.size(); i++) {
-			if (i > 0) {
-				result_str += ", ";
-			}
-			result_str += "\"" + candidates[i] + "\"";
-		}
-	}
-	return result_str;
-}
-
-string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const string &target,
-                                          const string &message_prefix, idx_t n) {
-	auto closest_strings = StringUtil::TopNLevenshtein(strings, target, n);
-	return StringUtil::CandidatesMessage(closest_strings, message_prefix);
-}
-
-unordered_map<string, string> StringUtil::ParseJSONMap(const string &json) {
-	unordered_map<string, string> result;
-	if (json.empty()) {
-		return result;
-	}
-	yyjson_read_flag flags = YYJSON_READ_ALLOW_INVALID_UNICODE;
-	yyjson_doc *doc = yyjson_read(json.c_str(), json.size(), flags);
-	if (!doc) {
-		throw SerializationException("Failed to parse JSON string: %s", json);
-	}
-	yyjson_val *root = yyjson_doc_get_root(doc);
-	if (!root || yyjson_get_type(root) != YYJSON_TYPE_OBJ) {
-		yyjson_doc_free(doc);
-		throw SerializationException("Failed to parse JSON string: %s", json);
-	}
-	yyjson_obj_iter iter;
-	yyjson_obj_iter_init(root, &iter);
-	yyjson_val *key, *value;
-	while ((key = yyjson_obj_iter_next(&iter))) {
-		value = yyjson_obj_iter_get_val(key);
-		if (yyjson_get_type(value) != YYJSON_TYPE_STR) {
-			yyjson_doc_free(doc);
-			throw SerializationException("Failed to parse JSON string: %s", json);
-		}
-		auto key_val = yyjson_get_str(key);
-		auto key_len = yyjson_get_len(key);
-		auto value_val = yyjson_get_str(value);
-		auto value_len = yyjson_get_len(value);
-		result.emplace(string(key_val, key_len), string(value_val, value_len));
-	}
-	yyjson_doc_free(doc);
-	return result;
-}
-
-string ToJsonMapInternal(const unordered_map<string, string> &map, yyjson_mut_doc *doc, yyjson_mut_val *root) {
-	for (auto &entry : map) {
-		auto key = yyjson_mut_strncpy(doc, entry.first.c_str(), entry.first.size());
-		auto value = yyjson_mut_strncpy(doc, entry.second.c_str(), entry.second.size());
-		yyjson_mut_obj_add(root, key, value);
-	}
-	yyjson_write_err err;
-	size_t len;
-	constexpr yyjson_write_flag flags = YYJSON_WRITE_ALLOW_INVALID_UNICODE;
-	char *json = yyjson_mut_write_opts(doc, flags, nullptr, &len, &err);
-	if (!json) {
-		yyjson_mut_doc_free(doc);
-		throw SerializationException("Failed to write JSON string: %s", err.msg);
-	}
-	// Create a string from the JSON
-	string result(json, len);
-
-	// Free the JSON and the document
-	free(json);
-	yyjson_mut_doc_free(doc);
-
-	// Return the result
-	return result;
-}
-string StringUtil::ToJSONMap(const unordered_map<string, string> &map) {
-	yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
-	yyjson_mut_val *root = yyjson_mut_obj(doc);
-	yyjson_mut_doc_set_root(doc, root);
-
-	return ToJsonMapInternal(map, doc, root);
-}
-
-string StringUtil::ExceptionToJSONMap(ExceptionType type, const string &message,
-                                      const unordered_map<string, string> &map) {
-	D_ASSERT(map.find("exception_type") == map.end());
-	D_ASSERT(map.find("exception_message") == map.end());
-
-	yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
-	yyjson_mut_val *root = yyjson_mut_obj(doc);
-	yyjson_mut_doc_set_root(doc, root);
-
-	auto except_str = Exception::ExceptionTypeToString(type);
-	yyjson_mut_obj_add_strncpy(doc, root, "exception_type", except_str.c_str(), except_str.size());
-	yyjson_mut_obj_add_strncpy(doc, root, "exception_message", message.c_str(), message.size());
-
-	return ToJsonMapInternal(map, doc, root);
-}
-
-string StringUtil::GetFileName(const string &file_path) {
-
-	idx_t pos = file_path.find_last_of("/\\");
-	if (pos == string::npos) {
-		return file_path;
-	}
-	auto end = file_path.size() - 1;
-
-	// If the rest of the string is just slashes or dots, trim them
-	if (file_path.find_first_not_of("/\\.", pos) == string::npos) {
-		// Trim the trailing slashes and dots
-		while (end > 0 && (file_path[end] == '/' || file_path[end] == '.' || file_path[end] == '\\')) {
-			end--;
-		}
-
-		// Now find the next slash
-		pos = file_path.find_last_of("/\\", end);
-		if (pos == string::npos) {
-			return file_path.substr(0, end + 1);
-		}
-	}
-
-	return file_path.substr(pos + 1, end - pos);
-}
-
-string StringUtil::GetFileExtension(const string &file_name) {
-	auto name = GetFileName(file_name);
-	idx_t pos = name.find_last_of('.');
-	// We dont consider e.g. `.gitignore` to have an extension
-	if (pos == string::npos || pos == 0) {
-		return "";
-	}
-	return name.substr(pos + 1);
-}
-
-string StringUtil::GetFileStem(const string &file_name) {
-	auto name = GetFileName(file_name);
-	if (name.size() > 1 && name[0] == '.') {
-		return name;
-	}
-	idx_t pos = name.find_last_of('.');
-	if (pos == string::npos) {
-		return name;
-	}
-	return name.substr(0, pos);
-}
-
-string StringUtil::GetFilePath(const string &file_path) {
-	// Trim the trailing slashes
-	auto end = file_path.size() - 1;
-	while (end > 0 && (file_path[end] == '/' || file_path[end] == '\\')) {
-		end--;
-	}
-
-	auto pos = file_path.find_last_of("/\\", end);
-	if (pos == string::npos) {
-		return "";
-	}
-
-	while (pos > 0 && (file_path[pos] == '/' || file_path[pos] == '\\')) {
-		pos--;
-	}
-
-	return file_path.substr(0, pos + 1);
-}
-
-struct URLEncodeLength {
-	using RESULT_TYPE = idx_t;
-
-	static void ProcessCharacter(idx_t &result, char) {
-		result++;
-	}
-
-	static void ProcessHex(idx_t &result, const char *, idx_t) {
-		result++;
-	}
-};
-
-struct URLEncodeWrite {
-	using RESULT_TYPE = char *;
-
-	static void ProcessCharacter(char *&result, char c) {
-		*result = c;
-		result++;
-	}
-
-	static void ProcessHex(char *&result, const char *input, idx_t idx) {
-		uint32_t hex_first = StringUtil::GetHexValue(input[idx + 1]);
-		uint32_t hex_second = StringUtil::GetHexValue(input[idx + 2]);
-		uint32_t hex_value = (hex_first << 4) + hex_second;
-		ProcessCharacter(result, static_cast<char>(hex_value));
-	}
-};
-
-template <class OP>
-void URLEncodeInternal(const char *input, idx_t input_size, typename OP::RESULT_TYPE &result, bool encode_slash) {
-	// https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
-	static const char *HEX_DIGIT = "0123456789ABCDEF";
-	for (idx_t i = 0; i < input_size; i++) {
-		char ch = input[i];
-		if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_' ||
-		    ch == '-' || ch == '~' || ch == '.') {
-			OP::ProcessCharacter(result, ch);
-		} else if (ch == '/' && !encode_slash) {
-			OP::ProcessCharacter(result, ch);
-		} else {
-			OP::ProcessCharacter(result, '%');
-			OP::ProcessCharacter(result, HEX_DIGIT[static_cast<unsigned char>(ch) >> 4]);
-			OP::ProcessCharacter(result, HEX_DIGIT[static_cast<unsigned char>(ch) & 15]);
-		}
-	}
-}
-
-idx_t StringUtil::URLEncodeSize(const char *input, idx_t input_size, bool encode_slash) {
-	idx_t result_length = 0;
-	URLEncodeInternal<URLEncodeLength>(input, input_size, result_length, encode_slash);
-	return result_length;
-}
-
-void StringUtil::URLEncodeBuffer(const char *input, idx_t input_size, char *output, bool encode_slash) {
-	URLEncodeInternal<URLEncodeWrite>(input, input_size, output, encode_slash);
-}
-
-string StringUtil::URLEncode(const string &input, bool encode_slash) {
-	idx_t result_size = URLEncodeSize(input.c_str(), input.size(), encode_slash);
-	auto result_data = make_uniq_array<char>(result_size);
-	URLEncodeBuffer(input.c_str(), input.size(), result_data.get(), encode_slash);
-	return string(result_data.get(), result_size);
-}
-
-template <class OP>
-void URLDecodeInternal(const char *input, idx_t input_size, typename OP::RESULT_TYPE &result, bool plus_to_space) {
-	for (idx_t i = 0; i < input_size; i++) {
-		char ch = input[i];
-		if (plus_to_space && ch == '+') {
-			OP::ProcessCharacter(result, ' ');
-		} else if (ch == '%' && i + 2 < input_size && StringUtil::CharacterIsHex(input[i + 1]) &&
-		           StringUtil::CharacterIsHex(input[i + 2])) {
-			OP::ProcessHex(result, input, i);
-			i += 2;
-		} else {
-			OP::ProcessCharacter(result, ch);
-		}
-	}
-}
-
-idx_t StringUtil::URLDecodeSize(const char *input, idx_t input_size, bool plus_to_space) {
-	idx_t result_length = 0;
-	URLDecodeInternal<URLEncodeLength>(input, input_size, result_length, plus_to_space);
-	return result_length;
-}
-
-void StringUtil::URLDecodeBuffer(const char *input, idx_t input_size, char *output, bool plus_to_space) {
-	char *output_start = output;
-	URLDecodeInternal<URLEncodeWrite>(input, input_size, output, plus_to_space);
-	if (!Utf8Proc::IsValid(output_start, NumericCast<idx_t>(output - output_start))) {
-		throw InvalidInputException("Failed to decode string \"%s\" using URL decoding - decoded value is invalid UTF8",
-		                            string(input, input_size));
-	}
-}
-
-string StringUtil::URLDecode(const string &input, bool plus_to_space) {
-	idx_t result_size = URLDecodeSize(input.c_str(), input.size(), plus_to_space);
-	auto result_data = make_uniq_array<char>(result_size);
-	URLDecodeBuffer(input.c_str(), input.size(), result_data.get(), plus_to_space);
-	return string(result_data.get(), result_size);
-}
-
-uint32_t StringUtil::StringToEnum(const EnumStringLiteral enum_list[], idx_t enum_count, const char *enum_name,
-                                  const char *str_value) {
-	for (idx_t i = 0; i < enum_count; i++) {
-		if (CIEquals(enum_list[i].string, str_value)) {
-			return enum_list[i].number;
-		}
-	}
-	// string to enum conversion failed - generate candidates
-	vector<string> candidates;
-	for (idx_t i = 0; i < enum_count; i++) {
-		candidates.push_back(enum_list[i].string);
-	}
-	auto closest_values = TopNJaroWinkler(candidates, str_value);
-	auto message = CandidatesMessage(closest_values, "Candidates");
-	throw NotImplementedException("Enum value: unrecognized value \"%s\" for enum \"%s\"\n%s", str_value, enum_name,
-	                              message);
-}
-
-const char *StringUtil::EnumToString(const EnumStringLiteral enum_list[], idx_t enum_count, const char *enum_name,
-                                     uint32_t enum_value) {
-	for (idx_t i = 0; i < enum_count; i++) {
-		if (enum_list[i].number == enum_value) {
-			return enum_list[i].string;
-		}
-	}
-	throw NotImplementedException("Enum value: unrecognized enum value \"%d\" for enum \"%s\"", enum_value, enum_name);
-}
-
-const uint8_t StringUtil::ASCII_TO_UPPER_MAP[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
-    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-    44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
-    66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
-    88,  89,  90,  91,  92,  93,  94,  95,  96,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
-    78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  123, 124, 125, 126, 127, 128, 129, 130, 131,
-    132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-    154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
-    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
-    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
-
-const uint8_t StringUtil::ASCII_TO_LOWER_MAP[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
-    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-    44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  97,
-    98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
-    120, 121, 122, 91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
-    110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
-    132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-    154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
-    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
-    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/tree_renderer.cpp b/src/duckdb/src/common/tree_renderer.cpp
deleted file mode 100644
index c924ff260..000000000
--- a/src/duckdb/src/common/tree_renderer.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/tree_renderer/text_tree_renderer.hpp"
-#include "duckdb/common/tree_renderer/json_tree_renderer.hpp"
-#include "duckdb/common/tree_renderer/html_tree_renderer.hpp"
-#include "duckdb/common/tree_renderer/graphviz_tree_renderer.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-unique_ptr<TreeRenderer> TreeRenderer::CreateRenderer(ExplainFormat format) {
-	switch (format) {
-	case ExplainFormat::DEFAULT:
-	case ExplainFormat::TEXT:
-		return make_uniq<TextTreeRenderer>();
-	case ExplainFormat::JSON:
-		return make_uniq<JSONTreeRenderer>();
-	case ExplainFormat::HTML:
-		return make_uniq<HTMLTreeRenderer>();
-	case ExplainFormat::GRAPHVIZ:
-		return make_uniq<GRAPHVIZTreeRenderer>();
-	default:
-		throw NotImplementedException("ExplainFormat %s not implemented", EnumUtil::ToString(format));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/tree_renderer/graphviz_tree_renderer.cpp b/src/duckdb/src/common/tree_renderer/graphviz_tree_renderer.cpp
deleted file mode 100644
index 40a93b692..000000000
--- a/src/duckdb/src/common/tree_renderer/graphviz_tree_renderer.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "duckdb/common/tree_renderer/graphviz_tree_renderer.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-string GRAPHVIZTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string GRAPHVIZTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string GRAPHVIZTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string GRAPHVIZTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-void GRAPHVIZTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void GRAPHVIZTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void GRAPHVIZTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void GRAPHVIZTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void GRAPHVIZTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
-	const string digraph_format = R"(
-digraph G {
-    node [shape=box, style=rounded, fontname="Courier New", fontsize=10];
-%s
-%s
-}
-	)";
-
-	vector<string> nodes;
-	vector<string> edges;
-
-	const string node_format = R"(    node_%d_%d [label="%s"];)";
-
-	for (idx_t y = 0; y < root.height; y++) {
-		for (idx_t x = 0; x < root.width; x++) {
-			auto node = root.GetNode(x, y);
-			if (!node) {
-				continue;
-			}
-
-			// Create Node
-			vector<string> body;
-			body.push_back(node->name);
-			for (auto &item : node->extra_text) {
-				auto &key = item.first;
-				auto &value_raw = item.second;
-
-				auto value = QueryProfiler::JSONSanitize(value_raw);
-				body.push_back(StringUtil::Format("%s:\\n%s", key, value));
-			}
-			nodes.push_back(StringUtil::Format(node_format, x, y, StringUtil::Join(body, "\\n───\\n")));
-
-			// Create Edge(s)
-			for (auto &coord : node->child_positions) {
-				edges.push_back(StringUtil::Format("    node_%d_%d -> node_%d_%d;", x, y, coord.x, coord.y));
-			}
-		}
-	}
-	auto node_lines = StringUtil::Join(nodes, "\n");
-	auto edge_lines = StringUtil::Join(edges, "\n");
-
-	string result = StringUtil::Format(digraph_format, node_lines, edge_lines);
-	ss << result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/tree_renderer/html_tree_renderer.cpp b/src/duckdb/src/common/tree_renderer/html_tree_renderer.cpp
deleted file mode 100644
index 66a8f2d1d..000000000
--- a/src/duckdb/src/common/tree_renderer/html_tree_renderer.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-#include "duckdb/common/tree_renderer/html_tree_renderer.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-string HTMLTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string HTMLTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string HTMLTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string HTMLTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-void HTMLTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void HTMLTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void HTMLTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void HTMLTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-static string CreateStyleSection(RenderTree &root) {
-	return R"(
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-        }
-
-        .tf-tree .tf-nc {
-            padding: 0px;
-            border: 1px solid #E5E5E5;
-        }
-
-        .tf-nc {
-            border-radius: 0.5rem;
-            padding: 0px;
-            min-width: 150px;
-            width: auto;
-            background-color: #FAFAFA;
-            text-align: center;
-            position: relative;
-        }
-
-        .collapse_button {
-            position:relative;
-            color: black;
-            z-index: 2;
-            width: 2em;
-            background-color: white;
-            height: 2em;
-            border-radius: 50%;
-            top: 2.25em;
-        }
-
-        .collapse_button:hover {
-            background-color: #f0f0f0; /* Light gray */
-        }
-
-        .collapse_button:active {
-            background-color: #e0e0e0; /* Slightly darker gray */
-        }
-
-        .hidden {
-            display: none !important;
-        }
-
-        .title {
-            font-weight: bold;
-            padding-bottom: 5px;
-            color: #fff100;
-            box-sizing: border-box;
-            background-color: black;
-            border-top-left-radius: 0.5rem;
-            border-top-right-radius: 0.5rem;
-            padding: 10px;
-        }
-
-        .content {
-            border-top: 1px solid #000;
-            text-align: center;
-            border-bottom-left-radius: 0.5rem;
-            border-bottom-right-radius: 0.5rem;
-            padding: 10px;
-        }
-
-        .sub-title {
-            color: black;
-            font-weight: bold;
-            padding-top: 5px;
-        }
-
-        .sub-title:not(:first-child) {
-            border-top: 1px solid #ADADAD;
-        }
-
-        .value {
-            margin-left: 10px;
-            margin-top: 5px;
-            color: #3B3B3B;
-            margin-bottom: 5px;
-        }
-
-        .tf-tree {
-            width: 100%;
-            height: 100%;
-            overflow: visible;
-        }
-    </style>
-    )";
-}
-
-static string CreateHeadSection(RenderTree &root) {
-	string head_section = R"(
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <link rel="stylesheet" href="https://unpkg.com/treeflex/dist/css/treeflex.css">
-    <title>DuckDB Query Plan</title>
-    %s
-</head>
-    )";
-	return StringUtil::Format(head_section, CreateStyleSection(root));
-}
-
-static string CreateGridItemContent(RenderTreeNode &node) {
-	const string content_format = R"(
-            <div class="content">
-%s
-            </div>
-    )";
-
-	vector<string> items;
-	for (auto &item : node.extra_text) {
-		auto &key = item.first;
-		auto &value = item.second;
-		if (value.empty()) {
-			continue;
-		}
-		items.push_back(StringUtil::Format(R"(                <div class="sub-title">%s</div>)", key));
-		auto splits = StringUtil::Split(value, "\n");
-		for (auto &split : splits) {
-			items.push_back(StringUtil::Format(R"(                <div class="value">%s</div>)", split));
-		}
-	}
-	string result;
-	if (!items.empty()) {
-		result = StringUtil::Format(content_format, StringUtil::Join(items, "\n"));
-	}
-	if (!node.child_positions.empty()) {
-		result += "<button class=\"collapse_button\", onclick=\"toggleDisplay(this)\">-</button>";
-	}
-	return result;
-}
-
-static string CreateGridItem(RenderTree &root, idx_t x, idx_t y) {
-	const string grid_item_format = R"(
-        <div class="tf-nc">
-            <div class="title">%s</div>%s
-        </div>
-    )";
-
-	auto node = root.GetNode(x, y);
-	if (!node) {
-		return "";
-	}
-
-	auto title = node->name;
-	auto content = CreateGridItemContent(*node);
-	return StringUtil::Format(grid_item_format, title, content);
-}
-
-static string CreateTreeRecursive(RenderTree &root, idx_t x, idx_t y) {
-	string result;
-
-	result += "<li>";
-	result += CreateGridItem(root, x, y);
-	auto node = root.GetNode(x, y);
-	if (!node->child_positions.empty()) {
-		result += "<ul class=\"list-inline\">";
-		for (auto &coord : node->child_positions) {
-			result += CreateTreeRecursive(root, coord.x, coord.y);
-		}
-		result += "</ul>";
-	}
-	result += "</li>";
-	return result;
-}
-
-static string CreateBodySection(RenderTree &root) {
-	const string body_section = R"(
-<body>
-    <div class="tf-tree">
-        <ul>%s</ul>
-    </div>
-
-<script>
-function toggleDisplay(button) {
-    const parentLi = button.closest('li');
-    const nestedUl = parentLi.querySelector('ul');
-    if (nestedUl) {
-        const currentDisplay = getComputedStyle(nestedUl).getPropertyValue('display');
-        if (currentDisplay === 'none') {
-            nestedUl.classList.toggle('hidden');
-            button.textContent = '-';
-        } else {
-            nestedUl.classList.toggle('hidden');
-            button.textContent = '+';
-        }
-    }
-}
-</script>
-
-</body>
-</html>
-    )";
-	return StringUtil::Format(body_section, CreateTreeRecursive(root, 0, 0));
-}
-
-void HTMLTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
-	string result;
-	result += CreateHeadSection(root);
-	result += CreateBodySection(root);
-	ss << result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/tree_renderer/json_tree_renderer.cpp b/src/duckdb/src/common/tree_renderer/json_tree_renderer.cpp
deleted file mode 100644
index edc9309be..000000000
--- a/src/duckdb/src/common/tree_renderer/json_tree_renderer.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/common/tree_renderer/json_tree_renderer.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include "yyjson.hpp"
-
-#include <sstream>
-
-using namespace duckdb_yyjson; // NOLINT
-
-namespace duckdb {
-
-string JSONTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string JSONTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string JSONTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string JSONTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-void JSONTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void JSONTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void JSONTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void JSONTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-static yyjson_mut_val *RenderRecursive(yyjson_mut_doc *doc, RenderTree &tree, idx_t x, idx_t y) {
-	auto node_p = tree.GetNode(x, y);
-	D_ASSERT(node_p);
-	auto &node = *node_p;
-
-	auto object = yyjson_mut_obj(doc);
-	auto children = yyjson_mut_arr(doc);
-	for (auto &child_pos : node.child_positions) {
-		auto child_object = RenderRecursive(doc, tree, child_pos.x, child_pos.y);
-		yyjson_mut_arr_append(children, child_object);
-	}
-	yyjson_mut_obj_add_str(doc, object, "name", node.name.c_str());
-	yyjson_mut_obj_add_val(doc, object, "children", children);
-	auto extra_info = yyjson_mut_obj(doc);
-	for (auto &it : node.extra_text) {
-		auto &key = it.first;
-		auto &value = it.second;
-		auto splits = StringUtil::Split(value, "\n");
-		if (splits.size() > 1) {
-			auto list_items = yyjson_mut_arr(doc);
-			for (auto &split : splits) {
-				yyjson_mut_arr_add_strcpy(doc, list_items, split.c_str());
-			}
-			yyjson_mut_obj_add_val(doc, extra_info, key.c_str(), list_items);
-		} else {
-			yyjson_mut_obj_add_strcpy(doc, extra_info, key.c_str(), value.c_str());
-		}
-	}
-	yyjson_mut_obj_add_val(doc, object, "extra_info", extra_info);
-	return object;
-}
-
-void JSONTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
-	auto doc = yyjson_mut_doc_new(nullptr);
-	auto result_obj = yyjson_mut_arr(doc);
-	yyjson_mut_doc_set_root(doc, result_obj);
-
-	auto plan = RenderRecursive(doc, root, 0, 0);
-	yyjson_mut_arr_append(result_obj, plan);
-
-	auto data = yyjson_mut_val_write_opts(result_obj, YYJSON_WRITE_ALLOW_INF_AND_NAN | YYJSON_WRITE_PRETTY, nullptr,
-	                                      nullptr, nullptr);
-	if (!data) {
-		yyjson_mut_doc_free(doc);
-		throw InternalException("The plan could not be rendered as JSON, yyjson failed");
-	}
-	ss << string(data);
-	free(data);
-	yyjson_mut_doc_free(doc);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/tree_renderer/text_tree_renderer.cpp b/src/duckdb/src/common/tree_renderer/text_tree_renderer.cpp
deleted file mode 100644
index fa24ee103..000000000
--- a/src/duckdb/src/common/tree_renderer/text_tree_renderer.cpp
+++ /dev/null
@@ -1,494 +0,0 @@
-#include "duckdb/common/tree_renderer/text_tree_renderer.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-#include <sstream>
-
-namespace duckdb {
-
-namespace {
-
-struct StringSegment {
-public:
-	StringSegment(idx_t start, idx_t width) : start(start), width(width) {
-	}
-
-public:
-	idx_t start;
-	idx_t width;
-};
-
-} // namespace
-
-void TextTreeRenderer::RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y) {
-	for (idx_t x = 0; x < root.width; x++) {
-		if (x * config.node_render_width >= config.maximum_render_width) {
-			break;
-		}
-		if (root.HasNode(x, y)) {
-			ss << config.LTCORNER;
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
-			if (y == 0) {
-				// top level node: no node above this one
-				ss << config.HORIZONTAL;
-			} else {
-				// render connection to node above this one
-				ss << config.DMIDDLE;
-			}
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
-			ss << config.RTCORNER;
-		} else {
-			bool has_adjacent_nodes = false;
-			for (idx_t i = 0; x + i < root.width; i++) {
-				has_adjacent_nodes = has_adjacent_nodes || root.HasNode(x + i, y);
-			}
-			if (!has_adjacent_nodes) {
-				// There are no nodes to the right side of this position
-				// no need to fill the empty space
-				continue;
-			}
-			// there are nodes next to this, fill the space
-			ss << StringUtil::Repeat(" ", config.node_render_width);
-		}
-	}
-	ss << '\n';
-}
-
-static bool NodeHasMultipleChildren(RenderTreeNode &node) {
-	return node.child_positions.size() > 1;
-}
-
-static bool ShouldRenderWhitespace(RenderTree &root, idx_t x, idx_t y) {
-	idx_t found_children = 0;
-	for (;; x--) {
-		auto node = root.GetNode(x, y);
-		if (root.HasNode(x, y + 1)) {
-			found_children++;
-		}
-		if (node) {
-			if (NodeHasMultipleChildren(*node)) {
-				if (found_children < node->child_positions.size()) {
-					return true;
-				}
-			}
-			return false;
-		}
-		if (x == 0) {
-			break;
-		}
-	}
-	return false;
-}
-
-void TextTreeRenderer::RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y) {
-	for (idx_t x = 0; x <= root.width; x++) {
-		if (x * config.node_render_width >= config.maximum_render_width) {
-			break;
-		}
-		bool has_adjacent_nodes = false;
-		for (idx_t i = 0; x + i < root.width; i++) {
-			has_adjacent_nodes = has_adjacent_nodes || root.HasNode(x + i, y);
-		}
-		auto node = root.GetNode(x, y);
-		if (node) {
-			ss << config.LDCORNER;
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
-			if (root.HasNode(x, y + 1)) {
-				// node below this one: connect to that one
-				ss << config.TMIDDLE;
-			} else {
-				// no node below this one: end the box
-				ss << config.HORIZONTAL;
-			}
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2 - 1);
-			ss << config.RDCORNER;
-		} else if (root.HasNode(x, y + 1)) {
-			ss << StringUtil::Repeat(" ", config.node_render_width / 2);
-			ss << config.VERTICAL;
-			if (has_adjacent_nodes || ShouldRenderWhitespace(root, x, y)) {
-				ss << StringUtil::Repeat(" ", config.node_render_width / 2);
-			}
-		} else {
-			if (has_adjacent_nodes || ShouldRenderWhitespace(root, x, y)) {
-				ss << StringUtil::Repeat(" ", config.node_render_width);
-			}
-		}
-	}
-	ss << '\n';
-}
-
-string AdjustTextForRendering(string source, idx_t max_render_width) {
-	const idx_t size = source.size();
-	const char *input = source.c_str();
-
-	idx_t render_width = 0;
-
-	// For every character in the input, create a StringSegment
-	vector<StringSegment> render_widths;
-	idx_t current_position = 0;
-	while (current_position < size) {
-		idx_t char_render_width = Utf8Proc::RenderWidth(input, size, current_position);
-		current_position = Utf8Proc::NextGraphemeCluster(input, size, current_position);
-		render_width += char_render_width;
-		render_widths.push_back(StringSegment(current_position, render_width));
-		if (render_width > max_render_width) {
-			break;
-		}
-	}
-
-	if (render_width > max_render_width) {
-		// need to find a position to truncate
-		for (idx_t pos = render_widths.size(); pos > 0; pos--) {
-			auto &source_range = render_widths[pos - 1];
-			if (source_range.width < max_render_width - 4) {
-				return source.substr(0, source_range.start) + string("...") +
-				       string(max_render_width - source_range.width - 3, ' ');
-			}
-		}
-		source = "...";
-	}
-	// need to pad with spaces
-	idx_t total_spaces = max_render_width - render_width;
-	idx_t half_spaces = total_spaces / 2;
-	idx_t extra_left_space = total_spaces % 2 == 0 ? 0 : 1;
-	return string(half_spaces + extra_left_space, ' ') + source + string(half_spaces, ' ');
-}
-
-void TextTreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y) {
-	// we first need to figure out how high our boxes are going to be
-	vector<vector<string>> extra_info;
-	idx_t extra_height = 0;
-	extra_info.resize(root.width);
-	for (idx_t x = 0; x < root.width; x++) {
-		auto node = root.GetNode(x, y);
-		if (node) {
-			SplitUpExtraInfo(node->extra_text, extra_info[x], config.max_extra_lines);
-			if (extra_info[x].size() > extra_height) {
-				extra_height = extra_info[x].size();
-			}
-		}
-	}
-	idx_t halfway_point = (extra_height + 1) / 2;
-	// now we render the actual node
-	for (idx_t render_y = 0; render_y <= extra_height; render_y++) {
-		for (idx_t x = 0; x < root.width; x++) {
-			if (x * config.node_render_width >= config.maximum_render_width) {
-				break;
-			}
-			bool has_adjacent_nodes = false;
-			for (idx_t i = 0; x + i < root.width; i++) {
-				has_adjacent_nodes = has_adjacent_nodes || root.HasNode(x + i, y);
-			}
-			auto node = root.GetNode(x, y);
-			if (!node) {
-				if (render_y == halfway_point) {
-					bool has_child_to_the_right = ShouldRenderWhitespace(root, x, y);
-					if (root.HasNode(x, y + 1)) {
-						// node right below this one
-						ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2);
-						if (has_child_to_the_right) {
-							ss << config.TMIDDLE;
-							// but we have another child to the right! keep rendering the line
-							ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width / 2);
-						} else {
-							ss << config.RTCORNER;
-							if (has_adjacent_nodes) {
-								// only a child below this one: fill the rest with spaces
-								ss << StringUtil::Repeat(" ", config.node_render_width / 2);
-							}
-						}
-					} else if (has_child_to_the_right) {
-						// child to the right, but no child right below this one: render a full line
-						ss << StringUtil::Repeat(config.HORIZONTAL, config.node_render_width);
-					} else {
-						if (has_adjacent_nodes) {
-							// empty spot: render spaces
-							ss << StringUtil::Repeat(" ", config.node_render_width);
-						}
-					}
-				} else if (render_y >= halfway_point) {
-					if (root.HasNode(x, y + 1)) {
-						// we have a node below this empty spot: render a vertical line
-						ss << StringUtil::Repeat(" ", config.node_render_width / 2);
-						ss << config.VERTICAL;
-						if (has_adjacent_nodes || ShouldRenderWhitespace(root, x, y)) {
-							ss << StringUtil::Repeat(" ", config.node_render_width / 2);
-						}
-					} else {
-						if (has_adjacent_nodes || ShouldRenderWhitespace(root, x, y)) {
-							// empty spot: render spaces
-							ss << StringUtil::Repeat(" ", config.node_render_width);
-						}
-					}
-				} else {
-					if (has_adjacent_nodes) {
-						// empty spot: render spaces
-						ss << StringUtil::Repeat(" ", config.node_render_width);
-					}
-				}
-			} else {
-				ss << config.VERTICAL;
-				// figure out what to render
-				string render_text;
-				if (render_y == 0) {
-					render_text = node->name;
-				} else {
-					if (render_y <= extra_info[x].size()) {
-						render_text = extra_info[x][render_y - 1];
-					}
-				}
-				if (render_y + 1 == extra_height && render_text.empty()) {
-					auto entry = node->extra_text.find(RenderTreeNode::CARDINALITY);
-					if (entry != node->extra_text.end()) {
-						render_text = entry->second + " Rows";
-					}
-				}
-				if (render_y == extra_height && render_text.empty()) {
-					auto timing_entry = node->extra_text.find(RenderTreeNode::TIMING);
-					if (timing_entry != node->extra_text.end()) {
-						render_text = "(" + timing_entry->second + ")";
-					} else if (node->extra_text.find(RenderTreeNode::CARDINALITY) == node->extra_text.end()) {
-						// we only render estimated cardinality if there is no real cardinality
-						auto entry = node->extra_text.find(RenderTreeNode::ESTIMATED_CARDINALITY);
-						if (entry != node->extra_text.end()) {
-							render_text = "~" + entry->second + " Rows";
-						}
-					}
-					if (node->extra_text.find(RenderTreeNode::CARDINALITY) == node->extra_text.end()) {
-						// we only render estimated cardinality if there is no real cardinality
-						auto entry = node->extra_text.find(RenderTreeNode::ESTIMATED_CARDINALITY);
-						if (entry != node->extra_text.end()) {
-							render_text = "~" + entry->second + " Rows";
-						}
-					}
-				}
-				render_text = AdjustTextForRendering(render_text, config.node_render_width - 2);
-				ss << render_text;
-
-				if (render_y == halfway_point && NodeHasMultipleChildren(*node)) {
-					ss << config.LMIDDLE;
-				} else {
-					ss << config.VERTICAL;
-				}
-			}
-		}
-		ss << '\n';
-	}
-}
-
-string TextTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string TextTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string TextTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string TextTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-void TextTreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void TextTreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void TextTreeRenderer::Render(const ProfilingNode &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void TextTreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
-	auto tree = RenderTree::CreateRenderTree(op);
-	ToStream(*tree, ss);
-}
-
-void TextTreeRenderer::ToStreamInternal(RenderTree &root, std::ostream &ss) {
-	while (root.width * config.node_render_width > config.maximum_render_width) {
-		if (config.node_render_width - 2 < config.minimum_render_width) {
-			break;
-		}
-		config.node_render_width -= 2;
-	}
-
-	for (idx_t y = 0; y < root.height; y++) {
-		// start by rendering the top layer
-		RenderTopLayer(root, ss, y);
-		// now we render the content of the boxes
-		RenderBoxContent(root, ss, y);
-		// render the bottom layer of each of the boxes
-		RenderBottomLayer(root, ss, y);
-	}
-}
-
-bool TextTreeRenderer::CanSplitOnThisChar(char l) {
-	return (l < '0' || (l > '9' && l < 'A') || (l > 'Z' && l < 'a')) && l != '_';
-}
-
-bool TextTreeRenderer::IsPadding(char l) {
-	return l == ' ' || l == '\t' || l == '\n' || l == '\r';
-}
-
-string TextTreeRenderer::RemovePadding(string l) {
-	idx_t start = 0, end = l.size();
-	while (start < l.size() && IsPadding(l[start])) {
-		start++;
-	}
-	while (end > 0 && IsPadding(l[end - 1])) {
-		end--;
-	}
-	return l.substr(start, end - start);
-}
-
-void TextTreeRenderer::SplitStringBuffer(const string &source, vector<string> &result) {
-	D_ASSERT(Utf8Proc::IsValid(source.c_str(), source.size()));
-	const idx_t max_line_render_size = config.node_render_width - 2;
-	// utf8 in prompt, get render width
-	idx_t character_pos = 0;
-	idx_t start_pos = 0;
-	idx_t render_width = 0;
-	idx_t last_possible_split = 0;
-
-	const idx_t size = source.size();
-	const char *input = source.c_str();
-
-	while (character_pos < size) {
-		size_t char_render_width = Utf8Proc::RenderWidth(input, size, character_pos);
-		idx_t next_character_pos = Utf8Proc::NextGraphemeCluster(input, size, character_pos);
-
-		// Does the next character make us exceed the line length?
-		if (render_width + char_render_width > max_line_render_size) {
-			if (start_pos + 8 > last_possible_split) {
-				// The last character we can split on is one of the first 8 characters of the line
-				// to not create very small lines we instead split on the current character
-				last_possible_split = character_pos;
-			}
-			result.push_back(source.substr(start_pos, last_possible_split - start_pos));
-			render_width = character_pos - last_possible_split;
-			start_pos = last_possible_split;
-			character_pos = last_possible_split;
-		}
-		// check if we can split on this character
-		if (CanSplitOnThisChar(source[character_pos])) {
-			last_possible_split = character_pos;
-		}
-		character_pos = next_character_pos;
-		render_width += char_render_width;
-	}
-	if (size > start_pos) {
-		// append the remainder of the input
-		result.push_back(source.substr(start_pos, size - start_pos));
-	}
-}
-
-void TextTreeRenderer::SplitUpExtraInfo(const InsertionOrderPreservingMap<string> &extra_info, vector<string> &result,
-                                        idx_t max_lines) {
-	if (extra_info.empty()) {
-		return;
-	}
-	for (auto &item : extra_info) {
-		auto &text = item.second;
-		if (!Utf8Proc::IsValid(text.c_str(), text.size())) {
-			return;
-		}
-	}
-	result.push_back(ExtraInfoSeparator());
-
-	bool requires_padding = false;
-	bool was_inlined = false;
-	for (auto &item : extra_info) {
-		string str = RemovePadding(item.second);
-		if (str.empty()) {
-			continue;
-		}
-		bool is_inlined = false;
-		if (!StringUtil::StartsWith(item.first, "__")) {
-			// the name is not internal (i.e. not __text__) - so we display the name in addition to the entry
-			const idx_t available_width = (config.node_render_width - 7);
-			idx_t total_size = item.first.size() + str.size() + 2;
-			bool is_multiline = StringUtil::Contains(str, "\n");
-			if (!is_multiline && total_size < available_width) {
-				// we can inline the full entry - no need for any separators unless the previous entry explicitly
-				// requires it
-				str = item.first + ": " + str;
-				is_inlined = true;
-			} else {
-				str = item.first + ":\n" + str;
-			}
-		}
-		if (is_inlined && was_inlined) {
-			// we can skip the padding if we have multiple inlined entries in a row
-			requires_padding = false;
-		}
-		if (requires_padding) {
-			result.emplace_back();
-		}
-		// cardinality, timing and estimated cardinality are rendered separately
-		// this is to allow alignment horizontally across nodes
-		if (item.first == RenderTreeNode::CARDINALITY) {
-			// cardinality - need to reserve space for cardinality AND timing
-			result.emplace_back();
-			if (extra_info.find(RenderTreeNode::TIMING) != extra_info.end()) {
-				result.emplace_back();
-			}
-			break;
-		}
-		if (item.first == RenderTreeNode::ESTIMATED_CARDINALITY) {
-			// estimated cardinality - reserve space for estimate
-			if (extra_info.find(RenderTreeNode::CARDINALITY) != extra_info.end()) {
-				// if we have a true cardinality render that instead of the estimate
-				result.pop_back();
-				continue;
-			}
-			result.emplace_back();
-			break;
-		}
-		auto splits = StringUtil::Split(str, "\n");
-		if (splits.size() > max_lines) {
-			// truncate this entry
-			vector<string> truncated_splits;
-			for (idx_t i = 0; i < max_lines / 2; i++) {
-				truncated_splits.push_back(std::move(splits[i]));
-			}
-			truncated_splits.push_back("...");
-			for (idx_t i = splits.size() - max_lines / 2; i < splits.size(); i++) {
-				truncated_splits.push_back(std::move(splits[i]));
-			}
-			splits = std::move(truncated_splits);
-		}
-		for (auto &split : splits) {
-			SplitStringBuffer(split, result);
-		}
-		requires_padding = true;
-		was_inlined = is_inlined;
-	}
-}
-
-string TextTreeRenderer::ExtraInfoSeparator() {
-	return StringUtil::Repeat(string(config.HORIZONTAL), (config.node_render_width - 9));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/tree_renderer/tree_renderer.cpp b/src/duckdb/src/common/tree_renderer/tree_renderer.cpp
deleted file mode 100644
index b0a58b597..000000000
--- a/src/duckdb/src/common/tree_renderer/tree_renderer.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "duckdb/common/tree_renderer.hpp"
-
-namespace duckdb {
-
-void TreeRenderer::ToStream(RenderTree &root, std::ostream &ss) {
-	if (!UsesRawKeyNames()) {
-		root.SanitizeKeyNames();
-	}
-	return ToStreamInternal(root, ss);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types.cpp b/src/duckdb/src/common/types.cpp
deleted file mode 100644
index 342a84bc0..000000000
--- a/src/duckdb/src/common/types.cpp
+++ /dev/null
@@ -1,1914 +0,0 @@
-#include "duckdb/common/types.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/catalog/default/default_types.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/function/cast_rules.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/parser/parser.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-LogicalType::LogicalType() : LogicalType(LogicalTypeId::INVALID) {
-}
-
-LogicalType::LogicalType(LogicalTypeId id) : id_(id) {
-	physical_type_ = GetInternalType();
-}
-LogicalType::LogicalType(LogicalTypeId id, shared_ptr<ExtraTypeInfo> type_info_p)
-    : id_(id), type_info_(std::move(type_info_p)) {
-	physical_type_ = GetInternalType();
-}
-
-LogicalType::LogicalType(const LogicalType &other)
-    : id_(other.id_), physical_type_(other.physical_type_), type_info_(other.type_info_) {
-}
-
-LogicalType::LogicalType(LogicalType &&other) noexcept
-    : id_(other.id_), physical_type_(other.physical_type_), type_info_(std::move(other.type_info_)) {
-}
-
-hash_t LogicalType::Hash() const {
-	return duckdb::Hash<uint8_t>((uint8_t)id_);
-}
-
-PhysicalType LogicalType::GetInternalType() {
-	switch (id_) {
-	case LogicalTypeId::BOOLEAN:
-		return PhysicalType::BOOL;
-	case LogicalTypeId::TINYINT:
-		return PhysicalType::INT8;
-	case LogicalTypeId::UTINYINT:
-		return PhysicalType::UINT8;
-	case LogicalTypeId::SMALLINT:
-		return PhysicalType::INT16;
-	case LogicalTypeId::USMALLINT:
-		return PhysicalType::UINT16;
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::INTEGER:
-		return PhysicalType::INT32;
-	case LogicalTypeId::UINTEGER:
-		return PhysicalType::UINT32;
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return PhysicalType::INT64;
-	case LogicalTypeId::UBIGINT:
-		return PhysicalType::UINT64;
-	case LogicalTypeId::UHUGEINT:
-		return PhysicalType::UINT128;
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UUID:
-		return PhysicalType::INT128;
-	case LogicalTypeId::FLOAT:
-		return PhysicalType::FLOAT;
-	case LogicalTypeId::DOUBLE:
-		return PhysicalType::DOUBLE;
-	case LogicalTypeId::DECIMAL: {
-		if (!type_info_) {
-			return PhysicalType::INVALID;
-		}
-		auto width = DecimalType::GetWidth(*this);
-		if (width <= Decimal::MAX_WIDTH_INT16) {
-			return PhysicalType::INT16;
-		} else if (width <= Decimal::MAX_WIDTH_INT32) {
-			return PhysicalType::INT32;
-		} else if (width <= Decimal::MAX_WIDTH_INT64) {
-			return PhysicalType::INT64;
-		} else if (width <= Decimal::MAX_WIDTH_INT128) {
-			return PhysicalType::INT128;
-		} else {
-			throw InternalException("Decimal has a width of %d which is bigger than the maximum supported width of %d",
-			                        width, DecimalType::MaxWidth());
-		}
-	}
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::CHAR:
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
-	case LogicalTypeId::VARINT:
-		return PhysicalType::VARCHAR;
-	case LogicalTypeId::INTERVAL:
-		return PhysicalType::INTERVAL;
-	case LogicalTypeId::UNION:
-	case LogicalTypeId::STRUCT:
-		return PhysicalType::STRUCT;
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-		return PhysicalType::LIST;
-	case LogicalTypeId::ARRAY:
-		return PhysicalType::ARRAY;
-	case LogicalTypeId::POINTER:
-		// LCOV_EXCL_START
-		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
-			return PhysicalType::UINT32;
-		} else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
-			return PhysicalType::UINT64;
-		} else {
-			throw InternalException("Unsupported pointer size");
-		}
-		// LCOV_EXCL_STOP
-	case LogicalTypeId::VALIDITY:
-		return PhysicalType::BIT;
-	case LogicalTypeId::ENUM: {
-		if (!type_info_) {
-			return PhysicalType::INVALID;
-		}
-		return EnumType::GetPhysicalType(*this);
-	}
-	case LogicalTypeId::TABLE:
-	case LogicalTypeId::LAMBDA:
-	case LogicalTypeId::ANY:
-	case LogicalTypeId::INVALID:
-	case LogicalTypeId::UNKNOWN:
-	case LogicalTypeId::STRING_LITERAL:
-	case LogicalTypeId::INTEGER_LITERAL:
-		return PhysicalType::INVALID;
-	case LogicalTypeId::USER:
-		return PhysicalType::UNKNOWN;
-	case LogicalTypeId::AGGREGATE_STATE:
-		return PhysicalType::VARCHAR;
-	default:
-		throw InternalException("Invalid LogicalType %s", ToString());
-	}
-}
-
-// **DEPRECATED**: Use EnumUtil directly instead.
-string LogicalTypeIdToString(LogicalTypeId type) {
-	return EnumUtil::ToString(type);
-}
-
-constexpr const LogicalTypeId LogicalType::INVALID;
-constexpr const LogicalTypeId LogicalType::SQLNULL;
-constexpr const LogicalTypeId LogicalType::UNKNOWN;
-constexpr const LogicalTypeId LogicalType::BOOLEAN;
-constexpr const LogicalTypeId LogicalType::TINYINT;
-constexpr const LogicalTypeId LogicalType::UTINYINT;
-constexpr const LogicalTypeId LogicalType::SMALLINT;
-constexpr const LogicalTypeId LogicalType::USMALLINT;
-constexpr const LogicalTypeId LogicalType::INTEGER;
-constexpr const LogicalTypeId LogicalType::UINTEGER;
-constexpr const LogicalTypeId LogicalType::BIGINT;
-constexpr const LogicalTypeId LogicalType::UBIGINT;
-constexpr const LogicalTypeId LogicalType::HUGEINT;
-constexpr const LogicalTypeId LogicalType::UHUGEINT;
-constexpr const LogicalTypeId LogicalType::UUID;
-constexpr const LogicalTypeId LogicalType::FLOAT;
-constexpr const LogicalTypeId LogicalType::DOUBLE;
-constexpr const LogicalTypeId LogicalType::DATE;
-
-constexpr const LogicalTypeId LogicalType::TIMESTAMP;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_MS;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_NS;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_S;
-
-constexpr const LogicalTypeId LogicalType::TIME;
-
-constexpr const LogicalTypeId LogicalType::TIME_TZ;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_TZ;
-
-constexpr const LogicalTypeId LogicalType::HASH;
-constexpr const LogicalTypeId LogicalType::POINTER;
-
-constexpr const LogicalTypeId LogicalType::VARCHAR;
-
-constexpr const LogicalTypeId LogicalType::BLOB;
-constexpr const LogicalTypeId LogicalType::BIT;
-constexpr const LogicalTypeId LogicalType::VARINT;
-
-constexpr const LogicalTypeId LogicalType::INTERVAL;
-constexpr const LogicalTypeId LogicalType::ROW_TYPE;
-
-// TODO these are incomplete and should maybe not exist as such
-constexpr const LogicalTypeId LogicalType::TABLE;
-constexpr const LogicalTypeId LogicalType::LAMBDA;
-
-constexpr const LogicalTypeId LogicalType::ANY;
-
-const vector<LogicalType> LogicalType::Numeric() {
-	vector<LogicalType> types = {LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
-	                             LogicalType::BIGINT,    LogicalType::HUGEINT,   LogicalType::FLOAT,
-	                             LogicalType::DOUBLE,    LogicalTypeId::DECIMAL, LogicalType::UTINYINT,
-	                             LogicalType::USMALLINT, LogicalType::UINTEGER,  LogicalType::UBIGINT,
-	                             LogicalType::UHUGEINT};
-	return types;
-}
-
-const vector<LogicalType> LogicalType::Integral() {
-	vector<LogicalType> types = {LogicalType::TINYINT,   LogicalType::SMALLINT, LogicalType::INTEGER,
-	                             LogicalType::BIGINT,    LogicalType::HUGEINT,  LogicalType::UTINYINT,
-	                             LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT,
-	                             LogicalType::UHUGEINT};
-	return types;
-}
-
-const vector<LogicalType> LogicalType::Real() {
-	vector<LogicalType> types = {LogicalType::FLOAT, LogicalType::DOUBLE};
-	return types;
-}
-
-const vector<LogicalType> LogicalType::AllTypes() {
-	vector<LogicalType> types = {
-	    LogicalType::BOOLEAN,  LogicalType::TINYINT,      LogicalType::SMALLINT,  LogicalType::INTEGER,
-	    LogicalType::BIGINT,   LogicalType::DATE,         LogicalType::TIMESTAMP, LogicalType::DOUBLE,
-	    LogicalType::FLOAT,    LogicalType::VARCHAR,      LogicalType::BLOB,      LogicalType::BIT,
-	    LogicalType::VARINT,   LogicalType::INTERVAL,     LogicalType::HUGEINT,   LogicalTypeId::DECIMAL,
-	    LogicalType::UTINYINT, LogicalType::USMALLINT,    LogicalType::UINTEGER,  LogicalType::UBIGINT,
-	    LogicalType::UHUGEINT, LogicalType::TIME,         LogicalTypeId::LIST,    LogicalTypeId::STRUCT,
-	    LogicalType::TIME_TZ,  LogicalType::TIMESTAMP_TZ, LogicalTypeId::MAP,     LogicalTypeId::UNION,
-	    LogicalType::UUID,     LogicalTypeId::ARRAY};
-	return types;
-}
-
-const PhysicalType ROW_TYPE = PhysicalType::INT64;
-
-// LCOV_EXCL_START
-string TypeIdToString(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-		return "BOOL";
-	case PhysicalType::INT8:
-		return "INT8";
-	case PhysicalType::INT16:
-		return "INT16";
-	case PhysicalType::INT32:
-		return "INT32";
-	case PhysicalType::INT64:
-		return "INT64";
-	case PhysicalType::UINT8:
-		return "UINT8";
-	case PhysicalType::UINT16:
-		return "UINT16";
-	case PhysicalType::UINT32:
-		return "UINT32";
-	case PhysicalType::UINT64:
-		return "UINT64";
-	case PhysicalType::INT128:
-		return "INT128";
-	case PhysicalType::UINT128:
-		return "UINT128";
-	case PhysicalType::FLOAT:
-		return "FLOAT";
-	case PhysicalType::DOUBLE:
-		return "DOUBLE";
-	case PhysicalType::VARCHAR:
-		return "VARCHAR";
-	case PhysicalType::INTERVAL:
-		return "INTERVAL";
-	case PhysicalType::STRUCT:
-		return "STRUCT";
-	case PhysicalType::LIST:
-		return "LIST";
-	case PhysicalType::ARRAY:
-		return "ARRAY";
-	case PhysicalType::INVALID:
-		return "INVALID";
-	case PhysicalType::BIT:
-		return "BIT";
-	case PhysicalType::UNKNOWN:
-		return "UNKNOWN";
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-idx_t GetTypeIdSize(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-	case PhysicalType::BOOL:
-		return sizeof(bool);
-	case PhysicalType::INT8:
-		return sizeof(int8_t);
-	case PhysicalType::INT16:
-		return sizeof(int16_t);
-	case PhysicalType::INT32:
-		return sizeof(int32_t);
-	case PhysicalType::INT64:
-		return sizeof(int64_t);
-	case PhysicalType::UINT8:
-		return sizeof(uint8_t);
-	case PhysicalType::UINT16:
-		return sizeof(uint16_t);
-	case PhysicalType::UINT32:
-		return sizeof(uint32_t);
-	case PhysicalType::UINT64:
-		return sizeof(uint64_t);
-	case PhysicalType::INT128:
-		return sizeof(hugeint_t);
-	case PhysicalType::UINT128:
-		return sizeof(uhugeint_t);
-	case PhysicalType::FLOAT:
-		return sizeof(float);
-	case PhysicalType::DOUBLE:
-		return sizeof(double);
-	case PhysicalType::VARCHAR:
-		return sizeof(string_t);
-	case PhysicalType::INTERVAL:
-		return sizeof(interval_t);
-	case PhysicalType::STRUCT:
-	case PhysicalType::UNKNOWN:
-	case PhysicalType::ARRAY:
-		return 0; // no own payload
-	case PhysicalType::LIST:
-		return sizeof(list_entry_t); // offset + len
-	default:
-		throw InternalException("Invalid PhysicalType for GetTypeIdSize");
-	}
-}
-
-bool TypeIsConstantSize(PhysicalType type) {
-	return (type >= PhysicalType::BOOL && type <= PhysicalType::DOUBLE) || type == PhysicalType::INTERVAL ||
-	       type == PhysicalType::INT128 || type == PhysicalType::UINT128;
-}
-bool TypeIsIntegral(PhysicalType type) {
-	return (type >= PhysicalType::UINT8 && type <= PhysicalType::INT64) || type == PhysicalType::INT128 ||
-	       type == PhysicalType::UINT128;
-}
-bool TypeIsNumeric(PhysicalType type) {
-	return (type >= PhysicalType::UINT8 && type <= PhysicalType::DOUBLE) || type == PhysicalType::INT128 ||
-	       type == PhysicalType::UINT128;
-}
-bool TypeIsInteger(PhysicalType type) {
-	return (type >= PhysicalType::UINT8 && type <= PhysicalType::INT64) || type == PhysicalType::INT128 ||
-	       type == PhysicalType::UINT128;
-}
-
-static string TypeModifierListToString(const vector<LogicalTypeModifier> &mod_list) {
-	string result;
-	if (mod_list.empty()) {
-		return result;
-	}
-	result = "(";
-	for (idx_t i = 0; i < mod_list.size(); i++) {
-		result += mod_list[i].ToString();
-		if (i < mod_list.size() - 1) {
-			result += ", ";
-		}
-	}
-	result += ")";
-	return result;
-}
-
-string LogicalType::ToString() const {
-	if (id_ != LogicalTypeId::USER) {
-		auto alias = GetAlias();
-		if (!alias.empty()) {
-			if (HasExtensionInfo()) {
-				auto &ext_info = *GetExtensionInfo();
-				alias += TypeModifierListToString(ext_info.modifiers);
-			}
-			return alias;
-		}
-	}
-	switch (id_) {
-	case LogicalTypeId::STRUCT: {
-		if (!type_info_) {
-			return "STRUCT";
-		}
-		auto is_unnamed = StructType::IsUnnamed(*this);
-		auto &child_types = StructType::GetChildTypes(*this);
-		string ret = "STRUCT(";
-		for (size_t i = 0; i < child_types.size(); i++) {
-			if (is_unnamed) {
-				ret += child_types[i].second.ToString();
-			} else {
-				ret += StringUtil::Format("%s %s", SQLIdentifier(child_types[i].first), child_types[i].second);
-			}
-			if (i < child_types.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += ")";
-		return ret;
-	}
-	case LogicalTypeId::LIST: {
-		if (!type_info_) {
-			return "LIST";
-		}
-		return ListType::GetChildType(*this).ToString() + "[]";
-	}
-	case LogicalTypeId::MAP: {
-		if (!type_info_) {
-			return "MAP";
-		}
-		auto &key_type = MapType::KeyType(*this);
-		auto &value_type = MapType::ValueType(*this);
-		return "MAP(" + key_type.ToString() + ", " + value_type.ToString() + ")";
-	}
-	case LogicalTypeId::UNION: {
-		if (!type_info_) {
-			return "UNION";
-		}
-		string ret = "UNION(";
-		size_t count = UnionType::GetMemberCount(*this);
-		for (size_t i = 0; i < count; i++) {
-			auto member_name = UnionType::GetMemberName(*this, i);
-			auto member_type = UnionType::GetMemberType(*this, i).ToString();
-			ret += StringUtil::Format("%s %s", SQLIdentifier(member_name), member_type);
-			if (i < count - 1) {
-				ret += ", ";
-			}
-		}
-		ret += ")";
-		return ret;
-	}
-	case LogicalTypeId::ARRAY: {
-		if (!type_info_) {
-			return "ARRAY";
-		}
-		auto size = ArrayType::GetSize(*this);
-		if (size == 0) {
-			return ArrayType::GetChildType(*this).ToString() + "[ANY]";
-		} else {
-			return ArrayType::GetChildType(*this).ToString() + "[" + to_string(size) + "]";
-		}
-	}
-	case LogicalTypeId::DECIMAL: {
-		if (!type_info_) {
-			return "DECIMAL";
-		}
-		auto width = DecimalType::GetWidth(*this);
-		auto scale = DecimalType::GetScale(*this);
-		if (width == 0) {
-			return "DECIMAL";
-		}
-		return StringUtil::Format("DECIMAL(%d,%d)", width, scale);
-	}
-	case LogicalTypeId::ENUM: {
-		string ret = "ENUM(";
-		for (idx_t i = 0; i < EnumType::GetSize(*this); i++) {
-			if (i > 0) {
-				ret += ", ";
-			}
-			ret += KeywordHelper::WriteQuoted(EnumType::GetString(*this, i).GetString(), '\'');
-		}
-		ret += ")";
-		return ret;
-	}
-	case LogicalTypeId::USER: {
-		string result;
-		auto &catalog = UserType::GetCatalog(*this);
-		auto &schema = UserType::GetSchema(*this);
-		auto &type = UserType::GetTypeName(*this);
-		auto &mods = UserType::GetTypeModifiers(*this);
-
-		if (!catalog.empty()) {
-			result = KeywordHelper::WriteOptionallyQuoted(catalog);
-		}
-		if (!schema.empty()) {
-			if (!result.empty()) {
-				result += ".";
-			}
-			result += KeywordHelper::WriteOptionallyQuoted(schema);
-		}
-		if (!result.empty()) {
-			result += ".";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(type);
-
-		if (!mods.empty()) {
-			result += "(";
-			for (idx_t i = 0; i < mods.size(); i++) {
-				result += mods[i].ToString();
-				if (i < mods.size() - 1) {
-					result += ", ";
-				}
-			}
-			result += ")";
-		}
-
-		return result;
-	}
-	case LogicalTypeId::AGGREGATE_STATE: {
-		return AggregateStateType::GetTypeName(*this);
-	}
-	case LogicalTypeId::SQLNULL: {
-		return "\"NULL\"";
-	}
-	default:
-		return EnumUtil::ToString(id_);
-	}
-}
-// LCOV_EXCL_STOP
-
-LogicalTypeId TransformStringToLogicalTypeId(const string &str) {
-	auto type = DefaultTypeGenerator::GetDefaultType(str);
-	if (type == LogicalTypeId::INVALID) {
-		// This is a User Type, at this point we don't know if its one of the User Defined Types or an error
-		// It is checked in the binder
-		type = LogicalTypeId::USER;
-	}
-	return type;
-}
-
-LogicalType TransformStringToLogicalType(const string &str) {
-	if (StringUtil::Lower(str) == "null") {
-		return LogicalType::SQLNULL;
-	}
-	ColumnList column_list;
-	try {
-		column_list = Parser::ParseColumnList("dummy " + str);
-	} catch (const std::runtime_error &e) {
-		const vector<string> suggested_types {"BIGINT",
-		                                      "INT8",
-		                                      "LONG",
-		                                      "BIT",
-		                                      "BITSTRING",
-		                                      "BLOB",
-		                                      "BYTEA",
-		                                      "BINARY,",
-		                                      "VARBINARY",
-		                                      "BOOLEAN",
-		                                      "BOOL",
-		                                      "LOGICAL",
-		                                      "DATE",
-		                                      "DECIMAL(prec, scale)",
-		                                      "DOUBLE",
-		                                      "FLOAT8",
-		                                      "FLOAT",
-		                                      "FLOAT4",
-		                                      "REAL",
-		                                      "HUGEINT",
-		                                      "INTEGER",
-		                                      "INT4",
-		                                      "INT",
-		                                      "SIGNED",
-		                                      "INTERVAL",
-		                                      "SMALLINT",
-		                                      "INT2",
-		                                      "SHORT",
-		                                      "TIME",
-		                                      "TIMESTAMPTZ",
-		                                      "TIMESTAMP",
-		                                      "DATETIME",
-		                                      "TINYINT",
-		                                      "INT1",
-		                                      "UBIGINT",
-		                                      "UHUGEINT",
-		                                      "UINTEGER",
-		                                      "USMALLINT",
-		                                      "UTINYINT",
-		                                      "UUID",
-		                                      "VARCHAR",
-		                                      "CHAR",
-		                                      "BPCHAR",
-		                                      "TEXT",
-		                                      "STRING",
-		                                      "MAP(INTEGER, VARCHAR)",
-		                                      "UNION(num INTEGER, text VARCHAR)"};
-		std::ostringstream error;
-		error << "Value \"" << str << "\" can not be converted to a DuckDB Type." << '\n';
-		error << "Possible examples as suggestions: " << '\n';
-		auto suggestions = StringUtil::TopNJaroWinkler(suggested_types, str);
-		for (auto &suggestion : suggestions) {
-			error << "* " << suggestion << '\n';
-		}
-		throw InvalidInputException(error.str());
-	}
-	return column_list.GetColumn(LogicalIndex(0)).Type();
-}
-
-LogicalType GetUserTypeRecursive(const LogicalType &type, ClientContext &context) {
-	if (type.id() == LogicalTypeId::USER && type.HasAlias()) {
-		auto &type_entry =
-		    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, INVALID_SCHEMA, type.GetAlias());
-		return type_entry.user_type;
-	}
-	// Look for LogicalTypeId::USER in nested types
-	if (type.id() == LogicalTypeId::STRUCT) {
-		child_list_t<LogicalType> children;
-		children.reserve(StructType::GetChildCount(type));
-		for (auto &child : StructType::GetChildTypes(type)) {
-			children.emplace_back(child.first, GetUserTypeRecursive(child.second, context));
-		}
-		return LogicalType::STRUCT(children);
-	}
-	if (type.id() == LogicalTypeId::LIST) {
-		return LogicalType::LIST(GetUserTypeRecursive(ListType::GetChildType(type), context));
-	}
-	if (type.id() == LogicalTypeId::MAP) {
-		return LogicalType::MAP(GetUserTypeRecursive(MapType::KeyType(type), context),
-		                        GetUserTypeRecursive(MapType::ValueType(type), context));
-	}
-	// Not LogicalTypeId::USER or a nested type
-	return type;
-}
-
-LogicalType TransformStringToLogicalType(const string &str, ClientContext &context) {
-	return GetUserTypeRecursive(TransformStringToLogicalType(str), context);
-}
-
-bool LogicalType::IsIntegral() const {
-	switch (id_) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UHUGEINT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool LogicalType::IsNumeric() const {
-	switch (id_) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool LogicalType::IsTemporal() const {
-	switch (id_) {
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool LogicalType::IsValid() const {
-	return id() != LogicalTypeId::INVALID && id() != LogicalTypeId::UNKNOWN;
-}
-
-bool LogicalType::IsComplete() const {
-	// Check if type does not contain incomplete types
-	return !TypeVisitor::Contains(*this, [](const LogicalType &type) {
-		switch (type.id()) {
-		case LogicalTypeId::INVALID:
-		case LogicalTypeId::UNKNOWN:
-		case LogicalTypeId::ANY:
-			return true; // These are incomplete by default
-		case LogicalTypeId::LIST:
-		case LogicalTypeId::MAP:
-			if (!type.AuxInfo() || type.AuxInfo()->type != ExtraTypeInfoType::LIST_TYPE_INFO) {
-				return true; // Missing or incorrect type info
-			}
-			break;
-		case LogicalTypeId::STRUCT:
-		case LogicalTypeId::UNION:
-			if (!type.AuxInfo() || type.AuxInfo()->type != ExtraTypeInfoType::STRUCT_TYPE_INFO) {
-				return true; // Missing or incorrect type info
-			}
-			break;
-		case LogicalTypeId::ARRAY:
-			if (!type.AuxInfo() || type.AuxInfo()->type != ExtraTypeInfoType::ARRAY_TYPE_INFO) {
-				return true; // Missing or incorrect type info
-			}
-			break;
-		case LogicalTypeId::DECIMAL:
-			if (!type.AuxInfo() || type.AuxInfo()->type != ExtraTypeInfoType::DECIMAL_TYPE_INFO) {
-				return true; // Missing or incorrect type info
-			}
-			break;
-		case LogicalTypeId::ENUM:
-			if (!type.AuxInfo() || type.AuxInfo()->type != ExtraTypeInfoType::ENUM_TYPE_INFO) {
-				return true; // Missing or incorrect type info
-			}
-			break;
-		default:
-			return false;
-		}
-
-		// Type has type info, check if it is complete
-		D_ASSERT(type.AuxInfo());
-		switch (type.AuxInfo()->type) {
-		case ExtraTypeInfoType::STRUCT_TYPE_INFO:
-			return type.AuxInfo()->Cast<StructTypeInfo>().child_types.empty(); // Cannot be empty
-		case ExtraTypeInfoType::DECIMAL_TYPE_INFO:
-			return DecimalType::GetWidth(type) >= 1 && DecimalType::GetWidth(type) <= Decimal::MAX_WIDTH_DECIMAL &&
-			       DecimalType::GetScale(type) <= DecimalType::GetWidth(type);
-		default:
-			return false; // Nested types are checked by TypeVisitor recursion
-		}
-	});
-}
-
-bool LogicalType::SupportsRegularUpdate() const {
-	switch (id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::ARRAY:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::UNION:
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &child_types = StructType::GetChildTypes(*this);
-		for (auto &entry : child_types) {
-			if (!entry.second.SupportsRegularUpdate()) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
-bool LogicalType::GetDecimalProperties(uint8_t &width, uint8_t &scale) const {
-	switch (id_) {
-	case LogicalTypeId::SQLNULL:
-		width = 0;
-		scale = 0;
-		break;
-	case LogicalTypeId::BOOLEAN:
-		width = 1;
-		scale = 0;
-		break;
-	case LogicalTypeId::TINYINT:
-		// tinyint: [-127, 127] = DECIMAL(3,0)
-		width = 3;
-		scale = 0;
-		break;
-	case LogicalTypeId::SMALLINT:
-		// smallint: [-32767, 32767] = DECIMAL(5,0)
-		width = 5;
-		scale = 0;
-		break;
-	case LogicalTypeId::INTEGER:
-		// integer: [-2147483647, 2147483647] = DECIMAL(10,0)
-		width = 10;
-		scale = 0;
-		break;
-	case LogicalTypeId::BIGINT:
-		// bigint: [-9223372036854775807, 9223372036854775807] = DECIMAL(19,0)
-		width = 19;
-		scale = 0;
-		break;
-	case LogicalTypeId::UTINYINT:
-		// UInt8 — [0 : 255]
-		width = 3;
-		scale = 0;
-		break;
-	case LogicalTypeId::USMALLINT:
-		// UInt16 — [0 : 65535]
-		width = 5;
-		scale = 0;
-		break;
-	case LogicalTypeId::UINTEGER:
-		// UInt32 — [0 : 4294967295]
-		width = 10;
-		scale = 0;
-		break;
-	case LogicalTypeId::UBIGINT:
-		// UInt64 — [0 : 18446744073709551615]
-		width = 20;
-		scale = 0;
-		break;
-	case LogicalTypeId::HUGEINT:
-		// hugeint: max size decimal (38, 0)
-		// note that a hugeint is not guaranteed to fit in this
-		width = 38;
-		scale = 0;
-		break;
-	case LogicalTypeId::UHUGEINT:
-		// hugeint: max size decimal (38, 0)
-		// note that a uhugeint is not guaranteed to fit in this
-		width = 38;
-		scale = 0;
-		break;
-	case LogicalTypeId::DECIMAL:
-		width = DecimalType::GetWidth(*this);
-		scale = DecimalType::GetScale(*this);
-		break;
-	case LogicalTypeId::INTEGER_LITERAL:
-		return IntegerLiteral::GetType(*this).GetDecimalProperties(width, scale);
-	default:
-		// Nonsense values to ensure initialization
-		width = 255u;
-		scale = 255u;
-		// FIXME(carlo): This should be probably a throw, requires checkign the various call-sites
-		return false;
-	}
-	return true;
-}
-
-//! Grows Decimal width/scale when appropriate
-static LogicalType DecimalSizeCheck(const LogicalType &left, const LogicalType &right) {
-	D_ASSERT(left.id() == LogicalTypeId::DECIMAL || right.id() == LogicalTypeId::DECIMAL);
-	D_ASSERT(left.id() != right.id());
-
-	//! Make sure the 'right' is the DECIMAL type
-	if (left.id() == LogicalTypeId::DECIMAL) {
-		return DecimalSizeCheck(right, left);
-	}
-	auto width = DecimalType::GetWidth(right);
-	auto scale = DecimalType::GetScale(right);
-
-	uint8_t other_width;
-	uint8_t other_scale;
-	bool success = left.GetDecimalProperties(other_width, other_scale);
-	if (!success) {
-		throw InternalException("Type provided to DecimalSizeCheck was not a numeric type");
-	}
-	D_ASSERT(other_scale == 0);
-	const auto effective_width = width - scale;
-	if (other_width > effective_width) {
-		auto new_width = NumericCast<uint8_t>(other_width + scale);
-		//! Cap the width at max, if an actual value exceeds this, an exception will be thrown later
-		if (new_width > DecimalType::MaxWidth()) {
-			new_width = DecimalType::MaxWidth();
-		}
-		return LogicalType::DECIMAL(new_width, scale);
-	}
-	return right;
-}
-
-static LogicalType CombineNumericTypes(const LogicalType &left, const LogicalType &right) {
-	D_ASSERT(left.id() != right.id());
-	if (left.id() > right.id()) {
-		// this method is symmetric
-		// arrange it so the left type is smaller to limit the number of options we need to check
-		return CombineNumericTypes(right, left);
-	}
-	// we can't cast implicitly either way and types are not equal
-	// this happens when left is signed and right is unsigned
-	// e.g. INTEGER and UINTEGER
-	// in this case we need to upcast to make sure the types fit
-
-	if (left.id() == LogicalTypeId::BIGINT || right.id() == LogicalTypeId::UBIGINT) {
-		return LogicalType::HUGEINT;
-	}
-	if (left.id() == LogicalTypeId::INTEGER || right.id() == LogicalTypeId::UINTEGER) {
-		return LogicalType::BIGINT;
-	}
-	if (left.id() == LogicalTypeId::SMALLINT || right.id() == LogicalTypeId::USMALLINT) {
-		return LogicalType::INTEGER;
-	}
-	if (left.id() == LogicalTypeId::TINYINT || right.id() == LogicalTypeId::UTINYINT) {
-		return LogicalType::SMALLINT;
-	}
-
-	// No type is larger than (u)hugeint, so casting to double is required
-	// UHUGEINT is on the left because the enum is lower
-	if (left.id() == LogicalTypeId::UHUGEINT || right.id() == LogicalTypeId::HUGEINT) {
-		return LogicalType::DOUBLE;
-	}
-	throw InternalException("Cannot combine these numeric types (%s & %s)", left.ToString(), right.ToString());
-}
-
-LogicalType LogicalType::NormalizeType(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::STRING_LITERAL:
-		return LogicalType::VARCHAR;
-	case LogicalTypeId::INTEGER_LITERAL:
-		return IntegerLiteral::GetType(type);
-	case LogicalTypeId::UNKNOWN:
-		throw ParameterNotResolvedException();
-	default:
-		return type;
-	}
-}
-
-template <class OP>
-static bool CombineUnequalTypes(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-	// left and right are not equal
-	// NULL/unknown (parameter) types always take the other type
-	LogicalTypeId other_types[] = {LogicalTypeId::SQLNULL, LogicalTypeId::UNKNOWN};
-	for (auto &other_type : other_types) {
-		if (left.id() == other_type) {
-			result = LogicalType::NormalizeType(right);
-			return true;
-		} else if (right.id() == other_type) {
-			result = LogicalType::NormalizeType(left);
-			return true;
-		}
-	}
-
-	// for enums, match the varchar rules
-	if (left.id() == LogicalTypeId::ENUM) {
-		return OP::Operation(LogicalType::VARCHAR, right, result);
-	} else if (right.id() == LogicalTypeId::ENUM) {
-		return OP::Operation(left, LogicalType::VARCHAR, result);
-	}
-
-	// for everything but enums - string literals also take the other type
-	if (left.id() == LogicalTypeId::STRING_LITERAL) {
-		result = LogicalType::NormalizeType(right);
-		return true;
-	} else if (right.id() == LogicalTypeId::STRING_LITERAL) {
-		result = LogicalType::NormalizeType(left);
-		return true;
-	}
-
-	// for other types - use implicit cast rules to check if we can combine the types
-	auto left_to_right_cost = CastRules::ImplicitCast(left, right);
-	auto right_to_left_cost = CastRules::ImplicitCast(right, left);
-	if (left_to_right_cost >= 0 && (left_to_right_cost < right_to_left_cost || right_to_left_cost < 0)) {
-		// we can implicitly cast left to right, return right
-		//! Depending on the type, we might need to grow the `width` of the DECIMAL type
-		if (right.id() == LogicalTypeId::DECIMAL) {
-			result = DecimalSizeCheck(left, right);
-		} else {
-			result = right;
-		}
-		return true;
-	}
-	if (right_to_left_cost >= 0) {
-		// we can implicitly cast right to left, return left
-		//! Depending on the type, we might need to grow the `width` of the DECIMAL type
-		if (left.id() == LogicalTypeId::DECIMAL) {
-			result = DecimalSizeCheck(right, left);
-		} else {
-			result = left;
-		}
-		return true;
-	}
-	// for integer literals - rerun the operation with the underlying type
-	if (left.id() == LogicalTypeId::INTEGER_LITERAL) {
-		return OP::Operation(IntegerLiteral::GetType(left), right, result);
-	}
-	if (right.id() == LogicalTypeId::INTEGER_LITERAL) {
-		return OP::Operation(left, IntegerLiteral::GetType(right), result);
-	}
-	// for unsigned/signed comparisons we have a few fallbacks
-	if (left.IsNumeric() && right.IsNumeric()) {
-		result = CombineNumericTypes(left, right);
-		return true;
-	}
-	if (left.id() == LogicalTypeId::BOOLEAN && right.IsIntegral()) {
-		result = right;
-		return true;
-	}
-	if (right.id() == LogicalTypeId::BOOLEAN && left.IsIntegral()) {
-		result = left;
-		return true;
-	}
-	return false;
-}
-
-template <class OP>
-static bool CombineStructTypes(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-	auto &left_children = StructType::GetChildTypes(left);
-	auto &right_children = StructType::GetChildTypes(right);
-
-	auto left_unnamed = StructType::IsUnnamed(left);
-	auto is_unnamed = left_unnamed || StructType::IsUnnamed(right);
-	child_list_t<LogicalType> child_types;
-
-	// At least one side is unnamed, so we attempt positional casting.
-	if (is_unnamed) {
-		if (left_children.size() != right_children.size()) {
-			// We can't cast, or create the super-set.
-			return false;
-		}
-
-		for (idx_t i = 0; i < left_children.size(); i++) {
-			LogicalType child_type;
-			if (!OP::Operation(left_children[i].second, right_children[i].second, child_type)) {
-				return false;
-			}
-			auto &child_name = left_unnamed ? right_children[i].first : left_children[i].first;
-			child_types.emplace_back(child_name, std::move(child_type));
-		}
-		result = LogicalType::STRUCT(child_types);
-		return true;
-	}
-
-	// Create a super-set of the STRUCT fields.
-	// First, create a name->index map of the right children.
-	case_insensitive_map_t<idx_t> right_children_map;
-	for (idx_t i = 0; i < right_children.size(); i++) {
-		auto &name = right_children[i].first;
-		right_children_map[name] = i;
-	}
-
-	for (idx_t i = 0; i < left_children.size(); i++) {
-		auto &left_child = left_children[i];
-		auto right_child_it = right_children_map.find(left_child.first);
-
-		if (right_child_it == right_children_map.end()) {
-			// We can directly put the left child.
-			child_types.emplace_back(left_child.first, left_child.second);
-			continue;
-		}
-
-		// We need to recurse to ensure the children have a maximum logical type.
-		LogicalType child_type;
-		auto &right_child = right_children[right_child_it->second];
-		if (!OP::Operation(left_child.second, right_child.second, child_type)) {
-			return false;
-		}
-		child_types.emplace_back(left_child.first, std::move(child_type));
-		right_children_map.erase(right_child_it);
-	}
-
-	// Add all remaining right children.
-	for (const auto &right_child_it : right_children_map) {
-		auto &right_child = right_children[right_child_it.second];
-		child_types.emplace_back(right_child.first, right_child.second);
-	}
-
-	result = LogicalType::STRUCT(child_types);
-	return true;
-}
-
-template <class OP>
-static bool CombineEqualTypes(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-	// Since both left and right are equal we get the left type as our type_id for checks
-	auto type_id = left.id();
-	switch (type_id) {
-	case LogicalTypeId::STRING_LITERAL:
-		// two string literals convert to varchar
-		result = LogicalType::VARCHAR;
-		return true;
-	case LogicalTypeId::INTEGER_LITERAL:
-		// for two integer literals we unify the underlying types
-		return OP::Operation(IntegerLiteral::GetType(left), IntegerLiteral::GetType(right), result);
-	case LogicalTypeId::ENUM:
-		// If both types are different ENUMs we do a string comparison.
-		result = left == right ? left : LogicalType::VARCHAR;
-		return true;
-	case LogicalTypeId::VARCHAR:
-		// varchar: use type that has collation (if any)
-		if (StringType::GetCollation(right).empty()) {
-			result = left;
-		} else {
-			result = right;
-		}
-		return true;
-	case LogicalTypeId::DECIMAL: {
-		// unify the width/scale so that the resulting decimal always fits
-		// "width - scale" gives us the number of digits on the left side of the decimal point
-		// "scale" gives us the number of digits allowed on the right of the decimal point
-		// using the max of these of the two types gives us the new decimal size
-		auto extra_width_left = DecimalType::GetWidth(left) - DecimalType::GetScale(left);
-		auto extra_width_right = DecimalType::GetWidth(right) - DecimalType::GetScale(right);
-		auto extra_width =
-		    MaxValue<uint8_t>(NumericCast<uint8_t>(extra_width_left), NumericCast<uint8_t>(extra_width_right));
-		auto scale = MaxValue<uint8_t>(DecimalType::GetScale(left), DecimalType::GetScale(right));
-		auto width = NumericCast<uint8_t>(extra_width + scale);
-		if (width > DecimalType::MaxWidth()) {
-			// if the resulting decimal does not fit, we truncate the scale
-			width = DecimalType::MaxWidth();
-			scale = NumericCast<uint8_t>(width - extra_width);
-		}
-		result = LogicalType::DECIMAL(width, scale);
-		return true;
-	}
-	case LogicalTypeId::LIST: {
-		// list: perform max recursively on child type
-		LogicalType new_child;
-		if (!OP::Operation(ListType::GetChildType(left), ListType::GetChildType(right), new_child)) {
-			return false;
-		}
-		result = LogicalType::LIST(new_child);
-		return true;
-	}
-	case LogicalTypeId::ARRAY: {
-		LogicalType new_child;
-		if (!OP::Operation(ArrayType::GetChildType(left), ArrayType::GetChildType(right), new_child)) {
-			return false;
-		}
-		auto new_size = MaxValue(ArrayType::GetSize(left), ArrayType::GetSize(right));
-		result = LogicalType::ARRAY(new_child, new_size);
-		return true;
-	}
-	case LogicalTypeId::MAP: {
-		// map: perform max recursively on child type
-		LogicalType new_child;
-		if (!OP::Operation(ListType::GetChildType(left), ListType::GetChildType(right), new_child)) {
-			return false;
-		}
-		result = LogicalType::MAP(new_child);
-		return true;
-	}
-	case LogicalTypeId::STRUCT: {
-		return CombineStructTypes<OP>(left, right, result);
-	}
-	case LogicalTypeId::UNION: {
-		auto left_member_count = UnionType::GetMemberCount(left);
-		auto right_member_count = UnionType::GetMemberCount(right);
-		if (left_member_count != right_member_count) {
-			// return the "larger" type, with the most members
-			result = left_member_count > right_member_count ? left : right;
-			return true;
-		}
-		// otherwise, keep left, don't try to meld the two together.
-		result = left;
-		return true;
-	}
-	default:
-		result = left;
-		return true;
-	}
-}
-
-template <class OP>
-bool TryGetMaxLogicalTypeInternal(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-	// we always prefer aliased types
-	if (!left.GetAlias().empty()) {
-		result = left;
-		return true;
-	}
-	if (!right.GetAlias().empty()) {
-		result = right;
-		return true;
-	}
-	if (left.id() != right.id()) {
-		return CombineUnequalTypes<OP>(left, right, result);
-	} else {
-		return CombineEqualTypes<OP>(left, right, result);
-	}
-}
-
-struct TryGetTypeOperation {
-	static bool Operation(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-		return TryGetMaxLogicalTypeInternal<TryGetTypeOperation>(left, right, result);
-	}
-};
-
-struct ForceGetTypeOperation {
-	static bool Operation(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-		result = LogicalType::ForceMaxLogicalType(left, right);
-		return true;
-	}
-};
-
-bool LogicalType::TryGetMaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right,
-                                       LogicalType &result) {
-	if (DBConfig::GetConfig(context).options.old_implicit_casting) {
-		result = LogicalType::ForceMaxLogicalType(left, right);
-		return true;
-	}
-	return TryGetMaxLogicalTypeInternal<TryGetTypeOperation>(left, right, result);
-}
-
-static idx_t GetLogicalTypeScore(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::INVALID:
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::UNKNOWN:
-	case LogicalTypeId::ANY:
-	case LogicalTypeId::STRING_LITERAL:
-	case LogicalTypeId::INTEGER_LITERAL:
-		return 0;
-	// numerics
-	case LogicalTypeId::BOOLEAN:
-		return 10;
-	case LogicalTypeId::UTINYINT:
-		return 11;
-	case LogicalTypeId::TINYINT:
-		return 12;
-	case LogicalTypeId::USMALLINT:
-		return 13;
-	case LogicalTypeId::SMALLINT:
-		return 14;
-	case LogicalTypeId::UINTEGER:
-		return 15;
-	case LogicalTypeId::INTEGER:
-		return 16;
-	case LogicalTypeId::UBIGINT:
-		return 17;
-	case LogicalTypeId::BIGINT:
-		return 18;
-	case LogicalTypeId::UHUGEINT:
-		return 19;
-	case LogicalTypeId::HUGEINT:
-		return 20;
-	case LogicalTypeId::DECIMAL:
-		return 21;
-	case LogicalTypeId::FLOAT:
-		return 22;
-	case LogicalTypeId::DOUBLE:
-		return 23;
-	// date/time/timestamp
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return 50;
-	case LogicalTypeId::DATE:
-		return 51;
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return 52;
-	case LogicalTypeId::TIMESTAMP_MS:
-		return 53;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return 54;
-	case LogicalTypeId::TIMESTAMP_NS:
-		return 55;
-	case LogicalTypeId::INTERVAL:
-		return 56;
-	// text/character strings
-	case LogicalTypeId::CHAR:
-		return 75;
-	case LogicalTypeId::VARCHAR:
-		return 77;
-	case LogicalTypeId::ENUM:
-		return 78;
-	// blob/complex types
-	case LogicalTypeId::BIT:
-		return 100;
-	case LogicalTypeId::BLOB:
-		return 101;
-	case LogicalTypeId::UUID:
-		return 102;
-	case LogicalTypeId::VARINT:
-		return 103;
-	// nested types
-	case LogicalTypeId::STRUCT:
-		return 125;
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::ARRAY:
-		return 126;
-	case LogicalTypeId::MAP:
-		return 127;
-	case LogicalTypeId::UNION:
-	case LogicalTypeId::TABLE:
-		return 150;
-	// weirdo types
-	case LogicalTypeId::LAMBDA:
-	case LogicalTypeId::AGGREGATE_STATE:
-	case LogicalTypeId::POINTER:
-	case LogicalTypeId::VALIDITY:
-	case LogicalTypeId::USER:
-		break;
-	}
-	return 1000;
-}
-
-LogicalType LogicalType::ForceMaxLogicalType(const LogicalType &left, const LogicalType &right) {
-	LogicalType result;
-	if (TryGetMaxLogicalTypeInternal<ForceGetTypeOperation>(left, right, result)) {
-		return result;
-	}
-	// we prefer the type with the highest score
-	auto left_score = GetLogicalTypeScore(left);
-	auto right_score = GetLogicalTypeScore(right);
-	if (left_score < right_score) {
-		return right;
-	} else {
-		return left;
-	}
-}
-
-LogicalType LogicalType::MaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right) {
-	LogicalType result;
-	if (!TryGetMaxLogicalType(context, left, right, result)) {
-		throw NotImplementedException("Cannot combine types %s and %s - an explicit cast is required", left.ToString(),
-		                              right.ToString());
-	}
-	return result;
-}
-
-void LogicalType::Verify() const {
-#ifdef DEBUG
-	switch (id_) {
-	case LogicalTypeId::DECIMAL:
-		D_ASSERT(DecimalType::GetWidth(*this) >= 1 && DecimalType::GetWidth(*this) <= Decimal::MAX_WIDTH_DECIMAL);
-		D_ASSERT(DecimalType::GetScale(*this) >= 0 && DecimalType::GetScale(*this) <= DecimalType::GetWidth(*this));
-		break;
-	case LogicalTypeId::STRUCT: {
-		// verify child types
-		case_insensitive_set_t child_names;
-		bool all_empty = true;
-		for (auto &entry : StructType::GetChildTypes(*this)) {
-			if (entry.first.empty()) {
-				D_ASSERT(all_empty);
-			} else {
-				// check for duplicate struct names
-				all_empty = false;
-				auto existing_entry = child_names.find(entry.first);
-				D_ASSERT(existing_entry == child_names.end());
-				child_names.insert(entry.first);
-			}
-			entry.second.Verify();
-		}
-		break;
-	}
-	case LogicalTypeId::LIST:
-		ListType::GetChildType(*this).Verify();
-		break;
-	case LogicalTypeId::MAP: {
-		MapType::KeyType(*this).Verify();
-		MapType::ValueType(*this).Verify();
-		break;
-	}
-	default:
-		break;
-	}
-#endif
-}
-
-bool ApproxEqual(float ldecimal, float rdecimal) {
-	if (Value::IsNan(ldecimal) && Value::IsNan(rdecimal)) {
-		return true;
-	}
-	if (!Value::FloatIsFinite(ldecimal) || !Value::FloatIsFinite(rdecimal)) {
-		return ldecimal == rdecimal;
-	}
-	float epsilon = static_cast<float>(std::fabs(rdecimal) * 0.01 + 0.00000001);
-	return std::fabs(ldecimal - rdecimal) <= epsilon;
-}
-
-bool ApproxEqual(double ldecimal, double rdecimal) {
-	if (Value::IsNan(ldecimal) && Value::IsNan(rdecimal)) {
-		return true;
-	}
-	if (!Value::DoubleIsFinite(ldecimal) || !Value::DoubleIsFinite(rdecimal)) {
-		return ldecimal == rdecimal;
-	}
-	double epsilon = std::fabs(rdecimal) * 0.01 + 0.00000001;
-	return std::fabs(ldecimal - rdecimal) <= epsilon;
-}
-
-//===--------------------------------------------------------------------===//
-// Extra Type Info
-//===--------------------------------------------------------------------===//
-
-LogicalType LogicalType::DeepCopy() const {
-	LogicalType copy = *this;
-	if (type_info_) {
-		copy.type_info_ = type_info_->Copy();
-	}
-	return copy;
-}
-
-void LogicalType::SetAlias(string alias) {
-	if (!type_info_) {
-		type_info_ = make_shared_ptr<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO, std::move(alias));
-	} else {
-		type_info_->alias = std::move(alias);
-	}
-}
-
-string LogicalType::GetAlias() const {
-	if (id() == LogicalTypeId::USER) {
-		return UserType::GetTypeName(*this);
-	}
-	if (type_info_) {
-		return type_info_->alias;
-	}
-	return string();
-}
-
-bool LogicalType::HasAlias() const {
-	if (id() == LogicalTypeId::USER) {
-		return !UserType::GetTypeName(*this).empty();
-	}
-	if (type_info_ && !type_info_->alias.empty()) {
-		return true;
-	}
-	return false;
-}
-
-bool LogicalType::HasExtensionInfo() const {
-	if (type_info_ && type_info_->extension_info) {
-		return true;
-	}
-	return false;
-}
-
-optional_ptr<const ExtensionTypeInfo> LogicalType::GetExtensionInfo() const {
-	if (type_info_ && type_info_->extension_info) {
-		return type_info_->extension_info.get();
-	}
-	return nullptr;
-}
-
-optional_ptr<ExtensionTypeInfo> LogicalType::GetExtensionInfo() {
-	if (type_info_ && type_info_->extension_info) {
-		return type_info_->extension_info.get();
-	}
-	return nullptr;
-}
-
-void LogicalType::SetExtensionInfo(unique_ptr<ExtensionTypeInfo> info) {
-	if (!type_info_) {
-		type_info_ = make_shared_ptr<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO);
-	}
-	type_info_->extension_info = std::move(info);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal Type
-//===--------------------------------------------------------------------===//
-uint8_t DecimalType::GetWidth(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return info->Cast<DecimalTypeInfo>().width;
-}
-
-uint8_t DecimalType::GetScale(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return info->Cast<DecimalTypeInfo>().scale;
-}
-
-uint8_t DecimalType::MaxWidth() {
-	return DecimalWidth<hugeint_t>::max;
-}
-
-LogicalType LogicalType::DECIMAL(uint8_t width, uint8_t scale) {
-	D_ASSERT(width >= scale);
-	auto type_info = make_shared_ptr<DecimalTypeInfo>(width, scale);
-	return LogicalType(LogicalTypeId::DECIMAL, std::move(type_info));
-}
-
-//===--------------------------------------------------------------------===//
-// String Type
-//===--------------------------------------------------------------------===//
-string StringType::GetCollation(const LogicalType &type) {
-	if (type.id() != LogicalTypeId::VARCHAR) {
-		return string();
-	}
-	auto info = type.AuxInfo();
-	if (!info) {
-		return string();
-	}
-	if (info->type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
-		return string();
-	}
-	return info->Cast<StringTypeInfo>().collation;
-}
-
-LogicalType LogicalType::VARCHAR_COLLATION(string collation) { // NOLINT
-	auto string_info = make_shared_ptr<StringTypeInfo>(std::move(collation));
-	return LogicalType(LogicalTypeId::VARCHAR, std::move(string_info));
-}
-
-//===--------------------------------------------------------------------===//
-// List Type
-//===--------------------------------------------------------------------===//
-const LogicalType &ListType::GetChildType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return info->Cast<ListTypeInfo>().child_type;
-}
-
-LogicalType LogicalType::LIST(const LogicalType &child) {
-	auto info = make_shared_ptr<ListTypeInfo>(child);
-	return LogicalType(LogicalTypeId::LIST, std::move(info));
-}
-
-//===--------------------------------------------------------------------===//
-// Aggregate State Type
-//===--------------------------------------------------------------------===//
-const aggregate_state_t &AggregateStateType::GetStateType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::AGGREGATE_STATE);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return info->Cast<AggregateStateTypeInfo>().state_type;
-}
-
-const string AggregateStateType::GetTypeName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::AGGREGATE_STATE);
-	auto info = type.AuxInfo();
-	if (!info) {
-		return "AGGREGATE_STATE<?>";
-	}
-	auto aggr_state = info->Cast<AggregateStateTypeInfo>().state_type;
-	return "AGGREGATE_STATE<" + aggr_state.function_name + "(" +
-	       StringUtil::Join(aggr_state.bound_argument_types, aggr_state.bound_argument_types.size(), ", ",
-	                        [](const LogicalType &arg_type) { return arg_type.ToString(); }) +
-	       ")" + "::" + aggr_state.return_type.ToString() + ">";
-}
-
-//===--------------------------------------------------------------------===//
-// Struct Type
-//===--------------------------------------------------------------------===//
-const child_list_t<LogicalType> &StructType::GetChildTypes(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::UNION);
-
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return info->Cast<StructTypeInfo>().child_types;
-}
-
-const LogicalType &StructType::GetChildType(const LogicalType &type, idx_t index) {
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(index < child_types.size());
-	return child_types[index].second;
-}
-
-const string &StructType::GetChildName(const LogicalType &type, idx_t index) {
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(index < child_types.size());
-	return child_types[index].first;
-}
-
-idx_t StructType::GetChildIndexUnsafe(const LogicalType &type, const string &name) {
-	auto &child_types = StructType::GetChildTypes(type);
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		if (StringUtil::CIEquals(child_types[i].first, name)) {
-			return i;
-		}
-	}
-	throw InternalException("Could not find child with name \"%s\" in struct type \"%s\"", name, type.ToString());
-}
-
-idx_t StructType::GetChildCount(const LogicalType &type) {
-	return StructType::GetChildTypes(type).size();
-}
-bool StructType::IsUnnamed(const LogicalType &type) {
-	auto &child_types = StructType::GetChildTypes(type);
-	if (child_types.empty()) {
-		return false;
-	}
-	return child_types[0].first.empty(); // NOLINT
-}
-
-LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
-	auto info = make_shared_ptr<StructTypeInfo>(std::move(children));
-	return LogicalType(LogicalTypeId::STRUCT, std::move(info));
-}
-
-LogicalType LogicalType::AGGREGATE_STATE(aggregate_state_t state_type) { // NOLINT
-	auto info = make_shared_ptr<AggregateStateTypeInfo>(std::move(state_type));
-	return LogicalType(LogicalTypeId::AGGREGATE_STATE, std::move(info));
-}
-
-//===--------------------------------------------------------------------===//
-// Map Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::MAP(const LogicalType &child_p) {
-	D_ASSERT(child_p.id() == LogicalTypeId::STRUCT);
-	auto &children = StructType::GetChildTypes(child_p);
-	D_ASSERT(children.size() == 2);
-
-	// We do this to enforce that for every MAP created, the keys are called "key"
-	// and the values are called "value"
-
-	// This is done because for Vector the keys of the STRUCT are used in equality checks.
-	// Vector::Reference will throw if the types don't match
-	child_list_t<LogicalType> new_children(2);
-	new_children[0] = children[0];
-	new_children[0].first = "key";
-
-	new_children[1] = children[1];
-	new_children[1].first = "value";
-
-	auto child = LogicalType::STRUCT(std::move(new_children));
-	auto info = make_shared_ptr<ListTypeInfo>(child);
-	return LogicalType(LogicalTypeId::MAP, std::move(info));
-}
-
-LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
-	child_list_t<LogicalType> child_types;
-	child_types.emplace_back("key", std::move(key));
-	child_types.emplace_back("value", std::move(value));
-	return LogicalType::MAP(LogicalType::STRUCT(child_types));
-}
-
-const LogicalType &MapType::KeyType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::MAP);
-	return StructType::GetChildTypes(ListType::GetChildType(type))[0].second;
-}
-
-const LogicalType &MapType::ValueType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::MAP);
-	return StructType::GetChildTypes(ListType::GetChildType(type))[1].second;
-}
-
-//===--------------------------------------------------------------------===//
-// Union Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::UNION(child_list_t<LogicalType> members) {
-	D_ASSERT(!members.empty());
-	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
-	// union types always have a hidden "tag" field in front
-	members.insert(members.begin(), {"", LogicalType::UTINYINT});
-	auto info = make_shared_ptr<StructTypeInfo>(std::move(members));
-	return LogicalType(LogicalTypeId::UNION, std::move(info));
-}
-
-const LogicalType &UnionType::GetMemberType(const LogicalType &type, idx_t index) {
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(index < child_types.size());
-	// skip the "tag" field
-	return child_types[index + 1].second;
-}
-
-const string &UnionType::GetMemberName(const LogicalType &type, idx_t index) {
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(index < child_types.size());
-	// skip the "tag" field
-	return child_types[index + 1].first;
-}
-
-idx_t UnionType::GetMemberCount(const LogicalType &type) {
-	// don't count the "tag" field
-	return StructType::GetChildTypes(type).size() - 1;
-}
-const child_list_t<LogicalType> UnionType::CopyMemberTypes(const LogicalType &type) {
-	auto child_types = StructType::GetChildTypes(type);
-	child_types.erase(child_types.begin());
-	return child_types;
-}
-
-//===--------------------------------------------------------------------===//
-// User Type
-//===--------------------------------------------------------------------===//
-const string &UserType::GetCatalog(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::USER);
-	auto info = type.AuxInfo();
-	return info->Cast<UserTypeInfo>().catalog;
-}
-
-const string &UserType::GetSchema(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::USER);
-	auto info = type.AuxInfo();
-	return info->Cast<UserTypeInfo>().schema;
-}
-
-const string &UserType::GetTypeName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::USER);
-	auto info = type.AuxInfo();
-	return info->Cast<UserTypeInfo>().user_type_name;
-}
-
-const vector<Value> &UserType::GetTypeModifiers(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::USER);
-	auto info = type.AuxInfo();
-	return info->Cast<UserTypeInfo>().user_type_modifiers;
-}
-
-vector<Value> &UserType::GetTypeModifiers(LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::USER);
-	auto info = type.GetAuxInfoShrPtr();
-	return info->Cast<UserTypeInfo>().user_type_modifiers;
-}
-
-LogicalType LogicalType::USER(const string &user_type_name) {
-	auto info = make_shared_ptr<UserTypeInfo>(user_type_name);
-	return LogicalType(LogicalTypeId::USER, std::move(info));
-}
-
-LogicalType LogicalType::USER(const string &user_type_name, const vector<Value> &user_type_mods) {
-	auto info = make_shared_ptr<UserTypeInfo>(user_type_name, user_type_mods);
-	return LogicalType(LogicalTypeId::USER, std::move(info));
-}
-
-LogicalType LogicalType::USER(string catalog, string schema, string name, vector<Value> user_type_mods) {
-	auto info = make_shared_ptr<UserTypeInfo>(std::move(catalog), std::move(schema), std::move(name),
-	                                          std::move(user_type_mods));
-	return LogicalType(LogicalTypeId::USER, std::move(info));
-}
-
-//===--------------------------------------------------------------------===//
-// Enum Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::ENUM(Vector &ordered_data, idx_t size) {
-	return EnumTypeInfo::CreateType(ordered_data, size);
-}
-
-LogicalType LogicalType::ENUM(const string &enum_name, Vector &ordered_data, idx_t size) {
-	return LogicalType::ENUM(ordered_data, size);
-}
-
-const string EnumType::GetValue(const Value &val) {
-	auto info = val.type().AuxInfo();
-	auto &values_insert_order = info->Cast<EnumTypeInfo>().GetValuesInsertOrder();
-	return StringValue::Get(values_insert_order.GetValue(val.GetValue<uint32_t>()));
-}
-
-const Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	return info->Cast<EnumTypeInfo>().GetValuesInsertOrder();
-}
-
-idx_t EnumType::GetSize(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	return info->Cast<EnumTypeInfo>().GetDictSize();
-}
-
-PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto aux_info = type.AuxInfo();
-	auto &info = aux_info->Cast<EnumTypeInfo>();
-	D_ASSERT(info.GetEnumDictType() == EnumDictType::VECTOR_DICT);
-	return EnumTypeInfo::DictType(info.GetDictSize());
-}
-
-//===--------------------------------------------------------------------===//
-// JSON Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::JSON() {
-	auto json_type = LogicalType(LogicalTypeId::VARCHAR);
-	json_type.SetAlias(JSON_TYPE_NAME);
-	return json_type;
-}
-
-bool LogicalType::IsJSONType() const {
-	return id() == LogicalTypeId::VARCHAR && HasAlias() && GetAlias() == JSON_TYPE_NAME;
-}
-
-//===--------------------------------------------------------------------===//
-// Array Type
-//===--------------------------------------------------------------------===//
-
-const LogicalType &ArrayType::GetChildType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ARRAY);
-	auto info = type.AuxInfo();
-	return info->Cast<ArrayTypeInfo>().child_type;
-}
-
-idx_t ArrayType::GetSize(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ARRAY);
-	auto info = type.AuxInfo();
-	return info->Cast<ArrayTypeInfo>().size;
-}
-
-bool ArrayType::IsAnySize(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ARRAY);
-	auto info = type.AuxInfo();
-	return info->Cast<ArrayTypeInfo>().size == 0;
-}
-
-LogicalType ArrayType::ConvertToList(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::ARRAY: {
-		return LogicalType::LIST(ConvertToList(ArrayType::GetChildType(type)));
-	}
-	case LogicalTypeId::LIST:
-		return LogicalType::LIST(ConvertToList(ListType::GetChildType(type)));
-	case LogicalTypeId::STRUCT: {
-		auto children = StructType::GetChildTypes(type);
-		for (auto &child : children) {
-			child.second = ConvertToList(child.second);
-		}
-		return LogicalType::STRUCT(children);
-	}
-	case LogicalTypeId::MAP: {
-		auto key_type = ConvertToList(MapType::KeyType(type));
-		auto value_type = ConvertToList(MapType::ValueType(type));
-		return LogicalType::MAP(key_type, value_type);
-	}
-	case LogicalTypeId::UNION: {
-		auto children = UnionType::CopyMemberTypes(type);
-		for (auto &child : children) {
-			child.second = ConvertToList(child.second);
-		}
-		return LogicalType::UNION(children);
-	}
-	default:
-		return type;
-	}
-}
-
-LogicalType LogicalType::ARRAY(const LogicalType &child, optional_idx size) {
-	if (!size.IsValid()) {
-		// Create an incomplete ARRAY type, used for binding
-		auto info = make_shared_ptr<ArrayTypeInfo>(child, 0);
-		return LogicalType(LogicalTypeId::ARRAY, std::move(info));
-	} else {
-		auto array_size = size.GetIndex();
-		D_ASSERT(array_size > 0);
-		D_ASSERT(array_size <= ArrayType::MAX_ARRAY_SIZE);
-		auto info = make_shared_ptr<ArrayTypeInfo>(child, array_size);
-		return LogicalType(LogicalTypeId::ARRAY, std::move(info));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Any Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::ANY_PARAMS(LogicalType target, idx_t cast_score) { // NOLINT
-	auto type_info = make_shared_ptr<AnyTypeInfo>(std::move(target), cast_score);
-	return LogicalType(LogicalTypeId::ANY, std::move(type_info));
-}
-
-LogicalType AnyType::GetTargetType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ANY);
-	auto info = type.AuxInfo();
-	if (!info) {
-		return LogicalType::ANY;
-	}
-	return info->Cast<AnyTypeInfo>().target_type;
-}
-
-idx_t AnyType::GetCastScore(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ANY);
-	auto info = type.AuxInfo();
-	if (!info) {
-		return 5;
-	}
-	return info->Cast<AnyTypeInfo>().cast_score;
-}
-
-//===--------------------------------------------------------------------===//
-// Integer Literal Type
-//===--------------------------------------------------------------------===//
-LogicalType IntegerLiteral::GetType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::INTEGER_LITERAL);
-	auto info = type.AuxInfo();
-	D_ASSERT(info->type == ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO);
-	return info->Cast<IntegerLiteralTypeInfo>().constant_value.type();
-}
-
-bool IntegerLiteral::FitsInType(const LogicalType &type, const LogicalType &target) {
-	D_ASSERT(type.id() == LogicalTypeId::INTEGER_LITERAL);
-	// we can always cast integer literals to float and double
-	if (target.id() == LogicalTypeId::FLOAT || target.id() == LogicalTypeId::DOUBLE) {
-		return true;
-	}
-	if (!target.IsIntegral()) {
-		return false;
-	}
-	// we can cast to integral types if the constant value fits within that type
-	auto info = type.AuxInfo();
-	D_ASSERT(info->type == ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO);
-	auto &literal_info = info->Cast<IntegerLiteralTypeInfo>();
-	Value copy = literal_info.constant_value;
-	return copy.DefaultTryCastAs(target);
-}
-
-LogicalType LogicalType::INTEGER_LITERAL(const Value &constant) { // NOLINT
-	if (!constant.type().IsIntegral()) {
-		throw InternalException("INTEGER_LITERAL can only be made from literals of integer types");
-	}
-	auto type_info = make_shared_ptr<IntegerLiteralTypeInfo>(constant);
-	return LogicalType(LogicalTypeId::INTEGER_LITERAL, std::move(type_info));
-}
-
-//===--------------------------------------------------------------------===//
-// Logical Type
-//===--------------------------------------------------------------------===//
-
-// the destructor needs to know about the extra type info
-LogicalType::~LogicalType() {
-}
-
-bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {
-	if (type_info_.get() == rhs.type_info_.get()) {
-		return true;
-	}
-	if (type_info_) {
-		return type_info_->Equals(rhs.type_info_.get());
-	} else {
-		D_ASSERT(rhs.type_info_);
-		return rhs.type_info_->Equals(type_info_.get());
-	}
-}
-
-bool LogicalType::operator==(const LogicalType &rhs) const {
-	if (id_ != rhs.id_) {
-		return false;
-	}
-	return EqualTypeInfo(rhs);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/batched_data_collection.cpp b/src/duckdb/src/common/types/batched_data_collection.cpp
deleted file mode 100644
index fd25dbc1a..000000000
--- a/src/duckdb/src/common/types/batched_data_collection.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-#include "duckdb/common/types/batched_data_collection.hpp"
-
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-BatchedDataCollection::BatchedDataCollection(ClientContext &context_p, vector<LogicalType> types_p,
-                                             bool buffer_managed_p)
-    : context(context_p), types(std::move(types_p)), buffer_managed(buffer_managed_p) {
-}
-
-BatchedDataCollection::BatchedDataCollection(ClientContext &context_p, vector<LogicalType> types_p, batch_map_t batches,
-                                             bool buffer_managed_p)
-    : context(context_p), types(std::move(types_p)), buffer_managed(buffer_managed_p), data(std::move(batches)) {
-}
-
-void BatchedDataCollection::Append(DataChunk &input, idx_t batch_index) {
-	D_ASSERT(batch_index != DConstants::INVALID_INDEX);
-	optional_ptr<ColumnDataCollection> collection;
-	if (last_collection.collection && last_collection.batch_index == batch_index) {
-		// we are inserting into the same collection as before: use it directly
-		collection = last_collection.collection;
-	} else {
-		// new collection: check if there is already an entry
-		D_ASSERT(data.find(batch_index) == data.end());
-		unique_ptr<ColumnDataCollection> new_collection;
-		if (last_collection.collection) {
-			new_collection = make_uniq<ColumnDataCollection>(*last_collection.collection);
-		} else if (buffer_managed) {
-			new_collection = make_uniq<ColumnDataCollection>(BufferManager::GetBufferManager(context), types);
-		} else {
-			new_collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
-		}
-		last_collection.collection = new_collection.get();
-		last_collection.batch_index = batch_index;
-		new_collection->InitializeAppend(last_collection.append_state);
-		collection = new_collection.get();
-		data.insert(make_pair(batch_index, std::move(new_collection)));
-	}
-	collection->Append(last_collection.append_state, input);
-}
-
-void BatchedDataCollection::Merge(BatchedDataCollection &other) {
-	for (auto &entry : other.data) {
-		if (data.find(entry.first) != data.end()) {
-			throw InternalException(
-			    "BatchedDataCollection::Merge error - batch index %d is present in both collections. This occurs when "
-			    "batch indexes are not uniquely distributed over threads",
-			    entry.first);
-		}
-		data[entry.first] = std::move(entry.second);
-	}
-	other.data.clear();
-}
-
-void BatchedDataCollection::InitializeScan(BatchedChunkScanState &state, const BatchedChunkIteratorRange &range) {
-	state.range = range;
-	if (state.range.begin == state.range.end) {
-		return;
-	}
-	state.range.begin->second->InitializeScan(state.scan_state);
-}
-
-void BatchedDataCollection::InitializeScan(BatchedChunkScanState &state) {
-	auto range = BatchRange();
-	return InitializeScan(state, range);
-}
-
-void BatchedDataCollection::Scan(BatchedChunkScanState &state, DataChunk &output) {
-	while (state.range.begin != state.range.end) {
-		// check if there is a chunk remaining in this collection
-		auto collection = state.range.begin->second.get();
-		collection->Scan(state.scan_state, output);
-		if (output.size() > 0) {
-			return;
-		}
-		// there isn't! move to the next collection
-		state.range.begin->second.reset();
-		state.range.begin++;
-		if (state.range.begin == state.range.end) {
-			return;
-		}
-		state.range.begin->second->InitializeScan(state.scan_state);
-	}
-}
-
-unique_ptr<ColumnDataCollection> BatchedDataCollection::FetchCollection() {
-	unique_ptr<ColumnDataCollection> result;
-	for (auto &entry : data) {
-		if (!result) {
-			result = std::move(entry.second);
-		} else {
-			result->Combine(*entry.second);
-		}
-	}
-	data.clear();
-	if (!result) {
-		// empty result
-		return make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
-	}
-	return result;
-}
-
-const vector<LogicalType> &BatchedDataCollection::Types() const {
-	return types;
-}
-
-idx_t BatchedDataCollection::Count() const {
-	idx_t count = 0;
-	for (auto &collection : data) {
-		count += collection.second->Count();
-	}
-	return count;
-}
-
-idx_t BatchedDataCollection::BatchCount() const {
-	return data.size();
-}
-
-idx_t BatchedDataCollection::IndexToBatchIndex(idx_t index) const {
-	if (index >= data.size()) {
-		throw InternalException("Index %d is out of range for this collection, it only contains %d batches", index,
-		                        data.size());
-	}
-	auto entry = data.begin();
-	std::advance(entry, index);
-	return entry->first;
-}
-
-idx_t BatchedDataCollection::BatchSize(idx_t batch_index) const {
-	auto &collection = Batch(batch_index);
-	return collection.Count();
-}
-
-const ColumnDataCollection &BatchedDataCollection::Batch(idx_t batch_index) const {
-	auto entry = data.find(batch_index);
-	if (entry == data.end()) {
-		throw InternalException("This batched data collection does not contain a collection for batch_index %d",
-		                        batch_index);
-	}
-	return *entry->second;
-}
-
-BatchedChunkIteratorRange BatchedDataCollection::BatchRange(idx_t begin_idx, idx_t end_idx) {
-	D_ASSERT(begin_idx < end_idx);
-	if (end_idx > data.size()) {
-		// Limit the iterator to the end
-		end_idx = DConstants::INVALID_INDEX;
-	}
-	BatchedChunkIteratorRange range;
-	range.begin = data.begin();
-	std::advance(range.begin, begin_idx);
-	if (end_idx == DConstants::INVALID_INDEX) {
-		range.end = data.end();
-	} else {
-		range.end = data.begin();
-		std::advance(range.end, end_idx);
-	}
-	return range;
-}
-
-string BatchedDataCollection::ToString() const {
-	string result;
-	result += "Batched Data Collection\n";
-	for (auto &entry : data) {
-		result += "Batch Index - " + to_string(entry.first) + "\n";
-		result += entry.second->ToString() + "\n\n";
-	}
-	return result;
-}
-
-void BatchedDataCollection::Print() const {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/bit.cpp b/src/duckdb/src/common/types/bit.cpp
deleted file mode 100644
index 5006d64f2..000000000
--- a/src/duckdb/src/common/types/bit.cpp
+++ /dev/null
@@ -1,434 +0,0 @@
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-
-// **** helper functions ****
-static char ComputePadding(idx_t len) {
-	return UnsafeNumericCast<char>((8 - (len % 8)) % 8);
-}
-
-idx_t Bit::ComputeBitstringLen(idx_t len) {
-	idx_t result = len / 8;
-	if (len % 8 != 0) {
-		result++;
-	}
-	// additional first byte to store info on zero padding
-	result++;
-	return result;
-}
-
-static inline idx_t GetBitPadding(const bitstring_t &bit_string) {
-	auto data = const_data_ptr_cast(bit_string.GetData());
-	D_ASSERT(idx_t(data[0]) <= 8);
-	return data[0];
-}
-
-static inline idx_t GetBitSize(const string_t &str) {
-	string error_message;
-	idx_t str_len;
-	if (!Bit::TryGetBitStringSize(str, str_len, &error_message)) {
-		throw ConversionException(error_message);
-	}
-	return str_len;
-}
-
-uint8_t Bit::GetFirstByte(const bitstring_t &str) {
-	D_ASSERT(str.GetSize() > 1);
-
-	auto data = const_data_ptr_cast(str.GetData());
-	return data[1] & ((1 << (8 - data[0])) - 1);
-}
-
-void Bit::Finalize(bitstring_t &str) {
-	// bit strings require all padding bits to be set to 1
-	// this method sets all padding bits to 1
-	auto padding = GetBitPadding(str);
-	for (idx_t i = 0; i < idx_t(padding); i++) {
-		Bit::SetBitInternal(str, i, 1);
-	}
-	str.Finalize();
-	Bit::Verify(str);
-}
-
-void Bit::SetEmptyBitString(bitstring_t &target, string_t &input) {
-	char *res_buf = target.GetDataWriteable();
-	const char *buf = input.GetData();
-	memset(res_buf, 0, input.GetSize());
-	res_buf[0] = buf[0];
-	Bit::Finalize(target);
-}
-
-void Bit::SetEmptyBitString(bitstring_t &target, idx_t len) {
-	char *res_buf = target.GetDataWriteable();
-	memset(res_buf, 0, target.GetSize());
-	res_buf[0] = ComputePadding(len);
-	Bit::Finalize(target);
-}
-
-// **** casting functions ****
-void Bit::ToString(bitstring_t bits, char *output) {
-	auto data = const_data_ptr_cast(bits.GetData());
-	auto len = bits.GetSize();
-
-	idx_t padding = GetBitPadding(bits);
-	idx_t output_idx = 0;
-	for (idx_t bit_idx = padding; bit_idx < 8; bit_idx++) {
-		output[output_idx++] = data[1] & (1 << (7 - bit_idx)) ? '1' : '0';
-	}
-	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			output[output_idx++] = data[byte_idx] & (1 << (7 - bit_idx)) ? '1' : '0';
-		}
-	}
-}
-
-string Bit::ToString(bitstring_t str) {
-	auto len = BitLength(str);
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(len);
-	ToString(str, buffer.get());
-	return string(buffer.get(), len);
-}
-
-bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = const_data_ptr_cast(str.GetData());
-	auto len = str.GetSize();
-	str_len = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] == '0' || data[i] == '1') {
-			str_len++;
-		} else {
-			string error = StringUtil::Format("Invalid character encountered in string -> bit conversion: '%s'",
-			                                  string(const_char_ptr_cast(data) + i, 1));
-			HandleCastError::AssignError(error, error_message);
-			return false;
-		}
-	}
-	if (str_len == 0) {
-		string error = "Cannot cast empty string to BIT";
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	str_len = ComputeBitstringLen(str_len);
-	return true;
-}
-
-void Bit::ToBit(string_t str, bitstring_t &output_str) {
-	auto data = const_data_ptr_cast(str.GetData());
-	auto len = str.GetSize();
-	auto output = output_str.GetDataWriteable();
-
-	char byte = 0;
-	idx_t padded_byte = len % 8;
-	for (idx_t i = 0; i < padded_byte; i++) {
-		byte <<= 1;
-		if (data[i] == '1') {
-			byte |= 1;
-		}
-	}
-	if (padded_byte != 0) {
-		*(output++) = UnsafeNumericCast<char>((8 - padded_byte)); // the first byte contains the number of padded zeroes
-	}
-	*(output++) = byte;
-
-	for (idx_t byte_idx = padded_byte; byte_idx < len; byte_idx += 8) {
-		byte = 0;
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			byte <<= 1;
-			if (data[byte_idx + bit_idx] == '1') {
-				byte |= 1;
-			}
-		}
-		*(output++) = byte;
-	}
-	Bit::Finalize(output_str);
-}
-
-string Bit::ToBit(string_t str) {
-	auto bit_len = GetBitSize(str);
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(bit_len);
-	bitstring_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit_len));
-	Bit::ToBit(str, output_str);
-	return output_str.GetString();
-}
-
-void Bit::BlobToBit(string_t blob, bitstring_t &output_str) {
-	auto data = const_data_ptr_cast(blob.GetData());
-	auto output = output_str.GetDataWriteable();
-	idx_t size = blob.GetSize();
-
-	*output = 0; // No padding
-	memcpy(output + 1, data, size);
-}
-
-string Bit::BlobToBit(string_t blob) {
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(blob.GetSize() + 1);
-	bitstring_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(blob.GetSize() + 1));
-	Bit::BlobToBit(blob, output_str);
-	return output_str.GetString();
-}
-
-void Bit::BitToBlob(bitstring_t bit, string_t &output_blob) {
-	D_ASSERT(bit.GetSize() == output_blob.GetSize() + 1);
-
-	auto data = const_data_ptr_cast(bit.GetData());
-	auto output = output_blob.GetDataWriteable();
-	idx_t size = output_blob.GetSize();
-
-	output[0] = UnsafeNumericCast<char>(GetFirstByte(bit));
-	if (size >= 2) {
-		++output;
-		// First byte in bitstring contains amount of padded bits,
-		// second byte in bitstring is the padded byte,
-		// therefore the rest of the data starts at data + 2 (third byte)
-		memcpy(output, data + 2, size - 1);
-	}
-}
-
-string Bit::BitToBlob(bitstring_t bit) {
-	D_ASSERT(bit.GetSize() > 1);
-
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(bit.GetSize() - 1);
-	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit.GetSize() - 1));
-	Bit::BitToBlob(bit, output_str);
-	return output_str.GetString();
-}
-
-// **** scalar functions ****
-void Bit::BitString(const string_t &input, idx_t bit_length, bitstring_t &result) {
-	char *res_buf = result.GetDataWriteable();
-	const char *buf = input.GetData();
-
-	auto padding = ComputePadding(bit_length);
-	res_buf[0] = padding;
-	auto padding_len = UnsafeNumericCast<idx_t>(padding);
-	for (idx_t i = 0; i < bit_length; i++) {
-		if (i < bit_length - input.GetSize()) {
-			Bit::SetBitInternal(result, i + padding_len, 0);
-		} else {
-			idx_t bit = buf[i - (bit_length - input.GetSize())] == '1' ? 1 : 0;
-			Bit::SetBitInternal(result, i + padding_len, bit);
-		}
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::ExtendBitString(const bitstring_t &input, idx_t bit_length, bitstring_t &result) {
-	uint8_t *res_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-
-	auto padding = ComputePadding(bit_length);
-	res_buf[0] = static_cast<uint8_t>(padding);
-
-	idx_t original_length = Bit::BitLength(input);
-	D_ASSERT(bit_length >= original_length);
-	idx_t shift = bit_length - original_length;
-	for (idx_t i = 0; i < bit_length; i++) {
-		if (i < shift) {
-			Bit::SetBit(result, i, 0);
-		} else {
-			idx_t bit = Bit::GetBit(input, i - shift);
-			Bit::SetBit(result, i, bit);
-		}
-	}
-	Bit::Finalize(result);
-}
-
-idx_t Bit::BitLength(bitstring_t bits) {
-	return ((bits.GetSize() - 1) * 8) - GetBitPadding(bits);
-}
-
-idx_t Bit::OctetLength(bitstring_t bits) {
-	return bits.GetSize() - 1;
-}
-
-idx_t Bit::BitCount(bitstring_t bits) {
-	idx_t count = 0;
-	const char *buf = bits.GetData();
-	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
-		}
-	}
-	return count - GetBitPadding(bits);
-}
-
-idx_t Bit::BitPosition(bitstring_t substring, bitstring_t bits) {
-	const char *buf = bits.GetData();
-	auto len = bits.GetSize();
-	auto substr_len = BitLength(substring);
-	idx_t substr_idx = 0;
-
-	for (idx_t bit_idx = GetBitPadding(bits); bit_idx < 8; bit_idx++) {
-		idx_t bit = buf[1] & (1 << (7 - bit_idx)) ? 1 : 0;
-		if (bit == GetBit(substring, substr_idx)) {
-			substr_idx++;
-			if (substr_idx == substr_len) {
-				return (bit_idx - GetBitPadding(bits)) - substr_len + 2;
-			}
-		} else {
-			substr_idx = 0;
-		}
-	}
-
-	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			idx_t bit = buf[byte_idx] & (1 << (7 - bit_idx)) ? 1 : 0;
-			if (bit == GetBit(substring, substr_idx)) {
-				substr_idx++;
-				if (substr_idx == substr_len) {
-					return (((byte_idx - 1) * 8) + bit_idx - GetBitPadding(bits)) - substr_len + 2;
-				}
-			} else {
-				substr_idx = 0;
-			}
-		}
-	}
-	return 0;
-}
-
-idx_t Bit::GetBit(bitstring_t bit_string, idx_t n) {
-	return Bit::GetBitInternal(bit_string, n + GetBitPadding(bit_string));
-}
-
-idx_t Bit::GetBitIndex(idx_t n) {
-	return n / 8 + 1;
-}
-
-idx_t Bit::GetBitInternal(bitstring_t bit_string, idx_t n) {
-	const char *buf = bit_string.GetData();
-	auto idx = Bit::GetBitIndex(n);
-	D_ASSERT(idx < bit_string.GetSize());
-	auto byte = buf[idx] >> (7 - (n % 8));
-	return (byte & 1 ? 1 : 0);
-}
-
-void Bit::SetBit(bitstring_t &bit_string, idx_t n, idx_t new_value) {
-	SetBitInternal(bit_string, n + GetBitPadding(bit_string), new_value);
-	Bit::Finalize(bit_string);
-}
-
-void Bit::SetBitInternal(bitstring_t &bit_string, idx_t n, idx_t new_value) {
-	uint8_t *buf = reinterpret_cast<uint8_t *>(bit_string.GetDataWriteable());
-
-	auto idx = Bit::GetBitIndex(n);
-	D_ASSERT(idx < bit_string.GetSize());
-	auto shift_byte = UnsafeNumericCast<uint8_t>(1 << (7 - (n % 8)));
-	if (new_value == 0) {
-		shift_byte = ~shift_byte;
-		buf[idx] &= shift_byte;
-	} else {
-		buf[idx] |= shift_byte;
-	}
-}
-
-// **** BITWISE operators ****
-void Bit::RightShift(const bitstring_t &bit_string, idx_t shift, bitstring_t &result) {
-	uint8_t *res_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-	const uint8_t *buf = reinterpret_cast<const uint8_t *>(bit_string.GetData());
-
-	res_buf[0] = buf[0];
-	auto padding = GetBitPadding(result);
-	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
-		if (i < shift) {
-			Bit::SetBitInternal(result, i + padding, 0);
-		} else {
-			idx_t bit = Bit::GetBit(bit_string, i - shift);
-			Bit::SetBitInternal(result, i + padding, bit);
-		}
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::LeftShift(const bitstring_t &bit_string, idx_t shift, bitstring_t &result) {
-	uint8_t *res_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-	const uint8_t *buf = reinterpret_cast<const uint8_t *>(bit_string.GetData());
-
-	res_buf[0] = buf[0];
-	auto padding = GetBitPadding(result);
-	for (idx_t i = 0; i < Bit::BitLength(bit_string); i++) {
-		if (i < (Bit::BitLength(bit_string) - shift)) {
-			idx_t bit = Bit::GetBit(bit_string, shift + i);
-			Bit::SetBitInternal(result, i + padding, bit);
-		} else {
-			Bit::SetBitInternal(result, i + padding, 0);
-		}
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::BitwiseAnd(const bitstring_t &rhs, const bitstring_t &lhs, bitstring_t &result) {
-	if (Bit::BitLength(lhs) != Bit::BitLength(rhs)) {
-		throw InvalidInputException("Cannot AND bit strings of different sizes");
-	}
-
-	uint8_t *buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-	const uint8_t *r_buf = reinterpret_cast<const uint8_t *>(rhs.GetData());
-	const uint8_t *l_buf = reinterpret_cast<const uint8_t *>(lhs.GetData());
-
-	buf[0] = l_buf[0];
-	for (idx_t i = 1; i < lhs.GetSize(); i++) {
-		buf[i] = l_buf[i] & r_buf[i];
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::BitwiseOr(const bitstring_t &rhs, const bitstring_t &lhs, bitstring_t &result) {
-	if (Bit::BitLength(lhs) != Bit::BitLength(rhs)) {
-		throw InvalidInputException("Cannot OR bit strings of different sizes");
-	}
-
-	uint8_t *buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-	const uint8_t *r_buf = reinterpret_cast<const uint8_t *>(rhs.GetData());
-	const uint8_t *l_buf = reinterpret_cast<const uint8_t *>(lhs.GetData());
-
-	buf[0] = l_buf[0];
-	for (idx_t i = 1; i < lhs.GetSize(); i++) {
-		buf[i] = l_buf[i] | r_buf[i];
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::BitwiseXor(const bitstring_t &rhs, const bitstring_t &lhs, bitstring_t &result) {
-	if (Bit::BitLength(lhs) != Bit::BitLength(rhs)) {
-		throw InvalidInputException("Cannot XOR bit strings of different sizes");
-	}
-
-	uint8_t *buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-	const uint8_t *r_buf = reinterpret_cast<const uint8_t *>(rhs.GetData());
-	const uint8_t *l_buf = reinterpret_cast<const uint8_t *>(lhs.GetData());
-
-	buf[0] = l_buf[0];
-	for (idx_t i = 1; i < lhs.GetSize(); i++) {
-		buf[i] = l_buf[i] ^ r_buf[i];
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::BitwiseNot(const bitstring_t &input, bitstring_t &result) {
-	uint8_t *result_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
-	const uint8_t *buf = reinterpret_cast<const uint8_t *>(input.GetData());
-
-	result_buf[0] = buf[0];
-	for (idx_t i = 1; i < input.GetSize(); i++) {
-		result_buf[i] = ~buf[i];
-	}
-	Bit::Finalize(result);
-}
-
-void Bit::Verify(const bitstring_t &input) {
-#ifdef DEBUG
-	// bit strings require all padding bits to be set to 1
-	auto padding = GetBitPadding(input);
-	for (idx_t i = 0; i < padding; i++) {
-		D_ASSERT(Bit::GetBitInternal(input, i));
-	}
-	// verify bit respects the "normal" string_t rules (i.e. null padding for inlined strings, prefix matches)
-	input.VerifyCharacters();
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/blob.cpp b/src/duckdb/src/common/types/blob.cpp
deleted file mode 100644
index 11cd47b7e..000000000
--- a/src/duckdb/src/common/types/blob.cpp
+++ /dev/null
@@ -1,281 +0,0 @@
-#include "duckdb/common/types/blob.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-
-constexpr const char *Blob::HEX_TABLE;
-const int Blob::HEX_MAP[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
-    -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
-bool IsRegularCharacter(data_t c) {
-	return c >= 32 && c <= 126 && c != '\\' && c != '\'' && c != '"';
-}
-
-idx_t Blob::GetStringSize(string_t blob) {
-	auto data = const_data_ptr_cast(blob.GetData());
-	auto len = blob.GetSize();
-	idx_t str_len = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (IsRegularCharacter(data[i])) {
-			// ascii characters are rendered as-is
-			str_len++;
-		} else {
-			// non-ascii characters are rendered as hexadecimal (e.g. \x00)
-			str_len += 4;
-		}
-	}
-	return str_len;
-}
-
-void Blob::ToString(string_t blob, char *output) {
-	auto data = const_data_ptr_cast(blob.GetData());
-	auto len = blob.GetSize();
-	idx_t str_idx = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (IsRegularCharacter(data[i])) {
-			// ascii characters are rendered as-is
-			output[str_idx++] = UnsafeNumericCast<char>(data[i]);
-		} else {
-			auto byte_a = data[i] >> 4;
-			auto byte_b = data[i] & 0x0F;
-			D_ASSERT(byte_a >= 0 && byte_a < 16);
-			D_ASSERT(byte_b >= 0 && byte_b < 16);
-			// non-ascii characters are rendered as hexadecimal (e.g. \x00)
-			output[str_idx++] = '\\';
-			output[str_idx++] = 'x';
-			output[str_idx++] = Blob::HEX_TABLE[byte_a];
-			output[str_idx++] = Blob::HEX_TABLE[byte_b];
-		}
-	}
-	D_ASSERT(str_idx == GetStringSize(blob));
-}
-
-string Blob::ToString(string_t blob) {
-	auto str_len = GetStringSize(blob);
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(str_len);
-	Blob::ToString(blob, buffer.get());
-	return string(buffer.get(), str_len);
-}
-
-bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, CastParameters &parameters) {
-	auto data = const_data_ptr_cast(str.GetData());
-	auto len = str.GetSize();
-	str_len = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] == '\\') {
-			if (i + 3 >= len) {
-				string error = StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion of "
-				                                  "string \"%s\": unterminated escape code at end of blob",
-				                                  str.GetString());
-				HandleCastError::AssignError(error, parameters);
-				return false;
-			}
-			if (data[i + 1] != 'x' || Blob::HEX_MAP[data[i + 2]] < 0 || Blob::HEX_MAP[data[i + 3]] < 0) {
-				string error = StringUtil::Format(
-				    "Invalid hex escape code encountered in string -> blob conversion of string \"%s\": %s",
-				    str.GetString(), string(const_char_ptr_cast(data) + i, 4));
-				HandleCastError::AssignError(error, parameters);
-				return false;
-			}
-			str_len++;
-			i += 3;
-		} else if (data[i] <= 127) {
-			str_len++;
-		} else {
-			string error = StringUtil::Format(
-			    "Invalid byte encountered in STRING -> BLOB conversion of string \"%s\". All non-ascii characters "
-			    "must be escaped with hex codes (e.g. \\xAA)",
-			    str.GetString());
-			HandleCastError::AssignError(error, parameters);
-			return false;
-		}
-	}
-	return true;
-}
-
-idx_t Blob::GetBlobSize(string_t str) {
-	CastParameters parameters;
-	return GetBlobSize(str, parameters);
-}
-
-idx_t Blob::GetBlobSize(string_t str, CastParameters &parameters) {
-	idx_t str_len;
-	auto result = Blob::TryGetBlobSize(str, str_len, parameters);
-	if (!result) {
-		throw InternalException("Blob::TryGetBlobSize failed but no exception was thrown!?");
-	}
-	return str_len;
-}
-
-void Blob::ToBlob(string_t str, data_ptr_t output) {
-	auto data = const_data_ptr_cast(str.GetData());
-	auto len = str.GetSize();
-	idx_t blob_idx = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] == '\\') {
-			int byte_a = Blob::HEX_MAP[data[i + 2]];
-			int byte_b = Blob::HEX_MAP[data[i + 3]];
-			D_ASSERT(i + 3 < len);
-			D_ASSERT(byte_a >= 0 && byte_b >= 0);
-			D_ASSERT(data[i + 1] == 'x');
-			output[blob_idx++] = UnsafeNumericCast<data_t>((byte_a << 4) + byte_b);
-			i += 3;
-		} else if (data[i] <= 127) {
-			output[blob_idx++] = data_t(data[i]);
-		} else {
-			throw ConversionException("Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters "
-			                          "must be escaped with hex codes (e.g. \\xAA)");
-		}
-	}
-	D_ASSERT(blob_idx == GetBlobSize(str));
-}
-
-string Blob::ToBlob(string_t str) {
-	CastParameters parameters;
-	return Blob::ToBlob(str, parameters);
-}
-
-string Blob::ToBlob(string_t str, CastParameters &parameters) {
-	auto blob_len = GetBlobSize(str, parameters);
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(blob_len);
-	Blob::ToBlob(str, data_ptr_cast(buffer.get()));
-	return string(buffer.get(), blob_len);
-}
-
-// base64 functions are adapted from https://gist.github.com/tomykaira/f0fd86b6c73063283afe550bc5d77594
-idx_t Blob::ToBase64Size(string_t blob) {
-	// every 4 characters in base64 encode 3 bytes, plus (potential) padding at the end
-	auto input_size = blob.GetSize();
-	return ((input_size + 2) / 3) * 4;
-}
-
-void Blob::ToBase64(string_t blob, char *output) {
-	auto input_data = const_data_ptr_cast(blob.GetData());
-	auto input_size = blob.GetSize();
-	idx_t out_idx = 0;
-	idx_t i;
-	// convert the bulk of the string to base64
-	// this happens in steps of 3 bytes -> 4 output bytes
-	for (i = 0; i + 2 < input_size; i += 3) {
-		output[out_idx++] = Blob::BASE64_MAP[(input_data[i] >> 2) & 0x3F];
-		output[out_idx++] = Blob::BASE64_MAP[((input_data[i] & 0x3) << 4) | ((input_data[i + 1] & 0xF0) >> 4)];
-		output[out_idx++] = Blob::BASE64_MAP[((input_data[i + 1] & 0xF) << 2) | ((input_data[i + 2] & 0xC0) >> 6)];
-		output[out_idx++] = Blob::BASE64_MAP[input_data[i + 2] & 0x3F];
-	}
-
-	if (i < input_size) {
-		// there are one or two bytes left over: we have to insert padding
-		// first write the first 6 bits of the first byte
-		output[out_idx++] = Blob::BASE64_MAP[(input_data[i] >> 2) & 0x3F];
-		// now check the character count
-		if (i == input_size - 1) {
-			// single byte left over: convert the remainder of that byte and insert padding
-			output[out_idx++] = Blob::BASE64_MAP[((input_data[i] & 0x3) << 4)];
-			output[out_idx++] = Blob::BASE64_PADDING;
-		} else {
-			// two bytes left over: convert the second byte as well
-			output[out_idx++] = Blob::BASE64_MAP[((input_data[i] & 0x3) << 4) | ((input_data[i + 1] & 0xF0) >> 4)];
-			output[out_idx++] = Blob::BASE64_MAP[((input_data[i + 1] & 0xF) << 2)];
-		}
-		output[out_idx++] = Blob::BASE64_PADDING;
-	}
-}
-
-static constexpr int BASE64_DECODING_TABLE[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-    -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-    22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
-    45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
-idx_t Blob::FromBase64Size(string_t str) {
-	auto input_data = str.GetData();
-	auto input_size = str.GetSize();
-	if (input_size % 4 != 0) {
-		// valid base64 needs to always be cleanly divisible by 4
-		throw ConversionException("Could not decode string \"%s\" as base64: length must be a multiple of 4",
-		                          str.GetString());
-	}
-	if (input_size < 4) {
-		// empty string
-		return 0;
-	}
-	auto base_size = input_size / 4 * 3;
-	// check for padding to figure out the length
-	if (input_data[input_size - 2] == Blob::BASE64_PADDING) {
-		// two bytes of padding
-		return base_size - 2;
-	}
-	if (input_data[input_size - 1] == Blob::BASE64_PADDING) {
-		// one byte of padding
-		return base_size - 1;
-	}
-	// no padding
-	return base_size;
-}
-
-template <bool ALLOW_PADDING>
-uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx_t base_idx) {
-	int decoded_bytes[4];
-	for (idx_t decode_idx = 0; decode_idx < 4; decode_idx++) {
-		if (ALLOW_PADDING && decode_idx >= 2 && input_data[base_idx + decode_idx] == Blob::BASE64_PADDING) {
-			// the last two bytes of a base64 string can have padding: in this case we set the byte to 0
-			decoded_bytes[decode_idx] = 0;
-		} else {
-			decoded_bytes[decode_idx] = BASE64_DECODING_TABLE[input_data[base_idx + decode_idx]];
-		}
-		if (decoded_bytes[decode_idx] < 0) {
-			throw ConversionException(
-			    "Could not decode string \"%s\" as base64: invalid byte value '%d' at position %d", str.GetString(),
-			    input_data[base_idx + decode_idx], base_idx + decode_idx);
-		}
-	}
-	return UnsafeNumericCast<uint32_t>((decoded_bytes[0] << 3 * 6) + (decoded_bytes[1] << 2 * 6) +
-	                                   (decoded_bytes[2] << 1 * 6) + (decoded_bytes[3] << 0 * 6));
-}
-
-void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
-	D_ASSERT(output_size == FromBase64Size(str));
-	auto input_data = const_data_ptr_cast(str.GetData());
-	auto input_size = str.GetSize();
-	if (input_size == 0) {
-		return;
-	}
-	idx_t out_idx = 0;
-	idx_t i = 0;
-	for (i = 0; i + 4 < input_size; i += 4) {
-		auto combined = DecodeBase64Bytes<false>(str, input_data, i);
-		output[out_idx++] = (combined >> 2 * 8) & 0xFF;
-		output[out_idx++] = (combined >> 1 * 8) & 0xFF;
-		output[out_idx++] = (combined >> 0 * 8) & 0xFF;
-	}
-	// decode the final four bytes: padding is allowed here
-	auto combined = DecodeBase64Bytes<true>(str, input_data, i);
-	output[out_idx++] = (combined >> 2 * 8) & 0xFF;
-	if (out_idx < output_size) {
-		output[out_idx++] = (combined >> 1 * 8) & 0xFF;
-	}
-	if (out_idx < output_size) {
-		output[out_idx++] = (combined >> 0 * 8) & 0xFF;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/cast_helpers.cpp b/src/duckdb/src/common/types/cast_helpers.cpp
deleted file mode 100644
index 5a5f11210..000000000
--- a/src/duckdb/src/common/types/cast_helpers.cpp
+++ /dev/null
@@ -1,313 +0,0 @@
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-
-namespace duckdb {
-
-const int64_t NumericHelper::POWERS_OF_TEN[] {1,
-                                              10,
-                                              100,
-                                              1000,
-                                              10000,
-                                              100000,
-                                              1000000,
-                                              10000000,
-                                              100000000,
-                                              1000000000,
-                                              10000000000,
-                                              100000000000,
-                                              1000000000000,
-                                              10000000000000,
-                                              100000000000000,
-                                              1000000000000000,
-                                              10000000000000000,
-                                              100000000000000000,
-                                              1000000000000000000};
-
-const double NumericHelper::DOUBLE_POWERS_OF_TEN[] {1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,
-                                                    1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-                                                    1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
-                                                    1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39};
-
-template <>
-int NumericHelper::UnsignedLength(uint8_t value) {
-	int length = 1;
-	length += value >= 10;
-	length += value >= 100;
-	return length;
-}
-
-template <>
-int NumericHelper::UnsignedLength(uint16_t value) {
-	int length = 1;
-	length += value >= 10;
-	length += value >= 100;
-	length += value >= 1000;
-	length += value >= 10000;
-	return length;
-}
-
-template <>
-int NumericHelper::UnsignedLength(uint32_t value) {
-	if (value >= 10000) {
-		int length = 5;
-		length += value >= 100000;
-		length += value >= 1000000;
-		length += value >= 10000000;
-		length += value >= 100000000;
-		length += value >= 1000000000;
-		return length;
-	} else {
-		int length = 1;
-		length += value >= 10;
-		length += value >= 100;
-		length += value >= 1000;
-		return length;
-	}
-}
-
-template <>
-int NumericHelper::UnsignedLength(uint64_t value) {
-	if (value >= 10000000000ULL) {
-		if (value >= 1000000000000000ULL) {
-			int length = 16;
-			length += value >= 10000000000000000ULL;
-			length += value >= 100000000000000000ULL;
-			length += value >= 1000000000000000000ULL;
-			length += value >= 10000000000000000000ULL;
-			return length;
-		} else {
-			int length = 11;
-			length += value >= 100000000000ULL;
-			length += value >= 1000000000000ULL;
-			length += value >= 10000000000000ULL;
-			length += value >= 100000000000000ULL;
-			return length;
-		}
-	} else {
-		if (value >= 100000ULL) {
-			int length = 6;
-			length += value >= 1000000ULL;
-			length += value >= 10000000ULL;
-			length += value >= 100000000ULL;
-			length += value >= 1000000000ULL;
-			return length;
-		} else {
-			int length = 1;
-			length += value >= 10ULL;
-			length += value >= 100ULL;
-			length += value >= 1000ULL;
-			length += value >= 10000ULL;
-			return length;
-		}
-	}
-}
-
-template <>
-int NumericHelper::UnsignedLength(hugeint_t value) {
-	D_ASSERT(value.upper >= 0);
-	if (value.upper == 0) {
-		return UnsignedLength<uint64_t>(value.lower);
-	}
-	// search the length using the POWERS_OF_TEN array
-	// the length has to be between [17] and [38], because the hugeint is bigger than 2^63
-	// we use the same approach as above, but split a bit more because comparisons for hugeints are more expensive
-	if (value >= Hugeint::POWERS_OF_TEN[27]) {
-		// [27..38]
-		if (value >= Hugeint::POWERS_OF_TEN[32]) {
-			if (value >= Hugeint::POWERS_OF_TEN[36]) {
-				int length = 37;
-				length += value >= Hugeint::POWERS_OF_TEN[37];
-				length += value >= Hugeint::POWERS_OF_TEN[38];
-				return length;
-			} else {
-				int length = 33;
-				length += value >= Hugeint::POWERS_OF_TEN[33];
-				length += value >= Hugeint::POWERS_OF_TEN[34];
-				length += value >= Hugeint::POWERS_OF_TEN[35];
-				return length;
-			}
-		} else {
-			if (value >= Hugeint::POWERS_OF_TEN[30]) {
-				int length = 31;
-				length += value >= Hugeint::POWERS_OF_TEN[31];
-				length += value >= Hugeint::POWERS_OF_TEN[32];
-				return length;
-			} else {
-				int length = 28;
-				length += value >= Hugeint::POWERS_OF_TEN[28];
-				length += value >= Hugeint::POWERS_OF_TEN[29];
-				return length;
-			}
-		}
-	} else {
-		// [17..27]
-		if (value >= Hugeint::POWERS_OF_TEN[22]) {
-			// [22..27]
-			if (value >= Hugeint::POWERS_OF_TEN[25]) {
-				int length = 26;
-				length += value >= Hugeint::POWERS_OF_TEN[26];
-				return length;
-			} else {
-				int length = 23;
-				length += value >= Hugeint::POWERS_OF_TEN[23];
-				length += value >= Hugeint::POWERS_OF_TEN[24];
-				return length;
-			}
-		} else {
-			// [17..22]
-			if (value >= Hugeint::POWERS_OF_TEN[20]) {
-				int length = 21;
-				length += value >= Hugeint::POWERS_OF_TEN[21];
-				return length;
-			} else {
-				int length = 18;
-				length += value >= Hugeint::POWERS_OF_TEN[18];
-				length += value >= Hugeint::POWERS_OF_TEN[19];
-				return length;
-			}
-		}
-	}
-}
-
-template <>
-string_t NumericHelper::FormatSigned(hugeint_t value, Vector &vector) {
-	int negative = value.upper < 0;
-	if (negative) {
-		if (value == NumericLimits<hugeint_t>::Minimum()) {
-			string_t result = StringVector::AddString(vector, Hugeint::HUGEINT_MINIMUM_STRING);
-			return result;
-		}
-		Hugeint::NegateInPlace(value);
-	}
-	int length = UnsignedLength(value) + negative;
-	string_t result = StringVector::EmptyString(vector, NumericCast<size_t>(length));
-	auto dataptr = result.GetDataWriteable();
-	auto endptr = dataptr + length;
-	if (value.upper == 0) {
-		// small value: format as uint64_t
-		endptr = NumericHelper::FormatUnsigned<uint64_t>(value.lower, endptr);
-	} else {
-		endptr = FormatUnsigned(value, endptr);
-	}
-	if (negative) {
-		*--endptr = '-';
-	}
-	D_ASSERT(endptr == dataptr);
-	result.Finalize();
-	return result;
-}
-
-template <>
-std::string NumericHelper::ToString(hugeint_t value) {
-	return Hugeint::ToString(value);
-}
-
-template <>
-std::string NumericHelper::ToString(uhugeint_t value) {
-	return Uhugeint::ToString(value);
-}
-
-template <>
-int DecimalToString::DecimalLength(hugeint_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(value > NumericLimits<hugeint_t>::Minimum());
-	int negative;
-
-	if (value.upper < 0) {
-		Hugeint::NegateInPlace(value);
-		negative = 1;
-	} else {
-		negative = 0;
-	}
-	if (scale == 0) {
-		// scale is 0: regular number
-		return NumericHelper::UnsignedLength(value) + negative;
-	}
-	// length is max of either:
-	// scale + 2 OR
-	// integer length + 1
-	// scale + 2 happens when the number is in the range of (-1, 1)
-	// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
-	// integer length + 1 happens when the number is outside of that range
-	// in that case we print the integer number, but with one extra character ('.')
-	auto extra_numbers = width > scale ? 2 : 1;
-	return MaxValue(scale + extra_numbers, NumericHelper::UnsignedLength(value) + 1) + negative;
-}
-
-template <>
-string_t DecimalToString::Format(hugeint_t value, uint8_t width, uint8_t scale, Vector &vector) {
-	int length = DecimalLength(value, width, scale);
-	string_t result = StringVector::EmptyString(vector, NumericCast<idx_t>(length));
-
-	auto dst = result.GetDataWriteable();
-
-	FormatDecimal(value, width, scale, dst, NumericCast<idx_t>(length));
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-char *NumericHelper::FormatUnsigned(hugeint_t value, char *ptr) {
-	while (value.upper > 0) {
-		// while integer division is slow, hugeint division is MEGA slow
-		// we want to avoid doing as many divisions as possible
-		// for that reason we start off doing a division by a large power of ten that uint64_t can hold
-		// (100000000000000000) - this is the third largest
-		// the reason we don't use the largest is because that can result in an overflow inside the division
-		// function
-		uint64_t remainder;
-		value = Hugeint::DivModPositive(value, 100000000000000000ULL, remainder);
-
-		auto startptr = ptr;
-		// now we format the remainder: note that we need to pad with zero's in case
-		// the remainder is small (i.e. less than 10000000000000000)
-		ptr = NumericHelper::FormatUnsigned<uint64_t>(remainder, ptr);
-
-		int format_length = UnsafeNumericCast<int>(startptr - ptr);
-		// pad with zero
-		for (int i = format_length; i < 17; i++) {
-			*--ptr = '0';
-		}
-	}
-	// once the value falls in the range of a uint64_t, fallback to formatting as uint64_t to avoid hugeint division
-	return NumericHelper::FormatUnsigned<uint64_t>(value.lower, ptr);
-}
-
-template <>
-void DecimalToString::FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, char *dst, idx_t len) {
-	auto endptr = dst + len;
-
-	int negative = value.upper < 0;
-	if (negative) {
-		Hugeint::NegateInPlace(value);
-		*dst = '-';
-		dst++;
-	}
-	if (scale == 0) {
-		// with scale=0 we format the number as a regular number
-		NumericHelper::FormatUnsigned(value, endptr);
-		return;
-	}
-
-	// we write two numbers:
-	// the numbers BEFORE the decimal (major)
-	// and the numbers AFTER the decimal (minor)
-	hugeint_t minor;
-	hugeint_t major = Hugeint::DivMod(value, Hugeint::POWERS_OF_TEN[scale], minor);
-
-	// write the number after the decimal
-	dst = NumericHelper::FormatUnsigned(minor, endptr);
-	// (optionally) pad with zeros and add the decimal point
-	while (dst > (endptr - scale)) {
-		*--dst = '0';
-	}
-	*--dst = '.';
-	// now write the part before the decimal
-	D_ASSERT(width > scale || major == 0);
-	if (width > scale) {
-		dst = NumericHelper::FormatUnsigned(major, dst);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/column/column_data_allocator.cpp b/src/duckdb/src/common/types/column/column_data_allocator.cpp
deleted file mode 100644
index 66a1e612f..000000000
--- a/src/duckdb/src/common/types/column/column_data_allocator.cpp
+++ /dev/null
@@ -1,297 +0,0 @@
-#include "duckdb/common/types/column/column_data_allocator.hpp"
-
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/types/column/column_data_collection_segment.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-ColumnDataAllocator::ColumnDataAllocator(Allocator &allocator) : type(ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
-	alloc.allocator = &allocator;
-}
-
-ColumnDataAllocator::ColumnDataAllocator(BufferManager &buffer_manager)
-    : type(ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
-	alloc.buffer_manager = &buffer_manager;
-}
-
-ColumnDataAllocator::ColumnDataAllocator(ClientContext &context, ColumnDataAllocatorType allocator_type)
-    : type(allocator_type) {
-	switch (type) {
-	case ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR:
-	case ColumnDataAllocatorType::HYBRID:
-		alloc.buffer_manager = &BufferManager::GetBufferManager(context);
-		break;
-	case ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR:
-		alloc.allocator = &Allocator::Get(context);
-		break;
-	default:
-		throw InternalException("Unrecognized column data allocator type");
-	}
-}
-
-ColumnDataAllocator::ColumnDataAllocator(ColumnDataAllocator &other) {
-	type = other.GetType();
-	switch (type) {
-	case ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR:
-	case ColumnDataAllocatorType::HYBRID:
-		alloc.allocator = other.alloc.allocator;
-		break;
-	case ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR:
-		alloc.buffer_manager = other.alloc.buffer_manager;
-		break;
-	default:
-		throw InternalException("Unrecognized column data allocator type");
-	}
-}
-
-ColumnDataAllocator::~ColumnDataAllocator() {
-	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
-		return;
-	}
-	for (auto &block : blocks) {
-		block.handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
-	}
-	const auto data_size = SizeInBytes();
-	blocks.clear();
-	if (Allocator::SupportsFlush() &&
-	    data_size > alloc.buffer_manager->GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) {
-		Allocator::FlushAll();
-	}
-}
-
-BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) {
-	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR || type == ColumnDataAllocatorType::HYBRID);
-	shared_ptr<BlockHandle> handle;
-	if (shared) {
-		// we only need to grab the lock when accessing the vector, because vector access is not thread-safe:
-		// the vector can be resized by another thread while we try to access it
-		lock_guard<mutex> guard(lock);
-		handle = blocks[block_id].handle;
-	} else {
-		handle = blocks[block_id].handle;
-	}
-	return alloc.buffer_manager->Pin(handle);
-}
-
-BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
-	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR || type == ColumnDataAllocatorType::HYBRID);
-	auto max_size = MaxValue<idx_t>(size, GetBufferManager().GetBlockSize());
-	BlockMetaData data;
-	data.size = 0;
-	data.capacity = NumericCast<uint32_t>(max_size);
-	auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, max_size, false);
-	data.handle = pin.GetBlockHandle();
-	blocks.push_back(std::move(data));
-	if (partition_index.IsValid()) { // Set the eviction queue index logarithmically using RadixBits
-		blocks.back().handle->SetEvictionQueueIndex(RadixPartitioning::RadixBits(partition_index.GetIndex()));
-	}
-	allocated_size += max_size;
-	return pin;
-}
-
-void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) {
-	auto allocation_amount = MaxValue<idx_t>(NextPowerOfTwo(size), 4096);
-	if (!blocks.empty()) {
-		idx_t last_capacity = blocks.back().capacity;
-		auto next_capacity = MinValue<idx_t>(last_capacity * 2, last_capacity + Storage::DEFAULT_BLOCK_SIZE);
-		allocation_amount = MaxValue<idx_t>(next_capacity, allocation_amount);
-	}
-	D_ASSERT(type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR);
-	BlockMetaData data;
-	data.size = 0;
-	data.capacity = NumericCast<uint32_t>(allocation_amount);
-	data.handle = nullptr;
-	blocks.push_back(std::move(data));
-	allocated_size += allocation_amount;
-}
-
-void ColumnDataAllocator::AssignPointer(uint32_t &block_id, uint32_t &offset, data_ptr_t pointer) {
-	auto pointer_value = uintptr_t(pointer);
-	if (sizeof(uintptr_t) == sizeof(uint32_t)) {
-		block_id = uint32_t(pointer_value);
-	} else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
-		block_id = uint32_t(pointer_value & 0xFFFFFFFF);
-		offset = uint32_t(pointer_value >> 32);
-	} else {
-		throw InternalException("ColumnDataCollection: Architecture not supported!?");
-	}
-}
-
-void ColumnDataAllocator::AllocateBuffer(idx_t size, uint32_t &block_id, uint32_t &offset,
-                                         ChunkManagementState *chunk_state) {
-	D_ASSERT(allocated_data.empty());
-	if (blocks.empty() || blocks.back().Capacity() < size) {
-		auto pinned_block = AllocateBlock(size);
-		if (chunk_state) {
-			D_ASSERT(!blocks.empty());
-			auto new_block_id = blocks.size() - 1;
-			chunk_state->handles[new_block_id] = std::move(pinned_block);
-		}
-	}
-	auto &block = blocks.back();
-	D_ASSERT(size <= block.capacity - block.size);
-	block_id = NumericCast<uint32_t>(blocks.size() - 1);
-	if (chunk_state && chunk_state->handles.find(block_id) == chunk_state->handles.end()) {
-		// not guaranteed to be pinned already by this thread (if shared allocator)
-		chunk_state->handles[block_id] = alloc.buffer_manager->Pin(blocks[block_id].handle);
-	}
-	offset = block.size;
-	block.size += size;
-}
-
-void ColumnDataAllocator::AllocateMemory(idx_t size, uint32_t &block_id, uint32_t &offset,
-                                         ChunkManagementState *chunk_state) {
-	D_ASSERT(blocks.size() == allocated_data.size());
-	if (blocks.empty() || blocks.back().Capacity() < size) {
-		AllocateEmptyBlock(size);
-		auto &last_block = blocks.back();
-		auto allocated = alloc.allocator->Allocate(last_block.capacity);
-		allocated_data.push_back(std::move(allocated));
-	}
-	auto &block = blocks.back();
-	D_ASSERT(size <= block.capacity - block.size);
-	AssignPointer(block_id, offset, allocated_data.back().get() + block.size);
-	block.size += size;
-}
-
-void ColumnDataAllocator::AllocateData(idx_t size, uint32_t &block_id, uint32_t &offset,
-                                       ChunkManagementState *chunk_state) {
-	switch (type) {
-	case ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR:
-	case ColumnDataAllocatorType::HYBRID:
-		if (shared) {
-			lock_guard<mutex> guard(lock);
-			AllocateBuffer(size, block_id, offset, chunk_state);
-		} else {
-			AllocateBuffer(size, block_id, offset, chunk_state);
-		}
-		break;
-	case ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR:
-		D_ASSERT(!shared);
-		AllocateMemory(size, block_id, offset, chunk_state);
-		break;
-	default:
-		throw InternalException("Unrecognized allocator type");
-	}
-}
-
-void ColumnDataAllocator::Initialize(ColumnDataAllocator &other) {
-	D_ASSERT(other.HasBlocks());
-	blocks.push_back(other.blocks.back());
-}
-
-data_ptr_t ColumnDataAllocator::GetDataPointer(ChunkManagementState &state, uint32_t block_id, uint32_t offset) {
-	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
-		// in-memory allocator: construct pointer from block_id and offset
-		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
-			uintptr_t pointer_value = uintptr_t(block_id);
-			return (data_ptr_t)pointer_value; // NOLINT - convert from pointer value back to pointer
-		} else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
-			uintptr_t pointer_value = (uintptr_t(offset) << 32) | uintptr_t(block_id);
-			return (data_ptr_t)pointer_value; // NOLINT - convert from pointer value back to pointer
-		} else {
-			throw InternalException("ColumnDataCollection: Architecture not supported!?");
-		}
-	}
-	D_ASSERT(state.handles.find(block_id) != state.handles.end());
-	return state.handles[block_id].Ptr() + offset;
-}
-
-void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector &result, idx_t v_offset, uint16_t count,
-                                            uint32_t block_id, uint32_t offset) {
-	D_ASSERT(result.GetType().InternalType() == PhysicalType::VARCHAR);
-	lock_guard<mutex> guard(lock);
-
-	auto &validity = FlatVector::Validity(result);
-	auto strings = FlatVector::GetData<string_t>(result);
-
-	// find first non-inlined string
-	auto i = NumericCast<uint32_t>(v_offset);
-	const uint32_t end = NumericCast<uint32_t>(v_offset + count);
-	for (; i < end; i++) {
-		if (!validity.RowIsValid(i)) {
-			continue;
-		}
-		if (!strings[i].IsInlined()) {
-			break;
-		}
-	}
-	// at least one string must be non-inlined, otherwise this function should not be called
-	D_ASSERT(i < end);
-
-	auto base_ptr = char_ptr_cast(GetDataPointer(state, block_id, offset));
-	if (strings[i].GetData() == base_ptr) {
-		// pointers are still valid
-		return;
-	}
-
-	// pointer mismatch! pointers are invalid, set them correctly
-	for (; i < end; i++) {
-		if (!validity.RowIsValid(i)) {
-			continue;
-		}
-		if (strings[i].IsInlined()) {
-			continue;
-		}
-		strings[i].SetPointer(base_ptr);
-		base_ptr += strings[i].GetSize();
-	}
-}
-
-void ColumnDataAllocator::SetDestroyBufferUponUnpin(uint32_t block_id) {
-	blocks[block_id].handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
-}
-
-Allocator &ColumnDataAllocator::GetAllocator() {
-	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
-		return *alloc.allocator;
-	}
-	return alloc.buffer_manager->GetBufferAllocator();
-}
-
-BufferManager &ColumnDataAllocator::GetBufferManager() {
-	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
-		throw InternalException("cannot obtain the buffer manager for in memory allocations");
-	}
-	return *alloc.buffer_manager;
-}
-
-void ColumnDataAllocator::InitializeChunkState(ChunkManagementState &state, ChunkMetaData &chunk) {
-	if (type != ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR && type != ColumnDataAllocatorType::HYBRID) {
-		// nothing to pin
-		return;
-	}
-	// release any handles that are no longer required
-	bool found_handle;
-	do {
-		found_handle = false;
-		for (auto it = state.handles.begin(); it != state.handles.end(); it++) {
-			if (chunk.block_ids.find(NumericCast<uint32_t>(it->first)) != chunk.block_ids.end()) {
-				// still required: do not release
-				continue;
-			}
-			state.handles.erase(it);
-			found_handle = true;
-			break;
-		}
-	} while (found_handle);
-
-	// grab any handles that are now required
-	for (auto &block_id : chunk.block_ids) {
-		if (state.handles.find(block_id) != state.handles.end()) {
-			// already pinned: don't need to do anything
-			continue;
-		}
-		state.handles[block_id] = Pin(block_id);
-	}
-}
-
-uint32_t BlockMetaData::Capacity() {
-	D_ASSERT(size <= capacity);
-	return capacity - size;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/column/column_data_collection.cpp b/src/duckdb/src/common/types/column/column_data_collection.cpp
deleted file mode 100644
index d6e01e5a6..000000000
--- a/src/duckdb/src/common/types/column/column_data_collection.cpp
+++ /dev/null
@@ -1,1242 +0,0 @@
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/column/column_data_collection_segment.hpp"
-#include "duckdb/common/types/value_map.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-struct ColumnDataMetaData;
-
-typedef void (*column_data_copy_function_t)(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data,
-                                            Vector &source, idx_t offset, idx_t copy_count);
-
-struct ColumnDataCopyFunction {
-	column_data_copy_function_t function;
-	vector<ColumnDataCopyFunction> child_functions;
-};
-
-struct ColumnDataMetaData {
-	ColumnDataMetaData(ColumnDataCopyFunction &copy_function, ColumnDataCollectionSegment &segment,
-	                   ColumnDataAppendState &state, ChunkMetaData &chunk_data, VectorDataIndex vector_data_index)
-	    : copy_function(copy_function), segment(segment), state(state), chunk_data(chunk_data),
-	      vector_data_index(vector_data_index) {
-	}
-	ColumnDataMetaData(ColumnDataCopyFunction &copy_function, ColumnDataMetaData &parent,
-	                   VectorDataIndex vector_data_index)
-	    : copy_function(copy_function), segment(parent.segment), state(parent.state), chunk_data(parent.chunk_data),
-	      vector_data_index(vector_data_index) {
-	}
-
-	ColumnDataCopyFunction &copy_function;
-	ColumnDataCollectionSegment &segment;
-	ColumnDataAppendState &state;
-	ChunkMetaData &chunk_data;
-	VectorDataIndex vector_data_index;
-	idx_t child_list_size = DConstants::INVALID_INDEX;
-
-	VectorMetaData &GetVectorMetaData() {
-		return segment.GetVectorData(vector_data_index);
-	}
-};
-
-//! Explicitly initialized without types
-ColumnDataCollection::ColumnDataCollection(Allocator &allocator_p) {
-	types.clear();
-	count = 0;
-	this->finished_append = false;
-	allocator = make_shared_ptr<ColumnDataAllocator>(allocator_p);
-}
-
-ColumnDataCollection::ColumnDataCollection(Allocator &allocator_p, vector<LogicalType> types_p) {
-	Initialize(std::move(types_p));
-	allocator = make_shared_ptr<ColumnDataAllocator>(allocator_p);
-}
-
-ColumnDataCollection::ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types_p) {
-	Initialize(std::move(types_p));
-	allocator = make_shared_ptr<ColumnDataAllocator>(buffer_manager);
-}
-
-ColumnDataCollection::ColumnDataCollection(shared_ptr<ColumnDataAllocator> allocator_p, vector<LogicalType> types_p) {
-	Initialize(std::move(types_p));
-	this->allocator = std::move(allocator_p);
-}
-
-ColumnDataCollection::ColumnDataCollection(ClientContext &context, vector<LogicalType> types_p,
-                                           ColumnDataAllocatorType type)
-    : ColumnDataCollection(make_shared_ptr<ColumnDataAllocator>(context, type), std::move(types_p)) {
-	D_ASSERT(!types.empty());
-}
-
-ColumnDataCollection::ColumnDataCollection(ColumnDataCollection &other)
-    : ColumnDataCollection(other.allocator, other.types) {
-	other.finished_append = true;
-	D_ASSERT(!types.empty());
-}
-
-ColumnDataCollection::~ColumnDataCollection() {
-}
-
-void ColumnDataCollection::Initialize(vector<LogicalType> types_p) {
-	this->types = std::move(types_p);
-	this->count = 0;
-	this->finished_append = false;
-	D_ASSERT(!types.empty());
-	copy_functions.reserve(types.size());
-	for (auto &type : types) {
-		copy_functions.push_back(GetCopyFunction(type));
-	}
-}
-
-void ColumnDataCollection::CreateSegment() {
-	segments.emplace_back(make_uniq<ColumnDataCollectionSegment>(allocator, types));
-}
-
-Allocator &ColumnDataCollection::GetAllocator() const {
-	return allocator->GetAllocator();
-}
-
-idx_t ColumnDataCollection::SizeInBytes() const {
-	idx_t total_size = 0;
-	for (const auto &segment : segments) {
-		total_size += segment->SizeInBytes();
-	}
-	return total_size;
-}
-
-idx_t ColumnDataCollection::AllocationSize() const {
-	idx_t total_size = 0;
-	for (const auto &segment : segments) {
-		total_size += segment->AllocationSize();
-	}
-	return total_size;
-}
-
-void ColumnDataCollection::SetPartitionIndex(const idx_t index) {
-	D_ASSERT(!partition_index.IsValid());
-	D_ASSERT(Count() == 0);
-	partition_index = index;
-	allocator->SetPartitionIndex(index);
-}
-
-//===--------------------------------------------------------------------===//
-// ColumnDataRow
-//===--------------------------------------------------------------------===//
-ColumnDataRow::ColumnDataRow(DataChunk &chunk_p, idx_t row_index, idx_t base_index)
-    : chunk(chunk_p), row_index(row_index), base_index(base_index) {
-}
-
-Value ColumnDataRow::GetValue(idx_t column_index) const {
-	D_ASSERT(column_index < chunk.ColumnCount());
-	D_ASSERT(row_index < chunk.size());
-	return chunk.data[column_index].GetValue(row_index);
-}
-
-idx_t ColumnDataRow::RowIndex() const {
-	return base_index + row_index;
-}
-
-//===--------------------------------------------------------------------===//
-// ColumnDataRowCollection
-//===--------------------------------------------------------------------===//
-ColumnDataRowCollection::ColumnDataRowCollection(const ColumnDataCollection &collection) {
-	if (collection.Count() == 0) {
-		return;
-	}
-	// read all the chunks
-	ColumnDataScanState temp_scan_state;
-	collection.InitializeScan(temp_scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY);
-	while (true) {
-		auto chunk = make_uniq<DataChunk>();
-		collection.InitializeScanChunk(*chunk);
-		if (!collection.Scan(temp_scan_state, *chunk)) {
-			break;
-		}
-		chunks.push_back(std::move(chunk));
-	}
-	// now create all of the column data rows
-	rows.reserve(collection.Count());
-	idx_t base_row = 0;
-	for (auto &chunk : chunks) {
-		for (idx_t row_idx = 0; row_idx < chunk->size(); row_idx++) {
-			rows.emplace_back(*chunk, row_idx, base_row);
-		}
-		base_row += chunk->size();
-	}
-}
-
-ColumnDataRow &ColumnDataRowCollection::operator[](idx_t i) {
-	return rows[i];
-}
-
-const ColumnDataRow &ColumnDataRowCollection::operator[](idx_t i) const {
-	return rows[i];
-}
-
-Value ColumnDataRowCollection::GetValue(idx_t column, idx_t index) const {
-	return rows[index].GetValue(column);
-}
-
-//===--------------------------------------------------------------------===//
-// ColumnDataChunkIterator
-//===--------------------------------------------------------------------===//
-ColumnDataChunkIterationHelper ColumnDataCollection::Chunks() const {
-	vector<column_t> column_ids;
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		column_ids.push_back(i);
-	}
-	return Chunks(column_ids);
-}
-
-ColumnDataChunkIterationHelper ColumnDataCollection::Chunks(vector<column_t> column_ids) const {
-	return ColumnDataChunkIterationHelper(*this, std::move(column_ids));
-}
-
-ColumnDataChunkIterationHelper::ColumnDataChunkIterationHelper(const ColumnDataCollection &collection_p,
-                                                               vector<column_t> column_ids_p)
-    : collection(collection_p), column_ids(std::move(column_ids_p)) {
-}
-
-ColumnDataChunkIterationHelper::ColumnDataChunkIterator::ColumnDataChunkIterator(
-    const ColumnDataCollection *collection_p, vector<column_t> column_ids_p)
-    : collection(collection_p), scan_chunk(make_shared_ptr<DataChunk>()), row_index(0) {
-	if (!collection) {
-		return;
-	}
-	collection->InitializeScan(scan_state, std::move(column_ids_p));
-	collection->InitializeScanChunk(scan_state, *scan_chunk);
-	collection->Scan(scan_state, *scan_chunk);
-}
-
-void ColumnDataChunkIterationHelper::ColumnDataChunkIterator::Next() {
-	if (!collection) {
-		return;
-	}
-	if (!collection->Scan(scan_state, *scan_chunk)) {
-		collection = nullptr;
-		row_index = 0;
-	} else {
-		row_index += scan_chunk->size();
-	}
-}
-
-ColumnDataChunkIterationHelper::ColumnDataChunkIterator &
-ColumnDataChunkIterationHelper::ColumnDataChunkIterator::operator++() {
-	Next();
-	return *this;
-}
-
-bool ColumnDataChunkIterationHelper::ColumnDataChunkIterator::operator!=(const ColumnDataChunkIterator &other) const {
-	return collection != other.collection || row_index != other.row_index;
-}
-
-DataChunk &ColumnDataChunkIterationHelper::ColumnDataChunkIterator::operator*() const {
-	return *scan_chunk;
-}
-
-//===--------------------------------------------------------------------===//
-// ColumnDataRowIterator
-//===--------------------------------------------------------------------===//
-ColumnDataRowIterationHelper ColumnDataCollection::Rows() const {
-	return ColumnDataRowIterationHelper(*this);
-}
-
-ColumnDataRowIterationHelper::ColumnDataRowIterationHelper(const ColumnDataCollection &collection_p)
-    : collection(collection_p) {
-}
-
-ColumnDataRowIterationHelper::ColumnDataRowIterator::ColumnDataRowIterator(const ColumnDataCollection *collection_p)
-    : collection(collection_p), scan_chunk(make_shared_ptr<DataChunk>()), current_row(*scan_chunk, 0, 0) {
-	if (!collection) {
-		return;
-	}
-	collection->InitializeScan(scan_state);
-	collection->InitializeScanChunk(*scan_chunk);
-	collection->Scan(scan_state, *scan_chunk);
-}
-
-void ColumnDataRowIterationHelper::ColumnDataRowIterator::Next() {
-	if (!collection) {
-		return;
-	}
-	current_row.row_index++;
-	if (current_row.row_index >= scan_chunk->size()) {
-		current_row.base_index += scan_chunk->size();
-		current_row.row_index = 0;
-		if (!collection->Scan(scan_state, *scan_chunk)) {
-			// exhausted collection: move iterator to nop state
-			current_row.base_index = 0;
-			collection = nullptr;
-		}
-	}
-}
-
-ColumnDataRowIterationHelper::ColumnDataRowIterator ColumnDataRowIterationHelper::begin() { // NOLINT
-	return ColumnDataRowIterationHelper::ColumnDataRowIterator(collection.Count() == 0 ? nullptr : &collection);
-}
-ColumnDataRowIterationHelper::ColumnDataRowIterator ColumnDataRowIterationHelper::end() { // NOLINT
-	return ColumnDataRowIterationHelper::ColumnDataRowIterator(nullptr);
-}
-
-ColumnDataRowIterationHelper::ColumnDataRowIterator &ColumnDataRowIterationHelper::ColumnDataRowIterator::operator++() {
-	Next();
-	return *this;
-}
-
-bool ColumnDataRowIterationHelper::ColumnDataRowIterator::operator!=(const ColumnDataRowIterator &other) const {
-	return collection != other.collection || current_row.row_index != other.current_row.row_index ||
-	       current_row.base_index != other.current_row.base_index;
-}
-
-const ColumnDataRow &ColumnDataRowIterationHelper::ColumnDataRowIterator::operator*() const {
-	return current_row;
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-void ColumnDataCollection::InitializeAppend(ColumnDataAppendState &state) {
-	D_ASSERT(!finished_append);
-	state.current_chunk_state.handles.clear();
-	state.vector_data.resize(types.size());
-	if (segments.empty()) {
-		CreateSegment();
-	}
-	auto &segment = *segments.back();
-	if (segment.chunk_data.empty()) {
-		segment.AllocateNewChunk();
-	}
-	segment.InitializeChunkState(segment.chunk_data.size() - 1, state.current_chunk_state);
-}
-
-void ColumnDataCopyValidity(const UnifiedVectorFormat &source_data, validity_t *target, idx_t source_offset,
-                            idx_t target_offset, idx_t copy_count) {
-	ValidityMask validity(target, STANDARD_VECTOR_SIZE);
-	if (target_offset == 0) {
-		// first time appending to this vector
-		// all data here is still uninitialized
-		// initialize the validity mask to set all to valid
-		validity.SetAllValid(STANDARD_VECTOR_SIZE);
-	}
-	// FIXME: we can do something more optimized here using bitshifts & bitwise ors
-	if (!source_data.validity.AllValid()) {
-		for (idx_t i = 0; i < copy_count; i++) {
-			auto idx = source_data.sel->get_index(source_offset + i);
-			if (!source_data.validity.RowIsValid(idx)) {
-				validity.SetInvalid(target_offset + i);
-			}
-		}
-	}
-}
-
-template <class T>
-struct BaseValueCopy {
-	static idx_t TypeSize() {
-		return sizeof(T);
-	}
-
-	template <class OP>
-	static void Assign(ColumnDataMetaData &meta_data, data_ptr_t target, data_ptr_t source, idx_t target_idx,
-	                   idx_t source_idx) {
-		auto result_data = (T *)target;
-		auto source_data = (T *)source;
-		result_data[target_idx] = OP::Operation(meta_data, source_data[source_idx]);
-	}
-};
-
-template <class T>
-struct StandardValueCopy : public BaseValueCopy<T> {
-	static T Operation(ColumnDataMetaData &, T input) {
-		return input;
-	}
-};
-
-struct StringValueCopy : public BaseValueCopy<string_t> {
-	static string_t Operation(ColumnDataMetaData &meta_data, string_t input) {
-		return input.IsInlined() ? input : meta_data.segment.heap->AddBlob(input);
-	}
-};
-
-struct ConstListValueCopy : public BaseValueCopy<list_entry_t> {
-	using TYPE = list_entry_t;
-
-	static TYPE Operation(ColumnDataMetaData &meta_data, TYPE input) {
-		input.offset = meta_data.child_list_size;
-		return input;
-	}
-};
-
-struct ListValueCopy : public BaseValueCopy<list_entry_t> {
-	using TYPE = list_entry_t;
-
-	static TYPE Operation(ColumnDataMetaData &meta_data, TYPE input) {
-		input.offset = meta_data.child_list_size;
-		meta_data.child_list_size += input.length;
-		return input;
-	}
-};
-
-struct StructValueCopy {
-	static idx_t TypeSize() {
-		return 0;
-	}
-
-	template <class OP>
-	static void Assign(ColumnDataMetaData &meta_data, data_ptr_t target, data_ptr_t source, idx_t target_idx,
-	                   idx_t source_idx) {
-	}
-};
-
-template <class OP>
-static void TemplatedColumnDataCopy(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data,
-                                    Vector &source, idx_t offset, idx_t count) {
-	auto &segment = meta_data.segment;
-	auto &append_state = meta_data.state;
-
-	auto current_index = meta_data.vector_data_index;
-	idx_t remaining = count;
-	while (remaining > 0) {
-		auto &current_segment = segment.GetVectorData(current_index);
-		idx_t append_count = MinValue<idx_t>(STANDARD_VECTOR_SIZE - current_segment.count, remaining);
-
-		auto base_ptr = segment.allocator->GetDataPointer(append_state.current_chunk_state, current_segment.block_id,
-		                                                  current_segment.offset);
-		auto validity_data = ColumnDataCollectionSegment::GetValidityPointerForWriting(base_ptr, OP::TypeSize());
-
-		ValidityMask result_validity(validity_data, STANDARD_VECTOR_SIZE);
-		if (current_segment.count == 0) {
-			// first time appending to this vector
-			// all data here is still uninitialized
-			// initialize the validity mask to set all to valid
-			result_validity.SetAllValid(STANDARD_VECTOR_SIZE);
-		}
-		for (idx_t i = 0; i < append_count; i++) {
-			auto source_idx = source_data.sel->get_index(offset + i);
-			if (source_data.validity.RowIsValid(source_idx)) {
-				OP::template Assign<OP>(meta_data, base_ptr, source_data.data, current_segment.count + i, source_idx);
-			} else {
-				result_validity.SetInvalid(current_segment.count + i);
-			}
-		}
-		current_segment.count += append_count;
-		offset += append_count;
-		remaining -= append_count;
-		if (remaining > 0) {
-			// need to append more, check if we need to allocate a new vector or not
-			if (!current_segment.next_data.IsValid()) {
-				segment.AllocateVector(source.GetType(), meta_data.chunk_data, append_state, current_index);
-			}
-			D_ASSERT(segment.GetVectorData(current_index).next_data.IsValid());
-			current_index = segment.GetVectorData(current_index).next_data;
-		}
-	}
-}
-
-template <class T>
-static void ColumnDataCopy(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
-                           idx_t offset, idx_t copy_count) {
-	TemplatedColumnDataCopy<StandardValueCopy<T>>(meta_data, source_data, source, offset, copy_count);
-}
-
-template <>
-void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
-                              idx_t offset, idx_t copy_count) {
-
-	const auto &allocator_type = meta_data.segment.allocator->GetType();
-	if (allocator_type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR ||
-	    allocator_type == ColumnDataAllocatorType::HYBRID) {
-		// strings cannot be spilled to disk - use StringHeap
-		TemplatedColumnDataCopy<StringValueCopy>(meta_data, source_data, source, offset, copy_count);
-		return;
-	}
-	D_ASSERT(allocator_type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
-
-	auto &segment = meta_data.segment;
-	auto &append_state = meta_data.state;
-
-	VectorDataIndex child_index;
-	if (meta_data.GetVectorMetaData().child_index.IsValid()) {
-		// find the last child index
-		child_index = segment.GetChildIndex(meta_data.GetVectorMetaData().child_index);
-		auto next_child_index = segment.GetVectorData(child_index).next_data;
-		while (next_child_index.IsValid()) {
-			child_index = next_child_index;
-			next_child_index = segment.GetVectorData(child_index).next_data;
-		}
-	}
-
-	auto current_index = meta_data.vector_data_index;
-	idx_t remaining = copy_count;
-	auto block_size = meta_data.segment.allocator->GetBufferManager().GetBlockSize();
-	while (remaining > 0) {
-		// how many values fit in the current string vector
-		idx_t vector_remaining =
-		    MinValue<idx_t>(STANDARD_VECTOR_SIZE - segment.GetVectorData(current_index).count, remaining);
-
-		// 'append_count' is less if we cannot fit that amount of non-inlined strings on one buffer-managed block
-		idx_t append_count;
-		idx_t heap_size = 0;
-		const auto source_entries = UnifiedVectorFormat::GetData<string_t>(source_data);
-		for (append_count = 0; append_count < vector_remaining; append_count++) {
-			auto source_idx = source_data.sel->get_index(offset + append_count);
-			if (!source_data.validity.RowIsValid(source_idx)) {
-				continue;
-			}
-			const auto &entry = source_entries[source_idx];
-			if (entry.IsInlined()) {
-				continue;
-			}
-			if (heap_size + entry.GetSize() > block_size) {
-				break;
-			}
-			heap_size += entry.GetSize();
-		}
-
-		if (vector_remaining != 0 && append_count == 0) {
-			// The string exceeds Storage::DEFAULT_BLOCK_SIZE, so we allocate one block at a time for long strings.
-			auto source_idx = source_data.sel->get_index(offset + append_count);
-			D_ASSERT(source_data.validity.RowIsValid(source_idx));
-			D_ASSERT(!source_entries[source_idx].IsInlined());
-			D_ASSERT(source_entries[source_idx].GetSize() > block_size);
-			heap_size += source_entries[source_idx].GetSize();
-			append_count++;
-		}
-
-		// allocate string heap for the next 'append_count' strings
-		data_ptr_t heap_ptr = nullptr;
-		if (heap_size != 0) {
-			child_index = segment.AllocateStringHeap(heap_size, meta_data.chunk_data, append_state, child_index);
-			if (!meta_data.GetVectorMetaData().child_index.IsValid()) {
-				meta_data.GetVectorMetaData().child_index = meta_data.segment.AddChildIndex(child_index);
-			}
-			auto &child_segment = segment.GetVectorData(child_index);
-			heap_ptr = segment.allocator->GetDataPointer(append_state.current_chunk_state, child_segment.block_id,
-			                                             child_segment.offset);
-		}
-
-		auto &current_segment = segment.GetVectorData(current_index);
-		auto base_ptr = segment.allocator->GetDataPointer(append_state.current_chunk_state, current_segment.block_id,
-		                                                  current_segment.offset);
-		auto validity_data = ColumnDataCollectionSegment::GetValidityPointerForWriting(base_ptr, sizeof(string_t));
-		ValidityMask target_validity(validity_data, STANDARD_VECTOR_SIZE);
-		if (current_segment.count == 0) {
-			// first time appending to this vector
-			// all data here is still uninitialized
-			// initialize the validity mask to set all to valid
-			target_validity.SetAllValid(STANDARD_VECTOR_SIZE);
-		}
-
-		auto target_entries = reinterpret_cast<string_t *>(base_ptr);
-		for (idx_t i = 0; i < append_count; i++) {
-			auto source_idx = source_data.sel->get_index(offset + i);
-			auto target_idx = current_segment.count + i;
-			if (!source_data.validity.RowIsValid(source_idx)) {
-				target_validity.SetInvalid(target_idx);
-				continue;
-			}
-			const auto &source_entry = source_entries[source_idx];
-			auto &target_entry = target_entries[target_idx];
-			if (source_entry.IsInlined()) {
-				target_entry = source_entry;
-			} else {
-				D_ASSERT(heap_ptr != nullptr);
-				memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize());
-				target_entry =
-				    string_t(const_char_ptr_cast(heap_ptr), UnsafeNumericCast<uint32_t>(source_entry.GetSize()));
-				heap_ptr += source_entry.GetSize();
-			}
-		}
-
-		if (heap_size != 0) {
-			current_segment.swizzle_data.emplace_back(child_index, current_segment.count, append_count);
-		}
-
-		current_segment.count += append_count;
-		offset += append_count;
-		remaining -= append_count;
-
-		if (vector_remaining - append_count == 0) {
-			// need to append more, check if we need to allocate a new vector or not
-			if (!current_segment.next_data.IsValid()) {
-				segment.AllocateVector(source.GetType(), meta_data.chunk_data, append_state, current_index);
-			}
-			D_ASSERT(segment.GetVectorData(current_index).next_data.IsValid());
-			current_index = segment.GetVectorData(current_index).next_data;
-		}
-	}
-}
-
-template <>
-void ColumnDataCopy<list_entry_t>(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
-                                  idx_t offset, idx_t copy_count) {
-
-	auto &segment = meta_data.segment;
-
-	auto &child_vector = ListVector::GetEntry(source);
-	auto &child_type = child_vector.GetType();
-
-	if (!meta_data.GetVectorMetaData().child_index.IsValid()) {
-		auto child_index = segment.AllocateVector(child_type, meta_data.chunk_data, meta_data.state);
-		meta_data.GetVectorMetaData().child_index = meta_data.segment.AddChildIndex(child_index);
-	}
-
-	auto &child_function = meta_data.copy_function.child_functions[0];
-	auto child_index = segment.GetChildIndex(meta_data.GetVectorMetaData().child_index);
-
-	// figure out the current list size by traversing the set of child entries
-	idx_t current_list_size = 0;
-	auto current_child_index = child_index;
-	while (current_child_index.IsValid()) {
-		auto &child_vdata = segment.GetVectorData(current_child_index);
-		current_list_size += child_vdata.count;
-		current_child_index = child_vdata.next_data;
-	}
-
-	// set the child vector
-	UnifiedVectorFormat child_vector_data;
-	ColumnDataMetaData child_meta_data(child_function, meta_data, child_index);
-	auto info = ListVector::GetConsecutiveChildListInfo(source, offset, copy_count);
-
-	if (info.needs_slicing) {
-		SelectionVector sel(info.child_list_info.length);
-		ListVector::GetConsecutiveChildSelVector(source, sel, offset, copy_count);
-
-		auto sliced_child_vector = Vector(child_vector, sel, info.child_list_info.length);
-		sliced_child_vector.Flatten(info.child_list_info.length);
-		info.child_list_info.offset = 0;
-
-		sliced_child_vector.ToUnifiedFormat(info.child_list_info.length, child_vector_data);
-		child_function.function(child_meta_data, child_vector_data, sliced_child_vector, info.child_list_info.offset,
-		                        info.child_list_info.length);
-
-	} else {
-		child_vector.ToUnifiedFormat(info.child_list_info.length, child_vector_data);
-		child_function.function(child_meta_data, child_vector_data, child_vector, info.child_list_info.offset,
-		                        info.child_list_info.length);
-	}
-
-	// now copy the list entries
-	meta_data.child_list_size = current_list_size;
-	if (info.is_constant) {
-		TemplatedColumnDataCopy<ConstListValueCopy>(meta_data, source_data, source, offset, copy_count);
-	} else {
-		TemplatedColumnDataCopy<ListValueCopy>(meta_data, source_data, source, offset, copy_count);
-	}
-}
-
-void ColumnDataCopyStruct(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
-                          idx_t offset, idx_t copy_count) {
-	auto &segment = meta_data.segment;
-
-	// copy the NULL values for the main struct vector
-	TemplatedColumnDataCopy<StructValueCopy>(meta_data, source_data, source, offset, copy_count);
-
-	auto &child_types = StructType::GetChildTypes(source.GetType());
-	// now copy all the child vectors
-	D_ASSERT(meta_data.GetVectorMetaData().child_index.IsValid());
-	auto &child_vectors = StructVector::GetEntries(source);
-	for (idx_t child_idx = 0; child_idx < child_types.size(); child_idx++) {
-		auto &child_function = meta_data.copy_function.child_functions[child_idx];
-		auto child_index = segment.GetChildIndex(meta_data.GetVectorMetaData().child_index, child_idx);
-		ColumnDataMetaData child_meta_data(child_function, meta_data, child_index);
-
-		UnifiedVectorFormat child_data;
-		child_vectors[child_idx]->ToUnifiedFormat(copy_count, child_data);
-
-		child_function.function(child_meta_data, child_data, *child_vectors[child_idx], offset, copy_count);
-	}
-}
-
-void ColumnDataCopyArray(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
-                         idx_t offset, idx_t copy_count) {
-
-	auto &segment = meta_data.segment;
-
-	// copy the NULL values for the main array vector (the same as for a struct vector)
-	TemplatedColumnDataCopy<StructValueCopy>(meta_data, source_data, source, offset, copy_count);
-
-	auto &child_vector = ArrayVector::GetEntry(source);
-	auto &child_type = child_vector.GetType();
-	auto array_size = ArrayType::GetSize(source.GetType());
-
-	if (!meta_data.GetVectorMetaData().child_index.IsValid()) {
-		auto child_index = segment.AllocateVector(child_type, meta_data.chunk_data, meta_data.state);
-		meta_data.GetVectorMetaData().child_index = meta_data.segment.AddChildIndex(child_index);
-	}
-
-	auto &child_function = meta_data.copy_function.child_functions[0];
-	auto child_index = segment.GetChildIndex(meta_data.GetVectorMetaData().child_index);
-
-	auto current_child_index = child_index;
-	while (current_child_index.IsValid()) {
-		auto &child_vdata = segment.GetVectorData(current_child_index);
-		current_child_index = child_vdata.next_data;
-	}
-
-	UnifiedVectorFormat child_vector_data;
-	ColumnDataMetaData child_meta_data(child_function, meta_data, child_index);
-	child_vector.ToUnifiedFormat(copy_count * array_size, child_vector_data);
-
-	// Broadcast and sync the validity of the array vector to the child vector
-
-	if (source_data.validity.IsMaskSet()) {
-		for (idx_t i = 0; i < copy_count; i++) {
-			auto source_idx = source_data.sel->get_index(offset + i);
-			if (!source_data.validity.RowIsValid(source_idx)) {
-				for (idx_t j = 0; j < array_size; j++) {
-					child_vector_data.validity.SetInvalid(source_idx * array_size + j);
-				}
-			}
-		}
-	}
-
-	auto is_constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	// If the array is constant, we need to copy the child vector n times
-	if (is_constant) {
-		for (idx_t i = 0; i < copy_count; i++) {
-			child_function.function(child_meta_data, child_vector_data, child_vector, 0, array_size);
-		}
-	} else {
-		child_function.function(child_meta_data, child_vector_data, child_vector, offset * array_size,
-		                        copy_count * array_size);
-	}
-}
-
-ColumnDataCopyFunction ColumnDataCollection::GetCopyFunction(const LogicalType &type) {
-	ColumnDataCopyFunction result;
-	column_data_copy_function_t function;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		function = ColumnDataCopy<bool>;
-		break;
-	case PhysicalType::INT8:
-		function = ColumnDataCopy<int8_t>;
-		break;
-	case PhysicalType::INT16:
-		function = ColumnDataCopy<int16_t>;
-		break;
-	case PhysicalType::INT32:
-		function = ColumnDataCopy<int32_t>;
-		break;
-	case PhysicalType::INT64:
-		function = ColumnDataCopy<int64_t>;
-		break;
-	case PhysicalType::INT128:
-		function = ColumnDataCopy<hugeint_t>;
-		break;
-	case PhysicalType::UINT8:
-		function = ColumnDataCopy<uint8_t>;
-		break;
-	case PhysicalType::UINT16:
-		function = ColumnDataCopy<uint16_t>;
-		break;
-	case PhysicalType::UINT32:
-		function = ColumnDataCopy<uint32_t>;
-		break;
-	case PhysicalType::UINT64:
-		function = ColumnDataCopy<uint64_t>;
-		break;
-	case PhysicalType::UINT128:
-		function = ColumnDataCopy<uhugeint_t>;
-		break;
-	case PhysicalType::FLOAT:
-		function = ColumnDataCopy<float>;
-		break;
-	case PhysicalType::DOUBLE:
-		function = ColumnDataCopy<double>;
-		break;
-	case PhysicalType::INTERVAL:
-		function = ColumnDataCopy<interval_t>;
-		break;
-	case PhysicalType::VARCHAR:
-		function = ColumnDataCopy<string_t>;
-		break;
-	case PhysicalType::STRUCT: {
-		function = ColumnDataCopyStruct;
-		auto &child_types = StructType::GetChildTypes(type);
-		for (auto &kv : child_types) {
-			result.child_functions.push_back(GetCopyFunction(kv.second));
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		function = ColumnDataCopy<list_entry_t>;
-		auto child_function = GetCopyFunction(ListType::GetChildType(type));
-		result.child_functions.push_back(child_function);
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		function = ColumnDataCopyArray;
-		auto child_function = GetCopyFunction(ArrayType::GetChildType(type));
-		result.child_functions.push_back(child_function);
-		break;
-	}
-	default:
-		throw InternalException("Unsupported type %s for ColumnDataCollection::GetCopyFunction",
-		                        EnumUtil::ToString(type.InternalType()));
-	}
-	result.function = function;
-	return result;
-}
-
-static bool IsComplexType(const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-	case PhysicalType::ARRAY:
-		return true;
-	default:
-		return false;
-	};
-}
-
-void ColumnDataCollection::Append(ColumnDataAppendState &state, DataChunk &input) {
-	D_ASSERT(!finished_append);
-	D_ASSERT(types == input.GetTypes());
-
-	auto &segment = *segments.back();
-	for (idx_t vector_idx = 0; vector_idx < types.size(); vector_idx++) {
-		if (IsComplexType(input.data[vector_idx].GetType())) {
-			input.data[vector_idx].Flatten(input.size());
-		}
-		input.data[vector_idx].ToUnifiedFormat(input.size(), state.vector_data[vector_idx]);
-	}
-
-	idx_t remaining = input.size();
-	while (remaining > 0) {
-		auto &chunk_data = segment.chunk_data.back();
-		idx_t append_amount = MinValue<idx_t>(remaining, STANDARD_VECTOR_SIZE - chunk_data.count);
-		if (append_amount > 0) {
-			idx_t offset = input.size() - remaining;
-			for (idx_t vector_idx = 0; vector_idx < types.size(); vector_idx++) {
-				ColumnDataMetaData meta_data(copy_functions[vector_idx], segment, state, chunk_data,
-				                             chunk_data.vector_data[vector_idx]);
-				copy_functions[vector_idx].function(meta_data, state.vector_data[vector_idx], input.data[vector_idx],
-				                                    offset, append_amount);
-			}
-			chunk_data.count += append_amount;
-		}
-		remaining -= append_amount;
-		if (remaining > 0) {
-			// more to do
-			// allocate a new chunk
-			segment.AllocateNewChunk();
-			segment.InitializeChunkState(segment.chunk_data.size() - 1, state.current_chunk_state);
-		}
-	}
-	segment.count += input.size();
-	count += input.size();
-}
-
-void ColumnDataCollection::Append(DataChunk &input) {
-	ColumnDataAppendState state;
-	InitializeAppend(state);
-	Append(state, input);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void ColumnDataCollection::InitializeScan(ColumnDataScanState &state, ColumnDataScanProperties properties) const {
-	vector<column_t> column_ids;
-	column_ids.reserve(types.size());
-	for (idx_t i = 0; i < types.size(); i++) {
-		column_ids.push_back(i);
-	}
-	InitializeScan(state, std::move(column_ids), properties);
-}
-
-void ColumnDataCollection::InitializeScan(ColumnDataScanState &state, vector<column_t> column_ids,
-                                          ColumnDataScanProperties properties) const {
-	state.chunk_index = 0;
-	state.segment_index = 0;
-	state.current_row_index = 0;
-	state.next_row_index = 0;
-	state.current_chunk_state.handles.clear();
-	state.properties = properties;
-	state.column_ids = std::move(column_ids);
-}
-
-void ColumnDataCollection::InitializeScan(ColumnDataParallelScanState &state,
-                                          ColumnDataScanProperties properties) const {
-	InitializeScan(state.scan_state, properties);
-}
-
-void ColumnDataCollection::InitializeScan(ColumnDataParallelScanState &state, vector<column_t> column_ids,
-                                          ColumnDataScanProperties properties) const {
-	InitializeScan(state.scan_state, std::move(column_ids), properties);
-}
-
-bool ColumnDataCollection::Scan(ColumnDataParallelScanState &state, ColumnDataLocalScanState &lstate,
-                                DataChunk &result) const {
-	result.Reset();
-
-	idx_t chunk_index;
-	idx_t segment_index;
-	idx_t row_index;
-	{
-		lock_guard<mutex> l(state.lock);
-		if (!NextScanIndex(state.scan_state, chunk_index, segment_index, row_index)) {
-			return false;
-		}
-	}
-	ScanAtIndex(state, lstate, result, chunk_index, segment_index, row_index);
-	return true;
-}
-
-void ColumnDataCollection::InitializeScanChunk(DataChunk &chunk) const {
-	chunk.Initialize(allocator->GetAllocator(), types);
-}
-
-void ColumnDataCollection::InitializeScanChunk(ColumnDataScanState &state, DataChunk &chunk) const {
-	D_ASSERT(!state.column_ids.empty());
-	vector<LogicalType> chunk_types;
-	chunk_types.reserve(state.column_ids.size());
-	for (idx_t i = 0; i < state.column_ids.size(); i++) {
-		auto column_idx = state.column_ids[i];
-		D_ASSERT(column_idx < types.size());
-		chunk_types.push_back(types[column_idx]);
-	}
-	chunk.Initialize(allocator->GetAllocator(), chunk_types);
-}
-
-bool ColumnDataCollection::NextScanIndex(ColumnDataScanState &state, idx_t &chunk_index, idx_t &segment_index,
-                                         idx_t &row_index) const {
-	row_index = state.current_row_index = state.next_row_index;
-	// check if we still have collections to scan
-	if (state.segment_index >= segments.size()) {
-		// no more data left in the scan
-		return false;
-	}
-	// check within the current collection if we still have chunks to scan
-	while (state.chunk_index >= segments[state.segment_index]->chunk_data.size()) {
-		// exhausted all chunks for this internal data structure: move to the next one
-		state.chunk_index = 0;
-		state.segment_index++;
-		state.current_chunk_state.handles.clear();
-		if (state.segment_index >= segments.size()) {
-			return false;
-		}
-	}
-	state.next_row_index += segments[state.segment_index]->chunk_data[state.chunk_index].count;
-	segment_index = state.segment_index;
-	chunk_index = state.chunk_index++;
-	return true;
-}
-
-bool ColumnDataCollection::PrevScanIndex(ColumnDataScanState &state, idx_t &chunk_index, idx_t &segment_index,
-                                         idx_t &row_index) const {
-	// check within the current segment if we still have chunks to scan
-	// Note that state.chunk_index is 1-indexed, with 0 as undefined.
-	while (state.chunk_index <= 1) {
-		if (!state.segment_index) {
-			return false;
-		}
-
-		--state.segment_index;
-		state.chunk_index = segments[state.segment_index]->chunk_data.size() + 1;
-		state.current_chunk_state.handles.clear();
-	}
-
-	--state.chunk_index;
-	segment_index = state.segment_index;
-	chunk_index = state.chunk_index - 1;
-	state.next_row_index = state.current_row_index;
-	state.current_row_index -= segments[state.segment_index]->chunk_data[chunk_index].count;
-	row_index = state.current_row_index;
-	return true;
-}
-
-void ColumnDataCollection::ScanAtIndex(ColumnDataParallelScanState &state, ColumnDataLocalScanState &lstate,
-                                       DataChunk &result, idx_t chunk_index, idx_t segment_index,
-                                       idx_t row_index) const {
-	if (segment_index != lstate.current_segment_index) {
-		lstate.current_chunk_state.handles.clear();
-		lstate.current_segment_index = segment_index;
-	}
-	auto &segment = *segments[segment_index];
-	lstate.current_chunk_state.properties = state.scan_state.properties;
-	segment.ReadChunk(chunk_index, lstate.current_chunk_state, result, state.scan_state.column_ids);
-	lstate.current_row_index = row_index;
-	result.Verify();
-}
-
-bool ColumnDataCollection::Scan(ColumnDataScanState &state, DataChunk &result) const {
-	result.Reset();
-
-	idx_t chunk_index;
-	idx_t segment_index;
-	idx_t row_index;
-	if (!NextScanIndex(state, chunk_index, segment_index, row_index)) {
-		return false;
-	}
-
-	// found a chunk to scan -> scan it
-	auto &segment = *segments[segment_index];
-	state.current_chunk_state.properties = state.properties;
-	segment.ReadChunk(chunk_index, state.current_chunk_state, result, state.column_ids);
-	result.Verify();
-	return true;
-}
-
-bool ColumnDataCollection::Seek(idx_t seek_idx, ColumnDataScanState &state, DataChunk &result) const {
-	//	Idempotency: Don't change anything if the row is already in range
-	if (state.current_row_index <= seek_idx && seek_idx < state.next_row_index) {
-		return true;
-	}
-
-	result.Reset();
-
-	//	Linear scan for now. We could use a current_row_index => chunk map at some point
-	//	but most use cases should be pretty local
-	idx_t chunk_index;
-	idx_t segment_index;
-	idx_t row_index;
-	while (seek_idx < state.current_row_index) {
-		if (!PrevScanIndex(state, chunk_index, segment_index, row_index)) {
-			return false;
-		}
-	}
-	while (state.next_row_index <= seek_idx) {
-		if (!NextScanIndex(state, chunk_index, segment_index, row_index)) {
-			return false;
-		}
-	}
-
-	// found a chunk to scan -> scan it
-	auto &segment = *segments[segment_index];
-	state.current_chunk_state.properties = state.properties;
-	segment.ReadChunk(chunk_index, state.current_chunk_state, result, state.column_ids);
-	result.Verify();
-	return true;
-}
-
-ColumnDataRowCollection ColumnDataCollection::GetRows() const {
-	return ColumnDataRowCollection(*this);
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-void ColumnDataCollection::Combine(ColumnDataCollection &other) {
-	if (other.count == 0) {
-		return;
-	}
-	if (types != other.types) {
-		throw InternalException("Attempting to combine ColumnDataCollections with mismatching types");
-	}
-	this->count += other.count;
-	this->segments.reserve(segments.size() + other.segments.size());
-	for (auto &other_seg : other.segments) {
-		segments.push_back(std::move(other_seg));
-	}
-	other.Reset();
-	Verify();
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-idx_t ColumnDataCollection::ChunkCount() const {
-	idx_t chunk_count = 0;
-	for (auto &segment : segments) {
-		chunk_count += segment->ChunkCount();
-	}
-	return chunk_count;
-}
-
-void ColumnDataCollection::FetchChunk(idx_t chunk_idx, DataChunk &result) const {
-	D_ASSERT(chunk_idx < ChunkCount());
-	for (auto &segment : segments) {
-		if (chunk_idx >= segment->ChunkCount()) {
-			chunk_idx -= segment->ChunkCount();
-		} else {
-			segment->FetchChunk(chunk_idx, result);
-			return;
-		}
-	}
-	throw InternalException("Failed to find chunk in ColumnDataCollection");
-}
-
-//===--------------------------------------------------------------------===//
-// Helpers
-//===--------------------------------------------------------------------===//
-void ColumnDataCollection::Verify() {
-#ifdef DEBUG
-	// verify counts
-	idx_t total_segment_count = 0;
-	for (auto &segment : segments) {
-		segment->Verify();
-		total_segment_count += segment->count;
-	}
-	D_ASSERT(total_segment_count == this->count);
-#endif
-}
-
-// LCOV_EXCL_START
-string ColumnDataCollection::ToString() const {
-	DataChunk chunk;
-	InitializeScanChunk(chunk);
-
-	ColumnDataScanState scan_state;
-	InitializeScan(scan_state);
-
-	string result = StringUtil::Format("ColumnDataCollection - [%llu Chunks, %llu Rows]\n", ChunkCount(), Count());
-	idx_t chunk_idx = 0;
-	idx_t row_count = 0;
-	while (Scan(scan_state, chunk)) {
-		result +=
-		    StringUtil::Format("Chunk %llu - [Rows %llu - %llu]\n", chunk_idx, row_count, row_count + chunk.size()) +
-		    chunk.ToString();
-		chunk_idx++;
-		row_count += chunk.size();
-	}
-
-	return result;
-}
-// LCOV_EXCL_STOP
-
-void ColumnDataCollection::Print() const {
-	Printer::Print(ToString());
-}
-
-void ColumnDataCollection::Reset() {
-	count = 0;
-	segments.clear();
-
-	// Refreshes the ColumnDataAllocator to prevent holding on to allocated data unnecessarily
-	allocator = make_shared_ptr<ColumnDataAllocator>(*allocator);
-}
-
-struct ValueResultEquals {
-	bool operator()(const Value &a, const Value &b) const {
-		return Value::DefaultValuesAreEqual(a, b);
-	}
-};
-
-bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const ColumnDataCollection &right,
-                                        string &error_message, bool ordered) {
-	if (left.ColumnCount() != right.ColumnCount()) {
-		error_message = "Column count mismatch";
-		return false;
-	}
-	if (left.Count() != right.Count()) {
-		error_message = "Row count mismatch";
-		return false;
-	}
-	auto left_rows = left.GetRows();
-	auto right_rows = right.GetRows();
-	for (idx_t r = 0; r < left.Count(); r++) {
-		for (idx_t c = 0; c < left.ColumnCount(); c++) {
-			auto lvalue = left_rows.GetValue(c, r);
-			auto rvalue = right_rows.GetValue(c, r);
-
-			if (!Value::DefaultValuesAreEqual(lvalue, rvalue)) {
-				error_message =
-				    StringUtil::Format("%s <> %s (row: %lld, col: %lld)\n", lvalue.ToString(), rvalue.ToString(), r, c);
-				break;
-			}
-		}
-		if (!error_message.empty()) {
-			if (ordered) {
-				return false;
-			} else {
-				break;
-			}
-		}
-	}
-	if (!error_message.empty()) {
-		// do an unordered comparison
-		bool found_all = true;
-		for (idx_t c = 0; c < left.ColumnCount(); c++) {
-			std::unordered_multiset<Value, ValueHashFunction, ValueResultEquals> lvalues;
-			for (idx_t r = 0; r < left.Count(); r++) {
-				auto lvalue = left_rows.GetValue(c, r);
-				lvalues.insert(lvalue);
-			}
-			for (idx_t r = 0; r < right.Count(); r++) {
-				auto rvalue = right_rows.GetValue(c, r);
-				auto entry = lvalues.find(rvalue);
-				if (entry == lvalues.end()) {
-					found_all = false;
-					break;
-				}
-				lvalues.erase(entry);
-			}
-			if (!found_all) {
-				break;
-			}
-		}
-		if (!found_all) {
-			return false;
-		}
-		error_message = string();
-	}
-	return true;
-}
-
-vector<shared_ptr<StringHeap>> ColumnDataCollection::GetHeapReferences() {
-	vector<shared_ptr<StringHeap>> result(segments.size(), nullptr);
-	for (idx_t segment_idx = 0; segment_idx < segments.size(); segment_idx++) {
-		result[segment_idx] = segments[segment_idx]->heap;
-	}
-	return result;
-}
-
-ColumnDataAllocatorType ColumnDataCollection::GetAllocatorType() const {
-	return allocator->GetType();
-}
-
-const vector<unique_ptr<ColumnDataCollectionSegment>> &ColumnDataCollection::GetSegments() const {
-	return segments;
-}
-
-void ColumnDataCollection::Serialize(Serializer &serializer) const {
-	vector<vector<Value>> values;
-	values.resize(ColumnCount());
-	for (auto &chunk : Chunks()) {
-		for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-			for (idx_t r = 0; r < chunk.size(); r++) {
-				values[c].push_back(chunk.GetValue(c, r));
-			}
-		}
-	}
-	serializer.WriteProperty(100, "types", types);
-	serializer.WriteProperty(101, "values", values);
-}
-
-unique_ptr<ColumnDataCollection> ColumnDataCollection::Deserialize(Deserializer &deserializer) {
-	auto types = deserializer.ReadProperty<vector<LogicalType>>(100, "types");
-	auto values = deserializer.ReadProperty<vector<vector<Value>>>(101, "values");
-
-	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
-	if (values.empty()) {
-		return collection;
-	}
-	DataChunk chunk;
-	chunk.Initialize(Allocator::DefaultAllocator(), types);
-
-	for (idx_t r = 0; r < values[0].size(); r++) {
-		for (idx_t c = 0; c < types.size(); c++) {
-			chunk.SetValue(c, chunk.size(), values[c][r]);
-		}
-		chunk.SetCardinality(chunk.size() + 1);
-		if (chunk.size() == STANDARD_VECTOR_SIZE) {
-			collection->Append(chunk);
-			chunk.Reset();
-		}
-	}
-	if (chunk.size() > 0) {
-		collection->Append(chunk);
-	}
-	return collection;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/column/column_data_collection_segment.cpp b/src/duckdb/src/common/types/column/column_data_collection_segment.cpp
deleted file mode 100644
index 1ec0f6f45..000000000
--- a/src/duckdb/src/common/types/column/column_data_collection_segment.cpp
+++ /dev/null
@@ -1,309 +0,0 @@
-#include "duckdb/common/types/column/column_data_collection_segment.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-ColumnDataCollectionSegment::ColumnDataCollectionSegment(shared_ptr<ColumnDataAllocator> allocator_p,
-                                                         vector<LogicalType> types_p)
-    : allocator(std::move(allocator_p)), types(std::move(types_p)), count(0),
-      heap(make_shared_ptr<StringHeap>(allocator->GetAllocator())) {
-}
-
-idx_t ColumnDataCollectionSegment::GetDataSize(idx_t type_size) {
-	return AlignValue(type_size * STANDARD_VECTOR_SIZE);
-}
-
-validity_t *ColumnDataCollectionSegment::GetValidityPointerForWriting(data_ptr_t base_ptr, idx_t type_size) {
-	return reinterpret_cast<validity_t *>(base_ptr + GetDataSize(type_size));
-}
-
-validity_t *ColumnDataCollectionSegment::GetValidityPointer(data_ptr_t base_ptr, idx_t type_size, idx_t count) {
-	auto validity_mask = reinterpret_cast<validity_t *>(base_ptr + GetDataSize(type_size));
-
-	// Optimized check to see if all entries are valid
-	for (idx_t i = 0; i < (count / ValidityMask::BITS_PER_VALUE); i++) {
-		if (!ValidityMask::AllValid(validity_mask[i])) {
-			return validity_mask;
-		}
-	}
-
-	if ((count % ValidityMask::BITS_PER_VALUE) != 0) {
-		// Create a mask with the lower `bits_to_check` bits set to 1
-		validity_t mask = (1ULL << (count % ValidityMask::BITS_PER_VALUE)) - 1;
-		if ((validity_mask[(count / ValidityMask::BITS_PER_VALUE)] & mask) != mask) {
-			return validity_mask;
-		}
-	}
-	// All entries are valid, no need to initialize the validity mask
-	return nullptr;
-}
-
-VectorDataIndex ColumnDataCollectionSegment::AllocateVectorInternal(const LogicalType &type, ChunkMetaData &chunk_meta,
-                                                                    ChunkManagementState *chunk_state) {
-	VectorMetaData meta_data;
-	meta_data.count = 0;
-
-	auto internal_type = type.InternalType();
-	auto struct_or_array = internal_type == PhysicalType::STRUCT || internal_type == PhysicalType::ARRAY;
-	auto type_size = struct_or_array ? 0 : GetTypeIdSize(internal_type);
-
-	allocator->AllocateData(GetDataSize(type_size) + ValidityMask::STANDARD_MASK_SIZE, meta_data.block_id,
-	                        meta_data.offset, chunk_state);
-	if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR ||
-	    allocator->GetType() == ColumnDataAllocatorType::HYBRID) {
-		chunk_meta.block_ids.insert(meta_data.block_id);
-	}
-
-	auto index = vector_data.size();
-	vector_data.push_back(meta_data);
-	return VectorDataIndex(index);
-}
-
-VectorDataIndex ColumnDataCollectionSegment::AllocateVector(const LogicalType &type, ChunkMetaData &chunk_meta,
-                                                            ChunkManagementState *chunk_state,
-                                                            VectorDataIndex prev_index) {
-	auto index = AllocateVectorInternal(type, chunk_meta, chunk_state);
-	if (prev_index.IsValid()) {
-		GetVectorData(prev_index).next_data = index;
-	}
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		// initialize the struct children
-		auto &child_types = StructType::GetChildTypes(type);
-		auto base_child_index = ReserveChildren(child_types.size());
-		for (idx_t child_idx = 0; child_idx < child_types.size(); child_idx++) {
-			VectorDataIndex prev_child_index;
-			if (prev_index.IsValid()) {
-				prev_child_index = GetChildIndex(GetVectorData(prev_index).child_index, child_idx);
-			}
-			auto child_index = AllocateVector(child_types[child_idx].second, chunk_meta, chunk_state, prev_child_index);
-			SetChildIndex(base_child_index, child_idx, child_index);
-		}
-		GetVectorData(index).child_index = base_child_index;
-	}
-	return index;
-}
-
-VectorDataIndex ColumnDataCollectionSegment::AllocateVector(const LogicalType &type, ChunkMetaData &chunk_meta,
-                                                            ColumnDataAppendState &append_state,
-                                                            VectorDataIndex prev_index) {
-	return AllocateVector(type, chunk_meta, &append_state.current_chunk_state, prev_index);
-}
-
-VectorDataIndex ColumnDataCollectionSegment::AllocateStringHeap(idx_t size, ChunkMetaData &chunk_meta,
-                                                                ColumnDataAppendState &append_state,
-                                                                VectorDataIndex prev_index) {
-	D_ASSERT(allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
-	D_ASSERT(size != 0);
-
-	VectorMetaData meta_data;
-	meta_data.count = 0;
-	allocator->AllocateData(AlignValue(size), meta_data.block_id, meta_data.offset, &append_state.current_chunk_state);
-	chunk_meta.block_ids.insert(meta_data.block_id);
-
-	VectorDataIndex index(vector_data.size());
-	vector_data.push_back(meta_data);
-
-	if (prev_index.IsValid()) {
-		GetVectorData(prev_index).next_data = index;
-	}
-
-	return index;
-}
-
-void ColumnDataCollectionSegment::AllocateNewChunk() {
-	ChunkMetaData meta_data;
-	meta_data.count = 0;
-	meta_data.vector_data.reserve(types.size());
-	for (idx_t i = 0; i < types.size(); i++) {
-		auto vector_idx = AllocateVector(types[i], meta_data);
-		meta_data.vector_data.push_back(vector_idx);
-	}
-	chunk_data.push_back(std::move(meta_data));
-}
-
-void ColumnDataCollectionSegment::InitializeChunkState(idx_t chunk_index, ChunkManagementState &state) {
-	auto &chunk = chunk_data[chunk_index];
-	allocator->InitializeChunkState(state, chunk);
-}
-
-VectorDataIndex ColumnDataCollectionSegment::GetChildIndex(VectorChildIndex index, idx_t child_entry) {
-	D_ASSERT(index.IsValid());
-	D_ASSERT(index.index + child_entry < child_indices.size());
-	return VectorDataIndex(child_indices[index.index + child_entry]);
-}
-
-VectorChildIndex ColumnDataCollectionSegment::AddChildIndex(VectorDataIndex index) {
-	auto result = child_indices.size();
-	child_indices.push_back(index);
-	return VectorChildIndex(result);
-}
-
-VectorChildIndex ColumnDataCollectionSegment::ReserveChildren(idx_t child_count) {
-	auto result = child_indices.size();
-	for (idx_t i = 0; i < child_count; i++) {
-		child_indices.emplace_back();
-	}
-	return VectorChildIndex(result);
-}
-
-void ColumnDataCollectionSegment::SetChildIndex(VectorChildIndex base_idx, idx_t child_number, VectorDataIndex index) {
-	D_ASSERT(base_idx.IsValid());
-	D_ASSERT(index.IsValid());
-	D_ASSERT(base_idx.index + child_number < child_indices.size());
-	child_indices[base_idx.index + child_number] = index;
-}
-
-idx_t ColumnDataCollectionSegment::ReadVectorInternal(ChunkManagementState &state, VectorDataIndex vector_index,
-                                                      Vector &result) {
-	auto &vector_type = result.GetType();
-	auto internal_type = vector_type.InternalType();
-	auto type_size = GetTypeIdSize(internal_type);
-	auto &vdata = GetVectorData(vector_index);
-
-	auto base_ptr = allocator->GetDataPointer(state, vdata.block_id, vdata.offset);
-	auto validity_data = GetValidityPointer(base_ptr, type_size, vdata.count);
-	if (!vdata.next_data.IsValid() && state.properties != ColumnDataScanProperties::DISALLOW_ZERO_COPY) {
-		// no next data, we can do a zero-copy read of this vector
-		FlatVector::SetData(result, base_ptr);
-		FlatVector::Validity(result).Initialize(validity_data, STANDARD_VECTOR_SIZE);
-		return vdata.count;
-	}
-
-	// the data for this vector is spread over multiple vector data entries
-	// we need to copy over the data for each of the vectors
-	// first figure out how many rows we need to copy by looping over all of the child vector indexes
-	idx_t vector_count = 0;
-	auto next_index = vector_index;
-	while (next_index.IsValid()) {
-		auto &current_vdata = GetVectorData(next_index);
-		vector_count += current_vdata.count;
-		next_index = current_vdata.next_data;
-	}
-	// resize the result vector
-	result.Resize(0, vector_count);
-	next_index = vector_index;
-	// now perform the copy of each of the vectors
-	auto target_data = FlatVector::GetData(result);
-	auto &target_validity = FlatVector::Validity(result);
-	idx_t current_offset = 0;
-	while (next_index.IsValid()) {
-		auto &current_vdata = GetVectorData(next_index);
-		base_ptr = allocator->GetDataPointer(state, current_vdata.block_id, current_vdata.offset);
-		validity_data = GetValidityPointer(base_ptr, type_size, current_vdata.count);
-		if (type_size > 0) {
-			memcpy(target_data + current_offset * type_size, base_ptr, current_vdata.count * type_size);
-		}
-		ValidityMask current_validity(validity_data, STANDARD_VECTOR_SIZE);
-		target_validity.SliceInPlace(current_validity, current_offset, 0, current_vdata.count);
-		current_offset += current_vdata.count;
-		next_index = current_vdata.next_data;
-	}
-	return vector_count;
-}
-
-idx_t ColumnDataCollectionSegment::ReadVector(ChunkManagementState &state, VectorDataIndex vector_index,
-                                              Vector &result) {
-	auto &vector_type = result.GetType();
-	auto internal_type = vector_type.InternalType();
-	auto &vdata = GetVectorData(vector_index);
-	if (vdata.count == 0) {
-		return 0;
-	}
-	auto vcount = ReadVectorInternal(state, vector_index, result);
-	if (internal_type == PhysicalType::LIST) {
-		// list: copy child
-		auto &child_vector = ListVector::GetEntry(result);
-		auto child_count = ReadVector(state, GetChildIndex(vdata.child_index), child_vector);
-		ListVector::SetListSize(result, child_count);
-	} else if (internal_type == PhysicalType::ARRAY) {
-		auto &child_vector = ArrayVector::GetEntry(result);
-		auto child_count = ReadVector(state, GetChildIndex(vdata.child_index), child_vector);
-		(void)child_count;
-	} else if (internal_type == PhysicalType::STRUCT) {
-		auto &child_vectors = StructVector::GetEntries(result);
-		for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
-			auto child_count =
-			    ReadVector(state, GetChildIndex(vdata.child_index, child_idx), *child_vectors[child_idx]);
-			if (child_count != vcount) {
-				throw InternalException("Column Data Collection: mismatch in struct child sizes");
-			}
-		}
-	} else if (internal_type == PhysicalType::VARCHAR) {
-		if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
-			auto next_index = vector_index;
-			idx_t offset = 0;
-			while (next_index.IsValid()) {
-				auto &current_vdata = GetVectorData(next_index);
-				for (auto &swizzle_segment : current_vdata.swizzle_data) {
-					auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
-					allocator->UnswizzlePointers(state, result, offset + swizzle_segment.offset, swizzle_segment.count,
-					                             string_heap_segment.block_id, string_heap_segment.offset);
-				}
-				offset += current_vdata.count;
-				next_index = current_vdata.next_data;
-			}
-		}
-		if (state.properties == ColumnDataScanProperties::DISALLOW_ZERO_COPY) {
-			VectorOperations::Copy(result, result, vdata.count, 0, 0);
-		}
-	}
-	return vcount;
-}
-
-void ColumnDataCollectionSegment::ReadChunk(idx_t chunk_index, ChunkManagementState &state, DataChunk &chunk,
-                                            const vector<column_t> &column_ids) {
-	D_ASSERT(chunk.ColumnCount() == column_ids.size());
-	D_ASSERT(state.properties != ColumnDataScanProperties::INVALID);
-	chunk.Reset();
-	InitializeChunkState(chunk_index, state);
-	auto &chunk_meta = chunk_data[chunk_index];
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto vector_idx = column_ids[i];
-		D_ASSERT(vector_idx < chunk_meta.vector_data.size());
-		ReadVector(state, chunk_meta.vector_data[vector_idx], chunk.data[i]);
-	}
-	chunk.SetCardinality(chunk_meta.count);
-}
-
-idx_t ColumnDataCollectionSegment::ChunkCount() const {
-	return chunk_data.size();
-}
-
-idx_t ColumnDataCollectionSegment::SizeInBytes() const {
-	D_ASSERT(!allocator->IsShared());
-	return allocator->SizeInBytes() + heap->SizeInBytes();
-}
-
-idx_t ColumnDataCollectionSegment::AllocationSize() const {
-	D_ASSERT(!allocator->IsShared());
-	return allocator->AllocationSize() + heap->AllocationSize();
-}
-
-void ColumnDataCollectionSegment::FetchChunk(idx_t chunk_idx, DataChunk &result) {
-	vector<column_t> column_ids;
-	column_ids.reserve(types.size());
-	for (idx_t i = 0; i < types.size(); i++) {
-		column_ids.push_back(i);
-	}
-	FetchChunk(chunk_idx, result, column_ids);
-}
-
-void ColumnDataCollectionSegment::FetchChunk(idx_t chunk_idx, DataChunk &result, const vector<column_t> &column_ids) {
-	D_ASSERT(chunk_idx < chunk_data.size());
-	ChunkManagementState state;
-	state.properties = ColumnDataScanProperties::DISALLOW_ZERO_COPY;
-	ReadChunk(chunk_idx, state, result, column_ids);
-}
-
-void ColumnDataCollectionSegment::Verify() {
-#ifdef DEBUG
-	idx_t total_count = 0;
-	for (idx_t i = 0; i < chunk_data.size(); i++) {
-		total_count += chunk_data[i].count;
-	}
-	D_ASSERT(total_count == this->count);
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/column/column_data_consumer.cpp b/src/duckdb/src/common/types/column/column_data_consumer.cpp
deleted file mode 100644
index fa20f1d5b..000000000
--- a/src/duckdb/src/common/types/column/column_data_consumer.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "duckdb/common/types/column/column_data_consumer.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-using ChunkReference = ColumnDataConsumer::ChunkReference;
-
-ChunkReference::ChunkReference(ColumnDataCollectionSegment *segment_p, uint32_t chunk_index_p)
-    : segment(segment_p), chunk_index_in_segment(chunk_index_p) {
-}
-
-uint32_t ChunkReference::GetMinimumBlockID() const {
-	const auto &block_ids = segment->chunk_data[chunk_index_in_segment].block_ids;
-	return *std::min_element(block_ids.begin(), block_ids.end());
-}
-
-ColumnDataConsumer::ColumnDataConsumer(ColumnDataCollection &collection_p, vector<column_t> column_ids)
-    : collection(collection_p), column_ids(std::move(column_ids)) {
-}
-
-void ColumnDataConsumer::InitializeScan() {
-	chunk_count = collection.ChunkCount();
-	current_chunk_index = 0;
-	chunk_delete_index = DConstants::INVALID_INDEX;
-
-	// Initialize chunk references and sort them, so we can scan them in a sane order, regardless of how it was created
-	chunk_references.reserve(chunk_count);
-	for (auto &segment : collection.GetSegments()) {
-		for (idx_t chunk_index = 0; chunk_index < segment->chunk_data.size(); chunk_index++) {
-			chunk_references.emplace_back(segment.get(), chunk_index);
-		}
-	}
-	std::sort(chunk_references.begin(), chunk_references.end());
-}
-
-bool ColumnDataConsumer::AssignChunk(ColumnDataConsumerScanState &state) {
-	lock_guard<mutex> guard(lock);
-	if (current_chunk_index == chunk_count) {
-		// All chunks have been assigned
-		state.current_chunk_state.handles.clear();
-		state.chunk_index = DConstants::INVALID_INDEX;
-		return false;
-	}
-	// Assign chunk index
-	state.chunk_index = current_chunk_index++;
-	D_ASSERT(chunks_in_progress.find(state.chunk_index) == chunks_in_progress.end());
-	chunks_in_progress.insert(state.chunk_index);
-	return true;
-}
-
-void ColumnDataConsumer::ScanChunk(ColumnDataConsumerScanState &state, DataChunk &chunk) const {
-	D_ASSERT(state.chunk_index < chunk_count);
-	auto &chunk_ref = chunk_references[state.chunk_index];
-	if (state.allocator != chunk_ref.segment->allocator.get()) {
-		// Previously scanned a chunk from a different allocator, reset the handles
-		state.allocator = chunk_ref.segment->allocator.get();
-		state.current_chunk_state.handles.clear();
-	}
-	chunk_ref.segment->ReadChunk(chunk_ref.chunk_index_in_segment, state.current_chunk_state, chunk, column_ids);
-}
-
-void ColumnDataConsumer::FinishChunk(ColumnDataConsumerScanState &state) {
-	D_ASSERT(state.chunk_index < chunk_count);
-	idx_t delete_index_start;
-	idx_t delete_index_end;
-	{
-		lock_guard<mutex> guard(lock);
-		D_ASSERT(chunks_in_progress.find(state.chunk_index) != chunks_in_progress.end());
-		delete_index_start = chunk_delete_index;
-		delete_index_end = *std::min_element(chunks_in_progress.begin(), chunks_in_progress.end());
-		chunks_in_progress.erase(state.chunk_index);
-		chunk_delete_index = delete_index_end;
-	}
-	ConsumeChunks(delete_index_start, delete_index_end);
-}
-void ColumnDataConsumer::ConsumeChunks(idx_t delete_index_start, idx_t delete_index_end) {
-	for (idx_t chunk_index = delete_index_start; chunk_index < delete_index_end; chunk_index++) {
-		if (chunk_index == 0) {
-			continue;
-		}
-		auto &prev_chunk_ref = chunk_references[chunk_index - 1];
-		auto &curr_chunk_ref = chunk_references[chunk_index];
-		auto prev_allocator = prev_chunk_ref.segment->allocator.get();
-		auto curr_allocator = curr_chunk_ref.segment->allocator.get();
-		auto prev_min_block_id = prev_chunk_ref.GetMinimumBlockID();
-		auto curr_min_block_id = curr_chunk_ref.GetMinimumBlockID();
-		if (prev_allocator != curr_allocator) {
-			// Moved to the next allocator, delete all remaining blocks in the previous one
-			for (uint32_t block_id = prev_min_block_id; block_id < prev_allocator->BlockCount(); block_id++) {
-				prev_allocator->SetDestroyBufferUponUnpin(block_id);
-			}
-			continue;
-		}
-		// Same allocator, see if we can delete blocks
-		for (uint32_t block_id = prev_min_block_id; block_id < curr_min_block_id; block_id++) {
-			prev_allocator->SetDestroyBufferUponUnpin(block_id);
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/column/partitioned_column_data.cpp b/src/duckdb/src/common/types/column/partitioned_column_data.cpp
deleted file mode 100644
index 78e5b3673..000000000
--- a/src/duckdb/src/common/types/column/partitioned_column_data.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-
-#include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-PartitionedColumnData::PartitionedColumnData(PartitionedColumnDataType type_p, ClientContext &context_p,
-                                             vector<LogicalType> types_p)
-    : type(type_p), context(context_p), types(std::move(types_p)),
-      allocators(make_shared_ptr<PartitionColumnDataAllocators>()) {
-}
-
-PartitionedColumnData::PartitionedColumnData(const PartitionedColumnData &other)
-    : type(other.type), context(other.context), types(other.types), allocators(other.allocators) {
-}
-
-unique_ptr<PartitionedColumnData> PartitionedColumnData::CreateShared() {
-	switch (type) {
-	case PartitionedColumnDataType::RADIX:
-		return make_uniq<RadixPartitionedColumnData>(Cast<RadixPartitionedColumnData>());
-	default:
-		throw NotImplementedException("CreateShared for this type of PartitionedColumnData");
-	}
-}
-
-PartitionedColumnData::~PartitionedColumnData() {
-}
-
-void PartitionedColumnData::InitializeAppendState(PartitionedColumnDataAppendState &state) const {
-	state.partition_sel.Initialize();
-	state.slice_chunk.Initialize(BufferAllocator::Get(context), types);
-	InitializeAppendStateInternal(state);
-}
-
-bool PartitionedColumnData::UseFixedSizeMap() const {
-	return MaxPartitionIndex() < PartitionedTupleDataAppendState::MAP_THRESHOLD;
-}
-
-unique_ptr<DataChunk> PartitionedColumnData::CreatePartitionBuffer() const {
-	auto result = make_uniq<DataChunk>();
-	result->Initialize(BufferAllocator::Get(context), types, BufferSize());
-	return result;
-}
-
-void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, DataChunk &input) {
-	// Compute partition indices and store them in state.partition_indices
-	ComputePartitionIndices(state, input);
-
-	// Build the selection vector for the partitions
-	BuildPartitionSel(state, input.size());
-
-	// Early out: check if everything belongs to a single partition
-	const auto partition_index = state.GetPartitionIndexIfSinglePartition(UseFixedSizeMap());
-	if (partition_index.IsValid()) {
-		auto &partition = *partitions[partition_index.GetIndex()];
-		auto &partition_append_state = *state.partition_append_states[partition_index.GetIndex()];
-		partition.Append(partition_append_state, input);
-		return;
-	}
-
-	if (UseFixedSizeMap()) {
-		AppendInternal<true>(state, input);
-	} else {
-		AppendInternal<false>(state, input);
-	}
-}
-
-void PartitionedColumnData::BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) const {
-	if (UseFixedSizeMap()) {
-		BuildPartitionSel<true>(state, append_count);
-	} else {
-		BuildPartitionSel<false>(state, append_count);
-	}
-}
-
-template <class MAP_TYPE>
-MAP_TYPE &PartitionedColumnDataGetMap(PartitionedColumnDataAppendState &) {
-	throw InternalException("Unknown MAP_TYPE for PartitionedTupleDataGetMap");
-}
-
-template <>
-fixed_size_map_t<list_entry_t> &PartitionedColumnDataGetMap(PartitionedColumnDataAppendState &state) {
-	return state.fixed_partition_entries;
-}
-
-template <>
-perfect_map_t<list_entry_t> &PartitionedColumnDataGetMap(PartitionedColumnDataAppendState &state) {
-	return state.partition_entries;
-}
-
-template <bool fixed>
-void PartitionedColumnData::BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) {
-	using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
-	auto &partition_entries = state.GetMap<fixed>();
-	partition_entries.clear();
-	const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
-	switch (state.partition_indices.GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		for (idx_t i = 0; i < append_count; i++) {
-			const auto &partition_index = partition_indices[i];
-			auto partition_entry = partition_entries.find(partition_index);
-			if (partition_entry == partition_entries.end()) {
-				partition_entries[partition_index] = list_entry_t(0, 1);
-			} else {
-				GETTER::GetValue(partition_entry).length++;
-			}
-		}
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		partition_entries[partition_indices[0]] = list_entry_t(0, append_count);
-		break;
-	default:
-		throw InternalException("Unexpected VectorType in PartitionedTupleData::Append");
-	}
-
-	// Early out: check if everything belongs to a single partition
-	if (partition_entries.size() == 1) {
-		return;
-	}
-
-	// Compute offsets from the counts
-	idx_t offset = 0;
-	for (auto it = partition_entries.begin(); it != partition_entries.end(); ++it) {
-		auto &partition_entry = GETTER::GetValue(it);
-		partition_entry.offset = offset;
-		offset += partition_entry.length;
-	}
-
-	// Now initialize a single selection vector that acts as a selection vector for every partition
-	auto &partition_sel = state.partition_sel;
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto &partition_index = partition_indices[i];
-		auto &partition_offset = partition_entries[partition_index].offset;
-		partition_sel[partition_offset++] = UnsafeNumericCast<sel_t>(i);
-	}
-}
-
-template <bool fixed>
-void PartitionedColumnData::AppendInternal(PartitionedColumnDataAppendState &state, DataChunk &input) {
-	using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
-	const auto &partition_entries = state.GetMap<fixed>();
-
-	// Loop through the partitions to append the new data to the partition buffers, and flush the buffers if necessary
-	SelectionVector partition_sel;
-	for (auto it = partition_entries.begin(); it != partition_entries.end(); ++it) {
-		const auto &partition_index = GETTER::GetKey(it);
-
-		// Partition, buffer, and append state for this partition index
-		auto &partition = *partitions[partition_index];
-		auto &partition_buffer = *state.partition_buffers[partition_index];
-		auto &partition_append_state = *state.partition_append_states[partition_index];
-
-		// Length and offset into the selection vector for this chunk, for this partition
-		const auto &partition_entry = GETTER::GetValue(it);
-		const auto &partition_length = partition_entry.length;
-		const auto partition_offset = partition_entry.offset - partition_length;
-
-		// Create a selection vector for this partition using the offset into the single selection vector
-		partition_sel.Initialize(state.partition_sel.data() + partition_offset);
-
-		if (partition_length >= HalfBufferSize()) {
-			// Slice the input chunk using the selection vector
-			state.slice_chunk.Reset();
-			state.slice_chunk.Slice(input, partition_sel, partition_length);
-
-			// Append it to the partition directly
-			partition.Append(partition_append_state, state.slice_chunk);
-		} else {
-			// Append the input chunk to the partition buffer using the selection vector
-			partition_buffer.Append(input, false, &partition_sel, partition_length);
-
-			if (partition_buffer.size() >= HalfBufferSize()) {
-				// Next batch won't fit in the buffer, flush it to the partition
-				partition.Append(partition_append_state, partition_buffer);
-				partition_buffer.Reset();
-				partition_buffer.SetCapacity(BufferSize());
-			}
-		}
-	}
-}
-
-void PartitionedColumnData::FlushAppendState(PartitionedColumnDataAppendState &state) {
-	for (idx_t i = 0; i < state.partition_buffers.size(); i++) {
-		if (!state.partition_buffers[i]) {
-			continue;
-		}
-		auto &partition_buffer = *state.partition_buffers[i];
-		if (partition_buffer.size() > 0) {
-			partitions[i]->Append(partition_buffer);
-			partition_buffer.Reset();
-		}
-	}
-}
-
-void PartitionedColumnData::Combine(PartitionedColumnData &other) {
-	// Now combine the state's partitions into this
-	lock_guard<mutex> guard(lock);
-
-	if (partitions.empty()) {
-		// This is the first merge, we just copy them over
-		partitions = std::move(other.partitions);
-	} else {
-		D_ASSERT(partitions.size() == other.partitions.size());
-		// Combine the append state's partitions into this PartitionedColumnData
-		for (idx_t i = 0; i < other.partitions.size(); i++) {
-			if (!other.partitions[i]) {
-				continue;
-			}
-			if (!partitions[i]) {
-				partitions[i] = std::move(other.partitions[i]);
-			} else {
-				partitions[i]->Combine(*other.partitions[i]);
-			}
-		}
-	}
-}
-
-vector<unique_ptr<ColumnDataCollection>> &PartitionedColumnData::GetPartitions() {
-	return partitions;
-}
-
-void PartitionedColumnData::CreateAllocator() {
-	allocators->allocators.emplace_back(make_shared_ptr<ColumnDataAllocator>(BufferManager::GetBufferManager(context)));
-	allocators->allocators.back()->MakeShared();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/conflict_info.cpp b/src/duckdb/src/common/types/conflict_info.cpp
deleted file mode 100644
index 44f8aa7f1..000000000
--- a/src/duckdb/src/common/types/conflict_info.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/common/types/constraint_conflict_info.hpp"
-#include "duckdb/storage/index.hpp"
-
-namespace duckdb {
-
-bool ConflictInfo::ConflictTargetMatches(Index &index) const {
-	if (only_check_unique && !index.IsUnique()) {
-		// We only support checking ON CONFLICT for Unique/Primary key constraints
-		return false;
-	}
-	if (column_ids.empty()) {
-		return true;
-	}
-	// Check whether the column ids match
-	return column_ids == index.GetColumnIdSet();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/conflict_manager.cpp b/src/duckdb/src/common/types/conflict_manager.cpp
deleted file mode 100644
index 409d0278f..000000000
--- a/src/duckdb/src/common/types/conflict_manager.cpp
+++ /dev/null
@@ -1,272 +0,0 @@
-#include "duckdb/common/types/conflict_manager.hpp"
-#include "duckdb/storage/index.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/common/types/constraint_conflict_info.hpp"
-
-namespace duckdb {
-
-ConflictManager::ConflictManager(VerifyExistenceType lookup_type, idx_t input_size,
-                                 optional_ptr<ConflictInfo> conflict_info)
-    : lookup_type(lookup_type), input_size(input_size), conflict_info(conflict_info), conflicts(input_size, false),
-      mode(ConflictManagerMode::THROW) {
-}
-
-ManagedSelection &ConflictManager::InternalSelection() {
-	if (!conflicts.Initialized()) {
-		conflicts.Initialize(input_size);
-	}
-	return conflicts;
-}
-
-const unordered_set<idx_t> &ConflictManager::InternalConflictSet() const {
-	D_ASSERT(conflict_set);
-	return *conflict_set;
-}
-
-Vector &ConflictManager::InternalRowIds() {
-	if (!row_ids) {
-		row_ids = make_uniq<Vector>(LogicalType::ROW_TYPE, input_size);
-	}
-	return *row_ids;
-}
-
-Vector &ConflictManager::InternalIntermediate() {
-	if (!intermediate_vector) {
-		intermediate_vector = make_uniq<Vector>(LogicalType::BOOLEAN, true, true, input_size);
-	}
-	return *intermediate_vector;
-}
-
-const ConflictInfo &ConflictManager::GetConflictInfo() const {
-	D_ASSERT(conflict_info);
-	return *conflict_info;
-}
-
-void ConflictManager::FinishLookup() {
-	if (mode == ConflictManagerMode::THROW) {
-		return;
-	}
-	if (!SingleIndexTarget()) {
-		return;
-	}
-	if (conflicts.Count() != 0) {
-		// We have recorded conflicts from the one index we're interested in
-		// We set this so we don't duplicate the conflicts when there are duplicate indexes
-		// that also match our conflict target
-		single_index_finished = true;
-	}
-}
-
-void ConflictManager::SetMode(ConflictManagerMode mode) {
-	// Only allow SCAN when we have conflict info
-	D_ASSERT(mode != ConflictManagerMode::SCAN || conflict_info != nullptr);
-	this->mode = mode;
-}
-
-void ConflictManager::AddToConflictSet(idx_t chunk_index) {
-	if (!conflict_set) {
-		conflict_set = make_uniq<unordered_set<idx_t>>();
-	}
-	auto &set = *conflict_set;
-	set.insert(chunk_index);
-}
-
-void ConflictManager::AddConflictInternal(idx_t chunk_index, row_t row_id) {
-	D_ASSERT(mode == ConflictManagerMode::SCAN);
-
-	// Only when we should not throw on conflict should we get here
-	D_ASSERT(!ShouldThrow(chunk_index));
-	AddToConflictSet(chunk_index);
-	if (SingleIndexTarget()) {
-		// If we have identical indexes, only the conflicts of the first index should be recorded
-		// as the other index(es) would produce the exact same conflicts anyways
-		if (single_index_finished) {
-			return;
-		}
-
-		// We can be more efficient because we don't need to merge conflicts of multiple indexes
-		auto &selection = InternalSelection();
-		auto &row_ids = InternalRowIds();
-		auto data = FlatVector::GetData<row_t>(row_ids);
-		data[selection.Count()] = row_id;
-		selection.Append(chunk_index);
-	} else {
-		auto &intermediate = InternalIntermediate();
-		auto data = FlatVector::GetData<bool>(intermediate);
-		// Mark this index in the chunk as producing a conflict
-		data[chunk_index] = true;
-		if (row_id_map.empty()) {
-			row_id_map.resize(input_size);
-		}
-		row_id_map[chunk_index] = row_id;
-	}
-}
-
-bool ConflictManager::IsConflict(LookupResultType type) {
-	switch (type) {
-	case LookupResultType::LOOKUP_NULL: {
-		if (ShouldIgnoreNulls()) {
-			return false;
-		}
-		// If nulls are not ignored, treat this as a hit instead
-		return IsConflict(LookupResultType::LOOKUP_HIT);
-	}
-	case LookupResultType::LOOKUP_HIT: {
-		return true;
-	}
-	case LookupResultType::LOOKUP_MISS: {
-		// FIXME: If we record a miss as a conflict when the verify type is APPEND_FK, then we can simplify the checks
-		// in VerifyForeignKeyConstraint This also means we should not record a hit as a conflict when the verify type
-		// is APPEND_FK
-		return false;
-	}
-	default: {
-		throw NotImplementedException("Type not implemented for LookupResultType");
-	}
-	}
-}
-
-bool ConflictManager::AddHit(idx_t chunk_index, row_t row_id) {
-	D_ASSERT(chunk_index < input_size);
-	// First check if this causes a conflict
-	if (!IsConflict(LookupResultType::LOOKUP_HIT)) {
-		return false;
-	}
-
-	// Then check if we should throw on a conflict
-	if (ShouldThrow(chunk_index)) {
-		return true;
-	}
-	if (mode == ConflictManagerMode::THROW) {
-		// When our mode is THROW, and the chunk index is part of the previously scanned conflicts
-		// then we ignore the conflict instead
-		D_ASSERT(!ShouldThrow(chunk_index));
-		return false;
-	}
-	D_ASSERT(conflict_info);
-	// Because we don't throw, we need to register the conflict
-	AddConflictInternal(chunk_index, row_id);
-	return false;
-}
-
-bool ConflictManager::AddMiss(idx_t chunk_index) {
-	D_ASSERT(chunk_index < input_size);
-	return IsConflict(LookupResultType::LOOKUP_MISS);
-}
-
-bool ConflictManager::AddNull(idx_t chunk_index) {
-	D_ASSERT(chunk_index < input_size);
-	if (!IsConflict(LookupResultType::LOOKUP_NULL)) {
-		return false;
-	}
-	return AddHit(chunk_index, static_cast<row_t>(DConstants::INVALID_INDEX));
-}
-
-bool ConflictManager::SingleIndexTarget() const {
-	D_ASSERT(conflict_info);
-	// We are only interested in a specific index
-	return !conflict_info->column_ids.empty();
-}
-
-bool ConflictManager::ShouldThrow(idx_t chunk_index) const {
-	if (mode == ConflictManagerMode::SCAN) {
-		return false;
-	}
-	D_ASSERT(mode == ConflictManagerMode::THROW);
-	if (conflict_set == nullptr) {
-		// No conflicts were scanned, so this conflict is not in the set
-		return true;
-	}
-	auto &set = InternalConflictSet();
-	if (set.count(chunk_index)) {
-		return false;
-	}
-	// None of the scanned conflicts arose from this insert tuple
-	return true;
-}
-
-bool ConflictManager::ShouldIgnoreNulls() const {
-	switch (lookup_type) {
-	case VerifyExistenceType::APPEND:
-		return true;
-	case VerifyExistenceType::APPEND_FK:
-		return false;
-	case VerifyExistenceType::DELETE_FK:
-		return true;
-	default:
-		throw InternalException("Type not implemented for VerifyExistenceType");
-	}
-}
-
-Vector &ConflictManager::RowIds() {
-	D_ASSERT(finalized);
-	return *row_ids;
-}
-
-const ManagedSelection &ConflictManager::Conflicts() const {
-	D_ASSERT(finalized);
-	return conflicts;
-}
-
-idx_t ConflictManager::ConflictCount() const {
-	return conflicts.Count();
-}
-
-void ConflictManager::AddIndex(BoundIndex &index, optional_ptr<BoundIndex> delete_index) {
-	matched_indexes.push_back(index);
-	matched_delete_indexes.push_back(delete_index);
-	matched_index_names.insert(index.name);
-}
-
-bool ConflictManager::MatchedIndex(BoundIndex &index) {
-	return matched_index_names.find(index.name) != matched_index_names.end();
-}
-
-const vector<reference<BoundIndex>> &ConflictManager::MatchedIndexes() const {
-	return matched_indexes;
-}
-
-const vector<optional_ptr<BoundIndex>> &ConflictManager::MatchedDeleteIndexes() const {
-	return matched_delete_indexes;
-}
-
-void ConflictManager::Finalize() {
-	D_ASSERT(!finalized);
-	if (SingleIndexTarget()) {
-		// Selection vector has been directly populated already, no need to finalize
-		finalized = true;
-		return;
-	}
-	finalized = true;
-	if (!intermediate_vector) {
-		// No conflicts were found, we're done
-		return;
-	}
-	auto &intermediate = InternalIntermediate();
-	auto data = FlatVector::GetData<bool>(intermediate);
-	auto &selection = InternalSelection();
-	// Create the selection vector from the encountered conflicts
-	for (idx_t i = 0; i < input_size; i++) {
-		if (data[i]) {
-			selection.Append(i);
-		}
-	}
-	// Now create the row_ids Vector, aligned with the selection vector
-	auto &internal_row_ids = InternalRowIds();
-	auto row_id_data = FlatVector::GetData<row_t>(internal_row_ids);
-
-	for (idx_t i = 0; i < selection.Count(); i++) {
-		D_ASSERT(!row_id_map.empty());
-		auto index = selection[i];
-		D_ASSERT(index < row_id_map.size());
-		auto row_id = row_id_map[index];
-		row_id_data[i] = row_id;
-	}
-	intermediate_vector.reset();
-}
-
-VerifyExistenceType ConflictManager::LookupType() const {
-	return lookup_type;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/data_chunk.cpp b/src/duckdb/src/common/types/data_chunk.cpp
deleted file mode 100644
index 8b00a95f7..000000000
--- a/src/duckdb/src/common/types/data_chunk.cpp
+++ /dev/null
@@ -1,396 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-
-#include "duckdb/common/array.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/sel_cache.hpp"
-#include "duckdb/common/types/vector_cache.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/execution_context.hpp"
-
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-
-namespace duckdb {
-
-DataChunk::DataChunk() : count(0), capacity(STANDARD_VECTOR_SIZE) {
-}
-
-DataChunk::~DataChunk() {
-}
-
-void DataChunk::InitializeEmpty(const vector<LogicalType> &types) {
-	D_ASSERT(data.empty());
-	capacity = STANDARD_VECTOR_SIZE;
-	for (idx_t i = 0; i < types.size(); i++) {
-		data.emplace_back(types[i], nullptr);
-	}
-}
-
-void DataChunk::Initialize(ClientContext &context, const vector<LogicalType> &types, idx_t capacity_p) {
-	Initialize(Allocator::Get(context), types, capacity_p);
-}
-
-void DataChunk::Initialize(Allocator &allocator, const vector<LogicalType> &types, idx_t capacity_p) {
-	auto initialize = vector<bool>(types.size(), true);
-	Initialize(allocator, types, initialize, capacity_p);
-}
-
-void DataChunk::Initialize(ClientContext &context, const vector<LogicalType> &types, const vector<bool> &initialize,
-                           idx_t capacity_p) {
-	Initialize(Allocator::Get(context), types, initialize, capacity_p);
-}
-
-void DataChunk::Initialize(Allocator &allocator, const vector<LogicalType> &types, const vector<bool> &initialize,
-                           idx_t capacity_p) {
-	D_ASSERT(types.size() == initialize.size());
-	D_ASSERT(data.empty());
-
-	capacity = capacity_p;
-	for (idx_t i = 0; i < types.size(); i++) {
-		if (!initialize[i]) {
-			data.emplace_back(types[i], nullptr);
-			vector_caches.emplace_back();
-			continue;
-		}
-
-		VectorCache cache(allocator, types[i], capacity);
-		data.emplace_back(cache);
-		vector_caches.push_back(std::move(cache));
-	}
-}
-
-idx_t DataChunk::GetAllocationSize() const {
-	idx_t total_size = 0;
-	auto cardinality = size();
-	for (auto &vec : data) {
-		total_size += vec.GetAllocationSize(cardinality);
-	}
-	return total_size;
-}
-
-void DataChunk::Reset() {
-	if (data.empty() || vector_caches.empty()) {
-		return;
-	}
-	if (vector_caches.size() != data.size()) {
-		throw InternalException("VectorCache and column count mismatch in DataChunk::Reset");
-	}
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].ResetFromCache(vector_caches[i]);
-	}
-	capacity = STANDARD_VECTOR_SIZE;
-	SetCardinality(0);
-}
-
-void DataChunk::Destroy() {
-	data.clear();
-	vector_caches.clear();
-	capacity = 0;
-	SetCardinality(0);
-}
-
-Value DataChunk::GetValue(idx_t col_idx, idx_t index) const {
-	D_ASSERT(index < size());
-	return data[col_idx].GetValue(index);
-}
-
-void DataChunk::SetValue(idx_t col_idx, idx_t index, const Value &val) {
-	data[col_idx].SetValue(index, val);
-}
-
-bool DataChunk::AllConstant() const {
-	for (auto &v : data) {
-		if (v.GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void DataChunk::Reference(DataChunk &chunk) {
-	D_ASSERT(chunk.ColumnCount() <= ColumnCount());
-	SetCapacity(chunk);
-	SetCardinality(chunk);
-	for (idx_t i = 0; i < chunk.ColumnCount(); i++) {
-		data[i].Reference(chunk.data[i]);
-	}
-}
-
-void DataChunk::Move(DataChunk &chunk) {
-	SetCardinality(chunk);
-	SetCapacity(chunk);
-	data = std::move(chunk.data);
-	vector_caches = std::move(chunk.vector_caches);
-
-	chunk.Destroy();
-}
-
-void DataChunk::Copy(DataChunk &other, idx_t offset) const {
-	D_ASSERT(ColumnCount() == other.ColumnCount());
-	D_ASSERT(other.size() == 0);
-
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		D_ASSERT(other.data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-		VectorOperations::Copy(data[i], other.data[i], size(), offset, 0);
-	}
-	other.SetCardinality(size() - offset);
-}
-
-void DataChunk::Copy(DataChunk &other, const SelectionVector &sel, const idx_t source_count, const idx_t offset) const {
-	D_ASSERT(ColumnCount() == other.ColumnCount());
-	D_ASSERT(other.size() == 0);
-	D_ASSERT(source_count <= size());
-
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		D_ASSERT(other.data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-		VectorOperations::Copy(data[i], other.data[i], sel, source_count, offset, 0);
-	}
-	other.SetCardinality(source_count - offset);
-}
-
-void DataChunk::Split(DataChunk &other, idx_t split_idx) {
-	D_ASSERT(other.size() == 0);
-	D_ASSERT(other.data.empty());
-	D_ASSERT(split_idx < data.size());
-	const idx_t num_cols = data.size();
-	for (idx_t col_idx = split_idx; col_idx < num_cols; col_idx++) {
-		other.data.push_back(std::move(data[col_idx]));
-		other.vector_caches.push_back(std::move(vector_caches[col_idx]));
-	}
-	for (idx_t col_idx = split_idx; col_idx < num_cols; col_idx++) {
-		data.pop_back();
-		vector_caches.pop_back();
-	}
-	other.SetCapacity(*this);
-	other.SetCardinality(*this);
-}
-
-void DataChunk::Fuse(DataChunk &other) {
-	D_ASSERT(other.size() == size());
-	const idx_t num_cols = other.data.size();
-	for (idx_t col_idx = 0; col_idx < num_cols; ++col_idx) {
-		data.emplace_back(std::move(other.data[col_idx]));
-		vector_caches.emplace_back(std::move(other.vector_caches[col_idx]));
-	}
-	other.Destroy();
-}
-
-void DataChunk::ReferenceColumns(DataChunk &other, const vector<column_t> &column_ids) {
-	D_ASSERT(ColumnCount() == column_ids.size());
-	Reset();
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		auto &other_col = other.data[column_ids[col_idx]];
-		auto &this_col = data[col_idx];
-		D_ASSERT(other_col.GetType() == this_col.GetType());
-		this_col.Reference(other_col);
-	}
-	SetCardinality(other.size());
-}
-
-void DataChunk::Append(const DataChunk &other, bool resize, SelectionVector *sel, idx_t sel_count) {
-	idx_t new_size = sel ? size() + sel_count : size() + other.size();
-	if (other.size() == 0) {
-		return;
-	}
-	if (ColumnCount() != other.ColumnCount()) {
-		throw InternalException("Column counts of appending chunk doesn't match!");
-	}
-	if (new_size > capacity) {
-		if (resize) {
-			auto new_capacity = NextPowerOfTwo(new_size);
-			for (idx_t i = 0; i < ColumnCount(); i++) {
-				data[i].Resize(size(), new_capacity);
-			}
-			capacity = new_capacity;
-		} else {
-			throw InternalException("Can't append chunk to other chunk without resizing");
-		}
-	}
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		D_ASSERT(data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-		if (sel) {
-			VectorOperations::Copy(other.data[i], data[i], *sel, sel_count, 0, size());
-		} else {
-			VectorOperations::Copy(other.data[i], data[i], other.size(), 0, size());
-		}
-	}
-	SetCardinality(new_size);
-}
-
-void DataChunk::Flatten() {
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].Flatten(size());
-	}
-}
-
-vector<LogicalType> DataChunk::GetTypes() const {
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		types.push_back(data[i].GetType());
-	}
-	return types;
-}
-
-string DataChunk::ToString() const {
-	string retval = "Chunk - [" + to_string(ColumnCount()) + " Columns]\n";
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		retval += "- " + data[i].ToString(size()) + "\n";
-	}
-	return retval;
-}
-
-void DataChunk::Serialize(Serializer &serializer) const {
-
-	// write the count
-	auto row_count = size();
-	serializer.WriteProperty<sel_t>(100, "rows", NumericCast<sel_t>(row_count));
-
-	// we should never try to serialize empty data chunks
-	auto column_count = ColumnCount();
-	D_ASSERT(column_count);
-
-	// write the types
-	serializer.WriteList(101, "types", column_count,
-	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(data[i].GetType()); });
-
-	// write the data
-	serializer.WriteList(102, "columns", column_count, [&](Serializer::List &list, idx_t i) {
-		list.WriteObject([&](Serializer &object) {
-			// Reference the vector to avoid potentially mutating it during serialization
-			Vector serialized_vector(data[i].GetType());
-			serialized_vector.Reference(data[i]);
-			serialized_vector.Serialize(object, row_count);
-		});
-	});
-}
-
-void DataChunk::Deserialize(Deserializer &deserializer) {
-
-	// read and set the row count
-	auto row_count = deserializer.ReadProperty<sel_t>(100, "rows");
-
-	// read the types
-	vector<LogicalType> types;
-	deserializer.ReadList(101, "types", [&](Deserializer::List &list, idx_t i) {
-		auto type = list.ReadElement<LogicalType>();
-		types.push_back(type);
-	});
-
-	// initialize the data chunk
-	D_ASSERT(!types.empty());
-	Initialize(Allocator::DefaultAllocator(), types, MaxValue<idx_t>(row_count, STANDARD_VECTOR_SIZE));
-	SetCardinality(row_count);
-
-	// read the data
-	deserializer.ReadList(102, "columns", [&](Deserializer::List &list, idx_t i) {
-		list.ReadObject([&](Deserializer &object) { data[i].Deserialize(object, row_count); });
-	});
-}
-
-void DataChunk::Slice(const SelectionVector &sel_vector, idx_t count_p) {
-	this->count = count_p;
-	SelCache merge_cache;
-	for (idx_t c = 0; c < ColumnCount(); c++) {
-		data[c].Slice(sel_vector, count_p, merge_cache);
-	}
-}
-
-void DataChunk::Slice(const DataChunk &other, const SelectionVector &sel, idx_t count_p, idx_t col_offset) {
-	D_ASSERT(other.ColumnCount() <= col_offset + ColumnCount());
-	this->count = count_p;
-	SelCache merge_cache;
-	for (idx_t c = 0; c < other.ColumnCount(); c++) {
-		if (other.data[c].GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-			// already a dictionary! merge the dictionaries
-			data[col_offset + c].Reference(other.data[c]);
-			data[col_offset + c].Slice(sel, count_p, merge_cache);
-		} else {
-			data[col_offset + c].Slice(other.data[c], sel, count_p);
-		}
-	}
-}
-
-void DataChunk::Slice(idx_t offset, idx_t slice_count) {
-	D_ASSERT(offset + slice_count <= size());
-	SelectionVector sel(slice_count);
-	for (idx_t i = 0; i < slice_count; i++) {
-		sel.set_index(i, offset + i);
-	}
-	Slice(sel, slice_count);
-}
-
-unsafe_unique_array<UnifiedVectorFormat> DataChunk::ToUnifiedFormat() {
-	auto unified_data = make_unsafe_uniq_array<UnifiedVectorFormat>(ColumnCount());
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		data[col_idx].ToUnifiedFormat(size(), unified_data[col_idx]);
-	}
-	return unified_data;
-}
-
-void DataChunk::Hash(Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalType::HASH);
-	VectorOperations::Hash(data[0], result, size());
-	for (idx_t i = 1; i < ColumnCount(); i++) {
-		VectorOperations::CombineHash(result, data[i], size());
-	}
-}
-
-void DataChunk::Hash(vector<idx_t> &column_ids, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalType::HASH);
-	D_ASSERT(!column_ids.empty());
-
-	VectorOperations::Hash(data[column_ids[0]], result, size());
-	for (idx_t i = 1; i < column_ids.size(); i++) {
-		VectorOperations::CombineHash(result, data[column_ids[i]], size());
-	}
-}
-
-void DataChunk::Verify() {
-#ifdef DEBUG
-	D_ASSERT(size() <= capacity);
-
-	// verify that all vectors in this chunk have the chunk selection vector
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].Verify(size());
-	}
-
-	if (!ColumnCount()) {
-		// don't try to round-trip dummy data chunks with no data
-		// e.g., these exist in queries like 'SELECT distinct(col0, col1) FROM tbl', where we have groups, but no
-		// payload so the payload will be such an empty data chunk
-		return;
-	}
-
-	// verify that we can round-trip chunk serialization
-	MemoryStream mem_stream;
-	BinarySerializer serializer(mem_stream);
-
-	serializer.Begin();
-	Serialize(serializer);
-	serializer.End();
-
-	mem_stream.Rewind();
-
-	BinaryDeserializer deserializer(mem_stream);
-	DataChunk new_chunk;
-
-	deserializer.Begin();
-	new_chunk.Deserialize(deserializer);
-	deserializer.End();
-
-	D_ASSERT(size() == new_chunk.size());
-#endif
-}
-
-void DataChunk::Print() const {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/date.cpp b/src/duckdb/src/common/types/date.cpp
deleted file mode 100644
index 429ee0311..000000000
--- a/src/duckdb/src/common/types/date.cpp
+++ /dev/null
@@ -1,625 +0,0 @@
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include <cstring>
-#include <cctype>
-#include <algorithm>
-
-namespace duckdb {
-
-static_assert(sizeof(date_t) == sizeof(int32_t), "date_t was padded");
-
-const char *Date::PINF = "infinity";  // NOLINT
-const char *Date::NINF = "-infinity"; // NOLINT
-const char *Date::EPOCH = "epoch";    // NOLINT
-
-const string_t Date::MONTH_NAMES_ABBREVIATED[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-                                                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-const string_t Date::MONTH_NAMES[] = {"January", "February", "March",     "April",   "May",      "June",
-                                      "July",    "August",   "September", "October", "November", "December"};
-const string_t Date::DAY_NAMES[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
-const string_t Date::DAY_NAMES_ABBREVIATED[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-
-const int32_t Date::NORMAL_DAYS[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-const int32_t Date::CUMULATIVE_DAYS[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
-const int32_t Date::LEAP_DAYS[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-const int32_t Date::CUMULATIVE_LEAP_DAYS[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
-const int8_t Date::MONTH_PER_DAY_OF_YEAR[] = {
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-    2,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
-    3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
-    4,  4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
-    5,  5,  5,  5,  5,  5,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
-    6,  6,  6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
-    8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12};
-const int8_t Date::LEAP_MONTH_PER_DAY_OF_YEAR[] = {
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-    2,  2,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
-    3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
-    4,  4,  4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
-    5,  5,  5,  5,  5,  5,  5,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
-    6,  6,  6,  6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
-    8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12};
-const int32_t Date::CUMULATIVE_YEAR_DAYS[] = {
-    0,      365,    730,    1096,   1461,   1826,   2191,   2557,   2922,   3287,   3652,   4018,   4383,   4748,
-    5113,   5479,   5844,   6209,   6574,   6940,   7305,   7670,   8035,   8401,   8766,   9131,   9496,   9862,
-    10227,  10592,  10957,  11323,  11688,  12053,  12418,  12784,  13149,  13514,  13879,  14245,  14610,  14975,
-    15340,  15706,  16071,  16436,  16801,  17167,  17532,  17897,  18262,  18628,  18993,  19358,  19723,  20089,
-    20454,  20819,  21184,  21550,  21915,  22280,  22645,  23011,  23376,  23741,  24106,  24472,  24837,  25202,
-    25567,  25933,  26298,  26663,  27028,  27394,  27759,  28124,  28489,  28855,  29220,  29585,  29950,  30316,
-    30681,  31046,  31411,  31777,  32142,  32507,  32872,  33238,  33603,  33968,  34333,  34699,  35064,  35429,
-    35794,  36160,  36525,  36890,  37255,  37621,  37986,  38351,  38716,  39082,  39447,  39812,  40177,  40543,
-    40908,  41273,  41638,  42004,  42369,  42734,  43099,  43465,  43830,  44195,  44560,  44926,  45291,  45656,
-    46021,  46387,  46752,  47117,  47482,  47847,  48212,  48577,  48942,  49308,  49673,  50038,  50403,  50769,
-    51134,  51499,  51864,  52230,  52595,  52960,  53325,  53691,  54056,  54421,  54786,  55152,  55517,  55882,
-    56247,  56613,  56978,  57343,  57708,  58074,  58439,  58804,  59169,  59535,  59900,  60265,  60630,  60996,
-    61361,  61726,  62091,  62457,  62822,  63187,  63552,  63918,  64283,  64648,  65013,  65379,  65744,  66109,
-    66474,  66840,  67205,  67570,  67935,  68301,  68666,  69031,  69396,  69762,  70127,  70492,  70857,  71223,
-    71588,  71953,  72318,  72684,  73049,  73414,  73779,  74145,  74510,  74875,  75240,  75606,  75971,  76336,
-    76701,  77067,  77432,  77797,  78162,  78528,  78893,  79258,  79623,  79989,  80354,  80719,  81084,  81450,
-    81815,  82180,  82545,  82911,  83276,  83641,  84006,  84371,  84736,  85101,  85466,  85832,  86197,  86562,
-    86927,  87293,  87658,  88023,  88388,  88754,  89119,  89484,  89849,  90215,  90580,  90945,  91310,  91676,
-    92041,  92406,  92771,  93137,  93502,  93867,  94232,  94598,  94963,  95328,  95693,  96059,  96424,  96789,
-    97154,  97520,  97885,  98250,  98615,  98981,  99346,  99711,  100076, 100442, 100807, 101172, 101537, 101903,
-    102268, 102633, 102998, 103364, 103729, 104094, 104459, 104825, 105190, 105555, 105920, 106286, 106651, 107016,
-    107381, 107747, 108112, 108477, 108842, 109208, 109573, 109938, 110303, 110669, 111034, 111399, 111764, 112130,
-    112495, 112860, 113225, 113591, 113956, 114321, 114686, 115052, 115417, 115782, 116147, 116513, 116878, 117243,
-    117608, 117974, 118339, 118704, 119069, 119435, 119800, 120165, 120530, 120895, 121260, 121625, 121990, 122356,
-    122721, 123086, 123451, 123817, 124182, 124547, 124912, 125278, 125643, 126008, 126373, 126739, 127104, 127469,
-    127834, 128200, 128565, 128930, 129295, 129661, 130026, 130391, 130756, 131122, 131487, 131852, 132217, 132583,
-    132948, 133313, 133678, 134044, 134409, 134774, 135139, 135505, 135870, 136235, 136600, 136966, 137331, 137696,
-    138061, 138427, 138792, 139157, 139522, 139888, 140253, 140618, 140983, 141349, 141714, 142079, 142444, 142810,
-    143175, 143540, 143905, 144271, 144636, 145001, 145366, 145732, 146097};
-
-void Date::ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset) {
-	year = Date::EPOCH_YEAR;
-	// first we normalize n to be in the year range [1970, 2370]
-	// since leap years repeat every 400 years, we can safely normalize just by "shifting" the CumulativeYearDays array
-	while (n < 0) {
-		n += Date::DAYS_PER_YEAR_INTERVAL;
-		year -= Date::YEAR_INTERVAL;
-	}
-	while (n >= Date::DAYS_PER_YEAR_INTERVAL) {
-		n -= Date::DAYS_PER_YEAR_INTERVAL;
-		year += Date::YEAR_INTERVAL;
-	}
-	// interpolation search
-	// we can find an upper bound of the year by assuming each year has 365 days
-	year_offset = n / 365;
-	// because of leap years we might be off by a little bit: compensate by decrementing the year offset until we find
-	// our year
-	while (n < Date::CUMULATIVE_YEAR_DAYS[year_offset]) {
-		year_offset--;
-		D_ASSERT(year_offset >= 0);
-	}
-	year += year_offset;
-	D_ASSERT(n >= Date::CUMULATIVE_YEAR_DAYS[year_offset]);
-}
-
-void Date::Convert(date_t d, int32_t &year, int32_t &month, int32_t &day) {
-	auto n = d.days;
-	int32_t year_offset;
-	Date::ExtractYearOffset(n, year, year_offset);
-
-	day = n - Date::CUMULATIVE_YEAR_DAYS[year_offset];
-	D_ASSERT(day >= 0 && day <= 365);
-
-	bool is_leap_year = (Date::CUMULATIVE_YEAR_DAYS[year_offset + 1] - Date::CUMULATIVE_YEAR_DAYS[year_offset]) == 366;
-	if (is_leap_year) {
-		month = Date::LEAP_MONTH_PER_DAY_OF_YEAR[day];
-		day -= Date::CUMULATIVE_LEAP_DAYS[month - 1];
-	} else {
-		month = Date::MONTH_PER_DAY_OF_YEAR[day];
-		day -= Date::CUMULATIVE_DAYS[month - 1];
-	}
-	day++;
-	D_ASSERT(day > 0 && day <= (is_leap_year ? Date::LEAP_DAYS[month] : Date::NORMAL_DAYS[month]));
-	D_ASSERT(month > 0 && month <= 12);
-}
-
-bool Date::TryFromDate(int32_t year, int32_t month, int32_t day, date_t &result) {
-	int32_t n = 0;
-	if (!Date::IsValid(year, month, day)) {
-		return false;
-	}
-	n += Date::IsLeapYear(year) ? Date::CUMULATIVE_LEAP_DAYS[month - 1] : Date::CUMULATIVE_DAYS[month - 1];
-	n += day - 1;
-	if (year < 1970) {
-		int32_t diff_from_base = 1970 - year;
-		int32_t year_index = 400 - (diff_from_base % 400);
-		int32_t fractions = diff_from_base / 400;
-		n += Date::CUMULATIVE_YEAR_DAYS[year_index];
-		n -= Date::DAYS_PER_YEAR_INTERVAL;
-		n -= fractions * Date::DAYS_PER_YEAR_INTERVAL;
-	} else if (year >= 2370) {
-		int32_t diff_from_base = year - 2370;
-		int32_t year_index = diff_from_base % 400;
-		int32_t fractions = diff_from_base / 400;
-		n += Date::CUMULATIVE_YEAR_DAYS[year_index];
-		n += Date::DAYS_PER_YEAR_INTERVAL;
-		n += fractions * Date::DAYS_PER_YEAR_INTERVAL;
-	} else {
-		n += Date::CUMULATIVE_YEAR_DAYS[year - 1970];
-	}
-#ifdef DEBUG
-	int32_t y, m, d;
-	Date::Convert(date_t(n), y, m, d);
-	D_ASSERT(year == y);
-	D_ASSERT(month == m);
-	D_ASSERT(day == d);
-#endif
-	result = date_t(n);
-	return true;
-}
-
-date_t Date::FromDate(int32_t year, int32_t month, int32_t day) {
-	date_t result;
-	if (!Date::TryFromDate(year, month, day, result)) {
-		throw ConversionException("Date out of range: %d-%d-%d", year, month, day);
-	}
-	return result;
-}
-
-bool Date::ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result) {
-	if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) {
-		result = buf[pos++] - '0';
-		if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) {
-			result = (buf[pos++] - '0') + result * 10;
-		}
-		return true;
-	}
-	return false;
-}
-
-bool Date::TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special) {
-	auto p = pos;
-	for (; p < len && *special; ++p) {
-		const auto s = *special++;
-		if (!s || StringUtil::CharacterToLower(buf[p]) != s) {
-			return false;
-		}
-	}
-	if (*special) {
-		return false;
-	}
-	pos = p;
-	return true;
-}
-
-DateCastResult Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special,
-                                    bool strict) {
-	special = false;
-	pos = 0;
-	if (len == 0) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	int32_t day = 0;
-	int32_t month = -1;
-	int32_t year = 0;
-	bool yearneg = false;
-	int sep;
-
-	// skip leading spaces
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
-
-	if (pos >= len) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-	if (buf[pos] == '-') {
-		yearneg = true;
-		pos++;
-		if (pos >= len) {
-			return DateCastResult::ERROR_INCORRECT_FORMAT;
-		}
-	}
-	if (!StringUtil::CharacterIsDigit(buf[pos])) {
-		// Check for special values
-		if (TryConvertDateSpecial(buf, len, pos, PINF)) {
-			result = yearneg ? date_t::ninfinity() : date_t::infinity();
-		} else if (TryConvertDateSpecial(buf, len, pos, EPOCH)) {
-			result = date_t::epoch();
-		} else {
-			return DateCastResult::ERROR_INCORRECT_FORMAT;
-		}
-		// skip trailing spaces - parsing must be strict here
-		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-			pos++;
-		}
-		special = true;
-		return (pos == len) ? DateCastResult::SUCCESS : DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-	// first parse the year
-	idx_t year_length = 0;
-	for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++) {
-		if (year >= 100000000) {
-			return DateCastResult::ERROR_RANGE;
-		}
-		year = (buf[pos] - '0') + year * 10;
-		year_length++;
-	}
-	if (year_length < 2 && strict) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-	if (yearneg) {
-		year = -year;
-	}
-
-	if (pos >= len) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	// fetch the separator
-	sep = buf[pos++];
-	if (sep != ' ' && sep != '-' && sep != '/' && sep != '\\') {
-		// invalid separator
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	// parse the month
-	if (!Date::ParseDoubleDigit(buf, len, pos, month)) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	if (pos >= len) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	if (buf[pos++] != sep) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	if (pos >= len) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	// now parse the day
-	if (!Date::ParseDoubleDigit(buf, len, pos, day)) {
-		return DateCastResult::ERROR_INCORRECT_FORMAT;
-	}
-
-	// check for an optional trailing " (BC)""
-	if (len - pos >= 5 && StringUtil::CharacterIsSpace(buf[pos]) && buf[pos + 1] == '(' &&
-	    StringUtil::CharacterToLower(buf[pos + 2]) == 'b' && StringUtil::CharacterToLower(buf[pos + 3]) == 'c' &&
-	    buf[pos + 4] == ')') {
-		if (yearneg || year == 0) {
-			return DateCastResult::ERROR_INCORRECT_FORMAT;
-		}
-		year = -year + 1;
-		pos += 5;
-	}
-
-	// in strict mode, check remaining string for non-space characters
-	if (strict) {
-		// skip trailing spaces
-		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-			pos++;
-		}
-		// check position. if end was not reached, non-space chars remaining
-		if (pos < len) {
-			return DateCastResult::ERROR_INCORRECT_FORMAT;
-		}
-	} else {
-		// in non-strict mode, check for any direct trailing digits
-		if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) {
-			return DateCastResult::ERROR_INCORRECT_FORMAT;
-		}
-	}
-
-	return Date::TryFromDate(year, month, day, result) ? DateCastResult::SUCCESS : DateCastResult::ERROR_RANGE;
-}
-
-string Date::FormatError(const string &str) {
-	return StringUtil::Format("invalid date field format: \"%s\", "
-	                          "expected format is (YYYY-MM-DD)",
-	                          str);
-}
-
-string Date::RangeError(const string &str) {
-	return StringUtil::Format("date field value out of range: \"%s\"", str);
-}
-
-string Date::RangeError(string_t str) {
-	return RangeError(str.GetString());
-}
-
-string Date::FormatError(string_t str) {
-	return FormatError(str.GetString());
-}
-
-date_t Date::FromCString(const char *buf, idx_t len, bool strict) {
-	date_t result;
-	idx_t pos;
-	bool special = false;
-	switch (TryConvertDate(buf, len, pos, result, special, strict)) {
-	case DateCastResult::ERROR_INCORRECT_FORMAT:
-		throw ConversionException(FormatError(string(buf, len)));
-	case DateCastResult::ERROR_RANGE:
-		throw ConversionException(RangeError(string(buf, len)));
-	case DateCastResult::SUCCESS:
-		break;
-	}
-	return result;
-}
-
-date_t Date::FromString(const string &str, bool strict) {
-	return Date::FromCString(str.c_str(), str.size(), strict);
-}
-
-string Date::ToString(date_t date) {
-	// PG displays temporal infinities in lowercase,
-	// but numerics in Titlecase.
-	if (date == date_t::infinity()) {
-		return PINF;
-	} else if (date == date_t::ninfinity()) {
-		return NINF;
-	}
-	int32_t date_units[3];
-	idx_t year_length;
-	bool add_bc;
-	Date::Convert(date, date_units[0], date_units[1], date_units[2]);
-
-	auto length = DateToStringCast::Length(date_units, year_length, add_bc);
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(length);
-	DateToStringCast::Format(buffer.get(), date_units, year_length, add_bc);
-	return string(buffer.get(), length);
-}
-
-string Date::Format(int32_t year, int32_t month, int32_t day) {
-	return ToString(Date::FromDate(year, month, day));
-}
-
-bool Date::IsLeapYear(int32_t year) {
-	return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
-}
-
-bool Date::IsValid(int32_t year, int32_t month, int32_t day) {
-	if (month < 1 || month > 12) {
-		return false;
-	}
-	if (day < 1) {
-		return false;
-	}
-	if (year <= DATE_MIN_YEAR) {
-		if (year < DATE_MIN_YEAR) {
-			return false;
-		} else if (year == DATE_MIN_YEAR) {
-			if (month < DATE_MIN_MONTH || (month == DATE_MIN_MONTH && day < DATE_MIN_DAY)) {
-				return false;
-			}
-		}
-	}
-	if (year >= DATE_MAX_YEAR) {
-		if (year > DATE_MAX_YEAR) {
-			return false;
-		} else if (year == DATE_MAX_YEAR) {
-			if (month > DATE_MAX_MONTH || (month == DATE_MAX_MONTH && day > DATE_MAX_DAY)) {
-				return false;
-			}
-		}
-	}
-	return Date::IsLeapYear(year) ? day <= Date::LEAP_DAYS[month] : day <= Date::NORMAL_DAYS[month];
-}
-
-int32_t Date::MonthDays(int32_t year, int32_t month) {
-	D_ASSERT(month >= 1 && month <= 12);
-	return Date::IsLeapYear(year) ? Date::LEAP_DAYS[month] : Date::NORMAL_DAYS[month];
-}
-
-date_t Date::EpochDaysToDate(int32_t epoch) {
-	return (date_t)epoch;
-}
-
-int32_t Date::EpochDays(date_t date) {
-	return date.days;
-}
-
-date_t Date::EpochToDate(int64_t epoch) {
-	return date_t(UnsafeNumericCast<int32_t>(epoch / Interval::SECS_PER_DAY));
-}
-
-int64_t Date::Epoch(date_t date) {
-	return ((int64_t)date.days) * Interval::SECS_PER_DAY;
-}
-
-int64_t Date::EpochNanoseconds(date_t date) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::MICROS_PER_DAY * 1000,
-	                                                               result)) {
-		throw ConversionException("Could not convert DATE (%s) to nanoseconds", Date::ToString(date));
-	}
-	return result;
-}
-
-int64_t Date::EpochMicroseconds(date_t date) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::MICROS_PER_DAY, result)) {
-		throw ConversionException("Could not convert DATE (%s) to microseconds", Date::ToString(date));
-	}
-	return result;
-}
-
-int64_t Date::EpochMilliseconds(date_t date) {
-	int64_t result;
-	const auto MILLIS_PER_DAY = Interval::MICROS_PER_DAY / Interval::MICROS_PER_MSEC;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, MILLIS_PER_DAY, result)) {
-		throw ConversionException("Could not convert DATE (%s) to milliseconds", Date::ToString(date));
-	}
-	return result;
-}
-
-int32_t Date::ExtractYear(date_t d) {
-	int32_t year, year_offset;
-	Date::ExtractYearOffset(d.days, year, year_offset);
-	return year;
-}
-
-int32_t Date::ExtractMonth(date_t date) {
-	int32_t out_year, out_month, out_day;
-	Date::Convert(date, out_year, out_month, out_day);
-	return out_month;
-}
-
-int32_t Date::ExtractDay(date_t date) {
-	int32_t out_year, out_month, out_day;
-	Date::Convert(date, out_year, out_month, out_day);
-	return out_day;
-}
-
-int32_t Date::ExtractDayOfTheYear(date_t date) {
-	int32_t year, year_offset;
-	Date::ExtractYearOffset(date.days, year, year_offset);
-	return date.days - Date::CUMULATIVE_YEAR_DAYS[year_offset] + 1;
-}
-
-int64_t Date::ExtractJulianDay(date_t date) {
-	// Julian Day 0 is (-4713, 11, 24) in the proleptic Gregorian calendar.
-	static const int64_t JULIAN_EPOCH = -2440588;
-	return date.days - JULIAN_EPOCH;
-}
-
-int32_t Date::ExtractISODayOfTheWeek(date_t date) {
-	// date of 0 is 1970-01-01, which was a Thursday (4)
-	// -7 = 4
-	// -6 = 5
-	// -5 = 6
-	// -4 = 7
-	// -3 = 1
-	// -2 = 2
-	// -1 = 3
-	// 0  = 4
-	// 1  = 5
-	// 2  = 6
-	// 3  = 7
-	// 4  = 1
-	// 5  = 2
-	// 6  = 3
-	// 7  = 4
-	if (date.days < 0) {
-		// negative date: start off at 4 and cycle downwards
-		return UnsafeNumericCast<int32_t>((7 - ((-int64_t(date.days) + 3) % 7)));
-	} else {
-		// positive date: start off at 4 and cycle upwards
-		return UnsafeNumericCast<int32_t>(((int64_t(date.days) + 3) % 7) + 1);
-	}
-}
-
-template <typename T>
-static T PythonDivMod(const T &x, const T &y, T &r) {
-	// D_ASSERT(y > 0);
-	T quo = x / y;
-	r = x - quo * y;
-	if (r < 0) {
-		--quo;
-		r += y;
-	}
-	// D_ASSERT(0 <= r && r < y);
-	return quo;
-}
-
-static date_t GetISOWeekOne(int32_t year) {
-	const auto first_day = Date::FromDate(year, 1, 1); /* ord of 1/1 */
-	/* 0 if 1/1 is a Monday, 1 if a Tue, etc. */
-	const auto first_weekday = Date::ExtractISODayOfTheWeek(first_day) - 1;
-	/* ordinal of closest Monday at or before 1/1 */
-	auto week1_monday = first_day - first_weekday;
-
-	if (first_weekday > 3) { /* if 1/1 was Fri, Sat, Sun */
-		week1_monday += 7;
-	}
-
-	return week1_monday;
-}
-
-static int32_t GetISOYearWeek(const date_t date, int32_t &year) {
-	int32_t month, day;
-	Date::Convert(date, year, month, day);
-	auto week1_monday = GetISOWeekOne(year);
-	auto week = PythonDivMod((date.days - week1_monday.days), 7, day);
-	if (week < 0) {
-		week1_monday = GetISOWeekOne(--year);
-		week = PythonDivMod((date.days - week1_monday.days), 7, day);
-	} else if (week >= 52 && date >= GetISOWeekOne(year + 1)) {
-		++year;
-		week = 0;
-	}
-
-	return week + 1;
-}
-
-void Date::ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week) {
-	week = GetISOYearWeek(date, year);
-}
-
-int32_t Date::ExtractISOWeekNumber(date_t date) {
-	int32_t year, week;
-	ExtractISOYearWeek(date, year, week);
-	return week;
-}
-
-int32_t Date::ExtractISOYearNumber(date_t date) {
-	int32_t year, week;
-	ExtractISOYearWeek(date, year, week);
-	return year;
-}
-
-int32_t Date::ExtractWeekNumberRegular(date_t date, bool monday_first) {
-	int32_t year, month, day;
-	Date::Convert(date, year, month, day);
-	month -= 1;
-	day -= 1;
-	// get the day of the year
-	auto day_of_the_year =
-	    (Date::IsLeapYear(year) ? Date::CUMULATIVE_LEAP_DAYS[month] : Date::CUMULATIVE_DAYS[month]) + day;
-	// now figure out the first monday or sunday of the year
-	// what day is January 1st?
-	auto day_of_jan_first = Date::ExtractISODayOfTheWeek(Date::FromDate(year, 1, 1));
-	// monday = 1, sunday = 7
-	int32_t first_week_start;
-	if (monday_first) {
-		// have to find next "1"
-		if (day_of_jan_first == 1) {
-			// jan 1 is monday: starts immediately
-			first_week_start = 0;
-		} else {
-			// jan 1 is not monday: count days until next monday
-			first_week_start = 8 - day_of_jan_first;
-		}
-	} else {
-		first_week_start = 7 - day_of_jan_first;
-	}
-	if (day_of_the_year < first_week_start) {
-		// day occurs before first week starts: week 0
-		return 0;
-	}
-	return ((day_of_the_year - first_week_start) / 7) + 1;
-}
-
-// Returns the date of the monday of the current week.
-date_t Date::GetMondayOfCurrentWeek(date_t date) {
-	int32_t dotw = Date::ExtractISODayOfTheWeek(date);
-	return date - (dotw - 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/decimal.cpp b/src/duckdb/src/common/types/decimal.cpp
deleted file mode 100644
index 5ecb39a0a..000000000
--- a/src/duckdb/src/common/types/decimal.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/common/types/decimal.hpp"
-
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-template <class SIGNED>
-string TemplatedDecimalToString(SIGNED value, uint8_t width, uint8_t scale) {
-	auto len = DecimalToString::DecimalLength<SIGNED>(value, width, scale);
-	auto data = make_unsafe_uniq_array_uninitialized<char>(UnsafeNumericCast<size_t>(len + 1));
-	DecimalToString::FormatDecimal<SIGNED>(value, width, scale, data.get(), UnsafeNumericCast<idx_t>(len));
-	return string(data.get(), UnsafeNumericCast<uint32_t>(len));
-}
-
-string Decimal::ToString(int16_t value, uint8_t width, uint8_t scale) {
-	return TemplatedDecimalToString<int16_t>(value, width, scale);
-}
-
-string Decimal::ToString(int32_t value, uint8_t width, uint8_t scale) {
-	return TemplatedDecimalToString<int32_t>(value, width, scale);
-}
-
-string Decimal::ToString(int64_t value, uint8_t width, uint8_t scale) {
-	return TemplatedDecimalToString<int64_t>(value, width, scale);
-}
-
-string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
-	auto len = DecimalToString::DecimalLength(value, width, scale);
-	auto data = make_unsafe_uniq_array_uninitialized<char>(UnsafeNumericCast<size_t>(len + 1));
-	DecimalToString::FormatDecimal(value, width, scale, data.get(), UnsafeNumericCast<idx_t>(len));
-	return string(data.get(), UnsafeNumericCast<uint32_t>(len));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/hash.cpp b/src/duckdb/src/common/types/hash.cpp
deleted file mode 100644
index 83a1ef223..000000000
--- a/src/duckdb/src/common/types/hash.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#include "duckdb/common/types/hash.hpp"
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-
-#include <functional>
-#include <cmath>
-
-namespace duckdb {
-
-template <>
-hash_t Hash(uint64_t val) {
-	return MurmurHash64(val);
-}
-
-template <>
-hash_t Hash(int64_t val) {
-	return MurmurHash64((uint64_t)val);
-}
-
-template <>
-hash_t Hash(hugeint_t val) {
-	return MurmurHash64(val.lower) ^ MurmurHash64(static_cast<uint64_t>(val.upper));
-}
-
-template <>
-hash_t Hash(uhugeint_t val) {
-	return MurmurHash64(val.lower) ^ MurmurHash64(val.upper);
-}
-
-template <class T>
-struct FloatingPointEqualityTransform {
-	static void OP(T &val) {
-		if (val == (T)0.0) {
-			// Turn negative zero into positive zero
-			val = (T)0.0;
-		} else if (std::isnan(val)) {
-			val = std::numeric_limits<T>::quiet_NaN();
-		}
-	}
-};
-
-template <>
-hash_t Hash(float val) {
-	static_assert(sizeof(float) == sizeof(uint32_t), "");
-	FloatingPointEqualityTransform<float>::OP(val);
-	uint32_t uval = Load<uint32_t>(const_data_ptr_cast(&val));
-	return MurmurHash64(uval);
-}
-
-template <>
-hash_t Hash(double val) {
-	static_assert(sizeof(double) == sizeof(uint64_t), "");
-	FloatingPointEqualityTransform<double>::OP(val);
-	uint64_t uval = Load<uint64_t>(const_data_ptr_cast(&val));
-	return MurmurHash64(uval);
-}
-
-template <>
-hash_t Hash(interval_t val) {
-	int64_t months, days, micros;
-	val.Normalize(months, days, micros);
-	return Hash(days) ^ Hash(months) ^ Hash(micros);
-}
-
-template <>
-hash_t Hash(const char *str) {
-	return Hash(str, strlen(str));
-}
-
-template <>
-hash_t Hash(string_t val) {
-	return Hash(val.GetData(), val.GetSize());
-}
-
-template <>
-hash_t Hash(char *val) {
-	return Hash<const char *>(val);
-}
-
-// MIT License
-// Copyright (c) 2018-2021 Martin Ankerl
-// https://github.com/martinus/robin-hood-hashing/blob/3.11.5/LICENSE
-hash_t HashBytes(void *ptr, size_t len) noexcept {
-	static constexpr uint64_t M = UINT64_C(0xc6a4a7935bd1e995);
-	static constexpr uint64_t SEED = UINT64_C(0xe17a1465);
-	static constexpr unsigned int R = 47;
-
-	auto const *const data64 = static_cast<uint64_t const *>(ptr);
-	uint64_t h = SEED ^ (len * M);
-
-	size_t const n_blocks = len / 8;
-	for (size_t i = 0; i < n_blocks; ++i) {
-		auto k = Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(data64 + i));
-
-		k *= M;
-		k ^= k >> R;
-		k *= M;
-
-		h ^= k;
-		h *= M;
-	}
-
-	auto const *const data8 = reinterpret_cast<uint8_t const *>(data64 + n_blocks);
-	switch (len & 7U) {
-	case 7:
-		h ^= static_cast<uint64_t>(data8[6]) << 48U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 6:
-		h ^= static_cast<uint64_t>(data8[5]) << 40U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 5:
-		h ^= static_cast<uint64_t>(data8[4]) << 32U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 4:
-		h ^= static_cast<uint64_t>(data8[3]) << 24U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 3:
-		h ^= static_cast<uint64_t>(data8[2]) << 16U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 2:
-		h ^= static_cast<uint64_t>(data8[1]) << 8U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 1:
-		h ^= static_cast<uint64_t>(data8[0]);
-		h *= M;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	default:
-		break;
-	}
-	h ^= h >> R;
-	h *= M;
-	h ^= h >> R;
-	return static_cast<hash_t>(h);
-}
-
-hash_t Hash(const char *val, size_t size) {
-	return HashBytes((void *)val, size);
-}
-
-hash_t Hash(uint8_t *val, size_t size) {
-	return HashBytes((void *)val, size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/hugeint.cpp b/src/duckdb/src/common/types/hugeint.cpp
deleted file mode 100644
index b19a03b70..000000000
--- a/src/duckdb/src/common/types/hugeint.cpp
+++ /dev/null
@@ -1,998 +0,0 @@
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-#include <cmath>
-#include <limits>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// String Conversion
-//===--------------------------------------------------------------------===//
-const hugeint_t Hugeint::POWERS_OF_TEN[] {
-    hugeint_t(1),
-    hugeint_t(10),
-    hugeint_t(100),
-    hugeint_t(1000),
-    hugeint_t(10000),
-    hugeint_t(100000),
-    hugeint_t(1000000),
-    hugeint_t(10000000),
-    hugeint_t(100000000),
-    hugeint_t(1000000000),
-    hugeint_t(10000000000),
-    hugeint_t(100000000000),
-    hugeint_t(1000000000000),
-    hugeint_t(10000000000000),
-    hugeint_t(100000000000000),
-    hugeint_t(1000000000000000),
-    hugeint_t(10000000000000000),
-    hugeint_t(100000000000000000),
-    hugeint_t(1000000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10),
-    hugeint_t(1000000000000000000) * hugeint_t(100),
-    hugeint_t(1000000000000000000) * hugeint_t(1000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000) * hugeint_t(10),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000) * hugeint_t(100)};
-
-//===--------------------------------------------------------------------===//
-// Negate
-//===--------------------------------------------------------------------===//
-
-template <>
-void Hugeint::NegateInPlace<false>(hugeint_t &input) {
-	input.lower = NumericLimits<uint64_t>::Maximum() - input.lower + 1ull;
-	input.upper = -1 - input.upper + (input.lower == 0);
-}
-
-bool Hugeint::TryNegate(hugeint_t input, hugeint_t &result) {
-	if (input.upper == NumericLimits<int64_t>::Minimum() && input.lower == 0) {
-		return false;
-	}
-	NegateInPlace<false>(input);
-	result = input;
-	return true;
-}
-
-hugeint_t Hugeint::Abs(hugeint_t n) {
-	if (n < 0) {
-		return Hugeint::Negate(n);
-	} else {
-		return n;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Divide
-//===--------------------------------------------------------------------===//
-
-static uint8_t PositiveHugeintHighestBit(hugeint_t bits) {
-	uint8_t out = 0;
-	if (bits.upper) {
-		out = 64;
-		uint64_t up = static_cast<uint64_t>(bits.upper);
-		while (up) {
-			up >>= 1;
-			out++;
-		}
-	} else {
-		uint64_t low = bits.lower;
-		while (low) {
-			low >>= 1;
-			out++;
-		}
-	}
-	return out;
-}
-
-static bool PositiveHugeintIsBitSet(hugeint_t lhs, uint8_t bit_position) {
-	if (bit_position < 64) {
-		return lhs.lower & (uint64_t(1) << uint64_t(bit_position));
-	} else {
-		return static_cast<uint64_t>(lhs.upper) & (uint64_t(1) << uint64_t(bit_position - 64));
-	}
-}
-
-static hugeint_t PositiveHugeintLeftShift(hugeint_t lhs, uint32_t amount) {
-	D_ASSERT(amount > 0 && amount < 64);
-	hugeint_t result;
-	result.lower = lhs.lower << amount;
-	result.upper =
-	    UnsafeNumericCast<int64_t>((UnsafeNumericCast<uint64_t>(lhs.upper) << amount) + (lhs.lower >> (64 - amount)));
-	return result;
-}
-
-hugeint_t Hugeint::DivModPositive(hugeint_t lhs, uint64_t rhs, uint64_t &remainder) {
-	D_ASSERT(lhs.upper >= 0);
-	// DivMod code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// initialize the result and remainder to 0
-	hugeint_t div_result;
-	div_result.lower = 0;
-	div_result.upper = 0;
-	remainder = 0;
-
-	uint8_t highest_bit_set = PositiveHugeintHighestBit(lhs);
-	// now iterate over the amount of bits that are set in the LHS
-	for (uint8_t x = highest_bit_set; x > 0; x--) {
-		// left-shift the current result and remainder by 1
-		div_result = PositiveHugeintLeftShift(div_result, 1);
-		remainder <<= 1;
-		// we get the value of the bit at position X, where position 0 is the least-significant bit
-		if (PositiveHugeintIsBitSet(lhs, x - 1)) {
-			// increment the remainder
-			remainder++;
-		}
-		if (remainder >= rhs) {
-			// the remainder has passed the division multiplier: add one to the divide result
-			remainder -= rhs;
-			div_result.lower++;
-			if (div_result.lower == 0) {
-				// overflow
-				div_result.upper++;
-			}
-		}
-	}
-	return div_result;
-}
-
-string Hugeint::ToString(hugeint_t input) {
-	uint64_t remainder;
-	string result;
-	if (input == NumericLimits<hugeint_t>::Minimum()) {
-		return string(Hugeint::HUGEINT_MINIMUM_STRING);
-	}
-	bool negative = input.upper < 0;
-	if (negative) {
-		NegateInPlace(input);
-	}
-	while (true) {
-		if (!input.lower && !input.upper) {
-			break;
-		}
-		input = Hugeint::DivModPositive(input, 10, remainder);
-		result = string(1, UnsafeNumericCast<char>('0' + remainder)) + result; // NOLINT
-	}
-	if (result.empty()) {
-		// value is zero
-		return "0";
-	}
-	return negative ? "-" + result : result;
-}
-
-//===--------------------------------------------------------------------===//
-// Multiply
-//===--------------------------------------------------------------------===//
-
-// Multiply with overflow checks
-bool Hugeint::TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result) {
-	// Check if one of the sides is hugeint_t minimum, as that can't be negated.
-	// You can only multiply the minimum by 0 or 1, any other value will result in overflow
-	if (lhs == NumericLimits<hugeint_t>::Minimum() || rhs == NumericLimits<hugeint_t>::Minimum()) {
-		if (lhs == 0 || rhs == 0) {
-			result = 0;
-			return true;
-		}
-		if (lhs == 1 || rhs == 1) {
-			result = NumericLimits<hugeint_t>::Minimum();
-			return true;
-		}
-		return false;
-	}
-
-	bool lhs_negative = lhs.upper < 0;
-	bool rhs_negative = rhs.upper < 0;
-	if (lhs_negative && !TryNegate(lhs, lhs)) {
-		return false;
-	}
-	if (rhs_negative && !TryNegate(rhs, rhs)) {
-		return false;
-	}
-
-#if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
-	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
-	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
-	__uint128_t result_i128;
-	if (__builtin_mul_overflow(left, right, &result_i128)) {
-		return false;
-	}
-	uint64_t upper = uint64_t(result_i128 >> 64);
-	if (upper & 0x8000000000000000) {
-		return false;
-	}
-	result.upper = int64_t(upper);
-	result.lower = uint64_t(result_i128 & 0xffffffffffffffff);
-#else
-	// Multiply code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// split values into 4 32-bit parts
-	uint64_t top[4] = {uint64_t(lhs.upper) >> 32, uint64_t(lhs.upper) & 0xffffffff, lhs.lower >> 32,
-	                   lhs.lower & 0xffffffff};
-	uint64_t bottom[4] = {uint64_t(rhs.upper) >> 32, uint64_t(rhs.upper) & 0xffffffff, rhs.lower >> 32,
-	                      rhs.lower & 0xffffffff};
-	uint64_t products[4][4];
-
-	// multiply each component of the values
-	for (auto x = 0; x < 4; x++) {
-		for (auto y = 0; y < 4; y++) {
-			products[x][y] = top[x] * bottom[y];
-		}
-	}
-
-	// if any of these products are set to a non-zero value, there is always an overflow
-	if (products[0][0] || products[0][1] || products[0][2] || products[1][0] || products[2][0] || products[1][1]) {
-		return false;
-	}
-	// if the high bits of any of these are set, there is always an overflow
-	if ((products[0][3] & 0xffffffff80000000) || (products[1][2] & 0xffffffff80000000) ||
-	    (products[2][1] & 0xffffffff80000000) || (products[3][0] & 0xffffffff80000000)) {
-		return false;
-	}
-
-	// otherwise we merge the result of the different products together in-order
-
-	// first row
-	uint64_t fourth32 = (products[3][3] & 0xffffffff);
-	uint64_t third32 = (products[3][2] & 0xffffffff) + (products[3][3] >> 32);
-	uint64_t second32 = (products[3][1] & 0xffffffff) + (products[3][2] >> 32);
-	uint64_t first32 = (products[3][0] & 0xffffffff) + (products[3][1] >> 32);
-
-	// second row
-	third32 += (products[2][3] & 0xffffffff);
-	second32 += (products[2][2] & 0xffffffff) + (products[2][3] >> 32);
-	first32 += (products[2][1] & 0xffffffff) + (products[2][2] >> 32);
-
-	// third row
-	second32 += (products[1][3] & 0xffffffff);
-	first32 += (products[1][2] & 0xffffffff) + (products[1][3] >> 32);
-
-	// fourth row
-	first32 += (products[0][3] & 0xffffffff);
-
-	// move carry to next digit
-	third32 += fourth32 >> 32;
-	second32 += third32 >> 32;
-	first32 += second32 >> 32;
-
-	// check if the combination of the different products resulted in an overflow
-	if (first32 & 0xffffff80000000) {
-		return false;
-	}
-
-	// remove carry from current digit
-	fourth32 &= 0xffffffff;
-	third32 &= 0xffffffff;
-	second32 &= 0xffffffff;
-	first32 &= 0xffffffff;
-
-	// combine components
-	result.lower = (third32 << 32) | fourth32;
-	result.upper = (first32 << 32) | second32;
-#endif
-	if (lhs_negative ^ rhs_negative) {
-		NegateInPlace<false>(result);
-	}
-	return true;
-}
-
-// Multiply without overflow check
-template <>
-hugeint_t Hugeint::Multiply<false>(hugeint_t lhs, hugeint_t rhs) {
-	hugeint_t result;
-	bool lhs_negative = lhs.upper < 0;
-	bool rhs_negative = rhs.upper < 0;
-	if (lhs_negative) {
-		NegateInPlace<false>(lhs);
-	}
-	if (rhs_negative) {
-		NegateInPlace<false>(rhs);
-	}
-
-#if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
-	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
-	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
-	__uint128_t result_i128;
-	result_i128 = left * right;
-	uint64_t upper = uint64_t(result_i128 >> 64);
-	result.upper = int64_t(upper);
-	result.lower = uint64_t(result_i128 & 0xffffffffffffffff);
-#else
-	// Multiply code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// split values into 4 32-bit parts
-	uint64_t top[4] = {uint64_t(lhs.upper) >> 32, uint64_t(lhs.upper) & 0xffffffff, lhs.lower >> 32,
-	                   lhs.lower & 0xffffffff};
-	uint64_t bottom[4] = {uint64_t(rhs.upper) >> 32, uint64_t(rhs.upper) & 0xffffffff, rhs.lower >> 32,
-	                      rhs.lower & 0xffffffff};
-	uint64_t products[4][4];
-
-	// multiply each component of the values
-	for (auto x = 0; x < 4; x++) {
-		for (auto y = 0; y < 4; y++) {
-			products[x][y] = top[x] * bottom[y];
-		}
-	}
-
-	// first row
-	uint64_t fourth32 = (products[3][3] & 0xffffffff);
-	uint64_t third32 = (products[3][2] & 0xffffffff) + (products[3][3] >> 32);
-	uint64_t second32 = (products[3][1] & 0xffffffff) + (products[3][2] >> 32);
-	uint64_t first32 = (products[3][0] & 0xffffffff) + (products[3][1] >> 32);
-
-	// second row
-	third32 += (products[2][3] & 0xffffffff);
-	second32 += (products[2][2] & 0xffffffff) + (products[2][3] >> 32);
-	first32 += (products[2][1] & 0xffffffff) + (products[2][2] >> 32);
-
-	// third row
-	second32 += (products[1][3] & 0xffffffff);
-	first32 += (products[1][2] & 0xffffffff) + (products[1][3] >> 32);
-
-	// fourth row
-	first32 += (products[0][3] & 0xffffffff);
-
-	// move carry to next digit
-	third32 += fourth32 >> 32;
-	second32 += third32 >> 32;
-	first32 += second32 >> 32;
-
-	// remove carry from current digit
-	fourth32 &= 0xffffffff;
-	third32 &= 0xffffffff;
-	second32 &= 0xffffffff;
-	first32 &= 0xffffffff;
-
-	// combine components
-	result.lower = (third32 << 32) | fourth32;
-	result.upper = (first32 << 32) | second32;
-#endif
-	if (lhs_negative ^ rhs_negative) {
-		NegateInPlace<false>(result);
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Divide
-//===--------------------------------------------------------------------===//
-
-int Sign(hugeint_t n) {
-	return ((n > 0) - (n < 0));
-}
-
-hugeint_t Abs(hugeint_t n) {
-	D_ASSERT(n != NumericLimits<hugeint_t>::Minimum());
-	return (n * Sign(n));
-}
-
-static hugeint_t DivModMinimum(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder) {
-	D_ASSERT(lhs == NumericLimits<hugeint_t>::Minimum() || rhs == NumericLimits<hugeint_t>::Minimum());
-	if (rhs == NumericLimits<hugeint_t>::Minimum()) {
-		if (lhs == NumericLimits<hugeint_t>::Minimum()) {
-			remainder = 0;
-			return 1;
-		}
-		remainder = lhs;
-		return 0;
-	}
-
-	// Add 1 to minimum and run through DivMod again
-	hugeint_t result = Hugeint::DivMod(NumericLimits<hugeint_t>::Minimum() + 1, rhs, remainder);
-
-	// If the 1 mattered we need to adjust the result, otherwise the remainder
-	if (Abs(remainder) + 1 == Abs(rhs)) {
-		result -= Sign(rhs);
-		remainder = 0;
-	} else {
-		remainder -= 1;
-	}
-	return result;
-}
-
-// No overflow checks
-hugeint_t Hugeint::DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder) {
-	if (rhs == 0) {
-		remainder = lhs;
-		return hugeint_t(0);
-	}
-
-	// Check if one of the sides is hugeint_t minimum, as that can't be negated.
-	if (lhs == NumericLimits<hugeint_t>::Minimum() || rhs == NumericLimits<hugeint_t>::Minimum()) {
-		return DivModMinimum(lhs, rhs, remainder);
-	}
-
-	bool lhs_negative = lhs.upper < 0;
-	bool rhs_negative = rhs.upper < 0;
-	if (lhs_negative) {
-		Hugeint::NegateInPlace<false>(lhs);
-	}
-	if (rhs_negative) {
-		Hugeint::NegateInPlace<false>(rhs);
-	}
-	// DivMod code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// initialize the result and remainder to 0
-	hugeint_t div_result;
-	div_result.lower = 0;
-	div_result.upper = 0;
-	remainder.lower = 0;
-	remainder.upper = 0;
-
-	uint8_t highest_bit_set = PositiveHugeintHighestBit(lhs);
-	// now iterate over the amount of bits that are set in the LHS
-	for (uint8_t x = highest_bit_set; x > 0; x--) {
-		// left-shift the current result and remainder by 1
-		div_result = PositiveHugeintLeftShift(div_result, 1);
-		remainder = PositiveHugeintLeftShift(remainder, 1);
-
-		// we get the value of the bit at position X, where position 0 is the least-significant bit
-		if (PositiveHugeintIsBitSet(lhs, x - 1)) {
-			remainder += 1;
-		}
-		if (Hugeint::GreaterThanEquals(remainder, rhs)) {
-			// the remainder has passed the division multiplier: add one to the divide result
-			remainder -= rhs;
-			div_result += 1;
-		}
-	}
-	if (lhs_negative ^ rhs_negative) {
-		Hugeint::NegateInPlace<false>(div_result);
-	}
-	if (lhs_negative) {
-		Hugeint::NegateInPlace<false>(remainder);
-	}
-	return div_result;
-}
-
-bool Hugeint::TryDivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &result, hugeint_t &remainder) {
-	// No division by zero
-	if (rhs == 0) {
-		return false;
-	}
-
-	// division only has one reason to overflow: MINIMUM / -1
-	if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
-		return false;
-	}
-
-	result = Hugeint::DivMod(lhs, rhs, remainder);
-	return true;
-}
-
-template <>
-hugeint_t Hugeint::Divide<false>(hugeint_t lhs, hugeint_t rhs) {
-	hugeint_t remainder;
-	return Hugeint::DivMod(lhs, rhs, remainder);
-}
-
-template <>
-hugeint_t Hugeint::Modulo<false>(hugeint_t lhs, hugeint_t rhs) {
-	hugeint_t remainder;
-	(void)Hugeint::DivMod(lhs, rhs, remainder);
-	return remainder;
-}
-
-//===--------------------------------------------------------------------===//
-// Add/Subtract
-//===--------------------------------------------------------------------===//
-bool Hugeint::TryAddInPlace(hugeint_t &lhs, hugeint_t rhs) {
-	int overflow = lhs.lower + rhs.lower < lhs.lower;
-	if (rhs.upper >= 0) {
-		// RHS is positive: check for overflow
-		if (lhs.upper > (std::numeric_limits<int64_t>::max() - rhs.upper - overflow)) {
-			return false;
-		}
-		lhs.upper = lhs.upper + overflow + rhs.upper;
-	} else {
-		// RHS is negative: check for underflow
-		if (lhs.upper < std::numeric_limits<int64_t>::min() - rhs.upper - overflow) {
-			return false;
-		}
-		lhs.upper = lhs.upper + (overflow + rhs.upper);
-	}
-	lhs.lower += rhs.lower;
-	return true;
-}
-
-bool Hugeint::TrySubtractInPlace(hugeint_t &lhs, hugeint_t rhs) {
-	// underflow
-	int underflow = lhs.lower - rhs.lower > lhs.lower;
-	if (rhs.upper >= 0) {
-		// RHS is positive: check for underflow
-		if (lhs.upper < (std::numeric_limits<int64_t>::min() + rhs.upper + underflow)) {
-			return false;
-		}
-		lhs.upper = (lhs.upper - rhs.upper) - underflow;
-	} else {
-		// RHS is negative: check for overflow
-		if (lhs.upper > std::numeric_limits<int64_t>::min() &&
-		    lhs.upper - 1 >= (std::numeric_limits<int64_t>::max() + rhs.upper + underflow)) {
-			return false;
-		}
-		lhs.upper = lhs.upper - (rhs.upper + underflow);
-	}
-	lhs.lower -= rhs.lower;
-	return true;
-}
-
-template <>
-hugeint_t Hugeint::Add<false>(hugeint_t lhs, hugeint_t rhs) {
-	return lhs + rhs;
-}
-
-template <>
-hugeint_t Hugeint::Subtract<false>(hugeint_t lhs, hugeint_t rhs) {
-	return lhs - rhs;
-}
-
-//===--------------------------------------------------------------------===//
-// Hugeint Cast/Conversion
-//===--------------------------------------------------------------------===//
-template <class DST, bool SIGNED = true>
-bool HugeintTryCastInteger(hugeint_t input, DST &result) {
-	switch (input.upper) {
-	case 0:
-		// positive number: check if the positive number is in range
-		if (input.lower <= uint64_t(NumericLimits<DST>::Maximum())) {
-			result = DST(input.lower);
-			return true;
-		}
-		break;
-	case -1:
-		if (!SIGNED) {
-			return false;
-		}
-		// negative number: check if the negative number is in range
-		if (input.lower >= NumericLimits<uint64_t>::Maximum() - uint64_t(NumericLimits<DST>::Maximum())) {
-			result = -DST(NumericLimits<uint64_t>::Maximum() - input.lower) - 1;
-			return true;
-		}
-		break;
-	default:
-		break;
-	}
-	return false;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int8_t &result) {
-	return HugeintTryCastInteger<int8_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int16_t &result) {
-	return HugeintTryCastInteger<int16_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int32_t &result) {
-	return HugeintTryCastInteger<int32_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int64_t &result) {
-	return HugeintTryCastInteger<int64_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint8_t &result) {
-	return HugeintTryCastInteger<uint8_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint16_t &result) {
-	return HugeintTryCastInteger<uint16_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint32_t &result) {
-	return HugeintTryCastInteger<uint32_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint64_t &result) {
-	return HugeintTryCastInteger<uint64_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, hugeint_t &result) {
-	result = input;
-	return true;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uhugeint_t &result) {
-	if (input < 0) {
-		return false;
-	}
-
-	result.lower = input.lower;
-	result.upper = UnsafeNumericCast<uint64_t>(input.upper);
-	return true;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, float &result) {
-	double dbl_result;
-	Hugeint::TryCast(input, dbl_result);
-	result = (float)dbl_result;
-	return true;
-}
-
-template <class REAL_T>
-bool CastBigintToFloating(hugeint_t input, REAL_T &result) {
-	switch (input.upper) {
-	case -1:
-		// special case for upper = -1 to avoid rounding issues in small negative numbers
-		result = -REAL_T(NumericLimits<uint64_t>::Maximum() - input.lower) - 1;
-		break;
-	default:
-		result = REAL_T(input.lower) + REAL_T(input.upper) * (REAL_T(NumericLimits<uint64_t>::Maximum()) + 1);
-		break;
-	}
-	return true;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, double &result) {
-	return CastBigintToFloating<double>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, long double &result) {
-	return CastBigintToFloating<long double>(input, result);
-}
-
-template <class DST>
-hugeint_t HugeintConvertInteger(DST input) {
-	hugeint_t result;
-	result.lower = (uint64_t)input;
-	result.upper = (input < 0) * -1;
-	return result;
-}
-
-template <>
-bool Hugeint::TryConvert(int8_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int8_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(const char *value, hugeint_t &result) {
-	auto len = strlen(value);
-	string_t string_val(value, UnsafeNumericCast<uint32_t>(len));
-	return TryCast::Operation<string_t, hugeint_t>(string_val, result, true);
-}
-
-template <>
-bool Hugeint::TryConvert(int16_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int16_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(int32_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int32_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(int64_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int64_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint8_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint8_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint16_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint16_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint32_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint32_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint64_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint64_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(hugeint_t value, hugeint_t &result) {
-	result = value;
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(float value, hugeint_t &result) {
-	return Hugeint::TryConvert(double(value), result);
-}
-
-template <class REAL_T>
-bool ConvertFloatingToBigint(REAL_T value, hugeint_t &result) {
-	if (!Value::IsFinite<REAL_T>(value)) {
-		return false;
-	}
-	if (value <= -170141183460469231731687303715884105728.0 || value >= 170141183460469231731687303715884105727.0) {
-		return false;
-	}
-	bool negative = value < 0;
-	if (negative) {
-		value = -value;
-	}
-	result.lower = (uint64_t)fmod(value, REAL_T(NumericLimits<uint64_t>::Maximum()));
-	result.upper = (int64_t)(value / REAL_T(NumericLimits<uint64_t>::Maximum()));
-	if (negative) {
-		Hugeint::NegateInPlace(result);
-	}
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(double value, hugeint_t &result) {
-	return ConvertFloatingToBigint<double>(value, result);
-}
-
-template <>
-bool Hugeint::TryConvert(long double value, hugeint_t &result) {
-	return ConvertFloatingToBigint<long double>(value, result);
-}
-
-//===--------------------------------------------------------------------===//
-// hugeint_t operators
-//===--------------------------------------------------------------------===//
-hugeint_t::hugeint_t(int64_t value) {
-	auto result = Hugeint::Convert(value);
-	this->lower = result.lower;
-	this->upper = result.upper;
-}
-
-bool hugeint_t::operator==(const hugeint_t &rhs) const {
-	return Hugeint::Equals(*this, rhs);
-}
-
-bool hugeint_t::operator!=(const hugeint_t &rhs) const {
-	return Hugeint::NotEquals(*this, rhs);
-}
-
-bool hugeint_t::operator<(const hugeint_t &rhs) const {
-	return Hugeint::LessThan(*this, rhs);
-}
-
-bool hugeint_t::operator<=(const hugeint_t &rhs) const {
-	return Hugeint::LessThanEquals(*this, rhs);
-}
-
-bool hugeint_t::operator>(const hugeint_t &rhs) const {
-	return Hugeint::GreaterThan(*this, rhs);
-}
-
-bool hugeint_t::operator>=(const hugeint_t &rhs) const {
-	return Hugeint::GreaterThanEquals(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator+(const hugeint_t &rhs) const {
-	return hugeint_t(upper + rhs.upper + ((lower + rhs.lower) < lower), lower + rhs.lower);
-}
-
-hugeint_t hugeint_t::operator-(const hugeint_t &rhs) const {
-	return hugeint_t(upper - rhs.upper - ((lower - rhs.lower) > lower), lower - rhs.lower);
-}
-
-hugeint_t hugeint_t::operator*(const hugeint_t &rhs) const {
-	hugeint_t result = *this;
-	result *= rhs;
-	return result;
-}
-
-hugeint_t hugeint_t::operator/(const hugeint_t &rhs) const {
-	return Hugeint::Divide<false>(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator%(const hugeint_t &rhs) const {
-	return Hugeint::Modulo<false>(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator-() const {
-	return Hugeint::Negate<false>(*this);
-}
-
-hugeint_t hugeint_t::operator>>(const hugeint_t &rhs) const {
-	hugeint_t result;
-	uint64_t shift = rhs.lower;
-	if (rhs.upper != 0 || shift >= 128) {
-		return hugeint_t(0);
-	} else if (shift == 0) {
-		return *this;
-	} else if (shift == 64) {
-		result.upper = (upper < 0) ? -1 : 0;
-		result.lower = uint64_t(upper);
-	} else if (shift < 64) {
-		// perform lower shift in unsigned integer, and mask away the most significant bit
-		result.lower = (uint64_t(upper) << (64 - shift)) | (lower >> shift);
-		result.upper = upper >> shift;
-	} else {
-		D_ASSERT(shift < 128);
-		result.lower = uint64_t(upper >> (shift - 64));
-		result.upper = (upper < 0) ? -1 : 0;
-	}
-	return result;
-}
-
-hugeint_t hugeint_t::operator<<(const hugeint_t &rhs) const {
-	if (upper < 0) {
-		return hugeint_t(0);
-	}
-	hugeint_t result;
-	uint64_t shift = rhs.lower;
-	if (rhs.upper != 0 || shift >= 128) {
-		return hugeint_t(0);
-	} else if (shift == 64) {
-		result.upper = int64_t(lower);
-		result.lower = 0;
-	} else if (shift == 0) {
-		return *this;
-	} else if (shift < 64) {
-		// perform upper shift in unsigned integer, and mask away the most significant bit
-		uint64_t upper_shift = ((uint64_t(upper) << shift) + (lower >> (64 - shift))) & 0x7FFFFFFFFFFFFFFF;
-		result.lower = lower << shift;
-		result.upper = int64_t(upper_shift);
-	} else {
-		D_ASSERT(shift < 128);
-		result.lower = 0;
-		result.upper = UnsafeNumericCast<int64_t>((lower << (shift - 64)) & 0x7FFFFFFFFFFFFFFF);
-	}
-	return result;
-}
-
-hugeint_t hugeint_t::operator&(const hugeint_t &rhs) const {
-	hugeint_t result;
-	result.lower = lower & rhs.lower;
-	result.upper = upper & rhs.upper;
-	return result;
-}
-
-hugeint_t hugeint_t::operator|(const hugeint_t &rhs) const {
-	hugeint_t result;
-	result.lower = lower | rhs.lower;
-	result.upper = upper | rhs.upper;
-	return result;
-}
-
-hugeint_t hugeint_t::operator^(const hugeint_t &rhs) const {
-	hugeint_t result;
-	result.lower = lower ^ rhs.lower;
-	result.upper = upper ^ rhs.upper;
-	return result;
-}
-
-hugeint_t hugeint_t::operator~() const {
-	hugeint_t result;
-	result.lower = ~lower;
-	result.upper = ~upper;
-	return result;
-}
-
-hugeint_t &hugeint_t::operator+=(const hugeint_t &rhs) {
-	*this = *this + rhs;
-	return *this;
-}
-hugeint_t &hugeint_t::operator-=(const hugeint_t &rhs) {
-	*this = *this - rhs;
-	return *this;
-}
-hugeint_t &hugeint_t::operator*=(const hugeint_t &rhs) {
-	*this = Hugeint::Multiply<false>(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator/=(const hugeint_t &rhs) {
-	*this = Hugeint::Divide<false>(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator%=(const hugeint_t &rhs) {
-	*this = Hugeint::Modulo<false>(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator>>=(const hugeint_t &rhs) {
-	*this = *this >> rhs;
-	return *this;
-}
-hugeint_t &hugeint_t::operator<<=(const hugeint_t &rhs) {
-	*this = *this << rhs;
-	return *this;
-}
-hugeint_t &hugeint_t::operator&=(const hugeint_t &rhs) {
-	lower &= rhs.lower;
-	upper &= rhs.upper;
-	return *this;
-}
-hugeint_t &hugeint_t::operator|=(const hugeint_t &rhs) {
-	lower |= rhs.lower;
-	upper |= rhs.upper;
-	return *this;
-}
-hugeint_t &hugeint_t::operator^=(const hugeint_t &rhs) {
-	lower ^= rhs.lower;
-	upper ^= rhs.upper;
-	return *this;
-}
-
-bool hugeint_t::operator!() const {
-	return *this == 0;
-}
-
-hugeint_t::operator bool() const {
-	return *this != 0;
-}
-
-template <class T>
-static T NarrowCast(const hugeint_t &input) {
-	// NarrowCast is supposed to truncate (take lower)
-	return static_cast<T>(input.lower);
-}
-
-hugeint_t::operator uint8_t() const {
-	return NarrowCast<uint8_t>(*this);
-}
-hugeint_t::operator uint16_t() const {
-	return NarrowCast<uint16_t>(*this);
-}
-hugeint_t::operator uint32_t() const {
-	return NarrowCast<uint32_t>(*this);
-}
-hugeint_t::operator uint64_t() const {
-	return NarrowCast<uint64_t>(*this);
-}
-hugeint_t::operator int8_t() const {
-	return NarrowCast<int8_t>(*this);
-}
-hugeint_t::operator int16_t() const {
-	return NarrowCast<int16_t>(*this);
-}
-hugeint_t::operator int32_t() const {
-	return NarrowCast<int32_t>(*this);
-}
-hugeint_t::operator int64_t() const {
-	return NarrowCast<int64_t>(*this);
-}
-hugeint_t::operator uhugeint_t() const {
-	return {static_cast<uint64_t>(this->upper), this->lower};
-}
-
-string hugeint_t::ToString() const {
-	return Hugeint::ToString(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/hyperloglog.cpp b/src/duckdb/src/common/types/hyperloglog.cpp
deleted file mode 100644
index 3ccd1f0d9..000000000
--- a/src/duckdb/src/common/types/hyperloglog.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-#include "duckdb/common/types/hyperloglog.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "hyperloglog.hpp"
-
-#include <math.h>
-
-namespace duckdb_hll {
-struct robj; // NOLINT
-}
-
-namespace duckdb {
-
-idx_t HyperLogLog::Count() const {
-	uint32_t c[Q + 2] = {0};
-	ExtractCounts(c);
-	return static_cast<idx_t>(EstimateCardinality(c));
-}
-
-//! Algorithm 2
-void HyperLogLog::Merge(const HyperLogLog &other) {
-	for (idx_t i = 0; i < M; ++i) {
-		Update(i, other.k[i]);
-	}
-}
-
-//! Algorithm 4
-void HyperLogLog::ExtractCounts(uint32_t *c) const {
-	for (idx_t i = 0; i < M; ++i) {
-		c[k[i]]++;
-	}
-}
-
-//! Taken from redis code
-static double HLLSigma(double x) {
-	if (x == 1.) {
-		return std::numeric_limits<double>::infinity();
-	}
-	double z_prime;
-	double y = 1;
-	double z = x;
-	do {
-		x *= x;
-		z_prime = z;
-		z += x * y;
-		y += y;
-	} while (z_prime != z);
-	return z;
-}
-
-//! Taken from redis code
-static double HLLTau(double x) {
-	if (x == 0. || x == 1.) {
-		return 0.;
-	}
-	double z_prime;
-	double y = 1.0;
-	double z = 1 - x;
-	do {
-		x = sqrt(x);
-		z_prime = z;
-		y *= 0.5;
-		z -= pow(1 - x, 2) * y;
-	} while (z_prime != z);
-	return z / 3;
-}
-
-//! Algorithm 6
-int64_t HyperLogLog::EstimateCardinality(uint32_t *c) {
-	auto z = M * HLLTau((double(M) - c[Q]) / double(M));
-
-	for (idx_t k = Q; k >= 1; --k) {
-		z += c[k];
-		z *= 0.5;
-	}
-
-	z += M * HLLSigma(c[0] / double(M));
-
-	return llroundl(ALPHA * M * M / z);
-}
-
-void HyperLogLog::Update(Vector &input, Vector &hash_vec, const idx_t count) {
-	UnifiedVectorFormat idata;
-	input.ToUnifiedFormat(count, idata);
-
-	UnifiedVectorFormat hdata;
-	hash_vec.ToUnifiedFormat(count, hdata);
-	const auto hashes = UnifiedVectorFormat::GetData<hash_t>(hdata);
-
-	if (hash_vec.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (idata.validity.RowIsValid(0)) {
-			InsertElement(hashes[0]);
-		}
-	} else {
-		D_ASSERT(hash_vec.GetVectorType() == VectorType::FLAT_VECTOR);
-		if (idata.validity.AllValid()) {
-			for (idx_t i = 0; i < count; ++i) {
-				const auto hash = hashes[i];
-				InsertElement(hash);
-			}
-		} else {
-			for (idx_t i = 0; i < count; ++i) {
-				if (idata.validity.RowIsValid(idata.sel->get_index(i))) {
-					const auto hash = hashes[i];
-					InsertElement(hash);
-				}
-			}
-		}
-	}
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Copy() const {
-	auto result = make_uniq<HyperLogLog>();
-	memcpy(result->k, this->k, sizeof(k));
-	D_ASSERT(result->Count() == Count());
-	return result;
-}
-
-class HLLV1 {
-public:
-	HLLV1() {
-		hll = duckdb_hll::hll_create();
-		duckdb_hll::hllSparseToDense(hll);
-	}
-
-	~HLLV1() {
-		duckdb_hll::hll_destroy(hll);
-	}
-
-public:
-	static idx_t GetSize() {
-		return duckdb_hll::get_size();
-	}
-
-	data_ptr_t GetPtr() const {
-		return data_ptr_cast((hll)->ptr);
-	}
-
-	void ToNew(HyperLogLog &new_hll) const {
-		const idx_t mult = duckdb_hll::num_registers() / HyperLogLog::M;
-		// Old implementation used more registers, so we compress the registers, losing some accuracy
-		for (idx_t i = 0; i < HyperLogLog::M; i++) {
-			uint8_t max_old = 0;
-			for (idx_t j = 0; j < mult; j++) {
-				D_ASSERT(i * mult + j < duckdb_hll::num_registers());
-				max_old = MaxValue<uint8_t>(max_old, duckdb_hll::get_register(hll, i * mult + j));
-			}
-			new_hll.Update(i, max_old);
-		}
-	}
-
-	void FromNew(const HyperLogLog &new_hll) {
-		const auto new_hll_count = new_hll.Count();
-		if (new_hll_count == 0) {
-			return;
-		}
-
-		const idx_t mult = duckdb_hll::num_registers() / HyperLogLog::M;
-		// When going from less to more registers, we cannot just duplicate the registers,
-		// as each register in the new HLL is the minimum of 'mult' registers in the old HLL.
-		// Duplicating will make for VERY large over-estimations. Instead, we do the following:
-
-		// Set the first of every 'mult' registers in the old HLL to the value in the new HLL
-		// This ensures that we can convert NEW to OLD and back to NEW without loss of information
-		double avg = 0;
-		for (idx_t i = 0; i < HyperLogLog::M; i++) {
-			const auto max_new = MinValue(new_hll.GetRegister(i), duckdb_hll::maximum_zeros());
-			duckdb_hll::set_register(hll, i * mult, max_new);
-			avg += static_cast<double>(max_new);
-		}
-		avg /= static_cast<double>(HyperLogLog::M);
-
-		// Using the average will ALWAYS overestimate, so we reduce it a bit here
-		if (avg > 10) {
-			avg *= 0.75;
-		} else if (avg > 2) {
-			avg -= 2;
-		}
-
-		// Set all other registers to a default value, starting with 0 (the initialization value)
-		// We optimize the default value in 5 iterations or until OLD count is close to NEW count
-		double default_val = 0;
-		for (idx_t opt_idx = 0; opt_idx < 5; opt_idx++) {
-			if (IsWithinAcceptableRange(new_hll_count, Count())) {
-				break;
-			}
-
-			// Delta is half the average, then a quarter, etc.
-			const double delta = avg / static_cast<double>(1 << (opt_idx + 1));
-			if (Count() > new_hll_count) {
-				default_val = delta > default_val ? 0 : default_val - delta;
-			} else {
-				default_val += delta;
-			}
-
-			// If the default value is, e.g., 3.3, then the first 70% gets value 3, and the rest gets value 4
-			const double floor_fraction = 1 - (default_val - floor(default_val));
-			for (idx_t i = 0; i < HyperLogLog::M; i++) {
-				const auto max_new = MinValue(new_hll.GetRegister(i), duckdb_hll::maximum_zeros());
-				uint8_t register_value;
-				if (static_cast<double>(i) / static_cast<double>(HyperLogLog::M) < floor_fraction) {
-					register_value = ExactNumericCast<uint8_t>(floor(default_val));
-				} else {
-					register_value = ExactNumericCast<uint8_t>(ceil(default_val));
-				}
-				register_value = MinValue(register_value, max_new);
-				for (idx_t j = 1; j < mult; j++) {
-					D_ASSERT(i * mult + j < duckdb_hll::num_registers());
-					duckdb_hll::set_register(hll, i * mult + j, register_value);
-				}
-			}
-		}
-	}
-
-private:
-	idx_t Count() const {
-		size_t result;
-		if (duckdb_hll::hll_count(hll, &result) != HLL_C_OK) {
-			throw InternalException("Could not count HLL?");
-		}
-		return result;
-	}
-
-	bool IsWithinAcceptableRange(const idx_t &new_hll_count, const idx_t &old_hll_count) const {
-		const auto newd = static_cast<double>(new_hll_count);
-		const auto oldd = static_cast<double>(old_hll_count);
-		return MaxValue(newd, oldd) / MinValue(newd, oldd) < ACCEPTABLE_Q_ERROR;
-	}
-
-private:
-	static constexpr double ACCEPTABLE_Q_ERROR = 1.2;
-	duckdb_hll::robj *hll;
-};
-
-void HyperLogLog::Serialize(Serializer &serializer) const {
-	if (serializer.ShouldSerialize(3)) {
-		serializer.WriteProperty(100, "type", HLLStorageType::HLL_V2);
-		serializer.WriteProperty(101, "data", k, sizeof(k));
-	} else {
-		auto old = make_uniq<HLLV1>();
-		old->FromNew(*this);
-
-		serializer.WriteProperty(100, "type", HLLStorageType::HLL_V1);
-		serializer.WriteProperty(101, "data", old->GetPtr(), old->GetSize());
-	}
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<HyperLogLog>();
-	auto storage_type = deserializer.ReadProperty<HLLStorageType>(100, "type");
-	switch (storage_type) {
-	case HLLStorageType::HLL_V1: {
-		auto old = make_uniq<HLLV1>();
-		deserializer.ReadProperty(101, "data", old->GetPtr(), old->GetSize());
-		old->ToNew(*result);
-		break;
-	}
-	case HLLStorageType::HLL_V2:
-		deserializer.ReadProperty(101, "data", result->k, sizeof(k));
-		break;
-	default:
-		throw SerializationException("Unknown HyperLogLog storage type!");
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/interval.cpp b/src/duckdb/src/common/types/interval.cpp
deleted file mode 100644
index 719e9ee2c..000000000
--- a/src/duckdb/src/common/types/interval.cpp
+++ /dev/null
@@ -1,532 +0,0 @@
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-bool Interval::FromString(const string &str, interval_t &result) {
-	string error_message;
-	return Interval::FromCString(str.c_str(), str.size(), result, &error_message, false);
-}
-
-template <class T>
-void IntervalTryAddition(T &target, int64_t input, int64_t multiplier, int64_t fraction = 0) {
-	int64_t addition;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, multiplier, addition)) {
-		throw OutOfRangeException("interval value is out of range");
-	}
-	T addition_base = Cast::Operation<int64_t, T>(addition);
-	if (!TryAddOperator::Operation<T, T, T>(target, addition_base, target)) {
-		throw OutOfRangeException("interval value is out of range");
-	}
-	if (fraction) {
-		//	Add in (fraction * multiplier) / MICROS_PER_SEC
-		//	This is always in range
-		addition = (fraction * multiplier) / Interval::MICROS_PER_SEC;
-		addition_base = Cast::Operation<int64_t, T>(addition);
-		if (!TryAddOperator::Operation<T, T, T>(target, addition_base, target)) {
-			throw OutOfRangeException("interval fraction is out of range");
-		}
-	}
-}
-
-bool Interval::FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict) {
-	idx_t pos = 0;
-	idx_t start_pos;
-	bool negative;
-	bool found_any = false;
-	int64_t number;
-	int64_t fraction;
-	DatePartSpecifier specifier;
-	string specifier_str;
-
-	result.days = 0;
-	result.micros = 0;
-	result.months = 0;
-
-	if (len == 0) {
-		return false;
-	}
-
-	switch (str[pos]) {
-	case '@':
-		pos++;
-		goto standard_interval;
-	case 'P':
-	case 'p':
-		pos++;
-		goto posix_interval;
-	default:
-		goto standard_interval;
-	}
-standard_interval:
-	// start parsing a standard interval (e.g. 2 years 3 months...)
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c == ' ' || c == '\t' || c == '\n') {
-			// skip spaces
-			continue;
-		} else if (c >= '0' && c <= '9') {
-			// start parsing a positive number
-			negative = false;
-			goto interval_parse_number;
-		} else if (c == '-') {
-			// negative number
-			negative = true;
-			pos++;
-			goto interval_parse_number;
-		} else if (c == 'a' || c == 'A') {
-			// parse the word "ago" as the final specifier
-			goto interval_parse_ago;
-		} else {
-			// unrecognized character, expected a number or end of string
-			return false;
-		}
-	}
-	goto end_of_string;
-interval_parse_number:
-	start_pos = pos;
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c >= '0' && c <= '9') {
-			// the number continues
-			continue;
-		} else if (c == ':') {
-			// colon: we are parsing a time
-			goto interval_parse_time;
-		} else {
-			if (pos == start_pos) {
-				return false;
-			}
-			// finished the number, parse it from the string
-			string_t nr_string(str + start_pos, UnsafeNumericCast<uint32_t>(pos - start_pos));
-			number = Cast::Operation<string_t, int64_t>(nr_string);
-			fraction = 0;
-			if (c == '.') {
-				// we expect some microseconds
-				int32_t mult = 100000;
-				for (++pos; pos < len && StringUtil::CharacterIsDigit(str[pos]); ++pos, mult /= 10) {
-					if (mult > 0) {
-						fraction += int64_t(str[pos] - '0') * mult;
-					}
-				}
-			}
-			if (negative) {
-				number = -number;
-				fraction = -fraction;
-			}
-			goto interval_parse_identifier;
-		}
-	}
-	goto end_of_string;
-interval_parse_time : {
-	// parse the remainder of the time as a Time type
-	dtime_t time;
-	idx_t pos;
-	if (!Time::TryConvertInterval(str + start_pos, len - start_pos, pos, time)) {
-		return false;
-	}
-	result.micros += time.micros;
-	found_any = true;
-	if (negative) {
-		result.micros = -result.micros;
-	}
-	goto end_of_string;
-}
-interval_parse_identifier:
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c == ' ' || c == '\t' || c == '\n') {
-			// skip spaces at the start
-			continue;
-		} else {
-			break;
-		}
-	}
-	// now parse the identifier
-	start_pos = pos;
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
-			// keep parsing the string
-			continue;
-		} else {
-			break;
-		}
-	}
-	specifier_str = string(str + start_pos, pos - start_pos);
-
-	// Special case SS[.FFFFFF] - implied SECONDS/MICROSECONDS
-	if (specifier_str.empty() && !found_any) {
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_SEC);
-		IntervalTryAddition<int64_t>(result.micros, fraction, 1);
-		found_any = true;
-		// parse any trailing whitespace
-		for (; pos < len; pos++) {
-			char c = str[pos];
-			if (c == ' ' || c == '\t' || c == '\n') {
-				continue;
-			} else {
-				return false;
-			}
-		}
-		goto end_of_string;
-	}
-
-	if (!TryGetDatePartSpecifier(specifier_str, specifier)) {
-		HandleCastError::AssignError(StringUtil::Format("extract specifier \"%s\" not recognized", specifier_str),
-		                             error_message);
-		return false;
-	}
-	// add the specifier to the interval
-	switch (specifier) {
-	case DatePartSpecifier::MILLENNIUM:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_MILLENIUM, fraction);
-		break;
-	case DatePartSpecifier::CENTURY:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_CENTURY, fraction);
-		break;
-	case DatePartSpecifier::DECADE:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_DECADE, fraction);
-		break;
-	case DatePartSpecifier::YEAR:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_YEAR, fraction);
-		break;
-	case DatePartSpecifier::QUARTER:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_QUARTER, fraction);
-		// Reduce to fraction of a month
-		fraction *= MONTHS_PER_QUARTER;
-		fraction %= MICROS_PER_SEC;
-		IntervalTryAddition<int32_t>(result.days, 0, DAYS_PER_MONTH, fraction);
-		break;
-	case DatePartSpecifier::MONTH:
-		IntervalTryAddition<int32_t>(result.months, number, 1);
-		IntervalTryAddition<int32_t>(result.days, 0, DAYS_PER_MONTH, fraction);
-		break;
-	case DatePartSpecifier::DAY:
-		IntervalTryAddition<int32_t>(result.days, number, 1);
-		IntervalTryAddition<int64_t>(result.micros, 0, MICROS_PER_DAY, fraction);
-		break;
-	case DatePartSpecifier::WEEK:
-		IntervalTryAddition<int32_t>(result.days, number, DAYS_PER_WEEK, fraction);
-		// Reduce to fraction of a day
-		fraction *= DAYS_PER_WEEK;
-		fraction %= MICROS_PER_SEC;
-		IntervalTryAddition<int64_t>(result.micros, 0, MICROS_PER_DAY, fraction);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		// Round the fraction
-		number += (fraction * 2) / MICROS_PER_SEC;
-		IntervalTryAddition<int64_t>(result.micros, number, 1);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MSEC, fraction);
-		break;
-	case DatePartSpecifier::SECOND:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_SEC, fraction);
-		break;
-	case DatePartSpecifier::MINUTE:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MINUTE, fraction);
-		break;
-	case DatePartSpecifier::HOUR:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_HOUR, fraction);
-		break;
-	default:
-		HandleCastError::AssignError(
-		    StringUtil::Format("extract specifier \"%s\" not supported for interval", specifier_str), error_message);
-		return false;
-	}
-	found_any = true;
-	goto standard_interval;
-interval_parse_ago:
-	D_ASSERT(str[pos] == 'a' || str[pos] == 'A');
-	// parse the "ago" string at the end of the interval
-	if (len - pos < 3) {
-		return false;
-	}
-	pos++;
-	if (!(str[pos] == 'g' || str[pos] == 'G')) {
-		return false;
-	}
-	pos++;
-	if (!(str[pos] == 'o' || str[pos] == 'O')) {
-		return false;
-	}
-	pos++;
-	// parse any trailing whitespace
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c == ' ' || c == '\t' || c == '\n') {
-			continue;
-		} else {
-			return false;
-		}
-	}
-	// invert all the values
-	result.months = -result.months;
-	result.days = -result.days;
-	result.micros = -result.micros;
-	goto end_of_string;
-end_of_string:
-	if (!found_any) {
-		// end of string and no identifiers were found: cannot convert empty interval
-		return false;
-	}
-	return true;
-posix_interval:
-	return false;
-}
-
-string Interval::ToString(const interval_t &interval) {
-	char buffer[70];
-	idx_t length = IntervalToStringCast::Format(interval, buffer);
-	return string(buffer, length);
-}
-
-int64_t Interval::GetMilli(const interval_t &val) {
-	int64_t milli_month, milli_day, milli;
-	if (!TryMultiplyOperator::Operation((int64_t)val.months, Interval::MICROS_PER_MONTH / 1000, milli_month)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	if (!TryMultiplyOperator::Operation((int64_t)val.days, Interval::MICROS_PER_DAY / 1000, milli_day)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	milli = val.micros / 1000;
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(milli, milli_month, milli)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(milli, milli_day, milli)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	return milli;
-}
-
-int64_t Interval::GetMicro(const interval_t &val) {
-	int64_t micro_month, micro_day, micro_total;
-	micro_total = val.micros;
-	if (!TryMultiplyOperator::Operation((int64_t)val.months, MICROS_PER_MONTH, micro_month)) {
-		throw ConversionException("Could not convert Month to Microseconds");
-	}
-	if (!TryMultiplyOperator::Operation((int64_t)val.days, MICROS_PER_DAY, micro_day)) {
-		throw ConversionException("Could not convert Day to Microseconds");
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(micro_total, micro_month, micro_total)) {
-		throw ConversionException("Could not convert Interval to Microseconds");
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(micro_total, micro_day, micro_total)) {
-		throw ConversionException("Could not convert Interval to Microseconds");
-	}
-
-	return micro_total;
-}
-
-int64_t Interval::GetNanoseconds(const interval_t &val) {
-	int64_t nano;
-	const auto micro_total = GetMicro(val);
-	if (!TryMultiplyOperator::Operation(micro_total, NANOS_PER_MICRO, nano)) {
-		throw ConversionException("Could not convert Interval to Nanoseconds");
-	}
-
-	return nano;
-}
-
-interval_t Interval::GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_1) && Timestamp::IsFinite(timestamp_2));
-	date_t date1, date2;
-	dtime_t time1, time2;
-
-	Timestamp::Convert(timestamp_1, date1, time1);
-	Timestamp::Convert(timestamp_2, date2, time2);
-
-	// and from date extract the years, months and days
-	int32_t year1, month1, day1;
-	int32_t year2, month2, day2;
-	Date::Convert(date1, year1, month1, day1);
-	Date::Convert(date2, year2, month2, day2);
-	// finally perform the differences
-	auto year_diff = year1 - year2;
-	auto month_diff = month1 - month2;
-	auto day_diff = day1 - day2;
-
-	// and from time extract hours, minutes, seconds and milliseconds
-	int32_t hour1, min1, sec1, micros1;
-	int32_t hour2, min2, sec2, micros2;
-	Time::Convert(time1, hour1, min1, sec1, micros1);
-	Time::Convert(time2, hour2, min2, sec2, micros2);
-	// finally perform the differences
-	auto hour_diff = hour1 - hour2;
-	auto min_diff = min1 - min2;
-	auto sec_diff = sec1 - sec2;
-	auto micros_diff = micros1 - micros2;
-
-	// flip sign if necessary
-	bool sign_flipped = false;
-	if (timestamp_1 < timestamp_2) {
-		year_diff = -year_diff;
-		month_diff = -month_diff;
-		day_diff = -day_diff;
-		hour_diff = -hour_diff;
-		min_diff = -min_diff;
-		sec_diff = -sec_diff;
-		micros_diff = -micros_diff;
-		sign_flipped = true;
-	}
-	// now propagate any negative field into the next higher field
-	while (micros_diff < 0) {
-		micros_diff += MICROS_PER_SEC;
-		sec_diff--;
-	}
-	while (sec_diff < 0) {
-		sec_diff += SECS_PER_MINUTE;
-		min_diff--;
-	}
-	while (min_diff < 0) {
-		min_diff += MINS_PER_HOUR;
-		hour_diff--;
-	}
-	while (hour_diff < 0) {
-		hour_diff += HOURS_PER_DAY;
-		day_diff--;
-	}
-	while (day_diff < 0) {
-		if (timestamp_1 < timestamp_2) {
-			day_diff += Date::IsLeapYear(year1) ? Date::LEAP_DAYS[month1] : Date::NORMAL_DAYS[month1];
-			month_diff--;
-		} else {
-			day_diff += Date::IsLeapYear(year2) ? Date::LEAP_DAYS[month2] : Date::NORMAL_DAYS[month2];
-			month_diff--;
-		}
-	}
-	while (month_diff < 0) {
-		month_diff += MONTHS_PER_YEAR;
-		year_diff--;
-	}
-
-	// recover sign if necessary
-	if (sign_flipped) {
-		year_diff = -year_diff;
-		month_diff = -month_diff;
-		day_diff = -day_diff;
-		hour_diff = -hour_diff;
-		min_diff = -min_diff;
-		sec_diff = -sec_diff;
-		micros_diff = -micros_diff;
-	}
-	interval_t interval;
-	interval.months = year_diff * MONTHS_PER_YEAR + month_diff;
-	interval.days = day_diff;
-	interval.micros = Time::FromTime(hour_diff, min_diff, sec_diff, micros_diff).micros;
-
-	return interval;
-}
-
-interval_t Interval::GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2) {
-	if (!Timestamp::IsFinite(timestamp_1) || !Timestamp::IsFinite(timestamp_2)) {
-		throw InvalidInputException("Cannot subtract infinite timestamps");
-	}
-	const auto us_1 = Timestamp::GetEpochMicroSeconds(timestamp_1);
-	const auto us_2 = Timestamp::GetEpochMicroSeconds(timestamp_2);
-	int64_t delta_us;
-	if (!TrySubtractOperator::Operation(us_1, us_2, delta_us)) {
-		throw ConversionException("Timestamp difference is out of bounds");
-	}
-	return FromMicro(delta_us);
-}
-
-interval_t Interval::FromMicro(int64_t delta_us) {
-	interval_t result;
-	result.months = 0;
-	result.days = UnsafeNumericCast<int32_t>(delta_us / Interval::MICROS_PER_DAY);
-	result.micros = delta_us % Interval::MICROS_PER_DAY;
-
-	return result;
-}
-
-interval_t Interval::Invert(interval_t interval) {
-	interval.days = -interval.days;
-	interval.micros = -interval.micros;
-	interval.months = -interval.months;
-	return interval;
-}
-
-date_t Interval::Add(date_t left, interval_t right) {
-	if (!Date::IsFinite(left)) {
-		return left;
-	}
-	date_t result;
-	if (right.months != 0) {
-		int32_t year, month, day;
-		Date::Convert(left, year, month, day);
-		int32_t year_diff = right.months / Interval::MONTHS_PER_YEAR;
-		year += year_diff;
-		month += right.months - year_diff * Interval::MONTHS_PER_YEAR;
-		if (month > Interval::MONTHS_PER_YEAR) {
-			year++;
-			month -= Interval::MONTHS_PER_YEAR;
-		} else if (month <= 0) {
-			year--;
-			month += Interval::MONTHS_PER_YEAR;
-		}
-		day = MinValue<int32_t>(day, Date::MonthDays(year, month));
-		result = Date::FromDate(year, month, day);
-	} else {
-		result = left;
-	}
-	if (right.days != 0) {
-		if (!TryAddOperator::Operation(result.days, right.days, result.days)) {
-			throw OutOfRangeException("Date out of range");
-		}
-	}
-	if (right.micros != 0) {
-		if (!TryAddOperator::Operation(result.days, int32_t(right.micros / Interval::MICROS_PER_DAY), result.days)) {
-			throw OutOfRangeException("Date out of range");
-		}
-	}
-	if (!Date::IsFinite(result)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	return result;
-}
-
-dtime_t Interval::Add(dtime_t left, interval_t right, date_t &date) {
-	int64_t diff = right.micros - ((right.micros / Interval::MICROS_PER_DAY) * Interval::MICROS_PER_DAY);
-	left += diff;
-	if (left.micros >= Interval::MICROS_PER_DAY) {
-		left.micros -= Interval::MICROS_PER_DAY;
-		date.days++;
-	} else if (left.micros < 0) {
-		left.micros += Interval::MICROS_PER_DAY;
-		date.days--;
-	}
-	return left;
-}
-
-dtime_tz_t Interval::Add(dtime_tz_t left, interval_t right, date_t &date) {
-	return dtime_tz_t(Interval::Add(left.time(), right, date), left.offset());
-}
-
-timestamp_t Interval::Add(timestamp_t left, interval_t right) {
-	if (!Timestamp::IsFinite(left)) {
-		return left;
-	}
-	date_t date;
-	dtime_t time;
-	Timestamp::Convert(left, date, time);
-	auto new_date = Interval::Add(date, right);
-	auto new_time = Interval::Add(time, right, new_date);
-	return Timestamp::FromDatetime(new_date, new_time);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/list_segment.cpp b/src/duckdb/src/common/types/list_segment.cpp
deleted file mode 100644
index 8145cf07f..000000000
--- a/src/duckdb/src/common/types/list_segment.cpp
+++ /dev/null
@@ -1,677 +0,0 @@
-#include "duckdb/common/types/list_segment.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-// forward declarations
-//===--------------------------------------------------------------------===//
-// Primitives
-//===--------------------------------------------------------------------===//
-template <class T>
-static idx_t GetAllocationSize(uint16_t capacity) {
-	return AlignValue(sizeof(ListSegment) + capacity * (sizeof(bool) + sizeof(T)));
-}
-
-template <class T>
-static data_ptr_t AllocatePrimitiveData(ArenaAllocator &allocator, uint16_t capacity) {
-	return allocator.Allocate(GetAllocationSize<T>(capacity));
-}
-
-template <class T>
-static T *GetPrimitiveData(ListSegment *segment) {
-	return reinterpret_cast<T *>(data_ptr_cast(segment) + sizeof(ListSegment) + segment->capacity * sizeof(bool));
-}
-
-template <class T>
-static const T *GetPrimitiveData(const ListSegment *segment) {
-	return reinterpret_cast<const T *>(const_data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                   segment->capacity * sizeof(bool));
-}
-
-//===--------------------------------------------------------------------===//
-// Strings
-//===--------------------------------------------------------------------===//
-static idx_t GetStringAllocationSize(uint16_t capacity) {
-	return AlignValue(sizeof(ListSegment) + (capacity * (sizeof(char))));
-}
-
-static data_ptr_t AllocateStringData(ArenaAllocator &allocator, uint16_t capacity) {
-	return allocator.Allocate(GetStringAllocationSize(capacity));
-}
-
-static char *GetStringData(ListSegment *segment) {
-	return reinterpret_cast<char *>(data_ptr_cast(segment) + sizeof(ListSegment));
-}
-
-//===--------------------------------------------------------------------===//
-// Lists
-//===--------------------------------------------------------------------===//
-static idx_t GetAllocationSizeList(uint16_t capacity) {
-	return AlignValue(sizeof(ListSegment) + capacity * (sizeof(bool) + sizeof(uint64_t)) + sizeof(LinkedList));
-}
-
-static data_ptr_t AllocateListData(ArenaAllocator &allocator, uint16_t capacity) {
-	return allocator.Allocate(GetAllocationSizeList(capacity));
-}
-
-static uint64_t *GetListLengthData(ListSegment *segment) {
-	return reinterpret_cast<uint64_t *>(data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                    segment->capacity * sizeof(bool));
-}
-
-static const uint64_t *GetListLengthData(const ListSegment *segment) {
-	return reinterpret_cast<const uint64_t *>(const_data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                          segment->capacity * sizeof(bool));
-}
-
-static const LinkedList *GetListChildData(const ListSegment *segment) {
-	return reinterpret_cast<const LinkedList *>(const_data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                            segment->capacity * (sizeof(bool) + sizeof(uint64_t)));
-}
-
-static LinkedList *GetListChildData(ListSegment *segment) {
-	return reinterpret_cast<LinkedList *>(data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                      segment->capacity * (sizeof(bool) + sizeof(uint64_t)));
-}
-
-//===--------------------------------------------------------------------===//
-// Array
-//===--------------------------------------------------------------------===//
-static idx_t GetAllocationSizeArray(uint16_t capacity) {
-	// Only store the null mask for the array segment, length is fixed so we don't need to store it
-	return AlignValue(sizeof(ListSegment) + capacity * (sizeof(bool)) + sizeof(LinkedList));
-}
-
-static data_ptr_t AllocateArrayData(ArenaAllocator &allocator, uint16_t capacity) {
-	return allocator.Allocate(GetAllocationSizeArray(capacity));
-}
-
-static const LinkedList *GetArrayChildData(const ListSegment *segment) {
-	return reinterpret_cast<const LinkedList *>(const_data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                            segment->capacity * sizeof(bool));
-}
-
-static LinkedList *GetArrayChildData(ListSegment *segment) {
-	return reinterpret_cast<LinkedList *>(data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                      segment->capacity * sizeof(bool));
-}
-
-//===--------------------------------------------------------------------===//
-// Structs
-//===--------------------------------------------------------------------===//
-static idx_t GetAllocationSizeStruct(uint16_t capacity, idx_t child_count) {
-	return AlignValue(sizeof(ListSegment) + capacity * sizeof(bool) + child_count * sizeof(ListSegment *));
-}
-
-static data_ptr_t AllocateStructData(ArenaAllocator &allocator, uint16_t capacity, idx_t child_count) {
-	return allocator.Allocate(GetAllocationSizeStruct(capacity, child_count));
-}
-
-static ListSegment **GetStructData(ListSegment *segment) {
-	return reinterpret_cast<ListSegment **>(data_ptr_cast(segment) + +sizeof(ListSegment) +
-	                                        segment->capacity * sizeof(bool));
-}
-
-static const ListSegment *const *GetStructData(const ListSegment *segment) {
-	return reinterpret_cast<const ListSegment *const *>(const_data_ptr_cast(segment) + sizeof(ListSegment) +
-	                                                    segment->capacity * sizeof(bool));
-}
-
-static bool *GetNullMask(ListSegment *segment) {
-	return reinterpret_cast<bool *>(data_ptr_cast(segment) + sizeof(ListSegment));
-}
-
-static const bool *GetNullMask(const ListSegment *segment) {
-	return reinterpret_cast<const bool *>(const_data_ptr_cast(segment) + sizeof(ListSegment));
-}
-
-static uint16_t GetCapacityForNewSegment(uint16_t capacity) {
-	auto next_power_of_two = idx_t(capacity) * 2;
-	if (next_power_of_two >= NumericLimits<uint16_t>::Maximum()) {
-		return capacity;
-	}
-	return uint16_t(next_power_of_two);
-}
-
-//===--------------------------------------------------------------------===//
-// Create
-//===--------------------------------------------------------------------===//
-template <class T>
-static ListSegment *CreatePrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
-	// allocate data and set the header
-	auto segment = reinterpret_cast<ListSegment *>(AllocatePrimitiveData<T>(allocator, capacity));
-	segment->capacity = capacity;
-	segment->count = 0;
-	segment->next = nullptr;
-	return segment;
-}
-
-static ListSegment *CreateVarcharDataSegment(const ListSegmentFunctions &, ArenaAllocator &allocator,
-                                             uint16_t capacity) {
-	// allocate data and set the header
-	auto segment = reinterpret_cast<ListSegment *>(AllocateStringData(allocator, capacity));
-	segment->capacity = capacity;
-	segment->count = 0;
-	segment->next = nullptr;
-	return segment;
-}
-
-static ListSegment *CreateListSegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
-	// allocate data and set the header
-	auto segment = reinterpret_cast<ListSegment *>(AllocateListData(allocator, capacity));
-	segment->capacity = capacity;
-	segment->count = 0;
-	segment->next = nullptr;
-
-	// create an empty linked list for the child vector
-	auto linked_child_list = GetListChildData(segment);
-	LinkedList linked_list(0, nullptr, nullptr);
-	Store<LinkedList>(linked_list, data_ptr_cast(linked_child_list));
-
-	return segment;
-}
-
-static ListSegment *CreateStructSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                        uint16_t capacity) {
-	// allocate data and set header
-	auto segment =
-	    reinterpret_cast<ListSegment *>(AllocateStructData(allocator, capacity, functions.child_functions.size()));
-	segment->capacity = capacity;
-	segment->count = 0;
-	segment->next = nullptr;
-
-	// create a child ListSegment with exactly the same capacity for each child vector
-	auto child_segments = GetStructData(segment);
-	for (idx_t i = 0; i < functions.child_functions.size(); i++) {
-		auto child_function = functions.child_functions[i];
-		auto child_segment = child_function.create_segment(child_function, allocator, capacity);
-		Store<ListSegment *>(child_segment, data_ptr_cast(child_segments + i));
-	}
-
-	return segment;
-}
-
-static ListSegment *CreateArraySegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
-	// allocate data and set header
-	auto segment = reinterpret_cast<ListSegment *>(AllocateArrayData(allocator, capacity));
-
-	segment->capacity = capacity;
-	segment->count = 0;
-	segment->next = nullptr;
-
-	// create an empty linked list for the child vector
-	auto linked_child_list = GetArrayChildData(segment);
-	LinkedList linked_list(0, nullptr, nullptr);
-	Store<LinkedList>(linked_list, data_ptr_cast(linked_child_list));
-
-	return segment;
-}
-
-static ListSegment *GetSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                               LinkedList &linked_list) {
-	ListSegment *segment;
-
-	// determine segment
-	if (!linked_list.last_segment) {
-		// empty linked list, create the first (and last) segment
-		segment = functions.create_segment(functions, allocator, functions.initial_capacity);
-		linked_list.first_segment = segment;
-		linked_list.last_segment = segment;
-	} else if (linked_list.last_segment->capacity == linked_list.last_segment->count) {
-		// the last segment of the linked list is full, create a new one and append it
-		auto capacity = GetCapacityForNewSegment(linked_list.last_segment->capacity);
-		segment = functions.create_segment(functions, allocator, capacity);
-		linked_list.last_segment->next = segment;
-		linked_list.last_segment = segment;
-	} else {
-		// the last segment of the linked list is not full, append the data to it
-		segment = linked_list.last_segment;
-	}
-
-	D_ASSERT(segment);
-	return segment;
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-template <class T>
-static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &, ListSegment *segment,
-                                        RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
-
-	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
-
-	// write null validity
-	auto null_mask = GetNullMask(segment);
-	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
-	null_mask[segment->count] = !valid;
-
-	// write value
-	if (valid) {
-		auto segment_data = GetPrimitiveData<T>(segment);
-		auto input_data_ptr = UnifiedVectorFormat::GetData<T>(input_data.unified);
-		Store<T>(input_data_ptr[sel_entry_idx], data_ptr_cast(segment_data + segment->count));
-	}
-}
-
-static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                      ListSegment *segment, RecursiveUnifiedVectorFormat &input_data,
-                                      idx_t &entry_idx) {
-
-	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
-
-	// write null validity
-	auto null_mask = GetNullMask(segment);
-	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
-	null_mask[segment->count] = !valid;
-
-	// set the length of this string
-	auto str_length_data = GetListLengthData(segment);
-
-	// we can reconstruct the offset from the length
-	if (!valid) {
-		Store<uint64_t>(0, data_ptr_cast(str_length_data + segment->count));
-		return;
-	}
-	auto &str_entry = UnifiedVectorFormat::GetData<string_t>(input_data.unified)[sel_entry_idx];
-	auto str_data = str_entry.GetData();
-	idx_t str_size = str_entry.GetSize();
-	Store<uint64_t>(str_size, data_ptr_cast(str_length_data + segment->count));
-
-	// write the characters to the linked list of child segments
-	auto child_segments = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
-	idx_t current_offset = 0;
-	while (current_offset < str_size) {
-		auto child_segment = GetSegment(functions.child_functions.back(), allocator, child_segments);
-		auto data = GetStringData(child_segment);
-		idx_t copy_count = MinValue<idx_t>(str_size - current_offset, child_segment->capacity - child_segment->count);
-		memcpy(data + child_segment->count, str_data + current_offset, copy_count);
-		current_offset += copy_count;
-		child_segment->count += copy_count;
-	}
-	child_segments.total_capacity += str_size;
-	// store the updated linked list
-	Store<LinkedList>(child_segments, data_ptr_cast(GetListChildData(segment)));
-}
-
-static void WriteDataToListSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                   ListSegment *segment, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
-
-	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
-
-	// write null validity
-	auto null_mask = GetNullMask(segment);
-	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
-	null_mask[segment->count] = !valid;
-
-	// set the length of this list
-	auto list_length_data = GetListLengthData(segment);
-	uint64_t list_length = 0;
-
-	if (valid) {
-		// get list entry information
-		const auto &list_entry = UnifiedVectorFormat::GetData<list_entry_t>(input_data.unified)[sel_entry_idx];
-		list_length = list_entry.length;
-
-		// loop over the child vector entries and recurse on them
-		auto child_segments = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
-		D_ASSERT(functions.child_functions.size() == 1);
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-			auto source_idx_child = list_entry.offset + child_idx;
-			functions.child_functions[0].AppendRow(allocator, child_segments, input_data.children.back(),
-			                                       source_idx_child);
-		}
-		// store the updated linked list
-		Store<LinkedList>(child_segments, data_ptr_cast(GetListChildData(segment)));
-	}
-
-	Store<uint64_t>(list_length, data_ptr_cast(list_length_data + segment->count));
-}
-
-static void WriteDataToStructSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                     ListSegment *segment, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
-
-	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
-
-	// write null validity
-	auto null_mask = GetNullMask(segment);
-	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
-	null_mask[segment->count] = !valid;
-
-	// write value
-	D_ASSERT(input_data.children.size() == functions.child_functions.size());
-	auto child_list = GetStructData(segment);
-
-	// write the data of each of the children of the struct
-	for (idx_t i = 0; i < input_data.children.size(); i++) {
-		auto child_list_segment = Load<ListSegment *>(data_ptr_cast(child_list + i));
-		auto &child_function = functions.child_functions[i];
-		child_function.write_data(child_function, allocator, child_list_segment, input_data.children[i], entry_idx);
-		child_list_segment->count++;
-	}
-}
-
-static void WriteDataToArraySegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                    ListSegment *segment, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
-	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
-
-	// write null validity
-	auto null_mask = GetNullMask(segment);
-	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
-	null_mask[segment->count] = !valid;
-
-	// Arrays require there to be values in the child even when the entry is NULL.
-	auto array_size = ArrayType::GetSize(input_data.logical_type);
-	auto array_offset = sel_entry_idx * array_size;
-
-	auto child_segments = Load<LinkedList>(data_ptr_cast(GetArrayChildData(segment)));
-	D_ASSERT(functions.child_functions.size() == 1);
-	for (idx_t elem_idx = array_offset; elem_idx < array_offset + array_size; elem_idx++) {
-		functions.child_functions[0].AppendRow(allocator, child_segments, input_data.children.back(), elem_idx);
-	}
-	// store the updated linked list
-	Store<LinkedList>(child_segments, data_ptr_cast(GetArrayChildData(segment)));
-}
-
-void ListSegmentFunctions::AppendRow(ArenaAllocator &allocator, LinkedList &linked_list,
-                                     RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) const {
-
-	auto &write_data_to_segment = *this;
-	auto segment = GetSegment(write_data_to_segment, allocator, linked_list);
-	write_data_to_segment.write_data(write_data_to_segment, allocator, segment, input_data, entry_idx);
-
-	linked_list.total_capacity++;
-	segment->count++;
-}
-
-//===--------------------------------------------------------------------===//
-// Read
-//===--------------------------------------------------------------------===//
-template <class T>
-static void ReadDataFromPrimitiveSegment(const ListSegmentFunctions &, const ListSegment *segment, Vector &result,
-                                         idx_t &total_count) {
-
-	auto &aggr_vector_validity = FlatVector::Validity(result);
-
-	// set NULLs
-	auto null_mask = GetNullMask(segment);
-	for (idx_t i = 0; i < segment->count; i++) {
-		if (null_mask[i]) {
-			aggr_vector_validity.SetInvalid(total_count + i);
-		}
-	}
-
-	auto aggr_vector_data = FlatVector::GetData<T>(result);
-
-	// load values
-	for (idx_t i = 0; i < segment->count; i++) {
-		if (aggr_vector_validity.RowIsValid(total_count + i)) {
-			auto data = GetPrimitiveData<T>(segment);
-			aggr_vector_data[total_count + i] = Load<T>(const_data_ptr_cast(data + i));
-		}
-	}
-}
-
-static void ReadDataFromVarcharSegment(const ListSegmentFunctions &, const ListSegment *segment, Vector &result,
-                                       idx_t &total_count) {
-	auto &aggr_vector_validity = FlatVector::Validity(result);
-
-	// use length and (reconstructed) offset to get the correct substrings
-	auto aggr_vector_data = FlatVector::GetData<string_t>(result);
-	auto str_length_data = GetListLengthData(segment);
-
-	auto null_mask = GetNullMask(segment);
-	auto linked_child_list = Load<LinkedList>(const_data_ptr_cast(GetListChildData(segment)));
-	auto current_segment = linked_child_list.first_segment;
-	idx_t child_offset = 0;
-	for (idx_t i = 0; i < segment->count; i++) {
-		if (null_mask[i]) {
-			// set to null
-			aggr_vector_validity.SetInvalid(total_count + i);
-			continue;
-		}
-		// read the string
-		auto &result_str = aggr_vector_data[total_count + i];
-		auto str_length = Load<uint64_t>(const_data_ptr_cast(str_length_data + i));
-		// allocate an empty string for the given size
-		result_str = StringVector::EmptyString(result, str_length);
-		auto result_data = result_str.GetDataWriteable();
-		// copy over the data
-		idx_t current_offset = 0;
-		while (current_offset < str_length) {
-			if (!current_segment) {
-				throw InternalException("Insufficient data to read string");
-			}
-			auto child_data = GetStringData(current_segment);
-			idx_t max_copy = MinValue<idx_t>(str_length - current_offset, current_segment->capacity - child_offset);
-			memcpy(result_data + current_offset, child_data + child_offset, max_copy);
-			current_offset += max_copy;
-			child_offset += max_copy;
-			if (child_offset >= current_segment->capacity) {
-				D_ASSERT(child_offset == current_segment->capacity);
-				current_segment = current_segment->next;
-				child_offset = 0;
-			}
-		}
-
-		// finalize the str
-		result_str.Finalize();
-	}
-}
-
-static void ReadDataFromListSegment(const ListSegmentFunctions &functions, const ListSegment *segment, Vector &result,
-                                    idx_t &total_count) {
-
-	auto &aggr_vector_validity = FlatVector::Validity(result);
-
-	// set NULLs
-	auto null_mask = GetNullMask(segment);
-	for (idx_t i = 0; i < segment->count; i++) {
-		if (null_mask[i]) {
-			aggr_vector_validity.SetInvalid(total_count + i);
-		}
-	}
-
-	auto list_vector_data = FlatVector::GetData<list_entry_t>(result);
-
-	// get the starting offset
-	idx_t offset = 0;
-	if (total_count != 0) {
-		offset = list_vector_data[total_count - 1].offset + list_vector_data[total_count - 1].length;
-	}
-	idx_t starting_offset = offset;
-
-	// set length and offsets
-	auto list_length_data = GetListLengthData(segment);
-	for (idx_t i = 0; i < segment->count; i++) {
-		auto list_length = Load<uint64_t>(const_data_ptr_cast(list_length_data + i));
-		list_vector_data[total_count + i].length = list_length;
-		list_vector_data[total_count + i].offset = offset;
-		offset += list_length;
-	}
-
-	auto &child_vector = ListVector::GetEntry(result);
-	auto linked_child_list = Load<LinkedList>(const_data_ptr_cast(GetListChildData(segment)));
-	ListVector::Reserve(result, offset);
-
-	// recurse into the linked list of child values
-	D_ASSERT(functions.child_functions.size() == 1);
-	functions.child_functions[0].BuildListVector(linked_child_list, child_vector, starting_offset);
-	ListVector::SetListSize(result, offset);
-}
-
-static void ReadDataFromStructSegment(const ListSegmentFunctions &functions, const ListSegment *segment, Vector &result,
-                                      idx_t &total_count) {
-
-	auto &aggr_vector_validity = FlatVector::Validity(result);
-
-	// set NULLs
-	auto null_mask = GetNullMask(segment);
-	for (idx_t i = 0; i < segment->count; i++) {
-		if (null_mask[i]) {
-			aggr_vector_validity.SetInvalid(total_count + i);
-		}
-	}
-
-	auto &children = StructVector::GetEntries(result);
-
-	// recurse into the child segments of each child of the struct
-	D_ASSERT(children.size() == functions.child_functions.size());
-	auto struct_children = GetStructData(segment);
-	for (idx_t child_count = 0; child_count < children.size(); child_count++) {
-		auto struct_children_segment = Load<ListSegment *>(const_data_ptr_cast(struct_children + child_count));
-		auto &child_function = functions.child_functions[child_count];
-		child_function.read_data(child_function, struct_children_segment, *children[child_count], total_count);
-	}
-}
-
-static void ReadDataFromArraySegment(const ListSegmentFunctions &functions, const ListSegment *segment, Vector &result,
-                                     idx_t &total_count) {
-
-	auto &aggr_vector_validity = FlatVector::Validity(result);
-
-	// set NULLs
-	auto null_mask = GetNullMask(segment);
-	for (idx_t i = 0; i < segment->count; i++) {
-		if (null_mask[i]) {
-			aggr_vector_validity.SetInvalid(total_count + i);
-		}
-	}
-
-	auto &child_vector = ArrayVector::GetEntry(result);
-	auto linked_child_list = Load<LinkedList>(const_data_ptr_cast(GetArrayChildData(segment)));
-	auto array_size = ArrayType::GetSize(result.GetType());
-	auto child_size = array_size * total_count;
-
-	// recurse into the linked list of child values
-	D_ASSERT(functions.child_functions.size() == 1);
-	functions.child_functions[0].BuildListVector(linked_child_list, child_vector, child_size);
-}
-
-void ListSegmentFunctions::BuildListVector(const LinkedList &linked_list, Vector &result, idx_t total_count) const {
-	auto &read_data_from_segment = *this;
-	auto segment = linked_list.first_segment;
-	while (segment) {
-		read_data_from_segment.read_data(read_data_from_segment, segment, result, total_count);
-		total_count += segment->count;
-		segment = segment->next;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Functions
-//===--------------------------------------------------------------------===//
-template <class T>
-void SegmentPrimitiveFunction(ListSegmentFunctions &functions) {
-	functions.create_segment = CreatePrimitiveSegment<T>;
-	functions.write_data = WriteDataToPrimitiveSegment<T>;
-	functions.read_data = ReadDataFromPrimitiveSegment<T>;
-}
-
-void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType &type) {
-
-	if (type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-
-	auto physical_type = type.InternalType();
-	switch (physical_type) {
-	case PhysicalType::BIT:
-	case PhysicalType::BOOL:
-		SegmentPrimitiveFunction<bool>(functions);
-		functions.initial_capacity = 8;
-		break;
-	case PhysicalType::INT8:
-		SegmentPrimitiveFunction<int8_t>(functions);
-		functions.initial_capacity = 8;
-		break;
-	case PhysicalType::INT16:
-		SegmentPrimitiveFunction<int16_t>(functions);
-		break;
-	case PhysicalType::INT32:
-		SegmentPrimitiveFunction<int32_t>(functions);
-		break;
-	case PhysicalType::INT64:
-		SegmentPrimitiveFunction<int64_t>(functions);
-		break;
-	case PhysicalType::UINT8:
-		SegmentPrimitiveFunction<uint8_t>(functions);
-		functions.initial_capacity = 8;
-		break;
-	case PhysicalType::UINT16:
-		SegmentPrimitiveFunction<uint16_t>(functions);
-		break;
-	case PhysicalType::UINT32:
-		SegmentPrimitiveFunction<uint32_t>(functions);
-		break;
-	case PhysicalType::UINT64:
-		SegmentPrimitiveFunction<uint64_t>(functions);
-		break;
-	case PhysicalType::FLOAT:
-		SegmentPrimitiveFunction<float>(functions);
-		break;
-	case PhysicalType::DOUBLE:
-		SegmentPrimitiveFunction<double>(functions);
-		break;
-	case PhysicalType::INT128:
-		SegmentPrimitiveFunction<hugeint_t>(functions);
-		break;
-	case PhysicalType::UINT128:
-		SegmentPrimitiveFunction<uhugeint_t>(functions);
-		break;
-	case PhysicalType::INTERVAL:
-		SegmentPrimitiveFunction<interval_t>(functions);
-		break;
-	case PhysicalType::VARCHAR: {
-		functions.create_segment = CreateListSegment;
-		functions.write_data = WriteDataToVarcharSegment;
-		functions.read_data = ReadDataFromVarcharSegment;
-
-		ListSegmentFunctions child_function;
-		child_function.create_segment = CreateVarcharDataSegment;
-		child_function.write_data = nullptr;
-		child_function.read_data = nullptr;
-		child_function.initial_capacity = 16;
-		functions.child_functions.push_back(child_function);
-		break;
-	}
-	case PhysicalType::LIST: {
-		functions.create_segment = CreateListSegment;
-		functions.write_data = WriteDataToListSegment;
-		functions.read_data = ReadDataFromListSegment;
-
-		// recurse
-		functions.child_functions.emplace_back();
-		GetSegmentDataFunctions(functions.child_functions.back(), ListType::GetChildType(type));
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		functions.create_segment = CreateStructSegment;
-		functions.write_data = WriteDataToStructSegment;
-		functions.read_data = ReadDataFromStructSegment;
-
-		// recurse
-		auto child_types = StructType::GetChildTypes(type);
-		for (idx_t i = 0; i < child_types.size(); i++) {
-			functions.child_functions.emplace_back();
-			GetSegmentDataFunctions(functions.child_functions.back(), child_types[i].second);
-		}
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		functions.create_segment = CreateArraySegment;
-		functions.write_data = WriteDataToArraySegment;
-		functions.read_data = ReadDataFromArraySegment;
-
-		// recurse
-		functions.child_functions.emplace_back();
-		GetSegmentDataFunctions(functions.child_functions.back(), ArrayType::GetChildType(type));
-		break;
-	}
-	default:
-		throw InternalException("LIST aggregate not yet implemented for " + type.ToString());
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/partitioned_tuple_data.cpp b/src/duckdb/src/common/types/row/partitioned_tuple_data.cpp
deleted file mode 100644
index b77463d8c..000000000
--- a/src/duckdb/src/common/types/row/partitioned_tuple_data.cpp
+++ /dev/null
@@ -1,372 +0,0 @@
-#include "duckdb/common/types/row/partitioned_tuple_data.hpp"
-
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/types/row/tuple_data_iterator.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-PartitionedTupleData::PartitionedTupleData(PartitionedTupleDataType type_p, BufferManager &buffer_manager_p,
-                                           const TupleDataLayout &layout_p)
-    : type(type_p), buffer_manager(buffer_manager_p), layout(layout_p.Copy()), count(0), data_size(0),
-      allocators(make_shared_ptr<PartitionTupleDataAllocators>()) {
-}
-
-PartitionedTupleData::PartitionedTupleData(const PartitionedTupleData &other)
-    : type(other.type), buffer_manager(other.buffer_manager), layout(other.layout.Copy()), count(0), data_size(0) {
-}
-
-PartitionedTupleData::~PartitionedTupleData() {
-}
-
-const TupleDataLayout &PartitionedTupleData::GetLayout() const {
-	return layout;
-}
-
-PartitionedTupleDataType PartitionedTupleData::GetType() const {
-	return type;
-}
-
-void PartitionedTupleData::InitializeAppendState(PartitionedTupleDataAppendState &state,
-                                                 TupleDataPinProperties properties) const {
-	state.partition_sel.Initialize();
-	state.reverse_partition_sel.Initialize();
-
-	InitializeAppendStateInternal(state, properties);
-}
-
-void PartitionedTupleData::Append(PartitionedTupleDataAppendState &state, DataChunk &input,
-                                  const SelectionVector &append_sel, const idx_t append_count) {
-	TupleDataCollection::ToUnifiedFormat(state.chunk_state, input);
-	AppendUnified(state, input, append_sel, append_count);
-}
-
-bool PartitionedTupleData::UseFixedSizeMap() const {
-	return MaxPartitionIndex() < PartitionedTupleDataAppendState::MAP_THRESHOLD;
-}
-
-void PartitionedTupleData::AppendUnified(PartitionedTupleDataAppendState &state, DataChunk &input,
-                                         const SelectionVector &append_sel, const idx_t append_count) {
-	const idx_t actual_append_count = append_count == DConstants::INVALID_INDEX ? input.size() : append_count;
-
-	// Compute partition indices and store them in state.partition_indices
-	ComputePartitionIndices(state, input, append_sel, actual_append_count);
-
-	// Build the selection vector for the partitions
-	BuildPartitionSel(state, append_sel, actual_append_count);
-
-	// Early out: check if everything belongs to a single partition
-	const auto partition_index = state.GetPartitionIndexIfSinglePartition(UseFixedSizeMap());
-	if (partition_index.IsValid()) {
-		auto &partition = *partitions[partition_index.GetIndex()];
-		auto &partition_pin_state = *state.partition_pin_states[partition_index.GetIndex()];
-
-		const auto size_before = partition.SizeInBytes();
-		partition.AppendUnified(partition_pin_state, state.chunk_state, input, append_sel, actual_append_count);
-		data_size += partition.SizeInBytes() - size_before;
-	} else {
-		// Compute the heap sizes for the whole chunk
-		if (!layout.AllConstant()) {
-			TupleDataCollection::ComputeHeapSizes(state.chunk_state, input, state.partition_sel, actual_append_count);
-		}
-
-		// Build the buffer space
-		BuildBufferSpace(state);
-
-		// Now scatter everything in one go
-		partitions[0]->Scatter(state.chunk_state, input, state.partition_sel, actual_append_count);
-	}
-
-	count += actual_append_count;
-	Verify();
-}
-
-void PartitionedTupleData::Append(PartitionedTupleDataAppendState &state, TupleDataChunkState &input,
-                                  const idx_t append_count) {
-	// Compute partition indices and store them in state.partition_indices
-	ComputePartitionIndices(input.row_locations, append_count, state.partition_indices);
-
-	// Build the selection vector for the partitions
-	BuildPartitionSel(state, *FlatVector::IncrementalSelectionVector(), append_count);
-
-	// Early out: check if everything belongs to a single partition
-	auto partition_index = state.GetPartitionIndexIfSinglePartition(UseFixedSizeMap());
-	if (partition_index.IsValid()) {
-		auto &partition = *partitions[partition_index.GetIndex()];
-		auto &partition_pin_state = *state.partition_pin_states[partition_index.GetIndex()];
-
-		state.chunk_state.heap_sizes.Reference(input.heap_sizes);
-
-		const auto size_before = partition.SizeInBytes();
-		partition.Build(partition_pin_state, state.chunk_state, 0, append_count);
-		data_size += partition.SizeInBytes() - size_before;
-
-		partition.CopyRows(state.chunk_state, input, *FlatVector::IncrementalSelectionVector(), append_count);
-	} else {
-		// Build the buffer space
-		state.chunk_state.heap_sizes.Slice(input.heap_sizes, state.partition_sel, append_count);
-		state.chunk_state.heap_sizes.Flatten(append_count);
-		BuildBufferSpace(state);
-
-		// Copy the rows
-		partitions[0]->CopyRows(state.chunk_state, input, state.partition_sel, append_count);
-	}
-
-	count += append_count;
-	Verify();
-}
-
-void PartitionedTupleData::BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
-                                             const idx_t append_count) const {
-	if (UseFixedSizeMap()) {
-		BuildPartitionSel<true>(state, append_sel, append_count);
-	} else {
-		BuildPartitionSel<false>(state, append_sel, append_count);
-	}
-}
-
-template <bool fixed>
-void PartitionedTupleData::BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
-                                             const idx_t append_count) {
-	using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
-	auto &partition_entries = state.GetMap<fixed>();
-	const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
-	partition_entries.clear();
-	switch (state.partition_indices.GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		for (idx_t i = 0; i < append_count; i++) {
-			const auto &partition_index = partition_indices[i];
-			auto partition_entry = partition_entries.find(partition_index);
-			if (partition_entry == partition_entries.end()) {
-				partition_entries[partition_index] = list_entry_t(0, 1);
-			} else {
-				GETTER::GetValue(partition_entry).length++;
-			}
-		}
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		partition_entries[partition_indices[0]] = list_entry_t(0, append_count);
-		break;
-	default:
-		throw InternalException("Unexpected VectorType in PartitionedTupleData::Append");
-	}
-
-	// Early out: check if everything belongs to a single partition
-	if (partition_entries.size() == 1) {
-		// This needs to be initialized, even if we go the short path here
-		for (sel_t i = 0; i < append_count; i++) {
-			const auto index = append_sel.get_index(i);
-			state.reverse_partition_sel[index] = i;
-		}
-		return;
-	}
-
-	// Compute offsets from the counts
-	idx_t offset = 0;
-	for (auto it = partition_entries.begin(); it != partition_entries.end(); ++it) {
-		auto &partition_entry = GETTER::GetValue(it);
-		partition_entry.offset = offset;
-		offset += partition_entry.length;
-	}
-
-	// Now initialize a single selection vector that acts as a selection vector for every partition
-	auto &partition_sel = state.partition_sel;
-	auto &reverse_partition_sel = state.reverse_partition_sel;
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto index = append_sel.get_index(i);
-		const auto &partition_index = partition_indices[i];
-		auto &partition_offset = partition_entries[partition_index].offset;
-		reverse_partition_sel[index] = UnsafeNumericCast<sel_t>(partition_offset);
-		partition_sel[partition_offset++] = UnsafeNumericCast<sel_t>(index);
-	}
-}
-
-void PartitionedTupleData::BuildBufferSpace(PartitionedTupleDataAppendState &state) {
-	if (UseFixedSizeMap()) {
-		BuildBufferSpace<true>(state);
-	} else {
-		BuildBufferSpace<false>(state);
-	}
-}
-
-template <bool fixed>
-void PartitionedTupleData::BuildBufferSpace(PartitionedTupleDataAppendState &state) {
-	using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
-	const auto &partition_entries = state.GetMap<fixed>();
-	for (auto it = partition_entries.begin(); it != partition_entries.end(); ++it) {
-		const auto &partition_index = GETTER::GetKey(it);
-
-		// Partition, pin state for this partition index
-		auto &partition = *partitions[partition_index];
-		auto &partition_pin_state = *state.partition_pin_states[partition_index];
-
-		// Length and offset for this partition
-		const auto &partition_entry = GETTER::GetValue(it);
-		const auto &partition_length = partition_entry.length;
-		const auto partition_offset = partition_entry.offset - partition_length;
-
-		// Build out the buffer space for this partition
-		const auto size_before = partition.SizeInBytes();
-		partition.Build(partition_pin_state, state.chunk_state, partition_offset, partition_length);
-		data_size += partition.SizeInBytes() - size_before;
-	}
-}
-
-void PartitionedTupleData::FlushAppendState(PartitionedTupleDataAppendState &state) {
-	for (idx_t partition_index = 0; partition_index < partitions.size(); partition_index++) {
-		auto &partition = *partitions[partition_index];
-		auto &partition_pin_state = *state.partition_pin_states[partition_index];
-		partition.FinalizePinState(partition_pin_state);
-	}
-}
-
-void PartitionedTupleData::Combine(PartitionedTupleData &other) {
-	if (other.Count() == 0) {
-		return;
-	}
-
-	// Now combine the state's partitions into this
-	lock_guard<mutex> guard(lock);
-	if (partitions.empty()) {
-		// This is the first merge, we just copy them over
-		partitions = std::move(other.partitions);
-	} else {
-		D_ASSERT(partitions.size() == other.partitions.size());
-		// Combine the append state's partitions into this PartitionedTupleData
-		for (idx_t i = 0; i < other.partitions.size(); i++) {
-			partitions[i]->Combine(*other.partitions[i]);
-		}
-	}
-	this->count += other.count;
-	this->data_size += other.data_size;
-	Verify();
-}
-
-void PartitionedTupleData::Reset() {
-	for (auto &partition : partitions) {
-		partition->Reset();
-	}
-	this->count = 0;
-	this->data_size = 0;
-	Verify();
-}
-
-void PartitionedTupleData::Repartition(PartitionedTupleData &new_partitioned_data) {
-	D_ASSERT(layout.GetTypes() == new_partitioned_data.layout.GetTypes());
-
-	if (partitions.size() == new_partitioned_data.partitions.size()) {
-		new_partitioned_data.Combine(*this);
-		return;
-	}
-
-	PartitionedTupleDataAppendState append_state;
-	new_partitioned_data.InitializeAppendState(append_state);
-
-	for (idx_t partition_idx = 0; partition_idx < partitions.size(); partition_idx++) {
-		auto &partition = *partitions[partition_idx];
-
-		if (partition.Count() > 0) {
-			TupleDataChunkIterator iterator(partition, TupleDataPinProperties::DESTROY_AFTER_DONE, true);
-			auto &chunk_state = iterator.GetChunkState();
-			do {
-				new_partitioned_data.Append(append_state, chunk_state, iterator.GetCurrentChunkCount());
-			} while (iterator.Next());
-
-			RepartitionFinalizeStates(*this, new_partitioned_data, append_state, partition_idx);
-		}
-		partitions[partition_idx]->Reset();
-	}
-	new_partitioned_data.FlushAppendState(append_state);
-
-	count = 0;
-	data_size = 0;
-
-	Verify();
-}
-
-void PartitionedTupleData::Unpin() {
-	for (auto &partition : partitions) {
-		partition->Unpin();
-	}
-}
-
-unsafe_vector<unique_ptr<TupleDataCollection>> &PartitionedTupleData::GetPartitions() {
-	return partitions;
-}
-
-unique_ptr<TupleDataCollection> PartitionedTupleData::GetUnpartitioned() {
-	auto data_collection = std::move(partitions[0]);
-	partitions[0] = make_uniq<TupleDataCollection>(buffer_manager, layout);
-
-	for (idx_t i = 1; i < partitions.size(); i++) {
-		data_collection->Combine(*partitions[i]);
-	}
-	count = 0;
-	data_size = 0;
-
-	data_collection->Verify();
-	Verify();
-
-	return data_collection;
-}
-
-idx_t PartitionedTupleData::Count() const {
-	return count;
-}
-
-idx_t PartitionedTupleData::SizeInBytes() const {
-	idx_t total_size = 0;
-	for (auto &partition : partitions) {
-		total_size += partition->SizeInBytes();
-	}
-	return total_size;
-}
-
-idx_t PartitionedTupleData::PartitionCount() const {
-	return partitions.size();
-}
-
-void PartitionedTupleData::GetSizesAndCounts(vector<idx_t> &partition_sizes, vector<idx_t> &partition_counts) const {
-	D_ASSERT(partition_sizes.size() == PartitionCount());
-	D_ASSERT(partition_sizes.size() == partition_counts.size());
-	for (idx_t i = 0; i < PartitionCount(); i++) {
-		auto &partition = *partitions[i];
-		partition_sizes[i] += partition.SizeInBytes();
-		partition_counts[i] += partition.Count();
-	}
-}
-
-void PartitionedTupleData::Verify() const {
-#ifdef DEBUG
-	idx_t total_count = 0;
-	idx_t total_size = 0;
-	for (auto &partition : partitions) {
-		partition->Verify();
-		total_count += partition->Count();
-		total_size += partition->SizeInBytes();
-	}
-	D_ASSERT(total_count == this->count);
-	D_ASSERT(total_size == this->data_size);
-#endif
-}
-
-// LCOV_EXCL_START
-string PartitionedTupleData::ToString() {
-	string result =
-	    StringUtil::Format("PartitionedTupleData - [%llu Partitions, %llu Rows]\n", partitions.size(), Count());
-	for (idx_t partition_idx = 0; partition_idx < partitions.size(); partition_idx++) {
-		result += StringUtil::Format("Partition %llu: ", partition_idx) + partitions[partition_idx]->ToString();
-	}
-	return result;
-}
-
-void PartitionedTupleData::Print() {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-void PartitionedTupleData::CreateAllocator() {
-	allocators->allocators.emplace_back(make_shared_ptr<TupleDataAllocator>(buffer_manager, layout));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/row_data_collection.cpp b/src/duckdb/src/common/types/row/row_data_collection.cpp
deleted file mode 100644
index b178b7fb5..000000000
--- a/src/duckdb/src/common/types/row/row_data_collection.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "duckdb/common/types/row/row_data_collection.hpp"
-
-namespace duckdb {
-
-RowDataCollection::RowDataCollection(BufferManager &buffer_manager, idx_t block_capacity, idx_t entry_size,
-                                     bool keep_pinned)
-    : buffer_manager(buffer_manager), count(0), block_capacity(block_capacity), entry_size(entry_size),
-      keep_pinned(keep_pinned) {
-	D_ASSERT(block_capacity * entry_size + entry_size > buffer_manager.GetBlockSize());
-}
-
-idx_t RowDataCollection::AppendToBlock(RowDataBlock &block, BufferHandle &handle,
-                                       vector<BlockAppendEntry> &append_entries, idx_t remaining, idx_t entry_sizes[]) {
-	idx_t append_count = 0;
-	data_ptr_t dataptr;
-	if (entry_sizes) {
-		D_ASSERT(entry_size == 1);
-		// compute how many entries fit if entry size is variable
-		dataptr = handle.Ptr() + block.byte_offset;
-		for (idx_t i = 0; i < remaining; i++) {
-			if (block.byte_offset + entry_sizes[i] > block.capacity) {
-				if (block.count == 0 && append_count == 0 && entry_sizes[i] > block.capacity) {
-					// special case: single entry is bigger than block capacity
-					// resize current block to fit the entry, append it, and move to the next block
-					block.capacity = entry_sizes[i];
-					buffer_manager.ReAllocate(block.block, block.capacity);
-					dataptr = handle.Ptr();
-					append_count++;
-					block.byte_offset += entry_sizes[i];
-				}
-				break;
-			}
-			append_count++;
-			block.byte_offset += entry_sizes[i];
-		}
-	} else {
-		append_count = MinValue<idx_t>(remaining, block.capacity - block.count);
-		dataptr = handle.Ptr() + block.count * entry_size;
-	}
-	append_entries.emplace_back(dataptr, append_count);
-	block.count += append_count;
-	return append_count;
-}
-
-RowDataBlock &RowDataCollection::CreateBlock() {
-	blocks.push_back(make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, block_capacity, entry_size));
-	return *blocks.back();
-}
-
-vector<BufferHandle> RowDataCollection::Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[],
-                                              const SelectionVector *sel) {
-	vector<BufferHandle> handles;
-	vector<BlockAppendEntry> append_entries;
-
-	// first allocate space of where to serialize the keys and payload columns
-	idx_t remaining = added_count;
-	{
-		// first append to the last block (if any)
-		lock_guard<mutex> append_lock(rdc_lock);
-		count += added_count;
-
-		if (!blocks.empty()) {
-			auto &last_block = *blocks.back();
-			if (last_block.count < last_block.capacity) {
-				// last block has space: pin the buffer of this block
-				auto handle = buffer_manager.Pin(last_block.block);
-				// now append to the block
-				idx_t append_count = AppendToBlock(last_block, handle, append_entries, remaining, entry_sizes);
-				remaining -= append_count;
-				handles.push_back(std::move(handle));
-			}
-		}
-		while (remaining > 0) {
-			// now for the remaining data, allocate new buffers to store the data and append there
-			auto &new_block = CreateBlock();
-			auto handle = buffer_manager.Pin(new_block.block);
-
-			// offset the entry sizes array if we have added entries already
-			idx_t *offset_entry_sizes = entry_sizes ? entry_sizes + added_count - remaining : nullptr;
-
-			idx_t append_count = AppendToBlock(new_block, handle, append_entries, remaining, offset_entry_sizes);
-			D_ASSERT(new_block.count > 0);
-			remaining -= append_count;
-
-			if (keep_pinned) {
-				pinned_blocks.push_back(std::move(handle));
-			} else {
-				handles.push_back(std::move(handle));
-			}
-		}
-	}
-	// now set up the key_locations based on the append entries
-	idx_t append_idx = 0;
-	for (auto &append_entry : append_entries) {
-		idx_t next = append_idx + append_entry.count;
-		if (entry_sizes) {
-			for (; append_idx < next; append_idx++) {
-				key_locations[append_idx] = append_entry.baseptr;
-				append_entry.baseptr += entry_sizes[append_idx];
-			}
-		} else {
-			for (; append_idx < next; append_idx++) {
-				auto idx = sel->get_index(append_idx);
-				key_locations[idx] = append_entry.baseptr;
-				append_entry.baseptr += entry_size;
-			}
-		}
-	}
-	// return the unique pointers to the handles because they must stay pinned
-	return handles;
-}
-
-void RowDataCollection::Merge(RowDataCollection &other) {
-	if (other.count == 0) {
-		return;
-	}
-	RowDataCollection temp(buffer_manager, buffer_manager.GetBlockSize(), 1);
-	{
-		//	One lock at a time to avoid deadlocks
-		lock_guard<mutex> read_lock(other.rdc_lock);
-		temp.count = other.count;
-		temp.block_capacity = other.block_capacity;
-		temp.entry_size = other.entry_size;
-		temp.blocks = std::move(other.blocks);
-		temp.pinned_blocks = std::move(other.pinned_blocks);
-	}
-	other.Clear();
-
-	lock_guard<mutex> write_lock(rdc_lock);
-	count += temp.count;
-	block_capacity = MaxValue(block_capacity, temp.block_capacity);
-	entry_size = MaxValue(entry_size, temp.entry_size);
-	for (auto &block : temp.blocks) {
-		blocks.emplace_back(std::move(block));
-	}
-	for (auto &handle : temp.pinned_blocks) {
-		pinned_blocks.emplace_back(std::move(handle));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp b/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp
deleted file mode 100644
index 9b3a4be06..000000000
--- a/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-#include "duckdb/common/types/row/row_data_collection_scanner.hpp"
-
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row/row_data_collection.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include <numeric>
-
-namespace duckdb {
-
-void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block_collection,
-                                               RowDataCollection &swizzled_string_heap,
-                                               RowDataCollection &block_collection, RowDataCollection &string_heap,
-                                               const RowLayout &layout) {
-	if (block_collection.count == 0) {
-		return;
-	}
-
-	if (layout.AllConstant()) {
-		// No heap blocks! Just merge fixed-size data
-		swizzled_block_collection.Merge(block_collection);
-		return;
-	}
-
-	// We create one heap block per data block and swizzle the pointers
-	D_ASSERT(string_heap.keep_pinned == swizzled_string_heap.keep_pinned);
-	auto &buffer_manager = block_collection.buffer_manager;
-	auto &heap_blocks = string_heap.blocks;
-	idx_t heap_block_idx = 0;
-	idx_t heap_block_remaining = heap_blocks[heap_block_idx]->count;
-	for (auto &data_block : block_collection.blocks) {
-		if (heap_block_remaining == 0) {
-			heap_block_remaining = heap_blocks[++heap_block_idx]->count;
-		}
-
-		// Pin the data block and swizzle the pointers within the rows
-		auto data_handle = buffer_manager.Pin(data_block->block);
-		auto data_ptr = data_handle.Ptr();
-		if (!string_heap.keep_pinned) {
-			D_ASSERT(!data_block->block->IsSwizzled());
-			RowOperations::SwizzleColumns(layout, data_ptr, data_block->count);
-			data_block->block->SetSwizzling(nullptr);
-		}
-		// At this point the data block is pinned and the heap pointer is valid
-		// so we can copy heap data as needed
-
-		// We want to copy as little of the heap data as possible, check how the data and heap blocks line up
-		if (heap_block_remaining >= data_block->count) {
-			// Easy: current heap block contains all strings for this data block, just copy (reference) the block
-			swizzled_string_heap.blocks.emplace_back(heap_blocks[heap_block_idx]->Copy());
-			swizzled_string_heap.blocks.back()->count = data_block->count;
-
-			// Swizzle the heap pointer if we are not pinning the heap
-			auto &heap_block = swizzled_string_heap.blocks.back()->block;
-			auto heap_handle = buffer_manager.Pin(heap_block);
-			if (!swizzled_string_heap.keep_pinned) {
-				auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapOffset());
-				auto heap_offset = heap_ptr - heap_handle.Ptr();
-				RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block->count,
-				                                  NumericCast<idx_t>(heap_offset));
-			} else {
-				swizzled_string_heap.pinned_blocks.emplace_back(std::move(heap_handle));
-			}
-
-			// Update counter
-			heap_block_remaining -= data_block->count;
-		} else {
-			// Strings for this data block are spread over the current heap block and the next (and possibly more)
-			if (string_heap.keep_pinned) {
-				// The heap is changing underneath the data block,
-				// so swizzle the string pointers to make them portable.
-				RowOperations::SwizzleColumns(layout, data_ptr, data_block->count);
-			}
-			idx_t data_block_remaining = data_block->count;
-			vector<std::pair<data_ptr_t, idx_t>> ptrs_and_sizes;
-			idx_t total_size = 0;
-			const auto base_row_ptr = data_ptr;
-			while (data_block_remaining > 0) {
-				if (heap_block_remaining == 0) {
-					heap_block_remaining = heap_blocks[++heap_block_idx]->count;
-				}
-				auto next = MinValue<idx_t>(data_block_remaining, heap_block_remaining);
-
-				// Figure out where to start copying strings, and how many bytes we need to copy
-				auto heap_start_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapOffset());
-				auto heap_end_ptr =
-				    Load<data_ptr_t>(data_ptr + layout.GetHeapOffset() + (next - 1) * layout.GetRowWidth());
-				auto size = NumericCast<idx_t>(heap_end_ptr - heap_start_ptr + Load<uint32_t>(heap_end_ptr));
-				ptrs_and_sizes.emplace_back(heap_start_ptr, size);
-				D_ASSERT(size <= heap_blocks[heap_block_idx]->byte_offset);
-
-				// Swizzle the heap pointer
-				RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_start_ptr, next, total_size);
-				total_size += size;
-
-				// Update where we are in the data and heap blocks
-				data_ptr += next * layout.GetRowWidth();
-				data_block_remaining -= next;
-				heap_block_remaining -= next;
-			}
-
-			// Finally, we allocate a new heap block and copy data to it
-			swizzled_string_heap.blocks.emplace_back(make_uniq<RowDataBlock>(
-			    MemoryTag::ORDER_BY, buffer_manager, MaxValue<idx_t>(total_size, buffer_manager.GetBlockSize()), 1U));
-			auto new_heap_handle = buffer_manager.Pin(swizzled_string_heap.blocks.back()->block);
-			auto new_heap_ptr = new_heap_handle.Ptr();
-			for (auto &ptr_and_size : ptrs_and_sizes) {
-				memcpy(new_heap_ptr, ptr_and_size.first, ptr_and_size.second);
-				new_heap_ptr += ptr_and_size.second;
-			}
-			new_heap_ptr = new_heap_handle.Ptr();
-			if (swizzled_string_heap.keep_pinned) {
-				// Since the heap blocks are pinned, we can unswizzle the data again.
-				swizzled_string_heap.pinned_blocks.emplace_back(std::move(new_heap_handle));
-				RowOperations::UnswizzlePointers(layout, base_row_ptr, new_heap_ptr, data_block->count);
-				RowOperations::UnswizzleHeapPointer(layout, base_row_ptr, new_heap_ptr, data_block->count);
-			}
-		}
-	}
-
-	// We're done with variable-sized data, now just merge the fixed-size data
-	swizzled_block_collection.Merge(block_collection);
-	D_ASSERT(swizzled_block_collection.blocks.size() == swizzled_string_heap.blocks.size());
-
-	// Update counts and cleanup
-	swizzled_string_heap.count = string_heap.count;
-	string_heap.Clear();
-}
-
-void RowDataCollectionScanner::ScanState::PinData() {
-	auto &rows = scanner.rows;
-	D_ASSERT(block_idx < rows.blocks.size());
-	auto &data_block = rows.blocks[block_idx];
-	if (!data_handle.IsValid() || data_handle.GetBlockHandle() != data_block->block) {
-		data_handle = rows.buffer_manager.Pin(data_block->block);
-	}
-	if (scanner.layout.AllConstant() || !scanner.external) {
-		return;
-	}
-
-	auto &heap = scanner.heap;
-	D_ASSERT(block_idx < heap.blocks.size());
-	auto &heap_block = heap.blocks[block_idx];
-	if (!heap_handle.IsValid() || heap_handle.GetBlockHandle() != heap_block->block) {
-		heap_handle = heap.buffer_manager.Pin(heap_block->block);
-	}
-}
-
-RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, RowDataCollection &heap_p,
-                                                   const RowLayout &layout_p, bool external_p, bool flush_p)
-    : rows(rows_p), heap(heap_p), layout(layout_p), read_state(*this), total_count(rows.count), total_scanned(0),
-      external(external_p), flush(flush_p), unswizzling(!layout.AllConstant() && external && !heap.keep_pinned) {
-
-	if (unswizzling) {
-		D_ASSERT(rows.blocks.size() == heap.blocks.size());
-	}
-
-	ValidateUnscannedBlock();
-}
-
-RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, RowDataCollection &heap_p,
-                                                   const RowLayout &layout_p, bool external_p, idx_t block_idx,
-                                                   bool flush_p)
-    : rows(rows_p), heap(heap_p), layout(layout_p), read_state(*this), total_count(rows.count), total_scanned(0),
-      external(external_p), flush(flush_p), unswizzling(!layout.AllConstant() && external && !heap.keep_pinned) {
-
-	if (unswizzling) {
-		D_ASSERT(rows.blocks.size() == heap.blocks.size());
-	}
-
-	D_ASSERT(block_idx < rows.blocks.size());
-	read_state.block_idx = block_idx;
-	read_state.entry_idx = 0;
-
-	//	Pretend that we have scanned up to the start block
-	//	and will stop at the end
-	auto begin = rows.blocks.begin();
-	auto end = begin + NumericCast<int64_t>(block_idx);
-	total_scanned =
-	    std::accumulate(begin, end, idx_t(0), [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-	total_count = total_scanned + (*end)->count;
-
-	ValidateUnscannedBlock();
-}
-
-void RowDataCollectionScanner::SwizzleBlockInternal(RowDataBlock &data_block, RowDataBlock &heap_block) {
-	// Pin the data block and swizzle the pointers within the rows
-	D_ASSERT(!data_block.block->IsSwizzled());
-	auto data_handle = rows.buffer_manager.Pin(data_block.block);
-	auto data_ptr = data_handle.Ptr();
-	RowOperations::SwizzleColumns(layout, data_ptr, data_block.count);
-	data_block.block->SetSwizzling(nullptr);
-
-	// Swizzle the heap pointers
-	auto heap_handle = heap.buffer_manager.Pin(heap_block.block);
-	auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapOffset());
-	auto heap_offset = heap_ptr - heap_handle.Ptr();
-	RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, NumericCast<idx_t>(heap_offset));
-}
-
-void RowDataCollectionScanner::SwizzleBlock(idx_t block_idx) {
-	if (rows.count == 0) {
-		return;
-	}
-
-	if (!unswizzling) {
-		// No swizzled blocks!
-		return;
-	}
-
-	auto &data_block = rows.blocks[block_idx];
-	if (data_block->block && !data_block->block->IsSwizzled()) {
-		SwizzleBlockInternal(*data_block, *heap.blocks[block_idx]);
-	}
-}
-
-void RowDataCollectionScanner::ReSwizzle() {
-	if (rows.count == 0) {
-		return;
-	}
-
-	if (!unswizzling) {
-		// No swizzled blocks!
-		return;
-	}
-
-	D_ASSERT(rows.blocks.size() == heap.blocks.size());
-	for (idx_t i = 0; i < rows.blocks.size(); ++i) {
-		auto &data_block = rows.blocks[i];
-		if (data_block->block && !data_block->block->IsSwizzled()) {
-			SwizzleBlockInternal(*data_block, *heap.blocks[i]);
-		}
-	}
-}
-
-void RowDataCollectionScanner::ValidateUnscannedBlock() const {
-	if (unswizzling && read_state.block_idx < rows.blocks.size() && Remaining()) {
-		D_ASSERT(rows.blocks[read_state.block_idx]->block->IsSwizzled());
-	}
-}
-
-void RowDataCollectionScanner::Scan(DataChunk &chunk) {
-	auto count = MinValue((idx_t)STANDARD_VECTOR_SIZE, total_count - total_scanned);
-	if (count == 0) {
-		chunk.SetCardinality(count);
-		return;
-	}
-
-	//	Only flush blocks we processed.
-	const auto flush_block_idx = read_state.block_idx;
-
-	const idx_t &row_width = layout.GetRowWidth();
-	// Set up a batch of pointers to scan data from
-	idx_t scanned = 0;
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-
-	// We must pin ALL blocks we are going to gather from
-	vector<BufferHandle> pinned_blocks;
-	while (scanned < count) {
-		read_state.PinData();
-		auto &data_block = rows.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.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++) {
-			data_pointers[scanned + i] = row_ptr;
-			row_ptr += row_width;
-		}
-		// Unswizzle the offsets back to pointers (if needed)
-		if (unswizzling) {
-			RowOperations::UnswizzlePointers(layout, data_ptr, read_state.heap_handle.Ptr(), next);
-			rows.blocks[read_state.block_idx]->block->SetSwizzling("RowDataCollectionScanner::Scan");
-		}
-		// Update state indices
-		read_state.entry_idx += next;
-		scanned += next;
-		total_scanned += next;
-		if (read_state.entry_idx == data_block->count) {
-			// Pin completed blocks so we don't lose them
-			pinned_blocks.emplace_back(rows.buffer_manager.Pin(data_block->block));
-			if (unswizzling) {
-				auto &heap_block = heap.blocks[read_state.block_idx];
-				pinned_blocks.emplace_back(heap.buffer_manager.Pin(heap_block->block));
-			}
-			read_state.block_idx++;
-			read_state.entry_idx = 0;
-			ValidateUnscannedBlock();
-		}
-	}
-	D_ASSERT(scanned == count);
-	// Deserialize the payload data
-	for (idx_t col_no = 0; col_no < layout.ColumnCount(); col_no++) {
-		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_no],
-		                      *FlatVector::IncrementalSelectionVector(), count, layout, col_no);
-	}
-	chunk.SetCardinality(count);
-	chunk.Verify();
-
-	//	Switch to a new set of pinned blocks
-	read_state.pinned_blocks.swap(pinned_blocks);
-
-	if (flush) {
-		// Release blocks we have passed.
-		for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
-			rows.blocks[i]->block = nullptr;
-			if (unswizzling) {
-				heap.blocks[i]->block = nullptr;
-			}
-		}
-	} else if (unswizzling) {
-		// Reswizzle blocks we have passed so they can be flushed safely.
-		for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
-			auto &data_block = rows.blocks[i];
-			if (data_block->block && !data_block->block->IsSwizzled()) {
-				SwizzleBlockInternal(*data_block, *heap.blocks[i]);
-			}
-		}
-	}
-}
-
-void RowDataCollectionScanner::Reset(bool flush_p) {
-	flush = flush_p;
-	total_scanned = 0;
-
-	read_state.block_idx = 0;
-	read_state.entry_idx = 0;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/row_layout.cpp b/src/duckdb/src/common/types/row/row_layout.cpp
deleted file mode 100644
index 3add8e425..000000000
--- a/src/duckdb/src/common/types/row/row_layout.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_layout.cpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/types/row/row_layout.hpp"
-
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-RowLayout::RowLayout() : flag_width(0), data_width(0), row_width(0), all_constant(true), heap_pointer_offset(0) {
-}
-
-void RowLayout::Initialize(vector<LogicalType> types_p, bool align) {
-	offsets.clear();
-	types = std::move(types_p);
-
-	// Null mask at the front - 1 bit per value.
-	flag_width = ValidityBytes::ValidityMaskSize(types.size());
-	row_width = flag_width;
-
-	// Whether all columns are constant size.
-	for (const auto &type : types) {
-		all_constant = all_constant && TypeIsConstantSize(type.InternalType());
-	}
-
-	// This enables pointer swizzling for out-of-core computation.
-	if (!all_constant) {
-		// When unswizzled, the pointer lives here.
-		// When swizzled, the pointer is replaced by an offset.
-		heap_pointer_offset = row_width;
-		// The 8 byte pointer will be replaced with an 8 byte idx_t when swizzled.
-		// However, this cannot be sizeof(data_ptr_t), since 32 bit builds use 4 byte pointers.
-		row_width += sizeof(idx_t);
-	}
-
-	// Data columns. No alignment required.
-	for (const auto &type : types) {
-		offsets.push_back(row_width);
-		const auto internal_type = type.InternalType();
-		if (TypeIsConstantSize(internal_type) || internal_type == PhysicalType::VARCHAR) {
-			row_width += GetTypeIdSize(type.InternalType());
-		} else {
-			// Variable size types use pointers to the actual data (can be swizzled).
-			// Again, we would use sizeof(data_ptr_t), but this is not guaranteed to be equal to sizeof(idx_t).
-			row_width += sizeof(idx_t);
-		}
-	}
-
-	data_width = row_width - flag_width;
-
-	// Alignment padding for the next row
-	if (align) {
-		row_width = AlignValue(row_width);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/tuple_data_allocator.cpp b/src/duckdb/src/common/types/row/tuple_data_allocator.cpp
deleted file mode 100644
index ed9145a11..000000000
--- a/src/duckdb/src/common/types/row/tuple_data_allocator.cpp
+++ /dev/null
@@ -1,528 +0,0 @@
-#include "duckdb/common/types/row/tuple_data_allocator.hpp"
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/types/row/tuple_data_segment.hpp"
-#include "duckdb/common/types/row/tuple_data_states.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = TupleDataLayout::ValidityBytes;
-
-TupleDataBlock::TupleDataBlock(BufferManager &buffer_manager, idx_t capacity_p) : capacity(capacity_p), size(0) {
-	auto buffer_handle = buffer_manager.Allocate(MemoryTag::HASH_TABLE, capacity, false);
-	handle = buffer_handle.GetBlockHandle();
-}
-
-TupleDataBlock::TupleDataBlock(TupleDataBlock &&other) noexcept : capacity(0), size(0) {
-	std::swap(handle, other.handle);
-	std::swap(capacity, other.capacity);
-	std::swap(size, other.size);
-}
-
-TupleDataBlock &TupleDataBlock::operator=(TupleDataBlock &&other) noexcept {
-	std::swap(handle, other.handle);
-	std::swap(capacity, other.capacity);
-	std::swap(size, other.size);
-	return *this;
-}
-
-TupleDataAllocator::TupleDataAllocator(BufferManager &buffer_manager, const TupleDataLayout &layout)
-    : buffer_manager(buffer_manager), layout(layout.Copy()) {
-}
-
-TupleDataAllocator::TupleDataAllocator(TupleDataAllocator &allocator)
-    : buffer_manager(allocator.buffer_manager), layout(allocator.layout.Copy()) {
-}
-
-void TupleDataAllocator::SetDestroyBufferUponUnpin() {
-	for (auto &block : row_blocks) {
-		if (block.handle) {
-			block.handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
-		}
-	}
-	for (auto &block : heap_blocks) {
-		if (block.handle) {
-			block.handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
-		}
-	}
-}
-
-TupleDataAllocator::~TupleDataAllocator() {
-	SetDestroyBufferUponUnpin();
-}
-
-BufferManager &TupleDataAllocator::GetBufferManager() {
-	return buffer_manager;
-}
-
-Allocator &TupleDataAllocator::GetAllocator() {
-	return buffer_manager.GetBufferAllocator();
-}
-
-const TupleDataLayout &TupleDataAllocator::GetLayout() const {
-	return layout;
-}
-
-idx_t TupleDataAllocator::RowBlockCount() const {
-	return row_blocks.size();
-}
-
-idx_t TupleDataAllocator::HeapBlockCount() const {
-	return heap_blocks.size();
-}
-
-void TupleDataAllocator::SetPartitionIndex(const idx_t index) {
-	D_ASSERT(!partition_index.IsValid());
-	D_ASSERT(row_blocks.empty() && heap_blocks.empty());
-	partition_index = index;
-}
-
-void TupleDataAllocator::Build(TupleDataSegment &segment, TupleDataPinState &pin_state,
-                               TupleDataChunkState &chunk_state, const idx_t append_offset, const idx_t append_count) {
-	D_ASSERT(this == segment.allocator.get());
-	auto &chunks = segment.chunks;
-	if (!chunks.empty()) {
-		ReleaseOrStoreHandles(pin_state, segment, chunks.back(), true);
-	}
-
-	// Build the chunk parts for the incoming data
-	chunk_part_indices.clear();
-	idx_t offset = 0;
-	while (offset != append_count) {
-		if (chunks.empty() || chunks.back().count == STANDARD_VECTOR_SIZE) {
-			chunks.emplace_back();
-		}
-		auto &chunk = chunks.back();
-
-		// Build the next part
-		auto next = MinValue<idx_t>(append_count - offset, STANDARD_VECTOR_SIZE - chunk.count);
-		chunk.AddPart(BuildChunkPart(pin_state, chunk_state, append_offset + offset, next, chunk), layout);
-		auto &chunk_part = chunk.parts.back();
-		next = chunk_part.count;
-
-		segment.count += next;
-		segment.data_size += chunk_part.count * layout.GetRowWidth();
-		if (!layout.AllConstant()) {
-			segment.data_size += chunk_part.total_heap_size;
-		}
-
-		if (layout.HasDestructor()) {
-			const auto base_row_ptr = GetRowPointer(pin_state, chunk_part);
-			for (auto &aggr_idx : layout.GetAggregateDestructorIndices()) {
-				const auto aggr_offset = layout.GetOffsets()[layout.ColumnCount() + aggr_idx];
-				auto &aggr_fun = layout.GetAggregates()[aggr_idx];
-				for (idx_t i = 0; i < next; i++) {
-					duckdb::FastMemset(base_row_ptr + i * layout.GetRowWidth() + aggr_offset, '\0',
-					                   aggr_fun.payload_size);
-				}
-			}
-		}
-
-		offset += next;
-		chunk_part_indices.emplace_back(chunks.size() - 1, chunk.parts.size() - 1);
-	}
-
-	// Now initialize the pointers to write the data to
-	chunk_parts.clear();
-	for (auto &indices : chunk_part_indices) {
-		chunk_parts.emplace_back(segment.chunks[indices.first].parts[indices.second]);
-	}
-	InitializeChunkStateInternal(pin_state, chunk_state, append_offset, false, true, false, chunk_parts);
-
-	// To reduce metadata, we try to merge chunk parts where possible
-	// Due to the way chunk parts are constructed, only the last part of the first chunk is eligible for merging
-	segment.chunks[chunk_part_indices[0].first].MergeLastChunkPart(layout);
-
-	segment.Verify();
-}
-
-TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-                                                      const idx_t append_offset, const idx_t append_count,
-                                                      TupleDataChunk &chunk) {
-	D_ASSERT(append_count != 0);
-	TupleDataChunkPart result(*chunk.lock);
-	const auto block_size = buffer_manager.GetBlockSize();
-
-	// Allocate row block (if needed)
-	if (row_blocks.empty() || row_blocks.back().RemainingCapacity() < layout.GetRowWidth()) {
-		row_blocks.emplace_back(buffer_manager, block_size);
-		if (partition_index.IsValid()) { // Set the eviction queue index logarithmically using RadixBits
-			row_blocks.back().handle->SetEvictionQueueIndex(RadixPartitioning::RadixBits(partition_index.GetIndex()));
-		}
-	}
-	result.row_block_index = NumericCast<uint32_t>(row_blocks.size() - 1);
-	auto &row_block = row_blocks[result.row_block_index];
-	result.row_block_offset = NumericCast<uint32_t>(row_block.size);
-
-	// Set count (might be reduced later when checking heap space)
-	result.count = NumericCast<uint32_t>(MinValue(row_block.RemainingCapacity(layout.GetRowWidth()), append_count));
-	if (!layout.AllConstant()) {
-		const auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
-
-		// Compute total heap size first
-		idx_t total_heap_size = 0;
-		for (idx_t i = 0; i < result.count; i++) {
-			const auto &heap_size = heap_sizes[append_offset + i];
-			total_heap_size += heap_size;
-		}
-
-		if (total_heap_size == 0) {
-			result.SetHeapEmpty();
-		} else {
-			const auto heap_remaining = MaxValue<idx_t>(
-			    heap_blocks.empty() ? block_size : heap_blocks.back().RemainingCapacity(), heap_sizes[append_offset]);
-
-			if (total_heap_size <= heap_remaining) {
-				// Everything fits
-				result.total_heap_size = NumericCast<uint32_t>(total_heap_size);
-			} else {
-				// Not everything fits - determine how many we can read next
-				result.total_heap_size = 0;
-				for (idx_t i = 0; i < result.count; i++) {
-					const auto &heap_size = heap_sizes[append_offset + i];
-					if (result.total_heap_size + heap_size > heap_remaining) {
-						result.count = NumericCast<uint32_t>(i);
-						break;
-					}
-					result.total_heap_size += heap_size;
-				}
-			}
-
-			if (result.total_heap_size == 0) {
-				result.SetHeapEmpty();
-			} else {
-				// Allocate heap block (if needed)
-				if (heap_blocks.empty() || heap_blocks.back().RemainingCapacity() < heap_sizes[append_offset]) {
-					const auto size = MaxValue<idx_t>(block_size, heap_sizes[append_offset]);
-					heap_blocks.emplace_back(buffer_manager, size);
-					if (partition_index.IsValid()) { // Set the eviction queue index logarithmically using RadixBits
-						heap_blocks.back().handle->SetEvictionQueueIndex(
-						    RadixPartitioning::RadixBits(partition_index.GetIndex()));
-					}
-				}
-				result.heap_block_index = NumericCast<uint32_t>(heap_blocks.size() - 1);
-				auto &heap_block = heap_blocks[result.heap_block_index];
-				result.heap_block_offset = NumericCast<uint32_t>(heap_block.size);
-
-				// Mark this portion of the heap block as filled and set the pointer
-				heap_block.size += result.total_heap_size;
-				result.base_heap_ptr = GetBaseHeapPointer(pin_state, result);
-			}
-		}
-	}
-	D_ASSERT(result.count != 0 && result.count <= STANDARD_VECTOR_SIZE);
-
-	// Mark this portion of the row block as filled
-	row_block.size += result.count * layout.GetRowWidth();
-
-	return result;
-}
-
-void TupleDataAllocator::InitializeChunkState(TupleDataSegment &segment, TupleDataPinState &pin_state,
-                                              TupleDataChunkState &chunk_state, idx_t chunk_idx, bool init_heap) {
-	D_ASSERT(this == segment.allocator.get());
-	D_ASSERT(chunk_idx < segment.ChunkCount());
-	auto &chunk = segment.chunks[chunk_idx];
-
-	// Release or store any handles that are no longer required:
-	// We can't release the heap here if the current chunk's heap_block_ids is empty, because if we are iterating with
-	// PinProperties::DESTROY_AFTER_DONE, we might destroy a heap block that is needed by a later chunk, e.g.,
-	// when chunk 0 needs heap block 0, chunk 1 does not need any heap blocks, and chunk 2 needs heap block 0 again
-	ReleaseOrStoreHandles(pin_state, segment, chunk, !chunk.heap_block_ids.empty());
-
-	unsafe_vector<reference<TupleDataChunkPart>> parts;
-	parts.reserve(chunk.parts.size());
-	for (auto &part : chunk.parts) {
-		parts.emplace_back(part);
-	}
-
-	InitializeChunkStateInternal(pin_state, chunk_state, 0, true, init_heap, init_heap, parts);
-}
-
-static inline void InitializeHeapSizes(const data_ptr_t row_locations[], idx_t heap_sizes[], const idx_t offset,
-                                       const idx_t next, const TupleDataChunkPart &part, const idx_t heap_size_offset) {
-	// Read the heap sizes from the rows
-	for (idx_t i = 0; i < next; i++) {
-		auto idx = offset + i;
-		heap_sizes[idx] = Load<uint32_t>(row_locations[idx] + heap_size_offset);
-	}
-
-	// Verify total size
-#ifdef DEBUG
-	idx_t total_heap_size = 0;
-	for (idx_t i = 0; i < next; i++) {
-		auto idx = offset + i;
-		total_heap_size += heap_sizes[idx];
-	}
-	D_ASSERT(total_heap_size == part.total_heap_size);
-#endif
-}
-
-void TupleDataAllocator::InitializeChunkStateInternal(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-                                                      idx_t offset, bool recompute, bool init_heap_pointers,
-                                                      bool init_heap_sizes,
-                                                      unsafe_vector<reference<TupleDataChunkPart>> &parts) {
-	auto row_locations = FlatVector::GetData<data_ptr_t>(chunk_state.row_locations);
-	auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
-	auto heap_locations = FlatVector::GetData<data_ptr_t>(chunk_state.heap_locations);
-
-	for (auto &part_ref : parts) {
-		auto &part = part_ref.get();
-		const auto next = part.count;
-
-		// Set up row locations for the scan
-		const auto row_width = layout.GetRowWidth();
-		const auto base_row_ptr = GetRowPointer(pin_state, part);
-		for (idx_t i = 0; i < next; i++) {
-			row_locations[offset + i] = base_row_ptr + i * row_width;
-		}
-
-		if (layout.AllConstant()) { // Can't have a heap
-			offset += next;
-			continue;
-		}
-
-		if (part.total_heap_size == 0) {
-			if (init_heap_sizes) { // No heap, but we need the heap sizes
-				InitializeHeapSizes(row_locations, heap_sizes, offset, next, part, layout.GetHeapSizeOffset());
-			}
-			offset += next;
-			continue;
-		}
-
-		// Check if heap block has changed - re-compute the pointers within each row if so
-		if (recompute && pin_state.properties != TupleDataPinProperties::ALREADY_PINNED) {
-			const auto new_base_heap_ptr = GetBaseHeapPointer(pin_state, part);
-			if (part.base_heap_ptr != new_base_heap_ptr) {
-				lock_guard<mutex> guard(part.lock);
-				const auto old_base_heap_ptr = part.base_heap_ptr;
-				if (old_base_heap_ptr != new_base_heap_ptr) {
-					Vector old_heap_ptrs(
-					    Value::POINTER(CastPointerToValue(old_base_heap_ptr + part.heap_block_offset)));
-					Vector new_heap_ptrs(
-					    Value::POINTER(CastPointerToValue(new_base_heap_ptr + part.heap_block_offset)));
-					RecomputeHeapPointers(old_heap_ptrs, *ConstantVector::ZeroSelectionVector(), row_locations,
-					                      new_heap_ptrs, offset, next, layout, 0);
-					part.base_heap_ptr = new_base_heap_ptr;
-				}
-			}
-		}
-
-		if (init_heap_sizes) {
-			InitializeHeapSizes(row_locations, heap_sizes, offset, next, part, layout.GetHeapSizeOffset());
-		}
-
-		if (init_heap_pointers) {
-			// Set the pointers where the heap data will be written (if needed)
-			heap_locations[offset] = part.base_heap_ptr + part.heap_block_offset;
-			for (idx_t i = 1; i < next; i++) {
-				auto idx = offset + i;
-				heap_locations[idx] = heap_locations[idx - 1] + heap_sizes[idx - 1];
-			}
-		}
-
-		offset += next;
-	}
-	D_ASSERT(offset <= STANDARD_VECTOR_SIZE);
-}
-
-static inline void VerifyStrings(const TupleDataLayout &layout, const LogicalTypeId type_id,
-                                 const data_ptr_t row_locations[], const idx_t col_idx, const idx_t base_col_offset,
-                                 const idx_t col_offset, const idx_t offset, const idx_t count) {
-#ifdef DEBUG
-	if (type_id != LogicalTypeId::VARCHAR) {
-		// Make sure we don't verify BLOB / AGGREGATE_STATE
-		return;
-	}
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-	for (idx_t i = 0; i < count; i++) {
-		const auto &row_location = row_locations[offset + i] + base_col_offset;
-		ValidityBytes row_mask(row_location, layout.ColumnCount());
-		if (row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
-			auto recomputed_string = Load<string_t>(row_location + col_offset);
-			recomputed_string.Verify();
-		}
-	}
-#endif
-}
-
-void TupleDataAllocator::RecomputeHeapPointers(Vector &old_heap_ptrs, const SelectionVector &old_heap_sel,
-                                               const data_ptr_t row_locations[], Vector &new_heap_ptrs,
-                                               const idx_t offset, const idx_t count, const TupleDataLayout &layout,
-                                               const idx_t base_col_offset) {
-	const auto old_heap_locations = FlatVector::GetData<data_ptr_t>(old_heap_ptrs);
-
-	UnifiedVectorFormat new_heap_data;
-	new_heap_ptrs.ToUnifiedFormat(offset + count, new_heap_data);
-	const auto new_heap_locations = UnifiedVectorFormat::GetData<data_ptr_t>(new_heap_data);
-	const auto new_heap_sel = *new_heap_data.sel;
-
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		const auto &col_offset = layout.GetOffsets()[col_idx];
-
-		// Precompute mask indexes
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-		const auto &type = layout.GetTypes()[col_idx];
-		switch (type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			for (idx_t i = 0; i < count; i++) {
-				const auto idx = offset + i;
-				const auto &row_location = row_locations[idx] + base_col_offset;
-				ValidityBytes row_mask(row_location, layout.ColumnCount());
-				if (!row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
-					continue;
-				}
-
-				const auto &old_heap_ptr = old_heap_locations[old_heap_sel.get_index(idx)];
-				const auto &new_heap_ptr = new_heap_locations[new_heap_sel.get_index(idx)];
-
-				const auto string_location = row_location + col_offset;
-				if (Load<uint32_t>(string_location) > string_t::INLINE_LENGTH) {
-					const auto string_ptr_location = string_location + string_t::HEADER_SIZE;
-					const auto string_ptr = Load<data_ptr_t>(string_ptr_location);
-					const auto diff = string_ptr - old_heap_ptr;
-					D_ASSERT(diff >= 0);
-					Store<data_ptr_t>(new_heap_ptr + diff, string_ptr_location);
-				}
-			}
-			VerifyStrings(layout, type.id(), row_locations, col_idx, base_col_offset, col_offset, offset, count);
-			break;
-		}
-		case PhysicalType::LIST:
-		case PhysicalType::ARRAY: {
-			for (idx_t i = 0; i < count; i++) {
-				const auto idx = offset + i;
-				const auto &row_location = row_locations[idx] + base_col_offset;
-				ValidityBytes row_mask(row_location, layout.ColumnCount());
-				if (!row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
-					continue;
-				}
-
-				const auto &old_heap_ptr = old_heap_locations[old_heap_sel.get_index(idx)];
-				const auto &new_heap_ptr = new_heap_locations[new_heap_sel.get_index(idx)];
-
-				const auto &list_ptr_location = row_location + col_offset;
-				const auto list_ptr = Load<data_ptr_t>(list_ptr_location);
-				const auto diff = list_ptr - old_heap_ptr;
-				D_ASSERT(diff >= 0);
-				Store<data_ptr_t>(new_heap_ptr + diff, list_ptr_location);
-			}
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			const auto &struct_layout = layout.GetStructLayout(col_idx);
-			if (!struct_layout.AllConstant()) {
-				RecomputeHeapPointers(old_heap_ptrs, old_heap_sel, row_locations, new_heap_ptrs, offset, count,
-				                      struct_layout, base_col_offset + col_offset);
-			}
-			break;
-		}
-		default:
-			continue;
-		}
-	}
-}
-
-void TupleDataAllocator::ReleaseOrStoreHandles(TupleDataPinState &pin_state, TupleDataSegment &segment,
-                                               TupleDataChunk &chunk, bool release_heap) {
-	D_ASSERT(this == segment.allocator.get());
-	ReleaseOrStoreHandlesInternal(segment, segment.pinned_row_handles, pin_state.row_handles, chunk.row_block_ids,
-	                              row_blocks, pin_state.properties);
-	if (!layout.AllConstant() && release_heap) {
-		ReleaseOrStoreHandlesInternal(segment, segment.pinned_heap_handles, pin_state.heap_handles,
-		                              chunk.heap_block_ids, heap_blocks, pin_state.properties);
-	}
-}
-
-void TupleDataAllocator::ReleaseOrStoreHandles(TupleDataPinState &pin_state, TupleDataSegment &segment) {
-	static TupleDataChunk DUMMY_CHUNK;
-	ReleaseOrStoreHandles(pin_state, segment, DUMMY_CHUNK, true);
-}
-
-void TupleDataAllocator::ReleaseOrStoreHandlesInternal(
-    TupleDataSegment &segment, unsafe_vector<BufferHandle> &pinned_handles, perfect_map_t<BufferHandle> &handles,
-    const perfect_set_t &block_ids, unsafe_vector<TupleDataBlock> &blocks, TupleDataPinProperties properties) {
-	bool found_handle;
-	do {
-		found_handle = false;
-		for (auto it = handles.begin(); it != handles.end(); it++) {
-			const auto block_id = it->first;
-			if (block_ids.find(block_id) != block_ids.end()) {
-				// still required: do not release
-				continue;
-			}
-			switch (properties) {
-			case TupleDataPinProperties::KEEP_EVERYTHING_PINNED: {
-				lock_guard<mutex> guard(segment.pinned_handles_lock);
-				const auto block_count = block_id + 1;
-				if (block_count > pinned_handles.size()) {
-					pinned_handles.resize(block_count);
-				}
-				pinned_handles[block_id] = std::move(it->second);
-				break;
-			}
-			case TupleDataPinProperties::UNPIN_AFTER_DONE:
-			case TupleDataPinProperties::ALREADY_PINNED:
-				break;
-			case TupleDataPinProperties::DESTROY_AFTER_DONE:
-				// Prevent it from being added to the eviction queue
-				blocks[block_id].handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
-				// Destroy
-				blocks[block_id].handle.reset();
-				break;
-			default:
-				D_ASSERT(properties == TupleDataPinProperties::INVALID);
-				throw InternalException("Encountered TupleDataPinProperties::INVALID");
-			}
-			handles.erase(it);
-			found_handle = true;
-			break;
-		}
-	} while (found_handle);
-}
-
-BufferHandle &TupleDataAllocator::PinRowBlock(TupleDataPinState &pin_state, const TupleDataChunkPart &part) {
-	const auto &row_block_index = part.row_block_index;
-	auto it = pin_state.row_handles.find(row_block_index);
-	if (it == pin_state.row_handles.end()) {
-		D_ASSERT(row_block_index < row_blocks.size());
-		auto &row_block = row_blocks[row_block_index];
-		D_ASSERT(row_block.handle);
-		D_ASSERT(part.row_block_offset < row_block.size);
-		D_ASSERT(part.row_block_offset + part.count * layout.GetRowWidth() <= row_block.size);
-		it = pin_state.row_handles.emplace(row_block_index, buffer_manager.Pin(row_block.handle)).first;
-	}
-	return it->second;
-}
-
-BufferHandle &TupleDataAllocator::PinHeapBlock(TupleDataPinState &pin_state, const TupleDataChunkPart &part) {
-	const auto &heap_block_index = part.heap_block_index;
-	auto it = pin_state.heap_handles.find(heap_block_index);
-	if (it == pin_state.heap_handles.end()) {
-		D_ASSERT(heap_block_index < heap_blocks.size());
-		auto &heap_block = heap_blocks[heap_block_index];
-		D_ASSERT(heap_block.handle);
-		D_ASSERT(part.heap_block_offset < heap_block.size);
-		D_ASSERT(part.heap_block_offset + part.total_heap_size <= heap_block.size);
-		it = pin_state.heap_handles.emplace(heap_block_index, buffer_manager.Pin(heap_block.handle)).first;
-	}
-	return it->second;
-}
-
-data_ptr_t TupleDataAllocator::GetRowPointer(TupleDataPinState &pin_state, const TupleDataChunkPart &part) {
-	return PinRowBlock(pin_state, part).Ptr() + part.row_block_offset;
-}
-
-data_ptr_t TupleDataAllocator::GetBaseHeapPointer(TupleDataPinState &pin_state, const TupleDataChunkPart &part) {
-	return PinHeapBlock(pin_state, part).Ptr();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/tuple_data_collection.cpp b/src/duckdb/src/common/types/row/tuple_data_collection.cpp
deleted file mode 100644
index 7db3ba37a..000000000
--- a/src/duckdb/src/common/types/row/tuple_data_collection.cpp
+++ /dev/null
@@ -1,611 +0,0 @@
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types/row/tuple_data_allocator.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-using ValidityBytes = TupleDataLayout::ValidityBytes;
-
-TupleDataCollection::TupleDataCollection(BufferManager &buffer_manager, const TupleDataLayout &layout_p)
-    : layout(layout_p.Copy()), allocator(make_shared_ptr<TupleDataAllocator>(buffer_manager, layout)) {
-	Initialize();
-}
-
-TupleDataCollection::TupleDataCollection(shared_ptr<TupleDataAllocator> allocator)
-    : layout(allocator->GetLayout().Copy()), allocator(std::move(allocator)) {
-	Initialize();
-}
-
-TupleDataCollection::~TupleDataCollection() {
-}
-
-void TupleDataCollection::Initialize() {
-	D_ASSERT(!layout.GetTypes().empty());
-	this->count = 0;
-	this->data_size = 0;
-	scatter_functions.reserve(layout.ColumnCount());
-	gather_functions.reserve(layout.ColumnCount());
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		auto &type = layout.GetTypes()[col_idx];
-		scatter_functions.emplace_back(GetScatterFunction(type));
-		gather_functions.emplace_back(GetGatherFunction(type));
-	}
-}
-
-void GetAllColumnIDsInternal(vector<column_t> &column_ids, const idx_t column_count) {
-	column_ids.reserve(column_count);
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-		column_ids.emplace_back(col_idx);
-	}
-}
-
-void TupleDataCollection::GetAllColumnIDs(vector<column_t> &column_ids) {
-	GetAllColumnIDsInternal(column_ids, layout.ColumnCount());
-}
-
-const TupleDataLayout &TupleDataCollection::GetLayout() const {
-	return layout;
-}
-
-const idx_t &TupleDataCollection::Count() const {
-	return count;
-}
-
-idx_t TupleDataCollection::ChunkCount() const {
-	idx_t total_chunk_count = 0;
-	for (const auto &segment : segments) {
-		total_chunk_count += segment.ChunkCount();
-	}
-	return total_chunk_count;
-}
-
-idx_t TupleDataCollection::SizeInBytes() const {
-	idx_t total_size = 0;
-	for (const auto &segment : segments) {
-		total_size += segment.SizeInBytes();
-	}
-	return total_size;
-}
-
-void TupleDataCollection::Unpin() {
-	for (auto &segment : segments) {
-		segment.Unpin();
-	}
-}
-
-void TupleDataCollection::SetPartitionIndex(const idx_t index) {
-	D_ASSERT(!partition_index.IsValid());
-	D_ASSERT(Count() == 0);
-	partition_index = index;
-	allocator->SetPartitionIndex(index);
-}
-
-// LCOV_EXCL_START
-void VerifyAppendColumns(const TupleDataLayout &layout, const vector<column_t> &column_ids) {
-#ifdef DEBUG
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		if (std::find(column_ids.begin(), column_ids.end(), col_idx) != column_ids.end()) {
-			continue;
-		}
-		// This column will not be appended in the first go - verify that it is fixed-size - we cannot resize heap after
-		const auto physical_type = layout.GetTypes()[col_idx].InternalType();
-		D_ASSERT(physical_type != PhysicalType::VARCHAR && physical_type != PhysicalType::LIST &&
-		         physical_type != PhysicalType::ARRAY);
-		if (physical_type == PhysicalType::STRUCT) {
-			const auto &struct_layout = layout.GetStructLayout(col_idx);
-			vector<column_t> struct_column_ids;
-			struct_column_ids.reserve(struct_layout.ColumnCount());
-			for (idx_t struct_col_idx = 0; struct_col_idx < struct_layout.ColumnCount(); struct_col_idx++) {
-				struct_column_ids.emplace_back(struct_col_idx);
-			}
-			VerifyAppendColumns(struct_layout, struct_column_ids);
-		}
-	}
-#endif
-}
-// LCOV_EXCL_STOP
-
-void TupleDataCollection::InitializeAppend(TupleDataAppendState &append_state, TupleDataPinProperties properties) {
-	vector<column_t> column_ids;
-	GetAllColumnIDs(column_ids);
-	InitializeAppend(append_state, std::move(column_ids), properties);
-}
-
-void TupleDataCollection::InitializeAppend(TupleDataAppendState &append_state, vector<column_t> column_ids,
-                                           TupleDataPinProperties properties) {
-	VerifyAppendColumns(layout, column_ids);
-	InitializeAppend(append_state.pin_state, properties);
-	InitializeChunkState(append_state.chunk_state, std::move(column_ids));
-}
-
-void TupleDataCollection::InitializeAppend(TupleDataPinState &pin_state, TupleDataPinProperties properties) {
-	pin_state.properties = properties;
-	if (segments.empty()) {
-		segments.emplace_back(allocator);
-	}
-}
-
-static void InitializeVectorFormat(vector<TupleDataVectorFormat> &vector_data, const vector<LogicalType> &types) {
-	vector_data.resize(types.size());
-	for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) {
-		const auto &type = types[col_idx];
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT: {
-			const auto &child_list = StructType::GetChildTypes(type);
-			vector<LogicalType> child_types;
-			child_types.reserve(child_list.size());
-			for (const auto &child_entry : child_list) {
-				child_types.emplace_back(child_entry.second);
-			}
-			InitializeVectorFormat(vector_data[col_idx].children, child_types);
-			break;
-		}
-		case PhysicalType::LIST:
-			InitializeVectorFormat(vector_data[col_idx].children, {ListType::GetChildType(type)});
-			break;
-		case PhysicalType::ARRAY:
-			InitializeVectorFormat(vector_data[col_idx].children, {ArrayType::GetChildType(type)});
-			break;
-		default:
-			break;
-		}
-	}
-}
-
-void TupleDataCollection::InitializeChunkState(TupleDataChunkState &chunk_state, vector<column_t> column_ids) {
-	TupleDataCollection::InitializeChunkState(chunk_state, layout.GetTypes(), std::move(column_ids));
-}
-
-void TupleDataCollection::InitializeChunkState(TupleDataChunkState &chunk_state, const vector<LogicalType> &types,
-                                               vector<column_t> column_ids) {
-	if (column_ids.empty()) {
-		GetAllColumnIDsInternal(column_ids, types.size());
-	}
-	InitializeVectorFormat(chunk_state.vector_data, types);
-
-	chunk_state.cached_cast_vectors.clear();
-	chunk_state.cached_cast_vector_cache.clear();
-	for (auto &col : column_ids) {
-		auto &type = types[col];
-		if (TypeVisitor::Contains(type, LogicalTypeId::ARRAY)) {
-			auto cast_type = ArrayType::ConvertToList(type);
-			chunk_state.cached_cast_vector_cache.push_back(
-			    make_uniq<VectorCache>(Allocator::DefaultAllocator(), cast_type));
-			chunk_state.cached_cast_vectors.push_back(make_uniq<Vector>(*chunk_state.cached_cast_vector_cache.back()));
-		} else {
-			chunk_state.cached_cast_vectors.emplace_back();
-			chunk_state.cached_cast_vector_cache.emplace_back();
-		}
-	}
-
-	chunk_state.column_ids = std::move(column_ids);
-}
-
-void TupleDataCollection::Append(DataChunk &new_chunk, const SelectionVector &append_sel, idx_t append_count) {
-	TupleDataAppendState append_state;
-	InitializeAppend(append_state);
-	Append(append_state, new_chunk, append_sel, append_count);
-}
-
-void TupleDataCollection::Append(DataChunk &new_chunk, vector<column_t> column_ids, const SelectionVector &append_sel,
-                                 const idx_t append_count) {
-	TupleDataAppendState append_state;
-	InitializeAppend(append_state, std::move(column_ids));
-	Append(append_state, new_chunk, append_sel, append_count);
-}
-
-void TupleDataCollection::Append(TupleDataAppendState &append_state, DataChunk &new_chunk,
-                                 const SelectionVector &append_sel, const idx_t append_count) {
-	Append(append_state.pin_state, append_state.chunk_state, new_chunk, append_sel, append_count);
-}
-
-void TupleDataCollection::Append(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, DataChunk &new_chunk,
-                                 const SelectionVector &append_sel, const idx_t append_count) {
-	TupleDataCollection::ToUnifiedFormat(chunk_state, new_chunk);
-	AppendUnified(pin_state, chunk_state, new_chunk, append_sel, append_count);
-}
-
-void TupleDataCollection::AppendUnified(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-                                        DataChunk &new_chunk, const SelectionVector &append_sel,
-                                        const idx_t append_count) {
-	const idx_t actual_append_count = append_count == DConstants::INVALID_INDEX ? new_chunk.size() : append_count;
-	if (actual_append_count == 0) {
-		return;
-	}
-
-	if (!layout.AllConstant()) {
-		TupleDataCollection::ComputeHeapSizes(chunk_state, new_chunk, append_sel, actual_append_count);
-	}
-
-	Build(pin_state, chunk_state, 0, actual_append_count);
-	Scatter(chunk_state, new_chunk, append_sel, actual_append_count);
-}
-
-static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector &vector, const idx_t count) {
-	vector.ToUnifiedFormat(count, format.unified);
-	format.original_sel = format.unified.sel;
-	format.original_owned_sel.Initialize(format.unified.owned_sel);
-	switch (vector.GetType().InternalType()) {
-	case PhysicalType::STRUCT: {
-		auto &entries = StructVector::GetEntries(vector);
-		D_ASSERT(format.children.size() == entries.size());
-		for (idx_t struct_col_idx = 0; struct_col_idx < entries.size(); struct_col_idx++) {
-			ToUnifiedFormatInternal(format.children[struct_col_idx], *entries[struct_col_idx], count);
-		}
-		break;
-	}
-	case PhysicalType::LIST:
-		D_ASSERT(format.children.size() == 1);
-		ToUnifiedFormatInternal(format.children[0], ListVector::GetEntry(vector), ListVector::GetListSize(vector));
-		break;
-	case PhysicalType::ARRAY: {
-		D_ASSERT(format.children.size() == 1);
-
-		// For arrays, we cheat a bit and pretend that they are lists by creating and assigning list_entry_t's to the
-		// vector This allows us to reuse all the list serialization functions for array types too.
-		auto array_size = ArrayType::GetSize(vector.GetType());
-
-		// How many list_entry_t's do we need to cover the whole child array?
-		// Make sure we round up so its all covered
-		auto child_array_total_size = ArrayVector::GetTotalSize(vector);
-		auto list_entry_t_count =
-		    MaxValue((child_array_total_size + array_size) / array_size, format.unified.validity.Capacity());
-
-		// Create list entries!
-		format.array_list_entries = make_unsafe_uniq_array<list_entry_t>(list_entry_t_count);
-		for (idx_t i = 0; i < list_entry_t_count; i++) {
-			format.array_list_entries[i].length = array_size;
-			format.array_list_entries[i].offset = i * array_size;
-		}
-		format.unified.data = reinterpret_cast<data_ptr_t>(format.array_list_entries.get());
-
-		ToUnifiedFormatInternal(format.children[0], ArrayVector::GetEntry(vector), child_array_total_size);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-void TupleDataCollection::ToUnifiedFormat(TupleDataChunkState &chunk_state, DataChunk &new_chunk) {
-	D_ASSERT(chunk_state.vector_data.size() >= chunk_state.column_ids.size()); // Needs InitializeAppend
-	for (const auto &col_idx : chunk_state.column_ids) {
-		ToUnifiedFormatInternal(chunk_state.vector_data[col_idx], new_chunk.data[col_idx], new_chunk.size());
-	}
-}
-
-void TupleDataCollection::GetVectorData(const TupleDataChunkState &chunk_state, UnifiedVectorFormat result[]) {
-	const auto &vector_data = chunk_state.vector_data;
-	for (idx_t i = 0; i < vector_data.size(); i++) {
-		const auto &source = vector_data[i].unified;
-		auto &target = result[i];
-		target.sel = source.sel;
-		target.data = source.data;
-		target.validity = source.validity;
-	}
-}
-
-void TupleDataCollection::Build(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-                                const idx_t append_offset, const idx_t append_count) {
-	auto &segment = segments.back();
-	const auto size_before = segment.SizeInBytes();
-	segment.allocator->Build(segment, pin_state, chunk_state, append_offset, append_count);
-	data_size += segment.SizeInBytes() - size_before;
-	count += append_count;
-	Verify();
-}
-
-// LCOV_EXCL_START
-void VerifyHeapSizes(const data_ptr_t source_locations[], const idx_t heap_sizes[], const SelectionVector &append_sel,
-                     const idx_t append_count, const idx_t heap_size_offset) {
-#ifdef DEBUG
-	for (idx_t i = 0; i < append_count; i++) {
-		auto idx = append_sel.get_index(i);
-		const auto stored_heap_size = Load<uint32_t>(source_locations[idx] + heap_size_offset);
-		D_ASSERT(stored_heap_size == heap_sizes[idx]);
-	}
-#endif
-}
-// LCOV_EXCL_STOP
-
-void TupleDataCollection::CopyRows(TupleDataChunkState &chunk_state, TupleDataChunkState &input,
-                                   const SelectionVector &append_sel, const idx_t append_count) const {
-	const auto source_locations = FlatVector::GetData<data_ptr_t>(input.row_locations);
-	const auto target_locations = FlatVector::GetData<data_ptr_t>(chunk_state.row_locations);
-
-	// Copy rows
-	const auto row_width = layout.GetRowWidth();
-	for (idx_t i = 0; i < append_count; i++) {
-		auto idx = append_sel.get_index(i);
-		FastMemcpy(target_locations[i], source_locations[idx], row_width);
-	}
-
-	// Copy heap if we need to
-	if (!layout.AllConstant()) {
-		const auto source_heap_locations = FlatVector::GetData<data_ptr_t>(input.heap_locations);
-		const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(chunk_state.heap_locations);
-		const auto heap_sizes = FlatVector::GetData<idx_t>(input.heap_sizes);
-		VerifyHeapSizes(source_locations, heap_sizes, append_sel, append_count, layout.GetHeapSizeOffset());
-
-		// Check if we need to copy anything at all
-		idx_t total_heap_size = 0;
-		for (idx_t i = 0; i < append_count; i++) {
-			auto idx = append_sel.get_index(i);
-			total_heap_size += heap_sizes[idx];
-		}
-		if (total_heap_size == 0) {
-			return;
-		}
-
-		// Copy heap
-		for (idx_t i = 0; i < append_count; i++) {
-			auto idx = append_sel.get_index(i);
-			FastMemcpy(target_heap_locations[i], source_heap_locations[idx], heap_sizes[idx]);
-		}
-
-		// Recompute pointers after copying the data
-		TupleDataAllocator::RecomputeHeapPointers(input.heap_locations, append_sel, target_locations,
-		                                          chunk_state.heap_locations, 0, append_count, layout, 0);
-	}
-}
-
-void TupleDataCollection::Combine(TupleDataCollection &other) {
-	if (other.count == 0) {
-		return;
-	}
-	if (this->layout.GetTypes() != other.GetLayout().GetTypes()) {
-		throw InternalException("Attempting to combine TupleDataCollection with mismatching types");
-	}
-	this->segments.reserve(this->segments.size() + other.segments.size());
-	for (auto &other_seg : other.segments) {
-		AddSegment(std::move(other_seg));
-	}
-	other.Reset();
-}
-
-void TupleDataCollection::AddSegment(TupleDataSegment &&segment) {
-	count += segment.count;
-	data_size += segment.data_size;
-	segments.emplace_back(std::move(segment));
-	Verify();
-}
-
-void TupleDataCollection::Combine(unique_ptr<TupleDataCollection> other) {
-	Combine(*other);
-}
-
-void TupleDataCollection::Reset() {
-	count = 0;
-	data_size = 0;
-	segments.clear();
-
-	// Refreshes the TupleDataAllocator to prevent holding on to allocated data unnecessarily
-	allocator = make_shared_ptr<TupleDataAllocator>(*allocator);
-}
-
-void TupleDataCollection::InitializeChunk(DataChunk &chunk) const {
-	chunk.Initialize(allocator->GetAllocator(), layout.GetTypes());
-}
-
-void TupleDataCollection::InitializeChunk(DataChunk &chunk, const vector<column_t> &columns) const {
-	vector<LogicalType> chunk_types(columns.size());
-	// keep the order of the columns
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto column_idx = columns[i];
-		D_ASSERT(column_idx < layout.ColumnCount());
-		chunk_types[i] = layout.GetTypes()[column_idx];
-	}
-	chunk.Initialize(allocator->GetAllocator(), chunk_types);
-}
-
-void TupleDataCollection::InitializeScanChunk(TupleDataScanState &state, DataChunk &chunk) const {
-	auto &column_ids = state.chunk_state.column_ids;
-	D_ASSERT(!column_ids.empty());
-	vector<LogicalType> chunk_types;
-	chunk_types.reserve(column_ids.size());
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column_idx = column_ids[i];
-		D_ASSERT(column_idx < layout.ColumnCount());
-		chunk_types.push_back(layout.GetTypes()[column_idx]);
-	}
-	chunk.Initialize(allocator->GetAllocator(), chunk_types);
-}
-
-void TupleDataCollection::InitializeScan(TupleDataScanState &state, TupleDataPinProperties properties) const {
-	vector<column_t> column_ids;
-	column_ids.reserve(layout.ColumnCount());
-	for (idx_t i = 0; i < layout.ColumnCount(); i++) {
-		column_ids.push_back(i);
-	}
-	InitializeScan(state, std::move(column_ids), properties);
-}
-
-void TupleDataCollection::InitializeScan(TupleDataScanState &state, vector<column_t> column_ids,
-                                         TupleDataPinProperties properties) const {
-	state.pin_state.row_handles.clear();
-	state.pin_state.heap_handles.clear();
-	state.pin_state.properties = properties;
-	state.segment_index = 0;
-	state.chunk_index = 0;
-
-	auto &chunk_state = state.chunk_state;
-
-	for (auto &col : column_ids) {
-		auto &type = layout.GetTypes()[col];
-
-		if (TypeVisitor::Contains(type, LogicalTypeId::ARRAY)) {
-			auto cast_type = ArrayType::ConvertToList(type);
-			chunk_state.cached_cast_vector_cache.push_back(
-			    make_uniq<VectorCache>(Allocator::DefaultAllocator(), cast_type));
-			chunk_state.cached_cast_vectors.push_back(make_uniq<Vector>(*chunk_state.cached_cast_vector_cache.back()));
-		} else {
-			chunk_state.cached_cast_vectors.emplace_back();
-			chunk_state.cached_cast_vector_cache.emplace_back();
-		}
-	}
-
-	state.chunk_state.column_ids = std::move(column_ids);
-}
-
-void TupleDataCollection::InitializeScan(TupleDataParallelScanState &gstate, TupleDataPinProperties properties) const {
-	InitializeScan(gstate.scan_state, properties);
-}
-
-void TupleDataCollection::InitializeScan(TupleDataParallelScanState &state, vector<column_t> column_ids,
-                                         TupleDataPinProperties properties) const {
-	InitializeScan(state.scan_state, std::move(column_ids), properties);
-}
-
-bool TupleDataCollection::Scan(TupleDataScanState &state, DataChunk &result) {
-	const auto segment_index_before = state.segment_index;
-	idx_t segment_index;
-	idx_t chunk_index;
-	if (!NextScanIndex(state, segment_index, chunk_index)) {
-		if (!segments.empty()) {
-			FinalizePinState(state.pin_state, segments[segment_index_before]);
-		}
-		result.SetCardinality(0);
-		return false;
-	}
-	if (segment_index_before != DConstants::INVALID_INDEX && segment_index != segment_index_before) {
-		FinalizePinState(state.pin_state, segments[segment_index_before]);
-	}
-	ScanAtIndex(state.pin_state, state.chunk_state, state.chunk_state.column_ids, segment_index, chunk_index, result);
-	return true;
-}
-
-bool TupleDataCollection::Scan(TupleDataParallelScanState &gstate, TupleDataLocalScanState &lstate, DataChunk &result) {
-	lstate.pin_state.properties = gstate.scan_state.pin_state.properties;
-
-	const auto segment_index_before = lstate.segment_index;
-	{
-		lock_guard<mutex> guard(gstate.lock);
-		if (!NextScanIndex(gstate.scan_state, lstate.segment_index, lstate.chunk_index)) {
-			if (!segments.empty()) {
-				FinalizePinState(lstate.pin_state, segments[segment_index_before]);
-			}
-			result.SetCardinality(0);
-			return false;
-		}
-	}
-	if (segment_index_before != DConstants::INVALID_INDEX && segment_index_before != lstate.segment_index) {
-		FinalizePinState(lstate.pin_state, segments[lstate.segment_index]);
-	}
-	ScanAtIndex(lstate.pin_state, lstate.chunk_state, gstate.scan_state.chunk_state.column_ids, lstate.segment_index,
-	            lstate.chunk_index, result);
-	return true;
-}
-
-bool TupleDataCollection::ScanComplete(const TupleDataScanState &state) const {
-	if (Count() == 0) {
-		return true;
-	}
-	return state.segment_index == segments.size() - 1 && state.chunk_index == segments.back().ChunkCount();
-}
-
-void TupleDataCollection::FinalizePinState(TupleDataPinState &pin_state, TupleDataSegment &segment) {
-	segment.allocator->ReleaseOrStoreHandles(pin_state, segment);
-}
-
-void TupleDataCollection::FinalizePinState(TupleDataPinState &pin_state) {
-	D_ASSERT(!segments.empty());
-	FinalizePinState(pin_state, segments.back());
-}
-
-bool TupleDataCollection::NextScanIndex(TupleDataScanState &state, idx_t &segment_index, idx_t &chunk_index) {
-	// Check if we still have segments to scan
-	if (state.segment_index >= segments.size()) {
-		// No more data left in the scan
-		return false;
-	}
-	// Check within the current segment if we still have chunks to scan
-	while (state.chunk_index >= segments[state.segment_index].ChunkCount()) {
-		// Exhausted all chunks for this segment: Move to the next one
-		state.segment_index++;
-		state.chunk_index = 0;
-		if (state.segment_index >= segments.size()) {
-			return false;
-		}
-	}
-	segment_index = state.segment_index;
-	chunk_index = state.chunk_index++;
-	return true;
-}
-void TupleDataCollection::ScanAtIndex(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-                                      const vector<column_t> &column_ids, idx_t segment_index, idx_t chunk_index,
-                                      DataChunk &result) {
-	auto &segment = segments[segment_index];
-	auto &chunk = segment.chunks[chunk_index];
-	segment.allocator->InitializeChunkState(segment, pin_state, chunk_state, chunk_index, false);
-	result.Reset();
-
-	ResetCachedCastVectors(chunk_state, column_ids);
-	Gather(chunk_state.row_locations, *FlatVector::IncrementalSelectionVector(), chunk.count, column_ids, result,
-	       *FlatVector::IncrementalSelectionVector(), chunk_state.cached_cast_vectors);
-	result.SetCardinality(chunk.count);
-}
-
-void TupleDataCollection::ResetCachedCastVectors(TupleDataChunkState &chunk_state, const vector<column_t> &column_ids) {
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		if (chunk_state.cached_cast_vectors[i]) {
-			chunk_state.cached_cast_vectors[i]->ResetFromCache(*chunk_state.cached_cast_vector_cache[i]);
-		}
-	}
-}
-
-// LCOV_EXCL_START
-string TupleDataCollection::ToString() {
-	DataChunk chunk;
-	InitializeChunk(chunk);
-
-	TupleDataScanState scan_state;
-	InitializeScan(scan_state);
-
-	string result = StringUtil::Format("TupleDataCollection - [%llu Chunks, %llu Rows]\n", ChunkCount(), Count());
-	idx_t chunk_idx = 0;
-	idx_t row_count = 0;
-	while (Scan(scan_state, chunk)) {
-		result +=
-		    StringUtil::Format("Chunk %llu - [Rows %llu - %llu]\n", chunk_idx, row_count, row_count + chunk.size()) +
-		    chunk.ToString();
-		chunk_idx++;
-		row_count += chunk.size();
-	}
-
-	return result;
-}
-
-void TupleDataCollection::Print() {
-	Printer::Print(ToString());
-}
-
-void TupleDataCollection::Verify() const {
-#ifdef DEBUG
-	idx_t total_count = 0;
-	idx_t total_size = 0;
-	for (const auto &segment : segments) {
-		segment.Verify();
-		total_count += segment.count;
-		total_size += segment.data_size;
-	}
-	D_ASSERT(total_count == this->count);
-	D_ASSERT(total_size == this->data_size);
-#endif
-}
-
-void TupleDataCollection::VerifyEverythingPinned() const {
-#ifdef DEBUG
-	for (const auto &segment : segments) {
-		segment.VerifyEverythingPinned();
-	}
-#endif
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/tuple_data_iterator.cpp b/src/duckdb/src/common/types/row/tuple_data_iterator.cpp
deleted file mode 100644
index a209322aa..000000000
--- a/src/duckdb/src/common/types/row/tuple_data_iterator.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "duckdb/common/types/row/tuple_data_iterator.hpp"
-
-#include "duckdb/common/types/row/tuple_data_allocator.hpp"
-
-namespace duckdb {
-
-TupleDataChunkIterator::TupleDataChunkIterator(TupleDataCollection &collection_p, TupleDataPinProperties properties_p,
-                                               bool init_heap)
-    : TupleDataChunkIterator(collection_p, properties_p, 0, collection_p.ChunkCount(), init_heap) {
-}
-
-TupleDataChunkIterator::TupleDataChunkIterator(TupleDataCollection &collection_p, TupleDataPinProperties properties,
-                                               idx_t chunk_idx_from, idx_t chunk_idx_to, bool init_heap_p)
-    : collection(collection_p), init_heap(init_heap_p) {
-	state.pin_state.properties = properties;
-	D_ASSERT(chunk_idx_from < chunk_idx_to);
-	D_ASSERT(chunk_idx_to <= collection.ChunkCount());
-	idx_t overall_chunk_index = 0;
-	for (idx_t segment_idx = 0; segment_idx < collection.segments.size(); segment_idx++) {
-		const auto &segment = collection.segments[segment_idx];
-		if (chunk_idx_from >= overall_chunk_index && chunk_idx_from <= overall_chunk_index + segment.ChunkCount()) {
-			// We start in this segment
-			start_segment_idx = segment_idx;
-			start_chunk_idx = chunk_idx_from - overall_chunk_index;
-		}
-		if (chunk_idx_to >= overall_chunk_index && chunk_idx_to <= overall_chunk_index + segment.ChunkCount()) {
-			// We end in this segment
-			end_segment_idx = segment_idx;
-			end_chunk_idx = chunk_idx_to - overall_chunk_index;
-		}
-		overall_chunk_index += segment.ChunkCount();
-	}
-
-	Reset();
-}
-
-void TupleDataChunkIterator::InitializeCurrentChunk() {
-	auto &segment = collection.segments[current_segment_idx];
-	segment.allocator->InitializeChunkState(segment, state.pin_state, state.chunk_state, current_chunk_idx, init_heap);
-}
-
-bool TupleDataChunkIterator::Done() const {
-	return current_segment_idx == end_segment_idx && current_chunk_idx == end_chunk_idx;
-}
-
-bool TupleDataChunkIterator::Next() {
-	D_ASSERT(!Done()); // Check if called after already done
-
-	// Set the next indices and checks if we're at the end of the collection
-	// NextScanIndex can go past this iterators 'end', so we have to check the indices again
-	const auto segment_idx_before = current_segment_idx;
-	if (!collection.NextScanIndex(state, current_segment_idx, current_chunk_idx) || Done()) {
-		// Drop pins / stores them if TupleDataPinProperties::KEEP_EVERYTHING_PINNED
-		collection.FinalizePinState(state.pin_state, collection.segments[segment_idx_before]);
-		current_segment_idx = end_segment_idx;
-		current_chunk_idx = end_chunk_idx;
-		return false;
-	}
-
-	// Finalize pin state when moving from one segment to the next
-	if (current_segment_idx != segment_idx_before) {
-		collection.FinalizePinState(state.pin_state, collection.segments[segment_idx_before]);
-	}
-
-	InitializeCurrentChunk();
-	return true;
-}
-
-void TupleDataChunkIterator::Reset() {
-	state.segment_index = start_segment_idx;
-	state.chunk_index = start_chunk_idx;
-	collection.NextScanIndex(state, current_segment_idx, current_chunk_idx);
-	InitializeCurrentChunk();
-}
-
-idx_t TupleDataChunkIterator::GetCurrentChunkCount() const {
-	return collection.segments[current_segment_idx].chunks[current_chunk_idx].count;
-}
-
-TupleDataChunkState &TupleDataChunkIterator::GetChunkState() {
-	return state.chunk_state;
-}
-
-data_ptr_t *TupleDataChunkIterator::GetRowLocations() {
-	return FlatVector::GetData<data_ptr_t>(state.chunk_state.row_locations);
-}
-
-data_ptr_t *TupleDataChunkIterator::GetHeapLocations() {
-	return FlatVector::GetData<data_ptr_t>(state.chunk_state.heap_locations);
-}
-
-idx_t *TupleDataChunkIterator::GetHeapSizes() {
-	return FlatVector::GetData<idx_t>(state.chunk_state.heap_sizes);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/tuple_data_layout.cpp b/src/duckdb/src/common/types/row/tuple_data_layout.cpp
deleted file mode 100644
index 5dec78e06..000000000
--- a/src/duckdb/src/common/types/row/tuple_data_layout.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-TupleDataLayout::TupleDataLayout()
-    : flag_width(0), data_width(0), aggr_width(0), row_width(0), all_constant(true), heap_size_offset(0) {
-}
-
-TupleDataLayout TupleDataLayout::Copy() const {
-	TupleDataLayout result;
-	result.types = this->types;
-	result.aggregates = this->aggregates;
-	if (this->struct_layouts) {
-		result.struct_layouts = make_uniq<unordered_map<idx_t, TupleDataLayout>>();
-		for (const auto &entry : *this->struct_layouts) {
-			result.struct_layouts->emplace(entry.first, entry.second.Copy());
-		}
-	}
-	result.flag_width = this->flag_width;
-	result.data_width = this->data_width;
-	result.aggr_width = this->aggr_width;
-	result.row_width = this->row_width;
-	result.offsets = this->offsets;
-	result.all_constant = this->all_constant;
-	result.heap_size_offset = this->heap_size_offset;
-	result.aggr_destructor_idxs = this->aggr_destructor_idxs;
-	return result;
-}
-
-void TupleDataLayout::Initialize(vector<LogicalType> types_p, Aggregates aggregates_p, bool align, bool heap_offset_p) {
-	offsets.clear();
-	types = std::move(types_p);
-
-	// Null mask at the front - 1 bit per value.
-	flag_width = ValidityBytes::ValidityMaskSize(types.size());
-	row_width = flag_width;
-
-	// Whether all columns are constant size.
-	for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) {
-		const auto &type = types[col_idx];
-		if (type.InternalType() == PhysicalType::STRUCT) {
-			// structs are recursively stored as a TupleDataLayout again
-			const auto &child_types = StructType::GetChildTypes(type);
-			vector<LogicalType> child_type_vector;
-			child_type_vector.reserve(child_types.size());
-			for (auto &ct : child_types) {
-				child_type_vector.emplace_back(ct.second);
-			}
-			if (!struct_layouts) {
-				struct_layouts = make_uniq<unordered_map<idx_t, TupleDataLayout>>();
-			}
-			auto struct_entry = struct_layouts->emplace(col_idx, TupleDataLayout());
-			struct_entry.first->second.Initialize(std::move(child_type_vector), false, false);
-			all_constant = all_constant && struct_entry.first->second.AllConstant();
-		} else {
-			all_constant = all_constant && TypeIsConstantSize(type.InternalType());
-		}
-	}
-
-	// This enables pointer swizzling for out-of-core computation.
-	if (heap_offset_p && !all_constant) {
-		heap_size_offset = row_width;
-		row_width += sizeof(uint32_t);
-	}
-
-	// Data columns. No alignment required.
-	for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) {
-		const auto &type = types[col_idx];
-		offsets.push_back(row_width);
-		const auto internal_type = type.InternalType();
-		if (TypeIsConstantSize(internal_type) || internal_type == PhysicalType::VARCHAR) {
-			row_width += GetTypeIdSize(type.InternalType());
-		} else if (internal_type == PhysicalType::STRUCT) {
-			// Just get the size of the TupleDataLayout of the struct
-			row_width += GetStructLayout(col_idx).GetRowWidth();
-		} else {
-			// Variable size types use pointers to the actual data (can be swizzled).
-			// Again, we would use sizeof(data_ptr_t), but this is not guaranteed to be equal to sizeof(idx_t).
-			row_width += sizeof(idx_t);
-		}
-	}
-
-	// Alignment padding for aggregates
-#ifndef DUCKDB_ALLOW_UNDEFINED
-	if (align) {
-		row_width = AlignValue(row_width);
-	}
-#endif
-	data_width = row_width - flag_width;
-
-	// Aggregate fields.
-	aggregates = std::move(aggregates_p);
-	for (auto &aggregate : aggregates) {
-		offsets.push_back(row_width);
-		row_width += aggregate.payload_size;
-#ifndef DUCKDB_ALLOW_UNDEFINED
-		D_ASSERT(aggregate.payload_size == AlignValue(aggregate.payload_size));
-#endif
-	}
-	aggr_width = row_width - data_width - flag_width;
-
-	// Alignment padding for the next row
-#ifndef DUCKDB_ALLOW_UNDEFINED
-	if (align) {
-		row_width = AlignValue(row_width);
-	}
-#endif
-
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		const auto &aggr = aggregates[aggr_idx];
-		if (aggr.function.destructor) {
-			aggr_destructor_idxs.push_back(aggr_idx);
-		}
-	}
-}
-
-void TupleDataLayout::Initialize(vector<LogicalType> types_p, bool align, bool heap_offset_p) {
-	Initialize(std::move(types_p), Aggregates(), align, heap_offset_p);
-}
-
-void TupleDataLayout::Initialize(Aggregates aggregates_p, bool align, bool heap_offset_p) {
-	Initialize(vector<LogicalType>(), std::move(aggregates_p), align, heap_offset_p);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp b/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp
deleted file mode 100644
index a735d90b0..000000000
--- a/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp
+++ /dev/null
@@ -1,1584 +0,0 @@
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = TupleDataLayout::ValidityBytes;
-
-template <class T>
-static constexpr idx_t TupleDataWithinListFixedSize() {
-	return sizeof(T);
-}
-
-template <>
-constexpr idx_t TupleDataWithinListFixedSize<string_t>() {
-	return sizeof(uint32_t);
-}
-
-template <class T>
-static void TupleDataValueStore(const T &source, const data_ptr_t &row_location, const idx_t offset_in_row,
-                                data_ptr_t &) {
-	Store<T>(source, row_location + offset_in_row);
-}
-
-template <>
-inline void TupleDataValueStore(const string_t &source, const data_ptr_t &row_location, const idx_t offset_in_row,
-                                data_ptr_t &heap_location) {
-#ifdef DEBUG
-	source.VerifyCharacters();
-#endif
-	if (source.IsInlined()) {
-		Store<string_t>(source, row_location + offset_in_row);
-	} else {
-		FastMemcpy(heap_location, source.GetData(), source.GetSize());
-		Store<string_t>(string_t(const_char_ptr_cast(heap_location), UnsafeNumericCast<uint32_t>(source.GetSize())),
-		                row_location + offset_in_row);
-		heap_location += source.GetSize();
-	}
-}
-
-template <class T>
-static void TupleDataWithinListValueStore(const T &source, const data_ptr_t &location, data_ptr_t &) {
-	Store<T>(source, location);
-}
-
-template <>
-inline void TupleDataWithinListValueStore(const string_t &source, const data_ptr_t &location,
-                                          data_ptr_t &heap_location) {
-#ifdef DEBUG
-	source.VerifyCharacters();
-#endif
-	Store<uint32_t>(UnsafeNumericCast<uint32_t>(source.GetSize()), location);
-	FastMemcpy(heap_location, source.GetData(), source.GetSize());
-	heap_location += source.GetSize();
-}
-
-template <class T>
-void TupleDataValueVerify(const LogicalType &, const T &) {
-#ifdef DEBUG
-	// NOP
-#endif
-}
-
-template <>
-inline void TupleDataValueVerify(const LogicalType &type, const string_t &value) {
-#ifdef DEBUG
-	if (type.id() == LogicalTypeId::VARCHAR) {
-		value.Verify();
-	}
-#endif
-}
-
-template <class T>
-static T TupleDataWithinListValueLoad(const data_ptr_t &location, data_ptr_t &) {
-	return Load<T>(location);
-}
-
-template <>
-inline string_t TupleDataWithinListValueLoad(const data_ptr_t &location, data_ptr_t &heap_location) {
-	const auto size = Load<uint32_t>(location);
-	string_t result(const_char_ptr_cast(heap_location), size);
-	heap_location += size;
-	return result;
-}
-
-static void ResetCombinedListData(vector<TupleDataVectorFormat> &vector_data) {
-#ifdef DEBUG
-	for (auto &vd : vector_data) {
-		vd.combined_list_data = nullptr;
-		ResetCombinedListData(vd.children);
-	}
-#endif
-}
-
-void TupleDataCollection::ComputeHeapSizes(TupleDataChunkState &chunk_state, const DataChunk &new_chunk,
-                                           const SelectionVector &append_sel, const idx_t append_count) {
-	ResetCombinedListData(chunk_state.vector_data);
-
-	auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
-	std::fill_n(heap_sizes, append_count, 0);
-
-	for (idx_t col_idx = 0; col_idx < new_chunk.ColumnCount(); col_idx++) {
-		auto &source_v = new_chunk.data[col_idx];
-		auto &source_format = chunk_state.vector_data[col_idx];
-		ComputeHeapSizes(chunk_state.heap_sizes, source_v, source_format, append_sel, append_count);
-	}
-}
-
-static idx_t StringHeapSize(const string_t &val) {
-	return val.IsInlined() ? 0 : val.GetSize();
-}
-
-void TupleDataCollection::ComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-                                           TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
-                                           const idx_t append_count) {
-	const auto type = source_v.GetType().InternalType();
-	if (type != PhysicalType::VARCHAR && type != PhysicalType::STRUCT && type != PhysicalType::LIST &&
-	    type != PhysicalType::ARRAY) {
-		return;
-	}
-
-	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
-
-	// Source
-	const auto &source_vector_data = source_format.unified;
-	const auto &source_sel = *source_vector_data.sel;
-	const auto &source_validity = source_vector_data.validity;
-
-	switch (type) {
-	case PhysicalType::VARCHAR: {
-		// Only non-inlined strings are stored in the heap
-		const auto source_data = UnifiedVectorFormat::GetData<string_t>(source_vector_data);
-		for (idx_t i = 0; i < append_count; i++) {
-			const auto source_idx = source_sel.get_index(append_sel.get_index(i));
-			if (source_validity.RowIsValid(source_idx)) {
-				heap_sizes[i] += StringHeapSize(source_data[source_idx]);
-			} else {
-				heap_sizes[i] += StringHeapSize(NullValue<string_t>());
-			}
-		}
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		// Recurse through the struct children
-		auto &struct_sources = StructVector::GetEntries(source_v);
-		for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
-			const auto &struct_source = struct_sources[struct_col_idx];
-			auto &struct_format = source_format.children[struct_col_idx];
-			ComputeHeapSizes(heap_sizes_v, *struct_source, struct_format, append_sel, append_count);
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		// Lists are stored entirely in the heap
-		for (idx_t i = 0; i < append_count; i++) {
-			auto source_idx = source_sel.get_index(append_sel.get_index(i));
-			if (source_validity.RowIsValid(source_idx)) {
-				heap_sizes[i] += sizeof(uint64_t); // Size of the list
-			}
-		}
-
-		// Recurse
-		D_ASSERT(source_format.children.size() == 1);
-		auto &child_source_v = ListVector::GetEntry(source_v);
-		auto &child_format = source_format.children[0];
-		WithinCollectionComputeHeapSizes(heap_sizes_v, child_source_v, child_format, append_sel, append_count,
-		                                 source_vector_data);
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		// Arrays are stored entirely in the heap
-		for (idx_t i = 0; i < append_count; i++) {
-			auto source_idx = source_sel.get_index(append_sel.get_index(i));
-			if (source_validity.RowIsValid(source_idx)) {
-				heap_sizes[i] += sizeof(uint64_t); // Size of the list
-			}
-		}
-
-		// Recurse
-		D_ASSERT(source_format.children.size() == 1);
-		auto &child_source_v = ArrayVector::GetEntry(source_v);
-		auto &child_format = source_format.children[0];
-		WithinCollectionComputeHeapSizes(heap_sizes_v, child_source_v, child_format, append_sel, append_count,
-		                                 source_vector_data);
-		break;
-	}
-	default:
-		throw NotImplementedException("ComputeHeapSizes for %s", EnumUtil::ToString(source_v.GetType().id()));
-	}
-}
-
-void TupleDataCollection::WithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-                                                           TupleDataVectorFormat &source_format,
-                                                           const SelectionVector &append_sel, const idx_t append_count,
-                                                           const UnifiedVectorFormat &list_data) {
-	auto type = source_v.GetType().InternalType();
-	if (TypeIsConstantSize(type)) {
-		ComputeFixedWithinCollectionHeapSizes(heap_sizes_v, source_v, source_format, append_sel, append_count,
-		                                      list_data);
-		return;
-	}
-	switch (type) {
-	case PhysicalType::VARCHAR:
-		StringWithinCollectionComputeHeapSizes(heap_sizes_v, source_v, source_format, append_sel, append_count,
-		                                       list_data);
-		break;
-	case PhysicalType::STRUCT:
-		StructWithinCollectionComputeHeapSizes(heap_sizes_v, source_v, source_format, append_sel, append_count,
-		                                       list_data);
-		break;
-	case PhysicalType::LIST:
-		CollectionWithinCollectionComputeHeapSizes(heap_sizes_v, source_v, source_format, append_sel, append_count,
-		                                           list_data);
-		break;
-	case PhysicalType::ARRAY:
-		CollectionWithinCollectionComputeHeapSizes(heap_sizes_v, source_v, source_format, append_sel, append_count,
-		                                           list_data);
-		break;
-	default:
-		throw NotImplementedException("WithinListHeapComputeSizes for %s", EnumUtil::ToString(source_v.GetType().id()));
-	}
-}
-
-void TupleDataCollection::ComputeFixedWithinCollectionHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-                                                                TupleDataVectorFormat &,
-                                                                const SelectionVector &append_sel,
-                                                                const idx_t append_count,
-                                                                const UnifiedVectorFormat &list_data) {
-	// Parent list data
-	const auto list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Target
-	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
-
-	D_ASSERT(TypeIsConstantSize(source_v.GetType().InternalType()));
-	const auto type_size = GetTypeIdSize(source_v.GetType().InternalType());
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue; // Original list entry is invalid - no need to serialize the child
-		}
-
-		// Get the current list length
-		const auto &list_length = list_entries[list_idx].length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Size is validity mask and all values
-		auto &heap_size = heap_sizes[i];
-		heap_size += ValidityBytes::SizeInBytes(list_length);
-		heap_size += list_length * type_size;
-	}
-}
-
-void TupleDataCollection::StringWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &,
-                                                                 TupleDataVectorFormat &source_format,
-                                                                 const SelectionVector &append_sel,
-                                                                 const idx_t append_count,
-                                                                 const UnifiedVectorFormat &list_data) {
-	// Parent list data
-	const auto list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Source
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto data = UnifiedVectorFormat::GetData<string_t>(source_data);
-	const auto &source_validity = source_data.validity;
-
-	// Target
-	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
-
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue; // Original list entry is invalid - no need to serialize the child
-		}
-
-		// Get the current list entry
-		const auto &list_entry = list_entries[list_idx];
-		const auto &list_offset = list_entry.offset;
-		const auto &list_length = list_entry.length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Size is validity mask and all string sizes
-		auto &heap_size = heap_sizes[i];
-		heap_size += ValidityBytes::SizeInBytes(list_length);
-		heap_size += list_length * TupleDataWithinListFixedSize<string_t>();
-
-		// Plus all the actual strings
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			const auto child_source_idx = source_sel.get_index(list_offset + child_i);
-			if (source_validity.RowIsValid(child_source_idx)) {
-				heap_size += data[child_source_idx].GetSize();
-			}
-		}
-	}
-}
-
-void TupleDataCollection::StructWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-                                                                 TupleDataVectorFormat &source_format,
-                                                                 const SelectionVector &append_sel,
-                                                                 const idx_t append_count,
-                                                                 const UnifiedVectorFormat &list_data) {
-	// Parent list data
-	const auto list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Target
-	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
-
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue; // Original list entry is invalid - no need to serialize the child
-		}
-
-		// Get the current list length
-		const auto &list_length = list_entries[list_idx].length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Size is just the validity mask
-		heap_sizes[i] += ValidityBytes::SizeInBytes(list_length);
-	}
-
-	// Recurse
-	auto &struct_sources = StructVector::GetEntries(source_v);
-	for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
-		auto &struct_source = *struct_sources[struct_col_idx];
-
-		auto &struct_format = source_format.children[struct_col_idx];
-		WithinCollectionComputeHeapSizes(heap_sizes_v, struct_source, struct_format, append_sel, append_count,
-		                                 list_data);
-	}
-}
-
-static void ApplySliceRecursive(const Vector &source_v, TupleDataVectorFormat &source_format,
-                                const SelectionVector &combined_sel, const idx_t count) {
-	D_ASSERT(source_format.combined_list_data);
-	auto &combined_list_data = *source_format.combined_list_data;
-
-	combined_list_data.selection_data = source_format.original_sel->Slice(combined_sel, count);
-	source_format.unified.owned_sel.Initialize(combined_list_data.selection_data);
-	source_format.unified.sel = &source_format.unified.owned_sel;
-
-	if (source_v.GetType().InternalType() == PhysicalType::STRUCT) {
-		// We have to apply it to the child vectors too
-		auto &struct_sources = StructVector::GetEntries(source_v);
-		for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
-			auto &struct_source = *struct_sources[struct_col_idx];
-			auto &struct_format = source_format.children[struct_col_idx];
-#ifdef DEBUG
-			D_ASSERT(!struct_format.combined_list_data);
-#endif
-			if (!struct_format.combined_list_data) {
-				struct_format.combined_list_data = make_uniq<CombinedListData>();
-			}
-			ApplySliceRecursive(struct_source, struct_format, *source_format.unified.sel, count);
-		}
-	}
-}
-
-void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-                                                                     TupleDataVectorFormat &source_format,
-                                                                     const SelectionVector &append_sel,
-                                                                     const idx_t append_count,
-                                                                     const UnifiedVectorFormat &list_data) {
-	// Parent list data
-	const auto list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Source
-	const auto &child_list_data = source_format.unified;
-	const auto child_list_sel = *child_list_data.sel;
-	const auto child_list_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_list_data);
-	const auto &child_list_validity = child_list_data.validity;
-
-	// Target
-	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
-
-	// Figure out actual child list size (can differ from ListVector::GetListSize if dict/const vector),
-	// and we cannot use ConstantVector::ZeroSelectionVector because it may need to be longer than STANDARD_VECTOR_SIZE
-	idx_t sum_of_sizes = 0;
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue;
-		}
-
-		// Get the current list entry
-		const auto &list_entry = list_entries[list_idx];
-		const auto &list_offset = list_entry.offset;
-		const auto &list_length = list_entry.length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			const auto child_list_idx = child_list_sel.get_index(list_offset + child_i);
-			if (!child_list_validity.RowIsValid(child_list_idx)) {
-				continue;
-			}
-
-			const auto &child_list_entry = child_list_entries[child_list_idx];
-			const auto &child_list_length = child_list_entry.length;
-
-			sum_of_sizes += child_list_length;
-		}
-	}
-
-	const auto child_list_child_count = MaxValue<idx_t>(
-	    sum_of_sizes, source_v.GetType().InternalType() == PhysicalType::LIST ? ListVector::GetListSize(source_v)
-	                                                                          : ArrayVector::GetTotalSize(source_v));
-
-	D_ASSERT(source_format.children.size() == 1);
-	auto &child_format = source_format.children[0];
-#ifdef DEBUG
-	// In debug mode this should be deleted by ResetCombinedListData
-	D_ASSERT(!child_format.combined_list_data);
-#endif
-	if (!child_format.combined_list_data) {
-		child_format.combined_list_data = make_uniq<CombinedListData>();
-	}
-	auto &combined_list_data = *child_format.combined_list_data;
-
-	// Construct combined list entries and a selection/validity vector for the child list child
-	SelectionVector combined_sel(child_list_child_count);
-	for (idx_t i = 0; i < child_list_child_count; i++) {
-		combined_sel.set_index(i, 0);
-	}
-	auto &combined_list_entries = combined_list_data.combined_list_entries;
-	auto &combined_validity = combined_list_data.combined_validity;
-	combined_validity.SetAllValid(STANDARD_VECTOR_SIZE);
-
-	idx_t combined_list_offset = 0;
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto append_idx = append_sel.get_index(i);
-		const auto list_idx = list_sel.get_index(append_idx);
-		if (!list_validity.RowIsValid(list_idx)) {
-			combined_validity.SetInvalidUnsafe(append_idx);
-			continue; // Original list entry is invalid - no need to serialize the child list
-		}
-
-		// Get the current list entry
-		const auto &list_entry = list_entries[list_idx];
-		const auto &list_offset = list_entry.offset;
-		const auto &list_length = list_entry.length;
-
-		// Size is the validity mask and the list sizes
-		auto &heap_size = heap_sizes[i];
-		heap_size += ValidityBytes::SizeInBytes(list_length);
-		heap_size += list_length * sizeof(uint64_t);
-
-		idx_t child_list_size = 0;
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			const auto child_list_idx = child_list_sel.get_index(list_offset + child_i);
-			if (child_list_validity.RowIsValid(child_list_idx)) {
-				const auto &child_list_entry = child_list_entries[child_list_idx];
-				const auto &child_list_offset = child_list_entry.offset;
-				const auto &child_list_length = child_list_entry.length;
-				if (child_list_length == 0) {
-					continue;
-				}
-
-				// Add this child's list entries to the combined selection vector
-				for (idx_t child_value_i = 0; child_value_i < child_list_length; child_value_i++) {
-					auto idx = combined_list_offset + child_list_size + child_value_i;
-					auto loc = child_list_offset + child_value_i;
-					combined_sel.set_index(idx, loc);
-				}
-
-				child_list_size += child_list_length;
-			}
-		}
-
-		// Combine the child list entries into one
-		auto &combined_list_entry = combined_list_entries[append_idx];
-		combined_list_entry.offset = combined_list_offset;
-		combined_list_entry.length = child_list_size;
-		combined_list_offset += child_list_size;
-	}
-
-	// TODO: Template this?
-	auto &child_source = source_v.GetType().InternalType() == PhysicalType::LIST ? ListVector::GetEntry(source_v)
-	                                                                             : ArrayVector::GetEntry(source_v);
-	ApplySliceRecursive(child_source, child_format, combined_sel, child_list_child_count);
-
-	// Create a combined child_list_data to be used as list_data in the recursion
-	auto &combined_child_list_data = combined_list_data.combined_data;
-	combined_child_list_data.sel = FlatVector::IncrementalSelectionVector();
-	combined_child_list_data.data = data_ptr_cast(combined_list_entries);
-	combined_child_list_data.validity.Initialize(combined_validity);
-
-	// Recurse
-	WithinCollectionComputeHeapSizes(heap_sizes_v, child_source, child_format, append_sel, append_count,
-	                                 combined_child_list_data);
-}
-
-template <class T>
-static void TemplatedInitializeValidityMask(const data_ptr_t row_locations[], const idx_t append_count) {
-	for (idx_t i = 0; i < append_count; i++) {
-		Store<T>(T(-1), row_locations[i]);
-	}
-}
-
-template <idx_t validity_bytes>
-static void TemplatedInitializeValidityMask(const data_ptr_t row_locations[], const idx_t append_count) {
-	for (idx_t i = 0; i < append_count; i++) {
-		memset(row_locations[i], ~0, validity_bytes);
-	}
-}
-
-static void InitializeValidityMask(const data_ptr_t row_locations[], const idx_t append_count,
-                                   const idx_t validity_bytes) {
-	switch (validity_bytes) {
-	case 1:
-		TemplatedInitializeValidityMask<uint8_t>(row_locations, append_count);
-		break;
-	case 2:
-		TemplatedInitializeValidityMask<uint16_t>(row_locations, append_count);
-		break;
-	case 3:
-		TemplatedInitializeValidityMask<3>(row_locations, append_count);
-		break;
-	case 4:
-		TemplatedInitializeValidityMask<uint32_t>(row_locations, append_count);
-		break;
-	case 5:
-		TemplatedInitializeValidityMask<5>(row_locations, append_count);
-		break;
-	case 6:
-		TemplatedInitializeValidityMask<6>(row_locations, append_count);
-		break;
-	case 7:
-		TemplatedInitializeValidityMask<7>(row_locations, append_count);
-		break;
-	case 8:
-		TemplatedInitializeValidityMask<uint64_t>(row_locations, append_count);
-		break;
-	default:
-		for (idx_t i = 0; i < append_count; i++) {
-			FastMemset(row_locations[i], ~0, validity_bytes);
-		}
-	}
-}
-
-void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const DataChunk &new_chunk,
-                                  const SelectionVector &append_sel, const idx_t append_count) const {
-#ifdef DEBUG
-	Vector heap_locations_copy(LogicalType::POINTER);
-	if (!layout.AllConstant()) {
-		const auto heap_locations = FlatVector::GetData<data_ptr_t>(chunk_state.heap_locations);
-		const auto copied_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations_copy);
-		for (idx_t i = 0; i < append_count; i++) {
-			copied_heap_locations[i] = heap_locations[i];
-		}
-	}
-#endif
-
-	const auto row_locations = FlatVector::GetData<data_ptr_t>(chunk_state.row_locations);
-
-	// Set the validity mask for each row before inserting data
-	InitializeValidityMask(row_locations, append_count, ValidityBytes::SizeInBytes(layout.ColumnCount()));
-
-	if (!layout.AllConstant()) {
-		// Set the heap size for each row
-		const auto heap_size_offset = layout.GetHeapSizeOffset();
-		const auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
-		for (idx_t i = 0; i < append_count; i++) {
-			Store<uint32_t>(UnsafeNumericCast<uint32_t>(heap_sizes[i]), row_locations[i] + heap_size_offset);
-		}
-	}
-
-	// Write the data
-	for (const auto &col_idx : chunk_state.column_ids) {
-		Scatter(chunk_state, new_chunk.data[col_idx], col_idx, append_sel, append_count);
-	}
-
-#ifdef DEBUG
-	// Verify that the size of the data written to the heap is the same as the size we computed it would be
-	if (!layout.AllConstant()) {
-		const auto original_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations_copy);
-		const auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
-		const auto offset_heap_locations = FlatVector::GetData<data_ptr_t>(chunk_state.heap_locations);
-		for (idx_t i = 0; i < append_count; i++) {
-			if (heap_sizes[i] != 0) {
-				D_ASSERT(offset_heap_locations[i] == original_heap_locations[i] + heap_sizes[i]);
-			}
-		}
-	}
-#endif
-}
-
-void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const Vector &source, const column_t column_id,
-                                  const SelectionVector &append_sel, const idx_t append_count) const {
-	const auto &scatter_function = scatter_functions[column_id];
-	scatter_function.function(source, chunk_state.vector_data[column_id], append_sel, append_count, layout,
-	                          chunk_state.row_locations, chunk_state.heap_locations, column_id,
-	                          chunk_state.vector_data[column_id].unified, scatter_function.child_functions);
-}
-
-template <class T>
-static void TupleDataTemplatedScatter(const Vector &, const TupleDataVectorFormat &source_format,
-                                      const SelectionVector &append_sel, const idx_t append_count,
-                                      const TupleDataLayout &layout, const Vector &row_locations,
-                                      Vector &heap_locations, const idx_t col_idx, const UnifiedVectorFormat &,
-                                      const vector<TupleDataScatterFunction> &) {
-	// Source
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto data = UnifiedVectorFormat::GetData<T>(source_data);
-	const auto &validity = source_data.validity;
-
-	// Target
-	const auto target_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-	const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	if (validity.AllValid()) {
-		for (idx_t i = 0; i < append_count; i++) {
-			const auto source_idx = source_sel.get_index(append_sel.get_index(i));
-			TupleDataValueStore<T>(data[source_idx], target_locations[i], offset_in_row, target_heap_locations[i]);
-		}
-	} else {
-		for (idx_t i = 0; i < append_count; i++) {
-			const auto source_idx = source_sel.get_index(append_sel.get_index(i));
-			if (validity.RowIsValid(source_idx)) {
-				TupleDataValueStore<T>(data[source_idx], target_locations[i], offset_in_row, target_heap_locations[i]);
-			} else {
-				TupleDataValueStore<T>(NullValue<T>(), target_locations[i], offset_in_row, target_heap_locations[i]);
-				ValidityBytes(target_locations[i], layout.ColumnCount()).SetInvalidUnsafe(entry_idx, idx_in_entry);
-			}
-		}
-	}
-}
-
-static void TupleDataStructScatter(const Vector &source, const TupleDataVectorFormat &source_format,
-                                   const SelectionVector &append_sel, const idx_t append_count,
-                                   const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations,
-                                   const idx_t col_idx, const UnifiedVectorFormat &dummy_arg,
-                                   const vector<TupleDataScatterFunction> &child_functions) {
-	// Source
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto &validity = source_data.validity;
-
-	// Target
-	const auto target_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	// Set validity of the STRUCT in this layout
-	if (!validity.AllValid()) {
-		for (idx_t i = 0; i < append_count; i++) {
-			const auto source_idx = source_sel.get_index(append_sel.get_index(i));
-			if (!validity.RowIsValid(source_idx)) {
-				ValidityBytes(target_locations[i], layout.ColumnCount()).SetInvalidUnsafe(entry_idx, idx_in_entry);
-			}
-		}
-	}
-
-	// Create a Vector of pointers to the TupleDataLayout of the STRUCT
-	Vector struct_row_locations(LogicalType::POINTER, append_count);
-	auto struct_target_locations = FlatVector::GetData<data_ptr_t>(struct_row_locations);
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	for (idx_t i = 0; i < append_count; i++) {
-		struct_target_locations[i] = target_locations[i] + offset_in_row;
-	}
-
-	const auto &struct_layout = layout.GetStructLayout(col_idx);
-	auto &struct_sources = StructVector::GetEntries(source);
-	D_ASSERT(struct_layout.ColumnCount() == struct_sources.size());
-
-	// Set the validity of the entries within the STRUCTs
-	InitializeValidityMask(struct_target_locations, append_count,
-	                       ValidityBytes::SizeInBytes(struct_layout.ColumnCount()));
-
-	// Recurse through the struct children
-	for (idx_t struct_col_idx = 0; struct_col_idx < struct_layout.ColumnCount(); struct_col_idx++) {
-		auto &struct_source = *struct_sources[struct_col_idx];
-		const auto &struct_source_format = source_format.children[struct_col_idx];
-		const auto &struct_scatter_function = child_functions[struct_col_idx];
-		struct_scatter_function.function(struct_source, struct_source_format, append_sel, append_count, struct_layout,
-		                                 struct_row_locations, heap_locations, struct_col_idx, dummy_arg,
-		                                 struct_scatter_function.child_functions);
-	}
-}
-
-//------------------------------------------------------------------------------
-// List Scatter
-//------------------------------------------------------------------------------
-static void TupleDataListScatter(const Vector &source, const TupleDataVectorFormat &source_format,
-                                 const SelectionVector &append_sel, const idx_t append_count,
-                                 const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations,
-                                 const idx_t col_idx, const UnifiedVectorFormat &,
-                                 const vector<TupleDataScatterFunction> &child_functions) {
-	// Source
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto data = UnifiedVectorFormat::GetData<list_entry_t>(source_data);
-	const auto &validity = source_data.validity;
-
-	// Target
-	const auto target_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-	const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	// Set validity of the LIST in this layout, and store pointer to where it's stored
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto source_idx = source_sel.get_index(append_sel.get_index(i));
-		if (validity.RowIsValid(source_idx)) {
-			auto &target_heap_location = target_heap_locations[i];
-			Store<data_ptr_t>(target_heap_location, target_locations[i] + offset_in_row);
-
-			// Store list length and skip over it
-			Store<uint64_t>(data[source_idx].length, target_heap_location);
-			target_heap_location += sizeof(uint64_t);
-		} else {
-			ValidityBytes(target_locations[i], layout.ColumnCount()).SetInvalidUnsafe(entry_idx, idx_in_entry);
-		}
-	}
-
-	// Recurse
-	D_ASSERT(child_functions.size() == 1);
-	auto &child_source = ListVector::GetEntry(source);
-	auto &child_format = source_format.children[0];
-	const auto &child_function = child_functions[0];
-	child_function.function(child_source, child_format, append_sel, append_count, layout, row_locations, heap_locations,
-	                        col_idx, source_format.unified, child_function.child_functions);
-}
-
-//------------------------------------------------------------------------------
-// Array Scatter
-//------------------------------------------------------------------------------
-static void TupleDataArrayScatter(const Vector &source, const TupleDataVectorFormat &source_format,
-                                  const SelectionVector &append_sel, const idx_t append_count,
-                                  const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations,
-                                  const idx_t col_idx, const UnifiedVectorFormat &,
-                                  const vector<TupleDataScatterFunction> &child_functions) {
-	// Source
-	// The Array vector has fake list_entry_t's set by this point, so this is fine
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto data = UnifiedVectorFormat::GetData<list_entry_t>(source_data);
-	const auto &validity = source_data.validity;
-
-	// Target
-	const auto target_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-	const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	// Set validity of the LIST in this layout, and store pointer to where it's stored
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto source_idx = source_sel.get_index(append_sel.get_index(i));
-		if (validity.RowIsValid(source_idx)) {
-			auto &target_heap_location = target_heap_locations[i];
-			Store<data_ptr_t>(target_heap_location, target_locations[i] + offset_in_row);
-
-			// Store list length and skip over it
-			Store<uint64_t>(data[source_idx].length, target_heap_location);
-			target_heap_location += sizeof(uint64_t);
-		} else {
-			ValidityBytes(target_locations[i], layout.ColumnCount()).SetInvalidUnsafe(entry_idx, idx_in_entry);
-		}
-	}
-
-	// Recurse
-	D_ASSERT(child_functions.size() == 1);
-	auto &child_source = ArrayVector::GetEntry(source);
-	auto &child_format = source_format.children[0];
-	const auto &child_function = child_functions[0];
-	child_function.function(child_source, child_format, append_sel, append_count, layout, row_locations, heap_locations,
-	                        col_idx, source_format.unified, child_function.child_functions);
-}
-
-//------------------------------------------------------------------------------
-// Collection Scatter
-//------------------------------------------------------------------------------
-template <class T>
-static void TupleDataTemplatedWithinCollectionScatter(const Vector &, const TupleDataVectorFormat &source_format,
-                                                      const SelectionVector &append_sel, const idx_t append_count,
-                                                      const TupleDataLayout &, const Vector &, Vector &heap_locations,
-                                                      const idx_t, const UnifiedVectorFormat &list_data,
-                                                      const vector<TupleDataScatterFunction> &) {
-	// Parent list data
-	const auto &list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Source
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto data = UnifiedVectorFormat::GetData<T>(source_data);
-	const auto &source_validity = source_data.validity;
-
-	// Target
-	const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue; // Original list entry is invalid - no need to serialize the child
-		}
-
-		// Get the current list entry
-		const auto &list_entry = list_entries[list_idx];
-		const auto &list_offset = list_entry.offset;
-		const auto &list_length = list_entry.length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Initialize validity mask and skip heap pointer over it
-		auto &target_heap_location = target_heap_locations[i];
-		ValidityBytes child_mask(target_heap_location, list_length);
-		child_mask.SetAllValid(list_length);
-		target_heap_location += ValidityBytes::SizeInBytes(list_length);
-
-		// Get the start to the fixed-size data and skip the heap pointer over it
-		const auto child_data_location = target_heap_location;
-		target_heap_location += list_length * TupleDataWithinListFixedSize<T>();
-
-		// Store the data and validity belonging to this list entry
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			const auto child_source_idx = source_sel.get_index(list_offset + child_i);
-			if (source_validity.RowIsValid(child_source_idx)) {
-				TupleDataWithinListValueStore<T>(data[child_source_idx],
-				                                 child_data_location + child_i * TupleDataWithinListFixedSize<T>(),
-				                                 target_heap_location);
-			} else {
-				child_mask.SetInvalidUnsafe(child_i);
-			}
-		}
-	}
-}
-
-static void TupleDataStructWithinCollectionScatter(const Vector &source, const TupleDataVectorFormat &source_format,
-                                                   const SelectionVector &append_sel, const idx_t append_count,
-                                                   const TupleDataLayout &layout, const Vector &row_locations,
-                                                   Vector &heap_locations, const idx_t,
-                                                   const UnifiedVectorFormat &list_data,
-                                                   const vector<TupleDataScatterFunction> &child_functions) {
-	// Parent list data
-	const auto &list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Source
-	const auto &source_data = source_format.unified;
-	const auto &source_sel = *source_data.sel;
-	const auto &source_validity = source_data.validity;
-
-	// Target
-	const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Initialize the validity of the STRUCTs
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue; // Original list entry is invalid - no need to serialize the child
-		}
-
-		// Get the current list entry
-		const auto &list_entry = list_entries[list_idx];
-		const auto &list_offset = list_entry.offset;
-		const auto &list_length = list_entry.length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Initialize validity mask and skip the heap pointer over it
-		auto &target_heap_location = target_heap_locations[i];
-		ValidityBytes child_mask(target_heap_location, list_length);
-		child_mask.SetAllValid(list_length);
-		target_heap_location += ValidityBytes::SizeInBytes(list_length);
-
-		// Store the validity belonging to this list entry
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			const auto child_source_idx = source_sel.get_index(list_offset + child_i);
-			if (!source_validity.RowIsValid(child_source_idx)) {
-				child_mask.SetInvalidUnsafe(child_i);
-			}
-		}
-	}
-
-	// Recurse through the children
-	auto &struct_sources = StructVector::GetEntries(source);
-	for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
-		auto &struct_source = *struct_sources[struct_col_idx];
-		auto &struct_format = source_format.children[struct_col_idx];
-		const auto &struct_scatter_function = child_functions[struct_col_idx];
-		struct_scatter_function.function(struct_source, struct_format, append_sel, append_count, layout, row_locations,
-		                                 heap_locations, struct_col_idx, list_data,
-		                                 struct_scatter_function.child_functions);
-	}
-}
-
-template <class COLLECTION_VECTOR>
-static void TupleDataCollectionWithinCollectionScatter(const Vector &child_list,
-                                                       const TupleDataVectorFormat &child_list_format,
-                                                       const SelectionVector &append_sel, const idx_t append_count,
-                                                       const TupleDataLayout &layout, const Vector &row_locations,
-                                                       Vector &heap_locations, const idx_t col_idx,
-                                                       const UnifiedVectorFormat &list_data,
-                                                       const vector<TupleDataScatterFunction> &child_functions) {
-	// Parent list data
-	const auto &list_sel = *list_data.sel;
-	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto &list_validity = list_data.validity;
-
-	// Source
-	const auto &child_list_data = child_list_format.unified;
-	const auto &child_list_sel = *child_list_data.sel;
-	const auto child_list_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_list_data);
-	const auto &child_list_validity = child_list_data.validity;
-
-	// Target
-	const auto target_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	for (idx_t i = 0; i < append_count; i++) {
-		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
-		if (!list_validity.RowIsValid(list_idx)) {
-			continue; // Original list entry is invalid - no need to serialize the child list
-		}
-
-		// Get the current list entry
-		const auto &list_entry = list_entries[list_idx];
-		const auto &list_offset = list_entry.offset;
-		const auto &list_length = list_entry.length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Initialize validity mask and skip heap pointer over it
-		auto &target_heap_location = target_heap_locations[i];
-		ValidityBytes child_mask(target_heap_location, list_length);
-		child_mask.SetAllValid(list_length);
-		target_heap_location += ValidityBytes::SizeInBytes(list_length);
-
-		// Get the start to the fixed-size data and skip the heap pointer over it
-		const auto child_data_location = target_heap_location;
-		target_heap_location += list_length * sizeof(uint64_t);
-
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			const auto child_list_idx = child_list_sel.get_index(list_offset + child_i);
-			if (child_list_validity.RowIsValid(child_list_idx)) {
-				const auto &child_list_length = child_list_entries[child_list_idx].length;
-				Store<uint64_t>(child_list_length, child_data_location + child_i * sizeof(uint64_t));
-			} else {
-				child_mask.SetInvalidUnsafe(child_i);
-			}
-		}
-	}
-
-	// Recurse
-	D_ASSERT(child_functions.size() == 1);
-	auto &child_vec = COLLECTION_VECTOR::GetEntry(child_list);
-	auto &child_format = child_list_format.children[0];
-	auto &combined_child_list_data = child_format.combined_list_data->combined_data;
-	const auto &child_function = child_functions[0];
-	child_function.function(child_vec, child_format, append_sel, append_count, layout, row_locations, heap_locations,
-	                        col_idx, combined_child_list_data, child_function.child_functions);
-}
-
-//------------------------------------------------------------------------------
-// Get Scatter Function
-//------------------------------------------------------------------------------
-template <class T>
-tuple_data_scatter_function_t TupleDataGetScatterFunction(bool within_collection) {
-	return within_collection ? TupleDataTemplatedWithinCollectionScatter<T> : TupleDataTemplatedScatter<T>;
-}
-
-TupleDataScatterFunction TupleDataCollection::GetScatterFunction(const LogicalType &type, bool within_collection) {
-	TupleDataScatterFunction result;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		result.function = TupleDataGetScatterFunction<bool>(within_collection);
-		break;
-	case PhysicalType::INT8:
-		result.function = TupleDataGetScatterFunction<int8_t>(within_collection);
-		break;
-	case PhysicalType::INT16:
-		result.function = TupleDataGetScatterFunction<int16_t>(within_collection);
-		break;
-	case PhysicalType::INT32:
-		result.function = TupleDataGetScatterFunction<int32_t>(within_collection);
-		break;
-	case PhysicalType::INT64:
-		result.function = TupleDataGetScatterFunction<int64_t>(within_collection);
-		break;
-	case PhysicalType::INT128:
-		result.function = TupleDataGetScatterFunction<hugeint_t>(within_collection);
-		break;
-	case PhysicalType::UINT8:
-		result.function = TupleDataGetScatterFunction<uint8_t>(within_collection);
-		break;
-	case PhysicalType::UINT16:
-		result.function = TupleDataGetScatterFunction<uint16_t>(within_collection);
-		break;
-	case PhysicalType::UINT32:
-		result.function = TupleDataGetScatterFunction<uint32_t>(within_collection);
-		break;
-	case PhysicalType::UINT64:
-		result.function = TupleDataGetScatterFunction<uint64_t>(within_collection);
-		break;
-	case PhysicalType::UINT128:
-		result.function = TupleDataGetScatterFunction<uhugeint_t>(within_collection);
-		break;
-	case PhysicalType::FLOAT:
-		result.function = TupleDataGetScatterFunction<float>(within_collection);
-		break;
-	case PhysicalType::DOUBLE:
-		result.function = TupleDataGetScatterFunction<double>(within_collection);
-		break;
-	case PhysicalType::INTERVAL:
-		result.function = TupleDataGetScatterFunction<interval_t>(within_collection);
-		break;
-	case PhysicalType::VARCHAR:
-		result.function = TupleDataGetScatterFunction<string_t>(within_collection);
-		break;
-	case PhysicalType::STRUCT: {
-		result.function = within_collection ? TupleDataStructWithinCollectionScatter : TupleDataStructScatter;
-		for (const auto &child_type : StructType::GetChildTypes(type)) {
-			result.child_functions.push_back(GetScatterFunction(child_type.second, within_collection));
-		}
-		break;
-	}
-	case PhysicalType::LIST:
-		result.function =
-		    within_collection ? TupleDataCollectionWithinCollectionScatter<ListVector> : TupleDataListScatter;
-		result.child_functions.emplace_back(GetScatterFunction(ListType::GetChildType(type), true));
-		break;
-	case PhysicalType::ARRAY:
-		result.function =
-		    within_collection ? TupleDataCollectionWithinCollectionScatter<ArrayVector> : TupleDataArrayScatter;
-		result.child_functions.emplace_back(GetScatterFunction(ArrayType::GetChildType(type), true));
-		break;
-	default:
-		throw InternalException("Unsupported type for TupleDataCollection::GetScatterFunction");
-	}
-	return result;
-}
-
-//-------------------------------------------------------------------------------
-// Gather
-//-------------------------------------------------------------------------------
-void TupleDataCollection::Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count,
-                                 DataChunk &result, const SelectionVector &target_sel,
-                                 vector<unique_ptr<Vector>> &cached_cast_vectors) const {
-	D_ASSERT(result.ColumnCount() == layout.ColumnCount());
-	vector<column_t> column_ids;
-	column_ids.reserve(layout.ColumnCount());
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		column_ids.emplace_back(col_idx);
-	}
-	Gather(row_locations, scan_sel, scan_count, column_ids, result, target_sel, cached_cast_vectors);
-}
-
-void TupleDataCollection::Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count,
-                                 const vector<column_t> &column_ids, DataChunk &result,
-                                 const SelectionVector &target_sel,
-                                 vector<unique_ptr<Vector>> &cached_cast_vectors) const {
-	for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
-		Gather(row_locations, scan_sel, scan_count, column_ids[col_idx], result.data[col_idx], target_sel,
-		       cached_cast_vectors[col_idx].get());
-	}
-}
-
-void TupleDataCollection::Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count,
-                                 const column_t column_id, Vector &result, const SelectionVector &target_sel,
-                                 optional_ptr<Vector> cached_cast_vector) const {
-	D_ASSERT(!cached_cast_vector || FlatVector::Validity(*cached_cast_vector).AllValid()); // ResetCachedCastVectors
-	const auto &gather_function = gather_functions[column_id];
-	gather_function.function(layout, row_locations, column_id, scan_sel, scan_count, result, target_sel,
-	                         cached_cast_vector, gather_function.child_functions);
-	Vector::Verify(result, target_sel, scan_count);
-}
-
-template <class T>
-static void TupleDataTemplatedGather(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
-                                     const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                     const SelectionVector &target_sel, optional_ptr<Vector>,
-                                     const vector<TupleDataGatherFunction> &) {
-	// Source
-	const auto source_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-
-	// Target
-	auto target_data = FlatVector::GetData<T>(target);
-	auto &target_validity = FlatVector::Validity(target);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	for (idx_t i = 0; i < scan_count; i++) {
-		const auto &source_row = source_locations[scan_sel.get_index(i)];
-		const auto target_idx = target_sel.get_index(i);
-		target_data[target_idx] = Load<T>(source_row + offset_in_row);
-		ValidityBytes row_mask(source_row, layout.ColumnCount());
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
-			target_validity.SetInvalid(target_idx);
-		}
-#ifdef DEBUG
-		else {
-			TupleDataValueVerify<T>(target.GetType(), target_data[target_idx]);
-		}
-#endif
-	}
-}
-
-static void TupleDataStructGather(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
-                                  const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                  const SelectionVector &target_sel, optional_ptr<Vector> dummy_vector,
-                                  const vector<TupleDataGatherFunction> &child_functions) {
-	// Source
-	const auto source_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-
-	// Target
-	auto &target_validity = FlatVector::Validity(target);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	// Get validity of the struct and create a Vector of pointers to the start of the TupleDataLayout of the STRUCT
-	Vector struct_row_locations(LogicalType::POINTER);
-	auto struct_source_locations = FlatVector::GetData<data_ptr_t>(struct_row_locations);
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	for (idx_t i = 0; i < scan_count; i++) {
-		const auto source_idx = scan_sel.get_index(i);
-		const auto &source_row = source_locations[source_idx];
-
-		// Set the validity
-		ValidityBytes row_mask(source_row, layout.ColumnCount());
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
-			const auto target_idx = target_sel.get_index(i);
-			target_validity.SetInvalid(target_idx);
-		}
-
-		// Set the pointer
-		struct_source_locations[source_idx] = source_row + offset_in_row;
-	}
-
-	// Get the struct layout and struct entries
-	const auto &struct_layout = layout.GetStructLayout(col_idx);
-	auto &struct_targets = StructVector::GetEntries(target);
-	D_ASSERT(struct_layout.ColumnCount() == struct_targets.size());
-
-	// Recurse through the struct children
-	for (idx_t struct_col_idx = 0; struct_col_idx < struct_layout.ColumnCount(); struct_col_idx++) {
-		auto &struct_target = *struct_targets[struct_col_idx];
-		const auto &struct_gather_function = child_functions[struct_col_idx];
-		struct_gather_function.function(struct_layout, struct_row_locations, struct_col_idx, scan_sel, scan_count,
-		                                struct_target, target_sel, dummy_vector,
-		                                struct_gather_function.child_functions);
-	}
-}
-
-//------------------------------------------------------------------------------
-// List Gather
-//------------------------------------------------------------------------------
-static void TupleDataListGather(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
-                                const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                const SelectionVector &target_sel, optional_ptr<Vector>,
-                                const vector<TupleDataGatherFunction> &child_functions) {
-	// Source
-	const auto source_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-
-	// Target
-	const auto target_list_entries = FlatVector::GetData<list_entry_t>(target);
-	auto &target_list_validity = FlatVector::Validity(target);
-
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-	// Load pointers to the data from the row
-	Vector heap_locations(LogicalType::POINTER);
-	const auto source_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	const auto offset_in_row = layout.GetOffsets()[col_idx];
-	auto list_size_before = ListVector::GetListSize(target);
-	uint64_t target_list_offset = list_size_before;
-	for (idx_t i = 0; i < scan_count; i++) {
-		const auto &source_row = source_locations[scan_sel.get_index(i)];
-		ValidityBytes row_mask(source_row, layout.ColumnCount());
-
-		const auto target_idx = target_sel.get_index(i);
-		if (row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
-			auto &source_heap_location = source_heap_locations[i];
-			source_heap_location = Load<data_ptr_t>(source_row + offset_in_row);
-
-			// Load list size and skip over
-			const auto list_length = Load<uint64_t>(source_heap_location);
-			source_heap_location += sizeof(uint64_t);
-
-			// Initialize list entry, and increment offset
-			auto &target_list_entry = target_list_entries[target_idx];
-			target_list_entry.offset = target_list_offset;
-			target_list_entry.length = list_length;
-			target_list_offset += list_length;
-		} else {
-			target_list_validity.SetInvalid(target_idx);
-		}
-	}
-	ListVector::Reserve(target, target_list_offset);
-	ListVector::SetListSize(target, target_list_offset);
-
-	// Recurse
-	D_ASSERT(child_functions.size() == 1);
-	const auto &child_function = child_functions[0];
-	child_function.function(layout, heap_locations, list_size_before, scan_sel, scan_count,
-	                        ListVector::GetEntry(target), target_sel, &target, child_function.child_functions);
-}
-
-//------------------------------------------------------------------------------
-// Collection Gather
-//------------------------------------------------------------------------------
-template <class T>
-static void
-TupleDataTemplatedWithinCollectionGather(const TupleDataLayout &, Vector &heap_locations, const idx_t list_size_before,
-                                         const SelectionVector &, const idx_t scan_count, Vector &target,
-                                         const SelectionVector &target_sel, optional_ptr<Vector> list_vector,
-                                         const vector<TupleDataGatherFunction> &) {
-	// List parent
-	const auto list_entries = FlatVector::GetData<list_entry_t>(*list_vector);
-	const auto &list_validity = FlatVector::Validity(*list_vector);
-
-	// Source
-	const auto source_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Target
-	const auto target_data = FlatVector::GetData<T>(target);
-	auto &target_validity = FlatVector::Validity(target);
-
-	uint64_t target_offset = list_size_before;
-	for (idx_t i = 0; i < scan_count; i++) {
-		const auto target_idx = target_sel.get_index(i);
-		if (!list_validity.RowIsValid(target_idx)) {
-			continue;
-		}
-
-		const auto &list_length = list_entries[target_idx].length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Initialize validity mask
-		auto &source_heap_location = source_heap_locations[i];
-		ValidityBytes source_mask(source_heap_location, list_length);
-		source_heap_location += ValidityBytes::SizeInBytes(list_length);
-
-		// Get the start to the fixed-size data and skip the heap pointer over it
-		const auto source_data_location = source_heap_location;
-		source_heap_location += list_length * TupleDataWithinListFixedSize<T>();
-
-		// Load the child validity and data belonging to this list entry
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			if (source_mask.RowIsValidUnsafe(child_i)) {
-				auto &target_value = target_data[target_offset + child_i];
-				target_value = TupleDataWithinListValueLoad<T>(
-				    source_data_location + child_i * TupleDataWithinListFixedSize<T>(), source_heap_location);
-				TupleDataValueVerify(target.GetType(), target_value);
-			} else {
-				target_validity.SetInvalid(target_offset + child_i);
-			}
-		}
-		target_offset += list_length;
-	}
-}
-
-static void TupleDataStructWithinCollectionGather(const TupleDataLayout &layout, Vector &heap_locations,
-                                                  const idx_t list_size_before, const SelectionVector &scan_sel,
-                                                  const idx_t scan_count, Vector &target,
-                                                  const SelectionVector &target_sel, optional_ptr<Vector> list_vector,
-                                                  const vector<TupleDataGatherFunction> &child_functions) {
-	// List parent
-	const auto list_entries = FlatVector::GetData<list_entry_t>(*list_vector);
-	const auto &list_validity = FlatVector::Validity(*list_vector);
-
-	// Source
-	const auto source_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Target
-	auto &target_validity = FlatVector::Validity(target);
-
-	uint64_t target_offset = list_size_before;
-	for (idx_t i = 0; i < scan_count; i++) {
-		const auto target_idx = target_sel.get_index(i);
-		if (!list_validity.RowIsValid(target_idx)) {
-			continue;
-		}
-
-		const auto &list_length = list_entries[target_idx].length;
-		if (list_length == 0) {
-			continue;
-		}
-
-		// Initialize validity mask and skip over it
-		auto &source_heap_location = source_heap_locations[i];
-		ValidityBytes source_mask(source_heap_location, list_length);
-		source_heap_location += ValidityBytes::SizeInBytes(list_length);
-
-		// Load the child validity belonging to this list entry
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			if (!source_mask.RowIsValidUnsafe(child_i)) {
-				target_validity.SetInvalid(target_offset + child_i);
-			}
-		}
-		target_offset += list_length;
-	}
-
-	// Recurse
-	auto &struct_targets = StructVector::GetEntries(target);
-	for (idx_t struct_col_idx = 0; struct_col_idx < struct_targets.size(); struct_col_idx++) {
-		auto &struct_target = *struct_targets[struct_col_idx];
-		const auto &struct_gather_function = child_functions[struct_col_idx];
-		struct_gather_function.function(layout, heap_locations, list_size_before, scan_sel, scan_count, struct_target,
-		                                target_sel, list_vector, struct_gather_function.child_functions);
-	}
-}
-
-static void TupleDataCollectionWithinCollectionGather(const TupleDataLayout &layout, Vector &heap_locations,
-                                                      const idx_t list_size_before, const SelectionVector &scan_sel,
-                                                      const idx_t scan_count, Vector &target,
-                                                      const SelectionVector &target_sel,
-                                                      optional_ptr<Vector> list_vector,
-                                                      const vector<TupleDataGatherFunction> &child_functions) {
-	// List parent
-	const auto list_entries = FlatVector::GetData<list_entry_t>(*list_vector);
-	const auto &list_validity = FlatVector::Validity(*list_vector);
-
-	// Source
-	const auto source_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations);
-
-	// Target
-	const auto target_list_entries = FlatVector::GetData<list_entry_t>(target);
-	auto &target_validity = FlatVector::Validity(target);
-	const auto child_list_size_before = ListVector::GetListSize(target);
-
-	// We need to create a vector that has the combined list sizes (hugeint_t has same size as list_entry_t)
-	Vector combined_list_vector(LogicalType::HUGEINT);
-	FlatVector::SetValidity(combined_list_vector, list_validity); // Has same validity as list parent
-	const auto combined_list_entries = FlatVector::GetData<list_entry_t>(combined_list_vector);
-
-	uint64_t target_offset = list_size_before;
-	uint64_t target_child_offset = child_list_size_before;
-	for (idx_t i = 0; i < scan_count; i++) {
-		const auto target_idx = target_sel.get_index(i);
-		if (!list_validity.RowIsValid(target_idx)) {
-			continue;
-		}
-
-		// Set the offset of the combined list entry
-		auto &combined_list_entry = combined_list_entries[target_idx];
-		combined_list_entry.offset = target_child_offset;
-
-		const auto &list_length = list_entries[target_idx].length;
-		if (list_length == 0) {
-			combined_list_entry.length = 0;
-			continue;
-		}
-
-		// Initialize validity mask and skip over it
-		auto &source_heap_location = source_heap_locations[i];
-		ValidityBytes source_mask(source_heap_location, list_length);
-		source_heap_location += ValidityBytes::SizeInBytes(list_length);
-
-		// Get the start to the fixed-size data and skip the heap pointer over it
-		const auto source_data_location = source_heap_location;
-		source_heap_location += list_length * sizeof(uint64_t);
-
-		// Load the child validity and data belonging to this list entry
-		for (idx_t child_i = 0; child_i < list_length; child_i++) {
-			if (source_mask.RowIsValidUnsafe(child_i)) {
-				auto &target_list_entry = target_list_entries[target_offset + child_i];
-				target_list_entry.offset = target_child_offset;
-				target_list_entry.length = Load<uint64_t>(source_data_location + child_i * sizeof(uint64_t));
-				target_child_offset += target_list_entry.length;
-			} else {
-				target_validity.SetInvalid(target_offset + child_i);
-			}
-		}
-
-		// Set the length of the combined list entry
-		combined_list_entry.length = target_child_offset - combined_list_entry.offset;
-
-		target_offset += list_length;
-	}
-
-	ListVector::Reserve(target, target_child_offset);
-	ListVector::SetListSize(target, target_child_offset);
-
-	// Recurse
-	D_ASSERT(child_functions.size() == 1);
-	const auto &child_function = child_functions[0];
-	child_function.function(layout, heap_locations, child_list_size_before, scan_sel, scan_count,
-	                        ListVector::GetEntry(target), target_sel, &combined_list_vector,
-	                        child_function.child_functions);
-}
-
-//------------------------------------------------------------------------------
-// Special cases for arrays
-//------------------------------------------------------------------------------
-// A gather function that wraps another gather function and casts the result to the target array type
-static void TupleDataCastToArrayListGather(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
-                                           const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                           const SelectionVector &target_sel, optional_ptr<Vector> cached_cast_vector,
-                                           const vector<TupleDataGatherFunction> &child_functions) {
-	if (cached_cast_vector) {
-		// Reuse the cached cast vector
-		TupleDataListGather(layout, row_locations, col_idx, scan_sel, scan_count, *cached_cast_vector, target_sel,
-		                    cached_cast_vector, child_functions);
-		VectorOperations::DefaultCast(*cached_cast_vector, target, scan_count);
-	} else {
-		// Otherwise, create a new temporary cast vector
-		Vector cast_vector(ArrayType::ConvertToList(target.GetType()));
-		TupleDataListGather(layout, row_locations, col_idx, scan_sel, scan_count, cast_vector, target_sel, &cast_vector,
-		                    child_functions);
-		VectorOperations::DefaultCast(cast_vector, target, scan_count);
-	}
-}
-
-static void TupleDataCastToArrayStructGather(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
-                                             const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                             const SelectionVector &target_sel, optional_ptr<Vector> cached_cast_vector,
-                                             const vector<TupleDataGatherFunction> &child_functions) {
-
-	if (cached_cast_vector) {
-		// Reuse the cached cast vector
-		TupleDataStructGather(layout, row_locations, col_idx, scan_sel, scan_count, *cached_cast_vector, target_sel,
-		                      cached_cast_vector, child_functions);
-		VectorOperations::DefaultCast(*cached_cast_vector, target, scan_count);
-	} else {
-		// Otherwise, create a new temporary cast vector
-		Vector cast_vector(ArrayType::ConvertToList(target.GetType()));
-		TupleDataStructGather(layout, row_locations, col_idx, scan_sel, scan_count, cast_vector, target_sel,
-		                      &cast_vector, child_functions);
-		VectorOperations::DefaultCast(cast_vector, target, scan_count);
-	}
-}
-
-//------------------------------------------------------------------------------
-// Get Gather Function
-//------------------------------------------------------------------------------
-template <class T>
-tuple_data_gather_function_t TupleDataGetGatherFunction(bool within_collection) {
-	return within_collection ? TupleDataTemplatedWithinCollectionGather<T> : TupleDataTemplatedGather<T>;
-}
-
-static TupleDataGatherFunction TupleDataGetGatherFunctionInternal(const LogicalType &type, bool within_collection) {
-	TupleDataGatherFunction result;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		result.function = TupleDataGetGatherFunction<bool>(within_collection);
-		break;
-	case PhysicalType::INT8:
-		result.function = TupleDataGetGatherFunction<int8_t>(within_collection);
-		break;
-	case PhysicalType::INT16:
-		result.function = TupleDataGetGatherFunction<int16_t>(within_collection);
-		break;
-	case PhysicalType::INT32:
-		result.function = TupleDataGetGatherFunction<int32_t>(within_collection);
-		break;
-	case PhysicalType::INT64:
-		result.function = TupleDataGetGatherFunction<int64_t>(within_collection);
-		break;
-	case PhysicalType::INT128:
-		result.function = TupleDataGetGatherFunction<hugeint_t>(within_collection);
-		break;
-	case PhysicalType::UINT8:
-		result.function = TupleDataGetGatherFunction<uint8_t>(within_collection);
-		break;
-	case PhysicalType::UINT16:
-		result.function = TupleDataGetGatherFunction<uint16_t>(within_collection);
-		break;
-	case PhysicalType::UINT32:
-		result.function = TupleDataGetGatherFunction<uint32_t>(within_collection);
-		break;
-	case PhysicalType::UINT64:
-		result.function = TupleDataGetGatherFunction<uint64_t>(within_collection);
-		break;
-	case PhysicalType::UINT128:
-		result.function = TupleDataGetGatherFunction<uhugeint_t>(within_collection);
-		break;
-	case PhysicalType::FLOAT:
-		result.function = TupleDataGetGatherFunction<float>(within_collection);
-		break;
-	case PhysicalType::DOUBLE:
-		result.function = TupleDataGetGatherFunction<double>(within_collection);
-		break;
-	case PhysicalType::INTERVAL:
-		result.function = TupleDataGetGatherFunction<interval_t>(within_collection);
-		break;
-	case PhysicalType::VARCHAR:
-		result.function = TupleDataGetGatherFunction<string_t>(within_collection);
-		break;
-	case PhysicalType::STRUCT: {
-		result.function = within_collection ? TupleDataStructWithinCollectionGather : TupleDataStructGather;
-		for (const auto &child_type : StructType::GetChildTypes(type)) {
-			result.child_functions.push_back(TupleDataGetGatherFunctionInternal(child_type.second, within_collection));
-		}
-		break;
-	}
-	case PhysicalType::LIST:
-		result.function = within_collection ? TupleDataCollectionWithinCollectionGather : TupleDataListGather;
-		result.child_functions.push_back(TupleDataGetGatherFunctionInternal(ListType::GetChildType(type), true));
-		break;
-	case PhysicalType::ARRAY:
-		result.function = within_collection ? TupleDataCollectionWithinCollectionGather : TupleDataListGather;
-		result.child_functions.push_back(TupleDataGetGatherFunctionInternal(ArrayType::GetChildType(type), true));
-		break;
-	default:
-		throw InternalException("Unsupported type for TupleDataCollection::GetGatherFunction");
-	}
-	return result;
-}
-
-TupleDataGatherFunction TupleDataCollection::GetGatherFunction(const LogicalType &type) {
-	if (!type.IsNested()) {
-		return TupleDataGetGatherFunctionInternal(type, false);
-	}
-
-	if (TypeVisitor::Contains(type, LogicalTypeId::ARRAY)) {
-		// Special case: we cant handle arrays yet, so we need to replace them with lists when gathering
-		const auto new_type = ArrayType::ConvertToList(type);
-		TupleDataGatherFunction result;
-		// Theres only two cases: Either the array is within a struct, or it is within a list (or has now become a list)
-		switch (new_type.InternalType()) {
-		case PhysicalType::LIST:
-			result.function = TupleDataCastToArrayListGather;
-			result.child_functions.push_back(
-			    TupleDataGetGatherFunctionInternal(ListType::GetChildType(new_type), true));
-			return result;
-		case PhysicalType::STRUCT:
-			result.function = TupleDataCastToArrayStructGather;
-			for (const auto &child_type : StructType::GetChildTypes(new_type)) {
-				result.child_functions.push_back(TupleDataGetGatherFunctionInternal(child_type.second, false));
-			}
-			return result;
-		default:
-			throw InternalException("Unsupported type for TupleDataCollection::GetGatherFunction");
-		}
-	}
-	return TupleDataGetGatherFunctionInternal(type, false);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/row/tuple_data_segment.cpp b/src/duckdb/src/common/types/row/tuple_data_segment.cpp
deleted file mode 100644
index ddec13238..000000000
--- a/src/duckdb/src/common/types/row/tuple_data_segment.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-#include "duckdb/common/types/row/tuple_data_segment.hpp"
-
-#include "duckdb/common/types/row/tuple_data_allocator.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-
-namespace duckdb {
-
-TupleDataChunkPart::TupleDataChunkPart(mutex &lock_p) : lock(lock_p) {
-}
-
-void TupleDataChunkPart::SetHeapEmpty() {
-	heap_block_index = INVALID_INDEX;
-	heap_block_offset = INVALID_INDEX;
-	total_heap_size = 0;
-	base_heap_ptr = nullptr;
-}
-
-void SwapTupleDataChunkPart(TupleDataChunkPart &a, TupleDataChunkPart &b) {
-	std::swap(a.row_block_index, b.row_block_index);
-	std::swap(a.row_block_offset, b.row_block_offset);
-	std::swap(a.heap_block_index, b.heap_block_index);
-	std::swap(a.heap_block_offset, b.heap_block_offset);
-	std::swap(a.base_heap_ptr, b.base_heap_ptr);
-	std::swap(a.total_heap_size, b.total_heap_size);
-	std::swap(a.count, b.count);
-	std::swap(a.lock, b.lock);
-}
-
-TupleDataChunkPart::TupleDataChunkPart(TupleDataChunkPart &&other) noexcept : lock((other.lock)) {
-	SwapTupleDataChunkPart(*this, other);
-}
-
-TupleDataChunkPart &TupleDataChunkPart::operator=(TupleDataChunkPart &&other) noexcept {
-	SwapTupleDataChunkPart(*this, other);
-	return *this;
-}
-
-TupleDataChunk::TupleDataChunk() : count(0), lock(make_unsafe_uniq<mutex>()) {
-	parts.reserve(2);
-}
-
-static inline void SwapTupleDataChunk(TupleDataChunk &a, TupleDataChunk &b) noexcept {
-	std::swap(a.parts, b.parts);
-	std::swap(a.row_block_ids, b.row_block_ids);
-	std::swap(a.heap_block_ids, b.heap_block_ids);
-	std::swap(a.count, b.count);
-	std::swap(a.lock, b.lock);
-}
-
-TupleDataChunk::TupleDataChunk(TupleDataChunk &&other) noexcept {
-	SwapTupleDataChunk(*this, other);
-}
-
-TupleDataChunk &TupleDataChunk::operator=(TupleDataChunk &&other) noexcept {
-	SwapTupleDataChunk(*this, other);
-	return *this;
-}
-
-void TupleDataChunk::AddPart(TupleDataChunkPart &&part, const TupleDataLayout &layout) {
-	count += part.count;
-	row_block_ids.insert(part.row_block_index);
-	if (!layout.AllConstant() && part.total_heap_size > 0) {
-		heap_block_ids.insert(part.heap_block_index);
-	}
-	part.lock = *lock;
-	parts.emplace_back(std::move(part));
-}
-
-void TupleDataChunk::Verify() const {
-#ifdef DEBUG
-	idx_t total_count = 0;
-	for (const auto &part : parts) {
-		total_count += part.count;
-	}
-	D_ASSERT(this->count == total_count);
-	D_ASSERT(this->count <= STANDARD_VECTOR_SIZE);
-#endif
-}
-
-void TupleDataChunk::MergeLastChunkPart(const TupleDataLayout &layout) {
-	if (parts.size() < 2) {
-		return;
-	}
-
-	auto &second_to_last = parts[parts.size() - 2];
-	auto &last = parts[parts.size() - 1];
-
-	auto rows_align =
-	    last.row_block_index == second_to_last.row_block_index &&
-	    last.row_block_offset == second_to_last.row_block_offset + second_to_last.count * layout.GetRowWidth();
-
-	if (!rows_align) { // If rows don't align we can never merge
-		return;
-	}
-
-	if (layout.AllConstant()) { // No heap and rows align - merge
-		second_to_last.count += last.count;
-		parts.pop_back();
-		return;
-	}
-
-	if (last.heap_block_index == second_to_last.heap_block_index &&
-	    last.heap_block_offset == second_to_last.heap_block_index + second_to_last.total_heap_size &&
-	    last.base_heap_ptr == second_to_last.base_heap_ptr) { // There is a heap and it aligns - merge
-		second_to_last.total_heap_size += last.total_heap_size;
-		second_to_last.count += last.count;
-		parts.pop_back();
-	}
-}
-
-TupleDataSegment::TupleDataSegment(shared_ptr<TupleDataAllocator> allocator_p)
-    : allocator(std::move(allocator_p)), count(0), data_size(0) {
-}
-
-TupleDataSegment::~TupleDataSegment() {
-	lock_guard<mutex> guard(pinned_handles_lock);
-	if (allocator) {
-		allocator->SetDestroyBufferUponUnpin(); // Prevent blocks from being added to eviction queue
-	}
-	pinned_row_handles.clear();
-	pinned_heap_handles.clear();
-	if (Allocator::SupportsFlush() && allocator &&
-	    data_size > allocator->GetBufferManager().GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) {
-		Allocator::FlushAll();
-	}
-	allocator.reset();
-}
-
-void SwapTupleDataSegment(TupleDataSegment &a, TupleDataSegment &b) {
-	std::swap(a.allocator, b.allocator);
-	std::swap(a.chunks, b.chunks);
-	std::swap(a.count, b.count);
-	std::swap(a.data_size, b.data_size);
-	std::swap(a.pinned_row_handles, b.pinned_row_handles);
-	std::swap(a.pinned_heap_handles, b.pinned_heap_handles);
-}
-
-TupleDataSegment::TupleDataSegment(TupleDataSegment &&other) noexcept {
-	SwapTupleDataSegment(*this, other);
-}
-
-TupleDataSegment &TupleDataSegment::operator=(TupleDataSegment &&other) noexcept {
-	SwapTupleDataSegment(*this, other);
-	return *this;
-}
-
-idx_t TupleDataSegment::ChunkCount() const {
-	return chunks.size();
-}
-
-idx_t TupleDataSegment::SizeInBytes() const {
-	return data_size;
-}
-
-void TupleDataSegment::Unpin() {
-	lock_guard<mutex> guard(pinned_handles_lock);
-	pinned_row_handles.clear();
-	pinned_heap_handles.clear();
-}
-
-void TupleDataSegment::Verify() const {
-#ifdef DEBUG
-	const auto &layout = allocator->GetLayout();
-
-	idx_t total_count = 0;
-	idx_t total_size = 0;
-	for (const auto &chunk : chunks) {
-		chunk.Verify();
-		total_count += chunk.count;
-
-		total_size += chunk.count * layout.GetRowWidth();
-		if (!layout.AllConstant()) {
-			for (const auto &part : chunk.parts) {
-				total_size += part.total_heap_size;
-			}
-		}
-	}
-	D_ASSERT(total_count == this->count);
-	D_ASSERT(total_size == this->data_size);
-#endif
-}
-
-void TupleDataSegment::VerifyEverythingPinned() const {
-#ifdef DEBUG
-	D_ASSERT(pinned_row_handles.size() == allocator->RowBlockCount());
-	D_ASSERT(pinned_heap_handles.size() == allocator->HeapBlockCount());
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/selection_vector.cpp b/src/duckdb/src/common/types/selection_vector.cpp
deleted file mode 100644
index 7b6fda414..000000000
--- a/src/duckdb/src/common/types/selection_vector.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "duckdb/common/types/selection_vector.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-SelectionData::SelectionData(idx_t count) {
-	owned_data = make_unsafe_uniq_array_uninitialized<sel_t>(count);
-#ifdef DEBUG
-	for (idx_t i = 0; i < count; i++) {
-		owned_data[i] = std::numeric_limits<sel_t>::max();
-	}
-#endif
-}
-
-// LCOV_EXCL_START
-string SelectionVector::ToString(idx_t count) const {
-	string result = "Selection Vector (" + to_string(count) + ") [";
-	for (idx_t i = 0; i < count; i++) {
-		if (i != 0) {
-			result += ", ";
-		}
-		result += to_string(get_index(i));
-	}
-	result += "]";
-	return result;
-}
-
-void SelectionVector::Print(idx_t count) const {
-	Printer::Print(ToString(count));
-}
-// LCOV_EXCL_STOP
-
-buffer_ptr<SelectionData> SelectionVector::Slice(const SelectionVector &sel, idx_t count) const {
-	auto data = make_buffer<SelectionData>(count);
-	auto result_ptr = data->owned_data.get();
-	// for every element, we perform result[i] = target[new[i]]
-	for (idx_t i = 0; i < count; i++) {
-		auto new_idx = sel.get_index(i);
-		auto idx = this->get_index(new_idx);
-		result_ptr[i] = UnsafeNumericCast<sel_t>(idx);
-	}
-	return data;
-}
-
-void SelectionVector::Verify(idx_t count, idx_t vector_size) const {
-#ifdef DEBUG
-	D_ASSERT(vector_size >= 1);
-	for (idx_t i = 0; i < count; i++) {
-		auto index = get_index(i);
-		if (index >= vector_size) {
-			throw InternalException(
-			    "Provided SelectionVector is invalid, index %d points to %d, which is out of range. "
-			    "the valid range (0-%d)",
-			    i, index, vector_size - 1);
-		}
-	}
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/string_heap.cpp b/src/duckdb/src/common/types/string_heap.cpp
deleted file mode 100644
index be23433dd..000000000
--- a/src/duckdb/src/common/types/string_heap.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "duckdb/common/types/string_heap.hpp"
-
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-StringHeap::StringHeap(Allocator &allocator) : allocator(allocator) {
-}
-
-void StringHeap::Destroy() {
-	allocator.Destroy();
-}
-
-void StringHeap::Move(StringHeap &other) {
-	other.allocator.Move(allocator);
-}
-
-string_t StringHeap::AddString(const char *data, idx_t len) {
-	D_ASSERT(Utf8Proc::Analyze(data, len) != UnicodeType::INVALID);
-	return AddBlob(data, len);
-}
-
-string_t StringHeap::AddString(const char *data) {
-	return AddString(data, strlen(data));
-}
-
-string_t StringHeap::AddString(const string &data) {
-	return AddString(data.c_str(), data.size());
-}
-
-string_t StringHeap::AddString(const string_t &data) {
-	return AddString(data.GetData(), data.GetSize());
-}
-
-string_t StringHeap::AddBlob(const char *data, idx_t len) {
-	auto insert_string = EmptyString(len);
-	auto insert_pos = insert_string.GetDataWriteable();
-	memcpy(insert_pos, data, len);
-	insert_string.Finalize();
-	return insert_string;
-}
-
-string_t StringHeap::AddBlob(const string_t &data) {
-	return AddBlob(data.GetData(), data.GetSize());
-}
-
-string_t StringHeap::EmptyString(idx_t len) {
-	D_ASSERT(len > string_t::INLINE_LENGTH);
-	if (len > string_t::MAX_STRING_SIZE) {
-		throw OutOfRangeException("Cannot create a string of size: '%d', the maximum supported string size is: '%d'",
-		                          len, string_t::MAX_STRING_SIZE);
-	}
-	auto insert_pos = const_char_ptr_cast(allocator.Allocate(len));
-	return string_t(insert_pos, UnsafeNumericCast<uint32_t>(len));
-}
-
-idx_t StringHeap::SizeInBytes() const {
-	return allocator.SizeInBytes();
-}
-
-idx_t StringHeap::AllocationSize() const {
-	return allocator.AllocationSize();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/string_type.cpp b/src/duckdb/src/common/types/string_type.cpp
deleted file mode 100644
index f5a236557..000000000
--- a/src/duckdb/src/common/types/string_type.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/common/types/string_type.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-void string_t::Verify() const {
-#ifdef DEBUG
-	VerifyUTF8();
-#endif
-
-	VerifyCharacters();
-}
-
-void string_t::VerifyUTF8() const {
-	auto dataptr = GetData();
-	(void)dataptr;
-	D_ASSERT(dataptr);
-
-	auto utf_type = Utf8Proc::Analyze(dataptr, GetSize());
-	(void)utf_type;
-	D_ASSERT(utf_type != UnicodeType::INVALID);
-}
-
-void string_t::VerifyCharacters() const {
-	auto dataptr = GetData();
-	(void)dataptr;
-	D_ASSERT(dataptr);
-
-	// verify that the prefix contains the first four characters of the string
-	for (idx_t i = 0; i < MinValue<idx_t>(PREFIX_LENGTH, GetSize()); i++) {
-		D_ASSERT(GetPrefix()[i] == dataptr[i]);
-	}
-	// verify that for strings with length <= INLINE_LENGTH, the rest of the string is zero
-	for (idx_t i = GetSize(); i < INLINE_LENGTH; i++) {
-		D_ASSERT(GetData()[i] == '\0');
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/time.cpp b/src/duckdb/src/common/types/time.cpp
deleted file mode 100644
index fa4d135f5..000000000
--- a/src/duckdb/src/common/types/time.cpp
+++ /dev/null
@@ -1,347 +0,0 @@
-#include "duckdb/common/types/time.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-
-#include <cctype>
-#include <cstring>
-#include <sstream>
-
-namespace duckdb {
-static_assert(sizeof(dtime_t) == sizeof(int64_t), "dtime_t was padded");
-
-// string format is hh:mm:ss.microsecondsZ
-// microseconds and Z are optional
-// ISO 8601
-
-bool Time::TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict,
-                              optional_ptr<int32_t> nanos) {
-	int32_t hour = -1, min = -1, sec = -1, micros = -1;
-	pos = 0;
-
-	if (len == 0) {
-		return false;
-	}
-
-	int sep;
-
-	// skip leading spaces
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	if (!StringUtil::CharacterIsDigit(buf[pos])) {
-		return false;
-	}
-
-	// Allow up to 9 digit hours to support intervals
-	hour = 0;
-	for (int32_t digits = 9; pos < len && StringUtil::CharacterIsDigit(buf[pos]); ++pos) {
-		if (digits-- > 0) {
-			hour = hour * 10 + (buf[pos] - '0');
-		} else {
-			return false;
-		}
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	// fetch the separator
-	sep = buf[pos++];
-	if (sep != ':') {
-		// invalid separator
-		return false;
-	}
-	idx_t sep_pos = pos;
-	if (pos == len && !strict) {
-		min = 0;
-	} else {
-		if (!Date::ParseDoubleDigit(buf, len, pos, min)) {
-			return false;
-		}
-		if (min < 0 || min >= 60) {
-			return false;
-		}
-	}
-
-	if (pos > len) {
-		return false;
-	}
-	if (pos == len && (!strict || sep_pos + 2 == pos)) {
-		sec = 0;
-	} else {
-		if (buf[pos++] != sep) {
-			return false;
-		}
-
-		if (pos == len && !strict) {
-			sec = 0;
-		} else {
-			if (!Date::ParseDoubleDigit(buf, len, pos, sec)) {
-				return false;
-			}
-			if (sec < 0 || sec >= 60) {
-				return false;
-			}
-		}
-	}
-
-	micros = 0;
-	if (pos < len && buf[pos] == '.') {
-		pos++;
-		// we expect some microseconds
-		int32_t mult = 100000;
-		if (nanos) {
-			// do we expect nanoseconds?
-			mult *= Interval::NANOS_PER_MICRO;
-		}
-		for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++, mult /= 10) {
-			if (mult > 0) {
-				micros += (buf[pos] - '0') * mult;
-			}
-		}
-		if (nanos) {
-			*nanos = UnsafeNumericCast<int32_t>(micros % Interval::NANOS_PER_MICRO);
-			micros /= Interval::NANOS_PER_MICRO;
-		}
-	}
-
-	// in strict mode, check remaining string for non-space characters
-	if (strict) {
-		// skip trailing spaces
-		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-			pos++;
-		}
-		// check position. if end was not reached, non-space chars remaining
-		if (pos < len) {
-			return false;
-		}
-	}
-
-	result = Time::FromTime(hour, min, sec, micros);
-	return true;
-}
-
-bool Time::TryConvertInterval(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict,
-                              optional_ptr<int32_t> nanos) {
-	return Time::TryConvertInternal(buf, len, pos, result, strict, nanos);
-}
-
-bool Time::TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict,
-                          optional_ptr<int32_t> nanos) {
-	if (!Time::TryConvertInternal(buf, len, pos, result, strict, nanos)) {
-		if (!strict) {
-			// last chance, check if we can parse as timestamp
-			timestamp_t timestamp;
-			if (Timestamp::TryConvertTimestamp(buf, len, timestamp, nanos) == TimestampCastResult::SUCCESS) {
-				if (!Timestamp::IsFinite(timestamp)) {
-					return false;
-				}
-				result = Timestamp::GetTime(timestamp);
-				return true;
-			}
-		}
-		return false;
-	}
-	return result.micros <= Interval::MICROS_PER_DAY;
-}
-
-bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, bool &has_offset, bool strict,
-                            optional_ptr<int32_t> nanos) {
-	dtime_t time_part;
-	has_offset = false;
-	if (!Time::TryConvertInternal(buf, len, pos, time_part, false, nanos)) {
-		if (!strict) {
-			// last chance, check if we can parse as timestamp
-			timestamp_t timestamp;
-			if (Timestamp::TryConvertTimestamp(buf, len, timestamp, nanos) == TimestampCastResult::SUCCESS) {
-				if (!Timestamp::IsFinite(timestamp)) {
-					return false;
-				}
-				result = dtime_tz_t(Timestamp::GetTime(timestamp), 0);
-				return true;
-			}
-		}
-		return false;
-	}
-
-	// skip optional whitespace before offset
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
-
-	//	Get the ±HH[:MM] part
-	int hh = 0;
-	int mm = 0;
-	has_offset = (pos < len);
-	if (has_offset && !Timestamp::TryParseUTCOffset(buf, pos, len, hh, mm)) {
-		return false;
-	}
-
-	//	Offsets are in seconds in the open interval (-16:00:00, +16:00:00)
-	int32_t offset = ((hh * Interval::MINS_PER_HOUR) + mm) * Interval::SECS_PER_MINUTE;
-
-	//	Check for trailing seconds.
-	//	(PG claims they don't support this but they do...)
-	if (pos < len && buf[pos] == ':') {
-		++pos;
-		int ss = 0;
-		if (!Date::ParseDoubleDigit(buf, len, pos, ss)) {
-			return false;
-		}
-		offset += (offset < 0) ? -ss : ss;
-	}
-
-	if (offset < dtime_tz_t::MIN_OFFSET || offset > dtime_tz_t::MAX_OFFSET) {
-		return false;
-	}
-
-	// in strict mode, check remaining string for non-space characters
-	if (strict) {
-		// skip trailing spaces
-		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-			pos++;
-		}
-		// check position. if end was not reached, non-space chars remaining
-		if (pos < len) {
-			return false;
-		}
-	}
-
-	result = dtime_tz_t(time_part, offset);
-
-	return true;
-}
-
-dtime_t Time::NormalizeTimeTZ(dtime_tz_t timetz) {
-	date_t date(0);
-	return Interval::Add(timetz.time(), {0, 0, -timetz.offset() * Interval::MICROS_PER_SEC}, date);
-}
-
-string Time::ConversionError(const string &str) {
-	return StringUtil::Format("time field value out of range: \"%s\", "
-	                          "expected format is ([YYYY-MM-DD ]HH:MM:SS[.MS])",
-	                          str);
-}
-
-string Time::ConversionError(string_t str) {
-	return Time::ConversionError(str.GetString());
-}
-
-dtime_t Time::FromCString(const char *buf, idx_t len, bool strict, optional_ptr<int32_t> nanos) {
-	dtime_t result;
-	idx_t pos;
-	if (!Time::TryConvertTime(buf, len, pos, result, strict, nanos)) {
-		throw ConversionException(ConversionError(string(buf, len)));
-	}
-	return result;
-}
-
-dtime_t Time::FromString(const string &str, bool strict, optional_ptr<int32_t> nanos) {
-	return Time::FromCString(str.c_str(), str.size(), strict, nanos);
-}
-
-string Time::ToString(dtime_t time) {
-	int32_t time_units[4];
-	Time::Convert(time, time_units[0], time_units[1], time_units[2], time_units[3]);
-
-	char micro_buffer[6];
-	auto length = TimeToStringCast::Length(time_units, micro_buffer);
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(length);
-	TimeToStringCast::Format(buffer.get(), length, time_units, micro_buffer);
-	return string(buffer.get(), length);
-}
-
-string Time::ToUTCOffset(int hour_offset, int minute_offset) {
-	dtime_t time((hour_offset * Interval::MINS_PER_HOUR + minute_offset) * Interval::MICROS_PER_MINUTE);
-
-	char buffer[1 + 2 + 1 + 2];
-	idx_t length = 0;
-	buffer[length++] = (time.micros < 0 ? '-' : '+');
-	time.micros = std::abs(time.micros);
-
-	int32_t time_units[4];
-	Time::Convert(time, time_units[0], time_units[1], time_units[2], time_units[3]);
-
-	TimeToStringCast::FormatTwoDigits(buffer + length, time_units[0]);
-	length += 2;
-	if (time_units[1]) {
-		buffer[length++] = ':';
-		TimeToStringCast::FormatTwoDigits(buffer + length, time_units[1]);
-		length += 2;
-	}
-
-	return string(buffer, length);
-}
-
-dtime_t Time::FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
-	int64_t result;
-	result = hour;                                             // hours
-	result = result * Interval::MINS_PER_HOUR + minute;        // hours -> minutes
-	result = result * Interval::SECS_PER_MINUTE + second;      // minutes -> seconds
-	result = result * Interval::MICROS_PER_SEC + microseconds; // seconds -> microseconds
-	return dtime_t(result);
-}
-
-int64_t Time::ToNanoTime(int32_t hour, int32_t minute, int32_t second, int32_t nanoseconds) {
-	int64_t result;
-	result = hour;                                           // hours
-	result = result * Interval::MINS_PER_HOUR + minute;      // hours -> minutes
-	result = result * Interval::SECS_PER_MINUTE + second;    // minutes -> seconds
-	result = result * Interval::NANOS_PER_SEC + nanoseconds; // seconds -> nanoseconds
-	return result;
-}
-
-bool Time::IsValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
-	if (hour < 0 || hour >= 24) {
-		return (hour == 24) && (minute == 0) && (second == 0) && (microseconds == 0);
-	}
-	if (minute < 0 || minute >= 60) {
-		return false;
-	}
-	if (second < 0 || second > 60) {
-		return false;
-	}
-	if (microseconds < 0 || microseconds > 1000000) {
-		return false;
-	}
-	return true;
-}
-
-void Time::Convert(dtime_t dtime, int32_t &hour, int32_t &min, int32_t &sec, int32_t &micros) {
-	int64_t time = dtime.micros;
-	hour = int32_t(time / Interval::MICROS_PER_HOUR);
-	time -= int64_t(hour) * Interval::MICROS_PER_HOUR;
-	min = int32_t(time / Interval::MICROS_PER_MINUTE);
-	time -= int64_t(min) * Interval::MICROS_PER_MINUTE;
-	sec = int32_t(time / Interval::MICROS_PER_SEC);
-	time -= int64_t(sec) * Interval::MICROS_PER_SEC;
-	micros = int32_t(time);
-	D_ASSERT(Time::IsValidTime(hour, min, sec, micros));
-}
-
-dtime_t Time::FromTimeMs(int64_t time_ms) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation(time_ms, Interval::MICROS_PER_MSEC, result)) {
-		throw ConversionException("Could not convert Time(MS) to Time(US)");
-	}
-	return dtime_t(result);
-}
-
-dtime_t Time::FromTimeNs(int64_t time_ns) {
-	return dtime_t(time_ns / Interval::NANOS_PER_MICRO);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/timestamp.cpp b/src/duckdb/src/common/types/timestamp.cpp
deleted file mode 100644
index d596e7530..000000000
--- a/src/duckdb/src/common/types/timestamp.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-#include "duckdb/common/types/timestamp.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include <ctime>
-
-namespace duckdb {
-
-static_assert(sizeof(timestamp_t) == sizeof(int64_t), "timestamp_t was padded");
-
-// Temporal values need to round down when changing precision,
-// but C/C++ rounds towrds 0 when you simply divide.
-// This piece of bit banging solves that problem.
-template <typename T>
-static inline T TemporalRound(T value, T scale) {
-	const auto negative = int(value < 0);
-	return UnsafeNumericCast<T>((value + negative) / scale - negative);
-}
-
-// timestamp/datetime uses 64 bits, high 32 bits for date and low 32 bits for time
-// string format is YYYY-MM-DDThh:mm:ssZ
-// T may be a space
-// Z is optional
-// ISO 8601
-
-// arithmetic operators
-timestamp_t timestamp_t::operator+(const double &value) const {
-	timestamp_t result;
-	if (!TryAddOperator::Operation(this->value, int64_t(value), result.value)) {
-		throw OutOfRangeException("Overflow in timestamp addition");
-	}
-	return result;
-}
-
-int64_t timestamp_t::operator-(const timestamp_t &other) const {
-	int64_t result;
-	if (!TrySubtractOperator::Operation(value, int64_t(other.value), result)) {
-		throw OutOfRangeException("Overflow in timestamp subtraction");
-	}
-	return result;
-}
-
-// in-place operators
-timestamp_t &timestamp_t::operator+=(const int64_t &delta) {
-	if (!TryAddOperator::Operation(value, delta, value)) {
-		throw OutOfRangeException("Overflow in timestamp increment");
-	}
-	return *this;
-}
-
-timestamp_t &timestamp_t::operator-=(const int64_t &delta) {
-	if (!TrySubtractOperator::Operation(value, delta, value)) {
-		throw OutOfRangeException("Overflow in timestamp decrement");
-	}
-	return *this;
-}
-
-TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
-                                                     string_t &tz, optional_ptr<int32_t> nanos) {
-	idx_t pos;
-	date_t date;
-	dtime_t time;
-	has_offset = false;
-	switch (Date::TryConvertDate(str, len, pos, date, has_offset)) {
-	case DateCastResult::ERROR_INCORRECT_FORMAT:
-		return TimestampCastResult::ERROR_INCORRECT_FORMAT;
-	case DateCastResult::ERROR_RANGE:
-		return TimestampCastResult::ERROR_RANGE;
-	default:
-		break;
-	}
-	if (pos == len) {
-		// no time: only a date or special
-		if (date == date_t::infinity()) {
-			result = timestamp_t::infinity();
-			return TimestampCastResult::SUCCESS;
-		} else if (date == date_t::ninfinity()) {
-			result = timestamp_t::ninfinity();
-			return TimestampCastResult::SUCCESS;
-		}
-		return Timestamp::TryFromDatetime(date, dtime_t(0), result) ? TimestampCastResult::SUCCESS
-		                                                            : TimestampCastResult::ERROR_RANGE;
-	}
-	// try to parse a time field
-	if (str[pos] == ' ' || str[pos] == 'T') {
-		pos++;
-	}
-	idx_t time_pos = 0;
-	// TryConvertTime may recursively call us, so we opt for a stricter
-	// operation. Note that we can't pass strict== true here because we
-	// want to process any suffix.
-	if (!Time::TryConvertInterval(str + pos, len - pos, time_pos, time, false, nanos)) {
-		return TimestampCastResult::ERROR_INCORRECT_FORMAT;
-	}
-	//	We parsed an interval, so make sure it is in range.
-	if (time.micros > Interval::MICROS_PER_DAY) {
-		return TimestampCastResult::ERROR_RANGE;
-	}
-	pos += time_pos;
-	if (!Timestamp::TryFromDatetime(date, time, result)) {
-		return TimestampCastResult::ERROR_RANGE;
-	}
-	if (pos < len) {
-		// skip a "Z" at the end (as per the ISO8601 specs)
-		int hour_offset, minute_offset;
-		if (str[pos] == 'Z') {
-			pos++;
-			has_offset = true;
-		} else if (Timestamp::TryParseUTCOffset(str, pos, len, hour_offset, minute_offset)) {
-			const int64_t delta = hour_offset * Interval::MICROS_PER_HOUR + minute_offset * Interval::MICROS_PER_MINUTE;
-			if (!TrySubtractOperator::Operation(result.value, delta, result.value)) {
-				return TimestampCastResult::ERROR_RANGE;
-			}
-			has_offset = true;
-		} else {
-			// Parse a time zone: / [A-Za-z0-9/_]+/
-			if (str[pos++] != ' ') {
-				return TimestampCastResult::ERROR_NON_UTC_TIMEZONE;
-			}
-			auto tz_name = str + pos;
-			for (; pos < len && CharacterIsTimeZone(str[pos]); ++pos) {
-				continue;
-			}
-			auto tz_len = str + pos - tz_name;
-			if (tz_len) {
-				tz = string_t(tz_name, UnsafeNumericCast<uint32_t>(tz_len));
-			}
-			// Note that the caller must reinterpret the instant we return to the given time zone
-		}
-
-		// skip any spaces at the end
-		while (pos < len && StringUtil::CharacterIsSpace(str[pos])) {
-			pos++;
-		}
-		if (pos < len) {
-			return TimestampCastResult::ERROR_INCORRECT_FORMAT;
-		}
-	}
-	return TimestampCastResult::SUCCESS;
-}
-
-TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result,
-                                                   optional_ptr<int32_t> nanos) {
-	string_t tz(nullptr, 0);
-	bool has_offset = false;
-	// We don't understand TZ without an extension, so fail if one was provided.
-	auto success = TryConvertTimestampTZ(str, len, result, has_offset, tz, nanos);
-	if (success != TimestampCastResult::SUCCESS) {
-		return success;
-	}
-	if (tz.GetSize() == 0) {
-		// no timezone provided - success!
-		return TimestampCastResult::SUCCESS;
-	}
-	if (tz.GetSize() == 3) {
-		// we can ONLY handle UTC without ICU being loaded
-		auto tz_ptr = tz.GetData();
-		if ((tz_ptr[0] == 'u' || tz_ptr[0] == 'U') && (tz_ptr[1] == 't' || tz_ptr[1] == 'T') &&
-		    (tz_ptr[2] == 'c' || tz_ptr[2] == 'C')) {
-			return TimestampCastResult::SUCCESS;
-		}
-	}
-	return TimestampCastResult::ERROR_NON_UTC_TIMEZONE;
-}
-
-bool Timestamp::TryFromTimestampNanos(timestamp_t input, int32_t nanos, timestamp_ns_t &result) {
-	if (!IsFinite(input)) {
-		result.value = input.value;
-		return true;
-	}
-	// Scale to ns
-	if (!TryMultiplyOperator::Operation(input.value, Interval::NANOS_PER_MICRO, result.value)) {
-		return false;
-	}
-
-	if (!TryAddOperator::Operation(result.value, int64_t(nanos), result.value)) {
-		return false;
-	}
-
-	return IsFinite(result);
-}
-
-TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_ns_t &result) {
-	int32_t nanos = 0;
-	auto success = TryConvertTimestamp(str, len, result, &nanos);
-	if (success != TimestampCastResult::SUCCESS) {
-		return success;
-	}
-	if (!TryFromTimestampNanos(result, nanos, result)) {
-		return TimestampCastResult::ERROR_INCORRECT_FORMAT;
-	}
-	return TimestampCastResult::SUCCESS;
-}
-
-string Timestamp::FormatError(const string &str) {
-	return StringUtil::Format("invalid timestamp field format: \"%s\", "
-	                          "expected format is (YYYY-MM-DD HH:MM:SS[.US][±HH:MM| ZONE])",
-	                          str);
-}
-
-string Timestamp::UnsupportedTimezoneError(const string &str) {
-	return StringUtil::Format("timestamp field value \"%s\" has a timestamp that is not UTC.\nUse the TIMESTAMPTZ type "
-	                          "with the ICU extension loaded to handle non-UTC timestamps.",
-	                          str);
-}
-
-string Timestamp::RangeError(const string &str) {
-	return StringUtil::Format("timestamp field value out of range: \"%s\"", str);
-}
-
-string Timestamp::FormatError(string_t str) {
-	return Timestamp::FormatError(str.GetString());
-}
-
-string Timestamp::UnsupportedTimezoneError(string_t str) {
-	return Timestamp::UnsupportedTimezoneError(str.GetString());
-}
-
-string Timestamp::RangeError(string_t str) {
-	return Timestamp::RangeError(str.GetString());
-}
-
-timestamp_t Timestamp::FromCString(const char *str, idx_t len, optional_ptr<int32_t> nanos) {
-	timestamp_t result;
-	switch (Timestamp::TryConvertTimestamp(str, len, result, nanos)) {
-	case TimestampCastResult::SUCCESS:
-		break;
-	case TimestampCastResult::ERROR_NON_UTC_TIMEZONE:
-		throw ConversionException(UnsupportedTimezoneError(string(str, len)));
-	case TimestampCastResult::ERROR_INCORRECT_FORMAT:
-		throw ConversionException(FormatError(string(str, len)));
-	case TimestampCastResult::ERROR_RANGE:
-		throw ConversionException(RangeError(string(str, len)));
-	}
-	return result;
-}
-
-bool Timestamp::TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset, int &minute_offset) {
-	minute_offset = 0;
-	idx_t curpos = pos;
-	// parse the next 3 characters
-	if (curpos + 3 > len) {
-		// no characters left to parse
-		return false;
-	}
-	char sign_char = str[curpos];
-	if (sign_char != '+' && sign_char != '-') {
-		// expected either + or -
-		return false;
-	}
-	curpos++;
-	if (!StringUtil::CharacterIsDigit(str[curpos]) || !StringUtil::CharacterIsDigit(str[curpos + 1])) {
-		// expected +HH or -HH
-		return false;
-	}
-	hour_offset = (str[curpos] - '0') * 10 + (str[curpos + 1] - '0');
-	if (sign_char == '-') {
-		hour_offset = -hour_offset;
-	}
-	curpos += 2;
-
-	// optional minute specifier: expected either "MM" or ":MM"
-	if (curpos >= len) {
-		// done, nothing left
-		pos = curpos;
-		return true;
-	}
-	if (str[curpos] == ':') {
-		curpos++;
-	}
-	if (curpos + 2 > len || !StringUtil::CharacterIsDigit(str[curpos]) ||
-	    !StringUtil::CharacterIsDigit(str[curpos + 1])) {
-		// no MM specifier
-		pos = curpos;
-		return true;
-	}
-	// we have an MM specifier: parse it
-	minute_offset = (str[curpos] - '0') * 10 + (str[curpos + 1] - '0');
-	if (sign_char == '-') {
-		minute_offset = -minute_offset;
-	}
-	pos = curpos + 2;
-	return true;
-}
-
-timestamp_t Timestamp::FromString(const string &str) {
-	return Timestamp::FromCString(str.c_str(), str.size());
-}
-
-string Timestamp::ToString(timestamp_t timestamp) {
-	if (timestamp == timestamp_t::infinity()) {
-		return Date::PINF;
-	}
-	if (timestamp == timestamp_t::ninfinity()) {
-		return Date::NINF;
-	}
-
-	date_t date;
-	dtime_t time;
-	Timestamp::Convert(timestamp, date, time);
-	return Date::ToString(date) + " " + Time::ToString(time);
-}
-
-date_t Timestamp::GetDate(timestamp_t timestamp) {
-	if (DUCKDB_UNLIKELY(timestamp == timestamp_t::infinity())) {
-		return date_t::infinity();
-	}
-	if (DUCKDB_UNLIKELY(timestamp == timestamp_t::ninfinity())) {
-		return date_t::ninfinity();
-	}
-	return date_t(UnsafeNumericCast<int32_t>((timestamp.value + (timestamp.value < 0)) / Interval::MICROS_PER_DAY -
-	                                         (timestamp.value < 0)));
-}
-
-dtime_t Timestamp::GetTime(timestamp_t timestamp) {
-	if (!IsFinite(timestamp)) {
-		throw ConversionException("Can't get TIME of infinite TIMESTAMP");
-	}
-	date_t date = Timestamp::GetDate(timestamp);
-	return dtime_t(timestamp.value - (int64_t(date.days) * int64_t(Interval::MICROS_PER_DAY)));
-}
-
-bool Timestamp::TryFromDatetime(date_t date, dtime_t time, timestamp_t &result) {
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::MICROS_PER_DAY, result.value)) {
-		return false;
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(result.value, time.micros, result.value)) {
-		return false;
-	}
-	return Timestamp::IsFinite(result);
-}
-
-bool Timestamp::TryFromDatetime(date_t date, dtime_tz_t timetz, timestamp_t &result) {
-	if (!TryFromDatetime(date, timetz.time(), result)) {
-		return false;
-	}
-	// Offset is in seconds
-	const auto offset = int64_t(timetz.offset() * Interval::MICROS_PER_SEC);
-	if (!TryAddOperator::Operation(result.value, -offset, result.value)) {
-		return false;
-	}
-	return Timestamp::IsFinite(result);
-}
-
-timestamp_t Timestamp::FromDatetime(date_t date, dtime_t time) {
-	timestamp_t result;
-	if (!TryFromDatetime(date, time, result)) {
-		throw ConversionException("Date and time not in timestamp range");
-	}
-	return result;
-}
-
-void Timestamp::Convert(timestamp_t timestamp, date_t &out_date, dtime_t &out_time) {
-	out_date = GetDate(timestamp);
-	int64_t days_micros;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(out_date.days, Interval::MICROS_PER_DAY,
-	                                                               days_micros)) {
-		throw ConversionException("Date out of range in timestamp conversion");
-	}
-	out_time = dtime_t(timestamp.value - days_micros);
-	D_ASSERT(timestamp == Timestamp::FromDatetime(out_date, out_time));
-}
-
-void Timestamp::Convert(timestamp_ns_t input, date_t &out_date, dtime_t &out_time, int32_t &out_nanos) {
-	timestamp_t ms(TemporalRound(input.value, Interval::NANOS_PER_MICRO));
-	out_date = Timestamp::GetDate(ms);
-	int64_t days_nanos;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(out_date.days, Interval::NANOS_PER_DAY,
-	                                                               days_nanos)) {
-		throw ConversionException("Date out of range in timestamp_ns conversion");
-	}
-
-	out_time = dtime_t((input.value - days_nanos) / Interval::NANOS_PER_MICRO);
-	out_nanos = UnsafeNumericCast<int32_t>((input.value - days_nanos) % Interval::NANOS_PER_MICRO);
-}
-
-timestamp_t Timestamp::GetCurrentTimestamp() {
-	auto now = system_clock::now();
-	auto epoch_ms = duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
-	return Timestamp::FromEpochMs(epoch_ms);
-}
-
-timestamp_t Timestamp::FromEpochSecondsPossiblyInfinite(int64_t sec) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation(sec, Interval::MICROS_PER_SEC, result)) {
-		throw ConversionException("Could not convert Timestamp(S) to Timestamp(US)");
-	}
-	return timestamp_t(result);
-}
-
-timestamp_t Timestamp::FromEpochSeconds(int64_t sec) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_t(sec)));
-	return FromEpochSecondsPossiblyInfinite(sec);
-}
-
-timestamp_t Timestamp::FromEpochMsPossiblyInfinite(int64_t ms) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation(ms, Interval::MICROS_PER_MSEC, result)) {
-		throw ConversionException("Could not convert Timestamp(MS) to Timestamp(US)");
-	}
-	return timestamp_t(result);
-}
-
-timestamp_t Timestamp::FromEpochMs(int64_t ms) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_t(ms)));
-	return FromEpochMsPossiblyInfinite(ms);
-}
-
-timestamp_t Timestamp::FromEpochMicroSeconds(int64_t micros) {
-	return timestamp_t(micros);
-}
-
-timestamp_t Timestamp::FromEpochNanoSecondsPossiblyInfinite(int64_t ns) {
-	return timestamp_t(ns / Interval::NANOS_PER_MICRO);
-}
-
-timestamp_t Timestamp::FromEpochNanoSeconds(int64_t ns) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_t(ns)));
-	return FromEpochNanoSecondsPossiblyInfinite(ns);
-}
-
-timestamp_ns_t Timestamp::TimestampNsFromEpochMillis(int64_t millis) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_t(millis)));
-	timestamp_ns_t result;
-	if (!TryMultiplyOperator::Operation(millis, Interval::NANOS_PER_MICRO, result.value)) {
-		throw ConversionException("Could not convert Timestamp(US) to Timestamp(NS)");
-	}
-	return result;
-}
-
-timestamp_ns_t Timestamp::TimestampNsFromEpochMicros(int64_t micros) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_t(micros)));
-	timestamp_ns_t result;
-	if (!TryMultiplyOperator::Operation(micros, Interval::NANOS_PER_MSEC, result.value)) {
-		throw ConversionException("Could not convert Timestamp(MS) to Timestamp(NS)");
-	}
-	return result;
-}
-
-int64_t Timestamp::GetEpochSeconds(timestamp_t timestamp) {
-	D_ASSERT(Timestamp::IsFinite(timestamp));
-	return timestamp.value / Interval::MICROS_PER_SEC;
-}
-
-int64_t Timestamp::GetEpochMs(timestamp_t timestamp) {
-	D_ASSERT(Timestamp::IsFinite(timestamp));
-	return timestamp.value / Interval::MICROS_PER_MSEC;
-}
-
-int64_t Timestamp::GetEpochMicroSeconds(timestamp_t timestamp) {
-	return timestamp.value;
-}
-
-bool Timestamp::TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result) {
-	D_ASSERT(Timestamp::IsFinite(timestamp));
-	if (!TryMultiplyOperator::Operation(timestamp.value, Interval::NANOS_PER_MICRO, result)) {
-		return false;
-	}
-	return true;
-}
-
-int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
-	int64_t result;
-	D_ASSERT(Timestamp::IsFinite(timestamp));
-	if (!TryGetEpochNanoSeconds(timestamp, result)) {
-		throw ConversionException("Could not convert Timestamp(US) to Timestamp(NS)");
-	}
-	return result;
-}
-
-int64_t Timestamp::GetEpochNanoSeconds(timestamp_ns_t timestamp) {
-	D_ASSERT(Timestamp::IsFinite(timestamp));
-	return timestamp.value;
-}
-
-int64_t Timestamp::GetEpochRounded(timestamp_t input, int64_t power_of_ten) {
-	D_ASSERT(Timestamp::IsFinite(input));
-	//	Round away from the epoch.
-	//	Scale first so we don't overflow.
-	const auto scaling = power_of_ten / 2;
-	input.value /= scaling;
-	if (input.value < 0) {
-		--input.value;
-	} else {
-		++input.value;
-	}
-	input.value /= 2;
-	return input.value;
-}
-
-double Timestamp::GetJulianDay(timestamp_t timestamp) {
-	double result = double(Timestamp::GetTime(timestamp).micros);
-	result /= Interval::MICROS_PER_DAY;
-	result += double(Date::ExtractJulianDay(Timestamp::GetDate(timestamp)));
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/uhugeint.cpp b/src/duckdb/src/common/types/uhugeint.cpp
deleted file mode 100644
index 7469dd809..000000000
--- a/src/duckdb/src/common/types/uhugeint.cpp
+++ /dev/null
@@ -1,747 +0,0 @@
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-#include <cmath>
-#include <limits>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// String Conversion
-//===--------------------------------------------------------------------===//
-const uhugeint_t Uhugeint::POWERS_OF_TEN[] {
-    uhugeint_t(1),
-    uhugeint_t(10),
-    uhugeint_t(100),
-    uhugeint_t(1000),
-    uhugeint_t(10000),
-    uhugeint_t(100000),
-    uhugeint_t(1000000),
-    uhugeint_t(10000000),
-    uhugeint_t(100000000),
-    uhugeint_t(1000000000),
-    uhugeint_t(10000000000),
-    uhugeint_t(100000000000),
-    uhugeint_t(1000000000000),
-    uhugeint_t(10000000000000),
-    uhugeint_t(100000000000000),
-    uhugeint_t(1000000000000000),
-    uhugeint_t(10000000000000000),
-    uhugeint_t(100000000000000000),
-    uhugeint_t(1000000000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(10),
-    uhugeint_t(1000000000000000000) * uhugeint_t(100),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(10000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(100000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(10000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(100000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(10000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(100000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(10000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(100000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(10000000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(100000000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000000000000000),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000000000000000) * uhugeint_t(10),
-    uhugeint_t(1000000000000000000) * uhugeint_t(1000000000000000000) * uhugeint_t(100)};
-
-string Uhugeint::ToString(uhugeint_t input) {
-	uhugeint_t remainder;
-	string result;
-	while (true) {
-		if (!input.lower && !input.upper) {
-			break;
-		}
-		input = Uhugeint::DivMod(input, 10, remainder);
-		result = string(1, UnsafeNumericCast<char>('0' + remainder.lower)) + result; // NOLINT
-	}
-	if (result.empty()) {
-		// value is zero
-		return "0";
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Negate
-//===--------------------------------------------------------------------===//
-
-template <>
-void Uhugeint::NegateInPlace<false>(uhugeint_t &input) {
-	uhugeint_t result = 0;
-	result -= input;
-	input = result;
-}
-
-bool Uhugeint::TryNegate(uhugeint_t input, uhugeint_t &result) {
-	// unsigned integers can always be negated
-	Uhugeint::NegateInPlace<false>(input);
-	result = input;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Multiply
-//===--------------------------------------------------------------------===//
-bool Uhugeint::TryMultiply(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result) {
-#if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
-	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
-	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
-	__uint128_t result_u128;
-	if (__builtin_mul_overflow(left, right, &result_u128)) {
-		return false;
-	}
-	result.upper = uint64_t(result_u128 >> 64);
-	result.lower = uint64_t(result_u128 & 0xffffffffffffffff);
-#else
-	// split values into 4 32-bit parts
-	uint64_t top[4] = {lhs.upper >> 32, lhs.upper & 0xffffffff, lhs.lower >> 32, lhs.lower & 0xffffffff};
-	uint64_t bottom[4] = {rhs.upper >> 32, rhs.upper & 0xffffffff, rhs.lower >> 32, rhs.lower & 0xffffffff};
-	uint64_t products[4][4];
-
-	// multiply each component of the values
-	for (int y = 3; y > -1; y--) {
-		for (int x = 3; x > -1; x--) {
-			products[3 - x][y] = top[x] * bottom[y];
-		}
-	}
-
-	// if any of these products are set to a non-zero value, there is always an overflow
-	if (products[2][1] || products[1][0] || products[2][0]) {
-		return false;
-	}
-
-	// if the high bits of any of these are set, there is always an overflow
-	if (products[1][1] & 0xffffffff00000000 || products[3][0] & 0xffffffff00000000 ||
-	    products[3][3] & 0xffffffff00000000 || products[3][2] & 0xffffffff00000000 ||
-	    products[3][1] & 0xffffffff00000000 || products[2][2] & 0xffffffff00000000 ||
-	    products[0][0] & 0xffffffff00000000) {
-		return false;
-	}
-
-	// first row
-	uint64_t fourth32 = (products[0][3] & 0xffffffff);
-	uint64_t third32 = (products[0][2] & 0xffffffff) + (products[0][3] >> 32);
-	uint64_t second32 = (products[0][1] & 0xffffffff) + (products[0][2] >> 32);
-	uint64_t first32 = (products[0][0] & 0xffffffff) + (products[0][1] >> 32);
-
-	// second row
-	third32 += (products[1][3] & 0xffffffff);
-	second32 += (products[1][2] & 0xffffffff) + (products[1][3] >> 32);
-	first32 += (products[1][1] & 0xffffffff) + (products[1][2] >> 32);
-
-	// third row
-	second32 += (products[2][3] & 0xffffffff);
-	first32 += (products[2][2] & 0xffffffff) + (products[2][3] >> 32);
-
-	// fourth row
-	first32 += (products[3][3] & 0xffffffff);
-
-	// move carry to next digit
-	third32 += fourth32 >> 32;
-	second32 += third32 >> 32;
-	first32 += second32 >> 32;
-
-	// remove carry from current digit
-	fourth32 &= 0xffffffff;
-	third32 &= 0xffffffff;
-	second32 &= 0xffffffff;
-	first32 &= 0xffffffff;
-
-	// combine components
-	result.lower = (third32 << 32) | fourth32;
-	result.upper = (first32 << 32) | second32;
-#endif
-	return true;
-}
-
-// No overflow check, will wrap
-template <>
-uhugeint_t Uhugeint::Multiply<false>(uhugeint_t lhs, uhugeint_t rhs) {
-	uhugeint_t result;
-#if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
-	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
-	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
-	__uint128_t result_u128;
-
-	result_u128 = left * right;
-	result.upper = uint64_t(result_u128 >> 64);
-	result.lower = uint64_t(result_u128 & 0xffffffffffffffff);
-#else
-	// split values into 4 32-bit parts
-	uint64_t top[4] = {lhs.upper >> 32, lhs.upper & 0xffffffff, lhs.lower >> 32, lhs.lower & 0xffffffff};
-	uint64_t bottom[4] = {rhs.upper >> 32, rhs.upper & 0xffffffff, rhs.lower >> 32, rhs.lower & 0xffffffff};
-	uint64_t products[4][4];
-
-	// multiply each component of the values
-	for (int y = 3; y > -1; y--) {
-		for (int x = 3; x > -1; x--) {
-			products[3 - x][y] = top[x] * bottom[y];
-		}
-	}
-
-	// first row
-	uint64_t fourth32 = (products[0][3] & 0xffffffff);
-	uint64_t third32 = (products[0][2] & 0xffffffff) + (products[0][3] >> 32);
-	uint64_t second32 = (products[0][1] & 0xffffffff) + (products[0][2] >> 32);
-	uint64_t first32 = (products[0][0] & 0xffffffff) + (products[0][1] >> 32);
-
-	// second row
-	third32 += (products[1][3] & 0xffffffff);
-	second32 += (products[1][2] & 0xffffffff) + (products[1][3] >> 32);
-	first32 += (products[1][1] & 0xffffffff) + (products[1][2] >> 32);
-
-	// third row
-	second32 += (products[2][3] & 0xffffffff);
-	first32 += (products[2][2] & 0xffffffff) + (products[2][3] >> 32);
-
-	// fourth row
-	first32 += (products[3][3] & 0xffffffff);
-
-	// move carry to next digit
-	third32 += fourth32 >> 32;
-	second32 += third32 >> 32;
-	first32 += second32 >> 32;
-
-	// remove carry from current digit
-	fourth32 &= 0xffffffff;
-	third32 &= 0xffffffff;
-	second32 &= 0xffffffff;
-	first32 &= 0xffffffff;
-
-	// combine components
-	result.lower = (third32 << 32) | fourth32;
-	result.upper = (first32 << 32) | second32;
-#endif
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Divide
-//===--------------------------------------------------------------------===//
-
-int Sign(uhugeint_t n) {
-	return (n > 0);
-}
-
-uhugeint_t Abs(uhugeint_t n) {
-	return (n);
-}
-
-static uint8_t Bits(uhugeint_t x) {
-	uint8_t out = 0;
-	if (x.upper) {
-		out = 64;
-		for (uint64_t upper = x.upper; upper; upper >>= 1) {
-			++out;
-		}
-	} else {
-		for (uint64_t lower = x.lower; lower; lower >>= 1) {
-			++out;
-		}
-	}
-	return out;
-}
-
-uhugeint_t Uhugeint::DivMod(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &remainder) {
-	if (rhs == 0) {
-		remainder = lhs;
-		return uhugeint_t(0);
-	}
-
-	remainder = uhugeint_t(0);
-	if (rhs == uhugeint_t(1)) {
-		return lhs;
-	} else if (lhs == rhs) {
-		return uhugeint_t(1);
-	} else if (lhs == uhugeint_t(0) || lhs < rhs) {
-		remainder = lhs;
-		return uhugeint_t(0);
-	}
-
-	uhugeint_t result = 0;
-	for (uint8_t idx = Bits(lhs); idx > 0; --idx) {
-		result <<= 1;
-		remainder <<= 1;
-
-		if (((lhs >> (idx - 1U)) & 1) != 0) {
-			remainder += 1;
-		}
-
-		if (remainder >= rhs) {
-			remainder -= rhs;
-			result += 1;
-		}
-	}
-	return result;
-}
-
-template <>
-uhugeint_t Uhugeint::Divide<false>(uhugeint_t lhs, uhugeint_t rhs) {
-	uhugeint_t remainder;
-	return Uhugeint::DivMod(lhs, rhs, remainder);
-}
-
-template <>
-uhugeint_t Uhugeint::Modulo<false>(uhugeint_t lhs, uhugeint_t rhs) {
-	uhugeint_t remainder;
-	(void)Uhugeint::DivMod(lhs, rhs, remainder);
-	return remainder;
-}
-
-//===--------------------------------------------------------------------===//
-// Add/Subtract
-//===--------------------------------------------------------------------===//
-bool Uhugeint::TryAddInPlace(uhugeint_t &lhs, uhugeint_t rhs) {
-	uint64_t new_upper = lhs.upper + rhs.upper;
-	bool no_overflow = !(new_upper < lhs.upper || new_upper < rhs.upper);
-	new_upper += (lhs.lower + rhs.lower) < lhs.lower;
-	if (new_upper < lhs.upper || new_upper < rhs.upper) {
-		no_overflow = false;
-	}
-	lhs.upper = new_upper;
-	lhs.lower += rhs.lower;
-	return no_overflow;
-}
-
-bool Uhugeint::TrySubtractInPlace(uhugeint_t &lhs, uhugeint_t rhs) {
-	uint64_t new_upper = lhs.upper - rhs.upper - ((lhs.lower - rhs.lower) > lhs.lower);
-	bool no_overflow = !(new_upper > lhs.upper);
-	lhs.lower -= rhs.lower;
-	lhs.upper = new_upper;
-	return no_overflow;
-}
-
-template <>
-uhugeint_t Uhugeint::Add<false>(uhugeint_t lhs, uhugeint_t rhs) {
-	return lhs + rhs;
-}
-
-template <>
-uhugeint_t Uhugeint::Subtract<false>(uhugeint_t lhs, uhugeint_t rhs) {
-	return lhs - rhs;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast/Conversion
-//===--------------------------------------------------------------------===//
-template <class DST>
-bool UhugeintTryCastInteger(uhugeint_t input, DST &result) {
-	if (input.upper == 0 && input.lower <= uint64_t(NumericLimits<DST>::Maximum())) {
-		result = DST(input.lower);
-		return true;
-	}
-	return false;
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, int8_t &result) {
-	return UhugeintTryCastInteger<int8_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, int16_t &result) {
-	return UhugeintTryCastInteger<int16_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, int32_t &result) {
-	return UhugeintTryCastInteger<int32_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, int64_t &result) {
-	return UhugeintTryCastInteger<int64_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, uint8_t &result) {
-	return UhugeintTryCastInteger<uint8_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, uint16_t &result) {
-	return UhugeintTryCastInteger<uint16_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, uint32_t &result) {
-	return UhugeintTryCastInteger<uint32_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, uint64_t &result) {
-	return UhugeintTryCastInteger<uint64_t>(input, result);
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, uhugeint_t &result) {
-	result = input;
-	return true;
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, hugeint_t &result) {
-	if (input > uhugeint_t(NumericLimits<hugeint_t>::Maximum())) {
-		return false;
-	}
-
-	result.lower = input.lower;
-	result.upper = UnsafeNumericCast<int64_t>(input.upper);
-	return true;
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, float &result) {
-	double dbl_result;
-	Uhugeint::TryCast(input, dbl_result);
-	result = (float)dbl_result;
-	return true;
-}
-
-template <class REAL_T>
-bool CastUhugeintToFloating(uhugeint_t input, REAL_T &result) {
-	result = REAL_T(input.lower) + REAL_T(input.upper) * REAL_T(NumericLimits<uint64_t>::Maximum());
-	return true;
-}
-
-template <>
-bool Uhugeint::TryCast(uhugeint_t input, double &result) {
-	return CastUhugeintToFloating<double>(input, result);
-}
-
-template <class DST>
-uhugeint_t UhugeintConvertInteger(DST input) {
-	uhugeint_t result;
-	result.lower = (uint64_t)input;
-	result.upper = 0;
-	return result;
-}
-
-template <>
-bool Uhugeint::TryConvert(const char *value, uhugeint_t &result) {
-	auto len = strlen(value);
-	string_t string_val(value, UnsafeNumericCast<uint32_t>(len));
-	return TryCast::Operation<string_t, uhugeint_t>(string_val, result, true);
-}
-
-template <>
-bool Uhugeint::TryConvert(int8_t value, uhugeint_t &result) {
-	if (value < 0) {
-		return false;
-	}
-	result = UhugeintConvertInteger<int8_t>(value);
-	return true;
-}
-
-template <>
-bool Uhugeint::TryConvert(int16_t value, uhugeint_t &result) {
-	if (value < 0) {
-		return false;
-	}
-	result = UhugeintConvertInteger<int16_t>(value);
-	return true;
-}
-
-template <>
-bool Uhugeint::TryConvert(int32_t value, uhugeint_t &result) {
-	if (value < 0) {
-		return false;
-	}
-	result = UhugeintConvertInteger<int32_t>(value);
-	return true;
-}
-
-template <>
-bool Uhugeint::TryConvert(int64_t value, uhugeint_t &result) {
-	if (value < 0) {
-		return false;
-	}
-	result = UhugeintConvertInteger<int64_t>(value);
-	return true;
-}
-template <>
-bool Uhugeint::TryConvert(uint8_t value, uhugeint_t &result) {
-	result = UhugeintConvertInteger<uint8_t>(value);
-	return true;
-}
-template <>
-bool Uhugeint::TryConvert(uint16_t value, uhugeint_t &result) {
-	result = UhugeintConvertInteger<uint16_t>(value);
-	return true;
-}
-template <>
-bool Uhugeint::TryConvert(uint32_t value, uhugeint_t &result) {
-	result = UhugeintConvertInteger<uint32_t>(value);
-	return true;
-}
-template <>
-bool Uhugeint::TryConvert(uint64_t value, uhugeint_t &result) {
-	result = UhugeintConvertInteger<uint64_t>(value);
-	return true;
-}
-
-template <>
-bool Uhugeint::TryConvert(uhugeint_t value, uhugeint_t &result) {
-	result = value;
-	return true;
-}
-
-template <>
-bool Uhugeint::TryConvert(float value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(double(value), result);
-}
-
-template <class REAL_T>
-bool ConvertFloatingToUhugeint(REAL_T value, uhugeint_t &result) {
-	if (!Value::IsFinite<REAL_T>(value)) {
-		return false;
-	}
-	if (value < 0 || value >= 340282366920938463463374607431768211456.0) {
-		return false;
-	}
-	result.lower = (uint64_t)fmod(value, REAL_T(NumericLimits<uint64_t>::Maximum()));
-	result.upper = (uint64_t)(value / REAL_T(NumericLimits<uint64_t>::Maximum()));
-	return true;
-}
-
-template <>
-bool Uhugeint::TryConvert(double value, uhugeint_t &result) {
-	return ConvertFloatingToUhugeint<double>(value, result);
-}
-
-template <>
-bool Uhugeint::TryConvert(long double value, uhugeint_t &result) {
-	return ConvertFloatingToUhugeint<long double>(value, result);
-}
-
-//===--------------------------------------------------------------------===//
-// uhugeint_t operators
-//===--------------------------------------------------------------------===//
-uhugeint_t::uhugeint_t(uint64_t value) {
-	this->lower = value;
-	this->upper = 0;
-}
-
-bool uhugeint_t::operator==(const uhugeint_t &rhs) const {
-	return Uhugeint::Equals(*this, rhs);
-}
-
-bool uhugeint_t::operator!=(const uhugeint_t &rhs) const {
-	return Uhugeint::NotEquals(*this, rhs);
-}
-
-bool uhugeint_t::operator<(const uhugeint_t &rhs) const {
-	return Uhugeint::LessThan(*this, rhs);
-}
-
-bool uhugeint_t::operator<=(const uhugeint_t &rhs) const {
-	return Uhugeint::LessThanEquals(*this, rhs);
-}
-
-bool uhugeint_t::operator>(const uhugeint_t &rhs) const {
-	return Uhugeint::GreaterThan(*this, rhs);
-}
-
-bool uhugeint_t::operator>=(const uhugeint_t &rhs) const {
-	return Uhugeint::GreaterThanEquals(*this, rhs);
-}
-
-uhugeint_t uhugeint_t::operator+(const uhugeint_t &rhs) const {
-	return uhugeint_t(upper + rhs.upper + ((lower + rhs.lower) < lower), lower + rhs.lower);
-}
-
-uhugeint_t uhugeint_t::operator-(const uhugeint_t &rhs) const {
-	return uhugeint_t(upper - rhs.upper - ((lower - rhs.lower) > lower), lower - rhs.lower);
-}
-
-uhugeint_t uhugeint_t::operator*(const uhugeint_t &rhs) const {
-	uhugeint_t result = *this;
-	result *= rhs;
-	return result;
-}
-
-uhugeint_t uhugeint_t::operator/(const uhugeint_t &rhs) const {
-	return Uhugeint::Divide<false>(*this, rhs);
-}
-
-uhugeint_t uhugeint_t::operator%(const uhugeint_t &rhs) const {
-	return Uhugeint::Modulo<false>(*this, rhs);
-}
-
-uhugeint_t uhugeint_t::operator-() const {
-	return Uhugeint::Negate<false>(*this);
-}
-
-uhugeint_t uhugeint_t::operator>>(const uhugeint_t &rhs) const {
-	const uint64_t shift = rhs.lower;
-	if (rhs.upper != 0 || shift >= 128) {
-		return uhugeint_t(0);
-	} else if (shift == 0) {
-		return *this;
-	} else if (shift == 64) {
-		return uhugeint_t(0, upper);
-	} else if (shift < 64) {
-		return uhugeint_t(upper >> shift, (upper << (64 - shift)) + (lower >> shift));
-	} else if ((128 > shift) && (shift > 64)) {
-		return uhugeint_t(0, (upper >> (shift - 64)));
-	}
-	return uhugeint_t(0);
-}
-
-uhugeint_t uhugeint_t::operator<<(const uhugeint_t &rhs) const {
-	const uint64_t shift = rhs.lower;
-	if (rhs.upper != 0 || shift >= 128) {
-		return uhugeint_t(0);
-	} else if (shift == 0) {
-		return *this;
-	} else if (shift == 64) {
-		return uhugeint_t(lower, 0);
-	} else if (shift < 64) {
-		return uhugeint_t((upper << shift) + (lower >> (64 - shift)), lower << shift);
-	} else if ((128 > shift) && (shift > 64)) {
-		return uhugeint_t(lower << (shift - 64), 0);
-	}
-	return uhugeint_t(0);
-}
-
-uhugeint_t uhugeint_t::operator&(const uhugeint_t &rhs) const {
-	uhugeint_t result;
-	result.lower = lower & rhs.lower;
-	result.upper = upper & rhs.upper;
-	return result;
-}
-
-uhugeint_t uhugeint_t::operator|(const uhugeint_t &rhs) const {
-	uhugeint_t result;
-	result.lower = lower | rhs.lower;
-	result.upper = upper | rhs.upper;
-	return result;
-}
-
-uhugeint_t uhugeint_t::operator^(const uhugeint_t &rhs) const {
-	uhugeint_t result;
-	result.lower = lower ^ rhs.lower;
-	result.upper = upper ^ rhs.upper;
-	return result;
-}
-
-uhugeint_t uhugeint_t::operator~() const {
-	uhugeint_t result;
-	result.lower = ~lower;
-	result.upper = ~upper;
-	return result;
-}
-
-uhugeint_t &uhugeint_t::operator+=(const uhugeint_t &rhs) {
-	*this = *this + rhs;
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator-=(const uhugeint_t &rhs) {
-	*this = *this - rhs;
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator*=(const uhugeint_t &rhs) {
-	*this = Uhugeint::Multiply<false>(*this, rhs);
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator/=(const uhugeint_t &rhs) {
-	*this = Uhugeint::Divide<false>(*this, rhs);
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator%=(const uhugeint_t &rhs) {
-	*this = Uhugeint::Modulo<false>(*this, rhs);
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator>>=(const uhugeint_t &rhs) {
-	*this = *this >> rhs;
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator<<=(const uhugeint_t &rhs) {
-	*this = *this << rhs;
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator&=(const uhugeint_t &rhs) {
-	lower &= rhs.lower;
-	upper &= rhs.upper;
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator|=(const uhugeint_t &rhs) {
-	lower |= rhs.lower;
-	upper |= rhs.upper;
-	return *this;
-}
-
-uhugeint_t &uhugeint_t::operator^=(const uhugeint_t &rhs) {
-	lower ^= rhs.lower;
-	upper ^= rhs.upper;
-	return *this;
-}
-
-bool uhugeint_t::operator!() const {
-	return *this == 0;
-}
-
-uhugeint_t::operator bool() const {
-	return *this != 0;
-}
-
-template <class T>
-static T NarrowCast(const uhugeint_t &input) {
-	// NarrowCast is supposed to truncate (take lower)
-	return static_cast<T>(input.lower);
-}
-
-uhugeint_t::operator uint8_t() const {
-	return NarrowCast<uint8_t>(*this);
-}
-uhugeint_t::operator uint16_t() const {
-	return NarrowCast<uint16_t>(*this);
-}
-uhugeint_t::operator uint32_t() const {
-	return NarrowCast<uint32_t>(*this);
-}
-uhugeint_t::operator uint64_t() const {
-	return NarrowCast<uint64_t>(*this);
-}
-uhugeint_t::operator int8_t() const {
-	return NarrowCast<int8_t>(*this);
-}
-uhugeint_t::operator int16_t() const {
-	return NarrowCast<int16_t>(*this);
-}
-uhugeint_t::operator int32_t() const {
-	return NarrowCast<int32_t>(*this);
-}
-uhugeint_t::operator int64_t() const {
-	return NarrowCast<int64_t>(*this);
-}
-uhugeint_t::operator hugeint_t() const {
-	return {static_cast<int64_t>(this->upper), this->lower};
-}
-
-string uhugeint_t::ToString() const {
-	return Uhugeint::ToString(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/uuid.cpp b/src/duckdb/src/common/types/uuid.cpp
deleted file mode 100644
index a0196ae81..000000000
--- a/src/duckdb/src/common/types/uuid.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/common/random_engine.hpp"
-
-namespace duckdb {
-
-bool UUID::FromString(const string &str, hugeint_t &result) {
-	auto hex2char = [](char ch) -> unsigned char {
-		if (ch >= '0' && ch <= '9') {
-			return UnsafeNumericCast<unsigned char>(ch - '0');
-		}
-		if (ch >= 'a' && ch <= 'f') {
-			return UnsafeNumericCast<unsigned char>(10 + ch - 'a');
-		}
-		if (ch >= 'A' && ch <= 'F') {
-			return UnsafeNumericCast<unsigned char>(10 + ch - 'A');
-		}
-		return 0;
-	};
-	auto is_hex = [](char ch) -> bool {
-		return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
-	};
-
-	if (str.empty()) {
-		return false;
-	}
-	idx_t has_braces = 0;
-	if (str.front() == '{') {
-		has_braces = 1;
-	}
-	if (has_braces && str.back() != '}') {
-		return false;
-	}
-
-	result.lower = 0;
-	result.upper = 0;
-	size_t count = 0;
-	for (size_t i = has_braces; i < str.size() - has_braces; ++i) {
-		if (str[i] == '-') {
-			continue;
-		}
-		if (count >= 32 || !is_hex(str[i])) {
-			return false;
-		}
-		if (count >= 16) {
-			result.lower = (result.lower << 4) | hex2char(str[i]);
-		} else {
-			result.upper = (result.upper << 4) | hex2char(str[i]);
-		}
-		count++;
-	}
-	// Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
-	result.upper ^= NumericLimits<int64_t>::Minimum();
-	return count == 32;
-}
-
-void UUID::ToString(hugeint_t input, char *buf) {
-	auto byte_to_hex = [](uint64_t byte_val, char *buf, idx_t &pos) {
-		D_ASSERT(byte_val <= 0xFF);
-		static char const HEX_DIGITS[] = "0123456789abcdef";
-		buf[pos++] = HEX_DIGITS[(byte_val >> 4) & 0xf];
-		buf[pos++] = HEX_DIGITS[byte_val & 0xf];
-	};
-
-	// Flip back before convert to string
-	int64_t upper = int64_t(uint64_t(input.upper) ^ (uint64_t(1) << 63));
-	idx_t pos = 0;
-	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 48 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 40 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 32 & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(upper >> 24 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 16 & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(upper >> 8 & 0xFF, buf, pos);
-	byte_to_hex(upper & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(input.lower >> 56 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 48 & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(input.lower >> 40 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 32 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 24 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 16 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 8 & 0xFF, buf, pos);
-	byte_to_hex(input.lower & 0xFF, buf, pos);
-}
-
-hugeint_t UUID::FromUHugeint(uhugeint_t input) {
-	hugeint_t result;
-	result.lower = input.lower;
-	if (input.upper > uint64_t(NumericLimits<int64_t>::Maximum())) {
-		result.upper = int64_t(input.upper - uint64_t(NumericLimits<int64_t>::Maximum()) - 1);
-	} else {
-		result.upper = int64_t(input.upper) - NumericLimits<int64_t>::Maximum() - 1;
-	}
-	return result;
-}
-
-uhugeint_t UUID::ToUHugeint(hugeint_t input) {
-	uhugeint_t result;
-	result.lower = input.lower;
-	if (input.upper >= 0) {
-		result.upper = uint64_t(input.upper) + uint64_t(NumericLimits<int64_t>::Maximum()) + 1;
-	} else {
-		result.upper = uint64_t(input.upper + NumericLimits<int64_t>::Maximum() + 1);
-	}
-	return result;
-}
-
-hugeint_t UUID::GenerateRandomUUID(RandomEngine &engine) {
-	uint8_t bytes[16];
-	for (int i = 0; i < 16; i += 4) {
-		*reinterpret_cast<uint32_t *>(bytes + i) = engine.NextRandomInteger();
-	}
-	// variant must be 10xxxxxx
-	bytes[8] &= 0xBF;
-	bytes[8] |= 0x80;
-	// version must be 0100xxxx
-	bytes[6] &= 0x4F;
-	bytes[6] |= 0x40;
-
-	hugeint_t result;
-	result.upper = 0;
-	result.upper |= ((int64_t)bytes[0] << 56);
-	result.upper |= ((int64_t)bytes[1] << 48);
-	result.upper |= ((int64_t)bytes[2] << 40);
-	result.upper |= ((int64_t)bytes[3] << 32);
-	result.upper |= ((int64_t)bytes[4] << 24);
-	result.upper |= ((int64_t)bytes[5] << 16);
-	result.upper |= ((int64_t)bytes[6] << 8);
-	result.upper |= bytes[7];
-	result.lower = 0;
-	result.lower |= ((uint64_t)bytes[8] << 56);
-	result.lower |= ((uint64_t)bytes[9] << 48);
-	result.lower |= ((uint64_t)bytes[10] << 40);
-	result.lower |= ((uint64_t)bytes[11] << 32);
-	result.lower |= ((uint64_t)bytes[12] << 24);
-	result.lower |= ((uint64_t)bytes[13] << 16);
-	result.lower |= ((uint64_t)bytes[14] << 8);
-	result.lower |= bytes[15];
-	return result;
-}
-
-hugeint_t UUID::GenerateRandomUUID() {
-	RandomEngine engine;
-	return GenerateRandomUUID(engine);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/validity_mask.cpp b/src/duckdb/src/common/types/validity_mask.cpp
deleted file mode 100644
index c4a526b59..000000000
--- a/src/duckdb/src/common/types/validity_mask.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-#include "duckdb/common/types/selection_vector.hpp"
-
-namespace duckdb {
-
-ValidityData::ValidityData(idx_t count) : TemplatedValidityData(count) {
-}
-ValidityData::ValidityData(const ValidityMask &original, idx_t count)
-    : TemplatedValidityData(original.GetData(), count) {
-}
-
-void ValidityMask::Combine(const ValidityMask &other, idx_t count) {
-	if (other.AllValid()) {
-		// X & 1 = X
-		return;
-	}
-	if (AllValid()) {
-		// 1 & Y = Y
-		Initialize(other);
-		return;
-	}
-	if (validity_mask == other.validity_mask) {
-		// X & X == X
-		return;
-	}
-	// have to merge
-	// create a new validity mask that contains the combined mask
-	auto owned_data = std::move(validity_data);
-	auto data = GetData();
-	auto other_data = other.GetData();
-
-	Initialize(count);
-	auto result_data = GetData();
-
-	auto entry_count = ValidityData::EntryCount(count);
-	for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-		result_data[entry_idx] = data[entry_idx] & other_data[entry_idx];
-	}
-}
-
-// LCOV_EXCL_START
-string ValidityMask::ToString(idx_t count) const {
-	string result = "Validity Mask (" + to_string(count) + ") [";
-	for (idx_t i = 0; i < count; i++) {
-		result += RowIsValid(i) ? "." : "X";
-	}
-	result += "]";
-	return result;
-}
-
-string ValidityMask::ToString() const {
-	return ValidityMask::ToString(capacity);
-}
-// LCOV_EXCL_STOP
-
-void ValidityMask::Resize(idx_t new_size) {
-	idx_t old_size = capacity;
-	if (new_size <= old_size) {
-		return;
-	}
-	capacity = new_size;
-	if (validity_mask) {
-		auto new_size_count = EntryCount(new_size);
-		auto old_size_count = EntryCount(old_size);
-		auto new_validity_data = make_buffer<ValidityBuffer>(new_size);
-		auto new_owned_data = new_validity_data->owned_data.get();
-		for (idx_t entry_idx = 0; entry_idx < old_size_count; entry_idx++) {
-			new_owned_data[entry_idx] = validity_mask[entry_idx];
-		}
-		for (idx_t entry_idx = old_size_count; entry_idx < new_size_count; entry_idx++) {
-			new_owned_data[entry_idx] = ValidityData::MAX_ENTRY;
-		}
-		validity_data = std::move(new_validity_data);
-		validity_mask = validity_data->owned_data.get();
-	}
-}
-
-idx_t ValidityMask::Capacity() const {
-	return capacity;
-}
-
-void ValidityMask::Slice(const ValidityMask &other, idx_t source_offset, idx_t count) {
-	if (other.AllValid()) {
-		validity_mask = nullptr;
-		validity_data.reset();
-		return;
-	}
-	if (source_offset == 0) {
-		Initialize(other);
-		return;
-	}
-	ValidityMask new_mask(count);
-	new_mask.SliceInPlace(other, 0, source_offset, count);
-	Initialize(new_mask);
-}
-
-bool ValidityMask::IsAligned(idx_t count) {
-	return count % BITS_PER_VALUE == 0;
-}
-
-void ValidityMask::CopySel(const ValidityMask &other, const SelectionVector &sel, idx_t source_offset,
-                           idx_t target_offset, idx_t copy_count) {
-	if (!other.IsMaskSet() && !IsMaskSet()) {
-		// no need to copy anything if neither has any null values
-		return;
-	}
-
-	if (!sel.IsSet() && IsAligned(source_offset) && IsAligned(target_offset)) {
-		// common case where we are shifting into an aligned mask using a flat vector
-		SliceInPlace(other, target_offset, source_offset, copy_count);
-		return;
-	}
-	for (idx_t i = 0; i < copy_count; i++) {
-		auto source_idx = sel.get_index(source_offset + i);
-		Set(target_offset + i, other.RowIsValid(source_idx));
-	}
-}
-
-void ValidityMask::SliceInPlace(const ValidityMask &other, idx_t target_offset, idx_t source_offset, idx_t count) {
-	if (AllValid() && other.AllValid()) {
-		// Both validity masks are uninitialized, nothing to do
-		return;
-	}
-	EnsureWritable();
-	const idx_t ragged = count % BITS_PER_VALUE;
-	const idx_t entire_units = count / BITS_PER_VALUE;
-	if (IsAligned(source_offset) && IsAligned(target_offset)) {
-		auto target_validity = GetData();
-		auto source_validity = other.GetData();
-		auto source_offset_entries = EntryCount(source_offset);
-		auto target_offset_entries = EntryCount(target_offset);
-		if (!source_validity) {
-			// if source has no validity mask - set all bytes to 1
-			memset(target_validity + target_offset_entries, 0xFF, sizeof(validity_t) * entire_units);
-		} else {
-			memcpy(target_validity + target_offset_entries, source_validity + source_offset_entries,
-			       sizeof(validity_t) * entire_units);
-		}
-		if (ragged) {
-			auto src_entry =
-			    source_validity ? source_validity[source_offset_entries + entire_units] : ValidityBuffer::MAX_ENTRY;
-			src_entry &= (ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - ragged));
-
-			target_validity += target_offset_entries + entire_units;
-			auto tgt_entry = *target_validity;
-			tgt_entry &= (ValidityBuffer::MAX_ENTRY << ragged);
-
-			*target_validity = tgt_entry | src_entry;
-		}
-		return;
-	} else if (IsAligned(target_offset)) {
-		//	Simple common case where we are shifting into an aligned mask (e.g., 0 in Slice above)
-		const idx_t tail = source_offset % BITS_PER_VALUE;
-		const idx_t head = BITS_PER_VALUE - tail;
-		auto source_validity = other.GetData() + (source_offset / BITS_PER_VALUE);
-		auto target_validity = this->GetData() + (target_offset / BITS_PER_VALUE);
-		auto src_entry = *source_validity++;
-		for (idx_t i = 0; i < entire_units; ++i) {
-			//	Start with head of previous src
-			validity_t tgt_entry = src_entry >> tail;
-			src_entry = *source_validity++;
-			// 	Add in tail of current src
-			tgt_entry |= (src_entry << head);
-			*target_validity++ = tgt_entry;
-		}
-		//	Finish last ragged entry
-		if (ragged) {
-			//	Start with head of previous src
-			validity_t tgt_entry = (src_entry >> tail);
-			//  Add in the tail of the next src, if head was too small
-			if (head < ragged) {
-				src_entry = *source_validity++;
-				tgt_entry |= (src_entry << head);
-			}
-			//  Mask off the bits that go past the ragged end
-			tgt_entry &= (ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - ragged));
-			//	Restore the ragged end of the target
-			tgt_entry |= *target_validity & (ValidityBuffer::MAX_ENTRY << ragged);
-			*target_validity++ = tgt_entry;
-		}
-		return;
-	}
-
-	// FIXME: use bitwise operations here
-#if 1
-	for (idx_t i = 0; i < count; i++) {
-		Set(target_offset + i, other.RowIsValid(source_offset + i));
-	}
-#else
-	// first shift the "whole" units
-	idx_t entire_units = offset / BITS_PER_VALUE;
-	idx_t sub_units = offset - entire_units * BITS_PER_VALUE;
-	if (entire_units > 0) {
-		idx_t validity_idx;
-		for (validity_idx = 0; validity_idx + entire_units < STANDARD_ENTRY_COUNT; validity_idx++) {
-			new_mask.validity_mask[validity_idx] = other.validity_mask[validity_idx + entire_units];
-		}
-	}
-	// now we shift the remaining sub units
-	// this gets a bit more complicated because we have to shift over the borders of the entries
-	// e.g. suppose we have 2 entries of length 4 and we left-shift by two
-	// 0101|1010
-	// a regular left-shift of both gets us:
-	// 0100|1000
-	// we then OR the overflow (right-shifted by BITS_PER_VALUE - offset) together to get the correct result
-	// 0100|1000 ->
-	// 0110|1000
-	if (sub_units > 0) {
-		idx_t validity_idx;
-		for (validity_idx = 0; validity_idx + 1 < STANDARD_ENTRY_COUNT; validity_idx++) {
-			new_mask.validity_mask[validity_idx] =
-			    (other.validity_mask[validity_idx] >> sub_units) |
-			    (other.validity_mask[validity_idx + 1] << (BITS_PER_VALUE - sub_units));
-		}
-		new_mask.validity_mask[validity_idx] >>= sub_units;
-	}
-#ifdef DEBUG
-	for (idx_t i = offset; i < STANDARD_VECTOR_SIZE; i++) {
-		D_ASSERT(new_mask.RowIsValid(i - offset) == other.RowIsValid(i));
-	}
-	Initialize(new_mask);
-#endif
-#endif
-}
-
-enum class ValiditySerialization : uint8_t { BITMASK = 0, VALID_VALUES = 1, INVALID_VALUES = 2 };
-
-void ValidityMask::Write(WriteStream &writer, idx_t count) {
-	auto valid_values = CountValid(count);
-	auto invalid_values = count - valid_values;
-	auto bitmask_bytes = ValidityMask::ValidityMaskSize(count);
-	auto need_u32 = count >= NumericLimits<uint16_t>::Maximum();
-	auto bytes_per_value = need_u32 ? sizeof(uint32_t) : sizeof(uint16_t);
-	auto valid_value_size = bytes_per_value * valid_values + sizeof(uint32_t);
-	auto invalid_value_size = bytes_per_value * invalid_values + sizeof(uint32_t);
-	if (valid_value_size < bitmask_bytes || invalid_value_size < bitmask_bytes) {
-		auto serialize_valid = valid_value_size < invalid_value_size;
-		// serialize (in)valid value indexes as [COUNT][V0][V1][...][VN]
-		auto flag = serialize_valid ? ValiditySerialization::VALID_VALUES : ValiditySerialization::INVALID_VALUES;
-		writer.Write(flag);
-		writer.Write<uint32_t>(NumericCast<uint32_t>(MinValue(valid_values, invalid_values)));
-		for (idx_t i = 0; i < count; i++) {
-			if (RowIsValid(i) == serialize_valid) {
-				if (need_u32) {
-					writer.Write<uint32_t>(UnsafeNumericCast<uint32_t>(i));
-				} else {
-					writer.Write<uint16_t>(UnsafeNumericCast<uint16_t>(i));
-				}
-			}
-		}
-	} else {
-		// serialize the entire bitmask
-		writer.Write(ValiditySerialization::BITMASK);
-		writer.WriteData(const_data_ptr_cast(GetData()), bitmask_bytes);
-	}
-}
-
-void ValidityMask::Read(ReadStream &reader, idx_t count) {
-	Initialize(count);
-	// deserialize the storage type
-	auto flag = reader.Read<ValiditySerialization>();
-	if (flag == ValiditySerialization::BITMASK) {
-		// deserialize the bitmask
-		reader.ReadData(data_ptr_cast(GetData()), ValidityMask::ValidityMaskSize(count));
-		return;
-	}
-	auto is_u32 = count >= NumericLimits<uint16_t>::Maximum();
-	auto is_valid = flag == ValiditySerialization::VALID_VALUES;
-	auto serialize_count = reader.Read<uint32_t>();
-	if (is_valid) {
-		SetAllInvalid(count);
-	}
-	for (idx_t i = 0; i < serialize_count; i++) {
-		idx_t index = is_u32 ? reader.Read<uint32_t>() : reader.Read<uint16_t>();
-		Set(index, is_valid);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/value.cpp b/src/duckdb/src/common/types/value.cpp
deleted file mode 100644
index 4e8566c9a..000000000
--- a/src/duckdb/src/common/types/value.cpp
+++ /dev/null
@@ -1,2257 +0,0 @@
-#include "duckdb/common/types/value.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-#include "duckdb/common/uhugeint.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/common/operator/numeric_binary_operators.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/types/blob.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/common/types/varint.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-#include <utility>
-#include <cmath>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Extra Value Info
-//===--------------------------------------------------------------------===//
-enum class ExtraValueInfoType : uint8_t { INVALID_TYPE_INFO = 0, STRING_VALUE_INFO = 1, NESTED_VALUE_INFO = 2 };
-
-struct ExtraValueInfo {
-	explicit ExtraValueInfo(ExtraValueInfoType type) : type(type) {
-	}
-	virtual ~ExtraValueInfo() {
-	}
-
-	ExtraValueInfoType type;
-
-public:
-	bool Equals(ExtraValueInfo *other_p) const {
-		if (!other_p) {
-			return false;
-		}
-		if (type != other_p->type) {
-			return false;
-		}
-		return EqualsInternal(other_p);
-	}
-
-	template <class T>
-	T &Get() {
-		if (type != T::TYPE) {
-			throw InternalException("ExtraValueInfo type mismatch");
-		}
-		return (T &)*this;
-	}
-
-protected:
-	virtual bool EqualsInternal(ExtraValueInfo *other_p) const {
-		return true;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// String Value Info
-//===--------------------------------------------------------------------===//
-struct StringValueInfo : public ExtraValueInfo {
-	static constexpr const ExtraValueInfoType TYPE = ExtraValueInfoType::STRING_VALUE_INFO;
-
-public:
-	explicit StringValueInfo(string str_p)
-	    : ExtraValueInfo(ExtraValueInfoType::STRING_VALUE_INFO), str(std::move(str_p)) {
-	}
-
-	const string &GetString() {
-		return str;
-	}
-
-protected:
-	bool EqualsInternal(ExtraValueInfo *other_p) const override {
-		return other_p->Get<StringValueInfo>().str == str;
-	}
-
-	string str;
-};
-
-//===--------------------------------------------------------------------===//
-// Nested Value Info
-//===--------------------------------------------------------------------===//
-struct NestedValueInfo : public ExtraValueInfo {
-	static constexpr const ExtraValueInfoType TYPE = ExtraValueInfoType::NESTED_VALUE_INFO;
-
-public:
-	NestedValueInfo() : ExtraValueInfo(ExtraValueInfoType::NESTED_VALUE_INFO) {
-	}
-	explicit NestedValueInfo(vector<Value> values_p)
-	    : ExtraValueInfo(ExtraValueInfoType::NESTED_VALUE_INFO), values(std::move(values_p)) {
-	}
-
-	const vector<Value> &GetValues() {
-		return values;
-	}
-
-protected:
-	bool EqualsInternal(ExtraValueInfo *other_p) const override {
-		return other_p->Get<NestedValueInfo>().values == values;
-	}
-
-	vector<Value> values;
-};
-//===--------------------------------------------------------------------===//
-// Value
-//===--------------------------------------------------------------------===//
-Value::Value(LogicalType type) : type_(std::move(type)), is_null(true) {
-}
-
-Value::Value(int32_t val) : type_(LogicalType::INTEGER), is_null(false) {
-	value_.integer = val;
-}
-
-Value::Value(bool val) : type_(LogicalType::BOOLEAN), is_null(false) {
-	value_.boolean = val;
-}
-
-Value::Value(int64_t val) : type_(LogicalType::BIGINT), is_null(false) {
-	value_.bigint = val;
-}
-
-Value::Value(float val) : type_(LogicalType::FLOAT), is_null(false) {
-	value_.float_ = val;
-}
-
-Value::Value(double val) : type_(LogicalType::DOUBLE), is_null(false) {
-	value_.double_ = val;
-}
-
-Value::Value(const char *val) : Value(val ? string(val) : string()) {
-}
-
-Value::Value(std::nullptr_t val) : Value(LogicalType::VARCHAR) {
-}
-
-Value::Value(string_t val) : Value(val.GetString()) {
-}
-
-Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false) {
-	if (!Value::StringIsValid(val.c_str(), val.size())) {
-		throw ErrorManager::InvalidUnicodeError(val, "value construction");
-	}
-	value_info_ = make_shared_ptr<StringValueInfo>(std::move(val));
-}
-
-Value::~Value() {
-}
-
-Value::Value(const Value &other)
-    : type_(other.type_), is_null(other.is_null), value_(other.value_), value_info_(other.value_info_) {
-}
-
-Value::Value(Value &&other) noexcept
-    : type_(std::move(other.type_)), is_null(other.is_null), value_(other.value_),
-      value_info_(std::move(other.value_info_)) {
-}
-
-Value &Value::operator=(const Value &other) {
-	if (this == &other) {
-		return *this;
-	}
-	type_ = other.type_;
-	is_null = other.is_null;
-	value_ = other.value_;
-	value_info_ = other.value_info_;
-	return *this;
-}
-
-Value &Value::operator=(Value &&other) noexcept {
-	type_ = std::move(other.type_);
-	is_null = other.is_null;
-	value_ = other.value_;
-	value_info_ = std::move(other.value_info_);
-	return *this;
-}
-
-Value Value::MinimumValue(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Value::BOOLEAN(false);
-	case LogicalTypeId::TINYINT:
-		return Value::TINYINT(NumericLimits<int8_t>::Minimum());
-	case LogicalTypeId::SMALLINT:
-		return Value::SMALLINT(NumericLimits<int16_t>::Minimum());
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::SQLNULL:
-		return Value::INTEGER(NumericLimits<int32_t>::Minimum());
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(NumericLimits<int64_t>::Minimum());
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Minimum());
-	case LogicalTypeId::UHUGEINT:
-		return Value::UHUGEINT(NumericLimits<uhugeint_t>::Minimum());
-	case LogicalTypeId::UUID:
-		return Value::UUID(NumericLimits<hugeint_t>::Minimum());
-	case LogicalTypeId::UTINYINT:
-		return Value::UTINYINT(NumericLimits<uint8_t>::Minimum());
-	case LogicalTypeId::USMALLINT:
-		return Value::USMALLINT(NumericLimits<uint16_t>::Minimum());
-	case LogicalTypeId::UINTEGER:
-		return Value::UINTEGER(NumericLimits<uint32_t>::Minimum());
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(NumericLimits<uint64_t>::Minimum());
-	case LogicalTypeId::DATE:
-		return Value::DATE(Date::FromDate(Date::DATE_MIN_YEAR, Date::DATE_MIN_MONTH, Date::DATE_MIN_DAY));
-	case LogicalTypeId::TIME:
-		return Value::TIME(dtime_t(0));
-	case LogicalTypeId::TIMESTAMP: {
-		const auto date = Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY);
-		return Value::TIMESTAMP(date, dtime_t(0));
-	}
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		// Get the minimum timestamp and cast it to timestamp_sec_t.
-		const auto min_ts = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		const auto ts = Cast::Operation<timestamp_t, timestamp_sec_t>(min_ts);
-		return Value::TIMESTAMPSEC(ts);
-	}
-	case LogicalTypeId::TIMESTAMP_MS: {
-		// Get the minimum timestamp and cast it to timestamp_ms_t.
-		const auto min_ts = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		const auto ts = Cast::Operation<timestamp_t, timestamp_ms_t>(min_ts);
-		return Value::TIMESTAMPMS(ts);
-	}
-	case LogicalTypeId::TIMESTAMP_NS: {
-		// Clear the fractional day.
-		auto min_ns = NumericLimits<int64_t>::Minimum();
-		min_ns /= Interval::NANOS_PER_DAY;
-		min_ns *= Interval::NANOS_PER_DAY;
-		return Value::TIMESTAMPNS(timestamp_ns_t(min_ns));
-	}
-	case LogicalTypeId::TIME_TZ:
-		//	"00:00:00+1559" from the PG docs, but actually 00:00:00+15:59:59
-		return Value::TIMETZ(dtime_tz_t(dtime_t(0), dtime_tz_t::MAX_OFFSET));
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		const auto date = Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY);
-		const auto ts = Timestamp::FromDatetime(date, dtime_t(0));
-		return Value::TIMESTAMPTZ(timestamp_tz_t(ts));
-	}
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(NumericLimits<float>::Minimum());
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(NumericLimits<double>::Minimum());
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(int16_t(-NumericHelper::POWERS_OF_TEN[width] + 1), width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(int32_t(-NumericHelper::POWERS_OF_TEN[width] + 1), width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(int64_t(-NumericHelper::POWERS_OF_TEN[width] + 1), width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(-Hugeint::POWERS_OF_TEN[width] + 1, width, scale);
-		default:
-			throw InternalException("Unknown decimal type");
-		}
-	}
-	case LogicalTypeId::ENUM:
-		return Value::ENUM(0, type);
-	case LogicalTypeId::VARINT:
-		return Value::VARINT(Varint::VarcharToVarInt(
-		    "-179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540"
-		    "4589535143824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339"
-		    "42304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368"));
-	default:
-		throw InvalidTypeException(type, "MinimumValue requires numeric type");
-	}
-}
-
-Value Value::MaximumValue(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Value::BOOLEAN(true);
-	case LogicalTypeId::TINYINT:
-		return Value::TINYINT(NumericLimits<int8_t>::Maximum());
-	case LogicalTypeId::SMALLINT:
-		return Value::SMALLINT(NumericLimits<int16_t>::Maximum());
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::SQLNULL:
-		return Value::INTEGER(NumericLimits<int32_t>::Maximum());
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(NumericLimits<int64_t>::Maximum());
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Maximum());
-	case LogicalTypeId::UHUGEINT:
-		return Value::UHUGEINT(NumericLimits<uhugeint_t>::Maximum());
-	case LogicalTypeId::UUID:
-		return Value::UUID(NumericLimits<hugeint_t>::Maximum());
-	case LogicalTypeId::UTINYINT:
-		return Value::UTINYINT(NumericLimits<uint8_t>::Maximum());
-	case LogicalTypeId::USMALLINT:
-		return Value::USMALLINT(NumericLimits<uint16_t>::Maximum());
-	case LogicalTypeId::UINTEGER:
-		return Value::UINTEGER(NumericLimits<uint32_t>::Maximum());
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(NumericLimits<uint64_t>::Maximum());
-	case LogicalTypeId::DATE:
-		return Value::DATE(Date::FromDate(Date::DATE_MAX_YEAR, Date::DATE_MAX_MONTH, Date::DATE_MAX_DAY));
-	case LogicalTypeId::TIME:
-		//	24:00:00 according to PG
-		return Value::TIME(dtime_t(Interval::MICROS_PER_DAY));
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		// Get the maximum timestamp and cast it to timestamp_s_t.
-		const auto max_ts = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		const auto ts = Cast::Operation<timestamp_t, timestamp_sec_t>(max_ts);
-		return Value::TIMESTAMPSEC(ts);
-	}
-	case LogicalTypeId::TIMESTAMP_MS: {
-		// Get the maximum timestamp and cast it to timestamp_ms_t.
-		const auto max_ts = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		const auto ts = Cast::Operation<timestamp_t, timestamp_ms_t>(max_ts);
-		return Value::TIMESTAMPMS(ts);
-	}
-	case LogicalTypeId::TIMESTAMP_NS: {
-		const auto ts = timestamp_ns_t(NumericLimits<int64_t>::Maximum() - 1);
-		return Value::TIMESTAMPNS(ts);
-	}
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_tz_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIME_TZ:
-		// "24:00:00-1559" from the PG docs but actually "24:00:00-15:59:59".
-		return Value::TIMETZ(dtime_tz_t(dtime_t(Interval::MICROS_PER_DAY), dtime_tz_t::MIN_OFFSET));
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(NumericLimits<float>::Maximum());
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(NumericLimits<double>::Maximum());
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(int16_t(NumericHelper::POWERS_OF_TEN[width] - 1), width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(int32_t(NumericHelper::POWERS_OF_TEN[width] - 1), width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(int64_t(NumericHelper::POWERS_OF_TEN[width] - 1), width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(Hugeint::POWERS_OF_TEN[width] - 1, width, scale);
-		default:
-			throw InternalException("Unknown decimal type");
-		}
-	}
-	case LogicalTypeId::ENUM: {
-		auto enum_size = EnumType::GetSize(type);
-		return Value::ENUM(enum_size - (enum_size ? 1 : 0), type);
-	}
-	case LogicalTypeId::VARINT:
-		return Value::VARINT(Varint::VarcharToVarInt(
-		    "1797693134862315708145274237317043567980705675258449965989174768031572607800285387605895586327668781715404"
-		    "5895351438246423432132688946418276846754670353751698604991057655128207624549009038932894407586850845513394"
-		    "2304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368"));
-	default:
-		throw InvalidTypeException(type, "MaximumValue requires numeric type");
-	}
-}
-
-Value Value::Infinity(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::DATE:
-		return Value::DATE(date_t::infinity());
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t::infinity());
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_sec_t(timestamp_t::infinity().value));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_ms_t(timestamp_t::infinity().value));
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_ns_t(timestamp_t::infinity().value));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::infinity()));
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(std::numeric_limits<float>::infinity());
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(std::numeric_limits<double>::infinity());
-	default:
-		throw InvalidTypeException(type, "Infinity requires numeric type");
-	}
-}
-
-Value Value::NegativeInfinity(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::DATE:
-		return Value::DATE(date_t::ninfinity());
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t::ninfinity());
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_sec_t(timestamp_t::ninfinity().value));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_ms_t(timestamp_t::ninfinity().value));
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_ns_t(timestamp_t::ninfinity().value));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::ninfinity()));
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(-std::numeric_limits<float>::infinity());
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(-std::numeric_limits<double>::infinity());
-	default:
-		throw InvalidTypeException(type, "NegativeInfinity requires numeric type");
-	}
-}
-
-Value Value::BOOLEAN(bool value) {
-	Value result(LogicalType::BOOLEAN);
-	result.value_.boolean = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TINYINT(int8_t value) {
-	Value result(LogicalType::TINYINT);
-	result.value_.tinyint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::SMALLINT(int16_t value) {
-	Value result(LogicalType::SMALLINT);
-	result.value_.smallint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::INTEGER(int32_t value) {
-	Value result(LogicalType::INTEGER);
-	result.value_.integer = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::BIGINT(int64_t value) {
-	Value result(LogicalType::BIGINT);
-	result.value_.bigint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::HUGEINT(hugeint_t value) {
-	Value result(LogicalType::HUGEINT);
-	result.value_.hugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UHUGEINT(uhugeint_t value) {
-	Value result(LogicalType::UHUGEINT);
-	result.value_.uhugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UUID(hugeint_t value) {
-	Value result(LogicalType::UUID);
-	result.value_.hugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UUID(const string &value) {
-	Value result(LogicalType::UUID);
-	result.value_.hugeint = UUID::FromString(value);
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UTINYINT(uint8_t value) {
-	Value result(LogicalType::UTINYINT);
-	result.value_.utinyint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::USMALLINT(uint16_t value) {
-	Value result(LogicalType::USMALLINT);
-	result.value_.usmallint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UINTEGER(uint32_t value) {
-	Value result(LogicalType::UINTEGER);
-	result.value_.uinteger = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UBIGINT(uint64_t value) {
-	Value result(LogicalType::UBIGINT);
-	result.value_.ubigint = value;
-	result.is_null = false;
-	return result;
-}
-
-bool Value::FloatIsFinite(float value) {
-	return !(std::isnan(value) || std::isinf(value));
-}
-
-bool Value::DoubleIsFinite(double value) {
-	return !(std::isnan(value) || std::isinf(value));
-}
-
-template <>
-bool Value::IsNan(float input) {
-	return std::isnan(input);
-}
-
-template <>
-bool Value::IsNan(double input) {
-	return std::isnan(input);
-}
-
-template <>
-bool Value::IsFinite(float input) {
-	return Value::FloatIsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(double input) {
-	return Value::DoubleIsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(date_t input) {
-	return Date::IsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(timestamp_t input) {
-	return Timestamp::IsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(timestamp_sec_t input) {
-	return Timestamp::IsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(timestamp_ms_t input) {
-	return Timestamp::IsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(timestamp_ns_t input) {
-	return Timestamp::IsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(timestamp_tz_t input) {
-	return Timestamp::IsFinite(input);
-}
-
-bool Value::StringIsValid(const char *str, idx_t length) {
-	auto utf_type = Utf8Proc::Analyze(str, length);
-	return utf_type != UnicodeType::INVALID;
-}
-
-Value Value::DECIMAL(int16_t value, uint8_t width, uint8_t scale) {
-	return Value::DECIMAL(int64_t(value), width, scale);
-}
-
-Value Value::DECIMAL(int32_t value, uint8_t width, uint8_t scale) {
-	return Value::DECIMAL(int64_t(value), width, scale);
-}
-
-Value Value::DECIMAL(int64_t value, uint8_t width, uint8_t scale) {
-	auto decimal_type = LogicalType::DECIMAL(width, scale);
-	Value result(decimal_type);
-	switch (decimal_type.InternalType()) {
-	case PhysicalType::INT16:
-		result.value_.smallint = NumericCast<int16_t>(value);
-		break;
-	case PhysicalType::INT32:
-		result.value_.integer = NumericCast<int32_t>(value);
-		break;
-	case PhysicalType::INT64:
-		result.value_.bigint = value;
-		break;
-	default:
-		result.value_.hugeint = value;
-		break;
-	}
-	result.type_.Verify();
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DECIMAL(hugeint_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(width >= Decimal::MAX_WIDTH_INT64 && width <= Decimal::MAX_WIDTH_INT128);
-	Value result(LogicalType::DECIMAL(width, scale));
-	result.value_.hugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::FLOAT(float value) {
-	Value result(LogicalType::FLOAT);
-	result.value_.float_ = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DOUBLE(double value) {
-	Value result(LogicalType::DOUBLE);
-	result.value_.double_ = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::HASH(hash_t value) {
-	Value result(LogicalType::HASH);
-	result.value_.hash = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::POINTER(uintptr_t value) {
-	Value result(LogicalType::POINTER);
-	result.value_.pointer = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DATE(date_t value) {
-	Value result(LogicalType::DATE);
-	result.value_.date = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DATE(int32_t year, int32_t month, int32_t day) {
-	return Value::DATE(Date::FromDate(year, month, day));
-}
-
-Value Value::TIME(dtime_t value) {
-	Value result(LogicalType::TIME);
-	result.value_.time = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMETZ(dtime_tz_t value) {
-	Value result(LogicalType::TIME_TZ);
-	result.value_.timetz = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros) {
-	return Value::TIME(Time::FromTime(hour, min, sec, micros));
-}
-
-Value Value::TIMESTAMP(timestamp_t value) {
-	Value result(LogicalType::TIMESTAMP);
-	result.value_.timestamp = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPSEC(timestamp_sec_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_S);
-	result.value_.timestamp_s = timestamp;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPMS(timestamp_ms_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_MS);
-	result.value_.timestamp_ms = timestamp;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPNS(timestamp_ns_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_NS);
-	result.value_.timestamp_ns = timestamp;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPTZ(timestamp_tz_t value) {
-	Value result(LogicalType::TIMESTAMP_TZ);
-	result.value_.timestamp_tz = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMP(date_t date, dtime_t time) {
-	return Value::TIMESTAMP(Timestamp::FromDatetime(date, time));
-}
-
-Value Value::TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
-                       int32_t micros) {
-	auto date = Date::FromDate(year, month, day);
-	auto time = Time::FromTime(hour, min, sec, micros);
-	auto val = Value::TIMESTAMP(date, time);
-	val.type_ = LogicalType::TIMESTAMP;
-	return val;
-}
-
-Value Value::STRUCT(const LogicalType &type, vector<Value> struct_values) {
-	Value result;
-	auto child_types = StructType::GetChildTypes(type);
-	for (size_t i = 0; i < struct_values.size(); i++) {
-		struct_values[i] = struct_values[i].DefaultCastAs(child_types[i].second);
-	}
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(struct_values));
-	result.type_ = type;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::STRUCT(child_list_t<Value> values) {
-	child_list_t<LogicalType> child_types;
-	vector<Value> struct_values;
-	for (auto &child : values) {
-		child_types.push_back(make_pair(std::move(child.first), child.second.type()));
-		struct_values.push_back(std::move(child.second));
-	}
-	return Value::STRUCT(LogicalType::STRUCT(child_types), std::move(struct_values));
-}
-
-void MapKeyCheck(unordered_set<hash_t> &unique_keys, const Value &key) {
-	// NULL key check.
-	if (key.IsNull()) {
-		MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_KEY);
-	}
-
-	// Duplicate key check.
-	auto key_hash = key.Hash();
-	if (unique_keys.find(key_hash) != unique_keys.end()) {
-		MapVector::EvalMapInvalidReason(MapInvalidReason::DUPLICATE_KEY);
-	}
-	unique_keys.insert(key_hash);
-}
-
-Value Value::MAP(const LogicalType &child_type, vector<Value> values) { // NOLINT
-	vector<Value> map_keys;
-	vector<Value> map_values;
-	unordered_set<hash_t> unique_keys;
-
-	for (auto &val : values) {
-		D_ASSERT(val.type().InternalType() == PhysicalType::STRUCT);
-		auto &children = StructValue::GetChildren(val);
-		D_ASSERT(children.size() == 2);
-
-		auto &key = children[0];
-		MapKeyCheck(unique_keys, key);
-
-		map_keys.push_back(key);
-		map_values.push_back(children[1]);
-	}
-
-	auto &key_type = StructType::GetChildType(child_type, 0);
-	auto &value_type = StructType::GetChildType(child_type, 1);
-	return Value::MAP(key_type, value_type, std::move(map_keys), std::move(map_values));
-}
-
-Value Value::MAP(const LogicalType &key_type, const LogicalType &value_type, vector<Value> keys, vector<Value> values) {
-	D_ASSERT(keys.size() == values.size());
-	Value result;
-
-	result.type_ = LogicalType::MAP(key_type, value_type);
-	result.is_null = false;
-	unordered_set<hash_t> unique_keys;
-
-	for (idx_t i = 0; i < keys.size(); i++) {
-		child_list_t<LogicalType> struct_types;
-		vector<Value> new_children;
-		struct_types.reserve(2);
-		new_children.reserve(2);
-
-		struct_types.push_back(make_pair("key", key_type));
-		struct_types.push_back(make_pair("value", value_type));
-
-		auto key = keys[i].DefaultCastAs(key_type);
-		MapKeyCheck(unique_keys, key);
-
-		new_children.push_back(key);
-		new_children.push_back(values[i]);
-		auto struct_type = LogicalType::STRUCT(std::move(struct_types));
-		values[i] = Value::STRUCT(struct_type, std::move(new_children));
-	}
-
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
-	return result;
-}
-
-Value Value::MAP(const unordered_map<string, string> &kv_pairs) {
-	Value result;
-	result.type_ = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	result.is_null = false;
-	vector<Value> pairs;
-	for (auto &kv : kv_pairs) {
-		pairs.push_back(Value::STRUCT({{"key", Value(kv.first)}, {"value", Value(kv.second)}}));
-	}
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(pairs));
-	return result;
-}
-
-Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value) {
-	D_ASSERT(!members.empty());
-	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
-	D_ASSERT(members.size() > tag);
-
-	D_ASSERT(value.type() == members[tag].second);
-
-	Value result;
-	result.is_null = false;
-	// add the tag to the front of the struct
-	vector<Value> union_values;
-	union_values.emplace_back(Value::UTINYINT(tag));
-	for (idx_t i = 0; i < members.size(); i++) {
-		if (i != tag) {
-			union_values.emplace_back(members[i].second);
-		} else {
-			union_values.emplace_back(nullptr);
-		}
-	}
-	union_values[tag + 1] = std::move(value);
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(union_values));
-	result.type_ = LogicalType::UNION(std::move(members));
-	return result;
-}
-
-Value Value::LIST(const LogicalType &child_type, vector<Value> values) {
-	Value result;
-	result.type_ = LogicalType::LIST(child_type);
-	result.is_null = false;
-	for (auto &val : values) {
-		val = val.DefaultCastAs(child_type);
-	}
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
-	return result;
-}
-
-Value Value::LIST(vector<Value> values) {
-	if (values.empty()) {
-		throw InternalException(
-		    "Value::LIST(values) cannot be used to make an empty list - use Value::LIST(type, values) instead");
-	}
-	auto &type = values[0].type();
-	return Value::LIST(type, std::move(values));
-}
-
-Value Value::ARRAY(const LogicalType &child_type, vector<Value> values) {
-	Value result;
-	result.type_ = LogicalType::ARRAY(child_type, values.size());
-	for (auto &val : values) {
-		val = val.DefaultCastAs(child_type);
-	}
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
-	result.is_null = false;
-	return result;
-}
-
-Value Value::BLOB(const_data_ptr_t data, idx_t len) {
-	Value result(LogicalType::BLOB);
-	result.is_null = false;
-	result.value_info_ = make_shared_ptr<StringValueInfo>(string(const_char_ptr_cast(data), len));
-	return result;
-}
-
-Value Value::VARINT(const_data_ptr_t data, idx_t len) {
-	return VARINT(string(const_char_ptr_cast(data), len));
-}
-
-Value Value::VARINT(const string &data) {
-	Value result(LogicalType::VARINT);
-	result.is_null = false;
-	result.value_info_ = make_shared_ptr<StringValueInfo>(data);
-	return result;
-}
-
-Value Value::BLOB(const string &data) {
-	Value result(LogicalType::BLOB);
-	result.is_null = false;
-	result.value_info_ = make_shared_ptr<StringValueInfo>(Blob::ToBlob(string_t(data)));
-	return result;
-}
-
-Value Value::AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len) { // NOLINT
-	Value result(type);
-	result.is_null = false;
-	result.value_info_ = make_shared_ptr<StringValueInfo>(string(const_char_ptr_cast(data), len));
-	return result;
-}
-
-Value Value::BIT(const_data_ptr_t data, idx_t len) {
-	Value result(LogicalType::BIT);
-	result.is_null = false;
-	result.value_info_ = make_shared_ptr<StringValueInfo>(string(const_char_ptr_cast(data), len));
-	return result;
-}
-
-Value Value::BIT(const string &data) {
-	Value result(LogicalType::BIT);
-	result.is_null = false;
-	result.value_info_ = make_shared_ptr<StringValueInfo>(Bit::ToBit(string_t(data)));
-	return result;
-}
-
-Value Value::ENUM(uint64_t value, const LogicalType &original_type) {
-	D_ASSERT(original_type.id() == LogicalTypeId::ENUM);
-	Value result(original_type);
-	switch (original_type.InternalType()) {
-	case PhysicalType::UINT8:
-		result.value_.utinyint = NumericCast<uint8_t>(value);
-		break;
-	case PhysicalType::UINT16:
-		result.value_.usmallint = NumericCast<uint16_t>(value);
-		break;
-	case PhysicalType::UINT32:
-		result.value_.uinteger = NumericCast<uint32_t>(value);
-		break;
-	default:
-		throw InternalException("Incorrect Physical Type for ENUM");
-	}
-	result.is_null = false;
-	return result;
-}
-
-Value Value::INTERVAL(int32_t months, int32_t days, int64_t micros) {
-	Value result(LogicalType::INTERVAL);
-	result.is_null = false;
-	result.value_.interval.months = months;
-	result.value_.interval.days = days;
-	result.value_.interval.micros = micros;
-	return result;
-}
-
-Value Value::INTERVAL(interval_t interval) {
-	return Value::INTERVAL(interval.months, interval.days, interval.micros);
-}
-
-//===--------------------------------------------------------------------===//
-// CreateValue
-//===--------------------------------------------------------------------===//
-template <>
-Value Value::CreateValue(bool value) {
-	return Value::BOOLEAN(value);
-}
-
-template <>
-Value Value::CreateValue(int8_t value) {
-	return Value::TINYINT(value);
-}
-
-template <>
-Value Value::CreateValue(int16_t value) {
-	return Value::SMALLINT(value);
-}
-
-template <>
-Value Value::CreateValue(int32_t value) {
-	return Value::INTEGER(value);
-}
-
-template <>
-Value Value::CreateValue(int64_t value) {
-	return Value::BIGINT(value);
-}
-
-template <>
-Value Value::CreateValue(uint8_t value) {
-	return Value::UTINYINT(value);
-}
-
-template <>
-Value Value::CreateValue(uint16_t value) {
-	return Value::USMALLINT(value);
-}
-
-template <>
-Value Value::CreateValue(uint32_t value) {
-	return Value::UINTEGER(value);
-}
-
-template <>
-Value Value::CreateValue(uint64_t value) {
-	return Value::UBIGINT(value);
-}
-
-template <>
-Value Value::CreateValue(hugeint_t value) {
-	return Value::HUGEINT(value);
-}
-
-template <>
-Value Value::CreateValue(uhugeint_t value) {
-	return Value::UHUGEINT(value);
-}
-
-template <>
-Value Value::CreateValue(date_t value) {
-	return Value::DATE(value);
-}
-
-template <>
-Value Value::CreateValue(dtime_t value) {
-	return Value::TIME(value);
-}
-
-template <>
-Value Value::CreateValue(dtime_tz_t value) {
-	return Value::TIMETZ(value);
-}
-
-template <>
-Value Value::CreateValue(timestamp_t value) {
-	return Value::TIMESTAMP(value);
-}
-
-template <>
-Value Value::CreateValue(timestamp_sec_t value) {
-	return Value::TIMESTAMPSEC(value);
-}
-
-template <>
-Value Value::CreateValue(timestamp_ms_t value) {
-	return Value::TIMESTAMPMS(value);
-}
-
-template <>
-Value Value::CreateValue(timestamp_ns_t value) {
-	return Value::TIMESTAMPNS(value);
-}
-
-template <>
-Value Value::CreateValue(timestamp_tz_t value) {
-	return Value::TIMESTAMPTZ(value);
-}
-
-template <>
-Value Value::CreateValue(const char *value) {
-	return Value(string(value));
-}
-
-template <>
-Value Value::CreateValue(string value) { // NOLINT: required for templating
-	return Value::BLOB(value);
-}
-
-template <>
-Value Value::CreateValue(string_t value) {
-	return Value(value);
-}
-
-template <>
-Value Value::CreateValue(float value) {
-	return Value::FLOAT(value);
-}
-
-template <>
-Value Value::CreateValue(double value) {
-	return Value::DOUBLE(value);
-}
-
-template <>
-Value Value::CreateValue(interval_t value) {
-	return Value::INTERVAL(value);
-}
-
-template <>
-Value Value::CreateValue(Value value) {
-	return value;
-}
-
-//===--------------------------------------------------------------------===//
-// GetValue
-//===--------------------------------------------------------------------===//
-template <class T>
-T Value::GetValueInternal() const {
-	if (IsNull()) {
-		throw InternalException("Calling GetValueInternal on a value that is NULL");
-	}
-	switch (type_.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Cast::Operation<bool, T>(value_.boolean);
-	case LogicalTypeId::TINYINT:
-		return Cast::Operation<int8_t, T>(value_.tinyint);
-	case LogicalTypeId::SMALLINT:
-		return Cast::Operation<int16_t, T>(value_.smallint);
-	case LogicalTypeId::INTEGER:
-		return Cast::Operation<int32_t, T>(value_.integer);
-	case LogicalTypeId::BIGINT:
-		return Cast::Operation<int64_t, T>(value_.bigint);
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UUID:
-		return Cast::Operation<hugeint_t, T>(value_.hugeint);
-	case LogicalTypeId::UHUGEINT:
-		return Cast::Operation<uhugeint_t, T>(value_.uhugeint);
-	case LogicalTypeId::DATE:
-		return Cast::Operation<date_t, T>(value_.date);
-	case LogicalTypeId::TIME:
-		return Cast::Operation<dtime_t, T>(value_.time);
-	case LogicalTypeId::TIME_TZ:
-		return Cast::Operation<dtime_tz_t, T>(value_.timetz);
-	case LogicalTypeId::TIMESTAMP:
-		return Cast::Operation<timestamp_t, T>(value_.timestamp);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Cast::Operation<timestamp_sec_t, T>(value_.timestamp_s);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Cast::Operation<timestamp_ms_t, T>(value_.timestamp_ms);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Cast::Operation<timestamp_ns_t, T>(value_.timestamp_ns);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Cast::Operation<timestamp_tz_t, T>(value_.timestamp_tz);
-	case LogicalTypeId::UTINYINT:
-		return Cast::Operation<uint8_t, T>(value_.utinyint);
-	case LogicalTypeId::USMALLINT:
-		return Cast::Operation<uint16_t, T>(value_.usmallint);
-	case LogicalTypeId::UINTEGER:
-		return Cast::Operation<uint32_t, T>(value_.uinteger);
-	case LogicalTypeId::UBIGINT:
-		return Cast::Operation<uint64_t, T>(value_.ubigint);
-	case LogicalTypeId::FLOAT:
-		return Cast::Operation<float, T>(value_.float_);
-	case LogicalTypeId::DOUBLE:
-		return Cast::Operation<double, T>(value_.double_);
-	case LogicalTypeId::VARCHAR:
-		return Cast::Operation<string_t, T>(StringValue::Get(*this).c_str());
-	case LogicalTypeId::INTERVAL:
-		return Cast::Operation<interval_t, T>(value_.interval);
-	case LogicalTypeId::DECIMAL:
-		return DefaultCastAs(LogicalType::DOUBLE).GetValueInternal<T>();
-	case LogicalTypeId::ENUM: {
-		switch (type_.InternalType()) {
-		case PhysicalType::UINT8:
-			return Cast::Operation<uint8_t, T>(value_.utinyint);
-		case PhysicalType::UINT16:
-			return Cast::Operation<uint16_t, T>(value_.usmallint);
-		case PhysicalType::UINT32:
-			return Cast::Operation<uint32_t, T>(value_.uinteger);
-		default:
-			throw InternalException("Invalid Internal Type for ENUMs");
-		}
-	}
-	default:
-		throw NotImplementedException("Unimplemented type \"%s\" for GetValue()", type_.ToString());
-	}
-}
-
-template <>
-bool Value::GetValue() const {
-	return GetValueInternal<int8_t>();
-}
-template <>
-int8_t Value::GetValue() const {
-	return GetValueInternal<int8_t>();
-}
-template <>
-int16_t Value::GetValue() const {
-	return GetValueInternal<int16_t>();
-}
-template <>
-int32_t Value::GetValue() const {
-	if (type_.id() == LogicalTypeId::DATE) {
-		return value_.integer;
-	}
-	return GetValueInternal<int32_t>();
-}
-template <>
-int64_t Value::GetValue() const {
-	if (IsNull()) {
-		throw InternalException("Calling GetValue on a value that is NULL");
-	}
-	switch (type_.id()) {
-	case LogicalTypeId::TIMESTAMP:
-		return value_.timestamp.value;
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return value_.timestamp_s.value;
-	case LogicalTypeId::TIMESTAMP_MS:
-		return value_.timestamp_ms.value;
-	case LogicalTypeId::TIMESTAMP_NS:
-		return value_.timestamp_ns.value;
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return value_.timestamp_tz.value;
-	case LogicalTypeId::TIME:
-		return value_.bigint;
-	default:
-		return GetValueInternal<int64_t>();
-	}
-}
-template <>
-hugeint_t Value::GetValue() const {
-	return GetValueInternal<hugeint_t>();
-}
-template <>
-uint8_t Value::GetValue() const {
-	return GetValueInternal<uint8_t>();
-}
-template <>
-uint16_t Value::GetValue() const {
-	return GetValueInternal<uint16_t>();
-}
-template <>
-uint32_t Value::GetValue() const {
-	return GetValueInternal<uint32_t>();
-}
-template <>
-uint64_t Value::GetValue() const {
-	return GetValueInternal<uint64_t>();
-}
-template <>
-uhugeint_t Value::GetValue() const {
-	return GetValueInternal<uhugeint_t>();
-}
-template <>
-string Value::GetValue() const {
-	return ToString();
-}
-template <>
-float Value::GetValue() const {
-	return GetValueInternal<float>();
-}
-template <>
-double Value::GetValue() const {
-	return GetValueInternal<double>();
-}
-template <>
-date_t Value::GetValue() const {
-	return GetValueInternal<date_t>();
-}
-template <>
-dtime_t Value::GetValue() const {
-	return GetValueInternal<dtime_t>();
-}
-
-template <>
-timestamp_t Value::GetValue() const {
-	return GetValueInternal<timestamp_t>();
-}
-
-template <>
-timestamp_sec_t Value::GetValue() const {
-	return GetValueInternal<timestamp_sec_t>();
-}
-
-template <>
-timestamp_ms_t Value::GetValue() const {
-	return GetValueInternal<timestamp_ms_t>();
-}
-
-template <>
-timestamp_ns_t Value::GetValue() const {
-	return GetValueInternal<timestamp_ns_t>();
-}
-
-template <>
-timestamp_tz_t Value::GetValue() const {
-	return GetValueInternal<timestamp_tz_t>();
-}
-
-template <>
-dtime_tz_t Value::GetValue() const {
-	return GetValueInternal<dtime_tz_t>();
-}
-
-template <>
-DUCKDB_API interval_t Value::GetValue() const {
-	return GetValueInternal<interval_t>();
-}
-
-template <>
-DUCKDB_API Value Value::GetValue() const {
-	return Value(*this);
-}
-
-uintptr_t Value::GetPointer() const {
-	D_ASSERT(type() == LogicalType::POINTER);
-	return value_.pointer;
-}
-
-Value Value::Numeric(const LogicalType &type, int64_t value) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		D_ASSERT(value == 0 || value == 1);
-		return Value::BOOLEAN(value ? true : false);
-	case LogicalTypeId::TINYINT:
-		D_ASSERT(value >= NumericLimits<int8_t>::Minimum() && value <= NumericLimits<int8_t>::Maximum());
-		return Value::TINYINT((int8_t)value);
-	case LogicalTypeId::SMALLINT:
-		D_ASSERT(value >= NumericLimits<int16_t>::Minimum() && value <= NumericLimits<int16_t>::Maximum());
-		return Value::SMALLINT((int16_t)value);
-	case LogicalTypeId::INTEGER:
-		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
-		return Value::INTEGER((int32_t)value);
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(value);
-	case LogicalTypeId::UTINYINT:
-		D_ASSERT(value >= NumericLimits<uint8_t>::Minimum() && value <= NumericLimits<uint8_t>::Maximum());
-		return Value::UTINYINT((uint8_t)value);
-	case LogicalTypeId::USMALLINT:
-		D_ASSERT(value >= NumericLimits<uint16_t>::Minimum() && value <= NumericLimits<uint16_t>::Maximum());
-		return Value::USMALLINT((uint16_t)value);
-	case LogicalTypeId::UINTEGER:
-		D_ASSERT(value >= NumericLimits<uint32_t>::Minimum() && value <= NumericLimits<uint32_t>::Maximum());
-		return Value::UINTEGER((uint32_t)value);
-	case LogicalTypeId::UBIGINT:
-		D_ASSERT(value >= 0);
-		return Value::UBIGINT(NumericCast<uint64_t>(value));
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(value);
-	case LogicalTypeId::UHUGEINT:
-		return Value::UHUGEINT(NumericCast<uint64_t>(value));
-	case LogicalTypeId::DECIMAL:
-		return Value::DECIMAL(value, DecimalType::GetWidth(type), DecimalType::GetScale(type));
-	case LogicalTypeId::FLOAT:
-		return Value((float)value);
-	case LogicalTypeId::DOUBLE:
-		return Value((double)value);
-	case LogicalTypeId::POINTER:
-		return Value::POINTER(NumericCast<uintptr_t>(value));
-	case LogicalTypeId::DATE:
-		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
-		return Value::DATE(date_t(NumericCast<int32_t>(value)));
-	case LogicalTypeId::TIME:
-		return Value::TIME(dtime_t(value));
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t(value));
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_sec_t(value));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_ms_t(value));
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_ns_t(value));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_tz_t(value));
-	case LogicalTypeId::ENUM:
-		switch (type.InternalType()) {
-		case PhysicalType::UINT8:
-			D_ASSERT(value >= NumericLimits<uint8_t>::Minimum() && value <= NumericLimits<uint8_t>::Maximum());
-			return Value::UTINYINT((uint8_t)value);
-		case PhysicalType::UINT16:
-			D_ASSERT(value >= NumericLimits<uint16_t>::Minimum() && value <= NumericLimits<uint16_t>::Maximum());
-			return Value::USMALLINT((uint16_t)value);
-		case PhysicalType::UINT32:
-			D_ASSERT(value >= NumericLimits<uint32_t>::Minimum() && value <= NumericLimits<uint32_t>::Maximum());
-			return Value::UINTEGER((uint32_t)value);
-		default:
-			throw InternalException("Enum doesn't accept this physical type");
-		}
-	default:
-		throw InvalidTypeException(type, "Numeric requires numeric type");
-	}
-}
-
-Value Value::Numeric(const LogicalType &type, hugeint_t value) {
-#ifdef DEBUG
-	// perform a throwing cast to verify that the type fits
-	Value::HUGEINT(value).DefaultCastAs(type);
-#endif
-	switch (type.id()) {
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(value);
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(Hugeint::Cast<uint64_t>(value));
-	default:
-		return Value::Numeric(type, Hugeint::Cast<int64_t>(value));
-	}
-}
-
-Value Value::Numeric(const LogicalType &type, uhugeint_t value) {
-#ifdef DEBUG
-	// perform a throwing cast to verify that the type fits
-	Value::UHUGEINT(value).DefaultCastAs(type);
-#endif
-	switch (type.id()) {
-	case LogicalTypeId::UHUGEINT:
-		return Value::UHUGEINT(value);
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(Uhugeint::Cast<uint64_t>(value));
-	default:
-		return Value::Numeric(type, Uhugeint::Cast<int64_t>(value));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// GetValueUnsafe
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::BOOL);
-	return value_.boolean;
-}
-
-template <>
-int8_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT8 || type_.InternalType() == PhysicalType::BOOL);
-	return value_.tinyint;
-}
-
-template <>
-int16_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT16);
-	return value_.smallint;
-}
-
-template <>
-int32_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.integer;
-}
-
-template <>
-int64_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.bigint;
-}
-
-template <>
-hugeint_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT128);
-	return value_.hugeint;
-}
-
-template <>
-uint8_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT8);
-	return value_.utinyint;
-}
-
-template <>
-uint16_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT16);
-	return value_.usmallint;
-}
-
-template <>
-uint32_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT32);
-	return value_.uinteger;
-}
-
-template <>
-uint64_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT64);
-	return value_.ubigint;
-}
-
-template <>
-uhugeint_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT128);
-	return value_.uhugeint;
-}
-
-template <>
-string Value::GetValueUnsafe() const {
-	return StringValue::Get(*this);
-}
-
-template <>
-DUCKDB_API string_t Value::GetValueUnsafe() const {
-	return string_t(StringValue::Get(*this));
-}
-
-template <>
-float Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::FLOAT);
-	return value_.float_;
-}
-
-template <>
-double Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::DOUBLE);
-	return value_.double_;
-}
-
-template <>
-date_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.date;
-}
-
-template <>
-dtime_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.time;
-}
-
-template <>
-dtime_tz_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timetz;
-}
-
-template <>
-timestamp_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp;
-}
-
-template <>
-timestamp_sec_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp_s;
-}
-
-template <>
-timestamp_ms_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp_ms;
-}
-
-template <>
-timestamp_ns_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp_ns;
-}
-
-template <>
-timestamp_tz_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp_tz;
-}
-
-template <>
-interval_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INTERVAL);
-	return value_.interval;
-}
-
-//===--------------------------------------------------------------------===//
-// Hash
-//===--------------------------------------------------------------------===//
-hash_t Value::Hash() const {
-	if (IsNull()) {
-		return 0;
-	}
-	Vector input(*this);
-	Vector result(LogicalType::HASH, 1);
-	VectorOperations::Hash(input, result, 1);
-
-	auto data = FlatVector::GetData<hash_t>(result);
-	return data[0];
-}
-
-string Value::ToString() const {
-	if (IsNull()) {
-		return "NULL";
-	}
-	return StringValue::Get(DefaultCastAs(LogicalType::VARCHAR));
-}
-
-string Value::ToSQLString() const {
-	if (IsNull()) {
-		return ToString();
-	}
-	switch (type_.id()) {
-	case LogicalTypeId::UUID:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::INTERVAL:
-	case LogicalTypeId::BLOB:
-		return "'" + ToString() + "'::" + type_.ToString();
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::ENUM: {
-		auto str_val = ToString();
-		if (str_val.size() == 1 && str_val[0] == '\0') {
-			return "chr(0)";
-		}
-		return "'" + StringUtil::Replace(ToString(), "'", "''") + "'";
-	}
-	case LogicalTypeId::STRUCT: {
-		bool is_unnamed = StructType::IsUnnamed(type_);
-		string ret = is_unnamed ? "(" : "{";
-		auto &child_types = StructType::GetChildTypes(type_);
-		auto &struct_values = StructValue::GetChildren(*this);
-		for (idx_t i = 0; i < struct_values.size(); i++) {
-			auto &name = child_types[i].first;
-			auto &child = struct_values[i];
-			if (is_unnamed) {
-				ret += child.ToSQLString();
-			} else {
-				ret += "'" + name + "': " + child.ToSQLString();
-			}
-			if (i < struct_values.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += is_unnamed ? ")" : "}";
-		return ret;
-	}
-	case LogicalTypeId::FLOAT:
-		if (!FloatIsFinite(FloatValue::Get(*this))) {
-			return "'" + ToString() + "'::" + type_.ToString();
-		}
-		return ToString();
-	case LogicalTypeId::DOUBLE: {
-		double val = DoubleValue::Get(*this);
-		if (!DoubleIsFinite(val)) {
-			if (!Value::IsNan(val)) {
-				// to infinity and beyond
-				return val < 0 ? "-1e1000" : "1e1000";
-			}
-			return "'" + ToString() + "'::" + type_.ToString();
-		}
-		return ToString();
-	}
-	case LogicalTypeId::LIST: {
-		string ret = "[";
-		auto &list_values = ListValue::GetChildren(*this);
-		for (idx_t i = 0; i < list_values.size(); i++) {
-			auto &child = list_values[i];
-			ret += child.ToSQLString();
-			if (i < list_values.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "]";
-		return ret;
-	}
-	case LogicalTypeId::ARRAY: {
-		string ret = "[";
-		auto &array_values = ArrayValue::GetChildren(*this);
-		for (idx_t i = 0; i < array_values.size(); i++) {
-			auto &child = array_values[i];
-			ret += child.ToSQLString();
-			if (i < array_values.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "]";
-		return ret;
-	}
-	default:
-		return ToString();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Type-specific getters
-//===--------------------------------------------------------------------===//
-bool BooleanValue::Get(const Value &value) {
-	return value.GetValueUnsafe<bool>();
-}
-
-int8_t TinyIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int8_t>();
-}
-
-int16_t SmallIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int16_t>();
-}
-
-int32_t IntegerValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int32_t>();
-}
-
-int64_t BigIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int64_t>();
-}
-
-hugeint_t HugeIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<hugeint_t>();
-}
-
-uint8_t UTinyIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint8_t>();
-}
-
-uint16_t USmallIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint16_t>();
-}
-
-uint32_t UIntegerValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint32_t>();
-}
-
-uint64_t UBigIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint64_t>();
-}
-
-uhugeint_t UhugeIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uhugeint_t>();
-}
-
-float FloatValue::Get(const Value &value) {
-	return value.GetValueUnsafe<float>();
-}
-
-double DoubleValue::Get(const Value &value) {
-	return value.GetValueUnsafe<double>();
-}
-
-const string &StringValue::Get(const Value &value) {
-	if (value.is_null) {
-		throw InternalException("Calling StringValue::Get on a NULL value");
-	}
-	D_ASSERT(value.type().InternalType() == PhysicalType::VARCHAR);
-	D_ASSERT(value.value_info_);
-	return value.value_info_->Get<StringValueInfo>().GetString();
-}
-
-date_t DateValue::Get(const Value &value) {
-	return value.GetValueUnsafe<date_t>();
-}
-
-dtime_t TimeValue::Get(const Value &value) {
-	return value.GetValueUnsafe<dtime_t>();
-}
-
-timestamp_t TimestampValue::Get(const Value &value) {
-	return value.GetValueUnsafe<timestamp_t>();
-}
-
-timestamp_sec_t TimestampSValue::Get(const Value &value) {
-	return value.GetValueUnsafe<timestamp_sec_t>();
-}
-
-timestamp_ms_t TimestampMSValue::Get(const Value &value) {
-	return value.GetValueUnsafe<timestamp_ms_t>();
-}
-
-timestamp_ns_t TimestampNSValue::Get(const Value &value) {
-	return value.GetValueUnsafe<timestamp_ns_t>();
-}
-
-timestamp_tz_t TimestampTZValue::Get(const Value &value) {
-	return value.GetValueUnsafe<timestamp_tz_t>();
-}
-
-interval_t IntervalValue::Get(const Value &value) {
-	return value.GetValueUnsafe<interval_t>();
-}
-
-const vector<Value> &StructValue::GetChildren(const Value &value) {
-	if (value.is_null) {
-		throw InternalException("Calling StructValue::GetChildren on a NULL value");
-	}
-	D_ASSERT(value.type().InternalType() == PhysicalType::STRUCT);
-	D_ASSERT(value.value_info_);
-	return value.value_info_->Get<NestedValueInfo>().GetValues();
-}
-
-const vector<Value> &MapValue::GetChildren(const Value &value) {
-	if (value.is_null) {
-		throw InternalException("Calling MapValue::GetChildren on a NULL value");
-	}
-	D_ASSERT(value.type().id() == LogicalTypeId::MAP);
-	D_ASSERT(value.type().InternalType() == PhysicalType::LIST);
-	D_ASSERT(value.value_info_);
-	return value.value_info_->Get<NestedValueInfo>().GetValues();
-}
-
-const vector<Value> &ListValue::GetChildren(const Value &value) {
-	if (value.is_null) {
-		throw InternalException("Calling ListValue::GetChildren on a NULL value");
-	}
-	D_ASSERT(value.type().InternalType() == PhysicalType::LIST);
-	D_ASSERT(value.value_info_);
-	return value.value_info_->Get<NestedValueInfo>().GetValues();
-}
-
-const vector<Value> &ArrayValue::GetChildren(const Value &value) {
-	if (value.is_null) {
-		throw InternalException("Calling ArrayValue::GetChildren on a NULL value");
-	}
-	D_ASSERT(value.type().InternalType() == PhysicalType::ARRAY);
-	D_ASSERT(value.value_info_);
-	return value.value_info_->Get<NestedValueInfo>().GetValues();
-}
-
-const Value &UnionValue::GetValue(const Value &value) {
-	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
-	auto &children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<union_tag_t>();
-	D_ASSERT(tag < children.size() - 1);
-	return children[tag + 1];
-}
-
-union_tag_t UnionValue::GetTag(const Value &value) {
-	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
-	auto children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<union_tag_t>();
-	D_ASSERT(tag < children.size() - 1);
-	return tag;
-}
-
-const LogicalType &UnionValue::GetType(const Value &value) {
-	return UnionType::GetMemberType(value.type(), UnionValue::GetTag(value));
-}
-
-hugeint_t IntegralValue::Get(const Value &value) {
-	switch (value.type().InternalType()) {
-	case PhysicalType::INT8:
-		return TinyIntValue::Get(value);
-	case PhysicalType::INT16:
-		return SmallIntValue::Get(value);
-	case PhysicalType::INT32:
-		return IntegerValue::Get(value);
-	case PhysicalType::INT64:
-		return BigIntValue::Get(value);
-	case PhysicalType::INT128:
-		return HugeIntValue::Get(value);
-	case PhysicalType::UINT8:
-		return UTinyIntValue::Get(value);
-	case PhysicalType::UINT16:
-		return USmallIntValue::Get(value);
-	case PhysicalType::UINT32:
-		return UIntegerValue::Get(value);
-	case PhysicalType::UINT64:
-		return NumericCast<int64_t>(UBigIntValue::Get(value));
-	case PhysicalType::UINT128:
-		return static_cast<hugeint_t>(UhugeIntValue::Get(value));
-	default:
-		throw InternalException("Invalid internal type \"%s\" for IntegralValue::Get", value.type().ToString());
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Comparison Operators
-//===--------------------------------------------------------------------===//
-bool Value::operator==(const Value &rhs) const {
-	return ValueOperations::Equals(*this, rhs);
-}
-
-bool Value::operator!=(const Value &rhs) const {
-	return ValueOperations::NotEquals(*this, rhs);
-}
-
-bool Value::operator<(const Value &rhs) const {
-	return ValueOperations::LessThan(*this, rhs);
-}
-
-bool Value::operator>(const Value &rhs) const {
-	return ValueOperations::GreaterThan(*this, rhs);
-}
-
-bool Value::operator<=(const Value &rhs) const {
-	return ValueOperations::LessThanEquals(*this, rhs);
-}
-
-bool Value::operator>=(const Value &rhs) const {
-	return ValueOperations::GreaterThanEquals(*this, rhs);
-}
-
-bool Value::operator==(const int64_t &rhs) const {
-	return *this == Value::Numeric(type_, rhs);
-}
-
-bool Value::operator!=(const int64_t &rhs) const {
-	return *this != Value::Numeric(type_, rhs);
-}
-
-bool Value::operator<(const int64_t &rhs) const {
-	return *this < Value::Numeric(type_, rhs);
-}
-
-bool Value::operator>(const int64_t &rhs) const {
-	return *this > Value::Numeric(type_, rhs);
-}
-
-bool Value::operator<=(const int64_t &rhs) const {
-	return *this <= Value::Numeric(type_, rhs);
-}
-
-bool Value::operator>=(const int64_t &rhs) const {
-	return *this >= Value::Numeric(type_, rhs);
-}
-
-bool Value::TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
-                      Value &new_value, string *error_message, bool strict) const {
-	if (type_ == target_type) {
-		new_value = Copy();
-		return true;
-	}
-	Vector input(*this);
-	Vector result(target_type);
-	if (!VectorOperations::TryCast(set, get_input, input, result, 1, error_message, strict)) {
-		return false;
-	}
-	new_value = result.GetValue(0);
-	return true;
-}
-
-bool Value::TryCastAs(ClientContext &context, const LogicalType &target_type, Value &new_value, string *error_message,
-                      bool strict) const {
-	GetCastFunctionInput get_input(context);
-	return TryCastAs(CastFunctionSet::Get(context), get_input, target_type, new_value, error_message, strict);
-}
-
-bool Value::DefaultTryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
-                             bool strict) const {
-	CastFunctionSet set;
-	GetCastFunctionInput get_input;
-	return TryCastAs(set, get_input, target_type, new_value, error_message, strict);
-}
-
-Value Value::CastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
-                    bool strict) const {
-	if (target_type.id() == LogicalTypeId::ANY) {
-		return *this;
-	}
-	Value new_value;
-	string error_message;
-	if (!TryCastAs(set, get_input, target_type, new_value, &error_message, strict)) {
-		throw InvalidInputException("Failed to cast value: %s", error_message);
-	}
-	return new_value;
-}
-
-Value Value::CastAs(ClientContext &context, const LogicalType &target_type, bool strict) const {
-	GetCastFunctionInput get_input(context);
-	return CastAs(CastFunctionSet::Get(context), get_input, target_type, strict);
-}
-
-Value Value::DefaultCastAs(const LogicalType &target_type, bool strict) const {
-	CastFunctionSet set;
-	GetCastFunctionInput get_input;
-	return CastAs(set, get_input, target_type, strict);
-}
-
-bool Value::TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
-                      bool strict) {
-	Value new_value;
-	string error_message;
-	if (!TryCastAs(set, get_input, target_type, new_value, &error_message, strict)) {
-		return false;
-	}
-	type_ = target_type;
-	is_null = new_value.is_null;
-	value_ = new_value.value_;
-	value_info_ = std::move(new_value.value_info_);
-	return true;
-}
-
-bool Value::TryCastAs(ClientContext &context, const LogicalType &target_type, bool strict) {
-	GetCastFunctionInput get_input(context);
-	return TryCastAs(CastFunctionSet::Get(context), get_input, target_type, strict);
-}
-
-bool Value::DefaultTryCastAs(const LogicalType &target_type, bool strict) {
-	CastFunctionSet set;
-	GetCastFunctionInput get_input;
-	return TryCastAs(set, get_input, target_type, strict);
-}
-
-void Value::Reinterpret(LogicalType new_type) {
-	this->type_ = std::move(new_type);
-}
-
-const LogicalType &GetChildType(const LogicalType &parent_type, idx_t i) {
-	switch (parent_type.InternalType()) {
-	case PhysicalType::LIST:
-		return ListType::GetChildType(parent_type);
-	case PhysicalType::STRUCT:
-		return StructType::GetChildType(parent_type, i);
-	case PhysicalType::ARRAY:
-		return ArrayType::GetChildType(parent_type);
-	default:
-		throw InternalException("Parent type is not a nested type");
-	}
-}
-
-bool SerializeTypeMatches(const LogicalType &expected_type, const LogicalType &actual_type) {
-	if (expected_type.id() != actual_type.id()) {
-		// type id needs to be the same
-		return false;
-	}
-	if (expected_type.IsNested()) {
-		// for nested types that is enough - we will recurse into the children and check there again anyway
-		return true;
-	}
-	// otherwise we do a deep comparison of the type (e.g. decimal flags need to be consistent)
-	return expected_type == actual_type;
-}
-
-void Value::SerializeChildren(Serializer &serializer, const vector<Value> &children, const LogicalType &parent_type) {
-	serializer.WriteObject(102, "value", [&](Serializer &child_serializer) {
-		child_serializer.WriteList(100, "children", children.size(), [&](Serializer::List &list, idx_t i) {
-			auto &value_type = GetChildType(parent_type, i);
-			bool serialize_type = value_type.InternalType() == PhysicalType::INVALID;
-			if (!serialize_type && !SerializeTypeMatches(value_type, children[i].type())) {
-				throw InternalException("Error when serializing type - serializing a child of a nested value with type "
-				                        "%s, but expected type %s",
-				                        children[i].type(), value_type);
-			}
-			list.WriteObject([&](Serializer &element_serializer) {
-				children[i].SerializeInternal(element_serializer, serialize_type);
-			});
-		});
-	});
-}
-
-void Value::SerializeInternal(Serializer &serializer, bool serialize_type) const {
-	if (serialize_type || !serializer.ShouldSerialize(4)) {
-		// only the root value needs to serialize its type
-		// for forwards compatibility reasons, we also serialize the type always when targeting versions < v1.2.0
-		serializer.WriteProperty(100, "type", type_);
-	}
-	serializer.WriteProperty(101, "is_null", is_null);
-	if (IsNull()) {
-		return;
-	}
-	switch (type_.InternalType()) {
-	case PhysicalType::BIT:
-		throw InternalException("BIT type should not be serialized");
-	case PhysicalType::BOOL:
-		serializer.WriteProperty(102, "value", value_.boolean);
-		break;
-	case PhysicalType::INT8:
-		serializer.WriteProperty(102, "value", value_.tinyint);
-		break;
-	case PhysicalType::INT16:
-		serializer.WriteProperty(102, "value", value_.smallint);
-		break;
-	case PhysicalType::INT32:
-		serializer.WriteProperty(102, "value", value_.integer);
-		break;
-	case PhysicalType::INT64:
-		serializer.WriteProperty(102, "value", value_.bigint);
-		break;
-	case PhysicalType::UINT8:
-		serializer.WriteProperty(102, "value", value_.utinyint);
-		break;
-	case PhysicalType::UINT16:
-		serializer.WriteProperty(102, "value", value_.usmallint);
-		break;
-	case PhysicalType::UINT32:
-		serializer.WriteProperty(102, "value", value_.uinteger);
-		break;
-	case PhysicalType::UINT64:
-		serializer.WriteProperty(102, "value", value_.ubigint);
-		break;
-	case PhysicalType::INT128:
-		serializer.WriteProperty(102, "value", value_.hugeint);
-		break;
-	case PhysicalType::UINT128:
-		serializer.WriteProperty(102, "value", value_.uhugeint);
-		break;
-	case PhysicalType::FLOAT:
-		serializer.WriteProperty(102, "value", value_.float_);
-		break;
-	case PhysicalType::DOUBLE:
-		serializer.WriteProperty(102, "value", value_.double_);
-		break;
-	case PhysicalType::INTERVAL:
-		serializer.WriteProperty(102, "value", value_.interval);
-		break;
-	case PhysicalType::VARCHAR: {
-		if (type_.id() == LogicalTypeId::BLOB) {
-			auto blob_str = Blob::ToString(StringValue::Get(*this));
-			serializer.WriteProperty(102, "value", blob_str);
-		} else {
-			serializer.WriteProperty(102, "value", StringValue::Get(*this));
-		}
-	} break;
-	case PhysicalType::LIST:
-		SerializeChildren(serializer, ListValue::GetChildren(*this), type_);
-		break;
-	case PhysicalType::STRUCT:
-		SerializeChildren(serializer, StructValue::GetChildren(*this), type_);
-		break;
-	case PhysicalType::ARRAY:
-		SerializeChildren(serializer, ArrayValue::GetChildren(*this), type_);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for Serialize");
-	}
-}
-
-void Value::Serialize(Serializer &serializer) const {
-	// serialize the value - the top-level value always needs to serialize its type
-	SerializeInternal(serializer, true);
-}
-
-Value Value::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadPropertyWithExplicitDefault<LogicalType>(100, "type", LogicalTypeId::INVALID);
-	if (type.InternalType() == PhysicalType::INVALID) {
-		type = deserializer.Get<const LogicalType &>();
-	}
-	auto is_null = deserializer.ReadProperty<bool>(101, "is_null");
-	Value new_value = Value(type);
-	if (is_null) {
-		return new_value;
-	}
-	new_value.is_null = false;
-	switch (type.InternalType()) {
-	case PhysicalType::BIT:
-		throw InternalException("BIT type should not be deserialized");
-	case PhysicalType::BOOL:
-		new_value.value_.boolean = deserializer.ReadProperty<bool>(102, "value");
-		break;
-	case PhysicalType::UINT8:
-		new_value.value_.utinyint = deserializer.ReadProperty<uint8_t>(102, "value");
-		break;
-	case PhysicalType::INT8:
-		new_value.value_.tinyint = deserializer.ReadProperty<int8_t>(102, "value");
-		break;
-	case PhysicalType::UINT16:
-		new_value.value_.usmallint = deserializer.ReadProperty<uint16_t>(102, "value");
-		break;
-	case PhysicalType::INT16:
-		new_value.value_.smallint = deserializer.ReadProperty<int16_t>(102, "value");
-		break;
-	case PhysicalType::UINT32:
-		new_value.value_.uinteger = deserializer.ReadProperty<uint32_t>(102, "value");
-		break;
-	case PhysicalType::INT32:
-		new_value.value_.integer = deserializer.ReadProperty<int32_t>(102, "value");
-		break;
-	case PhysicalType::UINT64:
-		new_value.value_.ubigint = deserializer.ReadProperty<uint64_t>(102, "value");
-		break;
-	case PhysicalType::INT64:
-		new_value.value_.bigint = deserializer.ReadProperty<int64_t>(102, "value");
-		break;
-	case PhysicalType::UINT128:
-		new_value.value_.uhugeint = deserializer.ReadProperty<uhugeint_t>(102, "value");
-		break;
-	case PhysicalType::INT128:
-		new_value.value_.hugeint = deserializer.ReadProperty<hugeint_t>(102, "value");
-		break;
-	case PhysicalType::FLOAT:
-		new_value.value_.float_ = deserializer.ReadProperty<float>(102, "value");
-		break;
-	case PhysicalType::DOUBLE:
-		new_value.value_.double_ = deserializer.ReadProperty<double>(102, "value");
-		break;
-	case PhysicalType::INTERVAL:
-		new_value.value_.interval = deserializer.ReadProperty<interval_t>(102, "value");
-		break;
-	case PhysicalType::VARCHAR: {
-		auto str = deserializer.ReadProperty<string>(102, "value");
-		if (type.id() == LogicalTypeId::BLOB) {
-			new_value.value_info_ = make_shared_ptr<StringValueInfo>(Blob::ToBlob(str));
-		} else {
-			new_value.value_info_ = make_shared_ptr<StringValueInfo>(str);
-		}
-	} break;
-	case PhysicalType::LIST: {
-		deserializer.Set<const LogicalType &>(ListType::GetChildType(type));
-		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
-			auto children = obj.ReadProperty<vector<Value>>(100, "children");
-			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
-		});
-		deserializer.Unset<LogicalType>();
-	} break;
-	case PhysicalType::STRUCT: {
-		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
-			vector<Value> children;
-			obj.ReadList(100, "children", [&](Deserializer::List &list, idx_t i) {
-				deserializer.Set<const LogicalType &>(StructType::GetChildType(type, i));
-				auto child = list.ReadElement<Value>();
-				deserializer.Unset<LogicalType>();
-				children.push_back(std::move(child));
-			});
-			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
-		});
-	} break;
-	case PhysicalType::ARRAY: {
-		deserializer.Set<const LogicalType &>(ArrayType::GetChildType(type));
-		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
-			auto children = obj.ReadProperty<vector<Value>>(100, "children");
-			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
-		});
-		deserializer.Unset<LogicalType>();
-	} break;
-	default:
-		throw NotImplementedException("Unimplemented type for Deserialize");
-	}
-	return new_value;
-}
-
-void Value::Print() const {
-	Printer::Print(ToString());
-}
-
-bool Value::NotDistinctFrom(const Value &lvalue, const Value &rvalue) {
-	return ValueOperations::NotDistinctFrom(lvalue, rvalue);
-}
-
-static string SanitizeValue(string input) {
-	// some results might contain padding spaces, e.g. when rendering
-	// VARCHAR(10) and the string only has 6 characters, they will be padded
-	// with spaces to 10 in the rendering. We don't do that here yet as we
-	// are looking at internal structures. So just ignore any extra spaces
-	// on the right
-	StringUtil::RTrim(input);
-	// for result checking code, replace null bytes with their escaped value (\0)
-	return StringUtil::Replace(input, string("\0", 1), "\\0");
-}
-
-bool Value::ValuesAreEqual(CastFunctionSet &set, GetCastFunctionInput &get_input, const Value &result_value,
-                           const Value &value) {
-	if (result_value.IsNull() != value.IsNull()) {
-		return false;
-	}
-	if (result_value.IsNull() && value.IsNull()) {
-		// NULL = NULL in checking code
-		return true;
-	}
-	switch (value.type_.id()) {
-	case LogicalTypeId::FLOAT: {
-		auto other = result_value.CastAs(set, get_input, LogicalType::FLOAT);
-		float ldecimal = value.value_.float_;
-		float rdecimal = other.value_.float_;
-		return ApproxEqual(ldecimal, rdecimal);
-	}
-	case LogicalTypeId::DOUBLE: {
-		auto other = result_value.CastAs(set, get_input, LogicalType::DOUBLE);
-		double ldecimal = value.value_.double_;
-		double rdecimal = other.value_.double_;
-		return ApproxEqual(ldecimal, rdecimal);
-	}
-	case LogicalTypeId::VARCHAR: {
-		auto other = result_value.CastAs(set, get_input, LogicalType::VARCHAR);
-		string left = SanitizeValue(StringValue::Get(other));
-		string right = SanitizeValue(StringValue::Get(value));
-		return left == right;
-	}
-	default:
-		if (result_value.type_.id() == LogicalTypeId::FLOAT || result_value.type_.id() == LogicalTypeId::DOUBLE) {
-			return Value::ValuesAreEqual(set, get_input, value, result_value);
-		}
-		return value == result_value;
-	}
-}
-
-bool Value::ValuesAreEqual(ClientContext &context, const Value &result_value, const Value &value) {
-	GetCastFunctionInput get_input(context);
-	return Value::ValuesAreEqual(CastFunctionSet::Get(context), get_input, result_value, value);
-}
-bool Value::DefaultValuesAreEqual(const Value &result_value, const Value &value) {
-	CastFunctionSet set;
-	GetCastFunctionInput get_input;
-	return Value::ValuesAreEqual(set, get_input, result_value, value);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/varint.cpp b/src/duckdb/src/common/types/varint.cpp
deleted file mode 100644
index b92ded113..000000000
--- a/src/duckdb/src/common/types/varint.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-#include "duckdb/common/types/varint.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-void Varint::Verify(const string_t &input) {
-#ifdef DEBUG
-	// Size must be >= 4
-	idx_t varint_bytes = input.GetSize();
-	if (varint_bytes < 4) {
-		throw InternalException("Varint number of bytes is invalid, current number of bytes is %d", varint_bytes);
-	}
-	// Bytes in header must quantify the number of data bytes
-	auto varint_ptr = input.GetData();
-	bool is_negative = (varint_ptr[0] & 0x80) == 0;
-	uint32_t number_of_bytes = 0;
-	char mask = 0x7F;
-	if (is_negative) {
-		number_of_bytes |= static_cast<uint32_t>(~varint_ptr[0] & mask) << 16 & 0xFF0000;
-		number_of_bytes |= static_cast<uint32_t>(~varint_ptr[1]) << 8 & 0xFF00;
-		;
-		number_of_bytes |= static_cast<uint32_t>(~varint_ptr[2]) & 0xFF;
-	} else {
-		number_of_bytes |= static_cast<uint32_t>(varint_ptr[0] & mask) << 16 & 0xFF0000;
-		number_of_bytes |= static_cast<uint32_t>(varint_ptr[1]) << 8 & 0xFF00;
-		number_of_bytes |= static_cast<uint32_t>(varint_ptr[2]) & 0xFF;
-	}
-	if (number_of_bytes != varint_bytes - 3) {
-		throw InternalException("The number of bytes set in the Varint header: %d bytes. Does not "
-		                        "match the number of bytes encountered as the varint data: %d bytes.",
-		                        number_of_bytes, varint_bytes - 3);
-	}
-	//  No bytes between 4 and end can be 0, unless total size == 4
-	if (varint_bytes > 4) {
-		if (is_negative) {
-			if (~varint_ptr[3] == 0) {
-				throw InternalException("Invalid top data bytes set to 0 for VARINT values");
-			}
-		} else {
-			if (varint_ptr[3] == 0) {
-				throw InternalException("Invalid top data bytes set to 0 for VARINT values");
-			}
-		}
-	}
-#endif
-}
-void Varint::SetHeader(char *blob, uint64_t number_of_bytes, bool is_negative) {
-	uint32_t header = static_cast<uint32_t>(number_of_bytes);
-	// Set MSBit of 3rd byte
-	header |= 0x00800000;
-	if (is_negative) {
-		header = ~header;
-	}
-	// we ignore MSByte  of header.
-	// write the 3 bytes to blob.
-	blob[0] = static_cast<char>(header >> 16);
-	blob[1] = static_cast<char>(header >> 8 & 0xFF);
-	blob[2] = static_cast<char>(header & 0xFF);
-}
-
-// Creates a blob representing the value 0
-string_t Varint::InitializeVarintZero(Vector &result) {
-	uint32_t blob_size = 1 + VARINT_HEADER_SIZE;
-	auto blob = StringVector::EmptyString(result, blob_size);
-	auto writable_blob = blob.GetDataWriteable();
-	SetHeader(writable_blob, 1, false);
-	writable_blob[3] = 0;
-	blob.Finalize();
-	return blob;
-}
-
-string Varint::InitializeVarintZero() {
-	uint32_t blob_size = 1 + VARINT_HEADER_SIZE;
-	string result(blob_size, '0');
-	SetHeader(&result[0], 1, false);
-	result[3] = 0;
-	return result;
-}
-
-int Varint::CharToDigit(char c) {
-	return c - '0';
-}
-
-char Varint::DigitToChar(int digit) {
-	// FIXME: this would be the proper solution:
-	// return UnsafeNumericCast<char>(digit + '0');
-	return static_cast<char>(digit + '0');
-}
-
-bool Varint::VarcharFormatting(const string_t &value, idx_t &start_pos, idx_t &end_pos, bool &is_negative,
-                               bool &is_zero) {
-	// If it's empty we error
-	if (value.Empty()) {
-		return false;
-	}
-	start_pos = 0;
-	is_zero = false;
-
-	auto int_value_char = value.GetData();
-	end_pos = value.GetSize();
-
-	// If first character is -, we have a negative number, if + we have a + number
-	is_negative = int_value_char[0] == '-';
-	if (is_negative) {
-		start_pos++;
-	}
-	if (int_value_char[0] == '+') {
-		start_pos++;
-	}
-	// Now lets trim 0s
-	bool at_least_one_zero = false;
-	while (start_pos < end_pos && int_value_char[start_pos] == '0') {
-		start_pos++;
-		at_least_one_zero = true;
-	}
-	if (start_pos == end_pos) {
-		if (at_least_one_zero) {
-			// This is a 0 value
-			is_zero = true;
-			return true;
-		}
-		// This is either a '+' or '-'. Hence, invalid.
-		return false;
-	}
-	idx_t cur_pos = start_pos;
-	// Verify all is numeric
-	while (cur_pos < end_pos && std::isdigit(int_value_char[cur_pos])) {
-		cur_pos++;
-	}
-	if (cur_pos < end_pos) {
-		idx_t possible_end = cur_pos;
-		// Oh oh, this is not a digit, if it's a . we might be fine, otherwise, this is invalid.
-		if (int_value_char[cur_pos] == '.') {
-			cur_pos++;
-		} else {
-			return false;
-		}
-
-		while (cur_pos < end_pos) {
-			if (std::isdigit(int_value_char[cur_pos])) {
-				cur_pos++;
-			} else {
-				// By now we can only have numbers, otherwise this is invalid.
-				return false;
-			}
-		}
-		// Floor cast this boy
-		end_pos = possible_end;
-	}
-	return true;
-}
-
-void Varint::GetByteArray(vector<uint8_t> &byte_array, bool &is_negative, const string_t &blob) {
-	if (blob.GetSize() < 4) {
-		throw InvalidInputException("Invalid blob size.");
-	}
-	auto blob_ptr = blob.GetData();
-
-	// Determine if the number is negative
-	is_negative = (blob_ptr[0] & 0x80) == 0;
-	for (idx_t i = 3; i < blob.GetSize(); i++) {
-		if (is_negative) {
-			byte_array.push_back(static_cast<uint8_t>(~blob_ptr[i]));
-		} else {
-			byte_array.push_back(static_cast<uint8_t>(blob_ptr[i]));
-		}
-	}
-}
-
-string Varint::FromByteArray(uint8_t *data, idx_t size, bool is_negative) {
-	string result(VARINT_HEADER_SIZE + size, '0');
-	SetHeader(&result[0], size, is_negative);
-	uint8_t *result_data = reinterpret_cast<uint8_t *>(&result[VARINT_HEADER_SIZE]);
-	if (is_negative) {
-		for (idx_t i = 0; i < size; i++) {
-			result_data[i] = ~data[i];
-		}
-	} else {
-		for (idx_t i = 0; i < size; i++) {
-			result_data[i] = data[i];
-		}
-	}
-	return result;
-}
-
-string Varint::VarIntToVarchar(const string_t &blob) {
-	string decimal_string;
-	vector<uint8_t> byte_array;
-	bool is_negative;
-	GetByteArray(byte_array, is_negative, blob);
-	while (!byte_array.empty()) {
-		string quotient;
-		uint8_t remainder = 0;
-		for (uint8_t byte : byte_array) {
-			int new_value = remainder * 256 + byte;
-			quotient += DigitToChar(new_value / 10);
-			remainder = static_cast<uint8_t>(new_value % 10);
-		}
-		decimal_string += DigitToChar(remainder);
-		// Remove leading zeros from the quotient
-		byte_array.clear();
-		for (char digit : quotient) {
-			if (digit != '0' || !byte_array.empty()) {
-				byte_array.push_back(static_cast<uint8_t>(CharToDigit(digit)));
-			}
-		}
-	}
-	if (is_negative) {
-		decimal_string += '-';
-	}
-	// Reverse the string to get the correct decimal representation
-	std::reverse(decimal_string.begin(), decimal_string.end());
-	return decimal_string;
-}
-
-string Varint::VarcharToVarInt(const string_t &value) {
-	idx_t start_pos, end_pos;
-	bool is_negative, is_zero;
-	if (!VarcharFormatting(value, start_pos, end_pos, is_negative, is_zero)) {
-		throw ConversionException("Could not convert string \'%s\' to Varint", value.GetString());
-	}
-	if (is_zero) {
-		// Return Value 0
-		return InitializeVarintZero();
-	}
-	auto int_value_char = value.GetData();
-	idx_t actual_size = end_pos - start_pos;
-
-	// we initalize result with space for our header
-	string result(VARINT_HEADER_SIZE, '0');
-	unsafe_vector<uint64_t> digits;
-
-	// The max number a uint64_t can represent is 18.446.744.073.709.551.615
-	// That has 20 digits
-	// In the worst case a remainder of a division will be 255, which is 3 digits
-	// Since the max value is 184, we need to take one more digit out
-	// Hence we end up with a max of 16 digits supported.
-	constexpr uint8_t max_digits = 16;
-	const idx_t number_of_digits = static_cast<idx_t>(std::ceil(static_cast<double>(actual_size) / max_digits));
-
-	// lets convert the string to a uint64_t vector
-	idx_t cur_end = end_pos;
-	for (idx_t i = 0; i < number_of_digits; i++) {
-		idx_t cur_start = static_cast<int64_t>(start_pos) > static_cast<int64_t>(cur_end - max_digits)
-		                      ? start_pos
-		                      : cur_end - max_digits;
-		std::string current_number(int_value_char + cur_start, cur_end - cur_start);
-		digits.push_back(std::stoull(current_number));
-		// move cur_end to more digits down the road
-		cur_end = cur_end - max_digits;
-	}
-
-	// Now that we have our uint64_t vector, lets start our division process to figure out the new number and remainder
-	while (!digits.empty()) {
-		idx_t digit_idx = digits.size() - 1;
-		uint8_t remainder = 0;
-		idx_t digits_size = digits.size();
-		for (idx_t i = 0; i < digits_size; i++) {
-			digits[digit_idx] += static_cast<uint64_t>(remainder * pow(10, max_digits));
-			remainder = static_cast<uint8_t>(digits[digit_idx] % 256);
-			digits[digit_idx] /= 256;
-			if (digits[digit_idx] == 0 && digit_idx == digits.size() - 1) {
-				// we can cap this
-				digits.pop_back();
-			}
-			digit_idx--;
-		}
-		if (is_negative) {
-			result.push_back(static_cast<char>(~remainder));
-		} else {
-			result.push_back(static_cast<char>(remainder));
-		}
-	}
-	std::reverse(result.begin() + VARINT_HEADER_SIZE, result.end());
-	// Set header after we know the size of the varint
-	SetHeader(&result[0], result.size() - VARINT_HEADER_SIZE, is_negative);
-	return result;
-}
-
-bool Varint::VarintToDouble(const string_t &blob, double &result, bool &strict) {
-	result = 0;
-
-	if (blob.GetSize() < 4) {
-		throw InvalidInputException("Invalid blob size.");
-	}
-	auto blob_ptr = blob.GetData();
-
-	// Determine if the number is negative
-	bool is_negative = (blob_ptr[0] & 0x80) == 0;
-	idx_t byte_pos = 0;
-	for (idx_t i = blob.GetSize() - 1; i > 2; i--) {
-		if (is_negative) {
-			result += static_cast<uint8_t>(~blob_ptr[i]) * pow(256, static_cast<double>(byte_pos));
-		} else {
-			result += static_cast<uint8_t>(blob_ptr[i]) * pow(256, static_cast<double>(byte_pos));
-		}
-		byte_pos++;
-	}
-
-	if (is_negative) {
-		result *= -1;
-	}
-	if (!std::isfinite(result)) {
-		// We throw an error
-		throw ConversionException("Could not convert varint '%s' to Double", VarIntToVarchar(blob));
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/vector.cpp b/src/duckdb/src/common/types/vector.cpp
deleted file mode 100644
index 722b8b699..000000000
--- a/src/duckdb/src/common/types/vector.cpp
+++ /dev/null
@@ -1,2661 +0,0 @@
-#include "duckdb/common/types/vector.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/fsst.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/sel_cache.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/value_map.hpp"
-#include "duckdb/common/types/varint.hpp"
-#include "duckdb/common/types/vector_cache.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/string_uncompressed.hpp"
-#include "fsst.h"
-
-#include <cstring> // strlen() on Solaris
-
-namespace duckdb {
-
-UnifiedVectorFormat::UnifiedVectorFormat() : sel(nullptr), data(nullptr) {
-}
-
-UnifiedVectorFormat::UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept : sel(nullptr), data(nullptr) {
-	bool refers_to_self = other.sel == &other.owned_sel;
-	std::swap(sel, other.sel);
-	std::swap(data, other.data);
-	std::swap(validity, other.validity);
-	std::swap(owned_sel, other.owned_sel);
-	if (refers_to_self) {
-		sel = &owned_sel;
-	}
-}
-
-UnifiedVectorFormat &UnifiedVectorFormat::operator=(UnifiedVectorFormat &&other) noexcept {
-	bool refers_to_self = other.sel == &other.owned_sel;
-	std::swap(sel, other.sel);
-	std::swap(data, other.data);
-	std::swap(validity, other.validity);
-	std::swap(owned_sel, other.owned_sel);
-	if (refers_to_self) {
-		sel = &owned_sel;
-	}
-	return *this;
-}
-
-Vector::Vector(LogicalType type_p, bool create_data, bool initialize_to_zero, idx_t capacity)
-    : vector_type(VectorType::FLAT_VECTOR), type(std::move(type_p)), data(nullptr), validity(capacity) {
-	if (create_data) {
-		Initialize(initialize_to_zero, capacity);
-	}
-}
-
-Vector::Vector(LogicalType type_p, idx_t capacity) : Vector(std::move(type_p), true, false, capacity) {
-}
-
-Vector::Vector(LogicalType type_p, data_ptr_t dataptr)
-    : vector_type(VectorType::FLAT_VECTOR), type(std::move(type_p)), data(dataptr) {
-	if (dataptr && !type.IsValid()) {
-		throw InternalException("Cannot create a vector of type INVALID!");
-	}
-}
-
-Vector::Vector(const VectorCache &cache) : type(cache.GetType()) {
-	ResetFromCache(cache);
-}
-
-Vector::Vector(Vector &other) : type(other.type) {
-	Reference(other);
-}
-
-Vector::Vector(const Vector &other, const SelectionVector &sel, idx_t count) : type(other.type) {
-	Slice(other, sel, count);
-}
-
-Vector::Vector(const Vector &other, idx_t offset, idx_t end) : type(other.type) {
-	Slice(other, offset, end);
-}
-
-Vector::Vector(const Value &value) : type(value.type()) {
-	Reference(value);
-}
-
-Vector::Vector(Vector &&other) noexcept
-    : vector_type(other.vector_type), type(std::move(other.type)), data(other.data),
-      validity(std::move(other.validity)), buffer(std::move(other.buffer)), auxiliary(std::move(other.auxiliary)) {
-}
-
-void Vector::Reference(const Value &value) {
-	D_ASSERT(GetType().id() == value.type().id());
-	this->vector_type = VectorType::CONSTANT_VECTOR;
-	buffer = VectorBuffer::CreateConstantVector(value.type());
-	auto internal_type = value.type().InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		auto struct_buffer = make_uniq<VectorStructBuffer>();
-		auto &child_types = StructType::GetChildTypes(value.type());
-		auto &child_vectors = struct_buffer->GetChildren();
-		for (idx_t i = 0; i < child_types.size(); i++) {
-			auto vector =
-			    make_uniq<Vector>(value.IsNull() ? Value(child_types[i].second) : StructValue::GetChildren(value)[i]);
-			child_vectors.push_back(std::move(vector));
-		}
-		auxiliary = shared_ptr<VectorBuffer>(struct_buffer.release());
-		if (value.IsNull()) {
-			SetValue(0, value);
-		}
-	} else if (internal_type == PhysicalType::LIST) {
-		auto list_buffer = make_uniq<VectorListBuffer>(value.type());
-		auxiliary = shared_ptr<VectorBuffer>(list_buffer.release());
-		data = buffer->GetData();
-		SetValue(0, value);
-	} else if (internal_type == PhysicalType::ARRAY) {
-		auto array_buffer = make_uniq<VectorArrayBuffer>(value.type());
-		auxiliary = shared_ptr<VectorBuffer>(array_buffer.release());
-		SetValue(0, value);
-	} else {
-		auxiliary.reset();
-		data = buffer->GetData();
-		SetValue(0, value);
-	}
-}
-
-void Vector::Reference(const Vector &other) {
-	if (other.GetType().id() != GetType().id()) {
-		throw InternalException("Vector::Reference used on vector of different type");
-	}
-	D_ASSERT(other.GetType() == GetType());
-	Reinterpret(other);
-}
-
-void Vector::ReferenceAndSetType(const Vector &other) {
-	type = other.GetType();
-	Reference(other);
-}
-
-void Vector::Reinterpret(const Vector &other) {
-	vector_type = other.vector_type;
-#ifdef DEBUG
-	auto &this_type = GetType();
-	auto &other_type = other.GetType();
-
-	auto type_is_same = other_type == this_type;
-	bool this_is_nested = this_type.IsNested();
-	bool other_is_nested = other_type.IsNested();
-
-	bool not_nested = this_is_nested == false && other_is_nested == false;
-	bool type_size_equal = GetTypeIdSize(this_type.InternalType()) == GetTypeIdSize(other_type.InternalType());
-	//! Either the types are completely identical, or they are not nested and their physical type size is the same
-	//! The reason nested types are not allowed is because copying the auxiliary buffer does not happen recursively
-	//! e.g DOUBLE[] to BIGINT[], the type of the LIST would say BIGINT but the child Vector says DOUBLE
-	D_ASSERT((not_nested && type_size_equal) || type_is_same);
-#endif
-	AssignSharedPointer(buffer, other.buffer);
-	AssignSharedPointer(auxiliary, other.auxiliary);
-	data = other.data;
-	validity = other.validity;
-}
-
-void Vector::ResetFromCache(const VectorCache &cache) {
-	cache.ResetFromCache(*this);
-}
-
-void Vector::Slice(const Vector &other, idx_t offset, idx_t end) {
-	D_ASSERT(end >= offset);
-	if (other.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		Reference(other);
-		return;
-	}
-	if (other.GetVectorType() != VectorType::FLAT_VECTOR) {
-		// we can slice the data directly only for flat vectors
-		// for non-flat vectors slice using a selection vector instead
-		idx_t count = end - offset;
-		SelectionVector sel(count);
-		for (idx_t i = 0; i < count; i++) {
-			sel.set_index(i, offset + i);
-		}
-		Slice(other, sel, count);
-		return;
-	}
-
-	auto internal_type = GetType().InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		Vector new_vector(GetType());
-		auto &entries = StructVector::GetEntries(new_vector);
-		auto &other_entries = StructVector::GetEntries(other);
-		D_ASSERT(entries.size() == other_entries.size());
-		for (idx_t i = 0; i < entries.size(); i++) {
-			entries[i]->Slice(*other_entries[i], offset, end);
-		}
-		new_vector.validity.Slice(other.validity, offset, end - offset);
-		Reference(new_vector);
-	} else if (internal_type == PhysicalType::ARRAY) {
-		Vector new_vector(GetType());
-		auto &child_vec = ArrayVector::GetEntry(new_vector);
-		auto &other_child_vec = ArrayVector::GetEntry(other);
-		D_ASSERT(ArrayType::GetSize(GetType()) == ArrayType::GetSize(other.GetType()));
-		const auto array_size = ArrayType::GetSize(GetType());
-		// We need to slice the child vector with the multiplied offset and end
-		child_vec.Slice(other_child_vec, offset * array_size, end * array_size);
-		new_vector.validity.Slice(other.validity, offset, end - offset);
-		Reference(new_vector);
-	} else {
-		Reference(other);
-		if (offset > 0) {
-			data = data + GetTypeIdSize(internal_type) * offset;
-			validity.Slice(other.validity, offset, end - offset);
-		}
-	}
-}
-
-void Vector::Slice(const Vector &other, const SelectionVector &sel, idx_t count) {
-	Reference(other);
-	Slice(sel, count);
-}
-
-void Vector::Slice(const SelectionVector &sel, idx_t count) {
-	if (GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// dictionary on a constant is just a constant
-		return;
-	}
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		// already a dictionary, slice the current dictionary
-		auto &current_sel = DictionaryVector::SelVector(*this);
-		auto dictionary_size = DictionaryVector::DictionarySize(*this);
-		auto dictionary_id = DictionaryVector::DictionaryId(*this);
-		auto sliced_dictionary = current_sel.Slice(sel, count);
-		buffer = make_buffer<DictionaryBuffer>(std::move(sliced_dictionary));
-		if (GetType().InternalType() == PhysicalType::STRUCT) {
-			auto &child_vector = DictionaryVector::Child(*this);
-
-			Vector new_child(child_vector);
-			new_child.auxiliary = make_buffer<VectorStructBuffer>(new_child, sel, count);
-			auxiliary = make_buffer<VectorChildBuffer>(std::move(new_child));
-		}
-		if (dictionary_size.IsValid()) {
-			auto &dict_buffer = buffer->Cast<DictionaryBuffer>();
-			dict_buffer.SetDictionarySize(dictionary_size.GetIndex());
-			dict_buffer.SetDictionaryId(std::move(dictionary_id));
-		}
-		return;
-	}
-
-	if (GetVectorType() == VectorType::FSST_VECTOR) {
-		Flatten(sel, count);
-		return;
-	}
-
-	Vector child_vector(*this);
-	auto internal_type = GetType().InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		child_vector.auxiliary = make_buffer<VectorStructBuffer>(*this, sel, count);
-	}
-	auto child_ref = make_buffer<VectorChildBuffer>(std::move(child_vector));
-	auto dict_buffer = make_buffer<DictionaryBuffer>(sel);
-	vector_type = VectorType::DICTIONARY_VECTOR;
-	buffer = std::move(dict_buffer);
-	auxiliary = std::move(child_ref);
-}
-
-void Vector::Dictionary(idx_t dictionary_size, const SelectionVector &sel, idx_t count) {
-	Slice(sel, count);
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		buffer->Cast<DictionaryBuffer>().SetDictionarySize(dictionary_size);
-	}
-}
-
-void Vector::Dictionary(const Vector &dict, idx_t dictionary_size, const SelectionVector &sel, idx_t count) {
-	Reference(dict);
-	Dictionary(dictionary_size, sel, count);
-}
-
-void Vector::Slice(const SelectionVector &sel, idx_t count, SelCache &cache) {
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR && GetType().InternalType() != PhysicalType::STRUCT) {
-		// dictionary vector: need to merge dictionaries
-		// check if we have a cached entry
-		auto &current_sel = DictionaryVector::SelVector(*this);
-		auto dictionary_size = DictionaryVector::DictionarySize(*this);
-		auto dictionary_id = DictionaryVector::DictionaryId(*this);
-		auto target_data = current_sel.data();
-		auto entry = cache.cache.find(target_data);
-		if (entry != cache.cache.end()) {
-			// cached entry exists: use that
-			this->buffer = make_buffer<DictionaryBuffer>(entry->second->Cast<DictionaryBuffer>().GetSelVector());
-			vector_type = VectorType::DICTIONARY_VECTOR;
-		} else {
-			Slice(sel, count);
-			cache.cache[target_data] = this->buffer;
-		}
-		if (dictionary_size.IsValid()) {
-			auto &dict_buffer = buffer->Cast<DictionaryBuffer>();
-			dict_buffer.SetDictionarySize(dictionary_size.GetIndex());
-			dict_buffer.SetDictionaryId(std::move(dictionary_id));
-		}
-	} else {
-		Slice(sel, count);
-	}
-}
-
-void Vector::Initialize(bool initialize_to_zero, idx_t capacity) {
-	auxiliary.reset();
-	validity.Reset();
-	auto &type = GetType();
-	auto internal_type = type.InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		auto struct_buffer = make_uniq<VectorStructBuffer>(type, capacity);
-		auxiliary = shared_ptr<VectorBuffer>(struct_buffer.release());
-	} else if (internal_type == PhysicalType::LIST) {
-		auto list_buffer = make_uniq<VectorListBuffer>(type, capacity);
-		auxiliary = shared_ptr<VectorBuffer>(list_buffer.release());
-	} else if (internal_type == PhysicalType::ARRAY) {
-		auto array_buffer = make_uniq<VectorArrayBuffer>(type, capacity);
-		auxiliary = shared_ptr<VectorBuffer>(array_buffer.release());
-	}
-	auto type_size = GetTypeIdSize(internal_type);
-	if (type_size > 0) {
-		buffer = VectorBuffer::CreateStandardVector(type, capacity);
-		data = buffer->GetData();
-		if (initialize_to_zero) {
-			memset(data, 0, capacity * type_size);
-		}
-	}
-
-	if (capacity > validity.Capacity()) {
-		validity.Resize(capacity);
-	}
-}
-
-void Vector::FindResizeInfos(vector<ResizeInfo> &resize_infos, const idx_t multiplier) {
-
-	ResizeInfo resize_info(*this, data, buffer.get(), multiplier);
-	resize_infos.emplace_back(resize_info);
-
-	// Base case.
-	if (data) {
-		return;
-	}
-
-	D_ASSERT(auxiliary);
-	switch (GetAuxiliary()->GetBufferType()) {
-	case VectorBufferType::LIST_BUFFER: {
-		auto &vector_list_buffer = auxiliary->Cast<VectorListBuffer>();
-		auto &child = vector_list_buffer.GetChild();
-		child.FindResizeInfos(resize_infos, multiplier);
-		break;
-	}
-	case VectorBufferType::STRUCT_BUFFER: {
-		auto &vector_struct_buffer = auxiliary->Cast<VectorStructBuffer>();
-		auto &children = vector_struct_buffer.GetChildren();
-		for (auto &child : children) {
-			child->FindResizeInfos(resize_infos, multiplier);
-		}
-		break;
-	}
-	case VectorBufferType::ARRAY_BUFFER: {
-		// We need to multiply the multiplier by the array size because
-		// the child vectors of ARRAY types are always child_count * array_size.
-		auto &vector_array_buffer = auxiliary->Cast<VectorArrayBuffer>();
-		auto new_multiplier = vector_array_buffer.GetArraySize() * multiplier;
-		auto &child = vector_array_buffer.GetChild();
-		child.FindResizeInfos(resize_infos, new_multiplier);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-void Vector::Resize(idx_t current_size, idx_t new_size) {
-	// The vector does not contain any data.
-	if (!buffer) {
-		buffer = make_buffer<VectorBuffer>(0);
-	}
-
-	// Obtain the resize information for each (nested) vector.
-	vector<ResizeInfo> resize_infos;
-	FindResizeInfos(resize_infos, 1);
-
-	for (auto &resize_info_entry : resize_infos) {
-		// Resize the validity mask.
-		auto new_validity_size = new_size * resize_info_entry.multiplier;
-		resize_info_entry.vec.validity.Resize(new_validity_size);
-
-		// For nested data types, we only need to resize the validity mask.
-		if (!resize_info_entry.data) {
-			continue;
-		}
-
-		auto type_size = GetTypeIdSize(resize_info_entry.vec.GetType().InternalType());
-		auto old_size = current_size * type_size * resize_info_entry.multiplier * sizeof(data_t);
-		auto target_size = new_size * type_size * resize_info_entry.multiplier * sizeof(data_t);
-
-		// We have an upper limit of 128GB for a single vector.
-		if (target_size > DConstants::MAX_VECTOR_SIZE) {
-			throw OutOfRangeException("Cannot resize vector to %s: maximum allowed vector size is %s",
-			                          StringUtil::BytesToHumanReadableString(target_size),
-			                          StringUtil::BytesToHumanReadableString(DConstants::MAX_VECTOR_SIZE));
-		}
-
-		// Copy the data buffer to a resized buffer.
-		auto new_data = make_unsafe_uniq_array_uninitialized<data_t>(target_size);
-		memcpy(new_data.get(), resize_info_entry.data, old_size);
-		resize_info_entry.buffer->SetData(std::move(new_data));
-		resize_info_entry.vec.data = resize_info_entry.buffer->GetData();
-	}
-}
-
-static bool IsStructOrArrayRecursive(const LogicalType &type) {
-	return TypeVisitor::Contains(type, [](const LogicalType &type) {
-		auto physical_type = type.InternalType();
-		return (physical_type == PhysicalType::STRUCT || physical_type == PhysicalType::ARRAY);
-	});
-}
-
-void Vector::SetValue(idx_t index, const Value &val) {
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		// dictionary: apply dictionary and forward to child
-		auto &sel_vector = DictionaryVector::SelVector(*this);
-		auto &child = DictionaryVector::Child(*this);
-		return child.SetValue(sel_vector.get_index(index), val);
-	}
-	if (!val.IsNull() && val.type() != GetType()) {
-		SetValue(index, val.DefaultCastAs(GetType()));
-		return;
-	}
-	D_ASSERT(val.IsNull() || (val.type().InternalType() == GetType().InternalType()));
-
-	validity.EnsureWritable();
-	validity.Set(index, !val.IsNull());
-	auto physical_type = GetType().InternalType();
-	if (val.IsNull() && !IsStructOrArrayRecursive(GetType())) {
-		// for structs and arrays we still need to set the child-entries to NULL
-		// so we do not bail out yet
-		return;
-	}
-
-	switch (physical_type) {
-	case PhysicalType::BOOL:
-		reinterpret_cast<bool *>(data)[index] = val.GetValueUnsafe<bool>();
-		break;
-	case PhysicalType::INT8:
-		reinterpret_cast<int8_t *>(data)[index] = val.GetValueUnsafe<int8_t>();
-		break;
-	case PhysicalType::INT16:
-		reinterpret_cast<int16_t *>(data)[index] = val.GetValueUnsafe<int16_t>();
-		break;
-	case PhysicalType::INT32:
-		reinterpret_cast<int32_t *>(data)[index] = val.GetValueUnsafe<int32_t>();
-		break;
-	case PhysicalType::INT64:
-		reinterpret_cast<int64_t *>(data)[index] = val.GetValueUnsafe<int64_t>();
-		break;
-	case PhysicalType::INT128:
-		reinterpret_cast<hugeint_t *>(data)[index] = val.GetValueUnsafe<hugeint_t>();
-		break;
-	case PhysicalType::UINT8:
-		reinterpret_cast<uint8_t *>(data)[index] = val.GetValueUnsafe<uint8_t>();
-		break;
-	case PhysicalType::UINT16:
-		reinterpret_cast<uint16_t *>(data)[index] = val.GetValueUnsafe<uint16_t>();
-		break;
-	case PhysicalType::UINT32:
-		reinterpret_cast<uint32_t *>(data)[index] = val.GetValueUnsafe<uint32_t>();
-		break;
-	case PhysicalType::UINT64:
-		reinterpret_cast<uint64_t *>(data)[index] = val.GetValueUnsafe<uint64_t>();
-		break;
-	case PhysicalType::UINT128:
-		reinterpret_cast<uhugeint_t *>(data)[index] = val.GetValueUnsafe<uhugeint_t>();
-		break;
-	case PhysicalType::FLOAT:
-		reinterpret_cast<float *>(data)[index] = val.GetValueUnsafe<float>();
-		break;
-	case PhysicalType::DOUBLE:
-		reinterpret_cast<double *>(data)[index] = val.GetValueUnsafe<double>();
-		break;
-	case PhysicalType::INTERVAL:
-		reinterpret_cast<interval_t *>(data)[index] = val.GetValueUnsafe<interval_t>();
-		break;
-	case PhysicalType::VARCHAR: {
-		if (!val.IsNull()) {
-			reinterpret_cast<string_t *>(data)[index] = StringVector::AddStringOrBlob(*this, StringValue::Get(val));
-		}
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		D_ASSERT(GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR);
-
-		auto &children = StructVector::GetEntries(*this);
-		if (val.IsNull()) {
-			for (size_t i = 0; i < children.size(); i++) {
-				auto &vec_child = children[i];
-				vec_child->SetValue(index, Value());
-			}
-		} else {
-			auto &val_children = StructValue::GetChildren(val);
-			D_ASSERT(children.size() == val_children.size());
-			for (size_t i = 0; i < children.size(); i++) {
-				auto &vec_child = children[i];
-				auto &struct_child = val_children[i];
-				vec_child->SetValue(index, struct_child);
-			}
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		auto offset = ListVector::GetListSize(*this);
-		if (val.IsNull()) {
-			auto &entry = reinterpret_cast<list_entry_t *>(data)[index];
-			ListVector::PushBack(*this, Value());
-			entry.length = 1;
-			entry.offset = offset;
-		} else {
-			auto &val_children = ListValue::GetChildren(val);
-			if (!val_children.empty()) {
-				for (idx_t i = 0; i < val_children.size(); i++) {
-					ListVector::PushBack(*this, val_children[i]);
-				}
-			}
-			//! now set the pointer
-			auto &entry = reinterpret_cast<list_entry_t *>(data)[index];
-			entry.length = val_children.size();
-			entry.offset = offset;
-		}
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		auto array_size = ArrayType::GetSize(GetType());
-		auto &child = ArrayVector::GetEntry(*this);
-		if (val.IsNull()) {
-			for (idx_t i = 0; i < array_size; i++) {
-				child.SetValue(index * array_size + i, Value());
-			}
-		} else {
-			auto &val_children = ArrayValue::GetChildren(val);
-			for (idx_t i = 0; i < array_size; i++) {
-				child.SetValue(index * array_size + i, val_children[i]);
-			}
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for Vector::SetValue");
-	}
-}
-
-Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
-	const Vector *vector = &v_p;
-	idx_t index = index_p;
-	bool finished = false;
-	while (!finished) {
-		switch (vector->GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR:
-			index = 0;
-			finished = true;
-			break;
-		case VectorType::FLAT_VECTOR:
-			finished = true;
-			break;
-		case VectorType::FSST_VECTOR:
-			finished = true;
-			break;
-		// dictionary: apply dictionary and forward to child
-		case VectorType::DICTIONARY_VECTOR: {
-			auto &sel_vector = DictionaryVector::SelVector(*vector);
-			auto &child = DictionaryVector::Child(*vector);
-			vector = &child;
-			index = sel_vector.get_index(index);
-			break;
-		}
-		case VectorType::SEQUENCE_VECTOR: {
-			int64_t start, increment;
-			SequenceVector::GetSequence(*vector, start, increment);
-			return Value::Numeric(vector->GetType(), start + increment * NumericCast<int64_t>(index));
-		}
-		default:
-			throw InternalException("Unimplemented vector type for Vector::GetValue");
-		}
-	}
-	auto data = vector->data;
-	auto &validity = vector->validity;
-	auto &type = vector->GetType();
-
-	if (!validity.RowIsValid(index)) {
-		return Value(vector->GetType());
-	}
-
-	if (vector->GetVectorType() == VectorType::FSST_VECTOR) {
-		if (vector->GetType().InternalType() != PhysicalType::VARCHAR) {
-			throw InternalException("FSST Vector with non-string datatype found!");
-		}
-		auto str_compressed = reinterpret_cast<string_t *>(data)[index];
-		auto decoder = FSSTVector::GetDecoder(*vector);
-		auto &decompress_buffer = FSSTVector::GetDecompressBuffer(*vector);
-		auto string_val = FSSTPrimitives::DecompressValue(decoder, str_compressed.GetData(), str_compressed.GetSize(),
-		                                                  decompress_buffer);
-		switch (vector->GetType().id()) {
-		case LogicalTypeId::VARCHAR:
-			return Value(std::move(string_val));
-		case LogicalTypeId::BLOB:
-			return Value::BLOB_RAW(string_val);
-		default:
-			throw InternalException("Unsupported vector type for FSST vector");
-		}
-	}
-
-	switch (vector->GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Value::BOOLEAN(reinterpret_cast<bool *>(data)[index]);
-	case LogicalTypeId::TINYINT:
-		return Value::TINYINT(reinterpret_cast<int8_t *>(data)[index]);
-	case LogicalTypeId::SMALLINT:
-		return Value::SMALLINT(reinterpret_cast<int16_t *>(data)[index]);
-	case LogicalTypeId::INTEGER:
-		return Value::INTEGER(reinterpret_cast<int32_t *>(data)[index]);
-	case LogicalTypeId::DATE:
-		return Value::DATE(reinterpret_cast<date_t *>(data)[index]);
-	case LogicalTypeId::TIME:
-		return Value::TIME(reinterpret_cast<dtime_t *>(data)[index]);
-	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(reinterpret_cast<dtime_tz_t *>(data)[index]);
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(reinterpret_cast<int64_t *>(data)[index]);
-	case LogicalTypeId::UTINYINT:
-		return Value::UTINYINT(reinterpret_cast<uint8_t *>(data)[index]);
-	case LogicalTypeId::USMALLINT:
-		return Value::USMALLINT(reinterpret_cast<uint16_t *>(data)[index]);
-	case LogicalTypeId::UINTEGER:
-		return Value::UINTEGER(reinterpret_cast<uint32_t *>(data)[index]);
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(reinterpret_cast<uint64_t *>(data)[index]);
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(reinterpret_cast<timestamp_t *>(data)[index]);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(reinterpret_cast<timestamp_ns_t *>(data)[index]);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(reinterpret_cast<timestamp_ms_t *>(data)[index]);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(reinterpret_cast<timestamp_sec_t *>(data)[index]);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(reinterpret_cast<timestamp_tz_t *>(data)[index]);
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(reinterpret_cast<hugeint_t *>(data)[index]);
-	case LogicalTypeId::UHUGEINT:
-		return Value::UHUGEINT(reinterpret_cast<uhugeint_t *>(data)[index]);
-	case LogicalTypeId::UUID:
-		return Value::UUID(reinterpret_cast<hugeint_t *>(data)[index]);
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(reinterpret_cast<int16_t *>(data)[index], width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(reinterpret_cast<int32_t *>(data)[index], width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(reinterpret_cast<int64_t *>(data)[index], width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(reinterpret_cast<hugeint_t *>(data)[index], width, scale);
-		default:
-			throw InternalException("Physical type '%s' has a width bigger than 38, which is not supported",
-			                        TypeIdToString(type.InternalType()));
-		}
-	}
-	case LogicalTypeId::ENUM: {
-		switch (type.InternalType()) {
-		case PhysicalType::UINT8:
-			return Value::ENUM(reinterpret_cast<uint8_t *>(data)[index], type);
-		case PhysicalType::UINT16:
-			return Value::ENUM(reinterpret_cast<uint16_t *>(data)[index], type);
-		case PhysicalType::UINT32:
-			return Value::ENUM(reinterpret_cast<uint32_t *>(data)[index], type);
-		default:
-			throw InternalException("ENUM can only have unsigned integers as physical types");
-		}
-	}
-	case LogicalTypeId::POINTER:
-		return Value::POINTER(reinterpret_cast<uintptr_t *>(data)[index]);
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(reinterpret_cast<float *>(data)[index]);
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(reinterpret_cast<double *>(data)[index]);
-	case LogicalTypeId::INTERVAL:
-		return Value::INTERVAL(reinterpret_cast<interval_t *>(data)[index]);
-	case LogicalTypeId::VARCHAR: {
-		auto str = reinterpret_cast<string_t *>(data)[index];
-		return Value(str.GetString());
-	}
-	case LogicalTypeId::BLOB: {
-		auto str = reinterpret_cast<string_t *>(data)[index];
-		return Value::BLOB(const_data_ptr_cast(str.GetData()), str.GetSize());
-	}
-	case LogicalTypeId::VARINT: {
-		auto str = reinterpret_cast<string_t *>(data)[index];
-		return Value::VARINT(const_data_ptr_cast(str.GetData()), str.GetSize());
-	}
-	case LogicalTypeId::AGGREGATE_STATE: {
-		auto str = reinterpret_cast<string_t *>(data)[index];
-		return Value::AGGREGATE_STATE(vector->GetType(), const_data_ptr_cast(str.GetData()), str.GetSize());
-	}
-	case LogicalTypeId::BIT: {
-		auto str = reinterpret_cast<string_t *>(data)[index];
-		return Value::BIT(const_data_ptr_cast(str.GetData()), str.GetSize());
-	}
-	case LogicalTypeId::MAP: {
-		auto offlen = reinterpret_cast<list_entry_t *>(data)[index];
-		auto &child_vec = ListVector::GetEntry(*vector);
-		duckdb::vector<Value> children;
-		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
-			children.push_back(child_vec.GetValue(i));
-		}
-		return Value::MAP(ListType::GetChildType(type), std::move(children));
-	}
-	case LogicalTypeId::UNION: {
-		// Remember to pass the original index_p here so we dont slice twice when looking up the tag
-		// in case this is a dictionary vector
-		union_tag_t tag;
-		if (UnionVector::TryGetTag(*vector, index_p, tag)) {
-			auto value = UnionVector::GetMember(*vector, tag).GetValue(index_p);
-			auto members = UnionType::CopyMemberTypes(type);
-			return Value::UNION(members, tag, std::move(value));
-		} else {
-			return Value(vector->GetType());
-		}
-	}
-	case LogicalTypeId::STRUCT: {
-		// we can derive the value schema from the vector schema
-		auto &child_entries = StructVector::GetEntries(*vector);
-		child_list_t<Value> children;
-		for (idx_t child_idx = 0; child_idx < child_entries.size(); child_idx++) {
-			auto &struct_child = child_entries[child_idx];
-			children.push_back(make_pair(StructType::GetChildName(type, child_idx), struct_child->GetValue(index_p)));
-		}
-		return Value::STRUCT(std::move(children));
-	}
-	case LogicalTypeId::LIST: {
-		auto offlen = reinterpret_cast<list_entry_t *>(data)[index];
-		auto &child_vec = ListVector::GetEntry(*vector);
-		duckdb::vector<Value> children;
-		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
-			children.push_back(child_vec.GetValue(i));
-		}
-		return Value::LIST(ListType::GetChildType(type), std::move(children));
-	}
-	case LogicalTypeId::ARRAY: {
-		auto stride = ArrayType::GetSize(type);
-		auto offset = index * stride;
-		auto &child_vec = ArrayVector::GetEntry(*vector);
-		duckdb::vector<Value> children;
-		for (idx_t i = offset; i < offset + stride; i++) {
-			children.push_back(child_vec.GetValue(i));
-		}
-		return Value::ARRAY(ArrayType::GetChildType(type), std::move(children));
-	}
-	default:
-		throw InternalException("Unimplemented type for value access");
-	}
-}
-
-Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
-	auto value = GetValueInternal(v_p, index_p);
-	// set the alias of the type to the correct value, if there is a type alias
-	if (v_p.GetType().HasAlias()) {
-		value.GetTypeMutable().CopyAuxInfo(v_p.GetType());
-	}
-	if (v_p.GetType().id() != LogicalTypeId::AGGREGATE_STATE && value.type().id() != LogicalTypeId::AGGREGATE_STATE) {
-
-		D_ASSERT(v_p.GetType() == value.type());
-	}
-	return value;
-}
-
-Value Vector::GetValue(idx_t index) const {
-	return GetValue(*this, index);
-}
-
-// LCOV_EXCL_START
-string VectorTypeToString(VectorType type) {
-	switch (type) {
-	case VectorType::FLAT_VECTOR:
-		return "FLAT";
-	case VectorType::FSST_VECTOR:
-		return "FSST";
-	case VectorType::SEQUENCE_VECTOR:
-		return "SEQUENCE";
-	case VectorType::DICTIONARY_VECTOR:
-		return "DICTIONARY";
-	case VectorType::CONSTANT_VECTOR:
-		return "CONSTANT";
-	default:
-		return "UNKNOWN";
-	}
-}
-
-string Vector::ToString(idx_t count) const {
-	string retval =
-	    VectorTypeToString(GetVectorType()) + " " + GetType().ToString() + ": " + to_string(count) + " = [ ";
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-	case VectorType::DICTIONARY_VECTOR:
-		for (idx_t i = 0; i < count; i++) {
-			retval += GetValue(i).ToString() + (i == count - 1 ? "" : ", ");
-		}
-		break;
-	case VectorType::FSST_VECTOR: {
-		for (idx_t i = 0; i < count; i++) {
-			string_t compressed_string = reinterpret_cast<string_t *>(data)[i];
-			auto decoder = FSSTVector::GetDecoder(*this);
-			auto &decompress_buffer = FSSTVector::GetDecompressBuffer(*this);
-			Value val = FSSTPrimitives::DecompressValue(decoder, compressed_string.GetData(),
-			                                            compressed_string.GetSize(), decompress_buffer);
-			retval += GetValue(i).ToString() + (i == count - 1 ? "" : ", ");
-		}
-	} break;
-	case VectorType::CONSTANT_VECTOR:
-		retval += GetValue(0).ToString();
-		break;
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(*this, start, increment);
-		for (idx_t i = 0; i < count; i++) {
-			retval += to_string(start + increment * UnsafeNumericCast<int64_t>(i)) + (i == count - 1 ? "" : ", ");
-		}
-		break;
-	}
-	default:
-		retval += "UNKNOWN VECTOR TYPE";
-		break;
-	}
-	retval += "]";
-	return retval;
-}
-
-void Vector::Print(idx_t count) const {
-	Printer::Print(ToString(count));
-}
-
-// TODO: add the size of validity masks to this
-idx_t Vector::GetAllocationSize(idx_t cardinality) const {
-	if (!type.IsNested()) {
-		auto physical_size = GetTypeIdSize(type.InternalType());
-		return cardinality * physical_size;
-	}
-	auto internal_type = type.InternalType();
-	switch (internal_type) {
-	case PhysicalType::LIST: {
-		auto physical_size = GetTypeIdSize(type.InternalType());
-		auto total_size = physical_size * cardinality;
-
-		auto child_cardinality = ListVector::GetListCapacity(*this);
-		auto &child_entry = ListVector::GetEntry(*this);
-		total_size += (child_entry.GetAllocationSize(child_cardinality));
-		return total_size;
-	}
-	case PhysicalType::ARRAY: {
-		auto child_cardinality = ArrayVector::GetTotalSize(*this);
-
-		auto &child_entry = ArrayVector::GetEntry(*this);
-		auto total_size = (child_entry.GetAllocationSize(child_cardinality));
-		return total_size;
-	}
-	case PhysicalType::STRUCT: {
-		idx_t total_size = 0;
-		auto &children = StructVector::GetEntries(*this);
-		for (auto &child : children) {
-			total_size += child->GetAllocationSize(cardinality);
-		}
-		return total_size;
-	}
-	default:
-		throw NotImplementedException("Vector::GetAllocationSize not implemented for type: %s", type.ToString());
-		break;
-	}
-}
-
-string Vector::ToString() const {
-	string retval = VectorTypeToString(GetVectorType()) + " " + GetType().ToString() + ": (UNKNOWN COUNT) [ ";
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-	case VectorType::DICTIONARY_VECTOR:
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		retval += GetValue(0).ToString();
-		break;
-	case VectorType::SEQUENCE_VECTOR: {
-		break;
-	}
-	default:
-		retval += "UNKNOWN VECTOR TYPE";
-		break;
-	}
-	retval += "]";
-	return retval;
-}
-
-void Vector::Print() const {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-template <class T>
-static void TemplatedFlattenConstantVector(data_ptr_t data, data_ptr_t old_data, idx_t count) {
-	auto constant = Load<T>(old_data);
-	auto output = (T *)data;
-	for (idx_t i = 0; i < count; i++) {
-		output[i] = constant;
-	}
-}
-
-void Vector::Flatten(idx_t count) {
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		// already a flat vector
-		break;
-	case VectorType::FSST_VECTOR: {
-		// Even though count may only be a part of the vector, we need to flatten the whole thing due to the way
-		// ToUnifiedFormat uses flatten
-		idx_t total_count = FSSTVector::GetCount(*this);
-		// create vector to decompress into
-		Vector other(GetType(), total_count);
-		// now copy the data of this vector to the other vector, decompressing the strings in the process
-		VectorOperations::Copy(*this, other, total_count, 0, 0);
-		// create a reference to the data in the other vector
-		this->Reference(other);
-		break;
-	}
-	case VectorType::DICTIONARY_VECTOR: {
-		// create a new flat vector of this type
-		Vector other(GetType(), count);
-		// now copy the data of this vector to the other vector, removing the selection vector in the process
-		VectorOperations::Copy(*this, other, count, 0, 0);
-		// create a reference to the data in the other vector
-		this->Reference(other);
-		break;
-	}
-	case VectorType::CONSTANT_VECTOR: {
-		bool is_null = ConstantVector::IsNull(*this);
-		// allocate a new buffer for the vector
-		auto old_buffer = std::move(buffer);
-		auto old_data = data;
-		buffer = VectorBuffer::CreateStandardVector(type, MaxValue<idx_t>(STANDARD_VECTOR_SIZE, count));
-		if (old_buffer) {
-			D_ASSERT(buffer->GetAuxiliaryData() == nullptr);
-			// The old buffer might be relying on the auxiliary data, keep it alive
-			buffer->MoveAuxiliaryData(*old_buffer);
-		}
-		data = buffer->GetData();
-		vector_type = VectorType::FLAT_VECTOR;
-		if (is_null && GetType().InternalType() != PhysicalType::ARRAY) {
-			// constant NULL, set nullmask
-			validity.EnsureWritable();
-			validity.SetAllInvalid(count);
-			if (GetType().InternalType() != PhysicalType::STRUCT) {
-				// for structs we still need to flatten the child vectors as well
-				return;
-			}
-		}
-		// non-null constant: have to repeat the constant
-		switch (GetType().InternalType()) {
-		case PhysicalType::BOOL:
-			TemplatedFlattenConstantVector<bool>(data, old_data, count);
-			break;
-		case PhysicalType::INT8:
-			TemplatedFlattenConstantVector<int8_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT16:
-			TemplatedFlattenConstantVector<int16_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT32:
-			TemplatedFlattenConstantVector<int32_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT64:
-			TemplatedFlattenConstantVector<int64_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT8:
-			TemplatedFlattenConstantVector<uint8_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT16:
-			TemplatedFlattenConstantVector<uint16_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT32:
-			TemplatedFlattenConstantVector<uint32_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT64:
-			TemplatedFlattenConstantVector<uint64_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT128:
-			TemplatedFlattenConstantVector<hugeint_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT128:
-			TemplatedFlattenConstantVector<uhugeint_t>(data, old_data, count);
-			break;
-		case PhysicalType::FLOAT:
-			TemplatedFlattenConstantVector<float>(data, old_data, count);
-			break;
-		case PhysicalType::DOUBLE:
-			TemplatedFlattenConstantVector<double>(data, old_data, count);
-			break;
-		case PhysicalType::INTERVAL:
-			TemplatedFlattenConstantVector<interval_t>(data, old_data, count);
-			break;
-		case PhysicalType::VARCHAR:
-			TemplatedFlattenConstantVector<string_t>(data, old_data, count);
-			break;
-		case PhysicalType::LIST: {
-			TemplatedFlattenConstantVector<list_entry_t>(data, old_data, count);
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			auto &original_child = ArrayVector::GetEntry(*this);
-			auto array_size = ArrayType::GetSize(GetType());
-			auto flattened_buffer = make_uniq<VectorArrayBuffer>(GetType(), count);
-			auto &new_child = flattened_buffer->GetChild();
-
-			// Fast path: The array is a constant null
-			if (is_null) {
-				// Invalidate the parent array
-				validity.SetAllInvalid(count);
-				// Also invalidate the new child array
-				new_child.validity.SetAllInvalid(count * array_size);
-				// Recurse
-				new_child.Flatten(count * array_size);
-				// TODO: the fast path should exit here, but the part below it is somehow required for correctness
-				// Attach the flattened buffer and return
-				// auxiliary = shared_ptr<VectorBuffer>(flattened_buffer.release());
-				// return;
-			}
-
-			// Now we need to "unpack" the child vector.
-			// Basically, do this:
-			//
-			// | a1 | | 1 |      | a1 | | 1 |
-			//        | 2 |      | a2 | | 2 |
-			//	             =>    ..   | 1 |
-			//                          | 2 |
-			// 							 ...
-
-			auto child_vec = make_uniq<Vector>(original_child);
-			child_vec->Flatten(count * array_size);
-
-			// Create a selection vector
-			SelectionVector sel(count * array_size);
-			for (idx_t array_idx = 0; array_idx < count; array_idx++) {
-				for (idx_t elem_idx = 0; elem_idx < array_size; elem_idx++) {
-					auto position = array_idx * array_size + elem_idx;
-					// Broadcast the validity
-					if (FlatVector::IsNull(*child_vec, elem_idx)) {
-						FlatVector::SetNull(new_child, position, true);
-					}
-					sel.set_index(position, elem_idx);
-				}
-			}
-
-			// Copy over the data to the new buffer
-			VectorOperations::Copy(*child_vec, new_child, sel, count * array_size, 0, 0);
-			auxiliary = shared_ptr<VectorBuffer>(flattened_buffer.release());
-
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto normalified_buffer = make_uniq<VectorStructBuffer>();
-
-			auto &new_children = normalified_buffer->GetChildren();
-
-			auto &child_entries = StructVector::GetEntries(*this);
-			for (auto &child : child_entries) {
-				D_ASSERT(child->GetVectorType() == VectorType::CONSTANT_VECTOR);
-				auto vector = make_uniq<Vector>(*child);
-				vector->Flatten(count);
-				new_children.push_back(std::move(vector));
-			}
-			auxiliary = shared_ptr<VectorBuffer>(normalified_buffer.release());
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented type for VectorOperations::Flatten");
-		}
-		break;
-	}
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment, sequence_count;
-		SequenceVector::GetSequence(*this, start, increment, sequence_count);
-		auto seq_count = NumericCast<idx_t>(sequence_count);
-
-		buffer = VectorBuffer::CreateStandardVector(GetType(), MaxValue<idx_t>(STANDARD_VECTOR_SIZE, seq_count));
-		data = buffer->GetData();
-		VectorOperations::GenerateSequence(*this, seq_count, start, increment);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for normalify");
-	}
-}
-
-void Vector::Flatten(const SelectionVector &sel, idx_t count) {
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		// already a flat vector
-		break;
-	case VectorType::FSST_VECTOR: {
-		// create a new flat vector of this type
-		Vector other(GetType(), count);
-		// copy the data of this vector to the other vector, removing compression and selection vector in the process
-		VectorOperations::Copy(*this, other, sel, count, 0, 0);
-		// create a reference to the data in the other vector
-		this->Reference(other);
-		break;
-	}
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(*this, start, increment);
-
-		buffer = VectorBuffer::CreateStandardVector(GetType());
-		data = buffer->GetData();
-		VectorOperations::GenerateSequence(*this, count, sel, start, increment);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for normalify with selection vector");
-	}
-}
-
-void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &format) {
-	switch (GetVectorType()) {
-	case VectorType::DICTIONARY_VECTOR: {
-		auto &sel = DictionaryVector::SelVector(*this);
-		format.owned_sel.Initialize(sel);
-		format.sel = &format.owned_sel;
-
-		auto &child = DictionaryVector::Child(*this);
-		if (child.GetVectorType() == VectorType::FLAT_VECTOR) {
-			format.data = FlatVector::GetData(child);
-			format.validity = FlatVector::Validity(child);
-		} else {
-			// dictionary with non-flat child: create a new reference to the child and flatten it
-			Vector child_vector(child);
-			child_vector.Flatten(sel, count);
-			auto new_aux = make_buffer<VectorChildBuffer>(std::move(child_vector));
-
-			format.data = FlatVector::GetData(new_aux->data);
-			format.validity = FlatVector::Validity(new_aux->data);
-			this->auxiliary = std::move(new_aux);
-		}
-		break;
-	}
-	case VectorType::CONSTANT_VECTOR:
-		format.sel = ConstantVector::ZeroSelectionVector(count, format.owned_sel);
-		format.data = ConstantVector::GetData(*this);
-		format.validity = ConstantVector::Validity(*this);
-		break;
-	default:
-		Flatten(count);
-		format.sel = FlatVector::IncrementalSelectionVector();
-		format.data = FlatVector::GetData(*this);
-		format.validity = FlatVector::Validity(*this);
-		break;
-	}
-}
-
-void Vector::RecursiveToUnifiedFormat(Vector &input, idx_t count, RecursiveUnifiedVectorFormat &data) {
-
-	input.ToUnifiedFormat(count, data.unified);
-	data.logical_type = input.GetType();
-
-	if (input.GetType().InternalType() == PhysicalType::LIST) {
-		auto &child = ListVector::GetEntry(input);
-		auto child_count = ListVector::GetListSize(input);
-		data.children.emplace_back();
-		Vector::RecursiveToUnifiedFormat(child, child_count, data.children.back());
-
-	} else if (input.GetType().InternalType() == PhysicalType::ARRAY) {
-		auto &child = ArrayVector::GetEntry(input);
-		auto array_size = ArrayType::GetSize(input.GetType());
-		auto child_count = count * array_size;
-		data.children.emplace_back();
-		Vector::RecursiveToUnifiedFormat(child, child_count, data.children.back());
-
-	} else if (input.GetType().InternalType() == PhysicalType::STRUCT) {
-		auto &children = StructVector::GetEntries(input);
-		for (idx_t i = 0; i < children.size(); i++) {
-			data.children.emplace_back();
-		}
-		for (idx_t i = 0; i < children.size(); i++) {
-			Vector::RecursiveToUnifiedFormat(*children[i], count, data.children[i]);
-		}
-	}
-}
-
-void Vector::Sequence(int64_t start, int64_t increment, idx_t count) {
-	this->vector_type = VectorType::SEQUENCE_VECTOR;
-	this->buffer = make_buffer<VectorBuffer>(sizeof(int64_t) * 3);
-	auto data = reinterpret_cast<int64_t *>(buffer->GetData());
-	data[0] = start;
-	data[1] = increment;
-	data[2] = int64_t(count);
-	validity.Reset();
-	auxiliary.reset();
-}
-
-// FIXME: This should ideally be const
-void Vector::Serialize(Serializer &serializer, idx_t count) {
-	auto &logical_type = GetType();
-
-	UnifiedVectorFormat vdata;
-	ToUnifiedFormat(count, vdata);
-
-	const bool has_validity_mask = (count > 0) && !vdata.validity.AllValid();
-	serializer.WriteProperty(100, "has_validity_mask", has_validity_mask);
-	if (has_validity_mask) {
-		ValidityMask flat_mask(count);
-		flat_mask.Initialize();
-		for (idx_t i = 0; i < count; ++i) {
-			auto row_idx = vdata.sel->get_index(i);
-			flat_mask.Set(i, vdata.validity.RowIsValid(row_idx));
-		}
-		serializer.WriteProperty(101, "validity", const_data_ptr_cast(flat_mask.GetData()),
-		                         flat_mask.ValidityMaskSize(count));
-	}
-	if (TypeIsConstantSize(logical_type.InternalType())) {
-		// constant size type: simple copy
-		idx_t write_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = make_unsafe_uniq_array_uninitialized<data_t>(write_size);
-		VectorOperations::WriteToStorage(*this, count, ptr.get());
-		serializer.WriteProperty(102, "data", ptr.get(), write_size);
-	} else {
-		switch (logical_type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
-
-			// Serialize data as a list
-			serializer.WriteList(102, "data", count, [&](Serializer::List &list, idx_t i) {
-				auto idx = vdata.sel->get_index(i);
-				auto str = !vdata.validity.RowIsValid(idx) ? NullValue<string_t>() : strings[idx];
-				list.WriteElement(str);
-			});
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto &entries = StructVector::GetEntries(*this);
-
-			// Serialize entries as a list
-			serializer.WriteList(103, "children", entries.size(), [&](Serializer::List &list, idx_t i) {
-				list.WriteObject([&](Serializer &object) { entries[i]->Serialize(object, count); });
-			});
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto &child = ListVector::GetEntry(*this);
-			auto list_size = ListVector::GetListSize(*this);
-
-			// serialize the list entries in a flat array
-			auto entries = make_unsafe_uniq_array_uninitialized<list_entry_t>(count);
-			auto source_array = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = vdata.sel->get_index(i);
-				auto source = source_array[idx];
-				if (vdata.validity.RowIsValid(idx)) {
-					entries[i].offset = source.offset;
-					entries[i].length = source.length;
-				} else {
-					entries[i].offset = 0;
-					entries[i].length = 0;
-				}
-			}
-			serializer.WriteProperty(104, "list_size", list_size);
-			serializer.WriteList(105, "entries", count, [&](Serializer::List &list, idx_t i) {
-				list.WriteObject([&](Serializer &object) {
-					object.WriteProperty(100, "offset", entries[i].offset);
-					object.WriteProperty(101, "length", entries[i].length);
-				});
-			});
-			serializer.WriteObject(106, "child", [&](Serializer &object) { child.Serialize(object, list_size); });
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			Vector serialized_vector(*this);
-			serialized_vector.Flatten(count);
-
-			auto &child = ArrayVector::GetEntry(serialized_vector);
-			auto array_size = ArrayType::GetSize(serialized_vector.GetType());
-			auto child_size = array_size * count;
-			serializer.WriteProperty<uint64_t>(103, "array_size", array_size);
-			serializer.WriteObject(104, "child", [&](Serializer &object) { child.Serialize(object, child_size); });
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented variable width type for Vector::Serialize!");
-		}
-	}
-}
-
-void Vector::Deserialize(Deserializer &deserializer, idx_t count) {
-	auto &logical_type = GetType();
-
-	auto &validity = FlatVector::Validity(*this);
-	auto validity_count = MaxValue<idx_t>(count, STANDARD_VECTOR_SIZE);
-	validity.Reset(validity_count);
-	const auto has_validity_mask = deserializer.ReadProperty<bool>(100, "has_validity_mask");
-	if (has_validity_mask) {
-		validity.Initialize(validity_count);
-		deserializer.ReadProperty(101, "validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
-	}
-
-	if (TypeIsConstantSize(logical_type.InternalType())) {
-		// constant size type: read fixed amount of data
-		auto column_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = make_unsafe_uniq_array_uninitialized<data_t>(column_size);
-		deserializer.ReadProperty(102, "data", ptr.get(), column_size);
-
-		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
-	} else {
-		switch (logical_type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			auto strings = FlatVector::GetData<string_t>(*this);
-			deserializer.ReadList(102, "data", [&](Deserializer::List &list, idx_t i) {
-				auto str = list.ReadElement<string>();
-				if (validity.RowIsValid(i)) {
-					strings[i] = StringVector::AddStringOrBlob(*this, str);
-				}
-			});
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto &entries = StructVector::GetEntries(*this);
-			// Deserialize entries as a list
-			deserializer.ReadList(103, "children", [&](Deserializer::List &list, idx_t i) {
-				list.ReadObject([&](Deserializer &obj) { entries[i]->Deserialize(obj, count); });
-			});
-			break;
-		}
-		case PhysicalType::LIST: {
-			// Read the list size
-			auto list_size = deserializer.ReadProperty<uint64_t>(104, "list_size");
-			ListVector::Reserve(*this, list_size);
-			ListVector::SetListSize(*this, list_size);
-
-			// Read the entries
-			auto list_entries = FlatVector::GetData<list_entry_t>(*this);
-			deserializer.ReadList(105, "entries", [&](Deserializer::List &list, idx_t i) {
-				list.ReadObject([&](Deserializer &obj) {
-					list_entries[i].offset = obj.ReadProperty<uint64_t>(100, "offset");
-					list_entries[i].length = obj.ReadProperty<uint64_t>(101, "length");
-				});
-			});
-
-			// Read the child vector
-			deserializer.ReadObject(106, "child", [&](Deserializer &obj) {
-				auto &child = ListVector::GetEntry(*this);
-				child.Deserialize(obj, list_size);
-			});
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			auto array_size = deserializer.ReadProperty<uint64_t>(103, "array_size");
-			deserializer.ReadObject(104, "child", [&](Deserializer &obj) {
-				auto &child = ArrayVector::GetEntry(*this);
-				child.Deserialize(obj, array_size * count);
-			});
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented variable width type for Vector::Deserialize!");
-		}
-	}
-}
-
-void Vector::SetVectorType(VectorType vector_type_p) {
-	vector_type = vector_type_p;
-	auto physical_type = GetType().InternalType();
-	auto flat_or_const = GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR;
-	if (TypeIsConstantSize(physical_type) && flat_or_const) {
-		auxiliary.reset();
-	}
-	if (vector_type == VectorType::CONSTANT_VECTOR && physical_type == PhysicalType::STRUCT) {
-		auto &entries = StructVector::GetEntries(*this);
-		for (auto &entry : entries) {
-			entry->SetVectorType(vector_type);
-		}
-	}
-}
-
-void Vector::UTFVerify(const SelectionVector &sel, idx_t count) {
-#ifdef DEBUG
-	if (count == 0) {
-		return;
-	}
-	if (GetType().InternalType() == PhysicalType::VARCHAR) {
-		// we just touch all the strings and let the sanitizer figure out if any
-		// of them are deallocated/corrupt
-		switch (GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			auto string = ConstantVector::GetData<string_t>(*this);
-			if (!ConstantVector::IsNull(*this)) {
-				string->Verify();
-			}
-			break;
-		}
-		case VectorType::FLAT_VECTOR: {
-			auto strings = FlatVector::GetData<string_t>(*this);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel.get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					strings[oidx].Verify();
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-#endif
-}
-
-void Vector::UTFVerify(idx_t count) {
-	auto flat_sel = FlatVector::IncrementalSelectionVector();
-
-	UTFVerify(*flat_sel, count);
-}
-
-void Vector::VerifyMap(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
-#ifdef DEBUG
-	D_ASSERT(vector_p.GetType().id() == LogicalTypeId::MAP);
-	auto &child = ListType::GetChildType(vector_p.GetType());
-	D_ASSERT(StructType::GetChildCount(child) == 2);
-	D_ASSERT(StructType::GetChildName(child, 0) == "key");
-	D_ASSERT(StructType::GetChildName(child, 1) == "value");
-
-	auto valid_check = MapVector::CheckMapValidity(vector_p, count, sel_p);
-	D_ASSERT(valid_check == MapInvalidReason::VALID);
-#endif // DEBUG
-}
-
-void Vector::VerifyUnion(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
-#ifdef DEBUG
-
-	D_ASSERT(vector_p.GetType().id() == LogicalTypeId::UNION);
-	auto valid_check = UnionVector::CheckUnionValidity(vector_p, count, sel_p);
-	if (valid_check != UnionInvalidReason::VALID) {
-		throw InternalException("Union not valid, reason: %s", EnumUtil::ToString(valid_check));
-	}
-#endif // DEBUG
-}
-
-void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
-#ifdef DEBUG
-	if (count == 0) {
-		return;
-	}
-	Vector *vector = &vector_p;
-	const SelectionVector *sel = &sel_p;
-	SelectionVector owned_sel;
-	auto &type = vector->GetType();
-	auto vtype = vector->GetVectorType();
-	if (vector->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(*vector);
-		D_ASSERT(child.GetVectorType() != VectorType::DICTIONARY_VECTOR);
-		auto &dict_sel = DictionaryVector::SelVector(*vector);
-		// merge the selection vectors and verify the child
-		auto new_buffer = dict_sel.Slice(*sel, count);
-		owned_sel.Initialize(new_buffer);
-		sel = &owned_sel;
-		vector = &child;
-		vtype = vector->GetVectorType();
-	}
-	if (TypeIsConstantSize(type.InternalType()) &&
-	    (vtype == VectorType::CONSTANT_VECTOR || vtype == VectorType::FLAT_VECTOR)) {
-		D_ASSERT(!vector->auxiliary);
-	}
-	if (type.id() == LogicalTypeId::VARCHAR) {
-		// verify that the string is correct unicode
-		switch (vtype) {
-		case VectorType::FLAT_VECTOR: {
-			auto &validity = FlatVector::Validity(*vector);
-			auto strings = FlatVector::GetData<string_t>(*vector);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel->get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					strings[oidx].Verify();
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	if (type.id() == LogicalTypeId::VARINT) {
-		switch (vtype) {
-		case VectorType::FLAT_VECTOR: {
-			auto &validity = FlatVector::Validity(*vector);
-			auto strings = FlatVector::GetData<string_t>(*vector);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel->get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					Varint::Verify(strings[oidx]);
-				}
-			}
-		} break;
-		default:
-			break;
-		}
-	}
-
-	if (type.id() == LogicalTypeId::BIT) {
-		switch (vtype) {
-		case VectorType::FLAT_VECTOR: {
-			auto &validity = FlatVector::Validity(*vector);
-			auto strings = FlatVector::GetData<string_t>(*vector);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel->get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					auto buf = strings[oidx].GetData();
-					D_ASSERT(*buf >= 0 && *buf < 8);
-					Bit::Verify(strings[oidx]);
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	if (type.InternalType() == PhysicalType::ARRAY) {
-		// Arrays have the following invariants
-		// 1. if the array vector is a CONSTANT_VECTOR
-		//	1.1	The child vector is a FLAT_VECTOR with count = array_size
-		//	1.2 OR The child vector is a CONSTANT_VECTOR and must be NULL
-		//  1.3 OR The child vector is a CONSTANT_VECTOR and array_size = 1
-		// 2. if the array vector is a FLAT_VECTOR, the child vector is a FLAT_VECTOR
-		// 	2.2 the count of the child vector is array_size * (parent)count
-
-		auto &child = ArrayVector::GetEntry(*vector);
-		auto array_size = ArrayType::GetSize(type);
-
-		if (child.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			D_ASSERT(ConstantVector::IsNull(child));
-		} else {
-			D_ASSERT(child.GetVectorType() == VectorType::FLAT_VECTOR);
-		}
-
-		if (vtype == VectorType::CONSTANT_VECTOR) {
-			if (!ConstantVector::IsNull(*vector)) {
-				child.Verify(array_size);
-			}
-		} else if (vtype == VectorType::FLAT_VECTOR) {
-			// Flat vector case
-			auto &validity = FlatVector::Validity(*vector);
-			idx_t selected_child_count = 0;
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel->get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					selected_child_count += array_size;
-				}
-			}
-
-			SelectionVector child_sel(selected_child_count);
-			idx_t child_count = 0;
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel->get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					for (idx_t j = 0; j < array_size; j++) {
-						child_sel.set_index(child_count++, oidx * array_size + j);
-					}
-				}
-			}
-			Vector::Verify(child, child_sel, child_count);
-		}
-	}
-
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		auto &child_types = StructType::GetChildTypes(type);
-		D_ASSERT(!child_types.empty());
-
-		// create a selection vector of the non-null entries of the struct vector
-		auto &children = StructVector::GetEntries(*vector);
-		D_ASSERT(child_types.size() == children.size());
-		for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
-			D_ASSERT(children[child_idx]->GetType() == child_types[child_idx].second);
-			Vector::Verify(*children[child_idx], sel_p, count);
-			if (vtype == VectorType::CONSTANT_VECTOR) {
-				D_ASSERT(children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR);
-				if (ConstantVector::IsNull(*vector)) {
-					D_ASSERT(ConstantVector::IsNull(*children[child_idx]));
-				}
-			}
-			if (vtype != VectorType::FLAT_VECTOR) {
-				continue;
-			}
-			optional_ptr<ValidityMask> child_validity;
-			SelectionVector owned_child_sel;
-			const SelectionVector *child_sel = &owned_child_sel;
-			if (children[child_idx]->GetVectorType() == VectorType::FLAT_VECTOR) {
-				child_sel = FlatVector::IncrementalSelectionVector();
-				child_validity = &FlatVector::Validity(*children[child_idx]);
-			} else if (children[child_idx]->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-				auto &child = DictionaryVector::Child(*children[child_idx]);
-				if (child.GetVectorType() != VectorType::FLAT_VECTOR) {
-					continue;
-				}
-				child_validity = &FlatVector::Validity(child);
-				child_sel = &DictionaryVector::SelVector(*children[child_idx]);
-			} else if (children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				child_sel = ConstantVector::ZeroSelectionVector(count, owned_child_sel);
-				child_validity = &ConstantVector::Validity(*children[child_idx]);
-			} else {
-				continue;
-			}
-			// for any NULL entry in the struct, the child should be NULL as well
-			auto &validity = FlatVector::Validity(*vector);
-			for (idx_t i = 0; i < count; i++) {
-				auto index = sel->get_index(i);
-				if (!validity.RowIsValid(index)) {
-					auto child_index = child_sel->get_index(sel_p.get_index(i));
-					D_ASSERT(!child_validity->RowIsValid(child_index));
-				}
-			}
-		}
-
-		if (vector->GetType().id() == LogicalTypeId::UNION) {
-			// Pass in raw vector
-			VerifyUnion(vector_p, sel_p, count);
-		}
-	}
-
-	if (type.InternalType() == PhysicalType::LIST) {
-		if (vtype == VectorType::CONSTANT_VECTOR) {
-			if (!ConstantVector::IsNull(*vector)) {
-				auto &child = ListVector::GetEntry(*vector);
-				SelectionVector child_sel(ListVector::GetListSize(*vector));
-				idx_t child_count = 0;
-				auto le = ConstantVector::GetData<list_entry_t>(*vector);
-				D_ASSERT(le->offset + le->length <= ListVector::GetListSize(*vector));
-				for (idx_t k = 0; k < le->length; k++) {
-					child_sel.set_index(child_count++, le->offset + k);
-				}
-				Vector::Verify(child, child_sel, child_count);
-			}
-		} else if (vtype == VectorType::FLAT_VECTOR) {
-			auto &validity = FlatVector::Validity(*vector);
-			auto &child = ListVector::GetEntry(*vector);
-			auto child_size = ListVector::GetListSize(*vector);
-			auto list_data = FlatVector::GetData<list_entry_t>(*vector);
-			idx_t total_size = 0;
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel->get_index(i);
-				auto &le = list_data[idx];
-				if (validity.RowIsValid(idx)) {
-					D_ASSERT(le.offset + le.length <= child_size);
-					total_size += le.length;
-				}
-			}
-			SelectionVector child_sel(total_size);
-			idx_t child_count = 0;
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel->get_index(i);
-				auto &le = list_data[idx];
-				if (validity.RowIsValid(idx)) {
-					D_ASSERT(le.offset + le.length <= child_size);
-					for (idx_t k = 0; k < le.length; k++) {
-						child_sel.set_index(child_count++, le.offset + k);
-					}
-				}
-			}
-			Vector::Verify(child, child_sel, child_count);
-		}
-
-		if (vector->GetType().id() == LogicalTypeId::MAP) {
-			VerifyMap(*vector, *sel, count);
-		}
-	}
-#endif
-}
-
-void Vector::Verify(idx_t count) {
-	auto flat_sel = FlatVector::IncrementalSelectionVector();
-	Verify(*this, *flat_sel, count);
-}
-
-void Vector::DebugTransformToDictionary(Vector &vector, idx_t count) {
-	if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
-		// only supported for flat vectors currently
-		return;
-	}
-	// convert vector to dictionary vector
-	// first create an inverted vector of twice the size with NULL values every other value
-	// i.e. [1, 2, 3] is converted into [NULL, 3, NULL, 2, NULL, 1]
-	idx_t verify_count = count * 2;
-	SelectionVector inverted_sel(verify_count);
-	idx_t offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t current_index = count - i - 1;
-		inverted_sel.set_index(offset++, current_index);
-		inverted_sel.set_index(offset++, current_index);
-	}
-	Vector inverted_vector(vector, inverted_sel, verify_count);
-	inverted_vector.Flatten(verify_count);
-	// now insert the NULL values at every other position
-	for (idx_t i = 0; i < count; i++) {
-		FlatVector::SetNull(inverted_vector, i * 2, true);
-	}
-	// construct the selection vector pointing towards the original values
-	// we start at the back, (verify_count - 1) and move backwards
-	SelectionVector original_sel(count);
-	offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		original_sel.set_index(offset++, verify_count - 1 - i * 2);
-	}
-	// now slice the inverted vector with the inverted selection vector
-	vector.Slice(inverted_vector, original_sel, count);
-	vector.Verify(count);
-}
-
-void Vector::DebugShuffleNestedVector(Vector &vector, idx_t count) {
-	switch (vector.GetType().id()) {
-	case LogicalTypeId::STRUCT: {
-		auto &entries = StructVector::GetEntries(vector);
-		// recurse into child elements
-		for (auto &entry : entries) {
-			Vector::DebugShuffleNestedVector(*entry, count);
-		}
-		break;
-	}
-	case LogicalTypeId::LIST: {
-		if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
-			break;
-		}
-		auto list_entries = FlatVector::GetData<list_entry_t>(vector);
-		idx_t child_count = 0;
-		for (idx_t r = 0; r < count; r++) {
-			if (FlatVector::IsNull(vector, r)) {
-				continue;
-			}
-			child_count += list_entries[r].length;
-		}
-		if (child_count == 0) {
-			break;
-		}
-		auto &child_vector = ListVector::GetEntry(vector);
-		// reverse the order of all lists
-		SelectionVector child_sel(child_count);
-		idx_t position = child_count;
-		for (idx_t r = 0; r < count; r++) {
-			if (FlatVector::IsNull(vector, r)) {
-				continue;
-			}
-			// move this list to the back
-			position -= list_entries[r].length;
-			for (idx_t k = 0; k < list_entries[r].length; k++) {
-				child_sel.set_index(position + k, list_entries[r].offset + k);
-			}
-			// adjust the offset to this new position
-			list_entries[r].offset = position;
-		}
-		child_vector.Slice(child_sel, child_count);
-		child_vector.Flatten(child_count);
-		ListVector::SetListSize(vector, child_count);
-
-		// recurse into child elements
-		Vector::DebugShuffleNestedVector(child_vector, child_count);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// FlatVector
-//===--------------------------------------------------------------------===//
-void FlatVector::SetNull(Vector &vector, idx_t idx, bool is_null) {
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-	vector.validity.Set(idx, !is_null);
-	if (!is_null) {
-		return;
-	}
-
-	auto &type = vector.GetType();
-	auto internal_type = type.InternalType();
-
-	// Set all child entries to NULL.
-	if (internal_type == PhysicalType::STRUCT) {
-		auto &entries = StructVector::GetEntries(vector);
-		for (auto &entry : entries) {
-			FlatVector::SetNull(*entry, idx, is_null);
-		}
-		return;
-	}
-
-	// Set all child entries to NULL.
-	if (internal_type == PhysicalType::ARRAY) {
-		auto &child = ArrayVector::GetEntry(vector);
-		auto array_size = ArrayType::GetSize(type);
-		auto child_offset = idx * array_size;
-		for (idx_t i = 0; i < array_size; i++) {
-			FlatVector::SetNull(child, child_offset + i, is_null);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// ConstantVector
-//===--------------------------------------------------------------------===//
-void ConstantVector::SetNull(Vector &vector, bool is_null) {
-	D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	vector.validity.Set(0, !is_null);
-	if (is_null) {
-		auto &type = vector.GetType();
-		auto internal_type = type.InternalType();
-		if (internal_type == PhysicalType::STRUCT) {
-			// set all child entries to null as well
-			auto &entries = StructVector::GetEntries(vector);
-			for (auto &entry : entries) {
-				entry->SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(*entry, is_null);
-			}
-		} else if (internal_type == PhysicalType::ARRAY) {
-			auto &child = ArrayVector::GetEntry(vector);
-			D_ASSERT(child.GetVectorType() == VectorType::CONSTANT_VECTOR ||
-			         child.GetVectorType() == VectorType::FLAT_VECTOR);
-			auto array_size = ArrayType::GetSize(type);
-			if (child.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				D_ASSERT(array_size == 1);
-				ConstantVector::SetNull(child, is_null);
-			} else {
-				for (idx_t i = 0; i < array_size; i++) {
-					FlatVector::SetNull(child, i, is_null);
-				}
-			}
-		}
-	}
-}
-
-const SelectionVector *ConstantVector::ZeroSelectionVector(idx_t count, SelectionVector &owned_sel) {
-	if (count <= STANDARD_VECTOR_SIZE) {
-		return ConstantVector::ZeroSelectionVector();
-	}
-	owned_sel.Initialize(count);
-	for (idx_t i = 0; i < count; i++) {
-		owned_sel.set_index(i, 0);
-	}
-	return &owned_sel;
-}
-
-void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, idx_t count) {
-	auto &source_type = source.GetType();
-	switch (source_type.InternalType()) {
-	case PhysicalType::LIST: {
-		// retrieve the list entry from the source vector
-		UnifiedVectorFormat vdata;
-		source.ToUnifiedFormat(count, vdata);
-
-		auto list_index = vdata.sel->get_index(position);
-		if (!vdata.validity.RowIsValid(list_index)) {
-			// list is null: create null value
-			Value null_value(source_type);
-			vector.Reference(null_value);
-			break;
-		}
-
-		auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
-		auto list_entry = list_data[list_index];
-
-		// add the list entry as the first element of "vector"
-		// FIXME: we only need to allocate space for 1 tuple here
-		auto target_data = FlatVector::GetData<list_entry_t>(vector);
-		target_data[0] = list_entry;
-
-		// create a reference to the child list of the source vector
-		auto &child = ListVector::GetEntry(vector);
-		child.Reference(ListVector::GetEntry(source));
-
-		ListVector::SetListSize(vector, ListVector::GetListSize(source));
-		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		UnifiedVectorFormat vdata;
-		source.ToUnifiedFormat(count, vdata);
-		auto source_idx = vdata.sel->get_index(position);
-		if (!vdata.validity.RowIsValid(source_idx)) {
-			// list is null: create null value
-			Value null_value(source_type);
-			vector.Reference(null_value);
-			break;
-		}
-
-		// Reference the child vector
-		auto &target_child = ArrayVector::GetEntry(vector);
-		auto &source_child = ArrayVector::GetEntry(source);
-		target_child.Reference(source_child);
-
-		// Only take the element at the given position
-		auto array_size = ArrayType::GetSize(source_type);
-		SelectionVector sel(array_size);
-		for (idx_t i = 0; i < array_size; i++) {
-			sel.set_index(i, array_size * source_idx + i);
-		}
-		target_child.Slice(sel, array_size);
-		target_child.Flatten(array_size); // since its constant we only have to flatten this much
-
-		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		vector.validity.Set(0, true);
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		UnifiedVectorFormat vdata;
-		source.ToUnifiedFormat(count, vdata);
-
-		auto struct_index = vdata.sel->get_index(position);
-		if (!vdata.validity.RowIsValid(struct_index)) {
-			// null struct: create null value
-			Value null_value(source_type);
-			vector.Reference(null_value);
-			break;
-		}
-
-		// struct: pass constant reference into child entries
-		auto &source_entries = StructVector::GetEntries(source);
-		auto &target_entries = StructVector::GetEntries(vector);
-		for (idx_t i = 0; i < source_entries.size(); i++) {
-			ConstantVector::Reference(*target_entries[i], *source_entries[i], position, count);
-		}
-		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		vector.validity.Set(0, true);
-		break;
-	}
-	default:
-		// default behavior: get a value from the vector and reference it
-		// this is not that expensive for scalar types
-		auto value = source.GetValue(position);
-		vector.Reference(value);
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-		break;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// StringVector
-//===--------------------------------------------------------------------===//
-string_t StringVector::AddString(Vector &vector, const char *data, idx_t len) {
-	return StringVector::AddString(vector, string_t(data, UnsafeNumericCast<uint32_t>(len)));
-}
-
-string_t StringVector::AddStringOrBlob(Vector &vector, const char *data, idx_t len) {
-	return StringVector::AddStringOrBlob(vector, string_t(data, UnsafeNumericCast<uint32_t>(len)));
-}
-
-string_t StringVector::AddString(Vector &vector, const char *data) {
-	return StringVector::AddString(vector, string_t(data, UnsafeNumericCast<uint32_t>(strlen(data))));
-}
-
-string_t StringVector::AddString(Vector &vector, const string &data) {
-	return StringVector::AddString(vector, string_t(data.c_str(), UnsafeNumericCast<uint32_t>(data.size())));
-}
-
-string_t StringVector::AddString(Vector &vector, string_t data) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::VARCHAR || vector.GetType().id() == LogicalTypeId::BIT);
-	if (data.IsInlined()) {
-		// string will be inlined: no need to store in string heap
-		return data;
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = vector.auxiliary.get()->Cast<VectorStringBuffer>();
-	return string_buffer.AddString(data);
-}
-
-string_t StringVector::AddStringOrBlob(Vector &vector, string_t data) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (data.IsInlined()) {
-		// string will be inlined: no need to store in string heap
-		return data;
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = vector.auxiliary.get()->Cast<VectorStringBuffer>();
-	return string_buffer.AddBlob(data);
-}
-
-string_t StringVector::EmptyString(Vector &vector, idx_t len) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (len <= string_t::INLINE_LENGTH) {
-		return string_t(UnsafeNumericCast<uint32_t>(len));
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = vector.auxiliary.get()->Cast<VectorStringBuffer>();
-	return string_buffer.EmptyString(len);
-}
-
-void StringVector::AddHandle(Vector &vector, BufferHandle handle) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	auto &string_buffer = vector.auxiliary->Cast<VectorStringBuffer>();
-	string_buffer.AddHeapReference(make_buffer<ManagedVectorBuffer>(std::move(handle)));
-}
-
-void StringVector::AddBuffer(Vector &vector, buffer_ptr<VectorBuffer> buffer) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	D_ASSERT(buffer.get() != vector.auxiliary.get());
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	auto &string_buffer = vector.auxiliary->Cast<VectorStringBuffer>();
-	string_buffer.AddHeapReference(std::move(buffer));
-}
-
-void StringVector::AddHeapReference(Vector &vector, Vector &other) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	D_ASSERT(other.GetType().InternalType() == PhysicalType::VARCHAR);
-
-	if (other.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		StringVector::AddHeapReference(vector, DictionaryVector::Child(other));
-		return;
-	}
-	if (!other.auxiliary) {
-		return;
-	}
-	StringVector::AddBuffer(vector, other.auxiliary);
-}
-
-//===--------------------------------------------------------------------===//
-// FSSTVector
-//===--------------------------------------------------------------------===//
-string_t FSSTVector::AddCompressedString(Vector &vector, const char *data, idx_t len) {
-	return FSSTVector::AddCompressedString(vector, string_t(data, UnsafeNumericCast<uint32_t>(len)));
-}
-
-string_t FSSTVector::AddCompressedString(Vector &vector, string_t data) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (data.IsInlined()) {
-		// string will be inlined: no need to store in string heap
-		return data;
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorFSSTStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-	auto &fsst_string_buffer = vector.auxiliary.get()->Cast<VectorFSSTStringBuffer>();
-	return fsst_string_buffer.AddBlob(data);
-}
-
-void *FSSTVector::GetDecoder(const Vector &vector) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (!vector.auxiliary) {
-		throw InternalException("GetDecoder called on FSST Vector without registered buffer");
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
-	return fsst_string_buffer.GetDecoder();
-}
-
-vector<unsigned char> &FSSTVector::GetDecompressBuffer(const Vector &vector) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (!vector.auxiliary) {
-		throw InternalException("GetDecompressBuffer called on FSST Vector without registered buffer");
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
-	return fsst_string_buffer.GetDecompressBuffer();
-}
-
-void FSSTVector::RegisterDecoder(Vector &vector, buffer_ptr<void> &duckdb_fsst_decoder,
-                                 const idx_t string_block_limit) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorFSSTStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-
-	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
-	fsst_string_buffer.AddDecoder(duckdb_fsst_decoder, string_block_limit);
-}
-
-void FSSTVector::SetCount(Vector &vector, idx_t count) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorFSSTStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-
-	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
-	fsst_string_buffer.SetCount(count);
-}
-
-idx_t FSSTVector::GetCount(Vector &vector) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorFSSTStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-
-	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
-	return fsst_string_buffer.GetCount();
-}
-
-void FSSTVector::DecompressVector(const Vector &src, Vector &dst, idx_t src_offset, idx_t dst_offset, idx_t copy_count,
-                                  const SelectionVector *sel) {
-	D_ASSERT(src.GetVectorType() == VectorType::FSST_VECTOR);
-	D_ASSERT(dst.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto dst_mask = FlatVector::Validity(dst);
-	auto ldata = FSSTVector::GetCompressedData<string_t>(src);
-	auto tdata = FlatVector::GetData<string_t>(dst);
-	for (idx_t i = 0; i < copy_count; i++) {
-		auto source_idx = sel->get_index(src_offset + i);
-		auto target_idx = dst_offset + i;
-		string_t compressed_string = ldata[source_idx];
-		if (dst_mask.RowIsValid(target_idx) && compressed_string.GetSize() > 0) {
-			auto decoder = FSSTVector::GetDecoder(src);
-			auto &decompress_buffer = FSSTVector::GetDecompressBuffer(src);
-			tdata[target_idx] = FSSTPrimitives::DecompressValue(decoder, dst, compressed_string.GetData(),
-			                                                    compressed_string.GetSize(), decompress_buffer);
-		} else {
-			tdata[target_idx] = string_t(nullptr, 0);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// MapVector
-//===--------------------------------------------------------------------===//
-Vector &MapVector::GetKeys(Vector &vector) {
-	auto &entries = StructVector::GetEntries(ListVector::GetEntry(vector));
-	D_ASSERT(entries.size() == 2);
-	return *entries[0];
-}
-Vector &MapVector::GetValues(Vector &vector) {
-	auto &entries = StructVector::GetEntries(ListVector::GetEntry(vector));
-	D_ASSERT(entries.size() == 2);
-	return *entries[1];
-}
-
-const Vector &MapVector::GetKeys(const Vector &vector) {
-	return GetKeys((Vector &)vector);
-}
-const Vector &MapVector::GetValues(const Vector &vector) {
-	return GetValues((Vector &)vector);
-}
-
-MapInvalidReason MapVector::CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) {
-
-	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
-
-	// unify the MAP vector, which is a physical LIST vector
-	UnifiedVectorFormat map_data;
-	map.ToUnifiedFormat(count, map_data);
-	auto map_entries = UnifiedVectorFormat::GetDataNoConst<list_entry_t>(map_data);
-	auto maps_length = ListVector::GetListSize(map);
-
-	// unify the child vector containing the keys
-	auto &keys = MapVector::GetKeys(map);
-	UnifiedVectorFormat key_data;
-	keys.ToUnifiedFormat(maps_length, key_data);
-
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-
-		auto mapped_row = sel.get_index(row_idx);
-		auto map_idx = map_data.sel->get_index(mapped_row);
-
-		if (!map_data.validity.RowIsValid(map_idx)) {
-			continue;
-		}
-
-		value_set_t unique_keys;
-		auto length = map_entries[map_idx].length;
-		auto offset = map_entries[map_idx].offset;
-
-		for (idx_t child_idx = 0; child_idx < length; child_idx++) {
-			auto key_idx = key_data.sel->get_index(offset + child_idx);
-
-			if (!key_data.validity.RowIsValid(key_idx)) {
-				return MapInvalidReason::NULL_KEY;
-			}
-
-			auto value = keys.GetValue(key_idx);
-			auto unique = unique_keys.insert(value).second;
-			if (!unique) {
-				return MapInvalidReason::DUPLICATE_KEY;
-			}
-		}
-	}
-
-	return MapInvalidReason::VALID;
-}
-
-void MapVector::MapConversionVerify(Vector &vector, idx_t count) {
-	auto reason = MapVector::CheckMapValidity(vector, count);
-	EvalMapInvalidReason(reason);
-}
-
-void MapVector::EvalMapInvalidReason(MapInvalidReason reason) {
-	switch (reason) {
-	case MapInvalidReason::VALID:
-		return;
-	case MapInvalidReason::DUPLICATE_KEY:
-		throw InvalidInputException("Map keys must be unique.");
-	case MapInvalidReason::NULL_KEY:
-		throw InvalidInputException("Map keys can not be NULL.");
-	case MapInvalidReason::NOT_ALIGNED:
-		throw InvalidInputException("The map key list does not align with the map value list.");
-	case MapInvalidReason::INVALID_PARAMS:
-		throw InvalidInputException("Invalid map argument(s). Valid map arguments are a list of key-value pairs (MAP "
-		                            "{'key1': 'val1', ...}), two lists (MAP ([1, 2], [10, 11])), or no arguments.");
-	default:
-		throw InternalException("MapInvalidReason not implemented");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// StructVector
-//===--------------------------------------------------------------------===//
-vector<unique_ptr<Vector>> &StructVector::GetEntries(Vector &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::STRUCT || vector.GetType().id() == LogicalTypeId::UNION);
-
-	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vector);
-		return StructVector::GetEntries(child);
-	}
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRUCT_BUFFER);
-	return vector.auxiliary->Cast<VectorStructBuffer>().GetChildren();
-}
-
-const vector<unique_ptr<Vector>> &StructVector::GetEntries(const Vector &vector) {
-	return GetEntries((Vector &)vector);
-}
-
-//===--------------------------------------------------------------------===//
-// ListVector
-//===--------------------------------------------------------------------===//
-template <class T>
-T &ListVector::GetEntryInternal(T &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST || vector.GetType().id() == LogicalTypeId::MAP);
-	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vector);
-		return ListVector::GetEntry(child);
-	}
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::LIST_BUFFER);
-	return vector.auxiliary->template Cast<VectorListBuffer>().GetChild();
-}
-
-const Vector &ListVector::GetEntry(const Vector &vector) {
-	return GetEntryInternal<const Vector>(vector);
-}
-
-Vector &ListVector::GetEntry(Vector &vector) {
-	return GetEntryInternal<Vector>(vector);
-}
-
-void ListVector::Reserve(Vector &vector, idx_t required_capacity) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST || vector.GetType().id() == LogicalTypeId::MAP);
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::LIST_BUFFER);
-	auto &child_buffer = vector.auxiliary->Cast<VectorListBuffer>();
-	child_buffer.Reserve(required_capacity);
-}
-
-idx_t ListVector::GetListSize(const Vector &vec) {
-	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vec);
-		return ListVector::GetListSize(child);
-	}
-	D_ASSERT(vec.auxiliary);
-	return vec.auxiliary->Cast<VectorListBuffer>().GetSize();
-}
-
-idx_t ListVector::GetListCapacity(const Vector &vec) {
-	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vec);
-		return ListVector::GetListSize(child);
-	}
-	D_ASSERT(vec.auxiliary);
-	return vec.auxiliary->Cast<VectorListBuffer>().GetCapacity();
-}
-
-void ListVector::ReferenceEntry(Vector &vector, Vector &other) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(other.GetType().id() == LogicalTypeId::LIST);
-	D_ASSERT(other.GetVectorType() == VectorType::FLAT_VECTOR || other.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	vector.auxiliary = other.auxiliary;
-}
-
-void ListVector::SetListSize(Vector &vec, idx_t size) {
-	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vec);
-		ListVector::SetListSize(child, size);
-		return;
-	}
-	vec.auxiliary->Cast<VectorListBuffer>().SetSize(size);
-}
-
-void ListVector::Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset) {
-	if (source_size - source_offset == 0) {
-		//! Nothing to add
-		return;
-	}
-	auto &target_buffer = target.auxiliary->Cast<VectorListBuffer>();
-	target_buffer.Append(source, source_size, source_offset);
-}
-
-void ListVector::Append(Vector &target, const Vector &source, const SelectionVector &sel, idx_t source_size,
-                        idx_t source_offset) {
-	if (source_size - source_offset == 0) {
-		//! Nothing to add
-		return;
-	}
-	auto &target_buffer = target.auxiliary->Cast<VectorListBuffer>();
-	target_buffer.Append(source, sel, source_size, source_offset);
-}
-
-void ListVector::PushBack(Vector &target, const Value &insert) {
-	auto &target_buffer = target.auxiliary.get()->Cast<VectorListBuffer>();
-	target_buffer.PushBack(insert);
-}
-
-idx_t ListVector::GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t count) {
-
-	auto info = ListVector::GetConsecutiveChildListInfo(list, offset, count);
-	if (info.needs_slicing) {
-		SelectionVector sel(info.child_list_info.length);
-		ListVector::GetConsecutiveChildSelVector(list, sel, offset, count);
-
-		result.Slice(sel, info.child_list_info.length);
-		result.Flatten(info.child_list_info.length);
-	}
-	return info.child_list_info.length;
-}
-
-ConsecutiveChildListInfo ListVector::GetConsecutiveChildListInfo(Vector &list, idx_t offset, idx_t count) {
-
-	ConsecutiveChildListInfo info;
-	UnifiedVectorFormat unified_list_data;
-	list.ToUnifiedFormat(offset + count, unified_list_data);
-	auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(unified_list_data);
-
-	// find the first non-NULL entry
-	idx_t first_length = 0;
-	for (idx_t i = offset; i < offset + count; i++) {
-		auto idx = unified_list_data.sel->get_index(i);
-		if (!unified_list_data.validity.RowIsValid(idx)) {
-			continue;
-		}
-		info.child_list_info.offset = list_data[idx].offset;
-		first_length = list_data[idx].length;
-		break;
-	}
-
-	// small performance improvement for constant vectors
-	// avoids iterating over all their (constant) elements
-	if (list.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		info.child_list_info.length = first_length;
-		return info;
-	}
-
-	// now get the child count and determine whether the children are stored consecutively
-	// also determine if a flat vector has pseudo constant values (all offsets + length the same)
-	// this can happen e.g. for UNNESTs
-	bool is_consecutive = true;
-	for (idx_t i = offset; i < offset + count; i++) {
-		auto idx = unified_list_data.sel->get_index(i);
-		if (!unified_list_data.validity.RowIsValid(idx)) {
-			continue;
-		}
-		if (list_data[idx].offset != info.child_list_info.offset || list_data[idx].length != first_length) {
-			info.is_constant = false;
-		}
-		if (list_data[idx].offset != info.child_list_info.offset + info.child_list_info.length) {
-			is_consecutive = false;
-		}
-		info.child_list_info.length += list_data[idx].length;
-	}
-
-	if (info.is_constant) {
-		info.child_list_info.length = first_length;
-	}
-	if (!info.is_constant && !is_consecutive) {
-		info.needs_slicing = true;
-	}
-
-	return info;
-}
-
-void ListVector::GetConsecutiveChildSelVector(Vector &list, SelectionVector &sel, idx_t offset, idx_t count) {
-	UnifiedVectorFormat unified_list_data;
-	list.ToUnifiedFormat(offset + count, unified_list_data);
-	auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(unified_list_data);
-
-	//	SelectionVector child_sel(info.second.length);
-	idx_t entry = 0;
-	for (idx_t i = offset; i < offset + count; i++) {
-		auto idx = unified_list_data.sel->get_index(i);
-		if (!unified_list_data.validity.RowIsValid(idx)) {
-			continue;
-		}
-		for (idx_t k = 0; k < list_data[idx].length; k++) {
-			//			child_sel.set_index(entry++, list_data[idx].offset + k);
-			sel.set_index(entry++, list_data[idx].offset + k);
-		}
-	}
-	//
-	//	result.Slice(child_sel, info.second.length);
-	//	result.Flatten(info.second.length);
-	//	info.second.offset = 0;
-}
-
-//===--------------------------------------------------------------------===//
-// UnionVector
-//===--------------------------------------------------------------------===//
-const Vector &UnionVector::GetMember(const Vector &vector, idx_t member_index) {
-	D_ASSERT(member_index < UnionType::GetMemberCount(vector.GetType()));
-	auto &entries = StructVector::GetEntries(vector);
-	return *entries[member_index + 1]; // skip the "tag" entry
-}
-
-Vector &UnionVector::GetMember(Vector &vector, idx_t member_index) {
-	D_ASSERT(member_index < UnionType::GetMemberCount(vector.GetType()));
-	auto &entries = StructVector::GetEntries(vector);
-	return *entries[member_index + 1]; // skip the "tag" entry
-}
-
-const Vector &UnionVector::GetTags(const Vector &vector) {
-	// the tag vector is always the first struct child.
-	return *StructVector::GetEntries(vector)[0];
-}
-
-Vector &UnionVector::GetTags(Vector &vector) {
-	// the tag vector is always the first struct child.
-	return *StructVector::GetEntries(vector)[0];
-}
-
-void UnionVector::SetToMember(Vector &union_vector, union_tag_t tag, Vector &member_vector, idx_t count,
-                              bool keep_tags_for_null) {
-	D_ASSERT(union_vector.GetType().id() == LogicalTypeId::UNION);
-	D_ASSERT(tag < UnionType::GetMemberCount(union_vector.GetType()));
-
-	// Set the union member to the specified vector
-	UnionVector::GetMember(union_vector, tag).Reference(member_vector);
-	auto &tag_vector = UnionVector::GetTags(union_vector);
-
-	if (member_vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// if the member vector is constant, we can set the union to constant as well
-		union_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::GetData<union_tag_t>(tag_vector)[0] = tag;
-		if (keep_tags_for_null) {
-			ConstantVector::SetNull(union_vector, false);
-			ConstantVector::SetNull(tag_vector, false);
-		} else {
-			ConstantVector::SetNull(union_vector, ConstantVector::IsNull(member_vector));
-			ConstantVector::SetNull(tag_vector, ConstantVector::IsNull(member_vector));
-		}
-
-	} else {
-		// otherwise flatten and set to flatvector
-		member_vector.Flatten(count);
-		union_vector.SetVectorType(VectorType::FLAT_VECTOR);
-
-		if (member_vector.validity.AllValid()) {
-			// if the member vector is all valid, we can set the tag to constant
-			tag_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			auto tag_data = ConstantVector::GetData<union_tag_t>(tag_vector);
-			*tag_data = tag;
-		} else {
-			tag_vector.SetVectorType(VectorType::FLAT_VECTOR);
-			if (keep_tags_for_null) {
-				FlatVector::Validity(tag_vector).SetAllValid(count);
-				FlatVector::Validity(union_vector).SetAllValid(count);
-			} else {
-				// ensure the tags have the same validity as the member
-				FlatVector::Validity(union_vector) = FlatVector::Validity(member_vector);
-				FlatVector::Validity(tag_vector) = FlatVector::Validity(member_vector);
-			}
-
-			auto tag_data = FlatVector::GetData<union_tag_t>(tag_vector);
-			memset(tag_data, tag, count);
-		}
-	}
-
-	// Set the non-selected members to constant null vectors
-	for (idx_t i = 0; i < UnionType::GetMemberCount(union_vector.GetType()); i++) {
-		if (i != tag) {
-			auto &member = UnionVector::GetMember(union_vector, i);
-			member.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(member, true);
-		}
-	}
-}
-
-bool UnionVector::TryGetTag(const Vector &vector, idx_t index, union_tag_t &result) {
-	// the tag vector is always the first struct child.
-	auto &tag_vector = *StructVector::GetEntries(vector)[0];
-	if (tag_vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(tag_vector);
-		auto &dict_sel = DictionaryVector::SelVector(tag_vector);
-		auto mapped_idx = dict_sel.get_index(index);
-		if (FlatVector::IsNull(child, mapped_idx)) {
-			return false;
-		} else {
-			result = FlatVector::GetData<union_tag_t>(child)[mapped_idx];
-			return true;
-		}
-	}
-	if (tag_vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (ConstantVector::IsNull(tag_vector)) {
-			return false;
-		} else {
-			result = ConstantVector::GetData<union_tag_t>(tag_vector)[0];
-			return true;
-		}
-	}
-	if (FlatVector::IsNull(tag_vector, index)) {
-		return false;
-	} else {
-		result = FlatVector::GetData<union_tag_t>(tag_vector)[index];
-		return true;
-	}
-}
-
-//! Raw selection vector passed in (not merged with any other selection vectors)
-UnionInvalidReason UnionVector::CheckUnionValidity(Vector &vector_p, idx_t count, const SelectionVector &sel_p) {
-	D_ASSERT(vector_p.GetType().id() == LogicalTypeId::UNION);
-
-	// Will contain the (possibly) merged selection vector
-	const SelectionVector *sel = &sel_p;
-	SelectionVector owned_sel;
-	Vector *vector = &vector_p;
-	if (vector->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		// In the case of a dictionary vector, unwrap the Vector, and merge the selection vectors.
-		auto &child = DictionaryVector::Child(*vector);
-		D_ASSERT(child.GetVectorType() != VectorType::DICTIONARY_VECTOR);
-		auto &dict_sel = DictionaryVector::SelVector(*vector);
-		// merge the selection vectors and verify the child
-		auto new_buffer = dict_sel.Slice(*sel, count);
-		owned_sel.Initialize(new_buffer);
-		sel = &owned_sel;
-		vector = &child;
-	} else if (vector->GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		sel = ConstantVector::ZeroSelectionVector(count, owned_sel);
-	}
-
-	auto member_count = UnionType::GetMemberCount(vector_p.GetType());
-	if (member_count == 0) {
-		return UnionInvalidReason::NO_MEMBERS;
-	}
-
-	UnifiedVectorFormat vector_vdata;
-	vector_p.ToUnifiedFormat(count, vector_vdata);
-
-	auto &entries = StructVector::GetEntries(vector_p);
-	duckdb::vector<UnifiedVectorFormat> child_vdata(entries.size());
-	for (idx_t entry_idx = 0; entry_idx < entries.size(); entry_idx++) {
-		auto &child = *entries[entry_idx];
-		child.ToUnifiedFormat(count, child_vdata[entry_idx]);
-	}
-
-	auto &tag_vdata = child_vdata[0];
-
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		auto mapped_idx = sel->get_index(row_idx);
-
-		if (!vector_vdata.validity.RowIsValid(mapped_idx)) {
-			continue;
-		}
-
-		auto tag_idx = tag_vdata.sel->get_index(sel_p.get_index(row_idx));
-		if (!tag_vdata.validity.RowIsValid(tag_idx)) {
-			// we can't have NULL tags!
-			return UnionInvalidReason::NULL_TAG;
-		}
-		auto tag = UnifiedVectorFormat::GetData<union_tag_t>(tag_vdata)[tag_idx];
-		if (tag >= member_count) {
-			return UnionInvalidReason::TAG_OUT_OF_RANGE;
-		}
-
-		bool found_valid = false;
-		for (idx_t i = 0; i < member_count; i++) {
-			auto &member_vdata = child_vdata[1 + i]; // skip the tag
-			idx_t member_idx = member_vdata.sel->get_index(sel_p.get_index(row_idx));
-			if (!member_vdata.validity.RowIsValid(member_idx)) {
-				continue;
-			}
-			if (found_valid) {
-				return UnionInvalidReason::VALIDITY_OVERLAP;
-			}
-			found_valid = true;
-			if (tag != static_cast<union_tag_t>(i)) {
-				return UnionInvalidReason::TAG_MISMATCH;
-			}
-		}
-	}
-
-	return UnionInvalidReason::VALID;
-}
-
-//===--------------------------------------------------------------------===//
-// ArrayVector
-//===--------------------------------------------------------------------===//
-template <class T>
-T &ArrayVector::GetEntryInternal(T &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::ARRAY);
-	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vector);
-		return ArrayVector::GetEntry(child);
-	}
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::ARRAY_BUFFER);
-	return vector.auxiliary->template Cast<VectorArrayBuffer>().GetChild();
-}
-
-const Vector &ArrayVector::GetEntry(const Vector &vector) {
-	return GetEntryInternal<const Vector>(vector);
-}
-
-Vector &ArrayVector::GetEntry(Vector &vector) {
-	return GetEntryInternal<Vector>(vector);
-}
-
-idx_t ArrayVector::GetTotalSize(const Vector &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::ARRAY);
-	D_ASSERT(vector.auxiliary);
-	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vector);
-		return ArrayVector::GetTotalSize(child);
-	}
-	return vector.auxiliary->Cast<VectorArrayBuffer>().GetChildSize();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/vector_buffer.cpp b/src/duckdb/src/common/types/vector_buffer.cpp
deleted file mode 100644
index aed61d192..000000000
--- a/src/duckdb/src/common/types/vector_buffer.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include "duckdb/common/types/vector_buffer.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateStandardVector(PhysicalType type, idx_t capacity) {
-	return make_buffer<VectorBuffer>(capacity * GetTypeIdSize(type));
-}
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateConstantVector(PhysicalType type) {
-	return make_buffer<VectorBuffer>(GetTypeIdSize(type));
-}
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateConstantVector(const LogicalType &type) {
-	return VectorBuffer::CreateConstantVector(type.InternalType());
-}
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateStandardVector(const LogicalType &type, idx_t capacity) {
-	return VectorBuffer::CreateStandardVector(type.InternalType(), capacity);
-}
-
-VectorStringBuffer::VectorStringBuffer() : VectorBuffer(VectorBufferType::STRING_BUFFER) {
-}
-
-VectorStringBuffer::VectorStringBuffer(VectorBufferType type) : VectorBuffer(type) {
-}
-
-VectorFSSTStringBuffer::VectorFSSTStringBuffer() : VectorStringBuffer(VectorBufferType::FSST_BUFFER) {
-}
-
-VectorStructBuffer::VectorStructBuffer() : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
-}
-
-VectorStructBuffer::VectorStructBuffer(const LogicalType &type, idx_t capacity)
-    : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
-	auto &child_types = StructType::GetChildTypes(type);
-	for (auto &child_type : child_types) {
-		auto vector = make_uniq<Vector>(child_type.second, capacity);
-		children.push_back(std::move(vector));
-	}
-}
-
-VectorStructBuffer::VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count)
-    : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
-	auto &other_vector = StructVector::GetEntries(other);
-	for (auto &child_vector : other_vector) {
-		auto vector = make_uniq<Vector>(*child_vector, sel, count);
-		children.push_back(std::move(vector));
-	}
-}
-
-VectorStructBuffer::~VectorStructBuffer() {
-}
-
-VectorListBuffer::VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), child(std::move(vector)), capacity(initial_capacity) {
-}
-
-VectorListBuffer::VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER),
-      child(make_uniq<Vector>(ListType::GetChildType(list_type), initial_capacity)), capacity(initial_capacity) {
-}
-
-void VectorListBuffer::Reserve(idx_t to_reserve) {
-	if (to_reserve > capacity) {
-		if (to_reserve > DConstants::MAX_VECTOR_SIZE) {
-			// overflow: throw an exception
-			throw OutOfRangeException("Cannot resize vector to %d rows: maximum allowed vector size is %s", to_reserve,
-			                          StringUtil::BytesToHumanReadableString(DConstants::MAX_VECTOR_SIZE));
-		}
-		idx_t new_capacity = NextPowerOfTwo(to_reserve);
-		D_ASSERT(new_capacity >= to_reserve);
-		child->Resize(capacity, new_capacity);
-		capacity = new_capacity;
-	}
-}
-
-void VectorListBuffer::Append(const Vector &to_append, idx_t to_append_size, idx_t source_offset) {
-	Reserve(size + to_append_size - source_offset);
-	VectorOperations::Copy(to_append, *child, to_append_size, source_offset, size);
-	size += to_append_size - source_offset;
-}
-
-void VectorListBuffer::Append(const Vector &to_append, const SelectionVector &sel, idx_t to_append_size,
-                              idx_t source_offset) {
-	Reserve(size + to_append_size - source_offset);
-	VectorOperations::Copy(to_append, *child, sel, to_append_size, source_offset, size);
-	size += to_append_size - source_offset;
-}
-
-void VectorListBuffer::PushBack(const Value &insert) {
-	while (size + 1 > capacity) {
-		child->Resize(capacity, capacity * 2);
-		capacity *= 2;
-	}
-	child->SetValue(size++, insert);
-}
-
-void VectorListBuffer::SetCapacity(idx_t new_capacity) {
-	this->capacity = new_capacity;
-}
-
-void VectorListBuffer::SetSize(idx_t new_size) {
-	this->size = new_size;
-}
-
-VectorListBuffer::~VectorListBuffer() {
-}
-
-VectorArrayBuffer::VectorArrayBuffer(unique_ptr<Vector> child_vector, idx_t array_size, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::ARRAY_BUFFER), child(std::move(child_vector)), array_size(array_size),
-      size(initial_capacity) {
-	D_ASSERT(array_size != 0);
-}
-
-VectorArrayBuffer::VectorArrayBuffer(const LogicalType &array, idx_t initial)
-    : VectorBuffer(VectorBufferType::ARRAY_BUFFER),
-      child(make_uniq<Vector>(ArrayType::GetChildType(array), initial * ArrayType::GetSize(array))),
-      array_size(ArrayType::GetSize(array)), size(initial) {
-	// initialize the child array with (array_size * size) ^
-	D_ASSERT(!ArrayType::IsAnySize(array));
-}
-
-VectorArrayBuffer::~VectorArrayBuffer() {
-}
-
-Vector &VectorArrayBuffer::GetChild() {
-	return *child;
-}
-
-idx_t VectorArrayBuffer::GetArraySize() {
-	return array_size;
-}
-
-idx_t VectorArrayBuffer::GetChildSize() {
-	return size * array_size;
-}
-
-ManagedVectorBuffer::ManagedVectorBuffer(BufferHandle handle)
-    : VectorBuffer(VectorBufferType::MANAGED_BUFFER), handle(std::move(handle)) {
-}
-
-ManagedVectorBuffer::~ManagedVectorBuffer() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/vector_cache.cpp b/src/duckdb/src/common/types/vector_cache.cpp
deleted file mode 100644
index 49ffe3579..000000000
--- a/src/duckdb/src/common/types/vector_cache.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include "duckdb/common/types/vector_cache.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-class VectorCacheBuffer : public VectorBuffer {
-public:
-	explicit VectorCacheBuffer(Allocator &allocator, const LogicalType &type_p, idx_t capacity_p = STANDARD_VECTOR_SIZE)
-	    : VectorBuffer(VectorBufferType::OPAQUE_BUFFER), type(type_p), capacity(capacity_p) {
-		auto internal_type = type.InternalType();
-		switch (internal_type) {
-		case PhysicalType::LIST: {
-			// memory for the list offsets
-			owned_data = allocator.Allocate(capacity * GetTypeIdSize(internal_type));
-			// child data of the list
-			auto &child_type = ListType::GetChildType(type);
-			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type, capacity));
-			auto child_vector = make_uniq<Vector>(child_type, false, false);
-			auxiliary = make_shared_ptr<VectorListBuffer>(std::move(child_vector));
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			auto &child_type = ArrayType::GetChildType(type);
-			auto array_size = ArrayType::GetSize(type);
-			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type, array_size * capacity));
-			auto child_vector = make_uniq<Vector>(child_type, true, false, array_size * capacity);
-			auxiliary = make_shared_ptr<VectorArrayBuffer>(std::move(child_vector), array_size, capacity);
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto &child_types = StructType::GetChildTypes(type);
-			for (auto &child_type : child_types) {
-				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second, capacity));
-			}
-			auto struct_buffer = make_shared_ptr<VectorStructBuffer>(type);
-			auxiliary = std::move(struct_buffer);
-			break;
-		}
-		default:
-			owned_data = allocator.Allocate(capacity * GetTypeIdSize(internal_type));
-			break;
-		}
-	}
-
-	void ResetFromCache(Vector &result, const buffer_ptr<VectorBuffer> &buffer) {
-		D_ASSERT(type == result.GetType());
-		auto internal_type = type.InternalType();
-		result.vector_type = VectorType::FLAT_VECTOR;
-		AssignSharedPointer(result.buffer, buffer);
-		result.validity.Reset(capacity);
-		switch (internal_type) {
-		case PhysicalType::LIST: {
-			result.data = owned_data.get();
-			// reinitialize the VectorListBuffer
-			AssignSharedPointer(result.auxiliary, auxiliary);
-			// propagate through child
-			auto &child_cache = child_caches[0]->Cast<VectorCacheBuffer>();
-			auto &list_buffer = result.auxiliary->Cast<VectorListBuffer>();
-			list_buffer.SetCapacity(child_cache.capacity);
-			list_buffer.SetSize(0);
-			list_buffer.SetAuxiliaryData(nullptr);
-
-			auto &list_child = list_buffer.GetChild();
-			child_cache.ResetFromCache(list_child, child_caches[0]);
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			// fixed size list does not have own data
-			result.data = nullptr;
-			// reinitialize the VectorArrayBuffer
-			// auxiliary->SetAuxiliaryData(nullptr);
-			AssignSharedPointer(result.auxiliary, auxiliary);
-
-			// propagate through child
-			auto &child_cache = child_caches[0]->Cast<VectorCacheBuffer>();
-			auto &array_child = result.auxiliary->Cast<VectorArrayBuffer>().GetChild();
-			child_cache.ResetFromCache(array_child, child_caches[0]);
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			// struct does not have data
-			result.data = nullptr;
-			// reinitialize the VectorStructBuffer
-			auxiliary->SetAuxiliaryData(nullptr);
-			AssignSharedPointer(result.auxiliary, auxiliary);
-			// propagate through children
-			auto &children = result.auxiliary->Cast<VectorStructBuffer>().GetChildren();
-			for (idx_t i = 0; i < children.size(); i++) {
-				auto &child_cache = child_caches[i]->Cast<VectorCacheBuffer>();
-				child_cache.ResetFromCache(*children[i], child_caches[i]);
-			}
-			break;
-		}
-		default:
-			// regular type: no aux data and reset data to cached data
-			result.data = owned_data.get();
-			result.auxiliary.reset();
-			break;
-		}
-	}
-
-	const LogicalType &GetType() {
-		return type;
-	}
-
-private:
-	//! The type of the vector cache
-	LogicalType type;
-	//! Owned data
-	AllocatedData owned_data;
-	//! Child caches (if any). Used for nested types.
-	vector<buffer_ptr<VectorBuffer>> child_caches;
-	//! Aux data for the vector (if any)
-	buffer_ptr<VectorBuffer> auxiliary;
-	//! Capacity of the vector
-	idx_t capacity;
-};
-
-VectorCache::VectorCache() : buffer(nullptr) {
-}
-
-VectorCache::VectorCache(Allocator &allocator, const LogicalType &type_p, const idx_t capacity_p) {
-	buffer = make_buffer<VectorCacheBuffer>(allocator, type_p, capacity_p);
-}
-
-void VectorCache::ResetFromCache(Vector &result) const {
-	if (!buffer) {
-		return;
-	}
-	auto &vector_cache = buffer->Cast<VectorCacheBuffer>();
-	vector_cache.ResetFromCache(result, buffer);
-}
-
-const LogicalType &VectorCache::GetType() const {
-	D_ASSERT(buffer);
-	auto &vector_cache = buffer->Cast<VectorCacheBuffer>();
-	return vector_cache.GetType();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/types/vector_constants.cpp b/src/duckdb/src/common/types/vector_constants.cpp
deleted file mode 100644
index 78c7fb5b2..000000000
--- a/src/duckdb/src/common/types/vector_constants.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-const SelectionVector *ConstantVector::ZeroSelectionVector() {
-	static const SelectionVector ZERO_SELECTION_VECTOR =
-	    SelectionVector(const_cast<sel_t *>(ConstantVector::ZERO_VECTOR)); // NOLINT
-	return &ZERO_SELECTION_VECTOR;
-}
-
-const SelectionVector *FlatVector::IncrementalSelectionVector() {
-	static const SelectionVector INCREMENTAL_SELECTION_VECTOR;
-	return &INCREMENTAL_SELECTION_VECTOR;
-}
-
-const sel_t ConstantVector::ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/value_operations/comparison_operations.cpp b/src/duckdb/src/common/value_operations/comparison_operations.cpp
deleted file mode 100644
index b2d59b0b5..000000000
--- a/src/duckdb/src/common/value_operations/comparison_operations.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Comparison Operations
-//===--------------------------------------------------------------------===//
-
-struct ValuePositionComparator {
-	// Return true if the positional Values definitely match.
-	// Default to the same as the final value
-	template <typename OP>
-	static inline bool Definite(const Value &lhs, const Value &rhs) {
-		return Final<OP>(lhs, rhs);
-	}
-
-	// Select the positional Values that need further testing.
-	// Usually this means Is Not Distinct, as those are the semantics used by Postges
-	template <typename OP>
-	static inline bool Possible(const Value &lhs, const Value &rhs) {
-		return ValueOperations::NotDistinctFrom(lhs, rhs);
-	}
-
-	// Return true if the positional Values definitely match in the final position
-	// This needs to be specialised.
-	template <typename OP>
-	static inline bool Final(const Value &lhs, const Value &rhs) {
-		return false;
-	}
-
-	// Tie-break based on length when one of the sides has been exhausted, returning true if the LHS matches.
-	// This essentially means that the existing positions compare equal.
-	// Default to the same semantics as the OP for idx_t. This works in most cases.
-	template <typename OP>
-	static inline bool TieBreak(const idx_t lpos, const idx_t rpos) {
-		return OP::Operation(lpos, rpos);
-	}
-};
-
-// Equals must always check every column
-template <>
-inline bool ValuePositionComparator::Definite<duckdb::Equals>(const Value &lhs, const Value &rhs) {
-	return false;
-}
-
-template <>
-inline bool ValuePositionComparator::Final<duckdb::Equals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::NotDistinctFrom(lhs, rhs);
-}
-
-// NotEquals must check everything that matched
-template <>
-inline bool ValuePositionComparator::Possible<duckdb::NotEquals>(const Value &lhs, const Value &rhs) {
-	return true;
-}
-
-template <>
-inline bool ValuePositionComparator::Final<duckdb::NotEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::NotDistinctFrom(lhs, rhs);
-}
-
-// Non-strict inequalities must use strict comparisons for Definite
-template <>
-bool ValuePositionComparator::Definite<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
-	return !ValuePositionComparator::Definite<duckdb::GreaterThan>(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::GreaterThan>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThan(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
-	return !ValuePositionComparator::Final<duckdb::GreaterThan>(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Definite<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
-	return !ValuePositionComparator::Definite<duckdb::GreaterThan>(rhs, lhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
-	return !ValuePositionComparator::Final<duckdb::GreaterThan>(rhs, lhs);
-}
-
-// Strict inequalities just use strict for both Definite and Final
-template <>
-bool ValuePositionComparator::Final<duckdb::LessThan>(const Value &lhs, const Value &rhs) {
-	return ValuePositionComparator::Final<duckdb::GreaterThan>(rhs, lhs);
-}
-
-template <class OP>
-static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
-	const auto &left_type = left.type();
-	const auto &right_type = right.type();
-	if (left_type != right_type) {
-		Value left_copy = left;
-		Value right_copy = right;
-
-		auto comparison_type = LogicalType::ForceMaxLogicalType(left_type, right_type);
-		if (!left_copy.DefaultTryCastAs(comparison_type) || !right_copy.DefaultTryCastAs(comparison_type)) {
-			return false;
-		}
-		D_ASSERT(left_copy.type() == right_copy.type());
-		return TemplatedBooleanOperation<OP>(left_copy, right_copy);
-	}
-	switch (left_type.InternalType()) {
-	case PhysicalType::BOOL:
-		return OP::Operation(left.GetValueUnsafe<bool>(), right.GetValueUnsafe<bool>());
-	case PhysicalType::INT8:
-		return OP::Operation(left.GetValueUnsafe<int8_t>(), right.GetValueUnsafe<int8_t>());
-	case PhysicalType::INT16:
-		return OP::Operation(left.GetValueUnsafe<int16_t>(), right.GetValueUnsafe<int16_t>());
-	case PhysicalType::INT32:
-		return OP::Operation(left.GetValueUnsafe<int32_t>(), right.GetValueUnsafe<int32_t>());
-	case PhysicalType::INT64:
-		return OP::Operation(left.GetValueUnsafe<int64_t>(), right.GetValueUnsafe<int64_t>());
-	case PhysicalType::UINT8:
-		return OP::Operation(left.GetValueUnsafe<uint8_t>(), right.GetValueUnsafe<uint8_t>());
-	case PhysicalType::UINT16:
-		return OP::Operation(left.GetValueUnsafe<uint16_t>(), right.GetValueUnsafe<uint16_t>());
-	case PhysicalType::UINT32:
-		return OP::Operation(left.GetValueUnsafe<uint32_t>(), right.GetValueUnsafe<uint32_t>());
-	case PhysicalType::UINT64:
-		return OP::Operation(left.GetValueUnsafe<uint64_t>(), right.GetValueUnsafe<uint64_t>());
-	case PhysicalType::UINT128:
-		return OP::Operation(left.GetValueUnsafe<uhugeint_t>(), right.GetValueUnsafe<uhugeint_t>());
-	case PhysicalType::INT128:
-		return OP::Operation(left.GetValueUnsafe<hugeint_t>(), right.GetValueUnsafe<hugeint_t>());
-	case PhysicalType::FLOAT:
-		return OP::Operation(left.GetValueUnsafe<float>(), right.GetValueUnsafe<float>());
-	case PhysicalType::DOUBLE:
-		return OP::Operation(left.GetValueUnsafe<double>(), right.GetValueUnsafe<double>());
-	case PhysicalType::INTERVAL:
-		return OP::Operation(left.GetValueUnsafe<interval_t>(), right.GetValueUnsafe<interval_t>());
-	case PhysicalType::VARCHAR:
-		return OP::Operation(StringValue::Get(left), StringValue::Get(right));
-	case PhysicalType::STRUCT: {
-		auto &left_children = StructValue::GetChildren(left);
-		auto &right_children = StructValue::GetChildren(right);
-		// this should be enforced by the type
-		D_ASSERT(left_children.size() == right_children.size());
-		idx_t i = 0;
-		for (; i < left_children.size() - 1; ++i) {
-			if (ValuePositionComparator::Definite<OP>(left_children[i], right_children[i])) {
-				return true;
-			}
-			if (!ValuePositionComparator::Possible<OP>(left_children[i], right_children[i])) {
-				return false;
-			}
-		}
-		return ValuePositionComparator::Final<OP>(left_children[i], right_children[i]);
-	}
-	case PhysicalType::LIST: {
-		auto &left_children = ListValue::GetChildren(left);
-		auto &right_children = ListValue::GetChildren(right);
-		for (idx_t pos = 0;; ++pos) {
-			if (pos == left_children.size() || pos == right_children.size()) {
-				return ValuePositionComparator::TieBreak<OP>(left_children.size(), right_children.size());
-			}
-			if (ValuePositionComparator::Definite<OP>(left_children[pos], right_children[pos])) {
-				return true;
-			}
-			if (!ValuePositionComparator::Possible<OP>(left_children[pos], right_children[pos])) {
-				return false;
-			}
-		}
-		return false;
-	}
-	case PhysicalType::ARRAY: {
-		auto &left_children = ArrayValue::GetChildren(left);
-		auto &right_children = ArrayValue::GetChildren(right);
-
-		// Should be enforced by the type
-		D_ASSERT(left_children.size() == right_children.size());
-
-		for (idx_t i = 0; i < left_children.size(); i++) {
-			if (ValuePositionComparator::Definite<OP>(left_children[i], right_children[i])) {
-				return true;
-			}
-			if (!ValuePositionComparator::Possible<OP>(left_children[i], right_children[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		throw InternalException("Unimplemented type for value comparison");
-	}
-}
-
-bool ValueOperations::Equals(const Value &left, const Value &right) {
-	if (left.IsNull() || right.IsNull()) {
-		throw InternalException("Comparison on NULL values");
-	}
-	return TemplatedBooleanOperation<duckdb::Equals>(left, right);
-}
-
-bool ValueOperations::NotEquals(const Value &left, const Value &right) {
-	return !ValueOperations::Equals(left, right);
-}
-
-bool ValueOperations::GreaterThan(const Value &left, const Value &right) {
-	if (left.IsNull() || right.IsNull()) {
-		throw InternalException("Comparison on NULL values");
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThan>(left, right);
-}
-
-bool ValueOperations::GreaterThanEquals(const Value &left, const Value &right) {
-	return !ValueOperations::GreaterThan(right, left);
-}
-
-bool ValueOperations::LessThan(const Value &left, const Value &right) {
-	return ValueOperations::GreaterThan(right, left);
-}
-
-bool ValueOperations::LessThanEquals(const Value &left, const Value &right) {
-	return !ValueOperations::GreaterThan(left, right);
-}
-
-bool ValueOperations::NotDistinctFrom(const Value &left, const Value &right) {
-	if (left.IsNull() && right.IsNull()) {
-		return true;
-	}
-	if (left.IsNull() != right.IsNull()) {
-		return false;
-	}
-	return TemplatedBooleanOperation<duckdb::Equals>(left, right);
-}
-
-bool ValueOperations::DistinctFrom(const Value &left, const Value &right) {
-	return !ValueOperations::NotDistinctFrom(left, right);
-}
-
-bool ValueOperations::DistinctGreaterThan(const Value &left, const Value &right) {
-	if (left.IsNull() && right.IsNull()) {
-		return false;
-	} else if (right.IsNull()) {
-		return false;
-	} else if (left.IsNull()) {
-		return true;
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThan>(left, right);
-}
-
-bool ValueOperations::DistinctGreaterThanEquals(const Value &left, const Value &right) {
-	return !ValueOperations::DistinctGreaterThan(right, left);
-}
-
-bool ValueOperations::DistinctLessThan(const Value &left, const Value &right) {
-	return ValueOperations::DistinctGreaterThan(right, left);
-}
-
-bool ValueOperations::DistinctLessThanEquals(const Value &left, const Value &right) {
-	return !ValueOperations::DistinctGreaterThan(left, right);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/boolean_operators.cpp b/src/duckdb/src/common/vector_operations/boolean_operators.cpp
deleted file mode 100644
index 667c92085..000000000
--- a/src/duckdb/src/common/vector_operations/boolean_operators.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//===--------------------------------------------------------------------===//
-// boolean_operators.cpp
-// Description: This file contains the implementation of the boolean
-// operations AND OR !
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// AND/OR
-//===--------------------------------------------------------------------===//
-template <class OP>
-static void TemplatedBooleanNullmask(Vector &left, Vector &right, Vector &result, idx_t count) {
-	D_ASSERT(left.GetType().id() == LogicalTypeId::BOOLEAN && right.GetType().id() == LogicalTypeId::BOOLEAN &&
-	         result.GetType().id() == LogicalTypeId::BOOLEAN);
-
-	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// operation on two constants, result is constant vector
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto ldata = ConstantVector::GetData<uint8_t>(left);
-		auto rdata = ConstantVector::GetData<uint8_t>(right);
-		auto result_data = ConstantVector::GetData<bool>(result);
-
-		bool is_null = OP::Operation(*ldata > 0, *rdata > 0, ConstantVector::IsNull(left),
-		                             ConstantVector::IsNull(right), *result_data);
-		ConstantVector::SetNull(result, is_null);
-	} else {
-		// perform generic loop
-		UnifiedVectorFormat ldata, rdata;
-		left.ToUnifiedFormat(count, ldata);
-		right.ToUnifiedFormat(count, rdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto left_data = UnifiedVectorFormat::GetData<uint8_t>(ldata); // we use uint8 to avoid load of gunk bools
-		auto right_data = UnifiedVectorFormat::GetData<uint8_t>(rdata);
-		auto result_data = FlatVector::GetData<bool>(result);
-		auto &result_mask = FlatVector::Validity(result);
-		if (!ldata.validity.AllValid() || !rdata.validity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto lidx = ldata.sel->get_index(i);
-				auto ridx = rdata.sel->get_index(i);
-				bool is_null =
-				    OP::Operation(left_data[lidx] > 0, right_data[ridx] > 0, !ldata.validity.RowIsValid(lidx),
-				                  !rdata.validity.RowIsValid(ridx), result_data[i]);
-				result_mask.Set(i, !is_null);
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto lidx = ldata.sel->get_index(i);
-				auto ridx = rdata.sel->get_index(i);
-				result_data[i] = OP::SimpleOperation(left_data[lidx], right_data[ridx]);
-			}
-		}
-	}
-}
-
-/*
-SQL AND Rules:
-
-TRUE  AND TRUE   = TRUE
-TRUE  AND FALSE  = FALSE
-TRUE  AND NULL   = NULL
-FALSE AND TRUE   = FALSE
-FALSE AND FALSE  = FALSE
-FALSE AND NULL   = FALSE
-NULL  AND TRUE   = NULL
-NULL  AND FALSE  = FALSE
-NULL  AND NULL   = NULL
-
-Basically:
-- Only true if both are true
-- False if either is false (regardless of NULLs)
-- NULL otherwise
-*/
-struct TernaryAnd {
-	static bool SimpleOperation(bool left, bool right) {
-		return left && right;
-	}
-	static bool Operation(bool left, bool right, bool left_null, bool right_null, bool &result) {
-		if (left_null && right_null) {
-			// both NULL:
-			// result is NULL
-			return true;
-		} else if (left_null) {
-			// left is NULL:
-			// result is FALSE if right is false
-			// result is NULL if right is true
-			result = right;
-			return right;
-		} else if (right_null) {
-			// right is NULL:
-			// result is FALSE if left is false
-			// result is NULL if left is true
-			result = left;
-			return left;
-		} else {
-			// no NULL: perform the AND
-			result = left && right;
-			return false;
-		}
-	}
-};
-
-void VectorOperations::And(Vector &left, Vector &right, Vector &result, idx_t count) {
-	TemplatedBooleanNullmask<TernaryAnd>(left, right, result, count);
-}
-
-/*
-SQL OR Rules:
-
-OR
-TRUE  OR TRUE  = TRUE
-TRUE  OR FALSE = TRUE
-TRUE  OR NULL  = TRUE
-FALSE OR TRUE  = TRUE
-FALSE OR FALSE = FALSE
-FALSE OR NULL  = NULL
-NULL  OR TRUE  = TRUE
-NULL  OR FALSE = NULL
-NULL  OR NULL  = NULL
-
-Basically:
-- Only false if both are false
-- True if either is true (regardless of NULLs)
-- NULL otherwise
-*/
-
-struct TernaryOr {
-	static bool SimpleOperation(bool left, bool right) {
-		return left || right;
-	}
-	static bool Operation(bool left, bool right, bool left_null, bool right_null, bool &result) {
-		if (left_null && right_null) {
-			// both NULL:
-			// result is NULL
-			return true;
-		} else if (left_null) {
-			// left is NULL:
-			// result is TRUE if right is true
-			// result is NULL if right is false
-			result = right;
-			return !right;
-		} else if (right_null) {
-			// right is NULL:
-			// result is TRUE if left is true
-			// result is NULL if left is false
-			result = left;
-			return !left;
-		} else {
-			// no NULL: perform the OR
-			result = left || right;
-			return false;
-		}
-	}
-};
-
-void VectorOperations::Or(Vector &left, Vector &right, Vector &result, idx_t count) {
-	TemplatedBooleanNullmask<TernaryOr>(left, right, result, count);
-}
-
-struct NotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return !left;
-	}
-};
-
-void VectorOperations::Not(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType() == LogicalType::BOOLEAN && result.GetType() == LogicalType::BOOLEAN);
-	UnaryExecutor::Execute<bool, bool, NotOperator>(input, result, count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/comparison_operators.cpp b/src/duckdb/src/common/vector_operations/comparison_operators.cpp
deleted file mode 100644
index 9c5c3d662..000000000
--- a/src/duckdb/src/common/vector_operations/comparison_operators.cpp
+++ /dev/null
@@ -1,308 +0,0 @@
-//===--------------------------------------------------------------------===//
-// comparison_operators.cpp
-// Description: This file contains the implementation of the comparison
-// operations == != >= <= > <
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/operator/comparison_operators.hpp"
-
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include "duckdb/common/likely.hpp"
-
-namespace duckdb {
-
-template <class T>
-bool EqualsFloat(T left, T right) {
-	if (DUCKDB_UNLIKELY(Value::IsNan(left) && Value::IsNan(right))) {
-		return true;
-	}
-	return left == right;
-}
-
-template <>
-bool Equals::Operation(const float &left, const float &right) {
-	return EqualsFloat<float>(left, right);
-}
-
-template <>
-bool Equals::Operation(const double &left, const double &right) {
-	return EqualsFloat<double>(left, right);
-}
-
-template <class T>
-bool GreaterThanFloat(T left, T right) {
-	// handle nans
-	// nan is always bigger than everything else
-	bool left_is_nan = Value::IsNan(left);
-	bool right_is_nan = Value::IsNan(right);
-	// if right is nan, there is no number that is bigger than right
-	if (DUCKDB_UNLIKELY(right_is_nan)) {
-		return false;
-	}
-	// if left is nan, but right is not, left is always bigger
-	if (DUCKDB_UNLIKELY(left_is_nan)) {
-		return true;
-	}
-	return left > right;
-}
-
-template <>
-bool GreaterThan::Operation(const float &left, const float &right) {
-	return GreaterThanFloat<float>(left, right);
-}
-
-template <>
-bool GreaterThan::Operation(const double &left, const double &right) {
-	return GreaterThanFloat<double>(left, right);
-}
-
-template <class T>
-bool GreaterThanEqualsFloat(T left, T right) {
-	// handle nans
-	// nan is always bigger than everything else
-	bool left_is_nan = Value::IsNan(left);
-	bool right_is_nan = Value::IsNan(right);
-	// if right is nan, there is no bigger number
-	// we only return true if left is also nan (in which case the numbers are equal)
-	if (DUCKDB_UNLIKELY(right_is_nan)) {
-		return left_is_nan;
-	}
-	// if left is nan, but right is not, left is always bigger
-	if (DUCKDB_UNLIKELY(left_is_nan)) {
-		return true;
-	}
-	return left >= right;
-}
-
-template <>
-bool GreaterThanEquals::Operation(const float &left, const float &right) {
-	return GreaterThanEqualsFloat<float>(left, right);
-}
-
-template <>
-bool GreaterThanEquals::Operation(const double &left, const double &right) {
-	return GreaterThanEqualsFloat<double>(left, right);
-}
-
-struct ComparisonSelector {
-	template <typename OP>
-	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel, ValidityMask &null_mask) {
-		throw NotImplementedException("Unknown comparison operation!");
-	}
-};
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::Equals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                        idx_t count, SelectionVector *true_sel,
-                                                        SelectionVector *false_sel, ValidityMask &null_mask) {
-	return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel, &null_mask);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                           idx_t count, SelectionVector *true_sel,
-                                                           SelectionVector *false_sel, ValidityMask &null_mask) {
-	return VectorOperations::NotEquals(left, right, sel, count, true_sel, false_sel, &null_mask);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                             idx_t count, SelectionVector *true_sel,
-                                                             SelectionVector *false_sel, ValidityMask &null_mask) {
-	return VectorOperations::GreaterThan(left, right, sel, count, true_sel, false_sel, &null_mask);
-}
-
-template <>
-inline idx_t
-ComparisonSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                      idx_t count, SelectionVector *true_sel,
-                                                      SelectionVector *false_sel, ValidityMask &null_mask) {
-	return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, false_sel, &null_mask);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                          idx_t count, SelectionVector *true_sel,
-                                                          SelectionVector *false_sel, ValidityMask &null_mask) {
-	return VectorOperations::GreaterThan(right, left, sel, count, true_sel, false_sel, &null_mask);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                                idx_t count, SelectionVector *true_sel,
-                                                                SelectionVector *false_sel, ValidityMask &null_mask) {
-	return VectorOperations::GreaterThanEquals(right, left, sel, count, true_sel, false_sel, &null_mask);
-}
-
-static void ComparesNotNull(UnifiedVectorFormat &ldata, UnifiedVectorFormat &rdata, ValidityMask &vresult,
-                            idx_t count) {
-	for (idx_t i = 0; i < count; ++i) {
-		auto lidx = ldata.sel->get_index(i);
-		auto ridx = rdata.sel->get_index(i);
-		if (!ldata.validity.RowIsValid(lidx) || !rdata.validity.RowIsValid(ridx)) {
-			vresult.SetInvalid(i);
-		}
-	}
-}
-
-template <typename OP>
-static void NestedComparisonExecutor(Vector &left, Vector &right, Vector &result, idx_t count) {
-	const auto left_constant = left.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	const auto right_constant = right.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-	if ((left_constant && ConstantVector::IsNull(left)) || (right_constant && ConstantVector::IsNull(right))) {
-		// either left or right is constant NULL: result is constant NULL
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	if (left_constant && right_constant) {
-		// both sides are constant, and neither is NULL so just compare one element.
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto &result_validity = ConstantVector::Validity(result);
-		SelectionVector true_sel(1);
-		auto match_count = ComparisonSelector::Select<OP>(left, right, nullptr, 1, &true_sel, nullptr, result_validity);
-		// since we are dealing with nested types where the values are not NULL, the result is always valid (i.e true or
-		// false)
-		result_validity.SetAllValid(1);
-		auto result_data = ConstantVector::GetData<bool>(result);
-		result_data[0] = match_count > 0;
-		return;
-	}
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<bool>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	UnifiedVectorFormat leftv, rightv;
-	left.ToUnifiedFormat(count, leftv);
-	right.ToUnifiedFormat(count, rightv);
-	if (!leftv.validity.AllValid() || !rightv.validity.AllValid()) {
-		ComparesNotNull(leftv, rightv, result_validity, count);
-	}
-	ValidityMask original_mask;
-	original_mask.SetAllValid(count);
-	original_mask.Copy(result_validity, count);
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-	idx_t match_count =
-	    ComparisonSelector::Select<OP>(left, right, nullptr, count, &true_sel, &false_sel, result_validity);
-
-	for (idx_t i = 0; i < match_count; ++i) {
-		const auto idx = true_sel.get_index(i);
-		result_data[idx] = true;
-		// if the row was valid during the null check, set it to valid here as well
-		if (original_mask.RowIsValid(idx)) {
-			result_validity.SetValid(idx);
-		}
-	}
-
-	const idx_t no_match_count = count - match_count;
-	for (idx_t i = 0; i < no_match_count; ++i) {
-		const auto idx = false_sel.get_index(i);
-		result_data[idx] = false;
-		if (original_mask.RowIsValid(idx)) {
-			result_validity.SetValid(idx);
-		}
-	}
-}
-
-struct ComparisonExecutor {
-private:
-	template <class T, class OP>
-	static inline void TemplatedExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		BinaryExecutor::Execute<T, T, bool, OP>(left, right, result, count);
-	}
-
-public:
-	template <class OP>
-	static inline void Execute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		D_ASSERT(left.GetType().InternalType() == right.GetType().InternalType() &&
-		         result.GetType() == LogicalType::BOOLEAN);
-		// the inplace loops take the result as the last parameter
-		switch (left.GetType().InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			TemplatedExecute<int8_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT16:
-			TemplatedExecute<int16_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT32:
-			TemplatedExecute<int32_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT64:
-			TemplatedExecute<int64_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT8:
-			TemplatedExecute<uint8_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT16:
-			TemplatedExecute<uint16_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT32:
-			TemplatedExecute<uint32_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT64:
-			TemplatedExecute<uint64_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT128:
-			TemplatedExecute<hugeint_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT128:
-			TemplatedExecute<uhugeint_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::FLOAT:
-			TemplatedExecute<float, OP>(left, right, result, count);
-			break;
-		case PhysicalType::DOUBLE:
-			TemplatedExecute<double, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INTERVAL:
-			TemplatedExecute<interval_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::VARCHAR:
-			TemplatedExecute<string_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::LIST:
-		case PhysicalType::STRUCT:
-		case PhysicalType::ARRAY:
-			NestedComparisonExecutor<OP>(left, right, result, count);
-			break;
-		default:
-			throw InternalException("Invalid type for comparison");
-		}
-	}
-};
-
-void VectorOperations::Equals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::Equals>(left, right, result, count);
-}
-
-void VectorOperations::NotEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::NotEquals>(left, right, result, count);
-}
-
-void VectorOperations::GreaterThanEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::GreaterThanEquals>(left, right, result, count);
-}
-
-void VectorOperations::LessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::GreaterThanEquals>(right, left, result, count);
-}
-
-void VectorOperations::GreaterThan(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::GreaterThan>(left, right, result, count);
-}
-
-void VectorOperations::LessThan(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::GreaterThan>(right, left, result, count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/generators.cpp b/src/duckdb/src/common/vector_operations/generators.cpp
deleted file mode 100644
index 2fc5b67c6..000000000
--- a/src/duckdb/src/common/vector_operations/generators.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//===--------------------------------------------------------------------===//
-// generators.cpp
-// Description: This file contains the implementation of different generators
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-template <class T>
-void TemplatedGenerateSequence(Vector &result, idx_t count, int64_t start, int64_t increment) {
-	D_ASSERT(result.GetType().IsNumeric());
-	if (start > NumericLimits<T>::Maximum() || increment > NumericLimits<T>::Maximum()) {
-		throw InternalException("Sequence start or increment out of type range");
-	}
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<T>(result);
-	auto value = T(start);
-	for (idx_t i = 0; i < count; i++) {
-		if (i > 0) {
-			value += increment;
-		}
-		result_data[i] = value;
-	}
-}
-
-void VectorOperations::GenerateSequence(Vector &result, idx_t count, int64_t start, int64_t increment) {
-	if (!result.GetType().IsNumeric()) {
-		throw InvalidTypeException(result.GetType(), "Can only generate sequences for numeric values!");
-	}
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedGenerateSequence<int8_t>(result, count, start, increment);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGenerateSequence<int16_t>(result, count, start, increment);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGenerateSequence<int32_t>(result, count, start, increment);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGenerateSequence<int64_t>(result, count, start, increment);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for generate sequence");
-	}
-}
-
-template <class T>
-void TemplatedGenerateSequence(Vector &result, idx_t count, const SelectionVector &sel, int64_t start,
-                               int64_t increment) {
-	D_ASSERT(result.GetType().IsNumeric());
-	if (start > NumericLimits<T>::Maximum() || increment > NumericLimits<T>::Maximum()) {
-		throw InternalException("Sequence start or increment out of type range");
-	}
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<T>(result);
-	auto value = static_cast<uint64_t>(start);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		result_data[idx] = static_cast<T>(value + static_cast<uint64_t>(increment) * idx);
-	}
-}
-
-void VectorOperations::GenerateSequence(Vector &result, idx_t count, const SelectionVector &sel, int64_t start,
-                                        int64_t increment) {
-	if (!result.GetType().IsNumeric()) {
-		throw InvalidTypeException(result.GetType(), "Can only generate sequences for numeric values!");
-	}
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedGenerateSequence<int8_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGenerateSequence<int16_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGenerateSequence<int32_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGenerateSequence<int64_t>(result, count, sel, start, increment);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for generate sequence");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/is_distinct_from.cpp b/src/duckdb/src/common/vector_operations/is_distinct_from.cpp
deleted file mode 100644
index b250eddc7..000000000
--- a/src/duckdb/src/common/vector_operations/is_distinct_from.cpp
+++ /dev/null
@@ -1,1261 +0,0 @@
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-
-namespace duckdb {
-
-struct DistinctBinaryLambdaWrapper {
-	template <class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(LEFT_TYPE left, RIGHT_TYPE right, bool is_left_null, bool is_right_null) {
-		return OP::template Operation<LEFT_TYPE>(left, right, is_left_null, is_right_null);
-	}
-};
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-                                       RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel,
-                                       const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lmask,
-                                       ValidityMask &rmask, ValidityMask &result_mask) {
-	for (idx_t i = 0; i < count; i++) {
-		auto lindex = lsel->get_index(i);
-		auto rindex = rsel->get_index(i);
-		auto lentry = ldata[lindex];
-		auto rentry = rdata[rindex];
-		result_data[i] =
-		    OP::template Operation<LEFT_TYPE>(lentry, rentry, !lmask.RowIsValid(lindex), !rmask.RowIsValid(rindex));
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteConstant(Vector &left, Vector &right, Vector &result) {
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-	auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-	auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-	auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-	*result_data =
-	    OP::template Operation<LEFT_TYPE>(*ldata, *rdata, ConstantVector::IsNull(left), ConstantVector::IsNull(right));
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteGeneric(Vector &left, Vector &right, Vector &result, idx_t count) {
-	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		DistinctExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result);
-	} else {
-		UnifiedVectorFormat ldata, rdata;
-
-		left.ToUnifiedFormat(count, ldata);
-		right.ToUnifiedFormat(count, rdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-		DistinctExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(
-		    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata),
-		    result_data, ldata.sel, rdata.sel, count, ldata.validity, rdata.validity, FlatVector::Validity(result));
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteSwitch(Vector &left, Vector &right, Vector &result, idx_t count) {
-	DistinctExecuteGeneric<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result, count);
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-	DistinctExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result, count);
-}
-
-#ifndef DUCKDB_SMALLER_BINARY
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-#else
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-#endif
-static inline idx_t
-DistinctSelectGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-                          const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-                          const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
-                          ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-#ifdef DUCKDB_SMALLER_BINARY
-	bool HAS_TRUE_SEL = true_sel;
-	bool HAS_FALSE_SEL = false_sel;
-#endif
-	idx_t true_count = 0, false_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto result_idx = result_sel->get_index(i);
-		auto lindex = lsel->get_index(i);
-		auto rindex = rsel->get_index(i);
-#ifndef DUCKDB_SMALLER_BINARY
-		if (NO_NULL) {
-			if (OP::Operation(ldata[lindex], rdata[rindex], false, false)) {
-				if (HAS_TRUE_SEL) {
-					true_sel->set_index(true_count++, result_idx);
-				}
-			} else {
-				if (HAS_FALSE_SEL) {
-					false_sel->set_index(false_count++, result_idx);
-				}
-			}
-		} else
-#endif
-		{
-			if (OP::Operation(ldata[lindex], rdata[rindex], !lmask.RowIsValid(lindex), !rmask.RowIsValid(rindex))) {
-				if (HAS_TRUE_SEL) {
-					true_sel->set_index(true_count++, result_idx);
-				}
-			} else {
-				if (HAS_FALSE_SEL) {
-					false_sel->set_index(false_count++, result_idx);
-				}
-			}
-		}
-	}
-	if (HAS_TRUE_SEL) {
-		return true_count;
-	} else {
-		return count - false_count;
-	}
-}
-
-#ifndef DUCKDB_SMALLER_BINARY
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
-static inline idx_t
-DistinctSelectGenericLoopSelSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-                                   const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-                                   const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
-                                   ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (true_sel && false_sel) {
-		return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, true>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	} else if (true_sel) {
-		return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, false>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	} else {
-		D_ASSERT(false_sel);
-		return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, false, true>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	}
-}
-#endif
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static inline idx_t
-DistinctSelectGenericLoopSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-                                const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-                                const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
-                                ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-#ifndef DUCKDB_SMALLER_BINARY
-	if (!lmask.AllValid() || !rmask.AllValid()) {
-		return DistinctSelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, false>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	} else {
-		return DistinctSelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, true>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	}
-#else
-	return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP>(ldata, rdata, lsel, rsel, result_sel, count, lmask,
-	                                                            rmask, true_sel, false_sel);
-#endif
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static idx_t DistinctSelectGeneric(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	UnifiedVectorFormat ldata, rdata;
-
-	left.ToUnifiedFormat(count, ldata);
-	right.ToUnifiedFormat(count, rdata);
-
-	return DistinctSelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>(
-	    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata), ldata.sel,
-	    rdata.sel, sel, count, ldata.validity, rdata.validity, true_sel, false_sel);
-}
-
-#ifndef DUCKDB_SMALLER_BINARY
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool NO_NULL,
-          bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-static inline idx_t DistinctSelectFlatLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                           const SelectionVector *sel, idx_t count, ValidityMask &lmask,
-                                           ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	idx_t true_count = 0, false_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t result_idx = sel->get_index(i);
-		idx_t lidx = LEFT_CONSTANT ? 0 : i;
-		idx_t ridx = RIGHT_CONSTANT ? 0 : i;
-		const bool lnull = !lmask.RowIsValid(lidx);
-		const bool rnull = !rmask.RowIsValid(ridx);
-		bool comparison_result = OP::Operation(ldata[lidx], rdata[ridx], lnull, rnull);
-		if (HAS_TRUE_SEL) {
-			true_sel->set_index(true_count, result_idx);
-			true_count += comparison_result;
-		}
-		if (HAS_FALSE_SEL) {
-			false_sel->set_index(false_count, result_idx);
-			false_count += !comparison_result;
-		}
-	}
-	if (HAS_TRUE_SEL) {
-		return true_count;
-	} else {
-		return count - false_count;
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool NO_NULL>
-static inline idx_t DistinctSelectFlatLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                                    const SelectionVector *sel, idx_t count, ValidityMask &lmask,
-                                                    ValidityMask &rmask, SelectionVector *true_sel,
-                                                    SelectionVector *false_sel) {
-	if (true_sel && false_sel) {
-		return DistinctSelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, NO_NULL, true, true>(
-		    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-	} else if (true_sel) {
-		return DistinctSelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, NO_NULL, true, false>(
-		    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-	} else {
-		D_ASSERT(false_sel);
-		return DistinctSelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, NO_NULL, false, true>(
-		    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-static inline idx_t DistinctSelectFlatLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                                 const SelectionVector *sel, idx_t count, ValidityMask &lmask,
-                                                 ValidityMask &rmask, SelectionVector *true_sel,
-                                                 SelectionVector *false_sel) {
-	return DistinctSelectFlatLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true>(
-	    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-static idx_t DistinctSelectFlat(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                SelectionVector *true_sel, SelectionVector *false_sel) {
-	auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
-	auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
-	if (LEFT_CONSTANT) {
-		ValidityMask validity;
-		if (ConstantVector::IsNull(left)) {
-			validity.SetAllInvalid(1);
-		}
-		return DistinctSelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, sel, count, validity, FlatVector::Validity(right), true_sel, false_sel);
-	} else if (RIGHT_CONSTANT) {
-		ValidityMask validity;
-		if (ConstantVector::IsNull(right)) {
-			validity.SetAllInvalid(1);
-		}
-		return DistinctSelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, sel, count, FlatVector::Validity(left), validity, true_sel, false_sel);
-	} else {
-		return DistinctSelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, sel, count, FlatVector::Validity(left), FlatVector::Validity(right), true_sel, false_sel);
-	}
-}
-#endif
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static idx_t DistinctSelectConstant(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-	auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-
-	// both sides are constant, return either 0 or the count
-	// in this case we do not fill in the result selection vector at all
-	if (!OP::Operation(*ldata, *rdata, ConstantVector::IsNull(left), ConstantVector::IsNull(right))) {
-		if (false_sel) {
-			for (idx_t i = 0; i < count; i++) {
-				false_sel->set_index(i, sel->get_index(i));
-			}
-		}
-		return 0;
-	} else {
-		if (true_sel) {
-			for (idx_t i = 0; i < count; i++) {
-				true_sel->set_index(i, sel->get_index(i));
-			}
-		}
-		return count;
-	}
-}
-
-static void UpdateNullMask(Vector &vec, const SelectionVector &sel, idx_t count, ValidityMask &null_mask) {
-	UnifiedVectorFormat vdata;
-	vec.ToUnifiedFormat(count, vdata);
-
-	if (vdata.validity.AllValid()) {
-		return;
-	}
-
-	for (idx_t i = 0; i < count; ++i) {
-		const auto ridx = sel.get_index(i);
-		const auto vidx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(vidx)) {
-			null_mask.SetInvalid(ridx);
-		}
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static idx_t DistinctSelect(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                            SelectionVector *true_sel, SelectionVector *false_sel,
-                            optional_ptr<ValidityMask> null_mask) {
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-
-	// TODO: Push this down?
-	if (null_mask) {
-		UpdateNullMask(left, *sel, count, *null_mask);
-		UpdateNullMask(right, *sel, count, *null_mask);
-	}
-
-	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return DistinctSelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-#ifndef DUCKDB_SMALLER_BINARY
-	} else if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-	           right.GetVectorType() == VectorType::FLAT_VECTOR) {
-		return DistinctSelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(left, right, sel, count, true_sel, false_sel);
-	} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
-	           right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return DistinctSelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(left, right, sel, count, true_sel, false_sel);
-	} else if (left.GetVectorType() == VectorType::FLAT_VECTOR && right.GetVectorType() == VectorType::FLAT_VECTOR) {
-		return DistinctSelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, false>(left, right, sel, count, true_sel,
-		                                                                   false_sel);
-#endif
-	} else {
-		return DistinctSelectGeneric<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectNotNull(Vector &left, Vector &right, const idx_t count, idx_t &true_count,
-                                   const SelectionVector &sel, SelectionVector &maybe_vec, OptionalSelection &true_opt,
-                                   OptionalSelection &false_opt, optional_ptr<ValidityMask> null_mask) {
-	UnifiedVectorFormat lvdata, rvdata;
-	left.ToUnifiedFormat(count, lvdata);
-	right.ToUnifiedFormat(count, rvdata);
-
-	auto &lmask = lvdata.validity;
-	auto &rmask = rvdata.validity;
-
-	idx_t remaining = 0;
-	if (lmask.AllValid() && rmask.AllValid()) {
-		//	None are NULL, distinguish values.
-		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = sel.get_index(i);
-			maybe_vec.set_index(remaining++, idx);
-		}
-		return remaining;
-	}
-
-	// Slice the Vectors down to the rows that are not determined (i.e., neither is NULL)
-	SelectionVector slicer(count);
-	true_count = 0;
-	idx_t false_count = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const auto result_idx = sel.get_index(i);
-		const auto lidx = lvdata.sel->get_index(i);
-		const auto ridx = rvdata.sel->get_index(i);
-		const auto lnull = !lmask.RowIsValid(lidx);
-		const auto rnull = !rmask.RowIsValid(ridx);
-		if (lnull || rnull) {
-			// If either is NULL then we can major distinguish them
-			if (null_mask) {
-				null_mask->SetInvalid(result_idx);
-			}
-			if (!OP::Operation(false, false, lnull, rnull)) {
-				false_opt.Append(false_count, result_idx);
-			} else {
-				true_opt.Append(true_count, result_idx);
-			}
-		} else {
-			//	Neither is NULL, distinguish values.
-			slicer.set_index(remaining, i);
-			maybe_vec.set_index(remaining++, result_idx);
-		}
-	}
-
-	true_opt.Advance(true_count);
-	false_opt.Advance(false_count);
-
-	if (remaining && remaining < count) {
-		left.Slice(slicer, remaining);
-		right.Slice(slicer, remaining);
-	}
-
-	return remaining;
-}
-
-struct PositionComparator {
-	// Select the rows that definitely match.
-	// Default to the same as the final row
-	template <typename OP>
-	static idx_t Definite(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                      optional_ptr<SelectionVector> true_sel, SelectionVector &false_sel,
-	                      optional_ptr<ValidityMask> null_mask) {
-		return Final<OP>(left, right, sel, count, true_sel, &false_sel, null_mask);
-	}
-
-	// Select the possible rows that need further testing.
-	// Usually this means Is Not Distinct, as those are the semantics used by Postges
-	template <typename OP>
-	static idx_t Possible(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                      SelectionVector &true_sel, optional_ptr<SelectionVector> false_sel,
-	                      optional_ptr<ValidityMask> null_mask) {
-		return VectorOperations::NestedEquals(left, right, &sel, count, &true_sel, false_sel, null_mask);
-	}
-
-	// Select the matching rows for the final position.
-	// This needs to be specialised.
-	template <typename OP>
-	static idx_t Final(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                   optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                   optional_ptr<ValidityMask> null_mask) {
-		return 0;
-	}
-
-	// Tie-break based on length when one of the sides has been exhausted, returning true if the LHS matches.
-	// This essentially means that the existing positions compare equal.
-	// Default to the same semantics as the OP for idx_t. This works in most cases.
-	template <typename OP>
-	static bool TieBreak(const idx_t lpos, const idx_t rpos) {
-		return OP::Operation(lpos, rpos, false, false);
-	}
-};
-
-// NotDistinctFrom must always check every column
-template <>
-idx_t PositionComparator::Definite<duckdb::NotDistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                            idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                            SelectionVector &false_sel,
-                                                            optional_ptr<ValidityMask> null_mask) {
-	return 0;
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::NotDistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                         idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                         optional_ptr<SelectionVector> false_sel,
-                                                         optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::NestedEquals(left, right, &sel, count, true_sel, false_sel, null_mask);
-}
-
-// DistinctFrom must check everything that matched
-template <>
-idx_t PositionComparator::Possible<duckdb::DistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                         idx_t count, SelectionVector &true_sel,
-                                                         optional_ptr<SelectionVector> false_sel,
-                                                         optional_ptr<ValidityMask> null_mask) {
-	return count;
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                      idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                      optional_ptr<SelectionVector> false_sel,
-                                                      optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::NestedNotEquals(left, right, &sel, count, true_sel, false_sel, null_mask);
-}
-
-// Non-strict inequalities must use strict comparisons for Definite
-template <>
-idx_t PositionComparator::Definite<duckdb::DistinctLessThanEquals>(Vector &left, Vector &right,
-                                                                   const SelectionVector &sel, idx_t count,
-                                                                   optional_ptr<SelectionVector> true_sel,
-                                                                   SelectionVector &false_sel,
-                                                                   optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, &false_sel, null_mask);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctLessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                                idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                                optional_ptr<SelectionVector> false_sel,
-                                                                optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThanEquals(right, left, &sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t PositionComparator::Definite<duckdb::DistinctGreaterThanEquals>(Vector &left, Vector &right,
-                                                                      const SelectionVector &sel, idx_t count,
-                                                                      optional_ptr<SelectionVector> true_sel,
-                                                                      SelectionVector &false_sel,
-                                                                      optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, &false_sel, null_mask);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctGreaterThanEquals>(Vector &left, Vector &right,
-                                                                   const SelectionVector &sel, idx_t count,
-                                                                   optional_ptr<SelectionVector> true_sel,
-                                                                   optional_ptr<SelectionVector> false_sel,
-                                                                   optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel, null_mask);
-}
-
-// Strict inequalities just use strict for both Definite and Final
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctLessThan>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                          idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                          optional_ptr<SelectionVector> false_sel,
-                                                          optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctLessThanNullsFirst>(Vector &left, Vector &right,
-                                                                    const SelectionVector &sel, idx_t count,
-                                                                    optional_ptr<SelectionVector> true_sel,
-                                                                    optional_ptr<SelectionVector> false_sel,
-                                                                    optional_ptr<ValidityMask> null_mask) {
-	// DistinctGreaterThan has NULLs last
-	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctGreaterThan>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                             idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                             optional_ptr<SelectionVector> false_sel,
-                                                             optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctGreaterThanNullsFirst>(Vector &left, Vector &right,
-                                                                       const SelectionVector &sel, idx_t count,
-                                                                       optional_ptr<SelectionVector> true_sel,
-                                                                       optional_ptr<SelectionVector> false_sel,
-                                                                       optional_ptr<ValidityMask> null_mask) {
-	// DistinctLessThan has NULLs last
-	return VectorOperations::DistinctLessThan(right, left, &sel, count, true_sel, false_sel, null_mask);
-}
-
-using StructEntries = vector<unique_ptr<Vector>>;
-
-static void ExtractNestedSelection(const SelectionVector &slice_sel, const idx_t count, const SelectionVector &sel,
-                                   OptionalSelection &opt) {
-
-	for (idx_t i = 0; i < count;) {
-		const auto slice_idx = slice_sel.get_index(i);
-		const auto result_idx = sel.get_index(slice_idx);
-		opt.Append(i, result_idx);
-	}
-	opt.Advance(count);
-}
-
-static void ExtractNestedMask(const SelectionVector &slice_sel, const idx_t count, const SelectionVector &sel,
-                              ValidityMask *child_mask, optional_ptr<ValidityMask> null_mask) {
-
-	if (!child_mask) {
-		return;
-	}
-
-	for (idx_t i = 0; i < count; ++i) {
-		const auto slice_idx = slice_sel.get_index(i);
-		const auto result_idx = sel.get_index(slice_idx);
-		if (child_mask && !child_mask->RowIsValid(slice_idx)) {
-			null_mask->SetInvalid(result_idx);
-		}
-	}
-
-	child_mask->Reset(null_mask->Capacity());
-}
-
-static void DensifyNestedSelection(const SelectionVector &dense_sel, const idx_t count, SelectionVector &slice_sel) {
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, dense_sel.get_index(i));
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
-                                  OptionalSelection &true_opt, OptionalSelection &false_opt,
-                                  optional_ptr<ValidityMask> null_mask) {
-	if (count == 0) {
-		return 0;
-	}
-
-	// Avoid allocating in the 99% of the cases where we don't need to.
-	StructEntries lsliced, rsliced;
-	auto &lchildren = StructVector::GetEntries(left);
-	auto &rchildren = StructVector::GetEntries(right);
-	D_ASSERT(lchildren.size() == rchildren.size());
-
-	// In order to reuse the comparators, we have to track what passed and failed internally.
-	// To do that, we need local SVs that we then merge back into the real ones after every pass.
-	const auto vcount = count;
-	SelectionVector slice_sel(count);
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, i);
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	ValidityMask child_validity;
-	ValidityMask *child_mask = nullptr;
-	if (null_mask) {
-		child_mask = &child_validity;
-		child_mask->Reset(null_mask->Capacity());
-	}
-
-	idx_t match_count = 0;
-	for (idx_t col_no = 0; col_no < lchildren.size(); ++col_no) {
-		// Slice the children to maintain density
-		Vector lchild(*lchildren[col_no]);
-		lchild.Flatten(vcount);
-		lchild.Slice(slice_sel, count);
-
-		Vector rchild(*rchildren[col_no]);
-		rchild.Flatten(vcount);
-		rchild.Slice(slice_sel, count);
-
-		// Find everything that definitely matches
-		auto true_count =
-		    PositionComparator::Definite<OP>(lchild, rchild, slice_sel, count, &true_sel, false_sel, child_mask);
-		// Extract any NULLs we found
-		ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-		if (true_count > 0) {
-			auto false_count = count - true_count;
-
-			// Extract the definite matches into the true result
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-
-			// Remove the definite matches from the slicing vector
-			DensifyNestedSelection(false_sel, false_count, slice_sel);
-
-			match_count += true_count;
-			count -= true_count;
-		}
-
-		if (col_no != lchildren.size() - 1) {
-			// Find what might match on the next position
-			true_count =
-			    PositionComparator::Possible<OP>(lchild, rchild, slice_sel, count, true_sel, &false_sel, child_mask);
-			auto false_count = count - true_count;
-
-			// Extract any NULLs we found
-			ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-
-			// Extract the definite failures into the false result
-			ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-			// Remove any definite failures from the slicing vector
-			if (false_count) {
-				DensifyNestedSelection(true_sel, true_count, slice_sel);
-			}
-
-			count = true_count;
-		} else {
-			true_count =
-			    PositionComparator::Final<OP>(lchild, rchild, slice_sel, count, &true_sel, &false_sel, child_mask);
-			auto false_count = count - true_count;
-
-			// Extract any NULLs we found
-			ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-
-			// Extract the definite matches into the true result
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-
-			// Extract the definite failures into the false result
-			ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-			match_count += true_count;
-		}
-	}
-	return match_count;
-}
-
-static void PositionListCursor(SelectionVector &cursor, UnifiedVectorFormat &vdata, const idx_t pos,
-                               const SelectionVector &slice_sel, const idx_t count) {
-	const auto data = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
-	for (idx_t i = 0; i < count; ++i) {
-		const auto slice_idx = slice_sel.get_index(i);
-
-		const auto lidx = vdata.sel->get_index(slice_idx);
-		const auto &entry = data[lidx];
-		cursor.set_index(i, entry.offset + pos);
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
-                                OptionalSelection &true_opt, OptionalSelection &false_opt,
-                                optional_ptr<ValidityMask> null_mask) {
-	if (count == 0) {
-		return count;
-	}
-
-	// Create dictionary views of the children so we can vectorise the positional comparisons.
-	SelectionVector lcursor(count);
-	SelectionVector rcursor(count);
-
-	Vector lentry_flattened(ListVector::GetEntry(left));
-	Vector rentry_flattened(ListVector::GetEntry(right));
-	lentry_flattened.Flatten(ListVector::GetListSize(left));
-	rentry_flattened.Flatten(ListVector::GetListSize(right));
-	Vector lchild(lentry_flattened, lcursor, count);
-	Vector rchild(rentry_flattened, rcursor, count);
-
-	// To perform the positional comparison, we use a vectorisation of the following algorithm:
-	// bool CompareLists(T *left, idx_t nleft, T *right, nright) {
-	// 	for (idx_t pos = 0; ; ++pos) {
-	// 		if (nleft == pos || nright == pos)
-	// 			return OP::TieBreak(nleft, nright);
-	// 		if (OP::Definite(*left, *right))
-	// 			return true;
-	// 		if (!OP::Maybe(*left, *right))
-	// 			return false;
-	// 		}
-	//	 	++left, ++right;
-	// 	}
-	// }
-
-	// Get pointers to the list entries
-	UnifiedVectorFormat lvdata;
-	left.ToUnifiedFormat(count, lvdata);
-	const auto ldata = UnifiedVectorFormat::GetData<list_entry_t>(lvdata);
-
-	UnifiedVectorFormat rvdata;
-	right.ToUnifiedFormat(count, rvdata);
-	const auto rdata = UnifiedVectorFormat::GetData<list_entry_t>(rvdata);
-
-	// In order to reuse the comparators, we have to track what passed and failed internally.
-	// To do that, we need local SVs that we then merge back into the real ones after every pass.
-	SelectionVector slice_sel(count);
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, i);
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	ValidityMask child_validity;
-	ValidityMask *child_mask = nullptr;
-	if (null_mask) {
-		child_mask = &child_validity;
-		child_mask->Reset(null_mask->Capacity());
-	}
-
-	idx_t match_count = 0;
-	for (idx_t pos = 0; count > 0; ++pos) {
-		// Set up the cursors for the current position
-		PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
-		PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
-
-		// Tie-break the pairs where one of the LISTs is exhausted.
-		idx_t true_count = 0;
-		idx_t false_count = 0;
-		idx_t maybe_count = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto slice_idx = slice_sel.get_index(i);
-			const auto lidx = lvdata.sel->get_index(slice_idx);
-			const auto &lentry = ldata[lidx];
-			const auto ridx = rvdata.sel->get_index(slice_idx);
-			const auto &rentry = rdata[ridx];
-			if (lentry.length == pos || rentry.length == pos) {
-				const auto idx = sel.get_index(slice_idx);
-				if (PositionComparator::TieBreak<OP>(lentry.length, rentry.length)) {
-					true_opt.Append(true_count, idx);
-				} else {
-					false_opt.Append(false_count, idx);
-				}
-			} else {
-				true_sel.set_index(maybe_count++, slice_idx);
-			}
-		}
-		true_opt.Advance(true_count);
-		false_opt.Advance(false_count);
-		match_count += true_count;
-
-		// Redensify the list cursors
-		if (maybe_count < count) {
-			count = maybe_count;
-			DensifyNestedSelection(true_sel, count, slice_sel);
-			PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
-			PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
-		}
-
-		// Find everything that definitely matches
-		true_count =
-		    PositionComparator::Definite<OP>(lchild, rchild, slice_sel, count, &true_sel, false_sel, child_mask);
-		// Extract any NULLs we found
-		ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-		if (true_count) {
-			false_count = count - true_count;
-
-			// Extract the definite matches into the true result
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-			match_count += true_count;
-
-			// Redensify the list cursors
-			count -= true_count;
-			DensifyNestedSelection(false_sel, count, slice_sel);
-			PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
-			PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
-		}
-
-		// Find what might match on the next position
-		true_count =
-		    PositionComparator::Possible<OP>(lchild, rchild, slice_sel, count, true_sel, &false_sel, child_mask);
-		false_count = count - true_count;
-
-		// Extract any NULLs we found
-		ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-
-		// Extract the definite failures into the false result
-		ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-		if (false_count) {
-			DensifyNestedSelection(true_sel, true_count, slice_sel);
-		}
-		count = true_count;
-	}
-
-	return match_count;
-}
-
-static void PositionArrayCursor(SelectionVector &cursor, UnifiedVectorFormat &vdata, const idx_t pos,
-                                const SelectionVector &slice_sel, const idx_t count, idx_t array_size) {
-	for (idx_t i = 0; i < count; ++i) {
-		const auto slice_idx = slice_sel.get_index(i);
-		const auto lidx = vdata.sel->get_index(slice_idx);
-		const auto offset = array_size * lidx;
-		cursor.set_index(i, offset + pos);
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectArray(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
-                                 OptionalSelection &true_opt, OptionalSelection &false_opt,
-                                 optional_ptr<ValidityMask> null_mask) {
-	if (count == 0) {
-		return count;
-	}
-
-	// FIXME: This function can probably be optimized since we know the array size is fixed for every entry.
-
-	D_ASSERT(ArrayType::GetSize(left.GetType()) == ArrayType::GetSize(right.GetType()));
-	auto array_size = ArrayType::GetSize(left.GetType());
-
-	// Create dictionary views of the children so we can vectorise the positional comparisons.
-	SelectionVector lcursor(count);
-	SelectionVector rcursor(count);
-
-	Vector lentry_flattened(ArrayVector::GetEntry(left));
-	Vector rentry_flattened(ArrayVector::GetEntry(right));
-	lentry_flattened.Flatten(ArrayVector::GetTotalSize(left));
-	rentry_flattened.Flatten(ArrayVector::GetTotalSize(right));
-	Vector lchild(lentry_flattened, lcursor, count);
-	Vector rchild(rentry_flattened, rcursor, count);
-
-	// Get pointers to the list entries
-	UnifiedVectorFormat lvdata;
-	left.ToUnifiedFormat(count, lvdata);
-
-	UnifiedVectorFormat rvdata;
-	right.ToUnifiedFormat(count, rvdata);
-
-	// In order to reuse the comparators, we have to track what passed and failed internally.
-	// To do that, we need local SVs that we then merge back into the real ones after every pass.
-	SelectionVector slice_sel(count);
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, i);
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	ValidityMask child_validity;
-	ValidityMask *child_mask = nullptr;
-	if (null_mask) {
-		child_mask = &child_validity;
-		child_mask->Reset(null_mask->Capacity());
-	}
-
-	idx_t match_count = 0;
-	for (idx_t pos = 0; count > 0; ++pos) {
-		// Set up the cursors for the current position
-		PositionArrayCursor(lcursor, lvdata, pos, slice_sel, count, array_size);
-		PositionArrayCursor(rcursor, rvdata, pos, slice_sel, count, array_size);
-
-		// Tie-break the pairs where one of the LISTs is exhausted.
-		idx_t true_count = 0;
-		idx_t false_count = 0;
-		idx_t maybe_count = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto slice_idx = slice_sel.get_index(i);
-			if (array_size == pos) {
-				const auto idx = sel.get_index(slice_idx);
-				if (PositionComparator::TieBreak<OP>(array_size, array_size)) {
-					true_opt.Append(true_count, idx);
-				} else {
-					false_opt.Append(false_count, idx);
-				}
-			} else {
-				true_sel.set_index(maybe_count++, slice_idx);
-			}
-		}
-		true_opt.Advance(true_count);
-		false_opt.Advance(false_count);
-		match_count += true_count;
-
-		// Redensify the list cursors
-		if (maybe_count < count) {
-			count = maybe_count;
-			DensifyNestedSelection(true_sel, count, slice_sel);
-			PositionArrayCursor(lcursor, lvdata, pos, slice_sel, count, array_size);
-			PositionArrayCursor(rcursor, rvdata, pos, slice_sel, count, array_size);
-		}
-
-		// Find everything that definitely matches
-		true_count =
-		    PositionComparator::Definite<OP>(lchild, rchild, slice_sel, count, &true_sel, false_sel, child_mask);
-		// Extract any NULLs we found
-		ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-		if (true_count) {
-			false_count = count - true_count;
-
-			// Extract the definite matches into the true result
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-			match_count += true_count;
-
-			// Redensify the list cursors
-			count -= true_count;
-			DensifyNestedSelection(false_sel, count, slice_sel);
-			PositionArrayCursor(lcursor, lvdata, pos, slice_sel, count, array_size);
-			PositionArrayCursor(rcursor, rvdata, pos, slice_sel, count, array_size);
-		}
-
-		// Find what might match on the next position
-		true_count =
-		    PositionComparator::Possible<OP>(lchild, rchild, slice_sel, count, true_sel, &false_sel, null_mask);
-		false_count = count - true_count;
-
-		// Extract any NULLs we found
-		ExtractNestedMask(slice_sel, count, sel, child_mask, null_mask);
-
-		// Extract the definite failures into the false result
-		ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-		if (false_count) {
-			DensifyNestedSelection(true_sel, true_count, slice_sel);
-		}
-		count = true_count;
-	}
-
-	return match_count;
-}
-
-template <class OP>
-static idx_t DistinctSelectNested(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                  const idx_t count, optional_ptr<SelectionVector> true_sel,
-                                  optional_ptr<SelectionVector> false_sel, optional_ptr<ValidityMask> null_mask) {
-	// The Select operations all use a dense pair of input vectors to partition
-	// a selection vector in a single pass. But to implement progressive comparisons,
-	// we have to make multiple passes, so we need to keep track of the original input positions
-	// and then scatter the output selections when we are done.
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-
-	// Make buffered selections for progressive comparisons
-	// TODO: Remove unnecessary allocations
-	SelectionVector true_vec(count);
-	OptionalSelection true_opt(&true_vec);
-
-	SelectionVector false_vec(count);
-	OptionalSelection false_opt(&false_vec);
-
-	SelectionVector maybe_vec(count);
-
-	// Handle NULL nested values
-	Vector l_not_null(left);
-	Vector r_not_null(right);
-
-	idx_t match_count = 0;
-	auto unknown = DistinctSelectNotNull<OP>(l_not_null, r_not_null, count, match_count, *sel, maybe_vec, true_opt,
-	                                         false_opt, null_mask);
-
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::LIST:
-		match_count +=
-		    DistinctSelectList<OP>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt, null_mask);
-		break;
-	case PhysicalType::STRUCT:
-		match_count +=
-		    DistinctSelectStruct<OP>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt, null_mask);
-		break;
-	case PhysicalType::ARRAY:
-		match_count +=
-		    DistinctSelectArray<OP>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt, null_mask);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for DISTINCT");
-	}
-
-	// Copy the buffered selections to the output selections
-	if (true_sel) {
-		DensifyNestedSelection(true_vec, match_count, *true_sel);
-	}
-
-	if (false_sel) {
-		DensifyNestedSelection(false_vec, count - match_count, *false_sel);
-	}
-
-	return match_count;
-}
-
-template <typename OP>
-static void NestedDistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count);
-
-template <class T, class OP>
-static inline void TemplatedDistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-	DistinctExecute<T, T, bool, OP>(left, right, result, count);
-}
-template <class OP>
-static void ExecuteDistinct(Vector &left, Vector &right, Vector &result, idx_t count) {
-	D_ASSERT(left.GetType() == right.GetType() && result.GetType() == LogicalType::BOOLEAN);
-	// the inplace loops take the result as the last parameter
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedDistinctExecute<int8_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedDistinctExecute<int16_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedDistinctExecute<int32_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedDistinctExecute<int64_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedDistinctExecute<uint8_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedDistinctExecute<uint16_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedDistinctExecute<uint32_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedDistinctExecute<uint64_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedDistinctExecute<hugeint_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedDistinctExecute<uhugeint_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedDistinctExecute<float, OP>(left, right, result, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedDistinctExecute<double, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedDistinctExecute<interval_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedDistinctExecute<string_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT:
-	case PhysicalType::ARRAY:
-		NestedDistinctExecute<OP>(left, right, result, count);
-		break;
-	default:
-		throw InternalException("Invalid type for distinct comparison");
-	}
-}
-
-template <class OP>
-static idx_t TemplatedDistinctSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                              idx_t count, optional_ptr<SelectionVector> true_sel,
-                                              optional_ptr<SelectionVector> false_sel,
-                                              optional_ptr<ValidityMask> null_mask) {
-
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return DistinctSelect<int8_t, int8_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                          null_mask);
-	case PhysicalType::INT16:
-		return DistinctSelect<int16_t, int16_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                            null_mask);
-	case PhysicalType::INT32:
-		return DistinctSelect<int32_t, int32_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                            null_mask);
-	case PhysicalType::INT64:
-		return DistinctSelect<int64_t, int64_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                            null_mask);
-	case PhysicalType::UINT8:
-		return DistinctSelect<uint8_t, uint8_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                            null_mask);
-	case PhysicalType::UINT16:
-		return DistinctSelect<uint16_t, uint16_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                              null_mask);
-	case PhysicalType::UINT32:
-		return DistinctSelect<uint32_t, uint32_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                              null_mask);
-	case PhysicalType::UINT64:
-		return DistinctSelect<uint64_t, uint64_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                              null_mask);
-	case PhysicalType::INT128:
-		return DistinctSelect<hugeint_t, hugeint_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                                null_mask);
-	case PhysicalType::UINT128:
-		return DistinctSelect<uhugeint_t, uhugeint_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                  false_sel.get(), null_mask);
-	case PhysicalType::FLOAT:
-		return DistinctSelect<float, float, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                        null_mask);
-	case PhysicalType::DOUBLE:
-		return DistinctSelect<double, double, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                          null_mask);
-	case PhysicalType::INTERVAL:
-		return DistinctSelect<interval_t, interval_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                  false_sel.get(), null_mask);
-	case PhysicalType::VARCHAR:
-		return DistinctSelect<string_t, string_t, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get(),
-		                                              null_mask);
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-	case PhysicalType::ARRAY:
-		return DistinctSelectNested<OP>(left, right, sel, count, true_sel, false_sel, null_mask);
-	default:
-		throw InternalException("Invalid type for distinct selection");
-	}
-}
-
-template <typename OP>
-static void NestedDistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-	const auto left_constant = left.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	const auto right_constant = right.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-	if (left_constant && right_constant) {
-		// both sides are constant, so just compare one element.
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto result_data = ConstantVector::GetData<bool>(result);
-		SelectionVector true_sel(1);
-		auto match_count = TemplatedDistinctSelectOperation<OP>(left, right, nullptr, 1, &true_sel, nullptr, nullptr);
-		result_data[0] = match_count > 0;
-		return;
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	// DISTINCT is either true or false
-	idx_t match_count =
-	    TemplatedDistinctSelectOperation<OP>(left, right, nullptr, count, &true_sel, &false_sel, nullptr);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<bool>(result);
-
-	for (idx_t i = 0; i < match_count; ++i) {
-		const auto idx = true_sel.get_index(i);
-		result_data[idx] = true;
-	}
-
-	const idx_t no_match_count = count - match_count;
-	for (idx_t i = 0; i < no_match_count; ++i) {
-		const auto idx = false_sel.get_index(i);
-		result_data[idx] = false;
-	}
-}
-
-void VectorOperations::DistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ExecuteDistinct<duckdb::DistinctFrom>(left, right, result, count);
-}
-
-void VectorOperations::NotDistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ExecuteDistinct<duckdb::NotDistinctFrom>(left, right, result, count);
-}
-
-// true := A != B with nulls being equal
-idx_t VectorOperations::DistinctFrom(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                     optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, sel, count, true_sel, false_sel,
-	                                                              nullptr);
-}
-// true := A == B with nulls being equal
-idx_t VectorOperations::NotDistinctFrom(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                        idx_t count, optional_ptr<SelectionVector> true_sel,
-                                        optional_ptr<SelectionVector> false_sel) {
-	return count - TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, sel, count, false_sel, true_sel,
-	                                                                      nullptr);
-}
-
-// true := A > B with nulls being maximal
-idx_t VectorOperations::DistinctGreaterThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                            idx_t count, optional_ptr<SelectionVector> true_sel,
-                                            optional_ptr<SelectionVector> false_sel,
-                                            optional_ptr<ValidityMask> null_mask) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(left, right, sel, count, true_sel, false_sel,
-	                                                                     null_mask);
-}
-
-// true := A > B with nulls being minimal
-idx_t VectorOperations::DistinctGreaterThanNullsFirst(Vector &left, Vector &right,
-                                                      optional_ptr<const SelectionVector> sel, idx_t count,
-                                                      optional_ptr<SelectionVector> true_sel,
-                                                      optional_ptr<SelectionVector> false_sel,
-                                                      optional_ptr<ValidityMask> null_mask) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanNullsFirst>(left, right, sel, count, true_sel,
-	                                                                               false_sel, null_mask);
-}
-
-// true := A >= B with nulls being maximal
-idx_t VectorOperations::DistinctGreaterThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                                  idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                  optional_ptr<SelectionVector> false_sel,
-                                                  optional_ptr<ValidityMask> null_mask) {
-	return count - TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(right, left, sel, count, false_sel,
-	                                                                             true_sel, null_mask);
-}
-// true := A < B with nulls being maximal
-idx_t VectorOperations::DistinctLessThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                         idx_t count, optional_ptr<SelectionVector> true_sel,
-                                         optional_ptr<SelectionVector> false_sel,
-                                         optional_ptr<ValidityMask> null_mask) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(right, left, sel, count, true_sel, false_sel,
-	                                                                     null_mask);
-}
-
-// true := A < B with nulls being minimal
-idx_t VectorOperations::DistinctLessThanNullsFirst(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                                   idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                   optional_ptr<SelectionVector> false_sel,
-                                                   optional_ptr<ValidityMask> null_mask) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanNullsFirst>(right, left, sel, count, true_sel,
-	                                                                               false_sel, nullptr);
-}
-
-// true := A <= B with nulls being maximal
-idx_t VectorOperations::DistinctLessThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                               idx_t count, optional_ptr<SelectionVector> true_sel,
-                                               optional_ptr<SelectionVector> false_sel,
-                                               optional_ptr<ValidityMask> null_mask) {
-	return count - TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(left, right, sel, count, false_sel,
-	                                                                             true_sel, null_mask);
-}
-
-// true := A != B with nulls being equal, inputs selected
-idx_t VectorOperations::NestedNotEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                        idx_t count, optional_ptr<SelectionVector> true_sel,
-                                        optional_ptr<SelectionVector> false_sel, optional_ptr<ValidityMask> null_mask) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, sel, count, true_sel, false_sel,
-	                                                              null_mask);
-}
-// true := A == B with nulls being equal, inputs selected
-idx_t VectorOperations::NestedEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                     optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                     optional_ptr<ValidityMask> null_mask) {
-	return count - TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, sel, count, false_sel, true_sel,
-	                                                                      null_mask);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/null_operations.cpp b/src/duckdb/src/common/vector_operations/null_operations.cpp
deleted file mode 100644
index dd34ac8ed..000000000
--- a/src/duckdb/src/common/vector_operations/null_operations.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//===--------------------------------------------------------------------===//
-// null_operators.cpp
-// Description: This file contains the implementation of the
-// IS NULL/NOT IS NULL operators
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-template <bool INVERSE>
-void IsNullLoop(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(result.GetType() == LogicalType::BOOLEAN);
-
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto result_data = ConstantVector::GetData<bool>(result);
-		*result_data = INVERSE ? !ConstantVector::IsNull(input) : ConstantVector::IsNull(input);
-	} else {
-		UnifiedVectorFormat data;
-		input.ToUnifiedFormat(count, data);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<bool>(result);
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = data.sel->get_index(i);
-			result_data[i] = INVERSE ? data.validity.RowIsValid(idx) : !data.validity.RowIsValid(idx);
-		}
-	}
-}
-
-void VectorOperations::IsNotNull(Vector &input, Vector &result, idx_t count) {
-	IsNullLoop<true>(input, result, count);
-}
-
-void VectorOperations::IsNull(Vector &input, Vector &result, idx_t count) {
-	IsNullLoop<false>(input, result, count);
-}
-
-bool VectorOperations::HasNotNull(Vector &input, idx_t count) {
-	if (count == 0) {
-		return false;
-	}
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return !ConstantVector::IsNull(input);
-	} else {
-		UnifiedVectorFormat data;
-		input.ToUnifiedFormat(count, data);
-
-		if (data.validity.AllValid()) {
-			return true;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = data.sel->get_index(i);
-			if (data.validity.RowIsValid(idx)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
-
-bool VectorOperations::HasNull(Vector &input, idx_t count) {
-	if (count == 0) {
-		return false;
-	}
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return ConstantVector::IsNull(input);
-	} else {
-		UnifiedVectorFormat data;
-		input.ToUnifiedFormat(count, data);
-
-		if (data.validity.AllValid()) {
-			return false;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = data.sel->get_index(i);
-			if (!data.validity.RowIsValid(idx)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
-
-idx_t VectorOperations::CountNotNull(Vector &input, const idx_t count) {
-	idx_t valid = 0;
-
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-	if (vdata.validity.AllValid()) {
-		return count;
-	}
-	switch (input.GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		valid += vdata.validity.CountValid(count);
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		valid += vdata.validity.CountValid(1) * count;
-		break;
-	default:
-		for (idx_t i = 0; i < count; ++i) {
-			const auto row_idx = vdata.sel->get_index(i);
-			valid += idx_t(vdata.validity.RowIsValid(row_idx));
-		}
-		break;
-	}
-
-	return valid;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/numeric_inplace_operators.cpp b/src/duckdb/src/common/vector_operations/numeric_inplace_operators.cpp
deleted file mode 100644
index 863f3ba8d..000000000
--- a/src/duckdb/src/common/vector_operations/numeric_inplace_operators.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===--------------------------------------------------------------------===//
-// numeric_inplace_operators.cpp
-// Description: This file contains the implementation of numeric inplace ops
-// += *= /= -= %=
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// In-Place Addition
-//===--------------------------------------------------------------------===//
-
-void VectorOperations::AddInPlace(Vector &input, int64_t right, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::POINTER);
-	if (right == 0) {
-		return;
-	}
-	switch (input.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		D_ASSERT(!ConstantVector::IsNull(input));
-		auto data = ConstantVector::GetData<uintptr_t>(input);
-		*data += UnsafeNumericCast<uintptr_t>(right);
-		break;
-	}
-	default: {
-		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
-		auto data = FlatVector::GetData<uintptr_t>(input);
-		for (idx_t i = 0; i < count; i++) {
-			data[i] = UnsafeNumericCast<uintptr_t>(UnsafeNumericCast<int64_t>(data[i]) + right);
-		}
-		break;
-	}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/vector_cast.cpp b/src/duckdb/src/common/vector_operations/vector_cast.cpp
deleted file mode 100644
index e49e51361..000000000
--- a/src/duckdb/src/common/vector_operations/vector_cast.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/function/scalar_function.hpp"
-
-namespace duckdb {
-
-bool VectorOperations::TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result,
-                               idx_t count, string *error_message, bool strict, const bool nullify_parent) {
-	auto cast_function = set.GetCastFunction(source.GetType(), result.GetType(), input);
-	unique_ptr<FunctionLocalState> local_state;
-	if (cast_function.init_local_state) {
-		CastLocalStateParameters lparameters(input.context, cast_function.cast_data);
-		local_state = cast_function.init_local_state(lparameters);
-	}
-	CastParameters parameters(cast_function.cast_data.get(), strict, error_message, local_state.get(), nullify_parent);
-	return cast_function.function(source, result, count, parameters);
-}
-
-bool VectorOperations::DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
-	CastFunctionSet set;
-	GetCastFunctionInput input;
-	return VectorOperations::TryCast(set, input, source, result, count, error_message, strict);
-}
-
-void VectorOperations::DefaultCast(Vector &source, Vector &result, idx_t count, bool strict) {
-	VectorOperations::DefaultTryCast(source, result, count, nullptr, strict);
-}
-
-bool VectorOperations::TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count,
-                               string *error_message, bool strict, const bool nullify_parent) {
-	auto &config = DBConfig::GetConfig(context);
-	auto &set = config.GetCastFunctions();
-	GetCastFunctionInput get_input(context);
-	return VectorOperations::TryCast(set, get_input, source, result, count, error_message, strict, nullify_parent);
-}
-
-void VectorOperations::Cast(ClientContext &context, Vector &source, Vector &result, idx_t count, bool strict) {
-	VectorOperations::TryCast(context, source, result, count, nullptr, strict);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/vector_copy.cpp b/src/duckdb/src/common/vector_operations/vector_copy.cpp
deleted file mode 100644
index 0880f23be..000000000
--- a/src/duckdb/src/common/vector_operations/vector_copy.cpp
+++ /dev/null
@@ -1,281 +0,0 @@
-//===--------------------------------------------------------------------===//
-// copy.cpp
-// Description: This file contains the implementation of the different copy
-// functions
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-template <class T>
-static void TemplatedCopy(const Vector &source, const SelectionVector &sel, Vector &target, idx_t source_offset,
-                          idx_t target_offset, idx_t copy_count) {
-	auto ldata = FlatVector::GetData<T>(source);
-	auto tdata = FlatVector::GetData<T>(target);
-	for (idx_t i = 0; i < copy_count; i++) {
-		auto source_idx = sel.get_index(source_offset + i);
-		tdata[target_offset + i] = ldata[source_idx];
-	}
-}
-
-static const ValidityMask &ExtractValidityMask(const Vector &v) {
-	switch (v.GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		return FlatVector::Validity(v);
-	case VectorType::FSST_VECTOR:
-		return FSSTVector::Validity(v);
-	default:
-		throw InternalException("Unsupported vector type in vector copy");
-	}
-}
-
-void VectorOperations::Copy(const Vector &source_p, Vector &target, const SelectionVector &sel_p, idx_t source_count,
-                            idx_t source_offset, idx_t target_offset, idx_t copy_count) {
-
-	SelectionVector owned_sel;
-	const SelectionVector *sel = &sel_p;
-
-	const Vector *source = &source_p;
-	bool finished = false;
-	while (!finished) {
-		switch (source->GetVectorType()) {
-		case VectorType::DICTIONARY_VECTOR: {
-			// dictionary vector: merge selection vectors
-			auto &child = DictionaryVector::Child(*source);
-			auto &dict_sel = DictionaryVector::SelVector(*source);
-			// merge the selection vectors and verify the child
-			auto new_buffer = dict_sel.Slice(*sel, source_count);
-			owned_sel.Initialize(new_buffer);
-			sel = &owned_sel;
-			source = &child;
-			break;
-		}
-		case VectorType::SEQUENCE_VECTOR: {
-			int64_t start, increment;
-			Vector seq(source->GetType());
-			SequenceVector::GetSequence(*source, start, increment);
-			VectorOperations::GenerateSequence(seq, source_count, *sel, start, increment);
-			VectorOperations::Copy(seq, target, *sel, source_count, source_offset, target_offset);
-			return;
-		}
-		case VectorType::CONSTANT_VECTOR:
-			sel = ConstantVector::ZeroSelectionVector(copy_count, owned_sel);
-			finished = true;
-			break;
-		case VectorType::FSST_VECTOR:
-			finished = true;
-			break;
-		case VectorType::FLAT_VECTOR:
-			finished = true;
-			break;
-		default:
-			throw NotImplementedException("FIXME unimplemented vector type for VectorOperations::Copy");
-		}
-	}
-
-	if (copy_count == 0) {
-		return;
-	}
-
-	// Allow copying of a single value to constant vectors
-	const auto target_vector_type = target.GetVectorType();
-	if (copy_count == 1 && target_vector_type == VectorType::CONSTANT_VECTOR) {
-		target_offset = 0;
-		target.SetVectorType(VectorType::FLAT_VECTOR);
-	}
-	D_ASSERT(target.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	// first copy the nullmask
-	auto &tmask = FlatVector::Validity(target);
-	if (source->GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		const bool valid = !ConstantVector::IsNull(*source);
-		for (idx_t i = 0; i < copy_count; i++) {
-			tmask.Set(target_offset + i, valid);
-		}
-	} else {
-		auto &smask = ExtractValidityMask(*source);
-		tmask.CopySel(smask, *sel, source_offset, target_offset, copy_count);
-	}
-
-	D_ASSERT(sel);
-
-	// For FSST Vectors we decompress instead of copying.
-	if (source->GetVectorType() == VectorType::FSST_VECTOR) {
-		FSSTVector::DecompressVector(*source, target, source_offset, target_offset, copy_count, sel);
-		return;
-	}
-
-	// now copy over the data
-	switch (source->GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedCopy<int8_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedCopy<int16_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedCopy<int32_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedCopy<int64_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedCopy<uint8_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedCopy<uint16_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedCopy<uint32_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedCopy<uint64_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedCopy<hugeint_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedCopy<uhugeint_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedCopy<float>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedCopy<double>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedCopy<interval_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::VARCHAR: {
-		auto ldata = FlatVector::GetData<string_t>(*source);
-		auto tdata = FlatVector::GetData<string_t>(target);
-		for (idx_t i = 0; i < copy_count; i++) {
-			auto source_idx = sel->get_index(source_offset + i);
-			auto target_idx = target_offset + i;
-			if (tmask.RowIsValid(target_idx)) {
-				tdata[target_idx] = StringVector::AddStringOrBlob(target, ldata[source_idx]);
-			}
-		}
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		auto &source_children = StructVector::GetEntries(*source);
-		auto &target_children = StructVector::GetEntries(target);
-		D_ASSERT(source_children.size() == target_children.size());
-		for (idx_t i = 0; i < source_children.size(); i++) {
-			VectorOperations::Copy(*source_children[i], *target_children[i], sel_p, source_count, source_offset,
-			                       target_offset, copy_count);
-		}
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		D_ASSERT(target.GetType().InternalType() == PhysicalType::ARRAY);
-		D_ASSERT(ArrayType::GetSize(source->GetType()) == ArrayType::GetSize(target.GetType()));
-
-		auto &source_child = ArrayVector::GetEntry(*source);
-		auto &target_child = ArrayVector::GetEntry(target);
-		auto array_size = ArrayType::GetSize(source->GetType());
-
-		// Create a selection vector for the child elements
-		SelectionVector child_sel(source_count * array_size);
-		for (idx_t i = 0; i < copy_count; i++) {
-			auto source_idx = sel->get_index(source_offset + i);
-			for (idx_t j = 0; j < array_size; j++) {
-				child_sel.set_index((source_offset * array_size) + (i * array_size + j), source_idx * array_size + j);
-			}
-		}
-		VectorOperations::Copy(source_child, target_child, child_sel, source_count * array_size,
-		                       source_offset * array_size, target_offset * array_size);
-		break;
-	}
-	case PhysicalType::LIST: {
-		D_ASSERT(target.GetType().InternalType() == PhysicalType::LIST);
-
-		auto &source_child = ListVector::GetEntry(*source);
-		auto sdata = FlatVector::GetData<list_entry_t>(*source);
-		auto tdata = FlatVector::GetData<list_entry_t>(target);
-
-		if (target_vector_type == VectorType::CONSTANT_VECTOR) {
-			// If we are only writing one value, then the copied values (if any) are contiguous
-			// and we can just Append from the offset position
-			if (!tmask.RowIsValid(target_offset)) {
-				break;
-			}
-			auto source_idx = sel->get_index(source_offset);
-			auto &source_entry = sdata[source_idx];
-			const idx_t source_child_size = source_entry.length + source_entry.offset;
-
-			//! overwrite constant target vectors.
-			ListVector::SetListSize(target, 0);
-			ListVector::Append(target, source_child, source_child_size, source_entry.offset);
-
-			auto &target_entry = tdata[target_offset];
-			target_entry.length = source_entry.length;
-			target_entry.offset = 0;
-		} else {
-			//! if the source has list offsets, we need to append them to the target
-			//! build a selection vector for the copied child elements
-			vector<sel_t> child_rows;
-			for (idx_t i = 0; i < copy_count; ++i) {
-				if (tmask.RowIsValid(target_offset + i)) {
-					auto source_idx = sel->get_index(source_offset + i);
-					auto &source_entry = sdata[source_idx];
-					for (idx_t j = 0; j < source_entry.length; ++j) {
-						child_rows.emplace_back(source_entry.offset + j);
-					}
-				}
-			}
-			idx_t source_child_size = child_rows.size();
-			SelectionVector child_sel(child_rows.data());
-
-			idx_t old_target_child_len = ListVector::GetListSize(target);
-
-			//! append to list itself
-			ListVector::Append(target, source_child, child_sel, source_child_size);
-
-			//! now write the list offsets
-			for (idx_t i = 0; i < copy_count; i++) {
-				auto source_idx = sel->get_index(source_offset + i);
-				auto &source_entry = sdata[source_idx];
-				auto &target_entry = tdata[target_offset + i];
-
-				target_entry.length = source_entry.length;
-				target_entry.offset = old_target_child_len;
-				if (tmask.RowIsValid(target_offset + i)) {
-					old_target_child_len += target_entry.length;
-				}
-			}
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type '%s' for copy!",
-		                              TypeIdToString(source->GetType().InternalType()));
-	}
-
-	if (target_vector_type != VectorType::FLAT_VECTOR) {
-		target.SetVectorType(target_vector_type);
-	}
-}
-
-void VectorOperations::Copy(const Vector &source_p, Vector &target, const SelectionVector &sel_p, idx_t source_count,
-                            idx_t source_offset, idx_t target_offset) {
-	D_ASSERT(source_offset <= source_count);
-	D_ASSERT(source_p.GetType() == target.GetType());
-	idx_t copy_count = source_count - source_offset;
-	VectorOperations::Copy(source_p, target, sel_p, source_count, source_offset, target_offset, copy_count);
-}
-
-void VectorOperations::Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
-                            idx_t target_offset) {
-	VectorOperations::Copy(source, target, *FlatVector::IncrementalSelectionVector(), source_count, source_offset,
-	                       target_offset);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/vector_hash.cpp b/src/duckdb/src/common/vector_operations/vector_hash.cpp
deleted file mode 100644
index c82422c23..000000000
--- a/src/duckdb/src/common/vector_operations/vector_hash.cpp
+++ /dev/null
@@ -1,465 +0,0 @@
-//===--------------------------------------------------------------------===//
-// hash.cpp
-// Description: This file contains the vectorized hash implementations
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-struct HashOp {
-	static const hash_t NULL_HASH = 0xbf58476d1ce4e5b9;
-
-	template <class T>
-	static inline hash_t Operation(T input, bool is_null) {
-		return is_null ? NULL_HASH : duckdb::Hash<T>(input);
-	}
-};
-
-static inline hash_t CombineHashScalar(hash_t a, hash_t b) {
-	a ^= a >> 32;
-	a *= 0xd6e8feb86659fd93U;
-	return a ^ b;
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TightLoopHash(const T *__restrict ldata, hash_t *__restrict result_data, const SelectionVector *rsel,
-                                 idx_t count, const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
-	if (!mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			result_data[ridx] = HashOp::Operation(ldata[idx], !mask.RowIsValid(idx));
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			result_data[ridx] = duckdb::Hash<T>(ldata[idx]);
-		}
-	}
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TemplatedLoopHash(Vector &input, Vector &result, const SelectionVector *rsel, idx_t count) {
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		auto ldata = ConstantVector::GetData<T>(input);
-		auto result_data = ConstantVector::GetData<hash_t>(result);
-		*result_data = HashOp::Operation(*ldata, ConstantVector::IsNull(input));
-	} else {
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		UnifiedVectorFormat idata;
-		input.ToUnifiedFormat(count, idata);
-
-		TightLoopHash<HAS_RSEL, T>(UnifiedVectorFormat::GetData<T>(idata), FlatVector::GetData<hash_t>(result), rsel,
-		                           count, idata.sel, idata.validity);
-	}
-}
-
-template <bool HAS_RSEL, bool FIRST_HASH>
-static inline void StructLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	auto &children = StructVector::GetEntries(input);
-
-	D_ASSERT(!children.empty());
-	idx_t col_no = 0;
-	if (HAS_RSEL) {
-		if (FIRST_HASH) {
-			VectorOperations::Hash(*children[col_no++], hashes, *rsel, count);
-		} else {
-			VectorOperations::CombineHash(hashes, *children[col_no++], *rsel, count);
-		}
-		while (col_no < children.size()) {
-			VectorOperations::CombineHash(hashes, *children[col_no++], *rsel, count);
-		}
-	} else {
-		if (FIRST_HASH) {
-			VectorOperations::Hash(*children[col_no++], hashes, count);
-		} else {
-			VectorOperations::CombineHash(hashes, *children[col_no++], count);
-		}
-		while (col_no < children.size()) {
-			VectorOperations::CombineHash(hashes, *children[col_no++], count);
-		}
-	}
-}
-
-template <bool HAS_RSEL, bool FIRST_HASH>
-static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	// FIXME: if we want to be more efficient we shouldn't flatten, but the logic here currently requires it
-	hashes.Flatten(count);
-	auto hdata = FlatVector::GetData<hash_t>(hashes);
-
-	UnifiedVectorFormat idata;
-	input.ToUnifiedFormat(count, idata);
-	const auto ldata = UnifiedVectorFormat::GetData<list_entry_t>(idata);
-
-	// Hash the children into a temporary
-	auto &child = ListVector::GetEntry(input);
-	const auto child_count = ListVector::GetListSize(input);
-
-	Vector child_hashes(LogicalType::HASH, child_count);
-	if (child_count > 0) {
-		VectorOperations::Hash(child, child_hashes, child_count);
-		child_hashes.Flatten(child_count);
-	}
-	auto chdata = FlatVector::GetData<hash_t>(child_hashes);
-
-	// Reduce the number of entries to check to the non-empty ones
-	SelectionVector unprocessed(count);
-	SelectionVector cursor(HAS_RSEL ? STANDARD_VECTOR_SIZE : count);
-	idx_t remaining = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const idx_t ridx = HAS_RSEL ? rsel->get_index(i) : i;
-		const auto lidx = idata.sel->get_index(ridx);
-		const auto &entry = ldata[lidx];
-		if (idata.validity.RowIsValid(lidx) && entry.length > 0) {
-			unprocessed.set_index(remaining++, ridx);
-			cursor.set_index(ridx, entry.offset);
-		} else if (FIRST_HASH) {
-			hdata[ridx] = HashOp::NULL_HASH;
-		}
-		// Empty or NULL non-first elements have no effect.
-	}
-
-	count = remaining;
-	if (count == 0) {
-		return;
-	}
-
-	// Merge the first position hash into the main hash
-	idx_t position = 1;
-	if (FIRST_HASH) {
-		remaining = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto ridx = unprocessed.get_index(i);
-			const auto cidx = cursor.get_index(ridx);
-			hdata[ridx] = chdata[cidx];
-
-			const auto lidx = idata.sel->get_index(ridx);
-			const auto &entry = ldata[lidx];
-			if (entry.length > position) {
-				// Entry still has values to hash
-				unprocessed.set_index(remaining++, ridx);
-				cursor.set_index(ridx, cidx + 1);
-			}
-		}
-		count = remaining;
-		if (count == 0) {
-			return;
-		}
-		++position;
-	}
-
-	// Combine the hashes for the remaining positions until there are none left
-	for (;; ++position) {
-		remaining = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto ridx = unprocessed.get_index(i);
-			const auto cidx = cursor.get_index(ridx);
-			hdata[ridx] = CombineHashScalar(hdata[ridx], chdata[cidx]);
-
-			const auto lidx = idata.sel->get_index(ridx);
-			const auto &entry = ldata[lidx];
-			if (entry.length > position) {
-				// Entry still has values to hash
-				unprocessed.set_index(remaining++, ridx);
-				cursor.set_index(ridx, cidx + 1);
-			}
-		}
-
-		count = remaining;
-		if (count == 0) {
-			break;
-		}
-	}
-}
-
-template <bool HAS_RSEL, bool FIRST_HASH>
-static inline void ArrayLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	hashes.Flatten(count);
-	auto hdata = FlatVector::GetData<hash_t>(hashes);
-
-	UnifiedVectorFormat idata;
-	input.ToUnifiedFormat(count, idata);
-
-	// Hash the children into a temporary
-	auto &child = ArrayVector::GetEntry(input);
-	auto array_size = ArrayType::GetSize(input.GetType());
-
-	auto is_flat = input.GetVectorType() == VectorType::FLAT_VECTOR;
-	auto is_constant = input.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-	if (!HAS_RSEL && (is_flat || is_constant)) {
-		// Fast path for contiguous vectors with no selection vector
-		auto child_count = array_size * (is_constant ? 1 : count);
-
-		Vector child_hashes(LogicalType::HASH, child_count);
-		VectorOperations::Hash(child, child_hashes, child_count);
-		child_hashes.Flatten(child_count);
-		auto chdata = FlatVector::GetData<hash_t>(child_hashes);
-
-		for (idx_t i = 0; i < count; i++) {
-			auto lidx = idata.sel->get_index(i);
-			if (idata.validity.RowIsValid(lidx)) {
-				if (FIRST_HASH) {
-					hdata[i] = 0;
-				}
-				for (idx_t j = 0; j < array_size; j++) {
-					auto offset = lidx * array_size + j;
-					hdata[i] = CombineHashScalar(hdata[i], chdata[offset]);
-				}
-			} else if (FIRST_HASH) {
-				hdata[i] = HashOp::NULL_HASH;
-			}
-		}
-	} else {
-		// Hash the arrays one-by-one
-		SelectionVector array_sel(array_size);
-		Vector array_hashes(LogicalType::HASH, array_size);
-		for (idx_t i = 0; i < count; i++) {
-			const auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			const auto lidx = idata.sel->get_index(ridx);
-
-			if (idata.validity.RowIsValid(lidx)) {
-				// Create a selection vector for the array
-				for (idx_t j = 0; j < array_size; j++) {
-					array_sel.set_index(j, lidx * array_size + j);
-				}
-
-				// Hash the array slice
-				Vector dict_vec(child, array_sel, array_size);
-				VectorOperations::Hash(dict_vec, array_hashes, array_size);
-				auto ahdata = FlatVector::GetData<hash_t>(array_hashes);
-
-				if (FIRST_HASH) {
-					hdata[ridx] = 0;
-				}
-				// Combine the hashes of the array
-				for (idx_t j = 0; j < array_size; j++) {
-					hdata[ridx] = CombineHashScalar(hdata[ridx], ahdata[j]);
-					// Clear the hash for the next iteration
-					ahdata[j] = 0;
-				}
-			} else if (FIRST_HASH) {
-				hdata[ridx] = HashOp::NULL_HASH;
-			}
-		}
-	}
-}
-
-template <bool HAS_RSEL>
-static inline void HashTypeSwitch(Vector &input, Vector &result, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(result.GetType().id() == LogicalType::HASH);
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedLoopHash<HAS_RSEL, int8_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedLoopHash<HAS_RSEL, int16_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedLoopHash<HAS_RSEL, int32_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedLoopHash<HAS_RSEL, int64_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedLoopHash<HAS_RSEL, uint8_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedLoopHash<HAS_RSEL, uint16_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedLoopHash<HAS_RSEL, uint32_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedLoopHash<HAS_RSEL, uint64_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedLoopHash<HAS_RSEL, hugeint_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedLoopHash<HAS_RSEL, uhugeint_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedLoopHash<HAS_RSEL, float>(input, result, rsel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedLoopHash<HAS_RSEL, double>(input, result, rsel, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedLoopHash<HAS_RSEL, interval_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedLoopHash<HAS_RSEL, string_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::STRUCT:
-		StructLoopHash<HAS_RSEL, true>(input, result, rsel, count);
-		break;
-	case PhysicalType::LIST:
-		ListLoopHash<HAS_RSEL, true>(input, result, rsel, count);
-		break;
-	case PhysicalType::ARRAY:
-		ArrayLoopHash<HAS_RSEL, true>(input, result, rsel, count);
-		break;
-	default:
-		throw InvalidTypeException(input.GetType(), "Invalid type for hash");
-	}
-}
-
-void VectorOperations::Hash(Vector &input, Vector &result, idx_t count) {
-	HashTypeSwitch<false>(input, result, nullptr, count);
-}
-
-void VectorOperations::Hash(Vector &input, Vector &result, const SelectionVector &sel, idx_t count) {
-	HashTypeSwitch<true>(input, result, &sel, count);
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TightLoopCombineHashConstant(const T *__restrict ldata, hash_t constant_hash,
-                                                hash_t *__restrict hash_data, const SelectionVector *rsel, idx_t count,
-                                                const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
-	if (!mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = HashOp::Operation(ldata[idx], !mask.RowIsValid(idx));
-			hash_data[ridx] = CombineHashScalar(constant_hash, other_hash);
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = duckdb::Hash<T>(ldata[idx]);
-			hash_data[ridx] = CombineHashScalar(constant_hash, other_hash);
-		}
-	}
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TightLoopCombineHash(const T *__restrict ldata, hash_t *__restrict hash_data,
-                                        const SelectionVector *rsel, idx_t count,
-                                        const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
-	if (!mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = HashOp::Operation(ldata[idx], !mask.RowIsValid(idx));
-			hash_data[ridx] = CombineHashScalar(hash_data[ridx], other_hash);
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = duckdb::Hash<T>(ldata[idx]);
-			hash_data[ridx] = CombineHashScalar(hash_data[ridx], other_hash);
-		}
-	}
-}
-
-template <bool HAS_RSEL, class T>
-void TemplatedLoopCombineHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR && hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto ldata = ConstantVector::GetData<T>(input);
-		auto hash_data = ConstantVector::GetData<hash_t>(hashes);
-
-		auto other_hash = HashOp::Operation(*ldata, ConstantVector::IsNull(input));
-		*hash_data = CombineHashScalar(*hash_data, other_hash);
-	} else {
-		UnifiedVectorFormat idata;
-		input.ToUnifiedFormat(count, idata);
-		if (hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// mix constant with non-constant, first get the constant value
-			auto constant_hash = *ConstantVector::GetData<hash_t>(hashes);
-			// now re-initialize the hashes vector to an empty flat vector
-			hashes.SetVectorType(VectorType::FLAT_VECTOR);
-			TightLoopCombineHashConstant<HAS_RSEL, T>(UnifiedVectorFormat::GetData<T>(idata), constant_hash,
-			                                          FlatVector::GetData<hash_t>(hashes), rsel, count, idata.sel,
-			                                          idata.validity);
-		} else {
-			D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
-			TightLoopCombineHash<HAS_RSEL, T>(UnifiedVectorFormat::GetData<T>(idata),
-			                                  FlatVector::GetData<hash_t>(hashes), rsel, count, idata.sel,
-			                                  idata.validity);
-		}
-	}
-}
-
-template <bool HAS_RSEL>
-static inline void CombineHashTypeSwitch(Vector &hashes, Vector &input, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedLoopCombineHash<HAS_RSEL, int8_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedLoopCombineHash<HAS_RSEL, int16_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedLoopCombineHash<HAS_RSEL, int32_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedLoopCombineHash<HAS_RSEL, int64_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedLoopCombineHash<HAS_RSEL, uint8_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedLoopCombineHash<HAS_RSEL, uint16_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedLoopCombineHash<HAS_RSEL, uint32_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedLoopCombineHash<HAS_RSEL, uint64_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedLoopCombineHash<HAS_RSEL, hugeint_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedLoopCombineHash<HAS_RSEL, uhugeint_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedLoopCombineHash<HAS_RSEL, float>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedLoopCombineHash<HAS_RSEL, double>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedLoopCombineHash<HAS_RSEL, interval_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedLoopCombineHash<HAS_RSEL, string_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::STRUCT:
-		StructLoopHash<HAS_RSEL, false>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::LIST:
-		ListLoopHash<HAS_RSEL, false>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::ARRAY:
-		ArrayLoopHash<HAS_RSEL, false>(input, hashes, rsel, count);
-		break;
-	default:
-		throw InvalidTypeException(input.GetType(), "Invalid type for hash");
-	}
-}
-
-void VectorOperations::CombineHash(Vector &hashes, Vector &input, idx_t count) {
-	CombineHashTypeSwitch<false>(hashes, input, nullptr, count);
-}
-
-void VectorOperations::CombineHash(Vector &hashes, Vector &input, const SelectionVector &rsel, idx_t count) {
-	CombineHashTypeSwitch<true>(hashes, input, &rsel, count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/vector_operations/vector_storage.cpp b/src/duckdb/src/common/vector_operations/vector_storage.cpp
deleted file mode 100644
index 9c399519d..000000000
--- a/src/duckdb/src/common/vector_operations/vector_storage.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-template <class T>
-static void CopyToStorageLoop(UnifiedVectorFormat &vdata, idx_t count, data_ptr_t target) {
-	auto ldata = UnifiedVectorFormat::GetData<T>(vdata);
-	auto result_data = (T *)target;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(idx)) {
-			result_data[i] = NullValue<T>();
-		} else {
-			result_data[i] = ldata[idx];
-		}
-	}
-}
-
-void VectorOperations::WriteToStorage(Vector &source, idx_t count, data_ptr_t target) {
-	if (count == 0) {
-		return;
-	}
-	UnifiedVectorFormat vdata;
-	source.ToUnifiedFormat(count, vdata);
-
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		CopyToStorageLoop<int8_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT16:
-		CopyToStorageLoop<int16_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT32:
-		CopyToStorageLoop<int32_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT64:
-		CopyToStorageLoop<int64_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT8:
-		CopyToStorageLoop<uint8_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT16:
-		CopyToStorageLoop<uint16_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT32:
-		CopyToStorageLoop<uint32_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT64:
-		CopyToStorageLoop<uint64_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT128:
-		CopyToStorageLoop<hugeint_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT128:
-		CopyToStorageLoop<uhugeint_t>(vdata, count, target);
-		break;
-	case PhysicalType::FLOAT:
-		CopyToStorageLoop<float>(vdata, count, target);
-		break;
-	case PhysicalType::DOUBLE:
-		CopyToStorageLoop<double>(vdata, count, target);
-		break;
-	case PhysicalType::INTERVAL:
-		CopyToStorageLoop<interval_t>(vdata, count, target);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for WriteToStorage");
-	}
-}
-
-template <class T>
-static void ReadFromStorageLoop(data_ptr_t source, idx_t count, Vector &result) {
-	auto ldata = (T *)source;
-	auto result_data = FlatVector::GetData<T>(result);
-	for (idx_t i = 0; i < count; i++) {
-		result_data[i] = ldata[i];
-	}
-}
-
-void VectorOperations::ReadFromStorage(data_ptr_t source, idx_t count, Vector &result) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		ReadFromStorageLoop<int8_t>(source, count, result);
-		break;
-	case PhysicalType::INT16:
-		ReadFromStorageLoop<int16_t>(source, count, result);
-		break;
-	case PhysicalType::INT32:
-		ReadFromStorageLoop<int32_t>(source, count, result);
-		break;
-	case PhysicalType::INT64:
-		ReadFromStorageLoop<int64_t>(source, count, result);
-		break;
-	case PhysicalType::UINT8:
-		ReadFromStorageLoop<uint8_t>(source, count, result);
-		break;
-	case PhysicalType::UINT16:
-		ReadFromStorageLoop<uint16_t>(source, count, result);
-		break;
-	case PhysicalType::UINT32:
-		ReadFromStorageLoop<uint32_t>(source, count, result);
-		break;
-	case PhysicalType::UINT64:
-		ReadFromStorageLoop<uint64_t>(source, count, result);
-		break;
-	case PhysicalType::INT128:
-		ReadFromStorageLoop<hugeint_t>(source, count, result);
-		break;
-	case PhysicalType::UINT128:
-		ReadFromStorageLoop<uhugeint_t>(source, count, result);
-		break;
-	case PhysicalType::FLOAT:
-		ReadFromStorageLoop<float>(source, count, result);
-		break;
-	case PhysicalType::DOUBLE:
-		ReadFromStorageLoop<double>(source, count, result);
-		break;
-	case PhysicalType::INTERVAL:
-		ReadFromStorageLoop<interval_t>(source, count, result);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for ReadFromStorage");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/virtual_file_system.cpp b/src/duckdb/src/common/virtual_file_system.cpp
deleted file mode 100644
index 74892a4e0..000000000
--- a/src/duckdb/src/common/virtual_file_system.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-#include "duckdb/common/virtual_file_system.hpp"
-#include "duckdb/common/gzip_file_system.hpp"
-#include "duckdb/common/pipe_file_system.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-VirtualFileSystem::VirtualFileSystem() : default_fs(FileSystem::CreateLocal()) {
-	VirtualFileSystem::RegisterSubSystem(FileCompressionType::GZIP, make_uniq<GZipFileSystem>());
-}
-
-unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, FileOpenFlags flags,
-                                                   optional_ptr<FileOpener> opener) {
-	auto compression = flags.Compression();
-	if (compression == FileCompressionType::AUTO_DETECT) {
-		// auto-detect compression settings based on file name
-		auto lower_path = StringUtil::Lower(path);
-		if (StringUtil::EndsWith(lower_path, ".tmp")) {
-			// strip .tmp
-			lower_path = lower_path.substr(0, lower_path.length() - 4);
-		}
-		if (IsFileCompressed(path, FileCompressionType::GZIP)) {
-			compression = FileCompressionType::GZIP;
-		} else if (IsFileCompressed(path, FileCompressionType::ZSTD)) {
-			compression = FileCompressionType::ZSTD;
-		} else {
-			compression = FileCompressionType::UNCOMPRESSED;
-		}
-	}
-	// open the base file handle in UNCOMPRESSED mode
-	flags.SetCompression(FileCompressionType::UNCOMPRESSED);
-	auto file_handle = FindFileSystem(path).OpenFile(path, flags, opener);
-	if (!file_handle) {
-		return nullptr;
-	}
-	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
-		file_handle = PipeFileSystem::OpenPipe(std::move(file_handle));
-	} else if (compression != FileCompressionType::UNCOMPRESSED) {
-		auto entry = compressed_fs.find(compression);
-		if (entry == compressed_fs.end()) {
-			throw NotImplementedException(
-			    "Attempting to open a compressed file, but the compression type is not supported");
-		}
-		file_handle = entry->second->OpenCompressedFile(std::move(file_handle), flags.OpenForWriting());
-	}
-	return file_handle;
-}
-
-void VirtualFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	handle.file_system.Read(handle, buffer, nr_bytes, location);
-}
-
-void VirtualFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	handle.file_system.Write(handle, buffer, nr_bytes, location);
-}
-
-int64_t VirtualFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	return handle.file_system.Read(handle, buffer, nr_bytes);
-}
-
-int64_t VirtualFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	return handle.file_system.Write(handle, buffer, nr_bytes);
-}
-
-int64_t VirtualFileSystem::GetFileSize(FileHandle &handle) {
-	return handle.file_system.GetFileSize(handle);
-}
-time_t VirtualFileSystem::GetLastModifiedTime(FileHandle &handle) {
-	return handle.file_system.GetLastModifiedTime(handle);
-}
-FileType VirtualFileSystem::GetFileType(FileHandle &handle) {
-	return handle.file_system.GetFileType(handle);
-}
-
-void VirtualFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	handle.file_system.Truncate(handle, new_size);
-}
-
-void VirtualFileSystem::FileSync(FileHandle &handle) {
-	handle.file_system.FileSync(handle);
-}
-
-// need to look up correct fs for this
-bool VirtualFileSystem::DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) {
-	return FindFileSystem(directory).DirectoryExists(directory, opener);
-}
-void VirtualFileSystem::CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	FindFileSystem(directory).CreateDirectory(directory, opener);
-}
-
-void VirtualFileSystem::RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) {
-	FindFileSystem(directory).RemoveDirectory(directory, opener);
-}
-
-bool VirtualFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-                                  FileOpener *opener) {
-	return FindFileSystem(directory).ListFiles(directory, callback, opener);
-}
-
-void VirtualFileSystem::MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) {
-	FindFileSystem(source).MoveFile(source, target, opener);
-}
-
-bool VirtualFileSystem::FileExists(const string &filename, optional_ptr<FileOpener> opener) {
-	return FindFileSystem(filename).FileExists(filename, opener);
-}
-
-bool VirtualFileSystem::IsPipe(const string &filename, optional_ptr<FileOpener> opener) {
-	return FindFileSystem(filename).IsPipe(filename, opener);
-}
-
-void VirtualFileSystem::RemoveFile(const string &filename, optional_ptr<FileOpener> opener) {
-	FindFileSystem(filename).RemoveFile(filename, opener);
-}
-
-string VirtualFileSystem::PathSeparator(const string &path) {
-	return FindFileSystem(path).PathSeparator(path);
-}
-
-vector<string> VirtualFileSystem::Glob(const string &path, FileOpener *opener) {
-	return FindFileSystem(path).Glob(path, opener);
-}
-
-void VirtualFileSystem::RegisterSubSystem(unique_ptr<FileSystem> fs) {
-	sub_systems.push_back(std::move(fs));
-}
-
-void VirtualFileSystem::UnregisterSubSystem(const string &name) {
-	for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) {
-		if (sub_system->get()->GetName() == name) {
-			sub_systems.erase(sub_system);
-			return;
-		}
-	}
-	throw InvalidInputException("Could not find filesystem with name %s", name);
-}
-
-void VirtualFileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) {
-	compressed_fs[compression_type] = std::move(fs);
-}
-
-vector<string> VirtualFileSystem::ListSubSystems() {
-	vector<string> names(sub_systems.size());
-	for (idx_t i = 0; i < sub_systems.size(); i++) {
-		names[i] = sub_systems[i]->GetName();
-	}
-	return names;
-}
-
-std::string VirtualFileSystem::GetName() const {
-	return "VirtualFileSystem";
-}
-
-void VirtualFileSystem::SetDisabledFileSystems(const vector<string> &names) {
-	unordered_set<string> new_disabled_file_systems;
-	for (auto &name : names) {
-		if (name.empty()) {
-			continue;
-		}
-		if (new_disabled_file_systems.find(name) != new_disabled_file_systems.end()) {
-			throw InvalidInputException("Duplicate disabled file system \"%s\"", name);
-		}
-		new_disabled_file_systems.insert(name);
-	}
-	for (auto &disabled_fs : disabled_file_systems) {
-		if (new_disabled_file_systems.find(disabled_fs) == new_disabled_file_systems.end()) {
-			throw InvalidInputException("File system \"%s\" has been disabled previously, it cannot be re-enabled",
-			                            disabled_fs);
-		}
-	}
-	disabled_file_systems = std::move(new_disabled_file_systems);
-}
-
-FileSystem &VirtualFileSystem::FindFileSystem(const string &path) {
-	auto &fs = FindFileSystemInternal(path);
-	if (!disabled_file_systems.empty() && disabled_file_systems.find(fs.GetName()) != disabled_file_systems.end()) {
-		throw PermissionException("File system %s has been disabled by configuration", fs.GetName());
-	}
-	return fs;
-}
-
-FileSystem &VirtualFileSystem::FindFileSystemInternal(const string &path) {
-	FileSystem *fs = nullptr;
-	for (auto &sub_system : sub_systems) {
-		if (sub_system->CanHandleFile(path)) {
-			if (sub_system->IsManuallySet()) {
-				return *sub_system;
-			}
-			fs = sub_system.get();
-		}
-	}
-	if (fs) {
-		return *fs;
-	}
-	return *default_fs;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/common/windows_util.cpp b/src/duckdb/src/common/windows_util.cpp
deleted file mode 100644
index 8be7a3a04..000000000
--- a/src/duckdb/src/common/windows_util.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/common/windows_util.hpp"
-
-namespace duckdb {
-
-#ifdef DUCKDB_WINDOWS
-
-std::wstring WindowsUtil::UTF8ToUnicode(const char *input) {
-	idx_t result_size;
-
-	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, nullptr, 0);
-	if (result_size == 0) {
-		throw IOException("Failure in MultiByteToWideChar");
-	}
-	auto buffer = make_unsafe_uniq_array<wchar_t>(result_size);
-	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, buffer.get(), result_size);
-	if (result_size == 0) {
-		throw IOException("Failure in MultiByteToWideChar");
-	}
-	return std::wstring(buffer.get(), result_size);
-}
-
-static string WideCharToMultiByteWrapper(LPCWSTR input, uint32_t code_page) {
-	idx_t result_size;
-
-	result_size = WideCharToMultiByte(code_page, 0, input, -1, 0, 0, 0, 0);
-	if (result_size == 0) {
-		throw IOException("Failure in WideCharToMultiByte");
-	}
-	auto buffer = make_unsafe_uniq_array<char>(result_size);
-	result_size = WideCharToMultiByte(code_page, 0, input, -1, buffer.get(), result_size, 0, 0);
-	if (result_size == 0) {
-		throw IOException("Failure in WideCharToMultiByte");
-	}
-	return string(buffer.get(), result_size - 1);
-}
-
-string WindowsUtil::UnicodeToUTF8(LPCWSTR input) {
-	return WideCharToMultiByteWrapper(input, CP_UTF8);
-}
-
-static string WindowsUnicodeToMBCS(LPCWSTR unicode_text, int use_ansi) {
-	uint32_t code_page = use_ansi ? CP_ACP : CP_OEMCP;
-	return WideCharToMultiByteWrapper(unicode_text, code_page);
-}
-
-string WindowsUtil::UTF8ToMBCS(const char *input, bool use_ansi) {
-	auto unicode = WindowsUtil::UTF8ToUnicode(input);
-	return WindowsUnicodeToMBCS(unicode.c_str(), use_ansi);
-}
-
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/adaptive_filter.cpp b/src/duckdb/src/execution/adaptive_filter.cpp
deleted file mode 100644
index 6077ae3ff..000000000
--- a/src/duckdb/src/execution/adaptive_filter.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/execution/adaptive_filter.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-AdaptiveFilter::AdaptiveFilter(const Expression &expr) : observe_interval(10), execute_interval(20), warmup(true) {
-	auto &conj_expr = expr.Cast<BoundConjunctionExpression>();
-	D_ASSERT(conj_expr.children.size() > 1);
-	for (idx_t idx = 0; idx < conj_expr.children.size(); idx++) {
-		permutation.push_back(idx);
-		if (conj_expr.children[idx]->CanThrow()) {
-			disable_permutations = true;
-		}
-		if (idx != conj_expr.children.size() - 1) {
-			swap_likeliness.push_back(100);
-		}
-	}
-	right_random_border = 100 * (conj_expr.children.size() - 1);
-}
-
-AdaptiveFilter::AdaptiveFilter(const TableFilterSet &table_filters)
-    : observe_interval(10), execute_interval(20), warmup(true) {
-	for (idx_t idx = 0; idx < table_filters.filters.size(); idx++) {
-		permutation.push_back(idx);
-		swap_likeliness.push_back(100);
-	}
-	swap_likeliness.pop_back();
-	right_random_border = 100 * (table_filters.filters.size() - 1);
-}
-
-AdaptiveFilterState AdaptiveFilter::BeginFilter() const {
-	if (permutation.size() <= 1 || disable_permutations) {
-		return AdaptiveFilterState();
-	}
-	AdaptiveFilterState state;
-	state.start_time = high_resolution_clock::now();
-	return state;
-}
-
-void AdaptiveFilter::EndFilter(AdaptiveFilterState state) {
-	if (permutation.size() <= 1 || disable_permutations) {
-		// nothing to permute
-		return;
-	}
-	auto end_time = high_resolution_clock::now();
-	AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - state.start_time).count());
-}
-
-void AdaptiveFilter::AdaptRuntimeStatistics(double duration) {
-	iteration_count++;
-	runtime_sum += duration;
-
-	D_ASSERT(!disable_permutations);
-	if (!warmup) {
-		// the last swap was observed
-		if (observe && iteration_count == observe_interval) {
-			// keep swap if runtime decreased, else reverse swap
-			if (prev_mean - (runtime_sum / static_cast<double>(iteration_count)) <= 0) {
-				// reverse swap because runtime didn't decrease
-				std::swap(permutation[swap_idx], permutation[swap_idx + 1]);
-
-				// decrease swap likeliness, but make sure there is always a small likeliness left
-				if (swap_likeliness[swap_idx] > 1) {
-					swap_likeliness[swap_idx] /= 2;
-				}
-			} else {
-				// keep swap because runtime decreased, reset likeliness
-				swap_likeliness[swap_idx] = 100;
-			}
-			observe = false;
-
-			// reset values
-			iteration_count = 0;
-			runtime_sum = 0.0;
-		} else if (!observe && iteration_count == execute_interval) {
-			// save old mean to evaluate swap
-			prev_mean = runtime_sum / static_cast<double>(iteration_count);
-
-			// get swap index and swap likeliness
-			// a <= i <= b
-			auto random_number = generator.NextRandomInteger(1, NumericCast<uint32_t>(right_random_border));
-
-			swap_idx = random_number / 100;                    // index to be swapped
-			idx_t likeliness = random_number - 100 * swap_idx; // random number between [0, 100)
-
-			// check if swap is going to happen
-			if (swap_likeliness[swap_idx] > likeliness) { // always true for the first swap of an index
-				// swap
-				std::swap(permutation[swap_idx], permutation[swap_idx + 1]);
-
-				// observe whether swap will be applied
-				observe = true;
-			}
-
-			// reset values
-			iteration_count = 0;
-			runtime_sum = 0.0;
-		}
-	} else {
-		if (iteration_count == 5) {
-			// initially set all values
-			iteration_count = 0;
-			runtime_sum = 0.0;
-			observe = false;
-			warmup = false;
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/aggregate_hashtable.cpp b/src/duckdb/src/execution/aggregate_hashtable.cpp
deleted file mode 100644
index 198b77fac..000000000
--- a/src/duckdb/src/execution/aggregate_hashtable.cpp
+++ /dev/null
@@ -1,854 +0,0 @@
-#include "duckdb/execution/aggregate_hashtable.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/row/tuple_data_iterator.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/ht_entry.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = TupleDataLayout::ValidityBytes;
-
-GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, Allocator &allocator,
-                                                     vector<LogicalType> group_types, vector<LogicalType> payload_types,
-                                                     const vector<BoundAggregateExpression *> &bindings,
-                                                     idx_t initial_capacity, idx_t radix_bits)
-    : GroupedAggregateHashTable(context, allocator, std::move(group_types), std::move(payload_types),
-                                AggregateObject::CreateAggregateObjects(bindings), initial_capacity, radix_bits) {
-}
-
-GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, Allocator &allocator,
-                                                     vector<LogicalType> group_types)
-    : GroupedAggregateHashTable(context, allocator, std::move(group_types), {}, vector<AggregateObject>()) {
-}
-
-GroupedAggregateHashTable::AggregateHTAppendState::AggregateHTAppendState()
-    : ht_offsets(LogicalType::UBIGINT), hash_salts(LogicalType::HASH), group_compare_vector(STANDARD_VECTOR_SIZE),
-      no_match_vector(STANDARD_VECTOR_SIZE), empty_vector(STANDARD_VECTOR_SIZE), new_groups(STANDARD_VECTOR_SIZE),
-      addresses(LogicalType::POINTER) {
-}
-
-GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, Allocator &allocator,
-                                                     vector<LogicalType> group_types_p,
-                                                     vector<LogicalType> payload_types_p,
-                                                     vector<AggregateObject> aggregate_objects_p,
-                                                     idx_t initial_capacity, idx_t radix_bits)
-    : BaseAggregateHashTable(context, allocator, aggregate_objects_p, std::move(payload_types_p)),
-      radix_bits(radix_bits), count(0), capacity(0), skip_lookups(false),
-      aggregate_allocator(make_shared_ptr<ArenaAllocator>(allocator)) {
-
-	// Append hash column to the end and initialise the row layout
-	group_types_p.emplace_back(LogicalType::HASH);
-	layout.Initialize(std::move(group_types_p), std::move(aggregate_objects_p));
-
-	hash_offset = layout.GetOffsets()[layout.ColumnCount() - 1];
-
-	// Partitioned data and pointer table
-	InitializePartitionedData();
-	if (radix_bits >= UNPARTITIONED_RADIX_BITS_THRESHOLD) {
-		InitializeUnpartitionedData();
-	}
-	Resize(initial_capacity);
-
-	// Predicates
-	predicates.resize(layout.ColumnCount() - 1, ExpressionType::COMPARE_NOT_DISTINCT_FROM);
-	row_matcher.Initialize(true, layout, predicates);
-}
-
-void GroupedAggregateHashTable::InitializePartitionedData() {
-	if (!partitioned_data ||
-	    RadixPartitioning::RadixBitsOfPowerOfTwo(partitioned_data->PartitionCount()) != radix_bits) {
-		D_ASSERT(!partitioned_data || partitioned_data->Count() == 0);
-		partitioned_data =
-		    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
-	} else {
-		partitioned_data->Reset();
-	}
-
-	D_ASSERT(GetLayout().GetAggrWidth() == layout.GetAggrWidth());
-	D_ASSERT(GetLayout().GetDataWidth() == layout.GetDataWidth());
-	D_ASSERT(GetLayout().GetRowWidth() == layout.GetRowWidth());
-
-	partitioned_data->InitializeAppendState(state.partitioned_append_state,
-	                                        TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
-}
-
-void GroupedAggregateHashTable::InitializeUnpartitionedData() {
-	D_ASSERT(radix_bits >= UNPARTITIONED_RADIX_BITS_THRESHOLD);
-	if (!unpartitioned_data) {
-		unpartitioned_data =
-		    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, 0ULL, layout.ColumnCount() - 1);
-	} else {
-		unpartitioned_data->Reset();
-	}
-	unpartitioned_data->InitializeAppendState(state.unpartitioned_append_state,
-	                                          TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
-}
-
-const PartitionedTupleData &GroupedAggregateHashTable::GetPartitionedData() const {
-	return *partitioned_data;
-}
-
-unique_ptr<PartitionedTupleData> GroupedAggregateHashTable::AcquirePartitionedData() {
-	// Flush/unpin partitioned data
-	partitioned_data->FlushAppendState(state.partitioned_append_state);
-	partitioned_data->Unpin();
-
-	if (radix_bits >= UNPARTITIONED_RADIX_BITS_THRESHOLD) {
-		// Flush/unpin unpartitioned data and append to partitioned data
-		if (unpartitioned_data) {
-			unpartitioned_data->FlushAppendState(state.unpartitioned_append_state);
-			unpartitioned_data->Unpin();
-			unpartitioned_data->Repartition(*partitioned_data);
-		}
-		InitializeUnpartitionedData();
-	}
-
-	// Return and re-initialize
-	auto result = std::move(partitioned_data);
-	InitializePartitionedData();
-	return result;
-}
-
-void GroupedAggregateHashTable::Abandon() {
-	if (radix_bits >= UNPARTITIONED_RADIX_BITS_THRESHOLD) {
-		// Flush/unpin unpartitioned data and append to partitioned data
-		if (unpartitioned_data) {
-			unpartitioned_data->FlushAppendState(state.unpartitioned_append_state);
-			unpartitioned_data->Unpin();
-			unpartitioned_data->Repartition(*partitioned_data);
-		}
-		InitializeUnpartitionedData();
-	}
-
-	// Start over
-	ClearPointerTable();
-	count = 0;
-
-	// Resetting the id ensures the dict state is reset properly when needed
-	state.dict_state.dictionary_id = string();
-}
-
-void GroupedAggregateHashTable::Repartition() {
-	auto old = AcquirePartitionedData();
-	D_ASSERT(old->GetPartitions().size() != partitioned_data->GetPartitions().size());
-	old->Repartition(*partitioned_data);
-}
-
-shared_ptr<ArenaAllocator> GroupedAggregateHashTable::GetAggregateAllocator() {
-	return aggregate_allocator;
-}
-
-GroupedAggregateHashTable::~GroupedAggregateHashTable() {
-	Destroy();
-}
-
-void GroupedAggregateHashTable::Destroy() {
-	if (!partitioned_data || partitioned_data->Count() == 0 || !layout.HasDestructor()) {
-		return;
-	}
-
-	// There are aggregates with destructors: Call the destructor for each of the aggregates
-	// Currently does not happen because aggregate destructors are called while scanning in RadixPartitionedHashTable
-	// LCOV_EXCL_START
-	RowOperationsState row_state(*aggregate_allocator);
-	for (auto &data_collection : partitioned_data->GetPartitions()) {
-		if (data_collection->Count() == 0) {
-			continue;
-		}
-		TupleDataChunkIterator iterator(*data_collection, TupleDataPinProperties::DESTROY_AFTER_DONE, false);
-		auto &row_locations = iterator.GetChunkState().row_locations;
-		do {
-			RowOperations::DestroyStates(row_state, layout, row_locations, iterator.GetCurrentChunkCount());
-		} while (iterator.Next());
-		data_collection->Reset();
-	}
-	// LCOV_EXCL_STOP
-}
-
-const TupleDataLayout &GroupedAggregateHashTable::GetLayout() const {
-	return partitioned_data->GetLayout();
-}
-
-idx_t GroupedAggregateHashTable::Count() const {
-	return count;
-}
-
-idx_t GroupedAggregateHashTable::InitialCapacity() {
-	return STANDARD_VECTOR_SIZE * 2ULL;
-}
-
-idx_t GroupedAggregateHashTable::GetCapacityForCount(idx_t count) {
-	count = MaxValue<idx_t>(InitialCapacity(), count);
-	return NextPowerOfTwo(LossyNumericCast<uint64_t>(static_cast<double>(count) * LOAD_FACTOR));
-}
-
-idx_t GroupedAggregateHashTable::Capacity() const {
-	return capacity;
-}
-
-idx_t GroupedAggregateHashTable::ResizeThreshold() const {
-	return ResizeThreshold(Capacity());
-}
-
-idx_t GroupedAggregateHashTable::ResizeThreshold(const idx_t capacity) {
-	return LossyNumericCast<idx_t>(static_cast<double>(capacity) / LOAD_FACTOR);
-}
-
-idx_t GroupedAggregateHashTable::ApplyBitMask(hash_t hash) const {
-	return hash & bitmask;
-}
-
-void GroupedAggregateHashTable::Verify() {
-#ifdef DEBUG
-	if (skip_lookups) {
-		return;
-	}
-	idx_t total_count = 0;
-	for (idx_t i = 0; i < capacity; i++) {
-		const auto &entry = entries[i];
-		if (!entry.IsOccupied()) {
-			continue;
-		}
-		auto hash = Load<hash_t>(entry.GetPointer() + hash_offset);
-		D_ASSERT(entry.GetSalt() == ht_entry_t::ExtractSalt(hash));
-		total_count++;
-	}
-	D_ASSERT(total_count == Count());
-#endif
-}
-
-void GroupedAggregateHashTable::ClearPointerTable() {
-	std::fill_n(entries, capacity, ht_entry_t());
-}
-
-void GroupedAggregateHashTable::SetRadixBits(idx_t radix_bits_p) {
-	radix_bits = radix_bits_p;
-}
-
-idx_t GroupedAggregateHashTable::GetRadixBits() const {
-	return radix_bits;
-}
-
-idx_t GroupedAggregateHashTable::GetSinkCount() const {
-	return sink_count;
-}
-
-void GroupedAggregateHashTable::SkipLookups() {
-	skip_lookups = true;
-}
-
-void GroupedAggregateHashTable::Resize(idx_t size) {
-	D_ASSERT(size >= STANDARD_VECTOR_SIZE);
-	D_ASSERT(IsPowerOfTwo(size));
-	if (Count() != 0 && size < capacity) {
-		throw InternalException("Cannot downsize a non-empty hash table!");
-	}
-
-	capacity = size;
-	hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(ht_entry_t));
-	entries = reinterpret_cast<ht_entry_t *>(hash_map.get());
-	ClearPointerTable();
-	bitmask = capacity - 1;
-
-	if (Count() != 0) {
-		ReinsertTuples(*partitioned_data);
-		if (radix_bits >= UNPARTITIONED_RADIX_BITS_THRESHOLD) {
-			ReinsertTuples(*unpartitioned_data);
-		}
-	}
-
-	Verify();
-}
-
-void GroupedAggregateHashTable::ReinsertTuples(PartitionedTupleData &data) {
-	for (auto &data_collection : data.GetPartitions()) {
-		if (data_collection->Count() == 0) {
-			continue;
-		}
-		TupleDataChunkIterator iterator(*data_collection, TupleDataPinProperties::ALREADY_PINNED, false);
-		const auto row_locations = iterator.GetRowLocations();
-		do {
-			for (idx_t i = 0; i < iterator.GetCurrentChunkCount(); i++) {
-				const auto &row_location = row_locations[i];
-				const auto hash = Load<hash_t>(row_location + hash_offset);
-
-				// Find an empty entry
-				auto ht_offset = ApplyBitMask(hash);
-				D_ASSERT(ht_offset == hash % capacity);
-				while (entries[ht_offset].IsOccupied()) {
-					IncrementAndWrap(ht_offset, bitmask);
-				}
-				auto &entry = entries[ht_offset];
-				D_ASSERT(!entry.IsOccupied());
-				entry.SetSalt(ht_entry_t::ExtractSalt(hash));
-				entry.SetPointer(row_location);
-				D_ASSERT(entry.IsOccupied());
-			}
-		} while (iterator.Next());
-	}
-}
-
-idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload, AggregateType filter) {
-	unsafe_vector<idx_t> aggregate_filter;
-
-	auto &aggregates = layout.GetAggregates();
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i];
-		if (aggregate.aggr_type == filter) {
-			aggregate_filter.push_back(i);
-		}
-	}
-	return AddChunk(groups, payload, aggregate_filter);
-}
-
-GroupedAggregateHashTable::AggregateDictionaryState::AggregateDictionaryState()
-    : hashes(LogicalType::HASH), new_dictionary_pointers(LogicalType::POINTER), unique_entries(STANDARD_VECTOR_SIZE) {
-}
-
-optional_idx GroupedAggregateHashTable::TryAddDictionaryGroups(DataChunk &groups, DataChunk &payload,
-                                                               const unsafe_vector<idx_t> &filter) {
-	static constexpr idx_t MAX_DICTIONARY_SIZE_THRESHOLD = 20000;
-	static constexpr idx_t DICTIONARY_THRESHOLD = 2;
-	// dictionary vector - check if this is a duplicate eliminated dictionary from the storage
-	auto &dict_col = groups.data[0];
-	auto opt_dict_size = DictionaryVector::DictionarySize(dict_col);
-	if (!opt_dict_size.IsValid()) {
-		// dict size not known - this is not a dictionary that comes from the storage
-		return optional_idx();
-	}
-	idx_t dict_size = opt_dict_size.GetIndex();
-	auto &dictionary_id = DictionaryVector::DictionaryId(dict_col);
-	if (dictionary_id.empty()) {
-		// dictionary has no id, we can't cache across vectors
-		// only use dictionary compression if there are fewer entries than groups
-		if (dict_size >= groups.size() * DICTIONARY_THRESHOLD) {
-			// dictionary is too large - use regular aggregation
-			return optional_idx();
-		}
-	} else {
-		// dictionary has an id - we can cache across vectors
-		// use a much larger limit for dictionary
-		if (dict_size >= MAX_DICTIONARY_SIZE_THRESHOLD) {
-			// dictionary is too large - use regular aggregation
-			return optional_idx();
-		}
-	}
-	auto &dictionary_vector = DictionaryVector::Child(dict_col);
-	auto &offsets = DictionaryVector::SelVector(dict_col);
-	auto &dict_state = state.dict_state;
-	if (dict_state.dictionary_id.empty() || dict_state.dictionary_id != dictionary_id) {
-		// new dictionary - initialize the index state
-		if (dict_size > dict_state.capacity) {
-			dict_state.dictionary_addresses = make_uniq<Vector>(LogicalType::POINTER, dict_size);
-			dict_state.found_entry = make_unsafe_uniq_array<bool>(dict_size);
-			dict_state.capacity = dict_size;
-		}
-		memset(dict_state.found_entry.get(), 0, dict_size * sizeof(bool));
-		dict_state.dictionary_id = dictionary_id;
-	} else if (dict_size > dict_state.capacity) {
-		throw InternalException("AggregateHT - using cached dictionary data but dictionary has changed (dictionary id "
-		                        "%s - dict size %d, current capacity %d)",
-		                        dict_state.dictionary_id, dict_size, dict_state.capacity);
-	}
-
-	auto &found_entry = dict_state.found_entry;
-	auto &unique_entries = dict_state.unique_entries;
-	idx_t unique_count = 0;
-	// for each of the dictionary entries - check if we have already done a look-up into the hash table
-	// if we have, we can just use the cached group pointers
-	for (idx_t i = 0; i < groups.size(); i++) {
-		auto dict_idx = offsets.get_index(i);
-		unique_entries.set_index(unique_count, dict_idx);
-		unique_count += !found_entry[dict_idx];
-		found_entry[dict_idx] = true;
-	}
-	auto &new_dictionary_pointers = dict_state.new_dictionary_pointers;
-	idx_t new_group_count = 0;
-	if (unique_count > 0) {
-		auto &unique_values = dict_state.unique_values;
-		if (unique_values.ColumnCount() == 0) {
-			unique_values.InitializeEmpty(groups.GetTypes());
-		}
-		// slice the dictionary
-		unique_values.data[0].Slice(dictionary_vector, unique_entries, unique_count);
-		unique_values.SetCardinality(unique_count);
-		// now we know which entries we are going to add - hash them
-		auto &hashes = dict_state.hashes;
-		unique_values.Hash(hashes);
-
-		// add the dictionary groups to the hash table
-		new_group_count = FindOrCreateGroups(unique_values, hashes, new_dictionary_pointers, state.new_groups);
-	}
-	auto &aggregates = layout.GetAggregates();
-	if (aggregates.empty()) {
-		// early-out - no aggregates to update
-		return new_group_count;
-	}
-
-	// set the addresses that we found for each of the unique groups in the main addresses vector
-	auto new_dict_addresses = FlatVector::GetData<uintptr_t>(new_dictionary_pointers);
-	// for each of the new groups, add them to the global (cached) list of addresses for the dictionary
-	auto &dictionary_addresses = *dict_state.dictionary_addresses;
-	auto dict_addresses = FlatVector::GetData<uintptr_t>(dictionary_addresses);
-	for (idx_t i = 0; i < unique_count; i++) {
-		auto dict_idx = unique_entries.get_index(i);
-		dict_addresses[dict_idx] = new_dict_addresses[i] + layout.GetAggrOffset();
-	}
-	// now set up the addresses for the aggregates
-	auto result_addresses = FlatVector::GetData<uintptr_t>(state.addresses);
-	for (idx_t i = 0; i < groups.size(); i++) {
-		auto dict_idx = offsets.get_index(i);
-		result_addresses[i] = dict_addresses[dict_idx];
-	}
-
-	// finally process the aggregates
-	UpdateAggregates(payload, filter);
-
-	return new_group_count;
-}
-
-optional_idx GroupedAggregateHashTable::TryAddConstantGroups(DataChunk &groups, DataChunk &payload,
-                                                             const unsafe_vector<idx_t> &filter) {
-#ifndef DEBUG
-	if (groups.size() <= 1) {
-		// this only has a point if we have multiple groups
-		return optional_idx();
-	}
-#endif
-	auto &dict_state = state.dict_state;
-	auto &unique_values = dict_state.unique_values;
-	if (unique_values.ColumnCount() == 0) {
-		unique_values.InitializeEmpty(groups.GetTypes());
-	}
-	// slice the dictionary
-	unique_values.Reference(groups);
-	unique_values.SetCardinality(1);
-	unique_values.Flatten();
-
-	auto &hashes = dict_state.hashes;
-	unique_values.Hash(hashes);
-
-	// add the single constant group to the hash table
-	auto &new_dictionary_pointers = dict_state.new_dictionary_pointers;
-	auto new_group_count = FindOrCreateGroups(unique_values, hashes, new_dictionary_pointers, state.new_groups);
-
-	auto &aggregates = layout.GetAggregates();
-	if (aggregates.empty()) {
-		// early-out - no aggregates to update
-		return new_group_count;
-	}
-
-	auto new_dict_addresses = FlatVector::GetData<uintptr_t>(new_dictionary_pointers);
-	auto result_addresses = FlatVector::GetData<uintptr_t>(state.addresses);
-	uintptr_t aggregate_address = new_dict_addresses[0] + layout.GetAggrOffset();
-	for (idx_t i = 0; i < payload.size(); i++) {
-		result_addresses[i] = aggregate_address;
-	}
-
-	// process the aggregates
-	// FIXME: we can use simple_update here if the aggregates support it
-	UpdateAggregates(payload, filter);
-
-	return new_group_count;
-}
-
-optional_idx GroupedAggregateHashTable::TryAddCompressedGroups(DataChunk &groups, DataChunk &payload,
-                                                               const unsafe_vector<idx_t> &filter) {
-	// all groups must be compressed
-	if (groups.AllConstant()) {
-		return TryAddConstantGroups(groups, payload, filter);
-	}
-	if (groups.ColumnCount() == 1 && groups.data[0].GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		return TryAddDictionaryGroups(groups, payload, filter);
-	}
-	return optional_idx();
-}
-
-idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload, const unsafe_vector<idx_t> &filter) {
-	sink_count += groups.size();
-
-	// check if we can use an optimized path that utilizes compressed vectors
-	auto result = TryAddCompressedGroups(groups, payload, filter);
-	if (result.IsValid()) {
-		return result.GetIndex();
-	}
-	// otherwise append the raw values
-	Vector hashes(LogicalType::HASH);
-	groups.Hash(hashes);
-
-	return AddChunk(groups, hashes, payload, filter);
-}
-
-void GroupedAggregateHashTable::UpdateAggregates(DataChunk &payload, const unsafe_vector<idx_t> &filter) {
-	// Now every cell has an entry, update the aggregates
-	auto &aggregates = layout.GetAggregates();
-	idx_t filter_idx = 0;
-	idx_t payload_idx = 0;
-	RowOperationsState row_state(*aggregate_allocator);
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggr = aggregates[i];
-		if (filter_idx >= filter.size() || i < filter[filter_idx]) {
-			// Skip all the aggregates that are not in the filter
-			payload_idx += aggr.child_count;
-			VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(aggr.payload_size), payload.size());
-			continue;
-		}
-		D_ASSERT(i == filter[filter_idx]);
-
-		if (aggr.aggr_type != AggregateType::DISTINCT && aggr.filter) {
-			RowOperations::UpdateFilteredStates(row_state, filter_set.GetFilterData(i), aggr, state.addresses, payload,
-			                                    payload_idx);
-		} else {
-			RowOperations::UpdateStates(row_state, aggr, state.addresses, payload, payload_idx, payload.size());
-		}
-
-		// Move to the next aggregate
-		payload_idx += aggr.child_count;
-		VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(aggr.payload_size), payload.size());
-		filter_idx++;
-	}
-
-	Verify();
-}
-
-idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashes, DataChunk &payload,
-                                          const unsafe_vector<idx_t> &filter) {
-	if (groups.size() == 0) {
-		return 0;
-	}
-
-#ifdef DEBUG
-	D_ASSERT(groups.ColumnCount() + 1 == layout.ColumnCount());
-	for (idx_t i = 0; i < groups.ColumnCount(); i++) {
-		D_ASSERT(groups.GetTypes()[i] == layout.GetTypes()[i]);
-	}
-#endif
-
-	const auto new_group_count = FindOrCreateGroups(groups, group_hashes, state.addresses, state.new_groups);
-	VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(layout.GetAggrOffset()), payload.size());
-
-	UpdateAggregates(payload, filter);
-
-	return new_group_count;
-}
-
-void GroupedAggregateHashTable::FetchAggregates(DataChunk &groups, DataChunk &result) {
-#ifdef DEBUG
-	groups.Verify();
-	D_ASSERT(groups.ColumnCount() + 1 == layout.ColumnCount());
-	for (idx_t i = 0; i < result.ColumnCount(); i++) {
-		D_ASSERT(result.data[i].GetType() == payload_types[i]);
-	}
-#endif
-
-	result.SetCardinality(groups);
-	if (groups.size() == 0) {
-		return;
-	}
-
-	// find the groups associated with the addresses
-	// FIXME: this should not use the FindOrCreateGroups, creating them is unnecessary
-	Vector addresses(LogicalType::POINTER);
-	FindOrCreateGroups(groups, addresses);
-	// now fetch the aggregates
-	RowOperationsState row_state(*aggregate_allocator);
-	RowOperations::FinalizeStates(row_state, layout, addresses, result, 0);
-}
-
-idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes_v,
-                                                            Vector &addresses_v, SelectionVector &new_groups_out) {
-	D_ASSERT(groups.ColumnCount() + 1 == layout.ColumnCount());
-	D_ASSERT(group_hashes_v.GetType() == LogicalType::HASH);
-	D_ASSERT(state.ht_offsets.GetVectorType() == VectorType::FLAT_VECTOR);
-	D_ASSERT(state.ht_offsets.GetType() == LogicalType::UBIGINT);
-	D_ASSERT(addresses_v.GetType() == LogicalType::POINTER);
-	D_ASSERT(state.hash_salts.GetType() == LogicalType::HASH);
-
-	// Need to fit the entire vector, and resize at threshold
-	const auto chunk_size = groups.size();
-	if (Count() + chunk_size > capacity || Count() + chunk_size > ResizeThreshold()) {
-		Verify();
-		Resize(capacity * 2);
-	}
-	D_ASSERT(capacity - Count() >= chunk_size); // we need to be able to fit at least one vector of data
-
-	// we start out with all entries [0, 1, 2, ..., chunk_size]
-	const SelectionVector *sel_vector = FlatVector::IncrementalSelectionVector();
-
-	// Make a chunk that references the groups and the hashes and convert to unified format
-	if (state.group_chunk.ColumnCount() == 0) {
-		state.group_chunk.InitializeEmpty(layout.GetTypes());
-	}
-	D_ASSERT(state.group_chunk.ColumnCount() == layout.GetTypes().size());
-	for (idx_t grp_idx = 0; grp_idx < groups.ColumnCount(); grp_idx++) {
-		state.group_chunk.data[grp_idx].Reference(groups.data[grp_idx]);
-	}
-	state.group_chunk.data[groups.ColumnCount()].Reference(group_hashes_v);
-	state.group_chunk.SetCardinality(groups);
-
-	// convert all vectors to unified format
-	TupleDataCollection::ToUnifiedFormat(state.partitioned_append_state.chunk_state, state.group_chunk);
-	if (!state.group_data) {
-		state.group_data = make_unsafe_uniq_array_uninitialized<UnifiedVectorFormat>(state.group_chunk.ColumnCount());
-	}
-	TupleDataCollection::GetVectorData(state.partitioned_append_state.chunk_state, state.group_data.get());
-
-	group_hashes_v.Flatten(chunk_size);
-	const auto hashes = FlatVector::GetData<hash_t>(group_hashes_v);
-
-	addresses_v.Flatten(chunk_size);
-	const auto addresses = FlatVector::GetData<data_ptr_t>(addresses_v);
-
-	if (skip_lookups) {
-		// Just appending now
-		partitioned_data->AppendUnified(state.partitioned_append_state, state.group_chunk,
-		                                *FlatVector::IncrementalSelectionVector(), chunk_size);
-		RowOperations::InitializeStates(layout, state.partitioned_append_state.chunk_state.row_locations,
-		                                *FlatVector::IncrementalSelectionVector(), chunk_size);
-
-		const auto row_locations =
-		    FlatVector::GetData<data_ptr_t>(state.partitioned_append_state.chunk_state.row_locations);
-		const auto &row_sel = state.partitioned_append_state.reverse_partition_sel;
-		for (idx_t i = 0; i < chunk_size; i++) {
-			const auto &row_idx = row_sel[i];
-			const auto &row_location = row_locations[row_idx];
-			addresses[i] = row_location;
-		}
-		count += chunk_size;
-		return chunk_size;
-	}
-
-	// Compute the entry in the table based on the hash using a modulo,
-	// and precompute the hash salts for faster comparison below
-	const auto ht_offsets = FlatVector::GetData<uint64_t>(state.ht_offsets);
-	const auto hash_salts = FlatVector::GetData<hash_t>(state.hash_salts);
-
-	// We also compute the occupied count, which is essentially useless.
-	// However, this loop is branchless, while the main lookup loop below is not.
-	// So, by doing the lookups here, we better amortize cache misses.
-	idx_t occupied_count = 0;
-	for (idx_t r = 0; r < chunk_size; r++) {
-		const auto &hash = hashes[r];
-		auto &ht_offset = ht_offsets[r];
-		ht_offset = ApplyBitMask(hash);
-		occupied_count += entries[ht_offset].IsOccupied(); // Lookup
-		D_ASSERT(ht_offset == hash % capacity);
-		hash_salts[r] = ht_entry_t::ExtractSalt(hash);
-	}
-
-	idx_t new_group_count = 0;
-	idx_t remaining_entries = chunk_size;
-	idx_t iteration_count;
-	for (iteration_count = 0; remaining_entries > 0 && iteration_count < capacity; iteration_count++) {
-		idx_t new_entry_count = 0;
-		idx_t need_compare_count = 0;
-		idx_t no_match_count = 0;
-
-		// For each remaining entry, figure out whether or not it belongs to a full or empty group
-		for (idx_t i = 0; i < remaining_entries; i++) {
-			const auto index = sel_vector->get_index(i);
-			const auto salt = hash_salts[index];
-			auto &ht_offset = ht_offsets[index];
-
-			idx_t inner_iteration_count;
-			for (inner_iteration_count = 0; inner_iteration_count < capacity; inner_iteration_count++) {
-				auto &entry = entries[ht_offset];
-				if (!entry.IsOccupied()) { // Unoccupied: claim it
-					entry.SetSalt(salt);
-					state.empty_vector.set_index(new_entry_count++, index);
-					new_groups_out.set_index(new_group_count++, index);
-					break;
-				}
-
-				if (DUCKDB_LIKELY(entry.GetSalt() == salt)) { // Matching salt: compare groups
-					state.group_compare_vector.set_index(need_compare_count++, index);
-					break;
-				}
-
-				// Linear probing
-				IncrementAndWrap(ht_offset, bitmask);
-			}
-			if (DUCKDB_UNLIKELY(inner_iteration_count == capacity)) {
-				throw InternalException("Maximum inner iteration count reached in GroupedAggregateHashTable");
-			}
-		}
-
-		if (DUCKDB_UNLIKELY(occupied_count > new_entry_count + need_compare_count)) {
-			// We use the useless occupied_count we summed above here so the variable is used,
-			// and the compiler cannot optimize away the vectorized lookups above. This should never be triggered.
-			throw InternalException("Internal validation failed in GroupedAggregateHashTable");
-		}
-		occupied_count = 0; // Have to set to 0 for next iterations
-
-		if (new_entry_count != 0) {
-			// Append everything that belongs to an empty group
-			optional_ptr<PartitionedTupleData> data;
-			optional_ptr<PartitionedTupleDataAppendState> append_state;
-			if (radix_bits >= UNPARTITIONED_RADIX_BITS_THRESHOLD &&
-			    new_entry_count / RadixPartitioning::NumberOfPartitions(radix_bits) <= 4) {
-				TupleDataCollection::ToUnifiedFormat(state.unpartitioned_append_state.chunk_state, state.group_chunk);
-				data = unpartitioned_data.get();
-				append_state = &state.unpartitioned_append_state;
-			} else {
-				data = partitioned_data.get();
-				append_state = &state.partitioned_append_state;
-			}
-			data->AppendUnified(*append_state, state.group_chunk, state.empty_vector, new_entry_count);
-			RowOperations::InitializeStates(layout, append_state->chunk_state.row_locations,
-			                                *FlatVector::IncrementalSelectionVector(), new_entry_count);
-
-			// Set the entry pointers in the 1st part of the HT now that the data has been appended
-			const auto row_locations = FlatVector::GetData<data_ptr_t>(append_state->chunk_state.row_locations);
-			const auto &row_sel = append_state->reverse_partition_sel;
-			for (idx_t new_entry_idx = 0; new_entry_idx < new_entry_count; new_entry_idx++) {
-				const auto &index = state.empty_vector[new_entry_idx];
-				const auto &row_idx = row_sel[index];
-				const auto &row_location = row_locations[row_idx];
-
-				auto &entry = entries[ht_offsets[index]];
-
-				entry.SetPointer(row_location);
-				addresses[index] = row_location;
-			}
-		}
-
-		if (need_compare_count != 0) {
-			// Get the pointers to the rows that need to be compared
-			for (idx_t need_compare_idx = 0; need_compare_idx < need_compare_count; need_compare_idx++) {
-				const auto &index = state.group_compare_vector[need_compare_idx];
-				const auto &entry = entries[ht_offsets[index]];
-				addresses[index] = entry.GetPointer();
-			}
-
-			// Perform group comparisons
-			row_matcher.Match(state.group_chunk, state.partitioned_append_state.chunk_state.vector_data,
-			                  state.group_compare_vector, need_compare_count, layout, addresses_v,
-			                  &state.no_match_vector, no_match_count);
-		}
-
-		// Linear probing: each of the entries that do not match move to the next entry in the HT
-		for (idx_t i = 0; i < no_match_count; i++) {
-			const auto &index = state.no_match_vector[i];
-			auto &ht_offset = ht_offsets[index];
-			IncrementAndWrap(ht_offset, bitmask);
-		}
-		sel_vector = &state.no_match_vector;
-		remaining_entries = no_match_count;
-	}
-	if (iteration_count == capacity) {
-		throw InternalException("Maximum outer iteration count reached in GroupedAggregateHashTable");
-	}
-
-	count += new_group_count;
-	return new_group_count;
-}
-
-// this is to support distinct aggregations where we need to record whether we
-// have already seen a value for a group
-idx_t GroupedAggregateHashTable::FindOrCreateGroups(DataChunk &groups, Vector &group_hashes, Vector &addresses_out,
-                                                    SelectionVector &new_groups_out) {
-	return FindOrCreateGroupsInternal(groups, group_hashes, addresses_out, new_groups_out);
-}
-
-void GroupedAggregateHashTable::FindOrCreateGroups(DataChunk &groups, Vector &addresses) {
-	// create a dummy new_groups sel vector
-	FindOrCreateGroups(groups, addresses, state.new_groups);
-}
-
-idx_t GroupedAggregateHashTable::FindOrCreateGroups(DataChunk &groups, Vector &addresses_out,
-                                                    SelectionVector &new_groups_out) {
-	Vector hashes(LogicalType::HASH);
-	groups.Hash(hashes);
-	return FindOrCreateGroups(groups, hashes, addresses_out, new_groups_out);
-}
-
-struct FlushMoveState {
-	explicit FlushMoveState(TupleDataCollection &collection_p)
-	    : collection(collection_p), hashes(LogicalType::HASH), group_addresses(LogicalType::POINTER),
-	      new_groups_sel(STANDARD_VECTOR_SIZE) {
-		const auto &layout = collection.GetLayout();
-		vector<column_t> column_ids;
-		column_ids.reserve(layout.ColumnCount() - 1);
-		for (idx_t col_idx = 0; col_idx < layout.ColumnCount() - 1; col_idx++) {
-			column_ids.emplace_back(col_idx);
-		}
-		collection.InitializeScan(scan_state, column_ids, TupleDataPinProperties::DESTROY_AFTER_DONE);
-		collection.InitializeScanChunk(scan_state, groups);
-		hash_col_idx = layout.ColumnCount() - 1;
-	}
-
-	bool Scan() {
-		if (collection.Scan(scan_state, groups)) {
-			collection.Gather(scan_state.chunk_state.row_locations, *FlatVector::IncrementalSelectionVector(),
-			                  groups.size(), hash_col_idx, hashes, *FlatVector::IncrementalSelectionVector(), nullptr);
-			return true;
-		}
-
-		collection.FinalizePinState(scan_state.pin_state);
-		return false;
-	}
-
-	TupleDataCollection &collection;
-	TupleDataScanState scan_state;
-	DataChunk groups;
-
-	idx_t hash_col_idx;
-	Vector hashes;
-
-	Vector group_addresses;
-	SelectionVector new_groups_sel;
-};
-
-void GroupedAggregateHashTable::Combine(GroupedAggregateHashTable &other) {
-	auto other_partitioned_data = other.AcquirePartitionedData();
-	auto other_data = other_partitioned_data->GetUnpartitioned();
-	Combine(*other_data);
-
-	// Inherit ownership to all stored aggregate allocators
-	stored_allocators.emplace_back(other.aggregate_allocator);
-	for (const auto &stored_allocator : other.stored_allocators) {
-		stored_allocators.emplace_back(stored_allocator);
-	}
-}
-
-void GroupedAggregateHashTable::Combine(TupleDataCollection &other_data, optional_ptr<atomic<double>> progress) {
-	D_ASSERT(other_data.GetLayout().GetAggrWidth() == layout.GetAggrWidth());
-	D_ASSERT(other_data.GetLayout().GetDataWidth() == layout.GetDataWidth());
-	D_ASSERT(other_data.GetLayout().GetRowWidth() == layout.GetRowWidth());
-
-	if (other_data.Count() == 0) {
-		return;
-	}
-
-	FlushMoveState fm_state(other_data);
-	RowOperationsState row_state(*aggregate_allocator);
-
-	idx_t chunk_idx = 0;
-	const auto chunk_count = other_data.ChunkCount();
-	while (fm_state.Scan()) {
-		const auto input_chunk_size = fm_state.groups.size();
-		FindOrCreateGroups(fm_state.groups, fm_state.hashes, fm_state.group_addresses, fm_state.new_groups_sel);
-		RowOperations::CombineStates(row_state, layout, fm_state.scan_state.chunk_state.row_locations,
-		                             fm_state.group_addresses, input_chunk_size);
-		if (layout.HasDestructor()) {
-			RowOperations::DestroyStates(row_state, layout, fm_state.scan_state.chunk_state.row_locations,
-			                             input_chunk_size);
-		}
-
-		if (progress) {
-			*progress = static_cast<double>(++chunk_idx) / static_cast<double>(chunk_count);
-		}
-	}
-
-	Verify();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/base_aggregate_hashtable.cpp b/src/duckdb/src/execution/base_aggregate_hashtable.cpp
deleted file mode 100644
index eec99f9e3..000000000
--- a/src/duckdb/src/execution/base_aggregate_hashtable.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/execution/base_aggregate_hashtable.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-BaseAggregateHashTable::BaseAggregateHashTable(ClientContext &context, Allocator &allocator,
-                                               const vector<AggregateObject> &aggregates,
-                                               vector<LogicalType> payload_types_p)
-    : allocator(allocator), buffer_manager(BufferManager::GetBufferManager(context)),
-      payload_types(std::move(payload_types_p)) {
-	filter_set.Initialize(context, aggregates, payload_types);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/column_binding_resolver.cpp b/src/duckdb/src/execution/column_binding_resolver.cpp
deleted file mode 100644
index 3a931a3f5..000000000
--- a/src/duckdb/src/execution/column_binding_resolver.cpp
+++ /dev/null
@@ -1,202 +0,0 @@
-#include "duckdb/execution/column_binding_resolver.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_create_index.hpp"
-#include "duckdb/planner/operator/logical_extension_operator.hpp"
-#include "duckdb/planner/operator/logical_insert.hpp"
-
-namespace duckdb {
-
-ColumnBindingResolver::ColumnBindingResolver(bool verify_only) : verify_only(verify_only) {
-}
-
-void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		// special case: comparison join
-		auto &comp_join = op.Cast<LogicalComparisonJoin>();
-		// first get the bindings of the LHS and resolve the LHS expressions
-		VisitOperator(*comp_join.children[0]);
-		for (auto &cond : comp_join.conditions) {
-			VisitExpression(&cond.left);
-		}
-		// visit the duplicate eliminated columns on the LHS, if any
-		for (auto &expr : comp_join.duplicate_eliminated_columns) {
-			VisitExpression(&expr);
-		}
-		// then get the bindings of the RHS and resolve the RHS expressions
-		VisitOperator(*comp_join.children[1]);
-		for (auto &cond : comp_join.conditions) {
-			VisitExpression(&cond.right);
-		}
-		// finally update the bindings with the result bindings of the join
-		bindings = op.GetColumnBindings();
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
-		auto &comp_join = op.Cast<LogicalComparisonJoin>();
-		// depending on whether the delim join has been flipped, get the appropriate bindings
-		if (comp_join.delim_flipped) {
-			VisitOperator(*comp_join.children[1]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.right);
-			}
-		} else {
-			VisitOperator(*comp_join.children[0]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.left);
-			}
-		}
-		// visit the duplicate eliminated columns
-		for (auto &expr : comp_join.duplicate_eliminated_columns) {
-			VisitExpression(&expr);
-		}
-		// now get the other side
-		if (comp_join.delim_flipped) {
-			VisitOperator(*comp_join.children[0]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.left);
-			}
-		} else {
-			VisitOperator(*comp_join.children[1]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.right);
-			}
-		}
-		// finally update the bindings with the result bindings of the join
-		bindings = op.GetColumnBindings();
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		// ANY join, this join is different because we evaluate the expression on the bindings of BOTH join sides at
-		// once i.e. we set the bindings first to the bindings of the entire join, and then resolve the expressions of
-		// this operator
-		VisitOperatorChildren(op);
-		bindings = op.GetColumnBindings();
-		auto &any_join = op.Cast<LogicalAnyJoin>();
-		if (any_join.join_type == JoinType::SEMI || any_join.join_type == JoinType::ANTI) {
-			auto right_bindings = op.children[1]->GetColumnBindings();
-			bindings.insert(bindings.end(), right_bindings.begin(), right_bindings.end());
-		}
-		if (any_join.join_type == JoinType::RIGHT_SEMI || any_join.join_type == JoinType::RIGHT_ANTI) {
-			throw InternalException("RIGHT SEMI/ANTI any join not supported yet");
-		}
-		VisitOperatorExpressions(op);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX: {
-		// CREATE INDEX statement, add the columns of the table with table index 0 to the binding set
-		// afterwards bind the expressions of the CREATE INDEX statement
-		auto &create_index = op.Cast<LogicalCreateIndex>();
-		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.GetColumns().LogicalColumnCount());
-		VisitOperatorExpressions(op);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_GET: {
-		//! We first need to update the current set of bindings and then visit operator expressions
-		bindings = op.GetColumnBindings();
-		VisitOperatorExpressions(op);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_INSERT: {
-		//! We want to execute the normal path, but also add a dummy 'excluded' binding if there is a
-		// ON CONFLICT DO UPDATE clause
-		auto &insert_op = op.Cast<LogicalInsert>();
-		if (insert_op.action_type != OnConflictAction::THROW) {
-			// Get the bindings from the children
-			VisitOperatorChildren(op);
-			auto column_count = insert_op.table.GetColumns().PhysicalColumnCount();
-			auto dummy_bindings = LogicalOperator::GenerateColumnBindings(insert_op.excluded_table_index, column_count);
-			// Now insert our dummy bindings at the start of the bindings,
-			// so the first 'column_count' indices of the chunk are reserved for our 'excluded' columns
-			bindings.insert(bindings.begin(), dummy_bindings.begin(), dummy_bindings.end());
-			if (insert_op.on_conflict_condition) {
-				VisitExpression(&insert_op.on_conflict_condition);
-			}
-			if (insert_op.do_update_condition) {
-				VisitExpression(&insert_op.do_update_condition);
-			}
-			VisitOperatorExpressions(op);
-			bindings = op.GetColumnBindings();
-			return;
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR: {
-		auto &ext_op = op.Cast<LogicalExtensionOperator>();
-		ext_op.ResolveColumnBindings(*this, bindings);
-		return;
-	}
-	default:
-		break;
-	}
-
-	// general case
-	// first visit the children of this operator
-	VisitOperatorChildren(op);
-	// now visit the expressions of this operator to resolve any bound column references
-	VisitOperatorExpressions(op);
-	// finally update the current set of bindings to the current set of column bindings
-	bindings = op.GetColumnBindings();
-}
-
-unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpression &expr,
-                                                           unique_ptr<Expression> *expr_ptr) {
-	D_ASSERT(expr.depth == 0);
-	// check the current set of column bindings to see which index corresponds to the column reference
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (expr.binding == bindings[i]) {
-			if (verify_only) {
-				// in verification mode
-				return nullptr;
-			}
-			return make_uniq<BoundReferenceExpression>(expr.GetAlias(), expr.return_type, i);
-		}
-	}
-	// LCOV_EXCL_START
-	// could not bind the column reference, this should never happen and indicates a bug in the code
-	// generate an error message
-	throw InternalException("Failed to bind column reference \"%s\" [%d.%d] (bindings: %s)", expr.GetAlias(),
-	                        expr.binding.table_index, expr.binding.column_index,
-	                        LogicalOperator::ColumnBindingsToString(bindings));
-	// LCOV_EXCL_STOP
-}
-
-unordered_set<idx_t> ColumnBindingResolver::VerifyInternal(LogicalOperator &op) {
-	unordered_set<idx_t> result;
-	for (auto &child : op.children) {
-		auto child_indexes = VerifyInternal(*child);
-		for (auto index : child_indexes) {
-			D_ASSERT(index != DConstants::INVALID_INDEX);
-			if (result.find(index) != result.end()) {
-				throw InternalException("Duplicate table index \"%lld\" found", index);
-			}
-			result.insert(index);
-		}
-	}
-	auto indexes = op.GetTableIndex();
-	for (auto index : indexes) {
-		D_ASSERT(index != DConstants::INVALID_INDEX);
-		if (result.find(index) != result.end()) {
-			throw InternalException("Duplicate table index \"%lld\" found", index);
-		}
-		result.insert(index);
-	}
-	return result;
-}
-
-void ColumnBindingResolver::Verify(LogicalOperator &op) {
-#ifdef DEBUG
-	ColumnBindingResolver resolver(true);
-	resolver.VisitOperator(op);
-	VerifyInternal(op);
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor.cpp b/src/duckdb/src/execution/expression_executor.cpp
deleted file mode 100644
index 567deb326..000000000
--- a/src/duckdb/src/execution/expression_executor.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/planner/expression/list.hpp"
-
-namespace duckdb {
-
-ExpressionExecutor::ExpressionExecutor(ClientContext &context) : context(&context) {
-}
-
-ExpressionExecutor::ExpressionExecutor(ClientContext &context, const Expression *expression)
-    : ExpressionExecutor(context) {
-	D_ASSERT(expression);
-	AddExpression(*expression);
-}
-
-ExpressionExecutor::ExpressionExecutor(ClientContext &context, const Expression &expression)
-    : ExpressionExecutor(context) {
-	AddExpression(expression);
-}
-
-ExpressionExecutor::ExpressionExecutor(ClientContext &context, const vector<unique_ptr<Expression>> &exprs)
-    : ExpressionExecutor(context) {
-	D_ASSERT(exprs.size() > 0);
-	for (auto &expr : exprs) {
-		AddExpression(*expr);
-	}
-}
-
-ExpressionExecutor::ExpressionExecutor(const vector<unique_ptr<Expression>> &exprs) : context(nullptr) {
-	D_ASSERT(exprs.size() > 0);
-	for (auto &expr : exprs) {
-		AddExpression(*expr);
-	}
-}
-
-ExpressionExecutor::ExpressionExecutor() : context(nullptr) {
-}
-
-bool ExpressionExecutor::HasContext() {
-	return context;
-}
-
-ClientContext &ExpressionExecutor::GetContext() {
-	if (!context) {
-		throw InternalException("Calling ExpressionExecutor::GetContext on an expression executor without a context");
-	}
-	return *context;
-}
-
-Allocator &ExpressionExecutor::GetAllocator() {
-	return context ? Allocator::Get(*context) : Allocator::DefaultAllocator();
-}
-
-void ExpressionExecutor::AddExpression(const Expression &expr) {
-	expressions.push_back(&expr);
-	auto state = make_uniq<ExpressionExecutorState>();
-	Initialize(expr, *state);
-	state->Verify();
-	states.push_back(std::move(state));
-}
-
-void ExpressionExecutor::Initialize(const Expression &expression, ExpressionExecutorState &state) {
-	state.executor = this;
-	state.root_state = InitializeState(expression, state);
-}
-
-void ExpressionExecutor::Execute(DataChunk *input, DataChunk &result) {
-	SetChunk(input);
-	D_ASSERT(expressions.size() == result.ColumnCount());
-	D_ASSERT(!expressions.empty());
-
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		ExecuteExpression(i, result.data[i]);
-	}
-	result.SetCardinality(input ? input->size() : 1);
-	result.Verify();
-}
-
-void ExpressionExecutor::ExecuteExpression(DataChunk &input, Vector &result) {
-	SetChunk(&input);
-	ExecuteExpression(result);
-}
-
-idx_t ExpressionExecutor::SelectExpression(DataChunk &input, SelectionVector &sel) {
-	D_ASSERT(expressions.size() == 1);
-	SetChunk(&input);
-	idx_t selected_tuples = Select(*expressions[0], states[0]->root_state.get(), nullptr, input.size(), &sel, nullptr);
-	return selected_tuples;
-}
-
-void ExpressionExecutor::ExecuteExpression(Vector &result) {
-	D_ASSERT(expressions.size() == 1);
-	ExecuteExpression(0, result);
-}
-
-void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) {
-	D_ASSERT(expr_idx < expressions.size());
-	D_ASSERT(result.GetType().id() == expressions[expr_idx]->return_type.id());
-	Execute(*expressions[expr_idx], states[expr_idx]->root_state.get(), nullptr, chunk ? chunk->size() : 1, result);
-}
-
-Value ExpressionExecutor::EvaluateScalar(ClientContext &context, const Expression &expr, bool allow_unfoldable) {
-	D_ASSERT(allow_unfoldable || expr.IsFoldable());
-	D_ASSERT(expr.IsScalar());
-	// use an ExpressionExecutor to execute the expression
-	ExpressionExecutor executor(context, expr);
-
-	Vector result(expr.return_type);
-	executor.ExecuteExpression(result);
-
-	D_ASSERT(allow_unfoldable || result.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	auto result_value = result.GetValue(0);
-	D_ASSERT(result_value.type().InternalType() == expr.return_type.InternalType());
-	return result_value;
-}
-
-bool ExpressionExecutor::TryEvaluateScalar(ClientContext &context, const Expression &expr, Value &result) {
-	try {
-		result = EvaluateScalar(context, expr);
-		return true;
-	} catch (InternalException &ex) {
-		throw;
-	} catch (...) {
-		return false;
-	}
-}
-
-void ExpressionExecutor::Verify(const Expression &expr, Vector &vector, idx_t count) {
-	D_ASSERT(expr.return_type.id() == vector.GetType().id());
-	vector.Verify(count);
-	if (expr.verification_stats) {
-		expr.verification_stats->Verify(vector, count);
-	}
-#ifdef DUCKDB_VERIFY_DICTIONARY_EXPRESSION
-	Vector::DebugTransformToDictionary(vector, count);
-#endif
-}
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const Expression &expr,
-                                                                ExpressionExecutorState &state) {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_REF:
-		return InitializeState(expr.Cast<BoundReferenceExpression>(), state);
-	case ExpressionClass::BOUND_BETWEEN:
-		return InitializeState(expr.Cast<BoundBetweenExpression>(), state);
-	case ExpressionClass::BOUND_CASE:
-		return InitializeState(expr.Cast<BoundCaseExpression>(), state);
-	case ExpressionClass::BOUND_CAST:
-		return InitializeState(expr.Cast<BoundCastExpression>(), state);
-	case ExpressionClass::BOUND_COMPARISON:
-		return InitializeState(expr.Cast<BoundComparisonExpression>(), state);
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return InitializeState(expr.Cast<BoundConjunctionExpression>(), state);
-	case ExpressionClass::BOUND_CONSTANT:
-		return InitializeState(expr.Cast<BoundConstantExpression>(), state);
-	case ExpressionClass::BOUND_FUNCTION:
-		return InitializeState(expr.Cast<BoundFunctionExpression>(), state);
-	case ExpressionClass::BOUND_OPERATOR:
-		return InitializeState(expr.Cast<BoundOperatorExpression>(), state);
-	case ExpressionClass::BOUND_PARAMETER:
-		return InitializeState(expr.Cast<BoundParameterExpression>(), state);
-	default:
-		throw InternalException("Attempting to initialize state of expression of unknown type!");
-	}
-}
-
-void ExpressionExecutor::Execute(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-#ifdef DEBUG
-	// The result vector must be used for the first time, or must be reset.
-	// Otherwise, the validity mask can contain previous (now incorrect) data.
-	if (result.GetVectorType() == VectorType::FLAT_VECTOR) {
-
-		// We do not initialize vector caches for these expressions.
-		if (expr.GetExpressionClass() != ExpressionClass::BOUND_REF &&
-		    expr.GetExpressionClass() != ExpressionClass::BOUND_CONSTANT &&
-		    expr.GetExpressionClass() != ExpressionClass::BOUND_PARAMETER) {
-			D_ASSERT(FlatVector::Validity(result).CheckAllValid(count));
-		}
-	}
-#endif
-
-	if (count == 0) {
-		return;
-	}
-	if (result.GetType().id() != expr.return_type.id()) {
-		throw InternalException(
-		    "ExpressionExecutor::Execute called with a result vector of type %s that does not match expression type %s",
-		    result.GetType(), expr.return_type);
-	}
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_BETWEEN:
-		Execute(expr.Cast<BoundBetweenExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_REF:
-		Execute(expr.Cast<BoundReferenceExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CASE:
-		Execute(expr.Cast<BoundCaseExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CAST:
-		Execute(expr.Cast<BoundCastExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_COMPARISON:
-		Execute(expr.Cast<BoundComparisonExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CONJUNCTION:
-		Execute(expr.Cast<BoundConjunctionExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CONSTANT:
-		Execute(expr.Cast<BoundConstantExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_FUNCTION:
-		Execute(expr.Cast<BoundFunctionExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_OPERATOR:
-		Execute(expr.Cast<BoundOperatorExpression>(), state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_PARAMETER:
-		Execute(expr.Cast<BoundParameterExpression>(), state, sel, count, result);
-		break;
-	default:
-		throw InternalException("Attempting to execute expression of unknown type!");
-	}
-	Verify(expr, result, count);
-}
-
-idx_t ExpressionExecutor::Select(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (count == 0) {
-		return 0;
-	}
-	D_ASSERT(true_sel || false_sel);
-	D_ASSERT(expr.return_type.id() == LogicalTypeId::BOOLEAN);
-	switch (expr.GetExpressionClass()) {
-#ifndef DUCKDB_SMALLER_BINARY
-	case ExpressionClass::BOUND_BETWEEN:
-		return Select(expr.Cast<BoundBetweenExpression>(), state, sel, count, true_sel, false_sel);
-#endif
-	case ExpressionClass::BOUND_COMPARISON:
-		return Select(expr.Cast<BoundComparisonExpression>(), state, sel, count, true_sel, false_sel);
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return Select(expr.Cast<BoundConjunctionExpression>(), state, sel, count, true_sel, false_sel);
-	default:
-		return DefaultSelect(expr, state, sel, count, true_sel, false_sel);
-	}
-}
-
-template <bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-static inline idx_t DefaultSelectLoop(const SelectionVector *bsel, const uint8_t *__restrict bdata, ValidityMask &mask,
-                                      const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-                                      SelectionVector *false_sel) {
-	idx_t true_count = 0, false_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto bidx = bsel->get_index(i);
-		auto result_idx = sel->get_index(i);
-		if ((NO_NULL || mask.RowIsValid(bidx)) && bdata[bidx] > 0) {
-			if (HAS_TRUE_SEL) {
-				true_sel->set_index(true_count++, result_idx);
-			}
-		} else {
-			if (HAS_FALSE_SEL) {
-				false_sel->set_index(false_count++, result_idx);
-			}
-		}
-	}
-	if (HAS_TRUE_SEL) {
-		return true_count;
-	} else {
-		return count - false_count;
-	}
-}
-
-template <bool NO_NULL>
-static inline idx_t DefaultSelectSwitch(UnifiedVectorFormat &idata, const SelectionVector *sel, idx_t count,
-                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (true_sel && false_sel) {
-		return DefaultSelectLoop<NO_NULL, true, true>(idata.sel, UnifiedVectorFormat::GetData<uint8_t>(idata),
-		                                              idata.validity, sel, count, true_sel, false_sel);
-	} else if (true_sel) {
-		return DefaultSelectLoop<NO_NULL, true, false>(idata.sel, UnifiedVectorFormat::GetData<uint8_t>(idata),
-		                                               idata.validity, sel, count, true_sel, false_sel);
-	} else {
-		D_ASSERT(false_sel);
-		return DefaultSelectLoop<NO_NULL, false, true>(idata.sel, UnifiedVectorFormat::GetData<uint8_t>(idata),
-		                                               idata.validity, sel, count, true_sel, false_sel);
-	}
-}
-
-idx_t ExpressionExecutor::DefaultSelect(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
-                                        idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	// generic selection of boolean expression:
-	// resolve the true/false expression first
-	// then use that to generate the selection vector
-	bool intermediate_bools[STANDARD_VECTOR_SIZE];
-	Vector intermediate(LogicalType::BOOLEAN, data_ptr_cast(intermediate_bools));
-	Execute(expr, state, sel, count, intermediate);
-
-	UnifiedVectorFormat idata;
-	intermediate.ToUnifiedFormat(count, idata);
-
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-	if (!idata.validity.AllValid()) {
-		return DefaultSelectSwitch<false>(idata, sel, count, true_sel, false_sel);
-	} else {
-		return DefaultSelectSwitch<true>(idata, sel, count, true_sel, false_sel);
-	}
-}
-
-vector<unique_ptr<ExpressionExecutorState>> &ExpressionExecutor::GetStates() {
-	return states;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_between.cpp b/src/duckdb/src/execution/expression_executor/execute_between.cpp
deleted file mode 100644
index 341835136..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_between.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-
-namespace duckdb {
-
-#ifndef DUCKDB_SMALLER_BINARY
-struct BothInclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThanEquals::Operation<T>(input, lower) && LessThanEquals::Operation<T>(input, upper);
-	}
-};
-
-struct LowerInclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThanEquals::Operation<T>(input, lower) && LessThan::Operation<T>(input, upper);
-	}
-};
-
-struct UpperInclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThan::Operation<T>(input, lower) && LessThanEquals::Operation<T>(input, upper);
-	}
-};
-
-struct ExclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThan::Operation<T>(input, lower) && LessThan::Operation<T>(input, upper);
-	}
-};
-
-template <class OP>
-static idx_t BetweenLoopTypeSwitch(Vector &input, Vector &lower, Vector &upper, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TernaryExecutor::Select<int8_t, int8_t, int8_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                           false_sel);
-	case PhysicalType::INT16:
-		return TernaryExecutor::Select<int16_t, int16_t, int16_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::INT32:
-		return TernaryExecutor::Select<int32_t, int32_t, int32_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::INT64:
-		return TernaryExecutor::Select<int64_t, int64_t, int64_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::INT128:
-		return TernaryExecutor::Select<hugeint_t, hugeint_t, hugeint_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                    false_sel);
-	case PhysicalType::UINT8:
-		return TernaryExecutor::Select<uint8_t, uint8_t, uint8_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::UINT16:
-		return TernaryExecutor::Select<uint16_t, uint16_t, uint16_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::UINT32:
-		return TernaryExecutor::Select<uint32_t, uint32_t, uint32_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::UINT64:
-		return TernaryExecutor::Select<uint64_t, uint64_t, uint64_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::UINT128:
-		return TernaryExecutor::Select<uhugeint_t, uhugeint_t, uhugeint_t, OP>(input, lower, upper, sel, count,
-		                                                                       true_sel, false_sel);
-	case PhysicalType::FLOAT:
-		return TernaryExecutor::Select<float, float, float, OP>(input, lower, upper, sel, count, true_sel, false_sel);
-	case PhysicalType::DOUBLE:
-		return TernaryExecutor::Select<double, double, double, OP>(input, lower, upper, sel, count, true_sel,
-		                                                           false_sel);
-	case PhysicalType::VARCHAR:
-		return TernaryExecutor::Select<string_t, string_t, string_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::INTERVAL:
-		return TernaryExecutor::Select<interval_t, interval_t, interval_t, OP>(input, lower, upper, sel, count,
-		                                                                       true_sel, false_sel);
-	default:
-		throw InvalidTypeException(input.GetType(), "Invalid type for BETWEEN");
-	}
-}
-#endif
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundBetweenExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExpressionState>(expr, root);
-	result->AddChild(*expr.input);
-	result->AddChild(*expr.lower);
-	result->AddChild(*expr.upper);
-
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-	// resolve the children
-	state->intermediate_chunk.Reset();
-
-	auto &input = state->intermediate_chunk.data[0];
-	auto &lower = state->intermediate_chunk.data[1];
-	auto &upper = state->intermediate_chunk.data[2];
-
-	Execute(*expr.input, state->child_states[0].get(), sel, count, input);
-	Execute(*expr.lower, state->child_states[1].get(), sel, count, lower);
-	Execute(*expr.upper, state->child_states[2].get(), sel, count, upper);
-
-	Vector intermediate1(LogicalType::BOOLEAN);
-	Vector intermediate2(LogicalType::BOOLEAN);
-
-	if (expr.upper_inclusive && expr.lower_inclusive) {
-		VectorOperations::GreaterThanEquals(input, lower, intermediate1, count);
-		VectorOperations::LessThanEquals(input, upper, intermediate2, count);
-	} else if (expr.lower_inclusive) {
-		VectorOperations::GreaterThanEquals(input, lower, intermediate1, count);
-		VectorOperations::LessThan(input, upper, intermediate2, count);
-	} else if (expr.upper_inclusive) {
-		VectorOperations::GreaterThan(input, lower, intermediate1, count);
-		VectorOperations::LessThanEquals(input, upper, intermediate2, count);
-	} else {
-		VectorOperations::GreaterThan(input, lower, intermediate1, count);
-		VectorOperations::LessThan(input, upper, intermediate2, count);
-	}
-	VectorOperations::And(intermediate1, intermediate2, result, count);
-}
-
-idx_t ExpressionExecutor::Select(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-#ifdef DUCKDB_SMALLER_BINARY
-	throw InternalException("ExpressionExecutor::Select not available with DUCKDB_SMALLER_BINARY");
-#else
-	// resolve the children
-	Vector input(state->intermediate_chunk.data[0]);
-	Vector lower(state->intermediate_chunk.data[1]);
-	Vector upper(state->intermediate_chunk.data[2]);
-
-	Execute(*expr.input, state->child_states[0].get(), sel, count, input);
-	Execute(*expr.lower, state->child_states[1].get(), sel, count, lower);
-	Execute(*expr.upper, state->child_states[2].get(), sel, count, upper);
-
-	if (expr.upper_inclusive && expr.lower_inclusive) {
-		return BetweenLoopTypeSwitch<BothInclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel,
-		                                                           false_sel);
-	} else if (expr.lower_inclusive) {
-		return BetweenLoopTypeSwitch<LowerInclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel,
-		                                                            false_sel);
-	} else if (expr.upper_inclusive) {
-		return BetweenLoopTypeSwitch<UpperInclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel,
-		                                                            false_sel);
-	} else {
-		return BetweenLoopTypeSwitch<ExclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel, false_sel);
-	}
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_case.cpp b/src/duckdb/src/execution/expression_executor/execute_case.cpp
deleted file mode 100644
index cdeae3116..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_case.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-
-namespace duckdb {
-
-struct CaseExpressionState : public ExpressionState {
-	CaseExpressionState(const Expression &expr, ExpressionExecutorState &root)
-	    : ExpressionState(expr, root), true_sel(STANDARD_VECTOR_SIZE), false_sel(STANDARD_VECTOR_SIZE) {
-	}
-
-	SelectionVector true_sel;
-	SelectionVector false_sel;
-};
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCaseExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<CaseExpressionState>(expr, root);
-	for (auto &case_check : expr.case_checks) {
-		result->AddChild(*case_check.when_expr);
-		result->AddChild(*case_check.then_expr);
-	}
-	result->AddChild(*expr.else_expr);
-
-	result->Finalize();
-	return std::move(result);
-}
-
-void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionState *state_p, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-	auto &state = state_p->Cast<CaseExpressionState>();
-
-	state.intermediate_chunk.Reset();
-
-	// first execute the check expression
-	auto current_true_sel = &state.true_sel;
-	auto current_false_sel = &state.false_sel;
-	auto current_sel = sel;
-	idx_t current_count = count;
-	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
-		auto &case_check = expr.case_checks[i];
-		auto &intermediate_result = state.intermediate_chunk.data[i * 2 + 1];
-		auto check_state = state.child_states[i * 2].get();
-		auto then_state = state.child_states[i * 2 + 1].get();
-
-		idx_t tcount =
-		    Select(*case_check.when_expr, check_state, current_sel, current_count, current_true_sel, current_false_sel);
-		if (tcount == 0) {
-			// everything is false: do nothing
-			continue;
-		}
-		idx_t fcount = current_count - tcount;
-		if (fcount == 0 && current_count == count) {
-			// everything is true in the first CHECK statement
-			// we can skip the entire case and only execute the TRUE side
-			Execute(*case_check.then_expr, then_state, sel, count, result);
-			return;
-		} else {
-			// we need to execute and then fill in the desired tuples in the result
-			Execute(*case_check.then_expr, then_state, current_true_sel, tcount, intermediate_result);
-			FillSwitch(intermediate_result, result, *current_true_sel, NumericCast<sel_t>(tcount));
-		}
-		// continue with the false tuples
-		current_sel = current_false_sel;
-		current_count = fcount;
-		if (fcount == 0) {
-			// everything is true: we are done
-			break;
-		}
-	}
-	if (current_count > 0) {
-		auto else_state = state.child_states.back().get();
-		if (current_count == count) {
-			// everything was false, we can just evaluate the else expression directly
-			Execute(*expr.else_expr, else_state, sel, count, result);
-			return;
-		} else {
-			auto &intermediate_result = state.intermediate_chunk.data[expr.case_checks.size() * 2];
-
-			D_ASSERT(current_sel);
-			Execute(*expr.else_expr, else_state, current_sel, current_count, intermediate_result);
-			FillSwitch(intermediate_result, result, *current_sel, NumericCast<sel_t>(current_count));
-		}
-	}
-	if (sel) {
-		result.Slice(*sel, count);
-	}
-}
-
-template <class T>
-void TemplatedFillLoop(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto res = FlatVector::GetData<T>(result);
-	auto &result_mask = FlatVector::Validity(result);
-	if (vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto data = ConstantVector::GetData<T>(vector);
-		if (ConstantVector::IsNull(vector)) {
-			for (idx_t i = 0; i < count; i++) {
-				result_mask.SetInvalid(sel.get_index(i));
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				res[sel.get_index(i)] = *data;
-			}
-		}
-	} else {
-		UnifiedVectorFormat vdata;
-		vector.ToUnifiedFormat(count, vdata);
-		auto data = UnifiedVectorFormat::GetData<T>(vdata);
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = vdata.sel->get_index(i);
-			auto res_idx = sel.get_index(i);
-
-			res[res_idx] = data[source_idx];
-			result_mask.Set(res_idx, vdata.validity.RowIsValid(source_idx));
-		}
-	}
-}
-
-void ValidityFillLoop(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto &result_mask = FlatVector::Validity(result);
-	if (vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (ConstantVector::IsNull(vector)) {
-			for (idx_t i = 0; i < count; i++) {
-				result_mask.SetInvalid(sel.get_index(i));
-			}
-		}
-	} else {
-		UnifiedVectorFormat vdata;
-		vector.ToUnifiedFormat(count, vdata);
-		if (vdata.validity.AllValid()) {
-			return;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(source_idx)) {
-				result_mask.SetInvalid(sel.get_index(i));
-			}
-		}
-	}
-}
-
-void ExpressionExecutor::FillSwitch(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count) {
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedFillLoop<int8_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedFillLoop<int16_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedFillLoop<int32_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedFillLoop<int64_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedFillLoop<uint8_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedFillLoop<uint16_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedFillLoop<uint32_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedFillLoop<uint64_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedFillLoop<hugeint_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedFillLoop<uhugeint_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedFillLoop<float>(vector, result, sel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedFillLoop<double>(vector, result, sel, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedFillLoop<interval_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedFillLoop<string_t>(vector, result, sel, count);
-		StringVector::AddHeapReference(result, vector);
-		break;
-	case PhysicalType::STRUCT: {
-		auto &vector_entries = StructVector::GetEntries(vector);
-		auto &result_entries = StructVector::GetEntries(result);
-		ValidityFillLoop(vector, result, sel, count);
-		D_ASSERT(vector_entries.size() == result_entries.size());
-		for (idx_t i = 0; i < vector_entries.size(); i++) {
-			FillSwitch(*vector_entries[i], *result_entries[i], sel, count);
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		idx_t offset = ListVector::GetListSize(result);
-		auto &list_child = ListVector::GetEntry(vector);
-		ListVector::Append(result, list_child, ListVector::GetListSize(vector));
-
-		// all the false offsets need to be incremented by true_child.count
-		TemplatedFillLoop<list_entry_t>(vector, result, sel, count);
-		if (offset == 0) {
-			break;
-		}
-
-		auto result_data = FlatVector::GetData<list_entry_t>(result);
-		for (idx_t i = 0; i < count; i++) {
-			auto result_idx = sel.get_index(i);
-			result_data[result_idx].offset += offset;
-		}
-
-		Vector::Verify(result, sel, count);
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type for case expression: %s", result.GetType().ToString());
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_cast.cpp b/src/duckdb/src/execution/expression_executor/execute_cast.cpp
deleted file mode 100644
index 0627dcf51..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_cast.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExecuteFunctionState>(expr, root);
-	result->AddChild(*expr.child);
-	result->Finalize();
-
-	if (expr.bound_cast.init_local_state) {
-		auto context_ptr = root.executor->HasContext() ? &root.executor->GetContext() : nullptr;
-		CastLocalStateParameters parameters(context_ptr, expr.bound_cast.cast_data);
-		result->local_state = expr.bound_cast.init_local_state(parameters);
-	}
-	return std::move(result);
-}
-
-void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-	auto lstate = ExecuteFunctionState::GetFunctionState(*state);
-
-	// resolve the child
-	state->intermediate_chunk.Reset();
-
-	auto &child = state->intermediate_chunk.data[0];
-	auto child_state = state->child_states[0].get();
-
-	Execute(*expr.child, child_state, sel, count, child);
-	if (expr.try_cast) {
-		string error_message;
-		CastParameters parameters(expr.bound_cast.cast_data.get(), false, &error_message, lstate);
-		parameters.query_location = expr.GetQueryLocation();
-		expr.bound_cast.function(child, result, count, parameters);
-	} else {
-		// cast it to the type specified by the cast expression
-		D_ASSERT(result.GetType() == expr.return_type);
-		CastParameters parameters(expr.bound_cast.cast_data.get(), false, nullptr, lstate);
-		parameters.query_location = expr.GetQueryLocation();
-		expr.bound_cast.function(child, result, count, parameters);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_comparison.cpp b/src/duckdb/src/execution/expression_executor/execute_comparison.cpp
deleted file mode 100644
index 6e78de49c..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_comparison.cpp
+++ /dev/null
@@ -1,382 +0,0 @@
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundComparisonExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExpressionState>(expr, root);
-	result->AddChild(*expr.left);
-	result->AddChild(*expr.right);
-
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundComparisonExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	// resolve the children
-	state->intermediate_chunk.Reset();
-	auto &left = state->intermediate_chunk.data[0];
-	auto &right = state->intermediate_chunk.data[1];
-
-	Execute(*expr.left, state->child_states[0].get(), sel, count, left);
-	Execute(*expr.right, state->child_states[1].get(), sel, count, right);
-
-	switch (expr.GetExpressionType()) {
-	case ExpressionType::COMPARE_EQUAL:
-		VectorOperations::Equals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		VectorOperations::NotEquals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		VectorOperations::LessThan(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		VectorOperations::GreaterThan(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		VectorOperations::LessThanEquals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		VectorOperations::GreaterThanEquals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		VectorOperations::DistinctFrom(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		VectorOperations::NotDistinctFrom(left, right, result, count);
-		break;
-	default:
-		throw InternalException("Unknown comparison type!");
-	}
-}
-
-static void UpdateNullMask(Vector &vec, optional_ptr<const SelectionVector> sel, idx_t count, ValidityMask &null_mask) {
-	UnifiedVectorFormat vdata;
-	vec.ToUnifiedFormat(count, vdata);
-
-	if (vdata.validity.AllValid()) {
-		return;
-	}
-
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-
-	for (idx_t i = 0; i < count; ++i) {
-		const auto ridx = sel->get_index(i);
-		const auto vidx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(vidx)) {
-			null_mask.SetInvalid(ridx);
-		}
-	}
-}
-
-template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                   optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                   optional_ptr<ValidityMask> null_mask);
-
-template <class OP>
-static idx_t TemplatedSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                      optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                      optional_ptr<ValidityMask> null_mask) {
-	if (null_mask) {
-		UpdateNullMask(left, sel, count, *null_mask);
-		UpdateNullMask(right, sel, count, *null_mask);
-	}
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return BinaryExecutor::Select<int8_t, int8_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                  false_sel.get());
-	case PhysicalType::INT16:
-		return BinaryExecutor::Select<int16_t, int16_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                    false_sel.get());
-	case PhysicalType::INT32:
-		return BinaryExecutor::Select<int32_t, int32_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                    false_sel.get());
-	case PhysicalType::INT64:
-		return BinaryExecutor::Select<int64_t, int64_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                    false_sel.get());
-	case PhysicalType::UINT8:
-		return BinaryExecutor::Select<uint8_t, uint8_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                    false_sel.get());
-	case PhysicalType::UINT16:
-		return BinaryExecutor::Select<uint16_t, uint16_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                      false_sel.get());
-	case PhysicalType::UINT32:
-		return BinaryExecutor::Select<uint32_t, uint32_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                      false_sel.get());
-	case PhysicalType::UINT64:
-		return BinaryExecutor::Select<uint64_t, uint64_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                      false_sel.get());
-	case PhysicalType::INT128:
-		return BinaryExecutor::Select<hugeint_t, hugeint_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                        false_sel.get());
-	case PhysicalType::UINT128:
-		return BinaryExecutor::Select<uhugeint_t, uhugeint_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                          false_sel.get());
-	case PhysicalType::FLOAT:
-		return BinaryExecutor::Select<float, float, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get());
-	case PhysicalType::DOUBLE:
-		return BinaryExecutor::Select<double, double, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                  false_sel.get());
-	case PhysicalType::INTERVAL:
-		return BinaryExecutor::Select<interval_t, interval_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                          false_sel.get());
-	case PhysicalType::VARCHAR:
-		return BinaryExecutor::Select<string_t, string_t, OP>(left, right, sel.get(), count, true_sel.get(),
-		                                                      false_sel.get());
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT:
-	case PhysicalType::ARRAY:
-		return NestedSelectOperation<OP>(left, right, sel, count, true_sel, false_sel, null_mask);
-	default:
-		throw InternalException("Invalid type for comparison");
-	}
-}
-
-struct NestedSelector {
-	// Select the matching rows for the values of a nested type that are not both NULL.
-	// Those semantics are the same as the corresponding non-distinct comparator
-	template <typename OP>
-	static idx_t Select(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                    optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                    optional_ptr<ValidityMask> null_mask) {
-		throw InvalidTypeException(left.GetType(), "Invalid operation for nested SELECT");
-	}
-};
-
-template <>
-idx_t NestedSelector::Select<duckdb::Equals>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                             idx_t count, optional_ptr<SelectionVector> true_sel,
-                                             optional_ptr<SelectionVector> false_sel,
-                                             optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                                idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                optional_ptr<SelectionVector> false_sel,
-                                                optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                               idx_t count, optional_ptr<SelectionVector> true_sel,
-                                               optional_ptr<SelectionVector> false_sel,
-                                               optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctLessThan(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right,
-                                                     optional_ptr<const SelectionVector> sel, idx_t count,
-                                                     optional_ptr<SelectionVector> true_sel,
-                                                     optional_ptr<SelectionVector> false_sel,
-                                                     optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctLessThanEquals(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                                  idx_t count, optional_ptr<SelectionVector> true_sel,
-                                                  optional_ptr<SelectionVector> false_sel,
-                                                  optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThan(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right,
-                                                        optional_ptr<const SelectionVector> sel, idx_t count,
-                                                        optional_ptr<SelectionVector> true_sel,
-                                                        optional_ptr<SelectionVector> false_sel,
-                                                        optional_ptr<ValidityMask> null_mask) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count, const SelectionVector &sel,
-                                  SelectionVector &maybe_vec, OptionalSelection &false_opt,
-                                  optional_ptr<ValidityMask> null_mask) {
-
-	UnifiedVectorFormat lvdata, rvdata;
-	left.ToUnifiedFormat(count, lvdata);
-	right.ToUnifiedFormat(count, rvdata);
-
-	auto &lmask = lvdata.validity;
-	auto &rmask = rvdata.validity;
-
-	// For top-level comparisons, NULL semantics are in effect,
-	// so filter out any NULLs
-	idx_t remaining = 0;
-	if (lmask.AllValid() && rmask.AllValid()) {
-		//	None are NULL, distinguish values.
-		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = sel.get_index(i);
-			maybe_vec.set_index(remaining++, idx);
-		}
-		return remaining;
-	}
-
-	// Slice the Vectors down to the rows that are not determined (i.e., neither is NULL)
-	SelectionVector slicer(count);
-	idx_t false_count = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const auto result_idx = sel.get_index(i);
-		const auto lidx = lvdata.sel->get_index(i);
-		const auto ridx = rvdata.sel->get_index(i);
-		if (!lmask.RowIsValid(lidx) || !rmask.RowIsValid(ridx)) {
-			if (null_mask) {
-				null_mask->SetInvalid(result_idx);
-			}
-			false_opt.Append(false_count, result_idx);
-		} else {
-			//	Neither is NULL, distinguish values.
-			slicer.set_index(remaining, i);
-			maybe_vec.set_index(remaining++, result_idx);
-		}
-	}
-	false_opt.Advance(false_count);
-
-	if (remaining && remaining < count) {
-		left.Slice(slicer, remaining);
-		right.Slice(slicer, remaining);
-	}
-
-	return remaining;
-}
-
-static void ScatterSelection(optional_ptr<SelectionVector> target, const idx_t count,
-                             const SelectionVector &dense_vec) {
-	if (target) {
-		for (idx_t i = 0; i < count; ++i) {
-			target->set_index(i, dense_vec.get_index(i));
-		}
-	}
-}
-
-template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                   optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                   optional_ptr<ValidityMask> null_mask) {
-	// The Select operations all use a dense pair of input vectors to partition
-	// a selection vector in a single pass. But to implement progressive comparisons,
-	// we have to make multiple passes, so we need to keep track of the original input positions
-	// and then scatter the output selections when we are done.
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-
-	// Make buffered selections for progressive comparisons
-	// TODO: Remove unnecessary allocations
-	SelectionVector true_vec(count);
-	OptionalSelection true_opt(&true_vec);
-
-	SelectionVector false_vec(count);
-	OptionalSelection false_opt(&false_vec);
-
-	SelectionVector maybe_vec(count);
-
-	// Handle NULL nested values
-	Vector l_not_null(left);
-	Vector r_not_null(right);
-
-	auto match_count = SelectNotNull(l_not_null, r_not_null, count, *sel, maybe_vec, false_opt, null_mask);
-	auto no_match_count = count - match_count;
-	count = match_count;
-
-	//	Now that we have handled the NULLs, we can use the recursive nested comparator for the rest.
-	match_count =
-	    NestedSelector::Select<OP>(l_not_null, r_not_null, &maybe_vec, count, optional_ptr<SelectionVector>(true_opt),
-	                               optional_ptr<SelectionVector>(false_opt), null_mask);
-	no_match_count += (count - match_count);
-
-	// Copy the buffered selections to the output selections
-	ScatterSelection(true_sel, match_count, true_vec);
-	ScatterSelection(false_sel, no_match_count, false_vec);
-
-	return match_count;
-}
-
-idx_t VectorOperations::Equals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                               optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                               optional_ptr<ValidityMask> null_mask) {
-	return TemplatedSelectOperation<duckdb::Equals>(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-idx_t VectorOperations::NotEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                  optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                  optional_ptr<ValidityMask> null_mask) {
-	return TemplatedSelectOperation<duckdb::NotEquals>(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-idx_t VectorOperations::GreaterThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                    optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                    optional_ptr<ValidityMask> null_mask) {
-	return TemplatedSelectOperation<duckdb::GreaterThan>(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-idx_t VectorOperations::GreaterThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                          idx_t count, optional_ptr<SelectionVector> true_sel,
-                                          optional_ptr<SelectionVector> false_sel,
-                                          optional_ptr<ValidityMask> null_mask) {
-	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(left, right, sel, count, true_sel, false_sel, null_mask);
-}
-
-idx_t VectorOperations::LessThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-                                 optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-                                 optional_ptr<ValidityMask> null_mask) {
-	return TemplatedSelectOperation<duckdb::GreaterThan>(right, left, sel, count, true_sel, false_sel, null_mask);
-}
-
-idx_t VectorOperations::LessThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-                                       idx_t count, optional_ptr<SelectionVector> true_sel,
-                                       optional_ptr<SelectionVector> false_sel, optional_ptr<ValidityMask> null_mask) {
-	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(right, left, sel, count, true_sel, false_sel, null_mask);
-}
-
-idx_t ExpressionExecutor::Select(const BoundComparisonExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-                                 SelectionVector *false_sel) {
-	// resolve the children
-	state->intermediate_chunk.Reset();
-	auto &left = state->intermediate_chunk.data[0];
-	auto &right = state->intermediate_chunk.data[1];
-
-	Execute(*expr.left, state->child_states[0].get(), sel, count, left);
-	Execute(*expr.right, state->child_states[1].get(), sel, count, right);
-
-	switch (expr.GetExpressionType()) {
-	case ExpressionType::COMPARE_EQUAL:
-		return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return VectorOperations::NotEquals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return VectorOperations::LessThan(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return VectorOperations::GreaterThan(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return VectorOperations::NotDistinctFrom(left, right, sel, count, true_sel, false_sel);
-	default:
-		throw InternalException("Unknown comparison type!");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp b/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp
deleted file mode 100644
index 1b2bc3a4e..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/execution/adaptive_filter.hpp"
-
-#include <random>
-
-namespace duckdb {
-
-struct ConjunctionState : public ExpressionState {
-	ConjunctionState(const Expression &expr, ExpressionExecutorState &root) : ExpressionState(expr, root) {
-		adaptive_filter = make_uniq<AdaptiveFilter>(expr);
-	}
-	unique_ptr<AdaptiveFilter> adaptive_filter;
-};
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConjunctionExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ConjunctionState>(expr, root);
-	for (auto &child : expr.children) {
-		result->AddChild(*child);
-	}
-
-	result->Finalize();
-	return std::move(result);
-}
-
-void ExpressionExecutor::Execute(const BoundConjunctionExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	// execute the children
-	state->intermediate_chunk.Reset();
-	for (idx_t i = 0; i < expr.children.size(); i++) {
-		auto &current_result = state->intermediate_chunk.data[i];
-		Execute(*expr.children[i], state->child_states[i].get(), sel, count, current_result);
-		if (i == 0) {
-			// move the result
-			result.Reference(current_result);
-		} else {
-			Vector intermediate(LogicalType::BOOLEAN);
-			// AND/OR together
-			switch (expr.GetExpressionType()) {
-			case ExpressionType::CONJUNCTION_AND:
-				VectorOperations::And(current_result, result, intermediate, count);
-				break;
-			case ExpressionType::CONJUNCTION_OR:
-				VectorOperations::Or(current_result, result, intermediate, count);
-				break;
-			default:
-				throw InternalException("Unknown conjunction type!");
-			}
-			result.Reference(intermediate);
-		}
-	}
-}
-
-idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, ExpressionState *state_p,
-                                 const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-                                 SelectionVector *false_sel) {
-	auto &state = state_p->Cast<ConjunctionState>();
-
-	if (expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		// get runtime statistics
-		auto filter_state = state.adaptive_filter->BeginFilter();
-		const SelectionVector *current_sel = sel;
-		idx_t current_count = count;
-		idx_t false_count = 0;
-
-		unique_ptr<SelectionVector> temp_true, temp_false;
-		if (false_sel) {
-			temp_false = make_uniq<SelectionVector>(STANDARD_VECTOR_SIZE);
-		}
-		if (!true_sel) {
-			temp_true = make_uniq<SelectionVector>(STANDARD_VECTOR_SIZE);
-			true_sel = temp_true.get();
-		}
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			idx_t tcount = Select(*expr.children[state.adaptive_filter->permutation[i]],
-			                      state.child_states[state.adaptive_filter->permutation[i]].get(), current_sel,
-			                      current_count, true_sel, temp_false.get());
-			idx_t fcount = current_count - tcount;
-			if (fcount > 0 && false_sel) {
-				// move failing tuples into the false_sel
-				// tuples passed, move them into the actual result vector
-				for (idx_t i = 0; i < fcount; i++) {
-					false_sel->set_index(false_count++, temp_false->get_index(i));
-				}
-			}
-			current_count = tcount;
-			if (current_count == 0) {
-				break;
-			}
-			if (current_count < count) {
-				// tuples were filtered out: move on to using the true_sel to only evaluate passing tuples in subsequent
-				// iterations
-				current_sel = true_sel;
-			}
-		}
-		// adapt runtime statistics
-		state.adaptive_filter->EndFilter(filter_state);
-		return current_count;
-	} else {
-		// get runtime statistics
-		auto filter_state = state.adaptive_filter->BeginFilter();
-
-		const SelectionVector *current_sel = sel;
-		idx_t current_count = count;
-		idx_t result_count = 0;
-
-		unique_ptr<SelectionVector> temp_true, temp_false;
-		if (true_sel) {
-			temp_true = make_uniq<SelectionVector>(STANDARD_VECTOR_SIZE);
-		}
-		if (!false_sel) {
-			temp_false = make_uniq<SelectionVector>(STANDARD_VECTOR_SIZE);
-			false_sel = temp_false.get();
-		}
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			idx_t tcount = Select(*expr.children[state.adaptive_filter->permutation[i]],
-			                      state.child_states[state.adaptive_filter->permutation[i]].get(), current_sel,
-			                      current_count, temp_true.get(), false_sel);
-			if (tcount > 0) {
-				if (true_sel) {
-					// tuples passed, move them into the actual result vector
-					for (idx_t i = 0; i < tcount; i++) {
-						true_sel->set_index(result_count++, temp_true->get_index(i));
-					}
-				}
-				// now move on to check only the non-passing tuples
-				current_count -= tcount;
-				current_sel = false_sel;
-			}
-		}
-
-		// adapt runtime statistics
-		state.adaptive_filter->EndFilter(filter_state);
-		return result_count;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_constant.cpp b/src/duckdb/src/execution/expression_executor/execute_constant.cpp
deleted file mode 100644
index cd9b463b8..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_constant.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConstantExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExpressionState>(expr, root);
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundConstantExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	D_ASSERT(expr.value.type() == expr.return_type);
-	result.Reference(expr.value);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_function.cpp b/src/duckdb/src/execution/expression_executor/execute_function.cpp
deleted file mode 100644
index 5a95d27a3..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_function.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-ExecuteFunctionState::ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root)
-    : ExpressionState(expr, root) {
-}
-
-ExecuteFunctionState::~ExecuteFunctionState() {
-}
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundFunctionExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExecuteFunctionState>(expr, root);
-	for (auto &child : expr.children) {
-		result->AddChild(*child);
-	}
-
-	result->Finalize();
-	if (expr.function.init_local_state) {
-		result->local_state = expr.function.init_local_state(*result, expr, expr.bind_info.get());
-	}
-	return std::move(result);
-}
-
-static void VerifyNullHandling(const BoundFunctionExpression &expr, DataChunk &args, Vector &result) {
-#ifdef DEBUG
-	if (args.data.empty() || expr.function.null_handling != FunctionNullHandling::DEFAULT_NULL_HANDLING) {
-		return;
-	}
-
-	// Combine all the argument validity masks into a flat validity mask
-	idx_t count = args.size();
-	ValidityMask combined_mask(count);
-	for (auto &arg : args.data) {
-		UnifiedVectorFormat arg_data;
-		arg.ToUnifiedFormat(count, arg_data);
-
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = arg_data.sel->get_index(i);
-			if (!arg_data.validity.RowIsValid(idx)) {
-				combined_mask.SetInvalid(i);
-			}
-		}
-	}
-
-	// Default is that if any of the arguments are NULL, the result is also NULL
-	UnifiedVectorFormat result_data;
-	result.ToUnifiedFormat(count, result_data);
-	for (idx_t i = 0; i < count; i++) {
-		if (!combined_mask.RowIsValid(i)) {
-			auto idx = result_data.sel->get_index(i);
-			D_ASSERT(!result_data.validity.RowIsValid(idx));
-		}
-	}
-#endif
-}
-
-void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	state->intermediate_chunk.Reset();
-	auto &arguments = state->intermediate_chunk;
-	if (!state->types.empty()) {
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			D_ASSERT(state->types[i] == expr.children[i]->return_type);
-			Execute(*expr.children[i], state->child_states[i].get(), sel, count, arguments.data[i]);
-#ifdef DEBUG
-			if (expr.children[i]->return_type.id() == LogicalTypeId::VARCHAR) {
-				arguments.data[i].UTFVerify(count);
-			}
-#endif
-		}
-	}
-	arguments.SetCardinality(count);
-	arguments.Verify();
-
-	D_ASSERT(expr.function.function);
-	// #ifdef DEBUG
-	expr.function.function(arguments, *state, result);
-
-	VerifyNullHandling(expr, arguments, result);
-	D_ASSERT(result.GetType() == expr.return_type);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_operator.cpp b/src/duckdb/src/execution/expression_executor/execute_operator.cpp
deleted file mode 100644
index b543679e8..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_operator.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundOperatorExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExpressionState>(expr, root);
-	for (auto &child : expr.children) {
-		result->AddChild(*child);
-	}
-
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	// special handling for special snowflake 'IN'
-	// IN has n children
-	if (expr.GetExpressionType() == ExpressionType::COMPARE_IN ||
-	    expr.GetExpressionType() == ExpressionType::COMPARE_NOT_IN) {
-		if (expr.children.size() < 2) {
-			throw InvalidInputException("IN needs at least two children");
-		}
-
-		Vector left(expr.children[0]->return_type);
-		// eval left side
-		Execute(*expr.children[0], state->child_states[0].get(), sel, count, left);
-
-		// init result to false
-		Vector intermediate(LogicalType::BOOLEAN);
-		Value false_val = Value::BOOLEAN(false);
-		intermediate.Reference(false_val);
-
-		// in rhs is a list of constants
-		// for every child, OR the result of the comparison with the left
-		// to get the overall result.
-		for (idx_t child = 1; child < expr.children.size(); child++) {
-			Vector vector_to_check(expr.children[child]->return_type);
-			Vector comp_res(LogicalType::BOOLEAN);
-
-			Execute(*expr.children[child], state->child_states[child].get(), sel, count, vector_to_check);
-			VectorOperations::Equals(left, vector_to_check, comp_res, count);
-
-			if (child == 1) {
-				// first child: move to result
-				intermediate.Reference(comp_res);
-			} else {
-				// otherwise OR together
-				Vector new_result(LogicalType::BOOLEAN, true, false);
-				VectorOperations::Or(intermediate, comp_res, new_result, count);
-				intermediate.Reference(new_result);
-			}
-		}
-		if (expr.GetExpressionType() == ExpressionType::COMPARE_NOT_IN) {
-			// NOT IN: invert result
-			VectorOperations::Not(intermediate, result, count);
-		} else {
-			// directly use the result
-			result.Reference(intermediate);
-		}
-	} else if (expr.GetExpressionType() == ExpressionType::OPERATOR_COALESCE) {
-		SelectionVector sel_a(count);
-		SelectionVector sel_b(count);
-		SelectionVector slice_sel(count);
-		SelectionVector result_sel(count);
-		SelectionVector *next_sel = &sel_a;
-		const SelectionVector *current_sel = sel;
-		idx_t remaining_count = count;
-		idx_t next_count;
-		for (idx_t child = 0; child < expr.children.size(); child++) {
-			Vector vector_to_check(expr.children[child]->return_type);
-			Execute(*expr.children[child], state->child_states[child].get(), current_sel, remaining_count,
-			        vector_to_check);
-
-			UnifiedVectorFormat vdata;
-			vector_to_check.ToUnifiedFormat(remaining_count, vdata);
-
-			idx_t result_count = 0;
-			next_count = 0;
-			for (idx_t i = 0; i < remaining_count; i++) {
-				auto base_idx = current_sel ? current_sel->get_index(i) : i;
-				auto idx = vdata.sel->get_index(i);
-				if (vdata.validity.RowIsValid(idx)) {
-					slice_sel.set_index(result_count, i);
-					result_sel.set_index(result_count++, base_idx);
-				} else {
-					next_sel->set_index(next_count++, base_idx);
-				}
-			}
-			if (result_count > 0) {
-				vector_to_check.Slice(slice_sel, result_count);
-				FillSwitch(vector_to_check, result, result_sel, NumericCast<sel_t>(result_count));
-			}
-			current_sel = next_sel;
-			next_sel = next_sel == &sel_a ? &sel_b : &sel_a;
-			remaining_count = next_count;
-			if (next_count == 0) {
-				break;
-			}
-		}
-		if (remaining_count > 0) {
-			for (idx_t i = 0; i < remaining_count; i++) {
-				FlatVector::SetNull(result, current_sel->get_index(i), true);
-			}
-		}
-		if (sel) {
-			result.Slice(*sel, count);
-		} else if (count == 1) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	} else if (expr.children.size() == 1) {
-		state->intermediate_chunk.Reset();
-		auto &child = state->intermediate_chunk.data[0];
-
-		Execute(*expr.children[0], state->child_states[0].get(), sel, count, child);
-		switch (expr.GetExpressionType()) {
-		case ExpressionType::OPERATOR_NOT: {
-			VectorOperations::Not(child, result, count);
-			break;
-		}
-		case ExpressionType::OPERATOR_IS_NULL: {
-			VectorOperations::IsNull(child, result, count);
-			break;
-		}
-		case ExpressionType::OPERATOR_IS_NOT_NULL: {
-			VectorOperations::IsNotNull(child, result, count);
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported operator type with 1 child!");
-		}
-	} else {
-		throw NotImplementedException("operator");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_parameter.cpp b/src/duckdb/src/execution/expression_executor/execute_parameter.cpp
deleted file mode 100644
index c03ca9347..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_parameter.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundParameterExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExpressionState>(expr, root);
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundParameterExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	D_ASSERT(expr.parameter_data);
-	D_ASSERT(expr.parameter_data->return_type == expr.return_type);
-	D_ASSERT(expr.parameter_data->GetValue().type() == expr.return_type);
-	result.Reference(expr.parameter_data->GetValue());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor/execute_reference.cpp b/src/duckdb/src/execution/expression_executor/execute_reference.cpp
deleted file mode 100644
index 88fdfa63d..000000000
--- a/src/duckdb/src/execution/expression_executor/execute_reference.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundReferenceExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_uniq<ExpressionState>(expr, root);
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundReferenceExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	D_ASSERT(expr.index != DConstants::INVALID_INDEX);
-	D_ASSERT(expr.index < chunk->ColumnCount());
-
-	if (sel) {
-		result.Slice(chunk->data[expr.index], *sel, count);
-	} else {
-		result.Reference(chunk->data[expr.index]);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/expression_executor_state.cpp b/src/duckdb/src/execution/expression_executor_state.cpp
deleted file mode 100644
index 070a399db..000000000
--- a/src/duckdb/src/execution/expression_executor_state.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "duckdb/execution/expression_executor_state.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-void ExpressionState::AddChild(Expression &child_expr) {
-	types.push_back(child_expr.return_type);
-	auto child_state = ExpressionExecutor::InitializeState(child_expr, root);
-	child_states.push_back(std::move(child_state));
-
-	auto expr_class = child_expr.GetExpressionClass();
-	auto initialize_child = expr_class != ExpressionClass::BOUND_REF && expr_class != ExpressionClass::BOUND_CONSTANT &&
-	                        expr_class != ExpressionClass::BOUND_PARAMETER;
-	initialize.push_back(initialize_child);
-}
-
-void ExpressionState::Finalize() {
-	if (types.empty()) {
-		return;
-	}
-	intermediate_chunk.Initialize(GetAllocator(), types, initialize);
-}
-
-Allocator &ExpressionState::GetAllocator() {
-	return root.executor->GetAllocator();
-}
-
-bool ExpressionState::HasContext() {
-	return root.executor->HasContext();
-}
-
-ClientContext &ExpressionState::GetContext() {
-	if (!HasContext()) {
-		throw BinderException("Cannot use %s in this context", (expr.Cast<BoundFunctionExpression>()).function.name);
-	}
-	return root.executor->GetContext();
-}
-
-ExpressionState::ExpressionState(const Expression &expr, ExpressionExecutorState &root) : expr(expr), root(root) {
-}
-
-ExpressionExecutorState::ExpressionExecutorState() {
-}
-
-void ExpressionState::Verify(ExpressionExecutorState &root_executor) {
-	D_ASSERT(&root_executor == &root);
-	for (auto &entry : child_states) {
-		entry->Verify(root_executor);
-	}
-}
-
-void ExpressionExecutorState::Verify() {
-	D_ASSERT(executor);
-	root_state->Verify(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/art.cpp b/src/duckdb/src/execution/index/art/art.cpp
deleted file mode 100644
index a92f2eebf..000000000
--- a/src/duckdb/src/execution/index/art/art.cpp
+++ /dev/null
@@ -1,1436 +0,0 @@
-#include "duckdb/execution/index/art/art.hpp"
-
-#include "duckdb/common/types/conflict_manager.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/base_leaf.hpp"
-#include "duckdb/execution/index/art/base_node.hpp"
-#include "duckdb/execution/index/art/iterator.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/art/node256_leaf.hpp"
-#include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-
-namespace duckdb {
-
-struct ARTIndexScanState : public IndexScanState {
-	//! The predicates to scan.
-	//! A single predicate for point lookups, and two predicates for range scans.
-	Value values[2];
-	//! The expressions over the scan predicates.
-	ExpressionType expressions[2];
-	bool checked = false;
-	//! All scanned row IDs.
-	unsafe_vector<row_t> row_ids;
-};
-
-//===--------------------------------------------------------------------===//
-// ART
-//===--------------------------------------------------------------------===//
-
-ART::ART(const string &name, const IndexConstraintType index_constraint_type, const vector<column_t> &column_ids,
-         TableIOManager &table_io_manager, const vector<unique_ptr<Expression>> &unbound_expressions,
-         AttachedDatabase &db,
-         const shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr,
-         const IndexStorageInfo &info)
-    : BoundIndex(name, ART::TYPE_NAME, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db),
-      allocators(allocators_ptr), owns_data(false), append_mode(ARTAppendMode::DEFAULT) {
-
-	// FIXME: Use the new byte representation function to support nested types.
-	for (idx_t i = 0; i < types.size(); i++) {
-		switch (types[i]) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-		case PhysicalType::INT64:
-		case PhysicalType::INT128:
-		case PhysicalType::UINT8:
-		case PhysicalType::UINT16:
-		case PhysicalType::UINT32:
-		case PhysicalType::UINT64:
-		case PhysicalType::UINT128:
-		case PhysicalType::FLOAT:
-		case PhysicalType::DOUBLE:
-		case PhysicalType::VARCHAR:
-			break;
-		default:
-			throw InvalidTypeException(logical_types[i], "Invalid type for index key.");
-		}
-	}
-
-	// Initialize the allocators.
-	SetPrefixCount(info);
-	if (!allocators) {
-		owns_data = true;
-		auto prefix_size = NumericCast<idx_t>(prefix_count) + NumericCast<idx_t>(Prefix::METADATA_SIZE);
-		auto &block_manager = table_io_manager.GetIndexBlockManager();
-
-		array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT> allocator_array = {
-		    make_unsafe_uniq<FixedSizeAllocator>(prefix_size, block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Leaf), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node4), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node16), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node48), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node256), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node7Leaf), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node15Leaf), block_manager),
-		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node256Leaf), block_manager),
-		};
-		allocators =
-		    make_shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>>(std::move(allocator_array));
-	}
-
-	if (!info.IsValid()) {
-		// We create a new ART.
-		return;
-	}
-
-	if (info.root_block_ptr.IsValid()) {
-		// Backwards compatibility.
-		Deserialize(info.root_block_ptr);
-		return;
-	}
-
-	// Set the root node and initialize the allocators.
-	tree.Set(info.root);
-	InitAllocators(info);
-}
-
-//===--------------------------------------------------------------------===//
-// Initialize Scans
-//===--------------------------------------------------------------------===//
-
-static unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Value &value,
-                                                                const ExpressionType expression_type) {
-	auto result = make_uniq<ARTIndexScanState>();
-	result->values[0] = value;
-	result->expressions[0] = expression_type;
-	return std::move(result);
-}
-
-static unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Value &low_value,
-                                                              const ExpressionType low_expression_type,
-                                                              const Value &high_value,
-                                                              const ExpressionType high_expression_type) {
-	auto result = make_uniq<ARTIndexScanState>();
-	result->values[0] = low_value;
-	result->expressions[0] = low_expression_type;
-	result->values[1] = high_value;
-	result->expressions[1] = high_expression_type;
-	return std::move(result);
-}
-
-unique_ptr<IndexScanState> ART::TryInitializeScan(const Expression &expr, const Expression &filter_expr) {
-	Value low_value, high_value, equal_value;
-	ExpressionType low_comparison_type = ExpressionType::INVALID, high_comparison_type = ExpressionType::INVALID;
-
-	// Try to find a matching index for any of the filter expressions.
-	ComparisonExpressionMatcher matcher;
-
-	// Match on a comparison type.
-	matcher.expr_type = make_uniq<ComparisonExpressionTypeMatcher>();
-
-	// Match on a constant comparison with the indexed expression.
-	matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(expr));
-	matcher.matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-	matcher.policy = SetMatcher::Policy::UNORDERED;
-
-	vector<reference<Expression>> bindings;
-	auto filter_match =
-	    matcher.Match(const_cast<Expression &>(filter_expr), bindings); // NOLINT: Match does not alter the expr.
-	if (filter_match) {
-		// This is a range or equality comparison with a constant value, so we can use the index.
-		// 		bindings[0] = the expression
-		// 		bindings[1] = the index expression
-		// 		bindings[2] = the constant
-		auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
-		auto constant_value = bindings[2].get().Cast<BoundConstantExpression>().value;
-		auto comparison_type = comparison.GetExpressionType();
-
-		if (comparison.left->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-			// The expression is on the right side, we flip the comparison expression.
-			comparison_type = FlipComparisonExpression(comparison_type);
-		}
-
-		if (comparison_type == ExpressionType::COMPARE_EQUAL) {
-			// An equality value overrides any other bounds.
-			equal_value = constant_value;
-		} else if (comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-		           comparison_type == ExpressionType::COMPARE_GREATERTHAN) {
-			// This is a lower bound.
-			low_value = constant_value;
-			low_comparison_type = comparison_type;
-		} else {
-			// This is an upper bound.
-			high_value = constant_value;
-			high_comparison_type = comparison_type;
-		}
-
-	} else if (filter_expr.GetExpressionType() == ExpressionType::COMPARE_BETWEEN) {
-		auto &between = filter_expr.Cast<BoundBetweenExpression>();
-		if (!between.input->Equals(expr)) {
-			// The expression does not match the index expression.
-			return nullptr;
-		}
-
-		if (between.lower->GetExpressionType() != ExpressionType::VALUE_CONSTANT ||
-		    between.upper->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
-			// Not a constant expression.
-			return nullptr;
-		}
-
-		low_value = between.lower->Cast<BoundConstantExpression>().value;
-		low_comparison_type = between.lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
-		                                              : ExpressionType::COMPARE_GREATERTHAN;
-		high_value = (between.upper->Cast<BoundConstantExpression>()).value;
-		high_comparison_type =
-		    between.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
-	}
-
-	// We cannot use an index scan.
-	if (equal_value.IsNull() && low_value.IsNull() && high_value.IsNull()) {
-		return nullptr;
-	}
-
-	// Initialize the index scan state and return it.
-	if (!equal_value.IsNull()) {
-		// Equality predicate.
-		return InitializeScanSinglePredicate(equal_value, ExpressionType::COMPARE_EQUAL);
-	}
-	if (!low_value.IsNull() && !high_value.IsNull()) {
-		// Two-sided predicate.
-		return InitializeScanTwoPredicates(low_value, low_comparison_type, high_value, high_comparison_type);
-	}
-	if (!low_value.IsNull()) {
-		// Less-than predicate.
-		return InitializeScanSinglePredicate(low_value, low_comparison_type);
-	}
-	// Greater-than predicate.
-	return InitializeScanSinglePredicate(high_value, high_comparison_type);
-}
-
-//===--------------------------------------------------------------------===//
-// ART Keys
-//===--------------------------------------------------------------------===//
-
-template <class T, bool IS_NOT_NULL>
-static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, unsafe_vector<ARTKey> &keys) {
-	D_ASSERT(keys.size() >= count);
-
-	UnifiedVectorFormat data;
-	input.ToUnifiedFormat(count, data);
-	auto input_data = UnifiedVectorFormat::GetData<T>(data);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = data.sel->get_index(i);
-		if (IS_NOT_NULL || data.validity.RowIsValid(idx)) {
-			ARTKey::CreateARTKey<T>(allocator, keys[i], input_data[idx]);
-			continue;
-		}
-
-		// We need to reset the key value in the reusable keys vector.
-		keys[i] = ARTKey();
-	}
-}
-
-template <class T, bool IS_NOT_NULL>
-static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, unsafe_vector<ARTKey> &keys) {
-	UnifiedVectorFormat data;
-	input.ToUnifiedFormat(count, data);
-	auto input_data = UnifiedVectorFormat::GetData<T>(data);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = data.sel->get_index(i);
-
-		if (IS_NOT_NULL) {
-			auto other_key = ARTKey::CreateARTKey<T>(allocator, input_data[idx]);
-			keys[i].Concat(allocator, other_key);
-			continue;
-		}
-
-		// A previous column entry was NULL.
-		if (keys[i].Empty()) {
-			continue;
-		}
-
-		// This column entry is NULL, so we set the whole key to NULL.
-		if (!data.validity.RowIsValid(idx)) {
-			keys[i] = ARTKey();
-			continue;
-		}
-
-		// Concatenate the keys.
-		auto other_key = ARTKey::CreateARTKey<T>(allocator, input_data[idx]);
-		keys[i].Concat(allocator, other_key);
-	}
-}
-
-template <bool IS_NOT_NULL>
-void GenerateKeysInternal(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys) {
-	switch (input.data[0].GetType().InternalType()) {
-	case PhysicalType::BOOL:
-		TemplatedGenerateKeys<bool, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::INT8:
-		TemplatedGenerateKeys<int8_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGenerateKeys<int16_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGenerateKeys<int32_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGenerateKeys<int64_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::INT128:
-		TemplatedGenerateKeys<hugeint_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedGenerateKeys<uint8_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedGenerateKeys<uint16_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedGenerateKeys<uint32_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedGenerateKeys<uint64_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedGenerateKeys<uhugeint_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGenerateKeys<float, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGenerateKeys<double, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedGenerateKeys<string_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
-		break;
-	default:
-		throw InternalException("Invalid type for index");
-	}
-
-	// We concatenate the keys for each remaining column of a compound key.
-	for (idx_t i = 1; i < input.ColumnCount(); i++) {
-		switch (input.data[i].GetType().InternalType()) {
-		case PhysicalType::BOOL:
-			ConcatenateKeys<bool, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::INT8:
-			ConcatenateKeys<int8_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::INT16:
-			ConcatenateKeys<int16_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::INT32:
-			ConcatenateKeys<int32_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::INT64:
-			ConcatenateKeys<int64_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::INT128:
-			ConcatenateKeys<hugeint_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::UINT8:
-			ConcatenateKeys<uint8_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::UINT16:
-			ConcatenateKeys<uint16_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::UINT32:
-			ConcatenateKeys<uint32_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::UINT64:
-			ConcatenateKeys<uint64_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::UINT128:
-			ConcatenateKeys<uhugeint_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::FLOAT:
-			ConcatenateKeys<float, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::DOUBLE:
-			ConcatenateKeys<double, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		case PhysicalType::VARCHAR:
-			ConcatenateKeys<string_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
-			break;
-		default:
-			throw InternalException("Invalid type for index");
-		}
-	}
-}
-
-template <>
-void ART::GenerateKeys<>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys) {
-	GenerateKeysInternal<false>(allocator, input, keys);
-}
-
-template <>
-void ART::GenerateKeys<true>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys) {
-	GenerateKeysInternal<true>(allocator, input, keys);
-}
-
-void ART::GenerateKeyVectors(ArenaAllocator &allocator, DataChunk &input, Vector &row_ids, unsafe_vector<ARTKey> &keys,
-                             unsafe_vector<ARTKey> &row_id_keys) {
-	GenerateKeys<>(allocator, input, keys);
-
-	DataChunk row_id_chunk;
-	row_id_chunk.Initialize(Allocator::DefaultAllocator(), vector<LogicalType> {LogicalType::ROW_TYPE}, input.size());
-	row_id_chunk.data[0].Reference(row_ids);
-	row_id_chunk.SetCardinality(input.size());
-	GenerateKeys<>(allocator, row_id_chunk, row_id_keys);
-}
-
-//===--------------------------------------------------------------------===//
-// Construct from sorted data.
-//===--------------------------------------------------------------------===//
-
-bool ART::ConstructInternal(const unsafe_vector<ARTKey> &keys, const unsafe_vector<ARTKey> &row_ids, Node &node,
-                            ARTKeySection &section) {
-	D_ASSERT(section.start < keys.size());
-	D_ASSERT(section.end < keys.size());
-	D_ASSERT(section.start <= section.end);
-
-	auto &start = keys[section.start];
-	auto &end = keys[section.end];
-	D_ASSERT(start.len != 0);
-
-	// Increment the depth until we reach a leaf or find a mismatching byte.
-	auto prefix_depth = section.depth;
-	while (start.len != section.depth && start.ByteMatches(end, section.depth)) {
-		section.depth++;
-	}
-
-	if (start.len == section.depth) {
-		// We reached a leaf. All the bytes of start_key and end_key match.
-		auto row_id_count = section.end - section.start + 1;
-		if (IsUnique() && row_id_count != 1) {
-			return false;
-		}
-
-		reference<Node> ref(node);
-		auto count = UnsafeNumericCast<uint8_t>(start.len - prefix_depth);
-		Prefix::New(*this, ref, start, prefix_depth, count);
-		if (row_id_count == 1) {
-			Leaf::New(ref, row_ids[section.start].GetRowId());
-		} else {
-			Leaf::New(*this, ref, row_ids, section.start, row_id_count);
-		}
-		return true;
-	}
-
-	// Create a new node and recurse.
-	unsafe_vector<ARTKeySection> children;
-	section.GetChildSections(children, keys);
-
-	// Create the prefix.
-	reference<Node> ref(node);
-	auto prefix_length = section.depth - prefix_depth;
-	Prefix::New(*this, ref, start, prefix_depth, prefix_length);
-
-	// Create the node.
-	Node::New(*this, ref, Node::GetNodeType(children.size()));
-	for (auto &child : children) {
-		Node new_child;
-		auto success = ConstructInternal(keys, row_ids, new_child, child);
-		Node::InsertChild(*this, ref, child.key_byte, new_child);
-		if (!success) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool ART::Construct(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids, const idx_t row_count) {
-	ARTKeySection section(0, row_count - 1, 0, 0);
-	if (!ConstructInternal(keys, row_ids, tree, section)) {
-		return false;
-	}
-
-#ifdef DEBUG
-	unsafe_vector<row_t> row_ids_debug;
-	Iterator it(*this);
-	it.FindMinimum(tree);
-	ARTKey empty_key = ARTKey();
-	it.Scan(empty_key, NumericLimits<row_t>().Maximum(), row_ids_debug, false);
-	D_ASSERT(row_count == row_ids_debug.size());
-#endif
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Insert and Constraint Checking
-//===--------------------------------------------------------------------===//
-
-ErrorData ART::Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids) {
-	return Insert(l, chunk, row_ids, nullptr);
-}
-
-ErrorData ART::Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids, optional_ptr<BoundIndex> delete_index) {
-	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	auto row_count = chunk.size();
-
-	ArenaAllocator allocator(BufferAllocator::Get(db));
-	unsafe_vector<ARTKey> keys(row_count);
-	unsafe_vector<ARTKey> row_id_keys(row_count);
-	GenerateKeyVectors(allocator, chunk, row_ids, keys, row_id_keys);
-
-	optional_ptr<ART> delete_art;
-	if (delete_index) {
-		delete_art = delete_index->Cast<ART>();
-	}
-
-	auto conflict_type = ARTConflictType::NO_CONFLICT;
-	optional_idx conflict_idx;
-	auto was_empty = !tree.HasMetadata();
-
-	// Insert the entries into the index.
-	for (idx_t i = 0; i < row_count; i++) {
-		if (keys[i].Empty()) {
-			continue;
-		}
-		conflict_type = Insert(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus(), delete_art);
-		if (conflict_type != ARTConflictType::NO_CONFLICT) {
-			conflict_idx = i;
-			break;
-		}
-	}
-
-	// Remove any previously inserted entries.
-	if (conflict_type != ARTConflictType::NO_CONFLICT) {
-		D_ASSERT(conflict_idx.IsValid());
-		for (idx_t i = 0; i < conflict_idx.GetIndex(); i++) {
-			if (keys[i].Empty()) {
-				continue;
-			}
-			Erase(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus());
-		}
-	}
-
-	if (was_empty) {
-		// All nodes are in-memory.
-		VerifyAllocationsInternal();
-	}
-
-	if (conflict_type == ARTConflictType::TRANSACTION) {
-		auto msg = AppendRowError(chunk, conflict_idx.GetIndex());
-		return ErrorData(TransactionException("write-write conflict on key: \"%s\"", msg));
-	}
-
-	if (conflict_type == ARTConflictType::CONSTRAINT) {
-		auto msg = AppendRowError(chunk, conflict_idx.GetIndex());
-		return ErrorData(ConstraintException("PRIMARY KEY or UNIQUE constraint violation: duplicate key \"%s\"", msg));
-	}
-
-#ifdef DEBUG
-	for (idx_t i = 0; i < row_count; i++) {
-		if (keys[i].Empty()) {
-			continue;
-		}
-		D_ASSERT(Lookup(tree, keys[i], 0));
-	}
-#endif
-	return ErrorData();
-}
-
-ErrorData ART::Append(IndexLock &l, DataChunk &chunk, Vector &row_ids) {
-	// Execute all column expressions before inserting the data chunk.
-	DataChunk expr_chunk;
-	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(chunk, expr_chunk);
-
-	// Now insert the data chunk.
-	return Insert(l, expr_chunk, row_ids, nullptr);
-}
-
-ErrorData ART::AppendWithDeleteIndex(IndexLock &l, DataChunk &chunk, Vector &row_ids,
-                                     optional_ptr<BoundIndex> delete_index) {
-	// Execute all column expressions before inserting the data chunk.
-	DataChunk expr_chunk;
-	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(chunk, expr_chunk);
-
-	// Now insert the data chunk.
-	return Insert(l, expr_chunk, row_ids, delete_index);
-}
-
-void ART::VerifyAppend(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, optional_ptr<ConflictManager> manager) {
-	if (manager) {
-		D_ASSERT(manager->LookupType() == VerifyExistenceType::APPEND);
-		return VerifyConstraint(chunk, delete_index, *manager);
-	}
-	ConflictManager local_manager(VerifyExistenceType::APPEND, chunk.size());
-	VerifyConstraint(chunk, delete_index, local_manager);
-}
-
-void ART::InsertIntoEmpty(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-                          const GateStatus status) {
-	D_ASSERT(depth <= key.len);
-	D_ASSERT(!node.HasMetadata());
-
-	if (status == GateStatus::GATE_SET) {
-		Leaf::New(node, row_id.GetRowId());
-		return;
-	}
-
-	reference<Node> ref(node);
-	auto count = key.len - depth;
-
-	Prefix::New(*this, ref, key, depth, count);
-	Leaf::New(ref, row_id.GetRowId());
-}
-
-ARTConflictType ART::InsertIntoInlined(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-                                       const GateStatus status, optional_ptr<ART> delete_art) {
-
-	if (!IsUnique() || append_mode == ARTAppendMode::INSERT_DUPLICATES) {
-		Leaf::InsertIntoInlined(*this, node, row_id, depth, status);
-		return ARTConflictType::NO_CONFLICT;
-	}
-
-	if (!delete_art) {
-		if (append_mode == ARTAppendMode::IGNORE_DUPLICATES) {
-			return ARTConflictType::NO_CONFLICT;
-		}
-		return ARTConflictType::CONSTRAINT;
-	}
-
-	// Lookup in the delete_art.
-	auto delete_leaf = delete_art->Lookup(delete_art->tree, key, 0);
-	if (!delete_leaf) {
-		return ARTConflictType::CONSTRAINT;
-	}
-
-	// The row ID has changed.
-	// Thus, the local index has a newer (local) row ID, and this is a constraint violation.
-	D_ASSERT(delete_leaf->GetType() == NType::LEAF_INLINED);
-	auto deleted_row_id = delete_leaf->GetRowId();
-	auto this_row_id = node.GetRowId();
-	if (deleted_row_id != this_row_id) {
-		return ARTConflictType::CONSTRAINT;
-	}
-
-	// The deleted key and its row ID match the current key and its row ID.
-	Leaf::InsertIntoInlined(*this, node, row_id, depth, status);
-	return ARTConflictType::NO_CONFLICT;
-}
-
-ARTConflictType ART::InsertIntoNode(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-                                    const GateStatus status, optional_ptr<ART> delete_art) {
-	D_ASSERT(depth < key.len);
-	auto child = node.GetChildMutable(*this, key[depth]);
-
-	// Recurse, if a child exists at key[depth].
-	if (child) {
-		D_ASSERT(child->HasMetadata());
-		auto conflict_type = Insert(*child, key, depth + 1, row_id, status, delete_art);
-		node.ReplaceChild(*this, key[depth], *child);
-		return conflict_type;
-	}
-
-	// Create an inlined prefix at key[depth].
-	if (status == GateStatus::GATE_SET) {
-		Node remainder;
-		auto byte = key[depth];
-		auto conflict_type = Insert(remainder, key, depth + 1, row_id, status, delete_art);
-		Node::InsertChild(*this, node, byte, remainder);
-		return conflict_type;
-	}
-
-	// Insert an inlined leaf at key[depth].
-	Node leaf;
-	reference<Node> ref(leaf);
-
-	// Create the prefix.
-	if (depth + 1 < key.len) {
-		auto count = key.len - depth - 1;
-		Prefix::New(*this, ref, key, depth + 1, count);
-	}
-
-	// Create the inlined leaf.
-	Leaf::New(ref, row_id.GetRowId());
-	Node::InsertChild(*this, node, key[depth], leaf);
-	return ARTConflictType::NO_CONFLICT;
-}
-
-ARTConflictType ART::Insert(Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id, const GateStatus status,
-                            optional_ptr<ART> delete_art) {
-	if (!node.HasMetadata()) {
-		InsertIntoEmpty(node, key, depth, row_id, status);
-		return ARTConflictType::NO_CONFLICT;
-	}
-
-	// Enter a nested leaf.
-	if (status == GateStatus::GATE_NOT_SET && node.GetGateStatus() == GateStatus::GATE_SET) {
-		if (IsUnique()) {
-			// Unique indexes can have duplicates, if another transaction DELETE + INSERT
-			// the same key. In that case, the previous value must be kept alive until all
-			// other transactions do not depend on it anymore.
-
-			// We restrict this transactionality to two-value leaves, so any subsequent
-			// incoming transaction must fail here.
-			return ARTConflictType::TRANSACTION;
-		}
-		return Insert(node, row_id, 0, row_id, GateStatus::GATE_SET, delete_art);
-	}
-
-	auto type = node.GetType();
-	switch (type) {
-	case NType::LEAF_INLINED: {
-		return InsertIntoInlined(node, key, depth, row_id, status, delete_art);
-	}
-	case NType::LEAF: {
-		Leaf::TransformToNested(*this, node);
-		return Insert(node, key, depth, row_id, status, delete_art);
-	}
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF: {
-		// Row IDs are unique, so there are never any duplicate byte conflicts here.
-		auto byte = key[Prefix::ROW_ID_COUNT];
-		Node::InsertChild(*this, node, byte);
-		return ARTConflictType::NO_CONFLICT;
-	}
-	case NType::NODE_4:
-	case NType::NODE_16:
-	case NType::NODE_48:
-	case NType::NODE_256:
-		return InsertIntoNode(node, key, depth, row_id, status, delete_art);
-	case NType::PREFIX:
-		return Prefix::Insert(*this, node, key, depth, row_id, status, delete_art);
-	default:
-		throw InternalException("Invalid node type for ART::Insert.");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Drop and Delete
-//===--------------------------------------------------------------------===//
-
-void ART::CommitDrop(IndexLock &index_lock) {
-	for (auto &allocator : *allocators) {
-		allocator->Reset();
-	}
-	tree.Clear();
-}
-
-void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
-	auto row_count = input.size();
-
-	DataChunk expr_chunk;
-	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(input, expr_chunk);
-
-	ArenaAllocator allocator(BufferAllocator::Get(db));
-	unsafe_vector<ARTKey> keys(row_count);
-	unsafe_vector<ARTKey> row_id_keys(row_count);
-	GenerateKeyVectors(allocator, expr_chunk, row_ids, keys, row_id_keys);
-
-	for (idx_t i = 0; i < row_count; i++) {
-		if (keys[i].Empty()) {
-			continue;
-		}
-		Erase(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus());
-	}
-
-	if (!tree.HasMetadata()) {
-		// No more allocations.
-		VerifyAllocationsInternal();
-	}
-
-#ifdef DEBUG
-	for (idx_t i = 0; i < row_count; i++) {
-		if (keys[i].Empty()) {
-			continue;
-		}
-		auto leaf = Lookup(tree, keys[i], 0);
-		if (leaf && leaf->GetType() == NType::LEAF_INLINED) {
-			D_ASSERT(leaf->GetRowId() != row_id_keys[i].GetRowId());
-		}
-	}
-#endif
-}
-
-void ART::Erase(Node &node, reference<const ARTKey> key, idx_t depth, reference<const ARTKey> row_id,
-                GateStatus status) {
-	if (!node.HasMetadata()) {
-		return;
-	}
-
-	// Traverse the prefix.
-	reference<Node> next(node);
-	if (next.get().GetType() == NType::PREFIX) {
-		Prefix::TraverseMutable(*this, next, key, depth);
-
-		// Prefixes don't match: nothing to erase.
-		if (next.get().GetType() == NType::PREFIX && next.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
-			return;
-		}
-	}
-
-	//	Delete the row ID from the leaf.
-	//	This is the root node, which can be a leaf with possible prefix nodes.
-	if (next.get().GetType() == NType::LEAF_INLINED) {
-		if (next.get().GetRowId() == row_id.get().GetRowId()) {
-			Node::Free(*this, node);
-		}
-		return;
-	}
-
-	// Transform a deprecated leaf.
-	if (next.get().GetType() == NType::LEAF) {
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		Leaf::TransformToNested(*this, next);
-	}
-
-	// Enter a nested leaf.
-	if (status == GateStatus::GATE_NOT_SET && next.get().GetGateStatus() == GateStatus::GATE_SET) {
-		return Erase(next, row_id, 0, row_id, GateStatus::GATE_SET);
-	}
-
-	D_ASSERT(depth < key.get().len);
-	if (next.get().IsLeafNode()) {
-		auto byte = key.get()[depth];
-		if (next.get().HasByte(*this, byte)) {
-			Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
-		}
-		return;
-	}
-
-	auto child = next.get().GetChildMutable(*this, key.get()[depth]);
-	if (!child) {
-		// No child at the byte: nothing to erase.
-		return;
-	}
-
-	// Transform a deprecated leaf.
-	if (child->GetType() == NType::LEAF) {
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		Leaf::TransformToNested(*this, *child);
-	}
-
-	// Enter a nested leaf.
-	if (status == GateStatus::GATE_NOT_SET && child->GetGateStatus() == GateStatus::GATE_SET) {
-		Erase(*child, row_id, 0, row_id, GateStatus::GATE_SET);
-		if (!child->HasMetadata()) {
-			Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
-		} else {
-			next.get().ReplaceChild(*this, key.get()[depth], *child);
-		}
-		return;
-	}
-
-	auto temp_depth = depth + 1;
-	reference<Node> ref(*child);
-
-	if (ref.get().GetType() == NType::PREFIX) {
-		Prefix::TraverseMutable(*this, ref, key, temp_depth);
-
-		// Prefixes don't match: nothing to erase.
-		if (ref.get().GetType() == NType::PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
-			return;
-		}
-	}
-
-	if (ref.get().GetType() == NType::LEAF_INLINED) {
-		if (ref.get().GetRowId() == row_id.get().GetRowId()) {
-			Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
-		}
-		return;
-	}
-
-	// Recurse.
-	Erase(*child, key, depth + 1, row_id, status);
-	if (!child->HasMetadata()) {
-		Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
-	} else {
-		next.get().ReplaceChild(*this, key.get()[depth], *child);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Point and range lookups
-//===--------------------------------------------------------------------===//
-
-const unsafe_optional_ptr<const Node> ART::Lookup(const Node &node, const ARTKey &key, idx_t depth) {
-	reference<const Node> ref(node);
-	while (ref.get().HasMetadata()) {
-
-		// Return the leaf.
-		if (ref.get().IsAnyLeaf() || ref.get().GetGateStatus() == GateStatus::GATE_SET) {
-			return unsafe_optional_ptr<const Node>(ref.get());
-		}
-
-		// Traverse the prefix.
-		if (ref.get().GetType() == NType::PREFIX) {
-			Prefix::Traverse(*this, ref, key, depth);
-			if (ref.get().GetType() == NType::PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
-				// Prefix mismatch, return nullptr.
-				return nullptr;
-			}
-			continue;
-		}
-
-		// Get the child node.
-		D_ASSERT(depth < key.len);
-		auto child = ref.get().GetChild(*this, key[depth]);
-
-		// No child at the matching byte, return nullptr.
-		if (!child) {
-			return nullptr;
-		}
-
-		// Continue in the child.
-		ref = *child;
-		D_ASSERT(ref.get().HasMetadata());
-		depth++;
-	}
-
-	return nullptr;
-}
-
-bool ART::SearchEqual(ARTKey &key, idx_t max_count, unsafe_vector<row_t> &row_ids) {
-	auto leaf = Lookup(tree, key, 0);
-	if (!leaf) {
-		return true;
-	}
-
-	Iterator it(*this);
-	it.FindMinimum(*leaf);
-	ARTKey empty_key = ARTKey();
-	return it.Scan(empty_key, max_count, row_ids, false);
-}
-
-bool ART::SearchGreater(ARTKey &key, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids) {
-	if (!tree.HasMetadata()) {
-		return true;
-	}
-
-	// Find the lowest value that satisfies the predicate.
-	Iterator it(*this);
-
-	// Early-out, if the maximum value in the ART is lower than the lower bound.
-	if (!it.LowerBound(tree, key, equal, 0)) {
-		return true;
-	}
-
-	// We continue the scan. We do not check the bounds as any value following this value is
-	// greater and satisfies our predicate.
-	return it.Scan(ARTKey(), max_count, row_ids, false);
-}
-
-bool ART::SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids) {
-	if (!tree.HasMetadata()) {
-		return true;
-	}
-
-	// Find the minimum value in the ART: we start scanning from this value.
-	Iterator it(*this);
-	it.FindMinimum(tree);
-
-	// Early-out, if the minimum value is higher than the upper bound.
-	if (it.current_key.GreaterThan(upper_bound, equal, it.GetNestedDepth())) {
-		return true;
-	}
-
-	// Continue the scan until we reach the upper bound.
-	return it.Scan(upper_bound, max_count, row_ids, equal);
-}
-
-bool ART::SearchCloseRange(ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal, bool right_equal, idx_t max_count,
-                           unsafe_vector<row_t> &row_ids) {
-	// Find the first node that satisfies the left predicate.
-	Iterator it(*this);
-
-	// Early-out, if the maximum value in the ART is lower than the lower bound.
-	if (!it.LowerBound(tree, lower_bound, left_equal, 0)) {
-		return true;
-	}
-
-	// Continue the scan until we reach the upper bound.
-	return it.Scan(upper_bound, max_count, row_ids, right_equal);
-}
-
-bool ART::Scan(IndexScanState &state, const idx_t max_count, unsafe_vector<row_t> &row_ids) {
-	auto &scan_state = state.Cast<ARTIndexScanState>();
-	D_ASSERT(scan_state.values[0].type().InternalType() == types[0]);
-	ArenaAllocator arena_allocator(Allocator::Get(db));
-	auto key = ARTKey::CreateKey(arena_allocator, types[0], scan_state.values[0]);
-
-	if (scan_state.values[1].IsNull()) {
-		// Single predicate.
-		lock_guard<mutex> l(lock);
-		switch (scan_state.expressions[0]) {
-		case ExpressionType::COMPARE_EQUAL:
-			return SearchEqual(key, max_count, row_ids);
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			return SearchGreater(key, true, max_count, row_ids);
-		case ExpressionType::COMPARE_GREATERTHAN:
-			return SearchGreater(key, false, max_count, row_ids);
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			return SearchLess(key, true, max_count, row_ids);
-		case ExpressionType::COMPARE_LESSTHAN:
-			return SearchLess(key, false, max_count, row_ids);
-		default:
-			throw InternalException("Index scan type not implemented");
-		}
-	}
-
-	// Two predicates.
-	lock_guard<mutex> l(lock);
-	D_ASSERT(scan_state.values[1].type().InternalType() == types[0]);
-	auto upper_bound = ARTKey::CreateKey(arena_allocator, types[0], scan_state.values[1]);
-	bool left_equal = scan_state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
-	bool right_equal = scan_state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
-	return SearchCloseRange(key, upper_bound, left_equal, right_equal, max_count, row_ids);
-}
-
-//===--------------------------------------------------------------------===//
-// More Constraint Checking
-//===--------------------------------------------------------------------===//
-
-string ART::GenerateErrorKeyName(DataChunk &input, idx_t row_idx) {
-	DataChunk expr_chunk;
-	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(input, expr_chunk);
-
-	string key_name;
-	for (idx_t k = 0; k < expr_chunk.ColumnCount(); k++) {
-		if (k > 0) {
-			key_name += ", ";
-		}
-		key_name += unbound_expressions[k]->GetName() + ": " + expr_chunk.data[k].GetValue(row_idx).ToString();
-	}
-	return key_name;
-}
-
-string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, const string &key_name) {
-	switch (verify_type) {
-	case VerifyExistenceType::APPEND: {
-		// APPEND to PK/UNIQUE table, but node/key already exists in PK/UNIQUE table.
-		string type = IsPrimary() ? "primary key" : "unique";
-		return StringUtil::Format("Duplicate key \"%s\" violates %s constraint.", key_name, type);
-	}
-	case VerifyExistenceType::APPEND_FK: {
-		// APPEND_FK to FK table, node/key does not exist in PK/UNIQUE table.
-		return StringUtil::Format(
-		    "Violates foreign key constraint because key \"%s\" does not exist in the referenced table", key_name);
-	}
-	case VerifyExistenceType::DELETE_FK: {
-		// DELETE_FK that still exists in a FK table, i.e., not a valid delete.
-		return StringUtil::Format("Violates foreign key constraint because key \"%s\" is still referenced by a foreign "
-		                          "key in a different table",
-		                          key_name);
-	}
-	default:
-		throw NotImplementedException("Type not implemented for VerifyExistenceType");
-	}
-}
-
-void ART::VerifyLeaf(const Node &leaf, const ARTKey &key, optional_ptr<ART> delete_art, ConflictManager &manager,
-                     optional_idx &conflict_idx, idx_t i) {
-	// Fast path, the leaf is inlined, and the delete ART does not exist.
-	if (leaf.GetType() == NType::LEAF_INLINED && !delete_art) {
-		if (manager.AddHit(i, leaf.GetRowId())) {
-			conflict_idx = i;
-		}
-		return;
-	}
-
-	// Get the delete_leaf.
-	// All leaves in the delete ART are inlined.
-	auto deleted_leaf = delete_art->Lookup(delete_art->tree, key, 0);
-
-	// The leaf is inlined, and the same key does not exist in the delete ART.
-	if (leaf.GetType() == NType::LEAF_INLINED && !deleted_leaf) {
-		if (manager.AddHit(i, leaf.GetRowId())) {
-			conflict_idx = i;
-		}
-		return;
-	}
-
-	// The leaf is inlined, and the same key exists in the delete ART.
-	if (leaf.GetType() == NType::LEAF_INLINED && deleted_leaf) {
-		auto deleted_row_id = deleted_leaf->GetRowId();
-		auto this_row_id = leaf.GetRowId();
-
-		if (deleted_row_id == this_row_id) {
-			if (manager.AddMiss(i)) {
-				conflict_idx = i;
-			}
-			return;
-		}
-
-		if (manager.AddHit(i, this_row_id)) {
-			conflict_idx = i;
-		}
-		return;
-	}
-
-	// Scan the two row IDs in the leaf.
-	Iterator it(*this);
-	it.FindMinimum(leaf);
-	ARTKey empty_key = ARTKey();
-	unsafe_vector<row_t> row_ids;
-	it.Scan(empty_key, 2, row_ids, false);
-
-	if (!deleted_leaf) {
-		if (manager.AddHit(i, row_ids[0]) || manager.AddHit(i, row_ids[0])) {
-			conflict_idx = i;
-		}
-		return;
-	}
-
-	auto deleted_row_id = deleted_leaf->GetRowId();
-
-	if (deleted_row_id == row_ids[0] || deleted_row_id == row_ids[1]) {
-		if (manager.AddMiss(i)) {
-			conflict_idx = i;
-		}
-		return;
-	}
-
-	if (manager.AddHit(i, row_ids[0]) || manager.AddHit(i, row_ids[1])) {
-		conflict_idx = i;
-	}
-}
-
-void ART::VerifyConstraint(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, ConflictManager &manager) {
-	// Lock the index during constraint checking.
-	lock_guard<mutex> l(lock);
-
-	DataChunk expr_chunk;
-	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(chunk, expr_chunk);
-
-	ArenaAllocator arena_allocator(BufferAllocator::Get(db));
-	unsafe_vector<ARTKey> keys(expr_chunk.size());
-	GenerateKeys<>(arena_allocator, expr_chunk, keys);
-
-	optional_ptr<ART> delete_art;
-	if (delete_index) {
-		delete_art = delete_index->Cast<ART>();
-	}
-
-	optional_idx conflict_idx;
-	for (idx_t i = 0; !conflict_idx.IsValid() && i < chunk.size(); i++) {
-		if (keys[i].Empty()) {
-			if (manager.AddNull(i)) {
-				conflict_idx = i;
-			}
-			continue;
-		}
-
-		auto leaf = Lookup(tree, keys[i], 0);
-		if (!leaf) {
-			if (manager.AddMiss(i)) {
-				conflict_idx = i;
-			}
-			continue;
-		}
-		VerifyLeaf(*leaf, keys[i], delete_art, manager, conflict_idx, i);
-	}
-
-	manager.FinishLookup();
-	if (!conflict_idx.IsValid()) {
-		return;
-	}
-
-	auto key_name = GenerateErrorKeyName(chunk, conflict_idx.GetIndex());
-	auto exception_msg = GenerateConstraintErrorMessage(manager.LookupType(), key_name);
-	throw ConstraintException(exception_msg);
-}
-
-string ART::GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index, DataChunk &input) {
-	auto key_name = GenerateErrorKeyName(input, failed_index);
-	auto exception_msg = GenerateConstraintErrorMessage(verify_type, key_name);
-	return exception_msg;
-}
-
-//===--------------------------------------------------------------------===//
-// Storage and Memory
-//===--------------------------------------------------------------------===//
-
-void ART::TransformToDeprecated() {
-	auto idx = Node::GetAllocatorIdx(NType::PREFIX);
-	auto &block_manager = (*allocators)[idx]->block_manager;
-	unsafe_unique_ptr<FixedSizeAllocator> deprecated_allocator;
-
-	if (prefix_count != Prefix::DEPRECATED_COUNT) {
-		auto prefix_size = NumericCast<idx_t>(Prefix::DEPRECATED_COUNT) + NumericCast<idx_t>(Prefix::METADATA_SIZE);
-		deprecated_allocator = make_unsafe_uniq<FixedSizeAllocator>(prefix_size, block_manager);
-	}
-
-	// Transform all leaves, and possibly the prefixes.
-	if (tree.HasMetadata()) {
-		Node::TransformToDeprecated(*this, tree, deprecated_allocator);
-	}
-
-	// Replace the prefix allocator with the deprecated allocator.
-	if (deprecated_allocator) {
-		prefix_count = Prefix::DEPRECATED_COUNT;
-
-		D_ASSERT((*allocators)[idx]->IsEmpty());
-		(*allocators)[idx]->Reset();
-		(*allocators)[idx] = std::move(deprecated_allocator);
-	}
-}
-
-IndexStorageInfo ART::GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal) {
-	// If the storage format uses deprecated leaf storage,
-	// then we need to transform all nested leaves before serialization.
-	auto v1_0_0_option = options.find("v1_0_0_storage");
-	bool v1_0_0_storage = v1_0_0_option == options.end() || v1_0_0_option->second != Value(false);
-	if (v1_0_0_storage) {
-		TransformToDeprecated();
-	}
-
-	IndexStorageInfo info(name);
-	info.root = tree.Get();
-	info.options = options;
-
-	for (auto &allocator : *allocators) {
-		allocator->RemoveEmptyBuffers();
-	}
-
-#ifdef DEBUG
-	if (v1_0_0_storage) {
-		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::NODE_7_LEAF)]->IsEmpty());
-		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::NODE_15_LEAF)]->IsEmpty());
-		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::NODE_256_LEAF)]->IsEmpty());
-		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::PREFIX)]->GetSegmentSize() ==
-		         Prefix::DEPRECATED_COUNT + Prefix::METADATA_SIZE);
-	}
-#endif
-
-	auto allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
-	if (!to_wal) {
-		// Store the data on disk as partial blocks and set the block ids.
-		WritePartialBlocks(v1_0_0_storage);
-
-	} else {
-		// Set the correct allocation sizes and get the map containing all buffers.
-		for (idx_t i = 0; i < allocator_count; i++) {
-			info.buffers.push_back((*allocators)[i]->InitSerializationToWAL());
-		}
-	}
-
-	for (idx_t i = 0; i < allocator_count; i++) {
-		info.allocator_infos.push_back((*allocators)[i]->GetInfo());
-	}
-	return info;
-}
-
-void ART::WritePartialBlocks(const bool v1_0_0_storage) {
-	auto &block_manager = table_io_manager.GetIndexBlockManager();
-	PartialBlockManager partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT);
-
-	idx_t allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
-	for (idx_t i = 0; i < allocator_count; i++) {
-		(*allocators)[i]->SerializeBuffers(partial_block_manager);
-	}
-	partial_block_manager.FlushPartialBlocks();
-}
-
-void ART::InitAllocators(const IndexStorageInfo &info) {
-	for (idx_t i = 0; i < info.allocator_infos.size(); i++) {
-		(*allocators)[i]->Init(info.allocator_infos[i]);
-	}
-}
-
-void ART::Deserialize(const BlockPointer &pointer) {
-	D_ASSERT(pointer.IsValid());
-
-	auto &metadata_manager = table_io_manager.GetMetadataManager();
-	MetadataReader reader(metadata_manager, pointer);
-	tree = reader.Read<Node>();
-
-	for (idx_t i = 0; i < DEPRECATED_ALLOCATOR_COUNT; i++) {
-		(*allocators)[i]->Deserialize(metadata_manager, reader.Read<BlockPointer>());
-	}
-}
-
-void ART::SetPrefixCount(const IndexStorageInfo &info) {
-	auto numeric_max = NumericLimits<uint8_t>().Maximum();
-	auto max_aligned = AlignValueFloor<uint8_t>(numeric_max - Prefix::METADATA_SIZE);
-
-	if (info.IsValid() && info.root_block_ptr.IsValid()) {
-		prefix_count = Prefix::DEPRECATED_COUNT;
-		return;
-	}
-
-	if (info.IsValid()) {
-		auto serialized_count = info.allocator_infos[0].segment_size - Prefix::METADATA_SIZE;
-		prefix_count = NumericCast<uint8_t>(serialized_count);
-		return;
-	}
-
-	if (!IsUnique()) {
-		prefix_count = Prefix::ROW_ID_COUNT;
-		return;
-	}
-
-	idx_t compound_size = 0;
-	for (const auto &type : types) {
-		compound_size += GetTypeIdSize(type);
-	}
-
-	auto aligned = AlignValue(compound_size) - 1;
-	if (aligned > NumericCast<idx_t>(max_aligned)) {
-		prefix_count = max_aligned;
-		return;
-	}
-
-	prefix_count = NumericCast<uint8_t>(aligned);
-}
-
-idx_t ART::GetInMemorySize(IndexLock &index_lock) {
-	D_ASSERT(owns_data);
-
-	idx_t in_memory_size = 0;
-	for (auto &allocator : *allocators) {
-		in_memory_size += allocator->GetInMemorySize();
-	}
-	return in_memory_size;
-}
-
-//===--------------------------------------------------------------------===//
-// Vacuum
-//===--------------------------------------------------------------------===//
-
-void ART::InitializeVacuum(unordered_set<uint8_t> &indexes) {
-	for (idx_t i = 0; i < allocators->size(); i++) {
-		if ((*allocators)[i]->InitializeVacuum()) {
-			indexes.insert(NumericCast<uint8_t>(i));
-		}
-	}
-}
-
-void ART::FinalizeVacuum(const unordered_set<uint8_t> &indexes) {
-	for (const auto &idx : indexes) {
-		(*allocators)[idx]->FinalizeVacuum();
-	}
-}
-
-void ART::Vacuum(IndexLock &state) {
-	D_ASSERT(owns_data);
-
-	if (!tree.HasMetadata()) {
-		for (auto &allocator : *allocators) {
-			allocator->Reset();
-		}
-		return;
-	}
-
-	// True, if an allocator needs a vacuum, false otherwise.
-	unordered_set<uint8_t> indexes;
-	InitializeVacuum(indexes);
-
-	// Skip vacuum, if no allocators require it.
-	if (indexes.empty()) {
-		return;
-	}
-
-	// Traverse the allocated memory of the tree to perform a vacuum.
-	tree.Vacuum(*this, indexes);
-
-	// Finalize the vacuum operation.
-	FinalizeVacuum(indexes);
-}
-
-//===--------------------------------------------------------------------===//
-// Merging
-//===--------------------------------------------------------------------===//
-
-void ART::InitializeMerge(unsafe_vector<idx_t> &upper_bounds) {
-	D_ASSERT(owns_data);
-	for (auto &allocator : *allocators) {
-		upper_bounds.emplace_back(allocator->GetUpperBoundBufferId());
-	}
-}
-
-bool ART::MergeIndexes(IndexLock &state, BoundIndex &other_index) {
-	auto &other_art = other_index.Cast<ART>();
-	if (!other_art.tree.HasMetadata()) {
-		return true;
-	}
-
-	if (other_art.owns_data) {
-		if (tree.HasMetadata()) {
-			// Fully deserialize other_index, and traverse it to increment its buffer IDs.
-			unsafe_vector<idx_t> upper_bounds;
-			InitializeMerge(upper_bounds);
-			other_art.tree.InitMerge(other_art, upper_bounds);
-		}
-
-		// Merge the node storage.
-		for (idx_t i = 0; i < allocators->size(); i++) {
-			(*allocators)[i]->Merge(*(*other_art.allocators)[i]);
-		}
-	}
-
-	// Merge the ARTs.
-	D_ASSERT(tree.GetGateStatus() == other_art.tree.GetGateStatus());
-	if (!tree.Merge(*this, other_art.tree, tree.GetGateStatus())) {
-		return false;
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Verification
-//===--------------------------------------------------------------------===//
-
-string ART::VerifyAndToString(IndexLock &state, const bool only_verify) {
-	return VerifyAndToStringInternal(only_verify);
-}
-
-string ART::VerifyAndToStringInternal(const bool only_verify) {
-	if (tree.HasMetadata()) {
-		return "ART: " + tree.VerifyAndToString(*this, only_verify);
-	}
-	return "[empty]";
-}
-
-void ART::VerifyAllocations(IndexLock &state) {
-	return VerifyAllocationsInternal();
-}
-
-void ART::VerifyAllocationsInternal() {
-#ifdef DEBUG
-	unordered_map<uint8_t, idx_t> node_counts;
-	for (idx_t i = 0; i < allocators->size(); i++) {
-		node_counts[NumericCast<uint8_t>(i)] = 0;
-	}
-
-	if (tree.HasMetadata()) {
-		tree.VerifyAllocations(*this, node_counts);
-	}
-
-	for (idx_t i = 0; i < allocators->size(); i++) {
-		auto segment_count = (*allocators)[i]->GetSegmentCount();
-		D_ASSERT(segment_count == node_counts[NumericCast<uint8_t>(i)]);
-	}
-#endif
-}
-
-constexpr const char *ART::TYPE_NAME;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/art_key.cpp b/src/duckdb/src/execution/index/art/art_key.cpp
deleted file mode 100644
index d5769f0f5..000000000
--- a/src/duckdb/src/execution/index/art/art_key.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#include "duckdb/execution/index/art/art_key.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// ARTKey
-//===--------------------------------------------------------------------===//
-
-ARTKey::ARTKey() : len(0) {
-}
-
-ARTKey::ARTKey(const data_ptr_t data, idx_t len) : len(len), data(data) {
-}
-
-ARTKey::ARTKey(ArenaAllocator &allocator, idx_t len) : len(len) {
-	data = allocator.Allocate(len);
-}
-
-template <>
-ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, string_t value) {
-	auto string_data = const_data_ptr_cast(value.GetData());
-	auto string_len = value.GetSize();
-
-	// We escape \00 and \01.
-	idx_t escape_count = 0;
-	for (idx_t i = 0; i < string_len; i++) {
-		if (string_data[i] <= 1) {
-			escape_count++;
-		}
-	}
-
-	idx_t len = string_len + escape_count + 1;
-	auto data = allocator.Allocate(len);
-
-	// Copy over the data and add escapes.
-	idx_t pos = 0;
-	for (idx_t i = 0; i < string_len; i++) {
-		if (string_data[i] <= 1) {
-			// Add escape.
-			data[pos++] = '\01';
-		}
-		data[pos++] = string_data[i];
-	}
-
-	// End with a null-terminator.
-	data[pos] = '\0';
-	return ARTKey(data, len);
-}
-
-template <>
-ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const char *value) {
-	return ARTKey::CreateARTKey(allocator, string_t(value, UnsafeNumericCast<uint32_t>(strlen(value))));
-}
-
-template <>
-void ARTKey::CreateARTKey(ArenaAllocator &allocator, ARTKey &key, string_t value) {
-	key = ARTKey::CreateARTKey<string_t>(allocator, value);
-}
-
-template <>
-void ARTKey::CreateARTKey(ArenaAllocator &allocator, ARTKey &key, const char *value) {
-	ARTKey::CreateARTKey(allocator, key, string_t(value, UnsafeNumericCast<uint32_t>(strlen(value))));
-}
-
-ARTKey ARTKey::CreateKey(ArenaAllocator &allocator, PhysicalType type, Value &value) {
-	D_ASSERT(type == value.type().InternalType());
-	switch (type) {
-	case PhysicalType::BOOL:
-		return ARTKey::CreateARTKey<bool>(allocator, value);
-	case PhysicalType::INT8:
-		return ARTKey::CreateARTKey<int8_t>(allocator, value);
-	case PhysicalType::INT16:
-		return ARTKey::CreateARTKey<int16_t>(allocator, value);
-	case PhysicalType::INT32:
-		return ARTKey::CreateARTKey<int32_t>(allocator, value);
-	case PhysicalType::INT64:
-		return ARTKey::CreateARTKey<int64_t>(allocator, value);
-	case PhysicalType::UINT8:
-		return ARTKey::CreateARTKey<uint8_t>(allocator, value);
-	case PhysicalType::UINT16:
-		return ARTKey::CreateARTKey<uint16_t>(allocator, value);
-	case PhysicalType::UINT32:
-		return ARTKey::CreateARTKey<uint32_t>(allocator, value);
-	case PhysicalType::UINT64:
-		return ARTKey::CreateARTKey<uint64_t>(allocator, value);
-	case PhysicalType::INT128:
-		return ARTKey::CreateARTKey<hugeint_t>(allocator, value);
-	case PhysicalType::UINT128:
-		return ARTKey::CreateARTKey<uhugeint_t>(allocator, value);
-	case PhysicalType::FLOAT:
-		return ARTKey::CreateARTKey<float>(allocator, value);
-	case PhysicalType::DOUBLE:
-		return ARTKey::CreateARTKey<double>(allocator, value);
-	case PhysicalType::VARCHAR:
-		return ARTKey::CreateARTKey<string_t>(allocator, value);
-	default:
-		throw InternalException("Invalid type for the ART key.");
-	}
-}
-
-bool ARTKey::operator>(const ARTKey &key) const {
-	for (idx_t i = 0; i < MinValue(len, key.len); i++) {
-		if (data[i] > key.data[i]) {
-			return true;
-		} else if (data[i] < key.data[i]) {
-			return false;
-		}
-	}
-	return len > key.len;
-}
-
-bool ARTKey::operator>=(const ARTKey &key) const {
-	for (idx_t i = 0; i < MinValue(len, key.len); i++) {
-		if (data[i] > key.data[i]) {
-			return true;
-		} else if (data[i] < key.data[i]) {
-			return false;
-		}
-	}
-	return len >= key.len;
-}
-
-bool ARTKey::operator==(const ARTKey &key) const {
-	if (len != key.len) {
-		return false;
-	}
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] != key.data[i]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void ARTKey::Concat(ArenaAllocator &allocator, const ARTKey &other) {
-	auto compound_data = allocator.Allocate(len + other.len);
-	memcpy(compound_data, data, len);
-	memcpy(compound_data + len, other.data, other.len);
-	len += other.len;
-	data = compound_data;
-}
-
-row_t ARTKey::GetRowId() const {
-	D_ASSERT(len == sizeof(row_t));
-	return Radix::DecodeData<row_t>(data);
-}
-
-idx_t ARTKey::GetMismatchPos(const ARTKey &other, const idx_t start) const {
-	D_ASSERT(len <= other.len);
-	D_ASSERT(start <= len);
-	for (idx_t i = start; i < other.len; i++) {
-		if (data[i] != other.data[i]) {
-			return i;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-//===--------------------------------------------------------------------===//
-// ARTKeySection
-//===--------------------------------------------------------------------===//
-
-ARTKeySection::ARTKeySection(idx_t start, idx_t end, idx_t depth, data_t byte)
-    : start(start), end(end), depth(depth), key_byte(byte) {
-}
-
-ARTKeySection::ARTKeySection(idx_t start, idx_t end, const unsafe_vector<ARTKey> &keys, const ARTKeySection &section)
-    : start(start), end(end), depth(section.depth + 1), key_byte(keys[end].data[section.depth]) {
-}
-
-void ARTKeySection::GetChildSections(unsafe_vector<ARTKeySection> &sections, const unsafe_vector<ARTKey> &keys) {
-	auto child_idx = start;
-	for (idx_t i = start + 1; i <= end; i++) {
-		if (keys[i - 1].data[depth] != keys[i].data[depth]) {
-			sections.emplace_back(child_idx, i - 1, keys, *this);
-			child_idx = i;
-		}
-	}
-	sections.emplace_back(child_idx, end, keys, *this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/base_leaf.cpp b/src/duckdb/src/execution/index/art/base_leaf.cpp
deleted file mode 100644
index 5034a0399..000000000
--- a/src/duckdb/src/execution/index/art/base_leaf.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#include "duckdb/execution/index/art/base_leaf.hpp"
-
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/base_node.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
-#include "duckdb/execution/index/art/node256_leaf.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// BaseLeaf
-//===--------------------------------------------------------------------===//
-
-template <uint8_t CAPACITY, NType TYPE>
-void BaseLeaf<CAPACITY, TYPE>::InsertByteInternal(BaseLeaf &n, const uint8_t byte) {
-	// Still space. Insert the child.
-	uint8_t child_pos = 0;
-	while (child_pos < n.count && n.key[child_pos] < byte) {
-		child_pos++;
-	}
-
-	// Move children backwards to make space.
-	for (uint8_t i = n.count; i > child_pos; i--) {
-		n.key[i] = n.key[i - 1];
-	}
-
-	n.key[child_pos] = byte;
-	n.count++;
-}
-
-template <uint8_t CAPACITY, NType TYPE>
-BaseLeaf<CAPACITY, TYPE> &BaseLeaf<CAPACITY, TYPE>::DeleteByteInternal(ART &art, Node &node, const uint8_t byte) {
-	auto &n = Node::Ref<BaseLeaf>(art, node, node.GetType());
-	uint8_t child_pos = 0;
-
-	for (; child_pos < n.count; child_pos++) {
-		if (n.key[child_pos] == byte) {
-			break;
-		}
-	}
-	n.count--;
-
-	// Possibly move children backwards.
-	for (uint8_t i = child_pos; i < n.count; i++) {
-		n.key[i] = n.key[i + 1];
-	}
-	return n;
-}
-
-//===--------------------------------------------------------------------===//
-// Node7Leaf
-//===--------------------------------------------------------------------===//
-
-void Node7Leaf::InsertByte(ART &art, Node &node, const uint8_t byte) {
-	// The node is full. Grow to Node15.
-	auto &n7 = Node::Ref<Node7Leaf>(art, node, NODE_7_LEAF);
-	if (n7.count == CAPACITY) {
-		auto node7 = node;
-		Node15Leaf::GrowNode7Leaf(art, node, node7);
-		Node15Leaf::InsertByte(art, node, byte);
-		return;
-	}
-
-	// Still space. Insert the child.
-	uint8_t child_pos = 0;
-	while (child_pos < n7.count && n7.key[child_pos] < byte) {
-		child_pos++;
-	}
-
-	InsertByteInternal(n7, byte);
-}
-
-void Node7Leaf::DeleteByte(ART &art, Node &node, Node &prefix, const uint8_t byte, const ARTKey &row_id) {
-	auto &n7 = DeleteByteInternal(art, node, byte);
-
-	// Compress one-way nodes.
-	if (n7.count == 1) {
-		D_ASSERT(node.GetGateStatus() == GateStatus::GATE_NOT_SET);
-
-		// Get the remaining row ID.
-		auto remainder = UnsafeNumericCast<idx_t>(row_id.GetRowId()) & AND_LAST_BYTE;
-		remainder |= UnsafeNumericCast<idx_t>(n7.key[0]);
-
-		n7.count--;
-		Node::Free(art, node);
-
-		if (prefix.GetType() == NType::PREFIX) {
-			Node::Free(art, prefix);
-			Leaf::New(prefix, UnsafeNumericCast<row_t>(remainder));
-		} else {
-			Leaf::New(node, UnsafeNumericCast<row_t>(remainder));
-		}
-	}
-}
-
-void Node7Leaf::ShrinkNode15Leaf(ART &art, Node &node7_leaf, Node &node15_leaf) {
-	auto &n7 = New(art, node7_leaf);
-	auto &n15 = Node::Ref<Node15Leaf>(art, node15_leaf, NType::NODE_15_LEAF);
-	node7_leaf.SetGateStatus(node15_leaf.GetGateStatus());
-
-	n7.count = n15.count;
-	for (uint8_t i = 0; i < n15.count; i++) {
-		n7.key[i] = n15.key[i];
-	}
-
-	n15.count = 0;
-	Node::Free(art, node15_leaf);
-}
-
-//===--------------------------------------------------------------------===//
-// Node15Leaf
-//===--------------------------------------------------------------------===//
-
-void Node15Leaf::InsertByte(ART &art, Node &node, const uint8_t byte) {
-	// The node is full. Grow to Node256Leaf.
-	auto &n15 = Node::Ref<Node15Leaf>(art, node, NODE_15_LEAF);
-	if (n15.count == CAPACITY) {
-		auto node15 = node;
-		Node256Leaf::GrowNode15Leaf(art, node, node15);
-		Node256Leaf::InsertByte(art, node, byte);
-		return;
-	}
-
-	InsertByteInternal(n15, byte);
-}
-
-void Node15Leaf::DeleteByte(ART &art, Node &node, const uint8_t byte) {
-	auto &n15 = DeleteByteInternal(art, node, byte);
-
-	// Shrink node to Node7.
-	if (n15.count < Node7Leaf::CAPACITY) {
-		auto node15 = node;
-		Node7Leaf::ShrinkNode15Leaf(art, node, node15);
-	}
-}
-
-void Node15Leaf::GrowNode7Leaf(ART &art, Node &node15_leaf, Node &node7_leaf) {
-	auto &n7 = Node::Ref<Node7Leaf>(art, node7_leaf, NType::NODE_7_LEAF);
-	auto &n15 = New(art, node15_leaf);
-	node15_leaf.SetGateStatus(node7_leaf.GetGateStatus());
-
-	n15.count = n7.count;
-	for (uint8_t i = 0; i < n7.count; i++) {
-		n15.key[i] = n7.key[i];
-	}
-
-	n7.count = 0;
-	Node::Free(art, node7_leaf);
-}
-
-void Node15Leaf::ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_leaf) {
-	auto &n15 = New(art, node15_leaf);
-	auto &n256 = Node::Ref<Node256Leaf>(art, node256_leaf, NType::NODE_256_LEAF);
-	node15_leaf.SetGateStatus(node256_leaf.GetGateStatus());
-
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		if (mask.RowIsValid(i)) {
-			n15.key[n15.count] = UnsafeNumericCast<uint8_t>(i);
-			n15.count++;
-		}
-	}
-
-	Node::Free(art, node256_leaf);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/base_node.cpp b/src/duckdb/src/execution/index/art/base_node.cpp
deleted file mode 100644
index 228d12e80..000000000
--- a/src/duckdb/src/execution/index/art/base_node.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/execution/index/art/base_node.hpp"
-
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// BaseNode
-//===--------------------------------------------------------------------===//
-
-template <uint8_t CAPACITY, NType TYPE>
-void BaseNode<CAPACITY, TYPE>::InsertChildInternal(BaseNode &n, const uint8_t byte, const Node child) {
-	// Still space. Insert the child.
-	uint8_t child_pos = 0;
-	while (child_pos < n.count && n.key[child_pos] < byte) {
-		child_pos++;
-	}
-
-	// Move children backwards to make space.
-	for (uint8_t i = n.count; i > child_pos; i--) {
-		n.key[i] = n.key[i - 1];
-		n.children[i] = n.children[i - 1];
-	}
-
-	n.key[child_pos] = byte;
-	n.children[child_pos] = child;
-	n.count++;
-}
-
-template <uint8_t CAPACITY, NType TYPE>
-BaseNode<CAPACITY, TYPE> &BaseNode<CAPACITY, TYPE>::DeleteChildInternal(ART &art, Node &node, const uint8_t byte) {
-	auto &n = Node::Ref<BaseNode>(art, node, TYPE);
-
-	uint8_t child_pos = 0;
-	for (; child_pos < n.count; child_pos++) {
-		if (n.key[child_pos] == byte) {
-			break;
-		}
-	}
-
-	// Free the child and decrease the count.
-	Node::Free(art, n.children[child_pos]);
-	n.count--;
-
-	// Possibly move children backwards.
-	for (uint8_t i = child_pos; i < n.count; i++) {
-		n.key[i] = n.key[i + 1];
-		n.children[i] = n.children[i + 1];
-	}
-	return n;
-}
-
-//===--------------------------------------------------------------------===//
-// Node4
-//===--------------------------------------------------------------------===//
-
-void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	// The node is full. Grow to Node16.
-	auto &n = Node::Ref<Node4>(art, node, NODE_4);
-	if (n.count == CAPACITY) {
-		auto node4 = node;
-		Node16::GrowNode4(art, node, node4);
-		Node16::InsertChild(art, node, byte, child);
-		return;
-	}
-
-	InsertChildInternal(n, byte, child);
-}
-
-void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, const GateStatus status) {
-	auto &n = DeleteChildInternal(art, node, byte);
-
-	// Compress one-way nodes.
-	if (n.count == 1) {
-		n.count--;
-
-		auto child = n.children[0];
-		auto remainder = n.key[0];
-		auto old_status = node.GetGateStatus();
-
-		Node::Free(art, node);
-		Prefix::Concat(art, prefix, remainder, old_status, child, status);
-	}
-}
-
-void Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
-	auto &n4 = New(art, node4);
-	auto &n16 = Node::Ref<Node16>(art, node16, NType::NODE_16);
-	node4.SetGateStatus(node16.GetGateStatus());
-
-	n4.count = n16.count;
-	for (uint8_t i = 0; i < n16.count; i++) {
-		n4.key[i] = n16.key[i];
-		n4.children[i] = n16.children[i];
-	}
-
-	n16.count = 0;
-	Node::Free(art, node16);
-}
-
-//===--------------------------------------------------------------------===//
-// Node16
-//===--------------------------------------------------------------------===//
-
-void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-	auto &n = DeleteChildInternal(art, node, byte);
-
-	// Shrink node to Node4.
-	if (n.count < Node4::CAPACITY) {
-		auto node16 = node;
-		Node4::ShrinkNode16(art, node, node16);
-	}
-}
-
-void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	// The node is full. Grow to Node48.
-	auto &n16 = Node::Ref<Node16>(art, node, NODE_16);
-	if (n16.count == CAPACITY) {
-		auto node16 = node;
-		Node48::GrowNode16(art, node, node16);
-		Node48::InsertChild(art, node, byte, child);
-		return;
-	}
-
-	InsertChildInternal(n16, byte, child);
-}
-
-void Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
-	auto &n4 = Node::Ref<Node4>(art, node4, NType::NODE_4);
-	auto &n16 = New(art, node16);
-	node16.SetGateStatus(node4.GetGateStatus());
-
-	n16.count = n4.count;
-	for (uint8_t i = 0; i < n4.count; i++) {
-		n16.key[i] = n4.key[i];
-		n16.children[i] = n4.children[i];
-	}
-
-	n4.count = 0;
-	Node::Free(art, node4);
-}
-
-void Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
-	auto &n16 = New(art, node16);
-	auto &n48 = Node::Ref<Node48>(art, node48, NType::NODE_48);
-	node16.SetGateStatus(node48.GetGateStatus());
-
-	n16.count = 0;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		if (n48.child_index[i] != Node48::EMPTY_MARKER) {
-			n16.key[n16.count] = UnsafeNumericCast<uint8_t>(i);
-			n16.children[n16.count] = n48.children[n48.child_index[i]];
-			n16.count++;
-		}
-	}
-
-	n48.count = 0;
-	Node::Free(art, node48);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/iterator.cpp b/src/duckdb/src/execution/index/art/iterator.cpp
deleted file mode 100644
index 689029a02..000000000
--- a/src/duckdb/src/execution/index/art/iterator.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-#include "duckdb/execution/index/art/iterator.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// IteratorKey
-//===--------------------------------------------------------------------===//
-
-bool IteratorKey::Contains(const ARTKey &key) const {
-	if (Size() < key.len) {
-		return false;
-	}
-	for (idx_t i = 0; i < key.len; i++) {
-		if (key_bytes[i] != key.data[i]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool IteratorKey::GreaterThan(const ARTKey &key, const bool equal, const uint8_t nested_depth) const {
-	for (idx_t i = 0; i < MinValue<idx_t>(Size(), key.len); i++) {
-		if (key_bytes[i] > key.data[i]) {
-			return true;
-		} else if (key_bytes[i] < key.data[i]) {
-			return false;
-		}
-	}
-
-	// Returns true, if current_key is greater than (or equal to) key.
-	D_ASSERT(Size() >= nested_depth);
-	auto this_len = Size() - nested_depth;
-	return equal ? this_len > key.len : this_len >= key.len;
-}
-
-//===--------------------------------------------------------------------===//
-// Iterator
-//===--------------------------------------------------------------------===//
-
-bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, unsafe_vector<row_t> &row_ids, const bool equal) {
-	bool has_next;
-	do {
-		// An empty upper bound indicates that no upper bound exists.
-		if (!upper_bound.Empty() && status == GateStatus::GATE_NOT_SET) {
-			if (current_key.GreaterThan(upper_bound, equal, nested_depth)) {
-				return true;
-			}
-		}
-
-		switch (last_leaf.GetType()) {
-		case NType::LEAF_INLINED:
-			if (row_ids.size() + 1 > max_count) {
-				return false;
-			}
-			row_ids.push_back(last_leaf.GetRowId());
-			break;
-		case NType::LEAF:
-			if (!Leaf::DeprecatedGetRowIds(art, last_leaf, row_ids, max_count)) {
-				return false;
-			}
-			break;
-		case NType::NODE_7_LEAF:
-		case NType::NODE_15_LEAF:
-		case NType::NODE_256_LEAF: {
-			uint8_t byte = 0;
-			while (last_leaf.GetNextByte(art, byte)) {
-				if (row_ids.size() + 1 > max_count) {
-					return false;
-				}
-				row_id[ROW_ID_SIZE - 1] = byte;
-				ARTKey key(&row_id[0], ROW_ID_SIZE);
-				row_ids.push_back(key.GetRowId());
-				if (byte == NumericLimits<uint8_t>::Maximum()) {
-					break;
-				}
-				byte++;
-			}
-			break;
-		}
-		default:
-			throw InternalException("Invalid leaf type for index scan.");
-		}
-
-		has_next = Next();
-	} while (has_next);
-	return true;
-}
-
-void Iterator::FindMinimum(const Node &node) {
-	D_ASSERT(node.HasMetadata());
-
-	// Found the minimum.
-	if (node.IsAnyLeaf()) {
-		last_leaf = node;
-		return;
-	}
-
-	// We are passing a gate node.
-	if (node.GetGateStatus() == GateStatus::GATE_SET) {
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		status = GateStatus::GATE_SET;
-		nested_depth = 0;
-	}
-
-	// Traverse the prefix.
-	if (node.GetType() == NType::PREFIX) {
-		Prefix prefix(art, node);
-		for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
-			current_key.Push(prefix.data[i]);
-			if (status == GateStatus::GATE_SET) {
-				row_id[nested_depth] = prefix.data[i];
-				nested_depth++;
-				D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
-			}
-		}
-		nodes.emplace(node, 0);
-		return FindMinimum(*prefix.ptr);
-	}
-
-	// Go to the leftmost entry in the current node.
-	uint8_t byte = 0;
-	auto next = node.GetNextChild(art, byte);
-	D_ASSERT(next);
-
-	// Recurse on the leftmost node.
-	current_key.Push(byte);
-	if (status == GateStatus::GATE_SET) {
-		row_id[nested_depth] = byte;
-		nested_depth++;
-		D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
-	}
-	nodes.emplace(node, byte);
-	FindMinimum(*next);
-}
-
-bool Iterator::LowerBound(const Node &node, const ARTKey &key, const bool equal, idx_t depth) {
-	if (!node.HasMetadata()) {
-		return false;
-	}
-
-	// We found any leaf node, or a gate.
-	if (node.IsAnyLeaf() || node.GetGateStatus() == GateStatus::GATE_SET) {
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		D_ASSERT(current_key.Size() == key.len);
-		if (!equal && current_key.Contains(key)) {
-			return Next();
-		}
-
-		if (node.GetGateStatus() == GateStatus::GATE_SET) {
-			FindMinimum(node);
-		} else {
-			last_leaf = node;
-		}
-		return true;
-	}
-
-	D_ASSERT(node.GetGateStatus() == GateStatus::GATE_NOT_SET);
-	if (node.GetType() != NType::PREFIX) {
-		auto next_byte = key[depth];
-		auto child = node.GetNextChild(art, next_byte);
-
-		// The key is greater than any key in this subtree.
-		if (!child) {
-			return Next();
-		}
-
-		current_key.Push(next_byte);
-		nodes.emplace(node, next_byte);
-
-		// We return the minimum because all keys are greater than the lower bound.
-		if (next_byte > key[depth]) {
-			FindMinimum(*child);
-			return true;
-		}
-
-		// We recurse into the child.
-		return LowerBound(*child, key, equal, depth + 1);
-	}
-
-	// Push back all prefix bytes.
-	Prefix prefix(art, node);
-	for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
-		current_key.Push(prefix.data[i]);
-	}
-	nodes.emplace(node, 0);
-
-	// We compare the prefix bytes with the key bytes.
-	for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
-		// We found a prefix byte that is less than its corresponding key byte.
-		// I.e., the subsequent node is lesser than the key. Thus, the next node
-		// is the lower bound.
-		if (prefix.data[i] < key[depth + i]) {
-			return Next();
-		}
-
-		// We found a prefix byte that is greater than its corresponding key byte.
-		// I.e., the subsequent node is greater than the key. Thus, the minimum is
-		// the lower bound.
-		if (prefix.data[i] > key[depth + i]) {
-			FindMinimum(*prefix.ptr);
-			return true;
-		}
-	}
-
-	// The prefix matches the key. We recurse into the child.
-	depth += prefix.data[Prefix::Count(art)];
-	return LowerBound(*prefix.ptr, key, equal, depth);
-}
-
-bool Iterator::Next() {
-	while (!nodes.empty()) {
-		auto &top = nodes.top();
-		D_ASSERT(!top.node.IsAnyLeaf());
-
-		if (top.node.GetType() == NType::PREFIX) {
-			PopNode();
-			continue;
-		}
-
-		if (top.byte == NumericLimits<uint8_t>::Maximum()) {
-			// No more children of this node.
-			// Move up the tree by popping the key byte of the current node.
-			PopNode();
-			continue;
-		}
-
-		top.byte++;
-		auto next_node = top.node.GetNextChild(art, top.byte);
-		if (!next_node) {
-			// No more children of this node.
-			// Move up the tree by popping the key byte of the current node.
-			PopNode();
-			continue;
-		}
-
-		current_key.Pop(1);
-		current_key.Push(top.byte);
-		if (status == GateStatus::GATE_SET) {
-			row_id[nested_depth - 1] = top.byte;
-		}
-
-		FindMinimum(*next_node);
-		return true;
-	}
-	return false;
-}
-
-void Iterator::PopNode() {
-	auto gate_status = nodes.top().node.GetGateStatus();
-
-	// Pop the byte and the node.
-	if (nodes.top().node.GetType() != NType::PREFIX) {
-		current_key.Pop(1);
-		if (status == GateStatus::GATE_SET) {
-			nested_depth--;
-			D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
-		}
-
-	} else {
-		// Pop all prefix bytes and the node.
-		Prefix prefix(art, nodes.top().node);
-		auto prefix_byte_count = prefix.data[Prefix::Count(art)];
-		current_key.Pop(prefix_byte_count);
-
-		if (status == GateStatus::GATE_SET) {
-			nested_depth -= prefix_byte_count;
-			D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
-		}
-	}
-	nodes.pop();
-
-	// We are popping a gate node.
-	if (gate_status == GateStatus::GATE_SET) {
-		D_ASSERT(status == GateStatus::GATE_SET);
-		status = GateStatus::GATE_NOT_SET;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/leaf.cpp b/src/duckdb/src/execution/index/art/leaf.cpp
deleted file mode 100644
index 5cde0d5d0..000000000
--- a/src/duckdb/src/execution/index/art/leaf.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "duckdb/execution/index/art/leaf.hpp"
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/base_leaf.hpp"
-#include "duckdb/execution/index/art/base_node.hpp"
-#include "duckdb/execution/index/art/iterator.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
-
-namespace duckdb {
-
-void Leaf::New(Node &node, const row_t row_id) {
-	D_ASSERT(row_id < MAX_ROW_ID_LOCAL);
-	node.Clear();
-	node.SetMetadata(static_cast<uint8_t>(INLINED));
-	node.SetRowId(row_id);
-}
-
-void Leaf::New(ART &art, reference<Node> &node, const unsafe_vector<ARTKey> &row_ids, const idx_t start,
-               const idx_t count) {
-	D_ASSERT(count > 1);
-	D_ASSERT(!node.get().HasMetadata());
-
-	// We cannot recurse into the leaf during Construct(...) because row IDs are not sorted.
-	for (idx_t i = 0; i < count; i++) {
-		idx_t offset = start + i;
-		art.Insert(node, row_ids[offset], 0, row_ids[offset], GateStatus::GATE_SET, nullptr);
-	}
-	node.get().SetGateStatus(GateStatus::GATE_SET);
-}
-
-void Leaf::MergeInlined(ART &art, Node &l_node, Node &r_node) {
-	D_ASSERT(r_node.GetType() == INLINED);
-
-	ArenaAllocator arena_allocator(Allocator::Get(art.db));
-	auto key = ARTKey::CreateARTKey<row_t>(arena_allocator, r_node.GetRowId());
-	art.Insert(l_node, key, 0, key, l_node.GetGateStatus(), nullptr);
-	r_node.Clear();
-}
-
-void Leaf::InsertIntoInlined(ART &art, Node &node, const ARTKey &row_id, idx_t depth, const GateStatus status) {
-	D_ASSERT(node.GetType() == INLINED);
-
-	ArenaAllocator allocator(Allocator::Get(art.db));
-	auto key = ARTKey::CreateARTKey<row_t>(allocator, node.GetRowId());
-
-	GateStatus new_status;
-	if (status == GateStatus::GATE_NOT_SET || node.GetGateStatus() == GateStatus::GATE_SET) {
-		new_status = GateStatus::GATE_SET;
-	} else {
-		new_status = GateStatus::GATE_NOT_SET;
-	}
-
-	if (new_status == GateStatus::GATE_SET) {
-		depth = 0;
-	}
-	node.Clear();
-
-	// Get the mismatching position.
-	D_ASSERT(row_id.len == key.len);
-	auto pos = row_id.GetMismatchPos(key, depth);
-	D_ASSERT(pos != DConstants::INVALID_INDEX);
-	D_ASSERT(pos >= depth);
-	auto byte = row_id.data[pos];
-
-	// Create the (optional) prefix and the node.
-	reference<Node> next(node);
-	auto count = pos - depth;
-	if (count != 0) {
-		Prefix::New(art, next, row_id, depth, count);
-	}
-	if (pos == Prefix::ROW_ID_COUNT) {
-		Node7Leaf::New(art, next);
-	} else {
-		Node4::New(art, next);
-	}
-
-	// Create the children.
-	Node row_id_node;
-	Leaf::New(row_id_node, row_id.GetRowId());
-	Node remainder;
-	if (pos != Prefix::ROW_ID_COUNT) {
-		Leaf::New(remainder, key.GetRowId());
-	}
-
-	Node::InsertChild(art, next, key[pos], remainder);
-	Node::InsertChild(art, next, byte, row_id_node);
-	node.SetGateStatus(new_status);
-}
-
-void Leaf::TransformToNested(ART &art, Node &node) {
-	D_ASSERT(node.GetType() == LEAF);
-
-	ArenaAllocator allocator(Allocator::Get(art.db));
-	Node root = Node();
-
-	// Temporarily disable constraint checking.
-	if (art.IsUnique() && art.append_mode == ARTAppendMode::DEFAULT) {
-		art.append_mode = ARTAppendMode::INSERT_DUPLICATES;
-	}
-
-	// Move all row IDs into the nested leaf.
-	reference<const Node> leaf_ref(node);
-	while (leaf_ref.get().HasMetadata()) {
-		auto &leaf = Node::Ref<const Leaf>(art, leaf_ref, LEAF);
-		for (uint8_t i = 0; i < leaf.count; i++) {
-			auto row_id = ARTKey::CreateARTKey<row_t>(allocator, leaf.row_ids[i]);
-			auto conflict_type = art.Insert(root, row_id, 0, row_id, GateStatus::GATE_SET, nullptr);
-			if (conflict_type != ARTConflictType::NO_CONFLICT) {
-				throw InternalException("invalid conflict type in Leaf::TransformToNested");
-			}
-		}
-		leaf_ref = leaf.ptr;
-	}
-
-	art.append_mode = ARTAppendMode::DEFAULT;
-	root.SetGateStatus(GateStatus::GATE_SET);
-	Node::Free(art, node);
-	node = root;
-}
-
-void Leaf::TransformToDeprecated(ART &art, Node &node) {
-	D_ASSERT(node.GetGateStatus() == GateStatus::GATE_SET || node.GetType() == LEAF);
-
-	// Early-out, if we never transformed this leaf.
-	if (node.GetGateStatus() == GateStatus::GATE_NOT_SET) {
-		return;
-	}
-
-	// Collect all row IDs and free the nested leaf.
-	unsafe_vector<row_t> row_ids;
-	Iterator it(art);
-	it.FindMinimum(node);
-	ARTKey empty_key = ARTKey();
-	it.Scan(empty_key, NumericLimits<row_t>().Maximum(), row_ids, false);
-	Node::Free(art, node);
-	D_ASSERT(row_ids.size() > 1);
-
-	// Create the deprecated leaves.
-	idx_t remaining = row_ids.size();
-	idx_t copy_count = 0;
-	reference<Node> ref(node);
-	while (remaining) {
-		ref.get() = Node::GetAllocator(art, LEAF).New();
-		ref.get().SetMetadata(static_cast<uint8_t>(LEAF));
-
-		auto &leaf = Node::Ref<Leaf>(art, ref, LEAF);
-		auto min = MinValue(UnsafeNumericCast<idx_t>(LEAF_SIZE), remaining);
-		leaf.count = UnsafeNumericCast<uint8_t>(min);
-
-		for (uint8_t i = 0; i < leaf.count; i++) {
-			leaf.row_ids[i] = row_ids[copy_count + i];
-		}
-
-		copy_count += leaf.count;
-		remaining -= leaf.count;
-
-		ref = leaf.ptr;
-		leaf.ptr.Clear();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Deprecated code paths.
-//===--------------------------------------------------------------------===//
-
-void Leaf::DeprecatedFree(ART &art, Node &node) {
-	D_ASSERT(node.GetType() == LEAF);
-
-	Node next;
-	while (node.HasMetadata()) {
-		next = Node::Ref<Leaf>(art, node, LEAF).ptr;
-		Node::GetAllocator(art, LEAF).Free(node);
-		node = next;
-	}
-	node.Clear();
-}
-
-bool Leaf::DeprecatedGetRowIds(ART &art, const Node &node, unsafe_vector<row_t> &row_ids, const idx_t max_count) {
-	D_ASSERT(node.GetType() == LEAF);
-
-	reference<const Node> ref(node);
-	while (ref.get().HasMetadata()) {
-
-		auto &leaf = Node::Ref<const Leaf>(art, ref, LEAF);
-		if (row_ids.size() + leaf.count > max_count) {
-			return false;
-		}
-		for (uint8_t i = 0; i < leaf.count; i++) {
-			row_ids.push_back(leaf.row_ids[i]);
-		}
-		ref = leaf.ptr;
-	}
-	return true;
-}
-
-void Leaf::DeprecatedVacuum(ART &art, Node &node) {
-	D_ASSERT(node.HasMetadata());
-	D_ASSERT(node.GetType() == LEAF);
-
-	auto &allocator = Node::GetAllocator(art, LEAF);
-	reference<Node> ref(node);
-	while (ref.get().HasMetadata()) {
-		if (allocator.NeedsVacuum(ref)) {
-			ref.get() = allocator.VacuumPointer(ref);
-			ref.get().SetMetadata(static_cast<uint8_t>(LEAF));
-		}
-		auto &leaf = Node::Ref<Leaf>(art, ref, LEAF);
-		ref = leaf.ptr;
-	}
-}
-
-string Leaf::DeprecatedVerifyAndToString(ART &art, const Node &node, const bool only_verify) {
-	D_ASSERT(node.GetType() == LEAF);
-
-	string str = "";
-	reference<const Node> ref(node);
-
-	while (ref.get().HasMetadata()) {
-		auto &leaf = Node::Ref<const Leaf>(art, ref, LEAF);
-		D_ASSERT(leaf.count <= LEAF_SIZE);
-
-		str += "Leaf [count: " + to_string(leaf.count) + ", row IDs: ";
-		for (uint8_t i = 0; i < leaf.count; i++) {
-			str += to_string(leaf.row_ids[i]) + "-";
-		}
-		str += "] ";
-		ref = leaf.ptr;
-	}
-
-	return only_verify ? "" : str;
-}
-
-void Leaf::DeprecatedVerifyAllocations(ART &art, unordered_map<uint8_t, idx_t> &node_counts) const {
-	auto idx = Node::GetAllocatorIdx(LEAF);
-	node_counts[idx]++;
-
-	reference<const Node> ref(ptr);
-	while (ref.get().HasMetadata()) {
-		auto &leaf = Node::Ref<const Leaf>(art, ref, LEAF);
-		node_counts[idx]++;
-		ref = leaf.ptr;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/node.cpp b/src/duckdb/src/execution/index/art/node.cpp
deleted file mode 100644
index 25c1dd5ff..000000000
--- a/src/duckdb/src/execution/index/art/node.cpp
+++ /dev/null
@@ -1,765 +0,0 @@
-#include "duckdb/execution/index/art/node.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/swap.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/base_leaf.hpp"
-#include "duckdb/execution/index/art/base_node.hpp"
-#include "duckdb/execution/index/art/iterator.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/art/node256_leaf.hpp"
-#include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// New and free
-//===--------------------------------------------------------------------===//
-
-void Node::New(ART &art, Node &node, NType type) {
-	switch (type) {
-	case NType::NODE_7_LEAF:
-		Node7Leaf::New(art, node);
-		break;
-	case NType::NODE_15_LEAF:
-		Node15Leaf::New(art, node);
-		break;
-	case NType::NODE_256_LEAF:
-		Node256Leaf::New(art, node);
-		break;
-	case NType::NODE_4:
-		Node4::New(art, node);
-		break;
-	case NType::NODE_16:
-		Node16::New(art, node);
-		break;
-	case NType::NODE_48:
-		Node48::New(art, node);
-		break;
-	case NType::NODE_256:
-		Node256::New(art, node);
-		break;
-	default:
-		throw InternalException("Invalid node type for New: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-void Node::Free(ART &art, Node &node) {
-	if (!node.HasMetadata()) {
-		return node.Clear();
-	}
-
-	// Free the children.
-	auto type = node.GetType();
-	switch (type) {
-	case NType::PREFIX:
-		return Prefix::Free(art, node);
-	case NType::LEAF:
-		return Leaf::DeprecatedFree(art, node);
-	case NType::NODE_4:
-		Node4::Free(art, node);
-		break;
-	case NType::NODE_16:
-		Node16::Free(art, node);
-		break;
-	case NType::NODE_48:
-		Node48::Free(art, node);
-		break;
-	case NType::NODE_256:
-		Node256::Free(art, node);
-		break;
-	case NType::LEAF_INLINED:
-		return node.Clear();
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF:
-		break;
-	}
-
-	GetAllocator(art, type).Free(node);
-	node.Clear();
-}
-
-//===--------------------------------------------------------------------===//
-// Allocators
-//===--------------------------------------------------------------------===//
-
-FixedSizeAllocator &Node::GetAllocator(const ART &art, const NType type) {
-	return *(*art.allocators)[GetAllocatorIdx(type)];
-}
-
-uint8_t Node::GetAllocatorIdx(const NType type) {
-	switch (type) {
-	case NType::PREFIX:
-		return 0;
-	case NType::LEAF:
-		return 1;
-	case NType::NODE_4:
-		return 2;
-	case NType::NODE_16:
-		return 3;
-	case NType::NODE_48:
-		return 4;
-	case NType::NODE_256:
-		return 5;
-	case NType::NODE_7_LEAF:
-		return 6;
-	case NType::NODE_15_LEAF:
-		return 7;
-	case NType::NODE_256_LEAF:
-		return 8;
-	default:
-		throw InternalException("Invalid node type for GetAllocatorIdx: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Inserts
-//===--------------------------------------------------------------------===//
-
-void Node::ReplaceChild(const ART &art, const uint8_t byte, const Node child) const {
-	D_ASSERT(HasMetadata());
-
-	auto type = GetType();
-	switch (type) {
-	case NType::NODE_4:
-		return Node4::ReplaceChild(Ref<Node4>(art, *this, type), byte, child);
-	case NType::NODE_16:
-		return Node16::ReplaceChild(Ref<Node16>(art, *this, type), byte, child);
-	case NType::NODE_48:
-		return Ref<Node48>(art, *this, type).ReplaceChild(byte, child);
-	case NType::NODE_256:
-		return Ref<Node256>(art, *this, type).ReplaceChild(byte, child);
-	default:
-		throw InternalException("Invalid node type for ReplaceChild: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-void Node::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	D_ASSERT(node.HasMetadata());
-
-	auto type = node.GetType();
-	switch (type) {
-	case NType::NODE_4:
-		return Node4::InsertChild(art, node, byte, child);
-	case NType::NODE_16:
-		return Node16::InsertChild(art, node, byte, child);
-	case NType::NODE_48:
-		return Node48::InsertChild(art, node, byte, child);
-	case NType::NODE_256:
-		return Node256::InsertChild(art, node, byte, child);
-	case NType::NODE_7_LEAF:
-		return Node7Leaf::InsertByte(art, node, byte);
-	case NType::NODE_15_LEAF:
-		return Node15Leaf::InsertByte(art, node, byte);
-	case NType::NODE_256_LEAF:
-		return Node256Leaf::InsertByte(art, node, byte);
-	default:
-		throw InternalException("Invalid node type for InsertChild: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Delete
-//===--------------------------------------------------------------------===//
-
-void Node::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, const GateStatus status,
-                       const ARTKey &row_id) {
-	D_ASSERT(node.HasMetadata());
-
-	auto type = node.GetType();
-	switch (type) {
-	case NType::NODE_4:
-		return Node4::DeleteChild(art, node, prefix, byte, status);
-	case NType::NODE_16:
-		return Node16::DeleteChild(art, node, byte);
-	case NType::NODE_48:
-		return Node48::DeleteChild(art, node, byte);
-	case NType::NODE_256:
-		return Node256::DeleteChild(art, node, byte);
-	case NType::NODE_7_LEAF:
-		return Node7Leaf::DeleteByte(art, node, prefix, byte, row_id);
-	case NType::NODE_15_LEAF:
-		return Node15Leaf::DeleteByte(art, node, byte);
-	case NType::NODE_256_LEAF:
-		return Node256Leaf::DeleteByte(art, node, byte);
-	default:
-		throw InternalException("Invalid node type for DeleteChild: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Get child and byte.
-//===--------------------------------------------------------------------===//
-
-template <class NODE>
-unsafe_optional_ptr<Node> GetChildInternal(ART &art, NODE &node, const uint8_t byte) {
-	D_ASSERT(node.HasMetadata());
-
-	auto type = node.GetType();
-	switch (type) {
-	case NType::NODE_4:
-		return Node4::GetChild(Node::Ref<Node4>(art, node, type), byte);
-	case NType::NODE_16:
-		return Node16::GetChild(Node::Ref<Node16>(art, node, type), byte);
-	case NType::NODE_48:
-		return Node48::GetChild(Node::Ref<Node48>(art, node, type), byte);
-	case NType::NODE_256: {
-		return Node256::GetChild(Node::Ref<Node256>(art, node, type), byte);
-	}
-	default:
-		throw InternalException("Invalid node type for GetChildInternal: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-const unsafe_optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
-	return GetChildInternal(art, *this, byte);
-}
-
-unsafe_optional_ptr<Node> Node::GetChildMutable(ART &art, const uint8_t byte) const {
-	return GetChildInternal(art, *this, byte);
-}
-
-template <class NODE>
-unsafe_optional_ptr<Node> GetNextChildInternal(ART &art, NODE &node, uint8_t &byte) {
-	D_ASSERT(node.HasMetadata());
-
-	auto type = node.GetType();
-	switch (type) {
-	case NType::NODE_4:
-		return Node4::GetNextChild(Node::Ref<Node4>(art, node, type), byte);
-	case NType::NODE_16:
-		return Node16::GetNextChild(Node::Ref<Node16>(art, node, type), byte);
-	case NType::NODE_48:
-		return Node48::GetNextChild(Node::Ref<Node48>(art, node, type), byte);
-	case NType::NODE_256:
-		return Node256::GetNextChild(Node::Ref<Node256>(art, node, type), byte);
-	default:
-		throw InternalException("Invalid node type for GetNextChildInternal: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-const unsafe_optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte) const {
-	return GetNextChildInternal(art, *this, byte);
-}
-
-unsafe_optional_ptr<Node> Node::GetNextChildMutable(ART &art, uint8_t &byte) const {
-	return GetNextChildInternal(art, *this, byte);
-}
-
-bool Node::HasByte(ART &art, uint8_t &byte) const {
-	D_ASSERT(HasMetadata());
-
-	auto type = GetType();
-	switch (type) {
-	case NType::NODE_7_LEAF:
-		return Ref<const Node7Leaf>(art, *this, NType::NODE_7_LEAF).HasByte(byte);
-	case NType::NODE_15_LEAF:
-		return Ref<const Node15Leaf>(art, *this, NType::NODE_15_LEAF).HasByte(byte);
-	case NType::NODE_256_LEAF:
-		return Ref<Node256Leaf>(art, *this, NType::NODE_256_LEAF).HasByte(byte);
-	default:
-		throw InternalException("Invalid node type for GetNextByte: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-bool Node::GetNextByte(ART &art, uint8_t &byte) const {
-	D_ASSERT(HasMetadata());
-
-	auto type = GetType();
-	switch (type) {
-	case NType::NODE_7_LEAF:
-		return Ref<const Node7Leaf>(art, *this, NType::NODE_7_LEAF).GetNextByte(byte);
-	case NType::NODE_15_LEAF:
-		return Ref<const Node15Leaf>(art, *this, NType::NODE_15_LEAF).GetNextByte(byte);
-	case NType::NODE_256_LEAF:
-		return Ref<Node256Leaf>(art, *this, NType::NODE_256_LEAF).GetNextByte(byte);
-	default:
-		throw InternalException("Invalid node type for GetNextByte: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Utility
-//===--------------------------------------------------------------------===//
-
-idx_t GetCapacity(NType type) {
-	switch (type) {
-	case NType::NODE_4:
-		return Node4::CAPACITY;
-	case NType::NODE_7_LEAF:
-		return Node7Leaf::CAPACITY;
-	case NType::NODE_15_LEAF:
-		return Node15Leaf::CAPACITY;
-	case NType::NODE_16:
-		return Node16::CAPACITY;
-	case NType::NODE_48:
-		return Node48::CAPACITY;
-	case NType::NODE_256_LEAF:
-		return Node256::CAPACITY;
-	case NType::NODE_256:
-		return Node256::CAPACITY;
-	default:
-		throw InternalException("Invalid node type for GetCapacity: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-NType Node::GetNodeType(idx_t count) {
-	if (count <= Node4::CAPACITY) {
-		return NType::NODE_4;
-	} else if (count <= Node16::CAPACITY) {
-		return NType::NODE_16;
-	} else if (count <= Node48::CAPACITY) {
-		return NType::NODE_48;
-	}
-	return NType::NODE_256;
-}
-
-bool Node::IsNode() const {
-	switch (GetType()) {
-	case NType::NODE_4:
-	case NType::NODE_16:
-	case NType::NODE_48:
-	case NType::NODE_256:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool Node::IsLeafNode() const {
-	switch (GetType()) {
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool Node::IsAnyLeaf() const {
-	if (IsLeafNode()) {
-		return true;
-	}
-
-	switch (GetType()) {
-	case NType::LEAF_INLINED:
-	case NType::LEAF:
-		return true;
-	default:
-		return false;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Merge
-//===--------------------------------------------------------------------===//
-
-void Node::InitMerge(ART &art, const unsafe_vector<idx_t> &upper_bounds) {
-	D_ASSERT(HasMetadata());
-	auto type = GetType();
-
-	switch (type) {
-	case NType::PREFIX:
-		return Prefix::InitializeMerge(art, *this, upper_bounds);
-	case NType::LEAF:
-		throw InternalException("Failed to initialize merge due to deprecated ART storage.");
-	case NType::NODE_4:
-		InitMergeInternal(art, Ref<Node4>(art, *this, type), upper_bounds);
-		break;
-	case NType::NODE_16:
-		InitMergeInternal(art, Ref<Node16>(art, *this, type), upper_bounds);
-		break;
-	case NType::NODE_48:
-		InitMergeInternal(art, Ref<Node48>(art, *this, type), upper_bounds);
-		break;
-	case NType::NODE_256:
-		InitMergeInternal(art, Ref<Node256>(art, *this, type), upper_bounds);
-		break;
-	case NType::LEAF_INLINED:
-		return;
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF:
-		break;
-	}
-
-	auto idx = GetAllocatorIdx(type);
-	IncreaseBufferId(upper_bounds[idx]);
-}
-
-bool Node::MergeNormalNodes(ART &art, Node &l_node, Node &r_node, uint8_t &byte, const GateStatus status) {
-	// Merge N4, N16, N48, N256 nodes.
-	D_ASSERT(l_node.IsNode() && r_node.IsNode());
-	D_ASSERT(l_node.GetGateStatus() == r_node.GetGateStatus());
-
-	auto r_child = r_node.GetNextChildMutable(art, byte);
-	while (r_child) {
-		auto l_child = l_node.GetChildMutable(art, byte);
-		if (!l_child) {
-			Node::InsertChild(art, l_node, byte, *r_child);
-			r_node.ReplaceChild(art, byte);
-		} else {
-			if (!l_child->MergeInternal(art, *r_child, status)) {
-				return false;
-			}
-		}
-
-		if (byte == NumericLimits<uint8_t>::Maximum()) {
-			break;
-		}
-		byte++;
-		r_child = r_node.GetNextChildMutable(art, byte);
-	}
-
-	Node::Free(art, r_node);
-	return true;
-}
-
-void Node::MergeLeafNodes(ART &art, Node &l_node, Node &r_node, uint8_t &byte) {
-	// Merge N7, N15, N256 leaf nodes.
-	D_ASSERT(l_node.IsLeafNode() && r_node.IsLeafNode());
-	D_ASSERT(l_node.GetGateStatus() == GateStatus::GATE_NOT_SET);
-	D_ASSERT(r_node.GetGateStatus() == GateStatus::GATE_NOT_SET);
-
-	auto has_next = r_node.GetNextByte(art, byte);
-	while (has_next) {
-		// Row IDs are always unique.
-		Node::InsertChild(art, l_node, byte);
-		if (byte == NumericLimits<uint8_t>::Maximum()) {
-			break;
-		}
-		byte++;
-		has_next = r_node.GetNextByte(art, byte);
-	}
-
-	Node::Free(art, r_node);
-}
-
-bool Node::MergeNodes(ART &art, Node &other, GateStatus status) {
-	// Merge the smaller node into the bigger node.
-	if (GetType() < other.GetType()) {
-		swap(*this, other);
-	}
-
-	uint8_t byte = 0;
-	if (IsNode()) {
-		return MergeNormalNodes(art, *this, other, byte, status);
-	}
-	MergeLeafNodes(art, *this, other, byte);
-	return true;
-}
-
-bool Node::Merge(ART &art, Node &other, const GateStatus status) {
-	if (HasMetadata()) {
-		return MergeInternal(art, other, status);
-	}
-
-	*this = other;
-	other = Node();
-	return true;
-}
-
-bool Node::PrefixContainsOther(ART &art, Node &l_node, Node &r_node, const uint8_t pos, const GateStatus status) {
-	// r_node's prefix contains l_node's prefix. l_node must be a node with child nodes.
-	D_ASSERT(l_node.IsNode());
-
-	// Check if the next byte (pos) in r_node exists in l_node.
-	auto byte = Prefix::GetByte(art, r_node, pos);
-	auto child = l_node.GetChildMutable(art, byte);
-
-	// Reduce r_node's prefix to the bytes after pos.
-	Prefix::Reduce(art, r_node, pos);
-	if (child) {
-		return child->MergeInternal(art, r_node, status);
-	}
-
-	Node::InsertChild(art, l_node, byte, r_node);
-	r_node.Clear();
-	return true;
-}
-
-void Node::MergeIntoNode4(ART &art, Node &l_node, Node &r_node, const uint8_t pos) {
-	Node l_child;
-	auto l_byte = Prefix::GetByte(art, l_node, pos);
-
-	reference<Node> ref(l_node);
-	auto status = Prefix::Split(art, ref, l_child, pos);
-	Node4::New(art, ref);
-	ref.get().SetGateStatus(status);
-
-	Node4::InsertChild(art, ref, l_byte, l_child);
-
-	auto r_byte = Prefix::GetByte(art, r_node, pos);
-	Prefix::Reduce(art, r_node, pos);
-	Node4::InsertChild(art, ref, r_byte, r_node);
-	r_node.Clear();
-}
-
-bool Node::MergePrefixes(ART &art, Node &other, const GateStatus status) {
-	reference<Node> l_node(*this);
-	reference<Node> r_node(other);
-	auto pos = DConstants::INVALID_INDEX;
-
-	if (l_node.get().GetType() == NType::PREFIX && r_node.get().GetType() == NType::PREFIX) {
-		// Traverse prefixes. Possibly change the referenced nodes.
-		if (!Prefix::Traverse(art, l_node, r_node, pos, status)) {
-			return false;
-		}
-		if (pos == DConstants::INVALID_INDEX) {
-			return true;
-		}
-
-	} else {
-		// l_prefix contains r_prefix.
-		if (l_node.get().GetType() == NType::PREFIX) {
-			swap(*this, other);
-		}
-		pos = 0;
-	}
-
-	D_ASSERT(pos != DConstants::INVALID_INDEX);
-	if (l_node.get().GetType() != NType::PREFIX && r_node.get().GetType() == NType::PREFIX) {
-		return PrefixContainsOther(art, l_node, r_node, UnsafeNumericCast<uint8_t>(pos), status);
-	}
-
-	// The prefixes differ.
-	MergeIntoNode4(art, l_node, r_node, UnsafeNumericCast<uint8_t>(pos));
-	return true;
-}
-
-bool Node::MergeInternal(ART &art, Node &other, const GateStatus status) {
-	D_ASSERT(HasMetadata());
-	D_ASSERT(other.HasMetadata());
-
-	// Merge inlined leaves.
-	if (GetType() == NType::LEAF_INLINED) {
-		swap(*this, other);
-	}
-	if (other.GetType() == NType::LEAF_INLINED) {
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		D_ASSERT(other.GetGateStatus() == GateStatus::GATE_SET || other.GetType() == NType::LEAF_INLINED);
-		D_ASSERT(GetType() == NType::LEAF_INLINED || GetGateStatus() == GateStatus::GATE_SET);
-
-		if (art.IsUnique()) {
-			return false;
-		}
-		Leaf::MergeInlined(art, *this, other);
-		return true;
-	}
-
-	// Enter a gate.
-	if (GetGateStatus() == GateStatus::GATE_SET && status == GateStatus::GATE_NOT_SET) {
-		D_ASSERT(other.GetGateStatus() == GateStatus::GATE_SET);
-		D_ASSERT(GetType() != NType::LEAF_INLINED);
-		D_ASSERT(other.GetType() != NType::LEAF_INLINED);
-
-		// Get all row IDs.
-		unsafe_vector<row_t> row_ids;
-		Iterator it(art);
-		it.FindMinimum(other);
-		ARTKey empty_key = ARTKey();
-		it.Scan(empty_key, NumericLimits<row_t>().Maximum(), row_ids, false);
-		Node::Free(art, other);
-		D_ASSERT(row_ids.size() > 1);
-
-		// Insert all row IDs.
-		ArenaAllocator allocator(Allocator::Get(art.db));
-		for (idx_t i = 0; i < row_ids.size(); i++) {
-			auto row_id = ARTKey::CreateARTKey<row_t>(allocator, row_ids[i]);
-			art.Insert(*this, row_id, 0, row_id, GateStatus::GATE_SET, nullptr);
-		}
-		return true;
-	}
-
-	// Merge N4, N16, N48, N256 nodes.
-	if (IsNode() && other.IsNode()) {
-		return MergeNodes(art, other, status);
-	}
-	// Merge N7, N15, N256 leaf nodes.
-	if (IsLeafNode() && other.IsLeafNode()) {
-		D_ASSERT(status == GateStatus::GATE_SET);
-		return MergeNodes(art, other, status);
-	}
-
-	// Merge prefixes.
-	return MergePrefixes(art, other, status);
-}
-
-//===--------------------------------------------------------------------===//
-// Vacuum
-//===--------------------------------------------------------------------===//
-
-void Node::Vacuum(ART &art, const unordered_set<uint8_t> &indexes) {
-	D_ASSERT(HasMetadata());
-
-	auto type = GetType();
-	switch (type) {
-	case NType::LEAF_INLINED:
-		return;
-	case NType::PREFIX:
-		return Prefix::Vacuum(art, *this, indexes);
-	case NType::LEAF:
-		if (indexes.find(GetAllocatorIdx(type)) == indexes.end()) {
-			return;
-		}
-		return Leaf::DeprecatedVacuum(art, *this);
-	default:
-		break;
-	}
-
-	auto idx = GetAllocatorIdx(type);
-	auto &allocator = GetAllocator(art, type);
-	auto needs_vacuum = indexes.find(idx) != indexes.end() && allocator.NeedsVacuum(*this);
-	if (needs_vacuum) {
-		auto status = GetGateStatus();
-		*this = allocator.VacuumPointer(*this);
-		SetMetadata(static_cast<uint8_t>(type));
-		SetGateStatus(status);
-	}
-
-	switch (type) {
-	case NType::NODE_4:
-		return VacuumInternal(art, Ref<Node4>(art, *this, type), indexes);
-	case NType::NODE_16:
-		return VacuumInternal(art, Ref<Node16>(art, *this, type), indexes);
-	case NType::NODE_48:
-		return VacuumInternal(art, Ref<Node48>(art, *this, type), indexes);
-	case NType::NODE_256:
-		return VacuumInternal(art, Ref<Node256>(art, *this, type), indexes);
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF:
-		return;
-	default:
-		throw InternalException("Invalid node type for Vacuum: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// TransformToDeprecated
-//===--------------------------------------------------------------------===//
-
-void Node::TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<FixedSizeAllocator> &allocator) {
-	D_ASSERT(node.HasMetadata());
-
-	if (node.GetGateStatus() == GateStatus::GATE_SET) {
-		D_ASSERT(node.GetType() != NType::LEAF_INLINED);
-		return Leaf::TransformToDeprecated(art, node);
-	}
-
-	auto type = node.GetType();
-	switch (type) {
-	case NType::PREFIX:
-		return Prefix::TransformToDeprecated(art, node, allocator);
-	case NType::LEAF_INLINED:
-		return;
-	case NType::LEAF:
-		return;
-	case NType::NODE_4:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node4>(art, node, type), allocator);
-	case NType::NODE_16:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node16>(art, node, type), allocator);
-	case NType::NODE_48:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node48>(art, node, type), allocator);
-	case NType::NODE_256:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node256>(art, node, type), allocator);
-	default:
-		throw InternalException("Invalid node type for TransformToDeprecated: %d.", static_cast<uint8_t>(type));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Verification
-//===--------------------------------------------------------------------===//
-
-string Node::VerifyAndToString(ART &art, const bool only_verify) const {
-	D_ASSERT(HasMetadata());
-
-	auto type = GetType();
-	switch (type) {
-	case NType::LEAF_INLINED:
-		return only_verify ? "" : "Inlined Leaf [row ID: " + to_string(GetRowId()) + "]";
-	case NType::LEAF:
-		return Leaf::DeprecatedVerifyAndToString(art, *this, only_verify);
-	case NType::PREFIX: {
-		auto str = Prefix::VerifyAndToString(art, *this, only_verify);
-		if (GetGateStatus() == GateStatus::GATE_SET) {
-			str = "Gate [ " + str + " ]";
-		}
-		return only_verify ? "" : "\n" + str;
-	}
-	default:
-		break;
-	}
-
-	string str = "Node" + to_string(GetCapacity(type)) + ": [ ";
-	uint8_t byte = 0;
-
-	if (IsLeafNode()) {
-		str = "Leaf " + str;
-		auto has_byte = GetNextByte(art, byte);
-		while (has_byte) {
-			str += to_string(byte) + "-";
-			if (byte == NumericLimits<uint8_t>::Maximum()) {
-				break;
-			}
-			byte++;
-			has_byte = GetNextByte(art, byte);
-		}
-	} else {
-		auto child = GetNextChild(art, byte);
-		while (child) {
-			str += "(" + to_string(byte) + ", " + child->VerifyAndToString(art, only_verify) + ")";
-			if (byte == NumericLimits<uint8_t>::Maximum()) {
-				break;
-			}
-			byte++;
-			child = GetNextChild(art, byte);
-		}
-	}
-
-	if (GetGateStatus() == GateStatus::GATE_SET) {
-		str = "Gate [ " + str + " ]";
-	}
-	return only_verify ? "" : "\n" + str + "]";
-}
-
-void Node::VerifyAllocations(ART &art, unordered_map<uint8_t, idx_t> &node_counts) const {
-	D_ASSERT(HasMetadata());
-
-	auto type = GetType();
-	switch (type) {
-	case NType::PREFIX:
-		return Prefix::VerifyAllocations(art, *this, node_counts);
-	case NType::LEAF:
-		return Ref<Leaf>(art, *this, type).DeprecatedVerifyAllocations(art, node_counts);
-	case NType::LEAF_INLINED:
-		return;
-	case NType::NODE_4:
-		VerifyAllocationsInternal(art, Ref<Node4>(art, *this, type), node_counts);
-		break;
-	case NType::NODE_16:
-		VerifyAllocationsInternal(art, Ref<Node16>(art, *this, type), node_counts);
-		break;
-	case NType::NODE_48:
-		VerifyAllocationsInternal(art, Ref<Node48>(art, *this, type), node_counts);
-		break;
-	case NType::NODE_256:
-		VerifyAllocationsInternal(art, Ref<Node256>(art, *this, type), node_counts);
-		break;
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF:
-		break;
-	}
-
-	node_counts[GetAllocatorIdx(type)]++;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/node256.cpp b/src/duckdb/src/execution/index/art/node256.cpp
deleted file mode 100644
index f08717e13..000000000
--- a/src/duckdb/src/execution/index/art/node256.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "duckdb/execution/index/art/node256.hpp"
-
-#include "duckdb/execution/index/art/node48.hpp"
-
-namespace duckdb {
-
-Node256 &Node256::New(ART &art, Node &node) {
-	node = Node::GetAllocator(art, NODE_256).New();
-	node.SetMetadata(static_cast<uint8_t>(NODE_256));
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-
-	n256.count = 0;
-	for (uint16_t i = 0; i < CAPACITY; i++) {
-		n256.children[i].Clear();
-	}
-
-	return n256;
-}
-
-void Node256::Free(ART &art, Node &node) {
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-	if (!n256.count) {
-		return;
-	}
-
-	Iterator(n256, [&](Node &child) { Node::Free(art, child); });
-}
-
-void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-	n256.count++;
-	n256.children[byte] = child;
-}
-
-void Node256::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-
-	// Free the child and decrease the count.
-	Node::Free(art, n256.children[byte]);
-	n256.count--;
-
-	// Shrink to Node48.
-	if (n256.count <= SHRINK_THRESHOLD) {
-		auto node256 = node;
-		Node48::ShrinkNode256(art, node, node256);
-	}
-}
-
-void Node256::ReplaceChild(const uint8_t byte, const Node child) {
-	D_ASSERT(count > SHRINK_THRESHOLD);
-
-	auto status = children[byte].GetGateStatus();
-	children[byte] = child;
-	if (status == GateStatus::GATE_SET && child.HasMetadata()) {
-		children[byte].SetGateStatus(status);
-	}
-}
-
-Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
-	auto &n48 = Node::Ref<Node48>(art, node48, NType::NODE_48);
-	auto &n256 = New(art, node256);
-	node256.SetGateStatus(node48.GetGateStatus());
-
-	n256.count = n48.count;
-	for (uint16_t i = 0; i < CAPACITY; i++) {
-		if (n48.child_index[i] != Node48::EMPTY_MARKER) {
-			n256.children[i] = n48.children[n48.child_index[i]];
-		} else {
-			n256.children[i].Clear();
-		}
-	}
-
-	n48.count = 0;
-	Node::Free(art, node48);
-	return n256;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/node256_leaf.cpp b/src/duckdb/src/execution/index/art/node256_leaf.cpp
deleted file mode 100644
index 5c74674f4..000000000
--- a/src/duckdb/src/execution/index/art/node256_leaf.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "duckdb/execution/index/art/node256_leaf.hpp"
-
-#include "duckdb/execution/index/art/base_leaf.hpp"
-#include "duckdb/execution/index/art/node48.hpp"
-
-namespace duckdb {
-
-Node256Leaf &Node256Leaf::New(ART &art, Node &node) {
-	node = Node::GetAllocator(art, NODE_256_LEAF).New();
-	node.SetMetadata(static_cast<uint8_t>(NODE_256_LEAF));
-	auto &n256 = Node::Ref<Node256Leaf>(art, node, NODE_256_LEAF);
-
-	n256.count = 0;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	mask.SetAllInvalid(CAPACITY);
-	return n256;
-}
-
-void Node256Leaf::InsertByte(ART &art, Node &node, const uint8_t byte) {
-	auto &n256 = Node::Ref<Node256Leaf>(art, node, NODE_256_LEAF);
-	n256.count++;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	mask.SetValid(byte);
-}
-
-void Node256Leaf::DeleteByte(ART &art, Node &node, const uint8_t byte) {
-	auto &n256 = Node::Ref<Node256Leaf>(art, node, NODE_256_LEAF);
-	n256.count--;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	mask.SetInvalid(byte);
-
-	// Shrink node to Node15
-	if (n256.count <= Node48::SHRINK_THRESHOLD) {
-		auto node256 = node;
-		Node15Leaf::ShrinkNode256Leaf(art, node, node256);
-	}
-}
-
-bool Node256Leaf::HasByte(uint8_t &byte) {
-	ValidityMask v_mask(&mask[0], Node256::CAPACITY);
-	return v_mask.RowIsValid(byte);
-}
-
-bool Node256Leaf::GetNextByte(uint8_t &byte) {
-	ValidityMask v_mask(&mask[0], Node256::CAPACITY);
-	for (uint16_t i = byte; i < CAPACITY; i++) {
-		if (v_mask.RowIsValid(i)) {
-			byte = UnsafeNumericCast<uint8_t>(i);
-			return true;
-		}
-	}
-	return false;
-}
-
-Node256Leaf &Node256Leaf::GrowNode15Leaf(ART &art, Node &node256_leaf, Node &node15_leaf) {
-	auto &n15 = Node::Ref<Node15Leaf>(art, node15_leaf, NType::NODE_15_LEAF);
-	auto &n256 = New(art, node256_leaf);
-	node256_leaf.SetGateStatus(node15_leaf.GetGateStatus());
-
-	n256.count = n15.count;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	for (uint8_t i = 0; i < n15.count; i++) {
-		mask.SetValid(n15.key[i]);
-	}
-
-	n15.count = 0;
-	Node::Free(art, node15_leaf);
-	return n256;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/node48.cpp b/src/duckdb/src/execution/index/art/node48.cpp
deleted file mode 100644
index f9ad0460c..000000000
--- a/src/duckdb/src/execution/index/art/node48.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#include "duckdb/execution/index/art/node48.hpp"
-
-#include "duckdb/execution/index/art/base_node.hpp"
-#include "duckdb/execution/index/art/node256.hpp"
-
-namespace duckdb {
-
-Node48 &Node48::New(ART &art, Node &node) {
-	node = Node::GetAllocator(art, NODE_48).New();
-	node.SetMetadata(static_cast<uint8_t>(NODE_48));
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-
-	n48.count = 0;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		n48.child_index[i] = EMPTY_MARKER;
-	}
-	for (uint8_t i = 0; i < CAPACITY; i++) {
-		n48.children[i].Clear();
-	}
-
-	return n48;
-}
-
-void Node48::Free(ART &art, Node &node) {
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-	if (!n48.count) {
-		return;
-	}
-
-	Iterator(n48, [&](Node &child) { Node::Free(art, child); });
-}
-
-void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-
-	// The node is full. Grow to Node256.
-	if (n48.count == CAPACITY) {
-		auto node48 = node;
-		Node256::GrowNode48(art, node, node48);
-		Node256::InsertChild(art, node, byte, child);
-		return;
-	}
-
-	// Still space. Insert the child.
-	uint8_t child_pos = n48.count;
-	if (n48.children[child_pos].HasMetadata()) {
-		// Find an empty position in the node list.
-		child_pos = 0;
-		while (n48.children[child_pos].HasMetadata()) {
-			child_pos++;
-		}
-	}
-
-	n48.children[child_pos] = child;
-	n48.child_index[byte] = child_pos;
-	n48.count++;
-}
-
-void Node48::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-
-	// Free the child and decrease the count.
-	Node::Free(art, n48.children[n48.child_index[byte]]);
-	n48.child_index[byte] = EMPTY_MARKER;
-	n48.count--;
-
-	// Shrink to Node16.
-	if (n48.count < SHRINK_THRESHOLD) {
-		auto node48 = node;
-		Node16::ShrinkNode48(art, node, node48);
-	}
-}
-
-void Node48::ReplaceChild(const uint8_t byte, const Node child) {
-	D_ASSERT(count >= SHRINK_THRESHOLD);
-
-	auto status = children[child_index[byte]].GetGateStatus();
-	children[child_index[byte]] = child;
-	if (status == GateStatus::GATE_SET && child.HasMetadata()) {
-		children[child_index[byte]].SetGateStatus(status);
-	}
-}
-
-Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
-	auto &n16 = Node::Ref<Node16>(art, node16, NType::NODE_16);
-	auto &n48 = New(art, node48);
-	node48.SetGateStatus(node16.GetGateStatus());
-
-	n48.count = n16.count;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		n48.child_index[i] = EMPTY_MARKER;
-	}
-	for (uint8_t i = 0; i < n16.count; i++) {
-		n48.child_index[n16.key[i]] = i;
-		n48.children[i] = n16.children[i];
-	}
-	for (uint8_t i = n16.count; i < CAPACITY; i++) {
-		n48.children[i].Clear();
-	}
-
-	n16.count = 0;
-	Node::Free(art, node16);
-	return n48;
-}
-
-Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
-	auto &n48 = New(art, node48);
-	auto &n256 = Node::Ref<Node256>(art, node256, NType::NODE_256);
-	node48.SetGateStatus(node256.GetGateStatus());
-
-	n48.count = 0;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		if (!n256.children[i].HasMetadata()) {
-			n48.child_index[i] = EMPTY_MARKER;
-			continue;
-		}
-		n48.child_index[i] = n48.count;
-		n48.children[n48.count] = n256.children[i];
-		n48.count++;
-	}
-	for (uint8_t i = n48.count; i < CAPACITY; i++) {
-		n48.children[i].Clear();
-	}
-
-	n256.count = 0;
-	Node::Free(art, node256);
-	return n48;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/plan_art.cpp b/src/duckdb/src/execution/index/art/plan_art.cpp
deleted file mode 100644
index ce459b290..000000000
--- a/src/duckdb/src/execution/index/art/plan_art.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/operator/filter/physical_filter.hpp"
-#include "duckdb/execution/operator/order/physical_order.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_create_index.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> ART::CreatePlan(PlanIndexInput &input) {
-	auto &op = input.op;
-
-	// PROJECTION on indexed columns.
-	vector<LogicalType> new_column_types;
-	vector<unique_ptr<Expression>> select_list;
-	for (idx_t i = 0; i < op.expressions.size(); i++) {
-		new_column_types.push_back(op.expressions[i]->return_type);
-		select_list.push_back(std::move(op.expressions[i]));
-	}
-	new_column_types.emplace_back(LogicalType::ROW_TYPE);
-	select_list.push_back(make_uniq<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
-
-	auto projection = make_uniq<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
-	projection->children.push_back(std::move(input.table_scan));
-
-	// Optional NOT NULL filter.
-	unique_ptr<PhysicalOperator> prev_operator;
-	auto is_alter = op.alter_table_info != nullptr;
-	if (!is_alter) {
-		vector<LogicalType> filter_types;
-		vector<unique_ptr<Expression>> filter_select_list;
-		auto not_null_type = ExpressionType::OPERATOR_IS_NOT_NULL;
-
-		for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
-			filter_types.push_back(new_column_types[i]);
-			auto is_not_null_expr = make_uniq<BoundOperatorExpression>(not_null_type, LogicalType::BOOLEAN);
-			auto bound_ref = make_uniq<BoundReferenceExpression>(new_column_types[i], i);
-			is_not_null_expr->children.push_back(std::move(bound_ref));
-			filter_select_list.push_back(std::move(is_not_null_expr));
-		}
-
-		prev_operator =
-		    make_uniq<PhysicalFilter>(std::move(filter_types), std::move(filter_select_list), op.estimated_cardinality);
-		prev_operator->types.emplace_back(LogicalType::ROW_TYPE);
-		prev_operator->children.push_back(std::move(projection));
-
-	} else {
-		prev_operator = std::move(projection);
-	}
-
-	// Determine whether to push an ORDER BY operator.
-	auto sort = true;
-	if (op.unbound_expressions.size() > 1) {
-		sort = false;
-	} else if (op.unbound_expressions[0]->return_type.InternalType() == PhysicalType::VARCHAR) {
-		sort = false;
-	}
-
-	// CREATE INDEX operator.
-	auto physical_create_index = make_uniq<PhysicalCreateARTIndex>(
-	    op, op.table, op.info->column_ids, std::move(op.info), std::move(op.unbound_expressions),
-	    op.estimated_cardinality, sort, std::move(op.alter_table_info));
-
-	if (!sort) {
-		physical_create_index->children.push_back(std::move(prev_operator));
-		return std::move(physical_create_index);
-	}
-
-	// ORDER BY operator.
-	vector<BoundOrderByNode> orders;
-	vector<idx_t> projections;
-	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
-		auto col_expr = make_uniq_base<Expression, BoundReferenceExpression>(new_column_types[i], i);
-		orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(col_expr));
-		projections.emplace_back(i);
-	}
-	projections.emplace_back(new_column_types.size() - 1);
-
-	auto physical_order =
-	    make_uniq<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections), op.estimated_cardinality);
-
-	physical_order->children.push_back(std::move(prev_operator));
-	physical_create_index->children.push_back(std::move(physical_order));
-	return std::move(physical_create_index);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/art/prefix.cpp b/src/duckdb/src/execution/index/art/prefix.cpp
deleted file mode 100644
index f0821be04..000000000
--- a/src/duckdb/src/execution/index/art/prefix.cpp
+++ /dev/null
@@ -1,519 +0,0 @@
-#include "duckdb/execution/index/art/prefix.hpp"
-
-#include "duckdb/common/swap.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/base_leaf.hpp"
-#include "duckdb/execution/index/art/base_node.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-Prefix::Prefix(const ART &art, const Node ptr_p, const bool is_mutable, const bool set_in_memory) {
-	if (!set_in_memory) {
-		data = Node::GetAllocator(art, PREFIX).Get(ptr_p, is_mutable);
-	} else {
-		data = Node::GetAllocator(art, PREFIX).GetIfLoaded(ptr_p);
-		if (!data) {
-			ptr = nullptr;
-			in_memory = false;
-			return;
-		}
-	}
-	ptr = reinterpret_cast<Node *>(data + Count(art) + 1);
-	in_memory = true;
-}
-
-Prefix::Prefix(unsafe_unique_ptr<FixedSizeAllocator> &allocator, const Node ptr_p, const idx_t count) {
-	data = allocator->Get(ptr_p, true);
-	ptr = reinterpret_cast<Node *>(data + count + 1);
-	in_memory = true;
-}
-
-idx_t Prefix::GetMismatchWithOther(const Prefix &l_prefix, const Prefix &r_prefix, const idx_t max_count) {
-	for (idx_t i = 0; i < max_count; i++) {
-		if (l_prefix.data[i] != r_prefix.data[i]) {
-			return i;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t Prefix::GetMismatchWithKey(ART &art, const Node &node, const ARTKey &key, idx_t &depth) {
-	Prefix prefix(art, node);
-	for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
-		if (prefix.data[i] != key[depth]) {
-			return i;
-		}
-		depth++;
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-uint8_t Prefix::GetByte(const ART &art, const Node &node, const uint8_t pos) {
-	D_ASSERT(node.GetType() == PREFIX);
-	Prefix prefix(art, node);
-	return prefix.data[pos];
-}
-
-Prefix Prefix::NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset,
-                           const NType type) {
-	node = Node::GetAllocator(art, type).New();
-	node.SetMetadata(static_cast<uint8_t>(type));
-
-	Prefix prefix(art, node, true);
-	prefix.data[Count(art)] = count;
-	if (data) {
-		D_ASSERT(count);
-		memcpy(prefix.data, data + offset, count);
-	}
-	return prefix;
-}
-
-void Prefix::New(ART &art, reference<Node> &ref, const ARTKey &key, const idx_t depth, idx_t count) {
-	idx_t offset = 0;
-
-	while (count) {
-		auto min = MinValue(UnsafeNumericCast<idx_t>(Count(art)), count);
-		auto this_count = UnsafeNumericCast<uint8_t>(min);
-		auto prefix = NewInternal(art, ref, key.data, this_count, offset + depth, PREFIX);
-
-		ref = *prefix.ptr;
-		offset += this_count;
-		count -= this_count;
-	}
-}
-
-void Prefix::Free(ART &art, Node &node) {
-	Node next;
-
-	while (node.HasMetadata() && node.GetType() == PREFIX) {
-		Prefix prefix(art, node, true);
-		next = *prefix.ptr;
-		Node::GetAllocator(art, PREFIX).Free(node);
-		node = next;
-	}
-
-	Node::Free(art, node);
-	node.Clear();
-}
-
-void Prefix::InitializeMerge(ART &art, Node &node, const unsafe_vector<idx_t> &upper_bounds) {
-	auto buffer_count = upper_bounds[Node::GetAllocatorIdx(PREFIX)];
-	Node next = node;
-	Prefix prefix(art, next, true);
-
-	while (next.GetType() == PREFIX) {
-		next = *prefix.ptr;
-		if (prefix.ptr->GetType() == PREFIX) {
-			prefix.ptr->IncreaseBufferId(buffer_count);
-			prefix = Prefix(art, next, true);
-		}
-	}
-
-	node.IncreaseBufferId(buffer_count);
-	prefix.ptr->InitMerge(art, upper_bounds);
-}
-
-void Prefix::Concat(ART &art, Node &parent, uint8_t byte, const GateStatus old_status, const Node &child,
-                    const GateStatus status) {
-	D_ASSERT(!parent.IsAnyLeaf());
-	D_ASSERT(child.HasMetadata());
-
-	if (old_status == GateStatus::GATE_SET) {
-		// Concat Node4.
-		D_ASSERT(status == GateStatus::GATE_SET);
-		return ConcatGate(art, parent, byte, child);
-	}
-	if (child.GetGateStatus() == GateStatus::GATE_SET) {
-		// Concat Node4.
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		return ConcatChildIsGate(art, parent, byte, child);
-	}
-
-	if (status == GateStatus::GATE_SET && child.GetType() == NType::LEAF_INLINED) {
-		auto row_id = child.GetRowId();
-		Free(art, parent);
-		Leaf::New(parent, row_id);
-		return;
-	}
-
-	if (parent.GetType() != PREFIX) {
-		auto prefix = NewInternal(art, parent, &byte, 1, 0, PREFIX);
-		if (child.GetType() == PREFIX) {
-			prefix.Append(art, child);
-		} else {
-			*prefix.ptr = child;
-		}
-		return;
-	}
-
-	auto tail = GetTail(art, parent);
-	tail = tail.Append(art, byte);
-
-	if (child.GetType() == PREFIX) {
-		tail.Append(art, child);
-	} else {
-		*tail.ptr = child;
-	}
-}
-
-template <class NODE>
-idx_t TraverseInternal(ART &art, reference<NODE> &node, const ARTKey &key, idx_t &depth,
-                       const bool is_mutable = false) {
-	D_ASSERT(node.get().HasMetadata());
-	D_ASSERT(node.get().GetType() == NType::PREFIX);
-
-	while (node.get().GetType() == NType::PREFIX) {
-		auto pos = Prefix::GetMismatchWithKey(art, node, key, depth);
-		if (pos != DConstants::INVALID_INDEX) {
-			return pos;
-		}
-
-		Prefix prefix(art, node, is_mutable);
-		node = *prefix.ptr;
-		if (node.get().GetGateStatus() == GateStatus::GATE_SET) {
-			break;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t Prefix::Traverse(ART &art, reference<const Node> &node, const ARTKey &key, idx_t &depth) {
-	return TraverseInternal<const Node>(art, node, key, depth);
-}
-
-idx_t Prefix::TraverseMutable(ART &art, reference<Node> &node, const ARTKey &key, idx_t &depth) {
-	return TraverseInternal<Node>(art, node, key, depth, true);
-}
-
-bool Prefix::Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &pos, const GateStatus status) {
-	D_ASSERT(l_node.get().HasMetadata());
-	D_ASSERT(r_node.get().HasMetadata());
-
-	Prefix l_prefix(art, l_node, true);
-	Prefix r_prefix(art, r_node, true);
-
-	idx_t max_count = MinValue(l_prefix.data[Count(art)], r_prefix.data[Count(art)]);
-	pos = GetMismatchWithOther(l_prefix, r_prefix, max_count);
-	if (pos != DConstants::INVALID_INDEX) {
-		return true;
-	}
-
-	// Match.
-	if (l_prefix.data[Count(art)] == r_prefix.data[Count(art)]) {
-		auto r_child = *r_prefix.ptr;
-		r_prefix.ptr->Clear();
-		Node::Free(art, r_node);
-		return l_prefix.ptr->MergeInternal(art, r_child, status);
-	}
-
-	pos = max_count;
-	if (r_prefix.ptr->GetType() != PREFIX && r_prefix.data[Count(art)] == max_count) {
-		// l_prefix contains r_prefix.
-		swap(l_node.get(), r_node.get());
-		l_node = *r_prefix.ptr;
-		return true;
-	}
-	// r_prefix contains l_prefix.
-	l_node = *l_prefix.ptr;
-	return true;
-}
-
-void Prefix::Reduce(ART &art, Node &node, const idx_t pos) {
-	D_ASSERT(node.HasMetadata());
-	D_ASSERT(pos < Count(art));
-
-	Prefix prefix(art, node);
-	if (pos == idx_t(prefix.data[Count(art)] - 1)) {
-		auto next = *prefix.ptr;
-		prefix.ptr->Clear();
-		Node::Free(art, node);
-		node = next;
-		return;
-	}
-
-	for (idx_t i = 0; i < Count(art) - pos - 1; i++) {
-		prefix.data[i] = prefix.data[pos + i + 1];
-	}
-
-	prefix.data[Count(art)] -= pos + 1;
-	prefix.Append(art, *prefix.ptr);
-}
-
-GateStatus Prefix::Split(ART &art, reference<Node> &node, Node &child, const uint8_t pos) {
-	D_ASSERT(node.get().HasMetadata());
-
-	Prefix prefix(art, node, true);
-
-	// The split is at the last prefix byte. Decrease the count and return.
-	if (pos + 1 == Count(art)) {
-		prefix.data[Count(art)]--;
-		node = *prefix.ptr;
-		child = *prefix.ptr;
-		return GateStatus::GATE_NOT_SET;
-	}
-
-	if (pos + 1 < prefix.data[Count(art)]) {
-		// Create a new prefix and
-		// 1. copy the remaining bytes of this prefix.
-		// 2. append remaining prefix nodes.
-		auto new_prefix = NewInternal(art, child, nullptr, 0, 0, PREFIX);
-		new_prefix.data[Count(art)] = prefix.data[Count(art)] - pos - 1;
-		memcpy(new_prefix.data, prefix.data + pos + 1, new_prefix.data[Count(art)]);
-
-		if (prefix.ptr->GetType() == PREFIX && prefix.ptr->GetGateStatus() == GateStatus::GATE_NOT_SET) {
-			new_prefix.Append(art, *prefix.ptr);
-		} else {
-			*new_prefix.ptr = *prefix.ptr;
-		}
-
-	} else if (pos + 1 == prefix.data[Count(art)]) {
-		// No prefix bytes after the split.
-		child = *prefix.ptr;
-	}
-
-	// Set the new count of this node.
-	prefix.data[Count(art)] = pos;
-
-	// No bytes left before the split, free this node.
-	if (pos == 0) {
-		auto old_status = node.get().GetGateStatus();
-		prefix.ptr->Clear();
-		Node::Free(art, node);
-		return old_status;
-	}
-
-	// There are bytes left before the split.
-	// The subsequent node replaces the split byte.
-	node = *prefix.ptr;
-	return GateStatus::GATE_NOT_SET;
-}
-
-ARTConflictType Prefix::Insert(ART &art, Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id,
-                               const GateStatus status, optional_ptr<ART> delete_art) {
-	reference<Node> next(node);
-	auto pos = TraverseMutable(art, next, key, depth);
-
-	// We recurse into the next node, if
-	// (1) the prefix matches the key.
-	// (2) we reach a gate.
-	if (pos == DConstants::INVALID_INDEX) {
-		if (next.get().GetType() != NType::PREFIX || next.get().GetGateStatus() == GateStatus::GATE_SET) {
-			return art.Insert(next, key, depth, row_id, status, delete_art);
-		}
-	}
-
-	Node remainder;
-	auto byte = GetByte(art, next, UnsafeNumericCast<uint8_t>(pos));
-	auto split_status = Split(art, next, remainder, UnsafeNumericCast<uint8_t>(pos));
-	Node4::New(art, next);
-	next.get().SetGateStatus(split_status);
-
-	// Insert the remaining prefix into the new Node4.
-	Node4::InsertChild(art, next, byte, remainder);
-
-	if (status == GateStatus::GATE_SET) {
-		D_ASSERT(pos != ROW_ID_COUNT);
-		Node new_row_id;
-		Leaf::New(new_row_id, key.GetRowId());
-		Node::InsertChild(art, next, key[depth], new_row_id);
-		return ARTConflictType::NO_CONFLICT;
-	}
-
-	Node leaf;
-	reference<Node> ref(leaf);
-	if (depth + 1 < key.len) {
-		// Create the prefix.
-		auto count = key.len - depth - 1;
-		Prefix::New(art, ref, key, depth + 1, count);
-	}
-	// Create the inlined leaf.
-	Leaf::New(ref, row_id.GetRowId());
-	Node4::InsertChild(art, next, key[depth], leaf);
-	return ARTConflictType::NO_CONFLICT;
-}
-
-string Prefix::VerifyAndToString(ART &art, const Node &node, const bool only_verify) {
-	string str = "";
-	reference<const Node> ref(node);
-
-	Iterator(art, ref, true, false, [&](Prefix &prefix) {
-		D_ASSERT(prefix.data[Count(art)] != 0);
-		D_ASSERT(prefix.data[Count(art)] <= Count(art));
-
-		str += " Prefix :[ ";
-		for (idx_t i = 0; i < prefix.data[Count(art)]; i++) {
-			str += to_string(prefix.data[i]) + "-";
-		}
-		str += " ] ";
-	});
-
-	auto child = ref.get().VerifyAndToString(art, only_verify);
-	return only_verify ? "" : str + child;
-}
-
-void Prefix::VerifyAllocations(ART &art, const Node &node, unordered_map<uint8_t, idx_t> &node_counts) {
-	auto idx = Node::GetAllocatorIdx(PREFIX);
-	reference<const Node> ref(node);
-	Iterator(art, ref, false, false, [&](Prefix &prefix) { node_counts[idx]++; });
-	return ref.get().VerifyAllocations(art, node_counts);
-}
-
-void Prefix::Vacuum(ART &art, Node &node, const unordered_set<uint8_t> &indexes) {
-	bool set = indexes.find(Node::GetAllocatorIdx(PREFIX)) != indexes.end();
-	auto &allocator = Node::GetAllocator(art, PREFIX);
-
-	reference<Node> ref(node);
-	while (ref.get().GetType() == PREFIX) {
-		if (set && allocator.NeedsVacuum(ref)) {
-			auto status = ref.get().GetGateStatus();
-			ref.get() = allocator.VacuumPointer(ref);
-			ref.get().SetMetadata(static_cast<uint8_t>(PREFIX));
-			ref.get().SetGateStatus(status);
-		}
-		Prefix prefix(art, ref, true);
-		ref = *prefix.ptr;
-	}
-
-	ref.get().Vacuum(art, indexes);
-}
-
-void Prefix::TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<FixedSizeAllocator> &allocator) {
-	// Early-out, if we do not need any transformations.
-	if (!allocator) {
-		reference<Node> ref(node);
-		while (ref.get().GetType() == PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
-			Prefix prefix(art, ref, true, true);
-			if (!prefix.in_memory) {
-				return;
-			}
-			ref = *prefix.ptr;
-		}
-		return Node::TransformToDeprecated(art, ref, allocator);
-	}
-
-	// We need to create a new prefix (chain).
-	Node new_node;
-	new_node = allocator->New();
-	new_node.SetMetadata(static_cast<uint8_t>(PREFIX));
-	Prefix new_prefix(allocator, new_node, DEPRECATED_COUNT);
-
-	Node current_node = node;
-	while (current_node.GetType() == PREFIX && current_node.GetGateStatus() == GateStatus::GATE_NOT_SET) {
-		Prefix prefix(art, current_node, true, true);
-		if (!prefix.in_memory) {
-			return;
-		}
-
-		for (idx_t i = 0; i < prefix.data[Count(art)]; i++) {
-			new_prefix = new_prefix.TransformToDeprecatedAppend(art, allocator, prefix.data[i]);
-		}
-
-		*new_prefix.ptr = *prefix.ptr;
-		prefix.ptr->Clear();
-		Node::Free(art, current_node);
-		current_node = *new_prefix.ptr;
-	}
-
-	node = new_node;
-	return Node::TransformToDeprecated(art, *new_prefix.ptr, allocator);
-}
-
-Prefix Prefix::Append(ART &art, const uint8_t byte) {
-	if (data[Count(art)] != Count(art)) {
-		data[data[Count(art)]] = byte;
-		data[Count(art)]++;
-		return *this;
-	}
-
-	auto prefix = NewInternal(art, *ptr, nullptr, 0, 0, PREFIX);
-	return prefix.Append(art, byte);
-}
-
-void Prefix::Append(ART &art, Node other) {
-	D_ASSERT(other.HasMetadata());
-
-	Prefix prefix = *this;
-	while (other.GetType() == PREFIX) {
-		if (other.GetGateStatus() == GateStatus::GATE_SET) {
-			*prefix.ptr = other;
-			return;
-		}
-
-		Prefix other_prefix(art, other, true);
-		for (idx_t i = 0; i < other_prefix.data[Count(art)]; i++) {
-			prefix = prefix.Append(art, other_prefix.data[i]);
-		}
-
-		*prefix.ptr = *other_prefix.ptr;
-		Node::GetAllocator(art, PREFIX).Free(other);
-		other = *prefix.ptr;
-	}
-}
-
-Prefix Prefix::GetTail(ART &art, const Node &node) {
-	Prefix prefix(art, node, true);
-	while (prefix.ptr->GetType() == PREFIX) {
-		prefix = Prefix(art, *prefix.ptr, true);
-	}
-	return prefix;
-}
-
-void Prefix::ConcatGate(ART &art, Node &parent, uint8_t byte, const Node &child) {
-	D_ASSERT(child.HasMetadata());
-	Node new_prefix = Node();
-
-	// Inside gates, inlined row IDs are not prefixed.
-	if (child.GetType() == NType::LEAF_INLINED) {
-		Leaf::New(new_prefix, child.GetRowId());
-
-	} else if (child.GetType() == PREFIX) {
-		// At least one more row ID in this gate.
-		auto prefix = NewInternal(art, new_prefix, &byte, 1, 0, PREFIX);
-		prefix.ptr->Clear();
-		prefix.Append(art, child);
-		new_prefix.SetGateStatus(GateStatus::GATE_SET);
-
-	} else {
-		// At least one more row ID in this gate.
-		auto prefix = NewInternal(art, new_prefix, &byte, 1, 0, PREFIX);
-		*prefix.ptr = child;
-		new_prefix.SetGateStatus(GateStatus::GATE_SET);
-	}
-
-	if (parent.GetType() != PREFIX) {
-		parent = new_prefix;
-		return;
-	}
-	*GetTail(art, parent).ptr = new_prefix;
-}
-
-void Prefix::ConcatChildIsGate(ART &art, Node &parent, uint8_t byte, const Node &child) {
-	// Create a new prefix and point it to the gate.
-	if (parent.GetType() != PREFIX) {
-		auto prefix = NewInternal(art, parent, &byte, 1, 0, PREFIX);
-		*prefix.ptr = child;
-		return;
-	}
-
-	auto tail = GetTail(art, parent);
-	tail = tail.Append(art, byte);
-	*tail.ptr = child;
-}
-
-Prefix Prefix::TransformToDeprecatedAppend(ART &art, unsafe_unique_ptr<FixedSizeAllocator> &allocator, uint8_t byte) {
-	if (data[DEPRECATED_COUNT] != DEPRECATED_COUNT) {
-		data[data[DEPRECATED_COUNT]] = byte;
-		data[DEPRECATED_COUNT]++;
-		return *this;
-	}
-
-	*ptr = allocator->New();
-	ptr->SetMetadata(static_cast<uint8_t>(PREFIX));
-	Prefix prefix(allocator, *ptr, DEPRECATED_COUNT);
-	return prefix.TransformToDeprecatedAppend(art, allocator, byte);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/bound_index.cpp b/src/duckdb/src/execution/index/bound_index.cpp
deleted file mode 100644
index 199cc4bdd..000000000
--- a/src/duckdb/src/execution/index/bound_index.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "duckdb/execution/index/bound_index.hpp"
-
-#include "duckdb/common/radix.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-
-namespace duckdb {
-
-//-------------------------------------------------------------------------------
-// Bound index
-//-------------------------------------------------------------------------------
-
-BoundIndex::BoundIndex(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
-                       const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-                       const vector<unique_ptr<Expression>> &unbound_expressions_p, AttachedDatabase &db)
-    : Index(column_ids, table_io_manager, db), name(name), index_type(index_type),
-      index_constraint_type(index_constraint_type) {
-
-	for (auto &expr : unbound_expressions_p) {
-		types.push_back(expr->return_type.InternalType());
-		logical_types.push_back(expr->return_type);
-		unbound_expressions.emplace_back(expr->Copy());
-		bound_expressions.push_back(BindExpression(expr->Copy()));
-		executor.AddExpression(*bound_expressions.back());
-	}
-}
-
-void BoundIndex::InitializeLock(IndexLock &state) {
-	state.index_lock = unique_lock<mutex>(lock);
-}
-
-ErrorData BoundIndex::Append(DataChunk &chunk, Vector &row_ids) {
-	IndexLock l;
-	InitializeLock(l);
-	return Append(l, chunk, row_ids);
-}
-
-ErrorData BoundIndex::AppendWithDeleteIndex(IndexLock &l, DataChunk &chunk, Vector &row_ids,
-                                            optional_ptr<BoundIndex> delete_index) {
-	// Fallback to the old Append.
-	return Append(l, chunk, row_ids);
-}
-
-ErrorData BoundIndex::AppendWithDeleteIndex(DataChunk &chunk, Vector &row_ids, optional_ptr<BoundIndex> delete_index) {
-	IndexLock l;
-	InitializeLock(l);
-	return AppendWithDeleteIndex(l, chunk, row_ids, delete_index);
-}
-
-void BoundIndex::VerifyAppend(DataChunk &chunk, optional_ptr<BoundIndex> delete_index,
-                              optional_ptr<ConflictManager> manager) {
-	throw NotImplementedException("this implementation of VerifyAppend does not exist.");
-}
-
-void BoundIndex::VerifyConstraint(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, ConflictManager &manager) {
-	throw NotImplementedException("this implementation of VerifyConstraint does not exist.");
-}
-
-void BoundIndex::CommitDrop() {
-	IndexLock index_lock;
-	InitializeLock(index_lock);
-	CommitDrop(index_lock);
-}
-
-void BoundIndex::Delete(DataChunk &entries, Vector &row_identifiers) {
-	IndexLock state;
-	InitializeLock(state);
-	Delete(state, entries, row_identifiers);
-}
-
-ErrorData BoundIndex::Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids, optional_ptr<BoundIndex> delete_index) {
-	throw NotImplementedException("this implementation of Insert does not exist.");
-}
-
-bool BoundIndex::MergeIndexes(BoundIndex &other_index) {
-	IndexLock state;
-	InitializeLock(state);
-	return MergeIndexes(state, other_index);
-}
-
-string BoundIndex::VerifyAndToString(const bool only_verify) {
-	IndexLock state;
-	InitializeLock(state);
-	return VerifyAndToString(state, only_verify);
-}
-
-void BoundIndex::VerifyAllocations() {
-	IndexLock state;
-	InitializeLock(state);
-	return VerifyAllocations(state);
-}
-
-void BoundIndex::Vacuum() {
-	IndexLock state;
-	InitializeLock(state);
-	Vacuum(state);
-}
-
-idx_t BoundIndex::GetInMemorySize() {
-	IndexLock state;
-	InitializeLock(state);
-	return GetInMemorySize(state);
-}
-
-void BoundIndex::ExecuteExpressions(DataChunk &input, DataChunk &result) {
-	executor.Execute(input, result);
-}
-
-unique_ptr<Expression> BoundIndex::BindExpression(unique_ptr<Expression> expr) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-		return make_uniq<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [this](unique_ptr<Expression> &expr) { expr = BindExpression(std::move(expr)); });
-	return expr;
-}
-
-bool BoundIndex::IndexIsUpdated(const vector<PhysicalIndex> &column_ids_p) const {
-	for (auto &column : column_ids_p) {
-		if (column_id_set.find(column.index) != column_id_set.end()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-IndexStorageInfo BoundIndex::GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal) {
-	throw NotImplementedException("The implementation of this index serialization does not exist.");
-}
-
-string BoundIndex::AppendRowError(DataChunk &input, idx_t index) {
-	string error;
-	for (idx_t c = 0; c < input.ColumnCount(); c++) {
-		if (c > 0) {
-			error += ", ";
-		}
-		error += input.GetValue(c, index).ToString();
-	}
-	return error;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/fixed_size_allocator.cpp b/src/duckdb/src/execution/index/fixed_size_allocator.cpp
deleted file mode 100644
index 24ea09181..000000000
--- a/src/duckdb/src/execution/index/fixed_size_allocator.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-
-namespace duckdb {
-
-FixedSizeAllocator::FixedSizeAllocator(const idx_t segment_size, BlockManager &block_manager)
-    : block_manager(block_manager), buffer_manager(block_manager.buffer_manager), segment_size(segment_size),
-      total_segment_count(0) {
-
-	if (segment_size > block_manager.GetBlockSize() - sizeof(validity_t)) {
-		throw InternalException("The maximum segment size of fixed-size allocators is " +
-		                        to_string(block_manager.GetBlockSize() - sizeof(validity_t)));
-	}
-
-	// calculate how many segments fit into one buffer (available_segments_per_buffer)
-
-	idx_t bits_per_value = sizeof(validity_t) * 8;
-	idx_t byte_count = 0;
-
-	bitmask_count = 0;
-	available_segments_per_buffer = 0;
-
-	while (byte_count < block_manager.GetBlockSize()) {
-		if (!bitmask_count || (bitmask_count * bits_per_value) % available_segments_per_buffer == 0) {
-			// we need to add another validity_t value to the bitmask, to allow storing another
-			// bits_per_value segments on a buffer
-			bitmask_count++;
-			byte_count += sizeof(validity_t);
-		}
-
-		auto remaining_bytes = block_manager.GetBlockSize() - byte_count;
-		auto remaining_segments = MinValue(remaining_bytes / segment_size, bits_per_value);
-
-		if (remaining_segments == 0) {
-			break;
-		}
-
-		available_segments_per_buffer += remaining_segments;
-		byte_count += remaining_segments * segment_size;
-	}
-
-	bitmask_offset = bitmask_count * sizeof(validity_t);
-}
-
-IndexPointer FixedSizeAllocator::New() {
-	// no more segments available
-	if (buffers_with_free_space.empty()) {
-
-		// add a new buffer
-		auto buffer_id = GetAvailableBufferId();
-		FixedSizeBuffer new_buffer(block_manager);
-		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
-		buffers_with_free_space.insert(buffer_id);
-
-		// set the bitmask
-		D_ASSERT(buffers.find(buffer_id) != buffers.end());
-		auto &buffer = buffers.find(buffer_id)->second;
-		ValidityMask mask(reinterpret_cast<validity_t *>(buffer.Get()), available_segments_per_buffer);
-
-		// zero-initialize the bitmask to avoid leaking memory to disk
-		auto data = mask.GetData();
-		for (idx_t i = 0; i < bitmask_count; i++) {
-			data[i] = 0;
-		}
-
-		// initializing the bitmask of the new buffer
-		mask.SetAllValid(available_segments_per_buffer);
-	}
-
-	// return a pointer to a free segment
-	D_ASSERT(!buffers_with_free_space.empty());
-	auto buffer_id = uint32_t(*buffers_with_free_space.begin());
-
-	D_ASSERT(buffers.find(buffer_id) != buffers.end());
-	auto &buffer = buffers.find(buffer_id)->second;
-	auto offset = buffer.GetOffset(bitmask_count, available_segments_per_buffer);
-
-	total_segment_count++;
-	buffer.segment_count++;
-	if (buffer.segment_count == available_segments_per_buffer) {
-		buffers_with_free_space.erase(buffer_id);
-	}
-
-	// zero-initialize that segment
-	auto buffer_ptr = buffer.Get();
-	auto offset_in_buffer = buffer_ptr + offset * segment_size + bitmask_offset;
-	memset(offset_in_buffer, 0, segment_size);
-
-	return IndexPointer(buffer_id, offset);
-}
-
-void FixedSizeAllocator::Free(const IndexPointer ptr) {
-
-	auto buffer_id = ptr.GetBufferId();
-	auto offset = ptr.GetOffset();
-
-	D_ASSERT(buffers.find(buffer_id) != buffers.end());
-	auto &buffer = buffers.find(buffer_id)->second;
-
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffer.Get());
-	ValidityMask mask(bitmask_ptr, offset + 1); // FIXME
-	D_ASSERT(!mask.RowIsValid(offset));
-	mask.SetValid(offset);
-
-	D_ASSERT(total_segment_count > 0);
-	D_ASSERT(buffer.segment_count > 0);
-
-	// adjust the allocator fields
-	buffers_with_free_space.insert(buffer_id);
-	total_segment_count--;
-	buffer.segment_count--;
-}
-
-void FixedSizeAllocator::Reset() {
-	for (auto &buffer : buffers) {
-		buffer.second.Destroy();
-	}
-	buffers.clear();
-	buffers_with_free_space.clear();
-	total_segment_count = 0;
-}
-
-idx_t FixedSizeAllocator::GetInMemorySize() const {
-	idx_t memory_usage = 0;
-	for (auto &buffer : buffers) {
-		if (buffer.second.InMemory()) {
-			memory_usage += block_manager.GetBlockSize();
-		}
-	}
-	return memory_usage;
-}
-
-idx_t FixedSizeAllocator::GetUpperBoundBufferId() const {
-	idx_t upper_bound_id = 0;
-	for (auto &buffer : buffers) {
-		if (buffer.first >= upper_bound_id) {
-			upper_bound_id = buffer.first + 1;
-		}
-	}
-	return upper_bound_id;
-}
-
-void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
-
-	D_ASSERT(segment_size == other.segment_size);
-
-	// remember the buffer count and merge the buffers
-	idx_t upper_bound_id = GetUpperBoundBufferId();
-	for (auto &buffer : other.buffers) {
-		buffers.insert(make_pair(buffer.first + upper_bound_id, std::move(buffer.second)));
-	}
-	other.buffers.clear();
-
-	// merge the buffers with free spaces
-	for (auto &buffer_id : other.buffers_with_free_space) {
-		buffers_with_free_space.insert(buffer_id + upper_bound_id);
-	}
-	other.buffers_with_free_space.clear();
-
-	// add the total allocations
-	total_segment_count += other.total_segment_count;
-}
-
-bool FixedSizeAllocator::InitializeVacuum() {
-
-	// NOTE: we do not vacuum buffers that are not in memory. We might consider changing this
-	// in the future, although buffers on disk should almost never be eligible for a vacuum
-
-	if (total_segment_count == 0) {
-		Reset();
-		return false;
-	}
-	RemoveEmptyBuffers();
-
-	// determine if a vacuum is necessary
-	multimap<idx_t, idx_t> temporary_vacuum_buffers;
-	D_ASSERT(vacuum_buffers.empty());
-	idx_t available_segments_in_memory = 0;
-
-	for (auto &buffer : buffers) {
-		buffer.second.vacuum = false;
-		if (buffer.second.InMemory()) {
-			auto available_segments_in_buffer = available_segments_per_buffer - buffer.second.segment_count;
-			available_segments_in_memory += available_segments_in_buffer;
-			temporary_vacuum_buffers.emplace(available_segments_in_buffer, buffer.first);
-		}
-	}
-
-	// no buffers in memory
-	if (temporary_vacuum_buffers.empty()) {
-		return false;
-	}
-
-	auto excess_buffer_count = available_segments_in_memory / available_segments_per_buffer;
-
-	// calculate the vacuum threshold adaptively
-	D_ASSERT(excess_buffer_count < temporary_vacuum_buffers.size());
-	idx_t memory_usage = GetInMemorySize();
-	idx_t excess_memory_usage = excess_buffer_count * block_manager.GetBlockSize();
-	auto excess_percentage = double(excess_memory_usage) / double(memory_usage);
-	auto threshold = double(VACUUM_THRESHOLD) / 100.0;
-	if (excess_percentage < threshold) {
-		return false;
-	}
-
-	D_ASSERT(excess_buffer_count <= temporary_vacuum_buffers.size());
-	D_ASSERT(temporary_vacuum_buffers.size() <= buffers.size());
-
-	// erasing from a multimap, we vacuum the buffers with the most free spaces (least full)
-	while (temporary_vacuum_buffers.size() != excess_buffer_count) {
-		temporary_vacuum_buffers.erase(temporary_vacuum_buffers.begin());
-	}
-
-	// adjust the buffers, and erase all to-be-vacuumed buffers from the available buffer list
-	for (auto &vacuum_buffer : temporary_vacuum_buffers) {
-		auto buffer_id = vacuum_buffer.second;
-		D_ASSERT(buffers.find(buffer_id) != buffers.end());
-		buffers.find(buffer_id)->second.vacuum = true;
-		buffers_with_free_space.erase(buffer_id);
-	}
-
-	for (auto &vacuum_buffer : temporary_vacuum_buffers) {
-		vacuum_buffers.insert(vacuum_buffer.second);
-	}
-
-	return true;
-}
-
-void FixedSizeAllocator::FinalizeVacuum() {
-
-	for (auto &buffer_id : vacuum_buffers) {
-		D_ASSERT(buffers.find(buffer_id) != buffers.end());
-		auto &buffer = buffers.find(buffer_id)->second;
-		D_ASSERT(buffer.InMemory());
-		buffer.Destroy();
-		buffers.erase(buffer_id);
-	}
-	vacuum_buffers.clear();
-}
-
-IndexPointer FixedSizeAllocator::VacuumPointer(const IndexPointer ptr) {
-
-	// we do not need to adjust the bitmask of the old buffer, because we will free the entire
-	// buffer after the vacuum operation
-
-	auto new_ptr = New();
-	// new increases the allocation count, we need to counter that here
-	total_segment_count--;
-
-	memcpy(Get(new_ptr), Get(ptr), segment_size);
-	return new_ptr;
-}
-
-FixedSizeAllocatorInfo FixedSizeAllocator::GetInfo() const {
-
-	FixedSizeAllocatorInfo info;
-	info.segment_size = segment_size;
-
-	for (const auto &buffer : buffers) {
-		info.buffer_ids.push_back(buffer.first);
-		info.block_pointers.push_back(buffer.second.block_pointer);
-		info.segment_counts.push_back(buffer.second.segment_count);
-		info.allocation_sizes.push_back(buffer.second.allocation_size);
-	}
-
-	for (auto &buffer_id : buffers_with_free_space) {
-		info.buffers_with_free_space.push_back(buffer_id);
-	}
-
-	return info;
-}
-
-void FixedSizeAllocator::SerializeBuffers(PartialBlockManager &partial_block_manager) {
-	for (auto &buffer : buffers) {
-		buffer.second.Serialize(partial_block_manager, available_segments_per_buffer, segment_size, bitmask_offset);
-	}
-}
-
-vector<IndexBufferInfo> FixedSizeAllocator::InitSerializationToWAL() {
-
-	vector<IndexBufferInfo> buffer_infos;
-	for (auto &buffer : buffers) {
-		buffer.second.SetAllocationSize(available_segments_per_buffer, segment_size, bitmask_offset);
-		buffer_infos.emplace_back(buffer.second.Get(), buffer.second.allocation_size);
-	}
-	return buffer_infos;
-}
-
-void FixedSizeAllocator::Init(const FixedSizeAllocatorInfo &info) {
-	segment_size = info.segment_size;
-	total_segment_count = 0;
-
-	for (idx_t i = 0; i < info.buffer_ids.size(); i++) {
-
-		// read all FixedSizeBuffer data
-		auto buffer_id = info.buffer_ids[i];
-		auto buffer_block_pointer = info.block_pointers[i];
-		auto segment_count = info.segment_counts[i];
-		auto allocation_size = info.allocation_sizes[i];
-
-		// create the FixedSizeBuffer
-		FixedSizeBuffer new_buffer(block_manager, segment_count, allocation_size, buffer_block_pointer);
-		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
-		total_segment_count += segment_count;
-	}
-
-	for (const auto &buffer_id : info.buffers_with_free_space) {
-		buffers_with_free_space.insert(buffer_id);
-	}
-}
-
-void FixedSizeAllocator::Deserialize(MetadataManager &metadata_manager, const BlockPointer &block_pointer) {
-
-	MetadataReader reader(metadata_manager, block_pointer);
-	segment_size = reader.Read<idx_t>();
-	auto buffer_count = reader.Read<idx_t>();
-	auto buffers_with_free_space_count = reader.Read<idx_t>();
-
-	total_segment_count = 0;
-
-	for (idx_t i = 0; i < buffer_count; i++) {
-		auto buffer_id = reader.Read<idx_t>();
-		auto buffer_block_pointer = reader.Read<BlockPointer>();
-		auto segment_count = reader.Read<idx_t>();
-		auto allocation_size = reader.Read<idx_t>();
-		FixedSizeBuffer new_buffer(block_manager, segment_count, allocation_size, buffer_block_pointer);
-		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
-		total_segment_count += segment_count;
-	}
-	for (idx_t i = 0; i < buffers_with_free_space_count; i++) {
-		buffers_with_free_space.insert(reader.Read<idx_t>());
-	}
-}
-
-idx_t FixedSizeAllocator::GetAvailableBufferId() const {
-	idx_t buffer_id = buffers.size();
-	while (buffers.find(buffer_id) != buffers.end()) {
-		D_ASSERT(buffer_id > 0);
-		buffer_id--;
-	}
-	return buffer_id;
-}
-
-void FixedSizeAllocator::RemoveEmptyBuffers() {
-
-	auto buffer_it = buffers.begin();
-	while (buffer_it != buffers.end()) {
-		if (buffer_it->second.segment_count != 0) {
-			buffer_it++;
-			continue;
-		}
-
-		buffers_with_free_space.erase(buffer_it->first);
-		buffer_it->second.Destroy();
-		buffer_it = buffers.erase(buffer_it);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/fixed_size_buffer.cpp b/src/duckdb/src/execution/index/fixed_size_buffer.cpp
deleted file mode 100644
index 336d96396..000000000
--- a/src/duckdb/src/execution/index/fixed_size_buffer.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-#include "duckdb/execution/index/fixed_size_buffer.hpp"
-
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// PartialBlockForIndex
-//===--------------------------------------------------------------------===//
-
-PartialBlockForIndex::PartialBlockForIndex(PartialBlockState state, BlockManager &block_manager,
-                                           const shared_ptr<BlockHandle> &block_handle)
-    : PartialBlock(state, block_manager, block_handle) {
-}
-
-void PartialBlockForIndex::Flush(const idx_t free_space_left) {
-	FlushInternal(free_space_left);
-	block_handle = block_manager.ConvertToPersistent(state.block_id, std::move(block_handle));
-	Clear();
-}
-
-void PartialBlockForIndex::Merge(PartialBlock &other, idx_t offset, idx_t other_size) {
-	throw InternalException("no merge for PartialBlockForIndex");
-}
-
-void PartialBlockForIndex::Clear() {
-	block_handle.reset();
-}
-
-//===--------------------------------------------------------------------===//
-// FixedSizeBuffer
-//===--------------------------------------------------------------------===//
-
-constexpr idx_t FixedSizeBuffer::BASE[];
-constexpr uint8_t FixedSizeBuffer::SHIFT[];
-
-FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager)
-    : block_manager(block_manager), segment_count(0), allocation_size(0), dirty(false), vacuum(false), block_pointer(),
-      block_handle(nullptr) {
-
-	auto &buffer_manager = block_manager.buffer_manager;
-	buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager.GetBlockSize(), false);
-	block_handle = buffer_handle.GetBlockHandle();
-}
-
-FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size,
-                                 const BlockPointer &block_pointer)
-    : block_manager(block_manager), segment_count(segment_count), allocation_size(allocation_size), dirty(false),
-      vacuum(false), block_pointer(block_pointer) {
-
-	D_ASSERT(block_pointer.IsValid());
-	block_handle = block_manager.RegisterBlock(block_pointer.block_id);
-	D_ASSERT(block_handle->BlockId() < MAXIMUM_BLOCK);
-}
-
-void FixedSizeBuffer::Destroy() {
-	if (InMemory()) {
-		// we can have multiple readers on a pinned block, and unpinning the buffer handle
-		// decrements the reader count on the underlying block handle (Destroy() unpins)
-		buffer_handle.Destroy();
-	}
-	if (OnDisk()) {
-		// marking a block as modified decreases the reference count of multi-use blocks
-		block_manager.MarkBlockAsModified(block_pointer.block_id);
-	}
-}
-
-void FixedSizeBuffer::Serialize(PartialBlockManager &partial_block_manager, const idx_t available_segments,
-                                const idx_t segment_size, const idx_t bitmask_offset) {
-
-	// Early-out, if the block is already on disk and not in memory.
-	if (!InMemory()) {
-		if (!OnDisk() || dirty) {
-			throw InternalException("invalid or missing buffer in FixedSizeAllocator");
-		}
-		return;
-	}
-
-	// Early-out, if the buffer is already on disk and not dirty.
-	if (!dirty && OnDisk()) {
-		return;
-	}
-
-	// Adjust the allocation size.
-	D_ASSERT(segment_count != 0);
-	SetAllocationSize(available_segments, segment_size, bitmask_offset);
-
-	// the buffer is in memory, so we copied it onto a new buffer when pinning
-	D_ASSERT(InMemory());
-	if (OnDisk()) {
-		block_manager.MarkBlockAsModified(block_pointer.block_id);
-	}
-
-	// now we write the changes, first get a partial block allocation
-	PartialBlockAllocation allocation =
-	    partial_block_manager.GetBlockAllocation(NumericCast<uint32_t>(allocation_size));
-	block_pointer.block_id = allocation.state.block_id;
-	block_pointer.offset = allocation.state.offset;
-
-	auto &buffer_manager = block_manager.buffer_manager;
-
-	if (allocation.partial_block) {
-		// copy to an existing partial block
-		D_ASSERT(block_pointer.offset > 0);
-		auto &p_block_for_index = allocation.partial_block->Cast<PartialBlockForIndex>();
-		auto dst_handle = buffer_manager.Pin(p_block_for_index.block_handle);
-		memcpy(dst_handle.Ptr() + block_pointer.offset, buffer_handle.Ptr(), allocation_size);
-		SetUninitializedRegions(p_block_for_index, segment_size, block_pointer.offset, bitmask_offset,
-		                        available_segments);
-
-	} else {
-		// create a new block that can potentially be used as a partial block
-		D_ASSERT(block_handle);
-		D_ASSERT(!block_pointer.offset);
-		auto p_block_for_index = make_uniq<PartialBlockForIndex>(allocation.state, block_manager, block_handle);
-		SetUninitializedRegions(*p_block_for_index, segment_size, block_pointer.offset, bitmask_offset,
-		                        available_segments);
-		allocation.partial_block = std::move(p_block_for_index);
-	}
-
-	// resetting this buffer
-	buffer_handle.Destroy();
-
-	// register the partial block
-	partial_block_manager.RegisterPartialBlock(std::move(allocation));
-
-	block_handle = block_manager.RegisterBlock(block_pointer.block_id);
-	D_ASSERT(block_handle->BlockId() < MAXIMUM_BLOCK);
-
-	// we persist any changes, so the buffer is no longer dirty
-	dirty = false;
-}
-
-void FixedSizeBuffer::Pin() {
-	auto &buffer_manager = block_manager.buffer_manager;
-	D_ASSERT(block_pointer.IsValid());
-	D_ASSERT(block_handle && block_handle->BlockId() < MAXIMUM_BLOCK);
-	D_ASSERT(!dirty);
-
-	buffer_handle = buffer_manager.Pin(block_handle);
-
-	// Copy the (partial) data into a new (not yet disk-backed) buffer handle.
-	shared_ptr<BlockHandle> new_block_handle;
-	auto new_buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager.GetBlockSize(), false);
-	new_block_handle = new_buffer_handle.GetBlockHandle();
-	memcpy(new_buffer_handle.Ptr(), buffer_handle.Ptr() + block_pointer.offset, allocation_size);
-
-	buffer_handle = std::move(new_buffer_handle);
-	block_handle = std::move(new_block_handle);
-}
-
-uint32_t FixedSizeBuffer::GetOffset(const idx_t bitmask_count, const idx_t available_segments) {
-
-	// get the bitmask data
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(Get());
-	ValidityMask mask(bitmask_ptr, available_segments);
-	auto data = mask.GetData();
-
-	// fills up a buffer sequentially before searching for free bits
-	if (mask.RowIsValid(segment_count)) {
-		mask.SetInvalid(segment_count);
-		return UnsafeNumericCast<uint32_t>(segment_count);
-	}
-
-	for (idx_t entry_idx = 0; entry_idx < bitmask_count; entry_idx++) {
-		// get an entry with free bits
-		if (data[entry_idx] == 0) {
-			continue;
-		}
-
-		// find the position of the free bit
-		auto entry = data[entry_idx];
-		idx_t first_valid_bit = 0;
-
-		// this loop finds the position of the rightmost set bit in entry and stores it
-		// in first_valid_bit
-		for (idx_t i = 0; i < 6; i++) {
-			// set the left half of the bits of this level to zero and test if the entry is still not zero
-			if (entry & BASE[i]) {
-				// first valid bit is in the rightmost s[i] bits
-				// permanently set the left half of the bits to zero
-				entry &= BASE[i];
-			} else {
-				// first valid bit is in the leftmost s[i] bits
-				// shift by s[i] for the next iteration and add s[i] to the position of the rightmost set bit
-				entry >>= SHIFT[i];
-				first_valid_bit += SHIFT[i];
-			}
-		}
-		D_ASSERT(entry);
-
-		auto prev_bits = entry_idx * sizeof(validity_t) * 8;
-		D_ASSERT(mask.RowIsValid(prev_bits + first_valid_bit));
-		mask.SetInvalid(prev_bits + first_valid_bit);
-		return UnsafeNumericCast<uint32_t>(prev_bits + first_valid_bit);
-	}
-
-	throw InternalException("Invalid bitmask for FixedSizeAllocator");
-}
-
-void FixedSizeBuffer::SetAllocationSize(const idx_t available_segments, const idx_t segment_size,
-                                        const idx_t bitmask_offset) {
-	if (!dirty) {
-		return;
-	}
-
-	// We traverse from the back. A binary search would be faster.
-	// However, buffers are often (almost) full, so the overhead is acceptable.
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(Get());
-	ValidityMask mask(bitmask_ptr, available_segments);
-
-	auto max_offset = available_segments;
-	for (idx_t i = available_segments; i > 0; i--) {
-		if (!mask.RowIsValid(i - 1)) {
-			max_offset = i;
-			break;
-		}
-	}
-	allocation_size = max_offset * segment_size + bitmask_offset;
-}
-
-void FixedSizeBuffer::SetUninitializedRegions(PartialBlockForIndex &p_block_for_index, const idx_t segment_size,
-                                              const idx_t offset, const idx_t bitmask_offset,
-                                              const idx_t available_segments) {
-
-	// this function calls Get() on the buffer
-	D_ASSERT(InMemory());
-
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(Get());
-	ValidityMask mask(bitmask_ptr, available_segments);
-
-	idx_t i = 0;
-	idx_t max_offset = offset + allocation_size;
-	idx_t current_offset = offset + bitmask_offset;
-	while (current_offset < max_offset) {
-
-		if (mask.RowIsValid(i)) {
-			D_ASSERT(current_offset + segment_size <= max_offset);
-			p_block_for_index.AddUninitializedRegion(current_offset, current_offset + segment_size);
-		}
-		current_offset += segment_size;
-		i++;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/index_type_set.cpp b/src/duckdb/src/execution/index/index_type_set.cpp
deleted file mode 100644
index 4fe7cda4f..000000000
--- a/src/duckdb/src/execution/index/index_type_set.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/execution/index/index_type.hpp"
-#include "duckdb/execution/index/index_type_set.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-
-namespace duckdb {
-
-IndexTypeSet::IndexTypeSet() {
-
-	// Register the ART index type by default
-	IndexType art_index_type;
-	art_index_type.name = ART::TYPE_NAME;
-	art_index_type.create_instance = ART::Create;
-	art_index_type.create_plan = ART::CreatePlan;
-
-	RegisterIndexType(art_index_type);
-}
-
-optional_ptr<IndexType> IndexTypeSet::FindByName(const string &name) {
-	lock_guard<mutex> g(lock);
-	auto entry = functions.find(name);
-	if (entry == functions.end()) {
-		return nullptr;
-	}
-	return &entry->second;
-}
-
-void IndexTypeSet::RegisterIndexType(const IndexType &index_type) {
-	lock_guard<mutex> g(lock);
-	if (functions.find(index_type.name) != functions.end()) {
-		throw CatalogException("Index type with name \"%s\" already exists!", index_type.name.c_str());
-	}
-	functions[index_type.name] = index_type;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/index/unbound_index.cpp b/src/duckdb/src/execution/index/unbound_index.cpp
deleted file mode 100644
index b8173d751..000000000
--- a/src/duckdb/src/execution/index/unbound_index.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "duckdb/execution/index/unbound_index.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/index_storage_info.hpp"
-
-namespace duckdb {
-
-//-------------------------------------------------------------------------------
-// Unbound index
-//-------------------------------------------------------------------------------
-
-UnboundIndex::UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo storage_info_p,
-                           TableIOManager &table_io_manager, AttachedDatabase &db)
-    : Index(create_info->Cast<CreateIndexInfo>().column_ids, table_io_manager, db), create_info(std::move(create_info)),
-      storage_info(std::move(storage_info_p)) {
-}
-
-void UnboundIndex::CommitDrop() {
-	auto &block_manager = table_io_manager.GetIndexBlockManager();
-	for (auto &info : storage_info.allocator_infos) {
-		for (auto &block : info.block_pointers) {
-			if (block.IsValid()) {
-				block_manager.MarkBlockAsModified(block.block_id);
-			}
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/join_hashtable.cpp b/src/duckdb/src/execution/join_hashtable.cpp
deleted file mode 100644
index 14abdc61e..000000000
--- a/src/duckdb/src/execution/join_hashtable.cpp
+++ /dev/null
@@ -1,1679 +0,0 @@
-#include "duckdb/execution/join_hashtable.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/ht_entry.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-using ValidityBytes = JoinHashTable::ValidityBytes;
-using ScanStructure = JoinHashTable::ScanStructure;
-using ProbeSpill = JoinHashTable::ProbeSpill;
-using ProbeSpillLocalState = JoinHashTable::ProbeSpillLocalAppendState;
-
-JoinHashTable::SharedState::SharedState()
-    : rhs_row_locations(LogicalType::POINTER), salt_v(LogicalType::UBIGINT), salt_match_sel(STANDARD_VECTOR_SIZE),
-      key_no_match_sel(STANDARD_VECTOR_SIZE) {
-}
-
-JoinHashTable::ProbeState::ProbeState()
-    : SharedState(), ht_offsets_v(LogicalType::UBIGINT), ht_offsets_dense_v(LogicalType::UBIGINT),
-      non_empty_sel(STANDARD_VECTOR_SIZE) {
-}
-
-JoinHashTable::InsertState::InsertState(const JoinHashTable &ht)
-    : SharedState(), remaining_sel(STANDARD_VECTOR_SIZE), key_match_sel(STANDARD_VECTOR_SIZE) {
-	ht.data_collection->InitializeChunk(lhs_data, ht.equality_predicate_columns);
-	ht.data_collection->InitializeChunkState(chunk_state, ht.equality_predicate_columns);
-}
-
-JoinHashTable::JoinHashTable(ClientContext &context, const vector<JoinCondition> &conditions_p,
-                             vector<LogicalType> btypes, JoinType type_p, const vector<idx_t> &output_columns_p)
-    : buffer_manager(BufferManager::GetBufferManager(context)), conditions(conditions_p),
-      build_types(std::move(btypes)), output_columns(output_columns_p), entry_size(0), tuple_size(0),
-      vfound(Value::BOOLEAN(false)), join_type(type_p), finalized(false), has_null(false),
-      radix_bits(INITIAL_RADIX_BITS) {
-	for (idx_t i = 0; i < conditions.size(); ++i) {
-		auto &condition = conditions[i];
-		D_ASSERT(condition.left->return_type == condition.right->return_type);
-		auto type = condition.left->return_type;
-		if (condition.comparison == ExpressionType::COMPARE_EQUAL ||
-		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-
-			// ensure that all equality conditions are at the front,
-			// and that all other conditions are at the back
-			D_ASSERT(equality_types.size() == condition_types.size());
-			equality_types.push_back(type);
-			equality_predicates.push_back(condition.comparison);
-			equality_predicate_columns.push_back(i);
-
-		} else {
-			// all non-equality conditions are at the back
-			non_equality_predicates.push_back(condition.comparison);
-			non_equality_predicate_columns.push_back(i);
-		}
-
-		null_values_are_equal.push_back(condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-		                                condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM);
-
-		condition_types.push_back(type);
-	}
-	// at least one equality is necessary
-	D_ASSERT(!equality_types.empty());
-
-	// Types for the layout
-	vector<LogicalType> layout_types(condition_types);
-	layout_types.insert(layout_types.end(), build_types.begin(), build_types.end());
-	if (PropagatesBuildSide(join_type)) {
-		// full/right outer joins need an extra bool to keep track of whether or not a tuple has found a matching entry
-		// we place the bool before the NEXT pointer
-		layout_types.emplace_back(LogicalType::BOOLEAN);
-	}
-	layout_types.emplace_back(LogicalType::HASH);
-	layout.Initialize(layout_types, false);
-
-	// Initialize the row matcher that are used for filtering during the probing only if there are non-equality
-	if (!non_equality_predicates.empty()) {
-
-		row_matcher_probe = unique_ptr<RowMatcher>(new RowMatcher());
-		row_matcher_probe_no_match_sel = unique_ptr<RowMatcher>(new RowMatcher());
-
-		row_matcher_probe->Initialize(false, layout, non_equality_predicates, non_equality_predicate_columns);
-		row_matcher_probe_no_match_sel->Initialize(true, layout, non_equality_predicates,
-		                                           non_equality_predicate_columns);
-
-		needs_chain_matcher = true;
-	} else {
-		needs_chain_matcher = false;
-	}
-
-	chains_longer_than_one = false;
-	row_matcher_build.Initialize(true, layout, equality_predicates);
-
-	const auto &offsets = layout.GetOffsets();
-	tuple_size = offsets[condition_types.size() + build_types.size()];
-	pointer_offset = offsets.back();
-	entry_size = layout.GetRowWidth();
-
-	data_collection = make_uniq<TupleDataCollection>(buffer_manager, layout);
-	sink_collection =
-	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
-
-	dead_end = make_unsafe_uniq_array_uninitialized<data_t>(layout.GetRowWidth());
-	memset(dead_end.get(), 0, layout.GetRowWidth());
-
-	if (join_type == JoinType::SINGLE) {
-		auto &config = ClientConfig::GetConfig(context);
-		single_join_error_on_multiple_rows = config.scalar_subquery_error_on_multiple_rows;
-	}
-
-	InitializePartitionMasks();
-}
-
-JoinHashTable::~JoinHashTable() {
-}
-
-void JoinHashTable::Merge(JoinHashTable &other) {
-	{
-		lock_guard<mutex> guard(data_lock);
-		data_collection->Combine(*other.data_collection);
-	}
-
-	if (join_type == JoinType::MARK) {
-		auto &info = correlated_mark_join_info;
-		lock_guard<mutex> mj_lock(info.mj_lock);
-		has_null = has_null || other.has_null;
-		if (!info.correlated_types.empty()) {
-			auto &other_info = other.correlated_mark_join_info;
-			info.correlated_counts->Combine(*other_info.correlated_counts);
-		}
-	}
-
-	sink_collection->Combine(*other.sink_collection);
-}
-
-static void ApplyBitmaskAndGetSaltBuild(Vector &hashes_v, Vector &salt_v, const idx_t &count, const idx_t &bitmask) {
-	if (hashes_v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto &hash = *ConstantVector::GetData<hash_t>(hashes_v);
-		salt_v.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		*ConstantVector::GetData<hash_t>(salt_v) = ht_entry_t::ExtractSalt(hash);
-		salt_v.Flatten(count);
-
-		hash = hash & bitmask;
-		hashes_v.Flatten(count);
-	} else {
-		hashes_v.Flatten(count);
-		auto salts = FlatVector::GetData<hash_t>(salt_v);
-		auto hashes = FlatVector::GetData<hash_t>(hashes_v);
-		for (idx_t i = 0; i < count; i++) {
-			salts[i] = ht_entry_t::ExtractSalt(hashes[i]);
-			hashes[i] &= bitmask;
-		}
-	}
-}
-
-//! Gets a pointer to the entry in the HT for each of the hashes_v using linear probing. Will update the key_match_sel
-//! vector and the count argument to the number and position of the matches
-template <bool USE_SALTS>
-static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_state,
-                                          JoinHashTable::ProbeState &state, Vector &hashes_v,
-                                          const SelectionVector &sel, idx_t &count, JoinHashTable &ht,
-                                          ht_entry_t *entries, Vector &pointers_result_v, SelectionVector &match_sel) {
-	UnifiedVectorFormat hashes_v_unified;
-	hashes_v.ToUnifiedFormat(count, hashes_v_unified);
-
-	auto hashes = UnifiedVectorFormat::GetData<hash_t>(hashes_v_unified);
-	auto salts = FlatVector::GetData<hash_t>(state.salt_v);
-
-	auto ht_offsets = FlatVector::GetData<idx_t>(state.ht_offsets_v);
-	auto ht_offsets_dense = FlatVector::GetData<idx_t>(state.ht_offsets_dense_v);
-
-	idx_t non_empty_count = 0;
-
-	// first, filter out the empty rows and calculate the offset
-	for (idx_t i = 0; i < count; i++) {
-		const auto row_index = sel.get_index(i);
-		auto uvf_index = hashes_v_unified.sel->get_index(row_index);
-		auto ht_offset = hashes[uvf_index] & ht.bitmask;
-		ht_offsets_dense[i] = ht_offset;
-		ht_offsets[row_index] = ht_offset;
-	}
-
-	// have a dense loop to have as few instructions as possible while producing cache misses as this is the
-	// first location where we access the big entries array
-	for (idx_t i = 0; i < count; i++) {
-		idx_t ht_offset = ht_offsets_dense[i];
-		auto &entry = entries[ht_offset];
-		bool occupied = entry.IsOccupied();
-		state.non_empty_sel.set_index(non_empty_count, i);
-		non_empty_count += occupied;
-	}
-
-	for (idx_t i = 0; i < non_empty_count; i++) {
-		// transform the dense index to the actual index in the sel vector
-		idx_t dense_index = state.non_empty_sel.get_index(i);
-		const auto row_index = sel.get_index(dense_index);
-		state.non_empty_sel.set_index(i, row_index);
-
-		if (USE_SALTS) {
-			auto uvf_index = hashes_v_unified.sel->get_index(row_index);
-			auto hash = hashes[uvf_index];
-			hash_t row_salt = ht_entry_t::ExtractSalt(hash);
-			salts[row_index] = row_salt;
-		}
-	}
-
-	auto pointers_result = FlatVector::GetData<data_ptr_t>(pointers_result_v);
-	auto row_ptr_insert_to = FlatVector::GetData<data_ptr_t>(state.rhs_row_locations);
-
-	const SelectionVector *remaining_sel = &state.non_empty_sel;
-	idx_t remaining_count = non_empty_count;
-
-	idx_t &match_count = count;
-	match_count = 0;
-
-	while (remaining_count > 0) {
-		idx_t salt_match_count = 0;
-		idx_t key_no_match_count = 0;
-
-		// for each entry, linear probing until
-		// a) an empty entry is found -> return nullptr (do nothing, as vector is zeroed)
-		// b) an entry is found where the salt matches -> need to compare the keys
-		for (idx_t i = 0; i < remaining_count; i++) {
-			const auto row_index = remaining_sel->get_index(i);
-
-			idx_t &ht_offset = ht_offsets[row_index];
-			bool occupied;
-			ht_entry_t entry;
-
-			if (USE_SALTS) {
-				hash_t row_salt = salts[row_index];
-				// increment the ht_offset of the entry as long as next entry is occupied and salt does not match
-				while (true) {
-					entry = entries[ht_offset];
-					occupied = entry.IsOccupied();
-					bool salt_match = entry.GetSalt() == row_salt;
-
-					// condition for incrementing the ht_offset: occupied and row_salt does not match -> move to next
-					// entry
-					if (!occupied || salt_match) {
-						break;
-					}
-
-					IncrementAndWrap(ht_offset, ht.bitmask);
-				}
-			} else {
-				entry = entries[ht_offset];
-				occupied = entry.IsOccupied();
-			}
-
-			// the entries we need to process in the next iteration are the ones that are occupied and the row_salt
-			// does not match, the ones that are empty need no further processing
-			state.salt_match_sel.set_index(salt_match_count, row_index);
-			salt_match_count += occupied;
-
-			// entry might be empty, so the pointer in the entry is nullptr, but this does not matter as the row
-			// will not be compared anyway as with an empty entry we are already done
-			row_ptr_insert_to[row_index] = entry.GetPointerOrNull();
-		}
-
-		if (salt_match_count != 0) {
-			// Perform row comparisons, after function call salt_match_sel will point to the keys that match
-			idx_t key_match_count = ht.row_matcher_build.Match(keys, key_state.vector_data, state.salt_match_sel,
-			                                                   salt_match_count, ht.layout, state.rhs_row_locations,
-			                                                   &state.key_no_match_sel, key_no_match_count);
-
-			D_ASSERT(key_match_count + key_no_match_count == salt_match_count);
-
-			// Set a pointer to the matching row
-			for (idx_t i = 0; i < key_match_count; i++) {
-				const auto row_index = state.salt_match_sel.get_index(i);
-				pointers_result[row_index] = row_ptr_insert_to[row_index];
-
-				match_sel.set_index(match_count, row_index);
-				match_count++;
-			}
-
-			// Linear probing: each of the entries that do not match move to the next entry in the HT
-			for (idx_t i = 0; i < key_no_match_count; i++) {
-				const auto row_index = state.key_no_match_sel.get_index(i);
-				auto &ht_offset = ht_offsets[row_index];
-
-				IncrementAndWrap(ht_offset, ht.bitmask);
-			}
-		}
-
-		remaining_sel = &state.key_no_match_sel;
-		remaining_count = key_no_match_count;
-	}
-}
-
-inline bool JoinHashTable::UseSalt() const {
-	// only use salt for large hash tables
-	return this->capacity > USE_SALT_THRESHOLD;
-}
-
-void JoinHashTable::GetRowPointers(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &state, Vector &hashes_v,
-                                   const SelectionVector &sel, idx_t &count, Vector &pointers_result_v,
-                                   SelectionVector &match_sel) {
-	if (UseSalt()) {
-		GetRowPointersInternal<true>(keys, key_state, state, hashes_v, sel, count, *this, entries, pointers_result_v,
-		                             match_sel);
-	} else {
-		GetRowPointersInternal<false>(keys, key_state, state, hashes_v, sel, count, *this, entries, pointers_result_v,
-		                              match_sel);
-	}
-}
-
-void JoinHashTable::Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes) {
-	if (count == keys.size()) {
-		// no null values are filtered: use regular hash functions
-		VectorOperations::Hash(keys.data[0], hashes, keys.size());
-		for (idx_t i = 1; i < equality_types.size(); i++) {
-			VectorOperations::CombineHash(hashes, keys.data[i], keys.size());
-		}
-	} else {
-		// null values were filtered: use selection vector
-		VectorOperations::Hash(keys.data[0], hashes, sel, count);
-		for (idx_t i = 1; i < equality_types.size(); i++) {
-			VectorOperations::CombineHash(hashes, keys.data[i], sel, count);
-		}
-	}
-}
-
-static idx_t FilterNullValues(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t count,
-                              SelectionVector &result) {
-	idx_t result_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto key_idx = vdata.sel->get_index(idx);
-		if (vdata.validity.RowIsValid(key_idx)) {
-			result.set_index(result_count++, idx);
-		}
-	}
-	return result_count;
-}
-
-void JoinHashTable::Build(PartitionedTupleDataAppendState &append_state, DataChunk &keys, DataChunk &payload) {
-	D_ASSERT(!finalized);
-	D_ASSERT(keys.size() == payload.size());
-	if (keys.size() == 0) {
-		return;
-	}
-	// special case: correlated mark join
-	if (join_type == JoinType::MARK && !correlated_mark_join_info.correlated_types.empty()) {
-		auto &info = correlated_mark_join_info;
-		lock_guard<mutex> mj_lock(info.mj_lock);
-		// Correlated MARK join
-		// for the correlated mark join we need to keep track of COUNT(*) and COUNT(COLUMN) for each of the correlated
-		// columns push into the aggregate hash table
-		D_ASSERT(info.correlated_counts);
-		info.group_chunk.SetCardinality(keys);
-		for (idx_t i = 0; i < info.correlated_types.size(); i++) {
-			info.group_chunk.data[i].Reference(keys.data[i]);
-		}
-		if (info.correlated_payload.data.empty()) {
-			vector<LogicalType> types;
-			types.push_back(keys.data[info.correlated_types.size()].GetType());
-			info.correlated_payload.InitializeEmpty(types);
-		}
-		info.correlated_payload.SetCardinality(keys);
-		info.correlated_payload.data[0].Reference(keys.data[info.correlated_types.size()]);
-		info.correlated_counts->AddChunk(info.group_chunk, info.correlated_payload, AggregateType::NON_DISTINCT);
-	}
-
-	// build a chunk to append to the data collection [keys, payload, (optional "found" boolean), hash]
-	DataChunk source_chunk;
-	source_chunk.InitializeEmpty(layout.GetTypes());
-	for (idx_t i = 0; i < keys.ColumnCount(); i++) {
-		source_chunk.data[i].Reference(keys.data[i]);
-	}
-	idx_t col_offset = keys.ColumnCount();
-	D_ASSERT(build_types.size() == payload.ColumnCount());
-	for (idx_t i = 0; i < payload.ColumnCount(); i++) {
-		source_chunk.data[col_offset + i].Reference(payload.data[i]);
-	}
-	col_offset += payload.ColumnCount();
-	if (PropagatesBuildSide(join_type)) {
-		// for FULL/RIGHT OUTER joins initialize the "found" boolean to false
-		source_chunk.data[col_offset].Reference(vfound);
-		col_offset++;
-	}
-	Vector hash_values(LogicalType::HASH);
-	source_chunk.data[col_offset].Reference(hash_values);
-	source_chunk.SetCardinality(keys);
-
-	// ToUnifiedFormat the source chunk
-	TupleDataCollection::ToUnifiedFormat(append_state.chunk_state, source_chunk);
-
-	// prepare the keys for processing
-	const SelectionVector *current_sel;
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	idx_t added_count = PrepareKeys(keys, append_state.chunk_state.vector_data, current_sel, sel, true);
-	if (added_count < keys.size()) {
-		has_null = true;
-	}
-	if (added_count == 0) {
-		return;
-	}
-
-	// hash the keys and obtain an entry in the list
-	// note that we only hash the keys used in the equality comparison
-	Hash(keys, *current_sel, added_count, hash_values);
-
-	// Re-reference and ToUnifiedFormat the hash column after computing it
-	source_chunk.data[col_offset].Reference(hash_values);
-	hash_values.ToUnifiedFormat(source_chunk.size(), append_state.chunk_state.vector_data.back().unified);
-
-	// We already called TupleDataCollection::ToUnifiedFormat, so we can AppendUnified here
-	sink_collection->AppendUnified(append_state, source_chunk, *current_sel, added_count);
-}
-
-idx_t JoinHashTable::PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat> &vector_data,
-                                 const SelectionVector *&current_sel, SelectionVector &sel, bool build_side) {
-	// figure out which keys are NULL, and create a selection vector out of them
-	current_sel = FlatVector::IncrementalSelectionVector();
-	idx_t added_count = keys.size();
-	if (build_side && PropagatesBuildSide(join_type)) {
-		// in case of a right or full outer join, we cannot remove NULL keys from the build side
-		return added_count;
-	}
-
-	for (idx_t col_idx = 0; col_idx < keys.ColumnCount(); col_idx++) {
-		// see internal issue 3717.
-		if (join_type == JoinType::MARK && !correlated_mark_join_info.correlated_types.empty()) {
-			continue;
-		}
-		if (null_values_are_equal[col_idx]) {
-			continue;
-		}
-		auto &col_key_data = vector_data[col_idx].unified;
-		if (col_key_data.validity.AllValid()) {
-			continue;
-		}
-		added_count = FilterNullValues(col_key_data, *current_sel, added_count, sel);
-		// null values are NOT equal for this column, filter them out
-		current_sel = &sel;
-	}
-	return added_count;
-}
-
-static void StorePointer(const const_data_ptr_t &pointer, const data_ptr_t &target) {
-	Store<uint64_t>(cast_pointer_to_uint64(pointer), target);
-}
-
-static data_ptr_t LoadPointer(const const_data_ptr_t &source) {
-	return cast_uint64_to_pointer(Load<uint64_t>(source));
-}
-
-//! If we consider to insert into an entry we expct to be empty, if it was filled in the meantime the insert will not
-//! happen and we need to return the pointer to the to row with which the new entry would have collided. In any other
-//! case we return a nullptr
-template <bool PARALLEL, bool EXPECT_EMPTY>
-static inline data_ptr_t InsertRowToEntry(atomic<ht_entry_t> &entry, const data_ptr_t &row_ptr_to_insert,
-                                          const hash_t &salt, const idx_t &pointer_offset) {
-	const ht_entry_t desired_entry(salt, row_ptr_to_insert);
-	if (PARALLEL) {
-		if (EXPECT_EMPTY) {
-			// Add nullptr to the end of the list to mark the end
-			StorePointer(nullptr, row_ptr_to_insert + pointer_offset);
-
-			ht_entry_t expected_entry;
-			entry.compare_exchange_strong(expected_entry, desired_entry, std::memory_order_acquire,
-			                              std::memory_order_relaxed);
-
-			// The expected entry is updated with the encountered entry by the compare exchange
-			// So, this returns a nullptr if it was empty, and a non-null if it was not (which cancels the insert)
-			return expected_entry.GetPointerOrNull();
-		} else {
-			// At this point we know that the keys match, so we can try to insert until we succeed
-			ht_entry_t expected_entry = entry.load(std::memory_order_relaxed);
-			D_ASSERT(expected_entry.IsOccupied());
-			do {
-				data_ptr_t current_row_pointer = expected_entry.GetPointer();
-				StorePointer(current_row_pointer, row_ptr_to_insert + pointer_offset);
-			} while (!entry.compare_exchange_weak(expected_entry, desired_entry, std::memory_order_release,
-			                                      std::memory_order_relaxed));
-
-			return nullptr;
-		}
-	} else {
-		// If we are not in parallel mode, we can just do the operation without any checks
-		data_ptr_t current_row_pointer = entry.load(std::memory_order_relaxed).GetPointerOrNull();
-		StorePointer(current_row_pointer, row_ptr_to_insert + pointer_offset);
-		entry = desired_entry;
-		return nullptr;
-	}
-}
-static inline void PerformKeyComparison(JoinHashTable::InsertState &state, JoinHashTable &ht,
-                                        const TupleDataCollection &data_collection, Vector &row_locations,
-                                        const idx_t count, idx_t &key_match_count, idx_t &key_no_match_count) {
-	// Get the data for the rows that need to be compared
-	state.lhs_data.Reset();
-	state.lhs_data.SetCardinality(count); // the right size
-
-	// The target selection vector says where to write the results into the lhs_data, we just want to write
-	// sequentially as otherwise we trigger a bug in the Gather function
-	data_collection.ResetCachedCastVectors(state.chunk_state, ht.equality_predicate_columns);
-	data_collection.Gather(row_locations, state.salt_match_sel, count, ht.equality_predicate_columns, state.lhs_data,
-	                       *FlatVector::IncrementalSelectionVector(), state.chunk_state.cached_cast_vectors);
-	TupleDataCollection::ToUnifiedFormat(state.chunk_state, state.lhs_data);
-
-	for (idx_t i = 0; i < count; i++) {
-		state.key_match_sel.set_index(i, i);
-	}
-
-	// Perform row comparisons
-	key_match_count =
-	    ht.row_matcher_build.Match(state.lhs_data, state.chunk_state.vector_data, state.key_match_sel, count, ht.layout,
-	                               state.rhs_row_locations, &state.key_no_match_sel, key_no_match_count);
-
-	D_ASSERT(key_match_count + key_no_match_count == count);
-}
-
-template <bool PARALLEL>
-static inline void InsertMatchesAndIncrementMisses(atomic<ht_entry_t> entries[], JoinHashTable::InsertState &state,
-                                                   JoinHashTable &ht, const data_ptr_t lhs_row_locations[],
-                                                   idx_t ht_offsets[], const hash_t hash_salts[],
-                                                   const idx_t capacity_mask, const idx_t key_match_count,
-                                                   const idx_t key_no_match_count) {
-	if (key_match_count != 0) {
-		ht.chains_longer_than_one = true;
-	}
-
-	// Insert the rows that match
-	for (idx_t i = 0; i < key_match_count; i++) {
-		const auto need_compare_idx = state.key_match_sel.get_index(i);
-		const auto entry_index = state.salt_match_sel.get_index(need_compare_idx);
-
-		const auto &ht_offset = ht_offsets[entry_index];
-		auto &entry = entries[ht_offset];
-		const auto row_ptr_to_insert = lhs_row_locations[entry_index];
-
-		const auto salt = hash_salts[entry_index];
-		InsertRowToEntry<PARALLEL, false>(entry, row_ptr_to_insert, salt, ht.pointer_offset);
-	}
-
-	// Linear probing: each of the entries that do not match move to the next entry in the HT
-	for (idx_t i = 0; i < key_no_match_count; i++) {
-		const auto need_compare_idx = state.key_no_match_sel.get_index(i);
-		const auto entry_index = state.salt_match_sel.get_index(need_compare_idx);
-
-		auto &ht_offset = ht_offsets[entry_index];
-		IncrementAndWrap(ht_offset, capacity_mask);
-
-		state.remaining_sel.set_index(i, entry_index);
-	}
-}
-
-template <bool PARALLEL>
-static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations, Vector &hashes_v, const idx_t &count,
-                             JoinHashTable::InsertState &state, const TupleDataCollection &data_collection,
-                             JoinHashTable &ht) {
-	D_ASSERT(hashes_v.GetType().id() == LogicalType::HASH);
-	ApplyBitmaskAndGetSaltBuild(hashes_v, state.salt_v, count, ht.bitmask);
-
-	// the salts offset for each row to insert
-	const auto ht_offsets = FlatVector::GetData<idx_t>(hashes_v);
-	const auto hash_salts = FlatVector::GetData<hash_t>(state.salt_v);
-	// the row locations of the rows that are already in the hash table
-	const auto rhs_row_locations = FlatVector::GetData<data_ptr_t>(state.rhs_row_locations);
-	// the row locations of the rows that are to be inserted
-	const auto lhs_row_locations = FlatVector::GetData<data_ptr_t>(row_locations);
-
-	// we start off with the entire chunk
-	idx_t remaining_count = count;
-	const auto *remaining_sel = FlatVector::IncrementalSelectionVector();
-
-	if (PropagatesBuildSide(ht.join_type)) {
-		// if we propagate the build side, we may have added rows with NULL keys to the HT
-		// these may need to be filtered out depending on the comparison type (exactly like PrepareKeys does)
-		for (idx_t col_idx = 0; col_idx < ht.conditions.size(); col_idx++) {
-			// if null values are NOT equal for this column we filter them out
-			if (ht.NullValuesAreEqual(col_idx)) {
-				continue;
-			}
-
-			idx_t entry_idx;
-			idx_t idx_in_entry;
-			ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-
-			idx_t new_remaining_count = 0;
-			for (idx_t i = 0; i < remaining_count; i++) {
-				const auto idx = remaining_sel->get_index(i);
-				if (ValidityBytes(lhs_row_locations[idx], count).RowIsValidUnsafe(col_idx)) {
-					state.remaining_sel.set_index(new_remaining_count++, idx);
-				}
-			}
-			remaining_count = new_remaining_count;
-			remaining_sel = &state.remaining_sel;
-		}
-	}
-
-	// use the ht bitmask to make the modulo operation faster but keep the salt bits intact
-	idx_t capacity_mask = ht.bitmask | ht_entry_t::SALT_MASK;
-	while (remaining_count > 0) {
-		idx_t salt_match_count = 0;
-
-		// iterate over each entry to find out whether it belongs to an existing list or will start a new list
-		for (idx_t i = 0; i < remaining_count; i++) {
-			const idx_t row_index = remaining_sel->get_index(i);
-			auto &ht_offset = ht_offsets[row_index];
-			auto &salt = hash_salts[row_index];
-
-			// increment the ht_offset of the entry as long as next entry is occupied and salt does not match
-			ht_entry_t entry;
-			bool occupied;
-			while (true) {
-				atomic<ht_entry_t> &atomic_entry = entries[ht_offset];
-				entry = atomic_entry.load(std::memory_order_relaxed);
-				occupied = entry.IsOccupied();
-
-				// condition for incrementing the ht_offset: occupied and row_salt does not match -> move to next entry
-				if (!occupied) {
-					break;
-				}
-				if (entry.GetSalt() == salt) {
-					break;
-				}
-
-				IncrementAndWrap(ht_offset, capacity_mask);
-			}
-
-			if (!occupied) { // insert into free
-				auto &atomic_entry = entries[ht_offset];
-				const auto row_ptr_to_insert = lhs_row_locations[row_index];
-				const auto potential_collided_ptr =
-				    InsertRowToEntry<PARALLEL, true>(atomic_entry, row_ptr_to_insert, salt, ht.pointer_offset);
-
-				if (PARALLEL) {
-					// if the insertion was not successful, the entry was occupied in the meantime, so we have to
-					// compare the keys and insert the row to the next entry
-					if (potential_collided_ptr) {
-						// if the entry was occupied, we need to compare the keys and insert the row to the next entry
-						// we need to compare the keys and insert the row to the next entry
-						state.salt_match_sel.set_index(salt_match_count, row_index);
-						rhs_row_locations[salt_match_count] = potential_collided_ptr;
-						salt_match_count += 1;
-					}
-				}
-
-			} else { // compare with full entry
-				state.salt_match_sel.set_index(salt_match_count, row_index);
-				rhs_row_locations[salt_match_count] = entry.GetPointer();
-				salt_match_count += 1;
-			}
-		}
-
-		// at this step, for all the rows to insert we stepped either until we found an empty entry or an entry with
-		// a matching salt, we now need to compare the keys for the ones that have a matching salt
-		idx_t key_no_match_count = 0;
-		if (salt_match_count != 0) {
-			idx_t key_match_count = 0;
-			PerformKeyComparison(state, ht, data_collection, row_locations, salt_match_count, key_match_count,
-			                     key_no_match_count);
-			InsertMatchesAndIncrementMisses<PARALLEL>(entries, state, ht, lhs_row_locations, ht_offsets, hash_salts,
-			                                          capacity_mask, key_match_count, key_no_match_count);
-		}
-
-		// update the overall selection vector to only point the entries that still need to be inserted
-		// as there was no match found for them yet
-		remaining_sel = &state.remaining_sel;
-		remaining_count = key_no_match_count;
-	}
-}
-
-void JoinHashTable::InsertHashes(Vector &hashes_v, const idx_t count, TupleDataChunkState &chunk_state,
-                                 InsertState &insert_state, bool parallel) {
-	auto atomic_entries = reinterpret_cast<atomic<ht_entry_t> *>(this->entries);
-	auto row_locations = chunk_state.row_locations;
-	if (parallel) {
-		InsertHashesLoop<true>(atomic_entries, row_locations, hashes_v, count, insert_state, *data_collection, *this);
-	} else {
-		InsertHashesLoop<false>(atomic_entries, row_locations, hashes_v, count, insert_state, *data_collection, *this);
-	}
-}
-
-void JoinHashTable::InitializePointerTable() {
-	capacity = PointerTableCapacity(Count());
-	D_ASSERT(IsPowerOfTwo(capacity));
-
-	if (hash_map.get()) {
-		// There is already a hash map
-		auto current_capacity = hash_map.GetSize() / sizeof(ht_entry_t);
-		if (capacity > current_capacity) {
-			// Need more space
-			hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(ht_entry_t));
-			entries = reinterpret_cast<ht_entry_t *>(hash_map.get());
-		} else {
-			// Just use the current hash map
-			capacity = current_capacity;
-		}
-	} else {
-		// Allocate a hash map
-		hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(ht_entry_t));
-		entries = reinterpret_cast<ht_entry_t *>(hash_map.get());
-	}
-	D_ASSERT(hash_map.GetSize() == capacity * sizeof(ht_entry_t));
-
-	// initialize HT with all-zero entries
-	std::fill_n(entries, capacity, ht_entry_t());
-
-	bitmask = capacity - 1;
-}
-
-void JoinHashTable::Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel) {
-	// Pointer table should be allocated
-	D_ASSERT(hash_map.get());
-
-	Vector hashes(LogicalType::HASH);
-	auto hash_data = FlatVector::GetData<hash_t>(hashes);
-
-	TupleDataChunkIterator iterator(*data_collection, TupleDataPinProperties::KEEP_EVERYTHING_PINNED, chunk_idx_from,
-	                                chunk_idx_to, false);
-	const auto row_locations = iterator.GetRowLocations();
-
-	InsertState insert_state(*this);
-	do {
-		const auto count = iterator.GetCurrentChunkCount();
-		for (idx_t i = 0; i < count; i++) {
-			hash_data[i] = Load<hash_t>(row_locations[i] + pointer_offset);
-		}
-		TupleDataChunkState &chunk_state = iterator.GetChunkState();
-
-		InsertHashes(hashes, count, chunk_state, insert_state, parallel);
-	} while (iterator.Next());
-}
-
-void JoinHashTable::InitializeScanStructure(ScanStructure &scan_structure, DataChunk &keys,
-                                            TupleDataChunkState &key_state, const SelectionVector *&current_sel) {
-	D_ASSERT(Count() > 0); // should be handled before
-	D_ASSERT(finalized);
-
-	// set up the scan structure
-	scan_structure.is_null = false;
-	scan_structure.finished = false;
-	if (join_type != JoinType::INNER) {
-		memset(scan_structure.found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-	}
-
-	// first prepare the keys for probing
-	TupleDataCollection::ToUnifiedFormat(key_state, keys);
-	scan_structure.count = PrepareKeys(keys, key_state.vector_data, current_sel, scan_structure.sel_vector, false);
-}
-
-void JoinHashTable::Probe(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state,
-                          ProbeState &probe_state, optional_ptr<Vector> precomputed_hashes) {
-	const SelectionVector *current_sel;
-	InitializeScanStructure(scan_structure, keys, key_state, current_sel);
-	if (scan_structure.count == 0) {
-		return;
-	}
-
-	if (precomputed_hashes) {
-		GetRowPointers(keys, key_state, probe_state, *precomputed_hashes, *current_sel, scan_structure.count,
-		               scan_structure.pointers, scan_structure.sel_vector);
-	} else {
-		Vector hashes(LogicalType::HASH);
-		// hash all the keys
-		Hash(keys, *current_sel, scan_structure.count, hashes);
-
-		// now initialize the pointers of the scan structure based on the hashes
-		GetRowPointers(keys, key_state, probe_state, hashes, *current_sel, scan_structure.count,
-		               scan_structure.pointers, scan_structure.sel_vector);
-	}
-}
-
-ScanStructure::ScanStructure(JoinHashTable &ht_p, TupleDataChunkState &key_state_p)
-    : key_state(key_state_p), pointers(LogicalType::POINTER), count(0), sel_vector(STANDARD_VECTOR_SIZE),
-      chain_match_sel_vector(STANDARD_VECTOR_SIZE), chain_no_match_sel_vector(STANDARD_VECTOR_SIZE),
-      found_match(make_unsafe_uniq_array_uninitialized<bool>(STANDARD_VECTOR_SIZE)), ht(ht_p), finished(false),
-      is_null(true), rhs_pointers(LogicalType::POINTER), lhs_sel_vector(STANDARD_VECTOR_SIZE), last_match_count(0),
-      last_sel_vector(STANDARD_VECTOR_SIZE) {
-}
-
-void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	D_ASSERT(keys.size() == left.size());
-	if (finished) {
-		return;
-	}
-	switch (ht.join_type) {
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-		NextInnerJoin(keys, left, result);
-		break;
-	case JoinType::SEMI:
-		NextSemiJoin(keys, left, result);
-		break;
-	case JoinType::MARK:
-		NextMarkJoin(keys, left, result);
-		break;
-	case JoinType::ANTI:
-		NextAntiJoin(keys, left, result);
-		break;
-	case JoinType::RIGHT_ANTI:
-	case JoinType::RIGHT_SEMI:
-		NextRightSemiOrAntiJoin(keys);
-		break;
-	case JoinType::OUTER:
-	case JoinType::LEFT:
-		NextLeftJoin(keys, left, result);
-		break;
-	case JoinType::SINGLE:
-		NextSingleJoin(keys, left, result);
-		break;
-	default:
-		throw InternalException("Unhandled join type in JoinHashTable");
-	}
-}
-
-bool ScanStructure::PointersExhausted() const {
-	// AdvancePointers creates a "new_count" for every pointer advanced during the
-	// previous advance pointers call. If no pointers are advanced, new_count = 0.
-	// count is then set ot new_count.
-	return count == 0;
-}
-
-idx_t ScanStructure::ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector *no_match_sel) {
-
-	// Initialize the found_match array to the current sel_vector
-	for (idx_t i = 0; i < this->count; ++i) {
-		match_sel.set_index(i, this->sel_vector.get_index(i));
-	}
-
-	// If there is a matcher for the probing side because of non-equality predicates, use it
-	if (ht.needs_chain_matcher) {
-		idx_t no_match_count = 0;
-		auto &matcher = no_match_sel ? ht.row_matcher_probe_no_match_sel : ht.row_matcher_probe;
-		D_ASSERT(matcher);
-
-		// we need to only use the vectors with the indices of the columns that are used in the probe phase, namely
-		// the non-equality columns
-		return matcher->Match(keys, key_state.vector_data, match_sel, this->count, ht.layout, pointers, no_match_sel,
-		                      no_match_count, ht.non_equality_predicate_columns);
-	} else {
-		// no match sel is the opposite of match sel
-		return this->count;
-	}
-}
-
-idx_t ScanStructure::ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector) {
-	while (true) {
-		// resolve the equality_predicates for this set of keys
-		idx_t result_count = ResolvePredicates(keys, result_vector, nullptr);
-
-		// after doing all the comparisons set the found_match vector
-		if (found_match) {
-			for (idx_t i = 0; i < result_count; i++) {
-				auto idx = result_vector.get_index(i);
-				found_match[idx] = true;
-			}
-		}
-		if (result_count > 0) {
-			return result_count;
-		}
-		// no matches found: check the next set of pointers
-		AdvancePointers();
-		if (this->count == 0) {
-			return 0;
-		}
-	}
-}
-
-void ScanStructure::AdvancePointers(const SelectionVector &sel, const idx_t sel_count) {
-
-	if (!ht.chains_longer_than_one) {
-		this->count = 0;
-		return;
-	}
-
-	// now for all the pointers, we move on to the next set of pointers
-	idx_t new_count = 0;
-	auto ptrs = FlatVector::GetData<data_ptr_t>(this->pointers);
-	for (idx_t i = 0; i < sel_count; i++) {
-		auto idx = sel.get_index(i);
-		ptrs[idx] = LoadPointer(ptrs[idx] + ht.pointer_offset);
-		if (ptrs[idx]) {
-			this->sel_vector.set_index(new_count++, idx);
-		}
-	}
-	this->count = new_count;
-}
-
-void ScanStructure::AdvancePointers() {
-	AdvancePointers(this->sel_vector, this->count);
-}
-
-void ScanStructure::GatherResult(Vector &result, const SelectionVector &result_vector,
-                                 const SelectionVector &sel_vector, const idx_t count, const idx_t col_no) {
-	ht.data_collection->Gather(pointers, sel_vector, count, col_no, result, result_vector, nullptr);
-}
-
-void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count,
-                                 const idx_t col_idx) {
-	GatherResult(result, *FlatVector::IncrementalSelectionVector(), sel_vector, count, col_idx);
-}
-
-void ScanStructure::GatherResult(Vector &result, const idx_t count, const idx_t col_idx) {
-	ht.data_collection->Gather(rhs_pointers, *FlatVector::IncrementalSelectionVector(), count, col_idx, result,
-	                           *FlatVector::IncrementalSelectionVector(), nullptr);
-}
-
-void ScanStructure::UpdateCompactionBuffer(idx_t base_count, SelectionVector &result_vector, idx_t result_count) {
-	// matches were found
-	// record the result
-	// on the LHS, we store result vector
-	for (idx_t i = 0; i < result_count; i++) {
-		lhs_sel_vector.set_index(base_count + i, result_vector.get_index(i));
-	}
-
-	// on the RHS, we collect their pointers
-	VectorOperations::Copy(pointers, rhs_pointers, result_vector, result_count, 0, base_count);
-}
-
-void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	if (ht.join_type != JoinType::RIGHT_SEMI && ht.join_type != JoinType::RIGHT_ANTI) {
-		D_ASSERT(result.ColumnCount() == left.ColumnCount() + ht.output_columns.size());
-	}
-
-	idx_t base_count = 0;
-	idx_t result_count;
-	while (this->count > 0) {
-		// if we have saved the match result, we need not call ScanInnerJoin again
-		if (last_match_count == 0) {
-			result_count = ScanInnerJoin(keys, chain_match_sel_vector);
-		} else {
-			chain_match_sel_vector.Initialize(last_sel_vector);
-			result_count = last_match_count;
-			last_match_count = 0;
-		}
-
-		if (result_count > 0) {
-			// the result chunk cannot contain more data, we record the match result for future use
-			if (base_count + result_count > STANDARD_VECTOR_SIZE) {
-				last_sel_vector.Initialize(chain_match_sel_vector);
-				last_match_count = result_count;
-				break;
-			}
-
-			if (PropagatesBuildSide(ht.join_type)) {
-				// full/right outer join: mark join matches as FOUND in the HT
-				auto ptrs = FlatVector::GetData<data_ptr_t>(pointers);
-				for (idx_t i = 0; i < result_count; i++) {
-					auto idx = chain_match_sel_vector.get_index(i);
-					// NOTE: threadsan reports this as a data race because this can be set concurrently by separate
-					// threads Technically it is, but it does not matter, since the only value that can be written is
-					// "true"
-					Store<bool>(true, ptrs[idx] + ht.tuple_size);
-				}
-			}
-
-			if (ht.join_type != JoinType::RIGHT_SEMI && ht.join_type != JoinType::RIGHT_ANTI) {
-				// Fast Path: if there is NO more than one element in the chain, we construct the result chunk directly
-				if (!ht.chains_longer_than_one) {
-					// matches were found
-					// on the LHS, we create a slice using the result vector
-					result.Slice(left, chain_match_sel_vector, result_count);
-
-					// on the RHS, we need to fetch the data from the hash table
-					for (idx_t i = 0; i < ht.output_columns.size(); i++) {
-						auto &vector = result.data[left.ColumnCount() + i];
-						const auto output_col_idx = ht.output_columns[i];
-						D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
-						GatherResult(vector, chain_match_sel_vector, result_count, output_col_idx);
-					}
-
-					AdvancePointers();
-					return;
-				}
-
-				// Common Path: use a buffer to store temporary data
-				UpdateCompactionBuffer(base_count, chain_match_sel_vector, result_count);
-				base_count += result_count;
-			}
-		}
-		AdvancePointers();
-	}
-
-	if (base_count > 0) {
-		// create result chunk, we have two steps:
-		// 1) slice LHS vectors
-		result.Slice(left, lhs_sel_vector, base_count);
-
-		// 2) gather RHS vectors
-		for (idx_t i = 0; i < ht.output_columns.size(); i++) {
-			auto &vector = result.data[left.ColumnCount() + i];
-			const auto output_col_idx = ht.output_columns[i];
-			D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
-			GatherResult(vector, base_count, output_col_idx);
-		}
-	}
-}
-
-void ScanStructure::ScanKeyMatches(DataChunk &keys) {
-	// the semi-join, anti-join and mark-join we handle a differently from the inner join
-	// since there can be at most STANDARD_VECTOR_SIZE results
-	// we handle the entire chunk in one call to Next().
-	// for every pointer, we keep chasing pointers and doing comparisons.
-	// this results in a boolean array indicating whether or not the tuple has a match
-	// Start with the scan selection
-
-	while (this->count > 0) {
-		// resolve the equality_predicates for the current set of pointers
-		idx_t match_count = ResolvePredicates(keys, chain_match_sel_vector, &chain_no_match_sel_vector);
-		idx_t no_match_count = this->count - match_count;
-
-		// mark each of the matches as found
-		for (idx_t i = 0; i < match_count; i++) {
-			found_match[chain_match_sel_vector.get_index(i)] = true;
-		}
-		// continue searching for the ones where we did not find a match yet
-		AdvancePointers(chain_no_match_sel_vector, no_match_count);
-	}
-}
-
-template <bool MATCH>
-void ScanStructure::NextSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	D_ASSERT(left.ColumnCount() == result.ColumnCount());
-	// create the selection vector from the matches that were found
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	idx_t result_count = 0;
-	for (idx_t i = 0; i < keys.size(); i++) {
-		if (found_match[i] == MATCH) {
-			// part of the result
-			sel.set_index(result_count++, i);
-		}
-	}
-	// construct the final result
-	if (result_count > 0) {
-		// we only return the columns on the left side
-		// reference the columns of the left side from the result
-		result.Slice(left, sel, result_count);
-	} else {
-		D_ASSERT(result.size() == 0);
-	}
-}
-
-void ScanStructure::NextSemiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// first scan for key matches
-	ScanKeyMatches(keys);
-	// then construct the result from all tuples with a match
-	NextSemiOrAntiJoin<true>(keys, left, result);
-
-	finished = true;
-}
-
-void ScanStructure::NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// first scan for key matches
-	ScanKeyMatches(keys);
-	// then construct the result from all tuples that did not find a match
-	NextSemiOrAntiJoin<false>(keys, left, result);
-
-	finished = true;
-}
-
-void ScanStructure::NextRightSemiOrAntiJoin(DataChunk &keys) {
-	const auto ptrs = FlatVector::GetData<data_ptr_t>(pointers);
-	while (!PointersExhausted()) {
-		// resolve the equality_predicates for this set of keys
-		idx_t result_count = ResolvePredicates(keys, chain_match_sel_vector, nullptr);
-
-		// for each match, fully follow the chain
-		for (idx_t i = 0; i < result_count; i++) {
-			const auto idx = chain_match_sel_vector.get_index(i);
-			auto &ptr = ptrs[idx];
-			if (Load<bool>(ptr + ht.tuple_size)) { // Early out: chain has been fully marked as found before
-				ptr = ht.dead_end.get();
-				continue;
-			}
-
-			// Fully mark chain as found
-			while (true) {
-				// NOTE: threadsan reports this as a data race because this can be set concurrently by separate threads
-				// Technically it is, but it does not matter, since the only value that can be written is "true"
-				Store<bool>(true, ptr + ht.tuple_size);
-				auto next_ptr = LoadPointer(ptr + ht.pointer_offset);
-				if (!next_ptr) {
-					break;
-				}
-				ptr = next_ptr;
-			}
-		}
-
-		// check the next set of pointers
-		AdvancePointers();
-	}
-
-	finished = true;
-}
-
-void ScanStructure::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &child, DataChunk &result) {
-	// for the initial set of columns we just reference the left side
-	result.SetCardinality(child);
-	for (idx_t i = 0; i < child.ColumnCount(); i++) {
-		result.data[i].Reference(child.data[i]);
-	}
-	auto &mark_vector = result.data.back();
-	mark_vector.SetVectorType(VectorType::FLAT_VECTOR);
-	// first we set the NULL values from the join keys
-	// if there is any NULL in the keys, the result is NULL
-	auto bool_result = FlatVector::GetData<bool>(mark_vector);
-	auto &mask = FlatVector::Validity(mark_vector);
-	for (idx_t col_idx = 0; col_idx < join_keys.ColumnCount(); col_idx++) {
-		if (ht.null_values_are_equal[col_idx]) {
-			continue;
-		}
-		UnifiedVectorFormat jdata;
-		join_keys.data[col_idx].ToUnifiedFormat(join_keys.size(), jdata);
-		if (!jdata.validity.AllValid()) {
-			for (idx_t i = 0; i < join_keys.size(); i++) {
-				auto jidx = jdata.sel->get_index(i);
-				mask.Set(i, jdata.validity.RowIsValidUnsafe(jidx));
-			}
-		}
-	}
-	// now set the remaining entries to either true or false based on whether a match was found
-	if (found_match) {
-		for (idx_t i = 0; i < child.size(); i++) {
-			bool_result[i] = found_match[i];
-		}
-	} else {
-		memset(bool_result, 0, sizeof(bool) * child.size());
-	}
-	// if the right side contains NULL values, the result of any FALSE becomes NULL
-	if (ht.has_null) {
-		for (idx_t i = 0; i < child.size(); i++) {
-			if (!bool_result[i]) {
-				mask.SetInvalid(i);
-			}
-		}
-	}
-}
-
-void ScanStructure::NextMarkJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	D_ASSERT(result.ColumnCount() == left.ColumnCount() + 1);
-	D_ASSERT(result.data.back().GetType() == LogicalType::BOOLEAN);
-	// this method should only be called for a non-empty HT
-	D_ASSERT(ht.Count() > 0);
-
-	ScanKeyMatches(keys);
-	if (ht.correlated_mark_join_info.correlated_types.empty()) {
-		ConstructMarkJoinResult(keys, left, result);
-	} else {
-		auto &info = ht.correlated_mark_join_info;
-		lock_guard<mutex> mj_lock(info.mj_lock);
-
-		// there are correlated columns
-		// first we fetch the counts from the aggregate hashtable corresponding to these entries
-		D_ASSERT(keys.ColumnCount() == info.group_chunk.ColumnCount() + 1);
-		info.group_chunk.SetCardinality(keys);
-		for (idx_t i = 0; i < info.group_chunk.ColumnCount(); i++) {
-			info.group_chunk.data[i].Reference(keys.data[i]);
-		}
-		info.correlated_counts->FetchAggregates(info.group_chunk, info.result_chunk);
-
-		// for the initial set of columns we just reference the left side
-		result.SetCardinality(left);
-		for (idx_t i = 0; i < left.ColumnCount(); i++) {
-			result.data[i].Reference(left.data[i]);
-		}
-		// create the result matching vector
-		auto &last_key = keys.data.back();
-		auto &result_vector = result.data.back();
-		// first set the nullmask based on whether or not there were NULL values in the join key
-		result_vector.SetVectorType(VectorType::FLAT_VECTOR);
-		auto bool_result = FlatVector::GetData<bool>(result_vector);
-		auto &mask = FlatVector::Validity(result_vector);
-		switch (last_key.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR:
-			if (ConstantVector::IsNull(last_key)) {
-				mask.SetAllInvalid(left.size());
-			}
-			break;
-		case VectorType::FLAT_VECTOR:
-			mask.Copy(FlatVector::Validity(last_key), left.size());
-			break;
-		default: {
-			UnifiedVectorFormat kdata;
-			last_key.ToUnifiedFormat(keys.size(), kdata);
-			for (idx_t i = 0; i < left.size(); i++) {
-				auto kidx = kdata.sel->get_index(i);
-				mask.Set(i, kdata.validity.RowIsValid(kidx));
-			}
-			break;
-		}
-		}
-
-		auto count_star = FlatVector::GetData<int64_t>(info.result_chunk.data[0]);
-		auto count = FlatVector::GetData<int64_t>(info.result_chunk.data[1]);
-		// set the entries to either true or false based on whether a match was found
-		for (idx_t i = 0; i < left.size(); i++) {
-			D_ASSERT(count_star[i] >= count[i]);
-			bool_result[i] = found_match ? found_match[i] : false;
-			if (!bool_result[i] && count_star[i] > count[i]) {
-				// RHS has NULL value and result is false: set to null
-				mask.SetInvalid(i);
-			}
-			if (count_star[i] == 0) {
-				// count == 0, set nullmask to false (we know the result is false now)
-				mask.SetValid(i);
-			}
-		}
-	}
-	finished = true;
-}
-
-void ScanStructure::NextLeftJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// a LEFT OUTER JOIN is identical to an INNER JOIN except all tuples that do
-	// not have a match must return at least one tuple (with the right side set
-	// to NULL in every column)
-	NextInnerJoin(keys, left, result);
-	if (result.size() == 0) {
-		// no entries left from the normal join
-		// fill in the result of the remaining left tuples
-		// together with NULL values on the right-hand side
-		idx_t remaining_count = 0;
-		SelectionVector sel(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < left.size(); i++) {
-			if (!found_match[i]) {
-				sel.set_index(remaining_count++, i);
-			}
-		}
-		if (remaining_count > 0) {
-			// have remaining tuples
-			// slice the left side with tuples that did not find a match
-			result.Slice(left, sel, remaining_count);
-
-			// now set the right side to NULL
-			for (idx_t i = left.ColumnCount(); i < result.ColumnCount(); i++) {
-				Vector &vec = result.data[i];
-				vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(vec, true);
-			}
-		}
-		finished = true;
-	}
-}
-
-void ScanStructure::NextSingleJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// single join
-	// this join is similar to the semi join except that
-	// (1) we actually return data from the RHS and
-	// (2) we return NULL for that data if there is no match
-	// (3) if single_join_error_on_multiple_rows is set, we need to keep looking for duplicates after fetching
-	idx_t result_count = 0;
-	SelectionVector result_sel(STANDARD_VECTOR_SIZE);
-
-	while (this->count > 0) {
-		// resolve the equality_predicates for the current set of pointers
-		idx_t match_count = ResolvePredicates(keys, chain_match_sel_vector, &chain_no_match_sel_vector);
-		idx_t no_match_count = this->count - match_count;
-
-		// mark each of the matches as found
-		for (idx_t i = 0; i < match_count; i++) {
-			// found a match for this index
-			auto index = chain_match_sel_vector.get_index(i);
-			found_match[index] = true;
-			result_sel.set_index(result_count++, index);
-		}
-		// continue searching for the ones where we did not find a match yet
-		AdvancePointers(chain_no_match_sel_vector, no_match_count);
-	}
-	// reference the columns of the left side from the result
-	D_ASSERT(left.ColumnCount() > 0);
-	for (idx_t i = 0; i < left.ColumnCount(); i++) {
-		result.data[i].Reference(left.data[i]);
-	}
-	// now fetch the data from the RHS
-	for (idx_t i = 0; i < ht.output_columns.size(); i++) {
-		auto &vector = result.data[left.ColumnCount() + i];
-		// set NULL entries for every entry that was not found
-		for (idx_t j = 0; j < left.size(); j++) {
-			if (!found_match[j]) {
-				FlatVector::SetNull(vector, j, true);
-			}
-		}
-		const auto output_col_idx = ht.output_columns[i];
-		D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
-		GatherResult(vector, result_sel, result_sel, result_count, output_col_idx);
-	}
-	result.SetCardinality(left.size());
-
-	// like the SEMI, ANTI and MARK join types, the SINGLE join only ever does one pass over the HT per input chunk
-	finished = true;
-
-	if (ht.single_join_error_on_multiple_rows && result_count > 0) {
-		// we need to throw an error if there are multiple rows per key
-		// advance pointers for those rows
-		AdvancePointers(result_sel, result_count);
-
-		// now resolve the predicates
-		idx_t match_count = ResolvePredicates(keys, chain_match_sel_vector, nullptr);
-		if (match_count > 0) {
-			// we found at least one duplicate row - throw
-			throw InvalidInputException(
-			    "More than one row returned by a subquery used as an expression - scalar subqueries can only "
-			    "return a single row.\n\nUse \"SET scalar_subquery_error_on_multiple_rows=false\" to revert to "
-			    "previous behavior of returning a random row.");
-		}
-
-		this->count = 0;
-	}
-}
-
-void JoinHashTable::ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result) const {
-	// scan the HT starting from the current position and check which rows from the build side did not find a match
-	auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
-	idx_t found_entries = 0;
-
-	auto &iterator = state.iterator;
-	if (iterator.Done()) {
-		return;
-	}
-
-	// When scanning Full Outer for right semi joins, we only propagate matches that have true
-	// Right Semi Joins do not propagate values during the probe phase, since we do not want to
-	// duplicate RHS rows.
-	bool match_propagation_value = false;
-	if (join_type == JoinType::RIGHT_SEMI) {
-		match_propagation_value = true;
-	}
-
-	const auto row_locations = iterator.GetRowLocations();
-	do {
-		const auto count = iterator.GetCurrentChunkCount();
-		for (idx_t i = state.offset_in_chunk; i < count; i++) {
-			auto found_match = Load<bool>(row_locations[i] + tuple_size);
-			if (found_match == match_propagation_value) {
-				key_locations[found_entries++] = row_locations[i];
-				if (found_entries == STANDARD_VECTOR_SIZE) {
-					state.offset_in_chunk = i + 1;
-					break;
-				}
-			}
-		}
-		if (found_entries == STANDARD_VECTOR_SIZE) {
-			break;
-		}
-		state.offset_in_chunk = 0;
-	} while (iterator.Next());
-
-	// now gather from the found rows
-	if (found_entries == 0) {
-		return;
-	}
-	result.SetCardinality(found_entries);
-
-	idx_t left_column_count = result.ColumnCount() - output_columns.size();
-	if (join_type == JoinType::RIGHT_SEMI || join_type == JoinType::RIGHT_ANTI) {
-		left_column_count = 0;
-	}
-	const auto &sel_vector = *FlatVector::IncrementalSelectionVector();
-	// set the left side as a constant NULL
-	for (idx_t i = 0; i < left_column_count; i++) {
-		Vector &vec = result.data[i];
-		vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(vec, true);
-	}
-
-	// gather the values from the RHS
-	for (idx_t i = 0; i < output_columns.size(); i++) {
-		auto &vector = result.data[left_column_count + i];
-		const auto output_col_idx = output_columns[i];
-		D_ASSERT(vector.GetType() == layout.GetTypes()[output_col_idx]);
-		data_collection->Gather(addresses, sel_vector, found_entries, output_col_idx, vector, sel_vector, nullptr);
-	}
-}
-
-idx_t JoinHashTable::FillWithHTOffsets(JoinHTScanState &state, Vector &addresses) {
-	// iterate over HT
-	auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
-	idx_t key_count = 0;
-
-	auto &iterator = state.iterator;
-	const auto row_locations = iterator.GetRowLocations();
-	do {
-		const auto count = iterator.GetCurrentChunkCount();
-		for (idx_t i = 0; i < count; i++) {
-			key_locations[key_count + i] = row_locations[i];
-		}
-		key_count += count;
-	} while (iterator.Next());
-
-	return key_count;
-}
-
-idx_t JoinHashTable::GetTotalSize(const vector<idx_t> &partition_sizes, const vector<idx_t> &partition_counts,
-                                  idx_t &max_partition_size, idx_t &max_partition_count) const {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-
-	idx_t total_size = 0;
-	idx_t total_count = 0;
-	idx_t max_partition_ht_size = 0;
-	max_partition_size = 0;
-	max_partition_count = 0;
-	for (idx_t i = 0; i < num_partitions; i++) {
-		total_size += partition_sizes[i];
-		total_count += partition_counts[i];
-
-		auto partition_size = partition_sizes[i] + PointerTableSize(partition_counts[i]);
-		if (partition_size > max_partition_ht_size) {
-			max_partition_ht_size = partition_size;
-			max_partition_size = partition_sizes[i];
-			max_partition_count = partition_counts[i];
-		}
-	}
-
-	if (total_count == 0) {
-		return 0;
-	}
-
-	return total_size + PointerTableSize(total_count);
-}
-
-idx_t JoinHashTable::GetTotalSize(const vector<unique_ptr<JoinHashTable>> &local_hts, idx_t &max_partition_size,
-                                  idx_t &max_partition_count) const {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	vector<idx_t> partition_sizes(num_partitions, 0);
-	vector<idx_t> partition_counts(num_partitions, 0);
-	for (auto &ht : local_hts) {
-		ht->GetSinkCollection().GetSizesAndCounts(partition_sizes, partition_counts);
-	}
-
-	return GetTotalSize(partition_sizes, partition_counts, max_partition_size, max_partition_count);
-}
-
-idx_t JoinHashTable::GetRemainingSize() const {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	auto &partitions = sink_collection->GetPartitions();
-
-	idx_t count = 0;
-	idx_t data_size = 0;
-	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
-		if (completed_partitions.RowIsValidUnsafe(partition_idx)) {
-			continue;
-		}
-		count += partitions[partition_idx]->Count();
-		data_size += partitions[partition_idx]->SizeInBytes();
-	}
-
-	return data_size + PointerTableSize(count);
-}
-
-void JoinHashTable::Unpartition() {
-	data_collection = sink_collection->GetUnpartitioned();
-}
-
-void JoinHashTable::SetRepartitionRadixBits(const idx_t max_ht_size, const idx_t max_partition_size,
-                                            const idx_t max_partition_count) {
-	D_ASSERT(max_partition_size + PointerTableSize(max_partition_count) > max_ht_size);
-
-	const auto max_added_bits = RadixPartitioning::MAX_RADIX_BITS - radix_bits;
-	idx_t added_bits = 1;
-	for (; added_bits < max_added_bits; added_bits++) {
-		double partition_multiplier = static_cast<double>(RadixPartitioning::NumberOfPartitions(added_bits));
-
-		auto new_estimated_size = static_cast<double>(max_partition_size) / partition_multiplier;
-		auto new_estimated_count = static_cast<double>(max_partition_count) / partition_multiplier;
-		auto new_estimated_ht_size =
-		    new_estimated_size + static_cast<double>(PointerTableSize(LossyNumericCast<idx_t>(new_estimated_count)));
-
-		if (new_estimated_ht_size <= static_cast<double>(max_ht_size) / 4) {
-			// Aim for an estimated partition size of max_ht_size / 4
-			break;
-		}
-	}
-	radix_bits += added_bits;
-	sink_collection =
-	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
-
-	// Need to initialize again after changing the number of bits
-	InitializePartitionMasks();
-}
-
-void JoinHashTable::InitializePartitionMasks() {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-
-	current_partitions.Initialize(num_partitions);
-	current_partitions.SetAllInvalid(num_partitions);
-
-	completed_partitions.Initialize(num_partitions);
-	completed_partitions.SetAllInvalid(num_partitions);
-}
-
-idx_t JoinHashTable::CurrentPartitionCount() const {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	D_ASSERT(current_partitions.Capacity() == num_partitions);
-	return current_partitions.CountValid(num_partitions);
-}
-
-idx_t JoinHashTable::FinishedPartitionCount() const {
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	D_ASSERT(completed_partitions.Capacity() == num_partitions);
-	// We already marked the active partitions as done, so we have to subtract them here
-	return completed_partitions.CountValid(num_partitions) - CurrentPartitionCount();
-}
-
-void JoinHashTable::Repartition(JoinHashTable &global_ht) {
-	auto new_sink_collection =
-	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, global_ht.radix_bits, layout.ColumnCount() - 1);
-	sink_collection->Repartition(*new_sink_collection);
-	sink_collection = std::move(new_sink_collection);
-	global_ht.Merge(*this);
-}
-
-void JoinHashTable::Reset() {
-	data_collection->Reset();
-	hash_map.Reset();
-	current_partitions.SetAllInvalid(RadixPartitioning::NumberOfPartitions(radix_bits));
-	finalized = false;
-}
-
-bool JoinHashTable::PrepareExternalFinalize(const idx_t max_ht_size) {
-	if (finalized) {
-		Reset();
-	}
-
-	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	D_ASSERT(current_partitions.Capacity() == num_partitions);
-	D_ASSERT(completed_partitions.Capacity() == num_partitions);
-	D_ASSERT(current_partitions.CheckAllInvalid(num_partitions));
-
-	if (completed_partitions.CheckAllValid(num_partitions)) {
-		return false; // All partitions are done
-	}
-
-	// Create vector with unfinished partition indices
-	auto &partitions = sink_collection->GetPartitions();
-	auto min_partition_size = NumericLimits<idx_t>::Maximum();
-	vector<idx_t> partition_indices;
-	partition_indices.reserve(num_partitions);
-	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
-		if (completed_partitions.RowIsValidUnsafe(partition_idx)) {
-			continue;
-		}
-		partition_indices.push_back(partition_idx);
-		// Keep track of min partition size
-		const auto size =
-		    partitions[partition_idx]->SizeInBytes() + PointerTableSize(partitions[partition_idx]->Count());
-		min_partition_size = MinValue(min_partition_size, size);
-	}
-
-	// Sort partitions by size, from small to large
-	std::stable_sort(partition_indices.begin(), partition_indices.end(), [&](const idx_t &lhs, const idx_t &rhs) {
-		const auto lhs_size = partitions[lhs]->SizeInBytes() + PointerTableSize(partitions[lhs]->Count());
-		const auto rhs_size = partitions[rhs]->SizeInBytes() + PointerTableSize(partitions[rhs]->Count());
-		// We divide by min_partition_size, effectively rouding everything down to a multiple of min_partition_size
-		// Makes it so minor differences in partition sizes don't mess up the original order
-		// Retaining as much of the original order as possible reduces I/O (partition idx determines eviction queue idx)
-		return lhs_size / min_partition_size < rhs_size / min_partition_size;
-	});
-
-	// Determine which partitions should go next
-	idx_t count = 0;
-	idx_t data_size = 0;
-	for (const auto &partition_idx : partition_indices) {
-		D_ASSERT(!completed_partitions.RowIsValidUnsafe(partition_idx));
-		const auto incl_count = count + partitions[partition_idx]->Count();
-		const auto incl_data_size = data_size + partitions[partition_idx]->SizeInBytes();
-		const auto incl_ht_size = incl_data_size + PointerTableSize(incl_count);
-		if (count > 0 && incl_ht_size > max_ht_size) {
-			break; // Always add at least one partition
-		}
-		count = incl_count;
-		data_size = incl_data_size;
-		current_partitions.SetValidUnsafe(partition_idx);     // Mark as currently active
-		data_collection->Combine(*partitions[partition_idx]); // Move partition to the main data collection
-		completed_partitions.SetValidUnsafe(partition_idx);   // Also already mark as done
-	}
-	D_ASSERT(Count() == count);
-
-	return true;
-}
-
-void JoinHashTable::ProbeAndSpill(ScanStructure &scan_structure, DataChunk &probe_keys, TupleDataChunkState &key_state,
-                                  ProbeState &probe_state, DataChunk &probe_chunk, ProbeSpill &probe_spill,
-                                  ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk) {
-	// hash all the keys
-	Vector hashes(LogicalType::HASH);
-	Hash(probe_keys, *FlatVector::IncrementalSelectionVector(), probe_keys.size(), hashes);
-
-	// find out which keys we can match with the current pinned partitions
-	SelectionVector true_sel(STANDARD_VECTOR_SIZE);
-	SelectionVector false_sel(STANDARD_VECTOR_SIZE);
-	const auto true_count =
-	    RadixPartitioning::Select(hashes, FlatVector::IncrementalSelectionVector(), probe_keys.size(), radix_bits,
-	                              current_partitions, &true_sel, &false_sel);
-	const auto false_count = probe_keys.size() - true_count;
-
-	// can't probe these values right now, append to spill
-	spill_chunk.Reset();
-	spill_chunk.Reference(probe_chunk);
-	spill_chunk.data.back().Reference(hashes);
-	spill_chunk.Slice(false_sel, false_count);
-	probe_spill.Append(spill_chunk, spill_state);
-
-	// slice the stuff we CAN probe right now
-	hashes.Slice(true_sel, true_count);
-	probe_keys.Slice(true_sel, true_count);
-	probe_chunk.Slice(true_sel, true_count);
-
-	const SelectionVector *current_sel;
-	InitializeScanStructure(scan_structure, probe_keys, key_state, current_sel);
-	if (scan_structure.count == 0) {
-		return;
-	}
-
-	// now initialize the pointers of the scan structure based on the hashes
-	GetRowPointers(probe_keys, key_state, probe_state, hashes, *current_sel, scan_structure.count,
-	               scan_structure.pointers, scan_structure.sel_vector);
-}
-
-ProbeSpill::ProbeSpill(JoinHashTable &ht, ClientContext &context, const vector<LogicalType> &probe_types)
-    : ht(ht), context(context), probe_types(probe_types) {
-	global_partitions =
-	    make_uniq<RadixPartitionedColumnData>(context, probe_types, ht.radix_bits, probe_types.size() - 1);
-	column_ids.reserve(probe_types.size());
-	for (column_t column_id = 0; column_id < probe_types.size(); column_id++) {
-		column_ids.emplace_back(column_id);
-	}
-}
-
-ProbeSpillLocalState ProbeSpill::RegisterThread() {
-	ProbeSpillLocalAppendState result;
-	lock_guard<mutex> guard(lock);
-	local_partitions.emplace_back(global_partitions->CreateShared());
-	local_partition_append_states.emplace_back(make_uniq<PartitionedColumnDataAppendState>());
-	local_partitions.back()->InitializeAppendState(*local_partition_append_states.back());
-
-	result.local_partition = local_partitions.back().get();
-	result.local_partition_append_state = local_partition_append_states.back().get();
-	return result;
-}
-
-void ProbeSpill::Append(DataChunk &chunk, ProbeSpillLocalAppendState &local_state) {
-	local_state.local_partition->Append(*local_state.local_partition_append_state, chunk);
-}
-
-void ProbeSpill::Finalize() {
-	D_ASSERT(local_partitions.size() == local_partition_append_states.size());
-	for (idx_t i = 0; i < local_partition_append_states.size(); i++) {
-		local_partitions[i]->FlushAppendState(*local_partition_append_states[i]);
-	}
-	for (auto &local_partition : local_partitions) {
-		global_partitions->Combine(*local_partition);
-	}
-	local_partitions.clear();
-	local_partition_append_states.clear();
-}
-
-void ProbeSpill::PrepareNextProbe() {
-	global_spill_collection.reset();
-	auto &partitions = global_partitions->GetPartitions();
-	if (partitions.empty() || ht.current_partitions.CheckAllInvalid(partitions.size())) {
-		// Can't probe, just make an empty one
-		global_spill_collection =
-		    make_uniq<ColumnDataCollection>(BufferManager::GetBufferManager(context), probe_types);
-	} else {
-		// Move current partitions to the global spill collection
-		for (idx_t partition_idx = 0; partition_idx < partitions.size(); partition_idx++) {
-			if (!ht.current_partitions.RowIsValidUnsafe(partition_idx)) {
-				continue;
-			}
-			auto &partition = partitions[partition_idx];
-			if (!global_spill_collection) {
-				global_spill_collection = std::move(partition);
-			} else if (partition->Count() != 0) {
-				global_spill_collection->Combine(*partition);
-			}
-			partition.reset();
-		}
-	}
-	consumer = make_uniq<ColumnDataConsumer>(*global_spill_collection, column_ids);
-	consumer->InitializeScan();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/nested_loop_join/nested_loop_join_inner.cpp b/src/duckdb/src/execution/nested_loop_join/nested_loop_join_inner.cpp
deleted file mode 100644
index 583c5946f..000000000
--- a/src/duckdb/src/execution/nested_loop_join/nested_loop_join_inner.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/execution/nested_loop_join.hpp"
-
-namespace duckdb {
-
-struct InitialNestedLoopJoin {
-	template <class T, class OP>
-	static idx_t Operation(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos, idx_t &rpos,
-	                       SelectionVector &lvector, SelectionVector &rvector, idx_t current_match_count) {
-		using MATCH_OP = ComparisonOperationWrapper<OP>;
-
-		// initialize phase of nested loop join
-		// fill lvector and rvector with matches from the base vectors
-		UnifiedVectorFormat left_data, right_data;
-		left.ToUnifiedFormat(left_size, left_data);
-		right.ToUnifiedFormat(right_size, right_data);
-
-		auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
-		auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
-		idx_t result_count = 0;
-		for (; rpos < right_size; rpos++) {
-			idx_t right_position = right_data.sel->get_index(rpos);
-			bool right_is_valid = right_data.validity.RowIsValid(right_position);
-			for (; lpos < left_size; lpos++) {
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					return result_count;
-				}
-				idx_t left_position = left_data.sel->get_index(lpos);
-				bool left_is_valid = left_data.validity.RowIsValid(left_position);
-				if (MATCH_OP::Operation(ldata[left_position], rdata[right_position], !left_is_valid, !right_is_valid)) {
-					// emit tuple
-					lvector.set_index(result_count, lpos);
-					rvector.set_index(result_count, rpos);
-					result_count++;
-				}
-			}
-			lpos = 0;
-		}
-		return result_count;
-	}
-};
-
-struct RefineNestedLoopJoin {
-	template <class T, class OP>
-	static idx_t Operation(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos, idx_t &rpos,
-	                       SelectionVector &lvector, SelectionVector &rvector, idx_t current_match_count) {
-		using MATCH_OP = ComparisonOperationWrapper<OP>;
-
-		UnifiedVectorFormat left_data, right_data;
-		left.ToUnifiedFormat(left_size, left_data);
-		right.ToUnifiedFormat(right_size, right_data);
-
-		// refine phase of the nested loop join
-		// refine lvector and rvector based on matches of subsequent conditions (in case there are multiple conditions
-		// in the join)
-		D_ASSERT(current_match_count > 0);
-		auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
-		auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
-		idx_t result_count = 0;
-		for (idx_t i = 0; i < current_match_count; i++) {
-			auto lidx = lvector.get_index(i);
-			auto ridx = rvector.get_index(i);
-			auto left_idx = left_data.sel->get_index(lidx);
-			auto right_idx = right_data.sel->get_index(ridx);
-			bool left_is_valid = left_data.validity.RowIsValid(left_idx);
-			bool right_is_valid = right_data.validity.RowIsValid(right_idx);
-			if (MATCH_OP::Operation(ldata[left_idx], rdata[right_idx], !left_is_valid, !right_is_valid)) {
-				lvector.set_index(result_count, lidx);
-				rvector.set_index(result_count, ridx);
-				result_count++;
-			}
-		}
-		return result_count;
-	}
-};
-
-template <class NLTYPE, class OP>
-static idx_t NestedLoopJoinTypeSwitch(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos,
-                                      idx_t &rpos, SelectionVector &lvector, SelectionVector &rvector,
-                                      idx_t current_match_count) {
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return NLTYPE::template Operation<int8_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                              current_match_count);
-	case PhysicalType::INT16:
-		return NLTYPE::template Operation<int16_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::INT32:
-		return NLTYPE::template Operation<int32_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::INT64:
-		return NLTYPE::template Operation<int64_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::UINT8:
-		return NLTYPE::template Operation<uint8_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::UINT16:
-		return NLTYPE::template Operation<uint16_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case PhysicalType::UINT32:
-		return NLTYPE::template Operation<uint32_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case PhysicalType::UINT64:
-		return NLTYPE::template Operation<uint64_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case PhysicalType::INT128:
-		return NLTYPE::template Operation<hugeint_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                 rvector, current_match_count);
-	case PhysicalType::UINT128:
-		return NLTYPE::template Operation<uhugeint_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                  rvector, current_match_count);
-	case PhysicalType::FLOAT:
-		return NLTYPE::template Operation<float, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                             current_match_count);
-	case PhysicalType::DOUBLE:
-		return NLTYPE::template Operation<double, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                              current_match_count);
-	case PhysicalType::INTERVAL:
-		return NLTYPE::template Operation<interval_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                  rvector, current_match_count);
-	case PhysicalType::VARCHAR:
-		return NLTYPE::template Operation<string_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	default:
-		throw InternalException("Unimplemented type for join!");
-	}
-}
-
-template <class NLTYPE>
-idx_t NestedLoopJoinComparisonSwitch(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos,
-                                     idx_t &rpos, SelectionVector &lvector, SelectionVector &rvector,
-                                     idx_t current_match_count, ExpressionType comparison_type) {
-	D_ASSERT(left.GetType() == right.GetType());
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return NestedLoopJoinTypeSwitch<NLTYPE, Equals>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return NestedLoopJoinTypeSwitch<NLTYPE, NotEquals>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                   rvector, current_match_count);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return NestedLoopJoinTypeSwitch<NLTYPE, LessThan>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                  rvector, current_match_count);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return NestedLoopJoinTypeSwitch<NLTYPE, GreaterThan>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                     rvector, current_match_count);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return NestedLoopJoinTypeSwitch<NLTYPE, LessThanEquals>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                        rvector, current_match_count);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return NestedLoopJoinTypeSwitch<NLTYPE, GreaterThanEquals>(left, right, left_size, right_size, lpos, rpos,
-		                                                           lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return NestedLoopJoinTypeSwitch<NLTYPE, DistinctFrom>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                      rvector, current_match_count);
-	default:
-		throw NotImplementedException("Unimplemented comparison type for join!");
-	}
-}
-
-idx_t NestedLoopJoinInner::Perform(idx_t &lpos, idx_t &rpos, DataChunk &left_conditions, DataChunk &right_conditions,
-                                   SelectionVector &lvector, SelectionVector &rvector,
-                                   const vector<JoinCondition> &conditions) {
-	D_ASSERT(left_conditions.ColumnCount() == right_conditions.ColumnCount());
-	if (lpos >= left_conditions.size() || rpos >= right_conditions.size()) {
-		return 0;
-	}
-	// for the first condition, lvector and rvector are not set yet
-	// we initialize them using the InitialNestedLoopJoin
-	idx_t match_count = NestedLoopJoinComparisonSwitch<InitialNestedLoopJoin>(
-	    left_conditions.data[0], right_conditions.data[0], left_conditions.size(), right_conditions.size(), lpos, rpos,
-	    lvector, rvector, 0, conditions[0].comparison);
-	// now resolve the rest of the conditions
-	for (idx_t i = 1; i < conditions.size(); i++) {
-		// check if we have run out of tuples to compare
-		if (match_count == 0) {
-			return 0;
-		}
-		// if not, get the vectors to compare
-		Vector &l = left_conditions.data[i];
-		Vector &r = right_conditions.data[i];
-		// then we refine the currently obtained results using the RefineNestedLoopJoin
-		match_count = NestedLoopJoinComparisonSwitch<RefineNestedLoopJoin>(
-		    l, r, left_conditions.size(), right_conditions.size(), lpos, rpos, lvector, rvector, match_count,
-		    conditions[i].comparison);
-	}
-	return match_count;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/nested_loop_join/nested_loop_join_mark.cpp b/src/duckdb/src/execution/nested_loop_join/nested_loop_join_mark.cpp
deleted file mode 100644
index 4bb1c5f29..000000000
--- a/src/duckdb/src/execution/nested_loop_join/nested_loop_join_mark.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/nested_loop_join.hpp"
-
-namespace duckdb {
-
-template <class T, class OP>
-static void TemplatedMarkJoin(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[]) {
-	using MATCH_OP = ComparisonOperationWrapper<OP>;
-
-	UnifiedVectorFormat left_data, right_data;
-	left.ToUnifiedFormat(lcount, left_data);
-	right.ToUnifiedFormat(rcount, right_data);
-
-	auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
-	auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
-	for (idx_t i = 0; i < lcount; i++) {
-		if (found_match[i]) {
-			continue;
-		}
-		auto lidx = left_data.sel->get_index(i);
-		const auto left_null = !left_data.validity.RowIsValid(lidx);
-		if (!MATCH_OP::COMPARE_NULL && left_null) {
-			continue;
-		}
-		for (idx_t j = 0; j < rcount; j++) {
-			auto ridx = right_data.sel->get_index(j);
-			const auto right_null = !right_data.validity.RowIsValid(ridx);
-			if (!MATCH_OP::COMPARE_NULL && right_null) {
-				continue;
-			}
-			if (MATCH_OP::template Operation<T>(ldata[lidx], rdata[ridx], left_null, right_null)) {
-				found_match[i] = true;
-				break;
-			}
-		}
-	}
-}
-
-static void MarkJoinNested(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[],
-                           ExpressionType comparison_type) {
-	Vector left_reference(left.GetType());
-	for (idx_t i = 0; i < lcount; i++) {
-		if (found_match[i]) {
-			continue;
-		}
-		ConstantVector::Reference(left_reference, left, i, rcount);
-		idx_t count;
-		switch (comparison_type) {
-		case ExpressionType::COMPARE_EQUAL:
-			count = VectorOperations::Equals(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-			count = VectorOperations::NotEquals(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-			count = VectorOperations::LessThan(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			count = VectorOperations::GreaterThan(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			count = VectorOperations::LessThanEquals(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			count = VectorOperations::GreaterThanEquals(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			count = VectorOperations::DistinctFrom(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-			count = VectorOperations::NotDistinctFrom(left_reference, right, nullptr, rcount, nullptr, nullptr);
-			break;
-		default:
-			throw InternalException("Unsupported comparison type for MarkJoinNested");
-		}
-		if (count > 0) {
-			found_match[i] = true;
-		}
-	}
-}
-
-template <class OP>
-static void MarkJoinSwitch(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[]) {
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedMarkJoin<int8_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT16:
-		return TemplatedMarkJoin<int16_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT32:
-		return TemplatedMarkJoin<int32_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT64:
-		return TemplatedMarkJoin<int64_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT128:
-		return TemplatedMarkJoin<hugeint_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT8:
-		return TemplatedMarkJoin<uint8_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT16:
-		return TemplatedMarkJoin<uint16_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT32:
-		return TemplatedMarkJoin<uint32_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT64:
-		return TemplatedMarkJoin<uint64_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT128:
-		return TemplatedMarkJoin<uhugeint_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::FLOAT:
-		return TemplatedMarkJoin<float, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::DOUBLE:
-		return TemplatedMarkJoin<double, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::VARCHAR:
-		return TemplatedMarkJoin<string_t, OP>(left, right, lcount, rcount, found_match);
-	default:
-		throw NotImplementedException("Unimplemented type for mark join!");
-	}
-}
-
-static void MarkJoinComparisonSwitch(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[],
-                                     ExpressionType comparison_type) {
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-	case PhysicalType::ARRAY:
-		return MarkJoinNested(left, right, lcount, rcount, found_match, comparison_type);
-	default:
-		break;
-	}
-	D_ASSERT(left.GetType() == right.GetType());
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return MarkJoinSwitch<Equals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return MarkJoinSwitch<NotEquals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return MarkJoinSwitch<LessThan>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return MarkJoinSwitch<GreaterThan>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return MarkJoinSwitch<LessThanEquals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return MarkJoinSwitch<GreaterThanEquals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return MarkJoinSwitch<DistinctFrom>(left, right, lcount, rcount, found_match);
-	default:
-		throw NotImplementedException("Unimplemented comparison type for join!");
-	}
-}
-
-void NestedLoopJoinMark::Perform(DataChunk &left, ColumnDataCollection &right, bool found_match[],
-                                 const vector<JoinCondition> &conditions) {
-	// initialize a new temporary selection vector for the left chunk
-	// loop over all chunks in the RHS
-	ColumnDataScanState scan_state;
-	right.InitializeScan(scan_state);
-
-	DataChunk scan_chunk;
-	right.InitializeScanChunk(scan_chunk);
-
-	while (right.Scan(scan_state, scan_chunk)) {
-		for (idx_t i = 0; i < conditions.size(); i++) {
-			MarkJoinComparisonSwitch(left.data[i], scan_chunk.data[i], left.size(), scan_chunk.size(), found_match,
-			                         conditions[i].comparison);
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/aggregate_object.cpp b/src/duckdb/src/execution/operator/aggregate/aggregate_object.cpp
deleted file mode 100644
index 53fe0368a..000000000
--- a/src/duckdb/src/execution/operator/aggregate/aggregate_object.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-AggregateObject::AggregateObject(AggregateFunction function, FunctionData *bind_data, idx_t child_count,
-                                 idx_t payload_size, AggregateType aggr_type, PhysicalType return_type,
-                                 Expression *filter)
-    : function(std::move(function)),
-      bind_data_wrapper(bind_data ? make_shared_ptr<FunctionDataWrapper>(bind_data->Copy()) : nullptr),
-      child_count(child_count), payload_size(payload_size), aggr_type(aggr_type), return_type(return_type),
-      filter(filter) {
-}
-
-AggregateObject::AggregateObject(BoundAggregateExpression *aggr)
-    : AggregateObject(aggr->function, aggr->bind_info.get(), aggr->children.size(),
-                      AlignValue(aggr->function.state_size(aggr->function)), aggr->aggr_type,
-                      aggr->return_type.InternalType(), aggr->filter.get()) {
-}
-
-AggregateObject::AggregateObject(const BoundWindowExpression &window)
-    : AggregateObject(*window.aggregate, window.bind_info.get(), window.children.size(),
-                      AlignValue(window.aggregate->state_size(*window.aggregate)),
-                      window.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT,
-                      window.return_type.InternalType(), window.filter_expr.get()) {
-}
-
-vector<AggregateObject> AggregateObject::CreateAggregateObjects(const vector<BoundAggregateExpression *> &bindings) {
-	vector<AggregateObject> aggregates;
-	aggregates.reserve(bindings.size());
-	for (auto &binding : bindings) {
-		aggregates.emplace_back(binding);
-	}
-	return aggregates;
-}
-
-AggregateFilterData::AggregateFilterData(ClientContext &context, Expression &filter_expr,
-                                         const vector<LogicalType> &payload_types)
-    : filter_executor(context, &filter_expr), true_sel(STANDARD_VECTOR_SIZE) {
-	if (payload_types.empty()) {
-		return;
-	}
-	filtered_payload.Initialize(Allocator::Get(context), payload_types);
-}
-
-idx_t AggregateFilterData::ApplyFilter(DataChunk &payload) {
-	filtered_payload.Reset();
-
-	auto count = filter_executor.SelectExpression(payload, true_sel);
-	filtered_payload.Slice(payload, true_sel, count);
-	return count;
-}
-
-AggregateFilterDataSet::AggregateFilterDataSet() {
-}
-
-void AggregateFilterDataSet::Initialize(ClientContext &context, const vector<AggregateObject> &aggregates,
-                                        const vector<LogicalType> &payload_types) {
-	bool has_filters = false;
-	for (auto &aggregate : aggregates) {
-		if (aggregate.filter) {
-			has_filters = true;
-			break;
-		}
-	}
-	if (!has_filters) {
-		// no filters: nothing to do
-		return;
-	}
-	filter_data.resize(aggregates.size());
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggr = aggregates[aggr_idx];
-		if (aggr.filter) {
-			filter_data[aggr_idx] = make_uniq<AggregateFilterData>(context, *aggr.filter, payload_types);
-		}
-	}
-}
-
-AggregateFilterData &AggregateFilterDataSet::GetFilterData(idx_t aggr_idx) {
-	D_ASSERT(aggr_idx < filter_data.size());
-	D_ASSERT(filter_data[aggr_idx]);
-	return *filter_data[aggr_idx];
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp b/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp
deleted file mode 100644
index d1d0d20d6..000000000
--- a/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-//! Shared information about a collection of distinct aggregates
-DistinctAggregateCollectionInfo::DistinctAggregateCollectionInfo(const vector<unique_ptr<Expression>> &aggregates,
-                                                                 vector<idx_t> indices)
-    : indices(std::move(indices)), aggregates(aggregates) {
-	table_count = CreateTableIndexMap();
-
-	const idx_t aggregate_count = aggregates.size();
-
-	total_child_count = 0;
-	for (idx_t i = 0; i < aggregate_count; i++) {
-		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
-
-		if (!aggregate.IsDistinct()) {
-			continue;
-		}
-		total_child_count += aggregate.children.size();
-	}
-}
-
-//! Stateful data for the distinct aggregates
-
-DistinctAggregateState::DistinctAggregateState(const DistinctAggregateData &data, ClientContext &client)
-    : child_executor(client) {
-
-	radix_states.resize(data.info.table_count);
-	distinct_output_chunks.resize(data.info.table_count);
-
-	idx_t aggregate_count = data.info.aggregates.size();
-	for (idx_t i = 0; i < aggregate_count; i++) {
-		auto &aggregate = data.info.aggregates[i]->Cast<BoundAggregateExpression>();
-
-		// Initialize the child executor and get the payload types for every aggregate
-		for (auto &child : aggregate.children) {
-			child_executor.AddExpression(*child);
-		}
-		if (!aggregate.IsDistinct()) {
-			continue;
-		}
-		D_ASSERT(data.info.table_map.count(i));
-		idx_t table_idx = data.info.table_map.at(i);
-		if (data.radix_tables[table_idx] == nullptr) {
-			//! This table is unused because the aggregate shares its data with another
-			continue;
-		}
-
-		// Get the global sinkstate for the aggregate
-		auto &radix_table = *data.radix_tables[table_idx];
-		radix_states[table_idx] = radix_table.GetGlobalSinkState(client);
-
-		// Fill the chunk_types (group_by + children)
-		vector<LogicalType> chunk_types;
-		for (auto &group_type : data.grouped_aggregate_data[table_idx]->group_types) {
-			chunk_types.push_back(group_type);
-		}
-
-		// This is used in Finalize to get the data from the radix table
-		distinct_output_chunks[table_idx] = make_uniq<DataChunk>();
-		distinct_output_chunks[table_idx]->Initialize(client, chunk_types);
-	}
-}
-
-//! Persistent + shared (read-only) data for the distinct aggregates
-DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionInfo &info)
-    : DistinctAggregateData(info, {}, nullptr) {
-}
-
-DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionInfo &info, const GroupingSet &groups,
-                                             const vector<unique_ptr<Expression>> *group_expressions)
-    : info(info) {
-	grouped_aggregate_data.resize(info.table_count);
-	radix_tables.resize(info.table_count);
-	grouping_sets.resize(info.table_count);
-
-	for (auto &i : info.indices) {
-		auto &aggregate = info.aggregates[i]->Cast<BoundAggregateExpression>();
-
-		D_ASSERT(info.table_map.count(i));
-		idx_t table_idx = info.table_map.at(i);
-		if (radix_tables[table_idx] != nullptr) {
-			//! This aggregate shares a table with another aggregate, and the table is already initialized
-			continue;
-		}
-		// The grouping set contains the indices of the chunk that correspond to the data vector
-		// that will be used to figure out in which bucket the payload should be put
-		auto &grouping_set = grouping_sets[table_idx];
-		//! Populate the group with the children of the aggregate
-		for (auto &group : groups) {
-			grouping_set.insert(group);
-		}
-		idx_t group_by_size = group_expressions ? group_expressions->size() : 0;
-		for (idx_t set_idx = 0; set_idx < aggregate.children.size(); set_idx++) {
-			grouping_set.insert(set_idx + group_by_size);
-		}
-		// Create the hashtable for the aggregate
-		grouped_aggregate_data[table_idx] = make_uniq<GroupedAggregateData>();
-		grouped_aggregate_data[table_idx]->InitializeDistinct(info.aggregates[i], group_expressions);
-		radix_tables[table_idx] =
-		    make_uniq<RadixPartitionedHashTable>(grouping_set, *grouped_aggregate_data[table_idx]);
-
-		// Fill the chunk_types (only contains the payload of the distinct aggregates)
-		vector<LogicalType> chunk_types;
-		for (auto &child_p : aggregate.children) {
-			chunk_types.push_back(child_p->return_type);
-		}
-	}
-}
-
-using aggr_ref_t = reference<BoundAggregateExpression>;
-
-struct FindMatchingAggregate {
-	explicit FindMatchingAggregate(const aggr_ref_t &aggr) : aggr_r(aggr) {
-	}
-	bool operator()(const aggr_ref_t other_r) {
-		auto &other = other_r.get();
-		auto &aggr = aggr_r.get();
-		if (other.children.size() != aggr.children.size()) {
-			return false;
-		}
-		if (!Expression::Equals(aggr.filter, other.filter)) {
-			return false;
-		}
-		for (idx_t i = 0; i < aggr.children.size(); i++) {
-			auto &other_child = other.children[i]->Cast<BoundReferenceExpression>();
-			auto &aggr_child = aggr.children[i]->Cast<BoundReferenceExpression>();
-			if (other_child.index != aggr_child.index) {
-				return false;
-			}
-		}
-		return true;
-	}
-	const aggr_ref_t aggr_r;
-};
-
-idx_t DistinctAggregateCollectionInfo::CreateTableIndexMap() {
-	vector<aggr_ref_t> table_inputs;
-
-	D_ASSERT(table_map.empty());
-	for (auto &agg_idx : indices) {
-		D_ASSERT(agg_idx < aggregates.size());
-		auto &aggregate = aggregates[agg_idx]->Cast<BoundAggregateExpression>();
-
-		auto matching_inputs =
-		    std::find_if(table_inputs.begin(), table_inputs.end(), FindMatchingAggregate(std::ref(aggregate)));
-		if (matching_inputs != table_inputs.end()) {
-			//! Assign the existing table to the aggregate
-			auto found_idx = NumericCast<idx_t>(std::distance(table_inputs.begin(), matching_inputs));
-			table_map[agg_idx] = found_idx;
-			continue;
-		}
-		//! Create a new table and assign its index to the aggregate
-		table_map[agg_idx] = table_inputs.size();
-		table_inputs.push_back(std::ref(aggregate));
-	}
-	//! Every distinct aggregate needs to be assigned an index
-	D_ASSERT(table_map.size() == indices.size());
-	//! There can not be more tables than there are distinct aggregates
-	D_ASSERT(table_inputs.size() <= indices.size());
-
-	return table_inputs.size();
-}
-
-bool DistinctAggregateCollectionInfo::AnyDistinct() const {
-	return !indices.empty();
-}
-
-const unsafe_vector<idx_t> &DistinctAggregateCollectionInfo::Indices() const {
-	return this->indices;
-}
-
-static vector<idx_t> GetDistinctIndices(vector<unique_ptr<Expression>> &aggregates) {
-	vector<idx_t> distinct_indices;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i];
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		if (aggr.IsDistinct()) {
-			distinct_indices.push_back(i);
-		}
-	}
-	return distinct_indices;
-}
-
-unique_ptr<DistinctAggregateCollectionInfo>
-DistinctAggregateCollectionInfo::Create(vector<unique_ptr<Expression>> &aggregates) {
-	vector<idx_t> indices = GetDistinctIndices(aggregates);
-	if (indices.empty()) {
-		return nullptr;
-	}
-	return make_uniq<DistinctAggregateCollectionInfo>(aggregates, std::move(indices));
-}
-
-bool DistinctAggregateData::IsDistinct(idx_t index) const {
-	bool is_distinct = !radix_tables.empty() && info.table_map.count(index);
-#ifdef DEBUG
-	//! Make sure that if it is distinct, it's also in the indices
-	//! And if it's not distinct, that it's also not in the indices
-	bool found = false;
-	for (auto &idx : info.indices) {
-		if (idx == index) {
-			found = true;
-			break;
-		}
-	}
-	D_ASSERT(found == is_distinct);
-#endif
-	return is_distinct;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/grouped_aggregate_data.cpp b/src/duckdb/src/execution/operator/aggregate/grouped_aggregate_data.cpp
deleted file mode 100644
index 088a0f59a..000000000
--- a/src/duckdb/src/execution/operator/aggregate/grouped_aggregate_data.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-
-namespace duckdb {
-
-idx_t GroupedAggregateData::GroupCount() const {
-	return groups.size();
-}
-
-const vector<vector<idx_t>> &GroupedAggregateData::GetGroupingFunctions() const {
-	return grouping_functions;
-}
-
-void GroupedAggregateData::InitializeGroupby(vector<unique_ptr<Expression>> groups,
-                                             vector<unique_ptr<Expression>> expressions,
-                                             vector<unsafe_vector<idx_t>> grouping_functions) {
-	InitializeGroupbyGroups(std::move(groups));
-	vector<LogicalType> payload_types_filters;
-
-	SetGroupingFunctions(grouping_functions);
-
-	filter_count = 0;
-	for (auto &expr : expressions) {
-		D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-		D_ASSERT(expr->IsAggregate());
-		auto &aggr = expr->Cast<BoundAggregateExpression>();
-		bindings.push_back(&aggr);
-
-		aggregate_return_types.push_back(aggr.return_type);
-		for (auto &child : aggr.children) {
-			payload_types.push_back(child->return_type);
-		}
-		if (aggr.filter) {
-			filter_count++;
-			payload_types_filters.push_back(aggr.filter->return_type);
-		}
-		if (!aggr.function.combine) {
-			throw InternalException("Aggregate function %s is missing a combine method", aggr.function.name);
-		}
-		aggregates.push_back(std::move(expr));
-	}
-	for (const auto &pay_filters : payload_types_filters) {
-		payload_types.push_back(pay_filters);
-	}
-}
-
-void GroupedAggregateData::InitializeDistinct(const unique_ptr<Expression> &aggregate,
-                                              const vector<unique_ptr<Expression>> *groups_p) {
-	auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-	D_ASSERT(aggr.IsDistinct());
-
-	// Add the (empty in ungrouped case) groups of the aggregates
-	InitializeDistinctGroups(groups_p);
-
-	// bindings.push_back(&aggr);
-	filter_count = 0;
-	aggregate_return_types.push_back(aggr.return_type);
-	for (idx_t i = 0; i < aggr.children.size(); i++) {
-		auto &child = aggr.children[i];
-		group_types.push_back(child->return_type);
-		groups.push_back(child->Copy());
-		payload_types.push_back(child->return_type);
-		if (aggr.filter) {
-			filter_count++;
-		}
-	}
-	if (!aggr.function.combine) {
-		throw InternalException("Aggregate function %s is missing a combine method", aggr.function.name);
-	}
-}
-
-void GroupedAggregateData::InitializeDistinctGroups(const vector<unique_ptr<Expression>> *groups_p) {
-	if (!groups_p) {
-		return;
-	}
-	for (auto &expr : *groups_p) {
-		group_types.push_back(expr->return_type);
-		groups.push_back(expr->Copy());
-	}
-}
-
-void GroupedAggregateData::InitializeGroupbyGroups(vector<unique_ptr<Expression>> groups) {
-	// Add all the expressions of the group by clause
-	for (auto &expr : groups) {
-		group_types.push_back(expr->return_type);
-	}
-	this->groups = std::move(groups);
-}
-
-void GroupedAggregateData::SetGroupingFunctions(vector<unsafe_vector<idx_t>> &functions) {
-	grouping_functions.reserve(functions.size());
-	for (idx_t i = 0; i < functions.size(); i++) {
-		grouping_functions.push_back(std::move(functions[i]));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp b/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp
deleted file mode 100644
index 6636389ea..000000000
--- a/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp
+++ /dev/null
@@ -1,928 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-namespace duckdb {
-
-HashAggregateGroupingData::HashAggregateGroupingData(GroupingSet &grouping_set_p,
-                                                     const GroupedAggregateData &grouped_aggregate_data,
-                                                     unique_ptr<DistinctAggregateCollectionInfo> &info)
-    : table_data(grouping_set_p, grouped_aggregate_data) {
-	if (info) {
-		distinct_data = make_uniq<DistinctAggregateData>(*info, grouping_set_p, &grouped_aggregate_data.groups);
-	}
-}
-
-bool HashAggregateGroupingData::HasDistinct() const {
-	return distinct_data != nullptr;
-}
-
-HashAggregateGroupingGlobalState::HashAggregateGroupingGlobalState(const HashAggregateGroupingData &data,
-                                                                   ClientContext &context) {
-	table_state = data.table_data.GetGlobalSinkState(context);
-	if (data.HasDistinct()) {
-		distinct_state = make_uniq<DistinctAggregateState>(*data.distinct_data, context);
-	}
-}
-
-HashAggregateGroupingLocalState::HashAggregateGroupingLocalState(const PhysicalHashAggregate &op,
-                                                                 const HashAggregateGroupingData &data,
-                                                                 ExecutionContext &context) {
-	table_state = data.table_data.GetLocalSinkState(context);
-	if (!data.HasDistinct()) {
-		return;
-	}
-	auto &distinct_data = *data.distinct_data;
-
-	auto &distinct_indices = op.distinct_collection_info->Indices();
-	D_ASSERT(!distinct_indices.empty());
-
-	distinct_states.resize(op.distinct_collection_info->aggregates.size());
-	auto &table_map = op.distinct_collection_info->table_map;
-
-	for (auto &idx : distinct_indices) {
-		idx_t table_idx = table_map[idx];
-		auto &radix_table = distinct_data.radix_tables[table_idx];
-		if (radix_table == nullptr) {
-			// This aggregate has identical input as another aggregate, so no table is created for it
-			continue;
-		}
-		// Initialize the states of the radix tables used for the distinct aggregates
-		distinct_states[table_idx] = radix_table->GetLocalSinkState(context);
-	}
-}
-
-static vector<LogicalType> CreateGroupChunkTypes(vector<unique_ptr<Expression>> &groups) {
-	set<idx_t> group_indices;
-
-	if (groups.empty()) {
-		return {};
-	}
-
-	for (auto &group : groups) {
-		D_ASSERT(group->GetExpressionType() == ExpressionType::BOUND_REF);
-		auto &bound_ref = group->Cast<BoundReferenceExpression>();
-		group_indices.insert(bound_ref.index);
-	}
-	idx_t highest_index = *group_indices.rbegin();
-	vector<LogicalType> types(highest_index + 1, LogicalType::SQLNULL);
-	for (auto &group : groups) {
-		auto &bound_ref = group->Cast<BoundReferenceExpression>();
-		types[bound_ref.index] = bound_ref.return_type;
-	}
-	return types;
-}
-
-bool PhysicalHashAggregate::CanSkipRegularSink() const {
-	if (!filter_indexes.empty()) {
-		// If we have filters, we can't skip the regular sink, because we might lose groups otherwise.
-		return false;
-	}
-	if (grouped_aggregate_data.aggregates.empty()) {
-		// When there are no aggregates, we have to add to the main ht right away
-		return false;
-	}
-	if (!non_distinct_filter.empty()) {
-		return false;
-	}
-	return true;
-}
-
-PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
-                                             vector<unique_ptr<Expression>> expressions, idx_t estimated_cardinality)
-    : PhysicalHashAggregate(context, std::move(types), std::move(expressions), {}, estimated_cardinality) {
-}
-
-PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
-                                             vector<unique_ptr<Expression>> expressions,
-                                             vector<unique_ptr<Expression>> groups_p, idx_t estimated_cardinality)
-    : PhysicalHashAggregate(context, std::move(types), std::move(expressions), std::move(groups_p), {}, {},
-                            estimated_cardinality) {
-}
-
-PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
-                                             vector<unique_ptr<Expression>> expressions,
-                                             vector<unique_ptr<Expression>> groups_p,
-                                             vector<GroupingSet> grouping_sets_p,
-                                             vector<unsafe_vector<idx_t>> grouping_functions_p,
-                                             idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::HASH_GROUP_BY, std::move(types), estimated_cardinality),
-      grouping_sets(std::move(grouping_sets_p)) {
-	// get a list of all aggregates to be computed
-	const idx_t group_count = groups_p.size();
-	if (grouping_sets.empty()) {
-		GroupingSet set;
-		for (idx_t i = 0; i < group_count; i++) {
-			set.insert(i);
-		}
-		grouping_sets.push_back(std::move(set));
-	}
-	input_group_types = CreateGroupChunkTypes(groups_p);
-
-	grouped_aggregate_data.InitializeGroupby(std::move(groups_p), std::move(expressions),
-	                                         std::move(grouping_functions_p));
-
-	auto &aggregates = grouped_aggregate_data.aggregates;
-	// filter_indexes must be pre-built, not lazily instantiated in parallel...
-	// Because everything that lives in this class should be read-only at execution time
-	idx_t aggregate_input_idx = 0;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i];
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		aggregate_input_idx += aggr.children.size();
-		if (aggr.aggr_type == AggregateType::DISTINCT) {
-			distinct_filter.push_back(i);
-		} else if (aggr.aggr_type == AggregateType::NON_DISTINCT) {
-			non_distinct_filter.push_back(i);
-		} else { // LCOV_EXCL_START
-			throw NotImplementedException("AggregateType not implemented in PhysicalHashAggregate");
-		} // LCOV_EXCL_STOP
-	}
-
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i];
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		if (aggr.filter) {
-			auto &bound_ref_expr = aggr.filter->Cast<BoundReferenceExpression>();
-			if (!filter_indexes.count(aggr.filter.get())) {
-				// Replace the bound reference expression's index with the corresponding index of the payload chunk
-				filter_indexes[aggr.filter.get()] = bound_ref_expr.index;
-				bound_ref_expr.index = aggregate_input_idx;
-			}
-			aggregate_input_idx++;
-		}
-	}
-
-	distinct_collection_info = DistinctAggregateCollectionInfo::Create(grouped_aggregate_data.aggregates);
-
-	for (idx_t i = 0; i < grouping_sets.size(); i++) {
-		groupings.emplace_back(grouping_sets[i], grouped_aggregate_data, distinct_collection_info);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class HashAggregateGlobalSinkState : public GlobalSinkState {
-public:
-	HashAggregateGlobalSinkState(const PhysicalHashAggregate &op, ClientContext &context) {
-		grouping_states.reserve(op.groupings.size());
-		for (idx_t i = 0; i < op.groupings.size(); i++) {
-			auto &grouping = op.groupings[i];
-			grouping_states.emplace_back(grouping, context);
-		}
-		vector<LogicalType> filter_types;
-		for (auto &aggr : op.grouped_aggregate_data.aggregates) {
-			auto &aggregate = aggr->Cast<BoundAggregateExpression>();
-			for (auto &child : aggregate.children) {
-				payload_types.push_back(child->return_type);
-			}
-			if (aggregate.filter) {
-				filter_types.push_back(aggregate.filter->return_type);
-			}
-		}
-		payload_types.reserve(payload_types.size() + filter_types.size());
-		payload_types.insert(payload_types.end(), filter_types.begin(), filter_types.end());
-	}
-
-	vector<HashAggregateGroupingGlobalState> grouping_states;
-	vector<LogicalType> payload_types;
-	//! Whether or not the aggregate is finished
-	bool finished = false;
-};
-
-class HashAggregateLocalSinkState : public LocalSinkState {
-public:
-	HashAggregateLocalSinkState(const PhysicalHashAggregate &op, ExecutionContext &context) {
-
-		auto &payload_types = op.grouped_aggregate_data.payload_types;
-		if (!payload_types.empty()) {
-			aggregate_input_chunk.InitializeEmpty(payload_types);
-		}
-
-		grouping_states.reserve(op.groupings.size());
-		for (auto &grouping : op.groupings) {
-			grouping_states.emplace_back(op, grouping, context);
-		}
-		// The filter set is only needed here for the distinct aggregates
-		// the filtering of data for the regular aggregates is done within the hashtable
-		vector<AggregateObject> aggregate_objects;
-		for (auto &aggregate : op.grouped_aggregate_data.aggregates) {
-			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-			aggregate_objects.emplace_back(&aggr);
-		}
-
-		filter_set.Initialize(context.client, aggregate_objects, payload_types);
-	}
-
-	DataChunk aggregate_input_chunk;
-	vector<HashAggregateGroupingLocalState> grouping_states;
-	AggregateFilterDataSet filter_set;
-};
-
-void PhysicalHashAggregate::SetMultiScan(GlobalSinkState &state) {
-	auto &gstate = state.Cast<HashAggregateGlobalSinkState>();
-	for (auto &grouping_state : gstate.grouping_states) {
-		RadixPartitionedHashTable::SetMultiScan(*grouping_state.table_state);
-		if (!grouping_state.distinct_state) {
-			continue;
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-unique_ptr<GlobalSinkState> PhysicalHashAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<HashAggregateGlobalSinkState>(*this, context);
-}
-
-unique_ptr<LocalSinkState> PhysicalHashAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<HashAggregateLocalSinkState>(*this, context);
-}
-
-void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
-                                                 idx_t grouping_idx) const {
-	auto &sink = input.local_state.Cast<HashAggregateLocalSinkState>();
-	auto &global_sink = input.global_state.Cast<HashAggregateGlobalSinkState>();
-
-	auto &grouping_gstate = global_sink.grouping_states[grouping_idx];
-	auto &grouping_lstate = sink.grouping_states[grouping_idx];
-	auto &distinct_info = *distinct_collection_info;
-
-	auto &distinct_state = grouping_gstate.distinct_state;
-	auto &distinct_data = groupings[grouping_idx].distinct_data;
-
-	DataChunk empty_chunk;
-
-	// Create an empty filter for Sink, since we don't need to update any aggregate states here
-	unsafe_vector<idx_t> empty_filter;
-
-	for (idx_t &idx : distinct_info.indices) {
-		auto &aggregate = grouped_aggregate_data.aggregates[idx]->Cast<BoundAggregateExpression>();
-
-		D_ASSERT(distinct_info.table_map.count(idx));
-		idx_t table_idx = distinct_info.table_map[idx];
-		if (!distinct_data->radix_tables[table_idx]) {
-			continue;
-		}
-		D_ASSERT(distinct_data->radix_tables[table_idx]);
-		auto &radix_table = *distinct_data->radix_tables[table_idx];
-		auto &radix_global_sink = *distinct_state->radix_states[table_idx];
-		auto &radix_local_sink = *grouping_lstate.distinct_states[table_idx];
-
-		InterruptState interrupt_state;
-		OperatorSinkInput sink_input {radix_global_sink, radix_local_sink, interrupt_state};
-
-		if (aggregate.filter) {
-			DataChunk filter_chunk;
-			auto &filtered_data = sink.filter_set.GetFilterData(idx);
-			filter_chunk.InitializeEmpty(filtered_data.filtered_payload.GetTypes());
-
-			// Add the filter Vector (BOOL)
-			auto it = filter_indexes.find(aggregate.filter.get());
-			D_ASSERT(it != filter_indexes.end());
-			D_ASSERT(it->second < chunk.data.size());
-			auto &filter_bound_ref = aggregate.filter->Cast<BoundReferenceExpression>();
-			filter_chunk.data[filter_bound_ref.index].Reference(chunk.data[it->second]);
-			filter_chunk.SetCardinality(chunk.size());
-
-			// We cant use the AggregateFilterData::ApplyFilter method, because the chunk we need to
-			// apply the filter to also has the groups, and the filtered_data.filtered_payload does not have those.
-			SelectionVector sel_vec(STANDARD_VECTOR_SIZE);
-			idx_t count = filtered_data.filter_executor.SelectExpression(filter_chunk, sel_vec);
-
-			if (count == 0) {
-				continue;
-			}
-
-			// Because the 'input' chunk needs to be re-used after this, we need to create
-			// a duplicate of it, that we can apply the filter to
-			DataChunk filtered_input;
-			filtered_input.InitializeEmpty(chunk.GetTypes());
-
-			for (idx_t group_idx = 0; group_idx < grouped_aggregate_data.groups.size(); group_idx++) {
-				auto &group = grouped_aggregate_data.groups[group_idx];
-				auto &bound_ref = group->Cast<BoundReferenceExpression>();
-				auto &col = filtered_input.data[bound_ref.index];
-				col.Reference(chunk.data[bound_ref.index]);
-				col.Slice(sel_vec, count);
-			}
-			for (idx_t child_idx = 0; child_idx < aggregate.children.size(); child_idx++) {
-				auto &child = aggregate.children[child_idx];
-				auto &bound_ref = child->Cast<BoundReferenceExpression>();
-				auto &col = filtered_input.data[bound_ref.index];
-				col.Reference(chunk.data[bound_ref.index]);
-				col.Slice(sel_vec, count);
-			}
-			filtered_input.SetCardinality(count);
-
-			radix_table.Sink(context, filtered_input, sink_input, empty_chunk, empty_filter);
-		} else {
-			radix_table.Sink(context, chunk, sink_input, empty_chunk, empty_filter);
-		}
-	}
-}
-
-void PhysicalHashAggregate::SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	for (idx_t i = 0; i < groupings.size(); i++) {
-		SinkDistinctGrouping(context, chunk, input, i);
-	}
-}
-
-SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
-                                           OperatorSinkInput &input) const {
-	auto &local_state = input.local_state.Cast<HashAggregateLocalSinkState>();
-	auto &global_state = input.global_state.Cast<HashAggregateGlobalSinkState>();
-
-	if (distinct_collection_info) {
-		SinkDistinct(context, chunk, input);
-	}
-
-	if (CanSkipRegularSink()) {
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	DataChunk &aggregate_input_chunk = local_state.aggregate_input_chunk;
-	auto &aggregates = grouped_aggregate_data.aggregates;
-	idx_t aggregate_input_idx = 0;
-
-	// Populate the aggregate child vectors
-	for (auto &aggregate : aggregates) {
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		for (auto &child_expr : aggr.children) {
-			D_ASSERT(child_expr->GetExpressionType() == ExpressionType::BOUND_REF);
-			auto &bound_ref_expr = child_expr->Cast<BoundReferenceExpression>();
-			D_ASSERT(bound_ref_expr.index < chunk.data.size());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[bound_ref_expr.index]);
-		}
-	}
-	// Populate the filter vectors
-	for (auto &aggregate : aggregates) {
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		if (aggr.filter) {
-			auto it = filter_indexes.find(aggr.filter.get());
-			D_ASSERT(it != filter_indexes.end());
-			D_ASSERT(it->second < chunk.data.size());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[it->second]);
-		}
-	}
-
-	aggregate_input_chunk.SetCardinality(chunk.size());
-	aggregate_input_chunk.Verify();
-
-	// For every grouping set there is one radix_table
-	for (idx_t i = 0; i < groupings.size(); i++) {
-		auto &grouping_global_state = global_state.grouping_states[i];
-		auto &grouping_local_state = local_state.grouping_states[i];
-		InterruptState interrupt_state;
-		OperatorSinkInput sink_input {*grouping_global_state.table_state, *grouping_local_state.table_state,
-		                              interrupt_state};
-
-		auto &grouping = groupings[i];
-		auto &table = grouping.table_data;
-		table.Sink(context, chunk, sink_input, aggregate_input_chunk, non_distinct_filter);
-	}
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-void PhysicalHashAggregate::CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-
-	auto &global_sink = input.global_state.Cast<HashAggregateGlobalSinkState>();
-	auto &sink = input.local_state.Cast<HashAggregateLocalSinkState>();
-
-	if (!distinct_collection_info) {
-		return;
-	}
-	for (idx_t i = 0; i < groupings.size(); i++) {
-		auto &grouping_gstate = global_sink.grouping_states[i];
-		auto &grouping_lstate = sink.grouping_states[i];
-
-		auto &distinct_data = groupings[i].distinct_data;
-		auto &distinct_state = grouping_gstate.distinct_state;
-
-		const auto table_count = distinct_data->radix_tables.size();
-		for (idx_t table_idx = 0; table_idx < table_count; table_idx++) {
-			if (!distinct_data->radix_tables[table_idx]) {
-				continue;
-			}
-			auto &radix_table = *distinct_data->radix_tables[table_idx];
-			auto &radix_global_sink = *distinct_state->radix_states[table_idx];
-			auto &radix_local_sink = *grouping_lstate.distinct_states[table_idx];
-
-			radix_table.Combine(context, radix_global_sink, radix_local_sink);
-		}
-	}
-}
-
-SinkCombineResultType PhysicalHashAggregate::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<HashAggregateGlobalSinkState>();
-	auto &llstate = input.local_state.Cast<HashAggregateLocalSinkState>();
-
-	OperatorSinkCombineInput combine_distinct_input {gstate, llstate, input.interrupt_state};
-	CombineDistinct(context, combine_distinct_input);
-
-	if (CanSkipRegularSink()) {
-		return SinkCombineResultType::FINISHED;
-	}
-	for (idx_t i = 0; i < groupings.size(); i++) {
-		auto &grouping_gstate = gstate.grouping_states[i];
-		auto &grouping_lstate = llstate.grouping_states[i];
-
-		auto &grouping = groupings[i];
-		auto &table = grouping.table_data;
-		table.Combine(context, *grouping_gstate.table_state, *grouping_lstate.table_state);
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-class HashAggregateFinalizeEvent : public BasePipelineEvent {
-public:
-	//! "Regular" Finalize Event that is scheduled after combining the thread-local distinct HTs
-	HashAggregateFinalizeEvent(ClientContext &context, Pipeline *pipeline_p, const PhysicalHashAggregate &op_p,
-	                           HashAggregateGlobalSinkState &gstate_p)
-	    : BasePipelineEvent(*pipeline_p), context(context), op(op_p), gstate(gstate_p) {
-	}
-
-public:
-	void Schedule() override;
-
-private:
-	ClientContext &context;
-
-	const PhysicalHashAggregate &op;
-	HashAggregateGlobalSinkState &gstate;
-};
-
-class HashAggregateFinalizeTask : public ExecutorTask {
-public:
-	HashAggregateFinalizeTask(ClientContext &context, Pipeline &pipeline, shared_ptr<Event> event_p,
-	                          const PhysicalHashAggregate &op, HashAggregateGlobalSinkState &state_p)
-	    : ExecutorTask(pipeline.executor, std::move(event_p)), context(context), pipeline(pipeline), op(op),
-	      gstate(state_p) {
-	}
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
-
-private:
-	ClientContext &context;
-	Pipeline &pipeline;
-
-	const PhysicalHashAggregate &op;
-	HashAggregateGlobalSinkState &gstate;
-};
-
-void HashAggregateFinalizeEvent::Schedule() {
-	vector<shared_ptr<Task>> tasks;
-	tasks.push_back(make_uniq<HashAggregateFinalizeTask>(context, *pipeline, shared_from_this(), op, gstate));
-	D_ASSERT(!tasks.empty());
-	SetTasks(std::move(tasks));
-}
-
-TaskExecutionResult HashAggregateFinalizeTask::ExecuteTask(TaskExecutionMode mode) {
-	op.FinalizeInternal(pipeline, *event, context, gstate, false);
-	D_ASSERT(!gstate.finished);
-	gstate.finished = true;
-	event->FinishTask();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-class HashAggregateDistinctFinalizeEvent : public BasePipelineEvent {
-public:
-	//! Distinct Finalize Event that is scheduled if we have distinct aggregates
-	HashAggregateDistinctFinalizeEvent(ClientContext &context, Pipeline &pipeline_p, const PhysicalHashAggregate &op_p,
-	                                   HashAggregateGlobalSinkState &gstate_p)
-	    : BasePipelineEvent(pipeline_p), context(context), op(op_p), gstate(gstate_p) {
-	}
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-
-private:
-	idx_t CreateGlobalSources();
-
-private:
-	ClientContext &context;
-
-	const PhysicalHashAggregate &op;
-	HashAggregateGlobalSinkState &gstate;
-
-public:
-	//! The GlobalSourceStates for all the radix tables of the distinct aggregates
-	vector<vector<unique_ptr<GlobalSourceState>>> global_source_states;
-};
-
-class HashAggregateDistinctFinalizeTask : public ExecutorTask {
-public:
-	HashAggregateDistinctFinalizeTask(Pipeline &pipeline, shared_ptr<Event> event_p, const PhysicalHashAggregate &op,
-	                                  HashAggregateGlobalSinkState &state_p)
-	    : ExecutorTask(pipeline.executor, std::move(event_p)), pipeline(pipeline), op(op), gstate(state_p) {
-	}
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
-
-private:
-	TaskExecutionResult AggregateDistinctGrouping(const idx_t grouping_idx);
-
-private:
-	Pipeline &pipeline;
-
-	const PhysicalHashAggregate &op;
-	HashAggregateGlobalSinkState &gstate;
-
-	unique_ptr<LocalSinkState> local_sink_state;
-	idx_t grouping_idx = 0;
-	unique_ptr<LocalSourceState> radix_table_lstate;
-	bool blocked = false;
-	idx_t aggregation_idx = 0;
-	idx_t payload_idx = 0;
-	idx_t next_payload_idx = 0;
-};
-
-void HashAggregateDistinctFinalizeEvent::Schedule() {
-	auto n_tasks = CreateGlobalSources();
-	n_tasks = MinValue<idx_t>(n_tasks, NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads()));
-	vector<shared_ptr<Task>> tasks;
-	for (idx_t i = 0; i < n_tasks; i++) {
-		tasks.push_back(make_uniq<HashAggregateDistinctFinalizeTask>(*pipeline, shared_from_this(), op, gstate));
-	}
-	SetTasks(std::move(tasks));
-}
-
-idx_t HashAggregateDistinctFinalizeEvent::CreateGlobalSources() {
-	auto &aggregates = op.grouped_aggregate_data.aggregates;
-	global_source_states.reserve(op.groupings.size());
-
-	idx_t n_tasks = 0;
-	for (idx_t grouping_idx = 0; grouping_idx < op.groupings.size(); grouping_idx++) {
-		auto &grouping = op.groupings[grouping_idx];
-		auto &distinct_state = *gstate.grouping_states[grouping_idx].distinct_state;
-		auto &distinct_data = *grouping.distinct_data;
-
-		vector<unique_ptr<GlobalSourceState>> aggregate_sources;
-		aggregate_sources.reserve(aggregates.size());
-		for (idx_t agg_idx = 0; agg_idx < aggregates.size(); agg_idx++) {
-			auto &aggregate = aggregates[agg_idx];
-			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-
-			if (!aggr.IsDistinct()) {
-				aggregate_sources.push_back(nullptr);
-				continue;
-			}
-			D_ASSERT(distinct_data.info.table_map.count(agg_idx));
-
-			auto table_idx = distinct_data.info.table_map.at(agg_idx);
-			auto &radix_table_p = distinct_data.radix_tables[table_idx];
-			n_tasks += radix_table_p->MaxThreads(*distinct_state.radix_states[table_idx]);
-			aggregate_sources.push_back(radix_table_p->GetGlobalSourceState(context));
-		}
-		global_source_states.push_back(std::move(aggregate_sources));
-	}
-
-	return MaxValue<idx_t>(n_tasks, 1);
-}
-
-void HashAggregateDistinctFinalizeEvent::FinishEvent() {
-	// Now that everything is added to the main ht, we can actually finalize
-	auto new_event = make_shared_ptr<HashAggregateFinalizeEvent>(context, pipeline.get(), op, gstate);
-	this->InsertEvent(std::move(new_event));
-}
-
-TaskExecutionResult HashAggregateDistinctFinalizeTask::ExecuteTask(TaskExecutionMode mode) {
-	for (; grouping_idx < op.groupings.size(); grouping_idx++) {
-		auto res = AggregateDistinctGrouping(grouping_idx);
-		if (res == TaskExecutionResult::TASK_BLOCKED) {
-			return res;
-		}
-		D_ASSERT(res == TaskExecutionResult::TASK_FINISHED);
-		aggregation_idx = 0;
-		payload_idx = 0;
-		next_payload_idx = 0;
-		local_sink_state = nullptr;
-	}
-	event->FinishTask();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-TaskExecutionResult HashAggregateDistinctFinalizeTask::AggregateDistinctGrouping(const idx_t grouping_idx) {
-	D_ASSERT(op.distinct_collection_info);
-	auto &info = *op.distinct_collection_info;
-
-	auto &grouping_data = op.groupings[grouping_idx];
-	auto &grouping_state = gstate.grouping_states[grouping_idx];
-	D_ASSERT(grouping_state.distinct_state);
-	auto &distinct_state = *grouping_state.distinct_state;
-	auto &distinct_data = *grouping_data.distinct_data;
-
-	auto &aggregates = info.aggregates;
-
-	// Thread-local contexts
-	ThreadContext thread_context(executor.context);
-	ExecutionContext execution_context(executor.context, thread_context, &pipeline);
-
-	// Sink state to sink into global HTs
-	InterruptState interrupt_state(shared_from_this());
-	auto &global_sink_state = *grouping_state.table_state;
-	if (!local_sink_state) {
-		local_sink_state = grouping_data.table_data.GetLocalSinkState(execution_context);
-	}
-	OperatorSinkInput sink_input {global_sink_state, *local_sink_state, interrupt_state};
-
-	// Create a chunk that mimics the 'input' chunk in Sink, for storing the group vectors
-	DataChunk group_chunk;
-	if (!op.input_group_types.empty()) {
-		group_chunk.Initialize(executor.context, op.input_group_types);
-	}
-
-	const idx_t group_by_size = op.grouped_aggregate_data.groups.size();
-
-	DataChunk aggregate_input_chunk;
-	if (!gstate.payload_types.empty()) {
-		aggregate_input_chunk.Initialize(executor.context, gstate.payload_types);
-	}
-
-	const auto &finalize_event = event->Cast<HashAggregateDistinctFinalizeEvent>();
-
-	auto &agg_idx = aggregation_idx;
-	for (; agg_idx < op.grouped_aggregate_data.aggregates.size(); agg_idx++) {
-		auto &aggregate = aggregates[agg_idx]->Cast<BoundAggregateExpression>();
-
-		if (!blocked) {
-			// Forward the payload idx
-			payload_idx = next_payload_idx;
-			next_payload_idx = payload_idx + aggregate.children.size();
-		}
-
-		// If aggregate is not distinct, skip it
-		if (!distinct_data.IsDistinct(agg_idx)) {
-			continue;
-		}
-
-		D_ASSERT(distinct_data.info.table_map.count(agg_idx));
-		const auto &table_idx = distinct_data.info.table_map.at(agg_idx);
-		auto &radix_table = distinct_data.radix_tables[table_idx];
-
-		auto &sink = *distinct_state.radix_states[table_idx];
-		if (!blocked) {
-			radix_table_lstate = radix_table->GetLocalSourceState(execution_context);
-		}
-		auto &local_source = *radix_table_lstate;
-		OperatorSourceInput source_input {*finalize_event.global_source_states[grouping_idx][agg_idx], local_source,
-		                                  interrupt_state};
-
-		// Create a duplicate of the output_chunk, because of multi-threading we cant alter the original
-		DataChunk output_chunk;
-		output_chunk.Initialize(executor.context, distinct_state.distinct_output_chunks[table_idx]->GetTypes());
-
-		// Fetch all the data from the aggregate ht, and Sink it into the main ht
-		while (true) {
-			output_chunk.Reset();
-			group_chunk.Reset();
-			aggregate_input_chunk.Reset();
-
-			auto res = radix_table->GetData(execution_context, output_chunk, sink, source_input);
-			if (res == SourceResultType::FINISHED) {
-				D_ASSERT(output_chunk.size() == 0);
-				break;
-			} else if (res == SourceResultType::BLOCKED) {
-				blocked = true;
-				return TaskExecutionResult::TASK_BLOCKED;
-			}
-
-			auto &grouped_aggregate_data = *distinct_data.grouped_aggregate_data[table_idx];
-			for (idx_t group_idx = 0; group_idx < group_by_size; group_idx++) {
-				auto &group = grouped_aggregate_data.groups[group_idx];
-				auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
-				group_chunk.data[bound_ref_expr.index].Reference(output_chunk.data[group_idx]);
-			}
-			group_chunk.SetCardinality(output_chunk);
-
-			for (idx_t child_idx = 0; child_idx < grouped_aggregate_data.groups.size() - group_by_size; child_idx++) {
-				aggregate_input_chunk.data[payload_idx + child_idx].Reference(
-				    output_chunk.data[group_by_size + child_idx]);
-			}
-			aggregate_input_chunk.SetCardinality(output_chunk);
-
-			// Sink it into the main ht
-			grouping_data.table_data.Sink(execution_context, group_chunk, sink_input, aggregate_input_chunk, {agg_idx});
-		}
-		blocked = false;
-	}
-	grouping_data.table_data.Combine(execution_context, global_sink_state, *local_sink_state);
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-SinkFinalizeType PhysicalHashAggregate::FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                         GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<HashAggregateGlobalSinkState>();
-	D_ASSERT(distinct_collection_info);
-
-	for (idx_t i = 0; i < groupings.size(); i++) {
-		auto &grouping = groupings[i];
-		auto &distinct_data = *grouping.distinct_data;
-		auto &distinct_state = *gstate.grouping_states[i].distinct_state;
-
-		for (idx_t table_idx = 0; table_idx < distinct_data.radix_tables.size(); table_idx++) {
-			if (!distinct_data.radix_tables[table_idx]) {
-				continue;
-			}
-			auto &radix_table = distinct_data.radix_tables[table_idx];
-			auto &radix_state = *distinct_state.radix_states[table_idx];
-			radix_table->Finalize(context, radix_state);
-		}
-	}
-	auto new_event = make_shared_ptr<HashAggregateDistinctFinalizeEvent>(context, pipeline, *this, gstate);
-	event.InsertEvent(std::move(new_event));
-	return SinkFinalizeType::READY;
-}
-
-SinkFinalizeType PhysicalHashAggregate::FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                         GlobalSinkState &gstate_p, bool check_distinct) const {
-	auto &gstate = gstate_p.Cast<HashAggregateGlobalSinkState>();
-
-	if (check_distinct && distinct_collection_info) {
-		// There are distinct aggregates
-		// If these are partitioned those need to be combined first
-		// Then we Finalize again, skipping this step
-		return FinalizeDistinct(pipeline, event, context, gstate_p);
-	}
-
-	for (idx_t i = 0; i < groupings.size(); i++) {
-		auto &grouping = groupings[i];
-		auto &grouping_gstate = gstate.grouping_states[i];
-		grouping.table_data.Finalize(context, *grouping_gstate.table_state);
-	}
-	return SinkFinalizeType::READY;
-}
-
-SinkFinalizeType PhysicalHashAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                 OperatorSinkFinalizeInput &input) const {
-	return FinalizeInternal(pipeline, event, context, input.global_state, true);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class HashAggregateGlobalSourceState : public GlobalSourceState {
-public:
-	HashAggregateGlobalSourceState(ClientContext &context, const PhysicalHashAggregate &op) : op(op), state_index(0) {
-		for (auto &grouping : op.groupings) {
-			auto &rt = grouping.table_data;
-			radix_states.push_back(rt.GetGlobalSourceState(context));
-		}
-	}
-
-	const PhysicalHashAggregate &op;
-	atomic<idx_t> state_index;
-
-	vector<unique_ptr<GlobalSourceState>> radix_states;
-
-public:
-	idx_t MaxThreads() override {
-		// If there are no tables, we only need one thread.
-		if (op.groupings.empty()) {
-			return 1;
-		}
-
-		auto &ht_state = op.sink_state->Cast<HashAggregateGlobalSinkState>();
-		idx_t threads = 0;
-		for (size_t sidx = 0; sidx < op.groupings.size(); ++sidx) {
-			auto &grouping = op.groupings[sidx];
-			auto &grouping_gstate = ht_state.grouping_states[sidx];
-			threads += grouping.table_data.MaxThreads(*grouping_gstate.table_state);
-		}
-		return MaxValue<idx_t>(1, threads);
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalHashAggregate::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<HashAggregateGlobalSourceState>(context, *this);
-}
-
-class HashAggregateLocalSourceState : public LocalSourceState {
-public:
-	explicit HashAggregateLocalSourceState(ExecutionContext &context, const PhysicalHashAggregate &op) {
-		for (auto &grouping : op.groupings) {
-			auto &rt = grouping.table_data;
-			radix_states.push_back(rt.GetLocalSourceState(context));
-		}
-	}
-
-	optional_idx radix_idx;
-	vector<unique_ptr<LocalSourceState>> radix_states;
-};
-
-unique_ptr<LocalSourceState> PhysicalHashAggregate::GetLocalSourceState(ExecutionContext &context,
-                                                                        GlobalSourceState &gstate) const {
-	return make_uniq<HashAggregateLocalSourceState>(context, *this);
-}
-
-SourceResultType PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                OperatorSourceInput &input) const {
-	auto &sink_gstate = sink_state->Cast<HashAggregateGlobalSinkState>();
-	auto &gstate = input.global_state.Cast<HashAggregateGlobalSourceState>();
-	auto &lstate = input.local_state.Cast<HashAggregateLocalSourceState>();
-	while (true) {
-		if (!lstate.radix_idx.IsValid()) {
-			lstate.radix_idx = gstate.state_index.load();
-		}
-		const auto radix_idx = lstate.radix_idx.GetIndex();
-		if (radix_idx >= groupings.size()) {
-			break;
-		}
-
-		auto &grouping = groupings[radix_idx];
-		auto &radix_table = grouping.table_data;
-		auto &grouping_gstate = sink_gstate.grouping_states[radix_idx];
-
-		OperatorSourceInput source_input {*gstate.radix_states[radix_idx], *lstate.radix_states[radix_idx],
-		                                  input.interrupt_state};
-		auto res = radix_table.GetData(context, chunk, *grouping_gstate.table_state, source_input);
-		if (res == SourceResultType::BLOCKED) {
-			return res;
-		}
-		if (chunk.size() != 0) {
-			return SourceResultType::HAVE_MORE_OUTPUT;
-		}
-
-		// move to the next table
-		auto guard = gstate.Lock();
-		lstate.radix_idx = lstate.radix_idx.GetIndex() + 1;
-		if (lstate.radix_idx.GetIndex() > gstate.state_index) {
-			// we have not yet worked on the table
-			// move the global index forwards
-			gstate.state_index = lstate.radix_idx.GetIndex();
-		}
-		lstate.radix_idx = gstate.state_index.load();
-	}
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-ProgressData PhysicalHashAggregate::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &sink_gstate = sink_state->Cast<HashAggregateGlobalSinkState>();
-	auto &gstate = gstate_p.Cast<HashAggregateGlobalSourceState>();
-	ProgressData progress;
-	for (idx_t radix_idx = 0; radix_idx < groupings.size(); radix_idx++) {
-		progress.Add(groupings[radix_idx].table_data.GetProgress(
-		    context, *sink_gstate.grouping_states[radix_idx].table_state, *gstate.radix_states[radix_idx]));
-	}
-	return progress;
-}
-
-InsertionOrderPreservingMap<string> PhysicalHashAggregate::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	auto &groups = grouped_aggregate_data.groups;
-	auto &aggregates = grouped_aggregate_data.aggregates;
-	string groups_info;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			groups_info += "\n";
-		}
-		groups_info += groups[i]->GetName();
-	}
-	result["Groups"] = groups_info;
-
-	string aggregate_info;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
-		if (i > 0) {
-			aggregate_info += "\n";
-		}
-		aggregate_info += aggregates[i]->GetName();
-		if (aggregate.filter) {
-			aggregate_info += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	result["Aggregates"] = aggregate_info;
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/physical_partitioned_aggregate.cpp b/src/duckdb/src/execution/operator/aggregate/physical_partitioned_aggregate.cpp
deleted file mode 100644
index 32bf4ecc2..000000000
--- a/src/duckdb/src/execution/operator/aggregate/physical_partitioned_aggregate.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp"
-#include "duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp"
-#include "duckdb/common/types/value_map.hpp"
-
-namespace duckdb {
-
-PhysicalPartitionedAggregate::PhysicalPartitionedAggregate(ClientContext &context, vector<LogicalType> types,
-                                                           vector<unique_ptr<Expression>> aggregates_p,
-                                                           vector<unique_ptr<Expression>> groups_p,
-                                                           vector<column_t> partitions_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::PARTITIONED_AGGREGATE, std::move(types), estimated_cardinality),
-      partitions(std::move(partitions_p)), groups(std::move(groups_p)), aggregates(std::move(aggregates_p)) {
-}
-
-OperatorPartitionInfo PhysicalPartitionedAggregate::RequiredPartitionInfo() const {
-	return OperatorPartitionInfo::PartitionColumns(partitions);
-}
-//===--------------------------------------------------------------------===//
-// Global State
-//===--------------------------------------------------------------------===//
-class PartitionedAggregateLocalSinkState : public LocalSinkState {
-public:
-	PartitionedAggregateLocalSinkState(const PhysicalPartitionedAggregate &op, const vector<LogicalType> &child_types,
-	                                   ExecutionContext &context)
-	    : execute_state(context.client, op.aggregates, child_types) {
-	}
-
-	//! The current partition
-	Value current_partition;
-	//! The local aggregate state for the current partition
-	unique_ptr<LocalUngroupedAggregateState> state;
-	//! The ungrouped aggregate execute state
-	UngroupedAggregateExecuteState execute_state;
-};
-
-class PartitionedAggregateGlobalSinkState : public GlobalSinkState {
-public:
-	PartitionedAggregateGlobalSinkState(const PhysicalPartitionedAggregate &op, ClientContext &context)
-	    : op(op), aggregate_result(BufferAllocator::Get(context), op.types) {
-	}
-
-	mutex lock;
-	const PhysicalPartitionedAggregate &op;
-	//! The per-partition aggregate states
-	value_map_t<unique_ptr<GlobalUngroupedAggregateState>> aggregate_states;
-	//! Final aggregate result
-	ColumnDataCollection aggregate_result;
-
-	GlobalUngroupedAggregateState &GetOrCreatePartition(ClientContext &context, const Value &partition) {
-		lock_guard<mutex> l(lock);
-		// find the state that corresponds to this partition and combine
-		auto entry = aggregate_states.find(partition);
-		if (entry != aggregate_states.end()) {
-			return *entry->second;
-		}
-		// no state yet for this partition - allocate a new one
-		auto new_global_state = make_uniq<GlobalUngroupedAggregateState>(BufferAllocator::Get(context), op.aggregates);
-		auto &result = *new_global_state;
-		aggregate_states.insert(make_pair(partition, std::move(new_global_state)));
-		return result;
-	}
-
-	void Combine(ClientContext &context, PartitionedAggregateLocalSinkState &lstate) {
-		if (!lstate.state) {
-			// no aggregate state
-			return;
-		}
-		auto &global_state = GetOrCreatePartition(context, lstate.current_partition);
-		global_state.Combine(*lstate.state);
-		// clear the local aggregate state
-		lstate.state.reset();
-	}
-};
-
-unique_ptr<GlobalSinkState> PhysicalPartitionedAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<PartitionedAggregateGlobalSinkState>(*this, context);
-}
-
-//===--------------------------------------------------------------------===//
-// Local State
-//===--------------------------------------------------------------------===//
-
-unique_ptr<LocalSinkState> PhysicalPartitionedAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	D_ASSERT(sink_state);
-	return make_uniq<PartitionedAggregateLocalSinkState>(*this, children[0]->GetTypes(), context);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalPartitionedAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
-                                                  OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<PartitionedAggregateGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<PartitionedAggregateLocalSinkState>();
-	if (!lstate.state) {
-		// the local state is not yet initialized for this partition
-		// initialize the partition
-		child_list_t<Value> partition_values;
-		for (idx_t partition_idx = 0; partition_idx < groups.size(); partition_idx++) {
-			auto column_name = to_string(partition_idx);
-			auto &partition = input.local_state.partition_info.partition_data[partition_idx];
-			D_ASSERT(Value::NotDistinctFrom(partition.min_val, partition.max_val));
-			partition_values.emplace_back(make_pair(std::move(column_name), partition.min_val));
-		}
-		lstate.current_partition = Value::STRUCT(std::move(partition_values));
-
-		// initialize the state
-		auto &global_aggregate_state = gstate.GetOrCreatePartition(context.client, lstate.current_partition);
-		lstate.state = make_uniq<LocalUngroupedAggregateState>(global_aggregate_state);
-	}
-
-	// perform the aggregation
-	lstate.execute_state.Sink(*lstate.state, chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Next Batch
-//===--------------------------------------------------------------------===//
-SinkNextBatchType PhysicalPartitionedAggregate::NextBatch(ExecutionContext &context,
-                                                          OperatorSinkNextBatchInput &input) const {
-	// flush the local state
-	auto &gstate = input.global_state.Cast<PartitionedAggregateGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<PartitionedAggregateLocalSinkState>();
-
-	// finalize and reset the current state (if any)
-	gstate.Combine(context.client, lstate);
-	return SinkNextBatchType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-SinkCombineResultType PhysicalPartitionedAggregate::Combine(ExecutionContext &context,
-                                                            OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<PartitionedAggregateGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<PartitionedAggregateLocalSinkState>();
-	gstate.Combine(context.client, lstate);
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalPartitionedAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                        OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<PartitionedAggregateGlobalSinkState>();
-	ColumnDataAppendState append_state;
-	gstate.aggregate_result.InitializeAppend(append_state);
-	// finalize each of the partitions and append to a ColumnDataCollection
-	DataChunk chunk;
-	chunk.Initialize(context, types);
-	for (auto &entry : gstate.aggregate_states) {
-		chunk.Reset();
-		// reference the partitions
-		auto &partitions = StructValue::GetChildren(entry.first);
-		for (idx_t partition_idx = 0; partition_idx < partitions.size(); partition_idx++) {
-			chunk.data[partition_idx].Reference(partitions[partition_idx]);
-		}
-		// finalize the aggregates
-		entry.second->Finalize(chunk, partitions.size());
-
-		// append to the CDC
-		gstate.aggregate_result.Append(append_state, chunk);
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PartitionedAggregateGlobalSourceState : public GlobalSourceState {
-public:
-	explicit PartitionedAggregateGlobalSourceState(PartitionedAggregateGlobalSinkState &gstate) {
-		gstate.aggregate_result.InitializeScan(scan_state);
-	}
-
-	ColumnDataScanState scan_state;
-
-	idx_t MaxThreads() override {
-		return 1;
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalPartitionedAggregate::GetGlobalSourceState(ClientContext &context) const {
-	auto &gstate = sink_state->Cast<PartitionedAggregateGlobalSinkState>();
-	return make_uniq<PartitionedAggregateGlobalSourceState>(gstate);
-}
-
-SourceResultType PhysicalPartitionedAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                       OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<PartitionedAggregateGlobalSinkState>();
-	auto &gsource = input.global_state.Cast<PartitionedAggregateGlobalSourceState>();
-	gstate.aggregate_result.Scan(gsource.scan_state, chunk);
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// ParamsToString
-//===--------------------------------------------------------------------===//
-InsertionOrderPreservingMap<string> PhysicalPartitionedAggregate::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string groups_info;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			groups_info += "\n";
-		}
-		groups_info += groups[i]->GetName();
-	}
-	result["Groups"] = groups_info;
-	string aggregate_info;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
-		if (i > 0) {
-			aggregate_info += "\n";
-		}
-		aggregate_info += aggregates[i]->GetName();
-		if (aggregate.filter) {
-			aggregate_info += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	result["Aggregates"] = aggregate_info;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp b/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp
deleted file mode 100644
index d00b6fd9e..000000000
--- a/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp"
-
-#include "duckdb/execution/perfect_aggregate_hashtable.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types_p,
-                                                           vector<unique_ptr<Expression>> aggregates_p,
-                                                           vector<unique_ptr<Expression>> groups_p,
-                                                           const vector<unique_ptr<BaseStatistics>> &group_stats,
-                                                           vector<idx_t> required_bits_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::PERFECT_HASH_GROUP_BY, std::move(types_p), estimated_cardinality),
-      groups(std::move(groups_p)), aggregates(std::move(aggregates_p)), required_bits(std::move(required_bits_p)) {
-	D_ASSERT(groups.size() == group_stats.size());
-	group_minima.reserve(group_stats.size());
-	for (auto &stats : group_stats) {
-		D_ASSERT(stats);
-		auto &nstats = *stats;
-		D_ASSERT(NumericStats::HasMin(nstats));
-		group_minima.push_back(NumericStats::Min(nstats));
-	}
-	for (auto &expr : groups) {
-		group_types.push_back(expr->return_type);
-	}
-
-	vector<BoundAggregateExpression *> bindings;
-	vector<LogicalType> payload_types_filters;
-	for (auto &expr : aggregates) {
-		D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-		D_ASSERT(expr->IsAggregate());
-		auto &aggr = expr->Cast<BoundAggregateExpression>();
-		bindings.push_back(&aggr);
-
-		D_ASSERT(!aggr.IsDistinct());
-		D_ASSERT(aggr.function.combine);
-		for (auto &child : aggr.children) {
-			payload_types.push_back(child->return_type);
-		}
-		if (aggr.filter) {
-			payload_types_filters.push_back(aggr.filter->return_type);
-		}
-	}
-	for (const auto &pay_filters : payload_types_filters) {
-		payload_types.push_back(pay_filters);
-	}
-	aggregate_objects = AggregateObject::CreateAggregateObjects(bindings);
-
-	// filter_indexes must be pre-built, not lazily instantiated in parallel...
-	idx_t aggregate_input_idx = 0;
-	for (auto &aggregate : aggregates) {
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		aggregate_input_idx += aggr.children.size();
-	}
-	for (auto &aggregate : aggregates) {
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		if (aggr.filter) {
-			auto &bound_ref_expr = aggr.filter->Cast<BoundReferenceExpression>();
-			auto it = filter_indexes.find(aggr.filter.get());
-			if (it == filter_indexes.end()) {
-				filter_indexes[aggr.filter.get()] = bound_ref_expr.index;
-				bound_ref_expr.index = aggregate_input_idx++;
-			} else {
-				++aggregate_input_idx;
-			}
-		}
-	}
-}
-
-unique_ptr<PerfectAggregateHashTable> PhysicalPerfectHashAggregate::CreateHT(Allocator &allocator,
-                                                                             ClientContext &context) const {
-	return make_uniq<PerfectAggregateHashTable>(context, allocator, group_types, payload_types, aggregate_objects,
-	                                            group_minima, required_bits);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class PerfectHashAggregateGlobalState : public GlobalSinkState {
-public:
-	PerfectHashAggregateGlobalState(const PhysicalPerfectHashAggregate &op, ClientContext &context)
-	    : ht(op.CreateHT(Allocator::Get(context), context)) {
-	}
-
-	//! The lock for updating the global aggregate state
-	mutex lock;
-	//! The global aggregate hash table
-	unique_ptr<PerfectAggregateHashTable> ht;
-};
-
-class PerfectHashAggregateLocalState : public LocalSinkState {
-public:
-	PerfectHashAggregateLocalState(const PhysicalPerfectHashAggregate &op, ExecutionContext &context)
-	    : ht(op.CreateHT(Allocator::Get(context.client), context.client)) {
-		group_chunk.InitializeEmpty(op.group_types);
-		if (!op.payload_types.empty()) {
-			aggregate_input_chunk.InitializeEmpty(op.payload_types);
-		}
-	}
-
-	//! The local aggregate hash table
-	unique_ptr<PerfectAggregateHashTable> ht;
-	DataChunk group_chunk;
-	DataChunk aggregate_input_chunk;
-};
-
-unique_ptr<GlobalSinkState> PhysicalPerfectHashAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<PerfectHashAggregateGlobalState>(*this, context);
-}
-
-unique_ptr<LocalSinkState> PhysicalPerfectHashAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<PerfectHashAggregateLocalState>(*this, context);
-}
-
-SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
-                                                  OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<PerfectHashAggregateLocalState>();
-	DataChunk &group_chunk = lstate.group_chunk;
-	DataChunk &aggregate_input_chunk = lstate.aggregate_input_chunk;
-
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		auto &group = groups[group_idx];
-		D_ASSERT(group->GetExpressionType() == ExpressionType::BOUND_REF);
-		auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
-		group_chunk.data[group_idx].Reference(chunk.data[bound_ref_expr.index]);
-	}
-	idx_t aggregate_input_idx = 0;
-	for (auto &aggregate : aggregates) {
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		for (auto &child_expr : aggr.children) {
-			D_ASSERT(child_expr->GetExpressionType() == ExpressionType::BOUND_REF);
-			auto &bound_ref_expr = child_expr->Cast<BoundReferenceExpression>();
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[bound_ref_expr.index]);
-		}
-	}
-	for (auto &aggregate : aggregates) {
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		if (aggr.filter) {
-			auto it = filter_indexes.find(aggr.filter.get());
-			D_ASSERT(it != filter_indexes.end());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[it->second]);
-		}
-	}
-
-	group_chunk.SetCardinality(chunk.size());
-
-	aggregate_input_chunk.SetCardinality(chunk.size());
-
-	group_chunk.Verify();
-	aggregate_input_chunk.Verify();
-	D_ASSERT(aggregate_input_chunk.ColumnCount() == 0 || group_chunk.size() == aggregate_input_chunk.size());
-
-	lstate.ht->AddChunk(group_chunk, aggregate_input_chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-SinkCombineResultType PhysicalPerfectHashAggregate::Combine(ExecutionContext &context,
-                                                            OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<PerfectHashAggregateLocalState>();
-	auto &gstate = input.global_state.Cast<PerfectHashAggregateGlobalState>();
-
-	lock_guard<mutex> l(gstate.lock);
-	gstate.ht->Combine(*lstate.ht);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PerfectHashAggregateState : public GlobalSourceState {
-public:
-	PerfectHashAggregateState() : ht_scan_position(0) {
-	}
-
-	//! The current position to scan the HT for output tuples
-	idx_t ht_scan_position;
-};
-
-unique_ptr<GlobalSourceState> PhysicalPerfectHashAggregate::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<PerfectHashAggregateState>();
-}
-
-SourceResultType PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                       OperatorSourceInput &input) const {
-	auto &state = input.global_state.Cast<PerfectHashAggregateState>();
-	auto &gstate = sink_state->Cast<PerfectHashAggregateGlobalState>();
-
-	gstate.ht->Scan(state.ht_scan_position, chunk);
-
-	if (chunk.size() > 0) {
-		return SourceResultType::HAVE_MORE_OUTPUT;
-	} else {
-		return SourceResultType::FINISHED;
-	}
-}
-
-InsertionOrderPreservingMap<string> PhysicalPerfectHashAggregate::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string groups_info;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			groups_info += "\n";
-		}
-		groups_info += groups[i]->GetName();
-	}
-	result["Groups"] = groups_info;
-
-	string aggregate_info;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		if (i > 0) {
-			aggregate_info += "\n";
-		}
-		aggregate_info += aggregates[i]->GetName();
-		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
-		if (aggregate.filter) {
-			aggregate_info += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	result["Aggregates"] = aggregate_info;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp b/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp
deleted file mode 100644
index 8d78e6653..000000000
--- a/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp
+++ /dev/null
@@ -1,647 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_streaming_window.hpp"
-
-#include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-PhysicalStreamingWindow::PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                                                 idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list)) {
-}
-
-class StreamingWindowGlobalState : public GlobalOperatorState {
-public:
-	StreamingWindowGlobalState() : row_number(1) {
-	}
-
-	//! The next row number.
-	std::atomic<int64_t> row_number;
-};
-
-class StreamingWindowState : public OperatorState {
-public:
-	struct AggregateState {
-		AggregateState(ClientContext &client, BoundWindowExpression &wexpr, Allocator &allocator)
-		    : wexpr(wexpr), arena_allocator(Allocator::DefaultAllocator()), executor(client), filter_executor(client),
-		      statev(LogicalType::POINTER, data_ptr_cast(&state_ptr)), hashes(LogicalType::HASH),
-		      addresses(LogicalType::POINTER) {
-			D_ASSERT(wexpr.GetExpressionType() == ExpressionType::WINDOW_AGGREGATE);
-			auto &aggregate = *wexpr.aggregate;
-			bind_data = wexpr.bind_info.get();
-			dtor = aggregate.destructor;
-			state.resize(aggregate.state_size(aggregate));
-			state_ptr = state.data();
-			aggregate.initialize(aggregate, state.data());
-			for (auto &child : wexpr.children) {
-				arg_types.push_back(child->return_type);
-				executor.AddExpression(*child);
-			}
-			if (!arg_types.empty()) {
-				arg_chunk.Initialize(allocator, arg_types);
-				arg_cursor.Initialize(allocator, arg_types);
-			}
-			if (wexpr.filter_expr) {
-				filter_executor.AddExpression(*wexpr.filter_expr);
-				filter_sel.Initialize();
-			}
-			if (wexpr.distinct) {
-				distinct = make_uniq<GroupedAggregateHashTable>(client, allocator, arg_types);
-				distinct_args.Initialize(allocator, arg_types);
-				distinct_sel.Initialize();
-			}
-		}
-
-		~AggregateState() {
-			if (dtor) {
-				AggregateInputData aggr_input_data(bind_data, arena_allocator);
-				state_ptr = state.data();
-				dtor(statev, aggr_input_data, 1);
-			}
-		}
-
-		void Execute(ExecutionContext &context, DataChunk &input, Vector &result);
-
-		//! The aggregate expression
-		BoundWindowExpression &wexpr;
-		//! The allocator to use for aggregate data structures
-		ArenaAllocator arena_allocator;
-		//! Reusable executor for the children
-		ExpressionExecutor executor;
-		//! Shared executor for FILTER clauses
-		ExpressionExecutor filter_executor;
-		//! The single aggregate state we update row-by-row
-		vector<data_t> state;
-		//! The pointer to the state stored in the state vector
-		data_ptr_t state_ptr = nullptr;
-		//! The state vector for the single state
-		Vector statev;
-		//! The aggregate binding data (if any)
-		FunctionData *bind_data = nullptr;
-		//! The aggregate state destructor (if any)
-		aggregate_destructor_t dtor = nullptr;
-		//! The inputs rows that pass the FILTER
-		SelectionVector filter_sel;
-		//! The number of unfiltered rows so far for COUNT(*)
-		int64_t unfiltered = 0;
-		//! Argument types
-		vector<LogicalType> arg_types;
-		//! Argument value buffer
-		DataChunk arg_chunk;
-		//! Argument cursor (a one element slice of arg_chunk)
-		DataChunk arg_cursor;
-
-		//! Hash table for accumulating the distinct values
-		unique_ptr<GroupedAggregateHashTable> distinct;
-		//! Filtered arguments for checking distinctness
-		DataChunk distinct_args;
-		//! Reusable hash vector
-		Vector hashes;
-		//! Rows that produced new distinct values
-		SelectionVector distinct_sel;
-		//! Pointers to groups in the hash table.
-		Vector addresses;
-	};
-
-	struct LeadLagState {
-		//	Fixed size
-		static constexpr idx_t MAX_BUFFER = 2048U;
-
-		static bool ComputeOffset(ClientContext &context, BoundWindowExpression &wexpr, int64_t &offset) {
-			offset = 1;
-			if (wexpr.offset_expr) {
-				if (wexpr.offset_expr->HasParameter() || !wexpr.offset_expr->IsFoldable()) {
-					return false;
-				}
-				auto offset_value = ExpressionExecutor::EvaluateScalar(context, *wexpr.offset_expr);
-				if (offset_value.IsNull()) {
-					return false;
-				}
-				Value bigint_value;
-				if (!offset_value.DefaultTryCastAs(LogicalType::BIGINT, bigint_value, nullptr, false)) {
-					return false;
-				}
-				offset = bigint_value.GetValue<int64_t>();
-			}
-
-			//	We can only support LEAD and LAG values within one standard vector
-			if (wexpr.GetExpressionType() == ExpressionType::WINDOW_LEAD) {
-				offset = -offset;
-			}
-			return idx_t(std::abs(offset)) < MAX_BUFFER;
-		}
-
-		static bool ComputeDefault(ClientContext &context, BoundWindowExpression &wexpr, Value &result) {
-			if (!wexpr.default_expr) {
-				result = Value(wexpr.return_type);
-				return true;
-			}
-
-			if (wexpr.default_expr && (wexpr.default_expr->HasParameter() || !wexpr.default_expr->IsFoldable())) {
-				return false;
-			}
-			auto dflt_value = ExpressionExecutor::EvaluateScalar(context, *wexpr.default_expr);
-			return dflt_value.DefaultTryCastAs(wexpr.return_type, result, nullptr, false);
-		}
-
-		LeadLagState(ClientContext &context, BoundWindowExpression &wexpr)
-		    : wexpr(wexpr), executor(context, *wexpr.children[0]), prev(wexpr.return_type), temp(wexpr.return_type) {
-			ComputeOffset(context, wexpr, offset);
-			ComputeDefault(context, wexpr, dflt);
-
-			curr_chunk.Initialize(context, {wexpr.return_type});
-
-			buffered = idx_t(std::abs(offset));
-			prev.Reference(dflt);
-			prev.Flatten(buffered);
-			temp.Initialize(false, buffered);
-		}
-
-		void Execute(ExecutionContext &context, DataChunk &input, DataChunk &delayed, Vector &result) {
-			if (offset >= 0) {
-				ExecuteLag(context, input, result);
-			} else {
-				ExecuteLead(context, input, delayed, result);
-			}
-		}
-
-		void ExecuteLag(ExecutionContext &context, DataChunk &input, Vector &result) {
-			D_ASSERT(offset >= 0);
-			auto &curr = curr_chunk.data[0];
-			curr_chunk.Reset();
-			executor.Execute(input, curr_chunk);
-			const idx_t count = input.size();
-			//	Copy prev[0, buffered] => result[0, buffered]
-			idx_t source_count = MinValue<idx_t>(buffered, count);
-			VectorOperations::Copy(prev, result, source_count, 0, 0);
-			// Special case when we have buffered enough values for the output
-			if (count < buffered) {
-				//	Shift down incomplete buffers
-				// 	Copy prev[buffered-count, buffered] => temp[0, count]
-				source_count = buffered - count;
-				FlatVector::Validity(temp).Reset();
-				VectorOperations::Copy(prev, temp, buffered, source_count, 0);
-
-				// 	Copy temp[0, count] => prev[0, count]
-				FlatVector::Validity(prev).Reset();
-				VectorOperations::Copy(temp, prev, count, 0, 0);
-				// 	Copy curr[0, buffered-count] => prev[count, buffered]
-				VectorOperations::Copy(curr, prev, source_count, 0, count);
-			} else {
-				//	Copy input values beyond what we have buffered
-				source_count = count - buffered;
-				//	Copy curr[0, count-buffered] => result[buffered, count]
-				VectorOperations::Copy(curr, result, source_count, 0, buffered);
-				// 	Copy curr[count-buffered, count] => prev[0, buffered]
-				FlatVector::Validity(prev).Reset();
-				VectorOperations::Copy(curr, prev, count, source_count, 0);
-			}
-		}
-
-		void ExecuteLead(ExecutionContext &context, DataChunk &input, DataChunk &delayed, Vector &result) {
-			//	We treat input || delayed as a logical unified buffer
-			D_ASSERT(offset < 0);
-			// Input has been set up with the number of rows we CAN produce.
-			const idx_t count = input.size();
-			auto &curr = curr_chunk.data[0];
-			// Copy unified[buffered:count] => result[pos:]
-			idx_t pos = 0;
-			idx_t unified_offset = buffered;
-			if (unified_offset < count) {
-				curr_chunk.Reset();
-				executor.Execute(input, curr_chunk);
-				VectorOperations::Copy(curr, result, count, unified_offset, pos);
-				pos += count - unified_offset;
-				unified_offset = count;
-			}
-			// Copy unified[unified_offset:] => result[pos:]
-			idx_t unified_count = count + delayed.size();
-			if (unified_offset < unified_count) {
-				curr_chunk.Reset();
-				executor.Execute(delayed, curr_chunk);
-				idx_t delayed_offset = unified_offset - count;
-				// Only copy as many values as we need
-				idx_t delayed_count = MinValue<idx_t>(delayed.size(), delayed_offset + (count - pos));
-				VectorOperations::Copy(curr, result, delayed_count, delayed_offset, pos);
-				pos += delayed_count - delayed_offset;
-			}
-			// Copy default[:count-pos] => result[pos:]
-			if (pos < count) {
-				const idx_t defaulted = count - pos;
-				VectorOperations::Copy(prev, result, defaulted, 0, pos);
-			}
-		}
-
-		//! The aggregate expression
-		BoundWindowExpression &wexpr;
-		//! Cache the executor to cut down on memory allocation
-		ExpressionExecutor executor;
-		//! The constant offset
-		int64_t offset;
-		//! The number of rows we have buffered
-		idx_t buffered;
-		//! The constant default value
-		Value dflt;
-		//! The current set of values
-		DataChunk curr_chunk;
-		//! The previous set of values
-		Vector prev;
-		//! The copy buffer
-		Vector temp;
-	};
-
-	explicit StreamingWindowState(ClientContext &client) : initialized(false), allocator(Allocator::Get(client)) {
-	}
-
-	~StreamingWindowState() override {
-	}
-
-	void Initialize(ClientContext &context, DataChunk &input, const vector<unique_ptr<Expression>> &expressions) {
-		const_vectors.resize(expressions.size());
-		aggregate_states.resize(expressions.size());
-		lead_lag_states.resize(expressions.size());
-
-		for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
-			auto &expr = *expressions[expr_idx];
-			auto &wexpr = expr.Cast<BoundWindowExpression>();
-			switch (expr.GetExpressionType()) {
-			case ExpressionType::WINDOW_AGGREGATE:
-				aggregate_states[expr_idx] = make_uniq<AggregateState>(context, wexpr, allocator);
-				break;
-			case ExpressionType::WINDOW_FIRST_VALUE: {
-				// Just execute the expression once
-				ExpressionExecutor executor(context);
-				executor.AddExpression(*wexpr.children[0]);
-				DataChunk result;
-				result.Initialize(Allocator::Get(context), {wexpr.children[0]->return_type});
-				executor.Execute(input, result);
-
-				const_vectors[expr_idx] = make_uniq<Vector>(result.GetValue(0, 0));
-				break;
-			}
-			case ExpressionType::WINDOW_PERCENT_RANK: {
-				const_vectors[expr_idx] = make_uniq<Vector>(Value((double)0));
-				break;
-			}
-			case ExpressionType::WINDOW_RANK:
-			case ExpressionType::WINDOW_RANK_DENSE: {
-				const_vectors[expr_idx] = make_uniq<Vector>(Value((int64_t)1));
-				break;
-			}
-			case ExpressionType::WINDOW_LAG:
-			case ExpressionType::WINDOW_LEAD: {
-				lead_lag_states[expr_idx] = make_uniq<LeadLagState>(context, wexpr);
-				const auto offset = lead_lag_states[expr_idx]->offset;
-				if (offset < 0) {
-					lead_count = MaxValue<idx_t>(idx_t(-offset), lead_count);
-				}
-				break;
-			}
-			default:
-				break;
-			}
-		}
-		if (lead_count) {
-			delayed.Initialize(context, input.GetTypes(), lead_count + STANDARD_VECTOR_SIZE);
-			shifted.Initialize(context, input.GetTypes(), lead_count + STANDARD_VECTOR_SIZE);
-		}
-		initialized = true;
-	}
-
-public:
-	//! We can't initialise until we have an input chunk
-	bool initialized;
-	//! The values that are determined by the first row.
-	vector<unique_ptr<Vector>> const_vectors;
-	//! Aggregation states
-	vector<unique_ptr<AggregateState>> aggregate_states;
-	Allocator &allocator;
-	//! Lead/Lag states
-	vector<unique_ptr<LeadLagState>> lead_lag_states;
-	//! The number of rows ahead to buffer for LEAD
-	idx_t lead_count = 0;
-	//! A buffer for delayed input
-	DataChunk delayed;
-	//! A buffer for shifting delayed input
-	DataChunk shifted;
-};
-
-bool PhysicalStreamingWindow::IsStreamingFunction(ClientContext &context, unique_ptr<Expression> &expr) {
-	auto &wexpr = expr->Cast<BoundWindowExpression>();
-	if (!wexpr.partitions.empty() || !wexpr.orders.empty() || wexpr.ignore_nulls || !wexpr.arg_orders.empty() ||
-	    wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) {
-		return false;
-	}
-	switch (wexpr.GetExpressionType()) {
-	// TODO: add more expression types here?
-	case ExpressionType::WINDOW_AGGREGATE:
-		// We can stream aggregates if they are "running totals"
-		return wexpr.start == WindowBoundary::UNBOUNDED_PRECEDING && wexpr.end == WindowBoundary::CURRENT_ROW_ROWS;
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		return true;
-	case ExpressionType::WINDOW_LAG:
-	case ExpressionType::WINDOW_LEAD: {
-		// We can stream LEAD/LAG if the arguments are constant and the delta is less than a block behind
-		Value dflt;
-		int64_t offset;
-		return StreamingWindowState::LeadLagState::ComputeDefault(context, wexpr, dflt) &&
-		       StreamingWindowState::LeadLagState::ComputeOffset(context, wexpr, offset);
-	}
-	default:
-		return false;
-	}
-}
-
-unique_ptr<GlobalOperatorState> PhysicalStreamingWindow::GetGlobalOperatorState(ClientContext &context) const {
-	return make_uniq<StreamingWindowGlobalState>();
-}
-
-unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<StreamingWindowState>(context.client);
-}
-
-void StreamingWindowState::AggregateState::Execute(ExecutionContext &context, DataChunk &input, Vector &result) {
-	//	Establish the aggregation environment
-	const idx_t count = input.size();
-	auto &aggregate = *wexpr.aggregate;
-	auto &aggr_state = *this;
-	auto &statev = aggr_state.statev;
-
-	// Compute the FILTER mask (if any)
-	ValidityMask filter_mask;
-	auto filtered = count;
-	auto &filter_sel = aggr_state.filter_sel;
-	if (wexpr.filter_expr) {
-		filtered = filter_executor.SelectExpression(input, filter_sel);
-		if (filtered < count) {
-			filter_mask.Initialize(count);
-			filter_mask.SetAllInvalid(count);
-			for (idx_t f = 0; f < filtered; ++f) {
-				filter_mask.SetValid(filter_sel.get_index(f));
-			}
-		}
-	}
-
-	// Check for COUNT(*)
-	if (wexpr.children.empty()) {
-		D_ASSERT(GetTypeIdSize(result.GetType().InternalType()) == sizeof(int64_t));
-		auto data = FlatVector::GetData<int64_t>(result);
-		auto &unfiltered = aggr_state.unfiltered;
-		for (idx_t i = 0; i < count; ++i) {
-			unfiltered += int64_t(filter_mask.RowIsValid(i));
-			data[i] = unfiltered;
-		}
-		return;
-	}
-
-	// Compute the arguments
-	auto &arg_chunk = aggr_state.arg_chunk;
-	executor.Execute(input, arg_chunk);
-	arg_chunk.Flatten();
-
-	// Update the distinct hash table
-	ValidityMask distinct_mask;
-	if (aggr_state.distinct) {
-		auto &distinct_args = aggr_state.distinct_args;
-		distinct_args.Reference(arg_chunk);
-		if (wexpr.filter_expr) {
-			distinct_args.Slice(filter_sel, filtered);
-		}
-		idx_t distinct = 0;
-		auto &distinct_sel = aggr_state.distinct_sel;
-		if (filtered) {
-			// FindOrCreateGroups assumes non-empty input
-			auto &hashes = aggr_state.hashes;
-			distinct_args.Hash(hashes);
-
-			auto &addresses = aggr_state.addresses;
-			distinct = aggr_state.distinct->FindOrCreateGroups(distinct_args, hashes, addresses, distinct_sel);
-		}
-
-		//	Translate the distinct selection from filtered row numbers
-		//	back to input row numbers. We need to produce output for all input rows,
-		//	so we filter out
-		if (distinct < filtered) {
-			distinct_mask.Initialize(count);
-			distinct_mask.SetAllInvalid(count);
-			for (idx_t d = 0; d < distinct; ++d) {
-				const auto f = distinct_sel.get_index(d);
-				distinct_mask.SetValid(filter_sel.get_index(f));
-			}
-		}
-	}
-
-	// Iterate through them using a single SV
-	sel_t s = 0;
-	SelectionVector sel(&s);
-	auto &arg_cursor = aggr_state.arg_cursor;
-	arg_cursor.Reset();
-	arg_cursor.Slice(sel, 1);
-	// This doesn't work for STRUCTs because the SV
-	// is not copied to the children when you slice
-	vector<column_t> structs;
-	for (column_t col_idx = 0; col_idx < arg_chunk.ColumnCount(); ++col_idx) {
-		auto &col_vec = arg_cursor.data[col_idx];
-		DictionaryVector::Child(col_vec).Reference(arg_chunk.data[col_idx]);
-		if (col_vec.GetType().InternalType() == PhysicalType::STRUCT) {
-			structs.emplace_back(col_idx);
-		}
-	}
-
-	// Update the state and finalize it one row at a time.
-	AggregateInputData aggr_input_data(wexpr.bind_info.get(), aggr_state.arena_allocator);
-	for (idx_t i = 0; i < count; ++i) {
-		sel.set_index(0, i);
-		for (const auto struct_idx : structs) {
-			arg_cursor.data[struct_idx].Slice(arg_chunk.data[struct_idx], sel, 1);
-		}
-		if (filter_mask.RowIsValid(i) && distinct_mask.RowIsValid(i)) {
-			aggregate.update(arg_cursor.data.data(), aggr_input_data, arg_cursor.ColumnCount(), statev, 1);
-		}
-		aggregate.finalize(statev, aggr_input_data, result, 1, i);
-	}
-}
-
-void PhysicalStreamingWindow::ExecuteFunctions(ExecutionContext &context, DataChunk &chunk, DataChunk &delayed,
-                                               GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = gstate_p.Cast<StreamingWindowGlobalState>();
-	auto &state = state_p.Cast<StreamingWindowState>();
-
-	// Compute window functions
-	const idx_t count = chunk.size();
-	const column_t input_width = children[0]->GetTypes().size();
-	for (column_t expr_idx = 0; expr_idx < select_list.size(); expr_idx++) {
-		column_t col_idx = input_width + expr_idx;
-		auto &expr = *select_list[expr_idx];
-		auto &result = chunk.data[col_idx];
-		switch (expr.GetExpressionType()) {
-		case ExpressionType::WINDOW_AGGREGATE:
-			state.aggregate_states[expr_idx]->Execute(context, chunk, result);
-			break;
-		case ExpressionType::WINDOW_FIRST_VALUE:
-		case ExpressionType::WINDOW_PERCENT_RANK:
-		case ExpressionType::WINDOW_RANK:
-		case ExpressionType::WINDOW_RANK_DENSE: {
-			// Reference constant vector
-			chunk.data[col_idx].Reference(*state.const_vectors[expr_idx]);
-			break;
-		}
-		case ExpressionType::WINDOW_ROW_NUMBER: {
-			// Set row numbers
-			int64_t start_row = gstate.row_number;
-			auto rdata = FlatVector::GetData<int64_t>(chunk.data[col_idx]);
-			for (idx_t i = 0; i < count; i++) {
-				rdata[i] = NumericCast<int64_t>(start_row + NumericCast<int64_t>(i));
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_LAG:
-		case ExpressionType::WINDOW_LEAD:
-			state.lead_lag_states[expr_idx]->Execute(context, chunk, delayed, result);
-			break;
-		default:
-			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
-		}
-	}
-	gstate.row_number += NumericCast<int64_t>(count);
-}
-
-void PhysicalStreamingWindow::ExecuteInput(ExecutionContext &context, DataChunk &delayed, DataChunk &input,
-                                           DataChunk &chunk, GlobalOperatorState &gstate_p,
-                                           OperatorState &state_p) const {
-	auto &state = state_p.Cast<StreamingWindowState>();
-
-	// Put payload columns in place
-	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
-		chunk.data[col_idx].Reference(input.data[col_idx]);
-	}
-	idx_t count = input.size();
-
-	//	Handle LEAD
-	if (state.lead_count > 0) {
-		//	Nothing delayed yet, so just truncate and copy the delayed values
-		count -= state.lead_count;
-		input.Copy(delayed, count);
-	}
-	chunk.SetCardinality(count);
-
-	ExecuteFunctions(context, chunk, state.delayed, gstate_p, state_p);
-}
-
-void PhysicalStreamingWindow::ExecuteShifted(ExecutionContext &context, DataChunk &delayed, DataChunk &input,
-                                             DataChunk &chunk, GlobalOperatorState &gstate_p,
-                                             OperatorState &state_p) const {
-	auto &state = state_p.Cast<StreamingWindowState>();
-	auto &shifted = state.shifted;
-
-	idx_t i = input.size();
-	idx_t d = delayed.size();
-	shifted.Reset();
-	// shifted = delayed
-	delayed.Copy(shifted);
-	delayed.Reset();
-	for (idx_t col_idx = 0; col_idx < delayed.data.size(); ++col_idx) {
-		// chunk[0:i] = shifted[0:i]
-		chunk.data[col_idx].Reference(shifted.data[col_idx]);
-		// delayed[0:i] = chunk[i:d-i]
-		VectorOperations::Copy(shifted.data[col_idx], delayed.data[col_idx], d, i, 0);
-		// delayed[d-i:d] = input[0:i]
-		VectorOperations::Copy(input.data[col_idx], delayed.data[col_idx], i, 0, d - i);
-	}
-	chunk.SetCardinality(i);
-	delayed.SetCardinality(d);
-
-	ExecuteFunctions(context, chunk, delayed, gstate_p, state_p);
-}
-
-void PhysicalStreamingWindow::ExecuteDelayed(ExecutionContext &context, DataChunk &delayed, DataChunk &input,
-                                             DataChunk &chunk, GlobalOperatorState &gstate_p,
-                                             OperatorState &state_p) const {
-	// Put payload columns in place
-	for (idx_t col_idx = 0; col_idx < delayed.data.size(); col_idx++) {
-		chunk.data[col_idx].Reference(delayed.data[col_idx]);
-	}
-	idx_t count = delayed.size();
-	chunk.SetCardinality(count);
-
-	ExecuteFunctions(context, chunk, input, gstate_p, state_p);
-}
-
-OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &state = state_p.Cast<StreamingWindowState>();
-	if (!state.initialized) {
-		state.Initialize(context.client, input, select_list);
-	}
-
-	auto &delayed = state.delayed;
-	// We can Reset delayed now that no one can be referencing it.
-	if (!delayed.size()) {
-		delayed.Reset();
-	}
-	const idx_t available = delayed.size() + input.size();
-	if (available <= state.lead_count) {
-		//	If we don't have enough to produce a single row,
-		//	then just delay more rows, return nothing
-		//	and ask for more data.
-		delayed.Append(input);
-		chunk.SetCardinality(0);
-		return OperatorResultType::NEED_MORE_INPUT;
-	} else if (input.size() < delayed.size()) {
-		// If we can't consume all of the delayed values,
-		// we need to split them instead of referencing them all
-		ExecuteShifted(context, delayed, input, chunk, gstate_p, state_p);
-		// We delayed the unused input so ask for more
-		return OperatorResultType::NEED_MORE_INPUT;
-	} else if (delayed.size()) {
-		//	We have enough delayed rows so flush them
-		ExecuteDelayed(context, delayed, input, chunk, gstate_p, state_p);
-		// Defer resetting delayed as it may be referenced.
-		delayed.SetCardinality(0);
-		// Come back to process the input
-		return OperatorResultType::HAVE_MORE_OUTPUT;
-	} else {
-		//	No delayed rows, so emit what we can and delay the rest.
-		ExecuteInput(context, delayed, input, chunk, gstate_p, state_p);
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-}
-
-OperatorFinalizeResultType PhysicalStreamingWindow::FinalExecute(ExecutionContext &context, DataChunk &chunk,
-                                                                 GlobalOperatorState &gstate_p,
-                                                                 OperatorState &state_p) const {
-	auto &state = state_p.Cast<StreamingWindowState>();
-
-	if (state.initialized && state.lead_count) {
-		auto &delayed = state.delayed;
-		//	There are no more input rows
-		auto &input = state.shifted;
-		input.Reset();
-		ExecuteDelayed(context, delayed, input, chunk, gstate_p, state_p);
-	}
-
-	return OperatorFinalizeResultType::FINISHED;
-}
-
-InsertionOrderPreservingMap<string> PhysicalStreamingWindow::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string projections;
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			projections += "\n";
-		}
-		projections += select_list[i]->GetName();
-	}
-	result["Projections"] = projections;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp b/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp
deleted file mode 100644
index 0ec4bd2a3..000000000
--- a/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp
+++ /dev/null
@@ -1,675 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
-#include "duckdb/execution/radix_partitioned_hashtable.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-PhysicalUngroupedAggregate::PhysicalUngroupedAggregate(vector<LogicalType> types,
-                                                       vector<unique_ptr<Expression>> expressions,
-                                                       idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::UNGROUPED_AGGREGATE, std::move(types), estimated_cardinality),
-      aggregates(std::move(expressions)) {
-
-	distinct_collection_info = DistinctAggregateCollectionInfo::Create(aggregates);
-	if (!distinct_collection_info) {
-		return;
-	}
-	distinct_data = make_uniq<DistinctAggregateData>(*distinct_collection_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Ungrouped Aggregate State
-//===--------------------------------------------------------------------===//
-UngroupedAggregateState::UngroupedAggregateState(const vector<unique_ptr<Expression>> &aggregate_expressions)
-    : aggregate_expressions(aggregate_expressions) {
-	counts = make_uniq_array<atomic<idx_t>>(aggregate_expressions.size());
-	for (idx_t i = 0; i < aggregate_expressions.size(); i++) {
-		auto &aggregate = aggregate_expressions[i];
-		D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		auto state = make_unsafe_uniq_array_uninitialized<data_t>(aggr.function.state_size(aggr.function));
-		aggr.function.initialize(aggr.function, state.get());
-		aggregate_data.push_back(std::move(state));
-		bind_data.push_back(aggr.bind_info.get());
-		destructors.push_back(aggr.function.destructor);
-#ifdef DEBUG
-		counts[i] = 0;
-#endif
-	}
-}
-UngroupedAggregateState::~UngroupedAggregateState() {
-	D_ASSERT(destructors.size() == aggregate_data.size());
-	for (idx_t i = 0; i < destructors.size(); i++) {
-		if (!destructors[i]) {
-			continue;
-		}
-		Vector state_vector(Value::POINTER(CastPointerToValue(aggregate_data[i].get())));
-		state_vector.SetVectorType(VectorType::FLAT_VECTOR);
-
-		ArenaAllocator allocator(Allocator::DefaultAllocator());
-		AggregateInputData aggr_input_data(bind_data[i], allocator);
-		destructors[i](state_vector, aggr_input_data, 1);
-	}
-}
-
-void UngroupedAggregateState::Move(UngroupedAggregateState &other) {
-	other.aggregate_data = std::move(aggregate_data);
-	other.destructors = std::move(destructors);
-}
-
-//===--------------------------------------------------------------------===//
-// Global State
-//===--------------------------------------------------------------------===//
-class UngroupedAggregateGlobalSinkState : public GlobalSinkState {
-public:
-	UngroupedAggregateGlobalSinkState(const PhysicalUngroupedAggregate &op, ClientContext &client)
-	    : state(BufferAllocator::Get(client), op.aggregates), finished(false) {
-		if (op.distinct_data) {
-			distinct_state = make_uniq<DistinctAggregateState>(*op.distinct_data, client);
-		}
-	}
-
-	//! The global aggregate state
-	GlobalUngroupedAggregateState state;
-	//! Whether or not the aggregate is finished
-	bool finished;
-	//! The data related to the distinct aggregates (if there are any)
-	unique_ptr<DistinctAggregateState> distinct_state;
-};
-
-ArenaAllocator &GlobalUngroupedAggregateState::CreateAllocator() const {
-	lock_guard<mutex> glock(lock);
-	stored_allocators.emplace_back(make_uniq<ArenaAllocator>(client_allocator));
-	return *stored_allocators.back();
-}
-
-void GlobalUngroupedAggregateState::Combine(LocalUngroupedAggregateState &other) {
-	lock_guard<mutex> glock(lock);
-	for (idx_t aggr_idx = 0; aggr_idx < state.aggregate_expressions.size(); aggr_idx++) {
-		auto &aggregate = state.aggregate_expressions[aggr_idx]->Cast<BoundAggregateExpression>();
-
-		if (aggregate.IsDistinct()) {
-			continue;
-		}
-
-		Vector source_state(Value::POINTER(CastPointerToValue(other.state.aggregate_data[aggr_idx].get())));
-		Vector dest_state(Value::POINTER(CastPointerToValue(state.aggregate_data[aggr_idx].get())));
-
-		AggregateInputData aggr_input_data(aggregate.bind_info.get(), allocator,
-		                                   AggregateCombineType::ALLOW_DESTRUCTIVE);
-		aggregate.function.combine(source_state, dest_state, aggr_input_data, 1);
-#ifdef DEBUG
-		state.counts[aggr_idx] += other.state.counts[aggr_idx];
-#endif
-	}
-}
-
-void GlobalUngroupedAggregateState::CombineDistinct(LocalUngroupedAggregateState &other,
-                                                    DistinctAggregateData &distinct_data) {
-	lock_guard<mutex> glock(lock);
-	for (idx_t aggr_idx = 0; aggr_idx < state.aggregate_expressions.size(); aggr_idx++) {
-		if (!distinct_data.IsDistinct(aggr_idx)) {
-			continue;
-		}
-
-		auto &aggregate = state.aggregate_expressions[aggr_idx]->Cast<BoundAggregateExpression>();
-		AggregateInputData aggr_input_data(aggregate.bind_info.get(), allocator,
-		                                   AggregateCombineType::ALLOW_DESTRUCTIVE);
-
-		Vector state_vec(Value::POINTER(CastPointerToValue(other.state.aggregate_data[aggr_idx].get())));
-		Vector combined_vec(Value::POINTER(CastPointerToValue(state.aggregate_data[aggr_idx].get())));
-		aggregate.function.combine(state_vec, combined_vec, aggr_input_data, 1);
-#ifdef DEBUG
-		state.counts[aggr_idx] += other.state.counts[aggr_idx];
-#endif
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Ungrouped Aggregate Execute State
-//===--------------------------------------------------------------------===//
-UngroupedAggregateExecuteState::UngroupedAggregateExecuteState(ClientContext &context,
-                                                               const vector<unique_ptr<Expression>> &aggregates,
-                                                               const vector<LogicalType> &child_types)
-    : aggregates(aggregates), child_executor(context), aggregate_input_chunk(), filter_set() {
-	vector<LogicalType> payload_types;
-	vector<AggregateObject> aggregate_objects;
-	auto &allocator = BufferAllocator::Get(context);
-	for (auto &aggregate : aggregates) {
-		D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-		// initialize the payload chunk
-		for (auto &child : aggr.children) {
-			payload_types.push_back(child->return_type);
-			child_executor.AddExpression(*child);
-		}
-		aggregate_objects.emplace_back(&aggr);
-	}
-	if (!payload_types.empty()) { // for select count(*) from t; there is no payload at all
-		aggregate_input_chunk.Initialize(allocator, payload_types);
-	}
-	filter_set.Initialize(context, aggregate_objects, child_types);
-}
-
-void UngroupedAggregateExecuteState::Reset() {
-	aggregate_input_chunk.Reset();
-}
-
-void UngroupedAggregateExecuteState::Sink(LocalUngroupedAggregateState &state, DataChunk &input) {
-	DataChunk &payload_chunk = aggregate_input_chunk;
-
-	idx_t payload_idx = 0;
-	idx_t next_payload_idx = 0;
-
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
-
-		payload_idx = next_payload_idx;
-		next_payload_idx = payload_idx + aggregate.children.size();
-
-		if (aggregate.IsDistinct()) {
-			continue;
-		}
-
-		idx_t payload_cnt = 0;
-		// resolve the filter (if any)
-		if (aggregate.filter) {
-			auto &filtered_data = filter_set.GetFilterData(aggr_idx);
-			auto count = filtered_data.ApplyFilter(input);
-
-			child_executor.SetChunk(filtered_data.filtered_payload);
-			payload_chunk.SetCardinality(count);
-		} else {
-			child_executor.SetChunk(input);
-			payload_chunk.SetCardinality(input);
-		}
-
-		// resolve the child expressions of the aggregate (if any)
-		for (idx_t i = 0; i < aggregate.children.size(); ++i) {
-			child_executor.ExecuteExpression(payload_idx + payload_cnt, payload_chunk.data[payload_idx + payload_cnt]);
-			payload_cnt++;
-		}
-
-		state.Sink(payload_chunk, payload_idx, aggr_idx);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Local State
-//===--------------------------------------------------------------------===//
-LocalUngroupedAggregateState::LocalUngroupedAggregateState(GlobalUngroupedAggregateState &gstate)
-    : allocator(gstate.CreateAllocator()), state(gstate.state.aggregate_expressions) {
-}
-
-class UngroupedAggregateLocalSinkState : public LocalSinkState {
-public:
-	UngroupedAggregateLocalSinkState(const PhysicalUngroupedAggregate &op, const vector<LogicalType> &child_types,
-	                                 UngroupedAggregateGlobalSinkState &gstate_p, ExecutionContext &context)
-	    : state(gstate_p.state), execute_state(context.client, op.aggregates, child_types) {
-		auto &gstate = gstate_p.Cast<UngroupedAggregateGlobalSinkState>();
-		InitializeDistinctAggregates(op, gstate, context);
-	}
-
-	//! The local aggregate state
-	LocalUngroupedAggregateState state;
-	//! The ungrouped aggregate execute state
-	UngroupedAggregateExecuteState execute_state;
-	//! The local sink states of the distinct aggregates hash tables
-	vector<unique_ptr<LocalSinkState>> radix_states;
-
-public:
-	void InitializeDistinctAggregates(const PhysicalUngroupedAggregate &op,
-	                                  const UngroupedAggregateGlobalSinkState &gstate, ExecutionContext &context) {
-
-		if (!op.distinct_data) {
-			return;
-		}
-		auto &data = *op.distinct_data;
-		auto &state = *gstate.distinct_state;
-		D_ASSERT(!data.radix_tables.empty());
-
-		const idx_t aggregate_count = state.radix_states.size();
-		radix_states.resize(aggregate_count);
-
-		auto &distinct_info = *op.distinct_collection_info;
-
-		for (auto &idx : distinct_info.indices) {
-			idx_t table_idx = distinct_info.table_map[idx];
-			if (data.radix_tables[table_idx] == nullptr) {
-				// This aggregate has identical input as another aggregate, so no table is created for it
-				continue;
-			}
-			auto &radix_table = *data.radix_tables[table_idx];
-			radix_states[table_idx] = radix_table.GetLocalSinkState(context);
-		}
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-bool PhysicalUngroupedAggregate::SinkOrderDependent() const {
-	for (auto &expr : aggregates) {
-		auto &aggr = expr->Cast<BoundAggregateExpression>();
-		if (aggr.function.order_dependent == AggregateOrderDependent::ORDER_DEPENDENT) {
-			return true;
-		}
-	}
-	return false;
-}
-
-unique_ptr<GlobalSinkState> PhysicalUngroupedAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<UngroupedAggregateGlobalSinkState>(*this, context);
-}
-
-unique_ptr<LocalSinkState> PhysicalUngroupedAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	D_ASSERT(sink_state);
-	auto &gstate = sink_state->Cast<UngroupedAggregateGlobalSinkState>();
-	return make_uniq<UngroupedAggregateLocalSinkState>(*this, children[0]->GetTypes(), gstate, context);
-}
-
-void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSinkInput &input) const {
-	auto &sink = input.local_state.Cast<UngroupedAggregateLocalSinkState>();
-	auto &global_sink = input.global_state.Cast<UngroupedAggregateGlobalSinkState>();
-	D_ASSERT(distinct_data);
-	auto &distinct_state = *global_sink.distinct_state;
-	auto &distinct_info = *distinct_collection_info;
-	auto &distinct_indices = distinct_info.Indices();
-
-	DataChunk empty_chunk;
-
-	auto &distinct_filter = distinct_info.Indices();
-
-	for (auto &idx : distinct_indices) {
-		auto &aggregate = aggregates[idx]->Cast<BoundAggregateExpression>();
-
-		idx_t table_idx = distinct_info.table_map[idx];
-		if (!distinct_data->radix_tables[table_idx]) {
-			// This distinct aggregate shares its data with another
-			continue;
-		}
-		D_ASSERT(distinct_data->radix_tables[table_idx]);
-		auto &radix_table = *distinct_data->radix_tables[table_idx];
-		auto &radix_global_sink = *distinct_state.radix_states[table_idx];
-		auto &radix_local_sink = *sink.radix_states[table_idx];
-		OperatorSinkInput sink_input {radix_global_sink, radix_local_sink, input.interrupt_state};
-
-		if (aggregate.filter) {
-			// The hashtable can apply a filter, but only on the payload
-			// And in our case, we need to filter the groups (the distinct aggr children)
-
-			// Apply the filter before inserting into the hashtable
-			auto &filtered_data = sink.execute_state.filter_set.GetFilterData(idx);
-			idx_t count = filtered_data.ApplyFilter(chunk);
-			filtered_data.filtered_payload.SetCardinality(count);
-
-			radix_table.Sink(context, filtered_data.filtered_payload, sink_input, empty_chunk, distinct_filter);
-		} else {
-			radix_table.Sink(context, chunk, sink_input, empty_chunk, distinct_filter);
-		}
-	}
-}
-
-SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
-                                                OperatorSinkInput &input) const {
-	auto &sink = input.local_state.Cast<UngroupedAggregateLocalSinkState>();
-
-	// perform the aggregation inside the local state
-	sink.execute_state.Reset();
-
-	if (distinct_data) {
-		SinkDistinct(context, chunk, input);
-	}
-
-	sink.execute_state.Sink(sink.state, chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void LocalUngroupedAggregateState::Sink(DataChunk &payload_chunk, idx_t payload_idx, idx_t aggr_idx) {
-#ifdef DEBUG
-	state.counts[aggr_idx] += payload_chunk.size();
-#endif
-	auto &aggregate = state.aggregate_expressions[aggr_idx]->Cast<BoundAggregateExpression>();
-	idx_t payload_cnt = aggregate.children.size();
-	D_ASSERT(payload_idx + payload_cnt <= payload_chunk.data.size());
-	auto start_of_input = payload_cnt == 0 ? nullptr : &payload_chunk.data[payload_idx];
-	AggregateInputData aggr_input_data(state.bind_data[aggr_idx], allocator);
-	aggregate.function.simple_update(start_of_input, aggr_input_data, payload_cnt, state.aggregate_data[aggr_idx].get(),
-	                                 payload_chunk.size());
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-void PhysicalUngroupedAggregate::CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<UngroupedAggregateGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<UngroupedAggregateLocalSinkState>();
-
-	if (!distinct_data) {
-		return;
-	}
-	auto &distinct_state = gstate.distinct_state;
-	auto table_count = distinct_data->radix_tables.size();
-	for (idx_t table_idx = 0; table_idx < table_count; table_idx++) {
-		D_ASSERT(distinct_data->radix_tables[table_idx]);
-		auto &radix_table = *distinct_data->radix_tables[table_idx];
-		auto &radix_global_sink = *distinct_state->radix_states[table_idx];
-		auto &radix_local_sink = *lstate.radix_states[table_idx];
-
-		radix_table.Combine(context, radix_global_sink, radix_local_sink);
-	}
-}
-
-SinkCombineResultType PhysicalUngroupedAggregate::Combine(ExecutionContext &context,
-                                                          OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<UngroupedAggregateGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<UngroupedAggregateLocalSinkState>();
-	D_ASSERT(!gstate.finished);
-
-	// finalize: combine the local state into the global state
-	// all aggregates are combinable: we might be doing a parallel aggregate
-	// use the combine method to combine the partial aggregates
-	OperatorSinkCombineInput distinct_input {gstate, lstate, input.interrupt_state};
-	CombineDistinct(context, distinct_input);
-
-	gstate.state.Combine(lstate.state);
-
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-class UngroupedDistinctAggregateFinalizeEvent : public BasePipelineEvent {
-public:
-	UngroupedDistinctAggregateFinalizeEvent(ClientContext &context, const PhysicalUngroupedAggregate &op_p,
-	                                        UngroupedAggregateGlobalSinkState &gstate_p, Pipeline &pipeline_p)
-	    : BasePipelineEvent(pipeline_p), context(context), op(op_p), gstate(gstate_p), tasks_scheduled(0),
-	      tasks_done(0) {
-	}
-
-public:
-	void Schedule() override;
-	void FinalizeTask() {
-		lock_guard<mutex> finalize(lock);
-		D_ASSERT(!gstate.finished);
-		D_ASSERT(tasks_done < tasks_scheduled);
-		if (++tasks_done == tasks_scheduled) {
-			gstate.finished = true;
-		}
-	}
-
-private:
-	ClientContext &context;
-
-	const PhysicalUngroupedAggregate &op;
-	UngroupedAggregateGlobalSinkState &gstate;
-
-	mutex lock;
-	idx_t tasks_scheduled;
-	idx_t tasks_done;
-
-public:
-	vector<unique_ptr<GlobalSourceState>> global_source_states;
-};
-
-class UngroupedDistinctAggregateFinalizeTask : public ExecutorTask {
-public:
-	UngroupedDistinctAggregateFinalizeTask(Executor &executor, shared_ptr<Event> event_p,
-	                                       const PhysicalUngroupedAggregate &op,
-	                                       UngroupedAggregateGlobalSinkState &state_p)
-	    : ExecutorTask(executor, std::move(event_p)), op(op), gstate(state_p), aggregate_state(gstate.state) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
-
-private:
-	TaskExecutionResult AggregateDistinct();
-
-private:
-	const PhysicalUngroupedAggregate &op;
-	UngroupedAggregateGlobalSinkState &gstate;
-
-	// Distinct aggregation state
-	LocalUngroupedAggregateState aggregate_state;
-	idx_t aggregation_idx = 0;
-	unique_ptr<LocalSourceState> radix_table_lstate;
-	bool blocked = false;
-};
-
-void UngroupedDistinctAggregateFinalizeEvent::Schedule() {
-	D_ASSERT(gstate.distinct_state);
-	auto &aggregates = op.aggregates;
-	auto &distinct_data = *op.distinct_data;
-
-	idx_t n_tasks = 0;
-	idx_t payload_idx = 0;
-	idx_t next_payload_idx = 0;
-	for (idx_t agg_idx = 0; agg_idx < aggregates.size(); agg_idx++) {
-		auto &aggregate = aggregates[agg_idx]->Cast<BoundAggregateExpression>();
-
-		// Forward the payload idx
-		payload_idx = next_payload_idx;
-		next_payload_idx = payload_idx + aggregate.children.size();
-
-		// If aggregate is not distinct, skip it
-		if (!distinct_data.IsDistinct(agg_idx)) {
-			global_source_states.push_back(nullptr);
-			continue;
-		}
-		D_ASSERT(distinct_data.info.table_map.count(agg_idx));
-
-		// Create global state for scanning
-		auto table_idx = distinct_data.info.table_map.at(agg_idx);
-		auto &radix_table_p = *distinct_data.radix_tables[table_idx];
-		n_tasks += radix_table_p.MaxThreads(*gstate.distinct_state->radix_states[table_idx]);
-		global_source_states.push_back(radix_table_p.GetGlobalSourceState(context));
-	}
-	n_tasks = MaxValue<idx_t>(n_tasks, 1);
-	n_tasks = MinValue<idx_t>(n_tasks, NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads()));
-
-	vector<shared_ptr<Task>> tasks;
-	for (idx_t i = 0; i < n_tasks; i++) {
-		tasks.push_back(
-		    make_uniq<UngroupedDistinctAggregateFinalizeTask>(pipeline->executor, shared_from_this(), op, gstate));
-		tasks_scheduled++;
-	}
-	SetTasks(std::move(tasks));
-}
-
-TaskExecutionResult UngroupedDistinctAggregateFinalizeTask::ExecuteTask(TaskExecutionMode mode) {
-	auto res = AggregateDistinct();
-	if (res == TaskExecutionResult::TASK_BLOCKED) {
-		return res;
-	}
-	event->FinishTask();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-TaskExecutionResult UngroupedDistinctAggregateFinalizeTask::AggregateDistinct() {
-	D_ASSERT(gstate.distinct_state);
-	auto &distinct_state = *gstate.distinct_state;
-	auto &distinct_data = *op.distinct_data;
-
-	auto &aggregates = op.aggregates;
-	auto &state = aggregate_state;
-
-	// Thread-local contexts
-	ThreadContext thread_context(executor.context);
-	ExecutionContext execution_context(executor.context, thread_context, nullptr);
-
-	auto &finalize_event = event->Cast<UngroupedDistinctAggregateFinalizeEvent>();
-
-	// Now loop through the distinct aggregates, scanning the distinct HTs
-
-	// This needs to be preserved in case the radix_table.GetData blocks
-	auto &agg_idx = aggregation_idx;
-
-	for (; agg_idx < aggregates.size(); agg_idx++) {
-		auto &aggregate = aggregates[agg_idx]->Cast<BoundAggregateExpression>();
-
-		// If aggregate is not distinct, skip it
-		if (!distinct_data.IsDistinct(agg_idx)) {
-			continue;
-		}
-
-		const auto table_idx = distinct_data.info.table_map.at(agg_idx);
-		auto &radix_table = *distinct_data.radix_tables[table_idx];
-		if (!blocked) {
-			// Because we can block, we need to make sure we preserve this state
-			radix_table_lstate = radix_table.GetLocalSourceState(execution_context);
-		}
-		auto &lstate = *radix_table_lstate;
-
-		auto &sink = *distinct_state.radix_states[table_idx];
-		InterruptState interrupt_state(shared_from_this());
-		OperatorSourceInput source_input {*finalize_event.global_source_states[agg_idx], lstate, interrupt_state};
-
-		DataChunk output_chunk;
-		output_chunk.Initialize(executor.context, distinct_state.distinct_output_chunks[table_idx]->GetTypes());
-
-		DataChunk payload_chunk;
-		payload_chunk.InitializeEmpty(distinct_data.grouped_aggregate_data[table_idx]->group_types);
-		payload_chunk.SetCardinality(0);
-
-		while (true) {
-			output_chunk.Reset();
-
-			auto res = radix_table.GetData(execution_context, output_chunk, sink, source_input);
-			if (res == SourceResultType::FINISHED) {
-				D_ASSERT(output_chunk.size() == 0);
-				break;
-			} else if (res == SourceResultType::BLOCKED) {
-				blocked = true;
-				return TaskExecutionResult::TASK_BLOCKED;
-			}
-
-			// We dont need to resolve the filter, we already did this in Sink
-			idx_t payload_cnt = aggregate.children.size();
-			for (idx_t i = 0; i < payload_cnt; i++) {
-				payload_chunk.data[i].Reference(output_chunk.data[i]);
-			}
-			payload_chunk.SetCardinality(output_chunk);
-
-			// Update the aggregate state
-			state.Sink(payload_chunk, 0, agg_idx);
-		}
-		blocked = false;
-	}
-
-	// After scanning the distinct HTs, we can combine the thread-local agg states with the thread-global
-	gstate.state.CombineDistinct(state, distinct_data);
-	finalize_event.FinalizeTask();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-SinkFinalizeType PhysicalUngroupedAggregate::FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                              GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<UngroupedAggregateGlobalSinkState>();
-	D_ASSERT(distinct_data);
-	auto &distinct_state = *gstate.distinct_state;
-
-	for (idx_t table_idx = 0; table_idx < distinct_data->radix_tables.size(); table_idx++) {
-		auto &radix_table_p = distinct_data->radix_tables[table_idx];
-		auto &radix_state = *distinct_state.radix_states[table_idx];
-		radix_table_p->Finalize(context, radix_state);
-	}
-	auto new_event = make_shared_ptr<UngroupedDistinctAggregateFinalizeEvent>(context, *this, gstate, pipeline);
-	event.InsertEvent(std::move(new_event));
-	return SinkFinalizeType::READY;
-}
-
-SinkFinalizeType PhysicalUngroupedAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                      OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<UngroupedAggregateGlobalSinkState>();
-
-	if (distinct_data) {
-		return FinalizeDistinct(pipeline, event, context, input.global_state);
-	}
-
-	D_ASSERT(!gstate.finished);
-	gstate.finished = true;
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-void VerifyNullHandling(DataChunk &chunk, UngroupedAggregateState &state,
-                        const vector<unique_ptr<Expression>> &aggregates) {
-#ifdef DEBUG
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggr = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
-		if (state.counts[aggr_idx] == 0 && aggr.function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
-			// Default is when 0 values go in, NULL comes out
-			UnifiedVectorFormat vdata;
-			chunk.data[aggr_idx].ToUnifiedFormat(1, vdata);
-			D_ASSERT(!vdata.validity.RowIsValid(vdata.sel->get_index(0)));
-		}
-	}
-#endif
-}
-
-void GlobalUngroupedAggregateState::Finalize(DataChunk &result, idx_t column_offset) {
-	result.SetCardinality(1);
-	for (idx_t aggr_idx = 0; aggr_idx < state.aggregate_expressions.size(); aggr_idx++) {
-		auto &aggregate = state.aggregate_expressions[aggr_idx]->Cast<BoundAggregateExpression>();
-
-		Vector state_vector(Value::POINTER(CastPointerToValue(state.aggregate_data[aggr_idx].get())));
-		AggregateInputData aggr_input_data(aggregate.bind_info.get(), allocator);
-		aggregate.function.finalize(state_vector, aggr_input_data, result.data[column_offset + aggr_idx], 1, 0);
-	}
-}
-
-SourceResultType PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                     OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<UngroupedAggregateGlobalSinkState>();
-	D_ASSERT(gstate.finished);
-
-	// initialize the result chunk with the aggregate values
-	gstate.state.Finalize(chunk);
-	VerifyNullHandling(chunk, gstate.state.state, aggregates);
-
-	return SourceResultType::FINISHED;
-}
-
-InsertionOrderPreservingMap<string> PhysicalUngroupedAggregate::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string aggregate_info;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
-		if (i > 0) {
-			aggregate_info += "\n";
-		}
-		aggregate_info += aggregates[i]->GetName();
-		if (aggregate.filter) {
-			aggregate_info += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	result["Aggregates"] = aggregate_info;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/aggregate/physical_window.cpp b/src/duckdb/src/execution/operator/aggregate/physical_window.cpp
deleted file mode 100644
index 8b8b2a162..000000000
--- a/src/duckdb/src/execution/operator/aggregate/physical_window.cpp
+++ /dev/null
@@ -1,1014 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_window.hpp"
-
-#include "duckdb/common/sort/partition_state.hpp"
-#include "duckdb/function/window/window_aggregate_function.hpp"
-#include "duckdb/function/window/window_executor.hpp"
-#include "duckdb/function/window/window_rank_function.hpp"
-#include "duckdb/function/window/window_rownumber_function.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/function/window/window_value_function.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-//
-#include <numeric>
-
-namespace duckdb {
-
-//	Global sink state
-class WindowGlobalSinkState;
-
-enum WindowGroupStage : uint8_t { SINK, FINALIZE, GETDATA, DONE };
-
-class WindowHashGroup {
-public:
-	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
-	using OrderMasks = PartitionGlobalHashGroup::OrderMasks;
-	using ExecutorGlobalStatePtr = unique_ptr<WindowExecutorGlobalState>;
-	using ExecutorGlobalStates = vector<ExecutorGlobalStatePtr>;
-	using ExecutorLocalStatePtr = unique_ptr<WindowExecutorLocalState>;
-	using ExecutorLocalStates = vector<ExecutorLocalStatePtr>;
-	using ThreadLocalStates = vector<ExecutorLocalStates>;
-
-	WindowHashGroup(WindowGlobalSinkState &gstate, const idx_t hash_bin_p);
-
-	ExecutorGlobalStates &Initialize(WindowGlobalSinkState &gstate);
-
-	// Scan all of the blocks during the build phase
-	unique_ptr<RowDataCollectionScanner> GetBuildScanner(idx_t block_idx) const {
-		if (!rows) {
-			return nullptr;
-		}
-		return make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, block_idx, false);
-	}
-
-	// Scan a single block during the evaluate phase
-	unique_ptr<RowDataCollectionScanner> GetEvaluateScanner(idx_t block_idx) const {
-		//	Second pass can flush
-		D_ASSERT(rows);
-		return make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, block_idx, true);
-	}
-
-	// The processing stage for this group
-	WindowGroupStage GetStage() const {
-		return stage;
-	}
-
-	bool TryPrepareNextStage() {
-		lock_guard<mutex> prepare_guard(lock);
-		switch (stage.load()) {
-		case WindowGroupStage::SINK:
-			if (sunk == count) {
-				stage = WindowGroupStage::FINALIZE;
-				return true;
-			}
-			return false;
-		case WindowGroupStage::FINALIZE:
-			if (finalized == blocks) {
-				stage = WindowGroupStage::GETDATA;
-				return true;
-			}
-			return false;
-		default:
-			// never block in GETDATA
-			return true;
-		}
-	}
-
-	//! The hash partition data
-	HashGroupPtr hash_group;
-	//! The size of the group
-	idx_t count = 0;
-	//! The number of blocks in the group
-	idx_t blocks = 0;
-	unique_ptr<RowDataCollection> rows;
-	unique_ptr<RowDataCollection> heap;
-	RowLayout layout;
-	//! The partition boundary mask
-	ValidityMask partition_mask;
-	//! The order boundary mask
-	OrderMasks order_masks;
-	//! The fully materialised data collection
-	unique_ptr<WindowCollection> collection;
-	//! External paging
-	bool external;
-	// The processing stage for this group
-	atomic<WindowGroupStage> stage;
-	//! The function global states for this hash group
-	ExecutorGlobalStates gestates;
-	//! Executor local states, one per thread
-	ThreadLocalStates thread_states;
-
-	//! The bin number
-	idx_t hash_bin;
-	//! Single threading lock
-	mutex lock;
-	//! Count of sunk rows
-	std::atomic<idx_t> sunk;
-	//! Count of finalized blocks
-	std::atomic<idx_t> finalized;
-	//! The number of tasks left before we should be deleted
-	std::atomic<idx_t> tasks_remaining;
-	//! The output ordering batch index this hash group starts at
-	idx_t batch_base;
-
-private:
-	void MaterializeSortedData();
-};
-
-class WindowPartitionGlobalSinkState;
-
-class WindowGlobalSinkState : public GlobalSinkState {
-public:
-	using ExecutorPtr = unique_ptr<WindowExecutor>;
-	using Executors = vector<ExecutorPtr>;
-
-	WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &context);
-
-	//! Parent operator
-	const PhysicalWindow &op;
-	//! Execution context
-	ClientContext &context;
-	//! The partitioned sunk data
-	unique_ptr<WindowPartitionGlobalSinkState> global_partition;
-	//! The execution functions
-	Executors executors;
-	//! The shared expressions library
-	WindowSharedExpressions shared;
-};
-
-class WindowPartitionGlobalSinkState : public PartitionGlobalSinkState {
-public:
-	using WindowHashGroupPtr = unique_ptr<WindowHashGroup>;
-
-	WindowPartitionGlobalSinkState(WindowGlobalSinkState &gsink, const BoundWindowExpression &wexpr)
-	    : PartitionGlobalSinkState(gsink.context, wexpr.partitions, wexpr.orders, gsink.op.children[0]->types,
-	                               wexpr.partitions_stats, gsink.op.estimated_cardinality),
-	      gsink(gsink) {
-	}
-	~WindowPartitionGlobalSinkState() override = default;
-
-	void OnBeginMerge() override {
-		PartitionGlobalSinkState::OnBeginMerge();
-		window_hash_groups.resize(hash_groups.size());
-	}
-
-	void OnSortedPartition(const idx_t group_idx) override {
-		PartitionGlobalSinkState::OnSortedPartition(group_idx);
-		window_hash_groups[group_idx] = make_uniq<WindowHashGroup>(gsink, group_idx);
-	}
-
-	//! Operator global sink state
-	WindowGlobalSinkState &gsink;
-	//! The sorted hash groups
-	vector<WindowHashGroupPtr> window_hash_groups;
-};
-
-//	Per-thread sink state
-class WindowLocalSinkState : public LocalSinkState {
-public:
-	WindowLocalSinkState(ClientContext &context, const WindowGlobalSinkState &gstate)
-	    : local_partition(context, *gstate.global_partition) {
-	}
-
-	void Sink(DataChunk &input_chunk) {
-		local_partition.Sink(input_chunk);
-	}
-
-	void Combine() {
-		local_partition.Combine();
-	}
-
-	PartitionLocalSinkState local_partition;
-};
-
-// this implements a sorted window functions variant
-PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list_p,
-                               idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list_p)),
-      order_idx(0), is_order_dependent(false) {
-
-	idx_t max_orders = 0;
-	for (idx_t i = 0; i < select_list.size(); ++i) {
-		auto &expr = select_list[i];
-		D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-		auto &bound_window = expr->Cast<BoundWindowExpression>();
-		if (bound_window.partitions.empty() && bound_window.orders.empty()) {
-			is_order_dependent = true;
-		}
-
-		if (bound_window.orders.size() > max_orders) {
-			order_idx = i;
-			max_orders = bound_window.orders.size();
-		}
-	}
-}
-
-static unique_ptr<WindowExecutor> WindowExecutorFactory(BoundWindowExpression &wexpr, ClientContext &context,
-                                                        WindowSharedExpressions &shared, WindowAggregationMode mode) {
-	switch (wexpr.GetExpressionType()) {
-	case ExpressionType::WINDOW_AGGREGATE:
-		return make_uniq<WindowAggregateExecutor>(wexpr, context, shared, mode);
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		return make_uniq<WindowRowNumberExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_RANK_DENSE:
-		return make_uniq<WindowDenseRankExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_RANK:
-		return make_uniq<WindowRankExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_PERCENT_RANK:
-		return make_uniq<WindowPercentRankExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_CUME_DIST:
-		return make_uniq<WindowCumeDistExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_NTILE:
-		return make_uniq<WindowNtileExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-		return make_uniq<WindowLeadLagExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_FIRST_VALUE:
-		return make_uniq<WindowFirstValueExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_LAST_VALUE:
-		return make_uniq<WindowLastValueExecutor>(wexpr, context, shared);
-	case ExpressionType::WINDOW_NTH_VALUE:
-		return make_uniq<WindowNthValueExecutor>(wexpr, context, shared);
-		break;
-	default:
-		throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType()));
-	}
-}
-
-WindowGlobalSinkState::WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &context)
-    : op(op), context(context) {
-
-	D_ASSERT(op.select_list[op.order_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-	auto &wexpr = op.select_list[op.order_idx]->Cast<BoundWindowExpression>();
-
-	const auto mode = DBConfig::GetConfig(context).options.window_mode;
-	for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) {
-		D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-		auto &wexpr = op.select_list[expr_idx]->Cast<BoundWindowExpression>();
-		auto wexec = WindowExecutorFactory(wexpr, context, shared, mode);
-		executors.emplace_back(std::move(wexec));
-	}
-
-	global_partition = make_uniq<WindowPartitionGlobalSinkState>(*this, wexpr);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalWindow::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
-
-	lstate.Sink(chunk);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalWindow::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
-	lstate.Combine();
-
-	return SinkCombineResultType::FINISHED;
-}
-
-unique_ptr<LocalSinkState> PhysicalWindow::GetLocalSinkState(ExecutionContext &context) const {
-	auto &gstate = sink_state->Cast<WindowGlobalSinkState>();
-	return make_uniq<WindowLocalSinkState>(context.client, gstate);
-}
-
-unique_ptr<GlobalSinkState> PhysicalWindow::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<WindowGlobalSinkState>(*this, context);
-}
-
-SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          OperatorSinkFinalizeInput &input) const {
-	auto &state = input.global_state.Cast<WindowGlobalSinkState>();
-
-	//	Did we get any data?
-	if (!state.global_partition->count) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Do we have any sorting to schedule?
-	if (state.global_partition->rows) {
-		D_ASSERT(!state.global_partition->grouping_data);
-		return state.global_partition->rows->count ? SinkFinalizeType::READY : SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Find the first group to sort
-	if (!state.global_partition->HasMergeTasks()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Schedule all the sorts for maximum thread utilisation
-	auto new_event = make_shared_ptr<PartitionMergeEvent>(*state.global_partition, pipeline, *this);
-	event.InsertEvent(std::move(new_event));
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class WindowGlobalSourceState : public GlobalSourceState {
-public:
-	using ScannerPtr = unique_ptr<RowDataCollectionScanner>;
-
-	struct Task {
-		Task(WindowGroupStage stage, idx_t group_idx, idx_t max_idx)
-		    : stage(stage), group_idx(group_idx), thread_idx(0), max_idx(max_idx) {
-		}
-		WindowGroupStage stage;
-		//! The hash group
-		idx_t group_idx;
-		//! The thread index (for local state)
-		idx_t thread_idx;
-		//! The total block index count
-		idx_t max_idx;
-		//! The first block index count
-		idx_t begin_idx = 0;
-		//! The end block index count
-		idx_t end_idx = 0;
-	};
-	using TaskPtr = optional_ptr<Task>;
-
-	WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p);
-
-	//! Build task list
-	void CreateTaskList();
-
-	//! Are there any more tasks?
-	bool HasMoreTasks() const {
-		return !stopped && next_task < tasks.size();
-	}
-	bool HasUnfinishedTasks() const {
-		return !stopped && finished < tasks.size();
-	}
-	//! Try to advance the group stage
-	bool TryPrepareNextStage();
-	//! Get the next task given the current state
-	bool TryNextTask(TaskPtr &task);
-	//! Finish a task
-	void FinishTask(TaskPtr task);
-
-	//! Context for executing computations
-	ClientContext &context;
-	//! All the sunk data
-	WindowGlobalSinkState &gsink;
-	//! The total number of blocks to process;
-	idx_t total_blocks = 0;
-	//! The number of local states
-	atomic<idx_t> locals;
-	//! The list of tasks
-	vector<Task> tasks;
-	//! The the next task
-	atomic<idx_t> next_task;
-	//! The the number of finished tasks
-	atomic<idx_t> finished;
-	//! Stop producing tasks
-	atomic<bool> stopped;
-	//! The number of rows returned
-	atomic<idx_t> returned;
-
-public:
-	idx_t MaxThreads() override {
-		return total_blocks;
-	}
-};
-
-WindowGlobalSourceState::WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p)
-    : context(context_p), gsink(gsink_p), locals(0), next_task(0), finished(0), stopped(false), returned(0) {
-	auto &gpart = gsink.global_partition;
-	auto &window_hash_groups = gsink.global_partition->window_hash_groups;
-
-	if (window_hash_groups.empty()) {
-		//	OVER()
-		if (gpart->rows && !gpart->rows->blocks.empty()) {
-			// We need to construct the single WindowHashGroup here because the sort tasks will not be run.
-			window_hash_groups.emplace_back(make_uniq<WindowHashGroup>(gsink, idx_t(0)));
-			total_blocks = gpart->rows->blocks.size();
-		}
-	} else {
-		idx_t batch_base = 0;
-		for (auto &window_hash_group : window_hash_groups) {
-			if (!window_hash_group) {
-				continue;
-			}
-			auto &rows = window_hash_group->rows;
-			if (!rows) {
-				continue;
-			}
-
-			const auto block_count = window_hash_group->rows->blocks.size();
-			window_hash_group->batch_base = batch_base;
-			batch_base += block_count;
-		}
-		total_blocks = batch_base;
-	}
-}
-
-void WindowGlobalSourceState::CreateTaskList() {
-	//	Check whether we have a task list outside the mutex.
-	if (next_task.load()) {
-		return;
-	}
-
-	auto guard = Lock();
-
-	auto &window_hash_groups = gsink.global_partition->window_hash_groups;
-	if (!tasks.empty()) {
-		return;
-	}
-
-	//    Sort the groups from largest to smallest
-	if (window_hash_groups.empty()) {
-		return;
-	}
-
-	using PartitionBlock = std::pair<idx_t, idx_t>;
-	vector<PartitionBlock> partition_blocks;
-	for (idx_t group_idx = 0; group_idx < window_hash_groups.size(); ++group_idx) {
-		auto &window_hash_group = window_hash_groups[group_idx];
-		partition_blocks.emplace_back(window_hash_group->rows->blocks.size(), group_idx);
-	}
-	std::sort(partition_blocks.begin(), partition_blocks.end(), std::greater<PartitionBlock>());
-
-	//	Schedule the largest group on as many threads as possible
-	const auto threads = locals.load();
-	const auto &max_block = partition_blocks.front();
-	const auto per_thread = (max_block.first + threads - 1) / threads;
-	if (!per_thread) {
-		throw InternalException("No blocks per thread! %ld threads, %ld groups, %ld blocks, %ld hash group", threads,
-		                        partition_blocks.size(), max_block.first, max_block.second);
-	}
-
-	//	TODO: Generate dynamically instead of building a big list?
-	vector<WindowGroupStage> states {WindowGroupStage::SINK, WindowGroupStage::FINALIZE, WindowGroupStage::GETDATA};
-	for (const auto &b : partition_blocks) {
-		auto &window_hash_group = *window_hash_groups[b.second];
-		for (const auto &state : states) {
-			idx_t thread_count = 0;
-			for (Task task(state, b.second, b.first); task.begin_idx < task.max_idx; task.begin_idx += per_thread) {
-				task.end_idx = MinValue<idx_t>(task.begin_idx + per_thread, task.max_idx);
-				tasks.emplace_back(task);
-				window_hash_group.tasks_remaining++;
-				thread_count = ++task.thread_idx;
-			}
-			window_hash_group.thread_states.resize(thread_count);
-		}
-	}
-}
-
-void WindowHashGroup::MaterializeSortedData() {
-	auto &global_sort_state = *hash_group->global_sort;
-	if (global_sort_state.sorted_blocks.empty()) {
-		return;
-	}
-
-	// scan the sorted row data
-	D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-	auto &sb = *global_sort_state.sorted_blocks[0];
-
-	// Free up some memory before allocating more
-	sb.radix_sorting_data.clear();
-	sb.blob_sorting_data = nullptr;
-
-	// Move the sorting row blocks into our RDCs
-	auto &buffer_manager = global_sort_state.buffer_manager;
-	auto &sd = *sb.payload_data;
-
-	// Data blocks are required
-	D_ASSERT(!sd.data_blocks.empty());
-	auto &block = sd.data_blocks[0];
-	rows = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-	rows->blocks = std::move(sd.data_blocks);
-	rows->count = std::accumulate(rows->blocks.begin(), rows->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-
-	// Heap blocks are optional, but we want both for iteration.
-	if (!sd.heap_blocks.empty()) {
-		auto &block = sd.heap_blocks[0];
-		heap = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-		heap->blocks = std::move(sd.heap_blocks);
-		hash_group.reset();
-	} else {
-		heap = make_uniq<RowDataCollection>(buffer_manager, buffer_manager.GetBlockSize(), 1U, true);
-	}
-	heap->count = std::accumulate(heap->blocks.begin(), heap->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-}
-
-WindowHashGroup::WindowHashGroup(WindowGlobalSinkState &gstate, const idx_t hash_bin_p)
-    : count(0), blocks(0), stage(WindowGroupStage::SINK), hash_bin(hash_bin_p), sunk(0), finalized(0),
-      tasks_remaining(0), batch_base(0) {
-	// There are three types of partitions:
-	// 1. No partition (no sorting)
-	// 2. One partition (sorting, but no hashing)
-	// 3. Multiple partitions (sorting and hashing)
-
-	//	How big is the partition?
-	auto &gpart = *gstate.global_partition;
-	layout.Initialize(gpart.payload_types);
-	if (hash_bin < gpart.hash_groups.size() && gpart.hash_groups[hash_bin]) {
-		count = gpart.hash_groups[hash_bin]->count;
-	} else if (gpart.rows && !hash_bin) {
-		count = gpart.count;
-	} else {
-		return;
-	}
-
-	//	Initialise masks to false
-	partition_mask.Initialize(count);
-	partition_mask.SetAllInvalid(count);
-
-	const auto &executors = gstate.executors;
-	for (auto &wexec : executors) {
-		auto &wexpr = wexec->wexpr;
-		auto &order_mask = order_masks[wexpr.partitions.size() + wexpr.orders.size()];
-		if (order_mask.IsMaskSet()) {
-			continue;
-		}
-		order_mask.Initialize(count);
-		order_mask.SetAllInvalid(count);
-	}
-
-	// Scan the sorted data into new Collections
-	external = gpart.external;
-	if (gpart.rows && !hash_bin) {
-		// Simple mask
-		partition_mask.SetValidUnsafe(0);
-		for (auto &order_mask : order_masks) {
-			order_mask.second.SetValidUnsafe(0);
-		}
-		//	No partition - align the heap blocks with the row blocks
-		rows = gpart.rows->CloneEmpty(gpart.rows->keep_pinned);
-		heap = gpart.strings->CloneEmpty(gpart.strings->keep_pinned);
-		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gpart.rows, *gpart.strings, layout);
-		external = true;
-	} else if (hash_bin < gpart.hash_groups.size()) {
-		// Overwrite the collections with the sorted data
-		D_ASSERT(gpart.hash_groups[hash_bin].get());
-		hash_group = std::move(gpart.hash_groups[hash_bin]);
-		hash_group->ComputeMasks(partition_mask, order_masks);
-		external = hash_group->global_sort->external;
-		MaterializeSortedData();
-	}
-
-	if (rows) {
-		blocks = rows->blocks.size();
-	}
-
-	// Set up the collection for any fully materialised data
-	const auto &shared = WindowSharedExpressions::GetSortedExpressions(gstate.shared.coll_shared);
-	vector<LogicalType> types;
-	for (auto &expr : shared) {
-		types.emplace_back(expr->return_type);
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(gstate.context);
-	collection = make_uniq<WindowCollection>(buffer_manager, count, types);
-}
-
-// Per-thread scan state
-class WindowLocalSourceState : public LocalSourceState {
-public:
-	using Task = WindowGlobalSourceState::Task;
-	using TaskPtr = optional_ptr<Task>;
-
-	explicit WindowLocalSourceState(WindowGlobalSourceState &gsource);
-
-	//! Does the task have more work to do?
-	bool TaskFinished() const {
-		return !task || task->begin_idx == task->end_idx;
-	}
-	//! Assign the next task
-	bool TryAssignTask();
-	//! Execute a step in the current task
-	void ExecuteTask(DataChunk &chunk);
-
-	//! The shared source state
-	WindowGlobalSourceState &gsource;
-	//! The current batch index (for output reordering)
-	idx_t batch_index;
-	//! The task this thread is working on
-	TaskPtr task;
-	//! The current source being processed
-	optional_ptr<WindowHashGroup> window_hash_group;
-	//! The scan cursor
-	unique_ptr<RowDataCollectionScanner> scanner;
-	//! Buffer for the inputs
-	DataChunk input_chunk;
-	//! Buffer for window results
-	DataChunk output_chunk;
-
-protected:
-	void Sink();
-	void Finalize();
-	void GetData(DataChunk &chunk);
-
-	//! Storage and evaluation for the fully materialised data
-	unique_ptr<WindowBuilder> builder;
-	ExpressionExecutor coll_exec;
-	DataChunk coll_chunk;
-
-	//! Storage and evaluation for chunks used in the sink/build phase
-	ExpressionExecutor sink_exec;
-	DataChunk sink_chunk;
-
-	//! Storage and evaluation for chunks used in the evaluate phase
-	ExpressionExecutor eval_exec;
-	DataChunk eval_chunk;
-};
-
-WindowHashGroup::ExecutorGlobalStates &WindowHashGroup::Initialize(WindowGlobalSinkState &gsink) {
-	//	Single-threaded building as this is mostly memory allocation
-	lock_guard<mutex> gestate_guard(lock);
-	const auto &executors = gsink.executors;
-	if (gestates.size() == executors.size()) {
-		return gestates;
-	}
-
-	// These can be large so we defer building them until we are ready.
-	for (auto &wexec : executors) {
-		auto &wexpr = wexec->wexpr;
-		auto &order_mask = order_masks[wexpr.partitions.size() + wexpr.orders.size()];
-		gestates.emplace_back(wexec->GetGlobalState(count, partition_mask, order_mask));
-	}
-
-	return gestates;
-}
-
-void WindowLocalSourceState::Sink() {
-	D_ASSERT(task);
-	D_ASSERT(task->stage == WindowGroupStage::SINK);
-
-	auto &gsink = gsource.gsink;
-	const auto &executors = gsink.executors;
-
-	// Create the global state for each function
-	// These can be large so we defer building them until we are ready.
-	auto &gestates = window_hash_group->Initialize(gsink);
-
-	//	Set up the local states
-	auto &local_states = window_hash_group->thread_states.at(task->thread_idx);
-	if (local_states.empty()) {
-		for (idx_t w = 0; w < executors.size(); ++w) {
-			local_states.emplace_back(executors[w]->GetLocalState(*gestates[w]));
-		}
-	}
-
-	//	First pass over the input without flushing
-	for (; task->begin_idx < task->end_idx; ++task->begin_idx) {
-		scanner = window_hash_group->GetBuildScanner(task->begin_idx);
-		if (!scanner) {
-			break;
-		}
-		while (true) {
-			//	TODO: Try to align on validity mask boundaries by starting ragged?
-			idx_t input_idx = scanner->Scanned();
-			input_chunk.Reset();
-			scanner->Scan(input_chunk);
-			if (input_chunk.size() == 0) {
-				break;
-			}
-
-			//	Compute fully materialised expressions
-			if (coll_chunk.data.empty()) {
-				coll_chunk.SetCardinality(input_chunk);
-			} else {
-				coll_chunk.Reset();
-				coll_exec.Execute(input_chunk, coll_chunk);
-				auto collection = window_hash_group->collection.get();
-				if (!builder || &builder->collection != collection) {
-					builder = make_uniq<WindowBuilder>(*collection);
-				}
-
-				builder->Sink(coll_chunk, input_idx);
-			}
-
-			// Compute sink expressions
-			if (sink_chunk.data.empty()) {
-				sink_chunk.SetCardinality(input_chunk);
-			} else {
-				sink_chunk.Reset();
-				sink_exec.Execute(input_chunk, sink_chunk);
-			}
-
-			for (idx_t w = 0; w < executors.size(); ++w) {
-				executors[w]->Sink(sink_chunk, coll_chunk, input_idx, *gestates[w], *local_states[w]);
-			}
-
-			window_hash_group->sunk += input_chunk.size();
-		}
-
-		// External scanning assumes all blocks are swizzled.
-		scanner->SwizzleBlock(task->begin_idx);
-		scanner.reset();
-	}
-}
-
-void WindowLocalSourceState::Finalize() {
-	D_ASSERT(task);
-	D_ASSERT(task->stage == WindowGroupStage::FINALIZE);
-
-	// First finalize the collection (so the executors can use it)
-	auto &gsink = gsource.gsink;
-	if (window_hash_group->collection) {
-		window_hash_group->collection->Combine(gsink.shared.coll_validity);
-	}
-
-	// Finalize all the executors.
-	// Parallel finalisation is handled internally by the executor,
-	// and should not return until all threads have completed work.
-	const auto &executors = gsink.executors;
-	auto &gestates = window_hash_group->gestates;
-	auto &local_states = window_hash_group->thread_states.at(task->thread_idx);
-	for (idx_t w = 0; w < executors.size(); ++w) {
-		executors[w]->Finalize(*gestates[w], *local_states[w], window_hash_group->collection);
-	}
-
-	//	Mark this range as done
-	window_hash_group->finalized += (task->end_idx - task->begin_idx);
-	task->begin_idx = task->end_idx;
-}
-
-WindowLocalSourceState::WindowLocalSourceState(WindowGlobalSourceState &gsource)
-    : gsource(gsource), batch_index(0), coll_exec(gsource.context), sink_exec(gsource.context),
-      eval_exec(gsource.context) {
-	auto &gsink = gsource.gsink;
-	auto &global_partition = *gsink.global_partition;
-
-	input_chunk.Initialize(global_partition.allocator, global_partition.payload_types);
-
-	vector<LogicalType> output_types;
-	for (auto &wexec : gsink.executors) {
-		auto &wexpr = wexec->wexpr;
-		output_types.emplace_back(wexpr.return_type);
-	}
-	output_chunk.Initialize(global_partition.allocator, output_types);
-
-	auto &shared = gsink.shared;
-	shared.PrepareCollection(coll_exec, coll_chunk);
-	shared.PrepareSink(sink_exec, sink_chunk);
-	shared.PrepareEvaluate(eval_exec, eval_chunk);
-
-	++gsource.locals;
-}
-
-bool WindowGlobalSourceState::TryNextTask(TaskPtr &task) {
-	auto guard = Lock();
-	if (next_task >= tasks.size() || stopped) {
-		task = nullptr;
-		return false;
-	}
-
-	//	If the next task matches the current state of its group, then we can use it
-	//	Otherwise block.
-	task = &tasks[next_task];
-
-	auto &gpart = *gsink.global_partition;
-	auto &window_hash_group = gpart.window_hash_groups[task->group_idx];
-	auto group_stage = window_hash_group->GetStage();
-
-	if (task->stage == group_stage) {
-		++next_task;
-		return true;
-	}
-
-	task = nullptr;
-	return false;
-}
-
-void WindowGlobalSourceState::FinishTask(TaskPtr task) {
-	if (!task) {
-		return;
-	}
-
-	auto &gpart = *gsink.global_partition;
-	auto &finished_hash_group = gpart.window_hash_groups[task->group_idx];
-	D_ASSERT(finished_hash_group);
-
-	if (!--finished_hash_group->tasks_remaining) {
-		finished_hash_group.reset();
-	}
-}
-
-bool WindowLocalSourceState::TryAssignTask() {
-	// Because downstream operators may be using our internal buffers,
-	// we can't "finish" a task until we are about to get the next one.
-
-	// Scanner first, as it may be referencing sort blocks in the hash group
-	scanner.reset();
-	gsource.FinishTask(task);
-
-	return gsource.TryNextTask(task);
-}
-
-bool WindowGlobalSourceState::TryPrepareNextStage() {
-	if (next_task >= tasks.size() || stopped) {
-		return true;
-	}
-
-	auto task = &tasks[next_task];
-	auto window_hash_group = gsink.global_partition->window_hash_groups[task->group_idx].get();
-	return window_hash_group->TryPrepareNextStage();
-}
-
-void WindowLocalSourceState::ExecuteTask(DataChunk &result) {
-	auto &gsink = gsource.gsink;
-
-	// Update the hash group
-	window_hash_group = gsink.global_partition->window_hash_groups[task->group_idx].get();
-
-	// Process the new state
-	switch (task->stage) {
-	case WindowGroupStage::SINK:
-		Sink();
-		D_ASSERT(TaskFinished());
-		break;
-	case WindowGroupStage::FINALIZE:
-		Finalize();
-		D_ASSERT(TaskFinished());
-		break;
-	case WindowGroupStage::GETDATA:
-		D_ASSERT(!TaskFinished());
-		GetData(result);
-		break;
-	default:
-		throw InternalException("Invalid window source state.");
-	}
-
-	// Count this task as finished.
-	if (TaskFinished()) {
-		++gsource.finished;
-	}
-}
-
-void WindowLocalSourceState::GetData(DataChunk &result) {
-	D_ASSERT(window_hash_group->GetStage() == WindowGroupStage::GETDATA);
-
-	if (!scanner || !scanner->Remaining()) {
-		scanner = window_hash_group->GetEvaluateScanner(task->begin_idx);
-		batch_index = window_hash_group->batch_base + task->begin_idx;
-	}
-
-	const auto position = scanner->Scanned();
-	input_chunk.Reset();
-	scanner->Scan(input_chunk);
-
-	const auto &executors = gsource.gsink.executors;
-	auto &gestates = window_hash_group->gestates;
-	auto &local_states = window_hash_group->thread_states.at(task->thread_idx);
-	output_chunk.Reset();
-	for (idx_t expr_idx = 0; expr_idx < executors.size(); ++expr_idx) {
-		auto &executor = *executors[expr_idx];
-		auto &gstate = *gestates[expr_idx];
-		auto &lstate = *local_states[expr_idx];
-		auto &result = output_chunk.data[expr_idx];
-		if (eval_chunk.data.empty()) {
-			eval_chunk.SetCardinality(input_chunk);
-		} else {
-			eval_chunk.Reset();
-			eval_exec.Execute(input_chunk, eval_chunk);
-		}
-		executor.Evaluate(position, eval_chunk, result, lstate, gstate);
-	}
-	output_chunk.SetCardinality(input_chunk);
-	output_chunk.Verify();
-
-	idx_t out_idx = 0;
-	result.SetCardinality(input_chunk);
-	for (idx_t col_idx = 0; col_idx < input_chunk.ColumnCount(); col_idx++) {
-		result.data[out_idx++].Reference(input_chunk.data[col_idx]);
-	}
-	for (idx_t col_idx = 0; col_idx < output_chunk.ColumnCount(); col_idx++) {
-		result.data[out_idx++].Reference(output_chunk.data[col_idx]);
-	}
-
-	// If we done with this block, move to the next one
-	if (!scanner->Remaining()) {
-		++task->begin_idx;
-	}
-
-	// If that was the last block, release out local state memory.
-	if (TaskFinished()) {
-		local_states.clear();
-	}
-	result.Verify();
-}
-
-unique_ptr<LocalSourceState> PhysicalWindow::GetLocalSourceState(ExecutionContext &context,
-                                                                 GlobalSourceState &gsource_p) const {
-	auto &gsource = gsource_p.Cast<WindowGlobalSourceState>();
-	return make_uniq<WindowLocalSourceState>(gsource);
-}
-
-unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext &context) const {
-	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
-	return make_uniq<WindowGlobalSourceState>(context, gsink);
-}
-
-bool PhysicalWindow::SupportsPartitioning(const OperatorPartitionInfo &partition_info) const {
-	if (partition_info.RequiresPartitionColumns()) {
-		return false;
-	}
-	//	We can only preserve order for single partitioning
-	//	or work stealing causes out of order batch numbers
-	auto &wexpr = select_list[order_idx]->Cast<BoundWindowExpression>();
-	return wexpr.partitions.empty(); // NOLINT
-}
-
-OrderPreservationType PhysicalWindow::SourceOrder() const {
-	auto &wexpr = select_list[order_idx]->Cast<BoundWindowExpression>();
-	if (!wexpr.partitions.empty()) {
-		// if we have partitions the window order is not defined
-		return OrderPreservationType::NO_ORDER;
-	}
-	// without partitions we can maintain order
-	if (wexpr.orders.empty()) {
-		// if we have no orders we maintain insertion order
-		return OrderPreservationType::INSERTION_ORDER;
-	}
-	// otherwise we can maintain the fixed order
-	return OrderPreservationType::FIXED_ORDER;
-}
-
-ProgressData PhysicalWindow::GetProgress(ClientContext &context, GlobalSourceState &gsource_p) const {
-	auto &gsource = gsource_p.Cast<WindowGlobalSourceState>();
-	const auto returned = gsource.returned.load();
-
-	auto &gsink = gsource.gsink;
-	const auto count = gsink.global_partition->count.load();
-	ProgressData res;
-	if (count) {
-		res.done = double(returned);
-		res.total = double(count);
-	} else {
-		res.SetInvalid();
-	}
-	return res;
-}
-
-OperatorPartitionData PhysicalWindow::GetPartitionData(ExecutionContext &context, DataChunk &chunk,
-                                                       GlobalSourceState &gstate_p, LocalSourceState &lstate_p,
-                                                       const OperatorPartitionInfo &partition_info) const {
-	if (partition_info.RequiresPartitionColumns()) {
-		throw InternalException("PhysicalWindow::GetPartitionData: partition columns not supported");
-	}
-	auto &lstate = lstate_p.Cast<WindowLocalSourceState>();
-	return OperatorPartitionData(lstate.batch_index);
-}
-
-SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &gsource = input.global_state.Cast<WindowGlobalSourceState>();
-	auto &lsource = input.local_state.Cast<WindowLocalSourceState>();
-
-	gsource.CreateTaskList();
-
-	while (gsource.HasUnfinishedTasks() && chunk.size() == 0) {
-		if (!lsource.TaskFinished() || lsource.TryAssignTask()) {
-			try {
-				lsource.ExecuteTask(chunk);
-			} catch (...) {
-				gsource.stopped = true;
-				throw;
-			}
-		} else {
-			auto guard = gsource.Lock();
-			if (!gsource.HasMoreTasks()) {
-				// no more tasks - exit
-				gsource.UnblockTasks(guard);
-				break;
-			}
-			if (gsource.TryPrepareNextStage()) {
-				// we successfully prepared the next stage - unblock tasks
-				gsource.UnblockTasks(guard);
-			} else {
-				// there are more tasks available, but we can't execute them yet
-				// block the source
-				return gsource.BlockSource(guard, input.interrupt_state);
-			}
-		}
-	}
-
-	gsource.returned += chunk.size();
-
-	if (chunk.size() == 0) {
-		return SourceResultType::FINISHED;
-	}
-	return SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalWindow::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string projections;
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			projections += "\n";
-		}
-		projections += select_list[i]->GetName();
-	}
-	result["Projections"] = projections;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp
deleted file mode 100644
index c18c5f61e..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_buffer.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-CSVBuffer::CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
-                     idx_t &global_csv_current_position, idx_t file_number_p)
-    : context(context), requested_size(buffer_size_p), file_number(file_number_p), can_seek(file_handle.CanSeek()),
-      is_pipe(file_handle.IsPipe()) {
-	AllocateBuffer(buffer_size_p);
-	auto buffer = Ptr();
-	actual_buffer_size = file_handle.Read(buffer, buffer_size_p);
-	while (actual_buffer_size < buffer_size_p && !file_handle.FinishedReading()) {
-		// We keep reading until this block is full
-		actual_buffer_size += file_handle.Read(&buffer[actual_buffer_size], buffer_size_p - actual_buffer_size);
-	}
-	global_csv_start = global_csv_current_position;
-	last_buffer = file_handle.FinishedReading();
-}
-
-CSVBuffer::CSVBuffer(CSVFileHandle &file_handle, ClientContext &context, idx_t buffer_size,
-                     idx_t global_csv_current_position, idx_t file_number_p, idx_t buffer_idx_p)
-    : context(context), requested_size(buffer_size), global_csv_start(global_csv_current_position),
-      file_number(file_number_p), can_seek(file_handle.CanSeek()), is_pipe(file_handle.IsPipe()),
-      buffer_idx(buffer_idx_p) {
-	AllocateBuffer(buffer_size);
-	auto buffer = handle.Ptr();
-	actual_buffer_size = file_handle.Read(handle.Ptr(), buffer_size);
-	while (actual_buffer_size < buffer_size && !file_handle.FinishedReading()) {
-		// We keep reading until this block is full
-		actual_buffer_size += file_handle.Read(&buffer[actual_buffer_size], buffer_size - actual_buffer_size);
-	}
-	last_buffer = file_handle.FinishedReading();
-}
-
-shared_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number_p,
-                                      bool &has_seaked) {
-	if (has_seaked) {
-		// This means that at some point a reload was done, and we are currently on the incorrect position in our file
-		// handle
-		file_handle.Seek(global_csv_start + actual_buffer_size);
-		has_seaked = false;
-	}
-	auto next_csv_buffer = make_shared_ptr<CSVBuffer>(
-	    file_handle, context, buffer_size, global_csv_start + actual_buffer_size, file_number_p, buffer_idx + 1);
-	if (next_csv_buffer->GetBufferSize() == 0) {
-		// We are done reading
-		return nullptr;
-	}
-	return next_csv_buffer;
-}
-
-void CSVBuffer::AllocateBuffer(idx_t buffer_size) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	bool can_destroy = !is_pipe;
-	handle = buffer_manager.Allocate(MemoryTag::CSV_READER, MaxValue<idx_t>(buffer_manager.GetBlockSize(), buffer_size),
-	                                 can_destroy);
-	block = handle.GetBlockHandle();
-}
-
-idx_t CSVBuffer::GetBufferSize() const {
-	return actual_buffer_size;
-}
-
-void CSVBuffer::Reload(CSVFileHandle &file_handle) {
-	AllocateBuffer(actual_buffer_size);
-	// If we can seek, we seek and return the correct pointers
-	file_handle.Seek(global_csv_start);
-	file_handle.Read(handle.Ptr(), actual_buffer_size);
-}
-
-shared_ptr<CSVBufferHandle> CSVBuffer::Pin(CSVFileHandle &file_handle, bool &has_seeked) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	if (!is_pipe && block->IsUnloaded()) {
-		// We have to reload it from disk
-		block = nullptr;
-		Reload(file_handle);
-		has_seeked = true;
-	}
-	return make_shared_ptr<CSVBufferHandle>(buffer_manager.Pin(block), actual_buffer_size, requested_size, last_buffer,
-	                                        file_number, buffer_idx);
-}
-
-void CSVBuffer::Unpin() {
-	if (handle.IsValid()) {
-		handle.Destroy();
-	}
-}
-
-bool CSVBuffer::IsCSVFileLastBuffer() const {
-	return last_buffer;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp
deleted file mode 100644
index 811689917..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_buffer.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-namespace duckdb {
-
-CSVBufferManager::CSVBufferManager(ClientContext &context_p, const CSVReaderOptions &options, const string &file_path_p,
-                                   const idx_t file_idx_p, bool per_file_single_threaded_p,
-                                   unique_ptr<CSVFileHandle> file_handle_p)
-    : context(context_p), per_file_single_threaded(per_file_single_threaded_p), file_idx(file_idx_p),
-      file_path(file_path_p), buffer_size(options.buffer_size_option.GetValue()) {
-	D_ASSERT(!file_path.empty());
-	if (file_handle_p) {
-		file_handle = std::move(file_handle_p);
-	} else {
-		file_handle = ReadCSV::OpenCSV(file_path, options, context);
-	}
-	is_pipe = file_handle->IsPipe();
-	skip_rows = options.dialect_options.skip_rows.GetValue();
-	Initialize();
-}
-
-void CSVBufferManager::UnpinBuffer(const idx_t cache_idx) {
-	if (cache_idx < cached_buffers.size()) {
-		cached_buffers[cache_idx]->Unpin();
-	}
-}
-
-void CSVBufferManager::Initialize() {
-	if (cached_buffers.empty()) {
-		cached_buffers.emplace_back(
-		    make_shared_ptr<CSVBuffer>(context, buffer_size, *file_handle, global_csv_pos, file_idx));
-		last_buffer = cached_buffers.front();
-	}
-}
-
-bool CSVBufferManager::ReadNextAndCacheIt() {
-	D_ASSERT(last_buffer);
-	for (idx_t i = 0; i < 2; i++) {
-		if (!last_buffer->IsCSVFileLastBuffer()) {
-			auto maybe_last_buffer = last_buffer->Next(*file_handle, buffer_size, file_idx, has_seeked);
-			if (!maybe_last_buffer) {
-				last_buffer->last_buffer = true;
-				return false;
-			}
-			last_buffer = std::move(maybe_last_buffer);
-			bytes_read += last_buffer->GetBufferSize();
-			cached_buffers.emplace_back(last_buffer);
-			return true;
-		}
-	}
-	return false;
-}
-
-shared_ptr<CSVBufferHandle> CSVBufferManager::GetBuffer(const idx_t pos) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if (pos == 0 && done && cached_buffers.empty()) {
-		if (is_pipe) {
-			throw InvalidInputException("Recursive CTEs are not allowed when using piped csv files");
-		}
-		// This is a recursive CTE, we have to reset out whole buffer
-		done = false;
-		file_handle->Reset();
-		Initialize();
-	}
-	while (pos >= cached_buffers.size()) {
-		if (done) {
-			return nullptr;
-		}
-		if (!ReadNextAndCacheIt()) {
-			done = true;
-		}
-	}
-	if (pos != 0 && (sniffing || file_handle->CanSeek() || per_file_single_threaded)) {
-		// We don't need to unpin the buffers here if we are not sniffing since we
-		// control it per-thread on the scan
-		if (cached_buffers[pos - 1]) {
-			cached_buffers[pos - 1]->Unpin();
-		}
-	}
-	return cached_buffers[pos]->Pin(*file_handle, has_seeked);
-}
-
-void CSVBufferManager::ResetBuffer(const idx_t buffer_idx) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if (buffer_idx >= cached_buffers.size()) {
-		// Nothing to reset
-		return;
-	}
-	D_ASSERT(cached_buffers[buffer_idx]);
-	if (buffer_idx == 0 && cached_buffers.size() > 1) {
-		cached_buffers[buffer_idx].reset();
-		idx_t cur_buffer = buffer_idx + 1;
-		while (reset_when_possible.find(cur_buffer) != reset_when_possible.end()) {
-			cached_buffers[cur_buffer].reset();
-			reset_when_possible.erase(cur_buffer);
-			cur_buffer++;
-		}
-		return;
-	}
-	// We only reset if previous one was also already reset
-	if (buffer_idx > 0 && !cached_buffers[buffer_idx - 1]) {
-		if (cached_buffers[buffer_idx]->last_buffer) {
-			// We clear the whole shebang
-			cached_buffers.clear();
-			reset_when_possible.clear();
-			return;
-		}
-		cached_buffers[buffer_idx].reset();
-		idx_t cur_buffer = buffer_idx + 1;
-		while (reset_when_possible.find(cur_buffer) != reset_when_possible.end()) {
-			cached_buffers[cur_buffer].reset();
-			reset_when_possible.erase(cur_buffer);
-			cur_buffer++;
-		}
-	} else {
-		reset_when_possible.insert(buffer_idx);
-	}
-}
-
-idx_t CSVBufferManager::GetBufferSize() const {
-	return buffer_size;
-}
-
-idx_t CSVBufferManager::BufferCount() const {
-	return cached_buffers.size();
-}
-
-bool CSVBufferManager::Done() const {
-	return done;
-}
-
-void CSVBufferManager::ResetBufferManager() {
-	if (!file_handle->IsPipe()) {
-		// If this is not a pipe we reset the buffer manager and restart it when doing the actual scan
-		cached_buffers.clear();
-		reset_when_possible.clear();
-		file_handle->Reset();
-		last_buffer = nullptr;
-		done = false;
-		global_csv_pos = 0;
-		Initialize();
-	}
-}
-
-string CSVBufferManager::GetFilePath() const {
-	return file_path;
-}
-
-bool CSVBufferManager::IsBlockUnloaded(idx_t block_idx) {
-	if (block_idx < cached_buffers.size()) {
-		return cached_buffers[block_idx]->IsUnloaded();
-	}
-	return false;
-}
-
-idx_t CSVBufferManager::GetBytesRead() const {
-	return bytes_read;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp
deleted file mode 100644
index 73fbb4ed0..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/compressed_file_system.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-
-namespace duckdb {
-
-CSVFileHandle::CSVFileHandle(DBConfig &config, unique_ptr<FileHandle> file_handle_p, const string &path_p,
-                             const CSVReaderOptions &options)
-    : compression_type(options.compression), file_handle(std::move(file_handle_p)),
-      encoder(config, options.encoding, options.buffer_size_option.GetValue()), path(path_p) {
-	can_seek = file_handle->CanSeek();
-	on_disk_file = file_handle->OnDiskFile();
-	file_size = file_handle->GetFileSize();
-	is_pipe = file_handle->IsPipe();
-	compression_type = file_handle->GetFileCompressionType();
-}
-
-unique_ptr<FileHandle> CSVFileHandle::OpenFileHandle(FileSystem &fs, Allocator &allocator, const string &path,
-                                                     FileCompressionType compression) {
-	auto file_handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ | compression);
-	if (file_handle->CanSeek()) {
-		file_handle->Reset();
-	}
-	return file_handle;
-}
-
-unique_ptr<CSVFileHandle> CSVFileHandle::OpenFile(DBConfig &config, FileSystem &fs, Allocator &allocator,
-                                                  const string &path, const CSVReaderOptions &options) {
-	auto file_handle = OpenFileHandle(fs, allocator, path, options.compression);
-	return make_uniq<CSVFileHandle>(config, std::move(file_handle), path, options);
-}
-
-double CSVFileHandle::GetProgress() const {
-	return static_cast<double>(file_handle->GetProgress());
-}
-
-bool CSVFileHandle::CanSeek() const {
-	return can_seek;
-}
-
-void CSVFileHandle::Seek(const idx_t position) const {
-	if (!can_seek) {
-		if (is_pipe) {
-			throw InternalException("Trying to seek a piped CSV File.");
-		}
-		throw InternalException("Trying to seek a compressed CSV File.");
-	}
-	file_handle->Seek(position);
-}
-
-bool CSVFileHandle::OnDiskFile() const {
-	return on_disk_file;
-}
-
-void CSVFileHandle::Reset() {
-	file_handle->Reset();
-	finished = false;
-	requested_bytes = 0;
-}
-
-bool CSVFileHandle::IsPipe() const {
-	return is_pipe;
-}
-
-idx_t CSVFileHandle::FileSize() const {
-	return file_size;
-}
-
-bool CSVFileHandle::FinishedReading() const {
-	return finished;
-}
-
-idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
-	requested_bytes += nr_bytes;
-	// if this is a plain file source OR we can seek we are not caching anything
-	idx_t bytes_read = 0;
-	if (encoder.encoding_name == "utf-8") {
-		bytes_read = static_cast<idx_t>(file_handle->Read(buffer, nr_bytes));
-	} else {
-		bytes_read = encoder.Encode(*file_handle, static_cast<char *>(buffer), nr_bytes);
-	}
-	if (!finished) {
-		finished = bytes_read == 0;
-	}
-	uncompressed_bytes_read += static_cast<idx_t>(bytes_read);
-	return UnsafeNumericCast<idx_t>(bytes_read);
-}
-
-string CSVFileHandle::ReadLine() {
-	bool carriage_return = false;
-	string result;
-	char buffer[1];
-	while (true) {
-		idx_t bytes_read = Read(buffer, 1);
-		if (bytes_read == 0) {
-			return result;
-		}
-		if (carriage_return) {
-			if (buffer[0] != '\n') {
-				if (!file_handle->CanSeek()) {
-					throw BinderException(
-					    "Carriage return newlines not supported when reading CSV files in which we cannot seek");
-				}
-				file_handle->Seek(file_handle->SeekPosition() - 1);
-				return result;
-			}
-		}
-		if (buffer[0] == '\n') {
-			return result;
-		}
-		if (buffer[0] != '\r') {
-			result += buffer[0];
-		} else {
-			carriage_return = true;
-		}
-	}
-}
-
-string CSVFileHandle::GetFilePath() {
-	return path;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/encode/csv_encoder.cpp b/src/duckdb/src/execution/operator/csv_scanner/encode/csv_encoder.cpp
deleted file mode 100644
index 89fc5df04..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/encode/csv_encoder.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/function/encoding_function.hpp"
-
-namespace duckdb {
-
-void CSVEncoderBuffer::Initialize(idx_t encoded_size) {
-	encoded_buffer_size = encoded_size;
-	encoded_buffer = std::unique_ptr<char[]>(new char[encoded_size]);
-}
-
-char *CSVEncoderBuffer::Ptr() const {
-	return encoded_buffer.get();
-}
-
-idx_t CSVEncoderBuffer::GetCapacity() const {
-	return encoded_buffer_size;
-}
-
-idx_t CSVEncoderBuffer::GetSize() const {
-	return actual_encoded_buffer_size;
-}
-
-void CSVEncoderBuffer::SetSize(const idx_t buffer_size) {
-	D_ASSERT(buffer_size <= encoded_buffer_size);
-	actual_encoded_buffer_size = buffer_size;
-}
-
-bool CSVEncoderBuffer::HasDataToRead() const {
-	return cur_pos < actual_encoded_buffer_size;
-}
-
-void CSVEncoderBuffer::Reset() {
-	cur_pos = 0;
-	actual_encoded_buffer_size = 0;
-}
-
-CSVEncoder::CSVEncoder(DBConfig &config, const string &encoding_name_to_find, idx_t buffer_size) {
-	encoding_name = StringUtil::Lower(encoding_name_to_find);
-	auto function = config.GetEncodeFunction(encoding_name_to_find);
-	if (!function) {
-		auto loaded_encodings = config.GetLoadedEncodedFunctions();
-		std::ostringstream error;
-		error << "The CSV Reader does not support the encoding: \"" << encoding_name_to_find << "\"\n";
-		error << "The currently supported encodings are: " << '\n';
-		for (auto &encoding_function : loaded_encodings) {
-			error << "*  " << encoding_function.get().GetType() << '\n';
-		}
-		throw InvalidInputException(error.str());
-	}
-	// We ensure that the encoded buffer size is an even number to make the two byte lookup on utf-16 work
-	idx_t encoded_buffer_size = buffer_size % 2 != 0 ? buffer_size - 1 : buffer_size;
-	D_ASSERT(encoded_buffer_size > 0);
-	encoded_buffer.Initialize(encoded_buffer_size);
-	remaining_bytes_buffer.Initialize(function->GetBytesPerIteration());
-	encoding_function = function;
-}
-
-idx_t CSVEncoder::Encode(FileHandle &file_handle_input, char *output_buffer, const idx_t decoded_buffer_size) {
-	idx_t output_buffer_pos = 0;
-	// Check if we have some left-overs. These can either be
-	// 1. missing decoded bytes
-	if (remaining_bytes_buffer.HasDataToRead()) {
-		D_ASSERT(remaining_bytes_buffer.cur_pos == 0);
-		const auto remaining_bytes_buffer_ptr = remaining_bytes_buffer.Ptr();
-		for (; remaining_bytes_buffer.cur_pos < remaining_bytes_buffer.GetSize(); remaining_bytes_buffer.cur_pos++) {
-			output_buffer[output_buffer_pos++] = remaining_bytes_buffer_ptr[remaining_bytes_buffer.cur_pos];
-		}
-		remaining_bytes_buffer.Reset();
-	}
-	// 2. remaining encoded buffer
-	if (encoded_buffer.HasDataToRead()) {
-		encoding_function->GetFunction()(
-		    encoded_buffer.Ptr(), encoded_buffer.cur_pos, encoded_buffer.GetSize(), output_buffer, output_buffer_pos,
-		    decoded_buffer_size, remaining_bytes_buffer.Ptr(), remaining_bytes_buffer.actual_encoded_buffer_size);
-	}
-	// 3. a new encoded buffer from the file
-	while (output_buffer_pos < decoded_buffer_size) {
-		idx_t current_decoded_buffer_start = output_buffer_pos;
-		encoded_buffer.Reset();
-		auto actual_encoded_bytes =
-		    static_cast<idx_t>(file_handle_input.Read(encoded_buffer.Ptr(), encoded_buffer.GetCapacity()));
-		encoded_buffer.SetSize(actual_encoded_bytes);
-		encoding_function->GetFunction()(
-		    encoded_buffer.Ptr(), encoded_buffer.cur_pos, encoded_buffer.GetSize(), output_buffer, output_buffer_pos,
-		    decoded_buffer_size, remaining_bytes_buffer.Ptr(), remaining_bytes_buffer.actual_encoded_buffer_size);
-		if (output_buffer_pos == current_decoded_buffer_start) {
-			return output_buffer_pos;
-		}
-	}
-	return output_buffer_pos;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/base_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/base_scanner.cpp
deleted file mode 100644
index 757598e14..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/scanner/base_scanner.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
-
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp"
-
-namespace duckdb {
-
-ScannerResult::ScannerResult(CSVStates &states_p, CSVStateMachine &state_machine_p, idx_t result_size_p)
-    : result_size(result_size_p), state_machine(state_machine_p), states(states_p) {
-}
-
-BaseScanner::BaseScanner(shared_ptr<CSVBufferManager> buffer_manager_p, shared_ptr<CSVStateMachine> state_machine_p,
-                         shared_ptr<CSVErrorHandler> error_handler_p, bool sniffing_p,
-                         shared_ptr<CSVFileScan> csv_file_scan_p, CSVIterator iterator_p)
-    : csv_file_scan(std::move(csv_file_scan_p)), sniffing(sniffing_p), error_handler(std::move(error_handler_p)),
-      state_machine(std::move(state_machine_p)), buffer_manager(std::move(buffer_manager_p)), iterator(iterator_p) {
-	D_ASSERT(buffer_manager);
-	D_ASSERT(state_machine);
-	// Initialize current buffer handle
-	cur_buffer_handle = buffer_manager->GetBuffer(iterator.GetBufferIdx());
-	if (!cur_buffer_handle) {
-		buffer_handle_ptr = nullptr;
-	} else {
-		buffer_handle_ptr = cur_buffer_handle->Ptr();
-	}
-}
-
-bool BaseScanner::FinishedFile() const {
-	if (!cur_buffer_handle) {
-		return true;
-	}
-	// we have to scan to infinity, so we must check if we are done checking the whole file
-	if (!buffer_manager->Done()) {
-		return false;
-	}
-	// If yes, are we in the last buffer?
-	if (iterator.pos.buffer_idx != buffer_manager->BufferCount()) {
-		return false;
-	}
-	// If yes, are we in the last position?
-	return iterator.pos.buffer_pos + 1 == cur_buffer_handle->actual_size;
-}
-
-CSVIterator BaseScanner::SkipCSVRows(shared_ptr<CSVBufferManager> buffer_manager,
-                                     const shared_ptr<CSVStateMachine> &state_machine, idx_t rows_to_skip) {
-	if (rows_to_skip == 0) {
-		return {};
-	}
-	auto error_handler = make_shared_ptr<CSVErrorHandler>();
-	SkipScanner row_skipper(std::move(buffer_manager), state_machine, error_handler, rows_to_skip);
-	row_skipper.ParseChunk();
-	return row_skipper.GetIterator();
-}
-
-CSVIterator &BaseScanner::GetIterator() {
-	return iterator;
-}
-
-void BaseScanner::SetIterator(const CSVIterator &it) {
-	iterator = it;
-}
-
-ScannerResult &BaseScanner::ParseChunk() {
-	throw InternalException("ParseChunk() from CSV Base Scanner is not implemented");
-}
-
-ScannerResult &BaseScanner::GetResult() {
-	throw InternalException("GetResult() from CSV Base Scanner is not implemented");
-}
-
-void BaseScanner::Initialize() {
-	throw InternalException("Initialize() from CSV Base Scanner is not implemented");
-}
-
-void BaseScanner::FinalizeChunkProcess() {
-	throw InternalException("FinalizeChunkProcess() from CSV Base Scanner is not implemented");
-}
-
-CSVStateMachine &BaseScanner::GetStateMachine() const {
-	return *state_machine;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp
deleted file mode 100644
index 7c4b7bb9c..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/column_count_scanner.hpp"
-
-namespace duckdb {
-
-ColumnCountResult::ColumnCountResult(CSVStates &states, CSVStateMachine &state_machine, idx_t result_size)
-    : ScannerResult(states, state_machine, result_size) {
-	column_counts.resize(result_size);
-}
-
-void ColumnCountResult::AddValue(ColumnCountResult &result, idx_t buffer_pos) {
-	result.current_column_count++;
-}
-
-inline void ColumnCountResult::InternalAddRow() {
-	const idx_t column_count = current_column_count + 1;
-	column_counts[result_position].number_of_columns = column_count;
-	rows_per_column_count[column_count]++;
-	current_column_count = 0;
-}
-
-idx_t ColumnCountResult::GetMostFrequentColumnCount() const {
-	if (rows_per_column_count.empty()) {
-		return 1;
-	}
-	idx_t column_count = 0;
-	idx_t current_max = 0;
-	for (auto &rpc : rows_per_column_count) {
-		if (rpc.second > current_max) {
-			current_max = rpc.second;
-			column_count = rpc.first;
-		} else if (rpc.second == current_max) {
-			// We pick the largest to untie
-			if (rpc.first > column_count) {
-				column_count = rpc.first;
-			}
-		}
-	}
-	return column_count;
-}
-
-bool ColumnCountResult::AddRow(ColumnCountResult &result, idx_t buffer_pos) {
-	result.InternalAddRow();
-	if (!result.states.EmptyLastValue()) {
-		idx_t col_count_idx = result.result_position;
-		for (idx_t i = 0; i < result.result_position + 1; i++) {
-			if (!result.column_counts[col_count_idx].last_value_always_empty) {
-				break;
-			}
-			result.column_counts[col_count_idx--].last_value_always_empty = false;
-		}
-	}
-	result.result_position++;
-	if (result.result_position >= result.result_size) {
-		// We sniffed enough rows
-		return true;
-	}
-	return false;
-}
-
-void ColumnCountResult::SetComment(ColumnCountResult &result, idx_t buffer_pos) {
-	if (!result.states.WasStandard()) {
-		result.cur_line_starts_as_comment = true;
-	}
-	result.comment = true;
-}
-
-bool ColumnCountResult::UnsetComment(ColumnCountResult &result, idx_t buffer_pos) {
-	// If we are unsetting a comment, it means this row started with a comment char.
-	// We add the row but tag it as a comment
-	bool done = result.AddRow(result, buffer_pos);
-	if (result.cur_line_starts_as_comment) {
-		result.column_counts[result.result_position - 1].is_comment = true;
-	} else {
-		result.column_counts[result.result_position - 1].is_mid_comment = true;
-	}
-	result.comment = false;
-	result.cur_line_starts_as_comment = false;
-	return done;
-}
-
-void ColumnCountResult::InvalidState(ColumnCountResult &result) {
-	result.result_position = 0;
-	result.error = true;
-}
-
-bool ColumnCountResult::EmptyLine(ColumnCountResult &result, idx_t buffer_pos) {
-	// nop
-	return false;
-}
-
-void ColumnCountResult::QuotedNewLine(ColumnCountResult &result) {
-	// nop
-}
-
-ColumnCountScanner::ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manager,
-                                       const shared_ptr<CSVStateMachine> &state_machine,
-                                       shared_ptr<CSVErrorHandler> error_handler, idx_t result_size_p,
-                                       CSVIterator iterator)
-    : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler), true, nullptr, iterator),
-      result(states, *state_machine, result_size_p), column_count(1), result_size(result_size_p) {
-	sniffing = true;
-}
-
-unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner() {
-	idx_t rows_to_skip =
-	    std::max(state_machine->dialect_options.skip_rows.GetValue(), state_machine->dialect_options.rows_until_header);
-	auto iterator = SkipCSVRows(buffer_manager, state_machine, rows_to_skip);
-	if (iterator.done) {
-		CSVIterator it {};
-		return make_uniq<StringValueScanner>(0U, buffer_manager, state_machine, error_handler, nullptr, true, it,
-		                                     result_size);
-	}
-	return make_uniq<StringValueScanner>(0U, buffer_manager, state_machine, error_handler, nullptr, true, iterator,
-	                                     result_size);
-}
-
-ColumnCountResult &ColumnCountScanner::ParseChunk() {
-	result.result_position = 0;
-	column_count = 1;
-	ParseChunkInternal(result);
-	return result;
-}
-
-ColumnCountResult &ColumnCountScanner::GetResult() {
-	return result;
-}
-
-void ColumnCountScanner::Initialize() {
-	states.Initialize();
-}
-
-void ColumnCountScanner::FinalizeChunkProcess() {
-	if (result.result_position == result.result_size || result.error) {
-		// We are done
-		return;
-	}
-	// We run until we have a full chunk, or we are done scanning
-	while (!FinishedFile() && result.result_position < result.result_size && !result.error) {
-		if (iterator.pos.buffer_pos == cur_buffer_handle->actual_size) {
-			// Move to next buffer
-			cur_buffer_handle = buffer_manager->GetBuffer(++iterator.pos.buffer_idx);
-			if (!cur_buffer_handle) {
-				buffer_handle_ptr = nullptr;
-				if (states.EmptyLine() || states.NewRow() || states.IsCurrentNewRow() || states.IsNotSet()) {
-					return;
-				}
-				// This means we reached the end of the file, we must add a last line if there is any to be added
-				if (result.comment) {
-					// If it's a comment we add the last line via unsetcomment
-					result.UnsetComment(result, NumericLimits<idx_t>::Maximum());
-				} else {
-					// OW, we do a regular AddRow
-					result.AddRow(result, NumericLimits<idx_t>::Maximum());
-				}
-				return;
-			}
-			iterator.pos.buffer_pos = 0;
-			buffer_handle_ptr = cur_buffer_handle->Ptr();
-		}
-		Process(result);
-	}
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/csv_schema.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/csv_schema.cpp
deleted file mode 100644
index f99e46a9a..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/scanner/csv_schema.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_schema.hpp"
-
-namespace duckdb {
-
-struct TypeIdxPair {
-	TypeIdxPair(LogicalType type_p, idx_t idx_p) : type(std::move(type_p)), idx(idx_p) {
-	}
-	TypeIdxPair() {
-	}
-	LogicalType type;
-	idx_t idx {};
-};
-
-// We only really care about types that can be set in the sniffer_auto, or are sniffed by default
-// If the user manually sets them, we should never get a cast issue from the sniffer!
-bool CSVSchema::CanWeCastIt(LogicalTypeId source, LogicalTypeId destination) {
-	if (destination == LogicalTypeId::VARCHAR || source == destination) {
-		// We can always cast to varchar
-		// And obviously don't have to do anything if they are equal.
-		return true;
-	}
-	switch (source) {
-	case LogicalTypeId::SQLNULL:
-		return true;
-	case LogicalTypeId::TINYINT:
-		return destination == LogicalTypeId::SMALLINT || destination == LogicalTypeId::INTEGER ||
-		       destination == LogicalTypeId::BIGINT || destination == LogicalTypeId::DECIMAL ||
-		       destination == LogicalTypeId::FLOAT || destination == LogicalTypeId::DOUBLE;
-	case LogicalTypeId::SMALLINT:
-		return destination == LogicalTypeId::INTEGER || destination == LogicalTypeId::BIGINT ||
-		       destination == LogicalTypeId::DECIMAL || destination == LogicalTypeId::FLOAT ||
-		       destination == LogicalTypeId::DOUBLE;
-	case LogicalTypeId::INTEGER:
-		return destination == LogicalTypeId::BIGINT || destination == LogicalTypeId::DECIMAL ||
-		       destination == LogicalTypeId::FLOAT || destination == LogicalTypeId::DOUBLE;
-	case LogicalTypeId::BIGINT:
-		return destination == LogicalTypeId::DECIMAL || destination == LogicalTypeId::FLOAT ||
-		       destination == LogicalTypeId::DOUBLE;
-	case LogicalTypeId::FLOAT:
-		return destination == LogicalTypeId::DOUBLE;
-	default:
-		return false;
-	}
-}
-
-void CSVSchema::MergeSchemas(CSVSchema &other, bool null_padding) {
-	// TODO: We could also merge names, maybe by giving preference to non-generated names?
-	const vector<LogicalType> candidates_by_specificity = {LogicalType::BOOLEAN, LogicalType::BIGINT,
-	                                                       LogicalType::DOUBLE, LogicalType::VARCHAR};
-	for (idx_t i = 0; i < columns.size() && i < other.columns.size(); i++) {
-		auto this_type = columns[i].type.id();
-		auto other_type = other.columns[i].type.id();
-		if (columns[i].type != other.columns[i].type) {
-			if (CanWeCastIt(this_type, other_type)) {
-				// If we can cast this to other, this becomes other
-				columns[i].type = other.columns[i].type;
-			} else if (!CanWeCastIt(other_type, this_type)) {
-				// If we can't cast this to other or other to this, we see which parent they can be both cast to
-				for (const auto &type : candidates_by_specificity) {
-					if (CanWeCastIt(this_type, type.id()) && CanWeCastIt(other_type, type.id())) {
-						columns[i].type = type;
-						break;
-					}
-				}
-			}
-		}
-	}
-
-	if (null_padding && other.columns.size() > columns.size()) {
-		for (idx_t i = columns.size(); i < other.columns.size(); i++) {
-			auto name = other.columns[i].name;
-			auto type = other.columns[i].type;
-			columns.push_back({name, type});
-			name_idx_map[name] = i;
-		}
-	}
-}
-
-CSVSchema::CSVSchema(vector<string> &names, vector<LogicalType> &types, const string &file_path, idx_t rows_read_p,
-                     const bool empty_p)
-    : rows_read(rows_read_p), empty(empty_p) {
-	Initialize(names, types, file_path);
-}
-
-void CSVSchema::Initialize(const vector<string> &names, const vector<LogicalType> &types, const string &file_path_p) {
-	if (!columns.empty()) {
-		throw InternalException("CSV Schema is already populated, this should not happen.");
-	}
-	file_path = file_path_p;
-	D_ASSERT(names.size() == types.size() && !names.empty());
-	for (idx_t i = 0; i < names.size(); i++) {
-		// Populate our little schema
-		auto name = names.at(i);
-		auto type = types.at(i);
-		columns.push_back({name, type});
-		name_idx_map[names[i]] = i;
-	}
-}
-
-vector<string> CSVSchema::GetNames() const {
-	vector<string> names;
-	for (auto &column : columns) {
-		names.push_back(column.name);
-	}
-	return names;
-}
-
-vector<LogicalType> CSVSchema::GetTypes() const {
-	vector<LogicalType> types;
-	for (auto &column : columns) {
-		types.push_back(column.type);
-	}
-	return types;
-}
-
-bool CSVSchema::Empty() const {
-	return columns.empty();
-}
-
-bool CSVSchema::MatchColumns(const CSVSchema &other) const {
-	return other.columns.size() == columns.size() || empty || other.empty;
-}
-
-string CSVSchema::GetPath() const {
-	return file_path;
-}
-
-idx_t CSVSchema::GetColumnCount() const {
-	return columns.size();
-}
-
-idx_t CSVSchema::GetRowsRead() const {
-	return rows_read;
-}
-
-bool CSVSchema::SchemasMatch(string &error_message, SnifferResult &sniffer_result, const string &cur_file_path,
-                             bool is_minimal_sniffer) const {
-	D_ASSERT(sniffer_result.names.size() == sniffer_result.return_types.size());
-	bool match = true;
-	unordered_map<string, TypeIdxPair> current_schema;
-
-	for (idx_t i = 0; i < sniffer_result.names.size(); i++) {
-		// Populate our little schema
-		current_schema[sniffer_result.names[i]] = {sniffer_result.return_types[i], i};
-	}
-	if (is_minimal_sniffer) {
-		auto min_sniffer = static_cast<AdaptiveSnifferResult &>(sniffer_result);
-		if (!min_sniffer.more_than_one_row) {
-			bool min_sniff_match = true;
-			// If we don't have more than one row, either the names must match or the types must match.
-			for (auto &column : columns) {
-				if (current_schema.find(column.name) == current_schema.end()) {
-					min_sniff_match = false;
-					break;
-				}
-			}
-			if (min_sniff_match) {
-				return true;
-			}
-			// Otherwise, the types must match.
-			min_sniff_match = true;
-			if (sniffer_result.return_types.size() == columns.size()) {
-				idx_t return_type_idx = 0;
-				for (auto &column : columns) {
-					if (column.type != sniffer_result.return_types[return_type_idx++]) {
-						min_sniff_match = false;
-						break;
-					}
-				}
-			} else {
-				min_sniff_match = false;
-			}
-			if (min_sniff_match) {
-				// If we got here, we have the right types but the wrong names, lets fix the names
-				idx_t sniff_name_idx = 0;
-				for (auto &column : columns) {
-					sniffer_result.names[sniff_name_idx++] = column.name;
-				}
-				return true;
-			}
-		}
-		// If we got to this point, the minimal sniffer doesn't match, we throw an error.
-	}
-	// Here we check if the schema of a given file matched our original schema
-	// We consider it's not a match if:
-	// 1. The file misses columns that were defined in the original schema.
-	// 2. They have a column match, but the types do not match.
-	std::ostringstream error;
-	error << "Schema mismatch between globbed files."
-	      << "\n";
-	error << "Main file schema: " << file_path << "\n";
-	error << "Current file: " << cur_file_path << "\n";
-
-	for (auto &column : columns) {
-		if (current_schema.find(column.name) == current_schema.end()) {
-			error << "Column with name: \"" << column.name << "\" is missing"
-			      << "\n";
-			match = false;
-		} else {
-			if (!CanWeCastIt(current_schema[column.name].type.id(), column.type.id())) {
-				error << "Column with name: \"" << column.name
-				      << "\" is expected to have type: " << column.type.ToString();
-				error << " But has type: " << current_schema[column.name].type.ToString() << "\n";
-				match = false;
-			}
-		}
-	}
-
-	// Lets suggest some potential fixes
-	error << "Potential Fix: Since your schema has a mismatch, consider setting union_by_name=true.";
-	if (!match) {
-		error_message = error.str();
-	}
-	return match;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp
deleted file mode 100644
index b0511bec6..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-
-namespace duckdb {
-
-CSVPosition::CSVPosition(idx_t buffer_idx_p, idx_t buffer_pos_p) : buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p) {
-}
-CSVPosition::CSVPosition() {
-}
-
-CSVBoundary::CSVBoundary(idx_t buffer_idx_p, idx_t buffer_pos_p, idx_t boundary_idx_p, idx_t end_pos_p)
-    : buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p), boundary_idx(boundary_idx_p), end_pos(end_pos_p) {
-}
-CSVBoundary::CSVBoundary() : buffer_idx(0), buffer_pos(0), boundary_idx(0), end_pos(NumericLimits<idx_t>::Maximum()) {
-}
-
-CSVIterator::CSVIterator() : is_set(false) {
-}
-
-void CSVBoundary::Print() const {
-#ifndef DUCKDB_DISABLE_PRINT
-	std::cout << "---Boundary: " << boundary_idx << " ---" << '\n';
-	std::cout << "Buffer Index: " << buffer_idx << '\n';
-	std::cout << "Buffer Pos: " << buffer_pos << '\n';
-	std::cout << "End Pos: " << end_pos << '\n';
-	std::cout << "------------" << end_pos << '\n';
-#endif
-}
-
-void CSVIterator::Print() const {
-#ifndef DUCKDB_DISABLE_PRINT
-	boundary.Print();
-	std::cout << "Is set: " << is_set << '\n';
-#endif
-}
-
-idx_t CSVIterator::BytesPerThread(const CSVReaderOptions &reader_options) {
-	const idx_t buffer_size = reader_options.buffer_size_option.GetValue();
-	const idx_t max_row_size = reader_options.maximum_line_size.GetValue();
-	const idx_t bytes_per_thread = buffer_size / CSVBuffer::ROWS_PER_BUFFER * ROWS_PER_THREAD;
-	if (bytes_per_thread < max_row_size) {
-		// If we are setting up the buffer size directly, we must make sure each thread will read the full buffer.
-		return max_row_size;
-	}
-	return bytes_per_thread;
-}
-
-bool CSVIterator::Next(CSVBufferManager &buffer_manager, const CSVReaderOptions &reader_options) {
-	if (!is_set) {
-		return false;
-	}
-	const auto bytes_per_thread = BytesPerThread(reader_options);
-
-	// If we are calling next this is not the first one anymore
-	first_one = false;
-	boundary.boundary_idx++;
-	// This is our start buffer
-	auto buffer = buffer_manager.GetBuffer(boundary.buffer_idx);
-	if (buffer->is_last_buffer && boundary.buffer_pos + bytes_per_thread > buffer->actual_size) {
-		// 1) We are done with the current file
-		return false;
-	} else if (boundary.buffer_pos + bytes_per_thread >= buffer->actual_size) {
-		// 2) We still have data to scan in this file, we set the iterator accordingly.
-		// We must move the buffer
-		boundary.buffer_idx++;
-		boundary.buffer_pos = 0;
-		// Verify this buffer really exists
-		auto next_buffer = buffer_manager.GetBuffer(boundary.buffer_idx);
-		if (!next_buffer) {
-			return false;
-		}
-
-	} else {
-		// 3) We are not done with the current buffer, hence we just move where we start within the buffer
-		boundary.buffer_pos += bytes_per_thread;
-	}
-	boundary.end_pos = boundary.buffer_pos + bytes_per_thread;
-	SetCurrentPositionToBoundary();
-	return true;
-}
-
-bool CSVIterator::IsBoundarySet() const {
-	return is_set;
-}
-idx_t CSVIterator::GetEndPos() const {
-	return boundary.end_pos;
-}
-
-idx_t CSVIterator::GetBufferIdx() const {
-	return pos.buffer_idx;
-}
-
-idx_t CSVIterator::GetBoundaryIdx() const {
-	return boundary.boundary_idx;
-}
-
-void CSVIterator::SetCurrentPositionToBoundary() {
-	pos.buffer_idx = boundary.buffer_idx;
-	pos.buffer_pos = boundary.buffer_pos;
-}
-
-void CSVIterator::SetCurrentBoundaryToPosition(bool single_threaded, const CSVReaderOptions &reader_options) {
-	if (single_threaded) {
-		is_set = false;
-		return;
-	}
-	const auto bytes_per_thread = BytesPerThread(reader_options);
-
-	boundary.buffer_idx = pos.buffer_idx;
-	if (pos.buffer_pos == 0) {
-		boundary.end_pos = bytes_per_thread;
-	} else {
-		boundary.end_pos = ((pos.buffer_pos + bytes_per_thread - 1) / bytes_per_thread) * bytes_per_thread;
-	}
-
-	boundary.buffer_pos = boundary.end_pos - bytes_per_thread;
-	is_set = true;
-}
-
-void CSVIterator::SetStart(idx_t start) {
-	boundary.buffer_pos = start;
-}
-
-void CSVIterator::SetEnd(idx_t pos) {
-	boundary.end_pos = pos;
-}
-
-void CSVIterator::CheckIfDone() {
-	if (IsBoundarySet() && (pos.buffer_idx > boundary.buffer_idx || pos.buffer_pos > boundary.buffer_pos)) {
-		done = true;
-	}
-}
-
-idx_t CSVIterator::GetGlobalCurrentPos() const {
-	return pos.buffer_pos + buffer_size * pos.buffer_idx;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp
deleted file mode 100644
index 3afe22d6b..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/column_count_scanner.hpp"
-
-namespace duckdb {
-
-SkipResult::SkipResult(CSVStates &states, CSVStateMachine &state_machine, idx_t rows_to_skip_p)
-    : ScannerResult(states, state_machine, STANDARD_VECTOR_SIZE), rows_to_skip(rows_to_skip_p) {
-}
-
-void SkipResult::AddValue(SkipResult &result, const idx_t buffer_pos) {
-	// nop
-}
-
-inline void SkipResult::InternalAddRow() {
-	row_count++;
-}
-
-void SkipResult::QuotedNewLine(SkipResult &result) {
-	// nop
-}
-
-bool SkipResult::UnsetComment(SkipResult &result, idx_t buffer_pos) {
-	// If we are unsetting a comment, it means this row started with a comment char.
-	// We add the row but tag it as a comment
-	bool done = result.AddRow(result, buffer_pos);
-	result.comment = false;
-	return done;
-}
-
-bool SkipResult::AddRow(SkipResult &result, const idx_t buffer_pos) {
-	result.InternalAddRow();
-	if (result.row_count >= result.rows_to_skip) {
-		// We skipped enough rows
-		return true;
-	}
-	return false;
-}
-
-void SkipResult::InvalidState(SkipResult &result) {
-	// nop
-}
-
-bool SkipResult::EmptyLine(SkipResult &result, const idx_t buffer_pos) {
-	if (result.state_machine.dialect_options.num_cols == 1) {
-		return AddRow(result, buffer_pos);
-	}
-	return false;
-}
-
-SkipScanner::SkipScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
-                         shared_ptr<CSVErrorHandler> error_handler, idx_t rows_to_skip)
-    : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler)),
-      result(states, *state_machine, rows_to_skip) {
-}
-
-SkipResult &SkipScanner::ParseChunk() {
-	ParseChunkInternal(result);
-	return result;
-}
-
-SkipResult &SkipScanner::GetResult() {
-	return result;
-}
-
-void SkipScanner::Initialize() {
-	states.Initialize();
-}
-
-void SkipScanner::FinalizeChunkProcess() {
-	// We continue skipping until we skipped enough rows, or we have nothing else to read.
-	while (!FinishedFile() && result.row_count < result.rows_to_skip) {
-		cur_buffer_handle = buffer_manager->GetBuffer(++iterator.pos.buffer_idx);
-		if (cur_buffer_handle) {
-			iterator.pos.buffer_pos = 0;
-			buffer_handle_ptr = cur_buffer_handle->Ptr();
-			Process(result);
-		}
-	}
-	// Skip Carriage Return
-	if (state_machine->options.dialect_options.state_machine_options.new_line == NewLineIdentifier::CARRY_ON &&
-	    states.states[1] == CSVState::CARRIAGE_RETURN) {
-		iterator.pos.buffer_pos++;
-	}
-	iterator.done = FinishedFile();
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp
deleted file mode 100644
index c1ab79dfe..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp
+++ /dev/null
@@ -1,1839 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
-
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/common/operator/double_cast_operator.hpp"
-#include "duckdb/common/operator/integer_cast_operator.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_casting.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-constexpr idx_t StringValueScanner::LINE_FINDER_ID;
-
-StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_machine,
-                                     const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator,
-                                     idx_t result_size_p, idx_t buffer_position, CSVErrorHandler &error_hander_p,
-                                     CSVIterator &iterator_p, bool store_line_size_p,
-                                     shared_ptr<CSVFileScan> csv_file_scan_p, idx_t &lines_read_p, bool sniffing_p,
-                                     string path_p, idx_t scan_id)
-    : ScannerResult(states, state_machine, result_size_p),
-      number_of_columns(NumericCast<uint32_t>(state_machine.dialect_options.num_cols)),
-      null_padding(state_machine.options.null_padding), ignore_errors(state_machine.options.ignore_errors.GetValue()),
-      extra_delimiter_bytes(state_machine.dialect_options.state_machine_options.delimiter.GetValue().size() - 1),
-      error_handler(error_hander_p), iterator(iterator_p), store_line_size(store_line_size_p),
-      csv_file_scan(std::move(csv_file_scan_p)), lines_read(lines_read_p),
-      current_errors(scan_id, state_machine.options.IgnoreErrors()), sniffing(sniffing_p), path(std::move(path_p)) {
-	// Vector information
-	D_ASSERT(number_of_columns > 0);
-	if (!buffer_handle) {
-		// It Was Over Before It Even Began
-		D_ASSERT(iterator.done);
-		return;
-	}
-	buffer_handles[buffer_handle->buffer_idx] = buffer_handle;
-	// Buffer Information
-	buffer_ptr = buffer_handle->Ptr();
-	buffer_size = buffer_handle->actual_size;
-	last_position = {buffer_handle->buffer_idx, buffer_position, buffer_size};
-	requested_size = buffer_handle->requested_size;
-	// Current Result information
-	current_line_position.begin = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, buffer_handle->actual_size};
-	current_line_position.end = current_line_position.begin;
-	// Fill out Parse Types
-	vector<LogicalType> logical_types;
-	parse_types = make_unsafe_uniq_array<ParseTypeInfo>(number_of_columns);
-	LogicalType varchar_type = LogicalType::VARCHAR;
-	if (!csv_file_scan) {
-		for (idx_t i = 0; i < number_of_columns; i++) {
-			parse_types[i] = ParseTypeInfo(varchar_type, true);
-			logical_types.emplace_back(LogicalType::VARCHAR);
-			string name = "Column_" + to_string(i);
-			names.emplace_back(name);
-		}
-	} else {
-		if (csv_file_scan->file_types.size() > number_of_columns) {
-			throw InvalidInputException(
-			    "Mismatch between the number of columns (%d) in the CSV file and what is expected in the scanner (%d).",
-			    number_of_columns, csv_file_scan->file_types.size());
-		}
-		bool icu_loaded = csv_file_scan->buffer_manager->context.db->ExtensionIsLoaded("icu");
-		for (idx_t i = 0; i < csv_file_scan->file_types.size(); i++) {
-			auto &type = csv_file_scan->file_types[i];
-			if (type.IsJSONType()) {
-				type = LogicalType::VARCHAR;
-			}
-			if (StringValueScanner::CanDirectlyCast(type, icu_loaded)) {
-				parse_types[i] = ParseTypeInfo(type, true);
-				logical_types.emplace_back(type);
-			} else {
-				parse_types[i] = ParseTypeInfo(varchar_type, type.id() == LogicalTypeId::VARCHAR || type.IsNested());
-				logical_types.emplace_back(LogicalType::VARCHAR);
-			}
-		}
-		names = csv_file_scan->names;
-		if (!csv_file_scan->projected_columns.empty()) {
-			projecting_columns = false;
-			projected_columns = make_unsafe_uniq_array<bool>(number_of_columns);
-			for (idx_t col_idx = 0; col_idx < number_of_columns; col_idx++) {
-				if (csv_file_scan->projected_columns.find(col_idx) == csv_file_scan->projected_columns.end()) {
-					// Column is not projected
-					projecting_columns = true;
-					projected_columns[col_idx] = false;
-				} else {
-					projected_columns[col_idx] = true;
-				}
-			}
-		}
-		if (!projecting_columns) {
-			for (idx_t j = logical_types.size(); j < number_of_columns; j++) {
-				// This can happen if we have sneaky null columns at the end that we wish to ignore
-				parse_types[j] = ParseTypeInfo(varchar_type, true);
-				logical_types.emplace_back(LogicalType::VARCHAR);
-			}
-		}
-	}
-
-	// Initialize Parse Chunk
-	parse_chunk.Initialize(buffer_allocator, logical_types, result_size);
-	for (auto &col : parse_chunk.data) {
-		vector_ptr.push_back(FlatVector::GetData<string_t>(col));
-		validity_mask.push_back(&FlatVector::Validity(col));
-	}
-
-	// Setup the NullStr information
-	null_str_count = state_machine.options.null_str.size();
-	null_str_ptr = make_unsafe_uniq_array_uninitialized<const char *>(null_str_count);
-	null_str_size = make_unsafe_uniq_array_uninitialized<idx_t>(null_str_count);
-	for (idx_t i = 0; i < null_str_count; i++) {
-		null_str_ptr[i] = state_machine.options.null_str[i].c_str();
-		null_str_size[i] = state_machine.options.null_str[i].size();
-	}
-	date_format = state_machine.options.dialect_options.date_format.at(LogicalTypeId::DATE).GetValue();
-	timestamp_format = state_machine.options.dialect_options.date_format.at(LogicalTypeId::TIMESTAMP).GetValue();
-	decimal_separator = state_machine.options.decimal_separator[0];
-
-	if (iterator.first_one) {
-		lines_read +=
-		    state_machine.dialect_options.skip_rows.GetValue() + state_machine.dialect_options.header.GetValue();
-		if (lines_read == 0) {
-			SkipBOM();
-		}
-	}
-}
-
-StringValueResult::~StringValueResult() {
-	// We have to insert the lines read by this scanner
-	error_handler.Insert(iterator.GetBoundaryIdx(), lines_read);
-	if (!iterator.done) {
-		// Some operators, like Limit, might cause a future error to incorrectly report the wrong error line
-		// Better to print nothing to print something wrong
-		error_handler.DontPrintErrorLine();
-	}
-}
-
-inline bool IsValueNull(const char *null_str_ptr, const char *value_ptr, const idx_t size) {
-	for (idx_t i = 0; i < size; i++) {
-		if (null_str_ptr[i] != value_ptr[i]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool StringValueResult::HandleTooManyColumnsError(const char *value_ptr, const idx_t size) {
-	if (cur_col_id >= number_of_columns) {
-		bool error = true;
-		if (cur_col_id == number_of_columns && ((quoted && state_machine.options.allow_quoted_nulls) || !quoted)) {
-			// we make an exception if the first over-value is null
-			bool is_value_null = false;
-			for (idx_t i = 0; i < null_str_count; i++) {
-				is_value_null = is_value_null || IsValueNull(null_str_ptr[i], value_ptr, size);
-			}
-			error = !is_value_null;
-		}
-		if (error) {
-			// We error pointing to the current value error.
-			current_errors.Insert(TOO_MANY_COLUMNS, cur_col_id, chunk_col_id, last_position);
-			cur_col_id++;
-		}
-		// We had an error
-		return true;
-	}
-	return false;
-}
-
-void StringValueResult::SetComment(StringValueResult &result, idx_t buffer_pos) {
-	if (!result.comment) {
-		result.position_before_comment = buffer_pos;
-		result.comment = true;
-	}
-}
-
-bool StringValueResult::UnsetComment(StringValueResult &result, idx_t buffer_pos) {
-	bool done = false;
-	if (result.last_position.buffer_pos < result.position_before_comment) {
-		bool all_empty = true;
-		for (idx_t i = result.last_position.buffer_pos; i < result.position_before_comment; i++) {
-			if (result.buffer_ptr[i] != ' ') {
-				all_empty = false;
-				break;
-			}
-		}
-		if (!all_empty) {
-			done = AddRow(result, result.position_before_comment);
-		}
-	} else {
-		if (result.cur_col_id != 0) {
-			done = AddRow(result, result.position_before_comment);
-		}
-	}
-	if (result.number_of_rows == 0) {
-		result.first_line_is_comment = true;
-	}
-	result.comment = false;
-	if (result.state_machine.dialect_options.state_machine_options.new_line.GetValue() != NewLineIdentifier::CARRY_ON) {
-		result.last_position.buffer_pos = buffer_pos + 1;
-	} else {
-		result.last_position.buffer_pos = buffer_pos + 2;
-	}
-	result.cur_col_id = 0;
-	result.chunk_col_id = 0;
-	return done;
-}
-
-static void SanitizeError(string &value) {
-	std::vector<char> char_array(value.begin(), value.end());
-	char_array.push_back('\0'); // Null-terminate the character array
-	Utf8Proc::MakeValid(&char_array[0], char_array.size());
-	value = {char_array.begin(), char_array.end() - 1};
-}
-
-void StringValueResult::AddValueToVector(const char *value_ptr, const idx_t size, bool allocate) {
-	if (HandleTooManyColumnsError(value_ptr, size)) {
-		return;
-	}
-	if (cur_col_id >= number_of_columns) {
-		bool error = true;
-		if (cur_col_id == number_of_columns && ((quoted && state_machine.options.allow_quoted_nulls) || !quoted)) {
-			// we make an exception if the first over-value is null
-			bool is_value_null = false;
-			for (idx_t i = 0; i < null_str_count; i++) {
-				is_value_null = is_value_null || IsValueNull(null_str_ptr[i], value_ptr, size);
-			}
-			error = !is_value_null;
-		}
-		if (error) {
-			// We error pointing to the current value error.
-			current_errors.Insert(TOO_MANY_COLUMNS, cur_col_id, chunk_col_id, last_position);
-			cur_col_id++;
-		}
-		return;
-	}
-
-	if (projecting_columns) {
-		if (!projected_columns[cur_col_id]) {
-			cur_col_id++;
-			return;
-		}
-	}
-
-	if (((quoted && state_machine.options.allow_quoted_nulls) || !quoted)) {
-		// Check for the occurrence of escaped null string like \N only if RFC 4180 conformance is disabled
-		const bool check_unquoted_escaped_null =
-		    state_machine.state_machine_options.rfc_4180.GetValue() == false && escaped && !quoted && size == 1;
-		for (idx_t i = 0; i < null_str_count; i++) {
-			bool is_null = false;
-			if (null_str_size[i] == 2 && null_str_ptr[i][0] == state_machine.state_machine_options.escape.GetValue()) {
-				is_null = check_unquoted_escaped_null && null_str_ptr[i][1] == value_ptr[0];
-			} else if (size == null_str_size[i] && !check_unquoted_escaped_null) {
-				is_null = IsValueNull(null_str_ptr[i], value_ptr, size);
-			}
-			if (is_null) {
-				bool empty = false;
-				if (chunk_col_id < state_machine.options.force_not_null.size()) {
-					empty = state_machine.options.force_not_null[chunk_col_id];
-				}
-				if (empty) {
-					if (parse_types[chunk_col_id].type_id != LogicalTypeId::VARCHAR) {
-						// If it is not a varchar, empty values are not accepted, we must error.
-						current_errors.Insert(CAST_ERROR, cur_col_id, chunk_col_id, last_position);
-					} else {
-						static_cast<string_t *>(vector_ptr[chunk_col_id])[number_of_rows] = string_t();
-					}
-				} else {
-					if (chunk_col_id == number_of_columns) {
-						// We check for a weird case, where we ignore an extra value, if it is a null value
-						return;
-					}
-					validity_mask[chunk_col_id]->SetInvalid(static_cast<idx_t>(number_of_rows));
-				}
-				cur_col_id++;
-				chunk_col_id++;
-				return;
-			}
-		}
-	}
-	bool success = true;
-	switch (parse_types[chunk_col_id].type_id) {
-	case LogicalTypeId::BOOLEAN:
-		success =
-		    TryCastStringBool(value_ptr, size, static_cast<bool *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::TINYINT:
-		success = TrySimpleIntegerCast(value_ptr, size, static_cast<int8_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-		                               false);
-		break;
-	case LogicalTypeId::SMALLINT:
-		success = TrySimpleIntegerCast(value_ptr, size,
-		                               static_cast<int16_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::INTEGER:
-		success = TrySimpleIntegerCast(value_ptr, size,
-		                               static_cast<int32_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::BIGINT:
-		success = TrySimpleIntegerCast(value_ptr, size,
-		                               static_cast<int64_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::UTINYINT:
-		success = TrySimpleIntegerCast<uint8_t, false>(
-		    value_ptr, size, static_cast<uint8_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::USMALLINT:
-		success = TrySimpleIntegerCast<uint16_t, false>(
-		    value_ptr, size, static_cast<uint16_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::UINTEGER:
-		success = TrySimpleIntegerCast<uint32_t, false>(
-		    value_ptr, size, static_cast<uint32_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::UBIGINT:
-		success = TrySimpleIntegerCast<uint64_t, false>(
-		    value_ptr, size, static_cast<uint64_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	case LogicalTypeId::DOUBLE:
-		success =
-		    TryDoubleCast<double>(value_ptr, size, static_cast<double *>(vector_ptr[chunk_col_id])[number_of_rows],
-		                          false, state_machine.options.decimal_separator[0]);
-		break;
-	case LogicalTypeId::FLOAT:
-		success = TryDoubleCast<float>(value_ptr, size, static_cast<float *>(vector_ptr[chunk_col_id])[number_of_rows],
-		                               false, state_machine.options.decimal_separator[0]);
-		break;
-	case LogicalTypeId::DATE: {
-		if (!date_format.Empty()) {
-			success = date_format.TryParseDate(value_ptr, size,
-			                                   static_cast<date_t *>(vector_ptr[chunk_col_id])[number_of_rows]);
-		} else {
-			idx_t pos;
-			bool special;
-			success = Date::TryConvertDate(value_ptr, size, pos,
-			                               static_cast<date_t *>(vector_ptr[chunk_col_id])[number_of_rows], special,
-			                               false) == DateCastResult::SUCCESS;
-		}
-		break;
-	}
-	case LogicalTypeId::TIME: {
-		idx_t pos;
-		success = Time::TryConvertTime(value_ptr, size, pos,
-		                               static_cast<dtime_t *>(vector_ptr[chunk_col_id])[number_of_rows], false);
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		if (!timestamp_format.Empty()) {
-			success = timestamp_format.TryParseTimestamp(
-			    value_ptr, size, static_cast<timestamp_t *>(vector_ptr[chunk_col_id])[number_of_rows]);
-		} else {
-			success = Timestamp::TryConvertTimestamp(
-			              value_ptr, size, static_cast<timestamp_t *>(vector_ptr[chunk_col_id])[number_of_rows]) ==
-			          TimestampCastResult::SUCCESS;
-		}
-		break;
-	}
-	case LogicalTypeId::DECIMAL: {
-		if (decimal_separator == ',') {
-			switch (parse_types[chunk_col_id].internal_type) {
-			case PhysicalType::INT16:
-				success = TryDecimalStringCast<int16_t, ','>(
-				    value_ptr, size, static_cast<int16_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				    parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			case PhysicalType::INT32:
-				success = TryDecimalStringCast<int32_t, ','>(
-				    value_ptr, size, static_cast<int32_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				    parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			case PhysicalType::INT64:
-				success = TryDecimalStringCast<int64_t, ','>(
-				    value_ptr, size, static_cast<int64_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				    parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			case PhysicalType::INT128:
-				success = TryDecimalStringCast<hugeint_t, ','>(
-				    value_ptr, size, static_cast<hugeint_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				    parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			default:
-				throw InternalException("Invalid Physical Type for Decimal Value. Physical Type: " +
-				                        TypeIdToString(parse_types[chunk_col_id].internal_type));
-			}
-
-		} else if (decimal_separator == '.') {
-			switch (parse_types[chunk_col_id].internal_type) {
-			case PhysicalType::INT16:
-				success = TryDecimalStringCast(value_ptr, size,
-				                               static_cast<int16_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				                               parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			case PhysicalType::INT32:
-				success = TryDecimalStringCast(value_ptr, size,
-				                               static_cast<int32_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				                               parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			case PhysicalType::INT64:
-				success = TryDecimalStringCast(value_ptr, size,
-				                               static_cast<int64_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				                               parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			case PhysicalType::INT128:
-				success = TryDecimalStringCast(value_ptr, size,
-				                               static_cast<hugeint_t *>(vector_ptr[chunk_col_id])[number_of_rows],
-				                               parse_types[chunk_col_id].width, parse_types[chunk_col_id].scale);
-				break;
-			default:
-				throw InternalException("Invalid Physical Type for Decimal Value. Physical Type: " +
-				                        TypeIdToString(parse_types[chunk_col_id].internal_type));
-			}
-		} else {
-			throw InvalidInputException("Decimals can only have ',' and '.' as decimal separators");
-		}
-		break;
-	}
-	default: {
-		// By default, we add a string
-		// We only evaluate if a string is utf8 valid, if it's actually a varchar
-		if (parse_types[chunk_col_id].validate_utf8 &&
-		    !Utf8Proc::IsValid(value_ptr, UnsafeNumericCast<uint32_t>(size))) {
-			bool force_error = !state_machine.options.ignore_errors.GetValue() && sniffing;
-			// Invalid unicode, we must error
-			if (force_error) {
-				HandleUnicodeError(cur_col_id, last_position);
-			}
-			// If we got here, we are ignoring errors, hence we must ignore this line.
-			current_errors.Insert(INVALID_UNICODE, cur_col_id, chunk_col_id, last_position);
-			break;
-		}
-		if (allocate) {
-			// If it's a value produced over multiple buffers, we must allocate
-			static_cast<string_t *>(vector_ptr[chunk_col_id])[number_of_rows] = StringVector::AddStringOrBlob(
-			    parse_chunk.data[chunk_col_id], string_t(value_ptr, UnsafeNumericCast<uint32_t>(size)));
-		} else {
-			static_cast<string_t *>(vector_ptr[chunk_col_id])[number_of_rows] =
-			    string_t(value_ptr, UnsafeNumericCast<uint32_t>(size));
-		}
-		break;
-	}
-	}
-	if (!success) {
-		current_errors.Insert(CAST_ERROR, cur_col_id, chunk_col_id, last_position);
-		if (!state_machine.options.IgnoreErrors()) {
-			// We have to write the cast error message.
-			std::ostringstream error;
-			// Casting Error Message
-			error << "Could not convert string \"" << std::string(value_ptr, size) << "\" to \'"
-			      << LogicalTypeIdToString(parse_types[chunk_col_id].type_id) << "\'";
-			auto error_string = error.str();
-			SanitizeError(error_string);
-
-			current_errors.ModifyErrorMessageOfLastError(error_string);
-		}
-	}
-	cur_col_id++;
-	chunk_col_id++;
-}
-
-DataChunk &StringValueResult::ToChunk() {
-	if (number_of_rows < 0) {
-		throw InternalException("CSVScanner: ToChunk() function. Has a negative number of rows, this indicates an "
-		                        "issue with the error handler.");
-	}
-	parse_chunk.SetCardinality(static_cast<idx_t>(number_of_rows));
-	return parse_chunk;
-}
-
-void StringValueResult::Reset() {
-	if (number_of_rows == 0) {
-		return;
-	}
-	number_of_rows = 0;
-	cur_col_id = 0;
-	chunk_col_id = 0;
-	for (auto &v : validity_mask) {
-		v->SetAllValid(result_size);
-	}
-	// We keep a reference to the buffer from our current iteration if it already exists
-	shared_ptr<CSVBufferHandle> cur_buffer;
-	if (buffer_handles.find(iterator.GetBufferIdx()) != buffer_handles.end()) {
-		cur_buffer = buffer_handles[iterator.GetBufferIdx()];
-	}
-	buffer_handles.clear();
-	if (cur_buffer) {
-		buffer_handles[cur_buffer->buffer_idx] = cur_buffer;
-	}
-	current_errors.Reset();
-	borked_rows.clear();
-}
-
-void StringValueResult::AddQuotedValue(StringValueResult &result, const idx_t buffer_pos) {
-	if (!result.unquoted) {
-		result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, result.last_position);
-	}
-	AddPossiblyEscapedValue(result, buffer_pos, result.buffer_ptr + result.quoted_position + 1,
-	                        buffer_pos - result.quoted_position - 2, buffer_pos < result.last_position.buffer_pos + 2);
-	result.quoted = false;
-}
-
-void StringValueResult::AddPossiblyEscapedValue(StringValueResult &result, const idx_t buffer_pos,
-                                                const char *value_ptr, const idx_t length, const bool empty) {
-	if (result.escaped) {
-		if (result.projecting_columns) {
-			if (!result.projected_columns[result.cur_col_id]) {
-				result.cur_col_id++;
-				result.escaped = false;
-				return;
-			}
-		}
-		if (!result.HandleTooManyColumnsError(value_ptr, length)) {
-			// If it's an escaped value we have to remove all the escapes, this is not really great
-			// If we are going to escape, this vector must be a varchar vector
-			if (result.parse_chunk.data[result.chunk_col_id].GetType() != LogicalType::VARCHAR) {
-				result.current_errors.Insert(CAST_ERROR, result.cur_col_id, result.chunk_col_id, result.last_position);
-				if (!result.state_machine.options.IgnoreErrors()) {
-					// We have to write the cast error message.
-					std::ostringstream error;
-					// Casting Error Message
-
-					error << "Could not convert string \"" << std::string(value_ptr, length) << "\" to \'"
-					      << LogicalTypeIdToString(result.parse_types[result.chunk_col_id].type_id) << "\'";
-					auto error_string = error.str();
-					SanitizeError(error_string);
-					result.current_errors.ModifyErrorMessageOfLastError(error_string);
-				}
-				result.cur_col_id++;
-				result.chunk_col_id++;
-			} else {
-				auto value = StringValueScanner::RemoveEscape(
-				    value_ptr, length, result.state_machine.dialect_options.state_machine_options.escape.GetValue(),
-				    result.state_machine.dialect_options.state_machine_options.quote.GetValue(),
-				    result.parse_chunk.data[result.chunk_col_id]);
-				result.AddValueToVector(value.GetData(), value.GetSize());
-			}
-		}
-	} else {
-		if (empty) {
-			// empty value
-			auto value = string_t();
-			result.AddValueToVector(value.GetData(), value.GetSize());
-		} else {
-			result.AddValueToVector(value_ptr, length);
-		}
-	}
-	result.escaped = false;
-}
-
-inline idx_t StringValueResult::HandleMultiDelimiter(const idx_t buffer_pos) const {
-	idx_t size = buffer_pos - last_position.buffer_pos - extra_delimiter_bytes;
-	if (buffer_pos < last_position.buffer_pos + extra_delimiter_bytes) {
-		// If this is a scenario where the value is null, that is fine (e.g., delim = '||' and line is: A||)
-		if (buffer_pos == last_position.buffer_pos) {
-			size = 0;
-		} else {
-			// Otherwise something went wrong.
-			throw InternalException(
-			    "Value size is lower than the number of extra delimiter bytes in the HandleMultiDelimiter(). "
-			    "buffer_pos = %d, last_position.buffer_pos = %d, extra_delimiter_bytes = %d",
-			    buffer_pos, last_position.buffer_pos, extra_delimiter_bytes);
-		}
-	}
-	return size;
-}
-
-void StringValueResult::AddValue(StringValueResult &result, const idx_t buffer_pos) {
-	if (result.last_position.buffer_pos > buffer_pos) {
-		return;
-	}
-	if (result.quoted) {
-		AddQuotedValue(result, buffer_pos - result.extra_delimiter_bytes);
-	} else if (result.escaped) {
-		AddPossiblyEscapedValue(result, buffer_pos, result.buffer_ptr + result.last_position.buffer_pos,
-		                        buffer_pos - result.last_position.buffer_pos, false);
-	} else {
-		result.AddValueToVector(result.buffer_ptr + result.last_position.buffer_pos,
-		                        result.HandleMultiDelimiter(buffer_pos));
-	}
-	result.last_position.buffer_pos = buffer_pos + 1;
-}
-
-void StringValueResult::HandleUnicodeError(idx_t col_idx, LinePosition &error_position) {
-
-	bool first_nl;
-	auto borked_line = current_line_position.ReconstructCurrentLine(first_nl, buffer_handles, PrintErrorLine());
-	LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read);
-	if (current_line_position.begin == error_position) {
-		auto csv_error = CSVError::InvalidUTF8(state_machine.options, col_idx, lines_per_batch, borked_line,
-		                                       current_line_position.begin.GetGlobalPosition(requested_size, first_nl),
-		                                       error_position.GetGlobalPosition(requested_size, first_nl), path);
-		error_handler.Error(csv_error, true);
-	} else {
-		auto csv_error = CSVError::InvalidUTF8(state_machine.options, col_idx, lines_per_batch, borked_line,
-		                                       current_line_position.begin.GetGlobalPosition(requested_size, first_nl),
-		                                       error_position.GetGlobalPosition(requested_size), path);
-		error_handler.Error(csv_error, true);
-	}
-}
-
-bool LineError::HandleErrors(StringValueResult &result) {
-	bool skip_sniffing = false;
-	for (auto &cur_error : current_errors) {
-		if (cur_error.type == CSVErrorType::INVALID_UNICODE) {
-			skip_sniffing = true;
-		}
-	}
-	skip_sniffing = result.sniffing && skip_sniffing;
-
-	if ((ignore_errors || skip_sniffing) && is_error_in_line && !result.figure_out_new_line) {
-		result.RemoveLastLine();
-		Reset();
-		return true;
-	}
-	// Reconstruct CSV Line
-	for (auto &cur_error : current_errors) {
-		LinesPerBoundary lines_per_batch(result.iterator.GetBoundaryIdx(), result.lines_read);
-		bool first_nl = false;
-		auto borked_line = result.current_line_position.ReconstructCurrentLine(first_nl, result.buffer_handles,
-		                                                                       result.PrintErrorLine());
-		CSVError csv_error;
-		auto col_idx = cur_error.col_idx;
-		auto &line_pos = cur_error.error_position;
-
-		switch (cur_error.type) {
-		case TOO_MANY_COLUMNS:
-		case TOO_FEW_COLUMNS:
-			if (result.current_line_position.begin == line_pos) {
-				csv_error = CSVError::IncorrectColumnAmountError(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size, first_nl), result.path);
-			} else {
-				csv_error = CSVError::IncorrectColumnAmountError(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size), result.path);
-			}
-			break;
-		case INVALID_UNICODE: {
-			if (result.current_line_position.begin == line_pos) {
-				csv_error = CSVError::InvalidUTF8(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size, first_nl), result.path);
-			} else {
-				csv_error = CSVError::InvalidUTF8(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size), result.path);
-			}
-			break;
-		}
-		case UNTERMINATED_QUOTES:
-			if (result.current_line_position.begin == line_pos) {
-				csv_error = CSVError::UnterminatedQuotesError(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size, first_nl), result.path);
-			} else {
-				csv_error = CSVError::UnterminatedQuotesError(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size), result.path);
-			}
-			break;
-		case CAST_ERROR:
-			if (result.current_line_position.begin == line_pos) {
-				csv_error = CSVError::CastError(
-				    result.state_machine.options, result.names[cur_error.col_idx], cur_error.error_message,
-				    cur_error.col_idx, borked_line, lines_per_batch,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size, first_nl),
-				    result.parse_types[cur_error.chunk_idx].type_id, result.path);
-			} else {
-				csv_error = CSVError::CastError(
-				    result.state_machine.options, result.names[cur_error.col_idx], cur_error.error_message,
-				    cur_error.col_idx, borked_line, lines_per_batch,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size), result.parse_types[cur_error.chunk_idx].type_id,
-				    result.path);
-			}
-			break;
-		case MAXIMUM_LINE_SIZE:
-			csv_error = CSVError::LineSizeError(
-			    result.state_machine.options, lines_per_batch, borked_line,
-			    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl), result.path);
-			break;
-		case INVALID_STATE:
-			if (result.current_line_position.begin == line_pos) {
-				csv_error = CSVError::InvalidState(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size, first_nl), result.path);
-			} else {
-				csv_error = CSVError::InvalidState(
-				    result.state_machine.options, col_idx, lines_per_batch, borked_line,
-				    result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl),
-				    line_pos.GetGlobalPosition(result.requested_size), result.path);
-			}
-			break;
-		default:
-			throw InvalidInputException("CSV Error not allowed when inserting row");
-		}
-		result.error_handler.Error(csv_error);
-	}
-	if (is_error_in_line && scan_id != StringValueScanner::LINE_FINDER_ID) {
-		if (result.sniffing) {
-			// If we are sniffing we just remove the line
-			result.RemoveLastLine();
-		} else {
-			// Otherwise, we add it to the borked rows to remove it later and just cleanup the column variables.
-			result.borked_rows.insert(static_cast<idx_t>(result.number_of_rows));
-			result.cur_col_id = 0;
-			result.chunk_col_id = 0;
-		}
-		Reset();
-		return true;
-	}
-	return false;
-}
-
-void StringValueResult::QuotedNewLine(StringValueResult &result) {
-	result.quoted_new_line = true;
-}
-
-void StringValueResult::NullPaddingQuotedNewlineCheck() const {
-	// We do some checks for null_padding correctness
-	if (state_machine.options.null_padding && iterator.IsBoundarySet() && quoted_new_line) {
-		// If we have null_padding set, we found a quoted new line, we are scanning the file in parallel; We error.
-		LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read);
-		auto csv_error = CSVError::NullPaddingFail(state_machine.options, lines_per_batch, path);
-		error_handler.Error(csv_error);
-	}
-}
-
-//! Reconstructs the current line to be used in error messages
-string FullLinePosition::ReconstructCurrentLine(bool &first_char_nl,
-                                                unordered_map<idx_t, shared_ptr<CSVBufferHandle>> &buffer_handles,
-                                                bool reconstruct_line) const {
-	if (!reconstruct_line) {
-		return {};
-	}
-	string result;
-	if (end.buffer_idx == begin.buffer_idx) {
-		if (buffer_handles.find(end.buffer_idx) == buffer_handles.end()) {
-			throw InternalException("CSV Buffer is not available to reconstruct CSV Line, please open an issue with "
-			                        "your query and dataset.");
-		}
-		auto buffer = buffer_handles[begin.buffer_idx]->Ptr();
-		first_char_nl = buffer[begin.buffer_pos] == '\n' || buffer[begin.buffer_pos] == '\r';
-		for (idx_t i = begin.buffer_pos + first_char_nl; i < end.buffer_pos; i++) {
-			result += buffer[i];
-		}
-	} else {
-		if (buffer_handles.find(begin.buffer_idx) == buffer_handles.end() ||
-		    buffer_handles.find(end.buffer_idx) == buffer_handles.end()) {
-			throw InternalException("CSV Buffer is not available to reconstruct CSV Line, please open an issue with "
-			                        "your query and dataset.");
-		}
-		auto first_buffer = buffer_handles[begin.buffer_idx]->Ptr();
-		auto first_buffer_size = buffer_handles[begin.buffer_idx]->actual_size;
-		auto second_buffer = buffer_handles[end.buffer_idx]->Ptr();
-		first_char_nl = first_buffer[begin.buffer_pos] == '\n' || first_buffer[begin.buffer_pos] == '\r';
-		for (idx_t i = begin.buffer_pos + first_char_nl; i < first_buffer_size; i++) {
-			result += first_buffer[i];
-		}
-		for (idx_t i = 0; i < end.buffer_pos; i++) {
-			result += second_buffer[i];
-		}
-	}
-	// sanitize borked line
-	SanitizeError(result);
-	return result;
-}
-
-bool StringValueResult::AddRowInternal() {
-	LinePosition current_line_start = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, buffer_size};
-	idx_t current_line_size = current_line_start - current_line_position.end;
-	if (store_line_size) {
-		error_handler.NewMaxLineSize(current_line_size);
-	}
-	current_line_position.begin = current_line_position.end;
-	current_line_position.end = current_line_start;
-	if (current_line_size > state_machine.options.maximum_line_size.GetValue()) {
-		current_errors.Insert(MAXIMUM_LINE_SIZE, 1, chunk_col_id, last_position, current_line_size);
-	}
-	if (!state_machine.options.null_padding) {
-		for (idx_t col_idx = cur_col_id; col_idx < number_of_columns; col_idx++) {
-			current_errors.Insert(TOO_FEW_COLUMNS, col_idx - 1, chunk_col_id, last_position);
-		}
-	}
-
-	if (current_errors.HandleErrors(*this)) {
-		line_positions_per_row[static_cast<idx_t>(number_of_rows)] = current_line_position;
-		number_of_rows++;
-		if (static_cast<idx_t>(number_of_rows) >= result_size) {
-			// We have a full chunk
-			return true;
-		}
-		return false;
-	}
-	NullPaddingQuotedNewlineCheck();
-	quoted_new_line = false;
-	// We need to check if we are getting the correct number of columns here.
-	// If columns are correct, we add it, and that's it.
-	if (cur_col_id != number_of_columns) {
-		// We have too few columns:
-		if (null_padding) {
-			while (cur_col_id < number_of_columns) {
-				bool empty = false;
-				if (cur_col_id < state_machine.options.force_not_null.size()) {
-					empty = state_machine.options.force_not_null[cur_col_id];
-				}
-				if (projecting_columns) {
-					if (!projected_columns[cur_col_id]) {
-						cur_col_id++;
-						continue;
-					}
-				}
-				if (empty) {
-					static_cast<string_t *>(vector_ptr[chunk_col_id])[number_of_rows] = string_t();
-				} else {
-					validity_mask[chunk_col_id]->SetInvalid(static_cast<idx_t>(number_of_rows));
-				}
-				cur_col_id++;
-				chunk_col_id++;
-			}
-		} else {
-			// If we are not null-padding this is an error
-			if (!state_machine.options.IgnoreErrors()) {
-				bool first_nl = false;
-				auto borked_line =
-				    current_line_position.ReconstructCurrentLine(first_nl, buffer_handles, PrintErrorLine());
-				LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read);
-				if (current_line_position.begin == last_position) {
-					auto csv_error = CSVError::IncorrectColumnAmountError(
-					    state_machine.options, cur_col_id - 1, lines_per_batch, borked_line,
-					    current_line_position.begin.GetGlobalPosition(requested_size, first_nl),
-					    last_position.GetGlobalPosition(requested_size, first_nl), path);
-					error_handler.Error(csv_error);
-				} else {
-					auto csv_error = CSVError::IncorrectColumnAmountError(
-					    state_machine.options, cur_col_id - 1, lines_per_batch, borked_line,
-					    current_line_position.begin.GetGlobalPosition(requested_size, first_nl),
-					    last_position.GetGlobalPosition(requested_size), path);
-					error_handler.Error(csv_error);
-				}
-			}
-			// If we are here we ignore_errors, so we delete this line
-			RemoveLastLine();
-		}
-	}
-	line_positions_per_row[static_cast<idx_t>(number_of_rows)] = current_line_position;
-	cur_col_id = 0;
-	chunk_col_id = 0;
-	number_of_rows++;
-	if (static_cast<idx_t>(number_of_rows) >= result_size) {
-		// We have a full chunk
-		return true;
-	}
-	return false;
-}
-
-bool StringValueResult::AddRow(StringValueResult &result, const idx_t buffer_pos) {
-	if (result.last_position.buffer_pos <= buffer_pos) {
-		// We add the value
-		if (result.quoted) {
-			AddQuotedValue(result, buffer_pos);
-		} else {
-			char *value_ptr = result.buffer_ptr + result.last_position.buffer_pos;
-			idx_t size = buffer_pos - result.last_position.buffer_pos;
-			if (result.escaped) {
-				AddPossiblyEscapedValue(result, buffer_pos, value_ptr, size, size == 0);
-			} else {
-				result.AddValueToVector(value_ptr, size);
-			}
-		}
-		if (result.state_machine.dialect_options.state_machine_options.new_line == NewLineIdentifier::CARRY_ON) {
-			if (result.states.states[1] == CSVState::RECORD_SEPARATOR) {
-				// Even though this is marked as a carry on, this is a hippie mixie
-				result.last_position.buffer_pos = buffer_pos + 1;
-			} else {
-				result.last_position.buffer_pos = buffer_pos + 2;
-			}
-		} else {
-			result.last_position.buffer_pos = buffer_pos + 1;
-		}
-	}
-
-	// We add the value
-	return result.AddRowInternal();
-}
-
-void StringValueResult::InvalidState(StringValueResult &result) {
-	if (result.quoted) {
-		result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, result.last_position);
-	} else {
-		result.current_errors.Insert(INVALID_STATE, result.cur_col_id, result.chunk_col_id, result.last_position);
-	}
-}
-
-bool StringValueResult::EmptyLine(StringValueResult &result, const idx_t buffer_pos) {
-	// We care about empty lines if this is a single column csv file
-	result.last_position = {result.iterator.pos.buffer_idx, result.iterator.pos.buffer_pos + 1, result.buffer_size};
-	if (result.states.IsCarriageReturn() &&
-	    result.state_machine.dialect_options.state_machine_options.new_line == NewLineIdentifier::CARRY_ON) {
-		result.last_position.buffer_pos++;
-	}
-	if (result.number_of_columns == 1) {
-		for (idx_t i = 0; i < result.null_str_count; i++) {
-			if (result.null_str_size[i] == 0) {
-				bool empty = false;
-				if (!result.state_machine.options.force_not_null.empty()) {
-					empty = result.state_machine.options.force_not_null[0];
-				}
-				if (empty) {
-					static_cast<string_t *>(result.vector_ptr[0])[result.number_of_rows] = string_t();
-				} else {
-					result.validity_mask[0]->SetInvalid(static_cast<idx_t>(result.number_of_rows));
-				}
-				result.number_of_rows++;
-			}
-		}
-		if (static_cast<idx_t>(result.number_of_rows) >= result.result_size) {
-			// We have a full chunk
-			return true;
-		}
-	}
-	return false;
-}
-
-StringValueScanner::StringValueScanner(idx_t scanner_idx_p, const shared_ptr<CSVBufferManager> &buffer_manager,
-                                       const shared_ptr<CSVStateMachine> &state_machine,
-                                       const shared_ptr<CSVErrorHandler> &error_handler,
-                                       const shared_ptr<CSVFileScan> &csv_file_scan, bool sniffing,
-                                       const CSVIterator &boundary, idx_t result_size)
-    : BaseScanner(buffer_manager, state_machine, error_handler, sniffing, csv_file_scan, boundary),
-      scanner_idx(scanner_idx_p),
-      result(states, *state_machine, cur_buffer_handle, BufferAllocator::Get(buffer_manager->context), result_size,
-             iterator.pos.buffer_pos, *error_handler, iterator,
-             buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing,
-             buffer_manager->GetFilePath(), scanner_idx_p) {
-	iterator.buffer_size = state_machine->options.buffer_size_option.GetValue();
-}
-
-StringValueScanner::StringValueScanner(const shared_ptr<CSVBufferManager> &buffer_manager,
-                                       const shared_ptr<CSVStateMachine> &state_machine,
-                                       const shared_ptr<CSVErrorHandler> &error_handler, idx_t result_size,
-                                       const CSVIterator &boundary)
-    : BaseScanner(buffer_manager, state_machine, error_handler, false, nullptr, boundary), scanner_idx(0),
-      result(states, *state_machine, cur_buffer_handle, Allocator::DefaultAllocator(), result_size,
-             iterator.pos.buffer_pos, *error_handler, iterator,
-             buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing,
-             buffer_manager->GetFilePath(), 0) {
-	iterator.buffer_size = state_machine->options.buffer_size_option.GetValue();
-}
-
-unique_ptr<StringValueScanner> StringValueScanner::GetCSVScanner(ClientContext &context, CSVReaderOptions &options) {
-	auto state_machine = make_shared_ptr<CSVStateMachine>(options, options.dialect_options.state_machine_options,
-	                                                      CSVStateMachineCache::Get(context));
-
-	state_machine->dialect_options.num_cols = options.dialect_options.num_cols;
-	state_machine->dialect_options.header = options.dialect_options.header;
-	auto buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, options.file_path, 0);
-	idx_t rows_to_skip = state_machine->options.GetSkipRows() + state_machine->options.GetHeader();
-	rows_to_skip = std::max(rows_to_skip, state_machine->dialect_options.rows_until_header +
-	                                          state_machine->dialect_options.header.GetValue());
-	auto it = BaseScanner::SkipCSVRows(buffer_manager, state_machine, rows_to_skip);
-	auto scanner = make_uniq<StringValueScanner>(buffer_manager, state_machine, make_shared_ptr<CSVErrorHandler>(),
-	                                             STANDARD_VECTOR_SIZE, it);
-	scanner->csv_file_scan = make_shared_ptr<CSVFileScan>(context, options.file_path, options);
-	scanner->csv_file_scan->InitializeProjection();
-	return scanner;
-}
-
-bool StringValueScanner::FinishedIterator() const {
-	return iterator.done;
-}
-
-StringValueResult &StringValueScanner::ParseChunk() {
-	result.Reset();
-	ParseChunkInternal(result);
-	return result;
-}
-
-void StringValueScanner::Flush(DataChunk &insert_chunk) {
-	auto &process_result = ParseChunk();
-	// First Get Parsed Chunk
-	auto &parse_chunk = process_result.ToChunk();
-	// We have to check if we got to error
-	error_handler->ErrorIfNeeded();
-	if (parse_chunk.size() == 0) {
-		return;
-	}
-	// convert the columns in the parsed chunk to the types of the table
-	insert_chunk.SetCardinality(parse_chunk);
-
-	// We keep track of the borked lines, in case we are ignoring errors
-	D_ASSERT(csv_file_scan);
-
-	auto &reader_data = csv_file_scan->reader_data;
-	// Now Do the cast-aroo
-	for (idx_t c = 0; c < reader_data.column_ids.size(); c++) {
-		idx_t col_idx = c;
-		idx_t result_idx = reader_data.column_mapping[c];
-		if (!csv_file_scan->projection_ids.empty()) {
-			result_idx = reader_data.column_mapping[csv_file_scan->projection_ids[c].second];
-		}
-		if (col_idx >= parse_chunk.ColumnCount()) {
-			throw InvalidInputException("Mismatch between the schema of different files");
-		}
-		auto &parse_vector = parse_chunk.data[col_idx];
-		auto &result_vector = insert_chunk.data[result_idx];
-		auto &type = result_vector.GetType();
-		auto &parse_type = parse_vector.GetType();
-		if (!type.IsJSONType() &&
-		    (type == LogicalType::VARCHAR || (type != LogicalType::VARCHAR && parse_type != LogicalType::VARCHAR))) {
-			// reinterpret rather than reference
-			result_vector.Reinterpret(parse_vector);
-		} else {
-			string error_message;
-			idx_t line_error = 0;
-			if (VectorOperations::TryCast(buffer_manager->context, parse_vector, result_vector, parse_chunk.size(),
-			                              &error_message, false, true)) {
-				continue;
-			}
-			// An error happened, to propagate it we need to figure out the exact line where the casting failed.
-			UnifiedVectorFormat inserted_column_data;
-			result_vector.ToUnifiedFormat(parse_chunk.size(), inserted_column_data);
-			UnifiedVectorFormat parse_column_data;
-			parse_vector.ToUnifiedFormat(parse_chunk.size(), parse_column_data);
-
-			for (; line_error < parse_chunk.size(); line_error++) {
-				if (!inserted_column_data.validity.RowIsValid(line_error) &&
-				    parse_column_data.validity.RowIsValid(line_error)) {
-					break;
-				}
-			}
-			{
-
-				if (state_machine->options.ignore_errors.GetValue()) {
-					vector<Value> row;
-					for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) {
-						row.push_back(parse_chunk.GetValue(col, line_error));
-					}
-				}
-				if (!state_machine->options.IgnoreErrors()) {
-					LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(),
-					                                 lines_read - parse_chunk.size() + line_error);
-					bool first_nl;
-					auto borked_line = result.line_positions_per_row[line_error].ReconstructCurrentLine(
-					    first_nl, result.buffer_handles, result.PrintErrorLine());
-					std::ostringstream error;
-					error << "Could not convert string \"" << parse_vector.GetValue(line_error) << "\" to \'"
-					      << type.ToString() << "\'";
-					string error_msg = error.str();
-					SanitizeError(error_msg);
-					auto csv_error = CSVError::CastError(
-					    state_machine->options, csv_file_scan->names[col_idx], error_msg, col_idx, borked_line,
-					    lines_per_batch,
-					    result.line_positions_per_row[line_error].begin.GetGlobalPosition(result.result_size, first_nl),
-					    optional_idx::Invalid(), result_vector.GetType().id(), result.path);
-					error_handler->Error(csv_error);
-				}
-			}
-			result.borked_rows.insert(line_error++);
-			D_ASSERT(state_machine->options.ignore_errors.GetValue());
-			// We are ignoring errors. We must continue but ignoring borked-rows
-			for (; line_error < parse_chunk.size(); line_error++) {
-				if (!inserted_column_data.validity.RowIsValid(line_error) &&
-				    parse_column_data.validity.RowIsValid(line_error)) {
-					result.borked_rows.insert(line_error);
-					vector<Value> row;
-					for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) {
-						row.push_back(parse_chunk.GetValue(col, line_error));
-					}
-					if (!state_machine->options.IgnoreErrors()) {
-						LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(),
-						                                 lines_read - parse_chunk.size() + line_error);
-						bool first_nl;
-						auto borked_line = result.line_positions_per_row[line_error].ReconstructCurrentLine(
-						    first_nl, result.buffer_handles, result.PrintErrorLine());
-						std::ostringstream error;
-						// Casting Error Message
-						error << "Could not convert string \"" << parse_vector.GetValue(line_error) << "\" to \'"
-						      << LogicalTypeIdToString(type.id()) << "\'";
-						string error_msg = error.str();
-						SanitizeError(error_msg);
-						auto csv_error =
-						    CSVError::CastError(state_machine->options, csv_file_scan->names[col_idx], error_msg,
-						                        col_idx, borked_line, lines_per_batch,
-						                        result.line_positions_per_row[line_error].begin.GetGlobalPosition(
-						                            result.result_size, first_nl),
-						                        optional_idx::Invalid(), result_vector.GetType().id(), result.path);
-						error_handler->Error(csv_error);
-					}
-				}
-			}
-		}
-	}
-	if (!result.borked_rows.empty()) {
-		// We must remove the borked lines from our chunk
-		SelectionVector successful_rows(parse_chunk.size());
-		idx_t sel_idx = 0;
-		for (idx_t row_idx = 0; row_idx < parse_chunk.size(); row_idx++) {
-			if (result.borked_rows.find(row_idx) == result.borked_rows.end()) {
-				successful_rows.set_index(sel_idx++, row_idx);
-			}
-		}
-		// Now we slice the result
-		insert_chunk.Slice(successful_rows, sel_idx);
-	}
-}
-
-void StringValueScanner::Initialize() {
-	states.Initialize();
-
-	if (result.result_size != 1 && !(sniffing && state_machine->options.null_padding &&
-	                                 !state_machine->options.dialect_options.skip_rows.IsSetByUser())) {
-		SetStart();
-	} else {
-		start_pos = iterator.GetGlobalCurrentPos();
-	}
-
-	result.last_position = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, cur_buffer_handle->actual_size};
-	result.current_line_position.begin = result.last_position;
-	result.current_line_position.end = result.current_line_position.begin;
-}
-
-void StringValueScanner::ProcessExtraRow() {
-	result.NullPaddingQuotedNewlineCheck();
-	idx_t to_pos = cur_buffer_handle->actual_size;
-	while (iterator.pos.buffer_pos < to_pos) {
-		state_machine->Transition(states, buffer_handle_ptr[iterator.pos.buffer_pos]);
-		switch (states.states[1]) {
-		case CSVState::INVALID:
-			result.InvalidState(result);
-			iterator.pos.buffer_pos++;
-			return;
-		case CSVState::RECORD_SEPARATOR:
-			if (states.states[0] == CSVState::RECORD_SEPARATOR) {
-				result.EmptyLine(result, iterator.pos.buffer_pos);
-				iterator.pos.buffer_pos++;
-				lines_read++;
-				return;
-			} else if (states.states[0] != CSVState::CARRIAGE_RETURN) {
-				if (result.IsCommentSet(result)) {
-					result.UnsetComment(result, iterator.pos.buffer_pos);
-				} else {
-					result.AddRow(result, iterator.pos.buffer_pos);
-				}
-				iterator.pos.buffer_pos++;
-				lines_read++;
-				return;
-			}
-			lines_read++;
-			iterator.pos.buffer_pos++;
-			break;
-		case CSVState::CARRIAGE_RETURN:
-			if (states.states[0] != CSVState::RECORD_SEPARATOR) {
-				if (result.IsCommentSet(result)) {
-					result.UnsetComment(result, iterator.pos.buffer_pos);
-				} else {
-					result.AddRow(result, iterator.pos.buffer_pos);
-				}
-				iterator.pos.buffer_pos++;
-				lines_read++;
-				return;
-			} else {
-				result.EmptyLine(result, iterator.pos.buffer_pos);
-				iterator.pos.buffer_pos++;
-				lines_read++;
-				return;
-			}
-			break;
-		case CSVState::DELIMITER:
-			result.AddValue(result, iterator.pos.buffer_pos);
-			iterator.pos.buffer_pos++;
-			break;
-		case CSVState::QUOTED:
-			if (states.states[0] == CSVState::UNQUOTED) {
-				result.SetEscaped(result);
-			}
-			result.SetQuoted(result, iterator.pos.buffer_pos);
-			iterator.pos.buffer_pos++;
-			while (state_machine->transition_array
-			           .skip_quoted[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
-			       iterator.pos.buffer_pos < to_pos - 1) {
-				iterator.pos.buffer_pos++;
-			}
-			break;
-		case CSVState::ESCAPE:
-		case CSVState::UNQUOTED_ESCAPE:
-		case CSVState::ESCAPED_RETURN:
-			result.SetEscaped(result);
-			iterator.pos.buffer_pos++;
-			break;
-		case CSVState::STANDARD:
-			iterator.pos.buffer_pos++;
-			while (state_machine->transition_array
-			           .skip_standard[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
-			       iterator.pos.buffer_pos < to_pos - 1) {
-				iterator.pos.buffer_pos++;
-			}
-			break;
-		case CSVState::UNQUOTED: {
-			result.SetUnquoted(result);
-			iterator.pos.buffer_pos++;
-			break;
-		}
-		case CSVState::COMMENT:
-			result.SetComment(result, iterator.pos.buffer_pos);
-			iterator.pos.buffer_pos++;
-			while (state_machine->transition_array
-			           .skip_comment[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
-			       iterator.pos.buffer_pos < to_pos - 1) {
-				iterator.pos.buffer_pos++;
-			}
-			break;
-		case CSVState::QUOTED_NEW_LINE:
-			result.quoted_new_line = true;
-			result.NullPaddingQuotedNewlineCheck();
-			iterator.pos.buffer_pos++;
-			break;
-		default:
-			iterator.pos.buffer_pos++;
-			break;
-		}
-	}
-}
-
-string_t StringValueScanner::RemoveEscape(const char *str_ptr, idx_t end, char escape, char quote, Vector &vector) {
-	// Figure out the exact size
-	idx_t str_pos = 0;
-	bool just_escaped = false;
-	for (idx_t cur_pos = 0; cur_pos < end; cur_pos++) {
-		if (str_ptr[cur_pos] == escape && !just_escaped) {
-			just_escaped = true;
-		} else if (str_ptr[cur_pos] == quote) {
-			if (just_escaped) {
-				str_pos++;
-			}
-			just_escaped = false;
-		} else {
-			just_escaped = false;
-			str_pos++;
-		}
-	}
-
-	auto removed_escapes = StringVector::EmptyString(vector, str_pos);
-	auto removed_escapes_ptr = removed_escapes.GetDataWriteable();
-	// Allocate string and copy it
-	str_pos = 0;
-	just_escaped = false;
-	for (idx_t cur_pos = 0; cur_pos < end; cur_pos++) {
-		const char c = str_ptr[cur_pos];
-		if (c == escape && !just_escaped) {
-			just_escaped = true;
-		} else if (str_ptr[cur_pos] == quote) {
-			if (just_escaped) {
-				removed_escapes_ptr[str_pos++] = c;
-			}
-			just_escaped = false;
-		} else {
-			just_escaped = false;
-			removed_escapes_ptr[str_pos++] = c;
-		}
-	}
-	removed_escapes.Finalize();
-	return removed_escapes;
-}
-
-void StringValueScanner::ProcessOverBufferValue() {
-	// Process first string
-	if (result.last_position.buffer_pos != previous_buffer_handle->actual_size) {
-		states.Initialize();
-	}
-
-	string over_buffer_string;
-	auto previous_buffer = previous_buffer_handle->Ptr();
-	idx_t j = 0;
-	result.quoted = false;
-	for (idx_t i = result.last_position.buffer_pos; i < previous_buffer_handle->actual_size; i++) {
-		state_machine->Transition(states, previous_buffer[i]);
-		if (states.EmptyLine() || states.IsCurrentNewRow()) {
-			continue;
-		}
-		if (states.NewRow() || states.NewValue()) {
-			break;
-		} else {
-			if (!result.comment) {
-				over_buffer_string += previous_buffer[i];
-			}
-		}
-		if (states.IsQuoted()) {
-			result.SetQuoted(result, j);
-		}
-		if (states.IsUnquoted()) {
-			result.SetUnquoted(result);
-		}
-		if (states.IsEscaped() && result.state_machine.dialect_options.state_machine_options.escape != '\0') {
-			result.escaped = true;
-		}
-		if (states.IsComment()) {
-			result.comment = true;
-		}
-		if (states.IsInvalid()) {
-			result.InvalidState(result);
-		}
-		j++;
-	}
-	if (over_buffer_string.empty() &&
-	    state_machine->dialect_options.state_machine_options.new_line == NewLineIdentifier::CARRY_ON) {
-		if (buffer_handle_ptr[iterator.pos.buffer_pos] == '\n') {
-			iterator.pos.buffer_pos++;
-		}
-	}
-	// second buffer
-	for (; iterator.pos.buffer_pos < cur_buffer_handle->actual_size; iterator.pos.buffer_pos++) {
-		state_machine->Transition(states, buffer_handle_ptr[iterator.pos.buffer_pos]);
-		if (states.EmptyLine()) {
-			if (state_machine->dialect_options.num_cols == 1) {
-				break;
-			} else {
-				continue;
-			}
-		}
-		if (states.NewRow() || states.NewValue()) {
-			break;
-		} else {
-			if (!result.comment && !states.IsComment()) {
-				over_buffer_string += buffer_handle_ptr[iterator.pos.buffer_pos];
-			}
-		}
-		if (states.IsQuoted()) {
-			result.SetQuoted(result, j);
-		}
-		if (states.IsComment()) {
-			result.comment = true;
-		}
-		if (states.IsEscaped() && result.state_machine.dialect_options.state_machine_options.escape != '\0') {
-			result.escaped = true;
-		}
-		if (states.IsInvalid()) {
-			result.InvalidState(result);
-		}
-		j++;
-	}
-	bool skip_value = false;
-	if (result.projecting_columns) {
-		if (!result.projected_columns[result.cur_col_id] && result.cur_col_id != result.number_of_columns) {
-			result.cur_col_id++;
-			skip_value = true;
-		}
-	}
-	if (!skip_value) {
-		string_t value;
-		if (result.quoted) {
-			value = string_t(over_buffer_string.c_str() + result.quoted_position,
-			                 UnsafeNumericCast<uint32_t>(over_buffer_string.size() - 1 - result.quoted_position));
-			if (result.escaped) {
-				if (!result.HandleTooManyColumnsError(over_buffer_string.c_str(), over_buffer_string.size())) {
-					const auto str_ptr = over_buffer_string.c_str() + result.quoted_position;
-					value = RemoveEscape(str_ptr, over_buffer_string.size() - 2,
-					                     state_machine->dialect_options.state_machine_options.escape.GetValue(),
-					                     state_machine->dialect_options.state_machine_options.quote.GetValue(),
-					                     result.parse_chunk.data[result.chunk_col_id]);
-				}
-			}
-		} else {
-			value = string_t(over_buffer_string.c_str(), UnsafeNumericCast<uint32_t>(over_buffer_string.size()));
-			if (result.escaped) {
-				if (!result.HandleTooManyColumnsError(over_buffer_string.c_str(), over_buffer_string.size())) {
-					value = RemoveEscape(over_buffer_string.c_str(), over_buffer_string.size(),
-					                     state_machine->dialect_options.state_machine_options.escape.GetValue(),
-					                     state_machine->dialect_options.state_machine_options.quote.GetValue(),
-					                     result.parse_chunk.data[result.chunk_col_id]);
-				}
-			}
-		}
-		if (states.EmptyLine() && state_machine->dialect_options.num_cols == 1) {
-			result.EmptyLine(result, iterator.pos.buffer_pos);
-		} else if (!states.IsNotSet() && (!result.comment || !value.Empty())) {
-			idx_t value_size = value.GetSize();
-			if (states.IsDelimiter()) {
-				idx_t extra_delimiter_bytes =
-				    result.state_machine.dialect_options.state_machine_options.delimiter.GetValue().size() - 1;
-				if (extra_delimiter_bytes > value_size) {
-					throw InternalException(
-					    "Value size is lower than the number of extra delimiter bytes in the ProcesOverBufferValue()");
-				}
-				value_size -= extra_delimiter_bytes;
-			}
-			result.AddValueToVector(value.GetData(), value_size, true);
-		}
-	} else {
-		if (states.EmptyLine() && state_machine->dialect_options.num_cols == 1) {
-			result.EmptyLine(result, iterator.pos.buffer_pos);
-		}
-	}
-
-	if (states.NewRow() && !states.IsNotSet()) {
-		if (result.IsCommentSet(result)) {
-			result.UnsetComment(result, iterator.pos.buffer_pos);
-		} else {
-			result.AddRowInternal();
-		}
-		lines_read++;
-	}
-
-	if (iterator.pos.buffer_pos >= cur_buffer_handle->actual_size && cur_buffer_handle->is_last_buffer) {
-		result.added_last_line = true;
-	}
-	if (states.IsCarriageReturn() &&
-	    state_machine->dialect_options.state_machine_options.new_line == NewLineIdentifier::CARRY_ON) {
-		result.last_position = {iterator.pos.buffer_idx, ++iterator.pos.buffer_pos + 1, result.buffer_size};
-	} else {
-		result.last_position = {iterator.pos.buffer_idx, ++iterator.pos.buffer_pos, result.buffer_size};
-	}
-	// Be sure to reset the quoted and escaped variables
-	result.quoted = false;
-	result.escaped = false;
-}
-
-bool StringValueScanner::MoveToNextBuffer() {
-	if (iterator.pos.buffer_pos >= cur_buffer_handle->actual_size) {
-		previous_buffer_handle = cur_buffer_handle;
-		cur_buffer_handle = buffer_manager->GetBuffer(++iterator.pos.buffer_idx);
-		if (!cur_buffer_handle) {
-			iterator.pos.buffer_idx--;
-			buffer_handle_ptr = nullptr;
-			// We do not care if it's a quoted new line on the last row of our file.
-			result.quoted_new_line = false;
-			// This means we reached the end of the file, we must add a last line if there is any to be added
-			if (states.EmptyLine() || states.NewRow() || result.added_last_line || states.IsCurrentNewRow() ||
-			    states.IsNotSet()) {
-				if (result.cur_col_id == result.number_of_columns) {
-					result.number_of_rows++;
-				}
-				result.cur_col_id = 0;
-				result.chunk_col_id = 0;
-				return false;
-			} else if (states.NewValue()) {
-				// we add the value
-				result.AddValue(result, previous_buffer_handle->actual_size);
-				// And an extra empty value to represent what comes after the delimiter
-				if (result.IsCommentSet(result)) {
-					result.UnsetComment(result, iterator.pos.buffer_pos);
-				} else {
-					result.AddRow(result, previous_buffer_handle->actual_size);
-				}
-				lines_read++;
-			} else if (states.IsQuotedCurrent() &&
-			           state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) {
-				// Unterminated quote
-				LinePosition current_line_start = {iterator.pos.buffer_idx, iterator.pos.buffer_pos,
-				                                   result.buffer_size};
-				result.current_line_position.begin = result.current_line_position.end;
-				result.current_line_position.end = current_line_start;
-				result.InvalidState(result);
-			} else {
-				if (result.IsCommentSet(result)) {
-					result.UnsetComment(result, iterator.pos.buffer_pos);
-				} else {
-					if (result.quoted && states.IsDelimiterBytes() &&
-					    state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) {
-						result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id,
-						                             result.last_position);
-					}
-					result.AddRow(result, previous_buffer_handle->actual_size);
-				}
-				lines_read++;
-			}
-			return false;
-		}
-		result.buffer_handles[cur_buffer_handle->buffer_idx] = cur_buffer_handle;
-
-		iterator.pos.buffer_pos = 0;
-		buffer_handle_ptr = cur_buffer_handle->Ptr();
-		// Handle over-buffer value
-		ProcessOverBufferValue();
-		result.buffer_ptr = buffer_handle_ptr;
-		result.buffer_size = cur_buffer_handle->actual_size;
-		return true;
-	}
-	return false;
-}
-
-void StringValueResult::SkipBOM() const {
-	if (buffer_size >= 3 && buffer_ptr[0] == '\xEF' && buffer_ptr[1] == '\xBB' && buffer_ptr[2] == '\xBF' &&
-	    iterator.pos.buffer_pos == 0) {
-		iterator.pos.buffer_pos = 3;
-	}
-}
-
-void StringValueResult::RemoveLastLine() {
-	// potentially de-nullify values
-	for (idx_t i = 0; i < chunk_col_id; i++) {
-		validity_mask[i]->SetValid(static_cast<idx_t>(number_of_rows));
-	}
-	// reset column trackers
-	cur_col_id = 0;
-	chunk_col_id = 0;
-	// decrement row counter
-	number_of_rows--;
-}
-bool StringValueResult::PrintErrorLine() const {
-	// To print a lint, result size must be different, than one (i.e., this is a SetStart() trying to figure out new
-	// lines) And must either not be ignoring errors OR must be storing them in a rejects table.
-	return result_size != 1 &&
-	       (state_machine.options.store_rejects.GetValue() || !state_machine.options.ignore_errors.GetValue());
-}
-
-bool StringValueScanner::FirstValueEndsOnQuote(CSVIterator iterator) const {
-	CSVStates current_state;
-	current_state.Initialize(CSVState::STANDARD);
-	const idx_t to_pos = iterator.GetEndPos();
-	while (iterator.pos.buffer_pos < to_pos) {
-		state_machine->Transition(current_state, buffer_handle_ptr[iterator.pos.buffer_pos++]);
-		if ((current_state.IsState(CSVState::DELIMITER) || current_state.IsState(CSVState::CARRIAGE_RETURN) ||
-		     current_state.IsState(CSVState::RECORD_SEPARATOR))) {
-			return buffer_handle_ptr[iterator.pos.buffer_pos - 2] ==
-			       state_machine->dialect_options.state_machine_options.quote.GetValue();
-		}
-	}
-	return false;
-}
-
-bool StringValueScanner::SkipUntilState(CSVState initial_state, CSVState until_state, CSVIterator &current_iterator,
-                                        bool &quoted) const {
-	CSVStates current_state;
-	current_state.Initialize(initial_state);
-	bool first_column = true;
-	const idx_t to_pos = current_iterator.GetEndPos();
-	while (current_iterator.pos.buffer_pos < to_pos) {
-		state_machine_strict->Transition(current_state, buffer_handle_ptr[current_iterator.pos.buffer_pos++]);
-		if (current_state.IsState(CSVState::STANDARD) || current_state.IsState(CSVState::STANDARD_NEWLINE)) {
-			while (current_iterator.pos.buffer_pos + 8 < to_pos) {
-				uint64_t value = Load<uint64_t>(
-				    reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[current_iterator.pos.buffer_pos]));
-				if (ContainsZeroByte((value ^ state_machine_strict->transition_array.delimiter) &
-				                     (value ^ state_machine_strict->transition_array.new_line) &
-				                     (value ^ state_machine_strict->transition_array.carriage_return) &
-				                     (value ^ state_machine_strict->transition_array.comment))) {
-					break;
-				}
-				current_iterator.pos.buffer_pos += 8;
-			}
-			while (state_machine_strict->transition_array
-			           .skip_standard[static_cast<uint8_t>(buffer_handle_ptr[current_iterator.pos.buffer_pos])] &&
-			       current_iterator.pos.buffer_pos < to_pos - 1) {
-				current_iterator.pos.buffer_pos++;
-			}
-		}
-		if (current_state.IsState(CSVState::QUOTED)) {
-			while (current_iterator.pos.buffer_pos + 8 < to_pos) {
-				uint64_t value = Load<uint64_t>(
-				    reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[current_iterator.pos.buffer_pos]));
-				if (ContainsZeroByte((value ^ state_machine_strict->transition_array.quote) &
-				                     (value ^ state_machine_strict->transition_array.escape))) {
-					break;
-				}
-				current_iterator.pos.buffer_pos += 8;
-			}
-
-			while (state_machine_strict->transition_array
-			           .skip_quoted[static_cast<uint8_t>(buffer_handle_ptr[current_iterator.pos.buffer_pos])] &&
-			       current_iterator.pos.buffer_pos < to_pos - 1) {
-				current_iterator.pos.buffer_pos++;
-			}
-		}
-		if ((current_state.IsState(CSVState::DELIMITER) || current_state.IsState(CSVState::CARRIAGE_RETURN) ||
-		     current_state.IsState(CSVState::RECORD_SEPARATOR)) &&
-		    first_column) {
-			if (buffer_handle_ptr[current_iterator.pos.buffer_pos - 1] ==
-			    state_machine_strict->dialect_options.state_machine_options.quote.GetValue()) {
-				quoted = true;
-			}
-		}
-		if (current_state.WasState(CSVState::DELIMITER)) {
-			first_column = false;
-		}
-		if (current_state.IsState(until_state)) {
-			return true;
-		}
-		if (current_state.IsState(CSVState::INVALID)) {
-			return false;
-		}
-	}
-	return false;
-}
-
-bool StringValueScanner::CanDirectlyCast(const LogicalType &type, bool icu_loaded) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::DECIMAL:
-	case LogicalType::VARCHAR:
-	case LogicalType::BOOLEAN:
-		return true;
-	case LogicalType::TIMESTAMP_TZ:
-		// We only try to do direct cast of timestamp tz if the ICU extension is not loaded, otherwise, it needs to go
-		// through string -> timestamp_tz casting
-		return !icu_loaded;
-	default:
-		return false;
-	}
-}
-
-bool StringValueScanner::IsRowValid(CSVIterator &current_iterator) const {
-	if (iterator.pos.buffer_pos == cur_buffer_handle->actual_size) {
-		return false;
-	}
-	constexpr idx_t result_size = 1;
-	auto scan_finder = make_uniq<StringValueScanner>(StringValueScanner::LINE_FINDER_ID, buffer_manager,
-	                                                 state_machine_strict, make_shared_ptr<CSVErrorHandler>(),
-	                                                 csv_file_scan, false, current_iterator, result_size);
-	auto &tuples = scan_finder->ParseChunk();
-	current_iterator.pos = scan_finder->GetIteratorPosition();
-	bool has_error = false;
-	if (tuples.current_errors.HasError()) {
-		if (tuples.current_errors.Size() != 1 || !tuples.current_errors.HasErrorType(MAXIMUM_LINE_SIZE)) {
-			// We ignore maximum line size errors
-			has_error = true;
-		}
-	}
-	return (tuples.number_of_rows == 1 || tuples.first_line_is_comment) && !has_error && tuples.borked_rows.empty();
-}
-
-ValidRowInfo StringValueScanner::TryRow(CSVState state, idx_t start_pos, idx_t end_pos) const {
-	auto current_iterator = iterator;
-	current_iterator.SetStart(start_pos);
-	current_iterator.SetEnd(end_pos);
-	bool quoted = false;
-	if (SkipUntilState(state, CSVState::RECORD_SEPARATOR, current_iterator, quoted)) {
-		auto iterator_start = current_iterator;
-		idx_t current_pos = current_iterator.pos.buffer_pos;
-		current_iterator.SetEnd(iterator.GetEndPos());
-		if (IsRowValid(current_iterator)) {
-			if (!quoted) {
-				quoted = FirstValueEndsOnQuote(iterator_start);
-			}
-			return {true, current_pos, current_iterator.pos.buffer_idx, current_iterator.pos.buffer_pos, quoted};
-		}
-	}
-	return {false, current_iterator.pos.buffer_pos, current_iterator.pos.buffer_idx, current_iterator.pos.buffer_pos,
-	        quoted};
-}
-
-void StringValueScanner::SetStart() {
-	start_pos = iterator.GetGlobalCurrentPos();
-	if (iterator.first_one) {
-		if (result.store_line_size) {
-			result.error_handler.NewMaxLineSize(iterator.pos.buffer_pos);
-		}
-		return;
-	}
-	if (iterator.GetEndPos() > cur_buffer_handle->actual_size) {
-		iterator.SetEnd(cur_buffer_handle->actual_size);
-	}
-	if (!state_machine_strict) {
-		// We need to initialize our strict state machine
-		auto &state_machine_cache = CSVStateMachineCache::Get(buffer_manager->context);
-		auto state_options = state_machine->state_machine_options;
-		// To set the state machine to be strict we ensure that rfc_4180 is set to true
-		if (!state_options.rfc_4180.IsSetByUser()) {
-			state_options.rfc_4180 = true;
-		}
-		state_machine_strict =
-		    make_shared_ptr<CSVStateMachine>(state_machine_cache.Get(state_options), state_machine->options);
-	}
-	// At this point we have 3 options:
-	// 1. We are at the start of a valid line
-	ValidRowInfo best_row = TryRow(CSVState::STANDARD_NEWLINE, iterator.pos.buffer_pos, iterator.GetEndPos());
-	// 2. We are in the middle of a quoted value
-	if (state_machine->dialect_options.state_machine_options.quote.GetValue() != '\0') {
-		idx_t end_pos = iterator.GetEndPos();
-		if (best_row.is_valid && best_row.end_buffer_idx == iterator.pos.buffer_idx) {
-			// If we got a valid row from the standard state, we limit our search up to that.
-			end_pos = best_row.end_pos;
-		}
-		auto quoted_row = TryRow(CSVState::QUOTED, iterator.pos.buffer_pos, end_pos);
-		if (quoted_row.is_valid && (!best_row.is_valid || best_row.last_state_quote)) {
-			best_row = quoted_row;
-		}
-		if (!best_row.is_valid && !quoted_row.is_valid && best_row.start_pos < quoted_row.start_pos) {
-			best_row = quoted_row;
-		}
-	}
-	// 3. We are in an escaped value
-	if (!best_row.is_valid && state_machine->dialect_options.state_machine_options.escape.GetValue() != '\0' &&
-	    state_machine->dialect_options.state_machine_options.quote.GetValue() != '\0') {
-		auto escape_row = TryRow(CSVState::ESCAPE, iterator.pos.buffer_pos, iterator.GetEndPos());
-		if (escape_row.is_valid) {
-			best_row = escape_row;
-		} else {
-			if (best_row.start_pos < escape_row.start_pos) {
-				best_row = escape_row;
-			}
-		}
-	}
-	if (!best_row.is_valid) {
-		bool is_this_the_end =
-		    best_row.start_pos >= cur_buffer_handle->actual_size && cur_buffer_handle->is_last_buffer;
-		if (is_this_the_end) {
-			iterator.pos.buffer_pos = best_row.start_pos;
-			iterator.done = true;
-		} else {
-			bool mock;
-			if (!SkipUntilState(CSVState::STANDARD_NEWLINE, CSVState::RECORD_SEPARATOR, iterator, mock)) {
-				iterator.CheckIfDone();
-			}
-		}
-	} else {
-		iterator.pos.buffer_pos = best_row.start_pos;
-		bool is_this_the_end =
-		    best_row.start_pos >= cur_buffer_handle->actual_size && cur_buffer_handle->is_last_buffer;
-		if (is_this_the_end) {
-			iterator.done = true;
-		}
-	}
-
-	// 4. We have an error, if we have an error, we let life go on, the scanner will either ignore it
-	// or throw.
-	result.last_position = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, result.buffer_size};
-	start_pos = iterator.GetGlobalCurrentPos();
-}
-
-void StringValueScanner::FinalizeChunkProcess() {
-	if (static_cast<idx_t>(result.number_of_rows) >= result.result_size || iterator.done) {
-		// We are done
-		if (!sniffing) {
-			if (csv_file_scan) {
-				csv_file_scan->bytes_read += bytes_read;
-				bytes_read = 0;
-			}
-		}
-		return;
-	}
-	// If we are not done we have two options.
-	// 1) If a boundary is set.
-	if (iterator.IsBoundarySet()) {
-		bool found_error = false;
-		CSVErrorType type;
-		if (!result.current_errors.HasErrorType(UNTERMINATED_QUOTES) &&
-		    !result.current_errors.HasErrorType(INVALID_STATE)) {
-			iterator.done = true;
-		} else {
-			found_error = true;
-			if (result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) {
-				type = UNTERMINATED_QUOTES;
-			} else {
-				type = INVALID_STATE;
-			}
-		}
-		// We read until the next line or until we have nothing else to read.
-		// Move to next buffer
-		if (!cur_buffer_handle) {
-			return;
-		}
-		bool moved = MoveToNextBuffer();
-		if (cur_buffer_handle) {
-			if (moved && result.cur_col_id > 0) {
-				ProcessExtraRow();
-			} else if (!moved) {
-				ProcessExtraRow();
-			}
-			if (cur_buffer_handle->is_last_buffer && iterator.pos.buffer_pos >= cur_buffer_handle->actual_size) {
-				MoveToNextBuffer();
-			}
-		} else {
-			if (result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) {
-				found_error = true;
-				type = UNTERMINATED_QUOTES;
-			} else if (result.current_errors.HasErrorType(INVALID_STATE)) {
-				found_error = true;
-				type = INVALID_STATE;
-			}
-			if (result.current_errors.HandleErrors(result)) {
-				result.number_of_rows++;
-			}
-		}
-		if (states.IsQuotedCurrent() && !found_error &&
-		    state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) {
-			// If we finish the execution of a buffer, and we end in a quoted state, it means we have unterminated
-			// quotes
-			result.current_errors.Insert(type, result.cur_col_id, result.chunk_col_id, result.last_position);
-			if (result.current_errors.HandleErrors(result)) {
-				result.number_of_rows++;
-			}
-		}
-		if (!iterator.done) {
-			if (iterator.pos.buffer_pos >= iterator.GetEndPos() || iterator.pos.buffer_idx > iterator.GetBufferIdx() ||
-			    FinishedFile()) {
-				iterator.done = true;
-			}
-		}
-	} else {
-		// 2) If a boundary is not set
-		// We read until the chunk is complete, or we have nothing else to read.
-		while (!FinishedFile() && static_cast<idx_t>(result.number_of_rows) < result.result_size) {
-			MoveToNextBuffer();
-			if (static_cast<idx_t>(result.number_of_rows) >= result.result_size) {
-				return;
-			}
-			if (cur_buffer_handle) {
-				Process(result);
-			}
-		}
-		iterator.done = FinishedFile();
-		if (result.null_padding && result.number_of_rows < STANDARD_VECTOR_SIZE && result.chunk_col_id > 0) {
-			while (result.chunk_col_id < result.parse_chunk.ColumnCount()) {
-				result.validity_mask[result.chunk_col_id++]->SetInvalid(static_cast<idx_t>(result.number_of_rows));
-				result.cur_col_id++;
-			}
-			result.number_of_rows++;
-		}
-	}
-}
-
-ValidatorLine StringValueScanner::GetValidationLine() {
-	return {start_pos, result.iterator.GetGlobalCurrentPos()};
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp
deleted file mode 100644
index c8740ebde..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp
+++ /dev/null
@@ -1,272 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-CSVSniffer::CSVSniffer(CSVReaderOptions &options_p, shared_ptr<CSVBufferManager> buffer_manager_p,
-                       CSVStateMachineCache &state_machine_cache_p, bool default_null_to_varchar_p)
-    : state_machine_cache(state_machine_cache_p), options(options_p), buffer_manager(std::move(buffer_manager_p)),
-      lines_sniffed(0), default_null_to_varchar(default_null_to_varchar_p) {
-	// Initialize Format Candidates
-	for (const auto &format_template : format_template_candidates) {
-		auto &logical_type = format_template.first;
-		best_format_candidates[logical_type].clear();
-	}
-	// Initialize max columns found to either 0 or however many were set
-	max_columns_found = set_columns.Size();
-	error_handler = make_shared_ptr<CSVErrorHandler>(options.ignore_errors.GetValue());
-	detection_error_handler = make_shared_ptr<CSVErrorHandler>(true);
-	if (options.columns_set) {
-		set_columns = SetColumns(&options.sql_type_list, &options.name_list);
-	}
-}
-
-bool SetColumns::IsSet() const {
-	if (!types) {
-		return false;
-	}
-	return !types->empty();
-}
-
-idx_t SetColumns::Size() const {
-	if (!types) {
-		return 0;
-	}
-	return types->size();
-}
-
-template <class T>
-void MatchAndReplace(CSVOption<T> &original, CSVOption<T> &sniffed, const string &name, string &error) {
-	if (original.IsSetByUser()) {
-		// We verify that the user input matches the sniffed value
-		if (original != sniffed) {
-			error += "CSV Sniffer: Sniffer detected value different than the user input for the " + name;
-			error += " options \n Set: " + original.FormatValue() + ", Sniffed: " + sniffed.FormatValue() + "\n";
-		}
-	} else {
-		// We replace the value of original with the sniffed value
-		original.Set(sniffed.GetValue(), false);
-	}
-}
-
-void MatchAndReplaceUserSetVariables(DialectOptions &original, DialectOptions &sniffed, string &error, bool found_date,
-                                     bool found_timestamp) {
-	MatchAndReplace(original.header, sniffed.header, "Header", error);
-	if (sniffed.state_machine_options.new_line.GetValue() != NewLineIdentifier::NOT_SET) {
-		// Is sniffed line is not set (e.g., single-line file) , we don't try to replace and match.
-		MatchAndReplace(original.state_machine_options.new_line, sniffed.state_machine_options.new_line, "New Line",
-		                error);
-	}
-	MatchAndReplace(original.skip_rows, sniffed.skip_rows, "Skip Rows", error);
-	MatchAndReplace(original.state_machine_options.delimiter, sniffed.state_machine_options.delimiter, "Delimiter",
-	                error);
-	MatchAndReplace(original.state_machine_options.quote, sniffed.state_machine_options.quote, "Quote", error);
-	MatchAndReplace(original.state_machine_options.escape, sniffed.state_machine_options.escape, "Escape", error);
-	MatchAndReplace(original.state_machine_options.comment, sniffed.state_machine_options.comment, "Comment", error);
-	if (found_date) {
-		MatchAndReplace(original.date_format[LogicalTypeId::DATE], sniffed.date_format[LogicalTypeId::DATE],
-		                "Date Format", error);
-	}
-	if (found_timestamp) {
-		MatchAndReplace(original.date_format[LogicalTypeId::TIMESTAMP], sniffed.date_format[LogicalTypeId::TIMESTAMP],
-		                "Timestamp Format", error);
-	}
-}
-// Set the CSV Options in the reference
-void CSVSniffer::SetResultOptions() const {
-	bool found_date = false;
-	bool found_timestamp = false;
-	for (auto &type : detected_types) {
-		if (type == LogicalType::DATE) {
-			found_date = true;
-		} else if (type == LogicalType::TIMESTAMP) {
-			found_timestamp = true;
-		}
-	}
-	MatchAndReplaceUserSetVariables(options.dialect_options, best_candidate->GetStateMachine().dialect_options,
-	                                options.sniffer_user_mismatch_error, found_date, found_timestamp);
-	options.dialect_options.num_cols = best_candidate->GetStateMachine().dialect_options.num_cols;
-	options.dialect_options.rows_until_header = best_candidate->GetStateMachine().dialect_options.rows_until_header;
-}
-
-AdaptiveSnifferResult CSVSniffer::MinimalSniff() {
-	if (set_columns.IsSet()) {
-		// Nothing to see here
-		return AdaptiveSnifferResult(*set_columns.types, *set_columns.names, true);
-	}
-	// Return Types detected
-	vector<LogicalType> return_types;
-	// Column Names detected
-	buffer_manager->sniffing = true;
-	constexpr idx_t result_size = STANDARD_VECTOR_SIZE;
-
-	auto state_machine =
-	    make_shared_ptr<CSVStateMachine>(options, options.dialect_options.state_machine_options, state_machine_cache);
-	ColumnCountScanner count_scanner(buffer_manager, state_machine, error_handler, result_size);
-	auto &sniffed_column_counts = count_scanner.ParseChunk();
-	if (sniffed_column_counts.result_position == 0) {
-		// The file is an empty file, we just return
-		return {{}, {}, false};
-	}
-
-	state_machine->dialect_options.num_cols = sniffed_column_counts[0].number_of_columns;
-	options.dialect_options.num_cols = sniffed_column_counts[0].number_of_columns;
-
-	// First figure out the number of columns on this configuration
-	auto scanner = count_scanner.UpgradeToStringValueScanner();
-	scanner->error_handler->SetIgnoreErrors(true);
-	// Parse chunk and read csv with info candidate
-	auto &data_chunk = scanner->ParseChunk().ToChunk();
-	idx_t start_row = 0;
-	if (sniffed_column_counts.result_position == 2) {
-		// If equal to two, we will only use the second row for type checking
-		start_row = 1;
-	}
-
-	// Gather Types
-	for (idx_t i = 0; i < state_machine->dialect_options.num_cols; i++) {
-		best_sql_types_candidates_per_column_idx[i] = state_machine->options.auto_type_candidates;
-	}
-	SniffTypes(data_chunk, *state_machine, best_sql_types_candidates_per_column_idx, start_row);
-
-	// Possibly Gather Header
-	vector<HeaderValue> potential_header;
-	for (idx_t col_idx = 0; col_idx < data_chunk.ColumnCount(); col_idx++) {
-		auto &cur_vector = data_chunk.data[col_idx];
-		const auto vector_data = FlatVector::GetData<string_t>(cur_vector);
-		auto &validity = FlatVector::Validity(cur_vector);
-		HeaderValue val;
-		if (validity.RowIsValid(0)) {
-			val = HeaderValue(vector_data[0]);
-		}
-		potential_header.emplace_back(val);
-	}
-
-	auto names = DetectHeaderInternal(buffer_manager->context, potential_header, *state_machine, set_columns,
-	                                  best_sql_types_candidates_per_column_idx, options, *error_handler);
-
-	for (idx_t column_idx = 0; column_idx < best_sql_types_candidates_per_column_idx.size(); column_idx++) {
-		LogicalType d_type = best_sql_types_candidates_per_column_idx[column_idx].back();
-		if (best_sql_types_candidates_per_column_idx[column_idx].size() == options.auto_type_candidates.size()) {
-			d_type = LogicalType::VARCHAR;
-		}
-		detected_types.push_back(d_type);
-	}
-	return {detected_types, names, sniffed_column_counts.result_position > 1};
-}
-
-SnifferResult CSVSniffer::AdaptiveSniff(const CSVSchema &file_schema) {
-	auto min_sniff_res = MinimalSniff();
-	bool run_full = error_handler->AnyErrors() || detection_error_handler->AnyErrors();
-	// Check if we are happy with the result or if we need to do more sniffing
-	if (!error_handler->AnyErrors() && !detection_error_handler->AnyErrors()) {
-		// If we got no errors, we also run full if schemas do not match.
-		if (!set_columns.IsSet() && !options.file_options.AnySet()) {
-			string error;
-			run_full = !file_schema.SchemasMatch(error, min_sniff_res, options.file_path, true);
-		}
-	}
-	if (run_full) {
-		// We run full sniffer
-		auto full_sniffer = SniffCSV();
-		if (!set_columns.IsSet() && !options.file_options.AnySet()) {
-			string error;
-			if (!file_schema.SchemasMatch(error, full_sniffer, options.file_path, false) &&
-			    !options.ignore_errors.GetValue()) {
-				throw InvalidInputException(error);
-			}
-		}
-		return full_sniffer;
-	}
-	return min_sniff_res.ToSnifferResult();
-}
-
-SnifferResult CSVSniffer::SniffCSV(const bool force_match) {
-	buffer_manager->sniffing = true;
-	// 1. Dialect Detection
-	DetectDialect();
-	if (buffer_manager->file_handle->compression_type != FileCompressionType::UNCOMPRESSED &&
-	    buffer_manager->IsBlockUnloaded(0)) {
-		buffer_manager->ResetBufferManager();
-	}
-	// 2. Type Detection
-	DetectTypes();
-	// 3. Type Refinement
-	RefineTypes();
-	// 4. Header Detection
-	DetectHeader();
-	// 5. Type Replacement
-	ReplaceTypes();
-
-	// We reset the buffer for compressed files
-	// This is done because we can't easily seek on compressed files, if a buffer goes out of scope we must read from
-	// the start
-	if (buffer_manager->file_handle->compression_type != FileCompressionType::UNCOMPRESSED) {
-		buffer_manager->ResetBufferManager();
-	}
-	buffer_manager->sniffing = false;
-	if (best_candidate->error_handler->AnyErrors() && !options.ignore_errors.GetValue()) {
-		best_candidate->error_handler->ErrorIfTypeExists(MAXIMUM_LINE_SIZE);
-	}
-	D_ASSERT(best_sql_types_candidates_per_column_idx.size() == names.size());
-	// We are done, Set the CSV Options in the reference. Construct and return the result.
-	SetResultOptions();
-	options.auto_detect = true;
-	// Check if everything matches
-	auto &error = options.sniffer_user_mismatch_error;
-	if (set_columns.IsSet()) {
-		bool match = true;
-		// Columns and their types were set, let's validate they match
-		if (options.dialect_options.header.GetValue()) {
-			// If the header exists it should match
-			string header_error = "The Column names set by the user do not match the ones found by the sniffer. \n";
-			auto &set_names = *set_columns.names;
-			if (set_names.size() == names.size()) {
-				for (idx_t i = 0; i < set_columns.Size(); i++) {
-					if (set_names[i] != names[i]) {
-						header_error += "Column at position: " + to_string(i) + ", Set name: " + set_names[i] +
-						                ", Sniffed Name: " + names[i] + "\n";
-						match = false;
-					}
-				}
-			}
-
-			if (!match) {
-				error += header_error;
-			}
-		}
-		match = true;
-		string type_error = "The Column types set by the user do not match the ones found by the sniffer. \n";
-		auto &set_types = *set_columns.types;
-		if (detected_types.size() == set_columns.Size()) {
-			for (idx_t i = 0; i < set_columns.Size(); i++) {
-				if (set_types[i] != detected_types[i]) {
-					type_error += "Column at position: " + to_string(i) + " Set type: " + set_types[i].ToString() +
-					              " Sniffed type: " + detected_types[i].ToString() + "\n";
-					detected_types[i] = set_types[i];
-					manually_set[i] = true;
-					match = false;
-				}
-			}
-		}
-
-		if (!match) {
-			error += type_error;
-		}
-
-		if (!error.empty() && force_match) {
-			throw InvalidInputException(error);
-		}
-		options.was_type_manually_set = manually_set;
-	}
-	if (!error.empty() && force_match) {
-		throw InvalidInputException(error);
-	}
-	options.was_type_manually_set = manually_set;
-	if (set_columns.IsSet()) {
-		return SnifferResult(*set_columns.types, *set_columns.names);
-	}
-	return SnifferResult(detected_types, names);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp
deleted file mode 100644
index 5cced646d..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp
+++ /dev/null
@@ -1,597 +0,0 @@
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-
-namespace duckdb {
-
-constexpr idx_t CSVReaderOptions::sniff_size;
-
-bool IsQuoteDefault(char quote) {
-	if (quote == '\"' || quote == '\'' || quote == '\0') {
-		return true;
-	}
-	return false;
-}
-
-vector<string> DialectCandidates::GetDefaultDelimiter() {
-	return {",", "|", ";", "\t"};
-}
-
-vector<vector<char>> DialectCandidates::GetDefaultQuote() {
-	return {{'\0'}, {'\"', '\''}, {'\"'}};
-}
-
-vector<QuoteRule> DialectCandidates::GetDefaultQuoteRule() {
-	return {QuoteRule::NO_QUOTES, QuoteRule::QUOTES_OTHER, QuoteRule::QUOTES_RFC};
-}
-
-vector<vector<char>> DialectCandidates::GetDefaultEscape() {
-	return {{'\0'}, {'\\'}, {'\"', '\0', '\''}};
-}
-
-vector<char> DialectCandidates::GetDefaultComment() {
-	return {'#', '\0'};
-}
-
-string DialectCandidates::Print() {
-	std::ostringstream search_space;
-
-	search_space << "Delimiter Candidates: ";
-	for (idx_t i = 0; i < delim_candidates.size(); i++) {
-		search_space << "\'" << delim_candidates[i] << "\'";
-		if (i < delim_candidates.size() - 1) {
-			search_space << ", ";
-		}
-	}
-	search_space << "\n";
-	search_space << "Quote/Escape Candidates: ";
-	for (uint8_t i = 0; i < static_cast<uint8_t>(quote_rule_candidates.size()); i++) {
-		auto quote_candidate = quote_candidates_map[i];
-		auto escape_candidate = escape_candidates_map[i];
-		for (idx_t j = 0; j < quote_candidate.size(); j++) {
-			for (idx_t k = 0; k < escape_candidate.size(); k++) {
-				search_space << "[\'";
-				if (quote_candidate[j] == '\0') {
-					search_space << "(no quote)";
-				} else {
-					search_space << quote_candidate[j];
-				}
-				search_space << "\',\'";
-				if (escape_candidate[k] == '\0') {
-					search_space << "(no escape)";
-				} else {
-					search_space << escape_candidate[k];
-				}
-				search_space << "\']";
-				if (k < escape_candidate.size() - 1) {
-					search_space << ",";
-				}
-			}
-			if (j < quote_candidate.size() - 1) {
-				search_space << ",";
-			}
-		}
-		if (i < quote_rule_candidates.size() - 1) {
-			search_space << ",";
-		}
-	}
-	search_space << "\n";
-
-	search_space << "Comment Candidates: ";
-	for (idx_t i = 0; i < comment_candidates.size(); i++) {
-		search_space << "\'" << comment_candidates[i] << "\'";
-		if (i < comment_candidates.size() - 1) {
-			search_space << ", ";
-		}
-	}
-	search_space << "\n";
-
-	return search_space.str();
-}
-
-DialectCandidates::DialectCandidates(const CSVStateMachineOptions &options) {
-	// assert that quotes escapes and rules have equal size
-	const auto default_quote = GetDefaultQuote();
-	const auto default_escape = GetDefaultEscape();
-	const auto default_quote_rule = GetDefaultQuoteRule();
-	const auto default_delimiter = GetDefaultDelimiter();
-	const auto default_comment = GetDefaultComment();
-
-	D_ASSERT(default_quote.size() == default_quote_rule.size() && default_quote_rule.size() == default_escape.size());
-	// fill the escapes
-	for (idx_t i = 0; i < default_quote_rule.size(); i++) {
-		escape_candidates_map[static_cast<uint8_t>(default_quote_rule[i])] = default_escape[i];
-	}
-
-	if (options.delimiter.IsSetByUser()) {
-		// user provided a delimiter: use that delimiter
-		delim_candidates = {options.delimiter.GetValue()};
-	} else {
-		// no delimiter provided: try standard/common delimiters
-		delim_candidates = default_delimiter;
-	}
-	if (options.comment.IsSetByUser()) {
-		// user provided comment character: use that as a comment
-		comment_candidates = {options.comment.GetValue()};
-	} else {
-		// no comment provided: try standard/common comments
-		comment_candidates = default_comment;
-	}
-	if (options.quote.IsSetByUser()) {
-		// user provided quote: use that quote rule
-		for (auto &quote_rule : default_quote_rule) {
-			quote_candidates_map[static_cast<uint8_t>(quote_rule)] = {options.quote.GetValue()};
-		}
-		// also add it as an escape rule
-		if (!IsQuoteDefault(options.quote.GetValue())) {
-			escape_candidates_map[static_cast<uint8_t>(QuoteRule::QUOTES_RFC)].emplace_back(options.quote.GetValue());
-		}
-	} else {
-		// no quote rule provided: use standard/common quotes
-		for (idx_t i = 0; i < default_quote_rule.size(); i++) {
-			quote_candidates_map[static_cast<uint8_t>(default_quote_rule[i])] = {default_quote[i]};
-		}
-	}
-	if (options.escape.IsSetByUser()) {
-		// user provided escape: use that escape rule
-		if (options.escape == '\0') {
-			quote_rule_candidates = {QuoteRule::QUOTES_RFC};
-		} else {
-			quote_rule_candidates = {QuoteRule::QUOTES_OTHER};
-		}
-		escape_candidates_map[static_cast<uint8_t>(quote_rule_candidates[0])] = {options.escape.GetValue()};
-	} else {
-		// no escape provided: try standard/common escapes
-		quote_rule_candidates = default_quote_rule;
-	}
-}
-
-void CSVSniffer::GenerateStateMachineSearchSpace(vector<unique_ptr<ColumnCountScanner>> &column_count_scanners,
-                                                 const DialectCandidates &dialect_candidates) {
-	// Generate state machines for all option combinations
-	NewLineIdentifier new_line_id;
-	if (options.dialect_options.state_machine_options.new_line.IsSetByUser()) {
-		new_line_id = options.dialect_options.state_machine_options.new_line.GetValue();
-	} else {
-		new_line_id = DetectNewLineDelimiter(*buffer_manager);
-	}
-	// We only sniff RFC 4180 rules, unless manually set by user.
-	bool rfc_4180 = true;
-	if (options.dialect_options.state_machine_options.rfc_4180.IsSetByUser()) {
-		rfc_4180 = options.dialect_options.state_machine_options.rfc_4180.GetValue();
-	}
-	CSVIterator first_iterator;
-	bool iterator_set = false;
-	for (const auto quote_rule : dialect_candidates.quote_rule_candidates) {
-		const auto &quote_candidates = dialect_candidates.quote_candidates_map.at(static_cast<uint8_t>(quote_rule));
-		for (const auto &quote : quote_candidates) {
-			for (const auto &delimiter : dialect_candidates.delim_candidates) {
-				const auto &escape_candidates =
-				    dialect_candidates.escape_candidates_map.at(static_cast<uint8_t>(quote_rule));
-				for (const auto &escape : escape_candidates) {
-					for (const auto &comment : dialect_candidates.comment_candidates) {
-						D_ASSERT(buffer_manager);
-						CSVStateMachineOptions state_machine_options(delimiter, quote, escape, comment, new_line_id,
-						                                             rfc_4180);
-						auto sniffing_state_machine =
-						    make_shared_ptr<CSVStateMachine>(options, state_machine_options, state_machine_cache);
-						if (options.dialect_options.skip_rows.IsSetByUser()) {
-							if (!iterator_set) {
-								first_iterator = BaseScanner::SkipCSVRows(buffer_manager, sniffing_state_machine,
-								                                          options.dialect_options.skip_rows.GetValue());
-								iterator_set = true;
-							}
-							column_count_scanners.emplace_back(make_uniq<ColumnCountScanner>(
-							    buffer_manager, std::move(sniffing_state_machine), detection_error_handler,
-							    CSVReaderOptions::sniff_size, first_iterator));
-							continue;
-						}
-						column_count_scanners.emplace_back(
-						    make_uniq<ColumnCountScanner>(buffer_manager, std::move(sniffing_state_machine),
-						                                  detection_error_handler, CSVReaderOptions::sniff_size));
-					}
-				}
-			}
-		}
-	}
-}
-
-// Returns true if a comment is acceptable
-bool AreCommentsAcceptable(const ColumnCountResult &result, idx_t num_cols, bool comment_set_by_user) {
-	if (comment_set_by_user) {
-		return true;
-	}
-	// For a comment to be acceptable, we want 3/5th's the majority of unmatched in the columns
-	constexpr double min_majority = 0.6;
-	// detected comments, are all lines that started with a comment character.
-	double detected_comments = 0;
-	// If at least one comment is a full line comment
-	bool has_full_line_comment = false;
-	// valid comments are all lines where the number of columns does not fit our expected number of columns.
-	double valid_comments = 0;
-	for (idx_t i = 0; i < result.result_position; i++) {
-		if (result.column_counts[i].is_comment || result.column_counts[i].is_mid_comment) {
-			detected_comments++;
-			if (result.column_counts[i].number_of_columns != num_cols && result.column_counts[i].is_comment) {
-				has_full_line_comment = true;
-				valid_comments++;
-			}
-			if (result.column_counts[i].number_of_columns == num_cols && result.column_counts[i].is_mid_comment) {
-				valid_comments++;
-			}
-		}
-	}
-	// If we do not encounter at least one full line comment, we do not consider this comment option.
-	if (valid_comments == 0 || !has_full_line_comment) {
-		// this is only valid if our comment character is \0
-		if (result.state_machine.state_machine_options.comment.GetValue() == '\0') {
-			return true;
-		}
-		return false;
-	}
-
-	return valid_comments / detected_comments >= min_majority;
-}
-
-void CSVSniffer::AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner> scanner, idx_t &rows_read,
-                                         idx_t &best_consistent_rows, idx_t &prev_padding_count,
-                                         idx_t &min_ignored_rows) {
-	// The sniffed_column_counts variable keeps track of the number of columns found for each row
-	auto &sniffed_column_counts = scanner->ParseChunk();
-	idx_t dirty_notes = 0;
-	idx_t dirty_notes_minus_comments = 0;
-	if (sniffed_column_counts.error) {
-		// This candidate has an error (i.e., over maximum line size or never unquoting quoted values)
-		return;
-	}
-	idx_t consistent_rows = 0;
-	idx_t num_cols = sniffed_column_counts.result_position == 0 ? 1 : sniffed_column_counts[0].number_of_columns;
-	const bool ignore_errors = options.ignore_errors.GetValue();
-	// If we are ignoring errors and not null_padding , we pick the most frequent number of columns as the right one
-	const bool use_most_frequent_columns = ignore_errors && !options.null_padding;
-	if (use_most_frequent_columns) {
-		num_cols = sniffed_column_counts.GetMostFrequentColumnCount();
-	}
-	idx_t padding_count = 0;
-	idx_t comment_rows = 0;
-	idx_t ignored_rows = 0;
-	const bool allow_padding = options.null_padding;
-	bool first_valid = false;
-	if (sniffed_column_counts.result_position > rows_read) {
-		rows_read = sniffed_column_counts.result_position;
-	}
-	if (set_columns.IsCandidateUnacceptable(num_cols, options.null_padding, ignore_errors,
-	                                        sniffed_column_counts[0].last_value_always_empty)) {
-		// Not acceptable
-		return;
-	}
-	idx_t header_idx = 0;
-	for (idx_t row = 0; row < sniffed_column_counts.result_position; row++) {
-		if (set_columns.IsCandidateUnacceptable(sniffed_column_counts[row].number_of_columns, options.null_padding,
-		                                        ignore_errors, sniffed_column_counts[row].last_value_always_empty)) {
-			// Not acceptable
-			return;
-		}
-		if (sniffed_column_counts[row].is_comment) {
-			comment_rows++;
-		} else if (sniffed_column_counts[row].last_value_always_empty &&
-		           sniffed_column_counts[row].number_of_columns ==
-		               sniffed_column_counts[header_idx].number_of_columns + 1) {
-			// we allow for the first row to miss one column IF last_value_always_empty is true
-			// This is so we can sniff files that have an extra delimiter on the data part.
-			// e.g., C1|C2\n1|2|\n3|4|
-			consistent_rows++;
-		} else if (num_cols < sniffed_column_counts[row].number_of_columns &&
-		           (!options.dialect_options.skip_rows.IsSetByUser() || comment_rows > 0) &&
-		           (!set_columns.IsSet() || options.null_padding) && (!first_valid || (!use_most_frequent_columns))) {
-			// all rows up to this point will need padding
-			if (!first_valid) {
-				first_valid = true;
-				sniffed_column_counts.state_machine.dialect_options.rows_until_header = row;
-			}
-			padding_count = 0;
-			// we use the maximum amount of num_cols that we find
-			num_cols = sniffed_column_counts[row].number_of_columns;
-			dirty_notes = row;
-			dirty_notes_minus_comments = dirty_notes - comment_rows;
-			header_idx = row;
-			consistent_rows = 1;
-		} else if (sniffed_column_counts[row].number_of_columns == num_cols || (use_most_frequent_columns)) {
-			if (!first_valid) {
-				first_valid = true;
-				sniffed_column_counts.state_machine.dialect_options.rows_until_header = row;
-				dirty_notes = row;
-			}
-			if (sniffed_column_counts[row].number_of_columns != num_cols) {
-				ignored_rows++;
-			}
-			consistent_rows++;
-		} else if (num_cols >= sniffed_column_counts[row].number_of_columns) {
-			// we are missing some columns, we can parse this as long as we add padding
-			padding_count++;
-		}
-	}
-
-	if (sniffed_column_counts.state_machine.options.dialect_options.skip_rows.IsSetByUser()) {
-		sniffed_column_counts.state_machine.dialect_options.rows_until_header +=
-		    sniffed_column_counts.state_machine.options.dialect_options.skip_rows.GetValue();
-	}
-	// Calculate the total number of consistent rows after adding padding.
-	consistent_rows += padding_count;
-
-	// Whether there are more values (rows) available that are consistent, exceeding the current best.
-	const bool more_values = consistent_rows > best_consistent_rows && num_cols >= max_columns_found;
-
-	const bool more_columns = consistent_rows == best_consistent_rows && num_cols > max_columns_found;
-
-	// If additional padding is required when compared to the previous padding count.
-	const bool require_more_padding = padding_count > prev_padding_count;
-
-	// If less padding is now required when compared to the previous padding count.
-	const bool require_less_padding = padding_count < prev_padding_count;
-
-	// If there was only a single column before, and the new number of columns exceeds that.
-	const bool single_column_before = max_columns_found < 2 && num_cols > max_columns_found * candidates.size();
-
-	// If the number of rows is consistent with the calculated value after accounting for skipped rows and the
-	// start row.
-	const bool rows_consistent =
-	    consistent_rows + (dirty_notes_minus_comments - options.dialect_options.skip_rows.GetValue()) + comment_rows ==
-	    sniffed_column_counts.result_position - options.dialect_options.skip_rows.GetValue();
-	// If there are more than one consistent row.
-	const bool more_than_one_row = consistent_rows > 1;
-
-	// If there are more than one column.
-	const bool more_than_one_column = num_cols > 1;
-
-	// If the start position is valid.
-	const bool start_good = !candidates.empty() &&
-	                        dirty_notes <= candidates.front()->GetStateMachine().dialect_options.skip_rows.GetValue();
-
-	// If padding happened but it is not allowed.
-	const bool invalid_padding = !allow_padding && padding_count > 0;
-
-	const bool comments_are_acceptable = AreCommentsAcceptable(
-	    sniffed_column_counts, num_cols, options.dialect_options.state_machine_options.comment.IsSetByUser());
-
-	const bool quoted =
-	    scanner->ever_quoted &&
-	    sniffed_column_counts.state_machine.dialect_options.state_machine_options.quote.GetValue() != '\0';
-
-	// For our columns to match, we either don't have them manually set, or they match in value with the sniffed value
-	const bool columns_match_set =
-	    num_cols == set_columns.Size() ||
-	    (num_cols == set_columns.Size() + 1 && sniffed_column_counts[0].last_value_always_empty) ||
-	    !set_columns.IsSet();
-
-	// If rows are consistent and no invalid padding happens, this is the best suitable candidate if one of the
-	// following is valid:
-	// - There's a single column before.
-	// - There are more values and no additional padding is required.
-	// - There's more than one column and less padding is required.
-	if (columns_match_set && (rows_consistent || (set_columns.IsSet() && ignore_errors)) &&
-	    (single_column_before || ((more_values || more_columns) && !require_more_padding) ||
-	     (more_than_one_column && require_less_padding) || quoted) &&
-	    !invalid_padding && comments_are_acceptable) {
-		if (!candidates.empty() && set_columns.IsSet() && max_columns_found == set_columns.Size() &&
-		    consistent_rows <= best_consistent_rows) {
-			// We have a candidate that fits our requirements better
-			if (candidates.front()->ever_quoted || !scanner->ever_quoted) {
-				return;
-			}
-		}
-		auto &sniffing_state_machine = scanner->GetStateMachine();
-
-		if (!candidates.empty() && candidates.front()->ever_quoted) {
-			// Give preference to quoted boys.
-			if (!scanner->ever_quoted) {
-				return;
-			} else {
-				// Give preference to one that got escaped
-				if (!scanner->ever_escaped && candidates.front()->ever_escaped) {
-					return;
-				}
-				if (best_consistent_rows == consistent_rows && num_cols >= max_columns_found) {
-					// If both have not been escaped, this might get solved later on.
-					sniffing_state_machine.dialect_options.num_cols = num_cols;
-					candidates.emplace_back(std::move(scanner));
-					max_columns_found = num_cols;
-					return;
-				}
-			}
-		}
-		if (max_columns_found == num_cols && ignored_rows > min_ignored_rows) {
-			return;
-		}
-		if (quoted && num_cols < max_columns_found) {
-			for (auto &candidate : candidates) {
-				if (candidate->ever_quoted) {
-					return;
-				}
-			}
-		}
-		best_consistent_rows = consistent_rows;
-		max_columns_found = num_cols;
-		prev_padding_count = padding_count;
-		min_ignored_rows = ignored_rows;
-
-		if (options.dialect_options.skip_rows.IsSetByUser()) {
-			// If skip rows is set by user, and we found dirty notes, we only accept it if either null_padding or
-			// ignore_errors is set we have comments
-			if (dirty_notes != 0 && !options.null_padding && !options.ignore_errors.GetValue() && comment_rows == 0) {
-				return;
-			}
-			sniffing_state_machine.dialect_options.skip_rows = options.dialect_options.skip_rows.GetValue();
-		} else if (!options.null_padding) {
-			sniffing_state_machine.dialect_options.skip_rows = dirty_notes;
-		}
-
-		candidates.clear();
-		sniffing_state_machine.dialect_options.num_cols = num_cols;
-		lines_sniffed = sniffed_column_counts.result_position;
-		candidates.emplace_back(std::move(scanner));
-		return;
-	}
-	// If there's more than one row and column, the start is good, rows are consistent,
-	// no additional padding is required, and there is no invalid padding, and there is not yet a candidate
-	// with the same quote, we add this state_machine as a suitable candidate.
-	if (columns_match_set && more_than_one_row && more_than_one_column && start_good && rows_consistent &&
-	    !require_more_padding && !invalid_padding && num_cols == max_columns_found && comments_are_acceptable) {
-		auto &sniffing_state_machine = scanner->GetStateMachine();
-
-		bool same_quote_is_candidate = false;
-		for (const auto &candidate : candidates) {
-			if (sniffing_state_machine.dialect_options.state_machine_options.quote ==
-			    candidate->GetStateMachine().dialect_options.state_machine_options.quote) {
-				same_quote_is_candidate = true;
-			}
-		}
-		if (!same_quote_is_candidate) {
-			if (options.dialect_options.skip_rows.IsSetByUser()) {
-				// If skip rows is set by user, and we found dirty notes, we only accept it if either null_padding or
-				// ignore_errors is set
-				if (dirty_notes != 0 && !options.null_padding && !options.ignore_errors.GetValue()) {
-					return;
-				}
-				sniffing_state_machine.dialect_options.skip_rows = options.dialect_options.skip_rows.GetValue();
-			} else if (!options.null_padding) {
-				sniffing_state_machine.dialect_options.skip_rows = dirty_notes;
-			}
-			sniffing_state_machine.dialect_options.num_cols = num_cols;
-			lines_sniffed = sniffed_column_counts.result_position;
-			candidates.emplace_back(std::move(scanner));
-		}
-	}
-}
-
-bool CSVSniffer::RefineCandidateNextChunk(ColumnCountScanner &candidate) const {
-	auto &sniffed_column_counts = candidate.ParseChunk();
-	for (idx_t i = 0; i < sniffed_column_counts.result_position; i++) {
-		if (set_columns.IsSet()) {
-			return !set_columns.IsCandidateUnacceptable(sniffed_column_counts[i].number_of_columns,
-			                                            options.null_padding, options.ignore_errors.GetValue(),
-			                                            sniffed_column_counts[i].last_value_always_empty);
-		}
-		if (max_columns_found != sniffed_column_counts[i].number_of_columns &&
-		    (!options.null_padding && !options.ignore_errors.GetValue() && !sniffed_column_counts[i].is_comment)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void CSVSniffer::RefineCandidates() {
-	// It's very frequent that more than one dialect can parse a csv file, hence here we run one state machine
-	// fully on the whole sample dataset, when/if it fails we go to the next one.
-	if (candidates.empty()) {
-		// No candidates to refine
-		return;
-	}
-	if (candidates.size() == 1 || candidates[0]->FinishedFile()) {
-		// Only one candidate nothing to refine or all candidates already checked
-		return;
-	}
-
-	for (idx_t i = 1; i <= options.sample_size_chunks; i++) {
-		vector<unique_ptr<ColumnCountScanner>> successful_candidates;
-		bool done = false;
-		for (auto &cur_candidate : candidates) {
-			const bool finished_file = cur_candidate->FinishedFile();
-			if (successful_candidates.empty()) {
-				lines_sniffed += cur_candidate->GetResult().result_position;
-			}
-			if (finished_file || i == options.sample_size_chunks) {
-				// we finished the file or our chunk sample successfully
-				if (!cur_candidate->GetResult().error) {
-					successful_candidates.push_back(std::move(cur_candidate));
-				}
-				done = true;
-				continue;
-			}
-			if (RefineCandidateNextChunk(*cur_candidate) && !cur_candidate->GetResult().error) {
-				successful_candidates.push_back(std::move(cur_candidate));
-			}
-		}
-		candidates = std::move(successful_candidates);
-		if (done) {
-			break;
-		}
-	}
-	// If we have multiple candidates with quotes set, we will give the preference to ones
-	// that have actually quoted values, otherwise we will choose quotes = \0
-	vector<unique_ptr<ColumnCountScanner>> successful_candidates = std::move(candidates);
-	if (!successful_candidates.empty()) {
-		for (idx_t i = 0; i < successful_candidates.size(); i++) {
-			unique_ptr<ColumnCountScanner> cc_best_candidate = std::move(successful_candidates[i]);
-			if (cc_best_candidate->state_machine->state_machine_options.quote != '\0' &&
-			    cc_best_candidate->ever_quoted) {
-				candidates.clear();
-				candidates.push_back(std::move(cc_best_candidate));
-				return;
-			}
-			candidates.push_back(std::move(cc_best_candidate));
-		}
-	}
-}
-
-NewLineIdentifier CSVSniffer::DetectNewLineDelimiter(CSVBufferManager &buffer_manager) {
-	// Get first buffer
-	auto buffer = buffer_manager.GetBuffer(0);
-	auto buffer_ptr = buffer->Ptr();
-	bool carriage_return = false;
-	bool n = false;
-	for (idx_t i = 0; i < buffer->actual_size; i++) {
-		if (buffer_ptr[i] == '\r') {
-			carriage_return = true;
-		} else if (buffer_ptr[i] == '\n') {
-			n = true;
-			break;
-		} else if (carriage_return) {
-			break;
-		}
-	}
-	if (carriage_return && n) {
-		return NewLineIdentifier::CARRY_ON;
-	}
-	if (carriage_return) {
-		return NewLineIdentifier::SINGLE_R;
-	}
-	return NewLineIdentifier::SINGLE_N;
-}
-
-// Dialect Detection consists of five steps:
-// 1. Generate a search space of all possible dialects
-// 2. Generate a state machine for each dialect
-// 3. Analyze the first chunk of the file and find the best dialect candidates
-// 4. Analyze the remaining chunks of the file and find the best dialect candidate
-void CSVSniffer::DetectDialect() {
-	// Variables for Dialect Detection
-	DialectCandidates dialect_candidates(options.dialect_options.state_machine_options);
-	// Number of rows read
-	idx_t rows_read = 0;
-	// Best Number of consistent rows (i.e., presenting all columns)
-	idx_t best_consistent_rows = 0;
-	// If padding was necessary (i.e., rows are missing some columns, how many)
-	idx_t prev_padding_count = 0;
-	// Min number of ignores rows
-	idx_t best_ignored_rows = 0;
-	// Vector of CSV State Machines
-	vector<unique_ptr<ColumnCountScanner>> csv_state_machines;
-	// Step 1: Generate state machines
-	GenerateStateMachineSearchSpace(csv_state_machines, dialect_candidates);
-	// Step 2: Analyze all candidates on the first chunk
-	for (auto &state_machine : csv_state_machines) {
-		AnalyzeDialectCandidate(std::move(state_machine), rows_read, best_consistent_rows, prev_padding_count,
-		                        best_ignored_rows);
-	}
-	// Step 3: Loop over candidates and find if they can still produce good results for the remaining chunks
-	RefineCandidates();
-
-	// if no dialect candidate was found, we throw an exception
-	if (candidates.empty()) {
-		auto error = CSVError::SniffingError(options, dialect_candidates.Print());
-		error_handler->Error(error, true);
-	}
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp
deleted file mode 100644
index 424468c55..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp
+++ /dev/null
@@ -1,343 +0,0 @@
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-
-#include "utf8proc.hpp"
-
-namespace duckdb {
-// Helper function to generate column names
-static string GenerateColumnName(const idx_t total_cols, const idx_t col_number, const string &prefix = "column") {
-	auto max_digits = NumericHelper::UnsignedLength(total_cols - 1);
-	auto digits = NumericHelper::UnsignedLength(col_number);
-	string leading_zeros = string(NumericCast<idx_t>(max_digits - digits), '0');
-	string value = to_string(col_number);
-	return string(prefix + leading_zeros + value);
-}
-
-// Helper function for UTF-8 aware space trimming
-static string TrimWhitespace(const string &col_name) {
-	utf8proc_int32_t codepoint;
-	const auto str = reinterpret_cast<const utf8proc_uint8_t *>(col_name.c_str());
-	const idx_t size = col_name.size();
-	// Find the first character that is not left trimmed
-	idx_t begin = 0;
-	while (begin < size) {
-		auto bytes = utf8proc_iterate(str + begin, NumericCast<utf8proc_ssize_t>(size - begin), &codepoint);
-		D_ASSERT(bytes > 0);
-		if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-			break;
-		}
-		begin += NumericCast<idx_t>(bytes);
-	}
-
-	// Find the last character that is not right trimmed
-	idx_t end = begin;
-	for (auto next = begin; next < col_name.size();) {
-		auto bytes = utf8proc_iterate(str + next, NumericCast<utf8proc_ssize_t>(size - next), &codepoint);
-		D_ASSERT(bytes > 0);
-		next += NumericCast<idx_t>(bytes);
-		if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-			end = next;
-		}
-	}
-
-	// return the trimmed string
-	return col_name.substr(begin, end - begin);
-}
-
-static string NormalizeColumnName(const string &col_name) {
-	// normalize UTF8 characters to NFKD
-	auto nfkd = utf8proc_NFKD(reinterpret_cast<const utf8proc_uint8_t *>(col_name.c_str()),
-	                          NumericCast<utf8proc_ssize_t>(col_name.size()));
-	const string col_name_nfkd = string(const_char_ptr_cast(nfkd), strlen(const_char_ptr_cast(nfkd)));
-	free(nfkd);
-
-	// only keep ASCII characters 0-9 a-z A-Z and replace spaces with regular whitespace
-	string col_name_ascii = "";
-	for (idx_t i = 0; i < col_name_nfkd.size(); i++) {
-		if (col_name_nfkd[i] == '_' || (col_name_nfkd[i] >= '0' && col_name_nfkd[i] <= '9') ||
-		    (col_name_nfkd[i] >= 'A' && col_name_nfkd[i] <= 'Z') ||
-		    (col_name_nfkd[i] >= 'a' && col_name_nfkd[i] <= 'z')) {
-			col_name_ascii += col_name_nfkd[i];
-		} else if (StringUtil::CharacterIsSpace(col_name_nfkd[i])) {
-			col_name_ascii += " ";
-		}
-	}
-
-	// trim whitespace and replace remaining whitespace by _
-	string col_name_trimmed = TrimWhitespace(col_name_ascii);
-	string col_name_cleaned = "";
-	bool in_whitespace = false;
-	for (idx_t i = 0; i < col_name_trimmed.size(); i++) {
-		if (col_name_trimmed[i] == ' ') {
-			if (!in_whitespace) {
-				col_name_cleaned += "_";
-				in_whitespace = true;
-			}
-		} else {
-			col_name_cleaned += col_name_trimmed[i];
-			in_whitespace = false;
-		}
-	}
-
-	// don't leave string empty; if not empty, make lowercase
-	if (col_name_cleaned.empty()) {
-		col_name_cleaned = "_";
-	} else {
-		col_name_cleaned = StringUtil::Lower(col_name_cleaned);
-	}
-
-	// prepend _ if name starts with a digit or is a reserved keyword
-	auto keyword = KeywordHelper::KeywordCategoryType(col_name_cleaned);
-	if (keyword == KeywordCategory::KEYWORD_TYPE_FUNC || keyword == KeywordCategory::KEYWORD_RESERVED ||
-	    (col_name_cleaned[0] >= '0' && col_name_cleaned[0] <= '9')) {
-		col_name_cleaned = "_" + col_name_cleaned;
-	}
-	return col_name_cleaned;
-}
-
-static void ReplaceNames(vector<string> &detected_names, CSVStateMachine &state_machine,
-                         unordered_map<idx_t, vector<LogicalType>> &best_sql_types_candidates_per_column_idx,
-                         CSVReaderOptions &options, const vector<HeaderValue> &best_header_row,
-                         CSVErrorHandler &error_handler) {
-	auto &dialect_options = state_machine.dialect_options;
-	if (!options.columns_set) {
-		if (options.file_options.hive_partitioning || options.file_options.union_by_name || options.multi_file_reader) {
-			// Just do the replacement
-			for (idx_t i = 0; i < MinValue<idx_t>(detected_names.size(), options.name_list.size()); i++) {
-				detected_names[i] = options.name_list[i];
-			}
-			return;
-		}
-		if (options.name_list.size() > dialect_options.num_cols) {
-			if (options.null_padding) {
-				// we increase our types
-				idx_t col = 0;
-				for (idx_t i = dialect_options.num_cols; i < options.name_list.size(); i++) {
-					detected_names.push_back(GenerateColumnName(options.name_list.size(), col++));
-					best_sql_types_candidates_per_column_idx[i] = {LogicalType::VARCHAR};
-				}
-
-				dialect_options.num_cols = options.name_list.size();
-
-			} else {
-				// we throw an error
-				const auto error = CSVError::HeaderSniffingError(
-				    options, best_header_row, options.name_list.size(),
-				    state_machine.dialect_options.state_machine_options.delimiter.GetValue());
-				error_handler.Error(error);
-			}
-		}
-		for (idx_t i = 0; i < options.name_list.size(); i++) {
-			detected_names[i] = options.name_list[i];
-		}
-	}
-}
-
-// If our columns were set by the user, we verify if their names match with the first row
-bool CSVSniffer::DetectHeaderWithSetColumn(ClientContext &context, vector<HeaderValue> &best_header_row,
-                                           const SetColumns &set_columns, CSVReaderOptions &options) {
-	bool has_header = true;
-
-	std::ostringstream error;
-	// User set the names, we must check if they match the first row
-	// We do a +1 to check for situations where the csv file has an extra all null column
-	if (set_columns.Size() != best_header_row.size() && set_columns.Size() + 1 != best_header_row.size()) {
-		return false;
-	}
-
-	// Let's do a match-aroo
-	for (idx_t i = 0; i < set_columns.Size(); i++) {
-		if (best_header_row[i].IsNull()) {
-			return false;
-		}
-		if (best_header_row[i].value != (*set_columns.names)[i]) {
-			error << "Header mismatch at position: " << i << "\n";
-			error << "Expected name: \"" << (*set_columns.names)[i] << "\", ";
-			error << "Actual name: \"" << best_header_row[i].value << "\"."
-			      << "\n";
-			has_header = false;
-			break;
-		}
-	}
-
-	if (!has_header) {
-		bool all_varchar = true;
-		bool first_row_consistent = true;
-		// We verify if the types are consistent
-		for (idx_t col = 0; col < set_columns.Size(); col++) {
-			// try cast to sql_type of column
-			const auto &sql_type = (*set_columns.types)[col];
-			if (sql_type != LogicalType::VARCHAR) {
-				all_varchar = false;
-				if (!CSVSniffer::CanYouCastIt(context, best_header_row[col].value, sql_type, options.dialect_options,
-				                              best_header_row[col].IsNull(), options.decimal_separator[0])) {
-					first_row_consistent = false;
-				}
-			}
-		}
-		if (!first_row_consistent) {
-			options.sniffer_user_mismatch_error += error.str();
-		}
-		if (all_varchar) {
-			return true;
-		}
-		return !first_row_consistent;
-	}
-	return has_header;
-}
-
-bool EmptyHeader(const string &col_name, bool is_null, bool normalize) {
-	if (col_name.empty() || is_null) {
-		return true;
-	}
-	if (normalize) {
-		// normalize has special logic to trim white spaces and generate names
-		return false;
-	}
-	// check if it's all white spaces
-	for (auto &c : col_name) {
-		if (!StringUtil::CharacterIsSpace(c)) {
-			return false;
-		}
-	}
-	// if we are not normalizing the name and is all white spaces, then we generate a name
-	return true;
-}
-
-vector<string>
-CSVSniffer::DetectHeaderInternal(ClientContext &context, vector<HeaderValue> &best_header_row,
-                                 CSVStateMachine &state_machine, const SetColumns &set_columns,
-                                 unordered_map<idx_t, vector<LogicalType>> &best_sql_types_candidates_per_column_idx,
-                                 CSVReaderOptions &options, CSVErrorHandler &error_handler) {
-	vector<string> detected_names;
-	auto &dialect_options = state_machine.dialect_options;
-	dialect_options.num_cols = best_sql_types_candidates_per_column_idx.size();
-	if (best_header_row.empty()) {
-		dialect_options.header = false;
-		for (idx_t col = 0; col < dialect_options.num_cols; col++) {
-			detected_names.push_back(GenerateColumnName(dialect_options.num_cols, col));
-		}
-		// If the user provided names, we must replace our header with the user provided names
-		ReplaceNames(detected_names, state_machine, best_sql_types_candidates_per_column_idx, options, best_header_row,
-		             error_handler);
-		return detected_names;
-	}
-	// information for header detection
-	// check if header row is all null and/or consistent with detected column data types
-	// If null-padding is not allowed and there is a mismatch between our header candidate and the number of columns
-	// We can't detect the dialect/type options properly
-	if (!options.null_padding && best_sql_types_candidates_per_column_idx.size() != best_header_row.size()) {
-		if (options.ignore_errors.GetValue()) {
-			dialect_options.header = false;
-			for (idx_t col = 0; col < dialect_options.num_cols; col++) {
-				detected_names.push_back(GenerateColumnName(dialect_options.num_cols, col));
-			}
-			dialect_options.rows_until_header += 1;
-			ReplaceNames(detected_names, state_machine, best_sql_types_candidates_per_column_idx, options,
-			             best_header_row, error_handler);
-			return detected_names;
-		}
-		auto error =
-		    CSVError::HeaderSniffingError(options, best_header_row, best_sql_types_candidates_per_column_idx.size(),
-		                                  state_machine.dialect_options.state_machine_options.delimiter.GetValue());
-		error_handler.Error(error);
-	}
-	bool has_header;
-
-	if (set_columns.IsSet()) {
-		has_header = DetectHeaderWithSetColumn(context, best_header_row, set_columns, options);
-	} else {
-		bool first_row_consistent = true;
-		bool all_varchar = true;
-		bool first_row_nulls = true;
-		for (idx_t col = 0; col < best_header_row.size(); col++) {
-			if (!best_header_row[col].IsNull()) {
-				first_row_nulls = false;
-			}
-			// try cast to sql_type of column
-			const auto &sql_type = best_sql_types_candidates_per_column_idx[col].back();
-			if (sql_type != LogicalType::VARCHAR) {
-				all_varchar = false;
-				if (!CanYouCastIt(context, best_header_row[col].value, sql_type, dialect_options,
-				                  best_header_row[col].IsNull(), options.decimal_separator[0])) {
-					first_row_consistent = false;
-				}
-			}
-		}
-		// Our header is only false if types are not all varchar, and rows are consistent
-		if (all_varchar || first_row_nulls) {
-			has_header = true;
-		} else {
-			has_header = !first_row_consistent;
-		}
-	}
-
-	if (options.dialect_options.header.IsSetByUser()) {
-		// Header is defined by user, use that.
-		has_header = options.dialect_options.header.GetValue();
-	}
-	// update parser info, and read, generate & set col_names based on previous findings
-	if (has_header) {
-		dialect_options.header = true;
-		if (options.null_padding && !options.dialect_options.skip_rows.IsSetByUser()) {
-			if (dialect_options.skip_rows.GetValue() > 0) {
-				dialect_options.skip_rows = dialect_options.skip_rows.GetValue() - 1;
-			}
-		}
-		case_insensitive_map_t<idx_t> name_collision_count;
-
-		// get header names from CSV
-		for (idx_t col = 0; col < best_header_row.size(); col++) {
-			string &col_name = best_header_row[col].value;
-
-			// generate name if field is empty
-			if (EmptyHeader(col_name, best_header_row[col].is_null, options.normalize_names)) {
-				col_name = GenerateColumnName(dialect_options.num_cols, col);
-			}
-
-			// normalize names or at least trim whitespace
-			if (options.normalize_names) {
-				col_name = NormalizeColumnName(col_name);
-			} else {
-				col_name = TrimWhitespace(col_name);
-			}
-
-			// avoid duplicate header names
-			while (name_collision_count.find(col_name) != name_collision_count.end()) {
-				name_collision_count[col_name] += 1;
-				col_name = col_name + "_" + to_string(name_collision_count[col_name]);
-			}
-			detected_names.push_back(col_name);
-			name_collision_count[col_name] = 0;
-		}
-		if (best_header_row.size() < dialect_options.num_cols && options.null_padding) {
-			for (idx_t col = best_header_row.size(); col < dialect_options.num_cols; col++) {
-				detected_names.push_back(GenerateColumnName(dialect_options.num_cols, col));
-			}
-		} else if (best_header_row.size() < dialect_options.num_cols) {
-			throw InternalException("Detected header has number of columns inferior to dialect detection");
-		}
-
-	} else {
-		dialect_options.header = false;
-		for (idx_t col = 0; col < dialect_options.num_cols; col++) {
-			detected_names.push_back(GenerateColumnName(dialect_options.num_cols, col));
-		}
-	}
-
-	// If the user provided names, we must replace our header with the user provided names
-	ReplaceNames(detected_names, state_machine, best_sql_types_candidates_per_column_idx, options, best_header_row,
-	             error_handler);
-	return detected_names;
-}
-void CSVSniffer::DetectHeader() {
-	auto &sniffer_state_machine = best_candidate->GetStateMachine();
-	names = DetectHeaderInternal(buffer_manager->context, best_header_row, sniffer_state_machine, set_columns,
-	                             best_sql_types_candidates_per_column_idx, options, *error_handler);
-	for (idx_t i = max_columns_found; i < names.size(); i++) {
-		detected_types.push_back(LogicalType::VARCHAR);
-	}
-	max_columns_found = names.size();
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp
deleted file mode 100644
index d6b2b1a6b..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp
+++ /dev/null
@@ -1,493 +0,0 @@
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/common/operator/double_cast_operator.hpp"
-#include "duckdb/common/operator/integer_cast_operator.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-
-namespace duckdb {
-struct TryCastFloatingOperator {
-	template <class OP, class T>
-	static bool Operation(string_t input) {
-		T result;
-		string error_message;
-		CastParameters parameters(false, &error_message);
-		return OP::Operation(input, result, parameters);
-	}
-};
-
-static bool StartsWithNumericDate(string &separator, const string_t &value) {
-	auto begin = value.GetData();
-	auto end = begin + value.GetSize();
-
-	//	StrpTimeFormat::Parse will skip whitespace, so we can too
-	auto field1 = std::find_if_not(begin, end, StringUtil::CharacterIsSpace);
-	if (field1 == end) {
-		return false;
-	}
-
-	//	first numeric field must start immediately
-	if (!StringUtil::CharacterIsDigit(*field1)) {
-		return false;
-	}
-	auto literal1 = std::find_if_not(field1, end, StringUtil::CharacterIsDigit);
-	if (literal1 == end) {
-		return false;
-	}
-
-	//	second numeric field must exist
-	auto field2 = std::find_if(literal1, end, StringUtil::CharacterIsDigit);
-	if (field2 == end) {
-		return false;
-	}
-	auto literal2 = std::find_if_not(field2, end, StringUtil::CharacterIsDigit);
-	if (literal2 == end) {
-		return false;
-	}
-
-	//	third numeric field must exist
-	auto field3 = std::find_if(literal2, end, StringUtil::CharacterIsDigit);
-	if (field3 == end) {
-		return false;
-	}
-
-	//	second literal must match first
-	if (((field3 - literal2) != (field2 - literal1)) ||
-	    strncmp(literal1, literal2, NumericCast<size_t>((field2 - literal1))) != 0) {
-		return false;
-	}
-
-	//	copy the literal as the separator, escaping percent signs
-	separator.clear();
-	while (literal1 < field2) {
-		const auto literal_char = *literal1++;
-		if (literal_char == '%') {
-			separator.push_back(literal_char);
-		}
-		separator.push_back(literal_char);
-	}
-
-	return true;
-}
-
-string GenerateDateFormat(const string &separator, const char *format_template) {
-	string format_specifier = format_template;
-	auto amount_of_dashes = NumericCast<idx_t>(std::count(format_specifier.begin(), format_specifier.end(), '-'));
-	// All our date formats must have at least one -
-	D_ASSERT(amount_of_dashes);
-	string result;
-	result.reserve(format_specifier.size() - amount_of_dashes + (amount_of_dashes * separator.size()));
-	for (auto &character : format_specifier) {
-		if (character == '-') {
-			result += separator;
-		} else {
-			result += character;
-		}
-	}
-	return result;
-}
-
-void CSVSniffer::SetDateFormat(CSVStateMachine &candidate, const string &format_specifier,
-                               const LogicalTypeId &sql_type) {
-	StrpTimeFormat strpformat;
-	StrTimeFormat::ParseFormatSpecifier(format_specifier, strpformat);
-	candidate.dialect_options.date_format[sql_type].Set(strpformat, false);
-}
-
-idx_t CSVSniffer::LinesSniffed() const {
-	return lines_sniffed;
-}
-
-bool CSVSniffer::CanYouCastIt(ClientContext &context, const string_t value, const LogicalType &type,
-                              const DialectOptions &dialect_options, const bool is_null, const char decimal_separator) {
-	if (is_null) {
-		return true;
-	}
-	auto value_ptr = value.GetData();
-	auto value_size = value.GetSize();
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN: {
-		bool dummy_value;
-		return TryCastStringBool(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::TINYINT: {
-		int8_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, false);
-	}
-	case LogicalTypeId::SMALLINT: {
-		int16_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::INTEGER: {
-		int32_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::BIGINT: {
-		int64_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::UTINYINT: {
-		uint8_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::USMALLINT: {
-		uint16_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::UINTEGER: {
-		uint32_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::UBIGINT: {
-		uint64_t dummy_value;
-		return TrySimpleIntegerCast(value_ptr, value_size, dummy_value, true);
-	}
-	case LogicalTypeId::DOUBLE: {
-		double dummy_value;
-		return TryDoubleCast<double>(value_ptr, value_size, dummy_value, true, decimal_separator);
-	}
-	case LogicalTypeId::FLOAT: {
-		float dummy_value;
-		return TryDoubleCast<float>(value_ptr, value_size, dummy_value, true, decimal_separator);
-	}
-	case LogicalTypeId::DATE: {
-		if (!dialect_options.date_format.find(LogicalTypeId::DATE)->second.GetValue().Empty()) {
-			date_t result;
-			string error_message;
-			return dialect_options.date_format.find(LogicalTypeId::DATE)
-			    ->second.GetValue()
-			    .TryParseDate(value, result, error_message);
-		}
-		idx_t pos;
-		bool special;
-		date_t dummy_value;
-		return Date::TryConvertDate(value_ptr, value_size, pos, dummy_value, special, true) == DateCastResult::SUCCESS;
-	}
-	case LogicalTypeId::TIMESTAMP: {
-		timestamp_t dummy_value;
-		if (!dialect_options.date_format.find(LogicalTypeId::TIMESTAMP)->second.GetValue().Empty()) {
-			string error_message;
-			return dialect_options.date_format.find(LogicalTypeId::TIMESTAMP)
-			    ->second.GetValue()
-			    .TryParseTimestamp(value, dummy_value, error_message);
-		}
-		return Timestamp::TryConvertTimestamp(value_ptr, value_size, dummy_value) == TimestampCastResult::SUCCESS;
-	}
-	case LogicalTypeId::TIME: {
-		idx_t pos;
-		dtime_t dummy_value;
-		return Time::TryConvertTime(value_ptr, value_size, pos, dummy_value, true);
-	}
-	case LogicalTypeId::DECIMAL: {
-		uint8_t width, scale;
-		type.GetDecimalProperties(width, scale);
-		if (decimal_separator == ',') {
-			switch (type.InternalType()) {
-			case PhysicalType::INT16: {
-				int16_t dummy_value;
-				return TryDecimalStringCast<int16_t, ','>(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			case PhysicalType::INT32: {
-				int32_t dummy_value;
-				return TryDecimalStringCast<int32_t, ','>(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			case PhysicalType::INT64: {
-				int64_t dummy_value;
-				return TryDecimalStringCast<int64_t, ','>(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			case PhysicalType::INT128: {
-				hugeint_t dummy_value;
-				return TryDecimalStringCast<hugeint_t, ','>(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			default:
-				throw InternalException("Invalid Physical Type for Decimal Value. Physical Type: " +
-				                        TypeIdToString(type.InternalType()));
-			}
-
-		} else if (decimal_separator == '.') {
-			switch (type.InternalType()) {
-			case PhysicalType::INT16: {
-				int16_t dummy_value;
-				return TryDecimalStringCast(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			case PhysicalType::INT32: {
-				int32_t dummy_value;
-				return TryDecimalStringCast(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			case PhysicalType::INT64: {
-				int64_t dummy_value;
-				return TryDecimalStringCast(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			case PhysicalType::INT128: {
-				hugeint_t dummy_value;
-				return TryDecimalStringCast(value_ptr, value_size, dummy_value, width, scale);
-			}
-
-			default:
-				throw InternalException("Invalid Physical Type for Decimal Value. Physical Type: " +
-				                        TypeIdToString(type.InternalType()));
-			}
-		}
-		throw InvalidInputException("Decimals can only have ',' and '.' as decimal separators");
-	}
-	case LogicalTypeId::VARCHAR:
-		return true;
-	default: {
-		// We do Value Try Cast for non-basic types.
-		Value new_value;
-		string error_message;
-		Value str_value(value);
-		return str_value.TryCastAs(context, type, new_value, &error_message, true);
-	}
-	}
-}
-
-void CSVSniffer::InitializeDateAndTimeStampDetection(CSVStateMachine &candidate, const string &separator,
-                                                     const LogicalType &sql_type) {
-	auto &format_candidate = format_candidates[sql_type.id()];
-	if (!format_candidate.initialized) {
-		format_candidate.initialized = true;
-		// if user set a format, we add that as well
-		auto user_format = options.dialect_options.date_format.find(sql_type.id());
-		if (user_format->second.IsSetByUser()) {
-			format_candidate.format.emplace_back(user_format->second.GetValue().format_specifier);
-		} else {
-			auto entry = format_template_candidates.find(sql_type.id());
-			if (entry != format_template_candidates.end()) {
-				const auto &format_template_list = entry->second;
-				for (const auto &t : format_template_list) {
-					const auto format_string = GenerateDateFormat(separator, t);
-					// don't parse ISO 8601
-					if (format_string.find("%Y-%m-%d") == string::npos) {
-						format_candidate.format.emplace_back(format_string);
-					}
-				}
-			}
-		}
-		// order by preference
-		original_format_candidates = format_candidates;
-	}
-	//	initialise the first candidate
-	//	all formats are constructed to be valid
-	SetDateFormat(candidate, format_candidate.format.back(), sql_type.id());
-}
-
-bool ValidSeparator(const string &separator) {
-	// We use https://en.wikipedia.org/wiki/List_of_date_formats_by_country as reference
-	return separator == "-" || separator == "." || separator == "/" || separator == " ";
-}
-void CSVSniffer::DetectDateAndTimeStampFormats(CSVStateMachine &candidate, const LogicalType &sql_type,
-                                               const string &separator, const string_t &dummy_val) {
-	if (!ValidSeparator(separator)) {
-		return;
-	}
-	// If it is the first time running date/timestamp detection we must initialize the format variables
-	InitializeDateAndTimeStampDetection(candidate, separator, sql_type);
-	// generate date format candidates the first time through
-	auto &type_format_candidates = format_candidates[sql_type.id()].format;
-	// check all formats and keep the first one that works
-	StrpTimeFormat::ParseResult result;
-	auto save_format_candidates = type_format_candidates;
-	const bool had_format_candidates = !save_format_candidates.empty();
-	const bool initial_format_candidates =
-	    save_format_candidates.size() == original_format_candidates.at(sql_type.id()).format.size();
-	const bool is_set_by_user = options.dialect_options.date_format.find(sql_type.id())->second.IsSetByUser();
-	while (!type_format_candidates.empty() && !is_set_by_user) {
-		//	avoid using exceptions for flow control...
-		auto &current_format = candidate.dialect_options.date_format[sql_type.id()].GetValue();
-		if (current_format.Parse(dummy_val, result, true)) {
-			format_candidates[sql_type.id()].had_match = true;
-			break;
-		}
-		//	doesn't work - move to the next one
-		type_format_candidates.pop_back();
-		if (!type_format_candidates.empty()) {
-			SetDateFormat(candidate, type_format_candidates.back(), sql_type.id());
-		}
-	}
-	//	if none match, then this is not a value of type sql_type,
-	if (type_format_candidates.empty()) {
-		//	so restore the candidates that did work.
-		//	or throw them out if they were generated by this value.
-		if (had_format_candidates) {
-			if (initial_format_candidates && !format_candidates[sql_type.id()].had_match) {
-				// we reset the whole thing because we tried to sniff the wrong type.
-				format_candidates[sql_type.id()].initialized = false;
-				format_candidates[sql_type.id()].format.clear();
-				SetDateFormat(candidate, "", sql_type.id());
-				return;
-			}
-			type_format_candidates.swap(save_format_candidates);
-			SetDateFormat(candidate, type_format_candidates.back(), sql_type.id());
-		}
-	}
-}
-
-void CSVSniffer::SniffTypes(DataChunk &data_chunk, CSVStateMachine &state_machine,
-                            unordered_map<idx_t, vector<LogicalType>> &info_sql_types_candidates,
-                            idx_t start_idx_detection) {
-	const idx_t chunk_size = data_chunk.size();
-	HasType has_type;
-	for (idx_t col_idx = 0; col_idx < data_chunk.ColumnCount(); col_idx++) {
-		auto &cur_vector = data_chunk.data[col_idx];
-		D_ASSERT(cur_vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		D_ASSERT(cur_vector.GetType() == LogicalType::VARCHAR);
-		auto vector_data = FlatVector::GetData<string_t>(cur_vector);
-		auto null_mask = FlatVector::Validity(cur_vector);
-		auto &col_type_candidates = info_sql_types_candidates[col_idx];
-		for (idx_t row_idx = start_idx_detection; row_idx < chunk_size; row_idx++) {
-			// col_type_candidates can't be empty since anything in a CSV file should at least be a string
-			// and we validate utf-8 compatibility when creating the type
-			D_ASSERT(!col_type_candidates.empty());
-			auto cur_top_candidate = col_type_candidates.back();
-			// try cast from string to sql_type
-			while (col_type_candidates.size() > 1) {
-				const auto &sql_type = col_type_candidates.back();
-				// try formatting for date types if the user did not specify one, and it starts with numeric
-				// values.
-				string separator;
-				// If Value is not Null, Has a numeric date format, and the current investigated candidate is
-				// either a timestamp or a date
-				if (null_mask.RowIsValid(row_idx) && StartsWithNumericDate(separator, vector_data[row_idx]) &&
-				    ((col_type_candidates.back().id() == LogicalTypeId::TIMESTAMP && !has_type.timestamp) ||
-				     (col_type_candidates.back().id() == LogicalTypeId::DATE && !has_type.date))) {
-					DetectDateAndTimeStampFormats(state_machine, sql_type, separator, vector_data[row_idx]);
-				}
-				// try cast from string to sql_type
-				if (sql_type == LogicalType::VARCHAR) {
-					// Nothing to convert it to
-					continue;
-				}
-				if (CanYouCastIt(buffer_manager->context, vector_data[row_idx], sql_type, state_machine.dialect_options,
-				                 !null_mask.RowIsValid(row_idx), state_machine.options.decimal_separator[0])) {
-					break;
-				}
-
-				if (row_idx != start_idx_detection &&
-				    (cur_top_candidate == LogicalType::BOOLEAN || cur_top_candidate == LogicalType::DATE ||
-				     cur_top_candidate == LogicalType::TIME || cur_top_candidate == LogicalType::TIMESTAMP)) {
-					// If we thought this was a boolean value (i.e., T,F, True, False) and it is not, we
-					// immediately pop to varchar.
-					while (col_type_candidates.back() != LogicalType::VARCHAR) {
-						col_type_candidates.pop_back();
-					}
-					break;
-				}
-				col_type_candidates.pop_back();
-			}
-		}
-		if (col_type_candidates.back().id() == LogicalTypeId::DATE) {
-			has_type.date = true;
-		}
-		if (col_type_candidates.back().id() == LogicalTypeId::TIMESTAMP) {
-			has_type.timestamp = true;
-		}
-	}
-}
-
-// If we have a predefined date/timestamp format we set it
-void CSVSniffer::SetUserDefinedDateTimeFormat(CSVStateMachine &candidate) const {
-	const vector<LogicalTypeId> data_time_formats {LogicalTypeId::DATE, LogicalTypeId::TIMESTAMP};
-	for (auto &date_time_format : data_time_formats) {
-		auto &user_option = options.dialect_options.date_format.at(date_time_format);
-		if (user_option.IsSetByUser()) {
-			SetDateFormat(candidate, user_option.GetValue().format_specifier, date_time_format);
-		}
-	}
-}
-void CSVSniffer::DetectTypes() {
-	idx_t min_varchar_cols = max_columns_found + 1;
-	idx_t min_errors = NumericLimits<idx_t>::Maximum();
-	vector<LogicalType> return_types;
-	// check which info candidate leads to minimum amount of non-varchar columns...
-	for (auto &candidate_cc : candidates) {
-		auto &sniffing_state_machine = candidate_cc->GetStateMachine();
-		unordered_map<idx_t, vector<LogicalType>> info_sql_types_candidates;
-		for (idx_t i = 0; i < max_columns_found; i++) {
-			info_sql_types_candidates[i] = sniffing_state_machine.options.auto_type_candidates;
-		}
-		D_ASSERT(max_columns_found > 0);
-
-		// Set all return_types to VARCHAR, so we can do datatype detection based on VARCHAR values
-		return_types.clear();
-		return_types.assign(max_columns_found, LogicalType::VARCHAR);
-
-		// Reset candidate for parsing
-		auto candidate = candidate_cc->UpgradeToStringValueScanner();
-		SetUserDefinedDateTimeFormat(*candidate->state_machine);
-		// Parse chunk and read csv with info candidate
-		auto &data_chunk = candidate->ParseChunk().ToChunk();
-		if (candidate->error_handler->AnyErrors() && !candidate->error_handler->HasError(MAXIMUM_LINE_SIZE) &&
-		    !candidate->state_machine->options.ignore_errors.GetValue()) {
-			continue;
-		}
-		idx_t start_idx_detection = 0;
-		idx_t chunk_size = data_chunk.size();
-		if (chunk_size > 1 &&
-		    (!options.dialect_options.header.IsSetByUser() ||
-		     (options.dialect_options.header.IsSetByUser() && options.dialect_options.header.GetValue()))) {
-			// This means we have more than one row, hence we can use the first row to detect if we have a header
-			start_idx_detection = 1;
-		}
-		// First line where we start our type detection
-		SniffTypes(data_chunk, sniffing_state_machine, info_sql_types_candidates, start_idx_detection);
-
-		// Count the number of varchar columns
-		idx_t varchar_cols = 0;
-		for (idx_t col = 0; col < info_sql_types_candidates.size(); col++) {
-			auto &col_type_candidates = info_sql_types_candidates[col];
-			// check number of varchar columns
-			const auto &col_type = col_type_candidates.back();
-			if (col_type == LogicalType::VARCHAR) {
-				varchar_cols++;
-			}
-		}
-
-		// it's good if the dialect creates more non-varchar columns, but only if we sacrifice < 30% of
-		// best_num_cols.
-		const idx_t number_of_errors = candidate->error_handler->GetSize();
-		if (!best_candidate || (varchar_cols<min_varchar_cols &&static_cast<double>(info_sql_types_candidates.size())>(
-		                            static_cast<double>(max_columns_found) * 0.7) &&
-		                        (!options.ignore_errors.GetValue() || number_of_errors < min_errors))) {
-			min_errors = number_of_errors;
-			best_header_row.clear();
-			// we have a new best_options candidate
-			best_candidate = std::move(candidate);
-			min_varchar_cols = varchar_cols;
-			best_sql_types_candidates_per_column_idx = info_sql_types_candidates;
-			for (auto &format_candidate : format_candidates) {
-				best_format_candidates[format_candidate.first] = format_candidate.second.format;
-			}
-			if (chunk_size > 0) {
-				for (idx_t col_idx = 0; col_idx < data_chunk.ColumnCount(); col_idx++) {
-					auto &cur_vector = data_chunk.data[col_idx];
-					auto vector_data = FlatVector::GetData<string_t>(cur_vector);
-					auto null_mask = FlatVector::Validity(cur_vector);
-					if (null_mask.RowIsValid(0)) {
-						auto value = HeaderValue(vector_data[0]);
-						best_header_row.push_back(value);
-					} else {
-						best_header_row.push_back({});
-					}
-				}
-			}
-		}
-	}
-	if (!best_candidate) {
-		DialectCandidates dialect_candidates(options.dialect_options.state_machine_options);
-		auto error = CSVError::SniffingError(options, dialect_candidates.Print());
-		error_handler->Error(error, true);
-	}
-	// Assert that it's all good at this point.
-	D_ASSERT(best_candidate && !best_format_candidates.empty());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_refinement.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_refinement.cpp
deleted file mode 100644
index 8d3e26845..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_refinement.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_casting.hpp"
-
-namespace duckdb {
-bool CSVSniffer::TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type) {
-	auto &sniffing_state_machine = best_candidate->GetStateMachine();
-	// try vector-cast from string to sql_type
-	Vector dummy_result(sql_type, size);
-	if (!sniffing_state_machine.dialect_options.date_format[LogicalTypeId::DATE].GetValue().Empty() &&
-	    sql_type.id() == LogicalTypeId::DATE) {
-		// use the date format to cast the chunk
-		string error_message;
-		CastParameters parameters(false, &error_message);
-		idx_t line_error;
-		return CSVCast::TryCastDateVector(sniffing_state_machine.dialect_options.date_format, parse_chunk_col,
-		                                  dummy_result, size, parameters, line_error);
-	}
-	if (!sniffing_state_machine.dialect_options.date_format[LogicalTypeId::TIMESTAMP].GetValue().Empty() &&
-	    sql_type.id() == LogicalTypeId::TIMESTAMP) {
-		// use the timestamp format to cast the chunk
-		string error_message;
-		CastParameters parameters(false, &error_message);
-		return CSVCast::TryCastTimestampVector(sniffing_state_machine.dialect_options.date_format, parse_chunk_col,
-		                                       dummy_result, size, parameters);
-	}
-	if ((sql_type.id() == LogicalTypeId::DOUBLE || sql_type.id() == LogicalTypeId::FLOAT) &&
-	    options.decimal_separator == ",") {
-		string error_message;
-		CastParameters parameters(false, &error_message);
-		idx_t line_error;
-		return CSVCast::TryCastFloatingVectorCommaSeparated(options, parse_chunk_col, dummy_result, size, parameters,
-		                                                    sql_type, line_error);
-	}
-	if (sql_type.id() == LogicalTypeId::DECIMAL && options.decimal_separator == ",") {
-		string error_message;
-		CastParameters parameters(false, &error_message);
-		idx_t line_error;
-		return CSVCast::TryCastDecimalVectorCommaSeparated(options, parse_chunk_col, dummy_result, size, parameters,
-		                                                   sql_type, line_error);
-	}
-	// target type is not varchar: perform a cast
-	string error_message;
-	return VectorOperations::DefaultTryCast(parse_chunk_col, dummy_result, size, &error_message, true);
-}
-
-void CSVSniffer::RefineTypes() {
-	auto &sniffing_state_machine = best_candidate->GetStateMachine();
-	// if data types were provided, exit here if number of columns does not match
-	detected_types.assign(sniffing_state_machine.dialect_options.num_cols, LogicalType::VARCHAR);
-	if (sniffing_state_machine.options.all_varchar) {
-		// return all types varchar
-		return;
-	}
-	for (idx_t i = 1; i < sniffing_state_machine.options.sample_size_chunks; i++) {
-		bool finished_file = best_candidate->FinishedFile();
-		if (finished_file) {
-			// we finished the file: stop
-			// set sql types
-			detected_types.clear();
-			for (idx_t column_idx = 0; column_idx < best_sql_types_candidates_per_column_idx.size(); column_idx++) {
-				LogicalType d_type = best_sql_types_candidates_per_column_idx[column_idx].back();
-				if (best_sql_types_candidates_per_column_idx[column_idx].size() ==
-				    sniffing_state_machine.options.auto_type_candidates.size()) {
-					d_type = LogicalType::VARCHAR;
-				}
-				detected_types.push_back(d_type);
-			}
-			return;
-		}
-		auto &parse_chunk = best_candidate->ParseChunk().ToChunk();
-
-		for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) {
-			vector<LogicalType> &col_type_candidates = best_sql_types_candidates_per_column_idx[col];
-			bool is_bool_type = col_type_candidates.back() == LogicalType::BOOLEAN;
-			while (col_type_candidates.size() > 1) {
-				const auto &sql_type = col_type_candidates.back();
-				if (TryCastVector(parse_chunk.data[col], parse_chunk.size(), sql_type)) {
-					break;
-				}
-				if (col_type_candidates.back() == LogicalType::BOOLEAN && is_bool_type) {
-					// If we thought this was a boolean value (i.e., T,F, True, False) and it is not, we
-					// immediately pop to varchar.
-					while (col_type_candidates.back() != LogicalType::VARCHAR) {
-						col_type_candidates.pop_back();
-					}
-					break;
-				}
-				col_type_candidates.pop_back();
-			}
-		}
-		// reset parse chunk for the next iteration
-		parse_chunk.Reset();
-		parse_chunk.SetCapacity(CSVReaderOptions::sniff_size);
-	}
-	detected_types.clear();
-	// set sql types
-	for (idx_t column_idx = 0; column_idx < best_sql_types_candidates_per_column_idx.size(); column_idx++) {
-		LogicalType d_type = best_sql_types_candidates_per_column_idx[column_idx].back();
-		if (best_sql_types_candidates_per_column_idx[column_idx].size() ==
-		        best_candidate->GetStateMachine().options.auto_type_candidates.size() &&
-		    default_null_to_varchar) {
-			d_type = LogicalType::VARCHAR;
-		}
-		detected_types.push_back(d_type);
-	}
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_replacement.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_replacement.cpp
deleted file mode 100644
index a693144de..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_replacement.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-
-namespace duckdb {
-void CSVSniffer::ReplaceTypes() {
-	auto &sniffing_state_machine = best_candidate->GetStateMachine();
-	manually_set = vector<bool>(detected_types.size(), false);
-	if (sniffing_state_machine.options.sql_type_list.empty() || sniffing_state_machine.options.columns_set) {
-		return;
-	}
-	// user-defined types were supplied for certain columns
-	// override the types
-	if (!sniffing_state_machine.options.sql_types_per_column.empty()) {
-		// types supplied as name -> value map
-		idx_t found = 0;
-		for (idx_t i = 0; i < names.size(); i++) {
-			auto it = sniffing_state_machine.options.sql_types_per_column.find(names[i]);
-			if (it != sniffing_state_machine.options.sql_types_per_column.end()) {
-				best_sql_types_candidates_per_column_idx[i] = {
-				    sniffing_state_machine.options.sql_type_list[it->second]};
-				detected_types[i] = sniffing_state_machine.options.sql_type_list[it->second];
-				manually_set[i] = true;
-				found++;
-			}
-		}
-		if (!sniffing_state_machine.options.file_options.union_by_name &&
-		    found < sniffing_state_machine.options.sql_types_per_column.size()) {
-			auto error_msg = CSVError::ColumnTypesError(options.sql_types_per_column, names);
-			error_handler->Error(error_msg);
-		}
-		return;
-	}
-	// types supplied as list
-	if (names.size() < sniffing_state_machine.options.sql_type_list.size()) {
-		throw BinderException("read_csv: %d types were provided, but CSV file only has %d columns",
-		                      sniffing_state_machine.options.sql_type_list.size(), names.size());
-	}
-	for (idx_t i = 0; i < sniffing_state_machine.options.sql_type_list.size(); i++) {
-		detected_types[i] = sniffing_state_machine.options.sql_type_list[i];
-		manually_set[i] = true;
-	}
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine.cpp b/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine.cpp
deleted file mode 100644
index eae140f7d..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp"
-
-namespace duckdb {
-
-CSVStateMachine::CSVStateMachine(CSVReaderOptions &options_p, const CSVStateMachineOptions &state_machine_options_p,
-                                 CSVStateMachineCache &csv_state_machine_cache)
-    : transition_array(csv_state_machine_cache.Get(state_machine_options_p)),
-      state_machine_options(state_machine_options_p), options(options_p) {
-	dialect_options.state_machine_options = state_machine_options;
-}
-
-CSVStateMachine::CSVStateMachine(const StateMachine &transition_array_p, const CSVReaderOptions &options_p)
-    : transition_array(transition_array_p), state_machine_options(options_p.dialect_options.state_machine_options),
-      options(options_p), dialect_options(options.dialect_options) {
-	dialect_options.state_machine_options = state_machine_options;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp b/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp
deleted file mode 100644
index 29fda8863..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp
+++ /dev/null
@@ -1,444 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-
-namespace duckdb {
-
-void InitializeTransitionArray(StateMachine &transition_array, const CSVState cur_state, const CSVState state) {
-	for (uint32_t i = 0; i < StateMachine::NUM_TRANSITIONS; i++) {
-		transition_array[i][static_cast<uint8_t>(cur_state)] = state;
-	}
-}
-
-// Shift and OR to replicate across all bytes
-void ShiftAndReplicateBits(uint64_t &value) {
-	value |= value << 8;
-	value |= value << 16;
-	value |= value << 32;
-}
-void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_options) {
-	D_ASSERT(state_machine_cache.find(state_machine_options) == state_machine_cache.end());
-	// Initialize transition array with default values to the Standard option
-	auto &transition_array = state_machine_cache[state_machine_options];
-
-	for (uint32_t i = 0; i < StateMachine::NUM_STATES; i++) {
-		const auto cur_state = static_cast<CSVState>(i);
-		switch (cur_state) {
-		case CSVState::MAYBE_QUOTED:
-		case CSVState::QUOTED:
-		case CSVState::QUOTED_NEW_LINE:
-		case CSVState::ESCAPE:
-			InitializeTransitionArray(transition_array, cur_state, CSVState::QUOTED);
-			break;
-		case CSVState::UNQUOTED:
-			if (state_machine_options.rfc_4180.GetValue()) {
-				// If we have an unquoted state, following rfc 4180, our base state is invalid
-				InitializeTransitionArray(transition_array, cur_state, CSVState::INVALID);
-			} else {
-				// This will allow us to accept unescaped quotes
-				InitializeTransitionArray(transition_array, cur_state, CSVState::UNQUOTED);
-			}
-			break;
-		case CSVState::COMMENT:
-			InitializeTransitionArray(transition_array, cur_state, CSVState::COMMENT);
-			break;
-		default:
-			InitializeTransitionArray(transition_array, cur_state, CSVState::STANDARD);
-			break;
-		}
-	}
-
-	const auto delimiter_value = state_machine_options.delimiter.GetValue();
-	const auto delimiter_first_byte = static_cast<uint8_t>(delimiter_value[0]);
-	const auto quote = static_cast<uint8_t>(state_machine_options.quote.GetValue());
-	const auto escape = static_cast<uint8_t>(state_machine_options.escape.GetValue());
-	const auto comment = static_cast<uint8_t>(state_machine_options.comment.GetValue());
-
-	const auto new_line_id = state_machine_options.new_line.GetValue();
-
-	const bool multi_byte_delimiter = delimiter_value.size() != 1;
-
-	const bool enable_unquoted_escape = state_machine_options.rfc_4180.GetValue() == false &&
-	                                    state_machine_options.quote != state_machine_options.escape &&
-	                                    state_machine_options.escape != '\0';
-	// Now set values depending on configuration
-	// 1) Standard/Invalid State
-	const vector<uint8_t> std_inv {static_cast<uint8_t>(CSVState::STANDARD), static_cast<uint8_t>(CSVState::INVALID),
-	                               static_cast<uint8_t>(CSVState::STANDARD_NEWLINE)};
-	for (const auto &state : std_inv) {
-		if (multi_byte_delimiter) {
-			transition_array[delimiter_first_byte][state] = CSVState::DELIMITER_FIRST_BYTE;
-		} else {
-			transition_array[delimiter_first_byte][state] = CSVState::DELIMITER;
-		}
-		if (new_line_id == NewLineIdentifier::CARRY_ON) {
-			transition_array[static_cast<uint8_t>('\r')][state] = CSVState::CARRIAGE_RETURN;
-			if (state == static_cast<uint8_t>(CSVState::STANDARD_NEWLINE)) {
-				transition_array[static_cast<uint8_t>('\n')][state] = CSVState::STANDARD;
-			} else if (!state_machine_options.rfc_4180.GetValue()) {
-				transition_array[static_cast<uint8_t>('\n')][state] = CSVState::RECORD_SEPARATOR;
-			} else {
-				transition_array[static_cast<uint8_t>('\n')][state] = CSVState::INVALID;
-			}
-		} else {
-			transition_array[static_cast<uint8_t>('\r')][state] = CSVState::RECORD_SEPARATOR;
-			transition_array[static_cast<uint8_t>('\n')][state] = CSVState::RECORD_SEPARATOR;
-		}
-		if (comment != '\0') {
-			transition_array[comment][state] = CSVState::COMMENT;
-		}
-		if (enable_unquoted_escape) {
-			transition_array[escape][state] = CSVState::UNQUOTED_ESCAPE;
-		}
-	}
-	// 2) Field Separator State
-	if (quote != '\0') {
-		transition_array[quote][static_cast<uint8_t>(CSVState::DELIMITER)] = CSVState::QUOTED;
-	}
-	if (delimiter_first_byte != ' ') {
-		transition_array[' '][static_cast<uint8_t>(CSVState::DELIMITER)] = CSVState::EMPTY_SPACE;
-	}
-
-	const vector<uint8_t> delimiter_states {
-	    static_cast<uint8_t>(CSVState::DELIMITER), static_cast<uint8_t>(CSVState::DELIMITER_FIRST_BYTE),
-	    static_cast<uint8_t>(CSVState::DELIMITER_SECOND_BYTE), static_cast<uint8_t>(CSVState::DELIMITER_THIRD_BYTE)};
-
-	// These are the same transitions for all delimiter states
-	for (auto &state : delimiter_states) {
-		if (multi_byte_delimiter) {
-			transition_array[delimiter_first_byte][state] = CSVState::DELIMITER_FIRST_BYTE;
-		} else {
-			transition_array[delimiter_first_byte][state] = CSVState::DELIMITER;
-		}
-		transition_array[static_cast<uint8_t>('\n')][state] = CSVState::RECORD_SEPARATOR;
-		if (new_line_id == NewLineIdentifier::CARRY_ON) {
-			transition_array[static_cast<uint8_t>('\r')][state] = CSVState::CARRIAGE_RETURN;
-		} else {
-			transition_array[static_cast<uint8_t>('\r')][state] = CSVState::RECORD_SEPARATOR;
-		}
-		if (comment != '\0') {
-			transition_array[comment][static_cast<uint8_t>(CSVState::DELIMITER)] = CSVState::COMMENT;
-		}
-	}
-	// Deal other multi-byte delimiters
-	if (delimiter_value.size() == 2) {
-		transition_array[static_cast<uint8_t>(delimiter_value[1])]
-		                [static_cast<uint8_t>(CSVState::DELIMITER_FIRST_BYTE)] = CSVState::DELIMITER;
-	} else if (delimiter_value.size() == 3) {
-		if (delimiter_value[0] == delimiter_value[1]) {
-			transition_array[static_cast<uint8_t>(delimiter_value[1])]
-			                [static_cast<uint8_t>(CSVState::DELIMITER_SECOND_BYTE)] = CSVState::DELIMITER_SECOND_BYTE;
-		}
-		transition_array[static_cast<uint8_t>(delimiter_value[1])]
-		                [static_cast<uint8_t>(CSVState::DELIMITER_FIRST_BYTE)] = CSVState::DELIMITER_SECOND_BYTE;
-		transition_array[static_cast<uint8_t>(delimiter_value[2])]
-		                [static_cast<uint8_t>(CSVState::DELIMITER_SECOND_BYTE)] = CSVState::DELIMITER;
-	} else if (delimiter_value.size() == 4) {
-		if (delimiter_value[0] == delimiter_value[2]) {
-			transition_array[static_cast<uint8_t>(delimiter_value[1])]
-			                [static_cast<uint8_t>(CSVState::DELIMITER_THIRD_BYTE)] = CSVState::DELIMITER_SECOND_BYTE;
-		}
-		if (delimiter_value[0] == delimiter_value[1] && delimiter_value[1] == delimiter_value[2]) {
-			transition_array[static_cast<uint8_t>(delimiter_value[1])]
-			                [static_cast<uint8_t>(CSVState::DELIMITER_THIRD_BYTE)] = CSVState::DELIMITER_THIRD_BYTE;
-		}
-		transition_array[static_cast<uint8_t>(delimiter_value[1])]
-		                [static_cast<uint8_t>(CSVState::DELIMITER_FIRST_BYTE)] = CSVState::DELIMITER_SECOND_BYTE;
-		transition_array[static_cast<uint8_t>(delimiter_value[2])]
-		                [static_cast<uint8_t>(CSVState::DELIMITER_SECOND_BYTE)] = CSVState::DELIMITER_THIRD_BYTE;
-		transition_array[static_cast<uint8_t>(delimiter_value[3])]
-		                [static_cast<uint8_t>(CSVState::DELIMITER_THIRD_BYTE)] = CSVState::DELIMITER;
-	}
-	if (enable_unquoted_escape) {
-		transition_array[escape][static_cast<uint8_t>(CSVState::DELIMITER)] = CSVState::UNQUOTED_ESCAPE;
-	}
-
-	// 3) Record Separator State
-	if (multi_byte_delimiter) {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] =
-		    CSVState::DELIMITER_FIRST_BYTE;
-	} else {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] = CSVState::DELIMITER;
-	}
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] =
-	    CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] =
-		    CSVState::RECORD_SEPARATOR;
-	}
-	if (quote != '\0') {
-		transition_array[quote][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] = CSVState::QUOTED;
-	}
-	if (delimiter_first_byte != ' ') {
-		transition_array[' '][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] = CSVState::EMPTY_SPACE;
-	}
-	if (comment != '\0') {
-		transition_array[comment][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] = CSVState::COMMENT;
-	}
-	if (enable_unquoted_escape) {
-		transition_array[escape][static_cast<uint8_t>(CSVState::RECORD_SEPARATOR)] = CSVState::UNQUOTED_ESCAPE;
-	}
-
-	// 4) Carriage Return State
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::CARRIAGE_RETURN)] =
-	    CSVState::RECORD_SEPARATOR;
-	transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::CARRIAGE_RETURN)] =
-	    CSVState::CARRIAGE_RETURN;
-	if (quote != '\0') {
-		transition_array[quote][static_cast<uint8_t>(CSVState::CARRIAGE_RETURN)] = CSVState::QUOTED;
-	}
-	if (delimiter_first_byte != ' ') {
-		transition_array[' '][static_cast<uint8_t>(CSVState::CARRIAGE_RETURN)] = CSVState::EMPTY_SPACE;
-	}
-	if (comment != '\0') {
-		transition_array[comment][static_cast<uint8_t>(CSVState::CARRIAGE_RETURN)] = CSVState::COMMENT;
-	}
-	if (enable_unquoted_escape) {
-		transition_array[escape][static_cast<uint8_t>(CSVState::CARRIAGE_RETURN)] = CSVState::UNQUOTED_ESCAPE;
-	}
-
-	// 5) Quoted State
-	transition_array[quote][static_cast<uint8_t>(CSVState::QUOTED)] = CSVState::UNQUOTED;
-	transition_array['\n'][static_cast<uint8_t>(CSVState::QUOTED)] = CSVState::QUOTED_NEW_LINE;
-	transition_array['\r'][static_cast<uint8_t>(CSVState::QUOTED)] = CSVState::QUOTED_NEW_LINE;
-
-	if (state_machine_options.quote != state_machine_options.escape &&
-	    state_machine_options.escape.GetValue() != '\0') {
-		transition_array[escape][static_cast<uint8_t>(CSVState::QUOTED)] = CSVState::ESCAPE;
-	}
-	// 6) Unquoted State
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::UNQUOTED)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::UNQUOTED)] =
-		    CSVState::RECORD_SEPARATOR;
-	}
-	if (multi_byte_delimiter) {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::UNQUOTED)] =
-		    CSVState::DELIMITER_FIRST_BYTE;
-	} else {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::DELIMITER;
-	}
-	if (state_machine_options.quote == state_machine_options.escape) {
-		transition_array[quote][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::QUOTED;
-	}
-	if (state_machine_options.rfc_4180 == false) {
-		if (escape == '\0') {
-			// If escape is defined, it limits a bit how relaxed quotes can be in a reliable way.
-			transition_array[quote][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::MAYBE_QUOTED;
-		} else {
-			transition_array[quote][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::QUOTED;
-		}
-	}
-	if (comment != '\0') {
-		transition_array[comment][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::COMMENT;
-	}
-	if (delimiter_first_byte != ' ' && quote != ' ' && escape != ' ' && comment != ' ') {
-		// If space is not a special character, we can safely ignore it in an unquoted state
-		transition_array[' '][static_cast<uint8_t>(CSVState::UNQUOTED)] = CSVState::UNQUOTED;
-	}
-
-	// 8) Not Set
-	if (multi_byte_delimiter) {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::NOT_SET)] =
-		    CSVState::DELIMITER_FIRST_BYTE;
-	} else {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::NOT_SET)] = CSVState::DELIMITER;
-	}
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::NOT_SET)] = CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::NOT_SET)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::NOT_SET)] =
-		    CSVState::RECORD_SEPARATOR;
-	}
-	if (quote != '\0') {
-		transition_array[quote][static_cast<uint8_t>(CSVState::NOT_SET)] = CSVState::QUOTED;
-	}
-	if (delimiter_first_byte != ' ') {
-		transition_array[' '][static_cast<uint8_t>(CSVState::NOT_SET)] = CSVState::EMPTY_SPACE;
-	}
-	if (comment != '\0') {
-		transition_array[comment][static_cast<uint8_t>(CSVState::NOT_SET)] = CSVState::COMMENT;
-	}
-	if (enable_unquoted_escape) {
-		transition_array[escape][static_cast<uint8_t>(CSVState::NOT_SET)] = CSVState::UNQUOTED_ESCAPE;
-	}
-
-	// 9) Quoted NewLine
-	transition_array[quote][static_cast<uint8_t>(CSVState::QUOTED_NEW_LINE)] = CSVState::UNQUOTED;
-	if (state_machine_options.quote != state_machine_options.escape &&
-	    state_machine_options.escape.GetValue() != '\0') {
-		transition_array[escape][static_cast<uint8_t>(CSVState::QUOTED_NEW_LINE)] = CSVState::ESCAPE;
-	}
-
-	// 10) Empty Value State (Not first value)
-	if (multi_byte_delimiter) {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] =
-		    CSVState::DELIMITER_FIRST_BYTE;
-	} else {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] = CSVState::DELIMITER;
-	}
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] =
-	    CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] =
-		    CSVState::RECORD_SEPARATOR;
-	}
-	if (quote != '\0') {
-		transition_array[quote][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] = CSVState::QUOTED;
-	}
-	if (comment != '\0') {
-		transition_array[comment][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] = CSVState::COMMENT;
-	}
-	if (enable_unquoted_escape) {
-		transition_array[escape][static_cast<uint8_t>(CSVState::EMPTY_SPACE)] = CSVState::UNQUOTED_ESCAPE;
-	}
-
-	// 11) Comment State
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::COMMENT)] = CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::COMMENT)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::COMMENT)] =
-		    CSVState::RECORD_SEPARATOR;
-	}
-
-	// 12) Unquoted Escape State
-	if (enable_unquoted_escape) {
-		// Any character can be escaped, so default to STANDARD
-		if (new_line_id == NewLineIdentifier::CARRY_ON) {
-			transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::UNQUOTED_ESCAPE)] =
-			    CSVState::ESCAPED_RETURN;
-		}
-	}
-
-	// 13) Escaped Return State
-	if (enable_unquoted_escape) {
-		// The new state is STANDARD for \r + \n and \r + ordinary character.
-		// Other special characters need to be handled.
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::ESCAPED_RETURN)] = CSVState::DELIMITER;
-		if (new_line_id == NewLineIdentifier::CARRY_ON) {
-			transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::ESCAPED_RETURN)] =
-			    CSVState::CARRIAGE_RETURN;
-		} else {
-			transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::ESCAPED_RETURN)] =
-			    CSVState::RECORD_SEPARATOR;
-		}
-		if (comment != '\0') {
-			transition_array[comment][static_cast<uint8_t>(CSVState::ESCAPED_RETURN)] = CSVState::COMMENT;
-		}
-		transition_array[escape][static_cast<uint8_t>(CSVState::ESCAPED_RETURN)] = CSVState::UNQUOTED_ESCAPE;
-	}
-
-	// 14) Maybe quoted
-	transition_array[quote][static_cast<uint8_t>(CSVState::MAYBE_QUOTED)] = CSVState::MAYBE_QUOTED;
-
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::MAYBE_QUOTED)] =
-	    CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::MAYBE_QUOTED)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::MAYBE_QUOTED)] =
-		    CSVState::RECORD_SEPARATOR;
-	}
-	if (multi_byte_delimiter) {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::MAYBE_QUOTED)] =
-		    CSVState::DELIMITER_FIRST_BYTE;
-	} else {
-		transition_array[delimiter_first_byte][static_cast<uint8_t>(CSVState::MAYBE_QUOTED)] = CSVState::DELIMITER;
-	}
-
-	// Initialize characters we can skip during processing, for Standard and Quoted states
-	for (idx_t i = 0; i < StateMachine::NUM_TRANSITIONS; i++) {
-		transition_array.skip_standard[i] = true;
-		transition_array.skip_quoted[i] = true;
-		transition_array.skip_comment[i] = true;
-	}
-	// For standard states we only care for delimiters \r and \n
-	transition_array.skip_standard[delimiter_first_byte] = false;
-	transition_array.skip_standard[static_cast<uint8_t>('\n')] = false;
-	transition_array.skip_standard[static_cast<uint8_t>('\r')] = false;
-	transition_array.skip_standard[comment] = false;
-	if (enable_unquoted_escape) {
-		transition_array.skip_standard[escape] = false;
-	}
-
-	// For quoted we only care about quote, escape and for delimiters \r and \n
-	transition_array.skip_quoted[quote] = false;
-	transition_array.skip_quoted[escape] = false;
-	transition_array.skip_quoted[static_cast<uint8_t>('\n')] = false;
-	transition_array.skip_quoted[static_cast<uint8_t>('\r')] = false;
-
-	transition_array.skip_comment[static_cast<uint8_t>('\r')] = false;
-	transition_array.skip_comment[static_cast<uint8_t>('\n')] = false;
-
-	transition_array.delimiter = delimiter_first_byte;
-	transition_array.new_line = static_cast<uint8_t>('\n');
-	transition_array.carriage_return = static_cast<uint8_t>('\r');
-	transition_array.quote = quote;
-	transition_array.escape = escape;
-
-	// Shift and OR to replicate across all bytes
-	ShiftAndReplicateBits(transition_array.delimiter);
-	ShiftAndReplicateBits(transition_array.new_line);
-	ShiftAndReplicateBits(transition_array.carriage_return);
-	ShiftAndReplicateBits(transition_array.quote);
-	ShiftAndReplicateBits(transition_array.escape);
-	ShiftAndReplicateBits(transition_array.comment);
-}
-
-CSVStateMachineCache::CSVStateMachineCache() {
-	auto default_quote = DialectCandidates::GetDefaultQuote();
-	auto default_escape = DialectCandidates::GetDefaultEscape();
-	auto default_quote_rule = DialectCandidates::GetDefaultQuoteRule();
-	auto default_delimiter = DialectCandidates::GetDefaultDelimiter();
-	auto default_comment = DialectCandidates::GetDefaultComment();
-
-	for (auto quote_rule : default_quote_rule) {
-		const auto &quote_candidates = default_quote[static_cast<uint8_t>(quote_rule)];
-		for (const auto &quote : quote_candidates) {
-			for (const auto &delimiter : default_delimiter) {
-				const auto &escape_candidates = default_escape[static_cast<uint8_t>(quote_rule)];
-				for (const auto &escape : escape_candidates) {
-					for (const auto &comment : default_comment) {
-						for (const bool rfc_4180 : {true, false}) {
-							Insert({delimiter, quote, escape, comment, NewLineIdentifier::SINGLE_N, rfc_4180});
-							Insert({delimiter, quote, escape, comment, NewLineIdentifier::SINGLE_R, rfc_4180});
-							Insert({delimiter, quote, escape, comment, NewLineIdentifier::CARRY_ON, rfc_4180});
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-const StateMachine &CSVStateMachineCache::Get(const CSVStateMachineOptions &state_machine_options) {
-	// Custom State Machine, we need to create it and cache it first
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if (state_machine_cache.find(state_machine_options) == state_machine_cache.end()) {
-		Insert(state_machine_options);
-	}
-	const auto &transition_array = state_machine_cache[state_machine_options];
-	return transition_array;
-}
-
-CSVStateMachineCache &CSVStateMachineCache::Get(ClientContext &context) {
-
-	auto &cache = ObjectCache::GetObjectCache(context);
-	return *cache.GetOrCreate<CSVStateMachineCache>(CSVStateMachineCache::ObjectType());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp
deleted file mode 100644
index 093e698d0..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
-
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-
-namespace duckdb {
-CSVUnionData::~CSVUnionData() {
-}
-
-CSVFileScan::CSVFileScan(ClientContext &context, shared_ptr<CSVBufferManager> buffer_manager_p,
-                         shared_ptr<CSVStateMachine> state_machine_p, const CSVReaderOptions &options_p,
-                         const ReadCSVData &bind_data, const vector<ColumnIndex> &column_ids, CSVSchema &file_schema)
-    : file_path(options_p.file_path), file_idx(0), buffer_manager(std::move(buffer_manager_p)),
-      state_machine(std::move(state_machine_p)), file_size(buffer_manager->file_handle->FileSize()),
-      error_handler(make_shared_ptr<CSVErrorHandler>(options_p.ignore_errors.GetValue())),
-      on_disk_file(buffer_manager->file_handle->OnDiskFile()), options(options_p) {
-
-	auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan");
-	if (bind_data.initial_reader.get()) {
-		auto &union_reader = *bind_data.initial_reader;
-		names = union_reader.GetNames();
-		options = union_reader.options;
-		types = union_reader.GetTypes();
-		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
-		InitializeFileNamesTypes();
-		return;
-	}
-	if (!bind_data.column_info.empty()) {
-		// Serialized Union By name
-		names = bind_data.column_info[0].names;
-		types = bind_data.column_info[0].types;
-		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
-		InitializeFileNamesTypes();
-		return;
-	}
-	names = bind_data.csv_names;
-	types = bind_data.csv_types;
-	file_schema.Initialize(names, types, file_path);
-	multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-	                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
-
-	InitializeFileNamesTypes();
-	SetStart();
-}
-
-void CSVFileScan::SetStart() {
-	idx_t rows_to_skip = options.GetSkipRows() + state_machine->dialect_options.header.GetValue();
-	rows_to_skip = std::max(rows_to_skip, state_machine->dialect_options.rows_until_header +
-	                                          state_machine->dialect_options.header.GetValue());
-	if (rows_to_skip == 0) {
-		start_iterator.first_one = true;
-		return;
-	}
-	SkipScanner skip_scanner(buffer_manager, state_machine, error_handler, rows_to_skip);
-	skip_scanner.ParseChunk();
-	start_iterator = skip_scanner.GetIterator();
-}
-
-CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, const CSVReaderOptions &options_p,
-                         idx_t file_idx_p, const ReadCSVData &bind_data, const vector<ColumnIndex> &column_ids,
-                         CSVSchema &file_schema, bool per_file_single_threaded)
-    : file_path(file_path_p), file_idx(file_idx_p),
-      error_handler(make_shared_ptr<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
-	auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan");
-	if (file_idx == 0 && bind_data.initial_reader) {
-		auto &union_reader = *bind_data.initial_reader;
-		// Initialize Buffer Manager
-		buffer_manager = union_reader.buffer_manager;
-		// Initialize On Disk and Size of file
-		on_disk_file = union_reader.on_disk_file;
-		file_size = union_reader.file_size;
-		names = union_reader.GetNames();
-		options = union_reader.options;
-		types = union_reader.GetTypes();
-		state_machine = union_reader.state_machine;
-		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
-
-		InitializeFileNamesTypes();
-		SetStart();
-		return;
-	}
-
-	// Initialize Buffer Manager
-	buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, file_path, file_idx, per_file_single_threaded);
-	// Initialize On Disk and Size of file
-	on_disk_file = buffer_manager->file_handle->OnDiskFile();
-	file_size = buffer_manager->file_handle->FileSize();
-	// Initialize State Machine
-	auto &state_machine_cache = CSVStateMachineCache::Get(context);
-
-	if (file_idx < bind_data.column_info.size()) {
-		// (Serialized) Union By name
-		names = bind_data.column_info[file_idx].names;
-		types = bind_data.column_info[file_idx].types;
-		if (file_idx < bind_data.union_readers.size()) {
-			// union readers - use cached options
-			D_ASSERT(names == bind_data.union_readers[file_idx]->names);
-			D_ASSERT(types == bind_data.union_readers[file_idx]->types);
-			options = bind_data.union_readers[file_idx]->options;
-		} else {
-			// Serialized union by name - sniff again
-			options.dialect_options.num_cols = names.size();
-			if (options.auto_detect) {
-				CSVSniffer sniffer(options, buffer_manager, state_machine_cache);
-				sniffer.SniffCSV();
-			}
-		}
-		state_machine = make_shared_ptr<CSVStateMachine>(
-		    state_machine_cache.Get(options.dialect_options.state_machine_options), options);
-
-		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
-		InitializeFileNamesTypes();
-		SetStart();
-		return;
-	}
-	// Sniff it!
-	names = bind_data.csv_names;
-	types = bind_data.csv_types;
-	if (options.auto_detect && bind_data.files.size() > 1) {
-		if (file_schema.Empty()) {
-			CSVSniffer sniffer(options, buffer_manager, state_machine_cache);
-			auto result = sniffer.SniffCSV();
-			file_schema.Initialize(bind_data.csv_names, bind_data.csv_types, options.file_path);
-		} else if (file_idx > 0 && buffer_manager->file_handle->FileSize() > 0) {
-			options.file_path = file_path;
-			CSVSniffer sniffer(options, buffer_manager, state_machine_cache, false);
-			auto result = sniffer.AdaptiveSniff(file_schema);
-			names = result.names;
-			types = result.return_types;
-		}
-	}
-	if (options.dialect_options.num_cols == 0) {
-		// We need to define the number of columns, if the sniffer is not running this must be in the sql_type_list
-		options.dialect_options.num_cols = options.sql_type_list.size();
-	}
-	if (options.dialect_options.state_machine_options.new_line == NewLineIdentifier::NOT_SET) {
-		options.dialect_options.state_machine_options.new_line = CSVSniffer::DetectNewLineDelimiter(*buffer_manager);
-	}
-	state_machine = make_shared_ptr<CSVStateMachine>(
-	    state_machine_cache.Get(options.dialect_options.state_machine_options), options);
-	multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-	                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
-	InitializeFileNamesTypes();
-	SetStart();
-}
-
-CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, const CSVReaderOptions &options_p)
-    : file_path(file_name), file_idx(0),
-      error_handler(make_shared_ptr<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
-	buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, file_path, file_idx);
-	// Initialize On Disk and Size of file
-	on_disk_file = buffer_manager->file_handle->OnDiskFile();
-	file_size = buffer_manager->file_handle->FileSize();
-	// Sniff it (We only really care about dialect detection, if types or number of columns are different this will
-	// error out during scanning)
-	auto &state_machine_cache = CSVStateMachineCache::Get(context);
-	// We sniff file if it has not been sniffed yet and either auto-detect is on, or union by name is on
-	if ((options.auto_detect || options.file_options.union_by_name) && options.dialect_options.num_cols == 0) {
-		CSVSniffer sniffer(options, buffer_manager, state_machine_cache);
-		auto sniffer_result = sniffer.SniffCSV();
-		if (names.empty()) {
-			names = sniffer_result.names;
-			types = sniffer_result.return_types;
-		}
-	}
-	if (options.dialect_options.num_cols == 0) {
-		// We need to define the number of columns, if the sniffer is not running this must be in the sql_type_list
-		options.dialect_options.num_cols = options.sql_type_list.size();
-	}
-	// Initialize State Machine
-	state_machine = make_shared_ptr<CSVStateMachine>(
-	    state_machine_cache.Get(options.dialect_options.state_machine_options), options);
-	SetStart();
-}
-
-void CSVFileScan::InitializeFileNamesTypes() {
-	if (reader_data.empty_columns && reader_data.column_ids.empty()) {
-		// This means that the columns from this file are irrelevant.
-		// just read the first column
-		file_types.emplace_back(LogicalType::VARCHAR);
-		projected_columns.insert(0);
-		projection_ids.emplace_back(0, 0);
-		return;
-	}
-
-	for (idx_t i = 0; i < reader_data.column_ids.size(); i++) {
-		idx_t result_idx = reader_data.column_ids[i];
-		file_types.emplace_back(types[result_idx]);
-		projected_columns.insert(result_idx);
-		projection_ids.emplace_back(result_idx, i);
-	}
-
-	if (reader_data.column_ids.empty()) {
-		file_types = types;
-	}
-
-	// We need to be sure that our types are also following the cast_map
-	if (!reader_data.cast_map.empty()) {
-		for (idx_t i = 0; i < reader_data.column_ids.size(); i++) {
-			if (reader_data.cast_map.find(reader_data.column_ids[i]) != reader_data.cast_map.end()) {
-				file_types[i] = reader_data.cast_map[reader_data.column_ids[i]];
-			}
-		}
-	}
-
-	// We sort the types on the order of the parsed chunk
-	std::sort(projection_ids.begin(), projection_ids.end());
-	vector<LogicalType> sorted_types;
-	for (idx_t i = 0; i < projection_ids.size(); ++i) {
-		sorted_types.push_back(file_types[projection_ids[i].second]);
-	}
-	file_types = sorted_types;
-}
-
-const string &CSVFileScan::GetFileName() const {
-	return file_path;
-}
-const vector<string> &CSVFileScan::GetNames() {
-	return names;
-}
-const vector<LogicalType> &CSVFileScan::GetTypes() {
-	return types;
-}
-
-void CSVFileScan::InitializeProjection() {
-	for (idx_t i = 0; i < options.dialect_options.num_cols; i++) {
-		reader_data.column_ids.push_back(i);
-		reader_data.column_mapping.push_back(i);
-	}
-}
-
-void CSVFileScan::Finish() {
-	buffer_manager.reset();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp
deleted file mode 100644
index b1a4a6165..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/global_csv_state.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp"
-#include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
-#include "duckdb/main/appender.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr<CSVBufferManager> &buffer_manager,
-                               const CSVReaderOptions &options, idx_t system_threads_p, const vector<string> &files,
-                               vector<ColumnIndex> column_ids_p, const ReadCSVData &bind_data_p)
-    : context(context_p), system_threads(system_threads_p), column_ids(std::move(column_ids_p)),
-      sniffer_mismatch_error(options.sniffer_user_mismatch_error), bind_data(bind_data_p) {
-
-	if (buffer_manager && buffer_manager->GetFilePath() == files[0]) {
-		auto state_machine = make_shared_ptr<CSVStateMachine>(
-		    CSVStateMachineCache::Get(context).Get(options.dialect_options.state_machine_options), options);
-		// If we already have a buffer manager, we don't need to reconstruct it to the first file
-		file_scans.emplace_back(make_uniq<CSVFileScan>(context, buffer_manager, state_machine, options, bind_data,
-		                                               column_ids, file_schema));
-	} else {
-		// If not we need to construct it for the first file
-		file_scans.emplace_back(
-		    make_uniq<CSVFileScan>(context, files[0], options, 0U, bind_data, column_ids, file_schema, false));
-	}
-	idx_t cur_file_idx = 0;
-	while (file_scans.back()->start_iterator.done && file_scans.size() < files.size()) {
-		cur_file_idx++;
-		file_scans.emplace_back(make_uniq<CSVFileScan>(context, files[cur_file_idx], options, cur_file_idx, bind_data,
-		                                               column_ids, file_schema, false));
-	}
-	// There are situations where we only support single threaded scanning
-	bool many_csv_files = files.size() > 1 && files.size() > system_threads * 2;
-	single_threaded = many_csv_files || !options.parallel;
-	last_file_idx = 0;
-	scanner_idx = 0;
-	running_threads = CSVGlobalState::MaxThreads();
-	current_boundary = file_scans.back()->start_iterator;
-	current_boundary.SetCurrentBoundaryToPosition(single_threaded, options);
-	if (current_boundary.done && context.client_data->debug_set_max_line_length) {
-		context.client_data->debug_max_line_length = current_boundary.pos.buffer_pos;
-	}
-	current_buffer_in_use =
-	    make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx());
-}
-
-bool CSVGlobalState::IsDone() const {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	return current_boundary.done;
-}
-
-double CSVGlobalState::GetProgress(const ReadCSVData &bind_data_p) const {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	idx_t total_files = bind_data.files.size();
-	// get the progress WITHIN the current file
-	double percentage = 0;
-	if (file_scans.front()->file_size == 0) {
-		percentage = 1.0;
-	} else {
-		// for compressed files, read bytes may greater than files size.
-		for (auto &file : file_scans) {
-			double file_progress;
-			if (!file->buffer_manager) {
-				// We are done with this file, so it's 100%
-				file_progress = 1.0;
-			} else if (file->buffer_manager->file_handle->compression_type == FileCompressionType::GZIP ||
-			           file->buffer_manager->file_handle->compression_type == FileCompressionType::ZSTD) {
-				// This file is not done, and is a compressed file
-				file_progress = file->buffer_manager->file_handle->GetProgress();
-			} else {
-				file_progress = static_cast<double>(file->bytes_read);
-			}
-			// This file is an uncompressed file, so we use the more price bytes_read from the scanner
-			percentage += (static_cast<double>(1) / static_cast<double>(total_files)) *
-			              std::min(1.0, file_progress / static_cast<double>(file->file_size));
-		}
-	}
-	return percentage * 100;
-}
-
-unique_ptr<StringValueScanner> CSVGlobalState::Next(optional_ptr<StringValueScanner> previous_scanner) {
-	if (previous_scanner) {
-		// We have to insert information for validation
-		lock_guard<mutex> parallel_lock(main_mutex);
-		validator.Insert(previous_scanner->csv_file_scan->file_idx, previous_scanner->scanner_idx,
-		                 previous_scanner->GetValidationLine());
-	}
-	if (single_threaded) {
-		{
-			lock_guard<mutex> parallel_lock(main_mutex);
-			if (previous_scanner) {
-				// Cleanup previous scanner.
-				previous_scanner->buffer_tracker.reset();
-				current_buffer_in_use.reset();
-				previous_scanner->csv_file_scan->Finish();
-			}
-		}
-		idx_t cur_idx;
-		bool empty_file = false;
-		do {
-			{
-				lock_guard<mutex> parallel_lock(main_mutex);
-				cur_idx = last_file_idx++;
-				if (cur_idx >= bind_data.files.size()) {
-					// No more files to scan
-					return nullptr;
-				}
-				if (cur_idx == 0) {
-					D_ASSERT(!previous_scanner);
-					auto current_file = file_scans.front();
-					return make_uniq<StringValueScanner>(scanner_idx++, current_file->buffer_manager,
-					                                     current_file->state_machine, current_file->error_handler,
-					                                     current_file, false, current_boundary);
-				}
-			}
-			auto file_scan = make_shared_ptr<CSVFileScan>(context, bind_data.files[cur_idx], bind_data.options, cur_idx,
-			                                              bind_data, column_ids, file_schema, true);
-			empty_file = file_scan->file_size == 0;
-
-			if (!empty_file) {
-				lock_guard<mutex> parallel_lock(main_mutex);
-				file_scans.emplace_back(std::move(file_scan));
-				auto current_file = file_scans.back();
-				current_boundary = current_file->start_iterator;
-				current_boundary.SetCurrentBoundaryToPosition(single_threaded, bind_data.options);
-				current_buffer_in_use = make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager,
-				                                                        current_boundary.GetBufferIdx());
-
-				return make_uniq<StringValueScanner>(scanner_idx++, current_file->buffer_manager,
-				                                     current_file->state_machine, current_file->error_handler,
-				                                     current_file, false, current_boundary);
-			}
-		} while (empty_file);
-	}
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if (finished) {
-		return nullptr;
-	}
-	if (current_buffer_in_use->buffer_idx != current_boundary.GetBufferIdx()) {
-		current_buffer_in_use =
-		    make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx());
-	}
-	// We first create the scanner for the current boundary
-	auto &current_file = *file_scans.back();
-	auto csv_scanner =
-	    make_uniq<StringValueScanner>(scanner_idx++, current_file.buffer_manager, current_file.state_machine,
-	                                  current_file.error_handler, file_scans.back(), false, current_boundary);
-	threads_per_file[csv_scanner->csv_file_scan->file_idx]++;
-	if (previous_scanner) {
-		threads_per_file[previous_scanner->csv_file_scan->file_idx]--;
-		if (threads_per_file[previous_scanner->csv_file_scan->file_idx] == 0) {
-			previous_scanner->buffer_tracker.reset();
-			previous_scanner->csv_file_scan->Finish();
-		}
-	}
-	csv_scanner->buffer_tracker = current_buffer_in_use;
-
-	// We then produce the next boundary
-	if (!current_boundary.Next(*current_file.buffer_manager, bind_data.options)) {
-		// This means we are done scanning the current file
-		do {
-			auto current_file_idx = file_scans.back()->file_idx + 1;
-			if (current_file_idx < bind_data.files.size()) {
-				// If we have a next file we have to construct the file scan for that
-				file_scans.emplace_back(make_shared_ptr<CSVFileScan>(context, bind_data.files[current_file_idx],
-				                                                     bind_data.options, current_file_idx, bind_data,
-				                                                     column_ids, file_schema, false));
-				// And re-start the boundary-iterator
-				current_boundary = file_scans.back()->start_iterator;
-				current_boundary.SetCurrentBoundaryToPosition(single_threaded, bind_data.options);
-				current_buffer_in_use = make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager,
-				                                                        current_boundary.GetBufferIdx());
-			} else {
-				// If not we are done with this CSV Scanning
-				finished = true;
-				break;
-			}
-		} while (current_boundary.done);
-	}
-	// We initialize the scan
-	return csv_scanner;
-}
-
-idx_t CSVGlobalState::MaxThreads() const {
-	// We initialize max one thread per our set bytes per thread limit
-	if (single_threaded || !file_scans.front()->on_disk_file) {
-		return system_threads;
-	}
-	const idx_t bytes_per_thread = CSVIterator::BytesPerThread(file_scans.front()->options);
-	const idx_t total_threads = file_scans.front()->file_size / bytes_per_thread + 1;
-	if (total_threads < system_threads) {
-		return total_threads;
-	}
-	return system_threads;
-}
-
-void CSVGlobalState::DecrementThread() {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	D_ASSERT(running_threads > 0);
-	running_threads--;
-	if (running_threads == 0) {
-		const bool ignore_or_store_errors =
-		    bind_data.options.ignore_errors.GetValue() || bind_data.options.store_rejects.GetValue();
-		if (!single_threaded && !ignore_or_store_errors) {
-			// If we are running multithreaded and not ignoring errors, we must run the validator
-			validator.Verify();
-		}
-		for (const auto &file : file_scans) {
-			file->error_handler->ErrorIfNeeded();
-		}
-		FillRejectsTable();
-		if (context.client_data->debug_set_max_line_length) {
-			context.client_data->debug_max_line_length = file_scans[0]->error_handler->GetMaxLineLength();
-		}
-	}
-}
-
-void FillScanErrorTable(InternalAppender &scan_appender, idx_t scan_idx, idx_t file_idx, CSVFileScan &file) {
-	CSVReaderOptions &options = file.options;
-	// Add the row to the rejects table
-	scan_appender.BeginRow();
-	// 1. Scan Idx
-	scan_appender.Append(scan_idx);
-	// 2. File Idx
-	scan_appender.Append(file_idx);
-	// 3. File Path
-	scan_appender.Append(string_t(file.file_path));
-	// 4. Delimiter
-	scan_appender.Append(string_t(options.dialect_options.state_machine_options.delimiter.FormatValue()));
-	// 5. Quote
-	scan_appender.Append(string_t(options.dialect_options.state_machine_options.quote.FormatValue()));
-	// 6. Escape
-	scan_appender.Append(string_t(options.dialect_options.state_machine_options.escape.FormatValue()));
-	// 7. NewLine Delimiter
-	scan_appender.Append(string_t(options.NewLineIdentifierToString()));
-	// 8. Skip Rows
-	scan_appender.Append(Value::UINTEGER(NumericCast<uint32_t>(options.dialect_options.skip_rows.GetValue())));
-	// 9. Has Header
-	scan_appender.Append(Value::BOOLEAN(options.dialect_options.header.GetValue()));
-	// 10. List<Struct<Column-Name:Types>> {'col1': 'INTEGER', 'col2': 'VARCHAR'}
-	std::ostringstream columns;
-	columns << "{";
-	for (idx_t i = 0; i < file.types.size(); i++) {
-		columns << "'" << file.names[i] << "': '" << file.types[i].ToString() << "'";
-		if (i != file.types.size() - 1) {
-			columns << ",";
-		}
-	}
-	columns << "}";
-	scan_appender.Append(string_t(columns.str()));
-	// 11. Date Format
-	auto date_format = options.dialect_options.date_format[LogicalType::DATE].GetValue();
-	if (!date_format.Empty()) {
-		scan_appender.Append(string_t(date_format.format_specifier));
-	} else {
-		scan_appender.Append(Value());
-	}
-
-	// 12. Timestamp Format
-	auto timestamp_format = options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue();
-	if (!timestamp_format.Empty()) {
-		scan_appender.Append(string_t(timestamp_format.format_specifier));
-	} else {
-		scan_appender.Append(Value());
-	}
-
-	// 13. The Extra User Arguments
-	if (options.user_defined_parameters.empty()) {
-		scan_appender.Append(Value());
-	} else {
-		scan_appender.Append(string_t(options.user_defined_parameters));
-	}
-	// Finish the row to the rejects table
-	scan_appender.EndRow();
-}
-
-void CSVGlobalState::FillRejectsTable() const {
-	auto &options = bind_data.options;
-
-	if (options.store_rejects.GetValue()) {
-		auto limit = options.rejects_limit;
-		auto rejects = CSVRejectsTable::GetOrCreate(context, options.rejects_scan_name.GetValue(),
-		                                            options.rejects_table_name.GetValue());
-		lock_guard<mutex> lock(rejects->write_lock);
-		auto &errors_table = rejects->GetErrorsTable(context);
-		auto &scans_table = rejects->GetScansTable(context);
-		InternalAppender errors_appender(context, errors_table);
-		InternalAppender scans_appender(context, scans_table);
-		idx_t scan_idx = context.transaction.GetActiveQuery();
-		for (auto &file : file_scans) {
-			const idx_t file_idx = rejects->GetCurrentFileIndex(scan_idx);
-			auto file_name = file->file_path;
-			file->error_handler->FillRejectsTable(errors_appender, file_idx, scan_idx, *file, *rejects, bind_data,
-			                                      limit);
-			if (rejects->count != 0) {
-				rejects->count = 0;
-				FillScanErrorTable(scans_appender, scan_idx, file_idx, *file);
-			}
-		}
-		errors_appender.Close();
-		scans_appender.Close();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp
deleted file mode 100644
index f77a93ac0..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp
+++ /dev/null
@@ -1,552 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
-#include "duckdb/main/appender.hpp"
-#include <sstream>
-
-namespace duckdb {
-
-LinesPerBoundary::LinesPerBoundary() {
-}
-LinesPerBoundary::LinesPerBoundary(idx_t boundary_idx_p, idx_t lines_in_batch_p)
-    : boundary_idx(boundary_idx_p), lines_in_batch(lines_in_batch_p) {
-}
-
-CSVErrorHandler::CSVErrorHandler(bool ignore_errors_p) : ignore_errors(ignore_errors_p) {
-}
-
-void CSVErrorHandler::ThrowError(const CSVError &csv_error) {
-	std::ostringstream error;
-	if (PrintLineNumber(csv_error)) {
-		error << "CSV Error on Line: " << GetLineInternal(csv_error.error_info) << '\n';
-		if (!csv_error.csv_row.empty()) {
-			error << "Original Line: " << csv_error.csv_row << '\n';
-		}
-	}
-	if (csv_error.full_error_message.empty()) {
-		error << csv_error.error_message;
-	} else {
-		error << csv_error.full_error_message;
-	}
-
-	switch (csv_error.type) {
-	case CAST_ERROR:
-		throw ConversionException(error.str());
-	case COLUMN_NAME_TYPE_MISMATCH:
-		throw BinderException(error.str());
-	case NULLPADDED_QUOTED_NEW_VALUE:
-		throw ParameterNotAllowedException(error.str());
-	default:
-		throw InvalidInputException(error.str());
-	}
-}
-
-void CSVErrorHandler::Error(const CSVError &csv_error, bool force_error) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if ((ignore_errors && !force_error) || (PrintLineNumber(csv_error) && !CanGetLine(csv_error.GetBoundaryIndex()))) {
-		// We store this error, we can't throw it now, or we are ignoring it
-		errors.push_back(csv_error);
-		return;
-	}
-	// Otherwise we can throw directly
-	ThrowError(csv_error);
-}
-
-void CSVErrorHandler::ErrorIfNeeded() {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if (ignore_errors || errors.empty()) {
-		// Nothing to error
-		return;
-	}
-
-	if (CanGetLine(errors[0].error_info.boundary_idx)) {
-		ThrowError(errors[0]);
-	}
-}
-
-void CSVErrorHandler::ErrorIfTypeExists(CSVErrorType error_type) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	for (auto &error : errors) {
-		if (error.type == error_type) {
-			// If it's a maximum line size error, we can do it now.
-			ThrowError(error);
-		}
-	}
-}
-
-void CSVErrorHandler::Insert(idx_t boundary_idx, idx_t rows) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	if (lines_per_batch_map.find(boundary_idx) == lines_per_batch_map.end()) {
-		lines_per_batch_map[boundary_idx] = {boundary_idx, rows};
-	} else {
-		lines_per_batch_map[boundary_idx].lines_in_batch += rows;
-	}
-}
-
-void CSVErrorHandler::NewMaxLineSize(idx_t scan_line_size) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	max_line_length = std::max(scan_line_size, max_line_length);
-}
-
-bool CSVErrorHandler::AnyErrors() {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	return !errors.empty();
-}
-
-bool CSVErrorHandler::HasError(const CSVErrorType error_type) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	for (const auto &er : errors) {
-		if (er.type == error_type) {
-			return true;
-		}
-	}
-	return false;
-}
-
-idx_t CSVErrorHandler::GetSize() {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	return errors.size();
-}
-
-bool IsCSVErrorAcceptedReject(CSVErrorType type) {
-	switch (type) {
-	case CSVErrorType::INVALID_STATE:
-	case CSVErrorType::CAST_ERROR:
-	case CSVErrorType::TOO_MANY_COLUMNS:
-	case CSVErrorType::TOO_FEW_COLUMNS:
-	case CSVErrorType::MAXIMUM_LINE_SIZE:
-	case CSVErrorType::UNTERMINATED_QUOTES:
-	case CSVErrorType::INVALID_UNICODE:
-		return true;
-	default:
-		return false;
-	}
-}
-string CSVErrorTypeToEnum(CSVErrorType type) {
-	switch (type) {
-	case CSVErrorType::CAST_ERROR:
-		return "CAST";
-	case CSVErrorType::TOO_FEW_COLUMNS:
-		return "MISSING COLUMNS";
-	case CSVErrorType::TOO_MANY_COLUMNS:
-		return "TOO MANY COLUMNS";
-	case CSVErrorType::MAXIMUM_LINE_SIZE:
-		return "LINE SIZE OVER MAXIMUM";
-	case CSVErrorType::UNTERMINATED_QUOTES:
-		return "UNQUOTED VALUE";
-	case CSVErrorType::INVALID_UNICODE:
-		return "INVALID UNICODE";
-	case CSVErrorType::INVALID_STATE:
-		return "INVALID STATE";
-	default:
-		throw InternalException("CSV Error is not valid to be stored in a Rejects Table");
-	}
-}
-
-void CSVErrorHandler::FillRejectsTable(InternalAppender &errors_appender, const idx_t file_idx, const idx_t scan_idx,
-                                       const CSVFileScan &file, CSVRejectsTable &rejects, const ReadCSVData &bind_data,
-                                       const idx_t limit) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	// We first insert the file into the file scans table
-	for (auto &error : file.error_handler->errors) {
-		if (!IsCSVErrorAcceptedReject(error.type)) {
-			continue;
-		}
-		// short circuit if we already have too many rejects
-		if (limit == 0 || rejects.count < limit) {
-			if (limit != 0 && rejects.count >= limit) {
-				break;
-			}
-			rejects.count++;
-			const auto row_line = file.error_handler->GetLineInternal(error.error_info);
-			const auto col_idx = error.column_idx;
-			// Add the row to the rejects table
-			errors_appender.BeginRow();
-			// 1. Scan ID
-			errors_appender.Append(scan_idx);
-			// 2. File ID
-			errors_appender.Append(file_idx);
-			// 3. Row Line
-			errors_appender.Append(row_line);
-			// 4. Byte Position of the row error
-			errors_appender.Append(error.row_byte_position + 1);
-			// 5. Byte Position where error occurred
-			if (!error.byte_position.IsValid()) {
-				// This means this error comes from a flush, and we don't support this yet, so we give it
-				// a null
-				errors_appender.Append(Value());
-			} else {
-				errors_appender.Append(error.byte_position.GetIndex() + 1);
-			}
-			// 6. Column Index
-			if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) {
-				errors_appender.Append(Value());
-			} else {
-				errors_appender.Append(col_idx + 1);
-			}
-			// 7. Column Name (If Applicable)
-			switch (error.type) {
-			case CSVErrorType::TOO_MANY_COLUMNS:
-			case CSVErrorType::MAXIMUM_LINE_SIZE:
-				errors_appender.Append(Value());
-				break;
-			case CSVErrorType::TOO_FEW_COLUMNS:
-				D_ASSERT(bind_data.return_names.size() > col_idx + 1);
-				errors_appender.Append(string_t(bind_data.return_names[col_idx + 1]));
-				break;
-			default:
-				errors_appender.Append(string_t(bind_data.return_names[col_idx]));
-			}
-			// 8. Error Type
-			errors_appender.Append(string_t(CSVErrorTypeToEnum(error.type)));
-			// 9. Original CSV Line
-			errors_appender.Append(string_t(error.csv_row));
-			// 10. Full Error Message
-			errors_appender.Append(string_t(error.error_message));
-			errors_appender.EndRow();
-		}
-	}
-}
-
-idx_t CSVErrorHandler::GetMaxLineLength() {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	return max_line_length;
-}
-
-void CSVErrorHandler::DontPrintErrorLine() {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	print_line = false;
-}
-
-void CSVErrorHandler::SetIgnoreErrors(bool ignore_errors_p) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	ignore_errors = ignore_errors_p;
-}
-
-CSVError::CSVError(string error_message_p, CSVErrorType type_p, LinesPerBoundary error_info_p)
-    : error_message(std::move(error_message_p)), type(type_p), error_info(error_info_p) {
-}
-
-CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, string csv_row_p,
-                   LinesPerBoundary error_info_p, idx_t row_byte_position, optional_idx byte_position_p,
-                   const CSVReaderOptions &reader_options, const string &fixes, const string &current_path)
-    : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), csv_row(std::move(csv_row_p)),
-      error_info(error_info_p), row_byte_position(row_byte_position), byte_position(byte_position_p) {
-	// What were the options
-	std::ostringstream error;
-	if (reader_options.ignore_errors.GetValue()) {
-		RemoveNewLine(error_message);
-	}
-	error << error_message << '\n';
-	error << fixes << '\n';
-	error << reader_options.ToString(current_path);
-	error << '\n';
-	full_error_message = error.str();
-}
-
-CSVError CSVError::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names) {
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto it = sql_types_per_column.find(names[i]);
-		if (it != sql_types_per_column.end()) {
-			sql_types_per_column.erase(names[i]);
-		}
-	}
-	if (sql_types_per_column.empty()) {
-		return CSVError("", COLUMN_NAME_TYPE_MISMATCH, {});
-	}
-	string exception = "COLUMN_TYPES error: Columns with names: ";
-	for (auto &col : sql_types_per_column) {
-		exception += "\"" + col.first + "\",";
-	}
-	exception.pop_back();
-	exception += " do not exist in the CSV File";
-	return CSVError(exception, COLUMN_NAME_TYPE_MISMATCH, {});
-}
-
-void CSVError::RemoveNewLine(string &error) {
-	error = StringUtil::Split(error, "\n")[0];
-}
-
-CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, idx_t column_idx,
-                             string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position,
-                             optional_idx byte_position, LogicalTypeId type, const string &current_path) {
-	std::ostringstream error;
-	// Which column
-	error << "Error when converting column \"" << column_name << "\". ";
-	// What was the cast error
-	error << cast_error << '\n';
-	std::ostringstream how_to_fix_it;
-	how_to_fix_it << "Column " << column_name << " is being converted as type " << LogicalTypeIdToString(type) << '\n';
-	if (!options.WasTypeManuallySet(column_idx)) {
-		how_to_fix_it << "This type was auto-detected from the CSV file." << '\n';
-		how_to_fix_it << "Possible solutions:" << '\n';
-		how_to_fix_it << "* Override the type for this column manually by setting the type explicitly, e.g. types={'"
-		              << column_name << "': 'VARCHAR'}" << '\n';
-		how_to_fix_it
-		    << "* Set the sample size to a larger value to enable the auto-detection to scan more values, e.g. "
-		       "sample_size=-1"
-		    << '\n';
-		how_to_fix_it << "* Use a COPY statement to automatically derive types from an existing table." << '\n';
-	} else {
-		how_to_fix_it
-		    << "This type was either manually set or derived from an existing table. Select a different type to "
-		       "correctly parse this column."
-		    << '\n';
-	}
-
-	return CSVError(error.str(), CAST_ERROR, column_idx, csv_row, error_info, row_byte_position, byte_position, options,
-	                how_to_fix_it.str(), current_path);
-}
-
-CSVError CSVError::LineSizeError(const CSVReaderOptions &options, LinesPerBoundary error_info, string &csv_row,
-                                 idx_t byte_position, const string &current_path) {
-	std::ostringstream error;
-	error << "Maximum line size of " << options.maximum_line_size.GetValue() << " bytes exceeded. ";
-	error << "Actual Size:" << csv_row.size() << " bytes." << '\n';
-
-	std::ostringstream how_to_fix_it;
-	how_to_fix_it << "Possible Solution: Change the maximum length size, e.g., max_line_size=" << csv_row.size() + 2
-	              << "\n";
-
-	return CSVError(error.str(), MAXIMUM_LINE_SIZE, 0, csv_row, error_info, byte_position, byte_position, options,
-	                how_to_fix_it.str(), current_path);
-}
-
-CSVError CSVError::InvalidState(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
-                                string &csv_row, idx_t row_byte_position, optional_idx byte_position,
-                                const string &current_path) {
-	std::ostringstream error;
-	error << "The CSV Parser state machine reached an invalid state.\nThis can happen when is not possible to parse "
-	         "your CSV File with the given options, or the CSV File is not RFC 4180 compliant ";
-
-	std::ostringstream how_to_fix_it;
-	how_to_fix_it << "Possible fixes:" << '\n';
-	how_to_fix_it << "* Enable scanning files that are not RFC 4180 compliant (rfc_4180=false)." << '\n';
-
-	return CSVError(error.str(), INVALID_STATE, current_column, csv_row, error_info, row_byte_position, byte_position,
-	                options, how_to_fix_it.str(), current_path);
-}
-CSVError CSVError::HeaderSniffingError(const CSVReaderOptions &options, const vector<HeaderValue> &best_header_row,
-                                       const idx_t column_count, const string &delimiter) {
-	std::ostringstream error;
-	// 1. Which file
-	error << "Error when sniffing file \"" << options.file_path << "\"." << '\n';
-	// 2. What's the error
-	error << "It was not possible to detect the CSV Header, due to the header having less columns than expected"
-	      << '\n';
-	// 2.1 What's the expected number of columns
-	error << "Number of expected columns: " << column_count << ". Actual number of columns " << best_header_row.size()
-	      << '\n';
-	// 2.2 What was the detected row
-	error << "Detected row as Header:" << '\n';
-	for (idx_t i = 0; i < best_header_row.size(); i++) {
-		if (best_header_row[i].is_null) {
-			error << "NULL";
-		} else {
-			error << best_header_row[i].value;
-		}
-		if (i < best_header_row.size() - 1) {
-			error << delimiter << " ";
-		}
-	}
-	error << "\n";
-
-	// 3. Suggest how to fix it!
-	error << "Possible fixes:" << '\n';
-	// header
-	if (!options.dialect_options.header.IsSetByUser()) {
-		error << "* Set header (header = true) if your CSV has a header, or (header = false) if it doesn't" << '\n';
-	} else {
-		error << "* Header is set to \'" << options.dialect_options.header.GetValue() << "\'. Consider unsetting it."
-		      << '\n';
-	}
-	// skip_rows
-	if (!options.dialect_options.skip_rows.IsSetByUser()) {
-		error << "* Set skip (skip=${n}) to skip ${n} lines at the top of the file" << '\n';
-	} else {
-		error << "* Skip is set to \'" << options.dialect_options.skip_rows.GetValue() << "\'. Consider unsetting it."
-		      << '\n';
-	}
-	// ignore_errors
-	if (!options.ignore_errors.GetValue()) {
-		error << "* Enable ignore errors (ignore_errors=true) to ignore potential errors" << '\n';
-	}
-	// null_padding
-	if (!options.null_padding) {
-		error << "* Enable null padding (null_padding=true) to pad missing columns with NULL values" << '\n';
-	}
-
-	return CSVError(error.str(), SNIFFING, {});
-}
-
-CSVError CSVError::SniffingError(const CSVReaderOptions &options, const string &search_space) {
-	std::ostringstream error;
-	// 1. Which file
-	error << "Error when sniffing file \"" << options.file_path << "\"." << '\n';
-	// 2. What's the error
-	error << "It was not possible to automatically detect the CSV Parsing dialect/types" << '\n';
-
-	// 2. What was the search space?
-	error << "The search space used was:" << '\n';
-	error << search_space;
-	// 3. Suggest how to fix it!
-	error << "Possible fixes:" << '\n';
-	// 3.1 Inform the reader of the dialect
-	// delimiter
-	if (!options.dialect_options.state_machine_options.delimiter.IsSetByUser()) {
-		error << "* Set delimiter (e.g., delim=\',\')" << '\n';
-	} else {
-		error << "* Delimiter is set to \'" << options.dialect_options.state_machine_options.delimiter.GetValue()
-		      << "\'. Consider unsetting it." << '\n';
-	}
-	// quote
-	if (!options.dialect_options.state_machine_options.quote.IsSetByUser()) {
-		error << "* Set quote (e.g., quote=\'\"\')" << '\n';
-	} else {
-		error << "* Quote is set to \'" << options.dialect_options.state_machine_options.quote.GetValue()
-		      << "\'. Consider unsetting it." << '\n';
-	}
-	// escape
-	if (!options.dialect_options.state_machine_options.escape.IsSetByUser()) {
-		error << "* Set escape (e.g., escape=\'\"\')" << '\n';
-	} else {
-		error << "* Escape is set to \'" << options.dialect_options.state_machine_options.escape.GetValue()
-		      << "\'. Consider unsetting it." << '\n';
-	}
-	// comment
-	if (!options.dialect_options.state_machine_options.comment.IsSetByUser()) {
-		error << "* Set comment (e.g., comment=\'#\')" << '\n';
-	} else {
-		error << "* Comment is set to \'" << options.dialect_options.state_machine_options.comment.GetValue()
-		      << "\'. Consider unsetting it." << '\n';
-	}
-	// 3.2 skip_rows
-	if (!options.dialect_options.skip_rows.IsSetByUser()) {
-		error << "* Set skip (skip=${n}) to skip ${n} lines at the top of the file" << '\n';
-	}
-	// 3.3 ignore_errors
-	if (!options.ignore_errors.GetValue()) {
-		error << "* Enable ignore errors (ignore_errors=true) to ignore potential errors" << '\n';
-	}
-	// 3.4 null_padding
-	if (!options.null_padding) {
-		error << "* Enable null padding (null_padding=true) to pad missing columns with NULL values" << '\n';
-	}
-	error << "* Check you are using the correct file compression, otherwise set it (e.g., compression = \'zstd\')"
-	      << '\n';
-	error << "* Be sure that the maximum line size is set to an appropriate value, otherwise set it (e.g., "
-	         "max_line_size=10000000)"
-	      << "\n";
-
-	if (options.dialect_options.state_machine_options.rfc_4180.GetValue() != false ||
-	    !options.dialect_options.state_machine_options.rfc_4180.IsSetByUser()) {
-		error << "* Enable scanning files that are not RFC 4180 compliant (rfc_4180=false). " << '\n';
-	}
-	return CSVError(error.str(), SNIFFING, {});
-}
-
-CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info,
-                                   const string &current_path) {
-	std::ostringstream error;
-	error << " The parallel scanner does not support null_padding in conjunction with quoted new lines. Please "
-	         "disable the parallel csv reader with parallel=false"
-	      << '\n';
-	// What were the options
-	error << options.ToString(current_path);
-	return CSVError(error.str(), NULLPADDED_QUOTED_NEW_VALUE, error_info);
-}
-
-CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, idx_t current_column,
-                                           LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-                                           optional_idx byte_position, const string &current_path) {
-	std::ostringstream error;
-	error << "Value with unterminated quote found." << '\n';
-	std::ostringstream how_to_fix_it;
-	how_to_fix_it << "Possible fixes:" << '\n';
-	how_to_fix_it << "* Enable ignore errors (ignore_errors=true) to skip this row" << '\n';
-	how_to_fix_it << "* Set quote to empty or to a different value (e.g., quote=\'\')" << '\n';
-	return CSVError(error.str(), UNTERMINATED_QUOTES, current_column, csv_row, error_info, row_byte_position,
-	                byte_position, options, how_to_fix_it.str(), current_path);
-}
-
-CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, idx_t actual_columns,
-                                              LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-                                              optional_idx byte_position, const string &current_path) {
-	std::ostringstream error;
-	// We don't have a fix for this
-	std::ostringstream how_to_fix_it;
-	how_to_fix_it << "Possible fixes:" << '\n';
-	if (!options.null_padding) {
-		how_to_fix_it << "* Enable null padding (null_padding=true) to replace missing values with NULL" << '\n';
-	}
-	if (!options.ignore_errors.GetValue()) {
-		how_to_fix_it << "* Enable ignore errors (ignore_errors=true) to skip this row" << '\n';
-	}
-	// How many columns were expected and how many were found
-	error << "Expected Number of Columns: " << options.dialect_options.num_cols << " Found: " << actual_columns + 1;
-	idx_t byte_pos = byte_position.GetIndex() == 0 ? 0 : byte_position.GetIndex() - 1;
-	if (actual_columns >= options.dialect_options.num_cols) {
-		return CSVError(error.str(), TOO_MANY_COLUMNS, actual_columns, csv_row, error_info, row_byte_position, byte_pos,
-		                options, how_to_fix_it.str(), current_path);
-	} else {
-		return CSVError(error.str(), TOO_FEW_COLUMNS, actual_columns, csv_row, error_info, row_byte_position, byte_pos,
-		                options, how_to_fix_it.str(), current_path);
-	}
-}
-
-CSVError CSVError::InvalidUTF8(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
-                               string &csv_row, idx_t row_byte_position, optional_idx byte_position,
-                               const string &current_path) {
-	std::ostringstream error;
-	// How many columns were expected and how many were found
-	error << "Invalid unicode (byte sequence mismatch) detected." << '\n';
-	std::ostringstream how_to_fix_it;
-	how_to_fix_it << "Possible Solution: Enable ignore errors (ignore_errors=true) to skip this row" << '\n';
-	return CSVError(error.str(), INVALID_UNICODE, current_column, csv_row, error_info, row_byte_position, byte_position,
-	                options, how_to_fix_it.str(), current_path);
-}
-
-bool CSVErrorHandler::PrintLineNumber(const CSVError &error) const {
-	if (!print_line) {
-		return false;
-	}
-	switch (error.type) {
-	case CAST_ERROR:
-	case UNTERMINATED_QUOTES:
-	case TOO_FEW_COLUMNS:
-	case TOO_MANY_COLUMNS:
-	case MAXIMUM_LINE_SIZE:
-	case NULLPADDED_QUOTED_NEW_VALUE:
-	case INVALID_UNICODE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool CSVErrorHandler::CanGetLine(idx_t boundary_index) {
-	for (idx_t i = 0; i < boundary_index; i++) {
-		if (lines_per_batch_map.find(i) == lines_per_batch_map.end()) {
-			return false;
-		}
-	}
-	return true;
-}
-
-idx_t CSVErrorHandler::GetLine(const LinesPerBoundary &error_info) {
-	lock_guard<mutex> parallel_lock(main_mutex);
-	return GetLineInternal(error_info);
-}
-idx_t CSVErrorHandler::GetLineInternal(const LinesPerBoundary &error_info) {
-	// We start from one, since the lines are 1-indexed
-	idx_t current_line = 1 + error_info.lines_in_batch;
-	for (idx_t boundary_idx = 0; boundary_idx < error_info.boundary_idx; boundary_idx++) {
-		current_line += lines_per_batch_map[boundary_idx].lines_in_batch;
-	}
-	return current_line;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp
deleted file mode 100644
index ac18d42eb..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp
+++ /dev/null
@@ -1,765 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/common/bind_helpers.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/set.hpp"
-
-namespace duckdb {
-
-CSVReaderOptions::CSVReaderOptions(const CSVOption<char> single_byte_delimiter,
-                                   const CSVOption<string> &multi_byte_delimiter) {
-	if (multi_byte_delimiter.GetValue().empty()) {
-		const char single_byte_value = single_byte_delimiter.GetValue();
-		const string value(1, single_byte_value);
-		dialect_options.state_machine_options.delimiter = value;
-	} else {
-		dialect_options.state_machine_options.delimiter = multi_byte_delimiter;
-	}
-}
-static bool ParseBoolean(const Value &value, const string &loption);
-
-static bool ParseBoolean(const vector<Value> &set, const string &loption) {
-	if (set.empty()) {
-		// no option specified: default to true
-		return true;
-	}
-	if (set.size() > 1) {
-		throw BinderException("\"%s\" expects a single argument as a boolean value (e.g. TRUE or 1)", loption);
-	}
-	return ParseBoolean(set[0], loption);
-}
-
-static bool ParseBoolean(const Value &value, const string &loption) {
-	if (value.IsNull()) {
-		throw BinderException("\"%s\" expects a non-null boolean value (e.g. TRUE or 1)", loption);
-	}
-	if (value.type().id() == LogicalTypeId::LIST) {
-		auto &children = ListValue::GetChildren(value);
-		return ParseBoolean(children, loption);
-	}
-	if (value.type() == LogicalType::FLOAT || value.type() == LogicalType::DOUBLE ||
-	    value.type().id() == LogicalTypeId::DECIMAL) {
-		throw BinderException("\"%s\" expects a boolean value (e.g. TRUE or 1)", loption);
-	}
-	return BooleanValue::Get(value.DefaultCastAs(LogicalType::BOOLEAN));
-}
-
-static string ParseString(const Value &value, const string &loption) {
-	if (value.IsNull()) {
-		return string();
-	}
-	if (value.type().id() == LogicalTypeId::LIST) {
-		auto &children = ListValue::GetChildren(value);
-		if (children.size() != 1) {
-			throw BinderException("\"%s\" expects a single argument as a string value", loption);
-		}
-		return ParseString(children[0], loption);
-	}
-	if (value.type().id() != LogicalTypeId::VARCHAR) {
-		throw BinderException("\"%s\" expects a string argument!", loption);
-	}
-	return value.GetValue<string>();
-}
-
-static int64_t ParseInteger(const Value &value, const string &loption) {
-	if (value.IsNull()) {
-		throw BinderException("\"%s\" expects a non-null integer value", loption);
-	}
-	if (value.type().id() == LogicalTypeId::LIST) {
-		auto &children = ListValue::GetChildren(value);
-		if (children.size() != 1) {
-			// no option specified or multiple options specified
-			throw BinderException("\"%s\" expects a single argument as an integer value", loption);
-		}
-		return ParseInteger(children[0], loption);
-	}
-	return value.GetValue<int64_t>();
-}
-
-bool CSVReaderOptions::GetHeader() const {
-	return this->dialect_options.header.GetValue();
-}
-
-void CSVReaderOptions::SetHeader(bool input) {
-	this->dialect_options.header.Set(input);
-}
-
-void CSVReaderOptions::SetCompression(const string &compression_p) {
-	this->compression = FileCompressionTypeFromString(compression_p);
-}
-
-string CSVReaderOptions::GetEscape() const {
-	return std::string(1, this->dialect_options.state_machine_options.escape.GetValue());
-}
-
-void CSVReaderOptions::SetEscape(const string &input) {
-	auto escape_str = input;
-	if (escape_str.size() > 1) {
-		throw InvalidInputException("The escape option cannot exceed a size of 1 byte.");
-	}
-	if (escape_str.empty()) {
-		escape_str = string("\0", 1);
-	}
-	this->dialect_options.state_machine_options.escape.Set(escape_str[0]);
-}
-
-idx_t CSVReaderOptions::GetSkipRows() const {
-	return NumericCast<idx_t>(this->dialect_options.skip_rows.GetValue());
-}
-
-void CSVReaderOptions::SetSkipRows(int64_t skip_rows) {
-	if (skip_rows < 0) {
-		throw InvalidInputException("skip_rows option from read_csv scanner, must be equal or higher than 0");
-	}
-	dialect_options.skip_rows.Set(NumericCast<idx_t>(skip_rows));
-}
-
-string CSVReaderOptions::GetDelimiter() const {
-	return this->dialect_options.state_machine_options.delimiter.GetValue();
-}
-
-void CSVReaderOptions::SetDelimiter(const string &input) {
-	auto delim_str = StringUtil::Replace(input, "\\t", "\t");
-	if (delim_str.size() > 4) {
-		throw InvalidInputException("The delimiter option cannot exceed a size of 4 bytes.");
-	}
-	if (input.empty()) {
-		delim_str = string("\0", 1);
-	}
-	this->dialect_options.state_machine_options.delimiter.Set(delim_str);
-}
-
-string CSVReaderOptions::GetQuote() const {
-	return std::string(1, this->dialect_options.state_machine_options.quote.GetValue());
-}
-
-void CSVReaderOptions::SetQuote(const string &quote_p) {
-	auto quote_str = quote_p;
-	if (quote_str.size() > 1) {
-		throw InvalidInputException("The quote option cannot exceed a size of 1 byte.");
-	}
-	if (quote_str.empty()) {
-		quote_str = string("\0", 1);
-	}
-	this->dialect_options.state_machine_options.quote.Set(quote_str[0]);
-}
-
-string CSVReaderOptions::GetComment() const {
-	return std::string(1, this->dialect_options.state_machine_options.comment.GetValue());
-}
-
-void CSVReaderOptions::SetComment(const string &comment_p) {
-	auto comment_str = comment_p;
-	if (comment_str.size() > 1) {
-		throw InvalidInputException("The comment option cannot exceed a size of 1 byte.");
-	}
-	if (comment_str.empty()) {
-		comment_str = string("\0", 1);
-	}
-	this->dialect_options.state_machine_options.comment.Set(comment_str[0]);
-}
-
-string CSVReaderOptions::GetNewline() const {
-	switch (dialect_options.state_machine_options.new_line.GetValue()) {
-	case NewLineIdentifier::CARRY_ON:
-		return "\\r\\n";
-	case NewLineIdentifier::SINGLE_R:
-		return "\\r";
-	case NewLineIdentifier::SINGLE_N:
-		return "\\n";
-	case NewLineIdentifier::NOT_SET:
-		return "";
-	default:
-		throw NotImplementedException("New line type not supported");
-	}
-}
-
-void CSVReaderOptions::SetNewline(const string &input) {
-	if (input == "\\n") {
-		dialect_options.state_machine_options.new_line.Set(NewLineIdentifier::SINGLE_N);
-	} else if (input == "\\r") {
-		dialect_options.state_machine_options.new_line.Set(NewLineIdentifier::SINGLE_R);
-	} else if (input == "\\r\\n") {
-		dialect_options.state_machine_options.new_line.Set(NewLineIdentifier::CARRY_ON);
-	} else {
-		throw InvalidInputException("This is not accepted as a newline: " + input);
-	}
-}
-
-bool CSVReaderOptions::GetRFC4180() const {
-	return this->dialect_options.state_machine_options.rfc_4180.GetValue();
-}
-
-void CSVReaderOptions::SetRFC4180(bool input) {
-	this->dialect_options.state_machine_options.rfc_4180.Set(input);
-}
-
-bool CSVReaderOptions::IgnoreErrors() const {
-	return ignore_errors.GetValue() && !store_rejects.GetValue();
-}
-
-char CSVReaderOptions::GetSingleByteDelimiter() const {
-	return dialect_options.state_machine_options.delimiter.GetValue()[0];
-}
-
-string CSVReaderOptions::GetMultiByteDelimiter() const {
-	return dialect_options.state_machine_options.delimiter.GetValue();
-}
-
-void CSVReaderOptions::SetDateFormat(LogicalTypeId type, const string &format, bool read_format) {
-	string error;
-	if (read_format) {
-		StrpTimeFormat strpformat;
-		error = StrTimeFormat::ParseFormatSpecifier(format, strpformat);
-		dialect_options.date_format[type].Set(strpformat);
-	} else {
-		write_date_format[type] = Value(format);
-	}
-	if (!error.empty()) {
-		throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
-	}
-}
-
-void CSVReaderOptions::SetReadOption(const string &loption, const Value &value, vector<string> &expected_names) {
-	if (SetBaseOption(loption, value)) {
-		return;
-	}
-	if (loption == "auto_detect") {
-		auto_detect = ParseBoolean(value, loption);
-	} else if (loption == "sample_size") {
-		const auto sample_size_option = ParseInteger(value, loption);
-		if (sample_size_option < 1 && sample_size_option != -1) {
-			throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
-		}
-		if (sample_size_option == -1) {
-			// If -1, we basically read the whole thing
-			sample_size_chunks = NumericLimits<idx_t>().Maximum();
-		} else {
-			sample_size_chunks = NumericCast<idx_t>(sample_size_option / STANDARD_VECTOR_SIZE);
-			if (sample_size_option % STANDARD_VECTOR_SIZE != 0) {
-				sample_size_chunks++;
-			}
-		}
-
-	} else if (loption == "skip") {
-		SetSkipRows(ParseInteger(value, loption));
-	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
-		auto line_size = ParseInteger(value, loption);
-		if (line_size < 0) {
-			throw BinderException("Invalid value for MAX_LINE_SIZE parameter: it cannot be smaller than 0");
-		}
-		maximum_line_size.Set(NumericCast<idx_t>(line_size));
-	} else if (loption == "date_format" || loption == "dateformat") {
-		string format = ParseString(value, loption);
-		SetDateFormat(LogicalTypeId::DATE, format, true);
-	} else if (loption == "timestamp_format" || loption == "timestampformat") {
-		string format = ParseString(value, loption);
-		SetDateFormat(LogicalTypeId::TIMESTAMP, format, true);
-	} else if (loption == "ignore_errors") {
-		ignore_errors.Set(ParseBoolean(value, loption));
-	} else if (loption == "buffer_size") {
-		buffer_size_option.Set(NumericCast<idx_t>(ParseInteger(value, loption)));
-		if (buffer_size_option == 0) {
-			throw InvalidInputException("Buffer Size option must be higher than 0");
-		}
-	} else if (loption == "decimal_separator") {
-		decimal_separator = ParseString(value, loption);
-		if (decimal_separator != "." && decimal_separator != ",") {
-			throw BinderException("Unsupported parameter for DECIMAL_SEPARATOR: should be '.' or ','");
-		}
-	} else if (loption == "null_padding") {
-		null_padding = ParseBoolean(value, loption);
-	} else if (loption == "parallel") {
-		parallel = ParseBoolean(value, loption);
-	} else if (loption == "allow_quoted_nulls") {
-		allow_quoted_nulls = ParseBoolean(value, loption);
-	} else if (loption == "store_rejects") {
-		store_rejects.Set(ParseBoolean(value, loption));
-	} else if (loption == "force_not_null") {
-		if (!expected_names.empty()) {
-			force_not_null = ParseColumnList(value, expected_names, loption);
-		} else {
-			if (value.IsNull()) {
-				throw BinderException("Invalid value for 'force_not_null' paramenter");
-			}
-			// Get the list of columns to use as a recovery key
-			auto &children = ListValue::GetChildren(value);
-			for (auto &child : children) {
-				auto col_name = child.GetValue<string>();
-				force_not_null_names.insert(col_name);
-			}
-		}
-
-	} else if (loption == "rejects_table") {
-		// skip, handled in SetRejectsOptions
-		auto table_name = ParseString(value, loption);
-		if (table_name.empty()) {
-			throw BinderException("REJECTS_TABLE option cannot be empty");
-		}
-		rejects_table_name.Set(table_name);
-	} else if (loption == "rejects_scan") {
-		// skip, handled in SetRejectsOptions
-		auto table_name = ParseString(value, loption);
-		if (table_name.empty()) {
-			throw BinderException("rejects_scan option cannot be empty");
-		}
-		rejects_scan_name.Set(table_name);
-	} else if (loption == "rejects_limit") {
-		auto limit = ParseInteger(value, loption);
-		if (limit < 0) {
-			throw BinderException("Unsupported parameter for REJECTS_LIMIT: cannot be negative");
-		}
-		rejects_limit = NumericCast<idx_t>(limit);
-	} else if (loption == "encoding") {
-		encoding = ParseString(value, loption);
-	} else {
-		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
-	}
-}
-
-void CSVReaderOptions::SetWriteOption(const string &loption, const Value &value) {
-	if (loption == "new_line") {
-		// Steal this from SetBaseOption so we can write different newlines (e.g., format JSON ARRAY)
-		write_newline = ParseString(value, loption);
-		return;
-	}
-
-	if (SetBaseOption(loption, value, true)) {
-		return;
-	}
-
-	if (loption == "force_quote") {
-		force_quote = ParseColumnList(value, name_list, loption);
-	} else if (loption == "date_format" || loption == "dateformat") {
-		string format = ParseString(value, loption);
-		SetDateFormat(LogicalTypeId::DATE, format, false);
-	} else if (loption == "timestamp_format" || loption == "timestampformat") {
-		string format = ParseString(value, loption);
-		if (StringUtil::Lower(format) == "iso") {
-			format = "%Y-%m-%dT%H:%M:%S.%fZ";
-		}
-		SetDateFormat(LogicalTypeId::TIMESTAMP, format, false);
-		SetDateFormat(LogicalTypeId::TIMESTAMP_TZ, format, false);
-	} else if (loption == "prefix") {
-		prefix = ParseString(value, loption);
-	} else if (loption == "suffix") {
-		suffix = ParseString(value, loption);
-	} else {
-		throw BinderException("Unrecognized option CSV writer \"%s\"", loption);
-	}
-}
-
-bool CSVReaderOptions::SetBaseOption(const string &loption, const Value &value, bool write_option) {
-	// Make sure this function was only called after the option was turned into lowercase
-	D_ASSERT(!std::any_of(loption.begin(), loption.end(), ::isupper));
-
-	if (StringUtil::StartsWith(loption, "delim") || StringUtil::StartsWith(loption, "sep")) {
-		SetDelimiter(ParseString(value, loption));
-	} else if (loption == "quote") {
-		SetQuote(ParseString(value, loption));
-	} else if (loption == "comment") {
-		SetComment(ParseString(value, loption));
-	} else if (loption == "new_line") {
-		SetNewline(ParseString(value, loption));
-	} else if (loption == "escape") {
-		SetEscape(ParseString(value, loption));
-	} else if (loption == "header") {
-		SetHeader(ParseBoolean(value, loption));
-	} else if (loption == "nullstr" || loption == "null") {
-		auto &child_type = value.type();
-		null_str.clear();
-		if (child_type.id() != LogicalTypeId::LIST && child_type.id() != LogicalTypeId::VARCHAR) {
-			throw BinderException("CSV Reader function option %s requires a string or a list as input", loption);
-		}
-		if (!null_str.empty()) {
-			throw BinderException("CSV Reader function option nullstr can only be supplied once");
-		}
-		if (child_type.id() == LogicalTypeId::LIST) {
-			auto &list_child = ListType::GetChildType(child_type);
-			const vector<Value> *children = nullptr;
-			if (list_child.id() == LogicalTypeId::LIST) {
-				// This can happen if it comes from a copy FROM/TO
-				auto &list_grandchild = ListType::GetChildType(list_child);
-				auto &children_ref = ListValue::GetChildren(value);
-				if (list_grandchild.id() != LogicalTypeId::VARCHAR || children_ref.size() != 1) {
-					throw BinderException("CSV Reader function option %s requires a non-empty list of possible null "
-					                      "strings (varchar) as input",
-					                      loption);
-				}
-				children = &ListValue::GetChildren(children_ref.back());
-			} else if (list_child.id() != LogicalTypeId::VARCHAR) {
-				throw BinderException("CSV Reader function option %s requires a non-empty list of possible null "
-				                      "strings (varchar) as input",
-				                      loption);
-			}
-			if (!children) {
-				children = &ListValue::GetChildren(value);
-			}
-			for (auto &child : *children) {
-				if (child.IsNull()) {
-					throw BinderException(
-					    "CSV Reader function option %s does not accept NULL values as a valid nullstr option", loption);
-				}
-				null_str.push_back(StringValue::Get(child));
-			}
-		} else {
-			null_str.push_back(StringValue::Get(ParseString(value, loption)));
-		}
-		if (null_str.size() > 1 && write_option) {
-			throw BinderException("CSV Writer function option %s only accepts one nullstr value.", loption);
-		}
-
-	} else if (loption == "compression") {
-		SetCompression(ParseString(value, loption));
-	} else if (loption == "rfc_4180") {
-		SetRFC4180(ParseBoolean(value, loption));
-	} else {
-		// unrecognized option in base CSV
-		return false;
-	}
-	return true;
-}
-
-template <class T>
-string FormatOptionLine(const string &name, const CSVOption<T> &option) {
-	return name + " = " + option.FormatValue() + " " + option.FormatSet() + "\n  ";
-}
-
-bool CSVReaderOptions::WasTypeManuallySet(idx_t i) const {
-	if (i >= was_type_manually_set.size()) {
-		return false;
-	}
-	return was_type_manually_set[i];
-}
-
-string CSVReaderOptions::ToString(const string &current_file_path) const {
-	auto &delimiter = dialect_options.state_machine_options.delimiter;
-	auto &quote = dialect_options.state_machine_options.quote;
-	auto &escape = dialect_options.state_machine_options.escape;
-	auto &comment = dialect_options.state_machine_options.comment;
-	auto &new_line = dialect_options.state_machine_options.new_line;
-	auto &rfc_4180 = dialect_options.state_machine_options.rfc_4180;
-	auto &skip_rows = dialect_options.skip_rows;
-
-	auto &header = dialect_options.header;
-	string error = "  file = " + current_file_path + "\n  ";
-	// Let's first print options that can either be set by the user or by the sniffer
-	// delimiter
-	error += FormatOptionLine("delimiter", delimiter);
-	// quote
-	error += FormatOptionLine("quote", quote);
-	// escape
-	error += FormatOptionLine("escape", escape);
-	// newline
-	error += FormatOptionLine("new_line", new_line);
-	// has_header
-	error += FormatOptionLine("header", header);
-	// skip_rows
-	error += FormatOptionLine("skip_rows", skip_rows);
-	// comment
-	error += FormatOptionLine("comment", comment);
-	// rfc_4180
-	error += FormatOptionLine("rfc_4180", rfc_4180);
-	// date format
-	error += FormatOptionLine("date_format", dialect_options.date_format.at(LogicalType::DATE));
-	// timestamp format
-	error += FormatOptionLine("timestamp_format", dialect_options.date_format.at(LogicalType::TIMESTAMP));
-
-	// Now we do options that can only be set by the user, that might hold some general significance
-	// null padding
-	error += "null_padding = " + std::to_string(null_padding) + "\n  ";
-	// sample_size
-	error += "sample_size = " + std::to_string(sample_size_chunks * STANDARD_VECTOR_SIZE) + "\n  ";
-	// ignore_errors
-	error += "ignore_errors = " + ignore_errors.FormatValue() + "\n  ";
-	// all_varchar
-	error += "all_varchar = " + std::to_string(all_varchar) + "\n";
-
-	// Add information regarding sniffer mismatches (if any)
-	error += sniffer_user_mismatch_error;
-	return error;
-}
-
-static Value StringVectorToValue(const vector<string> &vec) {
-	vector<Value> content;
-	content.reserve(vec.size());
-	for (auto &item : vec) {
-		content.push_back(Value(item));
-	}
-	return Value::LIST(LogicalType::VARCHAR, std::move(content));
-}
-
-static uint8_t GetCandidateSpecificity(const LogicalType &candidate_type) {
-	//! Const ht with accepted auto_types and their weights in specificity
-	const duckdb::unordered_map<uint8_t, uint8_t> auto_type_candidates_specificity {
-	    {static_cast<uint8_t>(LogicalTypeId::VARCHAR), 0},   {static_cast<uint8_t>(LogicalTypeId::DOUBLE), 1},
-	    {static_cast<uint8_t>(LogicalTypeId::FLOAT), 2},     {static_cast<uint8_t>(LogicalTypeId::DECIMAL), 3},
-	    {static_cast<uint8_t>(LogicalTypeId::BIGINT), 4},    {static_cast<uint8_t>(LogicalTypeId::INTEGER), 5},
-	    {static_cast<uint8_t>(LogicalTypeId::SMALLINT), 6},  {static_cast<uint8_t>(LogicalTypeId::TINYINT), 7},
-	    {static_cast<uint8_t>(LogicalTypeId::TIMESTAMP), 8}, {static_cast<uint8_t>(LogicalTypeId::DATE), 9},
-	    {static_cast<uint8_t>(LogicalTypeId::TIME), 10},     {static_cast<uint8_t>(LogicalTypeId::BOOLEAN), 11},
-	    {static_cast<uint8_t>(LogicalTypeId::SQLNULL), 12}};
-
-	auto id = static_cast<uint8_t>(candidate_type.id());
-	auto it = auto_type_candidates_specificity.find(id);
-	if (it == auto_type_candidates_specificity.end()) {
-		throw BinderException("Auto Type Candidate of type %s is not accepted as a valid input",
-		                      EnumUtil::ToString(candidate_type.id()));
-	}
-	return it->second;
-}
-bool StoreUserDefinedParameter(const string &option) {
-	if (option == "column_types" || option == "types" || option == "dtypes" || option == "auto_detect" ||
-	    option == "auto_type_candidates" || option == "columns" || option == "names") {
-		// We don't store options related to types, names and auto-detection since these are either irrelevant to our
-		// prompt or are covered by the columns option.
-		return false;
-	}
-	return true;
-}
-
-void CSVReaderOptions::Verify() {
-	if (rejects_table_name.IsSetByUser() && !store_rejects.GetValue() && store_rejects.IsSetByUser()) {
-		throw BinderException("REJECTS_TABLE option is only supported when store_rejects is not manually set to false");
-	}
-	if (rejects_scan_name.IsSetByUser() && !store_rejects.GetValue() && store_rejects.IsSetByUser()) {
-		throw BinderException("REJECTS_SCAN option is only supported when store_rejects is not manually set to false");
-	}
-	if (rejects_scan_name.IsSetByUser() || rejects_table_name.IsSetByUser()) {
-		// Ensure we set store_rejects to true automagically
-		store_rejects.Set(true, false);
-	}
-	// Validate rejects_table options
-	if (store_rejects.GetValue()) {
-		if (!ignore_errors.GetValue() && ignore_errors.IsSetByUser()) {
-			throw BinderException(
-			    "STORE_REJECTS option is only supported when IGNORE_ERRORS is not manually set to false");
-		}
-		// Ensure we set ignore errors to true automagically
-		ignore_errors.Set(true, false);
-		if (file_options.union_by_name) {
-			throw BinderException("REJECTS_TABLE option is not supported when UNION_BY_NAME is set to true");
-		}
-	}
-	if (rejects_limit != 0 && !store_rejects.GetValue()) {
-		throw BinderException("REJECTS_LIMIT option is only supported when REJECTS_TABLE is set to a table name");
-	}
-	// Validate CSV Buffer and max_line_size do not conflict.
-	if (buffer_size_option.IsSetByUser() && maximum_line_size.IsSetByUser()) {
-		if (buffer_size_option.GetValue() < maximum_line_size.GetValue()) {
-			throw BinderException("BUFFER_SIZE option was set to %d, while MAX_LINE_SIZE was set to %d. BUFFER_SIZE "
-			                      "must have always be set to value bigger than MAX_LINE_SIZE",
-			                      buffer_size_option.GetValue(), maximum_line_size.GetValue());
-		}
-	} else if (maximum_line_size.IsSetByUser() && maximum_line_size.GetValue() > max_line_size_default) {
-		// If the max line size is set by the user and bigger than we have by default, we make it part of our buffer
-		// size decision.
-		buffer_size_option.Set(CSVBuffer::ROWS_PER_BUFFER * maximum_line_size.GetValue(), false);
-	}
-}
-
-bool GetBooleanValue(const pair<const string, Value> &option) {
-	if (option.second.IsNull()) {
-		throw BinderException("read_csv %s cannot be NULL", option.first);
-	}
-	return BooleanValue::Get(option.second);
-}
-
-void CSVReaderOptions::FromNamedParameters(const named_parameter_map_t &in, ClientContext &context) {
-	map<string, string> ordered_user_defined_parameters;
-	for (auto &kv : in) {
-		if (MultiFileReader().ParseOption(kv.first, kv.second, file_options, context)) {
-			continue;
-		}
-		auto loption = StringUtil::Lower(kv.first);
-		// skip variables that are specific to auto-detection
-		if (StoreUserDefinedParameter(loption)) {
-			ordered_user_defined_parameters[loption] = kv.second.ToSQLString();
-		}
-		if (loption == "columns") {
-			if (!name_list.empty()) {
-				throw BinderException("read_csv column_names/names can only be supplied once");
-			}
-			columns_set = true;
-			auto &child_type = kv.second.type();
-			if (child_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException("read_csv columns requires a struct as input");
-			}
-			auto &struct_children = StructValue::GetChildren(kv.second);
-			D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
-			for (idx_t i = 0; i < struct_children.size(); i++) {
-				auto &name = StructType::GetChildName(child_type, i);
-				auto &val = struct_children[i];
-				name_list.push_back(name);
-				if (val.type().id() != LogicalTypeId::VARCHAR) {
-					throw BinderException("read_csv requires a type specification as string");
-				}
-				sql_types_per_column[name] = i;
-				sql_type_list.emplace_back(TransformStringToLogicalType(StringValue::Get(val), context));
-			}
-			if (name_list.empty()) {
-				throw BinderException("read_csv requires at least a single column as input!");
-			}
-		} else if (loption == "auto_type_candidates") {
-			auto_type_candidates.clear();
-			map<uint8_t, LogicalType> candidate_types;
-			// We always have the extremes of Null and Varchar, so we can default to varchar if the
-			// sniffer is not able to confidently detect that column type
-			candidate_types[GetCandidateSpecificity(LogicalType::VARCHAR)] = LogicalType::VARCHAR;
-			candidate_types[GetCandidateSpecificity(LogicalType::SQLNULL)] = LogicalType::SQLNULL;
-
-			auto &child_type = kv.second.type();
-			if (child_type.id() != LogicalTypeId::LIST) {
-				throw BinderException("read_csv auto_types requires a list as input");
-			}
-			auto &list_children = ListValue::GetChildren(kv.second);
-			if (list_children.empty()) {
-				throw BinderException("auto_type_candidates requires at least one type");
-			}
-			for (auto &child : list_children) {
-				if (child.type().id() != LogicalTypeId::VARCHAR) {
-					throw BinderException("auto_type_candidates requires a type specification as string");
-				}
-				auto candidate_type = TransformStringToLogicalType(StringValue::Get(child), context);
-				candidate_types[GetCandidateSpecificity(candidate_type)] = candidate_type;
-			}
-			for (auto &candidate_type : candidate_types) {
-				auto_type_candidates.emplace_back(candidate_type.second);
-			}
-		} else if (loption == "column_names" || loption == "names") {
-			unordered_set<string> column_names;
-			if (!name_list.empty()) {
-				throw BinderException("read_csv column_names/names can only be supplied once");
-			}
-			if (kv.second.IsNull()) {
-				throw BinderException("read_csv %s cannot be NULL", kv.first);
-			}
-			auto &children = ListValue::GetChildren(kv.second);
-			for (auto &child : children) {
-				name_list.push_back(StringValue::Get(child));
-			}
-			for (auto &name : name_list) {
-				bool empty = true;
-				for (auto &c : name) {
-					if (!StringUtil::CharacterIsSpace(c)) {
-						empty = false;
-						break;
-					}
-				}
-				if (empty) {
-					throw BinderException("read_csv %s cannot have empty (or all whitespace) value", kv.first);
-				}
-				if (column_names.find(name) != column_names.end()) {
-					throw BinderException("read_csv %s must have unique values. \"%s\" is repeated.", kv.first, name);
-				}
-				column_names.insert(name);
-			}
-		} else if (loption == "column_types" || loption == "types" || loption == "dtypes") {
-			auto &child_type = kv.second.type();
-			if (child_type.id() != LogicalTypeId::STRUCT && child_type.id() != LogicalTypeId::LIST) {
-				throw BinderException("read_csv %s requires a struct or list as input", kv.first);
-			}
-			if (!sql_type_list.empty()) {
-				throw BinderException("read_csv column_types/types/dtypes can only be supplied once");
-			}
-			vector<string> sql_type_names;
-			if (child_type.id() == LogicalTypeId::STRUCT) {
-				auto &struct_children = StructValue::GetChildren(kv.second);
-				D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
-				for (idx_t i = 0; i < struct_children.size(); i++) {
-					auto &name = StructType::GetChildName(child_type, i);
-					auto &val = struct_children[i];
-					if (val.type().id() != LogicalTypeId::VARCHAR) {
-						throw BinderException("read_csv %s requires a type specification as string", kv.first);
-					}
-					sql_type_names.push_back(StringValue::Get(val));
-					sql_types_per_column[name] = i;
-				}
-			} else {
-				auto &list_child = ListType::GetChildType(child_type);
-				if (list_child.id() != LogicalTypeId::VARCHAR) {
-					throw BinderException("read_csv %s requires a list of types (varchar) as input", kv.first);
-				}
-				auto &children = ListValue::GetChildren(kv.second);
-				for (auto &child : children) {
-					sql_type_names.push_back(StringValue::Get(child));
-				}
-			}
-			sql_type_list.reserve(sql_type_names.size());
-			for (auto &sql_type : sql_type_names) {
-				auto def_type = TransformStringToLogicalType(sql_type, context);
-				if (def_type.id() == LogicalTypeId::USER) {
-					throw BinderException("Unrecognized type \"%s\" for read_csv %s definition", sql_type, kv.first);
-				}
-				sql_type_list.push_back(std::move(def_type));
-			}
-		} else if (loption == "all_varchar") {
-			all_varchar = GetBooleanValue(kv);
-		} else if (loption == "normalize_names") {
-			normalize_names = GetBooleanValue(kv);
-		} else {
-			SetReadOption(loption, kv.second, name_list);
-		}
-	}
-	for (auto &udf_parameter : ordered_user_defined_parameters) {
-		user_defined_parameters += udf_parameter.first + "=" + udf_parameter.second + ", ";
-	}
-	if (user_defined_parameters.size() >= 2) {
-		user_defined_parameters.erase(user_defined_parameters.size() - 2);
-	}
-}
-//! This function is used to remember options set by the sniffer, for use in ReadCSVRelation
-void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) const {
-	auto &delimiter = dialect_options.state_machine_options.delimiter;
-	auto &quote = dialect_options.state_machine_options.quote;
-	auto &escape = dialect_options.state_machine_options.escape;
-	auto &comment = dialect_options.state_machine_options.comment;
-	auto &rfc_4180 = dialect_options.state_machine_options.rfc_4180;
-	auto &header = dialect_options.header;
-	if (delimiter.IsSetByUser()) {
-		named_params["delim"] = Value(GetDelimiter());
-	}
-	if (dialect_options.state_machine_options.new_line.IsSetByUser()) {
-		named_params["new_line"] = Value(GetNewline());
-	}
-	if (quote.IsSetByUser()) {
-		named_params["quote"] = Value(GetQuote());
-	}
-	if (escape.IsSetByUser()) {
-		named_params["escape"] = Value(GetEscape());
-	}
-	if (comment.IsSetByUser()) {
-		named_params["comment"] = Value(GetComment());
-	}
-	if (header.IsSetByUser()) {
-		named_params["header"] = Value(GetHeader());
-	}
-	if (rfc_4180.IsSetByUser()) {
-		named_params["rfc_4180"] = Value(GetRFC4180());
-	}
-	named_params["max_line_size"] = Value::BIGINT(NumericCast<int64_t>(maximum_line_size.GetValue()));
-	if (dialect_options.skip_rows.IsSetByUser()) {
-		named_params["skip"] = Value::UBIGINT(GetSkipRows());
-	}
-	named_params["null_padding"] = Value::BOOLEAN(null_padding);
-	named_params["parallel"] = Value::BOOLEAN(parallel);
-	if (!dialect_options.date_format.at(LogicalType::DATE).GetValue().format_specifier.empty()) {
-		named_params["dateformat"] =
-		    Value(dialect_options.date_format.at(LogicalType::DATE).GetValue().format_specifier);
-	}
-	if (!dialect_options.date_format.at(LogicalType::TIMESTAMP).GetValue().format_specifier.empty()) {
-		named_params["timestampformat"] =
-		    Value(dialect_options.date_format.at(LogicalType::TIMESTAMP).GetValue().format_specifier);
-	}
-
-	named_params["normalize_names"] = Value::BOOLEAN(normalize_names);
-	if (!name_list.empty() && !named_params.count("columns") && !named_params.count("column_names") &&
-	    !named_params.count("names")) {
-		named_params["column_names"] = StringVectorToValue(name_list);
-	}
-	named_params["all_varchar"] = Value::BOOLEAN(all_varchar);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_validator.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_validator.cpp
deleted file mode 100644
index 1b8d3f348..000000000
--- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_validator.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/execution/operator/csv_scanner/csv_validator.hpp"
-#include <sstream>
-
-namespace duckdb {
-
-void ThreadLines::Insert(idx_t thread_idx, ValidatorLine line_info) {
-	D_ASSERT(thread_lines.find(thread_idx) == thread_lines.end());
-	thread_lines.insert({thread_idx, line_info});
-}
-
-string ThreadLines::Print() const {
-	string result;
-	for (auto &line : thread_lines) {
-		result += "{start_pos: " + std::to_string(line.second.start_pos) +
-		          ", end_pos: " + std::to_string(line.second.end_pos) + "}";
-	}
-	return result;
-}
-
-void ThreadLines::Verify() const {
-	bool initialized = false;
-	idx_t last_end_pos = 0;
-	for (auto &line_info : thread_lines) {
-		if (!initialized) {
-			// First run, we just set the initialized to true
-			initialized = true;
-		} else {
-			if (line_info.second.start_pos == line_info.second.end_pos) {
-				last_end_pos = line_info.second.end_pos;
-				continue;
-			}
-			if (last_end_pos + error_margin < line_info.second.start_pos ||
-			    line_info.second.start_pos < last_end_pos - error_margin) {
-				std::ostringstream error;
-				error << "The Parallel CSV Reader currently does not support a full read on this file." << '\n';
-				error << "To correctly parse this file, please run with the single threaded error (i.e., parallel = "
-				         "false)"
-				      << '\n';
-				throw NotImplementedException(error.str());
-			}
-		}
-		last_end_pos = line_info.second.end_pos;
-	}
-}
-
-void CSVValidator::Insert(idx_t file_idx, idx_t thread_idx, ValidatorLine line_info) {
-	if (per_file_thread_lines.size() <= file_idx) {
-		per_file_thread_lines.resize(file_idx + 1);
-	}
-	per_file_thread_lines[file_idx].Insert(thread_idx, line_info);
-}
-
-void CSVValidator::Verify() const {
-	for (auto &file : per_file_thread_lines) {
-		file.Verify();
-	}
-}
-
-string CSVValidator::Print(idx_t file_idx) const {
-	return per_file_thread_lines[file_idx].Print();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/filter/physical_filter.cpp b/src/duckdb/src/execution/operator/filter/physical_filter.cpp
deleted file mode 100644
index e2a25d9fd..000000000
--- a/src/duckdb/src/execution/operator/filter/physical_filter.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "duckdb/execution/operator/filter/physical_filter.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-namespace duckdb {
-
-PhysicalFilter::PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                               idx_t estimated_cardinality)
-    : CachingPhysicalOperator(PhysicalOperatorType::FILTER, std::move(types), estimated_cardinality) {
-	D_ASSERT(select_list.size() > 0);
-	if (select_list.size() > 1) {
-		// create a big AND out of the expressions
-		auto conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-		for (auto &expr : select_list) {
-			conjunction->children.push_back(std::move(expr));
-		}
-		expression = std::move(conjunction);
-	} else {
-		expression = std::move(select_list[0]);
-	}
-}
-
-class FilterState : public CachingOperatorState {
-public:
-	explicit FilterState(ExecutionContext &context, Expression &expr)
-	    : executor(context.client, expr), sel(STANDARD_VECTOR_SIZE) {
-	}
-
-	ExpressionExecutor executor;
-	SelectionVector sel;
-
-public:
-	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op);
-	}
-};
-
-unique_ptr<OperatorState> PhysicalFilter::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<FilterState>(context, *expression);
-}
-
-OperatorResultType PhysicalFilter::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = state_p.Cast<FilterState>();
-	idx_t result_count = state.executor.SelectExpression(input, state.sel);
-	if (result_count == input.size()) {
-		// nothing was filtered: skip adding any selection vectors
-		chunk.Reference(input);
-	} else {
-		chunk.Slice(input, state.sel, result_count);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalFilter::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["__expression__"] = expression->GetName();
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp b/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp
deleted file mode 100644
index c489124ee..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_batch_collector.hpp"
-
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-
-namespace duckdb {
-
-PhysicalBatchCollector::PhysicalBatchCollector(PreparedStatementData &data) : PhysicalResultCollector(data) {
-}
-
-SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-	auto &state = input.local_state.Cast<BatchCollectorLocalState>();
-	state.data.Append(chunk, state.partition_info.batch_index.GetIndex());
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalBatchCollector::Combine(ExecutionContext &context,
-                                                      OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<BatchCollectorGlobalState>();
-	auto &state = input.local_state.Cast<BatchCollectorLocalState>();
-
-	lock_guard<mutex> lock(gstate.glock);
-	gstate.data.Merge(state.data);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<BatchCollectorGlobalState>();
-	auto collection = gstate.data.FetchCollection();
-	D_ASSERT(collection);
-	auto result = make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),
-	                                                 context.GetClientProperties());
-	gstate.result = std::move(result);
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<LocalSinkState> PhysicalBatchCollector::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<BatchCollectorLocalState>(context.client, *this);
-}
-
-unique_ptr<GlobalSinkState> PhysicalBatchCollector::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<BatchCollectorGlobalState>(context, *this);
-}
-
-unique_ptr<QueryResult> PhysicalBatchCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = state.Cast<BatchCollectorGlobalState>();
-	D_ASSERT(gstate.result);
-	return std::move(gstate.result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_buffered_batch_collector.cpp b/src/duckdb/src/execution/operator/helper/physical_buffered_batch_collector.cpp
deleted file mode 100644
index f881da2a9..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_buffered_batch_collector.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp"
-
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/main/buffered_data/buffered_data.hpp"
-#include "duckdb/main/buffered_data/batched_buffered_data.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-
-namespace duckdb {
-
-PhysicalBufferedBatchCollector::PhysicalBufferedBatchCollector(PreparedStatementData &data)
-    : PhysicalResultCollector(data) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class BufferedBatchCollectorGlobalState : public GlobalSinkState {
-public:
-	weak_ptr<ClientContext> context;
-	shared_ptr<BufferedData> buffered_data;
-};
-
-BufferedBatchCollectorLocalState::BufferedBatchCollectorLocalState() {
-}
-
-SinkResultType PhysicalBufferedBatchCollector::Sink(ExecutionContext &context, DataChunk &chunk,
-                                                    OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<BufferedBatchCollectorGlobalState>();
-	auto &lstate = input.local_state.Cast<BufferedBatchCollectorLocalState>();
-
-	lstate.current_batch = lstate.partition_info.batch_index.GetIndex();
-	auto batch = lstate.partition_info.batch_index.GetIndex();
-	auto min_batch_index = lstate.partition_info.min_batch_index.GetIndex();
-
-	auto &buffered_data = gstate.buffered_data->Cast<BatchedBufferedData>();
-	buffered_data.UpdateMinBatchIndex(min_batch_index);
-
-	if (buffered_data.ShouldBlockBatch(batch)) {
-		auto callback_state = input.interrupt_state;
-		buffered_data.BlockSink(callback_state, batch);
-		return SinkResultType::BLOCKED;
-	}
-
-	// FIXME: if we want to make this more accurate, we should grab a reservation on the buffer space
-	// while we're unlocked some other thread could also append, causing us to potentially cross our buffer size
-
-	buffered_data.Append(chunk, batch);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkNextBatchType PhysicalBufferedBatchCollector::NextBatch(ExecutionContext &context,
-                                                            OperatorSinkNextBatchInput &input) const {
-
-	auto &gstate = input.global_state.Cast<BufferedBatchCollectorGlobalState>();
-	auto &lstate = input.local_state.Cast<BufferedBatchCollectorLocalState>();
-
-	auto batch = lstate.current_batch;
-	auto min_batch_index = lstate.partition_info.min_batch_index.GetIndex();
-	auto new_index = lstate.partition_info.batch_index.GetIndex();
-
-	auto &buffered_data = gstate.buffered_data->Cast<BatchedBufferedData>();
-	buffered_data.CompleteBatch(batch);
-	lstate.current_batch = new_index;
-	// FIXME: this can move from the buffer to the read queue, increasing the 'read_queue_byte_count'
-	// We might want to block here if 'read_queue_byte_count' has already reached the ReadQueueCapacity()
-	// So we don't completely disregard the 'streaming_buffer_size' that was set
-	buffered_data.UpdateMinBatchIndex(min_batch_index);
-	return SinkNextBatchType::READY;
-}
-
-SinkCombineResultType PhysicalBufferedBatchCollector::Combine(ExecutionContext &context,
-                                                              OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<BufferedBatchCollectorGlobalState>();
-	auto &lstate = input.local_state.Cast<BufferedBatchCollectorLocalState>();
-
-	auto min_batch_index = lstate.partition_info.min_batch_index.GetIndex();
-	auto &buffered_data = gstate.buffered_data->Cast<BatchedBufferedData>();
-
-	// FIXME: this can move from the buffer to the read queue, increasing the 'read_queue_byte_count'
-	// We might want to block here if 'read_queue_byte_count' has already reached the ReadQueueCapacity()
-	// So we don't completely disregard the 'streaming_buffer_size' that was set
-	buffered_data.UpdateMinBatchIndex(min_batch_index);
-	return SinkCombineResultType::FINISHED;
-}
-
-unique_ptr<LocalSinkState> PhysicalBufferedBatchCollector::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<BufferedBatchCollectorLocalState>();
-	return std::move(state);
-}
-
-unique_ptr<GlobalSinkState> PhysicalBufferedBatchCollector::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<BufferedBatchCollectorGlobalState>();
-	state->context = context.shared_from_this();
-	state->buffered_data = make_shared_ptr<BatchedBufferedData>(state->context);
-	return std::move(state);
-}
-
-unique_ptr<QueryResult> PhysicalBufferedBatchCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = state.Cast<BufferedBatchCollectorGlobalState>();
-	auto cc = gstate.context.lock();
-	auto result = make_uniq<StreamQueryResult>(statement_type, properties, types, names, cc->GetClientProperties(),
-	                                           gstate.buffered_data);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_buffered_collector.cpp b/src/duckdb/src/execution/operator/helper/physical_buffered_collector.cpp
deleted file mode 100644
index d52b7bc49..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_buffered_collector.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_buffered_collector.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-PhysicalBufferedCollector::PhysicalBufferedCollector(PreparedStatementData &data, bool parallel)
-    : PhysicalResultCollector(data), parallel(parallel) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class BufferedCollectorGlobalState : public GlobalSinkState {
-public:
-	mutex glock;
-	//! This is weak to avoid creating a cyclical reference
-	weak_ptr<ClientContext> context;
-	shared_ptr<BufferedData> buffered_data;
-};
-
-class BufferedCollectorLocalState : public LocalSinkState {};
-
-SinkResultType PhysicalBufferedCollector::Sink(ExecutionContext &context, DataChunk &chunk,
-                                               OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<BufferedCollectorGlobalState>();
-	auto &lstate = input.local_state.Cast<BufferedCollectorLocalState>();
-	(void)lstate;
-
-	lock_guard<mutex> l(gstate.glock);
-	auto &buffered_data = gstate.buffered_data->Cast<SimpleBufferedData>();
-
-	if (buffered_data.BufferIsFull()) {
-		auto callback_state = input.interrupt_state;
-		buffered_data.BlockSink(callback_state);
-		return SinkResultType::BLOCKED;
-	}
-	buffered_data.Append(chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalBufferedCollector::Combine(ExecutionContext &context,
-                                                         OperatorSinkCombineInput &input) const {
-	return SinkCombineResultType::FINISHED;
-}
-
-unique_ptr<GlobalSinkState> PhysicalBufferedCollector::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<BufferedCollectorGlobalState>();
-	state->context = context.shared_from_this();
-	state->buffered_data = make_shared_ptr<SimpleBufferedData>(state->context);
-	return std::move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalBufferedCollector::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<BufferedCollectorLocalState>();
-	return std::move(state);
-}
-
-unique_ptr<QueryResult> PhysicalBufferedCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = state.Cast<BufferedCollectorGlobalState>();
-	lock_guard<mutex> l(gstate.glock);
-	// FIXME: maybe we want to check if the execution was successful before creating the StreamQueryResult ?
-	auto cc = gstate.context.lock();
-	auto result = make_uniq<StreamQueryResult>(statement_type, properties, types, names, cc->GetClientProperties(),
-	                                           gstate.buffered_data);
-	return std::move(result);
-}
-
-bool PhysicalBufferedCollector::ParallelSink() const {
-	return parallel;
-}
-
-bool PhysicalBufferedCollector::SinkOrderDependent() const {
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_create_secret.cpp b/src/duckdb/src/execution/operator/helper/physical_create_secret.cpp
deleted file mode 100644
index 3a1dbe8b6..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_create_secret.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_create_secret.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalCreateSecret::GetData(ExecutionContext &context, DataChunk &chunk,
-                                               OperatorSourceInput &input) const {
-	auto &client = context.client;
-	auto &secret_manager = SecretManager::Get(client);
-
-	secret_manager.CreateSecret(client, info);
-
-	chunk.SetValue(0, 0, true);
-	chunk.SetCardinality(1);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_execute.cpp b/src/duckdb/src/execution/operator/helper/physical_execute.cpp
deleted file mode 100644
index 22cab9be8..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_execute.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_execute.hpp"
-
-#include "duckdb/parallel/meta_pipeline.hpp"
-
-namespace duckdb {
-
-PhysicalExecute::PhysicalExecute(PhysicalOperator &plan)
-    : PhysicalOperator(PhysicalOperatorType::EXECUTE, plan.types, idx_t(-1)), plan(plan) {
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalExecute::GetChildren() const {
-	return {plan};
-}
-
-void PhysicalExecute::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	// EXECUTE statement: build pipeline on child
-	meta_pipeline.Build(plan);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_explain_analyze.cpp b/src/duckdb/src/execution/operator/helper/physical_explain_analyze.cpp
deleted file mode 100644
index 8d2c12811..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_explain_analyze.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_explain_analyze.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/query_profiler.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class ExplainAnalyzeStateGlobalState : public GlobalSinkState {
-public:
-	string analyzed_plan;
-};
-
-SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<ExplainAnalyzeStateGlobalState>();
-	auto &profiler = QueryProfiler::Get(context);
-	gstate.analyzed_plan = profiler.ToString(format);
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<GlobalSinkState> PhysicalExplainAnalyze::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<ExplainAnalyzeStateGlobalState>();
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalExplainAnalyze::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                 OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<ExplainAnalyzeStateGlobalState>();
-
-	chunk.SetValue(0, 0, Value("analyzed_plan"));
-	chunk.SetValue(1, 0, Value(gstate.analyzed_plan));
-	chunk.SetCardinality(1);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_limit.cpp b/src/duckdb/src/execution/operator/helper/physical_limit.cpp
deleted file mode 100644
index 936cd311c..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_limit.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_limit.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/helper/physical_streaming_limit.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-PhysicalLimit::PhysicalLimit(vector<LogicalType> types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p,
-                             idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality),
-      limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class LimitGlobalState : public GlobalSinkState {
-public:
-	explicit LimitGlobalState(ClientContext &context, const PhysicalLimit &op) : data(context, op.types, true) {
-		limit = 0;
-		offset = 0;
-	}
-
-	mutex glock;
-	idx_t limit;
-	idx_t offset;
-	BatchedDataCollection data;
-};
-
-class LimitLocalState : public LocalSinkState {
-public:
-	explicit LimitLocalState(ClientContext &context, const PhysicalLimit &op)
-	    : current_offset(0), data(context, op.types, true) {
-		PhysicalLimit::SetInitialLimits(op.limit_val, op.offset_val, limit, offset);
-	}
-
-	idx_t current_offset;
-	optional_idx limit;
-	optional_idx offset;
-	BatchedDataCollection data;
-};
-
-unique_ptr<GlobalSinkState> PhysicalLimit::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<LimitGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalLimit::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<LimitLocalState>(context.client, *this);
-}
-
-void PhysicalLimit::SetInitialLimits(const BoundLimitNode &limit_val, const BoundLimitNode &offset_val,
-                                     optional_idx &limit, optional_idx &offset) {
-	switch (limit_val.Type()) {
-	case LimitNodeType::CONSTANT_VALUE:
-		limit = limit_val.GetConstantValue();
-		break;
-	case LimitNodeType::UNSET:
-		limit = MAX_LIMIT_VALUE;
-		break;
-	default:
-		break;
-	}
-	switch (offset_val.Type()) {
-	case LimitNodeType::CONSTANT_VALUE:
-		offset = offset_val.GetConstantValue();
-		break;
-	case LimitNodeType::UNSET:
-		offset = 0;
-		break;
-	default:
-		break;
-	}
-}
-
-bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, optional_idx &limit,
-                                  optional_idx &offset, idx_t current_offset, idx_t &max_element,
-                                  const BoundLimitNode &limit_val, const BoundLimitNode &offset_val) {
-	if (!limit.IsValid()) {
-		Value val = GetDelimiter(context, input, limit_val.GetValueExpression());
-		if (!val.IsNull()) {
-			limit = val.GetValue<idx_t>();
-		} else {
-			limit = MAX_LIMIT_VALUE;
-		}
-		if (limit.GetIndex() > MAX_LIMIT_VALUE) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", limit.GetIndex(), MAX_LIMIT_VALUE);
-		}
-	}
-	if (!offset.IsValid()) {
-		Value val = GetDelimiter(context, input, offset_val.GetValueExpression());
-		if (!val.IsNull()) {
-			offset = val.GetValue<idx_t>();
-		} else {
-			offset = 0;
-		}
-		if (offset.GetIndex() > MAX_LIMIT_VALUE) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset.GetIndex(), MAX_LIMIT_VALUE);
-		}
-	}
-	max_element = limit.GetIndex() + offset.GetIndex();
-	if (limit == 0 || current_offset >= max_element) {
-		return false;
-	}
-	return true;
-}
-
-SinkResultType PhysicalLimit::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-
-	D_ASSERT(chunk.size() > 0);
-	auto &state = input.local_state.Cast<LimitLocalState>();
-	auto &limit = state.limit;
-	auto &offset = state.offset;
-
-	idx_t max_element;
-	if (!ComputeOffset(context, chunk, limit, offset, state.current_offset, max_element, limit_val, offset_val)) {
-		return SinkResultType::FINISHED;
-	}
-	auto max_cardinality = max_element - state.current_offset;
-	if (max_cardinality < chunk.size()) {
-		chunk.SetCardinality(max_cardinality);
-	}
-	state.data.Append(chunk, state.partition_info.batch_index.GetIndex());
-	state.current_offset += chunk.size();
-	if (state.current_offset == max_element) {
-		return SinkResultType::FINISHED;
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalLimit::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<LimitGlobalState>();
-	auto &state = input.local_state.Cast<LimitLocalState>();
-
-	lock_guard<mutex> lock(gstate.glock);
-	if (state.limit.IsValid()) {
-		gstate.limit = state.limit.GetIndex();
-	}
-	if (state.offset.IsValid()) {
-		gstate.offset = state.offset.GetIndex();
-	}
-	gstate.data.Merge(state.data);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class LimitSourceState : public GlobalSourceState {
-public:
-	LimitSourceState() {
-		initialized = false;
-		current_offset = 0;
-	}
-
-	bool initialized;
-	idx_t current_offset;
-	BatchedChunkScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalLimit::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<LimitSourceState>();
-}
-
-SourceResultType PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<LimitGlobalState>();
-	auto &state = input.global_state.Cast<LimitSourceState>();
-	while (state.current_offset < gstate.limit + gstate.offset) {
-		if (!state.initialized) {
-			gstate.data.InitializeScan(state.scan_state);
-			state.initialized = true;
-		}
-		gstate.data.Scan(state.scan_state, chunk);
-		if (chunk.size() == 0) {
-			return SourceResultType::FINISHED;
-		}
-		if (HandleOffset(chunk, state.current_offset, gstate.offset, gstate.limit)) {
-			break;
-		}
-	}
-
-	return chunk.size() > 0 ? SourceResultType::HAVE_MORE_OUTPUT : SourceResultType::FINISHED;
-}
-
-bool PhysicalLimit::HandleOffset(DataChunk &input, idx_t &current_offset, idx_t offset, idx_t limit) {
-	idx_t max_element = limit + offset;
-	if (limit == DConstants::INVALID_INDEX) {
-		max_element = DConstants::INVALID_INDEX;
-	}
-	idx_t input_size = input.size();
-	if (current_offset < offset) {
-		// we are not yet at the offset point
-		if (current_offset + input.size() > offset) {
-			// however we will reach it in this chunk
-			// we have to copy part of the chunk with an offset
-			idx_t start_position = offset - current_offset;
-			auto chunk_count = MinValue<idx_t>(limit, input.size() - start_position);
-			SelectionVector sel(STANDARD_VECTOR_SIZE);
-			for (idx_t i = 0; i < chunk_count; i++) {
-				sel.set_index(i, start_position + i);
-			}
-			// set up a slice of the input chunks
-			input.Slice(input, sel, chunk_count);
-		} else {
-			current_offset += input_size;
-			return false;
-		}
-	} else {
-		// have to copy either the entire chunk or part of it
-		idx_t chunk_count;
-		if (current_offset + input.size() >= max_element) {
-			// have to limit the count of the chunk
-			chunk_count = max_element - current_offset;
-		} else {
-			// we copy the entire chunk
-			chunk_count = input.size();
-		}
-		// instead of copying we just change the pointer in the current chunk
-		input.Reference(input);
-		input.SetCardinality(chunk_count);
-	}
-
-	current_offset += input_size;
-	return true;
-}
-
-Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, const Expression &expr) {
-	DataChunk limit_chunk;
-	vector<LogicalType> types {expr.return_type};
-	auto &allocator = Allocator::Get(context.client);
-	limit_chunk.Initialize(allocator, types);
-	ExpressionExecutor limit_executor(context.client, &expr);
-	auto input_size = input.size();
-	input.SetCardinality(1);
-	limit_executor.Execute(input, limit_chunk);
-	input.SetCardinality(input_size);
-	auto limit_value = limit_chunk.GetValue(0, 0);
-	return limit_value;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp b/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp
deleted file mode 100644
index 69794be09..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_limit_percent.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/helper/physical_limit.hpp"
-
-namespace duckdb {
-
-PhysicalLimitPercent::PhysicalLimitPercent(vector<LogicalType> types, BoundLimitNode limit_val_p,
-                                           BoundLimitNode offset_val_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT_PERCENT, std::move(types), estimated_cardinality),
-      limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) {
-	D_ASSERT(limit_val.Type() == LimitNodeType::CONSTANT_PERCENTAGE ||
-	         limit_val.Type() == LimitNodeType::EXPRESSION_PERCENTAGE);
-}
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class LimitPercentGlobalState : public GlobalSinkState {
-public:
-	explicit LimitPercentGlobalState(ClientContext &context, const PhysicalLimitPercent &op)
-	    : current_offset(0), data(context, op.GetTypes()) {
-		switch (op.limit_val.Type()) {
-		case LimitNodeType::CONSTANT_PERCENTAGE:
-			this->limit_percent = op.limit_val.GetConstantPercentage();
-			this->is_limit_set = true;
-			break;
-		case LimitNodeType::EXPRESSION_PERCENTAGE:
-			this->is_limit_set = false;
-			break;
-		default:
-			throw InternalException("Unsupported type for limit value in PhysicalLimitPercent");
-		}
-		switch (op.offset_val.Type()) {
-		case LimitNodeType::CONSTANT_VALUE:
-			this->offset = op.offset_val.GetConstantValue();
-			break;
-		case LimitNodeType::UNSET:
-			this->offset = 0;
-			break;
-		case LimitNodeType::EXPRESSION_VALUE:
-			break;
-		default:
-			throw InternalException("Unsupported type for offset value in PhysicalLimitPercent");
-		}
-	}
-
-	idx_t current_offset;
-	double limit_percent;
-	optional_idx offset;
-	ColumnDataCollection data;
-
-	bool is_limit_set = false;
-};
-
-unique_ptr<GlobalSinkState> PhysicalLimitPercent::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<LimitPercentGlobalState>(context, *this);
-}
-
-SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	D_ASSERT(chunk.size() > 0);
-	auto &state = input.global_state.Cast<LimitPercentGlobalState>();
-	auto &limit_percent = state.limit_percent;
-	auto &offset = state.offset;
-
-	// get the next chunk from the child
-	if (!state.is_limit_set) {
-		Value val = PhysicalLimit::GetDelimiter(context, chunk, limit_val.GetPercentageExpression());
-		if (!val.IsNull()) {
-			limit_percent = val.GetValue<double>();
-		} else {
-			limit_percent = 100.0;
-		}
-		if (limit_percent < 0.0) {
-			throw BinderException("Percentage value(%f) can't be negative", limit_percent);
-		}
-		state.is_limit_set = true;
-	}
-	if (!state.offset.IsValid()) {
-		Value val = PhysicalLimit::GetDelimiter(context, chunk, offset_val.GetValueExpression());
-		if (!val.IsNull()) {
-			offset = val.GetValue<idx_t>();
-		} else {
-			offset = 0;
-		}
-		if (offset.GetIndex() > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset.GetIndex(), 1ULL << 62ULL);
-		}
-	}
-
-	if (!PhysicalLimit::HandleOffset(chunk, state.current_offset, offset.GetIndex(), NumericLimits<idx_t>::Maximum())) {
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	state.data.Append(chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class LimitPercentOperatorState : public GlobalSourceState {
-public:
-	explicit LimitPercentOperatorState(const PhysicalLimitPercent &op) : current_offset(0) {
-		D_ASSERT(op.sink_state);
-		auto &gstate = op.sink_state->Cast<LimitPercentGlobalState>();
-		gstate.data.InitializeScan(scan_state);
-	}
-
-	ColumnDataScanState scan_state;
-	optional_idx limit;
-	idx_t current_offset;
-};
-
-unique_ptr<GlobalSourceState> PhysicalLimitPercent::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<LimitPercentOperatorState>(*this);
-}
-
-SourceResultType PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk,
-                                               OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<LimitPercentGlobalState>();
-	auto &state = input.global_state.Cast<LimitPercentOperatorState>();
-	auto &percent_limit = gstate.limit_percent;
-	auto &offset = gstate.offset;
-	auto &limit = state.limit;
-	auto &current_offset = state.current_offset;
-
-	if (!limit.IsValid()) {
-		if (!gstate.is_limit_set) {
-			// no limit value and we have not set limit_percent
-			// we are running LIMIT % with a subquery over an empty table
-			D_ASSERT(gstate.data.Count() == 0);
-			return SourceResultType::FINISHED;
-		}
-		idx_t count = gstate.data.Count();
-		if (count > 0) {
-			count += offset.GetIndex();
-		}
-		if (Value::IsNan(percent_limit) || percent_limit < 0 || percent_limit > 100) {
-			throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%");
-		}
-		auto limit_percentage = idx_t(percent_limit / 100.0 * double(count));
-		if (limit_percentage > count) {
-			limit = count;
-		} else {
-			limit = idx_t(limit_percentage);
-		}
-		if (limit == 0) {
-			return SourceResultType::FINISHED;
-		}
-	}
-
-	if (current_offset >= limit.GetIndex()) {
-		return SourceResultType::FINISHED;
-	}
-	if (!gstate.data.Scan(state.scan_state, chunk)) {
-		return SourceResultType::FINISHED;
-	}
-
-	PhysicalLimit::HandleOffset(chunk, current_offset, 0, limit.GetIndex());
-
-	return SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_load.cpp b/src/duckdb/src/execution/operator/helper/physical_load.cpp
deleted file mode 100644
index 5f0e7a027..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_load.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_load.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-namespace duckdb {
-
-static void InstallFromRepository(ClientContext &context, const LoadInfo &info) {
-	ExtensionRepository repository;
-	if (!info.repository.empty() && info.repo_is_alias) {
-		auto repository_url = ExtensionRepository::TryGetRepositoryUrl(info.repository);
-		// This has been checked during bind, so it should not fail here
-		if (repository_url.empty()) {
-			throw InternalException("The repository alias failed to resolve");
-		}
-		repository = ExtensionRepository(info.repository, repository_url);
-	} else if (!info.repository.empty()) {
-		repository = ExtensionRepository::GetRepositoryByUrl(info.repository);
-	}
-
-	ExtensionInstallOptions options;
-	options.force_install = info.load_type == LoadType::FORCE_INSTALL;
-	options.throw_on_origin_mismatch = true;
-	options.version = info.version;
-	options.repository = repository;
-
-	ExtensionHelper::InstallExtension(context, info.filename, options);
-}
-
-SourceResultType PhysicalLoad::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	if (info->load_type == LoadType::INSTALL || info->load_type == LoadType::FORCE_INSTALL) {
-		if (info->repository.empty()) {
-			ExtensionInstallOptions options;
-			options.force_install = info->load_type == LoadType::FORCE_INSTALL;
-			options.throw_on_origin_mismatch = true;
-			options.version = info->version;
-			ExtensionHelper::InstallExtension(context.client, info->filename, options);
-		} else {
-			InstallFromRepository(context.client, *info);
-		}
-
-	} else {
-		ExtensionHelper::LoadExternalExtension(context.client, info->filename);
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp b/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp
deleted file mode 100644
index 2492a3a89..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_materialized_collector.hpp"
-
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-PhysicalMaterializedCollector::PhysicalMaterializedCollector(PreparedStatementData &data, bool parallel)
-    : PhysicalResultCollector(data), parallel(parallel) {
-}
-
-SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, DataChunk &chunk,
-                                                   OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<MaterializedCollectorLocalState>();
-	lstate.collection->Append(lstate.append_state, chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalMaterializedCollector::Combine(ExecutionContext &context,
-                                                             OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<MaterializedCollectorGlobalState>();
-	auto &lstate = input.local_state.Cast<MaterializedCollectorLocalState>();
-	if (lstate.collection->Count() == 0) {
-		return SinkCombineResultType::FINISHED;
-	}
-
-	lock_guard<mutex> l(gstate.glock);
-	if (!gstate.collection) {
-		gstate.collection = std::move(lstate.collection);
-	} else {
-		gstate.collection->Combine(*lstate.collection);
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-unique_ptr<GlobalSinkState> PhysicalMaterializedCollector::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<MaterializedCollectorGlobalState>();
-	state->context = context.shared_from_this();
-	return std::move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalMaterializedCollector::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<MaterializedCollectorLocalState>();
-	state->collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
-	state->collection->InitializeAppend(state->append_state);
-	return std::move(state);
-}
-
-unique_ptr<QueryResult> PhysicalMaterializedCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = state.Cast<MaterializedCollectorGlobalState>();
-	if (!gstate.collection) {
-		gstate.collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
-	}
-	auto result = make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(gstate.collection),
-	                                                 gstate.context->GetClientProperties());
-	return std::move(result);
-}
-
-bool PhysicalMaterializedCollector::ParallelSink() const {
-	return parallel;
-}
-
-bool PhysicalMaterializedCollector::SinkOrderDependent() const {
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_pragma.cpp b/src/duckdb/src/execution/operator/helper/physical_pragma.cpp
deleted file mode 100644
index 34a5cb6fb..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_pragma.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_pragma.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalPragma::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &client = context.client;
-	FunctionParameters parameters {info->parameters, info->named_parameters};
-	info->function.function(client, parameters);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_prepare.cpp b/src/duckdb/src/execution/operator/helper/physical_prepare.cpp
deleted file mode 100644
index 784d6ada4..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_prepare.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_prepare.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalPrepare::GetData(ExecutionContext &context, DataChunk &chunk,
-                                          OperatorSourceInput &input) const {
-	auto &client = context.client;
-
-	// store the prepared statement in the context
-	ClientData::Get(client).prepared_statements[name] = prepared;
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_reservoir_sample.cpp b/src/duckdb/src/execution/operator/helper/physical_reservoir_sample.cpp
deleted file mode 100644
index 32785a7ab..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_reservoir_sample.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_reservoir_sample.hpp"
-#include "duckdb/execution/reservoir_sample.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-
-class SampleGlobalSinkState : public GlobalSinkState {
-public:
-	explicit SampleGlobalSinkState(Allocator &allocator, SampleOptions &options) {
-		if (options.is_percentage) {
-			auto percentage = options.sample_size.GetValue<double>();
-			if (percentage == 0) {
-				return;
-			}
-			sample = make_uniq<ReservoirSamplePercentage>(allocator, percentage,
-			                                              static_cast<int64_t>(options.seed.GetIndex()));
-		} else {
-			auto size = NumericCast<idx_t>(options.sample_size.GetValue<int64_t>());
-			if (size == 0) {
-				return;
-			}
-			sample = make_uniq<ReservoirSample>(allocator, size, static_cast<int64_t>(options.seed.GetIndex()));
-		}
-	}
-
-	//! The lock for updating the global aggoregate state
-	//! Also used to update the global sample when percentages are used
-	mutex lock;
-	//! The reservoir sample
-	unique_ptr<BlockingSample> sample;
-};
-
-unique_ptr<GlobalSinkState> PhysicalReservoirSample::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<SampleGlobalSinkState>(Allocator::Get(context), *options);
-}
-
-SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, DataChunk &chunk,
-                                             OperatorSinkInput &input) const {
-	auto &global_state = input.global_state.Cast<SampleGlobalSinkState>();
-	// Percentage only has a global sample.
-	lock_guard<mutex> glock(global_state.lock);
-	if (!global_state.sample) {
-		// always gather full thread percentage
-		auto &allocator = Allocator::Get(context.client);
-		if (options->is_percentage) {
-			double percentage = options->sample_size.GetValue<double>();
-			if (percentage == 0) {
-				return SinkResultType::FINISHED;
-			}
-			global_state.sample = make_uniq<ReservoirSamplePercentage>(allocator, percentage,
-			                                                           static_cast<int64_t>(options->seed.GetIndex()));
-		} else {
-			idx_t num_samples = options->sample_size.GetValue<idx_t>();
-			if (num_samples == 0) {
-				return SinkResultType::FINISHED;
-			}
-			global_state.sample =
-			    make_uniq<ReservoirSample>(allocator, num_samples, static_cast<int64_t>(options->seed.GetIndex()));
-		}
-	}
-	global_state.sample->AddToReservoir(chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalReservoirSample::Combine(ExecutionContext &context,
-                                                       OperatorSinkCombineInput &input) const {
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalReservoirSample::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   OperatorSinkFinalizeInput &input) const {
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalReservoirSample::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                  OperatorSourceInput &input) const {
-	auto &sink = this->sink_state->Cast<SampleGlobalSinkState>();
-	lock_guard<mutex> glock(sink.lock);
-	if (!sink.sample) {
-		return SourceResultType::FINISHED;
-	}
-	auto sample_chunk = sink.sample->GetChunk();
-	if (!sample_chunk) {
-		return SourceResultType::FINISHED;
-	}
-	chunk.Move(*sample_chunk);
-
-	return SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalReservoirSample::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Sample Size"] = options->sample_size.ToString() + (options->is_percentage ? "%" : " rows");
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_reset.cpp b/src/duckdb/src/execution/operator/helper/physical_reset.cpp
deleted file mode 100644
index b6a219a48..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_reset.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_reset.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &config,
-                                           ExtensionOption &extension_option) const {
-	if (extension_option.set_function) {
-		extension_option.set_function(context.client, scope, extension_option.default_value);
-	}
-	if (scope == SetScope::GLOBAL) {
-		config.ResetOption(name);
-	} else {
-		auto &client_config = ClientConfig::GetConfig(context.client);
-		client_config.set_variables[name] = extension_option.default_value;
-	}
-}
-
-SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	if (scope == SetScope::VARIABLE) {
-		auto &client_config = ClientConfig::GetConfig(context.client);
-		client_config.ResetUserVariable(name);
-		return SourceResultType::FINISHED;
-	}
-	auto &config = DBConfig::GetConfig(context.client);
-	config.CheckLock(name);
-	auto option = DBConfig::GetOptionByName(name);
-	if (!option) {
-		// check if this is an extra extension variable
-		auto entry = config.extension_parameters.find(name);
-		if (entry == config.extension_parameters.end()) {
-			Catalog::AutoloadExtensionByConfigName(context.client, name);
-			entry = config.extension_parameters.find(name);
-			D_ASSERT(entry != config.extension_parameters.end());
-		}
-		ResetExtensionVariable(context, config, entry->second);
-		return SourceResultType::FINISHED;
-	}
-
-	// Transform scope
-	SetScope variable_scope = scope;
-	if (variable_scope == SetScope::AUTOMATIC) {
-		if (option->set_local) {
-			variable_scope = SetScope::SESSION;
-		} else {
-			D_ASSERT(option->set_global);
-			variable_scope = SetScope::GLOBAL;
-		}
-	}
-
-	switch (variable_scope) {
-	case SetScope::GLOBAL: {
-		if (!option->set_global) {
-			throw CatalogException("option \"%s\" cannot be reset globally", name);
-		}
-		auto &db = DatabaseInstance::GetDatabase(context.client);
-		config.ResetOption(&db, *option);
-		break;
-	}
-	case SetScope::SESSION:
-		if (!option->reset_local) {
-			throw CatalogException("option \"%s\" cannot be reset locally", name);
-		}
-		option->reset_local(context.client);
-		break;
-	default:
-		throw InternalException("Unsupported SetScope for variable");
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_result_collector.cpp b/src/duckdb/src/execution/operator/helper/physical_result_collector.cpp
deleted file mode 100644
index 5dcb356e7..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_result_collector.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-
-#include "duckdb/execution/operator/helper/physical_batch_collector.hpp"
-#include "duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp"
-#include "duckdb/execution/operator/helper/physical_materialized_collector.hpp"
-#include "duckdb/execution/operator/helper/physical_buffered_collector.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-PhysicalResultCollector::PhysicalResultCollector(PreparedStatementData &data)
-    : PhysicalOperator(PhysicalOperatorType::RESULT_COLLECTOR, {LogicalType::BOOLEAN}, 0),
-      statement_type(data.statement_type), properties(data.properties), plan(*data.plan), names(data.names) {
-	this->types = data.types;
-}
-
-unique_ptr<PhysicalResultCollector> PhysicalResultCollector::GetResultCollector(ClientContext &context,
-                                                                                PreparedStatementData &data) {
-	if (!PhysicalPlanGenerator::PreserveInsertionOrder(context, *data.plan)) {
-		// the plan is not order preserving, so we just use the parallel materialized collector
-		if (data.is_streaming) {
-			return make_uniq_base<PhysicalResultCollector, PhysicalBufferedCollector>(data, true);
-		}
-		return make_uniq_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, true);
-	} else if (!PhysicalPlanGenerator::UseBatchIndex(context, *data.plan)) {
-		// the plan is order preserving, but we cannot use the batch index: use a single-threaded result collector
-		if (data.is_streaming) {
-			return make_uniq_base<PhysicalResultCollector, PhysicalBufferedCollector>(data, false);
-		}
-		return make_uniq_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, false);
-	} else {
-		// we care about maintaining insertion order and the sources all support batch indexes
-		// use a batch collector
-		if (data.is_streaming) {
-			return make_uniq_base<PhysicalResultCollector, PhysicalBufferedBatchCollector>(data);
-		}
-		return make_uniq_base<PhysicalResultCollector, PhysicalBatchCollector>(data);
-	}
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalResultCollector::GetChildren() const {
-	return {plan};
-}
-
-void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	// operator is a sink, build a pipeline
-	sink_state.reset();
-
-	D_ASSERT(children.empty());
-
-	// single operator: the operator becomes the data source of the current pipeline
-	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, *this);
-
-	// we create a new pipeline starting from the child
-	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-	child_meta_pipeline.Build(plan);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_set.cpp b/src/duckdb/src/execution/operator/helper/physical_set.cpp
deleted file mode 100644
index 4a321a52e..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_set.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_set.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &extension_option, const string &name,
-                                       SetScope scope, const Value &value) {
-	auto &config = DBConfig::GetConfig(context);
-	auto &target_type = extension_option.type;
-	Value target_value = value.CastAs(context, target_type);
-	if (extension_option.set_function) {
-		extension_option.set_function(context, scope, target_value);
-	}
-	if (scope == SetScope::GLOBAL) {
-		config.SetOption(name, std::move(target_value));
-	} else {
-		auto &client_config = ClientConfig::GetConfig(context);
-		client_config.set_variables[name] = std::move(target_value);
-	}
-}
-
-SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	auto &config = DBConfig::GetConfig(context.client);
-	// check if we are allowed to change the configuration option
-	config.CheckLock(name);
-	auto option = DBConfig::GetOptionByName(name);
-	if (!option) {
-		// check if this is an extra extension variable
-		auto entry = config.extension_parameters.find(name);
-		if (entry == config.extension_parameters.end()) {
-			Catalog::AutoloadExtensionByConfigName(context.client, name);
-			entry = config.extension_parameters.find(name);
-			D_ASSERT(entry != config.extension_parameters.end());
-		}
-		SetExtensionVariable(context.client, entry->second, name, scope, value);
-		return SourceResultType::FINISHED;
-	}
-	SetScope variable_scope = scope;
-	if (variable_scope == SetScope::AUTOMATIC) {
-		if (option->set_local) {
-			variable_scope = SetScope::SESSION;
-		} else {
-			D_ASSERT(option->set_global);
-			variable_scope = SetScope::GLOBAL;
-		}
-	}
-
-	Value input_val = value.CastAs(context.client, DBConfig::ParseLogicalType(option->parameter_type));
-	switch (variable_scope) {
-	case SetScope::GLOBAL: {
-		if (!option->set_global) {
-			throw CatalogException("option \"%s\" cannot be set globally", name);
-		}
-		auto &db = DatabaseInstance::GetDatabase(context.client);
-		auto &config = DBConfig::GetConfig(context.client);
-		config.SetOption(&db, *option, input_val);
-		break;
-	}
-	case SetScope::SESSION:
-		if (!option->set_local) {
-			throw CatalogException("option \"%s\" cannot be set locally", name);
-		}
-		option->set_local(context.client, input_val);
-		break;
-	default:
-		throw InternalException("Unsupported SetScope for variable");
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_set_variable.cpp b/src/duckdb/src/execution/operator/helper/physical_set_variable.cpp
deleted file mode 100644
index 37482d2c8..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_set_variable.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_set_variable.hpp"
-#include "duckdb/main/client_config.hpp"
-
-namespace duckdb {
-
-PhysicalSetVariable::PhysicalSetVariable(string name_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::SET_VARIABLE, {LogicalType::BOOLEAN}, estimated_cardinality),
-      name(std::move(name_p)) {
-}
-
-SourceResultType PhysicalSetVariable::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
-	return SourceResultType::FINISHED;
-}
-
-class SetVariableGlobalState : public GlobalSinkState {
-public:
-	SetVariableGlobalState() {
-	}
-
-	bool is_set = false;
-};
-
-unique_ptr<GlobalSinkState> PhysicalSetVariable::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<SetVariableGlobalState>();
-}
-
-SinkResultType PhysicalSetVariable::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<SetVariableGlobalState>();
-	if (chunk.size() != 1 || gstate.is_set) {
-		throw InvalidInputException("PhysicalSetVariable can only handle a single value");
-	}
-	auto &config = ClientConfig::GetConfig(context.client);
-	config.SetUserVariable(name, chunk.GetValue(0, 0));
-	gstate.is_set = true;
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp b/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp
deleted file mode 100644
index 881375b95..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_streaming_limit.hpp"
-#include "duckdb/execution/operator/helper/physical_limit.hpp"
-
-namespace duckdb {
-
-PhysicalStreamingLimit::PhysicalStreamingLimit(vector<LogicalType> types, BoundLimitNode limit_val_p,
-                                               BoundLimitNode offset_val_p, idx_t estimated_cardinality, bool parallel)
-    : PhysicalOperator(PhysicalOperatorType::STREAMING_LIMIT, std::move(types), estimated_cardinality),
-      limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)), parallel(parallel) {
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class StreamingLimitOperatorState : public OperatorState {
-public:
-	explicit StreamingLimitOperatorState(const PhysicalStreamingLimit &op) {
-		PhysicalLimit::SetInitialLimits(op.limit_val, op.offset_val, limit, offset);
-	}
-
-	optional_idx limit;
-	optional_idx offset;
-};
-
-class StreamingLimitGlobalState : public GlobalOperatorState {
-public:
-	StreamingLimitGlobalState() : current_offset(0) {
-	}
-
-	std::atomic<idx_t> current_offset;
-};
-
-unique_ptr<OperatorState> PhysicalStreamingLimit::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<StreamingLimitOperatorState>(*this);
-}
-
-unique_ptr<GlobalOperatorState> PhysicalStreamingLimit::GetGlobalOperatorState(ClientContext &context) const {
-	return make_uniq<StreamingLimitGlobalState>();
-}
-
-OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = gstate_p.Cast<StreamingLimitGlobalState>();
-	auto &state = state_p.Cast<StreamingLimitOperatorState>();
-	auto &limit = state.limit;
-	auto &offset = state.offset;
-	idx_t current_offset = gstate.current_offset.fetch_add(input.size());
-	idx_t max_element;
-	if (!PhysicalLimit::ComputeOffset(context, input, limit, offset, current_offset, max_element, limit_val,
-	                                  offset_val)) {
-		return OperatorResultType::FINISHED;
-	}
-	if (PhysicalLimit::HandleOffset(input, current_offset, offset.GetIndex(), limit.GetIndex())) {
-		chunk.Reference(input);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-OrderPreservationType PhysicalStreamingLimit::OperatorOrder() const {
-	return OrderPreservationType::FIXED_ORDER;
-}
-
-bool PhysicalStreamingLimit::ParallelOperator() const {
-	return parallel;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_streaming_sample.cpp b/src/duckdb/src/execution/operator/helper/physical_streaming_sample.cpp
deleted file mode 100644
index 309256244..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_streaming_sample.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_streaming_sample.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-PhysicalStreamingSample::PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage,
-                                                 int64_t seed, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::STREAMING_SAMPLE, std::move(types), estimated_cardinality), method(method),
-      percentage(percentage / 100), seed(seed) {
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class StreamingSampleOperatorState : public OperatorState {
-public:
-	explicit StreamingSampleOperatorState(int64_t seed) : random(seed) {
-	}
-
-	RandomEngine random;
-};
-
-void PhysicalStreamingSample::SystemSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
-	// system sampling: we throw one dice per chunk
-	auto &state = state_p.Cast<StreamingSampleOperatorState>();
-	double rand = state.random.NextRandom();
-	if (rand <= percentage) {
-		// rand is smaller than sample_size: output chunk
-		result.Reference(input);
-	}
-}
-
-void PhysicalStreamingSample::BernoulliSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
-	// bernoulli sampling: we throw one dice per tuple
-	// then slice the result chunk
-	auto &state = state_p.Cast<StreamingSampleOperatorState>();
-	idx_t result_count = 0;
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < input.size(); i++) {
-		double rand = state.random.NextRandom();
-		if (rand <= percentage) {
-			sel.set_index(result_count++, i);
-		}
-	}
-	if (result_count > 0) {
-		result.Slice(input, sel, result_count);
-	}
-}
-
-unique_ptr<OperatorState> PhysicalStreamingSample::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<StreamingSampleOperatorState>(seed);
-}
-
-OperatorResultType PhysicalStreamingSample::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate, OperatorState &state) const {
-	switch (method) {
-	case SampleMethod::BERNOULLI_SAMPLE:
-		BernoulliSample(input, chunk, state);
-		break;
-	case SampleMethod::SYSTEM_SAMPLE:
-		SystemSample(input, chunk, state);
-		break;
-	default:
-		throw InternalException("Unsupported sample method for streaming sample");
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalStreamingSample::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Sample Method"] = EnumUtil::ToString(method) + ": " + to_string(100 * percentage) + "%";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_transaction.cpp b/src/duckdb/src/execution/operator/helper/physical_transaction.cpp
deleted file mode 100644
index a8ad410db..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_transaction.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_transaction.hpp"
-
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/valid_checker.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
-	auto &client = context.client;
-
-	auto type = info->type;
-	if (type == TransactionType::COMMIT && ValidChecker::IsInvalidated(client.ActiveTransaction())) {
-		// transaction is invalidated - turn COMMIT into ROLLBACK
-		type = TransactionType::ROLLBACK;
-	}
-	switch (type) {
-	case TransactionType::BEGIN_TRANSACTION: {
-		if (client.transaction.IsAutoCommit()) {
-			// start the active transaction
-			// if autocommit is active, we have already called
-			// BeginTransaction by setting autocommit to false we
-			// prevent it from being closed after this query, hence
-			// preserving the transaction context for the next query
-			client.transaction.SetAutoCommit(false);
-			auto &config = DBConfig::GetConfig(context.client);
-			if (info->modifier == TransactionModifierType::TRANSACTION_READ_ONLY) {
-				client.transaction.SetReadOnly();
-			}
-			if (config.options.immediate_transaction_mode) {
-				// if immediate transaction mode is enabled then start all transactions immediately
-				auto databases = DatabaseManager::Get(client).GetDatabases(client);
-				for (auto db : databases) {
-					context.client.transaction.ActiveTransaction().GetTransaction(db.get());
-				}
-			}
-		} else {
-			throw TransactionException("cannot start a transaction within a transaction");
-		}
-		break;
-	}
-	case TransactionType::COMMIT: {
-		if (client.transaction.IsAutoCommit()) {
-			throw TransactionException("cannot commit - no transaction is active");
-		} else {
-			// explicitly commit the current transaction
-			client.transaction.Commit();
-		}
-		break;
-	}
-	case TransactionType::ROLLBACK: {
-		if (client.transaction.IsAutoCommit()) {
-			throw TransactionException("cannot rollback - no transaction is active");
-		} else {
-			// Explicitly rollback the current transaction
-			// If it is because of an invalidated transaction, we need to rollback with an error
-			auto &valid_checker = ValidChecker::Get(client.transaction.ActiveTransaction());
-			if (valid_checker.IsInvalidated()) {
-				ErrorData error(ExceptionType::TRANSACTION, valid_checker.InvalidatedMessage());
-				client.transaction.Rollback(error);
-			} else {
-				client.transaction.Rollback(nullptr);
-			}
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unrecognized transaction type!");
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_update_extensions.cpp b/src/duckdb/src/execution/operator/helper/physical_update_extensions.cpp
deleted file mode 100644
index d29632d12..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_update_extensions.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_update_extensions.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalUpdateExtensions::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                   OperatorSourceInput &input) const {
-	auto &data = input.global_state.Cast<UpdateExtensionsGlobalState>();
-
-	if (data.offset >= data.update_result_entries.size()) {
-		// finished returning values
-		return SourceResultType::FINISHED;
-	}
-
-	idx_t count = 0;
-	while (data.offset < data.update_result_entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.update_result_entries[data.offset];
-
-		// return values:
-		idx_t col = 0;
-		// extension_name LogicalType::VARCHAR
-		chunk.SetValue(col++, count, Value(entry.extension_name));
-		// repository LogicalType::VARCHAR
-		chunk.SetValue(col++, count, Value(entry.repository));
-		// update_result
-		chunk.SetValue(col++, count, Value(EnumUtil::ToString(entry.tag)));
-		// previous_version LogicalType::VARCHAR
-		chunk.SetValue(col++, count, Value(entry.prev_version));
-		// current_version LogicalType::VARCHAR
-		chunk.SetValue(col++, count, Value(entry.installed_version));
-
-		data.offset++;
-		count++;
-	}
-	chunk.SetCardinality(count);
-
-	return data.offset >= data.update_result_entries.size() ? SourceResultType::FINISHED
-	                                                        : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-unique_ptr<GlobalSourceState> PhysicalUpdateExtensions::GetGlobalSourceState(ClientContext &context) const {
-	auto res = make_uniq<UpdateExtensionsGlobalState>();
-
-	if (info->extensions_to_update.empty()) {
-		// Update all
-		res->update_result_entries = ExtensionHelper::UpdateExtensions(context);
-	} else {
-		// Update extensions in extensions_to_update
-		for (const auto &ext : info->extensions_to_update) {
-			res->update_result_entries.emplace_back(ExtensionHelper::UpdateExtension(context, ext));
-		}
-	}
-
-	return std::move(res);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp b/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp
deleted file mode 100644
index 345745df8..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_vacuum.hpp"
-
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-namespace duckdb {
-
-PhysicalVacuum::PhysicalVacuum(unique_ptr<VacuumInfo> info_p, optional_ptr<TableCatalogEntry> table,
-                               unordered_map<idx_t, idx_t> column_id_map, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
-      info(std::move(info_p)), table(table), column_id_map(std::move(column_id_map)) {
-}
-
-class VacuumLocalSinkState : public LocalSinkState {
-public:
-	explicit VacuumLocalSinkState(VacuumInfo &info, optional_ptr<TableCatalogEntry> table) : hashes(LogicalType::HASH) {
-		for (const auto &column_name : info.columns) {
-			auto &column = table->GetColumn(column_name);
-			if (DistinctStatistics::TypeIsSupported(column.GetType())) {
-				column_distinct_stats.push_back(make_uniq<DistinctStatistics>());
-			} else {
-				column_distinct_stats.push_back(nullptr);
-			}
-		}
-	};
-
-	vector<unique_ptr<DistinctStatistics>> column_distinct_stats;
-	Vector hashes;
-};
-
-unique_ptr<LocalSinkState> PhysicalVacuum::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<VacuumLocalSinkState>(*info, table);
-}
-
-class VacuumGlobalSinkState : public GlobalSinkState {
-public:
-	explicit VacuumGlobalSinkState(VacuumInfo &info, optional_ptr<TableCatalogEntry> table) {
-		for (const auto &column_name : info.columns) {
-			auto &column = table->GetColumn(column_name);
-			if (DistinctStatistics::TypeIsSupported(column.GetType())) {
-				column_distinct_stats.push_back(make_uniq<DistinctStatistics>());
-			} else {
-				column_distinct_stats.push_back(nullptr);
-			}
-		}
-	};
-
-	mutex stats_lock;
-	vector<unique_ptr<DistinctStatistics>> column_distinct_stats;
-};
-
-unique_ptr<GlobalSinkState> PhysicalVacuum::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<VacuumGlobalSinkState>(*info, table);
-}
-
-SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<VacuumLocalSinkState>();
-	D_ASSERT(lstate.column_distinct_stats.size() == column_id_map.size());
-
-	for (idx_t col_idx = 0; col_idx < chunk.data.size(); col_idx++) {
-		if (!DistinctStatistics::TypeIsSupported(chunk.data[col_idx].GetType())) {
-			continue;
-		}
-		lstate.column_distinct_stats[col_idx]->Update(chunk.data[col_idx], chunk.size(), lstate.hashes);
-	}
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalVacuum::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &g_state = input.global_state.Cast<VacuumGlobalSinkState>();
-	auto &l_state = input.local_state.Cast<VacuumLocalSinkState>();
-
-	lock_guard<mutex> lock(g_state.stats_lock);
-	D_ASSERT(g_state.column_distinct_stats.size() == l_state.column_distinct_stats.size());
-
-	for (idx_t col_idx = 0; col_idx < g_state.column_distinct_stats.size(); col_idx++) {
-		if (g_state.column_distinct_stats[col_idx]) {
-			D_ASSERT(l_state.column_distinct_stats[col_idx]);
-			g_state.column_distinct_stats[col_idx]->Merge(*l_state.column_distinct_stats[col_idx]);
-		}
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          OperatorSinkFinalizeInput &input) const {
-	auto &sink = input.global_state.Cast<VacuumGlobalSinkState>();
-
-	auto tbl = table;
-	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
-		tbl->GetStorage().SetDistinct(column_id_map.at(col_idx), std::move(sink.column_distinct_stats[col_idx]));
-	}
-
-	return SinkFinalizeType::READY;
-}
-
-SourceResultType PhysicalVacuum::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	// NOP
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/helper/physical_verify_vector.cpp b/src/duckdb/src/execution/operator/helper/physical_verify_vector.cpp
deleted file mode 100644
index ea19d7ca9..000000000
--- a/src/duckdb/src/execution/operator/helper/physical_verify_vector.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_verify_vector.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-
-namespace duckdb {
-
-PhysicalVerifyVector::PhysicalVerifyVector(unique_ptr<PhysicalOperator> child)
-    : PhysicalOperator(PhysicalOperatorType::VERIFY_VECTOR, child->types, child->estimated_cardinality) {
-	children.push_back(std::move(child));
-}
-
-class VerifyVectorState : public OperatorState {
-public:
-	explicit VerifyVectorState() : const_idx(0) {
-	}
-
-	idx_t const_idx;
-};
-
-OperatorResultType VerifyEmitConstantVectors(const DataChunk &input, DataChunk &chunk, OperatorState &state_p) {
-	auto &state = state_p.Cast<VerifyVectorState>();
-	D_ASSERT(state.const_idx < input.size());
-
-	// Ensure that we don't alter the input data while another thread is still using it.
-	DataChunk copied_input;
-	copied_input.Initialize(Allocator::DefaultAllocator(), input.GetTypes());
-	input.Copy(copied_input);
-
-	// emit constant vectors at the current index
-	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-		ConstantVector::Reference(chunk.data[c], copied_input.data[c], state.const_idx, 1);
-	}
-	chunk.SetCardinality(1);
-	state.const_idx++;
-	if (state.const_idx >= copied_input.size()) {
-		state.const_idx = 0;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorResultType VerifyEmitDictionaryVectors(const DataChunk &input, DataChunk &chunk, OperatorState &state) {
-	input.Copy(chunk);
-	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-		Vector::DebugTransformToDictionary(chunk.data[c], chunk.size());
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-struct ConstantOrSequenceInfo {
-	vector<Value> values;
-	bool is_constant = true;
-};
-
-OperatorResultType VerifyEmitSequenceVector(const DataChunk &input, DataChunk &chunk, OperatorState &state_p) {
-	auto &state = state_p.Cast<VerifyVectorState>();
-	D_ASSERT(state.const_idx < input.size());
-
-	// find the longest length sequence or constant vector to emit
-	vector<ConstantOrSequenceInfo> infos;
-	idx_t max_length = 0;
-	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-		bool can_be_sequence = false;
-		switch (chunk.data[c].GetType().id()) {
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT: {
-			can_be_sequence = true;
-			break;
-		}
-		default: {
-			break;
-		}
-		}
-		bool can_be_constant = true;
-		switch (chunk.data[c].GetType().id()) {
-		case LogicalTypeId::INTERVAL:
-			can_be_constant = false;
-			break;
-		default:
-			break;
-		}
-		ConstantOrSequenceInfo info;
-		info.is_constant = true;
-		for (idx_t k = state.const_idx; k < input.size(); k++) {
-			auto val = input.data[c].GetValue(k);
-			if (info.values.empty()) {
-				info.values.push_back(std::move(val));
-			} else if (info.is_constant) {
-				if (!ValueOperations::DistinctFrom(val, info.values[0]) && can_be_constant) {
-					// found the same value! continue
-					info.values.push_back(std::move(val));
-					continue;
-				}
-				// not the same value - can we convert this into a sequence vector?
-				if (!can_be_sequence) {
-					break;
-				}
-				// we can only convert to a sequence if we have only gathered one value
-				// otherwise we would have multiple identical values here already
-				if (info.values.size() > 1) {
-					break;
-				}
-				// cannot create a sequence with null values
-				if (val.IsNull() || info.values[0].IsNull()) {
-					break;
-				}
-				// check if the increment fits in the target type
-				// i.e. we cannot have a sequence vector with an increment of 200 in `int8_t`
-				auto increment = hugeint_t(val.GetValue<int64_t>()) - hugeint_t(info.values[0].GetValue<int64_t>());
-				bool increment_fits = true;
-				switch (chunk.data[c].GetType().id()) {
-				case LogicalTypeId::TINYINT: {
-					int8_t result;
-					if (!Hugeint::TryCast<int8_t>(increment, result)) {
-						increment_fits = false;
-					}
-					break;
-				}
-				case LogicalTypeId::SMALLINT: {
-					int16_t result;
-					if (!Hugeint::TryCast<int16_t>(increment, result)) {
-						increment_fits = false;
-					}
-					break;
-				}
-				case LogicalTypeId::INTEGER: {
-					int32_t result;
-					if (!Hugeint::TryCast<int32_t>(increment, result)) {
-						increment_fits = false;
-					}
-					break;
-				}
-				case LogicalTypeId::BIGINT: {
-					int64_t result;
-					if (!Hugeint::TryCast<int64_t>(increment, result)) {
-						increment_fits = false;
-					}
-					break;
-				}
-				default:
-					throw InternalException("Unsupported sequence type");
-				}
-				if (!increment_fits) {
-					break;
-				}
-				info.values.push_back(std::move(val));
-				info.is_constant = false;
-				continue;
-			} else {
-				D_ASSERT(info.values.size() >= 2);
-				// sequence vector - check if this value is on the trajectory
-				if (val.IsNull()) {
-					// not on trajectory - this value is null
-					break;
-				}
-				int64_t start = info.values[0].GetValue<int64_t>();
-				int64_t increment = info.values[1].GetValue<int64_t>() - start;
-				int64_t last_value = info.values.back().GetValue<int64_t>();
-				if (hugeint_t(val.GetValue<int64_t>()) == hugeint_t(last_value) + hugeint_t(increment)) {
-					// value still fits in the sequence
-					info.values.push_back(std::move(val));
-					continue;
-				}
-				// value no longer fits into the sequence - break
-				break;
-			}
-		}
-		if (info.values.size() > max_length) {
-			max_length = info.values.size();
-		}
-		infos.push_back(std::move(info));
-	}
-	// go over each of the columns again and construct either (1) a dictionary vector, or (2) a constant/sequence vector
-	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-		auto &info = infos[c];
-		if (info.values.size() != max_length) {
-			// dictionary vector
-			SelectionVector sel(max_length);
-			for (idx_t k = 0; k < max_length; k++) {
-				sel.set_index(k, state.const_idx + k);
-			}
-			chunk.data[c].Slice(input.data[c], sel, max_length);
-		} else if (info.is_constant) {
-			// constant vector
-			chunk.data[c].Reference(info.values[0]);
-		} else {
-			// sequence vector
-			int64_t start = info.values[0].GetValue<int64_t>();
-			int64_t increment = info.values[1].GetValue<int64_t>() - start;
-			chunk.data[c].Sequence(start, increment, max_length);
-		}
-	}
-	chunk.SetCardinality(max_length);
-	state.const_idx += max_length;
-	if (state.const_idx >= input.size()) {
-		state.const_idx = 0;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorResultType VerifyEmitNestedShuffleVector(const DataChunk &input, DataChunk &chunk, OperatorState &state) {
-	input.Copy(chunk);
-	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-		Vector::DebugShuffleNestedVector(chunk.data[c], chunk.size());
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<OperatorState> PhysicalVerifyVector::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<VerifyVectorState>();
-}
-
-OperatorResultType PhysicalVerifyVector::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                 GlobalOperatorState &gstate, OperatorState &state) const {
-#ifdef DUCKDB_VERIFY_CONSTANT_OPERATOR
-	return VerifyEmitConstantVectors(input, chunk, state);
-#endif
-#ifdef DUCKDB_VERIFY_DICTIONARY_OPERATOR
-	return VerifyEmitDictionaryVectors(input, chunk, state);
-#endif
-#ifdef DUCKDB_VERIFY_SEQUENCE_OPERATOR
-	return VerifyEmitSequenceVector(input, chunk, state);
-#endif
-#ifdef DUCKDB_VERIFY_NESTED_SHUFFLE
-	return VerifyEmitNestedShuffleVector(input, chunk, state);
-#endif
-	throw InternalException("PhysicalVerifyVector created but no verification code present");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/outer_join_marker.cpp b/src/duckdb/src/execution/operator/join/outer_join_marker.cpp
deleted file mode 100644
index 645c702ad..000000000
--- a/src/duckdb/src/execution/operator/join/outer_join_marker.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "duckdb/execution/operator/join/outer_join_marker.hpp"
-
-namespace duckdb {
-
-OuterJoinMarker::OuterJoinMarker(bool enabled_p) : enabled(enabled_p), count(0) {
-}
-
-void OuterJoinMarker::Initialize(idx_t count_p) {
-	if (!enabled) {
-		return;
-	}
-	this->count = count_p;
-	found_match = make_unsafe_uniq_array_uninitialized<bool>(count);
-	Reset();
-}
-
-void OuterJoinMarker::Reset() {
-	if (!enabled) {
-		return;
-	}
-	memset(found_match.get(), 0, sizeof(bool) * count);
-}
-
-void OuterJoinMarker::SetMatch(idx_t position) {
-	if (!enabled) {
-		return;
-	}
-	D_ASSERT(position < count);
-	found_match[position] = true;
-}
-
-void OuterJoinMarker::SetMatches(const SelectionVector &sel, idx_t count, idx_t base_idx) {
-	if (!enabled) {
-		return;
-	}
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto pos = base_idx + idx;
-		D_ASSERT(pos < this->count);
-		found_match[pos] = true;
-	}
-}
-
-void OuterJoinMarker::ConstructLeftJoinResult(DataChunk &left, DataChunk &result) {
-	if (!enabled) {
-		return;
-	}
-	D_ASSERT(count == STANDARD_VECTOR_SIZE);
-	SelectionVector remaining_sel(STANDARD_VECTOR_SIZE);
-	idx_t remaining_count = 0;
-	for (idx_t i = 0; i < left.size(); i++) {
-		if (!found_match[i]) {
-			remaining_sel.set_index(remaining_count++, i);
-		}
-	}
-	if (remaining_count > 0) {
-		result.Slice(left, remaining_sel, remaining_count);
-		for (idx_t idx = left.ColumnCount(); idx < result.ColumnCount(); idx++) {
-			result.data[idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result.data[idx], true);
-		}
-	}
-}
-
-idx_t OuterJoinMarker::MaxThreads() const {
-	return count / (STANDARD_VECTOR_SIZE * 10ULL);
-}
-
-void OuterJoinMarker::InitializeScan(ColumnDataCollection &data, OuterJoinGlobalScanState &gstate) {
-	gstate.data = &data;
-	data.InitializeScan(gstate.global_scan);
-}
-
-void OuterJoinMarker::InitializeScan(OuterJoinGlobalScanState &gstate, OuterJoinLocalScanState &lstate) {
-	D_ASSERT(gstate.data);
-	lstate.match_sel.Initialize(STANDARD_VECTOR_SIZE);
-	gstate.data->InitializeScanChunk(lstate.scan_chunk);
-}
-
-void OuterJoinMarker::Scan(OuterJoinGlobalScanState &gstate, OuterJoinLocalScanState &lstate, DataChunk &result) {
-	D_ASSERT(gstate.data);
-	// fill in NULL values for the LHS
-	while (gstate.data->Scan(gstate.global_scan, lstate.local_scan, lstate.scan_chunk)) {
-		idx_t result_count = 0;
-		// figure out which tuples didn't find a match in the RHS
-		for (idx_t i = 0; i < lstate.scan_chunk.size(); i++) {
-			if (!found_match[lstate.local_scan.current_row_index + i]) {
-				lstate.match_sel.set_index(result_count++, i);
-			}
-		}
-		if (result_count > 0) {
-			// if there were any tuples that didn't find a match, output them
-			idx_t left_column_count = result.ColumnCount() - lstate.scan_chunk.ColumnCount();
-			for (idx_t i = 0; i < left_column_count; i++) {
-				result.data[i].SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result.data[i], true);
-			}
-			for (idx_t col_idx = left_column_count; col_idx < result.ColumnCount(); col_idx++) {
-				result.data[col_idx].Slice(lstate.scan_chunk.data[col_idx - left_column_count], lstate.match_sel,
-				                           result_count);
-			}
-			result.SetCardinality(result_count);
-			return;
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp b/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp
deleted file mode 100644
index 123d94161..000000000
--- a/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp
+++ /dev/null
@@ -1,401 +0,0 @@
-#include "duckdb/execution/operator/join/perfect_hash_join_executor.hpp"
-
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/execution/operator/join/physical_hash_join.hpp"
-
-namespace duckdb {
-
-PerfectHashJoinExecutor::PerfectHashJoinExecutor(const PhysicalHashJoin &join_p, JoinHashTable &ht_p)
-    : join(join_p), ht(ht_p) {
-}
-
-//===--------------------------------------------------------------------===//
-// Initialize
-//===--------------------------------------------------------------------===//
-bool ExtractNumericValue(Value val, hugeint_t &result) {
-	if (!val.type().IsIntegral()) {
-		switch (val.type().InternalType()) {
-		case PhysicalType::INT8:
-			result = Hugeint::Convert(val.GetValueUnsafe<int8_t>());
-			break;
-		case PhysicalType::INT16:
-			result = Hugeint::Convert(val.GetValueUnsafe<int16_t>());
-			break;
-		case PhysicalType::INT32:
-			result = Hugeint::Convert(val.GetValueUnsafe<int32_t>());
-			break;
-		case PhysicalType::INT64:
-			result = Hugeint::Convert(val.GetValueUnsafe<int64_t>());
-			break;
-		case PhysicalType::INT128:
-			result = val.GetValueUnsafe<hugeint_t>();
-			break;
-		case PhysicalType::UINT8:
-			result = Hugeint::Convert(val.GetValueUnsafe<uint8_t>());
-			break;
-		case PhysicalType::UINT16:
-			result = Hugeint::Convert(val.GetValueUnsafe<uint16_t>());
-			break;
-		case PhysicalType::UINT32:
-			result = Hugeint::Convert(val.GetValueUnsafe<uint32_t>());
-			break;
-		case PhysicalType::UINT64:
-			result = Hugeint::Convert(val.GetValueUnsafe<uint64_t>());
-			break;
-		case PhysicalType::UINT128: {
-			const auto uhugeint_val = val.GetValueUnsafe<uhugeint_t>();
-			if (uhugeint_val > NumericCast<uhugeint_t>(NumericLimits<hugeint_t>::Maximum())) {
-				return false;
-			}
-			result.lower = uhugeint_val.lower;
-			result.upper = NumericCast<int64_t>(uhugeint_val.upper);
-			break;
-		}
-		default:
-			return false;
-		}
-	} else {
-		if (!val.DefaultTryCastAs(LogicalType::HUGEINT)) {
-			return false;
-		}
-		result = val.GetValue<hugeint_t>();
-	}
-	return true;
-}
-
-bool PerfectHashJoinExecutor::CanDoPerfectHashJoin(const PhysicalHashJoin &op, const Value &min, const Value &max) {
-	if (perfect_join_statistics.is_build_small) {
-		return true; // Already true based on static statistics
-	}
-
-	// We only do this optimization for inner joins with one integer equality condition
-	const auto key_type = op.conditions[0].left->return_type;
-	if (op.join_type != JoinType::INNER || op.conditions.size() != 1 ||
-	    op.conditions[0].comparison != ExpressionType::COMPARE_EQUAL || !TypeIsInteger(key_type.InternalType())) {
-		return false;
-	}
-
-	// We bail out if there are nested types on the RHS
-	for (auto &type : op.children[1]->types) {
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT:
-		case PhysicalType::LIST:
-		case PhysicalType::ARRAY:
-			return false;
-		default:
-			break;
-		}
-	}
-
-	// And when the build range is smaller than the threshold
-	perfect_join_statistics.build_min = min;
-	perfect_join_statistics.build_max = max;
-	hugeint_t min_value, max_value;
-	if (!ExtractNumericValue(perfect_join_statistics.build_min, min_value) ||
-	    !ExtractNumericValue(perfect_join_statistics.build_max, max_value)) {
-		return false;
-	}
-	if (max_value < min_value) {
-		return false; // Empty table
-	}
-
-	hugeint_t build_range;
-	if (!TrySubtractOperator::Operation(max_value, min_value, build_range)) {
-		return false;
-	}
-
-	// The max size our build must have to run the perfect HJ
-	static constexpr idx_t MAX_BUILD_SIZE = 1048576;
-	if (build_range > Hugeint::Convert(MAX_BUILD_SIZE)) {
-		return false;
-	}
-	perfect_join_statistics.build_range = NumericCast<idx_t>(build_range);
-
-	// If count is larger than range (duplicates), we bail out
-	if (ht.Count() > perfect_join_statistics.build_range) {
-		return false;
-	}
-
-	perfect_join_statistics.is_build_small = true;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Build
-//===--------------------------------------------------------------------===//
-bool PerfectHashJoinExecutor::BuildPerfectHashTable(LogicalType &key_type) {
-	// First, allocate memory for each build column
-	auto build_size = perfect_join_statistics.build_range + 1;
-	for (const auto &type : join.rhs_output_columns.col_types) {
-		perfect_hash_table.emplace_back(type, build_size);
-	}
-
-	// and for duplicate_checking
-	bitmap_build_idx = make_unsafe_uniq_array_uninitialized<bool>(build_size);
-	memset(bitmap_build_idx.get(), 0, sizeof(bool) * build_size); // set false
-
-	// Now fill columns with build data
-	return FullScanHashTable(key_type);
-}
-
-bool PerfectHashJoinExecutor::FullScanHashTable(LogicalType &key_type) {
-	auto &data_collection = ht.GetDataCollection();
-
-	// TODO: In a parallel finalize: One should exclusively lock and each thread should do one part of the code below.
-	Vector tuples_addresses(LogicalType::POINTER, ht.Count()); // allocate space for all the tuples
-
-	idx_t key_count = 0;
-	if (data_collection.ChunkCount() > 0) {
-		JoinHTScanState join_ht_state(data_collection, 0, data_collection.ChunkCount(),
-		                              TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
-
-		// Go through all the blocks and fill the keys addresses
-		key_count = ht.FillWithHTOffsets(join_ht_state, tuples_addresses);
-	}
-
-	// Scan the build keys in the hash table
-	Vector build_vector(key_type, key_count);
-	data_collection.Gather(tuples_addresses, *FlatVector::IncrementalSelectionVector(), key_count, 0, build_vector,
-	                       *FlatVector::IncrementalSelectionVector(), nullptr);
-
-	// Now fill the selection vector using the build keys and create a sequential vector
-	// TODO: add check for fast pass when probe is part of build domain
-	SelectionVector sel_build(key_count + 1);
-	SelectionVector sel_tuples(key_count + 1);
-	bool success = FillSelectionVectorSwitchBuild(build_vector, sel_build, sel_tuples, key_count);
-
-	// early out
-	if (!success) {
-		return false;
-	}
-	if (unique_keys == perfect_join_statistics.build_range + 1 && !ht.has_null) {
-		perfect_join_statistics.is_build_dense = true;
-	}
-	key_count = unique_keys; // do not consider keys out of the range
-
-	// Full scan the remaining build columns and fill the perfect hash table
-	const auto build_size = perfect_join_statistics.build_range + 1;
-	for (idx_t i = 0; i < join.rhs_output_columns.col_types.size(); i++) {
-		auto &vector = perfect_hash_table[i];
-		const auto output_col_idx = ht.output_columns[i];
-		D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
-		if (build_size > STANDARD_VECTOR_SIZE) {
-			auto &col_mask = FlatVector::Validity(vector);
-			col_mask.Initialize(build_size);
-		}
-		data_collection.Gather(tuples_addresses, sel_tuples, key_count, output_col_idx, vector, sel_build, nullptr);
-	}
-
-	return true;
-}
-
-bool PerfectHashJoinExecutor::FillSelectionVectorSwitchBuild(Vector &source, SelectionVector &sel_vec,
-                                                             SelectionVector &seq_sel_vec, idx_t count) {
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		return TemplatedFillSelectionVectorBuild<int8_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT16:
-		return TemplatedFillSelectionVectorBuild<int16_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT32:
-		return TemplatedFillSelectionVectorBuild<int32_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT64:
-		return TemplatedFillSelectionVectorBuild<int64_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT128:
-		return TemplatedFillSelectionVectorBuild<hugeint_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT8:
-		return TemplatedFillSelectionVectorBuild<uint8_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT16:
-		return TemplatedFillSelectionVectorBuild<uint16_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT32:
-		return TemplatedFillSelectionVectorBuild<uint32_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT64:
-		return TemplatedFillSelectionVectorBuild<uint64_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT128:
-		return TemplatedFillSelectionVectorBuild<uhugeint_t>(source, sel_vec, seq_sel_vec, count);
-	default:
-		throw NotImplementedException("Type not supported for perfect hash join");
-	}
-}
-
-template <typename T>
-bool PerfectHashJoinExecutor::TemplatedFillSelectionVectorBuild(Vector &source, SelectionVector &sel_vec,
-                                                                SelectionVector &seq_sel_vec, idx_t count) {
-	if (perfect_join_statistics.build_min.IsNull() || perfect_join_statistics.build_max.IsNull()) {
-		return false;
-	}
-	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
-	auto max_value = perfect_join_statistics.build_max.GetValueUnsafe<T>();
-	UnifiedVectorFormat vector_data;
-	source.ToUnifiedFormat(count, vector_data);
-	auto data = reinterpret_cast<T *>(vector_data.data);
-	// generate the selection vector
-	for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
-		auto data_idx = vector_data.sel->get_index(i);
-		auto input_value = data[data_idx];
-		// add index to selection vector if value in the range
-		if (min_value <= input_value && input_value <= max_value) {
-			auto idx = (idx_t)(input_value - min_value); // subtract min value to get the idx position
-			sel_vec.set_index(sel_idx, idx);
-			if (bitmap_build_idx[idx]) {
-				return false;
-			} else {
-				bitmap_build_idx[idx] = true;
-				unique_keys++;
-			}
-			seq_sel_vec.set_index(sel_idx++, i);
-		}
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Probe
-//===--------------------------------------------------------------------===//
-class PerfectHashJoinState : public OperatorState {
-public:
-	PerfectHashJoinState(ClientContext &context, const PhysicalHashJoin &join) : probe_executor(context) {
-		join_keys.Initialize(Allocator::Get(context), join.condition_types);
-		for (auto &cond : join.conditions) {
-			probe_executor.AddExpression(*cond.left);
-		}
-		build_sel_vec.Initialize(STANDARD_VECTOR_SIZE);
-		probe_sel_vec.Initialize(STANDARD_VECTOR_SIZE);
-		seq_sel_vec.Initialize(STANDARD_VECTOR_SIZE);
-	}
-
-	DataChunk join_keys;
-	ExpressionExecutor probe_executor;
-	SelectionVector build_sel_vec;
-	SelectionVector probe_sel_vec;
-	SelectionVector seq_sel_vec;
-};
-
-unique_ptr<OperatorState> PerfectHashJoinExecutor::GetOperatorState(ExecutionContext &context) {
-	auto state = make_uniq<PerfectHashJoinState>(context.client, join);
-	return std::move(state);
-}
-
-OperatorResultType PerfectHashJoinExecutor::ProbePerfectHashTable(ExecutionContext &context, DataChunk &input,
-                                                                  DataChunk &lhs_output_columns, DataChunk &result,
-                                                                  OperatorState &state_p) {
-	auto &state = state_p.Cast<PerfectHashJoinState>();
-	// keeps track of how many probe keys have a match
-	idx_t probe_sel_count = 0;
-
-	// fetch the join keys from the chunk
-	state.join_keys.Reset();
-	state.probe_executor.Execute(input, state.join_keys);
-	// select the keys that are in the min-max range
-	auto &keys_vec = state.join_keys.data[0];
-	auto keys_count = state.join_keys.size();
-	// todo: add check for fast pass when probe is part of build domain
-	FillSelectionVectorSwitchProbe(keys_vec, state.build_sel_vec, state.probe_sel_vec, keys_count, probe_sel_count);
-
-	// If build is dense and probe is in build's domain, just reference probe
-	if (perfect_join_statistics.is_build_dense && keys_count == probe_sel_count) {
-		result.Reference(lhs_output_columns);
-	} else {
-		// otherwise, filter it out the values that do not match
-		result.Slice(lhs_output_columns, state.probe_sel_vec, probe_sel_count, 0);
-	}
-	// on the build side, we need to fetch the data and build dictionary vectors with the sel_vec
-	for (idx_t i = 0; i < join.rhs_output_columns.col_types.size(); i++) {
-		auto &result_vector = result.data[lhs_output_columns.ColumnCount() + i];
-		D_ASSERT(result_vector.GetType() == ht.layout.GetTypes()[ht.output_columns[i]]);
-		auto &build_vec = perfect_hash_table[i];
-		result_vector.Reference(build_vec);
-		result_vector.Slice(state.build_sel_vec, probe_sel_count);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-void PerfectHashJoinExecutor::FillSelectionVectorSwitchProbe(Vector &source, SelectionVector &build_sel_vec,
-                                                             SelectionVector &probe_sel_vec, idx_t count,
-                                                             idx_t &probe_sel_count) {
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedFillSelectionVectorProbe<int8_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedFillSelectionVectorProbe<int16_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedFillSelectionVectorProbe<int32_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedFillSelectionVectorProbe<int64_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedFillSelectionVectorProbe<hugeint_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedFillSelectionVectorProbe<uint8_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedFillSelectionVectorProbe<uint16_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedFillSelectionVectorProbe<uint32_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedFillSelectionVectorProbe<uint64_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedFillSelectionVectorProbe<uhugeint_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	default:
-		throw NotImplementedException("Type not supported");
-	}
-}
-
-template <typename T>
-void PerfectHashJoinExecutor::TemplatedFillSelectionVectorProbe(Vector &source, SelectionVector &build_sel_vec,
-                                                                SelectionVector &probe_sel_vec, idx_t count,
-                                                                idx_t &probe_sel_count) {
-	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
-	auto max_value = perfect_join_statistics.build_max.GetValueUnsafe<T>();
-
-	UnifiedVectorFormat vector_data;
-	source.ToUnifiedFormat(count, vector_data);
-	auto data = reinterpret_cast<T *>(vector_data.data);
-	auto validity_mask = &vector_data.validity;
-	// build selection vector for non-dense build
-	if (validity_mask->AllValid()) {
-		for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
-			// retrieve value from vector
-			auto data_idx = vector_data.sel->get_index(i);
-			auto input_value = data[data_idx];
-			// add index to selection vector if value in the range
-			if (min_value <= input_value && input_value <= max_value) {
-				auto idx = (idx_t)(input_value - min_value); // subtract min value to get the idx position
-				                                             // check for matches in the build
-				if (bitmap_build_idx[idx]) {
-					build_sel_vec.set_index(sel_idx, idx);
-					probe_sel_vec.set_index(sel_idx++, i);
-					probe_sel_count++;
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
-			// retrieve value from vector
-			auto data_idx = vector_data.sel->get_index(i);
-			if (!validity_mask->RowIsValid(data_idx)) {
-				continue;
-			}
-			auto input_value = data[data_idx];
-			// add index to selection vector if value in the range
-			if (min_value <= input_value && input_value <= max_value) {
-				auto idx = (idx_t)(input_value - min_value); // subtract min value to get the idx position
-				                                             // check for matches in the build
-				if (bitmap_build_idx[idx]) {
-					build_sel_vec.set_index(sel_idx, idx);
-					probe_sel_vec.set_index(sel_idx++, i);
-					probe_sel_count++;
-				}
-			}
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_asof_join.cpp b/src/duckdb/src/execution/operator/join/physical_asof_join.cpp
deleted file mode 100644
index 91dda01e6..000000000
--- a/src/duckdb/src/execution/operator/join/physical_asof_join.cpp
+++ /dev/null
@@ -1,876 +0,0 @@
-#include "duckdb/execution/operator/join/physical_asof_join.hpp"
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/sort/comparators.hpp"
-#include "duckdb/common/sort/partition_state.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/join/outer_join_marker.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-#include <thread>
-
-namespace duckdb {
-
-PhysicalAsOfJoin::PhysicalAsOfJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left,
-                                   unique_ptr<PhysicalOperator> right)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::ASOF_JOIN, std::move(op.conditions), op.join_type,
-                             op.estimated_cardinality),
-      comparison_type(ExpressionType::INVALID) {
-
-	// Convert the conditions partitions and sorts
-	for (auto &cond : conditions) {
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-
-		auto left = cond.left->Copy();
-		auto right = cond.right->Copy();
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHAN:
-			null_sensitive.emplace_back(lhs_orders.size());
-			lhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left));
-			rhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right));
-			comparison_type = cond.comparison;
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_LESSTHAN:
-			//	Always put NULLS LAST so they can be ignored.
-			null_sensitive.emplace_back(lhs_orders.size());
-			lhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left));
-			rhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right));
-			comparison_type = cond.comparison;
-			break;
-		case ExpressionType::COMPARE_EQUAL:
-			null_sensitive.emplace_back(lhs_orders.size());
-			DUCKDB_EXPLICIT_FALLTHROUGH;
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-			lhs_partitions.emplace_back(std::move(left));
-			rhs_partitions.emplace_back(std::move(right));
-			break;
-		default:
-			throw NotImplementedException("Unsupported join condition for ASOF join");
-		}
-	}
-	D_ASSERT(!lhs_orders.empty());
-	D_ASSERT(!rhs_orders.empty());
-
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-
-	//	Fill out the right projection map.
-	right_projection_map = op.right_projection_map;
-	if (right_projection_map.empty()) {
-		const auto right_count = children[1]->types.size();
-		right_projection_map.reserve(right_count);
-		for (column_t i = 0; i < right_count; ++i) {
-			right_projection_map.emplace_back(i);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class AsOfGlobalSinkState : public GlobalSinkState {
-public:
-	AsOfGlobalSinkState(ClientContext &context, const PhysicalAsOfJoin &op)
-	    : rhs_sink(context, op.rhs_partitions, op.rhs_orders, op.children[1]->types, {}, op.estimated_cardinality),
-	      is_outer(IsRightOuterJoin(op.join_type)), has_null(false) {
-	}
-
-	idx_t Count() const {
-		return rhs_sink.count;
-	}
-
-	PartitionLocalSinkState *RegisterBuffer(ClientContext &context) {
-		lock_guard<mutex> guard(lock);
-		lhs_buffers.emplace_back(make_uniq<PartitionLocalSinkState>(context, *lhs_sink));
-		return lhs_buffers.back().get();
-	}
-
-	PartitionGlobalSinkState rhs_sink;
-
-	//	One per partition
-	const bool is_outer;
-	vector<OuterJoinMarker> right_outers;
-	bool has_null;
-
-	//	Left side buffering
-	unique_ptr<PartitionGlobalSinkState> lhs_sink;
-
-	mutex lock;
-	vector<unique_ptr<PartitionLocalSinkState>> lhs_buffers;
-};
-
-class AsOfLocalSinkState : public LocalSinkState {
-public:
-	explicit AsOfLocalSinkState(ClientContext &context, PartitionGlobalSinkState &gstate_p)
-	    : local_partition(context, gstate_p) {
-	}
-
-	void Sink(DataChunk &input_chunk) {
-		local_partition.Sink(input_chunk);
-	}
-
-	void Combine() {
-		local_partition.Combine();
-	}
-
-	PartitionLocalSinkState local_partition;
-};
-
-unique_ptr<GlobalSinkState> PhysicalAsOfJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<AsOfGlobalSinkState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalAsOfJoin::GetLocalSinkState(ExecutionContext &context) const {
-	// We only sink the RHS
-	auto &gsink = sink_state->Cast<AsOfGlobalSinkState>();
-	return make_uniq<AsOfLocalSinkState>(context.client, gsink.rhs_sink);
-}
-
-SinkResultType PhysicalAsOfJoin::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<AsOfLocalSinkState>();
-
-	lstate.Sink(chunk);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalAsOfJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<AsOfLocalSinkState>();
-	lstate.Combine();
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalAsOfJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<AsOfGlobalSinkState>();
-
-	// The data is all in so we can initialise the left partitioning.
-	const vector<unique_ptr<BaseStatistics>> partitions_stats;
-	gstate.lhs_sink = make_uniq<PartitionGlobalSinkState>(context, lhs_partitions, lhs_orders, children[0]->types,
-	                                                      partitions_stats, 0U);
-	gstate.lhs_sink->SyncPartitioning(gstate.rhs_sink);
-
-	// Find the first group to sort
-	if (!gstate.rhs_sink.HasMergeTasks() && EmptyResultIfRHSIsEmpty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Schedule all the sorts for maximum thread utilisation
-	auto new_event = make_shared_ptr<PartitionMergeEvent>(gstate.rhs_sink, pipeline, *this);
-	event.InsertEvent(std::move(new_event));
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class AsOfGlobalState : public GlobalOperatorState {
-public:
-	explicit AsOfGlobalState(AsOfGlobalSinkState &gsink) {
-		// for FULL/RIGHT OUTER JOIN, initialize right_outers to false for every tuple
-		auto &rhs_partition = gsink.rhs_sink;
-		auto &right_outers = gsink.right_outers;
-		right_outers.reserve(rhs_partition.hash_groups.size());
-		for (const auto &hash_group : rhs_partition.hash_groups) {
-			right_outers.emplace_back(OuterJoinMarker(gsink.is_outer));
-			right_outers.back().Initialize(hash_group->count);
-		}
-	}
-};
-
-unique_ptr<GlobalOperatorState> PhysicalAsOfJoin::GetGlobalOperatorState(ClientContext &context) const {
-	auto &gsink = sink_state->Cast<AsOfGlobalSinkState>();
-	return make_uniq<AsOfGlobalState>(gsink);
-}
-
-class AsOfLocalState : public CachingOperatorState {
-public:
-	AsOfLocalState(ClientContext &context, const PhysicalAsOfJoin &op)
-	    : context(context), allocator(Allocator::Get(context)), op(op), lhs_executor(context),
-	      left_outer(IsLeftOuterJoin(op.join_type)), fetch_next_left(true) {
-		lhs_keys.Initialize(allocator, op.join_key_types);
-		for (const auto &cond : op.conditions) {
-			lhs_executor.AddExpression(*cond.left);
-		}
-
-		lhs_payload.Initialize(allocator, op.children[0]->types);
-		lhs_sel.Initialize();
-		left_outer.Initialize(STANDARD_VECTOR_SIZE);
-
-		auto &gsink = op.sink_state->Cast<AsOfGlobalSinkState>();
-		lhs_partition_sink = gsink.RegisterBuffer(context);
-	}
-
-	bool Sink(DataChunk &input);
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk);
-
-	ClientContext &context;
-	Allocator &allocator;
-	const PhysicalAsOfJoin &op;
-
-	ExpressionExecutor lhs_executor;
-	DataChunk lhs_keys;
-	ValidityMask lhs_valid_mask;
-	SelectionVector lhs_sel;
-	DataChunk lhs_payload;
-
-	OuterJoinMarker left_outer;
-	bool fetch_next_left;
-
-	optional_ptr<PartitionLocalSinkState> lhs_partition_sink;
-};
-
-bool AsOfLocalState::Sink(DataChunk &input) {
-	//	Compute the join keys
-	lhs_keys.Reset();
-	lhs_executor.Execute(input, lhs_keys);
-	lhs_keys.Flatten();
-
-	//	Combine the NULLs
-	const auto count = input.size();
-	lhs_valid_mask.Reset();
-	for (auto col_idx : op.null_sensitive) {
-		auto &col = lhs_keys.data[col_idx];
-		UnifiedVectorFormat unified;
-		col.ToUnifiedFormat(count, unified);
-		lhs_valid_mask.Combine(unified.validity, count);
-	}
-
-	//	Convert the mask to a selection vector
-	//	and mark all the rows that cannot match for early return.
-	idx_t lhs_valid = 0;
-	const auto entry_count = lhs_valid_mask.EntryCount(count);
-	idx_t base_idx = 0;
-	left_outer.Reset();
-	for (idx_t entry_idx = 0; entry_idx < entry_count;) {
-		const auto validity_entry = lhs_valid_mask.GetValidityEntry(entry_idx++);
-		const auto next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-		if (ValidityMask::AllValid(validity_entry)) {
-			for (; base_idx < next; ++base_idx) {
-				lhs_sel.set_index(lhs_valid++, base_idx);
-				left_outer.SetMatch(base_idx);
-			}
-		} else if (ValidityMask::NoneValid(validity_entry)) {
-			base_idx = next;
-		} else {
-			const auto start = base_idx;
-			for (; base_idx < next; ++base_idx) {
-				if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-					lhs_sel.set_index(lhs_valid++, base_idx);
-					left_outer.SetMatch(base_idx);
-				}
-			}
-		}
-	}
-
-	//	Slice the keys to the ones we can match
-	lhs_payload.Reset();
-	if (lhs_valid == count) {
-		lhs_payload.Reference(input);
-		lhs_payload.SetCardinality(input);
-	} else {
-		lhs_payload.Slice(input, lhs_sel, lhs_valid);
-		lhs_payload.SetCardinality(lhs_valid);
-
-		//	Flush the ones that can't match
-		fetch_next_left = false;
-	}
-
-	lhs_partition_sink->Sink(lhs_payload);
-
-	return false;
-}
-
-OperatorResultType AsOfLocalState::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk) {
-	input.Verify();
-	Sink(input);
-
-	//	If there were any unmatchable rows, return them now so we can forget about them.
-	if (!fetch_next_left) {
-		fetch_next_left = true;
-		left_outer.ConstructLeftJoinResult(input, chunk);
-		left_outer.Reset();
-	}
-
-	//	Just keep asking for data and buffering it
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-OperatorResultType PhysicalAsOfJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                     GlobalOperatorState &gstate, OperatorState &lstate_p) const {
-	auto &gsink = sink_state->Cast<AsOfGlobalSinkState>();
-	auto &lstate = lstate_p.Cast<AsOfLocalState>();
-
-	if (gsink.rhs_sink.count == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gsink.has_null, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	return lstate.ExecuteInternal(context, input, chunk);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class AsOfProbeBuffer {
-public:
-	using Orders = vector<BoundOrderByNode>;
-
-	static bool IsExternal(ClientContext &context) {
-		return ClientConfig::GetConfig(context).force_external;
-	}
-
-	AsOfProbeBuffer(ClientContext &context, const PhysicalAsOfJoin &op);
-
-public:
-	void ResolveJoin(bool *found_matches, idx_t *matches = nullptr);
-	bool Scanning() const {
-		return lhs_scanner.get();
-	}
-	void BeginLeftScan(hash_t scan_bin);
-	bool NextLeft();
-	void EndScan();
-
-	// resolve joins that output max N elements (SEMI, ANTI, MARK)
-	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &chunk);
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	void ResolveComplexJoin(ExecutionContext &context, DataChunk &chunk);
-	//	Chunk may be empty
-	void GetData(ExecutionContext &context, DataChunk &chunk);
-	bool HasMoreData() const {
-		return !fetch_next_left || (lhs_scanner && lhs_scanner->Remaining());
-	}
-
-	ClientContext &context;
-	Allocator &allocator;
-	const PhysicalAsOfJoin &op;
-	BufferManager &buffer_manager;
-	const bool force_external;
-	const idx_t memory_per_thread;
-	Orders lhs_orders;
-
-	//	LHS scanning
-	SelectionVector lhs_sel;
-	optional_ptr<PartitionGlobalHashGroup> left_hash;
-	OuterJoinMarker left_outer;
-	unique_ptr<SBIterator> left_itr;
-	unique_ptr<PayloadScanner> lhs_scanner;
-	DataChunk lhs_payload;
-
-	//	RHS scanning
-	optional_ptr<PartitionGlobalHashGroup> right_hash;
-	optional_ptr<OuterJoinMarker> right_outer;
-	unique_ptr<SBIterator> right_itr;
-	unique_ptr<PayloadScanner> rhs_scanner;
-	DataChunk rhs_payload;
-
-	idx_t lhs_match_count;
-	bool fetch_next_left;
-};
-
-AsOfProbeBuffer::AsOfProbeBuffer(ClientContext &context, const PhysicalAsOfJoin &op)
-    : context(context), allocator(Allocator::Get(context)), op(op),
-      buffer_manager(BufferManager::GetBufferManager(context)), force_external(IsExternal(context)),
-      memory_per_thread(op.GetMaxThreadMemory(context)), left_outer(IsLeftOuterJoin(op.join_type)),
-      fetch_next_left(true) {
-	vector<unique_ptr<BaseStatistics>> partition_stats;
-	Orders partitions; // Not used.
-	PartitionGlobalSinkState::GenerateOrderings(partitions, lhs_orders, op.lhs_partitions, op.lhs_orders,
-	                                            partition_stats);
-
-	//	We sort the row numbers of the incoming block, not the rows
-	lhs_payload.Initialize(allocator, op.children[0]->types);
-	rhs_payload.Initialize(allocator, op.children[1]->types);
-
-	lhs_sel.Initialize();
-	left_outer.Initialize(STANDARD_VECTOR_SIZE);
-}
-
-void AsOfProbeBuffer::BeginLeftScan(hash_t scan_bin) {
-	auto &gsink = op.sink_state->Cast<AsOfGlobalSinkState>();
-	auto &lhs_sink = *gsink.lhs_sink;
-	const auto left_group = lhs_sink.bin_groups[scan_bin];
-	if (left_group >= lhs_sink.bin_groups.size()) {
-		return;
-	}
-
-	auto iterator_comp = ExpressionType::INVALID;
-	switch (op.comparison_type) {
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		iterator_comp = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		iterator_comp = ExpressionType::COMPARE_LESSTHAN;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		iterator_comp = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		iterator_comp = ExpressionType::COMPARE_GREATERTHAN;
-		break;
-	default:
-		throw NotImplementedException("Unsupported comparison type for ASOF join");
-	}
-
-	left_hash = lhs_sink.hash_groups[left_group].get();
-	auto &left_sort = *(left_hash->global_sort);
-	if (left_sort.sorted_blocks.empty()) {
-		return;
-	}
-	lhs_scanner = make_uniq<PayloadScanner>(left_sort, false);
-	left_itr = make_uniq<SBIterator>(left_sort, iterator_comp);
-
-	// We are only probing the corresponding right side bin, which may be empty
-	// If they are empty, we leave the iterator as null so we can emit left matches
-	auto &rhs_sink = gsink.rhs_sink;
-	const auto right_group = rhs_sink.bin_groups[scan_bin];
-	if (right_group < rhs_sink.bin_groups.size()) {
-		right_hash = rhs_sink.hash_groups[right_group].get();
-		right_outer = gsink.right_outers.data() + right_group;
-		auto &right_sort = *(right_hash->global_sort);
-		right_itr = make_uniq<SBIterator>(right_sort, iterator_comp);
-		rhs_scanner = make_uniq<PayloadScanner>(right_sort, false);
-	}
-}
-
-bool AsOfProbeBuffer::NextLeft() {
-	if (!HasMoreData()) {
-		return false;
-	}
-
-	//	Scan the next sorted chunk
-	lhs_payload.Reset();
-	left_itr->SetIndex(lhs_scanner->Scanned());
-	lhs_scanner->Scan(lhs_payload);
-
-	return true;
-}
-
-void AsOfProbeBuffer::EndScan() {
-	right_hash = nullptr;
-	right_itr.reset();
-	rhs_scanner.reset();
-	right_outer = nullptr;
-
-	left_hash = nullptr;
-	left_itr.reset();
-	lhs_scanner.reset();
-}
-
-void AsOfProbeBuffer::ResolveJoin(bool *found_match, idx_t *matches) {
-	// If there was no right partition, there are no matches
-	lhs_match_count = 0;
-	left_outer.Reset();
-	if (!right_itr) {
-		return;
-	}
-
-	const auto count = lhs_payload.size();
-	const auto left_base = left_itr->GetIndex();
-	//	Searching for right <= left
-	for (idx_t i = 0; i < count; ++i) {
-		left_itr->SetIndex(left_base + i);
-
-		//	If right > left, then there is no match
-		if (!right_itr->Compare(*left_itr)) {
-			continue;
-		}
-
-		// Exponential search forward for a non-matching value using radix iterators
-		// (We use exponential search to avoid thrashing the block manager on large probes)
-		idx_t bound = 1;
-		idx_t begin = right_itr->GetIndex();
-		right_itr->SetIndex(begin + bound);
-		while (right_itr->GetIndex() < right_hash->count) {
-			if (right_itr->Compare(*left_itr)) {
-				//	If right <= left, jump ahead
-				bound *= 2;
-				right_itr->SetIndex(begin + bound);
-			} else {
-				break;
-			}
-		}
-
-		//	Binary search for the first non-matching value using radix iterators
-		//	The previous value (which we know exists) is the match
-		auto first = begin + bound / 2;
-		auto last = MinValue<idx_t>(begin + bound, right_hash->count);
-		while (first < last) {
-			const auto mid = first + (last - first) / 2;
-			right_itr->SetIndex(mid);
-			if (right_itr->Compare(*left_itr)) {
-				//	If right <= left, new lower bound
-				first = mid + 1;
-			} else {
-				last = mid;
-			}
-		}
-		right_itr->SetIndex(--first);
-
-		//	Check partitions for strict equality
-		if (right_hash->ComparePartitions(*left_itr, *right_itr)) {
-			continue;
-		}
-
-		// Emit match data
-		right_outer->SetMatch(first);
-		left_outer.SetMatch(i);
-		if (found_match) {
-			found_match[i] = true;
-		}
-		if (matches) {
-			matches[i] = first;
-		}
-		lhs_sel.set_index(lhs_match_count++, i);
-	}
-}
-
-unique_ptr<OperatorState> PhysicalAsOfJoin::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<AsOfLocalState>(context.client, *this);
-}
-
-void AsOfProbeBuffer::ResolveSimpleJoin(ExecutionContext &context, DataChunk &chunk) {
-	// perform the actual join
-	bool found_match[STANDARD_VECTOR_SIZE] = {false};
-	ResolveJoin(found_match);
-
-	// now construct the result based on the join result
-	switch (op.join_type) {
-	case JoinType::SEMI:
-		PhysicalJoin::ConstructSemiJoinResult(lhs_payload, chunk, found_match);
-		break;
-	case JoinType::ANTI:
-		PhysicalJoin::ConstructAntiJoinResult(lhs_payload, chunk, found_match);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented join type for AsOf join");
-	}
-}
-
-void AsOfProbeBuffer::ResolveComplexJoin(ExecutionContext &context, DataChunk &chunk) {
-	// perform the actual join
-	idx_t matches[STANDARD_VECTOR_SIZE];
-	ResolveJoin(nullptr, matches);
-
-	for (idx_t i = 0; i < lhs_match_count; ++i) {
-		const auto idx = lhs_sel[i];
-		const auto match_pos = matches[idx];
-		// Skip to the range containing the match
-		while (match_pos >= rhs_scanner->Scanned()) {
-			rhs_payload.Reset();
-			rhs_scanner->Scan(rhs_payload);
-		}
-		// Append the individual values
-		// TODO: Batch the copies
-		const auto source_offset = match_pos - (rhs_scanner->Scanned() - rhs_payload.size());
-		for (column_t col_idx = 0; col_idx < op.right_projection_map.size(); ++col_idx) {
-			const auto rhs_idx = op.right_projection_map[col_idx];
-			auto &source = rhs_payload.data[rhs_idx];
-			auto &target = chunk.data[lhs_payload.ColumnCount() + col_idx];
-			VectorOperations::Copy(source, target, source_offset + 1, source_offset, i);
-		}
-	}
-
-	//	Slice the left payload into the result
-	for (column_t i = 0; i < lhs_payload.ColumnCount(); ++i) {
-		chunk.data[i].Slice(lhs_payload.data[i], lhs_sel, lhs_match_count);
-	}
-	chunk.SetCardinality(lhs_match_count);
-
-	//	If we are doing a left join, come back for the NULLs
-	fetch_next_left = !left_outer.Enabled();
-}
-
-void AsOfProbeBuffer::GetData(ExecutionContext &context, DataChunk &chunk) {
-	//	Handle dangling left join results from current chunk
-	if (!fetch_next_left) {
-		fetch_next_left = true;
-		if (left_outer.Enabled()) {
-			// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-			// have a match found
-			left_outer.ConstructLeftJoinResult(lhs_payload, chunk);
-			left_outer.Reset();
-		}
-		return;
-	}
-
-	//	Stop if there is no more data
-	if (!NextLeft()) {
-		return;
-	}
-
-	switch (op.join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-	case JoinType::MARK:
-		// simple joins can have max STANDARD_VECTOR_SIZE matches per chunk
-		ResolveSimpleJoin(context, chunk);
-		break;
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-	case JoinType::OUTER:
-		ResolveComplexJoin(context, chunk);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for as-of join!");
-	}
-}
-
-class AsOfGlobalSourceState : public GlobalSourceState {
-public:
-	explicit AsOfGlobalSourceState(AsOfGlobalSinkState &gsink_p)
-	    : gsink(gsink_p), next_combine(0), combined(0), merged(0), mergers(0), next_left(0), flushed(0), next_right(0) {
-	}
-
-	PartitionGlobalMergeStates &GetMergeStates() {
-		lock_guard<mutex> guard(lock);
-		if (!merge_states) {
-			merge_states = make_uniq<PartitionGlobalMergeStates>(*gsink.lhs_sink);
-		}
-		return *merge_states;
-	}
-
-	AsOfGlobalSinkState &gsink;
-	//! The next buffer to combine
-	atomic<size_t> next_combine;
-	//! The number of combined buffers
-	atomic<size_t> combined;
-	//! The number of combined buffers
-	atomic<size_t> merged;
-	//! The number of combined buffers
-	atomic<size_t> mergers;
-	//! The next buffer to flush
-	atomic<size_t> next_left;
-	//! The number of flushed buffers
-	atomic<size_t> flushed;
-	//! The right outer output read position.
-	atomic<idx_t> next_right;
-	//! The merge handler
-	mutex lock;
-	unique_ptr<PartitionGlobalMergeStates> merge_states;
-
-public:
-	idx_t MaxThreads() override {
-		return gsink.lhs_buffers.size();
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalAsOfJoin::GetGlobalSourceState(ClientContext &context) const {
-	auto &gsink = sink_state->Cast<AsOfGlobalSinkState>();
-	return make_uniq<AsOfGlobalSourceState>(gsink);
-}
-
-class AsOfLocalSourceState : public LocalSourceState {
-public:
-	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
-
-	AsOfLocalSourceState(AsOfGlobalSourceState &gsource, const PhysicalAsOfJoin &op, ClientContext &client_p);
-
-	//	Return true if we were not interrupted (another thread died)
-	bool CombineLeftPartitions();
-	bool MergeLeftPartitions();
-
-	idx_t BeginRightScan(const idx_t hash_bin);
-
-	AsOfGlobalSourceState &gsource;
-	ClientContext &client;
-
-	//! The left side partition being probed
-	AsOfProbeBuffer probe_buffer;
-
-	//! The read partition
-	idx_t hash_bin;
-	HashGroupPtr hash_group;
-	//! The read cursor
-	unique_ptr<PayloadScanner> scanner;
-	//! Pointer to the matches
-	const bool *found_match = {};
-};
-
-AsOfLocalSourceState::AsOfLocalSourceState(AsOfGlobalSourceState &gsource, const PhysicalAsOfJoin &op,
-                                           ClientContext &client_p)
-    : gsource(gsource), client(client_p), probe_buffer(gsource.gsink.lhs_sink->context, op) {
-	gsource.mergers++;
-}
-
-bool AsOfLocalSourceState::CombineLeftPartitions() {
-	const auto buffer_count = gsource.gsink.lhs_buffers.size();
-	while (gsource.combined < buffer_count && !client.interrupted) {
-		const auto next_combine = gsource.next_combine++;
-		if (next_combine < buffer_count) {
-			gsource.gsink.lhs_buffers[next_combine]->Combine();
-			++gsource.combined;
-		} else {
-			TaskScheduler::GetScheduler(client).YieldThread();
-		}
-	}
-
-	return !client.interrupted;
-}
-
-bool AsOfLocalSourceState::MergeLeftPartitions() {
-	PartitionGlobalMergeStates::Callback local_callback;
-	PartitionLocalMergeState local_merge(*gsource.gsink.lhs_sink);
-	gsource.GetMergeStates().ExecuteTask(local_merge, local_callback);
-	gsource.merged++;
-	while (gsource.merged < gsource.mergers && !client.interrupted) {
-		TaskScheduler::GetScheduler(client).YieldThread();
-	}
-	return !client.interrupted;
-}
-
-idx_t AsOfLocalSourceState::BeginRightScan(const idx_t hash_bin_p) {
-	hash_bin = hash_bin_p;
-
-	hash_group = std::move(gsource.gsink.rhs_sink.hash_groups[hash_bin]);
-	if (hash_group->global_sort->sorted_blocks.empty()) {
-		return 0;
-	}
-	scanner = make_uniq<PayloadScanner>(*hash_group->global_sort);
-	found_match = gsource.gsink.right_outers[hash_bin].GetMatches();
-
-	return scanner->Remaining();
-}
-
-unique_ptr<LocalSourceState> PhysicalAsOfJoin::GetLocalSourceState(ExecutionContext &context,
-                                                                   GlobalSourceState &gstate) const {
-	auto &gsource = gstate.Cast<AsOfGlobalSourceState>();
-	return make_uniq<AsOfLocalSourceState>(gsource, *this, context.client);
-}
-
-SourceResultType PhysicalAsOfJoin::GetData(ExecutionContext &context, DataChunk &chunk,
-                                           OperatorSourceInput &input) const {
-	auto &gsource = input.global_state.Cast<AsOfGlobalSourceState>();
-	auto &lsource = input.local_state.Cast<AsOfLocalSourceState>();
-	auto &rhs_sink = gsource.gsink.rhs_sink;
-	auto &client = context.client;
-
-	//	Step 1: Combine the partitions
-	if (!lsource.CombineLeftPartitions()) {
-		return SourceResultType::FINISHED;
-	}
-
-	//	Step 2: Sort on all threads
-	if (!lsource.MergeLeftPartitions()) {
-		return SourceResultType::FINISHED;
-	}
-
-	//	Step 3: Join the partitions
-	auto &lhs_sink = *gsource.gsink.lhs_sink;
-	const auto left_bins = lhs_sink.grouping_data ? lhs_sink.grouping_data->GetPartitions().size() : 1;
-	while (gsource.flushed < left_bins) {
-		//	Make sure we have something to flush
-		if (!lsource.probe_buffer.Scanning()) {
-			const auto left_bin = gsource.next_left++;
-			if (left_bin < left_bins) {
-				//	More to flush
-				lsource.probe_buffer.BeginLeftScan(left_bin);
-			} else if (!IsRightOuterJoin(join_type) || client.interrupted) {
-				return SourceResultType::FINISHED;
-			} else {
-				//	Wait for all threads to finish
-				//	TODO: How to implement a spin wait correctly?
-				//	Returning BLOCKED seems to hang the system.
-				TaskScheduler::GetScheduler(client).YieldThread();
-				continue;
-			}
-		}
-
-		lsource.probe_buffer.GetData(context, chunk);
-		if (chunk.size()) {
-			return SourceResultType::HAVE_MORE_OUTPUT;
-		} else if (lsource.probe_buffer.HasMoreData()) {
-			//	Join the next partition
-			continue;
-		} else {
-			lsource.probe_buffer.EndScan();
-			gsource.flushed++;
-		}
-	}
-
-	//	Step 4: Emit right join matches
-	if (!IsRightOuterJoin(join_type)) {
-		return SourceResultType::FINISHED;
-	}
-
-	auto &hash_groups = rhs_sink.hash_groups;
-	const auto right_groups = hash_groups.size();
-
-	DataChunk rhs_chunk;
-	rhs_chunk.Initialize(Allocator::Get(context.client), rhs_sink.payload_types);
-	SelectionVector rsel(STANDARD_VECTOR_SIZE);
-
-	while (chunk.size() == 0) {
-		//	Move to the next bin if we are done.
-		while (!lsource.scanner || !lsource.scanner->Remaining()) {
-			lsource.scanner.reset();
-			lsource.hash_group.reset();
-			auto hash_bin = gsource.next_right++;
-			if (hash_bin >= right_groups) {
-				return SourceResultType::FINISHED;
-			}
-
-			for (; hash_bin < hash_groups.size(); hash_bin = gsource.next_right++) {
-				if (hash_groups[hash_bin]) {
-					break;
-				}
-			}
-			lsource.BeginRightScan(hash_bin);
-		}
-		const auto rhs_position = lsource.scanner->Scanned();
-		lsource.scanner->Scan(rhs_chunk);
-
-		const auto count = rhs_chunk.size();
-		if (count == 0) {
-			return SourceResultType::FINISHED;
-		}
-
-		// figure out which tuples didn't find a match in the RHS
-		auto found_match = lsource.found_match;
-		idx_t result_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			if (!found_match[rhs_position + i]) {
-				rsel.set_index(result_count++, i);
-			}
-		}
-
-		if (result_count > 0) {
-			// if there were any tuples that didn't find a match, output them
-			const idx_t left_column_count = children[0]->types.size();
-			for (idx_t col_idx = 0; col_idx < left_column_count; ++col_idx) {
-				chunk.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(chunk.data[col_idx], true);
-			}
-			for (idx_t col_idx = 0; col_idx < right_projection_map.size(); ++col_idx) {
-				const auto rhs_idx = right_projection_map[col_idx];
-				chunk.data[left_column_count + col_idx].Slice(rhs_chunk.data[rhs_idx], rsel, result_count);
-			}
-			chunk.SetCardinality(result_count);
-			break;
-		}
-	}
-
-	return chunk.size() > 0 ? SourceResultType::HAVE_MORE_OUTPUT : SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp b/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp
deleted file mode 100644
index deabb6f89..000000000
--- a/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-#include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/join/outer_join_marker.hpp"
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/execution/operator/join/physical_cross_product.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-PhysicalBlockwiseNLJoin::PhysicalBlockwiseNLJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                                 unique_ptr<PhysicalOperator> right, unique_ptr<Expression> condition,
-                                                 JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalJoin(op, PhysicalOperatorType::BLOCKWISE_NL_JOIN, join_type, estimated_cardinality),
-      condition(std::move(condition)) {
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-	// MARK and SINGLE joins not handled
-	D_ASSERT(join_type != JoinType::MARK);
-	D_ASSERT(join_type != JoinType::SINGLE);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class BlockwiseNLJoinLocalState : public LocalSinkState {
-public:
-	BlockwiseNLJoinLocalState() {
-	}
-};
-
-class BlockwiseNLJoinGlobalState : public GlobalSinkState {
-public:
-	explicit BlockwiseNLJoinGlobalState(ClientContext &context, const PhysicalBlockwiseNLJoin &op)
-	    : right_chunks(context, op.children[1]->GetTypes()), right_outer(PropagatesBuildSide(op.join_type)) {
-	}
-
-	mutex lock;
-	ColumnDataCollection right_chunks;
-	OuterJoinMarker right_outer;
-};
-
-unique_ptr<GlobalSinkState> PhysicalBlockwiseNLJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<BlockwiseNLJoinGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalBlockwiseNLJoin::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<BlockwiseNLJoinLocalState>();
-}
-
-SinkResultType PhysicalBlockwiseNLJoin::Sink(ExecutionContext &context, DataChunk &chunk,
-                                             OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<BlockwiseNLJoinGlobalState>();
-	lock_guard<mutex> nl_lock(gstate.lock);
-	gstate.right_chunks.Append(chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalBlockwiseNLJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<BlockwiseNLJoinGlobalState>();
-	gstate.right_outer.Initialize(gstate.right_chunks.Count());
-
-	if (gstate.right_chunks.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class BlockwiseNLJoinState : public CachingOperatorState {
-public:
-	explicit BlockwiseNLJoinState(ExecutionContext &context, ColumnDataCollection &rhs,
-	                              const PhysicalBlockwiseNLJoin &op)
-	    : op(op), cross_product(rhs), left_outer(IsLeftOuterJoin(op.join_type)), match_sel(STANDARD_VECTOR_SIZE),
-	      executor(context.client, *op.condition) {
-		left_outer.Initialize(STANDARD_VECTOR_SIZE);
-		ResetMatches();
-	}
-
-	const PhysicalBlockwiseNLJoin &op;
-	CrossProductExecutor cross_product;
-	OuterJoinMarker left_outer;
-	SelectionVector match_sel;
-	ExpressionExecutor executor;
-	DataChunk intermediate_chunk;
-	bool found_match[STANDARD_VECTOR_SIZE];
-
-	void ResetMatches() {
-		if (op.join_type != JoinType::SEMI && op.join_type != JoinType::ANTI) {
-			return;
-		}
-		for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-			found_match[i] = false;
-		}
-	}
-};
-
-unique_ptr<OperatorState> PhysicalBlockwiseNLJoin::GetOperatorState(ExecutionContext &context) const {
-	auto &gstate = sink_state->Cast<BlockwiseNLJoinGlobalState>();
-	auto result = make_uniq<BlockwiseNLJoinState>(context, gstate.right_chunks, *this);
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		vector<LogicalType> intermediate_types;
-		for (auto &type : children[0]->types) {
-			intermediate_types.emplace_back(type);
-		}
-		for (auto &type : children[1]->types) {
-			intermediate_types.emplace_back(type);
-		}
-		result->intermediate_chunk.Initialize(Allocator::DefaultAllocator(), intermediate_types);
-	}
-	if (join_type == JoinType::RIGHT_ANTI || join_type == JoinType::RIGHT_SEMI) {
-		throw NotImplementedException("physical blockwise RIGHT_SEMI/RIGHT_ANTI join not yet implemented");
-	}
-	return std::move(result);
-}
-
-OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input,
-                                                            DataChunk &chunk, GlobalOperatorState &gstate_p,
-                                                            OperatorState &state_p) const {
-	D_ASSERT(input.size() > 0);
-	auto &state = state_p.Cast<BlockwiseNLJoinState>();
-	auto &gstate = sink_state->Cast<BlockwiseNLJoinGlobalState>();
-
-	if (gstate.right_chunks.Count() == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			PhysicalComparisonJoin::ConstructEmptyJoinResult(join_type, false, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	DataChunk *intermediate_chunk = &chunk;
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		intermediate_chunk = &state.intermediate_chunk;
-		intermediate_chunk->Reset();
-	}
-
-	// now perform the actual join
-	// we perform a cross product, then execute the expression directly on the cross product result
-	idx_t result_count = 0;
-
-	auto result = state.cross_product.Execute(input, *intermediate_chunk);
-	if (result == OperatorResultType::NEED_MORE_INPUT) {
-		// exhausted input, have to pull new LHS chunk
-		if (state.left_outer.Enabled()) {
-			// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-			// have a match found
-			state.left_outer.ConstructLeftJoinResult(input, *intermediate_chunk);
-			state.left_outer.Reset();
-		}
-
-		if (join_type == JoinType::SEMI) {
-			PhysicalJoin::ConstructSemiJoinResult(input, chunk, state.found_match);
-		}
-		if (join_type == JoinType::ANTI) {
-			PhysicalJoin::ConstructAntiJoinResult(input, chunk, state.found_match);
-		}
-		state.ResetMatches();
-
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-
-	// now perform the computation
-	result_count = state.executor.SelectExpression(*intermediate_chunk, state.match_sel);
-
-	// handle anti and semi joins with different logic
-	if (result_count > 0) {
-		// found a match!
-		// handle anti semi join conditions first
-		if (join_type == JoinType::ANTI || join_type == JoinType::SEMI) {
-			if (state.cross_product.ScanLHS()) {
-				state.found_match[state.cross_product.PositionInChunk()] = true;
-			} else {
-				for (idx_t i = 0; i < result_count; i++) {
-					state.found_match[state.match_sel.get_index(i)] = true;
-				}
-			}
-			intermediate_chunk->Reset();
-			// trick the loop to continue as semi and anti joins will never produce more output than
-			// the LHS cardinality
-			result_count = 0;
-		} else {
-			// check if the cross product is scanning the LHS or the RHS in its entirety
-			if (!state.cross_product.ScanLHS()) {
-				// set the match flags in the LHS
-				state.left_outer.SetMatches(state.match_sel, result_count);
-				// set the match flag in the RHS
-				gstate.right_outer.SetMatch(state.cross_product.ScanPosition() + state.cross_product.PositionInChunk());
-			} else {
-				// set the match flag in the LHS
-				state.left_outer.SetMatch(state.cross_product.PositionInChunk());
-				// set the match flags in the RHS
-				gstate.right_outer.SetMatches(state.match_sel, result_count, state.cross_product.ScanPosition());
-			}
-			intermediate_chunk->Slice(state.match_sel, result_count);
-		}
-	} else {
-		// no result: reset the chunk
-		intermediate_chunk->Reset();
-	}
-
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalBlockwiseNLJoin::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Join Type"] = EnumUtil::ToString(join_type);
-	result["Condition"] = condition->GetName();
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class BlockwiseNLJoinGlobalScanState : public GlobalSourceState {
-public:
-	explicit BlockwiseNLJoinGlobalScanState(const PhysicalBlockwiseNLJoin &op) : op(op) {
-		D_ASSERT(op.sink_state);
-		auto &sink = op.sink_state->Cast<BlockwiseNLJoinGlobalState>();
-		sink.right_outer.InitializeScan(sink.right_chunks, scan_state);
-	}
-
-	const PhysicalBlockwiseNLJoin &op;
-	OuterJoinGlobalScanState scan_state;
-
-public:
-	idx_t MaxThreads() override {
-		auto &sink = op.sink_state->Cast<BlockwiseNLJoinGlobalState>();
-		return sink.right_outer.MaxThreads();
-	}
-};
-
-class BlockwiseNLJoinLocalScanState : public LocalSourceState {
-public:
-	explicit BlockwiseNLJoinLocalScanState(const PhysicalBlockwiseNLJoin &op, BlockwiseNLJoinGlobalScanState &gstate) {
-		D_ASSERT(op.sink_state);
-		auto &sink = op.sink_state->Cast<BlockwiseNLJoinGlobalState>();
-		sink.right_outer.InitializeScan(gstate.scan_state, scan_state);
-	}
-
-	OuterJoinLocalScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalBlockwiseNLJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<BlockwiseNLJoinGlobalScanState>(*this);
-}
-
-unique_ptr<LocalSourceState> PhysicalBlockwiseNLJoin::GetLocalSourceState(ExecutionContext &context,
-                                                                          GlobalSourceState &gstate) const {
-	return make_uniq<BlockwiseNLJoinLocalScanState>(*this, gstate.Cast<BlockwiseNLJoinGlobalScanState>());
-}
-
-SourceResultType PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                  OperatorSourceInput &input) const {
-	D_ASSERT(PropagatesBuildSide(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = sink_state->Cast<BlockwiseNLJoinGlobalState>();
-	auto &gstate = input.global_state.Cast<BlockwiseNLJoinGlobalScanState>();
-	auto &lstate = input.local_state.Cast<BlockwiseNLJoinLocalScanState>();
-
-	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan chunks we still need to output
-	sink.right_outer.Scan(gstate.scan_state, lstate.scan_state, chunk);
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp b/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp
deleted file mode 100644
index 1091e2165..000000000
--- a/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-PhysicalComparisonJoin::PhysicalComparisonJoin(LogicalOperator &op, PhysicalOperatorType type,
-                                               vector<JoinCondition> conditions_p, JoinType join_type,
-                                               idx_t estimated_cardinality)
-    : PhysicalJoin(op, type, join_type, estimated_cardinality), conditions(std::move(conditions_p)) {
-	ReorderConditions(conditions);
-}
-
-InsertionOrderPreservingMap<string> PhysicalComparisonJoin::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Join Type"] = EnumUtil::ToString(join_type);
-	string condition_info;
-	for (idx_t i = 0; i < conditions.size(); i++) {
-		auto &join_condition = conditions[i];
-		if (i > 0) {
-			condition_info += "\n";
-		}
-		condition_info +=
-		    StringUtil::Format("%s %s %s", join_condition.left->GetName(),
-		                       ExpressionTypeToOperator(join_condition.comparison), join_condition.right->GetName());
-		// string op = ExpressionTypeToOperator(it.comparison);
-		// extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
-	}
-	result["Conditions"] = condition_info;
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-void PhysicalComparisonJoin::ReorderConditions(vector<JoinCondition> &conditions) {
-	// we reorder conditions so the ones with COMPARE_EQUAL occur first
-	// check if this is already the case
-	bool is_ordered = true;
-	bool seen_non_equal = false;
-	for (auto &cond : conditions) {
-		if (cond.comparison == ExpressionType::COMPARE_EQUAL ||
-		    cond.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			if (seen_non_equal) {
-				is_ordered = false;
-				break;
-			}
-		} else {
-			seen_non_equal = true;
-		}
-	}
-	if (is_ordered) {
-		// no need to re-order
-		return;
-	}
-	// gather lists of equal/other conditions
-	vector<JoinCondition> equal_conditions;
-	vector<JoinCondition> other_conditions;
-	for (auto &cond : conditions) {
-		if (cond.comparison == ExpressionType::COMPARE_EQUAL ||
-		    cond.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			equal_conditions.push_back(std::move(cond));
-		} else {
-			other_conditions.push_back(std::move(cond));
-		}
-	}
-	conditions.clear();
-	// reconstruct the sorted conditions
-	for (auto &cond : equal_conditions) {
-		conditions.push_back(std::move(cond));
-	}
-	for (auto &cond : other_conditions) {
-		conditions.push_back(std::move(cond));
-	}
-}
-
-void PhysicalComparisonJoin::ConstructEmptyJoinResult(JoinType join_type, bool has_null, DataChunk &input,
-                                                      DataChunk &result) {
-	// empty hash table, special case
-	if (join_type == JoinType::ANTI) {
-		// anti join with empty hash table, NOP join
-		// return the input
-		D_ASSERT(input.ColumnCount() == result.ColumnCount());
-		result.Reference(input);
-	} else if (join_type == JoinType::MARK) {
-		// MARK join with empty hash table
-		D_ASSERT(join_type == JoinType::MARK);
-		D_ASSERT(result.ColumnCount() == input.ColumnCount() + 1);
-		auto &result_vector = result.data.back();
-		D_ASSERT(result_vector.GetType() == LogicalType::BOOLEAN);
-		// for every data vector, we just reference the child chunk
-		result.SetCardinality(input);
-		for (idx_t i = 0; i < input.ColumnCount(); i++) {
-			result.data[i].Reference(input.data[i]);
-		}
-		// for the MARK vector:
-		// if the HT has no NULL values (i.e. empty result set), return a vector that has false for every input
-		// entry if the HT has NULL values (i.e. result set had values, but all were NULL), return a vector that
-		// has NULL for every input entry
-		if (!has_null) {
-			auto bool_result = FlatVector::GetData<bool>(result_vector);
-			for (idx_t i = 0; i < result.size(); i++) {
-				bool_result[i] = false;
-			}
-		} else {
-			FlatVector::Validity(result_vector).SetAllInvalid(result.size());
-		}
-	} else if (join_type == JoinType::LEFT || join_type == JoinType::OUTER || join_type == JoinType::SINGLE) {
-		// LEFT/FULL OUTER/SINGLE join and build side is empty
-		// for the LHS we reference the data
-		result.SetCardinality(input.size());
-		for (idx_t i = 0; i < input.ColumnCount(); i++) {
-			result.data[i].Reference(input.data[i]);
-		}
-		// for the RHS
-		for (idx_t k = input.ColumnCount(); k < result.ColumnCount(); k++) {
-			result.data[k].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result.data[k], true);
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_cross_product.cpp b/src/duckdb/src/execution/operator/join/physical_cross_product.cpp
deleted file mode 100644
index a1175017e..000000000
--- a/src/duckdb/src/execution/operator/join/physical_cross_product.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "duckdb/execution/operator/join/physical_cross_product.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/join/physical_join.hpp"
-
-namespace duckdb {
-
-PhysicalCrossProduct::PhysicalCrossProduct(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-                                           unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality)
-    : CachingPhysicalOperator(PhysicalOperatorType::CROSS_PRODUCT, std::move(types), estimated_cardinality) {
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class CrossProductGlobalState : public GlobalSinkState {
-public:
-	explicit CrossProductGlobalState(ClientContext &context, const PhysicalCrossProduct &op)
-	    : rhs_materialized(context, op.children[1]->GetTypes()) {
-		rhs_materialized.InitializeAppend(append_state);
-	}
-
-	ColumnDataCollection rhs_materialized;
-	ColumnDataAppendState append_state;
-	mutex rhs_lock;
-};
-
-unique_ptr<GlobalSinkState> PhysicalCrossProduct::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<CrossProductGlobalState>(context, *this);
-}
-
-SinkResultType PhysicalCrossProduct::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &sink = input.global_state.Cast<CrossProductGlobalState>();
-	lock_guard<mutex> client_guard(sink.rhs_lock);
-	sink.rhs_materialized.Append(sink.append_state, chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-CrossProductExecutor::CrossProductExecutor(ColumnDataCollection &rhs)
-    : rhs(rhs), position_in_chunk(0), initialized(false), finished(false) {
-	rhs.InitializeScanChunk(scan_chunk);
-}
-
-void CrossProductExecutor::Reset(DataChunk &input, DataChunk &output) {
-	initialized = true;
-	finished = false;
-	scan_input_chunk = false;
-	rhs.InitializeScan(scan_state);
-	position_in_chunk = 0;
-	scan_chunk.Reset();
-}
-
-bool CrossProductExecutor::NextValue(DataChunk &input, DataChunk &output) {
-	if (!initialized) {
-		// not initialized yet: initialize the scan
-		Reset(input, output);
-	}
-	position_in_chunk++;
-	idx_t chunk_size = scan_input_chunk ? input.size() : scan_chunk.size();
-	if (position_in_chunk < chunk_size) {
-		return true;
-	}
-	// fetch the next chunk
-	rhs.Scan(scan_state, scan_chunk);
-	position_in_chunk = 0;
-	if (scan_chunk.size() == 0) {
-		return false;
-	}
-	// the way the cross product works is that we keep one chunk constantly referenced
-	// while iterating over the other chunk one value at a time
-	// the second one is the chunk we are "scanning"
-
-	// for the engine, it is better if we emit larger chunks
-	// hence the chunk that we keep constantly referenced should be the larger of the two
-	scan_input_chunk = input.size() < scan_chunk.size();
-	return true;
-}
-
-OperatorResultType CrossProductExecutor::Execute(DataChunk &input, DataChunk &output) {
-	if (rhs.Count() == 0) {
-		// no RHS: empty result
-		return OperatorResultType::FINISHED;
-	}
-	if (!NextValue(input, output)) {
-		// ran out of entries on the RHS
-		// reset the RHS and move to the next chunk on the LHS
-		initialized = false;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-
-	// set up the constant chunk
-	auto &constant_chunk = scan_input_chunk ? scan_chunk : input;
-	auto col_count = constant_chunk.ColumnCount();
-	auto col_offset = scan_input_chunk ? input.ColumnCount() : 0;
-	output.SetCardinality(constant_chunk.size());
-	for (idx_t i = 0; i < col_count; i++) {
-		output.data[col_offset + i].Reference(constant_chunk.data[i]);
-	}
-
-	// for the chunk that we are scanning, scan a single value from that chunk
-	auto &scan = scan_input_chunk ? input : scan_chunk;
-	col_count = scan.ColumnCount();
-	col_offset = scan_input_chunk ? 0 : input.ColumnCount();
-	for (idx_t i = 0; i < col_count; i++) {
-		ConstantVector::Reference(output.data[col_offset + i], scan.data[i], position_in_chunk, scan.size());
-	}
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-class CrossProductOperatorState : public CachingOperatorState {
-public:
-	explicit CrossProductOperatorState(ColumnDataCollection &rhs) : executor(rhs) {
-	}
-
-	CrossProductExecutor executor;
-};
-
-unique_ptr<OperatorState> PhysicalCrossProduct::GetOperatorState(ExecutionContext &context) const {
-	auto &sink = sink_state->Cast<CrossProductGlobalState>();
-	return make_uniq<CrossProductOperatorState>(sink.rhs_materialized);
-}
-
-OperatorResultType PhysicalCrossProduct::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                         GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = state_p.Cast<CrossProductOperatorState>();
-	return state.executor.Execute(input, chunk);
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalCrossProduct::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *this);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalCrossProduct::GetSources() const {
-	return children[0]->GetSources();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_delim_join.cpp b/src/duckdb/src/execution/operator/join/physical_delim_join.cpp
deleted file mode 100644
index 1da39904d..000000000
--- a/src/duckdb/src/execution/operator/join/physical_delim_join.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-
-namespace duckdb {
-
-PhysicalDelimJoin::PhysicalDelimJoin(PhysicalOperatorType type, vector<LogicalType> types,
-                                     unique_ptr<PhysicalOperator> original_join,
-                                     vector<const_reference<PhysicalOperator>> delim_scans, idx_t estimated_cardinality,
-                                     optional_idx delim_idx)
-    : PhysicalOperator(type, std::move(types), estimated_cardinality), join(std::move(original_join)),
-      delim_scans(std::move(delim_scans)), delim_idx(delim_idx) {
-	D_ASSERT(type == PhysicalOperatorType::LEFT_DELIM_JOIN || type == PhysicalOperatorType::RIGHT_DELIM_JOIN);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalDelimJoin::GetChildren() const {
-	vector<const_reference<PhysicalOperator>> result;
-	for (auto &child : children) {
-		result.push_back(*child);
-	}
-	result.push_back(*join);
-	result.push_back(*distinct);
-	return result;
-}
-
-InsertionOrderPreservingMap<string> PhysicalDelimJoin::ParamsToString() const {
-	auto result = join->ParamsToString();
-	result["Delim Index"] = StringUtil::Format("%llu", delim_idx.GetIndex());
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_hash_join.cpp b/src/duckdb/src/execution/operator/join/physical_hash_join.cpp
deleted file mode 100644
index 3c01a4acf..000000000
--- a/src/duckdb/src/execution/operator/join/physical_hash_join.cpp
+++ /dev/null
@@ -1,1391 +0,0 @@
-#include "duckdb/execution/operator/join/physical_hash_join.hpp"
-
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/types/value_map.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/optimizer/filter_combiner.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/in_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/temporary_memory_manager.hpp"
-
-namespace duckdb {
-
-PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                   unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                   const vector<idx_t> &left_projection_map, const vector<idx_t> &right_projection_map,
-                                   vector<LogicalType> delim_types, idx_t estimated_cardinality,
-                                   unique_ptr<JoinFilterPushdownInfo> pushdown_info_p)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::HASH_JOIN, std::move(cond), join_type, estimated_cardinality),
-      delim_types(std::move(delim_types)) {
-
-	filter_pushdown = std::move(pushdown_info_p);
-
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-
-	// Collect condition types, and which conditions are just references (so we won't duplicate them in the payload)
-	unordered_map<idx_t, idx_t> build_columns_in_conditions;
-	for (idx_t cond_idx = 0; cond_idx < conditions.size(); cond_idx++) {
-		auto &condition = conditions[cond_idx];
-		condition_types.push_back(condition.left->return_type);
-		if (condition.right->GetExpressionClass() == ExpressionClass::BOUND_REF) {
-			build_columns_in_conditions.emplace(condition.right->Cast<BoundReferenceExpression>().index, cond_idx);
-		}
-	}
-
-	auto &lhs_input_types = children[0]->GetTypes();
-
-	// Create a projection map for the LHS (if it was empty), for convenience
-	lhs_output_columns.col_idxs = left_projection_map;
-	if (lhs_output_columns.col_idxs.empty()) {
-		lhs_output_columns.col_idxs.reserve(lhs_input_types.size());
-		for (idx_t i = 0; i < lhs_input_types.size(); i++) {
-			lhs_output_columns.col_idxs.emplace_back(i);
-		}
-	}
-
-	for (auto &lhs_col : lhs_output_columns.col_idxs) {
-		auto &lhs_col_type = lhs_input_types[lhs_col];
-		lhs_output_columns.col_types.push_back(lhs_col_type);
-	}
-
-	// For ANTI, SEMI and MARK join, we only need to store the keys, so for these the payload/RHS types are empty
-	if (join_type == JoinType::ANTI || join_type == JoinType::SEMI || join_type == JoinType::MARK) {
-		return;
-	}
-
-	auto &rhs_input_types = children[1]->GetTypes();
-
-	// Create a projection map for the RHS (if it was empty), for convenience
-	auto right_projection_map_copy = right_projection_map;
-	if (right_projection_map_copy.empty()) {
-		right_projection_map_copy.reserve(rhs_input_types.size());
-		for (idx_t i = 0; i < rhs_input_types.size(); i++) {
-			right_projection_map_copy.emplace_back(i);
-		}
-	}
-
-	// Now fill payload expressions/types and RHS columns/types
-	for (auto &rhs_col : right_projection_map_copy) {
-		auto &rhs_col_type = rhs_input_types[rhs_col];
-
-		auto it = build_columns_in_conditions.find(rhs_col);
-		if (it == build_columns_in_conditions.end()) {
-			// This rhs column is not a join key
-			payload_columns.col_idxs.push_back(rhs_col);
-			payload_columns.col_types.push_back(rhs_col_type);
-			rhs_output_columns.col_idxs.push_back(condition_types.size() + payload_columns.col_types.size() - 1);
-		} else {
-			// This rhs column is a join key
-			rhs_output_columns.col_idxs.push_back(it->second);
-		}
-		rhs_output_columns.col_types.push_back(rhs_col_type);
-	}
-}
-
-PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                   unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                   idx_t estimated_cardinality)
-    : PhysicalHashJoin(op, std::move(left), std::move(right), std::move(cond), join_type, {}, {}, {},
-                       estimated_cardinality, nullptr) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-JoinFilterGlobalState::~JoinFilterGlobalState() {
-}
-
-JoinFilterLocalState::~JoinFilterLocalState() {
-}
-
-unique_ptr<JoinFilterGlobalState> JoinFilterPushdownInfo::GetGlobalState(ClientContext &context,
-                                                                         const PhysicalOperator &op) const {
-	// clear any previously set filters
-	// we can have previous filters for this operator in case of e.g. recursive CTEs
-	for (auto &info : probe_info) {
-		info.dynamic_filters->ClearFilters(op);
-	}
-	auto result = make_uniq<JoinFilterGlobalState>();
-	result->global_aggregate_state =
-	    make_uniq<GlobalUngroupedAggregateState>(BufferAllocator::Get(context), min_max_aggregates);
-	return result;
-}
-
-class HashJoinGlobalSinkState : public GlobalSinkState {
-public:
-	HashJoinGlobalSinkState(const PhysicalHashJoin &op_p, ClientContext &context_p)
-	    : context(context_p), op(op_p),
-	      num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads())),
-	      temporary_memory_state(TemporaryMemoryManager::Get(context).Register(context)), finalized(false),
-	      active_local_states(0), total_size(0), max_partition_size(0), max_partition_count(0),
-	      probe_side_requirement(0), scanned_data(false) {
-		hash_table = op.InitializeHashTable(context);
-
-		// For perfect hash join
-		perfect_join_executor = make_uniq<PerfectHashJoinExecutor>(op, *hash_table);
-		bool use_perfect_hash = false;
-		if (op.conditions.size() == 1 && !op.join_stats.empty() && op.join_stats[1] &&
-		    TypeIsIntegral(op.join_stats[1]->GetType().InternalType()) && NumericStats::HasMinMax(*op.join_stats[1])) {
-			use_perfect_hash = perfect_join_executor->CanDoPerfectHashJoin(op, NumericStats::Min(*op.join_stats[1]),
-			                                                               NumericStats::Max(*op.join_stats[1]));
-		}
-		// For external hash join
-		external = ClientConfig::GetConfig(context).GetSetting<DebugForceExternalSetting>(context);
-		// Set probe types
-		probe_types = op.children[0]->types;
-		probe_types.emplace_back(LogicalType::HASH);
-
-		if (op.filter_pushdown) {
-			if (op.filter_pushdown->probe_info.empty() && use_perfect_hash) {
-				// Only computing min/max to check for perfect HJ, but we already can
-				skip_filter_pushdown = true;
-			}
-			global_filter_state = op.filter_pushdown->GetGlobalState(context, op);
-		}
-	}
-
-	void ScheduleFinalize(Pipeline &pipeline, Event &event);
-	void InitializeProbeSpill();
-
-public:
-	ClientContext &context;
-	const PhysicalHashJoin &op;
-
-	const idx_t num_threads;
-	//! Temporary memory state for managing this operator's memory usage
-	unique_ptr<TemporaryMemoryState> temporary_memory_state;
-
-	//! Global HT used by the join
-	unique_ptr<JoinHashTable> hash_table;
-	//! The perfect hash join executor (if any)
-	unique_ptr<PerfectHashJoinExecutor> perfect_join_executor;
-	//! Whether or not the hash table has been finalized
-	bool finalized;
-	//! The number of active local states
-	atomic<idx_t> active_local_states;
-
-	//! Whether we are doing an external + some sizes
-	bool external;
-	idx_t total_size;
-	idx_t max_partition_size;
-	idx_t max_partition_count;
-	idx_t probe_side_requirement;
-
-	//! Hash tables built by each thread
-	vector<unique_ptr<JoinHashTable>> local_hash_tables;
-
-	//! Excess probe data gathered during Sink
-	vector<LogicalType> probe_types;
-	unique_ptr<JoinHashTable::ProbeSpill> probe_spill;
-
-	//! Whether or not we have started scanning data using GetData
-	atomic<bool> scanned_data;
-
-	bool skip_filter_pushdown = false;
-	unique_ptr<JoinFilterGlobalState> global_filter_state;
-};
-
-unique_ptr<JoinFilterLocalState> JoinFilterPushdownInfo::GetLocalState(JoinFilterGlobalState &gstate) const {
-	auto result = make_uniq<JoinFilterLocalState>();
-	result->local_aggregate_state = make_uniq<LocalUngroupedAggregateState>(*gstate.global_aggregate_state);
-	return result;
-}
-
-class HashJoinLocalSinkState : public LocalSinkState {
-public:
-	HashJoinLocalSinkState(const PhysicalHashJoin &op, ClientContext &context, HashJoinGlobalSinkState &gstate)
-	    : join_key_executor(context) {
-		auto &allocator = BufferAllocator::Get(context);
-
-		for (auto &cond : op.conditions) {
-			join_key_executor.AddExpression(*cond.right);
-		}
-		join_keys.Initialize(allocator, op.condition_types);
-
-		if (!op.payload_columns.col_types.empty()) {
-			payload_chunk.Initialize(allocator, op.payload_columns.col_types);
-		}
-
-		hash_table = op.InitializeHashTable(context);
-		hash_table->GetSinkCollection().InitializeAppendState(append_state);
-
-		gstate.active_local_states++;
-
-		if (op.filter_pushdown) {
-			local_filter_state = op.filter_pushdown->GetLocalState(*gstate.global_filter_state);
-		}
-	}
-
-public:
-	PartitionedTupleDataAppendState append_state;
-
-	ExpressionExecutor join_key_executor;
-	DataChunk join_keys;
-
-	DataChunk payload_chunk;
-
-	//! Thread-local HT
-	unique_ptr<JoinHashTable> hash_table;
-
-	unique_ptr<JoinFilterLocalState> local_filter_state;
-};
-
-unique_ptr<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &context) const {
-	auto result = make_uniq<JoinHashTable>(context, conditions, payload_columns.col_types, join_type,
-	                                       rhs_output_columns.col_idxs);
-	if (!delim_types.empty() && join_type == JoinType::MARK) {
-		// correlated MARK join
-		if (delim_types.size() + 1 == conditions.size()) {
-			// the correlated MARK join has one more condition than the amount of correlated columns
-			// this is the case in a correlated ANY() expression
-			// in this case we need to keep track of additional entries, namely:
-			// - (1) the total amount of elements per group
-			// - (2) the amount of non-null elements per group
-			// we need these to correctly deal with the cases of either:
-			// - (1) the group being empty [in which case the result is always false, even if the comparison is NULL]
-			// - (2) the group containing a NULL value [in which case FALSE becomes NULL]
-			auto &info = result->correlated_mark_join_info;
-
-			vector<LogicalType> delim_payload_types;
-			vector<BoundAggregateExpression *> correlated_aggregates;
-			unique_ptr<BoundAggregateExpression> aggr;
-
-			// jury-rigging the GroupedAggregateHashTable
-			// we need a count_star and a count to get counts with and without NULLs
-
-			FunctionBinder function_binder(context);
-			aggr = function_binder.BindAggregateFunction(CountStarFun::GetFunction(), {}, nullptr,
-			                                             AggregateType::NON_DISTINCT);
-			correlated_aggregates.push_back(&*aggr);
-			delim_payload_types.push_back(aggr->return_type);
-			info.correlated_aggregates.push_back(std::move(aggr));
-
-			auto count_fun = CountFunctionBase::GetFunction();
-			vector<unique_ptr<Expression>> children;
-			// this is a dummy but we need it to make the hash table understand whats going on
-			children.push_back(make_uniq_base<Expression, BoundReferenceExpression>(count_fun.return_type, 0U));
-			aggr = function_binder.BindAggregateFunction(count_fun, std::move(children), nullptr,
-			                                             AggregateType::NON_DISTINCT);
-			correlated_aggregates.push_back(&*aggr);
-			delim_payload_types.push_back(aggr->return_type);
-			info.correlated_aggregates.push_back(std::move(aggr));
-
-			auto &allocator = BufferAllocator::Get(context);
-			info.correlated_counts = make_uniq<GroupedAggregateHashTable>(context, allocator, delim_types,
-			                                                              delim_payload_types, correlated_aggregates);
-			info.correlated_types = delim_types;
-			info.group_chunk.Initialize(allocator, delim_types);
-			info.result_chunk.Initialize(allocator, delim_payload_types);
-		}
-	}
-	return result;
-}
-
-unique_ptr<GlobalSinkState> PhysicalHashJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<HashJoinGlobalSinkState>(*this, context);
-}
-
-unique_ptr<LocalSinkState> PhysicalHashJoin::GetLocalSinkState(ExecutionContext &context) const {
-	auto &gstate = sink_state->Cast<HashJoinGlobalSinkState>();
-	return make_uniq<HashJoinLocalSinkState>(*this, context.client, gstate);
-}
-
-void JoinFilterPushdownInfo::Sink(DataChunk &chunk, JoinFilterLocalState &lstate) const {
-	// if we are pushing any filters into a probe-side, compute the min/max over the columns that we are pushing
-	for (idx_t pushdown_idx = 0; pushdown_idx < join_condition.size(); pushdown_idx++) {
-		auto join_condition_idx = join_condition[pushdown_idx];
-		for (idx_t i = 0; i < 2; i++) {
-			idx_t aggr_idx = pushdown_idx * 2 + i;
-			lstate.local_aggregate_state->Sink(chunk, join_condition_idx, aggr_idx);
-		}
-	}
-}
-
-SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<HashJoinGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<HashJoinLocalSinkState>();
-
-	// resolve the join keys for the right chunk
-	lstate.join_keys.Reset();
-	lstate.join_key_executor.Execute(chunk, lstate.join_keys);
-
-	if (filter_pushdown && !gstate.skip_filter_pushdown) {
-		filter_pushdown->Sink(lstate.join_keys, *lstate.local_filter_state);
-	}
-
-	if (payload_columns.col_types.empty()) { // there are only keys: place an empty chunk in the payload
-		lstate.payload_chunk.SetCardinality(chunk.size());
-	} else { // there are payload columns
-		lstate.payload_chunk.ReferenceColumns(chunk, payload_columns.col_idxs);
-	}
-
-	// build the HT
-	lstate.hash_table->Build(lstate.append_state, lstate.join_keys, lstate.payload_chunk);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void JoinFilterPushdownInfo::Combine(JoinFilterGlobalState &gstate, JoinFilterLocalState &lstate) const {
-	gstate.global_aggregate_state->Combine(*lstate.local_aggregate_state);
-}
-
-SinkCombineResultType PhysicalHashJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<HashJoinGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<HashJoinLocalSinkState>();
-
-	lstate.hash_table->GetSinkCollection().FlushAppendState(lstate.append_state);
-	auto guard = gstate.Lock();
-	gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
-	if (gstate.local_hash_tables.size() == gstate.active_local_states) {
-		// Set to 0 until PrepareFinalize
-		gstate.temporary_memory_state->SetZero();
-	}
-
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-	if (filter_pushdown && !gstate.skip_filter_pushdown) {
-		filter_pushdown->Combine(*gstate.global_filter_state, *lstate.local_filter_state);
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-static idx_t GetTupleWidth(const vector<LogicalType> &types, bool &all_constant) {
-	idx_t tuple_width = 0;
-	all_constant = true;
-	for (auto &type : types) {
-		tuple_width += GetTypeIdSize(type.InternalType());
-		all_constant &= TypeIsConstantSize(type.InternalType());
-	}
-	return tuple_width + AlignValue(types.size()) / 8 + GetTypeIdSize(PhysicalType::UINT64);
-}
-
-static idx_t GetPartitioningSpaceRequirement(ClientContext &context, const vector<LogicalType> &types,
-                                             const idx_t radix_bits, const idx_t num_threads) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	bool all_constant;
-	idx_t tuple_width = GetTupleWidth(types, all_constant);
-
-	auto tuples_per_block = buffer_manager.GetBlockSize() / tuple_width;
-	auto blocks_per_chunk = (STANDARD_VECTOR_SIZE + tuples_per_block) / tuples_per_block + 1;
-	if (!all_constant) {
-		blocks_per_chunk += 2;
-	}
-	auto size_per_partition = blocks_per_chunk * buffer_manager.GetBlockAllocSize();
-	auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-
-	return num_threads * num_partitions * size_per_partition;
-}
-
-void PhysicalHashJoin::PrepareFinalize(ClientContext &context, GlobalSinkState &global_state) const {
-	auto &gstate = global_state.Cast<HashJoinGlobalSinkState>();
-	const auto &ht = *gstate.hash_table;
-
-	gstate.total_size =
-	    ht.GetTotalSize(gstate.local_hash_tables, gstate.max_partition_size, gstate.max_partition_count);
-	gstate.probe_side_requirement =
-	    GetPartitioningSpaceRequirement(context, children[0]->types, ht.GetRadixBits(), gstate.num_threads);
-	const auto max_partition_ht_size =
-	    gstate.max_partition_size + JoinHashTable::PointerTableSize(gstate.max_partition_count);
-	gstate.temporary_memory_state->SetMinimumReservation(max_partition_ht_size + gstate.probe_side_requirement);
-
-	bool all_constant;
-	gstate.temporary_memory_state->SetMaterializationPenalty(GetTupleWidth(children[0]->types, all_constant));
-	gstate.temporary_memory_state->SetRemainingSize(gstate.total_size);
-}
-
-class HashJoinFinalizeTask : public ExecutorTask {
-public:
-	HashJoinFinalizeTask(shared_ptr<Event> event_p, ClientContext &context, HashJoinGlobalSinkState &sink_p,
-	                     idx_t chunk_idx_from_p, idx_t chunk_idx_to_p, bool parallel_p, const PhysicalOperator &op_p)
-	    : ExecutorTask(context, std::move(event_p), op_p), sink(sink_p), chunk_idx_from(chunk_idx_from_p),
-	      chunk_idx_to(chunk_idx_to_p), parallel(parallel_p) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		sink.hash_table->Finalize(chunk_idx_from, chunk_idx_to, parallel);
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	HashJoinGlobalSinkState &sink;
-	idx_t chunk_idx_from;
-	idx_t chunk_idx_to;
-	bool parallel;
-};
-
-class HashJoinFinalizeEvent : public BasePipelineEvent {
-public:
-	HashJoinFinalizeEvent(Pipeline &pipeline_p, HashJoinGlobalSinkState &sink)
-	    : BasePipelineEvent(pipeline_p), sink(sink) {
-	}
-
-	HashJoinGlobalSinkState &sink;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline->GetClientContext();
-
-		vector<shared_ptr<Task>> finalize_tasks;
-		auto &ht = *sink.hash_table;
-		const auto chunk_count = ht.GetDataCollection().ChunkCount();
-		const auto num_threads = NumericCast<idx_t>(sink.num_threads);
-
-		// If the data is very skewed (many of the exact same key), our finalize will become slow,
-		// due to completely slamming the same atomic using compare-and-swaps.
-		// We can detect this because we partition the data, and go for a single-threaded finalize instead.
-		const auto max_partition_ht_size =
-		    sink.max_partition_size + JoinHashTable::PointerTableSize(sink.max_partition_count);
-		const auto skew = static_cast<double>(max_partition_ht_size) / static_cast<double>(sink.total_size);
-
-		if (num_threads == 1 || (ht.Count() < PARALLEL_CONSTRUCT_THRESHOLD && skew > SKEW_SINGLE_THREADED_THRESHOLD &&
-		                         !context.config.verify_parallelism)) {
-			// Single-threaded finalize
-			finalize_tasks.push_back(
-			    make_uniq<HashJoinFinalizeTask>(shared_from_this(), context, sink, 0U, chunk_count, false, sink.op));
-		} else {
-			// Parallel finalize
-			const idx_t chunks_per_task = context.config.verify_parallelism ? 1 : CHUNKS_PER_TASK;
-			for (idx_t chunk_idx = 0; chunk_idx < chunk_count; chunk_idx += chunks_per_task) {
-				auto chunk_idx_to = MinValue<idx_t>(chunk_idx + chunks_per_task, chunk_count);
-				finalize_tasks.push_back(make_uniq<HashJoinFinalizeTask>(shared_from_this(), context, sink, chunk_idx,
-				                                                         chunk_idx_to, true, sink.op));
-			}
-		}
-		SetTasks(std::move(finalize_tasks));
-	}
-
-	void FinishEvent() override {
-		sink.hash_table->GetDataCollection().VerifyEverythingPinned();
-		sink.hash_table->finalized = true;
-	}
-
-	static constexpr idx_t PARALLEL_CONSTRUCT_THRESHOLD = 1048576;
-	static constexpr idx_t CHUNKS_PER_TASK = 64;
-	static constexpr double SKEW_SINGLE_THREADED_THRESHOLD = 0.33;
-};
-
-void HashJoinGlobalSinkState::ScheduleFinalize(Pipeline &pipeline, Event &event) {
-	if (hash_table->Count() == 0) {
-		hash_table->finalized = true;
-		return;
-	}
-	hash_table->InitializePointerTable();
-	auto new_event = make_shared_ptr<HashJoinFinalizeEvent>(pipeline, *this);
-	event.InsertEvent(std::move(new_event));
-}
-
-void HashJoinGlobalSinkState::InitializeProbeSpill() {
-	auto guard = Lock();
-	if (!probe_spill) {
-		probe_spill = make_uniq<JoinHashTable::ProbeSpill>(*hash_table, context, probe_types);
-	}
-}
-
-class HashJoinRepartitionTask : public ExecutorTask {
-public:
-	HashJoinRepartitionTask(shared_ptr<Event> event_p, ClientContext &context, JoinHashTable &global_ht,
-	                        JoinHashTable &local_ht, const PhysicalOperator &op_p)
-	    : ExecutorTask(context, std::move(event_p), op_p), global_ht(global_ht), local_ht(local_ht) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		local_ht.Repartition(global_ht);
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	JoinHashTable &global_ht;
-	JoinHashTable &local_ht;
-};
-
-class HashJoinRepartitionEvent : public BasePipelineEvent {
-public:
-	HashJoinRepartitionEvent(Pipeline &pipeline_p, const PhysicalHashJoin &op_p, HashJoinGlobalSinkState &sink,
-	                         vector<unique_ptr<JoinHashTable>> &local_hts)
-	    : BasePipelineEvent(pipeline_p), op(op_p), sink(sink), local_hts(local_hts) {
-	}
-
-	const PhysicalHashJoin &op;
-	HashJoinGlobalSinkState &sink;
-	vector<unique_ptr<JoinHashTable>> &local_hts;
-
-public:
-	void Schedule() override {
-		D_ASSERT(sink.hash_table->GetRadixBits() > JoinHashTable::INITIAL_RADIX_BITS);
-		auto block_size = sink.hash_table->buffer_manager.GetBlockSize();
-
-		idx_t total_size = 0;
-		idx_t total_count = 0;
-		for (auto &local_ht : local_hts) {
-			auto &sink_collection = local_ht->GetSinkCollection();
-			total_size += sink_collection.SizeInBytes();
-			total_count += sink_collection.Count();
-		}
-		auto total_blocks = (total_size + block_size - 1) / block_size;
-		auto count_per_block = total_count / total_blocks;
-		auto blocks_per_vector = MaxValue<idx_t>(STANDARD_VECTOR_SIZE / count_per_block, 2);
-
-		// Assume 8 blocks per partition per thread (4 input, 4 output)
-		auto partition_multiplier =
-		    RadixPartitioning::NumberOfPartitions(sink.hash_table->GetRadixBits() - JoinHashTable::INITIAL_RADIX_BITS);
-		auto thread_memory = 2 * blocks_per_vector * partition_multiplier * block_size;
-		auto repartition_threads = MaxValue<idx_t>(sink.temporary_memory_state->GetReservation() / thread_memory, 1);
-
-		if (repartition_threads < local_hts.size()) {
-			// Limit the number of threads working on repartitioning based on our memory reservation
-			for (idx_t thread_idx = repartition_threads; thread_idx < local_hts.size(); thread_idx++) {
-				local_hts[thread_idx % repartition_threads]->Merge(*local_hts[thread_idx]);
-			}
-			local_hts.resize(repartition_threads);
-		}
-
-		auto &context = pipeline->GetClientContext();
-
-		vector<shared_ptr<Task>> partition_tasks;
-		partition_tasks.reserve(local_hts.size());
-		for (auto &local_ht : local_hts) {
-			partition_tasks.push_back(
-			    make_uniq<HashJoinRepartitionTask>(shared_from_this(), context, *sink.hash_table, *local_ht, op));
-		}
-		SetTasks(std::move(partition_tasks));
-	}
-
-	void FinishEvent() override {
-		local_hts.clear();
-
-		// Minimum reservation is now the new smallest partition size
-		const auto num_partitions = RadixPartitioning::NumberOfPartitions(sink.hash_table->GetRadixBits());
-		vector<idx_t> partition_sizes(num_partitions, 0);
-		vector<idx_t> partition_counts(num_partitions, 0);
-		sink.total_size = sink.hash_table->GetTotalSize(partition_sizes, partition_counts, sink.max_partition_size,
-		                                                sink.max_partition_count);
-		sink.probe_side_requirement =
-		    GetPartitioningSpaceRequirement(sink.context, op.types, sink.hash_table->GetRadixBits(), sink.num_threads);
-
-		sink.temporary_memory_state->SetMinimumReservation(sink.max_partition_size +
-		                                                   JoinHashTable::PointerTableSize(sink.max_partition_count) +
-		                                                   sink.probe_side_requirement);
-		sink.temporary_memory_state->UpdateReservation(executor.context);
-
-		D_ASSERT(sink.temporary_memory_state->GetReservation() >= sink.probe_side_requirement);
-		sink.hash_table->PrepareExternalFinalize(sink.temporary_memory_state->GetReservation() -
-		                                         sink.probe_side_requirement);
-		sink.ScheduleFinalize(*pipeline, *this);
-	}
-};
-
-void JoinFilterPushdownInfo::PushInFilter(const JoinFilterPushdownFilter &info, JoinHashTable &ht,
-                                          const PhysicalOperator &op, idx_t filter_idx, idx_t filter_col_idx) const {
-	// generate a "OR" filter (i.e. x=1 OR x=535 OR x=997)
-	// first scan the entire vector at the probe side
-	// FIXME: this code is duplicated from PerfectHashJoinExecutor::FullScanHashTable
-	auto build_idx = join_condition[filter_idx];
-	auto &data_collection = ht.GetDataCollection();
-
-	Vector tuples_addresses(LogicalType::POINTER, ht.Count()); // allocate space for all the tuples
-
-	JoinHTScanState join_ht_state(data_collection, 0, data_collection.ChunkCount(),
-	                              TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
-
-	// Go through all the blocks and fill the keys addresses
-	idx_t key_count = ht.FillWithHTOffsets(join_ht_state, tuples_addresses);
-
-	// Scan the build keys in the hash table
-	Vector build_vector(ht.layout.GetTypes()[build_idx], key_count);
-	data_collection.Gather(tuples_addresses, *FlatVector::IncrementalSelectionVector(), key_count, build_idx,
-	                       build_vector, *FlatVector::IncrementalSelectionVector(), nullptr);
-
-	// generate the OR-clause - note that we only need to consider unique values here (so we use a seT)
-	value_set_t unique_ht_values;
-	for (idx_t k = 0; k < key_count; k++) {
-		unique_ht_values.insert(build_vector.GetValue(k));
-	}
-	vector<Value> in_list(unique_ht_values.begin(), unique_ht_values.end());
-
-	// generating the OR filter only makes sense if the range is
-	// not dense and that the range does not contain NULL
-	// i.e. if we have the values [0, 1, 2, 3, 4] - the min/max is fully equivalent to the OR filter
-	if (FilterCombiner::ContainsNull(in_list) || FilterCombiner::IsDenseRange(in_list)) {
-		return;
-	}
-
-	// generate the OR filter
-	auto in_filter = make_uniq<InFilter>(std::move(in_list));
-	in_filter->origin_is_hash_join = true;
-
-	// we push the OR filter as an OptionalFilter so that we can use it for zonemap pruning only
-	// the IN-list is expensive to execute otherwise
-	auto filter = make_uniq<OptionalFilter>(std::move(in_filter));
-	info.dynamic_filters->PushFilter(op, filter_col_idx, std::move(filter));
-	return;
-}
-
-unique_ptr<DataChunk> JoinFilterPushdownInfo::Finalize(ClientContext &context, JoinHashTable &ht,
-                                                       JoinFilterGlobalState &gstate,
-                                                       const PhysicalOperator &op) const {
-	// finalize the min/max aggregates
-	vector<LogicalType> min_max_types;
-	for (auto &aggr_expr : min_max_aggregates) {
-		min_max_types.push_back(aggr_expr->return_type);
-	}
-	auto final_min_max = make_uniq<DataChunk>();
-	final_min_max->Initialize(Allocator::DefaultAllocator(), min_max_types);
-
-	gstate.global_aggregate_state->Finalize(*final_min_max);
-
-	if (probe_info.empty()) {
-		return final_min_max; // There are not table souces in which we can push down filters
-	}
-
-	auto dynamic_or_filter_threshold = ClientConfig::GetSetting<DynamicOrFilterThresholdSetting>(context);
-	// create a filter for each of the aggregates
-	for (idx_t filter_idx = 0; filter_idx < join_condition.size(); filter_idx++) {
-		for (auto &info : probe_info) {
-			auto filter_col_idx = info.columns[filter_idx].probe_column_index.column_index;
-			auto min_idx = filter_idx * 2;
-			auto max_idx = min_idx + 1;
-
-			auto min_val = final_min_max->data[min_idx].GetValue(0);
-			auto max_val = final_min_max->data[max_idx].GetValue(0);
-			if (min_val.IsNull() || max_val.IsNull()) {
-				// min/max is NULL
-				// this can happen in case all values in the RHS column are NULL, but they are still pushed into the
-				// hash table e.g. because they are part of a RIGHT join
-				continue;
-			}
-			// if the HT is small we can generate a complete "OR" filter
-			if (ht.Count() > 1 && ht.Count() <= dynamic_or_filter_threshold) {
-				PushInFilter(info, ht, op, filter_idx, filter_col_idx);
-			}
-
-			if (Value::NotDistinctFrom(min_val, max_val)) {
-				// min = max - generate an equality filter
-				auto constant_filter = make_uniq<ConstantFilter>(ExpressionType::COMPARE_EQUAL, std::move(min_val));
-				info.dynamic_filters->PushFilter(op, filter_col_idx, std::move(constant_filter));
-			} else {
-				// min != max - generate a range filter
-				auto greater_equals =
-				    make_uniq<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, std::move(min_val));
-				info.dynamic_filters->PushFilter(op, filter_col_idx, std::move(greater_equals));
-				auto less_equals =
-				    make_uniq<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO, std::move(max_val));
-				info.dynamic_filters->PushFilter(op, filter_col_idx, std::move(less_equals));
-			}
-		}
-	}
-
-	return final_min_max;
-}
-
-SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            OperatorSinkFinalizeInput &input) const {
-	auto &sink = input.global_state.Cast<HashJoinGlobalSinkState>();
-	auto &ht = *sink.hash_table;
-
-	sink.temporary_memory_state->UpdateReservation(context);
-	sink.external = sink.temporary_memory_state->GetReservation() < sink.total_size;
-	if (sink.external) {
-		// External Hash Join
-		sink.perfect_join_executor.reset();
-
-		const auto max_partition_ht_size =
-		    sink.max_partition_size + JoinHashTable::PointerTableSize(sink.max_partition_count);
-		const auto very_very_skewed = // No point in repartitioning if it's this skewed
-		    static_cast<double>(max_partition_ht_size) >= 0.8 * static_cast<double>(sink.total_size);
-		if (!very_very_skewed &&
-		    (max_partition_ht_size + sink.probe_side_requirement) > sink.temporary_memory_state->GetReservation()) {
-			// We have to repartition
-			ht.SetRepartitionRadixBits(sink.temporary_memory_state->GetReservation(), sink.max_partition_size,
-			                           sink.max_partition_count);
-			auto new_event = make_shared_ptr<HashJoinRepartitionEvent>(pipeline, *this, sink, sink.local_hash_tables);
-			event.InsertEvent(std::move(new_event));
-		} else {
-			// No repartitioning!
-			for (auto &local_ht : sink.local_hash_tables) {
-				ht.Merge(*local_ht);
-			}
-			sink.local_hash_tables.clear();
-			D_ASSERT(sink.temporary_memory_state->GetReservation() >= sink.probe_side_requirement);
-			sink.hash_table->PrepareExternalFinalize(sink.temporary_memory_state->GetReservation() -
-			                                         sink.probe_side_requirement);
-			sink.ScheduleFinalize(pipeline, event);
-		}
-		sink.finalized = true;
-		return SinkFinalizeType::READY;
-	}
-
-	// In-memory Hash Join
-	for (auto &local_ht : sink.local_hash_tables) {
-		ht.Merge(*local_ht);
-	}
-	sink.local_hash_tables.clear();
-	ht.Unpartition();
-
-	Value min;
-	Value max;
-	if (filter_pushdown && !sink.skip_filter_pushdown && ht.Count() > 0) {
-		auto final_min_max = filter_pushdown->Finalize(context, ht, *sink.global_filter_state, *this);
-		min = final_min_max->data[0].GetValue(0);
-		max = final_min_max->data[1].GetValue(0);
-	} else if (TypeIsIntegral(conditions[0].right->return_type.InternalType())) {
-		min = Value::MinimumValue(conditions[0].right->return_type);
-		max = Value::MaximumValue(conditions[0].right->return_type);
-	}
-
-	// check for possible perfect hash table
-	auto use_perfect_hash = sink.perfect_join_executor->CanDoPerfectHashJoin(*this, min, max);
-	if (use_perfect_hash) {
-		D_ASSERT(ht.equality_types.size() == 1);
-		auto key_type = ht.equality_types[0];
-		use_perfect_hash = sink.perfect_join_executor->BuildPerfectHashTable(key_type);
-	}
-	// In case of a large build side or duplicates, use regular hash join
-	if (!use_perfect_hash) {
-		sink.perfect_join_executor.reset();
-		sink.ScheduleFinalize(pipeline, event);
-	}
-	sink.finalized = true;
-	if (ht.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class HashJoinOperatorState : public CachingOperatorState {
-public:
-	explicit HashJoinOperatorState(ClientContext &context, HashJoinGlobalSinkState &sink)
-	    : probe_executor(context), scan_structure(*sink.hash_table, join_key_state) {
-	}
-
-	DataChunk lhs_join_keys;
-	TupleDataChunkState join_key_state;
-	DataChunk lhs_output;
-
-	ExpressionExecutor probe_executor;
-	JoinHashTable::ScanStructure scan_structure;
-	unique_ptr<OperatorState> perfect_hash_join_state;
-
-	JoinHashTable::ProbeSpillLocalAppendState spill_state;
-	JoinHashTable::ProbeState probe_state;
-	//! Chunk to sink data into for external join
-	DataChunk spill_chunk;
-
-public:
-	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op);
-	}
-};
-
-unique_ptr<OperatorState> PhysicalHashJoin::GetOperatorState(ExecutionContext &context) const {
-	auto &allocator = BufferAllocator::Get(context.client);
-	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
-	auto state = make_uniq<HashJoinOperatorState>(context.client, sink);
-	state->lhs_join_keys.Initialize(allocator, condition_types);
-	if (!lhs_output_columns.col_types.empty()) {
-		state->lhs_output.Initialize(allocator, lhs_output_columns.col_types);
-	}
-	if (sink.perfect_join_executor) {
-		state->perfect_hash_join_state = sink.perfect_join_executor->GetOperatorState(context);
-	} else {
-		for (auto &cond : conditions) {
-			state->probe_executor.AddExpression(*cond.left);
-		}
-		TupleDataCollection::InitializeChunkState(state->join_key_state, condition_types);
-	}
-	if (sink.external) {
-		state->spill_chunk.Initialize(allocator, sink.probe_types);
-		sink.InitializeProbeSpill();
-	}
-
-	return std::move(state);
-}
-
-OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                     GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = state_p.Cast<HashJoinOperatorState>();
-	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
-	D_ASSERT(sink.finalized);
-	D_ASSERT(!sink.scanned_data);
-
-	if (sink.hash_table->Count() == 0) {
-		if (EmptyResultIfRHSIsEmpty()) {
-			return OperatorResultType::FINISHED;
-		}
-		state.lhs_output.ReferenceColumns(input, lhs_output_columns.col_idxs);
-		ConstructEmptyJoinResult(sink.hash_table->join_type, sink.hash_table->has_null, state.lhs_output, chunk);
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-
-	if (sink.perfect_join_executor) {
-		D_ASSERT(!sink.external);
-		state.lhs_output.ReferenceColumns(input, lhs_output_columns.col_idxs);
-		return sink.perfect_join_executor->ProbePerfectHashTable(context, input, state.lhs_output, chunk,
-		                                                         *state.perfect_hash_join_state);
-	}
-
-	if (sink.external && !state.initialized) {
-		// some initialization for external hash join
-		if (!sink.probe_spill) {
-			sink.InitializeProbeSpill();
-		}
-		state.spill_state = sink.probe_spill->RegisterThread();
-		state.initialized = true;
-	}
-
-	if (state.scan_structure.is_null) {
-		// probe the HT, start by resolving the join keys for the left chunk
-		state.lhs_join_keys.Reset();
-		state.probe_executor.Execute(input, state.lhs_join_keys);
-
-		// perform the actual probe
-		if (sink.external) {
-			sink.hash_table->ProbeAndSpill(state.scan_structure, state.lhs_join_keys, state.join_key_state,
-			                               state.probe_state, input, *sink.probe_spill, state.spill_state,
-			                               state.spill_chunk);
-		} else {
-			sink.hash_table->Probe(state.scan_structure, state.lhs_join_keys, state.join_key_state, state.probe_state);
-		}
-	}
-
-	state.lhs_output.ReferenceColumns(input, lhs_output_columns.col_idxs);
-	state.scan_structure.Next(state.lhs_join_keys, state.lhs_output, chunk);
-
-	if (state.scan_structure.PointersExhausted() && chunk.size() == 0) {
-		state.scan_structure.is_null = true;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-enum class HashJoinSourceStage : uint8_t { INIT, BUILD, PROBE, SCAN_HT, DONE };
-
-class HashJoinLocalSourceState;
-
-class HashJoinGlobalSourceState : public GlobalSourceState {
-public:
-	HashJoinGlobalSourceState(const PhysicalHashJoin &op, const ClientContext &context);
-
-	//! Initialize this source state using the info in the sink
-	void Initialize(HashJoinGlobalSinkState &sink);
-	//! Try to prepare the next stage
-	bool TryPrepareNextStage(HashJoinGlobalSinkState &sink);
-	//! Prepare the next build/probe/scan_ht stage for external hash join (must hold lock)
-	void PrepareBuild(HashJoinGlobalSinkState &sink);
-	void PrepareProbe(HashJoinGlobalSinkState &sink);
-	void PrepareScanHT(HashJoinGlobalSinkState &sink);
-	//! Assigns a task to a local source state
-	bool AssignTask(HashJoinGlobalSinkState &sink, HashJoinLocalSourceState &lstate);
-
-	idx_t MaxThreads() override {
-		D_ASSERT(op.sink_state);
-		auto &gstate = op.sink_state->Cast<HashJoinGlobalSinkState>();
-
-		idx_t count;
-		if (gstate.probe_spill) {
-			count = probe_count;
-		} else if (PropagatesBuildSide(op.join_type)) {
-			count = gstate.hash_table->Count();
-		} else {
-			return 0;
-		}
-		return count / ((idx_t)STANDARD_VECTOR_SIZE * parallel_scan_chunk_count);
-	}
-
-public:
-	const PhysicalHashJoin &op;
-
-	//! For synchronizing the external hash join
-	atomic<HashJoinSourceStage> global_stage;
-
-	//! For HT build synchronization
-	idx_t build_chunk_idx = DConstants::INVALID_INDEX;
-	idx_t build_chunk_count;
-	idx_t build_chunk_done;
-	idx_t build_chunks_per_thread = DConstants::INVALID_INDEX;
-
-	//! For probe synchronization
-	atomic<idx_t> probe_chunk_count;
-	idx_t probe_chunk_done;
-
-	//! To determine the number of threads
-	idx_t probe_count;
-	idx_t parallel_scan_chunk_count;
-
-	//! For full/outer synchronization
-	idx_t full_outer_chunk_idx = DConstants::INVALID_INDEX;
-	atomic<idx_t> full_outer_chunk_count;
-	atomic<idx_t> full_outer_chunk_done;
-	idx_t full_outer_chunks_per_thread = DConstants::INVALID_INDEX;
-
-	vector<InterruptState> blocked_tasks;
-};
-
-class HashJoinLocalSourceState : public LocalSourceState {
-public:
-	HashJoinLocalSourceState(const PhysicalHashJoin &op, const HashJoinGlobalSinkState &sink, Allocator &allocator);
-
-	//! Do the work this thread has been assigned
-	void ExecuteTask(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate, DataChunk &chunk);
-	//! Whether this thread has finished the work it has been assigned
-	bool TaskFinished() const;
-	//! Build, probe and scan for external hash join
-	void ExternalBuild(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate);
-	void ExternalProbe(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate, DataChunk &chunk);
-	void ExternalScanHT(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate, DataChunk &chunk);
-
-public:
-	//! The stage that this thread was assigned work for
-	HashJoinSourceStage local_stage;
-	//! Vector with pointers here so we don't have to re-initialize
-	Vector addresses;
-
-	//! Chunks assigned to this thread for building the pointer table
-	idx_t build_chunk_idx_from = DConstants::INVALID_INDEX;
-	idx_t build_chunk_idx_to = DConstants::INVALID_INDEX;
-
-	//! Local scan state for probe spill
-	ColumnDataConsumerScanState probe_local_scan;
-	//! Chunks for holding the scanned probe collection
-	DataChunk lhs_probe_chunk;
-	DataChunk lhs_join_keys;
-	DataChunk lhs_output;
-	TupleDataChunkState join_key_state;
-	ExpressionExecutor lhs_join_key_executor;
-
-	//! Scan structure for the external probe
-	JoinHashTable::ScanStructure scan_structure;
-	JoinHashTable::ProbeState probe_state;
-	bool empty_ht_probe_in_progress = false;
-
-	//! Chunks assigned to this thread for a full/outer scan
-	idx_t full_outer_chunk_idx_from = DConstants::INVALID_INDEX;
-	idx_t full_outer_chunk_idx_to = DConstants::INVALID_INDEX;
-	unique_ptr<JoinHTScanState> full_outer_scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalHashJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<HashJoinGlobalSourceState>(*this, context);
-}
-
-unique_ptr<LocalSourceState> PhysicalHashJoin::GetLocalSourceState(ExecutionContext &context,
-                                                                   GlobalSourceState &gstate) const {
-	return make_uniq<HashJoinLocalSourceState>(*this, sink_state->Cast<HashJoinGlobalSinkState>(),
-	                                           BufferAllocator::Get(context.client));
-}
-
-HashJoinGlobalSourceState::HashJoinGlobalSourceState(const PhysicalHashJoin &op, const ClientContext &context)
-    : op(op), global_stage(HashJoinSourceStage::INIT), build_chunk_count(0), build_chunk_done(0), probe_chunk_count(0),
-      probe_chunk_done(0), probe_count(op.children[0]->estimated_cardinality),
-      parallel_scan_chunk_count(context.config.verify_parallelism ? 1 : 120) {
-}
-
-void HashJoinGlobalSourceState::Initialize(HashJoinGlobalSinkState &sink) {
-	auto guard = Lock();
-	if (global_stage != HashJoinSourceStage::INIT) {
-		// Another thread initialized
-		return;
-	}
-
-	// Finalize the probe spill
-	if (sink.probe_spill) {
-		sink.probe_spill->Finalize();
-	}
-
-	global_stage = HashJoinSourceStage::PROBE;
-	TryPrepareNextStage(sink);
-}
-
-bool HashJoinGlobalSourceState::TryPrepareNextStage(HashJoinGlobalSinkState &sink) {
-	switch (global_stage.load()) {
-	case HashJoinSourceStage::BUILD:
-		if (build_chunk_done == build_chunk_count) {
-			sink.hash_table->GetDataCollection().VerifyEverythingPinned();
-			sink.hash_table->finalized = true;
-			PrepareProbe(sink);
-			return true;
-		}
-		break;
-	case HashJoinSourceStage::PROBE:
-		if (probe_chunk_done == probe_chunk_count) {
-			if (PropagatesBuildSide(op.join_type)) {
-				PrepareScanHT(sink);
-			} else {
-				PrepareBuild(sink);
-			}
-			return true;
-		}
-		break;
-	case HashJoinSourceStage::SCAN_HT:
-		if (full_outer_chunk_done == full_outer_chunk_count) {
-			PrepareBuild(sink);
-			return true;
-		}
-		break;
-	default:
-		break;
-	}
-	return false;
-}
-
-void HashJoinGlobalSourceState::PrepareBuild(HashJoinGlobalSinkState &sink) {
-	D_ASSERT(global_stage != HashJoinSourceStage::BUILD);
-	auto &ht = *sink.hash_table;
-
-	// Update remaining size
-	sink.temporary_memory_state->SetRemainingSizeAndUpdateReservation(sink.context, ht.GetRemainingSize() +
-	                                                                                    sink.probe_side_requirement);
-
-	// Try to put the next partitions in the block collection of the HT
-	D_ASSERT(!sink.external || sink.temporary_memory_state->GetReservation() >= sink.probe_side_requirement);
-	if (!sink.external ||
-	    !ht.PrepareExternalFinalize(sink.temporary_memory_state->GetReservation() - sink.probe_side_requirement)) {
-		global_stage = HashJoinSourceStage::DONE;
-		sink.temporary_memory_state->SetZero();
-		return;
-	}
-
-	auto &data_collection = ht.GetDataCollection();
-	if (data_collection.Count() == 0 && op.EmptyResultIfRHSIsEmpty()) {
-		PrepareBuild(sink);
-		return;
-	}
-
-	build_chunk_idx = 0;
-	build_chunk_count = data_collection.ChunkCount();
-	build_chunk_done = 0;
-
-	if (sink.context.config.verify_parallelism) {
-		build_chunks_per_thread = 1;
-	} else {
-		const auto max_partition_ht_size =
-		    sink.max_partition_size + JoinHashTable::PointerTableSize(sink.max_partition_count);
-		const auto skew = static_cast<double>(max_partition_ht_size) / static_cast<double>(sink.total_size);
-
-		if (skew > HashJoinFinalizeEvent::SKEW_SINGLE_THREADED_THRESHOLD) {
-			build_chunks_per_thread = build_chunk_count; // This forces single-threaded building
-		} else {
-			build_chunks_per_thread = // Same task size as in HashJoinFinalizeEvent
-			    MaxValue<idx_t>(MinValue(build_chunk_count, HashJoinFinalizeEvent::CHUNKS_PER_TASK), 1);
-		}
-	}
-
-	ht.InitializePointerTable();
-
-	global_stage = HashJoinSourceStage::BUILD;
-}
-
-void HashJoinGlobalSourceState::PrepareProbe(HashJoinGlobalSinkState &sink) {
-	sink.probe_spill->PrepareNextProbe();
-	const auto &consumer = *sink.probe_spill->consumer;
-
-	probe_chunk_count = consumer.Count() == 0 ? 0 : consumer.ChunkCount();
-	probe_chunk_done = 0;
-
-	global_stage = HashJoinSourceStage::PROBE;
-	if (probe_chunk_count == 0) {
-		TryPrepareNextStage(sink);
-		return;
-	}
-}
-
-void HashJoinGlobalSourceState::PrepareScanHT(HashJoinGlobalSinkState &sink) {
-	D_ASSERT(global_stage != HashJoinSourceStage::SCAN_HT);
-	auto &ht = *sink.hash_table;
-
-	auto &data_collection = ht.GetDataCollection();
-	full_outer_chunk_idx = 0;
-	full_outer_chunk_count = data_collection.ChunkCount();
-	full_outer_chunk_done = 0;
-
-	full_outer_chunks_per_thread =
-	    MaxValue<idx_t>((full_outer_chunk_count + sink.num_threads - 1) / sink.num_threads, 1);
-
-	global_stage = HashJoinSourceStage::SCAN_HT;
-}
-
-bool HashJoinGlobalSourceState::AssignTask(HashJoinGlobalSinkState &sink, HashJoinLocalSourceState &lstate) {
-	D_ASSERT(lstate.TaskFinished());
-
-	auto guard = Lock();
-	switch (global_stage.load()) {
-	case HashJoinSourceStage::BUILD:
-		if (build_chunk_idx != build_chunk_count) {
-			lstate.local_stage = global_stage;
-			lstate.build_chunk_idx_from = build_chunk_idx;
-			build_chunk_idx = MinValue<idx_t>(build_chunk_count, build_chunk_idx + build_chunks_per_thread);
-			lstate.build_chunk_idx_to = build_chunk_idx;
-			return true;
-		}
-		break;
-	case HashJoinSourceStage::PROBE:
-		if (sink.probe_spill->consumer && sink.probe_spill->consumer->AssignChunk(lstate.probe_local_scan)) {
-			lstate.local_stage = global_stage;
-			lstate.empty_ht_probe_in_progress = false;
-			return true;
-		}
-		break;
-	case HashJoinSourceStage::SCAN_HT:
-		if (full_outer_chunk_idx != full_outer_chunk_count) {
-			lstate.local_stage = global_stage;
-			lstate.full_outer_chunk_idx_from = full_outer_chunk_idx;
-			full_outer_chunk_idx =
-			    MinValue<idx_t>(full_outer_chunk_count, full_outer_chunk_idx + full_outer_chunks_per_thread);
-			lstate.full_outer_chunk_idx_to = full_outer_chunk_idx;
-			return true;
-		}
-		break;
-	case HashJoinSourceStage::DONE:
-		break;
-	default:
-		throw InternalException("Unexpected HashJoinSourceStage in AssignTask!");
-	}
-	return false;
-}
-
-HashJoinLocalSourceState::HashJoinLocalSourceState(const PhysicalHashJoin &op, const HashJoinGlobalSinkState &sink,
-                                                   Allocator &allocator)
-    : local_stage(HashJoinSourceStage::INIT), addresses(LogicalType::POINTER), lhs_join_key_executor(sink.context),
-      scan_structure(*sink.hash_table, join_key_state) {
-	auto &chunk_state = probe_local_scan.current_chunk_state;
-	chunk_state.properties = ColumnDataScanProperties::ALLOW_ZERO_COPY;
-
-	lhs_probe_chunk.Initialize(allocator, sink.probe_types);
-	lhs_join_keys.Initialize(allocator, op.condition_types);
-	lhs_output.Initialize(allocator, op.lhs_output_columns.col_types);
-	TupleDataCollection::InitializeChunkState(join_key_state, op.condition_types);
-
-	for (auto &cond : op.conditions) {
-		lhs_join_key_executor.AddExpression(*cond.left);
-	}
-}
-
-void HashJoinLocalSourceState::ExecuteTask(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate,
-                                           DataChunk &chunk) {
-	switch (local_stage) {
-	case HashJoinSourceStage::BUILD:
-		ExternalBuild(sink, gstate);
-		break;
-	case HashJoinSourceStage::PROBE:
-		ExternalProbe(sink, gstate, chunk);
-		break;
-	case HashJoinSourceStage::SCAN_HT:
-		ExternalScanHT(sink, gstate, chunk);
-		break;
-	default:
-		throw InternalException("Unexpected HashJoinSourceStage in ExecuteTask!");
-	}
-}
-
-bool HashJoinLocalSourceState::TaskFinished() const {
-	switch (local_stage) {
-	case HashJoinSourceStage::INIT:
-	case HashJoinSourceStage::BUILD:
-		return true;
-	case HashJoinSourceStage::PROBE:
-		return scan_structure.is_null && !empty_ht_probe_in_progress;
-	case HashJoinSourceStage::SCAN_HT:
-		return full_outer_scan_state == nullptr;
-	default:
-		throw InternalException("Unexpected HashJoinSourceStage in TaskFinished!");
-	}
-}
-
-void HashJoinLocalSourceState::ExternalBuild(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate) {
-	D_ASSERT(local_stage == HashJoinSourceStage::BUILD);
-
-	auto &ht = *sink.hash_table;
-	ht.Finalize(build_chunk_idx_from, build_chunk_idx_to, true);
-
-	auto guard = gstate.Lock();
-	gstate.build_chunk_done += build_chunk_idx_to - build_chunk_idx_from;
-}
-
-void HashJoinLocalSourceState::ExternalProbe(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate,
-                                             DataChunk &chunk) {
-	D_ASSERT(local_stage == HashJoinSourceStage::PROBE && sink.hash_table->finalized);
-
-	if (!scan_structure.is_null) {
-		// Still have elements remaining (i.e. we got >STANDARD_VECTOR_SIZE elements in the previous probe)
-		scan_structure.Next(lhs_join_keys, lhs_output, chunk);
-		if (chunk.size() != 0 || !scan_structure.PointersExhausted()) {
-			return;
-		}
-	}
-
-	if (!scan_structure.is_null || empty_ht_probe_in_progress) {
-		// Previous probe is done
-		scan_structure.is_null = true;
-		empty_ht_probe_in_progress = false;
-		sink.probe_spill->consumer->FinishChunk(probe_local_scan);
-		auto guard = gstate.Lock();
-		gstate.probe_chunk_done++;
-		return;
-	}
-
-	// Scan input chunk for next probe
-	sink.probe_spill->consumer->ScanChunk(probe_local_scan, lhs_probe_chunk);
-
-	// Get the probe chunk columns/hashes
-	lhs_join_keys.Reset();
-	lhs_join_key_executor.Execute(lhs_probe_chunk, lhs_join_keys);
-	lhs_output.ReferenceColumns(lhs_probe_chunk, sink.op.lhs_output_columns.col_idxs);
-
-	if (sink.hash_table->Count() == 0 && !gstate.op.EmptyResultIfRHSIsEmpty()) {
-		gstate.op.ConstructEmptyJoinResult(sink.hash_table->join_type, sink.hash_table->has_null, lhs_output, chunk);
-		empty_ht_probe_in_progress = true;
-		return;
-	}
-
-	// Perform the probe
-	auto precomputed_hashes = &lhs_probe_chunk.data.back();
-	sink.hash_table->Probe(scan_structure, lhs_join_keys, join_key_state, probe_state, precomputed_hashes);
-	scan_structure.Next(lhs_join_keys, lhs_output, chunk);
-}
-
-void HashJoinLocalSourceState::ExternalScanHT(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate,
-                                              DataChunk &chunk) {
-	D_ASSERT(local_stage == HashJoinSourceStage::SCAN_HT);
-
-	if (!full_outer_scan_state) {
-		full_outer_scan_state = make_uniq<JoinHTScanState>(sink.hash_table->GetDataCollection(),
-		                                                   full_outer_chunk_idx_from, full_outer_chunk_idx_to);
-	}
-	sink.hash_table->ScanFullOuter(*full_outer_scan_state, addresses, chunk);
-
-	if (chunk.size() == 0) {
-		full_outer_scan_state = nullptr;
-		auto guard = gstate.Lock();
-		gstate.full_outer_chunk_done += full_outer_chunk_idx_to - full_outer_chunk_idx_from;
-	}
-}
-
-SourceResultType PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk &chunk,
-                                           OperatorSourceInput &input) const {
-	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
-	auto &gstate = input.global_state.Cast<HashJoinGlobalSourceState>();
-	auto &lstate = input.local_state.Cast<HashJoinLocalSourceState>();
-	sink.scanned_data = true;
-
-	if (!sink.external && !PropagatesBuildSide(join_type)) {
-		auto guard = gstate.Lock();
-		if (gstate.global_stage != HashJoinSourceStage::DONE) {
-			gstate.global_stage = HashJoinSourceStage::DONE;
-			sink.hash_table->Reset();
-			sink.temporary_memory_state->SetZero();
-		}
-		return SourceResultType::FINISHED;
-	}
-
-	if (gstate.global_stage == HashJoinSourceStage::INIT) {
-		gstate.Initialize(sink);
-	}
-
-	// Any call to GetData must produce tuples, otherwise the pipeline executor thinks that we're done
-	// Therefore, we loop until we've produced tuples, or until the operator is actually done
-	while (gstate.global_stage != HashJoinSourceStage::DONE && chunk.size() == 0) {
-		if (!lstate.TaskFinished() || gstate.AssignTask(sink, lstate)) {
-			lstate.ExecuteTask(sink, gstate, chunk);
-		} else {
-			auto guard = gstate.Lock();
-			if (gstate.TryPrepareNextStage(sink) || gstate.global_stage == HashJoinSourceStage::DONE) {
-				gstate.UnblockTasks(guard);
-			} else {
-				return gstate.BlockSource(guard, input.interrupt_state);
-			}
-		}
-	}
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-ProgressData PhysicalHashJoin::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
-	auto &gstate = gstate_p.Cast<HashJoinGlobalSourceState>();
-
-	ProgressData res;
-
-	if (!sink.external) {
-		if (PropagatesBuildSide(join_type)) {
-			res.done = static_cast<double>(gstate.full_outer_chunk_done);
-			res.total = static_cast<double>(gstate.full_outer_chunk_count);
-			return res;
-		}
-		res.done = 0.0;
-		res.total = 1.0;
-		return res;
-	}
-
-	const auto &ht = *sink.hash_table;
-	const auto num_partitions = static_cast<double>(RadixPartitioning::NumberOfPartitions(ht.GetRadixBits()));
-
-	res.done = static_cast<double>(ht.FinishedPartitionCount());
-	res.total = num_partitions;
-
-	const auto probe_chunk_done = static_cast<double>(gstate.probe_chunk_done);
-	const auto probe_chunk_count = static_cast<double>(gstate.probe_chunk_count);
-	if (probe_chunk_count != 0) {
-		// Progress of the current round of probing
-		auto probe_progress = probe_chunk_done / probe_chunk_count;
-		// Weighed by the number of partitions
-		probe_progress *= static_cast<double>(ht.CurrentPartitionCount());
-		// Add it to the progress
-		res.done += probe_progress;
-	}
-
-	return res;
-}
-
-InsertionOrderPreservingMap<string> PhysicalHashJoin::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Join Type"] = EnumUtil::ToString(join_type);
-
-	string condition_info;
-	for (idx_t i = 0; i < conditions.size(); i++) {
-		auto &join_condition = conditions[i];
-		if (i > 0) {
-			condition_info += "\n";
-		}
-		condition_info +=
-		    StringUtil::Format("%s %s %s", join_condition.left->GetName(),
-		                       ExpressionTypeToOperator(join_condition.comparison), join_condition.right->GetName());
-	}
-	result["Conditions"] = condition_info;
-
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_iejoin.cpp b/src/duckdb/src/execution/operator/join/physical_iejoin.cpp
deleted file mode 100644
index c5d5810fa..000000000
--- a/src/duckdb/src/execution/operator/join/physical_iejoin.cpp
+++ /dev/null
@@ -1,1057 +0,0 @@
-#include "duckdb/execution/operator/join/physical_iejoin.hpp"
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/sort/sorted_block.hpp"
-#include "duckdb/common/thread.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-namespace duckdb {
-
-PhysicalIEJoin::PhysicalIEJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left,
-                               unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                               idx_t estimated_cardinality)
-    : PhysicalRangeJoin(op, PhysicalOperatorType::IE_JOIN, std::move(left), std::move(right), std::move(cond),
-                        join_type, estimated_cardinality) {
-
-	// 1. let L1 (resp. L2) be the array of column X (resp. Y)
-	D_ASSERT(conditions.size() >= 2);
-	for (idx_t i = 0; i < 2; ++i) {
-		auto &cond = conditions[i];
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-
-		// Convert the conditions to sort orders
-		auto left = cond.left->Copy();
-		auto right = cond.right->Copy();
-		auto sense = OrderType::INVALID;
-
-		// 2. if (op1 ∈ {>, ≥}) sort L1 in descending order
-		// 3. else if (op1 ∈ {<, ≤}) sort L1 in ascending order
-		// 4. if (op2 ∈ {>, ≥}) sort L2 in ascending order
-		// 5. else if (op2 ∈ {<, ≤}) sort L2 in descending order
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			sense = i ? OrderType::ASCENDING : OrderType::DESCENDING;
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			sense = i ? OrderType::DESCENDING : OrderType::ASCENDING;
-			break;
-		default:
-			throw NotImplementedException("Unimplemented join type for IEJoin");
-		}
-		lhs_orders.emplace_back(sense, OrderByNullType::NULLS_LAST, std::move(left));
-		rhs_orders.emplace_back(sense, OrderByNullType::NULLS_LAST, std::move(right));
-	}
-
-	for (idx_t i = 2; i < conditions.size(); ++i) {
-		auto &cond = conditions[i];
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class IEJoinLocalState : public LocalSinkState {
-public:
-	using LocalSortedTable = PhysicalRangeJoin::LocalSortedTable;
-
-	IEJoinLocalState(ClientContext &context, const PhysicalRangeJoin &op, const idx_t child)
-	    : table(context, op, child) {
-	}
-
-	//! The local sort state
-	LocalSortedTable table;
-};
-
-class IEJoinGlobalState : public GlobalSinkState {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	IEJoinGlobalState(ClientContext &context, const PhysicalIEJoin &op) : child(0) {
-		tables.resize(2);
-		RowLayout lhs_layout;
-		lhs_layout.Initialize(op.children[0]->types);
-		vector<BoundOrderByNode> lhs_order;
-		lhs_order.emplace_back(op.lhs_orders[0].Copy());
-		tables[0] = make_uniq<GlobalSortedTable>(context, lhs_order, lhs_layout, op);
-
-		RowLayout rhs_layout;
-		rhs_layout.Initialize(op.children[1]->types);
-		vector<BoundOrderByNode> rhs_order;
-		rhs_order.emplace_back(op.rhs_orders[0].Copy());
-		tables[1] = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout, op);
-	}
-
-	IEJoinGlobalState(IEJoinGlobalState &prev) : tables(std::move(prev.tables)), child(prev.child + 1) {
-		state = prev.state;
-	}
-
-	void Sink(DataChunk &input, IEJoinLocalState &lstate) {
-		auto &table = *tables[child];
-		auto &global_sort_state = table.global_sort_state;
-		auto &local_sort_state = lstate.table.local_sort_state;
-
-		// Sink the data into the local sort state
-		lstate.table.Sink(input, global_sort_state);
-
-		// When sorting data reaches a certain size, we sort it
-		if (local_sort_state.SizeInBytes() >= table.memory_per_thread) {
-			local_sort_state.Sort(global_sort_state, true);
-		}
-	}
-
-	vector<unique_ptr<GlobalSortedTable>> tables;
-	size_t child;
-};
-
-unique_ptr<GlobalSinkState> PhysicalIEJoin::GetGlobalSinkState(ClientContext &context) const {
-	D_ASSERT(!sink_state);
-	return make_uniq<IEJoinGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalIEJoin::GetLocalSinkState(ExecutionContext &context) const {
-	idx_t sink_child = 0;
-	if (sink_state) {
-		const auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
-		sink_child = ie_sink.child;
-	}
-	return make_uniq<IEJoinLocalState>(context.client, *this, sink_child);
-}
-
-SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<IEJoinGlobalState>();
-	auto &lstate = input.local_state.Cast<IEJoinLocalState>();
-
-	gstate.Sink(chunk, lstate);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalIEJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<IEJoinGlobalState>();
-	auto &lstate = input.local_state.Cast<IEJoinLocalState>();
-	gstate.tables[gstate.child]->Combine(lstate.table);
-	auto &client_profiler = QueryProfiler::Get(context.client);
-
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<IEJoinGlobalState>();
-	auto &table = *gstate.tables[gstate.child];
-	auto &global_sort_state = table.global_sort_state;
-
-	if ((gstate.child == 1 && PropagatesBuildSide(join_type)) || (gstate.child == 0 && IsLeftOuterJoin(join_type))) {
-		// for FULL/LEFT/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		table.IntializeMatches();
-	}
-	if (gstate.child == 1 && global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Sort the current input child
-	table.Finalize(pipeline, event);
-
-	// Move to the next input child
-	++gstate.child;
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-OperatorResultType PhysicalIEJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate, OperatorState &state) const {
-	return OperatorResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-struct IEJoinUnion {
-	using SortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-	static idx_t AppendKey(SortedTable &table, ExpressionExecutor &executor, SortedTable &marked, int64_t increment,
-	                       int64_t base, const idx_t block_idx);
-
-	static void Sort(SortedTable &table) {
-		auto &global_sort_state = table.global_sort_state;
-		global_sort_state.PrepareMergePhase();
-		while (global_sort_state.sorted_blocks.size() > 1) {
-			global_sort_state.InitializeMergeRound();
-			MergeSorter merge_sorter(global_sort_state, global_sort_state.buffer_manager);
-			merge_sorter.PerformInMergeRound();
-			global_sort_state.CompleteMergeRound(true);
-		}
-	}
-
-	template <typename T>
-	static vector<T> ExtractColumn(SortedTable &table, idx_t col_idx) {
-		vector<T> result;
-		result.reserve(table.count);
-
-		auto &gstate = table.global_sort_state;
-		auto &blocks = *gstate.sorted_blocks[0]->payload_data;
-		PayloadScanner scanner(blocks, gstate, false);
-
-		DataChunk payload;
-		payload.Initialize(Allocator::DefaultAllocator(), gstate.payload_layout.GetTypes());
-		for (;;) {
-			payload.Reset();
-			scanner.Scan(payload);
-			const auto count = payload.size();
-			if (!count) {
-				break;
-			}
-
-			const auto data_ptr = FlatVector::GetData<T>(payload.data[col_idx]);
-			result.insert(result.end(), data_ptr, data_ptr + count);
-		}
-
-		return result;
-	}
-
-	IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, SortedTable &t1, const idx_t b1, SortedTable &t2,
-	            const idx_t b2);
-
-	idx_t SearchL1(idx_t pos);
-	bool NextRow();
-
-	//! Inverted loop
-	idx_t JoinComplexBlocks(SelectionVector &lsel, SelectionVector &rsel);
-
-	//! L1
-	unique_ptr<SortedTable> l1;
-	//! L2
-	unique_ptr<SortedTable> l2;
-
-	//! Li
-	vector<int64_t> li;
-	//! P
-	vector<idx_t> p;
-
-	//! B
-	vector<validity_t> bit_array;
-	ValidityMask bit_mask;
-
-	//! Bloom Filter
-	static constexpr idx_t BLOOM_CHUNK_BITS = 1024;
-	idx_t bloom_count;
-	vector<validity_t> bloom_array;
-	ValidityMask bloom_filter;
-
-	//! Iteration state
-	idx_t n;
-	idx_t i;
-	idx_t j;
-	unique_ptr<SBIterator> op1;
-	unique_ptr<SBIterator> off1;
-	unique_ptr<SBIterator> op2;
-	unique_ptr<SBIterator> off2;
-	int64_t lrid;
-};
-
-idx_t IEJoinUnion::AppendKey(SortedTable &table, ExpressionExecutor &executor, SortedTable &marked, int64_t increment,
-                             int64_t base, const idx_t block_idx) {
-	LocalSortState local_sort_state;
-	local_sort_state.Initialize(marked.global_sort_state, marked.global_sort_state.buffer_manager);
-
-	// Reading
-	const auto valid = table.count - table.has_null;
-	auto &gstate = table.global_sort_state;
-	PayloadScanner scanner(gstate, block_idx);
-	auto table_idx = block_idx * gstate.block_capacity;
-
-	DataChunk scanned;
-	scanned.Initialize(Allocator::DefaultAllocator(), scanner.GetPayloadTypes());
-
-	// Writing
-	auto types = local_sort_state.sort_layout->logical_types;
-	const idx_t payload_idx = types.size();
-
-	const auto &payload_types = local_sort_state.payload_layout->GetTypes();
-	types.insert(types.end(), payload_types.begin(), payload_types.end());
-	const idx_t rid_idx = types.size() - 1;
-
-	DataChunk keys;
-	DataChunk payload;
-	keys.Initialize(Allocator::DefaultAllocator(), types);
-
-	idx_t inserted = 0;
-	for (auto rid = base; table_idx < valid;) {
-		scanned.Reset();
-		scanner.Scan(scanned);
-
-		// NULLs are at the end, so stop when we reach them
-		auto scan_count = scanned.size();
-		if (table_idx + scan_count > valid) {
-			scan_count = valid - table_idx;
-			scanned.SetCardinality(scan_count);
-		}
-		if (scan_count == 0) {
-			break;
-		}
-		table_idx += scan_count;
-
-		// Compute the input columns from the payload
-		keys.Reset();
-		keys.Split(payload, rid_idx);
-		executor.Execute(scanned, keys);
-
-		// Mark the rid column
-		payload.data[0].Sequence(rid, increment, scan_count);
-		payload.SetCardinality(scan_count);
-		keys.Fuse(payload);
-		rid += increment * UnsafeNumericCast<int64_t>(scan_count);
-
-		// Sort on the sort columns (which will no longer be needed)
-		keys.Split(payload, payload_idx);
-		local_sort_state.SinkChunk(keys, payload);
-		inserted += scan_count;
-		keys.Fuse(payload);
-
-		// Flush when we have enough data
-		if (local_sort_state.SizeInBytes() >= marked.memory_per_thread) {
-			local_sort_state.Sort(marked.global_sort_state, true);
-		}
-	}
-	marked.global_sort_state.AddLocalState(local_sort_state);
-	marked.count += inserted;
-
-	return inserted;
-}
-
-IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, SortedTable &t1, const idx_t b1,
-                         SortedTable &t2, const idx_t b2)
-    : n(0), i(0) {
-	// input : query Q with 2 join predicates t1.X op1 t2.X' and t1.Y op2 t2.Y', tables T, T' of sizes m and n resp.
-	// output: a list of tuple pairs (ti , tj)
-	// Note that T/T' are already sorted on X/X' and contain the payload data
-	// We only join the two block numbers and use the sizes of the blocks as the counts
-
-	// 0. Filter out tables with no overlap
-	if (!t1.BlockSize(b1) || !t2.BlockSize(b2)) {
-		return;
-	}
-
-	const auto &cmp1 = op.conditions[0].comparison;
-	SBIterator bounds1(t1.global_sort_state, cmp1);
-	SBIterator bounds2(t2.global_sort_state, cmp1);
-
-	// t1.X[0] op1 t2.X'[-1]
-	bounds1.SetIndex(bounds1.block_capacity * b1);
-	bounds2.SetIndex(bounds2.block_capacity * b2 + t2.BlockSize(b2) - 1);
-	if (!bounds1.Compare(bounds2)) {
-		return;
-	}
-
-	// 1. let L1 (resp. L2) be the array of column X (resp. Y )
-	const auto &order1 = op.lhs_orders[0];
-	const auto &order2 = op.lhs_orders[1];
-
-	// 2. if (op1 ∈ {>, ≥}) sort L1 in descending order
-	// 3. else if (op1 ∈ {<, ≤}) sort L1 in ascending order
-
-	// For the union algorithm, we make a unified table with the keys and the rids as the payload:
-	//		X/X', Y/Y', R/R'/Li
-	// The first position is the sort key.
-	vector<LogicalType> types;
-	types.emplace_back(order2.expression->return_type);
-	types.emplace_back(LogicalType::BIGINT);
-	RowLayout payload_layout;
-	payload_layout.Initialize(types);
-
-	// Sort on the first expression
-	auto ref = make_uniq<BoundReferenceExpression>(order1.expression->return_type, 0U);
-	vector<BoundOrderByNode> orders;
-	orders.emplace_back(order1.type, order1.null_order, std::move(ref));
-	// The goal is to make i (from the left table) < j (from the right table),
-	// if value[i] and value[j] match the condition 1.
-	// Add a column from_left to solve the problem when there exist multiple equal values in l1.
-	// If the operator is loose inequality, make t1.from_left (== true) sort BEFORE t2.from_left (== false).
-	// Otherwise, make t1.from_left sort (== true) sort AFTER t2.from_left (== false).
-	// For example, if t1.time <= t2.time
-	// | value     | 1     | 1     | 1     | 1     |
-	// | --------- | ----- | ----- | ----- | ----- |
-	// | from_left | T(l2) | T(l2) | F(r1) | F(r2) |
-	// if t1.time < t2.time
-	// | value     | 1     | 1     | 1     | 1     |
-	// | --------- | ----- | ----- | ----- | ----- |
-	// | from_left | F(r2) | F(r1) | T(l2) | T(l1) |
-	// Using this OrderType, if i < j then value[i] (from left table) and value[j] (from right table) match
-	// the condition (t1.time <= t2.time or t1.time < t2.time), then from_left will force them into the correct order.
-	auto from_left = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-	orders.emplace_back(SBIterator::ComparisonValue(cmp1) == 0 ? OrderType::DESCENDING : OrderType::ASCENDING,
-	                    OrderByNullType::ORDER_DEFAULT, std::move(from_left));
-
-	l1 = make_uniq<SortedTable>(context, orders, payload_layout, op);
-
-	// LHS has positive rids
-	ExpressionExecutor l_executor(context);
-	l_executor.AddExpression(*order1.expression);
-	// add const column true
-	auto left_const = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-	l_executor.AddExpression(*left_const);
-	l_executor.AddExpression(*order2.expression);
-	AppendKey(t1, l_executor, *l1, 1, 1, b1);
-
-	// RHS has negative rids
-	ExpressionExecutor r_executor(context);
-	r_executor.AddExpression(*op.rhs_orders[0].expression);
-	// add const column flase
-	auto right_const = make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
-	r_executor.AddExpression(*right_const);
-	r_executor.AddExpression(*op.rhs_orders[1].expression);
-	AppendKey(t2, r_executor, *l1, -1, -1, b2);
-
-	if (l1->global_sort_state.sorted_blocks.empty()) {
-		return;
-	}
-
-	Sort(*l1);
-
-	op1 = make_uniq<SBIterator>(l1->global_sort_state, cmp1);
-	off1 = make_uniq<SBIterator>(l1->global_sort_state, cmp1);
-
-	// We don't actually need the L1 column, just its sort key, which is in the sort blocks
-	li = ExtractColumn<int64_t>(*l1, types.size() - 1);
-
-	// 4. if (op2 ∈ {>, ≥}) sort L2 in ascending order
-	// 5. else if (op2 ∈ {<, ≤}) sort L2 in descending order
-
-	// We sort on Y/Y' to obtain the sort keys and the permutation array.
-	// For this we just need a two-column table of Y, P
-	types.clear();
-	types.emplace_back(LogicalType::BIGINT);
-	payload_layout.Initialize(types);
-
-	// Sort on the first expression
-	orders.clear();
-	ref = make_uniq<BoundReferenceExpression>(order2.expression->return_type, 0U);
-	orders.emplace_back(order2.type, order2.null_order, std::move(ref));
-
-	ExpressionExecutor executor(context);
-	executor.AddExpression(*orders[0].expression);
-
-	l2 = make_uniq<SortedTable>(context, orders, payload_layout, op);
-	for (idx_t base = 0, block_idx = 0; block_idx < l1->BlockCount(); ++block_idx) {
-		base += AppendKey(*l1, executor, *l2, 1, NumericCast<int64_t>(base), block_idx);
-	}
-
-	Sort(*l2);
-
-	// We don't actually need the L2 column, just its sort key, which is in the sort blocks
-
-	// 6. compute the permutation array P of L2 w.r.t. L1
-	p = ExtractColumn<idx_t>(*l2, types.size() - 1);
-
-	// 7. initialize bit-array B (|B| = n), and set all bits to 0
-	n = l2->count.load();
-	bit_array.resize(ValidityMask::EntryCount(n), 0);
-	bit_mask.Initialize(bit_array.data(), n);
-
-	// Bloom filter
-	bloom_count = (n + (BLOOM_CHUNK_BITS - 1)) / BLOOM_CHUNK_BITS;
-	bloom_array.resize(ValidityMask::EntryCount(bloom_count), 0);
-	bloom_filter.Initialize(bloom_array.data(), bloom_count);
-
-	// 11. for(i←1 to n) do
-	const auto &cmp2 = op.conditions[1].comparison;
-	op2 = make_uniq<SBIterator>(l2->global_sort_state, cmp2);
-	off2 = make_uniq<SBIterator>(l2->global_sort_state, cmp2);
-	i = 0;
-	j = 0;
-	(void)NextRow();
-}
-
-bool IEJoinUnion::NextRow() {
-	for (; i < n; ++i) {
-		// 12. pos ← P[i]
-		auto pos = p[i];
-		lrid = li[pos];
-		if (lrid < 0) {
-			continue;
-		}
-
-		// 16. B[pos] ← 1
-		op2->SetIndex(i);
-		for (; off2->GetIndex() < n; ++(*off2)) {
-			if (!off2->Compare(*op2)) {
-				break;
-			}
-			const auto p2 = p[off2->GetIndex()];
-			if (li[p2] < 0) {
-				// Only mark rhs matches.
-				bit_mask.SetValid(p2);
-				bloom_filter.SetValid(p2 / BLOOM_CHUNK_BITS);
-			}
-		}
-
-		// 9.  if (op1 ∈ {≤,≥} and op2 ∈ {≤,≥}) eqOff = 0
-		// 10. else eqOff = 1
-		// No, because there could be more than one equal value.
-		// Find the leftmost off1 where L1[pos] op1 L1[off1..n]
-		// These are the rows that satisfy the op1 condition
-		// and that is where we should start scanning B from
-		j = pos;
-
-		return true;
-	}
-	return false;
-}
-
-static idx_t NextValid(const ValidityMask &bits, idx_t j, const idx_t n) {
-	if (j >= n) {
-		return n;
-	}
-
-	// We can do a first approximation by checking entries one at a time
-	// which gives 64:1.
-	idx_t entry_idx, idx_in_entry;
-	bits.GetEntryIndex(j, entry_idx, idx_in_entry);
-	auto entry = bits.GetValidityEntry(entry_idx++);
-
-	// Trim the bits before the start position
-	entry &= (ValidityMask::ValidityBuffer::MAX_ENTRY << idx_in_entry);
-
-	// Check the non-ragged entries
-	for (const auto entry_count = bits.EntryCount(n); entry_idx < entry_count; ++entry_idx) {
-		if (entry) {
-			for (; idx_in_entry < bits.BITS_PER_VALUE; ++idx_in_entry, ++j) {
-				if (bits.RowIsValid(entry, idx_in_entry)) {
-					return j;
-				}
-			}
-		} else {
-			j += bits.BITS_PER_VALUE - idx_in_entry;
-		}
-
-		entry = bits.GetValidityEntry(entry_idx);
-		idx_in_entry = 0;
-	}
-
-	// Check the final entry
-	for (; j < n; ++idx_in_entry, ++j) {
-		if (bits.RowIsValid(entry, idx_in_entry)) {
-			return j;
-		}
-	}
-
-	return j;
-}
-
-idx_t IEJoinUnion::JoinComplexBlocks(SelectionVector &lsel, SelectionVector &rsel) {
-	// 8. initialize join result as an empty list for tuple pairs
-	idx_t result_count = 0;
-
-	// 11. for(i←1 to n) do
-	while (i < n) {
-		// 13. for (j ← pos+eqOff to n) do
-		for (;;) {
-			// 14. if B[j] = 1 then
-
-			//	Use the Bloom filter to find candidate blocks
-			while (j < n) {
-				auto bloom_begin = NextValid(bloom_filter, j / BLOOM_CHUNK_BITS, bloom_count) * BLOOM_CHUNK_BITS;
-				auto bloom_end = MinValue<idx_t>(n, bloom_begin + BLOOM_CHUNK_BITS);
-
-				j = MaxValue<idx_t>(j, bloom_begin);
-				j = NextValid(bit_mask, j, bloom_end);
-				if (j < bloom_end) {
-					break;
-				}
-			}
-
-			if (j >= n) {
-				break;
-			}
-
-			// Filter out tuples with the same sign (they come from the same table)
-			const auto rrid = li[j];
-			++j;
-
-			D_ASSERT(lrid > 0 && rrid < 0);
-			// 15. add tuples w.r.t. (L1[j], L1[i]) to join result
-			lsel.set_index(result_count, sel_t(+lrid - 1));
-			rsel.set_index(result_count, sel_t(-rrid - 1));
-			++result_count;
-			if (result_count == STANDARD_VECTOR_SIZE) {
-				// out of space!
-				return result_count;
-			}
-		}
-		++i;
-
-		if (!NextRow()) {
-			break;
-		}
-	}
-
-	return result_count;
-}
-
-class IEJoinLocalSourceState : public LocalSourceState {
-public:
-	explicit IEJoinLocalSourceState(ClientContext &context, const PhysicalIEJoin &op)
-	    : op(op), true_sel(STANDARD_VECTOR_SIZE), left_executor(context), right_executor(context),
-	      left_matches(nullptr), right_matches(nullptr) {
-		auto &allocator = Allocator::Get(context);
-		unprojected.Initialize(allocator, op.unprojected_types);
-
-		if (op.conditions.size() < 3) {
-			return;
-		}
-
-		vector<LogicalType> left_types;
-		vector<LogicalType> right_types;
-		for (idx_t i = 2; i < op.conditions.size(); ++i) {
-			const auto &cond = op.conditions[i];
-
-			left_types.push_back(cond.left->return_type);
-			left_executor.AddExpression(*cond.left);
-
-			right_types.push_back(cond.left->return_type);
-			right_executor.AddExpression(*cond.right);
-		}
-
-		left_keys.Initialize(allocator, left_types);
-		right_keys.Initialize(allocator, right_types);
-	}
-
-	idx_t SelectOuterRows(bool *matches) {
-		idx_t count = 0;
-		for (; outer_idx < outer_count; ++outer_idx) {
-			if (!matches[outer_idx]) {
-				true_sel.set_index(count++, outer_idx);
-				if (count >= STANDARD_VECTOR_SIZE) {
-					outer_idx++;
-					break;
-				}
-			}
-		}
-
-		return count;
-	}
-
-	const PhysicalIEJoin &op;
-
-	// Joining
-	unique_ptr<IEJoinUnion> joiner;
-
-	idx_t left_base;
-	idx_t left_block_index;
-
-	idx_t right_base;
-	idx_t right_block_index;
-
-	// Trailing predicates
-	SelectionVector true_sel;
-
-	ExpressionExecutor left_executor;
-	DataChunk left_keys;
-
-	ExpressionExecutor right_executor;
-	DataChunk right_keys;
-
-	DataChunk unprojected;
-
-	// Outer joins
-	idx_t outer_idx;
-	idx_t outer_count;
-	bool *left_matches;
-	bool *right_matches;
-};
-
-void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &result, LocalSourceState &state_p) const {
-	auto &state = state_p.Cast<IEJoinLocalSourceState>();
-	auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
-	auto &left_table = *ie_sink.tables[0];
-	auto &right_table = *ie_sink.tables[1];
-
-	const auto left_cols = children[0]->GetTypes().size();
-	auto &chunk = state.unprojected;
-	do {
-		SelectionVector lsel(STANDARD_VECTOR_SIZE);
-		SelectionVector rsel(STANDARD_VECTOR_SIZE);
-		auto result_count = state.joiner->JoinComplexBlocks(lsel, rsel);
-		if (result_count == 0) {
-			// exhausted this pair
-			return;
-		}
-
-		// found matches: extract them
-
-		chunk.Reset();
-		SliceSortedPayload(chunk, left_table.global_sort_state, state.left_block_index, lsel, result_count, 0);
-		SliceSortedPayload(chunk, right_table.global_sort_state, state.right_block_index, rsel, result_count,
-		                   left_cols);
-		chunk.SetCardinality(result_count);
-
-		auto sel = FlatVector::IncrementalSelectionVector();
-		if (conditions.size() > 2) {
-			// If there are more expressions to compute,
-			// split the result chunk into the left and right halves
-			// so we can compute the values for comparison.
-			const auto tail_cols = conditions.size() - 2;
-
-			DataChunk right_chunk;
-			chunk.Split(right_chunk, left_cols);
-			state.left_executor.SetChunk(chunk);
-			state.right_executor.SetChunk(right_chunk);
-
-			auto tail_count = result_count;
-			auto true_sel = &state.true_sel;
-			for (size_t cmp_idx = 0; cmp_idx < tail_cols; ++cmp_idx) {
-				auto &left = state.left_keys.data[cmp_idx];
-				state.left_executor.ExecuteExpression(cmp_idx, left);
-
-				auto &right = state.right_keys.data[cmp_idx];
-				state.right_executor.ExecuteExpression(cmp_idx, right);
-
-				if (tail_count < result_count) {
-					left.Slice(*sel, tail_count);
-					right.Slice(*sel, tail_count);
-				}
-				tail_count = SelectJoinTail(conditions[cmp_idx + 2].comparison, left, right, sel, tail_count, true_sel);
-				sel = true_sel;
-			}
-			chunk.Fuse(right_chunk);
-
-			if (tail_count < result_count) {
-				result_count = tail_count;
-				chunk.Slice(*sel, result_count);
-			}
-		}
-
-		//	We need all of the data to compute other predicates,
-		//	but we only return what is in the projection map
-		ProjectResult(chunk, result);
-
-		// found matches: mark the found matches if required
-		if (left_table.found_match) {
-			for (idx_t i = 0; i < result_count; i++) {
-				left_table.found_match[state.left_base + lsel[sel->get_index(i)]] = true;
-			}
-		}
-		if (right_table.found_match) {
-			for (idx_t i = 0; i < result_count; i++) {
-				right_table.found_match[state.right_base + rsel[sel->get_index(i)]] = true;
-			}
-		}
-		result.Verify();
-	} while (result.size() == 0);
-}
-
-class IEJoinGlobalSourceState : public GlobalSourceState {
-public:
-	explicit IEJoinGlobalSourceState(const PhysicalIEJoin &op, IEJoinGlobalState &gsink)
-	    : op(op), gsink(gsink), initialized(false), next_pair(0), completed(0), left_outers(0), next_left(0),
-	      right_outers(0), next_right(0) {
-	}
-
-	void Initialize() {
-		auto guard = Lock();
-		if (initialized) {
-			return;
-		}
-
-		// Compute the starting row for reach block
-		// (In theory these are all the same size, but you never know...)
-		auto &left_table = *gsink.tables[0];
-		const auto left_blocks = left_table.BlockCount();
-		idx_t left_base = 0;
-
-		for (size_t lhs = 0; lhs < left_blocks; ++lhs) {
-			left_bases.emplace_back(left_base);
-			left_base += left_table.BlockSize(lhs);
-		}
-
-		auto &right_table = *gsink.tables[1];
-		const auto right_blocks = right_table.BlockCount();
-		idx_t right_base = 0;
-		for (size_t rhs = 0; rhs < right_blocks; ++rhs) {
-			right_bases.emplace_back(right_base);
-			right_base += right_table.BlockSize(rhs);
-		}
-
-		// Outer join block counts
-		if (left_table.found_match) {
-			left_outers = left_blocks;
-		}
-
-		if (right_table.found_match) {
-			right_outers = right_blocks;
-		}
-
-		// Ready for action
-		initialized = true;
-	}
-
-public:
-	idx_t MaxThreads() override {
-		// We can't leverage any more threads than block pairs.
-		const auto &sink_state = (op.sink_state->Cast<IEJoinGlobalState>());
-		return sink_state.tables[0]->BlockCount() * sink_state.tables[1]->BlockCount();
-	}
-
-	void GetNextPair(ClientContext &client, IEJoinLocalSourceState &lstate) {
-		auto &left_table = *gsink.tables[0];
-		auto &right_table = *gsink.tables[1];
-
-		const auto left_blocks = left_table.BlockCount();
-		const auto right_blocks = right_table.BlockCount();
-		const auto pair_count = left_blocks * right_blocks;
-
-		// Regular block
-		const auto i = next_pair++;
-		if (i < pair_count) {
-			const auto b1 = i / right_blocks;
-			const auto b2 = i % right_blocks;
-
-			lstate.left_block_index = b1;
-			lstate.left_base = left_bases[b1];
-
-			lstate.right_block_index = b2;
-			lstate.right_base = right_bases[b2];
-
-			lstate.joiner = make_uniq<IEJoinUnion>(client, op, left_table, b1, right_table, b2);
-			return;
-		}
-
-		// Outer joins
-		if (!left_outers && !right_outers) {
-			return;
-		}
-
-		// Spin wait for regular blocks to finish(!)
-		while (completed < pair_count) {
-			std::this_thread::yield();
-		}
-
-		// Left outer blocks
-		const auto l = next_left++;
-		if (l < left_outers) {
-			lstate.joiner = nullptr;
-			lstate.left_block_index = l;
-			lstate.left_base = left_bases[l];
-
-			lstate.left_matches = left_table.found_match.get() + lstate.left_base;
-			lstate.outer_idx = 0;
-			lstate.outer_count = left_table.BlockSize(l);
-			return;
-		} else {
-			lstate.left_matches = nullptr;
-		}
-
-		// Right outer block
-		const auto r = next_right++;
-		if (r < right_outers) {
-			lstate.joiner = nullptr;
-			lstate.right_block_index = r;
-			lstate.right_base = right_bases[r];
-
-			lstate.right_matches = right_table.found_match.get() + lstate.right_base;
-			lstate.outer_idx = 0;
-			lstate.outer_count = right_table.BlockSize(r);
-			return;
-		} else {
-			lstate.right_matches = nullptr;
-		}
-	}
-
-	void PairCompleted(ClientContext &client, IEJoinLocalSourceState &lstate) {
-		lstate.joiner.reset();
-		++completed;
-		GetNextPair(client, lstate);
-	}
-
-	ProgressData GetProgress() const {
-		auto &left_table = *gsink.tables[0];
-		auto &right_table = *gsink.tables[1];
-
-		const auto left_blocks = left_table.BlockCount();
-		const auto right_blocks = right_table.BlockCount();
-		const auto pair_count = left_blocks * right_blocks;
-
-		const auto count = pair_count + left_outers + right_outers;
-
-		const auto l = MinValue(next_left.load(), left_outers.load());
-		const auto r = MinValue(next_right.load(), right_outers.load());
-		const auto returned = completed.load() + l + r;
-
-		ProgressData res;
-		if (count) {
-			res.done = double(returned);
-			res.total = double(count);
-		} else {
-			res.SetInvalid();
-		}
-		return res;
-	}
-
-	const PhysicalIEJoin &op;
-	IEJoinGlobalState &gsink;
-
-	bool initialized;
-
-	// Join queue state
-	atomic<size_t> next_pair;
-	atomic<size_t> completed;
-
-	// Block base row number
-	vector<idx_t> left_bases;
-	vector<idx_t> right_bases;
-
-	// Outer joins
-	atomic<idx_t> left_outers;
-	atomic<idx_t> next_left;
-
-	atomic<idx_t> right_outers;
-	atomic<idx_t> next_right;
-};
-
-unique_ptr<GlobalSourceState> PhysicalIEJoin::GetGlobalSourceState(ClientContext &context) const {
-	auto &gsink = sink_state->Cast<IEJoinGlobalState>();
-	return make_uniq<IEJoinGlobalSourceState>(*this, gsink);
-}
-
-unique_ptr<LocalSourceState> PhysicalIEJoin::GetLocalSourceState(ExecutionContext &context,
-                                                                 GlobalSourceState &gstate) const {
-	return make_uniq<IEJoinLocalSourceState>(context.client, *this);
-}
-
-ProgressData PhysicalIEJoin::GetProgress(ClientContext &context, GlobalSourceState &gsource_p) const {
-	auto &gsource = gsource_p.Cast<IEJoinGlobalSourceState>();
-	return gsource.GetProgress();
-}
-
-SourceResultType PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result,
-                                         OperatorSourceInput &input) const {
-	auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
-	auto &ie_gstate = input.global_state.Cast<IEJoinGlobalSourceState>();
-	auto &ie_lstate = input.local_state.Cast<IEJoinLocalSourceState>();
-
-	ie_gstate.Initialize();
-
-	if (!ie_lstate.joiner && !ie_lstate.left_matches && !ie_lstate.right_matches) {
-		ie_gstate.GetNextPair(context.client, ie_lstate);
-	}
-
-	// Process INNER results
-	while (ie_lstate.joiner) {
-		ResolveComplexJoin(context, result, ie_lstate);
-
-		if (result.size()) {
-			return SourceResultType::HAVE_MORE_OUTPUT;
-		}
-
-		ie_gstate.PairCompleted(context.client, ie_lstate);
-	}
-
-	// Process LEFT OUTER results
-	const auto left_cols = children[0]->GetTypes().size();
-	while (ie_lstate.left_matches) {
-		const idx_t count = ie_lstate.SelectOuterRows(ie_lstate.left_matches);
-		if (!count) {
-			ie_gstate.GetNextPair(context.client, ie_lstate);
-			continue;
-		}
-		auto &chunk = ie_lstate.unprojected;
-		chunk.Reset();
-		SliceSortedPayload(chunk, ie_sink.tables[0]->global_sort_state, ie_lstate.left_block_index, ie_lstate.true_sel,
-		                   count);
-
-		// Fill in NULLs to the right
-		for (auto col_idx = left_cols; col_idx < chunk.ColumnCount(); ++col_idx) {
-			chunk.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(chunk.data[col_idx], true);
-		}
-
-		ProjectResult(chunk, result);
-		result.SetCardinality(count);
-		result.Verify();
-
-		return result.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-	}
-
-	// Process RIGHT OUTER results
-	while (ie_lstate.right_matches) {
-		const idx_t count = ie_lstate.SelectOuterRows(ie_lstate.right_matches);
-		if (!count) {
-			ie_gstate.GetNextPair(context.client, ie_lstate);
-			continue;
-		}
-
-		auto &chunk = ie_lstate.unprojected;
-		chunk.Reset();
-		SliceSortedPayload(chunk, ie_sink.tables[1]->global_sort_state, ie_lstate.right_block_index, ie_lstate.true_sel,
-		                   count, left_cols);
-
-		// Fill in NULLs to the left
-		for (idx_t col_idx = 0; col_idx < left_cols; ++col_idx) {
-			chunk.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(chunk.data[col_idx], true);
-		}
-
-		ProjectResult(chunk, result);
-		result.SetCardinality(count);
-		result.Verify();
-
-		break;
-	}
-
-	return result.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalIEJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	D_ASSERT(children.size() == 2);
-	if (meta_pipeline.HasRecursiveCTE()) {
-		throw NotImplementedException("IEJoins are not supported in recursive CTEs yet");
-	}
-
-	// becomes a source after both children fully sink their data
-	meta_pipeline.GetState().SetPipelineSource(current, *this);
-
-	// Create one child meta pipeline that will hold the LHS and RHS pipelines
-	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-
-	// Build out LHS
-	auto lhs_pipeline = child_meta_pipeline.GetBasePipeline();
-	children[0]->BuildPipelines(*lhs_pipeline, child_meta_pipeline);
-
-	// Build out RHS
-	auto &rhs_pipeline = child_meta_pipeline.CreatePipeline();
-	children[1]->BuildPipelines(rhs_pipeline, child_meta_pipeline);
-
-	// Despite having the same sink, RHS and everything created after it need their own (same) PipelineFinishEvent
-	child_meta_pipeline.AddFinishEvent(rhs_pipeline);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_join.cpp b/src/duckdb/src/execution/operator/join/physical_join.cpp
deleted file mode 100644
index bb7011a3a..000000000
--- a/src/duckdb/src/execution/operator/join/physical_join.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "duckdb/execution/operator/join/physical_join.hpp"
-
-#include "duckdb/execution/operator/join/physical_hash_join.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-PhysicalJoin::PhysicalJoin(LogicalOperator &op, PhysicalOperatorType type, JoinType join_type,
-                           idx_t estimated_cardinality)
-    : CachingPhysicalOperator(type, op.types, estimated_cardinality), join_type(join_type) {
-}
-
-bool PhysicalJoin::EmptyResultIfRHSIsEmpty() const {
-	// empty RHS with INNER, RIGHT or SEMI join means empty result set
-	switch (join_type) {
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-	case JoinType::SEMI:
-	case JoinType::RIGHT_SEMI:
-	case JoinType::RIGHT_ANTI:
-		return true;
-	default:
-		return false;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipeline, PhysicalOperator &op,
-                                      bool build_rhs) {
-	op.op_state.reset();
-	op.sink_state.reset();
-
-	// 'current' is the probe pipeline: add this operator
-	auto &state = meta_pipeline.GetState();
-	state.AddPipelineOperator(current, op);
-
-	// save the last added pipeline to set up dependencies later (in case we need to add a child pipeline)
-	vector<shared_ptr<Pipeline>> pipelines_so_far;
-	meta_pipeline.GetPipelines(pipelines_so_far, false);
-	auto &last_pipeline = *pipelines_so_far.back();
-
-	vector<shared_ptr<Pipeline>> dependencies;
-	optional_ptr<MetaPipeline> last_child_ptr;
-	if (build_rhs) {
-		// on the RHS (build side), we construct a child MetaPipeline with this operator as its sink
-		auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, op, MetaPipelineType::JOIN_BUILD);
-		child_meta_pipeline.Build(*op.children[1]);
-		if (op.children[1]->CanSaturateThreads(current.GetClientContext())) {
-			// if the build side can saturate all available threads,
-			// we don't just make the LHS pipeline depend on the RHS, but recursively all LHS children too.
-			// this prevents breadth-first plan evaluation
-			child_meta_pipeline.GetPipelines(dependencies, false);
-			last_child_ptr = meta_pipeline.GetLastChild();
-		}
-	}
-
-	// continue building the current pipeline on the LHS (probe side)
-	op.children[0]->BuildPipelines(current, meta_pipeline);
-
-	if (last_child_ptr) {
-		// the pointer was set, set up the dependencies
-		meta_pipeline.AddRecursiveDependencies(dependencies, *last_child_ptr);
-	}
-
-	switch (op.type) {
-	case PhysicalOperatorType::POSITIONAL_JOIN:
-		// Positional joins are always outer
-		meta_pipeline.CreateChildPipeline(current, op, last_pipeline);
-		return;
-	case PhysicalOperatorType::CROSS_PRODUCT:
-		return;
-	default:
-		break;
-	}
-
-	// Join can become a source operator if it's RIGHT/OUTER, or if the hash join goes out-of-core
-	if (op.Cast<PhysicalJoin>().IsSource()) {
-		meta_pipeline.CreateChildPipeline(current, op, last_pipeline);
-	}
-}
-
-void PhysicalJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *this);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalJoin::GetSources() const {
-	auto result = children[0]->GetSources();
-	if (IsSource()) {
-		result.push_back(*this);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_left_delim_join.cpp b/src/duckdb/src/execution/operator/join/physical_left_delim_join.cpp
deleted file mode 100644
index 49f259abc..000000000
--- a/src/duckdb/src/execution/operator/join/physical_left_delim_join.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "duckdb/execution/operator/join/physical_left_delim_join.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_join.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-PhysicalLeftDelimJoin::PhysicalLeftDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-                                             vector<const_reference<PhysicalOperator>> delim_scans,
-                                             idx_t estimated_cardinality, optional_idx delim_idx)
-    : PhysicalDelimJoin(PhysicalOperatorType::LEFT_DELIM_JOIN, std::move(types), std::move(original_join),
-                        std::move(delim_scans), estimated_cardinality, delim_idx) {
-	D_ASSERT(join->children.size() == 2);
-	// now for the original join
-	// we take its left child, this is the side that we will duplicate eliminate
-	children.push_back(std::move(join->children[0]));
-
-	// we replace it with a PhysicalColumnDataScan, that scans the ColumnDataCollection that we keep cached
-	// the actual chunk collection to scan will be created in the LeftDelimJoinGlobalState
-	auto cached_chunk_scan = make_uniq<PhysicalColumnDataScan>(
-	    children[0]->GetTypes(), PhysicalOperatorType::COLUMN_DATA_SCAN, estimated_cardinality, nullptr);
-	if (delim_idx.IsValid()) {
-		cached_chunk_scan->cte_index = delim_idx.GetIndex();
-	}
-	join->children[0] = std::move(cached_chunk_scan);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class LeftDelimJoinGlobalState : public GlobalSinkState {
-public:
-	explicit LeftDelimJoinGlobalState(ClientContext &context, const PhysicalLeftDelimJoin &delim_join)
-	    : lhs_data(context, delim_join.children[0]->GetTypes()) {
-		D_ASSERT(!delim_join.delim_scans.empty());
-		// set up the delim join chunk to scan in the original join
-		auto &cached_chunk_scan = delim_join.join->children[0]->Cast<PhysicalColumnDataScan>();
-		cached_chunk_scan.collection = &lhs_data;
-	}
-
-	ColumnDataCollection lhs_data;
-	mutex lhs_lock;
-
-	void Merge(ColumnDataCollection &input) {
-		lock_guard<mutex> guard(lhs_lock);
-		lhs_data.Combine(input);
-	}
-};
-
-class LeftDelimJoinLocalState : public LocalSinkState {
-public:
-	explicit LeftDelimJoinLocalState(ClientContext &context, const PhysicalLeftDelimJoin &delim_join)
-	    : lhs_data(context, delim_join.children[0]->GetTypes()) {
-		lhs_data.InitializeAppend(append_state);
-	}
-
-	unique_ptr<LocalSinkState> distinct_state;
-	ColumnDataCollection lhs_data;
-	ColumnDataAppendState append_state;
-
-	void Append(DataChunk &input) {
-		lhs_data.Append(input);
-	}
-};
-
-unique_ptr<GlobalSinkState> PhysicalLeftDelimJoin::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<LeftDelimJoinGlobalState>(context, *this);
-	distinct->sink_state = distinct->GetGlobalSinkState(context);
-	if (delim_scans.size() > 1) {
-		PhysicalHashAggregate::SetMultiScan(*distinct->sink_state);
-	}
-	return std::move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalLeftDelimJoin::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<LeftDelimJoinLocalState>(context.client, *this);
-	state->distinct_state = distinct->GetLocalSinkState(context);
-	return std::move(state);
-}
-
-SinkResultType PhysicalLeftDelimJoin::Sink(ExecutionContext &context, DataChunk &chunk,
-                                           OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<LeftDelimJoinLocalState>();
-	lstate.lhs_data.Append(lstate.append_state, chunk);
-	OperatorSinkInput distinct_sink_input {*distinct->sink_state, *lstate.distinct_state, input.interrupt_state};
-	distinct->Sink(context, chunk, distinct_sink_input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalLeftDelimJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<LeftDelimJoinLocalState>();
-	auto &gstate = input.global_state.Cast<LeftDelimJoinGlobalState>();
-	gstate.Merge(lstate.lhs_data);
-
-	OperatorSinkCombineInput distinct_combine_input {*distinct->sink_state, *lstate.distinct_state,
-	                                                 input.interrupt_state};
-	distinct->Combine(context, distinct_combine_input);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-void PhysicalLeftDelimJoin::PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const {
-	distinct->PrepareFinalize(context, *distinct->sink_state);
-}
-
-SinkFinalizeType PhysicalLeftDelimJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
-                                                 OperatorSinkFinalizeInput &input) const {
-	// finalize the distinct HT
-	D_ASSERT(distinct);
-
-	OperatorSinkFinalizeInput finalize_input {*distinct->sink_state, input.interrupt_state};
-	distinct->Finalize(pipeline, event, client, finalize_input);
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalLeftDelimJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	op_state.reset();
-	sink_state.reset();
-
-	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-	child_meta_pipeline.Build(*children[0]);
-
-	D_ASSERT(type == PhysicalOperatorType::LEFT_DELIM_JOIN);
-	// recurse into the actual join
-	// any pipelines in there depend on the main pipeline
-	// any scan of the duplicate eliminated data on the RHS depends on this pipeline
-	// we add an entry to the mapping of (PhysicalOperator*) -> (Pipeline*)
-	auto &state = meta_pipeline.GetState();
-	for (auto &delim_scan : delim_scans) {
-		state.delim_join_dependencies.insert(
-		    make_pair(delim_scan, reference<Pipeline>(*child_meta_pipeline.GetBasePipeline())));
-	}
-	join->BuildPipelines(current, meta_pipeline);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_nested_loop_join.cpp b/src/duckdb/src/execution/operator/join/physical_nested_loop_join.cpp
deleted file mode 100644
index 022337e5a..000000000
--- a/src/duckdb/src/execution/operator/join/physical_nested_loop_join.cpp
+++ /dev/null
@@ -1,470 +0,0 @@
-#include "duckdb/execution/operator/join/physical_nested_loop_join.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/nested_loop_join.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/execution/operator/join/outer_join_marker.hpp"
-
-namespace duckdb {
-
-PhysicalNestedLoopJoin::PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                               unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
-                                               JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::NESTED_LOOP_JOIN, std::move(cond), join_type,
-                             estimated_cardinality) {
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-}
-
-bool PhysicalJoin::HasNullValues(DataChunk &chunk) {
-	for (idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
-		UnifiedVectorFormat vdata;
-		chunk.data[col_idx].ToUnifiedFormat(chunk.size(), vdata);
-
-		if (vdata.validity.AllValid()) {
-			continue;
-		}
-		for (idx_t i = 0; i < chunk.size(); i++) {
-			auto idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(idx)) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-template <bool MATCH>
-static void ConstructSemiOrAntiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	D_ASSERT(left.ColumnCount() == result.ColumnCount());
-	// create the selection vector from the matches that were found
-	idx_t result_count = 0;
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < left.size(); i++) {
-		if (found_match[i] == MATCH) {
-			sel.set_index(result_count++, i);
-		}
-	}
-	// construct the final result
-	if (result_count > 0) {
-		// we only return the columns on the left side
-		// project them using the result selection vector
-		// reference the columns of the left side from the result
-		result.Slice(left, sel, result_count);
-	} else {
-		result.SetCardinality(0);
-	}
-}
-
-void PhysicalJoin::ConstructSemiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	ConstructSemiOrAntiJoinResult<true>(left, result, found_match);
-}
-
-void PhysicalJoin::ConstructAntiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	ConstructSemiOrAntiJoinResult<false>(left, result, found_match);
-}
-
-void PhysicalJoin::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &left, DataChunk &result, bool found_match[],
-                                           bool has_null) {
-	// for the initial set of columns we just reference the left side
-	result.SetCardinality(left);
-	for (idx_t i = 0; i < left.ColumnCount(); i++) {
-		result.data[i].Reference(left.data[i]);
-	}
-	auto &mark_vector = result.data.back();
-	mark_vector.SetVectorType(VectorType::FLAT_VECTOR);
-	// first we set the NULL values from the join keys
-	// if there is any NULL in the keys, the result is NULL
-	auto bool_result = FlatVector::GetData<bool>(mark_vector);
-	auto &mask = FlatVector::Validity(mark_vector);
-	for (idx_t col_idx = 0; col_idx < join_keys.ColumnCount(); col_idx++) {
-		UnifiedVectorFormat jdata;
-		join_keys.data[col_idx].ToUnifiedFormat(join_keys.size(), jdata);
-		if (!jdata.validity.AllValid()) {
-			for (idx_t i = 0; i < join_keys.size(); i++) {
-				auto jidx = jdata.sel->get_index(i);
-				mask.Set(i, jdata.validity.RowIsValid(jidx));
-			}
-		}
-	}
-	// now set the remaining entries to either true or false based on whether a match was found
-	if (found_match) {
-		for (idx_t i = 0; i < left.size(); i++) {
-			bool_result[i] = found_match[i];
-		}
-	} else {
-		memset(bool_result, 0, sizeof(bool) * left.size());
-	}
-	// if the right side contains NULL values, the result of any FALSE becomes NULL
-	if (has_null) {
-		for (idx_t i = 0; i < left.size(); i++) {
-			if (!bool_result[i]) {
-				mask.SetInvalid(i);
-			}
-		}
-	}
-}
-
-bool PhysicalNestedLoopJoin::IsSupported(const vector<JoinCondition> &conditions, JoinType join_type) {
-	if (join_type == JoinType::MARK) {
-		return true;
-	}
-	for (auto &cond : conditions) {
-		if (cond.left->return_type.InternalType() == PhysicalType::STRUCT ||
-		    cond.left->return_type.InternalType() == PhysicalType::LIST ||
-		    cond.left->return_type.InternalType() == PhysicalType::ARRAY) {
-			return false;
-		}
-	}
-	// To avoid situations like https://github.com/duckdb/duckdb/issues/10046
-	// If there is an equality in the conditions, a hash join is planned
-	// with one condition, we can use mark join logic, otherwise we should use physical blockwise nl join
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		return conditions.size() == 1;
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class NestedLoopJoinLocalState : public LocalSinkState {
-public:
-	explicit NestedLoopJoinLocalState(ClientContext &context, const vector<JoinCondition> &conditions)
-	    : rhs_executor(context) {
-		vector<LogicalType> condition_types;
-		for (auto &cond : conditions) {
-			rhs_executor.AddExpression(*cond.right);
-			condition_types.push_back(cond.right->return_type);
-		}
-		right_condition.Initialize(Allocator::Get(context), condition_types);
-	}
-
-	//! The chunk holding the right condition
-	DataChunk right_condition;
-	//! The executor of the RHS condition
-	ExpressionExecutor rhs_executor;
-};
-
-class NestedLoopJoinGlobalState : public GlobalSinkState {
-public:
-	explicit NestedLoopJoinGlobalState(ClientContext &context, const PhysicalNestedLoopJoin &op)
-	    : right_payload_data(context, op.children[1]->types), right_condition_data(context, op.GetJoinTypes()),
-	      has_null(false), right_outer(PropagatesBuildSide(op.join_type)) {
-	}
-
-	mutex nj_lock;
-	//! Materialized data of the RHS
-	ColumnDataCollection right_payload_data;
-	//! Materialized join condition of the RHS
-	ColumnDataCollection right_condition_data;
-	//! Whether or not the RHS of the nested loop join has NULL values
-	atomic<bool> has_null;
-	//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-	OuterJoinMarker right_outer;
-};
-
-vector<LogicalType> PhysicalNestedLoopJoin::GetJoinTypes() const {
-	vector<LogicalType> result;
-	for (auto &op : conditions) {
-		result.push_back(op.right->return_type);
-	}
-	return result;
-}
-
-SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<NestedLoopJoinGlobalState>();
-	auto &nlj_state = input.local_state.Cast<NestedLoopJoinLocalState>();
-
-	// resolve the join expression of the right side
-	nlj_state.right_condition.Reset();
-	nlj_state.rhs_executor.Execute(chunk, nlj_state.right_condition);
-
-	// if we have not seen any NULL values yet, and we are performing a MARK join, check if there are NULL values in
-	// this chunk
-	if (join_type == JoinType::MARK && !gstate.has_null) {
-		if (HasNullValues(nlj_state.right_condition)) {
-			gstate.has_null = true;
-		}
-	}
-
-	// append the payload data and the conditions
-	lock_guard<mutex> nj_guard(gstate.nj_lock);
-	gstate.right_payload_data.Append(chunk);
-	gstate.right_condition_data.Append(nlj_state.right_condition);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalNestedLoopJoin::Combine(ExecutionContext &context,
-                                                      OperatorSinkCombineInput &input) const {
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalNestedLoopJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<NestedLoopJoinGlobalState>();
-	gstate.right_outer.Initialize(gstate.right_payload_data.Count());
-	if (gstate.right_payload_data.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<GlobalSinkState> PhysicalNestedLoopJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<NestedLoopJoinGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalNestedLoopJoin::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<NestedLoopJoinLocalState>(context.client, conditions);
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class PhysicalNestedLoopJoinState : public CachingOperatorState {
-public:
-	PhysicalNestedLoopJoinState(ClientContext &context, const PhysicalNestedLoopJoin &op,
-	                            const vector<JoinCondition> &conditions)
-	    : fetch_next_left(true), fetch_next_right(false), lhs_executor(context), left_tuple(0), right_tuple(0),
-	      left_outer(IsLeftOuterJoin(op.join_type)) {
-		vector<LogicalType> condition_types;
-		for (auto &cond : conditions) {
-			lhs_executor.AddExpression(*cond.left);
-			condition_types.push_back(cond.left->return_type);
-		}
-		auto &allocator = Allocator::Get(context);
-		left_condition.Initialize(allocator, condition_types);
-		right_condition.Initialize(allocator, condition_types);
-		right_payload.Initialize(allocator, op.children[1]->GetTypes());
-		left_outer.Initialize(STANDARD_VECTOR_SIZE);
-	}
-
-	bool fetch_next_left;
-	bool fetch_next_right;
-	DataChunk left_condition;
-	//! The executor of the LHS condition
-	ExpressionExecutor lhs_executor;
-
-	ColumnDataScanState condition_scan_state;
-	ColumnDataScanState payload_scan_state;
-	DataChunk right_condition;
-	DataChunk right_payload;
-
-	idx_t left_tuple;
-	idx_t right_tuple;
-
-	OuterJoinMarker left_outer;
-
-public:
-	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op);
-	}
-};
-
-unique_ptr<OperatorState> PhysicalNestedLoopJoin::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<PhysicalNestedLoopJoinState>(context.client, *this, conditions);
-}
-
-OperatorResultType PhysicalNestedLoopJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input,
-                                                           DataChunk &chunk, GlobalOperatorState &gstate_p,
-                                                           OperatorState &state_p) const {
-	auto &gstate = sink_state->Cast<NestedLoopJoinGlobalState>();
-
-	if (gstate.right_payload_data.Count() == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gstate.has_null, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	switch (join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-	case JoinType::MARK:
-		// simple joins can have max STANDARD_VECTOR_SIZE matches per chunk
-		ResolveSimpleJoin(context, input, chunk, state_p);
-		return OperatorResultType::NEED_MORE_INPUT;
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::OUTER:
-	case JoinType::RIGHT:
-		return ResolveComplexJoin(context, input, chunk, state_p);
-	default:
-		throw NotImplementedException("Unimplemented type " + JoinTypeToString(join_type) + " for nested loop join!");
-	}
-}
-
-void PhysicalNestedLoopJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                               OperatorState &state_p) const {
-	auto &state = state_p.Cast<PhysicalNestedLoopJoinState>();
-	auto &gstate = sink_state->Cast<NestedLoopJoinGlobalState>();
-
-	// resolve the left join condition for the current chunk
-	state.left_condition.Reset();
-	state.lhs_executor.Execute(input, state.left_condition);
-
-	bool found_match[STANDARD_VECTOR_SIZE] = {false};
-	NestedLoopJoinMark::Perform(state.left_condition, gstate.right_condition_data, found_match, conditions);
-	switch (join_type) {
-	case JoinType::MARK:
-		// now construct the mark join result from the found matches
-		PhysicalJoin::ConstructMarkJoinResult(state.left_condition, input, chunk, found_match, gstate.has_null);
-		break;
-	case JoinType::SEMI:
-		// construct the semi join result from the found matches
-		PhysicalJoin::ConstructSemiJoinResult(input, chunk, found_match);
-		break;
-	case JoinType::ANTI:
-		// construct the anti join result from the found matches
-		PhysicalJoin::ConstructAntiJoinResult(input, chunk, found_match);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for simple nested loop join!");
-	}
-}
-
-OperatorResultType PhysicalNestedLoopJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
-                                                              DataChunk &chunk, OperatorState &state_p) const {
-	auto &state = state_p.Cast<PhysicalNestedLoopJoinState>();
-	auto &gstate = sink_state->Cast<NestedLoopJoinGlobalState>();
-
-	idx_t match_count;
-	do {
-		if (state.fetch_next_right) {
-			// we exhausted the chunk on the right: move to the next chunk on the right
-			state.left_tuple = 0;
-			state.right_tuple = 0;
-			state.fetch_next_right = false;
-			// check if we exhausted all chunks on the RHS
-			if (gstate.right_condition_data.Scan(state.condition_scan_state, state.right_condition)) {
-				if (!gstate.right_payload_data.Scan(state.payload_scan_state, state.right_payload)) {
-					throw InternalException("Nested loop join: payload and conditions are unaligned!?");
-				}
-				if (state.right_condition.size() != state.right_payload.size()) {
-					throw InternalException("Nested loop join: payload and conditions are unaligned!?");
-				}
-			} else {
-				// we exhausted all chunks on the right: move to the next chunk on the left
-				state.fetch_next_left = true;
-				if (state.left_outer.Enabled()) {
-					// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-					// have a match found
-					state.left_outer.ConstructLeftJoinResult(input, chunk);
-					state.left_outer.Reset();
-				}
-				return OperatorResultType::NEED_MORE_INPUT;
-			}
-		}
-		if (state.fetch_next_left) {
-			// resolve the left join condition for the current chunk
-			state.left_condition.Reset();
-			state.lhs_executor.Execute(input, state.left_condition);
-
-			state.left_tuple = 0;
-			state.right_tuple = 0;
-			gstate.right_condition_data.InitializeScan(state.condition_scan_state);
-			gstate.right_condition_data.Scan(state.condition_scan_state, state.right_condition);
-
-			gstate.right_payload_data.InitializeScan(state.payload_scan_state);
-			gstate.right_payload_data.Scan(state.payload_scan_state, state.right_payload);
-			state.fetch_next_left = false;
-		}
-		// now we have a left and a right chunk that we can join together
-		// note that we only get here in the case of a LEFT, INNER or FULL join
-		auto &left_chunk = input;
-		auto &right_condition = state.right_condition;
-		auto &right_payload = state.right_payload;
-
-		// sanity check
-		left_chunk.Verify();
-		right_condition.Verify();
-		right_payload.Verify();
-
-		// now perform the join
-		SelectionVector lvector(STANDARD_VECTOR_SIZE), rvector(STANDARD_VECTOR_SIZE);
-		match_count = NestedLoopJoinInner::Perform(state.left_tuple, state.right_tuple, state.left_condition,
-		                                           right_condition, lvector, rvector, conditions);
-		// we have finished resolving the join conditions
-		if (match_count > 0) {
-			// we have matching tuples!
-			// construct the result
-			state.left_outer.SetMatches(lvector, match_count);
-			gstate.right_outer.SetMatches(rvector, match_count, state.condition_scan_state.current_row_index);
-
-			chunk.Slice(input, lvector, match_count);
-			chunk.Slice(right_payload, rvector, match_count, input.ColumnCount());
-		}
-
-		// check if we exhausted the RHS, if we did we need to move to the next right chunk in the next iteration
-		if (state.right_tuple >= right_condition.size()) {
-			state.fetch_next_right = true;
-		}
-	} while (match_count == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class NestedLoopJoinGlobalScanState : public GlobalSourceState {
-public:
-	explicit NestedLoopJoinGlobalScanState(const PhysicalNestedLoopJoin &op) : op(op) {
-		D_ASSERT(op.sink_state);
-		auto &sink = op.sink_state->Cast<NestedLoopJoinGlobalState>();
-		sink.right_outer.InitializeScan(sink.right_payload_data, scan_state);
-	}
-
-	const PhysicalNestedLoopJoin &op;
-	OuterJoinGlobalScanState scan_state;
-
-public:
-	idx_t MaxThreads() override {
-		auto &sink = op.sink_state->Cast<NestedLoopJoinGlobalState>();
-		return sink.right_outer.MaxThreads();
-	}
-};
-
-class NestedLoopJoinLocalScanState : public LocalSourceState {
-public:
-	explicit NestedLoopJoinLocalScanState(const PhysicalNestedLoopJoin &op, NestedLoopJoinGlobalScanState &gstate) {
-		D_ASSERT(op.sink_state);
-		auto &sink = op.sink_state->Cast<NestedLoopJoinGlobalState>();
-		sink.right_outer.InitializeScan(gstate.scan_state, scan_state);
-	}
-
-	OuterJoinLocalScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalNestedLoopJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<NestedLoopJoinGlobalScanState>(*this);
-}
-
-unique_ptr<LocalSourceState> PhysicalNestedLoopJoin::GetLocalSourceState(ExecutionContext &context,
-                                                                         GlobalSourceState &gstate) const {
-	return make_uniq<NestedLoopJoinLocalScanState>(*this, gstate.Cast<NestedLoopJoinGlobalScanState>());
-}
-
-SourceResultType PhysicalNestedLoopJoin::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                 OperatorSourceInput &input) const {
-	D_ASSERT(PropagatesBuildSide(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = sink_state->Cast<NestedLoopJoinGlobalState>();
-	auto &gstate = input.global_state.Cast<NestedLoopJoinGlobalScanState>();
-	auto &lstate = input.local_state.Cast<NestedLoopJoinLocalScanState>();
-
-	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan chunks we still need to output
-	sink.right_outer.Scan(gstate.scan_state, lstate.scan_state, chunk);
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_piecewise_merge_join.cpp b/src/duckdb/src/execution/operator/join/physical_piecewise_merge_join.cpp
deleted file mode 100644
index 8216d91ab..000000000
--- a/src/duckdb/src/execution/operator/join/physical_piecewise_merge_join.cpp
+++ /dev/null
@@ -1,768 +0,0 @@
-#include "duckdb/execution/operator/join/physical_piecewise_merge_join.hpp"
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/sort/comparators.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/join/outer_join_marker.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-namespace duckdb {
-
-PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left,
-                                                       unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
-                                                       JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalRangeJoin(op, PhysicalOperatorType::PIECEWISE_MERGE_JOIN, std::move(left), std::move(right),
-                        std::move(cond), join_type, estimated_cardinality) {
-
-	for (auto &cond : conditions) {
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-
-		// Convert the conditions to sort orders
-		auto left = cond.left->Copy();
-		auto right = cond.right->Copy();
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			lhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left));
-			rhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right));
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			lhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left));
-			rhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right));
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			// Allowed in multi-predicate joins, but can't be first/sort.
-			D_ASSERT(!lhs_orders.empty());
-			lhs_orders.emplace_back(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(left));
-			rhs_orders.emplace_back(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(right));
-			break;
-
-		default:
-			// COMPARE EQUAL not supported with merge join
-			throw NotImplementedException("Unimplemented join type for merge join");
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class MergeJoinLocalState : public LocalSinkState {
-public:
-	explicit MergeJoinLocalState(ClientContext &context, const PhysicalRangeJoin &op, const idx_t child)
-	    : table(context, op, child) {
-	}
-
-	//! The local sort state
-	PhysicalRangeJoin::LocalSortedTable table;
-};
-
-class MergeJoinGlobalState : public GlobalSinkState {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	MergeJoinGlobalState(ClientContext &context, const PhysicalPiecewiseMergeJoin &op) {
-		RowLayout rhs_layout;
-		rhs_layout.Initialize(op.children[1]->types);
-		vector<BoundOrderByNode> rhs_order;
-		rhs_order.emplace_back(op.rhs_orders[0].Copy());
-		table = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout, op);
-	}
-
-	inline idx_t Count() const {
-		return table->count;
-	}
-
-	void Sink(DataChunk &input, MergeJoinLocalState &lstate) {
-		auto &global_sort_state = table->global_sort_state;
-		auto &local_sort_state = lstate.table.local_sort_state;
-
-		// Sink the data into the local sort state
-		lstate.table.Sink(input, global_sort_state);
-
-		// When sorting data reaches a certain size, we sort it
-		if (local_sort_state.SizeInBytes() >= table->memory_per_thread) {
-			local_sort_state.Sort(global_sort_state, true);
-		}
-	}
-
-	unique_ptr<GlobalSortedTable> table;
-};
-
-unique_ptr<GlobalSinkState> PhysicalPiecewiseMergeJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<MergeJoinGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalPiecewiseMergeJoin::GetLocalSinkState(ExecutionContext &context) const {
-	// We only sink the RHS
-	return make_uniq<MergeJoinLocalState>(context.client, *this, 1U);
-}
-
-SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, DataChunk &chunk,
-                                                OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<MergeJoinGlobalState>();
-	auto &lstate = input.local_state.Cast<MergeJoinLocalState>();
-
-	gstate.Sink(chunk, lstate);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context,
-                                                          OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<MergeJoinGlobalState>();
-	auto &lstate = input.local_state.Cast<MergeJoinLocalState>();
-	gstate.table->Combine(lstate.table);
-	auto &client_profiler = QueryProfiler::Get(context.client);
-
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalPiecewiseMergeJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                      OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<MergeJoinGlobalState>();
-	auto &global_sort_state = gstate.table->global_sort_state;
-
-	if (PropagatesBuildSide(join_type)) {
-		// for FULL/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		gstate.table->IntializeMatches();
-	}
-	if (global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Sort the current input child
-	gstate.table->Finalize(pipeline, event);
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class PiecewiseMergeJoinState : public CachingOperatorState {
-public:
-	using LocalSortedTable = PhysicalRangeJoin::LocalSortedTable;
-
-	PiecewiseMergeJoinState(ClientContext &context, const PhysicalPiecewiseMergeJoin &op, bool force_external)
-	    : context(context), allocator(Allocator::Get(context)), op(op),
-	      buffer_manager(BufferManager::GetBufferManager(context)), force_external(force_external),
-	      left_outer(IsLeftOuterJoin(op.join_type)), left_position(0), first_fetch(true), finished(true),
-	      right_position(0), right_chunk_index(0), rhs_executor(context) {
-		vector<LogicalType> condition_types;
-		for (auto &order : op.lhs_orders) {
-			condition_types.push_back(order.expression->return_type);
-		}
-		left_outer.Initialize(STANDARD_VECTOR_SIZE);
-		lhs_layout.Initialize(op.children[0]->types);
-		lhs_payload.Initialize(allocator, op.children[0]->types);
-
-		lhs_order.emplace_back(op.lhs_orders[0].Copy());
-
-		// Set up shared data for multiple predicates
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		condition_types.clear();
-		for (auto &order : op.rhs_orders) {
-			rhs_executor.AddExpression(*order.expression);
-			condition_types.push_back(order.expression->return_type);
-		}
-		rhs_keys.Initialize(allocator, condition_types);
-	}
-
-	ClientContext &context;
-	Allocator &allocator;
-	const PhysicalPiecewiseMergeJoin &op;
-	BufferManager &buffer_manager;
-	bool force_external;
-
-	// Block sorting
-	DataChunk lhs_payload;
-	OuterJoinMarker left_outer;
-	vector<BoundOrderByNode> lhs_order;
-	RowLayout lhs_layout;
-	unique_ptr<LocalSortedTable> lhs_local_table;
-	unique_ptr<GlobalSortState> lhs_global_state;
-	unique_ptr<PayloadScanner> scanner;
-
-	// Simple scans
-	idx_t left_position;
-
-	// Complex scans
-	bool first_fetch;
-	bool finished;
-	idx_t right_position;
-	idx_t right_chunk_index;
-	idx_t right_base;
-	idx_t prev_left_index;
-
-	// Secondary predicate shared data
-	SelectionVector sel;
-	DataChunk rhs_keys;
-	DataChunk rhs_input;
-	ExpressionExecutor rhs_executor;
-	vector<BufferHandle> payload_heap_handles;
-
-public:
-	void ResolveJoinKeys(DataChunk &input) {
-		// sort by join key
-		lhs_global_state = make_uniq<GlobalSortState>(buffer_manager, lhs_order, lhs_layout);
-		lhs_local_table = make_uniq<LocalSortedTable>(context, op, 0U);
-		lhs_local_table->Sink(input, *lhs_global_state);
-
-		// Set external (can be forced with the PRAGMA)
-		lhs_global_state->external = force_external;
-		lhs_global_state->AddLocalState(lhs_local_table->local_sort_state);
-		lhs_global_state->PrepareMergePhase();
-		while (lhs_global_state->sorted_blocks.size() > 1) {
-			MergeSorter merge_sorter(*lhs_global_state, buffer_manager);
-			merge_sorter.PerformInMergeRound();
-			lhs_global_state->CompleteMergeRound();
-		}
-
-		// Scan the sorted payload
-		D_ASSERT(lhs_global_state->sorted_blocks.size() == 1);
-
-		scanner = make_uniq<PayloadScanner>(*lhs_global_state->sorted_blocks[0]->payload_data, *lhs_global_state);
-		lhs_payload.Reset();
-		scanner->Scan(lhs_payload);
-
-		// Recompute the sorted keys from the sorted input
-		lhs_local_table->keys.Reset();
-		lhs_local_table->executor.Execute(lhs_payload, lhs_local_table->keys);
-	}
-
-	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		if (lhs_local_table) {
-			context.thread.profiler.Flush(op);
-		}
-	}
-};
-
-unique_ptr<OperatorState> PhysicalPiecewiseMergeJoin::GetOperatorState(ExecutionContext &context) const {
-	auto &config = ClientConfig::GetConfig(context.client);
-	return make_uniq<PiecewiseMergeJoinState>(context.client, *this, config.force_external);
-}
-
-static inline idx_t SortedBlockNotNull(const idx_t base, const idx_t count, const idx_t not_null) {
-	return MinValue(base + count, MaxValue(base, not_null)) - base;
-}
-
-static int MergeJoinComparisonValue(ExpressionType comparison) {
-	switch (comparison) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return -1;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return 0;
-	default:
-		throw InternalException("Unimplemented comparison type for merge join!");
-	}
-}
-
-struct BlockMergeInfo {
-	GlobalSortState &state;
-	//! The block being scanned
-	const idx_t block_idx;
-	//! The number of not-NULL values in the block (they are at the end)
-	const idx_t not_null;
-	//! The current offset in the block
-	idx_t &entry_idx;
-	SelectionVector result;
-
-	BlockMergeInfo(GlobalSortState &state, idx_t block_idx, idx_t &entry_idx, idx_t not_null)
-	    : state(state), block_idx(block_idx), not_null(not_null), entry_idx(entry_idx), result(STANDARD_VECTOR_SIZE) {
-	}
-};
-
-static void MergeJoinPinSortingBlock(SBScanState &scan, const idx_t block_idx) {
-	scan.SetIndices(block_idx, 0);
-	scan.PinRadix(block_idx);
-
-	auto &sd = *scan.sb->blob_sorting_data;
-	if (block_idx < sd.data_blocks.size()) {
-		scan.PinData(sd);
-	}
-}
-
-static data_ptr_t MergeJoinRadixPtr(SBScanState &scan, const idx_t entry_idx) {
-	scan.entry_idx = entry_idx;
-	return scan.RadixPtr();
-}
-
-static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlobalState &rstate, bool *found_match,
-                                   const ExpressionType comparison) {
-	const auto cmp = MergeJoinComparisonValue(comparison);
-
-	// The sort parameters should all be the same
-	auto &lsort = *lstate.lhs_global_state;
-	auto &rsort = rstate.table->global_sort_state;
-	D_ASSERT(lsort.sort_layout.all_constant == rsort.sort_layout.all_constant);
-	const auto all_constant = lsort.sort_layout.all_constant;
-	D_ASSERT(lsort.external == rsort.external);
-	const auto external = lsort.external;
-
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(lsort.sorted_blocks.size() == 1);
-	SBScanState lread(lsort.buffer_manager, lsort);
-	lread.sb = lsort.sorted_blocks[0].get();
-
-	const idx_t l_block_idx = 0;
-	idx_t l_entry_idx = 0;
-	const auto lhs_not_null = lstate.lhs_local_table->count - lstate.lhs_local_table->has_null;
-	MergeJoinPinSortingBlock(lread, l_block_idx);
-	auto l_ptr = MergeJoinRadixPtr(lread, l_entry_idx);
-
-	D_ASSERT(rsort.sorted_blocks.size() == 1);
-	SBScanState rread(rsort.buffer_manager, rsort);
-	rread.sb = rsort.sorted_blocks[0].get();
-
-	const auto cmp_size = lsort.sort_layout.comparison_size;
-	const auto entry_size = lsort.sort_layout.entry_size;
-
-	idx_t right_base = 0;
-	for (idx_t r_block_idx = 0; r_block_idx < rread.sb->radix_sorting_data.size(); r_block_idx++) {
-		// we only care about the BIGGEST value in each of the RHS data blocks
-		// because we want to figure out if the LHS values are less than [or equal] to ANY value
-		// get the biggest value from the RHS chunk
-		MergeJoinPinSortingBlock(rread, r_block_idx);
-
-		auto &rblock = *rread.sb->radix_sorting_data[r_block_idx];
-		const auto r_not_null =
-		    SortedBlockNotNull(right_base, rblock.count, rstate.table->count - rstate.table->has_null);
-		if (r_not_null == 0) {
-			break;
-		}
-		const auto r_entry_idx = r_not_null - 1;
-		right_base += rblock.count;
-
-		auto r_ptr = MergeJoinRadixPtr(rread, r_entry_idx);
-
-		// now we start from the current lpos value and check if we found a new value that is [<= OR <] the max RHS
-		// value
-		while (true) {
-			int comp_res;
-			if (all_constant) {
-				comp_res = FastMemcmp(l_ptr, r_ptr, cmp_size);
-			} else {
-				lread.entry_idx = l_entry_idx;
-				rread.entry_idx = r_entry_idx;
-				comp_res = Comparators::CompareTuple(lread, rread, l_ptr, r_ptr, lsort.sort_layout, external);
-			}
-
-			if (comp_res <= cmp) {
-				// found a match for lpos, set it in the found_match vector
-				found_match[l_entry_idx] = true;
-				l_entry_idx++;
-				l_ptr += entry_size;
-				if (l_entry_idx >= lhs_not_null) {
-					// early out: we exhausted the entire LHS and they all match
-					return 0;
-				}
-			} else {
-				// we found no match: any subsequent value from the LHS we scan now will be bigger and thus also not
-				// match move to the next RHS chunk
-				break;
-			}
-		}
-	}
-	return 0;
-}
-
-void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   OperatorState &state_p) const {
-	auto &state = state_p.Cast<PiecewiseMergeJoinState>();
-	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
-
-	state.ResolveJoinKeys(input);
-	auto &lhs_table = *state.lhs_local_table;
-
-	// perform the actual join
-	bool found_match[STANDARD_VECTOR_SIZE];
-	memset(found_match, 0, sizeof(found_match));
-	MergeJoinSimpleBlocks(state, gstate, found_match, conditions[0].comparison);
-
-	// use the sorted payload
-	const auto lhs_not_null = lhs_table.count - lhs_table.has_null;
-	auto &payload = state.lhs_payload;
-
-	// now construct the result based on the join result
-	switch (join_type) {
-	case JoinType::MARK: {
-		// The only part of the join keys that is actually used is the validity mask.
-		// Since the payload is sorted, we can just set the tail end of the validity masks to invalid.
-		for (auto &key : lhs_table.keys.data) {
-			key.Flatten(lhs_table.keys.size());
-			auto &mask = FlatVector::Validity(key);
-			if (mask.AllValid()) {
-				continue;
-			}
-			mask.SetAllValid(lhs_not_null);
-			for (idx_t i = lhs_not_null; i < lhs_table.count; ++i) {
-				mask.SetInvalid(i);
-			}
-		}
-		// So we make a set of keys that have the validity mask set for the
-		PhysicalJoin::ConstructMarkJoinResult(lhs_table.keys, payload, chunk, found_match, gstate.table->has_null);
-		break;
-	}
-	case JoinType::SEMI:
-		PhysicalJoin::ConstructSemiJoinResult(payload, chunk, found_match);
-		break;
-	case JoinType::ANTI:
-		PhysicalJoin::ConstructAntiJoinResult(payload, chunk, found_match);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented join type for merge join");
-	}
-}
-
-static idx_t MergeJoinComplexBlocks(BlockMergeInfo &l, BlockMergeInfo &r, const ExpressionType comparison,
-                                    idx_t &prev_left_index) {
-	const auto cmp = MergeJoinComparisonValue(comparison);
-
-	// The sort parameters should all be the same
-	D_ASSERT(l.state.sort_layout.all_constant == r.state.sort_layout.all_constant);
-	const auto all_constant = r.state.sort_layout.all_constant;
-	D_ASSERT(l.state.external == r.state.external);
-	const auto external = l.state.external;
-
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(l.state.sorted_blocks.size() == 1);
-	SBScanState lread(l.state.buffer_manager, l.state);
-	lread.sb = l.state.sorted_blocks[0].get();
-	D_ASSERT(lread.sb->radix_sorting_data.size() == 1);
-	MergeJoinPinSortingBlock(lread, l.block_idx);
-	auto l_start = MergeJoinRadixPtr(lread, 0);
-	auto l_ptr = MergeJoinRadixPtr(lread, l.entry_idx);
-
-	D_ASSERT(r.state.sorted_blocks.size() == 1);
-	SBScanState rread(r.state.buffer_manager, r.state);
-	rread.sb = r.state.sorted_blocks[0].get();
-
-	if (r.entry_idx >= r.not_null) {
-		return 0;
-	}
-
-	MergeJoinPinSortingBlock(rread, r.block_idx);
-	auto r_ptr = MergeJoinRadixPtr(rread, r.entry_idx);
-
-	const auto cmp_size = l.state.sort_layout.comparison_size;
-	const auto entry_size = l.state.sort_layout.entry_size;
-
-	idx_t result_count = 0;
-	while (true) {
-		if (l.entry_idx < prev_left_index) {
-			// left side smaller: found match
-			l.result.set_index(result_count, sel_t(l.entry_idx));
-			r.result.set_index(result_count, sel_t(r.entry_idx));
-			result_count++;
-			// move left side forward
-			l.entry_idx++;
-			l_ptr += entry_size;
-			if (result_count == STANDARD_VECTOR_SIZE) {
-				// out of space!
-				break;
-			}
-			continue;
-		}
-		if (l.entry_idx < l.not_null) {
-			int comp_res;
-			if (all_constant) {
-				comp_res = FastMemcmp(l_ptr, r_ptr, cmp_size);
-			} else {
-				lread.entry_idx = l.entry_idx;
-				rread.entry_idx = r.entry_idx;
-				comp_res = Comparators::CompareTuple(lread, rread, l_ptr, r_ptr, l.state.sort_layout, external);
-			}
-			if (comp_res <= cmp) {
-				// left side smaller: found match
-				l.result.set_index(result_count, sel_t(l.entry_idx));
-				r.result.set_index(result_count, sel_t(r.entry_idx));
-				result_count++;
-				// move left side forward
-				l.entry_idx++;
-				l_ptr += entry_size;
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					break;
-				}
-				continue;
-			}
-		}
-
-		prev_left_index = l.entry_idx;
-		// right side smaller or equal, or left side exhausted: move
-		// right pointer forward reset left side to start
-		r.entry_idx++;
-		if (r.entry_idx >= r.not_null) {
-			break;
-		}
-		r_ptr += entry_size;
-
-		l_ptr = l_start;
-		l.entry_idx = 0;
-	}
-
-	return result_count;
-}
-
-OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
-                                                                  DataChunk &chunk, OperatorState &state_p) const {
-	auto &state = state_p.Cast<PiecewiseMergeJoinState>();
-	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
-	auto &rsorted = *gstate.table->global_sort_state.sorted_blocks[0];
-	const auto left_cols = input.ColumnCount();
-	const auto tail_cols = conditions.size() - 1;
-
-	state.payload_heap_handles.clear();
-	do {
-		if (state.first_fetch) {
-			state.ResolveJoinKeys(input);
-
-			state.right_chunk_index = 0;
-			state.right_base = 0;
-			state.left_position = 0;
-			state.prev_left_index = 0;
-			state.right_position = 0;
-			state.first_fetch = false;
-			state.finished = false;
-		}
-		if (state.finished) {
-			if (state.left_outer.Enabled()) {
-				// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-				// have a match found
-				state.left_outer.ConstructLeftJoinResult(state.lhs_payload, chunk);
-				state.left_outer.Reset();
-			}
-			state.first_fetch = true;
-			state.finished = false;
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-
-		auto &lhs_table = *state.lhs_local_table;
-		const auto lhs_not_null = lhs_table.count - lhs_table.has_null;
-		BlockMergeInfo left_info(*state.lhs_global_state, 0, state.left_position, lhs_not_null);
-
-		const auto &rblock = *rsorted.radix_sorting_data[state.right_chunk_index];
-		const auto rhs_not_null =
-		    SortedBlockNotNull(state.right_base, rblock.count, gstate.table->count - gstate.table->has_null);
-		BlockMergeInfo right_info(gstate.table->global_sort_state, state.right_chunk_index, state.right_position,
-		                          rhs_not_null);
-
-		idx_t result_count =
-		    MergeJoinComplexBlocks(left_info, right_info, conditions[0].comparison, state.prev_left_index);
-		if (result_count == 0) {
-			// exhausted this chunk on the right side
-			// move to the next right chunk
-			state.left_position = 0;
-			state.right_position = 0;
-			state.right_base += rsorted.radix_sorting_data[state.right_chunk_index]->count;
-			state.right_chunk_index++;
-			if (state.right_chunk_index >= rsorted.radix_sorting_data.size()) {
-				state.finished = true;
-			}
-		} else {
-			// found matches: extract them
-			chunk.Reset();
-			for (idx_t c = 0; c < state.lhs_payload.ColumnCount(); ++c) {
-				chunk.data[c].Slice(state.lhs_payload.data[c], left_info.result, result_count);
-			}
-			state.payload_heap_handles.push_back(SliceSortedPayload(chunk, right_info.state, right_info.block_idx,
-			                                                        right_info.result, result_count, left_cols));
-			chunk.SetCardinality(result_count);
-
-			auto sel = FlatVector::IncrementalSelectionVector();
-			if (tail_cols) {
-				// If there are more expressions to compute,
-				// split the result chunk into the left and right halves
-				// so we can compute the values for comparison.
-				chunk.Split(state.rhs_input, left_cols);
-				state.rhs_executor.SetChunk(state.rhs_input);
-				state.rhs_keys.Reset();
-
-				auto tail_count = result_count;
-				for (size_t cmp_idx = 1; cmp_idx < conditions.size(); ++cmp_idx) {
-					Vector left(lhs_table.keys.data[cmp_idx]);
-					left.Slice(left_info.result, result_count);
-
-					auto &right = state.rhs_keys.data[cmp_idx];
-					state.rhs_executor.ExecuteExpression(cmp_idx, right);
-
-					if (tail_count < result_count) {
-						left.Slice(*sel, tail_count);
-						right.Slice(*sel, tail_count);
-					}
-					tail_count =
-					    SelectJoinTail(conditions[cmp_idx].comparison, left, right, sel, tail_count, &state.sel);
-					sel = &state.sel;
-				}
-				chunk.Fuse(state.rhs_input);
-
-				if (tail_count < result_count) {
-					result_count = tail_count;
-					if (result_count == 0) {
-						// Need to reset here otherwise we may use the non-flat chunk when constructing LEFT/OUTER
-						chunk.Reset();
-					} else {
-						chunk.Slice(*sel, result_count);
-					}
-				}
-			}
-
-			// found matches: mark the found matches if required
-			if (state.left_outer.Enabled()) {
-				for (idx_t i = 0; i < result_count; i++) {
-					state.left_outer.SetMatch(left_info.result[sel->get_index(i)]);
-				}
-			}
-			if (gstate.table->found_match) {
-				//	Absolute position of the block + start position inside that block
-				for (idx_t i = 0; i < result_count; i++) {
-					gstate.table->found_match[state.right_base + right_info.result[sel->get_index(i)]] = true;
-				}
-			}
-			chunk.SetCardinality(result_count);
-			chunk.Verify();
-		}
-	} while (chunk.size() == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorResultType PhysicalPiecewiseMergeJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input,
-                                                               DataChunk &chunk, GlobalOperatorState &gstate_p,
-                                                               OperatorState &state) const {
-	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
-
-	if (gstate.Count() == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gstate.table->has_null, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	input.Verify();
-	switch (join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-	case JoinType::MARK:
-		// simple joins can have max STANDARD_VECTOR_SIZE matches per chunk
-		ResolveSimpleJoin(context, input, chunk, state);
-		return OperatorResultType::NEED_MORE_INPUT;
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-	case JoinType::OUTER:
-		return ResolveComplexJoin(context, input, chunk, state);
-	default:
-		throw NotImplementedException("Unimplemented type for piecewise merge loop join!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PiecewiseJoinScanState : public GlobalSourceState {
-public:
-	explicit PiecewiseJoinScanState(const PhysicalPiecewiseMergeJoin &op) : op(op), right_outer_position(0) {
-	}
-
-	mutex lock;
-	const PhysicalPiecewiseMergeJoin &op;
-	unique_ptr<PayloadScanner> scanner;
-	idx_t right_outer_position;
-
-public:
-	idx_t MaxThreads() override {
-		auto &sink = op.sink_state->Cast<MergeJoinGlobalState>();
-		return sink.Count() / (STANDARD_VECTOR_SIZE * idx_t(10));
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalPiecewiseMergeJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<PiecewiseJoinScanState>(*this);
-}
-
-SourceResultType PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &result,
-                                                     OperatorSourceInput &input) const {
-	D_ASSERT(PropagatesBuildSide(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = sink_state->Cast<MergeJoinGlobalState>();
-	auto &state = input.global_state.Cast<PiecewiseJoinScanState>();
-
-	lock_guard<mutex> l(state.lock);
-	if (!state.scanner) {
-		// Initialize scanner (if not yet initialized)
-		auto &sort_state = sink.table->global_sort_state;
-		if (sort_state.sorted_blocks.empty()) {
-			return SourceResultType::FINISHED;
-		}
-		state.scanner = make_uniq<PayloadScanner>(*sort_state.sorted_blocks[0]->payload_data, sort_state);
-	}
-
-	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan the found_match for any chunks we
-	// still need to output
-	const auto found_match = sink.table->found_match.get();
-
-	DataChunk rhs_chunk;
-	rhs_chunk.Initialize(Allocator::Get(context.client), sink.table->global_sort_state.payload_layout.GetTypes());
-	SelectionVector rsel(STANDARD_VECTOR_SIZE);
-	for (;;) {
-		// Read the next sorted chunk
-		state.scanner->Scan(rhs_chunk);
-
-		const auto count = rhs_chunk.size();
-		if (count == 0) {
-			return result.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-		}
-
-		idx_t result_count = 0;
-		// figure out which tuples didn't find a match in the RHS
-		for (idx_t i = 0; i < count; i++) {
-			if (!found_match[state.right_outer_position + i]) {
-				rsel.set_index(result_count++, i);
-			}
-		}
-		state.right_outer_position += count;
-
-		if (result_count > 0) {
-			// if there were any tuples that didn't find a match, output them
-			const idx_t left_column_count = children[0]->types.size();
-			for (idx_t col_idx = 0; col_idx < left_column_count; ++col_idx) {
-				result.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result.data[col_idx], true);
-			}
-			const idx_t right_column_count = children[1]->types.size();
-			;
-			for (idx_t col_idx = 0; col_idx < right_column_count; ++col_idx) {
-				result.data[left_column_count + col_idx].Slice(rhs_chunk.data[col_idx], rsel, result_count);
-			}
-			result.SetCardinality(result_count);
-			break;
-		}
-	}
-
-	return result.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_positional_join.cpp b/src/duckdb/src/execution/operator/join/physical_positional_join.cpp
deleted file mode 100644
index bcf4b498b..000000000
--- a/src/duckdb/src/execution/operator/join/physical_positional_join.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#include "duckdb/execution/operator/join/physical_positional_join.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/join/physical_join.hpp"
-
-namespace duckdb {
-
-PhysicalPositionalJoin::PhysicalPositionalJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-                                               unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::POSITIONAL_JOIN, std::move(types), estimated_cardinality) {
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class PositionalJoinGlobalState : public GlobalSinkState {
-public:
-	explicit PositionalJoinGlobalState(ClientContext &context, const PhysicalPositionalJoin &op)
-	    : rhs(context, op.children[1]->GetTypes()), initialized(false), source_offset(0), exhausted(false) {
-		rhs.InitializeAppend(append_state);
-	}
-
-	ColumnDataCollection rhs;
-	ColumnDataAppendState append_state;
-	mutex rhs_lock;
-
-	bool initialized;
-	ColumnDataScanState scan_state;
-	DataChunk source;
-	idx_t source_offset;
-	bool exhausted;
-
-	void InitializeScan();
-	idx_t Refill();
-	idx_t CopyData(DataChunk &output, const idx_t count, const idx_t col_offset);
-	void Execute(DataChunk &input, DataChunk &output);
-	void GetData(DataChunk &output);
-};
-
-unique_ptr<GlobalSinkState> PhysicalPositionalJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<PositionalJoinGlobalState>(context, *this);
-}
-
-SinkResultType PhysicalPositionalJoin::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-	auto &sink = input.global_state.Cast<PositionalJoinGlobalState>();
-	lock_guard<mutex> client_guard(sink.rhs_lock);
-	sink.rhs.Append(sink.append_state, chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-void PositionalJoinGlobalState::InitializeScan() {
-	if (!initialized) {
-		// not initialized yet: initialize the scan
-		initialized = true;
-		rhs.InitializeScanChunk(source);
-		rhs.InitializeScan(scan_state);
-	}
-}
-
-idx_t PositionalJoinGlobalState::Refill() {
-	if (source_offset >= source.size()) {
-		if (!exhausted) {
-			source.Reset();
-			rhs.Scan(scan_state, source);
-		}
-		source_offset = 0;
-	}
-
-	const auto available = source.size() - source_offset;
-	if (!available) {
-		if (!exhausted) {
-			source.Reset();
-			for (idx_t i = 0; i < source.ColumnCount(); ++i) {
-				auto &vec = source.data[i];
-				vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(vec, true);
-			}
-			exhausted = true;
-		}
-	}
-
-	return available;
-}
-
-idx_t PositionalJoinGlobalState::CopyData(DataChunk &output, const idx_t count, const idx_t col_offset) {
-	if (!source_offset && (source.size() >= count || exhausted)) {
-		//	Fast track: aligned and has enough data
-		for (idx_t i = 0; i < source.ColumnCount(); ++i) {
-			output.data[col_offset + i].Reference(source.data[i]);
-		}
-		source_offset += count;
-	} else {
-		// Copy data
-		for (idx_t target_offset = 0; target_offset < count;) {
-			const auto needed = count - target_offset;
-			const auto available = exhausted ? needed : (source.size() - source_offset);
-			const auto copy_size = MinValue(needed, available);
-			const auto source_count = source_offset + copy_size;
-			for (idx_t i = 0; i < source.ColumnCount(); ++i) {
-				VectorOperations::Copy(source.data[i], output.data[col_offset + i], source_count, source_offset,
-				                       target_offset);
-			}
-			target_offset += copy_size;
-			source_offset += copy_size;
-			Refill();
-		}
-	}
-
-	return source.ColumnCount();
-}
-
-void PositionalJoinGlobalState::Execute(DataChunk &input, DataChunk &output) {
-	lock_guard<mutex> client_guard(rhs_lock);
-
-	// Reference the input and assume it will be full
-	const auto col_offset = input.ColumnCount();
-	for (idx_t i = 0; i < col_offset; ++i) {
-		output.data[i].Reference(input.data[i]);
-	}
-
-	// Copy or reference the RHS columns
-	const auto count = input.size();
-	InitializeScan();
-	Refill();
-	CopyData(output, count, col_offset);
-
-	output.SetCardinality(count);
-}
-
-OperatorResultType PhysicalPositionalJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &sink = sink_state->Cast<PositionalJoinGlobalState>();
-	sink.Execute(input, chunk);
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-void PositionalJoinGlobalState::GetData(DataChunk &output) {
-	lock_guard<mutex> client_guard(rhs_lock);
-
-	InitializeScan();
-	Refill();
-
-	//	LHS exhausted
-	if (exhausted) {
-		//	RHS exhausted too, so we are done
-		output.SetCardinality(0);
-		return;
-	}
-
-	//	LHS is all NULL
-	const auto col_offset = output.ColumnCount() - source.ColumnCount();
-	for (idx_t i = 0; i < col_offset; ++i) {
-		auto &vec = output.data[i];
-		vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(vec, true);
-	}
-
-	//	RHS still has data, so copy it
-	const auto count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, source.size() - source_offset);
-	CopyData(output, count, col_offset);
-	output.SetCardinality(count);
-}
-
-SourceResultType PhysicalPositionalJoin::GetData(ExecutionContext &context, DataChunk &result,
-                                                 OperatorSourceInput &input) const {
-	auto &sink = sink_state->Cast<PositionalJoinGlobalState>();
-	sink.GetData(result);
-
-	return result.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalPositionalJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *this);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalPositionalJoin::GetSources() const {
-	auto result = children[0]->GetSources();
-	if (IsSource()) {
-		result.push_back(*this);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_range_join.cpp b/src/duckdb/src/execution/operator/join/physical_range_join.cpp
deleted file mode 100644
index f7701f845..000000000
--- a/src/duckdb/src/execution/operator/join/physical_range_join.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-#include "duckdb/execution/operator/join/physical_range_join.hpp"
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/sort/comparators.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-
-#include <thread>
-
-namespace duckdb {
-
-PhysicalRangeJoin::LocalSortedTable::LocalSortedTable(ClientContext &context, const PhysicalRangeJoin &op,
-                                                      const idx_t child)
-    : op(op), executor(context), has_null(0), count(0) {
-	// Initialize order clause expression executor and key DataChunk
-	vector<LogicalType> types;
-	for (const auto &cond : op.conditions) {
-		const auto &expr = child ? cond.right : cond.left;
-		executor.AddExpression(*expr);
-
-		types.push_back(expr->return_type);
-	}
-	auto &allocator = Allocator::Get(context);
-	keys.Initialize(allocator, types);
-}
-
-void PhysicalRangeJoin::LocalSortedTable::Sink(DataChunk &input, GlobalSortState &global_sort_state) {
-	// Initialize local state (if necessary)
-	if (!local_sort_state.initialized) {
-		local_sort_state.Initialize(global_sort_state, global_sort_state.buffer_manager);
-	}
-
-	// Obtain sorting columns
-	keys.Reset();
-	executor.Execute(input, keys);
-
-	// Do not operate on primary key directly to avoid modifying the input chunk
-	Vector primary = keys.data[0];
-	// Count the NULLs so we can exclude them later
-	has_null += MergeNulls(primary, op.conditions);
-	count += keys.size();
-
-	//	Only sort the primary key
-	DataChunk join_head;
-	join_head.data.emplace_back(primary);
-	join_head.SetCardinality(keys.size());
-
-	// Sink the data into the local sort state
-	local_sort_state.SinkChunk(join_head, input);
-}
-
-PhysicalRangeJoin::GlobalSortedTable::GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders,
-                                                        RowLayout &payload_layout, const PhysicalOperator &op_p)
-    : op(op_p), global_sort_state(BufferManager::GetBufferManager(context), orders, payload_layout), has_null(0),
-      count(0), memory_per_thread(0) {
-
-	// Set external (can be forced with the PRAGMA)
-	auto &config = ClientConfig::GetConfig(context);
-	global_sort_state.external = config.force_external;
-	memory_per_thread = PhysicalRangeJoin::GetMaxThreadMemory(context);
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::Combine(LocalSortedTable &ltable) {
-	global_sort_state.AddLocalState(ltable.local_sort_state);
-	has_null += ltable.has_null;
-	count += ltable.count;
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::IntializeMatches() {
-	found_match = make_unsafe_uniq_array_uninitialized<bool>(Count());
-	memset(found_match.get(), 0, sizeof(bool) * Count());
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::Print() {
-	global_sort_state.Print();
-}
-
-class RangeJoinMergeTask : public ExecutorTask {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	RangeJoinMergeTask(shared_ptr<Event> event_p, ClientContext &context, GlobalSortedTable &table)
-	    : ExecutorTask(context, std::move(event_p), table.op), context(context), table(table) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		// Initialize iejoin sorted and iterate until done
-		auto &global_sort_state = table.global_sort_state;
-		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
-		merge_sorter.PerformInMergeRound();
-		event->FinishTask();
-
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	ClientContext &context;
-	GlobalSortedTable &table;
-};
-
-class RangeJoinMergeEvent : public BasePipelineEvent {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	RangeJoinMergeEvent(GlobalSortedTable &table_p, Pipeline &pipeline_p)
-	    : BasePipelineEvent(pipeline_p), table(table_p) {
-	}
-
-	GlobalSortedTable &table;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline->GetClientContext();
-
-		// Schedule tasks equal to the number of threads, which will each merge multiple partitions
-		auto &ts = TaskScheduler::GetScheduler(context);
-		auto num_threads = NumericCast<idx_t>(ts.NumberOfThreads());
-
-		vector<shared_ptr<Task>> iejoin_tasks;
-		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			iejoin_tasks.push_back(make_uniq<RangeJoinMergeTask>(shared_from_this(), context, table));
-		}
-		SetTasks(std::move(iejoin_tasks));
-	}
-
-	void FinishEvent() override {
-		auto &global_sort_state = table.global_sort_state;
-
-		global_sort_state.CompleteMergeRound(true);
-		if (global_sort_state.sorted_blocks.size() > 1) {
-			// Multiple blocks remaining: Schedule the next round
-			table.ScheduleMergeTasks(*pipeline, *this);
-		}
-	}
-};
-
-void PhysicalRangeJoin::GlobalSortedTable::ScheduleMergeTasks(Pipeline &pipeline, Event &event) {
-	// Initialize global sort state for a round of merging
-	global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared_ptr<RangeJoinMergeEvent>(*this, pipeline);
-	event.InsertEvent(std::move(new_event));
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::Finalize(Pipeline &pipeline, Event &event) {
-	// Prepare for merge sort phase
-	global_sort_state.PrepareMergePhase();
-
-	// Start the merge phase or finish if a merge is not necessary
-	if (global_sort_state.sorted_blocks.size() > 1) {
-		ScheduleMergeTasks(pipeline, event);
-	}
-}
-
-PhysicalRangeJoin::PhysicalRangeJoin(LogicalComparisonJoin &op, PhysicalOperatorType type,
-                                     unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-                                     vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, type, std::move(cond), join_type, estimated_cardinality) {
-	// Reorder the conditions so that ranges are at the front.
-	// TODO: use stats to improve the choice?
-	// TODO: Prefer fixed length types?
-	if (conditions.size() > 1) {
-		vector<JoinCondition> conditions_p(conditions.size());
-		std::swap(conditions_p, conditions);
-		idx_t range_position = 0;
-		idx_t other_position = conditions_p.size();
-		for (idx_t i = 0; i < conditions_p.size(); ++i) {
-			switch (conditions_p[i].comparison) {
-			case ExpressionType::COMPARE_LESSTHAN:
-			case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			case ExpressionType::COMPARE_GREATERTHAN:
-			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-				conditions[range_position++] = std::move(conditions_p[i]);
-				break;
-			default:
-				conditions[--other_position] = std::move(conditions_p[i]);
-				break;
-			}
-		}
-	}
-
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-
-	//	Fill out the left projection map.
-	left_projection_map = op.left_projection_map;
-	if (left_projection_map.empty()) {
-		const auto left_count = children[0]->types.size();
-		left_projection_map.reserve(left_count);
-		for (column_t i = 0; i < left_count; ++i) {
-			left_projection_map.emplace_back(i);
-		}
-	}
-	//	Fill out the right projection map.
-	right_projection_map = op.right_projection_map;
-	if (right_projection_map.empty()) {
-		const auto right_count = children[1]->types.size();
-		right_projection_map.reserve(right_count);
-		for (column_t i = 0; i < right_count; ++i) {
-			right_projection_map.emplace_back(i);
-		}
-	}
-
-	//	Construct the unprojected type layout from the children's types
-	unprojected_types = children[0]->GetTypes();
-	auto &types = children[1]->GetTypes();
-	unprojected_types.insert(unprojected_types.end(), types.begin(), types.end());
-}
-
-idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(Vector &primary, const vector<JoinCondition> &conditions) {
-	// Merge the validity masks of the comparison keys into the primary
-	// Return the number of NULLs in the resulting chunk
-	D_ASSERT(keys.ColumnCount() > 0);
-	const auto count = keys.size();
-
-	size_t all_constant = 0;
-	for (auto &v : keys.data) {
-		if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			++all_constant;
-		}
-	}
-
-	if (all_constant == keys.data.size()) {
-		//	Either all NULL or no NULLs
-		if (ConstantVector::IsNull(primary)) {
-			// Primary is already NULL
-			return count;
-		}
-		for (size_t c = 1; c < keys.data.size(); ++c) {
-			// Skip comparisons that accept NULLs
-			if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
-				continue;
-			}
-			auto &v = keys.data[c];
-			if (ConstantVector::IsNull(v)) {
-				// Create a new validity mask to avoid modifying original mask
-				auto &pvalidity = ConstantVector::Validity(primary);
-				ValidityMask pvalidity_copy = ConstantVector::Validity(primary);
-				pvalidity.Copy(pvalidity_copy, count);
-				ConstantVector::SetNull(primary, true);
-				return count;
-			}
-		}
-		return 0;
-	} else if (keys.ColumnCount() > 1) {
-		//	Flatten the primary, as it will need to merge arbitrary validity masks
-		primary.Flatten(count);
-		auto &pvalidity = FlatVector::Validity(primary);
-		// Make a copy of validity to avoid modifying original mask
-		ValidityMask pvalidity_copy = FlatVector::Validity(primary);
-		pvalidity.Copy(pvalidity_copy, count);
-
-		D_ASSERT(keys.ColumnCount() == conditions.size());
-		for (size_t c = 1; c < keys.data.size(); ++c) {
-			// Skip comparisons that accept NULLs
-			if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
-				continue;
-			}
-			//	ToUnifiedFormat the rest, as the sort code will do this anyway.
-			auto &v = keys.data[c];
-			UnifiedVectorFormat vdata;
-			v.ToUnifiedFormat(count, vdata);
-			auto &vvalidity = vdata.validity;
-			if (vvalidity.AllValid()) {
-				continue;
-			}
-			pvalidity.EnsureWritable();
-			switch (v.GetVectorType()) {
-			case VectorType::FLAT_VECTOR: {
-				// Merge entire entries
-				auto pmask = pvalidity.GetData();
-				const auto entry_count = pvalidity.EntryCount(count);
-				for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
-					pmask[entry_idx] &= vvalidity.GetValidityEntry(entry_idx);
-				}
-				break;
-			}
-			case VectorType::CONSTANT_VECTOR:
-				// All or nothing
-				if (ConstantVector::IsNull(v)) {
-					pvalidity.SetAllInvalid(count);
-					return count;
-				}
-				break;
-			default:
-				// One by one
-				for (idx_t i = 0; i < count; ++i) {
-					const auto idx = vdata.sel->get_index(i);
-					if (!vvalidity.RowIsValidUnsafe(idx)) {
-						pvalidity.SetInvalidUnsafe(i);
-					}
-				}
-				break;
-			}
-		}
-		return count - pvalidity.CountValid(count);
-	} else {
-		return count - VectorOperations::CountNotNull(primary, count);
-	}
-}
-
-void PhysicalRangeJoin::ProjectResult(DataChunk &chunk, DataChunk &result) const {
-	const auto left_projected = left_projection_map.size();
-	for (idx_t i = 0; i < left_projected; ++i) {
-		result.data[i].Reference(chunk.data[left_projection_map[i]]);
-	}
-	const auto left_width = children[0]->types.size();
-	for (idx_t i = 0; i < right_projection_map.size(); ++i) {
-		result.data[left_projected + i].Reference(chunk.data[left_width + right_projection_map[i]]);
-	}
-	result.SetCardinality(chunk);
-}
-
-BufferHandle PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-                                                   const SelectionVector &result, const idx_t result_count,
-                                                   const idx_t left_cols) {
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(state.sorted_blocks.size() == 1);
-	SBScanState read_state(state.buffer_manager, state);
-	read_state.sb = state.sorted_blocks[0].get();
-	auto &sorted_data = *read_state.sb->payload_data;
-
-	read_state.SetIndices(block_idx, 0);
-	read_state.PinData(sorted_data);
-	const auto data_ptr = read_state.DataPtr(sorted_data);
-	data_ptr_t heap_ptr = nullptr;
-
-	// Set up a batch of pointers to scan data from
-	Vector addresses(LogicalType::POINTER, result_count);
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-
-	// Set up the data pointers for the values that are actually referenced
-	const idx_t &row_width = sorted_data.layout.GetRowWidth();
-
-	auto prev_idx = result.get_index(0);
-	SelectionVector gsel(result_count);
-	idx_t addr_count = 0;
-	gsel.set_index(0, addr_count);
-	data_pointers[addr_count] = data_ptr + prev_idx * row_width;
-	for (idx_t i = 1; i < result_count; ++i) {
-		const auto row_idx = result.get_index(i);
-		if (row_idx != prev_idx) {
-			data_pointers[++addr_count] = data_ptr + row_idx * row_width;
-			prev_idx = row_idx;
-		}
-		gsel.set_index(i, addr_count);
-	}
-	++addr_count;
-
-	// Unswizzle the offsets back to pointers (if needed)
-	if (!sorted_data.layout.AllConstant() && state.external) {
-		heap_ptr = read_state.payload_heap_handle.Ptr();
-	}
-
-	// Deserialize the payload data
-	auto sel = FlatVector::IncrementalSelectionVector();
-	for (idx_t col_no = 0; col_no < sorted_data.layout.ColumnCount(); col_no++) {
-		auto &col = payload.data[left_cols + col_no];
-		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, sorted_data.layout, col_no, 0, heap_ptr);
-		col.Slice(gsel, result_count);
-	}
-
-	return std::move(read_state.payload_heap_handle);
-}
-
-idx_t PhysicalRangeJoin::SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
-                                        const SelectionVector *sel, idx_t count, SelectionVector *true_sel) {
-	switch (condition) {
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return VectorOperations::NotEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return VectorOperations::LessThan(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return VectorOperations::GreaterThan(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return VectorOperations::NotDistinctFrom(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_EQUAL:
-		return VectorOperations::Equals(left, right, sel, count, true_sel, nullptr);
-	default:
-		throw InternalException("Unsupported comparison type for PhysicalRangeJoin");
-	}
-
-	return count;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/join/physical_right_delim_join.cpp b/src/duckdb/src/execution/operator/join/physical_right_delim_join.cpp
deleted file mode 100644
index 60aaeaca8..000000000
--- a/src/duckdb/src/execution/operator/join/physical_right_delim_join.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "duckdb/execution/operator/join/physical_right_delim_join.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_join.hpp"
-#include "duckdb/execution/operator/scan/physical_dummy_scan.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-namespace duckdb {
-
-PhysicalRightDelimJoin::PhysicalRightDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-                                               vector<const_reference<PhysicalOperator>> delim_scans,
-                                               idx_t estimated_cardinality, optional_idx delim_idx)
-    : PhysicalDelimJoin(PhysicalOperatorType::RIGHT_DELIM_JOIN, std::move(types), std::move(original_join),
-                        std::move(delim_scans), estimated_cardinality, delim_idx) {
-	D_ASSERT(join->children.size() == 2);
-	// now for the original join
-	// we take its right child, this is the side that we will duplicate eliminate
-	children.push_back(std::move(join->children[1]));
-
-	// we replace it with a PhysicalDummyScan, which contains no data, just the types, it won't be scanned anyway
-	join->children[1] = make_uniq<PhysicalDummyScan>(children[0]->GetTypes(), estimated_cardinality);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class RightDelimJoinGlobalState : public GlobalSinkState {};
-
-class RightDelimJoinLocalState : public LocalSinkState {
-public:
-	unique_ptr<LocalSinkState> join_state;
-	unique_ptr<LocalSinkState> distinct_state;
-};
-
-unique_ptr<GlobalSinkState> PhysicalRightDelimJoin::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<RightDelimJoinGlobalState>();
-	join->sink_state = join->GetGlobalSinkState(context);
-	distinct->sink_state = distinct->GetGlobalSinkState(context);
-	if (delim_scans.size() > 1) {
-		PhysicalHashAggregate::SetMultiScan(*distinct->sink_state);
-	}
-	return std::move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalRightDelimJoin::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<RightDelimJoinLocalState>();
-	state->join_state = join->GetLocalSinkState(context);
-	state->distinct_state = distinct->GetLocalSinkState(context);
-	return std::move(state);
-}
-
-SinkResultType PhysicalRightDelimJoin::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<RightDelimJoinLocalState>();
-
-	OperatorSinkInput join_sink_input {*join->sink_state, *lstate.join_state, input.interrupt_state};
-	join->Sink(context, chunk, join_sink_input);
-
-	OperatorSinkInput distinct_sink_input {*distinct->sink_state, *lstate.distinct_state, input.interrupt_state};
-	distinct->Sink(context, chunk, distinct_sink_input);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalRightDelimJoin::Combine(ExecutionContext &context,
-                                                      OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<RightDelimJoinLocalState>();
-
-	OperatorSinkCombineInput join_combine_input {*join->sink_state, *lstate.join_state, input.interrupt_state};
-	join->Combine(context, join_combine_input);
-
-	OperatorSinkCombineInput distinct_combine_input {*distinct->sink_state, *lstate.distinct_state,
-	                                                 input.interrupt_state};
-	distinct->Combine(context, distinct_combine_input);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-void PhysicalRightDelimJoin::PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const {
-	join->PrepareFinalize(context, *join->sink_state);
-	distinct->PrepareFinalize(context, *distinct->sink_state);
-}
-
-SinkFinalizeType PhysicalRightDelimJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
-                                                  OperatorSinkFinalizeInput &input) const {
-	D_ASSERT(join);
-	D_ASSERT(distinct);
-
-	OperatorSinkFinalizeInput join_finalize_input {*join->sink_state, input.interrupt_state};
-	join->Finalize(pipeline, event, client, join_finalize_input);
-
-	OperatorSinkFinalizeInput distinct_finalize_input {*distinct->sink_state, input.interrupt_state};
-	distinct->Finalize(pipeline, event, client, distinct_finalize_input);
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalRightDelimJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	op_state.reset();
-	sink_state.reset();
-
-	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-	child_meta_pipeline.Build(*children[0]);
-
-	D_ASSERT(type == PhysicalOperatorType::RIGHT_DELIM_JOIN);
-	// recurse into the actual join
-	// any pipelines in there depend on the main pipeline
-	// any scan of the duplicate eliminated data on the LHS depends on this pipeline
-	// we add an entry to the mapping of (PhysicalOperator*) -> (Pipeline*)
-	auto &state = meta_pipeline.GetState();
-	for (auto &delim_scan : delim_scans) {
-		state.delim_join_dependencies.insert(
-		    make_pair(delim_scan, reference<Pipeline>(*child_meta_pipeline.GetBasePipeline())));
-	}
-
-	// Build join pipelines without building the RHS (already built in the Sink of this op)
-	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *join, false);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/order/physical_order.cpp b/src/duckdb/src/execution/operator/order/physical_order.cpp
deleted file mode 100644
index 71294e9b7..000000000
--- a/src/duckdb/src/execution/operator/order/physical_order.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-#include "duckdb/execution/operator/order/physical_order.hpp"
-
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-
-namespace duckdb {
-
-PhysicalOrder::PhysicalOrder(vector<LogicalType> types, vector<BoundOrderByNode> orders, vector<idx_t> projections,
-                             idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::ORDER_BY, std::move(types), estimated_cardinality),
-      orders(std::move(orders)), projections(std::move(projections)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class OrderGlobalSinkState : public GlobalSinkState {
-public:
-	OrderGlobalSinkState(BufferManager &buffer_manager, const PhysicalOrder &order, RowLayout &payload_layout)
-	    : order(order), global_sort_state(buffer_manager, order.orders, payload_layout) {
-	}
-
-	const PhysicalOrder &order;
-	//! Global sort state
-	GlobalSortState global_sort_state;
-	//! Memory usage per thread
-	idx_t memory_per_thread;
-};
-
-class OrderLocalSinkState : public LocalSinkState {
-public:
-	OrderLocalSinkState(ClientContext &context, const PhysicalOrder &op) : key_executor(context) {
-		// Initialize order clause expression executor and DataChunk
-		vector<LogicalType> key_types;
-		for (auto &order : op.orders) {
-			key_types.push_back(order.expression->return_type);
-			key_executor.AddExpression(*order.expression);
-		}
-		auto &allocator = Allocator::Get(context);
-		keys.Initialize(allocator, key_types);
-		payload.Initialize(allocator, op.types);
-	}
-
-public:
-	//! The local sort state
-	LocalSortState local_sort_state;
-	//! Key expression executor, and chunk to hold the vectors
-	ExpressionExecutor key_executor;
-	DataChunk keys;
-	//! Payload chunk to hold the vectors
-	DataChunk payload;
-};
-
-unique_ptr<GlobalSinkState> PhysicalOrder::GetGlobalSinkState(ClientContext &context) const {
-	// Get the payload layout from the return types
-	RowLayout payload_layout;
-	payload_layout.Initialize(types);
-	auto state = make_uniq<OrderGlobalSinkState>(BufferManager::GetBufferManager(context), *this, payload_layout);
-	// Set external (can be force with the PRAGMA)
-	state->global_sort_state.external = ClientConfig::GetConfig(context).force_external;
-	state->memory_per_thread = GetMaxThreadMemory(context);
-	return std::move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalOrder::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<OrderLocalSinkState>(context.client, *this);
-}
-
-SinkResultType PhysicalOrder::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<OrderGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<OrderLocalSinkState>();
-
-	auto &global_sort_state = gstate.global_sort_state;
-	auto &local_sort_state = lstate.local_sort_state;
-
-	// Initialize local state (if necessary)
-	if (!local_sort_state.initialized) {
-		local_sort_state.Initialize(global_sort_state, BufferManager::GetBufferManager(context.client));
-	}
-
-	// Obtain sorting columns
-	auto &keys = lstate.keys;
-	keys.Reset();
-	lstate.key_executor.Execute(chunk, keys);
-
-	auto &payload = lstate.payload;
-	payload.ReferenceColumns(chunk, projections);
-
-	// Sink the data into the local sort state
-	keys.Verify();
-	chunk.Verify();
-	local_sort_state.SinkChunk(keys, payload);
-
-	// When sorting data reaches a certain size, we sort it
-	if (local_sort_state.SizeInBytes() >= gstate.memory_per_thread) {
-		local_sort_state.Sort(global_sort_state, true);
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalOrder::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<OrderGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<OrderLocalSinkState>();
-	gstate.global_sort_state.AddLocalState(lstate.local_sort_state);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-class PhysicalOrderMergeTask : public ExecutorTask {
-public:
-	PhysicalOrderMergeTask(shared_ptr<Event> event_p, ClientContext &context, OrderGlobalSinkState &state,
-	                       const PhysicalOperator &op_p)
-	    : ExecutorTask(context, std::move(event_p), op_p), context(context), state(state) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		// Initialize merge sorted and iterate until done
-		auto &global_sort_state = state.global_sort_state;
-		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
-		merge_sorter.PerformInMergeRound();
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	ClientContext &context;
-	OrderGlobalSinkState &state;
-};
-
-class OrderMergeEvent : public BasePipelineEvent {
-public:
-	OrderMergeEvent(OrderGlobalSinkState &gstate_p, Pipeline &pipeline_p, const PhysicalOperator &op_p)
-	    : BasePipelineEvent(pipeline_p), gstate(gstate_p), op(op_p) {
-	}
-
-	OrderGlobalSinkState &gstate;
-	const PhysicalOperator &op;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline->GetClientContext();
-
-		// Schedule tasks equal to the number of threads, which will each merge multiple partitions
-		auto &ts = TaskScheduler::GetScheduler(context);
-		auto num_threads = NumericCast<idx_t>(ts.NumberOfThreads());
-
-		vector<shared_ptr<Task>> merge_tasks;
-		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			merge_tasks.push_back(make_uniq<PhysicalOrderMergeTask>(shared_from_this(), context, gstate, op));
-		}
-		SetTasks(std::move(merge_tasks));
-	}
-
-	void FinishEvent() override {
-		auto &global_sort_state = gstate.global_sort_state;
-
-		global_sort_state.CompleteMergeRound();
-		if (global_sort_state.sorted_blocks.size() > 1) {
-			// Multiple blocks remaining: Schedule the next round
-			PhysicalOrder::ScheduleMergeTasks(*pipeline, *this, gstate);
-		}
-	}
-};
-
-SinkFinalizeType PhysicalOrder::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                         OperatorSinkFinalizeInput &input) const {
-	auto &state = input.global_state.Cast<OrderGlobalSinkState>();
-	auto &global_sort_state = state.global_sort_state;
-
-	if (global_sort_state.sorted_blocks.empty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Prepare for merge sort phase
-	global_sort_state.PrepareMergePhase();
-
-	// Start the merge phase or finish if a merge is not necessary
-	if (global_sort_state.sorted_blocks.size() > 1) {
-		PhysicalOrder::ScheduleMergeTasks(pipeline, event, state);
-	}
-	return SinkFinalizeType::READY;
-}
-
-void PhysicalOrder::ScheduleMergeTasks(Pipeline &pipeline, Event &event, OrderGlobalSinkState &state) {
-	// Initialize global sort state for a round of merging
-	state.global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared_ptr<OrderMergeEvent>(state, pipeline, state.order);
-	event.InsertEvent(std::move(new_event));
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PhysicalOrderGlobalSourceState : public GlobalSourceState {
-public:
-	explicit PhysicalOrderGlobalSourceState(OrderGlobalSinkState &sink) : next_batch_index(0) {
-		auto &global_sort_state = sink.global_sort_state;
-		if (global_sort_state.sorted_blocks.empty()) {
-			total_batches = 0;
-		} else {
-			D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-			total_batches = global_sort_state.sorted_blocks[0]->payload_data->data_blocks.size();
-		}
-	}
-
-	idx_t MaxThreads() override {
-		return total_batches;
-	}
-
-public:
-	atomic<idx_t> next_batch_index;
-	idx_t total_batches;
-};
-
-unique_ptr<GlobalSourceState> PhysicalOrder::GetGlobalSourceState(ClientContext &context) const {
-	auto &sink = this->sink_state->Cast<OrderGlobalSinkState>();
-	return make_uniq<PhysicalOrderGlobalSourceState>(sink);
-}
-
-class PhysicalOrderLocalSourceState : public LocalSourceState {
-public:
-	explicit PhysicalOrderLocalSourceState(PhysicalOrderGlobalSourceState &gstate)
-	    : batch_index(gstate.next_batch_index++) {
-	}
-
-public:
-	idx_t batch_index;
-	unique_ptr<PayloadScanner> scanner;
-};
-
-unique_ptr<LocalSourceState> PhysicalOrder::GetLocalSourceState(ExecutionContext &context,
-                                                                GlobalSourceState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<PhysicalOrderGlobalSourceState>();
-	return make_uniq<PhysicalOrderLocalSourceState>(gstate);
-}
-
-SourceResultType PhysicalOrder::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	auto &gstate = input.global_state.Cast<PhysicalOrderGlobalSourceState>();
-	auto &lstate = input.local_state.Cast<PhysicalOrderLocalSourceState>();
-
-	if (lstate.scanner && lstate.scanner->Remaining() == 0) {
-		lstate.batch_index = gstate.next_batch_index++;
-		lstate.scanner = nullptr;
-	}
-
-	if (lstate.batch_index >= gstate.total_batches) {
-		return SourceResultType::FINISHED;
-	}
-
-	if (!lstate.scanner) {
-		auto &sink = this->sink_state->Cast<OrderGlobalSinkState>();
-		auto &global_sort_state = sink.global_sort_state;
-		lstate.scanner = make_uniq<PayloadScanner>(global_sort_state, lstate.batch_index, true);
-	}
-
-	lstate.scanner->Scan(chunk);
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorPartitionData PhysicalOrder::GetPartitionData(ExecutionContext &context, DataChunk &chunk,
-                                                      GlobalSourceState &gstate_p, LocalSourceState &lstate_p,
-                                                      const OperatorPartitionInfo &partition_info) const {
-	if (partition_info.RequiresPartitionColumns()) {
-		throw InternalException("PhysicalOrder::GetPartitionData: partition columns not supported");
-	}
-	auto &lstate = lstate_p.Cast<PhysicalOrderLocalSourceState>();
-	return OperatorPartitionData(lstate.batch_index);
-}
-
-InsertionOrderPreservingMap<string> PhysicalOrder::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string orders_info;
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (i > 0) {
-			orders_info += "\n";
-		}
-		orders_info += orders[i].expression->ToString() + " ";
-		orders_info += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
-	}
-	result["__order_by__"] = orders_info;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/order/physical_top_n.cpp b/src/duckdb/src/execution/operator/order/physical_top_n.cpp
deleted file mode 100644
index 669c25a5e..000000000
--- a/src/duckdb/src/execution/operator/order/physical_top_n.cpp
+++ /dev/null
@@ -1,585 +0,0 @@
-#include "duckdb/execution/operator/order/physical_top_n.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/planner/filter/dynamic_filter.hpp"
-
-namespace duckdb {
-
-PhysicalTopN::PhysicalTopN(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t limit, idx_t offset,
-                           shared_ptr<DynamicFilterData> dynamic_filter_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::TOP_N, std::move(types), estimated_cardinality), orders(std::move(orders)),
-      limit(limit), offset(offset), dynamic_filter(std::move(dynamic_filter_p)) {
-}
-
-PhysicalTopN::~PhysicalTopN() {
-}
-
-//===--------------------------------------------------------------------===//
-// Heaps
-//===--------------------------------------------------------------------===//
-class TopNHeap;
-
-struct TopNEntry {
-	string_t sort_key;
-	idx_t index;
-
-	bool operator<(const TopNEntry &other) const {
-		return sort_key < other.sort_key;
-	}
-};
-
-struct TopNScanState {
-	TopNScanState() : pos(0), sel(STANDARD_VECTOR_SIZE) {
-	}
-
-	idx_t pos;
-	vector<sel_t> scan_order;
-	SelectionVector sel;
-};
-
-struct TopNBoundaryValue {
-	explicit TopNBoundaryValue(const PhysicalTopN &op)
-	    : op(op), boundary_vector(op.orders[0].expression->return_type),
-	      boundary_modifiers(op.orders[0].type, op.orders[0].null_order) {
-	}
-
-	const PhysicalTopN &op;
-	mutex lock;
-	string boundary_value;
-	bool is_set = false;
-	Vector boundary_vector;
-	OrderModifiers boundary_modifiers;
-
-	string GetBoundaryValue() {
-		lock_guard<mutex> l(lock);
-		return boundary_value;
-	}
-
-	void UpdateValue(string_t boundary_val) {
-		unique_lock<mutex> l(lock);
-		if (!is_set || boundary_val < string_t(boundary_value)) {
-			boundary_value = boundary_val.GetString();
-			is_set = true;
-			if (op.dynamic_filter) {
-				CreateSortKeyHelpers::DecodeSortKey(boundary_val, boundary_vector, 0, boundary_modifiers);
-				auto new_dynamic_value = boundary_vector.GetValue(0);
-				l.unlock();
-				op.dynamic_filter->SetValue(std::move(new_dynamic_value));
-			}
-		}
-	}
-};
-
-class TopNHeap {
-public:
-	TopNHeap(ClientContext &context, const vector<LogicalType> &payload_types, const vector<BoundOrderByNode> &orders,
-	         idx_t limit, idx_t offset);
-	TopNHeap(ExecutionContext &context, const vector<LogicalType> &payload_types,
-	         const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset);
-	TopNHeap(ClientContext &context, Allocator &allocator, const vector<LogicalType> &payload_types,
-	         const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset);
-
-	Allocator &allocator;
-	BufferManager &buffer_manager;
-	unsafe_vector<TopNEntry> heap;
-	const vector<LogicalType> &payload_types;
-	const vector<BoundOrderByNode> &orders;
-	vector<OrderModifiers> modifiers;
-	idx_t limit;
-	idx_t offset;
-	idx_t heap_size;
-	ExpressionExecutor executor;
-	DataChunk sort_chunk;
-	DataChunk heap_data;
-	DataChunk payload_chunk;
-	DataChunk sort_keys;
-	StringHeap sort_key_heap;
-
-	SelectionVector matching_sel;
-
-	DataChunk compare_chunk;
-	//! Cached global boundary value as a set of constant vectors
-	DataChunk boundary_values;
-	//! Cached global boundary value in sort-key format
-	string boundary_val;
-	SelectionVector final_sel;
-	SelectionVector true_sel;
-	SelectionVector false_sel;
-	SelectionVector new_remaining_sel;
-
-public:
-	void Sink(DataChunk &input, optional_ptr<TopNBoundaryValue> boundary_value = nullptr);
-	void Combine(TopNHeap &other);
-	void Reduce();
-	void Finalize();
-
-	void InitializeScan(TopNScanState &state, bool exclude_offset);
-	void Scan(TopNScanState &state, DataChunk &chunk);
-
-	bool CheckBoundaryValues(DataChunk &sort_chunk, DataChunk &payload, TopNBoundaryValue &boundary_val);
-	void AddSmallHeap(DataChunk &input, Vector &sort_keys_vec);
-	void AddLargeHeap(DataChunk &input, Vector &sort_keys_vec);
-
-public:
-	idx_t ReduceThreshold() const {
-		return MaxValue<idx_t>(STANDARD_VECTOR_SIZE * 5ULL, 2ULL * heap_size);
-	}
-
-	idx_t InitialHeapAllocSize() const {
-		return MinValue<idx_t>(STANDARD_VECTOR_SIZE * 100ULL, ReduceThreshold()) + STANDARD_VECTOR_SIZE;
-	}
-
-private:
-	inline bool EntryShouldBeAdded(const string_t &sort_key) {
-		if (heap.size() < heap_size) {
-			// heap is full - check the latest entry
-			return true;
-		}
-		if (sort_key < heap.front().sort_key) {
-			// sort key is smaller than current max value
-			return true;
-		}
-		// heap is full and there is no room for the entry
-		return false;
-	}
-
-	inline void AddEntryToHeap(const TopNEntry &entry) {
-		if (heap.size() >= heap_size) {
-			std::pop_heap(heap.begin(), heap.end());
-			heap.pop_back();
-		}
-		heap.push_back(entry);
-		std::push_heap(heap.begin(), heap.end());
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// TopNHeap
-//===--------------------------------------------------------------------===//
-TopNHeap::TopNHeap(ClientContext &context, Allocator &allocator, const vector<LogicalType> &payload_types_p,
-                   const vector<BoundOrderByNode> &orders_p, idx_t limit, idx_t offset)
-    : allocator(allocator), buffer_manager(BufferManager::GetBufferManager(context)), payload_types(payload_types_p),
-      orders(orders_p), limit(limit), offset(offset), heap_size(limit + offset), executor(context),
-      matching_sel(STANDARD_VECTOR_SIZE), final_sel(STANDARD_VECTOR_SIZE), true_sel(STANDARD_VECTOR_SIZE),
-      false_sel(STANDARD_VECTOR_SIZE), new_remaining_sel(STANDARD_VECTOR_SIZE) {
-	// initialize the executor and the sort_chunk
-	vector<LogicalType> sort_types;
-	for (auto &order : orders) {
-		auto &expr = order.expression;
-		sort_types.push_back(expr->return_type);
-		executor.AddExpression(*expr);
-		modifiers.emplace_back(order.type, order.null_order);
-	}
-	heap.reserve(InitialHeapAllocSize());
-	vector<LogicalType> sort_keys_type {LogicalType::BLOB};
-	sort_keys.Initialize(allocator, sort_keys_type);
-	heap_data.Initialize(allocator, payload_types, InitialHeapAllocSize());
-	payload_chunk.Initialize(allocator, payload_types);
-	sort_chunk.Initialize(allocator, sort_types);
-	compare_chunk.Initialize(allocator, sort_types);
-	boundary_values.Initialize(allocator, sort_types);
-}
-
-TopNHeap::TopNHeap(ClientContext &context, const vector<LogicalType> &payload_types,
-                   const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-    : TopNHeap(context, BufferAllocator::Get(context), payload_types, orders, limit, offset) {
-}
-
-TopNHeap::TopNHeap(ExecutionContext &context, const vector<LogicalType> &payload_types,
-                   const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-    : TopNHeap(context.client, Allocator::Get(context.client), payload_types, orders, limit, offset) {
-}
-
-void TopNHeap::AddSmallHeap(DataChunk &input, Vector &sort_keys_vec) {
-	// insert the sort keys into the priority queue
-	constexpr idx_t BASE_INDEX = NumericLimits<uint32_t>::Maximum();
-
-	bool any_added = false;
-	auto sort_key_values = FlatVector::GetData<string_t>(sort_keys_vec);
-	for (idx_t r = 0; r < input.size(); r++) {
-		auto &sort_key = sort_key_values[r];
-		if (!EntryShouldBeAdded(sort_key)) {
-			continue;
-		}
-		// replace the previous top entry with the new entry
-		TopNEntry entry;
-		entry.sort_key = sort_key;
-		entry.index = BASE_INDEX + r;
-		AddEntryToHeap(entry);
-		any_added = true;
-	}
-	if (!any_added) {
-		// early-out: no matches
-		return;
-	}
-
-	// for all matching entries we need to copy over the corresponding payload values
-	idx_t match_count = 0;
-	for (auto &entry : heap) {
-		if (entry.index < BASE_INDEX) {
-			continue;
-		}
-		// this entry was added in this chunk
-		// if not inlined - copy over the string to the string heap
-		if (!entry.sort_key.IsInlined()) {
-			entry.sort_key = sort_key_heap.AddBlob(entry.sort_key);
-		}
-		// to finalize the addition of this entry we need to move over the payload data
-		matching_sel.set_index(match_count, entry.index - BASE_INDEX);
-		entry.index = heap_data.size() + match_count;
-		match_count++;
-	}
-
-	// copy over the input rows to the payload chunk
-	heap_data.Append(input, true, &matching_sel, match_count);
-}
-
-void TopNHeap::AddLargeHeap(DataChunk &input, Vector &sort_keys_vec) {
-	auto sort_key_values = FlatVector::GetData<string_t>(sort_keys_vec);
-	idx_t base_index = heap_data.size();
-	idx_t match_count = 0;
-	for (idx_t r = 0; r < input.size(); r++) {
-		auto &sort_key = sort_key_values[r];
-		if (!EntryShouldBeAdded(sort_key)) {
-			continue;
-		}
-		// replace the previous top entry with the new entry
-		TopNEntry entry;
-		entry.sort_key = sort_key.IsInlined() ? sort_key : sort_key_heap.AddBlob(sort_key);
-		entry.index = base_index + match_count;
-		AddEntryToHeap(entry);
-		matching_sel.set_index(match_count++, r);
-	}
-	if (match_count == 0) {
-		// early-out: no matches
-		return;
-	}
-
-	// copy over the input rows to the payload chunk
-	heap_data.Append(input, true, &matching_sel, match_count);
-}
-
-bool TopNHeap::CheckBoundaryValues(DataChunk &sort_chunk, DataChunk &payload, TopNBoundaryValue &global_boundary) {
-	// get the global boundary value
-	auto current_boundary_val = global_boundary.GetBoundaryValue();
-	if (current_boundary_val.empty()) {
-		// no boundary value (yet) - don't do anything
-		return true;
-	}
-	if (current_boundary_val != boundary_val) {
-		// new boundary value - decode
-		boundary_val = std::move(current_boundary_val);
-		boundary_values.Reset();
-		CreateSortKeyHelpers::DecodeSortKey(string_t(boundary_val), boundary_values, 0, modifiers);
-		for (auto &col : boundary_values.data) {
-			col.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-	boundary_values.SetCardinality(sort_chunk.size());
-
-	// we have boundary values
-	// from these boundary values, determine which values we should insert (if any)
-	idx_t final_count = 0;
-
-	SelectionVector remaining_sel(nullptr);
-	idx_t remaining_count = sort_chunk.size();
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (remaining_sel.data()) {
-			compare_chunk.data[i].Slice(sort_chunk.data[i], remaining_sel, remaining_count);
-		} else {
-			compare_chunk.data[i].Reference(sort_chunk.data[i]);
-		}
-		bool is_last = i + 1 == orders.size();
-		idx_t true_count;
-		if (orders[i].null_order == OrderByNullType::NULLS_LAST) {
-			if (orders[i].type == OrderType::ASCENDING) {
-				true_count = VectorOperations::DistinctLessThan(compare_chunk.data[i], boundary_values.data[i],
-				                                                &remaining_sel, remaining_count, &true_sel, &false_sel);
-			} else {
-				true_count = VectorOperations::DistinctGreaterThanNullsFirst(compare_chunk.data[i],
-				                                                             boundary_values.data[i], &remaining_sel,
-				                                                             remaining_count, &true_sel, &false_sel);
-			}
-		} else {
-			D_ASSERT(orders[i].null_order == OrderByNullType::NULLS_FIRST);
-			if (orders[i].type == OrderType::ASCENDING) {
-				true_count = VectorOperations::DistinctLessThanNullsFirst(compare_chunk.data[i],
-				                                                          boundary_values.data[i], &remaining_sel,
-				                                                          remaining_count, &true_sel, &false_sel);
-			} else {
-				true_count =
-				    VectorOperations::DistinctGreaterThan(compare_chunk.data[i], boundary_values.data[i],
-				                                          &remaining_sel, remaining_count, &true_sel, &false_sel);
-			}
-		}
-
-		if (true_count > 0) {
-			memcpy(final_sel.data() + final_count, true_sel.data(), true_count * sizeof(sel_t));
-			final_count += true_count;
-		}
-		idx_t false_count = remaining_count - true_count;
-		if (!is_last && false_count > 0) {
-			// check what we should continue to check
-			compare_chunk.data[i].Slice(sort_chunk.data[i], false_sel, false_count);
-			remaining_count = VectorOperations::NotDistinctFrom(compare_chunk.data[i], boundary_values.data[i],
-			                                                    &false_sel, false_count, &new_remaining_sel, nullptr);
-			remaining_sel.Initialize(new_remaining_sel);
-		} else {
-			break;
-		}
-	}
-	if (final_count == 0) {
-		return false;
-	}
-	if (final_count < sort_chunk.size()) {
-		sort_chunk.Slice(final_sel, final_count);
-		payload.Slice(final_sel, final_count);
-	}
-	return true;
-}
-
-void TopNHeap::Sink(DataChunk &input, optional_ptr<TopNBoundaryValue> global_boundary) {
-	static constexpr idx_t SMALL_HEAP_THRESHOLD = 100;
-
-	// compute the ordering values for the new chunk
-	sort_chunk.Reset();
-	executor.Execute(input, sort_chunk);
-
-	if (global_boundary) {
-		// if we have a global boundary value check which rows pass before doing anything
-		if (!CheckBoundaryValues(sort_chunk, input, *global_boundary)) {
-			// nothing in this chunk can be in the final result
-			return;
-		}
-	}
-
-	// construct the sort key from the sort chunk
-	sort_keys.Reset();
-	auto &sort_keys_vec = sort_keys.data[0];
-	CreateSortKeyHelpers::CreateSortKey(sort_chunk, modifiers, sort_keys_vec);
-
-	if (heap_size <= SMALL_HEAP_THRESHOLD) {
-		AddSmallHeap(input, sort_keys_vec);
-	} else {
-		AddLargeHeap(input, sort_keys_vec);
-	}
-
-	// if we modified the heap we might be able to update the global boundary
-	// note that the global boundary only applies to FULL heaps
-	if (heap.size() >= heap_size && global_boundary) {
-		global_boundary->UpdateValue(heap.front().sort_key);
-	}
-}
-
-void TopNHeap::Combine(TopNHeap &other) {
-	other.Finalize();
-
-	idx_t match_count = 0;
-	// merge the heap of other into this
-	for (idx_t i = 0; i < other.heap.size(); i++) {
-		// heap is full - check the latest entry
-		auto &other_entry = other.heap[i];
-		auto &sort_key = other_entry.sort_key;
-		if (!EntryShouldBeAdded(sort_key)) {
-			continue;
-		}
-		// add this entry
-		TopNEntry new_entry;
-		new_entry.sort_key = sort_key.IsInlined() ? sort_key : sort_key_heap.AddBlob(sort_key);
-		new_entry.index = heap_data.size() + match_count;
-		AddEntryToHeap(new_entry);
-
-		matching_sel.set_index(match_count++, other_entry.index);
-		if (match_count >= STANDARD_VECTOR_SIZE) {
-			// flush
-			heap_data.Append(other.heap_data, true, &matching_sel, match_count);
-			match_count = 0;
-		}
-	}
-	if (match_count > 0) {
-		// flush
-		heap_data.Append(other.heap_data, true, &matching_sel, match_count);
-		match_count = 0;
-	}
-	Reduce();
-}
-
-void TopNHeap::Finalize() {
-}
-
-void TopNHeap::Reduce() {
-	if (heap_data.size() < ReduceThreshold()) {
-		// only reduce when we pass the reduce threshold
-		return;
-	}
-	// we have too many values in the heap - reduce them
-	StringHeap new_sort_heap;
-	DataChunk new_heap_data;
-	new_heap_data.Initialize(allocator, payload_types, heap.size());
-
-	SelectionVector new_payload_sel(heap.size());
-	for (idx_t i = 0; i < heap.size(); i++) {
-		auto &entry = heap[i];
-		// the entry is not inlined - move the sort key to the new sort heap
-		if (!entry.sort_key.IsInlined()) {
-			entry.sort_key = new_sort_heap.AddBlob(entry.sort_key);
-		}
-		// move this heap entry to position X in the payload chunk
-		new_payload_sel.set_index(i, entry.index);
-		entry.index = i;
-	}
-
-	// copy over the data from the current payload chunk to the new payload chunk
-	new_heap_data.Slice(heap_data, new_payload_sel, heap.size());
-	new_heap_data.Flatten();
-
-	sort_key_heap.Destroy();
-	sort_key_heap.Move(new_sort_heap);
-	heap_data.Reference(new_heap_data);
-}
-
-void TopNHeap::InitializeScan(TopNScanState &state, bool exclude_offset) {
-	auto heap_copy = heap;
-	// traverse the rest of the heap
-	state.scan_order.resize(heap_copy.size());
-	while (!heap_copy.empty()) {
-		std::pop_heap(heap_copy.begin(), heap_copy.end());
-		state.scan_order[heap_copy.size() - 1] = UnsafeNumericCast<sel_t>(heap_copy.back().index);
-		heap_copy.pop_back();
-	}
-	state.pos = exclude_offset ? offset : 0;
-}
-
-void TopNHeap::Scan(TopNScanState &state, DataChunk &chunk) {
-	if (state.pos >= state.scan_order.size()) {
-		return;
-	}
-	SelectionVector sel(state.scan_order.data() + state.pos);
-	idx_t count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.scan_order.size() - state.pos);
-	state.pos += STANDARD_VECTOR_SIZE;
-
-	chunk.Reset();
-	chunk.Slice(heap_data, sel, count);
-}
-
-class TopNGlobalState : public GlobalSinkState {
-public:
-	TopNGlobalState(ClientContext &context, const PhysicalTopN &op)
-	    : heap(context, op.types, op.orders, op.limit, op.offset), boundary_value(op) {
-	}
-
-	mutex lock;
-	TopNHeap heap;
-	TopNBoundaryValue boundary_value;
-};
-
-class TopNLocalState : public LocalSinkState {
-public:
-	TopNLocalState(ExecutionContext &context, const vector<LogicalType> &payload_types,
-	               const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-	    : heap(context, payload_types, orders, limit, offset) {
-	}
-
-	TopNHeap heap;
-};
-
-unique_ptr<LocalSinkState> PhysicalTopN::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<TopNLocalState>(context, types, orders, limit, offset);
-}
-
-unique_ptr<GlobalSinkState> PhysicalTopN::GetGlobalSinkState(ClientContext &context) const {
-	if (dynamic_filter) {
-		dynamic_filter->Reset();
-	}
-	return make_uniq<TopNGlobalState>(context, *this);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalTopN::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	// append to the local sink state
-	auto &gstate = input.global_state.Cast<TopNGlobalState>();
-	auto &sink = input.local_state.Cast<TopNLocalState>();
-	sink.heap.Sink(chunk, &gstate.boundary_value);
-	sink.heap.Reduce();
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-SinkCombineResultType PhysicalTopN::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<TopNGlobalState>();
-	auto &lstate = input.local_state.Cast<TopNLocalState>();
-
-	// scan the local top N and append it to the global heap
-	lock_guard<mutex> glock(gstate.lock);
-	gstate.heap.Combine(lstate.heap);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalTopN::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                        OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<TopNGlobalState>();
-	// global finalize: compute the final top N
-	gstate.heap.Finalize();
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class TopNOperatorState : public GlobalSourceState {
-public:
-	TopNScanState state;
-	bool initialized = false;
-};
-
-unique_ptr<GlobalSourceState> PhysicalTopN::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<TopNOperatorState>();
-}
-
-SourceResultType PhysicalTopN::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	if (limit == 0) {
-		return SourceResultType::FINISHED;
-	}
-	auto &state = input.global_state.Cast<TopNOperatorState>();
-	auto &gstate = sink_state->Cast<TopNGlobalState>();
-
-	if (!state.initialized) {
-		gstate.heap.InitializeScan(state.state, true);
-		state.initialized = true;
-	}
-	gstate.heap.Scan(state.state, chunk);
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalTopN::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Top"] = to_string(limit);
-	if (offset > 0) {
-		result["Offset"] = to_string(offset);
-	}
-
-	string orders_info;
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (i > 0) {
-			orders_info += "\n";
-		}
-		orders_info += orders[i].expression->ToString() + " ";
-		orders_info += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
-	}
-	result["Order By"] = orders_info;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp b/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp
deleted file mode 100644
index 0674181f2..000000000
--- a/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "duckdb/main/appender.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-
-namespace duckdb {
-
-TableCatalogEntry &CSVRejectsTable::GetErrorsTable(ClientContext &context) {
-	auto &temp_catalog = Catalog::GetCatalog(context, TEMP_CATALOG);
-	auto &table_entry = temp_catalog.GetEntry<TableCatalogEntry>(context, TEMP_CATALOG, DEFAULT_SCHEMA, errors_table);
-	return table_entry;
-}
-
-TableCatalogEntry &CSVRejectsTable::GetScansTable(ClientContext &context) {
-	auto &temp_catalog = Catalog::GetCatalog(context, TEMP_CATALOG);
-	auto &table_entry = temp_catalog.GetEntry<TableCatalogEntry>(context, TEMP_CATALOG, DEFAULT_SCHEMA, scan_table);
-	return table_entry;
-}
-
-idx_t CSVRejectsTable::GetCurrentFileIndex(idx_t query_id) {
-	if (current_query_id != query_id) {
-		current_query_id = query_id;
-		current_file_idx = 0;
-	}
-	return current_file_idx++;
-}
-
-shared_ptr<CSVRejectsTable> CSVRejectsTable::GetOrCreate(ClientContext &context, const string &rejects_scan,
-                                                         const string &rejects_error) {
-	// Check that these names can't be the same
-	if (rejects_scan == rejects_error) {
-		throw BinderException("The names of the rejects scan and rejects error tables can't be the same. Use different "
-		                      "names for these tables.");
-	}
-	auto key =
-	    "CSV_REJECTS_TABLE_CACHE_ENTRY_" + StringUtil::Upper(rejects_scan) + "_" + StringUtil::Upper(rejects_error);
-	auto &cache = ObjectCache::GetObjectCache(context);
-	auto &catalog = Catalog::GetCatalog(context, TEMP_CATALOG);
-	auto rejects_scan_exist = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, DEFAULT_SCHEMA, rejects_scan,
-	                                           OnEntryNotFound::RETURN_NULL) != nullptr;
-	auto rejects_error_exist = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, DEFAULT_SCHEMA, rejects_error,
-	                                            OnEntryNotFound::RETURN_NULL) != nullptr;
-	if ((rejects_scan_exist || rejects_error_exist) && !cache.Get<CSVRejectsTable>(key)) {
-		std::ostringstream error;
-		if (rejects_scan_exist) {
-			error << "Reject Scan Table name \"" << rejects_scan << "\" is already in use. ";
-		}
-		if (rejects_error_exist) {
-			error << "Reject Error Table name \"" << rejects_error << "\" is already in use. ";
-		}
-		error << "Either drop the used name(s), or give other name options in the CSV Reader function.\n";
-		throw BinderException(error.str());
-	}
-
-	return cache.GetOrCreate<CSVRejectsTable>(key, rejects_scan, rejects_error);
-}
-
-void CSVRejectsTable::InitializeTable(ClientContext &context, const ReadCSVData &data) {
-	// (Re)Create the temporary rejects table
-	auto &catalog = Catalog::GetCatalog(context, TEMP_CATALOG);
-
-	// Create CSV_ERROR_TYPE ENUM
-	string enum_name = "CSV_ERROR_TYPE";
-	constexpr uint8_t number_of_accepted_errors = 7;
-	Vector order_errors(LogicalType::VARCHAR, number_of_accepted_errors);
-	order_errors.SetValue(0, "CAST");
-	order_errors.SetValue(1, "MISSING COLUMNS");
-	order_errors.SetValue(2, "TOO MANY COLUMNS");
-	order_errors.SetValue(3, "UNQUOTED VALUE");
-	order_errors.SetValue(4, "LINE SIZE OVER MAXIMUM");
-	order_errors.SetValue(5, "INVALID UNICODE");
-	order_errors.SetValue(6, "INVALID STATE");
-
-	LogicalType enum_type = LogicalType::ENUM(enum_name, order_errors, number_of_accepted_errors);
-	auto type_info = make_uniq<CreateTypeInfo>(enum_name, enum_type);
-	type_info->temporary = true;
-	type_info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateType(context, *type_info);
-
-	// Create Rejects Scans Table
-	{
-		auto info = make_uniq<CreateTableInfo>(TEMP_CATALOG, DEFAULT_SCHEMA, scan_table);
-		info->temporary = true;
-		info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-		// 0. Scan ID
-		info->columns.AddColumn(ColumnDefinition("scan_id", LogicalType::UBIGINT));
-		// 1. File ID (within the scan)
-		info->columns.AddColumn(ColumnDefinition("file_id", LogicalType::UBIGINT));
-		// 2. File Path
-		info->columns.AddColumn(ColumnDefinition("file_path", LogicalType::VARCHAR));
-		// 3. Delimiter
-		info->columns.AddColumn(ColumnDefinition("delimiter", LogicalType::VARCHAR));
-		// 4. Quote
-		info->columns.AddColumn(ColumnDefinition("quote", LogicalType::VARCHAR));
-		// 5. Escape
-		info->columns.AddColumn(ColumnDefinition("escape", LogicalType::VARCHAR));
-		// 6. NewLine Delimiter
-		info->columns.AddColumn(ColumnDefinition("newline_delimiter", LogicalType::VARCHAR));
-		// 7. Skip Rows
-		info->columns.AddColumn(ColumnDefinition("skip_rows", LogicalType::UINTEGER));
-		// 8. Has Header
-		info->columns.AddColumn(ColumnDefinition("has_header", LogicalType::BOOLEAN));
-		// 9. List<Struct<Column-Name:Types>>
-		info->columns.AddColumn(ColumnDefinition("columns", LogicalType::VARCHAR));
-		// 10. Date Format
-		info->columns.AddColumn(ColumnDefinition("date_format", LogicalType::VARCHAR));
-		// 11. Timestamp Format
-		info->columns.AddColumn(ColumnDefinition("timestamp_format", LogicalType::VARCHAR));
-		// 12. CSV read function with all the options used
-		info->columns.AddColumn(ColumnDefinition("user_arguments", LogicalType::VARCHAR));
-		catalog.CreateTable(context, std::move(info));
-	}
-	{
-		// Create Rejects Error Table
-		auto info = make_uniq<CreateTableInfo>(TEMP_CATALOG, DEFAULT_SCHEMA, errors_table);
-		info->temporary = true;
-		info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-		// 0. Scan ID
-		info->columns.AddColumn(ColumnDefinition("scan_id", LogicalType::UBIGINT));
-		// 1. File ID (within the scan)
-		info->columns.AddColumn(ColumnDefinition("file_id", LogicalType::UBIGINT));
-		// 2. Row Line
-		info->columns.AddColumn(ColumnDefinition("line", LogicalType::UBIGINT));
-		// 3. Byte Position of the start of the line
-		info->columns.AddColumn(ColumnDefinition("line_byte_position", LogicalType::UBIGINT));
-		// 4. Byte Position where error occurred
-		info->columns.AddColumn(ColumnDefinition("byte_position", LogicalType::UBIGINT));
-		// 5. Column Index (If Applicable)
-		info->columns.AddColumn(ColumnDefinition("column_idx", LogicalType::UBIGINT));
-		// 6. Column Name (If Applicable)
-		info->columns.AddColumn(ColumnDefinition("column_name", LogicalType::VARCHAR));
-		// 7. Error Type
-		info->columns.AddColumn(ColumnDefinition("error_type", enum_type));
-		// 8. Original CSV Line
-		info->columns.AddColumn(ColumnDefinition("csv_line", LogicalType::VARCHAR));
-		// 9. Full Error Message
-		info->columns.AddColumn(ColumnDefinition("error_message", LogicalType::VARCHAR));
-		catalog.CreateTable(context, std::move(info));
-	}
-
-	count = 0;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_batch_copy_to_file.cpp b/src/duckdb/src/execution/operator/persistent/physical_batch_copy_to_file.cpp
deleted file mode 100644
index 4effccaff..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_batch_copy_to_file.cpp
+++ /dev/null
@@ -1,629 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/persistent/batch_memory_manager.hpp"
-#include "duckdb/execution/operator/persistent/batch_task_manager.hpp"
-#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct ActiveFlushGuard {
-	explicit ActiveFlushGuard(atomic<bool> &bool_value_p) : bool_value(bool_value_p) {
-		bool_value = true;
-	}
-	~ActiveFlushGuard() {
-		bool_value = false;
-	}
-
-	atomic<bool> &bool_value;
-};
-
-PhysicalBatchCopyToFile::PhysicalBatchCopyToFile(vector<LogicalType> types, CopyFunction function_p,
-                                                 unique_ptr<FunctionData> bind_data_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::BATCH_COPY_TO_FILE, std::move(types), estimated_cardinality),
-      function(std::move(function_p)), bind_data(std::move(bind_data_p)) {
-	if (!function.flush_batch || !function.prepare_batch) {
-		throw InternalException("PhysicalFixedBatchCopy created for copy function that does not have "
-		                        "prepare_batch/flush_batch defined");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// States
-//===--------------------------------------------------------------------===//
-class BatchCopyTask {
-public:
-	virtual ~BatchCopyTask() {
-	}
-
-	virtual void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) = 0;
-};
-
-struct FixedRawBatchData {
-	FixedRawBatchData(idx_t memory_usage_p, unique_ptr<ColumnDataCollection> collection_p)
-	    : memory_usage(memory_usage_p), collection(std::move(collection_p)) {
-	}
-
-	idx_t memory_usage;
-	unique_ptr<ColumnDataCollection> collection;
-};
-
-struct FixedPreparedBatchData {
-	idx_t memory_usage;
-	unique_ptr<PreparedBatchData> prepared_data;
-};
-
-class FixedBatchCopyGlobalState : public GlobalSinkState {
-public:
-	// heuristic - we need at least 4MB of cache space per column per thread we launch
-	static constexpr const idx_t MINIMUM_MEMORY_PER_COLUMN_PER_THREAD = 4ULL * 1024ULL * 1024ULL;
-
-public:
-	explicit FixedBatchCopyGlobalState(ClientContext &context_p, unique_ptr<GlobalFunctionData> global_state,
-	                                   idx_t minimum_memory_per_thread)
-	    : memory_manager(context_p, minimum_memory_per_thread), rows_copied(0), global_state(std::move(global_state)),
-	      batch_size(0), scheduled_batch_index(0), flushed_batch_index(0), any_flushing(false), any_finished(false),
-	      minimum_memory_per_thread(minimum_memory_per_thread) {
-	}
-
-	BatchMemoryManager memory_manager;
-	BatchTaskManager<BatchCopyTask> task_manager;
-	mutex lock;
-	mutex flush_lock;
-	//! The total number of rows copied to the file
-	atomic<idx_t> rows_copied;
-	//! Global copy state
-	unique_ptr<GlobalFunctionData> global_state;
-	//! The desired batch size (if any)
-	idx_t batch_size;
-	//! Unpartitioned batches
-	map<idx_t, unique_ptr<FixedRawBatchData>> raw_batches;
-	//! The prepared batch data by batch index - ready to flush
-	map<idx_t, unique_ptr<FixedPreparedBatchData>> batch_data;
-	//! The index of the latest batch index that has been scheduled
-	atomic<idx_t> scheduled_batch_index;
-	//! The index of the latest batch index that has been flushed
-	atomic<idx_t> flushed_batch_index;
-	//! Whether or not any thread is flushing
-	atomic<bool> any_flushing;
-	//! Whether or not any threads are finished
-	atomic<bool> any_finished;
-	//! Minimum memory per thread
-	idx_t minimum_memory_per_thread;
-
-	void AddBatchData(idx_t batch_index, unique_ptr<PreparedBatchData> new_batch, idx_t memory_usage) {
-		// move the batch data to the set of prepared batch data
-		lock_guard<mutex> l(lock);
-		auto prepared_data = make_uniq<FixedPreparedBatchData>();
-		prepared_data->prepared_data = std::move(new_batch);
-		prepared_data->memory_usage = memory_usage;
-		auto entry = batch_data.insert(make_pair(batch_index, std::move(prepared_data)));
-		if (!entry.second) {
-			throw InternalException("Duplicate batch index %llu encountered in PhysicalFixedBatchCopy", batch_index);
-		}
-	}
-
-	idx_t MaxThreads(idx_t source_max_threads) override {
-		// try to request 4MB per column per thread
-		memory_manager.SetMemorySize(source_max_threads * minimum_memory_per_thread);
-		// cap the concurrent threads working on this task based on the amount of available memory
-		return MinValue<idx_t>(source_max_threads, memory_manager.AvailableMemory() / minimum_memory_per_thread + 1);
-	}
-};
-
-enum class FixedBatchCopyState : uint8_t { SINKING_DATA = 1, PROCESSING_TASKS = 2 };
-
-class FixedBatchCopyLocalState : public LocalSinkState {
-public:
-	explicit FixedBatchCopyLocalState(unique_ptr<LocalFunctionData> local_state_p)
-	    : local_state(std::move(local_state_p)), rows_copied(0), local_memory_usage(0) {
-	}
-
-	//! Local copy state
-	unique_ptr<LocalFunctionData> local_state;
-	//! The current collection we are appending to
-	unique_ptr<ColumnDataCollection> collection;
-	//! The append state of the collection
-	ColumnDataAppendState append_state;
-	//! How many rows have been copied in total
-	idx_t rows_copied;
-	//! Memory usage of the thread-local collection
-	idx_t local_memory_usage;
-	//! The current batch index
-	optional_idx batch_index;
-	//! Current task
-	FixedBatchCopyState current_task = FixedBatchCopyState::SINKING_DATA;
-
-	void InitializeCollection(ClientContext &context, const PhysicalOperator &op) {
-		collection = make_uniq<ColumnDataCollection>(BufferAllocator::Get(context), op.children[0]->types);
-		collection->InitializeAppend(append_state);
-		local_memory_usage = 0;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalBatchCopyToFile::Sink(ExecutionContext &context, DataChunk &chunk,
-                                             OperatorSinkInput &input) const {
-	auto &state = input.local_state.Cast<FixedBatchCopyLocalState>();
-	auto &gstate = input.global_state.Cast<FixedBatchCopyGlobalState>();
-	auto &memory_manager = gstate.memory_manager;
-	auto batch_index = state.partition_info.batch_index.GetIndex();
-	if (state.current_task == FixedBatchCopyState::PROCESSING_TASKS) {
-		ExecuteTasks(context.client, gstate);
-		FlushBatchData(context.client, gstate);
-
-		if (!memory_manager.IsMinimumBatchIndex(batch_index) && memory_manager.OutOfMemory(batch_index)) {
-			auto guard = memory_manager.Lock();
-			if (!memory_manager.IsMinimumBatchIndex(batch_index)) {
-				// no tasks to process, we are not the minimum batch index and we have no memory available to buffer
-				// block the task for now
-				return memory_manager.BlockSink(guard, input.interrupt_state);
-			}
-		}
-		state.current_task = FixedBatchCopyState::SINKING_DATA;
-	}
-	if (!memory_manager.IsMinimumBatchIndex(batch_index)) {
-		memory_manager.UpdateMinBatchIndex(state.partition_info.min_batch_index.GetIndex());
-
-		// we are not processing the current min batch index
-		// check if we have exceeded the maximum number of unflushed rows
-		if (memory_manager.OutOfMemory(batch_index)) {
-			// out-of-memory - stop sinking chunks and instead assist in processing tasks for the minimum batch index
-			state.current_task = FixedBatchCopyState::PROCESSING_TASKS;
-			return Sink(context, chunk, input);
-		}
-	}
-	if (!state.collection) {
-		state.InitializeCollection(context.client, *this);
-		state.batch_index = batch_index;
-	}
-	state.rows_copied += chunk.size();
-	state.collection->Append(state.append_state, chunk);
-	auto new_memory_usage = state.collection->AllocationSize();
-	if (new_memory_usage > state.local_memory_usage) {
-		// memory usage increased - add to global state
-		memory_manager.IncreaseUnflushedMemory(new_memory_usage - state.local_memory_usage);
-		state.local_memory_usage = new_memory_usage;
-	} else if (new_memory_usage < state.local_memory_usage) {
-		throw InternalException("PhysicalFixedBatchCopy - memory usage decreased somehow?");
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalBatchCopyToFile::Combine(ExecutionContext &context,
-                                                       OperatorSinkCombineInput &input) const {
-	auto &state = input.local_state.Cast<FixedBatchCopyLocalState>();
-	auto &gstate = input.global_state.Cast<FixedBatchCopyGlobalState>();
-	auto &memory_manager = gstate.memory_manager;
-	gstate.rows_copied += state.rows_copied;
-
-	// add any final remaining local batches
-	AddLocalBatch(context.client, gstate, state);
-
-	if (!gstate.any_finished) {
-		// signal that this thread is finished processing batches and that we should move on to Finalize
-		lock_guard<mutex> l(gstate.lock);
-		gstate.any_finished = true;
-	}
-	memory_manager.UpdateMinBatchIndex(state.partition_info.min_batch_index.GetIndex());
-	ExecuteTasks(context.client, gstate);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// ProcessRemainingBatchesEvent
-//===--------------------------------------------------------------------===//
-class ProcessRemainingBatchesTask : public ExecutorTask {
-public:
-	ProcessRemainingBatchesTask(Executor &executor, shared_ptr<Event> event_p, FixedBatchCopyGlobalState &state_p,
-	                            ClientContext &context, const PhysicalBatchCopyToFile &op)
-	    : ExecutorTask(executor, std::move(event_p)), op(op), gstate(state_p), context(context) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		while (op.ExecuteTask(context, gstate)) {
-			op.FlushBatchData(context, gstate);
-		}
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	const PhysicalBatchCopyToFile &op;
-	FixedBatchCopyGlobalState &gstate;
-	ClientContext &context;
-};
-
-class ProcessRemainingBatchesEvent : public BasePipelineEvent {
-public:
-	ProcessRemainingBatchesEvent(const PhysicalBatchCopyToFile &op_p, FixedBatchCopyGlobalState &gstate_p,
-	                             Pipeline &pipeline_p, ClientContext &context)
-	    : BasePipelineEvent(pipeline_p), op(op_p), gstate(gstate_p), context(context) {
-	}
-	const PhysicalBatchCopyToFile &op;
-	FixedBatchCopyGlobalState &gstate;
-	ClientContext &context;
-
-public:
-	void Schedule() override {
-		vector<shared_ptr<Task>> tasks;
-		for (idx_t i = 0; i < idx_t(TaskScheduler::GetScheduler(context).NumberOfThreads()); i++) {
-			auto process_task =
-			    make_uniq<ProcessRemainingBatchesTask>(pipeline->executor, shared_from_this(), gstate, context, op);
-			tasks.push_back(std::move(process_task));
-		}
-		D_ASSERT(!tasks.empty());
-		SetTasks(std::move(tasks));
-	}
-
-	void FinishEvent() override {
-		//! Now that all batches are processed we finish flushing the file to disk
-		op.FinalFlush(context, gstate);
-	}
-};
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalBatchCopyToFile::FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-	if (gstate.task_manager.TaskCount() != 0) {
-		throw InternalException("Unexecuted tasks are remaining in PhysicalFixedBatchCopy::FinalFlush!?");
-	}
-
-	FlushBatchData(context, gstate_p);
-	if (gstate.scheduled_batch_index != gstate.flushed_batch_index) {
-		throw InternalException("Not all batches were flushed to disk - incomplete file?");
-	}
-	if (function.copy_to_finalize) {
-		function.copy_to_finalize(context, *bind_data, *gstate.global_state);
-
-		if (use_tmp_file) {
-			PhysicalCopyToFile::MoveTmpFile(context, file_path);
-		}
-	}
-	gstate.memory_manager.FinalCheck();
-	return SinkFinalizeType::READY;
-}
-
-SinkFinalizeType PhysicalBatchCopyToFile::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<FixedBatchCopyGlobalState>();
-	auto min_batch_index = idx_t(NumericLimits<int64_t>::Maximum());
-	// repartition any remaining batches
-	RepartitionBatches(context, input.global_state, min_batch_index, true);
-	// check if we have multiple tasks to execute
-	if (gstate.task_manager.TaskCount() <= 1) {
-		// we don't - just execute the remaining task and finish flushing to disk
-		ExecuteTasks(context, input.global_state);
-		FinalFlush(context, input.global_state);
-	} else {
-		// we have multiple tasks remaining - launch an event to execute the tasks in parallel
-		auto new_event = make_shared_ptr<ProcessRemainingBatchesEvent>(*this, gstate, pipeline, context);
-		event.InsertEvent(std::move(new_event));
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Tasks
-//===--------------------------------------------------------------------===//
-class RepartitionedFlushTask : public BatchCopyTask {
-public:
-	RepartitionedFlushTask() {
-	}
-
-	void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) override {
-		op.FlushBatchData(context, gstate_p);
-	}
-};
-
-class PrepareBatchTask : public BatchCopyTask {
-public:
-	PrepareBatchTask(idx_t batch_index, unique_ptr<FixedRawBatchData> batch_data_p)
-	    : batch_index(batch_index), batch_data(std::move(batch_data_p)) {
-	}
-
-	idx_t batch_index;
-	unique_ptr<FixedRawBatchData> batch_data;
-
-	void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) override {
-		auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-		auto memory_usage = batch_data->memory_usage;
-		auto prepared_batch =
-		    op.function.prepare_batch(context, *op.bind_data, *gstate.global_state, std::move(batch_data->collection));
-		gstate.AddBatchData(batch_index, std::move(prepared_batch), memory_usage);
-		if (batch_index == gstate.flushed_batch_index) {
-			gstate.task_manager.AddTask(make_uniq<RepartitionedFlushTask>());
-		}
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Batch Data Handling
-//===--------------------------------------------------------------------===//
-void PhysicalBatchCopyToFile::AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index,
-                                              unique_ptr<FixedRawBatchData> raw_batch) const {
-	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-
-	// add the batch index to the set of raw batches
-	lock_guard<mutex> l(gstate.lock);
-	auto entry = gstate.raw_batches.insert(make_pair(batch_index, std::move(raw_batch)));
-	if (!entry.second) {
-		throw InternalException("Duplicate batch index %llu encountered in PhysicalFixedBatchCopy", batch_index);
-	}
-}
-
-static bool CorrectSizeForBatch(idx_t collection_size, idx_t desired_size) {
-	if (desired_size == 0) {
-		// a batch size of 0 indicates we are happy with any batch size
-		return true;
-	}
-	return idx_t(AbsValue<int64_t>(int64_t(collection_size) - int64_t(desired_size))) < STANDARD_VECTOR_SIZE;
-}
-
-void PhysicalBatchCopyToFile::RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index,
-                                                 bool final) const {
-	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-	auto &task_manager = gstate.task_manager;
-
-	// repartition batches until the min index is reached
-	lock_guard<mutex> l(gstate.lock);
-	if (gstate.raw_batches.empty()) {
-		return;
-	}
-	if (!final) {
-		if (gstate.any_finished) {
-			// we only repartition in ::NextBatch if all threads are still busy processing batches
-			// otherwise we might end up repartitioning a lot of data with only a few threads remaining
-			// which causes erratic performance
-			return;
-		}
-		// if this is not the final flush we first check if we have enough data to merge past the batch threshold
-		idx_t candidate_rows = 0;
-		for (auto entry = gstate.raw_batches.begin(); entry != gstate.raw_batches.end(); entry++) {
-			if (entry->first >= min_index) {
-				// we have exceeded the minimum batch
-				break;
-			}
-			candidate_rows += entry->second->collection->Count();
-		}
-		if (candidate_rows < gstate.batch_size) {
-			// not enough rows - cancel!
-			return;
-		}
-	}
-	// gather all collections we can repartition
-	idx_t max_batch_index = 0;
-	vector<unique_ptr<FixedRawBatchData>> raw_batches;
-	for (auto entry = gstate.raw_batches.begin(); entry != gstate.raw_batches.end();) {
-		if (entry->first >= min_index) {
-			break;
-		}
-		max_batch_index = entry->first;
-		raw_batches.push_back(std::move(entry->second));
-		entry = gstate.raw_batches.erase(entry);
-	}
-	unique_ptr<FixedRawBatchData> append_batch;
-	ColumnDataAppendState append_state;
-	// now perform the actual repartitioning
-	for (auto &current_batch : raw_batches) {
-		if (!append_batch) {
-			auto current_count = current_batch->collection->Count();
-			if (CorrectSizeForBatch(current_count, gstate.batch_size)) {
-				// the collection is ~approximately equal to the batch size (off by at most one vector)
-				// use it directly
-				task_manager.AddTask(
-				    make_uniq<PrepareBatchTask>(gstate.scheduled_batch_index++, std::move(current_batch)));
-				current_batch.reset();
-			} else if (current_count < gstate.batch_size) {
-				// the collection is smaller than the batch size - use it as a starting point
-				append_batch = std::move(current_batch);
-				current_batch.reset();
-			} else {
-				// the collection is too large for a batch - we need to repartition
-				// create an empty collection
-				auto new_collection =
-				    make_uniq<ColumnDataCollection>(BufferAllocator::Get(context), children[0]->types);
-				append_batch = make_uniq<FixedRawBatchData>(0U, std::move(new_collection));
-			}
-			if (append_batch) {
-				append_batch->collection->InitializeAppend(append_state);
-			}
-		}
-		if (!current_batch) {
-			// we have consumed the collection already - no need to append
-			continue;
-		}
-		auto &current_collection = *current_batch->collection;
-		append_batch->memory_usage += current_batch->memory_usage;
-		// iterate the collection while appending
-		for (auto &chunk : current_collection.Chunks()) {
-			// append the chunk to the collection
-			append_batch->collection->Append(append_state, chunk);
-			if (append_batch->collection->Count() < gstate.batch_size) {
-				// the collection is still under the batch size - continue
-				continue;
-			}
-			// the collection is full - move it to the result and create a new one
-			task_manager.AddTask(make_uniq<PrepareBatchTask>(gstate.scheduled_batch_index++, std::move(append_batch)));
-
-			auto new_collection = make_uniq<ColumnDataCollection>(BufferAllocator::Get(context), children[0]->types);
-			append_batch = make_uniq<FixedRawBatchData>(0U, std::move(new_collection));
-			append_batch->collection->InitializeAppend(append_state);
-		}
-	}
-	if (append_batch && append_batch->collection->Count() > 0) {
-		// if there are any remaining batches that are not filled up to the batch size
-		// AND this is not the final collection
-		// re-add it to the set of raw (to-be-merged) batches
-		if (final || CorrectSizeForBatch(append_batch->collection->Count(), gstate.batch_size)) {
-			task_manager.AddTask(make_uniq<PrepareBatchTask>(gstate.scheduled_batch_index++, std::move(append_batch)));
-		} else {
-			gstate.raw_batches[max_batch_index] = std::move(append_batch);
-		}
-	}
-}
-
-void PhysicalBatchCopyToFile::FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-	auto &memory_manager = gstate.memory_manager;
-
-	// flush batch data to disk (if there are any to flush)
-	// grab the flush lock - we can only call flush_batch with this lock
-	// otherwise the data might end up in the wrong order
-	{
-		lock_guard<mutex> l(gstate.flush_lock);
-		if (gstate.any_flushing) {
-			return;
-		}
-		gstate.any_flushing = true;
-	}
-	ActiveFlushGuard active_flush(gstate.any_flushing);
-	while (true) {
-		unique_ptr<FixedPreparedBatchData> batch_data;
-		{
-			lock_guard<mutex> l(gstate.lock);
-			if (gstate.batch_data.empty()) {
-				// no batch data left to flush
-				break;
-			}
-			auto entry = gstate.batch_data.begin();
-			if (entry->first != gstate.flushed_batch_index) {
-				// this entry is not yet ready to be flushed
-				break;
-			}
-			if (entry->first < gstate.flushed_batch_index) {
-				throw InternalException("Batch index was out of order!?");
-			}
-			batch_data = std::move(entry->second);
-			gstate.batch_data.erase(entry);
-		}
-		function.flush_batch(context, *bind_data, *gstate.global_state, *batch_data->prepared_data);
-		batch_data->prepared_data.reset();
-		memory_manager.ReduceUnflushedMemory(batch_data->memory_usage);
-		gstate.flushed_batch_index++;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Tasks
-//===--------------------------------------------------------------------===//
-bool PhysicalBatchCopyToFile::ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-	auto task = gstate.task_manager.GetTask();
-	if (!task) {
-		return false;
-	}
-	task->Execute(*this, context, gstate_p);
-	return true;
-}
-
-void PhysicalBatchCopyToFile::ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const {
-	while (ExecuteTask(context, gstate_p)) {
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Next Batch
-//===--------------------------------------------------------------------===//
-void PhysicalBatchCopyToFile::AddLocalBatch(ClientContext &context, GlobalSinkState &gstate_p,
-                                            LocalSinkState &lstate) const {
-	auto &state = lstate.Cast<FixedBatchCopyLocalState>();
-	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
-	auto &memory_manager = gstate.memory_manager;
-	if (!state.collection || state.collection->Count() == 0) {
-		return;
-	}
-	// we finished processing this batch
-	// start flushing data
-	auto min_batch_index = state.partition_info.min_batch_index.GetIndex();
-	// push the raw batch data into the set of unprocessed batches
-	auto raw_batch = make_uniq<FixedRawBatchData>(state.local_memory_usage, std::move(state.collection));
-	AddRawBatchData(context, gstate, state.batch_index.GetIndex(), std::move(raw_batch));
-	// attempt to repartition to our desired batch size
-	RepartitionBatches(context, gstate, min_batch_index);
-	// unblock tasks so they can help process batches (if any are blocked)
-	bool any_unblocked;
-	{
-		auto guard = memory_manager.Lock();
-		any_unblocked = memory_manager.UnblockTasks(guard);
-	}
-	// if any threads were unblocked they can pick up execution of the tasks
-	// otherwise we will execute a task and flush here
-	if (!any_unblocked) {
-		//! Execute a single repartition task
-		ExecuteTask(context, gstate);
-		//! Flush batch data to disk (if any is ready)
-		FlushBatchData(context, gstate);
-	}
-}
-
-SinkNextBatchType PhysicalBatchCopyToFile::NextBatch(ExecutionContext &context,
-                                                     OperatorSinkNextBatchInput &input) const {
-	auto &lstate = input.local_state;
-	auto &state = lstate.Cast<FixedBatchCopyLocalState>();
-	auto &gstate = input.global_state.Cast<FixedBatchCopyGlobalState>();
-	auto &memory_manager = gstate.memory_manager;
-
-	// add the previously finished batch (if any) to the state
-	AddLocalBatch(context.client, gstate, state);
-
-	// update the minimum batch index
-	memory_manager.UpdateMinBatchIndex(state.partition_info.min_batch_index.GetIndex());
-	state.batch_index = lstate.partition_info.batch_index.GetIndex();
-
-	state.InitializeCollection(context.client, *this);
-	return SinkNextBatchType::READY;
-}
-
-unique_ptr<LocalSinkState> PhysicalBatchCopyToFile::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<FixedBatchCopyLocalState>(function.copy_to_initialize_local(context, *bind_data));
-}
-
-unique_ptr<GlobalSinkState> PhysicalBatchCopyToFile::GetGlobalSinkState(ClientContext &context) const {
-	// request memory based on the minimum amount of memory per column
-	auto minimum_memory_per_thread =
-	    FixedBatchCopyGlobalState::MINIMUM_MEMORY_PER_COLUMN_PER_THREAD * children[0]->types.size();
-	auto result = make_uniq<FixedBatchCopyGlobalState>(
-	    context, function.copy_to_initialize_global(context, *bind_data, file_path), minimum_memory_per_thread);
-	result->batch_size = function.desired_batch_size ? function.desired_batch_size(context, *bind_data) : 0;
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalBatchCopyToFile::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                  OperatorSourceInput &input) const {
-	auto &g = sink_state->Cast<FixedBatchCopyGlobalState>();
-
-	chunk.SetCardinality(1);
-	switch (return_type) {
-	case CopyFunctionReturnType::CHANGED_ROWS:
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
-		break;
-	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: {
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
-		auto fp = use_tmp_file ? PhysicalCopyToFile::GetNonTmpFile(context.client, file_path) : file_path;
-		chunk.SetValue(1, 0, Value::LIST(LogicalType::VARCHAR, {fp}));
-		break;
-	}
-	default:
-		throw NotImplementedException("Unknown CopyFunctionReturnType");
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp b/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp
deleted file mode 100644
index 2e546c477..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp
+++ /dev/null
@@ -1,656 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_batch_insert.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/execution/operator/persistent/batch_memory_manager.hpp"
-#include "duckdb/execution/operator/persistent/batch_task_manager.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/row_group_collection.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/transaction/local_storage.hpp"
-
-namespace duckdb {
-
-PhysicalBatchInsert::PhysicalBatchInsert(vector<LogicalType> types_p, TableCatalogEntry &table,
-                                         physical_index_vector_t<idx_t> column_index_map_p,
-                                         vector<unique_ptr<Expression>> bound_defaults_p,
-                                         vector<unique_ptr<BoundConstraint>> bound_constraints_p,
-                                         idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::BATCH_INSERT, std::move(types_p), estimated_cardinality),
-      column_index_map(std::move(column_index_map_p)), insert_table(&table), insert_types(table.GetTypes()),
-      bound_defaults(std::move(bound_defaults_p)), bound_constraints(std::move(bound_constraints_p)) {
-}
-
-PhysicalBatchInsert::PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry &schema,
-                                         unique_ptr<BoundCreateTableInfo> info_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::BATCH_CREATE_TABLE_AS, op.types, estimated_cardinality),
-      insert_table(nullptr), schema(&schema), info(std::move(info_p)) {
-	PhysicalInsert::GetInsertInfo(*info, insert_types, bound_defaults);
-}
-
-//===--------------------------------------------------------------------===//
-// CollectionMerger
-//===--------------------------------------------------------------------===//
-enum class RowGroupBatchType : uint8_t { FLUSHED, NOT_FLUSHED };
-
-class CollectionMerger {
-public:
-	explicit CollectionMerger(ClientContext &context) : context(context) {
-	}
-
-	ClientContext &context;
-	vector<unique_ptr<RowGroupCollection>> current_collections;
-	RowGroupBatchType batch_type = RowGroupBatchType::NOT_FLUSHED;
-
-public:
-	void AddCollection(unique_ptr<RowGroupCollection> collection, RowGroupBatchType type) {
-		current_collections.push_back(std::move(collection));
-		if (type == RowGroupBatchType::FLUSHED) {
-			batch_type = RowGroupBatchType::FLUSHED;
-			if (current_collections.size() > 1) {
-				throw InternalException("Cannot merge flushed collections");
-			}
-		}
-	}
-
-	bool Empty() {
-		return current_collections.empty();
-	}
-
-	unique_ptr<RowGroupCollection> Flush(OptimisticDataWriter &writer) {
-		if (Empty()) {
-			return nullptr;
-		}
-		unique_ptr<RowGroupCollection> new_collection = std::move(current_collections[0]);
-		if (current_collections.size() > 1) {
-			// we have gathered multiple collections: create one big collection and merge that
-			auto &types = new_collection->GetTypes();
-			TableAppendState append_state;
-			new_collection->InitializeAppend(append_state);
-
-			DataChunk scan_chunk;
-			scan_chunk.Initialize(context, types);
-
-			vector<StorageIndex> column_ids;
-			for (idx_t i = 0; i < types.size(); i++) {
-				column_ids.emplace_back(i);
-			}
-			for (auto &collection : current_collections) {
-				if (!collection) {
-					continue;
-				}
-				TableScanState scan_state;
-				scan_state.Initialize(column_ids);
-				collection->InitializeScan(scan_state.local_state, column_ids, nullptr);
-
-				while (true) {
-					scan_chunk.Reset();
-					scan_state.local_state.ScanCommitted(scan_chunk, TableScanType::TABLE_SCAN_COMMITTED_ROWS);
-					if (scan_chunk.size() == 0) {
-						break;
-					}
-					auto new_row_group = new_collection->Append(scan_chunk, append_state);
-					if (new_row_group) {
-						writer.WriteNewRowGroup(*new_collection);
-					}
-				}
-			}
-			new_collection->FinalizeAppend(TransactionData(0, 0), append_state);
-			writer.WriteLastRowGroup(*new_collection);
-		} else if (batch_type == RowGroupBatchType::NOT_FLUSHED) {
-			writer.WriteLastRowGroup(*new_collection);
-		}
-		current_collections.clear();
-		return new_collection;
-	}
-};
-
-struct RowGroupBatchEntry {
-	RowGroupBatchEntry(idx_t batch_idx, unique_ptr<RowGroupCollection> collection_p, RowGroupBatchType type)
-	    : batch_idx(batch_idx), total_rows(collection_p->GetTotalRows()), unflushed_memory(0),
-	      collection(std::move(collection_p)), type(type) {
-		if (type == RowGroupBatchType::NOT_FLUSHED) {
-			unflushed_memory = collection->GetAllocationSize();
-		}
-	}
-
-	idx_t batch_idx;
-	idx_t total_rows;
-	idx_t unflushed_memory;
-	unique_ptr<RowGroupCollection> collection;
-	RowGroupBatchType type;
-};
-
-//===--------------------------------------------------------------------===//
-// States
-//===--------------------------------------------------------------------===//
-class BatchInsertTask {
-public:
-	virtual ~BatchInsertTask() {
-	}
-
-	virtual void Execute(const PhysicalBatchInsert &op, ClientContext &context, GlobalSinkState &gstate_p,
-	                     LocalSinkState &lstate_p) = 0;
-};
-
-class BatchInsertGlobalState : public GlobalSinkState {
-public:
-	explicit BatchInsertGlobalState(ClientContext &context, DuckTableEntry &table, idx_t minimum_memory_per_thread)
-	    : memory_manager(context, minimum_memory_per_thread), table(table), insert_count(0),
-	      optimistically_written(false), minimum_memory_per_thread(minimum_memory_per_thread) {
-		row_group_size = table.GetStorage().GetRowGroupSize();
-	}
-
-	BatchMemoryManager memory_manager;
-	BatchTaskManager<BatchInsertTask> task_manager;
-	mutex lock;
-	DuckTableEntry &table;
-	idx_t row_group_size;
-	idx_t insert_count;
-	vector<RowGroupBatchEntry> collections;
-	idx_t next_start = 0;
-	atomic<bool> optimistically_written;
-	idx_t minimum_memory_per_thread;
-
-	bool ReadyToMerge(idx_t count) const;
-	void ScheduleMergeTasks(idx_t min_batch_index);
-	unique_ptr<RowGroupCollection> MergeCollections(ClientContext &context,
-	                                                vector<RowGroupBatchEntry> merge_collections,
-	                                                OptimisticDataWriter &writer);
-	void AddCollection(ClientContext &context, idx_t batch_index, idx_t min_batch_index,
-	                   unique_ptr<RowGroupCollection> current_collection,
-	                   optional_ptr<OptimisticDataWriter> writer = nullptr);
-
-	idx_t MaxThreads(idx_t source_max_threads) override {
-		// try to request 4MB per column per thread
-		memory_manager.SetMemorySize(source_max_threads * minimum_memory_per_thread);
-		// cap the concurrent threads working on this task based on the amount of available memory
-		return MinValue<idx_t>(source_max_threads, memory_manager.AvailableMemory() / minimum_memory_per_thread + 1);
-	}
-};
-
-class BatchInsertLocalState : public LocalSinkState {
-public:
-	BatchInsertLocalState(ClientContext &context, const vector<LogicalType> &types,
-	                      const vector<unique_ptr<Expression>> &bound_defaults)
-	    : default_executor(context, bound_defaults) {
-		insert_chunk.Initialize(Allocator::Get(context), types);
-	}
-
-	DataChunk insert_chunk;
-	ExpressionExecutor default_executor;
-	idx_t current_index;
-	TableAppendState current_append_state;
-	unique_ptr<RowGroupCollection> current_collection;
-	optional_ptr<OptimisticDataWriter> writer;
-	unique_ptr<ConstraintState> constraint_state;
-
-	void CreateNewCollection(DuckTableEntry &table, const vector<LogicalType> &insert_types) {
-		auto table_info = table.GetStorage().GetDataTableInfo();
-		auto &io_manager = TableIOManager::Get(table.GetStorage());
-		current_collection = make_uniq<RowGroupCollection>(std::move(table_info), io_manager, insert_types,
-		                                                   NumericCast<idx_t>(MAX_ROW_ID));
-		current_collection->InitializeEmpty();
-		current_collection->InitializeAppend(current_append_state);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Merge Task
-//===--------------------------------------------------------------------===//
-class MergeCollectionTask : public BatchInsertTask {
-public:
-	MergeCollectionTask(vector<RowGroupBatchEntry> merge_collections_p, idx_t merged_batch_index)
-	    : merge_collections(std::move(merge_collections_p)), merged_batch_index(merged_batch_index) {
-	}
-
-	vector<RowGroupBatchEntry> merge_collections;
-	idx_t merged_batch_index;
-
-	void Execute(const PhysicalBatchInsert &op, ClientContext &context, GlobalSinkState &gstate_p,
-	             LocalSinkState &lstate_p) override {
-		auto &gstate = gstate_p.Cast<BatchInsertGlobalState>();
-		auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
-		// merge together the collections
-		D_ASSERT(lstate.writer);
-		auto final_collection = gstate.MergeCollections(context, std::move(merge_collections), *lstate.writer);
-		// add the merged-together collection to the set of batch indexes
-		lock_guard<mutex> l(gstate.lock);
-		RowGroupBatchEntry new_entry(merged_batch_index, std::move(final_collection), RowGroupBatchType::FLUSHED);
-		auto it = std::lower_bound(
-		    gstate.collections.begin(), gstate.collections.end(), new_entry,
-		    [&](const RowGroupBatchEntry &a, const RowGroupBatchEntry &b) { return a.batch_idx < b.batch_idx; });
-		if (it->batch_idx != merged_batch_index) {
-			throw InternalException("Merged batch index was no longer present in collection");
-		}
-		it->collection = std::move(new_entry.collection);
-	}
-};
-
-struct BatchMergeTask {
-	explicit BatchMergeTask(idx_t start_index) : start_index(start_index), end_index(0), total_count(0) {
-	}
-
-	idx_t start_index;
-	idx_t end_index;
-	idx_t total_count;
-};
-
-bool BatchInsertGlobalState::ReadyToMerge(idx_t count) const {
-	// we try to merge so the count fits nicely into row groups
-	if (count >= row_group_size / 10 * 9 && count <= row_group_size) {
-		// 90%-100% of row group size
-		return true;
-	}
-	if (count >= row_group_size / 10 * 18 && count <= row_group_size * 2) {
-		// 180%-200% of row group size
-		return true;
-	}
-	if (count >= row_group_size / 10 * 27 && count <= row_group_size * 3) {
-		// 270%-300% of row group size
-		return true;
-	}
-	if (count >= row_group_size / 10 * 36) {
-		// >360% of row group size
-		return true;
-	}
-	return false;
-}
-
-void BatchInsertGlobalState::ScheduleMergeTasks(idx_t min_batch_index) {
-	idx_t current_idx;
-
-	vector<BatchMergeTask> to_be_scheduled_tasks;
-
-	BatchMergeTask current_task(next_start);
-	for (current_idx = current_task.start_index; current_idx < collections.size(); current_idx++) {
-		auto &entry = collections[current_idx];
-		if (entry.batch_idx > min_batch_index) {
-			// this entry is AFTER the min_batch_index
-			// finished
-			if (ReadyToMerge(current_task.total_count)) {
-				current_task.end_index = current_idx;
-				to_be_scheduled_tasks.push_back(current_task);
-			}
-			break;
-		}
-		if (entry.type == RowGroupBatchType::FLUSHED) {
-			// already flushed: cannot flush anything here
-			if (current_task.total_count > 0) {
-				current_task.end_index = current_idx;
-				to_be_scheduled_tasks.push_back(current_task);
-			}
-			current_task.start_index = current_idx + 1;
-			if (current_task.start_index > next_start) {
-				// avoid checking this segment again in the future
-				next_start = current_task.start_index;
-			}
-			current_task.total_count = 0;
-			continue;
-		}
-		// not flushed - add to set of indexes to flush
-		current_task.total_count += entry.total_rows;
-		if (ReadyToMerge(current_task.total_count)) {
-			// create a task to merge these collections
-			current_task.end_index = current_idx + 1;
-			to_be_scheduled_tasks.push_back(current_task);
-			current_task.start_index = current_idx + 1;
-			current_task.total_count = 0;
-		}
-	}
-
-	if (to_be_scheduled_tasks.empty()) {
-		return;
-	}
-	for (auto &scheduled_task : to_be_scheduled_tasks) {
-		D_ASSERT(scheduled_task.total_count > 0);
-		D_ASSERT(current_idx > scheduled_task.start_index);
-		idx_t merged_batch_index = collections[scheduled_task.start_index].batch_idx;
-		vector<RowGroupBatchEntry> merge_collections;
-		for (idx_t idx = scheduled_task.start_index; idx < scheduled_task.end_index; idx++) {
-			auto &entry = collections[idx];
-			if (!entry.collection || entry.type == RowGroupBatchType::FLUSHED) {
-				throw InternalException("Adding a row group collection that should not be flushed");
-			}
-			RowGroupBatchEntry added_entry(collections[scheduled_task.start_index].batch_idx,
-			                               std::move(entry.collection), RowGroupBatchType::FLUSHED);
-			added_entry.unflushed_memory = entry.unflushed_memory;
-			merge_collections.push_back(std::move(added_entry));
-			entry.total_rows = scheduled_task.total_count;
-			entry.type = RowGroupBatchType::FLUSHED;
-		}
-		task_manager.AddTask(make_uniq<MergeCollectionTask>(std::move(merge_collections), merged_batch_index));
-	}
-	// erase in reverse order
-	for (idx_t i = to_be_scheduled_tasks.size(); i > 0; i--) {
-		auto &scheduled_task = to_be_scheduled_tasks[i - 1];
-		if (scheduled_task.start_index + 1 < scheduled_task.end_index) {
-			// erase all entries except the first one
-			collections.erase(collections.begin() + NumericCast<int64_t>(scheduled_task.start_index) + 1,
-			                  collections.begin() + NumericCast<int64_t>(scheduled_task.end_index));
-		}
-	}
-}
-
-unique_ptr<RowGroupCollection> BatchInsertGlobalState::MergeCollections(ClientContext &context,
-                                                                        vector<RowGroupBatchEntry> merge_collections,
-                                                                        OptimisticDataWriter &writer) {
-	D_ASSERT(!merge_collections.empty());
-	CollectionMerger merger(context);
-	idx_t written_data = 0;
-	for (auto &entry : merge_collections) {
-		merger.AddCollection(std::move(entry.collection), RowGroupBatchType::NOT_FLUSHED);
-		written_data += entry.unflushed_memory;
-	}
-	optimistically_written = true;
-	memory_manager.ReduceUnflushedMemory(written_data);
-	return merger.Flush(writer);
-}
-
-void BatchInsertGlobalState::AddCollection(ClientContext &context, idx_t batch_index, idx_t min_batch_index,
-                                           unique_ptr<RowGroupCollection> current_collection,
-                                           optional_ptr<OptimisticDataWriter> writer) {
-	if (batch_index < min_batch_index) {
-		throw InternalException("Batch index of the added collection (%llu) is smaller than the min batch index (%llu)",
-		                        batch_index, min_batch_index);
-	}
-	auto new_count = current_collection->GetTotalRows();
-	auto batch_type = new_count < row_group_size ? RowGroupBatchType::NOT_FLUSHED : RowGroupBatchType::FLUSHED;
-	if (batch_type == RowGroupBatchType::FLUSHED && writer) {
-		writer->WriteLastRowGroup(*current_collection);
-	}
-	lock_guard<mutex> l(lock);
-	insert_count += new_count;
-	// add the collection to the batch index
-	RowGroupBatchEntry new_entry(batch_index, std::move(current_collection), batch_type);
-	if (batch_type == RowGroupBatchType::NOT_FLUSHED) {
-		memory_manager.IncreaseUnflushedMemory(new_entry.unflushed_memory);
-	}
-
-	auto it = std::lower_bound(
-	    collections.begin(), collections.end(), new_entry,
-	    [&](const RowGroupBatchEntry &a, const RowGroupBatchEntry &b) { return a.batch_idx < b.batch_idx; });
-	if (it != collections.end() && it->batch_idx == new_entry.batch_idx) {
-		throw InternalException("PhysicalBatchInsert::AddCollection error: batch index %d is present in multiple "
-		                        "collections. This occurs when "
-		                        "batch indexes are not uniquely distributed over threads",
-		                        batch_index);
-	}
-	collections.insert(it, std::move(new_entry));
-	if (writer) {
-		ScheduleMergeTasks(min_batch_index);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// States
-//===--------------------------------------------------------------------===//
-unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContext &context) const {
-	optional_ptr<TableCatalogEntry> table;
-	if (info) {
-		// CREATE TABLE AS
-		D_ASSERT(!insert_table);
-		auto &catalog = schema->catalog;
-		auto created_table = catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info);
-		table = &created_table->Cast<TableCatalogEntry>();
-	} else {
-		D_ASSERT(insert_table);
-		D_ASSERT(insert_table->IsDuckTable());
-		table = insert_table.get_mutable();
-	}
-	// heuristic - we start off by allocating 4MB of cache space per column
-	static constexpr const idx_t MINIMUM_MEMORY_PER_COLUMN = 4ULL * 1024ULL * 1024ULL;
-	auto minimum_memory_per_thread = table->GetColumns().PhysicalColumnCount() * MINIMUM_MEMORY_PER_COLUMN;
-	auto result = make_uniq<BatchInsertGlobalState>(context, table->Cast<DuckTableEntry>(), minimum_memory_per_thread);
-	return std::move(result);
-}
-
-unique_ptr<LocalSinkState> PhysicalBatchInsert::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<BatchInsertLocalState>(context.client, insert_types, bound_defaults);
-}
-
-//===--------------------------------------------------------------------===//
-// Tasks
-//===--------------------------------------------------------------------===//
-bool PhysicalBatchInsert::ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p,
-                                      LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<BatchInsertGlobalState>();
-	auto task = gstate.task_manager.GetTask();
-	if (!task) {
-		return false;
-	}
-	task->Execute(*this, context, gstate_p, lstate_p);
-	return true;
-}
-
-void PhysicalBatchInsert::ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p,
-                                       LocalSinkState &lstate_p) const {
-	while (ExecuteTask(context, gstate_p, lstate_p)) {
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// NextBatch
-//===--------------------------------------------------------------------===//
-SinkNextBatchType PhysicalBatchInsert::NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const {
-	auto &gstate = input.global_state.Cast<BatchInsertGlobalState>();
-	auto &lstate = input.local_state.Cast<BatchInsertLocalState>();
-	auto &memory_manager = gstate.memory_manager;
-
-	auto batch_index = lstate.partition_info.batch_index.GetIndex();
-	if (lstate.current_collection) {
-		if (lstate.current_index == batch_index) {
-			throw InternalException("NextBatch called with the same batch index?");
-		}
-		// batch index has changed: move the old collection to the global state and create a new collection
-		TransactionData tdata(0, 0);
-		lstate.current_collection->FinalizeAppend(tdata, lstate.current_append_state);
-		gstate.AddCollection(context.client, lstate.current_index, lstate.partition_info.min_batch_index.GetIndex(),
-		                     std::move(lstate.current_collection), lstate.writer);
-
-		bool any_unblocked;
-		{
-			auto guard = memory_manager.Lock();
-			any_unblocked = memory_manager.UnblockTasks(guard);
-		}
-		if (!any_unblocked) {
-			ExecuteTasks(context.client, gstate, lstate);
-		}
-		lstate.current_collection.reset();
-	}
-	lstate.current_index = batch_index;
-
-	// unblock any blocked tasks
-	auto guard = memory_manager.Lock();
-	memory_manager.UnblockTasks(guard);
-
-	return SinkNextBatchType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<BatchInsertGlobalState>();
-	auto &lstate = input.local_state.Cast<BatchInsertLocalState>();
-	auto &memory_manager = gstate.memory_manager;
-
-	auto &table = gstate.table;
-	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
-
-	auto batch_index = lstate.partition_info.batch_index.GetIndex();
-	// check if we should process this batch
-	if (!memory_manager.IsMinimumBatchIndex(batch_index)) {
-		memory_manager.UpdateMinBatchIndex(lstate.partition_info.min_batch_index.GetIndex());
-
-		// we are not processing the current min batch index
-		// check if we have exceeded the maximum number of unflushed rows
-		if (memory_manager.OutOfMemory(batch_index)) {
-			// out-of-memory
-			// execute tasks while we wait (if any are available)
-			ExecuteTasks(context.client, gstate, lstate);
-
-			auto guard = memory_manager.Lock();
-			if (!memory_manager.IsMinimumBatchIndex(batch_index)) {
-				//  we are not the minimum batch index and we have no memory available to buffer - block the task for
-				//  now
-				return memory_manager.BlockSink(guard, input.interrupt_state);
-			}
-		}
-	}
-	if (!lstate.current_collection) {
-		lock_guard<mutex> l(gstate.lock);
-		// no collection yet: create a new one
-		lstate.CreateNewCollection(table, insert_types);
-		if (!lstate.writer) {
-			lstate.writer = &table.GetStorage().CreateOptimisticWriter(context.client);
-		}
-	}
-
-	if (lstate.current_index != batch_index) {
-		throw InternalException("Current batch differs from batch - but NextBatch was not called!?");
-	}
-
-	if (!lstate.constraint_state) {
-		lstate.constraint_state = table.GetStorage().InitializeConstraintState(table, bound_constraints);
-	}
-	auto &storage = table.GetStorage();
-	storage.VerifyAppendConstraints(*lstate.constraint_state, context.client, lstate.insert_chunk, nullptr, nullptr);
-
-	auto new_row_group = lstate.current_collection->Append(lstate.insert_chunk, lstate.current_append_state);
-	if (new_row_group) {
-		// we have already written to disk - flush the next row group as well
-		lstate.writer->WriteNewRowGroup(*lstate.current_collection);
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-SinkCombineResultType PhysicalBatchInsert::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<BatchInsertGlobalState>();
-	auto &lstate = input.local_state.Cast<BatchInsertLocalState>();
-	auto &memory_manager = gstate.memory_manager;
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-
-	memory_manager.UpdateMinBatchIndex(lstate.partition_info.min_batch_index.GetIndex());
-
-	if (lstate.current_collection) {
-		TransactionData tdata(0, 0);
-		lstate.current_collection->FinalizeAppend(tdata, lstate.current_append_state);
-		if (lstate.current_collection->GetTotalRows() > 0) {
-			gstate.AddCollection(context.client, lstate.current_index, lstate.partition_info.min_batch_index.GetIndex(),
-			                     std::move(lstate.current_collection));
-		}
-	}
-	if (lstate.writer) {
-		lock_guard<mutex> l(gstate.lock);
-		gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer);
-	}
-
-	// unblock any blocked tasks
-	auto guard = memory_manager.Lock();
-	memory_manager.UnblockTasks(guard);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                               OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<BatchInsertGlobalState>();
-	auto &memory_manager = gstate.memory_manager;
-
-	if (gstate.optimistically_written || gstate.insert_count >= gstate.row_group_size) {
-		// we have written data to disk optimistically or are inserting a large amount of data
-		// perform a final pass over all of the row groups and merge them together
-		vector<unique_ptr<CollectionMerger>> mergers;
-		unique_ptr<CollectionMerger> current_merger;
-
-		auto &storage = gstate.table.GetStorage();
-		for (auto &entry : gstate.collections) {
-			if (entry.type == RowGroupBatchType::NOT_FLUSHED) {
-				// this collection has not been flushed: add it to the merge set
-				if (!current_merger) {
-					current_merger = make_uniq<CollectionMerger>(context);
-				}
-				current_merger->AddCollection(std::move(entry.collection), entry.type);
-				memory_manager.ReduceUnflushedMemory(entry.unflushed_memory);
-			} else {
-				// this collection has been flushed: it does not need to be merged
-				// create a separate collection merger only for this entry
-				if (current_merger) {
-					// we have small collections remaining: flush them
-					mergers.push_back(std::move(current_merger));
-					current_merger.reset();
-				}
-				auto larger_merger = make_uniq<CollectionMerger>(context);
-				larger_merger->AddCollection(std::move(entry.collection), entry.type);
-				mergers.push_back(std::move(larger_merger));
-			}
-		}
-		if (current_merger) {
-			mergers.push_back(std::move(current_merger));
-		}
-
-		// now that we have created all of the mergers, perform the actual merging
-		vector<unique_ptr<RowGroupCollection>> final_collections;
-		final_collections.reserve(mergers.size());
-		auto &writer = storage.CreateOptimisticWriter(context);
-		for (auto &merger : mergers) {
-			final_collections.push_back(merger->Flush(writer));
-		}
-
-		// finally, merge the row groups into the local storage
-		for (auto &collection : final_collections) {
-			storage.LocalMerge(context, *collection);
-		}
-		storage.FinalizeOptimisticWriter(context, writer);
-	} else {
-		// we are writing a small amount of data to disk
-		// append directly to transaction local storage
-		auto &table = gstate.table;
-		auto &storage = table.GetStorage();
-		LocalAppendState append_state;
-		storage.InitializeLocalAppend(append_state, table, context, bound_constraints);
-		auto &transaction = DuckTransaction::Get(context, table.catalog);
-		for (auto &entry : gstate.collections) {
-			if (entry.type != RowGroupBatchType::NOT_FLUSHED) {
-				throw InternalException("Encountered a flushed batch");
-			}
-
-			memory_manager.ReduceUnflushedMemory(entry.unflushed_memory);
-			entry.collection->Scan(transaction, [&](DataChunk &insert_chunk) {
-				storage.LocalAppend(append_state, context, insert_chunk, false);
-				return true;
-			});
-		}
-		storage.FinalizeLocalAppend(append_state);
-	}
-	memory_manager.FinalCheck();
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-
-SourceResultType PhysicalBatchInsert::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
-	auto &insert_gstate = sink_state->Cast<BatchInsertGlobalState>();
-
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(insert_gstate.insert_count)));
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp b/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp
deleted file mode 100644
index 6ad354ea2..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_copy_database.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-
-namespace duckdb {
-
-PhysicalCopyDatabase::PhysicalCopyDatabase(vector<LogicalType> types, idx_t estimated_cardinality,
-                                           unique_ptr<CopyDatabaseInfo> info_p)
-    : PhysicalOperator(PhysicalOperatorType::COPY_DATABASE, std::move(types), estimated_cardinality),
-      info(std::move(info_p)) {
-}
-
-PhysicalCopyDatabase::~PhysicalCopyDatabase() {
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCopyDatabase::GetData(ExecutionContext &context, DataChunk &chunk,
-                                               OperatorSourceInput &input) const {
-	auto &catalog = Catalog::GetCatalog(context.client, info->target_database);
-	for (auto &create_info : info->entries) {
-		switch (create_info->type) {
-		case CatalogType::SCHEMA_ENTRY:
-			catalog.CreateSchema(context.client, create_info->Cast<CreateSchemaInfo>());
-			break;
-		case CatalogType::VIEW_ENTRY:
-			catalog.CreateView(context.client, create_info->Cast<CreateViewInfo>());
-			break;
-		case CatalogType::SEQUENCE_ENTRY:
-			catalog.CreateSequence(context.client, create_info->Cast<CreateSequenceInfo>());
-			break;
-		case CatalogType::TYPE_ENTRY:
-			catalog.CreateType(context.client, create_info->Cast<CreateTypeInfo>());
-			break;
-		case CatalogType::MACRO_ENTRY:
-		case CatalogType::TABLE_MACRO_ENTRY:
-			catalog.CreateFunction(context.client, create_info->Cast<CreateMacroInfo>());
-			break;
-		case CatalogType::TABLE_ENTRY: {
-			auto binder = Binder::CreateBinder(context.client);
-			auto bound_info = binder->BindCreateTableInfo(std::move(create_info));
-			catalog.CreateTable(context.client, *bound_info);
-			break;
-		}
-		case CatalogType::INDEX_ENTRY: {
-			catalog.CreateIndex(context.client, create_info->Cast<CreateIndexInfo>());
-			break;
-		}
-		default:
-			throw NotImplementedException("Entry type %s not supported in PhysicalCopyDatabase",
-			                              CatalogTypeToString(create_info->type));
-		}
-	}
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp b/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp
deleted file mode 100644
index fa85d670b..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp
+++ /dev/null
@@ -1,559 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp"
-
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/planner/operator/logical_copy_to_file.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct PartitionWriteInfo {
-	unique_ptr<GlobalFunctionData> global_state;
-	idx_t active_writes = 0;
-};
-
-struct VectorOfValuesHashFunction {
-	uint64_t operator()(const vector<Value> &values) const {
-		hash_t result = 0;
-		for (auto &val : values) {
-			result ^= val.Hash();
-		}
-		return result;
-	}
-};
-
-struct VectorOfValuesEquality {
-	bool operator()(const vector<Value> &a, const vector<Value> &b) const {
-		if (a.size() != b.size()) {
-			return false;
-		}
-		for (idx_t i = 0; i < a.size(); i++) {
-			if (ValueOperations::DistinctFrom(a[i], b[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-};
-
-template <class T>
-using vector_of_value_map_t = unordered_map<vector<Value>, T, VectorOfValuesHashFunction, VectorOfValuesEquality>;
-
-class CopyToFunctionGlobalState : public GlobalSinkState {
-public:
-	explicit CopyToFunctionGlobalState(ClientContext &context, unique_ptr<GlobalFunctionData> global_state)
-	    : rows_copied(0), last_file_offset(0), global_state(std::move(global_state)) {
-		max_open_files = ClientConfig::GetConfig(context).partitioned_write_max_open_files;
-	}
-	StorageLock lock;
-	atomic<idx_t> rows_copied;
-	atomic<idx_t> last_file_offset;
-	unique_ptr<GlobalFunctionData> global_state;
-	//! Created directories
-	unordered_set<string> created_directories;
-	//! shared state for HivePartitionedColumnData
-	shared_ptr<GlobalHivePartitionState> partition_state;
-	//! File names
-	vector<Value> file_names;
-	//! Max open files
-	idx_t max_open_files;
-
-	void CreateDir(const string &dir_path, FileSystem &fs) {
-		if (created_directories.find(dir_path) != created_directories.end()) {
-			// already attempted to create this directory
-			return;
-		}
-		if (!fs.DirectoryExists(dir_path)) {
-			fs.CreateDirectory(dir_path);
-		}
-		created_directories.insert(dir_path);
-	}
-
-	string GetOrCreateDirectory(const vector<idx_t> &cols, const vector<string> &names, const vector<Value> &values,
-	                            string path, FileSystem &fs) {
-		CreateDir(path, fs);
-		for (idx_t i = 0; i < cols.size(); i++) {
-			const auto &partition_col_name = names[cols[i]];
-			const auto &partition_value = values[i];
-			string p_dir;
-			p_dir += HivePartitioning::Escape(partition_col_name);
-			p_dir += "=";
-			p_dir += HivePartitioning::Escape(partition_value.ToString());
-			path = fs.JoinPath(path, p_dir);
-			CreateDir(path, fs);
-		}
-		return path;
-	}
-
-	void AddFileName(const StorageLockKey &l, const string &file_name) {
-		D_ASSERT(l.GetType() == StorageLockType::EXCLUSIVE);
-		file_names.emplace_back(file_name);
-	}
-
-	void FinalizePartition(ClientContext &context, const PhysicalCopyToFile &op, PartitionWriteInfo &info) {
-		if (!info.global_state) {
-			// already finalized
-			return;
-		}
-		// finalize the partition
-		op.function.copy_to_finalize(context, *op.bind_data, *info.global_state);
-		info.global_state.reset();
-	}
-
-	void FinalizePartitions(ClientContext &context, const PhysicalCopyToFile &op) {
-		// finalize any remaining partitions
-		for (auto &entry : active_partitioned_writes) {
-			FinalizePartition(context, op, *entry.second);
-		}
-	}
-
-	PartitionWriteInfo &GetPartitionWriteInfo(ExecutionContext &context, const PhysicalCopyToFile &op,
-	                                          const vector<Value> &values) {
-		auto global_lock = lock.GetExclusiveLock();
-		// check if we have already started writing this partition
-		auto active_write_entry = active_partitioned_writes.find(values);
-		if (active_write_entry != active_partitioned_writes.end()) {
-			// we have - continue writing in this partition
-			active_write_entry->second->active_writes++;
-			return *active_write_entry->second;
-		}
-		// check if we need to close any writers before we can continue
-		if (active_partitioned_writes.size() >= max_open_files) {
-			// we need to! try to close writers
-			for (auto &entry : active_partitioned_writes) {
-				if (entry.second->active_writes == 0) {
-					// we can evict this entry - evict the partition
-					FinalizePartition(context.client, op, *entry.second);
-					++previous_partitions[entry.first];
-					active_partitioned_writes.erase(entry.first);
-					break;
-				}
-			}
-		}
-		idx_t offset = 0;
-		auto prev_offset = previous_partitions.find(values);
-		if (prev_offset != previous_partitions.end()) {
-			offset = prev_offset->second;
-		}
-		auto &fs = FileSystem::GetFileSystem(context.client);
-		// Create a writer for the current file
-		auto trimmed_path = op.GetTrimmedPath(context.client);
-		string hive_path = GetOrCreateDirectory(op.partition_columns, op.names, values, trimmed_path, fs);
-		string full_path(op.filename_pattern.CreateFilename(fs, hive_path, op.file_extension, offset));
-		if (op.overwrite_mode == CopyOverwriteMode::COPY_APPEND) {
-			// when appending, we first check if the file exists
-			while (fs.FileExists(full_path)) {
-				// file already exists - re-generate name
-				if (!op.filename_pattern.HasUUID()) {
-					throw InternalException("CopyOverwriteMode::COPY_APPEND without {uuid} - and file exists");
-				}
-				full_path = op.filename_pattern.CreateFilename(fs, hive_path, op.file_extension, offset);
-			}
-		}
-		if (op.return_type == CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST) {
-			AddFileName(*global_lock, full_path);
-		}
-		// initialize writes
-		auto info = make_uniq<PartitionWriteInfo>();
-		info->global_state = op.function.copy_to_initialize_global(context.client, *op.bind_data, full_path);
-		auto &result = *info;
-		info->active_writes = 1;
-		// store in active write map
-		active_partitioned_writes.insert(make_pair(values, std::move(info)));
-		return result;
-	}
-
-	void FinishPartitionWrite(PartitionWriteInfo &info) {
-		auto global_lock = lock.GetExclusiveLock();
-		info.active_writes--;
-	}
-
-private:
-	//! The active writes per partition (for partitioned write)
-	vector_of_value_map_t<unique_ptr<PartitionWriteInfo>> active_partitioned_writes;
-	vector_of_value_map_t<idx_t> previous_partitions;
-};
-
-string PhysicalCopyToFile::GetTrimmedPath(ClientContext &context) const {
-	auto &fs = FileSystem::GetFileSystem(context);
-	string trimmed_path = file_path;
-	StringUtil::RTrim(trimmed_path, fs.PathSeparator(trimmed_path));
-	return trimmed_path;
-}
-
-class CopyToFunctionLocalState : public LocalSinkState {
-public:
-	explicit CopyToFunctionLocalState(unique_ptr<LocalFunctionData> local_state) : local_state(std::move(local_state)) {
-	}
-	unique_ptr<GlobalFunctionData> global_state;
-	unique_ptr<LocalFunctionData> local_state;
-
-	//! Buffers the tuples in partitions before writing
-	unique_ptr<HivePartitionedColumnData> part_buffer;
-	unique_ptr<PartitionedColumnDataAppendState> part_buffer_append_state;
-
-	idx_t append_count = 0;
-
-	void InitializeAppendState(ClientContext &context, const PhysicalCopyToFile &op,
-	                           CopyToFunctionGlobalState &gstate) {
-		part_buffer = make_uniq<HivePartitionedColumnData>(context, op.expected_types, op.partition_columns,
-		                                                   gstate.partition_state);
-		part_buffer_append_state = make_uniq<PartitionedColumnDataAppendState>();
-		part_buffer->InitializeAppendState(*part_buffer_append_state);
-		append_count = 0;
-	}
-
-	void AppendToPartition(ExecutionContext &context, const PhysicalCopyToFile &op, CopyToFunctionGlobalState &g,
-	                       DataChunk &chunk) {
-		if (!part_buffer) {
-			// re-initialize the append
-			InitializeAppendState(context.client, op, g);
-		}
-		part_buffer->Append(*part_buffer_append_state, chunk);
-		append_count += chunk.size();
-		if (append_count >= ClientConfig::GetConfig(context.client).partitioned_write_flush_threshold) {
-			// flush all cached partitions
-			FlushPartitions(context, op, g);
-		}
-	}
-
-	void ResetAppendState() {
-		part_buffer_append_state.reset();
-		part_buffer.reset();
-		append_count = 0;
-	}
-
-	void SetDataWithoutPartitions(DataChunk &chunk, const DataChunk &source, const vector<LogicalType> &col_types,
-	                              const vector<idx_t> &part_cols) {
-		D_ASSERT(source.ColumnCount() == col_types.size());
-		auto types = LogicalCopyToFile::GetTypesWithoutPartitions(col_types, part_cols, false);
-		chunk.InitializeEmpty(types);
-		set<idx_t> part_col_set(part_cols.begin(), part_cols.end());
-		idx_t new_col_id = 0;
-		for (idx_t col_idx = 0; col_idx < source.ColumnCount(); col_idx++) {
-			if (part_col_set.find(col_idx) == part_col_set.end()) {
-				chunk.data[new_col_id].Reference(source.data[col_idx]);
-				new_col_id++;
-			}
-		}
-		chunk.SetCardinality(source.size());
-	}
-
-	void FlushPartitions(ExecutionContext &context, const PhysicalCopyToFile &op, CopyToFunctionGlobalState &g) {
-		if (!part_buffer) {
-			return;
-		}
-		part_buffer->FlushAppendState(*part_buffer_append_state);
-		auto &partitions = part_buffer->GetPartitions();
-		auto partition_key_map = part_buffer->GetReverseMap();
-
-		for (idx_t i = 0; i < partitions.size(); i++) {
-			auto entry = partition_key_map.find(i);
-			if (entry == partition_key_map.end()) {
-				continue;
-			}
-			// get the partition write info for this buffer
-			auto &info = g.GetPartitionWriteInfo(context, op, entry->second->values);
-
-			auto local_copy_state = op.function.copy_to_initialize_local(context, *op.bind_data);
-			// push the chunks into the write state
-			for (auto &chunk : partitions[i]->Chunks()) {
-				if (op.write_partition_columns) {
-					op.function.copy_to_sink(context, *op.bind_data, *info.global_state, *local_copy_state, chunk);
-				} else {
-					DataChunk filtered_chunk;
-					SetDataWithoutPartitions(filtered_chunk, chunk, op.expected_types, op.partition_columns);
-					op.function.copy_to_sink(context, *op.bind_data, *info.global_state, *local_copy_state,
-					                         filtered_chunk);
-				}
-			}
-			op.function.copy_to_combine(context, *op.bind_data, *info.global_state, *local_copy_state);
-			local_copy_state.reset();
-			partitions[i].reset();
-			g.FinishPartitionWrite(info);
-		}
-		ResetAppendState();
-	}
-};
-
-unique_ptr<GlobalFunctionData> PhysicalCopyToFile::CreateFileState(ClientContext &context, GlobalSinkState &sink,
-                                                                   StorageLockKey &global_lock) const {
-	auto &g = sink.Cast<CopyToFunctionGlobalState>();
-	idx_t this_file_offset = g.last_file_offset++;
-	auto &fs = FileSystem::GetFileSystem(context);
-	string output_path(filename_pattern.CreateFilename(fs, file_path, file_extension, this_file_offset));
-	if (return_type == CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST) {
-		g.AddFileName(global_lock, output_path);
-	}
-	return function.copy_to_initialize_global(context, *bind_data, output_path);
-}
-
-unique_ptr<LocalSinkState> PhysicalCopyToFile::GetLocalSinkState(ExecutionContext &context) const {
-	if (partition_output) {
-		auto &g = sink_state->Cast<CopyToFunctionGlobalState>();
-
-		auto state = make_uniq<CopyToFunctionLocalState>(nullptr);
-		state->InitializeAppendState(context.client, *this, g);
-		return std::move(state);
-	}
-	auto res = make_uniq<CopyToFunctionLocalState>(function.copy_to_initialize_local(context, *bind_data));
-	return std::move(res);
-}
-
-void CheckDirectory(FileSystem &fs, const string &file_path, CopyOverwriteMode overwrite_mode) {
-	if (overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE ||
-	    overwrite_mode == CopyOverwriteMode::COPY_APPEND) {
-		// with overwrite or ignore we fully ignore the presence of any files instead of erasing them
-		return;
-	}
-	if (fs.IsRemoteFile(file_path) && overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE) {
-		// we can only remove files for local file systems currently
-		// as remote file systems (e.g. S3) do not support RemoveFile
-		throw NotImplementedException("OVERWRITE is not supported for remote file systems");
-	}
-	vector<string> file_list;
-	vector<string> directory_list;
-	directory_list.push_back(file_path);
-	for (idx_t dir_idx = 0; dir_idx < directory_list.size(); dir_idx++) {
-		auto directory = directory_list[dir_idx];
-		fs.ListFiles(directory, [&](const string &path, bool is_directory) {
-			auto full_path = fs.JoinPath(directory, path);
-			if (is_directory) {
-				directory_list.emplace_back(std::move(full_path));
-			} else {
-				file_list.emplace_back(std::move(full_path));
-			}
-		});
-	}
-	if (file_list.empty()) {
-		return;
-	}
-	if (overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE) {
-		for (auto &file : file_list) {
-			fs.RemoveFile(file);
-		}
-	} else {
-		throw IOException("Directory \"%s\" is not empty! Enable OVERWRITE option to overwrite files", file_path);
-	}
-}
-
-unique_ptr<GlobalSinkState> PhysicalCopyToFile::GetGlobalSinkState(ClientContext &context) const {
-	if (partition_output || per_thread_output || rotate) {
-		auto &fs = FileSystem::GetFileSystem(context);
-		if (fs.FileExists(file_path)) {
-			// the target file exists AND is a file (not a directory)
-			if (fs.IsRemoteFile(file_path)) {
-				// for remote files we cannot do anything - as we cannot delete the file
-				throw IOException("Cannot write to \"%s\" - it exists and is a file, not a directory!", file_path);
-			} else {
-				// for local files we can remove the file if OVERWRITE_OR_IGNORE is enabled
-				if (overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE) {
-					fs.RemoveFile(file_path);
-				} else {
-					throw IOException("Cannot write to \"%s\" - it exists and is a file, not a directory! Enable "
-					                  "OVERWRITE option to overwrite the file",
-					                  file_path);
-				}
-			}
-		}
-		// what if the target exists and is a directory
-		if (!fs.DirectoryExists(file_path)) {
-			fs.CreateDirectory(file_path);
-		} else {
-			CheckDirectory(fs, file_path, overwrite_mode);
-		}
-
-		auto state = make_uniq<CopyToFunctionGlobalState>(context, nullptr);
-		if (!per_thread_output && rotate) {
-			auto global_lock = state->lock.GetExclusiveLock();
-			state->global_state = CreateFileState(context, *state, *global_lock);
-		}
-
-		if (partition_output) {
-			state->partition_state = make_shared_ptr<GlobalHivePartitionState>();
-		}
-
-		return std::move(state);
-	}
-
-	auto state = make_uniq<CopyToFunctionGlobalState>(
-	    context, function.copy_to_initialize_global(context, *bind_data, file_path));
-	if (use_tmp_file) {
-		auto global_lock = state->lock.GetExclusiveLock();
-		state->AddFileName(*global_lock, file_path);
-	} else {
-		state->file_names.emplace_back(file_path);
-	}
-	return std::move(state);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-void PhysicalCopyToFile::MoveTmpFile(ClientContext &context, const string &tmp_file_path) {
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto file_path = GetNonTmpFile(context, tmp_file_path);
-	if (fs.FileExists(file_path)) {
-		fs.RemoveFile(file_path);
-	}
-	fs.MoveFile(tmp_file_path, file_path);
-}
-
-string PhysicalCopyToFile::GetNonTmpFile(ClientContext &context, const string &tmp_file_path) {
-	auto &fs = FileSystem::GetFileSystem(context);
-
-	auto path = StringUtil::GetFilePath(tmp_file_path);
-	auto base = StringUtil::GetFileName(tmp_file_path);
-
-	auto prefix = base.find("tmp_");
-	if (prefix == 0) {
-		base = base.substr(4);
-	}
-
-	return fs.JoinPath(path, base);
-}
-
-PhysicalCopyToFile::PhysicalCopyToFile(vector<LogicalType> types, CopyFunction function_p,
-                                       unique_ptr<FunctionData> bind_data, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::COPY_TO_FILE, std::move(types), estimated_cardinality),
-      function(std::move(function_p)), bind_data(std::move(bind_data)), parallel(false) {
-}
-
-SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &g = input.global_state.Cast<CopyToFunctionGlobalState>();
-	auto &l = input.local_state.Cast<CopyToFunctionLocalState>();
-
-	g.rows_copied += chunk.size();
-
-	if (partition_output) {
-		l.AppendToPartition(context, *this, g, chunk);
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	if (per_thread_output) {
-		auto &gstate = l.global_state;
-		if (!gstate) {
-			// Lazily create file state here to prevent creating empty files
-			auto global_lock = g.lock.GetExclusiveLock();
-			gstate = CreateFileState(context.client, *sink_state, *global_lock);
-		} else if (rotate && function.rotate_next_file(*gstate, *bind_data, file_size_bytes)) {
-			function.copy_to_finalize(context.client, *bind_data, *gstate);
-			auto global_lock = g.lock.GetExclusiveLock();
-			gstate = CreateFileState(context.client, *sink_state, *global_lock);
-		}
-		function.copy_to_sink(context, *bind_data, *gstate, *l.local_state, chunk);
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	if (!file_size_bytes.IsValid() && !rotate) {
-		function.copy_to_sink(context, *bind_data, *g.global_state, *l.local_state, chunk);
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	// FILE_SIZE_BYTES/rotate is set, but threads write to the same file, synchronize using lock
-	auto &gstate = g.global_state;
-	auto global_lock = g.lock.GetExclusiveLock();
-	if (rotate && function.rotate_next_file(*gstate, *bind_data, file_size_bytes)) {
-		auto owned_gstate = std::move(gstate);
-		gstate = CreateFileState(context.client, *sink_state, *global_lock);
-		global_lock.reset();
-		function.copy_to_finalize(context.client, *bind_data, *owned_gstate);
-	} else {
-		global_lock.reset();
-	}
-
-	global_lock = g.lock.GetSharedLock();
-	function.copy_to_sink(context, *bind_data, *gstate, *l.local_state, chunk);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalCopyToFile::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &g = input.global_state.Cast<CopyToFunctionGlobalState>();
-	auto &l = input.local_state.Cast<CopyToFunctionLocalState>();
-
-	if (partition_output) {
-		// flush all remaining partitions
-		l.FlushPartitions(context, *this, g);
-	} else if (function.copy_to_combine) {
-		if (per_thread_output) {
-			// For PER_THREAD_OUTPUT, we can combine/finalize immediately (if there is a gstate)
-			if (l.global_state) {
-				function.copy_to_combine(context, *bind_data, *l.global_state, *l.local_state);
-				function.copy_to_finalize(context.client, *bind_data, *l.global_state);
-			}
-		} else if (rotate) {
-			// File in global state may change with FILE_SIZE_BYTES/rotate, need to grab lock
-			auto lock = g.lock.GetSharedLock();
-			function.copy_to_combine(context, *bind_data, *g.global_state, *l.local_state);
-		} else {
-			function.copy_to_combine(context, *bind_data, *g.global_state, *l.local_state);
-		}
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalCopyToFile::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                              OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<CopyToFunctionGlobalState>();
-	if (partition_output) {
-		// finalize any outstanding partitions
-		gstate.FinalizePartitions(context, *this);
-		return SinkFinalizeType::READY;
-	}
-	if (per_thread_output) {
-		// already happened in combine
-		if (NumericCast<int64_t>(gstate.rows_copied.load()) == 0 && sink_state != nullptr) {
-			// no rows from source, write schema to file
-			auto global_lock = gstate.lock.GetExclusiveLock();
-			gstate.global_state = CreateFileState(context, *sink_state, *global_lock);
-			function.copy_to_finalize(context, *bind_data, *gstate.global_state);
-		}
-		return SinkFinalizeType::READY;
-	}
-	if (function.copy_to_finalize) {
-		function.copy_to_finalize(context, *bind_data, *gstate.global_state);
-
-		if (use_tmp_file) {
-			D_ASSERT(!per_thread_output);
-			D_ASSERT(!partition_output);
-			D_ASSERT(!file_size_bytes.IsValid());
-			D_ASSERT(!rotate);
-			MoveTmpFile(context, file_path);
-		}
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-
-SourceResultType PhysicalCopyToFile::GetData(ExecutionContext &context, DataChunk &chunk,
-                                             OperatorSourceInput &input) const {
-	auto &g = sink_state->Cast<CopyToFunctionGlobalState>();
-
-	chunk.SetCardinality(1);
-	switch (return_type) {
-	case CopyFunctionReturnType::CHANGED_ROWS:
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
-		break;
-	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST:
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
-		chunk.SetValue(1, 0, Value::LIST(LogicalType::VARCHAR, g.file_names));
-		break;
-	default:
-		throw NotImplementedException("Unknown CopyFunctionReturnType");
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_delete.cpp b/src/duckdb/src/execution/operator/persistent/physical_delete.cpp
deleted file mode 100644
index e92e2ec66..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_delete.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_delete.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/delete_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-namespace duckdb {
-
-PhysicalDelete::PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
-                               vector<unique_ptr<BoundConstraint>> bound_constraints, idx_t row_id_index,
-                               idx_t estimated_cardinality, bool return_chunk)
-    : PhysicalOperator(PhysicalOperatorType::DELETE_OPERATOR, std::move(types), estimated_cardinality),
-      tableref(tableref), table(table), bound_constraints(std::move(bound_constraints)), row_id_index(row_id_index),
-      return_chunk(return_chunk) {
-}
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class DeleteGlobalState : public GlobalSinkState {
-public:
-	explicit DeleteGlobalState(ClientContext &context, const vector<LogicalType> &return_types,
-	                           TableCatalogEntry &table, const vector<unique_ptr<BoundConstraint>> &bound_constraints)
-	    : deleted_count(0), return_collection(context, return_types), has_unique_indexes(false) {
-
-		// We need to append deletes to the local delete-ART.
-		auto &storage = table.GetStorage();
-		if (storage.HasUniqueIndexes()) {
-			storage.InitializeLocalStorage(delete_index_append_state, table, context, bound_constraints);
-			has_unique_indexes = true;
-		}
-	}
-
-	mutex delete_lock;
-	idx_t deleted_count;
-	ColumnDataCollection return_collection;
-	LocalAppendState delete_index_append_state;
-	bool has_unique_indexes;
-};
-
-class DeleteLocalState : public LocalSinkState {
-public:
-	DeleteLocalState(ClientContext &context, TableCatalogEntry &table,
-	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-		delete_chunk.Initialize(Allocator::Get(context), table.GetTypes());
-		auto &storage = table.GetStorage();
-		delete_state = storage.InitializeDelete(table, context, bound_constraints);
-	}
-
-public:
-	DataChunk delete_chunk;
-	unique_ptr<TableDeleteState> delete_state;
-};
-
-SinkResultType PhysicalDelete::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &g_state = input.global_state.Cast<DeleteGlobalState>();
-	auto &l_state = input.local_state.Cast<DeleteLocalState>();
-
-	auto &transaction = DuckTransaction::Get(context.client, table.db);
-	auto &row_ids = chunk.data[row_id_index];
-
-	vector<StorageIndex> column_ids;
-	for (idx_t i = 0; i < table.ColumnCount(); i++) {
-		column_ids.emplace_back(i);
-	};
-	auto fetch_state = ColumnFetchState();
-
-	lock_guard<mutex> delete_guard(g_state.delete_lock);
-	if (!return_chunk && !g_state.has_unique_indexes) {
-		g_state.deleted_count += table.Delete(*l_state.delete_state, context.client, row_ids, chunk.size());
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	// Fetch the to-be-deleted chunk.
-	l_state.delete_chunk.Reset();
-	row_ids.Flatten(chunk.size());
-	table.Fetch(transaction, l_state.delete_chunk, column_ids, row_ids, chunk.size(), fetch_state);
-
-	// Append the deleted row IDs to the delete indexes.
-	// If we only delete local row IDs, then the delete_chunk is empty.
-	if (g_state.has_unique_indexes && l_state.delete_chunk.size() != 0) {
-		auto &local_storage = LocalStorage::Get(context.client, table.db);
-		auto storage = local_storage.GetStorage(table);
-		storage->delete_indexes.Scan([&](Index &index) {
-			if (!index.IsBound() || !index.IsUnique()) {
-				return false;
-			}
-			auto &bound_index = index.Cast<BoundIndex>();
-			auto error = bound_index.Append(l_state.delete_chunk, row_ids);
-			if (error.HasError()) {
-				throw InternalException("failed to update delete ART in physical delete: ", error.Message());
-			}
-			return false;
-		});
-	}
-
-	// Append the return_chunk to the return collection.
-	if (return_chunk) {
-		g_state.return_collection.Append(l_state.delete_chunk);
-	}
-
-	g_state.deleted_count += table.Delete(*l_state.delete_state, context.client, row_ids, chunk.size());
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<GlobalSinkState> PhysicalDelete::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<DeleteGlobalState>(context, GetTypes(), tableref, bound_constraints);
-}
-
-unique_ptr<LocalSinkState> PhysicalDelete::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<DeleteLocalState>(context.client, tableref, bound_constraints);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class DeleteSourceState : public GlobalSourceState {
-public:
-	explicit DeleteSourceState(const PhysicalDelete &op) {
-		if (op.return_chunk) {
-			D_ASSERT(op.sink_state);
-			auto &g = op.sink_state->Cast<DeleteGlobalState>();
-			g.return_collection.InitializeScan(scan_state);
-		}
-	}
-
-	ColumnDataScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalDelete::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<DeleteSourceState>(*this);
-}
-
-SourceResultType PhysicalDelete::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &state = input.global_state.Cast<DeleteSourceState>();
-	auto &g = sink_state->Cast<DeleteGlobalState>();
-	if (!return_chunk) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.deleted_count)));
-		return SourceResultType::FINISHED;
-	}
-
-	g.return_collection.Scan(state.scan_state, chunk);
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_export.cpp b/src/duckdb/src/execution/operator/persistent/physical_export.cpp
deleted file mode 100644
index 66afb4c97..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_export.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_export.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-
-#include <algorithm>
-#include <sstream>
-
-namespace duckdb {
-
-void ReorderTableEntries(catalog_entry_vector_t &tables);
-
-using std::stringstream;
-
-PhysicalExport::PhysicalExport(vector<LogicalType> types, CopyFunction function, unique_ptr<CopyInfo> info,
-                               idx_t estimated_cardinality, unique_ptr<BoundExportData> exported_tables)
-    : PhysicalOperator(PhysicalOperatorType::EXPORT, std::move(types), estimated_cardinality),
-      function(std::move(function)), info(std::move(info)), exported_tables(std::move(exported_tables)) {
-}
-
-static void WriteCatalogEntries(stringstream &ss, catalog_entry_vector_t &entries) {
-	for (auto &entry : entries) {
-		if (entry.get().internal) {
-			continue;
-		}
-		auto create_info = entry.get().GetInfo();
-		try {
-			// Strip the catalog from the info
-			create_info->catalog.clear();
-			auto to_string = create_info->ToString();
-			ss << to_string;
-		} catch (const NotImplementedException &) {
-			ss << entry.get().ToSQL();
-		}
-		ss << '\n';
-	}
-	ss << '\n';
-}
-
-static void WriteStringStreamToFile(FileSystem &fs, stringstream &ss, const string &path) {
-	auto ss_string = ss.str();
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW |
-	                                    FileLockType::WRITE_LOCK);
-	fs.Write(*handle, (void *)ss_string.c_str(), NumericCast<int64_t>(ss_string.size()));
-	handle.reset();
-}
-
-static void WriteCopyStatement(FileSystem &fs, stringstream &ss, CopyInfo &info, ExportedTableData &exported_table,
-                               CopyFunction const &function) {
-	ss << "COPY ";
-
-	//! NOTE: The catalog is explicitly not set here
-	if (exported_table.schema_name != DEFAULT_SCHEMA && !exported_table.schema_name.empty()) {
-		ss << KeywordHelper::WriteOptionallyQuoted(exported_table.schema_name) << ".";
-	}
-
-	auto file_path = StringUtil::Replace(exported_table.file_path, "\\", "/");
-	ss << StringUtil::Format("%s FROM %s (", SQLIdentifier(exported_table.table_name), SQLString(file_path));
-	// write the copy options
-	ss << "FORMAT '" << info.format << "'";
-	if (info.format == "csv") {
-		// insert default csv options, if not specified
-		if (info.options.find("header") == info.options.end()) {
-			info.options["header"].push_back(Value::INTEGER(1));
-		}
-		if (info.options.find("delimiter") == info.options.end() && info.options.find("sep") == info.options.end() &&
-		    info.options.find("delim") == info.options.end()) {
-			info.options["delimiter"].push_back(Value(","));
-		}
-		if (info.options.find("quote") == info.options.end()) {
-			info.options["quote"].push_back(Value("\""));
-		}
-		info.options.erase("force_not_null");
-		for (auto &not_null_column : exported_table.not_null_columns) {
-			info.options["force_not_null"].push_back(not_null_column);
-		}
-	}
-	for (auto &copy_option : info.options) {
-		if (copy_option.first == "force_quote") {
-			continue;
-		}
-		if (copy_option.second.empty()) {
-			// empty options are interpreted as TRUE
-			copy_option.second.push_back(true);
-		}
-		ss << ", " << copy_option.first << " ";
-		if (copy_option.second.size() == 1) {
-			ss << copy_option.second[0].ToSQLString();
-		} else {
-			// For Lists
-			ss << "(";
-			for (idx_t i = 0; i < copy_option.second.size(); i++) {
-				ss << copy_option.second[i].ToSQLString();
-				if (i != copy_option.second.size() - 1) {
-					ss << ", ";
-				}
-			}
-			ss << ")";
-		}
-	}
-	ss << ");" << '\n';
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class ExportSourceState : public GlobalSourceState {
-public:
-	ExportSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalExport::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<ExportSourceState>();
-}
-
-void PhysicalExport::ExtractEntries(ClientContext &context, vector<reference<SchemaCatalogEntry>> &schema_list,
-                                    ExportEntries &result) {
-	for (auto &schema_p : schema_list) {
-		auto &schema = schema_p.get();
-		auto &catalog = schema.ParentCatalog();
-		if (catalog.IsSystemCatalog() || catalog.IsTemporaryCatalog()) {
-			continue;
-		}
-		if (!schema.internal) {
-			result.schemas.push_back(schema);
-		}
-		schema.Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			if (entry.type != CatalogType::TABLE_ENTRY) {
-				result.views.push_back(entry);
-			}
-			if (entry.type == CatalogType::TABLE_ENTRY) {
-				result.tables.push_back(entry);
-			}
-		});
-		schema.Scan(context, CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			result.sequences.push_back(entry);
-		});
-		schema.Scan(context, CatalogType::TYPE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			result.custom_types.push_back(entry);
-		});
-		schema.Scan(context, CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			result.indexes.push_back(entry);
-		});
-		schema.Scan(context, CatalogType::MACRO_ENTRY, [&](CatalogEntry &entry) {
-			if (!entry.internal && entry.type == CatalogType::MACRO_ENTRY) {
-				result.macros.push_back(entry);
-			}
-		});
-		schema.Scan(context, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry &entry) {
-			if (!entry.internal && entry.type == CatalogType::TABLE_MACRO_ENTRY) {
-				result.macros.push_back(entry);
-			}
-		});
-	}
-}
-
-static void AddEntries(catalog_entry_vector_t &all_entries, catalog_entry_vector_t &to_add) {
-	for (auto &entry : to_add) {
-		all_entries.push_back(entry);
-	}
-	to_add.clear();
-}
-
-catalog_entry_vector_t PhysicalExport::GetNaiveExportOrder(ClientContext &context, Catalog &catalog) {
-	// gather all catalog types to export
-	ExportEntries entries;
-	auto schema_list = catalog.GetSchemas(context);
-	PhysicalExport::ExtractEntries(context, schema_list, entries);
-
-	ReorderTableEntries(entries.tables);
-
-	// order macro's by timestamp so nested macro's are imported nicely
-	sort(entries.macros.begin(), entries.macros.end(),
-	     [](const reference<CatalogEntry> &lhs, const reference<CatalogEntry> &rhs) {
-		     return lhs.get().oid < rhs.get().oid;
-	     });
-
-	catalog_entry_vector_t catalog_entries;
-	idx_t size = 0;
-	size += entries.schemas.size();
-	size += entries.custom_types.size();
-	size += entries.sequences.size();
-	size += entries.tables.size();
-	size += entries.views.size();
-	size += entries.indexes.size();
-	size += entries.macros.size();
-	catalog_entries.reserve(size);
-	AddEntries(catalog_entries, entries.schemas);
-	AddEntries(catalog_entries, entries.sequences);
-	AddEntries(catalog_entries, entries.custom_types);
-	AddEntries(catalog_entries, entries.tables);
-	AddEntries(catalog_entries, entries.macros);
-	AddEntries(catalog_entries, entries.views);
-	AddEntries(catalog_entries, entries.indexes);
-	return catalog_entries;
-}
-
-SourceResultType PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &state = input.global_state.Cast<ExportSourceState>();
-	if (state.finished) {
-		return SourceResultType::FINISHED;
-	}
-
-	auto &ccontext = context.client;
-	auto &fs = FileSystem::GetFileSystem(ccontext);
-
-	auto &catalog = Catalog::GetCatalog(ccontext, info->catalog);
-
-	catalog_entry_vector_t catalog_entries;
-	catalog_entries = GetNaiveExportOrder(context.client, catalog);
-	auto dependency_manager = catalog.GetDependencyManager();
-	if (dependency_manager) {
-		dependency_manager->ReorderEntries(catalog_entries, ccontext);
-	}
-
-	// write the schema.sql file
-	stringstream ss;
-	WriteCatalogEntries(ss, catalog_entries);
-	WriteStringStreamToFile(fs, ss, fs.JoinPath(info->file_path, "schema.sql"));
-
-	// write the load.sql file
-	// for every table, we write COPY INTO statement with the specified options
-	stringstream load_ss;
-	for (idx_t i = 0; i < exported_tables->data.size(); i++) {
-		auto exported_table_info = exported_tables->data[i].table_data;
-		WriteCopyStatement(fs, load_ss, *info, exported_table_info, function);
-	}
-	WriteStringStreamToFile(fs, load_ss, fs.JoinPath(info->file_path, "load.sql"));
-	state.finished = true;
-
-	return SourceResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalExport::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	// nop
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalExport::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	// EXPORT has an optional child
-	// we only need to schedule child pipelines if there is a child
-	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, *this);
-	if (children.empty()) {
-		return;
-	}
-	PhysicalOperator::BuildPipelines(current, meta_pipeline);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalExport::GetSources() const {
-	return {*this};
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_insert.cpp b/src/duckdb/src/execution/operator/persistent/physical_insert.cpp
deleted file mode 100644
index dac3491fe..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_insert.cpp
+++ /dev/null
@@ -1,768 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_insert.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-#include "duckdb/transaction/local_storage.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/common/types/conflict_manager.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/update_state.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-
-namespace duckdb {
-
-PhysicalInsert::PhysicalInsert(
-    vector<LogicalType> types_p, TableCatalogEntry &table, physical_index_vector_t<idx_t> column_index_map,
-    vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<BoundConstraint>> bound_constraints_p,
-    vector<unique_ptr<Expression>> set_expressions, vector<PhysicalIndex> set_columns, vector<LogicalType> set_types,
-    idx_t estimated_cardinality, bool return_chunk, bool parallel, OnConflictAction action_type,
-    unique_ptr<Expression> on_conflict_condition_p, unique_ptr<Expression> do_update_condition_p,
-    unordered_set<column_t> conflict_target_p, vector<column_t> columns_to_fetch_p, bool update_is_del_and_insert)
-    : PhysicalOperator(PhysicalOperatorType::INSERT, std::move(types_p), estimated_cardinality),
-      column_index_map(std::move(column_index_map)), insert_table(&table), insert_types(table.GetTypes()),
-      bound_defaults(std::move(bound_defaults)), bound_constraints(std::move(bound_constraints_p)),
-      return_chunk(return_chunk), parallel(parallel), action_type(action_type),
-      set_expressions(std::move(set_expressions)), set_columns(std::move(set_columns)), set_types(std::move(set_types)),
-      on_conflict_condition(std::move(on_conflict_condition_p)), do_update_condition(std::move(do_update_condition_p)),
-      conflict_target(std::move(conflict_target_p)), update_is_del_and_insert(update_is_del_and_insert) {
-
-	if (action_type == OnConflictAction::THROW) {
-		return;
-	}
-
-	D_ASSERT(this->set_expressions.size() == this->set_columns.size());
-
-	// One or more columns are referenced from the existing table,
-	// we use the 'insert_types' to figure out which types these columns have
-	types_to_fetch = vector<LogicalType>(columns_to_fetch_p.size(), LogicalType::SQLNULL);
-	for (idx_t i = 0; i < columns_to_fetch_p.size(); i++) {
-		auto &id = columns_to_fetch_p[i];
-		D_ASSERT(id < insert_types.size());
-		types_to_fetch[i] = insert_types[id];
-		columns_to_fetch.emplace_back(id);
-	}
-}
-
-PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info_p,
-                               idx_t estimated_cardinality, bool parallel)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE_AS, op.types, estimated_cardinality), insert_table(nullptr),
-      return_chunk(false), schema(&schema), info(std::move(info_p)), parallel(parallel),
-      action_type(OnConflictAction::THROW), update_is_del_and_insert(false) {
-	GetInsertInfo(*info, insert_types, bound_defaults);
-}
-
-void PhysicalInsert::GetInsertInfo(const BoundCreateTableInfo &info, vector<LogicalType> &insert_types,
-                                   vector<unique_ptr<Expression>> &bound_defaults) {
-	auto &create_info = info.base->Cast<CreateTableInfo>();
-	for (auto &col : create_info.columns.Physical()) {
-		insert_types.push_back(col.GetType());
-		bound_defaults.push_back(make_uniq<BoundConstantExpression>(Value(col.GetType())));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-
-InsertGlobalState::InsertGlobalState(ClientContext &context, const vector<LogicalType> &return_types,
-                                     DuckTableEntry &table)
-    : table(table), insert_count(0), initialized(false), return_collection(context, return_types) {
-}
-
-InsertLocalState::InsertLocalState(ClientContext &context, const vector<LogicalType> &types,
-                                   const vector<unique_ptr<Expression>> &bound_defaults,
-                                   const vector<unique_ptr<BoundConstraint>> &bound_constraints)
-    : default_executor(context, bound_defaults), bound_constraints(bound_constraints) {
-
-	auto &allocator = Allocator::Get(context);
-	insert_chunk.Initialize(allocator, types);
-	update_chunk.Initialize(allocator, types);
-	append_chunk.Initialize(allocator, types);
-}
-
-ConstraintState &InsertLocalState::GetConstraintState(DataTable &table, TableCatalogEntry &table_ref) {
-	if (!constraint_state) {
-		constraint_state = table.InitializeConstraintState(table_ref, bound_constraints);
-	}
-	return *constraint_state;
-}
-
-TableDeleteState &InsertLocalState::GetDeleteState(DataTable &table, TableCatalogEntry &table_ref,
-                                                   ClientContext &context) {
-	if (!delete_state) {
-		delete_state = table.InitializeDelete(table_ref, context, bound_constraints);
-	}
-	return *delete_state;
-}
-
-unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &context) const {
-	optional_ptr<TableCatalogEntry> table;
-	if (info) {
-		// CREATE TABLE AS
-		D_ASSERT(!insert_table);
-		auto &catalog = schema->catalog;
-		table = &catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info)
-		             ->Cast<TableCatalogEntry>();
-	} else {
-		D_ASSERT(insert_table);
-		D_ASSERT(insert_table->IsDuckTable());
-		table = insert_table.get_mutable();
-	}
-	auto result = make_uniq<InsertGlobalState>(context, GetTypes(), table->Cast<DuckTableEntry>());
-	return std::move(result);
-}
-
-unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<InsertLocalState>(context.client, insert_types, bound_defaults, bound_constraints);
-}
-
-void PhysicalInsert::ResolveDefaults(const TableCatalogEntry &table, DataChunk &chunk,
-                                     const physical_index_vector_t<idx_t> &column_index_map,
-                                     ExpressionExecutor &default_executor, DataChunk &result) {
-	chunk.Flatten();
-	default_executor.SetChunk(chunk);
-
-	result.Reset();
-	result.SetCardinality(chunk);
-
-	if (!column_index_map.empty()) {
-		// columns specified by the user, use column_index_map
-		for (auto &col : table.GetColumns().Physical()) {
-			auto storage_idx = col.StorageOid();
-			auto mapped_index = column_index_map[col.Physical()];
-			if (mapped_index == DConstants::INVALID_INDEX) {
-				// insert default value
-				default_executor.ExecuteExpression(storage_idx, result.data[storage_idx]);
-			} else {
-				// get value from child chunk
-				D_ASSERT((idx_t)mapped_index < chunk.ColumnCount());
-				D_ASSERT(result.data[storage_idx].GetType() == chunk.data[mapped_index].GetType());
-				result.data[storage_idx].Reference(chunk.data[mapped_index]);
-			}
-		}
-	} else {
-		// no columns specified, just append directly
-		for (idx_t i = 0; i < result.ColumnCount(); i++) {
-			D_ASSERT(result.data[i].GetType() == chunk.data[i].GetType());
-			result.data[i].Reference(chunk.data[i]);
-		}
-	}
-}
-
-bool AllConflictsMeetCondition(DataChunk &result) {
-	result.Flatten();
-	auto data = FlatVector::GetData<bool>(result.data[0]);
-	for (idx_t i = 0; i < result.size(); i++) {
-		if (!data[i]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void CheckOnConflictCondition(ExecutionContext &context, DataChunk &conflicts, const unique_ptr<Expression> &condition,
-                              DataChunk &result) {
-	ExpressionExecutor executor(context.client, *condition);
-	result.Initialize(context.client, {LogicalType::BOOLEAN});
-	executor.Execute(conflicts, result);
-	result.SetCardinality(conflicts.size());
-}
-
-static void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
-                                           ClientContext &client, const PhysicalInsert &op) {
-	auto &types_to_fetch = op.types_to_fetch;
-	auto &insert_types = op.insert_types;
-
-	if (types_to_fetch.empty()) {
-		// We have not scanned the initial table, so we can just duplicate the initial chunk
-		result.Initialize(client, input_chunk.GetTypes());
-		result.Reference(input_chunk);
-		result.SetCardinality(input_chunk);
-		return;
-	}
-	vector<LogicalType> combined_types;
-	combined_types.reserve(insert_types.size() + types_to_fetch.size());
-	combined_types.insert(combined_types.end(), insert_types.begin(), insert_types.end());
-	combined_types.insert(combined_types.end(), types_to_fetch.begin(), types_to_fetch.end());
-
-	result.Initialize(client, combined_types);
-	result.Reset();
-	// Add the VALUES list
-	for (idx_t i = 0; i < insert_types.size(); i++) {
-		idx_t col_idx = i;
-		auto &other_col = input_chunk.data[i];
-		auto &this_col = result.data[col_idx];
-		D_ASSERT(other_col.GetType() == this_col.GetType());
-		this_col.Reference(other_col);
-	}
-	// Add the columns from the original conflicting tuples
-	for (idx_t i = 0; i < types_to_fetch.size(); i++) {
-		idx_t col_idx = i + insert_types.size();
-		auto &other_col = scan_chunk.data[i];
-		auto &this_col = result.data[col_idx];
-		D_ASSERT(other_col.GetType() == this_col.GetType());
-		this_col.Reference(other_col);
-	}
-	// This is guaranteed by the requirement of a conflict target to have a condition or set expressions
-	// Only when we have any sort of condition or SET expression that references the existing table is this possible
-	// to not be true.
-	// We can have a SET expression without a conflict target ONLY if there is only 1 Index on the table
-	// In which case this also can't cause a discrepancy between existing tuple count and insert tuple count
-	D_ASSERT(input_chunk.size() == scan_chunk.size());
-	result.SetCardinality(input_chunk.size());
-}
-
-static void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table, Vector &row_ids,
-                              DataChunk &update_chunk, const PhysicalInsert &op) {
-
-	auto &do_update_condition = op.do_update_condition;
-	auto &set_types = op.set_types;
-	auto &set_expressions = op.set_expressions;
-	// Check the optional condition for the DO UPDATE clause, to filter which rows will be updated
-	if (do_update_condition) {
-		DataChunk do_update_filter_result;
-		do_update_filter_result.Initialize(context.client, {LogicalType::BOOLEAN});
-		ExpressionExecutor where_executor(context.client, *do_update_condition);
-		where_executor.Execute(chunk, do_update_filter_result);
-		do_update_filter_result.SetCardinality(chunk.size());
-		do_update_filter_result.Flatten();
-
-		ManagedSelection selection(chunk.size());
-
-		auto where_data = FlatVector::GetData<bool>(do_update_filter_result.data[0]);
-		for (idx_t i = 0; i < chunk.size(); i++) {
-			if (where_data[i]) {
-				selection.Append(i);
-			}
-		}
-		if (selection.Count() != selection.Size()) {
-			// Not all conflicts met the condition, need to filter out the ones that don't
-			chunk.Slice(selection.Selection(), selection.Count());
-			chunk.SetCardinality(selection.Count());
-			// Also apply this Slice to the to-update row_ids
-			row_ids.Slice(selection.Selection(), selection.Count());
-		}
-	}
-
-	// Execute the SET expressions
-	update_chunk.Initialize(context.client, set_types);
-	ExpressionExecutor executor(context.client, set_expressions);
-	executor.Execute(chunk, update_chunk);
-	update_chunk.SetCardinality(chunk);
-}
-
-template <bool GLOBAL>
-static idx_t PerformOnConflictAction(InsertLocalState &lstate, ExecutionContext &context, DataChunk &chunk,
-                                     TableCatalogEntry &table, Vector &row_ids, const PhysicalInsert &op) {
-	// Early-out, if we do nothing on conflicting rows.
-	if (op.action_type == OnConflictAction::NOTHING) {
-		return 0;
-	}
-
-	auto &set_columns = op.set_columns;
-	DataChunk update_chunk;
-	CreateUpdateChunk(context, chunk, table, row_ids, update_chunk, op);
-	auto &data_table = table.GetStorage();
-
-	// Perform the UPDATE on the (global) storage.
-	if (!op.update_is_del_and_insert) {
-		if (GLOBAL) {
-			auto update_state = data_table.InitializeUpdate(table, context.client, op.bound_constraints);
-			data_table.Update(*update_state, context.client, row_ids, set_columns, update_chunk);
-			return update_chunk.size();
-		}
-		auto &local_storage = LocalStorage::Get(context.client, data_table.db);
-		local_storage.Update(data_table, row_ids, set_columns, update_chunk);
-		return update_chunk.size();
-	}
-
-	// Arrange the columns in the standard table order.
-	DataChunk &append_chunk = lstate.append_chunk;
-	append_chunk.SetCardinality(update_chunk);
-	for (idx_t i = 0; i < append_chunk.ColumnCount(); i++) {
-		append_chunk.data[i].Reference(chunk.data[i]);
-	}
-	for (idx_t i = 0; i < set_columns.size(); i++) {
-		append_chunk.data[set_columns[i].index].Reference(update_chunk.data[i]);
-	}
-
-	if (GLOBAL) {
-		auto &delete_state = lstate.GetDeleteState(data_table, table, context.client);
-		data_table.Delete(delete_state, context.client, row_ids, update_chunk.size());
-	} else {
-		auto &local_storage = LocalStorage::Get(context.client, data_table.db);
-		local_storage.Delete(data_table, row_ids, update_chunk.size());
-	}
-
-	data_table.LocalAppend(table, context.client, append_chunk, op.bound_constraints, row_ids, append_chunk);
-	return update_chunk.size();
-}
-
-// TODO: should we use a hash table to keep track of this instead?
-static void RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) {
-	// Insert all rows, if any of the rows has already been updated before, we throw an error
-	auto data = FlatVector::GetData<row_t>(row_ids);
-
-	auto &updated_rows = lstate.updated_rows;
-	for (idx_t i = 0; i < count; i++) {
-		auto result = updated_rows.insert(data[i]);
-		if (result.second == false) {
-			// This is following postgres behavior:
-			throw InvalidInputException(
-			    "ON CONFLICT DO UPDATE can not update the same row twice in the same command. Ensure that no rows "
-			    "proposed for insertion within the same command have duplicate constrained values");
-		}
-	}
-}
-
-static void CheckDistinctnessInternal(ValidityMask &valid, vector<reference<Vector>> &sort_keys, idx_t count,
-                                      map<idx_t, vector<idx_t>> &result) {
-	for (idx_t i = 0; i < count; i++) {
-		bool has_conflicts = false;
-		for (idx_t j = i + 1; j < count; j++) {
-			if (!valid.RowIsValid(j)) {
-				// Already a conflict
-				continue;
-			}
-			bool matches = true;
-			for (auto &sort_key : sort_keys) {
-				auto &this_row = FlatVector::GetData<string_t>(sort_key.get())[i];
-				auto &other_row = FlatVector::GetData<string_t>(sort_key.get())[j];
-				if (this_row != other_row) {
-					matches = false;
-					break;
-				}
-			}
-			if (matches) {
-				auto &row_ids = result[i];
-				has_conflicts = true;
-				row_ids.push_back(j);
-				valid.SetInvalid(j);
-			}
-		}
-		if (has_conflicts) {
-			valid.SetInvalid(i);
-		}
-	}
-}
-
-void PrepareSortKeys(DataChunk &input, unordered_map<column_t, unique_ptr<Vector>> &sort_keys,
-                     const unordered_set<column_t> &column_ids) {
-	OrderModifiers order_modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-	for (auto &it : column_ids) {
-		auto &sort_key = sort_keys[it];
-		if (sort_key != nullptr) {
-			continue;
-		}
-		auto &column = input.data[it];
-		sort_key = make_uniq<Vector>(LogicalType::BLOB);
-		CreateSortKeyHelpers::CreateSortKey(column, input.size(), order_modifiers, *sort_key);
-	}
-}
-
-static map<idx_t, vector<idx_t>> CheckDistinctness(DataChunk &input, ConflictInfo &info,
-                                                   unordered_set<BoundIndex *> &matched_indexes) {
-	map<idx_t, vector<idx_t>> conflicts;
-	unordered_map<idx_t, unique_ptr<Vector>> sort_keys;
-	//! Register which rows have already caused a conflict
-	ValidityMask valid(input.size());
-
-	auto &column_ids = info.column_ids;
-	if (column_ids.empty()) {
-		for (auto index : matched_indexes) {
-			auto &index_column_ids = index->GetColumnIdSet();
-			PrepareSortKeys(input, sort_keys, index_column_ids);
-			vector<reference<Vector>> columns;
-			for (auto &idx : index_column_ids) {
-				columns.push_back(*sort_keys[idx]);
-			}
-			CheckDistinctnessInternal(valid, columns, input.size(), conflicts);
-		}
-	} else {
-		PrepareSortKeys(input, sort_keys, column_ids);
-		vector<reference<Vector>> columns;
-		for (auto &idx : column_ids) {
-			columns.push_back(*sort_keys[idx]);
-		}
-		CheckDistinctnessInternal(valid, columns, input.size(), conflicts);
-	}
-	return conflicts;
-}
-
-template <bool GLOBAL>
-static void VerifyOnConflictCondition(ExecutionContext &context, DataChunk &combined_chunk,
-                                      const unique_ptr<Expression> &on_conflict_condition,
-                                      ConstraintState &constraint_state, DataChunk &tuples, DataTable &data_table,
-                                      LocalStorage &local_storage) {
-	if (!on_conflict_condition) {
-		return;
-	}
-	DataChunk conflict_condition_result;
-	CheckOnConflictCondition(context, combined_chunk, on_conflict_condition, conflict_condition_result);
-	bool conditions_met = AllConflictsMeetCondition(conflict_condition_result);
-	if (conditions_met) {
-		return;
-	}
-
-	// We need to throw. Filter all tuples that passed, and verify again with those that violate the constraint.
-	ManagedSelection sel(combined_chunk.size());
-	auto data = FlatVector::GetData<bool>(conflict_condition_result.data[0]);
-	for (idx_t i = 0; i < combined_chunk.size(); i++) {
-		if (!data[i]) {
-			// This tuple did not meet the condition.
-			sel.Append(i);
-		}
-	}
-	combined_chunk.Slice(sel.Selection(), sel.Count());
-
-	// Verify and throw.
-	if (GLOBAL) {
-		data_table.VerifyAppendConstraints(constraint_state, context.client, combined_chunk, nullptr, nullptr);
-		throw InternalException("VerifyAppendConstraints was expected to throw but didn't");
-	}
-
-	auto &indexes = local_storage.GetIndexes(data_table);
-	auto storage = local_storage.GetStorage(data_table);
-	DataTable::VerifyUniqueIndexes(indexes, storage, tuples, nullptr);
-	throw InternalException("VerifyUniqueIndexes was expected to throw but didn't");
-}
-
-template <bool GLOBAL>
-static idx_t HandleInsertConflicts(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate,
-                                   DataChunk &tuples, const PhysicalInsert &op) {
-	auto &types_to_fetch = op.types_to_fetch;
-	auto &on_conflict_condition = op.on_conflict_condition;
-	auto &conflict_target = op.conflict_target;
-	auto &columns_to_fetch = op.columns_to_fetch;
-	auto &data_table = table.GetStorage();
-
-	auto &local_storage = LocalStorage::Get(context.client, data_table.db);
-
-	ConflictInfo conflict_info(conflict_target);
-	ConflictManager conflict_manager(VerifyExistenceType::APPEND, tuples.size(), &conflict_info);
-	if (GLOBAL) {
-		auto &constraint_state = lstate.GetConstraintState(data_table, table);
-		auto storage = local_storage.GetStorage(data_table);
-		data_table.VerifyAppendConstraints(constraint_state, context.client, tuples, storage, &conflict_manager);
-	} else {
-		auto &indexes = local_storage.GetIndexes(data_table);
-		auto storage = local_storage.GetStorage(data_table);
-		DataTable::VerifyUniqueIndexes(indexes, storage, tuples, &conflict_manager);
-	}
-
-	conflict_manager.Finalize();
-	if (conflict_manager.ConflictCount() == 0) {
-		// No conflicts found, 0 updates performed
-		return 0;
-	}
-	idx_t affected_tuples = 0;
-
-	auto &conflicts = conflict_manager.Conflicts();
-	auto &row_ids = conflict_manager.RowIds();
-
-	DataChunk conflict_chunk; // contains only the conflicting values
-	DataChunk scan_chunk;     // contains the original values, that caused the conflict
-	DataChunk combined_chunk; // contains conflict_chunk + scan_chunk (wide)
-
-	// Filter out everything but the conflicting rows
-	conflict_chunk.Initialize(context.client, tuples.GetTypes());
-	conflict_chunk.Reference(tuples);
-	conflict_chunk.Slice(conflicts.Selection(), conflicts.Count());
-	conflict_chunk.SetCardinality(conflicts.Count());
-
-	// Holds the pins for the fetched rows
-	unique_ptr<ColumnFetchState> fetch_state;
-	if (!types_to_fetch.empty()) {
-		D_ASSERT(scan_chunk.size() == 0);
-		// When these values are required for the conditions or the SET expressions,
-		// then we scan the existing table for the conflicting tuples, using the rowids
-		scan_chunk.Initialize(context.client, types_to_fetch);
-		fetch_state = make_uniq<ColumnFetchState>();
-		if (GLOBAL) {
-			auto &transaction = DuckTransaction::Get(context.client, table.catalog);
-			data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
-		} else {
-			local_storage.FetchChunk(data_table, row_ids, conflicts.Count(), columns_to_fetch, scan_chunk,
-			                         *fetch_state);
-		}
-	}
-
-	// Splice the Input chunk and the fetched chunk together
-	CombineExistingAndInsertTuples(combined_chunk, scan_chunk, conflict_chunk, context.client, op);
-
-	auto &constraint_state = lstate.GetConstraintState(data_table, table);
-	VerifyOnConflictCondition<GLOBAL>(context, combined_chunk, on_conflict_condition, constraint_state, tuples,
-	                                  data_table, local_storage);
-
-	if (&tuples == &lstate.update_chunk) {
-		// Allow updating duplicate rows for the 'update_chunk'
-		RegisterUpdatedRows(lstate, row_ids, combined_chunk.size());
-	}
-
-	affected_tuples += PerformOnConflictAction<GLOBAL>(lstate, context, combined_chunk, table, row_ids, op);
-
-	// Remove the conflicting tuples from the insert chunk
-	SelectionVector sel_vec(tuples.size());
-	idx_t new_size = SelectionVector::Inverted(conflicts.Selection(), sel_vec, conflicts.Count(), tuples.size());
-	tuples.Slice(sel_vec, new_size);
-	tuples.SetCardinality(new_size);
-	return affected_tuples;
-}
-
-idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertGlobalState &gstate,
-                                         InsertLocalState &lstate) const {
-	auto &data_table = table.GetStorage();
-	auto &local_storage = LocalStorage::Get(context.client, data_table.db);
-
-	if (action_type == OnConflictAction::THROW) {
-		auto &constraint_state = lstate.GetConstraintState(data_table, table);
-		auto storage = local_storage.GetStorage(data_table);
-		data_table.VerifyAppendConstraints(constraint_state, context.client, lstate.insert_chunk, storage, nullptr);
-		return 0;
-	}
-
-	ConflictInfo conflict_info(conflict_target);
-
-	auto &global_indexes = data_table.GetDataTableInfo()->GetIndexes();
-	auto &local_indexes = local_storage.GetIndexes(data_table);
-
-	unordered_set<BoundIndex *> matched_indexes;
-	if (conflict_info.column_ids.empty()) {
-		// We care about every index that applies to the table if no ON CONFLICT (...) target is given
-		global_indexes.Scan([&](Index &index) {
-			if (!index.IsUnique()) {
-				return false;
-			}
-			if (conflict_info.ConflictTargetMatches(index)) {
-				D_ASSERT(index.IsBound());
-				auto &bound_index = index.Cast<BoundIndex>();
-				matched_indexes.insert(&bound_index);
-			}
-			return false;
-		});
-		local_indexes.Scan([&](Index &index) {
-			if (!index.IsUnique()) {
-				return false;
-			}
-			if (conflict_info.ConflictTargetMatches(index)) {
-				D_ASSERT(index.IsBound());
-				auto &bound_index = index.Cast<BoundIndex>();
-				matched_indexes.insert(&bound_index);
-			}
-			return false;
-		});
-	}
-
-	auto inner_conflicts = CheckDistinctness(lstate.insert_chunk, conflict_info, matched_indexes);
-	idx_t count = lstate.insert_chunk.size();
-	if (!inner_conflicts.empty()) {
-		// We have at least one inner conflict, filter it out
-		ManagedSelection sel_vec(count);
-		ValidityMask not_a_conflict(count);
-		set<idx_t> last_occurrences_of_conflict;
-		for (idx_t i = 0; i < count; i++) {
-			auto it = inner_conflicts.find(i);
-			if (it != inner_conflicts.end()) {
-				auto &conflicts = it->second;
-				auto conflict_it = conflicts.begin();
-				for (; conflict_it != conflicts.end();) {
-					auto &idx = *conflict_it;
-					not_a_conflict.SetInvalid(idx);
-					conflict_it++;
-					if (conflict_it == conflicts.end()) {
-						last_occurrences_of_conflict.insert(idx);
-					}
-				}
-			}
-			if (not_a_conflict.RowIsValid(i)) {
-				sel_vec.Append(i);
-			}
-		}
-		if (action_type == OnConflictAction::UPDATE) {
-			ManagedSelection last_occurrences(last_occurrences_of_conflict.size());
-			for (auto &idx : last_occurrences_of_conflict) {
-				last_occurrences.Append(idx);
-			}
-
-			lstate.update_chunk.Reference(lstate.insert_chunk);
-			lstate.update_chunk.Slice(last_occurrences.Selection(), last_occurrences.Count());
-			lstate.update_chunk.SetCardinality(last_occurrences.Count());
-		}
-
-		lstate.insert_chunk.Slice(sel_vec.Selection(), sel_vec.Count());
-		lstate.insert_chunk.SetCardinality(sel_vec.Count());
-	}
-
-	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
-	// If that's not the case - We throw the first error
-	idx_t updated_tuples = 0;
-	updated_tuples += HandleInsertConflicts<true>(table, context, lstate, lstate.insert_chunk, *this);
-	// Also check the transaction-local storage+ART so we can detect conflicts within this transaction
-	updated_tuples += HandleInsertConflicts<false>(table, context, lstate, lstate.insert_chunk, *this);
-
-	return updated_tuples;
-}
-
-SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<InsertGlobalState>();
-	auto &lstate = input.local_state.Cast<InsertLocalState>();
-
-	auto &table = gstate.table;
-	auto &storage = table.GetStorage();
-	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
-
-	if (!parallel) {
-		if (!gstate.initialized) {
-			storage.InitializeLocalAppend(gstate.append_state, table, context.client, bound_constraints);
-			gstate.initialized = true;
-		}
-
-		if (action_type != OnConflictAction::NOTHING && return_chunk) {
-			// If the action is UPDATE or REPLACE, we will always create either an APPEND or an INSERT
-			// for NOTHING we don't create either an APPEND or an INSERT for the tuple
-			// so it should not be added to the RETURNING chunk
-			gstate.return_collection.Append(lstate.insert_chunk);
-		}
-		idx_t updated_tuples = OnConflictHandling(table, context, gstate, lstate);
-		if (action_type == OnConflictAction::NOTHING && return_chunk) {
-			// Because we didn't add to the RETURNING chunk yet
-			// we add the tuples that did not get filtered out now
-			gstate.return_collection.Append(lstate.insert_chunk);
-		}
-		gstate.insert_count += lstate.insert_chunk.size();
-		gstate.insert_count += updated_tuples;
-		storage.LocalAppend(gstate.append_state, context.client, lstate.insert_chunk, true);
-		if (action_type == OnConflictAction::UPDATE && lstate.update_chunk.size() != 0) {
-			// Flush the append so we can target the data we just appended with the update
-			storage.FinalizeLocalAppend(gstate.append_state);
-			gstate.initialized = false;
-			(void)HandleInsertConflicts<true>(table, context, lstate, lstate.update_chunk, *this);
-			(void)HandleInsertConflicts<false>(table, context, lstate, lstate.update_chunk, *this);
-			// All of the tuples should have been turned into an update, leaving the chunk empty afterwards
-			D_ASSERT(lstate.update_chunk.size() == 0);
-		}
-	} else {
-		D_ASSERT(!return_chunk);
-		// parallel append
-		if (!lstate.local_collection) {
-			lock_guard<mutex> l(gstate.lock);
-			auto table_info = storage.GetDataTableInfo();
-			auto &io_manager = TableIOManager::Get(table.GetStorage());
-			lstate.local_collection = make_uniq<RowGroupCollection>(std::move(table_info), io_manager, insert_types,
-			                                                        NumericCast<idx_t>(MAX_ROW_ID));
-			lstate.local_collection->InitializeEmpty();
-			lstate.local_collection->InitializeAppend(lstate.local_append_state);
-			lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client);
-		}
-		OnConflictHandling(table, context, gstate, lstate);
-		D_ASSERT(action_type != OnConflictAction::UPDATE);
-
-		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
-		if (new_row_group) {
-			lstate.writer->WriteNewRowGroup(*lstate.local_collection);
-		}
-	}
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalInsert::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &gstate = input.global_state.Cast<InsertGlobalState>();
-	auto &lstate = input.local_state.Cast<InsertLocalState>();
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-
-	if (!parallel || !lstate.local_collection) {
-		return SinkCombineResultType::FINISHED;
-	}
-
-	auto &table = gstate.table;
-	auto &storage = table.GetStorage();
-	const idx_t row_group_size = storage.GetRowGroupSize();
-
-	// parallel append: finalize the append
-	TransactionData tdata(0, 0);
-	lstate.local_collection->FinalizeAppend(tdata, lstate.local_append_state);
-
-	auto append_count = lstate.local_collection->GetTotalRows();
-
-	lock_guard<mutex> lock(gstate.lock);
-	gstate.insert_count += append_count;
-	if (append_count < row_group_size) {
-		// we have few rows - append to the local storage directly
-		storage.InitializeLocalAppend(gstate.append_state, table, context.client, bound_constraints);
-		auto &transaction = DuckTransaction::Get(context.client, table.catalog);
-		lstate.local_collection->Scan(transaction, [&](DataChunk &insert_chunk) {
-			storage.LocalAppend(gstate.append_state, context.client, insert_chunk, false);
-			return true;
-		});
-		storage.FinalizeLocalAppend(gstate.append_state);
-	} else {
-		// we have written rows to disk optimistically - merge directly into the transaction-local storage
-		lstate.writer->WriteLastRowGroup(*lstate.local_collection);
-		lstate.writer->FinalFlush();
-		gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection);
-		gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer);
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalInsert::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          OperatorSinkFinalizeInput &input) const {
-	auto &gstate = input.global_state.Cast<InsertGlobalState>();
-	if (!parallel && gstate.initialized) {
-		auto &table = gstate.table;
-		auto &storage = table.GetStorage();
-		storage.FinalizeLocalAppend(gstate.append_state);
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class InsertSourceState : public GlobalSourceState {
-public:
-	explicit InsertSourceState(const PhysicalInsert &op) {
-		if (op.return_chunk) {
-			D_ASSERT(op.sink_state);
-			auto &g = op.sink_state->Cast<InsertGlobalState>();
-			g.return_collection.InitializeScan(scan_state);
-		}
-	}
-
-	ColumnDataScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalInsert::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<InsertSourceState>(*this);
-}
-
-SourceResultType PhysicalInsert::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &state = input.global_state.Cast<InsertSourceState>();
-	auto &insert_gstate = sink_state->Cast<InsertGlobalState>();
-	if (!return_chunk) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(insert_gstate.insert_count)));
-		return SourceResultType::FINISHED;
-	}
-
-	insert_gstate.return_collection.Scan(state.scan_state, chunk);
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/persistent/physical_update.cpp b/src/duckdb/src/execution/operator/persistent/physical_update.cpp
deleted file mode 100644
index 88d30c5e6..000000000
--- a/src/duckdb/src/execution/operator/persistent/physical_update.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_update.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/delete_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/update_state.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-namespace duckdb {
-
-PhysicalUpdate::PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
-                               vector<PhysicalIndex> columns, vector<unique_ptr<Expression>> expressions,
-                               vector<unique_ptr<Expression>> bound_defaults,
-                               vector<unique_ptr<BoundConstraint>> bound_constraints, idx_t estimated_cardinality,
-                               bool return_chunk)
-    : PhysicalOperator(PhysicalOperatorType::UPDATE, std::move(types), estimated_cardinality), tableref(tableref),
-      table(table), columns(std::move(columns)), expressions(std::move(expressions)),
-      bound_defaults(std::move(bound_defaults)), bound_constraints(std::move(bound_constraints)),
-      return_chunk(return_chunk), index_update(false) {
-
-	auto &indexes = table.GetDataTableInfo().get()->GetIndexes();
-	auto index_columns = indexes.GetRequiredColumns();
-
-	unordered_set<column_t> update_columns;
-	for (const auto col : this->columns) {
-		update_columns.insert(col.index);
-	}
-
-	for (const auto &col : table.Columns()) {
-		if (index_columns.find(col.Logical().index) == index_columns.end()) {
-			continue;
-		}
-		if (update_columns.find(col.Physical().index) == update_columns.end()) {
-			continue;
-		}
-		index_update = true;
-		break;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class UpdateGlobalState : public GlobalSinkState {
-public:
-	explicit UpdateGlobalState(ClientContext &context, const vector<LogicalType> &return_types)
-	    : updated_count(0), return_collection(context, return_types) {
-	}
-
-	mutex lock;
-	idx_t updated_count;
-	unordered_set<row_t> updated_rows;
-	ColumnDataCollection return_collection;
-};
-
-class UpdateLocalState : public LocalSinkState {
-public:
-	UpdateLocalState(ClientContext &context, const vector<unique_ptr<Expression>> &expressions,
-	                 const vector<LogicalType> &table_types, const vector<unique_ptr<Expression>> &bound_defaults,
-	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints)
-	    : default_executor(context, bound_defaults), bound_constraints(bound_constraints) {
-
-		// Initialize the update chunk.
-		auto &allocator = Allocator::Get(context);
-		vector<LogicalType> update_types;
-		update_types.reserve(expressions.size());
-		for (auto &expr : expressions) {
-			update_types.push_back(expr->return_type);
-		}
-		update_chunk.Initialize(allocator, update_types);
-
-		// Initialize the mock and delete chunk.
-		mock_chunk.Initialize(allocator, table_types);
-		delete_chunk.Initialize(allocator, table_types);
-	}
-
-	DataChunk update_chunk;
-	DataChunk mock_chunk;
-	DataChunk delete_chunk;
-	ExpressionExecutor default_executor;
-	unique_ptr<TableDeleteState> delete_state;
-	unique_ptr<TableUpdateState> update_state;
-	const vector<unique_ptr<BoundConstraint>> &bound_constraints;
-
-	TableDeleteState &GetDeleteState(DataTable &table, TableCatalogEntry &tableref, ClientContext &context) {
-		if (!delete_state) {
-			delete_state = table.InitializeDelete(tableref, context, bound_constraints);
-		}
-		return *delete_state;
-	}
-
-	TableUpdateState &GetUpdateState(DataTable &table, TableCatalogEntry &tableref, ClientContext &context) {
-		if (!update_state) {
-			update_state = table.InitializeUpdate(tableref, context, bound_constraints);
-		}
-		return *update_state;
-	}
-};
-
-SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &g_state = input.global_state.Cast<UpdateGlobalState>();
-	auto &l_state = input.local_state.Cast<UpdateLocalState>();
-
-	chunk.Flatten();
-	l_state.default_executor.SetChunk(chunk);
-
-	DataChunk &update_chunk = l_state.update_chunk;
-	update_chunk.Reset();
-	update_chunk.SetCardinality(chunk);
-
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		// Default expression, set to the default value of the column.
-		if (expressions[i]->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-			l_state.default_executor.ExecuteExpression(columns[i].index, update_chunk.data[i]);
-			continue;
-		}
-
-		D_ASSERT(expressions[i]->GetExpressionType() == ExpressionType::BOUND_REF);
-		auto &binding = expressions[i]->Cast<BoundReferenceExpression>();
-		update_chunk.data[i].Reference(chunk.data[binding.index]);
-	}
-
-	lock_guard<mutex> glock(g_state.lock);
-	auto &row_ids = chunk.data[chunk.ColumnCount() - 1];
-	DataChunk &mock_chunk = l_state.mock_chunk;
-
-	// Regular in-place update.
-	if (!update_is_del_and_insert) {
-		if (return_chunk) {
-			mock_chunk.SetCardinality(update_chunk);
-			for (idx_t i = 0; i < columns.size(); i++) {
-				mock_chunk.data[columns[i].index].Reference(update_chunk.data[i]);
-			}
-		}
-		auto &update_state = l_state.GetUpdateState(table, tableref, context.client);
-		table.Update(update_state, context.client, row_ids, columns, update_chunk);
-
-		if (return_chunk) {
-			g_state.return_collection.Append(mock_chunk);
-		}
-		g_state.updated_count += chunk.size();
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	// We update an index or a complex type, so we need to split the UPDATE into DELETE + INSERT.
-
-	// Keep track of the rows that have not yet been deleted in this UPDATE.
-	// This is required since we might see the same row_id multiple times, e.g.,
-	// during an UPDATE containing joins.
-	SelectionVector sel(update_chunk.size());
-	idx_t update_count = 0;
-	auto row_id_data = FlatVector::GetData<row_t>(row_ids);
-
-	for (idx_t i = 0; i < update_chunk.size(); i++) {
-		auto row_id = row_id_data[i];
-		if (g_state.updated_rows.find(row_id) == g_state.updated_rows.end()) {
-			g_state.updated_rows.insert(row_id);
-			sel.set_index(update_count++, i);
-		}
-	}
-
-	// The update chunk now contains exactly those rows that we are deleting.
-	Vector del_row_ids(row_ids);
-	if (update_count != update_chunk.size()) {
-		update_chunk.Slice(sel, update_count);
-		del_row_ids.Slice(row_ids, sel, update_count);
-	}
-
-	auto &delete_chunk = index_update ? l_state.delete_chunk : l_state.mock_chunk;
-	delete_chunk.Reset();
-	delete_chunk.SetCardinality(update_count);
-
-	if (index_update) {
-		auto &transaction = DuckTransaction::Get(context.client, table.db);
-		vector<StorageIndex> column_ids;
-		for (idx_t i = 0; i < table.ColumnCount(); i++) {
-			column_ids.emplace_back(i);
-		};
-		// We need to fetch the previous index keys to add them to the delete index.
-		auto fetch_state = ColumnFetchState();
-		table.Fetch(transaction, delete_chunk, column_ids, row_ids, update_count, fetch_state);
-	}
-
-	auto &delete_state = l_state.GetDeleteState(table, tableref, context.client);
-	table.Delete(delete_state, context.client, del_row_ids, update_count);
-
-	// Arrange the columns in the standard table order.
-	mock_chunk.SetCardinality(update_count);
-	for (idx_t i = 0; i < columns.size(); i++) {
-		mock_chunk.data[columns[i].index].Reference(update_chunk.data[i]);
-	}
-
-	table.LocalAppend(tableref, context.client, mock_chunk, bound_constraints, del_row_ids, delete_chunk);
-	if (return_chunk) {
-		g_state.return_collection.Append(mock_chunk);
-	}
-
-	g_state.updated_count += chunk.size();
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<GlobalSinkState> PhysicalUpdate::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<UpdateGlobalState>(context, GetTypes());
-}
-
-unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<UpdateLocalState>(context.client, expressions, table.GetTypes(), bound_defaults,
-	                                   bound_constraints);
-}
-
-SinkCombineResultType PhysicalUpdate::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this);
-	client_profiler.Flush(context.thread.profiler);
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class UpdateSourceState : public GlobalSourceState {
-public:
-	explicit UpdateSourceState(const PhysicalUpdate &op) {
-		if (op.return_chunk) {
-			D_ASSERT(op.sink_state);
-			auto &g = op.sink_state->Cast<UpdateGlobalState>();
-			g.return_collection.InitializeScan(scan_state);
-		}
-	}
-
-	ColumnDataScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalUpdate::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<UpdateSourceState>(*this);
-}
-
-SourceResultType PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &state = input.global_state.Cast<UpdateSourceState>();
-	auto &g = sink_state->Cast<UpdateGlobalState>();
-	if (!return_chunk) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.updated_count)));
-		return SourceResultType::FINISHED;
-	}
-
-	g.return_collection.Scan(state.scan_state, chunk);
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/projection/physical_pivot.cpp b/src/duckdb/src/execution/operator/projection/physical_pivot.cpp
deleted file mode 100644
index d3def4c0c..000000000
--- a/src/duckdb/src/execution/operator/projection/physical_pivot.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_pivot.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-PhysicalPivot::PhysicalPivot(vector<LogicalType> types_p, unique_ptr<PhysicalOperator> child,
-                             BoundPivotInfo bound_pivot_p)
-    : PhysicalOperator(PhysicalOperatorType::PIVOT, std::move(types_p), child->estimated_cardinality),
-      bound_pivot(std::move(bound_pivot_p)) {
-	children.push_back(std::move(child));
-	for (idx_t p = 0; p < bound_pivot.pivot_values.size(); p++) {
-		auto entry = pivot_map.find(bound_pivot.pivot_values[p]);
-		if (entry != pivot_map.end()) {
-			continue;
-		}
-		pivot_map[bound_pivot.pivot_values[p]] = bound_pivot.group_count + p;
-	}
-	// extract the empty aggregate expressions
-	ArenaAllocator allocator(Allocator::DefaultAllocator());
-	for (auto &aggr_expr : bound_pivot.aggregates) {
-		auto &aggr = aggr_expr->Cast<BoundAggregateExpression>();
-		// for each aggregate, initialize an empty aggregate state and finalize it immediately
-		auto state = make_unsafe_uniq_array<data_t>(aggr.function.state_size(aggr.function));
-		aggr.function.initialize(aggr.function, state.get());
-		Vector state_vector(Value::POINTER(CastPointerToValue(state.get())));
-		Vector result_vector(aggr_expr->return_type);
-		AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
-		aggr.function.finalize(state_vector, aggr_input_data, result_vector, 1, 0);
-		empty_aggregates.push_back(result_vector.GetValue(0));
-	}
-}
-
-OperatorResultType PhysicalPivot::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                          GlobalOperatorState &gstate, OperatorState &state) const {
-	// copy the groups as-is
-	input.Flatten();
-	for (idx_t i = 0; i < bound_pivot.group_count; i++) {
-		chunk.data[i].Reference(input.data[i]);
-	}
-	auto pivot_column_lists = FlatVector::GetData<list_entry_t>(input.data.back());
-	auto &pivot_column_values = ListVector::GetEntry(input.data.back());
-	auto pivot_columns = FlatVector::GetData<string_t>(pivot_column_values);
-
-	// initialize all aggregate columns with the empty aggregate value
-	// if there are multiple aggregates the columns are in order of [AGGR1][AGGR2][AGGR1][AGGR2]
-	// so we need to alternate the empty_aggregate that we use
-	idx_t aggregate = 0;
-	for (idx_t c = bound_pivot.group_count; c < chunk.ColumnCount(); c++) {
-		chunk.data[c].Reference(empty_aggregates[aggregate]);
-		chunk.data[c].Flatten(input.size());
-		aggregate++;
-		if (aggregate >= empty_aggregates.size()) {
-			aggregate = 0;
-		}
-	}
-
-	// move the pivots to the given columns
-	for (idx_t r = 0; r < input.size(); r++) {
-		auto list = pivot_column_lists[r];
-		for (idx_t l = 0; l < list.length; l++) {
-			// figure out the column value number of this list
-			auto &column_name = pivot_columns[list.offset + l];
-			auto entry = pivot_map.find(column_name);
-			if (entry == pivot_map.end()) {
-				// column entry not found in map - that means this element is explicitly excluded from the pivot list
-				continue;
-			}
-			auto column_idx = entry->second;
-			for (idx_t aggr = 0; aggr < empty_aggregates.size(); aggr++) {
-				auto pivot_value_lists = FlatVector::GetData<list_entry_t>(input.data[bound_pivot.group_count + aggr]);
-				auto &pivot_value_child = ListVector::GetEntry(input.data[bound_pivot.group_count + aggr]);
-				if (list.length != pivot_value_lists[r].length) {
-					throw InternalException("Pivot - unaligned lists between values and columns!?");
-				}
-				chunk.data[column_idx + aggr].SetValue(r, pivot_value_child.GetValue(pivot_value_lists[r].offset + l));
-			}
-		}
-	}
-	chunk.SetCardinality(input.size());
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/projection/physical_projection.cpp b/src/duckdb/src/execution/operator/projection/physical_projection.cpp
deleted file mode 100644
index 5d6dcb13f..000000000
--- a/src/duckdb/src/execution/operator/projection/physical_projection.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-namespace duckdb {
-
-class ProjectionState : public OperatorState {
-public:
-	explicit ProjectionState(ExecutionContext &context, const vector<unique_ptr<Expression>> &expressions)
-	    : executor(context.client, expressions) {
-	}
-
-	ExpressionExecutor executor;
-
-public:
-	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op);
-	}
-};
-
-PhysicalProjection::PhysicalProjection(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                                       idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::PROJECTION, std::move(types), estimated_cardinality),
-      select_list(std::move(select_list)) {
-}
-
-OperatorResultType PhysicalProjection::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                               GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = state_p.Cast<ProjectionState>();
-	state.executor.Execute(input, chunk);
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<OperatorState> PhysicalProjection::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<ProjectionState>(context, select_list);
-}
-
-unique_ptr<PhysicalOperator>
-PhysicalProjection::CreateJoinProjection(vector<LogicalType> proj_types, const vector<LogicalType> &lhs_types,
-                                         const vector<LogicalType> &rhs_types, const vector<idx_t> &left_projection_map,
-                                         const vector<idx_t> &right_projection_map, const idx_t estimated_cardinality) {
-
-	vector<unique_ptr<Expression>> proj_selects;
-	proj_selects.reserve(proj_types.size());
-
-	if (left_projection_map.empty()) {
-		for (storage_t i = 0; i < lhs_types.size(); ++i) {
-			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(lhs_types[i], i));
-		}
-	} else {
-		for (auto i : left_projection_map) {
-			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(lhs_types[i], i));
-		}
-	}
-	const auto left_cols = lhs_types.size();
-
-	if (right_projection_map.empty()) {
-		for (storage_t i = 0; i < rhs_types.size(); ++i) {
-			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(rhs_types[i], left_cols + i));
-		}
-
-	} else {
-		for (auto i : right_projection_map) {
-			proj_selects.emplace_back(make_uniq<BoundReferenceExpression>(rhs_types[i], left_cols + i));
-		}
-	}
-
-	return make_uniq<PhysicalProjection>(std::move(proj_types), std::move(proj_selects), estimated_cardinality);
-}
-
-InsertionOrderPreservingMap<string> PhysicalProjection::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string projections;
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			projections += "\n";
-		}
-		auto &expr = select_list[i];
-		projections += expr->GetName();
-	}
-	result["__projections__"] = projections;
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp b/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp
deleted file mode 100644
index fa150693e..000000000
--- a/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_tableinout_function.hpp"
-
-namespace duckdb {
-
-class TableInOutLocalState : public OperatorState {
-public:
-	TableInOutLocalState() : row_index(0), new_row(true) {
-	}
-
-	unique_ptr<LocalTableFunctionState> local_state;
-	idx_t row_index;
-	bool new_row;
-	DataChunk input_chunk;
-};
-
-class TableInOutGlobalState : public GlobalOperatorState {
-public:
-	TableInOutGlobalState() {
-	}
-
-	unique_ptr<GlobalTableFunctionState> global_state;
-};
-
-PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
-                                                       unique_ptr<FunctionData> bind_data_p,
-                                                       vector<ColumnIndex> column_ids_p, idx_t estimated_cardinality,
-                                                       vector<column_t> project_input_p)
-    : PhysicalOperator(PhysicalOperatorType::INOUT_FUNCTION, std::move(types), estimated_cardinality),
-      function(std::move(function_p)), bind_data(std::move(bind_data_p)), column_ids(std::move(column_ids_p)),
-      projected_input(std::move(project_input_p)) {
-}
-
-unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ExecutionContext &context) const {
-	auto &gstate = op_state->Cast<TableInOutGlobalState>();
-	auto result = make_uniq<TableInOutLocalState>();
-	if (function.init_local) {
-		TableFunctionInitInput input(bind_data.get(), column_ids, vector<idx_t>(), nullptr);
-		result->local_state = function.init_local(context, input, gstate.global_state.get());
-	}
-	if (!projected_input.empty()) {
-		vector<LogicalType> input_types;
-		auto &child_types = children[0]->types;
-		idx_t input_length = child_types.size() - projected_input.size();
-		for (idx_t k = 0; k < input_length; k++) {
-			input_types.push_back(child_types[k]);
-		}
-		for (idx_t k = 0; k < projected_input.size(); k++) {
-			D_ASSERT(projected_input[k] >= input_length);
-		}
-		result->input_chunk.Initialize(context.client, input_types);
-	}
-	return std::move(result);
-}
-
-unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorState(ClientContext &context) const {
-	auto result = make_uniq<TableInOutGlobalState>();
-	if (function.init_global) {
-		TableFunctionInitInput input(bind_data.get(), column_ids, vector<idx_t>(), nullptr);
-		result->global_state = function.init_global(context, input);
-	}
-	return std::move(result);
-}
-
-OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                       GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = gstate_p.Cast<TableInOutGlobalState>();
-	auto &state = state_p.Cast<TableInOutLocalState>();
-	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
-	if (projected_input.empty()) {
-		// straightforward case - no need to project input
-		return function.in_out_function(context, data, input, chunk);
-	}
-	// when project_input is set we execute the input function row-by-row
-	if (state.new_row) {
-		if (state.row_index >= input.size()) {
-			// finished processing this chunk
-			state.new_row = true;
-			state.row_index = 0;
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-		// we are processing a new row: fetch the data for the current row
-		state.input_chunk.Reset();
-		// set up the input data to the table in-out function
-		for (idx_t col_idx = 0; col_idx < state.input_chunk.ColumnCount(); col_idx++) {
-			ConstantVector::Reference(state.input_chunk.data[col_idx], input.data[col_idx], state.row_index, 1);
-		}
-		state.input_chunk.SetCardinality(1);
-		state.row_index++;
-		state.new_row = false;
-	}
-	// set up the output data in "chunk"
-	D_ASSERT(chunk.ColumnCount() > projected_input.size());
-	D_ASSERT(state.row_index > 0);
-	idx_t base_idx = chunk.ColumnCount() - projected_input.size();
-	for (idx_t project_idx = 0; project_idx < projected_input.size(); project_idx++) {
-		auto source_idx = projected_input[project_idx];
-		auto target_idx = base_idx + project_idx;
-		ConstantVector::Reference(chunk.data[target_idx], input.data[source_idx], state.row_index - 1, 1);
-	}
-	auto result = function.in_out_function(context, data, state.input_chunk, chunk);
-	if (result == OperatorResultType::FINISHED) {
-		return result;
-	}
-	if (result == OperatorResultType::NEED_MORE_INPUT) {
-		// we finished processing this row: move to the next row
-		state.new_row = true;
-	}
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-InsertionOrderPreservingMap<string> PhysicalTableInOutFunction::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	if (function.to_string) {
-		TableFunctionToStringInput input(function, bind_data.get());
-		auto to_string_result = function.to_string(input);
-		for (const auto &it : to_string_result) {
-			result[it.first] = it.second;
-		}
-	} else {
-		result["Name"] = function.name;
-	}
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-OperatorFinalizeResultType PhysicalTableInOutFunction::FinalExecute(ExecutionContext &context, DataChunk &chunk,
-                                                                    GlobalOperatorState &gstate_p,
-                                                                    OperatorState &state_p) const {
-	auto &gstate = gstate_p.Cast<TableInOutGlobalState>();
-	auto &state = state_p.Cast<TableInOutLocalState>();
-	if (!projected_input.empty()) {
-		throw InternalException("FinalExecute not supported for project_input");
-	}
-	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
-	return function.in_out_function_final(context, data, chunk);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/projection/physical_unnest.cpp b/src/duckdb/src/execution/operator/projection/physical_unnest.cpp
deleted file mode 100644
index 4f32fd291..000000000
--- a/src/duckdb/src/execution/operator/projection/physical_unnest.cpp
+++ /dev/null
@@ -1,387 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_unnest.hpp"
-
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-
-namespace duckdb {
-
-class UnnestOperatorState : public OperatorState {
-public:
-	UnnestOperatorState(ClientContext &context, const vector<unique_ptr<Expression>> &select_list)
-	    : current_row(0), list_position(0), longest_list_length(DConstants::INVALID_INDEX), first_fetch(true),
-	      executor(context) {
-
-		// for each UNNEST in the select_list, we add the child expression to the expression executor
-		// and set the return type in the list_data chunk, which will contain the evaluated expression results
-		vector<LogicalType> list_data_types;
-		for (auto &exp : select_list) {
-			D_ASSERT(exp->GetExpressionType() == ExpressionType::BOUND_UNNEST);
-			auto &bue = exp->Cast<BoundUnnestExpression>();
-			list_data_types.push_back(bue.child->return_type);
-			executor.AddExpression(*bue.child.get());
-		}
-
-		auto &allocator = Allocator::Get(context);
-		list_data.Initialize(allocator, list_data_types);
-
-		list_vector_data.resize(list_data.ColumnCount());
-		list_child_data.resize(list_data.ColumnCount());
-	}
-
-	idx_t current_row;
-	idx_t list_position;
-	idx_t longest_list_length;
-	bool first_fetch;
-
-	ExpressionExecutor executor;
-	DataChunk list_data;
-	vector<UnifiedVectorFormat> list_vector_data;
-	vector<UnifiedVectorFormat> list_child_data;
-
-public:
-	//! Reset the fields of the unnest operator state
-	void Reset();
-	//! Set the longest list's length for the current row
-	void SetLongestListLength();
-};
-
-void UnnestOperatorState::Reset() {
-	current_row = 0;
-	list_position = 0;
-	longest_list_length = DConstants::INVALID_INDEX;
-	first_fetch = true;
-}
-
-void UnnestOperatorState::SetLongestListLength() {
-	longest_list_length = 0;
-	for (idx_t col_idx = 0; col_idx < list_data.ColumnCount(); col_idx++) {
-
-		auto &vector_data = list_vector_data[col_idx];
-		auto current_idx = vector_data.sel->get_index(current_row);
-
-		if (vector_data.validity.RowIsValid(current_idx)) {
-
-			// check if this list is longer
-			auto list_data_entries = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
-			auto list_entry = list_data_entries[current_idx];
-			if (list_entry.length > longest_list_length) {
-				longest_list_length = list_entry.length;
-			}
-		}
-	}
-}
-
-PhysicalUnnest::PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                               idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list)) {
-	D_ASSERT(!this->select_list.empty());
-}
-
-static void UnnestNull(idx_t start, idx_t end, Vector &result) {
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto &validity = FlatVector::Validity(result);
-	for (idx_t i = start; i < end; i++) {
-		validity.SetInvalid(i);
-	}
-
-	const auto &logical_type = result.GetType();
-	if (logical_type.InternalType() == PhysicalType::STRUCT) {
-		const auto &struct_children = StructVector::GetEntries(result);
-		for (auto &child : struct_children) {
-			UnnestNull(start, end, *child);
-		}
-	} else if (logical_type.InternalType() == PhysicalType::ARRAY) {
-		auto &array_child = ArrayVector::GetEntry(result);
-		auto array_size = ArrayType::GetSize(logical_type);
-		UnnestNull(start * array_size, end * array_size, array_child);
-	}
-}
-
-template <class T>
-static void TemplatedUnnest(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
-
-	auto source_data = UnifiedVectorFormat::GetData<T>(vector_data);
-	auto &source_mask = vector_data.validity;
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<T>(result);
-	auto &result_mask = FlatVector::Validity(result);
-
-	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vector_data.sel->get_index(i);
-		auto target_idx = i - start;
-		if (source_mask.RowIsValid(source_idx)) {
-			result_data[target_idx] = source_data[source_idx];
-			result_mask.SetValid(target_idx);
-		} else {
-			result_mask.SetInvalid(target_idx);
-		}
-	}
-}
-
-static void UnnestValidity(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
-
-	auto &source_mask = vector_data.validity;
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto &result_mask = FlatVector::Validity(result);
-
-	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vector_data.sel->get_index(i);
-		auto target_idx = i - start;
-		result_mask.Set(target_idx, source_mask.RowIsValid(source_idx));
-	}
-}
-
-static void UnnestVector(UnifiedVectorFormat &child_vector_data, Vector &child_vector, idx_t list_size, idx_t start,
-                         idx_t end, Vector &result) {
-
-	D_ASSERT(child_vector.GetType() == result.GetType());
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedUnnest<int8_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::INT16:
-		TemplatedUnnest<int16_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::INT32:
-		TemplatedUnnest<int32_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::INT64:
-		TemplatedUnnest<int64_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::INT128:
-		TemplatedUnnest<hugeint_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedUnnest<uint8_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedUnnest<uint16_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedUnnest<uint32_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedUnnest<uint64_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedUnnest<uhugeint_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedUnnest<float>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedUnnest<double>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedUnnest<interval_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedUnnest<string_t>(child_vector_data, start, end, result);
-		break;
-	case PhysicalType::LIST: {
-		// the child vector of result now references the child vector source
-		// FIXME: only reference relevant children (start - end) instead of all
-		auto &target = ListVector::GetEntry(result);
-		target.Reference(ListVector::GetEntry(child_vector));
-		ListVector::SetListSize(result, ListVector::GetListSize(child_vector));
-		// unnest
-		TemplatedUnnest<list_entry_t>(child_vector_data, start, end, result);
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		auto &child_vector_entries = StructVector::GetEntries(child_vector);
-		auto &result_entries = StructVector::GetEntries(result);
-
-		// set the validity mask for the 'outer' struct vector before unnesting its children
-		UnnestValidity(child_vector_data, start, end, result);
-
-		for (idx_t i = 0; i < child_vector_entries.size(); i++) {
-			UnifiedVectorFormat child_vector_entries_data;
-			child_vector_entries[i]->ToUnifiedFormat(list_size, child_vector_entries_data);
-			UnnestVector(child_vector_entries_data, *child_vector_entries[i], list_size, start, end,
-			             *result_entries[i]);
-		}
-		break;
-	}
-	case PhysicalType::ARRAY: {
-		auto array_size = ArrayType::GetSize(child_vector.GetType());
-		auto &source_array = ArrayVector::GetEntry(child_vector);
-		auto &target_array = ArrayVector::GetEntry(result);
-
-		UnnestValidity(child_vector_data, start, end, result);
-
-		UnifiedVectorFormat child_array_data;
-		source_array.ToUnifiedFormat(list_size * array_size, child_array_data);
-		UnnestVector(child_array_data, source_array, list_size * array_size, start * array_size, end * array_size,
-		             target_array);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for UNNEST.");
-	}
-}
-
-static void PrepareInput(UnnestOperatorState &state, DataChunk &input,
-                         const vector<unique_ptr<Expression>> &select_list) {
-
-	state.list_data.Reset();
-	// execute the expressions inside each UNNEST in the select_list to get the list data
-	// execution results (lists) are kept in state.list_data chunk
-	state.executor.Execute(input, state.list_data);
-
-	// verify incoming lists
-	state.list_data.Verify();
-	D_ASSERT(input.size() == state.list_data.size());
-	D_ASSERT(state.list_data.ColumnCount() == select_list.size());
-	D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
-	D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
-
-	// get the UnifiedVectorFormat of each list_data vector (LIST vectors for the different UNNESTs)
-	// both for the vector itself and its child vector
-	for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-
-		auto &list_vector = state.list_data.data[col_idx];
-		list_vector.ToUnifiedFormat(state.list_data.size(), state.list_vector_data[col_idx]);
-
-		if (list_vector.GetType() == LogicalType::SQLNULL) {
-			// UNNEST(NULL): SQLNULL vectors don't have child vectors, but we need to point to the child vector of
-			// each vector, so we just get the UnifiedVectorFormat of the vector itself
-			auto &child_vector = list_vector;
-			child_vector.ToUnifiedFormat(0, state.list_child_data[col_idx]);
-		} else {
-			auto list_size = ListVector::GetListSize(list_vector);
-			auto &child_vector = ListVector::GetEntry(list_vector);
-			child_vector.ToUnifiedFormat(list_size, state.list_child_data[col_idx]);
-		}
-	}
-
-	state.first_fetch = false;
-}
-
-unique_ptr<OperatorState> PhysicalUnnest::GetOperatorState(ExecutionContext &context) const {
-	return PhysicalUnnest::GetState(context, select_list);
-}
-
-unique_ptr<OperatorState> PhysicalUnnest::GetState(ExecutionContext &context,
-                                                   const vector<unique_ptr<Expression>> &select_list) {
-	return make_uniq<UnnestOperatorState>(context.client, select_list);
-}
-
-OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   OperatorState &state_p,
-                                                   const vector<unique_ptr<Expression>> &select_list,
-                                                   bool include_input) {
-
-	auto &state = state_p.Cast<UnnestOperatorState>();
-
-	do {
-		// reset validities, if previous loop iteration contained UNNEST(NULL)
-		if (include_input) {
-			chunk.Reset();
-		}
-
-		// prepare the input data by executing any expressions and getting the
-		// UnifiedVectorFormat of each LIST vector (list_vector_data) and its child vector (list_child_data)
-		if (state.first_fetch) {
-			PrepareInput(state, input, select_list);
-		}
-
-		// finished with all rows of this input chunk, reset
-		if (state.current_row >= input.size()) {
-			state.Reset();
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-
-		// each UNNEST in the select_list contains a list (or NULL) for this row, find the longest list
-		// because this length determines how many times we need to repeat for the current row
-		if (state.longest_list_length == DConstants::INVALID_INDEX) {
-			state.SetLongestListLength();
-		}
-		D_ASSERT(state.longest_list_length != DConstants::INVALID_INDEX);
-
-		// we emit chunks of either STANDARD_VECTOR_SIZE or smaller
-		auto this_chunk_len = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.longest_list_length - state.list_position);
-		chunk.SetCardinality(this_chunk_len);
-
-		// if we include other projection input columns, e.g. SELECT 1, UNNEST([1, 2]);, then
-		// we need to add them as a constant vector to the resulting chunk
-		// FIXME: emit multiple unnested rows. Currently, we never emit a chunk containing multiple unnested input rows,
-		//  so setting a constant vector for the value at state.current_row is fine
-		idx_t col_offset = 0;
-		if (include_input) {
-			for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.current_row, input.size());
-			}
-			col_offset = input.ColumnCount();
-		}
-
-		// unnest the lists
-		for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-
-			auto &result_vector = chunk.data[col_idx + col_offset];
-
-			if (state.list_data.data[col_idx].GetType() == LogicalType::SQLNULL) {
-				// UNNEST(NULL)
-				chunk.SetCardinality(0);
-				break;
-			}
-
-			auto &vector_data = state.list_vector_data[col_idx];
-			auto current_idx = vector_data.sel->get_index(state.current_row);
-
-			if (!vector_data.validity.RowIsValid(current_idx)) {
-				UnnestNull(0, this_chunk_len, result_vector);
-				continue;
-			}
-
-			auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
-			auto list_entry = list_data[current_idx];
-
-			idx_t list_count = 0;
-			if (state.list_position < list_entry.length) {
-				// there are still list_count elements to unnest
-				list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
-
-				auto &list_vector = state.list_data.data[col_idx];
-				auto &child_vector = ListVector::GetEntry(list_vector);
-				auto list_size = ListVector::GetListSize(list_vector);
-				auto &child_vector_data = state.list_child_data[col_idx];
-
-				auto base_offset = list_entry.offset + state.list_position;
-				UnnestVector(child_vector_data, child_vector, list_size, base_offset, base_offset + list_count,
-				             result_vector);
-			}
-
-			// fill the rest with NULLs
-			if (list_count != this_chunk_len) {
-				UnnestNull(list_count, this_chunk_len, result_vector);
-			}
-		}
-
-		chunk.Verify();
-
-		state.list_position += this_chunk_len;
-		if (state.list_position == state.longest_list_length) {
-			state.current_row++;
-			state.longest_list_length = DConstants::INVALID_INDEX;
-			state.list_position = 0;
-		}
-
-		// we only emit one unnested row (that contains data) at a time
-	} while (chunk.size() == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &, OperatorState &state) const {
-	return ExecuteInternal(context, input, chunk, state, select_list);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/scan/physical_column_data_scan.cpp b/src/duckdb/src/execution/operator/scan/physical_column_data_scan.cpp
deleted file mode 100644
index e864f3a2e..000000000
--- a/src/duckdb/src/execution/operator/scan/physical_column_data_scan.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-PhysicalColumnDataScan::PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type,
-                                               idx_t estimated_cardinality,
-                                               optionally_owned_ptr<ColumnDataCollection> collection_p)
-    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(std::move(collection_p)),
-      cte_index(DConstants::INVALID_INDEX) {
-}
-
-PhysicalColumnDataScan::PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type,
-                                               idx_t estimated_cardinality, idx_t cte_index)
-    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(nullptr), cte_index(cte_index) {
-}
-
-class PhysicalColumnDataGlobalScanState : public GlobalSourceState {
-public:
-	explicit PhysicalColumnDataGlobalScanState(const ColumnDataCollection &collection)
-	    : max_threads(MaxValue<idx_t>(collection.ChunkCount(), 1)) {
-		collection.InitializeScan(global_scan_state);
-	}
-
-	idx_t MaxThreads() override {
-		return max_threads;
-	}
-
-public:
-	ColumnDataParallelScanState global_scan_state;
-
-	const idx_t max_threads;
-};
-
-class PhysicalColumnDataLocalScanState : public LocalSourceState {
-public:
-	ColumnDataLocalScanState local_scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalColumnDataScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<PhysicalColumnDataGlobalScanState>(*collection);
-}
-
-unique_ptr<LocalSourceState> PhysicalColumnDataScan::GetLocalSourceState(ExecutionContext &,
-                                                                         GlobalSourceState &) const {
-	return make_uniq<PhysicalColumnDataLocalScanState>();
-}
-
-SourceResultType PhysicalColumnDataScan::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                 OperatorSourceInput &input) const {
-	auto &gstate = input.global_state.Cast<PhysicalColumnDataGlobalScanState>();
-	auto &lstate = input.local_state.Cast<PhysicalColumnDataLocalScanState>();
-	collection->Scan(gstate.global_scan_state, lstate.local_scan_state, chunk);
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalColumnDataScan::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	// check if there is any additional action we need to do depending on the type
-	auto &state = meta_pipeline.GetState();
-	switch (type) {
-	case PhysicalOperatorType::DELIM_SCAN: {
-		auto entry = state.delim_join_dependencies.find(*this);
-		D_ASSERT(entry != state.delim_join_dependencies.end());
-		// this chunk scan introduces a dependency to the current pipeline
-		// namely a dependency on the duplicate elimination pipeline to finish
-		auto delim_dependency = entry->second.get().shared_from_this();
-		auto delim_sink = state.GetPipelineSink(*delim_dependency);
-		D_ASSERT(delim_sink);
-		D_ASSERT(delim_sink->type == PhysicalOperatorType::LEFT_DELIM_JOIN ||
-		         delim_sink->type == PhysicalOperatorType::RIGHT_DELIM_JOIN);
-		auto &delim_join = delim_sink->Cast<PhysicalDelimJoin>();
-		current.AddDependency(delim_dependency);
-		state.SetPipelineSource(current, delim_join.distinct->Cast<PhysicalOperator>());
-		return;
-	}
-	case PhysicalOperatorType::CTE_SCAN: {
-		auto entry = state.cte_dependencies.find(*this);
-		D_ASSERT(entry != state.cte_dependencies.end());
-		// this chunk scan introduces a dependency to the current pipeline
-		// namely a dependency on the CTE pipeline to finish
-		auto cte_dependency = entry->second.get().shared_from_this();
-		auto cte_sink = state.GetPipelineSink(*cte_dependency);
-		(void)cte_sink;
-		D_ASSERT(cte_sink);
-		D_ASSERT(cte_sink->type == PhysicalOperatorType::CTE);
-		current.AddDependency(cte_dependency);
-		state.SetPipelineSource(current, *this);
-		return;
-	}
-	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
-		if (!meta_pipeline.HasRecursiveCTE()) {
-			throw InternalException("Recursive CTE scan found without recursive CTE node");
-		}
-		break;
-	default:
-		break;
-	}
-	D_ASSERT(children.empty());
-	state.SetPipelineSource(current, *this);
-}
-
-InsertionOrderPreservingMap<string> PhysicalColumnDataScan::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	switch (type) {
-	case PhysicalOperatorType::DELIM_SCAN:
-		if (delim_index.IsValid()) {
-			result["Delim Index"] = StringUtil::Format("%llu", delim_index.GetIndex());
-		}
-		break;
-	case PhysicalOperatorType::CTE_SCAN:
-	case PhysicalOperatorType::RECURSIVE_CTE_SCAN: {
-		result["CTE Index"] = StringUtil::Format("%llu", cte_index);
-		break;
-	}
-	default:
-		break;
-	}
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/scan/physical_dummy_scan.cpp b/src/duckdb/src/execution/operator/scan/physical_dummy_scan.cpp
deleted file mode 100644
index 1a620803b..000000000
--- a/src/duckdb/src/execution/operator/scan/physical_dummy_scan.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_dummy_scan.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalDummyScan::GetData(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSourceInput &input) const {
-	// return a single row on the first call to the dummy scan
-	chunk.SetCardinality(1);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/scan/physical_empty_result.cpp b/src/duckdb/src/execution/operator/scan/physical_empty_result.cpp
deleted file mode 100644
index 2e7d006bf..000000000
--- a/src/duckdb/src/execution/operator/scan/physical_empty_result.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_empty_result.hpp"
-
-namespace duckdb {
-
-SourceResultType PhysicalEmptyResult::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/scan/physical_expression_scan.cpp b/src/duckdb/src/execution/operator/scan/physical_expression_scan.cpp
deleted file mode 100644
index c0e91ae2b..000000000
--- a/src/duckdb/src/execution/operator/scan/physical_expression_scan.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_expression_scan.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-namespace duckdb {
-
-class ExpressionScanState : public OperatorState {
-public:
-	explicit ExpressionScanState(Allocator &allocator, const PhysicalExpressionScan &op) : expression_index(0) {
-		temp_chunk.Initialize(allocator, op.GetTypes());
-	}
-
-	//! The current position in the scan
-	idx_t expression_index;
-	//! Temporary chunk for evaluating expressions
-	DataChunk temp_chunk;
-};
-
-unique_ptr<OperatorState> PhysicalExpressionScan::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<ExpressionScanState>(Allocator::Get(context.client), *this);
-}
-
-OperatorResultType PhysicalExpressionScan::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = state_p.Cast<ExpressionScanState>();
-
-	for (; chunk.size() + input.size() <= STANDARD_VECTOR_SIZE && state.expression_index < expressions.size();
-	     state.expression_index++) {
-		state.temp_chunk.Reset();
-		EvaluateExpression(context.client, state.expression_index, &input, chunk, &state.temp_chunk);
-	}
-	if (state.expression_index < expressions.size()) {
-		return OperatorResultType::HAVE_MORE_OUTPUT;
-	} else {
-		state.expression_index = 0;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-}
-
-void PhysicalExpressionScan::EvaluateExpression(ClientContext &context, idx_t expression_idx,
-                                                optional_ptr<DataChunk> child_chunk, DataChunk &result,
-                                                optional_ptr<DataChunk> temp_chunk_ptr) const {
-	if (temp_chunk_ptr) {
-		EvaluateExpressionInternal(context, expression_idx, child_chunk, result, *temp_chunk_ptr);
-	} else {
-		DataChunk temp_chunk;
-		temp_chunk.Initialize(Allocator::Get(context), GetTypes());
-		EvaluateExpressionInternal(context, expression_idx, child_chunk, result, temp_chunk);
-	}
-}
-
-void PhysicalExpressionScan::EvaluateExpressionInternal(ClientContext &context, idx_t expression_idx,
-                                                        optional_ptr<DataChunk> child_chunk, DataChunk &result,
-                                                        DataChunk &temp_chunk) const {
-	ExpressionExecutor executor(context, expressions[expression_idx]);
-	if (child_chunk) {
-		child_chunk->Verify();
-		executor.Execute(*child_chunk, temp_chunk);
-	} else {
-		executor.Execute(temp_chunk);
-	}
-	// Need to append because "executor" might be holding state (e.g., strings), which go out of scope here
-	result.Append(temp_chunk);
-}
-
-bool PhysicalExpressionScan::IsFoldable() const {
-	for (auto &expr_list : expressions) {
-		for (auto &expr : expr_list) {
-			if (!expr->IsFoldable()) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp b/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp
deleted file mode 100644
index c1e2707b2..000000000
--- a/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/transaction/transaction.hpp"
-
-#include <utility>
-
-namespace duckdb {
-
-PhysicalPositionalScan::PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-                                               unique_ptr<PhysicalOperator> right)
-    : PhysicalOperator(PhysicalOperatorType::POSITIONAL_SCAN, std::move(types),
-                       MaxValue(left->estimated_cardinality, right->estimated_cardinality)) {
-
-	// Manage the children ourselves
-	if (left->type == PhysicalOperatorType::TABLE_SCAN) {
-		child_tables.emplace_back(std::move(left));
-	} else if (left->type == PhysicalOperatorType::POSITIONAL_SCAN) {
-		auto &left_scan = left->Cast<PhysicalPositionalScan>();
-		child_tables = std::move(left_scan.child_tables);
-	} else {
-		throw InternalException("Invalid left input for PhysicalPositionalScan");
-	}
-
-	if (right->type == PhysicalOperatorType::TABLE_SCAN) {
-		child_tables.emplace_back(std::move(right));
-	} else if (right->type == PhysicalOperatorType::POSITIONAL_SCAN) {
-		auto &right_scan = right->Cast<PhysicalPositionalScan>();
-		auto &right_tables = right_scan.child_tables;
-		child_tables.reserve(child_tables.size() + right_tables.size());
-		std::move(right_tables.begin(), right_tables.end(), std::back_inserter(child_tables));
-	} else {
-		throw InternalException("Invalid right input for PhysicalPositionalScan");
-	}
-}
-
-class PositionalScanGlobalSourceState : public GlobalSourceState {
-public:
-	PositionalScanGlobalSourceState(ClientContext &context, const PhysicalPositionalScan &op) {
-		for (const auto &table : op.child_tables) {
-			global_states.emplace_back(table->GetGlobalSourceState(context));
-		}
-	}
-
-	vector<unique_ptr<GlobalSourceState>> global_states;
-
-	idx_t MaxThreads() override {
-		return 1;
-	}
-};
-
-class PositionalTableScanner {
-public:
-	PositionalTableScanner(ExecutionContext &context, PhysicalOperator &table_p, GlobalSourceState &gstate_p)
-	    : table(table_p), global_state(gstate_p), source_offset(0), exhausted(false) {
-		local_state = table.GetLocalSourceState(context, gstate_p);
-		source.Initialize(Allocator::Get(context.client), table.types);
-	}
-
-	idx_t Refill(ExecutionContext &context) {
-		if (source_offset >= source.size()) {
-			if (!exhausted) {
-				source.Reset();
-
-				InterruptState interrupt_state;
-				OperatorSourceInput source_input {global_state, *local_state, interrupt_state};
-				auto source_result = table.GetData(context, source, source_input);
-				if (source_result == SourceResultType::BLOCKED) {
-					throw NotImplementedException(
-					    "Unexpected interrupt from table Source in PositionalTableScanner refill");
-				}
-			}
-			source_offset = 0;
-		}
-
-		const auto available = source.size() - source_offset;
-		if (!available) {
-			if (!exhausted) {
-				source.Reset();
-				for (idx_t i = 0; i < source.ColumnCount(); ++i) {
-					auto &vec = source.data[i];
-					vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-					ConstantVector::SetNull(vec, true);
-				}
-				exhausted = true;
-			}
-		}
-
-		return available;
-	}
-
-	idx_t CopyData(ExecutionContext &context, DataChunk &output, const idx_t count, const idx_t col_offset) {
-		if (!source_offset && (source.size() >= count || exhausted)) {
-			//	Fast track: aligned and has enough data
-			for (idx_t i = 0; i < source.ColumnCount(); ++i) {
-				output.data[col_offset + i].Reference(source.data[i]);
-			}
-			source_offset += count;
-		} else {
-			// Copy data
-			for (idx_t target_offset = 0; target_offset < count;) {
-				const auto needed = count - target_offset;
-				const auto available = exhausted ? needed : (source.size() - source_offset);
-				const auto copy_size = MinValue(needed, available);
-				const auto source_count = source_offset + copy_size;
-				for (idx_t i = 0; i < source.ColumnCount(); ++i) {
-					VectorOperations::Copy(source.data[i], output.data[col_offset + i], source_count, source_offset,
-					                       target_offset);
-				}
-				target_offset += copy_size;
-				source_offset += copy_size;
-				Refill(context);
-			}
-		}
-
-		return source.ColumnCount();
-	}
-
-	ProgressData GetProgress(ClientContext &context) {
-		return table.GetProgress(context, global_state);
-	}
-
-	PhysicalOperator &table;
-	GlobalSourceState &global_state;
-	unique_ptr<LocalSourceState> local_state;
-	DataChunk source;
-	idx_t source_offset;
-	bool exhausted;
-};
-
-class PositionalScanLocalSourceState : public LocalSourceState {
-public:
-	PositionalScanLocalSourceState(ExecutionContext &context, PositionalScanGlobalSourceState &gstate,
-	                               const PhysicalPositionalScan &op) {
-		for (size_t i = 0; i < op.child_tables.size(); ++i) {
-			auto &child = *op.child_tables[i];
-			auto &global_state = *gstate.global_states[i];
-			scanners.emplace_back(make_uniq<PositionalTableScanner>(context, child, global_state));
-		}
-	}
-
-	vector<unique_ptr<PositionalTableScanner>> scanners;
-};
-
-unique_ptr<LocalSourceState> PhysicalPositionalScan::GetLocalSourceState(ExecutionContext &context,
-                                                                         GlobalSourceState &gstate) const {
-	return make_uniq<PositionalScanLocalSourceState>(context, gstate.Cast<PositionalScanGlobalSourceState>(), *this);
-}
-
-unique_ptr<GlobalSourceState> PhysicalPositionalScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<PositionalScanGlobalSourceState>(context, *this);
-}
-
-SourceResultType PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &output,
-                                                 OperatorSourceInput &input) const {
-	auto &lstate = input.local_state.Cast<PositionalScanLocalSourceState>();
-
-	// Find the longest source block
-	idx_t count = 0;
-	for (auto &scanner : lstate.scanners) {
-		count = MaxValue(count, scanner->Refill(context));
-	}
-
-	//	All done?
-	if (!count) {
-		return SourceResultType::FINISHED;
-	}
-
-	// Copy or reference the source columns
-	idx_t col_offset = 0;
-	for (auto &scanner : lstate.scanners) {
-		col_offset += scanner->CopyData(context, output, count, col_offset);
-	}
-
-	output.SetCardinality(count);
-	return SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-ProgressData PhysicalPositionalScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<PositionalScanGlobalSourceState>();
-
-	ProgressData res;
-
-	for (size_t t = 0; t < child_tables.size(); ++t) {
-		res.Add(child_tables[t]->GetProgress(context, *gstate.global_states[t]));
-	}
-
-	return res;
-}
-
-bool PhysicalPositionalScan::Equals(const PhysicalOperator &other_p) const {
-	if (type != other_p.type) {
-		return false;
-	}
-
-	auto &other = other_p.Cast<PhysicalPositionalScan>();
-	if (child_tables.size() != other.child_tables.size()) {
-		return false;
-	}
-	for (size_t i = 0; i < child_tables.size(); ++i) {
-		if (!child_tables[i]->Equals(*other.child_tables[i])) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalPositionalScan::GetChildren() const {
-	auto result = PhysicalOperator::GetChildren();
-	for (auto &entry : child_tables) {
-		result.push_back(*entry);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp b/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp
deleted file mode 100644
index 0ea996d34..000000000
--- a/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/transaction/transaction.hpp"
-
-#include <utility>
-
-namespace duckdb {
-
-PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction function_p,
-                                     unique_ptr<FunctionData> bind_data_p, vector<LogicalType> returned_types_p,
-                                     vector<ColumnIndex> column_ids_p, vector<idx_t> projection_ids_p,
-                                     vector<string> names_p, unique_ptr<TableFilterSet> table_filters_p,
-                                     idx_t estimated_cardinality, ExtraOperatorInfo extra_info,
-                                     vector<Value> parameters_p)
-    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, std::move(types), estimated_cardinality),
-      function(std::move(function_p)), bind_data(std::move(bind_data_p)), returned_types(std::move(returned_types_p)),
-      column_ids(std::move(column_ids_p)), projection_ids(std::move(projection_ids_p)), names(std::move(names_p)),
-      table_filters(std::move(table_filters_p)), extra_info(extra_info), parameters(std::move(parameters_p)) {
-}
-
-class TableScanGlobalSourceState : public GlobalSourceState {
-public:
-	TableScanGlobalSourceState(ClientContext &context, const PhysicalTableScan &op) {
-		if (op.dynamic_filters && op.dynamic_filters->HasFilters()) {
-			table_filters = op.dynamic_filters->GetFinalTableFilters(op, op.table_filters.get());
-		}
-
-		if (op.function.init_global) {
-			auto filters = table_filters ? *table_filters : GetTableFilters(op);
-			TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.projection_ids, filters,
-			                             op.extra_info.sample_options);
-
-			global_state = op.function.init_global(context, input);
-			if (global_state) {
-				max_threads = global_state->MaxThreads();
-			}
-		} else {
-			max_threads = 1;
-		}
-		if (op.function.in_out_function) {
-			// this is an in-out function, we need to setup the input chunk
-			vector<LogicalType> input_types;
-			for (auto &param : op.parameters) {
-				input_types.push_back(param.type());
-			}
-			input_chunk.Initialize(context, input_types);
-			for (idx_t c = 0; c < op.parameters.size(); c++) {
-				input_chunk.data[c].SetValue(0, op.parameters[c]);
-			}
-			input_chunk.SetCardinality(1);
-		}
-	}
-
-	idx_t max_threads = 0;
-	unique_ptr<GlobalTableFunctionState> global_state;
-	bool in_out_final = false;
-	DataChunk input_chunk;
-	//! Combined table filters, if we have dynamic filters
-	unique_ptr<TableFilterSet> table_filters;
-
-	optional_ptr<TableFilterSet> GetTableFilters(const PhysicalTableScan &op) const {
-		return table_filters ? table_filters.get() : op.table_filters.get();
-	}
-	idx_t MaxThreads() override {
-		return max_threads;
-	}
-};
-
-class TableScanLocalSourceState : public LocalSourceState {
-public:
-	TableScanLocalSourceState(ExecutionContext &context, TableScanGlobalSourceState &gstate,
-	                          const PhysicalTableScan &op) {
-		if (op.function.init_local) {
-			TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.projection_ids,
-			                             gstate.GetTableFilters(op), op.extra_info.sample_options);
-			local_state = op.function.init_local(context, input, gstate.global_state.get());
-		}
-	}
-
-	unique_ptr<LocalTableFunctionState> local_state;
-};
-
-unique_ptr<LocalSourceState> PhysicalTableScan::GetLocalSourceState(ExecutionContext &context,
-                                                                    GlobalSourceState &gstate) const {
-	return make_uniq<TableScanLocalSourceState>(context, gstate.Cast<TableScanGlobalSourceState>(), *this);
-}
-
-unique_ptr<GlobalSourceState> PhysicalTableScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<TableScanGlobalSourceState>(context, *this);
-}
-
-SourceResultType PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSourceInput &input) const {
-	D_ASSERT(!column_ids.empty());
-	auto &g_state = input.global_state.Cast<TableScanGlobalSourceState>();
-	auto &l_state = input.local_state.Cast<TableScanLocalSourceState>();
-
-	TableFunctionInput data(bind_data.get(), l_state.local_state.get(), g_state.global_state.get());
-
-	if (function.function) {
-		function.function(context.client, data, chunk);
-		return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-	}
-
-	if (g_state.in_out_final) {
-		function.in_out_function_final(context, data, chunk);
-	}
-	function.in_out_function(context, data, g_state.input_chunk, chunk);
-	if (chunk.size() == 0 && function.in_out_function_final) {
-		function.in_out_function_final(context, data, chunk);
-		g_state.in_out_final = true;
-	}
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-ProgressData PhysicalTableScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<TableScanGlobalSourceState>();
-	ProgressData res;
-	if (function.table_scan_progress) {
-		double table_progress = function.table_scan_progress(context, bind_data.get(), gstate.global_state.get());
-		if (table_progress < 0.0) {
-			res.SetInvalid();
-		} else {
-			res.done = table_progress;
-			res.total = 100.0;
-			// Assume cardinality is always 1e3
-			res.Normalize(1e3);
-		}
-	} else {
-		// if table_scan_progress is not implemented we don't support this function yet in the progress bar
-		res.SetInvalid();
-	}
-	return res;
-}
-
-bool PhysicalTableScan::SupportsPartitioning(const OperatorPartitionInfo &partition_info) const {
-	if (!function.get_partition_data) {
-		return false;
-	}
-	// FIXME: actually check if partition info is supported
-	return true;
-}
-
-OperatorPartitionData PhysicalTableScan::GetPartitionData(ExecutionContext &context, DataChunk &chunk,
-                                                          GlobalSourceState &gstate_p, LocalSourceState &lstate,
-                                                          const OperatorPartitionInfo &partition_info) const {
-	D_ASSERT(SupportsPartitioning(partition_info));
-	D_ASSERT(function.get_partition_data);
-	auto &gstate = gstate_p.Cast<TableScanGlobalSourceState>();
-	auto &state = lstate.Cast<TableScanLocalSourceState>();
-	TableFunctionGetPartitionInput input(bind_data.get(), state.local_state.get(), gstate.global_state.get(),
-	                                     partition_info);
-	return function.get_partition_data(context.client, input);
-}
-
-string PhysicalTableScan::GetName() const {
-	return StringUtil::Upper(function.name + " " + function.extra_info);
-}
-
-void AddProjectionNames(const ColumnIndex &index, const string &name, const LogicalType &type, string &result) {
-	if (!index.HasChildren()) {
-		// base case - no children projected out
-		if (!result.empty()) {
-			result += "\n";
-		}
-		result += name;
-		return;
-	}
-	auto &child_types = StructType::GetChildTypes(type);
-	for (auto &child_index : index.GetChildIndexes()) {
-		auto &ele = child_types[child_index.GetPrimaryIndex()];
-		AddProjectionNames(child_index, name + "." + ele.first, ele.second, result);
-	}
-}
-
-InsertionOrderPreservingMap<string> PhysicalTableScan::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	if (function.to_string) {
-		TableFunctionToStringInput input(function, bind_data.get());
-		auto to_string_result = function.to_string(input);
-		for (const auto &it : to_string_result) {
-			result[it.first] = it.second;
-		}
-	} else {
-		result["Function"] = StringUtil::Upper(function.name);
-	}
-	if (function.projection_pushdown) {
-		string projections;
-		idx_t projected_column_count = function.filter_prune ? projection_ids.size() : column_ids.size();
-		for (idx_t i = 0; i < projected_column_count; i++) {
-			auto base_index = function.filter_prune ? projection_ids[i] : i;
-			auto &column_index = column_ids[base_index];
-			auto column_id = column_index.GetPrimaryIndex();
-			if (column_id >= names.size()) {
-				continue;
-			}
-			AddProjectionNames(column_index, names[column_id], returned_types[column_id], projections);
-		}
-		result["Projections"] = projections;
-	}
-	if (function.filter_pushdown && table_filters) {
-		string filters_info;
-		bool first_item = true;
-		for (auto &f : table_filters->filters) {
-			auto &column_index = f.first;
-			auto &filter = f.second;
-			if (column_index < names.size()) {
-				if (!first_item) {
-					filters_info += "\n";
-				}
-				first_item = false;
-
-				const auto col_id = column_ids[column_index].GetPrimaryIndex();
-				if (col_id == COLUMN_IDENTIFIER_ROW_ID) {
-					filters_info += filter->ToString("rowid");
-				} else {
-					filters_info += filter->ToString(names[col_id]);
-				}
-			}
-		}
-		result["Filters"] = filters_info;
-	}
-	if (extra_info.sample_options) {
-		result["Sample Method"] = "System: " + extra_info.sample_options->sample_size.ToString() + "%";
-	}
-	if (!extra_info.file_filters.empty()) {
-		result["File Filters"] = extra_info.file_filters;
-		if (extra_info.filtered_files.IsValid() && extra_info.total_files.IsValid()) {
-			result["Scanning Files"] = StringUtil::Format("%llu/%llu", extra_info.filtered_files.GetIndex(),
-			                                              extra_info.total_files.GetIndex());
-		}
-	}
-
-	SetEstimatedCardinality(result, estimated_cardinality);
-	return result;
-}
-
-bool PhysicalTableScan::Equals(const PhysicalOperator &other_p) const {
-	if (type != other_p.type) {
-		return false;
-	}
-	auto &other = other_p.Cast<PhysicalTableScan>();
-	if (function.function != other.function.function) {
-		return false;
-	}
-	if (column_ids != other.column_ids) {
-		return false;
-	}
-	if (!FunctionData::Equals(bind_data.get(), other.bind_data.get())) {
-		return false;
-	}
-	return true;
-}
-
-bool PhysicalTableScan::ParallelSource() const {
-	if (!function.function) {
-		// table in-out functions cannot be executed in parallel as part of a PhysicalTableScan
-		// since they have only a single input row
-		return false;
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_alter.cpp b/src/duckdb/src/execution/operator/schema/physical_alter.cpp
deleted file mode 100644
index 0d463e5ad..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_alter.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_alter.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.Alter(context.client, *info);
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_attach.cpp b/src/duckdb/src/execution/operator/schema/physical_attach.cpp
deleted file mode 100644
index 523f0d57e..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_attach.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_attach.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-#include "duckdb/main/database_path_and_type.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	// parse the options
-	auto &config = DBConfig::GetConfig(context.client);
-	AttachOptions options(info, config.options.access_mode);
-
-	// get the name and path of the database
-	auto &name = info->name;
-	auto &path = info->path;
-	if (options.db_type.empty()) {
-		DBPathAndType::ExtractExtensionPrefix(path, options.db_type);
-	}
-	if (name.empty()) {
-		auto &fs = FileSystem::GetFileSystem(context.client);
-		name = AttachedDatabase::ExtractDatabaseName(path, fs);
-	}
-
-	// check ATTACH IF NOT EXISTS
-	auto &db_manager = DatabaseManager::Get(context.client);
-	if (info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		// constant-time lookup in the catalog for the db name
-		auto existing_db = db_manager.GetDatabase(context.client, name);
-		if (existing_db) {
-			if ((existing_db->IsReadOnly() && options.access_mode == AccessMode::READ_WRITE) ||
-			    (!existing_db->IsReadOnly() && options.access_mode == AccessMode::READ_ONLY)) {
-
-				auto existing_mode = existing_db->IsReadOnly() ? AccessMode::READ_ONLY : AccessMode::READ_WRITE;
-				auto existing_mode_str = EnumUtil::ToString(existing_mode);
-				auto attached_mode = EnumUtil::ToString(options.access_mode);
-				throw BinderException("Database \"%s\" is already attached in %s mode, cannot re-attach in %s mode",
-				                      name, existing_mode_str, attached_mode);
-			}
-			if (!options.default_table.name.empty()) {
-				existing_db->GetCatalog().SetDefaultTable(options.default_table.schema, options.default_table.name);
-			}
-			return SourceResultType::FINISHED;
-		}
-	}
-
-	string extension = "";
-	if (FileSystem::IsRemoteFile(path, extension)) {
-		if (!ExtensionHelper::TryAutoLoadExtension(context.client, extension)) {
-			throw MissingExtensionException("Attaching path '%s' requires extension '%s' to be loaded", path,
-			                                extension);
-		}
-		if (options.access_mode == AccessMode::AUTOMATIC) {
-			// Attaching of remote files gets bumped to READ_ONLY
-			// This is due to the fact that on most (all?) remote files writes to DB are not available
-			// and having this raised later is not super helpful
-			options.access_mode = AccessMode::READ_ONLY;
-		}
-	}
-
-	// Get the database type and attach the database.
-	db_manager.GetDatabaseType(context.client, *info, config, options);
-	auto attached_db = db_manager.AttachDatabase(context.client, *info, options);
-
-	//! Initialize the database.
-	const auto storage_options = info->GetStorageOptions();
-	attached_db->Initialize(storage_options);
-	if (!options.default_table.name.empty()) {
-		attached_db->GetCatalog().SetDefaultTable(options.default_table.schema, options.default_table.name);
-	}
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_art_index.cpp b/src/duckdb/src/execution/operator/schema/physical_create_art_index.cpp
deleted file mode 100644
index e34e49de4..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_art_index.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-
-namespace duckdb {
-
-PhysicalCreateARTIndex::PhysicalCreateARTIndex(LogicalOperator &op, TableCatalogEntry &table_p,
-                                               const vector<column_t> &column_ids, unique_ptr<CreateIndexInfo> info,
-                                               vector<unique_ptr<Expression>> unbound_expressions,
-                                               idx_t estimated_cardinality, const bool sorted,
-                                               unique_ptr<AlterTableInfo> alter_table_info)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
-      table(table_p.Cast<DuckTableEntry>()), info(std::move(info)), unbound_expressions(std::move(unbound_expressions)),
-      sorted(sorted), alter_table_info(std::move(alter_table_info)) {
-
-	// Convert the logical column ids to physical column ids.
-	for (auto &column_id : column_ids) {
-		storage_ids.push_back(table.GetColumns().LogicalToPhysical(LogicalIndex(column_id)).index);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-
-class CreateARTIndexGlobalSinkState : public GlobalSinkState {
-public:
-	unique_ptr<BoundIndex> global_index;
-};
-
-class CreateARTIndexLocalSinkState : public LocalSinkState {
-public:
-	explicit CreateARTIndexLocalSinkState(ClientContext &context) : arena_allocator(Allocator::Get(context)) {};
-
-	unique_ptr<BoundIndex> local_index;
-	ArenaAllocator arena_allocator;
-
-	DataChunk key_chunk;
-	unsafe_vector<ARTKey> keys;
-	vector<column_t> key_column_ids;
-
-	DataChunk row_id_chunk;
-	unsafe_vector<ARTKey> row_ids;
-};
-
-unique_ptr<GlobalSinkState> PhysicalCreateARTIndex::GetGlobalSinkState(ClientContext &context) const {
-	// Create the global sink state and add the global index.
-	auto state = make_uniq<CreateARTIndexGlobalSinkState>();
-	auto &storage = table.GetStorage();
-	state->global_index = make_uniq<ART>(info->index_name, info->constraint_type, storage_ids,
-	                                     TableIOManager::Get(storage), unbound_expressions, storage.db);
-	return (std::move(state));
-}
-
-unique_ptr<LocalSinkState> PhysicalCreateARTIndex::GetLocalSinkState(ExecutionContext &context) const {
-	// Create the local sink state and add the local index.
-	auto state = make_uniq<CreateARTIndexLocalSinkState>(context.client);
-	auto &storage = table.GetStorage();
-	state->local_index = make_uniq<ART>(info->index_name, info->constraint_type, storage_ids,
-	                                    TableIOManager::Get(storage), unbound_expressions, storage.db);
-
-	// Initialize the local sink state.
-	state->keys.resize(STANDARD_VECTOR_SIZE);
-	state->row_ids.resize(STANDARD_VECTOR_SIZE);
-	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
-	state->row_id_chunk.Initialize(Allocator::Get(context.client), vector<LogicalType> {LogicalType::ROW_TYPE});
-	for (idx_t i = 0; i < state->key_chunk.ColumnCount(); i++) {
-		state->key_column_ids.push_back(i);
-	}
-	return std::move(state);
-}
-
-SinkResultType PhysicalCreateARTIndex::SinkUnsorted(OperatorSinkInput &input) const {
-
-	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
-	auto row_count = l_state.key_chunk.size();
-	auto &art = l_state.local_index->Cast<ART>();
-
-	// Insert each key and its corresponding row ID.
-	for (idx_t i = 0; i < row_count; i++) {
-		auto status = art.tree.GetGateStatus();
-		auto conflict_type = art.Insert(art.tree, l_state.keys[i], 0, l_state.row_ids[i], status, nullptr);
-		D_ASSERT(conflict_type != ARTConflictType::TRANSACTION);
-		if (conflict_type == ARTConflictType::CONSTRAINT) {
-			throw ConstraintException("Data contains duplicates on indexed column(s)");
-		}
-	}
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkResultType PhysicalCreateARTIndex::SinkSorted(OperatorSinkInput &input) const {
-
-	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
-	auto &storage = table.GetStorage();
-	auto &l_index = l_state.local_index;
-
-	// Construct an ART for this chunk.
-	auto art = make_uniq<ART>(info->index_name, l_index->GetConstraintType(), l_index->GetColumnIds(),
-	                          l_index->table_io_manager, l_index->unbound_expressions, storage.db,
-	                          l_index->Cast<ART>().allocators);
-	if (!art->Construct(l_state.keys, l_state.row_ids, l_state.key_chunk.size())) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-
-	// Merge the ART into the local ART.
-	if (!l_index->MergeIndexes(*art)) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkResultType PhysicalCreateARTIndex::Sink(ExecutionContext &context, DataChunk &chunk,
-                                            OperatorSinkInput &input) const {
-
-	D_ASSERT(chunk.ColumnCount() >= 2);
-	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
-	l_state.arena_allocator.Reset();
-	l_state.key_chunk.ReferenceColumns(chunk, l_state.key_column_ids);
-
-	// Check for NULLs, if we are creating a PRIMARY KEY.
-	// FIXME: Later, we want to ensure that we skip the NULL check for any non-PK alter.
-	if (alter_table_info) {
-		auto row_count = l_state.key_chunk.size();
-		for (idx_t i = 0; i < l_state.key_chunk.ColumnCount(); i++) {
-			if (VectorOperations::HasNull(l_state.key_chunk.data[i], row_count)) {
-				throw ConstraintException("NOT NULL constraint failed: %s", info->index_name);
-			}
-		}
-	}
-
-	ART::GenerateKeyVectors(l_state.arena_allocator, l_state.key_chunk, chunk.data[chunk.ColumnCount() - 1],
-	                        l_state.keys, l_state.row_ids);
-
-	if (sorted) {
-		return SinkSorted(input);
-	}
-	return SinkUnsorted(input);
-}
-
-SinkCombineResultType PhysicalCreateARTIndex::Combine(ExecutionContext &context,
-                                                      OperatorSinkCombineInput &input) const {
-
-	auto &g_state = input.global_state.Cast<CreateARTIndexGlobalSinkState>();
-	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
-
-	// Merge the local index into the global index.
-	if (!g_state.global_index->MergeIndexes(*l_state.local_index)) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-
-	return SinkCombineResultType::FINISHED;
-}
-
-SinkFinalizeType PhysicalCreateARTIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  OperatorSinkFinalizeInput &input) const {
-
-	// Here, we set the resulting global index as the newly created index of the table.
-	auto &state = input.global_state.Cast<CreateARTIndexGlobalSinkState>();
-
-	// Vacuum excess memory and verify.
-	state.global_index->Vacuum();
-	D_ASSERT(!state.global_index->VerifyAndToString(true).empty());
-	state.global_index->VerifyAllocations();
-
-	auto &storage = table.GetStorage();
-	if (!storage.IsRoot()) {
-		throw TransactionException("cannot add an index to a table that has been altered");
-	}
-
-	auto &schema = table.schema;
-	info->column_ids = storage_ids;
-
-	// FIXME: We should check for catalog exceptions prior to index creation, and later double-check.
-	if (!alter_table_info) {
-		// Ensure that the index does not yet exist in the catalog.
-		auto entry = schema.GetEntry(schema.GetCatalogTransaction(context), CatalogType::INDEX_ENTRY, info->index_name);
-		if (entry) {
-			if (info->on_conflict != OnCreateConflict::IGNORE_ON_CONFLICT) {
-				throw CatalogException("Index with name \"%s\" already exists!", info->index_name);
-			}
-			// IF NOT EXISTS on existing index. We are done.
-			return SinkFinalizeType::READY;
-		}
-
-		auto index_entry = schema.CreateIndex(schema.GetCatalogTransaction(context), *info, table).get();
-		D_ASSERT(index_entry);
-		auto &index = index_entry->Cast<DuckIndexEntry>();
-		index.initial_index_size = state.global_index->GetInMemorySize();
-
-	} else {
-		// Ensure that there are no other indexes with that name on this table.
-		auto &indexes = storage.GetDataTableInfo()->GetIndexes();
-		indexes.Scan([&](Index &index) {
-			if (index.GetIndexName() == info->index_name) {
-				throw CatalogException("an index with that name already exists for this table: %s", info->index_name);
-			}
-			return false;
-		});
-
-		auto &catalog = Catalog::GetCatalog(context, info->catalog);
-		catalog.Alter(context, *alter_table_info);
-	}
-
-	// Add the index to the storage.
-	storage.AddIndex(std::move(state.global_index));
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-
-SourceResultType PhysicalCreateARTIndex::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                 OperatorSourceInput &input) const {
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_function.cpp b/src/duckdb/src/execution/operator/schema/physical_create_function.cpp
deleted file mode 100644
index 2521b2082..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_function.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_function.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                 OperatorSourceInput &input) const {
-	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateFunction(context.client, *info);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp b/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp
deleted file mode 100644
index b0b031390..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_schema.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk,
-                                               OperatorSourceInput &input) const {
-	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	if (catalog.IsSystemCatalog()) {
-		throw BinderException("Cannot create schema in system catalog");
-	}
-	catalog.CreateSchema(context.client, *info);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp b/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp
deleted file mode 100644
index 80c4a2ffa..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_sequence.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                 OperatorSourceInput &input) const {
-	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateSequence(context.client, *info);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_table.cpp b/src/duckdb/src/execution/operator/schema/physical_create_table.cpp
deleted file mode 100644
index 3220c4356..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_table.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_table.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-namespace duckdb {
-
-PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry &schema,
-                                         unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE, op.types, estimated_cardinality), schema(schema),
-      info(std::move(info)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
-	auto &catalog = schema.catalog;
-	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, *info);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_type.cpp b/src/duckdb/src/execution/operator/schema/physical_create_type.cpp
deleted file mode 100644
index 68bc258b3..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_type.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_type.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/common/string_map_set.hpp"
-
-namespace duckdb {
-
-PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_TYPE, {LogicalType::BIGINT}, estimated_cardinality),
-      info(std::move(info_p)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class CreateTypeGlobalState : public GlobalSinkState {
-public:
-	explicit CreateTypeGlobalState(ClientContext &context) : result(LogicalType::VARCHAR) {
-	}
-	Vector result;
-	idx_t size = 0;
-	idx_t capacity = STANDARD_VECTOR_SIZE;
-	string_set_t found_strings;
-};
-
-unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<CreateTypeGlobalState>(context);
-}
-
-SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<CreateTypeGlobalState>();
-	idx_t total_row_count = gstate.size + chunk.size();
-	if (total_row_count > NumericLimits<uint32_t>::Maximum()) {
-		throw InvalidInputException("Attempted to create ENUM of size %llu, which exceeds the maximum size of %llu",
-		                            total_row_count, NumericLimits<uint32_t>::Maximum());
-	}
-	UnifiedVectorFormat sdata;
-	chunk.data[0].ToUnifiedFormat(chunk.size(), sdata);
-
-	if (total_row_count > gstate.capacity) {
-		// We must resize our result vector
-		gstate.result.Resize(gstate.capacity, gstate.capacity * 2);
-		gstate.capacity *= 2;
-	}
-
-	auto src_ptr = UnifiedVectorFormat::GetData<string_t>(sdata);
-	auto result_ptr = FlatVector::GetData<string_t>(gstate.result);
-	// Input vector has NULL value, we just throw an exception
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		idx_t idx = sdata.sel->get_index(i);
-		if (!sdata.validity.RowIsValid(idx)) {
-			throw InvalidInputException("Attempted to create ENUM type with NULL value!");
-		}
-		auto str = src_ptr[idx];
-		auto entry = gstate.found_strings.find(src_ptr[idx]);
-		if (entry != gstate.found_strings.end()) {
-			// entry was already found - skip
-			continue;
-		}
-		auto owned_string = StringVector::AddStringOrBlob(gstate.result, str.GetData(), str.GetSize());
-		gstate.found_strings.insert(owned_string);
-		result_ptr[gstate.size++] = owned_string;
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk,
-                                             OperatorSourceInput &input) const {
-	if (IsSink()) {
-		D_ASSERT(info->type == LogicalType::INVALID);
-		auto &g_sink_state = sink_state->Cast<CreateTypeGlobalState>();
-		info->type = LogicalType::ENUM(g_sink_state.result, g_sink_state.size);
-	}
-
-	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateType(context.client, *info);
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_create_view.cpp b/src/duckdb/src/execution/operator/schema/physical_create_view.cpp
deleted file mode 100644
index 948adad14..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_create_view.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_view.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCreateView::GetData(ExecutionContext &context, DataChunk &chunk,
-                                             OperatorSourceInput &input) const {
-	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateView(context.client, *info);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_detach.cpp b/src/duckdb/src/execution/operator/schema/physical_detach.cpp
deleted file mode 100644
index 480890c3a..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_detach.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_detach.hpp"
-#include "duckdb/parser/parsed_data/detach_info.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalDetach::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &db_manager = DatabaseManager::Get(context.client);
-	db_manager.DetachDatabase(context.client, info->name, info->if_not_found);
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/schema/physical_drop.cpp b/src/duckdb/src/execution/operator/schema/physical_drop.cpp
deleted file mode 100644
index cfb6841a8..000000000
--- a/src/duckdb/src/execution/operator/schema/physical_drop.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_drop.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/main/settings.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	switch (info->type) {
-	case CatalogType::PREPARED_STATEMENT: {
-		// DEALLOCATE silently ignores errors
-		auto &statements = ClientData::Get(context.client).prepared_statements;
-		if (statements.find(info->name) != statements.end()) {
-			statements.erase(info->name);
-		}
-		break;
-	}
-	case CatalogType::SCHEMA_ENTRY: {
-		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-		catalog.DropEntry(context.client, *info);
-
-		// Check if the dropped schema was set as the current schema
-		auto &client_data = ClientData::Get(context.client);
-		auto &default_entry = client_data.catalog_search_path->GetDefault();
-		auto &current_catalog = default_entry.catalog;
-		auto &current_schema = default_entry.schema;
-		D_ASSERT(info->name != DEFAULT_SCHEMA);
-
-		if (info->catalog == current_catalog && current_schema == info->name) {
-			// Reset the schema to default
-			SchemaSetting::SetLocal(context.client, DEFAULT_SCHEMA);
-		}
-		break;
-	}
-	case CatalogType::SECRET_ENTRY: {
-		// Note: the schema param is used to optionally pass the storage to drop from
-		D_ASSERT(info->extra_drop_info);
-		auto &extra_info = info->extra_drop_info->Cast<ExtraDropSecretInfo>();
-		SecretManager::Get(context.client)
-		    .DropSecretByName(context.client, info->name, info->if_not_found, extra_info.persist_mode,
-		                      extra_info.secret_storage);
-		break;
-	}
-	default: {
-		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-		catalog.DropEntry(context.client, *info);
-		break;
-	}
-	}
-
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/set/physical_cte.cpp b/src/duckdb/src/execution/operator/set/physical_cte.cpp
deleted file mode 100644
index fad76bbdd..000000000
--- a/src/duckdb/src/execution/operator/set/physical_cte.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "duckdb/execution/operator/set/physical_cte.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-PhysicalCTE::PhysicalCTE(string ctename, idx_t table_index, vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
-                         unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CTE, std::move(types), estimated_cardinality), table_index(table_index),
-      ctename(std::move(ctename)) {
-	children.push_back(std::move(top));
-	children.push_back(std::move(bottom));
-}
-
-PhysicalCTE::~PhysicalCTE() {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class CTEGlobalState : public GlobalSinkState {
-public:
-	explicit CTEGlobalState(ClientContext &context, const PhysicalCTE &op) : working_table_ref(op.working_table.get()) {
-	}
-	optional_ptr<ColumnDataCollection> working_table_ref;
-
-	mutex lhs_lock;
-
-	void MergeIT(ColumnDataCollection &input) {
-		lock_guard<mutex> guard(lhs_lock);
-		working_table_ref->Combine(input);
-	}
-};
-
-class CTELocalState : public LocalSinkState {
-public:
-	explicit CTELocalState(ClientContext &context, const PhysicalCTE &op)
-	    : lhs_data(context, op.working_table->Types()) {
-		lhs_data.InitializeAppend(append_state);
-	}
-
-	unique_ptr<LocalSinkState> distinct_state;
-	ColumnDataCollection lhs_data;
-	ColumnDataAppendState append_state;
-
-	void Append(DataChunk &input) {
-		lhs_data.Append(input);
-	}
-};
-
-unique_ptr<GlobalSinkState> PhysicalCTE::GetGlobalSinkState(ClientContext &context) const {
-	working_table->Reset();
-	return make_uniq<CTEGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalCTE::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<CTELocalState>(context.client, *this);
-	return std::move(state);
-}
-
-SinkResultType PhysicalCTE::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<CTELocalState>();
-	lstate.lhs_data.Append(lstate.append_state, chunk);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkCombineResultType PhysicalCTE::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<CTELocalState>();
-	auto &gstate = input.global_state.Cast<CTEGlobalState>();
-	gstate.MergeIT(lstate.lhs_data);
-
-	return SinkCombineResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalCTE::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	D_ASSERT(children.size() == 2);
-	op_state.reset();
-	sink_state.reset();
-
-	auto &state = meta_pipeline.GetState();
-
-	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-	child_meta_pipeline.Build(*children[0]);
-
-	for (auto &cte_scan : cte_scans) {
-		state.cte_dependencies.insert(make_pair(cte_scan, reference<Pipeline>(*child_meta_pipeline.GetBasePipeline())));
-	}
-
-	children[1]->BuildPipelines(current, meta_pipeline);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalCTE::GetSources() const {
-	return children[1]->GetSources();
-}
-
-InsertionOrderPreservingMap<string> PhysicalCTE::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["CTE Name"] = ctename;
-	result["Table Index"] = StringUtil::Format("%llu", table_index);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp b/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp
deleted file mode 100644
index 328e0822b..000000000
--- a/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-PhysicalRecursiveCTE::PhysicalRecursiveCTE(string ctename, idx_t table_index, vector<LogicalType> types, bool union_all,
-                                           unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
-                                           idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::RECURSIVE_CTE, std::move(types), estimated_cardinality),
-      ctename(std::move(ctename)), table_index(table_index), union_all(union_all) {
-	children.push_back(std::move(top));
-	children.push_back(std::move(bottom));
-}
-
-PhysicalRecursiveCTE::~PhysicalRecursiveCTE() {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class RecursiveCTEState : public GlobalSinkState {
-public:
-	explicit RecursiveCTEState(ClientContext &context, const PhysicalRecursiveCTE &op)
-	    : intermediate_table(context, op.GetTypes()), new_groups(STANDARD_VECTOR_SIZE) {
-		ht = make_uniq<GroupedAggregateHashTable>(context, BufferAllocator::Get(context), op.types,
-		                                          vector<LogicalType>(), vector<BoundAggregateExpression *>());
-	}
-
-	unique_ptr<GroupedAggregateHashTable> ht;
-
-	bool intermediate_empty = true;
-	mutex intermediate_table_lock;
-	ColumnDataCollection intermediate_table;
-	ColumnDataScanState scan_state;
-	bool initialized = false;
-	bool finished_scan = false;
-	SelectionVector new_groups;
-};
-
-unique_ptr<GlobalSinkState> PhysicalRecursiveCTE::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<RecursiveCTEState>(context, *this);
-}
-
-idx_t PhysicalRecursiveCTE::ProbeHT(DataChunk &chunk, RecursiveCTEState &state) const {
-	Vector dummy_addresses(LogicalType::POINTER);
-
-	// Use the HT to eliminate duplicate rows
-	idx_t new_group_count = state.ht->FindOrCreateGroups(chunk, dummy_addresses, state.new_groups);
-
-	// we only return entries we have not seen before (i.e. new groups)
-	chunk.Slice(state.new_groups, new_group_count);
-
-	return new_group_count;
-}
-
-SinkResultType PhysicalRecursiveCTE::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<RecursiveCTEState>();
-
-	lock_guard<mutex> guard(gstate.intermediate_table_lock);
-	if (!union_all) {
-		idx_t match_count = ProbeHT(chunk, gstate);
-		if (match_count > 0) {
-			gstate.intermediate_table.Append(chunk);
-		}
-	} else {
-		gstate.intermediate_table.Append(chunk);
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalRecursiveCTE::GetData(ExecutionContext &context, DataChunk &chunk,
-                                               OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<RecursiveCTEState>();
-	if (!gstate.initialized) {
-		gstate.intermediate_table.InitializeScan(gstate.scan_state);
-		gstate.finished_scan = false;
-		gstate.initialized = true;
-	}
-	while (chunk.size() == 0) {
-		if (!gstate.finished_scan) {
-			// scan any chunks we have collected so far
-			gstate.intermediate_table.Scan(gstate.scan_state, chunk);
-			if (chunk.size() == 0) {
-				gstate.finished_scan = true;
-			} else {
-				break;
-			}
-		} else {
-			// we have run out of chunks
-			// now we need to recurse
-			// we set up the working table as the data we gathered in this iteration of the recursion
-			working_table->Reset();
-			working_table->Combine(gstate.intermediate_table);
-			// and we clear the intermediate table
-			gstate.finished_scan = false;
-			gstate.intermediate_table.Reset();
-			// now we need to re-execute all of the pipelines that depend on the recursion
-			ExecuteRecursivePipelines(context);
-
-			// check if we obtained any results
-			// if not, we are done
-			if (gstate.intermediate_table.Count() == 0) {
-				gstate.finished_scan = true;
-				break;
-			}
-			// set up the scan again
-			gstate.intermediate_table.InitializeScan(gstate.scan_state);
-		}
-	}
-
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
-}
-
-void PhysicalRecursiveCTE::ExecuteRecursivePipelines(ExecutionContext &context) const {
-	if (!recursive_meta_pipeline) {
-		throw InternalException("Missing meta pipeline for recursive CTE");
-	}
-	D_ASSERT(recursive_meta_pipeline->HasRecursiveCTE());
-
-	// get and reset pipelines
-	vector<shared_ptr<Pipeline>> pipelines;
-	recursive_meta_pipeline->GetPipelines(pipelines, true);
-	for (auto &pipeline : pipelines) {
-		auto sink = pipeline->GetSink();
-		if (sink.get() != this) {
-			sink->sink_state.reset();
-		}
-		for (auto &op_ref : pipeline->GetOperators()) {
-			auto &op = op_ref.get();
-			op.op_state.reset();
-		}
-		pipeline->ClearSource();
-	}
-
-	// get the MetaPipelines in the recursive_meta_pipeline and reschedule them
-	vector<shared_ptr<MetaPipeline>> meta_pipelines;
-	recursive_meta_pipeline->GetMetaPipelines(meta_pipelines, true, false);
-	auto &executor = recursive_meta_pipeline->GetExecutor();
-	vector<shared_ptr<Event>> events;
-	executor.ReschedulePipelines(meta_pipelines, events);
-
-	while (true) {
-		executor.WorkOnTasks();
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		bool finished = true;
-		for (auto &event : events) {
-			if (!event->IsFinished()) {
-				finished = false;
-				break;
-			}
-		}
-		if (finished) {
-			// all pipelines finished: done!
-			break;
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-
-static void GatherColumnDataScans(const PhysicalOperator &op, vector<const_reference<PhysicalOperator>> &delim_scans) {
-	if (op.type == PhysicalOperatorType::DELIM_SCAN || op.type == PhysicalOperatorType::CTE_SCAN) {
-		delim_scans.push_back(op);
-	}
-	for (auto &child : op.children) {
-		GatherColumnDataScans(*child, delim_scans);
-	}
-}
-
-void PhysicalRecursiveCTE::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	op_state.reset();
-	sink_state.reset();
-	recursive_meta_pipeline.reset();
-
-	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, *this);
-
-	auto &executor = meta_pipeline.GetExecutor();
-	executor.AddRecursiveCTE(*this);
-
-	// the LHS of the recursive CTE is our initial state
-	auto &initial_state_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-	initial_state_pipeline.Build(*children[0]);
-
-	// the RHS is the recursive pipeline
-	recursive_meta_pipeline = make_shared_ptr<MetaPipeline>(executor, state, this);
-	recursive_meta_pipeline->SetRecursiveCTE();
-	recursive_meta_pipeline->Build(*children[1]);
-
-	vector<const_reference<PhysicalOperator>> ops;
-	GatherColumnDataScans(*children[1], ops);
-
-	for (auto op : ops) {
-		auto entry = state.cte_dependencies.find(op);
-		if (entry == state.cte_dependencies.end()) {
-			continue;
-		}
-		// this chunk scan introduces a dependency to the current pipeline
-		// namely a dependency on the CTE pipeline to finish
-		auto cte_dependency = entry->second.get().shared_from_this();
-		current.AddDependency(cte_dependency);
-	}
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalRecursiveCTE::GetSources() const {
-	return {*this};
-}
-
-InsertionOrderPreservingMap<string> PhysicalRecursiveCTE::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["CTE Name"] = ctename;
-	result["Table Index"] = StringUtil::Format("%llu", table_index);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/operator/set/physical_union.cpp b/src/duckdb/src/execution/operator/set/physical_union.cpp
deleted file mode 100644
index 1194b9539..000000000
--- a/src/duckdb/src/execution/operator/set/physical_union.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "duckdb/execution/operator/set/physical_union.hpp"
-
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-namespace duckdb {
-
-PhysicalUnion::PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
-                             unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality, bool allow_out_of_order)
-    : PhysicalOperator(PhysicalOperatorType::UNION, std::move(types), estimated_cardinality),
-      allow_out_of_order(allow_out_of_order) {
-	children.push_back(std::move(top));
-	children.push_back(std::move(bottom));
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalUnion::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	op_state.reset();
-	sink_state.reset();
-
-	// order matters if any of the downstream operators are order dependent,
-	// or if the sink preserves order, but does not support batch indices to do so
-	auto sink = meta_pipeline.GetSink();
-	bool order_matters = false;
-	if (!allow_out_of_order) {
-		order_matters = true;
-	}
-	if (current.IsOrderDependent()) {
-		order_matters = true;
-	}
-	if (sink) {
-		if (sink->SinkOrderDependent()) {
-			order_matters = true;
-		}
-		auto partition_info = sink->RequiredPartitionInfo();
-		if (partition_info.batch_index) {
-			order_matters = true;
-		}
-		if (!sink->ParallelSink()) {
-			order_matters = true;
-		}
-	}
-
-	// create a union pipeline that has identical dependencies to 'current'
-	auto &union_pipeline = meta_pipeline.CreateUnionPipeline(current, order_matters);
-
-	// continue with the current pipeline
-	children[0]->BuildPipelines(current, meta_pipeline);
-
-	vector<shared_ptr<Pipeline>> dependencies;
-	optional_ptr<MetaPipeline> last_child_ptr;
-	const auto can_saturate_threads = children[0]->CanSaturateThreads(current.GetClientContext());
-	if (order_matters || can_saturate_threads) {
-		// we add dependencies if order matters: union_pipeline comes after all pipelines created by building current
-		dependencies = meta_pipeline.AddDependenciesFrom(union_pipeline, union_pipeline, false);
-		// we also add dependencies if the LHS child can saturate all available threads
-		// in that case, we recursively make all RHS children depend on the LHS.
-		// This prevents breadth-first plan evaluation
-		if (can_saturate_threads) {
-			last_child_ptr = meta_pipeline.GetLastChild();
-		}
-	}
-
-	// build the union pipeline
-	children[1]->BuildPipelines(union_pipeline, meta_pipeline);
-
-	if (last_child_ptr) {
-		// the pointer was set, set up the dependencies
-		meta_pipeline.AddRecursiveDependencies(dependencies, *last_child_ptr);
-	}
-
-	// Assign proper batch index to the union pipeline
-	// This needs to happen after the pipelines have been built because unions can be nested
-	meta_pipeline.AssignNextBatchIndex(union_pipeline);
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalUnion::GetSources() const {
-	vector<const_reference<PhysicalOperator>> result;
-	for (auto &child : children) {
-		auto child_sources = child->GetSources();
-		result.insert(result.end(), child_sources.begin(), child_sources.end());
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp b/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp
deleted file mode 100644
index c378e61ed..000000000
--- a/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp
+++ /dev/null
@@ -1,318 +0,0 @@
-#include "duckdb/execution/perfect_aggregate_hashtable.hpp"
-
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-PerfectAggregateHashTable::PerfectAggregateHashTable(ClientContext &context, Allocator &allocator,
-                                                     const vector<LogicalType> &group_types_p,
-                                                     vector<LogicalType> payload_types_p,
-                                                     vector<AggregateObject> aggregate_objects_p,
-                                                     vector<Value> group_minima_p, vector<idx_t> required_bits_p)
-    : BaseAggregateHashTable(context, allocator, aggregate_objects_p, std::move(payload_types_p)),
-      addresses(LogicalType::POINTER), required_bits(std::move(required_bits_p)), total_required_bits(0),
-      group_minima(std::move(group_minima_p)), sel(STANDARD_VECTOR_SIZE),
-      aggregate_allocator(make_uniq<ArenaAllocator>(allocator)) {
-	for (auto &group_bits : required_bits) {
-		total_required_bits += group_bits;
-	}
-	// the total amount of groups we allocate space for is 2^required_bits
-	total_groups = (uint64_t)1 << total_required_bits;
-	// we don't need to store the groups in a perfect hash table, since the group keys can be deduced by their location
-	grouping_columns = group_types_p.size();
-	layout.Initialize(std::move(aggregate_objects_p));
-	tuple_size = layout.GetRowWidth();
-
-	// allocate and null initialize the data
-	owned_data = make_unsafe_uniq_array_uninitialized<data_t>(tuple_size * total_groups);
-	data = owned_data.get();
-
-	// set up the empty payloads for every tuple, and initialize the "occupied" flag to false
-	group_is_set = make_unsafe_uniq_array_uninitialized<bool>(total_groups);
-	memset(group_is_set.get(), 0, total_groups * sizeof(bool));
-
-	// initialize the hash table for each entry
-	auto address_data = FlatVector::GetData<uintptr_t>(addresses);
-	idx_t init_count = 0;
-	for (idx_t i = 0; i < total_groups; i++) {
-		address_data[init_count] = uintptr_t(data) + (tuple_size * i);
-		init_count++;
-		if (init_count == STANDARD_VECTOR_SIZE) {
-			RowOperations::InitializeStates(layout, addresses, *FlatVector::IncrementalSelectionVector(), init_count);
-			init_count = 0;
-		}
-	}
-	RowOperations::InitializeStates(layout, addresses, *FlatVector::IncrementalSelectionVector(), init_count);
-}
-
-PerfectAggregateHashTable::~PerfectAggregateHashTable() {
-	Destroy();
-}
-
-template <class T>
-static void ComputeGroupLocationTemplated(UnifiedVectorFormat &group_data, Value &min, uintptr_t *address_data,
-                                          idx_t current_shift, idx_t count) {
-	auto data = UnifiedVectorFormat::GetData<T>(group_data);
-	auto min_val = min.GetValueUnsafe<T>();
-	if (!group_data.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto index = group_data.sel->get_index(i);
-			// check if the value is NULL
-			// NULL groups are considered as "0" in the hash table
-			// that is to say, they have no effect on the position of the element (because 0 << shift is 0)
-			// we only need to handle non-null values here
-			if (group_data.validity.RowIsValid(index)) {
-				D_ASSERT(data[index] >= min_val);
-				auto adjusted_value = UnsafeNumericCast<uintptr_t>((data[index] - min_val) + 1);
-				address_data[i] += adjusted_value << current_shift;
-			}
-		}
-	} else {
-		// no null values: we can directly compute the addresses
-		for (idx_t i = 0; i < count; i++) {
-			auto index = group_data.sel->get_index(i);
-			auto adjusted_value = UnsafeNumericCast<uintptr_t>((data[index] - min_val) + 1);
-			address_data[i] += adjusted_value << current_shift;
-		}
-	}
-}
-
-static void ComputeGroupLocation(Vector &group, Value &min, uintptr_t *address_data, idx_t current_shift, idx_t count) {
-	UnifiedVectorFormat vdata;
-	group.ToUnifiedFormat(count, vdata);
-
-	switch (group.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		ComputeGroupLocationTemplated<int8_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::INT16:
-		ComputeGroupLocationTemplated<int16_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::INT32:
-		ComputeGroupLocationTemplated<int32_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::INT64:
-		ComputeGroupLocationTemplated<int64_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::UINT8:
-		ComputeGroupLocationTemplated<uint8_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::UINT16:
-		ComputeGroupLocationTemplated<uint16_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::UINT32:
-		ComputeGroupLocationTemplated<uint32_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::UINT64:
-		ComputeGroupLocationTemplated<uint64_t>(vdata, min, address_data, current_shift, count);
-		break;
-	default:
-		throw InternalException("Unsupported group type for perfect aggregate hash table");
-	}
-}
-
-void PerfectAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload) {
-	// first we need to find the location in the HT of each of the groups
-	auto address_data = FlatVector::GetData<uintptr_t>(addresses);
-	// zero-initialize the address data
-	memset(address_data, 0, groups.size() * sizeof(uintptr_t));
-	D_ASSERT(groups.ColumnCount() == group_minima.size());
-
-	// then compute the actual group location by iterating over each of the groups
-	idx_t current_shift = total_required_bits;
-	for (idx_t i = 0; i < groups.ColumnCount(); i++) {
-		current_shift -= required_bits[i];
-		ComputeGroupLocation(groups.data[i], group_minima[i], address_data, current_shift, groups.size());
-	}
-	// now we have the HT entry number for every tuple
-	// compute the actual pointer to the data by adding it to the base HT pointer and multiplying by the tuple size
-	for (idx_t i = 0; i < groups.size(); i++) {
-		const auto group = address_data[i];
-		if (group >= total_groups) {
-			throw InvalidInputException("Perfect hash aggregate: aggregate group %llu exceeded total groups %llu. This "
-			                            "likely means that the statistics in your data source are corrupt.\n* PRAGMA "
-			                            "disable_optimizer to disable optimizations that rely on correct statistics",
-			                            group, total_groups);
-		}
-		group_is_set[group] = true;
-		address_data[i] = uintptr_t(data) + group * tuple_size;
-	}
-
-	// after finding the group location we update the aggregates
-	idx_t payload_idx = 0;
-	auto &aggregates = layout.GetAggregates();
-	RowOperationsState row_state(*aggregate_allocator);
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = aggregates[aggr_idx];
-		auto input_count = (idx_t)aggregate.child_count;
-		if (aggregate.filter) {
-			RowOperations::UpdateFilteredStates(row_state, filter_set.GetFilterData(aggr_idx), aggregate, addresses,
-			                                    payload, payload_idx);
-		} else {
-			RowOperations::UpdateStates(row_state, aggregate, addresses, payload, payload_idx, payload.size());
-		}
-		// move to the next aggregate
-		payload_idx += input_count;
-		VectorOperations::AddInPlace(addresses, UnsafeNumericCast<int64_t>(aggregate.payload_size), payload.size());
-	}
-}
-
-void PerfectAggregateHashTable::Combine(PerfectAggregateHashTable &other) {
-	D_ASSERT(total_groups == other.total_groups);
-	D_ASSERT(tuple_size == other.tuple_size);
-
-	Vector source_addresses(LogicalType::POINTER);
-	Vector target_addresses(LogicalType::POINTER);
-	auto source_addresses_ptr = FlatVector::GetData<data_ptr_t>(source_addresses);
-	auto target_addresses_ptr = FlatVector::GetData<data_ptr_t>(target_addresses);
-
-	// iterate over all entries of both hash tables and call combine for all entries that can be combined
-	data_ptr_t source_ptr = other.data;
-	data_ptr_t target_ptr = data;
-	idx_t combine_count = 0;
-	RowOperationsState row_state(*aggregate_allocator);
-	for (idx_t i = 0; i < total_groups; i++) {
-		auto has_entry_source = other.group_is_set[i];
-		// we only have any work to do if the source has an entry for this group
-		if (has_entry_source) {
-			group_is_set[i] = true;
-			source_addresses_ptr[combine_count] = source_ptr;
-			target_addresses_ptr[combine_count] = target_ptr;
-			combine_count++;
-			if (combine_count == STANDARD_VECTOR_SIZE) {
-				RowOperations::CombineStates(row_state, layout, source_addresses, target_addresses, combine_count);
-				combine_count = 0;
-			}
-		}
-		source_ptr += tuple_size;
-		target_ptr += tuple_size;
-	}
-	RowOperations::CombineStates(row_state, layout, source_addresses, target_addresses, combine_count);
-
-	// FIXME: after moving the arena allocator, we currently have to ensure that the pointer is not nullptr, because the
-	// FIXME: Destroy()-function of the hash table expects an allocator in some cases (e.g., for sorted aggregates)
-	stored_allocators.push_back(std::move(other.aggregate_allocator));
-	other.aggregate_allocator = make_uniq<ArenaAllocator>(allocator);
-}
-
-template <class T>
-static void ReconstructGroupVectorTemplated(uint32_t group_values[], Value &min, idx_t mask, idx_t shift,
-                                            idx_t entry_count, Vector &result) {
-	auto data = FlatVector::GetData<T>(result);
-	auto &validity_mask = FlatVector::Validity(result);
-	auto min_data = min.GetValueUnsafe<T>();
-	for (idx_t i = 0; i < entry_count; i++) {
-		// extract the value of this group from the total group index
-		auto group_index = UnsafeNumericCast<int32_t>((group_values[i] >> shift) & mask);
-		if (group_index == 0) {
-			// if it is 0, the value is NULL
-			validity_mask.SetInvalid(i);
-		} else {
-			// otherwise we add the value (minus 1) to the min value
-			data[i] = UnsafeNumericCast<T>(UnsafeNumericCast<int64_t>(min_data) +
-			                               UnsafeNumericCast<int64_t>(group_index) - 1);
-		}
-	}
-}
-
-static void ReconstructGroupVector(uint32_t group_values[], Value &min, idx_t required_bits, idx_t shift,
-                                   idx_t entry_count, Vector &result) {
-	// construct the mask for this entry
-	idx_t mask = ((uint64_t)1 << required_bits) - 1;
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		ReconstructGroupVectorTemplated<int8_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::INT16:
-		ReconstructGroupVectorTemplated<int16_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::INT32:
-		ReconstructGroupVectorTemplated<int32_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::INT64:
-		ReconstructGroupVectorTemplated<int64_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::UINT8:
-		ReconstructGroupVectorTemplated<uint8_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::UINT16:
-		ReconstructGroupVectorTemplated<uint16_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::UINT32:
-		ReconstructGroupVectorTemplated<uint32_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::UINT64:
-		ReconstructGroupVectorTemplated<uint64_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	default:
-		throw InternalException("Invalid type for perfect aggregate HT group");
-	}
-}
-
-void PerfectAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) {
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	uint32_t group_values[STANDARD_VECTOR_SIZE];
-
-	// iterate over the HT until we either have exhausted the entire HT, or
-	idx_t entry_count = 0;
-	for (; scan_position < total_groups; scan_position++) {
-		if (group_is_set[scan_position]) {
-			// this group is set: add it to the set of groups to extract
-			data_pointers[entry_count] = data + tuple_size * scan_position;
-			group_values[entry_count] = NumericCast<uint32_t>(scan_position);
-			entry_count++;
-			if (entry_count == STANDARD_VECTOR_SIZE) {
-				scan_position++;
-				break;
-			}
-		}
-	}
-	if (entry_count == 0) {
-		// no entries found
-		return;
-	}
-	// first reconstruct the groups from the group index
-	idx_t shift = total_required_bits;
-	for (idx_t i = 0; i < grouping_columns; i++) {
-		shift -= required_bits[i];
-		ReconstructGroupVector(group_values, group_minima[i], required_bits[i], shift, entry_count, result.data[i]);
-	}
-	// then construct the payloads
-	result.SetCardinality(entry_count);
-	RowOperationsState row_state(*aggregate_allocator);
-	RowOperations::FinalizeStates(row_state, layout, addresses, result, grouping_columns);
-}
-
-void PerfectAggregateHashTable::Destroy() {
-	// check if there is any destructor to call
-	bool has_destructor = false;
-	for (auto &aggr : layout.GetAggregates()) {
-		if (aggr.function.destructor) {
-			has_destructor = true;
-		}
-	}
-	if (!has_destructor) {
-		return;
-	}
-	// there are aggregates with destructors: loop over the hash table
-	// and call the destructor method for each of the aggregates
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	idx_t count = 0;
-
-	// iterate over all initialised slots of the hash table
-	RowOperationsState row_state(*aggregate_allocator);
-	data_ptr_t payload_ptr = data;
-	for (idx_t i = 0; i < total_groups; i++) {
-		data_pointers[count++] = payload_ptr;
-		if (count == STANDARD_VECTOR_SIZE) {
-			RowOperations::DestroyStates(row_state, layout, addresses, count);
-			count = 0;
-		}
-		payload_ptr += tuple_size;
-	}
-	RowOperations::DestroyStates(row_state, layout, addresses, count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_operator.cpp b/src/duckdb/src/execution/physical_operator.cpp
deleted file mode 100644
index c5119620b..000000000
--- a/src/duckdb/src/execution/physical_operator.cpp
+++ /dev/null
@@ -1,355 +0,0 @@
-#include "duckdb/execution/physical_operator.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/render_tree.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-string PhysicalOperator::GetName() const {
-	return PhysicalOperatorToString(type);
-}
-
-string PhysicalOperator::ToString(ExplainFormat format) const {
-	auto renderer = TreeRenderer::CreateRenderer(format);
-	stringstream ss;
-	auto tree = RenderTree::CreateRenderTree(*this);
-	renderer->ToStream(*tree, ss);
-	return ss.str();
-}
-
-// LCOV_EXCL_START
-void PhysicalOperator::Print() const {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-vector<const_reference<PhysicalOperator>> PhysicalOperator::GetChildren() const {
-	vector<const_reference<PhysicalOperator>> result;
-	for (auto &child : children) {
-		result.push_back(*child);
-	}
-	return result;
-}
-
-void PhysicalOperator::SetEstimatedCardinality(InsertionOrderPreservingMap<string> &result,
-                                               idx_t estimated_cardinality) {
-	result[RenderTreeNode::ESTIMATED_CARDINALITY] = StringUtil::Format("%llu", estimated_cardinality);
-}
-
-idx_t PhysicalOperator::EstimatedThreadCount() const {
-	idx_t result = 0;
-	if (children.empty()) {
-		// Terminal operator, e.g., base table, these decide the degree of parallelism of pipelines
-		result = MaxValue<idx_t>(estimated_cardinality / (DEFAULT_ROW_GROUP_SIZE * 2), 1);
-	} else if (type == PhysicalOperatorType::UNION) {
-		// We can run union pipelines in parallel, so we sum up the thread count of the children
-		for (auto &child : children) {
-			result += child->EstimatedThreadCount();
-		}
-	} else {
-		// For other operators we take the maximum of the children
-		for (auto &child : children) {
-			result = MaxValue(child->EstimatedThreadCount(), result);
-		}
-	}
-	return result;
-}
-
-bool PhysicalOperator::CanSaturateThreads(ClientContext &context) const {
-#ifdef DEBUG
-	// In debug mode we always return true here so that the code that depends on it is well-tested
-	return true;
-#else
-	const auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads());
-	return EstimatedThreadCount() >= num_threads;
-#endif
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-// LCOV_EXCL_START
-unique_ptr<OperatorState> PhysicalOperator::GetOperatorState(ExecutionContext &context) const {
-	return make_uniq<OperatorState>();
-}
-
-unique_ptr<GlobalOperatorState> PhysicalOperator::GetGlobalOperatorState(ClientContext &context) const {
-	return make_uniq<GlobalOperatorState>();
-}
-
-OperatorResultType PhysicalOperator::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                             GlobalOperatorState &gstate, OperatorState &state) const {
-	throw InternalException("Calling Execute on a node that is not an operator!");
-}
-
-OperatorFinalizeResultType PhysicalOperator::FinalExecute(ExecutionContext &context, DataChunk &chunk,
-                                                          GlobalOperatorState &gstate, OperatorState &state) const {
-	throw InternalException("Calling FinalExecute on a node that is not an operator!");
-}
-// LCOV_EXCL_STOP
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-unique_ptr<LocalSourceState> PhysicalOperator::GetLocalSourceState(ExecutionContext &context,
-                                                                   GlobalSourceState &gstate) const {
-	return make_uniq<LocalSourceState>();
-}
-
-unique_ptr<GlobalSourceState> PhysicalOperator::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<GlobalSourceState>();
-}
-
-// LCOV_EXCL_START
-SourceResultType PhysicalOperator::GetData(ExecutionContext &context, DataChunk &chunk,
-                                           OperatorSourceInput &input) const {
-	throw InternalException("Calling GetData on a node that is not a source!");
-}
-
-OperatorPartitionData PhysicalOperator::GetPartitionData(ExecutionContext &context, DataChunk &chunk,
-                                                         GlobalSourceState &gstate, LocalSourceState &lstate,
-                                                         const OperatorPartitionInfo &partition_info) const {
-	throw InternalException("Calling GetPartitionData on a node that does not support it");
-}
-
-ProgressData PhysicalOperator::GetProgress(ClientContext &context, GlobalSourceState &gstate) const {
-	ProgressData res;
-	res.SetInvalid();
-	return res;
-}
-// LCOV_EXCL_STOP
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-// LCOV_EXCL_START
-SinkResultType PhysicalOperator::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	throw InternalException("Calling Sink on a node that is not a sink!");
-}
-
-// LCOV_EXCL_STOP
-
-SinkCombineResultType PhysicalOperator::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	return SinkCombineResultType::FINISHED;
-}
-
-void PhysicalOperator::PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const {
-}
-
-SinkFinalizeType PhysicalOperator::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            OperatorSinkFinalizeInput &input) const {
-	return SinkFinalizeType::READY;
-}
-
-SinkNextBatchType PhysicalOperator::NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const {
-	return SinkNextBatchType::READY;
-}
-
-unique_ptr<LocalSinkState> PhysicalOperator::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<LocalSinkState>();
-}
-
-unique_ptr<GlobalSinkState> PhysicalOperator::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<GlobalSinkState>();
-}
-
-idx_t PhysicalOperator::GetMaxThreadMemory(ClientContext &context) {
-	// Memory usage per thread should scale with max mem / num threads
-	// We take 1/4th of this, to be conservative
-	auto max_memory = BufferManager::GetBufferManager(context).GetQueryMaxMemory();
-	auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads());
-	return (max_memory / num_threads) / 4;
-}
-
-bool PhysicalOperator::OperatorCachingAllowed(ExecutionContext &context) {
-	if (!context.client.config.enable_caching_operators) {
-		return false;
-	} else if (!context.pipeline) {
-		return false;
-	} else if (!context.pipeline->GetSink()) {
-		return false;
-	} else if (context.pipeline->IsOrderDependent()) {
-		return false;
-	} else {
-		auto partition_info = context.pipeline->GetSink()->RequiredPartitionInfo();
-		if (partition_info.AnyRequired()) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalOperator::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
-	op_state.reset();
-
-	auto &state = meta_pipeline.GetState();
-	if (IsSink()) {
-		// operator is a sink, build a pipeline
-		sink_state.reset();
-		D_ASSERT(children.size() == 1);
-
-		// single operator: the operator becomes the data source of the current pipeline
-		state.SetPipelineSource(current, *this);
-
-		// we create a new pipeline starting from the child
-		auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-		child_meta_pipeline.Build(*children[0]);
-	} else {
-		// operator is not a sink! recurse in children
-		if (children.empty()) {
-			// source
-			state.SetPipelineSource(current, *this);
-		} else {
-			if (children.size() != 1) {
-				throw InternalException("Operator not supported in BuildPipelines");
-			}
-			state.AddPipelineOperator(current, *this);
-			children[0]->BuildPipelines(current, meta_pipeline);
-		}
-	}
-}
-
-vector<const_reference<PhysicalOperator>> PhysicalOperator::GetSources() const {
-	vector<const_reference<PhysicalOperator>> result;
-	if (IsSink()) {
-		D_ASSERT(children.size() == 1);
-		result.push_back(*this);
-		return result;
-	} else {
-		if (children.empty()) {
-			// source
-			result.push_back(*this);
-			return result;
-		} else {
-			if (children.size() != 1) {
-				throw InternalException("Operator not supported in GetSource");
-			}
-			return children[0]->GetSources();
-		}
-	}
-}
-
-bool PhysicalOperator::AllSourcesSupportBatchIndex() const {
-	auto sources = GetSources();
-	for (auto &source : sources) {
-		if (!source.get().SupportsPartitioning(OperatorPartitionInfo::BatchIndex())) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void PhysicalOperator::Verify() {
-#ifdef DEBUG
-	auto sources = GetSources();
-	D_ASSERT(!sources.empty());
-	for (auto &child : children) {
-		child->Verify();
-	}
-#endif
-}
-
-bool CachingPhysicalOperator::CanCacheType(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::ARRAY:
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &entries = StructType::GetChildTypes(type);
-		for (auto &entry : entries) {
-			if (!CanCacheType(entry.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
-CachingPhysicalOperator::CachingPhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types_p,
-                                                 idx_t estimated_cardinality)
-    : PhysicalOperator(type, std::move(types_p), estimated_cardinality) {
-
-	caching_supported = true;
-	for (auto &col_type : types) {
-		if (!CanCacheType(col_type)) {
-			caching_supported = false;
-			break;
-		}
-	}
-}
-
-OperatorResultType CachingPhysicalOperator::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = state_p.Cast<CachingOperatorState>();
-
-	// Execute child operator
-	auto child_result = ExecuteInternal(context, input, chunk, gstate, state);
-
-#if STANDARD_VECTOR_SIZE >= 128
-	if (!state.initialized) {
-		state.initialized = true;
-		state.can_cache_chunk = caching_supported && PhysicalOperator::OperatorCachingAllowed(context);
-	}
-	if (!state.can_cache_chunk) {
-		return child_result;
-	}
-	// TODO chunk size of 0 should not result in a cache being created!
-	if (chunk.size() < CACHE_THRESHOLD) {
-		// we have filtered out a significant amount of tuples
-		// add this chunk to the cache and continue
-
-		if (!state.cached_chunk) {
-			state.cached_chunk = make_uniq<DataChunk>();
-			state.cached_chunk->Initialize(Allocator::Get(context.client), chunk.GetTypes());
-		}
-
-		state.cached_chunk->Append(chunk);
-
-		if (state.cached_chunk->size() >= (STANDARD_VECTOR_SIZE - CACHE_THRESHOLD) ||
-		    child_result == OperatorResultType::FINISHED) {
-			// chunk cache full: return it
-			chunk.Move(*state.cached_chunk);
-			state.cached_chunk->Initialize(Allocator::Get(context.client), chunk.GetTypes());
-			return child_result;
-		} else {
-			// chunk cache not full return empty result
-			chunk.Reset();
-		}
-	}
-#endif
-
-	return child_result;
-}
-
-OperatorFinalizeResultType CachingPhysicalOperator::FinalExecute(ExecutionContext &context, DataChunk &chunk,
-                                                                 GlobalOperatorState &gstate,
-                                                                 OperatorState &state_p) const {
-	auto &state = state_p.Cast<CachingOperatorState>();
-	if (state.cached_chunk) {
-		chunk.Move(*state.cached_chunk);
-		state.cached_chunk.reset();
-	} else {
-		chunk.SetCardinality(0);
-	}
-	return OperatorFinalizeResultType::FINISHED;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp b/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp
deleted file mode 100644
index c61781a33..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp
+++ /dev/null
@@ -1,332 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp"
-#include "duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp"
-#include "duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-
-namespace duckdb {
-
-static uint32_t RequiredBitsForValue(uint32_t n) {
-	idx_t required_bits = 0;
-	while (n > 0) {
-		n >>= 1;
-		required_bits++;
-	}
-	return UnsafeNumericCast<uint32_t>(required_bits);
-}
-
-template <class T>
-hugeint_t GetRangeHugeint(const BaseStatistics &nstats) {
-	return Hugeint::Convert(NumericStats::GetMax<T>(nstats)) - Hugeint::Convert(NumericStats::GetMin<T>(nstats));
-}
-
-static bool CanUsePartitionedAggregate(ClientContext &context, LogicalAggregate &op, PhysicalOperator &child,
-                                       vector<column_t> &partition_columns) {
-	if (op.grouping_sets.size() > 1 || !op.grouping_functions.empty()) {
-		return false;
-	}
-	for (auto &expression : op.expressions) {
-		auto &aggregate = expression->Cast<BoundAggregateExpression>();
-		if (aggregate.IsDistinct()) {
-			// distinct aggregates are not supported in partitioned hash aggregates
-			return false;
-		}
-	}
-	// check if the source is partitioned by the aggregate columns
-	// figure out the columns we are grouping by
-	for (auto &group_expr : op.groups) {
-		// only support bound reference here
-		if (group_expr->GetExpressionType() != ExpressionType::BOUND_REF) {
-			return false;
-		}
-		auto &ref = group_expr->Cast<BoundReferenceExpression>();
-		partition_columns.push_back(ref.index);
-	}
-	// traverse the children of the aggregate to find the source operator
-	reference<PhysicalOperator> child_ref(child);
-	while (child_ref.get().type != PhysicalOperatorType::TABLE_SCAN) {
-		auto &child_op = child_ref.get();
-		switch (child_op.type) {
-		case PhysicalOperatorType::PROJECTION: {
-			// recompute partition columns
-			auto &projection = child_op.Cast<PhysicalProjection>();
-			vector<column_t> new_columns;
-			for (auto &partition_col : partition_columns) {
-				// we only support bound reference here
-				auto &expr = projection.select_list[partition_col];
-				if (expr->GetExpressionType() != ExpressionType::BOUND_REF) {
-					return false;
-				}
-				auto &ref = expr->Cast<BoundReferenceExpression>();
-				new_columns.push_back(ref.index);
-			}
-			// continue into child node with new columns
-			partition_columns = std::move(new_columns);
-			child_ref = *child_op.children[0];
-			break;
-		}
-		case PhysicalOperatorType::FILTER:
-			// continue into child operators
-			child_ref = *child_op.children[0];
-			break;
-		default:
-			// unsupported operator for partition pass-through
-			return false;
-		}
-	}
-	auto &table_scan = child_ref.get().Cast<PhysicalTableScan>();
-	if (!table_scan.function.get_partition_info) {
-		// this source does not expose partition information - skip
-		return false;
-	}
-	// get the base columns by projecting over the projection_ids/column_ids
-	if (!table_scan.projection_ids.empty()) {
-		for (auto &partition_col : partition_columns) {
-			partition_col = table_scan.projection_ids[partition_col];
-		}
-	}
-	vector<column_t> base_columns;
-	for (const auto &partition_idx : partition_columns) {
-		auto col_idx = partition_idx;
-		col_idx = table_scan.column_ids[col_idx].GetPrimaryIndex();
-		base_columns.push_back(col_idx);
-	}
-	// check if the source operator is partitioned by the grouping columns
-	TableFunctionPartitionInput input(table_scan.bind_data.get(), base_columns);
-	auto partition_info = table_scan.function.get_partition_info(context, input);
-	if (partition_info != TablePartitionInfo::SINGLE_VALUE_PARTITIONS) {
-		// we only support single-value partitions currently
-		return false;
-	}
-	// we have single value partitions!
-	return true;
-}
-
-static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate &op, vector<idx_t> &bits_per_group) {
-	if (op.grouping_sets.size() > 1 || !op.grouping_functions.empty()) {
-		return false;
-	}
-	idx_t perfect_hash_bits = 0;
-	if (op.group_stats.empty()) {
-		op.group_stats.resize(op.groups.size());
-	}
-	for (idx_t group_idx = 0; group_idx < op.groups.size(); group_idx++) {
-		auto &group = op.groups[group_idx];
-		auto &stats = op.group_stats[group_idx];
-
-		switch (group->return_type.InternalType()) {
-		case PhysicalType::INT8:
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-		case PhysicalType::INT64:
-		case PhysicalType::UINT8:
-		case PhysicalType::UINT16:
-		case PhysicalType::UINT32:
-		case PhysicalType::UINT64:
-			break;
-		default:
-			// we only support simple integer types for perfect hashing
-			return false;
-		}
-		// check if the group has stats available
-		auto &group_type = group->return_type;
-		if (!stats) {
-			// no stats, but we might still be able to use perfect hashing if the type is small enough
-			// for small types we can just set the stats to [type_min, type_max]
-			switch (group_type.InternalType()) {
-			case PhysicalType::INT8:
-			case PhysicalType::INT16:
-			case PhysicalType::UINT8:
-			case PhysicalType::UINT16:
-				break;
-			default:
-				// type is too large and there are no stats: skip perfect hashing
-				return false;
-			}
-			// construct stats with the min and max value of the type
-			stats = NumericStats::CreateUnknown(group_type).ToUnique();
-			NumericStats::SetMin(*stats, Value::MinimumValue(group_type));
-			NumericStats::SetMax(*stats, Value::MaximumValue(group_type));
-		}
-		auto &nstats = *stats;
-
-		if (!NumericStats::HasMinMax(nstats)) {
-			return false;
-		}
-
-		if (NumericStats::Max(*stats) < NumericStats::Min(*stats)) {
-			// May result in underflow
-			return false;
-		}
-
-		// we have a min and a max value for the stats: use that to figure out how many bits we have
-		// we add two here, one for the NULL value, and one to make the computation one-indexed
-		// (e.g. if min and max are the same, we still need one entry in total)
-		hugeint_t range_h;
-		switch (group_type.InternalType()) {
-		case PhysicalType::INT8:
-			range_h = GetRangeHugeint<int8_t>(nstats);
-			break;
-		case PhysicalType::INT16:
-			range_h = GetRangeHugeint<int16_t>(nstats);
-			break;
-		case PhysicalType::INT32:
-			range_h = GetRangeHugeint<int32_t>(nstats);
-			break;
-		case PhysicalType::INT64:
-			range_h = GetRangeHugeint<int64_t>(nstats);
-			break;
-		case PhysicalType::UINT8:
-			range_h = GetRangeHugeint<uint8_t>(nstats);
-			break;
-		case PhysicalType::UINT16:
-			range_h = GetRangeHugeint<uint16_t>(nstats);
-			break;
-		case PhysicalType::UINT32:
-			range_h = GetRangeHugeint<uint32_t>(nstats);
-			break;
-		case PhysicalType::UINT64:
-			range_h = GetRangeHugeint<uint64_t>(nstats);
-			break;
-		default:
-			throw InternalException("Unsupported type for perfect hash (should be caught before)");
-		}
-
-		uint64_t range;
-		if (!Hugeint::TryCast(range_h, range)) {
-			return false;
-		}
-
-		// bail out on any range bigger than 2^32
-		if (range >= NumericLimits<int32_t>::Maximum()) {
-			return false;
-		}
-
-		range += 2;
-		// figure out how many bits we need
-		idx_t required_bits = RequiredBitsForValue(UnsafeNumericCast<uint32_t>(range));
-		bits_per_group.push_back(required_bits);
-		perfect_hash_bits += required_bits;
-		// check if we have exceeded the bits for the hash
-		if (perfect_hash_bits > ClientConfig::GetConfig(context).perfect_ht_threshold) {
-			// too many bits for perfect hash
-			return false;
-		}
-	}
-	for (auto &expression : op.expressions) {
-		auto &aggregate = expression->Cast<BoundAggregateExpression>();
-		if (aggregate.IsDistinct() || !aggregate.function.combine) {
-			// distinct aggregates are not supported in perfect hash aggregates
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate &op) {
-	unique_ptr<PhysicalOperator> groupby;
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	plan = ExtractAggregateExpressions(std::move(plan), op.expressions, op.groups);
-
-	bool can_use_simple_aggregation = true;
-	for (auto &expression : op.expressions) {
-		auto &aggregate = expression->Cast<BoundAggregateExpression>();
-		if (!aggregate.function.simple_update) {
-			// unsupported aggregate for simple aggregation: use hash aggregation
-			can_use_simple_aggregation = false;
-			break;
-		}
-	}
-	if (op.groups.empty() && op.grouping_sets.size() <= 1) {
-		// no groups, check if we can use a simple aggregation
-		// special case: aggregate entire columns together
-		if (can_use_simple_aggregation) {
-			groupby = make_uniq_base<PhysicalOperator, PhysicalUngroupedAggregate>(op.types, std::move(op.expressions),
-			                                                                       op.estimated_cardinality);
-		} else {
-			groupby = make_uniq_base<PhysicalOperator, PhysicalHashAggregate>(
-			    context, op.types, std::move(op.expressions), op.estimated_cardinality);
-		}
-	} else {
-		// groups! create a GROUP BY aggregator
-		// use a partitioned or perfect hash aggregate if possible
-		vector<column_t> partition_columns;
-		vector<idx_t> required_bits;
-		if (can_use_simple_aggregation && CanUsePartitionedAggregate(context, op, *plan, partition_columns)) {
-			groupby = make_uniq_base<PhysicalOperator, PhysicalPartitionedAggregate>(
-			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(partition_columns),
-			    op.estimated_cardinality);
-		} else if (CanUsePerfectHashAggregate(context, op, required_bits)) {
-			groupby = make_uniq_base<PhysicalOperator, PhysicalPerfectHashAggregate>(
-			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(op.group_stats),
-			    std::move(required_bits), op.estimated_cardinality);
-		} else {
-			groupby = make_uniq_base<PhysicalOperator, PhysicalHashAggregate>(
-			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(op.grouping_sets),
-			    std::move(op.grouping_functions), op.estimated_cardinality);
-		}
-	}
-	groupby->children.push_back(std::move(plan));
-	return groupby;
-}
-
-unique_ptr<PhysicalOperator>
-PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
-                                                   vector<unique_ptr<Expression>> &aggregates,
-                                                   vector<unique_ptr<Expression>> &groups) {
-	vector<unique_ptr<Expression>> expressions;
-	vector<LogicalType> types;
-
-	// bind sorted aggregates
-	for (auto &aggr : aggregates) {
-		auto &bound_aggr = aggr->Cast<BoundAggregateExpression>();
-		if (bound_aggr.order_bys) {
-			// sorted aggregate!
-			FunctionBinder::BindSortedAggregate(context, bound_aggr, groups);
-		}
-	}
-	for (auto &group : groups) {
-		auto ref = make_uniq<BoundReferenceExpression>(group->return_type, expressions.size());
-		types.push_back(group->return_type);
-		expressions.push_back(std::move(group));
-		group = std::move(ref);
-	}
-	for (auto &aggr : aggregates) {
-		auto &bound_aggr = aggr->Cast<BoundAggregateExpression>();
-		for (auto &child : bound_aggr.children) {
-			auto ref = make_uniq<BoundReferenceExpression>(child->return_type, expressions.size());
-			types.push_back(child->return_type);
-			expressions.push_back(std::move(child));
-			child = std::move(ref);
-		}
-		if (bound_aggr.filter) {
-			auto &filter = bound_aggr.filter;
-			auto ref = make_uniq<BoundReferenceExpression>(filter->return_type, expressions.size());
-			types.push_back(filter->return_type);
-			expressions.push_back(std::move(filter));
-			bound_aggr.filter = std::move(ref);
-		}
-	}
-	if (expressions.empty()) {
-		return child;
-	}
-	auto projection =
-	    make_uniq<PhysicalProjection>(std::move(types), std::move(expressions), child->estimated_cardinality);
-	projection->children.push_back(std::move(child));
-	return std::move(projection);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_any_join.cpp b/src/duckdb/src/execution/physical_plan/plan_any_join.cpp
deleted file mode 100644
index 5e8ee6223..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_any_join.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAnyJoin &op) {
-	// first visit the child nodes
-	D_ASSERT(op.children.size() == 2);
-	D_ASSERT(op.condition);
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-
-	// create the blockwise NL join
-	return make_uniq<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(op.condition),
-	                                          op.join_type, op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp b/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp
deleted file mode 100644
index 927defa4f..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_window.hpp"
-#include "duckdb/execution/operator/join/physical_asof_join.hpp"
-#include "duckdb/execution/operator/join/physical_iejoin.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::PlanAsOfJoin(LogicalComparisonJoin &op) {
-	// now visit the children
-	D_ASSERT(op.children.size() == 2);
-	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
-	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-	D_ASSERT(left && right);
-
-	//	Validate
-	vector<idx_t> equi_indexes;
-	auto asof_idx = op.conditions.size();
-	for (size_t c = 0; c < op.conditions.size(); ++c) {
-		auto &cond = op.conditions[c];
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-			equi_indexes.emplace_back(c);
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_LESSTHAN:
-			D_ASSERT(asof_idx == op.conditions.size());
-			asof_idx = c;
-			break;
-		default:
-			throw InternalException("Invalid ASOF JOIN comparison");
-		}
-	}
-	D_ASSERT(asof_idx < op.conditions.size());
-
-	if (!ClientConfig::GetConfig(context).force_asof_iejoin) {
-		return make_uniq<PhysicalAsOfJoin>(op, std::move(left), std::move(right));
-	}
-
-	//	Strip extra column from rhs projections
-	auto &right_projection_map = op.right_projection_map;
-	if (right_projection_map.empty()) {
-		const auto right_count = right->types.size();
-		right_projection_map.reserve(right_count);
-		for (column_t i = 0; i < right_count; ++i) {
-			right_projection_map.emplace_back(i);
-		}
-	}
-
-	//	Debug implementation: IEJoin of Window
-	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_end
-	auto &asof_comp = op.conditions[asof_idx];
-	auto &asof_column = asof_comp.right;
-	auto asof_type = asof_column->return_type;
-	auto asof_end = make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
-	asof_end->children.emplace_back(asof_column->Copy());
-	// TODO: If infinities are not supported for a type, fake them by looking at LHS statistics?
-	asof_end->offset_expr = make_uniq<BoundConstantExpression>(Value::BIGINT(1));
-	for (auto equi_idx : equi_indexes) {
-		asof_end->partitions.emplace_back(op.conditions[equi_idx].right->Copy());
-	}
-	switch (asof_comp.comparison) {
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		asof_end->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
-		asof_end->default_expr = make_uniq<BoundConstantExpression>(Value::Infinity(asof_type));
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-	case ExpressionType::COMPARE_LESSTHAN:
-		asof_end->orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
-		asof_end->default_expr = make_uniq<BoundConstantExpression>(Value::NegativeInfinity(asof_type));
-		break;
-	default:
-		throw InternalException("Invalid ASOF JOIN ordering for WINDOW");
-	}
-
-	asof_end->start = WindowBoundary::UNBOUNDED_PRECEDING;
-	asof_end->end = WindowBoundary::CURRENT_ROW_ROWS;
-
-	vector<unique_ptr<Expression>> window_select;
-	window_select.emplace_back(std::move(asof_end));
-
-	auto &window_types = op.children[1]->types;
-	window_types.emplace_back(asof_type);
-
-	auto window = make_uniq<PhysicalWindow>(window_types, std::move(window_select), rhs_cardinality);
-	window->children.emplace_back(std::move(right));
-
-	// IEJoin(left, window, conditions || asof_comp ~op asof_end)
-	JoinCondition asof_upper;
-	asof_upper.left = asof_comp.left->Copy();
-	asof_upper.right = make_uniq<BoundReferenceExpression>(asof_type, window_types.size() - 1);
-	switch (asof_comp.comparison) {
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		asof_upper.comparison = ExpressionType::COMPARE_LESSTHAN;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		asof_upper.comparison = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		asof_upper.comparison = ExpressionType::COMPARE_GREATERTHAN;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		asof_upper.comparison = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-		break;
-	default:
-		throw InternalException("Invalid ASOF JOIN comparison for IEJoin");
-	}
-
-	op.conditions.emplace_back(std::move(asof_upper));
-
-	return make_uniq<PhysicalIEJoin>(op, std::move(left), std::move(window), std::move(op.conditions), op.join_type,
-	                                 lhs_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_column_data_get.cpp b/src/duckdb/src/execution/physical_plan/plan_column_data_get.cpp
deleted file mode 100644
index 46305675b..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_column_data_get.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalColumnDataGet &op) {
-	D_ASSERT(op.children.size() == 0);
-	D_ASSERT(op.collection);
-
-	return make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality,
-	                                         std::move(op.collection));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp b/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp
deleted file mode 100644
index e8d310519..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/execution/operator/join/perfect_hash_join_executor.hpp"
-#include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
-#include "duckdb/execution/operator/join/physical_cross_product.hpp"
-#include "duckdb/execution/operator/join/physical_hash_join.hpp"
-#include "duckdb/execution/operator/join/physical_iejoin.hpp"
-#include "duckdb/execution/operator/join/physical_nested_loop_join.hpp"
-#include "duckdb/execution/operator/join/physical_piecewise_merge_join.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-namespace duckdb {
-
-static void RewriteJoinCondition(Expression &expr, idx_t offset) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_REF) {
-		auto &ref = expr.Cast<BoundReferenceExpression>();
-		ref.index += offset;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { RewriteJoinCondition(child, offset); });
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::PlanComparisonJoin(LogicalComparisonJoin &op) {
-	// now visit the children
-	D_ASSERT(op.children.size() == 2);
-	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
-	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-	left->estimated_cardinality = lhs_cardinality;
-	right->estimated_cardinality = rhs_cardinality;
-	D_ASSERT(left && right);
-
-	if (op.conditions.empty()) {
-		// no conditions: insert a cross product
-		return make_uniq<PhysicalCrossProduct>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
-	}
-
-	idx_t has_range = 0;
-	bool has_equality = op.HasEquality(has_range);
-	bool can_merge = has_range > 0;
-	bool can_iejoin = has_range >= 2 && recursive_cte_tables.empty();
-	switch (op.join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-	case JoinType::RIGHT_ANTI:
-	case JoinType::RIGHT_SEMI:
-	case JoinType::MARK:
-		can_merge = can_merge && op.conditions.size() == 1;
-		can_iejoin = false;
-		break;
-	default:
-		break;
-	}
-	auto &client_config = ClientConfig::GetConfig(context);
-
-	//	TODO: Extend PWMJ to handle all comparisons and projection maps
-	const auto prefer_range_joins = client_config.prefer_range_joins && can_iejoin;
-
-	unique_ptr<PhysicalOperator> plan;
-	if (has_equality && !prefer_range_joins) {
-		// Equality join with small number of keys : possible perfect join optimization
-		plan = make_uniq<PhysicalHashJoin>(
-		    op, std::move(left), std::move(right), std::move(op.conditions), op.join_type, op.left_projection_map,
-		    op.right_projection_map, std::move(op.mark_types), op.estimated_cardinality, std::move(op.filter_pushdown));
-		plan->Cast<PhysicalHashJoin>().join_stats = std::move(op.join_stats);
-	} else {
-		D_ASSERT(op.left_projection_map.empty());
-		if (left->estimated_cardinality <= client_config.nested_loop_join_threshold ||
-		    right->estimated_cardinality <= client_config.nested_loop_join_threshold) {
-			can_iejoin = false;
-			can_merge = false;
-		}
-		if (can_merge && can_iejoin) {
-			if (left->estimated_cardinality <= client_config.merge_join_threshold ||
-			    right->estimated_cardinality <= client_config.merge_join_threshold) {
-				can_iejoin = false;
-			}
-		}
-		if (can_iejoin) {
-			plan = make_uniq<PhysicalIEJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                 op.join_type, op.estimated_cardinality);
-		} else if (can_merge) {
-			// range join: use piecewise merge join
-			plan =
-			    make_uniq<PhysicalPiecewiseMergeJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                          op.join_type, op.estimated_cardinality);
-		} else if (PhysicalNestedLoopJoin::IsSupported(op.conditions, op.join_type)) {
-			// inequality join: use nested loop
-			plan = make_uniq<PhysicalNestedLoopJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
-			                                         op.join_type, op.estimated_cardinality);
-		} else {
-			for (auto &cond : op.conditions) {
-				RewriteJoinCondition(*cond.right, left->types.size());
-			}
-			auto condition = JoinCondition::CreateExpression(std::move(op.conditions));
-			plan = make_uniq<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(condition),
-			                                          op.join_type, op.estimated_cardinality);
-		}
-	}
-	return plan;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparisonJoin &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		return PlanAsOfJoin(op);
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		return PlanComparisonJoin(op);
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PlanDelimJoin(op);
-	default:
-		throw InternalException("Unrecognized operator type for LogicalComparisonJoin");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_copy_database.cpp b/src/duckdb/src/execution/physical_plan/plan_copy_database.cpp
deleted file mode 100644
index 68eaf5619..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_copy_database.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_copy_database.hpp"
-#include "duckdb/execution/operator/persistent/physical_copy_database.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCopyDatabase &op) {
-	auto node = make_uniq<PhysicalCopyDatabase>(op.types, op.estimated_cardinality, std::move(op.info));
-	return std::move(node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_copy_to_file.cpp b/src/duckdb/src/execution/physical_plan/plan_copy_to_file.cpp
deleted file mode 100644
index a2981f61f..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_copy_to_file.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp"
-#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_copy_to_file.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile &op) {
-	auto plan = CreatePlan(*op.children[0]);
-	bool preserve_insertion_order = PhysicalPlanGenerator::PreserveInsertionOrder(context, *plan);
-	bool supports_batch_index = PhysicalPlanGenerator::UseBatchIndex(context, *plan);
-	auto &fs = FileSystem::GetFileSystem(context);
-	op.file_path = fs.ExpandPath(op.file_path);
-	if (op.use_tmp_file) {
-		auto path = StringUtil::GetFilePath(op.file_path);
-		auto base = StringUtil::GetFileName(op.file_path);
-		op.file_path = fs.JoinPath(path, "tmp_" + base);
-	}
-	if (op.per_thread_output || op.file_size_bytes.IsValid() || op.rotate || op.partition_output ||
-	    !op.partition_columns.empty() || op.overwrite_mode != CopyOverwriteMode::COPY_ERROR_ON_CONFLICT) {
-		// hive-partitioning/per-thread output does not care about insertion order, and does not support batch indexes
-		preserve_insertion_order = false;
-		supports_batch_index = false;
-	}
-	auto mode = CopyFunctionExecutionMode::REGULAR_COPY_TO_FILE;
-	if (op.function.execution_mode) {
-		mode = op.function.execution_mode(preserve_insertion_order, supports_batch_index);
-	}
-	if (mode == CopyFunctionExecutionMode::BATCH_COPY_TO_FILE) {
-		if (!supports_batch_index) {
-			throw InternalException("BATCH_COPY_TO_FILE can only be used if batch indexes are supported");
-		}
-		// batched copy to file
-		auto copy = make_uniq<PhysicalBatchCopyToFile>(op.types, op.function, std::move(op.bind_data),
-		                                               op.estimated_cardinality);
-		copy->file_path = op.file_path;
-		copy->use_tmp_file = op.use_tmp_file;
-		copy->children.push_back(std::move(plan));
-		copy->return_type = op.return_type;
-		return std::move(copy);
-	}
-
-	// COPY from select statement to file
-	auto copy = make_uniq<PhysicalCopyToFile>(op.types, op.function, std::move(op.bind_data), op.estimated_cardinality);
-	copy->file_path = op.file_path;
-	copy->use_tmp_file = op.use_tmp_file;
-	copy->overwrite_mode = op.overwrite_mode;
-	copy->filename_pattern = op.filename_pattern;
-	copy->file_extension = op.file_extension;
-	copy->per_thread_output = op.per_thread_output;
-	if (op.file_size_bytes.IsValid()) {
-		copy->file_size_bytes = op.file_size_bytes;
-	}
-	copy->rotate = op.rotate;
-	copy->return_type = op.return_type;
-	copy->partition_output = op.partition_output;
-	copy->partition_columns = op.partition_columns;
-	copy->write_partition_columns = op.write_partition_columns;
-	copy->names = op.names;
-	copy->expected_types = op.expected_types;
-	copy->parallel = mode == CopyFunctionExecutionMode::PARALLEL_COPY_TO_FILE;
-
-	copy->children.push_back(std::move(plan));
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_create.cpp b/src/duckdb/src/execution/physical_plan/plan_create.cpp
deleted file mode 100644
index 42a1652e6..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_create.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_function.hpp"
-#include "duckdb/execution/operator/schema/physical_create_schema.hpp"
-#include "duckdb/execution/operator/schema/physical_create_sequence.hpp"
-#include "duckdb/execution/operator/schema/physical_create_type.hpp"
-#include "duckdb/execution/operator/schema/physical_create_view.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator/logical_create.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreate &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		return make_uniq<PhysicalCreateSequence>(unique_ptr_cast<CreateInfo, CreateSequenceInfo>(std::move(op.info)),
-		                                         op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		return make_uniq<PhysicalCreateView>(unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(op.info)),
-		                                     op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		return make_uniq<PhysicalCreateSchema>(unique_ptr_cast<CreateInfo, CreateSchemaInfo>(std::move(op.info)),
-		                                       op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		return make_uniq<PhysicalCreateFunction>(unique_ptr_cast<CreateInfo, CreateMacroInfo>(std::move(op.info)),
-		                                         op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE: {
-		unique_ptr<PhysicalOperator> create = make_uniq<PhysicalCreateType>(
-		    unique_ptr_cast<CreateInfo, CreateTypeInfo>(std::move(op.info)), op.estimated_cardinality);
-		if (!op.children.empty()) {
-			D_ASSERT(op.children.size() == 1);
-			auto plan = CreatePlan(*op.children[0]);
-			create->children.push_back(std::move(plan));
-		}
-		return create;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type for logical simple create");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_create_index.cpp b/src/duckdb/src/execution/physical_plan/plan_create_index.cpp
deleted file mode 100644
index e2017c233..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_create_index.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_create_index.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateIndex &op) {
-	// Ensure that all expressions contain valid scalar functions.
-	// E.g., get_current_timestamp(), random(), and sequence values cannot be index keys.
-	for (idx_t i = 0; i < op.unbound_expressions.size(); i++) {
-		auto &expr = op.unbound_expressions[i];
-		if (!expr->IsConsistent()) {
-			throw BinderException("Index keys cannot contain expressions with side effects.");
-		}
-	}
-
-	// If we get here and the index type is not valid index type, we throw an exception.
-	const auto index_type = context.db->config.GetIndexTypes().FindByName(op.info->index_type);
-	if (!index_type) {
-		throw BinderException("Unknown index type: " + op.info->index_type);
-	}
-	if (!index_type->create_plan) {
-		throw InternalException("Index type '%s' is missing a create_plan function", op.info->index_type);
-	}
-
-	// Add a dependency for the entire table on which we create the index.
-	dependencies.AddDependency(op.table);
-	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());
-	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->column_ids.size());
-
-	// Generate a physical plan for the parallel index creation.
-	// TABLE SCAN - PROJECTION - (optional) NOT NULL FILTER - (optional) ORDER BY - CREATE INDEX
-	D_ASSERT(op.children.size() == 1);
-	auto table_scan = CreatePlan(*op.children[0]);
-
-	PlanIndexInput input(context, op, table_scan);
-	return index_type->create_plan(input);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_create_secret.cpp b/src/duckdb/src/execution/physical_plan/plan_create_secret.cpp
deleted file mode 100644
index b4818c809..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_create_secret.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_create_secret.hpp"
-#include "duckdb/execution/operator/helper/physical_create_secret.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateSecret &op) {
-	return make_uniq<PhysicalCreateSecret>(op.info, op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_create_table.cpp b/src/duckdb/src/execution/physical_plan/plan_create_table.cpp
deleted file mode 100644
index 06b728ee4..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_create_table.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/execution/operator/persistent/physical_batch_insert.hpp"
-#include "duckdb/execution/operator/persistent/physical_insert.hpp"
-#include "duckdb/execution/operator/schema/physical_create_table.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/operator/logical_create_table.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
-                                                            unique_ptr<PhysicalOperator> plan) {
-	bool parallel_streaming_insert = !PhysicalPlanGenerator::PreserveInsertionOrder(context, *plan);
-	bool use_batch_index = PhysicalPlanGenerator::UseBatchIndex(context, *plan);
-	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-	unique_ptr<PhysicalOperator> create;
-	if (!parallel_streaming_insert && use_batch_index) {
-		create = make_uniq<PhysicalBatchInsert>(op, op.schema, std::move(op.info), 0U);
-
-	} else {
-		create = make_uniq<PhysicalInsert>(op, op.schema, std::move(op.info), 0U,
-		                                   parallel_streaming_insert && num_threads > 1);
-	}
-
-	D_ASSERT(op.children.size() == 1);
-	create->children.push_back(std::move(plan));
-	return create;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
-	const auto &create_info = op.info->base->Cast<CreateTableInfo>();
-	auto &catalog = op.info->schema.catalog;
-	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table,
-	                                                          OnEntryNotFound::RETURN_NULL);
-	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
-	if ((!existing_entry || replace) && !op.children.empty()) {
-		auto plan = CreatePlan(*op.children[0]);
-		return op.schema.catalog.PlanCreateTableAs(context, op, std::move(plan));
-	} else {
-		return make_uniq<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_cross_product.cpp b/src/duckdb/src/execution/physical_plan/plan_cross_product.cpp
deleted file mode 100644
index dac220706..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_cross_product.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/execution/operator/join/physical_cross_product.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCrossProduct &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-	return make_uniq<PhysicalCrossProduct>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_cte.cpp b/src/duckdb/src/execution/physical_plan/plan_cte.cpp
deleted file mode 100644
index 9c6596279..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_cte.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/execution/operator/set/physical_cte.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_cteref.hpp"
-#include "duckdb/planner/operator/logical_materialized_cte.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalMaterializedCTE &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	// Create the working_table that the PhysicalCTE will use for evaluation.
-	auto working_table = make_shared_ptr<ColumnDataCollection>(context, op.children[0]->types);
-
-	// Add the ColumnDataCollection to the context of this PhysicalPlanGenerator
-	recursive_cte_tables[op.table_index] = working_table;
-	materialized_ctes[op.table_index] = vector<const_reference<PhysicalOperator>>();
-
-	// Create the plan for the left side. This is the materialization.
-	auto left = CreatePlan(*op.children[0]);
-	// Initialize an empty vector to collect the scan operators.
-	auto right = CreatePlan(*op.children[1]);
-
-	unique_ptr<PhysicalCTE> cte;
-	cte = make_uniq<PhysicalCTE>(op.ctename, op.table_index, right->types, std::move(left), std::move(right),
-	                             op.estimated_cardinality);
-	cte->working_table = working_table;
-	cte->cte_scans = materialized_ctes[op.table_index];
-
-	return std::move(cte);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_delete.cpp b/src/duckdb/src/execution/physical_plan/plan_delete.cpp
deleted file mode 100644
index d6afee808..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_delete.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/execution/operator/persistent/physical_delete.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_delete.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> DuckCatalog::PlanDelete(ClientContext &context, LogicalDelete &op,
-                                                     unique_ptr<PhysicalOperator> plan) {
-	// get the index of the row_id column
-	auto &bound_ref = op.expressions[0]->Cast<BoundReferenceExpression>();
-
-	auto del = make_uniq<PhysicalDelete>(op.types, op.table, op.table.GetStorage(), std::move(op.bound_constraints),
-	                                     bound_ref.index, op.estimated_cardinality, op.return_chunk);
-	del->children.push_back(std::move(plan));
-	return std::move(del);
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op) {
-	D_ASSERT(op.children.size() == 1);
-	D_ASSERT(op.expressions.size() == 1);
-	D_ASSERT(op.expressions[0]->GetExpressionType() == ExpressionType::BOUND_REF);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	dependencies.AddDependency(op.table);
-	return op.table.catalog.PlanDelete(context, op, std::move(plan));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_delim_get.cpp b/src/duckdb/src/execution/physical_plan/plan_delim_get.cpp
deleted file mode 100644
index 1b45efe21..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_delim_get.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_delim_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimGet &op) {
-	D_ASSERT(op.children.empty());
-
-	// create a PhysicalChunkScan without an owned_collection, the collection will be added later
-	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::DELIM_SCAN,
-	                                                    op.estimated_cardinality, nullptr);
-	return std::move(chunk_scan);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp b/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp
deleted file mode 100644
index 9755f8330..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/join/physical_hash_join.hpp"
-#include "duckdb/execution/operator/join/physical_left_delim_join.hpp"
-#include "duckdb/execution/operator/join/physical_right_delim_join.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-
-namespace duckdb {
-
-static void GatherDelimScans(PhysicalOperator &op, vector<const_reference<PhysicalOperator>> &delim_scans,
-                             idx_t delim_index) {
-	if (op.type == PhysicalOperatorType::DELIM_SCAN) {
-		auto &scan = op.Cast<PhysicalColumnDataScan>();
-		scan.delim_index = optional_idx(delim_index);
-		delim_scans.push_back(op);
-	}
-	for (auto &child : op.children) {
-		GatherDelimScans(*child, delim_scans, delim_index);
-	}
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::PlanDelimJoin(LogicalComparisonJoin &op) {
-	// first create the underlying join
-	auto plan = PlanComparisonJoin(op);
-	// this should create a join, not a cross product
-	D_ASSERT(plan && plan->type != PhysicalOperatorType::CROSS_PRODUCT);
-	// duplicate eliminated join
-	// first gather the scans on the duplicate eliminated data set from the delim side
-	const idx_t delim_idx = op.delim_flipped ? 0 : 1;
-	vector<const_reference<PhysicalOperator>> delim_scans;
-	GatherDelimScans(*plan->children[delim_idx], delim_scans, ++this->delim_index);
-	if (delim_scans.empty()) {
-		// no duplicate eliminated scans in the delim side!
-		// in this case we don't need to create a delim join
-		// just push the normal join
-		return plan;
-	}
-	vector<LogicalType> delim_types;
-	vector<unique_ptr<Expression>> distinct_groups, distinct_expressions;
-	for (auto &delim_expr : op.duplicate_eliminated_columns) {
-		D_ASSERT(delim_expr->GetExpressionType() == ExpressionType::BOUND_REF);
-		auto &bound_ref = delim_expr->Cast<BoundReferenceExpression>();
-		delim_types.push_back(bound_ref.return_type);
-		distinct_groups.push_back(make_uniq<BoundReferenceExpression>(bound_ref.return_type, bound_ref.index));
-	}
-	// now create the duplicate eliminated join
-	unique_ptr<PhysicalDelimJoin> delim_join;
-	if (op.delim_flipped) {
-		delim_join = make_uniq<PhysicalRightDelimJoin>(op.types, std::move(plan), delim_scans, op.estimated_cardinality,
-		                                               optional_idx(this->delim_index));
-	} else {
-		delim_join = make_uniq<PhysicalLeftDelimJoin>(op.types, std::move(plan), delim_scans, op.estimated_cardinality,
-		                                              optional_idx(this->delim_index));
-	}
-	// we still have to create the DISTINCT clause that is used to generate the duplicate eliminated chunk
-	delim_join->distinct = make_uniq<PhysicalHashAggregate>(context, delim_types, std::move(distinct_expressions),
-	                                                        std::move(distinct_groups), op.estimated_cardinality);
-
-	return std::move(delim_join);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_distinct.cpp b/src/duckdb/src/execution/physical_plan/plan_distinct.cpp
deleted file mode 100644
index 60fdb6584..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_distinct.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto child = CreatePlan(*op.children[0]);
-	auto &distinct_targets = op.distinct_targets;
-	D_ASSERT(child);
-	D_ASSERT(!distinct_targets.empty());
-
-	auto &types = child->GetTypes();
-	vector<unique_ptr<Expression>> groups, aggregates, projections;
-	idx_t group_count = distinct_targets.size();
-	unordered_map<idx_t, idx_t> group_by_references;
-	vector<LogicalType> aggregate_types;
-	// creates one group per distinct_target
-	for (idx_t i = 0; i < distinct_targets.size(); i++) {
-		auto &target = distinct_targets[i];
-		if (target->GetExpressionType() == ExpressionType::BOUND_REF) {
-			auto &bound_ref = target->Cast<BoundReferenceExpression>();
-			group_by_references[bound_ref.index] = i;
-		}
-		aggregate_types.push_back(target->return_type);
-		groups.push_back(std::move(target));
-	}
-	bool requires_projection = false;
-	if (types.size() != group_count) {
-		requires_projection = true;
-	}
-	// we need to create one aggregate per column in the select_list
-	for (idx_t i = 0; i < types.size(); ++i) {
-		auto logical_type = types[i];
-		// check if we can directly refer to a group, or if we need to push an aggregate with FIRST
-		auto entry = group_by_references.find(i);
-		if (entry != group_by_references.end()) {
-			auto group_index = entry->second;
-			// entry is found: can directly refer to a group
-			projections.push_back(make_uniq<BoundReferenceExpression>(logical_type, group_index));
-			if (group_index != i) {
-				// we require a projection only if this group element is out of order
-				requires_projection = true;
-			}
-		} else {
-			if (op.distinct_type == DistinctType::DISTINCT && op.order_by) {
-				throw InternalException("Entry that is not a group, but not a DISTINCT ON aggregate");
-			}
-			// entry is not one of the groups: need to push a FIRST aggregate
-			auto bound = make_uniq<BoundReferenceExpression>(logical_type, i);
-			vector<unique_ptr<Expression>> first_children;
-			first_children.push_back(std::move(bound));
-
-			FunctionBinder function_binder(context);
-			auto first_aggregate =
-			    function_binder.BindAggregateFunction(FirstFunctionGetter::GetFunction(logical_type),
-			                                          std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
-			first_aggregate->order_bys = op.order_by ? op.order_by->Copy() : nullptr;
-
-			if (ClientConfig::GetConfig(context).enable_optimizer) {
-				bool changes_made = false;
-				auto new_expr = OrderedAggregateOptimizer::Apply(context, *first_aggregate, groups, changes_made);
-				if (new_expr) {
-					D_ASSERT(new_expr->return_type == first_aggregate->return_type);
-					D_ASSERT(new_expr->GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
-					first_aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(new_expr));
-				}
-			}
-			// add the projection
-			projections.push_back(make_uniq<BoundReferenceExpression>(logical_type, group_count + aggregates.size()));
-			// push it to the list of aggregates
-			aggregate_types.push_back(logical_type);
-			aggregates.push_back(std::move(first_aggregate));
-			requires_projection = true;
-		}
-	}
-
-	child = ExtractAggregateExpressions(std::move(child), aggregates, groups);
-
-	// we add a physical hash aggregation in the plan to select the distinct groups
-	auto groupby = make_uniq<PhysicalHashAggregate>(context, aggregate_types, std::move(aggregates), std::move(groups),
-	                                                child->estimated_cardinality);
-	groupby->children.push_back(std::move(child));
-	if (!requires_projection) {
-		return std::move(groupby);
-	}
-
-	// we add a physical projection on top of the aggregation to project all members in the select list
-	auto aggr_projection = make_uniq<PhysicalProjection>(types, std::move(projections), groupby->estimated_cardinality);
-	aggr_projection->children.push_back(std::move(groupby));
-	return std::move(aggr_projection);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_dummy_scan.cpp b/src/duckdb/src/execution/physical_plan/plan_dummy_scan.cpp
deleted file mode 100644
index ed561cf4e..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_dummy_scan.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_dummy_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDummyScan &op) {
-	D_ASSERT(op.children.size() == 0);
-	return make_uniq<PhysicalDummyScan>(op.types, op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_empty_result.cpp b/src/duckdb/src/execution/physical_plan/plan_empty_result.cpp
deleted file mode 100644
index 7313f034a..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_empty_result.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_empty_result.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalEmptyResult &op) {
-	D_ASSERT(op.children.size() == 0);
-	return make_uniq<PhysicalEmptyResult>(op.types, op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_execute.cpp b/src/duckdb/src/execution/physical_plan/plan_execute.cpp
deleted file mode 100644
index 735cf9fc1..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_execute.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_execute.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_execute.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExecute &op) {
-	if (!op.prepared->plan) {
-		D_ASSERT(op.children.size() == 1);
-		auto owned_plan = CreatePlan(*op.children[0]);
-		auto execute = make_uniq<PhysicalExecute>(*owned_plan);
-		execute->owned_plan = std::move(owned_plan);
-		execute->prepared = std::move(op.prepared);
-		return std::move(execute);
-	} else {
-		D_ASSERT(op.children.size() == 0);
-		return make_uniq<PhysicalExecute>(*op.prepared->plan);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_explain.cpp b/src/duckdb/src/execution/physical_plan/plan_explain.cpp
deleted file mode 100644
index 3f9d2a4b4..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_explain.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/helper/physical_explain_analyze.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/operator/logical_explain.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto logical_plan_opt = op.children[0]->ToString(op.explain_format);
-	auto plan = CreatePlan(*op.children[0]);
-	if (op.explain_type == ExplainType::EXPLAIN_ANALYZE) {
-		auto result = make_uniq<PhysicalExplainAnalyze>(op.types, op.explain_format);
-		result->children.push_back(std::move(plan));
-		return std::move(result);
-	}
-
-	op.physical_plan = plan->ToString(op.explain_format);
-	// the output of the explain
-	vector<string> keys, values;
-	switch (ClientConfig::GetConfig(context).explain_output_type) {
-	case ExplainOutputType::OPTIMIZED_ONLY:
-		keys = {"logical_opt"};
-		values = {logical_plan_opt};
-		break;
-	case ExplainOutputType::PHYSICAL_ONLY:
-		keys = {"physical_plan"};
-		values = {op.physical_plan};
-		break;
-	default:
-		keys = {"logical_plan", "logical_opt", "physical_plan"};
-		values = {op.logical_plan_unopt, logical_plan_opt, op.physical_plan};
-	}
-
-	// create a ColumnDataCollection from the output
-	auto &allocator = Allocator::Get(context);
-	vector<LogicalType> plan_types {LogicalType::VARCHAR, LogicalType::VARCHAR};
-	auto collection =
-	    make_uniq<ColumnDataCollection>(context, plan_types, ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR);
-
-	DataChunk chunk;
-	chunk.Initialize(allocator, op.types);
-	for (idx_t i = 0; i < keys.size(); i++) {
-		chunk.SetValue(0, chunk.size(), Value(keys[i]));
-		chunk.SetValue(1, chunk.size(), Value(values[i]));
-		chunk.SetCardinality(chunk.size() + 1);
-		if (chunk.size() == STANDARD_VECTOR_SIZE) {
-			collection->Append(chunk);
-			chunk.Reset();
-		}
-	}
-	collection->Append(chunk);
-
-	// create a chunk scan to output the result
-	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
-	                                                    op.estimated_cardinality, std::move(collection));
-	return std::move(chunk_scan);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_export.cpp b/src/duckdb/src/execution/physical_plan/plan_export.cpp
deleted file mode 100644
index ff04115e3..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_export.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/execution/operator/persistent/physical_export.hpp"
-#include "duckdb/planner/operator/logical_export.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExport &op) {
-	auto export_node = make_uniq<PhysicalExport>(op.types, op.function, std::move(op.copy_info),
-	                                             op.estimated_cardinality, std::move(op.exported_tables));
-	// plan the underlying copy statements, if any
-	if (!op.children.empty()) {
-		auto plan = CreatePlan(*op.children[0]);
-		export_node->children.push_back(std::move(plan));
-	}
-	return std::move(export_node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_expression_get.cpp b/src/duckdb/src/execution/physical_plan/plan_expression_get.cpp
deleted file mode 100644
index b63726742..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_expression_get.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/execution/operator/scan/physical_expression_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExpressionGet &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-
-	auto expr_scan = make_uniq<PhysicalExpressionScan>(op.types, std::move(op.expressions), op.estimated_cardinality);
-	expr_scan->children.push_back(std::move(plan));
-	if (!expr_scan->IsFoldable()) {
-		return std::move(expr_scan);
-	}
-	auto &allocator = Allocator::Get(context);
-	// simple expression scan (i.e. no subqueries to evaluate and no prepared statement parameters)
-	// we can evaluate all the expressions right now and turn this into a chunk collection scan
-	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
-	                                                    expr_scan->expressions.size(),
-	                                                    make_uniq<ColumnDataCollection>(context, op.types));
-
-	DataChunk chunk;
-	chunk.Initialize(allocator, op.types);
-
-	ColumnDataAppendState append_state;
-	chunk_scan->collection->InitializeAppend(append_state);
-	for (idx_t expression_idx = 0; expression_idx < expr_scan->expressions.size(); expression_idx++) {
-		chunk.Reset();
-		expr_scan->EvaluateExpression(context, expression_idx, nullptr, chunk);
-		chunk_scan->collection->Append(append_state, chunk);
-	}
-	return std::move(chunk_scan);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_filter.cpp b/src/duckdb/src/execution/physical_plan/plan_filter.cpp
deleted file mode 100644
index 50c1253d0..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_filter.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/execution/operator/filter/physical_filter.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalFilter &op) {
-	D_ASSERT(op.children.size() == 1);
-	unique_ptr<PhysicalOperator> plan = CreatePlan(*op.children[0]);
-	if (!op.expressions.empty()) {
-		D_ASSERT(plan->types.size() > 0);
-		// create a filter if there is anything to filter
-		auto filter = make_uniq<PhysicalFilter>(plan->types, std::move(op.expressions), op.estimated_cardinality);
-		filter->children.push_back(std::move(plan));
-		plan = std::move(filter);
-	}
-	if (op.HasProjectionMap()) {
-		// there is a projection map, generate a physical projection
-		vector<unique_ptr<Expression>> select_list;
-		for (idx_t i = 0; i < op.projection_map.size(); i++) {
-			select_list.push_back(make_uniq<BoundReferenceExpression>(op.types[i], op.projection_map[i]));
-		}
-		auto proj = make_uniq<PhysicalProjection>(op.types, std::move(select_list), op.estimated_cardinality);
-		proj->children.push_back(std::move(plan));
-		plan = std::move(proj);
-	}
-	return plan;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_get.cpp b/src/duckdb/src/execution/physical_plan/plan_get.cpp
deleted file mode 100644
index 3b5d940eb..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_get.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_expression_scan.hpp"
-#include "duckdb/execution/operator/scan/physical_dummy_scan.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/operator/projection/physical_tableinout_function.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/execution/operator/filter/physical_filter.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableFilterSet> CreateTableFilterSet(TableFilterSet &table_filters, const vector<ColumnIndex> &column_ids) {
-	// create the table filter map
-	auto table_filter_set = make_uniq<TableFilterSet>();
-	for (auto &table_filter : table_filters.filters) {
-		// find the relative column index from the absolute column index into the table
-		optional_idx column_index;
-		for (idx_t i = 0; i < column_ids.size(); i++) {
-			if (table_filter.first == column_ids[i].GetPrimaryIndex()) {
-				column_index = i;
-				break;
-			}
-		}
-		if (!column_index.IsValid()) {
-			throw InternalException("Could not find column index for table filter");
-		}
-		table_filter_set->filters[column_index.GetIndex()] = std::move(table_filter.second);
-	}
-	return table_filter_set;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
-	auto column_ids = op.GetColumnIds();
-	if (!op.children.empty()) {
-		auto child_node = CreatePlan(std::move(op.children[0]));
-		// this is for table producing functions that consume subquery results
-		// push a projection node with casts if required
-		if (child_node->types.size() < op.input_table_types.size()) {
-			throw InternalException(
-			    "Mismatch between input table types and child node types - expected %llu but got %llu",
-			    op.input_table_types.size(), child_node->types.size());
-		}
-		vector<LogicalType> return_types;
-		vector<unique_ptr<Expression>> expressions;
-		bool any_cast_required = false;
-		for (idx_t proj_idx = 0; proj_idx < child_node->types.size(); proj_idx++) {
-			auto ref = make_uniq<BoundReferenceExpression>(child_node->types[proj_idx], proj_idx);
-			auto &target_type =
-			    proj_idx < op.input_table_types.size() ? op.input_table_types[proj_idx] : child_node->types[proj_idx];
-			if (child_node->types[proj_idx] != target_type) {
-				// cast is required - push a cast
-				any_cast_required = true;
-				auto cast = BoundCastExpression::AddCastToType(context, std::move(ref), target_type);
-				expressions.push_back(std::move(cast));
-			} else {
-				expressions.push_back(std::move(ref));
-			}
-			return_types.push_back(target_type);
-		}
-		if (any_cast_required) {
-			auto proj = make_uniq<PhysicalProjection>(std::move(return_types), std::move(expressions),
-			                                          child_node->estimated_cardinality);
-			proj->children.push_back(std::move(child_node));
-			child_node = std::move(proj);
-		}
-
-		auto node = make_uniq<PhysicalTableInOutFunction>(op.types, op.function, std::move(op.bind_data), column_ids,
-		                                                  op.estimated_cardinality, std::move(op.projected_input));
-		node->children.push_back(std::move(child_node));
-		return std::move(node);
-	}
-	if (!op.projected_input.empty()) {
-		throw InternalException("LogicalGet::project_input can only be set for table-in-out functions");
-	}
-
-	unique_ptr<TableFilterSet> table_filters;
-	if (!op.table_filters.filters.empty()) {
-		table_filters = CreateTableFilterSet(op.table_filters, column_ids);
-	}
-
-	if (op.function.dependency) {
-		op.function.dependency(dependencies, op.bind_data.get());
-	}
-	unique_ptr<PhysicalFilter> filter;
-
-	auto &projection_ids = op.projection_ids;
-
-	if (table_filters && op.function.supports_pushdown_type) {
-		vector<unique_ptr<Expression>> select_list;
-		unique_ptr<Expression> unsupported_filter;
-		unordered_set<idx_t> to_remove;
-		for (auto &entry : table_filters->filters) {
-			auto column_id = column_ids[entry.first].GetPrimaryIndex();
-			auto &type = op.returned_types[column_id];
-			if (!op.function.supports_pushdown_type(type)) {
-				idx_t column_id_filter = entry.first;
-				bool found_projection = false;
-				for (idx_t i = 0; i < projection_ids.size(); i++) {
-					if (column_ids[projection_ids[i]] == column_ids[entry.first]) {
-						column_id_filter = i;
-						found_projection = true;
-						break;
-					}
-				}
-				if (!found_projection) {
-					projection_ids.push_back(entry.first);
-					column_id_filter = projection_ids.size() - 1;
-				}
-				auto column = make_uniq<BoundReferenceExpression>(type, column_id_filter);
-				select_list.push_back(entry.second->ToExpression(*column));
-				to_remove.insert(entry.first);
-			}
-		}
-		for (auto &col : to_remove) {
-			table_filters->filters.erase(col);
-		}
-
-		if (!select_list.empty()) {
-			vector<LogicalType> filter_types;
-			for (auto &c : projection_ids) {
-				auto column_id = column_ids[c].GetPrimaryIndex();
-				filter_types.push_back(op.returned_types[column_id]);
-			}
-			filter = make_uniq<PhysicalFilter>(filter_types, std::move(select_list), op.estimated_cardinality);
-		}
-	}
-	op.ResolveOperatorTypes();
-	// create the table scan node
-	if (!op.function.projection_pushdown) {
-		// function does not support projection pushdown
-		auto node = make_uniq<PhysicalTableScan>(
-		    op.returned_types, op.function, std::move(op.bind_data), op.returned_types, column_ids, vector<column_t>(),
-		    op.names, std::move(table_filters), op.estimated_cardinality, op.extra_info, std::move(op.parameters));
-		// first check if an additional projection is necessary
-		if (column_ids.size() == op.returned_types.size()) {
-			bool projection_necessary = false;
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				if (column_ids[i].GetPrimaryIndex() != i) {
-					projection_necessary = true;
-					break;
-				}
-			}
-			if (!projection_necessary) {
-				// a projection is not necessary if all columns have been requested in-order
-				// in that case we just return the node
-				if (filter) {
-					filter->children.push_back(std::move(node));
-					return std::move(filter);
-				}
-				return std::move(node);
-			}
-		}
-		// push a projection on top that does the projection
-		vector<LogicalType> types;
-		vector<unique_ptr<Expression>> expressions;
-		for (auto &column_id : column_ids) {
-			if (column_id.IsRowIdColumn()) {
-				types.emplace_back(op.GetRowIdType());
-				// Now how to make that a constant expression.
-				expressions.push_back(make_uniq<BoundConstantExpression>(Value(op.GetRowIdType())));
-			} else {
-				auto col_id = column_id.GetPrimaryIndex();
-				auto type = op.returned_types[col_id];
-				types.push_back(type);
-				expressions.push_back(make_uniq<BoundReferenceExpression>(type, col_id));
-			}
-		}
-		unique_ptr<PhysicalProjection> projection =
-		    make_uniq<PhysicalProjection>(std::move(types), std::move(expressions), op.estimated_cardinality);
-		if (filter) {
-			filter->children.push_back(std::move(node));
-			projection->children.push_back(std::move(filter));
-		} else {
-			projection->children.push_back(std::move(node));
-		}
-		return std::move(projection);
-	} else {
-		auto node = make_uniq<PhysicalTableScan>(op.types, op.function, std::move(op.bind_data), op.returned_types,
-		                                         column_ids, op.projection_ids, op.names, std::move(table_filters),
-		                                         op.estimated_cardinality, op.extra_info, std::move(op.parameters));
-		node->dynamic_filters = op.dynamic_filters;
-		if (filter) {
-			filter->children.push_back(std::move(node));
-			return std::move(filter);
-		}
-		return std::move(node);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_insert.cpp b/src/duckdb/src/execution/physical_plan/plan_insert.cpp
deleted file mode 100644
index 2342a1ef0..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_insert.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/operator/persistent/physical_insert.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_insert.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/execution/operator/persistent/physical_batch_insert.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-
-namespace duckdb {
-
-static OrderPreservationType OrderPreservationRecursive(PhysicalOperator &op) {
-	if (op.IsSource()) {
-		return op.SourceOrder();
-	}
-
-	idx_t child_idx = 0;
-	for (auto &child : op.children) {
-		// Do not take the materialization phase of physical CTEs into account
-		if (op.type == PhysicalOperatorType::CTE && child_idx == 0) {
-			continue;
-		}
-		auto child_preservation = OrderPreservationRecursive(*child);
-		if (child_preservation != OrderPreservationType::INSERTION_ORDER) {
-			return child_preservation;
-		}
-		child_idx++;
-	}
-	return OrderPreservationType::INSERTION_ORDER;
-}
-
-bool PhysicalPlanGenerator::PreserveInsertionOrder(ClientContext &context, PhysicalOperator &plan) {
-	auto &config = DBConfig::GetConfig(context);
-
-	auto preservation_type = OrderPreservationRecursive(plan);
-	if (preservation_type == OrderPreservationType::FIXED_ORDER) {
-		// always need to maintain preservation order
-		return true;
-	}
-	if (preservation_type == OrderPreservationType::NO_ORDER) {
-		// never need to preserve order
-		return false;
-	}
-	// preserve insertion order - check flags
-	if (!config.options.preserve_insertion_order) {
-		// preserving insertion order is disabled by config
-		return false;
-	}
-	return true;
-}
-
-bool PhysicalPlanGenerator::PreserveInsertionOrder(PhysicalOperator &plan) {
-	return PreserveInsertionOrder(context, plan);
-}
-
-bool PhysicalPlanGenerator::UseBatchIndex(ClientContext &context, PhysicalOperator &plan) {
-	// TODO: always preserve order if query contains ORDER BY
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-	if (scheduler.NumberOfThreads() == 1) {
-		// batch index usage only makes sense if we are using multiple threads
-		return false;
-	}
-	if (!plan.AllSourcesSupportBatchIndex()) {
-		// batch index is not supported
-		return false;
-	}
-	return true;
-}
-
-bool PhysicalPlanGenerator::UseBatchIndex(PhysicalOperator &plan) {
-	return UseBatchIndex(context, plan);
-}
-
-unique_ptr<PhysicalOperator> DuckCatalog::PlanInsert(ClientContext &context, LogicalInsert &op,
-                                                     unique_ptr<PhysicalOperator> plan) {
-	bool parallel_streaming_insert = !PhysicalPlanGenerator::PreserveInsertionOrder(context, *plan);
-	bool use_batch_index = PhysicalPlanGenerator::UseBatchIndex(context, *plan);
-	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-	if (op.return_chunk) {
-		// not supported for RETURNING (yet?)
-		parallel_streaming_insert = false;
-		use_batch_index = false;
-	}
-	if (op.action_type != OnConflictAction::THROW) {
-		// We don't support ON CONFLICT clause in batch insertion operation currently
-		use_batch_index = false;
-	}
-	if (op.action_type == OnConflictAction::UPDATE) {
-		// When we potentially need to perform updates, we have to check that row is not updated twice
-		// that currently needs to be done for every chunk, which would add a huge bottleneck to parallelized insertion
-		parallel_streaming_insert = false;
-	}
-	unique_ptr<PhysicalOperator> insert;
-	if (use_batch_index && !parallel_streaming_insert) {
-		insert = make_uniq<PhysicalBatchInsert>(op.types, op.table, op.column_index_map, std::move(op.bound_defaults),
-		                                        std::move(op.bound_constraints), op.estimated_cardinality);
-	} else {
-		insert = make_uniq<PhysicalInsert>(
-		    op.types, op.table, op.column_index_map, std::move(op.bound_defaults), std::move(op.bound_constraints),
-		    std::move(op.expressions), std::move(op.set_columns), std::move(op.set_types), op.estimated_cardinality,
-		    op.return_chunk, parallel_streaming_insert && num_threads > 1, op.action_type,
-		    std::move(op.on_conflict_condition), std::move(op.do_update_condition), std::move(op.on_conflict_filter),
-		    std::move(op.columns_to_fetch), op.update_is_del_and_insert);
-	}
-	D_ASSERT(plan);
-	insert->children.push_back(std::move(plan));
-	return insert;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op) {
-	unique_ptr<PhysicalOperator> plan;
-	if (!op.children.empty()) {
-		D_ASSERT(op.children.size() == 1);
-		plan = CreatePlan(*op.children[0]);
-	}
-	dependencies.AddDependency(op.table);
-	return op.table.catalog.PlanInsert(context, op, std::move(plan));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_limit.cpp b/src/duckdb/src/execution/physical_plan/plan_limit.cpp
deleted file mode 100644
index 508f1c889..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_limit.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_limit.hpp"
-#include "duckdb/execution/operator/helper/physical_streaming_limit.hpp"
-#include "duckdb/execution/operator/helper/physical_limit_percent.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-
-namespace duckdb {
-
-bool UseBatchLimit(PhysicalOperator &child_node, BoundLimitNode &limit_val, BoundLimitNode &offset_val) {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-	return true;
-#else
-	// we only want to use the batch limit when we are executing a complex query (e.g. involving a filter or join)
-	// if we are doing a limit over a table scan we are otherwise scanning a lot of rows just to throw them away
-	reference<PhysicalOperator> current_ref(child_node);
-	bool finished = false;
-	while (!finished) {
-		auto &current_op = current_ref.get();
-		switch (current_op.type) {
-		case PhysicalOperatorType::TABLE_SCAN:
-			return false;
-		case PhysicalOperatorType::PROJECTION:
-			current_ref = *current_op.children[0];
-			break;
-		default:
-			finished = true;
-			break;
-		}
-	}
-	// we only use batch limit when we are computing a small amount of values
-	// as the batch limit materializes this many rows PER thread
-	static constexpr const idx_t BATCH_LIMIT_THRESHOLD = 10000;
-
-	if (limit_val.Type() != LimitNodeType::CONSTANT_VALUE) {
-		return false;
-	}
-	if (offset_val.Type() == LimitNodeType::EXPRESSION_VALUE) {
-		return false;
-	}
-	idx_t total_offset = limit_val.GetConstantValue();
-	if (offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-		total_offset += offset_val.GetConstantValue();
-	}
-	return total_offset <= BATCH_LIMIT_THRESHOLD;
-#endif
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalLimit &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	unique_ptr<PhysicalOperator> limit;
-	switch (op.limit_val.Type()) {
-	case LimitNodeType::EXPRESSION_PERCENTAGE:
-	case LimitNodeType::CONSTANT_PERCENTAGE:
-		limit = make_uniq<PhysicalLimitPercent>(op.types, std::move(op.limit_val), std::move(op.offset_val),
-		                                        op.estimated_cardinality);
-		break;
-	default:
-		if (!PreserveInsertionOrder(*plan)) {
-			// use parallel streaming limit if insertion order is not important
-			limit = make_uniq<PhysicalStreamingLimit>(op.types, std::move(op.limit_val), std::move(op.offset_val),
-			                                          op.estimated_cardinality, true);
-		} else {
-			// maintaining insertion order is important
-			if (UseBatchIndex(*plan) && UseBatchLimit(*plan, op.limit_val, op.offset_val)) {
-				// source supports batch index: use parallel batch limit
-				limit = make_uniq<PhysicalLimit>(op.types, std::move(op.limit_val), std::move(op.offset_val),
-				                                 op.estimated_cardinality);
-			} else {
-				// source does not support batch index: use a non-parallel streaming limit
-				limit = make_uniq<PhysicalStreamingLimit>(op.types, std::move(op.limit_val), std::move(op.offset_val),
-				                                          op.estimated_cardinality, false);
-			}
-		}
-		break;
-	}
-
-	limit->children.push_back(std::move(plan));
-	return limit;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_order.cpp b/src/duckdb/src/execution/physical_plan/plan_order.cpp
deleted file mode 100644
index 449e7ee81..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_order.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "duckdb/execution/operator/order/physical_order.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOrder &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-	if (!op.orders.empty()) {
-		vector<idx_t> projection_map;
-		if (op.HasProjectionMap()) {
-			projection_map = std::move(op.projection_map);
-		} else {
-			for (idx_t i = 0; i < plan->types.size(); i++) {
-				projection_map.push_back(i);
-			}
-		}
-		auto order = make_uniq<PhysicalOrder>(op.types, std::move(op.orders), std::move(projection_map),
-		                                      op.estimated_cardinality);
-		order->children.push_back(std::move(plan));
-		plan = std::move(order);
-	}
-	return plan;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_pivot.cpp b/src/duckdb/src/execution/physical_plan/plan_pivot.cpp
deleted file mode 100644
index bca3bc909..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_pivot.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_pivot.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_pivot.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPivot &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto child_plan = CreatePlan(*op.children[0]);
-	auto pivot = make_uniq<PhysicalPivot>(std::move(op.types), std::move(child_plan), std::move(op.bound_pivot));
-	return std::move(pivot);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_positional_join.cpp b/src/duckdb/src/execution/physical_plan/plan_positional_join.cpp
deleted file mode 100644
index 6fd20ed4e..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_positional_join.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "duckdb/execution/operator/join/physical_positional_join.hpp"
-#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_positional_join.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPositionalJoin &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-	switch (left->type) {
-	case PhysicalOperatorType::TABLE_SCAN:
-	case PhysicalOperatorType::POSITIONAL_SCAN:
-		switch (right->type) {
-		case PhysicalOperatorType::TABLE_SCAN:
-		case PhysicalOperatorType::POSITIONAL_SCAN:
-			return make_uniq<PhysicalPositionalScan>(op.types, std::move(left), std::move(right));
-		default:
-			break;
-		}
-		break;
-	default:
-		break;
-	}
-
-	return make_uniq<PhysicalPositionalJoin>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_pragma.cpp b/src/duckdb/src/execution/physical_plan/plan_pragma.cpp
deleted file mode 100644
index c0303965f..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_pragma.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_pragma.hpp"
-
-#include "duckdb/execution/operator/helper/physical_pragma.hpp"
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPragma &op) {
-	return make_uniq<PhysicalPragma>(std::move(op.info), op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_prepare.cpp b/src/duckdb/src/execution/physical_plan/plan_prepare.cpp
deleted file mode 100644
index 191377b1f..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_prepare.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/execution/operator/scan/physical_dummy_scan.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_prepare.hpp"
-#include "duckdb/execution/operator/helper/physical_prepare.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPrepare &op) {
-	D_ASSERT(op.children.size() <= 1);
-
-	// generate physical plan only when all parameters are bound (otherwise the physical plan won't be used anyway)
-	if (op.prepared->properties.bound_all_parameters && !op.children.empty()) {
-		auto plan = CreatePlan(*op.children[0]);
-		op.prepared->types = plan->types;
-		op.prepared->plan = std::move(plan);
-	}
-
-	return make_uniq<PhysicalPrepare>(op.name, std::move(op.prepared), op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_projection.cpp b/src/duckdb/src/execution/physical_plan/plan_projection.cpp
deleted file mode 100644
index f5f262f55..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_projection.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalProjection &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-
-#ifdef DEBUG
-	for (auto &expr : op.expressions) {
-		D_ASSERT(!expr->IsWindow());
-		D_ASSERT(!expr->IsAggregate());
-	}
-#endif
-	if (plan->types.size() == op.types.size()) {
-		// check if this projection can be omitted entirely
-		// this happens if a projection simply emits the columns in the same order
-		// e.g. PROJECTION(#0, #1, #2, #3, ...)
-		bool omit_projection = true;
-		for (idx_t i = 0; i < op.types.size(); i++) {
-			if (op.expressions[i]->GetExpressionType() == ExpressionType::BOUND_REF) {
-				auto &bound_ref = op.expressions[i]->Cast<BoundReferenceExpression>();
-				if (bound_ref.index == i) {
-					continue;
-				}
-			}
-			omit_projection = false;
-			break;
-		}
-		if (omit_projection) {
-			// the projection only directly projects the child' columns: omit it entirely
-			return plan;
-		}
-	}
-
-	auto projection = make_uniq<PhysicalProjection>(op.types, std::move(op.expressions), op.estimated_cardinality);
-	projection->children.push_back(std::move(plan));
-	return std::move(projection);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_recursive_cte.cpp b/src/duckdb/src/execution/physical_plan/plan_recursive_cte.cpp
deleted file mode 100644
index 7933dd166..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_recursive_cte.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/logical_cteref.hpp"
-#include "duckdb/planner/operator/logical_recursive_cte.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalRecursiveCTE &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	// Create the working_table that the PhysicalRecursiveCTE will use for evaluation.
-	auto working_table = make_shared_ptr<ColumnDataCollection>(context, op.types);
-
-	// Add the ColumnDataCollection to the context of this PhysicalPlanGenerator
-	recursive_cte_tables[op.table_index] = working_table;
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-
-	auto cte = make_uniq<PhysicalRecursiveCTE>(op.ctename, op.table_index, op.types, op.union_all, std::move(left),
-	                                           std::move(right), op.estimated_cardinality);
-	cte->working_table = working_table;
-
-	return std::move(cte);
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op) {
-	D_ASSERT(op.children.empty());
-
-	// Check if this LogicalCTERef is supposed to scan a materialized CTE.
-	if (op.materialized_cte == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-		// Lookup if there is a materialized CTE for the cte_index.
-		auto materialized_cte = materialized_ctes.find(op.cte_index);
-
-		// If this check fails, this is a reference to a materialized recursive CTE.
-		if (materialized_cte != materialized_ctes.end()) {
-			auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.chunk_types, PhysicalOperatorType::CTE_SCAN,
-			                                                    op.estimated_cardinality, op.cte_index);
-
-			auto cte = recursive_cte_tables.find(op.cte_index);
-			if (cte == recursive_cte_tables.end()) {
-				throw InvalidInputException("Referenced materialized CTE does not exist.");
-			}
-			chunk_scan->collection = cte->second.get();
-			materialized_cte->second.push_back(*chunk_scan.get());
-
-			return std::move(chunk_scan);
-		}
-	}
-
-	// CreatePlan of a LogicalRecursiveCTE must have happened before.
-	auto cte = recursive_cte_tables.find(op.cte_index);
-	if (cte == recursive_cte_tables.end()) {
-		throw InvalidInputException("Referenced recursive CTE does not exist.");
-	}
-
-	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(
-	    cte->second.get()->Types(), PhysicalOperatorType::RECURSIVE_CTE_SCAN, op.estimated_cardinality, op.cte_index);
-
-	chunk_scan->collection = cte->second.get();
-
-	return std::move(chunk_scan);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_reset.cpp b/src/duckdb/src/execution/physical_plan/plan_reset.cpp
deleted file mode 100644
index 2f8aa3698..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_reset.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_reset.hpp"
-#include "duckdb/execution/operator/helper/physical_reset.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalReset &op) {
-	return make_uniq<PhysicalReset>(op.name, op.scope, op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_sample.cpp b/src/duckdb/src/execution/physical_plan/plan_sample.cpp
deleted file mode 100644
index be5578477..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_sample.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_reservoir_sample.hpp"
-#include "duckdb/execution/operator/helper/physical_streaming_sample.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/random_engine.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSample &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	unique_ptr<PhysicalOperator> sample;
-	if (!op.sample_options->seed.IsValid()) {
-		auto &random_engine = RandomEngine::Get(context);
-		op.sample_options->SetSeed(random_engine.NextRandomInteger());
-	}
-	switch (op.sample_options->method) {
-	case SampleMethod::RESERVOIR_SAMPLE:
-		sample = make_uniq<PhysicalReservoirSample>(op.types, std::move(op.sample_options), op.estimated_cardinality);
-		break;
-	case SampleMethod::SYSTEM_SAMPLE:
-	case SampleMethod::BERNOULLI_SAMPLE:
-		if (!op.sample_options->is_percentage) {
-			throw ParserException("Sample method %s cannot be used with a discrete sample count, either switch to "
-			                      "reservoir sampling or use a sample_size",
-			                      EnumUtil::ToString(op.sample_options->method));
-		}
-		sample = make_uniq<PhysicalStreamingSample>(
-		    op.types, op.sample_options->method, op.sample_options->sample_size.GetValue<double>(),
-		    static_cast<int64_t>(op.sample_options->seed.GetIndex()), op.estimated_cardinality);
-		break;
-	default:
-		throw InternalException("Unimplemented sample method");
-	}
-	sample->children.push_back(std::move(plan));
-	return sample;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_set.cpp b/src/duckdb/src/execution/physical_plan/plan_set.cpp
deleted file mode 100644
index fe09cb317..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_set.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_set.hpp"
-#include "duckdb/execution/operator/helper/physical_set.hpp"
-#include "duckdb/execution/operator/helper/physical_set_variable.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSet &op) {
-	if (!op.children.empty()) {
-		// set variable
-		auto child = CreatePlan(*op.children[0]);
-		auto set_variable = make_uniq<PhysicalSetVariable>(std::move(op.name), op.estimated_cardinality);
-		set_variable->children.push_back(std::move(child));
-		return std::move(set_variable);
-	}
-	// set config setting
-	return make_uniq<PhysicalSet>(op.name, op.value, op.scope, op.estimated_cardinality);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp b/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp
deleted file mode 100644
index dada24fcf..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/execution/operator/aggregate/physical_window.hpp"
-#include "duckdb/execution/operator/join/physical_hash_join.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/operator/set/physical_union.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-
-namespace duckdb {
-
-static vector<unique_ptr<Expression>> CreatePartitionedRowNumExpression(const vector<LogicalType> &types) {
-	vector<unique_ptr<Expression>> res;
-	auto expr =
-	    make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT, nullptr, nullptr);
-	expr->start = WindowBoundary::UNBOUNDED_PRECEDING;
-	expr->end = WindowBoundary::UNBOUNDED_FOLLOWING;
-	for (idx_t i = 0; i < types.size(); i++) {
-		expr->partitions.push_back(make_uniq<BoundReferenceExpression>(types[i], i));
-	}
-	res.push_back(std::move(expr));
-	return res;
-}
-
-static JoinCondition CreateNotDistinctComparison(const LogicalType &type, idx_t i) {
-	JoinCondition cond;
-	cond.left = make_uniq<BoundReferenceExpression>(type, i);
-	cond.right = make_uniq<BoundReferenceExpression>(type, i);
-	cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-	return cond;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSetOperation &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	unique_ptr<PhysicalOperator> result;
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-
-	if (left->GetTypes() != right->GetTypes()) {
-		throw InvalidInputException("Type mismatch for SET OPERATION");
-	}
-
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_UNION:
-		// UNION
-		result = make_uniq<PhysicalUnion>(op.types, std::move(left), std::move(right), op.estimated_cardinality,
-		                                  op.allow_out_of_order);
-		break;
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT: {
-		auto &types = left->GetTypes();
-		vector<JoinCondition> conditions;
-		// create equality condition for all columns
-		for (idx_t i = 0; i < types.size(); i++) {
-			conditions.push_back(CreateNotDistinctComparison(types[i], i));
-		}
-		// For EXCEPT ALL / INTERSECT ALL we push a window operator with a ROW_NUMBER into the scans and join to get bag
-		// semantics.
-		if (op.setop_all) {
-			vector<LogicalType> window_types = types;
-			window_types.push_back(LogicalType::BIGINT);
-
-			auto window_left = make_uniq<PhysicalWindow>(window_types, CreatePartitionedRowNumExpression(types),
-			                                             left->estimated_cardinality);
-			window_left->children.push_back(std::move(left));
-			left = std::move(window_left);
-
-			auto window_right = make_uniq<PhysicalWindow>(window_types, CreatePartitionedRowNumExpression(types),
-			                                              right->estimated_cardinality);
-			window_right->children.push_back(std::move(right));
-			right = std::move(window_right);
-
-			// add window expression result to join condition
-			conditions.push_back(CreateNotDistinctComparison(LogicalType::BIGINT, types.size()));
-			// join (created below) now includes the row number result column
-			op.types.push_back(LogicalType::BIGINT);
-		}
-
-		// EXCEPT is ANTI join
-		// INTERSECT is SEMI join
-
-		JoinType join_type = op.type == LogicalOperatorType::LOGICAL_EXCEPT ? JoinType::ANTI : JoinType::SEMI;
-		result = make_uniq<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(conditions), join_type,
-		                                     op.estimated_cardinality);
-
-		// For EXCEPT ALL / INTERSECT ALL we need to remove the row number column again
-		if (op.setop_all) {
-			vector<unique_ptr<Expression>> projection_select_list;
-			for (idx_t i = 0; i < types.size(); i++) {
-				projection_select_list.push_back(make_uniq<BoundReferenceExpression>(types[i], i));
-			}
-			auto projection =
-			    make_uniq<PhysicalProjection>(types, std::move(projection_select_list), op.estimated_cardinality);
-			projection->children.push_back(std::move(result));
-			result = std::move(projection);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unexpected operator type for set operation");
-	}
-
-	// if the ALL specifier is not given, we have to ensure distinct results. Hence, push a GROUP BY ALL
-	if (!op.setop_all) { // no ALL, use distinct semantics
-		auto &types = result->GetTypes();
-		vector<unique_ptr<Expression>> groups, aggregates /* left empty */;
-		for (idx_t i = 0; i < types.size(); i++) {
-			groups.push_back(make_uniq<BoundReferenceExpression>(types[i], i));
-		}
-		auto groupby = make_uniq<PhysicalHashAggregate>(context, op.types, std::move(aggregates), std::move(groups),
-		                                                result->estimated_cardinality);
-		groupby->children.push_back(std::move(result));
-		result = std::move(groupby);
-	}
-
-	D_ASSERT(result);
-	return (result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_simple.cpp b/src/duckdb/src/execution/physical_plan/plan_simple.cpp
deleted file mode 100644
index 7c03ff4f0..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_simple.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_load.hpp"
-#include "duckdb/execution/operator/helper/physical_transaction.hpp"
-#include "duckdb/execution/operator/helper/physical_update_extensions.hpp"
-#include "duckdb/execution/operator/helper/physical_vacuum.hpp"
-#include "duckdb/execution/operator/schema/physical_alter.hpp"
-#include "duckdb/execution/operator/schema/physical_attach.hpp"
-#include "duckdb/execution/operator/schema/physical_create_schema.hpp"
-#include "duckdb/execution/operator/schema/physical_create_view.hpp"
-#include "duckdb/execution/operator/schema/physical_detach.hpp"
-#include "duckdb/execution/operator/schema/physical_drop.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_ALTER:
-		return make_uniq<PhysicalAlter>(unique_ptr_cast<ParseInfo, AlterInfo>(std::move(op.info)),
-		                                op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_DROP:
-		return make_uniq<PhysicalDrop>(unique_ptr_cast<ParseInfo, DropInfo>(std::move(op.info)),
-		                               op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		return make_uniq<PhysicalTransaction>(unique_ptr_cast<ParseInfo, TransactionInfo>(std::move(op.info)),
-		                                      op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_LOAD:
-		return make_uniq<PhysicalLoad>(unique_ptr_cast<ParseInfo, LoadInfo>(std::move(op.info)),
-		                               op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		return make_uniq<PhysicalAttach>(unique_ptr_cast<ParseInfo, AttachInfo>(std::move(op.info)),
-		                                 op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_DETACH:
-		return make_uniq<PhysicalDetach>(unique_ptr_cast<ParseInfo, DetachInfo>(std::move(op.info)),
-		                                 op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS:
-		return make_uniq<PhysicalUpdateExtensions>(unique_ptr_cast<ParseInfo, UpdateExtensionsInfo>(std::move(op.info)),
-		                                           op.estimated_cardinality);
-	default:
-		throw NotImplementedException("Unimplemented type for logical simple operator");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_top_n.cpp b/src/duckdb/src/execution/physical_plan/plan_top_n.cpp
deleted file mode 100644
index 700021876..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_top_n.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/execution/operator/order/physical_top_n.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_top_n.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalTopN &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	auto top_n =
-	    make_uniq<PhysicalTopN>(op.types, std::move(op.orders), NumericCast<idx_t>(op.limit),
-	                            NumericCast<idx_t>(op.offset), std::move(op.dynamic_filter), op.estimated_cardinality);
-	top_n->children.push_back(std::move(plan));
-	return std::move(top_n);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_unnest.cpp b/src/duckdb/src/execution/physical_plan/plan_unnest.cpp
deleted file mode 100644
index 992da4306..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_unnest.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/execution/operator/projection/physical_unnest.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_unnest.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUnnest &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-	auto unnest = make_uniq<PhysicalUnnest>(op.types, std::move(op.expressions), op.estimated_cardinality);
-	unnest->children.push_back(std::move(plan));
-	return std::move(unnest);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_update.cpp b/src/duckdb/src/execution/physical_plan/plan_update.cpp
deleted file mode 100644
index b35914233..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_update.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/operator/persistent/physical_update.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> DuckCatalog::PlanUpdate(ClientContext &context, LogicalUpdate &op,
-                                                     unique_ptr<PhysicalOperator> plan) {
-	auto update = make_uniq<PhysicalUpdate>(op.types, op.table, op.table.GetStorage(), op.columns,
-	                                        std::move(op.expressions), std::move(op.bound_defaults),
-	                                        std::move(op.bound_constraints), op.estimated_cardinality, op.return_chunk);
-
-	update->update_is_del_and_insert = op.update_is_del_and_insert;
-	update->children.push_back(std::move(plan));
-	return std::move(update);
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	dependencies.AddDependency(op.table);
-	return op.table.catalog.PlanUpdate(context, op, std::move(plan));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_vacuum.cpp b/src/duckdb/src/execution/physical_plan/plan_vacuum.cpp
deleted file mode 100644
index 3f1f88b3d..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_vacuum.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/execution/operator/helper/physical_vacuum.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator/logical_vacuum.hpp"
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalVacuum &op) {
-	auto result = make_uniq<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(std::move(op.info)), op.table,
-	                                        std::move(op.column_id_map), op.estimated_cardinality);
-	if (!op.children.empty()) {
-		auto child = CreatePlan(*op.children[0]);
-		result->children.push_back(std::move(child));
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan/plan_window.cpp b/src/duckdb/src/execution/physical_plan/plan_window.cpp
deleted file mode 100644
index f294d9324..000000000
--- a/src/duckdb/src/execution/physical_plan/plan_window.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-#include "duckdb/execution/operator/aggregate/physical_streaming_window.hpp"
-#include "duckdb/execution/operator/aggregate/physical_window.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-
-#include <numeric>
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-#ifdef DEBUG
-	for (auto &expr : op.expressions) {
-		D_ASSERT(expr->IsWindow());
-	}
-#endif
-
-	op.estimated_cardinality = op.EstimateCardinality(context);
-
-	// Slice types
-	auto types = op.types;
-	const auto input_width = types.size() - op.expressions.size();
-	types.resize(input_width);
-
-	// Identify streaming windows
-	const bool enable_optimizer = ClientConfig::GetConfig(context).enable_optimizer;
-	vector<idx_t> blocking_windows;
-	vector<idx_t> streaming_windows;
-	for (idx_t expr_idx = 0; expr_idx < op.expressions.size(); expr_idx++) {
-		if (enable_optimizer && PhysicalStreamingWindow::IsStreamingFunction(context, op.expressions[expr_idx])) {
-			streaming_windows.push_back(expr_idx);
-		} else {
-			blocking_windows.push_back(expr_idx);
-		}
-	}
-
-	// Process the window functions by sharing the partition/order definitions
-	unordered_map<idx_t, idx_t> projection_map;
-	vector<vector<idx_t>> window_expressions;
-	idx_t blocking_count = 0;
-	auto output_pos = input_width;
-	while (!blocking_windows.empty() || !streaming_windows.empty()) {
-		const bool process_streaming = blocking_windows.empty();
-		auto &remaining = process_streaming ? streaming_windows : blocking_windows;
-		blocking_count += process_streaming ? 0 : 1;
-
-		// Find all functions that share the partitioning of the first remaining expression
-		auto over_idx = remaining[0];
-
-		vector<idx_t> matching;
-		vector<idx_t> unprocessed;
-		for (const auto &expr_idx : remaining) {
-			D_ASSERT(op.expressions[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto &wexpr = op.expressions[expr_idx]->Cast<BoundWindowExpression>();
-
-			// Just record the first one (it defines the partition)
-			if (over_idx == expr_idx) {
-				matching.emplace_back(expr_idx);
-				continue;
-			}
-
-			// If it is in a different partition, skip it
-			const auto &over_expr = op.expressions[over_idx]->Cast<BoundWindowExpression>();
-			if (!over_expr.PartitionsAreEquivalent(wexpr)) {
-				unprocessed.emplace_back(expr_idx);
-				continue;
-			}
-
-			// CSE Elimination: Search for a previous match
-			bool cse = false;
-			for (idx_t i = 0; i < matching.size(); ++i) {
-				const auto match_idx = matching[i];
-				auto &match_expr = op.expressions[match_idx]->Cast<BoundWindowExpression>();
-				if (wexpr.Equals(match_expr)) {
-					projection_map[input_width + expr_idx] = output_pos + i;
-					cse = true;
-					break;
-				}
-			}
-			if (cse) {
-				continue;
-			}
-
-			// Is there a common sort prefix?
-			const auto prefix = over_expr.GetSharedOrders(wexpr);
-			if (prefix != MinValue<idx_t>(over_expr.orders.size(), wexpr.orders.size())) {
-				unprocessed.emplace_back(expr_idx);
-				continue;
-			}
-			matching.emplace_back(expr_idx);
-
-			// Switch to the longer prefix
-			if (prefix < wexpr.orders.size()) {
-				over_idx = expr_idx;
-			}
-		}
-		remaining.swap(unprocessed);
-
-		// Remember the projection order
-		for (const auto &expr_idx : matching) {
-			projection_map[input_width + expr_idx] = output_pos++;
-		}
-
-		window_expressions.emplace_back(std::move(matching));
-	}
-
-	// Build the window operators
-	for (idx_t i = 0; i < window_expressions.size(); ++i) {
-		// Extract the matching expressions
-		const auto &matching = window_expressions[i];
-		vector<unique_ptr<Expression>> select_list;
-		for (const auto &expr_idx : matching) {
-			select_list.emplace_back(std::move(op.expressions[expr_idx]));
-			types.emplace_back(op.types[input_width + expr_idx]);
-		}
-
-		// Chain the new window operator on top of the plan
-		unique_ptr<PhysicalOperator> window;
-		if (i < blocking_count) {
-			window = make_uniq<PhysicalWindow>(types, std::move(select_list), op.estimated_cardinality);
-		} else {
-			window = make_uniq<PhysicalStreamingWindow>(types, std::move(select_list), op.estimated_cardinality);
-		}
-		window->children.push_back(std::move(plan));
-		plan = std::move(window);
-	}
-
-	// Put everything back into place if it moved
-	if (!projection_map.empty()) {
-		vector<unique_ptr<Expression>> select_list(op.types.size());
-		// The inputs don't move
-		for (idx_t i = 0; i < input_width; ++i) {
-			select_list[i] = make_uniq<BoundReferenceExpression>(op.types[i], i);
-		}
-		// The outputs have been rearranged
-		for (const auto &p : projection_map) {
-			select_list[p.first] = make_uniq<BoundReferenceExpression>(op.types[p.first], p.second);
-		}
-		auto proj = make_uniq<PhysicalProjection>(op.types, std::move(select_list), op.estimated_cardinality);
-		proj->children.push_back(std::move(plan));
-		plan = std::move(proj);
-	}
-
-	return plan;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/physical_plan_generator.cpp b/src/duckdb/src/execution/physical_plan_generator.cpp
deleted file mode 100644
index 1ac6f61b2..000000000
--- a/src/duckdb/src/execution/physical_plan_generator.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-#include "duckdb/execution/physical_plan_generator.hpp"
-
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/column_binding_resolver.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/operator/logical_extension_operator.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/execution/operator/helper/physical_verify_vector.hpp"
-
-namespace duckdb {
-
-PhysicalPlanGenerator::PhysicalPlanGenerator(ClientContext &context) : context(context) {
-}
-
-PhysicalPlanGenerator::~PhysicalPlanGenerator() {
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(unique_ptr<LogicalOperator> op) {
-	auto &profiler = QueryProfiler::Get(context);
-
-	// first resolve column references
-	profiler.StartPhase(MetricsType::PHYSICAL_PLANNER_COLUMN_BINDING);
-	ColumnBindingResolver resolver;
-	resolver.VisitOperator(*op);
-	profiler.EndPhase();
-
-	// now resolve types of all the operators
-	profiler.StartPhase(MetricsType::PHYSICAL_PLANNER_RESOLVE_TYPES);
-	op->ResolveOperatorTypes();
-	profiler.EndPhase();
-
-	// then create the main physical plan
-	profiler.StartPhase(MetricsType::PHYSICAL_PLANNER_CREATE_PLAN);
-	auto plan = CreatePlan(*op);
-	profiler.EndPhase();
-
-	plan->Verify();
-	return plan;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &op) {
-	op.estimated_cardinality = op.EstimateCardinality(context);
-	unique_ptr<PhysicalOperator> plan = nullptr;
-
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_GET:
-		plan = CreatePlan(op.Cast<LogicalGet>());
-		break;
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		plan = CreatePlan(op.Cast<LogicalProjection>());
-		break;
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		plan = CreatePlan(op.Cast<LogicalEmptyResult>());
-		break;
-	case LogicalOperatorType::LOGICAL_FILTER:
-		plan = CreatePlan(op.Cast<LogicalFilter>());
-		break;
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		plan = CreatePlan(op.Cast<LogicalAggregate>());
-		break;
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		plan = CreatePlan(op.Cast<LogicalWindow>());
-		break;
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		plan = CreatePlan(op.Cast<LogicalUnnest>());
-		break;
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		plan = CreatePlan(op.Cast<LogicalLimit>());
-		break;
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		plan = CreatePlan(op.Cast<LogicalSample>());
-		break;
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		plan = CreatePlan(op.Cast<LogicalOrder>());
-		break;
-	case LogicalOperatorType::LOGICAL_TOP_N:
-		plan = CreatePlan(op.Cast<LogicalTopN>());
-		break;
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		plan = CreatePlan(op.Cast<LogicalCopyToFile>());
-		break;
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		plan = CreatePlan(op.Cast<LogicalDummyScan>());
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		plan = CreatePlan(op.Cast<LogicalAnyJoin>());
-		break;
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		plan = CreatePlan(op.Cast<LogicalComparisonJoin>());
-		break;
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		plan = CreatePlan(op.Cast<LogicalCrossProduct>());
-		break;
-	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		plan = CreatePlan(op.Cast<LogicalPositionalJoin>());
-		break;
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		plan = CreatePlan(op.Cast<LogicalSetOperation>());
-		break;
-	case LogicalOperatorType::LOGICAL_INSERT:
-		plan = CreatePlan(op.Cast<LogicalInsert>());
-		break;
-	case LogicalOperatorType::LOGICAL_DELETE:
-		plan = CreatePlan(op.Cast<LogicalDelete>());
-		break;
-	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		plan = CreatePlan(op.Cast<LogicalColumnDataGet>());
-		break;
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		plan = CreatePlan(op.Cast<LogicalDelimGet>());
-		break;
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		plan = CreatePlan(op.Cast<LogicalExpressionGet>());
-		break;
-	case LogicalOperatorType::LOGICAL_UPDATE:
-		plan = CreatePlan(op.Cast<LogicalUpdate>());
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		plan = CreatePlan(op.Cast<LogicalCreateTable>());
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		plan = CreatePlan(op.Cast<LogicalCreateIndex>());
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_SECRET:
-		plan = CreatePlan(op.Cast<LogicalCreateSecret>());
-		break;
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		plan = CreatePlan(op.Cast<LogicalExplain>());
-		break;
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		plan = CreatePlan(op.Cast<LogicalDistinct>());
-		break;
-	case LogicalOperatorType::LOGICAL_PREPARE:
-		plan = CreatePlan(op.Cast<LogicalPrepare>());
-		break;
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-		plan = CreatePlan(op.Cast<LogicalExecute>());
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		plan = CreatePlan(op.Cast<LogicalCreate>());
-		break;
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-		plan = CreatePlan(op.Cast<LogicalPragma>());
-		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		plan = CreatePlan(op.Cast<LogicalVacuum>());
-		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-	case LogicalOperatorType::LOGICAL_ALTER:
-	case LogicalOperatorType::LOGICAL_DROP:
-	case LogicalOperatorType::LOGICAL_LOAD:
-	case LogicalOperatorType::LOGICAL_ATTACH:
-	case LogicalOperatorType::LOGICAL_DETACH:
-		plan = CreatePlan(op.Cast<LogicalSimple>());
-		break;
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		plan = CreatePlan(op.Cast<LogicalRecursiveCTE>());
-		break;
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-		plan = CreatePlan(op.Cast<LogicalMaterializedCTE>());
-		break;
-	case LogicalOperatorType::LOGICAL_CTE_REF:
-		plan = CreatePlan(op.Cast<LogicalCTERef>());
-		break;
-	case LogicalOperatorType::LOGICAL_EXPORT:
-		plan = CreatePlan(op.Cast<LogicalExport>());
-		break;
-	case LogicalOperatorType::LOGICAL_SET:
-		plan = CreatePlan(op.Cast<LogicalSet>());
-		break;
-	case LogicalOperatorType::LOGICAL_RESET:
-		plan = CreatePlan(op.Cast<LogicalReset>());
-		break;
-	case LogicalOperatorType::LOGICAL_PIVOT:
-		plan = CreatePlan(op.Cast<LogicalPivot>());
-		break;
-	case LogicalOperatorType::LOGICAL_COPY_DATABASE:
-		plan = CreatePlan(op.Cast<LogicalCopyDatabase>());
-		break;
-	case LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS:
-		plan = CreatePlan(op.Cast<LogicalSimple>());
-		break;
-	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		plan = op.Cast<LogicalExtensionOperator>().CreatePlan(context, *this);
-
-		if (!plan) {
-			throw InternalException("Missing PhysicalOperator for Extension Operator");
-		}
-		break;
-	case LogicalOperatorType::LOGICAL_JOIN:
-	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
-	case LogicalOperatorType::LOGICAL_INVALID: {
-		throw NotImplementedException("Unimplemented logical operator type!");
-	}
-	}
-	if (!plan) {
-		throw InternalException("Physical plan generator - no plan generated");
-	}
-
-	plan->estimated_cardinality = op.estimated_cardinality;
-#ifdef DUCKDB_VERIFY_VECTOR_OPERATOR
-	auto verify = make_uniq<PhysicalVerifyVector>(std::move(plan));
-	plan = std::move(verify);
-#endif
-
-	return plan;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/radix_partitioned_hashtable.cpp b/src/duckdb/src/execution/radix_partitioned_hashtable.cpp
deleted file mode 100644
index cf6038fa4..000000000
--- a/src/duckdb/src/execution/radix_partitioned_hashtable.cpp
+++ /dev/null
@@ -1,947 +0,0 @@
-#include "duckdb/execution/radix_partitioned_hashtable.hpp"
-
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-#include "duckdb/common/types/row/tuple_data_iterator.hpp"
-#include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/execution/ht_entry.hpp"
-#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/storage/temporary_memory_manager.hpp"
-
-namespace duckdb {
-
-RadixPartitionedHashTable::RadixPartitionedHashTable(GroupingSet &grouping_set_p, const GroupedAggregateData &op_p)
-    : grouping_set(grouping_set_p), op(op_p) {
-	auto groups_count = op.GroupCount();
-	for (idx_t i = 0; i < groups_count; i++) {
-		if (grouping_set.find(i) == grouping_set.end()) {
-			null_groups.push_back(i);
-		}
-	}
-	if (grouping_set.empty()) {
-		// Fake a single group with a constant value for aggregation without groups
-		group_types.emplace_back(LogicalType::TINYINT);
-	}
-	for (auto &entry : grouping_set) {
-		D_ASSERT(entry < op.group_types.size());
-		group_types.push_back(op.group_types[entry]);
-	}
-	SetGroupingValues();
-
-	auto group_types_copy = group_types;
-	group_types_copy.emplace_back(LogicalType::HASH);
-	layout.Initialize(std::move(group_types_copy), AggregateObject::CreateAggregateObjects(op.bindings));
-}
-
-void RadixPartitionedHashTable::SetGroupingValues() {
-	// Compute the GROUPING values:
-	// For each parameter to the GROUPING clause, we check if the hash table groups on this particular group
-	// If it does, we return 0, otherwise we return 1
-	// We then use bitshifts to combine these values
-	auto &grouping_functions = op.GetGroupingFunctions();
-	for (auto &grouping : grouping_functions) {
-		int64_t grouping_value = 0;
-		D_ASSERT(grouping.size() < sizeof(int64_t) * 8);
-		for (idx_t i = 0; i < grouping.size(); i++) {
-			if (grouping_set.find(grouping[i]) == grouping_set.end()) {
-				// We don't group on this value!
-				grouping_value += 1LL << (grouping.size() - (i + 1));
-			}
-		}
-		grouping_values.push_back(Value::BIGINT(grouping_value));
-	}
-}
-
-const TupleDataLayout &RadixPartitionedHashTable::GetLayout() const {
-	return layout;
-}
-
-unique_ptr<GroupedAggregateHashTable> RadixPartitionedHashTable::CreateHT(ClientContext &context, const idx_t capacity,
-                                                                          const idx_t radix_bits) const {
-	return make_uniq<GroupedAggregateHashTable>(context, BufferAllocator::Get(context), group_types, op.payload_types,
-	                                            op.bindings, capacity, radix_bits);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-enum class AggregatePartitionState : uint8_t {
-	//! Can be finalized
-	READY_TO_FINALIZE = 0,
-	//! Finalize is in progress
-	FINALIZE_IN_PROGRESS = 1,
-	//! Finalized, ready to scan
-	READY_TO_SCAN = 2
-};
-
-struct AggregatePartition : StateWithBlockableTasks {
-	explicit AggregatePartition(unique_ptr<TupleDataCollection> data_p)
-	    : state(AggregatePartitionState::READY_TO_FINALIZE), data(std::move(data_p)), progress(0) {
-	}
-
-	AggregatePartitionState state;
-
-	unique_ptr<TupleDataCollection> data;
-	atomic<double> progress;
-};
-
-class RadixHTGlobalSinkState;
-
-struct RadixHTConfig {
-public:
-	explicit RadixHTConfig(RadixHTGlobalSinkState &sink);
-
-	void SetRadixBits(const idx_t &radix_bits_p);
-	bool SetRadixBitsToExternal();
-	idx_t GetRadixBits() const;
-
-private:
-	void SetRadixBitsInternal(idx_t radix_bits_p, bool external);
-	idx_t InitialSinkRadixBits() const;
-	idx_t MaximumSinkRadixBits() const;
-	idx_t SinkCapacity() const;
-
-private:
-	//! The global sink state
-	RadixHTGlobalSinkState &sink;
-
-public:
-	//! Number of threads (from TaskScheduler)
-	const idx_t number_of_threads;
-	//! Width of tuples
-	const idx_t row_width;
-	//! Capacity of HTs during the Sink
-	const idx_t sink_capacity;
-
-private:
-	//! Assume (1 << 15) = 32KB L1 cache per core, divided by two because hyperthreading
-	static constexpr idx_t L1_CACHE_SIZE = 32768 / 2;
-	//! Assume (1 << 20) = 1MB L2 cache per core, divided by two because hyperthreading
-	static constexpr idx_t L2_CACHE_SIZE = 1048576 / 2;
-	//! Assume (1 << 20) + (1 << 19) = 1.5MB L3 cache per core (shared), divided by two because hyperthreading
-	static constexpr idx_t L3_CACHE_SIZE = 1572864 / 2;
-
-	//! Sink radix bits to initialize with
-	static constexpr idx_t MAXIMUM_INITIAL_SINK_RADIX_BITS = 4;
-	//! Maximum Sink radix bits (independent of threads)
-	static constexpr idx_t MAXIMUM_FINAL_SINK_RADIX_BITS = 8;
-
-	//! Current thread-global sink radix bits
-	atomic<idx_t> sink_radix_bits;
-	//! Maximum Sink radix bits (set based on number of threads)
-	const idx_t maximum_sink_radix_bits;
-
-	//! Thresholds at which we reduce the sink radix bits
-	//! This needed to reduce cache misses when we have very wide rows
-	static constexpr idx_t ROW_WIDTH_THRESHOLD_ONE = 32;
-	static constexpr idx_t ROW_WIDTH_THRESHOLD_TWO = 64;
-
-public:
-	//! If we have this many or less threads, we grow the HT, otherwise we abandon
-	static constexpr idx_t GROW_STRATEGY_THREAD_THRESHOLD = 2;
-	//! If we fill this many blocks per partition, we trigger a repartition
-	static constexpr double BLOCK_FILL_FACTOR = 1.8;
-	//! By how many bits to repartition if a repartition is triggered
-	static constexpr idx_t REPARTITION_RADIX_BITS = 2;
-};
-
-class RadixHTGlobalSinkState : public GlobalSinkState {
-public:
-	RadixHTGlobalSinkState(ClientContext &context, const RadixPartitionedHashTable &radix_ht);
-
-	//! Destroys aggregate states (if multi-scan)
-	~RadixHTGlobalSinkState() override;
-	void Destroy();
-
-public:
-	ClientContext &context;
-	//! Temporary memory state for managing this hash table's memory usage
-	unique_ptr<TemporaryMemoryState> temporary_memory_state;
-	idx_t minimum_reservation;
-
-	//! Whether we've called Finalize
-	bool finalized;
-	//! Whether we are doing an external aggregation
-	atomic<bool> external;
-	//! Threads that have called Sink
-	atomic<idx_t> active_threads;
-	//! Number of threads (from TaskScheduler)
-	const idx_t number_of_threads;
-	//! If any thread has called combine
-	atomic<bool> any_combined;
-
-	//! The radix HT
-	const RadixPartitionedHashTable &radix_ht;
-	//! Config for partitioning
-	RadixHTConfig config;
-
-	//! Uncombined partitioned data that will be put into the AggregatePartitions
-	unique_ptr<PartitionedTupleData> uncombined_data;
-	//! Allocators used during the Sink/Finalize
-	vector<shared_ptr<ArenaAllocator>> stored_allocators;
-	idx_t stored_allocators_size;
-
-	//! Partitions that are finalized during GetData
-	vector<unique_ptr<AggregatePartition>> partitions;
-	//! For keeping track of progress
-	atomic<idx_t> finalize_done;
-
-	//! Pin properties when scanning
-	TupleDataPinProperties scan_pin_properties;
-	//! Total count before combining
-	idx_t count_before_combining;
-	//! Maximum partition size if all unique
-	idx_t max_partition_size;
-};
-
-RadixHTGlobalSinkState::RadixHTGlobalSinkState(ClientContext &context_p, const RadixPartitionedHashTable &radix_ht_p)
-    : context(context_p), temporary_memory_state(TemporaryMemoryManager::Get(context).Register(context)),
-      finalized(false), external(false), active_threads(0),
-      number_of_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads())),
-      any_combined(false), radix_ht(radix_ht_p), config(*this), stored_allocators_size(0), finalize_done(0),
-      scan_pin_properties(TupleDataPinProperties::DESTROY_AFTER_DONE), count_before_combining(0),
-      max_partition_size(0) {
-
-	// Compute minimum reservation
-	auto block_alloc_size = BufferManager::GetBufferManager(context).GetBlockAllocSize();
-	auto tuples_per_block = block_alloc_size / radix_ht.GetLayout().GetRowWidth();
-	idx_t ht_count =
-	    LossyNumericCast<idx_t>(static_cast<double>(config.sink_capacity) / GroupedAggregateHashTable::LOAD_FACTOR);
-	auto num_partitions = RadixPartitioning::NumberOfPartitions(config.GetRadixBits());
-	auto count_per_partition = ht_count / num_partitions;
-	auto blocks_per_partition = (count_per_partition + tuples_per_block) / tuples_per_block + 1;
-	if (!radix_ht.GetLayout().AllConstant()) {
-		blocks_per_partition += 2;
-	}
-	auto ht_size = blocks_per_partition * block_alloc_size + config.sink_capacity * sizeof(ht_entry_t);
-
-	// This really is the minimum reservation that we can do
-	auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads());
-	minimum_reservation = num_threads * ht_size;
-
-	temporary_memory_state->SetMinimumReservation(minimum_reservation);
-	temporary_memory_state->SetRemainingSizeAndUpdateReservation(context, minimum_reservation);
-}
-
-RadixHTGlobalSinkState::~RadixHTGlobalSinkState() {
-	Destroy();
-}
-
-// LCOV_EXCL_START
-void RadixHTGlobalSinkState::Destroy() {
-	if (scan_pin_properties == TupleDataPinProperties::DESTROY_AFTER_DONE || count_before_combining == 0 ||
-	    partitions.empty()) {
-		// Already destroyed / empty
-		return;
-	}
-
-	TupleDataLayout layout = partitions[0]->data->GetLayout().Copy();
-	if (!layout.HasDestructor()) {
-		return; // No destructors, exit
-	}
-
-	// There are aggregates with destructors: Call the destructor for each of the aggregates
-	auto guard = Lock();
-	RowOperationsState row_state(*stored_allocators.back());
-	for (auto &partition : partitions) {
-		auto &data_collection = *partition->data;
-		if (data_collection.Count() == 0) {
-			continue;
-		}
-		TupleDataChunkIterator iterator(data_collection, TupleDataPinProperties::DESTROY_AFTER_DONE, false);
-		auto &row_locations = iterator.GetChunkState().row_locations;
-		do {
-			RowOperations::DestroyStates(row_state, layout, row_locations, iterator.GetCurrentChunkCount());
-		} while (iterator.Next());
-		data_collection.Reset();
-	}
-}
-// LCOV_EXCL_STOP
-
-RadixHTConfig::RadixHTConfig(RadixHTGlobalSinkState &sink_p)
-    : sink(sink_p), number_of_threads(sink.number_of_threads), row_width(sink.radix_ht.GetLayout().GetRowWidth()),
-      sink_capacity(SinkCapacity()), sink_radix_bits(InitialSinkRadixBits()),
-      maximum_sink_radix_bits(MaximumSinkRadixBits()) {
-}
-
-void RadixHTConfig::SetRadixBits(const idx_t &radix_bits_p) {
-	SetRadixBitsInternal(MinValue(radix_bits_p, maximum_sink_radix_bits), false);
-}
-
-bool RadixHTConfig::SetRadixBitsToExternal() {
-	SetRadixBitsInternal(MAXIMUM_FINAL_SINK_RADIX_BITS, true);
-	return sink.external;
-}
-
-idx_t RadixHTConfig::GetRadixBits() const {
-	return sink_radix_bits;
-}
-
-void RadixHTConfig::SetRadixBitsInternal(const idx_t radix_bits_p, bool external) {
-	if (sink_radix_bits >= radix_bits_p || sink.any_combined) {
-		return;
-	}
-
-	auto guard = sink.Lock();
-	if (sink_radix_bits >= radix_bits_p || sink.any_combined) {
-		return;
-	}
-
-	if (external) {
-		sink.external = true;
-	}
-	sink_radix_bits = radix_bits_p;
-}
-
-idx_t RadixHTConfig::InitialSinkRadixBits() const {
-	return MinValue(RadixPartitioning::RadixBitsOfPowerOfTwo(NextPowerOfTwo(number_of_threads)),
-	                MAXIMUM_INITIAL_SINK_RADIX_BITS);
-}
-
-idx_t RadixHTConfig::MaximumSinkRadixBits() const {
-	if (number_of_threads <= GROW_STRATEGY_THREAD_THRESHOLD) {
-		return InitialSinkRadixBits(); // Don't repartition unless we go external
-	}
-	// If rows are very wide we have to reduce the number of partitions, otherwise cache misses get out of hand
-	if (row_width >= ROW_WIDTH_THRESHOLD_TWO) {
-		return MAXIMUM_FINAL_SINK_RADIX_BITS - 2;
-	}
-	if (row_width >= ROW_WIDTH_THRESHOLD_ONE) {
-		return MAXIMUM_FINAL_SINK_RADIX_BITS - 1;
-	}
-	return MAXIMUM_FINAL_SINK_RADIX_BITS;
-}
-
-idx_t RadixHTConfig::SinkCapacity() const {
-	// Compute cache size per active thread (assuming cache is shared)
-	const auto total_shared_cache_size = number_of_threads * L3_CACHE_SIZE;
-	const auto cache_per_active_thread = L1_CACHE_SIZE + L2_CACHE_SIZE + total_shared_cache_size / number_of_threads;
-
-	// Divide cache per active thread by entry size, round up to next power of two, to get capacity
-	const auto size_per_entry = LossyNumericCast<idx_t>(sizeof(ht_entry_t) * GroupedAggregateHashTable::LOAD_FACTOR) +
-	                            MinValue(row_width, ROW_WIDTH_THRESHOLD_TWO);
-	const auto capacity = NextPowerOfTwo(cache_per_active_thread / size_per_entry);
-
-	// Capacity must be at least the minimum capacity
-	return MaxValue<idx_t>(capacity, GroupedAggregateHashTable::InitialCapacity());
-}
-
-class RadixHTLocalSinkState : public LocalSinkState {
-public:
-	RadixHTLocalSinkState(ClientContext &context, const RadixPartitionedHashTable &radix_ht);
-
-public:
-	//! Thread-local HT that is re-used after abandoning
-	unique_ptr<GroupedAggregateHashTable> ht;
-	//! Chunk with group columns
-	DataChunk group_chunk;
-
-	//! Data that is abandoned ends up here (only if we're doing external aggregation)
-	unique_ptr<PartitionedTupleData> abandoned_data;
-};
-
-RadixHTLocalSinkState::RadixHTLocalSinkState(ClientContext &, const RadixPartitionedHashTable &radix_ht) {
-	// If there are no groups we create a fake group so everything has the same group
-	group_chunk.InitializeEmpty(radix_ht.group_types);
-	if (radix_ht.grouping_set.empty()) {
-		group_chunk.data[0].Reference(Value::TINYINT(42));
-	}
-}
-
-unique_ptr<GlobalSinkState> RadixPartitionedHashTable::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<RadixHTGlobalSinkState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> RadixPartitionedHashTable::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<RadixHTLocalSinkState>(context.client, *this);
-}
-
-void RadixPartitionedHashTable::PopulateGroupChunk(DataChunk &group_chunk, DataChunk &input_chunk) const {
-	idx_t chunk_index = 0;
-	// Populate the group_chunk
-	for (auto &group_idx : grouping_set) {
-		// Retrieve the expression containing the index in the input chunk
-		auto &group = op.groups[group_idx];
-		D_ASSERT(group->GetExpressionType() == ExpressionType::BOUND_REF);
-		auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
-		// Reference from input_chunk[group.index] -> group_chunk[chunk_index]
-		group_chunk.data[chunk_index++].Reference(input_chunk.data[bound_ref_expr.index]);
-	}
-	group_chunk.SetCardinality(input_chunk.size());
-	group_chunk.Verify();
-}
-
-void MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, RadixHTLocalSinkState &lstate) {
-	auto &config = gstate.config;
-	auto &ht = *lstate.ht;
-
-	// Check if we're approaching the memory limit
-	auto &temporary_memory_state = *gstate.temporary_memory_state;
-	const auto aggregate_allocator_size = ht.GetAggregateAllocator()->AllocationSize();
-	const auto total_size =
-	    aggregate_allocator_size + ht.GetPartitionedData().SizeInBytes() + ht.Capacity() * sizeof(ht_entry_t);
-	idx_t thread_limit = temporary_memory_state.GetReservation() / gstate.number_of_threads;
-	if (total_size > thread_limit) {
-		// We're over the thread memory limit
-		if (!gstate.external) {
-			// We haven't yet triggered out-of-core behavior, but maybe we don't have to, grab the lock and check again
-			auto guard = gstate.Lock();
-			thread_limit = temporary_memory_state.GetReservation() / gstate.number_of_threads;
-			if (total_size > thread_limit) {
-				// Out-of-core would be triggered below, update minimum reservation and try to increase the reservation
-				temporary_memory_state.SetMinimumReservation(aggregate_allocator_size * gstate.number_of_threads +
-				                                             gstate.minimum_reservation);
-				auto remaining_size =
-				    MaxValue<idx_t>(gstate.number_of_threads * total_size, temporary_memory_state.GetRemainingSize());
-				temporary_memory_state.SetRemainingSizeAndUpdateReservation(context, 2 * remaining_size);
-				thread_limit = temporary_memory_state.GetReservation() / gstate.number_of_threads;
-			}
-		}
-	}
-
-	if (total_size > thread_limit) {
-		if (gstate.config.SetRadixBitsToExternal()) {
-			// We're approaching the memory limit, unpin the data
-			if (!lstate.abandoned_data) {
-				lstate.abandoned_data = make_uniq<RadixPartitionedTupleData>(
-				    BufferManager::GetBufferManager(context), gstate.radix_ht.GetLayout(), config.GetRadixBits(),
-				    gstate.radix_ht.GetLayout().ColumnCount() - 1);
-			}
-			ht.SetRadixBits(gstate.config.GetRadixBits());
-			ht.AcquirePartitionedData()->Repartition(*lstate.abandoned_data);
-		}
-	}
-
-	// We can go external when there are few threads, but we shouldn't repartition here
-	if (gstate.number_of_threads <= RadixHTConfig::GROW_STRATEGY_THREAD_THRESHOLD) {
-		return;
-	}
-
-	const auto partition_count = ht.GetPartitionedData().PartitionCount();
-	const auto current_radix_bits = RadixPartitioning::RadixBitsOfPowerOfTwo(partition_count);
-	D_ASSERT(current_radix_bits <= config.GetRadixBits());
-
-	const auto block_size = BufferManager::GetBufferManager(context).GetBlockSize();
-	const auto row_size_per_partition =
-	    ht.GetPartitionedData().Count() * ht.GetPartitionedData().GetLayout().GetRowWidth() / partition_count;
-	if (row_size_per_partition > LossyNumericCast<idx_t>(config.BLOCK_FILL_FACTOR * static_cast<double>(block_size))) {
-		// We crossed our block filling threshold, try to increment radix bits
-		config.SetRadixBits(current_radix_bits + config.REPARTITION_RADIX_BITS);
-	}
-
-	const auto global_radix_bits = config.GetRadixBits();
-	if (current_radix_bits == global_radix_bits) {
-		return; // We're already on the right number of radix bits
-	}
-
-	// We're out-of-sync with the global radix bits, repartition
-	ht.SetRadixBits(global_radix_bits);
-	ht.Repartition();
-}
-
-void RadixPartitionedHashTable::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
-                                     DataChunk &payload_input, const unsafe_vector<idx_t> &filter) const {
-	auto &gstate = input.global_state.Cast<RadixHTGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<RadixHTLocalSinkState>();
-	if (!lstate.ht) {
-		lstate.ht = CreateHT(context.client, gstate.config.sink_capacity, gstate.config.GetRadixBits());
-		gstate.active_threads++;
-	}
-
-	auto &group_chunk = lstate.group_chunk;
-	PopulateGroupChunk(group_chunk, chunk);
-
-	auto &ht = *lstate.ht;
-	ht.AddChunk(group_chunk, payload_input, filter);
-
-	if (ht.Count() + STANDARD_VECTOR_SIZE < GroupedAggregateHashTable::ResizeThreshold(gstate.config.sink_capacity)) {
-		return; // We can fit another chunk
-	}
-
-	if (gstate.number_of_threads > RadixHTConfig::GROW_STRATEGY_THREAD_THRESHOLD || gstate.external) {
-		// 'Reset' the HT without taking its data, we can just keep appending to the same collection
-		// This only works because we never resize the HT
-		// We don't do this when running with 1 or 2 threads, it only makes sense when there's many threads
-		ht.Abandon();
-
-		// Once we've inserted more than SKIP_LOOKUP_THRESHOLD tuples,
-		// and more than UNIQUE_PERCENTAGE_THRESHOLD were unique,
-		// we set the HT to skip doing lookups, which makes it blindly append data to the HT.
-		// This speeds up adding data, at the cost of no longer de-duplicating.
-		// The data will be de-duplicated later anyway
-		static constexpr idx_t SKIP_LOOKUP_THRESHOLD = 262144;
-		static constexpr double UNIQUE_PERCENTAGE_THRESHOLD = 0.95;
-		const auto unique_percentage =
-		    static_cast<double>(ht.GetPartitionedData().Count()) / static_cast<double>(ht.GetSinkCount());
-		if (ht.GetSinkCount() > SKIP_LOOKUP_THRESHOLD && unique_percentage > UNIQUE_PERCENTAGE_THRESHOLD) {
-			ht.SkipLookups();
-		}
-	}
-
-	// Check if we need to repartition
-	const auto radix_bits_before = ht.GetRadixBits();
-	MaybeRepartition(context.client, gstate, lstate);
-	const auto repartitioned = radix_bits_before != ht.GetRadixBits();
-
-	if (repartitioned && ht.Count() != 0) {
-		// We repartitioned, but we didn't clear the pointer table / reset the count because we're on 1 or 2 threads
-		ht.Abandon();
-		if (gstate.external) {
-			ht.Resize(gstate.config.sink_capacity);
-		}
-	}
-
-	// TODO: combine early and often
-}
-
-void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                        LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<RadixHTGlobalSinkState>();
-	auto &lstate = lstate_p.Cast<RadixHTLocalSinkState>();
-	if (!lstate.ht) {
-		return;
-	}
-
-	// Set any_combined, then check one last time whether we need to repartition
-	gstate.any_combined = true;
-	MaybeRepartition(context.client, gstate, lstate);
-
-	auto &ht = *lstate.ht;
-	auto lstate_data = ht.AcquirePartitionedData();
-	if (lstate.abandoned_data) {
-		D_ASSERT(gstate.external);
-		D_ASSERT(lstate.abandoned_data->PartitionCount() == lstate.ht->GetPartitionedData().PartitionCount());
-		D_ASSERT(lstate.abandoned_data->PartitionCount() ==
-		         RadixPartitioning::NumberOfPartitions(gstate.config.GetRadixBits()));
-		lstate.abandoned_data->Combine(*lstate_data);
-	} else {
-		lstate.abandoned_data = std::move(lstate_data);
-	}
-
-	auto guard = gstate.Lock();
-	if (gstate.uncombined_data) {
-		gstate.uncombined_data->Combine(*lstate.abandoned_data);
-	} else {
-		gstate.uncombined_data = std::move(lstate.abandoned_data);
-	}
-	gstate.stored_allocators.emplace_back(ht.GetAggregateAllocator());
-	gstate.stored_allocators_size += gstate.stored_allocators.back()->AllocationSize();
-}
-
-void RadixPartitionedHashTable::Finalize(ClientContext &context, GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<RadixHTGlobalSinkState>();
-
-	if (gstate.uncombined_data) {
-		auto &uncombined_data = *gstate.uncombined_data;
-		gstate.count_before_combining = uncombined_data.Count();
-
-		// If true there is no need to combine, it was all done by a single thread in a single HT
-		const auto single_ht = !gstate.external && gstate.active_threads == 1 && gstate.number_of_threads == 1;
-
-		auto &uncombined_partition_data = uncombined_data.GetPartitions();
-		const auto n_partitions = uncombined_partition_data.size();
-		gstate.partitions.reserve(n_partitions);
-		for (idx_t i = 0; i < n_partitions; i++) {
-			auto &partition = uncombined_partition_data[i];
-			auto partition_size =
-			    partition->SizeInBytes() +
-			    GroupedAggregateHashTable::GetCapacityForCount(partition->Count()) * sizeof(ht_entry_t);
-			gstate.max_partition_size = MaxValue(gstate.max_partition_size, partition_size);
-
-			gstate.partitions.emplace_back(make_uniq<AggregatePartition>(std::move(partition)));
-			if (single_ht) {
-				gstate.finalize_done++;
-				gstate.partitions.back()->progress = 1;
-				gstate.partitions.back()->state = AggregatePartitionState::READY_TO_SCAN;
-			}
-		}
-	} else {
-		gstate.count_before_combining = 0;
-	}
-
-	// Minimum of combining one partition at a time
-	gstate.temporary_memory_state->SetMinimumReservation(gstate.stored_allocators_size + gstate.max_partition_size);
-	// Set size to 0 until the scan actually starts
-	gstate.temporary_memory_state->SetZero();
-	gstate.finalized = true;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-idx_t RadixPartitionedHashTable::MaxThreads(GlobalSinkState &sink_p) const {
-	auto &sink = sink_p.Cast<RadixHTGlobalSinkState>();
-	if (sink.partitions.empty()) {
-		return 0;
-	}
-
-	const auto max_threads = MinValue<idx_t>(
-	    NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads()), sink.partitions.size());
-	sink.temporary_memory_state->SetRemainingSizeAndUpdateReservation(
-	    sink.context, sink.stored_allocators_size + max_threads * sink.max_partition_size);
-
-	// we cannot spill aggregate state memory
-	const auto usable_memory = sink.temporary_memory_state->GetReservation() > sink.stored_allocators_size
-	                               ? sink.temporary_memory_state->GetReservation() - sink.max_partition_size
-	                               : 0;
-	// This many partitions will fit given our reservation (at least 1))
-	const auto partitions_fit = MaxValue<idx_t>(usable_memory / sink.max_partition_size, 1);
-
-	// Mininum of the two
-	return MinValue<idx_t>(partitions_fit, max_threads);
-}
-
-void RadixPartitionedHashTable::SetMultiScan(GlobalSinkState &sink_p) {
-	auto &sink = sink_p.Cast<RadixHTGlobalSinkState>();
-	sink.scan_pin_properties = TupleDataPinProperties::UNPIN_AFTER_DONE;
-}
-
-enum class RadixHTSourceTaskType : uint8_t { NO_TASK, FINALIZE, SCAN };
-
-class RadixHTLocalSourceState;
-
-class RadixHTGlobalSourceState : public GlobalSourceState {
-public:
-	RadixHTGlobalSourceState(ClientContext &context, const RadixPartitionedHashTable &radix_ht);
-
-	//! Assigns a task to a local source state
-	SourceResultType AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate,
-	                            InterruptState &interrupt_state);
-
-public:
-	//! The client context
-	ClientContext &context;
-	//! For synchronizing the source phase
-	atomic<bool> finished;
-
-	//! Column ids for scanning
-	vector<column_t> column_ids;
-
-	//! For synchronizing tasks
-	idx_t task_idx;
-	atomic<idx_t> task_done;
-};
-
-enum class RadixHTScanStatus : uint8_t { INIT, IN_PROGRESS, DONE };
-
-class RadixHTLocalSourceState : public LocalSourceState {
-public:
-	explicit RadixHTLocalSourceState(ExecutionContext &context, const RadixPartitionedHashTable &radix_ht);
-
-public:
-	//! Do the work this thread has been assigned
-	void ExecuteTask(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate, DataChunk &chunk);
-	//! Whether this thread has finished the work it has been assigned
-	bool TaskFinished();
-
-private:
-	//! Execute the finalize or scan task
-	void Finalize(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate);
-	void Scan(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate, DataChunk &chunk);
-
-public:
-	//! Current task and index
-	RadixHTSourceTaskType task;
-	idx_t task_idx;
-
-	//! Thread-local HT that is re-used to Finalize
-	unique_ptr<GroupedAggregateHashTable> ht;
-	//! Current status of a Scan
-	RadixHTScanStatus scan_status;
-
-private:
-	//! Allocator and layout for finalizing state
-	TupleDataLayout layout;
-	ArenaAllocator aggregate_allocator;
-
-	//! State and chunk for scanning
-	TupleDataScanState scan_state;
-	DataChunk scan_chunk;
-};
-
-unique_ptr<GlobalSourceState> RadixPartitionedHashTable::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<RadixHTGlobalSourceState>(context, *this);
-}
-
-unique_ptr<LocalSourceState> RadixPartitionedHashTable::GetLocalSourceState(ExecutionContext &context) const {
-	return make_uniq<RadixHTLocalSourceState>(context, *this);
-}
-
-RadixHTGlobalSourceState::RadixHTGlobalSourceState(ClientContext &context_p, const RadixPartitionedHashTable &radix_ht)
-    : context(context_p), finished(false), task_idx(0), task_done(0) {
-	for (column_t column_id = 0; column_id < radix_ht.group_types.size(); column_id++) {
-		column_ids.push_back(column_id);
-	}
-}
-
-SourceResultType RadixHTGlobalSourceState::AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate,
-                                                      InterruptState &interrupt_state) {
-	// First, try to get a partition index
-	auto guard = sink.Lock();
-	if (finished || task_idx == sink.partitions.size()) {
-		lstate.ht.reset();
-		return SourceResultType::FINISHED;
-	}
-	lstate.task_idx = task_idx++;
-
-	// We got a partition index
-	auto &partition = *sink.partitions[lstate.task_idx];
-	auto partition_guard = partition.Lock();
-	switch (partition.state) {
-	case AggregatePartitionState::READY_TO_FINALIZE:
-		partition.state = AggregatePartitionState::FINALIZE_IN_PROGRESS;
-		lstate.task = RadixHTSourceTaskType::FINALIZE;
-		return SourceResultType::HAVE_MORE_OUTPUT;
-	case AggregatePartitionState::FINALIZE_IN_PROGRESS:
-		lstate.task = RadixHTSourceTaskType::SCAN;
-		lstate.scan_status = RadixHTScanStatus::INIT;
-		return partition.BlockSource(partition_guard, interrupt_state);
-	case AggregatePartitionState::READY_TO_SCAN:
-		lstate.task = RadixHTSourceTaskType::SCAN;
-		lstate.scan_status = RadixHTScanStatus::INIT;
-		return SourceResultType::HAVE_MORE_OUTPUT;
-	default:
-		throw InternalException("Unexpected AggregatePartitionState in RadixHTLocalSourceState::Finalize!");
-	}
-}
-
-RadixHTLocalSourceState::RadixHTLocalSourceState(ExecutionContext &context, const RadixPartitionedHashTable &radix_ht)
-    : task(RadixHTSourceTaskType::NO_TASK), task_idx(DConstants::INVALID_INDEX), scan_status(RadixHTScanStatus::DONE),
-      layout(radix_ht.GetLayout().Copy()), aggregate_allocator(BufferAllocator::Get(context.client)) {
-	auto &allocator = BufferAllocator::Get(context.client);
-	auto scan_chunk_types = radix_ht.group_types;
-	for (auto &aggr_type : radix_ht.op.aggregate_return_types) {
-		scan_chunk_types.push_back(aggr_type);
-	}
-	scan_chunk.Initialize(allocator, scan_chunk_types);
-}
-
-void RadixHTLocalSourceState::ExecuteTask(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate,
-                                          DataChunk &chunk) {
-	D_ASSERT(task != RadixHTSourceTaskType::NO_TASK);
-	switch (task) {
-	case RadixHTSourceTaskType::FINALIZE:
-		Finalize(sink, gstate);
-		break;
-	case RadixHTSourceTaskType::SCAN:
-		Scan(sink, gstate, chunk);
-		break;
-	default:
-		throw InternalException("Unexpected RadixHTSourceTaskType in ExecuteTask!");
-	}
-}
-
-void RadixHTLocalSourceState::Finalize(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate) {
-	D_ASSERT(task == RadixHTSourceTaskType::FINALIZE);
-	D_ASSERT(scan_status != RadixHTScanStatus::IN_PROGRESS);
-	auto &partition = *sink.partitions[task_idx];
-
-	if (!ht) {
-		// This capacity would always be sufficient for all data
-		const auto capacity = GroupedAggregateHashTable::GetCapacityForCount(partition.data->Count());
-
-		// However, we will limit the initial capacity so we don't do a huge over-allocation
-		const auto n_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(gstate.context).NumberOfThreads());
-		const auto memory_limit = BufferManager::GetBufferManager(gstate.context).GetMaxMemory();
-		const idx_t thread_limit = LossyNumericCast<idx_t>(0.6 * double(memory_limit) / double(n_threads));
-
-		const idx_t size_per_entry = partition.data->SizeInBytes() / MaxValue<idx_t>(partition.data->Count(), 1) +
-		                             idx_t(GroupedAggregateHashTable::LOAD_FACTOR * sizeof(ht_entry_t));
-		// but not lower than the initial capacity
-		const auto capacity_limit =
-		    MaxValue(NextPowerOfTwo(thread_limit / size_per_entry), GroupedAggregateHashTable::InitialCapacity());
-
-		ht = sink.radix_ht.CreateHT(gstate.context, MinValue<idx_t>(capacity, capacity_limit), 0);
-	} else {
-		ht->Abandon();
-	}
-
-	// Now combine the uncombined data using this thread's HT
-	ht->Combine(*partition.data, &partition.progress);
-	partition.progress = 1;
-
-	// Move the combined data back to the partition
-	partition.data =
-	    make_uniq<TupleDataCollection>(BufferManager::GetBufferManager(gstate.context), sink.radix_ht.GetLayout());
-	partition.data->Combine(*ht->AcquirePartitionedData()->GetPartitions()[0]);
-
-	// Update thread-global state
-	auto guard = sink.Lock();
-	sink.stored_allocators.emplace_back(ht->GetAggregateAllocator());
-	if (task_idx == sink.partitions.size()) {
-		ht.reset();
-	}
-	const auto finalizes_done = ++sink.finalize_done;
-	D_ASSERT(finalizes_done <= sink.partitions.size());
-	if (finalizes_done == sink.partitions.size()) {
-		// All finalizes are done, set remaining size to 0
-		sink.temporary_memory_state->SetZero();
-	}
-
-	// Update partition state
-	auto partition_guard = partition.Lock();
-	partition.state = AggregatePartitionState::READY_TO_SCAN;
-	partition.UnblockTasks(partition_guard);
-
-	// This thread will scan the partition
-	task = RadixHTSourceTaskType::SCAN;
-	scan_status = RadixHTScanStatus::INIT;
-}
-
-void RadixHTLocalSourceState::Scan(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate, DataChunk &chunk) {
-	D_ASSERT(task == RadixHTSourceTaskType::SCAN);
-	D_ASSERT(scan_status != RadixHTScanStatus::DONE);
-
-	auto &partition = *sink.partitions[task_idx];
-	D_ASSERT(partition.state == AggregatePartitionState::READY_TO_SCAN);
-	auto &data_collection = *partition.data;
-
-	if (scan_status == RadixHTScanStatus::INIT) {
-		data_collection.InitializeScan(scan_state, gstate.column_ids, sink.scan_pin_properties);
-		scan_status = RadixHTScanStatus::IN_PROGRESS;
-	}
-
-	if (!data_collection.Scan(scan_state, scan_chunk)) {
-		if (sink.scan_pin_properties == TupleDataPinProperties::DESTROY_AFTER_DONE) {
-			data_collection.Reset();
-		}
-		scan_status = RadixHTScanStatus::DONE;
-		auto guard = sink.Lock();
-		if (++gstate.task_done == sink.partitions.size()) {
-			gstate.finished = true;
-		}
-		return;
-	}
-
-	RowOperationsState row_state(aggregate_allocator);
-	const auto group_cols = layout.ColumnCount() - 1;
-	RowOperations::FinalizeStates(row_state, layout, scan_state.chunk_state.row_locations, scan_chunk, group_cols);
-
-	if (sink.scan_pin_properties == TupleDataPinProperties::DESTROY_AFTER_DONE && layout.HasDestructor()) {
-		RowOperations::DestroyStates(row_state, layout, scan_state.chunk_state.row_locations, scan_chunk.size());
-	}
-
-	auto &radix_ht = sink.radix_ht;
-	idx_t chunk_index = 0;
-	for (auto &entry : radix_ht.grouping_set) {
-		chunk.data[entry].Reference(scan_chunk.data[chunk_index++]);
-	}
-	for (auto null_group : radix_ht.null_groups) {
-		chunk.data[null_group].SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(chunk.data[null_group], true);
-	}
-	D_ASSERT(radix_ht.grouping_set.size() + radix_ht.null_groups.size() == radix_ht.op.GroupCount());
-	for (idx_t col_idx = 0; col_idx < radix_ht.op.aggregates.size(); col_idx++) {
-		chunk.data[radix_ht.op.GroupCount() + col_idx].Reference(
-		    scan_chunk.data[radix_ht.group_types.size() + col_idx]);
-	}
-	D_ASSERT(radix_ht.op.grouping_functions.size() == radix_ht.grouping_values.size());
-	for (idx_t i = 0; i < radix_ht.op.grouping_functions.size(); i++) {
-		chunk.data[radix_ht.op.GroupCount() + radix_ht.op.aggregates.size() + i].Reference(radix_ht.grouping_values[i]);
-	}
-	chunk.SetCardinality(scan_chunk);
-	D_ASSERT(chunk.size() != 0);
-}
-
-bool RadixHTLocalSourceState::TaskFinished() {
-	switch (task) {
-	case RadixHTSourceTaskType::FINALIZE:
-		return true;
-	case RadixHTSourceTaskType::SCAN:
-		return scan_status == RadixHTScanStatus::DONE;
-	default:
-		D_ASSERT(task == RadixHTSourceTaskType::NO_TASK);
-		return true;
-	}
-}
-
-SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &chunk,
-                                                    GlobalSinkState &sink_p, OperatorSourceInput &input) const {
-	auto &sink = sink_p.Cast<RadixHTGlobalSinkState>();
-	D_ASSERT(sink.finalized);
-
-	auto &gstate = input.global_state.Cast<RadixHTGlobalSourceState>();
-	auto &lstate = input.local_state.Cast<RadixHTLocalSourceState>();
-	D_ASSERT(sink.scan_pin_properties == TupleDataPinProperties::UNPIN_AFTER_DONE ||
-	         sink.scan_pin_properties == TupleDataPinProperties::DESTROY_AFTER_DONE);
-
-	if (gstate.finished) {
-		return SourceResultType::FINISHED;
-	}
-
-	if (sink.count_before_combining == 0) {
-		if (grouping_set.empty()) {
-			// Special case hack to sort out aggregating from empty intermediates for aggregations without groups
-			D_ASSERT(chunk.ColumnCount() == null_groups.size() + op.aggregates.size() + op.grouping_functions.size());
-			// For each column in the aggregates, set to initial state
-			chunk.SetCardinality(1);
-			for (auto null_group : null_groups) {
-				chunk.data[null_group].SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(chunk.data[null_group], true);
-			}
-			ArenaAllocator allocator(BufferAllocator::Get(context.client));
-			for (idx_t i = 0; i < op.aggregates.size(); i++) {
-				D_ASSERT(op.aggregates[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-				auto &aggr = op.aggregates[i]->Cast<BoundAggregateExpression>();
-				auto aggr_state = make_unsafe_uniq_array_uninitialized<data_t>(aggr.function.state_size(aggr.function));
-				aggr.function.initialize(aggr.function, aggr_state.get());
-
-				AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
-				Vector state_vector(Value::POINTER(CastPointerToValue(aggr_state.get())));
-				aggr.function.finalize(state_vector, aggr_input_data, chunk.data[null_groups.size() + i], 1, 0);
-				if (aggr.function.destructor) {
-					aggr.function.destructor(state_vector, aggr_input_data, 1);
-				}
-			}
-			// Place the grouping values (all the groups of the grouping_set condensed into a single value)
-			// Behind the null groups + aggregates
-			for (idx_t i = 0; i < op.grouping_functions.size(); i++) {
-				chunk.data[null_groups.size() + op.aggregates.size() + i].Reference(grouping_values[i]);
-			}
-		}
-		gstate.finished = true;
-		return SourceResultType::FINISHED;
-	}
-
-	while (!gstate.finished && chunk.size() == 0) {
-		if (lstate.TaskFinished()) {
-			const auto res = gstate.AssignTask(sink, lstate, input.interrupt_state);
-			if (res != SourceResultType::HAVE_MORE_OUTPUT) {
-				D_ASSERT(res == SourceResultType::FINISHED || res == SourceResultType::BLOCKED);
-				return res;
-			}
-		}
-		lstate.ExecuteTask(sink, gstate, chunk);
-	}
-
-	if (chunk.size() != 0) {
-		return SourceResultType::HAVE_MORE_OUTPUT;
-	} else {
-		return SourceResultType::FINISHED;
-	}
-}
-
-ProgressData RadixPartitionedHashTable::GetProgress(ClientContext &, GlobalSinkState &sink_p,
-                                                    GlobalSourceState &gstate_p) const {
-	auto &sink = sink_p.Cast<RadixHTGlobalSinkState>();
-	auto &gstate = gstate_p.Cast<RadixHTGlobalSourceState>();
-
-	// Get partition combine progress, weigh it 2x
-	ProgressData progress;
-	for (auto &partition : sink.partitions) {
-		progress.done += 2.0 * partition->progress;
-	}
-
-	// Get scan progress, weigh it 1x
-	progress.done += 1.0 * double(gstate.task_done);
-
-	// Divide by 3x for the weights, and the number of partitions to get a value between 0 and 1 again
-	progress.total += 3.0 * double(sink.partitions.size());
-
-	return progress;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/sample/base_reservoir_sample.cpp b/src/duckdb/src/execution/sample/base_reservoir_sample.cpp
deleted file mode 100644
index 0f0fcdf7a..000000000
--- a/src/duckdb/src/execution/sample/base_reservoir_sample.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-#include "duckdb/execution/reservoir_sample.hpp"
-#include <math.h>
-
-namespace duckdb {
-
-double BaseReservoirSampling::GetMinWeightFromTuplesSeen(idx_t rows_seen_total) {
-	// this function was obtained using https://mycurvefit.com. Inputting multiple x, y values into
-	// The
-	switch (rows_seen_total) {
-	case 0:
-		return 0;
-	case 1:
-		return 0.000161;
-	case 2:
-		return 0.530136;
-	case 3:
-		return 0.693454;
-	default: {
-		return (0.99 - 0.355 * std::exp(-0.07 * static_cast<double>(rows_seen_total)));
-	}
-	}
-}
-
-BaseReservoirSampling::BaseReservoirSampling(int64_t seed) : random(seed) {
-	next_index_to_sample = 0;
-	min_weight_threshold = 0;
-	min_weighted_entry_index = 0;
-	num_entries_to_skip_b4_next_sample = 0;
-	num_entries_seen_total = 0;
-}
-
-BaseReservoirSampling::BaseReservoirSampling() : BaseReservoirSampling(1) {
-}
-
-unique_ptr<BaseReservoirSampling> BaseReservoirSampling::Copy() {
-	auto ret = make_uniq<BaseReservoirSampling>(1);
-	ret->reservoir_weights = reservoir_weights;
-	ret->next_index_to_sample = next_index_to_sample;
-	ret->min_weight_threshold = min_weight_threshold;
-	ret->min_weighted_entry_index = min_weighted_entry_index;
-	ret->num_entries_to_skip_b4_next_sample = num_entries_to_skip_b4_next_sample;
-	ret->num_entries_seen_total = num_entries_seen_total;
-	return ret;
-}
-
-void BaseReservoirSampling::InitializeReservoirWeights(idx_t cur_size, idx_t sample_size) {
-	//! 1: The first m items of V are inserted into R
-	//! first we need to check if the reservoir already has "m" elements
-	//! 2. For each item vi ∈ R: Calculate a key ki = random(0, 1)
-	//! we then define the threshold to enter the reservoir T_w as the minimum key of R
-	//! we use a priority queue to extract the minimum key in O(1) time
-	if (cur_size == sample_size) {
-		//! 2. For each item vi ∈ R: Calculate a key ki = random(0, 1)
-		//! we then define the threshold to enter the reservoir T_w as the minimum key of R
-		//! we use a priority queue to extract the minimum key in O(1) time
-		for (idx_t i = 0; i < sample_size; i++) {
-			double k_i = random.NextRandom();
-			reservoir_weights.emplace(-k_i, i);
-		}
-		SetNextEntry();
-	}
-}
-
-void BaseReservoirSampling::SetNextEntry() {
-	D_ASSERT(!reservoir_weights.empty());
-	//! 4. Let r = random(0, 1) and Xw = log(r) / log(T_w)
-	auto &min_key = reservoir_weights.top();
-	double t_w = -min_key.first;
-	double r = random.NextRandom32();
-	double x_w = log(r) / log(t_w);
-	//! 5. From the current item vc skip items until item vi , such that:
-	//! 6. wc +wc+1 +···+wi−1 < Xw <= wc +wc+1 +···+wi−1 +wi
-	//! since all our weights are 1 (uniform sampling), we can just determine the amount of elements to skip
-	min_weight_threshold = t_w;
-	min_weighted_entry_index = min_key.second;
-	next_index_to_sample = MaxValue<idx_t>(1, idx_t(round(x_w)));
-	num_entries_to_skip_b4_next_sample = 0;
-}
-
-void BaseReservoirSampling::ReplaceElementWithIndex(idx_t entry_index, double with_weight, bool pop) {
-
-	if (pop) {
-		reservoir_weights.pop();
-	}
-	double r2 = with_weight;
-	//! now we insert the new weight into the reservoir
-	reservoir_weights.emplace(-r2, entry_index);
-	//! we update the min entry with the new min entry in the reservoir
-	SetNextEntry();
-}
-
-void BaseReservoirSampling::ReplaceElement(double with_weight) {
-	//! replace the entry in the reservoir
-	//! pop the minimum entry
-	reservoir_weights.pop();
-	//! now update the reservoir
-	//! 8. Let tw = Tw i , r2 = random(tw,1) and vi’s key: ki = (r2)1/wi
-	//! 9. The new threshold Tw is the new minimum key of R
-	//! we generate a random number between (min_weight_threshold, 1)
-	double r2 = random.NextRandom(min_weight_threshold, 1);
-
-	//! if we are merging two reservoir samples use the weight passed
-	if (with_weight >= 0) {
-		r2 = with_weight;
-	}
-	//! now we insert the new weight into the reservoir
-	reservoir_weights.emplace(-r2, min_weighted_entry_index);
-	//! we update the min entry with the new min entry in the reservoir
-	SetNextEntry();
-}
-
-void BaseReservoirSampling::UpdateMinWeightThreshold() {
-	if (!reservoir_weights.empty()) {
-		min_weight_threshold = -reservoir_weights.top().first;
-		min_weighted_entry_index = reservoir_weights.top().second;
-		return;
-	}
-	min_weight_threshold = 1;
-}
-
-void BaseReservoirSampling::FillWeights(SelectionVector &sel, idx_t &sel_size) {
-	if (!reservoir_weights.empty()) {
-		return;
-	}
-	D_ASSERT(reservoir_weights.empty());
-	auto num_entries_seen_normalized = num_entries_seen_total / FIXED_SAMPLE_SIZE;
-	auto min_weight = GetMinWeightFromTuplesSeen(num_entries_seen_normalized);
-	for (idx_t i = 0; i < sel_size; i++) {
-		auto weight = random.NextRandom(min_weight, 1);
-		reservoir_weights.emplace(-weight, i);
-	}
-	D_ASSERT(reservoir_weights.size() <= sel_size);
-	SetNextEntry();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/execution/sample/reservoir_sample.cpp b/src/duckdb/src/execution/sample/reservoir_sample.cpp
deleted file mode 100644
index ba777b609..000000000
--- a/src/duckdb/src/execution/sample/reservoir_sample.cpp
+++ /dev/null
@@ -1,930 +0,0 @@
-#include "duckdb/execution/reservoir_sample.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include <unordered_set>
-
-namespace duckdb {
-
-std::pair<double, idx_t> BlockingSample::PopFromWeightQueue() {
-	D_ASSERT(base_reservoir_sample && !base_reservoir_sample->reservoir_weights.empty());
-	auto ret = base_reservoir_sample->reservoir_weights.top();
-	base_reservoir_sample->reservoir_weights.pop();
-
-	base_reservoir_sample->UpdateMinWeightThreshold();
-	D_ASSERT(base_reservoir_sample->min_weight_threshold > 0);
-	return ret;
-}
-
-double BlockingSample::GetMinWeightThreshold() {
-	return base_reservoir_sample->min_weight_threshold;
-}
-
-idx_t BlockingSample::GetPriorityQueueSize() {
-	return base_reservoir_sample->reservoir_weights.size();
-}
-
-void BlockingSample::Destroy() {
-	destroyed = true;
-}
-
-void ReservoirChunk::Serialize(Serializer &serializer) const {
-	chunk.Serialize(serializer);
-}
-
-unique_ptr<ReservoirChunk> ReservoirChunk::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<ReservoirChunk>();
-	result->chunk.Deserialize(deserializer);
-	return result;
-}
-
-unique_ptr<ReservoirChunk> ReservoirChunk::Copy() const {
-	auto copy = make_uniq<ReservoirChunk>();
-	copy->chunk.Initialize(Allocator::DefaultAllocator(), chunk.GetTypes());
-
-	chunk.Copy(copy->chunk);
-	return copy;
-}
-
-ReservoirSample::ReservoirSample(idx_t sample_count, unique_ptr<ReservoirChunk> reservoir_chunk)
-    : ReservoirSample(Allocator::DefaultAllocator(), sample_count, 1) {
-	if (reservoir_chunk) {
-		this->reservoir_chunk = std::move(reservoir_chunk);
-		sel_size = this->reservoir_chunk->chunk.size();
-		sel = SelectionVector(0, sel_size);
-		ExpandSerializedSample();
-	}
-	stats_sample = true;
-}
-
-ReservoirSample::ReservoirSample(Allocator &allocator, idx_t sample_count, int64_t seed)
-    : BlockingSample(seed), sample_count(sample_count), allocator(allocator) {
-	base_reservoir_sample = make_uniq<BaseReservoirSampling>(seed);
-	type = SampleType::RESERVOIR_SAMPLE;
-	reservoir_chunk = nullptr;
-	stats_sample = false;
-	sel = SelectionVector(sample_count);
-	sel_size = 0;
-}
-
-idx_t ReservoirSample::GetSampleCount() {
-	return sample_count;
-}
-
-idx_t ReservoirSample::NumSamplesCollected() const {
-	if (!reservoir_chunk) {
-		return 0;
-	}
-	return reservoir_chunk->chunk.size();
-}
-
-SamplingState ReservoirSample::GetSamplingState() const {
-	if (base_reservoir_sample->reservoir_weights.empty()) {
-		return SamplingState::RANDOM;
-	}
-	return SamplingState::RESERVOIR;
-}
-
-idx_t ReservoirSample::GetActiveSampleCount() const {
-	switch (GetSamplingState()) {
-	case SamplingState::RANDOM:
-		return sel_size;
-	case SamplingState::RESERVOIR:
-		return base_reservoir_sample->reservoir_weights.size();
-	default:
-		throw InternalException("Sampling State is INVALID");
-	}
-}
-
-idx_t ReservoirSample::GetTuplesSeen() const {
-	return base_reservoir_sample->num_entries_seen_total;
-}
-
-DataChunk &ReservoirSample::Chunk() {
-	D_ASSERT(reservoir_chunk);
-	return reservoir_chunk->chunk;
-}
-
-unique_ptr<DataChunk> ReservoirSample::GetChunk() {
-	if (destroyed || !reservoir_chunk || Chunk().size() == 0) {
-		return nullptr;
-	}
-	// cannot destory internal samples.
-	auto ret = make_uniq<DataChunk>();
-
-	SelectionVector ret_sel(STANDARD_VECTOR_SIZE);
-	idx_t collected_samples = GetActiveSampleCount();
-
-	if (collected_samples == 0) {
-		return nullptr;
-	}
-
-	idx_t samples_remaining;
-	idx_t return_chunk_size;
-	if (collected_samples > STANDARD_VECTOR_SIZE) {
-		samples_remaining = collected_samples - STANDARD_VECTOR_SIZE;
-		return_chunk_size = STANDARD_VECTOR_SIZE;
-	} else {
-		samples_remaining = 0;
-		return_chunk_size = collected_samples;
-	}
-
-	for (idx_t i = samples_remaining; i < collected_samples; i++) {
-		// pop samples and reduce size of selection vector.
-		if (GetSamplingState() == SamplingState::RESERVOIR) {
-			auto top = PopFromWeightQueue();
-			ret_sel.set_index(i - samples_remaining, sel.get_index(top.second));
-		} else {
-			ret_sel.set_index(i - samples_remaining, sel.get_index(i));
-		}
-		sel_size -= 1;
-	}
-
-	auto reservoir_types = Chunk().GetTypes();
-
-	ret->Initialize(allocator, reservoir_types, STANDARD_VECTOR_SIZE);
-	ret->Slice(Chunk(), ret_sel, return_chunk_size);
-	ret->SetCardinality(return_chunk_size);
-	return ret;
-}
-
-unique_ptr<ReservoirChunk> ReservoirSample::CreateNewSampleChunk(vector<LogicalType> &types, idx_t size) const {
-	auto new_sample_chunk = make_uniq<ReservoirChunk>();
-	new_sample_chunk->chunk.Initialize(Allocator::DefaultAllocator(), types, size);
-
-	// set the NULL columns correctly
-	for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) {
-		if (!ValidSampleType(types[col_idx]) && stats_sample) {
-			new_sample_chunk->chunk.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(new_sample_chunk->chunk.data[col_idx], true);
-		}
-	}
-	return new_sample_chunk;
-}
-
-void ReservoirSample::Vacuum() {
-	Verify();
-	if (NumSamplesCollected() <= FIXED_SAMPLE_SIZE || !reservoir_chunk || destroyed) {
-		// sample is destroyed or too small to shrink
-		return;
-	}
-
-	auto ret = Copy();
-	auto ret_reservoir = duckdb::unique_ptr_cast<BlockingSample, ReservoirSample>(std::move(ret));
-	reservoir_chunk = std::move(ret_reservoir->reservoir_chunk);
-	sel = std::move(ret_reservoir->sel);
-	sel_size = ret_reservoir->sel_size;
-
-	Verify();
-	// We should only have one sample chunk now.
-	D_ASSERT(Chunk().size() > 0 && Chunk().size() <= sample_count);
-}
-
-unique_ptr<BlockingSample> ReservoirSample::Copy() const {
-
-	auto ret = make_uniq<ReservoirSample>(sample_count);
-	ret->stats_sample = stats_sample;
-
-	ret->base_reservoir_sample = base_reservoir_sample->Copy();
-	ret->destroyed = destroyed;
-
-	if (!reservoir_chunk || destroyed) {
-		return unique_ptr_cast<ReservoirSample, BlockingSample>(std::move(ret));
-	}
-
-	D_ASSERT(reservoir_chunk);
-
-	// create a new sample chunk to store new samples
-	auto types = reservoir_chunk->chunk.GetTypes();
-	// how many values should be copied
-	idx_t values_to_copy = MinValue<idx_t>(GetActiveSampleCount(), sample_count);
-
-	auto new_sample_chunk = CreateNewSampleChunk(types, GetReservoirChunkCapacity());
-
-	SelectionVector sel_copy(sel);
-
-	ret->reservoir_chunk = std::move(new_sample_chunk);
-	ret->UpdateSampleAppend(ret->reservoir_chunk->chunk, reservoir_chunk->chunk, sel_copy, values_to_copy);
-	ret->sel = SelectionVector(values_to_copy);
-	for (idx_t i = 0; i < values_to_copy; i++) {
-		ret->sel.set_index(i, i);
-	}
-	ret->sel_size = sel_size;
-	D_ASSERT(ret->reservoir_chunk->chunk.size() <= sample_count);
-	ret->Verify();
-	return unique_ptr_cast<ReservoirSample, BlockingSample>(std::move(ret));
-}
-
-void ReservoirSample::ConvertToReservoirSample() {
-	D_ASSERT(sel_size <= sample_count);
-	base_reservoir_sample->FillWeights(sel, sel_size);
-}
-
-vector<uint32_t> ReservoirSample::GetRandomizedVector(uint32_t range, uint32_t size) const {
-	vector<uint32_t> ret;
-	ret.reserve(range);
-	for (uint32_t i = 0; i < range; i++) {
-		ret.push_back(i);
-	}
-	if (size == FIXED_SAMPLE_SIZE) {
-		std::shuffle(ret.begin(), ret.end(), base_reservoir_sample->random);
-		return ret;
-	}
-	for (uint32_t i = 0; i < size; i++) {
-		uint32_t random_shuffle = base_reservoir_sample->random.NextRandomInteger32(i, range);
-		if (random_shuffle == i) {
-			// leave the value where it is
-			continue;
-		}
-		uint32_t tmp = ret[random_shuffle];
-		// basically replacing the tuple that was at index actual_sample_indexes[random_shuffle]
-		ret[random_shuffle] = ret[i];
-		ret[i] = tmp;
-	}
-	return ret;
-}
-
-void ReservoirSample::SimpleMerge(ReservoirSample &other) {
-	D_ASSERT(GetPriorityQueueSize() == 0);
-	D_ASSERT(other.GetPriorityQueueSize() == 0);
-	D_ASSERT(GetSamplingState() == SamplingState::RANDOM);
-	D_ASSERT(other.GetSamplingState() == SamplingState::RANDOM);
-
-	if (other.GetActiveSampleCount() == 0 && other.GetTuplesSeen() == 0) {
-		return;
-	}
-
-	if (GetActiveSampleCount() == 0 && GetTuplesSeen() == 0) {
-		sel = SelectionVector(other.sel);
-		sel_size = other.sel_size;
-		base_reservoir_sample->num_entries_seen_total = other.GetTuplesSeen();
-		return;
-	}
-
-	idx_t total_seen = GetTuplesSeen() + other.GetTuplesSeen();
-
-	auto weight_tuples_this = static_cast<double>(GetTuplesSeen()) / static_cast<double>(total_seen);
-	auto weight_tuples_other = static_cast<double>(other.GetTuplesSeen()) / static_cast<double>(total_seen);
-
-	// If weights don't add up to 1, most likely a simple merge occured and no new samples were added.
-	// if that is the case, add the missing weight to the lower weighted sample to adjust.
-	// this is to avoid cases where if you have a 20k row table and add another 20k rows row by row
-	// then eventually the missing weights will add up, and get you a more even distribution
-	if (weight_tuples_this + weight_tuples_other < 1) {
-		weight_tuples_other += 1 - (weight_tuples_other + weight_tuples_this);
-	}
-
-	idx_t keep_from_this = 0;
-	idx_t keep_from_other = 0;
-	D_ASSERT(stats_sample);
-	D_ASSERT(sample_count == FIXED_SAMPLE_SIZE);
-	D_ASSERT(sample_count == other.sample_count);
-	auto sample_count_double = static_cast<double>(sample_count);
-
-	if (weight_tuples_this > weight_tuples_other) {
-		keep_from_this = MinValue<idx_t>(static_cast<idx_t>(round(sample_count_double * weight_tuples_this)),
-		                                 GetActiveSampleCount());
-		keep_from_other = MinValue<idx_t>(sample_count - keep_from_this, other.GetActiveSampleCount());
-	} else {
-		keep_from_other = MinValue<idx_t>(static_cast<idx_t>(round(sample_count_double * weight_tuples_other)),
-		                                  other.GetActiveSampleCount());
-		keep_from_this = MinValue<idx_t>(sample_count - keep_from_other, GetActiveSampleCount());
-	}
-
-	D_ASSERT(keep_from_this <= GetActiveSampleCount());
-	D_ASSERT(keep_from_other <= other.GetActiveSampleCount());
-	D_ASSERT(keep_from_other + keep_from_this <= FIXED_SAMPLE_SIZE);
-	idx_t size_after_merge = MinValue<idx_t>(keep_from_other + keep_from_this, FIXED_SAMPLE_SIZE);
-
-	// Check if appending the other samples to this will go over the sample chunk size
-	if (reservoir_chunk->chunk.size() + keep_from_other > GetReservoirChunkCapacity()) {
-		Vacuum();
-	}
-
-	D_ASSERT(size_after_merge <= other.GetActiveSampleCount() + GetActiveSampleCount());
-	SelectionVector chunk_sel(keep_from_other);
-	auto offset = reservoir_chunk->chunk.size();
-	for (idx_t i = keep_from_this; i < size_after_merge; i++) {
-		if (i >= GetActiveSampleCount()) {
-			sel.set_index(GetActiveSampleCount(), offset);
-			sel_size += 1;
-		} else {
-			sel.set_index(i, offset);
-		}
-		chunk_sel.set_index(i - keep_from_this, other.sel.get_index(i - keep_from_this));
-		offset += 1;
-	}
-
-	D_ASSERT(GetActiveSampleCount() == size_after_merge);
-
-	// Copy the rows that make it to the sample from other and put them into this.
-	UpdateSampleAppend(reservoir_chunk->chunk, other.reservoir_chunk->chunk, chunk_sel, keep_from_other);
-	base_reservoir_sample->num_entries_seen_total += other.GetTuplesSeen();
-
-	// if THIS has too many samples now, we conver it to a slower sample.
-	if (GetTuplesSeen() >= FIXED_SAMPLE_SIZE * FAST_TO_SLOW_THRESHOLD) {
-		ConvertToReservoirSample();
-	}
-	Verify();
-}
-
-void ReservoirSample::WeightedMerge(ReservoirSample &other_sample) {
-	D_ASSERT(GetSamplingState() == SamplingState::RESERVOIR);
-	D_ASSERT(other_sample.GetSamplingState() == SamplingState::RESERVOIR);
-
-	// Find out how many samples we want to keep.
-	idx_t total_samples = GetActiveSampleCount() + other_sample.GetActiveSampleCount();
-	idx_t total_samples_seen =
-	    base_reservoir_sample->num_entries_seen_total + other_sample.base_reservoir_sample->num_entries_seen_total;
-	idx_t num_samples_to_keep = MinValue<idx_t>(total_samples, MinValue<idx_t>(sample_count, total_samples_seen));
-
-	D_ASSERT(GetActiveSampleCount() <= num_samples_to_keep);
-	D_ASSERT(total_samples <= FIXED_SAMPLE_SIZE * 2);
-
-	// pop from base base_reservoir weights until there are num_samples_to_keep left.
-	vector<idx_t> this_indexes_to_replace;
-	for (idx_t i = num_samples_to_keep; i < total_samples; i++) {
-		auto min_weight_this = base_reservoir_sample->min_weight_threshold;
-		auto min_weight_other = other_sample.base_reservoir_sample->min_weight_threshold;
-		// min weight threshol is always positive
-		if (min_weight_this > min_weight_other) {
-			// pop from other
-			other_sample.base_reservoir_sample->reservoir_weights.pop();
-			other_sample.base_reservoir_sample->UpdateMinWeightThreshold();
-		} else {
-			auto top_this = PopFromWeightQueue();
-			this_indexes_to_replace.push_back(top_this.second);
-			base_reservoir_sample->UpdateMinWeightThreshold();
-		}
-	}
-
-	D_ASSERT(other_sample.GetPriorityQueueSize() + GetPriorityQueueSize() <= FIXED_SAMPLE_SIZE);
-	D_ASSERT(other_sample.GetPriorityQueueSize() + GetPriorityQueueSize() == num_samples_to_keep);
-	D_ASSERT(other_sample.reservoir_chunk->chunk.GetTypes() == reservoir_chunk->chunk.GetTypes());
-
-	// Prepare a selection vector to copy data from the other sample chunk to this sample chunk
-	SelectionVector sel_other(other_sample.GetPriorityQueueSize());
-	D_ASSERT(GetPriorityQueueSize() <= num_samples_to_keep);
-	D_ASSERT(other_sample.GetPriorityQueueSize() >= this_indexes_to_replace.size());
-	idx_t chunk_offset = 0;
-
-	// Now push weights from other.base_reservoir_sample to this
-	// Depending on how many sample values "this" has, we either need to add to the selection vector
-	// Or replace values in "this'" selection vector
-	idx_t i = 0;
-	while (other_sample.GetPriorityQueueSize() > 0) {
-		auto other_top = other_sample.PopFromWeightQueue();
-		idx_t index_for_new_pair = chunk_offset + reservoir_chunk->chunk.size();
-
-		// update the sel used to copy values from other to this
-		sel_other.set_index(chunk_offset, other_top.second);
-		if (i < this_indexes_to_replace.size()) {
-			auto replacement_index = this_indexes_to_replace[i];
-			sel.set_index(replacement_index, index_for_new_pair);
-			other_top.second = replacement_index;
-		} else {
-			sel.set_index(sel_size, index_for_new_pair);
-			other_top.second = sel_size;
-			sel_size += 1;
-		}
-
-		// make sure that the sample indexes are (this.sample_chunk.size() + chunk_offfset)
-		base_reservoir_sample->reservoir_weights.push(other_top);
-		chunk_offset += 1;
-		i += 1;
-	}
-
-	D_ASSERT(GetPriorityQueueSize() == num_samples_to_keep);
-
-	base_reservoir_sample->UpdateMinWeightThreshold();
-	D_ASSERT(base_reservoir_sample->min_weight_threshold > 0);
-	base_reservoir_sample->num_entries_seen_total = GetTuplesSeen() + other_sample.GetTuplesSeen();
-
-	UpdateSampleAppend(reservoir_chunk->chunk, other_sample.reservoir_chunk->chunk, sel_other, chunk_offset);
-	if (reservoir_chunk->chunk.size() > FIXED_SAMPLE_SIZE * (FIXED_SAMPLE_SIZE_MULTIPLIER - 3)) {
-		Vacuum();
-	}
-
-	Verify();
-}
-
-void ReservoirSample::Merge(unique_ptr<BlockingSample> other) {
-	if (destroyed || other->destroyed) {
-		Destroy();
-		return;
-	}
-
-	D_ASSERT(other->type == SampleType::RESERVOIR_SAMPLE);
-	auto &other_sample = other->Cast<ReservoirSample>();
-
-	// if the other sample has not collected anything yet return
-	if (!other_sample.reservoir_chunk || other_sample.reservoir_chunk->chunk.size() == 0) {
-		return;
-	}
-
-	// this has not collected samples, take over the other
-	if (!reservoir_chunk || reservoir_chunk->chunk.size() == 0) {
-		base_reservoir_sample = std::move(other->base_reservoir_sample);
-		reservoir_chunk = std::move(other_sample.reservoir_chunk);
-		sel = SelectionVector(other_sample.sel);
-		sel_size = other_sample.sel_size;
-		Verify();
-		return;
-	}
-	//! Both samples are still in "fast sampling" method
-	if (GetSamplingState() == SamplingState::RANDOM && other_sample.GetSamplingState() == SamplingState::RANDOM) {
-		SimpleMerge(other_sample);
-		return;
-	}
-
-	// One or none of the samples are in "Fast Sampling" method.
-	// When this is the case, switch both to slow sampling
-	ConvertToReservoirSample();
-	other_sample.ConvertToReservoirSample();
-	WeightedMerge(other_sample);
-}
-
-void ReservoirSample::ShuffleSel(SelectionVector &sel, idx_t range, idx_t size) const {
-	auto randomized = GetRandomizedVector(static_cast<uint32_t>(range), static_cast<uint32_t>(size));
-	SelectionVector original_sel(range);
-	for (idx_t i = 0; i < range; i++) {
-		original_sel.set_index(i, sel.get_index(i));
-	}
-	for (idx_t i = 0; i < size; i++) {
-		sel.set_index(i, original_sel.get_index(randomized[i]));
-	}
-}
-
-void ReservoirSample::NormalizeWeights() {
-	vector<std::pair<double, idx_t>> tmp_weights;
-	while (!base_reservoir_sample->reservoir_weights.empty()) {
-		auto top = base_reservoir_sample->reservoir_weights.top();
-		tmp_weights.push_back(std::move(top));
-		base_reservoir_sample->reservoir_weights.pop();
-	}
-	std::sort(tmp_weights.begin(), tmp_weights.end(),
-	          [&](std::pair<double, idx_t> a, std::pair<double, idx_t> b) { return a.second < b.second; });
-	for (idx_t i = 0; i < tmp_weights.size(); i++) {
-		base_reservoir_sample->reservoir_weights.emplace(tmp_weights.at(i).first, i);
-	}
-	base_reservoir_sample->SetNextEntry();
-}
-
-void ReservoirSample::EvictOverBudgetSamples() {
-	Verify();
-	if (!reservoir_chunk || destroyed) {
-		return;
-	}
-
-	// since this is for serialization, we really need to make sure keep a
-	// minimum of 1% of the rows or 2048 rows
-	idx_t num_samples_to_keep =
-	    MinValue<idx_t>(FIXED_SAMPLE_SIZE, static_cast<idx_t>(SAVE_PERCENTAGE * static_cast<double>(GetTuplesSeen())));
-
-	if (num_samples_to_keep <= 0) {
-		reservoir_chunk->chunk.SetCardinality(0);
-		return;
-	}
-
-	if (num_samples_to_keep == sample_count) {
-		return;
-	}
-
-	// if we over sampled, make sure we only keep the highest percentage samples
-	std::unordered_set<idx_t> selections_to_delete;
-
-	while (num_samples_to_keep < GetPriorityQueueSize()) {
-		auto top = PopFromWeightQueue();
-		D_ASSERT(top.second < sel_size);
-		selections_to_delete.emplace(top.second);
-	}
-
-	// set up reservoir chunk for the reservoir sample
-	D_ASSERT(reservoir_chunk->chunk.size() <= sample_count);
-	// create a new sample chunk to store new samples
-	auto types = reservoir_chunk->chunk.GetTypes();
-	D_ASSERT(num_samples_to_keep <= sample_count);
-	D_ASSERT(stats_sample);
-	D_ASSERT(sample_count == FIXED_SAMPLE_SIZE);
-	auto new_reservoir_chunk = CreateNewSampleChunk(types, sample_count);
-
-	// The current selection vector can potentially have 2048 valid mappings.
-	// If we need to save a sample with less rows than that, we need to do the following
-	// 1. Create a new selection vector that doesn't point to the rows we are evicting
-	SelectionVector new_sel(num_samples_to_keep);
-	idx_t offset = 0;
-	for (idx_t i = 0; i < num_samples_to_keep + selections_to_delete.size(); i++) {
-		if (selections_to_delete.find(i) == selections_to_delete.end()) {
-			D_ASSERT(i - offset < num_samples_to_keep);
-			new_sel.set_index(i - offset, sel.get_index(i));
-		} else {
-			offset += 1;
-		}
-	}
-	// 2. Update row_ids in our weights so that they don't store rows ids to
-	//    indexes in the selection vector that have been evicted.
-	if (!selections_to_delete.empty()) {
-		NormalizeWeights();
-	}
-
-	D_ASSERT(reservoir_chunk->chunk.GetTypes() == new_reservoir_chunk->chunk.GetTypes());
-
-	UpdateSampleAppend(new_reservoir_chunk->chunk, reservoir_chunk->chunk, new_sel, num_samples_to_keep);
-	// set the cardinality
-	new_reservoir_chunk->chunk.SetCardinality(num_samples_to_keep);
-	reservoir_chunk = std::move(new_reservoir_chunk);
-	sel_size = num_samples_to_keep;
-	base_reservoir_sample->UpdateMinWeightThreshold();
-}
-
-void ReservoirSample::ExpandSerializedSample() {
-	if (!reservoir_chunk) {
-		return;
-	}
-
-	auto types = reservoir_chunk->chunk.GetTypes();
-	auto new_res_chunk = CreateNewSampleChunk(types, GetReservoirChunkCapacity());
-	auto copy_count = reservoir_chunk->chunk.size();
-	SelectionVector tmp_sel = SelectionVector(0, copy_count);
-	UpdateSampleAppend(new_res_chunk->chunk, reservoir_chunk->chunk, tmp_sel, copy_count);
-	new_res_chunk->chunk.SetCardinality(copy_count);
-	std::swap(reservoir_chunk, new_res_chunk);
-}
-
-idx_t ReservoirSample::GetReservoirChunkCapacity() const {
-	return sample_count + (FIXED_SAMPLE_SIZE_MULTIPLIER * FIXED_SAMPLE_SIZE);
-}
-
-idx_t ReservoirSample::FillReservoir(DataChunk &chunk) {
-
-	idx_t ingested_count = 0;
-	if (!reservoir_chunk) {
-		if (chunk.size() > FIXED_SAMPLE_SIZE) {
-			throw InternalException("Creating sample with DataChunk that is larger than the fixed sample size");
-		}
-		auto types = chunk.GetTypes();
-		// create a new sample chunk to store new samples
-		reservoir_chunk = CreateNewSampleChunk(types, GetReservoirChunkCapacity());
-	}
-
-	idx_t actual_sample_index_start = GetActiveSampleCount();
-	D_ASSERT(reservoir_chunk->chunk.ColumnCount() == chunk.ColumnCount());
-
-	if (reservoir_chunk->chunk.size() < sample_count) {
-		ingested_count = MinValue<idx_t>(sample_count - reservoir_chunk->chunk.size(), chunk.size());
-		auto random_other_sel =
-		    GetRandomizedVector(static_cast<uint32_t>(ingested_count), static_cast<uint32_t>(ingested_count));
-		SelectionVector sel_for_input_chunk(ingested_count);
-		for (idx_t i = 0; i < ingested_count; i++) {
-			sel.set_index(actual_sample_index_start + i, actual_sample_index_start + i);
-			sel_for_input_chunk.set_index(i, random_other_sel[i]);
-		}
-		UpdateSampleAppend(reservoir_chunk->chunk, chunk, sel_for_input_chunk, ingested_count);
-		sel_size += ingested_count;
-	}
-	D_ASSERT(GetActiveSampleCount() <= sample_count);
-	D_ASSERT(GetActiveSampleCount() >= ingested_count);
-	// always return how many tuples were ingested
-	return ingested_count;
-}
-
-void ReservoirSample::Destroy() {
-	destroyed = true;
-}
-
-SelectionVectorHelper ReservoirSample::GetReplacementIndexes(idx_t sample_chunk_offset,
-                                                             idx_t theoretical_chunk_length) {
-	if (GetSamplingState() == SamplingState::RANDOM) {
-		return GetReplacementIndexesFast(sample_chunk_offset, theoretical_chunk_length);
-	}
-	return GetReplacementIndexesSlow(sample_chunk_offset, theoretical_chunk_length);
-}
-
-SelectionVectorHelper ReservoirSample::GetReplacementIndexesFast(idx_t sample_chunk_offset, idx_t chunk_length) {
-
-	// how much weight to the other tuples have compared to the ones in this chunk?
-	auto weight_tuples_other = static_cast<double>(chunk_length) / static_cast<double>(GetTuplesSeen() + chunk_length);
-	auto num_to_pop = static_cast<uint32_t>(round(weight_tuples_other * static_cast<double>(sample_count)));
-	D_ASSERT(num_to_pop <= sample_count);
-	D_ASSERT(num_to_pop <= sel_size);
-	SelectionVectorHelper ret;
-
-	if (num_to_pop == 0) {
-		ret.sel = SelectionVector(num_to_pop);
-		ret.size = 0;
-		return ret;
-	}
-	std::unordered_map<idx_t, idx_t> replacement_indexes;
-	SelectionVector chunk_sel(num_to_pop);
-
-	auto random_indexes_chunk = GetRandomizedVector(static_cast<uint32_t>(chunk_length), num_to_pop);
-	auto random_sel_indexes = GetRandomizedVector(static_cast<uint32_t>(sel_size), num_to_pop);
-	for (idx_t i = 0; i < num_to_pop; i++) {
-		// update the selection vector for the reservoir sample
-		chunk_sel.set_index(i, random_indexes_chunk[i]);
-		// sel is not guaratneed to be random, so we update the indexes according to our
-		// random sel indexes.
-		sel.set_index(random_sel_indexes[i], sample_chunk_offset + i);
-	}
-
-	D_ASSERT(sel_size == sample_count);
-
-	ret.sel = SelectionVector(chunk_sel);
-	ret.size = num_to_pop;
-	return ret;
-}
-
-SelectionVectorHelper ReservoirSample::GetReplacementIndexesSlow(const idx_t sample_chunk_offset,
-                                                                 const idx_t chunk_length) {
-	idx_t remaining = chunk_length;
-	std::unordered_map<idx_t, idx_t> ret_map;
-	idx_t sample_chunk_index = 0;
-
-	idx_t base_offset = 0;
-
-	while (true) {
-		idx_t offset =
-		    base_reservoir_sample->next_index_to_sample - base_reservoir_sample->num_entries_to_skip_b4_next_sample;
-		if (offset >= remaining) {
-			// not in this chunk! increment current count and go to the next chunk
-			base_reservoir_sample->num_entries_to_skip_b4_next_sample += remaining;
-			break;
-		}
-		// in this chunk! replace the element
-		// ret[index_in_new_chunk] = index_in_sample_chunk (the sample chunk offset will be applied later)
-		// D_ASSERT(sample_chunk_index == ret.size());
-		ret_map[base_offset + offset] = sample_chunk_index;
-		double r2 = base_reservoir_sample->random.NextRandom32(base_reservoir_sample->min_weight_threshold, 1);
-		// replace element in our max_heap
-		// first get the top most pair
-		const auto top = PopFromWeightQueue();
-		const auto index = top.second;
-		const auto index_in_sample_chunk = sample_chunk_offset + sample_chunk_index;
-		sel.set_index(index, index_in_sample_chunk);
-		base_reservoir_sample->ReplaceElementWithIndex(index, r2, false);
-
-		sample_chunk_index += 1;
-		// shift the chunk forward
-		remaining -= offset;
-		base_offset += offset;
-	}
-
-	// create selection vector to return
-	SelectionVector ret_sel(ret_map.size());
-	D_ASSERT(sel_size == sample_count);
-	for (auto &kv : ret_map) {
-		ret_sel.set_index(kv.second, kv.first);
-	}
-	SelectionVectorHelper ret;
-	ret.sel = SelectionVector(ret_sel);
-	ret.size = static_cast<uint32_t>(ret_map.size());
-	return ret;
-}
-
-void ReservoirSample::Finalize() {
-}
-
-bool ReservoirSample::ValidSampleType(const LogicalType &type) {
-	return type.IsNumeric();
-}
-
-void ReservoirSample::UpdateSampleAppend(DataChunk &this_, DataChunk &other, SelectionVector &other_sel,
-                                         idx_t append_count) const {
-	idx_t new_size = this_.size() + append_count;
-	if (other.size() == 0) {
-		return;
-	}
-	D_ASSERT(this_.GetTypes() == other.GetTypes());
-
-	// UpdateSampleAppend(this_, other, other_sel, append_count);
-	D_ASSERT(this_.GetTypes() == other.GetTypes());
-	auto types = reservoir_chunk->chunk.GetTypes();
-
-	for (idx_t i = 0; i < reservoir_chunk->chunk.ColumnCount(); i++) {
-		auto col_type = types[i];
-		if (ValidSampleType(col_type) || !stats_sample) {
-			D_ASSERT(this_.data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-			VectorOperations::Copy(other.data[i], this_.data[i], other_sel, append_count, 0, this_.size());
-		}
-	}
-	this_.SetCardinality(new_size);
-}
-
-void ReservoirSample::AddToReservoir(DataChunk &chunk) {
-	if (destroyed || chunk.size() == 0) {
-		return;
-	}
-
-	idx_t tuples_consumed = FillReservoir(chunk);
-	base_reservoir_sample->num_entries_seen_total += tuples_consumed;
-	D_ASSERT(sample_count == 0 || reservoir_chunk->chunk.size() >= 1);
-
-	if (tuples_consumed == chunk.size()) {
-		return;
-	}
-
-	// the chunk filled the first FIXED_SAMPLE_SIZE chunk but still has tuples remaining
-	// slice the chunk and call AddToReservoir again.
-	if (tuples_consumed != chunk.size() && tuples_consumed != 0) {
-		// Fill reservoir consumed some of the chunk to reach FIXED_SAMPLE_SIZE
-		// now we need to
-		// So we slice it and call AddToReservoir
-		auto slice = make_uniq<DataChunk>();
-		auto samples_remaining = chunk.size() - tuples_consumed;
-		auto types = chunk.GetTypes();
-		SelectionVector input_sel(samples_remaining);
-		for (idx_t i = 0; i < samples_remaining; i++) {
-			input_sel.set_index(i, tuples_consumed + i);
-		}
-		slice->Initialize(Allocator::DefaultAllocator(), types, samples_remaining);
-		slice->Slice(chunk, input_sel, samples_remaining);
-		slice->SetCardinality(samples_remaining);
-		AddToReservoir(*slice);
-		return;
-	}
-
-	// at this point we should have collected at least sample count samples
-	D_ASSERT(GetActiveSampleCount() >= sample_count);
-
-	auto chunk_sel = GetReplacementIndexes(reservoir_chunk->chunk.size(), chunk.size());
-
-	if (chunk_sel.size == 0) {
-		// not adding any samples
-		return;
-	}
-	idx_t size = chunk_sel.size;
-	D_ASSERT(size <= chunk.size());
-
-	UpdateSampleAppend(reservoir_chunk->chunk, chunk, chunk_sel.sel, size);
-
-	base_reservoir_sample->num_entries_seen_total += chunk.size();
-	D_ASSERT(base_reservoir_sample->reservoir_weights.size() == 0 ||
-	         base_reservoir_sample->reservoir_weights.size() == sample_count);
-
-	Verify();
-
-	// if we are over the threshold, we ned to swith to slow sampling.
-	if (GetSamplingState() == SamplingState::RANDOM && GetTuplesSeen() >= FIXED_SAMPLE_SIZE * FAST_TO_SLOW_THRESHOLD) {
-		ConvertToReservoirSample();
-	}
-	if (reservoir_chunk->chunk.size() >= (GetReservoirChunkCapacity() - (static_cast<idx_t>(FIXED_SAMPLE_SIZE) * 3))) {
-		Vacuum();
-	}
-}
-
-void ReservoirSample::Verify() {
-#ifdef DEBUG
-	if (destroyed) {
-		return;
-	}
-	if (GetPriorityQueueSize() == 0) {
-		D_ASSERT(GetActiveSampleCount() <= sample_count);
-		D_ASSERT(GetTuplesSeen() >= GetActiveSampleCount());
-		return;
-	}
-	if (NumSamplesCollected() > sample_count) {
-		D_ASSERT(GetPriorityQueueSize() == sample_count);
-	} else if (NumSamplesCollected() <= sample_count && GetPriorityQueueSize() > 0) {
-		// it's possible to collect more samples than your priority queue size.
-		// see sample_converts_to_reservoir_sample.test
-		D_ASSERT(NumSamplesCollected() >= GetPriorityQueueSize());
-	}
-	auto base_reservoir_copy = base_reservoir_sample->Copy();
-	std::unordered_map<idx_t, idx_t> index_count;
-	while (!base_reservoir_copy->reservoir_weights.empty()) {
-		auto &pair = base_reservoir_copy->reservoir_weights.top();
-		if (index_count.find(pair.second) == index_count.end()) {
-			index_count[pair.second] = 1;
-			base_reservoir_copy->reservoir_weights.pop();
-		} else {
-			index_count[pair.second] += 1;
-			base_reservoir_copy->reservoir_weights.pop();
-			throw InternalException("Duplicate selection index in reservoir weights");
-		}
-	}
-	// TODO: Verify the Sel as well. No duplicate indices.
-
-	if (reservoir_chunk) {
-		reservoir_chunk->chunk.Verify();
-	}
-#endif
-}
-
-ReservoirSamplePercentage::ReservoirSamplePercentage(double percentage, int64_t seed, idx_t reservoir_sample_size)
-    : BlockingSample(seed), allocator(Allocator::DefaultAllocator()), sample_percentage(percentage / 100.0),
-      reservoir_sample_size(reservoir_sample_size), current_count(0), is_finalized(false) {
-	current_sample = make_uniq<ReservoirSample>(allocator, reservoir_sample_size, base_reservoir_sample->random());
-	type = SampleType::RESERVOIR_PERCENTAGE_SAMPLE;
-}
-
-ReservoirSamplePercentage::ReservoirSamplePercentage(Allocator &allocator, double percentage, int64_t seed)
-    : BlockingSample(seed), allocator(allocator), sample_percentage(percentage / 100.0), current_count(0),
-      is_finalized(false) {
-	reservoir_sample_size = (idx_t)(sample_percentage * RESERVOIR_THRESHOLD);
-	current_sample = make_uniq<ReservoirSample>(allocator, reservoir_sample_size, base_reservoir_sample->random());
-	type = SampleType::RESERVOIR_PERCENTAGE_SAMPLE;
-}
-
-ReservoirSamplePercentage::ReservoirSamplePercentage(double percentage, int64_t seed)
-    : ReservoirSamplePercentage(Allocator::DefaultAllocator(), percentage, seed) {
-}
-
-void ReservoirSamplePercentage::AddToReservoir(DataChunk &input) {
-	base_reservoir_sample->num_entries_seen_total += input.size();
-	if (current_count + input.size() > RESERVOIR_THRESHOLD) {
-		// we don't have enough space in our current reservoir
-		// first check what we still need to append to the current sample
-		idx_t append_to_current_sample_count = RESERVOIR_THRESHOLD - current_count;
-		idx_t append_to_next_sample = input.size() - append_to_current_sample_count;
-		if (append_to_current_sample_count > 0) {
-			// we have elements remaining, first add them to the current sample
-			if (append_to_next_sample > 0) {
-				// we need to also add to the next sample
-				DataChunk new_chunk;
-				new_chunk.InitializeEmpty(input.GetTypes());
-				new_chunk.Slice(input, *FlatVector::IncrementalSelectionVector(), append_to_current_sample_count);
-				new_chunk.Flatten();
-				current_sample->AddToReservoir(new_chunk);
-			} else {
-				input.Flatten();
-				input.SetCardinality(append_to_current_sample_count);
-				current_sample->AddToReservoir(input);
-			}
-		}
-		if (append_to_next_sample > 0) {
-			// slice the input for the remainder
-			SelectionVector sel(append_to_next_sample);
-			for (idx_t i = append_to_current_sample_count; i < append_to_next_sample + append_to_current_sample_count;
-			     i++) {
-				sel.set_index(i - append_to_current_sample_count, i);
-			}
-			input.Slice(sel, append_to_next_sample);
-		}
-		// now our first sample is filled: append it to the set of finished samples
-		finished_samples.push_back(std::move(current_sample));
-
-		// allocate a new sample, and potentially add the remainder of the current input to that sample
-		current_sample = make_uniq<ReservoirSample>(allocator, reservoir_sample_size, base_reservoir_sample->random());
-		if (append_to_next_sample > 0) {
-			current_sample->AddToReservoir(input);
-		}
-		current_count = append_to_next_sample;
-	} else {
-		// we can just append to the current sample
-		current_count += input.size();
-		current_sample->AddToReservoir(input);
-	}
-}
-
-unique_ptr<DataChunk> ReservoirSamplePercentage::GetChunk() {
-	// reservoir sample percentage should never stay
-	if (!is_finalized) {
-		Finalize();
-	}
-	while (!finished_samples.empty()) {
-		auto &front = finished_samples.front();
-		auto chunk = front->GetChunk();
-		if (chunk && chunk->size() > 0) {
-			return chunk;
-		}
-		// move to the next sample
-		finished_samples.erase(finished_samples.begin());
-	}
-	return nullptr;
-}
-
-unique_ptr<BlockingSample> ReservoirSamplePercentage::Copy() const {
-	throw InternalException("Cannot call Copy on ReservoirSample Percentage");
-}
-
-void ReservoirSamplePercentage::Finalize() {
-	// need to finalize the current sample, if any
-	// we are finializing, so we are starting to return chunks. Our last chunk has
-	// sample_percentage * RESERVOIR_THRESHOLD entries that hold samples.
-	// if our current count is less than the sample_percentage * RESERVOIR_THRESHOLD
-	// then we have sampled too much for the current_sample and we need to redo the sample
-	// otherwise we can just push the current sample back
-	// Imagine sampling 70% of 100 rows (so 70 rows). We allocate sample_percentage * RESERVOIR_THRESHOLD
-	// -----------------------------------------
-	auto sampled_more_than_required =
-	    static_cast<double>(current_count) > sample_percentage * RESERVOIR_THRESHOLD || finished_samples.empty();
-	if (current_count > 0 && sampled_more_than_required) {
-		// create a new sample
-		auto new_sample_size = static_cast<idx_t>(round(sample_percentage * static_cast<double>(current_count)));
-		auto new_sample = make_uniq<ReservoirSample>(allocator, new_sample_size, base_reservoir_sample->random());
-		while (true) {
-			auto chunk = current_sample->GetChunk();
-			if (!chunk || chunk->size() == 0) {
-				break;
-			}
-			new_sample->AddToReservoir(*chunk);
-		}
-		finished_samples.push_back(std::move(new_sample));
-	} else {
-		finished_samples.push_back(std::move(current_sample));
-	}
-	// when finalizing, current_sample is null. All samples are now in finished samples.
-	current_sample = nullptr;
-	is_finalized = true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/aggregate/distributive/count.cpp b/src/duckdb/src/function/aggregate/distributive/count.cpp
deleted file mode 100644
index 30824b7a2..000000000
--- a/src/duckdb/src/function/aggregate/distributive/count.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-struct BaseCountFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		target += source;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		target = state;
-	}
-};
-
-struct CountStarFunction : public BaseCountFunction {
-	template <class STATE, class OP>
-	static void Operation(STATE &state, AggregateInputData &, idx_t idx) {
-		state += 1;
-	}
-
-	template <class STATE, class OP>
-	static void ConstantOperation(STATE &state, AggregateInputData &, idx_t count) {
-		state += count;
-	}
-
-	template <typename RESULT_TYPE>
-	static void Window(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition, const_data_ptr_t,
-	                   data_ptr_t l_state, const SubFrames &frames, Vector &result, idx_t rid) {
-		D_ASSERT(partition.column_ids.empty());
-
-		auto data = FlatVector::GetData<RESULT_TYPE>(result);
-		RESULT_TYPE total = 0;
-		for (const auto &frame : frames) {
-			const auto begin = frame.start;
-			const auto end = frame.end;
-
-			// Slice to any filtered rows
-			if (partition.filter_mask.AllValid()) {
-				total += end - begin;
-				continue;
-			}
-			for (auto i = begin; i < end; ++i) {
-				total += partition.filter_mask.RowIsValid(i);
-			}
-		}
-		data[rid] = total;
-	}
-};
-
-struct CountFunction : public BaseCountFunction {
-	using STATE = int64_t;
-
-	static void Operation(STATE &state) {
-		state += 1;
-	}
-
-	static void ConstantOperation(STATE &state, idx_t count) {
-		state += UnsafeNumericCast<STATE>(count);
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	static inline void CountFlatLoop(STATE **__restrict states, ValidityMask &mask, idx_t count) {
-		if (!mask.AllValid()) {
-			idx_t base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						CountFunction::Operation(*states[base_idx]);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							CountFunction::Operation(*states[base_idx]);
-						}
-					}
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				CountFunction::Operation(*states[i]);
-			}
-		}
-	}
-
-	static inline void CountScatterLoop(STATE **__restrict states, const SelectionVector &isel,
-	                                    const SelectionVector &ssel, ValidityMask &mask, idx_t count) {
-		if (!mask.AllValid()) {
-			// potential NULL values
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				if (mask.RowIsValid(idx)) {
-					CountFunction::Operation(*states[sidx]);
-				}
-			}
-		} else {
-			// quick path: no NULL values
-			for (idx_t i = 0; i < count; i++) {
-				auto sidx = ssel.get_index(i);
-				CountFunction::Operation(*states[sidx]);
-			}
-		}
-	}
-
-	static void CountScatter(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
-	                         idx_t count) {
-		auto &input = inputs[0];
-		if (input.GetVectorType() == VectorType::FLAT_VECTOR && states.GetVectorType() == VectorType::FLAT_VECTOR) {
-			auto sdata = FlatVector::GetData<STATE *>(states);
-			CountFlatLoop(sdata, FlatVector::Validity(input), count);
-		} else {
-			UnifiedVectorFormat idata, sdata;
-			input.ToUnifiedFormat(count, idata);
-			states.ToUnifiedFormat(count, sdata);
-			CountScatterLoop(reinterpret_cast<STATE **>(sdata.data), *idata.sel, *sdata.sel, idata.validity, count);
-		}
-	}
-
-	static inline void CountFlatUpdateLoop(STATE &result, ValidityMask &mask, idx_t count) {
-		idx_t base_idx = 0;
-		auto entry_count = ValidityMask::EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			auto validity_entry = mask.GetValidityEntry(entry_idx);
-			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-			if (ValidityMask::AllValid(validity_entry)) {
-				// all valid
-				result += UnsafeNumericCast<STATE>(next - base_idx);
-				base_idx = next;
-			} else if (ValidityMask::NoneValid(validity_entry)) {
-				// nothing valid: skip all
-				base_idx = next;
-				continue;
-			} else {
-				// partially valid: need to check individual elements for validity
-				idx_t start = base_idx;
-				for (; base_idx < next; base_idx++) {
-					if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-						result++;
-					}
-				}
-			}
-		}
-	}
-
-	static inline void CountUpdateLoop(STATE &result, ValidityMask &mask, idx_t count,
-	                                   const SelectionVector &sel_vector) {
-		if (mask.AllValid()) {
-			// no NULL values
-			result += UnsafeNumericCast<STATE>(count);
-			return;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel_vector.get_index(i);
-			if (mask.RowIsValid(idx)) {
-				result++;
-			}
-		}
-	}
-
-	static void CountUpdate(Vector inputs[], AggregateInputData &, idx_t input_count, data_ptr_t state_p, idx_t count) {
-		auto &input = inputs[0];
-		auto &result = *reinterpret_cast<STATE *>(state_p);
-		switch (input.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			if (!ConstantVector::IsNull(input)) {
-				// if the constant is not null increment the state
-				result += UnsafeNumericCast<STATE>(count);
-			}
-			break;
-		}
-		case VectorType::FLAT_VECTOR: {
-			CountFlatUpdateLoop(result, FlatVector::Validity(input), count);
-			break;
-		}
-		case VectorType::SEQUENCE_VECTOR: {
-			// sequence vectors cannot have NULL values
-			result += UnsafeNumericCast<STATE>(count);
-			break;
-		}
-		default: {
-			UnifiedVectorFormat idata;
-			input.ToUnifiedFormat(count, idata);
-			CountUpdateLoop(result, idata.validity, count, *idata.sel);
-			break;
-		}
-		}
-	}
-};
-
-AggregateFunction CountFunctionBase::GetFunction() {
-	AggregateFunction fun({LogicalType(LogicalTypeId::ANY)}, LogicalType::BIGINT, AggregateFunction::StateSize<int64_t>,
-	                      AggregateFunction::StateInitialize<int64_t, CountFunction>, CountFunction::CountScatter,
-	                      AggregateFunction::StateCombine<int64_t, CountFunction>,
-	                      AggregateFunction::StateFinalize<int64_t, int64_t, CountFunction>,
-	                      FunctionNullHandling::SPECIAL_HANDLING, CountFunction::CountUpdate);
-	fun.name = "count";
-	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	return fun;
-}
-
-AggregateFunction CountStarFun::GetFunction() {
-	auto fun = AggregateFunction::NullaryAggregate<int64_t, int64_t, CountStarFunction>(LogicalType::BIGINT);
-	fun.name = "count_star";
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	fun.window = CountStarFunction::Window<int64_t>;
-	return fun;
-}
-
-unique_ptr<BaseStatistics> CountPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                               AggregateStatisticsInput &input) {
-	if (!expr.IsDistinct() && !input.child_stats[0].CanHaveNull()) {
-		// count on a column without null values: use count star
-		expr.function = CountStarFun::GetFunction();
-		expr.function.name = "count_star";
-		expr.children.clear();
-	}
-	return nullptr;
-}
-
-AggregateFunctionSet CountFun::GetFunctions() {
-	AggregateFunction count_function = CountFunctionBase::GetFunction();
-	count_function.statistics = CountPropagateStats;
-	AggregateFunctionSet count("count");
-	count.AddFunction(count_function);
-	// the count function can also be called without arguments
-	count.AddFunction(CountStarFun::GetFunction());
-	return count;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp b/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp
deleted file mode 100644
index 4e7455efa..000000000
--- a/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp
+++ /dev/null
@@ -1,378 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct FirstState {
-	T value;
-	bool is_set;
-	bool is_null;
-};
-
-struct FirstFunctionBase {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.is_set = false;
-		state.is_null = false;
-	}
-
-	static bool IgnoreNull() {
-		return false;
-	}
-};
-
-template <bool LAST, bool SKIP_NULLS>
-struct FirstFunction : public FirstFunctionBase {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		if (LAST || !state.is_set) {
-			if (!unary_input.RowIsValid()) {
-				if (!SKIP_NULLS) {
-					state.is_set = true;
-				}
-				state.is_null = true;
-			} else {
-				state.is_set = true;
-				state.is_null = false;
-				state.value = input;
-			}
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!target.is_set) {
-			target = source;
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_set || state.is_null) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.value;
-		}
-	}
-};
-
-template <bool LAST, bool SKIP_NULLS>
-struct FirstFunctionStringBase : public FirstFunctionBase {
-	template <class STATE, bool COMBINE = false>
-	static void SetValue(STATE &state, AggregateInputData &input_data, string_t value, bool is_null) {
-		if (LAST && state.is_set) {
-			Destroy(state, input_data);
-		}
-		if (is_null) {
-			if (!SKIP_NULLS) {
-				state.is_set = true;
-				state.is_null = true;
-			}
-		} else {
-			state.is_set = true;
-			state.is_null = false;
-			if ((COMBINE && !LAST) || value.IsInlined()) {
-				// We use the aggregate allocator for 'first', so the allocation is already done when combining
-				// Of course, if the value is inlined, we also don't need to allocate
-				state.value = value;
-			} else {
-				// non-inlined string, need to allocate space for it
-				auto len = value.GetSize();
-				auto ptr = LAST ? new char[len] : char_ptr_cast(input_data.allocator.Allocate(len));
-				memcpy(ptr, value.GetData(), len);
-
-				state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
-			}
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
-		if (source.is_set && (LAST || !target.is_set)) {
-			SetValue<STATE, true>(target, input_data, source.value, source.is_null);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &) {
-		if (state.is_set && !state.is_null && !state.value.IsInlined()) {
-			delete[] state.value.GetData();
-		}
-	}
-};
-
-template <bool LAST, bool SKIP_NULLS>
-struct FirstFunctionString : FirstFunctionStringBase<LAST, SKIP_NULLS> {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		if (LAST || !state.is_set) {
-			FirstFunctionStringBase<LAST, SKIP_NULLS>::template SetValue<STATE>(state, unary_input.input, input,
-			                                                                    !unary_input.RowIsValid());
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_set || state.is_null) {
-			finalize_data.ReturnNull();
-		} else {
-			target = StringVector::AddStringOrBlob(finalize_data.result, state.value);
-		}
-	}
-};
-
-template <bool LAST, bool SKIP_NULLS>
-struct FirstVectorFunction : FirstFunctionStringBase<LAST, SKIP_NULLS> {
-	using STATE = FirstState<string_t>;
-
-	static void Update(Vector inputs[], AggregateInputData &input_data, idx_t, Vector &state_vector, idx_t count) {
-		auto &input = inputs[0];
-		UnifiedVectorFormat idata;
-		input.ToUnifiedFormat(count, idata);
-
-		UnifiedVectorFormat sdata;
-		state_vector.ToUnifiedFormat(count, sdata);
-
-		sel_t assign_sel[STANDARD_VECTOR_SIZE];
-		idx_t assign_count = 0;
-
-		auto states = UnifiedVectorFormat::GetData<STATE *>(sdata);
-		for (idx_t i = 0; i < count; i++) {
-			const auto idx = idata.sel->get_index(i);
-			bool is_null = !idata.validity.RowIsValid(idx);
-			if (SKIP_NULLS && is_null) {
-				continue;
-			}
-			auto &state = *states[sdata.sel->get_index(i)];
-			if (!LAST && state.is_set) {
-				continue;
-			}
-			assign_sel[assign_count++] = NumericCast<sel_t>(i);
-		}
-		if (assign_count == 0) {
-			// fast path - nothing to set
-			return;
-		}
-
-		Vector sort_key(LogicalType::BLOB);
-		OrderModifiers modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-		// slice with a selection vector and generate sort keys
-		if (assign_count == count) {
-			CreateSortKeyHelpers::CreateSortKey(input, count, modifiers, sort_key);
-		} else {
-			SelectionVector sel(assign_sel);
-			Vector sliced_input(input, sel, assign_count);
-			CreateSortKeyHelpers::CreateSortKey(sliced_input, assign_count, modifiers, sort_key);
-		}
-		auto sort_key_data = FlatVector::GetData<string_t>(sort_key);
-
-		// now assign sort keys
-		for (idx_t i = 0; i < assign_count; i++) {
-			const auto state_idx = sdata.sel->get_index(assign_sel[i]);
-			auto &state = *states[state_idx];
-			if (!LAST && state.is_set) {
-				continue;
-			}
-
-			const auto idx = idata.sel->get_index(assign_sel[i]);
-			bool is_null = !idata.validity.RowIsValid(idx);
-			FirstFunctionStringBase<LAST, SKIP_NULLS>::template SetValue<STATE>(state, input_data, sort_key_data[i],
-			                                                                    is_null);
-		}
-	}
-
-	template <class STATE>
-	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (!state.is_set || state.is_null) {
-			finalize_data.ReturnNull();
-		} else {
-			CreateSortKeyHelpers::DecodeSortKey(state.value, finalize_data.result, finalize_data.result_idx,
-			                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
-		}
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function.arguments[0] = arguments[0]->return_type;
-		function.return_type = arguments[0]->return_type;
-		return nullptr;
-	}
-};
-
-template <class T, bool LAST, bool SKIP_NULLS>
-static void FirstFunctionSimpleUpdate(Vector inputs[], AggregateInputData &aggregate_input_data, idx_t input_count,
-                                      data_ptr_t state, idx_t count) {
-	auto agg_state = reinterpret_cast<FirstState<T> *>(state);
-	if (LAST || !agg_state->is_set) {
-		// For FIRST, this skips looping over the input once the aggregate state has been set
-		// FIXME: for LAST we could loop from the back of the Vector instead
-		AggregateFunction::UnaryUpdate<FirstState<T>, T, FirstFunction<LAST, SKIP_NULLS>>(inputs, aggregate_input_data,
-		                                                                                  input_count, state, count);
-	}
-}
-
-template <class T, bool LAST, bool SKIP_NULLS>
-static AggregateFunction GetFirstAggregateTemplated(LogicalType type) {
-	auto result = AggregateFunction::UnaryAggregate<FirstState<T>, T, T, FirstFunction<LAST, SKIP_NULLS>>(type, type);
-	result.simple_update = FirstFunctionSimpleUpdate<T, LAST, SKIP_NULLS>;
-	return result;
-}
-
-template <bool LAST, bool SKIP_NULLS>
-static AggregateFunction GetFirstFunction(const LogicalType &type);
-
-template <bool LAST, bool SKIP_NULLS>
-AggregateFunction GetDecimalFirstFunction(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-	switch (type.InternalType()) {
-	case PhysicalType::INT16:
-		return GetFirstFunction<LAST, SKIP_NULLS>(LogicalType::SMALLINT);
-	case PhysicalType::INT32:
-		return GetFirstFunction<LAST, SKIP_NULLS>(LogicalType::INTEGER);
-	case PhysicalType::INT64:
-		return GetFirstFunction<LAST, SKIP_NULLS>(LogicalType::BIGINT);
-	default:
-		return GetFirstFunction<LAST, SKIP_NULLS>(LogicalType::HUGEINT);
-	}
-}
-template <bool LAST, bool SKIP_NULLS>
-static AggregateFunction GetFirstFunction(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::DECIMAL) {
-		type.Verify();
-		AggregateFunction function = GetDecimalFirstFunction<LAST, SKIP_NULLS>(type);
-		function.arguments[0] = type;
-		function.return_type = type;
-		return function;
-	}
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return GetFirstAggregateTemplated<int8_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::INT16:
-		return GetFirstAggregateTemplated<int16_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::INT32:
-		return GetFirstAggregateTemplated<int32_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::INT64:
-		return GetFirstAggregateTemplated<int64_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::UINT8:
-		return GetFirstAggregateTemplated<uint8_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::UINT16:
-		return GetFirstAggregateTemplated<uint16_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::UINT32:
-		return GetFirstAggregateTemplated<uint32_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::UINT64:
-		return GetFirstAggregateTemplated<uint64_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::INT128:
-		return GetFirstAggregateTemplated<hugeint_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::UINT128:
-		return GetFirstAggregateTemplated<uhugeint_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::FLOAT:
-		return GetFirstAggregateTemplated<float, LAST, SKIP_NULLS>(type);
-	case PhysicalType::DOUBLE:
-		return GetFirstAggregateTemplated<double, LAST, SKIP_NULLS>(type);
-	case PhysicalType::INTERVAL:
-		return GetFirstAggregateTemplated<interval_t, LAST, SKIP_NULLS>(type);
-	case PhysicalType::VARCHAR:
-		if (LAST) {
-			return AggregateFunction::UnaryAggregateDestructor<FirstState<string_t>, string_t, string_t,
-			                                                   FirstFunctionString<LAST, SKIP_NULLS>>(type, type);
-		} else {
-			return AggregateFunction::UnaryAggregate<FirstState<string_t>, string_t, string_t,
-			                                         FirstFunctionString<LAST, SKIP_NULLS>>(type, type);
-		}
-	default: {
-		using OP = FirstVectorFunction<LAST, SKIP_NULLS>;
-		using STATE = FirstState<string_t>;
-		return AggregateFunction(
-		    {type}, type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-		    OP::Update, AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateVoidFinalize<STATE, OP>,
-		    nullptr, OP::Bind, LAST ? AggregateFunction::StateDestroy<STATE, OP> : nullptr, nullptr, nullptr);
-	}
-	}
-}
-
-AggregateFunction FirstFunctionGetter::GetFunction(const LogicalType &type) {
-	auto fun = GetFirstFunction<false, false>(type);
-	fun.name = "first";
-	return fun;
-}
-
-template <bool LAST, bool SKIP_NULLS>
-unique_ptr<FunctionData> BindDecimalFirst(ClientContext &context, AggregateFunction &function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	auto name = std::move(function.name);
-	function = GetFirstFunction<LAST, SKIP_NULLS>(decimal_type);
-	function.name = std::move(name);
-	function.distinct_dependent = AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT;
-	function.return_type = decimal_type;
-	return nullptr;
-}
-
-template <bool LAST, bool SKIP_NULLS>
-static AggregateFunction GetFirstOperator(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::DECIMAL) {
-		throw InternalException("FIXME: this shouldn't happen...");
-	}
-	return GetFirstFunction<LAST, SKIP_NULLS>(type);
-}
-
-template <bool LAST, bool SKIP_NULLS>
-unique_ptr<FunctionData> BindFirst(ClientContext &context, AggregateFunction &function,
-                                   vector<unique_ptr<Expression>> &arguments) {
-	auto input_type = arguments[0]->return_type;
-	auto name = std::move(function.name);
-	function = GetFirstOperator<LAST, SKIP_NULLS>(input_type);
-	function.name = std::move(name);
-	function.distinct_dependent = AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT;
-	if (function.bind) {
-		return function.bind(context, function, arguments);
-	} else {
-		return nullptr;
-	}
-}
-
-template <bool LAST, bool SKIP_NULLS>
-static void AddFirstOperator(AggregateFunctionSet &set) {
-	set.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, nullptr, BindDecimalFirst<LAST, SKIP_NULLS>));
-	set.AddFunction(AggregateFunction({LogicalType::ANY}, LogicalType::ANY, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                                  nullptr, BindFirst<LAST, SKIP_NULLS>));
-}
-
-AggregateFunctionSet FirstFun::GetFunctions() {
-	AggregateFunctionSet first("first");
-	AddFirstOperator<false, false>(first);
-	return first;
-}
-
-AggregateFunctionSet LastFun::GetFunctions() {
-	AggregateFunctionSet last("last");
-	AddFirstOperator<true, false>(last);
-	return last;
-}
-
-AggregateFunctionSet AnyValueFun::GetFunctions() {
-	AggregateFunctionSet any_value("any_value");
-	AddFirstOperator<false, true>(any_value);
-	return any_value;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/aggregate/distributive/minmax.cpp b/src/duckdb/src/function/aggregate/distributive/minmax.cpp
deleted file mode 100644
index b862bf6d9..000000000
--- a/src/duckdb/src/function/aggregate/distributive/minmax.cpp
+++ /dev/null
@@ -1,556 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/function/aggregate/minmax_n_helpers.hpp"
-#include "duckdb/function/aggregate/sort_key_helpers.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct MinMaxState {
-	T value;
-	bool isset;
-};
-
-template <class OP>
-static AggregateFunction GetUnaryAggregate(LogicalType type) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int8_t>, int8_t, int8_t, OP>(type, type);
-	case PhysicalType::INT8:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int8_t>, int8_t, int8_t, OP>(type, type);
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int16_t>, int16_t, int16_t, OP>(type, type);
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int32_t>, int32_t, int32_t, OP>(type, type);
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int64_t>, int64_t, int64_t, OP>(type, type);
-	case PhysicalType::UINT8:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint8_t>, uint8_t, uint8_t, OP>(type, type);
-	case PhysicalType::UINT16:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint16_t>, uint16_t, uint16_t, OP>(type, type);
-	case PhysicalType::UINT32:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint32_t>, uint32_t, uint32_t, OP>(type, type);
-	case PhysicalType::UINT64:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
-	case PhysicalType::INT128:
-		return AggregateFunction::UnaryAggregate<MinMaxState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type);
-	case PhysicalType::UINT128:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uhugeint_t>, uhugeint_t, uhugeint_t, OP>(type, type);
-	case PhysicalType::FLOAT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<float>, float, float, OP>(type, type);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregate<MinMaxState<double>, double, double, OP>(type, type);
-	case PhysicalType::INTERVAL:
-		return AggregateFunction::UnaryAggregate<MinMaxState<interval_t>, interval_t, interval_t, OP>(type, type);
-	default:
-		throw InternalException("Unimplemented type for min/max aggregate");
-	}
-}
-
-struct MinMaxBase {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.isset = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
-	                              idx_t count) {
-		if (!state.isset) {
-			OP::template Assign<INPUT_TYPE, STATE>(state, input, unary_input.input);
-			state.isset = true;
-		} else {
-			OP::template Execute<INPUT_TYPE, STATE>(state, input, unary_input.input);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		if (!state.isset) {
-			OP::template Assign<INPUT_TYPE, STATE>(state, input, unary_input.input);
-			state.isset = true;
-		} else {
-			OP::template Execute<INPUT_TYPE, STATE>(state, input, unary_input.input);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct NumericMinMaxBase : public MinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE &state, INPUT_TYPE input, AggregateInputData &) {
-		state.value = input;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			target = state.value;
-		}
-	}
-};
-
-struct MinOperation : public NumericMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &) {
-		if (LessThan::Operation<INPUT_TYPE>(input, state.value)) {
-			state.value = input;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		if (!target.isset) {
-			// target is NULL, use source value directly
-			target = source;
-		} else if (GreaterThan::Operation(target.value, source.value)) {
-			target.value = source.value;
-		}
-	}
-};
-
-struct MaxOperation : public NumericMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &) {
-		if (GreaterThan::Operation<INPUT_TYPE>(input, state.value)) {
-			state.value = input;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		if (!target.isset) {
-			// target is NULL, use source value directly
-			target = source;
-		} else if (LessThan::Operation(target.value, source.value)) {
-			target.value = source.value;
-		}
-	}
-};
-
-struct MinMaxStringState : MinMaxState<string_t> {
-	void Destroy() {
-		if (isset && !value.IsInlined()) {
-			delete[] value.GetData();
-		}
-	}
-
-	void Assign(string_t input) {
-		if (input.IsInlined()) {
-			// inlined string - we can directly store it into the string_t without having to allocate anything
-			Destroy();
-			value = input;
-		} else {
-			// non-inlined string, need to allocate space for it somehow
-			auto len = input.GetSize();
-			char *ptr;
-			if (!isset || value.GetSize() < len) {
-				// we cannot fit this into the current slot - destroy it and re-allocate
-				Destroy();
-				ptr = new char[len];
-			} else {
-				// this fits into the current slot - take over the pointer
-				ptr = value.GetDataWriteable();
-			}
-			memcpy(ptr, input.GetData(), len);
-
-			value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
-		}
-	}
-};
-
-struct StringMinMaxBase : public MinMaxBase {
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.Destroy();
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
-		state.Assign(input);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			target = StringVector::AddStringOrBlob(finalize_data.result, state.value);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		if (!target.isset) {
-			// target is NULL, use source value directly
-			Assign(target, source.value, input_data);
-			target.isset = true;
-		} else {
-			OP::template Execute<string_t, STATE>(target, source.value, input_data);
-		}
-	}
-};
-
-struct MinOperationString : public StringMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
-		if (LessThan::Operation<INPUT_TYPE>(input, state.value)) {
-			Assign(state, input, input_data);
-		}
-	}
-};
-
-struct MaxOperationString : public StringMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
-		if (GreaterThan::Operation<INPUT_TYPE>(input, state.value)) {
-			Assign(state, input, input_data);
-		}
-	}
-};
-
-template <OrderType ORDER_TYPE_TEMPLATED>
-struct VectorMinMaxBase {
-	static constexpr OrderType ORDER_TYPE = ORDER_TYPE_TEMPLATED;
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.isset = false;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.Destroy();
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
-		state.Assign(input);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
-		if (!state.isset) {
-			Assign(state, input, input_data);
-			state.isset = true;
-			return;
-		}
-		if (LessThan::Operation<INPUT_TYPE>(input, state.value)) {
-			Assign(state, input, input_data);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		OP::template Execute<string_t, STATE, OP>(target, source.value, input_data);
-	}
-
-	template <class STATE>
-	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (!state.isset) {
-			finalize_data.ReturnNull();
-		} else {
-			CreateSortKeyHelpers::DecodeSortKey(state.value, finalize_data.result, finalize_data.result_idx,
-			                                    OrderModifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST));
-		}
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function.arguments[0] = arguments[0]->return_type;
-		function.return_type = arguments[0]->return_type;
-		return nullptr;
-	}
-};
-
-struct MinOperationVector : VectorMinMaxBase<OrderType::ASCENDING> {};
-
-struct MaxOperationVector : VectorMinMaxBase<OrderType::DESCENDING> {};
-
-template <typename OP, typename STATE>
-static AggregateFunction GetMinMaxFunction(const LogicalType &type) {
-	return AggregateFunction(
-	    {type}, LogicalType::BLOB, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    AggregateSortKeyHelpers::UnaryUpdate<STATE, OP, OP::ORDER_TYPE, false>,
-	    AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind,
-	    AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <class OP, class OP_STRING, class OP_VECTOR>
-static AggregateFunction GetMinMaxOperator(const LogicalType &type) {
-	auto internal_type = type.InternalType();
-	switch (internal_type) {
-	case PhysicalType::VARCHAR:
-		return AggregateFunction::UnaryAggregateDestructor<MinMaxStringState, string_t, string_t, OP_STRING>(type,
-		                                                                                                     type);
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT:
-	case PhysicalType::ARRAY:
-		return GetMinMaxFunction<OP_VECTOR, MinMaxStringState>(type);
-	default:
-		return GetUnaryAggregate<OP>(type);
-	}
-}
-
-template <class OP, class OP_STRING, class OP_VECTOR>
-unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &function,
-                                    vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->return_type.id() == LogicalTypeId::VARCHAR) {
-		auto str_collation = StringType::GetCollation(arguments[0]->return_type);
-		if (!str_collation.empty() || !DBConfig::GetConfig(context).options.collation.empty()) {
-			// If aggr function is min/max and uses collations, replace bound_function with arg_min/arg_max
-			// to make sure the result's correctness.
-			string function_name = function.name == "min" ? "arg_min" : "arg_max";
-			QueryErrorContext error_context;
-			auto func = Catalog::GetEntry(context, CatalogType::AGGREGATE_FUNCTION_ENTRY, "", "", function_name,
-			                              OnEntryNotFound::RETURN_NULL, error_context);
-			if (!func) {
-				throw NotImplementedException(
-				    "Failure while binding function \"%s\" using collations - arg_min/arg_max do not exist in the "
-				    "catalog - load the core_functions module to fix this issue",
-				    function.name);
-			}
-
-			auto &func_entry = func->Cast<AggregateFunctionCatalogEntry>();
-
-			FunctionBinder function_binder(context);
-			vector<LogicalType> types {arguments[0]->return_type, arguments[0]->return_type};
-			ErrorData error;
-			auto best_function = function_binder.BindFunction(func_entry.name, func_entry.functions, types, error);
-			if (!best_function.IsValid()) {
-				throw BinderException(string("Fail to find corresponding function for collation min/max: ") +
-				                      error.Message());
-			}
-			function = func_entry.functions.GetFunctionByOffset(best_function.GetIndex());
-
-			// Create a copied child and PushCollation for it.
-			arguments.push_back(arguments[0]->Copy());
-			ExpressionBinder::PushCollation(context, arguments[1], arguments[0]->return_type);
-
-			// Bind function like arg_min/arg_max.
-			function.arguments[0] = arguments[0]->return_type;
-			function.return_type = arguments[0]->return_type;
-			return nullptr;
-		}
-	}
-
-	auto input_type = arguments[0]->return_type;
-	if (input_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	auto name = std::move(function.name);
-	function = GetMinMaxOperator<OP, OP_STRING, OP_VECTOR>(input_type);
-	function.name = std::move(name);
-	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	function.distinct_dependent = AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT;
-	if (function.bind) {
-		return function.bind(context, function, arguments);
-	} else {
-		return nullptr;
-	}
-}
-
-template <class OP, class OP_STRING, class OP_VECTOR>
-static AggregateFunction GetMinMaxOperator(string name) {
-	return AggregateFunction(std::move(name), {LogicalType::ANY}, LogicalType::ANY, nullptr, nullptr, nullptr, nullptr,
-	                         nullptr, nullptr, BindMinMax<OP, OP_STRING, OP_VECTOR>);
-}
-
-AggregateFunction MinFunction::GetFunction() {
-	return GetMinMaxOperator<MinOperation, MinOperationString, MinOperationVector>("min");
-}
-
-AggregateFunction MaxFunction::GetFunction() {
-	return GetMinMaxOperator<MaxOperation, MaxOperationString, MaxOperationVector>("max");
-}
-
-//---------------------------------------------------
-// MinMaxN
-//---------------------------------------------------
-
-template <class A, class COMPARATOR>
-class MinMaxNState {
-public:
-	using VAL_TYPE = A;
-	using T = typename VAL_TYPE::TYPE;
-
-	UnaryAggregateHeap<T, COMPARATOR> heap;
-	bool is_initialized = false;
-
-	void Initialize(idx_t nval) {
-		heap.Initialize(nval);
-		is_initialized = true;
-	}
-
-	static const T &GetValue(const T &val) {
-		return val;
-	}
-};
-
-template <class STATE>
-static void MinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
-                          idx_t count) {
-
-	auto &val_vector = inputs[0];
-	auto &n_vector = inputs[1];
-
-	UnifiedVectorFormat val_format;
-	UnifiedVectorFormat n_format;
-	UnifiedVectorFormat state_format;
-	;
-	auto val_extra_state = STATE::VAL_TYPE::CreateExtraState(val_vector, count);
-
-	STATE::VAL_TYPE::PrepareData(val_vector, count, val_extra_state, val_format);
-
-	n_vector.ToUnifiedFormat(count, n_format);
-	state_vector.ToUnifiedFormat(count, state_format);
-
-	auto states = UnifiedVectorFormat::GetData<STATE *>(state_format);
-
-	for (idx_t i = 0; i < count; i++) {
-		const auto val_idx = val_format.sel->get_index(i);
-		if (!val_format.validity.RowIsValid(val_idx)) {
-			continue;
-		}
-		const auto state_idx = state_format.sel->get_index(i);
-		auto &state = *states[state_idx];
-
-		// Initialize the heap if necessary and add the input to the heap
-		if (!state.is_initialized) {
-			static constexpr int64_t MAX_N = 1000000;
-			const auto nidx = n_format.sel->get_index(i);
-			if (!n_format.validity.RowIsValid(nidx)) {
-				throw InvalidInputException("Invalid input for MIN/MAX: n value cannot be NULL");
-			}
-			const auto nval = UnifiedVectorFormat::GetData<int64_t>(n_format)[nidx];
-			if (nval <= 0) {
-				throw InvalidInputException("Invalid input for MIN/MAX: n value must be > 0");
-			}
-			if (nval >= MAX_N) {
-				throw InvalidInputException("Invalid input for MIN/MAX: n value must be < %d", MAX_N);
-			}
-			state.Initialize(UnsafeNumericCast<idx_t>(nval));
-		}
-
-		// Now add the input to the heap
-		auto val_val = STATE::VAL_TYPE::Create(val_format, val_idx);
-		state.heap.Insert(aggr_input.allocator, val_val);
-	}
-}
-
-template <class VAL_TYPE, class COMPARATOR>
-static void SpecializeMinMaxNFunction(AggregateFunction &function) {
-	using STATE = MinMaxNState<VAL_TYPE, COMPARATOR>;
-	using OP = MinMaxNOperation;
-
-	function.state_size = AggregateFunction::StateSize<STATE>;
-	function.initialize = AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>;
-	function.combine = AggregateFunction::StateCombine<STATE, OP>;
-	function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-
-	function.finalize = MinMaxNOperation::Finalize<STATE>;
-	function.update = MinMaxNUpdate<STATE>;
-}
-
-template <class COMPARATOR>
-static void SpecializeMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
-	switch (arg_type) {
-	case PhysicalType::VARCHAR:
-		SpecializeMinMaxNFunction<MinMaxStringValue, COMPARATOR>(function);
-		break;
-	case PhysicalType::INT32:
-		SpecializeMinMaxNFunction<MinMaxFixedValue<int32_t>, COMPARATOR>(function);
-		break;
-	case PhysicalType::INT64:
-		SpecializeMinMaxNFunction<MinMaxFixedValue<int64_t>, COMPARATOR>(function);
-		break;
-	case PhysicalType::FLOAT:
-		SpecializeMinMaxNFunction<MinMaxFixedValue<float>, COMPARATOR>(function);
-		break;
-	case PhysicalType::DOUBLE:
-		SpecializeMinMaxNFunction<MinMaxFixedValue<double>, COMPARATOR>(function);
-		break;
-	default:
-		SpecializeMinMaxNFunction<MinMaxFallbackValue, COMPARATOR>(function);
-		break;
-	}
-}
-
-template <class COMPARATOR>
-unique_ptr<FunctionData> MinMaxNBind(ClientContext &context, AggregateFunction &function,
-                                     vector<unique_ptr<Expression>> &arguments) {
-
-	for (auto &arg : arguments) {
-		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-	}
-
-	const auto val_type = arguments[0]->return_type.InternalType();
-
-	// Specialize the function based on the input types
-	SpecializeMinMaxNFunction<COMPARATOR>(val_type, function);
-
-	function.return_type = LogicalType::LIST(arguments[0]->return_type);
-	return nullptr;
-}
-
-template <class COMPARATOR>
-static AggregateFunction GetMinMaxNFunction() {
-	return AggregateFunction({LogicalTypeId::ANY, LogicalType::BIGINT}, LogicalType::LIST(LogicalType::ANY), nullptr,
-	                         nullptr, nullptr, nullptr, nullptr, nullptr, MinMaxNBind<COMPARATOR>, nullptr);
-}
-
-//---------------------------------------------------
-// Function Registration
-//---------------------------------------------------s
-AggregateFunctionSet MinFun::GetFunctions() {
-	AggregateFunctionSet min("min");
-	min.AddFunction(MinFunction::GetFunction());
-	min.AddFunction(GetMinMaxNFunction<LessThan>());
-	return min;
-}
-
-AggregateFunctionSet MaxFun::GetFunctions() {
-	AggregateFunctionSet max("max");
-	max.AddFunction(MaxFunction::GetFunction());
-	max.AddFunction(GetMinMaxNFunction<GreaterThan>());
-	return max;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp b/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp
deleted file mode 100644
index aa49db798..000000000
--- a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp
+++ /dev/null
@@ -1,818 +0,0 @@
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/types/list_segment.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-
-namespace duckdb {
-
-struct SortedAggregateBindData : public FunctionData {
-	using Expressions = vector<unique_ptr<Expression>>;
-	using BindInfoPtr = unique_ptr<FunctionData>;
-	using OrderBys = vector<BoundOrderByNode>;
-
-	SortedAggregateBindData(ClientContext &context, Expressions &children, AggregateFunction &aggregate,
-	                        BindInfoPtr &bind_info, OrderBys &order_bys)
-	    : buffer_manager(BufferManager::GetBufferManager(context)), function(aggregate),
-	      bind_info(std::move(bind_info)), threshold(ClientConfig::GetConfig(context).ordered_aggregate_threshold),
-	      external(ClientConfig::GetConfig(context).force_external) {
-		arg_types.reserve(children.size());
-		arg_funcs.reserve(children.size());
-		for (const auto &child : children) {
-			arg_types.emplace_back(child->return_type);
-			ListSegmentFunctions funcs;
-			GetSegmentDataFunctions(funcs, arg_types.back());
-			arg_funcs.emplace_back(std::move(funcs));
-		}
-		sort_types.reserve(order_bys.size());
-		sort_funcs.reserve(order_bys.size());
-		for (auto &order : order_bys) {
-			orders.emplace_back(order.Copy());
-			sort_types.emplace_back(order.expression->return_type);
-			ListSegmentFunctions funcs;
-			GetSegmentDataFunctions(funcs, sort_types.back());
-			sort_funcs.emplace_back(std::move(funcs));
-		}
-		sorted_on_args = (children.size() == order_bys.size());
-		for (size_t i = 0; sorted_on_args && i < children.size(); ++i) {
-			sorted_on_args = children[i]->Equals(*order_bys[i].expression);
-		}
-	}
-
-	SortedAggregateBindData(ClientContext &context, BoundAggregateExpression &expr)
-	    : SortedAggregateBindData(context, expr.children, expr.function, expr.bind_info, expr.order_bys->orders) {
-	}
-
-	SortedAggregateBindData(ClientContext &context, BoundWindowExpression &expr)
-	    : SortedAggregateBindData(context, expr.children, *expr.aggregate, expr.bind_info, expr.arg_orders) {
-	}
-
-	SortedAggregateBindData(const SortedAggregateBindData &other)
-	    : buffer_manager(other.buffer_manager), function(other.function), arg_types(other.arg_types),
-	      arg_funcs(other.arg_funcs), sort_types(other.sort_types), sort_funcs(other.sort_funcs),
-	      sorted_on_args(other.sorted_on_args), threshold(other.threshold), external(other.external) {
-		if (other.bind_info) {
-			bind_info = other.bind_info->Copy();
-		}
-		for (auto &order : other.orders) {
-			orders.emplace_back(order.Copy());
-		}
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<SortedAggregateBindData>(*this);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<SortedAggregateBindData>();
-		if (bind_info && other.bind_info) {
-			if (!bind_info->Equals(*other.bind_info)) {
-				return false;
-			}
-		} else if (bind_info || other.bind_info) {
-			return false;
-		}
-		if (function != other.function) {
-			return false;
-		}
-		if (orders.size() != other.orders.size()) {
-			return false;
-		}
-		for (size_t i = 0; i < orders.size(); ++i) {
-			if (!orders[i].Equals(other.orders[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	BufferManager &buffer_manager;
-	AggregateFunction function;
-	vector<LogicalType> arg_types;
-	unique_ptr<FunctionData> bind_info;
-	vector<ListSegmentFunctions> arg_funcs;
-
-	vector<BoundOrderByNode> orders;
-	vector<LogicalType> sort_types;
-	vector<ListSegmentFunctions> sort_funcs;
-	bool sorted_on_args;
-
-	//! The sort flush threshold
-	const idx_t threshold;
-	const bool external;
-};
-
-struct SortedAggregateState {
-	// Linked list equivalent of DataChunk
-	using LinkedLists = vector<LinkedList>;
-	using LinkedChunkFunctions = vector<ListSegmentFunctions>;
-
-	//! Capacities of the various levels of buffering
-	static const idx_t CHUNK_CAPACITY = STANDARD_VECTOR_SIZE;
-	static const idx_t LIST_CAPACITY = MinValue<idx_t>(16, CHUNK_CAPACITY);
-
-	SortedAggregateState() : count(0), nsel(0), offset(0) {
-	}
-
-	static inline void InitializeLinkedList(LinkedLists &linked, const vector<LogicalType> &types) {
-		if (linked.empty() && !types.empty()) {
-			linked.resize(types.size(), LinkedList());
-		}
-	}
-
-	inline void InitializeLinkedLists(const SortedAggregateBindData &order_bind) {
-		InitializeLinkedList(sort_linked, order_bind.sort_types);
-		if (!order_bind.sorted_on_args) {
-			InitializeLinkedList(arg_linked, order_bind.arg_types);
-		}
-	}
-
-	static inline void InitializeChunk(unique_ptr<DataChunk> &chunk, const vector<LogicalType> &types) {
-		if (!chunk && !types.empty()) {
-			chunk = make_uniq<DataChunk>();
-			chunk->Initialize(Allocator::DefaultAllocator(), types);
-		}
-	}
-
-	void InitializeChunks(const SortedAggregateBindData &order_bind) {
-		// Lazy instantiation of the buffer chunks
-		InitializeChunk(sort_chunk, order_bind.sort_types);
-		if (!order_bind.sorted_on_args) {
-			InitializeChunk(arg_chunk, order_bind.arg_types);
-		}
-	}
-
-	static inline void FlushLinkedList(const LinkedChunkFunctions &funcs, LinkedLists &linked, DataChunk &chunk) {
-		idx_t total_count = 0;
-		for (column_t i = 0; i < linked.size(); ++i) {
-			funcs[i].BuildListVector(linked[i], chunk.data[i], total_count);
-			chunk.SetCardinality(linked[i].total_capacity);
-		}
-	}
-
-	void FlushLinkedLists(const SortedAggregateBindData &order_bind) {
-		InitializeChunks(order_bind);
-		FlushLinkedList(order_bind.sort_funcs, sort_linked, *sort_chunk);
-		if (arg_chunk) {
-			FlushLinkedList(order_bind.arg_funcs, arg_linked, *arg_chunk);
-		}
-	}
-
-	void InitializeCollections(const SortedAggregateBindData &order_bind) {
-		ordering = make_uniq<ColumnDataCollection>(order_bind.buffer_manager, order_bind.sort_types);
-		ordering_append = make_uniq<ColumnDataAppendState>();
-		ordering->InitializeAppend(*ordering_append);
-
-		if (!order_bind.sorted_on_args) {
-			arguments = make_uniq<ColumnDataCollection>(order_bind.buffer_manager, order_bind.arg_types);
-			arguments_append = make_uniq<ColumnDataAppendState>();
-			arguments->InitializeAppend(*arguments_append);
-		}
-	}
-
-	void FlushChunks(const SortedAggregateBindData &order_bind) {
-		D_ASSERT(sort_chunk);
-		ordering->Append(*ordering_append, *sort_chunk);
-		sort_chunk->Reset();
-
-		if (arguments) {
-			D_ASSERT(arg_chunk);
-			arguments->Append(*arguments_append, *arg_chunk);
-			arg_chunk->Reset();
-		}
-	}
-
-	void Resize(const SortedAggregateBindData &order_bind, idx_t n) {
-		count = n;
-
-		//	Establish the current buffering
-		if (count <= LIST_CAPACITY) {
-			InitializeLinkedLists(order_bind);
-		}
-
-		if (count > LIST_CAPACITY && !sort_chunk && !ordering) {
-			FlushLinkedLists(order_bind);
-		}
-
-		if (count > CHUNK_CAPACITY && !ordering) {
-			InitializeCollections(order_bind);
-			FlushChunks(order_bind);
-		}
-	}
-
-	static void LinkedAppend(const LinkedChunkFunctions &functions, ArenaAllocator &allocator, DataChunk &input,
-	                         LinkedLists &linked, SelectionVector &sel, idx_t nsel) {
-		const auto count = input.size();
-		for (column_t c = 0; c < input.ColumnCount(); ++c) {
-			auto &func = functions[c];
-			auto &linked_list = linked[c];
-			RecursiveUnifiedVectorFormat input_data;
-			Vector::RecursiveToUnifiedFormat(input.data[c], count, input_data);
-			for (idx_t i = 0; i < nsel; ++i) {
-				idx_t sidx = sel.get_index(i);
-				func.AppendRow(allocator, linked_list, input_data, sidx);
-			}
-		}
-	}
-
-	static void LinkedAbsorb(LinkedLists &source, LinkedLists &target) {
-		D_ASSERT(source.size() == target.size());
-		for (column_t i = 0; i < source.size(); ++i) {
-			auto &src = source[i];
-			if (!src.total_capacity) {
-				break;
-			}
-
-			auto &tgt = target[i];
-			if (!tgt.total_capacity) {
-				tgt = src;
-			} else {
-				// append the linked list
-				tgt.last_segment->next = src.first_segment;
-				tgt.last_segment = src.last_segment;
-				tgt.total_capacity += src.total_capacity;
-			}
-		}
-	}
-
-	void Update(const AggregateInputData &aggr_input_data, DataChunk &sort_input, DataChunk &arg_input) {
-		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		Resize(order_bind, count + sort_input.size());
-
-		sel.Initialize(nullptr);
-		nsel = sort_input.size();
-
-		if (ordering) {
-			//	Using collections
-			ordering->Append(*ordering_append, sort_input);
-			if (arguments) {
-				arguments->Append(*arguments_append, arg_input);
-			}
-		} else if (sort_chunk) {
-			//	Still using data chunks
-			sort_chunk->Append(sort_input);
-			if (arg_chunk) {
-				arg_chunk->Append(arg_input);
-			}
-		} else {
-			//	Still using linked lists
-			LinkedAppend(order_bind.sort_funcs, aggr_input_data.allocator, sort_input, sort_linked, sel, nsel);
-			if (!arg_linked.empty()) {
-				LinkedAppend(order_bind.arg_funcs, aggr_input_data.allocator, arg_input, arg_linked, sel, nsel);
-			}
-		}
-
-		nsel = 0;
-		offset = 0;
-	}
-
-	void UpdateSlice(const AggregateInputData &aggr_input_data, DataChunk &sort_input, DataChunk &arg_input) {
-		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		Resize(order_bind, count + nsel);
-
-		if (ordering) {
-			//	Using collections
-			D_ASSERT(sort_chunk);
-			sort_chunk->Slice(sort_input, sel, nsel);
-			if (arg_chunk) {
-				arg_chunk->Slice(arg_input, sel, nsel);
-			}
-			FlushChunks(order_bind);
-		} else if (sort_chunk) {
-			//	Still using data chunks
-			sort_chunk->Append(sort_input, true, &sel, nsel);
-			if (arg_chunk) {
-				arg_chunk->Append(arg_input, true, &sel, nsel);
-			}
-		} else {
-			//	Still using linked lists
-			LinkedAppend(order_bind.sort_funcs, aggr_input_data.allocator, sort_input, sort_linked, sel, nsel);
-			if (!arg_linked.empty()) {
-				LinkedAppend(order_bind.arg_funcs, aggr_input_data.allocator, arg_input, arg_linked, sel, nsel);
-			}
-		}
-
-		nsel = 0;
-		offset = 0;
-	}
-
-	void Swap(SortedAggregateState &other) {
-		std::swap(count, other.count);
-
-		std::swap(arguments, other.arguments);
-		std::swap(arguments_append, other.arguments_append);
-		std::swap(ordering, other.ordering);
-		std::swap(ordering_append, other.ordering_append);
-
-		std::swap(sort_chunk, other.sort_chunk);
-		std::swap(arg_chunk, other.arg_chunk);
-
-		std::swap(sort_linked, other.sort_linked);
-		std::swap(arg_linked, other.arg_linked);
-	}
-
-	void Absorb(const SortedAggregateBindData &order_bind, SortedAggregateState &other) {
-		if (!other.count) {
-			return;
-		} else if (!count) {
-			Swap(other);
-			return;
-		}
-
-		//	Change to a state large enough for all the data
-		Resize(order_bind, count + other.count);
-
-		//	3x3 matrix.
-		//	We can simplify the logic a bit because the target is already set for the final capacity
-		if (!sort_chunk) {
-			//	If the combined count is still linked lists,
-			//	then just move the pointers.
-			//	Note that this assumes ArenaAllocator is shared and the memory will not vanish under us.
-			LinkedAbsorb(other.sort_linked, sort_linked);
-			if (!arg_linked.empty()) {
-				LinkedAbsorb(other.arg_linked, arg_linked);
-			}
-
-			other.Reset();
-			return;
-		}
-
-		if (!other.sort_chunk) {
-			other.FlushLinkedLists(order_bind);
-		}
-
-		if (!ordering) {
-			//	Still using chunks, which means the source is using chunks or lists
-			D_ASSERT(sort_chunk);
-			D_ASSERT(other.sort_chunk);
-			sort_chunk->Append(*other.sort_chunk);
-			if (arg_chunk) {
-				D_ASSERT(other.arg_chunk);
-				arg_chunk->Append(*other.arg_chunk);
-			}
-		} else {
-			// Using collections, so source could be using anything.
-			if (other.ordering) {
-				ordering->Combine(*other.ordering);
-				if (arguments) {
-					D_ASSERT(other.arguments);
-					arguments->Combine(*other.arguments);
-				}
-			} else {
-				ordering->Append(*other.sort_chunk);
-				if (arguments) {
-					D_ASSERT(other.arg_chunk);
-					arguments->Append(*other.arg_chunk);
-				}
-			}
-		}
-
-		//	Free all memory as we have absorbed it.
-		other.Reset();
-	}
-
-	void PrefixSortBuffer(DataChunk &prefixed) {
-		for (column_t col_idx = 0; col_idx < sort_chunk->ColumnCount(); ++col_idx) {
-			prefixed.data[col_idx + 1].Reference(sort_chunk->data[col_idx]);
-		}
-		prefixed.SetCardinality(*sort_chunk);
-	}
-
-	void Finalize(const SortedAggregateBindData &order_bind, DataChunk &prefixed, LocalSortState &local_sort) {
-		if (arguments) {
-			ColumnDataScanState sort_state;
-			ordering->InitializeScan(sort_state);
-			ColumnDataScanState arg_state;
-			arguments->InitializeScan(arg_state);
-			for (sort_chunk->Reset(); ordering->Scan(sort_state, *sort_chunk); sort_chunk->Reset()) {
-				PrefixSortBuffer(prefixed);
-				arg_chunk->Reset();
-				arguments->Scan(arg_state, *arg_chunk);
-				local_sort.SinkChunk(prefixed, *arg_chunk);
-			}
-		} else if (ordering) {
-			ColumnDataScanState sort_state;
-			ordering->InitializeScan(sort_state);
-			for (sort_chunk->Reset(); ordering->Scan(sort_state, *sort_chunk); sort_chunk->Reset()) {
-				PrefixSortBuffer(prefixed);
-				local_sort.SinkChunk(prefixed, *sort_chunk);
-			}
-		} else {
-			//	Force chunks so we can sort
-			if (!sort_chunk) {
-				FlushLinkedLists(order_bind);
-			}
-
-			PrefixSortBuffer(prefixed);
-			if (arg_chunk) {
-				local_sort.SinkChunk(prefixed, *arg_chunk);
-			} else {
-				local_sort.SinkChunk(prefixed, *sort_chunk);
-			}
-		}
-
-		Reset();
-	}
-
-	void Reset() {
-		//	Release all memory
-		ordering.reset();
-		arguments.reset();
-
-		sort_chunk.reset();
-		arg_chunk.reset();
-
-		sort_linked.clear();
-		arg_linked.clear();
-
-		count = 0;
-	}
-
-	idx_t count;
-
-	unique_ptr<ColumnDataCollection> arguments;
-	unique_ptr<ColumnDataAppendState> arguments_append;
-	unique_ptr<ColumnDataCollection> ordering;
-	unique_ptr<ColumnDataAppendState> ordering_append;
-
-	unique_ptr<DataChunk> sort_chunk;
-	unique_ptr<DataChunk> arg_chunk;
-
-	LinkedLists sort_linked;
-	LinkedLists arg_linked;
-
-	// Selection for scattering
-	SelectionVector sel;
-	idx_t nsel;
-	idx_t offset;
-};
-
-struct SortedAggregateFunction {
-	template <typename STATE>
-	static void Initialize(STATE &state) {
-		new (&state) STATE();
-	}
-
-	template <typename STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.~STATE();
-	}
-
-	static void ProjectInputs(Vector inputs[], const SortedAggregateBindData &order_bind, idx_t input_count,
-	                          idx_t count, DataChunk &arg_input, DataChunk &sort_input) {
-		idx_t col = 0;
-
-		if (!order_bind.sorted_on_args) {
-			arg_input.InitializeEmpty(order_bind.arg_types);
-			for (auto &dst : arg_input.data) {
-				dst.Reference(inputs[col++]);
-			}
-			arg_input.SetCardinality(count);
-		}
-
-		sort_input.InitializeEmpty(order_bind.sort_types);
-		for (auto &dst : sort_input.data) {
-			dst.Reference(inputs[col++]);
-		}
-		sort_input.SetCardinality(count);
-	}
-
-	static void SimpleUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                         idx_t count) {
-		const auto order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		DataChunk arg_input;
-		DataChunk sort_input;
-		ProjectInputs(inputs, order_bind, input_count, count, arg_input, sort_input);
-
-		const auto order_state = reinterpret_cast<SortedAggregateState *>(state);
-		order_state->Update(aggr_input_data, sort_input, arg_input);
-	}
-
-	static void ScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
-	                          idx_t count) {
-		if (!count) {
-			return;
-		}
-
-		// Append the arguments to the two sub-collections
-		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		DataChunk arg_inputs;
-		DataChunk sort_inputs;
-		ProjectInputs(inputs, order_bind, input_count, count, arg_inputs, sort_inputs);
-
-		// We have to scatter the chunks one at a time
-		// so build a selection vector for each one.
-		UnifiedVectorFormat svdata;
-		states.ToUnifiedFormat(count, svdata);
-
-		// Size the selection vector for each state.
-		auto sdata = UnifiedVectorFormat::GetDataNoConst<SortedAggregateState *>(svdata);
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = svdata.sel->get_index(i);
-			auto order_state = sdata[sidx];
-			order_state->nsel++;
-		}
-
-		// Build the selection vector for each state.
-		vector<sel_t> sel_data(count);
-		idx_t start = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = svdata.sel->get_index(i);
-			auto order_state = sdata[sidx];
-			if (!order_state->offset) {
-				//	First one
-				order_state->offset = start;
-				order_state->sel.Initialize(sel_data.data() + order_state->offset);
-				start += order_state->nsel;
-			}
-			sel_data[order_state->offset++] = UnsafeNumericCast<sel_t>(sidx);
-		}
-
-		// Append nonempty slices to the arguments
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = svdata.sel->get_index(i);
-			auto order_state = sdata[sidx];
-			if (!order_state->nsel) {
-				continue;
-			}
-
-			order_state->UpdateSlice(aggr_input_data, sort_inputs, arg_inputs);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
-		auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		auto &other = const_cast<STATE &>(source); // NOLINT: absorb explicitly allows destruction
-		target.Absorb(order_bind, other);
-	}
-
-	static void Window(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                   const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &subframes, Vector &result,
-	                   idx_t rid) {
-		throw InternalException("Sorted aggregates should not be generated for window clauses");
-	}
-
-	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                     const idx_t offset) {
-		auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		auto &buffer_manager = order_bind.buffer_manager;
-		RowLayout payload_layout;
-		payload_layout.Initialize(order_bind.arg_types);
-		DataChunk chunk;
-		chunk.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
-		DataChunk sliced;
-		sliced.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
-
-		//	 Reusable inner state
-		auto &aggr = order_bind.function;
-		vector<data_t> agg_state(aggr.state_size(aggr));
-		Vector agg_state_vec(Value::POINTER(CastPointerToValue(agg_state.data())));
-
-		// State variables
-		auto bind_info = order_bind.bind_info.get();
-		AggregateInputData aggr_bind_info(bind_info, aggr_input_data.allocator);
-
-		// Inner aggregate APIs
-		auto initialize = aggr.initialize;
-		auto destructor = aggr.destructor;
-		auto simple_update = aggr.simple_update;
-		auto update = aggr.update;
-		auto finalize = aggr.finalize;
-
-		auto sdata = FlatVector::GetData<SortedAggregateState *>(states);
-
-		vector<idx_t> state_unprocessed(count, 0);
-		for (idx_t i = 0; i < count; ++i) {
-			state_unprocessed[i] = sdata[i]->count;
-		}
-
-		// Sort the input payloads on (state_idx ASC, orders)
-		vector<BoundOrderByNode> orders;
-		orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST,
-		                                     make_uniq<BoundConstantExpression>(Value::USMALLINT(0))));
-		for (const auto &order : order_bind.orders) {
-			orders.emplace_back(order.Copy());
-		}
-
-		auto global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
-		global_sort->external = order_bind.external;
-		auto local_sort = make_uniq<LocalSortState>();
-		local_sort->Initialize(*global_sort, global_sort->buffer_manager);
-
-		DataChunk prefixed;
-		prefixed.Initialize(Allocator::DefaultAllocator(), global_sort->sort_layout.logical_types);
-
-		//	Go through the states accumulating values to sort until we hit the sort threshold
-		idx_t unsorted_count = 0;
-		idx_t sorted = 0;
-		for (idx_t finalized = 0; finalized < count;) {
-			if (unsorted_count < order_bind.threshold) {
-				auto state = sdata[finalized];
-				prefixed.Reset();
-				prefixed.data[0].Reference(Value::USMALLINT(UnsafeNumericCast<uint16_t>(finalized)));
-				state->Finalize(order_bind, prefixed, *local_sort);
-				unsorted_count += state_unprocessed[finalized];
-
-				// Go to the next aggregate unless this is the last one
-				if (++finalized < count) {
-					continue;
-				}
-			}
-
-			//	If they were all empty (filtering) flush them
-			//	(This can only happen on the last range)
-			if (!unsorted_count) {
-				break;
-			}
-
-			//	Sort all the data
-			global_sort->AddLocalState(*local_sort);
-			global_sort->PrepareMergePhase();
-			while (global_sort->sorted_blocks.size() > 1) {
-				global_sort->InitializeMergeRound();
-				MergeSorter merge_sorter(*global_sort, global_sort->buffer_manager);
-				merge_sorter.PerformInMergeRound();
-				global_sort->CompleteMergeRound(false);
-			}
-
-			auto scanner = make_uniq<PayloadScanner>(*global_sort);
-			initialize(aggr, agg_state.data());
-			while (scanner->Remaining()) {
-				chunk.Reset();
-				scanner->Scan(chunk);
-				idx_t consumed = 0;
-
-				// Distribute the scanned chunk to the aggregates
-				while (consumed < chunk.size()) {
-					//	Find the next aggregate that needs data
-					for (; !state_unprocessed[sorted]; ++sorted) {
-						// Finalize a single value at the next offset
-						agg_state_vec.SetVectorType(states.GetVectorType());
-						finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
-						if (destructor) {
-							destructor(agg_state_vec, aggr_bind_info, 1);
-						}
-
-						initialize(aggr, agg_state.data());
-					}
-					const auto input_count = MinValue(state_unprocessed[sorted], chunk.size() - consumed);
-					for (column_t col_idx = 0; col_idx < chunk.ColumnCount(); ++col_idx) {
-						sliced.data[col_idx].Slice(chunk.data[col_idx], consumed, consumed + input_count);
-					}
-					sliced.SetCardinality(input_count);
-
-					// These are all simple updates, so use it if available
-					if (simple_update) {
-						simple_update(sliced.data.data(), aggr_bind_info, sliced.data.size(), agg_state.data(),
-						              sliced.size());
-					} else {
-						// We are only updating a constant state
-						agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-						update(sliced.data.data(), aggr_bind_info, sliced.data.size(), agg_state_vec, sliced.size());
-					}
-
-					consumed += input_count;
-					state_unprocessed[sorted] -= input_count;
-				}
-			}
-
-			//	Finalize the last state for this sort
-			agg_state_vec.SetVectorType(states.GetVectorType());
-			finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
-			if (destructor) {
-				destructor(agg_state_vec, aggr_bind_info, 1);
-			}
-			++sorted;
-
-			//	Stop if we are done
-			if (finalized >= count) {
-				break;
-			}
-
-			//	Create a new sort
-			scanner.reset();
-			global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
-			global_sort->external = order_bind.external;
-			local_sort = make_uniq<LocalSortState>();
-			local_sort->Initialize(*global_sort, global_sort->buffer_manager);
-			unsorted_count = 0;
-		}
-
-		for (; sorted < count; ++sorted) {
-			initialize(aggr, agg_state.data());
-
-			// Finalize a single value at the next offset
-			agg_state_vec.SetVectorType(states.GetVectorType());
-			finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
-
-			if (destructor) {
-				destructor(agg_state_vec, aggr_bind_info, 1);
-			}
-		}
-
-		result.Verify(count);
-	}
-};
-
-void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
-                                         const vector<unique_ptr<Expression>> &groups) {
-	if (!expr.order_bys || expr.order_bys->orders.empty() || expr.children.empty()) {
-		// not a sorted aggregate: return
-		return;
-	}
-	// Remove unnecessary ORDER BY clauses and return if nothing remains
-	if (context.config.enable_optimizer) {
-		if (expr.order_bys->Simplify(groups)) {
-			expr.order_bys.reset();
-			return;
-		}
-	}
-	auto &bound_function = expr.function;
-	auto &children = expr.children;
-	auto &order_bys = *expr.order_bys;
-	auto sorted_bind = make_uniq<SortedAggregateBindData>(context, expr);
-
-	if (!sorted_bind->sorted_on_args) {
-		// The arguments are the children plus the sort columns.
-		for (auto &order : order_bys.orders) {
-			children.emplace_back(std::move(order.expression));
-		}
-	}
-
-	vector<LogicalType> arguments;
-	arguments.reserve(children.size());
-	for (const auto &child : children) {
-		arguments.emplace_back(child->return_type);
-	}
-
-	// Replace the aggregate with the wrapper
-	AggregateFunction ordered_aggregate(
-	    bound_function.name, arguments, bound_function.return_type, AggregateFunction::StateSize<SortedAggregateState>,
-	    AggregateFunction::StateInitialize<SortedAggregateState, SortedAggregateFunction,
-	                                       AggregateDestructorType::LEGACY>,
-	    SortedAggregateFunction::ScatterUpdate,
-	    AggregateFunction::StateCombine<SortedAggregateState, SortedAggregateFunction>,
-	    SortedAggregateFunction::Finalize, bound_function.null_handling, SortedAggregateFunction::SimpleUpdate, nullptr,
-	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
-	    SortedAggregateFunction::Window);
-
-	expr.function = std::move(ordered_aggregate);
-	expr.bind_info = std::move(sorted_bind);
-	expr.order_bys.reset();
-}
-
-void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr) {
-	if (expr.arg_orders.empty() || expr.children.empty()) {
-		// not a sorted aggregate: return
-		return;
-	}
-	// Remove unnecessary ORDER BY clauses and return if nothing remains
-	if (context.config.enable_optimizer) {
-		if (BoundOrderModifier::Simplify(expr.arg_orders, expr.partitions)) {
-			expr.arg_orders.clear();
-			return;
-		}
-	}
-	auto &aggregate = *expr.aggregate;
-	auto &children = expr.children;
-	auto &arg_orders = expr.arg_orders;
-	auto sorted_bind = make_uniq<SortedAggregateBindData>(context, expr);
-
-	if (!sorted_bind->sorted_on_args) {
-		// The arguments are the children plus the sort columns.
-		for (auto &order : arg_orders) {
-			children.emplace_back(std::move(order.expression));
-		}
-	}
-
-	vector<LogicalType> arguments;
-	arguments.reserve(children.size());
-	for (const auto &child : children) {
-		arguments.emplace_back(child->return_type);
-	}
-
-	// Replace the aggregate with the wrapper
-	AggregateFunction ordered_aggregate(
-	    aggregate.name, arguments, aggregate.return_type, AggregateFunction::StateSize<SortedAggregateState>,
-	    AggregateFunction::StateInitialize<SortedAggregateState, SortedAggregateFunction,
-	                                       AggregateDestructorType::LEGACY>,
-	    SortedAggregateFunction::ScatterUpdate,
-	    AggregateFunction::StateCombine<SortedAggregateState, SortedAggregateFunction>,
-	    SortedAggregateFunction::Finalize, aggregate.null_handling, SortedAggregateFunction::SimpleUpdate, nullptr,
-	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
-	    SortedAggregateFunction::Window);
-
-	aggregate = std::move(ordered_aggregate);
-	expr.bind_info = std::move(sorted_bind);
-	expr.arg_orders.clear();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/aggregate_function.cpp b/src/duckdb/src/function/aggregate_function.cpp
deleted file mode 100644
index dd3bc0018..000000000
--- a/src/duckdb/src/function/aggregate_function.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "duckdb/function/aggregate_function.hpp"
-
-namespace duckdb {
-
-AggregateFunctionInfo::~AggregateFunctionInfo() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/built_in_functions.cpp b/src/duckdb/src/function/built_in_functions.cpp
deleted file mode 100644
index 00e7eac64..000000000
--- a/src/duckdb/src/function/built_in_functions.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#include "duckdb/function/built_in_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/main/extension_entries.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-BuiltinFunctions::BuiltinFunctions(CatalogTransaction transaction, Catalog &catalog)
-    : transaction(transaction), catalog(catalog) {
-}
-
-BuiltinFunctions::~BuiltinFunctions() {
-}
-
-void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool combinable,
-                                    bool not_required_for_equality) {
-	CreateCollationInfo info(std::move(name), std::move(function), combinable, not_required_for_equality);
-	info.internal = true;
-	catalog.CreateCollation(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
-	CreateAggregateFunctionInfo info(std::move(set));
-	info.internal = true;
-	catalog.CreateFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(AggregateFunction function) {
-	CreateAggregateFunctionInfo info(std::move(function));
-	info.internal = true;
-	catalog.CreateFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(PragmaFunction function) {
-	CreatePragmaFunctionInfo info(std::move(function));
-	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(const string &name, PragmaFunctionSet functions) {
-	CreatePragmaFunctionInfo info(name, std::move(functions));
-	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(ScalarFunction function) {
-	CreateScalarFunctionInfo info(std::move(function));
-	info.internal = true;
-	catalog.CreateFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
-	for (auto &name : names) {
-		function.name = name;
-		AddFunction(function);
-	}
-}
-
-void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
-	CreateScalarFunctionInfo info(std::move(set));
-	info.internal = true;
-	catalog.CreateFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(TableFunction function) {
-	CreateTableFunctionInfo info(std::move(function));
-	info.internal = true;
-	catalog.CreateTableFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(TableFunctionSet set) {
-	CreateTableFunctionInfo info(std::move(set));
-	info.internal = true;
-	catalog.CreateTableFunction(transaction, info);
-}
-
-void BuiltinFunctions::AddFunction(CopyFunction function) {
-	CreateCopyFunctionInfo info(std::move(function));
-	info.internal = true;
-	catalog.CreateCopyFunction(transaction, info);
-}
-
-struct ExtensionFunctionInfo : public ScalarFunctionInfo {
-	explicit ExtensionFunctionInfo(string extension_p) : extension(std::move(extension_p)) {
-	}
-
-	string extension;
-};
-
-unique_ptr<FunctionData> BindExtensionFunction(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	// if this is triggered we are trying to call a method that is present in an extension
-	// but the extension is not loaded
-	// try to autoload the extension
-	// first figure out which extension we need to auto-load
-	auto &function_info = bound_function.function_info->Cast<ExtensionFunctionInfo>();
-	auto &extension_name = function_info.extension;
-	auto &db = *context.db;
-
-	if (!ExtensionHelper::CanAutoloadExtension(extension_name)) {
-		throw BinderException("Trying to call function \"%s\" which is present in extension \"%s\" - but the extension "
-		                      "is not loaded and could not be auto-loaded",
-		                      bound_function.name, extension_name);
-	}
-	// auto-load the extension
-	ExtensionHelper::AutoLoadExtension(db, extension_name);
-
-	// now find the function in the catalog
-	auto &catalog = Catalog::GetSystemCatalog(db);
-	auto &function_entry = catalog.GetEntry<ScalarFunctionCatalogEntry>(context, DEFAULT_SCHEMA, bound_function.name);
-	// override the function with the extension function
-	bound_function = function_entry.functions.GetFunctionByArguments(context, bound_function.arguments);
-	// call the original bind (if any)
-	if (!bound_function.bind) {
-		return nullptr;
-	}
-	return bound_function.bind(context, bound_function, arguments);
-}
-
-void BuiltinFunctions::AddExtensionFunction(ScalarFunctionSet set) {
-	CreateScalarFunctionInfo info(std::move(set));
-	info.internal = true;
-	catalog.CreateFunction(transaction, info);
-}
-
-void BuiltinFunctions::RegisterExtensionOverloads() {
-#ifdef GENERATE_EXTENSION_ENTRIES
-	// do not insert auto loading placeholders when generating extension entries
-	return;
-#endif
-	ScalarFunctionSet current_set;
-	for (auto &entry : EXTENSION_FUNCTION_OVERLOADS) {
-		vector<LogicalType> arguments;
-		auto splits = StringUtil::Split(entry.signature, ">");
-		auto return_type = DBConfig::ParseLogicalType(splits[1]);
-		auto argument_splits = StringUtil::Split(splits[0], ",");
-		for (auto &param : argument_splits) {
-			arguments.push_back(DBConfig::ParseLogicalType(param));
-		}
-		if (entry.type != CatalogType::SCALAR_FUNCTION_ENTRY) {
-			throw InternalException(
-			    "Extension function overloads only supported for scalar functions currently - %s has a different type",
-			    entry.name);
-		}
-
-		ScalarFunction function(entry.name, std::move(arguments), std::move(return_type), nullptr,
-		                        BindExtensionFunction);
-		function.function_info = make_shared_ptr<ExtensionFunctionInfo>(entry.extension);
-		if (current_set.name != entry.name) {
-			if (!current_set.name.empty()) {
-				// create set of functions
-				AddExtensionFunction(current_set);
-			}
-			current_set = ScalarFunctionSet(entry.name);
-		}
-		// add this function to the set of function overloads
-		current_set.AddFunction(std::move(function));
-	}
-	AddExtensionFunction(std::move(current_set));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/array_casts.cpp b/src/duckdb/src/function/cast/array_casts.cpp
deleted file mode 100644
index 2357a2c2c..000000000
--- a/src/duckdb/src/function/cast/array_casts.cpp
+++ /dev/null
@@ -1,224 +0,0 @@
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/bound_cast_data.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundCastData> ArrayBoundCastData::BindArrayToArrayCast(BindCastInput &input, const LogicalType &source,
-                                                                   const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	auto &source_child_type = ArrayType::GetChildType(source);
-	auto &result_child_type = ArrayType::GetChildType(target);
-	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
-	return make_uniq<ArrayBoundCastData>(std::move(child_cast));
-}
-
-static unique_ptr<BoundCastData> BindArrayToListCast(BindCastInput &input, const LogicalType &source,
-                                                     const LogicalType &target) {
-	D_ASSERT(source.id() == LogicalTypeId::ARRAY);
-	D_ASSERT(target.id() == LogicalTypeId::LIST);
-
-	vector<BoundCastInfo> child_cast_info;
-	auto &source_child_type = ArrayType::GetChildType(source);
-	auto &result_child_type = ListType::GetChildType(target);
-	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
-	return make_uniq<ArrayBoundCastData>(std::move(child_cast));
-}
-
-unique_ptr<FunctionLocalState> ArrayBoundCastData::InitArrayLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
-	if (!cast_data.child_cast_info.init_local_state) {
-		return nullptr;
-	}
-	CastLocalStateParameters child_parameters(parameters, cast_data.child_cast_info.cast_data);
-	return cast_data.child_cast_info.init_local_state(child_parameters);
-}
-
-//------------------------------------------------------------------------------
-// ARRAY -> ARRAY
-//------------------------------------------------------------------------------
-static bool ArrayToArrayCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-
-	auto source_array_size = ArrayType::GetSize(source.GetType());
-	auto target_array_size = ArrayType::GetSize(result.GetType());
-	if (source_array_size != target_array_size) {
-		// Cant cast between arrays of different sizes
-		auto msg = StringUtil::Format("Cannot cast array of size %u to array of size %u", source_array_size,
-		                              target_array_size);
-		HandleCastError::AssignError(msg, parameters);
-		if (!parameters.strict) {
-			// if this was a TRY_CAST, we know every row will fail, so just return null
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return false;
-		}
-	}
-
-	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		if (ConstantVector::IsNull(source)) {
-			ConstantVector::SetNull(result, true);
-		}
-
-		auto &source_cc = ArrayVector::GetEntry(source);
-		auto &result_cc = ArrayVector::GetEntry(result);
-
-		// If the array vector is constant, the child vector must be flat (or constant if array size is 1)
-		D_ASSERT(source_cc.GetVectorType() == VectorType::FLAT_VECTOR || source_array_size == 1);
-
-		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-		bool all_ok = cast_data.child_cast_info.function(source_cc, result_cc, source_array_size, child_parameters);
-		return all_ok;
-	} else {
-		// Flatten if not constant
-		source.Flatten(count);
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		FlatVector::SetValidity(result, FlatVector::Validity(source));
-		auto &source_cc = ArrayVector::GetEntry(source);
-		auto &result_cc = ArrayVector::GetEntry(result);
-
-		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-		bool all_ok =
-		    cast_data.child_cast_info.function(source_cc, result_cc, count * source_array_size, child_parameters);
-		return all_ok;
-	}
-}
-
-//------------------------------------------------------------------------------
-// ARRAY -> VARCHAR
-//------------------------------------------------------------------------------
-static bool ArrayToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto is_constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-	auto size = ArrayType::GetSize(source.GetType());
-	Vector varchar_list(LogicalType::ARRAY(LogicalType::VARCHAR, size), count);
-	ArrayToArrayCast(source, varchar_list, count, parameters);
-
-	varchar_list.Flatten(count);
-	auto &validity = FlatVector::Validity(varchar_list);
-	auto &child = ArrayVector::GetEntry(varchar_list);
-
-	child.Flatten(count);
-	auto &child_validity = FlatVector::Validity(child);
-
-	auto in_data = FlatVector::GetData<string_t>(child);
-	auto out_data = FlatVector::GetData<string_t>(result);
-
-	static constexpr const idx_t SEP_LENGTH = 2;
-	static constexpr const idx_t NULL_LENGTH = 4;
-
-	for (idx_t i = 0; i < count; i++) {
-		if (!validity.RowIsValid(i)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-
-		// First pass, compute the length
-		idx_t array_varchar_length = 2;
-		for (idx_t j = 0; j < size; j++) {
-			auto elem_idx = (i * size) + j;
-			auto elem = in_data[elem_idx];
-			if (j > 0) {
-				array_varchar_length += SEP_LENGTH;
-			}
-			array_varchar_length += child_validity.RowIsValid(elem_idx) ? elem.GetSize() : NULL_LENGTH;
-		}
-
-		out_data[i] = StringVector::EmptyString(result, array_varchar_length);
-		auto dataptr = out_data[i].GetDataWriteable();
-		idx_t offset = 0;
-		dataptr[offset++] = '[';
-
-		// Second pass, write the actual data
-		for (idx_t j = 0; j < size; j++) {
-			auto elem_idx = (i * size) + j;
-			auto elem = in_data[elem_idx];
-			if (j > 0) {
-				memcpy(dataptr + offset, ", ", SEP_LENGTH);
-				offset += SEP_LENGTH;
-			}
-			if (child_validity.RowIsValid(elem_idx)) {
-				auto len = elem.GetSize();
-				memcpy(dataptr + offset, elem.GetData(), len);
-				offset += len;
-			} else {
-				memcpy(dataptr + offset, "NULL", NULL_LENGTH);
-				offset += NULL_LENGTH;
-			}
-		}
-		dataptr[offset++] = ']';
-		out_data[i].Finalize();
-	}
-
-	if (is_constant) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	return true;
-}
-
-//------------------------------------------------------------------------------
-// ARRAY -> LIST
-//------------------------------------------------------------------------------
-static bool ArrayToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
-
-	// FIXME: dont flatten
-	source.Flatten(count);
-
-	auto array_size = ArrayType::GetSize(source.GetType());
-	auto child_count = count * array_size;
-
-	ListVector::Reserve(result, child_count);
-	ListVector::SetListSize(result, child_count);
-
-	auto &source_child = ArrayVector::GetEntry(source);
-	auto &result_child = ListVector::GetEntry(result);
-
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-	bool all_ok = cast_data.child_cast_info.function(source_child, result_child, child_count, child_parameters);
-
-	auto list_data = ListVector::GetData(result);
-	for (idx_t i = 0; i < count; i++) {
-		if (FlatVector::IsNull(source, i)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-
-		list_data[i].offset = i * array_size;
-		list_data[i].length = array_size;
-	}
-
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	return all_ok;
-}
-
-BoundCastInfo DefaultCasts::ArrayCastSwitch(BindCastInput &input, const LogicalType &source,
-                                            const LogicalType &target) {
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR: {
-		auto size = ArrayType::GetSize(source);
-		return BoundCastInfo(
-		    ArrayToVarcharCast,
-		    ArrayBoundCastData::BindArrayToArrayCast(input, source, LogicalType::ARRAY(LogicalType::VARCHAR, size)),
-		    ArrayBoundCastData::InitArrayLocalState);
-	}
-	case LogicalTypeId::ARRAY:
-		return BoundCastInfo(ArrayToArrayCast, ArrayBoundCastData::BindArrayToArrayCast(input, source, target),
-		                     ArrayBoundCastData::InitArrayLocalState);
-	case LogicalTypeId::LIST:
-		return BoundCastInfo(ArrayToListCast, BindArrayToListCast(input, source, target),
-		                     ArrayBoundCastData::InitArrayLocalState);
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	};
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/bit_cast.cpp b/src/duckdb/src/function/cast/bit_cast.cpp
deleted file mode 100644
index e542a1427..000000000
--- a/src/duckdb/src/function/cast/bit_cast.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-namespace duckdb {
-
-BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	// Numerics
-	case LogicalTypeId::BOOLEAN:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, bool, CastFromBitToNumeric>);
-	case LogicalTypeId::TINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int8_t, CastFromBitToNumeric>);
-	case LogicalTypeId::SMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int16_t, CastFromBitToNumeric>);
-	case LogicalTypeId::INTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int32_t, CastFromBitToNumeric>);
-	case LogicalTypeId::BIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int64_t, CastFromBitToNumeric>);
-	case LogicalTypeId::UTINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint8_t, CastFromBitToNumeric>);
-	case LogicalTypeId::USMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint16_t, CastFromBitToNumeric>);
-	case LogicalTypeId::UINTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint32_t, CastFromBitToNumeric>);
-	case LogicalTypeId::UBIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint64_t, CastFromBitToNumeric>);
-	case LogicalTypeId::HUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, hugeint_t, CastFromBitToNumeric>);
-	case LogicalTypeId::UHUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uhugeint_t, CastFromBitToNumeric>);
-	case LogicalTypeId::FLOAT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, float, CastFromBitToNumeric>);
-	case LogicalTypeId::DOUBLE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, double, CastFromBitToNumeric>);
-
-	case LogicalTypeId::BLOB:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToBlob>);
-
-	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToString>);
-
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/blob_cast.cpp b/src/duckdb/src/function/cast/blob_cast.cpp
deleted file mode 100644
index 170a733d2..000000000
--- a/src/duckdb/src/function/cast/blob_cast.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-namespace duckdb {
-
-BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// blob to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
-	case LogicalTypeId::AGGREGATE_STATE:
-		return DefaultCasts::ReinterpretCast;
-	case LogicalTypeId::BIT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlobToBit>);
-
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/cast_function_set.cpp b/src/duckdb/src/function/cast/cast_function_set.cpp
deleted file mode 100644
index 48b8bef77..000000000
--- a/src/duckdb/src/function/cast/cast_function_set.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-#include "duckdb/function/cast/cast_function_set.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/type_map.hpp"
-#include "duckdb/function/cast_rules.hpp"
-#include "duckdb/planner/collation_binding.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-BindCastInput::BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCastInfo> info,
-                             optional_ptr<ClientContext> context)
-    : function_set(function_set), info(info), context(context) {
-}
-
-BoundCastInfo BindCastInput::GetCastFunction(const LogicalType &source, const LogicalType &target) {
-	GetCastFunctionInput input(context);
-	input.query_location = query_location;
-	return function_set.GetCastFunction(source, target, input);
-}
-
-BindCastFunction::BindCastFunction(bind_cast_function_t function_p, unique_ptr<BindCastInfo> info_p)
-    : function(function_p), info(std::move(info_p)) {
-}
-
-CastFunctionSet::CastFunctionSet() : map_info(nullptr) {
-	bind_functions.emplace_back(DefaultCasts::GetDefaultCastFunction);
-}
-
-CastFunctionSet::CastFunctionSet(DBConfig &config_p) : CastFunctionSet() {
-	this->config = &config_p;
-}
-
-CastFunctionSet &CastFunctionSet::Get(ClientContext &context) {
-	return DBConfig::GetConfig(context).GetCastFunctions();
-}
-
-CollationBinding &CollationBinding::Get(ClientContext &context) {
-	return DBConfig::GetConfig(context).GetCollationBinding();
-}
-
-CastFunctionSet &CastFunctionSet::Get(DatabaseInstance &db) {
-	return DBConfig::GetConfig(db).GetCastFunctions();
-}
-
-CollationBinding &CollationBinding::Get(DatabaseInstance &db) {
-	return DBConfig::GetConfig(db).GetCollationBinding();
-}
-
-BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const LogicalType &target,
-                                               GetCastFunctionInput &get_input) {
-	if (source == target) {
-		return DefaultCasts::NopCast;
-	}
-	// the first function is the default
-	// we iterate the set of bind functions backwards
-	for (idx_t i = bind_functions.size(); i > 0; i--) {
-		auto &bind_function = bind_functions[i - 1];
-		BindCastInput input(*this, bind_function.info.get(), get_input.context);
-		input.query_location = get_input.query_location;
-		auto result = bind_function.function(input, source, target);
-		if (result.function) {
-			// found a cast function! return it
-			return result;
-		}
-	}
-	// no cast found: return the default null cast
-	return DefaultCasts::TryVectorNullCast;
-}
-
-struct MapCastNode {
-	MapCastNode(BoundCastInfo info, int64_t implicit_cast_cost)
-	    : cast_info(std::move(info)), bind_function(nullptr), implicit_cast_cost(implicit_cast_cost) {
-	}
-	MapCastNode(bind_cast_function_t func, int64_t implicit_cast_cost)
-	    : cast_info(nullptr), bind_function(func), implicit_cast_cost(implicit_cast_cost) {
-	}
-
-	BoundCastInfo cast_info;
-	bind_cast_function_t bind_function;
-	int64_t implicit_cast_cost;
-};
-
-template <class MAP_VALUE_TYPE>
-static auto RelaxedTypeMatch(type_map_t<MAP_VALUE_TYPE> &map, const LogicalType &type) -> decltype(map.find(type)) {
-	D_ASSERT(map.find(type) == map.end()); // we shouldn't be here
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-		return map.find(LogicalType::LIST(LogicalType::ANY));
-	case LogicalTypeId::STRUCT:
-		return map.find(LogicalType::STRUCT({{"any", LogicalType::ANY}}));
-	case LogicalTypeId::MAP:
-		for (auto it = map.begin(); it != map.end(); it++) {
-			const auto &entry_type = it->first;
-			if (entry_type.id() != LogicalTypeId::MAP) {
-				continue;
-			}
-			auto &entry_key_type = MapType::KeyType(entry_type);
-			auto &entry_val_type = MapType::ValueType(entry_type);
-			if ((entry_key_type == LogicalType::ANY || entry_key_type == MapType::KeyType(type)) &&
-			    (entry_val_type == LogicalType::ANY || entry_val_type == MapType::ValueType(type))) {
-				return it;
-			}
-		}
-		return map.end();
-	case LogicalTypeId::UNION:
-		return map.find(LogicalType::UNION({{"any", LogicalType::ANY}}));
-	case LogicalTypeId::ARRAY:
-		return map.find(LogicalType::ARRAY(LogicalType::ANY, optional_idx()));
-	default:
-		return map.find(LogicalType::ANY);
-	}
-}
-
-struct MapCastInfo : public BindCastInfo {
-public:
-	const optional_ptr<MapCastNode> GetEntry(const LogicalType &source, const LogicalType &target) {
-		auto source_type_id_entry = casts.find(source.id());
-		if (source_type_id_entry == casts.end()) {
-			source_type_id_entry = casts.find(LogicalTypeId::ANY);
-			if (source_type_id_entry == casts.end()) {
-				return nullptr;
-			}
-		}
-
-		auto &source_type_entries = source_type_id_entry->second;
-		auto source_type_entry = source_type_entries.find(source);
-		if (source_type_entry == source_type_entries.end()) {
-			source_type_entry = RelaxedTypeMatch(source_type_entries, source);
-			if (source_type_entry == source_type_entries.end()) {
-				return nullptr;
-			}
-		}
-
-		auto &target_type_id_entries = source_type_entry->second;
-		auto target_type_id_entry = target_type_id_entries.find(target.id());
-		if (target_type_id_entry == target_type_id_entries.end()) {
-			target_type_id_entry = target_type_id_entries.find(LogicalTypeId::ANY);
-			if (target_type_id_entry == target_type_id_entries.end()) {
-				return nullptr;
-			}
-		}
-
-		auto &target_type_entries = target_type_id_entry->second;
-		auto target_type_entry = target_type_entries.find(target);
-		if (target_type_entry == target_type_entries.end()) {
-			target_type_entry = RelaxedTypeMatch(target_type_entries, target);
-			if (target_type_entry == target_type_entries.end()) {
-				return nullptr;
-			}
-		}
-
-		return &target_type_entry->second;
-	}
-
-	void AddEntry(const LogicalType &source, const LogicalType &target, MapCastNode node) {
-		casts[source.id()][source][target.id()].insert(make_pair(target, std::move(node)));
-	}
-
-private:
-	type_id_map_t<type_map_t<type_id_map_t<type_map_t<MapCastNode>>>> casts;
-};
-
-int64_t CastFunctionSet::ImplicitCastCost(const LogicalType &source, const LogicalType &target) {
-	// check if a cast has been registered
-	if (map_info) {
-		auto entry = map_info->GetEntry(source, target);
-		if (entry) {
-			return entry->implicit_cast_cost;
-		}
-	}
-	// if not, fallback to the default implicit cast rules
-	auto score = CastRules::ImplicitCast(source, target);
-	if (score < 0 && config && config->options.old_implicit_casting) {
-		if (source.id() != LogicalTypeId::BLOB && target.id() == LogicalTypeId::VARCHAR) {
-			score = 149;
-		}
-	}
-	return score;
-}
-
-BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	D_ASSERT(input.info);
-	auto &map_info = input.info->Cast<MapCastInfo>();
-	auto entry = map_info.GetEntry(source, target);
-	if (entry) {
-		if (entry->bind_function) {
-			return entry->bind_function(input, source, target);
-		}
-		return entry->cast_info.Copy();
-	}
-	return nullptr;
-}
-
-void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
-                                           int64_t implicit_cast_cost) {
-	RegisterCastFunction(source, target, MapCastNode(std::move(function), implicit_cast_cost));
-}
-
-void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target,
-                                           bind_cast_function_t bind_function, int64_t implicit_cast_cost) {
-	RegisterCastFunction(source, target, MapCastNode(bind_function, implicit_cast_cost));
-}
-
-void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, MapCastNode node) {
-	if (!map_info) {
-		// create the cast map and the cast map function
-		auto info = make_uniq<MapCastInfo>();
-		map_info = info.get();
-		bind_functions.emplace_back(MapCastFunction, std::move(info));
-	}
-	map_info->AddEntry(source, target, std::move(node));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/decimal_cast.cpp b/src/duckdb/src/function/cast/decimal_cast.cpp
deleted file mode 100644
index 21f80bf04..000000000
--- a/src/duckdb/src/function/cast/decimal_cast.cpp
+++ /dev/null
@@ -1,324 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-#include "duckdb/common/vector_operations/general_cast.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-template <class T>
-static bool FromDecimalCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &source_type = source.GetType();
-	auto width = DecimalType::GetWidth(source_type);
-	auto scale = DecimalType::GetScale(source_type);
-	switch (source_type.InternalType()) {
-	case PhysicalType::INT16:
-		return VectorCastHelpers::TemplatedDecimalCast<int16_t, T, TryCastFromDecimal>(source, result, count,
-		                                                                               parameters, width, scale);
-	case PhysicalType::INT32:
-		return VectorCastHelpers::TemplatedDecimalCast<int32_t, T, TryCastFromDecimal>(source, result, count,
-		                                                                               parameters, width, scale);
-	case PhysicalType::INT64:
-		return VectorCastHelpers::TemplatedDecimalCast<int64_t, T, TryCastFromDecimal>(source, result, count,
-		                                                                               parameters, width, scale);
-	case PhysicalType::INT128:
-		return VectorCastHelpers::TemplatedDecimalCast<hugeint_t, T, TryCastFromDecimal>(source, result, count,
-		                                                                                 parameters, width, scale);
-	default:
-		throw InternalException("Unimplemented internal type for decimal");
-	}
-}
-
-template <class LIMIT_TYPE, class FACTOR_TYPE = LIMIT_TYPE>
-struct DecimalScaleInput {
-	DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p, CastParameters &parameters)
-	    : result(result_p), vector_cast_data(result, parameters), factor(factor_p) {
-	}
-	DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, CastParameters &parameters,
-	                  uint8_t source_width_p, uint8_t source_scale_p)
-	    : result(result_p), vector_cast_data(result, parameters), limit(limit_p), factor(factor_p),
-	      source_width(source_width_p), source_scale(source_scale_p) {
-	}
-
-	Vector &result;
-	VectorTryCastData vector_cast_data;
-	LIMIT_TYPE limit;
-	FACTOR_TYPE factor;
-	uint8_t source_width;
-	uint8_t source_scale;
-};
-
-struct DecimalScaleUpOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalScaleInput<INPUT_TYPE, RESULT_TYPE> *)dataptr;
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input) * data->factor;
-	}
-};
-
-struct DecimalScaleUpCheckOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalScaleInput<INPUT_TYPE, RESULT_TYPE> *)dataptr;
-		if (input >= data->limit || input <= -data->limit) {
-			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
-			                                Decimal::ToString(input, data->source_width, data->source_scale),
-			                                data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->vector_cast_data);
-		}
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input) * data->factor;
-	}
-};
-
-template <class SOURCE, class DEST, class POWERS_SOURCE, class POWERS_DEST>
-bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto source_scale = DecimalType::GetScale(source.GetType());
-	auto source_width = DecimalType::GetWidth(source.GetType());
-	auto result_scale = DecimalType::GetScale(result.GetType());
-	auto result_width = DecimalType::GetWidth(result.GetType());
-	D_ASSERT(result_scale >= source_scale);
-	idx_t scale_difference = result_scale - source_scale;
-	DEST multiply_factor = UnsafeNumericCast<DEST>(POWERS_DEST::POWERS_OF_TEN[scale_difference]);
-	idx_t target_width = result_width - scale_difference;
-	if (source_width < target_width) {
-		DecimalScaleInput<SOURCE, DEST> input(result, multiply_factor, parameters);
-		// type will always fit: no need to check limit
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpOperator>(source, result, count, &input);
-		return true;
-	} else {
-		// type might not fit: check limit
-		auto limit = UnsafeNumericCast<SOURCE>(POWERS_SOURCE::POWERS_OF_TEN[target_width]);
-		DecimalScaleInput<SOURCE, DEST> input(result, limit, multiply_factor, parameters, source_width, source_scale);
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpCheckOperator>(source, result, count, &input,
-		                                                                         parameters.error_message);
-		return input.vector_cast_data.all_converted;
-	}
-}
-
-struct DecimalScaleDownOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		//	We need to round here, not truncate.
-		auto data = (DecimalScaleInput<INPUT_TYPE> *)dataptr;
-		//	Scale first so we don't overflow when rounding.
-		const auto scaling = data->factor / 2;
-		input /= scaling;
-		if (input < 0) {
-			input -= 1;
-		} else {
-			input += 1;
-		}
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / 2);
-	}
-};
-
-// This function detects if we can scale a decimal down to another.
-template <class INPUT_TYPE>
-bool CanScaleDownDecimal(INPUT_TYPE input, DecimalScaleInput<INPUT_TYPE> &data) {
-	int64_t divisor = UnsafeNumericCast<int64_t>(NumericHelper::POWERS_OF_TEN[data.source_scale]);
-	auto value = input % divisor;
-	auto rounded_input = input;
-	if (rounded_input < 0) {
-		rounded_input *= -1;
-		value *= -1;
-	}
-	if (value >= divisor / 2) {
-		rounded_input += divisor;
-	}
-	return rounded_input < data.limit && rounded_input > -data.limit;
-}
-
-template <>
-bool CanScaleDownDecimal<hugeint_t>(hugeint_t input, DecimalScaleInput<hugeint_t> &data) {
-	auto divisor = UnsafeNumericCast<hugeint_t>(Hugeint::POWERS_OF_TEN[data.source_scale]);
-	hugeint_t value = input % divisor;
-	hugeint_t rounded_input = input;
-	if (rounded_input < 0) {
-		rounded_input *= -1;
-		value *= -1;
-	}
-	if (value >= divisor / 2) {
-		rounded_input += divisor;
-	}
-	return rounded_input < data.limit && rounded_input > -data.limit;
-}
-
-struct DecimalScaleDownCheckOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = static_cast<DecimalScaleInput<INPUT_TYPE> *>(dataptr);
-		if (!CanScaleDownDecimal(input, *data)) {
-			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
-			                                Decimal::ToString(input, data->source_width, data->source_scale),
-			                                data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->vector_cast_data);
-		}
-		return DecimalScaleDownOperator::Operation<INPUT_TYPE, RESULT_TYPE>(input, mask, idx, dataptr);
-	}
-};
-
-template <class SOURCE, class DEST, class POWERS_SOURCE>
-bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto source_scale = DecimalType::GetScale(source.GetType());
-	auto source_width = DecimalType::GetWidth(source.GetType());
-	auto result_scale = DecimalType::GetScale(result.GetType());
-	auto result_width = DecimalType::GetWidth(result.GetType());
-	D_ASSERT(result_scale < source_scale);
-	idx_t scale_difference = source_scale - result_scale;
-	idx_t target_width = result_width + scale_difference;
-	auto divide_factor = UnsafeNumericCast<SOURCE>(POWERS_SOURCE::POWERS_OF_TEN[scale_difference]);
-	if (source_width < target_width) {
-		DecimalScaleInput<SOURCE> input(result, divide_factor, parameters);
-		// type will always fit: no need to check limit
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownOperator>(source, result, count, &input);
-		return true;
-	} else {
-		// type might not fit: check limit
-		auto limit = UnsafeNumericCast<SOURCE>(POWERS_SOURCE::POWERS_OF_TEN[target_width]);
-		DecimalScaleInput<SOURCE> input(result, limit, divide_factor, parameters, source_width, source_scale);
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownCheckOperator>(source, result, count, &input,
-		                                                                           parameters.error_message);
-		return input.vector_cast_data.all_converted;
-	}
-}
-
-template <class SOURCE, class POWERS_SOURCE>
-static bool DecimalDecimalCastSwitch(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto source_scale = DecimalType::GetScale(source.GetType());
-	auto result_scale = DecimalType::GetScale(result.GetType());
-	source.GetType().Verify();
-	result.GetType().Verify();
-
-	// we need to either multiply or divide by the difference in scales
-	if (result_scale >= source_scale) {
-		// multiply
-		switch (result.GetType().InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedDecimalScaleUp<SOURCE, int16_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              parameters);
-		case PhysicalType::INT32:
-			return TemplatedDecimalScaleUp<SOURCE, int32_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              parameters);
-		case PhysicalType::INT64:
-			return TemplatedDecimalScaleUp<SOURCE, int64_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              parameters);
-		case PhysicalType::INT128:
-			return TemplatedDecimalScaleUp<SOURCE, hugeint_t, POWERS_SOURCE, Hugeint>(source, result, count,
-			                                                                          parameters);
-		default:
-			throw NotImplementedException("Unimplemented internal type for decimal");
-		}
-	} else {
-		// divide
-		switch (result.GetType().InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedDecimalScaleDown<SOURCE, int16_t, POWERS_SOURCE>(source, result, count, parameters);
-		case PhysicalType::INT32:
-			return TemplatedDecimalScaleDown<SOURCE, int32_t, POWERS_SOURCE>(source, result, count, parameters);
-		case PhysicalType::INT64:
-			return TemplatedDecimalScaleDown<SOURCE, int64_t, POWERS_SOURCE>(source, result, count, parameters);
-		case PhysicalType::INT128:
-			return TemplatedDecimalScaleDown<SOURCE, hugeint_t, POWERS_SOURCE>(source, result, count, parameters);
-		default:
-			throw NotImplementedException("Unimplemented internal type for decimal");
-		}
-	}
-}
-
-struct DecimalCastInput {
-	DecimalCastInput(Vector &result_p, uint8_t width_p, uint8_t scale_p)
-	    : result(result_p), width(width_p), scale(scale_p) {
-	}
-
-	Vector &result;
-	uint8_t width;
-	uint8_t scale;
-};
-
-struct StringCastFromDecimalOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = reinterpret_cast<DecimalCastInput *>(dataptr);
-		return StringCastFromDecimal::Operation<INPUT_TYPE>(input, data->width, data->scale, data->result);
-	}
-};
-
-template <class SRC>
-static bool DecimalToStringCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &source_type = source.GetType();
-	auto width = DecimalType::GetWidth(source_type);
-	auto scale = DecimalType::GetScale(source_type);
-	DecimalCastInput input(result, width, scale);
-
-	UnaryExecutor::GenericExecute<SRC, string_t, StringCastFromDecimalOperator>(source, result, count, (void *)&input);
-	return true;
-}
-
-BoundCastInfo DefaultCasts::DecimalCastSwitch(BindCastInput &input, const LogicalType &source,
-                                              const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return FromDecimalCast<bool>;
-	case LogicalTypeId::TINYINT:
-		return FromDecimalCast<int8_t>;
-	case LogicalTypeId::SMALLINT:
-		return FromDecimalCast<int16_t>;
-	case LogicalTypeId::INTEGER:
-		return FromDecimalCast<int32_t>;
-	case LogicalTypeId::BIGINT:
-		return FromDecimalCast<int64_t>;
-	case LogicalTypeId::UTINYINT:
-		return FromDecimalCast<uint8_t>;
-	case LogicalTypeId::USMALLINT:
-		return FromDecimalCast<uint16_t>;
-	case LogicalTypeId::UINTEGER:
-		return FromDecimalCast<uint32_t>;
-	case LogicalTypeId::UBIGINT:
-		return FromDecimalCast<uint64_t>;
-	case LogicalTypeId::HUGEINT:
-		return FromDecimalCast<hugeint_t>;
-	case LogicalTypeId::UHUGEINT:
-		return FromDecimalCast<uhugeint_t>;
-	case LogicalTypeId::DECIMAL: {
-		// decimal to decimal cast
-		// first we need to figure out the source and target internal types
-		switch (source.InternalType()) {
-		case PhysicalType::INT16:
-			return DecimalDecimalCastSwitch<int16_t, NumericHelper>;
-		case PhysicalType::INT32:
-			return DecimalDecimalCastSwitch<int32_t, NumericHelper>;
-		case PhysicalType::INT64:
-			return DecimalDecimalCastSwitch<int64_t, NumericHelper>;
-		case PhysicalType::INT128:
-			return DecimalDecimalCastSwitch<hugeint_t, Hugeint>;
-		default:
-			throw NotImplementedException("Unimplemented internal type for decimal in decimal_decimal cast");
-		}
-	}
-	case LogicalTypeId::FLOAT:
-		return FromDecimalCast<float>;
-	case LogicalTypeId::DOUBLE:
-		return FromDecimalCast<double>;
-	case LogicalTypeId::VARCHAR: {
-		switch (source.InternalType()) {
-		case PhysicalType::INT16:
-			return DecimalToStringCast<int16_t>;
-		case PhysicalType::INT32:
-			return DecimalToStringCast<int32_t>;
-		case PhysicalType::INT64:
-			return DecimalToStringCast<int64_t>;
-		case PhysicalType::INT128:
-			return DecimalToStringCast<hugeint_t>;
-		default:
-			throw InternalException("Unimplemented internal decimal type");
-		}
-	}
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/default_casts.cpp b/src/duckdb/src/function/cast/default_casts.cpp
deleted file mode 100644
index d0da44327..000000000
--- a/src/duckdb/src/function/cast/default_casts.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-namespace duckdb {
-
-BindCastInfo::~BindCastInfo() {
-}
-
-BoundCastData::~BoundCastData() {
-}
-
-BoundCastInfo::BoundCastInfo(cast_function_t function_p, unique_ptr<BoundCastData> cast_data_p,
-                             init_cast_local_state_t init_local_state_p)
-    : function(function_p), init_local_state(init_local_state_p), cast_data(std::move(cast_data_p)) {
-}
-
-BoundCastInfo BoundCastInfo::Copy() const {
-	return BoundCastInfo(function, cast_data ? cast_data->Copy() : nullptr, init_local_state);
-}
-
-bool DefaultCasts::NopCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	result.Reference(source);
-	return true;
-}
-
-void HandleCastError::AssignError(const string &error_message, CastParameters &parameters) {
-	AssignError(error_message, parameters.error_message, parameters.query_location);
-}
-
-static string UnimplementedCastMessage(const LogicalType &source_type, const LogicalType &target_type) {
-	return StringUtil::Format("Unimplemented type for cast (%s -> %s)", source_type.ToString(), target_type.ToString());
-}
-
-// NULL cast only works if all values in source are NULL, otherwise an unimplemented cast exception is thrown
-bool DefaultCasts::TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	bool success = true;
-	if (VectorOperations::HasNotNull(source, count)) {
-		HandleCastError::AssignError(UnimplementedCastMessage(source.GetType(), result.GetType()), parameters);
-		success = false;
-	}
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::SetNull(result, true);
-	return success;
-}
-
-bool DefaultCasts::ReinterpretCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	result.Reinterpret(source);
-	return true;
-}
-
-static bool AggregateStateToBlobCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	if (result.GetType().id() != LogicalTypeId::BLOB) {
-		throw TypeMismatchException(source.GetType(), result.GetType(),
-		                            "Cannot cast AGGREGATE_STATE to anything but BLOB");
-	}
-	result.Reinterpret(source);
-	return true;
-}
-
-static bool NullTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	// cast a NULL to another type, just copy the properties and change the type
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::SetNull(result, true);
-	return true;
-}
-
-BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const LogicalType &source,
-                                                   const LogicalType &target) {
-	D_ASSERT(source != target);
-
-	// first check if were casting to a union
-	if (source.id() != LogicalTypeId::UNION && source.id() != LogicalTypeId::SQLNULL &&
-	    target.id() == LogicalTypeId::UNION) {
-		return ImplicitToUnionCast(input, source, target);
-	}
-
-	// else, switch on source type
-	switch (source.id()) {
-	case LogicalTypeId::BOOLEAN:
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-		return NumericCastSwitch(input, source, target);
-	case LogicalTypeId::POINTER:
-		return PointerCastSwitch(input, source, target);
-	case LogicalTypeId::UUID:
-		return UUIDCastSwitch(input, source, target);
-	case LogicalTypeId::DECIMAL:
-		return DecimalCastSwitch(input, source, target);
-	case LogicalTypeId::DATE:
-		return DateCastSwitch(input, source, target);
-	case LogicalTypeId::TIME:
-		return TimeCastSwitch(input, source, target);
-	case LogicalTypeId::TIME_TZ:
-		return TimeTzCastSwitch(input, source, target);
-	case LogicalTypeId::TIMESTAMP:
-		return TimestampCastSwitch(input, source, target);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return TimestampTzCastSwitch(input, source, target);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return TimestampNsCastSwitch(input, source, target);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return TimestampMsCastSwitch(input, source, target);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return TimestampSecCastSwitch(input, source, target);
-	case LogicalTypeId::INTERVAL:
-		return IntervalCastSwitch(input, source, target);
-	case LogicalTypeId::VARCHAR:
-		return StringCastSwitch(input, source, target);
-	case LogicalTypeId::BLOB:
-		return BlobCastSwitch(input, source, target);
-	case LogicalTypeId::BIT:
-		return BitCastSwitch(input, source, target);
-	case LogicalTypeId::SQLNULL:
-		return NullTypeCast;
-	case LogicalTypeId::MAP:
-		return MapCastSwitch(input, source, target);
-	case LogicalTypeId::STRUCT:
-		return StructCastSwitch(input, source, target);
-	case LogicalTypeId::LIST:
-		return ListCastSwitch(input, source, target);
-	case LogicalTypeId::UNION:
-		return UnionCastSwitch(input, source, target);
-	case LogicalTypeId::ENUM:
-		return EnumCastSwitch(input, source, target);
-	case LogicalTypeId::ARRAY:
-		return ArrayCastSwitch(input, source, target);
-	case LogicalTypeId::VARINT:
-		return VarintCastSwitch(input, source, target);
-	case LogicalTypeId::AGGREGATE_STATE:
-		return AggregateStateToBlobCast;
-	default:
-		return nullptr;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/enum_casts.cpp b/src/duckdb/src/function/cast/enum_casts.cpp
deleted file mode 100644
index 7e22cb932..000000000
--- a/src/duckdb/src/function/cast/enum_casts.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-
-namespace duckdb {
-
-template <class SRC_TYPE, class RES_TYPE>
-bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &enum_dictionary = EnumType::GetValuesInsertOrder(source.GetType());
-	auto dictionary_data = FlatVector::GetData<string_t>(enum_dictionary);
-	auto res_enum_type = result.GetType();
-
-	VectorTryCastData vector_cast_data(result, parameters);
-	UnaryExecutor::ExecuteWithNulls<SRC_TYPE, RES_TYPE>(
-	    source, result, count, [&](SRC_TYPE value, ValidityMask &mask, idx_t row_idx) {
-		    auto key = EnumType::GetPos(res_enum_type, dictionary_data[value]);
-		    if (key == -1) {
-			    if (!parameters.error_message) {
-				    return HandleVectorCastError::Operation<RES_TYPE>(CastExceptionText<SRC_TYPE, RES_TYPE>(value),
-				                                                      mask, row_idx, vector_cast_data);
-			    } else {
-				    mask.SetInvalid(row_idx);
-			    }
-			    return RES_TYPE();
-		    } else {
-			    return UnsafeNumericCast<RES_TYPE>(key);
-		    }
-	    });
-	return vector_cast_data.all_converted;
-}
-
-template <class SRC_TYPE>
-BoundCastInfo EnumEnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	switch (target.InternalType()) {
-	case PhysicalType::UINT8:
-		return EnumEnumCast<SRC_TYPE, uint8_t>;
-	case PhysicalType::UINT16:
-		return EnumEnumCast<SRC_TYPE, uint16_t>;
-	case PhysicalType::UINT32:
-		return EnumEnumCast<SRC_TYPE, uint32_t>;
-	default:
-		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-	}
-}
-
-template <class SRC>
-static bool EnumToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &enum_dictionary = EnumType::GetValuesInsertOrder(source.GetType());
-	auto dictionary_data = FlatVector::GetData<string_t>(enum_dictionary);
-
-	UnaryExecutor::Execute<SRC, string_t>(source, result, count,
-	                                      [&](SRC enum_idx) { return dictionary_data[enum_idx]; });
-	return true;
-}
-
-struct EnumBoundCastData : public BoundCastData {
-	EnumBoundCastData(BoundCastInfo to_varchar_cast, BoundCastInfo from_varchar_cast)
-	    : to_varchar_cast(std::move(to_varchar_cast)), from_varchar_cast(std::move(from_varchar_cast)) {
-	}
-
-	BoundCastInfo to_varchar_cast;
-	BoundCastInfo from_varchar_cast;
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<EnumBoundCastData>(to_varchar_cast.Copy(), from_varchar_cast.Copy());
-	}
-};
-
-unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	auto to_varchar_cast = input.GetCastFunction(source, LogicalType::VARCHAR);
-	auto from_varchar_cast = input.GetCastFunction(LogicalType::VARCHAR, target);
-	return make_uniq<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));
-}
-
-struct EnumCastLocalState : public FunctionLocalState {
-public:
-	unique_ptr<FunctionLocalState> to_varchar_local;
-	unique_ptr<FunctionLocalState> from_varchar_local;
-};
-
-static unique_ptr<FunctionLocalState> InitEnumCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<EnumBoundCastData>();
-	auto result = make_uniq<EnumCastLocalState>();
-
-	if (cast_data.from_varchar_cast.init_local_state) {
-		CastLocalStateParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data);
-		result->from_varchar_local = cast_data.from_varchar_cast.init_local_state(from_varchar_params);
-	}
-	if (cast_data.to_varchar_cast.init_local_state) {
-		CastLocalStateParameters from_varchar_params(parameters, cast_data.to_varchar_cast.cast_data);
-		result->from_varchar_local = cast_data.to_varchar_cast.init_local_state(from_varchar_params);
-	}
-	return std::move(result);
-}
-
-static bool EnumToAnyCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<EnumBoundCastData>();
-	auto &lstate = parameters.local_state->Cast<EnumCastLocalState>();
-
-	Vector varchar_cast(LogicalType::VARCHAR, count);
-
-	// cast to varchar
-	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data, lstate.to_varchar_local);
-	cast_data.to_varchar_cast.function(source, varchar_cast, count, to_varchar_params);
-
-	// cast from varchar to the target
-	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data, lstate.from_varchar_local);
-	cast_data.from_varchar_cast.function(varchar_cast, result, count, from_varchar_params);
-	return true;
-}
-
-BoundCastInfo DefaultCasts::EnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	auto enum_physical_type = source.InternalType();
-	switch (target.id()) {
-	case LogicalTypeId::ENUM: {
-		// This means they are both ENUMs, but of different types.
-		switch (enum_physical_type) {
-		case PhysicalType::UINT8:
-			return EnumEnumCastSwitch<uint8_t>(input, source, target);
-		case PhysicalType::UINT16:
-			return EnumEnumCastSwitch<uint16_t>(input, source, target);
-		case PhysicalType::UINT32:
-			return EnumEnumCastSwitch<uint32_t>(input, source, target);
-		default:
-			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-		}
-	}
-	case LogicalTypeId::VARCHAR:
-		switch (enum_physical_type) {
-		case PhysicalType::UINT8:
-			return EnumToVarcharCast<uint8_t>;
-		case PhysicalType::UINT16:
-			return EnumToVarcharCast<uint16_t>;
-		case PhysicalType::UINT32:
-			return EnumToVarcharCast<uint32_t>;
-		default:
-			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-		}
-	default: {
-		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target), InitEnumCastLocalState);
-	}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/list_casts.cpp b/src/duckdb/src/function/cast/list_casts.cpp
deleted file mode 100644
index a2326f860..000000000
--- a/src/duckdb/src/function/cast/list_casts.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/cast/bound_cast_data.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &input, const LogicalType &source,
-                                                                const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	auto &source_child_type = ListType::GetChildType(source);
-	auto &result_child_type = ListType::GetChildType(target);
-	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
-	return make_uniq<ListBoundCastData>(std::move(child_cast));
-}
-
-static unique_ptr<BoundCastData> BindListToArrayCast(BindCastInput &input, const LogicalType &source,
-                                                     const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	auto &source_child_type = ListType::GetChildType(source);
-	auto &result_child_type = ArrayType::GetChildType(target);
-	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
-	return make_uniq<ListBoundCastData>(std::move(child_cast));
-}
-
-unique_ptr<FunctionLocalState> ListBoundCastData::InitListLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
-	if (!cast_data.child_cast_info.init_local_state) {
-		return nullptr;
-	}
-	CastLocalStateParameters child_parameters(parameters, cast_data.child_cast_info.cast_data);
-	return cast_data.child_cast_info.init_local_state(child_parameters);
-}
-
-bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
-
-	// only handle constant and flat vectors here for now
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(source.GetVectorType());
-		const bool is_null = ConstantVector::IsNull(source);
-		ConstantVector::SetNull(result, is_null);
-
-		if (!is_null) {
-			auto ldata = ConstantVector::GetData<list_entry_t>(source);
-			auto tdata = ConstantVector::GetData<list_entry_t>(result);
-			*tdata = *ldata;
-		}
-	} else {
-		source.Flatten(count);
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		FlatVector::SetValidity(result, FlatVector::Validity(source));
-
-		auto ldata = FlatVector::GetData<list_entry_t>(source);
-		auto tdata = FlatVector::GetData<list_entry_t>(result);
-		for (idx_t i = 0; i < count; i++) {
-			tdata[i] = ldata[i];
-		}
-	}
-	auto &source_cc = ListVector::GetEntry(source);
-	auto source_size = ListVector::GetListSize(source);
-
-	ListVector::Reserve(result, source_size);
-	auto &append_vector = ListVector::GetEntry(result);
-
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-	bool all_succeeded = cast_data.child_cast_info.function(source_cc, append_vector, source_size, child_parameters);
-	ListVector::SetListSize(result, source_size);
-	D_ASSERT(ListVector::GetListSize(result) == source_size);
-	return all_succeeded;
-}
-
-static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	// first cast the child vector to varchar
-	Vector varchar_list(LogicalType::LIST(LogicalType::VARCHAR), count);
-	ListCast::ListToListCast(source, varchar_list, count, parameters);
-
-	// now construct the actual varchar vector
-	varchar_list.Flatten(count);
-	auto &child = ListVector::GetEntry(varchar_list);
-	auto list_data = FlatVector::GetData<list_entry_t>(varchar_list);
-	auto &validity = FlatVector::Validity(varchar_list);
-
-	child.Flatten(ListVector::GetListSize(varchar_list));
-	auto child_data = FlatVector::GetData<string_t>(child);
-	auto &child_validity = FlatVector::Validity(child);
-
-	auto result_data = FlatVector::GetData<string_t>(result);
-	static constexpr const idx_t SEP_LENGTH = 2;
-	static constexpr const idx_t NULL_LENGTH = 4;
-	for (idx_t i = 0; i < count; i++) {
-		if (!validity.RowIsValid(i)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-		auto list = list_data[i];
-		// figure out how long the result needs to be
-		idx_t list_length = 2; // "[" and "]"
-		for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-			auto idx = list.offset + list_idx;
-			if (list_idx > 0) {
-				list_length += SEP_LENGTH; // ", "
-			}
-			// string length, or "NULL"
-			list_length += child_validity.RowIsValid(idx) ? child_data[idx].GetSize() : NULL_LENGTH;
-		}
-		result_data[i] = StringVector::EmptyString(result, list_length);
-		auto dataptr = result_data[i].GetDataWriteable();
-		idx_t offset = 0;
-		dataptr[offset++] = '[';
-		for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-			auto idx = list.offset + list_idx;
-			if (list_idx > 0) {
-				memcpy(dataptr + offset, ", ", SEP_LENGTH);
-				offset += SEP_LENGTH;
-			}
-			if (child_validity.RowIsValid(idx)) {
-				auto len = child_data[idx].GetSize();
-				memcpy(dataptr + offset, child_data[idx].GetData(), len);
-				offset += len;
-			} else {
-				memcpy(dataptr + offset, "NULL", NULL_LENGTH);
-				offset += NULL_LENGTH;
-			}
-		}
-		dataptr[offset] = ']';
-		result_data[i].Finalize();
-	}
-
-	if (constant) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	return true;
-}
-
-static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
-	auto array_size = ArrayType::GetSize(result.GetType());
-
-	// only handle constant and flat vectors here for now
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(source.GetVectorType());
-		if (ConstantVector::IsNull(source)) {
-			ConstantVector::SetNull(result, true);
-			return true;
-		}
-
-		auto ldata = ConstantVector::GetData<list_entry_t>(source)[0];
-		if (!ConstantVector::IsNull(source) && ldata.length != array_size) {
-			// Cant cast to array, list size mismatch
-			auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u", ldata.length,
-			                              array_size);
-			HandleCastError::AssignError(msg, parameters);
-			ConstantVector::SetNull(result, true);
-			return false;
-		}
-
-		auto &source_cc = ListVector::GetEntry(source);
-		auto &result_cc = ArrayVector::GetEntry(result);
-
-		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-
-		if (ldata.offset == 0) {
-			// Fast path: offset is zero, we can just cast `array_size` elements of the child vectors directly
-			// Since the list was constant, there can only be one sequence of data in the child vector
-			return cast_data.child_cast_info.function(source_cc, result_cc, array_size, child_parameters);
-		}
-
-		// Else, we need to copy the range we want to cast to a new vector and cast that
-		// In theory we could slice the source child to create a dictionary, but we would then have to flatten the
-		// result child which is going to allocate a temp vector and perform a copy anyway. Since we just want to copy a
-		// single contiguous range with a single offset, this is simpler.
-
-		Vector payload_vector(source_cc.GetType(), array_size);
-		VectorOperations::Copy(source_cc, payload_vector, ldata.offset + array_size, ldata.offset, 0);
-		return cast_data.child_cast_info.function(payload_vector, result_cc, array_size, child_parameters);
-
-	} else {
-		source.Flatten(count);
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		auto child_type = ArrayType::GetChildType(result.GetType());
-		auto &source_cc = ListVector::GetEntry(source);
-		auto &result_cc = ArrayVector::GetEntry(result);
-		auto ldata = FlatVector::GetData<list_entry_t>(source);
-
-		auto child_count = array_size * count;
-		SelectionVector child_sel(child_count);
-
-		bool all_ok = true;
-
-		for (idx_t i = 0; i < count; i++) {
-			if (FlatVector::IsNull(source, i)) {
-				FlatVector::SetNull(result, i, true);
-				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
-					FlatVector::SetNull(result_cc, i * array_size + array_elem, true);
-					child_sel.set_index(i * array_size + array_elem, 0);
-				}
-			} else if (ldata[i].length != array_size) {
-				if (all_ok) {
-					all_ok = false;
-					auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u",
-					                              ldata[i].length, array_size);
-					HandleCastError::AssignError(msg, parameters);
-				}
-				FlatVector::SetNull(result, i, true);
-				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
-					FlatVector::SetNull(result_cc, i * array_size + array_elem, true);
-					child_sel.set_index(i * array_size + array_elem, 0);
-				}
-			} else {
-				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
-					child_sel.set_index(i * array_size + array_elem, ldata[i].offset + array_elem);
-				}
-			}
-		}
-
-		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-
-		// Fast path: No lists are null
-		// We can just cast the child vector directly
-		// Note: Its worth doing a CheckAllValid here, the slow path is significantly more expensive
-		if (FlatVector::Validity(result).CheckAllValid(count)) {
-			Vector payload_vector(result_cc.GetType(), child_count);
-
-			bool ok = cast_data.child_cast_info.function(source_cc, payload_vector, child_count, child_parameters);
-			if (all_ok && !ok) {
-				all_ok = false;
-				HandleCastError::AssignError(*child_parameters.error_message, parameters);
-			}
-			// Now do the actual copy onto the result vector, making sure to slice properly in case the lists are out of
-			// order
-			VectorOperations::Copy(payload_vector, result_cc, child_sel, child_count, 0, 0);
-			return all_ok;
-		}
-
-		// Slow path: Some lists are null, so we need to copy the data list by list to the right place
-		auto list_data = FlatVector::GetData<list_entry_t>(source);
-		DataChunk cast_chunk;
-		cast_chunk.Initialize(Allocator::DefaultAllocator(), {source_cc.GetType(), result_cc.GetType()}, array_size);
-
-		for (idx_t i = 0; i < count; i++) {
-			if (FlatVector::IsNull(result, i)) {
-				// We've already failed to cast this list above (e.g. length mismatch), so theres nothing to do here.
-				continue;
-			} else {
-				auto &list_cast_input = cast_chunk.data[0];
-				auto &list_cast_output = cast_chunk.data[1];
-				auto list_entry = list_data[i];
-
-				VectorOperations::Copy(source_cc, list_cast_input, list_entry.offset + array_size, list_entry.offset,
-				                       0);
-
-				bool ok =
-				    cast_data.child_cast_info.function(list_cast_input, list_cast_output, array_size, child_parameters);
-				if (all_ok && !ok) {
-					all_ok = false;
-					HandleCastError::AssignError(*child_parameters.error_message, parameters);
-				}
-				VectorOperations::Copy(list_cast_output, result_cc, array_size, 0, i * array_size);
-
-				// Reset the cast_chunk
-				cast_chunk.Reset();
-			}
-		}
-
-		return all_ok;
-	}
-}
-
-BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	switch (target.id()) {
-	case LogicalTypeId::LIST:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
-		                     ListBoundCastData::InitListLocalState);
-	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(
-		    ListToVarcharCast,
-		    ListBoundCastData::BindListToListCast(input, source, LogicalType::LIST(LogicalType::VARCHAR)),
-		    ListBoundCastData::InitListLocalState);
-	case LogicalTypeId::ARRAY:
-		return BoundCastInfo(ListToArrayCast, BindListToArrayCast(input, source, target),
-		                     ListBoundCastData::InitListLocalState);
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-/*
-
- */
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/map_cast.cpp b/src/duckdb/src/function/cast/map_cast.cpp
deleted file mode 100644
index 20c14efa0..000000000
--- a/src/duckdb/src/function/cast/map_cast.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/cast/bound_cast_data.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundCastData> MapBoundCastData::BindMapToMapCast(BindCastInput &input, const LogicalType &source,
-                                                             const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	auto source_key = MapType::KeyType(source);
-	auto target_key = MapType::KeyType(target);
-	auto source_val = MapType::ValueType(source);
-	auto target_val = MapType::ValueType(target);
-	auto key_cast = input.GetCastFunction(source_key, target_key);
-	auto value_cast = input.GetCastFunction(source_val, target_val);
-	return make_uniq<MapBoundCastData>(std::move(key_cast), std::move(value_cast));
-}
-
-static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	Vector varchar_map(varchar_type, count);
-
-	// since map's physical type is a list, the ListCast can be utilized
-	ListCast::ListToListCast(source, varchar_map, count, parameters);
-
-	varchar_map.Flatten(count);
-	auto &validity = FlatVector::Validity(varchar_map);
-	auto &key_str = MapVector::GetKeys(varchar_map);
-	auto &val_str = MapVector::GetValues(varchar_map);
-
-	key_str.Flatten(ListVector::GetListSize(source));
-	val_str.Flatten(ListVector::GetListSize(source));
-
-	auto list_data = ListVector::GetData(varchar_map);
-	auto key_data = FlatVector::GetData<string_t>(key_str);
-	auto val_data = FlatVector::GetData<string_t>(val_str);
-	auto &key_validity = FlatVector::Validity(key_str);
-	auto &val_validity = FlatVector::Validity(val_str);
-	auto &struct_validity = FlatVector::Validity(ListVector::GetEntry(varchar_map));
-
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < count; i++) {
-		if (!validity.RowIsValid(i)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-		auto list = list_data[i];
-		string ret = "{";
-		for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-			if (list_idx > 0) {
-				ret += ", ";
-			}
-			auto idx = list.offset + list_idx;
-
-			if (!struct_validity.RowIsValid(idx)) {
-				ret += "NULL";
-				continue;
-			}
-			if (!key_validity.RowIsValid(idx)) {
-				// throw InternalException("Error in map: key validity invalid?!");
-				ret += "invalid";
-				continue;
-			}
-			ret += key_data[idx].GetString();
-			ret += "=";
-			ret += val_validity.RowIsValid(idx) ? val_data[idx].GetString() : "NULL";
-		}
-		ret += "}";
-		result_data[i] = StringVector::AddString(result, ret);
-	}
-
-	if (constant) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	return true;
-}
-
-BoundCastInfo DefaultCasts::MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	switch (target.id()) {
-	case LogicalTypeId::MAP:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
-		                     ListBoundCastData::InitListLocalState);
-	case LogicalTypeId::VARCHAR: {
-		auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type),
-		                     ListBoundCastData::InitListLocalState);
-	}
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/numeric_casts.cpp b/src/duckdb/src/function/cast/numeric_casts.cpp
deleted file mode 100644
index bdb999ffc..000000000
--- a/src/duckdb/src/function/cast/numeric_casts.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/operator/numeric_cast.hpp"
-#include "duckdb/common/types/varint.hpp"
-
-namespace duckdb {
-
-template <class SRC>
-static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, bool, duckdb::NumericTryCast>);
-	case LogicalTypeId::TINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, int8_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::SMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, int16_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::INTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, int32_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::BIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, int64_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::UTINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uint8_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::USMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uint16_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::UINTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uint32_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::UBIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uint64_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::HUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, hugeint_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::UHUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uhugeint_t, duckdb::NumericTryCast>);
-	case LogicalTypeId::FLOAT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, float, duckdb::NumericTryCast>);
-	case LogicalTypeId::DOUBLE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, double, duckdb::NumericTryCast>);
-	case LogicalTypeId::DECIMAL:
-		return BoundCastInfo(&VectorCastHelpers::ToDecimalCast<SRC>);
-	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::StringCast>);
-	case LogicalTypeId::BIT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::NumericTryCastToBit>);
-	case LogicalTypeId::VARINT:
-		return Varint::NumericToVarintCastSwitch(source);
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::NumericCastSwitch(BindCastInput &input, const LogicalType &source,
-                                              const LogicalType &target) {
-	switch (source.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return InternalNumericCastSwitch<bool>(source, target);
-	case LogicalTypeId::TINYINT:
-		return InternalNumericCastSwitch<int8_t>(source, target);
-	case LogicalTypeId::SMALLINT:
-		return InternalNumericCastSwitch<int16_t>(source, target);
-	case LogicalTypeId::INTEGER:
-		return InternalNumericCastSwitch<int32_t>(source, target);
-	case LogicalTypeId::BIGINT:
-		return InternalNumericCastSwitch<int64_t>(source, target);
-	case LogicalTypeId::UTINYINT:
-		return InternalNumericCastSwitch<uint8_t>(source, target);
-	case LogicalTypeId::USMALLINT:
-		return InternalNumericCastSwitch<uint16_t>(source, target);
-	case LogicalTypeId::UINTEGER:
-		return InternalNumericCastSwitch<uint32_t>(source, target);
-	case LogicalTypeId::UBIGINT:
-		return InternalNumericCastSwitch<uint64_t>(source, target);
-	case LogicalTypeId::HUGEINT:
-		return InternalNumericCastSwitch<hugeint_t>(source, target);
-	case LogicalTypeId::UHUGEINT:
-		return InternalNumericCastSwitch<uhugeint_t>(source, target);
-	case LogicalTypeId::FLOAT:
-		return InternalNumericCastSwitch<float>(source, target);
-	case LogicalTypeId::DOUBLE:
-		return InternalNumericCastSwitch<double>(source, target);
-	default:
-		throw InternalException("NumericCastSwitch called with non-numeric argument");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/pointer_cast.cpp b/src/duckdb/src/function/cast/pointer_cast.cpp
deleted file mode 100644
index 33eead299..000000000
--- a/src/duckdb/src/function/cast/pointer_cast.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-namespace duckdb {
-
-BoundCastInfo DefaultCasts::PointerCastSwitch(BindCastInput &input, const LogicalType &source,
-                                              const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// pointer to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<uintptr_t, duckdb::CastFromPointer>);
-	default:
-		return nullptr;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/string_cast.cpp b/src/duckdb/src/function/cast/string_cast.cpp
deleted file mode 100644
index f3a19c427..000000000
--- a/src/duckdb/src/function/cast/string_cast.cpp
+++ /dev/null
@@ -1,526 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/cast/bound_cast_data.hpp"
-#include "duckdb/common/types/varint.hpp"
-
-namespace duckdb {
-
-template <class T>
-bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type,
-                        T *result_data, ValidityMask &result_mask, const LogicalType &result_type, idx_t count,
-                        VectorTryCastData &vector_cast_data, const SelectionVector *sel) {
-	for (idx_t i = 0; i < count; i++) {
-		idx_t source_idx = i;
-		if (sel) {
-			source_idx = sel->get_index(i);
-		}
-		if (source_mask.RowIsValid(source_idx)) {
-			auto pos = EnumType::GetPos(result_type, source_data[source_idx]);
-			if (pos == -1) {
-				result_data[i] = HandleVectorCastError::Operation<T>(
-				    CastExceptionText<string_t, T>(source_data[source_idx]), result_mask, i, vector_cast_data);
-			} else {
-				result_data[i] = UnsafeNumericCast<T>(pos);
-			}
-		} else {
-			result_mask.SetInvalid(i);
-		}
-	}
-	return vector_cast_data.all_converted;
-}
-
-template <class T>
-bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-	switch (source.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		auto source_data = ConstantVector::GetData<string_t>(source);
-		auto source_mask = ConstantVector::Validity(source);
-		auto result_data = ConstantVector::GetData<T>(result);
-		auto &result_mask = ConstantVector::Validity(result);
-
-		VectorTryCastData vector_cast_data(result, parameters);
-		return StringEnumCastLoop(source_data, source_mask, source.GetType(), result_data, result_mask,
-		                          result.GetType(), 1, vector_cast_data, nullptr);
-	}
-	default: {
-		UnifiedVectorFormat vdata;
-		source.ToUnifiedFormat(count, vdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		auto source_data = UnifiedVectorFormat::GetData<string_t>(vdata);
-		auto source_sel = vdata.sel;
-		auto source_mask = vdata.validity;
-		auto result_data = FlatVector::GetData<T>(result);
-		auto &result_mask = FlatVector::Validity(result);
-
-		VectorTryCastData vector_cast_data(result, parameters);
-		return StringEnumCastLoop(source_data, source_mask, source.GetType(), result_data, result_mask,
-		                          result.GetType(), count, vector_cast_data, source_sel);
-	}
-	}
-}
-
-static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const LogicalType &source,
-                                                   const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::ENUM: {
-		switch (target.InternalType()) {
-		case PhysicalType::UINT8:
-			return StringEnumCast<uint8_t>;
-		case PhysicalType::UINT16:
-			return StringEnumCast<uint16_t>;
-		case PhysicalType::UINT32:
-			return StringEnumCast<uint32_t>;
-		default:
-			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-		}
-	}
-	case LogicalTypeId::BOOLEAN:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, bool, duckdb::TryCast>);
-	case LogicalTypeId::TINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, int8_t, duckdb::TryCast>);
-	case LogicalTypeId::SMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, int16_t, duckdb::TryCast>);
-	case LogicalTypeId::INTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, int32_t, duckdb::TryCast>);
-	case LogicalTypeId::BIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, int64_t, duckdb::TryCast>);
-	case LogicalTypeId::UTINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uint8_t, duckdb::TryCast>);
-	case LogicalTypeId::USMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uint16_t, duckdb::TryCast>);
-	case LogicalTypeId::UINTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uint32_t, duckdb::TryCast>);
-	case LogicalTypeId::UBIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uint64_t, duckdb::TryCast>);
-	case LogicalTypeId::HUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, hugeint_t, duckdb::TryCast>);
-	case LogicalTypeId::UHUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uhugeint_t, duckdb::TryCast>);
-	case LogicalTypeId::FLOAT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, float, duckdb::TryCast>);
-	case LogicalTypeId::DOUBLE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, double, duckdb::TryCast>);
-	case LogicalTypeId::INTERVAL:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, interval_t, duckdb::TryCastErrorMessage>);
-	case LogicalTypeId::DECIMAL:
-		return BoundCastInfo(&VectorCastHelpers::ToDecimalCast<string_t>);
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// string -> list casting
-//===--------------------------------------------------------------------===//
-bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
-                                                    Vector &result, ValidityMask &result_mask, idx_t count,
-                                                    CastParameters &parameters, const SelectionVector *sel) {
-	idx_t total_list_size = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-		if (!source_mask.RowIsValid(idx)) {
-			continue;
-		}
-		total_list_size += VectorStringToList::CountPartsList(source_data[idx]);
-	}
-
-	Vector varchar_vector(LogicalType::VARCHAR, total_list_size);
-
-	ListVector::Reserve(result, total_list_size);
-	ListVector::SetListSize(result, total_list_size);
-
-	auto list_data = ListVector::GetData(result);
-	auto child_data = FlatVector::GetData<string_t>(varchar_vector);
-
-	VectorTryCastData vector_cast_data(result, parameters);
-	idx_t total = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-		if (!source_mask.RowIsValid(idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-
-		list_data[i].offset = total;
-		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
-			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
-			              "' can't be cast to the destination type LIST";
-			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
-		}
-		list_data[i].length = total - list_data[i].offset; // length is the amount of parts coming from this string
-	}
-	D_ASSERT(total_list_size == total);
-
-	auto &result_child = ListVector::GetEntry(result);
-	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-	bool all_converted =
-	    cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) &&
-	    vector_cast_data.all_converted;
-	if (!all_converted && parameters.nullify_parent) {
-		UnifiedVectorFormat inserted_column_data;
-		result_child.ToUnifiedFormat(total_list_size, inserted_column_data);
-		UnifiedVectorFormat parse_column_data;
-		varchar_vector.ToUnifiedFormat(total_list_size, parse_column_data);
-		// Something went wrong in the conversion, we need to nullify the parent
-		for (idx_t i = 0; i < count; i++) {
-			for (idx_t j = list_data[i].offset; j < list_data[i].offset + list_data[i].length; j++) {
-				if (!inserted_column_data.validity.RowIsValid(j) && parse_column_data.validity.RowIsValid(j)) {
-					result_mask.SetInvalid(i);
-					break;
-				}
-			}
-		}
-	}
-	return all_converted;
-}
-
-static LogicalType InitVarcharStructType(const LogicalType &target) {
-	child_list_t<LogicalType> child_types;
-	for (auto &child : StructType::GetChildTypes(target)) {
-		child_types.push_back(make_pair(child.first, LogicalType::VARCHAR));
-	}
-
-	return LogicalType::STRUCT(child_types);
-}
-
-//===--------------------------------------------------------------------===//
-// string -> struct casting
-//===--------------------------------------------------------------------===//
-bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
-                                                      Vector &result, ValidityMask &result_mask, idx_t count,
-                                                      CastParameters &parameters, const SelectionVector *sel) {
-	auto varchar_struct_type = InitVarcharStructType(result.GetType());
-	Vector varchar_vector(varchar_struct_type, count);
-	auto &child_vectors = StructVector::GetEntries(varchar_vector);
-	auto &result_children = StructVector::GetEntries(result);
-	auto is_unnamed = StructType::IsUnnamed(result.GetType());
-
-	string_map_t<idx_t> child_names;
-	vector<reference<ValidityMask>> child_masks;
-	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
-		if (!is_unnamed) {
-			child_names.insert({StructType::GetChildName(result.GetType(), child_idx), child_idx});
-		}
-		child_masks.emplace_back(FlatVector::Validity(*child_vectors[child_idx]));
-		child_masks[child_idx].get().SetAllInvalid(count);
-	}
-
-	VectorTryCastData vector_cast_data(result, parameters);
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-		if (!source_mask.RowIsValid(idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		if (is_unnamed) {
-			throw ConversionException("Casting strings to unnamed structs is unsupported");
-		}
-		if (!VectorStringToStruct::SplitStruct(source_data[idx], child_vectors, i, child_names, child_masks)) {
-			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
-			              "' can't be cast to the destination type STRUCT";
-			for (auto &child_mask : child_masks) {
-				child_mask.get().SetInvalid(i); // some values may have already been found and set valid
-			}
-			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
-		}
-	}
-
-	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
-	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
-	D_ASSERT(cast_data.child_cast_info.size() == result_children.size());
-
-	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
-		auto &child_varchar_vector = *child_vectors[child_idx];
-		auto &result_child_vector = *result_children[child_idx];
-		auto &child_cast_info = cast_data.child_cast_info[child_idx];
-		CastParameters child_parameters(parameters, child_cast_info.cast_data, lstate.local_states[child_idx]);
-		if (!child_cast_info.function(child_varchar_vector, result_child_vector, count, child_parameters)) {
-			vector_cast_data.all_converted = false;
-		}
-	}
-	return vector_cast_data.all_converted;
-}
-
-//===--------------------------------------------------------------------===//
-// string -> map casting
-//===--------------------------------------------------------------------===//
-unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
-	auto result = make_uniq<MapCastLocalState>();
-
-	if (cast_data.key_cast.init_local_state) {
-		CastLocalStateParameters child_params(parameters, cast_data.key_cast.cast_data);
-		result->key_state = cast_data.key_cast.init_local_state(child_params);
-	}
-	if (cast_data.value_cast.init_local_state) {
-		CastLocalStateParameters child_params(parameters, cast_data.value_cast.cast_data);
-		result->value_state = cast_data.value_cast.init_local_state(child_params);
-	}
-	return std::move(result);
-}
-
-bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
-                                                   Vector &result, ValidityMask &result_mask, idx_t count,
-                                                   CastParameters &parameters, const SelectionVector *sel) {
-	idx_t total_elements = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-		if (!source_mask.RowIsValid(idx)) {
-			continue;
-		}
-		total_elements += (VectorStringToMap::CountPartsMap(source_data[idx]) + 1) / 2;
-	}
-
-	Vector varchar_key_vector(LogicalType::VARCHAR, total_elements);
-	Vector varchar_val_vector(LogicalType::VARCHAR, total_elements);
-	auto child_key_data = FlatVector::GetData<string_t>(varchar_key_vector);
-	auto child_val_data = FlatVector::GetData<string_t>(varchar_val_vector);
-
-	ListVector::Reserve(result, total_elements);
-	ListVector::SetListSize(result, total_elements);
-	auto list_data = ListVector::GetData(result);
-
-	VectorTryCastData vector_cast_data(result, parameters);
-	idx_t total = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-		if (!source_mask.RowIsValid(idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-
-		list_data[i].offset = total;
-		if (!VectorStringToMap::SplitStringMap(source_data[idx], child_key_data, child_val_data, total,
-		                                       varchar_key_vector, varchar_val_vector)) {
-			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
-			              "' can't be cast to the destination type MAP";
-			FlatVector::SetNull(result, i, true);
-			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
-		}
-		list_data[i].length = total - list_data[i].offset;
-	}
-	D_ASSERT(total_elements == total);
-
-	auto &result_key_child = MapVector::GetKeys(result);
-	auto &result_val_child = MapVector::GetValues(result);
-	auto &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
-	auto &lstate = parameters.local_state->Cast<MapCastLocalState>();
-
-	CastParameters key_params(parameters, cast_data.key_cast.cast_data, lstate.key_state);
-	if (!cast_data.key_cast.function(varchar_key_vector, result_key_child, total_elements, key_params)) {
-		vector_cast_data.all_converted = false;
-	}
-	CastParameters val_params(parameters, cast_data.value_cast.cast_data, lstate.value_state);
-	if (!cast_data.value_cast.function(varchar_val_vector, result_val_child, total_elements, val_params)) {
-		vector_cast_data.all_converted = false;
-	}
-
-	if (!vector_cast_data.all_converted) {
-		auto &key_validity = FlatVector::Validity(result_key_child);
-		for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-			if (!result_mask.RowIsValid(row_idx)) {
-				continue;
-			}
-			auto list = list_data[row_idx];
-			for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-				auto idx = list.offset + list_idx;
-				if (!key_validity.RowIsValid(idx)) {
-					result_mask.SetInvalid(row_idx);
-				}
-			}
-		}
-	}
-	MapVector::MapConversionVerify(result, count);
-	return vector_cast_data.all_converted;
-}
-
-//===--------------------------------------------------------------------===//
-// string -> array casting
-//===--------------------------------------------------------------------===//
-bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
-                                                     Vector &result, ValidityMask &result_mask, idx_t count,
-                                                     CastParameters &parameters, const SelectionVector *sel) {
-	idx_t array_size = ArrayType::GetSize(result.GetType());
-	bool all_lengths_match = true;
-
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-		if (!source_mask.RowIsValid(idx)) {
-			continue;
-		}
-		auto str_array_size = VectorStringToList::CountPartsList(source_data[idx]);
-		if (array_size != str_array_size) {
-			if (all_lengths_match) {
-				all_lengths_match = false;
-				auto msg =
-				    StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY[%u]"
-				                       ", the size of the array must match the destination type",
-				                       source_data[idx].GetString(), array_size);
-				if (parameters.strict) {
-					throw ConversionException(msg);
-				}
-				HandleCastError::AssignError(msg, parameters);
-			}
-			result_mask.SetInvalid(i);
-		}
-	}
-
-	auto child_count = array_size * count;
-	Vector varchar_vector(LogicalType::VARCHAR, child_count);
-	auto child_data = FlatVector::GetData<string_t>(varchar_vector);
-
-	VectorTryCastData vector_cast_data(result, parameters);
-	idx_t total = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t idx = i;
-		if (sel) {
-			idx = sel->get_index(i);
-		}
-
-		if (!source_mask.RowIsValid(idx) || !result_mask.RowIsValid(i)) {
-			// The source is null, or there was a size-mismatch above, so dont try to split the string
-			result_mask.SetInvalid(i);
-
-			// Null the entire array
-			for (idx_t j = 0; j < array_size; j++) {
-				FlatVector::SetNull(varchar_vector, i * array_size + j, true);
-			}
-
-			total += array_size;
-			continue;
-		}
-
-		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
-			auto text = StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY",
-			                               source_data[idx].GetString());
-			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
-		}
-	}
-	D_ASSERT(total == child_count);
-
-	auto &result_child = ArrayVector::GetEntry(result);
-	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-	bool cast_result = cast_data.child_cast_info.function(varchar_vector, result_child, child_count, child_parameters);
-
-	return all_lengths_match && cast_result && vector_cast_data.all_converted;
-}
-
-template <class T>
-bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-
-	switch (source.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		auto source_data = ConstantVector::GetData<string_t>(source);
-		auto &source_mask = ConstantVector::Validity(source);
-		auto &result_mask = FlatVector::Validity(result);
-		auto ret = T::StringToNestedTypeCastLoop(source_data, source_mask, result, result_mask, 1, parameters, nullptr);
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		return ret;
-	}
-	default: {
-		UnifiedVectorFormat unified_source;
-
-		source.ToUnifiedFormat(count, unified_source);
-		auto source_sel = unified_source.sel;
-		auto source_data = UnifiedVectorFormat::GetData<string_t>(unified_source);
-		auto &source_mask = unified_source.validity;
-		auto &result_mask = FlatVector::Validity(result);
-
-		return T::StringToNestedTypeCastLoop(source_data, source_mask, result, result_mask, count, parameters,
-		                                     source_sel);
-	}
-	}
-}
-
-BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const LogicalType &source,
-                                             const LogicalType &target) {
-	switch (target.id()) {
-	case LogicalTypeId::DATE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>);
-	case LogicalTypeId::TIME:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>);
-	case LogicalTypeId::TIME_TZ:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_tz_t, duckdb::TryCastErrorMessage>);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return BoundCastInfo(
-		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_ns_t, duckdb::TryCastToTimestampNS>);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return BoundCastInfo(
-		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampSec>);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return BoundCastInfo(
-		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampMS>);
-	case LogicalTypeId::BLOB:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, duckdb::TryCastToBlob>);
-	case LogicalTypeId::BIT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, duckdb::TryCastToBit>);
-	case LogicalTypeId::UUID:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, hugeint_t, duckdb::TryCastToUUID>);
-	case LogicalTypeId::SQLNULL:
-		return &DefaultCasts::TryVectorNullCast;
-	case LogicalTypeId::VARCHAR:
-		return &DefaultCasts::ReinterpretCast;
-	case LogicalTypeId::LIST:
-		// the second argument allows for a secondary casting function to be passed in the CastParameters
-		return BoundCastInfo(
-		    &StringToNestedTypeCast<VectorStringToList>,
-		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target),
-		    ListBoundCastData::InitListLocalState);
-	case LogicalTypeId::ARRAY:
-		// the second argument allows for a secondary casting function to be passed in the CastParameters
-		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToArray>,
-		                     ArrayBoundCastData::BindArrayToArrayCast(
-		                         input, LogicalType::ARRAY(LogicalType::VARCHAR, optional_idx()), target),
-		                     ArrayBoundCastData::InitArrayLocalState);
-	case LogicalTypeId::STRUCT:
-		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
-		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target),
-		                     StructBoundCastData::InitStructCastLocalState);
-	case LogicalTypeId::MAP:
-		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToMap>,
-		                     MapBoundCastData::BindMapToMapCast(
-		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target),
-		                     InitMapCastLocalState);
-	case LogicalTypeId::VARINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, TryCastToVarInt>);
-	default:
-		return VectorStringCastNumericSwitch(input, source, target);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/struct_cast.cpp b/src/duckdb/src/function/cast/struct_cast.cpp
deleted file mode 100644
index 051581c54..000000000
--- a/src/duckdb/src/function/cast/struct_cast.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/cast/bound_cast_data.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastInput &input, const LogicalType &source,
-                                                                      const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	auto &source_children = StructType::GetChildTypes(source);
-	auto &target_children = StructType::GetChildTypes(target);
-
-	auto target_is_unnamed = StructType::IsUnnamed(target);
-	auto source_is_unnamed = StructType::IsUnnamed(source);
-
-	auto is_unnamed = target_is_unnamed || source_is_unnamed;
-	if (is_unnamed && source_children.size() != target_children.size()) {
-		throw TypeMismatchException(input.query_location, source, target, "Cannot cast STRUCTs of different size");
-	}
-
-	case_insensitive_map_t<idx_t> target_children_map;
-	if (!is_unnamed) {
-		for (idx_t i = 0; i < target_children.size(); i++) {
-			auto &name = target_children[i].first;
-			if (target_children_map.find(name) != target_children_map.end()) {
-				throw NotImplementedException("Error while casting - duplicate name \"%s\" in struct", name);
-			}
-			target_children_map[name] = i;
-		}
-	}
-
-	vector<idx_t> source_indexes;
-	vector<idx_t> target_indexes;
-	vector<idx_t> target_null_indexes;
-	bool has_any_match = is_unnamed;
-
-	for (idx_t i = 0; i < source_children.size(); i++) {
-		auto &source_child = source_children[i];
-		auto target_idx = i;
-
-		// Map to the correct index for names structs.
-		if (!is_unnamed) {
-			auto target_child = target_children_map.find(source_child.first);
-			if (target_child == target_children_map.end()) {
-				// Skip any children that have no target.
-				continue;
-			}
-			target_idx = target_child->second;
-			target_children_map.erase(target_child);
-			has_any_match = true;
-		}
-
-		source_indexes.push_back(i);
-		target_indexes.push_back(target_idx);
-		auto child_cast = input.GetCastFunction(source_child.second, target_children[target_idx].second);
-		child_cast_info.push_back(std::move(child_cast));
-	}
-
-	if (!has_any_match) {
-		throw BinderException("STRUCT to STRUCT cast must have at least one matching member");
-	}
-
-	// The remaining target children have no match in the source struct.
-	// Thus, they become NULL.
-	for (const auto &target_child : target_children_map) {
-		target_null_indexes.push_back(target_child.second);
-	}
-
-	return make_uniq<StructBoundCastData>(std::move(child_cast_info), target, std::move(source_indexes),
-	                                      std::move(target_indexes), std::move(target_null_indexes));
-}
-
-unique_ptr<FunctionLocalState> StructBoundCastData::InitStructCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
-	auto result = make_uniq<StructCastLocalState>();
-
-	for (auto &entry : cast_data.child_cast_info) {
-		unique_ptr<FunctionLocalState> child_state;
-		if (entry.init_local_state) {
-			CastLocalStateParameters child_params(parameters, entry.cast_data);
-			child_state = entry.init_local_state(child_params);
-		}
-		result->local_states.push_back(std::move(child_state));
-	}
-	return std::move(result);
-}
-
-static bool StructToStructCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
-	auto &l_state = parameters.local_state->Cast<StructCastLocalState>();
-
-	auto &source_vectors = StructVector::GetEntries(source);
-	auto &target_children = StructVector::GetEntries(result);
-
-	bool all_converted = true;
-	for (idx_t i = 0; i < cast_data.source_indexes.size(); i++) {
-		auto source_idx = cast_data.source_indexes[i];
-		auto target_idx = cast_data.target_indexes[i];
-
-		auto &source_vector = *source_vectors[source_idx];
-		auto &target_vector = *target_children[target_idx];
-
-		auto &child_cast_info = cast_data.child_cast_info[i];
-		CastParameters child_parameters(parameters, child_cast_info.cast_data, l_state.local_states[i]);
-		auto success = child_cast_info.function(source_vector, target_vector, count, child_parameters);
-		if (!success) {
-			all_converted = false;
-		}
-	}
-
-	if (!cast_data.target_null_indexes.empty()) {
-		for (idx_t i = 0; i < cast_data.target_null_indexes.size(); i++) {
-			auto target_idx = cast_data.target_null_indexes[i];
-			auto &target_vector = *target_children[target_idx];
-
-			target_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(target_vector, true);
-		}
-	}
-
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, ConstantVector::IsNull(source));
-		return all_converted;
-	}
-
-	source.Flatten(count);
-	auto &result_validity = FlatVector::Validity(result);
-	result_validity = FlatVector::Validity(source);
-	result.Verify(count);
-	return all_converted;
-}
-
-static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	// first cast all child elements to varchar
-	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
-	Vector varchar_struct(cast_data.target, count);
-	StructToStructCast(source, varchar_struct, count, parameters);
-
-	// now construct the actual varchar vector
-	varchar_struct.Flatten(count);
-	bool is_unnamed = StructType::IsUnnamed(source.GetType());
-	auto &child_types = StructType::GetChildTypes(source.GetType());
-	auto &children = StructVector::GetEntries(varchar_struct);
-	auto &validity = FlatVector::Validity(varchar_struct);
-	auto result_data = FlatVector::GetData<string_t>(result);
-	static constexpr const idx_t SEP_LENGTH = 2;
-	static constexpr const idx_t NAME_SEP_LENGTH = 4;
-	static constexpr const idx_t NULL_LENGTH = 4;
-	for (idx_t i = 0; i < count; i++) {
-		if (!validity.RowIsValid(i)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-		idx_t string_length = 2; // {}
-		for (idx_t c = 0; c < children.size(); c++) {
-			if (c > 0) {
-				string_length += SEP_LENGTH;
-			}
-			children[c]->Flatten(count);
-			auto &child_validity = FlatVector::Validity(*children[c]);
-			auto data = FlatVector::GetData<string_t>(*children[c]);
-			auto &name = child_types[c].first;
-			if (!is_unnamed) {
-				string_length += name.size() + NAME_SEP_LENGTH; // "'{name}': "
-			}
-			string_length += child_validity.RowIsValid(i) ? data[i].GetSize() : NULL_LENGTH;
-		}
-		result_data[i] = StringVector::EmptyString(result, string_length);
-		auto dataptr = result_data[i].GetDataWriteable();
-		idx_t offset = 0;
-		dataptr[offset++] = is_unnamed ? '(' : '{';
-		for (idx_t c = 0; c < children.size(); c++) {
-			if (c > 0) {
-				memcpy(dataptr + offset, ", ", SEP_LENGTH);
-				offset += SEP_LENGTH;
-			}
-			auto &child_validity = FlatVector::Validity(*children[c]);
-			auto data = FlatVector::GetData<string_t>(*children[c]);
-			if (!is_unnamed) {
-				auto &name = child_types[c].first;
-				// "'{name}': "
-				dataptr[offset++] = '\'';
-				memcpy(dataptr + offset, name.c_str(), name.size());
-				offset += name.size();
-				dataptr[offset++] = '\'';
-				dataptr[offset++] = ':';
-				dataptr[offset++] = ' ';
-			}
-			// value
-			if (child_validity.RowIsValid(i)) {
-				auto len = data[i].GetSize();
-				memcpy(dataptr + offset, data[i].GetData(), len);
-				offset += len;
-			} else {
-				memcpy(dataptr + offset, "NULL", NULL_LENGTH);
-				offset += NULL_LENGTH;
-			}
-		}
-		dataptr[offset++] = is_unnamed ? ')' : '}';
-		result_data[i].Finalize();
-	}
-
-	if (constant) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	return true;
-}
-
-BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const LogicalType &source,
-                                             const LogicalType &target) {
-	switch (target.id()) {
-	case LogicalTypeId::STRUCT:
-		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target),
-		                     StructBoundCastData::InitStructCastLocalState);
-	case LogicalTypeId::VARCHAR: {
-		// bind a cast in which we convert all child entries to VARCHAR entries
-		auto &struct_children = StructType::GetChildTypes(source);
-		child_list_t<LogicalType> varchar_children;
-		for (auto &child_entry : struct_children) {
-			varchar_children.push_back(make_pair(child_entry.first, LogicalType::VARCHAR));
-		}
-		auto varchar_type = LogicalType::STRUCT(varchar_children);
-		return BoundCastInfo(StructToVarcharCast,
-		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type),
-		                     StructBoundCastData::InitStructCastLocalState);
-	}
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/time_casts.cpp b/src/duckdb/src/function/cast/time_casts.cpp
deleted file mode 100644
index b9587ad1c..000000000
--- a/src/duckdb/src/function/cast/time_casts.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-namespace duckdb {
-
-BoundCastInfo DefaultCasts::DateCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// date to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<date_t, duckdb::StringCast>);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// date to timestamp
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_t, duckdb::TryCast>);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_ns_t, duckdb::TryCastToTimestampNS>);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampSec>);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampMS>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimeCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// time to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCast>);
-	case LogicalTypeId::TIME_TZ:
-		// time to time with time zone
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_t, dtime_tz_t, duckdb::Cast>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimeTzCastSwitch(BindCastInput &input, const LogicalType &source,
-                                             const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// time with time zone to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_tz_t, duckdb::StringCastTZ>);
-	case LogicalTypeId::TIME:
-		// time with time zone to time
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_tz_t, dtime_t, duckdb::Cast>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const LogicalType &source,
-                                                const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// timestamp to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCast>);
-	case LogicalTypeId::DATE:
-		// timestamp to date
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::Cast>);
-	case LogicalTypeId::TIME:
-		// timestamp to time
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
-	case LogicalTypeId::TIME_TZ:
-		// timestamp to time_tz
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// timestamp (us) to timestamp with time zone
-		return ReinterpretCast;
-	case LogicalTypeId::TIMESTAMP_NS:
-		// timestamp (us) to timestamp (ns)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampUsToNs>);
-	case LogicalTypeId::TIMESTAMP_MS:
-		// timestamp (us) to timestamp (ms)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampUsToMs>);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		// timestamp (us) to timestamp (s)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampUsToSec>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const LogicalType &source,
-                                                  const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// timestamp with time zone to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCastTZ>);
-	case LogicalTypeId::TIME_TZ:
-		// timestamp with time zone to time with time zone.
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp with time zone to timestamp (us)
-		return ReinterpretCast;
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimestampNsCastSwitch(BindCastInput &input, const LogicalType &source,
-                                                  const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// timestamp (ns) to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_ns_t, duckdb::StringCast>);
-	case LogicalTypeId::DATE:
-		// timestamp (ns) to date
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampNsToDate>);
-	case LogicalTypeId::TIME:
-		// timestamp (ns) to time
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampNsToTime>);
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp (ns) to timestamp (us)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampNsToUs>);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// timestamp (ns) to timestamp with time zone (us)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampNsToUs>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const LogicalType &source,
-                                                  const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// timestamp (ms) to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampMS>);
-	case LogicalTypeId::DATE:
-		// timestamp (ms) to date
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampMsToDate>);
-	case LogicalTypeId::TIME:
-		// timestamp (ms) to time
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampMsToTime>);
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp (ms) to timestamp (us)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToUs>);
-	case LogicalTypeId::TIMESTAMP_NS:
-		// timestamp (ms) to timestamp (ns)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToNs>);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// timestamp (ms) to timestamp with timezone (us)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToUs>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const LogicalType &source,
-                                                   const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// timestamp (s) to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampSec>);
-	case LogicalTypeId::DATE:
-		// timestamp (s) to date
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampSecToDate>);
-	case LogicalTypeId::TIME:
-		// timestamp (s) to time
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampSecToTime>);
-	case LogicalTypeId::TIMESTAMP_MS:
-		// timestamp (s) to timestamp (ms)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToMs>);
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp (s) to timestamp (us)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToUs>);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// timestamp (s) to timestamp with timezone (us)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToUs>);
-	case LogicalTypeId::TIMESTAMP_NS:
-		// timestamp (s) to timestamp (ns)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToNs>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-BoundCastInfo DefaultCasts::IntervalCastSwitch(BindCastInput &input, const LogicalType &source,
-                                               const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// time to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<interval_t, duckdb::StringCast>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/union/from_struct.cpp b/src/duckdb/src/function/cast/union/from_struct.cpp
deleted file mode 100644
index c6fcd2a03..000000000
--- a/src/duckdb/src/function/cast/union/from_struct.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#include "duckdb/function/cast/bound_cast_data.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-
-namespace duckdb {
-
-bool StructToUnionCast::AllowImplicitCastFromStruct(const LogicalType &source, const LogicalType &target) {
-	if (source.id() != LogicalTypeId::STRUCT) {
-		return false;
-	}
-	auto target_fields = StructType::GetChildTypes(target);
-	auto fields = StructType::GetChildTypes(source);
-	if (target_fields.size() != fields.size()) {
-		// Struct should have the same amount of fields as the union
-		return false;
-	}
-	for (idx_t i = 0; i < target_fields.size(); i++) {
-		auto &target_field = target_fields[i].second;
-		auto &target_field_name = target_fields[i].first;
-		auto &field = fields[i].second;
-		auto &field_name = fields[i].first;
-		if (i == 0) {
-			// For the tag field we don't accept a type substitute as varchar
-			if (target_field != field) {
-				return false;
-			}
-			continue;
-		}
-		if (!StringUtil::CIEquals(target_field_name, field_name)) {
-			return false;
-		}
-		if (target_field != field && field != LogicalType::VARCHAR) {
-			// We allow the field to be VARCHAR, since unsupported types get cast to VARCHAR by EXPORT DATABASE (format
-			// PARQUET) i.e UNION(a BIT) becomes STRUCT(a VARCHAR)
-			return false;
-		}
-	}
-	return true;
-}
-
-// Physical Cast execution
-
-bool StructToUnionCast::Cast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
-	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
-
-	D_ASSERT(source.GetType().id() == LogicalTypeId::STRUCT);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::UNION);
-	D_ASSERT(cast_data.target.id() == LogicalTypeId::UNION);
-
-	auto &source_children = StructVector::GetEntries(source);
-	auto &target_children = StructVector::GetEntries(result);
-
-	for (idx_t i = 0; i < source_children.size(); i++) {
-		auto &result_child_vector = *target_children[i];
-		auto &source_child_vector = *source_children[i];
-		CastParameters child_parameters(parameters, cast_data.child_cast_info[i].cast_data, lstate.local_states[i]);
-		auto converted =
-		    cast_data.child_cast_info[i].function(source_child_vector, result_child_vector, count, child_parameters);
-		(void)converted;
-		D_ASSERT(converted);
-		// we flatten the child because we use FlatVector::SetNull below and we may get non-flat from source/cast
-		result_child_vector.Flatten(count);
-	}
-
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, ConstantVector::IsNull(source));
-
-		// if the tag is NULL, the union should be NULL
-		auto &tag_vec = *target_children[0];
-		ConstantVector::SetNull(result, ConstantVector::IsNull(tag_vec));
-	} else {
-		// if the tag is NULL, the union should be NULL
-		auto &tag_vec = *target_children[0];
-		UnifiedVectorFormat source_data, tag_data;
-		source.ToUnifiedFormat(count, source_data);
-		tag_vec.ToUnifiedFormat(count, tag_data);
-
-		for (idx_t i = 0; i < count; i++) {
-			if (!source_data.validity.RowIsValid(source_data.sel->get_index(i)) ||
-			    !tag_data.validity.RowIsValid(tag_data.sel->get_index(i))) {
-				FlatVector::SetNull(result, i, true);
-			}
-		}
-	}
-
-	auto check_tags = UnionVector::CheckUnionValidity(result, count);
-	switch (check_tags) {
-	case UnionInvalidReason::TAG_OUT_OF_RANGE:
-		throw ConversionException("One or more of the tags do not point to a valid union member");
-	case UnionInvalidReason::VALIDITY_OVERLAP:
-		throw ConversionException("One or more rows in the produced UNION have validity set for more than 1 member");
-	case UnionInvalidReason::TAG_MISMATCH:
-		throw ConversionException(
-		    "One or more rows in the produced UNION have tags that don't point to the valid member");
-	case UnionInvalidReason::NULL_TAG:
-		throw ConversionException("One or more rows in the produced UNION have a NULL tag");
-	case UnionInvalidReason::VALID:
-		break;
-	default:
-		throw InternalException("Struct to union cast failed for unknown reason");
-	}
-
-	result.Verify(count);
-	return true;
-}
-
-// Bind cast
-
-unique_ptr<BoundCastData> StructToUnionCast::BindData(BindCastInput &input, const LogicalType &source,
-                                                      const LogicalType &target) {
-	vector<BoundCastInfo> child_cast_info;
-	D_ASSERT(source.id() == LogicalTypeId::STRUCT);
-	D_ASSERT(target.id() == LogicalTypeId::UNION);
-
-	auto result_child_count = StructType::GetChildCount(target);
-	D_ASSERT(result_child_count == StructType::GetChildCount(source));
-
-	for (idx_t i = 0; i < result_child_count; i++) {
-		auto &source_child = StructType::GetChildType(source, i);
-		auto &target_child = StructType::GetChildType(target, i);
-
-		auto child_cast = input.GetCastFunction(source_child, target_child);
-		child_cast_info.push_back(std::move(child_cast));
-	}
-	return make_uniq<StructBoundCastData>(std::move(child_cast_info), target);
-}
-
-BoundCastInfo StructToUnionCast::Bind(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	auto cast_data = StructToUnionCast::BindData(input, source, target);
-	return BoundCastInfo(&StructToUnionCast::Cast, std::move(cast_data), StructBoundCastData::InitStructCastLocalState);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/union_casts.cpp b/src/duckdb/src/function/cast/union_casts.cpp
deleted file mode 100644
index 72b171745..000000000
--- a/src/duckdb/src/function/cast/union_casts.cpp
+++ /dev/null
@@ -1,365 +0,0 @@
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/bound_cast_data.hpp"
-
-#include <algorithm> // for std::sort
-
-namespace duckdb {
-
-//--------------------------------------------------------------------------------------------------
-// ??? -> UNION
-//--------------------------------------------------------------------------------------------------
-// if the source can be implicitly cast to a member of the target union, the cast is valid
-
-unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	D_ASSERT(target.id() == LogicalTypeId::UNION);
-
-	vector<UnionBoundCastData> candidates;
-
-	for (idx_t member_idx = 0; member_idx < UnionType::GetMemberCount(target); member_idx++) {
-		auto member_type = UnionType::GetMemberType(target, member_idx);
-		auto member_name = UnionType::GetMemberName(target, member_idx);
-		auto member_cast_cost = input.function_set.ImplicitCastCost(source, member_type);
-		if (member_cast_cost != -1) {
-			auto member_cast_info = input.GetCastFunction(source, member_type);
-			candidates.emplace_back(member_idx, member_name, member_type, member_cast_cost,
-			                        std::move(member_cast_info));
-		}
-	};
-
-	// no possible casts found!
-	if (candidates.empty()) {
-		auto message = StringUtil::Format(
-		    "Type %s can't be cast as %s. %s can't be implicitly cast to any of the union member types: ",
-		    source.ToString(), target.ToString(), source.ToString());
-
-		auto member_count = UnionType::GetMemberCount(target);
-		for (idx_t member_idx = 0; member_idx < member_count; member_idx++) {
-			auto member_type = UnionType::GetMemberType(target, member_idx);
-			message += member_type.ToString();
-			if (member_idx < member_count - 1) {
-				message += ", ";
-			}
-		}
-		throw ConversionException(message);
-	}
-
-	// sort the candidate casts by cost
-	std::sort(candidates.begin(), candidates.end(), UnionBoundCastData::SortByCostAscending);
-
-	// select the lowest possible cost cast
-	auto &selected_cast = candidates[0];
-	auto selected_cost = candidates[0].cost;
-
-	// check if the cast is ambiguous (2 or more casts have the same cost)
-	if (candidates.size() > 1 && candidates[1].cost == selected_cost) {
-
-		// collect all the ambiguous types
-		auto message = StringUtil::Format(
-		    "Type %s can't be cast as %s. The cast is ambiguous, multiple possible members in target: ", source,
-		    target);
-		for (size_t i = 0; i < candidates.size(); i++) {
-			if (candidates[i].cost == selected_cost) {
-				message += StringUtil::Format("'%s (%s)'", candidates[i].name, candidates[i].type.ToString());
-				if (i < candidates.size() - 1) {
-					message += ", ";
-				}
-			}
-		}
-		message += ". Disambiguate the target type by using the 'union_value(<tag> := <arg>)' function to promote the "
-		           "source value to a single member union before casting.";
-		throw ConversionException(message);
-	}
-
-	// otherwise, return the selected cast
-	return make_uniq<UnionBoundCastData>(std::move(selected_cast));
-}
-
-unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<UnionBoundCastData>();
-	if (!cast_data.member_cast_info.init_local_state) {
-		return nullptr;
-	}
-	CastLocalStateParameters child_parameters(parameters, cast_data.member_cast_info.cast_data);
-	return cast_data.member_cast_info.init_local_state(child_parameters);
-}
-
-static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::UNION);
-	auto &cast_data = parameters.cast_data->Cast<UnionBoundCastData>();
-	auto &selected_member_vector = UnionVector::GetMember(result, cast_data.tag);
-
-	CastParameters child_parameters(parameters, cast_data.member_cast_info.cast_data, parameters.local_state);
-	if (!cast_data.member_cast_info.function(source, selected_member_vector, count, child_parameters)) {
-		return false;
-	}
-
-	// cast succeeded, create union vector
-	UnionVector::SetToMember(result, cast_data.tag, selected_member_vector, count, true);
-
-	result.Verify(count);
-
-	return true;
-}
-
-BoundCastInfo DefaultCasts::ImplicitToUnionCast(BindCastInput &input, const LogicalType &source,
-                                                const LogicalType &target) {
-
-	D_ASSERT(target.id() == LogicalTypeId::UNION);
-	if (StructToUnionCast::AllowImplicitCastFromStruct(source, target)) {
-		return StructToUnionCast::Bind(input, source, target);
-	}
-	auto cast_data = BindToUnionCast(input, source, target);
-	return BoundCastInfo(&ToUnionCast, std::move(cast_data), InitToUnionLocalState);
-}
-
-//--------------------------------------------------------------------------------------------------
-// UNION -> UNION
-//--------------------------------------------------------------------------------------------------
-// if the source member tags is a subset of the target member tags, and all the source members can be
-// implicitly cast to the corresponding target members, the cast is valid.
-//
-// VALID: 	UNION(A, B) 	-> 	UNION(A, B, C)
-// VALID: 	UNION(A, B) 	-> 	UNION(A, C)		if B can be implicitly cast to C
-//
-// INVALID: UNION(A, B, C)	->	UNION(A, B)
-// INVALID:	UNION(A, B) 	->	UNION(A, C)		if B can't be implicitly cast to C
-// INVALID:	UNION(A, B, D) 	->	UNION(A, B, C)
-
-struct UnionUnionBoundCastData : public BoundCastData {
-
-	// mapping from source member index to target member index
-	// these are always the same size as the source member count
-	// (since all source members must be present in the target)
-	vector<idx_t> tag_map;
-	vector<BoundCastInfo> member_casts;
-
-	LogicalType target_type;
-
-	UnionUnionBoundCastData(vector<idx_t> tag_map, vector<BoundCastInfo> member_casts, LogicalType target_type)
-	    : tag_map(std::move(tag_map)), member_casts(std::move(member_casts)), target_type(std::move(target_type)) {
-	}
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		vector<BoundCastInfo> member_casts_copy;
-		for (auto &member_cast : member_casts) {
-			member_casts_copy.push_back(member_cast.Copy());
-		}
-		return make_uniq<UnionUnionBoundCastData>(tag_map, std::move(member_casts_copy), target_type);
-	}
-};
-
-unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const LogicalType &source,
-                                               const LogicalType &target) {
-	D_ASSERT(source.id() == LogicalTypeId::UNION);
-	D_ASSERT(target.id() == LogicalTypeId::UNION);
-
-	auto source_member_count = UnionType::GetMemberCount(source);
-
-	auto tag_map = vector<idx_t>(source_member_count);
-	auto member_casts = vector<BoundCastInfo>();
-
-	for (idx_t source_idx = 0; source_idx < source_member_count; source_idx++) {
-		auto &source_member_type = UnionType::GetMemberType(source, source_idx);
-		auto &source_member_name = UnionType::GetMemberName(source, source_idx);
-
-		bool found = false;
-		for (idx_t target_idx = 0; target_idx < UnionType::GetMemberCount(target); target_idx++) {
-			auto &target_member_name = UnionType::GetMemberName(target, target_idx);
-
-			// found a matching member
-			if (StringUtil::CIEquals(source_member_name, target_member_name)) {
-				auto &target_member_type = UnionType::GetMemberType(target, target_idx);
-				tag_map[source_idx] = target_idx;
-				member_casts.push_back(input.GetCastFunction(source_member_type, target_member_type));
-				found = true;
-				break;
-			}
-		}
-		if (!found) {
-			// no matching member tag found in the target set
-			auto message =
-			    StringUtil::Format("Type %s can't be cast as %s. The member '%s' is not present in target union",
-			                       source.ToString(), target.ToString(), source_member_name);
-			throw ConversionException(message);
-		}
-	}
-
-	return make_uniq<UnionUnionBoundCastData>(tag_map, std::move(member_casts), target);
-}
-
-unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
-	auto result = make_uniq<StructCastLocalState>();
-
-	for (auto &entry : cast_data.member_casts) {
-		unique_ptr<FunctionLocalState> child_state;
-		if (entry.init_local_state) {
-			CastLocalStateParameters child_params(parameters, entry.cast_data);
-			child_state = entry.init_local_state(child_params);
-		}
-		result->local_states.push_back(std::move(child_state));
-	}
-	return std::move(result);
-}
-
-static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
-	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
-
-	auto source_member_count = UnionType::GetMemberCount(source.GetType());
-	auto target_member_count = UnionType::GetMemberCount(result.GetType());
-
-	auto target_member_is_mapped = vector<bool>(target_member_count);
-
-	// Perform the casts from source to target members
-	for (idx_t member_idx = 0; member_idx < source_member_count; member_idx++) {
-		auto target_member_idx = cast_data.tag_map[member_idx];
-
-		auto &source_member_vector = UnionVector::GetMember(source, member_idx);
-		auto &target_member_vector = UnionVector::GetMember(result, target_member_idx);
-		auto &member_cast = cast_data.member_casts[member_idx];
-
-		CastParameters child_parameters(parameters, member_cast.cast_data, lstate.local_states[member_idx]);
-		if (!member_cast.function(source_member_vector, target_member_vector, count, child_parameters)) {
-			return false;
-		}
-
-		target_member_is_mapped[target_member_idx] = true;
-	}
-
-	// All member casts succeeded!
-
-	// Set the unmapped target members to constant NULL.
-	// If we cast UNION(A, B) -> UNION(A, B, C) we need to invalidate C so that
-	// the invariants of the result union hold. (only member columns "selected"
-	// by the rowwise corresponding tag in the tag vector should be valid)
-	for (idx_t target_member_idx = 0; target_member_idx < target_member_count; target_member_idx++) {
-		if (!target_member_is_mapped[target_member_idx]) {
-			auto &target_member_vector = UnionVector::GetMember(result, target_member_idx);
-			target_member_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(target_member_vector, true);
-		}
-	}
-
-	// Update the tags in the result vector
-	auto &source_tag_vector = UnionVector::GetTags(source);
-	auto &result_tag_vector = UnionVector::GetTags(result);
-
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Constant vector case optimization
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		if (ConstantVector::IsNull(source)) {
-			ConstantVector::SetNull(result, true);
-		} else {
-			// map the tag
-			auto source_tag = ConstantVector::GetData<union_tag_t>(source_tag_vector)[0];
-			auto mapped_tag = cast_data.tag_map[source_tag];
-			ConstantVector::GetData<union_tag_t>(result_tag_vector)[0] = UnsafeNumericCast<union_tag_t>(mapped_tag);
-		}
-	} else {
-		// Otherwise, use the unified vector format to access the source vector.
-
-		// Ensure that all the result members are flat vectors
-		// This is not always the case, e.g. when a member is cast using the default TryNullCast function
-		// the resulting member vector will be a constant null vector.
-		for (idx_t target_member_idx = 0; target_member_idx < target_member_count; target_member_idx++) {
-			UnionVector::GetMember(result, target_member_idx).Flatten(count);
-		}
-
-		// We assume that a union tag vector validity matches the union vector validity.
-		UnifiedVectorFormat source_tag_format;
-		source_tag_vector.ToUnifiedFormat(count, source_tag_format);
-
-		for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-			auto source_row_idx = source_tag_format.sel->get_index(row_idx);
-			if (source_tag_format.validity.RowIsValid(source_row_idx)) {
-				// map the tag
-				auto source_tag = (UnifiedVectorFormat::GetData<union_tag_t>(source_tag_format))[source_row_idx];
-				auto target_tag = cast_data.tag_map[source_tag];
-				FlatVector::GetData<union_tag_t>(result_tag_vector)[row_idx] =
-				    UnsafeNumericCast<union_tag_t>(target_tag);
-			} else {
-
-				// Issue: The members of the result is not always flatvectors
-				// In the case of TryNullCast, the result member is constant.
-				FlatVector::SetNull(result, row_idx, true);
-			}
-		}
-	}
-
-	result.Verify(count);
-
-	return true;
-}
-
-static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	// first cast all union members to varchar
-	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
-	Vector varchar_union(cast_data.target_type, count);
-
-	UnionToUnionCast(source, varchar_union, count, parameters);
-
-	// now construct the actual varchar vector
-	// varchar_union.Flatten(count);
-	auto &tag_vector = UnionVector::GetTags(varchar_union);
-	UnifiedVectorFormat tag_format;
-	tag_vector.ToUnifiedFormat(count, tag_format);
-
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto tag_idx = tag_format.sel->get_index(i);
-		if (!tag_format.validity.RowIsValid(tag_idx)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-
-		auto tag = UnifiedVectorFormat::GetData<union_tag_t>(tag_format)[tag_idx];
-		auto &member = UnionVector::GetMember(varchar_union, tag);
-		UnifiedVectorFormat member_vdata;
-		member.ToUnifiedFormat(count, member_vdata);
-		auto mapped_idx = member_vdata.sel->get_index(i);
-		auto member_valid = member_vdata.validity.RowIsValid(mapped_idx);
-		if (member_valid) {
-			auto member_str = (UnifiedVectorFormat::GetData<string_t>(member_vdata))[mapped_idx];
-			result_data[i] = StringVector::AddString(result, member_str);
-		} else {
-			result_data[i] = StringVector::AddString(result, "NULL");
-		}
-	}
-
-	if (constant) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(count);
-	return true;
-}
-
-BoundCastInfo DefaultCasts::UnionCastSwitch(BindCastInput &input, const LogicalType &source,
-                                            const LogicalType &target) {
-	D_ASSERT(source.id() == LogicalTypeId::UNION);
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR: {
-		// bind a cast in which we convert all members to VARCHAR first
-		child_list_t<LogicalType> varchar_members;
-		for (idx_t member_idx = 0; member_idx < UnionType::GetMemberCount(source); member_idx++) {
-			varchar_members.push_back(make_pair(UnionType::GetMemberName(source, member_idx), LogicalType::VARCHAR));
-		}
-		auto varchar_type = LogicalType::UNION(std::move(varchar_members));
-		return BoundCastInfo(UnionToVarcharCast, BindUnionToUnionCast(input, source, varchar_type),
-		                     InitUnionToUnionLocalState);
-	}
-	case LogicalTypeId::UNION:
-		return BoundCastInfo(UnionToUnionCast, BindUnionToUnionCast(input, source, target), InitUnionToUnionLocalState);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/uuid_casts.cpp b/src/duckdb/src/function/cast/uuid_casts.cpp
deleted file mode 100644
index c2267b51e..000000000
--- a/src/duckdb/src/function/cast/uuid_casts.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-namespace duckdb {
-
-BoundCastInfo DefaultCasts::UUIDCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// uuid to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<hugeint_t, duckdb::CastFromUUID>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/varint_casts.cpp b/src/duckdb/src/function/cast/varint_casts.cpp
deleted file mode 100644
index 0f4346883..000000000
--- a/src/duckdb/src/function/cast/varint_casts.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-#include "duckdb/common/types/varint.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-template <class T>
-string_t IntToVarInt(Vector &result, T int_value) {
-	// Determine if the number is negative
-	bool is_negative = int_value < 0;
-	// Determine the number of data bytes
-	uint64_t abs_value;
-	if (is_negative) {
-		if (int_value == std::numeric_limits<T>::min()) {
-			abs_value = static_cast<uint64_t>(std::numeric_limits<T>::max()) + 1;
-		} else {
-			abs_value = static_cast<uint64_t>(std::abs(static_cast<int64_t>(int_value)));
-		}
-	} else {
-		abs_value = static_cast<uint64_t>(int_value);
-	}
-	uint32_t data_byte_size;
-	if (abs_value != NumericLimits<uint64_t>::Maximum()) {
-		data_byte_size = (abs_value == 0) ? 1 : static_cast<uint32_t>(std::ceil(std::log2(abs_value + 1) / 8.0));
-	} else {
-		data_byte_size = static_cast<uint32_t>(std::ceil(std::log2(abs_value) / 8.0));
-	}
-
-	uint32_t blob_size = data_byte_size + Varint::VARINT_HEADER_SIZE;
-	auto blob = StringVector::EmptyString(result, blob_size);
-	auto writable_blob = blob.GetDataWriteable();
-	Varint::SetHeader(writable_blob, data_byte_size, is_negative);
-
-	// Add data bytes to the blob, starting off after header bytes
-	idx_t wb_idx = Varint::VARINT_HEADER_SIZE;
-	for (int i = static_cast<int>(data_byte_size) - 1; i >= 0; --i) {
-		if (is_negative) {
-			writable_blob[wb_idx++] = static_cast<char>(~(abs_value >> i * 8 & 0xFF));
-		} else {
-			writable_blob[wb_idx++] = static_cast<char>(abs_value >> i * 8 & 0xFF);
-		}
-	}
-	blob.Finalize();
-	return blob;
-}
-
-template <>
-string_t HugeintCastToVarInt::Operation(uhugeint_t int_value, Vector &result) {
-	uint32_t data_byte_size;
-	if (int_value.upper != NumericLimits<uint64_t>::Maximum()) {
-		data_byte_size =
-		    (int_value.upper == 0) ? 0 : static_cast<uint32_t>(std::ceil(std::log2(int_value.upper + 1) / 8.0));
-	} else {
-		data_byte_size = static_cast<uint32_t>(std::ceil(std::log2(int_value.upper) / 8.0));
-	}
-
-	uint32_t upper_byte_size = data_byte_size;
-	if (data_byte_size > 0) {
-		// If we have at least one byte on the upper side, the bottom side is complete
-		data_byte_size += 8;
-	} else {
-		if (int_value.lower != NumericLimits<uint64_t>::Maximum()) {
-			data_byte_size += static_cast<uint32_t>(std::ceil(std::log2(int_value.lower + 1) / 8.0));
-		} else {
-			data_byte_size += static_cast<uint32_t>(std::ceil(std::log2(int_value.lower) / 8.0));
-		}
-	}
-	if (data_byte_size == 0) {
-		data_byte_size++;
-	}
-	uint32_t blob_size = data_byte_size + Varint::VARINT_HEADER_SIZE;
-	auto blob = StringVector::EmptyString(result, blob_size);
-	auto writable_blob = blob.GetDataWriteable();
-	Varint::SetHeader(writable_blob, data_byte_size, false);
-
-	// Add data bytes to the blob, starting off after header bytes
-	idx_t wb_idx = Varint::VARINT_HEADER_SIZE;
-	for (int i = static_cast<int>(upper_byte_size) - 1; i >= 0; --i) {
-		writable_blob[wb_idx++] = static_cast<char>(int_value.upper >> i * 8 & 0xFF);
-	}
-	for (int i = static_cast<int>(data_byte_size - upper_byte_size) - 1; i >= 0; --i) {
-		writable_blob[wb_idx++] = static_cast<char>(int_value.lower >> i * 8 & 0xFF);
-	}
-	blob.Finalize();
-	return blob;
-}
-
-template <>
-string_t HugeintCastToVarInt::Operation(hugeint_t int_value, Vector &result) {
-	// Determine if the number is negative
-	bool is_negative = int_value.upper >> 63 & 1;
-	if (is_negative) {
-		// We must check if it's -170141183460469231731687303715884105728, since it's not possible to negate it
-		// without overflowing
-		if (int_value == NumericLimits<hugeint_t>::Minimum()) {
-			uhugeint_t u_int_value {0x8000000000000000, 0};
-			auto cast_value = Operation<uhugeint_t>(u_int_value, result);
-			// We have to do all the bit flipping.
-			auto writable_value_ptr = cast_value.GetDataWriteable();
-			Varint::SetHeader(writable_value_ptr, cast_value.GetSize() - Varint::VARINT_HEADER_SIZE, is_negative);
-			for (idx_t i = Varint::VARINT_HEADER_SIZE; i < cast_value.GetSize(); i++) {
-				writable_value_ptr[i] = static_cast<char>(~writable_value_ptr[i]);
-			}
-			cast_value.Finalize();
-			return cast_value;
-		}
-		int_value = -int_value;
-	}
-	// Determine the number of data bytes
-	uint64_t abs_value_upper = static_cast<uint64_t>(int_value.upper);
-
-	uint32_t data_byte_size;
-	if (abs_value_upper != NumericLimits<uint64_t>::Maximum()) {
-		data_byte_size =
-		    (abs_value_upper == 0) ? 0 : static_cast<uint32_t>(std::ceil(std::log2(abs_value_upper + 1) / 8.0));
-	} else {
-		data_byte_size = static_cast<uint32_t>(std::ceil(std::log2(abs_value_upper) / 8.0));
-	}
-
-	uint32_t upper_byte_size = data_byte_size;
-	if (data_byte_size > 0) {
-		// If we have at least one byte on the upper side, the bottom side is complete
-		data_byte_size += 8;
-	} else {
-		if (int_value.lower != NumericLimits<uint64_t>::Maximum()) {
-			data_byte_size += static_cast<uint32_t>(std::ceil(std::log2(int_value.lower + 1) / 8.0));
-		} else {
-			data_byte_size += static_cast<uint32_t>(std::ceil(std::log2(int_value.lower) / 8.0));
-		}
-	}
-
-	if (data_byte_size == 0) {
-		data_byte_size++;
-	}
-	uint32_t blob_size = data_byte_size + Varint::VARINT_HEADER_SIZE;
-	auto blob = StringVector::EmptyString(result, blob_size);
-	auto writable_blob = blob.GetDataWriteable();
-	Varint::SetHeader(writable_blob, data_byte_size, is_negative);
-
-	// Add data bytes to the blob, starting off after header bytes
-	idx_t wb_idx = Varint::VARINT_HEADER_SIZE;
-	for (int i = static_cast<int>(upper_byte_size) - 1; i >= 0; --i) {
-		if (is_negative) {
-			writable_blob[wb_idx++] = static_cast<char>(~(abs_value_upper >> i * 8 & 0xFF));
-		} else {
-			writable_blob[wb_idx++] = static_cast<char>(abs_value_upper >> i * 8 & 0xFF);
-		}
-	}
-	for (int i = static_cast<int>(data_byte_size - upper_byte_size) - 1; i >= 0; --i) {
-		if (is_negative) {
-			writable_blob[wb_idx++] = static_cast<char>(~(int_value.lower >> i * 8 & 0xFF));
-		} else {
-			writable_blob[wb_idx++] = static_cast<char>(int_value.lower >> i * 8 & 0xFF);
-		}
-	}
-	blob.Finalize();
-	return blob;
-}
-
-// Varchar to Varint
-// TODO: This is a slow quadratic algorithm, we can still optimize it further.
-template <>
-bool TryCastToVarInt::Operation(string_t input_value, string_t &result_value, Vector &result,
-                                CastParameters &parameters) {
-	auto blob_string = Varint::VarcharToVarInt(input_value);
-
-	uint32_t blob_size = static_cast<uint32_t>(blob_string.size());
-	result_value = StringVector::EmptyString(result, blob_size);
-	auto writable_blob = result_value.GetDataWriteable();
-
-	// Write string_blob into blob
-	for (idx_t i = 0; i < blob_string.size(); i++) {
-		writable_blob[i] = blob_string[i];
-	}
-	result_value.Finalize();
-	return true;
-}
-
-template <class T>
-bool DoubleToVarInt(T double_value, string_t &result_value, Vector &result) {
-	// Check if we can cast it
-	if (!std::isfinite(double_value)) {
-		// We can't cast inf -inf nan
-		return false;
-	}
-	// Determine if the number is negative
-	bool is_negative = double_value < 0;
-	// Determine the number of data bytes
-	double abs_value = std::abs(double_value);
-
-	if (abs_value == 0) {
-		// Return Value 0
-		result_value = Varint::InitializeVarintZero(result);
-		return true;
-	}
-	vector<char> value;
-	while (abs_value > 0) {
-		double quotient = abs_value / 256;
-		double truncated = floor(quotient);
-		uint8_t byte = static_cast<uint8_t>(abs_value - truncated * 256);
-		abs_value = truncated;
-		if (is_negative) {
-			value.push_back(static_cast<char>(~byte));
-		} else {
-			value.push_back(static_cast<char>(byte));
-		}
-	}
-	uint32_t data_byte_size = static_cast<uint32_t>(value.size());
-	uint32_t blob_size = data_byte_size + Varint::VARINT_HEADER_SIZE;
-	result_value = StringVector::EmptyString(result, blob_size);
-	auto writable_blob = result_value.GetDataWriteable();
-	Varint::SetHeader(writable_blob, data_byte_size, is_negative);
-	// Add data bytes to the blob, starting off after header bytes
-	idx_t blob_string_idx = value.size() - 1;
-	for (idx_t i = Varint::VARINT_HEADER_SIZE; i < blob_size; i++) {
-		writable_blob[i] = value[blob_string_idx--];
-	}
-	result_value.Finalize();
-	return true;
-}
-
-template <>
-bool TryCastToVarInt::Operation(double double_value, string_t &result_value, Vector &result,
-                                CastParameters &parameters) {
-	return DoubleToVarInt(double_value, result_value, result);
-}
-
-template <>
-bool TryCastToVarInt::Operation(float double_value, string_t &result_value, Vector &result,
-                                CastParameters &parameters) {
-	return DoubleToVarInt(double_value, result_value, result);
-}
-
-BoundCastInfo Varint::NumericToVarintCastSwitch(const LogicalType &source) {
-	// now switch on the result type
-	switch (source.id()) {
-	case LogicalTypeId::TINYINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<int8_t, IntCastToVarInt>);
-	case LogicalTypeId::UTINYINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<uint8_t, IntCastToVarInt>);
-	case LogicalTypeId::SMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<int16_t, IntCastToVarInt>);
-	case LogicalTypeId::USMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<uint16_t, IntCastToVarInt>);
-	case LogicalTypeId::INTEGER:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<int32_t, IntCastToVarInt>);
-	case LogicalTypeId::UINTEGER:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<uint32_t, IntCastToVarInt>);
-	case LogicalTypeId::BIGINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<int64_t, IntCastToVarInt>);
-	case LogicalTypeId::UBIGINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<uint64_t, IntCastToVarInt>);
-	case LogicalTypeId::UHUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<uhugeint_t, HugeintCastToVarInt>);
-	case LogicalTypeId::FLOAT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<float, string_t, TryCastToVarInt>);
-	case LogicalTypeId::DOUBLE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<double, string_t, TryCastToVarInt>);
-	case LogicalTypeId::HUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<hugeint_t, HugeintCastToVarInt>);
-	case LogicalTypeId::DECIMAL:
-	default:
-		return DefaultCasts::TryVectorNullCast;
-	}
-}
-
-BoundCastInfo DefaultCasts::VarintCastSwitch(BindCastInput &input, const LogicalType &source,
-                                             const LogicalType &target) {
-	D_ASSERT(source.id() == LogicalTypeId::VARINT);
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, VarIntCastToVarchar>);
-	case LogicalTypeId::DOUBLE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, double, VarintToDoubleCast>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast/vector_cast_helpers.cpp b/src/duckdb/src/function/cast/vector_cast_helpers.cpp
deleted file mode 100644
index c7aa523ea..000000000
--- a/src/duckdb/src/function/cast/vector_cast_helpers.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
-
-namespace duckdb {
-
-// ------- Helper functions for splitting string nested types  -------
-static bool IsNull(const char *buf, idx_t start_pos, Vector &child, idx_t row_idx) {
-	if ((buf[start_pos] == 'N' || buf[start_pos] == 'n') && (buf[start_pos + 1] == 'U' || buf[start_pos + 1] == 'u') &&
-	    (buf[start_pos + 2] == 'L' || buf[start_pos + 2] == 'l') &&
-	    (buf[start_pos + 3] == 'L' || buf[start_pos + 3] == 'l')) {
-		FlatVector::SetNull(child, row_idx, true);
-		return true;
-	}
-	return false;
-}
-
-inline static void SkipWhitespace(const char *buf, idx_t &pos, idx_t len) {
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
-}
-
-static bool SkipToCloseQuotes(idx_t &pos, const char *buf, idx_t &len) {
-	char quote = buf[pos];
-	pos++;
-	bool escaped = false;
-
-	while (pos < len) {
-		if (buf[pos] == '\\') {
-			escaped = !escaped;
-		} else {
-			if (buf[pos] == quote && !escaped) {
-				return true;
-			}
-			escaped = false;
-		}
-		pos++;
-	}
-	return false;
-}
-
-static bool SkipToClose(idx_t &idx, const char *buf, idx_t &len, idx_t &lvl, char close_bracket) {
-	idx++;
-
-	vector<char> brackets;
-	brackets.push_back(close_bracket);
-	while (idx < len) {
-		if (buf[idx] == '"' || buf[idx] == '\'') {
-			if (!SkipToCloseQuotes(idx, buf, len)) {
-				return false;
-			}
-		} else if (buf[idx] == '{') {
-			brackets.push_back('}');
-		} else if (buf[idx] == '[') {
-			brackets.push_back(']');
-			lvl++;
-		} else if (buf[idx] == brackets.back()) {
-			if (buf[idx] == ']') {
-				lvl--;
-			}
-			brackets.pop_back();
-			if (brackets.empty()) {
-				return true;
-			}
-		}
-		idx++;
-	}
-	return false;
-}
-
-static idx_t StringTrim(const char *buf, idx_t &start_pos, idx_t pos) {
-	idx_t trailing_whitespace = 0;
-	while (pos > start_pos && StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
-		trailing_whitespace++;
-	}
-	if ((buf[start_pos] == '"' && buf[pos - trailing_whitespace - 1] == '"') ||
-	    (buf[start_pos] == '\'' && buf[pos - trailing_whitespace - 1] == '\'')) {
-		start_pos++;
-		trailing_whitespace++;
-	}
-	return (pos - trailing_whitespace);
-}
-
-struct CountPartOperation {
-	idx_t count = 0;
-
-	bool HandleKey(const char *buf, idx_t start_pos, idx_t pos) {
-		count++;
-		return true;
-	}
-	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
-		count++;
-	}
-};
-
-// ------- LIST SPLIT -------
-struct SplitStringListOperation {
-	SplitStringListOperation(string_t *child_data, idx_t &child_start, Vector &child)
-	    : child_data(child_data), child_start(child_start), child(child) {
-	}
-
-	string_t *child_data;
-	idx_t &child_start;
-	Vector &child;
-
-	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
-		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, child, child_start)) {
-			child_start++;
-			return;
-		}
-		if (start_pos > pos) {
-			pos = start_pos;
-		}
-		child_data[child_start] = StringVector::AddString(child, buf + start_pos, pos - start_pos);
-		child_start++;
-	}
-};
-
-template <class OP>
-static bool SplitStringListInternal(const string_t &input, OP &state) {
-	const char *buf = input.GetData();
-	idx_t len = input.GetSize();
-	idx_t lvl = 1;
-	idx_t pos = 0;
-	bool seen_value = false;
-
-	SkipWhitespace(buf, pos, len);
-	if (pos == len || buf[pos] != '[') {
-		return false;
-	}
-
-	SkipWhitespace(buf, ++pos, len);
-	idx_t start_pos = pos;
-	while (pos < len) {
-		if (buf[pos] == '[') {
-			if (!SkipToClose(pos, buf, len, ++lvl, ']')) {
-				return false;
-			}
-		} else if ((buf[pos] == '"' || buf[pos] == '\'') && pos == start_pos) {
-			SkipToCloseQuotes(pos, buf, len);
-		} else if (buf[pos] == '{') {
-			idx_t struct_lvl = 0;
-			SkipToClose(pos, buf, len, struct_lvl, '}');
-		} else if (buf[pos] == ',' || buf[pos] == ']') {
-			idx_t trailing_whitespace = 0;
-			while (StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
-				trailing_whitespace++;
-			}
-			if (buf[pos] != ']' || start_pos != pos || seen_value) {
-				state.HandleValue(buf, start_pos, pos - trailing_whitespace);
-				seen_value = true;
-			}
-			if (buf[pos] == ']') {
-				lvl--;
-				break;
-			}
-			SkipWhitespace(buf, ++pos, len);
-			start_pos = pos;
-			continue;
-		}
-		pos++;
-	}
-	SkipWhitespace(buf, ++pos, len);
-	return (pos == len && lvl == 0);
-}
-
-bool VectorStringToList::SplitStringList(const string_t &input, string_t *child_data, idx_t &child_start,
-                                         Vector &child) {
-	SplitStringListOperation state(child_data, child_start, child);
-	return SplitStringListInternal<SplitStringListOperation>(input, state);
-}
-
-idx_t VectorStringToList::CountPartsList(const string_t &input) {
-	CountPartOperation state;
-	SplitStringListInternal<CountPartOperation>(input, state);
-	return state.count;
-}
-
-// ------- MAP SPLIT -------
-struct SplitStringMapOperation {
-	SplitStringMapOperation(string_t *child_key_data, string_t *child_val_data, idx_t &child_start, Vector &varchar_key,
-	                        Vector &varchar_val)
-	    : child_key_data(child_key_data), child_val_data(child_val_data), child_start(child_start),
-	      varchar_key(varchar_key), varchar_val(varchar_val) {
-	}
-
-	string_t *child_key_data;
-	string_t *child_val_data;
-	idx_t &child_start;
-	Vector &varchar_key;
-	Vector &varchar_val;
-
-	bool HandleKey(const char *buf, idx_t start_pos, idx_t pos) {
-		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, varchar_key, child_start)) {
-			FlatVector::SetNull(varchar_val, child_start, true);
-			child_start++;
-			return false;
-		}
-		child_key_data[child_start] = StringVector::AddString(varchar_key, buf + start_pos, pos - start_pos);
-		return true;
-	}
-
-	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
-		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, varchar_val, child_start)) {
-			child_start++;
-			return;
-		}
-		child_val_data[child_start] = StringVector::AddString(varchar_val, buf + start_pos, pos - start_pos);
-		child_start++;
-	}
-};
-
-template <class OP>
-static bool FindKeyOrValueMap(const char *buf, idx_t len, idx_t &pos, OP &state, bool key) {
-	auto start_pos = pos;
-	idx_t lvl = 0;
-	while (pos < len) {
-		if (buf[pos] == '"' || buf[pos] == '\'') {
-			SkipToCloseQuotes(pos, buf, len);
-		} else if (buf[pos] == '{') {
-			SkipToClose(pos, buf, len, lvl, '}');
-		} else if (buf[pos] == '[') {
-			SkipToClose(pos, buf, len, lvl, ']');
-		} else if (key && buf[pos] == '=') {
-			idx_t end_pos = StringTrim(buf, start_pos, pos);
-			return state.HandleKey(buf, start_pos, end_pos); // put string in KEY_child_vector
-		} else if (!key && (buf[pos] == ',' || buf[pos] == '}')) {
-			idx_t end_pos = StringTrim(buf, start_pos, pos);
-			state.HandleValue(buf, start_pos, end_pos); // put string in VALUE_child_vector
-			return true;
-		}
-		pos++;
-	}
-	return false;
-}
-
-template <class OP>
-static bool SplitStringMapInternal(const string_t &input, OP &state) {
-	const char *buf = input.GetData();
-	idx_t len = input.GetSize();
-	idx_t pos = 0;
-
-	SkipWhitespace(buf, pos, len);
-	if (pos == len || buf[pos] != '{') {
-		return false;
-	}
-	SkipWhitespace(buf, ++pos, len);
-	if (pos == len) {
-		return false;
-	}
-	if (buf[pos] == '}') {
-		SkipWhitespace(buf, ++pos, len);
-		return (pos == len);
-	}
-	while (pos < len) {
-		if (!FindKeyOrValueMap(buf, len, pos, state, true)) {
-			return false;
-		}
-		SkipWhitespace(buf, ++pos, len);
-		if (!FindKeyOrValueMap(buf, len, pos, state, false)) {
-			return false;
-		}
-		SkipWhitespace(buf, ++pos, len);
-	}
-	return true;
-}
-
-bool VectorStringToMap::SplitStringMap(const string_t &input, string_t *child_key_data, string_t *child_val_data,
-                                       idx_t &child_start, Vector &varchar_key, Vector &varchar_val) {
-	SplitStringMapOperation state(child_key_data, child_val_data, child_start, varchar_key, varchar_val);
-	return SplitStringMapInternal<SplitStringMapOperation>(input, state);
-}
-
-idx_t VectorStringToMap::CountPartsMap(const string_t &input) {
-	CountPartOperation state;
-	SplitStringMapInternal<CountPartOperation>(input, state);
-	return state.count;
-}
-
-// ------- STRUCT SPLIT -------
-static bool FindKeyStruct(const char *buf, idx_t len, idx_t &pos) {
-	while (pos < len) {
-		if (buf[pos] == ':') {
-			return true;
-		}
-		pos++;
-	}
-	return false;
-}
-
-static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varchar_child, idx_t &row_idx,
-                            ValidityMask &child_mask) {
-	auto start_pos = pos;
-	idx_t lvl = 0;
-	while (pos < len) {
-		if (buf[pos] == '"' || buf[pos] == '\'') {
-			SkipToCloseQuotes(pos, buf, len);
-		} else if (buf[pos] == '{') {
-			SkipToClose(pos, buf, len, lvl, '}');
-		} else if (buf[pos] == '[') {
-			SkipToClose(pos, buf, len, lvl, ']');
-		} else if (buf[pos] == ',' || buf[pos] == '}') {
-			idx_t end_pos = StringTrim(buf, start_pos, pos);
-			if ((end_pos - start_pos) == 4 && IsNull(buf, start_pos, varchar_child, row_idx)) {
-				return true;
-			}
-			FlatVector::GetData<string_t>(varchar_child)[row_idx] =
-			    StringVector::AddString(varchar_child, buf + start_pos, end_pos - start_pos);
-			child_mask.SetValid(row_idx); // any child not set to valid will remain invalid
-			return true;
-		}
-		pos++;
-	}
-	return false;
-}
-
-bool VectorStringToStruct::SplitStruct(const string_t &input, vector<unique_ptr<Vector>> &varchar_vectors,
-                                       idx_t &row_idx, string_map_t<idx_t> &child_names,
-                                       vector<reference<ValidityMask>> &child_masks) {
-	const char *buf = input.GetData();
-	idx_t len = input.GetSize();
-	idx_t pos = 0;
-	idx_t child_idx;
-
-	SkipWhitespace(buf, pos, len);
-	if (pos == len || buf[pos] != '{') {
-		return false;
-	}
-	SkipWhitespace(buf, ++pos, len);
-	if (buf[pos] == '}') {
-		pos++;
-	} else {
-		while (pos < len) {
-			auto key_start = pos;
-			if (!FindKeyStruct(buf, len, pos)) {
-				return false;
-			}
-			auto key_end = StringTrim(buf, key_start, pos);
-			if (key_start >= key_end) {
-				// empty key name unsupported
-				return false;
-			}
-			string_t found_key(buf + key_start, UnsafeNumericCast<uint32_t>(key_end - key_start));
-
-			auto it = child_names.find(found_key);
-			if (it == child_names.end()) {
-				return false; // false key
-			}
-			child_idx = it->second;
-			SkipWhitespace(buf, ++pos, len);
-			if (!FindValueStruct(buf, len, pos, *varchar_vectors[child_idx], row_idx, child_masks[child_idx].get())) {
-				return false;
-			}
-			SkipWhitespace(buf, ++pos, len);
-		}
-	}
-	SkipWhitespace(buf, pos, len);
-	return (pos == len);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/cast_rules.cpp b/src/duckdb/src/function/cast_rules.cpp
deleted file mode 100644
index 951ecc935..000000000
--- a/src/duckdb/src/function/cast_rules.cpp
+++ /dev/null
@@ -1,585 +0,0 @@
-#include "duckdb/function/cast_rules.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-//! The target type determines the preferred implicit casts
-static int64_t TargetTypeCost(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BIGINT:
-		return 101;
-	case LogicalTypeId::INTEGER:
-		return 102;
-	case LogicalTypeId::HUGEINT:
-		return 103;
-	case LogicalTypeId::DOUBLE:
-		return 104;
-	case LogicalTypeId::DECIMAL:
-		return 105;
-	case LogicalTypeId::TIMESTAMP_NS:
-		return 119;
-	case LogicalTypeId::TIMESTAMP:
-		return 120;
-	case LogicalTypeId::TIMESTAMP_MS:
-		return 121;
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return 122;
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return 123;
-	case LogicalTypeId::VARCHAR:
-		return 149;
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::UNION:
-	case LogicalTypeId::ARRAY:
-		return 160;
-	case LogicalTypeId::ANY:
-		return int64_t(AnyType::GetCastScore(type));
-	default:
-		return 110;
-	}
-}
-
-static int64_t ImplicitCastTinyint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastSmallint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastInteger(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastBigint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUTinyint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUSmallint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUInteger(const LogicalType &to) {
-	switch (to.id()) {
-
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUBigint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastFloat(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::DOUBLE:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastDouble(const LogicalType &to) {
-	switch (to.id()) {
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastDecimal(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastHugeint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUhugeint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastDate(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastEnum(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::VARCHAR:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastTimestampSec(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastTimestampMS(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_NS:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastTimestampNS(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::TIMESTAMP:
-		// we allow casting ALL timestamps, including nanosecond ones, to TimestampNS
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastTimestamp(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::TIMESTAMP_NS:
-		return TargetTypeCost(to);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastVarint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::DOUBLE:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-bool LogicalTypeIsValid(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::UNION:
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::ARRAY:
-	case LogicalTypeId::DECIMAL:
-		// these types are only valid with auxiliary info
-		if (!type.AuxInfo()) {
-			return false;
-		}
-		break;
-	default:
-		break;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::ANY:
-	case LogicalTypeId::INVALID:
-	case LogicalTypeId::UNKNOWN:
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto child_count = StructType::GetChildCount(type);
-		for (idx_t i = 0; i < child_count; i++) {
-			if (!LogicalTypeIsValid(StructType::GetChildType(type, i))) {
-				return false;
-			}
-		}
-		return true;
-	}
-	case LogicalTypeId::UNION: {
-		auto member_count = UnionType::GetMemberCount(type);
-		for (idx_t i = 0; i < member_count; i++) {
-			if (!LogicalTypeIsValid(UnionType::GetMemberType(type, i))) {
-				return false;
-			}
-		}
-		return true;
-	}
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-		return LogicalTypeIsValid(ListType::GetChildType(type));
-	case LogicalTypeId::ARRAY:
-		return LogicalTypeIsValid(ArrayType::GetChildType(type));
-	default:
-		return true;
-	}
-}
-
-int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to) {
-	if (from.id() == LogicalTypeId::SQLNULL || to.id() == LogicalTypeId::ANY) {
-		// NULL expression can be cast to anything
-		return TargetTypeCost(to);
-	}
-	if (from.id() == LogicalTypeId::UNKNOWN) {
-		// parameter expression can be cast to anything for no cost
-		return 0;
-	}
-	if (from.id() == LogicalTypeId::STRING_LITERAL) {
-		// string literals can be cast to any type for low cost as long as the type is valid
-		// i.e. we cannot cast to LIST(ANY) as we don't know what "ANY" should be
-		// we cannot cast to DECIMAL without precision/width specified
-		if (!LogicalTypeIsValid(to)) {
-			return -1;
-		}
-		if (to.id() == LogicalTypeId::VARCHAR && to.GetAlias().empty()) {
-			return 1;
-		}
-		return 20;
-	}
-	if (from.id() == LogicalTypeId::INTEGER_LITERAL) {
-		// the integer literal has an underlying type - this type always matches
-		if (IntegerLiteral::GetType(from).id() == to.id()) {
-			return 0;
-		}
-		// integer literals can be cast to any other integer type for a low cost, but only if the literal fits
-		if (IntegerLiteral::FitsInType(from, to)) {
-			// to avoid ties we prefer BIGINT, INT, ...
-			auto target_cost = TargetTypeCost(to);
-			if (target_cost < 100) {
-				throw InternalException("Integer literal implicit cast - TargetTypeCost should be >= 100");
-			}
-			return target_cost - 90;
-		}
-		// in any other case we use the casting rules of the preferred type of the literal
-		return CastRules::ImplicitCast(IntegerLiteral::GetType(from), to);
-	}
-	if (from.GetAlias() != to.GetAlias()) {
-		// if aliases are different, an implicit cast is not possible
-		return -1;
-	}
-	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
-		// Lists can be cast if their child types can be cast
-		auto child_cost = ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
-		if (child_cost >= 1) {
-			// subtract one from the cost because we prefer LIST[X] -> LIST[VARCHAR] over LIST[X] -> VARCHAR
-			child_cost--;
-		}
-		return child_cost;
-	}
-	if (from.id() == LogicalTypeId::ARRAY && to.id() == LogicalTypeId::ARRAY) {
-		// Arrays can be cast if their child types can be cast and the source and target has the same size
-		// or the target type has a unknown (any) size.
-		auto from_size = ArrayType::GetSize(from);
-		auto to_size = ArrayType::GetSize(to);
-		auto to_is_any_size = ArrayType::IsAnySize(to);
-		if (from_size == to_size || to_is_any_size) {
-			auto child_cost = ImplicitCast(ArrayType::GetChildType(from), ArrayType::GetChildType(to));
-			if (child_cost >= 100) {
-				// subtract one from the cost because we prefer ARRAY[X] -> ARRAY[VARCHAR] over ARRAY[X] -> VARCHAR
-				child_cost--;
-			}
-			return child_cost;
-		}
-		return -1; // Not possible if the sizes are different
-	}
-	if (from.id() == LogicalTypeId::ARRAY && to.id() == LogicalTypeId::LIST) {
-		// Arrays can be cast to lists for the cost of casting the child type
-		auto child_cost = ImplicitCast(ArrayType::GetChildType(from), ListType::GetChildType(to));
-		if (child_cost < 0) {
-			return -1;
-		}
-		// add 1 because we prefer ARRAY->ARRAY casts over ARRAY->LIST casts
-		return child_cost + 1;
-	}
-	if (from.id() == LogicalTypeId::LIST && (to.id() == LogicalTypeId::ARRAY && !ArrayType::IsAnySize(to))) {
-		// Lists can be cast to arrays for the cost of casting the child type, if the target size is known
-		// there is no way for us to resolve the size at bind-time without inspecting the list values.
-		// TODO: if we can access the expression we could resolve the size if the list is constant.
-		return ImplicitCast(ListType::GetChildType(from), ArrayType::GetChildType(to));
-	}
-	if (from.id() == LogicalTypeId::UNION && to.id() == LogicalTypeId::UNION) {
-		// Check that the target union type is fully resolved.
-		if (to.AuxInfo() == nullptr) {
-			// If not, try anyway and let the actual cast logic handle it.
-			// This is to allow passing unions into functions that take a generic union type (without specifying member
-			// types) as an argument.
-			return 0;
-		}
-		// Unions can be cast if the source tags are a subset of the target tags
-		// in which case the most expensive cost is used
-		int64_t cost = -1;
-		for (idx_t from_member_idx = 0; from_member_idx < UnionType::GetMemberCount(from); from_member_idx++) {
-			auto &from_member_name = UnionType::GetMemberName(from, from_member_idx);
-
-			bool found = false;
-			for (idx_t to_member_idx = 0; to_member_idx < UnionType::GetMemberCount(to); to_member_idx++) {
-				auto &to_member_name = UnionType::GetMemberName(to, to_member_idx);
-
-				if (StringUtil::CIEquals(from_member_name, to_member_name)) {
-					auto &from_member_type = UnionType::GetMemberType(from, from_member_idx);
-					auto &to_member_type = UnionType::GetMemberType(to, to_member_idx);
-
-					auto child_cost = ImplicitCast(from_member_type, to_member_type);
-					cost = MaxValue(cost, child_cost);
-					found = true;
-					break;
-				}
-			}
-			if (!found) {
-				return -1;
-			}
-		}
-		return cost;
-	}
-	if (from.id() == LogicalTypeId::STRUCT && to.id() == LogicalTypeId::STRUCT) {
-		if (to.AuxInfo() == nullptr) {
-			// If this struct is not fully resolved, we'll leave it to the actual cast logic to handle it.
-			return 0;
-		}
-
-		auto &source_children = StructType::GetChildTypes(from);
-		auto &target_children = StructType::GetChildTypes(to);
-
-		if (source_children.size() != target_children.size()) {
-			// different number of children: not possible
-			return -1;
-		}
-
-		auto target_is_unnamed = StructType::IsUnnamed(to);
-		auto source_is_unnamed = StructType::IsUnnamed(from);
-		auto named_struct_cast = !source_is_unnamed && !target_is_unnamed;
-
-		int64_t cost = -1;
-		if (named_struct_cast) {
-
-			// Collect the target members in a map for easy lookup
-			case_insensitive_map_t<idx_t> target_members;
-			for (idx_t target_idx = 0; target_idx < target_children.size(); target_idx++) {
-				auto &target_name = target_children[target_idx].first;
-				if (target_members.find(target_name) != target_members.end()) {
-					// duplicate name in target struct
-					return -1;
-				}
-				target_members[target_name] = target_idx;
-			}
-			// Match the source members to the target members by name
-			for (idx_t source_idx = 0; source_idx < source_children.size(); source_idx++) {
-				auto &source_child = source_children[source_idx];
-				auto entry = target_members.find(source_child.first);
-				if (entry == target_members.end()) {
-					// element in source struct was not found in target struct
-					return -1;
-				}
-				auto target_idx = entry->second;
-				target_members.erase(entry);
-				auto child_cost = ImplicitCast(source_child.second, target_children[target_idx].second);
-				if (child_cost == -1) {
-					return -1;
-				}
-				cost = MaxValue(cost, child_cost);
-			}
-		} else {
-			// Match the source members to the target members by position
-			for (idx_t i = 0; i < source_children.size(); i++) {
-				auto &source_child = source_children[i];
-				auto &target_child = target_children[i];
-				auto child_cost = ImplicitCast(source_child.second, target_child.second);
-				if (child_cost == -1) {
-					return -1;
-				}
-				cost = MaxValue(cost, child_cost);
-			}
-		}
-		return cost;
-	}
-
-	if (from.id() == to.id()) {
-		// arguments match: do nothing
-		return 0;
-	}
-
-	// Special case: Anything can be cast to a union if the source type is a member of the union
-	if (to.id() == LogicalTypeId::UNION) {
-		// check that the union type is fully resolved.
-		if (to.AuxInfo() == nullptr) {
-			return -1;
-		}
-		// check if the union contains something castable from the source type
-		// in which case the least expensive (most specific) cast should be used
-		bool found = false;
-		auto cost = NumericLimits<int64_t>::Maximum();
-		for (idx_t i = 0; i < UnionType::GetMemberCount(to); i++) {
-			auto target_member = UnionType::GetMemberType(to, i);
-			auto target_cost = ImplicitCast(from, target_member);
-			if (target_cost != -1) {
-				found = true;
-				cost = MinValue(cost, target_cost);
-			}
-		}
-		return found ? cost : -1;
-	}
-
-	switch (from.id()) {
-	case LogicalTypeId::TINYINT:
-		return ImplicitCastTinyint(to);
-	case LogicalTypeId::SMALLINT:
-		return ImplicitCastSmallint(to);
-	case LogicalTypeId::INTEGER:
-		return ImplicitCastInteger(to);
-	case LogicalTypeId::BIGINT:
-		return ImplicitCastBigint(to);
-	case LogicalTypeId::UTINYINT:
-		return ImplicitCastUTinyint(to);
-	case LogicalTypeId::USMALLINT:
-		return ImplicitCastUSmallint(to);
-	case LogicalTypeId::UINTEGER:
-		return ImplicitCastUInteger(to);
-	case LogicalTypeId::UBIGINT:
-		return ImplicitCastUBigint(to);
-	case LogicalTypeId::HUGEINT:
-		return ImplicitCastHugeint(to);
-	case LogicalTypeId::UHUGEINT:
-		return ImplicitCastUhugeint(to);
-	case LogicalTypeId::FLOAT:
-		return ImplicitCastFloat(to);
-	case LogicalTypeId::DOUBLE:
-		return ImplicitCastDouble(to);
-	case LogicalTypeId::DATE:
-		return ImplicitCastDate(to);
-	case LogicalTypeId::DECIMAL:
-		return ImplicitCastDecimal(to);
-	case LogicalTypeId::ENUM:
-		return ImplicitCastEnum(to);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return ImplicitCastTimestampSec(to);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return ImplicitCastTimestampMS(to);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return ImplicitCastTimestampNS(to);
-	case LogicalTypeId::TIMESTAMP:
-		return ImplicitCastTimestamp(to);
-	case LogicalTypeId::VARINT:
-		return ImplicitCastVarint(to);
-	default:
-		return -1;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/compression_config.cpp b/src/duckdb/src/function/compression_config.cpp
deleted file mode 100644
index deece1a85..000000000
--- a/src/duckdb/src/function/compression_config.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#include "duckdb/common/pair.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-typedef CompressionFunction (*get_compression_function_t)(PhysicalType type);
-typedef bool (*compression_supports_type_t)(const PhysicalType physical_type);
-
-struct DefaultCompressionMethod {
-	CompressionType type;
-	get_compression_function_t get_function;
-	compression_supports_type_t supports_type;
-};
-
-static const 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_DICTIONARY, DictionaryCompressionFun::GetFunction,
-     DictionaryCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_CHIMP, ChimpCompressionFun::GetFunction, ChimpCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_PATAS, PatasCompressionFun::GetFunction, PatasCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_ALP, AlpCompressionFun::GetFunction, AlpCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_ALPRD, AlpRDCompressionFun::GetFunction, AlpRDCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_FSST, FSSTFun::GetFunction, FSSTFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_ZSTD, ZSTDFun::GetFunction, ZSTDFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_ROARING, RoaringCompressionFun::GetFunction, RoaringCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_EMPTY, EmptyValidityCompressionFun::GetFunction,
-     EmptyValidityCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}};
-
-static optional_ptr<CompressionFunction> FindCompressionFunction(CompressionFunctionSet &set, CompressionType type,
-                                                                 const PhysicalType physical_type) {
-	auto &functions = set.functions;
-	auto comp_entry = functions.find(type);
-	if (comp_entry != functions.end()) {
-		auto &type_functions = comp_entry->second;
-		auto type_entry = type_functions.find(physical_type);
-		if (type_entry != type_functions.end()) {
-			return &type_entry->second;
-		}
-	}
-	return nullptr;
-}
-
-static optional_ptr<CompressionFunction> LoadCompressionFunction(CompressionFunctionSet &set, CompressionType type,
-                                                                 const PhysicalType physical_type) {
-	for (idx_t i = 0; internal_compression_methods[i].get_function; i++) {
-		const auto &method = internal_compression_methods[i];
-		if (method.type == type) {
-			if (!method.supports_type(physical_type)) {
-				return nullptr;
-			}
-			// The type is supported. We create the function and insert it into the set of available functions.
-			auto function = method.get_function(physical_type);
-			set.functions[type].insert(make_pair(physical_type, function));
-			return FindCompressionFunction(set, type, physical_type);
-		}
-	}
-	throw InternalException("Unsupported compression function type");
-}
-
-static void TryLoadCompression(DBConfig &config, vector<reference<CompressionFunction>> &result, CompressionType type,
-                               const PhysicalType physical_type) {
-	auto function = config.GetCompressionFunction(type, physical_type);
-	if (!function) {
-		return;
-	}
-	result.push_back(*function);
-}
-
-vector<reference<CompressionFunction>> DBConfig::GetCompressionFunctions(const PhysicalType physical_type) {
-	vector<reference<CompressionFunction>> result;
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_UNCOMPRESSED, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_RLE, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_BITPACKING, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_DICTIONARY, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_CHIMP, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_PATAS, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_ALP, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_ALPRD, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_FSST, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_ZSTD, physical_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_ROARING, physical_type);
-	return result;
-}
-
-optional_ptr<CompressionFunction> DBConfig::GetCompressionFunction(CompressionType type,
-                                                                   const PhysicalType physical_type) {
-	lock_guard<mutex> l(compression_functions->lock);
-
-	// Check if the function is already loaded into the global compression functions.
-	auto function = FindCompressionFunction(*compression_functions, type, physical_type);
-	if (function) {
-		return function;
-	}
-
-	// We could not find the function in the global compression functions,
-	// so we attempt loading it.
-	return LoadCompressionFunction(*compression_functions, type, physical_type);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/copy_function.cpp b/src/duckdb/src/function/copy_function.cpp
deleted file mode 100644
index ac2bc7545..000000000
--- a/src/duckdb/src/function/copy_function.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/function/copy_function.hpp"
-
-namespace duckdb {
-
-vector<string> GetCopyFunctionReturnNames(CopyFunctionReturnType return_type) {
-	switch (return_type) {
-	case CopyFunctionReturnType::CHANGED_ROWS:
-		return {"Count"};
-	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST:
-		return {"Count", "Files"};
-	default:
-		throw NotImplementedException("Unknown CopyFunctionReturnType");
-	}
-}
-
-vector<LogicalType> GetCopyFunctionReturnLogicalTypes(CopyFunctionReturnType return_type) {
-	switch (return_type) {
-	case CopyFunctionReturnType::CHANGED_ROWS:
-		return {LogicalType::BIGINT};
-	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST:
-		return {LogicalType::BIGINT, LogicalType::LIST(LogicalType::VARCHAR)};
-	default:
-		throw NotImplementedException("Unknown CopyFunctionReturnType");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/encoding_function.cpp b/src/duckdb/src/function/encoding_function.cpp
deleted file mode 100644
index 644652c46..000000000
--- a/src/duckdb/src/function/encoding_function.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#include "duckdb/function/encoding_function.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-struct DefaultEncodeMethod {
-	string name;
-	encode_t encode_function;
-	idx_t ratio;
-	idx_t bytes_per_iteration;
-};
-
-void DecodeUTF16ToUTF8(const char *source_buffer, idx_t &source_buffer_current_position, const idx_t source_buffer_size,
-                       char *target_buffer, idx_t &target_buffer_current_position, const idx_t target_buffer_size,
-                       char *remaining_bytes_buffer, idx_t &remaining_bytes_size) {
-
-	for (; source_buffer_current_position < source_buffer_size; source_buffer_current_position += 2) {
-		if (target_buffer_current_position == target_buffer_size) {
-			// We are done
-			return;
-		}
-		const uint16_t ch =
-		    static_cast<uint16_t>(static_cast<unsigned char>(source_buffer[source_buffer_current_position]) |
-		                          (static_cast<unsigned char>(source_buffer[source_buffer_current_position + 1]) << 8));
-		if (ch >= 0xD800 && ch <= 0xDFFF) {
-			throw InvalidInputException("File is not utf-16 encoded");
-		}
-		if (ch <= 0x007F) {
-			// 1-byte UTF-8 for ASCII characters
-			target_buffer[target_buffer_current_position++] = static_cast<char>(ch & 0x7F);
-		} else if (ch <= 0x07FF) {
-			// 2-byte UTF-8
-			target_buffer[target_buffer_current_position++] = static_cast<char>(0xC0 | (ch >> 6));
-			if (target_buffer_current_position == target_buffer_size) {
-				// We are done, but we have to store one byte for the next chunk!
-				source_buffer_current_position += 2;
-				remaining_bytes_buffer[0] = static_cast<char>(0x80 | (ch & 0x3F));
-				remaining_bytes_size = 1;
-				return;
-			}
-			target_buffer[target_buffer_current_position++] = static_cast<char>(0x80 | (ch & 0x3F));
-		} else {
-			// 3-byte UTF-8
-			target_buffer[target_buffer_current_position++] = static_cast<char>(0xE0 | (ch >> 12));
-			if (target_buffer_current_position == target_buffer_size) {
-				// We are done, but we have to store two bytes for the next chunk!
-				source_buffer_current_position += 2;
-				remaining_bytes_buffer[0] = static_cast<char>(0x80 | ((ch >> 6) & 0x3F));
-				remaining_bytes_buffer[1] = static_cast<char>(0x80 | (ch & 0x3F));
-				remaining_bytes_size = 2;
-				return;
-			}
-			target_buffer[target_buffer_current_position++] = static_cast<char>(0x80 | ((ch >> 6) & 0x3F));
-			if (target_buffer_current_position == target_buffer_size) {
-				// We are done, but we have to store one byte for the next chunk!
-				source_buffer_current_position += 2;
-				remaining_bytes_buffer[0] = static_cast<char>(0x80 | (ch & 0x3F));
-				remaining_bytes_size = 1;
-				return;
-			}
-			target_buffer[target_buffer_current_position++] = static_cast<char>(0x80 | (ch & 0x3F));
-		}
-	}
-}
-
-void DecodeLatin1ToUTF8(const char *source_buffer, idx_t &source_buffer_current_position,
-                        const idx_t source_buffer_size, char *target_buffer, idx_t &target_buffer_current_position,
-                        const idx_t target_buffer_size, char *remaining_bytes_buffer, idx_t &remaining_bytes_size) {
-	for (; source_buffer_current_position < source_buffer_size; source_buffer_current_position++) {
-		if (target_buffer_current_position == target_buffer_size) {
-			// We are done
-			return;
-		}
-		const unsigned char ch = static_cast<unsigned char>(source_buffer[source_buffer_current_position]);
-		if (ch > 0x7F && ch <= 0x9F) {
-			throw InvalidInputException("File is not latin-1 encoded");
-		}
-		if (ch <= 0x7F) {
-			// ASCII: 1 byte in UTF-8
-			target_buffer[target_buffer_current_position++] = static_cast<char>(ch);
-		} else {
-			// Non-ASCII: 2 bytes in UTF-8
-			target_buffer[target_buffer_current_position++] = static_cast<char>(0xc2 + (ch > 0xbf));
-			if (target_buffer_current_position == target_buffer_size) {
-				// We are done, but we have to store one byte for the next chunk!
-				source_buffer_current_position++;
-				remaining_bytes_buffer[0] = static_cast<char>((ch & 0x3f) + 0x80);
-				remaining_bytes_size = 1;
-				return;
-			}
-			target_buffer[target_buffer_current_position++] = static_cast<char>((ch & 0x3f) + 0x80);
-		}
-	}
-}
-
-void DecodeUTF8(const char *source_buffer, idx_t &source_buffer_current_position, const idx_t source_buffer_size,
-                char *target_buffer, idx_t &target_buffer_current_position, const idx_t target_buffer_size,
-                char *remaining_bytes_buffer, idx_t &remaining_bytes_size) {
-	throw InternalException("Decode UTF8 is not a valid function, and should be verified one level up.");
-}
-
-void EncodingFunctionSet::Initialize(DBConfig &config) {
-	config.RegisterEncodeFunction({"utf-8", DecodeUTF8, 1, 1});
-	config.RegisterEncodeFunction({"latin-1", DecodeLatin1ToUTF8, 2, 1});
-	config.RegisterEncodeFunction({"utf-16", DecodeUTF16ToUTF8, 2, 2});
-}
-
-void DBConfig::RegisterEncodeFunction(const EncodingFunction &function) const {
-	lock_guard<mutex> l(encoding_functions->lock);
-	const auto decode_type = function.GetType();
-	if (encoding_functions->functions.find(decode_type) != encoding_functions->functions.end()) {
-		throw InvalidInputException("Decoding function with name %s already registered", decode_type);
-	}
-	encoding_functions->functions[decode_type] = function;
-}
-
-optional_ptr<EncodingFunction> DBConfig::GetEncodeFunction(const string &name) const {
-	lock_guard<mutex> l(encoding_functions->lock);
-	// Check if the function is already loaded into the global compression functions.
-	if (encoding_functions->functions.find(name) != encoding_functions->functions.end()) {
-		return &encoding_functions->functions[name];
-	}
-	return nullptr;
-}
-
-vector<reference<EncodingFunction>> DBConfig::GetLoadedEncodedFunctions() const {
-	lock_guard<mutex> l(encoding_functions->lock);
-	vector<reference<EncodingFunction>> result;
-	for (auto &function : encoding_functions->functions) {
-		result.push_back(function.second);
-	}
-	return result;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/function/function.cpp b/src/duckdb/src/function/function.cpp
deleted file mode 100644
index 3307d3c54..000000000
--- a/src/duckdb/src/function/function.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "duckdb/function/function.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/main/extension_entries.hpp"
-
-namespace duckdb {
-
-FunctionData::~FunctionData() {
-}
-
-bool FunctionData::Equals(const FunctionData *left, const FunctionData *right) {
-	if (left == right) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return left->Equals(*right);
-}
-
-TableFunctionData::~TableFunctionData() {
-}
-
-unique_ptr<FunctionData> TableFunctionData::Copy() const {
-	throw InternalException("Copy not supported for TableFunctionData");
-}
-
-bool TableFunctionData::Equals(const FunctionData &other) const {
-	return false;
-}
-
-Function::Function(string name_p) : name(std::move(name_p)) {
-}
-Function::~Function() {
-}
-
-SimpleFunction::SimpleFunction(string name_p, vector<LogicalType> arguments_p, LogicalType varargs_p)
-    : Function(std::move(name_p)), arguments(std::move(arguments_p)), varargs(std::move(varargs_p)) {
-}
-
-SimpleFunction::~SimpleFunction() {
-}
-
-string SimpleFunction::ToString() const {
-	return Function::CallToString(name, arguments, varargs);
-}
-
-bool SimpleFunction::HasVarArgs() const {
-	return varargs.id() != LogicalTypeId::INVALID;
-}
-
-SimpleNamedParameterFunction::SimpleNamedParameterFunction(string name_p, vector<LogicalType> arguments_p,
-                                                           LogicalType varargs_p)
-    : SimpleFunction(std::move(name_p), std::move(arguments_p), std::move(varargs_p)) {
-}
-
-SimpleNamedParameterFunction::~SimpleNamedParameterFunction() {
-}
-
-string SimpleNamedParameterFunction::ToString() const {
-	return Function::CallToString(name, arguments, named_parameters);
-}
-
-bool SimpleNamedParameterFunction::HasNamedParameters() const {
-	return !named_parameters.empty();
-}
-
-BaseScalarFunction::BaseScalarFunction(string name_p, vector<LogicalType> arguments_p, LogicalType return_type_p,
-                                       FunctionStability stability, LogicalType varargs_p,
-                                       FunctionNullHandling null_handling, FunctionErrors errors)
-    : SimpleFunction(std::move(name_p), std::move(arguments_p), std::move(varargs_p)),
-      return_type(std::move(return_type_p)), stability(stability), null_handling(null_handling), errors(errors),
-      collation_handling(FunctionCollationHandling::PROPAGATE_COLLATIONS) {
-}
-
-BaseScalarFunction::~BaseScalarFunction() {
-}
-
-string BaseScalarFunction::ToString() const {
-	return Function::CallToString(name, arguments, varargs, return_type);
-}
-
-// add your initializer for new functions here
-void BuiltinFunctions::Initialize() {
-	RegisterTableScanFunctions();
-	RegisterSQLiteFunctions();
-	RegisterReadFunctions();
-	RegisterTableFunctions();
-	RegisterArrowFunctions();
-
-	RegisterPragmaFunctions();
-
-	// initialize collations
-	AddCollation("nocase", LowerFun::GetFunction(), true);
-	AddCollation("noaccent", StripAccentsFun::GetFunction(), true);
-	AddCollation("nfc", NFCNormalizeFun::GetFunction());
-
-	RegisterExtensionOverloads();
-}
-
-hash_t BaseScalarFunction::Hash() const {
-	hash_t hash = return_type.Hash();
-	for (auto &arg : arguments) {
-		hash = duckdb::CombineHash(hash, arg.Hash());
-	}
-	return hash;
-}
-
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments, const LogicalType &varargs) {
-	string result = name + "(";
-	vector<string> string_arguments;
-	for (auto &arg : arguments) {
-		string_arguments.push_back(arg.ToString());
-	}
-	if (varargs.IsValid()) {
-		string_arguments.push_back("[" + varargs.ToString() + "...]");
-	}
-	result += StringUtil::Join(string_arguments, ", ");
-	return result + ")";
-}
-
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments, const LogicalType &varargs,
-                              const LogicalType &return_type) {
-	string result = CallToString(name, arguments, varargs);
-	result += " -> " + return_type.ToString();
-	return result;
-}
-
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments,
-                              const named_parameter_type_map_t &named_parameters) {
-	vector<string> input_arguments;
-	input_arguments.reserve(arguments.size() + named_parameters.size());
-	for (auto &arg : arguments) {
-		input_arguments.push_back(arg.ToString());
-	}
-	for (auto &kv : named_parameters) {
-		input_arguments.push_back(StringUtil::Format("%s : %s", kv.first, kv.second.ToString()));
-	}
-	return StringUtil::Format("%s(%s)", name, StringUtil::Join(input_arguments, ", "));
-}
-
-void Function::EraseArgument(SimpleFunction &bound_function, vector<unique_ptr<Expression>> &arguments,
-                             idx_t argument_index) {
-	if (bound_function.original_arguments.empty()) {
-		bound_function.original_arguments = bound_function.arguments;
-	}
-	D_ASSERT(arguments.size() == bound_function.arguments.size());
-	D_ASSERT(argument_index < arguments.size());
-	arguments.erase_at(argument_index);
-	bound_function.arguments.erase_at(argument_index);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/function_binder.cpp b/src/duckdb/src/function/function_binder.cpp
deleted file mode 100644
index 671441825..000000000
--- a/src/duckdb/src/function/function_binder.cpp
+++ /dev/null
@@ -1,487 +0,0 @@
-#include "duckdb/function/function_binder.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/cast_rules.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-FunctionBinder::FunctionBinder(ClientContext &context_p) : binder(nullptr), context(context_p) {
-}
-FunctionBinder::FunctionBinder(Binder &binder_p) : binder(&binder_p), context(binder_p.context) {
-}
-
-optional_idx FunctionBinder::BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments) {
-	if (arguments.size() < func.arguments.size()) {
-		// not enough arguments to fulfill the non-vararg part of the function
-		return optional_idx();
-	}
-	idx_t cost = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		LogicalType arg_type = i < func.arguments.size() ? func.arguments[i] : func.varargs;
-		if (arguments[i] == arg_type) {
-			// arguments match: do nothing
-			continue;
-		}
-		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], arg_type);
-		if (cast_cost >= 0) {
-			// we can implicitly cast, add the cost to the total cost
-			cost += idx_t(cast_cost);
-		} else {
-			// we can't implicitly cast: throw an error
-			return optional_idx();
-		}
-	}
-	return cost;
-}
-
-optional_idx FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments) {
-	if (func.HasVarArgs()) {
-		// special case varargs function
-		return BindVarArgsFunctionCost(func, arguments);
-	}
-	if (func.arguments.size() != arguments.size()) {
-		// invalid argument count: check the next function
-		return optional_idx();
-	}
-	idx_t cost = 0;
-	bool has_parameter = false;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (arguments[i].id() == LogicalTypeId::UNKNOWN) {
-			has_parameter = true;
-			continue;
-		}
-		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], func.arguments[i]);
-		if (cast_cost >= 0) {
-			// we can implicitly cast, add the cost to the total cost
-			cost += idx_t(cast_cost);
-		} else {
-			// we can't implicitly cast: throw an error
-			return optional_idx();
-		}
-	}
-	if (has_parameter) {
-		// all arguments are implicitly castable and there is a parameter - return 0 as cost
-		return 0;
-	}
-	return cost;
-}
-
-template <class T>
-vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, FunctionSet<T> &functions,
-                                                         const vector<LogicalType> &arguments, ErrorData &error) {
-	optional_idx best_function;
-	idx_t lowest_cost = NumericLimits<idx_t>::Maximum();
-	vector<idx_t> candidate_functions;
-	for (idx_t f_idx = 0; f_idx < functions.functions.size(); f_idx++) {
-		auto &func = functions.functions[f_idx];
-		// check the arguments of the function
-		auto bind_cost = BindFunctionCost(func, arguments);
-		if (!bind_cost.IsValid()) {
-			// auto casting was not possible
-			continue;
-		}
-		auto cost = bind_cost.GetIndex();
-		if (cost == lowest_cost) {
-			candidate_functions.push_back(f_idx);
-			continue;
-		}
-		if (cost > lowest_cost) {
-			continue;
-		}
-		candidate_functions.clear();
-		lowest_cost = cost;
-		best_function = f_idx;
-	}
-	if (!best_function.IsValid()) {
-		// no matching function was found, throw an error
-		vector<string> candidates;
-		for (auto &f : functions.functions) {
-			candidates.push_back(f.ToString());
-		}
-		error = ErrorData(BinderException::NoMatchingFunction(name, arguments, candidates));
-		return candidate_functions;
-	}
-	candidate_functions.push_back(best_function.GetIndex());
-	return candidate_functions;
-}
-
-template <class T>
-optional_idx FunctionBinder::MultipleCandidateException(const string &name, FunctionSet<T> &functions,
-                                                        vector<idx_t> &candidate_functions,
-                                                        const vector<LogicalType> &arguments, ErrorData &error) {
-	D_ASSERT(functions.functions.size() > 1);
-	// there are multiple possible function definitions
-	// throw an exception explaining which overloads are there
-	string call_str = Function::CallToString(name, arguments);
-	string candidate_str;
-	for (auto &conf : candidate_functions) {
-		T f = functions.GetFunctionByOffset(conf);
-		candidate_str += "\t" + f.ToString() + "\n";
-	}
-	error = ErrorData(
-	    ExceptionType::BINDER,
-	    StringUtil::Format("Could not choose a best candidate function for the function call \"%s\". In order to "
-	                       "select one, please add explicit type casts.\n\tCandidate functions:\n%s",
-	                       call_str, candidate_str));
-	return optional_idx();
-}
-
-template <class T>
-optional_idx FunctionBinder::BindFunctionFromArguments(const string &name, FunctionSet<T> &functions,
-                                                       const vector<LogicalType> &arguments, ErrorData &error) {
-	auto candidate_functions = BindFunctionsFromArguments<T>(name, functions, arguments, error);
-	if (candidate_functions.empty()) {
-		// no candidates
-		return optional_idx();
-	}
-	if (candidate_functions.size() > 1) {
-		// multiple candidates, check if there are any unknown arguments
-		bool has_parameters = false;
-		for (auto &arg_type : arguments) {
-			if (arg_type.id() == LogicalTypeId::UNKNOWN) {
-				//! there are! we could not resolve parameters in this case
-				throw ParameterNotResolvedException();
-			}
-		}
-		if (!has_parameters) {
-			return MultipleCandidateException(name, functions, candidate_functions, arguments, error);
-		}
-	}
-	return candidate_functions[0];
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
-                                          const vector<LogicalType> &arguments, ErrorData &error) {
-	return BindFunctionFromArguments(name, functions, arguments, error);
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
-                                          const vector<LogicalType> &arguments, ErrorData &error) {
-	return BindFunctionFromArguments(name, functions, arguments, error);
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
-                                          const vector<LogicalType> &arguments, ErrorData &error) {
-	return BindFunctionFromArguments(name, functions, arguments, error);
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
-                                          ErrorData &error) {
-	vector<LogicalType> types;
-	for (auto &value : parameters) {
-		types.push_back(value.type());
-	}
-	auto entry = BindFunctionFromArguments(name, functions, types, error);
-	if (!entry.IsValid()) {
-		error.Throw();
-	}
-	auto candidate_function = functions.GetFunctionByOffset(entry.GetIndex());
-	// cast the input parameters
-	for (idx_t i = 0; i < parameters.size(); i++) {
-		auto target_type =
-		    i < candidate_function.arguments.size() ? candidate_function.arguments[i] : candidate_function.varargs;
-		parameters[i] = parameters[i].CastAs(context, target_type);
-	}
-	return entry;
-}
-
-vector<LogicalType> FunctionBinder::GetLogicalTypesFromExpressions(vector<unique_ptr<Expression>> &arguments) {
-	vector<LogicalType> types;
-	types.reserve(arguments.size());
-	for (auto &argument : arguments) {
-		types.push_back(ExpressionBinder::GetExpressionReturnType(*argument));
-	}
-	return types;
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
-                                          vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
-	auto types = GetLogicalTypesFromExpressions(arguments);
-	return BindFunction(name, functions, types, error);
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
-                                          vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
-	auto types = GetLogicalTypesFromExpressions(arguments);
-	return BindFunction(name, functions, types, error);
-}
-
-optional_idx FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
-                                          vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
-	auto types = GetLogicalTypesFromExpressions(arguments);
-	return BindFunction(name, functions, types, error);
-}
-
-enum class LogicalTypeComparisonResult : uint8_t { IDENTICAL_TYPE, TARGET_IS_ANY, DIFFERENT_TYPES };
-
-LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const LogicalType &target_type) {
-	if (target_type.id() == LogicalTypeId::ANY) {
-		return LogicalTypeComparisonResult::TARGET_IS_ANY;
-	}
-	if (source_type == target_type) {
-		return LogicalTypeComparisonResult::IDENTICAL_TYPE;
-	}
-	if (source_type.id() == LogicalTypeId::LIST && target_type.id() == LogicalTypeId::LIST) {
-		return RequiresCast(ListType::GetChildType(source_type), ListType::GetChildType(target_type));
-	}
-	if (source_type.id() == LogicalTypeId::ARRAY && target_type.id() == LogicalTypeId::ARRAY) {
-		return RequiresCast(ArrayType::GetChildType(source_type), ArrayType::GetChildType(target_type));
-	}
-	return LogicalTypeComparisonResult::DIFFERENT_TYPES;
-}
-
-bool TypeRequiresPrepare(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::ANY) {
-		return true;
-	}
-	if (type.id() == LogicalTypeId::LIST) {
-		return TypeRequiresPrepare(ListType::GetChildType(type));
-	}
-	return false;
-}
-
-LogicalType PrepareTypeForCastRecursive(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::ANY) {
-		return AnyType::GetTargetType(type);
-	}
-	if (type.id() == LogicalTypeId::LIST) {
-		return LogicalType::LIST(PrepareTypeForCastRecursive(ListType::GetChildType(type)));
-	}
-	return type;
-}
-
-void PrepareTypeForCast(LogicalType &type) {
-	if (!TypeRequiresPrepare(type)) {
-		return;
-	}
-	type = PrepareTypeForCastRecursive(type);
-}
-
-void FunctionBinder::CastToFunctionArguments(SimpleFunction &function, vector<unique_ptr<Expression>> &children) {
-	for (auto &arg : function.arguments) {
-		PrepareTypeForCast(arg);
-	}
-	PrepareTypeForCast(function.varargs);
-
-	for (idx_t i = 0; i < children.size(); i++) {
-		auto target_type = i < function.arguments.size() ? function.arguments[i] : function.varargs;
-		if (target_type.id() == LogicalTypeId::STRING_LITERAL || target_type.id() == LogicalTypeId::INTEGER_LITERAL) {
-			throw InternalException(
-			    "Function %s returned a STRING_LITERAL or INTEGER_LITERAL type - return an explicit type instead",
-			    function.name);
-		}
-		target_type.Verify();
-		// don't cast lambda children, they get removed before execution
-		if (children[i]->return_type.id() == LogicalTypeId::LAMBDA) {
-			continue;
-		}
-		// check if the type of child matches the type of function argument
-		// if not we need to add a cast
-		auto cast_result = RequiresCast(children[i]->return_type, target_type);
-		// except for one special case: if the function accepts ANY argument
-		// in that case we don't add a cast
-		if (cast_result == LogicalTypeComparisonResult::DIFFERENT_TYPES) {
-			children[i] = BoundCastExpression::AddCastToType(context, std::move(children[i]), target_type);
-		}
-	}
-}
-
-unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema, const string &name,
-                                                          vector<unique_ptr<Expression>> children, ErrorData &error,
-                                                          bool is_operator, optional_ptr<Binder> binder) {
-	// bind the function
-	auto &function =
-	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
-	D_ASSERT(function.type == CatalogType::SCALAR_FUNCTION_ENTRY);
-	return BindScalarFunction(function.Cast<ScalarFunctionCatalogEntry>(), std::move(children), error, is_operator,
-	                          binder);
-}
-
-unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogEntry &func,
-                                                          vector<unique_ptr<Expression>> children, ErrorData &error,
-                                                          bool is_operator, optional_ptr<Binder> binder) {
-	// bind the function
-	auto best_function = BindFunction(func.name, func.functions, children, error);
-	if (!best_function.IsValid()) {
-		return nullptr;
-	}
-
-	// found a matching function!
-	auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
-
-	// If any of the parameters are NULL, the function will just be replaced with a NULL constant.
-	// We try to give the NULL constant the correct type, but we have to do this without binding the function,
-	// because functions with DEFAULT_NULL_HANDLING should not have to deal with NULL inputs in their bind code.
-	// Some functions may have an invalid default return type, as they must be bound to infer the return type.
-	// In those cases, we default to SQLNULL.
-	const auto return_type_if_null =
-	    bound_function.return_type.IsComplete() ? bound_function.return_type : LogicalType::SQLNULL;
-	if (bound_function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
-		for (auto &child : children) {
-			if (child->return_type == LogicalTypeId::SQLNULL) {
-				return make_uniq<BoundConstantExpression>(Value(return_type_if_null));
-			}
-			if (!child->IsFoldable()) {
-				continue;
-			}
-			Value result;
-			if (!ExpressionExecutor::TryEvaluateScalar(context, *child, result)) {
-				continue;
-			}
-			if (result.IsNull()) {
-				return make_uniq<BoundConstantExpression>(Value(return_type_if_null));
-			}
-		}
-	}
-	return BindScalarFunction(bound_function, std::move(children), is_operator, binder);
-}
-
-bool RequiresCollationPropagation(const LogicalType &type) {
-	return type.id() == LogicalTypeId::VARCHAR && !type.HasAlias();
-}
-
-string ExtractCollation(const vector<unique_ptr<Expression>> &children) {
-	string collation;
-	for (auto &arg : children) {
-		if (!RequiresCollationPropagation(arg->return_type)) {
-			// not a varchar column
-			continue;
-		}
-		auto child_collation = StringType::GetCollation(arg->return_type);
-		if (collation.empty()) {
-			collation = child_collation;
-		} else if (!child_collation.empty() && collation != child_collation) {
-			throw BinderException("Cannot combine types with different collation!");
-		}
-	}
-	return collation;
-}
-
-void PropagateCollations(ClientContext &, ScalarFunction &bound_function, vector<unique_ptr<Expression>> &children) {
-	if (!RequiresCollationPropagation(bound_function.return_type)) {
-		// we only need to propagate if the function returns a varchar
-		return;
-	}
-	auto collation = ExtractCollation(children);
-	if (collation.empty()) {
-		// no collation to propagate
-		return;
-	}
-	// propagate the collation to the return type
-	auto collation_type = LogicalType::VARCHAR_COLLATION(std::move(collation));
-	bound_function.return_type = std::move(collation_type);
-}
-
-void PushCollations(ClientContext &context, ScalarFunction &bound_function, vector<unique_ptr<Expression>> &children,
-                    CollationType type) {
-	auto collation = ExtractCollation(children);
-	if (collation.empty()) {
-		// no collation to push
-		return;
-	}
-	// push collation into the return type if required
-	auto collation_type = LogicalType::VARCHAR_COLLATION(std::move(collation));
-	if (RequiresCollationPropagation(bound_function.return_type)) {
-		bound_function.return_type = collation_type;
-	}
-	// push collations to the children
-	for (auto &arg : children) {
-		if (RequiresCollationPropagation(arg->return_type)) {
-			// if this is a varchar type - propagate the collation
-			arg->return_type = collation_type;
-		}
-		// now push the actual collation handling
-		ExpressionBinder::PushCollation(context, arg, arg->return_type, type);
-	}
-}
-
-void HandleCollations(ClientContext &context, ScalarFunction &bound_function,
-                      vector<unique_ptr<Expression>> &children) {
-	switch (bound_function.collation_handling) {
-	case FunctionCollationHandling::IGNORE_COLLATIONS:
-		// explicitly ignoring collation handling
-		break;
-	case FunctionCollationHandling::PROPAGATE_COLLATIONS:
-		PropagateCollations(context, bound_function, children);
-		break;
-	case FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS:
-		// first propagate, then push collations to the children
-		PushCollations(context, bound_function, children, CollationType::COMBINABLE_COLLATIONS);
-		break;
-	default:
-		throw InternalException("Unrecognized collation handling");
-	}
-}
-
-unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunction bound_function,
-                                                          vector<unique_ptr<Expression>> children, bool is_operator,
-                                                          optional_ptr<Binder> binder) {
-	unique_ptr<FunctionData> bind_info;
-
-	if (bound_function.bind) {
-		bind_info = bound_function.bind(context, bound_function, children);
-	} else if (bound_function.bind_extended) {
-		if (!binder) {
-			throw InternalException("Function '%s' has a 'bind_extended' but the FunctionBinder was created without "
-			                        "a reference to a Binder",
-			                        bound_function.name);
-		}
-		ScalarFunctionBindInput bind_input(*binder);
-		bind_info = bound_function.bind_extended(bind_input, bound_function, children);
-	}
-
-	if (bound_function.get_modified_databases && binder) {
-		auto &properties = binder->GetStatementProperties();
-		FunctionModifiedDatabasesInput input(bind_info, properties);
-		bound_function.get_modified_databases(context, input);
-	}
-	HandleCollations(context, bound_function, children);
-
-	// check if we need to add casts to the children
-	CastToFunctionArguments(bound_function, children);
-
-	auto return_type = bound_function.return_type;
-	unique_ptr<Expression> result;
-	auto result_func = make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(bound_function),
-	                                                      std::move(children), std::move(bind_info), is_operator);
-	if (result_func->function.bind_expression) {
-		// if a bind_expression callback is registered - call it and emit the resulting expression
-		FunctionBindExpressionInput input(context, result_func->bind_info.get(), *result_func);
-		result = result_func->function.bind_expression(input);
-	}
-	if (!result) {
-		result = std::move(result_func);
-	}
-	return result;
-}
-
-unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(AggregateFunction bound_function,
-                                                                           vector<unique_ptr<Expression>> children,
-                                                                           unique_ptr<Expression> filter,
-                                                                           AggregateType aggr_type) {
-	unique_ptr<FunctionData> bind_info;
-	if (bound_function.bind) {
-		bind_info = bound_function.bind(context, bound_function, children);
-		// we may have lost some arguments in the bind
-		children.resize(MinValue(bound_function.arguments.size(), children.size()));
-	}
-
-	// check if we need to add casts to the children
-	CastToFunctionArguments(bound_function, children);
-
-	return make_uniq<BoundAggregateExpression>(std::move(bound_function), std::move(children), std::move(filter),
-	                                           std::move(bind_info), aggr_type);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/function_list.cpp b/src/duckdb/src/function/function_list.cpp
deleted file mode 100644
index 70d869703..000000000
--- a/src/duckdb/src/function/function_list.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#include "duckdb/function/function_list.hpp"
-
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
-#include "duckdb/function/scalar/date_functions.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/function/scalar/list_functions.hpp"
-#include "duckdb/function/scalar/map_functions.hpp"
-#include "duckdb/function/scalar/operator_functions.hpp"
-#include "duckdb/function/scalar/sequence_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/struct_functions.hpp"
-#include "duckdb/function/scalar/system_functions.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-
-namespace duckdb {
-
-// Scalar Function
-#define DUCKDB_SCALAR_FUNCTION_BASE(_PARAM, _NAME)                                                                     \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, _PARAM::GetFunction, nullptr, nullptr, nullptr }
-#define DUCKDB_SCALAR_FUNCTION(_PARAM)       DUCKDB_SCALAR_FUNCTION_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_SCALAR_FUNCTION_ALIAS(_PARAM) DUCKDB_SCALAR_FUNCTION_BASE(_PARAM::ALIAS, _PARAM::Name)
-// Scalar Function Set
-#define DUCKDB_SCALAR_FUNCTION_SET_BASE(_PARAM, _NAME)                                                                 \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, nullptr, _PARAM::GetFunctions, nullptr, nullptr }
-#define DUCKDB_SCALAR_FUNCTION_SET(_PARAM)       DUCKDB_SCALAR_FUNCTION_SET_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_SCALAR_FUNCTION_SET_ALIAS(_PARAM) DUCKDB_SCALAR_FUNCTION_SET_BASE(_PARAM::ALIAS, _PARAM::Name)
-// Aggregate Function
-#define DUCKDB_AGGREGATE_FUNCTION_BASE(_PARAM, _NAME)                                                                  \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, nullptr, nullptr, _PARAM::GetFunction, nullptr }
-#define DUCKDB_AGGREGATE_FUNCTION(_PARAM)       DUCKDB_AGGREGATE_FUNCTION_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_AGGREGATE_FUNCTION_ALIAS(_PARAM) DUCKDB_AGGREGATE_FUNCTION_BASE(_PARAM::ALIAS, _PARAM::Name)
-// Aggregate Function Set
-#define DUCKDB_AGGREGATE_FUNCTION_SET_BASE(_PARAM, _NAME)                                                              \
-	{ _NAME, _PARAM::Parameters, _PARAM::Description, _PARAM::Example, nullptr, nullptr, nullptr, _PARAM::GetFunctions }
-#define DUCKDB_AGGREGATE_FUNCTION_SET(_PARAM)       DUCKDB_AGGREGATE_FUNCTION_SET_BASE(_PARAM, _PARAM::Name)
-#define DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(_PARAM) DUCKDB_AGGREGATE_FUNCTION_SET_BASE(_PARAM::ALIAS, _PARAM::Name)
-#define FINAL_FUNCTION                                                                                                 \
-	{ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }
-
-// this list is generated by scripts/generate_functions.py
-static const StaticFunctionDefinition function[] = {
-	DUCKDB_SCALAR_FUNCTION(NotLikeFun),
-	DUCKDB_SCALAR_FUNCTION(NotILikeFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OperatorModuloFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OperatorMultiplyFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OperatorAddFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OperatorSubtractFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OperatorFloatDivideFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OperatorIntegerDivideFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUbigintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUintegerFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUsmallintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUtinyintFun),
-	DUCKDB_SCALAR_FUNCTION(InternalCompressStringHugeintFun),
-	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUbigintFun),
-	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUintegerFun),
-	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUsmallintFun),
-	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUtinyintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralBigintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralHugeintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralIntegerFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralSmallintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralUbigintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralUhugeintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralUintegerFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressIntegralUsmallintFun),
-	DUCKDB_SCALAR_FUNCTION_SET(InternalDecompressStringFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(AddFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(AnyValueFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(ArbitraryFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayCatFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayConcatFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayContainsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayExtractFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayHasFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayIndexofFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ArrayLengthFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayPositionFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayResizeFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArraySelectFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayWhereFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayZipFun),
-	DUCKDB_SCALAR_FUNCTION_SET(BitLengthFun),
-	DUCKDB_SCALAR_FUNCTION(CombineFun),
-	DUCKDB_SCALAR_FUNCTION(ConcatFun),
-	DUCKDB_SCALAR_FUNCTION(ConcatWsFun),
-	DUCKDB_SCALAR_FUNCTION(ConstantOrNullFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ContainsFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(CountFun),
-	DUCKDB_AGGREGATE_FUNCTION(CountStarFun),
-	DUCKDB_SCALAR_FUNCTION(CreateSortKeyFun),
-	DUCKDB_SCALAR_FUNCTION(CurrvalFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(DivideFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(EndsWithFun),
-	DUCKDB_SCALAR_FUNCTION(ErrorFun),
-	DUCKDB_SCALAR_FUNCTION(FinalizeFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(FirstFun),
-	DUCKDB_SCALAR_FUNCTION(GetVariableFun),
-	DUCKDB_SCALAR_FUNCTION(IlikeEscapeFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(LastFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(LcaseFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(LenFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LengthFun),
-	DUCKDB_SCALAR_FUNCTION_SET(LengthGraphemeFun),
-	DUCKDB_SCALAR_FUNCTION(LikeEscapeFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListCatFun),
-	DUCKDB_SCALAR_FUNCTION(ListConcatFun),
-	DUCKDB_SCALAR_FUNCTION(ListContainsFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListElementFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListExtractFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListHasFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListIndexofFun),
-	DUCKDB_SCALAR_FUNCTION(ListPositionFun),
-	DUCKDB_SCALAR_FUNCTION_SET(ListResizeFun),
-	DUCKDB_SCALAR_FUNCTION(ListSelectFun),
-	DUCKDB_SCALAR_FUNCTION(ListWhereFun),
-	DUCKDB_SCALAR_FUNCTION(ListZipFun),
-	DUCKDB_SCALAR_FUNCTION(LowerFun),
-	DUCKDB_SCALAR_FUNCTION(MapContainsFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(MaxFun),
-	DUCKDB_SCALAR_FUNCTION_SET(MD5Fun),
-	DUCKDB_SCALAR_FUNCTION_SET(MD5NumberFun),
-	DUCKDB_AGGREGATE_FUNCTION_SET(MinFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ModFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(MultiplyFun),
-	DUCKDB_SCALAR_FUNCTION(NextvalFun),
-	DUCKDB_SCALAR_FUNCTION(NFCNormalizeFun),
-	DUCKDB_SCALAR_FUNCTION(NotIlikeEscapeFun),
-	DUCKDB_SCALAR_FUNCTION(NotLikeEscapeFun),
-	DUCKDB_SCALAR_FUNCTION_SET(OctetLengthFun),
-	DUCKDB_SCALAR_FUNCTION(PrefixFun),
-	DUCKDB_SCALAR_FUNCTION(RegexpEscapeFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RegexpExtractFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RegexpExtractAllFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RegexpFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RegexpMatchesFun),
-	DUCKDB_SCALAR_FUNCTION_SET(RegexpReplaceFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(RegexpSplitToArrayFun),
-	DUCKDB_SCALAR_FUNCTION(RowFun),
-	DUCKDB_SCALAR_FUNCTION_SET(SHA1Fun),
-	DUCKDB_SCALAR_FUNCTION_SET(SHA256Fun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(SplitFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(StrSplitFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(StrSplitRegexFun),
-	DUCKDB_SCALAR_FUNCTION_SET(StrfTimeFun),
-	DUCKDB_SCALAR_FUNCTION(StringSplitFun),
-	DUCKDB_SCALAR_FUNCTION_SET(StringSplitRegexFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(StringToArrayFun),
-	DUCKDB_SCALAR_FUNCTION(StripAccentsFun),
-	DUCKDB_SCALAR_FUNCTION(StrlenFun),
-	DUCKDB_SCALAR_FUNCTION_SET(StrpTimeFun),
-	DUCKDB_SCALAR_FUNCTION(StructConcatFun),
-	DUCKDB_SCALAR_FUNCTION_SET(StructExtractFun),
-	DUCKDB_SCALAR_FUNCTION_SET(StructExtractAtFun),
-	DUCKDB_SCALAR_FUNCTION(StructPackFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(SubstrFun),
-	DUCKDB_SCALAR_FUNCTION_SET(SubstringFun),
-	DUCKDB_SCALAR_FUNCTION_SET(SubstringGraphemeFun),
-	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(SubtractFun),
-	DUCKDB_SCALAR_FUNCTION(SuffixFun),
-	DUCKDB_SCALAR_FUNCTION_SET(TryStrpTimeFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(UcaseFun),
-	DUCKDB_SCALAR_FUNCTION(UpperFun),
-	DUCKDB_SCALAR_FUNCTION(ConcatOperatorFun),
-	DUCKDB_SCALAR_FUNCTION(LikeFun),
-	DUCKDB_SCALAR_FUNCTION(ILikeFun),
-	DUCKDB_SCALAR_FUNCTION(GlobPatternFun),
-	FINAL_FUNCTION
-};
-
-const StaticFunctionDefinition *FunctionList::GetInternalFunctionList() {
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/function_set.cpp b/src/duckdb/src/function/function_set.cpp
deleted file mode 100644
index cf48c14e4..000000000
--- a/src/duckdb/src/function/function_set.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/function_binder.hpp"
-
-namespace duckdb {
-
-ScalarFunctionSet::ScalarFunctionSet() : FunctionSet("") {
-}
-
-ScalarFunctionSet::ScalarFunctionSet(string name) : FunctionSet(std::move(name)) {
-}
-
-ScalarFunctionSet::ScalarFunctionSet(ScalarFunction fun) : FunctionSet(std::move(fun.name)) {
-	functions.push_back(std::move(fun));
-}
-
-ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
-	ErrorData error;
-	FunctionBinder binder(context);
-	auto index = binder.BindFunction(name, *this, arguments, error);
-	if (!index.IsValid()) {
-		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
-		                        error.Message());
-	}
-	return GetFunctionByOffset(index.GetIndex());
-}
-
-AggregateFunctionSet::AggregateFunctionSet() : FunctionSet("") {
-}
-
-AggregateFunctionSet::AggregateFunctionSet(string name) : FunctionSet(std::move(name)) {
-}
-
-AggregateFunctionSet::AggregateFunctionSet(AggregateFunction fun) : FunctionSet(std::move(fun.name)) {
-	functions.push_back(std::move(fun));
-}
-
-AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &context,
-                                                               const vector<LogicalType> &arguments) {
-	ErrorData error;
-	FunctionBinder binder(context);
-	auto index = binder.BindFunction(name, *this, arguments, error);
-	if (!index.IsValid()) {
-		// check if the arguments are a prefix of any of the arguments
-		// this is used for functions such as quantile or string_agg that delete part of their arguments during bind
-		// FIXME: we should come up with a better solution here
-		for (auto &func : functions) {
-			if (arguments.size() >= func.arguments.size()) {
-				continue;
-			}
-			bool is_prefix = true;
-			for (idx_t k = 0; k < arguments.size(); k++) {
-				if (arguments[k].id() != func.arguments[k].id()) {
-					is_prefix = false;
-					break;
-				}
-			}
-			if (is_prefix) {
-				return func;
-			}
-		}
-		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
-		                        error.Message());
-	}
-	return GetFunctionByOffset(index.GetIndex());
-}
-
-TableFunctionSet::TableFunctionSet(string name) : FunctionSet(std::move(name)) {
-}
-
-TableFunctionSet::TableFunctionSet(TableFunction fun) : FunctionSet(std::move(fun.name)) {
-	functions.push_back(std::move(fun));
-}
-
-TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
-	ErrorData error;
-	FunctionBinder binder(context);
-	auto index = binder.BindFunction(name, *this, arguments, error);
-	if (!index.IsValid()) {
-		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
-		                        error.Message());
-	}
-	return GetFunctionByOffset(index.GetIndex());
-}
-
-PragmaFunctionSet::PragmaFunctionSet(string name) : FunctionSet(std::move(name)) {
-}
-
-PragmaFunctionSet::PragmaFunctionSet(PragmaFunction fun) : FunctionSet(std::move(fun.name)) {
-	functions.push_back(std::move(fun));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/macro_function.cpp b/src/duckdb/src/function/macro_function.cpp
deleted file mode 100644
index d70150c88..000000000
--- a/src/duckdb/src/function/macro_function.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-
-#include "duckdb/function/macro_function.hpp"
-
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/scalar_macro_function.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-namespace duckdb {
-
-MacroFunction::MacroFunction(MacroType type) : type(type) {
-}
-
-string FormatMacroFunction(MacroFunction &function, const string &name) {
-	string result;
-	result = name + "(";
-	string parameters;
-	for (auto &param : function.parameters) {
-		if (!parameters.empty()) {
-			parameters += ", ";
-		}
-		parameters += param->Cast<ColumnRefExpression>().GetColumnName();
-	}
-	for (auto &named_param : function.default_parameters) {
-		if (!parameters.empty()) {
-			parameters += ", ";
-		}
-		parameters += named_param.first;
-		parameters += " := ";
-		parameters += named_param.second->ToString();
-	}
-	result += parameters + ")";
-	return result;
-}
-
-MacroBindResult MacroFunction::BindMacroFunction(const vector<unique_ptr<MacroFunction>> &functions, const string &name,
-                                                 FunctionExpression &function_expr,
-                                                 vector<unique_ptr<ParsedExpression>> &positionals,
-                                                 unordered_map<string, unique_ptr<ParsedExpression>> &defaults) {
-	// separate positional and default arguments
-	for (auto &arg : function_expr.children) {
-		if (!arg->GetAlias().empty()) {
-			// default argument
-			if (defaults.count(arg->GetAlias())) {
-				return MacroBindResult(StringUtil::Format("Duplicate default parameters %s!", arg->GetAlias()));
-			}
-			defaults[arg->GetAlias()] = std::move(arg);
-		} else if (!defaults.empty()) {
-			return MacroBindResult("Positional parameters cannot come after parameters with a default value!");
-		} else {
-			// positional argument
-			positionals.push_back(std::move(arg));
-		}
-	}
-
-	// check for each macro function if it matches the number of positional arguments
-	optional_idx result_idx;
-	for (idx_t function_idx = 0; function_idx < functions.size(); function_idx++) {
-		if (functions[function_idx]->parameters.size() == positionals.size()) {
-			// found a matching function
-			result_idx = function_idx;
-			break;
-		}
-	}
-	if (!result_idx.IsValid()) {
-		// no matching function found
-		string error;
-		if (functions.size() == 1) {
-			// we only have one function - print the old more detailed error message
-			auto &macro_def = *functions[0];
-			auto &parameters = macro_def.parameters;
-			error = StringUtil::Format("Macro function %s requires ", FormatMacroFunction(macro_def, name));
-			error += parameters.size() == 1 ? "a single positional argument"
-			                                : StringUtil::Format("%i positional arguments", parameters.size());
-			error += ", but ";
-			error += positionals.size() == 1 ? "a single positional argument was"
-			                                 : StringUtil::Format("%i positional arguments were", positionals.size());
-			error += " provided.";
-		} else {
-			// we have multiple functions - list all candidates
-			error += StringUtil::Format("Macro \"%s\" does not support %llu parameters.\n", name, positionals.size());
-			error += "Candidate macros:";
-			for (auto &function : functions) {
-				error += "\n\t" + FormatMacroFunction(*function, name);
-			}
-		}
-		return MacroBindResult(error);
-	}
-	// found a matching index - check if the default values exist within the macro
-	auto macro_idx = result_idx.GetIndex();
-	auto &macro_def = *functions[macro_idx];
-	for (auto &default_val : defaults) {
-		auto entry = macro_def.default_parameters.find(default_val.first);
-		if (entry == macro_def.default_parameters.end()) {
-			string error =
-			    StringUtil::Format("Macro \"%s\" does not have a named parameter \"%s\"\n", name, default_val.first);
-			error += "\nMacro definition: " + FormatMacroFunction(macro_def, name);
-			return MacroBindResult(error);
-		}
-	}
-	// Add the default values for parameters that have defaults, that were not explicitly assigned to
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		auto &parameter_name = it->first;
-		auto &parameter_default = it->second;
-		if (!defaults.count(parameter_name)) {
-			// This parameter was not set yet, set it with the default value
-			defaults[parameter_name] = parameter_default->Copy();
-		}
-	}
-	return MacroBindResult(macro_idx);
-}
-
-void MacroFunction::CopyProperties(MacroFunction &other) const {
-	other.type = type;
-	for (auto &param : parameters) {
-		other.parameters.push_back(param->Copy());
-	}
-	for (auto &kv : default_parameters) {
-		other.default_parameters[kv.first] = kv.second->Copy();
-	}
-}
-
-string MacroFunction::ToSQL() const {
-	vector<string> param_strings;
-	for (auto &param : parameters) {
-		param_strings.push_back(param->ToString());
-	}
-	for (auto &named_param : default_parameters) {
-		param_strings.push_back(StringUtil::Format("%s := %s", named_param.first, named_param.second->ToString()));
-	}
-	return StringUtil::Format("(%s) AS ", StringUtil::Join(param_strings, ", "));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/pragma/pragma_functions.cpp b/src/duckdb/src/function/pragma/pragma_functions.cpp
deleted file mode 100644
index 635828066..000000000
--- a/src/duckdb/src/function/pragma/pragma_functions.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/function/pragma/pragma_functions.hpp"
-
-#include "duckdb/common/enums/output_type.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/logging/http_logger.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-
-#include <cctype>
-
-namespace duckdb {
-
-static void PragmaEnableProfilingStatement(ClientContext &context, const FunctionParameters &parameters) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_profiler = true;
-	config.emit_profiler_output = true;
-}
-
-void RegisterEnableProfiling(BuiltinFunctions &set) {
-	PragmaFunctionSet functions("");
-	functions.AddFunction(PragmaFunction::PragmaStatement(string(), PragmaEnableProfilingStatement));
-
-	set.AddFunction("enable_profile", functions);
-	set.AddFunction("enable_profiling", functions);
-}
-
-static void PragmaDisableProfiling(ClientContext &context, const FunctionParameters &parameters) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_profiler = false;
-}
-
-static void PragmaEnableProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_progress_bar = true;
-}
-
-static void PragmaDisableProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_progress_bar = false;
-}
-
-static void PragmaEnablePrintProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).print_progress_bar = true;
-}
-
-static void PragmaDisablePrintProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).print_progress_bar = false;
-}
-
-static void PragmaEnableVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).query_verification_enabled = true;
-	ClientConfig::GetConfig(context).verify_serializer = true;
-}
-
-static void PragmaDisableVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).query_verification_enabled = false;
-	ClientConfig::GetConfig(context).verify_serializer = false;
-}
-
-static void PragmaVerifySerializer(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_serializer = true;
-}
-
-static void PragmaDisableVerifySerializer(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_serializer = false;
-}
-
-static void PragmaEnableExternalVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_external = true;
-}
-
-static void PragmaDisableExternalVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_external = false;
-}
-
-static void PragmaEnableFetchRowVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_fetch_row = true;
-}
-
-static void PragmaDisableFetchRowVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_fetch_row = false;
-}
-
-static void PragmaEnableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_parallelism = true;
-}
-
-static void PragmaForceCheckpoint(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).options.force_checkpoint = true;
-}
-
-static void PragmaDisableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_parallelism = false;
-}
-
-static void PragmaEnableObjectCache(ClientContext &context, const FunctionParameters &parameters) {
-}
-
-static void PragmaDisableObjectCache(ClientContext &context, const FunctionParameters &parameters) {
-}
-
-static void PragmaEnableCheckpointOnShutdown(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).options.checkpoint_on_shutdown = true;
-}
-
-static void PragmaDisableCheckpointOnShutdown(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).options.checkpoint_on_shutdown = false;
-}
-
-static void PragmaEnableOptimizer(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_optimizer = true;
-}
-
-static void PragmaDisableOptimizer(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_optimizer = false;
-}
-
-void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
-	RegisterEnableProfiling(set);
-
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_profile", PragmaDisableProfiling));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_profiling", PragmaDisableProfiling));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_verification", PragmaEnableVerification));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verification", PragmaDisableVerification));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("verify_external", PragmaEnableExternalVerification));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_external", PragmaDisableExternalVerification));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("verify_fetch_row", PragmaEnableFetchRowVerification));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_fetch_row", PragmaDisableFetchRowVerification));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("verify_serializer", PragmaVerifySerializer));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_serializer", PragmaDisableVerifySerializer));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("verify_parallelism", PragmaEnableForceParallelism));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_parallelism", PragmaDisableForceParallelism));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_object_cache", PragmaEnableObjectCache));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_object_cache", PragmaDisableObjectCache));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_optimizer", PragmaEnableOptimizer));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_optimizer", PragmaDisableOptimizer));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("force_checkpoint", PragmaForceCheckpoint));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_progress_bar", PragmaEnableProgressBar));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_progress_bar", PragmaDisableProgressBar));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_print_progress_bar", PragmaEnablePrintProgressBar));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_print_progress_bar", PragmaDisablePrintProgressBar));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_checkpoint_on_shutdown", PragmaEnableCheckpointOnShutdown));
-	set.AddFunction(
-	    PragmaFunction::PragmaStatement("disable_checkpoint_on_shutdown", PragmaDisableCheckpointOnShutdown));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/pragma/pragma_queries.cpp b/src/duckdb/src/function/pragma/pragma_queries.cpp
deleted file mode 100644
index 66dd6ace7..000000000
--- a/src/duckdb/src/function/pragma/pragma_queries.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/pragma/pragma_functions.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/statement/export_statement.hpp"
-
-namespace duckdb {
-
-string PragmaTableInfo(ClientContext &context, const FunctionParameters &parameters) {
-	return StringUtil::Format("SELECT * FROM pragma_table_info(%s);",
-	                          KeywordHelper::WriteQuoted(parameters.values[0].ToString(), '\''));
-}
-
-string PragmaShowTables() {
-	// clang-format off
-	return R"EOF(
-	with "tables" as
-	(
-		SELECT table_name as "name"
-		FROM duckdb_tables
-		where in_search_path(database_name, schema_name)
-	), "views" as
-	(
-		SELECT view_name as "name"
-		FROM duckdb_views
-		where in_search_path(database_name, schema_name)
-	), db_objects as
-	(
-		SELECT "name" FROM "tables"
-		UNION ALL
-		SELECT "name" FROM "views"
-	)
-	SELECT "name"
-	FROM db_objects
-	ORDER BY "name";)EOF";
-	// clang-format on
-}
-
-string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
-	return PragmaShowTables();
-}
-
-string PragmaShowTablesExpanded() {
-	return R"(
-	SELECT
-		t.database_name AS database,
-		t.schema_name AS schema,
-		t.table_name AS name,
-		LIST(c.column_name order by c.column_index) AS column_names,
-		LIST(c.data_type order by c.column_index) AS column_types,
-		FIRST(t.temporary) AS temporary,
-	FROM duckdb_tables t
-	JOIN duckdb_columns c
-	USING (table_oid)
-	GROUP BY database, schema, name
-
-	UNION ALL
-
-	SELECT
-		v.database_name AS database,
-		v.schema_name AS schema,
-		v.view_name AS name,
-		LIST(c.column_name order by c.column_index) AS column_names,
-		LIST(c.data_type order by c.column_index) AS column_types,
-		FIRST(v.temporary) AS temporary,
-	FROM duckdb_views v
-	JOIN duckdb_columns c
-	ON (v.view_oid=c.table_oid)
-	GROUP BY database, schema, name
-
-	ORDER BY database, schema, name
-	)";
-}
-
-string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
-	return PragmaShowTablesExpanded();
-}
-
-string PragmaShowDatabases() {
-	return "SELECT database_name FROM duckdb_databases() WHERE NOT internal ORDER BY database_name;";
-}
-
-string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
-	return PragmaShowDatabases();
-}
-
-string PragmaShowVariables() {
-	return "SELECT * FROM duckdb_variables() ORDER BY name";
-}
-string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_last_profiling_output() JOIN pragma_detailed_profiling_output() ON "
-	       "(pragma_last_profiling_output.operator_id);";
-}
-
-string PragmaDatabaseList(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_database_list;";
-}
-
-string PragmaCollations(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_collations() ORDER BY 1;";
-}
-
-string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT function_name AS name, upper(function_type) AS type, parameter_types AS parameters, varargs, "
-	       "return_type, has_side_effects AS side_effects"
-	       " FROM duckdb_functions()"
-	       " WHERE function_type IN ('scalar', 'aggregate')"
-	       " ORDER BY 1;";
-}
-
-string PragmaShow(const string &table_name) {
-	return StringUtil::Format("SELECT * FROM pragma_show(%s);", KeywordHelper::WriteQuoted(table_name, '\''));
-}
-
-string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
-	return PragmaShow(parameters.values[0].ToString());
-}
-
-string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_version();";
-}
-
-string PragmaExtensionVersions(ClientContext &context, const FunctionParameters &parameters) {
-	return "select extension_name, extension_version, install_mode, installed_from from duckdb_extensions() where "
-	       "installed";
-}
-
-string PragmaPlatform(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_platform();";
-}
-
-string PragmaImportDatabase(ClientContext &context, const FunctionParameters &parameters) {
-	auto &fs = FileSystem::GetFileSystem(context);
-
-	string final_query;
-	// read the "schema.sql" and "load.sql" files
-	vector<string> files = {"schema.sql", "load.sql"};
-	for (auto &file : files) {
-		auto file_path = fs.JoinPath(parameters.values[0].ToString(), file);
-		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ);
-		auto fsize = fs.GetFileSize(*handle);
-		auto buffer = make_unsafe_uniq_array<char>(UnsafeNumericCast<size_t>(fsize));
-		fs.Read(*handle, buffer.get(), fsize);
-		auto query = string(buffer.get(), UnsafeNumericCast<uint32_t>(fsize));
-		// Replace the placeholder with the path provided to IMPORT
-		if (file == "load.sql") {
-			Parser parser;
-			parser.ParseQuery(query);
-			auto copy_statements = std::move(parser.statements);
-			query.clear();
-			for (auto &statement_p : copy_statements) {
-				D_ASSERT(statement_p->type == StatementType::COPY_STATEMENT);
-				auto &statement = statement_p->Cast<CopyStatement>();
-				auto &info = *statement.info;
-				auto file_name = fs.ExtractName(info.file_path);
-				info.file_path = fs.JoinPath(parameters.values[0].ToString(), file_name);
-				query += statement.ToString() + ";";
-			}
-		}
-		final_query += query;
-	}
-	return final_query;
-}
-
-string PragmaCopyDatabase(ClientContext &context, const FunctionParameters &parameters) {
-	string copy_stmt = "COPY FROM DATABASE ";
-	copy_stmt += KeywordHelper::WriteOptionallyQuoted(parameters.values[0].ToString());
-	copy_stmt += " TO ";
-	copy_stmt += KeywordHelper::WriteOptionallyQuoted(parameters.values[1].ToString());
-	string final_query;
-	final_query += copy_stmt + " (SCHEMA);\n";
-	final_query += copy_stmt + " (DATA);";
-	return final_query;
-}
-
-string PragmaDatabaseSize(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_database_size();";
-}
-
-string PragmaStorageInfo(ClientContext &context, const FunctionParameters &parameters) {
-	return StringUtil::Format("SELECT * FROM pragma_storage_info('%s');", parameters.values[0].ToString());
-}
-
-string PragmaMetadataInfo(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_metadata_info();";
-}
-
-string PragmaUserAgent(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_user_agent()";
-}
-
-void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(PragmaFunction::PragmaCall("table_info", PragmaTableInfo, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaCall("storage_info", PragmaStorageInfo, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaCall("metadata_info", PragmaMetadataInfo, {}));
-	set.AddFunction(PragmaFunction::PragmaStatement("show_tables", PragmaShowTables));
-	set.AddFunction(PragmaFunction::PragmaStatement("show_tables_expanded", PragmaShowTablesExpanded));
-	set.AddFunction(PragmaFunction::PragmaStatement("show_databases", PragmaShowDatabases));
-	set.AddFunction(PragmaFunction::PragmaStatement("database_list", PragmaDatabaseList));
-	set.AddFunction(PragmaFunction::PragmaStatement("collations", PragmaCollations));
-	set.AddFunction(PragmaFunction::PragmaCall("show", PragmaShow, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaStatement("version", PragmaVersion));
-	set.AddFunction(PragmaFunction::PragmaStatement("extension_versions", PragmaExtensionVersions));
-	set.AddFunction(PragmaFunction::PragmaStatement("platform", PragmaPlatform));
-	set.AddFunction(PragmaFunction::PragmaStatement("database_size", PragmaDatabaseSize));
-	set.AddFunction(PragmaFunction::PragmaStatement("functions", PragmaFunctionsQuery));
-	set.AddFunction(PragmaFunction::PragmaCall("import_database", PragmaImportDatabase, {LogicalType::VARCHAR}));
-	set.AddFunction(
-	    PragmaFunction::PragmaCall("copy_database", PragmaCopyDatabase, {LogicalType::VARCHAR, LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaStatement("all_profiling_output", PragmaAllProfiling));
-	set.AddFunction(PragmaFunction::PragmaStatement("user_agent", PragmaUserAgent));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/pragma_function.cpp b/src/duckdb/src/function/pragma_function.cpp
deleted file mode 100644
index 531cdfb43..000000000
--- a/src/duckdb/src/function/pragma_function.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/function/pragma_function.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-PragmaFunction::PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
-                               vector<LogicalType> arguments, LogicalType varargs)
-    : SimpleNamedParameterFunction(std::move(name), std::move(arguments), std::move(varargs)), type(pragma_type),
-      query(query), function(function) {
-}
-
-PragmaFunction PragmaFunction::PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,
-                                          LogicalType varargs) {
-	return PragmaFunction(name, PragmaType::PRAGMA_CALL, query, nullptr, std::move(arguments), std::move(varargs));
-}
-
-PragmaFunction PragmaFunction::PragmaCall(const string &name, pragma_function_t function, vector<LogicalType> arguments,
-                                          LogicalType varargs) {
-	return PragmaFunction(name, PragmaType::PRAGMA_CALL, nullptr, function, std::move(arguments), std::move(varargs));
-}
-
-PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_query_t query) {
-	vector<LogicalType> types;
-	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, query, nullptr, std::move(types), LogicalType::INVALID);
-}
-
-PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_function_t function) {
-	vector<LogicalType> types;
-	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, nullptr, function, std::move(types),
-	                      LogicalType::INVALID);
-}
-
-string PragmaFunction::ToString() const {
-	switch (type) {
-	case PragmaType::PRAGMA_STATEMENT:
-		return StringUtil::Format("PRAGMA %s", name);
-	case PragmaType::PRAGMA_CALL: {
-		return StringUtil::Format("PRAGMA %s", SimpleNamedParameterFunction::ToString());
-	}
-	default:
-		return "UNKNOWN";
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/register_function_list.cpp b/src/duckdb/src/function/register_function_list.cpp
deleted file mode 100644
index 1aeebbbbb..000000000
--- a/src/duckdb/src/function/register_function_list.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/catalog/default/default_types.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/function_list.hpp"
-#include "duckdb/function/register_function_list_helper.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-
-namespace duckdb {
-
-template <class T>
-static void FillExtraInfo(const StaticFunctionDefinition &function, T &info) {
-	info.internal = true;
-	FillFunctionDescriptions(function, info);
-}
-
-static void RegisterFunctionList(Catalog &catalog, CatalogTransaction transaction,
-                                 const StaticFunctionDefinition *functions) {
-	for (idx_t i = 0; functions[i].name; i++) {
-		auto &function = functions[i];
-		if (function.get_function || function.get_function_set) {
-			// scalar function
-			ScalarFunctionSet result;
-			if (function.get_function) {
-				result.AddFunction(function.get_function());
-			} else {
-				result = function.get_function_set();
-			}
-			result.name = function.name;
-			CreateScalarFunctionInfo info(result);
-			FillExtraInfo(function, info);
-			catalog.CreateFunction(transaction, info);
-		} else if (function.get_aggregate_function || function.get_aggregate_function_set) {
-			// aggregate function
-			AggregateFunctionSet result;
-			if (function.get_aggregate_function) {
-				result.AddFunction(function.get_aggregate_function());
-			} else {
-				result = function.get_aggregate_function_set();
-			}
-			result.name = function.name;
-			CreateAggregateFunctionInfo info(result);
-			FillExtraInfo(function, info);
-			catalog.CreateFunction(transaction, info);
-		} else {
-			throw InternalException("Do not know how to register function of this type");
-		}
-	}
-}
-
-void FunctionList::RegisterFunctions(Catalog &catalog, CatalogTransaction transaction) {
-	RegisterFunctionList(catalog, transaction, FunctionList::GetInternalFunctionList());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp b/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp
deleted file mode 100644
index 78410a59f..000000000
--- a/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
-#include "duckdb/function/scalar/compressed_materialization_utils.hpp"
-
-namespace duckdb {
-
-static string IntegralCompressFunctionName(const LogicalType &result_type) {
-	return StringUtil::Format("__internal_compress_integral_%s",
-	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
-}
-
-template <class INPUT_TYPE, class RESULT_TYPE>
-struct TemplatedIntegralCompress {
-	static inline RESULT_TYPE Operation(const INPUT_TYPE &input, const INPUT_TYPE &min_val) {
-		D_ASSERT(min_val <= input);
-		return UnsafeNumericCast<RESULT_TYPE>(input - min_val);
-	}
-};
-
-template <class RESULT_TYPE>
-struct TemplatedIntegralCompress<hugeint_t, RESULT_TYPE> {
-	static inline RESULT_TYPE Operation(const hugeint_t &input, const hugeint_t &min_val) {
-		D_ASSERT(min_val <= input);
-		return UnsafeNumericCast<RESULT_TYPE>((input - min_val).lower);
-	}
-};
-
-template <class RESULT_TYPE>
-struct TemplatedIntegralCompress<uhugeint_t, RESULT_TYPE> {
-	static inline RESULT_TYPE Operation(const uhugeint_t &input, const uhugeint_t &min_val) {
-		D_ASSERT(min_val <= input);
-		return UnsafeNumericCast<RESULT_TYPE>((input - min_val).lower);
-	}
-};
-
-template <class INPUT_TYPE, class RESULT_TYPE>
-static void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	D_ASSERT(args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR);
-	const auto min_val = ConstantVector::GetData<INPUT_TYPE>(args.data[1])[0];
-	UnaryExecutor::Execute<INPUT_TYPE, RESULT_TYPE>(
-	    args.data[0], result, args.size(),
-	    [&](const INPUT_TYPE &input) {
-		    return TemplatedIntegralCompress<INPUT_TYPE, RESULT_TYPE>::Operation(input, min_val);
-	    },
-	    FunctionErrors::CANNOT_ERROR);
-}
-
-template <class INPUT_TYPE, class RESULT_TYPE>
-static scalar_function_t GetIntegralCompressFunction(const LogicalType &input_type, const LogicalType &result_type) {
-	return IntegralCompressFunction<INPUT_TYPE, RESULT_TYPE>;
-}
-
-template <class INPUT_TYPE>
-static scalar_function_t GetIntegralCompressFunctionResultSwitch(const LogicalType &input_type,
-                                                                 const LogicalType &result_type) {
-	switch (result_type.id()) {
-	case LogicalTypeId::UTINYINT:
-		return GetIntegralCompressFunction<INPUT_TYPE, uint8_t>(input_type, result_type);
-	case LogicalTypeId::USMALLINT:
-		return GetIntegralCompressFunction<INPUT_TYPE, uint16_t>(input_type, result_type);
-	case LogicalTypeId::UINTEGER:
-		return GetIntegralCompressFunction<INPUT_TYPE, uint32_t>(input_type, result_type);
-	case LogicalTypeId::UBIGINT:
-		return GetIntegralCompressFunction<INPUT_TYPE, uint64_t>(input_type, result_type);
-	default:
-		throw InternalException("Unexpected result type in GetIntegralCompressFunctionResultSwitch");
-	}
-}
-
-static scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalType &input_type,
-                                                                const LogicalType &result_type) {
-	switch (input_type.id()) {
-	case LogicalTypeId::SMALLINT:
-		return GetIntegralCompressFunctionResultSwitch<int16_t>(input_type, result_type);
-	case LogicalTypeId::INTEGER:
-		return GetIntegralCompressFunctionResultSwitch<int32_t>(input_type, result_type);
-	case LogicalTypeId::BIGINT:
-		return GetIntegralCompressFunctionResultSwitch<int64_t>(input_type, result_type);
-	case LogicalTypeId::HUGEINT:
-		return GetIntegralCompressFunctionResultSwitch<hugeint_t>(input_type, result_type);
-	case LogicalTypeId::USMALLINT:
-		return GetIntegralCompressFunctionResultSwitch<uint16_t>(input_type, result_type);
-	case LogicalTypeId::UINTEGER:
-		return GetIntegralCompressFunctionResultSwitch<uint32_t>(input_type, result_type);
-	case LogicalTypeId::UBIGINT:
-		return GetIntegralCompressFunctionResultSwitch<uint64_t>(input_type, result_type);
-	case LogicalTypeId::UHUGEINT:
-		return GetIntegralCompressFunctionResultSwitch<uhugeint_t>(input_type, result_type);
-	default:
-		throw InternalException("Unexpected input type in GetIntegralCompressFunctionInputSwitch");
-	}
-}
-
-static string IntegralDecompressFunctionName(const LogicalType &result_type) {
-	return StringUtil::Format("__internal_decompress_integral_%s",
-	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
-}
-
-template <class INPUT_TYPE, class RESULT_TYPE>
-struct TemplatedIntegralDecompress {
-	static inline RESULT_TYPE Operation(const INPUT_TYPE &input, const RESULT_TYPE &min_val) {
-		return min_val + UnsafeNumericCast<RESULT_TYPE, INPUT_TYPE>(input);
-	}
-};
-
-template <class INPUT_TYPE>
-struct TemplatedIntegralDecompress<INPUT_TYPE, hugeint_t> {
-	static inline hugeint_t Operation(const INPUT_TYPE &input, const hugeint_t &min_val) {
-		return min_val + hugeint_t(0, input);
-	}
-};
-
-template <class INPUT_TYPE>
-struct TemplatedIntegralDecompress<INPUT_TYPE, uhugeint_t> {
-	static inline uhugeint_t Operation(const INPUT_TYPE &input, const uhugeint_t &min_val) {
-		return min_val + uhugeint_t(0, input);
-	}
-};
-
-template <class INPUT_TYPE, class RESULT_TYPE>
-static void IntegralDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	D_ASSERT(args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(args.data[1].GetType() == result.GetType());
-	const auto min_val = ConstantVector::GetData<RESULT_TYPE>(args.data[1])[0];
-	UnaryExecutor::Execute<INPUT_TYPE, RESULT_TYPE>(
-	    args.data[0], result, args.size(),
-	    [&](const INPUT_TYPE &input) {
-		    return TemplatedIntegralDecompress<INPUT_TYPE, RESULT_TYPE>::Operation(input, min_val);
-	    },
-	    FunctionErrors::CANNOT_ERROR);
-}
-
-template <class INPUT_TYPE, class RESULT_TYPE>
-static scalar_function_t GetIntegralDecompressFunction(const LogicalType &input_type, const LogicalType &result_type) {
-	return IntegralDecompressFunction<INPUT_TYPE, RESULT_TYPE>;
-}
-
-template <class INPUT_TYPE>
-static scalar_function_t GetIntegralDecompressFunctionResultSwitch(const LogicalType &input_type,
-                                                                   const LogicalType &result_type) {
-	switch (result_type.id()) {
-	case LogicalTypeId::SMALLINT:
-		return GetIntegralDecompressFunction<INPUT_TYPE, int16_t>(input_type, result_type);
-	case LogicalTypeId::INTEGER:
-		return GetIntegralDecompressFunction<INPUT_TYPE, int32_t>(input_type, result_type);
-	case LogicalTypeId::BIGINT:
-		return GetIntegralDecompressFunction<INPUT_TYPE, int64_t>(input_type, result_type);
-	case LogicalTypeId::HUGEINT:
-		return GetIntegralDecompressFunction<INPUT_TYPE, hugeint_t>(input_type, result_type);
-	case LogicalTypeId::USMALLINT:
-		return GetIntegralDecompressFunction<INPUT_TYPE, uint16_t>(input_type, result_type);
-	case LogicalTypeId::UINTEGER:
-		return GetIntegralDecompressFunction<INPUT_TYPE, uint32_t>(input_type, result_type);
-	case LogicalTypeId::UBIGINT:
-		return GetIntegralDecompressFunction<INPUT_TYPE, uint64_t>(input_type, result_type);
-	case LogicalTypeId::UHUGEINT:
-		return GetIntegralDecompressFunction<INPUT_TYPE, uhugeint_t>(input_type, result_type);
-	default:
-		throw InternalException("Unexpected input type in GetIntegralDecompressFunctionSetSwitch");
-	}
-}
-
-static scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalType &input_type,
-                                                                  const LogicalType &result_type) {
-	switch (input_type.id()) {
-	case LogicalTypeId::UTINYINT:
-		return GetIntegralDecompressFunctionResultSwitch<uint8_t>(input_type, result_type);
-	case LogicalTypeId::USMALLINT:
-		return GetIntegralDecompressFunctionResultSwitch<uint16_t>(input_type, result_type);
-	case LogicalTypeId::UINTEGER:
-		return GetIntegralDecompressFunctionResultSwitch<uint32_t>(input_type, result_type);
-	case LogicalTypeId::UBIGINT:
-		return GetIntegralDecompressFunctionResultSwitch<uint64_t>(input_type, result_type);
-	default:
-		throw InternalException("Unexpected result type in GetIntegralDecompressFunctionInputSwitch");
-	}
-}
-
-static void CMIntegralSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                const ScalarFunction &function) {
-	serializer.WriteProperty(100, "arguments", function.arguments);
-	serializer.WriteProperty(101, "return_type", function.return_type);
-}
-
-template <scalar_function_t (*GET_FUNCTION)(const LogicalType &, const LogicalType &)>
-unique_ptr<FunctionData> CMIntegralDeserialize(Deserializer &deserializer, ScalarFunction &function) {
-	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
-	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
-	function.function = GET_FUNCTION(function.arguments[0], return_type);
-	return nullptr;
-}
-
-ScalarFunction CMIntegralCompressFun::GetFunction(const LogicalType &input_type, const LogicalType &result_type) {
-	ScalarFunction result(IntegralCompressFunctionName(result_type), {input_type, input_type}, result_type,
-	                      GetIntegralCompressFunctionInputSwitch(input_type, result_type), CMUtils::Bind);
-	result.serialize = CMIntegralSerialize;
-	result.deserialize = CMIntegralDeserialize<GetIntegralCompressFunctionInputSwitch>;
-	return result;
-}
-
-static ScalarFunctionSet GetIntegralCompressFunctionSet(const LogicalType &result_type) {
-	ScalarFunctionSet set(IntegralCompressFunctionName(result_type));
-	for (const auto &input_type : LogicalType::Integral()) {
-		if (GetTypeIdSize(result_type.InternalType()) < GetTypeIdSize(input_type.InternalType())) {
-			set.AddFunction(CMIntegralCompressFun::GetFunction(input_type, result_type));
-		}
-	}
-	return set;
-}
-
-ScalarFunction CMIntegralDecompressFun::GetFunction(const LogicalType &input_type, const LogicalType &result_type) {
-	ScalarFunction result(IntegralDecompressFunctionName(result_type), {input_type, result_type}, result_type,
-	                      GetIntegralDecompressFunctionInputSwitch(input_type, result_type), CMUtils::Bind);
-	result.serialize = CMIntegralSerialize;
-	result.deserialize = CMIntegralDeserialize<GetIntegralDecompressFunctionInputSwitch>;
-	return result;
-}
-
-static ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &result_type) {
-	ScalarFunctionSet set(IntegralDecompressFunctionName(result_type));
-	for (const auto &input_type : CMUtils::IntegralTypes()) {
-		if (GetTypeIdSize(result_type.InternalType()) > GetTypeIdSize(input_type.InternalType())) {
-			set.AddFunction(CMIntegralDecompressFun::GetFunction(input_type, result_type));
-		}
-	}
-	return set;
-}
-
-ScalarFunctionSet InternalCompressIntegralUtinyintFun::GetFunctions() {
-	return GetIntegralCompressFunctionSet(LogicalType(LogicalTypeId::UTINYINT));
-}
-
-ScalarFunctionSet InternalCompressIntegralUsmallintFun::GetFunctions() {
-	return GetIntegralCompressFunctionSet(LogicalType(LogicalTypeId::USMALLINT));
-}
-
-ScalarFunctionSet InternalCompressIntegralUintegerFun::GetFunctions() {
-	return GetIntegralCompressFunctionSet(LogicalType(LogicalTypeId::UINTEGER));
-}
-
-ScalarFunctionSet InternalCompressIntegralUbigintFun::GetFunctions() {
-	return GetIntegralCompressFunctionSet(LogicalType(LogicalTypeId::UBIGINT));
-}
-
-ScalarFunctionSet InternalDecompressIntegralSmallintFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::SMALLINT));
-}
-
-ScalarFunctionSet InternalDecompressIntegralIntegerFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::INTEGER));
-}
-
-ScalarFunctionSet InternalDecompressIntegralBigintFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::BIGINT));
-}
-
-ScalarFunctionSet InternalDecompressIntegralHugeintFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::HUGEINT));
-}
-
-ScalarFunctionSet InternalDecompressIntegralUsmallintFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::USMALLINT));
-}
-
-ScalarFunctionSet InternalDecompressIntegralUintegerFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::UINTEGER));
-}
-
-ScalarFunctionSet InternalDecompressIntegralUbigintFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::UBIGINT));
-}
-
-ScalarFunctionSet InternalDecompressIntegralUhugeintFun::GetFunctions() {
-	return GetIntegralDecompressFunctionSet(LogicalType(LogicalTypeId::UHUGEINT));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp b/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp
deleted file mode 100644
index d1d0734d1..000000000
--- a/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp
+++ /dev/null
@@ -1,268 +0,0 @@
-#include "duckdb/common/bswap.hpp"
-#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
-#include "duckdb/function/scalar/compressed_materialization_utils.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-static string StringCompressFunctionName(const LogicalType &result_type) {
-	return StringUtil::Format("__internal_compress_string_%s",
-	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
-}
-
-template <idx_t LENGTH>
-static inline void TemplatedReverseMemCpy(const data_ptr_t &__restrict dest, const const_data_ptr_t &__restrict src) {
-	for (idx_t i = 0; i < LENGTH; i++) {
-		dest[i] = src[LENGTH - 1 - i];
-	}
-}
-
-static inline void ReverseMemCpy(const data_ptr_t &__restrict dest, const const_data_ptr_t &__restrict src,
-                                 const idx_t &length) {
-	for (idx_t i = 0; i < length; i++) {
-		dest[i] = src[length - 1 - i];
-	}
-}
-
-template <class RESULT_TYPE>
-static inline RESULT_TYPE StringCompressInternal(const string_t &input) {
-	RESULT_TYPE result;
-	const auto result_ptr = data_ptr_cast(&result);
-	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
-		TemplatedReverseMemCpy<sizeof(RESULT_TYPE)>(result_ptr, const_data_ptr_cast(input.GetPrefix()));
-	} else if (input.IsInlined()) {
-		static constexpr auto REMAINDER = sizeof(RESULT_TYPE) - string_t::INLINE_LENGTH;
-		TemplatedReverseMemCpy<string_t::INLINE_LENGTH>(result_ptr + REMAINDER, const_data_ptr_cast(input.GetPrefix()));
-		memset(result_ptr, '\0', REMAINDER);
-	} else {
-		const auto remainder = sizeof(RESULT_TYPE) - input.GetSize();
-		ReverseMemCpy(result_ptr + remainder, data_ptr_cast(input.GetPointer()), input.GetSize());
-		memset(result_ptr, '\0', remainder);
-	}
-	result_ptr[0] = UnsafeNumericCast<data_t>(input.GetSize());
-	return result;
-}
-
-template <class RESULT_TYPE>
-static inline RESULT_TYPE StringCompress(const string_t &input) {
-	D_ASSERT(input.GetSize() < sizeof(RESULT_TYPE));
-	return StringCompressInternal<RESULT_TYPE>(input);
-}
-
-template <class RESULT_TYPE>
-static inline RESULT_TYPE MiniStringCompress(const string_t &input) {
-	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
-		return UnsafeNumericCast<RESULT_TYPE>(input.GetSize() + *const_data_ptr_cast(input.GetPrefix()));
-	} else if (input.GetSize() == 0) {
-		return 0;
-	} else {
-		return UnsafeNumericCast<RESULT_TYPE>(input.GetSize() + *const_data_ptr_cast(input.GetPointer()));
-	}
-}
-
-template <>
-inline uint8_t StringCompress(const string_t &input) {
-	D_ASSERT(input.GetSize() <= sizeof(uint8_t));
-	return MiniStringCompress<uint8_t>(input);
-}
-
-template <class RESULT_TYPE>
-static void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::Execute<string_t, RESULT_TYPE>(args.data[0], result, args.size(), StringCompress<RESULT_TYPE>,
-	                                              FunctionErrors::CANNOT_ERROR);
-}
-
-template <class RESULT_TYPE>
-static scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
-	return StringCompressFunction<RESULT_TYPE>;
-}
-
-static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
-	switch (result_type.id()) {
-	case LogicalTypeId::UTINYINT:
-		return GetStringCompressFunction<uint8_t>(result_type);
-	case LogicalTypeId::USMALLINT:
-		return GetStringCompressFunction<uint16_t>(result_type);
-	case LogicalTypeId::UINTEGER:
-		return GetStringCompressFunction<uint32_t>(result_type);
-	case LogicalTypeId::UBIGINT:
-		return GetStringCompressFunction<uint64_t>(result_type);
-	case LogicalTypeId::HUGEINT:
-		return GetStringCompressFunction<hugeint_t>(result_type);
-	default:
-		throw InternalException("Unexpected type in GetStringCompressFunctionSwitch");
-	}
-}
-
-static string StringDecompressFunctionName() {
-	return "__internal_decompress_string";
-}
-
-struct StringDecompressLocalState : public FunctionLocalState {
-public:
-	explicit StringDecompressLocalState(ClientContext &context) : allocator(Allocator::Get(context)) {
-	}
-
-	static unique_ptr<FunctionLocalState> Init(ExpressionState &state, const BoundFunctionExpression &expr,
-	                                           FunctionData *bind_data) {
-		return make_uniq<StringDecompressLocalState>(state.GetContext());
-	}
-
-public:
-	ArenaAllocator allocator;
-};
-
-template <class INPUT_TYPE>
-static inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
-	const auto input_ptr = const_data_ptr_cast(&input);
-	string_t result(input_ptr[0]);
-	if (sizeof(INPUT_TYPE) <= string_t::INLINE_LENGTH) {
-		const auto result_ptr = data_ptr_cast(result.GetPrefixWriteable());
-		TemplatedReverseMemCpy<sizeof(INPUT_TYPE)>(result_ptr, input_ptr);
-		memset(result_ptr + sizeof(INPUT_TYPE) - 1, '\0', string_t::INLINE_LENGTH - sizeof(INPUT_TYPE) + 1);
-	} else if (result.GetSize() <= string_t::INLINE_LENGTH) {
-		static constexpr auto REMAINDER = sizeof(INPUT_TYPE) - string_t::INLINE_LENGTH;
-		const auto result_ptr = data_ptr_cast(result.GetPrefixWriteable());
-		TemplatedReverseMemCpy<string_t::INLINE_LENGTH>(result_ptr, input_ptr + REMAINDER);
-	} else {
-		result.SetPointer(char_ptr_cast(allocator.Allocate(sizeof(INPUT_TYPE))));
-		TemplatedReverseMemCpy<sizeof(INPUT_TYPE)>(data_ptr_cast(result.GetPointer()), input_ptr);
-		memcpy(result.GetPrefixWriteable(), result.GetPointer(), string_t::PREFIX_LENGTH);
-	}
-	return result;
-}
-
-template <class INPUT_TYPE>
-static inline string_t MiniStringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
-	if (input == 0) {
-		string_t result(uint32_t(0));
-		memset(result.GetPrefixWriteable(), '\0', string_t::INLINE_BYTES);
-		return result;
-	}
-
-	string_t result(1);
-	if (sizeof(INPUT_TYPE) <= string_t::INLINE_LENGTH) {
-		memset(result.GetPrefixWriteable(), '\0', string_t::INLINE_BYTES);
-		*data_ptr_cast(result.GetPrefixWriteable()) = input - 1;
-	} else {
-		result.SetPointer(char_ptr_cast(allocator.Allocate(1)));
-		*data_ptr_cast(result.GetPointer()) = input - 1;
-		memset(result.GetPrefixWriteable(), '\0', string_t::PREFIX_LENGTH);
-		*result.GetPrefixWriteable() = *result.GetPointer();
-	}
-	return result;
-}
-
-template <>
-inline string_t StringDecompress(const uint8_t &input, ArenaAllocator &allocator) {
-	return MiniStringDecompress<uint8_t>(input, allocator);
-}
-
-template <class INPUT_TYPE>
-static void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &allocator = ExecuteFunctionState::GetFunctionState(state)->Cast<StringDecompressLocalState>().allocator;
-	allocator.Reset();
-	UnaryExecutor::Execute<INPUT_TYPE, string_t>(
-	    args.data[0], result, args.size(),
-	    [&](const INPUT_TYPE &input) { return StringDecompress<INPUT_TYPE>(input, allocator); },
-	    FunctionErrors::CANNOT_ERROR);
-}
-
-template <class INPUT_TYPE>
-static scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
-	return StringDecompressFunction<INPUT_TYPE>;
-}
-
-static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
-	switch (input_type.id()) {
-	case LogicalTypeId::UTINYINT:
-		return GetStringDecompressFunction<uint8_t>(input_type);
-	case LogicalTypeId::USMALLINT:
-		return GetStringDecompressFunction<uint16_t>(input_type);
-	case LogicalTypeId::UINTEGER:
-		return GetStringDecompressFunction<uint32_t>(input_type);
-	case LogicalTypeId::UBIGINT:
-		return GetStringDecompressFunction<uint64_t>(input_type);
-	case LogicalTypeId::HUGEINT:
-		return GetStringDecompressFunction<hugeint_t>(input_type);
-	default:
-		throw InternalException("Unexpected type in GetStringDecompressFunctionSwitch");
-	}
-}
-
-static void CMStringCompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                      const ScalarFunction &function) {
-	serializer.WriteProperty(100, "arguments", function.arguments);
-	serializer.WriteProperty(101, "return_type", function.return_type);
-}
-
-unique_ptr<FunctionData> CMStringCompressDeserialize(Deserializer &deserializer, ScalarFunction &function) {
-	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
-	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
-	function.function = GetStringCompressFunctionSwitch(return_type);
-	return nullptr;
-}
-
-ScalarFunction CMStringCompressFun::GetFunction(const LogicalType &result_type) {
-	ScalarFunction result(StringCompressFunctionName(result_type), {LogicalType::VARCHAR}, result_type,
-	                      GetStringCompressFunctionSwitch(result_type), CMUtils::Bind);
-	result.serialize = CMStringCompressSerialize;
-	result.deserialize = CMStringCompressDeserialize;
-	return result;
-}
-
-static void CMStringDecompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                        const ScalarFunction &function) {
-	serializer.WriteProperty(100, "arguments", function.arguments);
-}
-
-unique_ptr<FunctionData> CMStringDecompressDeserialize(Deserializer &deserializer, ScalarFunction &function) {
-	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
-	function.function = GetStringDecompressFunctionSwitch(function.arguments[0]);
-	function.return_type = deserializer.Get<const LogicalType &>();
-	return nullptr;
-}
-
-ScalarFunction CMStringDecompressFun::GetFunction(const LogicalType &input_type) {
-	ScalarFunction result(StringDecompressFunctionName(), {input_type}, LogicalType::VARCHAR,
-	                      GetStringDecompressFunctionSwitch(input_type), CMUtils::Bind, nullptr, nullptr,
-	                      StringDecompressLocalState::Init);
-	result.serialize = CMStringDecompressSerialize;
-	result.deserialize = CMStringDecompressDeserialize;
-	return result;
-}
-
-static ScalarFunctionSet GetStringDecompressFunctionSet() {
-	ScalarFunctionSet set(StringDecompressFunctionName());
-	for (const auto &input_type : CMUtils::StringTypes()) {
-		set.AddFunction(CMStringDecompressFun::GetFunction(input_type));
-	}
-	return set;
-}
-
-ScalarFunction InternalCompressStringUtinyintFun::GetFunction() {
-	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UTINYINT));
-}
-
-ScalarFunction InternalCompressStringUsmallintFun::GetFunction() {
-	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::USMALLINT));
-}
-
-ScalarFunction InternalCompressStringUintegerFun::GetFunction() {
-	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UINTEGER));
-}
-
-ScalarFunction InternalCompressStringUbigintFun::GetFunction() {
-	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UBIGINT));
-}
-
-ScalarFunction InternalCompressStringHugeintFun::GetFunction() {
-	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::HUGEINT));
-}
-
-ScalarFunctionSet InternalDecompressStringFun::GetFunctions() {
-	return GetStringDecompressFunctionSet();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/compressed_materialization_utils.cpp b/src/duckdb/src/function/scalar/compressed_materialization_utils.cpp
deleted file mode 100644
index 2d09a7e7f..000000000
--- a/src/duckdb/src/function/scalar/compressed_materialization_utils.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/function/scalar/compressed_materialization_utils.hpp"
-
-namespace duckdb {
-
-const vector<LogicalType> CMUtils::IntegralTypes() {
-	return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT};
-}
-
-const vector<LogicalType> CMUtils::StringTypes() {
-	return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT,
-	        LogicalType::HUGEINT};
-}
-
-// LCOV_EXCL_START
-unique_ptr<FunctionData> CMUtils::Bind(ClientContext &context, ScalarFunction &bound_function,
-                                       vector<unique_ptr<Expression>> &arguments) {
-	throw BinderException("Compressed materialization functions are for internal use only!");
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/create_sort_key.cpp b/src/duckdb/src/function/scalar/create_sort_key.cpp
deleted file mode 100644
index 1cb2acdde..000000000
--- a/src/duckdb/src/function/scalar/create_sort_key.cpp
+++ /dev/null
@@ -1,1037 +0,0 @@
-#include "duckdb/function/create_sort_key.hpp"
-
-#include "duckdb/common/enums/order_type.hpp"
-#include "duckdb/common/radix.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-struct CreateSortKeyBindData : public FunctionData {
-	vector<OrderModifiers> modifiers;
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<CreateSortKeyBindData>();
-		return modifiers == other.modifiers;
-	}
-	unique_ptr<FunctionData> Copy() const override {
-		auto result = make_uniq<CreateSortKeyBindData>();
-		result->modifiers = modifiers;
-		return std::move(result);
-	}
-};
-
-unique_ptr<FunctionData> CreateSortKeyBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() % 2 != 0) {
-		throw BinderException(
-		    "Arguments to create_sort_key must be [key1, sort_specifier1, key2, sort_specifier2, ...]");
-	}
-	auto result = make_uniq<CreateSortKeyBindData>();
-	for (idx_t i = 1; i < arguments.size(); i += 2) {
-		if (!arguments[i]->IsFoldable()) {
-			throw BinderException("sort_specifier must be a constant value - but got %s", arguments[i]->ToString());
-		}
-
-		// Rebind to return a date if we are truncating that far
-		Value sort_specifier = ExpressionExecutor::EvaluateScalar(context, *arguments[i]);
-		if (sort_specifier.IsNull()) {
-			throw BinderException("sort_specifier cannot be NULL");
-		}
-		auto sort_specifier_str = sort_specifier.ToString();
-		result->modifiers.push_back(OrderModifiers::Parse(sort_specifier_str));
-	}
-	// push collations
-	for (idx_t i = 0; i < arguments.size(); i += 2) {
-		ExpressionBinder::PushCollation(context, arguments[i], arguments[i]->return_type);
-	}
-	// check if all types are constant
-	bool all_constant = true;
-	idx_t constant_size = 0;
-	for (idx_t i = 0; i < arguments.size(); i += 2) {
-		auto physical_type = arguments[i]->return_type.InternalType();
-		if (!TypeIsConstantSize(physical_type)) {
-			all_constant = false;
-		} else {
-			// we always add one byte for the validity
-			constant_size += GetTypeIdSize(physical_type) + 1;
-		}
-	}
-	if (all_constant) {
-		if (constant_size <= sizeof(int64_t)) {
-			bound_function.return_type = LogicalType::BIGINT;
-		}
-	}
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Operators
-//===--------------------------------------------------------------------===//
-struct SortKeyVectorData {
-	static constexpr data_t NULL_FIRST_BYTE = 1;
-	static constexpr data_t NULL_LAST_BYTE = 2;
-	static constexpr data_t STRING_DELIMITER = 0;
-	static constexpr data_t LIST_DELIMITER = 0;
-	static constexpr data_t BLOB_ESCAPE_CHARACTER = 1;
-
-	SortKeyVectorData(Vector &input, idx_t size, OrderModifiers modifiers) : vec(input) {
-		if (size != 0) {
-			input.ToUnifiedFormat(size, format);
-		}
-		this->size = size;
-
-		null_byte = NULL_FIRST_BYTE;
-		valid_byte = NULL_LAST_BYTE;
-		if (modifiers.null_type == OrderByNullType::NULLS_LAST) {
-			std::swap(null_byte, valid_byte);
-		}
-
-		// NULLS FIRST/NULLS LAST passed in by the user are only respected at the top level
-		// within nested types NULLS LAST/NULLS FIRST is dependent on ASC/DESC order instead
-		// don't blame me this is what Postgres does
-		auto child_null_type =
-		    modifiers.order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_LAST : OrderByNullType::NULLS_FIRST;
-		OrderModifiers child_modifiers(modifiers.order_type, child_null_type);
-		switch (input.GetType().InternalType()) {
-		case PhysicalType::STRUCT: {
-			auto &children = StructVector::GetEntries(input);
-			for (auto &child : children) {
-				child_data.push_back(make_uniq<SortKeyVectorData>(*child, size, child_modifiers));
-			}
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			auto &child_entry = ArrayVector::GetEntry(input);
-			auto array_size = ArrayType::GetSize(input.GetType());
-			child_data.push_back(make_uniq<SortKeyVectorData>(child_entry, size * array_size, child_modifiers));
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto &child_entry = ListVector::GetEntry(input);
-			auto child_size = size == 0 ? 0 : ListVector::GetListSize(input);
-			child_data.push_back(make_uniq<SortKeyVectorData>(child_entry, child_size, child_modifiers));
-			break;
-		}
-		default:
-			break;
-		}
-	}
-	// disable copy constructors
-	SortKeyVectorData(const SortKeyVectorData &other) = delete;
-	SortKeyVectorData &operator=(const SortKeyVectorData &) = delete;
-
-	void Initialize() {
-	}
-
-	PhysicalType GetPhysicalType() {
-		return vec.GetType().InternalType();
-	}
-
-	Vector &vec;
-	idx_t size;
-	UnifiedVectorFormat format;
-	vector<unique_ptr<SortKeyVectorData>> child_data;
-	data_t null_byte;
-	data_t valid_byte;
-};
-
-template <class T>
-struct SortKeyConstantOperator {
-	using TYPE = T;
-
-	static idx_t GetEncodeLength(TYPE input) {
-		return sizeof(T);
-	}
-
-	static idx_t Encode(data_ptr_t result, TYPE input) {
-		Radix::EncodeData<T>(result, input);
-		return sizeof(T);
-	}
-
-	static idx_t Decode(const_data_ptr_t input, Vector &result, idx_t result_idx, bool flip_bytes) {
-		auto result_data = FlatVector::GetData<TYPE>(result);
-		if (flip_bytes) {
-			// descending order - so flip bytes
-			data_t flipped_bytes[sizeof(T)];
-			for (idx_t b = 0; b < sizeof(T); b++) {
-				flipped_bytes[b] = ~input[b];
-			}
-			result_data[result_idx] = Radix::DecodeData<T>(flipped_bytes);
-		} else {
-			result_data[result_idx] = Radix::DecodeData<T>(input);
-		}
-		return sizeof(T);
-	}
-};
-
-struct SortKeyVarcharOperator {
-	using TYPE = string_t;
-
-	static idx_t GetEncodeLength(TYPE input) {
-		return input.GetSize() + 1;
-	}
-
-	static idx_t Encode(data_ptr_t result, TYPE input) {
-		auto input_data = const_data_ptr_cast(input.GetDataUnsafe());
-		auto input_size = input.GetSize();
-		for (idx_t r = 0; r < input_size; r++) {
-			result[r] = input_data[r] + 1;
-		}
-		result[input_size] = SortKeyVectorData::STRING_DELIMITER; // null-byte delimiter
-		return input_size + 1;
-	}
-
-	static idx_t Decode(const_data_ptr_t input, Vector &result, idx_t result_idx, bool flip_bytes) {
-		auto result_data = FlatVector::GetData<TYPE>(result);
-		// iterate until we encounter the string delimiter to figure out the string length
-		data_t string_delimiter = SortKeyVectorData::STRING_DELIMITER;
-		if (flip_bytes) {
-			string_delimiter = ~string_delimiter;
-		}
-		idx_t pos;
-		for (pos = 0; input[pos] != string_delimiter; pos++) {
-		}
-		idx_t str_len = pos;
-		// now allocate the string data and fill it with the decoded data
-		result_data[result_idx] = StringVector::EmptyString(result, str_len);
-		auto str_data = data_ptr_cast(result_data[result_idx].GetDataWriteable());
-		for (pos = 0; pos < str_len; pos++) {
-			if (flip_bytes) {
-				str_data[pos] = (~input[pos]) - 1;
-			} else {
-				str_data[pos] = input[pos] - 1;
-			}
-		}
-		result_data[result_idx].Finalize();
-		return pos + 1;
-	}
-};
-
-struct SortKeyBlobOperator {
-	using TYPE = string_t;
-
-	static idx_t GetEncodeLength(TYPE input) {
-		auto input_data = data_ptr_t(input.GetDataUnsafe());
-		auto input_size = input.GetSize();
-		idx_t escaped_characters = 0;
-		for (idx_t r = 0; r < input_size; r++) {
-			if (input_data[r] <= 1) {
-				// we escape both \x00 and \x01
-				escaped_characters++;
-			}
-		}
-		return input.GetSize() + escaped_characters + 1;
-	}
-
-	static idx_t Encode(data_ptr_t result, TYPE input) {
-		auto input_data = data_ptr_t(input.GetDataUnsafe());
-		auto input_size = input.GetSize();
-		idx_t result_offset = 0;
-		for (idx_t r = 0; r < input_size; r++) {
-			if (input_data[r] <= 1) {
-				// we escape both \x00 and \x01 with \x01
-				result[result_offset++] = SortKeyVectorData::BLOB_ESCAPE_CHARACTER;
-				result[result_offset++] = input_data[r];
-			} else {
-				result[result_offset++] = input_data[r];
-			}
-		}
-		result[result_offset++] = SortKeyVectorData::STRING_DELIMITER; // null-byte delimiter
-		return result_offset;
-	}
-
-	static idx_t Decode(const_data_ptr_t input, Vector &result, idx_t result_idx, bool flip_bytes) {
-		auto result_data = FlatVector::GetData<TYPE>(result);
-		// scan until we find the delimiter, keeping in mind escapes
-		data_t string_delimiter = SortKeyVectorData::STRING_DELIMITER;
-		data_t escape_character = SortKeyVectorData::BLOB_ESCAPE_CHARACTER;
-		if (flip_bytes) {
-			string_delimiter = ~string_delimiter;
-			escape_character = ~escape_character;
-		}
-		idx_t blob_len = 0;
-		idx_t pos;
-		for (pos = 0; input[pos] != string_delimiter; pos++) {
-			blob_len++;
-			if (input[pos] == escape_character) {
-				// escape character - skip the next byte
-				pos++;
-			}
-		}
-		// now allocate the blob data and fill it with the decoded data
-		result_data[result_idx] = StringVector::EmptyString(result, blob_len);
-		auto str_data = data_ptr_cast(result_data[result_idx].GetDataWriteable());
-		for (idx_t input_pos = 0, result_pos = 0; input_pos < pos; input_pos++) {
-			if (input[input_pos] == escape_character) {
-				// if we encounter an escape character - copy the NEXT byte
-				input_pos++;
-			}
-			if (flip_bytes) {
-				str_data[result_pos++] = ~input[input_pos];
-			} else {
-				str_data[result_pos++] = input[input_pos];
-			}
-		}
-		result_data[result_idx].Finalize();
-		return pos + 1;
-	}
-};
-
-struct SortKeyListEntry {
-	static bool IsArray() {
-		return false;
-	}
-
-	static list_entry_t GetListEntry(SortKeyVectorData &vector_data, idx_t idx) {
-		auto data = UnifiedVectorFormat::GetData<list_entry_t>(vector_data.format);
-		return data[idx];
-	}
-};
-
-struct SortKeyArrayEntry {
-	static bool IsArray() {
-		return true;
-	}
-
-	static list_entry_t GetListEntry(SortKeyVectorData &vector_data, idx_t idx) {
-		auto array_size = ArrayType::GetSize(vector_data.vec.GetType());
-		return list_entry_t(array_size * idx, array_size);
-	}
-};
-
-struct SortKeyChunk {
-	SortKeyChunk(idx_t start, idx_t end) : start(start), end(end), has_result_index(false) {
-	}
-	SortKeyChunk(idx_t start, idx_t end, idx_t result_index)
-	    : start(start), end(end), result_index(result_index), has_result_index(true) {
-	}
-
-	idx_t start;
-	idx_t end;
-	idx_t result_index;
-	bool has_result_index;
-
-	inline idx_t GetResultIndex(idx_t r) {
-		return has_result_index ? result_index : r;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Get Sort Key Length
-//===--------------------------------------------------------------------===//
-struct SortKeyLengthInfo {
-	explicit SortKeyLengthInfo(idx_t size) : constant_length(0) {
-		variable_lengths.resize(size, 0);
-	}
-
-	idx_t constant_length;
-	unsafe_vector<idx_t> variable_lengths;
-};
-
-static void GetSortKeyLengthRecursive(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyLengthInfo &result);
-
-template <class OP>
-void TemplatedGetSortKeyLength(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyLengthInfo &result) {
-	auto &format = vector_data.format;
-	auto data = UnifiedVectorFormat::GetData<typename OP::TYPE>(vector_data.format);
-	for (idx_t r = chunk.start; r < chunk.end; r++) {
-		auto idx = format.sel->get_index(r);
-		auto result_index = chunk.GetResultIndex(r);
-		result.variable_lengths[result_index]++; // every value is prefixed by a validity byte
-
-		if (!format.validity.RowIsValid(idx)) {
-			continue;
-		}
-		result.variable_lengths[result_index] += OP::GetEncodeLength(data[idx]);
-	}
-}
-
-void GetSortKeyLengthStruct(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyLengthInfo &result) {
-	for (idx_t r = chunk.start; r < chunk.end; r++) {
-		auto result_index = chunk.GetResultIndex(r);
-		result.variable_lengths[result_index]++; // every struct is prefixed by a validity byte
-	}
-	// now recursively call GetSortKeyLength on the child elements
-	for (auto &child_data : vector_data.child_data) {
-		GetSortKeyLengthRecursive(*child_data, chunk, result);
-	}
-}
-
-template <class OP>
-void GetSortKeyLengthList(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyLengthInfo &result) {
-	auto &child_data = vector_data.child_data[0];
-	for (idx_t r = chunk.start; r < chunk.end; r++) {
-		auto idx = vector_data.format.sel->get_index(r);
-		auto result_index = chunk.GetResultIndex(r);
-		result.variable_lengths[result_index]++; // every list is prefixed by a validity byte
-
-		if (!vector_data.format.validity.RowIsValid(idx)) {
-			if (!OP::IsArray()) {
-				// for arrays we need to fill in the child vector for all elements, even if the top-level array is NULL
-				continue;
-			}
-		}
-		auto list_entry = OP::GetListEntry(vector_data, idx);
-		// for each non-null list we have an "end of list" delimiter
-		result.variable_lengths[result_index]++;
-		if (list_entry.length > 0) {
-			// recursively call GetSortKeyLength for the children of this list
-			SortKeyChunk child_chunk(list_entry.offset, list_entry.offset + list_entry.length, result_index);
-			GetSortKeyLengthRecursive(*child_data, child_chunk, result);
-		}
-	}
-}
-
-static void GetSortKeyLengthRecursive(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyLengthInfo &result) {
-	auto physical_type = vector_data.GetPhysicalType();
-	// handle variable lengths
-	switch (physical_type) {
-	case PhysicalType::BOOL:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<bool>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<uint8_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::INT8:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<int8_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<uint16_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<int16_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<uint32_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<int32_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<uint64_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<int64_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<float>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<double>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<interval_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<uhugeint_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::INT128:
-		TemplatedGetSortKeyLength<SortKeyConstantOperator<hugeint_t>>(vector_data, chunk, result);
-		break;
-	case PhysicalType::VARCHAR:
-		if (vector_data.vec.GetType().id() == LogicalTypeId::VARCHAR) {
-			TemplatedGetSortKeyLength<SortKeyVarcharOperator>(vector_data, chunk, result);
-		} else {
-			TemplatedGetSortKeyLength<SortKeyBlobOperator>(vector_data, chunk, result);
-		}
-		break;
-	case PhysicalType::STRUCT:
-		GetSortKeyLengthStruct(vector_data, chunk, result);
-		break;
-	case PhysicalType::LIST:
-		GetSortKeyLengthList<SortKeyListEntry>(vector_data, chunk, result);
-		break;
-	case PhysicalType::ARRAY:
-		GetSortKeyLengthList<SortKeyArrayEntry>(vector_data, chunk, result);
-		break;
-	default:
-		throw NotImplementedException("Unsupported physical type %s in GetSortKeyLength", physical_type);
-	}
-}
-
-static void GetSortKeyLength(SortKeyVectorData &vector_data, SortKeyLengthInfo &result, SortKeyChunk chunk) {
-	// top-level method
-	auto physical_type = vector_data.GetPhysicalType();
-	if (TypeIsConstantSize(physical_type)) {
-		// every row is prefixed by a validity byte
-		result.constant_length += 1;
-		result.constant_length += GetTypeIdSize(physical_type);
-		return;
-	}
-	GetSortKeyLengthRecursive(vector_data, chunk, result);
-}
-
-static void GetSortKeyLength(SortKeyVectorData &vector_data, SortKeyLengthInfo &result) {
-	GetSortKeyLength(vector_data, result, SortKeyChunk(0, vector_data.size));
-}
-
-//===--------------------------------------------------------------------===//
-// Construct Sort Key
-//===--------------------------------------------------------------------===//
-struct SortKeyConstructInfo {
-	SortKeyConstructInfo(OrderModifiers modifiers_p, unsafe_vector<idx_t> &offsets, data_ptr_t *result_data)
-	    : modifiers(modifiers_p), offsets(offsets), result_data(result_data) {
-		flip_bytes = modifiers.order_type == OrderType::DESCENDING;
-	}
-
-	OrderModifiers modifiers;
-	unsafe_vector<idx_t> &offsets;
-	data_ptr_t *result_data;
-	bool flip_bytes;
-};
-
-static void ConstructSortKeyRecursive(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyConstructInfo &info);
-
-template <class OP>
-void TemplatedConstructSortKey(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyConstructInfo &info) {
-	auto data = UnifiedVectorFormat::GetData<typename OP::TYPE>(vector_data.format);
-	auto &offsets = info.offsets;
-	for (idx_t r = chunk.start; r < chunk.end; r++) {
-		auto result_index = chunk.GetResultIndex(r);
-		auto idx = vector_data.format.sel->get_index(r);
-		auto &offset = offsets[result_index];
-		auto result_ptr = info.result_data[result_index];
-		if (!vector_data.format.validity.RowIsValid(idx)) {
-			// NULL value - write the null byte and skip
-			result_ptr[offset++] = vector_data.null_byte;
-			continue;
-		}
-		// valid value - write the validity byte
-		result_ptr[offset++] = vector_data.valid_byte;
-		idx_t encode_len = OP::Encode(result_ptr + offset, data[idx]);
-		if (info.flip_bytes) {
-			// descending order - so flip bytes
-			for (idx_t b = offset; b < offset + encode_len; b++) {
-				result_ptr[b] = ~result_ptr[b];
-			}
-		}
-		offset += encode_len;
-	}
-}
-
-void ConstructSortKeyStruct(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyConstructInfo &info) {
-	bool list_of_structs = chunk.has_result_index;
-	// write the validity data of the struct
-	auto &offsets = info.offsets;
-	for (idx_t r = chunk.start; r < chunk.end; r++) {
-		auto result_index = chunk.GetResultIndex(r);
-		auto idx = vector_data.format.sel->get_index(r);
-		auto &offset = offsets[result_index];
-		auto result_ptr = info.result_data[result_index];
-		if (!vector_data.format.validity.RowIsValid(idx)) {
-			// NULL value - write the null byte and skip
-			result_ptr[offset++] = vector_data.null_byte;
-		} else {
-			// valid value - write the validity byte
-			result_ptr[offset++] = vector_data.valid_byte;
-		}
-		if (list_of_structs) {
-			// for a list of structs we need to write the child data for every iteration
-			// since the final layout needs to be
-			// [struct1][struct2][...]
-			for (auto &child : vector_data.child_data) {
-				SortKeyChunk child_chunk(r, r + 1, result_index);
-				ConstructSortKeyRecursive(*child, child_chunk, info);
-			}
-		}
-	}
-	if (!list_of_structs) {
-		for (auto &child : vector_data.child_data) {
-			ConstructSortKeyRecursive(*child, chunk, info);
-		}
-	}
-}
-
-template <class OP>
-void ConstructSortKeyList(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyConstructInfo &info) {
-	auto &offsets = info.offsets;
-	for (idx_t r = chunk.start; r < chunk.end; r++) {
-		auto result_index = chunk.GetResultIndex(r);
-		auto idx = vector_data.format.sel->get_index(r);
-		auto &offset = offsets[result_index];
-		auto result_ptr = info.result_data[result_index];
-		if (!vector_data.format.validity.RowIsValid(idx)) {
-			// NULL value - write the null byte and skip
-			result_ptr[offset++] = vector_data.null_byte;
-			if (!OP::IsArray()) {
-				// for arrays we always write the child elements - also if the top-level array is NULL
-				continue;
-			}
-		} else {
-			// valid value - write the validity byte
-			result_ptr[offset++] = vector_data.valid_byte;
-		}
-
-		auto list_entry = OP::GetListEntry(vector_data, idx);
-		// recurse and write the list elements
-		if (list_entry.length > 0) {
-			SortKeyChunk child_chunk(list_entry.offset, list_entry.offset + list_entry.length, result_index);
-			ConstructSortKeyRecursive(*vector_data.child_data[0], child_chunk, info);
-		}
-
-		// write the end-of-list delimiter
-		result_ptr[offset++] = static_cast<data_t>(info.flip_bytes ? ~SortKeyVectorData::LIST_DELIMITER
-		                                                           : SortKeyVectorData::LIST_DELIMITER);
-	}
-}
-
-static void ConstructSortKeyRecursive(SortKeyVectorData &vector_data, SortKeyChunk chunk, SortKeyConstructInfo &info) {
-	switch (vector_data.GetPhysicalType()) {
-	case PhysicalType::BOOL:
-		TemplatedConstructSortKey<SortKeyConstantOperator<bool>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedConstructSortKey<SortKeyConstantOperator<uint8_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::INT8:
-		TemplatedConstructSortKey<SortKeyConstantOperator<int8_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedConstructSortKey<SortKeyConstantOperator<uint16_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::INT16:
-		TemplatedConstructSortKey<SortKeyConstantOperator<int16_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedConstructSortKey<SortKeyConstantOperator<uint32_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::INT32:
-		TemplatedConstructSortKey<SortKeyConstantOperator<int32_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedConstructSortKey<SortKeyConstantOperator<uint64_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::INT64:
-		TemplatedConstructSortKey<SortKeyConstantOperator<int64_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedConstructSortKey<SortKeyConstantOperator<float>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedConstructSortKey<SortKeyConstantOperator<double>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedConstructSortKey<SortKeyConstantOperator<interval_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedConstructSortKey<SortKeyConstantOperator<uhugeint_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::INT128:
-		TemplatedConstructSortKey<SortKeyConstantOperator<hugeint_t>>(vector_data, chunk, info);
-		break;
-	case PhysicalType::VARCHAR:
-		if (vector_data.vec.GetType().id() == LogicalTypeId::VARCHAR) {
-			TemplatedConstructSortKey<SortKeyVarcharOperator>(vector_data, chunk, info);
-		} else {
-			TemplatedConstructSortKey<SortKeyBlobOperator>(vector_data, chunk, info);
-		}
-		break;
-	case PhysicalType::STRUCT:
-		ConstructSortKeyStruct(vector_data, chunk, info);
-		break;
-	case PhysicalType::LIST:
-		ConstructSortKeyList<SortKeyListEntry>(vector_data, chunk, info);
-		break;
-	case PhysicalType::ARRAY:
-		ConstructSortKeyList<SortKeyArrayEntry>(vector_data, chunk, info);
-		break;
-	default:
-		throw NotImplementedException("Unsupported type %s in ConstructSortKey", vector_data.vec.GetType());
-	}
-}
-
-static void ConstructSortKey(SortKeyVectorData &vector_data, SortKeyConstructInfo &info) {
-	ConstructSortKeyRecursive(vector_data, SortKeyChunk(0, vector_data.size), info);
-}
-
-static void PrepareSortData(Vector &result, idx_t size, SortKeyLengthInfo &key_lengths, data_ptr_t *data_pointers) {
-	switch (result.GetType().id()) {
-	case LogicalTypeId::BLOB: {
-		auto result_data = FlatVector::GetData<string_t>(result);
-		for (idx_t r = 0; r < size; r++) {
-			auto blob_size = key_lengths.variable_lengths[r] + key_lengths.constant_length;
-			result_data[r] = StringVector::EmptyString(result, blob_size);
-			data_pointers[r] = data_ptr_cast(result_data[r].GetDataWriteable());
-#ifdef DEBUG
-			memset(data_pointers[r], 0xFF, blob_size);
-#endif
-		}
-		break;
-	}
-	case LogicalTypeId::BIGINT: {
-		auto result_data = FlatVector::GetData<int64_t>(result);
-		for (idx_t r = 0; r < size; r++) {
-			result_data[r] = 0;
-			data_pointers[r] = data_ptr_cast(&result_data[r]);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unsupported key type for CreateSortKey");
-	}
-}
-
-static void FinalizeSortData(Vector &result, idx_t size) {
-	switch (result.GetType().id()) {
-	case LogicalTypeId::BLOB: {
-		auto result_data = FlatVector::GetData<string_t>(result);
-		// call Finalize on the result
-		for (idx_t r = 0; r < size; r++) {
-			result_data[r].Finalize();
-		}
-		break;
-	}
-	case LogicalTypeId::BIGINT: {
-		auto result_data = FlatVector::GetData<int64_t>(result);
-		for (idx_t r = 0; r < size; r++) {
-			result_data[r] = BSwap(result_data[r]);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unsupported key type for CreateSortKey");
-	}
-}
-
-static void CreateSortKeyInternal(vector<unique_ptr<SortKeyVectorData>> &sort_key_data,
-                                  const vector<OrderModifiers> &modifiers, Vector &result, idx_t row_count) {
-	// two phases
-	// a) get the length of the final sorted key
-	// b) allocate the sorted key and construct
-	// we do all of this in a vectorized manner
-	SortKeyLengthInfo key_lengths(row_count);
-	for (auto &vector_data : sort_key_data) {
-		GetSortKeyLength(*vector_data, key_lengths);
-	}
-	// allocate the empty sort keys
-	auto data_pointers = unique_ptr<data_ptr_t[]>(new data_ptr_t[row_count]);
-	PrepareSortData(result, row_count, key_lengths, data_pointers.get());
-
-	unsafe_vector<idx_t> offsets;
-	offsets.resize(row_count, 0);
-	// now construct the sort keys
-	for (idx_t c = 0; c < sort_key_data.size(); c++) {
-		SortKeyConstructInfo info(modifiers[c], offsets, data_pointers.get());
-		ConstructSortKey(*sort_key_data[c], info);
-	}
-	FinalizeSortData(result, row_count);
-}
-
-void CreateSortKeyHelpers::CreateSortKey(Vector &input, idx_t input_count, OrderModifiers order_modifier,
-                                         Vector &result) {
-	// prepare the sort key data
-	vector<OrderModifiers> modifiers {order_modifier};
-	vector<unique_ptr<SortKeyVectorData>> sort_key_data;
-	sort_key_data.push_back(make_uniq<SortKeyVectorData>(input, input_count, order_modifier));
-
-	CreateSortKeyInternal(sort_key_data, modifiers, result, input_count);
-}
-
-void CreateSortKeyHelpers::CreateSortKey(DataChunk &input, const vector<OrderModifiers> &modifiers, Vector &result) {
-	vector<unique_ptr<SortKeyVectorData>> sort_key_data;
-	D_ASSERT(modifiers.size() == input.ColumnCount());
-	for (idx_t r = 0; r < modifiers.size(); r++) {
-		sort_key_data.push_back(make_uniq<SortKeyVectorData>(input.data[r], input.size(), modifiers[r]));
-	}
-	CreateSortKeyInternal(sort_key_data, modifiers, result, input.size());
-}
-
-void CreateSortKeyHelpers::CreateSortKeyWithValidity(Vector &input, Vector &result, const OrderModifiers &modifiers,
-                                                     const idx_t count) {
-	CreateSortKey(input, count, modifiers, result);
-	UnifiedVectorFormat format;
-	input.ToUnifiedFormat(count, format);
-	auto &validity = FlatVector::Validity(result);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = format.sel->get_index(i);
-		if (!format.validity.RowIsValid(idx)) {
-			validity.SetInvalid(i);
-		}
-	}
-}
-
-static void CreateSortKeyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &bind_data = state.expr.Cast<BoundFunctionExpression>().bind_info->Cast<CreateSortKeyBindData>();
-
-	// prepare the sort key data
-	vector<unique_ptr<SortKeyVectorData>> sort_key_data;
-	for (idx_t c = 0; c < args.ColumnCount(); c += 2) {
-		sort_key_data.push_back(make_uniq<SortKeyVectorData>(args.data[c], args.size(), bind_data.modifiers[c / 2]));
-	}
-	CreateSortKeyInternal(sort_key_data, bind_data.modifiers, result, args.size());
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Decode Sort Key
-//===--------------------------------------------------------------------===//
-struct DecodeSortKeyVectorData {
-	DecodeSortKeyVectorData(const LogicalType &type, OrderModifiers modifiers)
-	    : flip_bytes(modifiers.order_type == OrderType::DESCENDING) {
-		null_byte = SortKeyVectorData::NULL_FIRST_BYTE;
-		valid_byte = SortKeyVectorData::NULL_LAST_BYTE;
-		if (modifiers.null_type == OrderByNullType::NULLS_LAST) {
-			std::swap(null_byte, valid_byte);
-		}
-
-		// NULLS FIRST/NULLS LAST passed in by the user are only respected at the top level
-		// within nested types NULLS LAST/NULLS FIRST is dependent on ASC/DESC order instead
-		// don't blame me this is what Postgres does
-		auto child_null_type =
-		    modifiers.order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_LAST : OrderByNullType::NULLS_FIRST;
-		OrderModifiers child_modifiers(modifiers.order_type, child_null_type);
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT: {
-			auto &children = StructType::GetChildTypes(type);
-			for (auto &child_type : children) {
-				child_data.emplace_back(child_type.second, child_modifiers);
-			}
-			break;
-		}
-		case PhysicalType::ARRAY: {
-			auto &child_type = ArrayType::GetChildType(type);
-			child_data.emplace_back(child_type, child_modifiers);
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto &child_type = ListType::GetChildType(type);
-			child_data.emplace_back(child_type, child_modifiers);
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	data_t null_byte;
-	data_t valid_byte;
-	vector<DecodeSortKeyVectorData> child_data;
-	bool flip_bytes;
-};
-
-struct DecodeSortKeyData {
-	explicit DecodeSortKeyData(string_t &sort_key)
-	    : data(const_data_ptr_cast(sort_key.GetData())), size(sort_key.GetSize()), position(0) {
-	}
-
-	const_data_ptr_t data;
-	idx_t size;
-	idx_t position;
-};
-
-void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
-                            idx_t result_idx);
-
-template <class OP>
-void TemplatedDecodeSortKey(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
-                            idx_t result_idx) {
-	auto validity_byte = decode_data.data[decode_data.position];
-	decode_data.position++;
-	if (validity_byte == vector_data.null_byte) {
-		// NULL value
-		FlatVector::Validity(result).SetInvalid(result_idx);
-		return;
-	}
-	idx_t increment = OP::Decode(decode_data.data + decode_data.position, result, result_idx, vector_data.flip_bytes);
-	decode_data.position += increment;
-}
-
-void DecodeSortKeyStruct(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
-                         idx_t result_idx) {
-	// check if the top-level is valid or not
-	auto validity_byte = decode_data.data[decode_data.position];
-	decode_data.position++;
-	if (validity_byte == vector_data.null_byte) {
-		// entire struct is NULL
-		// note that we still deserialize the children
-		FlatVector::Validity(result).SetInvalid(result_idx);
-	}
-	// recurse into children
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t c = 0; c < child_entries.size(); c++) {
-		auto &child_entry = child_entries[c];
-		DecodeSortKeyRecursive(decode_data, vector_data.child_data[c], *child_entry, result_idx);
-	}
-}
-
-void DecodeSortKeyList(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
-                       idx_t result_idx) {
-	// check if the top-level is valid or not
-	auto validity_byte = decode_data.data[decode_data.position];
-	decode_data.position++;
-	if (validity_byte == vector_data.null_byte) {
-		// entire list is NULL
-		FlatVector::Validity(result).SetInvalid(result_idx);
-		return;
-	}
-	// list is valid - decode child elements
-	// we don't know how many there will be
-	// decode child elements until we encounter the list delimiter
-	auto list_delimiter = SortKeyVectorData::LIST_DELIMITER;
-	if (vector_data.flip_bytes) {
-		list_delimiter = ~list_delimiter;
-	}
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	auto &child_vector = ListVector::GetEntry(result);
-	// get the current list size
-	auto start_list_size = ListVector::GetListSize(result);
-	auto new_list_size = start_list_size;
-	// loop until we find the list delimiter
-	while (decode_data.data[decode_data.position] != list_delimiter) {
-		// found a valid entry here - decode it
-		// first reserve space for it
-		new_list_size++;
-		ListVector::Reserve(result, new_list_size);
-
-		// now decode the entry
-		DecodeSortKeyRecursive(decode_data, vector_data.child_data[0], child_vector, new_list_size - 1);
-	}
-	// skip the list delimiter
-	decode_data.position++;
-	// set the list_entry_t information and update the list size
-	list_data[result_idx].length = new_list_size - start_list_size;
-	list_data[result_idx].offset = start_list_size;
-	ListVector::SetListSize(result, new_list_size);
-}
-
-void DecodeSortKeyArray(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
-                        idx_t result_idx) {
-	// check if the top-level is valid or not
-	auto validity_byte = decode_data.data[decode_data.position];
-	decode_data.position++;
-	if (validity_byte == vector_data.null_byte) {
-		// entire array is NULL
-		// note that we still read the child elements
-		FlatVector::Validity(result).SetInvalid(result_idx);
-	}
-	// array is valid - decode child elements
-	// arrays need to encode exactly array_size child elements
-	// however the decoded data still contains a list delimiter
-	// we use this delimiter to verify we successfully decoded the entire array
-	auto list_delimiter = SortKeyVectorData::LIST_DELIMITER;
-	if (vector_data.flip_bytes) {
-		list_delimiter = ~list_delimiter;
-	}
-	auto &child_vector = ArrayVector::GetEntry(result);
-	auto array_size = ArrayType::GetSize(result.GetType());
-
-	idx_t found_elements = 0;
-	auto child_start = array_size * result_idx;
-	// loop until we find the list delimiter
-	while (decode_data.data[decode_data.position] != list_delimiter) {
-		found_elements++;
-		if (found_elements > array_size) {
-			// error - found too many elements
-			break;
-		}
-		// now decode the entry
-		DecodeSortKeyRecursive(decode_data, vector_data.child_data[0], child_vector, child_start + found_elements - 1);
-	}
-	// skip the list delimiter
-	decode_data.position++;
-	if (found_elements != array_size) {
-		throw InvalidInputException("Failed to decode array - found %d elements but expected %d", found_elements,
-		                            array_size);
-	}
-}
-
-void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
-                            idx_t result_idx) {
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<bool>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<uint8_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::INT8:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<int8_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<uint16_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::INT16:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<int16_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<uint32_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::INT32:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<int32_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<uint64_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::INT64:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<int64_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<float>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<double>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<interval_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<uhugeint_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::INT128:
-		TemplatedDecodeSortKey<SortKeyConstantOperator<hugeint_t>>(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::VARCHAR:
-		if (result.GetType().id() == LogicalTypeId::VARCHAR) {
-			TemplatedDecodeSortKey<SortKeyVarcharOperator>(decode_data, vector_data, result, result_idx);
-		} else {
-			TemplatedDecodeSortKey<SortKeyBlobOperator>(decode_data, vector_data, result, result_idx);
-		}
-		break;
-	case PhysicalType::STRUCT:
-		DecodeSortKeyStruct(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::LIST:
-		DecodeSortKeyList(decode_data, vector_data, result, result_idx);
-		break;
-	case PhysicalType::ARRAY:
-		DecodeSortKeyArray(decode_data, vector_data, result, result_idx);
-		break;
-	default:
-		throw NotImplementedException("Unsupported type %s in DecodeSortKey", result.GetType());
-	}
-}
-
-void CreateSortKeyHelpers::DecodeSortKey(string_t sort_key, Vector &result, idx_t result_idx,
-                                         OrderModifiers modifiers) {
-	DecodeSortKeyVectorData sort_key_data(result.GetType(), modifiers);
-	DecodeSortKeyData decode_data(sort_key);
-	DecodeSortKeyRecursive(decode_data, sort_key_data, result, result_idx);
-}
-
-void CreateSortKeyHelpers::DecodeSortKey(string_t sort_key, DataChunk &result, idx_t result_idx,
-                                         const vector<OrderModifiers> &modifiers) {
-	DecodeSortKeyData decode_data(sort_key);
-	D_ASSERT(modifiers.size() == result.ColumnCount());
-	for (idx_t c = 0; c < result.ColumnCount(); c++) {
-		auto &vec = result.data[c];
-		DecodeSortKeyVectorData vector_data(vec.GetType(), modifiers[c]);
-		DecodeSortKeyRecursive(decode_data, vector_data, vec, result_idx);
-	}
-}
-
-ScalarFunction CreateSortKeyFun::GetFunction() {
-	ScalarFunction sort_key_function("create_sort_key", {LogicalType::ANY}, LogicalType::BLOB, CreateSortKeyFunction,
-	                                 CreateSortKeyBind);
-	sort_key_function.varargs = LogicalType::ANY;
-	sort_key_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return sort_key_function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/date/strftime.cpp b/src/duckdb/src/function/scalar/date/strftime.cpp
deleted file mode 100644
index 32222f191..000000000
--- a/src/duckdb/src/function/scalar/date/strftime.cpp
+++ /dev/null
@@ -1,333 +0,0 @@
-#include "duckdb/function/scalar/strftime_format.hpp"
-
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/function/scalar/date_functions.hpp"
-
-#include <cctype>
-#include <utility>
-
-namespace duckdb {
-
-struct StrfTimeBindData : public FunctionData {
-	explicit StrfTimeBindData(StrfTimeFormat format_p, string format_string_p, bool is_null)
-	    : format(std::move(format_p)), format_string(std::move(format_string_p)), is_null(is_null) {
-	}
-
-	StrfTimeFormat format;
-	string format_string;
-	bool is_null;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StrfTimeBindData>(format, format_string, is_null);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<StrfTimeBindData>();
-		return format_string == other.format_string;
-	}
-};
-
-template <bool REVERSED>
-static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	auto format_idx = REVERSED ? 0U : 1U;
-	auto &format_arg = arguments[format_idx];
-	if (format_arg->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!format_arg->IsFoldable()) {
-		throw InvalidInputException(*format_arg, "strftime format must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(context, *format_arg);
-	auto format_string = options_str.GetValue<string>();
-	StrfTimeFormat format;
-	bool is_null = options_str.IsNull();
-	if (!is_null) {
-		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-		if (!error.empty()) {
-			throw InvalidInputException(*format_arg, "Failed to parse format specifier %s: %s", format_string, error);
-		}
-	}
-	return make_uniq<StrfTimeBindData>(format, format_string, is_null);
-}
-
-template <bool REVERSED>
-static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
-
-	if (info.is_null) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertDateVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
-template <bool REVERSED>
-static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
-
-	if (info.is_null) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertTimestampVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
-template <bool REVERSED>
-static void StrfTimeFunctionTimestampNS(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
-
-	if (info.is_null) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertTimestampNSVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
-ScalarFunctionSet StrfTimeFun::GetFunctions() {
-	ScalarFunctionSet strftime("strftime");
-
-	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<false>, StrfTimeBindFunction<false>));
-	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<false>, StrfTimeBindFunction<false>));
-	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_NS, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestampNS<false>, StrfTimeBindFunction<false>));
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<true>, StrfTimeBindFunction<true>));
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<true>, StrfTimeBindFunction<true>));
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP_NS}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestampNS<true>, StrfTimeBindFunction<true>));
-	return strftime;
-}
-
-StrpTimeFormat::StrpTimeFormat() {
-}
-
-StrpTimeFormat::StrpTimeFormat(const string &format_string) {
-	if (format_string.empty()) {
-		return;
-	}
-	StrTimeFormat::ParseFormatSpecifier(format_string, *this);
-}
-
-struct StrpTimeBindData : public FunctionData {
-	StrpTimeBindData(const StrpTimeFormat &format, const string &format_string)
-	    : formats(1, format), format_strings(1, format_string) {
-	}
-
-	StrpTimeBindData(vector<StrpTimeFormat> formats_p, vector<string> format_strings_p)
-	    : formats(std::move(formats_p)), format_strings(std::move(format_strings_p)) {
-	}
-
-	vector<StrpTimeFormat> formats;
-	vector<string> format_strings;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StrpTimeBindData>(formats, format_strings);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<StrpTimeBindData>();
-		return format_strings == other.format_strings;
-	}
-};
-
-template <typename T>
-inline T StrpTimeResult(StrpTimeFormat::ParseResult &parsed) {
-	return parsed.ToTimestamp();
-}
-
-template <>
-inline timestamp_ns_t StrpTimeResult(StrpTimeFormat::ParseResult &parsed) {
-	return parsed.ToTimestampNS();
-}
-
-template <typename T>
-inline bool StrpTimeTryResult(StrpTimeFormat &format, string_t &input, T &result, string &error) {
-	return format.TryParseTimestamp(input, result, error);
-}
-
-template <>
-inline bool StrpTimeTryResult(StrpTimeFormat &format, string_t &input, timestamp_ns_t &result, string &error) {
-	return format.TryParseTimestampNS(input, result, error);
-}
-
-struct StrpTimeFunction {
-
-	template <typename T>
-	static void Parse(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
-
-		//	There is a bizarre situation where the format column is foldable but not constant
-		//	(i.e., the statistics tell us it has only one value)
-		//	We have to check whether that value is NULL
-		const auto count = args.size();
-		UnifiedVectorFormat format_unified;
-		args.data[1].ToUnifiedFormat(count, format_unified);
-
-		if (!format_unified.validity.RowIsValid(0)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		UnaryExecutor::Execute<string_t, T>(args.data[0], result, args.size(), [&](string_t input) {
-			StrpTimeFormat::ParseResult result;
-			for (auto &format : info.formats) {
-				if (format.Parse(input, result)) {
-					return StrpTimeResult<T>(result);
-				}
-			}
-			throw InvalidInputException(result.FormatError(input, info.formats[0].format_specifier));
-		});
-	}
-
-	template <typename T>
-	static void TryParse(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
-
-		if (args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR && ConstantVector::IsNull(args.data[1])) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-
-		UnaryExecutor::ExecuteWithNulls<string_t, T>(args.data[0], result, args.size(),
-		                                             [&](string_t input, ValidityMask &mask, idx_t idx) {
-			                                             T result;
-			                                             string error;
-			                                             for (auto &format : info.formats) {
-				                                             if (StrpTimeTryResult(format, input, result, error)) {
-					                                             return result;
-				                                             }
-			                                             }
-
-			                                             mask.SetInvalid(idx);
-			                                             return T();
-		                                             });
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		if (arguments[1]->HasParameter()) {
-			throw ParameterNotResolvedException();
-		}
-		if (!arguments[1]->IsFoldable()) {
-			throw InvalidInputException(*arguments[0], "strptime format must be a constant");
-		}
-		Value format_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		string format_string;
-		StrpTimeFormat format;
-		if (format_value.IsNull()) {
-			return make_uniq<StrpTimeBindData>(format, format_string);
-		} else if (format_value.type().id() == LogicalTypeId::VARCHAR) {
-			format_string = format_value.ToString();
-			format.format_specifier = format_string;
-			string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-			if (!error.empty()) {
-				throw InvalidInputException(*arguments[0], "Failed to parse format specifier %s: %s", format_string,
-				                            error);
-			}
-			if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
-				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-			} else if (format.HasFormatSpecifier(StrTimeSpecifier::NANOSECOND_PADDED)) {
-				bound_function.return_type = LogicalType::TIMESTAMP_NS;
-				if (bound_function.name == "strptime") {
-					bound_function.function = Parse<timestamp_ns_t>;
-				} else {
-					bound_function.function = TryParse<timestamp_ns_t>;
-				}
-			}
-			return make_uniq<StrpTimeBindData>(format, format_string);
-		} else if (format_value.type() == LogicalType::LIST(LogicalType::VARCHAR)) {
-			const auto &children = ListValue::GetChildren(format_value);
-			if (children.empty()) {
-				throw InvalidInputException(*arguments[0], "strptime format list must not be empty");
-			}
-			vector<string> format_strings;
-			vector<StrpTimeFormat> formats;
-			bool has_offset = false;
-			bool has_nanos = false;
-
-			for (const auto &child : children) {
-				format_string = child.ToString();
-				format.format_specifier = format_string;
-				string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-				if (!error.empty()) {
-					throw InvalidInputException(*arguments[0], "Failed to parse format specifier %s: %s", format_string,
-					                            error);
-				}
-				has_offset = has_offset || format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET);
-				has_nanos = has_nanos || format.HasFormatSpecifier(StrTimeSpecifier::NANOSECOND_PADDED);
-				format_strings.emplace_back(format_string);
-				formats.emplace_back(format);
-			}
-
-			if (has_offset) {
-				// If any format has UTC offsets, then we have to produce TSTZ
-				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-			} else if (has_nanos) {
-				// If any format has nanoseconds, then we have to produce TSNS
-				// unless there is an offset, in which case we produce
-				bound_function.return_type = LogicalType::TIMESTAMP_NS;
-				if (bound_function.name == "strptime") {
-					bound_function.function = Parse<timestamp_ns_t>;
-				} else {
-					bound_function.function = TryParse<timestamp_ns_t>;
-				}
-			}
-			return make_uniq<StrpTimeBindData>(formats, format_strings);
-		} else {
-			throw InvalidInputException(*arguments[0], "strptime format must be a string");
-		}
-	}
-};
-
-ScalarFunctionSet StrpTimeFun::GetFunctions() {
-	ScalarFunctionSet strptime("strptime");
-
-	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                          StrpTimeFunction::Parse<timestamp_t>, StrpTimeFunction::Bind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	BaseScalarFunction::SetReturnsError(fun);
-	strptime.AddFunction(fun);
-
-	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP,
-	                     StrpTimeFunction::Parse<timestamp_t>, StrpTimeFunction::Bind);
-	BaseScalarFunction::SetReturnsError(fun);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	strptime.AddFunction(fun);
-	return strptime;
-}
-
-ScalarFunctionSet TryStrpTimeFun::GetFunctions() {
-	ScalarFunctionSet try_strptime("try_strptime");
-
-	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                          StrpTimeFunction::TryParse<timestamp_t>, StrpTimeFunction::Bind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	try_strptime.AddFunction(fun);
-
-	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP,
-	                     StrpTimeFunction::TryParse<timestamp_t>, StrpTimeFunction::Bind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	try_strptime.AddFunction(fun);
-
-	return try_strptime;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/generic/constant_or_null.cpp b/src/duckdb/src/function/scalar/generic/constant_or_null.cpp
deleted file mode 100644
index 32b9f855c..000000000
--- a/src/duckdb/src/function/scalar/generic/constant_or_null.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "duckdb/function/scalar/generic_common.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct ConstantOrNullBindData : public FunctionData {
-	explicit ConstantOrNullBindData(Value val) : value(std::move(val)) {
-	}
-
-	Value value;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<ConstantOrNullBindData>(value);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<ConstantOrNullBindData>();
-		return value == other.value;
-	}
-};
-
-static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<ConstantOrNullBindData>();
-	result.Reference(info.value);
-	for (idx_t idx = 1; idx < args.ColumnCount(); idx++) {
-		switch (args.data[idx].GetVectorType()) {
-		case VectorType::FLAT_VECTOR: {
-			auto &input_mask = FlatVector::Validity(args.data[idx]);
-			if (!input_mask.AllValid()) {
-				// there are null values: need to merge them into the result
-				result.Flatten(args.size());
-				auto &result_mask = FlatVector::Validity(result);
-				result_mask.Combine(input_mask, args.size());
-			}
-			break;
-		}
-		case VectorType::CONSTANT_VECTOR: {
-			if (ConstantVector::IsNull(args.data[idx])) {
-				// input is constant null, return constant null
-				result.Reference(info.value);
-				ConstantVector::SetNull(result, true);
-				return;
-			}
-			break;
-		}
-		default: {
-			UnifiedVectorFormat vdata;
-			args.data[idx].ToUnifiedFormat(args.size(), vdata);
-			if (!vdata.validity.AllValid()) {
-				result.Flatten(args.size());
-				auto &result_mask = FlatVector::Validity(result);
-				for (idx_t i = 0; i < args.size(); i++) {
-					if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-						result_mask.SetInvalid(i);
-					}
-				}
-			}
-			break;
-		}
-		}
-	}
-}
-
-unique_ptr<FunctionData> ConstantOrNull::Bind(Value value) {
-	return make_uniq<ConstantOrNullBindData>(std::move(value));
-}
-
-bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value &val) {
-	if (expr.function.name != "constant_or_null") {
-		return false;
-	}
-	D_ASSERT(expr.bind_info);
-	auto &bind_data = expr.bind_info->Cast<ConstantOrNullBindData>();
-	D_ASSERT(bind_data.value.type() == val.type());
-	return bind_data.value == val;
-}
-
-unique_ptr<FunctionData> ConstantOrNullBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[0]->IsFoldable()) {
-		throw BinderException("ConstantOrNull requires a constant input");
-	}
-	D_ASSERT(arguments.size() >= 2);
-	auto value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-	bound_function.return_type = arguments[0]->return_type;
-	return make_uniq<ConstantOrNullBindData>(std::move(value));
-}
-
-ScalarFunction ConstantOrNullFun::GetFunction() {
-	auto fun = ScalarFunction("constant_or_null", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY,
-	                          ConstantOrNullFunction);
-	fun.bind = ConstantOrNullBind;
-	fun.varargs = LogicalType::ANY;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/generic/error.cpp b/src/duckdb/src/function/scalar/generic/error.cpp
deleted file mode 100644
index 2d42cfced..000000000
--- a/src/duckdb/src/function/scalar/generic/error.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
-
-#include <iostream>
-
-namespace duckdb {
-
-struct ErrorOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		throw InvalidInputException(input.GetString());
-	}
-};
-
-ScalarFunction ErrorFun::GetFunction() {
-	auto fun = ScalarFunction("error", {LogicalType::VARCHAR}, LogicalType::SQLNULL,
-	                          ScalarFunction::UnaryFunction<string_t, int32_t, ErrorOperator>);
-	// Set the function with side effects to avoid the optimization.
-	fun.stability = FunctionStability::VOLATILE;
-	BaseScalarFunction::SetReturnsError(fun);
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/generic/getvariable.cpp b/src/duckdb/src/function/scalar/generic/getvariable.cpp
deleted file mode 100644
index 14d32954d..000000000
--- a/src/duckdb/src/function/scalar/generic/getvariable.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-
-namespace duckdb {
-
-struct GetVariableBindData : FunctionData {
-	explicit GetVariableBindData(Value value_p) : value(std::move(value_p)) {
-	}
-
-	Value value;
-
-	bool Equals(const FunctionData &other_p) const override {
-		const auto &other = other_p.Cast<GetVariableBindData>();
-		return Value::NotDistinctFrom(value, other.value);
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<GetVariableBindData>(value);
-	}
-};
-
-static unique_ptr<FunctionData> GetVariableBind(ClientContext &context, ScalarFunction &function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[0]->IsFoldable()) {
-		throw NotImplementedException("getvariable requires a constant input");
-	}
-	if (arguments[0]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	Value value;
-	auto variable_name = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-	if (!variable_name.IsNull()) {
-		ClientConfig::GetConfig(context).GetUserVariable(variable_name.ToString(), value);
-	}
-	function.return_type = value.type();
-	return make_uniq<GetVariableBindData>(std::move(value));
-}
-
-unique_ptr<Expression> BindGetVariableExpression(FunctionBindExpressionInput &input) {
-	if (!input.bind_data) {
-		// unknown type
-		throw InternalException("input.bind_data should be set");
-	}
-	auto &bind_data = input.bind_data->Cast<GetVariableBindData>();
-	// emit a constant expression
-	return make_uniq<BoundConstantExpression>(bind_data.value);
-}
-
-ScalarFunction GetVariableFun::GetFunction() {
-	ScalarFunction getvar("getvariable", {LogicalType::VARCHAR}, LogicalType::ANY, nullptr, GetVariableBind, nullptr);
-	getvar.bind_expression = BindGetVariableExpression;
-	return getvar;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/list/contains_or_position.cpp b/src/duckdb/src/function/scalar/list/contains_or_position.cpp
deleted file mode 100644
index 309d78c39..000000000
--- a/src/duckdb/src/function/scalar/list/contains_or_position.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "duckdb/function/scalar/list_functions.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/function/scalar/list/contains_or_position.hpp"
-
-namespace duckdb {
-
-template <bool RETURN_POSITION>
-static void ListSearchFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto target_count = input.size();
-	auto &list_vec = input.data[0];
-	auto &source_vec = ListVector::GetEntry(list_vec);
-	auto &target_vec = input.data[1];
-
-	ListSearchOp<RETURN_POSITION>(list_vec, source_vec, target_vec, result, target_count);
-
-	if (target_count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListSearchBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-
-	// If the first argument is an array, cast it to a list
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	const auto &list = arguments[0]->return_type;
-	const auto &value = arguments[1]->return_type;
-
-	const auto list_is_param = list.id() == LogicalTypeId::UNKNOWN;
-	const auto value_is_param = value.id() == LogicalTypeId::UNKNOWN;
-
-	if (list_is_param) {
-		if (!value_is_param) {
-			// only list is a parameter, cast it to a list of value type
-			bound_function.arguments[0] = LogicalType::LIST(value);
-			bound_function.arguments[1] = value;
-		}
-	} else if (value_is_param) {
-		// only value is a parameter: we expect the child type of list
-		bound_function.arguments[0] = list;
-		bound_function.arguments[1] = ListType::GetChildType(list);
-	} else {
-		LogicalType max_child_type;
-		if (!LogicalType::TryGetMaxLogicalType(context, ListType::GetChildType(list), value, max_child_type)) {
-			throw BinderException(
-			    "%s: Cannot match element of type '%s' in a list of type '%s' - an explicit cast is required",
-			    bound_function.name, value.ToString(), list.ToString());
-		}
-
-		bound_function.arguments[0] = LogicalType::LIST(max_child_type);
-		bound_function.arguments[1] = max_child_type;
-	}
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction ListContainsFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, LogicalType::BOOLEAN,
-	                      ListSearchFunction<false>, ListSearchBind);
-}
-
-ScalarFunction ListPositionFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, LogicalType::INTEGER,
-	                      ListSearchFunction<true>, ListSearchBind);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/list/list_extract.cpp b/src/duckdb/src/function/scalar/list/list_extract.cpp
deleted file mode 100644
index 058ce5f42..000000000
--- a/src/duckdb/src/function/scalar/list/list_extract.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/list_functions.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/list_stats.hpp"
-
-namespace duckdb {
-
-static optional_idx TryGetChildOffset(const list_entry_t &list_entry, const int64_t offset) {
-	// 1-based indexing
-	if (offset == 0) {
-		return optional_idx::Invalid();
-	}
-
-	const auto index_offset = (offset > 0) ? offset - 1 : offset;
-	if (index_offset < 0) {
-		const auto signed_list_length = UnsafeNumericCast<int64_t>(list_entry.length);
-		if (signed_list_length + index_offset < 0) {
-			return optional_idx::Invalid();
-		}
-		return optional_idx(list_entry.offset + UnsafeNumericCast<idx_t>(signed_list_length + index_offset));
-	}
-
-	const auto unsigned_offset = UnsafeNumericCast<idx_t>(index_offset);
-
-	// Check that the offset is within the list
-	if (unsigned_offset >= list_entry.length) {
-		return optional_idx::Invalid();
-	}
-
-	return optional_idx(list_entry.offset + unsigned_offset);
-}
-
-static void ExecuteListExtract(Vector &result, Vector &list, Vector &offsets, const idx_t count) {
-	D_ASSERT(list.GetType().id() == LogicalTypeId::LIST);
-	UnifiedVectorFormat list_data;
-	UnifiedVectorFormat offsets_data;
-
-	list.ToUnifiedFormat(count, list_data);
-	offsets.ToUnifiedFormat(count, offsets_data);
-
-	const auto list_ptr = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	const auto offsets_ptr = UnifiedVectorFormat::GetData<int64_t>(offsets_data);
-
-	UnifiedVectorFormat child_data;
-	auto &child_vector = ListVector::GetEntry(list);
-	auto child_count = ListVector::GetListSize(list);
-	child_vector.ToUnifiedFormat(child_count, child_data);
-
-	SelectionVector sel(count);
-	vector<idx_t> invalid_offsets;
-
-	optional_idx first_valid_child_idx;
-	for (idx_t i = 0; i < count; i++) {
-		const auto list_index = list_data.sel->get_index(i);
-		const auto offsets_index = offsets_data.sel->get_index(i);
-
-		if (!list_data.validity.RowIsValid(list_index) || !offsets_data.validity.RowIsValid(offsets_index)) {
-			invalid_offsets.push_back(i);
-			continue;
-		}
-
-		const auto child_offset = TryGetChildOffset(list_ptr[list_index], offsets_ptr[offsets_index]);
-
-		if (!child_offset.IsValid()) {
-			invalid_offsets.push_back(i);
-			continue;
-		}
-
-		const auto child_idx = child_data.sel->get_index(child_offset.GetIndex());
-		sel.set_index(i, child_idx);
-
-		if (!first_valid_child_idx.IsValid()) {
-			// Save the first valid child as a dummy index to copy in VectorOperations::Copy later
-			first_valid_child_idx = child_idx;
-		}
-	}
-
-	if (first_valid_child_idx.IsValid()) {
-		// Only copy if we found at least one valid child
-		for (const auto &invalid_offset : invalid_offsets) {
-			sel.set_index(invalid_offset, first_valid_child_idx.GetIndex());
-		}
-		VectorOperations::Copy(child_vector, result, sel, count, 0, 0);
-	}
-
-	// Copy:ing the vectors also copies the validity mask, so we set the rows with invalid offsets (0) to false here.
-	for (const auto &invalid_idx : invalid_offsets) {
-		FlatVector::SetNull(result, invalid_idx, true);
-	}
-
-	if (count == 1 || (list.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-	                   offsets.GetVectorType() == VectorType::CONSTANT_VECTOR)) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(count);
-}
-
-static void ExecuteStringExtract(Vector &result, Vector &input_vector, Vector &subscript_vector, const idx_t count) {
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    input_vector, subscript_vector, result, count,
-	    [&](string_t input_string, int64_t subscript) { return SubstringUnicode(result, input_string, subscript, 1); });
-}
-
-static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto count = args.size();
-
-	Vector &base = args.data[0];
-	Vector &subscript = args.data[1];
-
-	switch (base.GetType().id()) {
-	case LogicalTypeId::LIST:
-		ExecuteListExtract(result, base, subscript, count);
-		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteStringExtract(result, base, subscript, count);
-		break;
-	case LogicalTypeId::SQLNULL:
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented");
-	}
-}
-
-static unique_ptr<FunctionData> ListExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id());
-	// list extract returns the child type of the list as return type
-	auto child_type = ListType::GetChildType(arguments[0]->return_type);
-
-	bound_function.return_type = child_type;
-	bound_function.arguments[0] = LogicalType::LIST(child_type);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &list_child_stats = ListStats::GetChildStats(child_stats[0]);
-	auto child_copy = list_child_stats.Copy();
-	// list_extract always pushes a NULL, since if the offset is out of range for a list it inserts a null
-	child_copy.Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-	return child_copy.ToUnique();
-}
-
-ScalarFunctionSet ListExtractFun::GetFunctions() {
-	ScalarFunctionSet list_extract_set("list_extract");
-
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction lfun({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::ANY,
-	                    ListExtractFunction, ListExtractBind, nullptr, ListExtractStats);
-
-	ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, ListExtractFunction);
-	BaseScalarFunction::SetReturnsError(lfun);
-	BaseScalarFunction::SetReturnsError(sfun);
-	list_extract_set.AddFunction(lfun);
-	list_extract_set.AddFunction(sfun);
-	return list_extract_set;
-}
-
-ScalarFunctionSet ArrayExtractFun::GetFunctions() {
-	ScalarFunctionSet array_extract_set("array_extract");
-
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction lfun({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::ANY,
-	                    ListExtractFunction, ListExtractBind, nullptr, ListExtractStats);
-
-	ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, ListExtractFunction);
-
-	array_extract_set.AddFunction(lfun);
-	array_extract_set.AddFunction(sfun);
-	array_extract_set.AddFunction(GetKeyExtractFunction());
-	array_extract_set.AddFunction(GetIndexExtractFunction());
-	return array_extract_set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/list/list_resize.cpp b/src/duckdb/src/function/scalar/list/list_resize.cpp
deleted file mode 100644
index 019dfcc72..000000000
--- a/src/duckdb/src/function/scalar/list/list_resize.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/list_functions.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-void ListResizeFunction(DataChunk &args, ExpressionState &, Vector &result) {
-
-	// Early-out, if the return value is a constant NULL.
-	if (result.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	auto &lists = args.data[0];
-	auto &new_sizes = args.data[1];
-	auto row_count = args.size();
-
-	UnifiedVectorFormat lists_data;
-	lists.ToUnifiedFormat(row_count, lists_data);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
-
-	auto &child_vector = ListVector::GetEntry(lists);
-	UnifiedVectorFormat child_data;
-	child_vector.ToUnifiedFormat(row_count, child_data);
-
-	UnifiedVectorFormat new_sizes_data;
-	new_sizes.ToUnifiedFormat(row_count, new_sizes_data);
-	D_ASSERT(new_sizes.GetType().id() == LogicalTypeId::UBIGINT);
-	auto new_size_entries = UnifiedVectorFormat::GetData<uint64_t>(new_sizes_data);
-
-	// Get the new size of the result child vector.
-	// We skip rows with NULL values in the input lists.
-	idx_t child_vector_size = 0;
-	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
-		auto list_idx = lists_data.sel->get_index(row_idx);
-		auto new_size_idx = new_sizes_data.sel->get_index(row_idx);
-
-		if (lists_data.validity.RowIsValid(list_idx) && new_sizes_data.validity.RowIsValid(new_size_idx)) {
-			child_vector_size += new_size_entries[new_size_idx];
-		}
-	}
-	ListVector::Reserve(result, child_vector_size);
-	ListVector::SetListSize(result, child_vector_size);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-	auto &result_child_vector = ListVector::GetEntry(result);
-
-	// Get the default values, if provided.
-	UnifiedVectorFormat default_data;
-	optional_ptr<Vector> default_vector;
-	if (args.ColumnCount() == 3) {
-		default_vector = &args.data[2];
-		default_vector->ToUnifiedFormat(row_count, default_data);
-	}
-
-	idx_t offset = 0;
-	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
-
-		auto list_idx = lists_data.sel->get_index(row_idx);
-		auto new_size_idx = new_sizes_data.sel->get_index(row_idx);
-
-		// Set to NULL, if the list is NULL.
-		if (!lists_data.validity.RowIsValid(list_idx)) {
-			result_validity.SetInvalid(row_idx);
-			continue;
-		}
-
-		idx_t new_size = 0;
-		if (new_sizes_data.validity.RowIsValid(new_size_idx)) {
-			new_size = new_size_entries[new_size_idx];
-		}
-
-		// If new_size >= length, then we copy [0, length) values.
-		// If new_size < length, then we copy [0, new_size) values.
-		auto copy_count = MinValue<idx_t>(list_entries[list_idx].length, new_size);
-
-		// Set the result entry.
-		result_entries[row_idx].offset = offset;
-		result_entries[row_idx].length = new_size;
-
-		// Copy the child vector's values.
-		// The number of elements to copy is later determined like so: source_count - source_offset.
-		idx_t source_offset = list_entries[list_idx].offset;
-		idx_t source_count = source_offset + copy_count;
-		VectorOperations::Copy(child_vector, result_child_vector, source_count, source_offset, offset);
-		offset += copy_count;
-
-		// Fill the remaining space with the default values.
-		if (copy_count < new_size) {
-			idx_t remaining_count = new_size - copy_count;
-
-			if (default_vector) {
-				auto default_idx = default_data.sel->get_index(row_idx);
-				if (default_data.validity.RowIsValid(default_idx)) {
-					SelectionVector sel(remaining_count);
-					for (idx_t j = 0; j < remaining_count; j++) {
-						sel.set_index(j, row_idx);
-					}
-					VectorOperations::Copy(*default_vector, result_child_vector, sel, remaining_count, 0, offset);
-					offset += remaining_count;
-					continue;
-				}
-			}
-
-			// Fill the remaining space with NULL.
-			for (idx_t j = copy_count; j < new_size; j++) {
-				FlatVector::SetNull(result_child_vector, offset, true);
-				offset++;
-			}
-		}
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2 || arguments.size() == 3);
-	bound_function.arguments[1] = LogicalType::UBIGINT;
-
-	// If the first argument is an array, cast it to a list.
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	// Early-out, if the first argument is a constant NULL.
-	if (arguments[0]->return_type == LogicalType::SQLNULL) {
-		bound_function.arguments[0] = LogicalType::SQLNULL;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	// Early-out, if the first argument is a prepared statement.
-	if (arguments[0]->return_type == LogicalType::UNKNOWN) {
-		bound_function.return_type = arguments[0]->return_type;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	// Attempt implicit casting, if the default type does not match list the list child type.
-	if (bound_function.arguments.size() == 3 &&
-	    ListType::GetChildType(arguments[0]->return_type) != arguments[2]->return_type &&
-	    arguments[2]->return_type != LogicalTypeId::SQLNULL) {
-		bound_function.arguments[2] = ListType::GetChildType(arguments[0]->return_type);
-	}
-
-	bound_function.return_type = arguments[0]->return_type;
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunctionSet ListResizeFun::GetFunctions() {
-	ScalarFunction simple_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY},
-	                          LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
-	simple_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	BaseScalarFunction::SetReturnsError(simple_fun);
-	ScalarFunction default_value_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY, LogicalTypeId::ANY},
-	                                 LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
-	default_value_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	BaseScalarFunction::SetReturnsError(default_value_fun);
-	ScalarFunctionSet list_resize_set("list_resize");
-	list_resize_set.AddFunction(simple_fun);
-	list_resize_set.AddFunction(default_value_fun);
-	return list_resize_set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/list/list_select.cpp b/src/duckdb/src/function/scalar/list/list_select.cpp
deleted file mode 100644
index 55c6a9f1d..000000000
--- a/src/duckdb/src/function/scalar/list/list_select.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/function/scalar/list_functions.hpp"
-
-namespace duckdb {
-
-struct SetSelectionVectorSelect {
-	static void SetSelectionVector(SelectionVector &selection_vector, ValidityMask &validity_mask,
-	                               ValidityMask &input_validity, Vector &selection_entry, idx_t child_idx,
-	                               idx_t &target_offset, idx_t selection_offset, idx_t input_offset,
-	                               idx_t target_length) {
-		auto sel_idx = selection_entry.GetValue(selection_offset + child_idx).GetValue<int64_t>() - 1;
-		if (sel_idx >= 0 && sel_idx < UnsafeNumericCast<int64_t>(target_length)) {
-			auto sel_idx_unsigned = UnsafeNumericCast<idx_t>(sel_idx);
-			selection_vector.set_index(target_offset, input_offset + sel_idx_unsigned);
-			if (!input_validity.RowIsValid(input_offset + sel_idx_unsigned)) {
-				validity_mask.SetInvalid(target_offset);
-			}
-		} else {
-			selection_vector.set_index(target_offset, 0);
-			validity_mask.SetInvalid(target_offset);
-		}
-		target_offset++;
-	}
-
-	static void GetResultLength(DataChunk &args, idx_t &result_length, const list_entry_t *selection_data,
-	                            Vector selection_entry, idx_t selection_idx) {
-		result_length += selection_data[selection_idx].length;
-	}
-};
-
-struct SetSelectionVectorWhere {
-	static void SetSelectionVector(SelectionVector &selection_vector, ValidityMask &validity_mask,
-	                               ValidityMask &input_validity, Vector &selection_entry, idx_t child_idx,
-	                               idx_t &target_offset, idx_t selection_offset, idx_t input_offset,
-	                               idx_t target_length) {
-		if (!selection_entry.GetValue(selection_offset + child_idx).GetValue<bool>()) {
-			return;
-		}
-
-		selection_vector.set_index(target_offset, input_offset + child_idx);
-		if (!input_validity.RowIsValid(input_offset + child_idx)) {
-			validity_mask.SetInvalid(target_offset);
-		}
-
-		if (child_idx >= target_length) {
-			selection_vector.set_index(target_offset, 0);
-			validity_mask.SetInvalid(target_offset);
-		}
-
-		target_offset++;
-	}
-
-	static void GetResultLength(DataChunk &args, idx_t &result_length, const list_entry_t *selection_data,
-	                            Vector selection_entry, idx_t selection_idx) {
-		for (idx_t child_idx = 0; child_idx < selection_data[selection_idx].length; child_idx++) {
-			if (selection_entry.GetValue(selection_data[selection_idx].offset + child_idx).IsNull()) {
-				throw InvalidInputException("NULLs are not allowed as list elements in the second input parameter.");
-			}
-			if (selection_entry.GetValue(selection_data[selection_idx].offset + child_idx).GetValue<bool>()) {
-				result_length++;
-			}
-		}
-	}
-};
-
-template <class OP>
-static void ListSelectFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.data.size() == 2);
-	Vector &list = args.data[0];
-	Vector &selection_list = args.data[1];
-	idx_t count = args.size();
-
-	list_entry_t *result_data;
-	result_data = FlatVector::GetData<list_entry_t>(result);
-	auto &result_entry = ListVector::GetEntry(result);
-
-	UnifiedVectorFormat selection_lists;
-	selection_list.ToUnifiedFormat(count, selection_lists);
-	auto selection_lists_data = UnifiedVectorFormat::GetData<list_entry_t>(selection_lists);
-	auto &selection_entry = ListVector::GetEntry(selection_list);
-
-	UnifiedVectorFormat input_list;
-	list.ToUnifiedFormat(count, input_list);
-	auto input_lists_data = UnifiedVectorFormat::GetData<list_entry_t>(input_list);
-	auto &input_entry = ListVector::GetEntry(list);
-	auto &input_validity = FlatVector::Validity(input_entry);
-
-	idx_t result_length = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t input_idx = input_list.sel->get_index(i);
-		idx_t selection_idx = selection_lists.sel->get_index(i);
-		if (input_list.validity.RowIsValid(input_idx) && selection_lists.validity.RowIsValid(selection_idx)) {
-			OP::GetResultLength(args, result_length, selection_lists_data, selection_entry, selection_idx);
-		}
-	}
-
-	ListVector::Reserve(result, result_length);
-	SelectionVector result_selection_vec = SelectionVector(result_length);
-	ValidityMask entry_validity_mask = ValidityMask(result_length);
-	ValidityMask &result_validity_mask = FlatVector::Validity(result);
-
-	idx_t offset = 0;
-	for (idx_t j = 0; j < count; j++) {
-		// Get length and offset of selection list for current output row
-		auto selection_list_idx = selection_lists.sel->get_index(j);
-		idx_t selection_len = 0;
-		idx_t selection_offset = 0;
-		if (selection_lists.validity.RowIsValid(selection_list_idx)) {
-			selection_len = selection_lists_data[selection_list_idx].length;
-			selection_offset = selection_lists_data[selection_list_idx].offset;
-		} else {
-			result_validity_mask.SetInvalid(j);
-			continue;
-		}
-		// Get length and offset of input list for current output row
-		auto input_list_idx = input_list.sel->get_index(j);
-		idx_t input_length = 0;
-		idx_t input_offset = 0;
-		if (input_list.validity.RowIsValid(input_list_idx)) {
-			input_length = input_lists_data[input_list_idx].length;
-			input_offset = input_lists_data[input_list_idx].offset;
-		} else {
-			result_validity_mask.SetInvalid(j);
-			continue;
-		}
-		result_data[j].offset = offset;
-		// Set all selected values in the result
-		for (idx_t child_idx = 0; child_idx < selection_len; child_idx++) {
-			if (selection_entry.GetValue(selection_offset + child_idx).IsNull()) {
-				throw InvalidInputException("NULLs are not allowed as list elements in the second input parameter.");
-			}
-			OP::SetSelectionVector(result_selection_vec, entry_validity_mask, input_validity, selection_entry,
-			                       child_idx, offset, selection_offset, input_offset, input_length);
-		}
-		result_data[j].length = offset - result_data[j].offset;
-	}
-	result_entry.Slice(input_entry, result_selection_vec, count);
-	result_entry.Flatten(offset);
-	ListVector::SetListSize(result, offset);
-	FlatVector::SetValidity(result_entry, entry_validity_mask);
-	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
-}
-
-static unique_ptr<FunctionData> ListSelectBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-
-	// If the first argument is an array, cast it to a list
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-
-	LogicalType child_type;
-	if (arguments[0]->return_type == LogicalTypeId::UNKNOWN || arguments[1]->return_type == LogicalTypeId::UNKNOWN) {
-		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id() ||
-	         LogicalTypeId::SQLNULL == arguments[0]->return_type.id());
-
-	bound_function.return_type = arguments[0]->return_type;
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-ScalarFunction ListWhereFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::LIST(LogicalTypeId::ANY), LogicalType::LIST(LogicalType::BOOLEAN)},
-	                          LogicalType::LIST(LogicalTypeId::ANY), ListSelectFunction<SetSelectionVectorWhere>,
-	                          ListSelectBind);
-	return fun;
-}
-
-ScalarFunction ListSelectFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::LIST(LogicalTypeId::ANY), LogicalType::LIST(LogicalType::BIGINT)},
-	                          LogicalType::LIST(LogicalTypeId::ANY), ListSelectFunction<SetSelectionVectorSelect>,
-	                          ListSelectBind);
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/list/list_zip.cpp b/src/duckdb/src/function/scalar/list/list_zip.cpp
deleted file mode 100644
index ef39a989d..000000000
--- a/src/duckdb/src/function/scalar/list/list_zip.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/list_functions.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-static void ListZipFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	idx_t count = args.size();
-	idx_t args_size = args.ColumnCount();
-	auto *result_data = FlatVector::GetData<list_entry_t>(result);
-	auto &result_struct = ListVector::GetEntry(result);
-	auto &struct_entries = StructVector::GetEntries(result_struct);
-	bool truncate_flags_set = false;
-
-	// Check flag
-	if (args.data.back().GetType().id() == LogicalTypeId::BOOLEAN) {
-		truncate_flags_set = true;
-		args_size--;
-	}
-
-	vector<UnifiedVectorFormat> input_lists;
-	input_lists.resize(args.ColumnCount());
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		args.data[i].ToUnifiedFormat(count, input_lists[i]);
-	}
-
-	// Handling output row for each input row
-	idx_t result_size = 0;
-	vector<idx_t> lengths;
-	for (idx_t j = 0; j < count; j++) {
-		// Is flag for current row set
-		bool truncate_to_shortest = false;
-		if (truncate_flags_set) {
-			auto &flag_vec = input_lists.back();
-			idx_t flag_idx = flag_vec.sel->get_index(j);
-			if (flag_vec.validity.RowIsValid(flag_idx)) {
-				truncate_to_shortest = UnifiedVectorFormat::GetData<bool>(flag_vec)[flag_idx];
-			}
-		}
-
-		// Calculation of the outgoing list size
-		idx_t len = truncate_to_shortest ? NumericLimits<int>::Maximum() : 0;
-		for (idx_t i = 0; i < args_size; i++) {
-			idx_t curr_size;
-			if (args.data[i].GetType() == LogicalType::SQLNULL || ListVector::GetListSize(args.data[i]) == 0) {
-				curr_size = 0;
-			} else {
-				idx_t sel_idx = input_lists[i].sel->get_index(j);
-				auto curr_data = UnifiedVectorFormat::GetData<list_entry_t>(input_lists[i]);
-				curr_size = input_lists[i].validity.RowIsValid(sel_idx) ? curr_data[sel_idx].length : 0;
-			}
-
-			// Dependent on flag using gt or lt
-			if (truncate_to_shortest) {
-				len = len > curr_size ? curr_size : len;
-			} else {
-				len = len < curr_size ? curr_size : len;
-			}
-		}
-		lengths.push_back(len);
-		result_size += len;
-	}
-
-	ListVector::SetListSize(result, result_size);
-	ListVector::Reserve(result, result_size);
-	vector<SelectionVector> selections;
-	vector<ValidityMask> masks;
-	for (idx_t i = 0; i < args_size; i++) {
-		selections.push_back(SelectionVector(result_size));
-		masks.push_back(ValidityMask(result_size));
-	}
-
-	idx_t offset = 0;
-	for (idx_t j = 0; j < count; j++) {
-		idx_t len = lengths[j];
-		for (idx_t i = 0; i < args_size; i++) {
-			auto &curr = input_lists[i];
-			idx_t sel_idx = curr.sel->get_index(j);
-			idx_t curr_off = 0;
-			idx_t curr_len = 0;
-
-			// Copying values from the given lists
-			if (curr.validity.RowIsValid(sel_idx)) {
-				auto input_lists_data = UnifiedVectorFormat::GetData<list_entry_t>(curr);
-				curr_off = input_lists_data[sel_idx].offset;
-				curr_len = input_lists_data[sel_idx].length;
-				auto copy_len = len < curr_len ? len : curr_len;
-				idx_t entry = offset;
-				for (idx_t k = 0; k < copy_len; k++) {
-					if (!FlatVector::Validity(ListVector::GetEntry(args.data[i])).RowIsValid(curr_off + k)) {
-						masks[i].SetInvalid(entry + k);
-					}
-					selections[i].set_index(entry + k, curr_off + k);
-				}
-			}
-
-			// Set NULL values for list that are shorter than the output list
-			if (len > curr_len) {
-				for (idx_t d = curr_len; d < len; d++) {
-					masks[i].SetInvalid(d + offset);
-					selections[i].set_index(d + offset, 0);
-				}
-			}
-		}
-		result_data[j].length = len;
-		result_data[j].offset = offset;
-		offset += len;
-	}
-	for (idx_t child_idx = 0; child_idx < args_size; child_idx++) {
-		if (args.data[child_idx].GetType() != LogicalType::SQLNULL) {
-			struct_entries[child_idx]->Slice(ListVector::GetEntry(args.data[child_idx]), selections[child_idx],
-			                                 result_size);
-		}
-		struct_entries[child_idx]->Flatten(result_size);
-		FlatVector::SetValidity((*struct_entries[child_idx]), masks[child_idx]);
-	}
-	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
-}
-
-static unique_ptr<FunctionData> ListZipBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	child_list_t<LogicalType> struct_children;
-
-	// The last argument could be a flag to be set if we want a minimal list or a maximal list
-	idx_t size = arguments.size();
-	if (size == 0) {
-		throw BinderException("Provide at least one argument to " + bound_function.name);
-	}
-	if (arguments[size - 1]->return_type.id() == LogicalTypeId::BOOLEAN) {
-		if (--size == 0) {
-			throw BinderException("Provide at least one list argument to " + bound_function.name);
-		}
-	}
-
-	case_insensitive_set_t struct_names;
-	for (idx_t i = 0; i < size; i++) {
-		auto &child = arguments[i];
-		switch (child->return_type.id()) {
-		case LogicalTypeId::LIST:
-		case LogicalTypeId::ARRAY:
-			child = BoundCastExpression::AddArrayCastToList(context, std::move(child));
-			struct_children.push_back(make_pair(string(), ListType::GetChildType(child->return_type)));
-			break;
-		case LogicalTypeId::SQLNULL:
-			struct_children.push_back(make_pair(string(), LogicalTypeId::SQLNULL));
-			break;
-		case LogicalTypeId::UNKNOWN:
-			throw ParameterNotResolvedException();
-		default:
-			throw BinderException("Parameter type needs to be List");
-		}
-	}
-	bound_function.return_type = LogicalType::LIST(LogicalType::STRUCT(struct_children));
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-ScalarFunction ListZipFun::GetFunction() {
-
-	auto fun = ScalarFunction({}, LogicalType::LIST(LogicalTypeId::STRUCT), ListZipFunction, ListZipBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/map/map_contains.cpp b/src/duckdb/src/function/scalar/map/map_contains.cpp
deleted file mode 100644
index 068e67bc7..000000000
--- a/src/duckdb/src/function/scalar/map/map_contains.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "duckdb/function/scalar/list/contains_or_position.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/function/scalar/map_functions.hpp"
-
-namespace duckdb {
-
-static void MapContainsFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	const auto count = input.size();
-
-	auto &map_vec = input.data[0];
-	auto &key_vec = MapVector::GetKeys(map_vec);
-	auto &arg_vec = input.data[1];
-
-	ListSearchOp<false>(map_vec, key_vec, arg_vec, result, count);
-
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> MapContainsBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-
-	const auto &map = arguments[0]->return_type;
-	const auto &key = arguments[1]->return_type;
-
-	if (map.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-
-	if (key.id() == LogicalTypeId::UNKNOWN) {
-		// Infer the argument type from the map type
-		bound_function.arguments[0] = map;
-		bound_function.arguments[1] = MapType::KeyType(map);
-	} else {
-		LogicalType max_child_type;
-		if (!LogicalType::TryGetMaxLogicalType(context, MapType::KeyType(map), key, max_child_type)) {
-			throw BinderException(
-			    "%s: Cannot match element of type '%s' in a map of type '%s' - an explicit cast is required",
-			    bound_function.name, key.ToString(), map.ToString());
-		}
-
-		bound_function.arguments[0] = LogicalType::MAP(max_child_type, MapType::ValueType(map));
-		bound_function.arguments[1] = max_child_type;
-	}
-	return nullptr;
-}
-
-ScalarFunction MapContainsFun::GetFunction() {
-	ScalarFunction fun("map_contains", {LogicalType::MAP(LogicalType::ANY, LogicalType::ANY), LogicalType::ANY},
-	                   LogicalType::BOOLEAN, MapContainsFunction, MapContainsBind);
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/nested_functions.cpp b/src/duckdb/src/function/scalar/nested_functions.cpp
deleted file mode 100644
index 2d5359c4e..000000000
--- a/src/duckdb/src/function/scalar/nested_functions.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-void MapUtil::ReinterpretMap(Vector &result, Vector &input, idx_t count) {
-	UnifiedVectorFormat input_data;
-	input.ToUnifiedFormat(count, input_data);
-	// Copy the list validity
-	FlatVector::SetValidity(result, input_data.validity);
-
-	// Copy the struct validity
-	UnifiedVectorFormat input_struct_data;
-	ListVector::GetEntry(input).ToUnifiedFormat(count, input_struct_data);
-	auto &result_struct = ListVector::GetEntry(result);
-	FlatVector::SetValidity(result_struct, input_struct_data.validity);
-
-	// Copy the list size
-	auto list_size = ListVector::GetListSize(input);
-	ListVector::SetListSize(result, list_size);
-
-	// Copy the list buffer (the list_entry_t data)
-	result.CopyBuffer(input);
-
-	auto &input_keys = MapVector::GetKeys(input);
-	auto &result_keys = MapVector::GetKeys(result);
-	result_keys.Reference(input_keys);
-
-	auto &input_values = MapVector::GetValues(input);
-	auto &result_values = MapVector::GetValues(result);
-	result_values.Reference(input_values);
-
-	if (input.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		result.Slice(*input_data.sel, count);
-	}
-
-	// Set the right vector type
-	result.SetVectorType(input.GetVectorType());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/operator/add.cpp b/src/duckdb/src/function/scalar/operator/add.cpp
deleted file mode 100644
index fa2f1a9e7..000000000
--- a/src/duckdb/src/function/scalar/operator/add.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-#include "duckdb/common/operator/add.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/value.hpp"
-
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// + [add]
-//===--------------------------------------------------------------------===//
-template <>
-float AddOperator::Operation(float left, float right) {
-	auto result = left + right;
-	return result;
-}
-
-template <>
-double AddOperator::Operation(double left, double right) {
-	auto result = left + right;
-	return result;
-}
-
-template <>
-interval_t AddOperator::Operation(interval_t left, interval_t right) {
-	left.months = AddOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.months, right.months);
-	left.days = AddOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.days, right.days);
-	left.micros = AddOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(left.micros, right.micros);
-	return left;
-}
-
-template <>
-date_t AddOperator::Operation(date_t left, int32_t right) {
-	date_t result;
-	if (!TryAddOperator::Operation(left, right, result)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	return result;
-}
-
-template <>
-date_t AddOperator::Operation(int32_t left, date_t right) {
-	return AddOperator::Operation<date_t, int32_t, date_t>(right, left);
-}
-
-template <>
-timestamp_t AddOperator::Operation(date_t left, dtime_t right) {
-	if (left == date_t::infinity()) {
-		return timestamp_t::infinity();
-	} else if (left == date_t::ninfinity()) {
-		return timestamp_t::ninfinity();
-	}
-	timestamp_t result;
-	if (!Timestamp::TryFromDatetime(left, right, result)) {
-		throw OutOfRangeException("Timestamp out of range");
-	}
-	return result;
-}
-
-template <>
-timestamp_t AddOperator::Operation(date_t left, dtime_tz_t right) {
-	if (left == date_t::infinity()) {
-		return timestamp_t::infinity();
-	} else if (left == date_t::ninfinity()) {
-		return timestamp_t::ninfinity();
-	}
-	timestamp_t result;
-	if (!Timestamp::TryFromDatetime(left, right, result)) {
-		throw OutOfRangeException("Timestamp with time zone out of range");
-	}
-	return result;
-}
-
-template <>
-timestamp_t AddOperator::Operation(dtime_t left, date_t right) {
-	return AddOperator::Operation<date_t, dtime_t, timestamp_t>(right, left);
-}
-
-template <>
-timestamp_t AddOperator::Operation(dtime_tz_t left, date_t right) {
-	return AddOperator::Operation<date_t, dtime_tz_t, timestamp_t>(right, left);
-}
-
-template <>
-timestamp_t AddOperator::Operation(date_t left, interval_t right) {
-	if (left == date_t::infinity()) {
-		return timestamp_t::infinity();
-	}
-	if (left == date_t::ninfinity()) {
-		return timestamp_t::ninfinity();
-	}
-	return Interval::Add(Timestamp::FromDatetime(left, dtime_t(0)), right);
-}
-
-template <>
-timestamp_t AddOperator::Operation(interval_t left, date_t right) {
-	return AddOperator::Operation<date_t, interval_t, timestamp_t>(right, left);
-}
-
-template <>
-timestamp_t AddOperator::Operation(timestamp_t left, interval_t right) {
-	return Interval::Add(left, right);
-}
-
-template <>
-timestamp_t AddOperator::Operation(interval_t left, timestamp_t right) {
-	return AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(right, left);
-}
-
-//===--------------------------------------------------------------------===//
-// + [add] with overflow check
-//===--------------------------------------------------------------------===//
-struct OverflowCheckedAddition {
-	template <class SRCTYPE, class UTYPE>
-	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
-		UTYPE uresult = AddOperator::Operation<UTYPE, UTYPE, UTYPE>(UTYPE(left), UTYPE(right));
-		if (uresult < NumericLimits<SRCTYPE>::Minimum() || uresult > NumericLimits<SRCTYPE>::Maximum()) {
-			return false;
-		}
-		result = SRCTYPE(uresult);
-		return true;
-	}
-};
-
-template <>
-bool TryAddOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
-	return OverflowCheckedAddition::Operation<uint8_t, uint16_t>(left, right, result);
-}
-template <>
-bool TryAddOperator::Operation(uint16_t left, uint16_t right, uint16_t &result) {
-	return OverflowCheckedAddition::Operation<uint16_t, uint32_t>(left, right, result);
-}
-template <>
-bool TryAddOperator::Operation(uint32_t left, uint32_t right, uint32_t &result) {
-	return OverflowCheckedAddition::Operation<uint32_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(uint64_t left, uint64_t right, uint64_t &result) {
-	if (NumericLimits<uint64_t>::Maximum() - left < right) {
-		return false;
-	}
-	return OverflowCheckedAddition::Operation<uint64_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(date_t left, int32_t right, date_t &result) {
-	if (left == date_t::infinity() || left == date_t::ninfinity()) {
-		result = date_t(left);
-		return true;
-	}
-	int32_t days;
-	if (!TryAddOperator::Operation(left.days, right, days)) {
-		return false;
-	}
-	result.days = days;
-	if (!Value::IsFinite(result)) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryAddOperator::Operation(int8_t left, int8_t right, int8_t &result) {
-	return OverflowCheckedAddition::Operation<int8_t, int16_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int16_t left, int16_t right, int16_t &result) {
-	return OverflowCheckedAddition::Operation<int16_t, int32_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int32_t left, int32_t right, int32_t &result) {
-	return OverflowCheckedAddition::Operation<int32_t, int64_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result) {
-#if (__GNUC__ >= 5) || defined(__clang__)
-	if (__builtin_add_overflow(left, right, &result)) {
-		return false;
-	}
-#else
-	// https://blog.regehr.org/archives/1139
-	result = int64_t((uint64_t)left + (uint64_t)right);
-	if ((left < 0 && right < 0 && result >= 0) || (left >= 0 && right >= 0 && result < 0)) {
-		return false;
-	}
-#endif
-	return true;
-}
-
-template <>
-bool TryAddOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result) {
-	if (!Uhugeint::TryAddInPlace(left, right)) {
-		return false;
-	}
-	result = left;
-	return true;
-}
-
-template <>
-bool TryAddOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	if (!Hugeint::TryAddInPlace(left, right)) {
-		return false;
-	}
-	result = left;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// add decimal with overflow check
-//===--------------------------------------------------------------------===//
-template <class T, T min, T max>
-bool TryDecimalAddTemplated(T left, T right, T &result) {
-	if (right < 0) {
-		if (min - right > left) {
-			return false;
-		}
-	} else {
-		if (max - right < left) {
-			return false;
-		}
-	}
-	result = left + right;
-	return true;
-}
-
-template <>
-bool TryDecimalAdd::Operation(int16_t left, int16_t right, int16_t &result) {
-	return TryDecimalAddTemplated<int16_t, -9999, 9999>(left, right, result);
-}
-
-template <>
-bool TryDecimalAdd::Operation(int32_t left, int32_t right, int32_t &result) {
-	return TryDecimalAddTemplated<int32_t, -999999999, 999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalAdd::Operation(int64_t left, int64_t right, int64_t &result) {
-	return TryDecimalAddTemplated<int64_t, -999999999999999999, 999999999999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalAdd::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	if (!TryAddOperator::Operation(left, right, result)) {
-		return false;
-	}
-	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-hugeint_t DecimalAddOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
-	hugeint_t result;
-	if (!TryDecimalAdd::Operation(left, right, result)) {
-		throw OutOfRangeException("Overflow in addition of DECIMAL(38) (%s + %s);", left.ToString(), right.ToString());
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// add time operator
-//===--------------------------------------------------------------------===//
-template <>
-dtime_t AddTimeOperator::Operation(dtime_t left, interval_t right) {
-	date_t date(0);
-	return Interval::Add(left, right, date);
-}
-
-template <>
-dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right) {
-	return AddTimeOperator::Operation<dtime_t, interval_t, dtime_t>(right, left);
-}
-
-template <>
-dtime_tz_t AddTimeOperator::Operation(dtime_tz_t left, interval_t right) {
-	date_t date(0);
-	return Interval::Add(left, right, date);
-}
-
-template <>
-dtime_tz_t AddTimeOperator::Operation(interval_t left, dtime_tz_t right) {
-	return AddTimeOperator::Operation<dtime_tz_t, interval_t, dtime_tz_t>(right, left);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/operator/arithmetic.cpp b/src/duckdb/src/function/scalar/operator/arithmetic.cpp
deleted file mode 100644
index a3c11ed63..000000000
--- a/src/duckdb/src/function/scalar/operator/arithmetic.cpp
+++ /dev/null
@@ -1,1119 +0,0 @@
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/numeric_binary_operators.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/function/scalar/operator_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-#include <limits>
-
-namespace duckdb {
-
-template <class OP>
-static scalar_function_t GetScalarIntegerFunction(PhysicalType type) {
-	scalar_function_t function;
-	switch (type) {
-	case PhysicalType::INT8:
-		function = &ScalarFunction::BinaryFunction<int8_t, int8_t, int8_t, OP>;
-		break;
-	case PhysicalType::INT16:
-		function = &ScalarFunction::BinaryFunction<int16_t, int16_t, int16_t, OP>;
-		break;
-	case PhysicalType::INT32:
-		function = &ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, OP>;
-		break;
-	case PhysicalType::INT64:
-		function = &ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, OP>;
-		break;
-	case PhysicalType::INT128:
-		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
-		break;
-	case PhysicalType::UINT8:
-		function = &ScalarFunction::BinaryFunction<uint8_t, uint8_t, uint8_t, OP>;
-		break;
-	case PhysicalType::UINT16:
-		function = &ScalarFunction::BinaryFunction<uint16_t, uint16_t, uint16_t, OP>;
-		break;
-	case PhysicalType::UINT32:
-		function = &ScalarFunction::BinaryFunction<uint32_t, uint32_t, uint32_t, OP>;
-		break;
-	case PhysicalType::UINT64:
-		function = &ScalarFunction::BinaryFunction<uint64_t, uint64_t, uint64_t, OP>;
-		break;
-	case PhysicalType::UINT128:
-		function = &ScalarFunction::BinaryFunction<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarBinaryFunction: %s", TypeIdToString(type));
-	}
-	return function;
-}
-
-template <class OP>
-static scalar_function_t GetScalarBinaryFunction(PhysicalType type) {
-	scalar_function_t function;
-	switch (type) {
-	case PhysicalType::FLOAT:
-		function = &ScalarFunction::BinaryFunction<float, float, float, OP>;
-		break;
-	case PhysicalType::DOUBLE:
-		function = &ScalarFunction::BinaryFunction<double, double, double, OP>;
-		break;
-	default:
-		function = GetScalarIntegerFunction<OP>(type);
-		break;
-	}
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// + [add]
-//===--------------------------------------------------------------------===//
-struct AddPropagateStatistics {
-	template <class T, class OP>
-	static bool Operation(LogicalType type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
-	                      Value &new_max) {
-		T min, max;
-		// new min is min+min
-		if (!OP::Operation(NumericStats::GetMin<T>(lstats), NumericStats::GetMin<T>(rstats), min)) {
-			return true;
-		}
-		// new max is max+max
-		if (!OP::Operation(NumericStats::GetMax<T>(lstats), NumericStats::GetMax<T>(rstats), max)) {
-			return true;
-		}
-		new_min = Value::Numeric(type, min);
-		new_max = Value::Numeric(type, max);
-		return false;
-	}
-};
-
-struct SubtractPropagateStatistics {
-	template <class T, class OP>
-	static bool Operation(LogicalType type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
-	                      Value &new_max) {
-		T min, max;
-		if (!OP::Operation(NumericStats::GetMin<T>(lstats), NumericStats::GetMax<T>(rstats), min)) {
-			return true;
-		}
-		if (!OP::Operation(NumericStats::GetMax<T>(lstats), NumericStats::GetMin<T>(rstats), max)) {
-			return true;
-		}
-		new_min = Value::Numeric(type, min);
-		new_max = Value::Numeric(type, max);
-		return false;
-	}
-};
-
-struct DecimalArithmeticBindData : public FunctionData {
-	DecimalArithmeticBindData() : check_overflow(false) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		auto res = make_uniq<DecimalArithmeticBindData>();
-		res->check_overflow = check_overflow;
-		return std::move(res);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto other = other_p.Cast<DecimalArithmeticBindData>();
-		return other.check_overflow == check_overflow;
-	}
-
-	bool check_overflow;
-};
-
-template <class OP, class PROPAGATE, class BASEOP>
-static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 2);
-	// can only propagate stats if the children have stats
-	auto &lstats = child_stats[0];
-	auto &rstats = child_stats[1];
-	Value new_min, new_max;
-	bool potential_overflow = true;
-	if (NumericStats::HasMinMax(lstats) && NumericStats::HasMinMax(rstats)) {
-		switch (expr.return_type.InternalType()) {
-		case PhysicalType::INT8:
-			potential_overflow =
-			    PROPAGATE::template Operation<int8_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		case PhysicalType::INT16:
-			potential_overflow =
-			    PROPAGATE::template Operation<int16_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		case PhysicalType::INT32:
-			potential_overflow =
-			    PROPAGATE::template Operation<int32_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		case PhysicalType::INT64:
-			potential_overflow =
-			    PROPAGATE::template Operation<int64_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		default:
-			return nullptr;
-		}
-	}
-	if (potential_overflow) {
-		new_min = Value(expr.return_type);
-		new_max = Value(expr.return_type);
-	} else {
-		// no potential overflow: replace with non-overflowing operator
-		if (input.bind_data) {
-			auto &bind_data = input.bind_data->Cast<DecimalArithmeticBindData>();
-			bind_data.check_overflow = false;
-		}
-		expr.function.function = GetScalarIntegerFunction<BASEOP>(expr.return_type.InternalType());
-	}
-	auto result = NumericStats::CreateEmpty(expr.return_type);
-	NumericStats::SetMin(result, new_min);
-	NumericStats::SetMax(result, new_max);
-	result.CombineValidity(lstats, rstats);
-	return result.ToUnique();
-}
-
-template <bool IS_MODULO = false>
-unique_ptr<DecimalArithmeticBindData> BindDecimalArithmetic(ClientContext &context, ScalarFunction &bound_function,
-                                                            vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = make_uniq<DecimalArithmeticBindData>();
-
-	// get the max width and scale of the input arguments
-	uint8_t max_width = 0, max_scale = 0, max_width_over_scale = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (arguments[i]->return_type.id() == LogicalTypeId::UNKNOWN) {
-			continue;
-		}
-		uint8_t width, scale;
-		auto can_convert = arguments[i]->return_type.GetDecimalProperties(width, scale);
-		if (!can_convert) {
-			throw InternalException("Could not convert type %s to a decimal.", arguments[i]->return_type.ToString());
-		}
-		max_width = MaxValue<uint8_t>(width, max_width);
-		max_scale = MaxValue<uint8_t>(scale, max_scale);
-		max_width_over_scale = MaxValue<uint8_t>(width - scale, max_width_over_scale);
-	}
-	D_ASSERT(max_width > 0);
-	uint8_t required_width = MaxValue<uint8_t>(max_scale + max_width_over_scale, max_width);
-	if (!IS_MODULO) {
-		// for addition/subtraction, we add 1 to the width to ensure we don't overflow
-		required_width = NumericCast<uint8_t>(required_width + 1);
-		if (required_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64) {
-			// we don't automatically promote past the hugeint boundary to avoid the large hugeint performance penalty
-			bind_data->check_overflow = true;
-			required_width = Decimal::MAX_WIDTH_INT64;
-		}
-	}
-	if (required_width > Decimal::MAX_WIDTH_DECIMAL) {
-		// target width does not fit in decimal at all: truncate the scale and perform overflow detection
-		bind_data->check_overflow = true;
-		required_width = Decimal::MAX_WIDTH_DECIMAL;
-	}
-	// arithmetic between two decimal arguments: check the types of the input arguments
-	LogicalType result_type = LogicalType::DECIMAL(required_width, max_scale);
-	// we cast all input types to the specified type
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		// first check if the cast is necessary
-		// if the argument has a matching scale and internal type as the output type, no casting is necessary
-		auto &argument_type = arguments[i]->return_type;
-		uint8_t width, scale;
-		argument_type.GetDecimalProperties(width, scale);
-		if (scale == DecimalType::GetScale(result_type) && argument_type.InternalType() == result_type.InternalType()) {
-			bound_function.arguments[i] = argument_type;
-		} else {
-			bound_function.arguments[i] = result_type;
-		}
-	}
-	bound_function.return_type = result_type;
-	return bind_data;
-}
-
-template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindDecimalArithmetic(context, bound_function, arguments);
-
-	// now select the physical function to execute
-	auto &result_type = bound_function.return_type;
-	if (bind_data->check_overflow) {
-		bound_function.function = GetScalarBinaryFunction<OPOVERFLOWCHECK>(result_type.InternalType());
-	} else {
-		bound_function.function = GetScalarBinaryFunction<OP>(result_type.InternalType());
-	}
-	if (result_type.InternalType() != PhysicalType::INT128 && result_type.InternalType() != PhysicalType::UINT128) {
-		if (IS_SUBTRACT) {
-			bound_function.statistics =
-			    PropagateNumericStats<TryDecimalSubtract, SubtractPropagateStatistics, SubtractOperator>;
-		} else {
-			bound_function.statistics = PropagateNumericStats<TryDecimalAdd, AddPropagateStatistics, AddOperator>;
-		}
-	}
-	return std::move(bind_data);
-}
-
-static void SerializeDecimalArithmetic(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                       const ScalarFunction &function) {
-	auto &bind_data = bind_data_p->Cast<DecimalArithmeticBindData>();
-	serializer.WriteProperty(100, "check_overflow", bind_data.check_overflow);
-	serializer.WriteProperty(101, "return_type", function.return_type);
-	serializer.WriteProperty(102, "arguments", function.arguments);
-}
-
-// TODO this is partially duplicated from the bind
-template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> DeserializeDecimalArithmetic(Deserializer &deserializer, ScalarFunction &bound_function) {
-
-	//	// re-change the function pointers
-	auto check_overflow = deserializer.ReadProperty<bool>(100, "check_overflow");
-	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
-	auto arguments = deserializer.ReadProperty<vector<LogicalType>>(102, "arguments");
-	if (check_overflow) {
-		bound_function.function = GetScalarBinaryFunction<OPOVERFLOWCHECK>(return_type.InternalType());
-	} else {
-		bound_function.function = GetScalarBinaryFunction<OP>(return_type.InternalType());
-	}
-	bound_function.statistics = nullptr; // TODO we likely dont want to do stats prop again
-	bound_function.return_type = return_type;
-	bound_function.arguments = arguments;
-
-	auto bind_data = make_uniq<DecimalArithmeticBindData>();
-	bind_data->check_overflow = check_overflow;
-	return std::move(bind_data);
-}
-
-unique_ptr<FunctionData> NopDecimalBind(ClientContext &context, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	bound_function.return_type = arguments[0]->return_type;
-	bound_function.arguments[0] = arguments[0]->return_type;
-	return nullptr;
-}
-
-ScalarFunction AddFunction::GetFunction(const LogicalType &type) {
-	D_ASSERT(type.IsNumeric());
-	if (type.id() == LogicalTypeId::DECIMAL) {
-		return ScalarFunction("+", {type}, type, ScalarFunction::NopFunction, NopDecimalBind);
-	} else {
-		return ScalarFunction("+", {type}, type, ScalarFunction::NopFunction);
-	}
-}
-
-ScalarFunction AddFunction::GetFunction(const LogicalType &left_type, const LogicalType &right_type) {
-	if (left_type.IsNumeric() && left_type.id() == right_type.id()) {
-		if (left_type.id() == LogicalTypeId::DECIMAL) {
-			auto function = ScalarFunction("+", {left_type, right_type}, left_type, nullptr,
-			                               BindDecimalAddSubtract<AddOperator, DecimalAddOverflowCheck>);
-			BaseScalarFunction::SetReturnsError(function);
-			function.serialize = SerializeDecimalArithmetic;
-			function.deserialize = DeserializeDecimalArithmetic<AddOperator, DecimalAddOverflowCheck>;
-			return function;
-		} else if (left_type.IsIntegral()) {
-			ScalarFunction function("+", {left_type, right_type}, left_type,
-			                        GetScalarIntegerFunction<AddOperatorOverflowCheck>(left_type.InternalType()),
-			                        nullptr, nullptr,
-			                        PropagateNumericStats<TryAddOperator, AddPropagateStatistics, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		} else {
-			ScalarFunction function("+", {left_type, right_type}, left_type,
-			                        GetScalarBinaryFunction<AddOperator>(left_type.InternalType()));
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		}
-	}
-
-	switch (left_type.id()) {
-	case LogicalTypeId::DATE:
-		if (right_type.id() == LogicalTypeId::INTEGER) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::DATE,
-			                        ScalarFunction::BinaryFunction<date_t, int32_t, date_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<date_t, interval_t, timestamp_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::TIME) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<date_t, dtime_t, timestamp_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::TIME_TZ) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ,
-			                        ScalarFunction::BinaryFunction<date_t, dtime_tz_t, timestamp_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::INTEGER:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			ScalarFunction function("+", {left_type, right_type}, right_type,
-			                        ScalarFunction::BinaryFunction<int32_t, date_t, date_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::INTERVAL:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::INTERVAL,
-			                        ScalarFunction::BinaryFunction<interval_t, interval_t, interval_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::DATE) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<interval_t, date_t, timestamp_t, AddOperator>);
-			BaseScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::TIME) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIME,
-			                        ScalarFunction::BinaryFunction<interval_t, dtime_t, dtime_t, AddTimeOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::TIME_TZ) {
-			ScalarFunction function(
-			    "+", {left_type, right_type}, LogicalType::TIME_TZ,
-			    ScalarFunction::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t, AddTimeOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::TIMESTAMP) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<interval_t, timestamp_t, timestamp_t, AddOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::TIME:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIME,
-			                        ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, AddTimeOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::DATE) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<dtime_t, date_t, timestamp_t, AddOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::TIME_TZ:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ,
-			                        ScalarFunction::BinaryFunction<dtime_tz_t, date_t, timestamp_t, AddOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function(
-			    "+", {left_type, right_type}, LogicalType::TIME_TZ,
-			    ScalarFunction::BinaryFunction<dtime_tz_t, interval_t, dtime_tz_t, AddTimeOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<timestamp_t, interval_t, timestamp_t, AddOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	default:
-		break;
-	}
-	// LCOV_EXCL_START
-	throw NotImplementedException("AddFunction for types %s, %s", EnumUtil::ToString(left_type.id()),
-	                              EnumUtil::ToString(right_type.id()));
-	// LCOV_EXCL_STOP
-}
-
-ScalarFunctionSet OperatorAddFun::GetFunctions() {
-	ScalarFunctionSet add("+");
-	for (auto &type : LogicalType::Numeric()) {
-		// unary add function is a nop, but only exists for numeric types
-		add.AddFunction(AddFunction::GetFunction(type));
-		// binary add function adds two numbers together
-		add.AddFunction(AddFunction::GetFunction(type, type));
-	}
-	// we can add integers to dates
-	add.AddFunction(AddFunction::GetFunction(LogicalType::DATE, LogicalType::INTEGER));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::INTEGER, LogicalType::DATE));
-	// we can add intervals together
-	add.AddFunction(AddFunction::GetFunction(LogicalType::INTERVAL, LogicalType::INTERVAL));
-	// we can add intervals to dates/times/timestamps
-	add.AddFunction(AddFunction::GetFunction(LogicalType::DATE, LogicalType::INTERVAL));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::INTERVAL, LogicalType::DATE));
-
-	add.AddFunction(AddFunction::GetFunction(LogicalType::TIME, LogicalType::INTERVAL));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::INTERVAL, LogicalType::TIME));
-
-	add.AddFunction(AddFunction::GetFunction(LogicalType::TIMESTAMP, LogicalType::INTERVAL));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::INTERVAL, LogicalType::TIMESTAMP));
-
-	add.AddFunction(AddFunction::GetFunction(LogicalType::TIME_TZ, LogicalType::INTERVAL));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::INTERVAL, LogicalType::TIME_TZ));
-
-	// we can add times to dates
-	add.AddFunction(AddFunction::GetFunction(LogicalType::TIME, LogicalType::DATE));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::DATE, LogicalType::TIME));
-
-	// we can add times with time zones (offsets) to dates
-	add.AddFunction(AddFunction::GetFunction(LogicalType::TIME_TZ, LogicalType::DATE));
-	add.AddFunction(AddFunction::GetFunction(LogicalType::DATE, LogicalType::TIME_TZ));
-
-	// we can add lists together
-	add.AddFunction(ListConcatFun::GetFunction());
-
-	return add;
-}
-
-//===--------------------------------------------------------------------===//
-// - [subtract]
-//===--------------------------------------------------------------------===//
-struct NegateOperator {
-	template <class T>
-	static bool CanNegate(T input) {
-		using Limits = NumericLimits<T>;
-		return !(Limits::IsSigned() && Limits::Minimum() == input);
-	}
-
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		auto cast = (TR)input;
-		if (!CanNegate<TR>(cast)) {
-			throw OutOfRangeException("Overflow in negation of integer!");
-		}
-		return -cast;
-	}
-};
-
-template <>
-bool NegateOperator::CanNegate(float input) {
-	return true;
-}
-
-template <>
-bool NegateOperator::CanNegate(double input) {
-	return true;
-}
-
-template <>
-interval_t NegateOperator::Operation(interval_t input) {
-	interval_t result;
-	result.months = NegateOperator::Operation<int32_t, int32_t>(input.months);
-	result.days = NegateOperator::Operation<int32_t, int32_t>(input.days);
-	result.micros = NegateOperator::Operation<int64_t, int64_t>(input.micros);
-	return result;
-}
-
-struct DecimalNegateBindData : public FunctionData {
-	DecimalNegateBindData() : bound_type(LogicalTypeId::INVALID) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		auto res = make_uniq<DecimalNegateBindData>();
-		res->bound_type = bound_type;
-		return std::move(res);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto other = other_p.Cast<DecimalNegateBindData>();
-		return other.bound_type == bound_type;
-	}
-
-	LogicalTypeId bound_type;
-};
-
-unique_ptr<FunctionData> DecimalNegateBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-
-	auto bind_data = make_uniq<DecimalNegateBindData>();
-
-	auto &decimal_type = arguments[0]->return_type;
-	auto width = DecimalType::GetWidth(decimal_type);
-	if (width <= Decimal::MAX_WIDTH_INT16) {
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::SMALLINT);
-	} else if (width <= Decimal::MAX_WIDTH_INT32) {
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::INTEGER);
-	} else if (width <= Decimal::MAX_WIDTH_INT64) {
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::BIGINT);
-	} else {
-		D_ASSERT(width <= Decimal::MAX_WIDTH_INT128);
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::HUGEINT);
-	}
-	decimal_type.Verify();
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = decimal_type;
-	return nullptr;
-}
-
-struct NegatePropagateStatistics {
-	template <class T>
-	static bool Operation(LogicalType type, BaseStatistics &istats, Value &new_min, Value &new_max) {
-		auto max_value = NumericStats::GetMax<T>(istats);
-		auto min_value = NumericStats::GetMin<T>(istats);
-		if (!NegateOperator::CanNegate<T>(min_value) || !NegateOperator::CanNegate<T>(max_value)) {
-			return true;
-		}
-		// new min is -max
-		new_min = Value::Numeric(type, NegateOperator::Operation<T, T>(max_value));
-		// new max is -min
-		new_max = Value::Numeric(type, NegateOperator::Operation<T, T>(min_value));
-		return false;
-	}
-};
-
-static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	auto &istats = child_stats[0];
-	Value new_min, new_max;
-	bool potential_overflow = true;
-	if (NumericStats::HasMinMax(istats)) {
-		switch (expr.return_type.InternalType()) {
-		case PhysicalType::INT8:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int8_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		case PhysicalType::INT16:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int16_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		case PhysicalType::INT32:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int32_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		case PhysicalType::INT64:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int64_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		default:
-			return nullptr;
-		}
-	}
-	if (potential_overflow) {
-		new_min = Value(expr.return_type);
-		new_max = Value(expr.return_type);
-	}
-	auto stats = NumericStats::CreateEmpty(expr.return_type);
-	NumericStats::SetMin(stats, new_min);
-	NumericStats::SetMax(stats, new_max);
-	stats.CopyValidity(istats);
-	return stats.ToUnique();
-}
-
-ScalarFunction SubtractFunction::GetFunction(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::INTERVAL) {
-		ScalarFunction func("-", {type}, type, ScalarFunction::UnaryFunction<interval_t, interval_t, NegateOperator>);
-		ScalarFunction::SetReturnsError(func);
-		return func;
-	} else if (type.id() == LogicalTypeId::DECIMAL) {
-		ScalarFunction func("-", {type}, type, nullptr, DecimalNegateBind, nullptr, NegateBindStatistics);
-		return func;
-	} else {
-		D_ASSERT(type.IsNumeric());
-		ScalarFunction func("-", {type}, type, ScalarFunction::GetScalarUnaryFunction<NegateOperator>(type), nullptr,
-		                    nullptr, NegateBindStatistics);
-		ScalarFunction::SetReturnsError(func);
-		return func;
-	}
-}
-
-ScalarFunction SubtractFunction::GetFunction(const LogicalType &left_type, const LogicalType &right_type) {
-	if (left_type.IsNumeric() && left_type.id() == right_type.id()) {
-		if (left_type.id() == LogicalTypeId::DECIMAL) {
-			ScalarFunction function("-", {left_type, right_type}, left_type, nullptr,
-			                        BindDecimalAddSubtract<SubtractOperator, DecimalSubtractOverflowCheck, true>);
-			ScalarFunction::SetReturnsError(function);
-			function.serialize = SerializeDecimalArithmetic;
-			function.deserialize = DeserializeDecimalArithmetic<SubtractOperator, DecimalSubtractOverflowCheck>;
-			return function;
-		} else if (left_type.IsIntegral()) {
-			ScalarFunction function(
-			    "-", {left_type, right_type}, left_type,
-			    GetScalarIntegerFunction<SubtractOperatorOverflowCheck>(left_type.InternalType()), nullptr, nullptr,
-			    PropagateNumericStats<TrySubtractOperator, SubtractPropagateStatistics, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-
-		} else {
-			ScalarFunction function("-", {left_type, right_type}, left_type,
-			                        GetScalarBinaryFunction<SubtractOperator>(left_type.InternalType()));
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-	}
-
-	switch (left_type.id()) {
-	case LogicalTypeId::DATE:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			ScalarFunction function("-", {left_type, right_type}, LogicalType::BIGINT,
-			                        ScalarFunction::BinaryFunction<date_t, date_t, int64_t, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-
-		} else if (right_type.id() == LogicalTypeId::INTEGER) {
-			ScalarFunction function("-", {left_type, right_type}, LogicalType::DATE,
-			                        ScalarFunction::BinaryFunction<date_t, int32_t, date_t, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function("-", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                        ScalarFunction::BinaryFunction<date_t, interval_t, timestamp_t, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		if (right_type.id() == LogicalTypeId::TIMESTAMP) {
-			ScalarFunction function(
-			    "-", {left_type, right_type}, LogicalType::INTERVAL,
-			    ScalarFunction::BinaryFunction<timestamp_t, timestamp_t, interval_t, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function(
-			    "-", {left_type, right_type}, LogicalType::TIMESTAMP,
-			    ScalarFunction::BinaryFunction<timestamp_t, interval_t, timestamp_t, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::INTERVAL:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function(
-			    "-", {left_type, right_type}, LogicalType::INTERVAL,
-			    ScalarFunction::BinaryFunction<interval_t, interval_t, interval_t, SubtractOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::TIME:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function("-", {left_type, right_type}, LogicalType::TIME,
-			                        ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, SubtractTimeOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	case LogicalTypeId::TIME_TZ:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			ScalarFunction function(
-			    "-", {left_type, right_type}, LogicalType::TIME_TZ,
-			    ScalarFunction::BinaryFunction<dtime_tz_t, interval_t, dtime_tz_t, SubtractTimeOperator>);
-			ScalarFunction::SetReturnsError(function);
-			return function;
-		}
-		break;
-	default:
-		break;
-	}
-	// LCOV_EXCL_START
-	throw NotImplementedException("SubtractFun for types %s, %s", EnumUtil::ToString(left_type.id()),
-	                              EnumUtil::ToString(right_type.id()));
-	// LCOV_EXCL_STOP
-}
-
-ScalarFunctionSet OperatorSubtractFun::GetFunctions() {
-	ScalarFunctionSet subtract("-");
-	for (auto &type : LogicalType::Numeric()) {
-		// unary subtract function, negates the input (i.e. multiplies by -1)
-		subtract.AddFunction(SubtractFunction::GetFunction(type));
-		// binary subtract function "a - b", subtracts b from a
-		subtract.AddFunction(SubtractFunction::GetFunction(type, type));
-	}
-	// we can subtract dates from each other
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::DATE, LogicalType::DATE));
-	// we can subtract integers from dates
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::DATE, LogicalType::INTEGER));
-	// we can subtract timestamps from each other
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP));
-	// we can subtract intervals from each other
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::INTERVAL, LogicalType::INTERVAL));
-	// we can subtract intervals from dates/times/timestamps, but not the other way around
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::DATE, LogicalType::INTERVAL));
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::TIME, LogicalType::INTERVAL));
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::TIMESTAMP, LogicalType::INTERVAL));
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::TIME_TZ, LogicalType::INTERVAL));
-	// we can negate intervals
-	subtract.AddFunction(SubtractFunction::GetFunction(LogicalType::INTERVAL));
-
-	return subtract;
-}
-
-//===--------------------------------------------------------------------===//
-// * [multiply]
-//===--------------------------------------------------------------------===//
-struct MultiplyPropagateStatistics {
-	template <class T, class OP>
-	static bool Operation(LogicalType type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
-	                      Value &new_max) {
-		// statistics propagation on the multiplication is slightly less straightforward because of negative numbers
-		// the new min/max depend on the signs of the input types
-		// if both are positive the result is [lmin * rmin][lmax * rmax]
-		// if lmin/lmax are negative the result is [lmin * rmax][lmax * rmin]
-		// etc
-		// rather than doing all this switcheroo we just multiply all combinations of lmin/lmax with rmin/rmax
-		// and check what the minimum/maximum value is
-		T lvals[] {NumericStats::GetMin<T>(lstats), NumericStats::GetMax<T>(lstats)};
-		T rvals[] {NumericStats::GetMin<T>(rstats), NumericStats::GetMax<T>(rstats)};
-		T min = NumericLimits<T>::Maximum();
-		T max = NumericLimits<T>::Minimum();
-		// multiplications
-		for (idx_t l = 0; l < 2; l++) {
-			for (idx_t r = 0; r < 2; r++) {
-				T result;
-				if (!OP::Operation(lvals[l], rvals[r], result)) {
-					// potential overflow
-					return true;
-				}
-				if (result < min) {
-					min = result;
-				}
-				if (result > max) {
-					max = result;
-				}
-			}
-		}
-		new_min = Value::Numeric(type, min);
-		new_max = Value::Numeric(type, max);
-		return false;
-	}
-};
-
-unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments) {
-
-	auto bind_data = make_uniq<DecimalArithmeticBindData>();
-
-	uint8_t result_width = 0, result_scale = 0;
-	uint8_t max_width = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (arguments[i]->return_type.id() == LogicalTypeId::UNKNOWN) {
-			continue;
-		}
-		uint8_t width, scale;
-		auto can_convert = arguments[i]->return_type.GetDecimalProperties(width, scale);
-		if (!can_convert) {
-			throw InternalException("Could not convert type %s to a decimal?", arguments[i]->return_type.ToString());
-		}
-		if (width > max_width) {
-			max_width = width;
-		}
-		result_width += width;
-		result_scale += scale;
-	}
-	D_ASSERT(max_width > 0);
-	if (result_scale > Decimal::MAX_WIDTH_DECIMAL) {
-		throw OutOfRangeException(
-		    "Needed scale %d to accurately represent the multiplication result, but this is out of range of the "
-		    "DECIMAL type. Max scale is %d; could not perform an accurate multiplication. Either add a cast to DOUBLE, "
-		    "or add an explicit cast to a decimal with a lower scale.",
-		    result_scale, Decimal::MAX_WIDTH_DECIMAL);
-	}
-	if (result_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64 &&
-	    result_scale < Decimal::MAX_WIDTH_INT64) {
-		bind_data->check_overflow = true;
-		result_width = Decimal::MAX_WIDTH_INT64;
-	}
-	if (result_width > Decimal::MAX_WIDTH_DECIMAL) {
-		bind_data->check_overflow = true;
-		result_width = Decimal::MAX_WIDTH_DECIMAL;
-	}
-	LogicalType result_type = LogicalType::DECIMAL(result_width, result_scale);
-	// since our scale is the summation of our input scales, we do not need to cast to the result scale
-	// however, we might need to cast to the correct internal type
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		auto &argument_type = arguments[i]->return_type;
-		if (argument_type.InternalType() == result_type.InternalType()) {
-			bound_function.arguments[i] = argument_type;
-		} else {
-			uint8_t width, scale;
-			if (!argument_type.GetDecimalProperties(width, scale)) {
-				scale = 0;
-			}
-
-			bound_function.arguments[i] = LogicalType::DECIMAL(result_width, scale);
-		}
-	}
-	result_type.Verify();
-	bound_function.return_type = result_type;
-	// now select the physical function to execute
-	if (bind_data->check_overflow) {
-		bound_function.function = GetScalarBinaryFunction<DecimalMultiplyOverflowCheck>(result_type.InternalType());
-	} else {
-		bound_function.function = GetScalarBinaryFunction<MultiplyOperator>(result_type.InternalType());
-	}
-	if (result_type.InternalType() != PhysicalType::INT128) {
-		bound_function.statistics =
-		    PropagateNumericStats<TryDecimalMultiply, MultiplyPropagateStatistics, MultiplyOperator>;
-	}
-	return std::move(bind_data);
-}
-
-ScalarFunctionSet OperatorMultiplyFun::GetFunctions() {
-	ScalarFunctionSet multiply("*");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			ScalarFunction function({type, type}, type, nullptr, BindDecimalMultiply);
-			function.serialize = SerializeDecimalArithmetic;
-			function.deserialize = DeserializeDecimalArithmetic<MultiplyOperator, DecimalMultiplyOverflowCheck>;
-			multiply.AddFunction(function);
-		} else if (TypeIsIntegral(type.InternalType())) {
-			multiply.AddFunction(ScalarFunction(
-			    {type, type}, type, GetScalarIntegerFunction<MultiplyOperatorOverflowCheck>(type.InternalType()),
-			    nullptr, nullptr,
-			    PropagateNumericStats<TryMultiplyOperator, MultiplyPropagateStatistics, MultiplyOperator>));
-		} else {
-			multiply.AddFunction(
-			    ScalarFunction({type, type}, type, GetScalarBinaryFunction<MultiplyOperator>(type.InternalType())));
-		}
-	}
-	multiply.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   ScalarFunction::BinaryFunction<interval_t, int64_t, interval_t, MultiplyOperator>));
-	multiply.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTERVAL}, LogicalType::INTERVAL,
-	                   ScalarFunction::BinaryFunction<int64_t, interval_t, interval_t, MultiplyOperator>));
-	for (auto &func : multiply.functions) {
-		ScalarFunction::SetReturnsError(func);
-	}
-
-	return multiply;
-}
-
-//===--------------------------------------------------------------------===//
-// / [divide]
-//===--------------------------------------------------------------------===//
-template <>
-float DivideOperator::Operation(float left, float right) {
-	auto result = left / right;
-	return result;
-}
-
-template <>
-double DivideOperator::Operation(double left, double right) {
-	auto result = left / right;
-	return result;
-}
-
-template <>
-hugeint_t DivideOperator::Operation(hugeint_t left, hugeint_t right) {
-	if (right.lower == 0 && right.upper == 0) {
-		throw InternalException("Hugeint division by zero!");
-	}
-	return left / right;
-}
-
-template <>
-interval_t DivideOperator::Operation(interval_t left, int64_t right) {
-	left.days = UnsafeNumericCast<int32_t>(left.days / right);
-	left.months = UnsafeNumericCast<int32_t>(left.months / right);
-	left.micros /= right;
-	return left;
-}
-
-struct BinaryNumericDivideWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		if (left == NumericLimits<LEFT_TYPE>::Minimum() && right == -1) {
-			throw OutOfRangeException("Overflow in division of %d / %d", left, right);
-		} else if (right == 0) {
-			mask.SetInvalid(idx);
-			return left;
-		} else {
-			return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-		}
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-struct BinaryZeroIsNullWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		if (right == 0) {
-			mask.SetInvalid(idx);
-			return left;
-		} else {
-			return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-		}
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-struct BinaryNumericDivideHugeintWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		if (left == NumericLimits<LEFT_TYPE>::Minimum() && right == -1) {
-			throw OutOfRangeException("Overflow in division of %s / %s", left.ToString(), right.ToString());
-		} else if (right == 0) {
-			mask.SetInvalid(idx);
-			return left;
-		} else {
-			return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-		}
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-template <class TA, class TB, class TC, class OP, class ZWRAPPER = BinaryZeroIsNullWrapper>
-static void BinaryScalarFunctionIgnoreZero(DataChunk &input, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<TA, TB, TC, OP, ZWRAPPER>(input.data[0], input.data[1], result, input.size());
-}
-
-template <class OP>
-static scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT8:
-		return BinaryScalarFunctionIgnoreZero<int8_t, int8_t, int8_t, OP, BinaryNumericDivideWrapper>;
-	case PhysicalType::INT16:
-		return BinaryScalarFunctionIgnoreZero<int16_t, int16_t, int16_t, OP, BinaryNumericDivideWrapper>;
-	case PhysicalType::INT32:
-		return BinaryScalarFunctionIgnoreZero<int32_t, int32_t, int32_t, OP, BinaryNumericDivideWrapper>;
-	case PhysicalType::INT64:
-		return BinaryScalarFunctionIgnoreZero<int64_t, int64_t, int64_t, OP, BinaryNumericDivideWrapper>;
-	case PhysicalType::UINT8:
-		return BinaryScalarFunctionIgnoreZero<uint8_t, uint8_t, uint8_t, OP>;
-	case PhysicalType::UINT16:
-		return BinaryScalarFunctionIgnoreZero<uint16_t, uint16_t, uint16_t, OP>;
-	case PhysicalType::UINT32:
-		return BinaryScalarFunctionIgnoreZero<uint32_t, uint32_t, uint32_t, OP>;
-	case PhysicalType::UINT64:
-		return BinaryScalarFunctionIgnoreZero<uint64_t, uint64_t, uint64_t, OP>;
-	case PhysicalType::INT128:
-		return BinaryScalarFunctionIgnoreZero<hugeint_t, hugeint_t, hugeint_t, OP, BinaryNumericDivideHugeintWrapper>;
-	case PhysicalType::UINT128:
-		return BinaryScalarFunctionIgnoreZero<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
-	case PhysicalType::FLOAT:
-		return BinaryScalarFunctionIgnoreZero<float, float, float, OP>;
-	case PhysicalType::DOUBLE:
-		return BinaryScalarFunctionIgnoreZero<double, double, double, OP>;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarUnaryFunction");
-	}
-}
-
-template <class OP>
-unique_ptr<FunctionData> BindBinaryFloatingPoint(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (config.ieee_floating_point_ops) {
-		bound_function.function = GetScalarBinaryFunction<OP>(bound_function.return_type.InternalType());
-	} else {
-		bound_function.function = GetBinaryFunctionIgnoreZero<OP>(bound_function.return_type.InternalType());
-	}
-	return nullptr;
-}
-
-ScalarFunctionSet OperatorFloatDivideFun::GetFunctions() {
-	ScalarFunctionSet fp_divide("/");
-	fp_divide.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT, nullptr,
-	                                     BindBinaryFloatingPoint<DivideOperator>));
-	fp_divide.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE, nullptr,
-	                                     BindBinaryFloatingPoint<DivideOperator>));
-	fp_divide.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
-	for (auto &func : fp_divide.functions) {
-		ScalarFunction::SetReturnsError(func);
-	}
-	return fp_divide;
-}
-
-ScalarFunctionSet OperatorIntegerDivideFun::GetFunctions() {
-	ScalarFunctionSet full_divide("//");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			continue;
-		} else {
-			full_divide.AddFunction(
-			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type.InternalType())));
-		}
-	}
-	for (auto &func : full_divide.functions) {
-		ScalarFunction::SetReturnsError(func);
-	}
-	return full_divide;
-}
-
-//===--------------------------------------------------------------------===//
-// % [modulo]
-//===--------------------------------------------------------------------===//
-template <class OP>
-unique_ptr<FunctionData> BindDecimalModulo(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindDecimalArithmetic<true>(context, bound_function, arguments);
-	// now select the physical function to execute
-	if (bind_data->check_overflow) {
-		// fallback to DOUBLE if the decimal type is not guaranteed to fit within the max decimal width
-		for (auto &arg : bound_function.arguments) {
-			arg = LogicalType::DOUBLE;
-		}
-		bound_function.return_type = LogicalType::DOUBLE;
-	}
-	auto &result_type = bound_function.return_type;
-	bound_function.function = GetBinaryFunctionIgnoreZero<OP>(result_type.InternalType());
-	return std::move(bind_data);
-}
-
-template <>
-float ModuloOperator::Operation(float left, float right) {
-	auto result = std::fmod(left, right);
-	return result;
-}
-
-template <>
-double ModuloOperator::Operation(double left, double right) {
-	auto result = std::fmod(left, right);
-	return result;
-}
-
-template <>
-hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right) {
-	if (right.lower == 0 && right.upper == 0) {
-		throw InternalException("Hugeint division by zero!");
-	}
-	return left % right;
-}
-
-ScalarFunctionSet OperatorModuloFun::GetFunctions() {
-	ScalarFunctionSet modulo("%");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::FLOAT || type.id() == LogicalTypeId::DOUBLE) {
-			modulo.AddFunction(ScalarFunction({type, type}, type, nullptr, BindBinaryFloatingPoint<ModuloOperator>));
-		} else if (type.id() == LogicalTypeId::DECIMAL) {
-			modulo.AddFunction(ScalarFunction({type, type}, type, nullptr, BindDecimalModulo<ModuloOperator>));
-		} else {
-			modulo.AddFunction(
-			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<ModuloOperator>(type.InternalType())));
-		}
-	}
-	for (auto &func : modulo.functions) {
-		ScalarFunction::SetReturnsError(func);
-	}
-
-	return modulo;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/operator/multiply.cpp b/src/duckdb/src/function/scalar/operator/multiply.cpp
deleted file mode 100644
index c2ae20767..000000000
--- a/src/duckdb/src/function/scalar/operator/multiply.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-#include "duckdb/common/operator/multiply.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-
-#include <limits>
-#include <algorithm>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// * [multiply]
-//===--------------------------------------------------------------------===//
-template <>
-float MultiplyOperator::Operation(float left, float right) {
-	auto result = left * right;
-	return result;
-}
-
-template <>
-double MultiplyOperator::Operation(double left, double right) {
-	auto result = left * right;
-	return result;
-}
-
-template <>
-interval_t MultiplyOperator::Operation(interval_t left, int64_t right) {
-	const auto right32 = Cast::Operation<int64_t, int32_t>(right);
-	left.months = MultiplyOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.months, right32);
-	left.days = MultiplyOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.days, right32);
-	left.micros = MultiplyOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(left.micros, right);
-	return left;
-}
-
-template <>
-interval_t MultiplyOperator::Operation(int64_t left, interval_t right) {
-	return MultiplyOperator::Operation<interval_t, int64_t, interval_t>(right, left);
-}
-
-//===--------------------------------------------------------------------===//
-// * [multiply] with overflow check
-//===--------------------------------------------------------------------===//
-struct OverflowCheckedMultiply {
-	template <class SRCTYPE, class UTYPE>
-	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
-		UTYPE uresult = MultiplyOperator::Operation<UTYPE, UTYPE, UTYPE>(UTYPE(left), UTYPE(right));
-		if (uresult < NumericLimits<SRCTYPE>::Minimum() || uresult > NumericLimits<SRCTYPE>::Maximum()) {
-			return false;
-		}
-		result = SRCTYPE(uresult);
-		return true;
-	}
-};
-
-template <>
-bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
-	return OverflowCheckedMultiply::Operation<uint8_t, uint16_t>(left, right, result);
-}
-template <>
-bool TryMultiplyOperator::Operation(uint16_t left, uint16_t right, uint16_t &result) {
-	return OverflowCheckedMultiply::Operation<uint16_t, uint32_t>(left, right, result);
-}
-template <>
-bool TryMultiplyOperator::Operation(uint32_t left, uint32_t right, uint32_t &result) {
-	return OverflowCheckedMultiply::Operation<uint32_t, uint64_t>(left, right, result);
-}
-template <>
-bool TryMultiplyOperator::Operation(uint64_t left, uint64_t right, uint64_t &result) {
-	if (left > right) {
-		std::swap(left, right);
-	}
-	if (left > NumericLimits<uint32_t>::Maximum()) {
-		return false;
-	}
-	uint32_t c = right >> 32;
-	uint32_t d = NumericLimits<uint32_t>::Maximum() & right;
-	uint64_t r = left * c;
-	uint64_t s = left * d;
-	if (r > NumericLimits<uint32_t>::Maximum()) {
-		return false;
-	}
-	r <<= 32;
-	if (NumericLimits<uint64_t>::Maximum() - s < r) {
-		return false;
-	}
-	return OverflowCheckedMultiply::Operation<uint64_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int8_t left, int8_t right, int8_t &result) {
-	return OverflowCheckedMultiply::Operation<int8_t, int16_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int16_t left, int16_t right, int16_t &result) {
-	return OverflowCheckedMultiply::Operation<int16_t, int32_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result) {
-	return OverflowCheckedMultiply::Operation<int32_t, int64_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result) {
-#if (__GNUC__ >= 5) || defined(__clang__)
-	if (__builtin_mul_overflow(left, right, &result)) {
-		return false;
-	}
-#else
-	if (left == std::numeric_limits<int64_t>::min()) {
-		if (right == 0) {
-			result = 0;
-			return true;
-		}
-		if (right == 1) {
-			result = left;
-			return true;
-		}
-		return false;
-	}
-	if (right == std::numeric_limits<int64_t>::min()) {
-		if (left == 0) {
-			result = 0;
-			return true;
-		}
-		if (left == 1) {
-			result = right;
-			return true;
-		}
-		return false;
-	}
-	uint64_t left_non_negative = uint64_t(std::abs(left));
-	uint64_t right_non_negative = uint64_t(std::abs(right));
-	// split values into 2 32-bit parts
-	uint64_t left_high_bits = left_non_negative >> 32;
-	uint64_t left_low_bits = left_non_negative & 0xffffffff;
-	uint64_t right_high_bits = right_non_negative >> 32;
-	uint64_t right_low_bits = right_non_negative & 0xffffffff;
-
-	// check the high bits of both
-	// the high bits define the overflow
-	if (left_high_bits == 0) {
-		if (right_high_bits != 0) {
-			// only the right has high bits set
-			// multiply the high bits of right with the low bits of left
-			// multiply the low bits, and carry any overflow to the high bits
-			// then check for any overflow
-			auto low_low = left_low_bits * right_low_bits;
-			auto low_high = left_low_bits * right_high_bits;
-			auto high_bits = low_high + (low_low >> 32);
-			if (high_bits & 0xffffff80000000) {
-				// there is! abort
-				return false;
-			}
-		}
-	} else if (right_high_bits == 0) {
-		// only the left has high bits set
-		// multiply the high bits of left with the low bits of right
-		// multiply the low bits, and carry any overflow to the high bits
-		// then check for any overflow
-		auto low_low = left_low_bits * right_low_bits;
-		auto high_low = left_high_bits * right_low_bits;
-		auto high_bits = high_low + (low_low >> 32);
-		if (high_bits & 0xffffff80000000) {
-			// there is! abort
-			return false;
-		}
-	} else {
-		// both left and right have high bits set: guaranteed overflow
-		// abort!
-		return false;
-	}
-	// now we know that there is no overflow, we can just perform the multiplication
-	result = left * right;
-#endif
-	return true;
-}
-
-template <>
-bool TryMultiplyOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	return Hugeint::TryMultiply(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result) {
-	return Uhugeint::TryMultiply(left, right, result);
-}
-
-//===--------------------------------------------------------------------===//
-// multiply  decimal with overflow check
-//===--------------------------------------------------------------------===//
-template <class T, T min, T max>
-bool TryDecimalMultiplyTemplated(T left, T right, T &result) {
-	if (!TryMultiplyOperator::Operation(left, right, result) || result < min || result > max) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryDecimalMultiply::Operation(int16_t left, int16_t right, int16_t &result) {
-	return TryDecimalMultiplyTemplated<int16_t, -9999, 9999>(left, right, result);
-}
-
-template <>
-bool TryDecimalMultiply::Operation(int32_t left, int32_t right, int32_t &result) {
-	return TryDecimalMultiplyTemplated<int32_t, -999999999, 999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result) {
-	return TryDecimalMultiplyTemplated<int64_t, -999999999999999999, 999999999999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	if (!TryMultiplyOperator::Operation(left, right, result)) {
-		return false;
-	}
-	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
-	hugeint_t result;
-	if (!TryDecimalMultiply::Operation(left, right, result)) {
-		throw OutOfRangeException("Overflow in multiplication of DECIMAL(38) (%s * %s). You might want to add an "
-		                          "explicit cast to a decimal with a smaller scale.",
-		                          left.ToString(), right.ToString());
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/operator/subtract.cpp b/src/duckdb/src/function/scalar/operator/subtract.cpp
deleted file mode 100644
index 3a102b669..000000000
--- a/src/duckdb/src/function/scalar/operator/subtract.cpp
+++ /dev/null
@@ -1,243 +0,0 @@
-#include "duckdb/common/operator/subtract.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// - [subtract]
-//===--------------------------------------------------------------------===//
-template <>
-float SubtractOperator::Operation(float left, float right) {
-	auto result = left - right;
-	return result;
-}
-
-template <>
-double SubtractOperator::Operation(double left, double right) {
-	auto result = left - right;
-	return result;
-}
-
-template <>
-int64_t SubtractOperator::Operation(date_t left, date_t right) {
-	return int64_t(left.days) - int64_t(right.days);
-}
-
-template <>
-date_t SubtractOperator::Operation(date_t left, int32_t right) {
-	if (!Date::IsFinite(left)) {
-		return left;
-	}
-	int32_t days;
-	if (!TrySubtractOperator::Operation(left.days, right, days)) {
-		throw OutOfRangeException("Date out of range");
-	}
-
-	date_t result(days);
-	if (!Date::IsFinite(result)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	return result;
-}
-
-template <>
-interval_t SubtractOperator::Operation(interval_t left, interval_t right) {
-	interval_t result;
-	if (!TrySubtractOperator::Operation(left.months, right.months, result.months)) {
-		throw OutOfRangeException("Interval months subtraction out of range");
-	}
-	if (!TrySubtractOperator::Operation(left.days, right.days, result.days)) {
-		throw OutOfRangeException("Interval days subtraction out of range");
-	}
-	if (!TrySubtractOperator::Operation(left.micros, right.micros, result.micros)) {
-		throw OutOfRangeException("Interval micros subtraction out of range");
-	}
-	return result;
-}
-
-template <>
-timestamp_t SubtractOperator::Operation(date_t left, interval_t right) {
-	return AddOperator::Operation<date_t, interval_t, timestamp_t>(left, Interval::Invert(right));
-}
-
-template <>
-timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right) {
-	return AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(left, Interval::Invert(right));
-}
-
-template <>
-interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right) {
-	return Interval::GetDifference(left, right);
-}
-
-//===--------------------------------------------------------------------===//
-// - [subtract] with overflow check
-//===--------------------------------------------------------------------===//
-struct OverflowCheckedSubtract {
-	template <class SRCTYPE, class UTYPE>
-	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
-		UTYPE uresult = SubtractOperator::Operation<UTYPE, UTYPE, UTYPE>(UTYPE(left), UTYPE(right));
-		if (uresult < NumericLimits<SRCTYPE>::Minimum() || uresult > NumericLimits<SRCTYPE>::Maximum()) {
-			return false;
-		}
-		result = SRCTYPE(uresult);
-		return true;
-	}
-};
-
-template <>
-bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint8_t, uint16_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint16_t, uint32_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint32_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint64_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result) {
-	return OverflowCheckedSubtract::Operation<int8_t, int16_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result) {
-	return OverflowCheckedSubtract::Operation<int16_t, int32_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result) {
-	return OverflowCheckedSubtract::Operation<int32_t, int64_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result) {
-#if (__GNUC__ >= 5) || defined(__clang__)
-	if (__builtin_sub_overflow(left, right, &result)) {
-		return false;
-	}
-#else
-	if (right < 0) {
-		if (NumericLimits<int64_t>::Maximum() + right < left) {
-			return false;
-		}
-	} else {
-		if (NumericLimits<int64_t>::Minimum() + right > left) {
-			return false;
-		}
-	}
-	result = left - right;
-#endif
-	return true;
-}
-
-template <>
-bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left;
-	return Hugeint::TrySubtractInPlace(result, right);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result) {
-	result = left;
-	return Uhugeint::TrySubtractInPlace(result, right);
-}
-
-//===--------------------------------------------------------------------===//
-// subtract decimal with overflow check
-//===--------------------------------------------------------------------===//
-template <class T, T min, T max>
-bool TryDecimalSubtractTemplated(T left, T right, T &result) {
-	if (right < 0) {
-		if (max + right < left) {
-			return false;
-		}
-	} else {
-		if (min + right > left) {
-			return false;
-		}
-	}
-	result = left - right;
-	return true;
-}
-
-template <>
-bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result) {
-	return TryDecimalSubtractTemplated<int16_t, -9999, 9999>(left, right, result);
-}
-
-template <>
-bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result) {
-	return TryDecimalSubtractTemplated<int32_t, -999999999, 999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result) {
-	return TryDecimalSubtractTemplated<int64_t, -999999999999999999, 999999999999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	if (!TrySubtractOperator::Operation(left, right, result)) {
-		return false;
-	}
-	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
-	hugeint_t result;
-	if (!TryDecimalSubtract::Operation(left, right, result)) {
-		throw OutOfRangeException("Overflow in subtract of DECIMAL(38) (%s - %s);", left.ToString(), right.ToString());
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// subtract time operator
-//===--------------------------------------------------------------------===//
-template <>
-dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right) {
-	right.micros = -right.micros;
-	return AddTimeOperator::Operation<dtime_t, interval_t, dtime_t>(left, right);
-}
-
-template <>
-dtime_tz_t SubtractTimeOperator::Operation(dtime_tz_t left, interval_t right) {
-	right.micros = -right.micros;
-	return AddTimeOperator::Operation<dtime_tz_t, interval_t, dtime_tz_t>(left, right);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/pragma_functions.cpp b/src/duckdb/src/function/scalar/pragma_functions.cpp
deleted file mode 100644
index dfce174c4..000000000
--- a/src/duckdb/src/function/scalar/pragma_functions.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "duckdb/function/pragma/pragma_functions.hpp"
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterPragmaFunctions() {
-	Register<PragmaQueries>();
-	Register<PragmaFunctions>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/sequence/nextval.cpp b/src/duckdb/src/function/scalar/sequence/nextval.cpp
deleted file mode 100644
index 6738383dc..000000000
--- a/src/duckdb/src/function/scalar/sequence/nextval.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-#include "duckdb/function/scalar/sequence_functions.hpp"
-#include "duckdb/function/scalar/sequence_utils.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-struct CurrentSequenceValueOperator {
-	static int64_t Operation(DuckTransaction &, SequenceCatalogEntry &seq) {
-		return seq.CurrentValue();
-	}
-};
-
-struct NextSequenceValueOperator {
-	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry &seq) {
-		return seq.NextValue(transaction);
-	}
-};
-
-SequenceCatalogEntry &BindSequence(Binder &binder, string &catalog, string &schema, const string &name) {
-	// fetch the sequence from the catalog
-	Binder::BindSchemaOrCatalog(binder.context, catalog, schema);
-	return binder.EntryRetriever()
-	    .GetEntry(CatalogType::SEQUENCE_ENTRY, catalog, schema, name)
-	    ->Cast<SequenceCatalogEntry>();
-}
-
-SequenceCatalogEntry &BindSequenceFromContext(ClientContext &context, string &catalog, string &schema,
-                                              const string &name) {
-	Binder::BindSchemaOrCatalog(context, catalog, schema);
-	return Catalog::GetEntry<SequenceCatalogEntry>(context, catalog, schema, name);
-}
-
-SequenceCatalogEntry &BindSequence(Binder &binder, const string &name) {
-	auto qname = QualifiedName::Parse(name);
-	return BindSequence(binder, qname.catalog, qname.schema, qname.name);
-}
-
-struct NextValLocalState : public FunctionLocalState {
-	explicit NextValLocalState(DuckTransaction &transaction, SequenceCatalogEntry &sequence)
-	    : transaction(transaction), sequence(sequence) {
-	}
-
-	DuckTransaction &transaction;
-	SequenceCatalogEntry &sequence;
-};
-
-unique_ptr<FunctionLocalState> NextValLocalFunction(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                    FunctionData *bind_data) {
-	if (!bind_data) {
-		return nullptr;
-	}
-	auto &context = state.GetContext();
-	auto &info = bind_data->Cast<NextvalBindData>();
-	auto &sequence = info.sequence;
-	auto &transaction = DuckTransaction::Get(context, sequence.catalog);
-	return make_uniq<NextValLocalState>(transaction, sequence);
-}
-
-template <class OP>
-static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	if (!func_expr.bind_info) {
-		// no bind info - return null
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<NextValLocalState>();
-	// sequence to use is hard coded
-	// increment the sequence
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<int64_t>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		// get the next value from the sequence
-		result_data[i] = OP::Operation(lstate.transaction, lstate.sequence);
-	}
-}
-
-static unique_ptr<FunctionData> NextValBind(ScalarFunctionBindInput &bind_input, ScalarFunction &,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[0]->IsFoldable()) {
-		throw NotImplementedException(
-		    "currval/nextval requires a constant sequence - non-constant sequences are no longer supported");
-	}
-	auto &binder = bind_input.binder;
-	// parameter to nextval function is a foldable constant
-	// evaluate the constant and perform the catalog lookup already
-	auto seqname = ExpressionExecutor::EvaluateScalar(binder.context, *arguments[0]);
-	if (seqname.IsNull()) {
-		return nullptr;
-	}
-	auto &seq = BindSequence(binder, seqname.ToString());
-	return make_uniq<NextvalBindData>(seq);
-}
-
-void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data, const ScalarFunction &) {
-	auto &next_val_bind_data = bind_data->Cast<NextvalBindData>();
-	serializer.WritePropertyWithDefault(100, "sequence_create_info", next_val_bind_data.create_info);
-}
-
-unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &) {
-	auto create_info = deserializer.ReadPropertyWithExplicitDefault<unique_ptr<CreateInfo>>(100, "sequence_create_info",
-	                                                                                        unique_ptr<CreateInfo>());
-	if (!create_info) {
-		return nullptr;
-	}
-	auto &seq_info = create_info->Cast<CreateSequenceInfo>();
-	auto &context = deserializer.Get<ClientContext &>();
-	auto &sequence = BindSequenceFromContext(context, seq_info.catalog, seq_info.schema, seq_info.name);
-	return make_uniq<NextvalBindData>(sequence);
-}
-
-void NextValModifiedDatabases(ClientContext &context, FunctionModifiedDatabasesInput &input) {
-	if (!input.bind_data) {
-		return;
-	}
-	auto &seq = input.bind_data->Cast<NextvalBindData>();
-	input.properties.RegisterDBModify(seq.sequence.ParentCatalog(), context);
-}
-
-ScalarFunction NextvalFun::GetFunction() {
-	ScalarFunction next_val("nextval", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                        NextValFunction<NextSequenceValueOperator>, nullptr, nullptr);
-	next_val.bind_extended = NextValBind;
-	next_val.stability = FunctionStability::VOLATILE;
-	next_val.serialize = Serialize;
-	next_val.deserialize = Deserialize;
-	next_val.get_modified_databases = NextValModifiedDatabases;
-	next_val.init_local_state = NextValLocalFunction;
-	BaseScalarFunction::SetReturnsError(next_val);
-	return next_val;
-}
-
-ScalarFunction CurrvalFun::GetFunction() {
-	ScalarFunction curr_val("currval", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                        NextValFunction<CurrentSequenceValueOperator>, nullptr, nullptr);
-	curr_val.bind_extended = NextValBind;
-	curr_val.stability = FunctionStability::VOLATILE;
-	curr_val.serialize = Serialize;
-	curr_val.deserialize = Deserialize;
-	curr_val.init_local_state = NextValLocalFunction;
-	BaseScalarFunction::SetReturnsError(curr_val);
-	return curr_val;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/strftime_format.cpp b/src/duckdb/src/function/scalar/strftime_format.cpp
deleted file mode 100644
index 8ab46ace7..000000000
--- a/src/duckdb/src/function/scalar/strftime_format.cpp
+++ /dev/null
@@ -1,1594 +0,0 @@
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-
-#include <cctype>
-
-namespace duckdb {
-
-idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
-	switch (specifier) {
-	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
-	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME:
-		return 3;
-	case StrTimeSpecifier::WEEKDAY_DECIMAL:
-	case StrTimeSpecifier::WEEKDAY_ISO:
-		return 1;
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-	case StrTimeSpecifier::HOUR_24_PADDED:
-	case StrTimeSpecifier::HOUR_12_PADDED:
-	case StrTimeSpecifier::MINUTE_PADDED:
-	case StrTimeSpecifier::SECOND_PADDED:
-	case StrTimeSpecifier::AM_PM:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_ISO:
-		return 2;
-	case StrTimeSpecifier::NANOSECOND_PADDED:
-		return 9;
-	case StrTimeSpecifier::MICROSECOND_PADDED:
-		return 6;
-	case StrTimeSpecifier::MILLISECOND_PADDED:
-		return 3;
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-		return 3;
-	case StrTimeSpecifier::YEAR_ISO:
-		return 4;
-	default:
-		return 0;
-	}
-}
-
-void StrTimeFormat::AddLiteral(string literal) {
-	constant_size += literal.size();
-	literals.push_back(std::move(literal));
-}
-
-void StrTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
-	AddLiteral(std::move(preceding_literal));
-	specifiers.push_back(specifier);
-}
-
-void StrfTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
-	is_date_specifier.push_back(IsDateSpecifier(specifier));
-	idx_t specifier_size = StrfTimepecifierSize(specifier);
-	if (specifier_size == 0) {
-		// variable length specifier
-		var_length_specifiers.push_back(specifier);
-	} else {
-		// constant size specifier
-		constant_size += specifier_size;
-	}
-	StrTimeFormat::AddFormatSpecifier(std::move(preceding_literal), specifier);
-}
-
-idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date, int32_t data[8],
-                                         const char *tz_name) {
-	switch (specifier) {
-	case StrTimeSpecifier::FULL_WEEKDAY_NAME:
-		return Date::DAY_NAMES[Date::ExtractISODayOfTheWeek(date) % 7].GetSize();
-	case StrTimeSpecifier::FULL_MONTH_NAME:
-		return Date::MONTH_NAMES[data[1] - 1].GetSize();
-	case StrTimeSpecifier::YEAR_DECIMAL: {
-		auto year = data[0];
-		// Be consistent with WriteStandardSpecifier
-		if (0 <= year && year <= 9999) {
-			return 4;
-		} else {
-			return UnsafeNumericCast<idx_t>(NumericHelper::SignedLength<int32_t, uint32_t>(year));
-		}
-	}
-	case StrTimeSpecifier::MONTH_DECIMAL: {
-		idx_t len = 1;
-		auto month = data[1];
-		len += month >= 10;
-		return len;
-	}
-	case StrTimeSpecifier::UTC_OFFSET:
-		// ±HH or ±HH:MM
-		return (data[7] % 60) ? 6 : 3;
-	case StrTimeSpecifier::TZ_NAME:
-		if (tz_name) {
-			return strlen(tz_name);
-		}
-		// empty for now
-		return 0;
-	case StrTimeSpecifier::HOUR_24_DECIMAL:
-	case StrTimeSpecifier::HOUR_12_DECIMAL:
-	case StrTimeSpecifier::MINUTE_DECIMAL:
-	case StrTimeSpecifier::SECOND_DECIMAL: {
-		// time specifiers
-		idx_t len = 1;
-		int32_t hour = data[3], min = data[4], sec = data[5];
-		switch (specifier) {
-		case StrTimeSpecifier::HOUR_24_DECIMAL:
-			len += hour >= 10;
-			break;
-		case StrTimeSpecifier::HOUR_12_DECIMAL:
-			hour = hour % 12;
-			if (hour == 0) {
-				hour = 12;
-			}
-			len += hour >= 10;
-			break;
-		case StrTimeSpecifier::MINUTE_DECIMAL:
-			len += min >= 10;
-			break;
-		case StrTimeSpecifier::SECOND_DECIMAL:
-			len += sec >= 10;
-			break;
-		default:
-			throw InternalException("Time specifier mismatch");
-		}
-		return len;
-	}
-	case StrTimeSpecifier::DAY_OF_MONTH:
-		return UnsafeNumericCast<idx_t>(NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(data[2])));
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-		return UnsafeNumericCast<idx_t>(
-		    NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(Date::ExtractDayOfTheYear(date))));
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-		return UnsafeNumericCast<idx_t>(
-		    NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(AbsValue(data[0]) % 100)));
-	default:
-		throw InternalException("Unimplemented specifier for GetSpecifierLength");
-	}
-}
-
-//! Returns the total length of the date formatted by this format specifier
-idx_t StrfTimeFormat::GetLength(date_t date, int32_t data[8], const char *tz_name) const {
-	idx_t size = constant_size;
-	if (!var_length_specifiers.empty()) {
-		for (auto &specifier : var_length_specifiers) {
-			size += GetSpecifierLength(specifier, date, data, tz_name);
-		}
-	}
-	return size;
-}
-
-idx_t StrfTimeFormat::GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name) {
-	if (!var_length_specifiers.empty()) {
-		int32_t data[8];
-		Date::Convert(date, data[0], data[1], data[2]);
-		Time::Convert(time, data[3], data[4], data[5], data[6]);
-		data[6] *= Interval::NANOS_PER_MICRO;
-		data[7] = utc_offset;
-		return GetLength(date, data, tz_name);
-	}
-	return constant_size;
-}
-
-char *StrfTimeFormat::WriteString(char *target, const string_t &str) const {
-	idx_t size = str.GetSize();
-	memcpy(target, str.GetData(), size);
-	return target + size;
-}
-
-// write a value in the range of 0..99 unpadded (e.g. "1", "2", ... "98", "99")
-char *StrfTimeFormat::Write2(char *target, uint8_t value) const {
-	D_ASSERT(value < 100);
-	if (value >= 10) {
-		return WritePadded2(target, value);
-	} else {
-		*target = char(uint8_t('0') + value);
-		return target + 1;
-	}
-}
-
-// write a value in the range of 0..99 padded to 2 digits
-char *StrfTimeFormat::WritePadded2(char *target, uint32_t value) const {
-	D_ASSERT(value < 100);
-	auto index = static_cast<unsigned>(value * 2);
-	*target++ = duckdb_fmt::internal::data::digits[index];
-	*target++ = duckdb_fmt::internal::data::digits[index + 1];
-	return target;
-}
-
-// write a value in the range of 0..999 padded
-char *StrfTimeFormat::WritePadded3(char *target, uint32_t value) const {
-	D_ASSERT(value < 1000);
-	if (value >= 100) {
-		WritePadded2(target + 1, value % 100);
-		*target = char(uint8_t('0') + value / 100);
-		return target + 3;
-	} else {
-		*target = '0';
-		target++;
-		return WritePadded2(target, value);
-	}
-}
-
-// write a value in the range of 0..999999... padded to the given number of digits
-char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding) const {
-	D_ASSERT(padding > 1);
-	if (padding % 2) {
-		uint32_t decimals = value % 1000u;
-		WritePadded3(target + padding - 3, decimals);
-		value /= 1000;
-		padding -= 3;
-	}
-	for (size_t i = 0; i < padding / 2; i++) {
-		uint32_t decimals = value % 100u;
-		WritePadded2(target + padding - 2 * (i + 1), decimals);
-		value /= 100;
-	}
-	return target + padding;
-}
-
-bool StrfTimeFormat::IsDateSpecifier(StrTimeSpecifier specifier) {
-	switch (specifier) {
-	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
-	case StrTimeSpecifier::FULL_WEEKDAY_NAME:
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_ISO:
-	case StrTimeSpecifier::WEEKDAY_DECIMAL:
-	case StrTimeSpecifier::WEEKDAY_ISO:
-	case StrTimeSpecifier::YEAR_ISO:
-		return true;
-	default:
-		return false;
-	}
-}
-
-char *StrfTimeFormat::WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target) const {
-	switch (specifier) {
-	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME: {
-		auto dow = Date::ExtractISODayOfTheWeek(date);
-		target = WriteString(target, Date::DAY_NAMES_ABBREVIATED[dow % 7]);
-		break;
-	}
-	case StrTimeSpecifier::FULL_WEEKDAY_NAME: {
-		auto dow = Date::ExtractISODayOfTheWeek(date);
-		target = WriteString(target, Date::DAY_NAMES[dow % 7]);
-		break;
-	}
-	case StrTimeSpecifier::WEEKDAY_DECIMAL: {
-		auto dow = Date::ExtractISODayOfTheWeek(date);
-		*target = char('0' + uint8_t(dow % 7));
-		target++;
-		break;
-	}
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED: {
-		int32_t doy = Date::ExtractDayOfTheYear(date);
-		target = WritePadded3(target, UnsafeNumericCast<uint32_t>(doy));
-		break;
-	}
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(Date::ExtractWeekNumberRegular(date, true)));
-		break;
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(Date::ExtractWeekNumberRegular(date, false)));
-		break;
-	case StrTimeSpecifier::WEEK_NUMBER_ISO:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(Date::ExtractISOWeekNumber(date)));
-		break;
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL: {
-		auto doy = UnsafeNumericCast<uint32_t>(Date::ExtractDayOfTheYear(date));
-		target += NumericHelper::UnsignedLength<uint32_t>(doy);
-		NumericHelper::FormatUnsigned(doy, target);
-		break;
-	}
-	case StrTimeSpecifier::YEAR_ISO:
-		target = WritePadded(target, UnsafeNumericCast<uint32_t>(Date::ExtractISOYearNumber(date)), 4);
-		break;
-	case StrTimeSpecifier::WEEKDAY_ISO:
-		*target = char('0' + uint8_t(Date::ExtractISODayOfTheWeek(date)));
-		target++;
-		break;
-	default:
-		throw InternalException("Unimplemented date specifier for strftime");
-	}
-	return target;
-}
-
-char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name,
-                                             size_t tz_len, char *target) const {
-	// data contains [0] year, [1] month, [2] day, [3] hour, [4] minute, [5] second, [6] ns, [7] utc
-	switch (specifier) {
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[2]));
-		break;
-	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME: {
-		auto &month_name = Date::MONTH_NAMES_ABBREVIATED[data[1] - 1];
-		return WriteString(target, month_name);
-	}
-	case StrTimeSpecifier::FULL_MONTH_NAME: {
-		auto &month_name = Date::MONTH_NAMES[data[1] - 1];
-		return WriteString(target, month_name);
-	}
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[1]));
-		break;
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(AbsValue(data[0]) % 100));
-		break;
-	case StrTimeSpecifier::YEAR_DECIMAL:
-		if (data[0] >= 0 && data[0] <= 9999) {
-			target = WritePadded(target, UnsafeNumericCast<uint32_t>(data[0]), 4);
-		} else {
-			int32_t year = data[0];
-			if (data[0] < 0) {
-				*target = '-';
-				year = -year;
-				target++;
-			}
-			auto len = NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(year));
-			NumericHelper::FormatUnsigned(year, target + len);
-			target += len;
-		}
-		break;
-	case StrTimeSpecifier::HOUR_24_PADDED: {
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[3]));
-		break;
-	}
-	case StrTimeSpecifier::HOUR_12_PADDED: {
-		int hour = data[3] % 12;
-		if (hour == 0) {
-			hour = 12;
-		}
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(hour));
-		break;
-	}
-	case StrTimeSpecifier::AM_PM:
-		*target++ = data[3] >= 12 ? 'P' : 'A';
-		*target++ = 'M';
-		break;
-	case StrTimeSpecifier::MINUTE_PADDED: {
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[4]));
-		break;
-	}
-	case StrTimeSpecifier::SECOND_PADDED:
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[5]));
-		break;
-	case StrTimeSpecifier::NANOSECOND_PADDED:
-		target = WritePadded(target, UnsafeNumericCast<uint32_t>(data[6]), 9);
-		break;
-	case StrTimeSpecifier::MICROSECOND_PADDED:
-		target = WritePadded(target, UnsafeNumericCast<uint32_t>(data[6] / Interval::NANOS_PER_MICRO), 6);
-		break;
-	case StrTimeSpecifier::MILLISECOND_PADDED:
-		target = WritePadded3(target, UnsafeNumericCast<uint32_t>(data[6] / Interval::NANOS_PER_MSEC));
-		break;
-	case StrTimeSpecifier::UTC_OFFSET: {
-		*target++ = (data[7] < 0) ? '-' : '+';
-
-		auto offset = abs(data[7]);
-		auto offset_hours = offset / Interval::MINS_PER_HOUR;
-		auto offset_minutes = offset % Interval::MINS_PER_HOUR;
-		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(offset_hours));
-		if (offset_minutes) {
-			*target++ = ':';
-			target = WritePadded2(target, UnsafeNumericCast<uint32_t>(offset_minutes));
-		}
-		break;
-	}
-	case StrTimeSpecifier::TZ_NAME:
-		if (tz_name) {
-			memcpy(target, tz_name, tz_len);
-			target += strlen(tz_name);
-		}
-		break;
-	case StrTimeSpecifier::DAY_OF_MONTH: {
-		target = Write2(target, UnsafeNumericCast<uint8_t>(data[2] % 100));
-		break;
-	}
-	case StrTimeSpecifier::MONTH_DECIMAL: {
-		target = Write2(target, UnsafeNumericCast<uint8_t>(data[1]));
-		break;
-	}
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY: {
-		target = Write2(target, UnsafeNumericCast<uint8_t>(AbsValue(data[0]) % 100));
-		break;
-	}
-	case StrTimeSpecifier::HOUR_24_DECIMAL: {
-		target = Write2(target, UnsafeNumericCast<uint8_t>(data[3]));
-		break;
-	}
-	case StrTimeSpecifier::HOUR_12_DECIMAL: {
-		int hour = data[3] % 12;
-		if (hour == 0) {
-			hour = 12;
-		}
-		target = Write2(target, UnsafeNumericCast<uint8_t>(hour));
-		break;
-	}
-	case StrTimeSpecifier::MINUTE_DECIMAL: {
-		target = Write2(target, UnsafeNumericCast<uint8_t>(data[4]));
-		break;
-	}
-	case StrTimeSpecifier::SECOND_DECIMAL: {
-		target = Write2(target, UnsafeNumericCast<uint8_t>(data[5]));
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented specifier for WriteStandardSpecifier in strftime");
-	}
-	return target;
-}
-
-void StrfTimeFormat::FormatStringNS(date_t date, int32_t data[8], const char *tz_name, char *target) const {
-	D_ASSERT(specifiers.size() + 1 == literals.size());
-	idx_t i;
-	for (i = 0; i < specifiers.size(); i++) {
-		// first copy the current literal
-		memcpy(target, literals[i].c_str(), literals[i].size());
-		target += literals[i].size();
-		// now copy the specifier
-		if (is_date_specifier[i]) {
-			target = WriteDateSpecifier(specifiers[i], date, target);
-		} else {
-			auto tz_len = tz_name ? strlen(tz_name) : 0;
-			target = WriteStandardSpecifier(specifiers[i], data, tz_name, tz_len, target);
-		}
-	}
-	// copy the final literal into the target
-	memcpy(target, literals[i].c_str(), literals[i].size());
-}
-
-void StrfTimeFormat::FormatString(date_t date, int32_t data[8], const char *tz_name, char *target) {
-	data[6] *= Interval::NANOS_PER_MICRO;
-	FormatStringNS(date, data, tz_name, target);
-	data[6] /= Interval::NANOS_PER_MICRO;
-}
-
-void StrfTimeFormat::FormatString(date_t date, dtime_t time, char *target) {
-	int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
-	Date::Convert(date, data[0], data[1], data[2]);
-	Time::Convert(time, data[3], data[4], data[5], data[6]);
-	data[7] = 0;
-
-	FormatString(date, data, nullptr, target);
-}
-
-string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
-	StrfTimeFormat format;
-	format.ParseFormatSpecifier(format_str, format);
-
-	auto date = Timestamp::GetDate(timestamp);
-	auto time = Timestamp::GetTime(timestamp);
-
-	auto len = format.GetLength(date, time, 0, nullptr);
-	auto result = make_unsafe_uniq_array_uninitialized<char>(len);
-	format.FormatString(date, time, result.get());
-	return string(result.get(), len);
-}
-
-string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeFormat &format) {
-	if (format_string.empty()) {
-		return "Empty format string";
-	}
-	format.format_specifier = format_string;
-	format.specifiers.clear();
-	format.literals.clear();
-	format.numeric_width.clear();
-	format.constant_size = 0;
-	idx_t pos = 0;
-	string current_literal;
-	for (idx_t i = 0; i < format_string.size(); i++) {
-		if (format_string[i] == '%') {
-			if (i + 1 == format_string.size()) {
-				return "Trailing format character %";
-			}
-			if (i > pos) {
-				// push the previous string to the current literal
-				current_literal += format_string.substr(pos, i - pos);
-			}
-			char format_char = format_string[++i];
-			if (format_char == '%') {
-				// special case: %%
-				// set the pos for the next literal and continue
-				pos = i;
-				continue;
-			}
-			StrTimeSpecifier specifier;
-			if (format_char == '-' && i + 1 < format_string.size()) {
-				format_char = format_string[++i];
-				switch (format_char) {
-				case 'd':
-					specifier = StrTimeSpecifier::DAY_OF_MONTH;
-					break;
-				case 'm':
-					specifier = StrTimeSpecifier::MONTH_DECIMAL;
-					break;
-				case 'y':
-					specifier = StrTimeSpecifier::YEAR_WITHOUT_CENTURY;
-					break;
-				case 'H':
-					specifier = StrTimeSpecifier::HOUR_24_DECIMAL;
-					break;
-				case 'I':
-					specifier = StrTimeSpecifier::HOUR_12_DECIMAL;
-					break;
-				case 'M':
-					specifier = StrTimeSpecifier::MINUTE_DECIMAL;
-					break;
-				case 'S':
-					specifier = StrTimeSpecifier::SECOND_DECIMAL;
-					break;
-				case 'j':
-					specifier = StrTimeSpecifier::DAY_OF_YEAR_DECIMAL;
-					break;
-				default:
-					return "Unrecognized format for strftime/strptime: %-" + string(1, format_char);
-				}
-			} else {
-				switch (format_char) {
-				case 'a':
-					specifier = StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME;
-					break;
-				case 'A':
-					specifier = StrTimeSpecifier::FULL_WEEKDAY_NAME;
-					break;
-				case 'w':
-					specifier = StrTimeSpecifier::WEEKDAY_DECIMAL;
-					break;
-				case 'u':
-					specifier = StrTimeSpecifier::WEEKDAY_ISO;
-					break;
-				case 'd':
-					specifier = StrTimeSpecifier::DAY_OF_MONTH_PADDED;
-					break;
-				case 'h':
-				case 'b':
-					specifier = StrTimeSpecifier::ABBREVIATED_MONTH_NAME;
-					break;
-				case 'B':
-					specifier = StrTimeSpecifier::FULL_MONTH_NAME;
-					break;
-				case 'm':
-					specifier = StrTimeSpecifier::MONTH_DECIMAL_PADDED;
-					break;
-				case 'y':
-					specifier = StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED;
-					break;
-				case 'Y':
-					specifier = StrTimeSpecifier::YEAR_DECIMAL;
-					break;
-				case 'G':
-					specifier = StrTimeSpecifier::YEAR_ISO;
-					break;
-				case 'H':
-					specifier = StrTimeSpecifier::HOUR_24_PADDED;
-					break;
-				case 'I':
-					specifier = StrTimeSpecifier::HOUR_12_PADDED;
-					break;
-				case 'p':
-					specifier = StrTimeSpecifier::AM_PM;
-					break;
-				case 'M':
-					specifier = StrTimeSpecifier::MINUTE_PADDED;
-					break;
-				case 'S':
-					specifier = StrTimeSpecifier::SECOND_PADDED;
-					break;
-				case 'n':
-					specifier = StrTimeSpecifier::NANOSECOND_PADDED;
-					break;
-				case 'f':
-					specifier = StrTimeSpecifier::MICROSECOND_PADDED;
-					break;
-				case 'g':
-					specifier = StrTimeSpecifier::MILLISECOND_PADDED;
-					break;
-				case 'z':
-					specifier = StrTimeSpecifier::UTC_OFFSET;
-					break;
-				case 'Z':
-					specifier = StrTimeSpecifier::TZ_NAME;
-					break;
-				case 'j':
-					specifier = StrTimeSpecifier::DAY_OF_YEAR_PADDED;
-					break;
-				case 'U':
-					specifier = StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST;
-					break;
-				case 'W':
-					specifier = StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST;
-					break;
-				case 'V':
-					specifier = StrTimeSpecifier::WEEK_NUMBER_ISO;
-					break;
-				case 'c':
-				case 'x':
-				case 'X':
-				case 'T': {
-					string subformat;
-					if (format_char == 'c') {
-						// %c: Locale’s appropriate date and time representation.
-						// we push the ISO timestamp representation here
-						subformat = "%Y-%m-%d %H:%M:%S";
-					} else if (format_char == 'x') {
-						// %x - Locale’s appropriate date representation.
-						// we push the ISO date format here
-						subformat = "%Y-%m-%d";
-					} else if (format_char == 'X' || format_char == 'T') {
-						// %X - Locale’s appropriate time representation.
-						// we push the ISO time format here
-						subformat = "%H:%M:%S";
-					}
-					// parse the subformat in a separate format specifier
-					StrfTimeFormat locale_format;
-					string error = StrTimeFormat::ParseFormatSpecifier(subformat, locale_format);
-					if (!error.empty()) {
-						throw InternalException("Failed to bind sub-format specifier \"%s\": %s", subformat, error);
-					}
-					// add the previous literal to the first literal of the subformat
-					locale_format.literals[0] = std::move(current_literal) + locale_format.literals[0];
-					current_literal = "";
-					// now push the subformat into the current format specifier
-					for (idx_t i = 0; i < locale_format.specifiers.size(); i++) {
-						format.AddFormatSpecifier(std::move(locale_format.literals[i]), locale_format.specifiers[i]);
-					}
-					pos = i + 1;
-					continue;
-				}
-				default:
-					return "Unrecognized format for strftime/strptime: %" + string(1, format_char);
-				}
-			}
-			format.AddFormatSpecifier(std::move(current_literal), specifier);
-			current_literal = "";
-			pos = i + 1;
-		}
-	}
-	// add the final literal
-	if (pos < format_string.size()) {
-		current_literal += format_string.substr(pos, format_string.size() - pos);
-	}
-	format.AddLiteral(std::move(current_literal));
-	return string();
-}
-
-void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::DATE);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
-	UnaryExecutor::ExecuteWithNulls<date_t, string_t>(
-	    input, result, count, [&](date_t input, ValidityMask &mask, idx_t idx) {
-		    if (Date::IsFinite(input)) {
-			    dtime_t time(0);
-			    idx_t len = GetLength(input, time, 0, nullptr);
-			    string_t target = StringVector::EmptyString(result, len);
-			    FormatString(input, time, target.GetDataWriteable());
-			    target.Finalize();
-			    return target;
-		    } else {
-			    return StringVector::AddString(result, Date::ToString(input));
-		    }
-	    });
-}
-
-string_t StrfTimeFormat::ConvertTimestampValue(const timestamp_t &input, Vector &result) const {
-	if (Timestamp::IsFinite(input)) {
-		date_t date;
-		dtime_t time;
-		Timestamp::Convert(input, date, time);
-
-		int32_t data[8]; // year, month, day, hour, min, sec, ns, offset
-		Date::Convert(date, data[0], data[1], data[2]);
-		Time::Convert(time, data[3], data[4], data[5], data[6]);
-		data[6] *= Interval::NANOS_PER_MICRO;
-		data[7] = 0;
-		const char *tz_name = nullptr;
-
-		idx_t len = GetLength(date, data, tz_name);
-		string_t target = StringVector::EmptyString(result, len);
-		FormatStringNS(date, data, tz_name, target.GetDataWriteable());
-		target.Finalize();
-		return target;
-	} else {
-		return StringVector::AddString(result, Timestamp::ToString(input));
-	}
-}
-
-string_t StrfTimeFormat::ConvertTimestampValue(const timestamp_ns_t &input, Vector &result) const {
-	if (Timestamp::IsFinite(input)) {
-		date_t date;
-		dtime_t time;
-		int32_t nanos;
-		Timestamp::Convert(input, date, time, nanos);
-
-		int32_t data[8]; // year, month, day, hour, min, sec, ns, offset
-		Date::Convert(date, data[0], data[1], data[2]);
-		Time::Convert(time, data[3], data[4], data[5], data[6]);
-		data[6] *= Interval::NANOS_PER_MICRO;
-		data[6] += nanos;
-		data[7] = 0;
-		const char *tz_name = nullptr;
-
-		idx_t len = GetLength(date, data, tz_name);
-		string_t target = StringVector::EmptyString(result, len);
-		FormatStringNS(date, data, tz_name, target.GetDataWriteable());
-		target.Finalize();
-		return target;
-	} else {
-		return StringVector::AddString(result, Timestamp::ToString(input));
-	}
-}
-
-void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP || input.GetType().id() == LogicalTypeId::TIMESTAMP_TZ);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
-	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
-	    input, result, count,
-	    [&](timestamp_t input, ValidityMask &mask, idx_t idx) { return ConvertTimestampValue(input, result); });
-}
-
-void StrfTimeFormat::ConvertTimestampNSVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP_NS);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
-	UnaryExecutor::ExecuteWithNulls<timestamp_ns_t, string_t>(
-	    input, result, count,
-	    [&](timestamp_ns_t input, ValidityMask &mask, idx_t idx) { return ConvertTimestampValue(input, result); });
-}
-
-void StrpTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
-	numeric_width.push_back(NumericSpecifierWidth(specifier));
-	StrTimeFormat::AddFormatSpecifier(std::move(preceding_literal), specifier);
-}
-
-int StrpTimeFormat::NumericSpecifierWidth(StrTimeSpecifier specifier) {
-	switch (specifier) {
-	case StrTimeSpecifier::WEEKDAY_DECIMAL:
-	case StrTimeSpecifier::WEEKDAY_ISO:
-		return 1;
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-	case StrTimeSpecifier::DAY_OF_MONTH:
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-	case StrTimeSpecifier::MONTH_DECIMAL:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-	case StrTimeSpecifier::HOUR_24_PADDED:
-	case StrTimeSpecifier::HOUR_24_DECIMAL:
-	case StrTimeSpecifier::HOUR_12_PADDED:
-	case StrTimeSpecifier::HOUR_12_DECIMAL:
-	case StrTimeSpecifier::MINUTE_PADDED:
-	case StrTimeSpecifier::MINUTE_DECIMAL:
-	case StrTimeSpecifier::SECOND_PADDED:
-	case StrTimeSpecifier::SECOND_DECIMAL:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_ISO:
-		return 2;
-	case StrTimeSpecifier::MILLISECOND_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-		return 3;
-	case StrTimeSpecifier::YEAR_DECIMAL:
-	case StrTimeSpecifier::YEAR_ISO:
-		return 4;
-	case StrTimeSpecifier::MICROSECOND_PADDED:
-		return 6;
-	case StrTimeSpecifier::NANOSECOND_PADDED:
-		return 9;
-	default:
-		return -1;
-	}
-}
-
-enum class TimeSpecifierAMOrPM : uint8_t { TIME_SPECIFIER_NONE = 0, TIME_SPECIFIER_AM = 1, TIME_SPECIFIER_PM = 2 };
-
-int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
-                                           idx_t collection_count) const {
-	for (idx_t c = 0; c < collection_count; c++) {
-		auto &entry = collection[c];
-		auto entry_data = entry.GetData();
-		auto entry_size = entry.GetSize();
-		// check if this entry matches
-		if (pos + entry_size > size) {
-			// too big: can't match
-			continue;
-		}
-		// compare the characters
-		idx_t i;
-		for (i = 0; i < entry_size; i++) {
-			if (std::tolower(entry_data[i]) != std::tolower(data[pos + i])) {
-				break;
-			}
-		}
-		if (i == entry_size) {
-			// full match
-			pos += entry_size;
-			return UnsafeNumericCast<int32_t>(c);
-		}
-	}
-	return -1;
-}
-
-bool StrpTimeFormat::Parse(const char *data, size_t size, ParseResult &result, bool strict) const {
-	auto &result_data = result.data;
-	auto &error_message = result.error_message;
-	auto &error_position = result.error_position;
-
-	// initialize the result
-	result_data[0] = 1900;
-	result_data[1] = 1;
-	result_data[2] = 1;
-	result_data[3] = 0;
-	result_data[4] = 0;
-	result_data[5] = 0;
-	result_data[6] = 0;
-	result_data[7] = 0;
-	// skip leading spaces
-	while (StringUtil::CharacterIsSpace(*data)) {
-		data++;
-		size--;
-	}
-	//	Check for specials
-	//	Precheck for alphas for performance.
-	idx_t pos = 0;
-	result.is_special = false;
-	if (size > 4) {
-		if (StringUtil::CharacterIsAlpha(*data)) {
-			if (Date::TryConvertDateSpecial(data, size, pos, Date::PINF)) {
-				result.is_special = true;
-				result.special = date_t::infinity();
-			} else if (Date::TryConvertDateSpecial(data, size, pos, Date::EPOCH)) {
-				result.is_special = true;
-				result.special = date_t::epoch();
-			}
-		} else if (*data == '-' && Date::TryConvertDateSpecial(data, size, pos, Date::NINF)) {
-			result.is_special = true;
-			result.special = date_t::ninfinity();
-		}
-	}
-	if (result.is_special) {
-		// skip trailing spaces
-		while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
-			pos++;
-		}
-		if (pos != size) {
-			error_message = "Special timestamp did not match: trailing characters";
-			error_position = pos;
-			return false;
-		}
-		return true;
-	}
-
-	TimeSpecifierAMOrPM ampm = TimeSpecifierAMOrPM::TIME_SPECIFIER_NONE;
-
-	// Year offset state (Year+W/j)
-	auto offset_specifier = StrTimeSpecifier::WEEKDAY_DECIMAL;
-	uint64_t weekno = 0;
-	uint64_t weekday = 0;
-	uint64_t yearday = 0;
-	bool has_weekday = false;
-
-	// ISO state (%G/%V/%u)
-	// Out of range values to detect multiple specifications
-	uint64_t iso_year = 10000;
-	uint64_t iso_week = 54;
-	uint64_t iso_weekday = 8;
-
-	for (idx_t i = 0;; i++) {
-		D_ASSERT(i < literals.size());
-		// first compare the literal
-		const auto &literal = literals[i];
-		for (size_t l = 0; l < literal.size();) {
-			// Match runs of spaces to runs of spaces.
-			if (StringUtil::CharacterIsSpace(literal[l])) {
-				if (!StringUtil::CharacterIsSpace(data[pos])) {
-					error_message = "Space does not match, expected " + literals[i];
-					error_position = pos;
-					return false;
-				}
-				for (++pos; pos < size && StringUtil::CharacterIsSpace(data[pos]); ++pos) {
-					continue;
-				}
-				for (++l; l < literal.size() && StringUtil::CharacterIsSpace(literal[l]); ++l) {
-					continue;
-				}
-				continue;
-			}
-			// literal does not match
-			if (data[pos++] != literal[l++]) {
-				error_message = "Literal does not match, expected " + literal;
-				error_position = pos;
-				return false;
-			}
-		}
-		if (i == specifiers.size()) {
-			break;
-		}
-		// now parse the specifier
-		if (numeric_width[i] > 0) {
-			// numeric specifier: parse a number
-			uint64_t number = 0;
-			size_t start_pos = pos;
-			size_t end_pos = start_pos + UnsafeNumericCast<size_t>(numeric_width[i]);
-			while (pos < size && pos < end_pos && StringUtil::CharacterIsDigit(data[pos])) {
-				number = number * 10 + UnsafeNumericCast<uint64_t>(data[pos]) - '0';
-				pos++;
-			}
-			if (pos == start_pos) {
-				// expected a number here
-				error_message = "Expected a number";
-				error_position = start_pos;
-				return false;
-			}
-			switch (specifiers[i]) {
-			case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-			case StrTimeSpecifier::DAY_OF_MONTH:
-				if (number < 1 || number > 31) {
-					error_message = "Day out of range, expected a value between 1 and 31";
-					error_position = start_pos;
-					return false;
-				}
-				// day of the month
-				result_data[2] = UnsafeNumericCast<int32_t>(number);
-				offset_specifier = specifiers[i];
-				break;
-			case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-			case StrTimeSpecifier::MONTH_DECIMAL:
-				if (number < 1 || number > 12) {
-					error_message = "Month out of range, expected a value between 1 and 12";
-					error_position = start_pos;
-					return false;
-				}
-				// month number
-				result_data[1] = UnsafeNumericCast<int32_t>(number);
-				offset_specifier = specifiers[i];
-				break;
-			case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-			case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-				switch (offset_specifier) {
-				case StrTimeSpecifier::YEAR_ISO:
-				case StrTimeSpecifier::WEEK_NUMBER_ISO:
-					// Override
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				default:
-					break;
-				}
-				// year without century..
-				// Python uses 69 as a crossover point (i.e. >= 69 is 19.., < 69 is 20..)
-				if (pos - start_pos < 2 && strict) {
-					return false;
-				}
-				if (number >= 100) {
-					// %y only supports numbers between [0..99]
-					error_message = "Year without century out of range, expected a value between 0 and 99";
-					error_position = start_pos;
-					return false;
-				}
-				if (number >= 69) {
-					result_data[0] = int32_t(1900 + number);
-				} else {
-					result_data[0] = int32_t(2000 + number);
-				}
-				break;
-			case StrTimeSpecifier::YEAR_DECIMAL:
-				switch (offset_specifier) {
-				case StrTimeSpecifier::YEAR_ISO:
-				case StrTimeSpecifier::WEEK_NUMBER_ISO:
-					// Override
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				default:
-					break;
-				}
-				if (pos - start_pos < 2 && strict) {
-					return false;
-				}
-				// year as full number
-				result_data[0] = UnsafeNumericCast<int32_t>(number);
-				break;
-			case StrTimeSpecifier::YEAR_ISO:
-				switch (offset_specifier) {
-				// y/m/d overrides G/V/u but does not conflict
-				case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-				case StrTimeSpecifier::DAY_OF_MONTH:
-				case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-				case StrTimeSpecifier::MONTH_DECIMAL:
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-				case StrTimeSpecifier::YEAR_DECIMAL:
-					// Just validate, don't use
-					break;
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				case StrTimeSpecifier::YEAR_ISO:
-				case StrTimeSpecifier::WEEK_NUMBER_ISO:
-					// Already parsing ISO
-					if (iso_year <= 9999) {
-						error_message = "Multiple ISO year offsets specified";
-						error_position = start_pos;
-						return false;
-					}
-					break;
-				default:
-					error_message = "Incompatible ISO year offset specified";
-					error_position = start_pos;
-					return false;
-					break;
-				}
-				if (number > 9999) {
-					// %G only supports numbers between [0..9999]
-					error_message = "ISO Year out of range, expected a value between 0000 and 9999";
-					error_position = start_pos;
-					return false;
-				}
-				iso_year = number;
-				break;
-			case StrTimeSpecifier::HOUR_24_PADDED:
-			case StrTimeSpecifier::HOUR_24_DECIMAL:
-				if (number >= 24) {
-					error_message = "Hour out of range, expected a value between 0 and 23";
-					error_position = start_pos;
-					return false;
-				}
-				// hour as full number
-				result_data[3] = UnsafeNumericCast<int32_t>(number);
-				break;
-			case StrTimeSpecifier::HOUR_12_PADDED:
-			case StrTimeSpecifier::HOUR_12_DECIMAL:
-				if (number < 1 || number > 12) {
-					error_message = "Hour12 out of range, expected a value between 1 and 12";
-					error_position = start_pos;
-					return false;
-				}
-				// 12-hour number: start off by just storing the number
-				result_data[3] = UnsafeNumericCast<int32_t>(number);
-				break;
-			case StrTimeSpecifier::MINUTE_PADDED:
-			case StrTimeSpecifier::MINUTE_DECIMAL:
-				if (number >= 60) {
-					error_message = "Minutes out of range, expected a value between 0 and 59";
-					error_position = start_pos;
-					return false;
-				}
-				// minutes
-				result_data[4] = UnsafeNumericCast<int32_t>(number);
-				break;
-			case StrTimeSpecifier::SECOND_PADDED:
-			case StrTimeSpecifier::SECOND_DECIMAL:
-				if (number >= 60) {
-					error_message = "Seconds out of range, expected a value between 0 and 59";
-					error_position = start_pos;
-					return false;
-				}
-				// seconds
-				result_data[5] = UnsafeNumericCast<int32_t>(number);
-				break;
-			case StrTimeSpecifier::NANOSECOND_PADDED:
-				D_ASSERT(number < Interval::NANOS_PER_SEC); // enforced by the length of the number
-				// nanoseconds
-				result_data[6] = UnsafeNumericCast<int32_t>(number);
-				break;
-			case StrTimeSpecifier::MICROSECOND_PADDED:
-				D_ASSERT(number < Interval::MICROS_PER_SEC); // enforced by the length of the number
-				// nanoseconds
-				result_data[6] = UnsafeNumericCast<int32_t>(number * Interval::NANOS_PER_MICRO);
-				break;
-			case StrTimeSpecifier::MILLISECOND_PADDED:
-				D_ASSERT(number < Interval::MSECS_PER_SEC); // enforced by the length of the number
-				// nanoseconds
-				result_data[6] = UnsafeNumericCast<int32_t>(number * Interval::NANOS_PER_MSEC);
-				break;
-			case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-			case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-				// m/d overrides WU/w but does not conflict
-				switch (offset_specifier) {
-				case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-				case StrTimeSpecifier::DAY_OF_MONTH:
-				case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-				case StrTimeSpecifier::MONTH_DECIMAL:
-					// Just validate, don't use
-					break;
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-				case StrTimeSpecifier::YEAR_DECIMAL:
-					// Switch to offset parsing
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				default:
-					error_message = "Multiple week offsets specified";
-					error_position = start_pos;
-					return false;
-				}
-				if (number > 53) {
-					error_message = "Week out of range, expected a value between 0 and 53";
-					error_position = start_pos;
-					return false;
-				}
-				weekno = number;
-				break;
-			case StrTimeSpecifier::WEEKDAY_DECIMAL:
-				if (number > 6) {
-					error_message = "Weekday out of range, expected a value between 0 and 6";
-					error_position = start_pos;
-					return false;
-				}
-				has_weekday = true;
-				weekday = number;
-				break;
-			case StrTimeSpecifier::WEEK_NUMBER_ISO:
-				// y/m/d overrides G/V/u but does not conflict
-				switch (offset_specifier) {
-				case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-				case StrTimeSpecifier::DAY_OF_MONTH:
-				case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-				case StrTimeSpecifier::MONTH_DECIMAL:
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-				case StrTimeSpecifier::YEAR_DECIMAL:
-					// Just validate, don't use
-					break;
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				case StrTimeSpecifier::WEEK_NUMBER_ISO:
-				case StrTimeSpecifier::YEAR_ISO:
-					// Already parsing ISO
-					if (iso_week <= 53) {
-						error_message = "Multiple ISO week offsets specified";
-						error_position = start_pos;
-						return false;
-					}
-					break;
-				default:
-					error_message = "Incompatible ISO week offset specified";
-					error_position = start_pos;
-					return false;
-				}
-				if (number < 1 || number > 53) {
-					error_message = "ISO week offset out of range, expected a value between 1 and 53";
-					error_position = start_pos;
-					return false;
-				}
-				iso_week = number;
-				break;
-			case StrTimeSpecifier::WEEKDAY_ISO:
-				if (iso_weekday <= 7) {
-					error_message = "Multiple ISO weekday offsets specified";
-					error_position = start_pos;
-					return false;
-				}
-				if (number < 1 || number > 7) {
-					error_message = "ISO weekday offset out of range, expected a value between 1 and 7";
-					error_position = start_pos;
-					return false;
-				}
-				iso_weekday = number;
-				break;
-			case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-			case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-				// m/d overrides j but does not conflict
-				switch (offset_specifier) {
-				case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-				case StrTimeSpecifier::DAY_OF_MONTH:
-				case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-				case StrTimeSpecifier::MONTH_DECIMAL:
-					// Just validate, don't use
-					break;
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-				case StrTimeSpecifier::YEAR_DECIMAL:
-					// Switch to offset parsing
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				default:
-					error_message = "Multiple year offsets specified";
-					error_position = start_pos;
-					return false;
-				}
-				if (number < 1 || number > 366) {
-					error_message = "Year day out of range, expected a value between 1 and 366";
-					error_position = start_pos;
-					return false;
-				}
-				yearday = number;
-				break;
-			default:
-				throw NotImplementedException("Unsupported specifier for strptime");
-			}
-		} else {
-			switch (specifiers[i]) {
-			case StrTimeSpecifier::AM_PM: {
-				// parse the next 2 characters
-				if (pos + 2 > size) {
-					// no characters left to parse
-					error_message = "Expected AM/PM";
-					error_position = pos;
-					return false;
-				}
-				char pa_char = char(std::tolower(data[pos]));
-				char m_char = char(std::tolower(data[pos + 1]));
-				if (m_char != 'm') {
-					error_message = "Expected AM/PM";
-					error_position = pos;
-					return false;
-				}
-				if (pa_char == 'p') {
-					ampm = TimeSpecifierAMOrPM::TIME_SPECIFIER_PM;
-				} else if (pa_char == 'a') {
-					ampm = TimeSpecifierAMOrPM::TIME_SPECIFIER_AM;
-				} else {
-					error_message = "Expected AM/PM";
-					error_position = pos;
-					return false;
-				}
-				pos += 2;
-				break;
-			}
-			// we parse weekday names, but we don't use them as information
-			case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
-				if (TryParseCollection(data, pos, size, Date::DAY_NAMES_ABBREVIATED, 7) < 0) {
-					error_message = "Expected an abbreviated day name (Mon, Tue, Wed, Thu, Fri, Sat, Sun)";
-					error_position = pos;
-					return false;
-				}
-				break;
-			case StrTimeSpecifier::FULL_WEEKDAY_NAME:
-				if (TryParseCollection(data, pos, size, Date::DAY_NAMES, 7) < 0) {
-					error_message = "Expected a full day name (Monday, Tuesday, etc...)";
-					error_position = pos;
-					return false;
-				}
-				break;
-			case StrTimeSpecifier::ABBREVIATED_MONTH_NAME: {
-				int32_t month = TryParseCollection(data, pos, size, Date::MONTH_NAMES_ABBREVIATED, 12);
-				if (month < 0) {
-					error_message = "Expected an abbreviated month name (Jan, Feb, Mar, etc..)";
-					error_position = pos;
-					return false;
-				}
-				result_data[1] = month + 1;
-				break;
-			}
-			case StrTimeSpecifier::FULL_MONTH_NAME: {
-				int32_t month = TryParseCollection(data, pos, size, Date::MONTH_NAMES, 12);
-				if (month < 0) {
-					error_message = "Expected a full month name (January, February, etc...)";
-					error_position = pos;
-					return false;
-				}
-				result_data[1] = month + 1;
-				break;
-			}
-			case StrTimeSpecifier::UTC_OFFSET: {
-				int hour_offset, minute_offset;
-				if (!Timestamp::TryParseUTCOffset(data, pos, size, hour_offset, minute_offset)) {
-					error_message = "Expected +HH[MM] or -HH[MM]";
-					error_position = pos;
-					return false;
-				}
-				result_data[7] = hour_offset * Interval::MINS_PER_HOUR + minute_offset;
-				break;
-			}
-			case StrTimeSpecifier::TZ_NAME: {
-				// skip leading spaces
-				while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
-					pos++;
-				}
-				const auto tz_begin = data + pos;
-				// stop when we encounter a non-tz character
-				while (pos < size && Timestamp::CharacterIsTimeZone(data[pos])) {
-					pos++;
-				}
-				const auto tz_end = data + pos;
-				// Can't fully validate without a list - caller's responsibility.
-				// But tz must not be empty.
-				if (tz_end == tz_begin) {
-					error_message = "Empty Time Zone name";
-					error_position = UnsafeNumericCast<idx_t>(tz_begin - data);
-					return false;
-				}
-				result.tz.assign(tz_begin, tz_end);
-				break;
-			}
-			default:
-				throw NotImplementedException("Unsupported specifier for strptime");
-			}
-		}
-	}
-	// skip trailing spaces
-	while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
-		pos++;
-	}
-	if (pos != size) {
-		error_message = "Full specifier did not match: trailing characters";
-		error_position = pos;
-		return false;
-	}
-	if (ampm != TimeSpecifierAMOrPM::TIME_SPECIFIER_NONE) {
-		if (result_data[3] > 12) {
-			error_message =
-			    "Invalid hour: " + to_string(result_data[3]) + " AM/PM, expected an hour within the range [0..12]";
-			return false;
-		}
-		// adjust the hours based on the AM or PM specifier
-		if (ampm == TimeSpecifierAMOrPM::TIME_SPECIFIER_AM) {
-			// AM: 12AM=0, 1AM=1, 2AM=2, ..., 11AM=11
-			if (result_data[3] == 12) {
-				result_data[3] = 0;
-			}
-		} else {
-			// PM: 12PM=12, 1PM=13, 2PM=14, ..., 11PM=23
-			if (result_data[3] != 12) {
-				result_data[3] += 12;
-			}
-		}
-	}
-	switch (offset_specifier) {
-	case StrTimeSpecifier::YEAR_ISO:
-	case StrTimeSpecifier::WEEK_NUMBER_ISO: {
-		// Default to 1900-01-01
-		iso_year = (iso_year > 9999) ? 1900 : iso_year;
-		iso_week = (iso_week > 53) ? 1 : iso_week;
-		iso_weekday = (iso_weekday > 7) ? 1 : iso_weekday;
-		// Gregorian and ISO agree on the year of January 4
-		auto jan4 = Date::FromDate(UnsafeNumericCast<int32_t>(iso_year), 1, 4);
-		// ISO Week 1 starts on the previous Monday
-		auto week1 = Date::GetMondayOfCurrentWeek(jan4);
-		// ISO Week N starts N-1 weeks later
-		auto iso_date = week1 + UnsafeNumericCast<int32_t>((iso_week - 1) * 7 + (iso_weekday - 1));
-		Date::Convert(iso_date, result_data[0], result_data[1], result_data[2]);
-		break;
-	}
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST: {
-		// Adjust weekday to be 0-based for the week type
-		if (has_weekday) {
-			weekday = (weekday + 7 -
-			           static_cast<uint64_t>(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST)) %
-			          7;
-		}
-		// Get the start of week 1, move back 7 days and then weekno * 7 + weekday gives the date
-		const auto jan1 = Date::FromDate(result_data[0], 1, 1);
-		auto yeardate = Date::GetMondayOfCurrentWeek(jan1);
-		yeardate -= int(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST);
-		// Is there a week 0?
-		yeardate -= 7 * int(yeardate >= jan1);
-		yeardate += UnsafeNumericCast<int32_t>(weekno * 7 + weekday);
-		Date::Convert(yeardate, result_data[0], result_data[1], result_data[2]);
-		break;
-	}
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL: {
-		auto yeardate = Date::FromDate(result_data[0], 1, 1);
-		yeardate += UnsafeNumericCast<int32_t>(yearday - 1);
-		Date::Convert(yeardate, result_data[0], result_data[1], result_data[2]);
-		break;
-	}
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-	case StrTimeSpecifier::DAY_OF_MONTH:
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-	case StrTimeSpecifier::MONTH_DECIMAL:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-	case StrTimeSpecifier::YEAR_DECIMAL:
-		// m/d overrides UWVwu/j
-		break;
-	default:
-		D_ASSERT(offset_specifier == StrTimeSpecifier::WEEKDAY_DECIMAL);
-		break;
-	}
-
-	return true;
-}
-
-//! Parses a timestamp using the given specifier
-bool StrpTimeFormat::Parse(string_t str, ParseResult &result, bool strict) const {
-	auto data = str.GetData();
-	idx_t size = str.GetSize();
-	return Parse(data, size, result, strict);
-}
-
-StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
-	StrpTimeFormat format;
-	format.format_specifier = format_string;
-	string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-	if (!error.empty()) {
-		throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-	}
-	StrpTimeFormat::ParseResult result;
-	if (!format.Parse(text, result)) {
-		throw InvalidInputException("Failed to parse string \"%s\" with format specifier \"%s\"", text, format_string);
-	}
-	return result;
-}
-
-bool StrTimeFormat::Empty() const {
-	return format_specifier.empty();
-}
-
-string StrpTimeFormat::FormatStrpTimeError(const string &input, optional_idx position) {
-	if (!position.IsValid()) {
-		return string();
-	}
-	return input + "\n" + string(position.GetIndex(), ' ') + "^";
-}
-
-date_t StrpTimeFormat::ParseResult::ToDate() {
-	if (is_special) {
-		return special;
-	}
-	return Date::FromDate(data[0], data[1], data[2]);
-}
-
-bool StrpTimeFormat::ParseResult::TryToDate(date_t &result) {
-	return Date::TryFromDate(data[0], data[1], data[2], result);
-}
-
-int32_t StrpTimeFormat::ParseResult::GetMicros() const {
-	return UnsafeNumericCast<int32_t>((data[6] + Interval::NANOS_PER_MICRO / 2) / Interval::NANOS_PER_MICRO);
-}
-
-dtime_t StrpTimeFormat::ParseResult::ToTime() {
-	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
-	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
-	return Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], GetMicros());
-}
-
-int64_t StrpTimeFormat::ParseResult::ToTimeNS() {
-	const int32_t hour_offset = data[7] / Interval::MINS_PER_HOUR;
-	const int32_t mins_offset = data[7] % Interval::MINS_PER_HOUR;
-	return Time::ToNanoTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
-}
-
-bool StrpTimeFormat::ParseResult::TryToTime(dtime_t &result) {
-	if (data[7]) {
-		return false;
-	}
-	result = Time::FromTime(data[3], data[4], data[5], GetMicros());
-	return true;
-}
-
-timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
-	if (is_special) {
-		if (special == date_t::infinity()) {
-			return timestamp_t::infinity();
-		} else if (special == date_t::ninfinity()) {
-			return timestamp_t::ninfinity();
-		}
-		return Timestamp::FromDatetime(special, dtime_t(0));
-	}
-
-	date_t date = ToDate();
-	dtime_t time = ToTime();
-	return Timestamp::FromDatetime(date, time);
-}
-
-bool StrpTimeFormat::ParseResult::TryToTimestamp(timestamp_t &result) {
-	date_t date;
-	if (!TryToDate(date)) {
-		return false;
-	}
-	dtime_t time = ToTime();
-	return Timestamp::TryFromDatetime(date, time, result);
-}
-
-timestamp_ns_t StrpTimeFormat::ParseResult::ToTimestampNS() {
-	timestamp_ns_t result;
-	if (is_special) {
-		if (special == date_t::infinity()) {
-			result.value = timestamp_t::infinity().value;
-		} else if (special == date_t::ninfinity()) {
-			result.value = timestamp_t::ninfinity().value;
-		} else {
-			result.value = special.days * Interval::NANOS_PER_DAY;
-		}
-	} else {
-		// Don't use rounded µs
-		const auto date = ToDate();
-		const auto time = ToTimeNS();
-		if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::NANOS_PER_DAY,
-		                                                               result.value)) {
-			throw ConversionException("Date out of nanosecond range: %d-%d-%d", data[0], data[1], data[2]);
-		}
-		if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(result.value, time, result.value)) {
-			throw ConversionException("Overflow exception in date/time -> timestamp_ns conversion");
-		}
-	}
-
-	return result;
-}
-
-bool StrpTimeFormat::ParseResult::TryToTimestampNS(timestamp_ns_t &result) {
-	date_t date;
-	if (!TryToDate(date)) {
-		return false;
-	}
-
-	// Don't use rounded µs
-	const auto time = ToTimeNS();
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::NANOS_PER_DAY, result.value)) {
-		return false;
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(result.value, time, result.value)) {
-		return false;
-	}
-	return Timestamp::IsFinite(result);
-}
-
-string StrpTimeFormat::ParseResult::FormatError(string_t input, const string &format_specifier) {
-	return StringUtil::Format("Could not parse string \"%s\" according to format specifier \"%s\"\n%s\nError: %s",
-	                          input.GetString(), format_specifier,
-	                          FormatStrpTimeError(input.GetString(), error_position), error_message);
-}
-
-bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_message) const {
-	ParseResult parse_result;
-	if (!Parse(input, parse_result)) {
-		error_message = parse_result.FormatError(input, format_specifier);
-		return false;
-	}
-	return parse_result.TryToDate(result);
-}
-
-bool StrpTimeFormat::TryParseDate(const char *data, size_t size, date_t &result) const {
-	ParseResult parse_result;
-	if (!Parse(data, size, parse_result)) {
-		return false;
-	}
-	return parse_result.TryToDate(result);
-}
-
-bool StrpTimeFormat::TryParseTime(string_t input, dtime_t &result, string &error_message) const {
-	ParseResult parse_result;
-	if (!Parse(input, parse_result)) {
-		error_message = parse_result.FormatError(input, format_specifier);
-		return false;
-	}
-	return parse_result.TryToTime(result);
-}
-
-bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) const {
-	ParseResult parse_result;
-	if (!Parse(input, parse_result)) {
-		error_message = parse_result.FormatError(input, format_specifier);
-		return false;
-	}
-	return parse_result.TryToTimestamp(result);
-}
-
-bool StrpTimeFormat::TryParseTimestamp(const char *data, size_t size, timestamp_t &result) const {
-	ParseResult parse_result;
-	if (!Parse(data, size, parse_result)) {
-		return false;
-	}
-	return parse_result.TryToTimestamp(result);
-}
-
-bool StrpTimeFormat::TryParseTimestampNS(string_t input, timestamp_ns_t &result, string &error_message) const {
-	ParseResult parse_result;
-	if (!Parse(input, parse_result)) {
-		error_message = parse_result.FormatError(input, format_specifier);
-		return false;
-	}
-	return parse_result.TryToTimestampNS(result);
-}
-
-bool StrpTimeFormat::TryParseTimestampNS(const char *data, size_t size, timestamp_ns_t &result) const {
-	ParseResult parse_result;
-	if (!Parse(data, size, parse_result)) {
-		return false;
-	}
-	return parse_result.TryToTimestampNS(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/caseconvert.cpp b/src/duckdb/src/function/scalar/string/caseconvert.cpp
deleted file mode 100644
index d0d850f5a..000000000
--- a/src/duckdb/src/function/scalar/string/caseconvert.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-#include "utf8proc_wrapper.hpp"
-
-#include <string.h>
-
-namespace duckdb {
-
-template <bool IS_UPPER>
-static string_t ASCIICaseConvert(Vector &result, const char *input_data, idx_t input_length) {
-	idx_t output_length = input_length;
-	auto result_str = StringVector::EmptyString(result, output_length);
-	auto result_data = result_str.GetDataWriteable();
-	for (idx_t i = 0; i < input_length; i++) {
-		result_data[i] = UnsafeNumericCast<char>(IS_UPPER ? StringUtil::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
-		                                                  : StringUtil::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])]);
-	}
-	result_str.Finalize();
-	return result_str;
-}
-
-template <bool IS_UPPER>
-static idx_t GetResultLength(const char *input_data, idx_t input_length) {
-	idx_t output_length = 0;
-	for (idx_t i = 0; i < input_length;) {
-		if (input_data[i] & 0x80) {
-			// unicode
-			int sz = 0;
-			auto codepoint = Utf8Proc::UTF8ToCodepoint(input_data + i, sz);
-			auto converted_codepoint =
-			    IS_UPPER ? Utf8Proc::CodepointToUpper(codepoint) : Utf8Proc::CodepointToLower(codepoint);
-			auto new_sz = Utf8Proc::CodepointLength(converted_codepoint);
-			D_ASSERT(new_sz >= 0);
-			output_length += UnsafeNumericCast<idx_t>(new_sz);
-			i += UnsafeNumericCast<idx_t>(sz);
-		} else {
-			// ascii
-			output_length++;
-			i++;
-		}
-	}
-	return output_length;
-}
-
-template <bool IS_UPPER>
-static void CaseConvert(const char *input_data, idx_t input_length, char *result_data) {
-	for (idx_t i = 0; i < input_length;) {
-		if (input_data[i] & 0x80) {
-			// non-ascii character
-			int sz = 0, new_sz = 0;
-			auto codepoint = Utf8Proc::UTF8ToCodepoint(input_data + i, sz);
-			auto converted_codepoint =
-			    IS_UPPER ? Utf8Proc::CodepointToUpper(codepoint) : Utf8Proc::CodepointToLower(codepoint);
-			auto success = Utf8Proc::CodepointToUtf8(converted_codepoint, new_sz, result_data);
-			D_ASSERT(success);
-			(void)success;
-			result_data += new_sz;
-			i += UnsafeNumericCast<idx_t>(sz);
-		} else {
-			// ascii
-			*result_data = UnsafeNumericCast<char>(IS_UPPER ? StringUtil::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
-			                                                : StringUtil::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])]);
-			result_data++;
-			i++;
-		}
-	}
-}
-
-idx_t LowerLength(const char *input_data, idx_t input_length) {
-	return GetResultLength<false>(input_data, input_length);
-}
-
-void LowerCase(const char *input_data, idx_t input_length, char *result_data) {
-	CaseConvert<false>(input_data, input_length, result_data);
-}
-
-template <bool IS_UPPER>
-static string_t UnicodeCaseConvert(Vector &result, const char *input_data, idx_t input_length) {
-	// first figure out the output length
-	idx_t output_length = GetResultLength<IS_UPPER>(input_data, input_length);
-	auto result_str = StringVector::EmptyString(result, output_length);
-	auto result_data = result_str.GetDataWriteable();
-
-	CaseConvert<IS_UPPER>(input_data, input_length, result_data);
-	result_str.Finalize();
-	return result_str;
-}
-
-template <bool IS_UPPER>
-struct CaseConvertOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetData();
-		auto input_length = input.GetSize();
-		return UnicodeCaseConvert<IS_UPPER>(result, input_data, input_length);
-	}
-};
-
-template <bool IS_UPPER>
-static void CaseConvertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, CaseConvertOperator<IS_UPPER>>(args.data[0], result, args.size());
-}
-
-template <bool IS_UPPER>
-struct CaseConvertOperatorASCII {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetData();
-		auto input_length = input.GetSize();
-		return ASCIICaseConvert<IS_UPPER>(result, input_data, input_length);
-	}
-};
-
-template <bool IS_UPPER>
-static void CaseConvertFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, CaseConvertOperatorASCII<IS_UPPER>>(args.data[0], result,
-	                                                                                     args.size());
-}
-
-template <bool IS_UPPER>
-static unique_ptr<BaseStatistics> CaseConvertPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	if (!StringStats::CanContainUnicode(child_stats[0])) {
-		expr.function.function = CaseConvertFunctionASCII<IS_UPPER>;
-	}
-	return nullptr;
-}
-
-ScalarFunction LowerFun::GetFunction() {
-	return ScalarFunction("lower", {LogicalType::VARCHAR}, LogicalType::VARCHAR, CaseConvertFunction<false>, nullptr,
-	                      nullptr, CaseConvertPropagateStats<false>);
-}
-
-ScalarFunction UpperFun::GetFunction() {
-	return ScalarFunction("upper", {LogicalType::VARCHAR}, LogicalType::VARCHAR, CaseConvertFunction<true>, nullptr,
-	                      nullptr, CaseConvertPropagateStats<true>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/concat.cpp b/src/duckdb/src/function/scalar/string/concat.cpp
deleted file mode 100644
index a6a495a95..000000000
--- a/src/duckdb/src/function/scalar/string/concat.cpp
+++ /dev/null
@@ -1,367 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-#include <string.h>
-
-namespace duckdb {
-
-struct ConcatFunctionData : public FunctionData {
-	ConcatFunctionData(const LogicalType &return_type_p, bool is_operator_p)
-	    : return_type(return_type_p), is_operator(is_operator_p) {
-	}
-	~ConcatFunctionData() override;
-
-	LogicalType return_type;
-
-	bool is_operator = false;
-
-public:
-	bool Equals(const FunctionData &other_p) const override;
-	unique_ptr<FunctionData> Copy() const override;
-};
-
-ConcatFunctionData::~ConcatFunctionData() {
-}
-
-bool ConcatFunctionData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ConcatFunctionData>();
-	return return_type == other.return_type && is_operator == other.is_operator;
-}
-
-unique_ptr<FunctionData> ConcatFunctionData::Copy() const {
-	return make_uniq<ConcatFunctionData>(return_type, is_operator);
-}
-
-static void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	// iterate over the vectors to count how large the final string will be
-	idx_t constant_lengths = 0;
-	vector<idx_t> result_lengths(args.size(), 0);
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		auto &input = args.data[col_idx];
-		D_ASSERT(input.GetType().InternalType() == PhysicalType::VARCHAR);
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			if (ConstantVector::IsNull(input)) {
-				// constant null, skip
-				continue;
-			}
-			auto input_data = ConstantVector::GetData<string_t>(input);
-			constant_lengths += input_data->GetSize();
-		} else {
-			// non-constant vector: set the result type to a flat vector
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			// now get the lengths of each of the input elements
-			UnifiedVectorFormat vdata;
-			input.ToUnifiedFormat(args.size(), vdata);
-
-			auto input_data = UnifiedVectorFormat::GetData<string_t>(vdata);
-			// now add the length of each vector to the result length
-			for (idx_t i = 0; i < args.size(); i++) {
-				auto idx = vdata.sel->get_index(i);
-				if (!vdata.validity.RowIsValid(idx)) {
-					continue;
-				}
-				result_lengths[i] += input_data[idx].GetSize();
-			}
-		}
-	}
-
-	// first we allocate the empty strings for each of the values
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		// allocate an empty string of the required size
-		idx_t str_length = constant_lengths + result_lengths[i];
-		result_data[i] = StringVector::EmptyString(result, str_length);
-		// we reuse the result_lengths vector to store the currently appended size
-		result_lengths[i] = 0;
-	}
-
-	// now that the empty space for the strings has been allocated, perform the concatenation
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		auto &input = args.data[col_idx];
-
-		// loop over the vector and concat to all results
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// constant vector
-			if (ConstantVector::IsNull(input)) {
-				// constant null, skip
-				continue;
-			}
-			// append the constant vector to each of the strings
-			auto input_data = ConstantVector::GetData<string_t>(input);
-			auto input_ptr = input_data->GetData();
-			auto input_len = input_data->GetSize();
-			for (idx_t i = 0; i < args.size(); i++) {
-				memcpy(result_data[i].GetDataWriteable() + result_lengths[i], input_ptr, input_len);
-				result_lengths[i] += input_len;
-			}
-		} else {
-			// standard vector
-			UnifiedVectorFormat idata;
-			input.ToUnifiedFormat(args.size(), idata);
-
-			auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
-			for (idx_t i = 0; i < args.size(); i++) {
-				auto idx = idata.sel->get_index(i);
-				if (!idata.validity.RowIsValid(idx)) {
-					continue;
-				}
-				auto input_ptr = input_data[idx].GetData();
-				auto input_len = input_data[idx].GetSize();
-				memcpy(result_data[i].GetDataWriteable() + result_lengths[i], input_ptr, input_len);
-				result_lengths[i] += input_len;
-			}
-		}
-	}
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i].Finalize();
-	}
-}
-
-static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) {
-		    auto a_data = a.GetData();
-		    auto b_data = b.GetData();
-		    auto a_length = a.GetSize();
-		    auto b_length = b.GetSize();
-
-		    auto target_length = a_length + b_length;
-		    auto target = StringVector::EmptyString(result, target_length);
-		    auto target_data = target.GetDataWriteable();
-
-		    memcpy(target_data, a_data, a_length);
-		    memcpy(target_data + a_length, b_data, b_length);
-		    target.Finalize();
-		    return target;
-	    });
-}
-
-struct ListConcatInputData {
-	ListConcatInputData(Vector &input, Vector &child_vec) : input(input), child_vec(child_vec) {
-	}
-
-	UnifiedVectorFormat vdata;
-	Vector &input;
-	Vector &child_vec;
-	UnifiedVectorFormat child_vdata;
-	const list_entry_t *input_entries = nullptr;
-};
-
-static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result, bool is_operator) {
-	auto count = args.size();
-
-	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	vector<ListConcatInputData> input_data;
-	for (auto &input : args.data) {
-		if (!is_operator && input.GetType().id() == LogicalTypeId::SQLNULL) {
-			// LIST_CONCAT ignores NULL values
-			continue;
-		}
-
-		auto &child_vec = ListVector::GetEntry(input);
-		ListConcatInputData data(input, child_vec);
-		input.ToUnifiedFormat(count, data.vdata);
-
-		data.input_entries = UnifiedVectorFormat::GetData<list_entry_t>(data.vdata);
-		auto list_size = ListVector::GetListSize(input);
-
-		child_vec.ToUnifiedFormat(list_size, data.child_vdata);
-
-		input_data.push_back(std::move(data));
-	}
-
-	auto &result_validity = FlatVector::Validity(result);
-	idx_t offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto &result_entry = result_entries[i];
-		result_entry.offset = offset;
-		result_entry.length = 0;
-		for (auto &data : input_data) {
-			auto list_index = data.vdata.sel->get_index(i);
-			if (!data.vdata.validity.RowIsValid(list_index)) {
-				// LIST_CONCAT ignores NULL values, but || does not
-				if (is_operator) {
-					result_validity.SetInvalid(i);
-				}
-				continue;
-			}
-			const auto &list_entry = data.input_entries[list_index];
-			result_entry.length += list_entry.length;
-			ListVector::Append(result, data.child_vec, *data.child_vdata.sel, list_entry.offset + list_entry.length,
-			                   list_entry.offset);
-		}
-		offset += result_entry.length;
-	}
-	ListVector::SetListSize(result, offset);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<ConcatFunctionData>();
-	if (info.return_type.id() == LogicalTypeId::LIST) {
-		return ListConcatFunction(args, state, result, info.is_operator);
-	} else if (info.is_operator) {
-		return ConcatOperator(args, state, result);
-	}
-	return StringConcatFunction(args, state, result);
-}
-
-static void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bool is_operator) {
-	if (is_operator) {
-		bound_function.arguments[0] = type;
-		bound_function.arguments[1] = type;
-		bound_function.return_type = type;
-		return;
-	}
-
-	for (auto &arg : bound_function.arguments) {
-		arg = type;
-	}
-	bound_function.varargs = type;
-	bound_function.return_type = type;
-}
-
-static unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments, bool is_operator) {
-	LogicalType child_type = LogicalType::SQLNULL;
-	bool all_null = true;
-	for (auto &arg : arguments) {
-		auto &return_type = arg->return_type;
-		if (return_type == LogicalTypeId::SQLNULL) {
-			// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
-			continue;
-		}
-		all_null = false;
-		LogicalType next_type = LogicalTypeId::INVALID;
-		switch (return_type.id()) {
-		case LogicalTypeId::UNKNOWN:
-			throw ParameterNotResolvedException();
-		case LogicalTypeId::LIST:
-			next_type = ListType::GetChildType(return_type);
-			break;
-		case LogicalTypeId::ARRAY:
-			next_type = ArrayType::GetChildType(return_type);
-			break;
-		default: {
-			string type_list;
-			for (idx_t arg_idx = 0; arg_idx < arguments.size(); arg_idx++) {
-				if (!type_list.empty()) {
-					if (arg_idx + 1 == arguments.size()) {
-						// last argument
-						type_list += " and ";
-					} else {
-						type_list += ", ";
-					}
-				}
-				type_list += arguments[arg_idx]->return_type.ToString();
-			}
-			throw BinderException(*arg, "Cannot concatenate types %s - an explicit cast is required", type_list);
-		}
-		}
-		if (!LogicalType::TryGetMaxLogicalType(context, child_type, next_type, child_type)) {
-			throw BinderException(*arg,
-			                      "Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required",
-			                      child_type.ToString(), next_type.ToString());
-		}
-	}
-	if (all_null) {
-		// all arguments are NULL
-		SetArgumentType(bound_function, LogicalTypeId::SQLNULL, is_operator);
-		return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
-	}
-	auto list_type = LogicalType::LIST(child_type);
-
-	SetArgumentType(bound_function, list_type, is_operator);
-	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
-}
-
-static unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, ScalarFunction &bound_function,
-                                                           vector<unique_ptr<Expression>> &arguments,
-                                                           bool is_operator) {
-	bool list_concat = false;
-	// blob concat is only supported for the concat operator - regular concat converts to varchar
-	bool all_blob = is_operator ? true : false;
-	for (auto &arg : arguments) {
-		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-		if (arg->return_type.id() == LogicalTypeId::LIST || arg->return_type.id() == LogicalTypeId::ARRAY) {
-			list_concat = true;
-		}
-		if (arg->return_type.id() != LogicalTypeId::BLOB) {
-			all_blob = false;
-		}
-	}
-	if (list_concat) {
-		return BindListConcat(context, bound_function, arguments, is_operator);
-	}
-	auto return_type = all_blob ? LogicalType::BLOB : LogicalType::VARCHAR;
-
-	// we can now assume that the input is a string or castable to a string
-	SetArgumentType(bound_function, return_type, is_operator);
-	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
-}
-
-static unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	return BindConcatFunctionInternal(context, bound_function, arguments, false);
-}
-
-static unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	return BindConcatFunctionInternal(context, bound_function, arguments, true);
-}
-
-static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto stats = child_stats[0].ToUnique();
-	for (idx_t i = 1; i < child_stats.size(); i++) {
-		stats->Merge(child_stats[i]);
-	}
-	return stats;
-}
-
-ScalarFunction ListConcatFun::GetFunction() {
-	// The arguments and return types are set in the binder function.
-	auto fun = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)},
-	                          LogicalType::LIST(LogicalType::ANY), ConcatFunction, BindConcatFunction, nullptr,
-	                          ListConcatStats);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-// the concat operator and concat function have different behavior regarding NULLs
-// this is strange but seems consistent with postgresql and mysql
-// (sqlite does not support the concat function, only the concat operator)
-
-// the concat operator behaves as one would expect: any NULL value present results in a NULL
-// i.e. NULL || 'hello' = NULL
-// the concat function, however, treats NULL values as an empty string
-// i.e. concat(NULL, 'hello') = 'hello'
-ScalarFunction ConcatFun::GetFunction() {
-	ScalarFunction concat =
-	    ScalarFunction("concat", {LogicalType::ANY}, LogicalType::ANY, ConcatFunction, BindConcatFunction);
-	concat.varargs = LogicalType::ANY;
-	concat.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return concat;
-}
-
-ScalarFunction ConcatOperatorFun::GetFunction() {
-	ScalarFunction concat_op = ScalarFunction("||", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY,
-	                                          ConcatFunction, BindConcatOperator);
-	return concat_op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/concat_ws.cpp b/src/duckdb/src/function/scalar/string/concat_ws.cpp
deleted file mode 100644
index ebc1e8b3a..000000000
--- a/src/duckdb/src/function/scalar/string/concat_ws.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-
-#include <string.h>
-
-namespace duckdb {
-
-static void TemplatedConcatWS(DataChunk &args, const string_t *sep_data, const SelectionVector &sep_sel,
-                              const SelectionVector &rsel, idx_t count, Vector &result) {
-	vector<idx_t> result_lengths(args.size(), 0);
-	vector<bool> has_results(args.size(), false);
-
-	// we overallocate here, but this is important for static analysis
-	auto orrified_data = make_unsafe_uniq_array_uninitialized<UnifiedVectorFormat>(args.ColumnCount());
-
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]);
-	}
-
-	// first figure out the lengths
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		auto &idata = orrified_data[col_idx - 1];
-
-		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = rsel.get_index(i);
-			auto sep_idx = sep_sel.get_index(ridx);
-			auto idx = idata.sel->get_index(ridx);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			if (has_results[ridx]) {
-				result_lengths[ridx] += sep_data[sep_idx].GetSize();
-			}
-			result_lengths[ridx] += input_data[idx].GetSize();
-			has_results[ridx] = true;
-		}
-	}
-
-	// first we allocate the empty strings for each of the values
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < count; i++) {
-		auto ridx = rsel.get_index(i);
-		// allocate an empty string of the required size
-		result_data[ridx] = StringVector::EmptyString(result, result_lengths[ridx]);
-		// we reuse the result_lengths vector to store the currently appended size
-		result_lengths[ridx] = 0;
-		has_results[ridx] = false;
-	}
-
-	// now that the empty space for the strings has been allocated, perform the concatenation
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		auto &idata = orrified_data[col_idx - 1];
-		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = rsel.get_index(i);
-			auto sep_idx = sep_sel.get_index(ridx);
-			auto idx = idata.sel->get_index(ridx);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			if (has_results[ridx]) {
-				auto sep_size = sep_data[sep_idx].GetSize();
-				auto sep_ptr = sep_data[sep_idx].GetData();
-				memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size);
-				result_lengths[ridx] += sep_size;
-			}
-			auto input_ptr = input_data[idx].GetData();
-			auto input_len = input_data[idx].GetSize();
-			memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len);
-			result_lengths[ridx] += input_len;
-			has_results[ridx] = true;
-		}
-	}
-	for (idx_t i = 0; i < count; i++) {
-		auto ridx = rsel.get_index(i);
-		result_data[ridx].Finalize();
-	}
-}
-
-static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &separator = args.data[0];
-	UnifiedVectorFormat vdata;
-	separator.ToUnifiedFormat(args.size(), vdata);
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			break;
-		}
-	}
-	switch (separator.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		if (ConstantVector::IsNull(separator)) {
-			// constant NULL as separator: return constant NULL vector
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		// no null values
-		auto sel = FlatVector::IncrementalSelectionVector();
-		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, *sel, args.size(), result);
-		return;
-	}
-	default: {
-		// default case: loop over nullmask and create a non-null selection vector
-		idx_t not_null_count = 0;
-		SelectionVector not_null_vector(STANDARD_VECTOR_SIZE);
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < args.size(); i++) {
-			if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-				result_mask.SetInvalid(i);
-			} else {
-				not_null_vector.set_index(not_null_count++, i);
-			}
-		}
-		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, not_null_vector,
-		                  not_null_count, result);
-		return;
-	}
-	}
-}
-
-static unique_ptr<FunctionData> BindConcatWSFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	for (auto &arg : bound_function.arguments) {
-		arg = LogicalType::VARCHAR;
-	}
-	bound_function.varargs = LogicalType::VARCHAR;
-	return nullptr;
-}
-
-ScalarFunction ConcatWsFun::GetFunction() {
-	// concat_ws functions similarly to the concat function, except the result is NULL if the separator is NULL
-	// if the separator is not NULL, however, NULL values are counted as empty string
-	// there is one separate rule: there are no separators added between NULL values,
-	// so the NULL value and empty string are different!
-	// e.g.:
-	// concat_ws(',', NULL, NULL) = ""
-	// concat_ws(',', '', '') = ","
-
-	ScalarFunction concat_ws = ScalarFunction("concat_ws", {LogicalType::VARCHAR, LogicalType::ANY},
-	                                          LogicalType::VARCHAR, ConcatWSFunction, BindConcatWSFunction);
-	concat_ws.varargs = LogicalType::ANY;
-	concat_ws.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return ScalarFunction(concat_ws);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/contains.cpp b/src/duckdb/src/function/scalar/string/contains.cpp
deleted file mode 100644
index b34d62c78..000000000
--- a/src/duckdb/src/function/scalar/string/contains.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/list_functions.hpp"
-#include "duckdb/function/scalar/map_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-template <class UNSIGNED, int NEEDLE_SIZE>
-static idx_t ContainsUnaligned(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                               idx_t base_offset) {
-	if (NEEDLE_SIZE > haystack_size) {
-		// needle is bigger than haystack: haystack cannot contain needle
-		return DConstants::INVALID_INDEX;
-	}
-	// contains for a small unaligned needle (3/5/6/7 bytes)
-	// we perform unsigned integer comparisons to check for equality of the entire needle in a single comparison
-	// this implementation is inspired by the memmem implementation of freebsd
-
-	// first we set up the needle and the first NEEDLE_SIZE characters of the haystack as UNSIGNED integers
-	UNSIGNED needle_entry = 0;
-	UNSIGNED haystack_entry = 0;
-	const UNSIGNED start = (sizeof(UNSIGNED) * 8) - 8;
-	const UNSIGNED shift = (sizeof(UNSIGNED) - NEEDLE_SIZE) * 8;
-	for (idx_t i = 0; i < NEEDLE_SIZE; i++) {
-		needle_entry |= UNSIGNED(needle[i]) << UNSIGNED(start - i * 8);
-		haystack_entry |= UNSIGNED(haystack[i]) << UNSIGNED(start - i * 8);
-	}
-	// now we perform the actual search
-	for (idx_t offset = NEEDLE_SIZE; offset < haystack_size; offset++) {
-		// for this position we first compare the haystack with the needle
-		if (haystack_entry == needle_entry) {
-			return base_offset + offset - NEEDLE_SIZE;
-		}
-		// now we adjust the haystack entry by
-		// (1) removing the left-most character (shift by 8)
-		// (2) adding the next character (bitwise or, with potential shift)
-		// this shift is only necessary if the needle size is not aligned with the unsigned integer size
-		// (e.g. needle size 3, unsigned integer size 4, we need to shift by 1)
-		haystack_entry = (haystack_entry << 8) | ((UNSIGNED(haystack[offset])) << shift);
-	}
-	if (haystack_entry == needle_entry) {
-		return base_offset + haystack_size - NEEDLE_SIZE;
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-template <class UNSIGNED>
-static idx_t ContainsAligned(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                             idx_t base_offset) {
-	if (sizeof(UNSIGNED) > haystack_size) {
-		// needle is bigger than haystack: haystack cannot contain needle
-		return DConstants::INVALID_INDEX;
-	}
-	// contains for a small needle aligned with unsigned integer (2/4/8)
-	// similar to ContainsUnaligned, but simpler because we only need to do a reinterpret cast
-	auto needle_entry = Load<UNSIGNED>(needle);
-	for (idx_t offset = 0; offset <= haystack_size - sizeof(UNSIGNED); offset++) {
-		// for this position we first compare the haystack with the needle
-		auto haystack_entry = Load<UNSIGNED>(haystack + offset);
-		if (needle_entry == haystack_entry) {
-			return base_offset + offset;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t ContainsGeneric(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                      idx_t needle_size, idx_t base_offset) {
-	if (needle_size > haystack_size) {
-		// needle is bigger than haystack: haystack cannot contain needle
-		return DConstants::INVALID_INDEX;
-	}
-	// this implementation is inspired by Raphael Javaux's faststrstr (https://github.com/RaphaelJ/fast_strstr)
-	// generic contains; note that we can't use strstr because we don't have null-terminated strings anymore
-	// we keep track of a shifting window sum of all characters with window size equal to needle_size
-	// this shifting sum is used to avoid calling into memcmp;
-	// we only need to call into memcmp when the window sum is equal to the needle sum
-	// when that happens, the characters are potentially the same and we call into memcmp to check if they are
-	uint32_t sums_diff = 0;
-	for (idx_t i = 0; i < needle_size; i++) {
-		sums_diff += haystack[i];
-		sums_diff -= needle[i];
-	}
-	idx_t offset = 0;
-	while (true) {
-		if (sums_diff == 0 && haystack[offset] == needle[0]) {
-			if (memcmp(haystack + offset, needle, needle_size) == 0) {
-				return base_offset + offset;
-			}
-		}
-		if (offset >= haystack_size - needle_size) {
-			return DConstants::INVALID_INDEX;
-		}
-		sums_diff -= haystack[offset];
-		sums_diff += haystack[offset + needle_size];
-		offset++;
-	}
-}
-
-idx_t FindStrInStr(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle, idx_t needle_size) {
-	D_ASSERT(needle_size > 0);
-	// start off by performing a memchr to find the first character of the
-	auto location = memchr(haystack, needle[0], haystack_size);
-	if (location == nullptr) {
-		return DConstants::INVALID_INDEX;
-	}
-	idx_t base_offset = UnsafeNumericCast<idx_t>(const_uchar_ptr_cast(location) - haystack);
-	haystack_size -= base_offset;
-	haystack = const_uchar_ptr_cast(location);
-	// switch algorithm depending on needle size
-	switch (needle_size) {
-	case 1:
-		return base_offset;
-	case 2:
-		return ContainsAligned<uint16_t>(haystack, haystack_size, needle, base_offset);
-	case 3:
-		return ContainsUnaligned<uint32_t, 3>(haystack, haystack_size, needle, base_offset);
-	case 4:
-		return ContainsAligned<uint32_t>(haystack, haystack_size, needle, base_offset);
-	case 5:
-		return ContainsUnaligned<uint64_t, 5>(haystack, haystack_size, needle, base_offset);
-	case 6:
-		return ContainsUnaligned<uint64_t, 6>(haystack, haystack_size, needle, base_offset);
-	case 7:
-		return ContainsUnaligned<uint64_t, 7>(haystack, haystack_size, needle, base_offset);
-	case 8:
-		return ContainsAligned<uint64_t>(haystack, haystack_size, needle, base_offset);
-	default:
-		return ContainsGeneric(haystack, haystack_size, needle, needle_size, base_offset);
-	}
-}
-
-idx_t FindStrInStr(const string_t &haystack_s, const string_t &needle_s) {
-	auto haystack = const_uchar_ptr_cast(haystack_s.GetData());
-	auto haystack_size = haystack_s.GetSize();
-	auto needle = const_uchar_ptr_cast(needle_s.GetData());
-	auto needle_size = needle_s.GetSize();
-	if (needle_size == 0) {
-		// empty needle: always true
-		return 0;
-	}
-	return FindStrInStr(haystack, haystack_size, needle, needle_size);
-}
-
-struct ContainsOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return FindStrInStr(left, right) != DConstants::INVALID_INDEX;
-	}
-};
-
-ScalarFunction GetStringContains() {
-	ScalarFunction string_fun("contains", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                          ScalarFunction::BinaryFunction<string_t, string_t, bool, ContainsOperator>);
-	string_fun.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return string_fun;
-}
-
-ScalarFunctionSet ContainsFun::GetFunctions() {
-	auto string_fun = GetStringContains();
-	auto list_fun = ListContainsFun::GetFunction();
-	auto map_fun = MapContainsFun::GetFunction();
-	ScalarFunctionSet set("contains");
-	set.AddFunction(string_fun);
-	set.AddFunction(list_fun);
-	set.AddFunction(map_fun);
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/length.cpp b/src/duckdb/src/function/scalar/string/length.cpp
deleted file mode 100644
index 538646419..000000000
--- a/src/duckdb/src/function/scalar/string/length.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "utf8proc.hpp"
-
-namespace duckdb {
-
-// length returns the number of unicode codepoints
-struct StringLengthOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Length<TA, TR>(input);
-	}
-};
-
-struct GraphemeCountOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return GraphemeCount<TA, TR>(input);
-	}
-};
-
-// strlen returns the size in bytes
-struct StrLenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return UnsafeNumericCast<TR>(input.GetSize());
-	}
-};
-
-struct OctetLenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return UnsafeNumericCast<TR>(Bit::OctetLength(input));
-	}
-};
-
-// bitlen returns the size in bits
-struct BitLenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return UnsafeNumericCast<TR>(8 * input.GetSize());
-	}
-};
-
-// bitstringlen returns the amount of bits in a bitstring
-struct BitStringLenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return UnsafeNumericCast<TR>(Bit::BitLength(input));
-	}
-};
-
-static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	if (!StringStats::CanContainUnicode(child_stats[0])) {
-		expr.function.function = ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>;
-	}
-	return nullptr;
-}
-
-//------------------------------------------------------------------
-// ARRAY / LIST LENGTH
-//------------------------------------------------------------------
-static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-	D_ASSERT(input.GetType().id() == LogicalTypeId::LIST);
-	UnaryExecutor::Execute<list_entry_t, int64_t>(
-	    input, result, args.size(), [](list_entry_t input) { return UnsafeNumericCast<int64_t>(input.length); });
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnifiedVectorFormat format;
-	args.data[0].ToUnifiedFormat(args.size(), format);
-
-	// for arrays the length is constant
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::GetData<int64_t>(result)[0] = static_cast<int64_t>(ArrayType::GetSize(input.GetType()));
-
-	// but we do need to take null values into account
-	if (format.validity.AllValid()) {
-		// if there are no null values we can just return the constant
-		return;
-	}
-	// otherwise we flatten and inherit the null values of the parent
-	result.Flatten(args.size());
-	auto &result_validity = FlatVector::Validity(result);
-	for (idx_t r = 0; r < args.size(); r++) {
-		auto idx = format.sel->get_index(r);
-		if (!format.validity.RowIsValid(idx)) {
-			result_validity.SetInvalid(r);
-		}
-	}
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ArrayOrListLengthBind(ClientContext &context, ScalarFunction &bound_function,
-                                                      vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-
-	const auto &arg_type = arguments[0]->return_type.id();
-	if (arg_type == LogicalTypeId::ARRAY) {
-		bound_function.function = ArrayLengthFunction;
-	} else if (arg_type == LogicalTypeId::LIST) {
-		bound_function.function = ListLengthFunction;
-	} else {
-		// Unreachable
-		throw BinderException("length can only be used on arrays or lists");
-	}
-	bound_function.arguments[0] = arguments[0]->return_type;
-	return nullptr;
-}
-
-//------------------------------------------------------------------
-// ARRAY / LIST WITH DIMENSION
-//------------------------------------------------------------------
-static void ListLengthBinaryFunction(DataChunk &args, ExpressionState &, Vector &result) {
-	auto type = args.data[0].GetType();
-	auto &input = args.data[0];
-	auto &dimension = args.data[1];
-	BinaryExecutor::Execute<list_entry_t, int64_t, int64_t>(
-	    input, dimension, result, args.size(), [](list_entry_t input, int64_t dimension) {
-		    if (dimension != 1) {
-			    throw NotImplementedException("array_length for lists with dimensions other than 1 not implemented");
-		    }
-		    return UnsafeNumericCast<int64_t>(input.length);
-	    });
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-struct ArrayLengthBinaryFunctionData : public FunctionData {
-	vector<int64_t> dimensions;
-
-	unique_ptr<FunctionData> Copy() const override {
-		auto copy = make_uniq<ArrayLengthBinaryFunctionData>();
-		copy->dimensions = dimensions;
-		return std::move(copy);
-	}
-
-	bool Equals(const FunctionData &other) const override {
-		auto &other_data = other.Cast<const ArrayLengthBinaryFunctionData>();
-		return dimensions == other_data.dimensions;
-	}
-};
-
-static void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto type = args.data[0].GetType();
-	auto &dimension = args.data[1];
-
-	auto &expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &data = expr.bind_info->Cast<ArrayLengthBinaryFunctionData>();
-	auto &dimensions = data.dimensions;
-	auto max_dimension = static_cast<int64_t>(dimensions.size());
-
-	UnaryExecutor::Execute<int64_t, int64_t>(dimension, result, args.size(), [&](int64_t dimension) {
-		if (dimension < 1 || dimension > max_dimension) {
-			throw OutOfRangeException(StringUtil::Format(
-			    "array_length dimension '%lld' out of range (min: '1', max: '%lld')", dimension, max_dimension));
-		}
-		return dimensions[UnsafeNumericCast<idx_t>(dimension - 1)];
-	});
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ArrayOrListLengthBinaryBind(ClientContext &context, ScalarFunction &bound_function,
-                                                            vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	auto type = arguments[0]->return_type;
-	if (type.id() == LogicalTypeId::ARRAY) {
-		bound_function.arguments[0] = type;
-		bound_function.function = ArrayLengthBinaryFunction;
-
-		// If the input is an array, the dimensions are constant, so we can calculate them at bind time
-		vector<int64_t> dimensions;
-		while (true) {
-			if (type.id() == LogicalTypeId::ARRAY) {
-				dimensions.push_back(UnsafeNumericCast<int64_t>(ArrayType::GetSize(type)));
-				type = ArrayType::GetChildType(type);
-			} else {
-				break;
-			}
-		}
-		auto data = make_uniq<ArrayLengthBinaryFunctionData>();
-		data->dimensions = dimensions;
-		return std::move(data);
-
-	} else if (type.id() == LogicalTypeId::LIST) {
-		bound_function.function = ListLengthBinaryFunction;
-		bound_function.arguments[0] = type;
-		return nullptr;
-	} else {
-		// Unreachable
-		throw BinderException("array_length can only be used on arrays or lists");
-	}
-}
-
-ScalarFunctionSet LengthFun::GetFunctions() {
-	ScalarFunctionSet length("length");
-	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                  ScalarFunction::UnaryFunction<string_t, int64_t, StringLengthOperator>, nullptr,
-	                                  nullptr, LengthPropagateStats));
-	length.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
-	                                  ScalarFunction::UnaryFunction<string_t, int64_t, BitStringLenOperator>));
-	length.AddFunction(
-	    ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT, nullptr, ArrayOrListLengthBind));
-	return (length);
-}
-
-ScalarFunctionSet LengthGraphemeFun::GetFunctions() {
-	ScalarFunctionSet length_grapheme("length_grapheme");
-	length_grapheme.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                           ScalarFunction::UnaryFunction<string_t, int64_t, GraphemeCountOperator>,
-	                                           nullptr, nullptr, LengthPropagateStats));
-	return (length_grapheme);
-}
-
-ScalarFunctionSet ArrayLengthFun::GetFunctions() {
-	ScalarFunctionSet array_length("array_length");
-	array_length.AddFunction(
-	    ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT, nullptr, ArrayOrListLengthBind));
-	array_length.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT},
-	                                        LogicalType::BIGINT, nullptr, ArrayOrListLengthBinaryBind));
-	for (auto &func : array_length.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return (array_length);
-}
-
-ScalarFunction StrlenFun::GetFunction() {
-	return ScalarFunction("strlen", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                      ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>);
-}
-
-ScalarFunctionSet BitLengthFun::GetFunctions() {
-	ScalarFunctionSet bit_length("bit_length");
-	bit_length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                      ScalarFunction::UnaryFunction<string_t, int64_t, BitLenOperator>));
-	bit_length.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
-	                                      ScalarFunction::UnaryFunction<string_t, int64_t, BitStringLenOperator>));
-	return (bit_length);
-}
-
-ScalarFunctionSet OctetLengthFun::GetFunctions() {
-	// length for BLOB type
-	ScalarFunctionSet octet_length("octet_length");
-	octet_length.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::BIGINT,
-	                                        ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>));
-	octet_length.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
-	                                        ScalarFunction::UnaryFunction<string_t, int64_t, OctetLenOperator>));
-	return (octet_length);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/like.cpp b/src/duckdb/src/function/scalar/string/like.cpp
deleted file mode 100644
index 5e279cf28..000000000
--- a/src/duckdb/src/function/scalar/string/like.cpp
+++ /dev/null
@@ -1,587 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-struct StandardCharacterReader {
-	static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) {
-		sidx++;
-		while (sidx < slen && !IsCharacter(sdata[sidx])) {
-			sidx++;
-		}
-	}
-
-	static char Operation(const char *data, idx_t pos) {
-		return data[pos];
-	}
-};
-
-struct ASCIILCaseReader {
-	static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) {
-		sidx++;
-	}
-
-	static char Operation(const char *data, idx_t pos) {
-		return (char)StringUtil::ASCII_TO_LOWER_MAP[(uint8_t)data[pos]];
-	}
-};
-
-template <char PERCENTAGE, char UNDERSCORE, bool HAS_ESCAPE, class READER = StandardCharacterReader>
-bool TemplatedLikeOperator(const char *sdata, idx_t slen, const char *pdata, idx_t plen, char escape) {
-	idx_t pidx = 0;
-	idx_t sidx = 0;
-	for (; pidx < plen && sidx < slen; pidx++) {
-		char pchar = READER::Operation(pdata, pidx);
-		char schar = READER::Operation(sdata, sidx);
-		if (HAS_ESCAPE && pchar == escape) {
-			pidx++;
-			if (pidx == plen) {
-				throw SyntaxException("Like pattern must not end with escape character!");
-			}
-			if (pdata[pidx] != schar) {
-				return false;
-			}
-			sidx++;
-		} else if (pchar == UNDERSCORE) {
-			READER::NextCharacter(sdata, slen, sidx);
-		} else if (pchar == PERCENTAGE) {
-			pidx++;
-			while (pidx < plen && pdata[pidx] == PERCENTAGE) {
-				pidx++;
-			}
-			if (pidx == plen) {
-				return true; /* tail is acceptable */
-			}
-			for (; sidx < slen; sidx++) {
-				if (TemplatedLikeOperator<PERCENTAGE, UNDERSCORE, HAS_ESCAPE, READER>(
-				        sdata + sidx, slen - sidx, pdata + pidx, plen - pidx, escape)) {
-					return true;
-				}
-			}
-			return false;
-		} else if (pchar == schar) {
-			sidx++;
-		} else {
-			return false;
-		}
-	}
-	while (pidx < plen && pdata[pidx] == PERCENTAGE) {
-		pidx++;
-	}
-	return pidx == plen && sidx == slen;
-}
-
-struct LikeSegment {
-	explicit LikeSegment(string pattern) : pattern(std::move(pattern)) {
-	}
-
-	string pattern;
-};
-
-struct LikeMatcher : public FunctionData {
-	LikeMatcher(string like_pattern_p, vector<LikeSegment> segments, bool has_start_percentage, bool has_end_percentage)
-	    : like_pattern(std::move(like_pattern_p)), segments(std::move(segments)),
-	      has_start_percentage(has_start_percentage), has_end_percentage(has_end_percentage) {
-	}
-
-	bool Match(string_t &str) {
-		auto str_data = const_uchar_ptr_cast(str.GetData());
-		auto str_len = str.GetSize();
-		idx_t segment_idx = 0;
-		idx_t end_idx = segments.size() - 1;
-		if (!has_start_percentage) {
-			// no start sample_size: match the first part of the string directly
-			auto &segment = segments[0];
-			if (str_len < segment.pattern.size()) {
-				return false;
-			}
-			if (memcmp(str_data, segment.pattern.c_str(), segment.pattern.size()) != 0) {
-				return false;
-			}
-			str_data += segment.pattern.size();
-			str_len -= segment.pattern.size();
-			segment_idx++;
-			if (segments.size() == 1) {
-				// only one segment, and it matches
-				// we have a match if there is an end sample_size, OR if the memcmp was an exact match (remaining str is
-				// empty)
-				return has_end_percentage || str_len == 0;
-			}
-		}
-		// main match loop: for every segment in the middle, use Contains to find the needle in the haystack
-		for (; segment_idx < end_idx; segment_idx++) {
-			auto &segment = segments[segment_idx];
-			// find the pattern of the current segment
-			idx_t next_offset =
-			    FindStrInStr(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()), segment.pattern.size());
-			if (next_offset == DConstants::INVALID_INDEX) {
-				// could not find this pattern in the string: no match
-				return false;
-			}
-			idx_t offset = next_offset + segment.pattern.size();
-			str_data += offset;
-			str_len -= offset;
-		}
-		if (!has_end_percentage) {
-			end_idx--;
-			// no end sample_size: match the final segment now
-			auto &segment = segments.back();
-			if (str_len < segment.pattern.size()) {
-				return false;
-			}
-			if (memcmp(str_data + str_len - segment.pattern.size(), segment.pattern.c_str(), segment.pattern.size()) !=
-			    0) {
-				return false;
-			}
-			return true;
-		} else {
-			auto &segment = segments.back();
-			// find the pattern of the current segment
-			idx_t next_offset =
-			    FindStrInStr(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()), segment.pattern.size());
-			return next_offset != DConstants::INVALID_INDEX;
-		}
-	}
-
-	static unique_ptr<LikeMatcher> CreateLikeMatcher(string like_pattern, char escape = '\0') {
-		vector<LikeSegment> segments;
-		idx_t last_non_pattern = 0;
-		bool has_start_percentage = false;
-		bool has_end_percentage = false;
-		for (idx_t i = 0; i < like_pattern.size(); i++) {
-			auto ch = like_pattern[i];
-			if (ch == escape || ch == '%' || ch == '_') {
-				// special character, push a constant pattern
-				if (i > last_non_pattern) {
-					segments.emplace_back(like_pattern.substr(last_non_pattern, i - last_non_pattern));
-				}
-				last_non_pattern = i + 1;
-				if (ch == escape || ch == '_') {
-					// escape or underscore: could not create efficient like matcher
-					// FIXME: we could handle escaped percentages here
-					return nullptr;
-				} else {
-					// sample_size
-					if (i == 0) {
-						has_start_percentage = true;
-					}
-					if (i + 1 == like_pattern.size()) {
-						has_end_percentage = true;
-					}
-				}
-			}
-		}
-		if (last_non_pattern < like_pattern.size()) {
-			segments.emplace_back(like_pattern.substr(last_non_pattern, like_pattern.size() - last_non_pattern));
-		}
-		if (segments.empty()) {
-			return nullptr;
-		}
-		return make_uniq<LikeMatcher>(std::move(like_pattern), std::move(segments), has_start_percentage,
-		                              has_end_percentage);
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<LikeMatcher>(like_pattern, segments, has_start_percentage, has_end_percentage);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<LikeMatcher>();
-		return like_pattern == other.like_pattern;
-	}
-
-private:
-	string like_pattern;
-	vector<LikeSegment> segments;
-	bool has_start_percentage;
-	bool has_end_percentage;
-};
-
-static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
-	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
-	for (auto &arg : arguments) {
-		if (arg->return_type.id() == LogicalTypeId::VARCHAR && !StringType::GetCollation(arg->return_type).empty()) {
-			return nullptr;
-		}
-	}
-	if (arguments[1]->IsFoldable()) {
-		Value pattern_str = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		return LikeMatcher::CreateLikeMatcher(pattern_str.ToString());
-	}
-	return nullptr;
-}
-
-bool LikeOperatorFunction(const char *s, idx_t slen, const char *pattern, idx_t plen, char escape) {
-	return TemplatedLikeOperator<'%', '_', true>(s, slen, pattern, plen, escape);
-}
-
-bool LikeOperatorFunction(const char *s, idx_t slen, const char *pattern, idx_t plen) {
-	return TemplatedLikeOperator<'%', '_', false>(s, slen, pattern, plen, '\0');
-}
-
-bool LikeOperatorFunction(string_t &s, string_t &pat) {
-	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize());
-}
-
-bool LikeOperatorFunction(string_t &s, string_t &pat, char escape) {
-	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize(), escape);
-}
-
-bool Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
-	idx_t sidx = 0;
-	idx_t pidx = 0;
-main_loop : {
-	// main matching loop
-	while (sidx < slen && pidx < plen) {
-		char s = string[sidx];
-		char p = pattern[pidx];
-		switch (p) {
-		case '*': {
-			// asterisk: match any set of characters
-			// skip any subsequent asterisks
-			pidx++;
-			while (pidx < plen && pattern[pidx] == '*') {
-				pidx++;
-			}
-			// if the asterisk is the last character, the pattern always matches
-			if (pidx == plen) {
-				return true;
-			}
-			// recursively match the remainder of the pattern
-			for (; sidx < slen; sidx++) {
-				if (Glob(string + sidx, slen - sidx, pattern + pidx, plen - pidx)) {
-					return true;
-				}
-			}
-			return false;
-		}
-		case '?':
-			// when enabled: matches anything but null
-			if (allow_question_mark) {
-				break;
-			}
-			DUCKDB_EXPLICIT_FALLTHROUGH;
-		case '[':
-			pidx++;
-			goto parse_bracket;
-		case '\\':
-			// escape character, next character needs to match literally
-			pidx++;
-			// check that we still have a character remaining
-			if (pidx == plen) {
-				return false;
-			}
-			p = pattern[pidx];
-			if (s != p) {
-				return false;
-			}
-			break;
-		default:
-			// not a control character: characters need to match literally
-			if (s != p) {
-				return false;
-			}
-			break;
-		}
-		sidx++;
-		pidx++;
-	}
-	while (pidx < plen && pattern[pidx] == '*') {
-		pidx++;
-	}
-	// we are finished only if we have consumed the full pattern
-	return pidx == plen && sidx == slen;
-}
-parse_bracket : {
-	// inside a bracket
-	if (pidx == plen) {
-		return false;
-	}
-	// check the first character
-	// if it is an exclamation mark we need to invert our logic
-	char p = pattern[pidx];
-	char s = string[sidx];
-	bool invert = false;
-	if (p == '!') {
-		invert = true;
-		pidx++;
-	}
-	bool found_match = invert;
-	idx_t start_pos = pidx;
-	bool found_closing_bracket = false;
-	// now check the remainder of the pattern
-	while (pidx < plen) {
-		p = pattern[pidx];
-		// if the first character is a closing bracket, we match it literally
-		// otherwise it indicates an end of bracket
-		if (p == ']' && pidx > start_pos) {
-			// end of bracket found: we are done
-			found_closing_bracket = true;
-			pidx++;
-			break;
-		}
-		// we either match a range (a-b) or a single character (a)
-		// check if the next character is a dash
-		if (pidx + 1 == plen) {
-			// no next character!
-			break;
-		}
-		bool matches;
-		if (pattern[pidx + 1] == '-') {
-			// range! find the next character in the range
-			if (pidx + 2 == plen) {
-				break;
-			}
-			char next_char = pattern[pidx + 2];
-			// check if the current character is within the range
-			matches = s >= p && s <= next_char;
-			// shift the pattern forward past the range
-			pidx += 3;
-		} else {
-			// no range! perform a direct match
-			matches = p == s;
-			// shift the pattern forward past the character
-			pidx++;
-		}
-		if (found_match == invert && matches) {
-			// found a match! set the found_matches flag
-			// we keep on pattern matching after this until we reach the end bracket
-			// however, we don't need to update the found_match flag anymore
-			found_match = !invert;
-		}
-	}
-	if (!found_closing_bracket) {
-		// no end of bracket: invalid pattern
-		return false;
-	}
-	if (!found_match) {
-		// did not match the bracket: return false;
-		return false;
-	}
-	// finished the bracket matching: move forward
-	sidx++;
-	goto main_loop;
-}
-}
-
-static char GetEscapeChar(string_t escape) {
-	// Only one escape character should be allowed
-	if (escape.GetSize() > 1) {
-		throw SyntaxException("Invalid escape string. Escape string must be empty or one character.");
-	}
-	return escape.GetSize() == 0 ? '\0' : *escape.GetData();
-}
-
-struct LikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		char escape_char = GetEscapeChar(escape);
-		return LikeOperatorFunction(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize(), escape_char);
-	}
-};
-
-struct NotLikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		return !LikeEscapeOperator::Operation(str, pattern, escape);
-	}
-};
-
-struct LikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return LikeOperatorFunction(str, pattern);
-	}
-};
-
-bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0') {
-	auto str_data = str.GetData();
-	auto str_size = str.GetSize();
-	auto pat_data = pattern.GetData();
-	auto pat_size = pattern.GetSize();
-
-	// lowercase both the str and the pattern
-	idx_t str_llength = LowerLength(str_data, str_size);
-	auto str_ldata = make_unsafe_uniq_array_uninitialized<char>(str_llength);
-	LowerCase(str_data, str_size, str_ldata.get());
-
-	idx_t pat_llength = LowerLength(pat_data, pat_size);
-	auto pat_ldata = make_unsafe_uniq_array_uninitialized<char>(pat_llength);
-	LowerCase(pat_data, pat_size, pat_ldata.get());
-	string_t str_lcase(str_ldata.get(), UnsafeNumericCast<uint32_t>(str_llength));
-	string_t pat_lcase(pat_ldata.get(), UnsafeNumericCast<uint32_t>(pat_llength));
-	return LikeOperatorFunction(str_lcase, pat_lcase, escape);
-}
-
-struct ILikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		char escape_char = GetEscapeChar(escape);
-		return ILikeOperatorFunction(str, pattern, escape_char);
-	}
-};
-
-struct NotILikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		return !ILikeEscapeOperator::Operation(str, pattern, escape);
-	}
-};
-
-struct ILikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return ILikeOperatorFunction(str, pattern);
-	}
-};
-
-struct NotLikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return !LikeOperatorFunction(str, pattern);
-	}
-};
-
-struct NotILikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return !ILikeOperator::Operation<TA, TB, TR>(str, pattern);
-	}
-};
-
-struct ILikeOperatorASCII {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return TemplatedLikeOperator<'%', '_', false, ASCIILCaseReader>(str.GetData(), str.GetSize(), pattern.GetData(),
-		                                                                pattern.GetSize(), '\0');
-	}
-};
-
-struct NotILikeOperatorASCII {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return !ILikeOperatorASCII::Operation<TA, TB, TR>(str, pattern);
-	}
-};
-
-struct GlobOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return Glob(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize());
-	}
-};
-
-// This can be moved to the scalar_function class
-template <typename FUNC>
-static void LikeEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str = args.data[0];
-	auto &pattern = args.data[1];
-	auto &escape = args.data[2];
-
-	TernaryExecutor::Execute<string_t, string_t, string_t, bool>(
-	    str, pattern, escape, result, args.size(), FUNC::template Operation<string_t, string_t, string_t>);
-}
-
-template <class ASCII_OP>
-static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() >= 1);
-	// can only propagate stats if the children have stats
-	if (!StringStats::CanContainUnicode(child_stats[0])) {
-		expr.function.function = ScalarFunction::BinaryFunction<string_t, string_t, bool, ASCII_OP>;
-	}
-	return nullptr;
-}
-
-template <class OP, bool INVERT>
-static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	if (func_expr.bind_info) {
-		auto &matcher = func_expr.bind_info->Cast<LikeMatcher>();
-		// use fast like matcher
-		UnaryExecutor::Execute<string_t, bool>(input.data[0], result, input.size(), [&](string_t input) {
-			return INVERT ? !matcher.Match(input) : matcher.Match(input);
-		});
-	} else {
-		// use generic like matcher
-		BinaryExecutor::ExecuteStandard<string_t, string_t, bool, OP>(input.data[0], input.data[1], result,
-		                                                              input.size());
-	}
-}
-
-ScalarFunction NotLikeFun::GetFunction() {
-	ScalarFunction not_like("!~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                        RegularLikeFunction<NotLikeOperator, true>, LikeBindFunction);
-	not_like.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return not_like;
-}
-
-ScalarFunction GlobPatternFun::GetFunction() {
-	ScalarFunction glob("~~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                    ScalarFunction::BinaryFunction<string_t, string_t, bool, GlobOperator>);
-	glob.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return glob;
-}
-
-ScalarFunction ILikeFun::GetFunction() {
-	ScalarFunction ilike("~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                     ScalarFunction::BinaryFunction<string_t, string_t, bool, ILikeOperator>, nullptr, nullptr,
-	                     ILikePropagateStats<ILikeOperatorASCII>);
-	ilike.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return ilike;
-}
-
-ScalarFunction NotILikeFun::GetFunction() {
-	ScalarFunction not_ilike("!~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                         ScalarFunction::BinaryFunction<string_t, string_t, bool, NotILikeOperator>, nullptr,
-	                         nullptr, ILikePropagateStats<NotILikeOperatorASCII>);
-	not_ilike.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return not_ilike;
-}
-
-ScalarFunction LikeFun::GetFunction() {
-	ScalarFunction like("~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                    RegularLikeFunction<LikeOperator, false>, LikeBindFunction);
-	like.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return like;
-}
-
-ScalarFunction NotLikeEscapeFun::GetFunction() {
-	ScalarFunction not_like_escape("not_like_escape",
-	                               {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotLikeEscapeOperator>);
-	not_like_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return not_like_escape;
-}
-
-ScalarFunction IlikeEscapeFun::GetFunction() {
-	ScalarFunction ilike_escape("ilike_escape", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                            LogicalType::BOOLEAN, LikeEscapeFunction<ILikeEscapeOperator>);
-	ilike_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return ilike_escape;
-}
-
-ScalarFunction NotIlikeEscapeFun::GetFunction() {
-	ScalarFunction not_ilike_escape("not_ilike_escape",
-	                                {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                LogicalType::BOOLEAN, LikeEscapeFunction<NotILikeEscapeOperator>);
-	not_ilike_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return not_ilike_escape;
-}
-ScalarFunction LikeEscapeFun::GetFunction() {
-	ScalarFunction like_escape("like_escape", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                           LogicalType::BOOLEAN, LikeEscapeFunction<LikeEscapeOperator>);
-	like_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
-	return like_escape;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/md5.cpp b/src/duckdb/src/function/scalar/string/md5.cpp
deleted file mode 100644
index 837f97c12..000000000
--- a/src/duckdb/src/function/scalar/string/md5.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/common/crypto/md5.hpp"
-
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-
-namespace duckdb {
-
-struct MD5Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto hash = StringVector::EmptyString(result, MD5Context::MD5_HASH_LENGTH_TEXT);
-		MD5Context context;
-		context.Add(input);
-		context.FinishHex(hash.GetDataWriteable());
-		hash.Finalize();
-		return hash;
-	}
-};
-
-struct MD5Number128Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		data_t digest[MD5Context::MD5_HASH_LENGTH_BINARY];
-
-		MD5Context context;
-		context.Add(input);
-		context.Finish(digest);
-		return *reinterpret_cast<hugeint_t *>(digest);
-	}
-};
-
-static void MD5Function(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::ExecuteString<string_t, string_t, MD5Operator>(input, result, args.size());
-}
-
-static void MD5NumberFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::Execute<string_t, hugeint_t, MD5Number128Operator>(input, result, args.size());
-}
-
-ScalarFunctionSet MD5Fun::GetFunctions() {
-	ScalarFunctionSet set("md5");
-	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, MD5Function));
-	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, MD5Function));
-	return set;
-}
-
-ScalarFunctionSet MD5NumberFun::GetFunctions() {
-	ScalarFunctionSet set("md5_number");
-	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::HUGEINT, MD5NumberFunction));
-	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::HUGEINT, MD5NumberFunction));
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/nfc_normalize.cpp b/src/duckdb/src/function/scalar/string/nfc_normalize.cpp
deleted file mode 100644
index 92a061494..000000000
--- a/src/duckdb/src/function/scalar/string/nfc_normalize.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-struct NFCNormalizeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetData();
-		auto input_length = input.GetSize();
-		if (IsAscii(input_data, input_length)) {
-			return input;
-		}
-		auto normalized_str = Utf8Proc::Normalize(input_data, input_length);
-		D_ASSERT(normalized_str);
-		auto result_str = StringVector::AddString(result, normalized_str);
-		free(normalized_str);
-		return result_str;
-	}
-};
-
-static void NFCNormalizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-
-	UnaryExecutor::ExecuteString<string_t, string_t, NFCNormalizeOperator>(args.data[0], result, args.size());
-	StringVector::AddHeapReference(result, args.data[0]);
-}
-
-ScalarFunction NFCNormalizeFun::GetFunction() {
-	return ScalarFunction("nfc_normalize", {LogicalType::VARCHAR}, LogicalType::VARCHAR, NFCNormalizeFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/prefix.cpp b/src/duckdb/src/function/scalar/string/prefix.cpp
deleted file mode 100644
index 2b46610fa..000000000
--- a/src/duckdb/src/function/scalar/string/prefix.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-static bool PrefixFunction(const string_t &str, const string_t &pattern);
-
-struct PrefixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return PrefixFunction(left, right);
-	}
-};
-static bool PrefixFunction(const string_t &str, const string_t &pattern) {
-	auto str_length = str.GetSize();
-	auto patt_length = pattern.GetSize();
-	if (patt_length > str_length) {
-		return false;
-	}
-	if (patt_length <= string_t::PREFIX_LENGTH) {
-		// short prefix
-		if (patt_length == 0) {
-			// length = 0, return true
-			return true;
-		}
-
-		// prefix early out
-		const char *str_pref = str.GetPrefix();
-		const char *patt_pref = pattern.GetPrefix();
-		for (idx_t i = 0; i < patt_length; ++i) {
-			if (str_pref[i] != patt_pref[i]) {
-				return false;
-			}
-		}
-		return true;
-	} else {
-		// prefix early out
-		const char *str_pref = str.GetPrefix();
-		const char *patt_pref = pattern.GetPrefix();
-		for (idx_t i = 0; i < string_t::PREFIX_LENGTH; ++i) {
-			if (str_pref[i] != patt_pref[i]) {
-				// early out
-				return false;
-			}
-		}
-		// compare the rest of the prefix
-		const char *str_data = str.GetData();
-		const char *patt_data = pattern.GetData();
-		D_ASSERT(patt_length <= str_length);
-		for (idx_t i = string_t::PREFIX_LENGTH; i < patt_length; ++i) {
-			if (str_data[i] != patt_data[i]) {
-				return false;
-			}
-		}
-		return true;
-	}
-}
-
-ScalarFunction PrefixFun::GetFunction() {
-	return ScalarFunction("prefix",                                     // name of the function
-	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                      LogicalType::BOOLEAN,                         // return type
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, PrefixOperator>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/regexp.cpp b/src/duckdb/src/function/scalar/string/regexp.cpp
deleted file mode 100644
index 2383e3b57..000000000
--- a/src/duckdb/src/function/scalar/string/regexp.cpp
+++ /dev/null
@@ -1,470 +0,0 @@
-#include "duckdb/function/scalar/regexp.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-using regexp_util::CreateStringPiece;
-using regexp_util::Extract;
-using regexp_util::ParseRegexOptions;
-using regexp_util::TryParseConstantPattern;
-
-static bool RegexOptionsEquals(const duckdb_re2::RE2::Options &opt_a, const duckdb_re2::RE2::Options &opt_b) {
-	return opt_a.case_sensitive() == opt_b.case_sensitive();
-}
-
-RegexpBaseBindData::RegexpBaseBindData() : constant_pattern(false) {
-}
-RegexpBaseBindData::RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string_p,
-                                       bool constant_pattern)
-    : options(options), constant_string(std::move(constant_string_p)), constant_pattern(constant_pattern) {
-}
-
-RegexpBaseBindData::~RegexpBaseBindData() {
-}
-
-bool RegexpBaseBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<RegexpBaseBindData>();
-	return constant_pattern == other.constant_pattern && constant_string == other.constant_string &&
-	       RegexOptionsEquals(options, other.options);
-}
-
-unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                   FunctionData *bind_data) {
-	auto &info = bind_data->Cast<RegexpBaseBindData>();
-	if (info.constant_pattern) {
-		return make_uniq<RegexLocalState>(info);
-	}
-	return nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Regexp Matches
-//===--------------------------------------------------------------------===//
-RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p,
-                                             bool constant_pattern)
-    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern) {
-	if (constant_pattern) {
-		auto pattern = make_uniq<RE2>(constant_string, options);
-		if (!pattern->ok()) {
-			throw InvalidInputException(pattern->error());
-		}
-
-		range_success = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
-	} else {
-		range_success = false;
-	}
-}
-
-RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p,
-                                             bool constant_pattern, string range_min_p, string range_max_p,
-                                             bool range_success)
-    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern), range_min(std::move(range_min_p)),
-      range_max(std::move(range_max_p)), range_success(range_success) {
-}
-
-unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
-	return make_uniq<RegexpMatchesBindData>(options, constant_string, constant_pattern, range_min, range_max,
-	                                        range_success);
-}
-
-unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
-	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
-	RE2::Options options;
-	options.set_log_errors(false);
-	if (arguments.size() == 3) {
-		ParseRegexOptions(context, *arguments[2], options);
-	}
-
-	string constant_string;
-	bool constant_pattern;
-	constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
-	return make_uniq<RegexpMatchesBindData>(options, std::move(constant_string), constant_pattern);
-}
-
-struct RegexPartialMatch {
-	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
-		return duckdb_re2::RE2::PartialMatch(input, re);
-	}
-};
-
-struct RegexFullMatch {
-	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
-		return duckdb_re2::RE2::FullMatch(input, re);
-	}
-};
-
-template <class OP>
-static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
-
-	if (info.constant_pattern) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		UnaryExecutor::Execute<string_t, bool>(strings, result, args.size(), [&](string_t input) {
-			return OP::Operation(CreateStringPiece(input), lstate.constant_pattern);
-		});
-	} else {
-		BinaryExecutor::Execute<string_t, string_t, bool>(strings, patterns, result, args.size(),
-		                                                  [&](string_t input, string_t pattern) {
-			                                                  RE2 re(CreateStringPiece(pattern), info.options);
-			                                                  if (!re.ok()) {
-				                                                  throw InvalidInputException(re.error());
-			                                                  }
-			                                                  return OP::Operation(CreateStringPiece(input), re);
-		                                                  });
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Regexp Replace
-//===--------------------------------------------------------------------===//
-RegexpReplaceBindData::RegexpReplaceBindData() : global_replace(false) {
-}
-
-RegexpReplaceBindData::RegexpReplaceBindData(duckdb_re2::RE2::Options options, string constant_string_p,
-                                             bool constant_pattern, bool global_replace)
-    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern), global_replace(global_replace) {
-}
-
-unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
-	auto copy = make_uniq<RegexpReplaceBindData>(options, constant_string, constant_pattern, global_replace);
-	return std::move(copy);
-}
-
-bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<RegexpReplaceBindData>();
-	return RegexpBaseBindData::Equals(other) && global_replace == other.global_replace;
-}
-
-static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	auto data = make_uniq<RegexpReplaceBindData>();
-
-	data->constant_pattern = TryParseConstantPattern(context, *arguments[1], data->constant_string);
-	if (arguments.size() == 4) {
-		ParseRegexOptions(context, *arguments[3], data->options, &data->global_replace);
-	}
-	data->options.set_log_errors(false);
-	return std::move(data);
-}
-
-static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<RegexpReplaceBindData>();
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	auto &replaces = args.data[2];
-
-	if (info.constant_pattern) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		BinaryExecutor::Execute<string_t, string_t, string_t>(
-		    strings, replaces, result, args.size(), [&](string_t input, string_t replace) {
-			    std::string sstring = input.GetString();
-			    if (info.global_replace) {
-				    RE2::GlobalReplace(&sstring, lstate.constant_pattern, CreateStringPiece(replace));
-			    } else {
-				    RE2::Replace(&sstring, lstate.constant_pattern, CreateStringPiece(replace));
-			    }
-			    return StringVector::AddString(result, sstring);
-		    });
-	} else {
-		TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
-		    strings, patterns, replaces, result, args.size(), [&](string_t input, string_t pattern, string_t replace) {
-			    RE2 re(CreateStringPiece(pattern), info.options);
-			    std::string sstring = input.GetString();
-			    if (info.global_replace) {
-				    RE2::GlobalReplace(&sstring, re, CreateStringPiece(replace));
-			    } else {
-				    RE2::Replace(&sstring, re, CreateStringPiece(replace));
-			    }
-			    return StringVector::AddString(result, sstring);
-		    });
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Regexp Extract
-//===--------------------------------------------------------------------===//
-RegexpExtractBindData::RegexpExtractBindData() {
-}
-
-RegexpExtractBindData::RegexpExtractBindData(duckdb_re2::RE2::Options options, string constant_string_p,
-                                             bool constant_pattern, string group_string_p)
-    : RegexpBaseBindData(options, std::move(constant_string_p), constant_pattern),
-      group_string(std::move(group_string_p)), rewrite(group_string) {
-}
-
-unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
-	return make_uniq<RegexpExtractBindData>(options, constant_string, constant_pattern, group_string);
-}
-
-bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<RegexpExtractBindData>();
-	return RegexpBaseBindData::Equals(other) && group_string == other.group_string;
-}
-
-static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	const auto &info = func_expr.bind_info->Cast<RegexpExtractBindData>();
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	if (info.constant_pattern) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
-			return Extract(input, result, lstate.constant_pattern, info.rewrite);
-		});
-	} else {
-		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
-		                                                      [&](string_t input, string_t pattern) {
-			                                                      RE2 re(CreateStringPiece(pattern), info.options);
-			                                                      return Extract(input, result, re, info.rewrite);
-		                                                      });
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Regexp Extract Struct
-//===--------------------------------------------------------------------===//
-static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-
-	const auto count = args.size();
-	auto &input = args.data[0];
-
-	auto &child_entries = StructVector::GetEntries(result);
-	const auto groupSize = child_entries.size();
-	// Reference the 'input' StringBuffer, because we won't need to allocate new data
-	// for the result, all returned strings are substrings of the originals
-	for (auto &child_entry : child_entries) {
-		child_entry->SetAuxiliary(input.GetAuxiliary());
-	}
-
-	vector<RE2::Arg> argv(groupSize);
-	vector<RE2::Arg *> groups(groupSize);
-	vector<duckdb_re2::StringPiece> ws(groupSize);
-	for (size_t i = 0; i < groupSize; ++i) {
-		groups[i] = &argv[i];
-		argv[i] = &ws[i];
-	}
-
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		if (ConstantVector::IsNull(input)) {
-			ConstantVector::SetNull(result, true);
-		} else {
-			ConstantVector::SetNull(result, false);
-			auto idata = ConstantVector::GetData<string_t>(input);
-			auto str = CreateStringPiece(idata[0]);
-			auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(),
-			                                            UnsafeNumericCast<int>(groups.size()));
-			for (size_t col = 0; col < child_entries.size(); ++col) {
-				auto &child_entry = child_entries[col];
-				ConstantVector::SetNull(*child_entry, false);
-				auto &extracted = ws[col];
-				auto cdata = ConstantVector::GetData<string_t>(*child_entry);
-				cdata[0] = string_t(extracted.data(), UnsafeNumericCast<uint32_t>(match ? extracted.size() : 0));
-			}
-		}
-	} else {
-		UnifiedVectorFormat iunified;
-		input.ToUnifiedFormat(count, iunified);
-
-		const auto &ivalidity = iunified.validity;
-		auto idata = UnifiedVectorFormat::GetData<string_t>(iunified);
-
-		// Start with a valid flat vector
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		// Start with valid children
-		for (size_t col = 0; col < child_entries.size(); ++col) {
-			auto &child_entry = child_entries[col];
-			child_entry->SetVectorType(VectorType::FLAT_VECTOR);
-		}
-
-		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = iunified.sel->get_index(i);
-			if (ivalidity.RowIsValid(idx)) {
-				auto str = CreateStringPiece(idata[idx]);
-				auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(),
-				                                            UnsafeNumericCast<int>(groups.size()));
-				for (size_t col = 0; col < child_entries.size(); ++col) {
-					auto &child_entry = child_entries[col];
-					auto cdata = FlatVector::GetData<string_t>(*child_entry);
-					auto &extracted = ws[col];
-					cdata[i] = string_t(extracted.data(), UnsafeNumericCast<uint32_t>(match ? extracted.size() : 0));
-				}
-			} else {
-				FlatVector::SetNull(result, i, true);
-			}
-		}
-	}
-}
-
-static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() >= 2);
-
-	duckdb_re2::RE2::Options options;
-
-	string constant_string;
-	bool constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
-
-	if (arguments.size() >= 4) {
-		ParseRegexOptions(context, *arguments[3], options);
-	}
-
-	string group_string = "\\0";
-	if (arguments.size() >= 3) {
-		if (arguments[2]->HasParameter()) {
-			throw ParameterNotResolvedException();
-		}
-		if (!arguments[2]->IsFoldable()) {
-			throw InvalidInputException("Group specification field must be a constant!");
-		}
-		Value group = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
-		if (group.IsNull()) {
-			group_string = "";
-		} else if (group.type().id() == LogicalTypeId::LIST) {
-			if (!constant_pattern) {
-				throw BinderException("%s with LIST requires a constant pattern", bound_function.name);
-			}
-			auto &list_children = ListValue::GetChildren(group);
-			if (list_children.empty()) {
-				throw BinderException("%s requires non-empty lists of capture names", bound_function.name);
-			}
-			case_insensitive_set_t name_collision_set;
-			child_list_t<LogicalType> struct_children;
-			for (const auto &child : list_children) {
-				if (child.IsNull()) {
-					throw BinderException("NULL group name in %s", bound_function.name);
-				}
-				const auto group_name = child.ToString();
-				if (name_collision_set.find(group_name) != name_collision_set.end()) {
-					throw BinderException("Duplicate group name \"%s\" in %s", group_name, bound_function.name);
-				}
-				name_collision_set.insert(group_name);
-				struct_children.emplace_back(make_pair(group_name, LogicalType::VARCHAR));
-			}
-			bound_function.return_type = LogicalType::STRUCT(struct_children);
-
-			duckdb_re2::StringPiece constant_piece(constant_string.c_str(), constant_string.size());
-			RE2 constant_pattern(constant_piece, options);
-			if (size_t(constant_pattern.NumberOfCapturingGroups()) < list_children.size()) {
-				throw BinderException("Not enough group names in %s", bound_function.name);
-			}
-		} else {
-			auto group_idx = group.GetValue<int32_t>();
-			if (group_idx < 0 || group_idx > 9) {
-				throw InvalidInputException("Group index must be between 0 and 9!");
-			}
-			group_string = "\\" + to_string(group_idx);
-		}
-	}
-
-	return make_uniq<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern,
-	                                        std::move(group_string));
-}
-
-ScalarFunctionSet RegexpFun::GetFunctions() {
-	ScalarFunctionSet regexp_full_match("regexp_full_match");
-	regexp_full_match.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                   RegexpMatchesFunction<RegexFullMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	                   LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_full_match.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                   RegexpMatchesFunction<RegexFullMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	                   LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	return (regexp_full_match);
-}
-
-ScalarFunctionSet RegexpMatchesFun::GetFunctions() {
-	ScalarFunctionSet regexp_partial_match("regexp_matches");
-	regexp_partial_match.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, RegexpMatchesFunction<RegexPartialMatch>,
-	    RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID, FunctionStability::CONSISTENT,
-	    FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_partial_match.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	    RegexpMatchesFunction<RegexPartialMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	for (auto &func : regexp_partial_match.functions) {
-		BaseScalarFunction::SetReturnsError(func);
-	}
-	return (regexp_partial_match);
-}
-
-ScalarFunctionSet RegexpReplaceFun::GetFunctions() {
-	ScalarFunctionSet regexp_replace("regexp_replace");
-	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                          LogicalType::VARCHAR, RegexReplaceFunction, RegexReplaceBind, nullptr,
-	                                          nullptr, RegexInitLocalState));
-	regexp_replace.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	    RegexReplaceFunction, RegexReplaceBind, nullptr, nullptr, RegexInitLocalState));
-	return (regexp_replace);
-}
-
-ScalarFunctionSet RegexpExtractFun::GetFunctions() {
-	ScalarFunctionSet regexp_extract("regexp_extract");
-	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                          RegexExtractFunction, RegexExtractBind, nullptr, nullptr,
-	                                          RegexInitLocalState, LogicalType::INVALID, FunctionStability::CONSISTENT,
-	                                          FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER},
-	                                          LogicalType::VARCHAR, RegexExtractFunction, RegexExtractBind, nullptr,
-	                                          nullptr, RegexInitLocalState, LogicalType::INVALID,
-	                                          FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_extract.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...])
-	regexp_extract.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR)}, LogicalType::VARCHAR,
-	    RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...], <options>)
-	regexp_extract.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR), LogicalType::VARCHAR},
-	    LogicalType::VARCHAR, RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState,
-	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	return (regexp_extract);
-}
-
-ScalarFunctionSet RegexpExtractAllFun::GetFunctions() {
-	ScalarFunctionSet regexp_extract_all("regexp_extract_all");
-	regexp_extract_all.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::LIST(LogicalType::VARCHAR),
-	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
-	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_extract_all.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::LIST(LogicalType::VARCHAR),
-	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
-	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_extract_all.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR},
-	                   LogicalType::LIST(LogicalType::VARCHAR), RegexpExtractAll::Execute, RegexpExtractAll::Bind,
-	                   nullptr, nullptr, RegexpExtractAll::InitLocalState, LogicalType::INVALID,
-	                   FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-	return (regexp_extract_all);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp b/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp
deleted file mode 100644
index 144dcff03..000000000
--- a/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-#include "duckdb/function/scalar/regexp.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "re2/re2.h"
-
-namespace duckdb {
-
-using regexp_util::CreateStringPiece;
-using regexp_util::Extract;
-using regexp_util::ParseRegexOptions;
-using regexp_util::TryParseConstantPattern;
-
-unique_ptr<FunctionLocalState>
-RegexpExtractAll::InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr, FunctionData *bind_data) {
-	auto &info = bind_data->Cast<RegexpBaseBindData>();
-	if (info.constant_pattern) {
-		return make_uniq<RegexLocalState>(info, true);
-	}
-	return nullptr;
-}
-
-// Forwards startpos automatically
-bool ExtractAll(duckdb_re2::StringPiece &input, duckdb_re2::RE2 &pattern, idx_t *startpos,
-                duckdb_re2::StringPiece *groups, int ngroups) {
-
-	D_ASSERT(pattern.ok());
-	D_ASSERT(pattern.NumberOfCapturingGroups() == ngroups);
-
-	if (!pattern.Match(input, *startpos, input.size(), pattern.UNANCHORED, groups, ngroups + 1)) {
-		return false;
-	}
-	idx_t consumed = static_cast<size_t>(groups[0].end() - (input.begin() + *startpos));
-	if (!consumed) {
-		// Empty match found, have to manually forward the input
-		// to avoid an infinite loop
-		// FIXME: support unicode characters
-		consumed++;
-		while (*startpos + consumed < input.length() && !IsCharacter(input[*startpos + consumed])) {
-			consumed++;
-		}
-	}
-	*startpos += consumed;
-	return true;
-}
-
-void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_t group, RegexStringPieceArgs &args,
-                        Vector &result, idx_t row) {
-	auto input = CreateStringPiece(string);
-
-	auto &child_vector = ListVector::GetEntry(result);
-	auto list_content = FlatVector::GetData<string_t>(child_vector);
-	auto &child_validity = FlatVector::Validity(child_vector);
-
-	auto current_list_size = ListVector::GetListSize(result);
-	auto current_list_capacity = ListVector::GetListCapacity(result);
-
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	auto &list_entry = result_data[row];
-	list_entry.offset = current_list_size;
-
-	if (group < 0) {
-		list_entry.length = 0;
-		return;
-	}
-	// If the requested group index is out of bounds
-	// we want to throw only if there is a match
-	bool throw_on_group_found = (idx_t)group > args.size;
-
-	idx_t startpos = 0;
-	for (idx_t iteration = 0;
-	     ExtractAll(input, pattern, &startpos, args.group_buffer, UnsafeNumericCast<int>(args.size)); iteration++) {
-		if (!iteration && throw_on_group_found) {
-			throw InvalidInputException("Pattern has %d groups. Cannot access group %d", args.size, group);
-		}
-
-		// Make sure we have enough room for the new entries
-		if (current_list_size + 1 >= current_list_capacity) {
-			ListVector::Reserve(result, current_list_capacity * 2);
-			current_list_capacity = ListVector::GetListCapacity(result);
-			list_content = FlatVector::GetData<string_t>(child_vector);
-		}
-
-		// Write the captured groups into the list-child vector
-		auto &match_group = args.group_buffer[group];
-
-		idx_t child_idx = current_list_size;
-		if (match_group.empty()) {
-			// This group was not matched
-			list_content[child_idx] = string_t(string.GetData(), 0);
-			if (match_group.begin() == nullptr) {
-				// This group is optional
-				child_validity.SetInvalid(child_idx);
-			}
-		} else {
-			// Every group is a substring of the original, we can find out the offset using the pointer
-			// the 'match_group' address is guaranteed to be bigger than that of the source
-			D_ASSERT(const_char_ptr_cast(match_group.begin()) >= string.GetData());
-			auto offset = UnsafeNumericCast<idx_t>(match_group.begin() - string.GetData());
-			list_content[child_idx] =
-			    string_t(string.GetData() + offset, UnsafeNumericCast<uint32_t>(match_group.size()));
-		}
-		current_list_size++;
-		if (startpos > input.size()) {
-			// Empty match found at the end of the string
-			break;
-		}
-	}
-	list_entry.length = current_list_size - list_entry.offset;
-	ListVector::SetListSize(result, current_list_size);
-}
-
-int32_t GetGroupIndex(DataChunk &args, idx_t row, int32_t &result) {
-	if (args.ColumnCount() < 3) {
-		result = 0;
-		return true;
-	}
-	UnifiedVectorFormat format;
-	args.data[2].ToUnifiedFormat(args.size(), format);
-	idx_t index = format.sel->get_index(row);
-	if (!format.validity.RowIsValid(index)) {
-		return false;
-	}
-	result = UnifiedVectorFormat::GetData<int32_t>(format)[index];
-	return true;
-}
-
-duckdb_re2::RE2 &GetPattern(const RegexpBaseBindData &info, ExpressionState &state,
-                            unique_ptr<duckdb_re2::RE2> &pattern_p) {
-	if (info.constant_pattern) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		return lstate.constant_pattern;
-	}
-	D_ASSERT(pattern_p);
-	return *pattern_p;
-}
-
-RegexStringPieceArgs &GetGroupsBuffer(const RegexpBaseBindData &info, ExpressionState &state,
-                                      unique_ptr<RegexStringPieceArgs> &groups_p) {
-	if (info.constant_pattern) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		return lstate.group_buffer;
-	}
-	D_ASSERT(groups_p);
-	return *groups_p;
-}
-
-void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	const auto &info = func_expr.bind_info->Cast<RegexpBaseBindData>();
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	auto &output_child = ListVector::GetEntry(result);
-
-	UnifiedVectorFormat strings_data;
-	strings.ToUnifiedFormat(args.size(), strings_data);
-
-	UnifiedVectorFormat pattern_data;
-	patterns.ToUnifiedFormat(args.size(), pattern_data);
-
-	ListVector::Reserve(result, STANDARD_VECTOR_SIZE);
-	// Reference the 'strings' StringBuffer, because we won't need to allocate new data
-	// for the result, all returned strings are substrings of the originals
-	output_child.SetAuxiliary(strings.GetAuxiliary());
-
-	// Avoid doing extra work if all the inputs are constant
-	idx_t tuple_count = args.AllConstant() ? 1 : args.size();
-
-	unique_ptr<RegexStringPieceArgs> non_const_args;
-	unique_ptr<duckdb_re2::RE2> stored_re;
-	if (!info.constant_pattern) {
-		non_const_args = make_uniq<RegexStringPieceArgs>();
-	} else {
-		// Verify that the constant pattern is valid
-		auto &re = GetPattern(info, state, stored_re);
-		auto group_count_p = re.NumberOfCapturingGroups();
-		if (group_count_p == -1) {
-			throw InvalidInputException("Pattern failed to parse, error: '%s'", re.error());
-		}
-	}
-
-	for (idx_t row = 0; row < tuple_count; row++) {
-		bool pattern_valid = true;
-		if (!info.constant_pattern) {
-			// Check if the pattern is NULL or not,
-			// and compile the pattern if it's not constant
-			auto pattern_idx = pattern_data.sel->get_index(row);
-			if (!pattern_data.validity.RowIsValid(pattern_idx)) {
-				pattern_valid = false;
-			} else {
-				auto &pattern_p = UnifiedVectorFormat::GetData<string_t>(pattern_data)[pattern_idx];
-				auto pattern_strpiece = CreateStringPiece(pattern_p);
-				stored_re = make_uniq<duckdb_re2::RE2>(pattern_strpiece, info.options);
-
-				// Increase the size of the args buffer if needed
-				auto group_count_p = stored_re->NumberOfCapturingGroups();
-				if (group_count_p == -1) {
-					throw InvalidInputException("Pattern failed to parse, error: '%s'", stored_re->error());
-				}
-				non_const_args->SetSize(UnsafeNumericCast<idx_t>(group_count_p));
-			}
-		}
-
-		auto string_idx = strings_data.sel->get_index(row);
-		int32_t group_index;
-		if (!pattern_valid || !strings_data.validity.RowIsValid(string_idx) || !GetGroupIndex(args, row, group_index)) {
-			// If something is NULL, the result is NULL
-			// FIXME: do we even need 'SPECIAL_HANDLING'?
-			auto result_data = FlatVector::GetData<list_entry_t>(result);
-			auto &result_validity = FlatVector::Validity(result);
-			result_data[row].length = 0;
-			result_data[row].offset = ListVector::GetListSize(result);
-			result_validity.SetInvalid(row);
-			continue;
-		}
-
-		auto &re = GetPattern(info, state, stored_re);
-		auto &groups = GetGroupsBuffer(info, state, non_const_args);
-		auto &string = UnifiedVectorFormat::GetData<string_t>(strings_data)[string_idx];
-		ExtractSingleTuple(string, re, group_index, groups, result, row);
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-unique_ptr<FunctionData> RegexpExtractAll::Bind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() >= 2);
-
-	duckdb_re2::RE2::Options options;
-
-	string constant_string;
-	bool constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
-
-	if (arguments.size() >= 4) {
-		ParseRegexOptions(context, *arguments[3], options);
-	}
-	return make_uniq<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern, "");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/regexp/regexp_util.cpp b/src/duckdb/src/function/scalar/string/regexp/regexp_util.cpp
deleted file mode 100644
index 4e485195c..000000000
--- a/src/duckdb/src/function/scalar/string/regexp/regexp_util.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "duckdb/function/scalar/regexp.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-namespace regexp_util {
-
-bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string) {
-	if (!expr.IsFoldable()) {
-		return false;
-	}
-	Value pattern_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-		constant_string = StringValue::Get(pattern_str);
-		return true;
-	}
-	return false;
-}
-
-void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace) {
-	for (idx_t i = 0; i < options.size(); i++) {
-		switch (options[i]) {
-		case 'c':
-			// case-sensitive matching
-			result.set_case_sensitive(true);
-			break;
-		case 'i':
-			// case-insensitive matching
-			result.set_case_sensitive(false);
-			break;
-		case 'l':
-			// literal matching
-			result.set_literal(true);
-			break;
-		case 'm':
-		case 'n':
-		case 'p':
-			// newline-sensitive matching
-			result.set_dot_nl(false);
-			break;
-		case 's':
-			// non-newline-sensitive matching
-			result.set_dot_nl(true);
-			break;
-		case 'g':
-			// global replace, only available for regexp_replace
-			if (global_replace) {
-				*global_replace = true;
-			} else {
-				throw InvalidInputException("Option 'g' (global replace) is only valid for regexp_replace");
-			}
-			break;
-		case ' ':
-		case '\t':
-		case '\n':
-			// ignore whitespace
-			break;
-		default:
-			throw InvalidInputException("Unrecognized Regex option %c", options[i]);
-		}
-	}
-}
-
-void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace) {
-	if (expr.HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!expr.IsFoldable()) {
-		throw InvalidInputException("Regex options field must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (options_str.IsNull()) {
-		throw InvalidInputException("Regex options field must not be NULL");
-	}
-	if (options_str.type().id() != LogicalTypeId::VARCHAR) {
-		throw InvalidInputException("Regex options field must be a string");
-	}
-	ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
-}
-
-} // namespace regexp_util
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/regexp_escape.cpp b/src/duckdb/src/function/scalar/string/regexp_escape.cpp
deleted file mode 100644
index 3d72fe681..000000000
--- a/src/duckdb/src/function/scalar/string/regexp_escape.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "re2/re2.h"
-
-namespace duckdb {
-
-struct EscapeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE &input, Vector &result) {
-		auto escaped_pattern = RE2::QuoteMeta(input.GetString());
-		return StringVector::AddString(result, escaped_pattern);
-	}
-};
-
-static void RegexpEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, EscapeOperator>(args.data[0], result, args.size());
-}
-
-ScalarFunction RegexpEscapeFun::GetFunction() {
-	return ScalarFunction("regexp_escape", {LogicalType::VARCHAR}, LogicalType::VARCHAR, RegexpEscapeFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/sha1.cpp b/src/duckdb/src/function/scalar/string/sha1.cpp
deleted file mode 100644
index c59dcf252..000000000
--- a/src/duckdb/src/function/scalar/string/sha1.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "mbedtls_wrapper.hpp"
-
-namespace duckdb {
-
-struct SHA1Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto hash = StringVector::EmptyString(result, duckdb_mbedtls::MbedTlsWrapper::SHA1_HASH_LENGTH_TEXT);
-
-		duckdb_mbedtls::MbedTlsWrapper::SHA1State state;
-		state.AddString(input.GetString());
-		state.FinishHex(hash.GetDataWriteable());
-
-		hash.Finalize();
-		return hash;
-	}
-};
-
-static void SHA1Function(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::ExecuteString<string_t, string_t, SHA1Operator>(input, result, args.size());
-}
-
-ScalarFunctionSet SHA1Fun::GetFunctions() {
-	ScalarFunctionSet set("sha1");
-	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA1Function));
-	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, SHA1Function));
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/sha256.cpp b/src/duckdb/src/function/scalar/string/sha256.cpp
deleted file mode 100644
index a48ccf93f..000000000
--- a/src/duckdb/src/function/scalar/string/sha256.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "mbedtls_wrapper.hpp"
-
-namespace duckdb {
-
-struct SHA256Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto hash = StringVector::EmptyString(result, duckdb_mbedtls::MbedTlsWrapper::SHA256_HASH_LENGTH_TEXT);
-
-		duckdb_mbedtls::MbedTlsWrapper::SHA256State state;
-		state.AddString(input.GetString());
-		state.FinishHex(hash.GetDataWriteable());
-
-		hash.Finalize();
-		return hash;
-	}
-};
-
-static void SHA256Function(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::ExecuteString<string_t, string_t, SHA256Operator>(input, result, args.size());
-}
-
-ScalarFunctionSet SHA256Fun::GetFunctions() {
-	ScalarFunctionSet set("sha256");
-	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA256Function));
-	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, SHA256Function));
-	return set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/string_split.cpp b/src/duckdb/src/function/scalar/string/string_split.cpp
deleted file mode 100644
index 9673eca96..000000000
--- a/src/duckdb/src/function/scalar/string/string_split.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/function/scalar/regexp.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct StringSplitInput {
-	StringSplitInput(Vector &result_list, Vector &result_child, idx_t offset)
-	    : result_list(result_list), result_child(result_child), offset(offset) {
-	}
-
-	Vector &result_list;
-	Vector &result_child;
-	idx_t offset;
-
-	void AddSplit(const char *split_data, idx_t split_size, idx_t list_idx) {
-		auto list_entry = offset + list_idx;
-		if (list_entry >= ListVector::GetListCapacity(result_list)) {
-			ListVector::SetListSize(result_list, offset + list_idx);
-			ListVector::Reserve(result_list, ListVector::GetListCapacity(result_list) * 2);
-		}
-		FlatVector::GetData<string_t>(result_child)[list_entry] =
-		    string_t(split_data, UnsafeNumericCast<uint32_t>(split_size));
-	}
-};
-
-struct RegularStringSplit {
-	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
-	                  idx_t &match_size, void *data) {
-		match_size = delim_size;
-		if (delim_size == 0) {
-			return 0;
-		}
-		return FindStrInStr(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(delim_data), delim_size);
-	}
-};
-
-struct ConstantRegexpStringSplit {
-	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
-	                  idx_t &match_size, void *data) {
-		D_ASSERT(data);
-		auto regex = reinterpret_cast<duckdb_re2::RE2 *>(data);
-		duckdb_re2::StringPiece match;
-		if (!regex->Match(duckdb_re2::StringPiece(input_data, input_size), 0, input_size, RE2::UNANCHORED, &match, 1)) {
-			return DConstants::INVALID_INDEX;
-		}
-		match_size = match.size();
-		return UnsafeNumericCast<idx_t>(match.data() - input_data);
-	}
-};
-
-struct RegexpStringSplit {
-	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
-	                  idx_t &match_size, void *data) {
-		duckdb_re2::RE2 regex(duckdb_re2::StringPiece(delim_data, delim_size));
-		if (!regex.ok()) {
-			throw InvalidInputException(regex.error());
-		}
-		return ConstantRegexpStringSplit::Find(input_data, input_size, delim_data, delim_size, match_size, &regex);
-	}
-};
-
-struct StringSplitter {
-	template <class OP>
-	static idx_t Split(string_t input, string_t delim, StringSplitInput &state, void *data) {
-		auto input_data = input.GetData();
-		auto input_size = input.GetSize();
-		auto delim_data = delim.GetData();
-		auto delim_size = delim.GetSize();
-		idx_t list_idx = 0;
-		while (input_size > 0) {
-			idx_t match_size = 0;
-			auto pos = OP::Find(input_data, input_size, delim_data, delim_size, match_size, data);
-			if (pos > input_size) {
-				break;
-			}
-			if (match_size == 0 && pos == 0) {
-				// special case: 0 length match and pos is 0
-				// move to the next character
-				for (pos++; pos < input_size; pos++) {
-					if (IsCharacter(input_data[pos])) {
-						break;
-					}
-				}
-				if (pos == input_size) {
-					break;
-				}
-			}
-			D_ASSERT(input_size >= pos + match_size);
-			state.AddSplit(input_data, pos, list_idx);
-
-			list_idx++;
-			input_data += (pos + match_size);
-			input_size -= (pos + match_size);
-		}
-		state.AddSplit(input_data, input_size, list_idx);
-		list_idx++;
-		return list_idx;
-	}
-};
-
-template <class OP>
-static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, void *data = nullptr) {
-	UnifiedVectorFormat input_data;
-	args.data[0].ToUnifiedFormat(args.size(), input_data);
-	auto inputs = UnifiedVectorFormat::GetData<string_t>(input_data);
-
-	UnifiedVectorFormat delim_data;
-	args.data[1].ToUnifiedFormat(args.size(), delim_data);
-	auto delims = UnifiedVectorFormat::GetData<string_t>(delim_data);
-
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	ListVector::SetListSize(result, 0);
-
-	auto list_struct_data = FlatVector::GetData<list_entry_t>(result);
-
-	// count all the splits and set up the list entries
-	auto &child_entry = ListVector::GetEntry(result);
-	auto &result_mask = FlatVector::Validity(result);
-	idx_t total_splits = 0;
-	for (idx_t i = 0; i < args.size(); i++) {
-		auto input_idx = input_data.sel->get_index(i);
-		auto delim_idx = delim_data.sel->get_index(i);
-		if (!input_data.validity.RowIsValid(input_idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		StringSplitInput split_input(result, child_entry, total_splits);
-		if (!delim_data.validity.RowIsValid(delim_idx)) {
-			// delim is NULL: copy the complete entry
-			split_input.AddSplit(inputs[input_idx].GetData(), inputs[input_idx].GetSize(), 0);
-			list_struct_data[i].length = 1;
-			list_struct_data[i].offset = total_splits;
-			total_splits++;
-			continue;
-		}
-		auto list_length = StringSplitter::Split<OP>(inputs[input_idx], delims[delim_idx], split_input, data);
-		list_struct_data[i].length = list_length;
-		list_struct_data[i].offset = total_splits;
-		total_splits += list_length;
-	}
-	ListVector::SetListSize(result, total_splits);
-	D_ASSERT(ListVector::GetListSize(result) == total_splits);
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	StringVector::AddHeapReference(child_entry, args.data[0]);
-}
-
-static void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	StringSplitExecutor<RegularStringSplit>(args, state, result, nullptr);
-}
-
-static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
-	if (info.constant_pattern) {
-		// fast path: pre-compiled regex
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		StringSplitExecutor<ConstantRegexpStringSplit>(args, state, result, &lstate.constant_pattern);
-	} else {
-		// slow path: have to re-compile regex for every row
-		StringSplitExecutor<RegexpStringSplit>(args, state, result);
-	}
-}
-
-ScalarFunction StringSplitFun::GetFunction() {
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-
-	ScalarFunction string_split({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitFunction);
-	string_split.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return string_split;
-}
-
-ScalarFunctionSet StringSplitRegexFun::GetFunctions() {
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	ScalarFunctionSet regexp_split;
-	ScalarFunction regex_fun({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitRegexFunction,
-	                         RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	                         FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING);
-	regexp_split.AddFunction(regex_fun);
-	// regexp options
-	regex_fun.arguments.emplace_back(LogicalType::VARCHAR);
-	regexp_split.AddFunction(regex_fun);
-	return regexp_split;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/strip_accents.cpp b/src/duckdb/src/function/scalar/string/strip_accents.cpp
deleted file mode 100644
index 2ab7ca497..000000000
--- a/src/duckdb/src/function/scalar/string/strip_accents.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-
-#include "utf8proc.hpp"
-
-namespace duckdb {
-
-bool IsAscii(const char *input, idx_t n) {
-	for (idx_t i = 0; i < n; i++) {
-		if (input[i] & 0x80) {
-			// non-ascii character
-			return false;
-		}
-	}
-	return true;
-}
-
-struct StripAccentsOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		if (IsAscii(input.GetData(), input.GetSize())) {
-			return input;
-		}
-
-		// non-ascii, perform collation
-		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(),
-		                                        UnsafeNumericCast<utf8proc_ssize_t>(input.GetSize()));
-		auto result_str = StringVector::AddString(result, const_char_ptr_cast(stripped));
-		free(stripped);
-		return result_str;
-	}
-};
-
-static void StripAccentsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-
-	UnaryExecutor::ExecuteString<string_t, string_t, StripAccentsOperator>(args.data[0], result, args.size());
-	StringVector::AddHeapReference(result, args.data[0]);
-}
-
-ScalarFunction StripAccentsFun::GetFunction() {
-	return ScalarFunction("strip_accents", {LogicalType::VARCHAR}, LogicalType::VARCHAR, StripAccentsFunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/substring.cpp b/src/duckdb/src/function/scalar/string/substring.cpp
deleted file mode 100644
index 58c93624a..000000000
--- a/src/duckdb/src/function/scalar/string/substring.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "utf8proc.hpp"
-#include "duckdb/common/types/blob.hpp"
-
-namespace duckdb {
-
-static const int64_t SUPPORTED_UPPER_BOUND = NumericLimits<uint32_t>::Maximum();
-static const int64_t SUPPORTED_LOWER_BOUND = -SUPPORTED_UPPER_BOUND - 1;
-
-static inline void AssertInSupportedRange(idx_t input_size, int64_t offset, int64_t length) {
-
-	if (input_size > (uint64_t)SUPPORTED_UPPER_BOUND) {
-		throw OutOfRangeException("Substring input size is too large (> %d)", SUPPORTED_UPPER_BOUND);
-	}
-	if (offset < SUPPORTED_LOWER_BOUND) {
-		throw OutOfRangeException("Substring offset outside of supported range (< %d)", SUPPORTED_LOWER_BOUND);
-	}
-	if (offset > SUPPORTED_UPPER_BOUND) {
-		throw OutOfRangeException("Substring offset outside of supported range (> %d)", SUPPORTED_UPPER_BOUND);
-	}
-	if (length < SUPPORTED_LOWER_BOUND) {
-		throw OutOfRangeException("Substring length outside of supported range (< %d)", SUPPORTED_LOWER_BOUND);
-	}
-	if (length > SUPPORTED_UPPER_BOUND) {
-		throw OutOfRangeException("Substring length outside of supported range (> %d)", SUPPORTED_UPPER_BOUND);
-	}
-}
-
-string_t SubstringEmptyString(Vector &result) {
-	auto result_string = StringVector::EmptyString(result, 0);
-	result_string.Finalize();
-	return result_string;
-}
-
-string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
-	auto result_string = StringVector::EmptyString(result, UnsafeNumericCast<idx_t>(length));
-	auto result_data = result_string.GetDataWriteable();
-	memcpy(result_data, input_data + offset, UnsafeNumericCast<size_t>(length));
-	result_string.Finalize();
-	return result_string;
-}
-
-// compute start and end characters from the given input size and offset/length
-bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64_t &start, int64_t &end) {
-	if (length == 0) {
-		return false;
-	}
-	if (offset > 0) {
-		// positive offset: scan from start
-		start = MinValue<int64_t>(input_size, offset - 1);
-	} else if (offset < 0) {
-		// negative offset: scan from end (i.e. start = end + offset)
-		start = MaxValue<int64_t>(input_size + offset, 0);
-	} else {
-		// offset = 0: special case, we start 1 character BEHIND the first character
-		start = 0;
-		length--;
-		if (length <= 0) {
-			return false;
-		}
-	}
-	if (length > 0) {
-		// positive length: go forward (i.e. end = start + offset)
-		end = MinValue<int64_t>(input_size, start + length);
-	} else {
-		// negative length: go backwards (i.e. end = start, start = start + length)
-		end = start;
-		start = MaxValue<int64_t>(0, start + length);
-	}
-	if (start == end) {
-		return false;
-	}
-	D_ASSERT(start < end);
-	return true;
-}
-
-string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetData();
-	auto input_size = input.GetSize();
-
-	AssertInSupportedRange(input_size, offset, length);
-
-	int64_t start, end;
-	if (!SubstringStartEnd(UnsafeNumericCast<int64_t>(input_size), offset, length, start, end)) {
-		return SubstringEmptyString(result);
-	}
-	return SubstringSlice(result, input_data, start, UnsafeNumericCast<int64_t>(end - start));
-}
-
-string_t SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetData();
-	auto input_size = input.GetSize();
-
-	AssertInSupportedRange(input_size, offset, length);
-
-	if (length == 0) {
-		return SubstringEmptyString(result);
-	}
-	// first figure out which direction we need to scan
-	idx_t start_pos;
-	idx_t end_pos;
-	if (offset < 0) {
-		start_pos = 0;
-		end_pos = DConstants::INVALID_INDEX;
-
-		// negative offset: scan backwards
-		int64_t start, end;
-
-		// we express start and end as unicode codepoints from the back
-		offset--;
-		if (length < 0) {
-			// negative length
-			start = -offset - length;
-			end = -offset;
-		} else {
-			// positive length
-			start = -offset;
-			end = -offset - length;
-		}
-		if (end <= 0) {
-			end_pos = input_size;
-		}
-		int64_t current_character = 0;
-		for (idx_t i = input_size; i > 0; i--) {
-			if (IsCharacter(input_data[i - 1])) {
-				current_character++;
-				if (current_character == start) {
-					start_pos = i;
-					break;
-				} else if (current_character == end) {
-					end_pos = i;
-				}
-			}
-		}
-		while (!IsCharacter(input_data[start_pos])) {
-			start_pos++;
-		}
-		while (end_pos < input_size && !IsCharacter(input_data[end_pos])) {
-			end_pos++;
-		}
-
-		if (end_pos == DConstants::INVALID_INDEX) {
-			return SubstringEmptyString(result);
-		}
-	} else {
-		start_pos = DConstants::INVALID_INDEX;
-		end_pos = input_size;
-
-		// positive offset: scan forwards
-		int64_t start, end;
-
-		// we express start and end as unicode codepoints from the front
-		offset--;
-		if (length < 0) {
-			// negative length
-			start = MaxValue<int64_t>(0, offset + length);
-			end = offset;
-		} else {
-			// positive length
-			start = MaxValue<int64_t>(0, offset);
-			end = offset + length;
-		}
-
-		int64_t current_character = 0;
-		for (idx_t i = 0; i < input_size; i++) {
-			if (IsCharacter(input_data[i])) {
-				if (current_character == start) {
-					start_pos = i;
-				} else if (current_character == end) {
-					end_pos = i;
-					break;
-				}
-				current_character++;
-			}
-		}
-		if (start_pos == DConstants::INVALID_INDEX || end == 0 || end <= start) {
-			return SubstringEmptyString(result);
-		}
-	}
-	D_ASSERT(end_pos >= start_pos);
-	// after we have found these, we can slice the substring
-	return SubstringSlice(result, input_data, UnsafeNumericCast<int64_t>(start_pos),
-	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
-}
-
-string_t SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetData();
-	auto input_size = input.GetSize();
-
-	AssertInSupportedRange(input_size, offset, length);
-
-	// we don't know yet if the substring is ascii, but we assume it is (for now)
-	// first get the start and end as if this was an ascii string
-	int64_t start, end;
-	if (!SubstringStartEnd(UnsafeNumericCast<int64_t>(input_size), offset, length, start, end)) {
-		return SubstringEmptyString(result);
-	}
-
-	// now check if all the characters between 0 and end are ascii characters
-	// note that we scan one further to check for a potential combining diacritics (e.g. i + diacritic is ï)
-	bool is_ascii = true;
-	idx_t ascii_end = MinValue<idx_t>(UnsafeNumericCast<idx_t>(end + 1), input_size);
-	for (idx_t i = 0; i < ascii_end; i++) {
-		if (input_data[i] & 0x80) {
-			// found a non-ascii character: eek
-			is_ascii = false;
-			break;
-		}
-	}
-	if (is_ascii) {
-		// all characters are ascii, we can just slice the substring
-		return SubstringSlice(result, input_data, start, end - start);
-	}
-	// if the characters are not ascii, we need to scan grapheme clusters
-	// first figure out which direction we need to scan
-	// offset = 0 case is taken care of in SubstringStartEnd
-	if (offset < 0) {
-		// negative offset, this case is more difficult
-		// we first need to count the number of characters in the string
-		idx_t num_characters = Utf8Proc::GraphemeCount(input_data, input_size);
-		// now call substring start and end again, but with the number of unicode characters this time
-		SubstringStartEnd(UnsafeNumericCast<int64_t>(num_characters), offset, length, start, end);
-	}
-
-	// now scan the graphemes of the string to find the positions of the start and end characters
-	int64_t current_character = 0;
-	idx_t start_pos = DConstants::INVALID_INDEX, end_pos = input_size;
-	for (auto cluster : Utf8Proc::GraphemeClusters(input_data, input_size)) {
-		if (current_character == start) {
-			start_pos = cluster.start;
-		} else if (current_character == end) {
-			end_pos = cluster.start;
-			break;
-		}
-		current_character++;
-	}
-	if (start_pos == DConstants::INVALID_INDEX) {
-		return SubstringEmptyString(result);
-	}
-	// after we have found these, we can slice the substring
-	return SubstringSlice(result, input_data, UnsafeNumericCast<int64_t>(start_pos),
-	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
-}
-
-struct SubstringUnicodeOp {
-	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
-		return SubstringUnicode(result, input, offset, length);
-	}
-};
-
-struct SubstringGraphemeOp {
-	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
-		return SubstringGrapheme(result, input, offset, length);
-	}
-};
-
-template <class OP>
-static void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input_vector = args.data[0];
-	auto &offset_vector = args.data[1];
-	if (args.ColumnCount() == 3) {
-		auto &length_vector = args.data[2];
-
-		TernaryExecutor::Execute<string_t, int64_t, int64_t, string_t>(
-		    input_vector, offset_vector, length_vector, result, args.size(),
-		    [&](string_t input_string, int64_t offset, int64_t length) {
-			    return OP::Substring(result, input_string, offset, length);
-		    });
-	} else {
-		BinaryExecutor::Execute<string_t, int64_t, string_t>(
-		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int64_t offset) {
-			    return OP::Substring(result, input_string, offset, NumericLimits<uint32_t>::Maximum());
-		    });
-	}
-}
-
-static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input_vector = args.data[0];
-	auto &offset_vector = args.data[1];
-	if (args.ColumnCount() == 3) {
-		auto &length_vector = args.data[2];
-
-		TernaryExecutor::Execute<string_t, int64_t, int64_t, string_t>(
-		    input_vector, offset_vector, length_vector, result, args.size(),
-		    [&](string_t input_string, int64_t offset, int64_t length) {
-			    return SubstringASCII(result, input_string, offset, length);
-		    });
-	} else {
-		BinaryExecutor::Execute<string_t, int64_t, string_t>(
-		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int64_t offset) {
-			    return SubstringASCII(result, input_string, offset, NumericLimits<uint32_t>::Maximum());
-		    });
-	}
-}
-
-static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	// can only propagate stats if the children have stats
-	// we only care about the stats of the first child (i.e. the string)
-	if (!StringStats::CanContainUnicode(child_stats[0])) {
-		expr.function.function = SubstringFunctionASCII;
-	}
-	return nullptr;
-}
-
-ScalarFunctionSet SubstringFun::GetFunctions() {
-	ScalarFunctionSet substr("substring");
-	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                  LogicalType::VARCHAR, SubstringFunction<SubstringUnicodeOp>, nullptr, nullptr,
-	                                  SubstringPropagateStats));
-	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                                  SubstringFunction<SubstringUnicodeOp>, nullptr, nullptr,
-	                                  SubstringPropagateStats));
-	return (substr);
-}
-
-ScalarFunctionSet SubstringGraphemeFun::GetFunctions() {
-	ScalarFunctionSet substr_grapheme("substring_grapheme");
-	substr_grapheme.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                           LogicalType::VARCHAR, SubstringFunction<SubstringGraphemeOp>, nullptr,
-	                                           nullptr, SubstringPropagateStats));
-	substr_grapheme.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                                           SubstringFunction<SubstringGraphemeOp>, nullptr, nullptr,
-	                                           SubstringPropagateStats));
-	return (substr_grapheme);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/string/suffix.cpp b/src/duckdb/src/function/scalar/string/suffix.cpp
deleted file mode 100644
index 21175f61d..000000000
--- a/src/duckdb/src/function/scalar/string/suffix.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-static bool SuffixFunction(const string_t &str, const string_t &suffix);
-
-struct SuffixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return SuffixFunction(left, right);
-	}
-};
-
-static bool SuffixFunction(const string_t &str, const string_t &suffix) {
-	auto suffix_size = suffix.GetSize();
-	auto str_size = str.GetSize();
-	if (suffix_size > str_size) {
-		return false;
-	}
-
-	auto suffix_data = suffix.GetData();
-	auto str_data = str.GetData();
-	auto suf_idx = UnsafeNumericCast<int32_t>(suffix_size) - 1;
-	idx_t str_idx = str_size - 1;
-	for (; suf_idx >= 0; --suf_idx, --str_idx) {
-		if (suffix_data[suf_idx] != str_data[str_idx]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-ScalarFunction SuffixFun::GetFunction() {
-	return ScalarFunction("suffix",                                     // name of the function
-	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                      LogicalType::BOOLEAN,                         // return type
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, SuffixOperator>);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/struct/struct_concat.cpp b/src/duckdb/src/function/scalar/struct/struct_concat.cpp
deleted file mode 100644
index f5ed780e8..000000000
--- a/src/duckdb/src/function/scalar/struct/struct_concat.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/struct_functions.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-
-namespace duckdb {
-
-static void StructConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &result_cols = StructVector::GetEntries(result);
-	idx_t offset = 0;
-
-	if (!args.AllConstant()) {
-		// Unless all arguments are constant, we flatten the input to make sure it's homogeneous
-		args.Flatten();
-	}
-
-	for (auto &arg : args.data) {
-		const auto &child_cols = StructVector::GetEntries(arg);
-		for (auto &child_col : child_cols) {
-			result_cols[offset++]->Reference(*child_col);
-		}
-	}
-	D_ASSERT(offset == result_cols.size());
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> StructConcatBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-
-	// collect names and deconflict, construct return type
-	if (arguments.empty()) {
-		throw InvalidInputException("struct_concat: At least one argument is required");
-	}
-
-	child_list_t<LogicalType> combined_children;
-	case_insensitive_set_t name_set;
-
-	bool has_unnamed = false;
-
-	for (idx_t arg_idx = 0; arg_idx < arguments.size(); arg_idx++) {
-		const auto &arg = arguments[arg_idx];
-
-		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-
-		if (arg->return_type.id() != LogicalTypeId::STRUCT) {
-			throw InvalidInputException("struct_concat: Argument at position \"%d\" is not a STRUCT", arg_idx + 1);
-		}
-
-		const auto &child_types = StructType::GetChildTypes(arg->return_type);
-		for (const auto &child : child_types) {
-			if (!child.first.empty()) {
-				auto it = name_set.find(child.first);
-				if (it != name_set.end()) {
-					if (*it == child.first) {
-						throw InvalidInputException("struct_concat: Arguments contain duplicate STRUCT entry \"%s\"",
-						                            child.first);
-					}
-					throw InvalidInputException(
-					    "struct_concat: Arguments contain case-insensitive duplicate STRUCT entry \"%s\" and \"%s\"",
-					    child.first, *it);
-				}
-				name_set.insert(child.first);
-			} else {
-				has_unnamed = true;
-			}
-			combined_children.push_back(child);
-		}
-	}
-
-	if (has_unnamed && !name_set.empty()) {
-		throw InvalidInputException("struct_concat: Cannot mix named and unnamed STRUCTs");
-	}
-
-	bound_function.return_type = LogicalType::STRUCT(combined_children);
-	return nullptr;
-}
-
-unique_ptr<BaseStatistics> StructConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
-	const auto &expr = input.expr;
-
-	auto &arg_stats = input.child_stats;
-	auto &arg_exprs = input.expr.children;
-
-	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
-	idx_t struct_index = 0;
-
-	for (idx_t arg_idx = 0; arg_idx < arg_exprs.size(); arg_idx++) {
-		auto &arg_stat = arg_stats[arg_idx];
-		auto &arg_type = arg_exprs[arg_idx]->return_type;
-		for (idx_t child_idx = 0; child_idx < StructType::GetChildCount(arg_type); child_idx++) {
-			auto &child_stat = StructStats::GetChildStats(arg_stat, child_idx);
-			StructStats::SetChildStats(struct_stats, struct_index++, child_stat);
-		}
-	}
-	return struct_stats.ToUnique();
-}
-
-ScalarFunction StructConcatFun::GetFunction() {
-	ScalarFunction fun("struct_concat", {}, LogicalTypeId::STRUCT, StructConcatFunction, StructConcatBind, nullptr,
-	                   StructConcatStats);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/struct/struct_extract.cpp b/src/duckdb/src/function/scalar/struct/struct_extract.cpp
deleted file mode 100644
index 20cc74157..000000000
--- a/src/duckdb/src/function/scalar/struct/struct_extract.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/struct_functions.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/function/scalar/struct_utils.hpp"
-
-namespace duckdb {
-
-static void StructExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<StructExtractBindData>();
-
-	// this should be guaranteed by the binder
-	auto &vec = args.data[0];
-
-	vec.Verify(args.size());
-	auto &children = StructVector::GetEntries(vec);
-	D_ASSERT(info.index < children.size());
-	auto &struct_child = children[info.index];
-	result.Reference(*struct_child);
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-	auto &child_type = arguments[0]->return_type;
-	if (child_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	D_ASSERT(LogicalTypeId::STRUCT == child_type.id());
-	auto &struct_children = StructType::GetChildTypes(child_type);
-	if (struct_children.empty()) {
-		throw InternalException("Can't extract something from an empty struct");
-	}
-	if (StructType::IsUnnamed(child_type)) {
-		throw BinderException(
-		    "struct_extract with a string key cannot be used on an unnamed struct, use a numeric index instead");
-	}
-	bound_function.arguments[0] = child_type;
-
-	auto &key_child = arguments[1];
-	if (key_child->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-
-	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
-		throw BinderException("Key name for struct_extract needs to be a constant string");
-	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
-	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	auto &key_str = StringValue::Get(key_val);
-	if (key_val.IsNull() || key_str.empty()) {
-		throw BinderException("Key name for struct_extract needs to be neither NULL nor empty");
-	}
-	string key = StringUtil::Lower(key_str);
-
-	LogicalType return_type;
-	idx_t key_index = 0;
-	bool found_key = false;
-
-	for (size_t i = 0; i < struct_children.size(); i++) {
-		auto &child = struct_children[i];
-		if (StringUtil::Lower(child.first) == key) {
-			found_key = true;
-			key_index = i;
-			return_type = child.second;
-			break;
-		}
-	}
-
-	if (!found_key) {
-		vector<string> candidates;
-		candidates.reserve(struct_children.size());
-		for (auto &struct_child : struct_children) {
-			candidates.push_back(struct_child.first);
-		}
-		auto closest_settings = StringUtil::TopNJaroWinkler(candidates, key);
-		auto message = StringUtil::CandidatesMessage(closest_settings, "Candidate Entries");
-		throw BinderException("Could not find key \"%s\" in struct\n%s", key, message);
-	}
-
-	bound_function.return_type = std::move(return_type);
-	return GetBindData(key_index);
-}
-
-static unique_ptr<FunctionData> StructExtractBindInternal(ClientContext &context, ScalarFunction &bound_function,
-                                                          vector<unique_ptr<Expression>> &arguments,
-                                                          bool struct_extract) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-	auto &child_type = arguments[0]->return_type;
-	if (child_type.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	D_ASSERT(LogicalTypeId::STRUCT == child_type.id());
-	auto &struct_children = StructType::GetChildTypes(child_type);
-	if (struct_children.empty()) {
-		throw InternalException("Can't extract something from an empty struct");
-	}
-	if (struct_extract && !StructType::IsUnnamed(child_type)) {
-		throw BinderException(
-		    "struct_extract with an integer key can only be used on unnamed structs, use a string key instead");
-	}
-	bound_function.arguments[0] = child_type;
-
-	auto &key_child = arguments[1];
-	if (key_child->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-
-	if (!key_child->IsFoldable()) {
-		throw BinderException("Key index for struct_extract needs to be a constant value");
-	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
-	auto index = key_val.GetValue<int64_t>();
-	if (index <= 0 || idx_t(index) > struct_children.size()) {
-		throw BinderException("Key index %lld for struct_extract out of range - expected an index between 1 and %llu",
-		                      index, struct_children.size());
-	}
-	bound_function.return_type = struct_children[NumericCast<idx_t>(index - 1)].second;
-	return GetBindData(NumericCast<idx_t>(index - 1));
-}
-
-static unique_ptr<FunctionData> StructExtractBindIndex(ClientContext &context, ScalarFunction &bound_function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-	return StructExtractBindInternal(context, bound_function, arguments, true);
-}
-
-static unique_ptr<FunctionData> StructExtractAtBind(ClientContext &context, ScalarFunction &bound_function,
-                                                    vector<unique_ptr<Expression>> &arguments) {
-	return StructExtractBindInternal(context, bound_function, arguments, false);
-}
-
-static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &bind_data = input.bind_data;
-
-	auto &info = bind_data->Cast<StructExtractBindData>();
-	auto struct_child_stats = StructStats::GetChildStats(child_stats[0]);
-	return struct_child_stats[info.index].ToUnique();
-}
-
-unique_ptr<FunctionData> GetBindData(idx_t index) {
-	return make_uniq<StructExtractBindData>(index);
-}
-
-ScalarFunction GetKeyExtractFunction() {
-	return ScalarFunction("struct_extract", {LogicalTypeId::STRUCT, LogicalType::VARCHAR}, LogicalType::ANY,
-	                      StructExtractFunction, StructExtractBind, nullptr, PropagateStructExtractStats);
-}
-
-ScalarFunction GetIndexExtractFunction() {
-	return ScalarFunction("struct_extract", {LogicalTypeId::STRUCT, LogicalType::BIGINT}, LogicalType::ANY,
-	                      StructExtractFunction, StructExtractBindIndex);
-}
-
-ScalarFunction GetExtractAtFunction() {
-	return ScalarFunction("struct_extract_at", {LogicalTypeId::STRUCT, LogicalType::BIGINT}, LogicalType::ANY,
-	                      StructExtractFunction, StructExtractAtBind);
-}
-
-ScalarFunctionSet StructExtractFun::GetFunctions() {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunctionSet struct_extract_set("struct_extract");
-	struct_extract_set.AddFunction(GetKeyExtractFunction());
-	struct_extract_set.AddFunction(GetIndexExtractFunction());
-	return struct_extract_set;
-}
-
-ScalarFunctionSet StructExtractAtFun::GetFunctions() {
-	ScalarFunctionSet struct_extractat_set("struct_extract_at");
-	struct_extractat_set.AddFunction(GetExtractAtFunction());
-	return struct_extractat_set;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/struct/struct_pack.cpp b/src/duckdb/src/function/scalar/struct/struct_pack.cpp
deleted file mode 100644
index 51a3e34ca..000000000
--- a/src/duckdb/src/function/scalar/struct/struct_pack.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/struct_functions.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-
-namespace duckdb {
-
-static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-#ifdef DEBUG
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<VariableReturnBindData>();
-	// this should never happen if the binder below is sane
-	D_ASSERT(args.ColumnCount() == StructType::GetChildTypes(info.stype).size());
-#endif
-	bool all_const = true;
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			all_const = false;
-		}
-		// same holds for this
-		child_entries[i]->Reference(args.data[i]);
-	}
-	result.SetVectorType(all_const ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
-	result.Verify(args.size());
-}
-
-template <bool IS_STRUCT_PACK>
-static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	case_insensitive_set_t name_collision_set;
-
-	// collect names and deconflict, construct return type
-	if (arguments.empty()) {
-		throw InvalidInputException("Can't pack nothing into a struct");
-	}
-	child_list_t<LogicalType> struct_children;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		auto &child = arguments[i];
-		string alias;
-		if (IS_STRUCT_PACK) {
-			if (child->GetAlias().empty()) {
-				throw BinderException("Need named argument for struct pack, e.g. STRUCT_PACK(a := b)");
-			}
-			alias = child->GetAlias();
-			if (name_collision_set.find(alias) != name_collision_set.end()) {
-				throw BinderException("Duplicate struct entry name \"%s\"", alias);
-			}
-			name_collision_set.insert(alias);
-		}
-		struct_children.push_back(make_pair(alias, arguments[i]->return_type));
-	}
-
-	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(struct_children);
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		StructStats::SetChildStats(struct_stats, i, child_stats[i]);
-	}
-	return struct_stats.ToUnique();
-}
-
-template <bool IS_STRUCT_PACK>
-ScalarFunction GetStructPackFunction() {
-	ScalarFunction fun(IS_STRUCT_PACK ? "struct_pack" : "row", {}, LogicalTypeId::STRUCT, StructPackFunction,
-	                   StructPackBind<IS_STRUCT_PACK>, nullptr, StructPackStats);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	fun.serialize = VariableReturnBindData::Serialize;
-	fun.deserialize = VariableReturnBindData::Deserialize;
-	return fun;
-}
-
-ScalarFunction StructPackFun::GetFunction() {
-	return GetStructPackFunction<true>();
-}
-
-ScalarFunction RowFun::GetFunction() {
-	return GetStructPackFunction<false>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar/system/aggregate_export.cpp b/src/duckdb/src/function/scalar/system/aggregate_export.cpp
deleted file mode 100644
index 64fee3e8c..000000000
--- a/src/duckdb/src/function/scalar/system/aggregate_export.cpp
+++ /dev/null
@@ -1,363 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/function/scalar/generic_common.hpp"
-#include "duckdb/function/scalar/system_functions.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-// aggregate state export
-struct ExportAggregateBindData : public FunctionData {
-	AggregateFunction aggr;
-	idx_t state_size;
-
-	explicit ExportAggregateBindData(AggregateFunction aggr_p, idx_t state_size_p)
-	    : aggr(std::move(aggr_p)), state_size(state_size_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<ExportAggregateBindData>(aggr, state_size);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<ExportAggregateBindData>();
-		return aggr == other.aggr && state_size == other.state_size;
-	}
-
-	static ExportAggregateBindData &GetFrom(ExpressionState &state) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		return func_expr.bind_info->Cast<ExportAggregateBindData>();
-	}
-};
-
-struct CombineState : public FunctionLocalState {
-	idx_t state_size;
-
-	unsafe_unique_array<data_t> state_buffer0, state_buffer1;
-	Vector state_vector0, state_vector1;
-
-	ArenaAllocator allocator;
-
-	explicit CombineState(idx_t state_size_p)
-	    : state_size(state_size_p), state_buffer0(make_unsafe_uniq_array<data_t>(state_size_p)),
-	      state_buffer1(make_unsafe_uniq_array<data_t>(state_size_p)),
-	      state_vector0(Value::POINTER(CastPointerToValue(state_buffer0.get()))),
-	      state_vector1(Value::POINTER(CastPointerToValue(state_buffer1.get()))),
-	      allocator(Allocator::DefaultAllocator()) {
-	}
-};
-
-static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                       FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
-	return make_uniq<CombineState>(bind_data.state_size);
-}
-
-struct FinalizeState : public FunctionLocalState {
-	idx_t state_size;
-	unsafe_unique_array<data_t> state_buffer;
-	Vector addresses;
-
-	ArenaAllocator allocator;
-
-	explicit FinalizeState(idx_t state_size_p)
-	    : state_size(state_size_p),
-	      state_buffer(make_unsafe_uniq_array<data_t>(STANDARD_VECTOR_SIZE * AlignValue(state_size_p))),
-	      addresses(LogicalType::POINTER), allocator(Allocator::DefaultAllocator()) {
-	}
-};
-
-static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                        FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
-	return make_uniq<FinalizeState>(bind_data.state_size);
-}
-
-static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
-	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<FinalizeState>();
-	local_state.allocator.Reset();
-
-	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size(bind_data.aggr));
-	D_ASSERT(input.data.size() == 1);
-	D_ASSERT(input.data[0].GetType().id() == LogicalTypeId::AGGREGATE_STATE);
-	auto aligned_state_size = AlignValue(bind_data.state_size);
-
-	auto state_vec_ptr = FlatVector::GetData<data_ptr_t>(local_state.addresses);
-
-	UnifiedVectorFormat state_data;
-	input.data[0].ToUnifiedFormat(input.size(), state_data);
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto state_idx = state_data.sel->get_index(i);
-		auto state_entry = UnifiedVectorFormat::GetData<string_t>(state_data) + state_idx;
-		auto target_ptr = char_ptr_cast(local_state.state_buffer.get()) + aligned_state_size * i;
-
-		if (state_data.validity.RowIsValid(state_idx)) {
-			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
-			memcpy((void *)target_ptr, state_entry->GetData(), bind_data.state_size);
-		} else {
-			// create a dummy state because finalize does not understand NULLs in its input
-			// we put the NULL back in explicitly below
-			bind_data.aggr.initialize(bind_data.aggr, data_ptr_cast(target_ptr));
-		}
-		state_vec_ptr[i] = data_ptr_cast(target_ptr);
-	}
-
-	AggregateInputData aggr_input_data(nullptr, local_state.allocator);
-	bind_data.aggr.finalize(local_state.addresses, aggr_input_data, result, input.size(), 0);
-
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto state_idx = state_data.sel->get_index(i);
-		if (!state_data.validity.RowIsValid(state_idx)) {
-			FlatVector::SetNull(result, i, true);
-		}
-	}
-}
-
-static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
-	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<CombineState>();
-	local_state.allocator.Reset();
-
-	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size(bind_data.aggr));
-
-	D_ASSERT(input.data.size() == 2);
-	D_ASSERT(input.data[0].GetType().id() == LogicalTypeId::AGGREGATE_STATE);
-	D_ASSERT(input.data[0].GetType() == result.GetType());
-
-	if (input.data[0].GetType().InternalType() != input.data[1].GetType().InternalType()) {
-		throw IOException("Aggregate state combine type mismatch, expect %s, got %s",
-		                  input.data[0].GetType().ToString(), input.data[1].GetType().ToString());
-	}
-
-	UnifiedVectorFormat state0_data, state1_data;
-	input.data[0].ToUnifiedFormat(input.size(), state0_data);
-	input.data[1].ToUnifiedFormat(input.size(), state1_data);
-
-	auto result_ptr = FlatVector::GetData<string_t>(result);
-
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto state0_idx = state0_data.sel->get_index(i);
-		auto state1_idx = state1_data.sel->get_index(i);
-
-		auto &state0 = UnifiedVectorFormat::GetData<string_t>(state0_data)[state0_idx];
-		auto &state1 = UnifiedVectorFormat::GetData<string_t>(state1_data)[state1_idx];
-
-		// if both are NULL, we return NULL. If either of them is not, the result is that one
-		if (!state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-		if (state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, const_char_ptr_cast(state0.GetData()), bind_data.state_size);
-			continue;
-		}
-		if (!state0_data.validity.RowIsValid(state0_idx) && state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, const_char_ptr_cast(state1.GetData()), bind_data.state_size);
-			continue;
-		}
-
-		// we actually have to combine
-		if (state0.GetSize() != bind_data.state_size || state1.GetSize() != bind_data.state_size) {
-			throw IOException("Aggregate state size mismatch, expect %llu, got %llu and %llu", bind_data.state_size,
-			                  state0.GetSize(), state1.GetSize());
-		}
-
-		memcpy(local_state.state_buffer0.get(), state0.GetData(), bind_data.state_size);
-		memcpy(local_state.state_buffer1.get(), state1.GetData(), bind_data.state_size);
-
-		AggregateInputData aggr_input_data(nullptr, local_state.allocator, AggregateCombineType::ALLOW_DESTRUCTIVE);
-		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
-
-		result_ptr[i] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(local_state.state_buffer1.get()),
-		                                              bind_data.state_size);
-	}
-}
-
-static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-
-	// grab the aggregate type and bind the aggregate again
-
-	// the aggregate name and types are in the logical type of the aggregate state, make sure its sane
-	auto &arg_return_type = arguments[0]->return_type;
-	for (auto &arg_type : bound_function.arguments) {
-		arg_type = arg_return_type;
-	}
-
-	if (arg_return_type.id() != LogicalTypeId::AGGREGATE_STATE) {
-		throw BinderException("Can only FINALIZE aggregate state, not %s", arg_return_type.ToString());
-	}
-	// combine
-	if (arguments.size() == 2 && arguments[0]->return_type != arguments[1]->return_type &&
-	    arguments[1]->return_type.id() != LogicalTypeId::BLOB) {
-		throw BinderException("Cannot COMBINE aggregate states from different functions, %s <> %s",
-		                      arguments[0]->return_type.ToString(), arguments[1]->return_type.ToString());
-	}
-
-	// following error states are only reachable when someone messes up creating the state_type
-	// which is impossible from SQL
-
-	auto state_type = AggregateStateType::GetStateType(arg_return_type);
-
-	// now we can look up the function in the catalog again and bind it
-	auto &func = Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY,
-	                                                         DEFAULT_SCHEMA, state_type.function_name);
-	if (func.type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-		throw InternalException("Could not find aggregate %s", state_type.function_name);
-	}
-	auto &aggr = func.Cast<AggregateFunctionCatalogEntry>();
-
-	ErrorData error;
-
-	FunctionBinder function_binder(context);
-	auto best_function =
-	    function_binder.BindFunction(aggr.name, aggr.functions, state_type.bound_argument_types, error);
-	if (!best_function.IsValid()) {
-		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name,
-		                        error.Message());
-	}
-	auto bound_aggr = aggr.functions.GetFunctionByOffset(best_function.GetIndex());
-	if (bound_aggr.bind) {
-		// FIXME: this is really hacky
-		// but the aggregate state export needs a rework around how it handles more complex aggregates anyway
-		vector<unique_ptr<Expression>> args;
-		args.reserve(state_type.bound_argument_types.size());
-		for (auto &arg_type : state_type.bound_argument_types) {
-			args.push_back(make_uniq<BoundConstantExpression>(Value(arg_type)));
-		}
-		auto bind_info = bound_aggr.bind(context, bound_aggr, args);
-		if (bind_info) {
-			throw BinderException("Aggregate function with bind info not supported yet in aggregate state export");
-		}
-	}
-
-	if (bound_aggr.return_type != state_type.return_type || bound_aggr.arguments != state_type.bound_argument_types) {
-		throw InternalException("Type mismatch for exported aggregate %s", state_type.function_name);
-	}
-
-	if (bound_function.name == "finalize") {
-		bound_function.return_type = bound_aggr.return_type;
-	} else {
-		D_ASSERT(bound_function.name == "combine");
-		bound_function.return_type = arg_return_type;
-	}
-
-	return make_uniq<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size(bound_aggr));
-}
-
-static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                                    idx_t offset) {
-	D_ASSERT(offset == 0);
-	auto &bind_data = aggr_input_data.bind_data->Cast<ExportAggregateFunctionBindData>();
-	auto state_size = bind_data.aggregate->function.state_size(bind_data.aggregate->function);
-	auto blob_ptr = FlatVector::GetData<string_t>(result);
-	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(state);
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		auto data_ptr = addresses_ptr[row_idx];
-		blob_ptr[row_idx] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(data_ptr), state_size);
-	}
-}
-
-ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
-	D_ASSERT(aggregate_p->GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
-	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
-}
-
-unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
-	return make_uniq<ExportAggregateFunctionBindData>(aggregate->Copy());
-}
-
-bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
-	return aggregate->Equals(*other.aggregate);
-}
-
-static void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                          const AggregateFunction &function) {
-	throw NotImplementedException("FIXME: export state serialize");
-}
-
-static unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer,
-                                                                AggregateFunction &function) {
-	throw NotImplementedException("FIXME: export state deserialize");
-}
-
-static void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                       const ScalarFunction &function) {
-	throw NotImplementedException("FIXME: export state serialize");
-}
-
-static unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
-	throw NotImplementedException("FIXME: export state deserialize");
-}
-
-unique_ptr<BoundAggregateExpression>
-ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggregate) {
-	auto &bound_function = child_aggregate->function;
-	if (!bound_function.combine) {
-		throw BinderException("Cannot use EXPORT_STATE for non-combinable function %s", bound_function.name);
-	}
-	if (bound_function.bind) {
-		throw BinderException("Cannot use EXPORT_STATE on aggregate functions with custom binders");
-	}
-	if (bound_function.destructor) {
-		throw BinderException("Cannot use EXPORT_STATE on aggregate functions with custom destructors");
-	}
-	// this should be required
-	D_ASSERT(bound_function.state_size);
-	D_ASSERT(bound_function.finalize);
-
-	D_ASSERT(child_aggregate->function.return_type.id() != LogicalTypeId::INVALID);
-#ifdef DEBUG
-	for (auto &arg_type : child_aggregate->function.arguments) {
-		D_ASSERT(arg_type.id() != LogicalTypeId::INVALID);
-	}
-#endif
-	auto export_bind_data = make_uniq<ExportAggregateFunctionBindData>(child_aggregate->Copy());
-	aggregate_state_t state_type(child_aggregate->function.name, child_aggregate->function.return_type,
-	                             child_aggregate->function.arguments);
-	auto return_type = LogicalType::AGGREGATE_STATE(std::move(state_type));
-
-	auto export_function =
-	    AggregateFunction("aggregate_state_export_" + bound_function.name, bound_function.arguments, return_type,
-	                      bound_function.state_size, bound_function.initialize, bound_function.update,
-	                      bound_function.combine, ExportAggregateFinalize, bound_function.simple_update,
-	                      /* can't bind this again */ nullptr, /* no dynamic state yet */ nullptr,
-	                      /* can't propagate statistics */ nullptr, nullptr);
-	export_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	export_function.serialize = ExportStateAggregateSerialize;
-	export_function.deserialize = ExportStateAggregateDeserialize;
-
-	return make_uniq<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
-	                                           std::move(child_aggregate->filter), std::move(export_bind_data),
-	                                           child_aggregate->aggr_type);
-}
-
-ScalarFunction FinalizeFun::GetFunction() {
-	auto result = ScalarFunction("finalize", {LogicalTypeId::AGGREGATE_STATE}, LogicalTypeId::INVALID,
-	                             AggregateStateFinalize, BindAggregateState, nullptr, nullptr, InitFinalizeState);
-	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	result.serialize = ExportStateScalarSerialize;
-	result.deserialize = ExportStateScalarDeserialize;
-	return result;
-}
-
-ScalarFunction CombineFun::GetFunction() {
-	auto result =
-	    ScalarFunction("combine", {LogicalTypeId::AGGREGATE_STATE, LogicalTypeId::ANY}, LogicalTypeId::AGGREGATE_STATE,
-	                   AggregateStateCombine, BindAggregateState, nullptr, nullptr, InitCombineState);
-	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	result.serialize = ExportStateScalarSerialize;
-	result.deserialize = ExportStateScalarDeserialize;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar_function.cpp b/src/duckdb/src/function/scalar_function.cpp
deleted file mode 100644
index a627643fd..000000000
--- a/src/duckdb/src/function/scalar_function.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "duckdb/function/scalar_function.hpp"
-
-namespace duckdb {
-
-FunctionLocalState::~FunctionLocalState() {
-}
-
-ScalarFunctionInfo::~ScalarFunctionInfo() {
-}
-
-ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-                               scalar_function_t function, bind_scalar_function_t bind,
-                               bind_scalar_function_extended_t bind_extended, function_statistics_t statistics,
-                               init_local_state_t init_local_state, LogicalType varargs, FunctionStability side_effects,
-                               FunctionNullHandling null_handling, bind_lambda_function_t bind_lambda)
-    : BaseScalarFunction(std::move(name), std::move(arguments), std::move(return_type), side_effects,
-                         std::move(varargs), null_handling),
-      function(std::move(function)), bind(bind), bind_extended(bind_extended), init_local_state(init_local_state),
-      statistics(statistics), bind_lambda(bind_lambda), bind_expression(nullptr), get_modified_databases(nullptr),
-      serialize(nullptr), deserialize(nullptr) {
-}
-
-ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-                               bind_scalar_function_t bind, bind_scalar_function_extended_t bind_extended,
-                               function_statistics_t statistics, init_local_state_t init_local_state,
-                               LogicalType varargs, FunctionStability side_effects, FunctionNullHandling null_handling,
-                               bind_lambda_function_t bind_lambda)
-    : ScalarFunction(string(), std::move(arguments), std::move(return_type), std::move(function), bind, bind_extended,
-                     statistics, init_local_state, std::move(varargs), side_effects, null_handling, bind_lambda) {
-}
-
-bool ScalarFunction::operator==(const ScalarFunction &rhs) const {
-	return name == rhs.name && arguments == rhs.arguments && return_type == rhs.return_type && varargs == rhs.varargs &&
-	       bind == rhs.bind && bind_extended == rhs.bind_extended && statistics == rhs.statistics &&
-	       bind_lambda == rhs.bind_lambda;
-}
-
-bool ScalarFunction::operator!=(const ScalarFunction &rhs) const {
-	return !(*this == rhs);
-}
-
-bool ScalarFunction::Equal(const ScalarFunction &rhs) const {
-	// number of types
-	if (this->arguments.size() != rhs.arguments.size()) {
-		return false;
-	}
-	// argument types
-	for (idx_t i = 0; i < this->arguments.size(); ++i) {
-		if (this->arguments[i] != rhs.arguments[i]) {
-			return false;
-		}
-	}
-	// return type
-	if (this->return_type != rhs.return_type) {
-		return false;
-	}
-	// varargs
-	if (this->varargs != rhs.varargs) {
-		return false;
-	}
-
-	return true; // they are equal
-}
-
-void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() >= 1);
-	result.Reference(input.data[0]);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/scalar_macro_function.cpp b/src/duckdb/src/function/scalar_macro_function.cpp
deleted file mode 100644
index 9f3d79c3f..000000000
--- a/src/duckdb/src/function/scalar_macro_function.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/function/scalar_macro_function.hpp"
-
-#include "duckdb/function/macro_function.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-namespace duckdb {
-
-ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression)
-    : MacroFunction(MacroType::SCALAR_MACRO), expression(std::move(expression)) {
-}
-
-ScalarMacroFunction::ScalarMacroFunction(void) : MacroFunction(MacroType::SCALAR_MACRO) {
-}
-
-unique_ptr<MacroFunction> ScalarMacroFunction::Copy() const {
-	auto result = make_uniq<ScalarMacroFunction>();
-	result->expression = expression->Copy();
-	CopyProperties(*result);
-
-	return std::move(result);
-}
-
-void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
-	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &col_ref = expr->Cast<ColumnRefExpression>();
-		auto &col_names = col_ref.column_names;
-		if (col_names.size() == 2 && col_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
-			col_names.erase(col_names.begin());
-		}
-	} else {
-		ParsedExpressionIterator::EnumerateChildren(
-		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveQualificationRecursive(child); });
-	}
-}
-
-string ScalarMacroFunction::ToSQL() const {
-	// In case of nested macro's we need to fix it a bit
-	auto expression_copy = expression->Copy();
-	RemoveQualificationRecursive(expression_copy);
-	return MacroFunction::ToSQL() + StringUtil::Format("(%s)", expression_copy->ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/arrow.cpp b/src/duckdb/src/function/table/arrow.cpp
deleted file mode 100644
index 5d719e8f7..000000000
--- a/src/duckdb/src/function/table/arrow.cpp
+++ /dev/null
@@ -1,621 +0,0 @@
-#include "duckdb/common/arrow/arrow.hpp"
-
-#include "duckdb.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/function/table/arrow.hpp"
-#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
-#include "duckdb/function/table/arrow/arrow_type_info.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/common/arrow/schema_metadata.hpp"
-
-namespace duckdb {
-
-static unique_ptr<ArrowType> CreateListType(ArrowSchema &child, ArrowVariableSizeType size_type, bool view) {
-	auto child_type = ArrowTableFunction::GetArrowLogicalType(child);
-
-	unique_ptr<ArrowTypeInfo> type_info;
-	auto type = LogicalType::LIST(child_type->GetDuckType());
-	if (view) {
-		type_info = ArrowListInfo::ListView(std::move(child_type), size_type);
-	} else {
-		type_info = ArrowListInfo::List(std::move(child_type), size_type);
-	}
-	return make_uniq<ArrowType>(type, std::move(type_info));
-}
-
-static unique_ptr<ArrowType> GetArrowExtensionType(const ArrowSchemaMetadata &extension_type, const string &format) {
-	auto arrow_extension = extension_type.GetExtensionName();
-	// Check for arrow canonical extensions
-	if (arrow_extension == "arrow.uuid") {
-		if (format != "w:16") {
-			std::ostringstream error;
-			error
-			    << "arrow.uuid must be a fixed-size binary of 16 bytes (i.e., \'w:16\'). It is incorrectly defined as:"
-			    << format;
-			return make_uniq<ArrowType>(error.str());
-		}
-		return make_uniq<ArrowType>(LogicalType::UUID);
-	} else if (arrow_extension == "arrow.json") {
-		if (format == "u") {
-			return make_uniq<ArrowType>(LogicalType::JSON(), make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
-		} else if (format == "U") {
-			return make_uniq<ArrowType>(LogicalType::JSON(),
-			                            make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
-		} else if (format == "vu") {
-			return make_uniq<ArrowType>(LogicalType::JSON(), make_uniq<ArrowStringInfo>(ArrowVariableSizeType::VIEW));
-		} else {
-			std::ostringstream error;
-			error
-			    << "arrow.json must be of a varchar format (i.e., \'u\',\'U\' or \'vu\'). It is incorrectly defined as:"
-			    << format;
-			return make_uniq<ArrowType>(error.str());
-		}
-	}
-	// Check for DuckDB canonical extensions
-	else if (extension_type.IsNonCanonicalType("hugeint")) {
-		if (format != "w:16") {
-			std::ostringstream error;
-			error << "DuckDB hugeint must be a fixed-size binary of 16 bytes (i.e., \'w:16\'). It is incorrectly "
-			         "defined as:"
-			      << format;
-			return make_uniq<ArrowType>(error.str());
-		}
-		return make_uniq<ArrowType>(LogicalType::HUGEINT);
-	} else if (extension_type.IsNonCanonicalType("uhugeint")) {
-		if (format != "w:16") {
-			std::ostringstream error;
-			error << "DuckDB uhugeint must be a fixed-size binary of 16 bytes (i.e., \'w:16\'). It is incorrectly "
-			         "defined as:"
-			      << format;
-			return make_uniq<ArrowType>(error.str());
-		}
-		return make_uniq<ArrowType>(LogicalType::UHUGEINT);
-	} else if (extension_type.IsNonCanonicalType("time_tz")) {
-		if (format != "w:8") {
-			std::ostringstream error;
-			error << "DuckDB time_tz must be a fixed-size binary of 8 bytes (i.e., \'w:8\'). It is incorrectly defined "
-			         "as:"
-			      << format;
-			return make_uniq<ArrowType>(error.str());
-		}
-		return make_uniq<ArrowType>(LogicalType::TIME_TZ,
-		                            make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MICROSECONDS));
-	} else if (extension_type.IsNonCanonicalType("bit")) {
-		if (format != "z" && format != "Z") {
-			std::ostringstream error;
-			error << "DuckDB bit must be a blob (i.e., \'z\' or \'Z\'). It is incorrectly defined as:" << format;
-			return make_uniq<ArrowType>(error.str());
-		} else if (format == "z") {
-			auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL);
-			return make_uniq<ArrowType>(LogicalType::BIT, std::move(type_info));
-		}
-		auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE);
-		return make_uniq<ArrowType>(LogicalType::BIT, std::move(type_info));
-
-	} else if (extension_type.IsNonCanonicalType("varint")) {
-		if (format != "z" && format != "Z") {
-			std::ostringstream error;
-			error << "DuckDB bit must be a blob (i.e., \'z\'). It is incorrectly defined as:" << format;
-			return make_uniq<ArrowType>(error.str());
-		}
-		unique_ptr<ArrowStringInfo> type_info;
-		if (format == "z") {
-			type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL);
-		} else {
-			type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE);
-		}
-		return make_uniq<ArrowType>(LogicalType::VARINT, std::move(type_info));
-	} else {
-		std::ostringstream error;
-		error << "Arrow Type with extension name: " << arrow_extension << " and format: " << format
-		      << ", is not currently supported in DuckDB.";
-		return make_uniq<ArrowType>(error.str(), true);
-	}
-}
-static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema) {
-	auto format = string(schema.format);
-	// Let's first figure out if this type is an extension type
-	ArrowSchemaMetadata schema_metadata(schema.metadata);
-	if (schema_metadata.HasExtension()) {
-		return GetArrowExtensionType(schema_metadata, format);
-	}
-	// If not, we just check the format itself
-	if (format == "n") {
-		return make_uniq<ArrowType>(LogicalType::SQLNULL);
-	} else if (format == "b") {
-		return make_uniq<ArrowType>(LogicalType::BOOLEAN);
-	} else if (format == "c") {
-		return make_uniq<ArrowType>(LogicalType::TINYINT);
-	} else if (format == "s") {
-		return make_uniq<ArrowType>(LogicalType::SMALLINT);
-	} else if (format == "i") {
-		return make_uniq<ArrowType>(LogicalType::INTEGER);
-	} else if (format == "l") {
-		return make_uniq<ArrowType>(LogicalType::BIGINT);
-	} else if (format == "C") {
-		return make_uniq<ArrowType>(LogicalType::UTINYINT);
-	} else if (format == "S") {
-		return make_uniq<ArrowType>(LogicalType::USMALLINT);
-	} else if (format == "I") {
-		return make_uniq<ArrowType>(LogicalType::UINTEGER);
-	} else if (format == "L") {
-		return make_uniq<ArrowType>(LogicalType::UBIGINT);
-	} else if (format == "f") {
-		return make_uniq<ArrowType>(LogicalType::FLOAT);
-	} else if (format == "g") {
-		return make_uniq<ArrowType>(LogicalType::DOUBLE);
-	} else if (format[0] == 'd') { //! this can be either decimal128 or decimal 256 (e.g., d:38,0)
-		auto extra_info = StringUtil::Split(format, ':');
-		if (extra_info.size() != 2) {
-			throw InvalidInputException(
-			    "Decimal format of Arrow object is incomplete, it is missing the scale and width. Current format: %s",
-			    format);
-		}
-		auto parameters = StringUtil::Split(extra_info[1], ",");
-		// Parameters must always be 2 or 3 values (i.e., width, scale and an optional bit-width)
-		if (parameters.size() != 2 && parameters.size() != 3) {
-			throw InvalidInputException(
-			    "Decimal format of Arrow object is incomplete, it is missing the scale or width. Current format: %s",
-			    format);
-		}
-		uint64_t width = std::stoull(parameters[0]);
-		uint64_t scale = std::stoull(parameters[1]);
-		uint64_t bitwidth = 128;
-		if (parameters.size() == 3) {
-			// We have a bit-width defined
-			bitwidth = std::stoull(parameters[2]);
-		}
-		if (width > 38 || bitwidth > 128) {
-			throw NotImplementedException("Unsupported Internal Arrow Type for Decimal %s", format);
-		}
-		return make_uniq<ArrowType>(LogicalType::DECIMAL(NumericCast<uint8_t>(width), NumericCast<uint8_t>(scale)));
-	} else if (format == "u") {
-		return make_uniq<ArrowType>(LogicalType::VARCHAR, make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
-	} else if (format == "U") {
-		return make_uniq<ArrowType>(LogicalType::VARCHAR,
-		                            make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
-	} else if (format == "vu") {
-		return make_uniq<ArrowType>(LogicalType::VARCHAR, make_uniq<ArrowStringInfo>(ArrowVariableSizeType::VIEW));
-	} else if (format == "tsn:") {
-		return make_uniq<ArrowType>(LogicalTypeId::TIMESTAMP_NS);
-	} else if (format == "tsu:") {
-		return make_uniq<ArrowType>(LogicalTypeId::TIMESTAMP);
-	} else if (format == "tsm:") {
-		return make_uniq<ArrowType>(LogicalTypeId::TIMESTAMP_MS);
-	} else if (format == "tss:") {
-		return make_uniq<ArrowType>(LogicalTypeId::TIMESTAMP_SEC);
-	} else if (format == "tdD") {
-		return make_uniq<ArrowType>(LogicalType::DATE, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::DAYS));
-	} else if (format == "tdm") {
-		return make_uniq<ArrowType>(LogicalType::DATE, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MILLISECONDS));
-	} else if (format == "tts") {
-		return make_uniq<ArrowType>(LogicalType::TIME, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::SECONDS));
-	} else if (format == "ttm") {
-		return make_uniq<ArrowType>(LogicalType::TIME, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MILLISECONDS));
-	} else if (format == "ttu") {
-		return make_uniq<ArrowType>(LogicalType::TIME, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MICROSECONDS));
-	} else if (format == "ttn") {
-		return make_uniq<ArrowType>(LogicalType::TIME, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::NANOSECONDS));
-	} else if (format == "tDs") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::SECONDS));
-	} else if (format == "tDm") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL,
-		                            make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MILLISECONDS));
-	} else if (format == "tDu") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL,
-		                            make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MICROSECONDS));
-	} else if (format == "tDn") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL,
-		                            make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::NANOSECONDS));
-	} else if (format == "tiD") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::DAYS));
-	} else if (format == "tiM") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL, make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MONTHS));
-	} else if (format == "tin") {
-		return make_uniq<ArrowType>(LogicalType::INTERVAL,
-		                            make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MONTH_DAY_NANO));
-	} else if (format == "+l") {
-		return CreateListType(*schema.children[0], ArrowVariableSizeType::NORMAL, false);
-	} else if (format == "+L") {
-		return CreateListType(*schema.children[0], ArrowVariableSizeType::SUPER_SIZE, false);
-	} else if (format == "+vl") {
-		return CreateListType(*schema.children[0], ArrowVariableSizeType::NORMAL, true);
-	} else if (format == "+vL") {
-		return CreateListType(*schema.children[0], ArrowVariableSizeType::SUPER_SIZE, true);
-	} else if (format[0] == '+' && format[1] == 'w') {
-		std::string parameters = format.substr(format.find(':') + 1);
-		auto fixed_size = NumericCast<idx_t>(std::stoi(parameters));
-		auto child_type = ArrowTableFunction::GetArrowLogicalType(*schema.children[0]);
-
-		auto array_type = LogicalType::ARRAY(child_type->GetDuckType(), fixed_size);
-		auto type_info = make_uniq<ArrowArrayInfo>(std::move(child_type), fixed_size);
-		return make_uniq<ArrowType>(array_type, std::move(type_info));
-	} else if (format == "+s") {
-		child_list_t<LogicalType> child_types;
-		vector<unique_ptr<ArrowType>> children;
-		if (schema.n_children == 0) {
-			throw InvalidInputException(
-			    "Attempted to convert a STRUCT with no fields to DuckDB which is not supported");
-		}
-		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
-			children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*schema.children[type_idx]));
-			child_types.emplace_back(schema.children[type_idx]->name, children.back()->GetDuckType());
-		}
-		auto type_info = make_uniq<ArrowStructInfo>(std::move(children));
-		auto struct_type = make_uniq<ArrowType>(LogicalType::STRUCT(std::move(child_types)), std::move(type_info));
-		return struct_type;
-	} else if (format[0] == '+' && format[1] == 'u') {
-		if (format[2] != 's') {
-			throw NotImplementedException("Unsupported Internal Arrow Type: \"%c\" Union", format[2]);
-		}
-		D_ASSERT(format[3] == ':');
-
-		std::string prefix = "+us:";
-		// TODO: what are these type ids actually for?
-		auto type_ids = StringUtil::Split(format.substr(prefix.size()), ',');
-
-		child_list_t<LogicalType> members;
-		vector<unique_ptr<ArrowType>> children;
-		if (schema.n_children == 0) {
-			throw InvalidInputException("Attempted to convert a UNION with no fields to DuckDB which is not supported");
-		}
-		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
-			auto type = schema.children[type_idx];
-
-			children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*type));
-			members.emplace_back(type->name, children.back()->GetDuckType());
-		}
-
-		auto type_info = make_uniq<ArrowStructInfo>(std::move(children));
-		auto union_type = make_uniq<ArrowType>(LogicalType::UNION(members), std::move(type_info));
-		return union_type;
-	} else if (format == "+r") {
-		child_list_t<LogicalType> members;
-		vector<unique_ptr<ArrowType>> children;
-		idx_t n_children = idx_t(schema.n_children);
-		D_ASSERT(n_children == 2);
-		D_ASSERT(string(schema.children[0]->name) == "run_ends");
-		D_ASSERT(string(schema.children[1]->name) == "values");
-		for (idx_t i = 0; i < n_children; i++) {
-			auto type = schema.children[i];
-			children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*type));
-			members.emplace_back(type->name, children.back()->GetDuckType());
-		}
-
-		auto type_info = make_uniq<ArrowStructInfo>(std::move(children));
-		auto struct_type = make_uniq<ArrowType>(LogicalType::STRUCT(members), std::move(type_info));
-		struct_type->SetRunEndEncoded();
-		return struct_type;
-	} else if (format == "+m") {
-		auto &arrow_struct_type = *schema.children[0];
-		D_ASSERT(arrow_struct_type.n_children == 2);
-		auto key_type = ArrowTableFunction::GetArrowLogicalType(*arrow_struct_type.children[0]);
-		auto value_type = ArrowTableFunction::GetArrowLogicalType(*arrow_struct_type.children[1]);
-		child_list_t<LogicalType> key_value;
-		key_value.emplace_back(std::make_pair("key", key_type->GetDuckType()));
-		key_value.emplace_back(std::make_pair("value", value_type->GetDuckType()));
-
-		auto map_type = LogicalType::MAP(key_type->GetDuckType(), value_type->GetDuckType());
-		vector<unique_ptr<ArrowType>> children;
-		children.reserve(2);
-		children.push_back(std::move(key_type));
-		children.push_back(std::move(value_type));
-		auto inner_struct = make_uniq<ArrowType>(LogicalType::STRUCT(std::move(key_value)),
-		                                         make_uniq<ArrowStructInfo>(std::move(children)));
-		auto map_type_info = ArrowListInfo::List(std::move(inner_struct), ArrowVariableSizeType::NORMAL);
-		return make_uniq<ArrowType>(map_type, std::move(map_type_info));
-	} else if (format == "z") {
-		auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL);
-		return make_uniq<ArrowType>(LogicalType::BLOB, std::move(type_info));
-	} else if (format == "Z") {
-		auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE);
-		return make_uniq<ArrowType>(LogicalType::BLOB, std::move(type_info));
-	} else if (format[0] == 'w') {
-		string parameters = format.substr(format.find(':') + 1);
-		auto fixed_size = NumericCast<idx_t>(std::stoi(parameters));
-		auto type_info = make_uniq<ArrowStringInfo>(fixed_size);
-		return make_uniq<ArrowType>(LogicalType::BLOB, std::move(type_info));
-	} else if (format[0] == 't' && format[1] == 's') {
-		// Timestamp with Timezone
-		// TODO right now we just get the UTC value. We probably want to support this properly in the future
-		unique_ptr<ArrowTypeInfo> type_info;
-		if (format[2] == 'n') {
-			type_info = make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::NANOSECONDS);
-		} else if (format[2] == 'u') {
-			type_info = make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MICROSECONDS);
-		} else if (format[2] == 'm') {
-			type_info = make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::MILLISECONDS);
-		} else if (format[2] == 's') {
-			type_info = make_uniq<ArrowDateTimeInfo>(ArrowDateTimeType::SECONDS);
-		} else {
-			throw NotImplementedException(" Timestamptz precision of not accepted");
-		}
-		return make_uniq<ArrowType>(LogicalType::TIMESTAMP_TZ, std::move(type_info));
-	} else {
-		throw NotImplementedException("Unsupported Internal Arrow Type %s", format);
-	}
-}
-
-unique_ptr<ArrowType> ArrowTableFunction::GetArrowLogicalType(ArrowSchema &schema) {
-	auto arrow_type = GetArrowLogicalTypeNoDictionary(schema);
-	if (schema.dictionary) {
-		auto dictionary = GetArrowLogicalType(*schema.dictionary);
-		arrow_type->SetDictionary(std::move(dictionary));
-	}
-	return arrow_type;
-}
-
-void ArrowTableFunction::PopulateArrowTableType(ArrowTableType &arrow_table, ArrowSchemaWrapper &schema_p,
-                                                vector<string> &names, vector<LogicalType> &return_types) {
-	for (idx_t col_idx = 0; col_idx < (idx_t)schema_p.arrow_schema.n_children; col_idx++) {
-		auto &schema = *schema_p.arrow_schema.children[col_idx];
-		if (!schema.release) {
-			throw InvalidInputException("arrow_scan: released schema passed");
-		}
-		auto arrow_type = GetArrowLogicalType(schema);
-		return_types.emplace_back(arrow_type->GetDuckType(true));
-		arrow_table.AddColumn(col_idx, std::move(arrow_type));
-		auto name = string(schema.name);
-		if (name.empty()) {
-			name = string("v") + to_string(col_idx);
-		}
-		names.push_back(name);
-	}
-}
-
-unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBindDumb(ClientContext &context, TableFunctionBindInput &input,
-                                                               vector<LogicalType> &return_types,
-                                                               vector<string> &names) {
-	auto bind_data = ArrowScanBind(context, input, return_types, names);
-	auto &arrow_bind_data = bind_data->Cast<ArrowScanFunctionData>();
-	arrow_bind_data.projection_pushdown_enabled = false;
-	return bind_data;
-}
-
-unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
-                                                           vector<LogicalType> &return_types, vector<string> &names) {
-	if (input.inputs[0].IsNull() || input.inputs[1].IsNull() || input.inputs[2].IsNull()) {
-		throw BinderException("arrow_scan: pointers cannot be null");
-	}
-	auto &ref = input.ref;
-
-	shared_ptr<DependencyItem> dependency;
-	if (ref.external_dependency) {
-		// This was created during the replacement scan for Python (see python_replacement_scan.cpp)
-		// this object is the owning reference to 'stream_factory_ptr' and has to be kept alive.
-		dependency = ref.external_dependency->GetDependency("replacement_cache");
-		D_ASSERT(dependency);
-	}
-
-	auto stream_factory_ptr = input.inputs[0].GetPointer();
-	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();       // NOLINT
-	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer(); // NOLINT
-
-	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr, std::move(dependency));
-
-	auto &data = *res;
-	stream_factory_get_schema(reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr), data.schema_root.arrow_schema);
-	PopulateArrowTableType(res->arrow_table, data.schema_root, names, return_types);
-	QueryResult::DeduplicateColumns(names);
-	res->all_types = return_types;
-	if (return_types.empty()) {
-		throw InvalidInputException("Provided table/dataframe must have at least one column");
-	}
-	return std::move(res);
-}
-
-unique_ptr<ArrowArrayStreamWrapper> ProduceArrowScan(const ArrowScanFunctionData &function,
-                                                     const vector<column_t> &column_ids, TableFilterSet *filters) {
-	//! Generate Projection Pushdown Vector
-	ArrowStreamParameters parameters;
-	D_ASSERT(!column_ids.empty());
-	auto &arrow_types = function.arrow_table.GetColumns();
-	for (idx_t idx = 0; idx < column_ids.size(); idx++) {
-		auto col_idx = column_ids[idx];
-		if (col_idx != COLUMN_IDENTIFIER_ROW_ID) {
-			auto &schema = *function.schema_root.arrow_schema.children[col_idx];
-			arrow_types.at(col_idx)->ThrowIfInvalid();
-			parameters.projected_columns.projection_map[idx] = schema.name;
-			parameters.projected_columns.columns.emplace_back(schema.name);
-			parameters.projected_columns.filter_to_col[idx] = col_idx;
-		}
-	}
-	parameters.filters = filters;
-	return function.scanner_producer(function.stream_factory_ptr, parameters);
-}
-
-idx_t ArrowTableFunction::ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data_p) {
-	return context.db->NumberOfThreads();
-}
-
-bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-                                                    ArrowScanLocalState &state, ArrowScanGlobalState &parallel_state) {
-	lock_guard<mutex> parallel_lock(parallel_state.main_mutex);
-	if (parallel_state.done) {
-		return false;
-	}
-	state.Reset();
-	state.batch_index = ++parallel_state.batch_index;
-
-	auto current_chunk = parallel_state.stream->GetNextChunk();
-	while (current_chunk->arrow_array.length == 0 && current_chunk->arrow_array.release) {
-		current_chunk = parallel_state.stream->GetNextChunk();
-	}
-	state.chunk = std::move(current_chunk);
-	//! have we run out of chunks? we are done
-	if (!state.chunk->arrow_array.release) {
-		parallel_state.done = true;
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(ClientContext &context,
-                                                                             TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<ArrowScanFunctionData>();
-	auto result = make_uniq<ArrowScanGlobalState>();
-	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters.get());
-	result->max_threads = ArrowScanMaxThreads(context, input.bind_data.get());
-	if (!input.projection_ids.empty()) {
-		result->projection_ids = input.projection_ids;
-		for (const auto &col_idx : input.column_ids) {
-			if (col_idx == COLUMN_IDENTIFIER_ROW_ID) {
-				result->scanned_types.emplace_back(LogicalType::ROW_TYPE);
-			} else {
-				result->scanned_types.push_back(bind_data.all_types[col_idx]);
-			}
-		}
-	}
-	return std::move(result);
-}
-
-unique_ptr<LocalTableFunctionState>
-ArrowTableFunction::ArrowScanInitLocalInternal(ClientContext &context, TableFunctionInitInput &input,
-                                               GlobalTableFunctionState *global_state_p) {
-	auto &global_state = global_state_p->Cast<ArrowScanGlobalState>();
-	auto current_chunk = make_uniq<ArrowArrayWrapper>();
-	auto result = make_uniq<ArrowScanLocalState>(std::move(current_chunk));
-	result->column_ids = input.column_ids;
-	result->filters = input.filters.get();
-	auto &bind_data = input.bind_data->Cast<ArrowScanFunctionData>();
-	if (!bind_data.projection_pushdown_enabled) {
-		result->column_ids.clear();
-	} else if (!input.projection_ids.empty()) {
-		auto &asgs = global_state_p->Cast<ArrowScanGlobalState>();
-		result->all_columns.Initialize(context, asgs.scanned_types);
-	}
-	if (!ArrowScanParallelStateNext(context, input.bind_data.get(), *result, global_state)) {
-		return nullptr;
-	}
-	return std::move(result);
-}
-
-unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ExecutionContext &context,
-                                                                           TableFunctionInitInput &input,
-                                                                           GlobalTableFunctionState *global_state_p) {
-	return ArrowScanInitLocalInternal(context.client, input, global_state_p);
-}
-
-void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	if (!data_p.local_state) {
-		return;
-	}
-	auto &data = data_p.bind_data->CastNoConst<ArrowScanFunctionData>(); // FIXME
-	auto &state = data_p.local_state->Cast<ArrowScanLocalState>();
-	auto &global_state = data_p.global_state->Cast<ArrowScanGlobalState>();
-
-	//! Out of tuples in this chunk
-	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
-		if (!ArrowScanParallelStateNext(context, data_p.bind_data.get(), state, global_state)) {
-			return;
-		}
-	}
-	auto output_size =
-	    MinValue<idx_t>(STANDARD_VECTOR_SIZE, NumericCast<idx_t>(state.chunk->arrow_array.length) - state.chunk_offset);
-	data.lines_read += output_size;
-	if (global_state.CanRemoveFilterColumns()) {
-		state.all_columns.Reset();
-		state.all_columns.SetCardinality(output_size);
-		ArrowToDuckDB(state, data.arrow_table.GetColumns(), state.all_columns, data.lines_read - output_size);
-		output.ReferenceColumns(state.all_columns, global_state.projection_ids);
-	} else {
-		output.SetCardinality(output_size);
-		ArrowToDuckDB(state, data.arrow_table.GetColumns(), output, data.lines_read - output_size);
-	}
-
-	output.Verify();
-	state.chunk_offset += output.size();
-}
-
-unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContext &context, const FunctionData *data) {
-	return make_uniq<NodeStatistics>();
-}
-
-OperatorPartitionData ArrowTableFunction::ArrowGetPartitionData(ClientContext &context,
-                                                                TableFunctionGetPartitionInput &input) {
-	if (input.partition_info.RequiresPartitionColumns()) {
-		throw InternalException("ArrowTableFunction::GetPartitionData: partition columns not supported");
-	}
-	auto &state = input.local_state->Cast<ArrowScanLocalState>();
-	return OperatorPartitionData(state.batch_index);
-}
-
-bool ArrowTableFunction::ArrowPushdownType(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
-		return true;
-	case LogicalTypeId::DECIMAL: {
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-		case PhysicalType::INT64:
-			return true;
-		default:
-			return false;
-		}
-	} break;
-	case LogicalTypeId::STRUCT: {
-		auto struct_types = StructType::GetChildTypes(type);
-		for (auto &struct_type : struct_types) {
-			if (!ArrowPushdownType(struct_type.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return false;
-	}
-}
-
-void ArrowTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction arrow("arrow_scan", {LogicalType::POINTER, LogicalType::POINTER, LogicalType::POINTER},
-	                    ArrowScanFunction, ArrowScanBind, ArrowScanInitGlobal, ArrowScanInitLocal);
-	arrow.cardinality = ArrowScanCardinality;
-	arrow.get_partition_data = ArrowGetPartitionData;
-	arrow.projection_pushdown = true;
-	arrow.filter_pushdown = true;
-	arrow.filter_prune = true;
-	arrow.supports_pushdown_type = ArrowPushdownType;
-	set.AddFunction(arrow);
-
-	TableFunction arrow_dumb("arrow_scan_dumb", {LogicalType::POINTER, LogicalType::POINTER, LogicalType::POINTER},
-	                         ArrowScanFunction, ArrowScanBindDumb, ArrowScanInitGlobal, ArrowScanInitLocal);
-	arrow_dumb.cardinality = ArrowScanCardinality;
-	arrow_dumb.get_partition_data = ArrowGetPartitionData;
-	arrow_dumb.projection_pushdown = false;
-	arrow_dumb.filter_pushdown = false;
-	arrow_dumb.filter_prune = false;
-	set.AddFunction(arrow_dumb);
-}
-
-void BuiltinFunctions::RegisterArrowFunctions() {
-	ArrowTableFunction::RegisterFunction(*this);
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp b/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp
deleted file mode 100644
index 749ebc29c..000000000
--- a/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/function/table/arrow.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/types/arrow_aux_data.hpp"
-
-namespace duckdb {
-
-ArrowArrayScanState::ArrowArrayScanState(ArrowScanLocalState &state) : state(state) {
-	arrow_dictionary = nullptr;
-}
-
-ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) {
-	auto it = children.find(child_idx);
-	if (it == children.end()) {
-		auto child_p = make_uniq<ArrowArrayScanState>(state);
-		auto &child = *child_p;
-		child.owned_data = owned_data;
-		children.emplace(child_idx, std::move(child_p));
-		return child;
-	}
-	if (!it->second->owned_data) {
-		// Propagate down the ownership, for dictionaries in children
-		D_ASSERT(owned_data);
-		it->second->owned_data = owned_data;
-	}
-	return *it->second;
-}
-
-void ArrowArrayScanState::AddDictionary(unique_ptr<Vector> dictionary_p, ArrowArray *arrow_dict) {
-	dictionary = std::move(dictionary_p);
-	D_ASSERT(owned_data);
-	D_ASSERT(arrow_dict);
-	arrow_dictionary = arrow_dict;
-	// Make sure the data referenced by the dictionary stays alive
-	dictionary->GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(owned_data));
-}
-
-bool ArrowArrayScanState::HasDictionary() const {
-	return dictionary != nullptr;
-}
-
-bool ArrowArrayScanState::CacheOutdated(ArrowArray *dictionary) const {
-	if (!dictionary) {
-		// Not cached
-		return true;
-	}
-	if (dictionary == arrow_dictionary.get()) {
-		// Already cached, not outdated
-		return false;
-	}
-	return true;
-}
-
-Vector &ArrowArrayScanState::GetDictionary() {
-	D_ASSERT(HasDictionary());
-	return *dictionary;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp b/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp
deleted file mode 100644
index 3f23e94ee..000000000
--- a/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-void ArrowTableType::AddColumn(idx_t index, unique_ptr<ArrowType> type) {
-	D_ASSERT(arrow_convert_data.find(index) == arrow_convert_data.end());
-	arrow_convert_data.emplace(std::make_pair(index, std::move(type)));
-}
-
-const arrow_column_map_t &ArrowTableType::GetColumns() const {
-	return arrow_convert_data;
-}
-
-void ArrowType::SetDictionary(unique_ptr<ArrowType> dictionary) {
-	D_ASSERT(!this->dictionary_type);
-	dictionary_type = std::move(dictionary);
-}
-
-bool ArrowType::HasDictionary() const {
-	return dictionary_type != nullptr;
-}
-
-const ArrowType &ArrowType::GetDictionary() const {
-	D_ASSERT(dictionary_type);
-	return *dictionary_type;
-}
-
-void ArrowType::SetRunEndEncoded() {
-	D_ASSERT(type_info);
-	D_ASSERT(type_info->type == ArrowTypeInfoType::STRUCT);
-	auto &struct_info = type_info->Cast<ArrowStructInfo>();
-	D_ASSERT(struct_info.ChildCount() == 2);
-
-	auto actual_type = struct_info.GetChild(1).GetDuckType();
-	// Override the duckdb type to the actual type
-	type = actual_type;
-	run_end_encoded = true;
-}
-
-bool ArrowType::RunEndEncoded() const {
-	return run_end_encoded;
-}
-
-void ArrowType::ThrowIfInvalid() const {
-	if (type.id() == LogicalTypeId::INVALID) {
-		if (not_implemented) {
-			throw NotImplementedException(error_message);
-		}
-		throw InvalidInputException(error_message);
-	}
-}
-
-LogicalType ArrowType::GetDuckType(bool use_dictionary) const {
-	if (use_dictionary && dictionary_type) {
-		return dictionary_type->GetDuckType();
-	}
-	if (!use_dictionary) {
-		return type;
-	}
-	// Dictionaries can exist in arbitrarily nested schemas
-	// have to reconstruct the type
-	auto id = type.id();
-	switch (id) {
-	case LogicalTypeId::STRUCT: {
-		auto &struct_info = type_info->Cast<ArrowStructInfo>();
-		child_list_t<LogicalType> new_children;
-		for (idx_t i = 0; i < struct_info.ChildCount(); i++) {
-			auto &child = struct_info.GetChild(i);
-			auto &child_name = StructType::GetChildName(type, i);
-			new_children.emplace_back(std::make_pair(child_name, child.GetDuckType(true)));
-		}
-		return LogicalType::STRUCT(std::move(new_children));
-	}
-	case LogicalTypeId::LIST: {
-		auto &list_info = type_info->Cast<ArrowListInfo>();
-		auto &child = list_info.GetChild();
-		return LogicalType::LIST(child.GetDuckType(true));
-	}
-	case LogicalTypeId::MAP: {
-		auto &list_info = type_info->Cast<ArrowListInfo>();
-		auto &struct_child = list_info.GetChild();
-		auto struct_type = struct_child.GetDuckType(true);
-		return LogicalType::MAP(StructType::GetChildType(struct_type, 0), StructType::GetChildType(struct_type, 1));
-	}
-	case LogicalTypeId::UNION: {
-		auto &union_info = type_info->Cast<ArrowStructInfo>();
-		child_list_t<LogicalType> new_children;
-		for (idx_t i = 0; i < union_info.ChildCount(); i++) {
-			auto &child = union_info.GetChild(i);
-			auto &child_name = UnionType::GetMemberName(type, i);
-			new_children.emplace_back(std::make_pair(child_name, child.GetDuckType(true)));
-		}
-		return LogicalType::UNION(std::move(new_children));
-	}
-	default: {
-		return type;
-	}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/arrow/arrow_type_info.cpp b/src/duckdb/src/function/table/arrow/arrow_type_info.cpp
deleted file mode 100644
index e012f1b5c..000000000
--- a/src/duckdb/src/function/table/arrow/arrow_type_info.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/function/table/arrow/arrow_type_info.hpp"
-#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// ArrowTypeInfo
-//===--------------------------------------------------------------------===//
-
-ArrowTypeInfo::ArrowTypeInfo(ArrowTypeInfoType type) : type(type) {
-}
-
-ArrowTypeInfo::~ArrowTypeInfo() {
-}
-
-//===--------------------------------------------------------------------===//
-// ArrowStructInfo
-//===--------------------------------------------------------------------===//
-
-ArrowStructInfo::ArrowStructInfo(vector<unique_ptr<ArrowType>> children)
-    : ArrowTypeInfo(ArrowTypeInfoType::STRUCT), children(std::move(children)) {
-}
-
-idx_t ArrowStructInfo::ChildCount() const {
-	return children.size();
-}
-
-ArrowStructInfo::~ArrowStructInfo() {
-}
-
-const ArrowType &ArrowStructInfo::GetChild(idx_t index) const {
-	D_ASSERT(index < children.size());
-	return *children[index];
-}
-
-const vector<unique_ptr<ArrowType>> &ArrowStructInfo::GetChildren() const {
-	return children;
-}
-
-//===--------------------------------------------------------------------===//
-// ArrowDateTimeInfo
-//===--------------------------------------------------------------------===//
-
-ArrowDateTimeInfo::ArrowDateTimeInfo(ArrowDateTimeType size)
-    : ArrowTypeInfo(ArrowTypeInfoType::DATE_TIME), size_type(size) {
-}
-
-ArrowDateTimeInfo::~ArrowDateTimeInfo() {
-}
-
-ArrowDateTimeType ArrowDateTimeInfo::GetDateTimeType() const {
-	return size_type;
-}
-
-//===--------------------------------------------------------------------===//
-// ArrowStringInfo
-//===--------------------------------------------------------------------===//
-
-ArrowStringInfo::ArrowStringInfo(ArrowVariableSizeType size)
-    : ArrowTypeInfo(ArrowTypeInfoType::STRING), size_type(size), fixed_size(0) {
-	D_ASSERT(size != ArrowVariableSizeType::FIXED_SIZE);
-}
-
-ArrowStringInfo::~ArrowStringInfo() {
-}
-
-ArrowStringInfo::ArrowStringInfo(idx_t fixed_size)
-    : ArrowTypeInfo(ArrowTypeInfoType::STRING), size_type(ArrowVariableSizeType::FIXED_SIZE), fixed_size(fixed_size) {
-}
-
-ArrowVariableSizeType ArrowStringInfo::GetSizeType() const {
-	return size_type;
-}
-
-idx_t ArrowStringInfo::FixedSize() const {
-	D_ASSERT(size_type == ArrowVariableSizeType::FIXED_SIZE);
-	return fixed_size;
-}
-
-//===--------------------------------------------------------------------===//
-// ArrowListInfo
-//===--------------------------------------------------------------------===//
-
-ArrowListInfo::ArrowListInfo(unique_ptr<ArrowType> child, ArrowVariableSizeType size)
-    : ArrowTypeInfo(ArrowTypeInfoType::LIST), size_type(size), child(std::move(child)) {
-}
-
-ArrowListInfo::~ArrowListInfo() {
-}
-
-unique_ptr<ArrowListInfo> ArrowListInfo::ListView(unique_ptr<ArrowType> child, ArrowVariableSizeType size) {
-	D_ASSERT(size == ArrowVariableSizeType::SUPER_SIZE || size == ArrowVariableSizeType::NORMAL);
-	auto list_info = unique_ptr<ArrowListInfo>(new ArrowListInfo(std::move(child), size));
-	list_info->is_view = true;
-	return list_info;
-}
-
-unique_ptr<ArrowListInfo> ArrowListInfo::List(unique_ptr<ArrowType> child, ArrowVariableSizeType size) {
-	D_ASSERT(size == ArrowVariableSizeType::SUPER_SIZE || size == ArrowVariableSizeType::NORMAL);
-	return unique_ptr<ArrowListInfo>(new ArrowListInfo(std::move(child), size));
-}
-
-ArrowVariableSizeType ArrowListInfo::GetSizeType() const {
-	return size_type;
-}
-
-bool ArrowListInfo::IsView() const {
-	return is_view;
-}
-
-ArrowType &ArrowListInfo::GetChild() const {
-	return *child;
-}
-
-//===--------------------------------------------------------------------===//
-// ArrowArrayInfo
-//===--------------------------------------------------------------------===//
-
-ArrowArrayInfo::ArrowArrayInfo(unique_ptr<ArrowType> child, idx_t fixed_size)
-    : ArrowTypeInfo(ArrowTypeInfoType::ARRAY), child(std::move(child)), fixed_size(fixed_size) {
-	D_ASSERT(fixed_size > 0);
-}
-
-ArrowArrayInfo::~ArrowArrayInfo() {
-}
-
-idx_t ArrowArrayInfo::FixedSize() const {
-	return fixed_size;
-}
-
-ArrowType &ArrowArrayInfo::GetChild() const {
-	return *child;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/arrow_conversion.cpp b/src/duckdb/src/function/table/arrow_conversion.cpp
deleted file mode 100644
index e09f81aac..000000000
--- a/src/duckdb/src/function/table/arrow_conversion.cpp
+++ /dev/null
@@ -1,1416 +0,0 @@
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/types/arrow_aux_data.hpp"
-#include "duckdb/common/types/arrow_string_view_type.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/table/arrow.hpp"
-
-#include "duckdb/common/bswap.hpp"
-
-namespace duckdb {
-
-namespace {
-
-enum class ArrowArrayPhysicalType : uint8_t { DICTIONARY_ENCODED, RUN_END_ENCODED, DEFAULT };
-
-ArrowArrayPhysicalType GetArrowArrayPhysicalType(const ArrowType &type) {
-	if (type.HasDictionary()) {
-		return ArrowArrayPhysicalType::DICTIONARY_ENCODED;
-	}
-	if (type.RunEndEncoded()) {
-		return ArrowArrayPhysicalType::RUN_END_ENCODED;
-	}
-	return ArrowArrayPhysicalType::DEFAULT;
-}
-
-} // namespace
-
-#if STANDARD_VECTOR_SIZE > 64
-static void ShiftRight(unsigned char *ar, int size, int shift) {
-	int carry = 0;
-	while (shift--) {
-		for (int i = size - 1; i >= 0; --i) {
-			int next = (ar[i] & 1) ? 0x80 : 0;
-			ar[i] = UnsafeNumericCast<unsigned char>(carry | (ar[i] >> 1));
-			carry = next;
-		}
-	}
-}
-#endif
-
-idx_t GetEffectiveOffset(const ArrowArray &array, int64_t parent_offset, const ArrowScanLocalState &state,
-                         int64_t nested_offset = -1) {
-	if (nested_offset != -1) {
-		// The parent of this array is a list
-		// We just ignore the parent offset, it's already applied to the list
-		return UnsafeNumericCast<idx_t>(array.offset + nested_offset);
-	}
-	// Parent offset is set in the case of a struct, it applies to all child arrays
-	// 'chunk_offset' is how much of the chunk we've already scanned, in case the chunk size exceeds
-	// STANDARD_VECTOR_SIZE
-	return UnsafeNumericCast<idx_t>(array.offset + parent_offset) + state.chunk_offset;
-}
-
-template <class T>
-T *ArrowBufferData(ArrowArray &array, idx_t buffer_idx) {
-	return (T *)array.buffers[buffer_idx]; // NOLINT
-}
-
-static void GetValidityMask(ValidityMask &mask, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size,
-                            int64_t parent_offset, int64_t nested_offset = -1, bool add_null = false) {
-	// In certains we don't need to or cannot copy arrow's validity mask to duckdb.
-	//
-	// The conditions where we do want to copy arrow's mask to duckdb are:
-	// 1. nulls exist
-	// 2. n_buffers > 0, meaning the array's arrow type is not `null`
-	// 3. the validity buffer (the first buffer) is not a nullptr
-	if (array.null_count != 0 && array.n_buffers > 0 && array.buffers[0]) {
-		auto bit_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-		mask.EnsureWritable();
-#if STANDARD_VECTOR_SIZE > 64
-		auto n_bitmask_bytes = (size + 8 - 1) / 8;
-		if (bit_offset % 8 == 0) {
-			//! just memcpy nullmask
-			memcpy((void *)mask.GetData(), ArrowBufferData<uint8_t>(array, 0) + bit_offset / 8, n_bitmask_bytes);
-		} else {
-			//! need to re-align nullmask
-			vector<uint8_t> temp_nullmask(n_bitmask_bytes + 1);
-			memcpy(temp_nullmask.data(), ArrowBufferData<uint8_t>(array, 0) + bit_offset / 8, n_bitmask_bytes + 1);
-			ShiftRight(temp_nullmask.data(), NumericCast<int>(n_bitmask_bytes + 1),
-			           NumericCast<int>(bit_offset % 8ull)); //! why this has to be a right shift is a mystery to me
-			memcpy((void *)mask.GetData(), data_ptr_cast(temp_nullmask.data()), n_bitmask_bytes);
-		}
-#else
-		auto byte_offset = bit_offset / 8;
-		auto source_data = ArrowBufferData<uint8_t>(array, 0);
-		bit_offset %= 8;
-		for (idx_t i = 0; i < size; i++) {
-			mask.Set(i, source_data[byte_offset] & (1 << bit_offset));
-			bit_offset++;
-			if (bit_offset == 8) {
-				bit_offset = 0;
-				byte_offset++;
-			}
-		}
-#endif
-	}
-	if (add_null) {
-		//! We are setting a validity mask of the data part of dictionary vector
-		//! For some reason, Nulls are allowed to be indexes, hence we need to set the last element here to be null
-		//! We might have to resize the mask
-		mask.Resize(size + 1);
-		mask.SetInvalid(size);
-	}
-}
-
-static void SetValidityMask(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size,
-                            int64_t parent_offset, int64_t nested_offset, bool add_null = false) {
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto &mask = FlatVector::Validity(vector);
-	GetValidityMask(mask, array, scan_state, size, parent_offset, nested_offset, add_null);
-}
-
-static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &array, ArrowArrayScanState &array_state,
-                                             idx_t size, const ArrowType &arrow_type, int64_t nested_offset = -1,
-                                             ValidityMask *parent_mask = nullptr, uint64_t parent_offset = 0);
-
-static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                                const ArrowType &arrow_type, int64_t nested_offset = -1,
-                                ValidityMask *parent_mask = nullptr, uint64_t parent_offset = 0);
-
-static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state,
-                                          idx_t size, const ArrowType &arrow_type, int64_t nested_offset = -1,
-                                          const ValidityMask *parent_mask = nullptr, uint64_t parent_offset = 0);
-
-namespace {
-
-struct ArrowListOffsetData {
-	idx_t list_size = 0;
-	idx_t start_offset = 0;
-};
-
-} // namespace
-
-template <class BUFFER_TYPE>
-static ArrowListOffsetData ConvertArrowListOffsetsTemplated(Vector &vector, ArrowArray &array, idx_t size,
-                                                            idx_t effective_offset) {
-	ArrowListOffsetData result;
-	auto &start_offset = result.start_offset;
-	auto &list_size = result.list_size;
-
-	if (size == 0) {
-		start_offset = 0;
-		list_size = 0;
-		return result;
-	}
-
-	idx_t cur_offset = 0;
-	auto offsets = ArrowBufferData<BUFFER_TYPE>(array, 1) + effective_offset;
-	start_offset = offsets[0];
-	auto list_data = FlatVector::GetData<list_entry_t>(vector);
-	for (idx_t i = 0; i < size; i++) {
-		auto &le = list_data[i];
-		le.offset = cur_offset;
-		le.length = offsets[i + 1] - offsets[i];
-		cur_offset += le.length;
-	}
-	list_size = offsets[size];
-	list_size -= start_offset;
-	return result;
-}
-
-template <class BUFFER_TYPE>
-static ArrowListOffsetData ConvertArrowListViewOffsetsTemplated(Vector &vector, ArrowArray &array, idx_t size,
-                                                                idx_t effective_offset) {
-	ArrowListOffsetData result;
-	auto &start_offset = result.start_offset;
-	auto &list_size = result.list_size;
-
-	list_size = 0;
-	auto offsets = ArrowBufferData<BUFFER_TYPE>(array, 1) + effective_offset;
-	auto sizes = ArrowBufferData<BUFFER_TYPE>(array, 2) + effective_offset;
-
-	// In ListArrays the offsets have to be sequential
-	// ListViewArrays do not have this same constraint
-	// for that reason we need to keep track of the lowest offset, so we can skip all the data that comes before it
-	// when we scan the child data
-
-	auto lowest_offset = size ? offsets[0] : 0;
-	auto list_data = FlatVector::GetData<list_entry_t>(vector);
-	for (idx_t i = 0; i < size; i++) {
-		auto &le = list_data[i];
-		le.offset = offsets[i];
-		le.length = sizes[i];
-		list_size += le.length;
-		if (sizes[i] != 0) {
-			lowest_offset = MinValue(lowest_offset, offsets[i]);
-		}
-	}
-	start_offset = lowest_offset;
-	if (start_offset) {
-		// We start scanning the child data at the 'start_offset' so we need to fix up the created list entries
-		for (idx_t i = 0; i < size; i++) {
-			auto &le = list_data[i];
-			le.offset = le.offset <= start_offset ? 0 : le.offset - start_offset;
-		}
-	}
-	return result;
-}
-
-static ArrowListOffsetData ConvertArrowListOffsets(Vector &vector, ArrowArray &array, idx_t size,
-                                                   const ArrowType &arrow_type, idx_t effective_offset) {
-	auto &list_info = arrow_type.GetTypeInfo<ArrowListInfo>();
-	auto size_type = list_info.GetSizeType();
-	if (list_info.IsView()) {
-		if (size_type == ArrowVariableSizeType::NORMAL) {
-			return ConvertArrowListViewOffsetsTemplated<uint32_t>(vector, array, size, effective_offset);
-		} else {
-			D_ASSERT(size_type == ArrowVariableSizeType::SUPER_SIZE);
-			return ConvertArrowListViewOffsetsTemplated<uint64_t>(vector, array, size, effective_offset);
-		}
-	} else {
-		if (size_type == ArrowVariableSizeType::NORMAL) {
-			return ConvertArrowListOffsetsTemplated<uint32_t>(vector, array, size, effective_offset);
-		} else {
-			D_ASSERT(size_type == ArrowVariableSizeType::SUPER_SIZE);
-			return ConvertArrowListOffsetsTemplated<uint64_t>(vector, array, size, effective_offset);
-		}
-	}
-}
-
-static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                              const ArrowType &arrow_type, int64_t nested_offset, const ValidityMask *parent_mask,
-                              int64_t parent_offset) {
-	auto &scan_state = array_state.state;
-
-	auto &list_info = arrow_type.GetTypeInfo<ArrowListInfo>();
-	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
-
-	auto effective_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	auto list_data = ConvertArrowListOffsets(vector, array, size, arrow_type, effective_offset);
-	auto &start_offset = list_data.start_offset;
-	auto &list_size = list_data.list_size;
-
-	ListVector::Reserve(vector, list_size);
-	ListVector::SetListSize(vector, list_size);
-	auto &child_vector = ListVector::GetEntry(vector);
-	SetValidityMask(child_vector, *array.children[0], scan_state, list_size, array.offset,
-	                NumericCast<int64_t>(start_offset));
-	auto &list_mask = FlatVector::Validity(vector);
-	if (parent_mask) {
-		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
-		if (!parent_mask->AllValid()) {
-			for (idx_t i = 0; i < size; i++) {
-				if (!parent_mask->RowIsValid(i)) {
-					list_mask.SetInvalid(i);
-				}
-			}
-		}
-	}
-	auto &child_state = array_state.GetChild(0);
-	auto &child_array = *array.children[0];
-	auto &child_type = list_info.GetChild();
-
-	if (list_size == 0 && start_offset == 0) {
-		D_ASSERT(!child_array.dictionary);
-		ColumnArrowToDuckDB(child_vector, child_array, child_state, list_size, child_type, -1);
-		return;
-	}
-
-	auto array_physical_type = GetArrowArrayPhysicalType(child_type);
-	switch (array_physical_type) {
-	case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-		// TODO: add support for offsets
-		ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, list_size, child_type,
-		                              NumericCast<int64_t>(start_offset));
-		break;
-	case ArrowArrayPhysicalType::RUN_END_ENCODED:
-		ColumnArrowToDuckDBRunEndEncoded(child_vector, child_array, child_state, list_size, child_type,
-		                                 NumericCast<int64_t>(start_offset));
-		break;
-	case ArrowArrayPhysicalType::DEFAULT:
-		ColumnArrowToDuckDB(child_vector, child_array, child_state, list_size, child_type,
-		                    NumericCast<int64_t>(start_offset));
-		break;
-	default:
-		throw NotImplementedException("ArrowArrayPhysicalType not recognized");
-	}
-}
-
-static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                               const ArrowType &arrow_type, int64_t nested_offset, const ValidityMask *parent_mask,
-                               int64_t parent_offset) {
-
-	auto &array_info = arrow_type.GetTypeInfo<ArrowArrayInfo>();
-	auto &scan_state = array_state.state;
-	auto array_size = array_info.FixedSize();
-	auto child_count = array_size * size;
-	auto child_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * array_size;
-
-	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
-
-	auto &child_vector = ArrayVector::GetEntry(vector);
-	SetValidityMask(child_vector, *array.children[0], scan_state, child_count, array.offset,
-	                NumericCast<int64_t>(child_offset));
-
-	auto &array_mask = FlatVector::Validity(vector);
-	if (parent_mask) {
-		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
-		if (!parent_mask->AllValid()) {
-			for (idx_t i = 0; i < size; i++) {
-				if (!parent_mask->RowIsValid(i)) {
-					array_mask.SetInvalid(i);
-				}
-			}
-		}
-	}
-
-	// Broadcast the validity mask to the child vector
-	if (!array_mask.AllValid()) {
-		auto &child_validity_mask = FlatVector::Validity(child_vector);
-		for (idx_t i = 0; i < size; i++) {
-			if (!array_mask.RowIsValid(i)) {
-				for (idx_t j = 0; j < array_size; j++) {
-					child_validity_mask.SetInvalid(i * array_size + j);
-				}
-			}
-		}
-	}
-
-	auto &child_state = array_state.GetChild(0);
-	auto &child_array = *array.children[0];
-	auto &child_type = array_info.GetChild();
-	if (child_count == 0 && child_offset == 0) {
-		D_ASSERT(!child_array.dictionary);
-		ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, -1);
-	} else {
-		if (child_array.dictionary) {
-			ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, child_count, child_type,
-			                              NumericCast<int64_t>(child_offset));
-		} else {
-			ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type,
-			                    NumericCast<int64_t>(child_offset));
-		}
-	}
-}
-
-static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size,
-                              const ArrowType &arrow_type, int64_t nested_offset, int64_t parent_offset) {
-	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
-	auto &string_info = arrow_type.GetTypeInfo<ArrowStringInfo>();
-	auto size_type = string_info.GetSizeType();
-	if (size_type == ArrowVariableSizeType::FIXED_SIZE) {
-		auto fixed_size = string_info.FixedSize();
-		//! Have to check validity mask before setting this up
-		idx_t offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * fixed_size;
-		auto cdata = ArrowBufferData<char>(array, 1);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offset;
-			auto blob_len = fixed_size;
-			FlatVector::GetData<string_t>(vector)[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-			offset += blob_len;
-		}
-	} else if (size_type == ArrowVariableSizeType::NORMAL) {
-		auto offsets =
-		    ArrowBufferData<uint32_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-		auto cdata = ArrowBufferData<char>(array, 2);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offsets[row_idx];
-			auto blob_len = offsets[row_idx + 1] - offsets[row_idx];
-			FlatVector::GetData<string_t>(vector)[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-		}
-	} else {
-		//! Check if last offset is higher than max uint32
-		if (ArrowBufferData<uint64_t>(array, 1)[array.length] > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
-			throw ConversionException("DuckDB does not support Blobs over 4GB");
-		} // LCOV_EXCL_STOP
-		auto offsets =
-		    ArrowBufferData<uint64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-		auto cdata = ArrowBufferData<char>(array, 2);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offsets[row_idx];
-			auto blob_len = offsets[row_idx + 1] - offsets[row_idx];
-			FlatVector::GetData<string_t>(vector)[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-		}
-	}
-}
-
-static void ArrowToDuckDBMapVerify(Vector &vector, idx_t count) {
-	auto valid_check = MapVector::CheckMapValidity(vector, count);
-	switch (valid_check) {
-	case MapInvalidReason::VALID:
-		break;
-	case MapInvalidReason::DUPLICATE_KEY: {
-		throw InvalidInputException("Arrow map contains duplicate key, which isn't supported by DuckDB map type");
-	}
-	case MapInvalidReason::NULL_KEY: {
-		throw InvalidInputException("Arrow map contains NULL as map key, which isn't supported by DuckDB map type");
-	}
-	default: {
-		throw InternalException("MapInvalidReason not implemented");
-	}
-	}
-}
-
-template <class T>
-static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets) {
-	auto strings = FlatVector::GetData<string_t>(vector);
-	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-		if (FlatVector::IsNull(vector, row_idx)) {
-			continue;
-		}
-		auto cptr = cdata + offsets[row_idx];
-		auto str_len = offsets[row_idx + 1] - offsets[row_idx];
-		if (str_len > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
-			throw ConversionException("DuckDB does not support Strings over 4GB");
-		} // LCOV_EXCL_STOP
-		strings[row_idx] = string_t(cptr, UnsafeNumericCast<uint32_t>(str_len));
-	}
-}
-
-static void SetVectorStringView(Vector &vector, idx_t size, ArrowArray &array, idx_t current_pos) {
-	auto strings = FlatVector::GetData<string_t>(vector);
-	auto arrow_string = ArrowBufferData<arrow_string_view_t>(array, 1) + current_pos;
-
-	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-		if (FlatVector::IsNull(vector, row_idx)) {
-			continue;
-		}
-		auto length = UnsafeNumericCast<uint32_t>(arrow_string[row_idx].Length());
-		if (arrow_string[row_idx].IsInline()) {
-			//	This string is inlined
-			//  | Bytes 0-3  | Bytes 4-15                            |
-			//  |------------|---------------------------------------|
-			//  | length     | data (padded with 0)                  |
-			strings[row_idx] = string_t(arrow_string[row_idx].GetInlineData(), length);
-		} else {
-			//  This string is not inlined, we have to check a different buffer and offsets
-			//  | Bytes 0-3  | Bytes 4-7  | Bytes 8-11 | Bytes 12-15 |
-			//  |------------|------------|------------|-------------|
-			//  | length     | prefix     | buf. index | offset      |
-			auto buffer_index = UnsafeNumericCast<uint32_t>(arrow_string[row_idx].GetBufferIndex());
-			int32_t offset = arrow_string[row_idx].GetOffset();
-			D_ASSERT(array.n_buffers > 2 + buffer_index);
-			auto c_data = ArrowBufferData<char>(array, 2 + buffer_index);
-			strings[row_idx] = string_t(&c_data[offset], length);
-		}
-	}
-}
-
-static void DirectConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                             int64_t nested_offset, uint64_t parent_offset) {
-	auto internal_type = GetTypeIdSize(vector.GetType().InternalType());
-	auto data_ptr =
-	    ArrowBufferData<data_t>(array, 1) +
-	    internal_type * GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-	FlatVector::SetData(vector, data_ptr);
-}
-
-template <class T>
-static void TimeConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                           int64_t nested_offset, int64_t parent_offset, idx_t size, int64_t conversion) {
-	auto tgt_ptr = FlatVector::GetData<dtime_t>(vector);
-	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr =
-	    static_cast<const T *>(array.buffers[1]) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	for (idx_t row = 0; row < size; row++) {
-		if (!validity_mask.RowIsValid(row)) {
-			continue;
-		}
-		if (!TryMultiplyOperator::Operation(static_cast<int64_t>(src_ptr[row]), conversion, tgt_ptr[row].micros)) {
-			throw ConversionException("Could not convert Time to Microsecond");
-		}
-	}
-}
-
-static void UUIDConversion(Vector &vector, const ArrowArray &array, const ArrowScanLocalState &scan_state,
-                           int64_t nested_offset, int64_t parent_offset, idx_t size) {
-	auto tgt_ptr = FlatVector::GetData<hugeint_t>(vector);
-	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr = static_cast<const hugeint_t *>(array.buffers[1]) +
-	               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	for (idx_t row = 0; row < size; row++) {
-		if (!validity_mask.RowIsValid(row)) {
-			continue;
-		}
-		tgt_ptr[row].lower = static_cast<uint64_t>(BSwap(src_ptr[row].upper));
-		// flip Upper MSD
-		tgt_ptr[row].upper =
-		    static_cast<int64_t>(static_cast<uint64_t>(BSwap(src_ptr[row].lower)) ^ (static_cast<uint64_t>(1) << 63));
-	}
-}
-
-static void TimestampTZConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                  int64_t nested_offset, int64_t parent_offset, idx_t size, int64_t conversion) {
-	auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
-	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr =
-	    ArrowBufferData<int64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	for (idx_t row = 0; row < size; row++) {
-		if (!validity_mask.RowIsValid(row)) {
-			continue;
-		}
-		if (!TryMultiplyOperator::Operation(src_ptr[row], conversion, tgt_ptr[row].value)) {
-			throw ConversionException("Could not convert TimestampTZ to Microsecond");
-		}
-	}
-}
-
-static void IntervalConversionUs(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                 int64_t nested_offset, int64_t parent_offset, idx_t size, int64_t conversion) {
-	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
-	auto src_ptr =
-	    ArrowBufferData<int64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	for (idx_t row = 0; row < size; row++) {
-		tgt_ptr[row].days = 0;
-		tgt_ptr[row].months = 0;
-		if (!TryMultiplyOperator::Operation(src_ptr[row], conversion, tgt_ptr[row].micros)) {
-			throw ConversionException("Could not convert Interval to Microsecond");
-		}
-	}
-}
-
-static void IntervalConversionMonths(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                     int64_t nested_offset, int64_t parent_offset, idx_t size) {
-	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
-	auto src_ptr =
-	    ArrowBufferData<int32_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	for (idx_t row = 0; row < size; row++) {
-		tgt_ptr[row].days = 0;
-		tgt_ptr[row].micros = 0;
-		tgt_ptr[row].months = src_ptr[row];
-	}
-}
-
-static void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                            int64_t nested_offset, int64_t parent_offset, idx_t size) {
-	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
-	auto src_ptr =
-	    ArrowBufferData<ArrowInterval>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-	for (idx_t row = 0; row < size; row++) {
-		tgt_ptr[row].days = src_ptr[row].days;
-		tgt_ptr[row].micros = src_ptr[row].nanoseconds / Interval::NANOS_PER_MICRO;
-		tgt_ptr[row].months = src_ptr[row].months;
-	}
-}
-
-// Find the index of the first run-end that is strictly greater than the offset.
-// count is returned if no such run-end is found.
-template <class RUN_END_TYPE>
-static idx_t FindRunIndex(const RUN_END_TYPE *run_ends, idx_t count, idx_t offset) {
-	// Binary-search within the [0, count) range. For example:
-	// [0, 0, 0, 1, 1, 2] encoded as
-	// run_ends: [3, 5, 6]:
-	// 0, 1, 2 -> 0
-	//    3, 4 -> 1
-	//       5 -> 2
-	// 6, 7 .. -> 3 (3 == count [not found])
-	idx_t begin = 0;
-	idx_t end = count;
-	while (begin < end) {
-		idx_t middle = (begin + end) / 2;
-		// begin < end implies middle < end
-		if (offset >= static_cast<idx_t>(run_ends[middle])) {
-			// keep searching in [middle + 1, end)
-			begin = middle + 1;
-		} else {
-			// offset < run_ends[middle], so keep searching in [begin, middle)
-			end = middle;
-		}
-	}
-	return begin;
-}
-
-template <class RUN_END_TYPE, class VALUE_TYPE>
-static void FlattenRunEnds(Vector &result, ArrowRunEndEncodingState &run_end_encoding, idx_t compressed_size,
-                           idx_t scan_offset, idx_t count) {
-	auto &runs = *run_end_encoding.run_ends;
-	auto &values = *run_end_encoding.values;
-
-	UnifiedVectorFormat run_end_format;
-	UnifiedVectorFormat value_format;
-	runs.ToUnifiedFormat(compressed_size, run_end_format);
-	values.ToUnifiedFormat(compressed_size, value_format);
-	auto run_ends_data = run_end_format.GetData<RUN_END_TYPE>(run_end_format);
-	auto values_data = value_format.GetData<VALUE_TYPE>(value_format);
-	auto result_data = FlatVector::GetData<VALUE_TYPE>(result);
-	auto &validity = FlatVector::Validity(result);
-
-	// According to the arrow spec, the 'run_ends' array is always valid
-	// so we will assume this is true and not check the validity map
-
-	// Now construct the result vector from the run_ends and the values
-
-	auto run = FindRunIndex(run_ends_data, compressed_size, scan_offset);
-	idx_t logical_index = scan_offset;
-	idx_t index = 0;
-	if (value_format.validity.AllValid()) {
-		// None of the compressed values are NULL
-		for (; run < compressed_size; ++run) {
-			auto run_end_index = run_end_format.sel->get_index(run);
-			auto value_index = value_format.sel->get_index(run);
-			auto &value = values_data[value_index];
-			auto run_end = static_cast<idx_t>(run_ends_data[run_end_index]);
-
-			D_ASSERT(run_end > (logical_index + index));
-			auto to_scan = run_end - (logical_index + index);
-			// Cap the amount to scan so we don't go over size
-			to_scan = MinValue<idx_t>(to_scan, (count - index));
-
-			for (idx_t i = 0; i < to_scan; i++) {
-				result_data[index + i] = value;
-			}
-			index += to_scan;
-			if (index >= count) {
-				if (logical_index + index >= run_end) {
-					// The last run was completed, forward the run index
-					++run;
-				}
-				break;
-			}
-		}
-	} else {
-		for (; run < compressed_size; ++run) {
-			auto run_end_index = run_end_format.sel->get_index(run);
-			auto value_index = value_format.sel->get_index(run);
-			auto run_end = static_cast<idx_t>(run_ends_data[run_end_index]);
-
-			D_ASSERT(run_end > (logical_index + index));
-			auto to_scan = run_end - (logical_index + index);
-			// Cap the amount to scan so we don't go over size
-			to_scan = MinValue<idx_t>(to_scan, (count - index));
-
-			if (value_format.validity.RowIsValidUnsafe(value_index)) {
-				auto &value = values_data[value_index];
-				for (idx_t i = 0; i < to_scan; i++) {
-					result_data[index + i] = value;
-					validity.SetValid(index + i);
-				}
-			} else {
-				for (idx_t i = 0; i < to_scan; i++) {
-					validity.SetInvalid(index + i);
-				}
-			}
-			index += to_scan;
-			if (index >= count) {
-				if (logical_index + index >= run_end) {
-					// The last run was completed, forward the run index
-					++run;
-				}
-				break;
-			}
-		}
-	}
-}
-
-template <class RUN_END_TYPE>
-static void FlattenRunEndsSwitch(Vector &result, ArrowRunEndEncodingState &run_end_encoding, idx_t compressed_size,
-                                 idx_t scan_offset, idx_t size) {
-	auto &values = *run_end_encoding.values;
-	auto physical_type = values.GetType().InternalType();
-
-	switch (physical_type) {
-	case PhysicalType::INT8:
-		FlattenRunEnds<RUN_END_TYPE, int8_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INT16:
-		FlattenRunEnds<RUN_END_TYPE, int16_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INT32:
-		FlattenRunEnds<RUN_END_TYPE, int32_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INT64:
-		FlattenRunEnds<RUN_END_TYPE, int64_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INT128:
-		FlattenRunEnds<RUN_END_TYPE, hugeint_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::UINT8:
-		FlattenRunEnds<RUN_END_TYPE, uint8_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::UINT16:
-		FlattenRunEnds<RUN_END_TYPE, uint16_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::UINT32:
-		FlattenRunEnds<RUN_END_TYPE, uint32_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::UINT64:
-		FlattenRunEnds<RUN_END_TYPE, uint64_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::BOOL:
-		FlattenRunEnds<RUN_END_TYPE, bool>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::FLOAT:
-		FlattenRunEnds<RUN_END_TYPE, float>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::DOUBLE:
-		FlattenRunEnds<RUN_END_TYPE, double>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INTERVAL:
-		FlattenRunEnds<RUN_END_TYPE, interval_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::VARCHAR: {
-		// Share the string heap, we don't need to allocate new strings, we just reference the existing ones
-		result.SetAuxiliary(values.GetAuxiliary());
-		FlattenRunEnds<RUN_END_TYPE, string_t>(result, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	}
-	default:
-		throw NotImplementedException("RunEndEncoded value type '%s' not supported yet", TypeIdToString(physical_type));
-	}
-}
-
-static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &array, ArrowArrayScanState &array_state,
-                                             idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
-                                             ValidityMask *parent_mask, uint64_t parent_offset) {
-	// Scan the 'run_ends' array
-	D_ASSERT(array.n_children == 2);
-	auto &run_ends_array = *array.children[0];
-	auto &values_array = *array.children[1];
-
-	auto &struct_info = arrow_type.GetTypeInfo<ArrowStructInfo>();
-	auto &run_ends_type = struct_info.GetChild(0);
-	auto &values_type = struct_info.GetChild(1);
-	D_ASSERT(vector.GetType() == values_type.GetDuckType());
-
-	auto &scan_state = array_state.state;
-	if (vector.GetBuffer()) {
-		vector.GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(array_state.owned_data));
-	}
-
-	D_ASSERT(run_ends_array.length == values_array.length);
-	auto compressed_size = NumericCast<idx_t>(run_ends_array.length);
-	// Create a vector for the run ends and the values
-	auto &run_end_encoding = array_state.RunEndEncoding();
-	if (!run_end_encoding.run_ends) {
-		// The run ends and values have not been scanned yet for this array
-		D_ASSERT(!run_end_encoding.values);
-		run_end_encoding.run_ends = make_uniq<Vector>(run_ends_type.GetDuckType(), compressed_size);
-		run_end_encoding.values = make_uniq<Vector>(values_type.GetDuckType(), compressed_size);
-
-		ColumnArrowToDuckDB(*run_end_encoding.run_ends, run_ends_array, array_state, compressed_size, run_ends_type);
-		auto &values = *run_end_encoding.values;
-		SetValidityMask(values, values_array, scan_state, compressed_size, NumericCast<int64_t>(parent_offset),
-		                nested_offset);
-		ColumnArrowToDuckDB(values, values_array, array_state, compressed_size, values_type);
-	}
-
-	idx_t scan_offset = GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-	auto physical_type = run_ends_type.GetDuckType().InternalType();
-	switch (physical_type) {
-	case PhysicalType::INT16:
-		FlattenRunEndsSwitch<int16_t>(vector, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INT32:
-		FlattenRunEndsSwitch<int32_t>(vector, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	case PhysicalType::INT64:
-		FlattenRunEndsSwitch<int32_t>(vector, run_end_encoding, compressed_size, scan_offset, size);
-		break;
-	default:
-		throw NotImplementedException("Type '%s' not implemented for RunEndEncoding", TypeIdToString(physical_type));
-	}
-}
-
-static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                                const ArrowType &arrow_type, int64_t nested_offset, ValidityMask *parent_mask,
-                                uint64_t parent_offset) {
-	auto &scan_state = array_state.state;
-	D_ASSERT(!array.dictionary);
-
-	if (vector.GetBuffer()) {
-		vector.GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(array_state.owned_data));
-	}
-	switch (vector.GetType().id()) {
-	case LogicalTypeId::SQLNULL:
-		vector.Reference(Value());
-		break;
-	case LogicalTypeId::BOOLEAN: {
-		//! Arrow bit-packs boolean values
-		//! Lets first figure out where we are in the source array
-		auto effective_offset =
-		    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-		auto src_ptr = ArrowBufferData<uint8_t>(array, 1) + effective_offset / 8;
-		auto tgt_ptr = (uint8_t *)FlatVector::GetData(vector);
-		int src_pos = 0;
-		idx_t cur_bit = effective_offset % 8;
-		for (idx_t row = 0; row < size; row++) {
-			if ((src_ptr[src_pos] & (1 << cur_bit)) == 0) {
-				tgt_ptr[row] = 0;
-			} else {
-				tgt_ptr[row] = 1;
-			}
-			cur_bit++;
-			if (cur_bit == 8) {
-				src_pos++;
-				cur_bit = 0;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIME_TZ: {
-		DirectConversion(vector, array, scan_state, nested_offset, parent_offset);
-		break;
-	}
-	case LogicalTypeId::UUID:
-		UUIDConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size);
-		break;
-	case LogicalTypeId::VARCHAR: {
-		auto &string_info = arrow_type.GetTypeInfo<ArrowStringInfo>();
-		auto size_type = string_info.GetSizeType();
-		switch (size_type) {
-		case ArrowVariableSizeType::SUPER_SIZE: {
-			auto cdata = ArrowBufferData<char>(array, 2);
-			auto offsets = ArrowBufferData<uint64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			SetVectorString(vector, size, cdata, offsets);
-			break;
-		}
-		case ArrowVariableSizeType::NORMAL:
-		case ArrowVariableSizeType::FIXED_SIZE: {
-			auto cdata = ArrowBufferData<char>(array, 2);
-			auto offsets = ArrowBufferData<uint32_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			SetVectorString(vector, size, cdata, offsets);
-			break;
-		}
-		case ArrowVariableSizeType::VIEW: {
-			SetVectorStringView(
-			    vector, size, array,
-			    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset));
-			break;
-		}
-		}
-		break;
-	}
-	case LogicalTypeId::DATE: {
-		auto &datetime_info = arrow_type.GetTypeInfo<ArrowDateTimeInfo>();
-		auto precision = datetime_info.GetDateTimeType();
-		switch (precision) {
-		case ArrowDateTimeType::DAYS: {
-			DirectConversion(vector, array, scan_state, nested_offset, parent_offset);
-			break;
-		}
-		case ArrowDateTimeType::MILLISECONDS: {
-			//! convert date from nanoseconds to days
-			auto src_ptr = ArrowBufferData<uint64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			auto tgt_ptr = FlatVector::GetData<date_t>(vector);
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row] = date_t(UnsafeNumericCast<int32_t>(static_cast<int64_t>(src_ptr[row]) /
-				                                                 static_cast<int64_t>(1000 * 60 * 60 * 24)));
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported precision for Date Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::TIME: {
-		auto &datetime_info = arrow_type.GetTypeInfo<ArrowDateTimeInfo>();
-		auto precision = datetime_info.GetDateTimeType();
-		switch (precision) {
-		case ArrowDateTimeType::SECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                        1000000);
-			break;
-		}
-		case ArrowDateTimeType::MILLISECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                        1000);
-			break;
-		}
-		case ArrowDateTimeType::MICROSECONDS: {
-			TimeConversion<int64_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                        1);
-			break;
-		}
-		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = FlatVector::GetData<dtime_t>(vector);
-			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row].micros = src_ptr[row] / 1000;
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported precision for Time Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		auto &datetime_info = arrow_type.GetTypeInfo<ArrowDateTimeInfo>();
-		auto precision = datetime_info.GetDateTimeType();
-		switch (precision) {
-		case ArrowDateTimeType::SECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                      1000000);
-			break;
-		}
-		case ArrowDateTimeType::MILLISECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                      1000);
-			break;
-		}
-		case ArrowDateTimeType::MICROSECONDS: {
-			DirectConversion(vector, array, scan_state, nested_offset, parent_offset);
-			break;
-		}
-		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
-			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row].value = src_ptr[row] / 1000;
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported precision for TimestampTZ Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::INTERVAL: {
-		auto &datetime_info = arrow_type.GetTypeInfo<ArrowDateTimeInfo>();
-		auto precision = datetime_info.GetDateTimeType();
-		switch (precision) {
-		case ArrowDateTimeType::SECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                     1000000);
-			break;
-		}
-		case ArrowDateTimeType::DAYS:
-		case ArrowDateTimeType::MILLISECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                     1000);
-			break;
-		}
-		case ArrowDateTimeType::MICROSECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                     1);
-			break;
-		}
-		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
-			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row].micros = src_ptr[row] / 1000;
-				tgt_ptr[row].days = 0;
-				tgt_ptr[row].months = 0;
-			}
-			break;
-		}
-		case ArrowDateTimeType::MONTHS: {
-			IntervalConversionMonths(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset),
-			                         size);
-			break;
-		}
-		case ArrowDateTimeType::MONTH_DAY_NANO: {
-			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset,
-			                                NumericCast<int64_t>(parent_offset), size);
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported precision for Interval/Duration Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::DECIMAL: {
-		auto val_mask = FlatVector::Validity(vector);
-		//! We have to convert from INT128
-		auto src_ptr = ArrowBufferData<hugeint_t>(array, 1) +
-		               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-		switch (vector.GetType().InternalType()) {
-		case PhysicalType::INT16: {
-			auto tgt_ptr = FlatVector::GetData<int16_t>(vector);
-			for (idx_t row = 0; row < size; row++) {
-				if (val_mask.RowIsValid(row)) {
-					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
-					D_ASSERT(result);
-					(void)result;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT32: {
-			auto tgt_ptr = FlatVector::GetData<int32_t>(vector);
-			for (idx_t row = 0; row < size; row++) {
-				if (val_mask.RowIsValid(row)) {
-					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
-					D_ASSERT(result);
-					(void)result;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT64: {
-			auto tgt_ptr = FlatVector::GetData<int64_t>(vector);
-			for (idx_t row = 0; row < size; row++) {
-				if (val_mask.RowIsValid(row)) {
-					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
-					D_ASSERT(result);
-					(void)result;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT128: {
-			FlatVector::SetData(vector, ArrowBufferData<data_t>(array, 1) +
-			                                GetTypeIdSize(vector.GetType().InternalType()) *
-			                                    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset),
-			                                                       scan_state, nested_offset));
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported physical type for Decimal: %s",
-			                              TypeIdToString(vector.GetType().InternalType()));
-		}
-		break;
-	}
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
-	case LogicalTypeId::VARINT: {
-		ArrowToDuckDBBlob(vector, array, scan_state, size, arrow_type, nested_offset,
-		                  NumericCast<int64_t>(parent_offset));
-		break;
-	}
-	case LogicalTypeId::LIST: {
-		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask,
-		                  NumericCast<int64_t>(parent_offset));
-		break;
-	}
-	case LogicalTypeId::ARRAY: {
-		ArrowToDuckDBArray(vector, array, array_state, size, arrow_type, nested_offset, parent_mask,
-		                   NumericCast<int64_t>(parent_offset));
-		break;
-	}
-	case LogicalTypeId::MAP: {
-		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask,
-		                  NumericCast<int64_t>(parent_offset));
-		ArrowToDuckDBMapVerify(vector, size);
-		break;
-	}
-	case LogicalTypeId::STRUCT: {
-		//! Fill the children
-		auto &struct_info = arrow_type.GetTypeInfo<ArrowStructInfo>();
-		auto &child_entries = StructVector::GetEntries(vector);
-		auto &struct_validity_mask = FlatVector::Validity(vector);
-		for (idx_t child_idx = 0; child_idx < NumericCast<idx_t>(array.n_children); child_idx++) {
-			auto &child_entry = *child_entries[child_idx];
-			auto &child_array = *array.children[child_idx];
-			auto &child_type = struct_info.GetChild(child_idx);
-			auto &child_state = array_state.GetChild(child_idx);
-
-			SetValidityMask(child_entry, child_array, scan_state, size, array.offset, nested_offset);
-			if (!struct_validity_mask.AllValid()) {
-				auto &child_validity_mark = FlatVector::Validity(child_entry);
-				for (idx_t i = 0; i < size; i++) {
-					if (!struct_validity_mask.RowIsValid(i)) {
-						child_validity_mark.SetInvalid(i);
-					}
-				}
-			}
-
-			auto array_physical_type = GetArrowArrayPhysicalType(child_type);
-			switch (array_physical_type) {
-			case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-				ColumnArrowToDuckDBDictionary(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                              &struct_validity_mask, NumericCast<uint64_t>(array.offset));
-				break;
-			case ArrowArrayPhysicalType::RUN_END_ENCODED:
-				ColumnArrowToDuckDBRunEndEncoded(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                                 &struct_validity_mask, NumericCast<uint64_t>(array.offset));
-				break;
-			case ArrowArrayPhysicalType::DEFAULT:
-				ColumnArrowToDuckDB(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                    &struct_validity_mask, NumericCast<uint64_t>(array.offset));
-				break;
-			default:
-				throw NotImplementedException("ArrowArrayPhysicalType not recognized");
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::UNION: {
-		auto type_ids = ArrowBufferData<int8_t>(array, array.n_buffers == 1 ? 0 : 1);
-		D_ASSERT(type_ids);
-		auto members = UnionType::CopyMemberTypes(vector.GetType());
-
-		auto &validity_mask = FlatVector::Validity(vector);
-		auto &union_info = arrow_type.GetTypeInfo<ArrowStructInfo>();
-		duckdb::vector<Vector> children;
-		for (idx_t child_idx = 0; child_idx < NumericCast<idx_t>(array.n_children); child_idx++) {
-			Vector child(members[child_idx].second, size);
-			auto &child_array = *array.children[child_idx];
-			auto &child_state = array_state.GetChild(child_idx);
-			auto &child_type = union_info.GetChild(child_idx);
-
-			SetValidityMask(child, child_array, scan_state, size, NumericCast<int64_t>(parent_offset), nested_offset);
-			auto array_physical_type = GetArrowArrayPhysicalType(child_type);
-
-			switch (array_physical_type) {
-			case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-				ColumnArrowToDuckDBDictionary(child, child_array, child_state, size, child_type);
-				break;
-			case ArrowArrayPhysicalType::RUN_END_ENCODED:
-				ColumnArrowToDuckDBRunEndEncoded(child, child_array, child_state, size, child_type);
-				break;
-			case ArrowArrayPhysicalType::DEFAULT:
-				ColumnArrowToDuckDB(child, child_array, child_state, size, child_type, nested_offset, &validity_mask);
-				break;
-			default:
-				throw NotImplementedException("ArrowArrayPhysicalType not recognized");
-			}
-
-			children.push_back(std::move(child));
-		}
-
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			auto tag = NumericCast<uint8_t>(type_ids[row_idx]);
-
-			auto out_of_range = tag >= array.n_children;
-			if (out_of_range) {
-				throw InvalidInputException("Arrow union tag out of range: %d", tag);
-			}
-
-			const Value &value = children[tag].GetValue(row_idx);
-			vector.SetValue(row_idx, value.IsNull() ? Value() : Value::UNION(members, tag, value));
-		}
-
-		break;
-	}
-	default:
-		throw NotImplementedException("Unsupported type for arrow conversion: %s", vector.GetType().ToString());
-	}
-}
-
-template <class T>
-static void SetSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
-	auto indices = reinterpret_cast<T *>(indices_p);
-	for (idx_t row = 0; row < size; row++) {
-		sel.set_index(row, UnsafeNumericCast<idx_t>(indices[row]));
-	}
-}
-
-template <class T>
-static void SetSelectionVectorLoopWithChecks(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
-
-	auto indices = reinterpret_cast<T *>(indices_p);
-	for (idx_t row = 0; row < size; row++) {
-		if (indices[row] > NumericLimits<uint32_t>::Maximum()) {
-			throw ConversionException("DuckDB only supports indices that fit on an uint32");
-		}
-		sel.set_index(row, NumericCast<idx_t>(indices[row]));
-	}
-}
-
-template <class T>
-static void SetMaskedSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size, ValidityMask &mask,
-                                         idx_t last_element_pos) {
-	auto indices = reinterpret_cast<T *>(indices_p);
-	for (idx_t row = 0; row < size; row++) {
-		if (mask.RowIsValid(row)) {
-			sel.set_index(row, UnsafeNumericCast<idx_t>(indices[row]));
-		} else {
-			//! Need to point out to last element
-			sel.set_index(row, last_element_pos);
-		}
-	}
-}
-
-static void SetSelectionVector(SelectionVector &sel, data_ptr_t indices_p, const LogicalType &logical_type, idx_t size,
-                               ValidityMask *mask = nullptr, idx_t last_element_pos = 0) {
-	sel.Initialize(size);
-
-	if (mask) {
-		switch (logical_type.id()) {
-		case LogicalTypeId::UTINYINT:
-			SetMaskedSelectionVectorLoop<uint8_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::TINYINT:
-			SetMaskedSelectionVectorLoop<int8_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::USMALLINT:
-			SetMaskedSelectionVectorLoop<uint16_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::SMALLINT:
-			SetMaskedSelectionVectorLoop<int16_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::UINTEGER:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! Its guaranteed that our indices will point to the last element, so just throw an error
-				throw ConversionException("DuckDB only supports indices that fit on an uint32");
-			}
-			SetMaskedSelectionVectorLoop<uint32_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::INTEGER:
-			SetMaskedSelectionVectorLoop<int32_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::UBIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! Its guaranteed that our indices will point to the last element, so just throw an error
-				throw ConversionException("DuckDB only supports indices that fit on an uint32");
-			}
-			SetMaskedSelectionVectorLoop<uint64_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::BIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! Its guaranteed that our indices will point to the last element, so just throw an error
-				throw ConversionException("DuckDB only supports indices that fit on an uint32");
-			}
-			SetMaskedSelectionVectorLoop<int64_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-
-		default:
-			throw NotImplementedException("(Arrow) Unsupported type for selection vectors %s", logical_type.ToString());
-		}
-
-	} else {
-		switch (logical_type.id()) {
-		case LogicalTypeId::UTINYINT:
-			SetSelectionVectorLoop<uint8_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::TINYINT:
-			SetSelectionVectorLoop<int8_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::USMALLINT:
-			SetSelectionVectorLoop<uint16_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::SMALLINT:
-			SetSelectionVectorLoop<int16_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::UINTEGER:
-			SetSelectionVectorLoop<uint32_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::INTEGER:
-			SetSelectionVectorLoop<int32_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::UBIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! We need to check if our indexes fit in a uint32_t
-				SetSelectionVectorLoopWithChecks<uint64_t>(sel, indices_p, size);
-			} else {
-				SetSelectionVectorLoop<uint64_t>(sel, indices_p, size);
-			}
-			break;
-		case LogicalTypeId::BIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! We need to check if our indexes fit in a uint32_t
-				SetSelectionVectorLoopWithChecks<int64_t>(sel, indices_p, size);
-			} else {
-				SetSelectionVectorLoop<int64_t>(sel, indices_p, size);
-			}
-			break;
-		default:
-			throw ConversionException("(Arrow) Unsupported type for selection vectors %s", logical_type.ToString());
-		}
-	}
-}
-
-static bool CanContainNull(const ArrowArray &array, const ValidityMask *parent_mask) {
-	if (array.null_count > 0) {
-		return true;
-	}
-	if (!parent_mask) {
-		return false;
-	}
-	return !parent_mask->AllValid();
-}
-
-static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state,
-                                          idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
-                                          const ValidityMask *parent_mask, uint64_t parent_offset) {
-	if (vector.GetBuffer()) {
-		vector.GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(array_state.owned_data));
-	}
-	D_ASSERT(arrow_type.HasDictionary());
-	auto &scan_state = array_state.state;
-	const bool has_nulls = CanContainNull(array, parent_mask);
-	if (array_state.CacheOutdated(array.dictionary)) {
-		//! We need to set the dictionary data for this column
-		auto base_vector = make_uniq<Vector>(vector.GetType(), NumericCast<idx_t>(array.dictionary->length));
-		SetValidityMask(*base_vector, *array.dictionary, scan_state, NumericCast<idx_t>(array.dictionary->length), 0, 0,
-		                has_nulls);
-		auto &dictionary_type = arrow_type.GetDictionary();
-		auto arrow_physical_type = GetArrowArrayPhysicalType(dictionary_type);
-		switch (arrow_physical_type) {
-		case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-			ColumnArrowToDuckDBDictionary(*base_vector, *array.dictionary, array_state,
-			                              NumericCast<idx_t>(array.dictionary->length), dictionary_type);
-			break;
-		case ArrowArrayPhysicalType::RUN_END_ENCODED:
-			ColumnArrowToDuckDBRunEndEncoded(*base_vector, *array.dictionary, array_state,
-			                                 NumericCast<idx_t>(array.dictionary->length), dictionary_type);
-			break;
-		case ArrowArrayPhysicalType::DEFAULT:
-			ColumnArrowToDuckDB(*base_vector, *array.dictionary, array_state,
-			                    NumericCast<idx_t>(array.dictionary->length), dictionary_type);
-			break;
-		default:
-			throw NotImplementedException("ArrowArrayPhysicalType not recognized");
-		};
-		array_state.AddDictionary(std::move(base_vector), array.dictionary);
-	}
-	auto offset_type = arrow_type.GetDuckType();
-	//! Get Pointer to Indices of Dictionary
-	auto indices = ArrowBufferData<data_t>(array, 1) +
-	               GetTypeIdSize(offset_type.InternalType()) *
-	                   GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-
-	SelectionVector sel;
-	if (has_nulls) {
-		ValidityMask indices_validity;
-		GetValidityMask(indices_validity, array, scan_state, size, NumericCast<int64_t>(parent_offset));
-		if (parent_mask && !parent_mask->AllValid()) {
-			auto &struct_validity_mask = *parent_mask;
-			for (idx_t i = 0; i < size; i++) {
-				if (!struct_validity_mask.RowIsValid(i)) {
-					indices_validity.SetInvalid(i);
-				}
-			}
-		}
-		SetSelectionVector(sel, indices, offset_type, size, &indices_validity,
-		                   NumericCast<idx_t>(array.dictionary->length));
-	} else {
-		SetSelectionVector(sel, indices, offset_type, size);
-	}
-	vector.Slice(array_state.GetDictionary(), sel, size);
-	vector.Verify(size);
-}
-
-void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data,
-                                       DataChunk &output, idx_t start, bool arrow_scan_is_projected,
-                                       idx_t rowid_column_index) {
-	for (idx_t idx = 0; idx < output.ColumnCount(); idx++) {
-		auto col_idx = scan_state.column_ids.empty() ? idx : scan_state.column_ids[idx];
-
-		// If projection was not pushed down into the arrow scanner, but projection pushdown is enabled on the
-		// table function, we need to use original column ids here.
-		auto arrow_array_idx = arrow_scan_is_projected ? idx : col_idx;
-
-		if (rowid_column_index != COLUMN_IDENTIFIER_ROW_ID) {
-			if (col_idx == COLUMN_IDENTIFIER_ROW_ID) {
-				arrow_array_idx = rowid_column_index;
-			} else if (col_idx >= rowid_column_index) {
-				// Since the rowid column is skipped when the table is bound (its not a named column),
-				// we need to shift references forward in the Arrow array by one to match the alignment
-				// that DuckDB believes the Arrow array is in.
-				col_idx += 1;
-				arrow_array_idx += 1;
-			}
-		} else {
-			// If there isn't any defined row_id_index, and we're asked for it, skip the column.
-			// This is the incumbent behavior.
-			if (col_idx == COLUMN_IDENTIFIER_ROW_ID) {
-				continue;
-			}
-		}
-
-		auto &parent_array = scan_state.chunk->arrow_array;
-		auto &array = *scan_state.chunk->arrow_array.children[arrow_array_idx];
-		if (!array.release) {
-			throw InvalidInputException("arrow_scan: released array passed");
-		}
-		if (array.length != scan_state.chunk->arrow_array.length) {
-			throw InvalidInputException("arrow_scan: array length mismatch");
-		}
-
-		D_ASSERT(arrow_convert_data.find(col_idx) != arrow_convert_data.end());
-		auto &arrow_type = *arrow_convert_data.at(col_idx);
-		auto &array_state = scan_state.GetState(col_idx);
-
-		// Make sure this Vector keeps the Arrow chunk alive in case we can zero-copy the data
-		if (!array_state.owned_data) {
-			array_state.owned_data = scan_state.chunk;
-		}
-
-		auto array_physical_type = GetArrowArrayPhysicalType(arrow_type);
-
-		switch (array_physical_type) {
-		case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-			ColumnArrowToDuckDBDictionary(output.data[idx], array, array_state, output.size(), arrow_type);
-			break;
-		case ArrowArrayPhysicalType::RUN_END_ENCODED:
-			ColumnArrowToDuckDBRunEndEncoded(output.data[idx], array, array_state, output.size(), arrow_type);
-			break;
-		case ArrowArrayPhysicalType::DEFAULT:
-			SetValidityMask(output.data[idx], array, scan_state, output.size(), parent_array.offset, -1);
-			ColumnArrowToDuckDB(output.data[idx], array, array_state, output.size(), arrow_type);
-			break;
-		default:
-			throw NotImplementedException("ArrowArrayPhysicalType not recognized");
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/checkpoint.cpp b/src/duckdb/src/function/table/checkpoint.cpp
deleted file mode 100644
index 9fdd19a79..000000000
--- a/src/duckdb/src/function/table/checkpoint.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CheckpointBindData : public FunctionData {
-	explicit CheckpointBindData(optional_ptr<AttachedDatabase> db) : db(db) {
-	}
-
-	optional_ptr<AttachedDatabase> db;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<CheckpointBindData>(db);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<CheckpointBindData>();
-		return db == other.db;
-	}
-};
-
-static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunctionBindInput &input,
-                                               vector<LogicalType> &return_types, vector<string> &names) {
-	return_types.emplace_back(LogicalType::BOOLEAN);
-	names.emplace_back("Success");
-
-	optional_ptr<AttachedDatabase> db;
-	auto &db_manager = DatabaseManager::Get(context);
-	if (!input.inputs.empty()) {
-		if (input.inputs[0].IsNull()) {
-			throw BinderException("Database cannot be NULL");
-		}
-		auto &db_name = StringValue::Get(input.inputs[0]);
-		db = db_manager.GetDatabase(context, db_name);
-		if (!db) {
-			throw BinderException("Database \"%s\" not found", db_name);
-		}
-	} else {
-		db = db_manager.GetDatabase(context, DatabaseManager::GetDefaultDatabase(context));
-	}
-	return make_uniq<CheckpointBindData>(db);
-}
-
-template <bool FORCE>
-static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<CheckpointBindData>();
-	auto &transaction_manager = TransactionManager::Get(*bind_data.db.get_mutable());
-	transaction_manager.Checkpoint(context, FORCE);
-}
-
-void CheckpointFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet checkpoint("checkpoint");
-	checkpoint.AddFunction(TableFunction({}, TemplatedCheckpointFunction<false>, CheckpointBind));
-	checkpoint.AddFunction(TableFunction({LogicalType::VARCHAR}, TemplatedCheckpointFunction<false>, CheckpointBind));
-	set.AddFunction(checkpoint);
-
-	TableFunctionSet force_checkpoint("force_checkpoint");
-	force_checkpoint.AddFunction(TableFunction({}, TemplatedCheckpointFunction<true>, CheckpointBind));
-	force_checkpoint.AddFunction(
-	    TableFunction({LogicalType::VARCHAR}, TemplatedCheckpointFunction<true>, CheckpointBind));
-	set.AddFunction(force_checkpoint);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/copy_csv.cpp b/src/duckdb/src/function/table/copy_csv.cpp
deleted file mode 100644
index 42e3f0610..000000000
--- a/src/duckdb/src/function/table/copy_csv.cpp
+++ /dev/null
@@ -1,660 +0,0 @@
-#include "duckdb/common/bind_helpers.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-#include <limits>
-
-namespace duckdb {
-
-void AreOptionsEqual(char str_1, char str_2, const string &name_str_1, const string &name_str_2) {
-	if (str_1 == '\0' || str_2 == '\0') {
-		return;
-	}
-	if (str_1 == str_2) {
-		throw BinderException("%s must not appear in the %s specification and vice versa", name_str_1, name_str_2);
-	}
-}
-
-void SubstringDetection(char str_1, string &str_2, const string &name_str_1, const string &name_str_2) {
-	if (str_1 == '\0' || str_2.empty()) {
-		return;
-	}
-	if (str_2.find(str_1) != string::npos) {
-		throw BinderException("%s must not appear in the %s specification and vice versa", name_str_1, name_str_2);
-	}
-}
-
-void StringDetection(const string &str_1, const string &str_2, const string &name_str_1, const string &name_str_2) {
-	if (str_1.empty() || str_2.empty()) {
-		return;
-	}
-	if (str_2.find(str_1) != string::npos) {
-		throw BinderException("%s must not appear in the %s specification and vice versa", name_str_1, name_str_2);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Bind
-//===--------------------------------------------------------------------===//
-void WriteQuoteOrEscape(WriteStream &writer, char quote_or_escape) {
-	if (quote_or_escape != '\0') {
-		writer.Write(quote_or_escape);
-	}
-}
-
-void BaseCSVData::Finalize() {
-	auto delimiter_string = options.dialect_options.state_machine_options.delimiter.GetValue();
-
-	// quote and delimiter must not be substrings of each other
-	SubstringDetection(options.dialect_options.state_machine_options.quote.GetValue(), delimiter_string, "QUOTE",
-	                   "DELIMITER");
-
-	// escape and delimiter must not be substrings of each other
-	SubstringDetection(options.dialect_options.state_machine_options.escape.GetValue(), delimiter_string, "ESCAPE",
-	                   "DELIMITER");
-
-	// escape and quote must not be substrings of each other (but can be the same)
-	if (options.dialect_options.state_machine_options.quote != options.dialect_options.state_machine_options.escape) {
-		AreOptionsEqual(options.dialect_options.state_machine_options.quote.GetValue(),
-		                options.dialect_options.state_machine_options.escape.GetValue(), "QUOTE", "ESCAPE");
-	}
-
-	// comment and quote must not be substrings of each other
-	AreOptionsEqual(options.dialect_options.state_machine_options.comment.GetValue(),
-	                options.dialect_options.state_machine_options.quote.GetValue(), "COMMENT", "QUOTE");
-
-	// delimiter and comment must not be substrings of each other
-	SubstringDetection(options.dialect_options.state_machine_options.comment.GetValue(), delimiter_string, "COMMENT",
-	                   "DELIMITER");
-
-	// null string and delimiter must not be substrings of each other
-	for (auto &null_str : options.null_str) {
-		if (!null_str.empty()) {
-			StringDetection(options.dialect_options.state_machine_options.delimiter.GetValue(), null_str, "DELIMITER",
-			                "NULL");
-
-			// quote and nullstr must not be substrings of each other
-			SubstringDetection(options.dialect_options.state_machine_options.quote.GetValue(), null_str, "QUOTE",
-			                   "NULL");
-
-			// Validate the nullstr against the escape character
-			const char escape = options.dialect_options.state_machine_options.escape.GetValue();
-			// Allow nullstr to be escape character + some non-special character, e.g., "\N" (MySQL default).
-			// In this case, only unquoted occurrences of the nullstr will be recognized as null values.
-			if (options.dialect_options.state_machine_options.rfc_4180 == false && null_str.size() == 2 &&
-			    null_str[0] == escape && null_str[1] != '\0') {
-				continue;
-			}
-			SubstringDetection(escape, null_str, "ESCAPE", "NULL");
-		}
-	}
-
-	if (!options.prefix.empty() || !options.suffix.empty()) {
-		if (options.prefix.empty() || options.suffix.empty()) {
-			throw BinderException("COPY ... (FORMAT CSV) must have both PREFIX and SUFFIX, or none at all");
-		}
-		if (options.dialect_options.header.GetValue()) {
-			throw BinderException("COPY ... (FORMAT CSV)'s HEADER cannot be combined with PREFIX/SUFFIX");
-		}
-	}
-}
-
-string TransformNewLine(string new_line) {
-	new_line = StringUtil::Replace(new_line, "\\r", "\r");
-	return StringUtil::Replace(new_line, "\\n", "\n");
-	;
-}
-
-static vector<unique_ptr<Expression>> CreateCastExpressions(WriteCSVData &bind_data, ClientContext &context,
-                                                            const vector<string> &names,
-                                                            const vector<LogicalType> &sql_types) {
-	auto &options = bind_data.options;
-	auto &formats = options.write_date_format;
-
-	bool has_dateformat = !formats[LogicalTypeId::DATE].IsNull();
-	bool has_timestampformat = !formats[LogicalTypeId::TIMESTAMP].IsNull();
-
-	// Create a binder
-	auto binder = Binder::CreateBinder(context);
-
-	auto &bind_context = binder->bind_context;
-	auto table_index = binder->GenerateTableIndex();
-	bind_context.AddGenericBinding(table_index, "copy_csv", names, sql_types);
-
-	// Create the ParsedExpressions (cast, strftime, etc..)
-	vector<unique_ptr<ParsedExpression>> unbound_expressions;
-	for (idx_t i = 0; i < sql_types.size(); i++) {
-		auto &type = sql_types[i];
-		auto &name = names[i];
-
-		bool is_timestamp = type.id() == LogicalTypeId::TIMESTAMP || type.id() == LogicalTypeId::TIMESTAMP_TZ;
-		if (has_dateformat && type.id() == LogicalTypeId::DATE) {
-			// strftime(<name>, 'format')
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(make_uniq<BoundExpression>(make_uniq<BoundReferenceExpression>(name, type, i)));
-			children.push_back(make_uniq<ConstantExpression>(formats[LogicalTypeId::DATE]));
-			auto func = make_uniq_base<ParsedExpression, FunctionExpression>("strftime", std::move(children));
-			unbound_expressions.push_back(std::move(func));
-		} else if (has_timestampformat && is_timestamp) {
-			// strftime(<name>, 'format')
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(make_uniq<BoundExpression>(make_uniq<BoundReferenceExpression>(name, type, i)));
-			children.push_back(make_uniq<ConstantExpression>(formats[LogicalTypeId::TIMESTAMP]));
-			auto func = make_uniq_base<ParsedExpression, FunctionExpression>("strftime", std::move(children));
-			unbound_expressions.push_back(std::move(func));
-		} else {
-			// CAST <name> AS VARCHAR
-			auto column = make_uniq<BoundExpression>(make_uniq<BoundReferenceExpression>(name, type, i));
-			auto expr = make_uniq_base<ParsedExpression, CastExpression>(LogicalType::VARCHAR, std::move(column));
-			unbound_expressions.push_back(std::move(expr));
-		}
-	}
-
-	// Create an ExpressionBinder, bind the Expressions
-	vector<unique_ptr<Expression>> expressions;
-	ExpressionBinder expression_binder(*binder, context);
-	expression_binder.target_type = LogicalType::VARCHAR;
-	for (auto &expr : unbound_expressions) {
-		expressions.push_back(expression_binder.Bind(expr));
-	}
-
-	return expressions;
-}
-
-static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyFunctionBindInput &input,
-                                             const vector<string> &names, const vector<LogicalType> &sql_types) {
-	auto bind_data = make_uniq<WriteCSVData>(input.info.file_path, sql_types, names);
-
-	// check all the options in the copy info
-	for (auto &option : input.info.options) {
-		auto loption = StringUtil::Lower(option.first);
-		auto &set = option.second;
-		bind_data->options.SetWriteOption(loption, ConvertVectorToValue(set));
-	}
-	// verify the parsed options
-	if (bind_data->options.force_quote.empty()) {
-		// no FORCE_QUOTE specified: initialize to false
-		bind_data->options.force_quote.resize(names.size(), false);
-	}
-	bind_data->Finalize();
-
-	switch (bind_data->options.compression) {
-	case FileCompressionType::GZIP:
-		if (!IsFileCompressed(input.file_extension, FileCompressionType::GZIP)) {
-			input.file_extension += CompressionExtensionFromType(FileCompressionType::GZIP);
-		}
-		break;
-	case FileCompressionType::ZSTD:
-		if (!IsFileCompressed(input.file_extension, FileCompressionType::ZSTD)) {
-			input.file_extension += CompressionExtensionFromType(FileCompressionType::ZSTD);
-		}
-		break;
-	default:
-		break;
-	}
-
-	auto expressions = CreateCastExpressions(*bind_data, context, names, sql_types);
-	bind_data->cast_expressions = std::move(expressions);
-
-	bind_data->requires_quotes = make_unsafe_uniq_array<bool>(256);
-	memset(bind_data->requires_quotes.get(), 0, sizeof(bool) * 256);
-	bind_data->requires_quotes['\n'] = true;
-	bind_data->requires_quotes['\r'] = true;
-	bind_data->requires_quotes[NumericCast<idx_t>(
-	    bind_data->options.dialect_options.state_machine_options.delimiter.GetValue()[0])] = true;
-	bind_data->requires_quotes[NumericCast<idx_t>(
-	    bind_data->options.dialect_options.state_machine_options.quote.GetValue())] = true;
-
-	if (!bind_data->options.write_newline.empty()) {
-		bind_data->newline = TransformNewLine(bind_data->options.write_newline);
-	}
-	return std::move(bind_data);
-}
-
-static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &info, vector<string> &expected_names,
-                                            vector<LogicalType> &expected_types) {
-	auto bind_data = make_uniq<ReadCSVData>();
-	bind_data->csv_types = expected_types;
-	bind_data->csv_names = expected_names;
-	bind_data->return_types = expected_types;
-	bind_data->return_names = expected_names;
-
-	auto multi_file_reader = MultiFileReader::CreateDefault("CSVCopy");
-	bind_data->files = multi_file_reader->CreateFileList(context, Value(info.file_path))->GetAllFiles();
-
-	auto &options = bind_data->options;
-
-	// check all the options in the copy info
-	for (auto &option : info.options) {
-		auto loption = StringUtil::Lower(option.first);
-		auto &set = option.second;
-		options.SetReadOption(loption, ConvertVectorToValue(set), expected_names);
-	}
-	// verify the parsed options
-	if (options.force_not_null.empty()) {
-		// no FORCE_QUOTE specified: initialize to false
-		options.force_not_null.resize(expected_types.size(), false);
-	}
-
-	// Look for rejects table options last
-	named_parameter_map_t options_map;
-	for (auto &option : info.options) {
-		options_map[option.first] = ConvertVectorToValue(std::move(option.second));
-	}
-	options.file_path = bind_data->files[0];
-	options.name_list = expected_names;
-	options.sql_type_list = expected_types;
-	options.columns_set = true;
-	for (idx_t i = 0; i < expected_types.size(); i++) {
-		options.sql_types_per_column[expected_names[i]] = i;
-	}
-
-	if (options.auto_detect) {
-		auto buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, bind_data->files[0], 0);
-		CSVSniffer sniffer(options, buffer_manager, CSVStateMachineCache::Get(context));
-		sniffer.SniffCSV();
-	}
-	bind_data->FinalizeRead(context);
-
-	return std::move(bind_data);
-}
-
-//===--------------------------------------------------------------------===//
-// Helper writing functions
-//===--------------------------------------------------------------------===//
-static string AddEscapes(char to_be_escaped, const char escape, const string &val) {
-	idx_t i = 0;
-	string new_val = "";
-	idx_t found = val.find(to_be_escaped);
-
-	while (found != string::npos) {
-		while (i < found) {
-			new_val += val[i];
-			i++;
-		}
-		if (escape != '\0') {
-			new_val += escape;
-			found = val.find(to_be_escaped, found + 1);
-		}
-	}
-	while (i < val.length()) {
-		new_val += val[i];
-		i++;
-	}
-	return new_val;
-}
-
-static bool RequiresQuotes(WriteCSVData &csv_data, const char *str, idx_t len) {
-	auto &options = csv_data.options;
-	// check if the string is equal to the null string
-	if (len == options.null_str[0].size() && memcmp(str, options.null_str[0].c_str(), len) == 0) {
-		return true;
-	}
-	auto str_data = reinterpret_cast<const_data_ptr_t>(str);
-	for (idx_t i = 0; i < len; i++) {
-		if (csv_data.requires_quotes[str_data[i]]) {
-			// this byte requires quotes - write a quoted string
-			return true;
-		}
-	}
-	// no newline, quote or delimiter in the string
-	// no quoting or escaping necessary
-	return false;
-}
-
-static void WriteQuotedString(WriteStream &writer, WriteCSVData &csv_data, const char *str, idx_t len,
-                              bool force_quote) {
-	auto &options = csv_data.options;
-	if (!force_quote) {
-		// force quote is disabled: check if we need to add quotes anyway
-		force_quote = RequiresQuotes(csv_data, str, len);
-	}
-	// If a quote is set to none (i.e., null-terminator) we skip the quotation
-	if (force_quote && options.dialect_options.state_machine_options.quote.GetValue() != '\0') {
-		// quoting is enabled: we might need to escape things in the string
-		bool requires_escape = false;
-		// simple CSV
-		// do a single loop to check for a quote or escape value
-		for (idx_t i = 0; i < len; i++) {
-			if (str[i] == options.dialect_options.state_machine_options.quote.GetValue() ||
-			    str[i] == options.dialect_options.state_machine_options.escape.GetValue()) {
-				requires_escape = true;
-				break;
-			}
-		}
-
-		if (!requires_escape) {
-			// fast path: no need to escape anything
-			WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote.GetValue());
-			writer.WriteData(const_data_ptr_cast(str), len);
-			WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote.GetValue());
-			return;
-		}
-
-		// slow path: need to add escapes
-		string new_val(str, len);
-		new_val = AddEscapes(options.dialect_options.state_machine_options.escape.GetValue(),
-		                     options.dialect_options.state_machine_options.escape.GetValue(), new_val);
-		if (options.dialect_options.state_machine_options.escape !=
-		    options.dialect_options.state_machine_options.quote) {
-			// need to escape quotes separately
-			new_val = AddEscapes(options.dialect_options.state_machine_options.quote.GetValue(),
-			                     options.dialect_options.state_machine_options.escape.GetValue(), new_val);
-		}
-		WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote.GetValue());
-		writer.WriteData(const_data_ptr_cast(new_val.c_str()), new_val.size());
-		WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote.GetValue());
-	} else {
-		writer.WriteData(const_data_ptr_cast(str), len);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-struct LocalWriteCSVData : public LocalFunctionData {
-public:
-	LocalWriteCSVData(ClientContext &context, vector<unique_ptr<Expression>> &expressions)
-	    : executor(context, expressions) {
-	}
-
-public:
-	//! Used to execute the expressions that transform input -> string
-	ExpressionExecutor executor;
-	//! The thread-local buffer to write data into
-	MemoryStream stream;
-	//! A chunk with VARCHAR columns to cast intermediates into
-	DataChunk cast_chunk;
-	//! If we've written any rows yet, allows us to prevent a trailing comma when writing JSON ARRAY
-	bool written_anything = false;
-};
-
-struct GlobalWriteCSVData : public GlobalFunctionData {
-	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileCompressionType compression)
-	    : fs(fs), written_anything(false) {
-		handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW |
-		                                    FileLockType::WRITE_LOCK | compression);
-	}
-
-	//! Write generic data, e.g., CSV header
-	void WriteData(const_data_ptr_t data, idx_t size) {
-		lock_guard<mutex> flock(lock);
-		handle->Write((void *)data, size);
-	}
-
-	void WriteData(const char *data, idx_t size) {
-		WriteData(const_data_ptr_cast(data), size);
-	}
-
-	//! Write rows
-	void WriteRows(const_data_ptr_t data, idx_t size, const string &newline) {
-		lock_guard<mutex> flock(lock);
-		if (written_anything) {
-			handle->Write((void *)newline.c_str(), newline.length());
-		} else {
-			written_anything = true;
-		}
-		handle->Write((void *)data, size);
-	}
-
-	idx_t FileSize() {
-		lock_guard<mutex> flock(lock);
-		return handle->GetFileSize();
-	}
-
-	FileSystem &fs;
-	//! The mutex for writing to the physical file
-	mutex lock;
-	//! The file handle to write to
-	unique_ptr<FileHandle> handle;
-	//! If we've written any rows yet, allows us to prevent a trailing comma when writing JSON ARRAY
-	bool written_anything;
-};
-
-static unique_ptr<LocalFunctionData> WriteCSVInitializeLocal(ExecutionContext &context, FunctionData &bind_data) {
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto local_data = make_uniq<LocalWriteCSVData>(context.client, csv_data.cast_expressions);
-
-	// create the chunk with VARCHAR types
-	vector<LogicalType> types;
-	types.resize(csv_data.options.name_list.size(), LogicalType::VARCHAR);
-
-	local_data->cast_chunk.Initialize(Allocator::Get(context.client), types);
-	return std::move(local_data);
-}
-
-static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &context, FunctionData &bind_data,
-                                                               const string &file_path) {
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &options = csv_data.options;
-	auto global_data =
-	    make_uniq<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path, options.compression);
-
-	if (!options.prefix.empty()) {
-		global_data->WriteData(options.prefix.c_str(), options.prefix.size());
-	}
-
-	if (!(options.dialect_options.header.IsSetByUser() && !options.dialect_options.header.GetValue())) {
-		MemoryStream stream;
-		// write the header line to the file
-		for (idx_t i = 0; i < csv_data.options.name_list.size(); i++) {
-			if (i != 0) {
-				WriteQuoteOrEscape(stream, options.dialect_options.state_machine_options.delimiter.GetValue()[0]);
-			}
-			WriteQuotedString(stream, csv_data, csv_data.options.name_list[i].c_str(),
-			                  csv_data.options.name_list[i].size(), false);
-		}
-		stream.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
-
-		global_data->WriteData(stream.GetData(), stream.GetPosition());
-	}
-
-	return std::move(global_data);
-}
-
-static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_data, DataChunk &cast_chunk,
-                                  MemoryStream &writer, DataChunk &input, bool &written_anything,
-                                  ExpressionExecutor &executor) {
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &options = csv_data.options;
-
-	// first cast the columns of the chunk to varchar
-	cast_chunk.Reset();
-	cast_chunk.SetCardinality(input);
-
-	executor.Execute(input, cast_chunk);
-
-	cast_chunk.Flatten();
-	// now loop over the vectors and output the values
-	for (idx_t row_idx = 0; row_idx < cast_chunk.size(); row_idx++) {
-		if (row_idx == 0 && !written_anything) {
-			written_anything = true;
-		} else {
-			writer.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
-		}
-		// write values
-		D_ASSERT(options.null_str.size() == 1);
-		for (idx_t col_idx = 0; col_idx < cast_chunk.ColumnCount(); col_idx++) {
-			if (col_idx != 0) {
-				WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.delimiter.GetValue()[0]);
-			}
-			if (FlatVector::IsNull(cast_chunk.data[col_idx], row_idx)) {
-				// write null value
-				writer.WriteData(const_data_ptr_cast(options.null_str[0].c_str()), options.null_str[0].size());
-				continue;
-			}
-
-			// non-null value, fetch the string value from the cast chunk
-			auto str_data = FlatVector::GetData<string_t>(cast_chunk.data[col_idx]);
-			// FIXME: we could gain some performance here by checking for certain types if they ever require quotes
-			// (e.g. integers only require quotes if the delimiter is a number, decimals only require quotes if the
-			// delimiter is a number or "." character)
-			WriteQuotedString(writer, csv_data, str_data[row_idx].GetData(), str_data[row_idx].GetSize(),
-			                  csv_data.options.force_quote[col_idx]);
-		}
-	}
-}
-
-static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                         LocalFunctionData &lstate, DataChunk &input) {
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &local_data = lstate.Cast<LocalWriteCSVData>();
-	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
-
-	// write data into the local buffer
-	WriteCSVChunkInternal(context.client, bind_data, local_data.cast_chunk, local_data.stream, input,
-	                      local_data.written_anything, local_data.executor);
-
-	// check if we should flush what we have currently written
-	auto &writer = local_data.stream;
-	if (writer.GetPosition() >= csv_data.flush_size) {
-		global_state.WriteRows(writer.GetData(), writer.GetPosition(), csv_data.newline);
-		writer.Rewind();
-		local_data.written_anything = false;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-static void WriteCSVCombine(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                            LocalFunctionData &lstate) {
-	auto &local_data = lstate.Cast<LocalWriteCSVData>();
-	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &writer = local_data.stream;
-	// flush the local writer
-	if (local_data.written_anything) {
-		global_state.WriteRows(writer.GetData(), writer.GetPosition(), csv_data.newline);
-		writer.Rewind();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-void WriteCSVFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
-	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &options = csv_data.options;
-
-	MemoryStream stream;
-	if (!options.suffix.empty()) {
-		stream.WriteData(const_data_ptr_cast(options.suffix.c_str()), options.suffix.size());
-	} else if (global_state.written_anything) {
-		stream.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
-	}
-	global_state.WriteData(stream.GetData(), stream.GetPosition());
-
-	global_state.handle->Close();
-	global_state.handle.reset();
-}
-
-//===--------------------------------------------------------------------===//
-// Execution Mode
-//===--------------------------------------------------------------------===//
-CopyFunctionExecutionMode WriteCSVExecutionMode(bool preserve_insertion_order, bool supports_batch_index) {
-	if (!preserve_insertion_order) {
-		return CopyFunctionExecutionMode::PARALLEL_COPY_TO_FILE;
-	}
-	if (supports_batch_index) {
-		return CopyFunctionExecutionMode::BATCH_COPY_TO_FILE;
-	}
-	return CopyFunctionExecutionMode::REGULAR_COPY_TO_FILE;
-}
-//===--------------------------------------------------------------------===//
-// Prepare Batch
-//===--------------------------------------------------------------------===//
-struct WriteCSVBatchData : public PreparedBatchData {
-	//! The thread-local buffer to write data into
-	MemoryStream stream;
-};
-
-unique_ptr<PreparedBatchData> WriteCSVPrepareBatch(ClientContext &context, FunctionData &bind_data,
-                                                   GlobalFunctionData &gstate,
-                                                   unique_ptr<ColumnDataCollection> collection) {
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-
-	// create the cast chunk with VARCHAR types
-	vector<LogicalType> types;
-	types.resize(csv_data.options.name_list.size(), LogicalType::VARCHAR);
-	DataChunk cast_chunk;
-	cast_chunk.Initialize(Allocator::Get(context), types);
-
-	auto &original_types = collection->Types();
-	auto expressions = CreateCastExpressions(csv_data, context, csv_data.options.name_list, original_types);
-	ExpressionExecutor executor(context, expressions);
-
-	// write CSV chunks to the batch data
-	bool written_anything = false;
-	auto batch = make_uniq<WriteCSVBatchData>();
-	for (auto &chunk : collection->Chunks()) {
-		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->stream, chunk, written_anything, executor);
-	}
-	return std::move(batch);
-}
-
-//===--------------------------------------------------------------------===//
-// Flush Batch
-//===--------------------------------------------------------------------===//
-void WriteCSVFlushBatch(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                        PreparedBatchData &batch) {
-	auto &csv_batch = batch.Cast<WriteCSVBatchData>();
-	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
-	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &writer = csv_batch.stream;
-	global_state.WriteRows(writer.GetData(), writer.GetPosition(), csv_data.newline);
-	writer.Rewind();
-}
-
-//===--------------------------------------------------------------------===//
-// File rotation
-//===--------------------------------------------------------------------===//
-bool WriteCSVRotateFiles(FunctionData &, const optional_idx &file_size_bytes) {
-	return file_size_bytes.IsValid();
-}
-
-bool WriteCSVRotateNextFile(GlobalFunctionData &gstate, FunctionData &, const optional_idx &file_size_bytes) {
-	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
-	return global_state.FileSize() > file_size_bytes.GetIndex();
-}
-
-void CSVCopyFunction::RegisterFunction(BuiltinFunctions &set) {
-	CopyFunction info("csv");
-	info.copy_to_bind = WriteCSVBind;
-	info.copy_to_initialize_local = WriteCSVInitializeLocal;
-	info.copy_to_initialize_global = WriteCSVInitializeGlobal;
-	info.copy_to_sink = WriteCSVSink;
-	info.copy_to_combine = WriteCSVCombine;
-	info.copy_to_finalize = WriteCSVFinalize;
-	info.execution_mode = WriteCSVExecutionMode;
-	info.prepare_batch = WriteCSVPrepareBatch;
-	info.flush_batch = WriteCSVFlushBatch;
-	info.rotate_files = WriteCSVRotateFiles;
-	info.rotate_next_file = WriteCSVRotateNextFile;
-
-	info.copy_from_bind = ReadCSVBind;
-	info.copy_from_function = ReadCSVTableFunction::GetFunction();
-
-	info.extension = "csv";
-
-	set.AddFunction(info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/glob.cpp b/src/duckdb/src/function/table/glob.cpp
deleted file mode 100644
index 736c2778e..000000000
--- a/src/duckdb/src/function/table/glob.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-
-namespace duckdb {
-
-struct GlobFunctionBindData : public TableFunctionData {
-	shared_ptr<MultiFileList> file_list;
-};
-
-static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<GlobFunctionBindData>();
-	auto multi_file_reader = MultiFileReader::Create(input.table_function);
-	result->file_list = multi_file_reader->CreateFileList(context, input.inputs[0], FileGlobOptions::ALLOW_EMPTY);
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("file");
-	return std::move(result);
-}
-
-struct GlobFunctionState : public GlobalTableFunctionState {
-	GlobFunctionState() {
-	}
-
-	MultiFileListScanData file_list_scan;
-};
-
-static unique_ptr<GlobalTableFunctionState> GlobFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<GlobFunctionBindData>();
-	auto res = make_uniq<GlobFunctionState>();
-
-	bind_data.file_list->InitializeScan(res->file_list_scan);
-
-	return std::move(res);
-}
-
-static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<GlobFunctionBindData>();
-	auto &state = data_p.global_state->Cast<GlobFunctionState>();
-
-	idx_t count = 0;
-	while (count < STANDARD_VECTOR_SIZE) {
-		string file;
-		if (!bind_data.file_list->Scan(state.file_list_scan, file)) {
-			break;
-		}
-		output.data[0].SetValue(count++, file);
-	}
-	output.SetCardinality(count);
-}
-
-void GlobTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction glob_function("glob", {LogicalType::VARCHAR}, GlobFunction, GlobFunctionBind, GlobFunctionInit);
-	set.AddFunction(MultiFileReader::CreateFunctionSet(glob_function));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/query_function.cpp b/src/duckdb/src/function/table/query_function.cpp
deleted file mode 100644
index c44b1919c..000000000
--- a/src/duckdb/src/function/table/query_function.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-
-namespace duckdb {
-
-static unique_ptr<SubqueryRef> ParseSubquery(const string &query, const ParserOptions &options, const string &err_msg) {
-	Parser parser(options);
-	parser.ParseQuery(query);
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException(err_msg);
-	}
-	auto select_stmt = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
-	return duckdb::make_uniq<SubqueryRef>(std::move(select_stmt));
-}
-
-static string UnionTablesQuery(TableFunctionBindInput &input) {
-	for (auto &input_val : input.inputs) {
-		if (input_val.IsNull()) {
-			throw BinderException("Cannot use NULL as function argument");
-		}
-	}
-	string result;
-	string by_name = (input.inputs.size() == 2 &&
-	                  (input.inputs[1].type().id() == LogicalTypeId::BOOLEAN && input.inputs[1].GetValue<bool>()))
-	                     ? "BY NAME "
-	                     : ""; // 'by_name' variable defaults to false
-	if (input.inputs[0].type().id() == LogicalTypeId::VARCHAR) {
-		auto from_path = input.inputs[0].ToString();
-		auto qualified_name = QualifiedName::Parse(from_path);
-		result += "FROM " + qualified_name.ToString();
-	} else if (input.inputs[0].type() == LogicalType::LIST(LogicalType::VARCHAR)) {
-		string union_all_clause = " UNION ALL " + by_name + "FROM ";
-		const auto &children = ListValue::GetChildren(input.inputs[0]);
-
-		if (children.empty()) {
-			throw InvalidInputException("Input list is empty");
-		}
-		auto qualified_name = QualifiedName::Parse(children[0].ToString());
-		result += "FROM " + qualified_name.ToString();
-		for (size_t i = 1; i < children.size(); ++i) {
-			auto child = children[i].ToString();
-			auto qualified_name = QualifiedName::Parse(child);
-			result += union_all_clause + qualified_name.ToString();
-		}
-	} else {
-		throw InvalidInputException("Expected a table or a list with tables as input");
-	}
-	return result;
-}
-
-static unique_ptr<TableRef> QueryBindReplace(ClientContext &context, TableFunctionBindInput &input) {
-	auto query = input.inputs[0].ToString();
-	auto subquery_ref = ParseSubquery(query, context.GetParserOptions(), "Expected a single SELECT statement");
-	return std::move(subquery_ref);
-}
-
-static unique_ptr<TableRef> TableBindReplace(ClientContext &context, TableFunctionBindInput &input) {
-	auto query = UnionTablesQuery(input);
-	auto subquery_ref =
-	    ParseSubquery(query, context.GetParserOptions(), "Expected a table or a list with tables as input");
-	return std::move(subquery_ref);
-}
-
-void QueryTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction query("query", {LogicalType::VARCHAR}, nullptr, nullptr);
-	query.bind_replace = QueryBindReplace;
-	set.AddFunction(query);
-
-	TableFunctionSet query_table("query_table");
-	TableFunction query_table_function({LogicalType::VARCHAR}, nullptr, nullptr);
-	query_table_function.bind_replace = TableBindReplace;
-	query_table.AddFunction(query_table_function);
-
-	query_table_function.arguments = {LogicalType::LIST(LogicalType::VARCHAR)};
-	query_table.AddFunction(query_table_function);
-	// add by_name option
-	query_table_function.arguments.emplace_back(LogicalType::BOOLEAN);
-	query_table.AddFunction(query_table_function);
-	set.AddFunction(query_table);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/range.cpp b/src/duckdb/src/function/table/range.cpp
deleted file mode 100644
index 17bcda81d..000000000
--- a/src/duckdb/src/function/table/range.cpp
+++ /dev/null
@@ -1,367 +0,0 @@
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/function/table/summary.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Range (integers)
-//===--------------------------------------------------------------------===//
-static void GetParameters(int64_t values[], idx_t value_count, hugeint_t &start, hugeint_t &end, hugeint_t &increment) {
-	if (value_count < 2) {
-		// single argument: only the end is specified
-		start = 0;
-		end = values[0];
-	} else {
-		// two arguments: first two arguments are start and end
-		start = values[0];
-		end = values[1];
-	}
-	if (value_count < 3) {
-		increment = 1;
-	} else {
-		increment = values[2];
-	}
-}
-
-struct RangeFunctionBindData : public TableFunctionData {
-	explicit RangeFunctionBindData(const vector<Value> &inputs) : cardinality(0) {
-		int64_t values[3];
-		for (idx_t i = 0; i < inputs.size(); i++) {
-			if (inputs[i].IsNull()) {
-				return;
-			}
-			values[i] = inputs[i].GetValue<int64_t>();
-		}
-		hugeint_t start;
-		hugeint_t end;
-		hugeint_t increment;
-		GetParameters(values, inputs.size(), start, end, increment);
-		cardinality = Hugeint::Cast<idx_t>((end - start) / increment);
-	}
-
-	idx_t cardinality;
-};
-
-template <bool GENERATE_SERIES>
-static unique_ptr<FunctionData> RangeFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	return_types.emplace_back(LogicalType::BIGINT);
-	if (GENERATE_SERIES) {
-		names.emplace_back("generate_series");
-	} else {
-		names.emplace_back("range");
-	}
-	if (input.inputs.empty() || input.inputs.size() > 3) {
-		return nullptr;
-	}
-	return make_uniq<RangeFunctionBindData>(input.inputs);
-}
-
-struct RangeFunctionLocalState : public LocalTableFunctionState {
-	RangeFunctionLocalState() {
-	}
-
-	bool initialized_row = false;
-	idx_t current_input_row = 0;
-	idx_t current_idx = 0;
-
-	hugeint_t start;
-	hugeint_t end;
-	hugeint_t increment;
-};
-
-static unique_ptr<LocalTableFunctionState> RangeFunctionLocalInit(ExecutionContext &context,
-                                                                  TableFunctionInitInput &input,
-                                                                  GlobalTableFunctionState *global_state) {
-	return make_uniq<RangeFunctionLocalState>();
-}
-
-template <bool GENERATE_SERIES>
-static void GenerateRangeParameters(DataChunk &input, idx_t row_id, RangeFunctionLocalState &result) {
-	input.Flatten();
-	for (idx_t c = 0; c < input.ColumnCount(); c++) {
-		if (FlatVector::IsNull(input.data[c], row_id)) {
-			result.start = GENERATE_SERIES ? 1 : 0;
-			result.end = 0;
-			result.increment = 1;
-			return;
-		}
-	}
-	int64_t values[3];
-	for (idx_t c = 0; c < input.ColumnCount(); c++) {
-		if (c >= 3) {
-			throw InternalException("Unsupported parameter count for range function");
-		}
-		values[c] = FlatVector::GetValue<int64_t>(input.data[c], row_id);
-	}
-	GetParameters(values, input.ColumnCount(), result.start, result.end, result.increment);
-	if (result.increment == 0) {
-		throw BinderException("interval cannot be 0!");
-	}
-	if (result.start > result.end && result.increment > 0) {
-		throw BinderException("start is bigger than end, but increment is positive: cannot generate infinite series");
-	}
-	if (result.start < result.end && result.increment < 0) {
-		throw BinderException("start is smaller than end, but increment is negative: cannot generate infinite series");
-	}
-	if (GENERATE_SERIES) {
-		// generate_series has inclusive bounds on the RHS
-		if (result.increment < 0) {
-			result.end = result.end - 1;
-		} else {
-			result.end = result.end + 1;
-		}
-	}
-}
-
-template <bool GENERATE_SERIES>
-static OperatorResultType RangeFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
-                                        DataChunk &output) {
-	auto &state = data_p.local_state->Cast<RangeFunctionLocalState>();
-	while (true) {
-		if (!state.initialized_row) {
-			// initialize for the current input row
-			if (state.current_input_row >= input.size()) {
-				// ran out of rows
-				state.current_input_row = 0;
-				state.initialized_row = false;
-				return OperatorResultType::NEED_MORE_INPUT;
-			}
-			GenerateRangeParameters<GENERATE_SERIES>(input, state.current_input_row, state);
-			state.initialized_row = true;
-			state.current_idx = 0;
-		}
-		auto increment = state.increment;
-		auto end = state.end;
-		hugeint_t current_value = state.start + increment * UnsafeNumericCast<int64_t>(state.current_idx);
-		int64_t current_value_i64;
-		if (!Hugeint::TryCast<int64_t>(current_value, current_value_i64)) {
-			// move to next row
-			state.current_input_row++;
-			state.initialized_row = false;
-			continue;
-		}
-		int64_t offset = increment < 0 ? 1 : -1;
-		idx_t remaining = MinValue<idx_t>(
-		    Hugeint::Cast<idx_t>((end - current_value + (increment + offset)) / increment), STANDARD_VECTOR_SIZE);
-		// set the result vector as a sequence vector
-		output.data[0].Sequence(current_value_i64, Hugeint::Cast<int64_t>(increment), remaining);
-		// increment the index pointer by the remaining count
-		state.current_idx += remaining;
-		output.SetCardinality(remaining);
-		if (remaining == 0) {
-			// move to next row
-			state.current_input_row++;
-			state.initialized_row = false;
-			continue;
-		}
-		return OperatorResultType::HAVE_MORE_OUTPUT;
-	}
-}
-
-unique_ptr<NodeStatistics> RangeCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	if (!bind_data_p) {
-		return nullptr;
-	}
-	auto &bind_data = bind_data_p->Cast<RangeFunctionBindData>();
-	return make_uniq<NodeStatistics>(bind_data.cardinality, bind_data.cardinality);
-}
-
-//===--------------------------------------------------------------------===//
-// Range (timestamp)
-//===--------------------------------------------------------------------===//
-template <bool GENERATE_SERIES>
-static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	return_types.push_back(LogicalType::TIMESTAMP);
-	if (GENERATE_SERIES) {
-		names.emplace_back("generate_series");
-	} else {
-		names.emplace_back("range");
-	}
-	return nullptr;
-}
-
-struct RangeDateTimeLocalState : public LocalTableFunctionState {
-	RangeDateTimeLocalState() {
-	}
-
-	bool initialized_row = false;
-	idx_t current_input_row = 0;
-	timestamp_t current_state;
-
-	timestamp_t start;
-	timestamp_t end;
-	interval_t increment;
-	bool inclusive_bound;
-	bool greater_than_check;
-
-	bool Finished(timestamp_t current_value) const {
-		if (greater_than_check) {
-			if (inclusive_bound) {
-				return current_value > end;
-			} else {
-				return current_value >= end;
-			}
-		} else {
-			if (inclusive_bound) {
-				return current_value < end;
-			} else {
-				return current_value <= end;
-			}
-		}
-	}
-};
-
-template <bool GENERATE_SERIES>
-static void GenerateRangeDateTimeParameters(DataChunk &input, idx_t row_id, RangeDateTimeLocalState &result) {
-	input.Flatten();
-
-	for (idx_t c = 0; c < input.ColumnCount(); c++) {
-		if (FlatVector::IsNull(input.data[c], row_id)) {
-			result.start = timestamp_t(0);
-			result.end = timestamp_t(0);
-			result.increment = interval_t();
-			result.greater_than_check = true;
-			result.inclusive_bound = false;
-			return;
-		}
-	}
-
-	result.start = FlatVector::GetValue<timestamp_t>(input.data[0], row_id);
-	result.end = FlatVector::GetValue<timestamp_t>(input.data[1], row_id);
-	result.increment = FlatVector::GetValue<interval_t>(input.data[2], row_id);
-
-	// Infinities either cause errors or infinite loops, so just ban them
-	if (!Timestamp::IsFinite(result.start) || !Timestamp::IsFinite(result.end)) {
-		throw BinderException("RANGE with infinite bounds is not supported");
-	}
-
-	if (result.increment.months == 0 && result.increment.days == 0 && result.increment.micros == 0) {
-		throw BinderException("interval cannot be 0!");
-	}
-	// all elements should point in the same direction
-	if (result.increment.months > 0 || result.increment.days > 0 || result.increment.micros > 0) {
-		if (result.increment.months < 0 || result.increment.days < 0 || result.increment.micros < 0) {
-			throw BinderException("RANGE with composite interval that has mixed signs is not supported");
-		}
-		result.greater_than_check = true;
-		if (result.start > result.end) {
-			throw BinderException(
-			    "start is bigger than end, but increment is positive: cannot generate infinite series");
-		}
-	} else {
-		result.greater_than_check = false;
-		if (result.start < result.end) {
-			throw BinderException(
-			    "start is smaller than end, but increment is negative: cannot generate infinite series");
-		}
-	}
-	result.inclusive_bound = GENERATE_SERIES;
-}
-
-static unique_ptr<LocalTableFunctionState> RangeDateTimeLocalInit(ExecutionContext &context,
-                                                                  TableFunctionInitInput &input,
-                                                                  GlobalTableFunctionState *global_state) {
-	return make_uniq<RangeDateTimeLocalState>();
-}
-
-template <bool GENERATE_SERIES>
-static OperatorResultType RangeDateTimeFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
-                                                DataChunk &output) {
-	auto &state = data_p.local_state->Cast<RangeDateTimeLocalState>();
-	while (true) {
-		if (!state.initialized_row) {
-			// initialize for the current input row
-			if (state.current_input_row >= input.size()) {
-				// ran out of rows
-				state.current_input_row = 0;
-				state.initialized_row = false;
-				return OperatorResultType::NEED_MORE_INPUT;
-			}
-			GenerateRangeDateTimeParameters<GENERATE_SERIES>(input, state.current_input_row, state);
-			state.initialized_row = true;
-			state.current_state = state.start;
-		}
-		idx_t size = 0;
-		auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
-		while (true) {
-			if (state.Finished(state.current_state)) {
-				break;
-			}
-			if (size >= STANDARD_VECTOR_SIZE) {
-				break;
-			}
-			data[size++] = state.current_state;
-			state.current_state =
-			    AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(state.current_state, state.increment);
-		}
-		if (size == 0) {
-			// move to next row
-			state.current_input_row++;
-			state.initialized_row = false;
-			continue;
-		}
-		output.SetCardinality(size);
-		return OperatorResultType::HAVE_MORE_OUTPUT;
-	}
-}
-
-void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet range("range");
-
-	TableFunction range_function({LogicalType::BIGINT}, nullptr, RangeFunctionBind<false>, nullptr,
-	                             RangeFunctionLocalInit);
-	range_function.in_out_function = RangeFunction<false>;
-	range_function.cardinality = RangeCardinality;
-
-	// single argument range: (end) - implicit start = 0 and increment = 1
-	range.AddFunction(range_function);
-	// two arguments range: (start, end) - implicit increment = 1
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT};
-	range.AddFunction(range_function);
-	// three arguments range: (start, end, increment)
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT};
-	range.AddFunction(range_function);
-	TableFunction range_in_out({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, nullptr,
-	                           RangeDateTimeBind<false>, nullptr, RangeDateTimeLocalInit);
-	range_in_out.in_out_function = RangeDateTimeFunction<false>;
-	range.AddFunction(range_in_out);
-	set.AddFunction(range);
-	// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
-	TableFunctionSet generate_series("generate_series");
-	range_function.bind = RangeFunctionBind<true>;
-	range_function.in_out_function = RangeFunction<true>;
-	range_function.arguments = {LogicalType::BIGINT};
-	generate_series.AddFunction(range_function);
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT};
-	generate_series.AddFunction(range_function);
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT};
-	generate_series.AddFunction(range_function);
-	TableFunction generate_series_in_out({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                     nullptr, RangeDateTimeBind<true>, nullptr, RangeDateTimeLocalInit);
-	generate_series_in_out.in_out_function = RangeDateTimeFunction<true>;
-	generate_series.AddFunction(generate_series_in_out);
-	set.AddFunction(generate_series);
-}
-
-void BuiltinFunctions::RegisterTableFunctions() {
-	CheckpointFunction::RegisterFunction(*this);
-	GlobTableFunction::RegisterFunction(*this);
-	RangeTableFunction::RegisterFunction(*this);
-	RepeatTableFunction::RegisterFunction(*this);
-	SummaryTableFunction::RegisterFunction(*this);
-	UnnestTableFunction::RegisterFunction(*this);
-	RepeatRowTableFunction::RegisterFunction(*this);
-	CSVSnifferFunction::RegisterFunction(*this);
-	ReadBlobFunction::RegisterFunction(*this);
-	ReadTextFunction::RegisterFunction(*this);
-	QueryTableFunction::RegisterFunction(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/read_csv.cpp b/src/duckdb/src/function/table/read_csv.cpp
deleted file mode 100644
index f01934e7b..000000000
--- a/src/duckdb/src/function/table/read_csv.cpp
+++ /dev/null
@@ -1,465 +0,0 @@
-#include "duckdb/function/table/read_csv.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/union_by_name.hpp"
-#include "duckdb/execution/operator/csv_scanner/global_csv_state.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
-
-#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
-
-#include <limits>
-#include "duckdb/execution/operator/csv_scanner/csv_schema.hpp"
-
-namespace duckdb {
-
-unique_ptr<CSVFileHandle> ReadCSV::OpenCSV(const string &file_path, const CSVReaderOptions &options,
-                                           ClientContext &context) {
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto &allocator = BufferAllocator::Get(context);
-	auto &db_config = DBConfig::GetConfig(context);
-	return CSVFileHandle::OpenFile(db_config, fs, allocator, file_path, options);
-}
-
-ReadCSVData::ReadCSVData() {
-}
-
-void ReadCSVData::FinalizeRead(ClientContext &context) {
-	BaseCSVData::Finalize();
-}
-
-//! Function to do schema discovery over one CSV file or a list/glob of CSV files
-void SchemaDiscovery(ClientContext &context, ReadCSVData &result, CSVReaderOptions &options,
-                     vector<LogicalType> &return_types, vector<string> &names, MultiFileList &multi_file_list) {
-	vector<CSVSchema> schemas;
-	const auto option_og = options;
-
-	const auto file_paths = multi_file_list.GetAllFiles();
-
-	// Here what we want to do is to sniff a given number of lines, if we have many files, we might go through them
-	// to reach the number of lines.
-	const idx_t required_number_of_lines = options.sniff_size * options.sample_size_chunks;
-
-	idx_t total_number_of_rows = 0;
-	idx_t current_file = 0;
-	options.file_path = file_paths[current_file];
-
-	result.buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, options.file_path, 0, false);
-	{
-		CSVSniffer sniffer(options, result.buffer_manager, CSVStateMachineCache::Get(context));
-		auto sniffer_result = sniffer.SniffCSV();
-		idx_t rows_read = sniffer.LinesSniffed() -
-		                  (options.dialect_options.skip_rows.GetValue() + options.dialect_options.header.GetValue());
-
-		schemas.emplace_back(sniffer_result.names, sniffer_result.return_types, file_paths[0], rows_read,
-		                     result.buffer_manager->GetBuffer(0)->actual_size == 0);
-		total_number_of_rows += sniffer.LinesSniffed();
-	}
-
-	// We do a copy of the options to not pollute the options of the first file.
-	constexpr idx_t max_files_to_sniff = 10;
-	idx_t files_to_sniff = file_paths.size() > max_files_to_sniff ? max_files_to_sniff : file_paths.size();
-	while (total_number_of_rows < required_number_of_lines && current_file + 1 < files_to_sniff) {
-		auto option_copy = option_og;
-		current_file++;
-		option_copy.file_path = file_paths[current_file];
-		auto buffer_manager =
-		    make_shared_ptr<CSVBufferManager>(context, option_copy, option_copy.file_path, current_file, false);
-		// TODO: We could cache the sniffer to be reused during scanning. Currently that's an exercise left to the
-		// reader
-		CSVSniffer sniffer(option_copy, buffer_manager, CSVStateMachineCache::Get(context));
-		auto sniffer_result = sniffer.SniffCSV();
-		idx_t rows_read = sniffer.LinesSniffed() - (option_copy.dialect_options.skip_rows.GetValue() +
-		                                            option_copy.dialect_options.header.GetValue());
-		if (buffer_manager->GetBuffer(0)->actual_size == 0) {
-			schemas.emplace_back(true);
-		} else {
-			schemas.emplace_back(sniffer_result.names, sniffer_result.return_types, option_copy.file_path, rows_read);
-		}
-		total_number_of_rows += sniffer.LinesSniffed();
-	}
-
-	// We might now have multiple schemas, we need to go through them to define the one true schema
-	CSVSchema best_schema;
-	for (auto &schema : schemas) {
-		if (best_schema.Empty()) {
-			// A schema is bettah than no schema
-			best_schema = schema;
-		} else if (best_schema.GetRowsRead() == 0) {
-			// If the best-schema has no data-rows, that's easy, we just take the new schema
-			best_schema = schema;
-		} else if (schema.GetRowsRead() != 0) {
-			// We might have conflicting-schemas, we must merge them
-			best_schema.MergeSchemas(schema, options.null_padding);
-		}
-	}
-
-	if (names.empty()) {
-		names = best_schema.GetNames();
-		return_types = best_schema.GetTypes();
-	}
-	result.csv_types = return_types;
-	result.csv_names = names;
-}
-
-static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctionBindInput &input,
-                                            vector<LogicalType> &return_types, vector<string> &names) {
-
-	auto result = make_uniq<ReadCSVData>();
-	auto &options = result->options;
-	const auto multi_file_reader = MultiFileReader::Create(input.table_function);
-	const auto multi_file_list = multi_file_reader->CreateFileList(context, input.inputs[0]);
-	if (multi_file_list->GetTotalFileCount() > 1) {
-		options.multi_file_reader = true;
-	}
-	options.FromNamedParameters(input.named_parameters, context);
-
-	options.file_options.AutoDetectHivePartitioning(*multi_file_list, context);
-	options.Verify();
-	if (!options.file_options.union_by_name) {
-		if (options.auto_detect) {
-			SchemaDiscovery(context, *result, options, return_types, names, *multi_file_list);
-		} else {
-			// If we are not running the sniffer, the columns must be set!
-			if (!options.columns_set) {
-				throw BinderException("read_csv requires columns to be specified through the 'columns' option. Use "
-				                      "read_csv_auto or set read_csv(..., "
-				                      "AUTO_DETECT=TRUE) to automatically guess columns.");
-			}
-			names = options.name_list;
-			return_types = options.sql_type_list;
-		}
-		D_ASSERT(return_types.size() == names.size());
-		result->options.dialect_options.num_cols = names.size();
-
-		multi_file_reader->BindOptions(options.file_options, *multi_file_list, return_types, names,
-		                               result->reader_bind);
-	} else {
-		result->reader_bind = multi_file_reader->BindUnionReader<CSVFileScan>(context, return_types, names,
-		                                                                      *multi_file_list, *result, options);
-		if (result->union_readers.size() > 1) {
-			for (idx_t i = 0; i < result->union_readers.size(); i++) {
-				result->column_info.emplace_back(result->union_readers[i]->names, result->union_readers[i]->types);
-			}
-		}
-		if (!options.sql_types_per_column.empty()) {
-			const auto exception = CSVError::ColumnTypesError(options.sql_types_per_column, names);
-			if (!exception.error_message.empty()) {
-				throw BinderException(exception.error_message);
-			}
-			for (idx_t i = 0; i < names.size(); i++) {
-				auto it = options.sql_types_per_column.find(names[i]);
-				if (it != options.sql_types_per_column.end()) {
-					return_types[i] = options.sql_type_list[it->second];
-				}
-			}
-		}
-	}
-
-	result->csv_types = return_types;
-	result->csv_names = names;
-	result->return_types = return_types;
-	result->return_names = names;
-	if (!options.force_not_null_names.empty()) {
-		// Let's first check all column names match
-		duckdb::unordered_set<string> column_names;
-		for (auto &name : names) {
-			column_names.insert(name);
-		}
-		for (auto &force_name : options.force_not_null_names) {
-			if (column_names.find(force_name) == column_names.end()) {
-				throw BinderException("\"force_not_null\" expected to find %s, but it was not found in the table",
-				                      force_name);
-			}
-		}
-		D_ASSERT(options.force_not_null.empty());
-		for (idx_t i = 0; i < names.size(); i++) {
-			if (options.force_not_null_names.find(names[i]) != options.force_not_null_names.end()) {
-				options.force_not_null.push_back(true);
-			} else {
-				options.force_not_null.push_back(false);
-			}
-		}
-	}
-
-	// TODO: make the CSV reader use MultiFileList throughout, instead of converting to vector<string>
-	result->files = multi_file_list->GetAllFiles();
-	result->Finalize();
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Read CSV Local State
-//===--------------------------------------------------------------------===//
-struct CSVLocalState : public LocalTableFunctionState {
-public:
-	explicit CSVLocalState(unique_ptr<StringValueScanner> csv_reader_p) : csv_reader(std::move(csv_reader_p)) {
-	}
-
-	//! The CSV reader
-	unique_ptr<StringValueScanner> csv_reader;
-	bool done = false;
-};
-
-//===--------------------------------------------------------------------===//
-// Read CSV Functions
-//===--------------------------------------------------------------------===//
-static unique_ptr<GlobalTableFunctionState> ReadCSVInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<ReadCSVData>();
-
-	// Create the temporary rejects table
-	if (bind_data.options.store_rejects.GetValue()) {
-		CSVRejectsTable::GetOrCreate(context, bind_data.options.rejects_scan_name.GetValue(),
-		                             bind_data.options.rejects_table_name.GetValue())
-		    ->InitializeTable(context, bind_data);
-	}
-	if (bind_data.files.empty()) {
-		// This can happen when a filename based filter pushdown has eliminated all possible files for this scan.
-		return nullptr;
-	}
-	return make_uniq<CSVGlobalState>(context, bind_data.buffer_manager, bind_data.options,
-	                                 context.db->NumberOfThreads(), bind_data.files, input.column_indexes, bind_data);
-}
-
-unique_ptr<LocalTableFunctionState> ReadCSVInitLocal(ExecutionContext &context, TableFunctionInitInput &input,
-                                                     GlobalTableFunctionState *global_state_p) {
-	if (!global_state_p) {
-		return nullptr;
-	}
-	auto &global_state = global_state_p->Cast<CSVGlobalState>();
-	if (global_state.IsDone()) {
-		// nothing to do
-		return nullptr;
-	}
-	auto csv_scanner = global_state.Next(nullptr);
-	if (!csv_scanner) {
-		global_state.DecrementThread();
-	}
-	return make_uniq<CSVLocalState>(std::move(csv_scanner));
-}
-
-static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<ReadCSVData>();
-	if (!data_p.global_state) {
-		return;
-	}
-	auto &csv_global_state = data_p.global_state->Cast<CSVGlobalState>();
-	if (!data_p.local_state) {
-		return;
-	}
-	auto &csv_local_state = data_p.local_state->Cast<CSVLocalState>();
-
-	if (!csv_local_state.csv_reader) {
-		// no csv_reader was set, this can happen when a filename-based filter has filtered out all possible files
-		return;
-	}
-	do {
-		if (output.size() != 0) {
-			MultiFileReader().FinalizeChunk(context, bind_data.reader_bind,
-			                                csv_local_state.csv_reader->csv_file_scan->reader_data, output, nullptr);
-			break;
-		}
-		if (csv_local_state.csv_reader->FinishedIterator()) {
-			csv_local_state.csv_reader = csv_global_state.Next(csv_local_state.csv_reader.get());
-			if (!csv_local_state.csv_reader) {
-				csv_global_state.DecrementThread();
-				break;
-			}
-		}
-		csv_local_state.csv_reader->Flush(output);
-
-	} while (true);
-}
-
-static OperatorPartitionData CSVReaderGetPartitionData(ClientContext &context, TableFunctionGetPartitionInput &input) {
-	if (input.partition_info.RequiresPartitionColumns()) {
-		throw InternalException("CSVReader::GetPartitionData: partition columns not supported");
-	}
-	auto &data = input.local_state->Cast<CSVLocalState>();
-	return OperatorPartitionData(data.csv_reader->scanner_idx);
-}
-
-void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_function) {
-	table_function.named_parameters["sep"] = LogicalType::VARCHAR;
-	table_function.named_parameters["delim"] = LogicalType::VARCHAR;
-	table_function.named_parameters["quote"] = LogicalType::VARCHAR;
-	table_function.named_parameters["new_line"] = LogicalType::VARCHAR;
-	table_function.named_parameters["escape"] = LogicalType::VARCHAR;
-	table_function.named_parameters["nullstr"] = LogicalType::ANY;
-	table_function.named_parameters["columns"] = LogicalType::ANY;
-	table_function.named_parameters["auto_type_candidates"] = LogicalType::ANY;
-	table_function.named_parameters["header"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["auto_detect"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["sample_size"] = LogicalType::BIGINT;
-	table_function.named_parameters["all_varchar"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["dateformat"] = LogicalType::VARCHAR;
-	table_function.named_parameters["timestampformat"] = LogicalType::VARCHAR;
-	table_function.named_parameters["normalize_names"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["compression"] = LogicalType::VARCHAR;
-	table_function.named_parameters["skip"] = LogicalType::BIGINT;
-	table_function.named_parameters["max_line_size"] = LogicalType::VARCHAR;
-	table_function.named_parameters["maximum_line_size"] = LogicalType::VARCHAR;
-	table_function.named_parameters["ignore_errors"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["store_rejects"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["rejects_table"] = LogicalType::VARCHAR;
-	table_function.named_parameters["rejects_scan"] = LogicalType::VARCHAR;
-	table_function.named_parameters["rejects_limit"] = LogicalType::BIGINT;
-	table_function.named_parameters["force_not_null"] = LogicalType::LIST(LogicalType::VARCHAR);
-	table_function.named_parameters["buffer_size"] = LogicalType::UBIGINT;
-	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
-	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["null_padding"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["allow_quoted_nulls"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["column_types"] = LogicalType::ANY;
-	table_function.named_parameters["dtypes"] = LogicalType::ANY;
-	table_function.named_parameters["types"] = LogicalType::ANY;
-	table_function.named_parameters["names"] = LogicalType::LIST(LogicalType::VARCHAR);
-	table_function.named_parameters["column_names"] = LogicalType::LIST(LogicalType::VARCHAR);
-	table_function.named_parameters["comment"] = LogicalType::VARCHAR;
-	table_function.named_parameters["encoding"] = LogicalType::VARCHAR;
-	table_function.named_parameters["rfc_4180"] = LogicalType::BOOLEAN;
-
-	MultiFileReader::AddParameters(table_function);
-}
-
-double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
-                         const GlobalTableFunctionState *global_state) {
-	if (!global_state) {
-		return 0;
-	}
-	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
-	auto &data = global_state->Cast<CSVGlobalState>();
-	return data.GetProgress(bind_data);
-}
-
-void CSVComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
-                              vector<unique_ptr<Expression>> &filters) {
-	auto &data = bind_data_p->Cast<ReadCSVData>();
-	SimpleMultiFileList file_list(data.files);
-	MultiFilePushdownInfo info(get);
-	auto filtered_list =
-	    MultiFileReader().ComplexFilterPushdown(context, file_list, data.options.file_options, info, filters);
-	if (filtered_list) {
-		data.files = filtered_list->GetAllFiles();
-		MultiFileReader::PruneReaders(data, file_list);
-	} else {
-		data.files = file_list.GetAllFiles();
-	}
-}
-
-unique_ptr<NodeStatistics> CSVReaderCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
-	// determined through the scientific method as the average amount of rows in a CSV file
-	idx_t per_file_cardinality = 42;
-	if (bind_data.buffer_manager && bind_data.buffer_manager->file_handle) {
-		auto estimated_row_width = (bind_data.csv_types.size() * 5);
-		per_file_cardinality = bind_data.buffer_manager->file_handle->FileSize() / estimated_row_width;
-	}
-	return make_uniq<NodeStatistics>(bind_data.files.size() * per_file_cardinality);
-}
-
-static void CSVReaderSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                               const TableFunction &function) {
-	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
-	serializer.WriteProperty(100, "extra_info", function.extra_info);
-	serializer.WriteProperty(101, "csv_data", &bind_data);
-}
-
-static unique_ptr<FunctionData> CSVReaderDeserialize(Deserializer &deserializer, TableFunction &function) {
-	unique_ptr<ReadCSVData> result;
-	deserializer.ReadProperty(100, "extra_info", function.extra_info);
-	deserializer.ReadProperty(101, "csv_data", result);
-	return std::move(result);
-}
-
-void PushdownTypeToCSVScanner(ClientContext &context, optional_ptr<FunctionData> bind_data,
-                              const unordered_map<idx_t, LogicalType> &new_column_types) {
-	auto &csv_bind = bind_data->Cast<ReadCSVData>();
-	for (auto &type : new_column_types) {
-		csv_bind.csv_types[type.first] = type.second;
-		csv_bind.return_types[type.first] = type.second;
-	}
-}
-
-TableFunction ReadCSVTableFunction::GetFunction() {
-	TableFunction read_csv("read_csv", {LogicalType::VARCHAR}, ReadCSVFunction, ReadCSVBind, ReadCSVInitGlobal,
-	                       ReadCSVInitLocal);
-	read_csv.table_scan_progress = CSVReaderProgress;
-	read_csv.pushdown_complex_filter = CSVComplexFilterPushdown;
-	read_csv.serialize = CSVReaderSerialize;
-	read_csv.deserialize = CSVReaderDeserialize;
-	read_csv.get_partition_data = CSVReaderGetPartitionData;
-	read_csv.cardinality = CSVReaderCardinality;
-	read_csv.projection_pushdown = true;
-	read_csv.type_pushdown = PushdownTypeToCSVScanner;
-	ReadCSVAddNamedParameters(read_csv);
-	return read_csv;
-}
-
-TableFunction ReadCSVTableFunction::GetAutoFunction() {
-	auto read_csv_auto = ReadCSVTableFunction::GetFunction();
-	read_csv_auto.name = "read_csv_auto";
-	read_csv_auto.bind = ReadCSVBind;
-	return read_csv_auto;
-}
-
-void ReadCSVTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(MultiFileReader::CreateFunctionSet(ReadCSVTableFunction::GetFunction()));
-	set.AddFunction(MultiFileReader::CreateFunctionSet(ReadCSVTableFunction::GetAutoFunction()));
-}
-
-unique_ptr<TableRef> ReadCSVReplacement(ClientContext &context, ReplacementScanInput &input,
-                                        optional_ptr<ReplacementScanData> data) {
-	auto table_name = ReplacementScan::GetFullPath(input);
-	auto lower_name = StringUtil::Lower(table_name);
-	// remove any compression
-	if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::GZIP))) {
-		lower_name = lower_name.substr(0, lower_name.size() - 3);
-	} else if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::ZSTD))) {
-		if (!Catalog::TryAutoLoad(context, "parquet")) {
-			throw MissingExtensionException("parquet extension is required for reading zst compressed file");
-		}
-		lower_name = lower_name.substr(0, lower_name.size() - 4);
-	}
-	if (!StringUtil::EndsWith(lower_name, ".csv") && !StringUtil::Contains(lower_name, ".csv?") &&
-	    !StringUtil::EndsWith(lower_name, ".tsv") && !StringUtil::Contains(lower_name, ".tsv?")) {
-		return nullptr;
-	}
-	auto table_function = make_uniq<TableFunctionRef>();
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_uniq<ConstantExpression>(Value(table_name)));
-	table_function->function = make_uniq<FunctionExpression>("read_csv_auto", std::move(children));
-
-	if (!FileSystem::HasGlob(table_name)) {
-		auto &fs = FileSystem::GetFileSystem(context);
-		table_function->alias = fs.ExtractBaseName(table_name);
-	}
-
-	return std::move(table_function);
-}
-
-void BuiltinFunctions::RegisterReadFunctions() {
-	CSVCopyFunction::RegisterFunction(*this);
-	ReadCSVTableFunction::RegisterFunction(*this);
-	auto &config = DBConfig::GetConfig(*transaction.db);
-	config.replacement_scans.emplace_back(ReadCSVReplacement);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/read_file.cpp b/src/duckdb/src/function/table/read_file.cpp
deleted file mode 100644
index 158e89fd0..000000000
--- a/src/duckdb/src/function/table/read_file.cpp
+++ /dev/null
@@ -1,266 +0,0 @@
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/function/table/range.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-struct ReadBlobOperation {
-	static constexpr const char *NAME = "read_blob";
-	static constexpr const char *FILE_TYPE = "blob";
-
-	static inline LogicalType TYPE() {
-		return LogicalType::BLOB;
-	}
-
-	static inline void VERIFY(const string &, const string_t &) {
-	}
-};
-
-struct ReadTextOperation {
-	static constexpr const char *NAME = "read_text";
-	static constexpr const char *FILE_TYPE = "text";
-
-	static inline LogicalType TYPE() {
-		return LogicalType::VARCHAR;
-	}
-
-	static inline void VERIFY(const string &filename, const string_t &content) {
-		if (Utf8Proc::Analyze(content.GetData(), content.GetSize()) == UnicodeType::INVALID) {
-			throw InvalidInputException(
-			    "read_text: could not read content of file '%s' as valid UTF-8 encoded text. You "
-			    "may want to use read_blob instead.",
-			    filename);
-		}
-	}
-};
-
-//------------------------------------------------------------------------------
-// Bind
-//------------------------------------------------------------------------------
-struct ReadFileBindData : public TableFunctionData {
-	vector<string> files;
-
-	static constexpr const idx_t FILE_NAME_COLUMN = 0;
-	static constexpr const idx_t FILE_CONTENT_COLUMN = 1;
-	static constexpr const idx_t FILE_SIZE_COLUMN = 2;
-	static constexpr const idx_t FILE_LAST_MODIFIED_COLUMN = 3;
-};
-
-template <class OP>
-static unique_ptr<FunctionData> ReadFileBind(ClientContext &context, TableFunctionBindInput &input,
-                                             vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<ReadFileBindData>();
-
-	auto multi_file_reader = MultiFileReader::Create(input.table_function);
-	result->files =
-	    multi_file_reader->CreateFileList(context, input.inputs[0], FileGlobOptions::ALLOW_EMPTY)->GetAllFiles();
-
-	return_types.push_back(LogicalType::VARCHAR);
-	names.push_back("filename");
-	return_types.push_back(OP::TYPE());
-	names.push_back("content");
-	return_types.push_back(LogicalType::BIGINT);
-	names.push_back("size");
-	return_types.push_back(LogicalType::TIMESTAMP_TZ);
-	names.push_back("last_modified");
-
-	return std::move(result);
-}
-
-//------------------------------------------------------------------------------
-// Global state
-//------------------------------------------------------------------------------
-struct ReadFileGlobalState : public GlobalTableFunctionState {
-	ReadFileGlobalState() : current_file_idx(0) {
-	}
-
-	atomic<idx_t> current_file_idx;
-	vector<string> files;
-	vector<idx_t> column_ids;
-	bool requires_file_open = false;
-};
-
-static unique_ptr<GlobalTableFunctionState> ReadFileInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<ReadFileBindData>();
-	auto result = make_uniq<ReadFileGlobalState>();
-
-	result->files = bind_data.files;
-	result->current_file_idx = 0;
-	result->column_ids = input.column_ids;
-
-	for (const auto &column_id : input.column_ids) {
-		// For everything except the 'file' name column, we need to open the file
-		if (column_id != ReadFileBindData::FILE_NAME_COLUMN && column_id != COLUMN_IDENTIFIER_ROW_ID) {
-			result->requires_file_open = true;
-			break;
-		}
-	}
-
-	return std::move(result);
-}
-
-//------------------------------------------------------------------------------
-// Execute
-//------------------------------------------------------------------------------
-static void AssertMaxFileSize(const string &file_name, idx_t file_size) {
-	const auto max_file_size = NumericLimits<uint32_t>::Maximum();
-	if (file_size > max_file_size) {
-		auto max_byte_size_format = StringUtil::BytesToHumanReadableString(max_file_size);
-		auto file_byte_size_format = StringUtil::BytesToHumanReadableString(file_size);
-		auto error_msg = StringUtil::Format("File '%s' size (%s) exceeds maximum allowed file (%s)", file_name.c_str(),
-		                                    file_byte_size_format, max_byte_size_format);
-		throw InvalidInputException(error_msg);
-	}
-}
-
-template <class OP>
-static void ReadFileExecute(ClientContext &context, TableFunctionInput &input, DataChunk &output) {
-	auto &bind_data = input.bind_data->Cast<ReadFileBindData>();
-	auto &state = input.global_state->Cast<ReadFileGlobalState>();
-	auto &fs = FileSystem::GetFileSystem(context);
-
-	auto output_count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, bind_data.files.size() - state.current_file_idx);
-
-	// We utilize projection pushdown here to only read the file content if the 'data' column is requested
-	for (idx_t out_idx = 0; out_idx < output_count; out_idx++) {
-		// Add the file name to the output
-		auto &file_name = bind_data.files[state.current_file_idx + out_idx];
-
-		unique_ptr<FileHandle> file_handle = nullptr;
-
-		// Given the columns requested, do we even need to open the file?
-		if (state.requires_file_open) {
-			file_handle = fs.OpenFile(file_name, FileFlags::FILE_FLAGS_READ);
-		}
-
-		for (idx_t col_idx = 0; col_idx < state.column_ids.size(); col_idx++) {
-			// We utilize projection pushdown to avoid potentially expensive fs operations.
-			auto proj_idx = state.column_ids[col_idx];
-			if (proj_idx == COLUMN_IDENTIFIER_ROW_ID) {
-				continue;
-			}
-			try {
-				switch (proj_idx) {
-				case ReadFileBindData::FILE_NAME_COLUMN: {
-					auto &file_name_vector = output.data[col_idx];
-					auto file_name_string = StringVector::AddString(file_name_vector, file_name);
-					FlatVector::GetData<string_t>(file_name_vector)[out_idx] = file_name_string;
-				} break;
-				case ReadFileBindData::FILE_CONTENT_COLUMN: {
-					auto file_size_raw = file_handle->GetFileSize();
-					AssertMaxFileSize(file_name, file_size_raw);
-					auto file_size = UnsafeNumericCast<int64_t>(file_size_raw);
-					auto &file_content_vector = output.data[col_idx];
-					auto content_string = StringVector::EmptyString(file_content_vector, file_size_raw);
-
-					auto remaining_bytes = UnsafeNumericCast<int64_t>(file_size);
-
-					// Read in batches of 100mb
-					constexpr auto MAX_READ_SIZE = 100LL * 1024 * 1024;
-					while (remaining_bytes > 0) {
-						const auto bytes_to_read = MinValue<int64_t>(remaining_bytes, MAX_READ_SIZE);
-						const auto content_string_ptr =
-						    content_string.GetDataWriteable() + (file_size - remaining_bytes);
-						const auto actually_read =
-						    file_handle->Read(content_string_ptr, UnsafeNumericCast<idx_t>(bytes_to_read));
-						if (actually_read == 0) {
-							// Uh oh, random EOF?
-							throw IOException("Failed to read file '%s' at offset %lu, unexpected EOF", file_name,
-							                  file_size - remaining_bytes);
-						}
-						remaining_bytes -= actually_read;
-					}
-
-					content_string.Finalize();
-
-					OP::VERIFY(file_name, content_string);
-
-					FlatVector::GetData<string_t>(file_content_vector)[out_idx] = content_string;
-				} break;
-				case ReadFileBindData::FILE_SIZE_COLUMN: {
-					auto &file_size_vector = output.data[col_idx];
-					FlatVector::GetData<int64_t>(file_size_vector)[out_idx] =
-					    NumericCast<int64_t>(file_handle->GetFileSize());
-				} break;
-				case ReadFileBindData::FILE_LAST_MODIFIED_COLUMN: {
-					auto &last_modified_vector = output.data[col_idx];
-					// This can sometimes fail (e.g. httpfs file system cant always parse the last modified time
-					// correctly)
-					try {
-						auto timestamp_seconds = Timestamp::FromEpochSeconds(fs.GetLastModifiedTime(*file_handle));
-						FlatVector::GetData<timestamp_tz_t>(last_modified_vector)[out_idx] =
-						    timestamp_tz_t(timestamp_seconds);
-					} catch (std::exception &ex) {
-						ErrorData error(ex);
-						if (error.Type() == ExceptionType::CONVERSION) {
-							FlatVector::SetNull(last_modified_vector, out_idx, true);
-						} else {
-							throw;
-						}
-					}
-				} break;
-				default:
-					throw InternalException("Unsupported column index for read_file");
-				}
-			}
-			// Filesystems are not required to support all operations, so we just set the column to NULL if not
-			// implemented
-			catch (std::exception &ex) {
-				ErrorData error(ex);
-				if (error.Type() == ExceptionType::NOT_IMPLEMENTED) {
-					FlatVector::SetNull(output.data[col_idx], out_idx, true);
-				} else {
-					throw;
-				}
-			}
-		}
-	}
-
-	state.current_file_idx += output_count;
-	output.SetCardinality(output_count);
-}
-
-//------------------------------------------------------------------------------
-// Misc
-//------------------------------------------------------------------------------
-
-static double ReadFileProgress(ClientContext &context, const FunctionData *bind_data,
-                               const GlobalTableFunctionState *gstate) {
-	auto &state = gstate->Cast<ReadFileGlobalState>();
-	return static_cast<double>(state.current_file_idx) / static_cast<double>(state.files.size());
-}
-
-static unique_ptr<NodeStatistics> ReadFileCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<ReadFileBindData>();
-	auto result = make_uniq<NodeStatistics>();
-	result->has_max_cardinality = true;
-	result->max_cardinality = bind_data.files.size();
-	result->has_estimated_cardinality = true;
-	result->estimated_cardinality = bind_data.files.size();
-	return result;
-}
-
-//------------------------------------------------------------------------------
-// Register
-//------------------------------------------------------------------------------
-template <class OP>
-static TableFunction GetFunction() {
-	TableFunction func(OP::NAME, {LogicalType::VARCHAR}, ReadFileExecute<OP>, ReadFileBind<OP>, ReadFileInitGlobal);
-	func.table_scan_progress = ReadFileProgress;
-	func.cardinality = ReadFileCardinality;
-	func.projection_pushdown = true;
-	return func;
-}
-
-void ReadBlobFunction::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(MultiFileReader::CreateFunctionSet(GetFunction<ReadBlobOperation>()));
-}
-
-void ReadTextFunction::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(MultiFileReader::CreateFunctionSet(GetFunction<ReadTextOperation>()));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/repeat.cpp b/src/duckdb/src/function/table/repeat.cpp
deleted file mode 100644
index 08fdc0086..000000000
--- a/src/duckdb/src/function/table/repeat.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-struct RepeatFunctionData : public TableFunctionData {
-	RepeatFunctionData(Value value, idx_t target_count) : value(std::move(value)), target_count(target_count) {
-	}
-
-	Value value;
-	idx_t target_count;
-};
-
-struct RepeatOperatorData : public GlobalTableFunctionState {
-	RepeatOperatorData() : current_count(0) {
-	}
-	idx_t current_count;
-};
-
-static unique_ptr<FunctionData> RepeatBind(ClientContext &context, TableFunctionBindInput &input,
-                                           vector<LogicalType> &return_types, vector<string> &names) {
-	// the repeat function returns the type of the first argument
-	auto &inputs = input.inputs;
-	return_types.push_back(inputs[0].type());
-	names.push_back(inputs[0].ToString());
-	if (inputs[1].IsNull()) {
-		throw BinderException("Repeat second parameter cannot be NULL");
-	}
-	auto repeat_count = inputs[1].GetValue<int64_t>();
-	if (repeat_count < 0) {
-		throw BinderException("Repeat second parameter cannot be be less than 0");
-	}
-	return make_uniq<RepeatFunctionData>(inputs[0], NumericCast<idx_t>(repeat_count));
-}
-
-static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<RepeatOperatorData>();
-}
-
-static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<RepeatFunctionData>();
-	auto &state = data_p.global_state->Cast<RepeatOperatorData>();
-
-	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
-	output.data[0].Reference(bind_data.value);
-	output.SetCardinality(remaining);
-	state.current_count += remaining;
-}
-
-static unique_ptr<NodeStatistics> RepeatCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<RepeatFunctionData>();
-	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
-}
-
-void RepeatTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction repeat("repeat", {LogicalType::ANY, LogicalType::BIGINT}, RepeatFunction, RepeatBind, RepeatInit);
-	repeat.cardinality = RepeatCardinality;
-	set.AddFunction(repeat);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/repeat_row.cpp b/src/duckdb/src/function/table/repeat_row.cpp
deleted file mode 100644
index f68bf7cae..000000000
--- a/src/duckdb/src/function/table/repeat_row.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-struct RepeatRowFunctionData : public TableFunctionData {
-	RepeatRowFunctionData(vector<Value> values, idx_t target_count)
-	    : values(std::move(values)), target_count(target_count) {
-	}
-
-	const vector<Value> values;
-	idx_t target_count;
-};
-
-struct RepeatRowOperatorData : public GlobalTableFunctionState {
-	RepeatRowOperatorData() : current_count(0) {
-	}
-	idx_t current_count;
-};
-
-static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunctionBindInput &input,
-                                              vector<LogicalType> &return_types, vector<string> &names) {
-	auto &inputs = input.inputs;
-	for (idx_t input_idx = 0; input_idx < inputs.size(); input_idx++) {
-		return_types.push_back(inputs[input_idx].type());
-		names.push_back("column" + std::to_string(input_idx));
-	}
-	auto entry = input.named_parameters.find("num_rows");
-	if (entry == input.named_parameters.end()) {
-		throw BinderException("repeat_rows requires num_rows to be specified");
-	}
-	if (inputs.empty()) {
-		throw BinderException("repeat_rows requires at least one column to be specified");
-	}
-	return make_uniq<RepeatRowFunctionData>(inputs, NumericCast<idx_t>(entry->second.GetValue<int64_t>()));
-}
-
-static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<RepeatRowOperatorData>();
-}
-
-static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<RepeatRowFunctionData>();
-	auto &state = data_p.global_state->Cast<RepeatRowOperatorData>();
-
-	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
-	for (idx_t val_idx = 0; val_idx < bind_data.values.size(); val_idx++) {
-		output.data[val_idx].Reference(bind_data.values[val_idx]);
-	}
-	output.SetCardinality(remaining);
-	state.current_count += remaining;
-}
-
-static unique_ptr<NodeStatistics> RepeatRowCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<RepeatRowFunctionData>();
-	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
-}
-
-void RepeatRowTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction repeat_row("repeat_row", {}, RepeatRowFunction, RepeatRowBind, RepeatRowInit);
-	repeat_row.varargs = LogicalType::ANY;
-	repeat_row.named_parameters["num_rows"] = LogicalType::BIGINT;
-	repeat_row.cardinality = RepeatRowCardinality;
-	set.AddFunction(repeat_row);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/sniff_csv.cpp b/src/duckdb/src/function/table/sniff_csv.cpp
deleted file mode 100644
index 5c72aabb9..000000000
--- a/src/duckdb/src/function/table/sniff_csv.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-
-namespace duckdb {
-
-struct CSVSniffFunctionData : public TableFunctionData {
-	CSVSniffFunctionData() {
-	}
-	string path;
-	// The CSV reader options
-	CSVReaderOptions options;
-	// Return Types of CSV (If given by the user)
-	vector<LogicalType> return_types_csv;
-	// Column Names of CSV (If given by the user)
-	vector<string> names_csv;
-	// If we want to force the match of the sniffer types
-	bool force_match = true;
-};
-
-struct CSVSniffGlobalState : public GlobalTableFunctionState {
-	CSVSniffGlobalState() {
-	}
-	bool done = false;
-};
-
-static unique_ptr<GlobalTableFunctionState> CSVSniffInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<CSVSniffGlobalState>();
-}
-
-static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFunctionBindInput &input,
-                                             vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<CSVSniffFunctionData>();
-	if (input.inputs[0].IsNull()) {
-		throw BinderException("sniff_csv cannot take NULL as a file path parameter");
-	}
-	result->path = input.inputs[0].ToString();
-	auto it = input.named_parameters.find("auto_detect");
-	if (it != input.named_parameters.end()) {
-		if (it->second.IsNull()) {
-			throw BinderException("\"%s\" expects a non-null boolean value (e.g. TRUE or 1)", it->first);
-		}
-		if (!it->second.GetValue<bool>()) {
-			throw InvalidInputException("sniff_csv function does not accept auto_detect variable set to false");
-		}
-		// otherwise remove it
-		input.named_parameters.erase("auto_detect");
-	}
-
-	// If we want to force the match of the sniffer
-	it = input.named_parameters.find("force_match");
-	if (it != input.named_parameters.end()) {
-		result->force_match = it->second.GetValue<bool>();
-		input.named_parameters.erase("force_match");
-	}
-	result->options.FromNamedParameters(input.named_parameters, context);
-	result->options.Verify();
-
-	// We want to return the whole CSV Configuration
-	// 1. Delimiter
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("Delimiter");
-	// 2. Quote
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("Quote");
-	// 3. Escape
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("Escape");
-	// 4. NewLine Delimiter
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("NewLineDelimiter");
-	// 5. Comment
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("Comment");
-	// 6. Skip Rows
-	return_types.emplace_back(LogicalType::UINTEGER);
-	names.emplace_back("SkipRows");
-	// 7. Has Header
-	return_types.emplace_back(LogicalType::BOOLEAN);
-	names.emplace_back("HasHeader");
-	// 8. List<Struct<Column-Name:Types>>
-	child_list_t<LogicalType> struct_children {{"name", LogicalType::VARCHAR}, {"type", LogicalType::VARCHAR}};
-	auto list_child = LogicalType::STRUCT(struct_children);
-	return_types.emplace_back(LogicalType::LIST(list_child));
-	names.emplace_back("Columns");
-	// 9. Date Format
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("DateFormat");
-	// 10. Timestamp Format
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("TimestampFormat");
-	// 11. CSV read function with all the options used
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("UserArguments");
-	// 12. CSV read function with all the options used
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("Prompt");
-	return std::move(result);
-}
-
-string FormatOptions(char opt) {
-	if (opt == '\'') {
-		return "''";
-	}
-	if (opt == '\0') {
-		return "";
-	}
-	string result;
-	result += opt;
-	return result;
-}
-
-string FormatOptions(string opt) {
-	if (opt.size() == 1) {
-		return FormatOptions(opt[0]);
-	}
-	return opt;
-}
-
-static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &global_state = data_p.global_state->Cast<CSVSniffGlobalState>();
-	// Are we done?
-	if (global_state.done) {
-		return;
-	}
-	const CSVSniffFunctionData &data = data_p.bind_data->Cast<CSVSniffFunctionData>();
-	auto &fs = duckdb::FileSystem::GetFileSystem(context);
-
-	auto paths = fs.GlobFiles(data.path, context, FileGlobOptions::DISALLOW_EMPTY);
-	if (paths.size() > 1) {
-		throw NotImplementedException("sniff_csv does not operate on more than one file yet");
-	}
-
-	// We must run the sniffer.
-	auto sniffer_options = data.options;
-	sniffer_options.file_path = paths[0];
-
-	auto buffer_manager = make_shared_ptr<CSVBufferManager>(context, sniffer_options, sniffer_options.file_path, 0);
-	if (sniffer_options.name_list.empty()) {
-		sniffer_options.name_list = data.names_csv;
-	}
-
-	if (sniffer_options.sql_type_list.empty()) {
-		sniffer_options.sql_type_list = data.return_types_csv;
-	}
-	CSVSniffer sniffer(sniffer_options, buffer_manager, CSVStateMachineCache::Get(context));
-	auto sniffer_result = sniffer.SniffCSV(data.force_match);
-	string str_opt;
-	string separator = ", ";
-	// Set output
-	output.SetCardinality(1);
-
-	// 1. Delimiter
-	str_opt = sniffer_options.dialect_options.state_machine_options.delimiter.GetValue();
-	output.SetValue(0, 0, str_opt);
-	// 2. Quote
-	str_opt = sniffer_options.dialect_options.state_machine_options.quote.GetValue();
-	output.SetValue(1, 0, str_opt);
-	// 3. Escape
-	str_opt = sniffer_options.dialect_options.state_machine_options.escape.GetValue();
-	output.SetValue(2, 0, str_opt);
-	// 4. NewLine Delimiter
-	auto new_line_identifier = sniffer_options.NewLineIdentifierToString();
-	output.SetValue(3, 0, new_line_identifier);
-	// 5. Comment
-	str_opt = sniffer_options.dialect_options.state_machine_options.comment.GetValue();
-	output.SetValue(4, 0, str_opt);
-	// 6. Skip Rows
-	output.SetValue(5, 0, Value::UINTEGER(NumericCast<uint32_t>(sniffer_options.dialect_options.skip_rows.GetValue())));
-	// 7. Has Header
-	auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue());
-	output.SetValue(6, 0, has_header);
-	// 8. List<Struct<Column-Name:Types>> {'col1': 'INTEGER', 'col2': 'VARCHAR'}
-	vector<Value> values;
-	std::ostringstream columns;
-	columns << "{";
-	for (idx_t i = 0; i < sniffer_result.return_types.size(); i++) {
-		child_list_t<Value> struct_children {{"name", sniffer_result.names[i]},
-		                                     {"type", {sniffer_result.return_types[i].ToString()}}};
-		values.emplace_back(Value::STRUCT(struct_children));
-		columns << "'" << sniffer_result.names[i] << "': '" << sniffer_result.return_types[i].ToString() << "'";
-		if (i != sniffer_result.return_types.size() - 1) {
-			columns << separator;
-		}
-	}
-	columns << "}";
-	output.SetValue(7, 0, Value::LIST(values));
-	// 9. Date Format
-	auto date_format = sniffer_options.dialect_options.date_format[LogicalType::DATE].GetValue();
-	if (!date_format.Empty()) {
-		output.SetValue(8, 0, date_format.format_specifier);
-	} else {
-		bool has_date = false;
-		for (auto &c_type : sniffer_result.return_types) {
-			// Must be ISO 8601
-			if (c_type.id() == LogicalTypeId::DATE) {
-				output.SetValue(8, 0, Value("%Y-%m-%d"));
-				has_date = true;
-			}
-		}
-		if (!has_date) {
-			output.SetValue(8, 0, Value(nullptr));
-		}
-	}
-
-	// 10. Timestamp Format
-	auto timestamp_format = sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue();
-	if (!timestamp_format.Empty()) {
-		output.SetValue(9, 0, timestamp_format.format_specifier);
-	} else {
-		output.SetValue(9, 0, Value(nullptr));
-	}
-
-	// 11. The Extra User Arguments
-	if (data.options.user_defined_parameters.empty()) {
-		output.SetValue(10, 0, Value());
-	} else {
-		output.SetValue(10, 0, Value(data.options.user_defined_parameters));
-	}
-
-	// 12. csv_read string
-	std::ostringstream csv_read;
-
-	// Base, Path and auto_detect=false
-	csv_read << "FROM read_csv('" << paths[0] << "'" << separator << "auto_detect=false" << separator;
-	// 10.1. Delimiter
-	if (!sniffer_options.dialect_options.state_machine_options.delimiter.IsSetByUser()) {
-		csv_read << "delim="
-		         << "'" << FormatOptions(sniffer_options.dialect_options.state_machine_options.delimiter.GetValue())
-		         << "'" << separator;
-	}
-	// 11.2. Quote
-	if (!sniffer_options.dialect_options.state_machine_options.quote.IsSetByUser()) {
-		csv_read << "quote="
-		         << "'" << FormatOptions(sniffer_options.dialect_options.state_machine_options.quote.GetValue()) << "'"
-		         << separator;
-	}
-	// 11.3. Escape
-	if (!sniffer_options.dialect_options.state_machine_options.escape.IsSetByUser()) {
-		csv_read << "escape="
-		         << "'" << FormatOptions(sniffer_options.dialect_options.state_machine_options.escape.GetValue()) << "'"
-		         << separator;
-	}
-	// 11.4. NewLine Delimiter
-	if (!sniffer_options.dialect_options.state_machine_options.new_line.IsSetByUser()) {
-		if (new_line_identifier != "mix") {
-			csv_read << "new_line="
-			         << "'" << new_line_identifier << "'" << separator;
-		}
-	}
-	// 11.5. Skip Rows
-	if (!sniffer_options.dialect_options.skip_rows.IsSetByUser()) {
-		csv_read << "skip=" << sniffer_options.dialect_options.skip_rows.GetValue() << separator;
-	}
-
-	// 11.6. Comment
-	if (!sniffer_options.dialect_options.state_machine_options.comment.IsSetByUser()) {
-		csv_read << "comment="
-		         << "'" << FormatOptions(sniffer_options.dialect_options.state_machine_options.comment.GetValue())
-		         << "'" << separator;
-	}
-
-	// 11.7. Has Header
-	if (!sniffer_options.dialect_options.header.IsSetByUser()) {
-		csv_read << "header=" << has_header << separator;
-	}
-	// 11.8. column={'col1': 'INTEGER', 'col2': 'VARCHAR'}
-	csv_read << "columns=" << columns.str();
-	// 11.9. Date Format
-	if (!sniffer_options.dialect_options.date_format[LogicalType::DATE].IsSetByUser()) {
-		if (!sniffer_options.dialect_options.date_format[LogicalType::DATE].GetValue().format_specifier.empty()) {
-			csv_read << separator << "dateformat="
-			         << "'"
-			         << sniffer_options.dialect_options.date_format[LogicalType::DATE].GetValue().format_specifier
-			         << "'";
-		} else {
-			for (auto &c_type : sniffer_result.return_types) {
-				// Must be ISO 8601
-				if (c_type.id() == LogicalTypeId::DATE) {
-					csv_read << separator << "dateformat="
-					         << "'%Y-%m-%d'";
-					break;
-				}
-			}
-		}
-	}
-	// 11.10. Timestamp Format
-	if (!sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].IsSetByUser()) {
-		if (!sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue().format_specifier.empty()) {
-			csv_read << separator << "timestampformat="
-			         << "'"
-			         << sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue().format_specifier
-			         << "'";
-		}
-	}
-	// 11.11 User Arguments
-	if (!data.options.user_defined_parameters.empty()) {
-		csv_read << separator << data.options.user_defined_parameters;
-	}
-	csv_read << ");";
-	output.SetValue(11, 0, csv_read.str());
-	global_state.done = true;
-}
-
-void CSVSnifferFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction csv_sniffer("sniff_csv", {LogicalType::VARCHAR}, CSVSniffFunction, CSVSniffBind, CSVSniffInitGlobal);
-	// Accept same options as the actual csv reader
-	ReadCSVTableFunction::ReadCSVAddNamedParameters(csv_sniffer);
-	csv_sniffer.named_parameters["force_match"] = LogicalType::BOOLEAN;
-	set.AddFunction(csv_sniffer);
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/summary.cpp b/src/duckdb/src/function/table/summary.cpp
deleted file mode 100644
index d6c4615e4..000000000
--- a/src/duckdb/src/function/table/summary.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/function/table/summary.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/common/file_system.hpp"
-
-// this function makes not that much sense on its own but is a demo for table-parameter table-producing functions
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("summary");
-
-	for (idx_t i = 0; i < input.input_table_types.size(); i++) {
-		return_types.push_back(input.input_table_types[i]);
-		names.emplace_back(input.input_table_names[i]);
-	}
-
-	return make_uniq<TableFunctionData>();
-}
-
-static OperatorResultType SummaryFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
-                                          DataChunk &output) {
-	output.SetCardinality(input.size());
-
-	for (idx_t row_idx = 0; row_idx < input.size(); row_idx++) {
-		string summary_val = "[";
-
-		for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-			summary_val += input.GetValue(col_idx, row_idx).ToString();
-			if (col_idx < input.ColumnCount() - 1) {
-				summary_val += ", ";
-			}
-		}
-		summary_val += "]";
-		output.SetValue(0, row_idx, Value(summary_val));
-	}
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		output.data[col_idx + 1].Reference(input.data[col_idx]);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-void SummaryTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction summary_function("summary", {LogicalType::TABLE}, nullptr, SummaryFunctionBind);
-	summary_function.in_out_function = SummaryFunction;
-	set.AddFunction(summary_function);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_columns.cpp b/src/duckdb/src/function/table/system/duckdb_columns.cpp
deleted file mode 100644
index d30ea5300..000000000
--- a/src/duckdb/src/function/table/system/duckdb_columns.cpp
+++ /dev/null
@@ -1,350 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-
-#include <set>
-
-namespace duckdb {
-
-struct DuckDBColumnsData : public GlobalTableFunctionState {
-	DuckDBColumnsData() : offset(0), column_offset(0) {
-	}
-
-	vector<reference<CatalogEntry>> entries;
-	idx_t offset;
-	idx_t column_offset;
-};
-
-static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("column_index");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("column_default");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("is_nullable");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("data_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("data_type_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("character_maximum_length");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("numeric_precision");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("numeric_precision_radix");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("numeric_scale");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBColumnsData>();
-
-	// scan all the schemas for tables and views and collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::TABLE_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
-	}
-	return std::move(result);
-}
-
-class ColumnHelper {
-public:
-	static unique_ptr<ColumnHelper> Create(CatalogEntry &entry);
-
-	virtual ~ColumnHelper() {
-	}
-
-	virtual StandardEntry &Entry() = 0;
-	virtual idx_t NumColumns() = 0;
-	virtual const string &ColumnName(idx_t col) = 0;
-	virtual const LogicalType &ColumnType(idx_t col) = 0;
-	virtual const Value ColumnDefault(idx_t col) = 0;
-	virtual bool IsNullable(idx_t col) = 0;
-	virtual const Value ColumnComment(idx_t col) = 0;
-
-	void WriteColumns(idx_t index, idx_t start_col, idx_t end_col, DataChunk &output);
-};
-
-class TableColumnHelper : public ColumnHelper {
-public:
-	explicit TableColumnHelper(TableCatalogEntry &entry) : entry(entry) {
-		for (auto &constraint : entry.GetConstraints()) {
-			if (constraint->type == ConstraintType::NOT_NULL) {
-				auto &not_null = constraint->Cast<NotNullConstraint>();
-				not_null_cols.insert(not_null.index.index);
-			}
-		}
-	}
-
-	StandardEntry &Entry() override {
-		return entry;
-	}
-	idx_t NumColumns() override {
-		return entry.GetColumns().LogicalColumnCount();
-	}
-	const string &ColumnName(idx_t col) override {
-		return entry.GetColumn(LogicalIndex(col)).Name();
-	}
-	const LogicalType &ColumnType(idx_t col) override {
-		return entry.GetColumn(LogicalIndex(col)).Type();
-	}
-	const Value ColumnDefault(idx_t col) override {
-		auto &column = entry.GetColumn(LogicalIndex(col));
-		if (column.Generated()) {
-			return Value(column.GeneratedExpression().ToString());
-		} else if (column.HasDefaultValue()) {
-			return Value(column.DefaultValue().ToString());
-		}
-		return Value();
-	}
-	bool IsNullable(idx_t col) override {
-		return not_null_cols.find(col) == not_null_cols.end();
-	}
-	const Value ColumnComment(idx_t col) override {
-		return entry.GetColumn(LogicalIndex(col)).Comment();
-	}
-
-private:
-	TableCatalogEntry &entry;
-	std::set<idx_t> not_null_cols;
-};
-
-class ViewColumnHelper : public ColumnHelper {
-public:
-	explicit ViewColumnHelper(ViewCatalogEntry &entry) : entry(entry) {
-	}
-
-	StandardEntry &Entry() override {
-		return entry;
-	}
-	idx_t NumColumns() override {
-		return entry.types.size();
-	}
-	const string &ColumnName(idx_t col) override {
-		return col < entry.aliases.size() ? entry.aliases[col] : entry.names[col];
-	}
-	const LogicalType &ColumnType(idx_t col) override {
-		return entry.types[col];
-	}
-	const Value ColumnDefault(idx_t col) override {
-		return Value();
-	}
-	bool IsNullable(idx_t col) override {
-		return true;
-	}
-	const Value ColumnComment(idx_t col) override {
-		if (entry.column_comments.empty()) {
-			return Value();
-		}
-		D_ASSERT(entry.column_comments.size() == entry.types.size());
-		return entry.column_comments[col];
-	}
-
-private:
-	ViewCatalogEntry &entry;
-};
-
-unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry &entry) {
-	switch (entry.type) {
-	case CatalogType::TABLE_ENTRY:
-		return make_uniq<TableColumnHelper>(entry.Cast<TableCatalogEntry>());
-	case CatalogType::VIEW_ENTRY:
-		return make_uniq<ViewColumnHelper>(entry.Cast<ViewCatalogEntry>());
-	default:
-		throw NotImplementedException("Unsupported catalog type for duckdb_columns");
-	}
-}
-
-void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_col, DataChunk &output) {
-	for (idx_t i = start_col; i < end_col; i++) {
-		auto index = start_index + (i - start_col);
-		auto &entry = Entry();
-
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, index, entry.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(NumericCast<int64_t>(entry.catalog.GetOid())));
-		// schema_name, VARCHAR
-		output.SetValue(col++, index, entry.schema.name);
-		// schema_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(NumericCast<int64_t>(entry.schema.oid)));
-		// table_name, VARCHAR
-		output.SetValue(col++, index, entry.name);
-		// table_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(NumericCast<int64_t>(entry.oid)));
-		// column_name, VARCHAR
-		output.SetValue(col++, index, Value(ColumnName(i)));
-		// column_index, INTEGER
-		output.SetValue(col++, index, Value::INTEGER(UnsafeNumericCast<int32_t>(i + 1)));
-		// comment, VARCHAR
-		output.SetValue(col++, index, ColumnComment(i));
-		// internal, BOOLEAN
-		output.SetValue(col++, index, Value::BOOLEAN(entry.internal));
-		// column_default, VARCHAR
-		output.SetValue(col++, index, Value(ColumnDefault(i)));
-		// is_nullable, BOOLEAN
-		output.SetValue(col++, index, Value::BOOLEAN(IsNullable(i)));
-		// data_type, VARCHAR
-		const LogicalType &type = ColumnType(i);
-		output.SetValue(col++, index, Value(type.ToString()));
-		// data_type_id, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(int(type.id())));
-		if (type == LogicalType::VARCHAR) {
-			// FIXME: need check constraints in place to set this correctly
-			// character_maximum_length, INTEGER
-			output.SetValue(col++, index, Value());
-		} else {
-			// "character_maximum_length", PhysicalType::INTEGER
-			output.SetValue(col++, index, Value());
-		}
-
-		Value numeric_precision, numeric_scale, numeric_precision_radix;
-		switch (type.id()) {
-		case LogicalTypeId::DECIMAL:
-			numeric_precision = Value::INTEGER(DecimalType::GetWidth(type));
-			numeric_scale = Value::INTEGER(DecimalType::GetScale(type));
-			numeric_precision_radix = Value::INTEGER(10);
-			break;
-		case LogicalTypeId::HUGEINT:
-			numeric_precision = Value::INTEGER(128);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::BIGINT:
-			numeric_precision = Value::INTEGER(64);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::INTEGER:
-			numeric_precision = Value::INTEGER(32);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::SMALLINT:
-			numeric_precision = Value::INTEGER(16);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::TINYINT:
-			numeric_precision = Value::INTEGER(8);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::FLOAT:
-			numeric_precision = Value::INTEGER(24);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::DOUBLE:
-			numeric_precision = Value::INTEGER(53);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		default:
-			numeric_precision = Value();
-			numeric_scale = Value();
-			numeric_precision_radix = Value();
-			break;
-		}
-
-		// numeric_precision, INTEGER
-		output.SetValue(col++, index, numeric_precision);
-		// numeric_precision_radix, INTEGER
-		output.SetValue(col++, index, numeric_precision_radix);
-		// numeric_scale, INTEGER
-		output.SetValue(col++, index, numeric_scale);
-	}
-}
-
-void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBColumnsData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-
-	// We need to track the offset of the relation we're writing as well as the last column
-	// we wrote from that relation (if any); it's possible that we can fill up the output
-	// with a partial list of columns from a relation and will need to pick up processing the
-	// next chunk at the same spot.
-	idx_t next = data.offset;
-	idx_t column_offset = data.column_offset;
-	idx_t index = 0;
-	while (next < data.entries.size() && index < STANDARD_VECTOR_SIZE) {
-		auto column_helper = ColumnHelper::Create(data.entries[next].get());
-		idx_t columns = column_helper->NumColumns();
-
-		// Check to see if we are going to exceed the maximum index for a DataChunk
-		if (index + (columns - column_offset) > STANDARD_VECTOR_SIZE) {
-			idx_t column_limit = column_offset + (STANDARD_VECTOR_SIZE - index);
-			output.SetCardinality(STANDARD_VECTOR_SIZE);
-			column_helper->WriteColumns(index, column_offset, column_limit, output);
-
-			// Make the current column limit the column offset when we process the next chunk
-			column_offset = column_limit;
-			break;
-		} else {
-			// Otherwise, write all of the columns from the current relation and
-			// then move on to the next one.
-			output.SetCardinality(index + (columns - column_offset));
-			column_helper->WriteColumns(index, column_offset, columns, output);
-			index += columns - column_offset;
-			next++;
-			column_offset = 0;
-		}
-	}
-	data.offset = next;
-	data.column_offset = column_offset;
-}
-
-void DuckDBColumnsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_columns", {}, DuckDBColumnsFunction, DuckDBColumnsBind, DuckDBColumnsInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_constraints.cpp b/src/duckdb/src/function/table/system/duckdb_constraints.cpp
deleted file mode 100644
index 5f436f2c8..000000000
--- a/src/duckdb/src/function/table/system/duckdb_constraints.cpp
+++ /dev/null
@@ -1,341 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/constraints/check_constraint.hpp"
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-namespace duckdb {
-
-struct ConstraintEntry {
-	ConstraintEntry(ClientContext &context, TableCatalogEntry &table) : table(table) {
-		if (!table.IsDuckTable()) {
-			return;
-		}
-		auto binder = Binder::CreateBinder(context);
-		bound_constraints = binder->BindConstraints(table.GetConstraints(), table.name, table.GetColumns());
-	}
-
-	TableCatalogEntry &table;
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-};
-
-struct DuckDBConstraintsData : public GlobalTableFunctionState {
-	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
-	}
-
-	vector<ConstraintEntry> entries;
-	idx_t offset;
-	idx_t constraint_offset;
-	idx_t unique_constraint_offset;
-	case_insensitive_set_t constraint_names;
-};
-
-static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                      vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("constraint_index");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	// CHECK, PRIMARY KEY or UNIQUE
-	names.emplace_back("constraint_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("constraint_text");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("expression");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("constraint_column_indexes");
-	return_types.push_back(LogicalType::LIST(LogicalType::BIGINT));
-
-	names.emplace_back("constraint_column_names");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("constraint_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	// FOREIGN KEY
-	names.emplace_back("referenced_table");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("referenced_column_names");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBConstraintsData>();
-
-	// scan all the schemas for tables and collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-
-	for (auto &schema : schemas) {
-		vector<reference<CatalogEntry>> entries;
-
-		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.type == CatalogType::TABLE_ENTRY) {
-				entries.push_back(entry);
-			}
-		});
-
-		sort(entries.begin(), entries.end(), [&](CatalogEntry &x, CatalogEntry &y) { return (x.name < y.name); });
-		for (auto &entry : entries) {
-			result->entries.emplace_back(context, entry.get().Cast<TableCatalogEntry>());
-		}
-	};
-
-	return std::move(result);
-}
-
-struct ExtraConstraintInfo {
-	vector<LogicalIndex> column_indexes;
-	vector<string> column_names;
-	string referenced_table;
-	vector<string> referenced_columns;
-};
-
-void ExtractReferencedColumns(const ParsedExpression &expr, vector<string> &result) {
-	if (expr.GetExpressionClass() == ExpressionClass::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		result.push_back(colref.GetColumnName());
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { ExtractReferencedColumns(child, result); });
-}
-
-ExtraConstraintInfo GetExtraConstraintInfo(const TableCatalogEntry &table, const Constraint &constraint) {
-	ExtraConstraintInfo result;
-	switch (constraint.type) {
-	case ConstraintType::CHECK: {
-		auto &check_constraint = constraint.Cast<CheckConstraint>();
-		ExtractReferencedColumns(*check_constraint.expression, result.column_names);
-		break;
-	}
-	case ConstraintType::NOT_NULL: {
-		auto &not_null_constraint = constraint.Cast<NotNullConstraint>();
-		result.column_indexes.push_back(not_null_constraint.index);
-		break;
-	}
-	case ConstraintType::UNIQUE: {
-		auto &unique = constraint.Cast<UniqueConstraint>();
-		if (unique.HasIndex()) {
-			result.column_indexes.push_back(unique.GetIndex());
-		} else {
-			result.column_names = unique.GetColumnNames();
-		}
-		break;
-	}
-	case ConstraintType::FOREIGN_KEY: {
-		auto &fk = constraint.Cast<ForeignKeyConstraint>();
-		result.referenced_columns = fk.pk_columns;
-		result.referenced_table = fk.info.table;
-		result.column_names = fk.fk_columns;
-		break;
-	}
-	default:
-		throw InternalException("Unsupported type for constraint name");
-	}
-	if (result.column_indexes.empty()) {
-		// generate column indexes from names
-		for (auto &name : result.column_names) {
-			result.column_indexes.push_back(table.GetColumnIndex(name));
-		}
-	} else {
-		// generate names from column indexes
-		for (auto &index : result.column_indexes) {
-			result.column_names.push_back(table.GetColumn(index).GetName());
-		}
-	}
-	return result;
-}
-
-string GetConstraintName(const TableCatalogEntry &table, Constraint &constraint, const ExtraConstraintInfo &info) {
-	string result = table.name + "_";
-	for (auto &col : info.column_names) {
-		result += StringUtil::Lower(col) + "_";
-	}
-	for (auto &col : info.referenced_columns) {
-		result += StringUtil::Lower(col) + "_";
-	}
-	switch (constraint.type) {
-	case ConstraintType::CHECK:
-		result += "check";
-		break;
-	case ConstraintType::NOT_NULL:
-		result += "not_null";
-		break;
-	case ConstraintType::UNIQUE: {
-		auto &unique = constraint.Cast<UniqueConstraint>();
-		result += unique.IsPrimaryKey() ? "pkey" : "key";
-		break;
-	}
-	case ConstraintType::FOREIGN_KEY:
-		result += "fkey";
-		break;
-	default:
-		throw InternalException("Unsupported type for constraint name");
-	}
-	return result;
-}
-
-void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBConstraintsData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		auto &table = entry.table;
-		auto &constraints = table.GetConstraints();
-		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {
-			auto &constraint = constraints[data.constraint_offset];
-			// return values:
-			// constraint_type, VARCHAR
-			// Processing this first due to shortcut (early continue)
-			string constraint_type;
-			switch (constraint->type) {
-			case ConstraintType::CHECK:
-				constraint_type = "CHECK";
-				break;
-			case ConstraintType::UNIQUE: {
-				auto &unique = constraint->Cast<UniqueConstraint>();
-				constraint_type = unique.IsPrimaryKey() ? "PRIMARY KEY" : "UNIQUE";
-				break;
-			}
-			case ConstraintType::NOT_NULL:
-				constraint_type = "NOT NULL";
-				break;
-			case ConstraintType::FOREIGN_KEY: {
-				auto &fk = constraint->Cast<ForeignKeyConstraint>();
-				if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
-					// Those are already covered by PRIMARY KEY and UNIQUE entries
-					continue;
-				}
-				constraint_type = "FOREIGN KEY";
-				break;
-			}
-			default:
-				throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
-			}
-
-			idx_t col = 0;
-			// database_name, LogicalType::VARCHAR
-			output.SetValue(col++, count, Value(table.schema.catalog.GetName()));
-			// database_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.schema.catalog.GetOid())));
-			// schema_name, LogicalType::VARCHAR
-			output.SetValue(col++, count, Value(table.schema.name));
-			// schema_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.schema.oid)));
-			// table_name, LogicalType::VARCHAR
-			output.SetValue(col++, count, Value(table.name));
-			// table_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.oid)));
-
-			auto info = GetExtraConstraintInfo(table, *constraint);
-			auto constraint_name = GetConstraintName(table, *constraint, info);
-			if (data.constraint_names.find(constraint_name) != data.constraint_names.end()) {
-				// duplicate constraint name
-				idx_t index = 2;
-				while (data.constraint_names.find(constraint_name + "_" + to_string(index)) !=
-				       data.constraint_names.end()) {
-					index++;
-				}
-				constraint_name += "_" + to_string(index);
-			}
-			// constraint_index, BIGINT
-			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(data.unique_constraint_offset++)));
-
-			// constraint_type, VARCHAR
-			output.SetValue(col++, count, Value(constraint_type));
-
-			// constraint_text, VARCHAR
-			output.SetValue(col++, count, Value(constraint->ToString()));
-
-			// expression, VARCHAR
-			Value expression_text;
-			if (constraint->type == ConstraintType::CHECK) {
-				auto &check = constraint->Cast<CheckConstraint>();
-				expression_text = Value(check.expression->ToString());
-			}
-			output.SetValue(col++, count, expression_text);
-
-			vector<Value> column_index_list;
-			vector<Value> column_name_list;
-			vector<Value> referenced_column_name_list;
-			for (auto &col_index : info.column_indexes) {
-				column_index_list.push_back(Value::UBIGINT(col_index.index));
-			}
-			for (auto &name : info.column_names) {
-				column_name_list.push_back(Value(std::move(name)));
-			}
-			for (auto &name : info.referenced_columns) {
-				referenced_column_name_list.push_back(Value(std::move(name)));
-			}
-			// constraint_column_indexes, LIST
-			output.SetValue(col++, count, Value::LIST(LogicalType::BIGINT, std::move(column_index_list)));
-
-			// constraint_column_names, LIST
-			output.SetValue(col++, count, Value::LIST(LogicalType::VARCHAR, std::move(column_name_list)));
-
-			// constraint_name, VARCHAR
-			output.SetValue(col++, count, Value(std::move(constraint_name)));
-
-			// referenced_table, VARCHAR
-			output.SetValue(col++, count,
-			                info.referenced_table.empty() ? Value() : Value(std::move(info.referenced_table)));
-
-			// referenced_column_names, LIST
-			output.SetValue(col++, count, Value::LIST(LogicalType::VARCHAR, std::move(referenced_column_name_list)));
-			count++;
-		}
-
-		if (data.constraint_offset >= constraints.size()) {
-			data.constraint_offset = 0;
-			data.offset++;
-		}
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBConstraintsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_constraints", {}, DuckDBConstraintsFunction, DuckDBConstraintsBind,
-	                              DuckDBConstraintsInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_databases.cpp b/src/duckdb/src/function/table/system/duckdb_databases.cpp
deleted file mode 100644
index 2c7c9c913..000000000
--- a/src/duckdb/src/function/table/system/duckdb_databases.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/attached_database.hpp"
-
-namespace duckdb {
-
-struct DuckDBDatabasesData : public GlobalTableFunctionState {
-	DuckDBDatabasesData() : offset(0) {
-	}
-
-	vector<reference<AttachedDatabase>> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBDatabasesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("path");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("readonly");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBDatabasesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBDatabasesData>();
-
-	// scan all the schemas for tables and collect them and collect them
-	auto &db_manager = DatabaseManager::Get(context);
-	result->entries = db_manager.GetDatabases(context);
-	return std::move(result);
-}
-
-void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBDatabasesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		auto &attached = entry.get().Cast<AttachedDatabase>();
-		// return values:
-
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, attached.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(attached.oid)));
-		bool is_internal = attached.IsSystem() || attached.IsTemporary();
-		bool is_readonly = attached.IsReadOnly();
-		// path, VARCHAR
-		Value db_path;
-		if (!is_internal) {
-			bool in_memory = attached.GetCatalog().InMemory();
-			if (!in_memory) {
-				db_path = Value(attached.GetCatalog().GetDBPath());
-			}
-		}
-		output.SetValue(col++, count, db_path);
-		// comment, VARCHAR
-		output.SetValue(col++, count, Value(attached.comment));
-		// tags, MAP
-		output.SetValue(col++, count, Value::MAP(attached.tags));
-		// internal, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(is_internal));
-		// type, VARCHAR
-		output.SetValue(col++, count, Value(attached.GetCatalog().GetCatalogType()));
-		// readonly, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(is_readonly));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBDatabasesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_databases", {}, DuckDBDatabasesFunction, DuckDBDatabasesBind, DuckDBDatabasesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_dependencies.cpp b/src/duckdb/src/function/table/system/duckdb_dependencies.cpp
deleted file mode 100644
index 720bee4d8..000000000
--- a/src/duckdb/src/function/table/system/duckdb_dependencies.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-struct DependencyInformation {
-	DependencyInformation(CatalogEntry &object, CatalogEntry &dependent, const DependencyDependentFlags &flags)
-	    : object(object), dependent(dependent), flags(flags) {
-	}
-
-	CatalogEntry &object;
-	CatalogEntry &dependent;
-	DependencyDependentFlags flags;
-};
-
-struct DuckDBDependenciesData : public GlobalTableFunctionState {
-	DuckDBDependenciesData() : offset(0) {
-	}
-
-	vector<DependencyInformation> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBDependenciesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                       vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("classid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("objid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("objsubid");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("refclassid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("refobjid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("refobjsubid");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("deptype");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBDependenciesData>();
-
-	// scan all the schemas and collect them
-	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
-	auto dependency_manager = catalog.GetDependencyManager();
-	if (dependency_manager) {
-		dependency_manager->Scan(
-		    context, [&](CatalogEntry &obj, CatalogEntry &dependent, const DependencyDependentFlags &flags) {
-			    result->entries.emplace_back(obj, dependent, flags);
-		    });
-	}
-
-	return std::move(result);
-}
-
-void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBDependenciesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		// return values:
-		// classid, LogicalType::BIGINT
-		output.SetValue(0, count, Value::BIGINT(0));
-		// objid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(NumericCast<int64_t>(entry.object.oid)));
-		// objsubid, LogicalType::INTEGER
-		output.SetValue(2, count, Value::INTEGER(0));
-		// refclassid, LogicalType::BIGINT
-		output.SetValue(3, count, Value::BIGINT(0));
-		// refobjid, LogicalType::BIGINT
-		output.SetValue(4, count, Value::BIGINT(NumericCast<int64_t>(entry.dependent.oid)));
-		// refobjsubid, LogicalType::INTEGER
-		output.SetValue(5, count, Value::INTEGER(0));
-		// deptype, LogicalType::VARCHAR
-		string dependency_type_str;
-		if (entry.flags.IsBlocking()) {
-			dependency_type_str = "n";
-		} else {
-			dependency_type_str = "a";
-		}
-		output.SetValue(6, count, Value(dependency_type_str));
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBDependenciesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_dependencies", {}, DuckDBDependenciesFunction, DuckDBDependenciesBind,
-	                              DuckDBDependenciesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_extensions.cpp b/src/duckdb/src/function/table/system/duckdb_extensions.cpp
deleted file mode 100644
index 64d26dea9..000000000
--- a/src/duckdb/src/function/table/system/duckdb_extensions.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-
-namespace duckdb {
-
-struct ExtensionInformation {
-	string name;
-	bool loaded = false;
-	bool installed = false;
-	string file_path;
-	ExtensionInstallMode install_mode;
-	string installed_from;
-	string description;
-	vector<Value> aliases;
-	string extension_version;
-};
-
-struct DuckDBExtensionsData : public GlobalTableFunctionState {
-	DuckDBExtensionsData() : offset(0) {
-	}
-
-	vector<ExtensionInformation> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBExtensionsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                     vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("extension_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("loaded");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("installed");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("install_path");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("description");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("aliases");
-	return_types.emplace_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("extension_version");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("install_mode");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("installed_from");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBExtensionsData>();
-
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto &db = DatabaseInstance::GetDatabase(context);
-
-	// Firstly, we go over all Default Extensions: duckdb_extensions always prints those, installed/loaded or not
-	map<string, ExtensionInformation> installed_extensions;
-	auto extension_count = ExtensionHelper::DefaultExtensionCount();
-	auto alias_count = ExtensionHelper::ExtensionAliasCount();
-	for (idx_t i = 0; i < extension_count; i++) {
-		auto extension = ExtensionHelper::GetDefaultExtension(i);
-		ExtensionInformation info;
-		info.name = extension.name;
-		info.installed = extension.statically_loaded;
-		info.loaded = false;
-		info.file_path = extension.statically_loaded ? "(BUILT-IN)" : string();
-		info.install_mode =
-		    extension.statically_loaded ? ExtensionInstallMode::STATICALLY_LINKED : ExtensionInstallMode::UNKNOWN;
-		info.description = extension.description;
-		for (idx_t k = 0; k < alias_count; k++) {
-			auto alias = ExtensionHelper::GetExtensionAlias(k);
-			if (info.name == alias.extension) {
-				info.aliases.emplace_back(alias.alias);
-			}
-		}
-		installed_extensions[info.name] = std::move(info);
-	}
-
-	// Secondly we scan all installed extensions and their install info
-#ifndef WASM_LOADABLE_EXTENSIONS
-	auto ext_directory = ExtensionHelper::GetExtensionDirectoryPath(context);
-	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
-		if (!StringUtil::EndsWith(path, ".duckdb_extension")) {
-			return;
-		}
-		ExtensionInformation info;
-		info.name = fs.ExtractBaseName(path);
-		info.installed = true;
-		info.loaded = false;
-		info.file_path = fs.JoinPath(ext_directory, path);
-
-		// Check the info file for its installation source
-		auto info_file_path = fs.JoinPath(ext_directory, path + ".info");
-
-		// Read the info file
-		auto extension_install_info = ExtensionInstallInfo::TryReadInfoFile(fs, info_file_path, info.name);
-		info.install_mode = extension_install_info->mode;
-		info.extension_version = extension_install_info->version;
-		if (extension_install_info->mode == ExtensionInstallMode::REPOSITORY) {
-			info.installed_from = ExtensionRepository::GetRepository(extension_install_info->repository_url);
-		} else {
-			info.installed_from = extension_install_info->full_path;
-		}
-
-		auto entry = installed_extensions.find(info.name);
-		if (entry == installed_extensions.end()) {
-			installed_extensions[info.name] = std::move(info);
-		} else {
-			if (entry->second.install_mode != ExtensionInstallMode::STATICALLY_LINKED) {
-				entry->second.file_path = info.file_path;
-				entry->second.install_mode = info.install_mode;
-				entry->second.installed_from = info.installed_from;
-				entry->second.install_mode = info.install_mode;
-				entry->second.extension_version = info.extension_version;
-			}
-			entry->second.installed = true;
-		}
-	});
-#endif
-
-	// Finally, we check the list of currently loaded extensions
-	auto &extensions = db.GetExtensions();
-	for (auto &e : extensions) {
-		if (!e.second.is_loaded) {
-			continue;
-		}
-		auto &ext_name = e.first;
-		auto &ext_data = e.second;
-		if (auto &ext_install_info = ext_data.install_info) {
-			auto entry = installed_extensions.find(ext_name);
-			if (entry == installed_extensions.end() || !entry->second.installed) {
-				ExtensionInformation &info = installed_extensions[ext_name];
-				info.name = ext_name;
-				info.loaded = true;
-				info.extension_version = ext_install_info->version;
-				info.installed = ext_install_info->mode == ExtensionInstallMode::STATICALLY_LINKED;
-				info.install_mode = ext_install_info->mode;
-			} else {
-				entry->second.loaded = true;
-				entry->second.extension_version = ext_install_info->version;
-			}
-		}
-		if (auto &ext_load_info = ext_data.load_info) {
-			auto entry = installed_extensions.find(ext_name);
-			if (entry != installed_extensions.end()) {
-				entry->second.description = ext_load_info->description;
-			}
-		}
-	}
-
-	result->entries.reserve(installed_extensions.size());
-	for (auto &kv : installed_extensions) {
-		result->entries.push_back(std::move(kv.second));
-	}
-	return std::move(result);
-}
-
-void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBExtensionsData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		// return values:
-		// extension_name LogicalType::VARCHAR
-		output.SetValue(0, count, Value(entry.name));
-		// loaded LogicalType::BOOLEAN
-		output.SetValue(1, count, Value::BOOLEAN(entry.loaded));
-		// installed LogicalType::BOOLEAN
-		output.SetValue(2, count, Value::BOOLEAN(entry.installed));
-		// install_path LogicalType::VARCHAR
-		output.SetValue(3, count, Value(entry.file_path));
-		// description LogicalType::VARCHAR
-		output.SetValue(4, count, Value(entry.description));
-		// aliases     LogicalType::LIST(LogicalType::VARCHAR)
-		output.SetValue(5, count, Value::LIST(LogicalType::VARCHAR, entry.aliases));
-		// extension version     LogicalType::LIST(LogicalType::VARCHAR)
-		output.SetValue(6, count, Value(entry.extension_version));
-		// installed_mode LogicalType::VARCHAR
-		output.SetValue(7, count, entry.installed ? Value(EnumUtil::ToString(entry.install_mode)) : Value());
-		// installed_source LogicalType::VARCHAR
-		output.SetValue(8, count, Value(entry.installed_from));
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBExtensionsFun::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet functions("duckdb_extensions");
-	functions.AddFunction(TableFunction({}, DuckDBExtensionsFunction, DuckDBExtensionsBind, DuckDBExtensionsInit));
-	set.AddFunction(functions);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_functions.cpp b/src/duckdb/src/function/table/system/duckdb_functions.cpp
deleted file mode 100644
index 4ed87e524..000000000
--- a/src/duckdb/src/function/table/system/duckdb_functions.cpp
+++ /dev/null
@@ -1,708 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-#include "duckdb/function/scalar_macro_function.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct DuckDBFunctionsData : public GlobalTableFunctionState {
-	DuckDBFunctionsData() : offset(0), offset_in_entry(0) {
-	}
-
-	vector<reference<CatalogEntry>> entries;
-	idx_t offset;
-	idx_t offset_in_entry;
-};
-
-static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("function_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("function_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("description");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("return_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("parameters");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("parameter_types");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("varargs");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("macro_definition");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("has_side_effects");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("function_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("examples");
-	return_types.emplace_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("stability");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-static void ExtractFunctionsFromSchema(ClientContext &context, SchemaCatalogEntry &schema,
-                                       DuckDBFunctionsData &result) {
-	schema.Scan(context, CatalogType::SCALAR_FUNCTION_ENTRY,
-	            [&](CatalogEntry &entry) { result.entries.push_back(entry); });
-	schema.Scan(context, CatalogType::TABLE_FUNCTION_ENTRY,
-	            [&](CatalogEntry &entry) { result.entries.push_back(entry); });
-	schema.Scan(context, CatalogType::PRAGMA_FUNCTION_ENTRY,
-	            [&](CatalogEntry &entry) { result.entries.push_back(entry); });
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBFunctionsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBFunctionsData>();
-
-	// scan all the schemas for tables and collect them and collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		ExtractFunctionsFromSchema(context, schema.get(), *result);
-	};
-
-	std::sort(result->entries.begin(), result->entries.end(),
-	          [&](reference<CatalogEntry> a, reference<CatalogEntry> b) {
-		          return (int32_t)a.get().type < (int32_t)b.get().type;
-	          });
-	return std::move(result);
-}
-
-Value FunctionStabilityToValue(FunctionStability stability) {
-	switch (stability) {
-	case FunctionStability::VOLATILE:
-		return Value("VOLATILE");
-	case FunctionStability::CONSISTENT:
-		return Value("CONSISTENT");
-	case FunctionStability::CONSISTENT_WITHIN_QUERY:
-		return Value("CONSISTENT_WITHIN_QUERY");
-	default:
-		throw InternalException("Unsupported FunctionStability");
-	}
-}
-
-struct ScalarFunctionExtractor {
-	static idx_t FunctionCount(ScalarFunctionCatalogEntry &entry) {
-		return entry.functions.Size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("scalar");
-	}
-
-	static Value GetReturnType(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value(entry.functions.GetFunctionByOffset(offset).return_type.ToString());
-	}
-
-	static vector<Value> GetParameters(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions.GetFunctionByOffset(offset).arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		return results;
-	}
-
-	static Value GetParameterTypes(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		for (idx_t i = 0; i < fun.arguments.size(); i++) {
-			results.emplace_back(fun.arguments[i].ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
-	}
-
-	static vector<LogicalType> GetParameterLogicalTypes(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return fun.arguments;
-	}
-
-	static Value GetVarArgs(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return !fun.HasVarArgs() ? Value() : Value(fun.varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value IsVolatile(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value::BOOLEAN(entry.functions.GetFunctionByOffset(offset).stability == FunctionStability::VOLATILE);
-	}
-
-	static Value ResultType(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return FunctionStabilityToValue(entry.functions.GetFunctionByOffset(offset).stability);
-	}
-};
-
-struct AggregateFunctionExtractor {
-	static idx_t FunctionCount(AggregateFunctionCatalogEntry &entry) {
-		return entry.functions.Size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("aggregate");
-	}
-
-	static Value GetReturnType(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value(entry.functions.GetFunctionByOffset(offset).return_type.ToString());
-	}
-
-	static vector<Value> GetParameters(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions.GetFunctionByOffset(offset).arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		return results;
-	}
-
-	static Value GetParameterTypes(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		for (idx_t i = 0; i < fun.arguments.size(); i++) {
-			results.emplace_back(fun.arguments[i].ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
-	}
-
-	static vector<LogicalType> GetParameterLogicalTypes(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return fun.arguments;
-	}
-
-	static Value GetVarArgs(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return !fun.HasVarArgs() ? Value() : Value(fun.varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value IsVolatile(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value::BOOLEAN(entry.functions.GetFunctionByOffset(offset).stability == FunctionStability::VOLATILE);
-	}
-
-	static Value ResultType(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return FunctionStabilityToValue(entry.functions.GetFunctionByOffset(offset).stability);
-	}
-};
-
-struct MacroExtractor {
-	static idx_t FunctionCount(ScalarMacroCatalogEntry &entry) {
-		return entry.macros.size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("macro");
-	}
-
-	static Value GetReturnType(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static vector<Value> GetParameters(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto &macro_entry = *entry.macros[offset];
-		for (auto &param : macro_entry.parameters) {
-			D_ASSERT(param->GetExpressionType() == ExpressionType::COLUMN_REF);
-			auto &colref = param->Cast<ColumnRefExpression>();
-			results.emplace_back(colref.GetColumnName());
-		}
-		for (auto &param_entry : macro_entry.default_parameters) {
-			results.emplace_back(param_entry.first);
-		}
-		return results;
-	}
-
-	static Value GetParameterTypes(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto &macro_entry = *entry.macros[offset];
-		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
-	}
-
-	static vector<LogicalType> GetParameterLogicalTypes(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		vector<LogicalType> results;
-		auto &macro_entry = *entry.macros[offset];
-		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
-		}
-		return results;
-	}
-
-	static Value GetVarArgs(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetMacroDefinition(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		auto &macro_entry = *entry.macros[offset];
-		D_ASSERT(macro_entry.type == MacroType::SCALAR_MACRO);
-		auto &func = macro_entry.Cast<ScalarMacroFunction>();
-		return func.expression->ToString();
-	}
-
-	static Value IsVolatile(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value ResultType(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-struct TableMacroExtractor {
-	static idx_t FunctionCount(TableMacroCatalogEntry &entry) {
-		return entry.macros.size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("table_macro");
-	}
-
-	static Value GetReturnType(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static vector<Value> GetParameters(TableMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto &macro_entry = *entry.macros[offset];
-		for (auto &param : macro_entry.parameters) {
-			D_ASSERT(param->GetExpressionType() == ExpressionType::COLUMN_REF);
-			auto &colref = param->Cast<ColumnRefExpression>();
-			results.emplace_back(colref.GetColumnName());
-		}
-		for (auto &param_entry : macro_entry.default_parameters) {
-			results.emplace_back(param_entry.first);
-		}
-		return results;
-	}
-
-	static Value GetParameterTypes(TableMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto &macro_entry = *entry.macros[offset];
-		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
-	}
-
-	static vector<LogicalType> GetParameterLogicalTypes(TableMacroCatalogEntry &entry, idx_t offset) {
-		vector<LogicalType> results;
-		auto &macro_entry = *entry.macros[offset];
-		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
-		}
-		return results;
-	}
-
-	static Value GetVarArgs(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetMacroDefinition(TableMacroCatalogEntry &entry, idx_t offset) {
-		auto &macro_entry = *entry.macros[offset];
-		if (macro_entry.type == MacroType::TABLE_MACRO) {
-			auto &func = macro_entry.Cast<TableMacroFunction>();
-			return func.query_node->ToString();
-		}
-		return Value();
-	}
-
-	static Value IsVolatile(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value ResultType(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-struct TableFunctionExtractor {
-	static idx_t FunctionCount(TableFunctionCatalogEntry &entry) {
-		return entry.functions.Size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("table");
-	}
-
-	static Value GetReturnType(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static vector<Value> GetParameters(TableFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		for (idx_t i = 0; i < fun.arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		for (auto &param : fun.named_parameters) {
-			results.emplace_back(param.first);
-		}
-		return results;
-	}
-
-	static Value GetParameterTypes(TableFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-
-		for (idx_t i = 0; i < fun.arguments.size(); i++) {
-			results.emplace_back(fun.arguments[i].ToString());
-		}
-		for (auto &param : fun.named_parameters) {
-			results.emplace_back(param.second.ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
-	}
-
-	static vector<LogicalType> GetParameterLogicalTypes(TableFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return fun.arguments;
-	}
-
-	static Value GetVarArgs(TableFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return !fun.HasVarArgs() ? Value() : Value(fun.varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value IsVolatile(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value ResultType(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-struct PragmaFunctionExtractor {
-	static idx_t FunctionCount(PragmaFunctionCatalogEntry &entry) {
-		return entry.functions.Size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("pragma");
-	}
-
-	static Value GetReturnType(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static vector<Value> GetParameters(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-
-		for (idx_t i = 0; i < fun.arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		for (auto &param : fun.named_parameters) {
-			results.emplace_back(param.first);
-		}
-		return results;
-	}
-
-	static Value GetParameterTypes(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-
-		for (idx_t i = 0; i < fun.arguments.size(); i++) {
-			results.emplace_back(fun.arguments[i].ToString());
-		}
-		for (auto &param : fun.named_parameters) {
-			results.emplace_back(param.second.ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
-	}
-
-	static vector<LogicalType> GetParameterLogicalTypes(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return fun.arguments;
-	}
-
-	static Value GetVarArgs(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		auto fun = entry.functions.GetFunctionByOffset(offset);
-		return !fun.HasVarArgs() ? Value() : Value(fun.varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value IsVolatile(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value ResultType(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-static vector<Value> ToValueVector(vector<string> &string_vector) {
-	vector<Value> result;
-	for (string &str : string_vector) {
-		result.emplace_back(Value(str));
-	}
-	return result;
-}
-
-template <class T, class OP>
-static Value GetParameterNames(FunctionEntry &entry, idx_t function_idx, FunctionDescription &function_description,
-                               Value &parameter_types) {
-	vector<Value> parameter_names;
-	if (!function_description.parameter_names.empty()) {
-		for (idx_t param_idx = 0; param_idx < ListValue::GetChildren(parameter_types).size(); param_idx++) {
-			if (param_idx < function_description.parameter_names.size()) {
-				parameter_names.emplace_back(function_description.parameter_names[param_idx]);
-			} else {
-				parameter_names.emplace_back("col" + to_string(param_idx));
-			}
-		}
-	} else {
-		// fallback
-		auto &function = entry.Cast<T>();
-		parameter_names = OP::GetParameters(function, function_idx);
-	}
-	return Value::LIST(LogicalType::VARCHAR, parameter_names);
-}
-
-// returns values:
-// 0: exact type match; N: match using N <ANY> values; Invalid(): no match
-static optional_idx CalcDescriptionSpecificity(FunctionDescription &description,
-                                               const vector<LogicalType> &parameter_types) {
-	if (description.parameter_types.size() != parameter_types.size()) {
-		return optional_idx::Invalid();
-	}
-	idx_t any_count = 0;
-	for (idx_t i = 0; i < description.parameter_types.size(); i++) {
-		if (description.parameter_types[i].id() == LogicalTypeId::ANY) {
-			any_count++;
-		} else if (description.parameter_types[i] != parameter_types[i]) {
-			return optional_idx::Invalid();
-		}
-	}
-	return any_count;
-}
-
-// Find FunctionDescription object with matching number of arguments and types
-static optional_idx GetFunctionDescriptionIndex(vector<FunctionDescription> &function_descriptions,
-                                                vector<LogicalType> &function_parameter_types) {
-	if (function_descriptions.size() == 1) {
-		// one description, use it even if nr of parameters don't match
-		idx_t nr_function_parameters = function_parameter_types.size();
-		for (idx_t i = 0; i < function_descriptions[0].parameter_types.size(); i++) {
-			if (i < nr_function_parameters && function_descriptions[0].parameter_types[i] != LogicalTypeId::ANY &&
-			    function_descriptions[0].parameter_types[i] != function_parameter_types[i]) {
-				return optional_idx::Invalid();
-			}
-		}
-		return optional_idx(0);
-	}
-
-	// multiple descriptions, search most specific description
-	optional_idx best_description_idx;
-	// specificity_score: 0: exact type match; N: match using N <ANY> values; Invalid(): no match
-	optional_idx best_specificity_score;
-	optional_idx specificity_score;
-	for (idx_t descr_idx = 0; descr_idx < function_descriptions.size(); descr_idx++) {
-		specificity_score = CalcDescriptionSpecificity(function_descriptions[descr_idx], function_parameter_types);
-		if (specificity_score.IsValid() &&
-		    (!best_specificity_score.IsValid() || specificity_score.GetIndex() < best_specificity_score.GetIndex())) {
-			best_specificity_score = specificity_score;
-			best_description_idx = descr_idx;
-		}
-	}
-	return best_description_idx;
-}
-
-template <class T, class OP>
-bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
-	auto &function = entry.Cast<T>();
-	vector<LogicalType> parameter_types_vector = OP::GetParameterLogicalTypes(function, function_idx);
-	Value parameter_types_value = OP::GetParameterTypes(function, function_idx);
-	optional_idx description_idx = GetFunctionDescriptionIndex(entry.descriptions, parameter_types_vector);
-	FunctionDescription function_description =
-	    description_idx.IsValid() ? entry.descriptions[description_idx.GetIndex()] : FunctionDescription();
-
-	idx_t col = 0;
-
-	// database_name, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(function.schema.catalog.GetName()));
-
-	// database_oid, BIGINT
-	output.SetValue(col++, output_offset, Value::BIGINT(NumericCast<int64_t>(function.schema.catalog.GetOid())));
-
-	// schema_name, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(function.schema.name));
-
-	// function_name, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(function.name));
-
-	// function_type, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(OP::GetFunctionType()));
-
-	// function_description, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset,
-	                (function_description.description.empty()) ? Value() : Value(function_description.description));
-
-	// comment, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, entry.comment);
-
-	// tags, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)
-	output.SetValue(col++, output_offset, Value::MAP(entry.tags));
-
-	// return_type, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, OP::GetReturnType(function, function_idx));
-
-	// parameters, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(col++, output_offset,
-	                GetParameterNames<T, OP>(function, function_idx, function_description, parameter_types_value));
-
-	// parameter_types, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(col++, output_offset, parameter_types_value);
-
-	// varargs, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, OP::GetVarArgs(function, function_idx));
-
-	// macro_definition, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, OP::GetMacroDefinition(function, function_idx));
-
-	// has_side_effects, LogicalType::BOOLEAN
-	output.SetValue(col++, output_offset, OP::IsVolatile(function, function_idx));
-
-	// internal, LogicalType::BOOLEAN
-	output.SetValue(col++, output_offset, Value::BOOLEAN(function.internal));
-
-	// function_oid, LogicalType::BIGINT
-	output.SetValue(col++, output_offset, Value::BIGINT(NumericCast<int64_t>(function.oid)));
-
-	// examples, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(col++, output_offset,
-	                Value::LIST(LogicalType::VARCHAR, ToValueVector(function_description.examples)));
-
-	// stability, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, OP::ResultType(function, function_idx));
-
-	return function_idx + 1 == OP::FunctionCount(function);
-}
-
-void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBFunctionsData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset].get().Cast<FunctionEntry>();
-		bool finished;
-
-		switch (entry.type) {
-		case CatalogType::SCALAR_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<ScalarFunctionCatalogEntry, ScalarFunctionExtractor>(
-			    entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<AggregateFunctionCatalogEntry, AggregateFunctionExtractor>(
-			    entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::TABLE_MACRO_ENTRY:
-			finished = ExtractFunctionData<TableMacroCatalogEntry, TableMacroExtractor>(entry, data.offset_in_entry,
-			                                                                            output, count);
-			break;
-		case CatalogType::MACRO_ENTRY:
-			finished = ExtractFunctionData<ScalarMacroCatalogEntry, MacroExtractor>(entry, data.offset_in_entry, output,
-			                                                                        count);
-			break;
-		case CatalogType::TABLE_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<TableFunctionCatalogEntry, TableFunctionExtractor>(
-			    entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::PRAGMA_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<PragmaFunctionCatalogEntry, PragmaFunctionExtractor>(
-			    entry, data.offset_in_entry, output, count);
-			break;
-		default:
-			throw InternalException("FIXME: unrecognized function type in duckdb_functions");
-		}
-		if (finished) {
-			// finished with this function, move to the next function
-			data.offset++;
-			data.offset_in_entry = 0;
-		} else {
-			// more functions remain
-			data.offset_in_entry++;
-		}
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBFunctionsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_functions", {}, DuckDBFunctionsFunction, DuckDBFunctionsBind, DuckDBFunctionsInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_indexes.cpp b/src/duckdb/src/function/table/system/duckdb_indexes.cpp
deleted file mode 100644
index 78cc88d81..000000000
--- a/src/duckdb/src/function/table/system/duckdb_indexes.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct DuckDBIndexesData : public GlobalTableFunctionState {
-	DuckDBIndexesData() : offset(0) {
-	}
-
-	vector<reference<CatalogEntry>> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("index_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("index_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("is_unique");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("is_primary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("expressions");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBIndexesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBIndexesData>();
-
-	// scan all the schemas for tables and collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::INDEX_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
-	};
-	return std::move(result);
-}
-
-Value GetIndexExpressions(IndexCatalogEntry &index) {
-	auto create_info = index.GetInfo();
-	auto &create_index_info = create_info->Cast<CreateIndexInfo>();
-
-	auto vec = create_index_info.ExpressionsToList();
-
-	vector<Value> content;
-	content.reserve(vec.size());
-	for (auto &item : vec) {
-		content.push_back(Value(item));
-	}
-	return Value::LIST(LogicalType::VARCHAR, std::move(content));
-}
-
-void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBIndexesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++].get();
-
-		auto &index = entry.Cast<IndexCatalogEntry>();
-		// return values:
-
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, index.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(index.catalog.GetOid())));
-		// schema_name, VARCHAR
-		output.SetValue(col++, count, Value(index.schema.name));
-		// schema_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(index.schema.oid)));
-		// index_name, VARCHAR
-		output.SetValue(col++, count, Value(index.name));
-		// index_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(index.oid)));
-		// find the table in the catalog
-		auto &table_entry =
-		    index.schema.catalog.GetEntry<TableCatalogEntry>(context, index.GetSchemaName(), index.GetTableName());
-		// table_name, VARCHAR
-		output.SetValue(col++, count, Value(table_entry.name));
-		// table_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table_entry.oid)));
-		// comment, VARCHAR
-		output.SetValue(col++, count, Value(index.comment));
-		// tags, MAP
-		output.SetValue(col++, count, Value::MAP(index.tags));
-		// is_unique, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(index.IsUnique()));
-		// is_primary, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(index.IsPrimary()));
-		// expressions, VARCHAR
-		output.SetValue(col++, count, GetIndexExpressions(index).ToString());
-		// sql, VARCHAR
-		auto sql = index.ToSQL();
-		output.SetValue(col++, count, sql.empty() ? Value() : Value(std::move(sql)));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBIndexesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_indexes", {}, DuckDBIndexesFunction, DuckDBIndexesBind, DuckDBIndexesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_keywords.cpp b/src/duckdb/src/function/table/system/duckdb_keywords.cpp
deleted file mode 100644
index 35167a8b4..000000000
--- a/src/duckdb/src/function/table/system/duckdb_keywords.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parser.hpp"
-
-namespace duckdb {
-
-struct DuckDBKeywordsData : public GlobalTableFunctionState {
-	DuckDBKeywordsData() : offset(0) {
-	}
-
-	vector<ParserKeyword> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBKeywordsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                   vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("keyword_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("keyword_category");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBKeywordsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBKeywordsData>();
-	result->entries = Parser::KeywordList();
-	return std::move(result);
-}
-
-void DuckDBKeywordsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBKeywordsData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		// keyword_name, VARCHAR
-		output.SetValue(0, count, Value(entry.name));
-		// keyword_category, VARCHAR
-		string category_name;
-		switch (entry.category) {
-		case KeywordCategory::KEYWORD_RESERVED:
-			category_name = "reserved";
-			break;
-		case KeywordCategory::KEYWORD_UNRESERVED:
-			category_name = "unreserved";
-			break;
-		case KeywordCategory::KEYWORD_TYPE_FUNC:
-			category_name = "type_function";
-			break;
-		case KeywordCategory::KEYWORD_COL_NAME:
-			category_name = "column_name";
-			break;
-		default:
-			throw InternalException("Unrecognized keyword category");
-		}
-		output.SetValue(1, count, Value(std::move(category_name)));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBKeywordsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_keywords", {}, DuckDBKeywordsFunction, DuckDBKeywordsBind, DuckDBKeywordsInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_memory.cpp b/src/duckdb/src/function/table/system/duckdb_memory.cpp
deleted file mode 100644
index a1eb044b7..000000000
--- a/src/duckdb/src/function/table/system/duckdb_memory.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-struct DuckDBMemoryData : public GlobalTableFunctionState {
-	DuckDBMemoryData() : offset(0) {
-	}
-
-	vector<MemoryInformation> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBMemoryBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("tag");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("memory_usage_bytes");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("temporary_storage_bytes");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBMemoryInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBMemoryData>();
-	result->entries = BufferManager::GetBufferManager(context).GetMemoryUsageInfo();
-	return std::move(result);
-}
-
-void DuckDBMemoryFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBMemoryData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-		// return values:
-		idx_t col = 0;
-		// tag, VARCHAR
-		output.SetValue(col++, count, EnumUtil::ToString(entry.tag));
-		// memory_usage_bytes, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.size)));
-		// temporary_storage_bytes, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.evicted_data)));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBMemoryFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_memory", {}, DuckDBMemoryFunction, DuckDBMemoryBind, DuckDBMemoryInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_optimizers.cpp b/src/duckdb/src/function/table/system/duckdb_optimizers.cpp
deleted file mode 100644
index ac531678a..000000000
--- a/src/duckdb/src/function/table/system/duckdb_optimizers.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/enums/optimizer_type.hpp"
-
-namespace duckdb {
-
-struct DuckDBOptimizersData : public GlobalTableFunctionState {
-	DuckDBOptimizersData() : offset(0) {
-	}
-
-	vector<string> optimizers;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBOptimizersBind(ClientContext &context, TableFunctionBindInput &input,
-                                                     vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBOptimizersInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBOptimizersData>();
-	result->optimizers = ListAllOptimizers();
-	return std::move(result);
-}
-
-void DuckDBOptimizersFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBOptimizersData>();
-	if (data.offset >= data.optimizers.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.optimizers.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.optimizers[data.offset++];
-
-		// return values:
-		// name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(entry));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBOptimizersFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_optimizers", {}, DuckDBOptimizersFunction, DuckDBOptimizersBind, DuckDBOptimizersInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_schemas.cpp b/src/duckdb/src/function/table/system/duckdb_schemas.cpp
deleted file mode 100644
index 295d440b6..000000000
--- a/src/duckdb/src/function/table/system/duckdb_schemas.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct DuckDBSchemasData : public GlobalTableFunctionState {
-	DuckDBSchemasData() : offset(0) {
-	}
-
-	vector<reference<SchemaCatalogEntry>> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSchemasInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBSchemasData>();
-
-	// scan all the schemas and collect them
-	result->entries = Catalog::GetAllSchemas(context);
-
-	return std::move(result);
-}
-
-void DuckDBSchemasFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBSchemasData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset].get();
-
-		// return values:
-		idx_t col = 0;
-		// "oid", PhysicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.oid)));
-		// database_name, VARCHAR
-		output.SetValue(col++, count, entry.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.catalog.GetOid())));
-		// "schema_name", PhysicalType::VARCHAR
-		output.SetValue(col++, count, Value(entry.name));
-		// "comment", PhysicalType::VARCHAR
-		output.SetValue(col++, count, Value(entry.comment));
-		// "tags", MAP(VARCHAR, VARCHAR)
-		output.SetValue(col++, count, Value::MAP(entry.tags));
-		// "internal", PhysicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(entry.internal));
-		// "sql", PhysicalType::VARCHAR
-		output.SetValue(col++, count, Value());
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSchemasFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_schemas", {}, DuckDBSchemasFunction, DuckDBSchemasBind, DuckDBSchemasInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_secrets.cpp b/src/duckdb/src/function/table/system/duckdb_secrets.cpp
deleted file mode 100644
index 6069344bf..000000000
--- a/src/duckdb/src/function/table/system/duckdb_secrets.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-
-namespace duckdb {
-
-struct DuckDBSecretsData : public GlobalTableFunctionState {
-	DuckDBSecretsData() : offset(0) {
-	}
-	idx_t offset;
-	duckdb::vector<duckdb::SecretEntry> secrets;
-};
-
-struct DuckDBSecretsBindData : public FunctionData {
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<DuckDBSecretsBindData>();
-	};
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<DuckDBSecretsBindData>();
-		return redact == other.redact;
-	}
-	SecretDisplayType redact = SecretDisplayType::REDACTED;
-};
-
-static unique_ptr<FunctionData> DuckDBSecretsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<DuckDBSecretsBindData>();
-
-	auto entry = input.named_parameters.find("redact");
-	if (entry != input.named_parameters.end()) {
-		if (BooleanValue::Get(entry->second)) {
-			result->redact = SecretDisplayType::REDACTED;
-		} else {
-			result->redact = SecretDisplayType::UNREDACTED;
-		}
-	}
-
-	if (!DBConfig::GetConfig(context).options.allow_unredacted_secrets &&
-	    result->redact == SecretDisplayType::UNREDACTED) {
-		throw InvalidInputException("Displaying unredacted secrets is disabled");
-	}
-
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("provider");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("persistent");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("storage");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("scope");
-	return_types.emplace_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("secret_string");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return std::move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSecretsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBSecretsData>();
-	return std::move(result);
-}
-
-void DuckDBSecretsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBSecretsData>();
-	auto &bind_data = data_p.bind_data->Cast<DuckDBSecretsBindData>();
-
-	auto &secret_manager = SecretManager::Get(context);
-
-	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
-
-	if (data.secrets.empty()) {
-		data.secrets = secret_manager.AllSecrets(transaction);
-	}
-	auto &secrets = data.secrets;
-	if (data.offset >= secrets.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < secrets.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &secret_entry = secrets[data.offset];
-
-		vector<Value> scope_value;
-		for (const auto &scope_entry : secret_entry.secret->GetScope()) {
-			scope_value.push_back(scope_entry);
-		}
-
-		const auto &secret = *secret_entry.secret;
-
-		idx_t i = 0;
-		// name
-		output.SetValue(i++, count, secret.GetName());
-		// type
-		output.SetValue(i++, count, Value(secret.GetType()));
-		// provider
-		output.SetValue(i++, count, Value(secret.GetProvider()));
-		// persistent
-		output.SetValue(i++, count, Value(secret_entry.persist_type == SecretPersistType::PERSISTENT));
-		// storage
-		output.SetValue(i++, count, Value(secret_entry.storage_mode));
-		// scope
-		output.SetValue(i++, count, Value::LIST(LogicalType::VARCHAR, scope_value));
-		// secret_string
-		output.SetValue(i++, count, secret.ToString(bind_data.redact));
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSecretsFun::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet functions("duckdb_secrets");
-	auto fun = TableFunction({}, DuckDBSecretsFunction, DuckDBSecretsBind, DuckDBSecretsInit);
-	fun.named_parameters["redact"] = LogicalType::BOOLEAN;
-	functions.AddFunction(fun);
-	set.AddFunction(functions);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_sequences.cpp b/src/duckdb/src/function/table/system/duckdb_sequences.cpp
deleted file mode 100644
index b95d23c2e..000000000
--- a/src/duckdb/src/function/table/system/duckdb_sequences.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct DuckDBSequencesData : public GlobalTableFunctionState {
-	DuckDBSequencesData() : offset(0) {
-	}
-
-	vector<reference<SequenceCatalogEntry>> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sequence_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("sequence_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("temporary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("start_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("min_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("max_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("increment_by");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("cycle");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("last_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSequencesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBSequencesData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::SEQUENCE_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry.Cast<SequenceCatalogEntry>()); });
-	};
-	return std::move(result);
-}
-
-void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBSequencesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &seq = data.entries[data.offset++].get();
-		auto seq_data = seq.GetData();
-
-		// return values:
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, seq.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(seq.catalog.GetOid())));
-		// schema_name, VARCHAR
-		output.SetValue(col++, count, Value(seq.schema.name));
-		// schema_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(seq.schema.oid)));
-		// sequence_name, VARCHAR
-		output.SetValue(col++, count, Value(seq.name));
-		// sequence_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(seq.oid)));
-		// comment, VARCHAR
-		output.SetValue(col++, count, Value(seq.comment));
-		// tags, MAP(VARCHAR, VARCHAR)
-		output.SetValue(col++, count, Value::MAP(seq.tags));
-		// temporary, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(seq.temporary));
-		// start_value, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq_data.start_value));
-		// min_value, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq_data.min_value));
-		// max_value, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq_data.max_value));
-		// increment_by, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq_data.increment));
-		// cycle, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(seq_data.cycle));
-		// last_value, BIGINT
-		output.SetValue(col++, count, seq_data.usage_count == 0 ? Value() : Value::BIGINT(seq_data.last_value));
-		// sql, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(seq.ToSQL()));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSequencesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_sequences", {}, DuckDBSequencesFunction, DuckDBSequencesBind, DuckDBSequencesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_settings.cpp b/src/duckdb/src/function/table/system/duckdb_settings.cpp
deleted file mode 100644
index b7c3a56b8..000000000
--- a/src/duckdb/src/function/table/system/duckdb_settings.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-struct DuckDBSettingValue {
-	string name;
-	string value;
-	string description;
-	string input_type;
-	string scope;
-};
-
-struct DuckDBSettingsData : public GlobalTableFunctionState {
-	DuckDBSettingsData() : offset(0) {
-	}
-
-	vector<DuckDBSettingValue> settings;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                   vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("value");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("description");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("input_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("scope");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBSettingsData>();
-
-	auto &config = DBConfig::GetConfig(context);
-	auto options_count = DBConfig::GetOptionCount();
-	for (idx_t i = 0; i < options_count; i++) {
-		auto option = DBConfig::GetOptionByIndex(i);
-		D_ASSERT(option);
-		DuckDBSettingValue value;
-		auto scope = option->set_global ? SettingScope::GLOBAL : SettingScope::LOCAL;
-		value.name = option->name;
-		value.value = option->get_setting(context).ToString();
-		value.description = option->description;
-		value.input_type = option->parameter_type;
-		value.scope = EnumUtil::ToString(scope);
-
-		result->settings.push_back(std::move(value));
-	}
-	for (auto &ext_param : config.extension_parameters) {
-		Value setting_val;
-		string setting_str_val;
-		auto scope = SettingScope::GLOBAL;
-		auto lookup_result = context.TryGetCurrentSetting(ext_param.first, setting_val);
-		if (lookup_result) {
-			setting_str_val = setting_val.ToString();
-			scope = lookup_result.GetScope();
-		}
-		DuckDBSettingValue value;
-		value.name = ext_param.first;
-		value.value = std::move(setting_str_val);
-		value.description = ext_param.second.description;
-		value.input_type = ext_param.second.type.ToString();
-		value.scope = EnumUtil::ToString(scope);
-
-		result->settings.push_back(std::move(value));
-	}
-	return std::move(result);
-}
-
-void DuckDBSettingsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBSettingsData>();
-	if (data.offset >= data.settings.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.settings.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.settings[data.offset++];
-
-		// return values:
-		// name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(entry.name));
-		// value, LogicalType::VARCHAR
-		output.SetValue(1, count, Value(entry.value));
-		// description, LogicalType::VARCHAR
-		output.SetValue(2, count, Value(entry.description));
-		// input_type, LogicalType::VARCHAR
-		output.SetValue(3, count, Value(entry.input_type));
-		// scope, LogicalType::VARCHAR
-		output.SetValue(4, count, Value(entry.scope));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSettingsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_settings", {}, DuckDBSettingsFunction, DuckDBSettingsBind, DuckDBSettingsInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_tables.cpp b/src/duckdb/src/function/table/system/duckdb_tables.cpp
deleted file mode 100644
index 5e007bbff..000000000
--- a/src/duckdb/src/function/table/system/duckdb_tables.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-
-namespace duckdb {
-
-struct DuckDBTablesData : public GlobalTableFunctionState {
-	DuckDBTablesData() : offset(0) {
-	}
-
-	vector<reference<CatalogEntry>> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("temporary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("has_primary_key");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("estimated_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("index_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("check_constraint_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBTablesData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::TABLE_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
-	};
-	return std::move(result);
-}
-
-static idx_t CheckConstraintCount(TableCatalogEntry &table) {
-	idx_t check_count = 0;
-	for (auto &constraint : table.GetConstraints()) {
-		if (constraint->type == ConstraintType::CHECK) {
-			check_count++;
-		}
-	}
-	return check_count;
-}
-
-void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBTablesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++].get();
-
-		if (entry.type != CatalogType::TABLE_ENTRY) {
-			continue;
-		}
-		auto &table = entry.Cast<TableCatalogEntry>();
-		auto storage_info = table.GetStorageInfo(context);
-		// return values:
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, table.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.catalog.GetOid())));
-		// schema_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(table.schema.name));
-		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.schema.oid)));
-		// table_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(table.name));
-		// table_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.oid)));
-		// comment, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(table.comment));
-		// tags, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)
-		output.SetValue(col++, count, Value::MAP(table.tags));
-		// internal, LogicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(table.internal));
-		// temporary, LogicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(table.temporary));
-		// has_primary_key, LogicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(table.HasPrimaryKey()));
-		// estimated_size, LogicalType::BIGINT
-
-		Value card_val = !storage_info.cardinality.IsValid()
-		                     ? Value()
-		                     : Value::BIGINT(NumericCast<int64_t>(storage_info.cardinality.GetIndex()));
-		output.SetValue(col++, count, card_val);
-		// column_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.GetColumns().LogicalColumnCount())));
-		// index_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(storage_info.index_info.size())));
-		// check_constraint_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(CheckConstraintCount(table))));
-		// sql, LogicalType::VARCHAR
-		auto table_info = table.GetInfo();
-		table_info->catalog.clear();
-		output.SetValue(col++, count, Value(table_info->ToString()));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBTablesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_tables", {}, DuckDBTablesFunction, DuckDBTablesBind, DuckDBTablesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_temporary_files.cpp b/src/duckdb/src/function/table/system/duckdb_temporary_files.cpp
deleted file mode 100644
index f18866394..000000000
--- a/src/duckdb/src/function/table/system/duckdb_temporary_files.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-struct DuckDBTemporaryFilesData : public GlobalTableFunctionState {
-	DuckDBTemporaryFilesData() : offset(0) {
-	}
-
-	vector<TemporaryFileInformation> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBTemporaryFilesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                         vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("path");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBTemporaryFilesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBTemporaryFilesData>();
-
-	result->entries = BufferManager::GetBufferManager(context).GetTemporaryFiles();
-	return std::move(result);
-}
-
-void DuckDBTemporaryFilesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBTemporaryFilesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-		// return values:
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, entry.path);
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.size)));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBTemporaryFilesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_temporary_files", {}, DuckDBTemporaryFilesFunction, DuckDBTemporaryFilesBind,
-	                              DuckDBTemporaryFilesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_types.cpp b/src/duckdb/src/function/table/system/duckdb_types.cpp
deleted file mode 100644
index dd98408b9..000000000
--- a/src/duckdb/src/function/table/system/duckdb_types.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct DuckDBTypesData : public GlobalTableFunctionState {
-	DuckDBTypesData() : offset(0) {
-	}
-
-	vector<reference<TypeCatalogEntry>> entries;
-	idx_t offset;
-	unordered_set<int64_t> oids;
-};
-
-static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("type_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("type_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("logical_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	// NUMERIC, STRING, DATETIME, BOOLEAN, COMPOSITE, USER
-	names.emplace_back("type_category");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("labels");
-	return_types.emplace_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBTypesData>();
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::TYPE_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry.Cast<TypeCatalogEntry>()); });
-	};
-	return std::move(result);
-}
-
-void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBTypesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &type_entry = data.entries[data.offset++].get();
-		auto &type = type_entry.user_type;
-
-		// return values:
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, type_entry.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(type_entry.catalog.GetOid())));
-		// schema_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(type_entry.schema.name));
-		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(type_entry.schema.oid)));
-		// type_oid, BIGINT
-		int64_t oid;
-		if (type_entry.internal) {
-			oid = NumericCast<int64_t>(type.id());
-		} else {
-			oid = NumericCast<int64_t>(type_entry.oid);
-		}
-		Value oid_val;
-		if (data.oids.find(oid) == data.oids.end()) {
-			data.oids.insert(oid);
-			oid_val = Value::BIGINT(oid);
-		} else {
-			oid_val = Value();
-		}
-		output.SetValue(col++, count, oid_val);
-		// type_name, VARCHAR
-		output.SetValue(col++, count, Value(type_entry.name));
-		// type_size, BIGINT
-		auto internal_type = type.InternalType();
-		output.SetValue(col++, count,
-		                internal_type == PhysicalType::INVALID
-		                    ? Value()
-		                    : Value::BIGINT(NumericCast<int64_t>(GetTypeIdSize(internal_type))));
-		// logical_type, VARCHAR
-		output.SetValue(col++, count, Value(EnumUtil::ToString(type.id())));
-		// type_category, VARCHAR
-		string category;
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::DECIMAL:
-		case LogicalTypeId::FLOAT:
-		case LogicalTypeId::DOUBLE:
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-		case LogicalTypeId::HUGEINT:
-		case LogicalTypeId::UHUGEINT:
-			category = "NUMERIC";
-			break;
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::INTERVAL:
-		case LogicalTypeId::TIME_TZ:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			category = "DATETIME";
-			break;
-		case LogicalTypeId::CHAR:
-		case LogicalTypeId::VARCHAR:
-			category = "STRING";
-			break;
-		case LogicalTypeId::BOOLEAN:
-			category = "BOOLEAN";
-			break;
-		case LogicalTypeId::STRUCT:
-		case LogicalTypeId::LIST:
-		case LogicalTypeId::MAP:
-		case LogicalTypeId::UNION:
-			category = "COMPOSITE";
-			break;
-		default:
-			break;
-		}
-		output.SetValue(col++, count, category.empty() ? Value() : Value(category));
-		// comment, VARCHAR
-		output.SetValue(col++, count, Value(type_entry.comment));
-		// tags, MAP
-		output.SetValue(col++, count, Value::MAP(type_entry.tags));
-		// internal, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(type_entry.internal));
-		// labels, VARCHAR[]
-		if (type.id() == LogicalTypeId::ENUM && type.AuxInfo()) {
-			auto data = FlatVector::GetData<string_t>(EnumType::GetValuesInsertOrder(type));
-			idx_t size = EnumType::GetSize(type);
-
-			vector<Value> labels;
-			for (idx_t i = 0; i < size; i++) {
-				labels.emplace_back(data[i]);
-			}
-
-			output.SetValue(col++, count, Value::LIST(LogicalType::VARCHAR, labels));
-		} else {
-			output.SetValue(col++, count, Value());
-		}
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_types", {}, DuckDBTypesFunction, DuckDBTypesBind, DuckDBTypesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_variables.cpp b/src/duckdb/src/function/table/system/duckdb_variables.cpp
deleted file mode 100644
index 62cfbcb82..000000000
--- a/src/duckdb/src/function/table/system/duckdb_variables.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct VariableData {
-	string name;
-	Value value;
-};
-
-struct DuckDBVariablesData : public GlobalTableFunctionState {
-	DuckDBVariablesData() : offset(0) {
-	}
-
-	vector<VariableData> variables;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBVariablesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("value");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBVariablesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBVariablesData>();
-	auto &config = ClientConfig::GetConfig(context);
-
-	for (auto &entry : config.user_variables) {
-		VariableData data;
-		data.name = entry.first;
-		data.value = entry.second;
-		result->variables.push_back(std::move(data));
-	}
-	return std::move(result);
-}
-
-void DuckDBVariablesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBVariablesData>();
-	if (data.offset >= data.variables.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.variables.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &variable_entry = data.variables[data.offset++];
-
-		// return values:
-		idx_t col = 0;
-		// name, VARCHAR
-		output.SetValue(col++, count, Value(variable_entry.name));
-		// value, BIGINT
-		output.SetValue(col++, count, Value(variable_entry.value.ToString()));
-		// type, VARCHAR
-		output.SetValue(col, count, Value(variable_entry.value.type().ToString()));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBVariablesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_variables", {}, DuckDBVariablesFunction, DuckDBVariablesBind, DuckDBVariablesInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_views.cpp b/src/duckdb/src/function/table/system/duckdb_views.cpp
deleted file mode 100644
index 1ae6fcce7..000000000
--- a/src/duckdb/src/function/table/system/duckdb_views.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-
-namespace duckdb {
-
-struct DuckDBViewsData : public GlobalTableFunctionState {
-	DuckDBViewsData() : offset(0) {
-	}
-
-	vector<reference<CatalogEntry>> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("view_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("view_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("comment");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("tags");
-	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("temporary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("column_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<DuckDBViewsData>();
-
-	// scan all the schemas for tables and collect them and collect them
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::VIEW_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
-	};
-	return std::move(result);
-}
-
-void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBViewsData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++].get();
-
-		if (entry.type != CatalogType::VIEW_ENTRY) {
-			continue;
-		}
-		auto &view = entry.Cast<ViewCatalogEntry>();
-
-		// return values:
-		idx_t col = 0;
-		// database_name, VARCHAR
-		output.SetValue(col++, count, view.catalog.GetName());
-		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.catalog.GetOid())));
-		// schema_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(view.schema.name));
-		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.schema.oid)));
-		// view_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(view.name));
-		// view_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.oid)));
-		// comment, LogicalType::VARCHARs
-		output.SetValue(col++, count, Value(view.comment));
-		// tags, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)
-		output.SetValue(col++, count, Value::MAP(view.tags));
-		// internal, LogicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(view.internal));
-		// temporary, LogicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(view.temporary));
-		// column_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.types.size())));
-		// sql, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(view.ToSQL()));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBViewsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_views", {}, DuckDBViewsFunction, DuckDBViewsBind, DuckDBViewsInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/duckdb_which_secret.cpp b/src/duckdb/src/function/table/system/duckdb_which_secret.cpp
deleted file mode 100644
index 3314fee95..000000000
--- a/src/duckdb/src/function/table/system/duckdb_which_secret.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-
-namespace duckdb {
-
-struct DuckDBWhichSecretData : public GlobalTableFunctionState {
-	DuckDBWhichSecretData() : finished(false) {
-	}
-	bool finished;
-};
-
-struct DuckDBWhichSecretBindData : public TableFunctionData {
-	explicit DuckDBWhichSecretBindData(TableFunctionBindInput &tf_input) : inputs(tf_input.inputs) {};
-
-	duckdb::vector<duckdb::Value> inputs;
-};
-
-static unique_ptr<FunctionData> DuckDBWhichSecretBind(ClientContext &context, TableFunctionBindInput &input,
-                                                      vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("persistent");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("storage");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return make_uniq<DuckDBWhichSecretBindData>(input);
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBWhichSecretInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<DuckDBWhichSecretData>();
-}
-
-void DuckDBWhichSecretFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<DuckDBWhichSecretData>();
-	if (data.finished) {
-		// finished returning values
-		return;
-	}
-	auto &bind_data = data_p.bind_data->Cast<DuckDBWhichSecretBindData>();
-
-	auto &secret_manager = SecretManager::Get(context);
-	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
-
-	auto &inputs = bind_data.inputs;
-	auto path = inputs[0].ToString();
-	auto type = inputs[1].ToString();
-	auto secret_match = secret_manager.LookupSecret(transaction, path, type);
-	if (secret_match.HasMatch()) {
-		auto &secret_entry = *secret_match.secret_entry;
-		output.SetCardinality(1);
-		output.SetValue(0, 0, secret_entry.secret->GetName());
-		output.SetValue(1, 0, EnumUtil::ToString(secret_entry.persist_type));
-		output.SetValue(2, 0, secret_entry.storage_mode);
-	}
-	data.finished = true;
-}
-
-void DuckDBWhichSecretFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("which_secret", {duckdb::LogicalType::VARCHAR, duckdb::LogicalType::VARCHAR},
-	                              DuckDBWhichSecretFunction, DuckDBWhichSecretBind, DuckDBWhichSecretInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_collations.cpp b/src/duckdb/src/function/table/system/pragma_collations.cpp
deleted file mode 100644
index 187ae1745..000000000
--- a/src/duckdb/src/function/table/system/pragma_collations.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-struct PragmaCollateData : public GlobalTableFunctionState {
-	PragmaCollateData() : offset(0) {
-	}
-
-	vector<string> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("collname");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<PragmaCollateData>();
-
-	auto schemas = Catalog::GetAllSchemas(context);
-	for (auto schema : schemas) {
-		schema.get().Scan(context, CatalogType::COLLATION_ENTRY,
-		                  [&](CatalogEntry &entry) { result->entries.push_back(entry.name); });
-	}
-	return std::move(result);
-}
-
-static void PragmaCollateFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<PragmaCollateData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, data.entries.size());
-	output.SetCardinality(next - data.offset);
-	for (idx_t i = data.offset; i < next; i++) {
-		auto index = i - data.offset;
-		output.SetValue(0, index, Value(data.entries[i]));
-	}
-
-	data.offset = next;
-}
-
-void PragmaCollations::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("pragma_collations", {}, PragmaCollateFunction, PragmaCollateBind, PragmaCollateInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_database_size.cpp b/src/duckdb/src/function/table/system/pragma_database_size.cpp
deleted file mode 100644
index ba8f2020e..000000000
--- a/src/duckdb/src/function/table/system/pragma_database_size.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database_manager.hpp"
-
-namespace duckdb {
-
-struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
-	PragmaDatabaseSizeData() : index(0) {
-	}
-
-	idx_t index;
-	vector<reference<AttachedDatabase>> databases;
-	Value memory_usage;
-	Value memory_limit;
-};
-
-static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, TableFunctionBindInput &input,
-                                                       vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("database_size");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("block_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("total_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("used_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("free_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("wal_size");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("memory_usage");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("memory_limit");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<PragmaDatabaseSizeData>();
-	result->databases = DatabaseManager::Get(context).GetDatabases(context);
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	result->memory_usage = Value(StringUtil::BytesToHumanReadableString(buffer_manager.GetUsedMemory()));
-	auto max_memory = buffer_manager.GetMaxMemory();
-	result->memory_limit =
-	    max_memory == (idx_t)-1 ? Value("Unlimited") : Value(StringUtil::BytesToHumanReadableString(max_memory));
-
-	return std::move(result);
-}
-
-void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<PragmaDatabaseSizeData>();
-	idx_t row = 0;
-	for (; data.index < data.databases.size() && row < STANDARD_VECTOR_SIZE; data.index++) {
-		auto &db = data.databases[data.index].get();
-		if (db.IsSystem() || db.IsTemporary()) {
-			continue;
-		}
-		auto ds = db.GetCatalog().GetDatabaseSize(context);
-		idx_t col = 0;
-		output.data[col++].SetValue(row, Value(db.GetName()));
-		output.data[col++].SetValue(row, Value(StringUtil::BytesToHumanReadableString(ds.bytes)));
-		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.block_size)));
-		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.total_blocks)));
-		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.used_blocks)));
-		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.free_blocks)));
-		output.data[col++].SetValue(
-		    row, ds.wal_size == idx_t(-1) ? Value() : Value(StringUtil::BytesToHumanReadableString(ds.wal_size)));
-		output.data[col++].SetValue(row, data.memory_usage);
-		output.data[col++].SetValue(row, data.memory_limit);
-		row++;
-	}
-	output.SetCardinality(row);
-}
-
-void PragmaDatabaseSize::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_database_size", {}, PragmaDatabaseSizeFunction, PragmaDatabaseSizeBind,
-	                              PragmaDatabaseSizeInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_metadata_info.cpp b/src/duckdb/src/function/table/system/pragma_metadata_info.cpp
deleted file mode 100644
index 1a10c671e..000000000
--- a/src/duckdb/src/function/table/system/pragma_metadata_info.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/storage/database_size.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/function/function_set.hpp"
-namespace duckdb {
-
-struct PragmaMetadataFunctionData : public TableFunctionData {
-	explicit PragmaMetadataFunctionData() {
-	}
-
-	vector<MetadataBlockInfo> metadata_info;
-};
-
-struct PragmaMetadataOperatorData : public GlobalTableFunctionState {
-	PragmaMetadataOperatorData() : offset(0) {
-	}
-
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> PragmaMetadataInfoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                       vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("block_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("total_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("free_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("free_list");
-	return_types.emplace_back(LogicalType::LIST(LogicalType::BIGINT));
-
-	string db_name;
-	if (input.inputs.empty()) {
-		db_name = DatabaseManager::GetDefaultDatabase(context);
-	} else {
-		if (input.inputs[0].IsNull()) {
-			throw BinderException("Database argument for pragma_metadata_info cannot be NULL");
-		}
-		db_name = StringValue::Get(input.inputs[0]);
-	}
-	auto &catalog = Catalog::GetCatalog(context, db_name);
-	auto result = make_uniq<PragmaMetadataFunctionData>();
-	result->metadata_info = catalog.GetMetadataInfo(context);
-	return std::move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaMetadataInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<PragmaMetadataOperatorData>();
-}
-
-static void PragmaMetadataInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<PragmaMetadataFunctionData>();
-	auto &data = data_p.global_state->Cast<PragmaMetadataOperatorData>();
-	idx_t count = 0;
-	while (data.offset < bind_data.metadata_info.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = bind_data.metadata_info[data.offset++];
-
-		idx_t col_idx = 0;
-		// block_id
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.block_id));
-		// total_blocks
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.total_blocks)));
-		// free_blocks
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.free_list.size())));
-		// free_list
-		vector<Value> list_values;
-		for (auto &free_id : entry.free_list) {
-			list_values.push_back(Value::BIGINT(NumericCast<int64_t>(free_id)));
-		}
-		output.SetValue(col_idx++, count, Value::LIST(LogicalType::BIGINT, std::move(list_values)));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void PragmaMetadataInfo::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet metadata_info("pragma_metadata_info");
-	metadata_info.AddFunction(
-	    TableFunction({}, PragmaMetadataInfoFunction, PragmaMetadataInfoBind, PragmaMetadataInfoInit));
-	metadata_info.AddFunction(TableFunction({LogicalType::VARCHAR}, PragmaMetadataInfoFunction, PragmaMetadataInfoBind,
-	                                        PragmaMetadataInfoInit));
-	set.AddFunction(metadata_info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_storage_info.cpp b/src/duckdb/src/function/table/system/pragma_storage_info.cpp
deleted file mode 100644
index 5500c1c5d..000000000
--- a/src/duckdb/src/function/table/system/pragma_storage_info.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/planner/binder.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct PragmaStorageFunctionData : public TableFunctionData {
-	explicit PragmaStorageFunctionData(TableCatalogEntry &table_entry) : table_entry(table_entry) {
-	}
-
-	TableCatalogEntry &table_entry;
-	vector<ColumnSegmentInfo> column_segments_info;
-};
-
-struct PragmaStorageOperatorData : public GlobalTableFunctionState {
-	PragmaStorageOperatorData() : offset(0) {
-	}
-
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                      vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("row_group_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("column_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_path");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("segment_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("segment_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("start");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("compression");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("stats");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("has_updates");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("persistent");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("block_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("block_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("segment_info");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("additional_block_ids");
-	return_types.emplace_back(LogicalType::LIST(LogicalTypeId::BIGINT));
-
-	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
-
-	// look up the table name in the catalog
-	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
-	auto &table_entry = Catalog::GetEntry<TableCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
-	auto result = make_uniq<PragmaStorageFunctionData>(table_entry);
-	result->column_segments_info = table_entry.GetColumnSegmentInfo();
-	return std::move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaStorageInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<PragmaStorageOperatorData>();
-}
-
-static Value ValueFromBlockIdList(const vector<block_id_t> &block_ids) {
-	vector<Value> blocks;
-	for (auto &block_id : block_ids) {
-		blocks.push_back(Value::BIGINT(block_id));
-	}
-	return Value::LIST(LogicalTypeId::BIGINT, blocks);
-}
-
-static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<PragmaStorageFunctionData>();
-	auto &data = data_p.global_state->Cast<PragmaStorageOperatorData>();
-	idx_t count = 0;
-	auto &columns = bind_data.table_entry.GetColumns();
-	while (data.offset < bind_data.column_segments_info.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = bind_data.column_segments_info[data.offset++];
-
-		idx_t col_idx = 0;
-		// row_group_id
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.row_group_index)));
-		// column_name
-		auto &col = columns.GetColumn(PhysicalIndex(entry.column_id));
-		output.SetValue(col_idx++, count, Value(col.Name()));
-		// column_id
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.column_id)));
-		// column_path
-		output.SetValue(col_idx++, count, Value(entry.column_path));
-		// segment_id
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.segment_idx)));
-		// segment_type
-		output.SetValue(col_idx++, count, Value(entry.segment_type));
-		// start
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.segment_start)));
-		// count
-		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.segment_count)));
-		// compression
-		output.SetValue(col_idx++, count, Value(entry.compression_type));
-		// stats
-		output.SetValue(col_idx++, count, Value(entry.segment_stats));
-		// has_updates
-		output.SetValue(col_idx++, count, Value::BOOLEAN(entry.has_updates));
-		// persistent
-		output.SetValue(col_idx++, count, Value::BOOLEAN(entry.persistent));
-		// block_id
-		// block_offset
-		if (entry.persistent) {
-			output.SetValue(col_idx++, count, Value::BIGINT(entry.block_id));
-			output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.block_offset)));
-		} else {
-			output.SetValue(col_idx++, count, Value());
-			output.SetValue(col_idx++, count, Value());
-		}
-		// segment_info
-		output.SetValue(col_idx++, count, Value(entry.segment_info));
-		// additional_block_ids
-		if (entry.persistent) {
-			output.SetValue(col_idx++, count, ValueFromBlockIdList(entry.additional_blocks));
-		} else {
-			output.SetValue(col_idx++, count, Value());
-		}
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void PragmaStorageInfo::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_storage_info", {LogicalType::VARCHAR}, PragmaStorageInfoFunction,
-	                              PragmaStorageInfoBind, PragmaStorageInfoInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_table_info.cpp b/src/duckdb/src/function/table/system/pragma_table_info.cpp
deleted file mode 100644
index 56205d900..000000000
--- a/src/duckdb/src/function/table/system/pragma_table_info.cpp
+++ /dev/null
@@ -1,297 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct PragmaTableFunctionData : public TableFunctionData {
-	explicit PragmaTableFunctionData(CatalogEntry &entry_p, bool is_table_info)
-	    : entry(entry_p), is_table_info(is_table_info) {
-	}
-
-	CatalogEntry &entry;
-	bool is_table_info;
-};
-
-struct PragmaTableOperatorData : public GlobalTableFunctionState {
-	PragmaTableOperatorData() : offset(0) {
-	}
-	idx_t offset;
-};
-
-struct ColumnConstraintInfo {
-	bool not_null = false;
-	bool pk = false;
-	bool unique = false;
-};
-
-static Value DefaultValue(const ColumnDefinition &def) {
-	if (def.Generated()) {
-		return Value(def.GeneratedExpression().ToString());
-	}
-	if (!def.HasDefaultValue()) {
-		return Value();
-	}
-	auto &value = def.DefaultValue();
-	return Value(value.ToString());
-}
-
-struct PragmaTableInfoHelper {
-	static void GetSchema(vector<LogicalType> &return_types, vector<string> &names) {
-		names.emplace_back("cid");
-		return_types.emplace_back(LogicalType::INTEGER);
-
-		names.emplace_back("name");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("type");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("notnull");
-		return_types.emplace_back(LogicalType::BOOLEAN);
-
-		names.emplace_back("dflt_value");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("pk");
-		return_types.emplace_back(LogicalType::BOOLEAN);
-	}
-
-	static void GetTableColumns(const ColumnDefinition &column, ColumnConstraintInfo constraint_info, DataChunk &output,
-	                            idx_t index) {
-		// return values:
-		// "cid", PhysicalType::INT32
-		output.SetValue(0, index, Value::INTEGER((int32_t)column.Oid()));
-		// "name", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(column.Name()));
-		// "type", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(column.Type().ToString()));
-		// "notnull", PhysicalType::BOOL
-		output.SetValue(3, index, Value::BOOLEAN(constraint_info.not_null));
-		// "dflt_value", PhysicalType::VARCHAR
-		output.SetValue(4, index, DefaultValue(column));
-		// "pk", PhysicalType::BOOL
-		output.SetValue(5, index, Value::BOOLEAN(constraint_info.pk));
-	}
-
-	static void GetViewColumns(idx_t i, const string &name, const LogicalType &type, DataChunk &output, idx_t index) {
-		// return values:
-		// "cid", PhysicalType::INT32
-		output.SetValue(0, index, Value::INTEGER((int32_t)i));
-		// "name", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(name));
-		// "type", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(type.ToString()));
-		// "notnull", PhysicalType::BOOL
-		output.SetValue(3, index, Value::BOOLEAN(false));
-		// "dflt_value", PhysicalType::VARCHAR
-		output.SetValue(4, index, Value());
-		// "pk", PhysicalType::BOOL
-		output.SetValue(5, index, Value::BOOLEAN(false));
-	}
-};
-
-struct PragmaShowHelper {
-	static void GetSchema(vector<LogicalType> &return_types, vector<string> &names) {
-		names.emplace_back("column_name");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("column_type");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("null");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("key");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("default");
-		return_types.emplace_back(LogicalType::VARCHAR);
-
-		names.emplace_back("extra");
-		return_types.emplace_back(LogicalType::VARCHAR);
-	}
-
-	static void GetTableColumns(const ColumnDefinition &column, ColumnConstraintInfo constraint_info, DataChunk &output,
-	                            idx_t index) {
-		// "column_name", PhysicalType::VARCHAR
-		output.SetValue(0, index, Value(column.Name()));
-		// "column_type", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(column.Type().ToString()));
-		// "null", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(constraint_info.not_null ? "NO" : "YES"));
-		// "key", PhysicalType::VARCHAR
-		Value key;
-		if (constraint_info.pk || constraint_info.unique) {
-			key = Value(constraint_info.pk ? "PRI" : "UNI");
-		}
-		output.SetValue(3, index, key);
-		// "default", VARCHAR
-		output.SetValue(4, index, DefaultValue(column));
-		// "extra", VARCHAR
-		output.SetValue(5, index, Value());
-	}
-
-	static void GetViewColumns(idx_t i, const string &name, const LogicalType &type, DataChunk &output, idx_t index) {
-		// "column_name", PhysicalType::VARCHAR
-		output.SetValue(0, index, Value(name));
-		// "column_type", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(type.ToString()));
-		// "null", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value("YES"));
-		// "key", PhysicalType::VARCHAR
-		output.SetValue(3, index, Value());
-		// "default", VARCHAR
-		output.SetValue(4, index, Value());
-		// "extra", VARCHAR
-		output.SetValue(5, index, Value());
-	}
-};
-
-template <bool IS_PRAGMA_TABLE_INFO>
-static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	if (IS_PRAGMA_TABLE_INFO) {
-		PragmaTableInfoHelper::GetSchema(return_types, names);
-	} else {
-		PragmaShowHelper::GetSchema(return_types, names);
-	}
-
-	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
-
-	// look up the table name in the catalog
-	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
-	auto &entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
-	return make_uniq<PragmaTableFunctionData>(entry, IS_PRAGMA_TABLE_INFO);
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<PragmaTableOperatorData>();
-}
-
-static ColumnConstraintInfo CheckConstraints(TableCatalogEntry &table, const ColumnDefinition &column) {
-	ColumnConstraintInfo result;
-	// check all constraints
-	for (auto &constraint : table.GetConstraints()) {
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null = constraint->Cast<NotNullConstraint>();
-			if (not_null.index == column.Logical()) {
-				result.not_null = true;
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto &unique = constraint->Cast<UniqueConstraint>();
-			bool &constraint_info = unique.IsPrimaryKey() ? result.pk : result.unique;
-			if (unique.HasIndex()) {
-				if (unique.GetIndex() == column.Logical()) {
-					constraint_info = true;
-				}
-			} else {
-				auto &columns = unique.GetColumnNames();
-				if (std::find(columns.begin(), columns.end(), column.GetName()) != columns.end()) {
-					constraint_info = true;
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-	return result;
-}
-
-void PragmaTableInfo::GetColumnInfo(TableCatalogEntry &table, const ColumnDefinition &column, DataChunk &output,
-                                    idx_t index) {
-	auto constraint_info = CheckConstraints(table, column);
-	PragmaShowHelper::GetTableColumns(column, constraint_info, output, index);
-}
-
-static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry &table, DataChunk &output,
-                                 bool is_table_info) {
-	if (data.offset >= table.GetColumns().LogicalColumnCount()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table.GetColumns().LogicalColumnCount());
-	output.SetCardinality(next - data.offset);
-
-	for (idx_t i = data.offset; i < next; i++) {
-		auto index = i - data.offset;
-		auto &column = table.GetColumn(LogicalIndex(i));
-		D_ASSERT(column.Oid() < (idx_t)NumericLimits<int32_t>::Maximum());
-		auto constraint_info = CheckConstraints(table, column);
-
-		if (is_table_info) {
-			PragmaTableInfoHelper::GetTableColumns(column, constraint_info, output, index);
-		} else {
-			PragmaShowHelper::GetTableColumns(column, constraint_info, output, index);
-		}
-	}
-	data.offset = next;
-}
-
-static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry &view, DataChunk &output,
-                                bool is_table_info) {
-	if (data.offset >= view.types.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, view.types.size());
-	output.SetCardinality(next - data.offset);
-
-	for (idx_t i = data.offset; i < next; i++) {
-		auto index = i - data.offset;
-		auto type = view.types[i];
-		auto &name = i < view.aliases.size() ? view.aliases[i] : view.names[i];
-
-		if (is_table_info) {
-			PragmaTableInfoHelper::GetViewColumns(i, name, type, output, index);
-		} else {
-			PragmaShowHelper::GetViewColumns(i, name, type, output, index);
-		}
-	}
-	data.offset = next;
-}
-
-static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<PragmaTableFunctionData>();
-	auto &state = data_p.global_state->Cast<PragmaTableOperatorData>();
-	switch (bind_data.entry.type) {
-	case CatalogType::TABLE_ENTRY:
-		PragmaTableInfoTable(state, bind_data.entry.Cast<TableCatalogEntry>(), output, bind_data.is_table_info);
-		break;
-	case CatalogType::VIEW_ENTRY:
-		PragmaTableInfoView(state, bind_data.entry.Cast<ViewCatalogEntry>(), output, bind_data.is_table_info);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented catalog type for pragma_table_info");
-	}
-}
-
-void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_table_info", {LogicalType::VARCHAR}, PragmaTableInfoFunction,
-	                              PragmaTableInfoBind<true>, PragmaTableInfoInit));
-	set.AddFunction(TableFunction("pragma_show", {LogicalType::VARCHAR}, PragmaTableInfoFunction,
-	                              PragmaTableInfoBind<false>, PragmaTableInfoInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_table_sample.cpp b/src/duckdb/src/function/table/system/pragma_table_sample.cpp
deleted file mode 100644
index 7f4122b92..000000000
--- a/src/duckdb/src/function/table/system/pragma_table_sample.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct DuckDBTableSampleFunctionData : public TableFunctionData {
-	explicit DuckDBTableSampleFunctionData(CatalogEntry &entry_p) : entry(entry_p) {
-	}
-	CatalogEntry &entry;
-};
-
-struct DuckDBTableSampleOperatorData : public GlobalTableFunctionState {
-	DuckDBTableSampleOperatorData() : sample_offset(0) {
-		sample = nullptr;
-	}
-	idx_t sample_offset;
-	unique_ptr<BlockingSample> sample;
-};
-
-static unique_ptr<FunctionData> DuckDBTableSampleBind(ClientContext &context, TableFunctionBindInput &input,
-                                                      vector<LogicalType> &return_types, vector<string> &names) {
-
-	// look up the table name in the catalog
-	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
-	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
-
-	auto &entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
-	if (entry.type != CatalogType::TABLE_ENTRY) {
-		throw NotImplementedException("Invalid Catalog type passed to table_sample()");
-	}
-	auto &table_entry = entry.Cast<TableCatalogEntry>();
-	auto types = table_entry.GetTypes();
-	for (auto &type : types) {
-		return_types.push_back(type);
-	}
-	for (idx_t i = 0; i < types.size(); i++) {
-		auto logical_index = LogicalIndex(i);
-		auto &col = table_entry.GetColumn(logical_index);
-		names.push_back(col.GetName());
-	}
-
-	return make_uniq<DuckDBTableSampleFunctionData>(entry);
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBTableSampleInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<DuckDBTableSampleOperatorData>();
-}
-
-static void DuckDBTableSampleTable(ClientContext &context, DuckDBTableSampleOperatorData &data,
-                                   TableCatalogEntry &table, DataChunk &output) {
-	// if table has statistics.
-	// copy the sample of statistics into the output chunk
-	if (!data.sample) {
-		data.sample = table.GetSample();
-	}
-	if (data.sample) {
-		auto sample_chunk = data.sample->GetChunk();
-		if (sample_chunk) {
-			sample_chunk->Copy(output, 0);
-			data.sample_offset += sample_chunk->size();
-		}
-	}
-}
-
-static void DuckDBTableSampleFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<DuckDBTableSampleFunctionData>();
-	auto &state = data_p.global_state->Cast<DuckDBTableSampleOperatorData>();
-	switch (bind_data.entry.type) {
-	case CatalogType::TABLE_ENTRY:
-		DuckDBTableSampleTable(context, state, bind_data.entry.Cast<TableCatalogEntry>(), output);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented catalog type for pragma_table_sample");
-	}
-}
-
-void DuckDBTableSample::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_table_sample", {LogicalType::VARCHAR}, DuckDBTableSampleFunction,
-	                              DuckDBTableSampleBind, DuckDBTableSampleInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/pragma_user_agent.cpp b/src/duckdb/src/function/table/system/pragma_user_agent.cpp
deleted file mode 100644
index 3803f7195..000000000
--- a/src/duckdb/src/function/table/system/pragma_user_agent.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-struct PragmaUserAgentData : public GlobalTableFunctionState {
-	PragmaUserAgentData() : finished(false) {
-	}
-
-	std::string user_agent;
-	bool finished;
-};
-
-static unique_ptr<FunctionData> PragmaUserAgentBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-
-	names.emplace_back("user_agent");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaUserAgentInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_uniq<PragmaUserAgentData>();
-	auto &config = DBConfig::GetConfig(context);
-	result->user_agent = config.UserAgent();
-
-	return std::move(result);
-}
-
-void PragmaUserAgentFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<PragmaUserAgentData>();
-
-	if (data.finished) {
-		// signal end of output
-		return;
-	}
-
-	output.SetCardinality(1);
-	output.SetValue(0, 0, data.user_agent);
-
-	data.finished = true;
-}
-
-void PragmaUserAgent::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("pragma_user_agent", {}, PragmaUserAgentFunction, PragmaUserAgentBind, PragmaUserAgentInit));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/test_all_types.cpp b/src/duckdb/src/function/table/system/test_all_types.cpp
deleted file mode 100644
index 0fbcd884b..000000000
--- a/src/duckdb/src/function/table/system/test_all_types.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/function/table/system_functions.hpp"
-
-#include <cmath>
-#include <limits>
-
-namespace duckdb {
-
-struct TestAllTypesData : public GlobalTableFunctionState {
-	TestAllTypesData() : offset(0) {
-	}
-
-	vector<vector<Value>> entries;
-	idx_t offset;
-};
-
-vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
-	vector<TestType> result;
-	// scalar types/numerics
-	result.emplace_back(LogicalType::BOOLEAN, "bool");
-	result.emplace_back(LogicalType::TINYINT, "tinyint");
-	result.emplace_back(LogicalType::SMALLINT, "smallint");
-	result.emplace_back(LogicalType::INTEGER, "int");
-	result.emplace_back(LogicalType::BIGINT, "bigint");
-	result.emplace_back(LogicalType::HUGEINT, "hugeint");
-	result.emplace_back(LogicalType::UHUGEINT, "uhugeint");
-	result.emplace_back(LogicalType::UTINYINT, "utinyint");
-	result.emplace_back(LogicalType::USMALLINT, "usmallint");
-	result.emplace_back(LogicalType::UINTEGER, "uint");
-	result.emplace_back(LogicalType::UBIGINT, "ubigint");
-	result.emplace_back(LogicalType::VARINT, "varint");
-	result.emplace_back(LogicalType::DATE, "date");
-	result.emplace_back(LogicalType::TIME, "time");
-	result.emplace_back(LogicalType::TIMESTAMP, "timestamp");
-	result.emplace_back(LogicalType::TIMESTAMP_S, "timestamp_s");
-	result.emplace_back(LogicalType::TIMESTAMP_MS, "timestamp_ms");
-	result.emplace_back(LogicalType::TIMESTAMP_NS, "timestamp_ns");
-	result.emplace_back(LogicalType::TIME_TZ, "time_tz");
-	result.emplace_back(LogicalType::TIMESTAMP_TZ, "timestamp_tz");
-	result.emplace_back(LogicalType::FLOAT, "float");
-	result.emplace_back(LogicalType::DOUBLE, "double");
-	result.emplace_back(LogicalType::DECIMAL(4, 1), "dec_4_1");
-	result.emplace_back(LogicalType::DECIMAL(9, 4), "dec_9_4");
-	result.emplace_back(LogicalType::DECIMAL(18, 6), "dec_18_6");
-	result.emplace_back(LogicalType::DECIMAL(38, 10), "dec38_10");
-	result.emplace_back(LogicalType::UUID, "uuid");
-
-	// interval
-	interval_t min_interval;
-	min_interval.months = 0;
-	min_interval.days = 0;
-	min_interval.micros = 0;
-
-	interval_t max_interval;
-	max_interval.months = 999;
-	max_interval.days = 999;
-	max_interval.micros = 999999999;
-	result.emplace_back(LogicalType::INTERVAL, "interval", Value::INTERVAL(min_interval),
-	                    Value::INTERVAL(max_interval));
-	// strings/blobs/bitstrings
-	result.emplace_back(LogicalType::VARCHAR, "varchar", Value("🦆🦆🦆🦆🦆🦆"),
-	                    Value(string("goo\x00se", 6)));
-	result.emplace_back(LogicalType::BLOB, "blob", Value::BLOB("thisisalongblob\\x00withnullbytes"),
-	                    Value::BLOB("\\x00\\x00\\x00a"));
-	result.emplace_back(LogicalType::BIT, "bit", Value::BIT("0010001001011100010101011010111"), Value::BIT("10101"));
-
-	// enums
-	Vector small_enum(LogicalType::VARCHAR, 2);
-	auto small_enum_ptr = FlatVector::GetData<string_t>(small_enum);
-	small_enum_ptr[0] = StringVector::AddStringOrBlob(small_enum, "DUCK_DUCK_ENUM");
-	small_enum_ptr[1] = StringVector::AddStringOrBlob(small_enum, "GOOSE");
-	result.emplace_back(LogicalType::ENUM(small_enum, 2), "small_enum");
-
-	Vector medium_enum(LogicalType::VARCHAR, 300);
-	auto medium_enum_ptr = FlatVector::GetData<string_t>(medium_enum);
-	for (idx_t i = 0; i < 300; i++) {
-		medium_enum_ptr[i] = StringVector::AddStringOrBlob(medium_enum, string("enum_") + to_string(i));
-	}
-	result.emplace_back(LogicalType::ENUM(medium_enum, 300), "medium_enum");
-
-	if (use_large_enum) {
-		// this is a big one... not sure if we should push this one here, but it's required for completeness
-		Vector large_enum(LogicalType::VARCHAR, 70000);
-		auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
-		for (idx_t i = 0; i < 70000; i++) {
-			large_enum_ptr[i] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(i));
-		}
-		result.emplace_back(LogicalType::ENUM(large_enum, 70000), "large_enum");
-	} else {
-		Vector large_enum(LogicalType::VARCHAR, 2);
-		auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
-		large_enum_ptr[0] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(0));
-		large_enum_ptr[1] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(69999));
-		result.emplace_back(LogicalType::ENUM(large_enum, 2), "large_enum");
-	}
-
-	// arrays
-	auto int_list_type = LogicalType::LIST(LogicalType::INTEGER);
-	auto empty_int_list = Value::LIST(LogicalType::INTEGER, vector<Value>());
-	auto int_list =
-	    Value::LIST(LogicalType::INTEGER, {Value::INTEGER(42), Value::INTEGER(999), Value(LogicalType::INTEGER),
-	                                       Value(LogicalType::INTEGER), Value::INTEGER(-42)});
-	result.emplace_back(int_list_type, "int_array", empty_int_list, int_list);
-
-	auto double_list_type = LogicalType::LIST(LogicalType::DOUBLE);
-	auto empty_double_list = Value::LIST(LogicalType::DOUBLE, vector<Value>());
-	auto double_list = Value::LIST(LogicalType::DOUBLE, {Value::DOUBLE(42), Value::DOUBLE(NAN),
-	                                                     Value::DOUBLE(std::numeric_limits<double>::infinity()),
-	                                                     Value::DOUBLE(-std::numeric_limits<double>::infinity()),
-	                                                     Value(LogicalType::DOUBLE), Value::DOUBLE(-42)});
-	result.emplace_back(double_list_type, "double_array", empty_double_list, double_list);
-
-	auto date_list_type = LogicalType::LIST(LogicalType::DATE);
-	auto empty_date_list = Value::LIST(LogicalType::DATE, vector<Value>());
-	auto date_list = Value::LIST(LogicalType::DATE, {Value::DATE(date_t()), Value::DATE(date_t::infinity()),
-	                                                 Value::DATE(date_t::ninfinity()), Value(LogicalType::DATE),
-	                                                 Value::DATE(Date::FromString("2022-05-12"))});
-	result.emplace_back(date_list_type, "date_array", empty_date_list, date_list);
-
-	auto timestamp_list_type = LogicalType::LIST(LogicalType::TIMESTAMP);
-	auto empty_timestamp_list = Value::LIST(LogicalType::TIMESTAMP, vector<Value>());
-	auto timestamp_list =
-	    Value::LIST(LogicalType::TIMESTAMP, {Value::TIMESTAMP(timestamp_t()), Value::TIMESTAMP(timestamp_t::infinity()),
-	                                         Value::TIMESTAMP(timestamp_t::ninfinity()), Value(LogicalType::TIMESTAMP),
-	                                         Value::TIMESTAMP(Timestamp::FromString("2022-05-12 16:23:45"))});
-	result.emplace_back(timestamp_list_type, "timestamp_array", empty_timestamp_list, timestamp_list);
-
-	auto timestamptz_list_type = LogicalType::LIST(LogicalType::TIMESTAMP_TZ);
-	auto empty_timestamptz_list = Value::LIST(LogicalType::TIMESTAMP_TZ, vector<Value>());
-	auto timestamptz_list =
-	    Value::LIST(LogicalType::TIMESTAMP_TZ,
-	                {Value::TIMESTAMPTZ(timestamp_tz_t()), Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::infinity())),
-	                 Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::ninfinity())), Value(LogicalType::TIMESTAMP_TZ),
-	                 Value::TIMESTAMPTZ(timestamp_tz_t(Timestamp::FromString("2022-05-12 16:23:45-07")))});
-	result.emplace_back(timestamptz_list_type, "timestamptz_array", empty_timestamptz_list, timestamptz_list);
-
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto empty_varchar_list = Value::LIST(LogicalType::VARCHAR, vector<Value>());
-	auto varchar_list = Value::LIST(LogicalType::VARCHAR, {Value("🦆🦆🦆🦆🦆🦆"), Value("goose"),
-	                                                       Value(LogicalType::VARCHAR), Value("")});
-	result.emplace_back(varchar_list_type, "varchar_array", empty_varchar_list, varchar_list);
-
-	// nested arrays
-	auto nested_list_type = LogicalType::LIST(int_list_type);
-	auto empty_nested_list = Value::LIST(int_list_type, vector<Value>());
-	auto nested_int_list =
-	    Value::LIST(int_list_type, {empty_int_list, int_list, Value(int_list_type), empty_int_list, int_list});
-	result.emplace_back(nested_list_type, "nested_int_array", empty_nested_list, nested_int_list);
-
-	// structs
-	child_list_t<LogicalType> struct_type_list;
-	struct_type_list.push_back(make_pair("a", LogicalType::INTEGER));
-	struct_type_list.push_back(make_pair("b", LogicalType::VARCHAR));
-	auto struct_type = LogicalType::STRUCT(struct_type_list);
-
-	child_list_t<Value> min_struct_list;
-	min_struct_list.push_back(make_pair("a", Value(LogicalType::INTEGER)));
-	min_struct_list.push_back(make_pair("b", Value(LogicalType::VARCHAR)));
-	auto min_struct_val = Value::STRUCT(std::move(min_struct_list));
-
-	child_list_t<Value> max_struct_list;
-	max_struct_list.push_back(make_pair("a", Value::INTEGER(42)));
-	max_struct_list.push_back(make_pair("b", Value("🦆🦆🦆🦆🦆🦆")));
-	auto max_struct_val = Value::STRUCT(std::move(max_struct_list));
-
-	result.emplace_back(struct_type, "struct", min_struct_val, max_struct_val);
-
-	// structs with lists
-	child_list_t<LogicalType> struct_list_type_list;
-	struct_list_type_list.push_back(make_pair("a", int_list_type));
-	struct_list_type_list.push_back(make_pair("b", varchar_list_type));
-	auto struct_list_type = LogicalType::STRUCT(struct_list_type_list);
-
-	child_list_t<Value> min_struct_vl_list;
-	min_struct_vl_list.push_back(make_pair("a", Value(int_list_type)));
-	min_struct_vl_list.push_back(make_pair("b", Value(varchar_list_type)));
-	auto min_struct_val_list = Value::STRUCT(std::move(min_struct_vl_list));
-
-	child_list_t<Value> max_struct_vl_list;
-	max_struct_vl_list.push_back(make_pair("a", int_list));
-	max_struct_vl_list.push_back(make_pair("b", varchar_list));
-	auto max_struct_val_list = Value::STRUCT(std::move(max_struct_vl_list));
-
-	result.emplace_back(struct_list_type, "struct_of_arrays", std::move(min_struct_val_list),
-	                    std::move(max_struct_val_list));
-
-	// array of structs
-	auto array_of_structs_type = LogicalType::LIST(struct_type);
-	auto min_array_of_struct_val = Value::LIST(struct_type, vector<Value>());
-	auto max_array_of_struct_val = Value::LIST(struct_type, {min_struct_val, max_struct_val, Value(struct_type)});
-	result.emplace_back(array_of_structs_type, "array_of_structs", std::move(min_array_of_struct_val),
-	                    std::move(max_array_of_struct_val));
-
-	// map
-	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	auto min_map_value = Value::MAP(ListType::GetChildType(map_type), vector<Value>());
-
-	child_list_t<Value> map_struct1;
-	map_struct1.push_back(make_pair("key", Value("key1")));
-	map_struct1.push_back(make_pair("value", Value("🦆🦆🦆🦆🦆🦆")));
-	child_list_t<Value> map_struct2;
-	map_struct2.push_back(make_pair("key", Value("key2")));
-	map_struct2.push_back(make_pair("value", Value("goose")));
-
-	vector<Value> map_values;
-	map_values.push_back(Value::STRUCT(map_struct1));
-	map_values.push_back(Value::STRUCT(map_struct2));
-
-	auto max_map_value = Value::MAP(ListType::GetChildType(map_type), map_values);
-	result.emplace_back(map_type, "map", std::move(min_map_value), std::move(max_map_value));
-
-	// union
-	child_list_t<LogicalType> members = {{"name", LogicalType::VARCHAR}, {"age", LogicalType::SMALLINT}};
-	auto union_type = LogicalType::UNION(members);
-	const Value &min = Value::UNION(members, 0, Value("Frank"));
-	const Value &max = Value::UNION(members, 1, Value::SMALLINT(5));
-	result.emplace_back(union_type, "union", min, max);
-
-	// fixed int array
-	auto fixed_int_array_type = LogicalType::ARRAY(LogicalType::INTEGER, 3);
-	auto fixed_int_min_array_value = Value::ARRAY(LogicalType::INTEGER, {Value(LogicalType::INTEGER), 2, 3});
-	auto fixed_int_max_array_value = Value::ARRAY(LogicalType::INTEGER, {4, 5, 6});
-	result.emplace_back(fixed_int_array_type, "fixed_int_array", fixed_int_min_array_value, fixed_int_max_array_value);
-
-	// fixed varchar array
-	auto fixed_varchar_array_type = LogicalType::ARRAY(LogicalType::VARCHAR, 3);
-	auto fixed_varchar_min_array_value =
-	    Value::ARRAY(LogicalType::VARCHAR, {Value("a"), Value(LogicalType::VARCHAR), Value("c")});
-	auto fixed_varchar_max_array_value = Value::ARRAY(LogicalType::VARCHAR, {Value("d"), Value("e"), Value("f")});
-	result.emplace_back(fixed_varchar_array_type, "fixed_varchar_array", fixed_varchar_min_array_value,
-	                    fixed_varchar_max_array_value);
-
-	// fixed nested int array
-	auto fixed_nested_int_array_type = LogicalType::ARRAY(fixed_int_array_type, 3);
-	auto fixed_nested_int_min_array_value = Value::ARRAY(
-	    fixed_int_array_type, {fixed_int_min_array_value, Value(fixed_int_array_type), fixed_int_min_array_value});
-	auto fixed_nested_int_max_array_value = Value::ARRAY(
-	    fixed_int_array_type, {fixed_int_max_array_value, fixed_int_min_array_value, fixed_int_max_array_value});
-	result.emplace_back(fixed_nested_int_array_type, "fixed_nested_int_array", fixed_nested_int_min_array_value,
-	                    fixed_nested_int_max_array_value);
-
-	// fixed nested varchar array
-	auto fixed_nested_varchar_array_type = LogicalType::ARRAY(fixed_varchar_array_type, 3);
-	auto fixed_nested_varchar_min_array_value =
-	    Value::ARRAY(fixed_varchar_array_type,
-	                 {fixed_varchar_min_array_value, Value(fixed_varchar_array_type), fixed_varchar_min_array_value});
-	auto fixed_nested_varchar_max_array_value =
-	    Value::ARRAY(fixed_varchar_array_type,
-	                 {fixed_varchar_max_array_value, fixed_varchar_min_array_value, fixed_varchar_max_array_value});
-	result.emplace_back(fixed_nested_varchar_array_type, "fixed_nested_varchar_array",
-	                    fixed_nested_varchar_min_array_value, fixed_nested_varchar_max_array_value);
-
-	// fixed array of structs
-	auto fixed_struct_array_type = LogicalType::ARRAY(struct_type, 3);
-	auto fixed_struct_min_array_value = Value::ARRAY(struct_type, {min_struct_val, max_struct_val, min_struct_val});
-	auto fixed_struct_max_array_value = Value::ARRAY(struct_type, {max_struct_val, min_struct_val, max_struct_val});
-	result.emplace_back(fixed_struct_array_type, "fixed_struct_array", fixed_struct_min_array_value,
-	                    fixed_struct_max_array_value);
-
-	// struct of fixed array
-	auto struct_of_fixed_array_type =
-	    LogicalType::STRUCT({{"a", fixed_int_array_type}, {"b", fixed_varchar_array_type}});
-	auto struct_of_fixed_array_min_value =
-	    Value::STRUCT({{"a", fixed_int_min_array_value}, {"b", fixed_varchar_min_array_value}});
-	auto struct_of_fixed_array_max_value =
-	    Value::STRUCT({{"a", fixed_int_max_array_value}, {"b", fixed_varchar_max_array_value}});
-	result.emplace_back(struct_of_fixed_array_type, "struct_of_fixed_array", struct_of_fixed_array_min_value,
-	                    struct_of_fixed_array_max_value);
-
-	// fixed array of list of int
-	auto fixed_array_of_list_of_int_type = LogicalType::ARRAY(int_list_type, 3);
-	auto fixed_array_of_list_of_int_min_value = Value::ARRAY(int_list_type, {empty_int_list, int_list, empty_int_list});
-	auto fixed_array_of_list_of_int_max_value = Value::ARRAY(int_list_type, {int_list, empty_int_list, int_list});
-	result.emplace_back(fixed_array_of_list_of_int_type, "fixed_array_of_int_list",
-	                    fixed_array_of_list_of_int_min_value, fixed_array_of_list_of_int_max_value);
-
-	// list of fixed array of int
-	auto list_of_fixed_array_of_int_type = LogicalType::LIST(fixed_int_array_type);
-	auto list_of_fixed_array_of_int_min_value = Value::LIST(
-	    fixed_int_array_type, {fixed_int_min_array_value, fixed_int_max_array_value, fixed_int_min_array_value});
-	auto list_of_fixed_array_of_int_max_value = Value::LIST(
-	    fixed_int_array_type, {fixed_int_max_array_value, fixed_int_min_array_value, fixed_int_max_array_value});
-	result.emplace_back(list_of_fixed_array_of_int_type, "list_of_fixed_int_array",
-	                    list_of_fixed_array_of_int_min_value, list_of_fixed_array_of_int_max_value);
-
-	return result;
-}
-
-struct TestAllTypesBindData : public TableFunctionData {
-	vector<TestType> test_types;
-};
-
-static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<TestAllTypesBindData>();
-	bool use_large_enum = false;
-	auto entry = input.named_parameters.find("use_large_enum");
-	if (entry != input.named_parameters.end()) {
-		use_large_enum = BooleanValue::Get(entry->second);
-	}
-	result->test_types = TestAllTypesFun::GetTestTypes(use_large_enum);
-	for (auto &test_type : result->test_types) {
-		return_types.push_back(test_type.type);
-		names.push_back(test_type.name);
-	}
-	return std::move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<TestAllTypesBindData>();
-	auto result = make_uniq<TestAllTypesData>();
-	// 3 rows: min, max and NULL
-	result->entries.resize(3);
-	// initialize the values
-	for (auto &test_type : bind_data.test_types) {
-		result->entries[0].push_back(test_type.min_value);
-		result->entries[1].push_back(test_type.max_value);
-		result->entries[2].emplace_back(test_type.type);
-	}
-	return std::move(result);
-}
-
-void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<TestAllTypesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &vals = data.entries[data.offset++];
-		for (idx_t col_idx = 0; col_idx < vals.size(); col_idx++) {
-			output.SetValue(col_idx, count, vals[col_idx]);
-		}
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void TestAllTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction test_all_types("test_all_types", {}, TestAllTypesFunction, TestAllTypesBind, TestAllTypesInit);
-	test_all_types.named_parameters["use_large_enum"] = LogicalType::BOOLEAN;
-	set.AddFunction(test_all_types);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system/test_vector_types.cpp b/src/duckdb/src/function/table/system/test_vector_types.cpp
deleted file mode 100644
index 23dab8758..000000000
--- a/src/duckdb/src/function/table/system/test_vector_types.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/pair.hpp"
-
-namespace duckdb {
-
-// FLAT, CONSTANT, DICTIONARY, SEQUENCE
-struct TestVectorBindData : public TableFunctionData {
-	vector<LogicalType> types;
-	bool all_flat = false;
-};
-
-struct TestVectorTypesData : public GlobalTableFunctionState {
-	TestVectorTypesData() : offset(0) {
-	}
-
-	vector<unique_ptr<DataChunk>> entries;
-	idx_t offset;
-};
-
-struct TestVectorInfo {
-	TestVectorInfo(const vector<LogicalType> &types, const map<LogicalTypeId, TestType> &test_type_map,
-	               vector<unique_ptr<DataChunk>> &entries)
-	    : types(types), test_type_map(test_type_map), entries(entries) {
-	}
-
-	const vector<LogicalType> &types;
-	const map<LogicalTypeId, TestType> &test_type_map;
-	vector<unique_ptr<DataChunk>> &entries;
-};
-
-struct TestGeneratedValues {
-public:
-	void AddColumn(vector<Value> values) {
-		if (!column_values.empty() && column_values[0].size() != values.size()) {
-			throw InternalException("Size mismatch when adding a column to TestGeneratedValues");
-		}
-		column_values.push_back(std::move(values));
-	}
-
-	const Value &GetValue(idx_t row, idx_t column) const {
-		return column_values[column][row];
-	}
-
-	idx_t Rows() const {
-		return column_values.empty() ? 0 : column_values[0].size();
-	}
-
-	idx_t Columns() const {
-		return column_values.size();
-	}
-
-private:
-	vector<vector<Value>> column_values;
-};
-
-struct TestVectorFlat {
-	static constexpr const idx_t TEST_VECTOR_CARDINALITY = 3;
-
-	static vector<Value> GenerateValues(TestVectorInfo &info, const LogicalType &type) {
-		vector<Value> result;
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT: {
-			vector<child_list_t<Value>> struct_children;
-			auto &child_types = StructType::GetChildTypes(type);
-
-			struct_children.resize(TEST_VECTOR_CARDINALITY);
-			for (auto &child_type : child_types) {
-				auto child_values = GenerateValues(info, child_type.second);
-
-				for (idx_t i = 0; i < child_values.size(); i++) {
-					struct_children[i].push_back(make_pair(child_type.first, std::move(child_values[i])));
-				}
-			}
-			for (auto &struct_child : struct_children) {
-				result.push_back(Value::STRUCT(std::move(struct_child)));
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			if (type.id() == LogicalTypeId::MAP) {
-				auto &child_type = ListType::GetChildType(type);
-				auto child_values = GenerateValues(info, child_type);
-				result.push_back(Value::MAP(child_type, {child_values[0]}));
-				result.push_back(Value(type));
-				result.push_back(Value::MAP(child_type, {child_values[1]}));
-				break;
-			}
-			auto &child_type = ListType::GetChildType(type);
-			auto child_values = GenerateValues(info, child_type);
-
-			result.push_back(Value::LIST(child_type, {child_values[0], child_values[1]}));
-			result.push_back(Value::LIST(child_type, {}));
-			result.push_back(Value::LIST(child_type, {child_values[2]}));
-			break;
-		}
-		default: {
-			auto entry = info.test_type_map.find(type.id());
-			if (entry == info.test_type_map.end()) {
-				throw NotImplementedException("Unimplemented type for test_vector_types %s", type.ToString());
-			}
-			result.push_back(entry->second.min_value);
-			result.push_back(entry->second.max_value);
-			result.emplace_back(type);
-			break;
-		}
-		}
-		return result;
-	}
-
-	static TestGeneratedValues GenerateValues(TestVectorInfo &info) {
-		// generate the values for each column
-		TestGeneratedValues generated_values;
-		for (auto &type : info.types) {
-			generated_values.AddColumn(GenerateValues(info, type));
-		}
-		return generated_values;
-	}
-
-	static void Generate(TestVectorInfo &info) {
-		auto result_values = GenerateValues(info);
-		for (idx_t cur_row = 0; cur_row < result_values.Rows(); cur_row += STANDARD_VECTOR_SIZE) {
-			auto result = make_uniq<DataChunk>();
-			result->Initialize(Allocator::DefaultAllocator(), info.types);
-			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, result_values.Rows() - cur_row);
-			for (idx_t c = 0; c < info.types.size(); c++) {
-				for (idx_t i = 0; i < cardinality; i++) {
-					result->data[c].SetValue(i, result_values.GetValue(cur_row + i, c));
-				}
-			}
-			result->SetCardinality(cardinality);
-			info.entries.push_back(std::move(result));
-		}
-	}
-};
-
-struct TestVectorConstant {
-	static void Generate(TestVectorInfo &info) {
-		auto values = TestVectorFlat::GenerateValues(info);
-		for (idx_t cur_row = 0; cur_row < TestVectorFlat::TEST_VECTOR_CARDINALITY; cur_row += STANDARD_VECTOR_SIZE) {
-			auto result = make_uniq<DataChunk>();
-			result->Initialize(Allocator::DefaultAllocator(), info.types);
-			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, TestVectorFlat::TEST_VECTOR_CARDINALITY - cur_row);
-			for (idx_t c = 0; c < info.types.size(); c++) {
-				result->data[c].SetValue(0, values.GetValue(0, c));
-				result->data[c].SetVectorType(VectorType::CONSTANT_VECTOR);
-			}
-			result->SetCardinality(cardinality);
-
-			info.entries.push_back(std::move(result));
-		}
-	}
-};
-
-struct TestVectorSequence {
-	static void GenerateVector(TestVectorInfo &info, const LogicalType &type, Vector &result) {
-		D_ASSERT(type == result.GetType());
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-			result.Sequence(3, 2, 3);
-#if STANDARD_VECTOR_SIZE <= 2
-			result.Flatten(3);
-#endif
-			return;
-		default:
-			break;
-		}
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT: {
-			auto &child_entries = StructVector::GetEntries(result);
-			for (auto &child_entry : child_entries) {
-				GenerateVector(info, child_entry->GetType(), *child_entry);
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			D_ASSERT(type.id() != LogicalTypeId::MAP);
-			auto data = FlatVector::GetData<list_entry_t>(result);
-			data[0].offset = 0;
-			data[0].length = 2;
-			data[1].offset = 2;
-			data[1].length = 0;
-			data[2].offset = 2;
-			data[2].length = 1;
-
-			GenerateVector(info, ListType::GetChildType(type), ListVector::GetEntry(result));
-			ListVector::SetListSize(result, 3);
-			break;
-		}
-		default: {
-			auto entry = info.test_type_map.find(type.id());
-			if (entry == info.test_type_map.end()) {
-				throw NotImplementedException("Unimplemented type for test_vector_types %s", type.ToString());
-			}
-			result.SetValue(0, entry->second.min_value);
-			result.SetValue(1, entry->second.max_value);
-			result.SetValue(2, Value(type));
-			break;
-		}
-		}
-	}
-
-	static void Generate(TestVectorInfo &info) {
-		static constexpr const idx_t SEQ_CARDINALITY = 3;
-
-		auto result = make_uniq<DataChunk>();
-		result->Initialize(Allocator::DefaultAllocator(), info.types,
-		                   MaxValue<idx_t>(SEQ_CARDINALITY, STANDARD_VECTOR_SIZE));
-
-		for (idx_t c = 0; c < info.types.size(); c++) {
-			if (info.types[c].id() == LogicalTypeId::MAP) {
-				// FIXME: we don't support MAP in the TestVectorSequence
-				return;
-			}
-			GenerateVector(info, info.types[c], result->data[c]);
-		}
-		result->SetCardinality(SEQ_CARDINALITY);
-#if STANDARD_VECTOR_SIZE > 2
-		info.entries.push_back(std::move(result));
-#else
-		// vsize = 2, split into two smaller data chunks
-		for (idx_t offset = 0; offset < SEQ_CARDINALITY; offset += STANDARD_VECTOR_SIZE) {
-			auto new_result = make_uniq<DataChunk>();
-			new_result->Initialize(Allocator::DefaultAllocator(), info.types);
-
-			idx_t copy_count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, SEQ_CARDINALITY - offset);
-			result->Copy(*new_result, *FlatVector::IncrementalSelectionVector(), offset + copy_count, offset);
-
-			info.entries.push_back(std::move(new_result));
-		}
-#endif
-	}
-};
-
-struct TestVectorDictionary {
-	static void Generate(TestVectorInfo &info) {
-		idx_t current_chunk = info.entries.size();
-
-		unordered_set<idx_t> slice_entries {1, 2};
-
-		TestVectorFlat::Generate(info);
-		idx_t current_idx = 0;
-		for (idx_t i = current_chunk; i < info.entries.size(); i++) {
-			auto &chunk = *info.entries[i];
-			SelectionVector sel(STANDARD_VECTOR_SIZE);
-			idx_t sel_idx = 0;
-			for (idx_t k = 0; k < chunk.size(); k++) {
-				if (slice_entries.count(current_idx + k) > 0) {
-					sel.set_index(sel_idx++, k);
-				}
-			}
-			chunk.Slice(sel, sel_idx);
-			current_idx += chunk.size();
-		}
-	}
-};
-
-static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<TestVectorBindData>();
-	for (idx_t i = 0; i < input.inputs.size(); i++) {
-		string name = "test_vector";
-		if (i > 0) {
-			name += to_string(i + 1);
-		}
-		auto &input_val = input.inputs[i];
-		names.emplace_back(name);
-		return_types.push_back(input_val.type());
-		result->types.push_back(input_val.type());
-	}
-	for (auto &entry : input.named_parameters) {
-		if (entry.first == "all_flat") {
-			result->all_flat = BooleanValue::Get(entry.second);
-		} else {
-			throw InternalException("Unrecognized named parameter for test_vector_types");
-		}
-	}
-	return std::move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<TestVectorBindData>();
-
-	auto result = make_uniq<TestVectorTypesData>();
-
-	auto test_types = TestAllTypesFun::GetTestTypes();
-
-	map<LogicalTypeId, TestType> test_type_map;
-	for (auto &test_type : test_types) {
-		test_type_map.insert(make_pair(test_type.type.id(), std::move(test_type)));
-	}
-
-	TestVectorInfo info(bind_data.types, test_type_map, result->entries);
-	TestVectorFlat::Generate(info);
-	TestVectorConstant::Generate(info);
-	TestVectorDictionary::Generate(info);
-	TestVectorSequence::Generate(info);
-	for (auto &entry : result->entries) {
-		entry->Verify();
-	}
-	if (bind_data.all_flat) {
-		for (auto &entry : result->entries) {
-			entry->Flatten();
-			entry->Verify();
-		}
-	}
-	return std::move(result);
-}
-
-void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<TestVectorTypesData>();
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	output.Reference(*data.entries[data.offset]);
-	data.offset++;
-}
-
-void TestVectorTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction test_vector_types("test_vector_types", {LogicalType::ANY}, TestVectorTypesFunction,
-	                                TestVectorTypesBind, TestVectorTypesInit);
-	test_vector_types.varargs = LogicalType::ANY;
-	test_vector_types.named_parameters["all_flat"] = LogicalType::BOOLEAN;
-
-	set.AddFunction(std::move(test_vector_types));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/system_functions.cpp b/src/duckdb/src/function/table/system_functions.cpp
deleted file mode 100644
index 7560221c5..000000000
--- a/src/duckdb/src/function/table/system_functions.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterSQLiteFunctions() {
-	PragmaVersion::RegisterFunction(*this);
-	PragmaPlatform::RegisterFunction(*this);
-	PragmaCollations::RegisterFunction(*this);
-	PragmaTableInfo::RegisterFunction(*this);
-	PragmaStorageInfo::RegisterFunction(*this);
-	PragmaMetadataInfo::RegisterFunction(*this);
-	PragmaDatabaseSize::RegisterFunction(*this);
-	PragmaUserAgent::RegisterFunction(*this);
-
-	DuckDBColumnsFun::RegisterFunction(*this);
-	DuckDBConstraintsFun::RegisterFunction(*this);
-	DuckDBDatabasesFun::RegisterFunction(*this);
-	DuckDBFunctionsFun::RegisterFunction(*this);
-	DuckDBKeywordsFun::RegisterFunction(*this);
-	DuckDBIndexesFun::RegisterFunction(*this);
-	DuckDBSchemasFun::RegisterFunction(*this);
-	DuckDBDependenciesFun::RegisterFunction(*this);
-	DuckDBExtensionsFun::RegisterFunction(*this);
-	DuckDBMemoryFun::RegisterFunction(*this);
-	DuckDBOptimizersFun::RegisterFunction(*this);
-	DuckDBSecretsFun::RegisterFunction(*this);
-	DuckDBWhichSecretFun::RegisterFunction(*this);
-	DuckDBSequencesFun::RegisterFunction(*this);
-	DuckDBSettingsFun::RegisterFunction(*this);
-	DuckDBTablesFun::RegisterFunction(*this);
-	DuckDBTableSample::RegisterFunction(*this);
-	DuckDBTemporaryFilesFun::RegisterFunction(*this);
-	DuckDBTypesFun::RegisterFunction(*this);
-	DuckDBVariablesFun::RegisterFunction(*this);
-	DuckDBViewsFun::RegisterFunction(*this);
-	TestAllTypesFun::RegisterFunction(*this);
-	TestVectorTypesFun::RegisterFunction(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/table_scan.cpp b/src/duckdb/src/function/table/table_scan.cpp
deleted file mode 100644
index b36abbb9b..000000000
--- a/src/duckdb/src/function/table/table_scan.cpp
+++ /dev/null
@@ -1,645 +0,0 @@
-#include "duckdb/function/table/table_scan.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/transaction/local_storage.hpp"
-#include "duckdb/storage/storage_index.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/planner/filter/in_filter.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-
-namespace duckdb {
-
-struct TableScanLocalState : public LocalTableFunctionState {
-	//! The current position in the scan.
-	TableScanState scan_state;
-	//! The DataChunk containing all read columns.
-	//! This includes filter columns, which are immediately removed.
-	DataChunk all_columns;
-};
-
-struct IndexScanLocalState : public LocalTableFunctionState {
-	//! The batch index, which determines the offset in the row ID vector.
-	idx_t batch_index;
-	//! The DataChunk containing all read columns.
-	//! This includes filter columns, which are immediately removed.
-	DataChunk all_columns;
-};
-
-static StorageIndex TransformStorageIndex(const ColumnIndex &column_id) {
-	vector<StorageIndex> result;
-	for (auto &child_id : column_id.GetChildIndexes()) {
-		result.push_back(TransformStorageIndex(child_id));
-	}
-	return StorageIndex(column_id.GetPrimaryIndex(), std::move(result));
-}
-
-static StorageIndex GetStorageIndex(TableCatalogEntry &table, const ColumnIndex &column_id) {
-	if (column_id.IsRowIdColumn()) {
-		return StorageIndex();
-	}
-
-	// The index of the base ColumnIndex is equal to the physical column index in the table
-	// for any child indices because the indices are already the physical indices.
-	// Only the top-level can have generated columns.
-	auto &col = table.GetColumn(column_id.ToLogical());
-	auto result = TransformStorageIndex(column_id);
-	result.SetIndex(col.StorageOid());
-	return result;
-}
-
-class TableScanGlobalState : public GlobalTableFunctionState {
-public:
-	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
-		D_ASSERT(bind_data_p);
-		auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-		max_threads = bind_data.table.GetStorage().MaxThreads(context);
-	}
-
-	//! The maximum number of threads for this table scan.
-	idx_t max_threads;
-	//! The projected columns of this table scan.
-	vector<idx_t> projection_ids;
-	//! The types of all scanned columns.
-	vector<LogicalType> scanned_types;
-
-public:
-	virtual unique_ptr<LocalTableFunctionState> InitLocalState(ExecutionContext &context,
-	                                                           TableFunctionInitInput &input) = 0;
-	virtual void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) = 0;
-	virtual double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const = 0;
-	virtual OperatorPartitionData TableScanGetPartitionData(ClientContext &context,
-	                                                        TableFunctionGetPartitionInput &input) = 0;
-
-	idx_t MaxThreads() const override {
-		return max_threads;
-	}
-	bool CanRemoveFilterColumns() const {
-		return !projection_ids.empty();
-	}
-};
-
-class DuckIndexScanState : public TableScanGlobalState {
-public:
-	DuckIndexScanState(ClientContext &context, const FunctionData *bind_data_p)
-	    : TableScanGlobalState(context, bind_data_p), next_batch_index(0), finished(false) {
-	}
-
-	//! The batch index of the next Sink.
-	//! Also determines the offset of the next chunk. I.e., offset = next_batch_index * STANDARD_VECTOR_SIZE.
-	idx_t next_batch_index;
-	//! The total scanned row IDs.
-	unsafe_vector<row_t> row_ids;
-	//! The column IDs of the to-be-scanned columns.
-	vector<StorageIndex> column_ids;
-	//! True, if no more row IDs must be scanned.
-	bool finished;
-	//! Synchronize changes to the global index scan state.
-	mutex index_scan_lock;
-
-	ColumnFetchState fetch_state;
-	TableScanState table_scan_state;
-
-public:
-	unique_ptr<LocalTableFunctionState> InitLocalState(ExecutionContext &context,
-	                                                   TableFunctionInitInput &input) override {
-		auto l_state = make_uniq<IndexScanLocalState>();
-		if (input.CanRemoveFilterColumns()) {
-			l_state->all_columns.Initialize(context.client, scanned_types);
-		}
-		return std::move(l_state);
-	}
-
-	void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override {
-		auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
-		auto &tx = DuckTransaction::Get(context, bind_data.table.catalog);
-		auto &storage = bind_data.table.GetStorage();
-		auto &l_state = data_p.local_state->Cast<IndexScanLocalState>();
-
-		auto row_id_count = row_ids.size();
-		idx_t scan_count = 0;
-		idx_t offset = 0;
-
-		{
-			// Synchronize changes to the shared global state.
-			lock_guard<mutex> l(index_scan_lock);
-			if (!finished) {
-				l_state.batch_index = next_batch_index;
-				next_batch_index++;
-
-				offset = l_state.batch_index * STANDARD_VECTOR_SIZE;
-				auto remaining = row_id_count - offset;
-				scan_count = remaining < STANDARD_VECTOR_SIZE ? remaining : STANDARD_VECTOR_SIZE;
-				finished = remaining < STANDARD_VECTOR_SIZE ? true : false;
-			}
-		}
-
-		if (scan_count != 0) {
-			auto row_id_data = (data_ptr_t)&row_ids[0 + offset]; // NOLINT - this is not pretty
-			Vector local_vector(LogicalType::ROW_TYPE, row_id_data);
-
-			if (CanRemoveFilterColumns()) {
-				l_state.all_columns.Reset();
-				storage.Fetch(tx, l_state.all_columns, column_ids, local_vector, scan_count, fetch_state);
-				output.ReferenceColumns(l_state.all_columns, projection_ids);
-			} else {
-				storage.Fetch(tx, output, column_ids, local_vector, scan_count, fetch_state);
-			}
-		}
-
-		if (output.size() == 0) {
-			auto &local_storage = LocalStorage::Get(tx);
-			if (CanRemoveFilterColumns()) {
-				l_state.all_columns.Reset();
-				local_storage.Scan(table_scan_state.local_state, column_ids, l_state.all_columns);
-				output.ReferenceColumns(l_state.all_columns, projection_ids);
-			} else {
-				local_storage.Scan(table_scan_state.local_state, column_ids, output);
-			}
-		}
-	}
-
-	double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override {
-		auto total_rows = row_ids.size();
-		if (total_rows == 0) {
-			return 100;
-		}
-
-		auto scanned_rows = next_batch_index * STANDARD_VECTOR_SIZE;
-		auto percentage = 100 * (static_cast<double>(scanned_rows) / static_cast<double>(total_rows));
-		return percentage > 100 ? 100 : percentage;
-	}
-
-	OperatorPartitionData TableScanGetPartitionData(ClientContext &context,
-	                                                TableFunctionGetPartitionInput &input) override {
-		auto &l_state = input.local_state->Cast<IndexScanLocalState>();
-		return OperatorPartitionData(l_state.batch_index);
-	}
-};
-
-class DuckTableScanState : public TableScanGlobalState {
-public:
-	DuckTableScanState(ClientContext &context, const FunctionData *bind_data_p)
-	    : TableScanGlobalState(context, bind_data_p) {
-	}
-
-	ParallelTableScanState state;
-
-public:
-	unique_ptr<LocalTableFunctionState> InitLocalState(ExecutionContext &context,
-	                                                   TableFunctionInitInput &input) override {
-		auto &bind_data = input.bind_data->Cast<TableScanBindData>();
-		auto l_state = make_uniq<TableScanLocalState>();
-
-		vector<StorageIndex> storage_ids;
-		for (auto &col : input.column_indexes) {
-			storage_ids.push_back(GetStorageIndex(bind_data.table, col));
-		}
-
-		l_state->scan_state.Initialize(std::move(storage_ids), input.filters.get(), input.sample_options.get());
-
-		auto &storage = bind_data.table.GetStorage();
-		storage.NextParallelScan(context.client, state, l_state->scan_state);
-		if (input.CanRemoveFilterColumns()) {
-			l_state->all_columns.Initialize(context.client, scanned_types);
-		}
-
-		l_state->scan_state.options.force_fetch_row = ClientConfig::GetConfig(context.client).force_fetch_row;
-		return std::move(l_state);
-	}
-
-	void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override {
-		auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
-		auto &tx = DuckTransaction::Get(context, bind_data.table.catalog);
-		auto &storage = bind_data.table.GetStorage();
-
-		auto &l_state = data_p.local_state->Cast<TableScanLocalState>();
-		l_state.scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row;
-
-		do {
-			if (bind_data.is_create_index) {
-				storage.CreateIndexScan(l_state.scan_state, output,
-				                        TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED);
-			} else if (CanRemoveFilterColumns()) {
-				l_state.all_columns.Reset();
-				storage.Scan(tx, l_state.all_columns, l_state.scan_state);
-				output.ReferenceColumns(l_state.all_columns, projection_ids);
-			} else {
-				storage.Scan(tx, output, l_state.scan_state);
-			}
-			if (output.size() > 0) {
-				return;
-			}
-
-			auto next = storage.NextParallelScan(context, state, l_state.scan_state);
-			if (!next) {
-				return;
-			}
-		} while (true);
-	}
-
-	double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override {
-		auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-		auto &storage = bind_data.table.GetStorage();
-		auto total_rows = storage.GetTotalRows();
-
-		// The table is empty or smaller than the standard vector size.
-		if (total_rows == 0) {
-			return 100;
-		}
-
-		idx_t scanned_rows = state.scan_state.processed_rows;
-		scanned_rows += state.local_state.processed_rows;
-		auto percentage = 100 * (static_cast<double>(scanned_rows) / static_cast<double>(total_rows));
-		if (percentage > 100) {
-			// If the last chunk has fewer elements than STANDARD_VECTOR_SIZE, and if our percentage is over 100,
-			// then we finished this table.
-			return 100;
-		}
-		return percentage;
-	}
-
-	OperatorPartitionData TableScanGetPartitionData(ClientContext &context,
-	                                                TableFunctionGetPartitionInput &input) override {
-		auto &l_state = input.local_state->Cast<TableScanLocalState>();
-		if (l_state.scan_state.table_state.row_group) {
-			return OperatorPartitionData(l_state.scan_state.table_state.batch_index);
-		}
-		if (l_state.scan_state.local_state.row_group) {
-			return OperatorPartitionData(l_state.scan_state.table_state.batch_index +
-			                             l_state.scan_state.local_state.batch_index);
-		}
-		return OperatorPartitionData(0);
-	}
-};
-
-static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input,
-                                                              GlobalTableFunctionState *g_state) {
-	auto &cast_g_state = g_state->Cast<TableScanGlobalState>();
-	return cast_g_state.InitLocalState(context, input);
-}
-
-unique_ptr<GlobalTableFunctionState> DuckTableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input,
-                                                             DataTable &storage, const TableScanBindData &bind_data) {
-	auto g_state = make_uniq<DuckTableScanState>(context, input.bind_data.get());
-	storage.InitializeParallelScan(context, g_state->state);
-	if (!input.CanRemoveFilterColumns()) {
-		return std::move(g_state);
-	}
-
-	g_state->projection_ids = input.projection_ids;
-	const auto &columns = bind_data.table.GetColumns();
-	for (const auto &col_idx : input.column_indexes) {
-		if (col_idx.IsRowIdColumn()) {
-			g_state->scanned_types.emplace_back(LogicalType::ROW_TYPE);
-		} else {
-			g_state->scanned_types.push_back(columns.GetColumn(col_idx.ToLogical()).Type());
-		}
-	}
-	return std::move(g_state);
-}
-
-unique_ptr<GlobalTableFunctionState> DuckIndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input,
-                                                             DataTable &storage, const TableScanBindData &bind_data,
-                                                             unsafe_vector<row_t> &row_ids) {
-	auto g_state = make_uniq<DuckIndexScanState>(context, input.bind_data.get());
-	if (!row_ids.empty()) {
-		std::sort(row_ids.begin(), row_ids.end());
-		g_state->row_ids = std::move(row_ids);
-	}
-	g_state->finished = g_state->row_ids.empty() ? true : false;
-
-	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
-	g_state->table_scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row;
-
-	if (input.CanRemoveFilterColumns()) {
-		g_state->projection_ids = input.projection_ids;
-	}
-
-	const auto &columns = bind_data.table.GetColumns();
-	for (const auto &col_idx : input.column_indexes) {
-		g_state->column_ids.push_back(GetStorageIndex(bind_data.table, col_idx));
-		if (col_idx.IsRowIdColumn()) {
-			g_state->scanned_types.emplace_back(LogicalType::ROW_TYPE);
-			continue;
-		}
-		g_state->scanned_types.push_back(columns.GetColumn(col_idx.ToLogical()).Type());
-	}
-
-	g_state->table_scan_state.Initialize(g_state->column_ids, input.filters.get());
-	local_storage.InitializeScan(storage, g_state->table_scan_state.local_state, input.filters);
-
-	// Const-cast to indicate an index scan.
-	// We need this information in the bind data so that we can access it during ANALYZE.
-	auto &no_const_bind_data = bind_data.CastNoConst<TableScanBindData>();
-	no_const_bind_data.is_index_scan = true;
-
-	return std::move(g_state);
-}
-
-void ExtractInFilter(unique_ptr<TableFilter> &filter, BoundColumnRefExpression &bound_ref,
-                     unique_ptr<vector<unique_ptr<Expression>>> &filter_expressions) {
-	// Special-handling of IN filters.
-	// They are part of a CONJUNCTION_AND.
-	if (filter->filter_type != TableFilterType::CONJUNCTION_AND) {
-		return;
-	}
-
-	auto &and_filter = filter->Cast<ConjunctionAndFilter>();
-	auto &children = and_filter.child_filters;
-	if (children.empty()) {
-		return;
-	}
-	if (children[0]->filter_type != TableFilterType::OPTIONAL_FILTER) {
-		return;
-	}
-
-	auto &optional_filter = children[0]->Cast<OptionalFilter>();
-	auto &child = optional_filter.child_filter;
-	if (child->filter_type != TableFilterType::IN_FILTER) {
-		return;
-	}
-
-	auto &in_filter = child->Cast<InFilter>();
-	if (!in_filter.origin_is_hash_join) {
-		return;
-	}
-
-	// They are all on the same column, so we can split them.
-	for (const auto &value : in_filter.values) {
-		auto bound_constant = make_uniq<BoundConstantExpression>(value);
-		auto filter_expr = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(),
-		                                                        std::move(bound_constant));
-		filter_expressions->push_back(std::move(filter_expr));
-	}
-}
-
-unique_ptr<vector<unique_ptr<Expression>>> ExtractFilters(const ColumnDefinition &col, unique_ptr<TableFilter> &filter,
-                                                          idx_t storage_idx) {
-	ColumnBinding binding(0, storage_idx);
-	auto bound_ref = make_uniq<BoundColumnRefExpression>(col.Name(), col.Type(), binding);
-
-	auto filter_expressions = make_uniq<vector<unique_ptr<Expression>>>();
-	ExtractInFilter(filter, *bound_ref, filter_expressions);
-
-	if (filter_expressions->empty()) {
-		auto filter_expr = filter->ToExpression(*bound_ref);
-		filter_expressions->push_back(std::move(filter_expr));
-	}
-	return filter_expressions;
-}
-
-bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInput &input, TableFilterSet &filter_set,
-                  idx_t max_count, unsafe_vector<row_t> &row_ids) {
-	// FIXME: No support for index scans on compound ARTs.
-	// See note above on multi-filter support.
-	if (art.unbound_expressions.size() > 1) {
-		return false;
-	}
-
-	auto index_expr = art.unbound_expressions[0]->Copy();
-	auto &indexed_columns = art.GetColumnIds();
-
-	// NOTE: We do not push down multi-column filters, e.g., 42 = a + b.
-	if (indexed_columns.size() != 1) {
-		return false;
-	}
-
-	// Get ART column.
-	auto &col = column_list.GetColumn(LogicalIndex(indexed_columns[0]));
-
-	// The indexes of the filters match input.column_indexes, which are: i -> column_index.
-	// Try to find a filter on the ART column.
-	optional_idx storage_index;
-	for (idx_t i = 0; i < input.column_indexes.size(); i++) {
-		if (input.column_indexes[i].ToLogical() == col.Logical()) {
-			storage_index = i;
-			break;
-		}
-	}
-
-	// No filter matches the ART column.
-	if (!storage_index.IsValid()) {
-		return false;
-	}
-
-	// Try to find a matching filter for the column.
-	auto filter = filter_set.filters.find(storage_index.GetIndex());
-	if (filter == filter_set.filters.end()) {
-		return false;
-	}
-
-	auto filter_expressions = ExtractFilters(col, filter->second, storage_index.GetIndex());
-	for (const auto &filter_expr : *filter_expressions) {
-		auto scan_state = art.TryInitializeScan(*index_expr, *filter_expr);
-		if (!scan_state) {
-			return false;
-		}
-
-		// Check if we can use an index scan, and already retrieve the matching row ids.
-		if (!art.Scan(*scan_state, max_count, row_ids)) {
-			row_ids.clear();
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	D_ASSERT(input.bind_data);
-
-	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
-	auto &table = bind_data.table;
-	auto &storage = table.GetStorage();
-
-	// Can't index scan without filters.
-	if (!input.filters) {
-		return DuckTableScanInitGlobal(context, input, storage, bind_data);
-	}
-	auto &filter_set = *input.filters;
-
-	// FIXME: We currently only support scanning one ART with one filter.
-	// If multiple filters exist, i.e., a = 11 AND b = 24, we need to
-	// 1.	1.1. Find + scan one ART for a = 11.
-	//		1.2. Find + scan one ART for b = 24.
-	//		1.3. Return the intersecting row IDs.
-	// 2. (Reorder and) scan a single ART with a compound key of (a, b).
-	if (filter_set.filters.size() != 1) {
-		return DuckTableScanInitGlobal(context, input, storage, bind_data);
-	}
-
-	// The checkpoint lock ensures that we do not checkpoint while scanning this table.
-	auto checkpoint_lock = storage.GetSharedCheckpointLock();
-	auto &info = storage.GetDataTableInfo();
-	auto &indexes = info->GetIndexes();
-	if (indexes.Empty()) {
-		return DuckTableScanInitGlobal(context, input, storage, bind_data);
-	}
-
-	auto &db_config = DBConfig::GetConfig(context);
-	auto scan_percentage = db_config.GetSetting<IndexScanPercentageSetting>(context);
-	auto scan_max_count = db_config.GetSetting<IndexScanMaxCountSetting>(context);
-
-	auto total_rows = storage.GetTotalRows();
-	auto total_rows_from_percentage = LossyNumericCast<idx_t>(double(total_rows) * scan_percentage);
-	auto max_count = MaxValue(scan_max_count, total_rows_from_percentage);
-
-	auto &column_list = table.GetColumns();
-	bool index_scan = false;
-	unsafe_vector<row_t> row_ids;
-
-	info->GetIndexes().BindAndScan<ART>(context, *info, [&](ART &art) {
-		index_scan = TryScanIndex(art, column_list, input, filter_set, max_count, row_ids);
-		return index_scan;
-	});
-
-	if (!index_scan) {
-		return DuckTableScanInitGlobal(context, input, storage, bind_data);
-	}
-	return DuckIndexScanInitGlobal(context, input, storage, bind_data, row_ids);
-}
-
-static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p,
-                                                      column_t column_id) {
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
-
-	// Don't emit statistics for tables with outstanding transaction-local data.
-	if (local_storage.Find(bind_data.table.GetStorage())) {
-		return nullptr;
-	}
-	return bind_data.table.GetStatistics(context, column_id);
-}
-
-static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &g_state = data_p.global_state->Cast<TableScanGlobalState>();
-	g_state.TableScanFunc(context, data_p, output);
-}
-
-double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p,
-                         const GlobalTableFunctionState *g_state_p) {
-	auto &g_state = g_state_p->Cast<TableScanGlobalState>();
-	return g_state.TableScanProgress(context, bind_data_p);
-}
-
-OperatorPartitionData TableScanGetPartitionData(ClientContext &context, TableFunctionGetPartitionInput &input) {
-	if (input.partition_info.RequiresPartitionColumns()) {
-		throw InternalException("TableScan::GetPartitionData: partition columns not supported");
-	}
-
-	auto &g_state = input.global_state->Cast<TableScanGlobalState>();
-	return g_state.TableScanGetPartitionData(context, input);
-}
-
-vector<PartitionStatistics> TableScanGetPartitionStats(ClientContext &context, GetPartitionStatsInput &input) {
-	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
-	vector<PartitionStatistics> result;
-	auto &storage = bind_data.table.GetStorage();
-	return storage.GetPartitionStats(context);
-}
-
-BindInfo TableScanGetBindInfo(const optional_ptr<FunctionData> bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	return BindInfo(bind_data.table);
-}
-
-void TableScanDependency(LogicalDependencyList &entries, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	entries.AddDependency(bind_data.table);
-}
-
-unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
-	auto &storage = bind_data.table.GetStorage();
-	idx_t table_rows = storage.GetTotalRows();
-	idx_t estimated_cardinality = table_rows + local_storage.AddedRows(bind_data.table.GetStorage());
-	return make_uniq<NodeStatistics>(table_rows, estimated_cardinality);
-}
-
-InsertionOrderPreservingMap<string> TableScanToString(TableFunctionToStringInput &input) {
-	InsertionOrderPreservingMap<string> result;
-	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
-	result["Table"] = bind_data.table.name;
-	result["Type"] = bind_data.is_index_scan ? "Index Scan" : "Sequence Scan";
-	return result;
-}
-
-static void TableScanSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                               const TableFunction &function) {
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	serializer.WriteProperty(100, "catalog", bind_data.table.schema.catalog.GetName());
-	serializer.WriteProperty(101, "schema", bind_data.table.schema.name);
-	serializer.WriteProperty(102, "table", bind_data.table.name);
-	serializer.WriteProperty(103, "is_index_scan", bind_data.is_index_scan);
-	serializer.WriteProperty(104, "is_create_index", bind_data.is_create_index);
-	serializer.WritePropertyWithDefault(105, "result_ids", unsafe_vector<row_t>());
-}
-
-static unique_ptr<FunctionData> TableScanDeserialize(Deserializer &deserializer, TableFunction &function) {
-	auto catalog = deserializer.ReadProperty<string>(100, "catalog");
-	auto schema = deserializer.ReadProperty<string>(101, "schema");
-	auto table = deserializer.ReadProperty<string>(102, "table");
-	auto &catalog_entry =
-	    Catalog::GetEntry<TableCatalogEntry>(deserializer.Get<ClientContext &>(), catalog, schema, table);
-	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
-		throw SerializationException("Cant find table for %s.%s", schema, table);
-	}
-	auto result = make_uniq<TableScanBindData>(catalog_entry.Cast<DuckTableEntry>());
-	deserializer.ReadProperty(103, "is_index_scan", result->is_index_scan);
-	deserializer.ReadProperty(104, "is_create_index", result->is_create_index);
-	deserializer.ReadDeletedProperty<unsafe_vector<row_t>>(105, "result_ids");
-	return std::move(result);
-}
-
-TableFunction TableScanFunction::GetFunction() {
-	TableFunction scan_function("seq_scan", {}, TableScanFunc);
-	scan_function.init_local = TableScanInitLocal;
-	scan_function.init_global = TableScanInitGlobal;
-	scan_function.statistics = TableScanStatistics;
-	scan_function.dependency = TableScanDependency;
-	scan_function.cardinality = TableScanCardinality;
-	scan_function.pushdown_complex_filter = nullptr;
-	scan_function.to_string = TableScanToString;
-	scan_function.table_scan_progress = TableScanProgress;
-	scan_function.get_partition_data = TableScanGetPartitionData;
-	scan_function.get_partition_stats = TableScanGetPartitionStats;
-	scan_function.get_bind_info = TableScanGetBindInfo;
-	scan_function.projection_pushdown = true;
-	scan_function.filter_pushdown = true;
-	scan_function.filter_prune = true;
-	scan_function.sampling_pushdown = true;
-	scan_function.serialize = TableScanSerialize;
-	scan_function.deserialize = TableScanDeserialize;
-	return scan_function;
-}
-
-void TableScanFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet table_scan_set("seq_scan");
-	table_scan_set.AddFunction(GetFunction());
-	set.AddFunction(std::move(table_scan_set));
-}
-
-void BuiltinFunctions::RegisterTableScanFunctions() {
-	TableScanFunction::RegisterFunction(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/unnest.cpp b/src/duckdb/src/function/table/unnest.cpp
deleted file mode 100644
index 7abdf9df0..000000000
--- a/src/duckdb/src/function/table/unnest.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-#include "duckdb/execution/operator/projection/physical_unnest.hpp"
-
-namespace duckdb {
-
-struct UnnestBindData : public FunctionData {
-	explicit UnnestBindData(LogicalType input_type_p) : input_type(std::move(input_type_p)) {
-	}
-
-	LogicalType input_type;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<UnnestBindData>(input_type);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<UnnestBindData>();
-		return input_type == other.input_type;
-	}
-};
-
-struct UnnestGlobalState : public GlobalTableFunctionState {
-	UnnestGlobalState() {
-	}
-
-	vector<unique_ptr<Expression>> select_list;
-
-	idx_t MaxThreads() const override {
-		return GlobalTableFunctionState::MAX_THREADS;
-	}
-};
-
-struct UnnestLocalState : public LocalTableFunctionState {
-	UnnestLocalState() {
-	}
-
-	unique_ptr<OperatorState> operator_state;
-};
-
-static unique_ptr<FunctionData> UnnestBind(ClientContext &context, TableFunctionBindInput &input,
-                                           vector<LogicalType> &return_types, vector<string> &names) {
-	if (input.input_table_types.size() != 1 || input.input_table_types[0].id() != LogicalTypeId::LIST) {
-		throw BinderException("UNNEST requires a single list as input");
-	}
-	return_types.push_back(ListType::GetChildType(input.input_table_types[0]));
-	names.push_back("unnest");
-	return make_uniq<UnnestBindData>(input.input_table_types[0]);
-}
-
-static unique_ptr<LocalTableFunctionState> UnnestLocalInit(ExecutionContext &context, TableFunctionInitInput &input,
-                                                           GlobalTableFunctionState *global_state) {
-	auto &gstate = global_state->Cast<UnnestGlobalState>();
-
-	auto result = make_uniq<UnnestLocalState>();
-	result->operator_state = PhysicalUnnest::GetState(context, gstate.select_list);
-	return std::move(result);
-}
-
-static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<UnnestBindData>();
-	auto result = make_uniq<UnnestGlobalState>();
-	auto ref = make_uniq<BoundReferenceExpression>(bind_data.input_type, 0U);
-	auto bound_unnest = make_uniq<BoundUnnestExpression>(ListType::GetChildType(bind_data.input_type));
-	bound_unnest->child = std::move(ref);
-	result->select_list.push_back(std::move(bound_unnest));
-	return std::move(result);
-}
-
-static OperatorResultType UnnestFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
-                                         DataChunk &output) {
-	auto &state = data_p.global_state->Cast<UnnestGlobalState>();
-	auto &lstate = data_p.local_state->Cast<UnnestLocalState>();
-	return PhysicalUnnest::ExecuteInternal(context, input, output, *lstate.operator_state, state.select_list, false);
-}
-
-void UnnestTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction unnest_function("unnest", {LogicalType::ANY}, nullptr, UnnestBind, UnnestInit, UnnestLocalInit);
-	unnest_function.in_out_function = UnnestFunction;
-	set.AddFunction(unnest_function);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp
deleted file mode 100644
index bc8341084..000000000
--- a/src/duckdb/src/function/table/version/pragma_version.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "4-dev4329"
-#endif
-#ifndef DUCKDB_MINOR_VERSION
-#define DUCKDB_MINOR_VERSION 1
-#endif
-#ifndef DUCKDB_MAJOR_VERSION
-#define DUCKDB_MAJOR_VERSION 1
-#endif
-#ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.1.4-dev4329"
-#endif
-#ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a1c7e9b115"
-#endif
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/platform.hpp"
-
-#include <cstdint>
-
-namespace duckdb {
-
-struct PragmaVersionData : public GlobalTableFunctionState {
-	PragmaVersionData() : finished(false) {
-	}
-
-	bool finished;
-};
-
-static unique_ptr<FunctionData> PragmaVersionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("library_version");
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("source_id");
-	return_types.emplace_back(LogicalType::VARCHAR);
-	return nullptr;
-}
-
-static unique_ptr<GlobalTableFunctionState> PragmaVersionInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<PragmaVersionData>();
-}
-
-static void PragmaVersionFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<PragmaVersionData>();
-	if (data.finished) {
-		// finished returning values
-		return;
-	}
-	output.SetCardinality(1);
-	output.SetValue(0, 0, DuckDB::LibraryVersion());
-	output.SetValue(1, 0, DuckDB::SourceID());
-	data.finished = true;
-}
-
-void PragmaVersion::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction pragma_version("pragma_version", {}, PragmaVersionFunction);
-	pragma_version.bind = PragmaVersionBind;
-	pragma_version.init_global = PragmaVersionInit;
-	set.AddFunction(pragma_version);
-}
-
-idx_t DuckDB::StandardVectorSize() {
-	return STANDARD_VECTOR_SIZE;
-}
-
-const char *DuckDB::SourceID() {
-	return DUCKDB_SOURCE_ID;
-}
-
-const char *DuckDB::LibraryVersion() {
-	return DUCKDB_VERSION;
-}
-
-string DuckDB::Platform() {
-	return DuckDBPlatform();
-}
-
-struct PragmaPlatformData : public GlobalTableFunctionState {
-	PragmaPlatformData() : finished(false) {
-	}
-
-	bool finished;
-};
-
-static unique_ptr<FunctionData> PragmaPlatformBind(ClientContext &context, TableFunctionBindInput &input,
-                                                   vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("platform");
-	return_types.emplace_back(LogicalType::VARCHAR);
-	return nullptr;
-}
-
-static unique_ptr<GlobalTableFunctionState> PragmaPlatformInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<PragmaPlatformData>();
-}
-
-static void PragmaPlatformFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = data_p.global_state->Cast<PragmaPlatformData>();
-	if (data.finished) {
-		// finished returning values
-		return;
-	}
-	output.SetCardinality(1);
-	output.SetValue(0, 0, DuckDB::Platform());
-	data.finished = true;
-}
-
-void PragmaPlatform::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction pragma_platform("pragma_platform", {}, PragmaPlatformFunction);
-	pragma_platform.bind = PragmaPlatformBind;
-	pragma_platform.init_global = PragmaPlatformInit;
-	set.AddFunction(pragma_platform);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table_function.cpp b/src/duckdb/src/function/table_function.cpp
deleted file mode 100644
index 6e9df8194..000000000
--- a/src/duckdb/src/function/table_function.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/function/table_function.hpp"
-
-namespace duckdb {
-
-GlobalTableFunctionState::~GlobalTableFunctionState() {
-}
-
-LocalTableFunctionState::~LocalTableFunctionState() {
-}
-
-PartitionStatistics::PartitionStatistics() : row_start(0), count(0), count_type(CountType::COUNT_APPROXIMATE) {
-}
-
-TableFunctionInfo::~TableFunctionInfo() {
-}
-
-TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
-                             table_function_bind_t bind, table_function_init_global_t init_global,
-                             table_function_init_local_t init_local)
-    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), bind_replace(nullptr),
-      init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
-      in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
-      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_partition_data(nullptr),
-      get_bind_info(nullptr), type_pushdown(nullptr), get_multi_file_reader(nullptr), supports_pushdown_type(nullptr),
-      get_partition_info(nullptr), get_partition_stats(nullptr), serialize(nullptr), deserialize(nullptr),
-      projection_pushdown(false), filter_pushdown(false), filter_prune(false), sampling_pushdown(false) {
-}
-
-TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
-                             table_function_bind_t bind, table_function_init_global_t init_global,
-                             table_function_init_local_t init_local)
-    : TableFunction(string(), arguments, function, bind, init_global, init_local) {
-}
-TableFunction::TableFunction()
-    : SimpleNamedParameterFunction("", {}), bind(nullptr), bind_replace(nullptr), init_global(nullptr),
-      init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
-      cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
-      get_partition_data(nullptr), get_bind_info(nullptr), type_pushdown(nullptr), get_multi_file_reader(nullptr),
-      supports_pushdown_type(nullptr), get_partition_info(nullptr), get_partition_stats(nullptr), serialize(nullptr),
-      deserialize(nullptr), projection_pushdown(false), filter_pushdown(false), filter_prune(false),
-      sampling_pushdown(false) {
-}
-
-bool TableFunction::Equal(const TableFunction &rhs) const {
-	// number of types
-	if (this->arguments.size() != rhs.arguments.size()) {
-		return false;
-	}
-	// argument types
-	for (idx_t i = 0; i < this->arguments.size(); ++i) {
-		if (this->arguments[i] != rhs.arguments[i]) {
-			return false;
-		}
-	}
-	// varargs
-	if (this->varargs != rhs.varargs) {
-		return false;
-	}
-
-	return true; // they are equal
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/table_macro_function.cpp b/src/duckdb/src/function/table_macro_function.cpp
deleted file mode 100644
index becb1fe6b..000000000
--- a/src/duckdb/src/function/table_macro_function.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-//! The SelectStatement of the view
-#include "duckdb/function/table_macro_function.hpp"
-
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-TableMacroFunction::TableMacroFunction(unique_ptr<QueryNode> query_node)
-    : MacroFunction(MacroType::TABLE_MACRO), query_node(std::move(query_node)) {
-}
-
-TableMacroFunction::TableMacroFunction(void) : MacroFunction(MacroType::TABLE_MACRO) {
-}
-
-unique_ptr<MacroFunction> TableMacroFunction::Copy() const {
-	auto result = make_uniq<TableMacroFunction>();
-	result->query_node = query_node->Copy();
-	this->CopyProperties(*result);
-	return std::move(result);
-}
-
-string TableMacroFunction::ToSQL() const {
-	return MacroFunction::ToSQL() + StringUtil::Format("TABLE (%s)", query_node->ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/udf_function.cpp b/src/duckdb/src/function/udf_function.cpp
deleted file mode 100644
index 3c03dbbe3..000000000
--- a/src/duckdb/src/function/udf_function.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/function/udf_function.hpp"
-
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-void UDFWrapper::RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
-                                  scalar_function_t udf_function, ClientContext &context, LogicalType varargs) {
-
-	ScalarFunction scalar_function(std::move(name), std::move(args), std::move(ret_type), std::move(udf_function));
-	scalar_function.varargs = std::move(varargs);
-	scalar_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	CreateScalarFunctionInfo info(scalar_function);
-	info.schema = DEFAULT_SCHEMA;
-	context.RegisterFunction(info);
-}
-
-void UDFWrapper::RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context, LogicalType varargs) {
-	aggr_function.varargs = std::move(varargs);
-	CreateAggregateFunctionInfo info(std::move(aggr_function));
-	context.RegisterFunction(info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_aggregate_function.cpp b/src/duckdb/src/function/window/window_aggregate_function.cpp
deleted file mode 100644
index f08fc5dbc..000000000
--- a/src/duckdb/src/function/window/window_aggregate_function.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "duckdb/function/window/window_aggregate_function.hpp"
-
-#include "duckdb/function/window/window_constant_aggregator.hpp"
-#include "duckdb/function/window/window_custom_aggregator.hpp"
-#include "duckdb/function/window/window_distinct_aggregator.hpp"
-#include "duckdb/function/window/window_naive_aggregator.hpp"
-#include "duckdb/function/window/window_segment_tree.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowAggregateExecutor
-//===--------------------------------------------------------------------===//
-class WindowAggregateExecutorGlobalState : public WindowExecutorGlobalState {
-public:
-	WindowAggregateExecutorGlobalState(const WindowAggregateExecutor &executor, const idx_t payload_count,
-	                                   const ValidityMask &partition_mask, const ValidityMask &order_mask);
-
-	// aggregate global state
-	unique_ptr<WindowAggregatorState> gsink;
-
-	// the filter reference expression.
-	const Expression *filter_ref;
-};
-
-static BoundWindowExpression &SimplifyWindowedAggregate(BoundWindowExpression &wexpr, ClientContext &context) {
-	// Remove redundant/irrelevant modifiers (they can be serious performance cliffs)
-	if (wexpr.aggregate && ClientConfig::GetConfig(context).enable_optimizer) {
-		const auto &aggr = wexpr.aggregate;
-		auto &arg_orders = wexpr.arg_orders;
-		if (aggr->distinct_dependent != AggregateDistinctDependent::DISTINCT_DEPENDENT) {
-			wexpr.distinct = false;
-		}
-		if (aggr->order_dependent != AggregateOrderDependent::ORDER_DEPENDENT) {
-			arg_orders.clear();
-		} else {
-			//	If the argument order is prefix of the partition ordering,
-			//	then we can just use the partition ordering.
-			if (BoundWindowExpression::GetSharedOrders(wexpr.orders, arg_orders) == arg_orders.size()) {
-				arg_orders.clear();
-			}
-		}
-	}
-
-	return wexpr;
-}
-
-WindowAggregateExecutor::WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                 WindowSharedExpressions &shared, WindowAggregationMode mode)
-    : WindowExecutor(SimplifyWindowedAggregate(wexpr, context), context, shared), mode(mode) {
-
-	// Force naive for SEPARATE mode or for (currently!) unsupported functionality
-	if (!ClientConfig::GetConfig(context).enable_optimizer || mode == WindowAggregationMode::SEPARATE) {
-		aggregator = make_uniq<WindowNaiveAggregator>(*this, shared);
-	} else if (WindowDistinctAggregator::CanAggregate(wexpr)) {
-		// build a merge sort tree
-		// see https://dl.acm.org/doi/pdf/10.1145/3514221.3526184
-		aggregator = make_uniq<WindowDistinctAggregator>(wexpr, shared, context);
-	} else if (WindowConstantAggregator::CanAggregate(wexpr)) {
-		aggregator = make_uniq<WindowConstantAggregator>(wexpr, shared, context);
-	} else if (WindowCustomAggregator::CanAggregate(wexpr, mode)) {
-		aggregator = make_uniq<WindowCustomAggregator>(wexpr, shared);
-	} else if (WindowSegmentTree::CanAggregate(wexpr)) {
-		// build a segment tree for frame-adhering aggregates
-		// see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf
-		aggregator = make_uniq<WindowSegmentTree>(wexpr, shared);
-	} else {
-		// No accelerator can handle this combination, so fall back to naïve.
-		aggregator = make_uniq<WindowNaiveAggregator>(*this, shared);
-	}
-
-	// Compute the FILTER with the other eval columns.
-	// Anyone who needs it can then convert it to the form they need.
-	if (wexpr.filter_expr) {
-		const auto filter_idx = shared.RegisterSink(wexpr.filter_expr);
-		filter_ref = make_uniq<BoundReferenceExpression>(wexpr.filter_expr->return_type, filter_idx);
-	}
-}
-
-WindowAggregateExecutorGlobalState::WindowAggregateExecutorGlobalState(const WindowAggregateExecutor &executor,
-                                                                       const idx_t group_count,
-                                                                       const ValidityMask &partition_mask,
-                                                                       const ValidityMask &order_mask)
-    : WindowExecutorGlobalState(executor, group_count, partition_mask, order_mask),
-      filter_ref(executor.filter_ref.get()) {
-	gsink = executor.aggregator->GetGlobalState(executor.context, group_count, partition_mask);
-}
-
-unique_ptr<WindowExecutorGlobalState> WindowAggregateExecutor::GetGlobalState(const idx_t payload_count,
-                                                                              const ValidityMask &partition_mask,
-                                                                              const ValidityMask &order_mask) const {
-	return make_uniq<WindowAggregateExecutorGlobalState>(*this, payload_count, partition_mask, order_mask);
-}
-
-class WindowAggregateExecutorLocalState : public WindowExecutorBoundsState {
-public:
-	WindowAggregateExecutorLocalState(const WindowExecutorGlobalState &gstate, const WindowAggregator &aggregator)
-	    : WindowExecutorBoundsState(gstate), filter_executor(gstate.executor.context) {
-
-		auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-		aggregator_state = aggregator.GetLocalState(*gastate.gsink);
-
-		// evaluate the FILTER clause and stuff it into a large mask for compactness and reuse
-		auto filter_ref = gastate.filter_ref;
-		if (filter_ref) {
-			filter_executor.AddExpression(*filter_ref);
-			filter_sel.Initialize(STANDARD_VECTOR_SIZE);
-		}
-	}
-
-public:
-	// state of aggregator
-	unique_ptr<WindowAggregatorState> aggregator_state;
-	//! Executor for any filter clause
-	ExpressionExecutor filter_executor;
-	//! Result of filtering
-	SelectionVector filter_sel;
-};
-
-unique_ptr<WindowExecutorLocalState>
-WindowAggregateExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	return make_uniq<WindowAggregateExecutorLocalState>(gstate, *aggregator);
-}
-
-void WindowAggregateExecutor::Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx,
-                                   WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate) const {
-	auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregateExecutorLocalState>();
-	auto &filter_sel = lastate.filter_sel;
-	auto &filter_executor = lastate.filter_executor;
-
-	idx_t filtered = 0;
-	SelectionVector *filtering = nullptr;
-	if (gastate.filter_ref) {
-		filtering = &filter_sel;
-		filtered = filter_executor.SelectExpression(sink_chunk, filter_sel);
-	}
-
-	D_ASSERT(aggregator);
-	auto &gestate = *gastate.gsink;
-	auto &lestate = *lastate.aggregator_state;
-	aggregator->Sink(gestate, lestate, sink_chunk, coll_chunk, input_idx, filtering, filtered);
-
-	WindowExecutor::Sink(sink_chunk, coll_chunk, input_idx, gstate, lstate);
-}
-
-static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta, BaseStatistics *base, bool is_start) {
-	// Avoid overflow by clamping to the frame bounds
-	auto base_stats = delta;
-
-	switch (boundary) {
-	case WindowBoundary::UNBOUNDED_PRECEDING:
-		if (is_start) {
-			delta.end = 0;
-			return;
-		}
-		break;
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		if (!is_start) {
-			delta.begin = 0;
-			return;
-		}
-		break;
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		delta.begin = delta.end = 0;
-		return;
-	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) {
-			//	Preceding so negative offset from current row
-			base_stats.begin = NumericStats::GetMin<int64_t>(*base);
-			base_stats.end = NumericStats::GetMax<int64_t>(*base);
-			if (delta.begin < base_stats.end && base_stats.end < delta.end) {
-				delta.begin = -base_stats.end;
-			}
-			if (delta.begin < base_stats.begin && base_stats.begin < delta.end) {
-				delta.end = -base_stats.begin + 1;
-			}
-		}
-		return;
-	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) {
-			base_stats.begin = NumericStats::GetMin<int64_t>(*base);
-			base_stats.end = NumericStats::GetMax<int64_t>(*base);
-			if (base_stats.end < delta.end) {
-				delta.end = base_stats.end + 1;
-			}
-		}
-		return;
-
-	case WindowBoundary::CURRENT_ROW_RANGE:
-	case WindowBoundary::EXPR_PRECEDING_RANGE:
-	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		return;
-	default:
-		break;
-	}
-
-	if (is_start) {
-		throw InternalException("Unsupported window start boundary");
-	} else {
-		throw InternalException("Unsupported window end boundary");
-	}
-}
-
-void WindowAggregateExecutor::Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                       CollectionPtr collection) const {
-	WindowExecutor::Finalize(gstate, lstate, collection);
-
-	auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-	auto &gsink = gastate.gsink;
-	D_ASSERT(aggregator);
-
-	//	Estimate the frame statistics
-	//	Default to the entire partition if we don't know anything
-	FrameStats stats;
-	const auto count = NumericCast<int64_t>(gastate.payload_count);
-
-	//	First entry is the frame start
-	stats[0] = FrameDelta(-count, count);
-	auto base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[0].get();
-	ApplyWindowStats(wexpr.start, stats[0], base, true);
-
-	//	Second entry is the frame end
-	stats[1] = FrameDelta(-count, count);
-	base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[1].get();
-	ApplyWindowStats(wexpr.end, stats[1], base, false);
-
-	auto &lastate = lstate.Cast<WindowAggregateExecutorLocalState>();
-	aggregator->Finalize(*gsink, *lastate.aggregator_state, collection, stats);
-}
-
-void WindowAggregateExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                               DataChunk &eval_chunk, Vector &result, idx_t count,
-                                               idx_t row_idx) const {
-	auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregateExecutorLocalState>();
-	auto &gsink = gastate.gsink;
-	D_ASSERT(aggregator);
-
-	auto &agg_state = *lastate.aggregator_state;
-
-	aggregator->Evaluate(*gsink, agg_state, lastate.bounds, result, count, row_idx);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_aggregate_states.cpp b/src/duckdb/src/function/window/window_aggregate_states.cpp
deleted file mode 100644
index 2a673ec54..000000000
--- a/src/duckdb/src/function/window/window_aggregate_states.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/function/window/window_aggregate_states.hpp"
-
-namespace duckdb {
-
-WindowAggregateStates::WindowAggregateStates(const AggregateObject &aggr)
-    : aggr(aggr), state_size(aggr.function.state_size(aggr.function)), allocator(Allocator::DefaultAllocator()) {
-}
-
-void WindowAggregateStates::Initialize(idx_t count) {
-	states.resize(count * state_size);
-	auto state_ptr = states.data();
-
-	statef = make_uniq<Vector>(LogicalType::POINTER, count);
-	auto state_f_data = FlatVector::GetData<data_ptr_t>(*statef);
-
-	for (idx_t i = 0; i < count; ++i, state_ptr += state_size) {
-		state_f_data[i] = state_ptr;
-		aggr.function.initialize(aggr.function, state_ptr);
-	}
-
-	// Prevent conversion of results to constants
-	statef->SetVectorType(VectorType::FLAT_VECTOR);
-}
-
-void WindowAggregateStates::Combine(WindowAggregateStates &target, AggregateCombineType combine_type) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator, AggregateCombineType::ALLOW_DESTRUCTIVE);
-	aggr.function.combine(*statef, *target.statef, aggr_input_data, GetCount());
-}
-
-void WindowAggregateStates::Finalize(Vector &result) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	aggr.function.finalize(*statef, aggr_input_data, result, GetCount(), 0);
-}
-
-void WindowAggregateStates::Destroy() {
-	if (states.empty()) {
-		return;
-	}
-
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	if (aggr.function.destructor) {
-		aggr.function.destructor(*statef, aggr_input_data, GetCount());
-	}
-
-	states.clear();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_aggregator.cpp b/src/duckdb/src/function/window/window_aggregator.cpp
deleted file mode 100644
index 197b89e38..000000000
--- a/src/duckdb/src/function/window/window_aggregator.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "duckdb/function/window/window_aggregator.hpp"
-
-#include "duckdb/function/window/window_collection.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowAggregator
-//===--------------------------------------------------------------------===//
-WindowAggregatorState::WindowAggregatorState() : allocator(Allocator::DefaultAllocator()) {
-}
-
-WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr)
-    : wexpr(wexpr), aggr(wexpr), result_type(wexpr.return_type), state_size(aggr.function.state_size(aggr.function)),
-      exclude_mode(wexpr.exclude_clause) {
-
-	for (auto &child : wexpr.children) {
-		arg_types.emplace_back(child->return_type);
-	}
-}
-
-WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
-    : WindowAggregator(wexpr) {
-	for (auto &child : wexpr.children) {
-		child_idx.emplace_back(shared.RegisterCollection(child, false));
-	}
-}
-
-WindowAggregator::~WindowAggregator() {
-}
-
-unique_ptr<WindowAggregatorState> WindowAggregator::GetGlobalState(ClientContext &context, idx_t group_count,
-                                                                   const ValidityMask &) const {
-	return make_uniq<WindowAggregatorGlobalState>(context, *this, group_count);
-}
-
-void WindowAggregatorLocalState::Sink(WindowAggregatorGlobalState &gastate, DataChunk &sink_chunk,
-                                      DataChunk &coll_chunk, idx_t input_idx) {
-}
-
-void WindowAggregator::Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-                            DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-                            idx_t filtered) {
-	auto &gastate = gstate.Cast<WindowAggregatorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregatorLocalState>();
-	lastate.Sink(gastate, sink_chunk, coll_chunk, input_idx);
-	if (filter_sel) {
-		auto &filter_mask = gastate.filter_mask;
-		for (idx_t f = 0; f < filtered; ++f) {
-			filter_mask.SetValid(input_idx + filter_sel->get_index(f));
-		}
-	}
-}
-
-void WindowAggregatorLocalState::InitSubFrames(SubFrames &frames, const WindowExcludeMode exclude_mode) {
-	idx_t nframes = 0;
-	switch (exclude_mode) {
-	case WindowExcludeMode::NO_OTHER:
-		nframes = 1;
-		break;
-	case WindowExcludeMode::TIES:
-		nframes = 3;
-		break;
-	case WindowExcludeMode::CURRENT_ROW:
-	case WindowExcludeMode::GROUP:
-		nframes = 2;
-		break;
-	}
-	frames.resize(nframes, {0, 0});
-}
-
-void WindowAggregatorLocalState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
-	// Prepare to scan
-	if (!cursor) {
-		cursor = make_uniq<WindowCursor>(*collection, gastate.aggregator.child_idx);
-	}
-}
-
-void WindowAggregator::Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-                                const FrameStats &stats) {
-	auto &gasink = gstate.Cast<WindowAggregatorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregatorLocalState>();
-	lastate.Finalize(gasink, collection);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_boundaries_state.cpp b/src/duckdb/src/function/window/window_boundaries_state.cpp
deleted file mode 100644
index 7727e2a63..000000000
--- a/src/duckdb/src/function/window/window_boundaries_state.cpp
+++ /dev/null
@@ -1,854 +0,0 @@
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/function/window/window_boundaries_state.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowBoundariesState
-//===--------------------------------------------------------------------===//
-idx_t WindowBoundariesState::FindNextStart(const ValidityMask &mask, idx_t l, const idx_t r, idx_t &n) {
-	if (mask.AllValid()) {
-		auto start = MinValue(l + n - 1, r);
-		n -= MinValue(n, r - l);
-		return start;
-	}
-
-	while (l < r) {
-		//	If l is aligned with the start of a block, and the block is blank, then skip forward one block.
-		idx_t entry_idx;
-		idx_t shift;
-		mask.GetEntryIndex(l, entry_idx, shift);
-
-		const auto block = mask.GetValidityEntry(entry_idx);
-		if (mask.NoneValid(block) && !shift) {
-			l += ValidityMask::BITS_PER_VALUE;
-			continue;
-		}
-
-		// Loop over the block
-		for (; shift < ValidityMask::BITS_PER_VALUE && l < r; ++shift, ++l) {
-			if (mask.RowIsValid(block, shift) && --n == 0) {
-				return MinValue(l, r);
-			}
-		}
-	}
-
-	//	Didn't find a start so return the end of the range
-	return r;
-}
-
-idx_t WindowBoundariesState::FindPrevStart(const ValidityMask &mask, const idx_t l, idx_t r, idx_t &n) {
-	if (mask.AllValid()) {
-		auto start = (r <= l + n) ? l : r - n;
-		n -= r - start;
-		return start;
-	}
-
-	while (l < r) {
-		// If r is aligned with the start of a block, and the previous block is blank,
-		// then skip backwards one block.
-		idx_t entry_idx;
-		idx_t shift;
-		mask.GetEntryIndex(r - 1, entry_idx, shift);
-
-		const auto block = mask.GetValidityEntry(entry_idx);
-		if (mask.NoneValid(block) && (shift + 1 == ValidityMask::BITS_PER_VALUE)) {
-			// r is nonzero (> l) and word aligned, so this will not underflow.
-			r -= ValidityMask::BITS_PER_VALUE;
-			continue;
-		}
-
-		// Loop backwards over the block
-		// shift is probing r-1 >= l >= 0
-		for (++shift; shift-- > 0 && l < r; --r) {
-			// l < r ensures n == 1 if result is supposed to be NULL because of EXCLUDE
-			if (mask.RowIsValid(block, shift) && --n == 0) {
-				return MaxValue(l, r - 1);
-			}
-		}
-	}
-
-	//	Didn't find a start so return the start of the range
-	return l;
-}
-
-//===--------------------------------------------------------------------===//
-// WindowColumnIterator
-//===--------------------------------------------------------------------===//
-template <typename T>
-struct WindowColumnIterator {
-	using iterator = WindowColumnIterator<T>;
-	using iterator_category = std::random_access_iterator_tag;
-	using difference_type = std::ptrdiff_t;
-	using value_type = T;
-	using reference = T;
-	using pointer = idx_t;
-
-	explicit WindowColumnIterator(WindowCursor &coll, pointer pos = 0) : coll(&coll), pos(pos) {
-	}
-
-	//	Forward iterator
-	inline reference operator*() const {
-		return coll->GetCell<T>(0, pos);
-	}
-	inline explicit operator pointer() const {
-		return pos;
-	}
-
-	inline iterator &operator++() {
-		++pos;
-		return *this;
-	}
-	inline iterator operator++(int) {
-		auto result = *this;
-		++(*this);
-		return result;
-	}
-
-	//	Bidirectional iterator
-	inline iterator &operator--() {
-		--pos;
-		return *this;
-	}
-	inline iterator operator--(int) {
-		auto result = *this;
-		--(*this);
-		return result;
-	}
-
-	//	Random Access
-	inline iterator &operator+=(difference_type n) {
-		pos += UnsafeNumericCast<pointer>(n);
-		return *this;
-	}
-	inline iterator &operator-=(difference_type n) {
-		pos -= UnsafeNumericCast<pointer>(n);
-		return *this;
-	}
-
-	inline reference operator[](difference_type m) const {
-		return coll->GetCell<T>(0, pos + m);
-	}
-
-	friend inline iterator &operator+(const iterator &a, difference_type n) {
-		return iterator(a.coll, a.pos + n);
-	}
-
-	friend inline iterator operator-(const iterator &a, difference_type n) {
-		return iterator(a.coll, a.pos - n);
-	}
-
-	friend inline iterator operator+(difference_type n, const iterator &a) {
-		return a + n;
-	}
-	friend inline difference_type operator-(const iterator &a, const iterator &b) {
-		return difference_type(a.pos - b.pos);
-	}
-
-	friend inline bool operator==(const iterator &a, const iterator &b) {
-		return a.pos == b.pos;
-	}
-	friend inline bool operator!=(const iterator &a, const iterator &b) {
-		return a.pos != b.pos;
-	}
-	friend inline bool operator<(const iterator &a, const iterator &b) {
-		return a.pos < b.pos;
-	}
-	friend inline bool operator<=(const iterator &a, const iterator &b) {
-		return a.pos <= b.pos;
-	}
-	friend inline bool operator>(const iterator &a, const iterator &b) {
-		return a.pos > b.pos;
-	}
-	friend inline bool operator>=(const iterator &a, const iterator &b) {
-		return a.pos >= b.pos;
-	}
-
-private:
-	// optional_ptr does not allow us to modify this, but the constructor enforces it.
-	WindowCursor *coll;
-	pointer pos;
-};
-
-template <typename T, typename OP>
-struct OperationCompare : public std::function<bool(T, T)> {
-	inline bool operator()(const T &lhs, const T &val) const {
-		return OP::template Operation<T>(lhs, val);
-	}
-};
-
-template <typename T, typename OP, bool FROM>
-static idx_t FindTypedRangeBound(WindowCursor &over, const idx_t order_begin, const idx_t order_end,
-                                 const WindowBoundary range, WindowInputExpression &boundary, const idx_t chunk_idx,
-                                 const FrameBounds &prev) {
-	D_ASSERT(!boundary.CellIsNull(chunk_idx));
-	const auto val = boundary.GetCell<T>(chunk_idx);
-
-	OperationCompare<T, OP> comp;
-
-	// Check that the value we are searching for is in range.
-	if (range == WindowBoundary::EXPR_PRECEDING_RANGE) {
-		//	Preceding but value past the current value
-		const auto cur_val = over.GetCell<T>(0, order_end - 1);
-		if (comp(cur_val, val)) {
-			throw OutOfRangeException("Invalid RANGE PRECEDING value");
-		}
-	} else {
-		//	Following but value before the current value
-		D_ASSERT(range == WindowBoundary::EXPR_FOLLOWING_RANGE);
-		const auto cur_val = over.GetCell<T>(0, order_begin);
-		if (comp(val, cur_val)) {
-			throw OutOfRangeException("Invalid RANGE FOLLOWING value");
-		}
-	}
-
-	//	Try to reuse the previous bounds to restrict the search.
-	//	This is only valid if the previous bounds were non-empty
-	//	Only inject the comparisons if the previous bounds are a strict subset.
-	WindowColumnIterator<T> begin(over, order_begin);
-	WindowColumnIterator<T> end(over, order_end);
-	if (prev.start < prev.end) {
-		if (order_begin < prev.start && prev.start < order_end) {
-			const auto first = over.GetCell<T>(0, prev.start);
-			if (!comp(val, first)) {
-				//	prev.first <= val, so we can start further forward
-				begin += UnsafeNumericCast<int64_t>(prev.start - order_begin);
-			}
-		}
-		if (order_begin < prev.end && prev.end < order_end) {
-			const auto second = over.GetCell<T>(0, prev.end - 1);
-			if (!comp(second, val)) {
-				//	val <= prev.second, so we can end further back
-				// (prev.second is the largest peer)
-				end -= UnsafeNumericCast<int64_t>(order_end - prev.end - 1);
-			}
-		}
-	}
-
-	if (FROM) {
-		return idx_t(std::lower_bound(begin, end, val, comp));
-	} else {
-		return idx_t(std::upper_bound(begin, end, val, comp));
-	}
-}
-
-template <typename OP, bool FROM>
-static idx_t FindRangeBound(WindowCursor &over, const idx_t order_begin, const idx_t order_end,
-                            const WindowBoundary range, WindowInputExpression &boundary, const idx_t chunk_idx,
-                            const FrameBounds &prev) {
-	switch (boundary.InternalType()) {
-	case PhysicalType::INT8:
-		return FindTypedRangeBound<int8_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::INT16:
-		return FindTypedRangeBound<int16_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::INT32:
-		return FindTypedRangeBound<int32_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::INT64:
-		return FindTypedRangeBound<int64_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::UINT8:
-		return FindTypedRangeBound<uint8_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::UINT16:
-		return FindTypedRangeBound<uint16_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::UINT32:
-		return FindTypedRangeBound<uint32_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::UINT64:
-		return FindTypedRangeBound<uint64_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::INT128:
-		return FindTypedRangeBound<hugeint_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::UINT128:
-		return FindTypedRangeBound<uhugeint_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx,
-		                                                 prev);
-	case PhysicalType::FLOAT:
-		return FindTypedRangeBound<float, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::DOUBLE:
-		return FindTypedRangeBound<double, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case PhysicalType::INTERVAL:
-		return FindTypedRangeBound<interval_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx,
-		                                                 prev);
-	default:
-		throw InternalException("Unsupported column type for RANGE");
-	}
-}
-
-template <bool FROM>
-static idx_t FindOrderedRangeBound(WindowCursor &over, const OrderType range_sense, const idx_t order_begin,
-                                   const idx_t order_end, const WindowBoundary range, WindowInputExpression &boundary,
-                                   const idx_t chunk_idx, const FrameBounds &prev) {
-	switch (range_sense) {
-	case OrderType::ASCENDING:
-		return FindRangeBound<LessThan, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	case OrderType::DESCENDING:
-		return FindRangeBound<GreaterThan, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
-	default:
-		throw InternalException("Unsupported ORDER BY sense for RANGE");
-	}
-}
-
-bool WindowBoundariesState::HasPrecedingRange(const BoundWindowExpression &wexpr) {
-	return (wexpr.start == WindowBoundary::EXPR_PRECEDING_RANGE || wexpr.end == WindowBoundary::EXPR_PRECEDING_RANGE);
-}
-
-bool WindowBoundariesState::HasFollowingRange(const BoundWindowExpression &wexpr) {
-	return (wexpr.start == WindowBoundary::EXPR_FOLLOWING_RANGE || wexpr.end == WindowBoundary::EXPR_FOLLOWING_RANGE);
-}
-
-WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpression &wexpr) {
-	const auto partition_count = wexpr.partitions.size();
-	const auto order_count = wexpr.orders.size();
-
-	WindowBoundsSet result;
-	switch (wexpr.GetExpressionType()) {
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		if (wexpr.arg_orders.empty()) {
-			result.insert(PARTITION_BEGIN);
-		} else {
-			// Secondary orders need to know where the frame is
-			result.insert(FRAME_BEGIN);
-			result.insert(FRAME_END);
-		}
-		break;
-	case ExpressionType::WINDOW_NTILE:
-		if (wexpr.arg_orders.empty()) {
-			result.insert(PARTITION_BEGIN);
-			result.insert(PARTITION_END);
-		} else {
-			// Secondary orders need to know where the frame is
-			result.insert(FRAME_BEGIN);
-			result.insert(FRAME_END);
-		}
-		break;
-	case ExpressionType::WINDOW_RANK:
-		if (wexpr.arg_orders.empty()) {
-			result.insert(PARTITION_BEGIN);
-			result.insert(PEER_BEGIN);
-		} else {
-			// Secondary orders need to know where the frame is
-			result.insert(FRAME_BEGIN);
-			result.insert(FRAME_END);
-		}
-		break;
-	case ExpressionType::WINDOW_RANK_DENSE:
-		result.insert(PARTITION_BEGIN);
-		result.insert(PEER_BEGIN);
-		break;
-	case ExpressionType::WINDOW_PERCENT_RANK:
-		if (wexpr.arg_orders.empty()) {
-			result.insert(PARTITION_BEGIN);
-			result.insert(PARTITION_END);
-			result.insert(PEER_BEGIN);
-		} else {
-			// Secondary orders need to know where the frame is
-			result.insert(FRAME_BEGIN);
-			result.insert(FRAME_END);
-		}
-		break;
-	case ExpressionType::WINDOW_CUME_DIST:
-		if (wexpr.arg_orders.empty()) {
-			result.insert(PARTITION_BEGIN);
-			result.insert(PARTITION_END);
-			result.insert(PEER_END);
-		} else {
-			// Secondary orders need to know where the frame is
-			result.insert(FRAME_BEGIN);
-			result.insert(FRAME_END);
-		}
-		break;
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-		if (wexpr.arg_orders.empty()) {
-			result.insert(PARTITION_BEGIN);
-			result.insert(PARTITION_END);
-		} else {
-			// Secondary orders need to know where the frame is
-			result.insert(FRAME_BEGIN);
-			result.insert(FRAME_END);
-		}
-		break;
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_NTH_VALUE:
-	case ExpressionType::WINDOW_AGGREGATE:
-		result.insert(FRAME_BEGIN);
-		result.insert(FRAME_END);
-		break;
-	default:
-		throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType()));
-	}
-
-	//	Internal dependencies
-	if (result.count(FRAME_BEGIN) || result.count(FRAME_END)) {
-		result.insert(PARTITION_BEGIN);
-		result.insert(PARTITION_END);
-
-		// if we have EXCLUDE GROUP / TIES, we also need peer boundaries
-		if (wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) {
-			result.insert(PEER_BEGIN);
-			result.insert(PEER_END);
-		}
-
-		// If the frames are RANGE, then we need peer boundaries
-		// If they are preceding or following, we also need to know
-		// where the valid values begin or end.
-		switch (wexpr.start) {
-		case WindowBoundary::CURRENT_ROW_RANGE:
-			result.insert(PEER_BEGIN);
-			break;
-		case WindowBoundary::EXPR_PRECEDING_RANGE:
-			result.insert(PEER_BEGIN);
-			result.insert(VALID_BEGIN);
-			result.insert(VALID_END);
-			break;
-		case WindowBoundary::EXPR_FOLLOWING_RANGE:
-			result.insert(PEER_BEGIN);
-			result.insert(VALID_END);
-			break;
-		default:
-			break;
-		}
-
-		switch (wexpr.end) {
-		case WindowBoundary::CURRENT_ROW_RANGE:
-			result.insert(PEER_END);
-			break;
-		case WindowBoundary::EXPR_PRECEDING_RANGE:
-			result.insert(PEER_END);
-			result.insert(VALID_BEGIN);
-			break;
-		case WindowBoundary::EXPR_FOLLOWING_RANGE:
-			result.insert(PEER_END);
-			result.insert(VALID_BEGIN);
-			result.insert(VALID_END);
-			break;
-		default:
-			break;
-		}
-	}
-
-	if (result.count(VALID_END)) {
-		result.insert(PARTITION_END);
-		if (HasFollowingRange(wexpr)) {
-			result.insert(VALID_BEGIN);
-		}
-	}
-	if (result.count(VALID_BEGIN)) {
-		result.insert(PARTITION_BEGIN);
-		result.insert(PARTITION_END);
-	}
-	if (result.count(PEER_END)) {
-		result.insert(PARTITION_END);
-		if (order_count) {
-			result.insert(PEER_BEGIN);
-		}
-	}
-	if (result.count(PARTITION_END) && (partition_count + order_count)) {
-		result.insert(PARTITION_BEGIN);
-	}
-
-	return result;
-}
-
-WindowBoundariesState::WindowBoundariesState(const BoundWindowExpression &wexpr, const idx_t input_size)
-    : required(GetWindowBounds(wexpr)), type(wexpr.GetExpressionType()), input_size(input_size),
-      start_boundary(wexpr.start), end_boundary(wexpr.end), partition_count(wexpr.partitions.size()),
-      order_count(wexpr.orders.size()), range_sense(wexpr.orders.empty() ? OrderType::INVALID : wexpr.orders[0].type),
-      has_preceding_range(HasPrecedingRange(wexpr)), has_following_range(HasFollowingRange(wexpr)) {
-}
-
-void WindowBoundariesState::Bounds(DataChunk &bounds, idx_t row_idx, optional_ptr<WindowCursor> range,
-                                   const idx_t count, WindowInputExpression &boundary_start,
-                                   WindowInputExpression &boundary_end, const ValidityMask &partition_mask,
-                                   const ValidityMask &order_mask) {
-	bounds.Reset();
-	D_ASSERT(bounds.ColumnCount() == 8);
-
-	const auto is_jump = (next_pos != row_idx);
-	if (required.count(PARTITION_BEGIN)) {
-		PartitionBegin(bounds, row_idx, count, is_jump, partition_mask);
-	}
-	if (required.count(PARTITION_END)) {
-		PartitionEnd(bounds, row_idx, count, is_jump, partition_mask);
-	}
-	if (required.count(PEER_BEGIN)) {
-		PeerBegin(bounds, row_idx, count, is_jump, partition_mask, order_mask);
-	}
-	if (required.count(PEER_END)) {
-		PeerEnd(bounds, row_idx, count, partition_mask, order_mask);
-	}
-	if (required.count(VALID_BEGIN)) {
-		ValidBegin(bounds, row_idx, count, is_jump, partition_mask, order_mask, range);
-	}
-	if (required.count(VALID_END)) {
-		ValidEnd(bounds, row_idx, count, is_jump, partition_mask, order_mask, range);
-	}
-	if (required.count(FRAME_BEGIN)) {
-		FrameBegin(bounds, row_idx, count, boundary_start, range);
-	}
-	if (required.count(FRAME_END)) {
-		FrameEnd(bounds, row_idx, count, boundary_end, range);
-	}
-	next_pos += count;
-
-	bounds.SetCardinality(count);
-}
-
-void WindowBoundariesState::PartitionBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-                                           const ValidityMask &partition_mask) {
-	auto partition_begin_data = FlatVector::GetData<idx_t>(bounds.data[PARTITION_BEGIN]);
-
-	//	OVER()
-	if (partition_count + order_count == 0) {
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			partition_begin_data[chunk_idx] = 0;
-		}
-		return;
-	}
-
-	for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-		// determine partition and peer group boundaries to ultimately figure out window size
-		const auto is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-
-		// when the partition changes, recompute the boundaries
-		if (!is_same_partition || is_jump) {
-			if (is_jump) {
-				idx_t n = 1;
-				partition_start = FindPrevStart(partition_mask, 0, row_idx + 1, n);
-				is_jump = false;
-			} else {
-				partition_start = row_idx;
-			}
-		}
-
-		partition_begin_data[chunk_idx] = partition_start;
-	}
-}
-
-void WindowBoundariesState::PartitionEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-                                         const ValidityMask &partition_mask) {
-	auto partition_end_data = FlatVector::GetData<idx_t>(bounds.data[PARTITION_END]);
-
-	//	OVER()
-	if (partition_count + order_count == 0) {
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			partition_end_data[chunk_idx] = input_size;
-		}
-		return;
-	}
-
-	auto partition_begin_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_BEGIN]);
-	for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-		// determine partition and peer group boundaries to ultimately figure out window size
-		const auto is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-
-		// when the partition changes, recompute the boundaries
-		if (!is_same_partition || is_jump) {
-			// find end of partition
-			partition_end = input_size;
-			if (partition_count) {
-				const auto partition_begin = partition_begin_data[chunk_idx];
-				idx_t n = 1;
-				partition_end = FindNextStart(partition_mask, partition_begin + 1, input_size, n);
-			}
-			is_jump = false;
-		}
-
-		partition_end_data[chunk_idx] = partition_end;
-	}
-}
-
-void WindowBoundariesState::PeerBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-                                      const ValidityMask &partition_mask, const ValidityMask &order_mask) {
-
-	auto peer_begin_data = FlatVector::GetData<idx_t>(bounds.data[PEER_BEGIN]);
-
-	//	OVER()
-	if (partition_count + order_count == 0) {
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			peer_begin_data[chunk_idx] = 0;
-		}
-		return;
-	}
-
-	for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-		// determine partition and peer group boundaries to ultimately figure out window size
-		const auto is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-		const auto is_peer = !order_mask.RowIsValidUnsafe(row_idx);
-
-		// when the partition changes, recompute the boundaries
-		if (!is_same_partition || is_jump) {
-			// find end of partition
-			if (is_jump) {
-				idx_t n = 1;
-				peer_start = FindPrevStart(order_mask, 0, row_idx + 1, n);
-			} else {
-				peer_start = row_idx;
-			}
-			is_jump = false;
-		} else if (!is_peer) {
-			peer_start = row_idx;
-		}
-
-		peer_begin_data[chunk_idx] = peer_start;
-	}
-}
-
-void WindowBoundariesState::PeerEnd(DataChunk &bounds, idx_t row_idx, const idx_t count,
-                                    const ValidityMask &partition_mask, const ValidityMask &order_mask) {
-	//	OVER()
-	if (!order_count) {
-		bounds.data[PEER_END].Reference(bounds.data[PARTITION_END]);
-		return;
-	}
-
-	auto partition_end_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_END]);
-	auto peer_begin_data = FlatVector::GetData<const idx_t>(bounds.data[PEER_BEGIN]);
-	auto peer_end_data = FlatVector::GetData<idx_t>(bounds.data[PEER_END]);
-	for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-		idx_t n = 1;
-		const auto peer_start = peer_begin_data[chunk_idx];
-		const auto partition_end = partition_end_data[chunk_idx];
-		peer_end_data[chunk_idx] = FindNextStart(order_mask, peer_start + 1, partition_end, n);
-	}
-}
-
-void WindowBoundariesState::ValidBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-                                       const ValidityMask &partition_mask, const ValidityMask &order_mask,
-                                       optional_ptr<WindowCursor> range) {
-	auto partition_begin_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_BEGIN]);
-	auto partition_end_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_END]);
-	auto valid_begin_data = FlatVector::GetData<idx_t>(bounds.data[VALID_BEGIN]);
-
-	//	OVER()
-	D_ASSERT(partition_count + order_count != 0);
-	D_ASSERT(range);
-
-	for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-		const auto is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-
-		if (!is_same_partition || is_jump) {
-			// Find valid ordering values for the new partition
-			// so we can exclude NULLs from RANGE expression computations
-			valid_start = partition_begin_data[chunk_idx];
-			const auto valid_end = partition_end_data[chunk_idx];
-
-			if ((valid_start < valid_end) && has_preceding_range) {
-				// Exclude any leading NULLs
-				if (range->CellIsNull(0, valid_start)) {
-					idx_t n = 1;
-					valid_start = FindNextStart(order_mask, valid_start + 1, valid_end, n);
-				}
-			}
-		}
-
-		valid_begin_data[chunk_idx] = valid_start;
-	}
-}
-
-void WindowBoundariesState::ValidEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-                                     const ValidityMask &partition_mask, const ValidityMask &order_mask,
-                                     optional_ptr<WindowCursor> range) {
-	auto partition_end_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_END]);
-	auto valid_begin_data = FlatVector::GetData<const idx_t>(bounds.data[VALID_BEGIN]);
-	auto valid_end_data = FlatVector::GetData<idx_t>(bounds.data[VALID_END]);
-
-	//	OVER()
-	D_ASSERT(partition_count + order_count != 0);
-	D_ASSERT(range);
-
-	for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-		const auto is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-
-		if (!is_same_partition || is_jump) {
-			// Find valid ordering values for the new partition
-			// so we can exclude NULLs from RANGE expression computations
-			valid_end = partition_end_data[chunk_idx];
-
-			if ((valid_start < valid_end) && has_following_range) {
-				// Exclude any trailing NULLs
-				const auto valid_start = valid_begin_data[chunk_idx];
-				if (range->CellIsNull(0, valid_end - 1)) {
-					idx_t n = 1;
-					valid_end = FindPrevStart(order_mask, valid_start, valid_end, n);
-				}
-
-				//	Reset range hints
-				prev.start = valid_start;
-				prev.end = valid_end;
-			}
-		}
-
-		valid_end_data[chunk_idx] = valid_end;
-	}
-}
-
-void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const idx_t count,
-                                       WindowInputExpression &boundary_begin, optional_ptr<WindowCursor> range) {
-	auto partition_begin_data = FlatVector::GetData<idx_t>(bounds.data[PARTITION_BEGIN]);
-	auto partition_end_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_END]);
-	auto peer_begin_data = FlatVector::GetData<idx_t>(bounds.data[PEER_BEGIN]);
-	auto valid_begin_data = FlatVector::GetData<const idx_t>(bounds.data[VALID_BEGIN]);
-	auto valid_end_data = FlatVector::GetData<const idx_t>(bounds.data[VALID_END]);
-	auto frame_begin_data = FlatVector::GetData<idx_t>(bounds.data[FRAME_BEGIN]);
-
-	idx_t window_start = NumericLimits<idx_t>::Maximum();
-
-	switch (start_boundary) {
-	case WindowBoundary::UNBOUNDED_PRECEDING:
-		bounds.data[FRAME_BEGIN].Reference(bounds.data[PARTITION_BEGIN]);
-		// No need to clamp
-		return;
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			frame_begin_data[chunk_idx] = row_idx;
-		}
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		bounds.data[FRAME_BEGIN].Reference(bounds.data[PEER_BEGIN]);
-		frame_begin_data = peer_begin_data;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			int64_t computed_start;
-			if (!TrySubtractOperator::Operation(static_cast<int64_t>(row_idx),
-			                                    boundary_begin.GetCell<int64_t>(chunk_idx), computed_start)) {
-				window_start = partition_begin_data[chunk_idx];
-			} else {
-				window_start = UnsafeNumericCast<idx_t>(MaxValue<int64_t>(computed_start, 0));
-			}
-			frame_begin_data[chunk_idx] = window_start;
-		}
-		break;
-	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			int64_t computed_start;
-			if (!TryAddOperator::Operation(static_cast<int64_t>(row_idx), boundary_begin.GetCell<int64_t>(chunk_idx),
-			                               computed_start)) {
-				window_start = partition_begin_data[chunk_idx];
-			} else {
-				window_start = UnsafeNumericCast<idx_t>(MaxValue<int64_t>(computed_start, 0));
-			}
-			frame_begin_data[chunk_idx] = window_start;
-		}
-		break;
-	case WindowBoundary::EXPR_PRECEDING_RANGE:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			if (boundary_begin.CellIsNull(chunk_idx)) {
-				window_start = peer_begin_data[chunk_idx];
-			} else {
-				const auto valid_start = valid_begin_data[chunk_idx];
-				prev.end = valid_end_data[chunk_idx];
-				window_start = FindOrderedRangeBound<true>(*range, range_sense, valid_start, row_idx + 1,
-				                                           start_boundary, boundary_begin, chunk_idx, prev);
-				prev.start = window_start;
-			}
-			frame_begin_data[chunk_idx] = window_start;
-		}
-		break;
-	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			if (boundary_begin.CellIsNull(chunk_idx)) {
-				window_start = peer_begin_data[chunk_idx];
-			} else {
-				const auto valid_end = valid_end_data[chunk_idx];
-				prev.end = valid_end;
-				window_start = FindOrderedRangeBound<true>(*range, range_sense, row_idx, valid_end, start_boundary,
-				                                           boundary_begin, chunk_idx, prev);
-				prev.start = window_start;
-			}
-			frame_begin_data[chunk_idx] = window_start;
-		}
-		break;
-	default:
-		throw InternalException("Unsupported window start boundary");
-	}
-
-	ClampFrame(count, frame_begin_data, partition_begin_data, partition_end_data);
-}
-
-void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx_t count,
-                                     WindowInputExpression &boundary_end, optional_ptr<WindowCursor> range) {
-	auto partition_begin_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_BEGIN]);
-	auto partition_end_data = FlatVector::GetData<idx_t>(bounds.data[PARTITION_END]);
-	auto peer_end_data = FlatVector::GetData<idx_t>(bounds.data[PEER_END]);
-	auto valid_begin_data = FlatVector::GetData<const idx_t>(bounds.data[VALID_BEGIN]);
-	auto valid_end_data = FlatVector::GetData<const idx_t>(bounds.data[VALID_END]);
-	auto frame_end_data = FlatVector::GetData<idx_t>(bounds.data[FRAME_END]);
-
-	idx_t window_end = NumericLimits<idx_t>::Maximum();
-
-	switch (end_boundary) {
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			frame_end_data[chunk_idx] = row_idx + 1;
-		}
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		bounds.data[FRAME_END].Reference(bounds.data[PEER_END]);
-		frame_end_data = peer_end_data;
-		break;
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		bounds.data[FRAME_END].Reference(bounds.data[PARTITION_END]);
-		// No need to clamp
-		return;
-	case WindowBoundary::EXPR_PRECEDING_ROWS: {
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			int64_t computed_start;
-			if (!TrySubtractOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(chunk_idx),
-			                                    computed_start)) {
-				window_end = partition_end_data[chunk_idx];
-			} else {
-				window_end = UnsafeNumericCast<idx_t>(MaxValue<int64_t>(computed_start, 0));
-			}
-			frame_end_data[chunk_idx] = window_end;
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			int64_t computed_start;
-			if (!TryAddOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(chunk_idx),
-			                               computed_start)) {
-				window_end = partition_end_data[chunk_idx];
-			} else {
-				window_end = UnsafeNumericCast<idx_t>(MaxValue<int64_t>(computed_start, 0));
-			}
-			frame_end_data[chunk_idx] = window_end;
-		}
-		break;
-	case WindowBoundary::EXPR_PRECEDING_RANGE:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			if (boundary_end.CellIsNull(chunk_idx)) {
-				window_end = peer_end_data[chunk_idx];
-			} else {
-				const auto valid_start = valid_begin_data[chunk_idx];
-				prev.start = valid_start;
-				window_end = FindOrderedRangeBound<false>(*range, range_sense, valid_start, row_idx + 1, end_boundary,
-				                                          boundary_end, chunk_idx, prev);
-				prev.end = window_end;
-			}
-			frame_end_data[chunk_idx] = window_end;
-		}
-		break;
-	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
-			if (boundary_end.CellIsNull(chunk_idx)) {
-				window_end = peer_end_data[chunk_idx];
-			} else {
-				const auto valid_end = valid_end_data[chunk_idx];
-				prev.start = valid_begin_data[chunk_idx];
-				window_end = FindOrderedRangeBound<false>(*range, range_sense, row_idx, valid_end, end_boundary,
-				                                          boundary_end, chunk_idx, prev);
-				prev.end = window_end;
-			}
-			frame_end_data[chunk_idx] = window_end;
-		}
-		break;
-	default:
-		throw InternalException("Unsupported window end boundary");
-	}
-
-	ClampFrame(count, frame_end_data, partition_begin_data, partition_end_data);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_collection.cpp b/src/duckdb/src/function/window/window_collection.cpp
deleted file mode 100644
index 0dee0cc84..000000000
--- a/src/duckdb/src/function/window/window_collection.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "duckdb/function/window/window_collection.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowCollection
-//===--------------------------------------------------------------------===//
-WindowCollection::WindowCollection(BufferManager &buffer_manager, idx_t count, const vector<LogicalType> &types)
-    : all_valids(types.size()), types(types), count(count), buffer_manager(buffer_manager) {
-	if (!types.empty()) {
-		inputs = make_uniq<ColumnDataCollection>(buffer_manager, types);
-	}
-
-	validities.resize(types.size());
-
-	// Atomic vectors can't be constructed with a given value
-	for (auto &all_valid : all_valids) {
-		all_valid = true;
-	}
-}
-
-void WindowCollection::GetCollection(idx_t row_idx, ColumnDataCollectionSpec &spec) {
-	if (spec.second && row_idx == spec.first + spec.second->Count()) {
-		return;
-	}
-
-	lock_guard<mutex> collection_guard(lock);
-
-	auto collection = make_uniq<ColumnDataCollection>(buffer_manager, types);
-	spec = {row_idx, collection.get()};
-	Range probe {row_idx, collections.size()};
-	auto i = std::upper_bound(ranges.begin(), ranges.end(), probe);
-	ranges.insert(i, probe);
-	collections.emplace_back(std::move(collection));
-}
-
-void WindowCollection::Combine(const ColumnSet &validity_cols) {
-	lock_guard<mutex> collection_guard(lock);
-
-	// If there are no columns (COUNT(*)) then this is a NOP
-	if (types.empty()) {
-		return;
-	}
-
-	// Have we already combined?
-	if (inputs->Count()) {
-		D_ASSERT(collections.empty());
-		D_ASSERT(ranges.empty());
-		return;
-	}
-
-	// If there are columns, we should have data
-	D_ASSERT(!collections.empty());
-	D_ASSERT(!ranges.empty());
-
-	for (auto &range : ranges) {
-		inputs->Combine(*collections[range.second]);
-	}
-	collections.clear();
-	ranges.clear();
-
-	if (validity_cols.empty()) {
-		return;
-	}
-
-	D_ASSERT(inputs.get());
-
-	//	Find all columns with NULLs
-	vector<column_t> invalid_cols;
-	for (auto &col_idx : validity_cols) {
-		if (!all_valids[col_idx]) {
-			invalid_cols.emplace_back(col_idx);
-			validities[col_idx].Initialize(inputs->Count());
-		}
-	}
-
-	if (invalid_cols.empty()) {
-		return;
-	}
-
-	WindowCursor cursor(*this, invalid_cols);
-	idx_t target_offset = 0;
-	while (cursor.Scan()) {
-		const auto count = cursor.chunk.size();
-		for (idx_t i = 0; i < invalid_cols.size(); ++i) {
-			auto &other = FlatVector::Validity(cursor.chunk.data[i]);
-			const auto col_idx = invalid_cols[i];
-			validities[col_idx].SliceInPlace(other, target_offset, 0, count);
-		}
-		target_offset += count;
-	}
-}
-
-WindowBuilder::WindowBuilder(WindowCollection &collection) : collection(collection) {
-}
-
-void WindowBuilder::Sink(DataChunk &chunk, idx_t input_idx) {
-	// Check whether we need a a new collection
-	if (!sink.second || input_idx < sink.first || sink.first + sink.second->Count() < input_idx) {
-		collection.GetCollection(input_idx, sink);
-		D_ASSERT(sink.second);
-		sink.second->InitializeAppend(appender);
-	}
-	sink.second->Append(appender, chunk);
-
-	// Record NULLs
-	for (column_t col_idx = 0; col_idx < chunk.ColumnCount(); ++col_idx) {
-		if (!collection.all_valids[col_idx]) {
-			continue;
-		}
-
-		// Column was valid, make sure it still is.
-		UnifiedVectorFormat data;
-		chunk.data[col_idx].ToUnifiedFormat(chunk.size(), data);
-		if (!data.validity.AllValid()) {
-			collection.all_valids[col_idx] = false;
-		}
-	}
-}
-
-WindowCursor::WindowCursor(const WindowCollection &paged, vector<column_t> column_ids) : paged(paged) {
-	D_ASSERT(paged.collections.empty());
-	D_ASSERT(paged.ranges.empty());
-	if (column_ids.empty()) {
-		//	For things like COUNT(*) set the state up to contain the whole range
-		state.segment_index = 0;
-		state.chunk_index = 0;
-		state.current_row_index = 0;
-		state.next_row_index = paged.size();
-		state.properties = ColumnDataScanProperties::ALLOW_ZERO_COPY;
-		chunk.SetCapacity(state.next_row_index);
-		chunk.SetCardinality(state.next_row_index);
-		return;
-	} else if (chunk.data.empty()) {
-		auto &inputs = paged.inputs;
-		D_ASSERT(inputs.get());
-		inputs->InitializeScan(state, std::move(column_ids));
-		inputs->InitializeScanChunk(state, chunk);
-	}
-}
-
-WindowCursor::WindowCursor(const WindowCollection &paged, column_t col_idx)
-    : WindowCursor(paged, vector<column_t>(1, col_idx)) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_constant_aggregator.cpp b/src/duckdb/src/function/window/window_constant_aggregator.cpp
deleted file mode 100644
index 0e09c6f99..000000000
--- a/src/duckdb/src/function/window/window_constant_aggregator.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-#include "duckdb/function/window/window_constant_aggregator.hpp"
-
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/function/window/window_aggregate_states.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowConstantAggregatorGlobalState
-//===--------------------------------------------------------------------===//
-
-class WindowConstantAggregatorGlobalState : public WindowAggregatorGlobalState {
-public:
-	WindowConstantAggregatorGlobalState(ClientContext &context, const WindowConstantAggregator &aggregator, idx_t count,
-	                                    const ValidityMask &partition_mask);
-
-	void Finalize(const FrameStats &stats);
-
-	//! Partition starts
-	vector<idx_t> partition_offsets;
-	//! Reused result state container for the window functions
-	WindowAggregateStates statef;
-	//! Aggregate results
-	unique_ptr<Vector> results;
-};
-
-WindowConstantAggregatorGlobalState::WindowConstantAggregatorGlobalState(ClientContext &context,
-                                                                         const WindowConstantAggregator &aggregator,
-                                                                         idx_t group_count,
-                                                                         const ValidityMask &partition_mask)
-    : WindowAggregatorGlobalState(context, aggregator, STANDARD_VECTOR_SIZE), statef(aggr) {
-
-	// Locate the partition boundaries
-	if (partition_mask.AllValid()) {
-		partition_offsets.emplace_back(0);
-	} else {
-		idx_t entry_idx;
-		idx_t shift;
-		for (idx_t start = 0; start < group_count;) {
-			partition_mask.GetEntryIndex(start, entry_idx, shift);
-
-			//	If start is aligned with the start of a block,
-			//	and the block is blank, then skip forward one block.
-			const auto block = partition_mask.GetValidityEntry(entry_idx);
-			if (partition_mask.NoneValid(block) && !shift) {
-				start += ValidityMask::BITS_PER_VALUE;
-				continue;
-			}
-
-			// Loop over the block
-			for (; shift < ValidityMask::BITS_PER_VALUE && start < group_count; ++shift, ++start) {
-				if (partition_mask.RowIsValid(block, shift)) {
-					partition_offsets.emplace_back(start);
-				}
-			}
-		}
-	}
-
-	//	Initialise the vector for caching the results
-	results = make_uniq<Vector>(aggregator.result_type, partition_offsets.size());
-
-	//	Initialise the final states
-	statef.Initialize(partition_offsets.size());
-
-	// Add final guard
-	partition_offsets.emplace_back(group_count);
-}
-
-//===--------------------------------------------------------------------===//
-// WindowConstantAggregatorLocalState
-//===--------------------------------------------------------------------===//
-class WindowConstantAggregatorLocalState : public WindowAggregatorLocalState {
-public:
-	explicit WindowConstantAggregatorLocalState(const WindowConstantAggregatorGlobalState &gstate);
-	~WindowConstantAggregatorLocalState() override {
-	}
-
-	void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-	          idx_t filtered);
-	void Combine(WindowConstantAggregatorGlobalState &gstate);
-
-public:
-	//! The global state we are sharing
-	const WindowConstantAggregatorGlobalState &gstate;
-	//! Reusable chunk for sinking
-	DataChunk inputs;
-	//! Chunk for referencing the input columns
-	DataChunk payload_chunk;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! Reused result state container for the window functions
-	WindowAggregateStates statef;
-	//! The current result partition being read
-	idx_t partition;
-	//! Shared SV for evaluation
-	SelectionVector matches;
-};
-
-WindowConstantAggregatorLocalState::WindowConstantAggregatorLocalState(
-    const WindowConstantAggregatorGlobalState &gstate)
-    : gstate(gstate), statep(Value::POINTER(0)), statef(gstate.statef.aggr), partition(0) {
-	matches.Initialize();
-
-	//	Start the aggregates
-	auto &partition_offsets = gstate.partition_offsets;
-	auto &aggregator = gstate.aggregator;
-	statef.Initialize(partition_offsets.size() - 1);
-
-	// Set up shared buffer
-	inputs.Initialize(Allocator::DefaultAllocator(), aggregator.arg_types);
-	payload_chunk.InitializeEmpty(inputs.GetTypes());
-
-	gstate.locals++;
-}
-
-//===--------------------------------------------------------------------===//
-// WindowConstantAggregator
-//===--------------------------------------------------------------------===//
-bool WindowConstantAggregator::CanAggregate(const BoundWindowExpression &wexpr) {
-	if (!wexpr.aggregate) {
-		return false;
-	}
-	// window exclusion cannot be handled by constant aggregates
-	if (wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) {
-		return false;
-	}
-
-	// 	DISTINCT aggregation cannot be handled by constant aggregation
-	if (wexpr.distinct) {
-		return false;
-	}
-
-	//	COUNT(*) is already handled efficiently by segment trees.
-	if (wexpr.children.empty()) {
-		return false;
-	}
-
-	/*
-	    The default framing option is RANGE UNBOUNDED PRECEDING, which
-	    is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT
-	    ROW; it sets the frame to be all rows from the partition start
-	    up through the current row's last peer (a row that the window's
-	    ORDER BY clause considers equivalent to the current row; all
-	    rows are peers if there is no ORDER BY). In general, UNBOUNDED
-	    PRECEDING means that the frame starts with the first row of the
-	    partition, and similarly UNBOUNDED FOLLOWING means that the
-	    frame ends with the last row of the partition, regardless of
-	    RANGE, ROWS or GROUPS mode. In ROWS mode, CURRENT ROW means that
-	    the frame starts or ends with the current row; but in RANGE or
-	    GROUPS mode it means that the frame starts or ends with the
-	    current row's first or last peer in the ORDER BY ordering. The
-	    offset PRECEDING and offset FOLLOWING options vary in meaning
-	    depending on the frame mode.
-	*/
-	switch (wexpr.start) {
-	case WindowBoundary::UNBOUNDED_PRECEDING:
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		if (!wexpr.orders.empty()) {
-			return false;
-		}
-		break;
-	default:
-		return false;
-	}
-
-	switch (wexpr.end) {
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		if (!wexpr.orders.empty()) {
-			return false;
-		}
-		break;
-	default:
-		return false;
-	}
-
-	return true;
-}
-
-BoundWindowExpression &WindowConstantAggregator::RebindAggregate(ClientContext &context, BoundWindowExpression &wexpr) {
-	FunctionBinder::BindSortedAggregate(context, wexpr);
-
-	return wexpr;
-}
-
-WindowConstantAggregator::WindowConstantAggregator(BoundWindowExpression &wexpr, WindowSharedExpressions &shared,
-                                                   ClientContext &context)
-    : WindowAggregator(RebindAggregate(context, wexpr)) {
-
-	// We only need these values for Sink
-	for (auto &child : wexpr.children) {
-		child_idx.emplace_back(shared.RegisterSink(child));
-	}
-}
-
-unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetGlobalState(ClientContext &context, idx_t group_count,
-                                                                           const ValidityMask &partition_mask) const {
-	return make_uniq<WindowConstantAggregatorGlobalState>(context, *this, group_count, partition_mask);
-}
-
-void WindowConstantAggregator::Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-                                    DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-                                    idx_t filtered) {
-	auto &lastate = lstate.Cast<WindowConstantAggregatorLocalState>();
-
-	lastate.Sink(sink_chunk, coll_chunk, input_idx, filter_sel, filtered);
-}
-
-void WindowConstantAggregatorLocalState::Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t row,
-                                              optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
-	auto &partition_offsets = gstate.partition_offsets;
-	const auto &aggr = gstate.aggr;
-	const auto chunk_begin = row;
-	const auto chunk_end = chunk_begin + sink_chunk.size();
-	idx_t partition =
-	    idx_t(std::upper_bound(partition_offsets.begin(), partition_offsets.end(), row) - partition_offsets.begin()) -
-	    1;
-
-	auto state_f_data = statef.GetData();
-	auto state_p_data = FlatVector::GetData<data_ptr_t>(statep);
-
-	auto &child_idx = gstate.aggregator.child_idx;
-	for (column_t c = 0; c < child_idx.size(); ++c) {
-		payload_chunk.data[c].Reference(sink_chunk.data[child_idx[c]]);
-	}
-
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	idx_t begin = 0;
-	idx_t filter_idx = 0;
-	auto partition_end = partition_offsets[partition + 1];
-	while (row < chunk_end) {
-		if (row == partition_end) {
-			++partition;
-			partition_end = partition_offsets[partition + 1];
-		}
-		partition_end = MinValue(partition_end, chunk_end);
-		auto end = partition_end - chunk_begin;
-
-		inputs.Reset();
-		if (filter_sel) {
-			// 	Slice to any filtered rows in [begin, end)
-			SelectionVector sel;
-
-			//	Find the first value in [begin, end)
-			for (; filter_idx < filtered; ++filter_idx) {
-				auto idx = filter_sel->get_index(filter_idx);
-				if (idx >= begin) {
-					break;
-				}
-			}
-
-			//	Find the first value in [end, filtered)
-			sel.Initialize(filter_sel->data() + filter_idx);
-			idx_t nsel = 0;
-			for (; filter_idx < filtered; ++filter_idx, ++nsel) {
-				auto idx = filter_sel->get_index(filter_idx);
-				if (idx >= end) {
-					break;
-				}
-			}
-
-			if (nsel != inputs.size()) {
-				inputs.Slice(payload_chunk, sel, nsel);
-			}
-		} else {
-			//	Slice to [begin, end)
-			if (begin) {
-				for (idx_t c = 0; c < payload_chunk.ColumnCount(); ++c) {
-					inputs.data[c].Slice(payload_chunk.data[c], begin, end);
-				}
-			} else {
-				inputs.Reference(payload_chunk);
-			}
-			inputs.SetCardinality(end - begin);
-		}
-
-		//	Aggregate the filtered rows into a single state
-		const auto count = inputs.size();
-		auto state = state_f_data[partition];
-		if (aggr.function.simple_update) {
-			aggr.function.simple_update(inputs.data.data(), aggr_input_data, inputs.ColumnCount(), state, count);
-		} else {
-			state_p_data[0] = state_f_data[partition];
-			aggr.function.update(inputs.data.data(), aggr_input_data, inputs.ColumnCount(), statep, count);
-		}
-
-		//	Skip filtered rows too!
-		row += end - begin;
-		begin = end;
-	}
-}
-
-void WindowConstantAggregator::Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate,
-                                        CollectionPtr collection, const FrameStats &stats) {
-	auto &gastate = gstate.Cast<WindowConstantAggregatorGlobalState>();
-	auto &lastate = lstate.Cast<WindowConstantAggregatorLocalState>();
-
-	//	Single-threaded combine
-	lock_guard<mutex> finalize_guard(gastate.lock);
-	lastate.statef.Combine(gastate.statef);
-	lastate.statef.Destroy();
-
-	//	Last one out turns off the lights!
-	if (++gastate.finalized == gastate.locals) {
-		gastate.statef.Finalize(*gastate.results);
-		gastate.statef.Destroy();
-	}
-}
-
-unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
-	return make_uniq<WindowConstantAggregatorLocalState>(gstate.Cast<WindowConstantAggregatorGlobalState>());
-}
-
-void WindowConstantAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                        const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &gasink = gsink.Cast<WindowConstantAggregatorGlobalState>();
-	const auto &partition_offsets = gasink.partition_offsets;
-	const auto &results = *gasink.results;
-
-	auto begins = FlatVector::GetData<const idx_t>(bounds.data[FRAME_BEGIN]);
-	//	Chunk up the constants and copy them one at a time
-	auto &lcstate = lstate.Cast<WindowConstantAggregatorLocalState>();
-	idx_t matched = 0;
-	idx_t target_offset = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const auto begin = begins[i];
-		//	Find the partition containing [begin, end)
-		while (partition_offsets[lcstate.partition + 1] <= begin) {
-			//	Flush the previous partition's data
-			if (matched) {
-				VectorOperations::Copy(results, result, lcstate.matches, matched, 0, target_offset);
-				target_offset += matched;
-				matched = 0;
-			}
-			++lcstate.partition;
-		}
-
-		lcstate.matches.set_index(matched++, lcstate.partition);
-	}
-
-	//	Flush the last partition
-	if (matched) {
-		// Optimize constant result
-		if (target_offset == 0 && matched == count) {
-			VectorOperations::Copy(results, result, lcstate.matches, 1, 0, target_offset);
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		} else {
-			VectorOperations::Copy(results, result, lcstate.matches, matched, 0, target_offset);
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_custom_aggregator.cpp b/src/duckdb/src/function/window/window_custom_aggregator.cpp
deleted file mode 100644
index 8416e3031..000000000
--- a/src/duckdb/src/function/window/window_custom_aggregator.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "duckdb/function/window/window_custom_aggregator.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowCustomAggregator
-//===--------------------------------------------------------------------===//
-bool WindowCustomAggregator::CanAggregate(const BoundWindowExpression &wexpr, WindowAggregationMode mode) {
-	if (!wexpr.aggregate) {
-		return false;
-	}
-
-	if (!wexpr.aggregate->window) {
-		return false;
-	}
-
-	//	ORDER BY arguments are not currently supported
-	if (!wexpr.arg_orders.empty()) {
-		return false;
-	}
-
-	return (mode < WindowAggregationMode::COMBINE);
-}
-
-WindowCustomAggregator::WindowCustomAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
-    : WindowAggregator(wexpr, shared) {
-}
-
-WindowCustomAggregator::~WindowCustomAggregator() {
-}
-
-class WindowCustomAggregatorState : public WindowAggregatorLocalState {
-public:
-	WindowCustomAggregatorState(const AggregateObject &aggr, const WindowExcludeMode exclude_mode);
-	~WindowCustomAggregatorState() override;
-
-public:
-	//! The aggregate function
-	const AggregateObject aggr;
-	//! Data pointer that contains a single state, shared by all the custom evaluators
-	vector<data_t> state;
-	//! Reused result state container for the window functions
-	Vector statef;
-	//! The frame boundaries, used for the window functions
-	SubFrames frames;
-};
-
-class WindowCustomAggregatorGlobalState : public WindowAggregatorGlobalState {
-public:
-	explicit WindowCustomAggregatorGlobalState(ClientContext &context, const WindowCustomAggregator &aggregator,
-	                                           idx_t group_count)
-	    : WindowAggregatorGlobalState(context, aggregator, group_count), context(context) {
-
-		gcstate = make_uniq<WindowCustomAggregatorState>(aggr, aggregator.exclude_mode);
-	}
-
-	//! Buffer manager for paging custom accelerator data
-	ClientContext &context;
-	//! Traditional packed filter mask for API
-	ValidityMask filter_packed;
-	//! Data pointer that contains a single local state, used for global custom window execution state
-	unique_ptr<WindowCustomAggregatorState> gcstate;
-	//! Partition description for custom window APIs
-	unique_ptr<WindowPartitionInput> partition_input;
-};
-
-WindowCustomAggregatorState::WindowCustomAggregatorState(const AggregateObject &aggr,
-                                                         const WindowExcludeMode exclude_mode)
-    : aggr(aggr), state(aggr.function.state_size(aggr.function)),
-      statef(Value::POINTER(CastPointerToValue(state.data()))), frames(3, {0, 0}) {
-	// if we have a frame-by-frame method, share the single state
-	aggr.function.initialize(aggr.function, state.data());
-
-	InitSubFrames(frames, exclude_mode);
-}
-
-WindowCustomAggregatorState::~WindowCustomAggregatorState() {
-	if (aggr.function.destructor) {
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-		aggr.function.destructor(statef, aggr_input_data, 1);
-	}
-}
-
-unique_ptr<WindowAggregatorState> WindowCustomAggregator::GetGlobalState(ClientContext &context, idx_t group_count,
-                                                                         const ValidityMask &) const {
-	return make_uniq<WindowCustomAggregatorGlobalState>(context, *this, group_count);
-}
-
-void WindowCustomAggregator::Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate,
-                                      CollectionPtr collection, const FrameStats &stats) {
-	//	Single threaded Finalize for now
-	auto &gcsink = gstate.Cast<WindowCustomAggregatorGlobalState>();
-	lock_guard<mutex> gestate_guard(gcsink.lock);
-	if (gcsink.finalized) {
-		return;
-	}
-
-	WindowAggregator::Finalize(gstate, lstate, collection, stats);
-
-	auto inputs = collection->inputs.get();
-	const auto count = collection->size();
-	vector<bool> all_valids;
-	for (auto col_idx : child_idx) {
-		all_valids.push_back(collection->all_valids[col_idx]);
-	}
-	auto &filter_mask = gcsink.filter_mask;
-	auto &filter_packed = gcsink.filter_packed;
-	filter_mask.Pack(filter_packed, filter_mask.Capacity());
-
-	gcsink.partition_input =
-	    make_uniq<WindowPartitionInput>(gcsink.context, inputs, count, child_idx, all_valids, filter_packed, stats);
-
-	if (aggr.function.window_init) {
-		auto &gcstate = *gcsink.gcstate;
-
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), gcstate.allocator);
-		aggr.function.window_init(aggr_input_data, *gcsink.partition_input, gcstate.state.data());
-	}
-
-	++gcsink.finalized;
-}
-
-unique_ptr<WindowAggregatorState> WindowCustomAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
-	return make_uniq<WindowCustomAggregatorState>(aggr, exclude_mode);
-}
-
-void WindowCustomAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                      const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &lcstate = lstate.Cast<WindowCustomAggregatorState>();
-	auto &frames = lcstate.frames;
-	const_data_ptr_t gstate_p = nullptr;
-	auto &gcsink = gsink.Cast<WindowCustomAggregatorGlobalState>();
-	if (gcsink.gcstate) {
-		gstate_p = gcsink.gcstate->state.data();
-	}
-
-	EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) {
-		// Extract the range
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), lstate.allocator);
-		aggr.function.window(aggr_input_data, *gcsink.partition_input, gstate_p, lcstate.state.data(), frames, result,
-		                     i);
-	});
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_distinct_aggregator.cpp b/src/duckdb/src/function/window/window_distinct_aggregator.cpp
deleted file mode 100644
index 1dc940f95..000000000
--- a/src/duckdb/src/function/window/window_distinct_aggregator.cpp
+++ /dev/null
@@ -1,758 +0,0 @@
-#include "duckdb/function/window/window_distinct_aggregator.hpp"
-
-#include "duckdb/common/sort/partition_state.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/execution/merge_sort_tree.hpp"
-#include "duckdb/function/window/window_aggregate_states.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-#include <numeric>
-#include <thread>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowDistinctAggregator
-//===--------------------------------------------------------------------===//
-bool WindowDistinctAggregator::CanAggregate(const BoundWindowExpression &wexpr) {
-	if (!wexpr.aggregate) {
-		return false;
-	}
-
-	return wexpr.distinct && wexpr.exclude_clause == WindowExcludeMode::NO_OTHER && wexpr.arg_orders.empty();
-}
-
-WindowDistinctAggregator::WindowDistinctAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared,
-                                                   ClientContext &context)
-    : WindowAggregator(wexpr, shared), context(context) {
-}
-
-class WindowDistinctAggregatorLocalState;
-
-class WindowDistinctAggregatorGlobalState;
-
-class WindowDistinctSortTree : public MergeSortTree<idx_t, idx_t> {
-public:
-	// prev_idx, input_idx
-	using ZippedTuple = std::tuple<idx_t, idx_t>;
-	using ZippedElements = vector<ZippedTuple>;
-
-	explicit WindowDistinctSortTree(WindowDistinctAggregatorGlobalState &gdastate, idx_t count) : gdastate(gdastate) {
-		//	Set up for parallel build
-		build_level = 0;
-		build_complete = 0;
-		build_run = 0;
-		build_run_length = 1;
-		build_num_runs = count;
-	}
-
-	void Build(WindowDistinctAggregatorLocalState &ldastate);
-
-protected:
-	bool TryNextRun(idx_t &level_idx, idx_t &run_idx);
-	void BuildRun(idx_t level_nr, idx_t i, WindowDistinctAggregatorLocalState &ldastate);
-
-	WindowDistinctAggregatorGlobalState &gdastate;
-};
-
-class WindowDistinctAggregatorGlobalState : public WindowAggregatorGlobalState {
-public:
-	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
-	using LocalSortStatePtr = unique_ptr<LocalSortState>;
-	using ZippedTuple = WindowDistinctSortTree::ZippedTuple;
-	using ZippedElements = WindowDistinctSortTree::ZippedElements;
-
-	WindowDistinctAggregatorGlobalState(ClientContext &context, const WindowDistinctAggregator &aggregator,
-	                                    idx_t group_count);
-
-	//! Compute the block starts
-	void MeasurePayloadBlocks();
-	//! Create a new local sort
-	optional_ptr<LocalSortState> InitializeLocalSort() const;
-
-	//! Patch up the previous index block boundaries
-	void PatchPrevIdcs();
-	bool TryPrepareNextStage(WindowDistinctAggregatorLocalState &lstate);
-
-	//	Single threaded sorting for now
-	ClientContext &context;
-	idx_t memory_per_thread;
-
-	//! Finalize guard
-	mutable mutex lock;
-	//! Finalize stage
-	atomic<PartitionSortStage> stage;
-	//! Tasks launched
-	idx_t total_tasks = 0;
-	//! Tasks launched
-	mutable idx_t tasks_assigned;
-	//! Tasks landed
-	mutable atomic<idx_t> tasks_completed;
-
-	//! The sorted payload data types (partition index)
-	vector<LogicalType> payload_types;
-	//! The aggregate arguments + partition index
-	vector<LogicalType> sort_types;
-
-	//! Sorting operations
-	GlobalSortStatePtr global_sort;
-	//! Local sort set
-	mutable vector<LocalSortStatePtr> local_sorts;
-	//! The block starts (the scanner doesn't know this) plus the total count
-	vector<idx_t> block_starts;
-
-	//! The block boundary seconds
-	mutable ZippedElements seconds;
-	//! The MST with the distinct back pointers
-	mutable MergeSortTree<ZippedTuple> zipped_tree;
-	//! The merge sort tree for the aggregate.
-	WindowDistinctSortTree merge_sort_tree;
-
-	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	WindowAggregateStates levels_flat_native;
-	//! For each level, the starting location in the levels_flat_native array
-	vector<idx_t> levels_flat_start;
-};
-
-WindowDistinctAggregatorGlobalState::WindowDistinctAggregatorGlobalState(ClientContext &context,
-                                                                         const WindowDistinctAggregator &aggregator,
-                                                                         idx_t group_count)
-    : WindowAggregatorGlobalState(context, aggregator, group_count), context(aggregator.context),
-      stage(PartitionSortStage::INIT), tasks_assigned(0), tasks_completed(0), merge_sort_tree(*this, group_count),
-      levels_flat_native(aggr) {
-	payload_types.emplace_back(LogicalType::UBIGINT);
-
-	//	1:	functionComputePrevIdcs(𝑖𝑛)
-	//	2:		sorted ← []
-	//	We sort the aggregate arguments and use the partition index as a tie-breaker.
-	//	TODO: Use a hash table?
-	sort_types = aggregator.arg_types;
-	for (const auto &type : payload_types) {
-		sort_types.emplace_back(type);
-	}
-
-	vector<BoundOrderByNode> orders;
-	for (const auto &type : sort_types) {
-		auto expr = make_uniq<BoundConstantExpression>(Value(type));
-		orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(expr)));
-	}
-
-	RowLayout payload_layout;
-	payload_layout.Initialize(payload_types);
-
-	global_sort = make_uniq<GlobalSortState>(BufferManager::GetBufferManager(context), orders, payload_layout);
-
-	memory_per_thread = PhysicalOperator::GetMaxThreadMemory(context);
-
-	//	6:	prevIdcs ← []
-	//	7:	prevIdcs[0] ← “-”
-	auto &prev_idcs = zipped_tree.Allocate(group_count);
-
-	//	To handle FILTER clauses we make the missing elements
-	//	point to themselves so they won't be counted.
-	for (idx_t i = 0; i < group_count; ++i) {
-		prev_idcs[i] = ZippedTuple(i + 1, i);
-	}
-
-	// compute space required to store aggregation states of merge sort tree
-	// this is one aggregate state per entry per level
-	idx_t internal_nodes = 0;
-	levels_flat_start.push_back(internal_nodes);
-	for (idx_t level_nr = 0; level_nr < zipped_tree.tree.size(); ++level_nr) {
-		internal_nodes += zipped_tree.tree[level_nr].first.size();
-		levels_flat_start.push_back(internal_nodes);
-	}
-	levels_flat_native.Initialize(internal_nodes);
-
-	merge_sort_tree.tree.reserve(zipped_tree.tree.size());
-	for (idx_t level_nr = 0; level_nr < zipped_tree.tree.size(); ++level_nr) {
-		auto &zipped_level = zipped_tree.tree[level_nr].first;
-		WindowDistinctSortTree::Elements level;
-		WindowDistinctSortTree::Offsets cascades;
-		level.resize(zipped_level.size());
-		merge_sort_tree.tree.emplace_back(std::move(level), std::move(cascades));
-	}
-}
-
-optional_ptr<LocalSortState> WindowDistinctAggregatorGlobalState::InitializeLocalSort() const {
-	lock_guard<mutex> local_sort_guard(lock);
-	auto local_sort = make_uniq<LocalSortState>();
-	local_sort->Initialize(*global_sort, global_sort->buffer_manager);
-	++tasks_assigned;
-	local_sorts.emplace_back(std::move(local_sort));
-
-	return local_sorts.back().get();
-}
-
-class WindowDistinctAggregatorLocalState : public WindowAggregatorLocalState {
-public:
-	explicit WindowDistinctAggregatorLocalState(const WindowDistinctAggregatorGlobalState &aggregator);
-
-	void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-	          idx_t filtered);
-	void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
-	void Sorted();
-	void ExecuteTask();
-	void Evaluate(const WindowDistinctAggregatorGlobalState &gdstate, const DataChunk &bounds, Vector &result,
-	              idx_t count, idx_t row_idx);
-
-	//! Thread-local sorting data
-	optional_ptr<LocalSortState> local_sort;
-	//! Finalize stage
-	PartitionSortStage stage = PartitionSortStage::INIT;
-	//! Finalize scan block index
-	idx_t block_idx;
-	//! Thread-local tree aggregation
-	Vector update_v;
-	Vector source_v;
-	Vector target_v;
-	DataChunk leaves;
-	SelectionVector sel;
-
-protected:
-	//! Flush the accumulated intermediate states into the result states
-	void FlushStates();
-
-	//! The aggregator we are working with
-	const WindowDistinctAggregatorGlobalState &gastate;
-	DataChunk sort_chunk;
-	DataChunk payload_chunk;
-	//! Reused result state container for the window functions
-	WindowAggregateStates statef;
-	//! A vector of pointers to "state", used for buffering intermediate aggregates
-	Vector statep;
-	//! Reused state pointers for combining tree elements
-	Vector statel;
-	//! Count of buffered values
-	idx_t flush_count;
-	//! The frame boundaries, used for the window functions
-	SubFrames frames;
-};
-
-WindowDistinctAggregatorLocalState::WindowDistinctAggregatorLocalState(
-    const WindowDistinctAggregatorGlobalState &gastate)
-    : update_v(LogicalType::POINTER), source_v(LogicalType::POINTER), target_v(LogicalType::POINTER), gastate(gastate),
-      statef(gastate.aggr), statep(LogicalType::POINTER), statel(LogicalType::POINTER), flush_count(0) {
-	InitSubFrames(frames, gastate.aggregator.exclude_mode);
-	payload_chunk.Initialize(Allocator::DefaultAllocator(), gastate.payload_types);
-
-	sort_chunk.Initialize(Allocator::DefaultAllocator(), gastate.sort_types);
-	sort_chunk.data.back().Reference(payload_chunk.data[0]);
-
-	gastate.locals++;
-}
-
-unique_ptr<WindowAggregatorState> WindowDistinctAggregator::GetGlobalState(ClientContext &context, idx_t group_count,
-                                                                           const ValidityMask &partition_mask) const {
-	return make_uniq<WindowDistinctAggregatorGlobalState>(context, *this, group_count);
-}
-
-void WindowDistinctAggregator::Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-                                    DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-                                    idx_t filtered) {
-	WindowAggregator::Sink(gsink, lstate, sink_chunk, coll_chunk, input_idx, filter_sel, filtered);
-
-	auto &ldstate = lstate.Cast<WindowDistinctAggregatorLocalState>();
-	ldstate.Sink(sink_chunk, coll_chunk, input_idx, filter_sel, filtered);
-}
-
-void WindowDistinctAggregatorLocalState::Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx,
-                                              optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
-	//	3: 	for i ← 0 to in.size do
-	//	4: 		sorted[i] ← (in[i], i)
-	const auto count = sink_chunk.size();
-	payload_chunk.Reset();
-	auto &sorted_vec = payload_chunk.data[0];
-	auto sorted = FlatVector::GetData<idx_t>(sorted_vec);
-	std::iota(sorted, sorted + count, input_idx);
-
-	// Our arguments are being fully materialised,
-	// but we also need them as sort keys.
-	auto &child_idx = gastate.aggregator.child_idx;
-	for (column_t c = 0; c < child_idx.size(); ++c) {
-		sort_chunk.data[c].Reference(coll_chunk.data[child_idx[c]]);
-	}
-	sort_chunk.data.back().Reference(sorted_vec);
-	sort_chunk.SetCardinality(sink_chunk);
-	payload_chunk.SetCardinality(sort_chunk);
-
-	//	Apply FILTER clause, if any
-	if (filter_sel) {
-		sort_chunk.Slice(*filter_sel, filtered);
-		payload_chunk.Slice(*filter_sel, filtered);
-	}
-
-	if (!local_sort) {
-		local_sort = gastate.InitializeLocalSort();
-	}
-
-	local_sort->SinkChunk(sort_chunk, payload_chunk);
-
-	if (local_sort->SizeInBytes() > gastate.memory_per_thread) {
-		local_sort->Sort(*gastate.global_sort, true);
-	}
-}
-
-void WindowDistinctAggregatorLocalState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
-	WindowAggregatorLocalState::Finalize(gastate, collection);
-
-	//! Input data chunk, used for leaf segment aggregation
-	leaves.Initialize(Allocator::DefaultAllocator(), cursor->chunk.GetTypes());
-	sel.Initialize();
-}
-
-void WindowDistinctAggregatorLocalState::ExecuteTask() {
-	auto &global_sort = *gastate.global_sort;
-	switch (stage) {
-	case PartitionSortStage::SCAN:
-		global_sort.AddLocalState(*gastate.local_sorts[block_idx]);
-		break;
-	case PartitionSortStage::MERGE: {
-		MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
-		merge_sorter.PerformInMergeRound();
-		break;
-	}
-	case PartitionSortStage::SORTED:
-		Sorted();
-		break;
-	default:
-		break;
-	}
-
-	++gastate.tasks_completed;
-}
-
-void WindowDistinctAggregatorGlobalState::MeasurePayloadBlocks() {
-	const auto &blocks = global_sort->sorted_blocks[0]->payload_data->data_blocks;
-	idx_t count = 0;
-	for (const auto &block : blocks) {
-		block_starts.emplace_back(count);
-		count += block->count;
-	}
-	block_starts.emplace_back(count);
-}
-
-bool WindowDistinctAggregatorGlobalState::TryPrepareNextStage(WindowDistinctAggregatorLocalState &lstate) {
-	lock_guard<mutex> stage_guard(lock);
-
-	switch (stage.load()) {
-	case PartitionSortStage::INIT:
-		//	5: Sort sorted lexicographically increasing
-		total_tasks = local_sorts.size();
-		tasks_assigned = 0;
-		tasks_completed = 0;
-		lstate.stage = stage = PartitionSortStage::SCAN;
-		lstate.block_idx = tasks_assigned++;
-		return true;
-	case PartitionSortStage::SCAN:
-		// Process all the local sorts
-		if (tasks_assigned < total_tasks) {
-			lstate.stage = PartitionSortStage::SCAN;
-			lstate.block_idx = tasks_assigned++;
-			return true;
-		} else if (tasks_completed < tasks_assigned) {
-			return false;
-		}
-		global_sort->PrepareMergePhase();
-		if (!(global_sort->sorted_blocks.size() / 2)) {
-			if (global_sort->sorted_blocks.empty()) {
-				lstate.stage = stage = PartitionSortStage::FINISHED;
-				return true;
-			}
-			MeasurePayloadBlocks();
-			seconds.resize(block_starts.size() - 1);
-			total_tasks = seconds.size();
-			tasks_completed = 0;
-			tasks_assigned = 0;
-			lstate.stage = stage = PartitionSortStage::SORTED;
-			lstate.block_idx = tasks_assigned++;
-			return true;
-		}
-		global_sort->InitializeMergeRound();
-		lstate.stage = stage = PartitionSortStage::MERGE;
-		total_tasks = locals;
-		tasks_assigned = 1;
-		tasks_completed = 0;
-		return true;
-	case PartitionSortStage::MERGE:
-		if (tasks_assigned < total_tasks) {
-			lstate.stage = PartitionSortStage::MERGE;
-			++tasks_assigned;
-			return true;
-		} else if (tasks_completed < tasks_assigned) {
-			return false;
-		}
-		global_sort->CompleteMergeRound(true);
-		if (!(global_sort->sorted_blocks.size() / 2)) {
-			MeasurePayloadBlocks();
-			seconds.resize(block_starts.size() - 1);
-			total_tasks = seconds.size();
-			tasks_completed = 0;
-			tasks_assigned = 0;
-			lstate.stage = stage = PartitionSortStage::SORTED;
-			lstate.block_idx = tasks_assigned++;
-			return true;
-		}
-		global_sort->InitializeMergeRound();
-		lstate.stage = PartitionSortStage::MERGE;
-		total_tasks = locals;
-		tasks_assigned = 1;
-		tasks_completed = 0;
-		return true;
-	case PartitionSortStage::SORTED:
-		if (tasks_assigned < total_tasks) {
-			lstate.stage = PartitionSortStage::SORTED;
-			lstate.block_idx = tasks_assigned++;
-			return true;
-		} else if (tasks_completed < tasks_assigned) {
-			lstate.stage = PartitionSortStage::FINISHED;
-			// Sleep while other tasks finish
-			return false;
-		}
-		// Last task patches the boundaries
-		PatchPrevIdcs();
-		break;
-	default:
-		break;
-	}
-
-	lstate.stage = stage = PartitionSortStage::FINISHED;
-
-	return true;
-}
-
-void WindowDistinctAggregator::Finalize(WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                        CollectionPtr collection, const FrameStats &stats) {
-	auto &gdsink = gsink.Cast<WindowDistinctAggregatorGlobalState>();
-	auto &ldstate = lstate.Cast<WindowDistinctAggregatorLocalState>();
-	ldstate.Finalize(gdsink, collection);
-
-	// Sort, merge and build the tree in parallel
-	while (gdsink.stage.load() != PartitionSortStage::FINISHED) {
-		if (gdsink.TryPrepareNextStage(ldstate)) {
-			ldstate.ExecuteTask();
-		} else {
-			std::this_thread::yield();
-		}
-	}
-
-	//	These are a parallel implementations,
-	//	so every thread can call them.
-	gdsink.zipped_tree.Build();
-	gdsink.merge_sort_tree.Build(ldstate);
-
-	++gdsink.finalized;
-}
-
-void WindowDistinctAggregatorLocalState::Sorted() {
-	using ZippedTuple = WindowDistinctAggregatorGlobalState::ZippedTuple;
-	auto &global_sort = gastate.global_sort;
-	auto &prev_idcs = gastate.zipped_tree.LowestLevel();
-	auto &aggregator = gastate.aggregator;
-	auto &scan_chunk = payload_chunk;
-
-	auto scanner = make_uniq<PayloadScanner>(*global_sort, block_idx);
-	const auto in_size = gastate.block_starts.at(block_idx + 1);
-	scanner->Scan(scan_chunk);
-	idx_t scan_idx = 0;
-
-	auto *input_idx = FlatVector::GetData<idx_t>(scan_chunk.data[0]);
-	idx_t i = 0;
-
-	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
-	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
-	auto prefix_layout = global_sort->sort_layout.GetPrefixComparisonLayout(aggregator.arg_types.size());
-
-	const auto block_begin = gastate.block_starts.at(block_idx);
-	if (!block_begin) {
-		// First block, so set up initial sentinel
-		i = input_idx[scan_idx++];
-		prev_idcs[i] = ZippedTuple(0, i);
-		std::get<0>(gastate.seconds[block_idx]) = i;
-	} else {
-		// Move to the to end of the previous block
-		// so we can record the comparison result for the first row
-		curr.SetIndex(block_begin - 1);
-		prev.SetIndex(block_begin - 1);
-		scan_idx = 0;
-		std::get<0>(gastate.seconds[block_idx]) = input_idx[scan_idx];
-	}
-
-	//	8:	for i ← 1 to in.size do
-	for (++curr; curr.GetIndex() < in_size; ++curr, ++prev) {
-		//	Scan second one chunk at a time
-		//	Note the scan is one behind the iterators
-		if (scan_idx >= scan_chunk.size()) {
-			scan_chunk.Reset();
-			scanner->Scan(scan_chunk);
-			scan_idx = 0;
-			input_idx = FlatVector::GetData<idx_t>(scan_chunk.data[0]);
-		}
-		auto second = i;
-		i = input_idx[scan_idx++];
-
-		int lt = 0;
-		if (prefix_layout.all_constant) {
-			lt = FastMemcmp(prev.entry_ptr, curr.entry_ptr, prefix_layout.comparison_size);
-		} else {
-			lt = Comparators::CompareTuple(prev.scan, curr.scan, prev.entry_ptr, curr.entry_ptr, prefix_layout,
-			                               prev.external);
-		}
-
-		//	9:	if sorted[i].first == sorted[i-1].first then
-		//	10:		prevIdcs[i] ← sorted[i-1].second
-		//	11:	else
-		//	12:		prevIdcs[i] ← “-”
-		if (!lt) {
-			prev_idcs[i] = ZippedTuple(second + 1, i);
-		} else {
-			prev_idcs[i] = ZippedTuple(0, i);
-		}
-	}
-
-	// Save the last value of i for patching up the block boundaries
-	std::get<1>(gastate.seconds[block_idx]) = i;
-}
-
-void WindowDistinctAggregatorGlobalState::PatchPrevIdcs() {
-	//	13:	return prevIdcs
-
-	// Patch up the indices at block boundaries
-	// (We don't need to patch block 0.)
-	auto &prev_idcs = zipped_tree.LowestLevel();
-	for (idx_t block_idx = 1; block_idx < seconds.size(); ++block_idx) {
-		// We only need to patch if the first index in the block
-		// was a back link to the previous block (10:)
-		auto i = std::get<0>(seconds.at(block_idx));
-		if (std::get<0>(prev_idcs[i])) {
-			auto second = std::get<1>(seconds.at(block_idx - 1));
-			prev_idcs[i] = ZippedTuple(second + 1, i);
-		}
-	}
-}
-
-bool WindowDistinctSortTree::TryNextRun(idx_t &level_idx, idx_t &run_idx) {
-	const auto fanout = FANOUT;
-
-	lock_guard<mutex> stage_guard(build_lock);
-
-	//	Verify we are not done
-	if (build_level >= tree.size()) {
-		return false;
-	}
-
-	// Finished with this level?
-	if (build_complete >= build_num_runs) {
-		auto &zipped_tree = gdastate.zipped_tree;
-		std::swap(tree[build_level].second, zipped_tree.tree[build_level].second);
-
-		++build_level;
-		if (build_level >= tree.size()) {
-			zipped_tree.tree.clear();
-			return false;
-		}
-
-		const auto count = LowestLevel().size();
-		build_run_length *= fanout;
-		build_num_runs = (count + build_run_length - 1) / build_run_length;
-		build_run = 0;
-		build_complete = 0;
-	}
-
-	// If all runs are in flight,
-	// yield until the next level is ready
-	if (build_run >= build_num_runs) {
-		return false;
-	}
-
-	level_idx = build_level;
-	run_idx = build_run++;
-
-	return true;
-}
-
-void WindowDistinctSortTree::Build(WindowDistinctAggregatorLocalState &ldastate) {
-	//	Fan in parent levels until we are at the top
-	//	Note that we don't build the top layer as that would just be all the data.
-	while (build_level.load() < tree.size()) {
-		idx_t level_idx;
-		idx_t run_idx;
-		if (TryNextRun(level_idx, run_idx)) {
-			BuildRun(level_idx, run_idx, ldastate);
-		} else {
-			std::this_thread::yield();
-		}
-	}
-}
-
-void WindowDistinctSortTree::BuildRun(idx_t level_nr, idx_t run_idx, WindowDistinctAggregatorLocalState &ldastate) {
-	auto &aggr = gdastate.aggr;
-	auto &allocator = gdastate.allocator;
-	auto &inputs = ldastate.cursor->chunk;
-	auto &levels_flat_native = gdastate.levels_flat_native;
-
-	//! Input data chunk, used for leaf segment aggregation
-	auto &leaves = ldastate.leaves;
-	auto &sel = ldastate.sel;
-
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-
-	//! The states to update
-	auto &update_v = ldastate.update_v;
-	auto updates = FlatVector::GetData<data_ptr_t>(update_v);
-
-	auto &source_v = ldastate.source_v;
-	auto sources = FlatVector::GetData<data_ptr_t>(source_v);
-	auto &target_v = ldastate.target_v;
-	auto targets = FlatVector::GetData<data_ptr_t>(target_v);
-
-	auto &zipped_tree = gdastate.zipped_tree;
-	auto &zipped_level = zipped_tree.tree[level_nr].first;
-	auto &level = tree[level_nr].first;
-
-	//	Reset the combine state
-	idx_t nupdate = 0;
-	idx_t ncombine = 0;
-	data_ptr_t prev_state = nullptr;
-	idx_t i = run_idx * build_run_length;
-	auto next_limit = MinValue<idx_t>(zipped_level.size(), i + build_run_length);
-	idx_t levels_flat_offset = level_nr * zipped_level.size() + i;
-	for (auto j = i; j < next_limit; ++j) {
-		//	Initialise the next aggregate
-		auto curr_state = levels_flat_native.GetStatePtr(levels_flat_offset++);
-
-		//	Update this state (if it matches)
-		const auto prev_idx = std::get<0>(zipped_level[j]);
-		level[j] = prev_idx;
-		if (prev_idx < i + 1) {
-			const auto update_idx = std::get<1>(zipped_level[j]);
-			if (!ldastate.cursor->RowIsVisible(update_idx)) {
-				// 	Flush if we have to move the cursor
-				//	Push the updates first so they propagate
-				leaves.Reference(inputs);
-				leaves.Slice(sel, nupdate);
-				aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), update_v, nupdate);
-				nupdate = 0;
-
-				//	Combine the states sequentially
-				aggr.function.combine(source_v, target_v, aggr_input_data, ncombine);
-				ncombine = 0;
-
-				// Move the update into range.
-				ldastate.cursor->Seek(update_idx);
-			}
-
-			updates[nupdate] = curr_state;
-			//	input_idx
-			sel[nupdate] = ldastate.cursor->RowOffset(update_idx);
-			++nupdate;
-		}
-
-		//	Merge the previous state (if any)
-		if (prev_state) {
-			sources[ncombine] = prev_state;
-			targets[ncombine] = curr_state;
-			++ncombine;
-		}
-		prev_state = curr_state;
-
-		//	Flush the states if one is maxed out.
-		if (MaxValue<idx_t>(ncombine, nupdate) >= STANDARD_VECTOR_SIZE) {
-			//	Push the updates first so they propagate
-			leaves.Reference(inputs);
-			leaves.Slice(sel, nupdate);
-			aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), update_v, nupdate);
-			nupdate = 0;
-
-			//	Combine the states sequentially
-			aggr.function.combine(source_v, target_v, aggr_input_data, ncombine);
-			ncombine = 0;
-		}
-	}
-
-	//	Flush any remaining states
-	if (ncombine || nupdate) {
-		//	Push  the updates
-		leaves.Reference(inputs);
-		leaves.Slice(sel, nupdate);
-		aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), update_v, nupdate);
-		nupdate = 0;
-
-		//	Combine the states sequentially
-		aggr.function.combine(source_v, target_v, aggr_input_data, ncombine);
-		ncombine = 0;
-	}
-
-	++build_complete;
-}
-
-void WindowDistinctAggregatorLocalState::FlushStates() {
-	if (!flush_count) {
-		return;
-	}
-
-	const auto &aggr = gastate.aggr;
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	statel.Verify(flush_count);
-	aggr.function.combine(statel, statep, aggr_input_data, flush_count);
-
-	flush_count = 0;
-}
-
-void WindowDistinctAggregatorLocalState::Evaluate(const WindowDistinctAggregatorGlobalState &gdstate,
-                                                  const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) {
-	auto ldata = FlatVector::GetData<const_data_ptr_t>(statel);
-	auto pdata = FlatVector::GetData<data_ptr_t>(statep);
-
-	const auto &merge_sort_tree = gdstate.merge_sort_tree;
-	const auto &levels_flat_native = gdstate.levels_flat_native;
-	const auto exclude_mode = gdstate.aggregator.exclude_mode;
-
-	//	Build the finalise vector that just points to the result states
-	statef.Initialize(count);
-
-	WindowAggregator::EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t rid) {
-		auto agg_state = statef.GetStatePtr(rid);
-
-		//	TODO: Extend AggregateLowerBound to handle subframes, just like SelectNth.
-		const auto lower = frames[0].start;
-		const auto upper = frames[0].end;
-		merge_sort_tree.AggregateLowerBound(lower, upper, lower + 1,
-		                                    [&](idx_t level, const idx_t run_begin, const idx_t run_pos) {
-			                                    if (run_pos != run_begin) {
-				                                    //	Find the source aggregate
-				                                    // Buffer a merge of the indicated state into the current state
-				                                    const auto agg_idx = gdstate.levels_flat_start[level] + run_pos - 1;
-				                                    const auto running_agg = levels_flat_native.GetStatePtr(agg_idx);
-				                                    pdata[flush_count] = agg_state;
-				                                    ldata[flush_count++] = running_agg;
-				                                    if (flush_count >= STANDARD_VECTOR_SIZE) {
-					                                    FlushStates();
-				                                    }
-			                                    }
-		                                    });
-	});
-
-	//	Flush the final states
-	FlushStates();
-
-	//	Finalise the result aggregates and write to the result
-	statef.Finalize(result);
-	statef.Destroy();
-}
-
-unique_ptr<WindowAggregatorState> WindowDistinctAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
-	return make_uniq<WindowDistinctAggregatorLocalState>(gstate.Cast<const WindowDistinctAggregatorGlobalState>());
-}
-
-void WindowDistinctAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                        const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
-
-	const auto &gdstate = gsink.Cast<WindowDistinctAggregatorGlobalState>();
-	auto &ldstate = lstate.Cast<WindowDistinctAggregatorLocalState>();
-	ldstate.Evaluate(gdstate, bounds, result, count, row_idx);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_executor.cpp b/src/duckdb/src/function/window/window_executor.cpp
deleted file mode 100644
index faa7215e4..000000000
--- a/src/duckdb/src/function/window/window_executor.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "duckdb/function/window/window_executor.hpp"
-
-#include "duckdb/function/window/window_shared_expressions.hpp"
-
-#include "duckdb/common/array.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowExecutorBoundsState
-//===--------------------------------------------------------------------===//
-WindowExecutorBoundsState::WindowExecutorBoundsState(const WindowExecutorGlobalState &gstate)
-    : WindowExecutorLocalState(gstate), partition_mask(gstate.partition_mask), order_mask(gstate.order_mask),
-      state(gstate.executor.wexpr, gstate.payload_count) {
-	vector<LogicalType> bounds_types(8, LogicalType(LogicalTypeId::UBIGINT));
-	bounds.Initialize(Allocator::Get(gstate.executor.context), bounds_types);
-}
-
-void WindowExecutorBoundsState::UpdateBounds(WindowExecutorGlobalState &gstate, idx_t row_idx, DataChunk &eval_chunk,
-                                             optional_ptr<WindowCursor> range) {
-	// Evaluate the row-level arguments
-	WindowInputExpression boundary_start(eval_chunk, gstate.executor.boundary_start_idx);
-	WindowInputExpression boundary_end(eval_chunk, gstate.executor.boundary_end_idx);
-
-	const auto count = eval_chunk.size();
-	state.Bounds(bounds, row_idx, range, count, boundary_start, boundary_end, partition_mask, order_mask);
-}
-
-//===--------------------------------------------------------------------===//
-// WindowExecutor
-//===--------------------------------------------------------------------===//
-WindowExecutor::WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared)
-    : wexpr(wexpr), context(context),
-      range_expr((WindowBoundariesState::HasPrecedingRange(wexpr) || WindowBoundariesState::HasFollowingRange(wexpr))
-                     ? wexpr.orders[0].expression.get()
-                     : nullptr) {
-	if (range_expr) {
-		range_idx = shared.RegisterCollection(wexpr.orders[0].expression, false);
-	}
-
-	boundary_start_idx = shared.RegisterEvaluate(wexpr.start_expr);
-	boundary_end_idx = shared.RegisterEvaluate(wexpr.end_expr);
-}
-
-void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &eval_chunk, Vector &result, WindowExecutorLocalState &lstate,
-                              WindowExecutorGlobalState &gstate) const {
-	auto &lbstate = lstate.Cast<WindowExecutorBoundsState>();
-	lbstate.UpdateBounds(gstate, row_idx, eval_chunk, lstate.range_cursor);
-
-	const auto count = eval_chunk.size();
-	EvaluateInternal(gstate, lstate, eval_chunk, result, count, row_idx);
-
-	result.Verify(count);
-}
-
-WindowExecutorGlobalState::WindowExecutorGlobalState(const WindowExecutor &executor, const idx_t payload_count,
-                                                     const ValidityMask &partition_mask, const ValidityMask &order_mask)
-    : executor(executor), payload_count(payload_count), partition_mask(partition_mask), order_mask(order_mask) {
-	for (const auto &child : executor.wexpr.children) {
-		arg_types.emplace_back(child->return_type);
-	}
-}
-
-WindowExecutorLocalState::WindowExecutorLocalState(const WindowExecutorGlobalState &gstate) {
-}
-
-void WindowExecutorLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-                                    idx_t input_idx) {
-}
-
-void WindowExecutorLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) {
-	const auto range_idx = gstate.executor.range_idx;
-	if (range_idx != DConstants::INVALID_INDEX) {
-		range_cursor = make_uniq<WindowCursor>(*collection, range_idx);
-	}
-}
-
-unique_ptr<WindowExecutorGlobalState> WindowExecutor::GetGlobalState(const idx_t payload_count,
-                                                                     const ValidityMask &partition_mask,
-                                                                     const ValidityMask &order_mask) const {
-	return make_uniq<WindowExecutorGlobalState>(*this, payload_count, partition_mask, order_mask);
-}
-
-unique_ptr<WindowExecutorLocalState> WindowExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	return make_uniq<WindowExecutorBoundsState>(gstate);
-}
-
-void WindowExecutor::Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx,
-                          WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate) const {
-	lstate.Sink(gstate, sink_chunk, coll_chunk, input_idx);
-}
-
-void WindowExecutor::Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                              CollectionPtr collection) const {
-	lstate.Finalize(gstate, collection);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_index_tree.cpp b/src/duckdb/src/function/window/window_index_tree.cpp
deleted file mode 100644
index 5791b2af7..000000000
--- a/src/duckdb/src/function/window/window_index_tree.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/function/window/window_index_tree.hpp"
-
-#include <thread>
-#include <utility>
-
-namespace duckdb {
-
-WindowIndexTree::WindowIndexTree(ClientContext &context, const vector<BoundOrderByNode> &orders,
-                                 const vector<column_t> &sort_idx, const idx_t count)
-    : WindowMergeSortTree(context, orders, sort_idx, count) {
-}
-
-WindowIndexTree::WindowIndexTree(ClientContext &context, const BoundOrderModifier &order_bys,
-                                 const vector<column_t> &sort_idx, const idx_t count)
-    : WindowIndexTree(context, order_bys.orders, sort_idx, count) {
-}
-
-unique_ptr<WindowAggregatorState> WindowIndexTree::GetLocalState() {
-	return make_uniq<WindowIndexTreeLocalState>(*this);
-}
-
-WindowIndexTreeLocalState::WindowIndexTreeLocalState(WindowIndexTree &index_tree)
-    : WindowMergeSortTreeLocalState(index_tree), index_tree(index_tree) {
-}
-
-void WindowIndexTreeLocalState::BuildLeaves() {
-	auto &global_sort = *index_tree.global_sort;
-	if (global_sort.sorted_blocks.empty()) {
-		return;
-	}
-
-	PayloadScanner scanner(global_sort, build_task);
-	idx_t row_idx = index_tree.block_starts[build_task];
-	for (;;) {
-		payload_chunk.Reset();
-		scanner.Scan(payload_chunk);
-		const auto count = payload_chunk.size();
-		if (count == 0) {
-			break;
-		}
-		auto &indices = payload_chunk.data[0];
-		if (index_tree.mst32) {
-			auto &sorted = index_tree.mst32->LowestLevel();
-			auto data = FlatVector::GetData<uint32_t>(indices);
-			std::copy(data, data + count, sorted.data() + row_idx);
-		} else {
-			auto &sorted = index_tree.mst64->LowestLevel();
-			auto data = FlatVector::GetData<uint64_t>(indices);
-			std::copy(data, data + count, sorted.data() + row_idx);
-		}
-		row_idx += count;
-	}
-}
-
-idx_t WindowIndexTree::SelectNth(const SubFrames &frames, idx_t n) const {
-	if (mst32) {
-		return mst32->NthElement(mst32->SelectNth(frames, n));
-	} else {
-		return mst64->NthElement(mst64->SelectNth(frames, n));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_merge_sort_tree.cpp b/src/duckdb/src/function/window/window_merge_sort_tree.cpp
deleted file mode 100644
index ef22694c4..000000000
--- a/src/duckdb/src/function/window/window_merge_sort_tree.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-#include "duckdb/function/window/window_merge_sort_tree.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-#include <thread>
-#include <utility>
-
-namespace duckdb {
-
-WindowMergeSortTree::WindowMergeSortTree(ClientContext &context, const vector<BoundOrderByNode> &orders,
-                                         const vector<column_t> &sort_idx, const idx_t count, bool unique)
-    : context(context), memory_per_thread(PhysicalOperator::GetMaxThreadMemory(context)), sort_idx(sort_idx),
-      build_stage(PartitionSortStage::INIT), tasks_completed(0) {
-	// Sort the unfiltered indices by the orders
-	const auto force_external = ClientConfig::GetConfig(context).force_external;
-	LogicalType index_type;
-	if (count < std::numeric_limits<uint32_t>::max() && !force_external) {
-		index_type = LogicalType::INTEGER;
-		mst32 = make_uniq<MergeSortTree32>();
-	} else {
-		index_type = LogicalType::BIGINT;
-		mst64 = make_uniq<MergeSortTree64>();
-	}
-
-	vector<LogicalType> payload_types;
-	payload_types.emplace_back(index_type);
-
-	RowLayout payload_layout;
-	payload_layout.Initialize(payload_types);
-
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	if (unique) {
-		vector<BoundOrderByNode> unique_orders;
-		for (const auto &order : orders) {
-			unique_orders.emplace_back(order.Copy());
-		}
-		auto unique_expr = make_uniq<BoundConstantExpression>(Value(index_type));
-		const auto order_type = OrderType::ASCENDING;
-		const auto order_by_type = OrderByNullType::NULLS_LAST;
-		unique_orders.emplace_back(BoundOrderByNode(order_type, order_by_type, std::move(unique_expr)));
-		global_sort = make_uniq<GlobalSortState>(buffer_manager, unique_orders, payload_layout);
-	} else {
-		global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
-	}
-	global_sort->external = force_external;
-}
-
-optional_ptr<LocalSortState> WindowMergeSortTree::AddLocalSort() {
-	lock_guard<mutex> local_sort_guard(lock);
-	auto local_sort = make_uniq<LocalSortState>();
-	local_sort->Initialize(*global_sort, global_sort->buffer_manager);
-	local_sorts.emplace_back(std::move(local_sort));
-
-	return local_sorts.back().get();
-}
-
-WindowMergeSortTreeLocalState::WindowMergeSortTreeLocalState(WindowMergeSortTree &window_tree)
-    : window_tree(window_tree) {
-	sort_chunk.Initialize(window_tree.context, window_tree.global_sort->sort_layout.logical_types);
-	payload_chunk.Initialize(window_tree.context, window_tree.global_sort->payload_layout.GetTypes());
-	local_sort = window_tree.AddLocalSort();
-}
-
-void WindowMergeSortTreeLocalState::SinkChunk(DataChunk &chunk, const idx_t row_idx,
-                                              optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
-	//	Sequence the payload column
-	auto &indices = payload_chunk.data[0];
-	payload_chunk.SetCardinality(chunk);
-	indices.Sequence(int64_t(row_idx), 1, payload_chunk.size());
-
-	//	Reference the sort columns
-	auto &sort_idx = window_tree.sort_idx;
-	for (column_t c = 0; c < sort_idx.size(); ++c) {
-		sort_chunk.data[c].Reference(chunk.data[sort_idx[c]]);
-	}
-	// Add the row numbers if we are uniquifying
-	if (sort_idx.size() < sort_chunk.ColumnCount()) {
-		sort_chunk.data[sort_idx.size()].Reference(indices);
-	}
-	sort_chunk.SetCardinality(chunk);
-
-	//	Apply FILTER clause, if any
-	if (filter_sel) {
-		sort_chunk.Slice(*filter_sel, filtered);
-		payload_chunk.Slice(*filter_sel, filtered);
-	}
-
-	local_sort->SinkChunk(sort_chunk, payload_chunk);
-
-	//	Flush if we have too much data
-	if (local_sort->SizeInBytes() > window_tree.memory_per_thread) {
-		local_sort->Sort(*window_tree.global_sort, true);
-	}
-}
-
-void WindowMergeSortTreeLocalState::ExecuteSortTask() {
-	switch (build_stage) {
-	case PartitionSortStage::SCAN:
-		window_tree.global_sort->AddLocalState(*window_tree.local_sorts[build_task]);
-		break;
-	case PartitionSortStage::MERGE: {
-		auto &global_sort = *window_tree.global_sort;
-		MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
-		merge_sorter.PerformInMergeRound();
-		break;
-	}
-	case PartitionSortStage::SORTED:
-		BuildLeaves();
-		break;
-	default:
-		break;
-	}
-
-	++window_tree.tasks_completed;
-}
-
-idx_t WindowMergeSortTree::MeasurePayloadBlocks() {
-	const auto &blocks = global_sort->sorted_blocks[0]->payload_data->data_blocks;
-	idx_t count = 0;
-	for (const auto &block : blocks) {
-		block_starts.emplace_back(count);
-		count += block->count;
-	}
-	block_starts.emplace_back(count);
-
-	// Allocate the leaves.
-	if (mst32) {
-		mst32->Allocate(count);
-		mst32->LowestLevel().resize(count);
-	} else if (mst64) {
-		mst64->Allocate(count);
-		mst64->LowestLevel().resize(count);
-	}
-
-	return count;
-}
-
-void WindowMergeSortTreeLocalState::BuildLeaves() {
-	auto &global_sort = *window_tree.global_sort;
-	if (global_sort.sorted_blocks.empty()) {
-		return;
-	}
-
-	PayloadScanner scanner(global_sort, build_task);
-	idx_t row_idx = window_tree.block_starts[build_task];
-	for (;;) {
-		payload_chunk.Reset();
-		scanner.Scan(payload_chunk);
-		const auto count = payload_chunk.size();
-		if (count == 0) {
-			break;
-		}
-		auto &indices = payload_chunk.data[0];
-		if (window_tree.mst32) {
-			auto &sorted = window_tree.mst32->LowestLevel();
-			auto data = FlatVector::GetData<uint32_t>(indices);
-			std::copy(data, data + count, sorted.data() + row_idx);
-		} else {
-			auto &sorted = window_tree.mst64->LowestLevel();
-			auto data = FlatVector::GetData<uint64_t>(indices);
-			std::copy(data, data + count, sorted.data() + row_idx);
-		}
-		row_idx += count;
-	}
-}
-
-void WindowMergeSortTree::CleanupSort() {
-	global_sort.reset();
-	local_sorts.clear();
-}
-
-bool WindowMergeSortTree::TryPrepareSortStage(WindowMergeSortTreeLocalState &lstate) {
-	lock_guard<mutex> stage_guard(lock);
-
-	switch (build_stage.load()) {
-	case PartitionSortStage::INIT:
-		total_tasks = local_sorts.size();
-		tasks_assigned = 0;
-		tasks_completed = 0;
-		lstate.build_stage = build_stage = PartitionSortStage::SCAN;
-		lstate.build_task = tasks_assigned++;
-		return true;
-	case PartitionSortStage::SCAN:
-		// Process all the local sorts
-		if (tasks_assigned < total_tasks) {
-			lstate.build_stage = PartitionSortStage::SCAN;
-			lstate.build_task = tasks_assigned++;
-			return true;
-		} else if (tasks_completed < tasks_assigned) {
-			return false;
-		}
-		global_sort->PrepareMergePhase();
-		if (!(global_sort->sorted_blocks.size() / 2)) {
-			if (global_sort->sorted_blocks.empty()) {
-				lstate.build_stage = build_stage = PartitionSortStage::FINISHED;
-				return true;
-			}
-			MeasurePayloadBlocks();
-			total_tasks = block_starts.size() - 1;
-			tasks_completed = 0;
-			tasks_assigned = 0;
-			lstate.build_stage = build_stage = PartitionSortStage::SORTED;
-			lstate.build_task = tasks_assigned++;
-			return true;
-		}
-		global_sort->InitializeMergeRound();
-		lstate.build_stage = build_stage = PartitionSortStage::MERGE;
-		total_tasks = local_sorts.size();
-		tasks_assigned = 1;
-		tasks_completed = 0;
-		return true;
-	case PartitionSortStage::MERGE:
-		if (tasks_assigned < total_tasks) {
-			lstate.build_stage = PartitionSortStage::MERGE;
-			++tasks_assigned;
-			return true;
-		} else if (tasks_completed < tasks_assigned) {
-			return false;
-		}
-		global_sort->CompleteMergeRound(true);
-		if (!(global_sort->sorted_blocks.size() / 2)) {
-			MeasurePayloadBlocks();
-			total_tasks = block_starts.size() - 1;
-			tasks_completed = 0;
-			tasks_assigned = 0;
-			lstate.build_stage = build_stage = PartitionSortStage::SORTED;
-			lstate.build_task = tasks_assigned++;
-			return true;
-		}
-		global_sort->InitializeMergeRound();
-		lstate.build_stage = PartitionSortStage::MERGE;
-		total_tasks = local_sorts.size();
-		tasks_assigned = 1;
-		tasks_completed = 0;
-		return true;
-	case PartitionSortStage::SORTED:
-		if (tasks_assigned < total_tasks) {
-			lstate.build_stage = PartitionSortStage::SORTED;
-			lstate.build_task = tasks_assigned++;
-			return true;
-		} else if (tasks_completed < tasks_assigned) {
-			lstate.build_stage = PartitionSortStage::FINISHED;
-			// Sleep while other tasks finish
-			return false;
-		}
-		CleanupSort();
-		break;
-	default:
-		break;
-	}
-
-	lstate.build_stage = build_stage = PartitionSortStage::FINISHED;
-
-	return true;
-}
-
-void WindowMergeSortTreeLocalState::Sort() {
-	// Sort, merge and build the tree in parallel
-	while (window_tree.build_stage.load() != PartitionSortStage::FINISHED) {
-		if (window_tree.TryPrepareSortStage(*this)) {
-			ExecuteSortTask();
-		} else {
-			std::this_thread::yield();
-		}
-	}
-}
-
-void WindowMergeSortTree::Build() {
-	if (mst32) {
-		mst32->Build();
-	} else {
-		mst64->Build();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_naive_aggregator.cpp b/src/duckdb/src/function/window/window_naive_aggregator.cpp
deleted file mode 100644
index 448639e77..000000000
--- a/src/duckdb/src/function/window/window_naive_aggregator.cpp
+++ /dev/null
@@ -1,361 +0,0 @@
-#include "duckdb/function/window/window_naive_aggregator.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/function/window/window_collection.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/function/window/window_aggregate_function.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowNaiveAggregator
-//===--------------------------------------------------------------------===//
-WindowNaiveAggregator::WindowNaiveAggregator(const WindowAggregateExecutor &executor, WindowSharedExpressions &shared)
-    : WindowAggregator(executor.wexpr, shared), executor(executor) {
-
-	for (const auto &order : wexpr.arg_orders) {
-		arg_order_idx.emplace_back(shared.RegisterCollection(order.expression, false));
-	}
-}
-
-WindowNaiveAggregator::~WindowNaiveAggregator() {
-}
-
-class WindowNaiveState : public WindowAggregatorLocalState {
-public:
-	struct HashRow {
-		explicit HashRow(WindowNaiveState &state) : state(state) {
-		}
-
-		inline size_t operator()(const idx_t &i) const {
-			return state.Hash(i);
-		}
-
-		WindowNaiveState &state;
-	};
-
-	struct EqualRow {
-		explicit EqualRow(WindowNaiveState &state) : state(state) {
-		}
-
-		inline bool operator()(const idx_t &lhs, const idx_t &rhs) const {
-			return state.KeyEqual(lhs, rhs);
-		}
-
-		WindowNaiveState &state;
-	};
-
-	using RowSet = std::unordered_set<idx_t, HashRow, EqualRow>;
-
-	explicit WindowNaiveState(const WindowNaiveAggregator &gsink);
-
-	void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
-
-	void Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx);
-
-protected:
-	//! Flush the accumulated intermediate states into the result states
-	void FlushStates(const WindowAggregatorGlobalState &gsink);
-
-	//! Hashes a value for the hash table
-	size_t Hash(idx_t rid);
-	//! Compares two values for the hash table
-	bool KeyEqual(const idx_t &lhs, const idx_t &rhs);
-
-	//! The global state
-	const WindowNaiveAggregator &aggregator;
-	//! Data pointer that contains a vector of states, used for row aggregation
-	vector<data_t> state;
-	//! Reused result state container for the aggregate
-	Vector statef;
-	//! A vector of pointers to "state", used for buffering intermediate aggregates
-	Vector statep;
-	//! Input data chunk, used for leaf segment aggregation
-	DataChunk leaves;
-	//! The rows beging updated.
-	SelectionVector update_sel;
-	//! Count of buffered values
-	idx_t flush_count;
-	//! The frame boundaries, used for EXCLUDE
-	SubFrames frames;
-	//! The optional hash table used for DISTINCT
-	Vector hashes;
-	//! The state used for comparing the collection across chunk boundaries
-	unique_ptr<WindowCursor> comparer;
-
-	//! The state used for scanning ORDER BY values from the collection
-	unique_ptr<WindowCursor> arg_orderer;
-	//! Reusable sort key chunk
-	DataChunk orderby_sort;
-	//! Reusable sort payload chunk
-	DataChunk orderby_payload;
-	//! Reusable sort key slicer
-	SelectionVector orderby_sel;
-	//! Reusable payload layout.
-	RowLayout payload_layout;
-};
-
-WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p)
-    : aggregator(aggregator_p), state(aggregator.state_size * STANDARD_VECTOR_SIZE), statef(LogicalType::POINTER),
-      statep((LogicalType::POINTER)), flush_count(0), hashes(LogicalType::HASH) {
-	InitSubFrames(frames, aggregator.exclude_mode);
-
-	update_sel.Initialize();
-
-	//	Build the finalise vector that just points to the result states
-	data_ptr_t state_ptr = state.data();
-	D_ASSERT(statef.GetVectorType() == VectorType::FLAT_VECTOR);
-	statef.SetVectorType(VectorType::CONSTANT_VECTOR);
-	statef.Flatten(STANDARD_VECTOR_SIZE);
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; ++i) {
-		fdata[i] = state_ptr;
-		state_ptr += aggregator.state_size;
-	}
-
-	//	Initialise any ORDER BY data
-	if (!aggregator.arg_order_idx.empty() && !arg_orderer) {
-		orderby_payload.Initialize(Allocator::DefaultAllocator(), {LogicalType::UBIGINT});
-		payload_layout.Initialize(orderby_payload.GetTypes());
-		orderby_sel.Initialize();
-	}
-}
-
-void WindowNaiveState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
-	WindowAggregatorLocalState::Finalize(gastate, collection);
-
-	//	Set up the comparison scanner just in case
-	if (!comparer) {
-		comparer = make_uniq<WindowCursor>(*collection, aggregator.child_idx);
-	}
-
-	//	Set up the argument ORDER BY scanner if needed
-	if (!aggregator.arg_order_idx.empty() && !arg_orderer) {
-		arg_orderer = make_uniq<WindowCursor>(*collection, aggregator.arg_order_idx);
-		orderby_sort.Initialize(BufferAllocator::Get(gastate.context), arg_orderer->chunk.GetTypes());
-	}
-
-	// Initialise the chunks
-	const auto types = cursor->chunk.GetTypes();
-	if (leaves.ColumnCount() == 0 && !types.empty()) {
-		leaves.Initialize(BufferAllocator::Get(gastate.context), types);
-	}
-}
-
-void WindowNaiveState::FlushStates(const WindowAggregatorGlobalState &gsink) {
-	if (!flush_count) {
-		return;
-	}
-
-	auto &scanned = cursor->chunk;
-	leaves.Slice(scanned, update_sel, flush_count);
-
-	const auto &aggr = gsink.aggr;
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), statep, flush_count);
-
-	flush_count = 0;
-}
-
-size_t WindowNaiveState::Hash(idx_t rid) {
-	D_ASSERT(cursor->RowIsVisible(rid));
-	auto s = cursor->RowOffset(rid);
-	auto &scanned = cursor->chunk;
-	SelectionVector sel(&s);
-	leaves.Slice(scanned, sel, 1);
-	leaves.Hash(hashes);
-
-	return *FlatVector::GetData<hash_t>(hashes);
-}
-
-bool WindowNaiveState::KeyEqual(const idx_t &lidx, const idx_t &ridx) {
-	//	One of the indices will be scanned, so make it the left one
-	auto lhs = lidx;
-	auto rhs = ridx;
-	if (!cursor->RowIsVisible(lhs)) {
-		std::swap(lhs, rhs);
-		D_ASSERT(cursor->RowIsVisible(lhs));
-	}
-
-	auto &scanned = cursor->chunk;
-	auto l = cursor->RowOffset(lhs);
-	SelectionVector lsel(&l);
-
-	auto rreader = cursor.get();
-	if (!cursor->RowIsVisible(rhs)) {
-		//	Values on different pages!
-		rreader = comparer.get();
-		rreader->Seek(rhs);
-	}
-	auto rscanned = &rreader->chunk;
-	auto r = rreader->RowOffset(rhs);
-	SelectionVector rsel(&r);
-
-	sel_t f = 0;
-	SelectionVector fsel(&f);
-
-	for (column_t c = 0; c < scanned.ColumnCount(); ++c) {
-		Vector left(scanned.data[c], lsel, 1);
-		Vector right(rscanned->data[c], rsel, 1);
-		if (!VectorOperations::NotDistinctFrom(left, right, nullptr, 1, nullptr, &fsel)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result,
-                                idx_t count, idx_t row_idx) {
-	const auto &aggr = gsink.aggr;
-	auto &filter_mask = gsink.filter_mask;
-	const auto types = cursor->chunk.GetTypes();
-
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-	auto pdata = FlatVector::GetData<data_ptr_t>(statep);
-
-	HashRow hash_row(*this);
-	EqualRow equal_row(*this);
-	RowSet row_set(STANDARD_VECTOR_SIZE, hash_row, equal_row);
-
-	WindowAggregator::EvaluateSubFrames(bounds, aggregator.exclude_mode, count, row_idx, frames, [&](idx_t rid) {
-		auto agg_state = fdata[rid];
-		aggr.function.initialize(aggr.function, agg_state);
-
-		//	Reset the DISTINCT hash table
-		row_set.clear();
-
-		// 	Sort the input rows by the argument
-		if (arg_orderer) {
-			auto &context = aggregator.executor.context;
-			auto &orders = aggregator.wexpr.arg_orders;
-			auto &buffer_manager = BufferManager::GetBufferManager(context);
-			GlobalSortState global_sort(buffer_manager, orders, payload_layout);
-			LocalSortState local_sort;
-			local_sort.Initialize(global_sort, global_sort.buffer_manager);
-
-			idx_t orderby_count = 0;
-			auto orderby_row = FlatVector::GetData<idx_t>(orderby_payload.data[0]);
-			for (const auto &frame : frames) {
-				for (auto f = frame.start; f < frame.end; ++f) {
-					//	FILTER before the ORDER BY
-					if (!filter_mask.RowIsValid(f)) {
-						continue;
-					}
-
-					if (!arg_orderer->RowIsVisible(f) || orderby_count >= STANDARD_VECTOR_SIZE) {
-						if (orderby_count) {
-							orderby_sort.Reference(arg_orderer->chunk);
-							orderby_sort.Slice(orderby_sel, orderby_count);
-							orderby_payload.SetCardinality(orderby_count);
-							local_sort.SinkChunk(orderby_sort, orderby_payload);
-						}
-						orderby_count = 0;
-						arg_orderer->Seek(f);
-					}
-					orderby_row[orderby_count] = f;
-					orderby_sel.set_index(orderby_count++, arg_orderer->RowOffset(f));
-				}
-			}
-			if (orderby_count) {
-				orderby_sort.Reference(arg_orderer->chunk);
-				orderby_sort.Slice(orderby_sel, orderby_count);
-				orderby_payload.SetCardinality(orderby_count);
-				local_sort.SinkChunk(orderby_sort, orderby_payload);
-			}
-
-			global_sort.AddLocalState(local_sort);
-			if (global_sort.sorted_blocks.empty()) {
-				return;
-			}
-			global_sort.PrepareMergePhase();
-			while (global_sort.sorted_blocks.size() > 1) {
-				global_sort.InitializeMergeRound();
-				MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
-				merge_sorter.PerformInMergeRound();
-				global_sort.CompleteMergeRound(false);
-			}
-
-			PayloadScanner scanner(global_sort);
-			while (scanner.Remaining()) {
-				orderby_payload.Reset();
-				scanner.Scan(orderby_payload);
-				orderby_row = FlatVector::GetData<idx_t>(orderby_payload.data[0]);
-				for (idx_t i = 0; i < orderby_payload.size(); ++i) {
-					const auto f = orderby_row[i];
-					//	Seek to the current position
-					if (!cursor->RowIsVisible(f)) {
-						//	We need to flush when we cross a chunk boundary
-						FlushStates(gsink);
-						cursor->Seek(f);
-					}
-
-					//	Filter out duplicates
-					if (aggr.IsDistinct() && !row_set.insert(f).second) {
-						continue;
-					}
-
-					pdata[flush_count] = agg_state;
-					update_sel[flush_count++] = cursor->RowOffset(f);
-					if (flush_count >= STANDARD_VECTOR_SIZE) {
-						FlushStates(gsink);
-					}
-				}
-			}
-			return;
-		}
-
-		//	Just update the aggregate with the unfiltered input rows
-		for (const auto &frame : frames) {
-			for (auto f = frame.start; f < frame.end; ++f) {
-				if (!filter_mask.RowIsValid(f)) {
-					continue;
-				}
-
-				//	Seek to the current position
-				if (!cursor->RowIsVisible(f)) {
-					//	We need to flush when we cross a chunk boundary
-					FlushStates(gsink);
-					cursor->Seek(f);
-				}
-
-				//	Filter out duplicates
-				if (aggr.IsDistinct() && !row_set.insert(f).second) {
-					continue;
-				}
-
-				pdata[flush_count] = agg_state;
-				update_sel[flush_count++] = cursor->RowOffset(f);
-				if (flush_count >= STANDARD_VECTOR_SIZE) {
-					FlushStates(gsink);
-				}
-			}
-		}
-	});
-
-	//	Flush the final states
-	FlushStates(gsink);
-
-	//	Finalise the result aggregates and write to the result
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	aggr.function.finalize(statef, aggr_input_data, result, count, 0);
-
-	//	Destruct the result aggregates
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statef, aggr_input_data, count);
-	}
-}
-
-unique_ptr<WindowAggregatorState> WindowNaiveAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
-	return make_uniq<WindowNaiveState>(*this);
-}
-
-void WindowNaiveAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                     const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
-	const auto &gnstate = gsink.Cast<WindowAggregatorGlobalState>();
-	auto &lnstate = lstate.Cast<WindowNaiveState>();
-	lnstate.Evaluate(gnstate, bounds, result, count, row_idx);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_rank_function.cpp b/src/duckdb/src/function/window/window_rank_function.cpp
deleted file mode 100644
index b128ea89a..000000000
--- a/src/duckdb/src/function/window/window_rank_function.cpp
+++ /dev/null
@@ -1,288 +0,0 @@
-#include "duckdb/function/window/window_rank_function.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/function/window/window_token_tree.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowPeerGlobalState
-//===--------------------------------------------------------------------===//
-class WindowPeerGlobalState : public WindowExecutorGlobalState {
-public:
-	WindowPeerGlobalState(const WindowPeerExecutor &executor, const idx_t payload_count,
-	                      const ValidityMask &partition_mask, const ValidityMask &order_mask)
-	    : WindowExecutorGlobalState(executor, payload_count, partition_mask, order_mask) {
-		if (!executor.arg_order_idx.empty()) {
-			token_tree = make_uniq<WindowTokenTree>(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx,
-			                                        payload_count);
-		}
-	}
-
-	//! The token tree for ORDER BY arguments
-	unique_ptr<WindowTokenTree> token_tree;
-};
-
-//===--------------------------------------------------------------------===//
-// WindowPeerLocalState
-//===--------------------------------------------------------------------===//
-//	Base class for non-aggregate functions that use peer boundaries
-class WindowPeerLocalState : public WindowExecutorBoundsState {
-public:
-	explicit WindowPeerLocalState(const WindowPeerGlobalState &gpstate)
-	    : WindowExecutorBoundsState(gpstate), gpstate(gpstate) {
-		if (gpstate.token_tree) {
-			local_tree = gpstate.token_tree->GetLocalState();
-		}
-	}
-
-	//! Accumulate the secondary sort values
-	void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx) override;
-	//! Finish the sinking and prepare to scan
-	void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) override;
-
-	void NextRank(idx_t partition_begin, idx_t peer_begin, idx_t row_idx);
-
-	uint64_t dense_rank = 1;
-	uint64_t rank_equal = 0;
-	uint64_t rank = 1;
-
-	//! The corresponding global peer state
-	const WindowPeerGlobalState &gpstate;
-	//! The optional sorting state for secondary sorts
-	unique_ptr<WindowAggregatorState> local_tree;
-};
-
-void WindowPeerLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-                                idx_t input_idx) {
-	WindowExecutorBoundsState::Sink(gstate, sink_chunk, coll_chunk, input_idx);
-
-	if (local_tree) {
-		auto &local_tokens = local_tree->Cast<WindowMergeSortTreeLocalState>();
-		local_tokens.SinkChunk(sink_chunk, input_idx, nullptr, 0);
-	}
-}
-
-void WindowPeerLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) {
-	WindowExecutorBoundsState::Finalize(gstate, collection);
-
-	if (local_tree) {
-		auto &local_tokens = local_tree->Cast<WindowMergeSortTreeLocalState>();
-		local_tokens.Sort();
-		local_tokens.window_tree.Build();
-	}
-}
-
-void WindowPeerLocalState::NextRank(idx_t partition_begin, idx_t peer_begin, idx_t row_idx) {
-	if (partition_begin == row_idx) {
-		dense_rank = 1;
-		rank = 1;
-		rank_equal = 0;
-	} else if (peer_begin == row_idx) {
-		dense_rank++;
-		rank += rank_equal;
-		rank_equal = 0;
-	}
-	rank_equal++;
-}
-
-//===--------------------------------------------------------------------===//
-// WindowPeerExecutor
-//===--------------------------------------------------------------------===//
-WindowPeerExecutor::WindowPeerExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                       WindowSharedExpressions &shared)
-    : WindowExecutor(wexpr, context, shared) {
-
-	for (const auto &order : wexpr.arg_orders) {
-		arg_order_idx.emplace_back(shared.RegisterSink(order.expression));
-	}
-}
-
-unique_ptr<WindowExecutorGlobalState> WindowPeerExecutor::GetGlobalState(const idx_t payload_count,
-                                                                         const ValidityMask &partition_mask,
-                                                                         const ValidityMask &order_mask) const {
-	return make_uniq<WindowPeerGlobalState>(*this, payload_count, partition_mask, order_mask);
-}
-
-unique_ptr<WindowExecutorLocalState> WindowPeerExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	return make_uniq<WindowPeerLocalState>(gstate.Cast<WindowPeerGlobalState>());
-}
-
-//===--------------------------------------------------------------------===//
-// WindowRankExecutor
-//===--------------------------------------------------------------------===//
-WindowRankExecutor::WindowRankExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                       WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
-}
-
-void WindowRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                          DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &gpeer = gstate.Cast<WindowPeerGlobalState>();
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
-	auto rdata = FlatVector::GetData<uint64_t>(result);
-
-	if (gpeer.token_tree) {
-		auto frame_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_BEGIN]);
-		auto frame_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_END]);
-		for (idx_t i = 0; i < count; ++i, ++row_idx) {
-			rdata[i] = gpeer.token_tree->Rank(frame_begin[i], frame_end[i], row_idx);
-		}
-		return;
-	}
-
-	//	Reset to "previous" row
-	auto partition_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_BEGIN]);
-	auto peer_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PEER_BEGIN]);
-	lpeer.rank = (peer_begin[0] - partition_begin[0]) + 1;
-	lpeer.rank_equal = (row_idx - peer_begin[0]);
-
-	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		rdata[i] = lpeer.rank;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowDenseRankExecutor
-//===--------------------------------------------------------------------===//
-WindowDenseRankExecutor::WindowDenseRankExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                 WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
-}
-
-void WindowDenseRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                               DataChunk &eval_chunk, Vector &result, idx_t count,
-                                               idx_t row_idx) const {
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
-
-	auto &order_mask = gstate.order_mask;
-	auto partition_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_BEGIN]);
-	auto peer_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PEER_BEGIN]);
-	auto rdata = FlatVector::GetData<int64_t>(result);
-
-	//	Reset to "previous" row
-	lpeer.rank = (peer_begin[0] - partition_begin[0]) + 1;
-	lpeer.rank_equal = (row_idx - peer_begin[0]);
-
-	//	The previous dense rank is the number of order mask bits in [partition_begin, row_idx)
-	lpeer.dense_rank = 0;
-
-	auto order_begin = partition_begin[0];
-	idx_t begin_idx;
-	idx_t begin_offset;
-	order_mask.GetEntryIndex(order_begin, begin_idx, begin_offset);
-
-	auto order_end = row_idx;
-	idx_t end_idx;
-	idx_t end_offset;
-	order_mask.GetEntryIndex(order_end, end_idx, end_offset);
-
-	//	If they are in the same entry, just loop
-	if (begin_idx == end_idx) {
-		const auto entry = order_mask.GetValidityEntry(begin_idx);
-		for (; begin_offset < end_offset; ++begin_offset) {
-			lpeer.dense_rank += order_mask.RowIsValid(entry, begin_offset);
-		}
-	} else {
-		// Count the ragged bits at the start of the partition
-		if (begin_offset) {
-			const auto entry = order_mask.GetValidityEntry(begin_idx);
-			for (; begin_offset < order_mask.BITS_PER_VALUE; ++begin_offset) {
-				lpeer.dense_rank += order_mask.RowIsValid(entry, begin_offset);
-				++order_begin;
-			}
-			++begin_idx;
-		}
-
-		//	Count the the aligned bits.
-		ValidityMask tail_mask(order_mask.GetData() + begin_idx, end_idx - begin_idx);
-		lpeer.dense_rank += tail_mask.CountValid(order_end - order_begin);
-	}
-
-	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		rdata[i] = NumericCast<int64_t>(lpeer.dense_rank);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowPercentRankExecutor
-//===--------------------------------------------------------------------===//
-WindowPercentRankExecutor::WindowPercentRankExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                     WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
-}
-
-void WindowPercentRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                                 DataChunk &eval_chunk, Vector &result, idx_t count,
-                                                 idx_t row_idx) const {
-	auto &gpeer = gstate.Cast<WindowPeerGlobalState>();
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
-	auto rdata = FlatVector::GetData<double>(result);
-
-	if (gpeer.token_tree) {
-		auto frame_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_BEGIN]);
-		auto frame_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_END]);
-		for (idx_t i = 0; i < count; ++i, ++row_idx) {
-			auto denom = static_cast<double>(NumericCast<int64_t>(frame_end[i] - frame_begin[i] - 1));
-			const auto rank = gpeer.token_tree->Rank(frame_begin[i], frame_end[i], row_idx);
-			double percent_rank = denom > 0 ? ((double)rank - 1) / denom : 0;
-			rdata[i] = percent_rank;
-		}
-		return;
-	}
-
-	//	Reset to "previous" row
-	auto partition_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_BEGIN]);
-	auto partition_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_END]);
-	auto peer_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PEER_BEGIN]);
-	lpeer.rank = (peer_begin[0] - partition_begin[0]) + 1;
-	lpeer.rank_equal = (row_idx - peer_begin[0]);
-
-	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		auto denom = static_cast<double>(NumericCast<int64_t>(partition_end[i] - partition_begin[i] - 1));
-		double percent_rank = denom > 0 ? ((double)lpeer.rank - 1) / denom : 0;
-		rdata[i] = percent_rank;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowCumeDistExecutor
-//===--------------------------------------------------------------------===//
-WindowCumeDistExecutor::WindowCumeDistExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                               WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
-}
-
-void WindowCumeDistExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                              DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &gpeer = gstate.Cast<WindowPeerGlobalState>();
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
-	auto rdata = FlatVector::GetData<double>(result);
-
-	if (gpeer.token_tree) {
-		auto frame_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_BEGIN]);
-		auto frame_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_END]);
-		for (idx_t i = 0; i < count; ++i, ++row_idx) {
-			const auto denom = static_cast<double>(NumericCast<int64_t>(frame_end[i] - frame_begin[i]));
-			const auto peer_end = gpeer.token_tree->PeerEnd(frame_begin[i], frame_end[i], row_idx);
-			const auto num = static_cast<double>(peer_end - frame_begin[i]);
-			rdata[i] = denom > 0 ? (num / denom) : 0;
-		}
-		return;
-	}
-
-	auto partition_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_BEGIN]);
-	auto partition_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_END]);
-	auto peer_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PEER_END]);
-	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		const auto denom = static_cast<double>(NumericCast<int64_t>(partition_end[i] - partition_begin[i]));
-		const auto num = static_cast<double>(peer_end[i] - partition_begin[i]);
-		rdata[i] = denom > 0 ? (num / denom) : 0;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_rownumber_function.cpp b/src/duckdb/src/function/window/window_rownumber_function.cpp
deleted file mode 100644
index f946583f1..000000000
--- a/src/duckdb/src/function/window/window_rownumber_function.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-#include "duckdb/function/window/window_rownumber_function.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/function/window/window_token_tree.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowRowNumberGlobalState
-//===--------------------------------------------------------------------===//
-class WindowRowNumberGlobalState : public WindowExecutorGlobalState {
-public:
-	WindowRowNumberGlobalState(const WindowRowNumberExecutor &executor, const idx_t payload_count,
-	                           const ValidityMask &partition_mask, const ValidityMask &order_mask)
-	    : WindowExecutorGlobalState(executor, payload_count, partition_mask, order_mask),
-	      ntile_idx(executor.ntile_idx) {
-		if (!executor.arg_order_idx.empty()) {
-			//	"The ROW_NUMBER function can be computed by disambiguating duplicate elements based on their position in
-			//	the input data, such that two elements never compare as equal."
-			token_tree = make_uniq<WindowTokenTree>(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx,
-			                                        payload_count, true);
-		}
-	}
-
-	//! The token tree for ORDER BY arguments
-	unique_ptr<WindowTokenTree> token_tree;
-
-	//! The evaluation index for NTILE
-	const column_t ntile_idx;
-};
-
-//===--------------------------------------------------------------------===//
-// WindowRowNumberLocalState
-//===--------------------------------------------------------------------===//
-class WindowRowNumberLocalState : public WindowExecutorBoundsState {
-public:
-	explicit WindowRowNumberLocalState(const WindowRowNumberGlobalState &grstate)
-	    : WindowExecutorBoundsState(grstate), grstate(grstate) {
-		if (grstate.token_tree) {
-			local_tree = grstate.token_tree->GetLocalState();
-		}
-	}
-
-	//! Accumulate the secondary sort values
-	void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx) override;
-	//! Finish the sinking and prepare to scan
-	void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) override;
-
-	//! The corresponding global peer state
-	const WindowRowNumberGlobalState &grstate;
-	//! The optional sorting state for secondary sorts
-	unique_ptr<WindowAggregatorState> local_tree;
-};
-
-void WindowRowNumberLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-                                     idx_t input_idx) {
-	WindowExecutorBoundsState::Sink(gstate, sink_chunk, coll_chunk, input_idx);
-
-	if (local_tree) {
-		auto &local_tokens = local_tree->Cast<WindowMergeSortTreeLocalState>();
-		local_tokens.SinkChunk(sink_chunk, input_idx, nullptr, 0);
-	}
-}
-
-void WindowRowNumberLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) {
-	WindowExecutorBoundsState::Finalize(gstate, collection);
-
-	if (local_tree) {
-		auto &local_tokens = local_tree->Cast<WindowMergeSortTreeLocalState>();
-		local_tokens.Sort();
-		local_tokens.window_tree.Build();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowRowNumberExecutor
-//===--------------------------------------------------------------------===//
-WindowRowNumberExecutor::WindowRowNumberExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                 WindowSharedExpressions &shared)
-    : WindowExecutor(wexpr, context, shared) {
-
-	for (const auto &order : wexpr.arg_orders) {
-		arg_order_idx.emplace_back(shared.RegisterSink(order.expression));
-	}
-}
-
-unique_ptr<WindowExecutorGlobalState> WindowRowNumberExecutor::GetGlobalState(const idx_t payload_count,
-                                                                              const ValidityMask &partition_mask,
-                                                                              const ValidityMask &order_mask) const {
-	return make_uniq<WindowRowNumberGlobalState>(*this, payload_count, partition_mask, order_mask);
-}
-
-unique_ptr<WindowExecutorLocalState>
-WindowRowNumberExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	return make_uniq<WindowRowNumberLocalState>(gstate.Cast<WindowRowNumberGlobalState>());
-}
-
-void WindowRowNumberExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                               DataChunk &eval_chunk, Vector &result, idx_t count,
-                                               idx_t row_idx) const {
-	auto &grstate = gstate.Cast<WindowRowNumberGlobalState>();
-	auto &lrstate = lstate.Cast<WindowRowNumberLocalState>();
-	auto rdata = FlatVector::GetData<uint64_t>(result);
-
-	if (grstate.token_tree) {
-		auto frame_begin = FlatVector::GetData<const idx_t>(lrstate.bounds.data[FRAME_BEGIN]);
-		auto frame_end = FlatVector::GetData<const idx_t>(lrstate.bounds.data[FRAME_END]);
-		for (idx_t i = 0; i < count; ++i, ++row_idx) {
-			// Row numbers are unique ranks
-			rdata[i] = grstate.token_tree->Rank(frame_begin[i], frame_end[i], row_idx);
-		}
-		return;
-	}
-
-	auto partition_begin = FlatVector::GetData<const idx_t>(lrstate.bounds.data[PARTITION_BEGIN]);
-	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		rdata[i] = row_idx - partition_begin[i] + 1;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowNtileExecutor
-//===--------------------------------------------------------------------===//
-WindowNtileExecutor::WindowNtileExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                         WindowSharedExpressions &shared)
-    : WindowRowNumberExecutor(wexpr, context, shared) {
-
-	// NTILE has one argument
-	ntile_idx = shared.RegisterEvaluate(wexpr.children[0]);
-}
-
-void WindowNtileExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                           DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &grstate = gstate.Cast<WindowRowNumberGlobalState>();
-	auto &lrstate = lstate.Cast<WindowRowNumberLocalState>();
-	auto partition_begin = FlatVector::GetData<const idx_t>(lrstate.bounds.data[PARTITION_BEGIN]);
-	auto partition_end = FlatVector::GetData<const idx_t>(lrstate.bounds.data[PARTITION_END]);
-	if (grstate.token_tree) {
-		// With secondary sorts, we restrict to the frame boundaries, but everything else should compute the same.
-		partition_begin = FlatVector::GetData<const idx_t>(lrstate.bounds.data[FRAME_BEGIN]);
-		partition_end = FlatVector::GetData<const idx_t>(lrstate.bounds.data[FRAME_END]);
-	}
-	auto rdata = FlatVector::GetData<int64_t>(result);
-	WindowInputExpression ntile_col(eval_chunk, ntile_idx);
-	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		if (ntile_col.CellIsNull(i)) {
-			FlatVector::SetNull(result, i, true);
-		} else {
-			auto n_param = ntile_col.GetCell<int64_t>(i);
-			if (n_param < 1) {
-				throw InvalidInputException("Argument for ntile must be greater than zero");
-			}
-			// With thanks from SQLite's ntileValueFunc()
-			auto n_total = NumericCast<int64_t>(partition_end[i] - partition_begin[i]);
-			if (n_param > n_total) {
-				// more groups allowed than we have values
-				// map every entry to a unique group
-				n_param = n_total;
-			}
-			int64_t n_size = (n_total / n_param);
-			// find the row idx within the group
-			D_ASSERT(row_idx >= partition_begin[i]);
-			idx_t partition_idx = 0;
-			if (grstate.token_tree) {
-				partition_idx = grstate.token_tree->Rank(partition_begin[i], partition_end[i], row_idx) - 1;
-			} else {
-				partition_idx = row_idx - partition_begin[i];
-			}
-			auto adjusted_row_idx = NumericCast<int64_t>(partition_idx);
-
-			// now compute the ntile
-			int64_t n_large = n_total - n_param * n_size;
-			int64_t i_small = n_large * (n_size + 1);
-			int64_t result_ntile;
-
-			D_ASSERT((n_large * (n_size + 1) + (n_param - n_large) * n_size) == n_total);
-
-			if (adjusted_row_idx < i_small) {
-				result_ntile = 1 + adjusted_row_idx / (n_size + 1);
-			} else {
-				result_ntile = 1 + n_large + (adjusted_row_idx - i_small) / n_size;
-			}
-			// result has to be between [1, NTILE]
-			D_ASSERT(result_ntile >= 1 && result_ntile <= n_param);
-			rdata[i] = result_ntile;
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_segment_tree.cpp b/src/duckdb/src/function/window/window_segment_tree.cpp
deleted file mode 100644
index 6708ae90b..000000000
--- a/src/duckdb/src/function/window/window_segment_tree.cpp
+++ /dev/null
@@ -1,594 +0,0 @@
-#include "duckdb/function/window/window_segment_tree.hpp"
-
-#include "duckdb/function/window/window_aggregate_states.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-#include <thread>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowSegmentTree
-//===--------------------------------------------------------------------===//
-bool WindowSegmentTree::CanAggregate(const BoundWindowExpression &wexpr) {
-	if (!wexpr.aggregate) {
-		return false;
-	}
-
-	return !wexpr.distinct && wexpr.arg_orders.empty();
-}
-
-WindowSegmentTree::WindowSegmentTree(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
-    : WindowAggregator(wexpr, shared) {
-}
-
-class WindowSegmentTreeGlobalState : public WindowAggregatorGlobalState {
-public:
-	using AtomicCounters = vector<std::atomic<idx_t>>;
-
-	WindowSegmentTreeGlobalState(ClientContext &context, const WindowSegmentTree &aggregator, idx_t group_count);
-
-	ArenaAllocator &CreateTreeAllocator() {
-		lock_guard<mutex> tree_lock(lock);
-		tree_allocators.emplace_back(make_uniq<ArenaAllocator>(Allocator::DefaultAllocator()));
-		return *tree_allocators.back();
-	}
-
-	//! The owning aggregator
-	const WindowSegmentTree &tree;
-	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	WindowAggregateStates levels_flat_native;
-	//! For each level, the starting location in the levels_flat_native array
-	vector<idx_t> levels_flat_start;
-	//! The level being built (read)
-	std::atomic<idx_t> build_level;
-	//! The number of entries started so far at each level
-	unique_ptr<AtomicCounters> build_started;
-	//! The number of entries completed so far at each level
-	unique_ptr<AtomicCounters> build_completed;
-	//! The tree allocators.
-	//! We need to hold onto them for the tree lifetime,
-	//! not the lifetime of the local state that constructed part of the tree
-	vector<unique_ptr<ArenaAllocator>> tree_allocators;
-
-	// TREE_FANOUT needs to cleanly divide STANDARD_VECTOR_SIZE
-	static constexpr idx_t TREE_FANOUT = 16;
-};
-
-class WindowSegmentTreePart {
-public:
-	//! Right side nodes need to be cached and processed in reverse order
-	using RightEntry = std::pair<idx_t, idx_t>;
-
-	enum FramePart : uint8_t { FULL = 0, LEFT = 1, RIGHT = 2 };
-
-	WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr, unique_ptr<WindowCursor> cursor,
-	                      const ValidityArray &filter_mask);
-	~WindowSegmentTreePart();
-
-	unique_ptr<WindowSegmentTreePart> Copy() const {
-		return make_uniq<WindowSegmentTreePart>(allocator, aggr, cursor->Copy(), filter_mask);
-	}
-
-	void FlushStates(bool combining);
-	void ExtractFrame(idx_t begin, idx_t end, data_ptr_t current_state);
-	void WindowSegmentValue(const WindowSegmentTreeGlobalState &tree, idx_t l_idx, idx_t begin, idx_t end,
-	                        data_ptr_t current_state);
-	//! Writes result and calls destructors
-	void Finalize(Vector &result, idx_t count);
-
-	void Combine(WindowSegmentTreePart &other, idx_t count);
-
-	void Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, Vector &result,
-	              idx_t count, idx_t row_idx, FramePart frame_part);
-
-protected:
-	//! Initialises the accumulation state vector (statef)
-	void Initialize(idx_t count);
-	//! Accumulate upper tree levels
-	void EvaluateUpperLevels(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends,
-	                         idx_t count, idx_t row_idx, FramePart frame_part);
-	void EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, idx_t count,
-	                    idx_t row_idx, FramePart frame_part, FramePart leaf_part);
-
-public:
-	//! Allocator for aggregates
-	ArenaAllocator &allocator;
-	//! The aggregate function
-	const AggregateObject &aggr;
-	//! Order insensitive aggregate (we can optimise internal combines)
-	const bool order_insensitive;
-	//! The filtered rows in inputs
-	const ValidityArray &filter_mask;
-	//! The size of a single aggregate state
-	const idx_t state_size;
-	//! Data pointer that contains a vector of states, used for intermediate window segment aggregation
-	vector<data_t> state;
-	//! Scanned data state
-	unique_ptr<WindowCursor> cursor;
-	//! Input data chunk, used for leaf segment aggregation
-	DataChunk leaves;
-	//! The filtered rows in inputs.
-	SelectionVector filter_sel;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! Reused state pointers for combining segment tree levels
-	Vector statel;
-	//! Reused result state container for the window functions
-	Vector statef;
-	//! Count of buffered values
-	idx_t flush_count;
-	//! Cache of right side tree ranges for ordered aggregates
-	vector<RightEntry> right_stack;
-};
-
-class WindowSegmentTreeState : public WindowAggregatorLocalState {
-public:
-	WindowSegmentTreeState() {
-	}
-
-	void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
-	void Evaluate(const WindowSegmentTreeGlobalState &gsink, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx);
-	//! The left (default) segment tree part
-	unique_ptr<WindowSegmentTreePart> part;
-	//! The right segment tree part (for EXCLUDE)
-	unique_ptr<WindowSegmentTreePart> right_part;
-};
-
-void WindowSegmentTree::Finalize(WindowAggregatorState &gsink, WindowAggregatorState &lstate, CollectionPtr collection,
-                                 const FrameStats &stats) {
-	WindowAggregator::Finalize(gsink, lstate, collection, stats);
-
-	auto &gasink = gsink.Cast<WindowSegmentTreeGlobalState>();
-	++gasink.finalized;
-}
-
-WindowSegmentTreePart::WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr,
-                                             unique_ptr<WindowCursor> cursor_p, const ValidityArray &filter_mask)
-    : allocator(allocator), aggr(aggr),
-      order_insensitive(aggr.function.order_dependent == AggregateOrderDependent::NOT_ORDER_DEPENDENT),
-      filter_mask(filter_mask), state_size(aggr.function.state_size(aggr.function)),
-      state(state_size * STANDARD_VECTOR_SIZE), cursor(std::move(cursor_p)), statep(LogicalType::POINTER),
-      statel(LogicalType::POINTER), statef(LogicalType::POINTER), flush_count(0) {
-
-	auto &inputs = cursor->chunk;
-	if (inputs.ColumnCount() > 0) {
-		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
-		filter_sel.Initialize();
-	}
-
-	//	Build the finalise vector that just points to the result states
-	data_ptr_t state_ptr = state.data();
-	D_ASSERT(statef.GetVectorType() == VectorType::FLAT_VECTOR);
-	statef.SetVectorType(VectorType::CONSTANT_VECTOR);
-	statef.Flatten(STANDARD_VECTOR_SIZE);
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; ++i) {
-		fdata[i] = state_ptr;
-		state_ptr += state_size;
-	}
-}
-
-WindowSegmentTreePart::~WindowSegmentTreePart() {
-}
-
-unique_ptr<WindowAggregatorState> WindowSegmentTree::GetGlobalState(ClientContext &context, idx_t group_count,
-                                                                    const ValidityMask &partition_mask) const {
-	return make_uniq<WindowSegmentTreeGlobalState>(context, *this, group_count);
-}
-
-unique_ptr<WindowAggregatorState> WindowSegmentTree::GetLocalState(const WindowAggregatorState &gstate) const {
-	return make_uniq<WindowSegmentTreeState>();
-}
-
-void WindowSegmentTreePart::FlushStates(bool combining) {
-	if (!flush_count) {
-		return;
-	}
-
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	if (combining) {
-		statel.Verify(flush_count);
-		aggr.function.combine(statel, statep, aggr_input_data, flush_count);
-	} else {
-		auto &scanned = cursor->chunk;
-		leaves.Slice(scanned, filter_sel, flush_count);
-		aggr.function.update(&leaves.data[0], aggr_input_data, leaves.ColumnCount(), statep, flush_count);
-	}
-
-	flush_count = 0;
-}
-
-void WindowSegmentTreePart::Combine(WindowSegmentTreePart &other, idx_t count) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	aggr.function.combine(other.statef, statef, aggr_input_data, count);
-}
-
-void WindowSegmentTreePart::ExtractFrame(idx_t begin, idx_t end, data_ptr_t state_ptr) {
-	const auto count = end - begin;
-
-	//	If we are not filtering,
-	//	just update the shared dictionary selection to the range
-	//	Otherwise set it to the input rows that pass the filter
-	auto states = FlatVector::GetData<data_ptr_t>(statep);
-	if (filter_mask.AllValid()) {
-		const auto offset = cursor->RowOffset(begin);
-		for (idx_t i = 0; i < count; ++i) {
-			states[flush_count] = state_ptr;
-			filter_sel.set_index(flush_count++, offset + i);
-			if (flush_count >= STANDARD_VECTOR_SIZE) {
-				FlushStates(false);
-			}
-		}
-	} else {
-		for (idx_t i = begin; i < end; ++i) {
-			if (filter_mask.RowIsValid(i)) {
-				states[flush_count] = state_ptr;
-				filter_sel.set_index(flush_count++, cursor->RowOffset(i));
-				if (flush_count >= STANDARD_VECTOR_SIZE) {
-					FlushStates(false);
-				}
-			}
-		}
-	}
-}
-
-void WindowSegmentTreePart::WindowSegmentValue(const WindowSegmentTreeGlobalState &tree, idx_t l_idx, idx_t begin,
-                                               idx_t end, data_ptr_t state_ptr) {
-	D_ASSERT(begin <= end);
-	auto &inputs = cursor->chunk;
-	if (begin == end || inputs.ColumnCount() == 0) {
-		return;
-	}
-
-	const auto count = end - begin;
-	if (l_idx == 0) {
-		//	Check the leaves when they cross chunk boundaries
-		while (begin < end) {
-			if (!cursor->RowIsVisible(begin)) {
-				FlushStates(false);
-				cursor->Seek(begin);
-			}
-			auto next = MinValue(end, cursor->state.next_row_index);
-			ExtractFrame(begin, next, state_ptr);
-			begin = next;
-		}
-	} else {
-		// find out where the states begin
-		auto begin_ptr = tree.levels_flat_native.GetStatePtr(begin + tree.levels_flat_start[l_idx - 1]);
-		// set up a vector of pointers that point towards the set of states
-		auto ldata = FlatVector::GetData<const_data_ptr_t>(statel);
-		auto pdata = FlatVector::GetData<data_ptr_t>(statep);
-		for (idx_t i = 0; i < count; i++) {
-			pdata[flush_count] = state_ptr;
-			ldata[flush_count++] = begin_ptr;
-			begin_ptr += state_size;
-			if (flush_count >= STANDARD_VECTOR_SIZE) {
-				FlushStates(true);
-			}
-		}
-	}
-}
-void WindowSegmentTreePart::Finalize(Vector &result, idx_t count) {
-	//	Finalise the result aggregates and write to result if write_result is set
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	aggr.function.finalize(statef, aggr_input_data, result, count, 0);
-
-	//	Destruct the result aggregates
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statef, aggr_input_data, count);
-	}
-}
-
-WindowSegmentTreeGlobalState::WindowSegmentTreeGlobalState(ClientContext &context, const WindowSegmentTree &aggregator,
-                                                           idx_t group_count)
-    : WindowAggregatorGlobalState(context, aggregator, group_count), tree(aggregator), levels_flat_native(aggr) {
-
-	D_ASSERT(!aggregator.wexpr.children.empty());
-
-	// compute space required to store internal nodes of segment tree
-	levels_flat_start.push_back(0);
-
-	idx_t levels_flat_offset = 0;
-	idx_t level_current = 0;
-	// level 0 is data itself
-	idx_t level_size;
-	// iterate over the levels of the segment tree
-	while ((level_size =
-	            (level_current == 0 ? group_count : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
-		for (idx_t pos = 0; pos < level_size; pos += TREE_FANOUT) {
-			levels_flat_offset++;
-		}
-
-		levels_flat_start.push_back(levels_flat_offset);
-		level_current++;
-	}
-
-	// Corner case: single element in the window
-	if (levels_flat_offset == 0) {
-		++levels_flat_offset;
-	}
-
-	levels_flat_native.Initialize(levels_flat_offset);
-
-	// Start by building from the bottom level
-	build_level = 0;
-
-	build_started = make_uniq<AtomicCounters>(levels_flat_start.size());
-	for (auto &counter : *build_started) {
-		counter = 0;
-	}
-
-	build_completed = make_uniq<AtomicCounters>(levels_flat_start.size());
-	for (auto &counter : *build_completed) {
-		counter = 0;
-	}
-}
-
-void WindowSegmentTreeState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
-	WindowAggregatorLocalState::Finalize(gastate, collection);
-
-	//	Single part for constructing the tree
-	auto &gstate = gastate.Cast<WindowSegmentTreeGlobalState>();
-	auto cursor = make_uniq<WindowCursor>(*collection, gastate.aggregator.child_idx);
-	const auto leaf_count = collection->size();
-	auto &filter_mask = gstate.filter_mask;
-	WindowSegmentTreePart gtstate(gstate.CreateTreeAllocator(), gastate.aggr, std::move(cursor), filter_mask);
-
-	auto &levels_flat_native = gstate.levels_flat_native;
-	const auto &levels_flat_start = gstate.levels_flat_start;
-	// iterate over the levels of the segment tree
-	for (;;) {
-		const idx_t level_current = gstate.build_level.load();
-		if (level_current >= levels_flat_start.size()) {
-			break;
-		}
-
-		// level 0 is data itself
-		const auto level_size =
-		    (level_current == 0 ? leaf_count : levels_flat_start[level_current] - levels_flat_start[level_current - 1]);
-		if (level_size <= 1) {
-			break;
-		}
-		const idx_t build_count = (level_size + gstate.TREE_FANOUT - 1) / gstate.TREE_FANOUT;
-
-		// Build the next fan-in
-		const idx_t build_idx = (*gstate.build_started).at(level_current)++;
-		if (build_idx >= build_count) {
-			//	Nothing left at this level, so wait until other threads are done.
-			//	Since we are only building TREE_FANOUT values at a time, this will be quick.
-			while (level_current == gstate.build_level.load()) {
-				std::this_thread::sleep_for(std::chrono::milliseconds(1));
-			}
-			continue;
-		}
-
-		// compute the aggregate for this entry in the segment tree
-		const idx_t pos = build_idx * gstate.TREE_FANOUT;
-		const idx_t levels_flat_offset = levels_flat_start[level_current] + build_idx;
-		auto state_ptr = levels_flat_native.GetStatePtr(levels_flat_offset);
-		gtstate.WindowSegmentValue(gstate, level_current, pos, MinValue(level_size, pos + gstate.TREE_FANOUT),
-		                           state_ptr);
-		gtstate.FlushStates(level_current > 0);
-
-		//	If that was the last one, mark the level as complete.
-		const idx_t build_complete = ++(*gstate.build_completed).at(level_current);
-		if (build_complete == build_count) {
-			gstate.build_level++;
-			continue;
-		}
-	}
-}
-
-void WindowSegmentTree::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                 const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
-	const auto &gtstate = gsink.Cast<WindowSegmentTreeGlobalState>();
-	auto &ltstate = lstate.Cast<WindowSegmentTreeState>();
-	ltstate.Evaluate(gtstate, bounds, result, count, row_idx);
-}
-
-void WindowSegmentTreeState::Evaluate(const WindowSegmentTreeGlobalState &gtstate, const DataChunk &bounds,
-                                      Vector &result, idx_t count, idx_t row_idx) {
-	auto window_begin = FlatVector::GetData<const idx_t>(bounds.data[FRAME_BEGIN]);
-	auto window_end = FlatVector::GetData<const idx_t>(bounds.data[FRAME_END]);
-	auto peer_begin = FlatVector::GetData<const idx_t>(bounds.data[PEER_BEGIN]);
-	auto peer_end = FlatVector::GetData<const idx_t>(bounds.data[PEER_END]);
-
-	if (!part) {
-		part = make_uniq<WindowSegmentTreePart>(allocator, gtstate.aggr, cursor->Copy(), gtstate.filter_mask);
-	}
-
-	if (gtstate.aggregator.exclude_mode != WindowExcludeMode::NO_OTHER) {
-		// 1. evaluate the tree left of the excluded part
-		part->Evaluate(gtstate, window_begin, peer_begin, result, count, row_idx, WindowSegmentTreePart::LEFT);
-
-		// 2. set up a second state for the right of the excluded part
-		if (!right_part) {
-			right_part = part->Copy();
-		}
-
-		// 3. evaluate the tree right of the excluded part
-		right_part->Evaluate(gtstate, peer_end, window_end, result, count, row_idx, WindowSegmentTreePart::RIGHT);
-
-		// 4. combine the buffer state into the Segment Tree State
-		part->Combine(*right_part, count);
-	} else {
-		part->Evaluate(gtstate, window_begin, window_end, result, count, row_idx, WindowSegmentTreePart::FULL);
-	}
-
-	part->Finalize(result, count);
-}
-
-void WindowSegmentTreePart::Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends,
-                                     Vector &result, idx_t count, idx_t row_idx, FramePart frame_part) {
-	Initialize(count);
-
-	if (order_insensitive) {
-		//	First pass: aggregate the segment tree nodes with sharing
-		EvaluateUpperLevels(tree, begins, ends, count, row_idx, frame_part);
-
-		//	Second pass: aggregate the ragged leaves
-		EvaluateLeaves(tree, begins, ends, count, row_idx, frame_part, FramePart::FULL);
-	} else {
-		//	Evaluate leaves in order
-		EvaluateLeaves(tree, begins, ends, count, row_idx, frame_part, FramePart::LEFT);
-		EvaluateUpperLevels(tree, begins, ends, count, row_idx, frame_part);
-		EvaluateLeaves(tree, begins, ends, count, row_idx, frame_part, FramePart::RIGHT);
-	}
-}
-
-void WindowSegmentTreePart::Initialize(idx_t count) {
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-	for (idx_t rid = 0; rid < count; ++rid) {
-		auto state_ptr = fdata[rid];
-		aggr.function.initialize(aggr.function, state_ptr);
-	}
-}
-
-void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTreeGlobalState &tree, const idx_t *begins,
-                                                const idx_t *ends, idx_t count, idx_t row_idx, FramePart frame_part) {
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-
-	const auto exclude_mode = tree.tree.exclude_mode;
-	const bool begin_on_curr_row = frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
-	const bool end_on_curr_row = frame_part == FramePart::LEFT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
-
-	const auto max_level = tree.levels_flat_start.size() + 1;
-	right_stack.resize(max_level, {0, 0});
-
-	//	Share adjacent identical states
-	//  We do this first because we want to share only tree aggregations
-	idx_t prev_begin = 1;
-	idx_t prev_end = 0;
-	auto ldata = FlatVector::GetData<data_ptr_t>(statel);
-	auto pdata = FlatVector::GetData<data_ptr_t>(statep);
-	data_ptr_t prev_state = nullptr;
-	for (idx_t rid = 0, cur_row = row_idx; rid < count; ++rid, ++cur_row) {
-		auto state_ptr = fdata[rid];
-
-		auto begin = begin_on_curr_row ? cur_row + 1 : begins[rid];
-		auto end = end_on_curr_row ? cur_row : ends[rid];
-		if (begin >= end) {
-			continue;
-		}
-
-		//	Skip level 0
-		idx_t l_idx = 0;
-		idx_t right_max = 0;
-		for (; l_idx < max_level; l_idx++) {
-			idx_t parent_begin = begin / tree.TREE_FANOUT;
-			idx_t parent_end = end / tree.TREE_FANOUT;
-			if (prev_state && l_idx == 1 && begin == prev_begin && end == prev_end) {
-				//	Just combine the previous top level result
-				ldata[flush_count] = prev_state;
-				pdata[flush_count] = state_ptr;
-				if (++flush_count >= STANDARD_VECTOR_SIZE) {
-					FlushStates(true);
-				}
-				break;
-			}
-
-			if (order_insensitive && l_idx == 1) {
-				prev_state = state_ptr;
-				prev_begin = begin;
-				prev_end = end;
-			}
-
-			if (parent_begin == parent_end) {
-				if (l_idx) {
-					WindowSegmentValue(tree, l_idx, begin, end, state_ptr);
-				}
-				break;
-			}
-			idx_t group_begin = parent_begin * tree.TREE_FANOUT;
-			if (begin != group_begin) {
-				if (l_idx) {
-					WindowSegmentValue(tree, l_idx, begin, group_begin + tree.TREE_FANOUT, state_ptr);
-				}
-				parent_begin++;
-			}
-			idx_t group_end = parent_end * tree.TREE_FANOUT;
-			if (end != group_end) {
-				if (l_idx) {
-					if (order_insensitive) {
-						WindowSegmentValue(tree, l_idx, group_end, end, state_ptr);
-					} else {
-						right_stack[l_idx] = {group_end, end};
-						right_max = l_idx;
-					}
-				}
-			}
-			begin = parent_begin;
-			end = parent_end;
-		}
-
-		// Flush the right side values from left to right for order_sensitive aggregates
-		// As we go up the tree, the right side ranges move left,
-		// so we just cache them in a fixed size, preallocated array.
-		// Then we can just reverse scan the array and append the cached ranges.
-		for (l_idx = right_max; l_idx > 0; --l_idx) {
-			auto &right_entry = right_stack[l_idx];
-			const auto group_end = right_entry.first;
-			const auto end = right_entry.second;
-			if (end) {
-				WindowSegmentValue(tree, l_idx, group_end, end, state_ptr);
-				right_entry = {0, 0};
-			}
-		}
-	}
-	FlushStates(true);
-}
-
-void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins,
-                                           const idx_t *ends, idx_t count, idx_t row_idx, FramePart frame_part,
-                                           FramePart leaf_part) {
-
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-
-	// For order-sensitive aggregates, we have to process the ragged leaves in two pieces.
-	// The left side have to be added before the main tree followed by the ragged right sides.
-	// The current row is the leftmost value of the right hand side.
-	const bool compute_left = leaf_part != FramePart::RIGHT;
-	const bool compute_right = leaf_part != FramePart::LEFT;
-	const auto exclude_mode = tree.tree.exclude_mode;
-	const bool begin_on_curr_row = frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
-	const bool end_on_curr_row = frame_part == FramePart::LEFT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
-	// with EXCLUDE TIES, in addition to the frame part right of the peer group's end, we also need to consider the
-	// current row
-	const bool add_curr_row = compute_left && frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::TIES;
-
-	for (idx_t rid = 0, cur_row = row_idx; rid < count; ++rid, ++cur_row) {
-		auto state_ptr = fdata[rid];
-
-		const auto begin = begin_on_curr_row ? cur_row + 1 : begins[rid];
-		const auto end = end_on_curr_row ? cur_row : ends[rid];
-		if (add_curr_row) {
-			WindowSegmentValue(tree, 0, cur_row, cur_row + 1, state_ptr);
-		}
-		if (begin >= end) {
-			continue;
-		}
-
-		idx_t parent_begin = begin / tree.TREE_FANOUT;
-		idx_t parent_end = end / tree.TREE_FANOUT;
-		if (parent_begin == parent_end) {
-			if (compute_left) {
-				WindowSegmentValue(tree, 0, begin, end, state_ptr);
-			}
-			continue;
-		}
-
-		idx_t group_begin = parent_begin * tree.TREE_FANOUT;
-		if (begin != group_begin && compute_left) {
-			WindowSegmentValue(tree, 0, begin, group_begin + tree.TREE_FANOUT, state_ptr);
-		}
-		idx_t group_end = parent_end * tree.TREE_FANOUT;
-		if (end != group_end && compute_right) {
-			WindowSegmentValue(tree, 0, group_end, end, state_ptr);
-		}
-	}
-	FlushStates(false);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_shared_expressions.cpp b/src/duckdb/src/function/window/window_shared_expressions.cpp
deleted file mode 100644
index 811d3ec57..000000000
--- a/src/duckdb/src/function/window/window_shared_expressions.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-column_t WindowSharedExpressions::RegisterExpr(const unique_ptr<Expression> &expr, Shared &shared) {
-	auto pexpr = expr.get();
-	if (!pexpr) {
-		return DConstants::INVALID_INDEX;
-	}
-
-	//	We need to make separate columns for volatile arguments
-	const auto is_volatile = expr->IsVolatile();
-	auto i = shared.columns.find(*pexpr);
-	if (i != shared.columns.end() && !is_volatile) {
-		return i->second.front();
-	}
-
-	// New column, find maximum column number
-	column_t result = shared.size++;
-	shared.columns[*pexpr].emplace_back(result);
-
-	return result;
-}
-
-vector<optional_ptr<const Expression>> WindowSharedExpressions::GetSortedExpressions(Shared &shared) {
-	vector<optional_ptr<const Expression>> sorted(shared.size);
-	for (auto &col : shared.columns) {
-		auto &expr = col.first.get();
-		for (auto col_idx : col.second) {
-			sorted[col_idx] = &expr;
-		}
-	}
-
-	return sorted;
-}
-void WindowSharedExpressions::PrepareExecutors(Shared &shared, ExpressionExecutor &exec, DataChunk &chunk) {
-	const auto sorted = GetSortedExpressions(shared);
-	vector<LogicalType> types;
-	for (auto expr : sorted) {
-		exec.AddExpression(*expr);
-		types.emplace_back(expr->return_type);
-	}
-
-	if (!types.empty()) {
-		chunk.Initialize(exec.GetAllocator(), types);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_token_tree.cpp b/src/duckdb/src/function/window/window_token_tree.cpp
deleted file mode 100644
index 82b5124e4..000000000
--- a/src/duckdb/src/function/window/window_token_tree.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include "duckdb/function/window/window_token_tree.hpp"
-
-namespace duckdb {
-
-class WindowTokenTreeLocalState : public WindowMergeSortTreeLocalState {
-public:
-	explicit WindowTokenTreeLocalState(WindowTokenTree &token_tree)
-	    : WindowMergeSortTreeLocalState(token_tree), token_tree(token_tree) {
-	}
-	//! Process sorted leaf data
-	void BuildLeaves() override;
-
-	WindowTokenTree &token_tree;
-};
-
-void WindowTokenTreeLocalState::BuildLeaves() {
-	auto &global_sort = *token_tree.global_sort;
-	if (global_sort.sorted_blocks.empty()) {
-		return;
-	}
-
-	//	Scan the sort keys and note deltas
-	SBIterator curr(global_sort, ExpressionType::COMPARE_LESSTHAN);
-	SBIterator prev(global_sort, ExpressionType::COMPARE_LESSTHAN);
-	const auto &sort_layout = global_sort.sort_layout;
-
-	const auto block_begin = token_tree.block_starts.at(build_task);
-	const auto block_end = token_tree.block_starts.at(build_task + 1);
-	auto &deltas = token_tree.deltas;
-	if (!block_begin) {
-		// First block, so set up initial delta
-		deltas[0] = 0;
-	} else {
-		// Move to the to end of the previous block
-		// so we can record the comparison result for the first row
-		curr.SetIndex(block_begin - 1);
-		prev.SetIndex(block_begin - 1);
-	}
-
-	for (++curr; curr.GetIndex() < block_end; ++curr, ++prev) {
-		int lt = 0;
-		if (sort_layout.all_constant) {
-			lt = FastMemcmp(prev.entry_ptr, curr.entry_ptr, sort_layout.comparison_size);
-		} else {
-			lt = Comparators::CompareTuple(prev.scan, curr.scan, prev.entry_ptr, curr.entry_ptr, sort_layout,
-			                               prev.external);
-		}
-
-		deltas[curr.GetIndex()] = (lt != 0);
-	}
-}
-
-idx_t WindowTokenTree::MeasurePayloadBlocks() {
-	const auto count = WindowMergeSortTree::MeasurePayloadBlocks();
-
-	deltas.resize(count);
-
-	return count;
-}
-
-template <typename T>
-static void BuildTokens(WindowTokenTree &token_tree, vector<T> &tokens) {
-	PayloadScanner scanner(*token_tree.global_sort);
-	DataChunk payload_chunk;
-	payload_chunk.Initialize(token_tree.context, token_tree.global_sort->payload_layout.GetTypes());
-	const T *row_idx = nullptr;
-	idx_t i = 0;
-
-	T token = 0;
-	for (auto &d : token_tree.deltas) {
-		if (i >= payload_chunk.size()) {
-			payload_chunk.Reset();
-			scanner.Scan(payload_chunk);
-			if (!payload_chunk.size()) {
-				break;
-			}
-			row_idx = FlatVector::GetData<T>(payload_chunk.data[0]);
-			i = 0;
-		}
-
-		token += d;
-		tokens[row_idx[i++]] = token;
-	}
-}
-
-unique_ptr<WindowAggregatorState> WindowTokenTree::GetLocalState() {
-	return make_uniq<WindowTokenTreeLocalState>(*this);
-}
-
-void WindowTokenTree::CleanupSort() {
-	//	Convert the deltas to tokens
-	if (mst64) {
-		BuildTokens(*this, mst64->LowestLevel());
-	} else {
-		BuildTokens(*this, mst32->LowestLevel());
-	}
-
-	// Deallocate memory
-	vector<uint8_t> empty;
-	deltas.swap(empty);
-
-	WindowMergeSortTree::CleanupSort();
-}
-
-template <typename TREE>
-static idx_t TokenRank(const TREE &tree, const idx_t lower, const idx_t upper, const idx_t row_idx) {
-	idx_t rank = 1;
-	const auto needle = tree.LowestLevel()[row_idx];
-	tree.AggregateLowerBound(lower, upper, needle, [&](idx_t level, const idx_t run_begin, const idx_t run_pos) {
-		rank += run_pos - run_begin;
-	});
-	return rank;
-}
-
-idx_t WindowTokenTree::Rank(const idx_t lower, const idx_t upper, const idx_t row_idx) const {
-	if (mst64) {
-		return TokenRank(*mst64, lower, upper, row_idx);
-	} else {
-		return TokenRank(*mst32, lower, upper, row_idx);
-	}
-}
-
-template <typename TREE>
-static idx_t NextPeer(const TREE &tree, const idx_t lower, const idx_t upper, const idx_t row_idx) {
-	idx_t rank = 0;
-	// Because tokens are dense, we can find the next peer by adding 1 to the probed token value
-	const auto needle = tree.LowestLevel()[row_idx] + 1;
-	tree.AggregateLowerBound(lower, upper, needle, [&](idx_t level, const idx_t run_begin, const idx_t run_pos) {
-		rank += run_pos - run_begin;
-	});
-	return rank;
-}
-
-idx_t WindowTokenTree::PeerEnd(const idx_t lower, const idx_t upper, const idx_t row_idx) const {
-	if (mst64) {
-		return NextPeer(*mst64, lower, upper, row_idx);
-	} else {
-		return NextPeer(*mst32, lower, upper, row_idx);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/function/window/window_value_function.cpp b/src/duckdb/src/function/window/window_value_function.cpp
deleted file mode 100644
index 6b8a7038e..000000000
--- a/src/duckdb/src/function/window/window_value_function.cpp
+++ /dev/null
@@ -1,566 +0,0 @@
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/function/window/window_aggregator.hpp"
-#include "duckdb/function/window/window_collection.hpp"
-#include "duckdb/function/window/window_index_tree.hpp"
-#include "duckdb/function/window/window_shared_expressions.hpp"
-#include "duckdb/function/window/window_token_tree.hpp"
-#include "duckdb/function/window/window_value_function.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// WindowValueGlobalState
-//===--------------------------------------------------------------------===//
-
-class WindowValueGlobalState : public WindowExecutorGlobalState {
-public:
-	using WindowCollectionPtr = unique_ptr<WindowCollection>;
-	WindowValueGlobalState(const WindowValueExecutor &executor, const idx_t payload_count,
-	                       const ValidityMask &partition_mask, const ValidityMask &order_mask)
-	    : WindowExecutorGlobalState(executor, payload_count, partition_mask, order_mask), ignore_nulls(&all_valid),
-	      child_idx(executor.child_idx) {
-
-		if (!executor.arg_order_idx.empty()) {
-			value_tree = make_uniq<WindowIndexTree>(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx,
-			                                        payload_count);
-		}
-	}
-
-	void Finalize(CollectionPtr collection) {
-		lock_guard<mutex> ignore_nulls_guard(lock);
-		if (child_idx != DConstants::INVALID_INDEX && executor.wexpr.ignore_nulls) {
-			ignore_nulls = &collection->validities[child_idx];
-		}
-	}
-
-	// IGNORE NULLS
-	mutex lock;
-	ValidityMask all_valid;
-	optional_ptr<ValidityMask> ignore_nulls;
-
-	//! Copy of the executor child_idx
-	const column_t child_idx;
-
-	//! Merge sort tree to map unfiltered row number to value
-	unique_ptr<WindowIndexTree> value_tree;
-};
-
-//===--------------------------------------------------------------------===//
-// WindowValueLocalState
-//===--------------------------------------------------------------------===//
-
-//! A class representing the state of the first_value, last_value and nth_value functions
-class WindowValueLocalState : public WindowExecutorBoundsState {
-public:
-	explicit WindowValueLocalState(const WindowValueGlobalState &gvstate)
-	    : WindowExecutorBoundsState(gvstate), gvstate(gvstate) {
-		WindowAggregatorLocalState::InitSubFrames(frames, gvstate.executor.wexpr.exclude_clause);
-
-		if (gvstate.value_tree) {
-			local_value = gvstate.value_tree->GetLocalState();
-			if (gvstate.executor.wexpr.ignore_nulls) {
-				sort_nulls.Initialize();
-			}
-		}
-	}
-
-	//! Accumulate the secondary sort values
-	void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx) override;
-	//! Finish the sinking and prepare to scan
-	void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) override;
-
-	//! The corresponding global value state
-	const WindowValueGlobalState &gvstate;
-	//! The optional sorting state for secondary sorts
-	unique_ptr<WindowAggregatorState> local_value;
-	//! Reusable selection vector for NULLs
-	SelectionVector sort_nulls;
-	//! The frame boundaries, used for EXCLUDE
-	SubFrames frames;
-
-	//! The state used for reading the collection
-	unique_ptr<WindowCursor> cursor;
-};
-
-void WindowValueLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-                                 idx_t input_idx) {
-	WindowExecutorBoundsState::Sink(gstate, sink_chunk, coll_chunk, input_idx);
-
-	if (local_value) {
-		idx_t filtered = 0;
-		optional_ptr<SelectionVector> filter_sel;
-
-		// If we need to IGNORE NULLS for the child, and there are NULLs,
-		// then build an SV to hold them
-		const auto coll_count = coll_chunk.size();
-		auto &child = coll_chunk.data[gvstate.child_idx];
-		UnifiedVectorFormat child_data;
-		child.ToUnifiedFormat(coll_count, child_data);
-		const auto &validity = child_data.validity;
-		if (gstate.executor.wexpr.ignore_nulls && !validity.AllValid()) {
-			for (sel_t i = 0; i < coll_count; ++i) {
-				if (validity.RowIsValidUnsafe(i)) {
-					sort_nulls[filtered++] = i;
-				}
-			}
-			filter_sel = &sort_nulls;
-		}
-
-		auto &value_state = local_value->Cast<WindowIndexTreeLocalState>();
-		value_state.SinkChunk(sink_chunk, input_idx, filter_sel, filtered);
-	}
-}
-
-void WindowValueLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) {
-	WindowExecutorBoundsState::Finalize(gstate, collection);
-
-	if (local_value) {
-		auto &value_state = local_value->Cast<WindowIndexTreeLocalState>();
-		value_state.Sort();
-		value_state.index_tree.Build();
-	}
-
-	// Prepare to scan
-	if (!cursor && gvstate.child_idx != DConstants::INVALID_INDEX) {
-		cursor = make_uniq<WindowCursor>(*collection, gvstate.child_idx);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowValueExecutor
-//===--------------------------------------------------------------------===//
-WindowValueExecutor::WindowValueExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                         WindowSharedExpressions &shared)
-    : WindowExecutor(wexpr, context, shared) {
-
-	for (const auto &order : wexpr.arg_orders) {
-		arg_order_idx.emplace_back(shared.RegisterSink(order.expression));
-	}
-
-	//	The children have to be handled separately because only the first one is global
-	if (!wexpr.children.empty()) {
-		child_idx = shared.RegisterCollection(wexpr.children[0], wexpr.ignore_nulls);
-
-		if (wexpr.children.size() > 1) {
-			nth_idx = shared.RegisterEvaluate(wexpr.children[1]);
-		}
-	}
-
-	offset_idx = shared.RegisterEvaluate(wexpr.offset_expr);
-	default_idx = shared.RegisterEvaluate(wexpr.default_expr);
-}
-
-unique_ptr<WindowExecutorGlobalState> WindowValueExecutor::GetGlobalState(const idx_t payload_count,
-                                                                          const ValidityMask &partition_mask,
-                                                                          const ValidityMask &order_mask) const {
-	return make_uniq<WindowValueGlobalState>(*this, payload_count, partition_mask, order_mask);
-}
-
-void WindowValueExecutor::Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                   CollectionPtr collection) const {
-	auto &gvstate = gstate.Cast<WindowValueGlobalState>();
-	gvstate.Finalize(collection);
-
-	WindowExecutor::Finalize(gstate, lstate, collection);
-}
-
-unique_ptr<WindowExecutorLocalState> WindowValueExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	const auto &gvstate = gstate.Cast<WindowValueGlobalState>();
-	return make_uniq<WindowValueLocalState>(gvstate);
-}
-
-//===--------------------------------------------------------------------===//
-// WindowLeadLagGlobalState
-//===--------------------------------------------------------------------===//
-// The functions LEAD and LAG can be extended to a windowed version with
-// two independent ORDER BY clauses just like first_value and other value
-// functions.
-// To evaluate a windowed LEAD/LAG, one has to (1) compute the ROW_NUMBER
-// of the own row, (2) adjust the row number by adding or subtracting an
-// offset, (3) find the row at that offset, and (4) evaluate the expression
-// provided to LEAD/LAG on this row. One can use the algorithm from Section
-// 4.4 to determine the row number of the own row (step 1) and the
-// algorithm from Section 4.5 to find the row with the adjusted position
-// (step 3). Both algorithms are in O(𝑛 log𝑛), so the overall algorithm
-// for LEAD/LAG is also O(𝑛 log𝑛).
-//
-// 4.4: unique WindowTokenTree
-// 4.5: WindowIndexTree
-
-class WindowLeadLagGlobalState : public WindowValueGlobalState {
-public:
-	explicit WindowLeadLagGlobalState(const WindowValueExecutor &executor, const idx_t payload_count,
-	                                  const ValidityMask &partition_mask, const ValidityMask &order_mask)
-	    : WindowValueGlobalState(executor, payload_count, partition_mask, order_mask) {
-
-		if (value_tree) {
-			//	"The ROW_NUMBER function can be computed by disambiguating duplicate elements based on their position in
-			//	the input data, such that two elements never compare as equal."
-			// 	Note: If the user specifies an partial secondary sort, the disambiguation will use the
-			//	partition's row numbers, not the secondary sort's row numbers.
-			row_tree = make_uniq<WindowTokenTree>(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx,
-			                                      payload_count, true);
-		}
-	}
-
-	//! Merge sort tree to map partition offset to row number (algorithm from Section 4.5)
-	unique_ptr<WindowTokenTree> row_tree;
-};
-
-//===--------------------------------------------------------------------===//
-// WindowLeadLagLocalState
-//===--------------------------------------------------------------------===//
-class WindowLeadLagLocalState : public WindowValueLocalState {
-public:
-	explicit WindowLeadLagLocalState(const WindowLeadLagGlobalState &gstate) : WindowValueLocalState(gstate) {
-		if (gstate.row_tree) {
-			local_row = gstate.row_tree->GetLocalState();
-		}
-	}
-
-	//! Accumulate the secondary sort values
-	void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx) override;
-	//! Finish the sinking and prepare to scan
-	void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) override;
-
-	//! The optional sorting state for the secondary sort row mapping
-	unique_ptr<WindowAggregatorState> local_row;
-};
-
-void WindowLeadLagLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-                                   idx_t input_idx) {
-	WindowValueLocalState::Sink(gstate, sink_chunk, coll_chunk, input_idx);
-
-	if (local_row) {
-		idx_t filtered = 0;
-		optional_ptr<SelectionVector> filter_sel;
-
-		auto &row_state = local_row->Cast<WindowMergeSortTreeLocalState>();
-		row_state.SinkChunk(sink_chunk, input_idx, filter_sel, filtered);
-	}
-}
-
-void WindowLeadLagLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) {
-	WindowValueLocalState::Finalize(gstate, collection);
-
-	if (local_row) {
-		auto &row_state = local_row->Cast<WindowMergeSortTreeLocalState>();
-		row_state.Sort();
-		row_state.window_tree.Build();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// WindowLeadLagExecutor
-//===--------------------------------------------------------------------===//
-WindowLeadLagExecutor::WindowLeadLagExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                             WindowSharedExpressions &shared)
-    : WindowValueExecutor(wexpr, context, shared) {
-}
-
-unique_ptr<WindowExecutorGlobalState> WindowLeadLagExecutor::GetGlobalState(const idx_t payload_count,
-                                                                            const ValidityMask &partition_mask,
-                                                                            const ValidityMask &order_mask) const {
-	return make_uniq<WindowLeadLagGlobalState>(*this, payload_count, partition_mask, order_mask);
-}
-
-unique_ptr<WindowExecutorLocalState>
-WindowLeadLagExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	const auto &glstate = gstate.Cast<WindowLeadLagGlobalState>();
-	return make_uniq<WindowLeadLagLocalState>(glstate);
-}
-
-void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                             DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &glstate = gstate.Cast<WindowLeadLagGlobalState>();
-	auto &llstate = lstate.Cast<WindowLeadLagLocalState>();
-	auto &cursor = *llstate.cursor;
-
-	WindowInputExpression leadlag_offset(eval_chunk, offset_idx);
-	WindowInputExpression leadlag_default(eval_chunk, default_idx);
-
-	if (glstate.row_tree) {
-		auto frame_begin = FlatVector::GetData<const idx_t>(llstate.bounds.data[FRAME_BEGIN]);
-		auto frame_end = FlatVector::GetData<const idx_t>(llstate.bounds.data[FRAME_END]);
-		// TODO: Handle subframes.
-		auto &frames = llstate.frames;
-		frames.resize(1);
-		auto &frame = frames[0];
-		for (idx_t i = 0; i < count; ++i, ++row_idx) {
-			// (1) compute the ROW_NUMBER of the own row
-			frame = FrameBounds(frame_begin[i], frame_end[i]);
-			const auto own_row = glstate.row_tree->Rank(frame.start, frame.end, row_idx) - 1;
-			// (2) adjust the row number by adding or subtracting an offset
-			auto val_idx = NumericCast<int64_t>(own_row);
-			int64_t offset = 1;
-			if (wexpr.offset_expr) {
-				offset = leadlag_offset.GetCell<int64_t>(i);
-			}
-			if (wexpr.GetExpressionType() == ExpressionType::WINDOW_LEAD) {
-				val_idx = AddOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(val_idx, offset);
-			} else {
-				val_idx = SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(val_idx, offset);
-			}
-			const auto frame_width = NumericCast<int64_t>(frame.end - frame.start);
-			if (val_idx >= 0 && val_idx < frame_width) {
-				// (3) find the row at that offset
-				const auto n = NumericCast<idx_t>(val_idx);
-				const auto nth_index = glstate.value_tree->SelectNth(frames, n);
-				// (4) evaluate the expression provided to LEAD/LAG on this row.
-				cursor.CopyCell(0, nth_index, result, i);
-			} else if (wexpr.default_expr) {
-				leadlag_default.CopyCell(result, i);
-			} else {
-				FlatVector::SetNull(result, i, true);
-			}
-		}
-		return;
-	}
-
-	auto partition_begin = FlatVector::GetData<const idx_t>(llstate.bounds.data[PARTITION_BEGIN]);
-	auto partition_end = FlatVector::GetData<const idx_t>(llstate.bounds.data[PARTITION_END]);
-
-	auto &ignore_nulls = glstate.ignore_nulls;
-	bool can_shift = ignore_nulls->AllValid();
-	if (wexpr.offset_expr) {
-		can_shift = can_shift && wexpr.offset_expr->IsFoldable();
-	}
-	if (wexpr.default_expr) {
-		can_shift = can_shift && wexpr.default_expr->IsFoldable();
-	}
-
-	const auto row_end = row_idx + count;
-	for (idx_t i = 0; i < count;) {
-		int64_t offset = 1;
-		if (wexpr.offset_expr) {
-			offset = leadlag_offset.GetCell<int64_t>(i);
-		}
-		int64_t val_idx = (int64_t)row_idx;
-		if (wexpr.GetExpressionType() == ExpressionType::WINDOW_LEAD) {
-			val_idx = AddOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(val_idx, offset);
-		} else {
-			val_idx = SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(val_idx, offset);
-		}
-
-		idx_t delta = 0;
-		if (val_idx < (int64_t)row_idx) {
-			// Count backwards
-			delta = idx_t(row_idx - idx_t(val_idx));
-			val_idx = int64_t(WindowBoundariesState::FindPrevStart(*ignore_nulls, partition_begin[i], row_idx, delta));
-		} else if (val_idx > (int64_t)row_idx) {
-			delta = idx_t(idx_t(val_idx) - row_idx);
-			val_idx =
-			    int64_t(WindowBoundariesState::FindNextStart(*ignore_nulls, row_idx + 1, partition_end[i], delta));
-		}
-		// else offset is zero, so don't move.
-
-		if (can_shift) {
-			const auto target_limit = MinValue(partition_end[i], row_end) - row_idx;
-			if (!delta) {
-				//	Copy source[index:index+width] => result[i:]
-				auto index = NumericCast<idx_t>(val_idx);
-				const auto source_limit = partition_end[i] - index;
-				auto width = MinValue(source_limit, target_limit);
-				// We may have to scan multiple blocks here, so loop until we have copied everything
-				const idx_t col_idx = 0;
-				while (width) {
-					const auto source_offset = cursor.Seek(index);
-					auto &source = cursor.chunk.data[col_idx];
-					const auto copied = MinValue<idx_t>(cursor.chunk.size() - source_offset, width);
-					VectorOperations::Copy(source, result, source_offset + copied, source_offset, i);
-					i += copied;
-					row_idx += copied;
-					index += copied;
-					width -= copied;
-				}
-			} else if (wexpr.default_expr) {
-				const auto width = MinValue(delta, target_limit);
-				leadlag_default.CopyCell(result, i, width);
-				i += width;
-				row_idx += width;
-			} else {
-				for (idx_t nulls = MinValue(delta, target_limit); nulls--; ++i, ++row_idx) {
-					FlatVector::SetNull(result, i, true);
-				}
-			}
-		} else {
-			if (!delta) {
-				cursor.CopyCell(0, NumericCast<idx_t>(val_idx), result, i);
-			} else if (wexpr.default_expr) {
-				leadlag_default.CopyCell(result, i);
-			} else {
-				FlatVector::SetNull(result, i, true);
-			}
-			++i;
-			++row_idx;
-		}
-	}
-}
-
-WindowFirstValueExecutor::WindowFirstValueExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                   WindowSharedExpressions &shared)
-    : WindowValueExecutor(wexpr, context, shared) {
-}
-
-void WindowFirstValueExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                                DataChunk &eval_chunk, Vector &result, idx_t count,
-                                                idx_t row_idx) const {
-	auto &gvstate = gstate.Cast<WindowValueGlobalState>();
-	auto &lvstate = lstate.Cast<WindowValueLocalState>();
-	auto &cursor = *lvstate.cursor;
-	auto &bounds = lvstate.bounds;
-	auto &frames = lvstate.frames;
-	auto &ignore_nulls = *gvstate.ignore_nulls;
-	auto exclude_mode = gvstate.executor.wexpr.exclude_clause;
-	WindowAggregator::EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) {
-		if (gvstate.value_tree) {
-			idx_t frame_width = 0;
-			for (const auto &frame : frames) {
-				frame_width += frame.end - frame.start;
-			}
-
-			if (frame_width) {
-				const auto first_idx = gvstate.value_tree->SelectNth(frames, 0);
-				cursor.CopyCell(0, first_idx, result, i);
-			} else {
-				FlatVector::SetNull(result, i, true);
-			}
-			return;
-		}
-
-		for (const auto &frame : frames) {
-			if (frame.start >= frame.end) {
-				continue;
-			}
-
-			//	Same as NTH_VALUE(..., 1)
-			idx_t n = 1;
-			const auto first_idx = WindowBoundariesState::FindNextStart(ignore_nulls, frame.start, frame.end, n);
-			if (!n) {
-				cursor.CopyCell(0, first_idx, result, i);
-				return;
-			}
-		}
-
-		// Didn't find one
-		FlatVector::SetNull(result, i, true);
-	});
-}
-
-WindowLastValueExecutor::WindowLastValueExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                 WindowSharedExpressions &shared)
-    : WindowValueExecutor(wexpr, context, shared) {
-}
-
-void WindowLastValueExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                               DataChunk &eval_chunk, Vector &result, idx_t count,
-                                               idx_t row_idx) const {
-	auto &gvstate = gstate.Cast<WindowValueGlobalState>();
-	auto &lvstate = lstate.Cast<WindowValueLocalState>();
-	auto &cursor = *lvstate.cursor;
-	auto &bounds = lvstate.bounds;
-	auto &frames = lvstate.frames;
-	auto &ignore_nulls = *gvstate.ignore_nulls;
-	auto exclude_mode = gvstate.executor.wexpr.exclude_clause;
-	WindowAggregator::EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) {
-		if (gvstate.value_tree) {
-			idx_t frame_width = 0;
-			for (const auto &frame : frames) {
-				frame_width += frame.end - frame.start;
-			}
-
-			if (frame_width) {
-				const auto last_idx = gvstate.value_tree->SelectNth(frames, frame_width - 1);
-				cursor.CopyCell(0, last_idx, result, i);
-			} else {
-				FlatVector::SetNull(result, i, true);
-			}
-			return;
-		}
-
-		for (idx_t f = frames.size(); f-- > 0;) {
-			const auto &frame = frames[f];
-			if (frame.start >= frame.end) {
-				continue;
-			}
-
-			idx_t n = 1;
-			const auto last_idx = WindowBoundariesState::FindPrevStart(ignore_nulls, frame.start, frame.end, n);
-			if (!n) {
-				cursor.CopyCell(0, last_idx, result, i);
-				return;
-			}
-		}
-
-		// Didn't find one
-		FlatVector::SetNull(result, i, true);
-	});
-}
-
-WindowNthValueExecutor::WindowNthValueExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                               WindowSharedExpressions &shared)
-    : WindowValueExecutor(wexpr, context, shared) {
-}
-
-void WindowNthValueExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                              DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &gvstate = gstate.Cast<WindowValueGlobalState>();
-	auto &lvstate = lstate.Cast<WindowValueLocalState>();
-	auto &cursor = *lvstate.cursor;
-	auto &bounds = lvstate.bounds;
-	auto &frames = lvstate.frames;
-	auto &ignore_nulls = *gvstate.ignore_nulls;
-	auto exclude_mode = gvstate.executor.wexpr.exclude_clause;
-	D_ASSERT(cursor.chunk.ColumnCount() == 1);
-	WindowInputExpression nth_col(eval_chunk, nth_idx);
-	WindowAggregator::EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) {
-		// Returns value evaluated at the row that is the n'th row of the window frame (counting from 1);
-		// returns NULL if there is no such row.
-		if (nth_col.CellIsNull(i)) {
-			FlatVector::SetNull(result, i, true);
-			return;
-		}
-		auto n_param = nth_col.GetCell<int64_t>(i);
-		if (n_param < 1) {
-			FlatVector::SetNull(result, i, true);
-			return;
-		}
-
-		//	Decrement as we go along.
-		auto n = idx_t(n_param);
-
-		if (gvstate.value_tree) {
-			idx_t frame_width = 0;
-			for (const auto &frame : frames) {
-				frame_width += frame.end - frame.start;
-			}
-
-			if (n < frame_width) {
-				const auto nth_index = gvstate.value_tree->SelectNth(frames, n - 1);
-				cursor.CopyCell(0, nth_index, result, i);
-			} else {
-				FlatVector::SetNull(result, i, true);
-			}
-			return;
-		}
-
-		for (const auto &frame : frames) {
-			if (frame.start >= frame.end) {
-				continue;
-			}
-
-			const auto nth_index = WindowBoundariesState::FindNextStart(ignore_nulls, frame.start, frame.end, n);
-			if (!n) {
-				cursor.CopyCell(0, nth_index, result, i);
-				return;
-			}
-		}
-		FlatVector::SetNull(result, i, true);
-	});
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb.h b/src/duckdb/src/include/duckdb.h
deleted file mode 100644
index ae52abd33..000000000
--- a/src/duckdb/src/include/duckdb.h
+++ /dev/null
@@ -1,4545 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                         DuckDB
-//
-// duckdb.h
-//
-//
-//===----------------------------------------------------------------------===//
-//
-// !!!!!!!
-// WARNING: this file is autogenerated by scripts/generate_c_api.py, manual changes will be overwritten
-// !!!!!!!
-
-#pragma once
-
-//! duplicate of duckdb/main/winapi.hpp
-#ifndef DUCKDB_API
-#ifdef _WIN32
-#ifdef DUCKDB_STATIC_BUILD
-#define DUCKDB_API
-#else
-#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
-#define DUCKDB_API __declspec(dllexport)
-#else
-#define DUCKDB_API __declspec(dllimport)
-#endif
-#endif
-#else
-#define DUCKDB_API
-#endif
-#endif
-
-//! duplicate of duckdb/main/winapi.hpp
-#ifndef DUCKDB_EXTENSION_API
-#ifdef _WIN32
-#ifdef DUCKDB_STATIC_BUILD
-#define DUCKDB_EXTENSION_API
-#else
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
-#define DUCKDB_EXTENSION_API __declspec(dllexport)
-#else
-#define DUCKDB_EXTENSION_API
-#endif
-#endif
-#else
-#define DUCKDB_EXTENSION_API __attribute__((visibility("default")))
-#endif
-#endif
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//===--------------------------------------------------------------------===//
-// Enums
-//===--------------------------------------------------------------------===//
-// WARNING: the numbers of these enums should not be changed, as changing the numbers breaks ABI compatibility
-// Always add enums at the END of the enum
-//! An enum over DuckDB's internal types.
-typedef enum DUCKDB_TYPE {
-	DUCKDB_TYPE_INVALID = 0,
-	// bool
-	DUCKDB_TYPE_BOOLEAN = 1,
-	// int8_t
-	DUCKDB_TYPE_TINYINT = 2,
-	// int16_t
-	DUCKDB_TYPE_SMALLINT = 3,
-	// int32_t
-	DUCKDB_TYPE_INTEGER = 4,
-	// int64_t
-	DUCKDB_TYPE_BIGINT = 5,
-	// uint8_t
-	DUCKDB_TYPE_UTINYINT = 6,
-	// uint16_t
-	DUCKDB_TYPE_USMALLINT = 7,
-	// uint32_t
-	DUCKDB_TYPE_UINTEGER = 8,
-	// uint64_t
-	DUCKDB_TYPE_UBIGINT = 9,
-	// float
-	DUCKDB_TYPE_FLOAT = 10,
-	// double
-	DUCKDB_TYPE_DOUBLE = 11,
-	// duckdb_timestamp (microseconds)
-	DUCKDB_TYPE_TIMESTAMP = 12,
-	// duckdb_date
-	DUCKDB_TYPE_DATE = 13,
-	// duckdb_time
-	DUCKDB_TYPE_TIME = 14,
-	// duckdb_interval
-	DUCKDB_TYPE_INTERVAL = 15,
-	// duckdb_hugeint
-	DUCKDB_TYPE_HUGEINT = 16,
-	// duckdb_uhugeint
-	DUCKDB_TYPE_UHUGEINT = 32,
-	// const char*
-	DUCKDB_TYPE_VARCHAR = 17,
-	// duckdb_blob
-	DUCKDB_TYPE_BLOB = 18,
-	// duckdb_decimal
-	DUCKDB_TYPE_DECIMAL = 19,
-	// duckdb_timestamp_s (seconds)
-	DUCKDB_TYPE_TIMESTAMP_S = 20,
-	// duckdb_timestamp_ms (milliseconds)
-	DUCKDB_TYPE_TIMESTAMP_MS = 21,
-	// duckdb_timestamp_ns (nanoseconds)
-	DUCKDB_TYPE_TIMESTAMP_NS = 22,
-	// enum type, only useful as logical type
-	DUCKDB_TYPE_ENUM = 23,
-	// list type, only useful as logical type
-	DUCKDB_TYPE_LIST = 24,
-	// struct type, only useful as logical type
-	DUCKDB_TYPE_STRUCT = 25,
-	// map type, only useful as logical type
-	DUCKDB_TYPE_MAP = 26,
-	// duckdb_array, only useful as logical type
-	DUCKDB_TYPE_ARRAY = 33,
-	// duckdb_hugeint
-	DUCKDB_TYPE_UUID = 27,
-	// union type, only useful as logical type
-	DUCKDB_TYPE_UNION = 28,
-	// duckdb_bit
-	DUCKDB_TYPE_BIT = 29,
-	// duckdb_time_tz
-	DUCKDB_TYPE_TIME_TZ = 30,
-	// duckdb_timestamp (microseconds)
-	DUCKDB_TYPE_TIMESTAMP_TZ = 31,
-	// ANY type
-	DUCKDB_TYPE_ANY = 34,
-	// duckdb_varint
-	DUCKDB_TYPE_VARINT = 35,
-	// SQLNULL type
-	DUCKDB_TYPE_SQLNULL = 36,
-} duckdb_type;
-//! An enum over the returned state of different functions.
-typedef enum duckdb_state { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
-//! An enum over the pending state of a pending query result.
-typedef enum duckdb_pending_state {
-	DUCKDB_PENDING_RESULT_READY = 0,
-	DUCKDB_PENDING_RESULT_NOT_READY = 1,
-	DUCKDB_PENDING_ERROR = 2,
-	DUCKDB_PENDING_NO_TASKS_AVAILABLE = 3
-} duckdb_pending_state;
-//! An enum over DuckDB's different result types.
-typedef enum duckdb_result_type {
-	DUCKDB_RESULT_TYPE_INVALID = 0,
-	DUCKDB_RESULT_TYPE_CHANGED_ROWS = 1,
-	DUCKDB_RESULT_TYPE_NOTHING = 2,
-	DUCKDB_RESULT_TYPE_QUERY_RESULT = 3,
-} duckdb_result_type;
-//! An enum over DuckDB's different statement types.
-typedef enum duckdb_statement_type {
-	DUCKDB_STATEMENT_TYPE_INVALID = 0,
-	DUCKDB_STATEMENT_TYPE_SELECT = 1,
-	DUCKDB_STATEMENT_TYPE_INSERT = 2,
-	DUCKDB_STATEMENT_TYPE_UPDATE = 3,
-	DUCKDB_STATEMENT_TYPE_EXPLAIN = 4,
-	DUCKDB_STATEMENT_TYPE_DELETE = 5,
-	DUCKDB_STATEMENT_TYPE_PREPARE = 6,
-	DUCKDB_STATEMENT_TYPE_CREATE = 7,
-	DUCKDB_STATEMENT_TYPE_EXECUTE = 8,
-	DUCKDB_STATEMENT_TYPE_ALTER = 9,
-	DUCKDB_STATEMENT_TYPE_TRANSACTION = 10,
-	DUCKDB_STATEMENT_TYPE_COPY = 11,
-	DUCKDB_STATEMENT_TYPE_ANALYZE = 12,
-	DUCKDB_STATEMENT_TYPE_VARIABLE_SET = 13,
-	DUCKDB_STATEMENT_TYPE_CREATE_FUNC = 14,
-	DUCKDB_STATEMENT_TYPE_DROP = 15,
-	DUCKDB_STATEMENT_TYPE_EXPORT = 16,
-	DUCKDB_STATEMENT_TYPE_PRAGMA = 17,
-	DUCKDB_STATEMENT_TYPE_VACUUM = 18,
-	DUCKDB_STATEMENT_TYPE_CALL = 19,
-	DUCKDB_STATEMENT_TYPE_SET = 20,
-	DUCKDB_STATEMENT_TYPE_LOAD = 21,
-	DUCKDB_STATEMENT_TYPE_RELATION = 22,
-	DUCKDB_STATEMENT_TYPE_EXTENSION = 23,
-	DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN = 24,
-	DUCKDB_STATEMENT_TYPE_ATTACH = 25,
-	DUCKDB_STATEMENT_TYPE_DETACH = 26,
-	DUCKDB_STATEMENT_TYPE_MULTI = 27,
-} duckdb_statement_type;
-//! An enum over DuckDB's different result types.
-typedef enum duckdb_error_type {
-	DUCKDB_ERROR_INVALID = 0,
-	DUCKDB_ERROR_OUT_OF_RANGE = 1,
-	DUCKDB_ERROR_CONVERSION = 2,
-	DUCKDB_ERROR_UNKNOWN_TYPE = 3,
-	DUCKDB_ERROR_DECIMAL = 4,
-	DUCKDB_ERROR_MISMATCH_TYPE = 5,
-	DUCKDB_ERROR_DIVIDE_BY_ZERO = 6,
-	DUCKDB_ERROR_OBJECT_SIZE = 7,
-	DUCKDB_ERROR_INVALID_TYPE = 8,
-	DUCKDB_ERROR_SERIALIZATION = 9,
-	DUCKDB_ERROR_TRANSACTION = 10,
-	DUCKDB_ERROR_NOT_IMPLEMENTED = 11,
-	DUCKDB_ERROR_EXPRESSION = 12,
-	DUCKDB_ERROR_CATALOG = 13,
-	DUCKDB_ERROR_PARSER = 14,
-	DUCKDB_ERROR_PLANNER = 15,
-	DUCKDB_ERROR_SCHEDULER = 16,
-	DUCKDB_ERROR_EXECUTOR = 17,
-	DUCKDB_ERROR_CONSTRAINT = 18,
-	DUCKDB_ERROR_INDEX = 19,
-	DUCKDB_ERROR_STAT = 20,
-	DUCKDB_ERROR_CONNECTION = 21,
-	DUCKDB_ERROR_SYNTAX = 22,
-	DUCKDB_ERROR_SETTINGS = 23,
-	DUCKDB_ERROR_BINDER = 24,
-	DUCKDB_ERROR_NETWORK = 25,
-	DUCKDB_ERROR_OPTIMIZER = 26,
-	DUCKDB_ERROR_NULL_POINTER = 27,
-	DUCKDB_ERROR_IO = 28,
-	DUCKDB_ERROR_INTERRUPT = 29,
-	DUCKDB_ERROR_FATAL = 30,
-	DUCKDB_ERROR_INTERNAL = 31,
-	DUCKDB_ERROR_INVALID_INPUT = 32,
-	DUCKDB_ERROR_OUT_OF_MEMORY = 33,
-	DUCKDB_ERROR_PERMISSION = 34,
-	DUCKDB_ERROR_PARAMETER_NOT_RESOLVED = 35,
-	DUCKDB_ERROR_PARAMETER_NOT_ALLOWED = 36,
-	DUCKDB_ERROR_DEPENDENCY = 37,
-	DUCKDB_ERROR_HTTP = 38,
-	DUCKDB_ERROR_MISSING_EXTENSION = 39,
-	DUCKDB_ERROR_AUTOLOAD = 40,
-	DUCKDB_ERROR_SEQUENCE = 41,
-	DUCKDB_INVALID_CONFIGURATION = 42
-} duckdb_error_type;
-//! An enum over DuckDB's different cast modes.
-typedef enum duckdb_cast_mode { DUCKDB_CAST_NORMAL = 0, DUCKDB_CAST_TRY = 1 } duckdb_cast_mode;
-
-//===--------------------------------------------------------------------===//
-// General type definitions
-//===--------------------------------------------------------------------===//
-
-//! DuckDB's index type.
-typedef uint64_t idx_t;
-
-//! The callback that will be called to destroy data, e.g.,
-//! bind data (if any), init data (if any), extra data for replacement scans (if any)
-typedef void (*duckdb_delete_callback_t)(void *data);
-
-//! Used for threading, contains a task state. Must be destroyed with `duckdb_destroy_state`.
-typedef void *duckdb_task_state;
-
-//===--------------------------------------------------------------------===//
-// Types (no explicit freeing)
-//===--------------------------------------------------------------------===//
-
-//! Days are stored as days since 1970-01-01
-//! Use the duckdb_from_date/duckdb_to_date function to extract individual information
-typedef struct {
-	int32_t days;
-} duckdb_date;
-typedef struct {
-	int32_t year;
-	int8_t month;
-	int8_t day;
-} duckdb_date_struct;
-
-//! Time is stored as microseconds since 00:00:00
-//! Use the duckdb_from_time/duckdb_to_time function to extract individual information
-typedef struct {
-	int64_t micros;
-} duckdb_time;
-typedef struct {
-	int8_t hour;
-	int8_t min;
-	int8_t sec;
-	int32_t micros;
-} duckdb_time_struct;
-
-//! TIME_TZ is stored as 40 bits for int64_t micros, and 24 bits for int32_t offset
-typedef struct {
-	uint64_t bits;
-} duckdb_time_tz;
-typedef struct {
-	duckdb_time_struct time;
-	int32_t offset;
-} duckdb_time_tz_struct;
-
-//! TIMESTAMP values are stored as microseconds since 1970-01-01.
-//! Use the duckdb_from_timestamp and duckdb_to_timestamp functions to extract individual information.
-typedef struct {
-	int64_t micros;
-} duckdb_timestamp;
-
-//! TIMESTAMP_S values are stored as seconds since 1970-01-01.
-typedef struct {
-	int64_t seconds;
-} duckdb_timestamp_s;
-
-//! TIMESTAMP_MS values are stored as milliseconds since 1970-01-01.
-typedef struct {
-	int64_t millis;
-} duckdb_timestamp_ms;
-
-//! TIMESTAMP_NS values are stored as nanoseconds since 1970-01-01.
-typedef struct {
-	int64_t nanos;
-} duckdb_timestamp_ns;
-
-typedef struct {
-	duckdb_date_struct date;
-	duckdb_time_struct time;
-} duckdb_timestamp_struct;
-
-typedef struct {
-	int32_t months;
-	int32_t days;
-	int64_t micros;
-} duckdb_interval;
-
-//! Hugeints are composed of a (lower, upper) component
-//! The value of the hugeint is upper * 2^64 + lower
-//! For easy usage, the functions duckdb_hugeint_to_double/duckdb_double_to_hugeint are recommended
-typedef struct {
-	uint64_t lower;
-	int64_t upper;
-} duckdb_hugeint;
-typedef struct {
-	uint64_t lower;
-	uint64_t upper;
-} duckdb_uhugeint;
-
-//! Decimals are composed of a width and a scale, and are stored in a hugeint
-typedef struct {
-	uint8_t width;
-	uint8_t scale;
-	duckdb_hugeint value;
-} duckdb_decimal;
-
-//! A type holding information about the query execution progress
-typedef struct {
-	double percentage;
-	uint64_t rows_processed;
-	uint64_t total_rows_to_process;
-} duckdb_query_progress_type;
-
-//! The internal representation of a VARCHAR (string_t). If the VARCHAR does not
-//! exceed 12 characters, then we inline it. Otherwise, we inline a prefix for faster
-//! string comparisons and store a pointer to the remaining characters. This is a non-
-//! owning structure, i.e., it does not have to be freed.
-typedef struct {
-	union {
-		struct {
-			uint32_t length;
-			char prefix[4];
-			char *ptr;
-		} pointer;
-		struct {
-			uint32_t length;
-			char inlined[12];
-		} inlined;
-	} value;
-} duckdb_string_t;
-
-//! The internal representation of a list metadata entry contains the list's offset in
-//! the child vector, and its length. The parent vector holds these metadata entries,
-//! whereas the child vector holds the data
-typedef struct {
-	uint64_t offset;
-	uint64_t length;
-} duckdb_list_entry;
-
-//! A column consists of a pointer to its internal data. Don't operate on this type directly.
-//! Instead, use functions such as duckdb_column_data, duckdb_nullmask_data,
-//! duckdb_column_type, and duckdb_column_name, which take the result and the column index
-//! as their parameters
-typedef struct {
-	// deprecated, use duckdb_column_data
-	void *deprecated_data;
-	// deprecated, use duckdb_nullmask_data
-	bool *deprecated_nullmask;
-	// deprecated, use duckdb_column_type
-	duckdb_type deprecated_type;
-	// deprecated, use duckdb_column_name
-	char *deprecated_name;
-	void *internal_data;
-} duckdb_column;
-
-//! A vector to a specified column in a data chunk. Lives as long as the
-//! data chunk lives, i.e., must not be destroyed.
-typedef struct _duckdb_vector {
-	void *internal_ptr;
-} * duckdb_vector;
-
-//===--------------------------------------------------------------------===//
-// Types (explicit freeing/destroying)
-//===--------------------------------------------------------------------===//
-
-//! Strings are composed of a char pointer and a size. You must free string.data
-//! with `duckdb_free`.
-typedef struct {
-	char *data;
-	idx_t size;
-} duckdb_string;
-
-//! BLOBs are composed of a byte pointer and a size. You must free blob.data
-//! with `duckdb_free`.
-typedef struct {
-	void *data;
-	idx_t size;
-} duckdb_blob;
-
-//! BITs are composed of a byte pointer and a size.
-//! BIT byte data has 0 to 7 bits of padding.
-//! The first byte contains the number of padding bits.
-//! This number of bits of the second byte are set to 1, starting from the MSB.
-//! You must free `data` with `duckdb_free`.
-typedef struct {
-	uint8_t *data;
-	idx_t size;
-} duckdb_bit;
-
-//! VARINTs are composed of a byte pointer, a size, and an is_negative bool.
-//! The absolute value of the number is stored in `data` in little endian format.
-//! You must free `data` with `duckdb_free`.
-typedef struct {
-	uint8_t *data;
-	idx_t size;
-	bool is_negative;
-} duckdb_varint;
-
-//! A query result consists of a pointer to its internal data.
-//! Must be freed with 'duckdb_destroy_result'.
-typedef struct {
-	// deprecated, use duckdb_column_count
-	idx_t deprecated_column_count;
-	// deprecated, use duckdb_row_count
-	idx_t deprecated_row_count;
-	// deprecated, use duckdb_rows_changed
-	idx_t deprecated_rows_changed;
-	// deprecated, use duckdb_column_*-family of functions
-	duckdb_column *deprecated_columns;
-	// deprecated, use duckdb_result_error
-	char *deprecated_error_message;
-	void *internal_data;
-} duckdb_result;
-
-//! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`.
-typedef struct _duckdb_instance_cache {
-	void *internal_ptr;
-} * duckdb_instance_cache;
-
-//! A database object. Must be closed with `duckdb_close`.
-typedef struct _duckdb_database {
-	void *internal_ptr;
-} * duckdb_database;
-
-//! A connection to a duckdb database. Must be closed with `duckdb_disconnect`.
-typedef struct _duckdb_connection {
-	void *internal_ptr;
-} * duckdb_connection;
-
-//! A prepared statement is a parameterized query that allows you to bind parameters to it.
-//! Must be destroyed with `duckdb_destroy_prepare`.
-typedef struct _duckdb_prepared_statement {
-	void *internal_ptr;
-} * duckdb_prepared_statement;
-
-//! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`.
-typedef struct _duckdb_extracted_statements {
-	void *internal_ptr;
-} * duckdb_extracted_statements;
-
-//! The pending result represents an intermediate structure for a query that is not yet fully executed.
-//! Must be destroyed with `duckdb_destroy_pending`.
-typedef struct _duckdb_pending_result {
-	void *internal_ptr;
-} * duckdb_pending_result;
-
-//! The appender enables fast data loading into DuckDB.
-//! Must be destroyed with `duckdb_appender_destroy`.
-typedef struct _duckdb_appender {
-	void *internal_ptr;
-} * duckdb_appender;
-
-//! The table description allows querying info about the table.
-//! Must be destroyed with `duckdb_table_description_destroy`.
-typedef struct _duckdb_table_description {
-	void *internal_ptr;
-} * duckdb_table_description;
-
-//! Can be used to provide start-up options for the DuckDB instance.
-//! Must be destroyed with `duckdb_destroy_config`.
-typedef struct _duckdb_config {
-	void *internal_ptr;
-} * duckdb_config;
-
-//! Holds an internal logical type.
-//! Must be destroyed with `duckdb_destroy_logical_type`.
-typedef struct _duckdb_logical_type {
-	void *internal_ptr;
-} * duckdb_logical_type;
-
-//! Holds extra information used when registering a custom logical type.
-//! Reserved for future use.
-typedef struct _duckdb_create_type_info {
-	void *internal_ptr;
-} * duckdb_create_type_info;
-
-//! Contains a data chunk from a duckdb_result.
-//! Must be destroyed with `duckdb_destroy_data_chunk`.
-typedef struct _duckdb_data_chunk {
-	void *internal_ptr;
-} * duckdb_data_chunk;
-
-//! Holds a DuckDB value, which wraps a type.
-//! Must be destroyed with `duckdb_destroy_value`.
-typedef struct _duckdb_value {
-	void *internal_ptr;
-} * duckdb_value;
-
-//! Holds a recursive tree that matches the query plan.
-typedef struct _duckdb_profiling_info {
-	void *internal_ptr;
-} * duckdb_profiling_info;
-
-//===--------------------------------------------------------------------===//
-// C API Extension info
-//===--------------------------------------------------------------------===//
-//! Holds state during the C API extension intialization process
-typedef struct _duckdb_extension_info {
-	void *internal_ptr;
-} * duckdb_extension_info;
-
-//===--------------------------------------------------------------------===//
-// Function types
-//===--------------------------------------------------------------------===//
-//! Additional function info. When setting this info, it is necessary to pass a destroy-callback function.
-typedef struct _duckdb_function_info {
-	void *internal_ptr;
-} * duckdb_function_info;
-
-//===--------------------------------------------------------------------===//
-// Scalar function types
-//===--------------------------------------------------------------------===//
-//! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`.
-typedef struct _duckdb_scalar_function {
-	void *internal_ptr;
-} * duckdb_scalar_function;
-
-//! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`.
-typedef struct _duckdb_scalar_function_set {
-	void *internal_ptr;
-} * duckdb_scalar_function_set;
-
-//! The main function of the scalar function.
-typedef void (*duckdb_scalar_function_t)(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output);
-
-//===--------------------------------------------------------------------===//
-// Aggregate function types
-//===--------------------------------------------------------------------===//
-//! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`.
-typedef struct _duckdb_aggregate_function {
-	void *internal_ptr;
-} * duckdb_aggregate_function;
-
-//! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`.
-typedef struct _duckdb_aggregate_function_set {
-	void *internal_ptr;
-} * duckdb_aggregate_function_set;
-
-//! Aggregate state
-typedef struct _duckdb_aggregate_state {
-	void *internal_ptr;
-} * duckdb_aggregate_state;
-
-//! Returns the aggregate state size
-typedef idx_t (*duckdb_aggregate_state_size)(duckdb_function_info info);
-//! Initialize the aggregate state
-typedef void (*duckdb_aggregate_init_t)(duckdb_function_info info, duckdb_aggregate_state state);
-//! Destroy aggregate state (optional)
-typedef void (*duckdb_aggregate_destroy_t)(duckdb_aggregate_state *states, idx_t count);
-//! Update a set of aggregate states with new values
-typedef void (*duckdb_aggregate_update_t)(duckdb_function_info info, duckdb_data_chunk input,
-                                          duckdb_aggregate_state *states);
-//! Combine aggregate states
-typedef void (*duckdb_aggregate_combine_t)(duckdb_function_info info, duckdb_aggregate_state *source,
-                                           duckdb_aggregate_state *target, idx_t count);
-//! Finalize aggregate states into a result vector
-typedef void (*duckdb_aggregate_finalize_t)(duckdb_function_info info, duckdb_aggregate_state *source,
-                                            duckdb_vector result, idx_t count, idx_t offset);
-
-//===--------------------------------------------------------------------===//
-// Table function types
-//===--------------------------------------------------------------------===//
-
-//! A table function. Must be destroyed with `duckdb_destroy_table_function`.
-typedef struct _duckdb_table_function {
-	void *internal_ptr;
-} * duckdb_table_function;
-
-//! The bind info of the function. When setting this info, it is necessary to pass a destroy-callback function.
-typedef struct _duckdb_bind_info {
-	void *internal_ptr;
-} * duckdb_bind_info;
-
-//! Additional function init info. When setting this info, it is necessary to pass a destroy-callback function.
-typedef struct _duckdb_init_info {
-	void *internal_ptr;
-} * duckdb_init_info;
-
-//! The bind function of the table function.
-typedef void (*duckdb_table_function_bind_t)(duckdb_bind_info info);
-
-//! The (possibly thread-local) init function of the table function.
-typedef void (*duckdb_table_function_init_t)(duckdb_init_info info);
-
-//! The main function of the table function.
-typedef void (*duckdb_table_function_t)(duckdb_function_info info, duckdb_data_chunk output);
-
-//===--------------------------------------------------------------------===//
-// Cast types
-//===--------------------------------------------------------------------===//
-
-//! A cast function. Must be destroyed with `duckdb_destroy_cast_function`.
-typedef struct _duckdb_cast_function {
-	void *internal_ptr;
-} * duckdb_cast_function;
-
-typedef bool (*duckdb_cast_function_t)(duckdb_function_info info, idx_t count, duckdb_vector input,
-                                       duckdb_vector output);
-
-//===--------------------------------------------------------------------===//
-// Replacement scan types
-//===--------------------------------------------------------------------===//
-
-//! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function.
-typedef struct _duckdb_replacement_scan_info {
-	void *internal_ptr;
-} * duckdb_replacement_scan_info;
-
-//! A replacement scan function that can be added to a database.
-typedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info, const char *table_name, void *data);
-
-//===--------------------------------------------------------------------===//
-// Arrow-related types
-//===--------------------------------------------------------------------===//
-
-//! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`.
-typedef struct _duckdb_arrow {
-	void *internal_ptr;
-} * duckdb_arrow;
-
-//! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`.
-typedef struct _duckdb_arrow_stream {
-	void *internal_ptr;
-} * duckdb_arrow_stream;
-
-//! Holds an arrow schema. Remember to release the respective ArrowSchema object.
-typedef struct _duckdb_arrow_schema {
-	void *internal_ptr;
-} * duckdb_arrow_schema;
-
-//! Holds an arrow array. Remember to release the respective ArrowArray object.
-typedef struct _duckdb_arrow_array {
-	void *internal_ptr;
-} * duckdb_arrow_array;
-
-//===--------------------------------------------------------------------===//
-// DuckDB extension access
-//===--------------------------------------------------------------------===//
-//! Passed to C API extension as parameter to the entrypoint
-struct duckdb_extension_access {
-	//! Indicate that an error has occurred
-	void (*set_error)(duckdb_extension_info info, const char *error);
-	//! Fetch the database from duckdb to register extensions to
-	duckdb_database *(*get_database)(duckdb_extension_info info);
-	//! Fetch the API
-	const void *(*get_api)(duckdb_extension_info info, const char *version);
-};
-
-#ifndef DUCKDB_API_EXCLUDE_FUNCTIONS
-
-//===--------------------------------------------------------------------===//
-// Functions
-//===--------------------------------------------------------------------===//
-
-//===--------------------------------------------------------------------===//
-// Open Connect
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a new database instance cache.
-The instance cache is necessary if a client/program (re)opens multiple databases to the same file within the same
-process. Must be destroyed with 'duckdb_destroy_instance_cache'.
-
-* @return The database instance cache.
-*/
-DUCKDB_API duckdb_instance_cache duckdb_create_instance_cache();
-
-/*!
-Creates a new database instance in the instance cache, or retrieves an existing database instance.
-Must be closed with 'duckdb_close'.
-
-* @param instance_cache The instance cache in which to create the database, or from which to take the database.
-* @param path Path to the database file on disk. Both `nullptr` and `:memory:` open or retrieve an in-memory database.
-* @param out_database The resulting cached database.
-* @param config (Optional) configuration used to create the database.
-* @param out_error If set and the function returns `DuckDBError`, this contains the error message.
-Note that the error message must be freed using `duckdb_free`.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path,
-                                                        duckdb_database *out_database, duckdb_config config,
-                                                        char **out_error);
-
-/*!
-Destroys an existing database instance cache and de-allocates its memory.
-
-* @param instance_cache The instance cache to destroy.
-*/
-DUCKDB_API void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache);
-
-/*!
-Creates a new database or opens an existing database file stored at the given path.
-If no path is given a new in-memory database is created instead.
-The database must be closed with 'duckdb_close'.
-
-* @param path Path to the database file on disk. Both `nullptr` and `:memory:` open an in-memory database.
-* @param out_database The result database object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_open(const char *path, duckdb_database *out_database);
-
-/*!
-Extended version of duckdb_open. Creates a new database or opens an existing database file stored at the given path.
-The database must be closed with 'duckdb_close'.
-
-* @param path Path to the database file on disk. Both `nullptr` and `:memory:` open an in-memory database.
-* @param out_database The result database object.
-* @param config (Optional) configuration used to start up the database.
-* @param out_error If set and the function returns `DuckDBError`, this contains the error message.
-Note that the error message must be freed using `duckdb_free`.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config,
-                                        char **out_error);
-
-/*!
-Closes the specified database and de-allocates all memory allocated for that database.
-This should be called after you are done with any database allocated through `duckdb_open` or `duckdb_open_ext`.
-Note that failing to call `duckdb_close` (in case of e.g. a program crash) will not cause data corruption.
-Still, it is recommended to always correctly close a database object after you are done with it.
-
-* @param database The database object to shut down.
-*/
-DUCKDB_API void duckdb_close(duckdb_database *database);
-
-/*!
-Opens a connection to a database. Connections are required to query the database, and store transactional state
-associated with the connection.
-The instantiated connection should be closed using 'duckdb_disconnect'.
-
-* @param database The database file to connect to.
-* @param out_connection The result connection object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
-
-/*!
-Interrupt running query
-
-* @param connection The connection to interrupt
-*/
-DUCKDB_API void duckdb_interrupt(duckdb_connection connection);
-
-/*!
-Get progress of the running query
-
-* @param connection The working connection
-* @return -1 if no progress or a percentage of the progress
-*/
-DUCKDB_API duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);
-
-/*!
-Closes the specified connection and de-allocates all memory allocated for that connection.
-
-* @param connection The connection to close.
-*/
-DUCKDB_API void duckdb_disconnect(duckdb_connection *connection);
-
-/*!
-Returns the version of the linked DuckDB, with a version postfix for dev versions
-
-Usually used for developing C extensions that must return this for a compatibility check.
-*/
-DUCKDB_API const char *duckdb_library_version();
-
-//===--------------------------------------------------------------------===//
-// Configuration
-//===--------------------------------------------------------------------===//
-
-/*!
-Initializes an empty configuration object that can be used to provide start-up options for the DuckDB instance
-through `duckdb_open_ext`.
-The duckdb_config must be destroyed using 'duckdb_destroy_config'
-
-This will always succeed unless there is a malloc failure.
-
-Note that `duckdb_destroy_config` should always be called on the resulting config, even if the function returns
-`DuckDBError`.
-
-* @param out_config The result configuration object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_create_config(duckdb_config *out_config);
-
-/*!
-This returns the total amount of configuration options available for usage with `duckdb_get_config_flag`.
-
-This should not be called in a loop as it internally loops over all the options.
-
-* @return The amount of config options available.
-*/
-DUCKDB_API size_t duckdb_config_count();
-
-/*!
-Obtains a human-readable name and description of a specific configuration option. This can be used to e.g.
-display configuration options. This will succeed unless `index` is out of range (i.e. `>= duckdb_config_count`).
-
-The result name or description MUST NOT be freed.
-
-* @param index The index of the configuration option (between 0 and `duckdb_config_count`)
-* @param out_name A name of the configuration flag.
-* @param out_description A description of the configuration flag.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description);
-
-/*!
-Sets the specified option for the specified configuration. The configuration option is indicated by name.
-To obtain a list of config options, see `duckdb_get_config_flag`.
-
-In the source code, configuration options are defined in `config.cpp`.
-
-This can fail if either the name is invalid, or if the value provided for the option is invalid.
-
-* @param config The configuration object to set the option on.
-* @param name The name of the configuration flag to set.
-* @param option The value to set the configuration flag to.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option);
-
-/*!
-Destroys the specified configuration object and de-allocates all memory allocated for the object.
-
-* @param config The configuration object to destroy.
-*/
-DUCKDB_API void duckdb_destroy_config(duckdb_config *config);
-
-//===--------------------------------------------------------------------===//
-// Query Execution
-//===--------------------------------------------------------------------===//
-
-/*!
-Executes a SQL query within a connection and stores the full (materialized) result in the out_result pointer.
-If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling
-`duckdb_result_error`.
-
-Note that after running `duckdb_query`, `duckdb_destroy_result` must be called on the result object even if the
-query fails, otherwise the error stored within the result will not be freed correctly.
-
-* @param connection The connection to perform the query in.
-* @param query The SQL query to run.
-* @param out_result The query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out_result);
-
-/*!
-Closes the result and de-allocates all memory allocated for that connection.
-
-* @param result The result to destroy.
-*/
-DUCKDB_API void duckdb_destroy_result(duckdb_result *result);
-
-/*!
-Returns the column name of the specified column. The result should not need to be freed; the column names will
-automatically be destroyed when the result is destroyed.
-
-Returns `NULL` if the column is out of range.
-
-* @param result The result object to fetch the column name from.
-* @param col The column index.
-* @return The column name of the specified column.
-*/
-DUCKDB_API const char *duckdb_column_name(duckdb_result *result, idx_t col);
-
-/*!
-Returns the column type of the specified column.
-
-Returns `DUCKDB_TYPE_INVALID` if the column is out of range.
-
-* @param result The result object to fetch the column type from.
-* @param col The column index.
-* @return The column type of the specified column.
-*/
-DUCKDB_API duckdb_type duckdb_column_type(duckdb_result *result, idx_t col);
-
-/*!
-Returns the statement type of the statement that was executed
-
-* @param result The result object to fetch the statement type from.
-* @return duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
-*/
-DUCKDB_API duckdb_statement_type duckdb_result_statement_type(duckdb_result result);
-
-/*!
-Returns the logical column type of the specified column.
-
-The return type of this call should be destroyed with `duckdb_destroy_logical_type`.
-
-Returns `NULL` if the column is out of range.
-
-* @param result The result object to fetch the column type from.
-* @param col The column index.
-* @return The logical column type of the specified column.
-*/
-DUCKDB_API duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col);
-
-/*!
-Returns the number of columns present in a the result object.
-
-* @param result The result object.
-* @return The number of columns present in the result object.
-*/
-DUCKDB_API idx_t duckdb_column_count(duckdb_result *result);
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Returns the number of rows present in the result object.
-
-* @param result The result object.
-* @return The number of rows present in the result object.
-*/
-DUCKDB_API idx_t duckdb_row_count(duckdb_result *result);
-
-#endif
-/*!
-Returns the number of rows changed by the query stored in the result. This is relevant only for INSERT/UPDATE/DELETE
-queries. For other queries the rows_changed will be 0.
-
-* @param result The result object.
-* @return The number of rows changed.
-*/
-DUCKDB_API idx_t duckdb_rows_changed(duckdb_result *result);
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.
-
-Returns the data of a specific column of a result in columnar format.
-
-The function returns a dense array which contains the result data. The exact type stored in the array depends on the
-corresponding duckdb_type (as provided by `duckdb_column_type`). For the exact type by which the data should be
-accessed, see the comments in [the types section](types) or the `DUCKDB_TYPE` enum.
-
-For example, for a column of type `DUCKDB_TYPE_INTEGER`, rows can be accessed in the following manner:
-```c
-int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
-printf("Data for row %d: %d\n", row, data[row]);
-```
-
-* @param result The result object to fetch the column data from.
-* @param col The column index.
-* @return The column data of the specified column.
-*/
-DUCKDB_API void *duckdb_column_data(duckdb_result *result, idx_t col);
-
-/*!
-**DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.
-
-Returns the nullmask of a specific column of a result in columnar format. The nullmask indicates for every row
-whether or not the corresponding row is `NULL`. If a row is `NULL`, the values present in the array provided
-by `duckdb_column_data` are undefined.
-
-```c
-int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
-bool *nullmask = duckdb_nullmask_data(&result, 0);
-if (nullmask[row]) {
-    printf("Data for row %d: NULL\n", row);
-} else {
-    printf("Data for row %d: %d\n", row, data[row]);
-}
-```
-
-* @param result The result object to fetch the nullmask from.
-* @param col The column index.
-* @return The nullmask of the specified column.
-*/
-DUCKDB_API bool *duckdb_nullmask_data(duckdb_result *result, idx_t col);
-
-#endif
-/*!
-Returns the error message contained within the result. The error is only set if `duckdb_query` returns `DuckDBError`.
-
-The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_result` is called.
-
-* @param result The result object to fetch the error from.
-* @return The error of the result.
-*/
-DUCKDB_API const char *duckdb_result_error(duckdb_result *result);
-
-/*!
-Returns the result error type contained within the result. The error is only set if `duckdb_query` returns
-`DuckDBError`.
-
-* @param result The result object to fetch the error from.
-* @return The error type of the result.
-*/
-DUCKDB_API duckdb_error_type duckdb_result_error_type(duckdb_result *result);
-
-//===--------------------------------------------------------------------===//
-// Result Functions
-//===--------------------------------------------------------------------===//
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Fetches a data chunk from the duckdb_result. This function should be called repeatedly until the result is exhausted.
-
-The result must be destroyed with `duckdb_destroy_data_chunk`.
-
-This function supersedes all `duckdb_value` functions, as well as the `duckdb_column_data` and `duckdb_nullmask_data`
-functions. It results in significantly better performance, and should be preferred in newer code-bases.
-
-If this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be
-mixed with the legacy result functions).
-
-Use `duckdb_result_chunk_count` to figure out how many chunks there are in the result.
-
-* @param result The result object to fetch the data chunk from.
-* @param chunk_index The chunk index to fetch from.
-* @return The resulting data chunk. Returns `NULL` if the chunk index is out of bounds.
-*/
-DUCKDB_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Checks if the type of the internal result is StreamQueryResult.
-
-* @param result The result object to check.
-* @return Whether or not the result object is of the type StreamQueryResult
-*/
-DUCKDB_API bool duckdb_result_is_streaming(duckdb_result result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Returns the number of data chunks present in the result.
-
-* @param result The result object
-* @return Number of data chunks present in the result.
-*/
-DUCKDB_API idx_t duckdb_result_chunk_count(duckdb_result result);
-
-#endif
-/*!
-Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on error
-
-* @param result The result object
-* @return The return_type
-*/
-DUCKDB_API duckdb_result_type duckdb_result_return_type(duckdb_result result);
-
-//===--------------------------------------------------------------------===//
-// Safe Fetch Functions
-//===--------------------------------------------------------------------===//
-
-// These functions will perform conversions if necessary.
-// On failure (e.g. if conversion cannot be performed or if the value is NULL) a default value is returned.
-// Note that these functions are slow since they perform bounds checking and conversion
-// For fast access of values prefer using `duckdb_result_get_chunk`
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The boolean value at the specified location, or false if the value cannot be converted.
-*/
-DUCKDB_API bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The int8_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The int16_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The int32_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The int64_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_hugeint value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_uhugeint value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_uhugeint duckdb_value_uhugeint(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The uint8_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The uint16_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The uint32_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The uint64_t value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The float value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The double value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_date value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_time value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_timestamp value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_interval value at the specified location, or 0 if the value cannot be converted.
-*/
-DUCKDB_API duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATED**: Use duckdb_value_string instead. This function does not work correctly if the string contains null
-bytes.
-
-* @return The text value at the specified location as a null-terminated string, or nullptr if the value cannot be
-converted. The result must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-No support for nested types, and for other complex types.
-The resulting field "string.data" must be freed with `duckdb_free.`
-
-* @return The string value at the specified location. Attempts to cast the result value to string.
-*/
-DUCKDB_API duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATED**: Use duckdb_value_string_internal instead. This function does not work correctly if the string contains
-null bytes.
-
-* @return The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
-If the column is NOT a VARCHAR column this function will return NULL.
-
-The result must NOT be freed.
-*/
-DUCKDB_API char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATED**: Use duckdb_value_string_internal instead. This function does not work correctly if the string contains
-null bytes.
-* @return The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
-If the column is NOT a VARCHAR column this function will return NULL.
-
-The result must NOT be freed.
-*/
-DUCKDB_API duckdb_string duckdb_value_string_internal(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return The duckdb_blob value at the specified location. Returns a blob with blob.data set to nullptr if the
-value cannot be converted. The resulting field "blob.data" must be freed with `duckdb_free.`
-*/
-DUCKDB_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-* @return Returns true if the value at the specified index is NULL, and false otherwise.
-*/
-DUCKDB_API bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row);
-
-#endif
-//===--------------------------------------------------------------------===//
-// Helpers
-//===--------------------------------------------------------------------===//
-
-/*!
-Allocate `size` bytes of memory using the duckdb internal malloc function. Any memory allocated in this manner
-should be freed using `duckdb_free`.
-
-* @param size The number of bytes to allocate.
-* @return A pointer to the allocated memory region.
-*/
-DUCKDB_API void *duckdb_malloc(size_t size);
-
-/*!
-Free a value returned from `duckdb_malloc`, `duckdb_value_varchar`, `duckdb_value_blob`, or
-`duckdb_value_string`.
-
-* @param ptr The memory region to de-allocate.
-*/
-DUCKDB_API void duckdb_free(void *ptr);
-
-/*!
-The internal vector size used by DuckDB.
-This is the amount of tuples that will fit into a data chunk created by `duckdb_create_data_chunk`.
-
-* @return The vector size.
-*/
-DUCKDB_API idx_t duckdb_vector_size();
-
-/*!
-Whether or not the duckdb_string_t value is inlined.
-This means that the data of the string does not have a separate allocation.
-
-*/
-DUCKDB_API bool duckdb_string_is_inlined(duckdb_string_t string);
-
-/*!
-Get the string length of a string_t
-
-* @param string The string to get the length of.
-* @return The length.
-*/
-DUCKDB_API uint32_t duckdb_string_t_length(duckdb_string_t string);
-
-/*!
-Get a pointer to the string data of a string_t
-
-* @param string The string to get the pointer to.
-* @return The pointer.
-*/
-DUCKDB_API const char *duckdb_string_t_data(duckdb_string_t *string);
-
-//===--------------------------------------------------------------------===//
-// Date Time Timestamp Helpers
-//===--------------------------------------------------------------------===//
-
-/*!
-Decompose a `duckdb_date` object into year, month and date (stored as `duckdb_date_struct`).
-
-* @param date The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
-* @return The `duckdb_date_struct` with the decomposed elements.
-*/
-DUCKDB_API duckdb_date_struct duckdb_from_date(duckdb_date date);
-
-/*!
-Re-compose a `duckdb_date` from year, month and date (`duckdb_date_struct`).
-
-* @param date The year, month and date stored in a `duckdb_date_struct`.
-* @return The `duckdb_date` element.
-*/
-DUCKDB_API duckdb_date duckdb_to_date(duckdb_date_struct date);
-
-/*!
-Test a `duckdb_date` to see if it is a finite value.
-
-* @param date The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
-* @return True if the date is finite, false if it is ±infinity.
-*/
-DUCKDB_API bool duckdb_is_finite_date(duckdb_date date);
-
-/*!
-Decompose a `duckdb_time` object into hour, minute, second and microsecond (stored as `duckdb_time_struct`).
-
-* @param time The time object, as obtained from a `DUCKDB_TYPE_TIME` column.
-* @return The `duckdb_time_struct` with the decomposed elements.
-*/
-DUCKDB_API duckdb_time_struct duckdb_from_time(duckdb_time time);
-
-/*!
-Create a `duckdb_time_tz` object from micros and a timezone offset.
-
-* @param micros The microsecond component of the time.
-* @param offset The timezone offset component of the time.
-* @return The `duckdb_time_tz` element.
-*/
-DUCKDB_API duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset);
-
-/*!
-Decompose a TIME_TZ objects into micros and a timezone offset.
-
-Use `duckdb_from_time` to further decompose the micros into hour, minute, second and microsecond.
-
-* @param micros The time object, as obtained from a `DUCKDB_TYPE_TIME_TZ` column.
-*/
-DUCKDB_API duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz micros);
-
-/*!
-Re-compose a `duckdb_time` from hour, minute, second and microsecond (`duckdb_time_struct`).
-
-* @param time The hour, minute, second and microsecond in a `duckdb_time_struct`.
-* @return The `duckdb_time` element.
-*/
-DUCKDB_API duckdb_time duckdb_to_time(duckdb_time_struct time);
-
-/*!
-Decompose a `duckdb_timestamp` object into a `duckdb_timestamp_struct`.
-
-* @param ts The ts object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
-* @return The `duckdb_timestamp_struct` with the decomposed elements.
-*/
-DUCKDB_API duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);
-
-/*!
-Re-compose a `duckdb_timestamp` from a duckdb_timestamp_struct.
-
-* @param ts The de-composed elements in a `duckdb_timestamp_struct`.
-* @return The `duckdb_timestamp` element.
-*/
-DUCKDB_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);
-
-/*!
-Test a `duckdb_timestamp` to see if it is a finite value.
-
-* @param ts The duckdb_timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
-* @return True if the timestamp is finite, false if it is ±infinity.
-*/
-DUCKDB_API bool duckdb_is_finite_timestamp(duckdb_timestamp ts);
-
-/*!
-Test a `duckdb_timestamp_s` to see if it is a finite value.
-
-* @param ts The duckdb_timestamp_s object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_S` column.
-* @return True if the timestamp is finite, false if it is ±infinity.
-*/
-DUCKDB_API bool duckdb_is_finite_timestamp_s(duckdb_timestamp_s ts);
-
-/*!
-Test a `duckdb_timestamp_ms` to see if it is a finite value.
-
-* @param ts The duckdb_timestamp_ms object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_MS` column.
-* @return True if the timestamp is finite, false if it is ±infinity.
-*/
-DUCKDB_API bool duckdb_is_finite_timestamp_ms(duckdb_timestamp_ms ts);
-
-/*!
-Test a `duckdb_timestamp_ns` to see if it is a finite value.
-
-* @param ts The duckdb_timestamp_ns object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_NS` column.
-* @return True if the timestamp is finite, false if it is ±infinity.
-*/
-DUCKDB_API bool duckdb_is_finite_timestamp_ns(duckdb_timestamp_ns ts);
-
-//===--------------------------------------------------------------------===//
-// Hugeint Helpers
-//===--------------------------------------------------------------------===//
-
-/*!
-Converts a duckdb_hugeint object (as obtained from a `DUCKDB_TYPE_HUGEINT` column) into a double.
-
-* @param val The hugeint value.
-* @return The converted `double` element.
-*/
-DUCKDB_API double duckdb_hugeint_to_double(duckdb_hugeint val);
-
-/*!
-Converts a double value to a duckdb_hugeint object.
-
-If the conversion fails because the double value is too big the result will be 0.
-
-* @param val The double value.
-* @return The converted `duckdb_hugeint` element.
-*/
-DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
-
-//===--------------------------------------------------------------------===//
-// Unsigned Hugeint Helpers
-//===--------------------------------------------------------------------===//
-
-/*!
-Converts a duckdb_uhugeint object (as obtained from a `DUCKDB_TYPE_UHUGEINT` column) into a double.
-
-* @param val The uhugeint value.
-* @return The converted `double` element.
-*/
-DUCKDB_API double duckdb_uhugeint_to_double(duckdb_uhugeint val);
-
-/*!
-Converts a double value to a duckdb_uhugeint object.
-
-If the conversion fails because the double value is too big the result will be 0.
-
-* @param val The double value.
-* @return The converted `duckdb_uhugeint` element.
-*/
-DUCKDB_API duckdb_uhugeint duckdb_double_to_uhugeint(double val);
-
-//===--------------------------------------------------------------------===//
-// Decimal Helpers
-//===--------------------------------------------------------------------===//
-
-/*!
-Converts a double value to a duckdb_decimal object.
-
-If the conversion fails because the double value is too big, or the width/scale are invalid the result will be 0.
-
-* @param val The double value.
-* @return The converted `duckdb_decimal` element.
-*/
-DUCKDB_API duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale);
-
-/*!
-Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
-
-* @param val The decimal value.
-* @return The converted `double` element.
-*/
-DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
-
-//===--------------------------------------------------------------------===//
-// Prepared Statements
-//===--------------------------------------------------------------------===//
-
-// A prepared statement is a parameterized query that allows you to bind parameters to it.
-// * This is useful to easily supply parameters to functions and avoid SQL injection attacks.
-// * This is useful to speed up queries that you will execute several times with different parameters.
-// Because the query will only be parsed, bound, optimized and planned once during the prepare stage,
-// rather than once per execution.
-// For example:
-//   SELECT * FROM tbl WHERE id=?
-// Or a query with multiple parameters:
-//   SELECT * FROM tbl WHERE id=$1 OR name=$2
-/*!
-Create a prepared statement object from a query.
-
-Note that after calling `duckdb_prepare`, the prepared statement should always be destroyed using
-`duckdb_destroy_prepare`, even if the prepare fails.
-
-If the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.
-
-* @param connection The connection object
-* @param query The SQL query to prepare
-* @param out_prepared_statement The resulting prepared statement object
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
-                                       duckdb_prepared_statement *out_prepared_statement);
-
-/*!
-Closes the prepared statement and de-allocates all memory allocated for the statement.
-
-* @param prepared_statement The prepared statement to destroy.
-*/
-DUCKDB_API void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement);
-
-/*!
-Returns the error message associated with the given prepared statement.
-If the prepared statement has no error message, this returns `nullptr` instead.
-
-The error message should not be freed. It will be de-allocated when `duckdb_destroy_prepare` is called.
-
-* @param prepared_statement The prepared statement to obtain the error from.
-* @return The error message, or `nullptr` if there is none.
-*/
-DUCKDB_API const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement);
-
-/*!
-Returns the number of parameters that can be provided to the given prepared statement.
-
-Returns 0 if the query was not successfully prepared.
-
-* @param prepared_statement The prepared statement to obtain the number of parameters for.
-*/
-DUCKDB_API idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);
-
-/*!
-Returns the name used to identify the parameter
-The returned string should be freed using `duckdb_free`.
-
-Returns NULL if the index is out of range for the provided prepared statement.
-
-* @param prepared_statement The prepared statement for which to get the parameter name from.
-*/
-DUCKDB_API const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index);
-
-/*!
-Returns the parameter type for the parameter at the given index.
-
-Returns `DUCKDB_TYPE_INVALID` if the parameter index is out of range or the statement was not successfully prepared.
-
-* @param prepared_statement The prepared statement.
-* @param param_idx The parameter index.
-* @return The parameter type
-*/
-DUCKDB_API duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-
-/*!
-Returns the logical type for the parameter at the given index.
-
-Returns `nullptr` if the parameter index is out of range or the statement was not successfully prepared.
-
-The return type of this call should be destroyed with `duckdb_destroy_logical_type`.
-
-* @param prepared_statement The prepared statement.
-* @param param_idx The parameter index.
-* @return The logical type of the parameter
-*/
-DUCKDB_API duckdb_logical_type duckdb_param_logical_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-
-/*!
-Clear the params bind to the prepared statement.
-*/
-DUCKDB_API duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);
-
-/*!
-Returns the statement type of the statement to be executed
-
-* @param statement The prepared statement.
-* @return duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
-*/
-DUCKDB_API duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement);
-
-//===--------------------------------------------------------------------===//
-// Bind Values To Prepared Statements
-//===--------------------------------------------------------------------===//
-
-/*!
-Binds a value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                          duckdb_value val);
-
-/*!
-Retrieve the index of the parameter for the prepared statement, identified by name
-*/
-DUCKDB_API duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
-                                                    const char *name);
-
-/*!
-Binds a bool value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val);
-
-/*!
-Binds an int8_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val);
-
-/*!
-Binds an int16_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val);
-
-/*!
-Binds an int32_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val);
-
-/*!
-Binds an int64_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val);
-
-/*!
-Binds a duckdb_hugeint value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                            duckdb_hugeint val);
-
-/*!
-Binds an duckdb_uhugeint value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uhugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                             duckdb_uhugeint val);
-
-/*!
-Binds a duckdb_decimal value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                            duckdb_decimal val);
-
-/*!
-Binds an uint8_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val);
-
-/*!
-Binds an uint16_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val);
-
-/*!
-Binds an uint32_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val);
-
-/*!
-Binds an uint64_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val);
-
-/*!
-Binds a float value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val);
-
-/*!
-Binds a double value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val);
-
-/*!
-Binds a duckdb_date value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                         duckdb_date val);
-
-/*!
-Binds a duckdb_time value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                         duckdb_time val);
-
-/*!
-Binds a duckdb_timestamp value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                              duckdb_timestamp val);
-
-/*!
-Binds a duckdb_timestamp value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_timestamp_tz(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                                 duckdb_timestamp val);
-
-/*!
-Binds a duckdb_interval value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                             duckdb_interval val);
-
-/*!
-Binds a null-terminated varchar value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                            const char *val);
-
-/*!
-Binds a varchar value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                                   const char *val, idx_t length);
-
-/*!
-Binds a blob value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                         const void *data, idx_t length);
-
-/*!
-Binds a NULL value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-
-//===--------------------------------------------------------------------===//
-// Execute Prepared Statements
-//===--------------------------------------------------------------------===//
-
-/*!
-Executes the prepared statement with the given bound parameters, and returns a materialized query result.
-
-This method can be called multiple times for each prepared statement, and the parameters can be modified
-between calls to this function.
-
-Note that the result must be freed with `duckdb_destroy_result`.
-
-* @param prepared_statement The prepared statement to execute.
-* @param out_result The query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement,
-                                                duckdb_result *out_result);
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Executes the prepared statement with the given bound parameters, and returns an optionally-streaming query result.
-To determine if the resulting query was in fact streamed, use `duckdb_result_is_streaming`
-
-This method can be called multiple times for each prepared statement, and the parameters can be modified
-between calls to this function.
-
-Note that the result must be freed with `duckdb_destroy_result`.
-
-* @param prepared_statement The prepared statement to execute.
-* @param out_result The query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,
-                                                          duckdb_result *out_result);
-
-#endif
-//===--------------------------------------------------------------------===//
-// Extract Statements
-//===--------------------------------------------------------------------===//
-
-// A query string can be extracted into multiple SQL statements. Each statement can be prepared and executed separately.
-/*!
-Extract all statements from a query.
-Note that after calling `duckdb_extract_statements`, the extracted statements should always be destroyed using
-`duckdb_destroy_extracted`, even if no statements were extracted.
-
-If the extract fails, `duckdb_extract_statements_error` can be called to obtain the reason why the extract failed.
-
-* @param connection The connection object
-* @param query The SQL query to extract
-* @param out_extracted_statements The resulting extracted statements object
-* @return The number of extracted statements or 0 on failure.
-*/
-DUCKDB_API idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
-                                           duckdb_extracted_statements *out_extracted_statements);
-
-/*!
-Prepare an extracted statement.
-Note that after calling `duckdb_prepare_extracted_statement`, the prepared statement should always be destroyed using
-`duckdb_destroy_prepare`, even if the prepare fails.
-
-If the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.
-
-* @param connection The connection object
-* @param extracted_statements The extracted statements object
-* @param index The index of the extracted statement to prepare
-* @param out_prepared_statement The resulting prepared statement object
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection,
-                                                           duckdb_extracted_statements extracted_statements,
-                                                           idx_t index,
-                                                           duckdb_prepared_statement *out_prepared_statement);
-
-/*!
-Returns the error message contained within the extracted statements.
-The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_extracted` is called.
-
-* @param extracted_statements The extracted statements to fetch the error from.
-* @return The error of the extracted statements.
-*/
-DUCKDB_API const char *duckdb_extract_statements_error(duckdb_extracted_statements extracted_statements);
-
-/*!
-De-allocates all memory allocated for the extracted statements.
-* @param extracted_statements The extracted statements to destroy.
-*/
-DUCKDB_API void duckdb_destroy_extracted(duckdb_extracted_statements *extracted_statements);
-
-//===--------------------------------------------------------------------===//
-// Pending Result Interface
-//===--------------------------------------------------------------------===//
-
-/*!
-Executes the prepared statement with the given bound parameters, and returns a pending result.
-The pending result represents an intermediate structure for a query that is not yet fully executed.
-The pending result can be used to incrementally execute a query, returning control to the client between tasks.
-
-Note that after calling `duckdb_pending_prepared`, the pending result should always be destroyed using
-`duckdb_destroy_pending`, even if this function returns DuckDBError.
-
-* @param prepared_statement The prepared statement to execute.
-* @param out_result The pending query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement,
-                                                duckdb_pending_result *out_result);
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Executes the prepared statement with the given bound parameters, and returns a pending result.
-This pending result will create a streaming duckdb_result when executed.
-The pending result represents an intermediate structure for a query that is not yet fully executed.
-
-Note that after calling `duckdb_pending_prepared_streaming`, the pending result should always be destroyed using
-`duckdb_destroy_pending`, even if this function returns DuckDBError.
-
-* @param prepared_statement The prepared statement to execute.
-* @param out_result The pending query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
-                                                          duckdb_pending_result *out_result);
-
-#endif
-/*!
-Closes the pending result and de-allocates all memory allocated for the result.
-
-* @param pending_result The pending result to destroy.
-*/
-DUCKDB_API void duckdb_destroy_pending(duckdb_pending_result *pending_result);
-
-/*!
-Returns the error message contained within the pending result.
-
-The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_pending` is called.
-
-* @param pending_result The pending result to fetch the error from.
-* @return The error of the pending result.
-*/
-DUCKDB_API const char *duckdb_pending_error(duckdb_pending_result pending_result);
-
-/*!
-Executes a single task within the query, returning whether or not the query is ready.
-
-If this returns DUCKDB_PENDING_RESULT_READY, the duckdb_execute_pending function can be called to obtain the result.
-If this returns DUCKDB_PENDING_RESULT_NOT_READY, the duckdb_pending_execute_task function should be called again.
-If this returns DUCKDB_PENDING_ERROR, an error occurred during execution.
-
-The error message can be obtained by calling duckdb_pending_error on the pending_result.
-
-* @param pending_result The pending result to execute a task within.
-* @return The state of the pending result after the execution.
-*/
-DUCKDB_API duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_result);
-
-/*!
-If this returns DUCKDB_PENDING_RESULT_READY, the duckdb_execute_pending function can be called to obtain the result.
-If this returns DUCKDB_PENDING_RESULT_NOT_READY, the duckdb_pending_execute_check_state function should be called again.
-If this returns DUCKDB_PENDING_ERROR, an error occurred during execution.
-
-The error message can be obtained by calling duckdb_pending_error on the pending_result.
-
-* @param pending_result The pending result.
-* @return The state of the pending result.
-*/
-DUCKDB_API duckdb_pending_state duckdb_pending_execute_check_state(duckdb_pending_result pending_result);
-
-/*!
-Fully execute a pending query result, returning the final query result.
-
-If duckdb_pending_execute_task has been called until DUCKDB_PENDING_RESULT_READY was returned, this will return fast.
-Otherwise, all remaining tasks must be executed first.
-
-Note that the result must be freed with `duckdb_destroy_result`.
-
-* @param pending_result The pending result to execute.
-* @param out_result The result object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result);
-
-/*!
-Returns whether a duckdb_pending_state is finished executing. For example if `pending_state` is
-DUCKDB_PENDING_RESULT_READY, this function will return true.
-
-* @param pending_state The pending state on which to decide whether to finish execution.
-* @return Boolean indicating pending execution should be considered finished.
-*/
-DUCKDB_API bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state);
-
-//===--------------------------------------------------------------------===//
-// Value Interface
-//===--------------------------------------------------------------------===//
-
-/*!
-Destroys the value and de-allocates all memory allocated for that type.
-
-* @param value The value to destroy.
-*/
-DUCKDB_API void duckdb_destroy_value(duckdb_value *value);
-
-/*!
-Creates a value from a null-terminated string
-
-* @param text The null-terminated string
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_varchar(const char *text);
-
-/*!
-Creates a value from a string
-
-* @param text The text
-* @param length The length of the text
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_varchar_length(const char *text, idx_t length);
-
-/*!
-Creates a value from a boolean
-
-* @param input The boolean value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_bool(bool input);
-
-/*!
-Creates a value from a int8_t (a tinyint)
-
-* @param input The tinyint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_int8(int8_t input);
-
-/*!
-Creates a value from a uint8_t (a utinyint)
-
-* @param input The utinyint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_uint8(uint8_t input);
-
-/*!
-Creates a value from a int16_t (a smallint)
-
-* @param input The smallint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_int16(int16_t input);
-
-/*!
-Creates a value from a uint16_t (a usmallint)
-
-* @param input The usmallint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_uint16(uint16_t input);
-
-/*!
-Creates a value from a int32_t (an integer)
-
-* @param input The integer value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_int32(int32_t input);
-
-/*!
-Creates a value from a uint32_t (a uinteger)
-
-* @param input The uinteger value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_uint32(uint32_t input);
-
-/*!
-Creates a value from a uint64_t (a ubigint)
-
-* @param input The ubigint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_uint64(uint64_t input);
-
-/*!
-Creates a value from an int64
-
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_int64(int64_t val);
-
-/*!
-Creates a value from a hugeint
-
-* @param input The hugeint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_hugeint(duckdb_hugeint input);
-
-/*!
-Creates a value from a uhugeint
-
-* @param input The uhugeint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_uhugeint(duckdb_uhugeint input);
-
-/*!
-Creates a VARINT value from a duckdb_varint
-
-* @param input The duckdb_varint value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_varint(duckdb_varint input);
-
-/*!
-Creates a DECIMAL value from a duckdb_decimal
-
-* @param input The duckdb_decimal value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_decimal(duckdb_decimal input);
-
-/*!
-Creates a value from a float
-
-* @param input The float value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_float(float input);
-
-/*!
-Creates a value from a double
-
-* @param input The double value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_double(double input);
-
-/*!
-Creates a value from a date
-
-* @param input The date value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_date(duckdb_date input);
-
-/*!
-Creates a value from a time
-
-* @param input The time value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_time(duckdb_time input);
-
-/*!
-Creates a value from a time_tz.
-Not to be confused with `duckdb_create_time_tz`, which creates a duckdb_time_tz_t.
-
-* @param value The time_tz value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value);
-
-/*!
-Creates a TIMESTAMP value from a duckdb_timestamp
-
-* @param input The duckdb_timestamp value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_timestamp(duckdb_timestamp input);
-
-/*!
-Creates a TIMESTAMP_TZ value from a duckdb_timestamp
-
-* @param input The duckdb_timestamp value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_timestamp_tz(duckdb_timestamp input);
-
-/*!
-Creates a TIMESTAMP_S value from a duckdb_timestamp_s
-
-* @param input The duckdb_timestamp_s value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_timestamp_s(duckdb_timestamp_s input);
-
-/*!
-Creates a TIMESTAMP_MS value from a duckdb_timestamp_ms
-
-* @param input The duckdb_timestamp_ms value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_timestamp_ms(duckdb_timestamp_ms input);
-
-/*!
-Creates a TIMESTAMP_NS value from a duckdb_timestamp_ns
-
-* @param input The duckdb_timestamp_ns value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_timestamp_ns(duckdb_timestamp_ns input);
-
-/*!
-Creates a value from an interval
-
-* @param input The interval value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_interval(duckdb_interval input);
-
-/*!
-Creates a value from a blob
-
-* @param data The blob data
-* @param length The length of the blob data
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length);
-
-/*!
-Creates a BIT value from a duckdb_bit
-
-* @param input The duckdb_bit value
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_bit(duckdb_bit input);
-
-/*!
-Creates a UUID value from a uhugeint
-
-* @param input The duckdb_uhugeint containing the UUID
-* @return The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_uuid(duckdb_uhugeint input);
-
-/*!
-Returns the boolean value of the given value.
-
-* @param val A duckdb_value containing a boolean
-* @return A boolean, or false if the value cannot be converted
-*/
-DUCKDB_API bool duckdb_get_bool(duckdb_value val);
-
-/*!
-Returns the int8_t value of the given value.
-
-* @param val A duckdb_value containing a tinyint
-* @return A int8_t, or MinValue<int8> if the value cannot be converted
-*/
-DUCKDB_API int8_t duckdb_get_int8(duckdb_value val);
-
-/*!
-Returns the uint8_t value of the given value.
-
-* @param val A duckdb_value containing a utinyint
-* @return A uint8_t, or MinValue<uint8> if the value cannot be converted
-*/
-DUCKDB_API uint8_t duckdb_get_uint8(duckdb_value val);
-
-/*!
-Returns the int16_t value of the given value.
-
-* @param val A duckdb_value containing a smallint
-* @return A int16_t, or MinValue<int16> if the value cannot be converted
-*/
-DUCKDB_API int16_t duckdb_get_int16(duckdb_value val);
-
-/*!
-Returns the uint16_t value of the given value.
-
-* @param val A duckdb_value containing a usmallint
-* @return A uint16_t, or MinValue<uint16> if the value cannot be converted
-*/
-DUCKDB_API uint16_t duckdb_get_uint16(duckdb_value val);
-
-/*!
-Returns the int32_t value of the given value.
-
-* @param val A duckdb_value containing a integer
-* @return A int32_t, or MinValue<int32> if the value cannot be converted
-*/
-DUCKDB_API int32_t duckdb_get_int32(duckdb_value val);
-
-/*!
-Returns the uint32_t value of the given value.
-
-* @param val A duckdb_value containing a uinteger
-* @return A uint32_t, or MinValue<uint32> if the value cannot be converted
-*/
-DUCKDB_API uint32_t duckdb_get_uint32(duckdb_value val);
-
-/*!
-Returns the int64_t value of the given value.
-
-* @param val A duckdb_value containing a bigint
-* @return A int64_t, or MinValue<int64> if the value cannot be converted
-*/
-DUCKDB_API int64_t duckdb_get_int64(duckdb_value val);
-
-/*!
-Returns the uint64_t value of the given value.
-
-* @param val A duckdb_value containing a ubigint
-* @return A uint64_t, or MinValue<uint64> if the value cannot be converted
-*/
-DUCKDB_API uint64_t duckdb_get_uint64(duckdb_value val);
-
-/*!
-Returns the hugeint value of the given value.
-
-* @param val A duckdb_value containing a hugeint
-* @return A duckdb_hugeint, or MinValue<hugeint> if the value cannot be converted
-*/
-DUCKDB_API duckdb_hugeint duckdb_get_hugeint(duckdb_value val);
-
-/*!
-Returns the uhugeint value of the given value.
-
-* @param val A duckdb_value containing a uhugeint
-* @return A duckdb_uhugeint, or MinValue<uhugeint> if the value cannot be converted
-*/
-DUCKDB_API duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val);
-
-/*!
-Returns the duckdb_varint value of the given value.
-The `data` field must be destroyed with `duckdb_free`.
-
-* @param val A duckdb_value containing a VARINT
-* @return A duckdb_varint. The `data` field must be destroyed with `duckdb_free`.
-*/
-DUCKDB_API duckdb_varint duckdb_get_varint(duckdb_value val);
-
-/*!
-Returns the duckdb_decimal value of the given value.
-
-* @param val A duckdb_value containing a DECIMAL
-* @return A duckdb_decimal, or MinValue<decimal> if the value cannot be converted
-*/
-DUCKDB_API duckdb_decimal duckdb_get_decimal(duckdb_value val);
-
-/*!
-Returns the float value of the given value.
-
-* @param val A duckdb_value containing a float
-* @return A float, or NAN if the value cannot be converted
-*/
-DUCKDB_API float duckdb_get_float(duckdb_value val);
-
-/*!
-Returns the double value of the given value.
-
-* @param val A duckdb_value containing a double
-* @return A double, or NAN if the value cannot be converted
-*/
-DUCKDB_API double duckdb_get_double(duckdb_value val);
-
-/*!
-Returns the date value of the given value.
-
-* @param val A duckdb_value containing a date
-* @return A duckdb_date, or MinValue<date> if the value cannot be converted
-*/
-DUCKDB_API duckdb_date duckdb_get_date(duckdb_value val);
-
-/*!
-Returns the time value of the given value.
-
-* @param val A duckdb_value containing a time
-* @return A duckdb_time, or MinValue<time> if the value cannot be converted
-*/
-DUCKDB_API duckdb_time duckdb_get_time(duckdb_value val);
-
-/*!
-Returns the time_tz value of the given value.
-
-* @param val A duckdb_value containing a time_tz
-* @return A duckdb_time_tz, or MinValue<time_tz> if the value cannot be converted
-*/
-DUCKDB_API duckdb_time_tz duckdb_get_time_tz(duckdb_value val);
-
-/*!
-Returns the TIMESTAMP value of the given value.
-
-* @param val A duckdb_value containing a TIMESTAMP
-* @return A duckdb_timestamp, or MinValue<timestamp> if the value cannot be converted
-*/
-DUCKDB_API duckdb_timestamp duckdb_get_timestamp(duckdb_value val);
-
-/*!
-Returns the TIMESTAMP_TZ value of the given value.
-
-* @param val A duckdb_value containing a TIMESTAMP_TZ
-* @return A duckdb_timestamp, or MinValue<timestamp_tz> if the value cannot be converted
-*/
-DUCKDB_API duckdb_timestamp duckdb_get_timestamp_tz(duckdb_value val);
-
-/*!
-Returns the duckdb_timestamp_s value of the given value.
-
-* @param val A duckdb_value containing a TIMESTAMP_S
-* @return A duckdb_timestamp_s, or MinValue<timestamp_s> if the value cannot be converted
-*/
-DUCKDB_API duckdb_timestamp_s duckdb_get_timestamp_s(duckdb_value val);
-
-/*!
-Returns the duckdb_timestamp_ms value of the given value.
-
-* @param val A duckdb_value containing a TIMESTAMP_MS
-* @return A duckdb_timestamp_ms, or MinValue<timestamp_ms> if the value cannot be converted
-*/
-DUCKDB_API duckdb_timestamp_ms duckdb_get_timestamp_ms(duckdb_value val);
-
-/*!
-Returns the duckdb_timestamp_ns value of the given value.
-
-* @param val A duckdb_value containing a TIMESTAMP_NS
-* @return A duckdb_timestamp_ns, or MinValue<timestamp_ns> if the value cannot be converted
-*/
-DUCKDB_API duckdb_timestamp_ns duckdb_get_timestamp_ns(duckdb_value val);
-
-/*!
-Returns the interval value of the given value.
-
-* @param val A duckdb_value containing a interval
-* @return A duckdb_interval, or MinValue<interval> if the value cannot be converted
-*/
-DUCKDB_API duckdb_interval duckdb_get_interval(duckdb_value val);
-
-/*!
-Returns the type of the given value. The type is valid as long as the value is not destroyed.
-The type itself must not be destroyed.
-
-* @param val A duckdb_value
-* @return A duckdb_logical_type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_get_value_type(duckdb_value val);
-
-/*!
-Returns the blob value of the given value.
-
-* @param val A duckdb_value containing a blob
-* @return A duckdb_blob
-*/
-DUCKDB_API duckdb_blob duckdb_get_blob(duckdb_value val);
-
-/*!
-Returns the duckdb_bit value of the given value.
-The `data` field must be destroyed with `duckdb_free`.
-
-* @param val A duckdb_value containing a BIT
-* @return A duckdb_bit
-*/
-DUCKDB_API duckdb_bit duckdb_get_bit(duckdb_value val);
-
-/*!
-Returns a duckdb_uhugeint representing the UUID value of the given value.
-
-* @param val A duckdb_value containing a UUID
-* @return A duckdb_uhugeint representing the UUID value
-*/
-DUCKDB_API duckdb_uhugeint duckdb_get_uuid(duckdb_value val);
-
-/*!
-Obtains a string representation of the given value.
-The result must be destroyed with `duckdb_free`.
-
-* @param value The value
-* @return The string value. This must be destroyed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_get_varchar(duckdb_value value);
-
-/*!
-Creates a struct value from a type and an array of values. Must be destroyed with `duckdb_destroy_value`.
-
-* @param type The type of the struct
-* @param values The values for the struct fields
-* @return The struct value, or nullptr, if any child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`.
-*/
-DUCKDB_API duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values);
-
-/*!
-Creates a list value from a child (element) type and an array of values of length `value_count`.
-Must be destroyed with `duckdb_destroy_value`.
-
-* @param type The type of the list
-* @param values The values for the list
-* @param value_count The number of values in the list
-* @return The list value, or nullptr, if the child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`.
-*/
-DUCKDB_API duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
-
-/*!
-Creates an array value from a child (element) type and an array of values of length `value_count`.
-Must be destroyed with `duckdb_destroy_value`.
-
-* @param type The type of the array
-* @param values The values for the array
-* @param value_count The number of values in the array
-* @return The array value, or nullptr, if the child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`.
-*/
-DUCKDB_API duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
-
-/*!
-Returns the number of elements in a MAP value.
-
-* @param value The MAP value.
-* @return The number of elements in the map.
-*/
-DUCKDB_API idx_t duckdb_get_map_size(duckdb_value value);
-
-/*!
-Returns the MAP key at index as a duckdb_value.
-
-* @param value The MAP value.
-* @param index The index of the key.
-* @return The key as a duckdb_value.
-*/
-DUCKDB_API duckdb_value duckdb_get_map_key(duckdb_value value, idx_t index);
-
-/*!
-Returns the MAP value at index as a duckdb_value.
-
-* @param value The MAP value.
-* @param index The index of the value.
-* @return The value as a duckdb_value.
-*/
-DUCKDB_API duckdb_value duckdb_get_map_value(duckdb_value value, idx_t index);
-
-/*!
-Returns whether the value's type is SQLNULL or not.
-
-* @param value The value to check.
-* @return True, if the value's type is SQLNULL, otherwise false.
-*/
-DUCKDB_API bool duckdb_is_null_value(duckdb_value value);
-
-/*!
-Creates a value of type SQLNULL.
-
-* @return The duckdb_value representing SQLNULL. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_null_value();
-
-/*!
-Returns the number of elements in a LIST value.
-
-* @param value The LIST value.
-* @return The number of elements in the list.
-*/
-DUCKDB_API idx_t duckdb_get_list_size(duckdb_value value);
-
-/*!
-Returns the LIST child at index as a duckdb_value.
-
-* @param value The LIST value.
-* @param index The index of the child.
-* @return The child as a duckdb_value.
-*/
-DUCKDB_API duckdb_value duckdb_get_list_child(duckdb_value value, idx_t index);
-
-/*!
-Creates an enum value from a type and a value. Must be destroyed with `duckdb_destroy_value`.
-
-* @param type The type of the enum
-* @param value The value for the enum
-* @return The enum value, or nullptr.
-*/
-DUCKDB_API duckdb_value duckdb_create_enum_value(duckdb_logical_type type, uint64_t value);
-
-/*!
-Returns the enum value of the given value.
-
-* @param value A duckdb_value containing an enum
-* @return A uint64_t, or MinValue<uint64> if the value cannot be converted
-*/
-DUCKDB_API uint64_t duckdb_get_enum_value(duckdb_value value);
-
-/*!
-Returns the STRUCT child at index as a duckdb_value.
-
-* @param value The STRUCT value.
-* @param index The index of the child.
-* @return The child as a duckdb_value.
-*/
-DUCKDB_API duckdb_value duckdb_get_struct_child(duckdb_value value, idx_t index);
-
-//===--------------------------------------------------------------------===//
-// Logical Type Interface
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a `duckdb_logical_type` from a primitive type.
-The resulting logical type must be destroyed with `duckdb_destroy_logical_type`.
-
-Returns an invalid logical type, if type is: `DUCKDB_TYPE_INVALID`, `DUCKDB_TYPE_DECIMAL`, `DUCKDB_TYPE_ENUM`,
-`DUCKDB_TYPE_LIST`, `DUCKDB_TYPE_STRUCT`, `DUCKDB_TYPE_MAP`, `DUCKDB_TYPE_ARRAY`, or `DUCKDB_TYPE_UNION`.
-
-* @param type The primitive type to create.
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
-
-/*!
-Returns the alias of a duckdb_logical_type, if set, else `nullptr`.
-The result must be destroyed with `duckdb_free`.
-
-* @param type The logical type
-* @return The alias or `nullptr`
-*/
-DUCKDB_API char *duckdb_logical_type_get_alias(duckdb_logical_type type);
-
-/*!
-Sets the alias of a duckdb_logical_type.
-
-* @param type The logical type
-* @param alias The alias to set
-*/
-DUCKDB_API void duckdb_logical_type_set_alias(duckdb_logical_type type, const char *alias);
-
-/*!
-Creates a LIST type from its child type.
-The return type must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param type The child type of the list
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type);
-
-/*!
-Creates an ARRAY type from its child type.
-The return type must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param type The child type of the array.
-* @param array_size The number of elements in the array.
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size);
-
-/*!
-Creates a MAP type from its key type and value type.
-The return type must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param key_type The map's key type.
-* @param value_type The map's value type.
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type);
-
-/*!
-Creates a UNION type from the passed arrays.
-The return type must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param member_types The array of union member types.
-* @param member_names The union member names.
-* @param member_count The number of union members.
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types, const char **member_names,
-                                                        idx_t member_count);
-
-/*!
-Creates a STRUCT type based on the member types and names.
-The resulting type must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param member_types The array of types of the struct members.
-* @param member_names The array of names of the struct members.
-* @param member_count The number of members of the struct.
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types, const char **member_names,
-                                                         idx_t member_count);
-
-/*!
-Creates an ENUM type from the passed member name array.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
-
-* @param member_names The array of names that the enum should consist of.
-* @param member_count The number of elements that were specified in the array.
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count);
-
-/*!
-Creates a DECIMAL type with the specified width and scale.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
-
-* @param width The width of the decimal type
-* @param scale The scale of the decimal type
-* @return The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
-
-/*!
-Retrieves the enum `duckdb_type` of a `duckdb_logical_type`.
-
-* @param type The logical type.
-* @return The `duckdb_type` id.
-*/
-DUCKDB_API duckdb_type duckdb_get_type_id(duckdb_logical_type type);
-
-/*!
-Retrieves the width of a decimal type.
-
-* @param type The logical type object
-* @return The width of the decimal type
-*/
-DUCKDB_API uint8_t duckdb_decimal_width(duckdb_logical_type type);
-
-/*!
-Retrieves the scale of a decimal type.
-
-* @param type The logical type object
-* @return The scale of the decimal type
-*/
-DUCKDB_API uint8_t duckdb_decimal_scale(duckdb_logical_type type);
-
-/*!
-Retrieves the internal storage type of a decimal type.
-
-* @param type The logical type object
-* @return The internal type of the decimal type
-*/
-DUCKDB_API duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type);
-
-/*!
-Retrieves the internal storage type of an enum type.
-
-* @param type The logical type object
-* @return The internal type of the enum type
-*/
-DUCKDB_API duckdb_type duckdb_enum_internal_type(duckdb_logical_type type);
-
-/*!
-Retrieves the dictionary size of the enum type.
-
-* @param type The logical type object
-* @return The dictionary size of the enum type
-*/
-DUCKDB_API uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type);
-
-/*!
-Retrieves the dictionary value at the specified position from the enum.
-
-The result must be freed with `duckdb_free`.
-
-* @param type The logical type object
-* @param index The index in the dictionary
-* @return The string value of the enum type. Must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index);
-
-/*!
-Retrieves the child type of the given LIST type. Also accepts MAP types.
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* @param type The logical type, either LIST or MAP.
-* @return The child type of the LIST or MAP type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
-
-/*!
-Retrieves the child type of the given ARRAY type.
-
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* @param type The logical type. Must be ARRAY.
-* @return The child type of the ARRAY type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type);
-
-/*!
-Retrieves the array size of the given array type.
-
-* @param type The logical type object
-* @return The fixed number of elements the values of this array type can store.
-*/
-DUCKDB_API idx_t duckdb_array_type_array_size(duckdb_logical_type type);
-
-/*!
-Retrieves the key type of the given map type.
-
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* @param type The logical type object
-* @return The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type);
-
-/*!
-Retrieves the value type of the given map type.
-
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* @param type The logical type object
-* @return The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type);
-
-/*!
-Returns the number of children of a struct type.
-
-* @param type The logical type object
-* @return The number of children of a struct type.
-*/
-DUCKDB_API idx_t duckdb_struct_type_child_count(duckdb_logical_type type);
-
-/*!
-Retrieves the name of the struct child.
-
-The result must be freed with `duckdb_free`.
-
-* @param type The logical type object
-* @param index The child index
-* @return The name of the struct type. Must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index);
-
-/*!
-Retrieves the child type of the given struct type at the specified index.
-
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* @param type The logical type object
-* @param index The child index
-* @return The child type of the struct type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index);
-
-/*!
-Returns the number of members that the union type has.
-
-* @param type The logical type (union) object
-* @return The number of members of a union type.
-*/
-DUCKDB_API idx_t duckdb_union_type_member_count(duckdb_logical_type type);
-
-/*!
-Retrieves the name of the union member.
-
-The result must be freed with `duckdb_free`.
-
-* @param type The logical type object
-* @param index The child index
-* @return The name of the union member. Must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_union_type_member_name(duckdb_logical_type type, idx_t index);
-
-/*!
-Retrieves the child type of the given union member at the specified index.
-
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* @param type The logical type object
-* @param index The child index
-* @return The child type of the union member. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_union_type_member_type(duckdb_logical_type type, idx_t index);
-
-/*!
-Destroys the logical type and de-allocates all memory allocated for that type.
-
-* @param type The logical type to destroy.
-*/
-DUCKDB_API void duckdb_destroy_logical_type(duckdb_logical_type *type);
-
-/*!
-Registers a custom type within the given connection.
-The type must have an alias
-
-* @param con The connection to use
-* @param type The custom type to register
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_logical_type(duckdb_connection con, duckdb_logical_type type,
-                                                     duckdb_create_type_info info);
-
-//===--------------------------------------------------------------------===//
-// Data Chunk Interface
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates an empty data chunk with the specified column types.
-The result must be destroyed with `duckdb_destroy_data_chunk`.
-
-* @param types An array of column types. Column types can not contain ANY and INVALID types.
-* @param column_count The number of columns.
-* @return The data chunk.
-*/
-DUCKDB_API duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *types, idx_t column_count);
-
-/*!
-Destroys the data chunk and de-allocates all memory allocated for that chunk.
-
-* @param chunk The data chunk to destroy.
-*/
-DUCKDB_API void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk);
-
-/*!
-Resets a data chunk, clearing the validity masks and setting the cardinality of the data chunk to 0.
-After calling this method, you must call `duckdb_vector_get_validity` and `duckdb_vector_get_data` to obtain current
-data and validity pointers
-
-* @param chunk The data chunk to reset.
-*/
-DUCKDB_API void duckdb_data_chunk_reset(duckdb_data_chunk chunk);
-
-/*!
-Retrieves the number of columns in a data chunk.
-
-* @param chunk The data chunk to get the data from
-* @return The number of columns in the data chunk
-*/
-DUCKDB_API idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk);
-
-/*!
-Retrieves the vector at the specified column index in the data chunk.
-
-The pointer to the vector is valid for as long as the chunk is alive.
-It does NOT need to be destroyed.
-
-* @param chunk The data chunk to get the data from
-* @return The vector
-*/
-DUCKDB_API duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx);
-
-/*!
-Retrieves the current number of tuples in a data chunk.
-
-* @param chunk The data chunk to get the data from
-* @return The number of tuples in the data chunk
-*/
-DUCKDB_API idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk);
-
-/*!
-Sets the current number of tuples in a data chunk.
-
-* @param chunk The data chunk to set the size in
-* @param size The number of tuples in the data chunk
-*/
-DUCKDB_API void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size);
-
-//===--------------------------------------------------------------------===//
-// Vector Interface
-//===--------------------------------------------------------------------===//
-
-/*!
-Retrieves the column type of the specified vector.
-
-The result must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param vector The vector get the data from
-* @return The type of the vector
-*/
-DUCKDB_API duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector);
-
-/*!
-Retrieves the data pointer of the vector.
-
-The data pointer can be used to read or write values from the vector.
-How to read or write values depends on the type of the vector.
-
-* @param vector The vector to get the data from
-* @return The data pointer
-*/
-DUCKDB_API void *duckdb_vector_get_data(duckdb_vector vector);
-
-/*!
-Retrieves the validity mask pointer of the specified vector.
-
-If all values are valid, this function MIGHT return NULL!
-
-The validity mask is a bitset that signifies null-ness within the data chunk.
-It is a series of uint64_t values, where each uint64_t value contains validity for 64 tuples.
-The bit is set to 1 if the value is valid (i.e. not NULL) or 0 if the value is invalid (i.e. NULL).
-
-Validity of a specific value can be obtained like this:
-
-idx_t entry_idx = row_idx / 64;
-idx_t idx_in_entry = row_idx % 64;
-bool is_valid = validity_mask[entry_idx] & (1 << idx_in_entry);
-
-Alternatively, the (slower) duckdb_validity_row_is_valid function can be used.
-
-* @param vector The vector to get the data from
-* @return The pointer to the validity mask, or NULL if no validity mask is present
-*/
-DUCKDB_API uint64_t *duckdb_vector_get_validity(duckdb_vector vector);
-
-/*!
-Ensures the validity mask is writable by allocating it.
-
-After this function is called, `duckdb_vector_get_validity` will ALWAYS return non-NULL.
-This allows NULL values to be written to the vector, regardless of whether a validity mask was present before.
-
-* @param vector The vector to alter
-*/
-DUCKDB_API void duckdb_vector_ensure_validity_writable(duckdb_vector vector);
-
-/*!
-Assigns a string element in the vector at the specified location.
-
-* @param vector The vector to alter
-* @param index The row position in the vector to assign the string to
-* @param str The null-terminated string
-*/
-DUCKDB_API void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str);
-
-/*!
-Assigns a string element in the vector at the specified location. You may also use this function to assign BLOBs.
-
-* @param vector The vector to alter
-* @param index The row position in the vector to assign the string to
-* @param str The string
-* @param str_len The length of the string (in bytes)
-*/
-DUCKDB_API void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str,
-                                                        idx_t str_len);
-
-/*!
-Retrieves the child vector of a list vector.
-
-The resulting vector is valid as long as the parent vector is valid.
-
-* @param vector The vector
-* @return The child vector
-*/
-DUCKDB_API duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector);
-
-/*!
-Returns the size of the child vector of the list.
-
-* @param vector The vector
-* @return The size of the child list
-*/
-DUCKDB_API idx_t duckdb_list_vector_get_size(duckdb_vector vector);
-
-/*!
-Sets the total size of the underlying child-vector of a list vector.
-
-* @param vector The list vector.
-* @param size The size of the child list.
-* @return The duckdb state. Returns DuckDBError if the vector is nullptr.
-*/
-DUCKDB_API duckdb_state duckdb_list_vector_set_size(duckdb_vector vector, idx_t size);
-
-/*!
-Sets the total capacity of the underlying child-vector of a list.
-
-After calling this method, you must call `duckdb_vector_get_validity` and `duckdb_vector_get_data` to obtain current
-data and validity pointers
-
-* @param vector The list vector.
-* @param required_capacity the total capacity to reserve.
-* @return The duckdb state. Returns DuckDBError if the vector is nullptr.
-*/
-DUCKDB_API duckdb_state duckdb_list_vector_reserve(duckdb_vector vector, idx_t required_capacity);
-
-/*!
-Retrieves the child vector of a struct vector.
-
-The resulting vector is valid as long as the parent vector is valid.
-
-* @param vector The vector
-* @param index The child index
-* @return The child vector
-*/
-DUCKDB_API duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index);
-
-/*!
-Retrieves the child vector of a array vector.
-
-The resulting vector is valid as long as the parent vector is valid.
-The resulting vector has the size of the parent vector multiplied by the array size.
-
-* @param vector The vector
-* @return The child vector
-*/
-DUCKDB_API duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector);
-
-//===--------------------------------------------------------------------===//
-// Validity Mask Functions
-//===--------------------------------------------------------------------===//
-
-/*!
-Returns whether or not a row is valid (i.e. not NULL) in the given validity mask.
-
-* @param validity The validity mask, as obtained through `duckdb_vector_get_validity`
-* @param row The row index
-* @return true if the row is valid, false otherwise
-*/
-DUCKDB_API bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row);
-
-/*!
-In a validity mask, sets a specific row to either valid or invalid.
-
-Note that `duckdb_vector_ensure_validity_writable` should be called before calling `duckdb_vector_get_validity`,
-to ensure that there is a validity mask to write to.
-
-* @param validity The validity mask, as obtained through `duckdb_vector_get_validity`.
-* @param row The row index
-* @param valid Whether or not to set the row to valid, or invalid
-*/
-DUCKDB_API void duckdb_validity_set_row_validity(uint64_t *validity, idx_t row, bool valid);
-
-/*!
-In a validity mask, sets a specific row to invalid.
-
-Equivalent to `duckdb_validity_set_row_validity` with valid set to false.
-
-* @param validity The validity mask
-* @param row The row index
-*/
-DUCKDB_API void duckdb_validity_set_row_invalid(uint64_t *validity, idx_t row);
-
-/*!
-In a validity mask, sets a specific row to valid.
-
-Equivalent to `duckdb_validity_set_row_validity` with valid set to true.
-
-* @param validity The validity mask
-* @param row The row index
-*/
-DUCKDB_API void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row);
-
-//===--------------------------------------------------------------------===//
-// Scalar Functions
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a new empty scalar function.
-
-The return value should be destroyed with `duckdb_destroy_scalar_function`.
-
-* @return The scalar function object.
-*/
-DUCKDB_API duckdb_scalar_function duckdb_create_scalar_function();
-
-/*!
-Destroys the given scalar function object.
-
-* @param scalar_function The scalar function to destroy
-*/
-DUCKDB_API void duckdb_destroy_scalar_function(duckdb_scalar_function *scalar_function);
-
-/*!
-Sets the name of the given scalar function.
-
-* @param scalar_function The scalar function
-* @param name The name of the scalar function
-*/
-DUCKDB_API void duckdb_scalar_function_set_name(duckdb_scalar_function scalar_function, const char *name);
-
-/*!
-Sets the parameters of the given scalar function to varargs. Does not require adding parameters with
-duckdb_scalar_function_add_parameter.
-
-* @param scalar_function The scalar function.
-* @param type The type of the arguments.
-* @return The parameter type. Cannot contain INVALID.
-*/
-DUCKDB_API void duckdb_scalar_function_set_varargs(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-
-/*!
-Sets the parameters of the given scalar function to varargs. Does not require adding parameters with
-duckdb_scalar_function_add_parameter.
-
-* @param scalar_function The scalar function.
-*/
-DUCKDB_API void duckdb_scalar_function_set_special_handling(duckdb_scalar_function scalar_function);
-
-/*!
-Sets the Function Stability of the scalar function to VOLATILE, indicating the function should be re-run for every row.
-This limits optimization that can be performed for the function.
-
-* @param scalar_function The scalar function.
-*/
-DUCKDB_API void duckdb_scalar_function_set_volatile(duckdb_scalar_function scalar_function);
-
-/*!
-Adds a parameter to the scalar function.
-
-* @param scalar_function The scalar function.
-* @param type The parameter type. Cannot contain INVALID.
-*/
-DUCKDB_API void duckdb_scalar_function_add_parameter(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-
-/*!
-Sets the return type of the scalar function.
-
-* @param scalar_function The scalar function
-* @param type Cannot contain INVALID or ANY.
-*/
-DUCKDB_API void duckdb_scalar_function_set_return_type(duckdb_scalar_function scalar_function,
-                                                       duckdb_logical_type type);
-
-/*!
-Assigns extra information to the scalar function that can be fetched during binding, etc.
-
-* @param scalar_function The scalar function
-* @param extra_info The extra information
-* @param destroy The callback that will be called to destroy the bind data (if any)
-*/
-DUCKDB_API void duckdb_scalar_function_set_extra_info(duckdb_scalar_function scalar_function, void *extra_info,
-                                                      duckdb_delete_callback_t destroy);
-
-/*!
-Sets the main function of the scalar function.
-
-* @param scalar_function The scalar function
-* @param function The function
-*/
-DUCKDB_API void duckdb_scalar_function_set_function(duckdb_scalar_function scalar_function,
-                                                    duckdb_scalar_function_t function);
-
-/*!
-Register the scalar function object within the given connection.
-
-The function requires at least a name, a function and a return type.
-
-If the function is incomplete or a function with this name already exists DuckDBError is returned.
-
-* @param con The connection to register it in.
-* @param scalar_function The function pointer
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_scalar_function(duckdb_connection con, duckdb_scalar_function scalar_function);
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_scalar_function_set_extra_info`.
-
-* @param info The info object.
-* @return The extra info.
-*/
-DUCKDB_API void *duckdb_scalar_function_get_extra_info(duckdb_function_info info);
-
-/*!
-Report that an error has occurred while executing the scalar function.
-
-* @param info The info object.
-* @param error The error message
-*/
-DUCKDB_API void duckdb_scalar_function_set_error(duckdb_function_info info, const char *error);
-
-/*!
-Creates a new empty scalar function set.
-
-The return value should be destroyed with `duckdb_destroy_scalar_function_set`.
-
-* @return The scalar function set object.
-*/
-DUCKDB_API duckdb_scalar_function_set duckdb_create_scalar_function_set(const char *name);
-
-/*!
-Destroys the given scalar function set object.
-
-*/
-DUCKDB_API void duckdb_destroy_scalar_function_set(duckdb_scalar_function_set *scalar_function_set);
-
-/*!
-Adds the scalar function as a new overload to the scalar function set.
-
-Returns DuckDBError if the function could not be added, for example if the overload already exists.
-
-* @param set The scalar function set
-* @param function The function to add
-*/
-DUCKDB_API duckdb_state duckdb_add_scalar_function_to_set(duckdb_scalar_function_set set,
-                                                          duckdb_scalar_function function);
-
-/*!
-Register the scalar function set within the given connection.
-
-The set requires at least a single valid overload.
-
-If the set is incomplete or a function with this name already exists DuckDBError is returned.
-
-* @param con The connection to register it in.
-* @param set The function set to register
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_scalar_function_set(duckdb_connection con, duckdb_scalar_function_set set);
-
-//===--------------------------------------------------------------------===//
-// Aggregate Functions
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a new empty aggregate function.
-
-The return value should be destroyed with `duckdb_destroy_aggregate_function`.
-
-* @return The aggregate function object.
-*/
-DUCKDB_API duckdb_aggregate_function duckdb_create_aggregate_function();
-
-/*!
-Destroys the given aggregate function object.
-
-*/
-DUCKDB_API void duckdb_destroy_aggregate_function(duckdb_aggregate_function *aggregate_function);
-
-/*!
-Sets the name of the given aggregate function.
-
-* @param aggregate_function The aggregate function
-* @param name The name of the aggregate function
-*/
-DUCKDB_API void duckdb_aggregate_function_set_name(duckdb_aggregate_function aggregate_function, const char *name);
-
-/*!
-Adds a parameter to the aggregate function.
-
-* @param aggregate_function The aggregate function.
-* @param type The parameter type. Cannot contain INVALID.
-*/
-DUCKDB_API void duckdb_aggregate_function_add_parameter(duckdb_aggregate_function aggregate_function,
-                                                        duckdb_logical_type type);
-
-/*!
-Sets the return type of the aggregate function.
-
-* @param aggregate_function The aggregate function.
-* @param type The return type. Cannot contain INVALID or ANY.
-*/
-DUCKDB_API void duckdb_aggregate_function_set_return_type(duckdb_aggregate_function aggregate_function,
-                                                          duckdb_logical_type type);
-
-/*!
-Sets the main functions of the aggregate function.
-
-* @param aggregate_function The aggregate function
-* @param state_size state size
-* @param state_init state init function
-* @param update update states
-* @param combine combine states
-* @param finalize finalize states
-*/
-DUCKDB_API void duckdb_aggregate_function_set_functions(duckdb_aggregate_function aggregate_function,
-                                                        duckdb_aggregate_state_size state_size,
-                                                        duckdb_aggregate_init_t state_init,
-                                                        duckdb_aggregate_update_t update,
-                                                        duckdb_aggregate_combine_t combine,
-                                                        duckdb_aggregate_finalize_t finalize);
-
-/*!
-Sets the state destructor callback of the aggregate function (optional)
-
-* @param aggregate_function The aggregate function
-* @param destroy state destroy callback
-*/
-DUCKDB_API void duckdb_aggregate_function_set_destructor(duckdb_aggregate_function aggregate_function,
-                                                         duckdb_aggregate_destroy_t destroy);
-
-/*!
-Register the aggregate function object within the given connection.
-
-The function requires at least a name, functions and a return type.
-
-If the function is incomplete or a function with this name already exists DuckDBError is returned.
-
-* @param con The connection to register it in.
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_aggregate_function(duckdb_connection con,
-                                                           duckdb_aggregate_function aggregate_function);
-
-/*!
-Sets the NULL handling of the aggregate function to SPECIAL_HANDLING.
-
-* @param aggregate_function The aggregate function
-*/
-DUCKDB_API void duckdb_aggregate_function_set_special_handling(duckdb_aggregate_function aggregate_function);
-
-/*!
-Assigns extra information to the scalar function that can be fetched during binding, etc.
-
-* @param aggregate_function The aggregate function
-* @param extra_info The extra information
-* @param destroy The callback that will be called to destroy the bind data (if any)
-*/
-DUCKDB_API void duckdb_aggregate_function_set_extra_info(duckdb_aggregate_function aggregate_function, void *extra_info,
-                                                         duckdb_delete_callback_t destroy);
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_aggregate_function_set_extra_info`.
-
-* @param info The info object
-* @return The extra info
-*/
-DUCKDB_API void *duckdb_aggregate_function_get_extra_info(duckdb_function_info info);
-
-/*!
-Report that an error has occurred while executing the aggregate function.
-
-* @param info The info object
-* @param error The error message
-*/
-DUCKDB_API void duckdb_aggregate_function_set_error(duckdb_function_info info, const char *error);
-
-/*!
-Creates a new empty aggregate function set.
-
-The return value should be destroyed with `duckdb_destroy_aggregate_function_set`.
-
-* @return The aggregate function set object.
-*/
-DUCKDB_API duckdb_aggregate_function_set duckdb_create_aggregate_function_set(const char *name);
-
-/*!
-Destroys the given aggregate function set object.
-
-*/
-DUCKDB_API void duckdb_destroy_aggregate_function_set(duckdb_aggregate_function_set *aggregate_function_set);
-
-/*!
-Adds the aggregate function as a new overload to the aggregate function set.
-
-Returns DuckDBError if the function could not be added, for example if the overload already exists.
-
-* @param set The aggregate function set
-* @param function The function to add
-*/
-DUCKDB_API duckdb_state duckdb_add_aggregate_function_to_set(duckdb_aggregate_function_set set,
-                                                             duckdb_aggregate_function function);
-
-/*!
-Register the aggregate function set within the given connection.
-
-The set requires at least a single valid overload.
-
-If the set is incomplete or a function with this name already exists DuckDBError is returned.
-
-* @param con The connection to register it in.
-* @param set The function set to register
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_aggregate_function_set(duckdb_connection con,
-                                                               duckdb_aggregate_function_set set);
-
-//===--------------------------------------------------------------------===//
-// Table Functions
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a new empty table function.
-
-The return value should be destroyed with `duckdb_destroy_table_function`.
-
-* @return The table function object.
-*/
-DUCKDB_API duckdb_table_function duckdb_create_table_function();
-
-/*!
-Destroys the given table function object.
-
-* @param table_function The table function to destroy
-*/
-DUCKDB_API void duckdb_destroy_table_function(duckdb_table_function *table_function);
-
-/*!
-Sets the name of the given table function.
-
-* @param table_function The table function
-* @param name The name of the table function
-*/
-DUCKDB_API void duckdb_table_function_set_name(duckdb_table_function table_function, const char *name);
-
-/*!
-Adds a parameter to the table function.
-
-* @param table_function The table function.
-* @param type The parameter type. Cannot contain INVALID.
-*/
-DUCKDB_API void duckdb_table_function_add_parameter(duckdb_table_function table_function, duckdb_logical_type type);
-
-/*!
-Adds a named parameter to the table function.
-
-* @param table_function The table function.
-* @param name The parameter name.
-* @param type The parameter type. Cannot contain INVALID.
-*/
-DUCKDB_API void duckdb_table_function_add_named_parameter(duckdb_table_function table_function, const char *name,
-                                                          duckdb_logical_type type);
-
-/*!
-Assigns extra information to the table function that can be fetched during binding, etc.
-
-* @param table_function The table function
-* @param extra_info The extra information
-* @param destroy The callback that will be called to destroy the bind data (if any)
-*/
-DUCKDB_API void duckdb_table_function_set_extra_info(duckdb_table_function table_function, void *extra_info,
-                                                     duckdb_delete_callback_t destroy);
-
-/*!
-Sets the bind function of the table function.
-
-* @param table_function The table function
-* @param bind The bind function
-*/
-DUCKDB_API void duckdb_table_function_set_bind(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
-
-/*!
-Sets the init function of the table function.
-
-* @param table_function The table function
-* @param init The init function
-*/
-DUCKDB_API void duckdb_table_function_set_init(duckdb_table_function table_function, duckdb_table_function_init_t init);
-
-/*!
-Sets the thread-local init function of the table function.
-
-* @param table_function The table function
-* @param init The init function
-*/
-DUCKDB_API void duckdb_table_function_set_local_init(duckdb_table_function table_function,
-                                                     duckdb_table_function_init_t init);
-
-/*!
-Sets the main function of the table function.
-
-* @param table_function The table function
-* @param function The function
-*/
-DUCKDB_API void duckdb_table_function_set_function(duckdb_table_function table_function,
-                                                   duckdb_table_function_t function);
-
-/*!
-Sets whether or not the given table function supports projection pushdown.
-
-If this is set to true, the system will provide a list of all required columns in the `init` stage through
-the `duckdb_init_get_column_count` and `duckdb_init_get_column_index` functions.
-If this is set to false (the default), the system will expect all columns to be projected.
-
-* @param table_function The table function
-* @param pushdown True if the table function supports projection pushdown, false otherwise.
-*/
-DUCKDB_API void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown);
-
-/*!
-Register the table function object within the given connection.
-
-The function requires at least a name, a bind function, an init function and a main function.
-
-If the function is incomplete or a function with this name already exists DuckDBError is returned.
-
-* @param con The connection to register it in.
-* @param function The function pointer
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_table_function(duckdb_connection con, duckdb_table_function function);
-
-//===--------------------------------------------------------------------===//
-// Table Function Bind
-//===--------------------------------------------------------------------===//
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
-
-* @param info The info object
-* @return The extra info
-*/
-DUCKDB_API void *duckdb_bind_get_extra_info(duckdb_bind_info info);
-
-/*!
-Adds a result column to the output of the table function.
-
-* @param info The table function's bind info.
-* @param name The column name.
-* @param type The logical column type.
-*/
-DUCKDB_API void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type);
-
-/*!
-Retrieves the number of regular (non-named) parameters to the function.
-
-* @param info The info object
-* @return The number of parameters
-*/
-DUCKDB_API idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info);
-
-/*!
-Retrieves the parameter at the given index.
-
-The result must be destroyed with `duckdb_destroy_value`.
-
-* @param info The info object
-* @param index The index of the parameter to get
-* @return The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index);
-
-/*!
-Retrieves a named parameter with the given name.
-
-The result must be destroyed with `duckdb_destroy_value`.
-
-* @param info The info object
-* @param name The name of the parameter
-* @return The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_bind_get_named_parameter(duckdb_bind_info info, const char *name);
-
-/*!
-Sets the user-provided bind data in the bind object. This object can be retrieved again during execution.
-
-* @param info The info object
-* @param bind_data The bind data object.
-* @param destroy The callback that will be called to destroy the bind data (if any)
-*/
-DUCKDB_API void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
-
-/*!
-Sets the cardinality estimate for the table function, used for optimization.
-
-* @param info The bind data object.
-* @param is_exact Whether or not the cardinality estimate is exact, or an approximation
-*/
-DUCKDB_API void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact);
-
-/*!
-Report that an error has occurred while calling bind.
-
-* @param info The info object
-* @param error The error message
-*/
-DUCKDB_API void duckdb_bind_set_error(duckdb_bind_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Table Function Init
-//===--------------------------------------------------------------------===//
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
-
-* @param info The info object
-* @return The extra info
-*/
-DUCKDB_API void *duckdb_init_get_extra_info(duckdb_init_info info);
-
-/*!
-Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
-
-Note that the bind data should be considered as read-only.
-For tracking state, use the init data instead.
-
-* @param info The info object
-* @return The bind data object
-*/
-DUCKDB_API void *duckdb_init_get_bind_data(duckdb_init_info info);
-
-/*!
-Sets the user-provided init data in the init object. This object can be retrieved again during execution.
-
-* @param info The info object
-* @param init_data The init data object.
-* @param destroy The callback that will be called to destroy the init data (if any)
-*/
-DUCKDB_API void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
-
-/*!
-Returns the number of projected columns.
-
-This function must be used if projection pushdown is enabled to figure out which columns to emit.
-
-* @param info The info object
-* @return The number of projected columns.
-*/
-DUCKDB_API idx_t duckdb_init_get_column_count(duckdb_init_info info);
-
-/*!
-Returns the column index of the projected column at the specified position.
-
-This function must be used if projection pushdown is enabled to figure out which columns to emit.
-
-* @param info The info object
-* @param column_index The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)
-* @return The column index of the projected column.
-*/
-DUCKDB_API idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index);
-
-/*!
-Sets how many threads can process this table function in parallel (default: 1)
-
-* @param info The info object
-* @param max_threads The maximum amount of threads that can process this table function
-*/
-DUCKDB_API void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads);
-
-/*!
-Report that an error has occurred while calling init.
-
-* @param info The info object
-* @param error The error message
-*/
-DUCKDB_API void duckdb_init_set_error(duckdb_init_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Table Function
-//===--------------------------------------------------------------------===//
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
-
-* @param info The info object
-* @return The extra info
-*/
-DUCKDB_API void *duckdb_function_get_extra_info(duckdb_function_info info);
-
-/*!
-Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
-
-Note that the bind data should be considered as read-only.
-For tracking state, use the init data instead.
-
-* @param info The info object
-* @return The bind data object
-*/
-DUCKDB_API void *duckdb_function_get_bind_data(duckdb_function_info info);
-
-/*!
-Gets the init data set by `duckdb_init_set_init_data` during the init.
-
-* @param info The info object
-* @return The init data object
-*/
-DUCKDB_API void *duckdb_function_get_init_data(duckdb_function_info info);
-
-/*!
-Gets the thread-local init data set by `duckdb_init_set_init_data` during the local_init.
-
-* @param info The info object
-* @return The init data object
-*/
-DUCKDB_API void *duckdb_function_get_local_init_data(duckdb_function_info info);
-
-/*!
-Report that an error has occurred while executing the function.
-
-* @param info The info object
-* @param error The error message
-*/
-DUCKDB_API void duckdb_function_set_error(duckdb_function_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Replacement Scans
-//===--------------------------------------------------------------------===//
-
-/*!
-Add a replacement scan definition to the specified database.
-
-* @param db The database object to add the replacement scan to
-* @param replacement The replacement scan callback
-* @param extra_data Extra data that is passed back into the specified callback
-* @param delete_callback The delete callback to call on the extra data, if any
-*/
-DUCKDB_API void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback_t replacement,
-                                            void *extra_data, duckdb_delete_callback_t delete_callback);
-
-/*!
-Sets the replacement function name. If this function is called in the replacement callback,
-the replacement scan is performed. If it is not called, the replacement callback is not performed.
-
-* @param info The info object
-* @param function_name The function name to substitute.
-*/
-DUCKDB_API void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info, const char *function_name);
-
-/*!
-Adds a parameter to the replacement scan function.
-
-* @param info The info object
-* @param parameter The parameter to add.
-*/
-DUCKDB_API void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info, duckdb_value parameter);
-
-/*!
-Report that an error has occurred while executing the replacement scan.
-
-* @param info The info object
-* @param error The error message
-*/
-DUCKDB_API void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Profiling Info
-//===--------------------------------------------------------------------===//
-
-/*!
-Returns the root node of the profiling information. Returns nullptr, if profiling is not enabled.
-
-* @param connection A connection object.
-* @return A profiling information object.
-*/
-DUCKDB_API duckdb_profiling_info duckdb_get_profiling_info(duckdb_connection connection);
-
-/*!
-Returns the value of the metric of the current profiling info node. Returns nullptr, if the metric does
- not exist or is not enabled. Currently, the value holds a string, and you can retrieve the string
- by calling the corresponding function: char *duckdb_get_varchar(duckdb_value value).
-
-* @param info A profiling information object.
-* @param key The name of the requested metric.
-* @return The value of the metric. Must be freed with `duckdb_destroy_value`
-*/
-DUCKDB_API duckdb_value duckdb_profiling_info_get_value(duckdb_profiling_info info, const char *key);
-
-/*!
-Returns the key-value metric map of this profiling node as a MAP duckdb_value.
-The individual elements are accessible via the duckdb_value MAP functions.
-
-* @param info A profiling information object.
-* @return The key-value metric map as a MAP duckdb_value.
-*/
-DUCKDB_API duckdb_value duckdb_profiling_info_get_metrics(duckdb_profiling_info info);
-
-/*!
-Returns the number of children in the current profiling info node.
-
-* @param info A profiling information object.
-* @return The number of children in the current node.
-*/
-DUCKDB_API idx_t duckdb_profiling_info_get_child_count(duckdb_profiling_info info);
-
-/*!
-Returns the child node at the specified index.
-
-* @param info A profiling information object.
-* @param index The index of the child node.
-* @return The child node at the specified index.
-*/
-DUCKDB_API duckdb_profiling_info duckdb_profiling_info_get_child(duckdb_profiling_info info, idx_t index);
-
-//===--------------------------------------------------------------------===//
-// Appender
-//===--------------------------------------------------------------------===//
-
-// Appenders are the most efficient way of loading data into DuckDB from within the C API.
-// They are recommended for fast data loading as they perform better than prepared statements or individual `INSERT
-// INTO` statements.
-
-// Appends are possible in row-wise format, and by appending entire data chunks.
-
-// Row-wise: for every column, a `duckdb_append_[type]` call should be made. After finishing all appends to a row, call
-// `duckdb_appender_end_row`.
-
-// Chunk-wise: Consecutively call `duckdb_append_data_chunk` until all chunks have been appended.
-
-// After all data has been appended, call `duckdb_appender_close` to finalize the appender followed by
-// `duckdb_appender_destroy` to clean up the memory.
-
-/*!
-Creates an appender object.
-
-Note that the object must be destroyed with `duckdb_appender_destroy`.
-
-* @param connection The connection context to create the appender in.
-* @param schema The schema of the table to append to, or `nullptr` for the default schema.
-* @param table The table name to append to.
-* @param out_appender The resulting appender object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
-                                               duckdb_appender *out_appender);
-
-/*!
-Creates an appender object.
-
-Note that the object must be destroyed with `duckdb_appender_destroy`.
-
-* @param connection The connection context to create the appender in.
-* @param catalog The catalog of the table to append to, or `nullptr` for the default catalog.
-* @param schema The schema of the table to append to, or `nullptr` for the default schema.
-* @param table The table name to append to.
-* @param out_appender The resulting appender object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_create_ext(duckdb_connection connection, const char *catalog,
-                                                   const char *schema, const char *table,
-                                                   duckdb_appender *out_appender);
-
-/*!
-Returns the number of columns that belong to the appender.
-If there is no active column list, then this equals the table's physical columns.
-
-* @param appender The appender to get the column count from.
-* @return The number of columns in the data chunks.
-*/
-DUCKDB_API idx_t duckdb_appender_column_count(duckdb_appender appender);
-
-/*!
-Returns the type of the column at the specified index. This is either a type in the active column list, or the same type
-as a column in the receiving table.
-
-Note: The resulting type must be destroyed with `duckdb_destroy_logical_type`.
-
-* @param appender The appender to get the column type from.
-* @param col_idx The index of the column to get the type of.
-* @return The `duckdb_logical_type` of the column.
-*/
-DUCKDB_API duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx);
-
-/*!
-Returns the error message associated with the given appender.
-If the appender has no error message, this returns `nullptr` instead.
-
-The error message should not be freed. It will be de-allocated when `duckdb_appender_destroy` is called.
-
-* @param appender The appender to get the error from.
-* @return The error message, or `nullptr` if there is none.
-*/
-DUCKDB_API const char *duckdb_appender_error(duckdb_appender appender);
-
-/*!
-Flush the appender to the table, forcing the cache of the appender to be cleared. If flushing the data triggers a
-constraint violation or any other error, then all data is invalidated, and this function returns DuckDBError.
-It is not possible to append more values. Call duckdb_appender_error to obtain the error message followed by
-duckdb_appender_destroy to destroy the invalidated appender.
-
-* @param appender The appender to flush.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_flush(duckdb_appender appender);
-
-/*!
-Closes the appender by flushing all intermediate states and closing it for further appends. If flushing the data
-triggers a constraint violation or any other error, then all data is invalidated, and this function returns DuckDBError.
-Call duckdb_appender_error to obtain the error message followed by duckdb_appender_destroy to destroy the invalidated
-appender.
-
-* @param appender The appender to flush and close.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_close(duckdb_appender appender);
-
-/*!
-Closes the appender by flushing all intermediate states to the table and destroying it. By destroying it, this function
-de-allocates all memory associated with the appender. If flushing the data triggers a constraint violation,
-then all data is invalidated, and this function returns DuckDBError. Due to the destruction of the appender, it is no
-longer possible to obtain the specific error message with duckdb_appender_error. Therefore, call duckdb_appender_close
-before destroying the appender, if you need insights into the specific error.
-
-* @param appender The appender to flush, close and destroy.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_destroy(duckdb_appender *appender);
-
-/*!
-Appends a column to the active column list of the appender. Immediately flushes all previous data.
-
-The active column list specifies all columns that are expected when flushing the data. Any non-active columns are filled
-with their default values, or NULL.
-
-* @param appender The appender to add the column to.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_add_column(duckdb_appender appender, const char *name);
-
-/*!
-Removes all columns from the active column list of the appender, resetting the appender to treat all columns as active.
-Immediately flushes all previous data.
-
-* @param appender The appender to clear the columns from.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_clear_columns(duckdb_appender appender);
-
-/*!
-A nop function, provided for backwards compatibility reasons. Does nothing. Only `duckdb_appender_end_row` is required.
-*/
-DUCKDB_API duckdb_state duckdb_appender_begin_row(duckdb_appender appender);
-
-/*!
-Finish the current row of appends. After end_row is called, the next row can be appended.
-
-* @param appender The appender.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_end_row(duckdb_appender appender);
-
-/*!
-Append a DEFAULT value (NULL if DEFAULT not available for column) to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_default(duckdb_appender appender);
-
-/*!
-Append a DEFAULT value, at the specified row and column, (NULL if DEFAULT not available for column) to the chunk created
-from the specified appender. The default value of the column must be a constant value. Non-deterministic expressions
-like nextval('seq') or random() are not supported.
-
-* @param appender The appender to get the default value from.
-* @param chunk The data chunk to append the default value to.
-* @param col The chunk column index to append the default value to.
-* @param row The chunk row index to append the default value to.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_append_default_to_chunk(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col,
-                                                       idx_t row);
-
-/*!
-Append a bool value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_bool(duckdb_appender appender, bool value);
-
-/*!
-Append an int8_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value);
-
-/*!
-Append an int16_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value);
-
-/*!
-Append an int32_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value);
-
-/*!
-Append an int64_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value);
-
-/*!
-Append a duckdb_hugeint value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value);
-
-/*!
-Append a uint8_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value);
-
-/*!
-Append a uint16_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value);
-
-/*!
-Append a uint32_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value);
-
-/*!
-Append a uint64_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value);
-
-/*!
-Append a duckdb_uhugeint value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uhugeint(duckdb_appender appender, duckdb_uhugeint value);
-
-/*!
-Append a float value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_float(duckdb_appender appender, float value);
-
-/*!
-Append a double value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_double(duckdb_appender appender, double value);
-
-/*!
-Append a duckdb_date value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value);
-
-/*!
-Append a duckdb_time value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value);
-
-/*!
-Append a duckdb_timestamp value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value);
-
-/*!
-Append a duckdb_interval value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value);
-
-/*!
-Append a varchar value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val);
-
-/*!
-Append a varchar value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length);
-
-/*!
-Append a blob value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length);
-
-/*!
-Append a NULL value to the appender (of any type).
-*/
-DUCKDB_API duckdb_state duckdb_append_null(duckdb_appender appender);
-
-/*!
-Append a duckdb_value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_value(duckdb_appender appender, duckdb_value value);
-
-/*!
-Appends a pre-filled data chunk to the specified appender.
- Attempts casting, if the data chunk types do not match the active appender types.
-
-* @param appender The appender to append to.
-* @param chunk The data chunk to append.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk);
-
-//===--------------------------------------------------------------------===//
-// Table Description
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a table description object. Note that `duckdb_table_description_destroy` should always be called on the
-resulting table_description, even if the function returns `DuckDBError`.
-
-* @param connection The connection context.
-* @param schema The schema of the table, or `nullptr` for the default schema.
-* @param table The table name.
-* @param out The resulting table description object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_table_description_create(duckdb_connection connection, const char *schema,
-                                                        const char *table, duckdb_table_description *out);
-
-/*!
-Creates a table description object. Note that `duckdb_table_description_destroy` must be called on the resulting
-table_description, even if the function returns `DuckDBError`.
-
-* @param connection The connection context.
-* @param catalog The catalog (database) name of the table, or `nullptr` for the default catalog.
-* @param schema The schema of the table, or `nullptr` for the default schema.
-* @param table The table name.
-* @param out The resulting table description object.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_table_description_create_ext(duckdb_connection connection, const char *catalog,
-                                                            const char *schema, const char *table,
-                                                            duckdb_table_description *out);
-
-/*!
-Destroy the TableDescription object.
-
-* @param table_description The table_description to destroy.
-*/
-DUCKDB_API void duckdb_table_description_destroy(duckdb_table_description *table_description);
-
-/*!
-Returns the error message associated with the given table_description.
-If the table_description has no error message, this returns `nullptr` instead.
-The error message should not be freed. It will be de-allocated when `duckdb_table_description_destroy` is called.
-
-* @param table_description The table_description to get the error from.
-* @return The error message, or `nullptr` if there is none.
-*/
-DUCKDB_API const char *duckdb_table_description_error(duckdb_table_description table_description);
-
-/*!
-Check if the column at 'index' index of the table has a DEFAULT expression.
-
-* @param table_description The table_description to query.
-* @param index The index of the column to query.
-* @param out The out-parameter used to store the result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_column_has_default(duckdb_table_description table_description, idx_t index, bool *out);
-
-/*!
-Obtain the column name at 'index'.
-The out result must be destroyed with `duckdb_free`.
-
-* @param table_description The table_description to query.
-* @param index The index of the column to query.
-* @return The column name.
-*/
-DUCKDB_API char *duckdb_table_description_get_column_name(duckdb_table_description table_description, idx_t index);
-
-//===--------------------------------------------------------------------===//
-// Arrow Interface
-//===--------------------------------------------------------------------===//
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Executes a SQL query within a connection and stores the full (materialized) result in an arrow structure.
-If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling
-`duckdb_query_arrow_error`.
-
-Note that after running `duckdb_query_arrow`, `duckdb_destroy_arrow` must be called on the result object even if the
-query fails, otherwise the error stored within the result will not be freed correctly.
-
-* @param connection The connection to perform the query in.
-* @param query The SQL query to run.
-* @param out_result The query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Fetch the internal arrow schema from the arrow result. Remember to call release on the respective
-ArrowSchema object.
-
-* @param result The result to fetch the schema from.
-* @param out_schema The output schema.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Fetch the internal arrow schema from the prepared statement. Remember to call release on the respective
-ArrowSchema object.
-
-* @param prepared The prepared statement to fetch the schema from.
-* @param out_schema The output schema.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared,
-                                                     duckdb_arrow_schema *out_schema);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Convert a data chunk into an arrow struct array. Remember to call release on the respective
-ArrowArray object.
-
-* @param result The result object the data chunk have been fetched from.
-* @param chunk The data chunk to convert.
-* @param out_array The output array.
-*/
-DUCKDB_API void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Fetch an internal arrow struct array from the arrow result. Remember to call release on the respective
-ArrowArray object.
-
-This function can be called multiple time to get next chunks, which will free the previous out_array.
-So consume the out_array before calling this function again.
-
-* @param result The result to fetch the array from.
-* @param out_array The output array.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Returns the number of columns present in the arrow result object.
-
-* @param result The result object.
-* @return The number of columns present in the result object.
-*/
-DUCKDB_API idx_t duckdb_arrow_column_count(duckdb_arrow result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Returns the number of rows present in the arrow result object.
-
-* @param result The result object.
-* @return The number of rows present in the result object.
-*/
-DUCKDB_API idx_t duckdb_arrow_row_count(duckdb_arrow result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Returns the number of rows changed by the query stored in the arrow result. This is relevant only for
-INSERT/UPDATE/DELETE queries. For other queries the rows_changed will be 0.
-
-* @param result The result object.
-* @return The number of rows changed.
-*/
-DUCKDB_API idx_t duckdb_arrow_rows_changed(duckdb_arrow result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
- Returns the error message contained within the result. The error is only set if `duckdb_query_arrow` returns
-`DuckDBError`.
-
-The error message should not be freed. It will be de-allocated when `duckdb_destroy_arrow` is called.
-
-* @param result The result object to fetch the error from.
-* @return The error of the result.
-*/
-DUCKDB_API const char *duckdb_query_arrow_error(duckdb_arrow result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Closes the result and de-allocates all memory allocated for the arrow result.
-
-* @param result The result to destroy.
-*/
-DUCKDB_API void duckdb_destroy_arrow(duckdb_arrow *result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Releases the arrow array stream and de-allocates its memory.
-
-* @param stream_p The arrow array stream to destroy.
-*/
-DUCKDB_API void duckdb_destroy_arrow_stream(duckdb_arrow_stream *stream_p);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Executes the prepared statement with the given bound parameters, and returns an arrow query result.
-Note that after running `duckdb_execute_prepared_arrow`, `duckdb_destroy_arrow` must be called on the result object.
-
-* @param prepared_statement The prepared statement to execute.
-* @param out_result The query result.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement,
-                                                      duckdb_arrow *out_result);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Scans the Arrow stream and creates a view with the given name.
-
-* @param connection The connection on which to execute the scan.
-* @param table_name Name of the temporary view to create.
-* @param arrow Arrow stream wrapper.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name,
-                                          duckdb_arrow_stream arrow);
-
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Scans the Arrow array and creates a view with the given name.
-Note that after running `duckdb_arrow_array_scan`, `duckdb_destroy_arrow_stream` must be called on the out stream.
-
-* @param connection The connection on which to execute the scan.
-* @param table_name Name of the temporary view to create.
-* @param arrow_schema Arrow schema wrapper.
-* @param arrow_array Arrow array wrapper.
-* @param out_stream Output array stream that wraps around the passed schema, for releasing/deleting once done.
-* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *table_name,
-                                                duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
-                                                duckdb_arrow_stream *out_stream);
-
-#endif
-//===--------------------------------------------------------------------===//
-// Threading Information
-//===--------------------------------------------------------------------===//
-
-/*!
-Execute DuckDB tasks on this thread.
-
-Will return after `max_tasks` have been executed, or if there are no more tasks present.
-
-* @param database The database object to execute tasks for
-* @param max_tasks The maximum amount of tasks to execute
-*/
-DUCKDB_API void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks);
-
-/*!
-Creates a task state that can be used with duckdb_execute_tasks_state to execute tasks until
-`duckdb_finish_execution` is called on the state.
-
-`duckdb_destroy_state` must be called on the result.
-
-* @param database The database object to create the task state for
-* @return The task state that can be used with duckdb_execute_tasks_state.
-*/
-DUCKDB_API duckdb_task_state duckdb_create_task_state(duckdb_database database);
-
-/*!
-Execute DuckDB tasks on this thread.
-
-The thread will keep on executing tasks forever, until duckdb_finish_execution is called on the state.
-Multiple threads can share the same duckdb_task_state.
-
-* @param state The task state of the executor
-*/
-DUCKDB_API void duckdb_execute_tasks_state(duckdb_task_state state);
-
-/*!
-Execute DuckDB tasks on this thread.
-
-The thread will keep on executing tasks until either duckdb_finish_execution is called on the state,
-max_tasks tasks have been executed or there are no more tasks to be executed.
-
-Multiple threads can share the same duckdb_task_state.
-
-* @param state The task state of the executor
-* @param max_tasks The maximum amount of tasks to execute
-* @return The amount of tasks that have actually been executed
-*/
-DUCKDB_API idx_t duckdb_execute_n_tasks_state(duckdb_task_state state, idx_t max_tasks);
-
-/*!
-Finish execution on a specific task.
-
-* @param state The task state to finish execution
-*/
-DUCKDB_API void duckdb_finish_execution(duckdb_task_state state);
-
-/*!
-Check if the provided duckdb_task_state has finished execution
-
-* @param state The task state to inspect
-* @return Whether or not duckdb_finish_execution has been called on the task state
-*/
-DUCKDB_API bool duckdb_task_state_is_finished(duckdb_task_state state);
-
-/*!
-Destroys the task state returned from duckdb_create_task_state.
-
-Note that this should not be called while there is an active duckdb_execute_tasks_state running
-on the task state.
-
-* @param state The task state to clean up
-*/
-DUCKDB_API void duckdb_destroy_task_state(duckdb_task_state state);
-
-/*!
-Returns true if the execution of the current query is finished.
-
-* @param con The connection on which to check
-*/
-DUCKDB_API bool duckdb_execution_is_finished(duckdb_connection con);
-
-//===--------------------------------------------------------------------===//
-// Streaming Result Interface
-//===--------------------------------------------------------------------===//
-
-#ifndef DUCKDB_API_NO_DEPRECATED
-/*!
-**DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
-
-Fetches a data chunk from the (streaming) duckdb_result. This function should be called repeatedly until the result is
-exhausted.
-
-The result must be destroyed with `duckdb_destroy_data_chunk`.
-
-This function can only be used on duckdb_results created with 'duckdb_pending_prepared_streaming'
-
-If this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be
-mixed with the legacy result functions or the materialized result functions).
-
-It is not known beforehand how many chunks will be returned by this result.
-
-* @param result The result object to fetch the data chunk from.
-* @return The resulting data chunk. Returns `NULL` if the result has an error.
-*/
-DUCKDB_API duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result);
-
-#endif
-/*!
-Fetches a data chunk from a duckdb_result. This function should be called repeatedly until the result is exhausted.
-
-The result must be destroyed with `duckdb_destroy_data_chunk`.
-
-It is not known beforehand how many chunks will be returned by this result.
-
-* @param result The result object to fetch the data chunk from.
-* @return The resulting data chunk. Returns `NULL` if the result has an error.
-*/
-DUCKDB_API duckdb_data_chunk duckdb_fetch_chunk(duckdb_result result);
-
-//===--------------------------------------------------------------------===//
-// Cast Functions
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a new cast function object.
-
-* @return The cast function object.
-*/
-DUCKDB_API duckdb_cast_function duckdb_create_cast_function();
-
-/*!
-Sets the source type of the cast function.
-
-* @param cast_function The cast function object.
-* @param source_type The source type to set.
-*/
-DUCKDB_API void duckdb_cast_function_set_source_type(duckdb_cast_function cast_function,
-                                                     duckdb_logical_type source_type);
-
-/*!
-Sets the target type of the cast function.
-
-* @param cast_function The cast function object.
-* @param target_type The target type to set.
-*/
-DUCKDB_API void duckdb_cast_function_set_target_type(duckdb_cast_function cast_function,
-                                                     duckdb_logical_type target_type);
-
-/*!
-Sets the "cost" of implicitly casting the source type to the target type using this function.
-
-* @param cast_function The cast function object.
-* @param cost The cost to set.
-*/
-DUCKDB_API void duckdb_cast_function_set_implicit_cast_cost(duckdb_cast_function cast_function, int64_t cost);
-
-/*!
-Sets the actual cast function to use.
-
-* @param cast_function The cast function object.
-* @param function The function to set.
-*/
-DUCKDB_API void duckdb_cast_function_set_function(duckdb_cast_function cast_function, duckdb_cast_function_t function);
-
-/*!
-Assigns extra information to the cast function that can be fetched during execution, etc.
-
-* @param extra_info The extra information
-* @param destroy The callback that will be called to destroy the extra information (if any)
-*/
-DUCKDB_API void duckdb_cast_function_set_extra_info(duckdb_cast_function cast_function, void *extra_info,
-                                                    duckdb_delete_callback_t destroy);
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_cast_function_set_extra_info`.
-
-* @param info The info object.
-* @return The extra info.
-*/
-DUCKDB_API void *duckdb_cast_function_get_extra_info(duckdb_function_info info);
-
-/*!
-Get the cast execution mode from the given function info.
-
-* @param info The info object.
-* @return The cast mode.
-*/
-DUCKDB_API duckdb_cast_mode duckdb_cast_function_get_cast_mode(duckdb_function_info info);
-
-/*!
-Report that an error has occurred while executing the cast function.
-
-* @param info The info object.
-* @param error The error message.
-*/
-DUCKDB_API void duckdb_cast_function_set_error(duckdb_function_info info, const char *error);
-
-/*!
-Report that an error has occurred while executing the cast function, setting the corresponding output row to NULL.
-
-* @param info The info object.
-* @param error The error message.
-* @param row The index of the row within the output vector to set to NULL.
-* @param output The output vector.
-*/
-DUCKDB_API void duckdb_cast_function_set_row_error(duckdb_function_info info, const char *error, idx_t row,
-                                                   duckdb_vector output);
-
-/*!
-Registers a cast function within the given connection.
-
-* @param con The connection to use.
-* @param cast_function The cast function to register.
-* @return Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_cast_function(duckdb_connection con, duckdb_cast_function cast_function);
-
-/*!
-Destroys the cast function object.
-
-* @param cast_function The cast function object.
-*/
-DUCKDB_API void duckdb_destroy_cast_function(duckdb_cast_function *cast_function);
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/duckdb/src/include/duckdb.hpp b/src/duckdb/src/include/duckdb.hpp
deleted file mode 100644
index 168dfd00c..000000000
--- a/src/duckdb/src/include/duckdb.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/connection.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/appender.hpp"
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog.hpp b/src/duckdb/src/include/duckdb/catalog/catalog.hpp
deleted file mode 100644
index dbef14ee5..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog.hpp
+++ /dev/null
@@ -1,428 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_transaction.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/enums/catalog_lookup_behavior.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/exception/catalog_exception.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-
-#include <functional>
-
-namespace duckdb {
-struct CreateSchemaInfo;
-struct DropInfo;
-struct BoundCreateTableInfo;
-struct AlterTableInfo;
-struct CreateTableFunctionInfo;
-struct CreateCopyFunctionInfo;
-struct CreatePragmaFunctionInfo;
-struct CreateFunctionInfo;
-struct CreateViewInfo;
-struct CreateSequenceInfo;
-struct CreateCollationInfo;
-struct CreateIndexInfo;
-struct CreateTypeInfo;
-struct CreateTableInfo;
-struct DatabaseSize;
-struct MetadataBlockInfo;
-
-class AttachedDatabase;
-class ClientContext;
-class Transaction;
-
-class AggregateFunctionCatalogEntry;
-class CollateCatalogEntry;
-class SchemaCatalogEntry;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class SequenceCatalogEntry;
-class TableFunctionCatalogEntry;
-class CopyFunctionCatalogEntry;
-class PragmaFunctionCatalogEntry;
-class CatalogSet;
-class DatabaseInstance;
-class DependencyManager;
-
-struct CatalogLookup;
-struct CatalogEntryLookup;
-struct SimilarCatalogEntry;
-
-class Binder;
-class LogicalOperator;
-class PhysicalOperator;
-class LogicalCreateIndex;
-class LogicalCreateTable;
-class LogicalInsert;
-class LogicalDelete;
-class LogicalUpdate;
-class CreateStatement;
-class CatalogEntryRetriever;
-
-//! Return value of Catalog::LookupEntry
-struct CatalogEntryLookup {
-	optional_ptr<SchemaCatalogEntry> schema;
-	optional_ptr<CatalogEntry> entry;
-	ErrorData error;
-
-	DUCKDB_API bool Found() const {
-		return entry;
-	}
-};
-
-//! The Catalog object represents the catalog of the database.
-class Catalog {
-public:
-	explicit Catalog(AttachedDatabase &db);
-	virtual ~Catalog();
-
-public:
-	//! Get the SystemCatalog from the ClientContext
-	DUCKDB_API static Catalog &GetSystemCatalog(ClientContext &context);
-	//! Get the SystemCatalog from the DatabaseInstance
-	DUCKDB_API static Catalog &GetSystemCatalog(DatabaseInstance &db);
-	//! Get the specified Catalog from the ClientContext
-	DUCKDB_API static Catalog &GetCatalog(ClientContext &context, const string &catalog_name);
-	//! Get the specified Catalog from the ClientContext
-	DUCKDB_API static Catalog &GetCatalog(CatalogEntryRetriever &retriever, const string &catalog_name);
-	//! Get the specified Catalog from the DatabaseInstance
-	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db, const string &catalog_name);
-	//! Gets the specified Catalog from the database if it exists
-	DUCKDB_API static optional_ptr<Catalog> GetCatalogEntry(ClientContext &context, const string &catalog_name);
-	//! Gets the specified Catalog from the database if it exists
-	DUCKDB_API static optional_ptr<Catalog> GetCatalogEntry(CatalogEntryRetriever &retriever,
-	                                                        const string &catalog_name);
-	//! Get the specific Catalog from the AttachedDatabase
-	DUCKDB_API static Catalog &GetCatalog(AttachedDatabase &db);
-
-	DUCKDB_API AttachedDatabase &GetAttached();
-	DUCKDB_API const AttachedDatabase &GetAttached() const;
-	DUCKDB_API DatabaseInstance &GetDatabase();
-
-	virtual bool IsDuckCatalog() {
-		return false;
-	}
-	virtual void Initialize(bool load_builtin) = 0;
-
-	bool IsSystemCatalog() const;
-	bool IsTemporaryCatalog() const;
-
-	//! Returns a version number that uniquely characterizes the current catalog snapshot.
-	//! If there are transaction-local changes, the version returned is >= TRANSACTION_START, o.w. it is a simple number
-	//! starting at 0 that is incremented at each commit that has had catalog changes.
-	//! If the catalog does not support versioning, no index is returned.
-	DUCKDB_API virtual optional_idx GetCatalogVersion(ClientContext &context) {
-		return {}; // don't return anything by default
-	}
-
-	//! Returns the catalog name - based on how the catalog was attached
-	DUCKDB_API const string &GetName() const;
-	DUCKDB_API idx_t GetOid();
-	DUCKDB_API virtual string GetCatalogType() = 0;
-
-	DUCKDB_API CatalogTransaction GetCatalogTransaction(ClientContext &context);
-
-	//! Creates a schema in the catalog.
-	DUCKDB_API virtual optional_ptr<CatalogEntry> CreateSchema(CatalogTransaction transaction,
-	                                                           CreateSchemaInfo &info) = 0;
-	DUCKDB_API optional_ptr<CatalogEntry> CreateSchema(ClientContext &context, CreateSchemaInfo &info);
-	//! Creates a table in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(ClientContext &context, BoundCreateTableInfo &info);
-	//! Creates a table in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info);
-	//! Create a table function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTableFunction(CatalogTransaction transaction,
-	                                                          CreateTableFunctionInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTableFunction(ClientContext &context, CreateTableFunctionInfo &info);
-	// Kept for backwards compatibility
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTableFunction(ClientContext &context,
-	                                                          optional_ptr<CreateTableFunctionInfo> info);
-	//! Create a copy function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction,
-	                                                         CreateCopyFunctionInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo &info);
-	//! Create a pragma function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreatePragmaFunction(CatalogTransaction transaction,
-	                                                           CreatePragmaFunctionInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo &info);
-	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateFunction(ClientContext &context, CreateFunctionInfo &info);
-	//! Creates a table in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateView(ClientContext &context, CreateViewInfo &info);
-	//! Creates a sequence in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateSequence(ClientContext &context, CreateSequenceInfo &info);
-	//! Creates a Enum in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateType(ClientContext &context, CreateTypeInfo &info);
-	//! Creates a collation in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateCollation(ClientContext &context, CreateCollationInfo &info);
-	//! Creates an index in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info);
-	DUCKDB_API optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info);
-
-	//! Creates a table in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                  BoundCreateTableInfo &info);
-	//! Create a table function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry>
-	CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTableFunctionInfo &info);
-	//! Create a copy function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                         CreateCopyFunctionInfo &info);
-	//! Create a pragma function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry>
-	CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreatePragmaFunctionInfo &info);
-	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                     CreateFunctionInfo &info);
-	//! Creates a view in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                 CreateViewInfo &info);
-	//! Creates a table in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                     CreateSequenceInfo &info);
-	//! Creates a enum in the catalog.
-	DUCKDB_API optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                 CreateTypeInfo &info);
-	//! Creates a collation in the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                                      CreateCollationInfo &info);
-
-	//! Drops an entry from the catalog
-	DUCKDB_API void DropEntry(ClientContext &context, DropInfo &info);
-
-	//! Returns the schema object with the specified name, or throws an exception if it does not exist
-	DUCKDB_API SchemaCatalogEntry &GetSchema(ClientContext &context, const string &name,
-	                                         QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API optional_ptr<SchemaCatalogEntry> GetSchema(ClientContext &context, const string &name,
-	                                                      OnEntryNotFound if_not_found,
-	                                                      QueryErrorContext error_context = QueryErrorContext());
-	//! Overloadable method for giving warnings on ambiguous naming id.tab due to a database and schema with name id
-	DUCKDB_API virtual bool CheckAmbiguousCatalogOrSchema(ClientContext &context, const string &name) {
-		return !!GetSchema(context, name, OnEntryNotFound::RETURN_NULL);
-	}
-	DUCKDB_API SchemaCatalogEntry &GetSchema(CatalogTransaction transaction, const string &name,
-	                                         QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API virtual optional_ptr<SchemaCatalogEntry>
-	GetSchema(CatalogTransaction transaction, const string &schema_name, OnEntryNotFound if_not_found,
-	          QueryErrorContext error_context = QueryErrorContext()) = 0;
-	DUCKDB_API static SchemaCatalogEntry &GetSchema(ClientContext &context, const string &catalog_name,
-	                                                const string &schema_name,
-	                                                QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API static optional_ptr<SchemaCatalogEntry> GetSchema(ClientContext &context, const string &catalog_name,
-	                                                             const string &schema_name,
-	                                                             OnEntryNotFound if_not_found,
-	                                                             QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API static optional_ptr<SchemaCatalogEntry> GetSchema(CatalogEntryRetriever &retriever,
-	                                                             const string &catalog_name, const string &schema_name,
-	                                                             OnEntryNotFound if_not_found,
-	                                                             QueryErrorContext error_context = QueryErrorContext());
-	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
-	DUCKDB_API virtual void ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) = 0;
-
-	//! Gets the "schema.name" entry of the specified type, if entry does not exist behavior depends on OnEntryNotFound
-	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(ClientContext &context, CatalogType type, const string &schema,
-	                                               const string &name, OnEntryNotFound if_not_found,
-	                                               QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(CatalogEntryRetriever &retriever, CatalogType type,
-	                                               const string &schema, const string &name,
-	                                               OnEntryNotFound if_not_found,
-	                                               QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API CatalogEntry &GetEntry(ClientContext &context, CatalogType type, const string &schema,
-	                                  const string &name, QueryErrorContext error_context = QueryErrorContext());
-	//! Gets the "catalog.schema.name" entry of the specified type, if entry does not exist behavior depends on
-	//! OnEntryNotFound
-	DUCKDB_API static optional_ptr<CatalogEntry> GetEntry(ClientContext &context, CatalogType type,
-	                                                      const string &catalog, const string &schema,
-	                                                      const string &name, OnEntryNotFound if_not_found,
-	                                                      QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API static optional_ptr<CatalogEntry> GetEntry(CatalogEntryRetriever &retriever, CatalogType type,
-	                                                      const string &catalog, const string &schema,
-	                                                      const string &name, OnEntryNotFound if_not_found,
-	                                                      QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API static CatalogEntry &GetEntry(ClientContext &context, CatalogType type, const string &catalog,
-	                                         const string &schema, const string &name,
-	                                         QueryErrorContext error_context = QueryErrorContext());
-
-	template <class T>
-	optional_ptr<T> GetEntry(ClientContext &context, const string &schema_name, const string &name,
-	                         OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()) {
-		auto entry = GetEntry(context, T::Type, schema_name, name, if_not_found, error_context);
-		if (!entry) {
-			return nullptr;
-		}
-		if (entry->type != T::Type) {
-			throw CatalogException(error_context, "%s is not an %s", name, T::Name);
-		}
-		return &entry->template Cast<T>();
-	}
-	template <class T>
-	T &GetEntry(ClientContext &context, const string &schema_name, const string &name,
-	            QueryErrorContext error_context = QueryErrorContext()) {
-		auto entry = GetEntry<T>(context, schema_name, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-		return *entry;
-	}
-
-	//! Append a scalar or aggregate function to the catalog
-	DUCKDB_API optional_ptr<CatalogEntry> AddFunction(ClientContext &context, CreateFunctionInfo &info);
-
-	//! Alter an existing entry in the catalog.
-	DUCKDB_API void Alter(CatalogTransaction transaction, AlterInfo &info);
-	DUCKDB_API void Alter(ClientContext &context, AlterInfo &info);
-
-	virtual unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
-	                                                       unique_ptr<PhysicalOperator> plan) = 0;
-	virtual unique_ptr<PhysicalOperator> PlanInsert(ClientContext &context, LogicalInsert &op,
-	                                                unique_ptr<PhysicalOperator> plan) = 0;
-	virtual unique_ptr<PhysicalOperator> PlanDelete(ClientContext &context, LogicalDelete &op,
-	                                                unique_ptr<PhysicalOperator> plan) = 0;
-	virtual unique_ptr<PhysicalOperator> PlanUpdate(ClientContext &context, LogicalUpdate &op,
-	                                                unique_ptr<PhysicalOperator> plan) = 0;
-	virtual unique_ptr<LogicalOperator> BindCreateIndex(Binder &binder, CreateStatement &stmt, TableCatalogEntry &table,
-	                                                    unique_ptr<LogicalOperator> plan) = 0;
-	virtual unique_ptr<LogicalOperator> BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry,
-	                                                      unique_ptr<LogicalOperator> plan,
-	                                                      unique_ptr<CreateIndexInfo> create_info,
-	                                                      unique_ptr<AlterTableInfo> alter_info);
-
-	virtual DatabaseSize GetDatabaseSize(ClientContext &context) = 0;
-	virtual vector<MetadataBlockInfo> GetMetadataInfo(ClientContext &context);
-
-	virtual bool InMemory() = 0;
-	virtual string GetDBPath() = 0;
-
-	//! Whether or not this catalog should search a specific type with the standard priority
-	DUCKDB_API virtual CatalogLookupBehavior CatalogTypeLookupRule(CatalogType type) const {
-		return CatalogLookupBehavior::STANDARD;
-	}
-
-	//! The default table is used for `SELECT * FROM <catalog_name>;`
-	DUCKDB_API bool HasDefaultTable() const;
-	DUCKDB_API void SetDefaultTable(const string &schema, const string &name);
-	DUCKDB_API string GetDefaultTable() const;
-	DUCKDB_API string GetDefaultTableSchema() const;
-
-	//! Returns the dependency manager of this catalog - if the catalog has anye
-	virtual optional_ptr<DependencyManager> GetDependencyManager();
-
-public:
-	template <class T>
-	static optional_ptr<T> GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
-	                                const string &name, OnEntryNotFound if_not_found,
-	                                QueryErrorContext error_context = QueryErrorContext()) {
-		auto entry = GetEntry(context, T::Type, catalog_name, schema_name, name, if_not_found, error_context);
-		if (!entry) {
-			return nullptr;
-		}
-		if (entry->type != T::Type) {
-			throw CatalogException(error_context, "%s is not an %s", name, T::Name);
-		}
-		return &entry->template Cast<T>();
-	}
-	template <class T>
-	static T &GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
-	                   const string &name, QueryErrorContext error_context = QueryErrorContext()) {
-		auto entry =
-		    GetEntry<T>(context, catalog_name, schema_name, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-		return *entry;
-	}
-
-	DUCKDB_API vector<reference<SchemaCatalogEntry>> GetSchemas(ClientContext &context);
-	DUCKDB_API static vector<reference<SchemaCatalogEntry>> GetSchemas(ClientContext &context,
-	                                                                   const string &catalog_name);
-	DUCKDB_API static vector<reference<SchemaCatalogEntry>> GetSchemas(CatalogEntryRetriever &retriever,
-	                                                                   const string &catalog_name);
-	DUCKDB_API static vector<reference<SchemaCatalogEntry>> GetAllSchemas(ClientContext &context);
-
-	virtual void Verify();
-
-	static CatalogException UnrecognizedConfigurationError(ClientContext &context, const string &name);
-
-	//! Autoload the extension required for `configuration_name` or throw a CatalogException
-	static void AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name);
-	//! Autoload the extension required for `function_name` or throw a CatalogException
-	static bool AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name);
-	DUCKDB_API static bool TryAutoLoad(ClientContext &context, const string &extension_name) noexcept;
-
-protected:
-	//! Reference to the database
-	AttachedDatabase &db;
-
-	//! (optionally) a default table to query for `SELECT * FROM <catalog_name>;`
-	string default_table;
-	string default_table_schema;
-
-public:
-	//! Lookup an entry using TryLookupEntry, throws if entry not found and if_not_found == THROW_EXCEPTION
-	CatalogEntryLookup LookupEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &schema,
-	                               const string &name, OnEntryNotFound if_not_found,
-	                               QueryErrorContext error_context = QueryErrorContext());
-
-private:
-	//! Lookup an entry in the schema, returning a lookup with the entry and schema if they exist
-	CatalogEntryLookup TryLookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
-	                                          const string &name);
-	//! Calls LookupEntryInternal on the schema, trying other schemas if the schema is invalid. Sets
-	//! CatalogEntryLookup->error depending on if_not_found when no entry is found
-	CatalogEntryLookup TryLookupEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &schema,
-	                                  const string &name, OnEntryNotFound if_not_found,
-	                                  QueryErrorContext error_context = QueryErrorContext());
-	static CatalogEntryLookup TryLookupEntry(CatalogEntryRetriever &retriever, vector<CatalogLookup> &lookups,
-	                                         CatalogType type, const string &name, OnEntryNotFound if_not_found,
-	                                         QueryErrorContext error_context = QueryErrorContext());
-	static CatalogEntryLookup TryLookupEntry(CatalogEntryRetriever &retriever, CatalogType type, const string &catalog,
-	                                         const string &schema, const string &name, OnEntryNotFound if_not_found,
-	                                         QueryErrorContext error_context);
-
-	//! Looks for a Catalog with a DefaultTable that matches the lookup
-	static CatalogEntryLookup TryLookupDefaultTable(CatalogEntryRetriever &retriever, CatalogType type,
-	                                                const string &catalog, const string &schema, const string &name,
-	                                                OnEntryNotFound if_not_found, QueryErrorContext error_context);
-
-	//! Return an exception with did-you-mean suggestion.
-	static CatalogException CreateMissingEntryException(CatalogEntryRetriever &retriever, const string &entry_name,
-	                                                    CatalogType type,
-	                                                    const reference_set_t<SchemaCatalogEntry> &schemas,
-	                                                    QueryErrorContext error_context);
-
-	//! Return the close entry name, the distance and the belonging schema.
-	static vector<SimilarCatalogEntry> SimilarEntriesInSchemas(ClientContext &context, const string &entry_name,
-	                                                           CatalogType type,
-	                                                           const reference_set_t<SchemaCatalogEntry> &schemas);
-
-	virtual void DropSchema(ClientContext &context, DropInfo &info) = 0;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp
deleted file mode 100644
index 88c9706a1..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/exception/catalog_exception.hpp"
-#include "duckdb/common/types/value.hpp"
-#include <memory>
-
-namespace duckdb {
-
-class Catalog;
-class CatalogSet;
-class ClientContext;
-class Deserializer;
-class SchemaCatalogEntry;
-class Serializer;
-class Value;
-
-struct AlterInfo;
-struct CatalogTransaction;
-struct CreateInfo;
-
-//! Abstract base class of an entry in the catalog
-class CatalogEntry {
-public:
-	CatalogEntry(CatalogType type, Catalog &catalog, string name);
-	CatalogEntry(CatalogType type, string name, idx_t oid);
-	virtual ~CatalogEntry();
-
-	//! The oid of the entry
-	idx_t oid;
-	//! The type of this catalog entry
-	CatalogType type;
-	//! Reference to the catalog set this entry is stored in
-	optional_ptr<CatalogSet> set;
-	//! The name of the entry
-	string name;
-	//! Whether or not the object is deleted
-	bool deleted;
-	//! Whether or not the object is temporary and should not be added to the WAL
-	bool temporary;
-	//! Whether or not the entry is an internal entry (cannot be deleted, not dumped, etc)
-	bool internal;
-	//! Timestamp at which the catalog entry was created
-	atomic<transaction_t> timestamp;
-	//! (optional) comment on this entry
-	Value comment;
-	//! (optional) extra data associated with this entry
-	unordered_map<string, string> tags;
-
-private:
-	//! Child entry
-	unique_ptr<CatalogEntry> child;
-	//! Parent entry (the node that dependents_map this node)
-	optional_ptr<CatalogEntry> parent;
-
-public:
-	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info);
-	virtual unique_ptr<CatalogEntry> AlterEntry(CatalogTransaction transaction, AlterInfo &info);
-	virtual void UndoAlter(ClientContext &context, AlterInfo &info);
-	virtual void Rollback(CatalogEntry &prev_entry);
-
-	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const;
-
-	virtual unique_ptr<CreateInfo> GetInfo() const;
-
-	//! Sets the CatalogEntry as the new root entry (i.e. the newest entry)
-	// this is called on a rollback to an AlterEntry
-	virtual void SetAsRoot();
-
-	//! Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry
-	virtual string ToSQL() const;
-
-	virtual Catalog &ParentCatalog();
-	virtual const Catalog &ParentCatalog() const;
-	virtual SchemaCatalogEntry &ParentSchema();
-	virtual const SchemaCatalogEntry &ParentSchema() const;
-
-	virtual void Verify(Catalog &catalog);
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-public:
-	void SetChild(unique_ptr<CatalogEntry> child);
-	unique_ptr<CatalogEntry> TakeChild();
-	bool HasChild() const;
-	bool HasParent() const;
-	CatalogEntry &Child();
-	CatalogEntry &Parent();
-	const CatalogEntry &Parent() const;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class InCatalogEntry : public CatalogEntry {
-public:
-	InCatalogEntry(CatalogType type, Catalog &catalog, string name);
-	~InCatalogEntry() override;
-
-	//! The catalog the entry belongs to
-	Catalog &catalog;
-
-public:
-	Catalog &ParentCatalog() override {
-		return catalog;
-	}
-	const Catalog &ParentCatalog() const override {
-		return catalog;
-	}
-
-	void Verify(Catalog &catalog) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp
deleted file mode 100644
index d40dcb976..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/function_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-
-namespace duckdb {
-
-//! An aggregate function in the catalog
-class AggregateFunctionCatalogEntry : public FunctionEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::AGGREGATE_FUNCTION_ENTRY;
-	static constexpr const char *Name = "aggregate function";
-
-public:
-	AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateAggregateFunctionInfo &info)
-	    : FunctionEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) {
-	}
-
-	//! The aggregate functions
-	AggregateFunctionSet functions;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/collate_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/collate_catalog_entry.hpp
deleted file mode 100644
index 67e61293c..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/collate_catalog_entry.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/collate_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-
-namespace duckdb {
-
-//! A collation catalog entry
-class CollateCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::COLLATION_ENTRY;
-	static constexpr const char *Name = "collation";
-
-public:
-	CollateCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateCollationInfo &info)
-	    : StandardEntry(CatalogType::COLLATION_ENTRY, schema, catalog, info.name), function(info.function),
-	      combinable(info.combinable), not_required_for_equality(info.not_required_for_equality) {
-	}
-
-	//! The collation function to push in case collation is required
-	ScalarFunction function;
-	//! Whether or not the collation can be combined with other collations.
-	bool combinable;
-	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
-	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
-	//! speeds up processing.
-	bool not_required_for_equality;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/column_dependency_manager.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/column_dependency_manager.hpp
deleted file mode 100644
index 51cc82862..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/column_dependency_manager.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/column_dependency_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/stack.hpp"
-#include "duckdb/common/index_map.hpp"
-
-namespace duckdb {
-
-//! Dependency Manager local to a table, responsible for keeping track of generated column dependencies
-
-class ColumnDependencyManager {
-public:
-	DUCKDB_API ColumnDependencyManager();
-	DUCKDB_API ~ColumnDependencyManager();
-	ColumnDependencyManager(ColumnDependencyManager &&other) = default;
-	ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
-
-public:
-	//! Get the bind order that ensures dependencies are resolved before dependents are
-	stack<LogicalIndex> GetBindOrder(const ColumnList &columns);
-
-	//! Adds a connection between the dependent and its dependencies
-	void AddGeneratedColumn(LogicalIndex index, const vector<LogicalIndex> &indices, bool root = true);
-	//! Add a generated column from a column definition
-	void AddGeneratedColumn(const ColumnDefinition &column, const ColumnList &list);
-
-	//! Removes the column(s) and outputs the new column indices
-	vector<LogicalIndex> RemoveColumn(LogicalIndex index, idx_t column_amount);
-
-	bool IsDependencyOf(LogicalIndex dependent, LogicalIndex dependency) const;
-	bool HasDependencies(LogicalIndex index) const;
-	const logical_index_set_t &GetDependencies(LogicalIndex index) const;
-
-	bool HasDependents(LogicalIndex index) const;
-	const logical_index_set_t &GetDependents(LogicalIndex index) const;
-
-private:
-	void RemoveStandardColumn(LogicalIndex index);
-	void RemoveGeneratedColumn(LogicalIndex index);
-
-	void AdjustSingle(LogicalIndex idx, idx_t offset);
-	// Clean up the gaps created by a Remove operation
-	vector<LogicalIndex> CleanupInternals(idx_t column_amount);
-
-private:
-	//! A map of column dependency to generated column(s)
-	logical_index_map_t<logical_index_set_t> dependencies_map;
-	//! A map of generated column name to (potentially generated)column dependencies
-	logical_index_map_t<logical_index_set_t> dependents_map;
-	//! For resolve-order purposes, keep track of the 'direct' (not inherited) dependencies of a generated column
-	logical_index_map_t<logical_index_set_t> direct_dependencies;
-	logical_index_set_t deleted_columns;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp
deleted file mode 100644
index d65c324bc..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/function/copy_function.hpp"
-
-namespace duckdb {
-
-class Catalog;
-struct CreateCopyFunctionInfo;
-
-//! A table function in the catalog
-class CopyFunctionCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::COPY_FUNCTION_ENTRY;
-	static constexpr const char *Name = "copy function";
-
-public:
-	CopyFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateCopyFunctionInfo &info);
-
-	//! The copy function
-	CopyFunction function;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_dependent_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_dependent_entry.hpp
deleted file mode 100644
index 83de8dc15..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_dependent_entry.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-
-namespace duckdb {
-
-class DependencyDependentEntry : public DependencyEntry {
-public:
-	~DependencyDependentEntry() override;
-	DependencyDependentEntry(Catalog &catalog, const DependencyInfo &info);
-
-public:
-	const CatalogEntryInfo &EntryInfo() const override;
-	const MangledEntryName &EntryMangledName() const override;
-	const CatalogEntryInfo &SourceInfo() const override;
-	const MangledEntryName &SourceMangledName() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp
deleted file mode 100644
index b90a5c5e0..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/dependency.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include <memory>
-
-namespace duckdb {
-
-class DependencyManager;
-
-class DependencySetCatalogEntry;
-
-//! Resembles a connection between an object and the CatalogEntry that can be retrieved from the Catalog using the
-//! identifiers listed here
-
-enum class DependencyEntryType : uint8_t { SUBJECT, DEPENDENT };
-
-class DependencyEntry : public InCatalogEntry {
-public:
-	~DependencyEntry() override;
-
-protected:
-	DependencyEntry(Catalog &catalog, DependencyEntryType type, const MangledDependencyName &name,
-	                const DependencyInfo &info);
-
-public:
-	const MangledEntryName &SubjectMangledName() const;
-	const DependencySubject &Subject() const;
-
-	const MangledEntryName &DependentMangledName() const;
-	const DependencyDependent &Dependent() const;
-
-	virtual const CatalogEntryInfo &EntryInfo() const = 0;
-	virtual const MangledEntryName &EntryMangledName() const = 0;
-	virtual const CatalogEntryInfo &SourceInfo() const = 0;
-	virtual const MangledEntryName &SourceMangledName() const = 0;
-
-public:
-	DependencyEntryType Side() const;
-
-protected:
-	const MangledEntryName dependent_name;
-	const MangledEntryName subject_name;
-	const DependencyDependent dependent;
-	const DependencySubject subject;
-
-private:
-	DependencyEntryType side;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp
deleted file mode 100644
index 043d0cb25..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-
-namespace duckdb {
-
-class DependencySubjectEntry : public DependencyEntry {
-public:
-	~DependencySubjectEntry() override;
-	DependencySubjectEntry(Catalog &catalog, const DependencyInfo &info);
-
-public:
-	const CatalogEntryInfo &EntryInfo() const override;
-	const MangledEntryName &EntryMangledName() const override;
-	const CatalogEntryInfo &SourceInfo() const override;
-	const MangledEntryName &SourceMangledName() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp
deleted file mode 100644
index bb3ecd596..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/duck_index_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! Wrapper class to allow copying a DuckIndexEntry (for altering the DuckIndexEntry metadata such as comments)
-struct IndexDataTableInfo {
-	IndexDataTableInfo(shared_ptr<DataTableInfo> info_p, const string &index_name_p);
-
-	//! Pointer to the DataTableInfo
-	shared_ptr<DataTableInfo> info;
-	//! The index to be removed on destruction
-	string index_name;
-};
-
-//! A duck index entry
-class DuckIndexEntry : public IndexCatalogEntry {
-public:
-	//! Create a DuckIndexEntry
-	DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &create_info,
-	               TableCatalogEntry &table);
-	DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &create_info,
-	               shared_ptr<IndexDataTableInfo> storage_info);
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-	void Rollback(CatalogEntry &prev_entry) override;
-
-	//! The indexed table information
-	shared_ptr<IndexDataTableInfo> info;
-	//! We need the initial size of the index after the CREATE INDEX statement,
-	//! as it is necessary to determine the auto checkpoint threshold
-	idx_t initial_index_size;
-
-public:
-	string GetSchemaName() const override;
-	string GetTableName() const override;
-
-	DataTableInfo &GetDataTableInfo() const;
-
-	//! Drops in-memory index data and marks all blocks on disk as free blocks, allowing to reclaim them
-	void CommitDrop();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_schema_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_schema_entry.hpp
deleted file mode 100644
index 188424015..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_schema_entry.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/dschema_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-
-namespace duckdb {
-
-//! A schema in the catalog
-class DuckSchemaEntry : public SchemaCatalogEntry {
-public:
-	DuckSchemaEntry(Catalog &catalog, CreateSchemaInfo &info);
-
-private:
-	//! The catalog set holding the tables
-	CatalogSet tables;
-	//! The catalog set holding the indexes
-	CatalogSet indexes;
-	//! The catalog set holding the table functions
-	CatalogSet table_functions;
-	//! The catalog set holding the copy functions
-	CatalogSet copy_functions;
-	//! The catalog set holding the pragma functions
-	CatalogSet pragma_functions;
-	//! The catalog set holding the scalar and aggregate functions
-	CatalogSet functions;
-	//! The catalog set holding the sequences
-	CatalogSet sequences;
-	//! The catalog set holding the collations
-	CatalogSet collations;
-	//! The catalog set holding the types
-	CatalogSet types;
-
-public:
-	optional_ptr<CatalogEntry> AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                                    OnCreateConflict on_conflict);
-	optional_ptr<CatalogEntry> AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                                            OnCreateConflict on_conflict, LogicalDependencyList dependencies);
-
-	optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) override;
-	optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) override;
-	optional_ptr<CatalogEntry> CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info,
-	                                       TableCatalogEntry &table) override;
-	optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info) override;
-	optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) override;
-	optional_ptr<CatalogEntry> CreateTableFunction(CatalogTransaction transaction,
-	                                               CreateTableFunctionInfo &info) override;
-	optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction,
-	                                              CreateCopyFunctionInfo &info) override;
-	optional_ptr<CatalogEntry> CreatePragmaFunction(CatalogTransaction transaction,
-	                                                CreatePragmaFunctionInfo &info) override;
-	optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) override;
-	optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info) override;
-	void Alter(CatalogTransaction transaction, AlterInfo &info) override;
-	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
-	void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
-	void DropEntry(ClientContext &context, DropInfo &info) override;
-	optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
-	CatalogSet::EntryLookup GetEntryDetailed(CatalogTransaction transaction, CatalogType type,
-	                                         const string &name) override;
-	SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-
-	void Verify(Catalog &catalog) override;
-
-private:
-	void OnDropEntry(CatalogTransaction transaction, CatalogEntry &entry);
-
-private:
-	//! Get the catalog set for the specified type
-	CatalogSet &GetCatalogSet(CatalogType type);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp
deleted file mode 100644
index fb9d5ae67..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/duck_table_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-
-namespace duckdb {
-
-struct AddConstraintInfo;
-
-//! A table catalog entry
-class DuckTableEntry : public TableCatalogEntry {
-public:
-	//! Create a TableCatalogEntry and initialize storage for it
-	DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
-	               shared_ptr<DataTable> inherited_storage = nullptr);
-
-public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
-	unique_ptr<CatalogEntry> AlterEntry(CatalogTransaction, AlterInfo &info) override;
-	void UndoAlter(ClientContext &context, AlterInfo &info) override;
-	void Rollback(CatalogEntry &prev_entry) override;
-
-	//! Returns the underlying storage of the table
-	DataTable &GetStorage() override;
-
-	//! Get statistics of a column (physical or virtual) within the table
-	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) override;
-
-	unique_ptr<BlockingSample> GetSample() override;
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-
-	void SetAsRoot() override;
-
-	void CommitAlter(string &column_name);
-	void CommitDrop();
-
-	TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) override;
-
-	vector<ColumnSegmentInfo> GetColumnSegmentInfo() override;
-
-	TableStorageInfo GetStorageInfo(ClientContext &context) override;
-
-	bool IsDuckTable() const override {
-		return true;
-	}
-
-private:
-	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
-	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
-	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
-	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
-	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
-	unique_ptr<CatalogEntry> SetNotNull(ClientContext &context, SetNotNullInfo &info);
-	unique_ptr<CatalogEntry> DropNotNull(ClientContext &context, DropNotNullInfo &info);
-	unique_ptr<CatalogEntry> AddForeignKeyConstraint(optional_ptr<ClientContext> context, AlterForeignKeyInfo &info);
-	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
-	unique_ptr<CatalogEntry> SetColumnComment(ClientContext &context, SetColumnCommentInfo &info);
-	unique_ptr<CatalogEntry> AddConstraint(ClientContext &context, AddConstraintInfo &info);
-
-	void UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index, const vector<LogicalIndex> &adjusted_indices,
-	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info,
-	                                   const vector<unique_ptr<BoundConstraint>> &bound_constraints, bool is_generated);
-
-private:
-	//! A reference to the underlying storage unit used for this table
-	shared_ptr<DataTable> storage;
-	//! Manages dependencies of the individual columns of the table
-	ColumnDependencyManager column_dependency_manager;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/function_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/function_entry.hpp
deleted file mode 100644
index 955e5cd87..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/function_entry.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/function_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-
-namespace duckdb {
-
-//! A function in the catalog
-class FunctionEntry : public StandardEntry {
-public:
-	FunctionEntry(CatalogType type, Catalog &catalog, SchemaCatalogEntry &schema, CreateFunctionInfo &info)
-	    : StandardEntry(type, schema, catalog, info.name) {
-		descriptions = std::move(info.descriptions);
-		this->dependencies = info.dependencies;
-		this->internal = info.internal;
-	}
-
-	vector<FunctionDescription> descriptions;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp
deleted file mode 100644
index 2b1ea037f..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/index_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-
-namespace duckdb {
-
-struct DataTableInfo;
-
-//! An index catalog entry
-class IndexCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::INDEX_ENTRY;
-	static constexpr const char *Name = "index";
-
-public:
-	//! Create an IndexCatalogEntry
-	IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info);
-
-	//! The SQL of the CREATE INDEX statement
-	string sql;
-	//! Additional index options
-	case_insensitive_map_t<Value> options;
-
-	//! The index type (ART, B+-tree, Skip-List, ...)
-	string index_type;
-	//! The index constraint type
-	IndexConstraintType index_constraint_type;
-	//! The column ids of the indexed table
-	vector<column_t> column_ids;
-	//! The set of expressions to index by
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> parsed_expressions;
-
-public:
-	//! Returns the CreateIndexInfo
-	unique_ptr<CreateInfo> GetInfo() const override;
-	//! Returns the original CREATE INDEX SQL
-	string ToSQL() const override;
-
-	virtual string GetSchemaName() const = 0;
-	virtual string GetTableName() const = 0;
-
-	//! Returns true, if this index is UNIQUE
-	bool IsUnique() const;
-	//! Returns true, if this index is a PRIMARY KEY
-	bool IsPrimary() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/list.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/list.hpp
deleted file mode 100644
index 1be747588..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/list.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
deleted file mode 100644
index 669fc499f..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/catalog_entry/function_entry.hpp"
-#include "duckdb/function/macro_function.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-//! A macro function in the catalog
-class MacroCatalogEntry : public FunctionEntry {
-public:
-	MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-	//! The macro function
-	vector<unique_ptr<MacroFunction>> macros;
-
-public:
-	unique_ptr<CreateInfo> GetInfo() const override;
-
-	string ToSQL() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp
deleted file mode 100644
index 0deb03fd3..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/function_entry.hpp"
-#include "duckdb/function/pragma_function.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-class Catalog;
-struct CreatePragmaFunctionInfo;
-
-//! A pragma function in the catalog
-class PragmaFunctionCatalogEntry : public FunctionEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::PRAGMA_FUNCTION_ENTRY;
-	static constexpr const char *Name = "pragma function";
-
-public:
-	PragmaFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreatePragmaFunctionInfo &info);
-
-	//! The pragma functions
-	PragmaFunctionSet functions;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp
deleted file mode 100644
index 2055a5a76..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/function_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-
-namespace duckdb {
-
-//! A scalar function in the catalog
-class ScalarFunctionCatalogEntry : public FunctionEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::SCALAR_FUNCTION_ENTRY;
-	static constexpr const char *Name = "scalar function";
-
-public:
-	ScalarFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateScalarFunctionInfo &info);
-
-	//! The scalar functions
-	ScalarFunctionSet functions;
-
-public:
-	unique_ptr<CatalogEntry> AlterEntry(CatalogTransaction transaction, AlterInfo &info) override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp
deleted file mode 100644
index 736cb9ca8..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/catalog/catalog_entry/macro_catalog_entry.hpp"
-
-namespace duckdb {
-
-//! A macro function in the catalog
-class ScalarMacroCatalogEntry : public MacroCatalogEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::MACRO_ENTRY;
-	static constexpr const char *Name = "macro function";
-
-public:
-	ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp
deleted file mode 100644
index a82ea56cd..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/schema_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-class StandardEntry;
-class TableCatalogEntry;
-class TableFunctionCatalogEntry;
-class SequenceCatalogEntry;
-
-enum class OnCreateConflict : uint8_t;
-
-struct AlterTableInfo;
-struct CreateIndexInfo;
-struct CreateFunctionInfo;
-struct CreateCollationInfo;
-struct CreateViewInfo;
-struct BoundCreateTableInfo;
-struct CreatePragmaFunctionInfo;
-struct CreateSequenceInfo;
-struct CreateSchemaInfo;
-struct CreateTableFunctionInfo;
-struct CreateCopyFunctionInfo;
-struct CreateTypeInfo;
-
-struct DropInfo;
-
-//! A schema in the catalog
-class SchemaCatalogEntry : public InCatalogEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::SCHEMA_ENTRY;
-	static constexpr const char *Name = "schema";
-
-public:
-	SchemaCatalogEntry(Catalog &catalog, CreateSchemaInfo &info);
-
-public:
-	unique_ptr<CreateInfo> GetInfo() const override;
-
-	//! Scan the specified catalog set, invoking the callback method for every entry
-	virtual void Scan(ClientContext &context, CatalogType type,
-	                  const std::function<void(CatalogEntry &)> &callback) = 0;
-	//! Scan the specified catalog set, invoking the callback method for every committed entry
-	virtual void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) = 0;
-
-	string ToSQL() const override;
-
-	//! Creates an index with the given name in the schema
-	virtual optional_ptr<CatalogEntry> CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info,
-	                                               TableCatalogEntry &table) = 0;
-	optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info, TableCatalogEntry &table);
-	//! Create a scalar or aggregate function within the given schema
-	virtual optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) = 0;
-	//! Creates a table with the given name in the schema
-	virtual optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) = 0;
-	//! Creates a view with the given name in the schema
-	virtual optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info) = 0;
-	//! Creates a sequence with the given name in the schema
-	virtual optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) = 0;
-	//! Create a table function within the given schema
-	virtual optional_ptr<CatalogEntry> CreateTableFunction(CatalogTransaction transaction,
-	                                                       CreateTableFunctionInfo &info) = 0;
-	//! Create a copy function within the given schema
-	virtual optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction,
-	                                                      CreateCopyFunctionInfo &info) = 0;
-	//! Create a pragma function within the given schema
-	virtual optional_ptr<CatalogEntry> CreatePragmaFunction(CatalogTransaction transaction,
-	                                                        CreatePragmaFunctionInfo &info) = 0;
-	//! Create a collation within the given schema
-	virtual optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) = 0;
-	//! Create a enum within the given schema
-	virtual optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info) = 0;
-
-	DUCKDB_API virtual optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, CatalogType type,
-	                                                       const string &name) = 0;
-	DUCKDB_API virtual CatalogSet::EntryLookup GetEntryDetailed(CatalogTransaction transaction, CatalogType type,
-	                                                            const string &name);
-	DUCKDB_API virtual SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
-	                                                       const string &name);
-
-	//! Drops an entry from the schema
-	virtual void DropEntry(ClientContext &context, DropInfo &info) = 0;
-
-	//! Alters a catalog entry
-	virtual void Alter(CatalogTransaction transaction, AlterInfo &info) = 0;
-
-	CatalogTransaction GetCatalogTransaction(ClientContext &context);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp
deleted file mode 100644
index ed12b77a1..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-
-namespace duckdb {
-class DuckTransaction;
-class SequenceCatalogEntry;
-
-struct SequenceValue {
-	SequenceCatalogEntry *entry;
-	uint64_t usage_count;
-	int64_t counter;
-};
-
-struct SequenceData {
-	explicit SequenceData(CreateSequenceInfo &info);
-
-	//! The amount of times the sequence has been used
-	uint64_t usage_count;
-	//! The sequence counter
-	int64_t counter;
-	//! The most recently returned value
-	int64_t last_value;
-	//! The increment value
-	int64_t increment;
-	//! The minimum value of the sequence
-	int64_t start_value;
-	//! The minimum value of the sequence
-	int64_t min_value;
-	//! The maximum value of the sequence
-	int64_t max_value;
-	//! Whether or not the sequence cycles
-	bool cycle;
-};
-
-//! A sequence catalog entry
-class SequenceCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::SEQUENCE_ENTRY;
-	static constexpr const char *Name = "sequence";
-
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info);
-
-public:
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-	unique_ptr<CreateInfo> GetInfo() const override;
-
-	SequenceData GetData() const;
-	int64_t CurrentValue();
-	int64_t NextValue(DuckTransaction &transaction);
-	void ReplayValue(uint64_t usage_count, int64_t counter);
-
-	string ToSQL() const override;
-
-private:
-	//! Lock for getting a value on the sequence
-	mutable mutex lock;
-	//! Sequence data
-	SequenceData data;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp
deleted file mode 100644
index 398e49974..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/catalog/catalog_entry/column_dependency_manager.hpp"
-
-namespace duckdb {
-
-class DataTable;
-
-struct RenameColumnInfo;
-struct AddColumnInfo;
-struct RemoveColumnInfo;
-struct SetDefaultInfo;
-struct ChangeColumnTypeInfo;
-struct AlterForeignKeyInfo;
-struct SetNotNullInfo;
-struct DropNotNullInfo;
-struct SetColumnCommentInfo;
-struct CreateTableInfo;
-struct BoundCreateTableInfo;
-
-class TableFunction;
-struct FunctionData;
-
-class Binder;
-struct ColumnSegmentInfo;
-class TableStorageInfo;
-
-class LogicalGet;
-class LogicalProjection;
-class LogicalUpdate;
-
-//! A table catalog entry
-class TableCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::TABLE_ENTRY;
-	static constexpr const char *Name = "table";
-
-public:
-	//! Create a TableCatalogEntry and initialize storage for it
-	DUCKDB_API TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info);
-
-public:
-	DUCKDB_API unique_ptr<CreateInfo> GetInfo() const override;
-
-	DUCKDB_API bool HasGeneratedColumns() const;
-
-	//! Returns whether or not a column with the given name exists
-	DUCKDB_API bool ColumnExists(const string &name) const;
-	//! Returns a reference to the column of the specified name. Throws an
-	//! exception if the column does not exist.
-	DUCKDB_API const ColumnDefinition &GetColumn(const string &name) const;
-	//! Returns a reference to the column of the specified logical index. Throws an
-	//! exception if the column does not exist.
-	DUCKDB_API const ColumnDefinition &GetColumn(LogicalIndex idx) const;
-	//! Returns a list of types of the table, excluding generated columns
-	DUCKDB_API vector<LogicalType> GetTypes() const;
-	//! Returns a list of the columns of the table
-	DUCKDB_API const ColumnList &GetColumns() const;
-	//! Returns the underlying storage of the table
-	virtual DataTable &GetStorage();
-
-	//! Returns a list of the constraints of the table
-	DUCKDB_API const vector<unique_ptr<Constraint>> &GetConstraints() const;
-	DUCKDB_API string ToSQL() const override;
-
-	//! Get statistics of a column (physical or virtual) within the table
-	virtual unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) = 0;
-
-	virtual unique_ptr<BlockingSample> GetSample();
-
-	//! Returns the column index of the specified column name.
-	//! If the column does not exist:
-	//! If if_column_exists is true, returns DConstants::INVALID_INDEX
-	//! If if_column_exists is false, throws an exception
-	DUCKDB_API LogicalIndex GetColumnIndex(string &name, bool if_exists = false) const;
-
-	//! Returns the scan function that can be used to scan the given table
-	virtual TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) = 0;
-
-	virtual bool IsDuckTable() const {
-		return false;
-	}
-
-	DUCKDB_API static string ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints);
-
-	//! Returns the expression string list of the column names e.g. (col1, col2, col3)
-	static string ColumnNamesToSQL(const ColumnList &columns);
-
-	//! Returns a list of segment information for this table, if exists
-	virtual vector<ColumnSegmentInfo> GetColumnSegmentInfo();
-
-	//! Returns the storage info of this table
-	virtual TableStorageInfo GetStorageInfo(ClientContext &context) = 0;
-
-	virtual void BindUpdateConstraints(Binder &binder, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-	                                   ClientContext &context);
-
-	//! Returns a pointer to the table's primary key, if exists, else nullptr.
-	optional_ptr<Constraint> GetPrimaryKey() const;
-	//! Returns true, if the table has a primary key, else false.
-	bool HasPrimaryKey() const;
-
-	//! Returns the rowid type of this table
-	virtual LogicalType GetRowIdType() const {
-		return LogicalType::ROW_TYPE;
-	}
-
-protected:
-	//! A list of columns that are part of this table
-	ColumnList columns;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<Constraint>> constraints;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_column_type.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_column_type.hpp
deleted file mode 100644
index 4f21cde67..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_column_type.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_column_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class TableColumnType : uint8_t { STANDARD = 0, GENERATED = 1 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp
deleted file mode 100644
index a2e275700..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/function_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-
-namespace duckdb {
-
-//! A table function in the catalog
-class TableFunctionCatalogEntry : public FunctionEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::TABLE_FUNCTION_ENTRY;
-	static constexpr const char *Name = "table function";
-
-public:
-	TableFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableFunctionInfo &info);
-
-	//! The table function
-	TableFunctionSet functions;
-
-public:
-	unique_ptr<CatalogEntry> AlterEntry(CatalogTransaction transaction, AlterInfo &info) override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp
deleted file mode 100644
index bbea06a7c..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/catalog/catalog_entry/macro_catalog_entry.hpp"
-
-namespace duckdb {
-
-//! A macro function in the catalog
-class TableMacroCatalogEntry : public MacroCatalogEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::TABLE_MACRO_ENTRY;
-	static constexpr const char *Name = "table macro function";
-
-public:
-	TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp
deleted file mode 100644
index 3b479541b..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/type_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-
-namespace duckdb {
-
-//! A type catalog entry
-class TypeCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::TYPE_ENTRY;
-	static constexpr const char *Name = "type";
-
-public:
-	//! Create a TypeCatalogEntry and initialize storage for it
-	TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info);
-
-	LogicalType user_type;
-
-	bind_logical_type_function_t bind_function;
-
-public:
-	unique_ptr<CreateInfo> GetInfo() const override;
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-
-	string ToSQL() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp
deleted file mode 100644
index d435fcec2..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/view_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class DataTable;
-struct CreateViewInfo;
-
-//! A view catalog entry
-class ViewCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::VIEW_ENTRY;
-	static constexpr const char *Name = "view";
-
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info);
-
-	//! The query of the view
-	unique_ptr<SelectStatement> query;
-	//! The SQL query (if any)
-	string sql;
-	//! The set of aliases associated with the view
-	vector<string> aliases;
-	//! The returned types of the view
-	vector<LogicalType> types;
-	//! The returned names of the view
-	vector<string> names;
-	//! The comments on the columns of the view: can be empty if there are no comments
-	vector<Value> column_comments;
-
-public:
-	unique_ptr<CreateInfo> GetInfo() const override;
-
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
-
-	string ToSQL() const override;
-
-private:
-	void Initialize(CreateViewInfo &info);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry_map.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry_map.hpp
deleted file mode 100644
index 7557b3b7d..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry_map.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-
-struct CatalogEntryHashFunction {
-	uint64_t operator()(const reference<CatalogEntry> &a) const {
-		std::hash<void *> hash_func;
-		return hash_func((void *)&a.get());
-	}
-};
-
-struct CatalogEntryEquality {
-	bool operator()(const reference<CatalogEntry> &a, const reference<CatalogEntry> &b) const {
-		return RefersToSameObject(a, b);
-	}
-};
-
-using catalog_entry_set_t = unordered_set<reference<CatalogEntry>, CatalogEntryHashFunction, CatalogEntryEquality>;
-
-template <typename T>
-using catalog_entry_map_t = unordered_map<reference<CatalogEntry>, T, CatalogEntryHashFunction, CatalogEntryEquality>;
-
-using catalog_entry_vector_t = vector<reference<CatalogEntry>>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry_retriever.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry_retriever.hpp
deleted file mode 100644
index 4e771cdc5..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_entry_retriever.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry_retriever.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <functional>
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class Catalog;
-class CatalogEntry;
-
-using catalog_entry_callback_t = std::function<void(CatalogEntry &)>;
-
-// Wraps the Catalog::GetEntry method
-class CatalogEntryRetriever {
-public:
-	explicit CatalogEntryRetriever(ClientContext &context) : context(context) {
-	}
-	CatalogEntryRetriever(const CatalogEntryRetriever &other) : callback(other.callback), context(other.context) {
-	}
-
-public:
-	void Inherit(const CatalogEntryRetriever &parent);
-	ClientContext &GetContext() {
-		return context;
-	}
-
-	optional_ptr<CatalogEntry> GetEntry(CatalogType type, const string &catalog, const string &schema,
-	                                    const string &name,
-	                                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
-	                                    QueryErrorContext error_context = QueryErrorContext());
-
-	optional_ptr<CatalogEntry> GetEntry(CatalogType type, Catalog &catalog, const string &schema, const string &name,
-	                                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
-	                                    QueryErrorContext error_context = QueryErrorContext());
-
-	LogicalType GetType(const string &catalog, const string &schema, const string &name,
-	                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::RETURN_NULL);
-	LogicalType GetType(Catalog &catalog, const string &schema, const string &name,
-	                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::RETURN_NULL);
-
-	optional_ptr<SchemaCatalogEntry> GetSchema(const string &catalog, const string &name,
-	                                           OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
-	                                           QueryErrorContext error_context = QueryErrorContext());
-
-	CatalogSearchPath &GetSearchPath();
-	void SetSearchPath(vector<CatalogSearchEntry> entries);
-
-	void SetCallback(catalog_entry_callback_t callback);
-	catalog_entry_callback_t GetCallback();
-
-private:
-	optional_ptr<CatalogEntry> ReturnAndCallback(optional_ptr<CatalogEntry> result);
-
-private:
-	//! (optional) callback, called on every successful entry retrieval
-	catalog_entry_callback_t callback = nullptr;
-	ClientContext &context;
-	shared_ptr<CatalogSearchPath> search_path;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp
deleted file mode 100644
index ff0def0fc..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_search_path.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <functional>
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-
-struct CatalogSearchEntry {
-	CatalogSearchEntry(string catalog, string schema);
-
-	string catalog;
-	string schema;
-
-public:
-	string ToString() const;
-	static string ListToString(const vector<CatalogSearchEntry> &input);
-	static CatalogSearchEntry Parse(const string &input);
-	static vector<CatalogSearchEntry> ParseList(const string &input);
-
-private:
-	static CatalogSearchEntry ParseInternal(const string &input, idx_t &pos);
-	static string WriteOptionallyQuoted(const string &input);
-};
-
-enum class CatalogSetPathType { SET_SCHEMA, SET_SCHEMAS };
-
-//! The schema search path, in order by which entries are searched if no schema entry is provided
-class CatalogSearchPath {
-public:
-	DUCKDB_API explicit CatalogSearchPath(ClientContext &client_p);
-	DUCKDB_API CatalogSearchPath(ClientContext &client_p, vector<CatalogSearchEntry> entries);
-	CatalogSearchPath(const CatalogSearchPath &other) = delete;
-
-	DUCKDB_API void Set(CatalogSearchEntry new_value, CatalogSetPathType set_type);
-	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type);
-	DUCKDB_API void Reset();
-
-	DUCKDB_API const vector<CatalogSearchEntry> &Get();
-	const vector<CatalogSearchEntry> &GetSetPaths() {
-		return set_paths;
-	}
-	DUCKDB_API const CatalogSearchEntry &GetDefault();
-	DUCKDB_API string GetDefaultSchema(const string &catalog);
-	DUCKDB_API string GetDefaultCatalog(const string &schema);
-
-	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog);
-	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema);
-
-	DUCKDB_API bool SchemaInSearchPath(ClientContext &context, const string &catalog_name, const string &schema_name);
-
-private:
-	//! Set paths without checking if they exist
-	void SetPathsInternal(vector<CatalogSearchEntry> new_paths);
-	string GetSetName(CatalogSetPathType set_type);
-
-private:
-	ClientContext &context;
-	vector<CatalogSearchEntry> paths;
-	//! Only the paths that were explicitly set (minus the always included paths)
-	vector<CatalogSearchEntry> set_paths;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp
deleted file mode 100644
index 27364e773..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/default/default_generator.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/catalog/catalog_transaction.hpp"
-#include "duckdb/catalog/similar_catalog_entry.hpp"
-#include <functional>
-#include <memory>
-
-namespace duckdb {
-struct AlterInfo;
-
-class ClientContext;
-class LogicalDependencyList;
-
-class DuckCatalog;
-class TableCatalogEntry;
-class SequenceCatalogEntry;
-
-class CatalogEntryMap {
-public:
-	CatalogEntryMap() {
-	}
-
-public:
-	void AddEntry(unique_ptr<CatalogEntry> entry);
-	void UpdateEntry(unique_ptr<CatalogEntry> entry);
-	void DropEntry(CatalogEntry &entry);
-	case_insensitive_tree_t<unique_ptr<CatalogEntry>> &Entries();
-	optional_ptr<CatalogEntry> GetEntry(const string &name);
-
-private:
-	//! Mapping of string to catalog entry
-	case_insensitive_tree_t<unique_ptr<CatalogEntry>> entries;
-};
-
-//! The Catalog Set stores (key, value) map of a set of CatalogEntries
-class CatalogSet {
-public:
-	struct EntryLookup {
-		enum class FailureReason { SUCCESS, DELETED, NOT_PRESENT, INVISIBLE };
-		optional_ptr<CatalogEntry> result;
-		FailureReason reason;
-	};
-
-public:
-	DUCKDB_API explicit CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults = nullptr);
-	~CatalogSet();
-
-	//! Create an entry in the catalog set. Returns whether or not it was
-	//! successful.
-	DUCKDB_API bool CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-	                            const LogicalDependencyList &dependencies);
-	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-	                            const LogicalDependencyList &dependencies);
-
-	DUCKDB_API bool AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info);
-
-	DUCKDB_API bool DropEntry(CatalogTransaction transaction, const string &name, bool cascade,
-	                          bool allow_drop_internal = false);
-	DUCKDB_API bool DropEntry(ClientContext &context, const string &name, bool cascade,
-	                          bool allow_drop_internal = false);
-	//! Verify that the entry referenced by the dependency is still alive
-	DUCKDB_API void VerifyExistenceOfDependency(transaction_t commit_id, CatalogEntry &entry);
-	//! Verify we can still drop the entry while committing
-	DUCKDB_API void CommitDrop(transaction_t commit_id, transaction_t start_time, CatalogEntry &entry);
-
-	DUCKDB_API DuckCatalog &GetCatalog();
-
-	bool AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo &info);
-
-	void CleanupEntry(CatalogEntry &catalog_entry);
-
-	//! Returns the entry with the specified name
-	DUCKDB_API EntryLookup GetEntryDetailed(CatalogTransaction transaction, const string &name);
-	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, const string &name);
-	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(ClientContext &context, const string &name);
-
-	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
-	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
-	SimilarCatalogEntry SimilarEntry(CatalogTransaction transaction, const string &name);
-
-	//! Rollback <entry> to be the currently valid entry for a certain catalog
-	//! entry
-	void Undo(CatalogEntry &entry);
-
-	//! Scan the catalog set, invoking the callback method for every committed entry
-	DUCKDB_API void Scan(const std::function<void(CatalogEntry &)> &callback);
-	//! Scan the catalog set, invoking the callback method for every entry
-	DUCKDB_API void ScanWithPrefix(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback,
-	                               const string &prefix);
-	DUCKDB_API void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback);
-	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry &)> &callback);
-
-	template <class T>
-	vector<reference<T>> GetEntries(CatalogTransaction transaction) {
-		vector<reference<T>> result;
-		Scan(transaction, [&](CatalogEntry &entry) { result.push_back(entry.Cast<T>()); });
-		return result;
-	}
-
-	DUCKDB_API bool CreatedByOtherActiveTransaction(CatalogTransaction transaction, transaction_t timestamp);
-	DUCKDB_API bool CommittedAfterStarting(CatalogTransaction transaction, transaction_t timestamp);
-	DUCKDB_API bool HasConflict(CatalogTransaction transaction, transaction_t timestamp);
-	DUCKDB_API bool UseTimestamp(CatalogTransaction transaction, transaction_t timestamp);
-	static bool IsCommitted(transaction_t timestamp);
-
-	static void UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp);
-
-	mutex &GetCatalogLock() {
-		return catalog_lock;
-	}
-
-	void Verify(Catalog &catalog);
-
-private:
-	bool DropDependencies(CatalogTransaction transaction, const string &name, bool cascade,
-	                      bool allow_drop_internal = false);
-	//! Given a root entry, gets the entry valid for this transaction, 'visible' is used to indicate whether the entry
-	//! is actually visible to the transaction
-	CatalogEntry &GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current, bool &visible);
-	//! Given a root entry, gets the entry valid for this transaction
-	CatalogEntry &GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current);
-	CatalogEntry &GetCommittedEntry(CatalogEntry &current);
-	optional_ptr<CatalogEntry> GetEntryInternal(CatalogTransaction transaction, const string &name);
-	optional_ptr<CatalogEntry> CreateCommittedEntry(unique_ptr<CatalogEntry> entry);
-
-	//! Create all default entries
-	void CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &lock);
-	//! Attempt to create a default entry with the specified name. Returns the entry if successful, nullptr otherwise.
-	optional_ptr<CatalogEntry> CreateDefaultEntry(CatalogTransaction transaction, const string &name,
-	                                              unique_lock<mutex> &lock);
-
-	bool DropEntryInternal(CatalogTransaction transaction, const string &name, bool allow_drop_internal = false);
-
-	bool CreateEntryInternal(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-	                         unique_lock<mutex> &read_lock, bool should_be_empty = true);
-	void CheckCatalogEntryInvariants(CatalogEntry &value, const string &name);
-	//! Verify that the previous entry in the chain is dropped.
-	bool VerifyVacancy(CatalogTransaction transaction, CatalogEntry &entry);
-	//! Start the catalog entry chain with a dummy node
-	bool StartChain(CatalogTransaction transaction, const string &name, unique_lock<mutex> &read_lock);
-	bool RenameEntryInternal(CatalogTransaction transaction, CatalogEntry &old, const string &new_name,
-	                         AlterInfo &alter_info, unique_lock<mutex> &read_lock);
-
-private:
-	DuckCatalog &catalog;
-	//! The catalog lock is used to make changes to the data
-	mutex catalog_lock;
-	CatalogEntryMap map;
-	//! The generator used to generate default internal entries
-	unique_ptr<DefaultGenerator> defaults;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_transaction.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_transaction.hpp
deleted file mode 100644
index ce8024a83..000000000
--- a/src/duckdb/src/include/duckdb/catalog/catalog_transaction.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-class Catalog;
-class ClientContext;
-class DatabaseInstance;
-class Transaction;
-
-struct CatalogTransaction {
-	CatalogTransaction(Catalog &catalog, ClientContext &context);
-	CatalogTransaction(DatabaseInstance &db, transaction_t transaction_id_p, transaction_t start_time_p);
-
-	optional_ptr<DatabaseInstance> db;
-	optional_ptr<ClientContext> context;
-	optional_ptr<Transaction> transaction;
-	transaction_t transaction_id;
-	transaction_t start_time;
-
-	bool HasContext() const {
-		return context;
-	}
-	ClientContext &GetContext();
-
-	static CatalogTransaction GetSystemCatalogTransaction(ClientContext &context);
-	static CatalogTransaction GetSystemTransaction(DatabaseInstance &db);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp b/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp
deleted file mode 100644
index 8f4b5c956..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/builtin_types/types.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_builtin_types.py
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/array.hpp"
-
-namespace duckdb {
-
-struct DefaultType {
-	const char *name;
-	LogicalTypeId type;
-};
-
-using builtin_type_array = std::array<DefaultType, 73>;
-
-static constexpr const builtin_type_array BUILTIN_TYPES{{
-	{"decimal", LogicalTypeId::DECIMAL},
-	{"dec", LogicalTypeId::DECIMAL},
-	{"numeric", LogicalTypeId::DECIMAL},
-	{"time", LogicalTypeId::TIME},
-	{"date", LogicalTypeId::DATE},
-	{"timestamp", LogicalTypeId::TIMESTAMP},
-	{"datetime", LogicalTypeId::TIMESTAMP},
-	{"timestamp_us", LogicalTypeId::TIMESTAMP},
-	{"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
-	{"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
-	{"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
-	{"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
-	{"timetz", LogicalTypeId::TIME_TZ},
-	{"interval", LogicalTypeId::INTERVAL},
-	{"varchar", LogicalTypeId::VARCHAR},
-	{"bpchar", LogicalTypeId::VARCHAR},
-	{"string", LogicalTypeId::VARCHAR},
-	{"char", LogicalTypeId::VARCHAR},
-	{"nvarchar", LogicalTypeId::VARCHAR},
-	{"text", LogicalTypeId::VARCHAR},
-	{"blob", LogicalTypeId::BLOB},
-	{"bytea", LogicalTypeId::BLOB},
-	{"varbinary", LogicalTypeId::BLOB},
-	{"binary", LogicalTypeId::BLOB},
-	{"hugeint", LogicalTypeId::HUGEINT},
-	{"int128", LogicalTypeId::HUGEINT},
-	{"uhugeint", LogicalTypeId::UHUGEINT},
-	{"uint128", LogicalTypeId::UHUGEINT},
-	{"bigint", LogicalTypeId::BIGINT},
-	{"oid", LogicalTypeId::BIGINT},
-	{"long", LogicalTypeId::BIGINT},
-	{"int8", LogicalTypeId::BIGINT},
-	{"int64", LogicalTypeId::BIGINT},
-	{"ubigint", LogicalTypeId::UBIGINT},
-	{"uint64", LogicalTypeId::UBIGINT},
-	{"integer", LogicalTypeId::INTEGER},
-	{"int", LogicalTypeId::INTEGER},
-	{"int4", LogicalTypeId::INTEGER},
-	{"signed", LogicalTypeId::INTEGER},
-	{"integral", LogicalTypeId::INTEGER},
-	{"int32", LogicalTypeId::INTEGER},
-	{"uinteger", LogicalTypeId::UINTEGER},
-	{"uint32", LogicalTypeId::UINTEGER},
-	{"smallint", LogicalTypeId::SMALLINT},
-	{"int2", LogicalTypeId::SMALLINT},
-	{"short", LogicalTypeId::SMALLINT},
-	{"int16", LogicalTypeId::SMALLINT},
-	{"usmallint", LogicalTypeId::USMALLINT},
-	{"uint16", LogicalTypeId::USMALLINT},
-	{"tinyint", LogicalTypeId::TINYINT},
-	{"int1", LogicalTypeId::TINYINT},
-	{"utinyint", LogicalTypeId::UTINYINT},
-	{"uint8", LogicalTypeId::UTINYINT},
-	{"struct", LogicalTypeId::STRUCT},
-	{"row", LogicalTypeId::STRUCT},
-	{"list", LogicalTypeId::LIST},
-	{"map", LogicalTypeId::MAP},
-	{"union", LogicalTypeId::UNION},
-	{"bit", LogicalTypeId::BIT},
-	{"bitstring", LogicalTypeId::BIT},
-	{"varint", LogicalTypeId::VARINT},
-	{"boolean", LogicalTypeId::BOOLEAN},
-	{"bool", LogicalTypeId::BOOLEAN},
-	{"logical", LogicalTypeId::BOOLEAN},
-	{"uuid", LogicalTypeId::UUID},
-	{"guid", LogicalTypeId::UUID},
-	{"enum", LogicalTypeId::ENUM},
-	{"null", LogicalTypeId::SQLNULL},
-	{"float", LogicalTypeId::FLOAT},
-	{"real", LogicalTypeId::FLOAT},
-	{"float4", LogicalTypeId::FLOAT},
-	{"double", LogicalTypeId::DOUBLE},
-	{"float8", LogicalTypeId::DOUBLE}
-}};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_functions.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_functions.hpp
deleted file mode 100644
index 79c125c09..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/default_functions.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/default/default_generator.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/common/array_ptr.hpp"
-#include "duckdb/catalog/default/default_table_functions.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-struct DefaultMacro {
-	const char *schema;
-	const char *name;
-	const char *parameters[8];
-	DefaultNamedParameter named_parameters[8];
-	const char *macro;
-};
-
-class DefaultFunctionGenerator : public DefaultGenerator {
-public:
-	DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
-
-	SchemaCatalogEntry &schema;
-
-	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(const DefaultMacro &default_macro);
-	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(array_ptr<const DefaultMacro> macro);
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp
deleted file mode 100644
index 02480084a..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_generator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/common/atomic.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-class DefaultGenerator {
-public:
-	explicit DefaultGenerator(Catalog &catalog);
-	virtual ~DefaultGenerator();
-
-	Catalog &catalog;
-	atomic<bool> created_all_entries;
-
-public:
-	//! Creates a default entry with the specified name, or returns nullptr if no such entry can be generated
-	virtual unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name);
-	virtual unique_ptr<CatalogEntry> CreateDefaultEntry(CatalogTransaction transaction, const string &entry_name);
-	//! Get a list of all default entries in the generator
-	virtual vector<string> GetDefaultEntries() = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_schemas.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_schemas.hpp
deleted file mode 100644
index 5b48165f7..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/default_schemas.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_schemas.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/default/default_generator.hpp"
-
-namespace duckdb {
-
-class DefaultSchemaGenerator : public DefaultGenerator {
-public:
-	explicit DefaultSchemaGenerator(Catalog &catalog);
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(CatalogTransaction transaction, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-	static bool IsDefaultSchema(const string &input_schema);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_table_functions.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_table_functions.hpp
deleted file mode 100644
index c0eee2855..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/default_table_functions.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_table_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/default/default_generator.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-struct DefaultNamedParameter {
-	const char *name;
-	const char *default_value;
-};
-
-struct DefaultTableMacro {
-	const char *schema;
-	const char *name;
-	const char *parameters[8];
-	DefaultNamedParameter named_parameters[8];
-	const char *macro;
-};
-
-class DefaultTableFunctionGenerator : public DefaultGenerator {
-public:
-	DefaultTableFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
-
-	SchemaCatalogEntry &schema;
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-
-	static unique_ptr<CreateMacroInfo> CreateTableMacroInfo(const DefaultTableMacro &default_macro);
-
-private:
-	static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(const DefaultTableMacro &default_macro,
-	                                                                unique_ptr<MacroFunction> function);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp
deleted file mode 100644
index 83d90982b..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_types.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/catalog/default/default_generator.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-class DefaultTypeGenerator : public DefaultGenerator {
-public:
-	DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
-
-	SchemaCatalogEntry &schema;
-
-public:
-	DUCKDB_API static LogicalTypeId GetDefaultType(const string &name);
-
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_views.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_views.hpp
deleted file mode 100644
index 6ebd29eb1..000000000
--- a/src/duckdb/src/include/duckdb/catalog/default/default_views.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_views.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/catalog/default/default_generator.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-class DefaultViewGenerator : public DefaultGenerator {
-public:
-	DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
-
-	SchemaCatalogEntry &schema;
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/dependency.hpp b/src/duckdb/src/include/duckdb/catalog/dependency.hpp
deleted file mode 100644
index 4ac3656e7..000000000
--- a/src/duckdb/src/include/duckdb/catalog/dependency.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/dependency.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-
-struct DependencyFlags {
-public:
-	DependencyFlags() : value(0) {
-	}
-	DependencyFlags(const DependencyFlags &other) : value(other.value) {
-	}
-	virtual ~DependencyFlags() = default;
-	DependencyFlags &operator=(const DependencyFlags &other) {
-		value = other.value;
-		return *this;
-	}
-	bool operator==(const DependencyFlags &other) const {
-		return other.value == value;
-	}
-	bool operator!=(const DependencyFlags &other) const {
-		return !(*this == other);
-	}
-
-public:
-	virtual string ToString() const = 0;
-
-protected:
-	template <uint8_t BIT>
-	bool IsSet() const {
-		static const uint8_t FLAG = (1 << BIT);
-		return (value & FLAG) == FLAG;
-	}
-	template <uint8_t BIT>
-	void Set() {
-		static const uint8_t FLAG = (1 << BIT);
-		value |= FLAG;
-	}
-	void Merge(uint8_t other) {
-		value |= other;
-	}
-	uint8_t Value() {
-		return value;
-	}
-
-private:
-	uint8_t value;
-};
-
-struct DependencySubjectFlags : public DependencyFlags {
-private:
-	static constexpr uint8_t OWNERSHIP = 0;
-
-public:
-	DependencySubjectFlags &Apply(DependencySubjectFlags other) {
-		Merge(other.Value());
-		return *this;
-	}
-
-public:
-	bool IsOwnership() const {
-		return IsSet<OWNERSHIP>();
-	}
-
-public:
-	DependencySubjectFlags &SetOwnership() {
-		Set<OWNERSHIP>();
-		return *this;
-	}
-
-public:
-	string ToString() const override {
-		string result;
-		if (IsOwnership()) {
-			result += "OWNS";
-		}
-		return result;
-	}
-};
-
-struct DependencyDependentFlags : public DependencyFlags {
-private:
-	static constexpr uint8_t BLOCKING = 0;
-	static constexpr uint8_t OWNED_BY = 1;
-
-public:
-	DependencyDependentFlags &Apply(DependencyDependentFlags other) {
-		Merge(other.Value());
-		return *this;
-	}
-
-public:
-	bool IsBlocking() const {
-		return IsSet<BLOCKING>();
-	}
-	bool IsOwnedBy() const {
-		return IsSet<OWNED_BY>();
-	}
-
-public:
-	DependencyDependentFlags &SetBlocking() {
-		Set<BLOCKING>();
-		return *this;
-	}
-	DependencyDependentFlags &SetOwnedBy() {
-		Set<OWNED_BY>();
-		return *this;
-	}
-
-public:
-	string ToString() const override {
-		string result;
-		if (IsBlocking()) {
-			result += "REGULAR";
-		} else {
-			result += "AUTOMATIC";
-		}
-		result += " | ";
-		if (IsOwnedBy()) {
-			result += "OWNED BY";
-		}
-		return result;
-	}
-};
-
-struct CatalogEntryInfo {
-public:
-	CatalogType type;
-	string schema;
-	string name;
-
-public:
-	bool operator==(const CatalogEntryInfo &other) const {
-		if (other.type != type) {
-			return false;
-		}
-		if (!StringUtil::CIEquals(other.schema, schema)) {
-			return false;
-		}
-		if (!StringUtil::CIEquals(other.name, name)) {
-			return false;
-		}
-		return true;
-	}
-
-public:
-	void Serialize(Serializer &serializer) const;
-	static CatalogEntryInfo Deserialize(Deserializer &deserializer);
-};
-
-struct Dependency {
-	Dependency(CatalogEntry &entry, // NOLINT: Allow implicit conversion from `CatalogEntry`
-	           DependencyDependentFlags flags = DependencyDependentFlags().SetBlocking())
-	    : entry(entry), flags(std::move(flags)) {
-	}
-
-	//! The catalog entry this depends on
-	reference<CatalogEntry> entry;
-	//! The type of dependency
-	DependencyDependentFlags flags;
-};
-
-struct DependencyHashFunction {
-	uint64_t operator()(const Dependency &a) const {
-		std::hash<void *> hash_func;
-		return hash_func((void *)&a.entry.get());
-	}
-};
-
-struct DependencyEquality {
-	bool operator()(const Dependency &a, const Dependency &b) const {
-		return RefersToSameObject(a.entry, b.entry);
-	}
-};
-using dependency_set_t = unordered_set<Dependency, DependencyHashFunction, DependencyEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/dependency_catalog_set.hpp b/src/duckdb/src/include/duckdb/catalog/dependency_catalog_set.hpp
deleted file mode 100644
index 6c79ecc6f..000000000
--- a/src/duckdb/src/include/duckdb/catalog/dependency_catalog_set.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-
-namespace duckdb {
-
-//! This class mocks the CatalogSet interface, but does not actually store CatalogEntries
-class DependencyCatalogSet {
-public:
-	DependencyCatalogSet(CatalogSet &set, const CatalogEntryInfo &info)
-	    : set(set), info(info), mangled_name(DependencyManager::MangleName(info)) {
-	}
-
-public:
-	bool CreateEntry(CatalogTransaction transaction, const MangledEntryName &name, unique_ptr<CatalogEntry> value);
-	CatalogSet::EntryLookup GetEntryDetailed(CatalogTransaction transaction, const MangledEntryName &name);
-	optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, const MangledEntryName &name);
-	void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback);
-	bool DropEntry(CatalogTransaction transaction, const MangledEntryName &name, bool cascade,
-	               bool allow_drop_internal = false);
-
-private:
-	MangledDependencyName ApplyPrefix(const MangledEntryName &name) const;
-
-public:
-	CatalogSet &set;
-	CatalogEntryInfo info;
-	MangledEntryName mangled_name;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp b/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp
deleted file mode 100644
index 8bbadd218..000000000
--- a/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/dependency_list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry_map.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/catalog/dependency.hpp"
-
-namespace duckdb {
-class Catalog;
-class CatalogEntry;
-struct CreateInfo;
-class SchemaCatalogEntry;
-struct CatalogTransaction;
-class LogicalDependencyList;
-
-//! A minimal representation of a CreateInfo / CatalogEntry
-//! enough to look up the entry inside SchemaCatalogEntry::GetEntry
-struct LogicalDependency {
-public:
-	CatalogEntryInfo entry;
-	string catalog;
-
-public:
-	explicit LogicalDependency(CatalogEntry &entry);
-	LogicalDependency();
-	bool operator==(const LogicalDependency &other) const;
-
-public:
-	void Serialize(Serializer &serializer) const;
-	static LogicalDependency Deserialize(Deserializer &deserializer);
-};
-
-struct LogicalDependencyHashFunction {
-	uint64_t operator()(const LogicalDependency &a) const;
-};
-
-struct LogicalDependencyEquality {
-	bool operator()(const LogicalDependency &a, const LogicalDependency &b) const;
-};
-
-//! The LogicalDependencyList containing LogicalDependency objects, not looked up in the catalog yet
-class LogicalDependencyList {
-	using create_info_set_t =
-	    unordered_set<LogicalDependency, LogicalDependencyHashFunction, LogicalDependencyEquality>;
-
-public:
-	DUCKDB_API void AddDependency(CatalogEntry &entry);
-	DUCKDB_API void AddDependency(const LogicalDependency &entry);
-	DUCKDB_API bool Contains(CatalogEntry &entry);
-
-public:
-	DUCKDB_API void VerifyDependencies(Catalog &catalog, const string &name);
-	void Serialize(Serializer &serializer) const;
-	static LogicalDependencyList Deserialize(Deserializer &deserializer);
-	bool operator==(const LogicalDependencyList &other) const;
-	const create_info_set_t &Set() const;
-
-private:
-	create_info_set_t set;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/dependency_manager.hpp b/src/duckdb/src/include/duckdb/catalog/dependency_manager.hpp
deleted file mode 100644
index 804d2e7cf..000000000
--- a/src/duckdb/src/include/duckdb/catalog/dependency_manager.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/dependency_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/dependency.hpp"
-#include "duckdb/catalog/catalog_entry_map.hpp"
-#include "duckdb/catalog/catalog_transaction.hpp"
-#include "duckdb/common/stack.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include <functional>
-
-namespace duckdb {
-class DuckCatalog;
-class ClientContext;
-class DependencyEntry;
-class LogicalDependencyList;
-
-// The subject of this dependency
-struct DependencySubject {
-	CatalogEntryInfo entry;
-	//! The type of dependency this is (e.g, ownership)
-	DependencySubjectFlags flags;
-};
-
-// The entry that relies on the other entry
-struct DependencyDependent {
-	CatalogEntryInfo entry;
-	//! The type of dependency this is (e.g, blocking, non-blocking, ownership)
-	DependencyDependentFlags flags;
-};
-
-//! Every dependency consists of a subject (the entry being depended on) and a dependent (the entry that has the
-//! dependency)
-struct DependencyInfo {
-public:
-	static DependencyInfo FromSubject(DependencyEntry &dep);
-	static DependencyInfo FromDependent(DependencyEntry &dep);
-
-public:
-	DependencyDependent dependent;
-	DependencySubject subject;
-};
-
-struct MangledEntryName {
-public:
-	explicit MangledEntryName(const CatalogEntryInfo &info);
-	MangledEntryName() = delete;
-
-public:
-	//! Format: Type\0Schema\0Name
-	string name;
-
-public:
-	bool operator==(const MangledEntryName &other) const {
-		return StringUtil::CIEquals(other.name, name);
-	}
-	bool operator!=(const MangledEntryName &other) const {
-		return !(*this == other);
-	}
-};
-
-struct MangledDependencyName {
-public:
-	MangledDependencyName(const MangledEntryName &from, const MangledEntryName &to);
-	MangledDependencyName() = delete;
-
-public:
-	//! Format: MangledEntryName\0MangledEntryName
-	string name;
-};
-
-//! The DependencyManager is in charge of managing dependencies between catalog entries
-class DependencyManager {
-	friend class CatalogSet;
-
-public:
-	explicit DependencyManager(DuckCatalog &catalog);
-
-	//! Scans all dependencies, returning pairs of (object, dependent)
-	void Scan(ClientContext &context,
-	          const std::function<void(CatalogEntry &, CatalogEntry &, const DependencyDependentFlags &)> &callback);
-
-	void AddOwnership(CatalogTransaction transaction, CatalogEntry &owner, CatalogEntry &entry);
-
-	//! Get the order of entries needed by EXPORT, the objects with no dependencies are exported first
-	void ReorderEntries(catalog_entry_vector_t &entries);
-	void ReorderEntries(catalog_entry_vector_t &entries, ClientContext &context);
-
-private:
-	DuckCatalog &catalog;
-	CatalogSet subjects;
-	CatalogSet dependents;
-
-private:
-	bool IsSystemEntry(CatalogEntry &entry) const;
-	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, const LogicalDependency &dependency);
-	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency);
-	string CollectDependents(CatalogTransaction transaction, catalog_entry_set_t &entries, CatalogEntryInfo &info);
-	void CleanupDependencies(CatalogTransaction transaction, CatalogEntry &entry);
-
-public:
-	static string GetSchema(const CatalogEntry &entry);
-	static MangledEntryName MangleName(const CatalogEntryInfo &info);
-	static MangledEntryName MangleName(const CatalogEntry &entry);
-	static CatalogEntryInfo GetLookupProperties(const CatalogEntry &entry);
-
-private:
-	void ReorderEntry(CatalogTransaction transaction, CatalogEntry &entry, catalog_entry_set_t &visited,
-	                  catalog_entry_vector_t &order);
-	void ReorderEntries(catalog_entry_vector_t &entries, CatalogTransaction transaction);
-	void AddObject(CatalogTransaction transaction, CatalogEntry &object, const LogicalDependencyList &dependencies);
-	void VerifyExistence(CatalogTransaction transaction, DependencyEntry &object);
-	void VerifyCommitDrop(CatalogTransaction transaction, transaction_t start_time, CatalogEntry &object);
-	//! Returns the objects that should be dropped alongside the object
-	catalog_entry_set_t CheckDropDependencies(CatalogTransaction transaction, CatalogEntry &object, bool cascade);
-	void DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade);
-	void AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj, AlterInfo &info);
-
-private:
-	void RemoveDependency(CatalogTransaction transaction, const DependencyInfo &info);
-	void CreateDependency(CatalogTransaction transaction, DependencyInfo &info);
-	void CreateDependencies(CatalogTransaction transaction, const CatalogEntry &object,
-	                        const LogicalDependencyList &dependencies);
-	using dependency_entry_func_t = const std::function<unique_ptr<DependencyEntry>(
-	    Catalog &catalog, const DependencyDependent &dependent, const DependencySubject &dependency)>;
-
-	void CreateSubject(CatalogTransaction transaction, const DependencyInfo &info);
-	void CreateDependent(CatalogTransaction transaction, const DependencyInfo &info);
-
-	using dependency_callback_t = const std::function<void(DependencyEntry &)>;
-	void ScanDependents(CatalogTransaction transaction, const CatalogEntryInfo &info, dependency_callback_t &callback);
-	void ScanSubjects(CatalogTransaction transaction, const CatalogEntryInfo &info, dependency_callback_t &callback);
-	void ScanSetInternal(CatalogTransaction transaction, const CatalogEntryInfo &info, bool subjects,
-	                     dependency_callback_t &callback);
-	void PrintSubjects(CatalogTransaction transaction, const CatalogEntryInfo &info);
-	void PrintDependents(CatalogTransaction transaction, const CatalogEntryInfo &info);
-	CatalogSet &Dependents();
-	CatalogSet &Subjects();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp b/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp
deleted file mode 100644
index 54bcb40d6..000000000
--- a/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/duck_catalog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-//! The Catalog object represents the catalog of the database.
-class DuckCatalog : public Catalog {
-public:
-	explicit DuckCatalog(AttachedDatabase &db);
-	~DuckCatalog() override;
-
-public:
-	bool IsDuckCatalog() override;
-	void Initialize(bool load_builtin) override;
-	string GetCatalogType() override {
-		return "duckdb";
-	}
-
-	mutex &GetWriteLock() {
-		return write_lock;
-	}
-
-public:
-	DUCKDB_API optional_ptr<CatalogEntry> CreateSchema(CatalogTransaction transaction, CreateSchemaInfo &info) override;
-	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) override;
-	DUCKDB_API void ScanSchemas(std::function<void(SchemaCatalogEntry &)> callback);
-
-	DUCKDB_API optional_ptr<SchemaCatalogEntry>
-	GetSchema(CatalogTransaction transaction, const string &schema_name, OnEntryNotFound if_not_found,
-	          QueryErrorContext error_context = QueryErrorContext()) override;
-
-	DUCKDB_API unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
-	                                                          unique_ptr<PhysicalOperator> plan) override;
-	DUCKDB_API unique_ptr<PhysicalOperator> PlanInsert(ClientContext &context, LogicalInsert &op,
-	                                                   unique_ptr<PhysicalOperator> plan) override;
-	DUCKDB_API unique_ptr<PhysicalOperator> PlanDelete(ClientContext &context, LogicalDelete &op,
-	                                                   unique_ptr<PhysicalOperator> plan) override;
-	DUCKDB_API unique_ptr<PhysicalOperator> PlanUpdate(ClientContext &context, LogicalUpdate &op,
-	                                                   unique_ptr<PhysicalOperator> plan) override;
-	DUCKDB_API unique_ptr<LogicalOperator> BindCreateIndex(Binder &binder, CreateStatement &stmt,
-	                                                       TableCatalogEntry &table,
-	                                                       unique_ptr<LogicalOperator> plan) override;
-	DUCKDB_API unique_ptr<LogicalOperator> BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry,
-	                                                         unique_ptr<LogicalOperator> plan,
-	                                                         unique_ptr<CreateIndexInfo> create_info,
-	                                                         unique_ptr<AlterTableInfo> alter_info) override;
-
-	CatalogSet &GetSchemaCatalogSet();
-
-	DatabaseSize GetDatabaseSize(ClientContext &context) override;
-	vector<MetadataBlockInfo> GetMetadataInfo(ClientContext &context) override;
-
-	DUCKDB_API bool InMemory() override;
-	DUCKDB_API string GetDBPath() override;
-
-	DUCKDB_API optional_idx GetCatalogVersion(ClientContext &context) override;
-
-	optional_ptr<DependencyManager> GetDependencyManager() override;
-
-private:
-	DUCKDB_API void DropSchema(CatalogTransaction transaction, DropInfo &info);
-	DUCKDB_API void DropSchema(ClientContext &context, DropInfo &info) override;
-	optional_ptr<CatalogEntry> CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo &info);
-	void Verify() override;
-
-private:
-	//! The DependencyManager manages dependencies between different catalog objects
-	unique_ptr<DependencyManager> dependency_manager;
-	//! Write lock for the catalog
-	mutex write_lock;
-	//! The catalog set holding the schemas
-	unique_ptr<CatalogSet> schemas;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/similar_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/similar_catalog_entry.hpp
deleted file mode 100644
index 2031e7980..000000000
--- a/src/duckdb/src/include/duckdb/catalog/similar_catalog_entry.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/similar_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-//! Return value of SimilarEntryInSchemas
-struct SimilarCatalogEntry {
-	//! The entry name. Empty if absent
-	string name;
-	//! The similarity score of the given name (between 0.0 and 1.0, higher is better)
-	double score = 0.0;
-	//! The schema of the entry.
-	optional_ptr<SchemaCatalogEntry> schema;
-
-	bool Found() const {
-		return !name.empty();
-	}
-
-	DUCKDB_API string GetQualifiedName(bool qualify_catalog, bool qualify_schema) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/catalog/standard_entry.hpp b/src/duckdb/src/include/duckdb/catalog/standard_entry.hpp
deleted file mode 100644
index a3fa83d88..000000000
--- a/src/duckdb/src/include/duckdb/catalog/standard_entry.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/standard_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-//! A StandardEntry is a catalog entry that is a member of a schema
-class StandardEntry : public InCatalogEntry {
-public:
-	StandardEntry(CatalogType type, SchemaCatalogEntry &schema, Catalog &catalog, string name)
-	    : InCatalogEntry(type, catalog, std::move(name)), schema(schema) {
-	}
-	~StandardEntry() override {
-	}
-
-	//! The schema the entry belongs to
-	SchemaCatalogEntry &schema;
-	//! The dependencies of the entry, can be empty
-	LogicalDependencyList dependencies;
-
-public:
-	SchemaCatalogEntry &ParentSchema() override {
-		return schema;
-	}
-	const SchemaCatalogEntry &ParentSchema() const override {
-		return schema;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/adbc/adbc-init.hpp b/src/duckdb/src/include/duckdb/common/adbc/adbc-init.hpp
deleted file mode 100644
index 8a5ce110a..000000000
--- a/src/duckdb/src/include/duckdb/common/adbc/adbc-init.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#pragma once
-
-#ifndef DUCKDB_ADBC_INIT
-#define DUCKDB_ADBC_INIT
-
-#include "duckdb.h"
-#include "duckdb/common/adbc/adbc.hpp"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint8_t AdbcStatusCode;
-
-//! We gotta leak the symbols of the init function
-DUCKDB_API AdbcStatusCode duckdb_adbc_init(int version, void *driver, struct AdbcError *error);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/adbc/adbc.h b/src/duckdb/src/include/duckdb/common/adbc/adbc.h
deleted file mode 100644
index a9374cdaf..000000000
--- a/src/duckdb/src/include/duckdb/common/adbc/adbc.h
+++ /dev/null
@@ -1,2230 +0,0 @@
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-// THIS FILE IS GENERATED BY apache/arrow, DO NOT EDIT MANUALLY //
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-/// \file adbc.h ADBC: Arrow Database connectivity
-///
-/// An Arrow-based interface between applications and database
-/// drivers.  ADBC aims to provide a vendor-independent API for SQL
-/// and Substrait-based database access that is targeted at
-/// analytics/OLAP use cases.
-///
-/// This API is intended to be implemented directly by drivers and
-/// used directly by client applications.  To assist portability
-/// between different vendors, a "driver manager" library is also
-/// provided, which implements this same API, but dynamically loads
-/// drivers internally and forwards calls appropriately.
-///
-/// ADBC uses structs with free functions that operate on those
-/// structs to model objects.
-///
-/// In general, objects allow serialized access from multiple threads,
-/// but not concurrent access.  Specific implementations may permit
-/// multiple threads.
-///
-/// \version 1.1.0
-
-#pragma once
-
-#include <stddef.h>
-#include <stdint.h>
-#include "duckdb/common/arrow/arrow.hpp"
-
-/// \defgroup Arrow C Data Interface
-/// Definitions for the C Data Interface/C Stream Interface.
-///
-/// See https://arrow.apache.org/docs/format/CDataInterface.html
-///
-/// @{
-
-//! @cond Doxygen_Suppress
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Extra guard for versions of Arrow without the canonical guard
-#ifndef ARROW_FLAG_DICTIONARY_ORDERED
-
-#ifndef ARROW_C_DATA_INTERFACE
-#define ARROW_C_DATA_INTERFACE
-
-#define ARROW_FLAG_DICTIONARY_ORDERED 1
-#define ARROW_FLAG_NULLABLE           2
-#define ARROW_FLAG_MAP_KEYS_SORTED    4
-
-struct ArrowSchema {
-	// Array type description
-	const char *format;
-	const char *name;
-	const char *metadata;
-	int64_t flags;
-	int64_t n_children;
-	struct ArrowSchema **children;
-	struct ArrowSchema *dictionary;
-
-	// Release callback
-	void (*release)(struct ArrowSchema *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-
-struct ArrowArray {
-	// Array data description
-	int64_t length;
-	int64_t null_count;
-	int64_t offset;
-	int64_t n_buffers;
-	int64_t n_children;
-	const void **buffers;
-	struct ArrowArray **children;
-	struct ArrowArray *dictionary;
-
-	// Release callback
-	void (*release)(struct ArrowArray *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-
-#endif // ARROW_C_DATA_INTERFACE
-
-#ifndef ARROW_C_STREAM_INTERFACE
-#define ARROW_C_STREAM_INTERFACE
-
-struct ArrowArrayStream {
-	// Callback to get the stream type
-	// (will be the same for all arrays in the stream).
-	//
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	//
-	// If successful, the ArrowSchema must be released independently from the stream.
-	int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
-
-	// Callback to get the next array
-	// (if no error and the array is released, the stream has ended)
-	//
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	//
-	// If successful, the ArrowArray must be released independently from the stream.
-	int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
-
-	// Callback to get optional detailed error information.
-	// This must only be called if the last stream operation failed
-	// with a non-0 return code.
-	//
-	// Return value: pointer to a null-terminated character array describing
-	// the last error, or NULL if no description is available.
-	//
-	// The returned pointer is only valid until the next operation on this stream
-	// (including release).
-	const char *(*get_last_error)(struct ArrowArrayStream *);
-
-	// Release callback: release the stream's own resources.
-	// Note that arrays returned by `get_next` must be individually released.
-	void (*release)(struct ArrowArrayStream *);
-
-	// Opaque producer-specific data
-	void *private_data;
-};
-
-#endif // ARROW_C_STREAM_INTERFACE
-#endif // ARROW_FLAG_DICTIONARY_ORDERED
-
-//! @endcond
-
-/// @}
-
-#ifndef ADBC_EXPORTING
-#define ADBC_EXPORTING
-
-// Storage class macros for Windows
-// Allow overriding/aliasing with application-defined macros
-#if !defined(ADBC_EXPORT)
-#if defined(_WIN32)
-#if defined(ADBC_EXPORTING)
-#define ADBC_EXPORT __declspec(dllexport)
-#else
-#define ADBC_EXPORT __declspec(dllimport)
-#endif // defined(ADBC_EXPORTING)
-#else
-#define ADBC_EXPORT
-#endif // defined(_WIN32)
-#endif // !defined(ADBC_EXPORT)
-
-/// \defgroup adbc-error-handling Error Handling
-/// ADBC uses integer error codes to signal errors. To provide more
-/// detail about errors, functions may also return an AdbcError via an
-/// optional out parameter, which can be inspected. If provided, it is
-/// the responsibility of the caller to zero-initialize the AdbcError
-/// value.
-///
-/// @{
-
-/// \brief Error codes for operations that may fail.
-typedef uint8_t AdbcStatusCode;
-
-/// \brief No error.
-#define ADBC_STATUS_OK 0
-/// \brief An unknown error occurred.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_UNKNOWN 1
-/// \brief The operation is not implemented or supported.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_NOT_IMPLEMENTED 2
-/// \brief A requested resource was not found.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_NOT_FOUND 3
-/// \brief A requested resource already exists.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_ALREADY_EXISTS 4
-/// \brief The arguments are invalid, likely a programming error.
-///
-/// For instance, they may be of the wrong format, or out of range.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_INVALID_ARGUMENT 5
-/// \brief The preconditions for the operation are not met, likely a
-///   programming error.
-///
-/// For instance, the object may be uninitialized, or may have not
-/// been fully configured.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_INVALID_STATE 6
-/// \brief Invalid data was processed (not a programming error).
-///
-/// For instance, a division by zero may have occurred during query
-/// execution.
-///
-/// May indicate a database-side error only.
-#define ADBC_STATUS_INVALID_DATA 7
-/// \brief The database's integrity was affected.
-///
-/// For instance, a foreign key check may have failed, or a uniqueness
-/// constraint may have been violated.
-///
-/// May indicate a database-side error only.
-#define ADBC_STATUS_INTEGRITY 8
-/// \brief An error internal to the driver or database occurred.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_INTERNAL 9
-/// \brief An I/O error occurred.
-///
-/// For instance, a remote service may be unavailable.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_IO 10
-/// \brief The operation was cancelled, not due to a timeout.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_CANCELLED 11
-/// \brief The operation was cancelled due to a timeout.
-///
-/// May indicate a driver-side or database-side error.
-#define ADBC_STATUS_TIMEOUT 12
-/// \brief Authentication failed.
-///
-/// May indicate a database-side error only.
-#define ADBC_STATUS_UNAUTHENTICATED 13
-/// \brief The client is not authorized to perform the given operation.
-///
-/// May indicate a database-side error only.
-#define ADBC_STATUS_UNAUTHORIZED 14
-
-/// \brief Inform the driver/driver manager that we are using the extended
-///   AdbcError struct from ADBC 1.1.0.
-///
-/// See the AdbcError documentation for usage.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA INT32_MIN
-
-/// \brief A detailed error message for an operation.
-///
-/// The caller must zero-initialize this struct (clarified in ADBC 1.1.0).
-///
-/// The structure was extended in ADBC 1.1.0.  Drivers and clients using ADBC
-/// 1.0.0 will not have the private_data or private_driver fields.  Drivers
-/// should read/write these fields if and only if vendor_code is equal to
-/// ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA.  Clients are required to initialize
-/// this struct to avoid the possibility of uninitialized values confusing the
-/// driver.
-struct ADBC_EXPORT AdbcError {
-	/// \brief The error message.
-	char *message;
-
-	/// \brief A vendor-specific error code, if applicable.
-	int32_t vendor_code;
-
-	/// \brief A SQLSTATE error code, if provided, as defined by the
-	///   SQL:2003 standard.  If not set, it should be set to
-	///   "\0\0\0\0\0".
-	char sqlstate[5];
-
-	/// \brief Release the contained error.
-	///
-	/// Unlike other structures, this is an embedded callback to make it
-	/// easier for the driver manager and driver to cooperate.
-	void (*release)(struct AdbcError *error);
-
-	/// \brief Opaque implementation-defined state.
-	///
-	/// This field may not be used unless vendor_code is
-	/// ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA.  If present, this field is NULLPTR
-	/// iff the error is unintialized/freed.
-	///
-	/// \since ADBC API revision 1.1.0
-	void *private_data;
-
-	/// \brief The associated driver (used by the driver manager to help
-	///   track state).
-	///
-	/// This field may not be used unless vendor_code is
-	/// ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA.
-	///
-	/// \since ADBC API revision 1.1.0
-	struct AdbcDriver *private_driver;
-};
-
-#ifdef __cplusplus
-/// \brief A helper to initialize the full AdbcError structure.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_ERROR_INIT                                                                                                \
-	(AdbcError {nullptr, ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA, {0, 0, 0, 0, 0}, nullptr, nullptr, nullptr})
-#else
-/// \brief A helper to initialize the full AdbcError structure.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_ERROR_INIT                                                                                                \
-	((struct AdbcError) {NULL, ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA, {0, 0, 0, 0, 0}, NULL, NULL, NULL})
-#endif
-
-/// \brief The size of the AdbcError structure in ADBC 1.0.0.
-///
-/// Drivers written for ADBC 1.1.0 and later should never touch more than this
-/// portion of an AdbcDriver struct when vendor_code is not
-/// ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_ERROR_1_0_0_SIZE (offsetof(struct AdbcError, private_data))
-/// \brief The size of the AdbcError structure in ADBC 1.1.0.
-///
-/// Drivers written for ADBC 1.1.0 and later should never touch more than this
-/// portion of an AdbcDriver struct when vendor_code is
-/// ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_ERROR_1_1_0_SIZE (sizeof(struct AdbcError))
-
-/// \brief Extra key-value metadata for an error.
-///
-/// The fields here are owned by the driver and should not be freed.  The
-/// fields here are invalidated when the release callback in AdbcError is
-/// called.
-///
-/// \since ADBC API revision 1.1.0
-struct ADBC_EXPORT AdbcErrorDetail {
-	/// \brief The metadata key.
-	const char *key;
-	/// \brief The binary metadata value.
-	const uint8_t *value;
-	/// \brief The length of the metadata value.
-	size_t value_length;
-};
-
-/// \brief Get the number of metadata values available in an error.
-///
-/// \since ADBC API revision 1.1.0
-ADBC_EXPORT
-int AdbcErrorGetDetailCount(const struct AdbcError *error);
-
-/// \brief Get a metadata value in an error by index.
-///
-/// If index is invalid, returns an AdbcErrorDetail initialized with NULL/0
-/// fields.
-///
-/// \since ADBC API revision 1.1.0
-ADBC_EXPORT
-struct AdbcErrorDetail AdbcErrorGetDetail(const struct AdbcError *error, int index);
-
-/// \brief Get an ADBC error from an ArrowArrayStream created by a driver.
-///
-/// This allows retrieving error details and other metadata that would
-/// normally be suppressed by the Arrow C Stream Interface.
-///
-/// The caller MUST NOT release the error; it is managed by the release
-/// callback in the stream itself.
-///
-/// \param[in] stream The stream to query.
-/// \param[out] status The ADBC status code, or ADBC_STATUS_OK if there is no
-///   error.  Not written to if the stream does not contain an ADBC error or
-///   if the pointer is NULL.
-/// \return NULL if not supported.
-/// \since ADBC API revision 1.1.0
-ADBC_EXPORT
-const struct AdbcError *AdbcErrorFromArrayStream(struct ArrowArrayStream *stream, AdbcStatusCode *status);
-
-/// @}
-
-/// \defgroup adbc-constants Constants
-/// @{
-
-/// \brief ADBC revision 1.0.0.
-///
-/// When passed to an AdbcDriverInitFunc(), the driver parameter must
-/// point to an AdbcDriver.
-#define ADBC_VERSION_1_0_0 1000000
-
-/// \brief ADBC revision 1.1.0.
-///
-/// When passed to an AdbcDriverInitFunc(), the driver parameter must
-/// point to an AdbcDriver.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_VERSION_1_1_0 1001000
-
-/// \brief Canonical option value for enabling an option.
-///
-/// For use as the value in SetOption calls.
-#define ADBC_OPTION_VALUE_ENABLED "true"
-/// \brief Canonical option value for disabling an option.
-///
-/// For use as the value in SetOption calls.
-#define ADBC_OPTION_VALUE_DISABLED "false"
-
-/// \brief Canonical option name for URIs.
-///
-/// Should be used as the expected option name to specify a URI for
-/// any ADBC driver.
-///
-/// The type is char*.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_OPTION_URI "uri"
-/// \brief Canonical option name for usernames.
-///
-/// Should be used as the expected option name to specify a username
-/// to a driver for authentication.
-///
-/// The type is char*.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_OPTION_USERNAME "username"
-/// \brief Canonical option name for passwords.
-///
-/// Should be used as the expected option name to specify a password
-/// for authentication to a driver.
-///
-/// The type is char*.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_OPTION_PASSWORD "password"
-
-/// \brief The database vendor/product name (e.g. the server name).
-///   (type: utf8).
-///
-/// \see AdbcConnectionGetInfo
-#define ADBC_INFO_VENDOR_NAME 0
-/// \brief The database vendor/product version (type: utf8).
-///
-/// \see AdbcConnectionGetInfo
-#define ADBC_INFO_VENDOR_VERSION 1
-/// \brief The database vendor/product Arrow library version (type:
-///   utf8).
-///
-/// \see AdbcConnectionGetInfo
-#define ADBC_INFO_VENDOR_ARROW_VERSION 2
-
-/// \brief The driver name (type: utf8).
-///
-/// \see AdbcConnectionGetInfo
-#define ADBC_INFO_DRIVER_NAME 100
-/// \brief The driver version (type: utf8).
-///
-/// \see AdbcConnectionGetInfo
-#define ADBC_INFO_DRIVER_VERSION 101
-/// \brief The driver Arrow library version (type: utf8).
-///
-/// \see AdbcConnectionGetInfo
-#define ADBC_INFO_DRIVER_ARROW_VERSION 102
-/// \brief The driver ADBC API version (type: int64).
-///
-/// The value should be one of the ADBC_VERSION constants.
-///
-/// \since ADBC API revision 1.1.0
-/// \see AdbcConnectionGetInfo
-/// \see ADBC_VERSION_1_0_0
-/// \see ADBC_VERSION_1_1_0
-#define ADBC_INFO_DRIVER_ADBC_VERSION 103
-
-/// \brief Return metadata on catalogs, schemas, tables, and columns.
-///
-/// \see AdbcConnectionGetObjects
-#define ADBC_OBJECT_DEPTH_ALL 0
-/// \brief Return metadata on catalogs only.
-///
-/// \see AdbcConnectionGetObjects
-#define ADBC_OBJECT_DEPTH_CATALOGS 1
-/// \brief Return metadata on catalogs and schemas.
-///
-/// \see AdbcConnectionGetObjects
-#define ADBC_OBJECT_DEPTH_DB_SCHEMAS 2
-/// \brief Return metadata on catalogs, schemas, and tables.
-///
-/// \see AdbcConnectionGetObjects
-#define ADBC_OBJECT_DEPTH_TABLES 3
-/// \brief Return metadata on catalogs, schemas, tables, and columns.
-///
-/// \see AdbcConnectionGetObjects
-#define ADBC_OBJECT_DEPTH_COLUMNS ADBC_OBJECT_DEPTH_ALL
-
-/// \defgroup adbc-table-statistics ADBC Statistic Types
-/// Standard statistic names for AdbcConnectionGetStatistics.
-/// @{
-
-/// \brief The dictionary-encoded name of the average byte width statistic.
-#define ADBC_STATISTIC_AVERAGE_BYTE_WIDTH_KEY 0
-/// \brief The average byte width statistic.  The average size in bytes of a
-///   row in the column.  Value type is float64.
-///
-/// For example, this is roughly the average length of a string for a string
-/// column.
-#define ADBC_STATISTIC_AVERAGE_BYTE_WIDTH_NAME "adbc.statistic.byte_width"
-/// \brief The dictionary-encoded name of the distinct value count statistic.
-#define ADBC_STATISTIC_DISTINCT_COUNT_KEY 1
-/// \brief The distinct value count (NDV) statistic.  The number of distinct
-///   values in the column.  Value type is int64 (when not approximate) or
-///   float64 (when approximate).
-#define ADBC_STATISTIC_DISTINCT_COUNT_NAME "adbc.statistic.distinct_count"
-/// \brief The dictionary-encoded name of the max byte width statistic.
-#define ADBC_STATISTIC_MAX_BYTE_WIDTH_KEY 2
-/// \brief The max byte width statistic.  The maximum size in bytes of a row
-///   in the column.  Value type is int64 (when not approximate) or float64
-///   (when approximate).
-///
-/// For example, this is the maximum length of a string for a string column.
-#define ADBC_STATISTIC_MAX_BYTE_WIDTH_NAME "adbc.statistic.byte_width"
-/// \brief The dictionary-encoded name of the max value statistic.
-#define ADBC_STATISTIC_MAX_VALUE_KEY 3
-/// \brief The max value statistic.  Value type is column-dependent.
-#define ADBC_STATISTIC_MAX_VALUE_NAME "adbc.statistic.byte_width"
-/// \brief The dictionary-encoded name of the min value statistic.
-#define ADBC_STATISTIC_MIN_VALUE_KEY 4
-/// \brief The min value statistic.  Value type is column-dependent.
-#define ADBC_STATISTIC_MIN_VALUE_NAME "adbc.statistic.byte_width"
-/// \brief The dictionary-encoded name of the null count statistic.
-#define ADBC_STATISTIC_NULL_COUNT_KEY 5
-/// \brief The null count statistic.  The number of values that are null in
-///   the column.  Value type is int64 (when not approximate) or float64
-///   (when approximate).
-#define ADBC_STATISTIC_NULL_COUNT_NAME "adbc.statistic.null_count"
-/// \brief The dictionary-encoded name of the row count statistic.
-#define ADBC_STATISTIC_ROW_COUNT_KEY 6
-/// \brief The row count statistic.  The number of rows in the column or
-///   table.  Value type is int64 (when not approximate) or float64 (when
-///   approximate).
-#define ADBC_STATISTIC_ROW_COUNT_NAME "adbc.statistic.row_count"
-/// @}
-
-/// \brief The name of the canonical option for whether autocommit is
-///   enabled.
-///
-/// The type is char*.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_CONNECTION_OPTION_AUTOCOMMIT "adbc.connection.autocommit"
-
-/// \brief The name of the canonical option for whether the current
-///   connection should be restricted to being read-only.
-///
-/// The type is char*.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_CONNECTION_OPTION_READ_ONLY "adbc.connection.readonly"
-
-/// \brief The name of the canonical option for the current catalog.
-///
-/// The type is char*.
-///
-/// \see AdbcConnectionGetOption
-/// \see AdbcConnectionSetOption
-/// \since ADBC API revision 1.1.0
-#define ADBC_CONNECTION_OPTION_CURRENT_CATALOG "adbc.connection.catalog"
-
-/// \brief The name of the canonical option for the current schema.
-///
-/// The type is char*.
-///
-/// \see AdbcConnectionGetOption
-/// \see AdbcConnectionSetOption
-/// \since ADBC API revision 1.1.0
-#define ADBC_CONNECTION_OPTION_CURRENT_DB_SCHEMA "adbc.connection.db_schema"
-
-/// \brief The name of the canonical option for making query execution
-///   nonblocking.
-///
-/// When enabled, AdbcStatementExecutePartitions will return
-/// partitions as soon as they are available, instead of returning
-/// them all at the end.  When there are no more to return, it will
-/// return an empty set of partitions.  AdbcStatementExecuteQuery and
-/// AdbcStatementExecuteSchema are not affected.
-///
-/// The default is ADBC_OPTION_VALUE_DISABLED.
-///
-/// The type is char*.
-///
-/// \see AdbcStatementSetOption
-/// \since ADBC API revision 1.1.0
-#define ADBC_STATEMENT_OPTION_INCREMENTAL "adbc.statement.exec.incremental"
-
-/// \brief The name of the option for getting the progress of a query.
-///
-/// The value is not necessarily in any particular range or have any
-/// particular units.  (For example, it might be a percentage, bytes of data,
-/// rows of data, number of workers, etc.)  The max value can be retrieved via
-/// ADBC_STATEMENT_OPTION_MAX_PROGRESS.  This represents the progress of
-/// execution, not of consumption (i.e., it is independent of how much of the
-/// result set has been read by the client via ArrowArrayStream.get_next().)
-///
-/// The type is double.
-///
-/// \see AdbcStatementGetOptionDouble
-/// \since ADBC API revision 1.1.0
-#define ADBC_STATEMENT_OPTION_PROGRESS "adbc.statement.exec.progress"
-
-/// \brief The name of the option for getting the maximum progress of a query.
-///
-/// This is the value of ADBC_STATEMENT_OPTION_PROGRESS for a completed query.
-/// If not supported, or if the value is nonpositive, then the maximum is not
-/// known.  (For instance, the query may be fully streaming and the driver
-/// does not know when the result set will end.)
-///
-/// The type is double.
-///
-/// \see AdbcStatementGetOptionDouble
-/// \since ADBC API revision 1.1.0
-#define ADBC_STATEMENT_OPTION_MAX_PROGRESS "adbc.statement.exec.max_progress"
-
-/// \brief The name of the canonical option for setting the isolation
-///   level of a transaction.
-///
-/// Should only be used in conjunction with autocommit disabled and
-/// AdbcConnectionCommit / AdbcConnectionRollback. If the desired
-/// isolation level is not supported by a driver, it should return an
-/// appropriate error.
-///
-/// The type is char*.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_CONNECTION_OPTION_ISOLATION_LEVEL "adbc.connection.transaction.isolation_level"
-
-/// \brief Use database or driver default isolation level
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_DEFAULT "adbc.connection.transaction.isolation.default"
-
-/// \brief The lowest isolation level. Dirty reads are allowed, so one
-///   transaction may see not-yet-committed changes made by others.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_READ_UNCOMMITTED "adbc.connection.transaction.isolation.read_uncommitted"
-
-/// \brief Lock-based concurrency control keeps write locks until the
-///   end of the transaction, but read locks are released as soon as a
-///   SELECT is performed. Non-repeatable reads can occur in this
-///   isolation level.
-///
-/// More simply put, Read Committed is an isolation level that guarantees
-/// that any data read is committed at the moment it is read. It simply
-/// restricts the reader from seeing any intermediate, uncommitted,
-/// 'dirty' reads. It makes no promise whatsoever that if the transaction
-/// re-issues the read, it will find the same data; data is free to change
-/// after it is read.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_READ_COMMITTED "adbc.connection.transaction.isolation.read_committed"
-
-/// \brief Lock-based concurrency control keeps read AND write locks
-///   (acquired on selection data) until the end of the transaction.
-///
-/// However, range-locks are not managed, so phantom reads can occur.
-/// Write skew is possible at this isolation level in some systems.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_REPEATABLE_READ "adbc.connection.transaction.isolation.repeatable_read"
-
-/// \brief This isolation guarantees that all reads in the transaction
-///   will see a consistent snapshot of the database and the transaction
-///   should only successfully commit if no updates conflict with any
-///   concurrent updates made since that snapshot.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_SNAPSHOT "adbc.connection.transaction.isolation.snapshot"
-
-/// \brief Serializability requires read and write locks to be released
-///   only at the end of the transaction. This includes acquiring range-
-///   locks when a select query uses a ranged WHERE clause to avoid
-///   phantom reads.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_SERIALIZABLE "adbc.connection.transaction.isolation.serializable"
-
-/// \brief The central distinction between serializability and linearizability
-///   is that serializability is a global property; a property of an entire
-///   history of operations and transactions. Linearizability is a local
-///   property; a property of a single operation/transaction.
-///
-/// Linearizability can be viewed as a special case of strict serializability
-/// where transactions are restricted to consist of a single operation applied
-/// to a single object.
-///
-/// \see AdbcConnectionSetOption
-#define ADBC_OPTION_ISOLATION_LEVEL_LINEARIZABLE "adbc.connection.transaction.isolation.linearizable"
-
-/// \defgroup adbc-statement-ingestion Bulk Data Ingestion
-/// While it is possible to insert data via prepared statements, it can
-/// be more efficient to explicitly perform a bulk insert.  For
-/// compatible drivers, this can be accomplished by setting up and
-/// executing a statement.  Instead of setting a SQL query or Substrait
-/// plan, bind the source data via AdbcStatementBind, and set the name
-/// of the table to be created via AdbcStatementSetOption and the
-/// options below.  Then, call AdbcStatementExecute with a NULL for
-/// the out parameter (to indicate you do not expect a result set).
-///
-/// @{
-
-/// \brief The name of the target table for a bulk insert.
-///
-/// The driver should attempt to create the table if it does not
-/// exist.  If the table exists but has a different schema,
-/// ADBC_STATUS_ALREADY_EXISTS should be raised.  Else, data should be
-/// appended to the target table.
-///
-/// The type is char*.
-#define ADBC_INGEST_OPTION_TARGET_TABLE "adbc.ingest.target_table"
-/// \brief Whether to create (the default) or append.
-///
-/// The type is char*.
-#define ADBC_INGEST_OPTION_MODE "adbc.ingest.mode"
-/// \brief Create the table and insert data; error if the table exists.
-#define ADBC_INGEST_OPTION_MODE_CREATE "adbc.ingest.mode.create"
-/// \brief Do not create the table, and insert data; error if the
-///   table does not exist (ADBC_STATUS_NOT_FOUND) or does not match
-///   the schema of the data to append (ADBC_STATUS_ALREADY_EXISTS).
-#define ADBC_INGEST_OPTION_MODE_APPEND "adbc.ingest.mode.append"
-/// \brief Create the table and insert data; drop the original table
-///   if it already exists.
-/// \since ADBC API revision 1.1.0
-#define ADBC_INGEST_OPTION_MODE_REPLACE "adbc.ingest.mode.replace"
-/// \brief Insert data; create the table if it does not exist, or
-///   error if the table exists, but the schema does not match the
-///   schema of the data to append (ADBC_STATUS_ALREADY_EXISTS).
-/// \since ADBC API revision 1.1.0
-#define ADBC_INGEST_OPTION_MODE_CREATE_APPEND "adbc.ingest.mode.create_append"
-
-/// @}
-
-/// @}
-
-/// \defgroup adbc-database Database Initialization
-/// Clients first initialize a database, then create a connection
-/// (below).  This gives the implementation a place to initialize and
-/// own any common connection state.  For example, in-memory databases
-/// can place ownership of the actual database in this object.
-/// @{
-
-/// \brief An instance of a database.
-///
-/// Must be kept alive as long as any connections exist.
-struct ADBC_EXPORT AdbcDatabase {
-	/// \brief Opaque implementation-defined state.
-	/// This field is NULLPTR iff the connection is unintialized/freed.
-	void *private_data;
-	/// \brief The associated driver (used by the driver manager to help
-	///   track state).
-	struct AdbcDriver *private_driver;
-};
-
-/// @}
-
-/// \defgroup adbc-connection Connection Establishment
-/// Functions for creating, using, and releasing database connections.
-/// @{
-
-/// \brief An active database connection.
-///
-/// Provides methods for query execution, managing prepared
-/// statements, using transactions, and so on.
-///
-/// Connections are not required to be thread-safe, but they can be
-/// used from multiple threads so long as clients take care to
-/// serialize accesses to a connection.
-struct ADBC_EXPORT AdbcConnection {
-	/// \brief Opaque implementation-defined state.
-	/// This field is NULLPTR iff the connection is unintialized/freed.
-	void *private_data;
-	/// \brief The associated driver (used by the driver manager to help
-	///   track state).
-	struct AdbcDriver *private_driver;
-};
-
-/// @}
-
-/// \defgroup adbc-statement Managing Statements
-/// Applications should first initialize a statement with
-/// AdbcStatementNew. Then, the statement should be configured with
-/// functions like AdbcStatementSetSqlQuery and
-/// AdbcStatementSetOption. Finally, the statement can be executed
-/// with AdbcStatementExecuteQuery (or call AdbcStatementPrepare first
-/// to turn it into a prepared statement instead).
-/// @{
-
-/// \brief A container for all state needed to execute a database
-/// query, such as the query itself, parameters for prepared
-/// statements, driver parameters, etc.
-///
-/// Statements may represent queries or prepared statements.
-///
-/// Statements may be used multiple times and can be reconfigured
-/// (e.g. they can be reused to execute multiple different queries).
-/// However, executing a statement (and changing certain other state)
-/// will invalidate result sets obtained prior to that execution.
-///
-/// Multiple statements may be created from a single connection.
-/// However, the driver may block or error if they are used
-/// concurrently (whether from a single thread or multiple threads).
-///
-/// Statements are not required to be thread-safe, but they can be
-/// used from multiple threads so long as clients take care to
-/// serialize accesses to a statement.
-struct ADBC_EXPORT AdbcStatement {
-	/// \brief Opaque implementation-defined state.
-	/// This field is NULLPTR iff the connection is unintialized/freed.
-	void *private_data;
-
-	/// \brief The associated driver (used by the driver manager to help
-	///   track state).
-	struct AdbcDriver *private_driver;
-};
-
-/// \defgroup adbc-statement-partition Partitioned Results
-/// Some backends may internally partition the results. These
-/// partitions are exposed to clients who may wish to integrate them
-/// with a threaded or distributed execution model, where partitions
-/// can be divided among threads or machines and fetched in parallel.
-///
-/// To use partitioning, execute the statement with
-/// AdbcStatementExecutePartitions to get the partition descriptors.
-/// Call AdbcConnectionReadPartition to turn the individual
-/// descriptors into ArrowArrayStream instances.  This may be done on
-/// a different connection than the one the partition was created
-/// with, or even in a different process on another machine.
-///
-/// Drivers are not required to support partitioning.
-///
-/// @{
-
-/// \brief The partitions of a distributed/partitioned result set.
-struct AdbcPartitions {
-	/// \brief The number of partitions.
-	size_t num_partitions;
-
-	/// \brief The partitions of the result set, where each entry (up to
-	///   num_partitions entries) is an opaque identifier that can be
-	///   passed to AdbcConnectionReadPartition.
-	const uint8_t **partitions;
-
-	/// \brief The length of each corresponding entry in partitions.
-	const size_t *partition_lengths;
-
-	/// \brief Opaque implementation-defined state.
-	/// This field is NULLPTR iff the connection is unintialized/freed.
-	void *private_data;
-
-	/// \brief Release the contained partitions.
-	///
-	/// Unlike other structures, this is an embedded callback to make it
-	/// easier for the driver manager and driver to cooperate.
-	void (*release)(struct AdbcPartitions *partitions);
-};
-
-/// @}
-
-/// @}
-
-/// \defgroup adbc-driver Driver Initialization
-///
-/// These functions are intended to help support integration between a
-/// driver and the driver manager.
-/// @{
-
-/// \brief An instance of an initialized database driver.
-///
-/// This provides a common interface for vendor-specific driver
-/// initialization routines. Drivers should populate this struct, and
-/// applications can call ADBC functions through this struct, without
-/// worrying about multiple definitions of the same symbol.
-struct ADBC_EXPORT AdbcDriver {
-	/// \brief Opaque driver-defined state.
-	/// This field is NULL if the driver is unintialized/freed (but
-	/// it need not have a value even if the driver is initialized).
-	void *private_data;
-	/// \brief Opaque driver manager-defined state.
-	/// This field is NULL if the driver is unintialized/freed (but
-	/// it need not have a value even if the driver is initialized).
-	void *private_manager;
-
-	/// \brief Release the driver and perform any cleanup.
-	///
-	/// This is an embedded callback to make it easier for the driver
-	/// manager and driver to cooperate.
-	AdbcStatusCode (*release)(struct AdbcDriver *driver, struct AdbcError *error);
-
-	AdbcStatusCode (*DatabaseInit)(struct AdbcDatabase *, struct AdbcError *);
-	AdbcStatusCode (*DatabaseNew)(struct AdbcDatabase *, struct AdbcError *);
-	AdbcStatusCode (*DatabaseSetOption)(struct AdbcDatabase *, const char *, const char *, struct AdbcError *);
-	AdbcStatusCode (*DatabaseRelease)(struct AdbcDatabase *, struct AdbcError *);
-
-	AdbcStatusCode (*ConnectionCommit)(struct AdbcConnection *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetInfo)(struct AdbcConnection *, const uint32_t *, size_t, struct ArrowArrayStream *,
-	                                    struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetObjects)(struct AdbcConnection *, int, const char *, const char *, const char *,
-	                                       const char **, const char *, struct ArrowArrayStream *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetTableSchema)(struct AdbcConnection *, const char *, const char *, const char *,
-	                                           struct ArrowSchema *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetTableTypes)(struct AdbcConnection *, struct ArrowArrayStream *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionInit)(struct AdbcConnection *, struct AdbcDatabase *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionNew)(struct AdbcConnection *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionSetOption)(struct AdbcConnection *, const char *, const char *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionReadPartition)(struct AdbcConnection *, const uint8_t *, size_t,
-	                                          struct ArrowArrayStream *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionRelease)(struct AdbcConnection *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionRollback)(struct AdbcConnection *, struct AdbcError *);
-
-	AdbcStatusCode (*StatementBind)(struct AdbcStatement *, struct ArrowArray *, struct ArrowSchema *,
-	                                struct AdbcError *);
-	AdbcStatusCode (*StatementBindStream)(struct AdbcStatement *, struct ArrowArrayStream *, struct AdbcError *);
-	AdbcStatusCode (*StatementExecuteQuery)(struct AdbcStatement *, struct ArrowArrayStream *, int64_t *,
-	                                        struct AdbcError *);
-	AdbcStatusCode (*StatementExecutePartitions)(struct AdbcStatement *, struct ArrowSchema *, struct AdbcPartitions *,
-	                                             int64_t *, struct AdbcError *);
-	AdbcStatusCode (*StatementGetParameterSchema)(struct AdbcStatement *, struct ArrowSchema *, struct AdbcError *);
-	AdbcStatusCode (*StatementNew)(struct AdbcConnection *, struct AdbcStatement *, struct AdbcError *);
-	AdbcStatusCode (*StatementPrepare)(struct AdbcStatement *, struct AdbcError *);
-	AdbcStatusCode (*StatementRelease)(struct AdbcStatement *, struct AdbcError *);
-	AdbcStatusCode (*StatementSetOption)(struct AdbcStatement *, const char *, const char *, struct AdbcError *);
-	AdbcStatusCode (*StatementSetSqlQuery)(struct AdbcStatement *, const char *, struct AdbcError *);
-	AdbcStatusCode (*StatementSetSubstraitPlan)(struct AdbcStatement *, const uint8_t *, size_t, struct AdbcError *);
-
-	/// \defgroup adbc-1.1.0 ADBC API Revision 1.1.0
-	///
-	/// Functions added in ADBC 1.1.0.  For backwards compatibility,
-	/// these members must not be accessed unless the version passed to
-	/// the AdbcDriverInitFunc is greater than or equal to
-	/// ADBC_VERSION_1_1_0.
-	///
-	/// For a 1.0.0 driver being loaded by a 1.1.0 driver manager: the
-	/// 1.1.0 manager will allocate the new, expanded AdbcDriver struct
-	/// and attempt to have the driver initialize it with
-	/// ADBC_VERSION_1_1_0.  This must return an error, after which the
-	/// driver will try again with ADBC_VERSION_1_0_0.  The driver must
-	/// not access the new fields, which will carry undefined values.
-	///
-	/// For a 1.1.0 driver being loaded by a 1.0.0 driver manager: the
-	/// 1.0.0 manager will allocate the old AdbcDriver struct and
-	/// attempt to have the driver initialize it with
-	/// ADBC_VERSION_1_0_0.  The driver must not access the new fields,
-	/// and should initialize the old fields.
-	///
-	/// @{
-
-	int (*ErrorGetDetailCount)(const struct AdbcError *error);
-	struct AdbcErrorDetail (*ErrorGetDetail)(const struct AdbcError *error, int index);
-	const struct AdbcError *(*ErrorFromArrayStream)(struct ArrowArrayStream *stream, AdbcStatusCode *status);
-
-	AdbcStatusCode (*DatabaseGetOption)(struct AdbcDatabase *, const char *, char *, size_t *, struct AdbcError *);
-	AdbcStatusCode (*DatabaseGetOptionBytes)(struct AdbcDatabase *, const char *, uint8_t *, size_t *,
-	                                         struct AdbcError *);
-	AdbcStatusCode (*DatabaseGetOptionDouble)(struct AdbcDatabase *, const char *, double *, struct AdbcError *);
-	AdbcStatusCode (*DatabaseGetOptionInt)(struct AdbcDatabase *, const char *, int64_t *, struct AdbcError *);
-	AdbcStatusCode (*DatabaseSetOptionBytes)(struct AdbcDatabase *, const char *, const uint8_t *, size_t,
-	                                         struct AdbcError *);
-	AdbcStatusCode (*DatabaseSetOptionDouble)(struct AdbcDatabase *, const char *, double, struct AdbcError *);
-	AdbcStatusCode (*DatabaseSetOptionInt)(struct AdbcDatabase *, const char *, int64_t, struct AdbcError *);
-
-	AdbcStatusCode (*ConnectionCancel)(struct AdbcConnection *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetOption)(struct AdbcConnection *, const char *, char *, size_t *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetOptionBytes)(struct AdbcConnection *, const char *, uint8_t *, size_t *,
-	                                           struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetOptionDouble)(struct AdbcConnection *, const char *, double *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetOptionInt)(struct AdbcConnection *, const char *, int64_t *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetStatistics)(struct AdbcConnection *, const char *, const char *, const char *, char,
-	                                          struct ArrowArrayStream *, struct AdbcError *);
-	AdbcStatusCode (*ConnectionGetStatisticNames)(struct AdbcConnection *, struct ArrowArrayStream *,
-	                                              struct AdbcError *);
-	AdbcStatusCode (*ConnectionSetOptionBytes)(struct AdbcConnection *, const char *, const uint8_t *, size_t,
-	                                           struct AdbcError *);
-	AdbcStatusCode (*ConnectionSetOptionDouble)(struct AdbcConnection *, const char *, double, struct AdbcError *);
-	AdbcStatusCode (*ConnectionSetOptionInt)(struct AdbcConnection *, const char *, int64_t, struct AdbcError *);
-
-	AdbcStatusCode (*StatementCancel)(struct AdbcStatement *, struct AdbcError *);
-	AdbcStatusCode (*StatementExecuteSchema)(struct AdbcStatement *, struct ArrowSchema *, struct AdbcError *);
-	AdbcStatusCode (*StatementGetOption)(struct AdbcStatement *, const char *, char *, size_t *, struct AdbcError *);
-	AdbcStatusCode (*StatementGetOptionBytes)(struct AdbcStatement *, const char *, uint8_t *, size_t *,
-	                                          struct AdbcError *);
-	AdbcStatusCode (*StatementGetOptionDouble)(struct AdbcStatement *, const char *, double *, struct AdbcError *);
-	AdbcStatusCode (*StatementGetOptionInt)(struct AdbcStatement *, const char *, int64_t *, struct AdbcError *);
-	AdbcStatusCode (*StatementSetOptionBytes)(struct AdbcStatement *, const char *, const uint8_t *, size_t,
-	                                          struct AdbcError *);
-	AdbcStatusCode (*StatementSetOptionDouble)(struct AdbcStatement *, const char *, double, struct AdbcError *);
-	AdbcStatusCode (*StatementSetOptionInt)(struct AdbcStatement *, const char *, int64_t, struct AdbcError *);
-
-	/// @}
-};
-
-/// \brief The size of the AdbcDriver structure in ADBC 1.0.0.
-/// Drivers written for ADBC 1.1.0 and later should never touch more
-/// than this portion of an AdbcDriver struct when given
-/// ADBC_VERSION_1_0_0.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_DRIVER_1_0_0_SIZE (offsetof(struct AdbcDriver, ErrorGetDetailCount))
-
-/// \brief The size of the AdbcDriver structure in ADBC 1.1.0.
-/// Drivers written for ADBC 1.1.0 and later should never touch more
-/// than this portion of an AdbcDriver struct when given
-/// ADBC_VERSION_1_1_0.
-///
-/// \since ADBC API revision 1.1.0
-#define ADBC_DRIVER_1_1_0_SIZE (sizeof(struct AdbcDriver))
-
-/// @}
-
-/// \addtogroup adbc-database
-/// @{
-
-/// \brief Allocate a new (but uninitialized) database.
-///
-/// Callers pass in a zero-initialized AdbcDatabase.
-///
-/// Drivers should allocate their internal data structure and set the private_data
-/// field to point to the newly allocated struct. This struct should be released
-/// when AdbcDatabaseRelease is called.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase *database, struct AdbcError *error);
-
-/// \brief Get a string option of the database.
-///
-/// This must always be thread-safe (other operations are not), though
-/// given the semantics here, it is not recommended to call GetOption
-/// concurrently with itself.
-///
-/// length must be provided and must be the size of the buffer pointed
-/// to by value.  If there is sufficient space, the driver will copy
-/// the option value (including the null terminator) to buffer and set
-/// length to the size of the actual value.  If the buffer is too
-/// small, no data will be written and length will be set to the
-/// required length.
-///
-/// In other words:
-///
-/// - If output length <= input length, value will contain a value
-///   with length bytes.
-/// - If output length > input length, nothing has been written to
-///   value.
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[in,out] length The length of value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase *database, const char *key, char *value, size_t *length,
-                                     struct AdbcError *error);
-
-/// \brief Get a bytestring option of the database.
-///
-/// This must always be thread-safe (other operations are not), though
-/// given the semantics here, it is not recommended to call
-/// GetOptionBytes concurrently with itself.
-///
-/// length must be provided and must be the size of the buffer pointed
-/// to by value.  If there is sufficient space, the driver will copy
-/// the option value to buffer and set length to the size of the
-/// actual value.  If the buffer is too small, no data will be written
-/// and length will be set to the required length.
-///
-/// In other words:
-///
-/// - If output length <= input length, value will contain a value
-///   with length bytes.
-/// - If output length > input length, nothing has been written to
-///   value.
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[in,out] length The option value length.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase *database, const char *key, uint8_t *value,
-                                          size_t *length, struct AdbcError *error);
-
-/// \brief Get a double option of the database.
-///
-/// This must always be thread-safe (other operations are not).
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the double
-/// representation of an integer option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase *database, const char *key, double *value,
-                                           struct AdbcError *error);
-
-/// \brief Get an integer option of the database.
-///
-/// This must always be thread-safe (other operations are not).
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the integer
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase *database, const char *key, int64_t *value,
-                                        struct AdbcError *error);
-
-/// \brief Set a char* option.
-///
-/// Options may be set before AdbcDatabaseInit.  Some drivers may
-/// support setting options after initialization as well.
-///
-/// \param[in] database The database.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
-                                     struct AdbcError *error);
-
-/// \brief Set a bytestring option on a database.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[in] length The option value length.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase *database, const char *key, const uint8_t *value,
-                                          size_t length, struct AdbcError *error);
-
-/// \brief Set a double option on a database.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase *database, const char *key, double value,
-                                           struct AdbcError *error);
-
-/// \brief Set an integer option on a database.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] database The database.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase *database, const char *key, int64_t value,
-                                        struct AdbcError *error);
-
-/// \brief Finish setting options and initialize the database.
-///
-/// Some drivers may support setting options after initialization
-/// as well.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase *database, struct AdbcError *error);
-
-/// \brief Destroy this database. No connections may exist.
-/// \param[in] database The database to release.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error);
-
-/// @}
-
-/// \addtogroup adbc-connection
-/// @{
-
-/// \brief Allocate a new (but uninitialized) connection.
-///
-/// Callers pass in a zero-initialized AdbcConnection.
-///
-/// Drivers should allocate their internal data structure and set the private_data
-/// field to point to the newly allocated struct. This struct should be released
-/// when AdbcConnectionRelease is called.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionNew(struct AdbcConnection *connection, struct AdbcError *error);
-
-/// \brief Set a char* option.
-///
-/// Options may be set before AdbcConnectionInit.  Some drivers may
-/// support setting options after initialization as well.
-///
-/// \param[in] connection The database connection.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value,
-                                       struct AdbcError *error);
-
-/// \brief Set a bytestring option on a connection.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The connection.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[in] length The option value length.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection *connection, const char *key, const uint8_t *value,
-                                            size_t length, struct AdbcError *error);
-
-/// \brief Set an integer option.
-///
-/// Options may be set before AdbcConnectionInit.  Some drivers may
-/// support setting options after initialization as well.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection *connection, const char *key, int64_t value,
-                                          struct AdbcError *error);
-
-/// \brief Set a double option.
-///
-/// Options may be set before AdbcConnectionInit.  Some drivers may
-/// support setting options after initialization as well.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection *connection, const char *key, double value,
-                                             struct AdbcError *error);
-
-/// \brief Finish setting options and initialize the connection.
-///
-/// Some drivers may support setting options after initialization
-/// as well.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
-                                  struct AdbcError *error);
-
-/// \brief Destroy this connection.
-///
-/// \param[in] connection The connection to release.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error);
-
-/// \brief Cancel the in-progress operation on a connection.
-///
-/// This can be called during AdbcConnectionGetObjects (or similar),
-/// or while consuming an ArrowArrayStream returned from such.
-/// Calling this function should make the other functions return
-/// ADBC_STATUS_CANCELLED (from ADBC functions) or ECANCELED (from
-/// methods of ArrowArrayStream).  (It is not guaranteed to, for
-/// instance, the result set may be buffered in memory already.)
-///
-/// This must always be thread-safe (other operations are not).  It is
-/// not necessarily signal-safe.
-///
-/// \since ADBC API revision 1.1.0
-///
-/// \param[in] connection The connection to cancel.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-///
-/// \return ADBC_STATUS_INVALID_STATE if there is no operation to cancel.
-/// \return ADBC_STATUS_UNKNOWN if the operation could not be cancelled.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection *connection, struct AdbcError *error);
-
-/// \defgroup adbc-connection-metadata Metadata
-/// Functions for retrieving metadata about the database.
-///
-/// Generally, these functions return an ArrowArrayStream that can be
-/// consumed to get the metadata as Arrow data.  The returned metadata
-/// has an expected schema given in the function docstring. Schema
-/// fields are nullable unless otherwise marked.  While no
-/// AdbcStatement is used in these functions, the result set may count
-/// as an active statement to the driver for the purposes of
-/// concurrency management (e.g. if the driver has a limit on
-/// concurrent active statements and it must execute a SQL query
-/// internally in order to implement the metadata function).
-///
-/// This AdbcConnection must outlive the returned ArrowArrayStream.
-///
-/// Some functions accept "search pattern" arguments, which are
-/// strings that can contain the special character "%" to match zero
-/// or more characters, or "_" to match exactly one character.  (See
-/// the documentation of DatabaseMetaData in JDBC or "Pattern Value
-/// Arguments" in the ODBC documentation.)  Escaping is not currently
-/// supported.
-///
-/// @{
-
-/// \brief Get metadata about the database/driver.
-///
-/// The result is an Arrow dataset with the following schema:
-///
-/// Field Name                  | Field Type
-/// ----------------------------|------------------------
-/// info_name                   | uint32 not null
-/// info_value                  | INFO_SCHEMA
-///
-/// INFO_SCHEMA is a dense union with members:
-///
-/// Field Name (Type Code)      | Field Type
-/// ----------------------------|------------------------
-/// string_value (0)            | utf8
-/// bool_value (1)              | bool
-/// int64_value (2)             | int64
-/// int32_bitmask (3)           | int32
-/// string_list (4)             | list<utf8>
-/// int32_to_int32_list_map (5) | map<int32, list<int32>>
-///
-/// Each metadatum is identified by an integer code.  The recognized
-/// codes are defined as constants.  Codes [0, 10_000) are reserved
-/// for ADBC usage.  Drivers/vendors will ignore requests for
-/// unrecognized codes (the row will be omitted from the result).
-///
-/// Since ADBC 1.1.0: the range [500, 1_000) is reserved for "XDBC"
-/// information, which is the same metadata provided by the same info
-/// code range in the Arrow Flight SQL GetSqlInfo RPC.
-///
-/// \param[in] connection The connection to query.
-/// \param[in] info_codes A list of metadata codes to fetch, or NULL
-///   to fetch all.
-/// \param[in] info_codes_length The length of the info_codes
-///   parameter.  Ignored if info_codes is NULL.
-/// \param[out] out The result set.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes,
-                                     size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error);
-
-/// \brief Get a hierarchical view of all catalogs, database schemas,
-///   tables, and columns.
-///
-/// The result is an Arrow dataset with the following schema:
-///
-/// | Field Name               | Field Type              |
-/// |--------------------------|-------------------------|
-/// | catalog_name             | utf8                    |
-/// | catalog_db_schemas       | list<DB_SCHEMA_SCHEMA>  |
-///
-/// DB_SCHEMA_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type              |
-/// |--------------------------|-------------------------|
-/// | db_schema_name           | utf8                    |
-/// | db_schema_tables         | list<TABLE_SCHEMA>      |
-///
-/// TABLE_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type              |
-/// |--------------------------|-------------------------|
-/// | table_name               | utf8 not null           |
-/// | table_type               | utf8 not null           |
-/// | table_columns            | list<COLUMN_SCHEMA>     |
-/// | table_constraints        | list<CONSTRAINT_SCHEMA> |
-///
-/// COLUMN_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type              | Comments |
-/// |--------------------------|-------------------------|----------|
-/// | column_name              | utf8 not null           |          |
-/// | ordinal_position         | int32                   | (1)      |
-/// | remarks                  | utf8                    | (2)      |
-/// | xdbc_data_type           | int16                   | (3)      |
-/// | xdbc_type_name           | utf8                    | (3)      |
-/// | xdbc_column_size         | int32                   | (3)      |
-/// | xdbc_decimal_digits      | int16                   | (3)      |
-/// | xdbc_num_prec_radix      | int16                   | (3)      |
-/// | xdbc_nullable            | int16                   | (3)      |
-/// | xdbc_column_def          | utf8                    | (3)      |
-/// | xdbc_sql_data_type       | int16                   | (3)      |
-/// | xdbc_datetime_sub        | int16                   | (3)      |
-/// | xdbc_char_octet_length   | int32                   | (3)      |
-/// | xdbc_is_nullable         | utf8                    | (3)      |
-/// | xdbc_scope_catalog       | utf8                    | (3)      |
-/// | xdbc_scope_schema        | utf8                    | (3)      |
-/// | xdbc_scope_table         | utf8                    | (3)      |
-/// | xdbc_is_autoincrement    | bool                    | (3)      |
-/// | xdbc_is_generatedcolumn  | bool                    | (3)      |
-///
-/// 1. The column's ordinal position in the table (starting from 1).
-/// 2. Database-specific description of the column.
-/// 3. Optional value.  Should be null if not supported by the driver.
-///    xdbc_ values are meant to provide JDBC/ODBC-compatible metadata
-///    in an agnostic manner.
-///
-/// CONSTRAINT_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type              | Comments |
-/// |--------------------------|-------------------------|----------|
-/// | constraint_name          | utf8                    |          |
-/// | constraint_type          | utf8 not null           | (1)      |
-/// | constraint_column_names  | list<utf8> not null     | (2)      |
-/// | constraint_column_usage  | list<USAGE_SCHEMA>      | (3)      |
-///
-/// 1. One of 'CHECK', 'FOREIGN KEY', 'PRIMARY KEY', or 'UNIQUE'.
-/// 2. The columns on the current table that are constrained, in
-///    order.
-/// 3. For FOREIGN KEY only, the referenced table and columns.
-///
-/// USAGE_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type              |
-/// |--------------------------|-------------------------|
-/// | fk_catalog               | utf8                    |
-/// | fk_db_schema             | utf8                    |
-/// | fk_table                 | utf8 not null           |
-/// | fk_column_name           | utf8 not null           |
-///
-/// This AdbcConnection must outlive the returned ArrowArrayStream.
-///
-/// \param[in] connection The database connection.
-/// \param[in] depth The level of nesting to display. If 0, display
-///   all levels. If 1, display only catalogs (i.e.  catalog_schemas
-///   will be null). If 2, display only catalogs and schemas
-///   (i.e. db_schema_tables will be null), and so on.
-/// \param[in] catalog Only show tables in the given catalog. If NULL,
-///   do not filter by catalog. If an empty string, only show tables
-///   without a catalog.  May be a search pattern (see section
-///   documentation).
-/// \param[in] db_schema Only show tables in the given database schema. If
-///   NULL, do not filter by database schema. If an empty string, only show
-///   tables without a database schema. May be a search pattern (see section
-///   documentation).
-/// \param[in] table_name Only show tables with the given name. If NULL, do not
-///   filter by name. May be a search pattern (see section documentation).
-/// \param[in] table_type Only show tables matching one of the given table
-///   types. If NULL, show tables of any type. Valid table types can be fetched
-///   from GetTableTypes.  Terminate the list with a NULL entry.
-/// \param[in] column_name Only show columns with the given name. If
-///   NULL, do not filter by name.  May be a search pattern (see
-///   section documentation).
-/// \param[out] out The result set.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
-                                        const char *db_schema, const char *table_name, const char **table_type,
-                                        const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error);
-
-/// \brief Get a string option of the connection.
-///
-/// This must always be thread-safe (other operations are not), though
-/// given the semantics here, it is not recommended to call GetOption
-/// concurrently with itself.
-///
-/// length must be provided and must be the size of the buffer pointed
-/// to by value.  If there is sufficient space, the driver will copy
-/// the option value (including the null terminator) to buffer and set
-/// length to the size of the actual value.  If the buffer is too
-/// small, no data will be written and length will be set to the
-/// required length.
-///
-/// In other words:
-///
-/// - If output length <= input length, value will contain a value
-///   with length bytes.
-/// - If output length > input length, nothing has been written to
-///   value.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[in,out] length The length of value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection *connection, const char *key, char *value, size_t *length,
-                                       struct AdbcError *error);
-
-/// \brief Get a bytestring option of the connection.
-///
-/// This must always be thread-safe (other operations are not), though
-/// given the semantics here, it is not recommended to call
-/// GetOptionBytes concurrently with itself.
-///
-/// length must be provided and must be the size of the buffer pointed
-/// to by value.  If there is sufficient space, the driver will copy
-/// the option value to buffer and set length to the size of the
-/// actual value.  If the buffer is too small, no data will be written
-/// and length will be set to the required length.
-///
-/// In other words:
-///
-/// - If output length <= input length, value will contain a value
-///   with length bytes.
-/// - If output length > input length, nothing has been written to
-///   value.
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The connection.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[in,out] length The option value length.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection *connection, const char *key, uint8_t *value,
-                                            size_t *length, struct AdbcError *error);
-
-/// \brief Get an integer option of the connection.
-///
-/// This must always be thread-safe (other operations are not).
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection *connection, const char *key, int64_t *value,
-                                          struct AdbcError *error);
-
-/// \brief Get a double option of the connection.
-///
-/// This must always be thread-safe (other operations are not).
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection *connection, const char *key, double *value,
-                                             struct AdbcError *error);
-
-/// \brief Get statistics about the data distribution of table(s).
-///
-/// The result is an Arrow dataset with the following schema:
-///
-/// | Field Name               | Field Type                       |
-/// |--------------------------|----------------------------------|
-/// | catalog_name             | utf8                             |
-/// | catalog_db_schemas       | list<DB_SCHEMA_SCHEMA> not null  |
-///
-/// DB_SCHEMA_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type                       |
-/// |--------------------------|----------------------------------|
-/// | db_schema_name           | utf8                             |
-/// | db_schema_statistics     | list<STATISTICS_SCHEMA> not null |
-///
-/// STATISTICS_SCHEMA is a Struct with fields:
-///
-/// | Field Name               | Field Type                       | Comments |
-/// |--------------------------|----------------------------------| -------- |
-/// | table_name               | utf8 not null                    |          |
-/// | column_name              | utf8                             | (1)      |
-/// | statistic_key            | int16 not null                   | (2)      |
-/// | statistic_value          | VALUE_SCHEMA not null            |          |
-/// | statistic_is_approximate | bool not null                    | (3)      |
-///
-/// 1. If null, then the statistic applies to the entire table.
-/// 2. A dictionary-encoded statistic name (although we do not use the Arrow
-///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
-///    values are for implementation-specific statistics.  For the definitions
-///    of predefined statistic types, see \ref adbc-table-statistics.  To get
-///    driver-specific statistic names, use AdbcConnectionGetStatisticNames.
-/// 3. If true, then the value is approximate or best-effort.
-///
-/// VALUE_SCHEMA is a dense union with members:
-///
-/// | Field Name               | Field Type                       |
-/// |--------------------------|----------------------------------|
-/// | int64                    | int64                            |
-/// | uint64                   | uint64                           |
-/// | float64                  | float64                          |
-/// | binary                   | binary                           |
-///
-/// This AdbcConnection must outlive the returned ArrowArrayStream.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[in] catalog The catalog (or nullptr).  May be a search
-///   pattern (see section documentation).
-/// \param[in] db_schema The database schema (or nullptr).  May be a
-///   search pattern (see section documentation).
-/// \param[in] table_name The table name (or nullptr).  May be a
-///   search pattern (see section documentation).
-/// \param[in] approximate If zero, request exact values of
-///   statistics, else allow for best-effort, approximate, or cached
-///   values.  The database may return approximate values regardless,
-///   as indicated in the result.  Requesting exact values may be
-///   expensive or unsupported.
-/// \param[out] out The result set.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection *connection, const char *catalog,
-                                           const char *db_schema, const char *table_name, char approximate,
-                                           struct ArrowArrayStream *out, struct AdbcError *error);
-
-/// \brief Get the names of statistics specific to this driver.
-///
-/// The result is an Arrow dataset with the following schema:
-///
-/// Field Name     | Field Type
-/// ---------------|----------------
-/// statistic_name | utf8 not null
-/// statistic_key  | int16 not null
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] connection The database connection.
-/// \param[out] out The result set.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection *connection, struct ArrowArrayStream *out,
-                                               struct AdbcError *error);
-
-/// \brief Get the Arrow schema of a table.
-///
-/// \param[in] connection The database connection.
-/// \param[in] catalog The catalog (or nullptr if not applicable).
-/// \param[in] db_schema The database schema (or nullptr if not applicable).
-/// \param[in] table_name The table name.
-/// \param[out] schema The table schema.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection *connection, const char *catalog,
-                                            const char *db_schema, const char *table_name, struct ArrowSchema *schema,
-                                            struct AdbcError *error);
-
-/// \brief Get a list of table types in the database.
-///
-/// The result is an Arrow dataset with the following schema:
-///
-/// Field Name     | Field Type
-/// ---------------|--------------
-/// table_type     | utf8 not null
-///
-/// This AdbcConnection must outlive the returned ArrowArrayStream.
-///
-/// \param[in] connection The database connection.
-/// \param[out] out The result set.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,
-                                           struct AdbcError *error);
-
-/// @}
-
-/// \defgroup adbc-connection-partition Partitioned Results
-/// Some databases may internally partition the results. These
-/// partitions are exposed to clients who may wish to integrate them
-/// with a threaded or distributed execution model, where partitions
-/// can be divided among threads or machines for processing.
-///
-/// Drivers are not required to support partitioning.
-///
-/// Partitions are not ordered. If the result set is sorted,
-/// implementations should return a single partition.
-///
-/// @{
-
-/// \brief Construct a statement for a partition of a query. The
-///   results can then be read independently.
-///
-/// A partition can be retrieved from AdbcPartitions.
-///
-/// This AdbcConnection must outlive the returned ArrowArrayStream.
-///
-/// \param[in] connection The connection to use.  This does not have
-///   to be the same connection that the partition was created on.
-/// \param[in] serialized_partition The partition descriptor.
-/// \param[in] serialized_length The partition descriptor length.
-/// \param[out] out The result set.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
-                                           size_t serialized_length, struct ArrowArrayStream *out,
-                                           struct AdbcError *error);
-
-/// @}
-
-/// \defgroup adbc-connection-transaction Transaction Semantics
-///
-/// Connections start out in auto-commit mode by default (if
-/// applicable for the given vendor). Use AdbcConnectionSetOption and
-/// ADBC_CONNECTION_OPTION_AUTO_COMMIT to change this.
-///
-/// @{
-
-/// \brief Commit any pending transactions. Only used if autocommit is
-///   disabled.
-///
-/// Behavior is undefined if this is mixed with SQL transaction
-/// statements.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error);
-
-/// \brief Roll back any pending transactions. Only used if autocommit
-///   is disabled.
-///
-/// Behavior is undefined if this is mixed with SQL transaction
-/// statements.
-ADBC_EXPORT
-AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error);
-
-/// @}
-
-/// @}
-
-/// \addtogroup adbc-statement
-/// @{
-
-/// \brief Create a new statement for a given connection.
-///
-/// Callers pass in a zero-initialized AdbcStatement.
-///
-/// Drivers should allocate their internal data structure and set the private_data
-/// field to point to the newly allocated struct. This struct should be released
-/// when AdbcStatementRelease is called.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
-                                struct AdbcError *error);
-
-/// \brief Destroy a statement.
-/// \param[in] statement The statement to release.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementRelease(struct AdbcStatement *statement, struct AdbcError *error);
-
-/// \brief Execute a statement and get the results.
-///
-/// This invalidates any prior result sets.  This AdbcStatement must
-/// outlive the returned ArrowArrayStream.
-///
-/// Since ADBC 1.1.0: releasing the returned ArrowArrayStream without
-/// consuming it fully is equivalent to calling AdbcStatementCancel.
-///
-/// \param[in] statement The statement to execute.
-/// \param[out] out The results. Pass NULL if the client does not
-///   expect a result set.
-/// \param[out] rows_affected The number of rows affected if known,
-///   else -1. Pass NULL if the client does not want this information.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
-                                         int64_t *rows_affected, struct AdbcError *error);
-
-/// \brief Get the schema of the result set of a query without
-///   executing it.
-///
-/// This invalidates any prior result sets.
-///
-/// Depending on the driver, this may require first executing
-/// AdbcStatementPrepare.
-///
-/// \since ADBC API revision 1.1.0
-///
-/// \param[in] statement The statement to execute.
-/// \param[out] out The result schema.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-///
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the driver does not support this.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                          struct AdbcError *error);
-
-/// \brief Turn this statement into a prepared statement to be
-///   executed multiple times.
-///
-/// This invalidates any prior result sets.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement *statement, struct AdbcError *error);
-
-/// \defgroup adbc-statement-sql SQL Semantics
-/// Functions for executing SQL queries, or querying SQL-related
-/// metadata. Drivers are not required to support both SQL and
-/// Substrait semantics. If they do, it may be via converting
-/// between representations internally.
-/// @{
-
-/// \brief Set the SQL query to execute.
-///
-/// The query can then be executed with AdbcStatementExecute.  For
-/// queries expected to be executed repeatedly, AdbcStatementPrepare
-/// the statement first.
-///
-/// \param[in] statement The statement.
-/// \param[in] query The query to execute.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error);
-
-/// @}
-
-/// \defgroup adbc-statement-substrait Substrait Semantics
-/// Functions for executing Substrait plans, or querying
-/// Substrait-related metadata.  Drivers are not required to support
-/// both SQL and Substrait semantics.  If they do, it may be via
-/// converting between representations internally.
-/// @{
-
-/// \brief Set the Substrait plan to execute.
-///
-/// The query can then be executed with AdbcStatementExecute.  For
-/// queries expected to be executed repeatedly, AdbcStatementPrepare
-/// the statement first.
-///
-/// \param[in] statement The statement.
-/// \param[in] plan The serialized substrait.Plan to execute.
-/// \param[in] length The length of the serialized plan.
-/// \param[out] error Error details, if an error occurs.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement *statement, const uint8_t *plan, size_t length,
-                                             struct AdbcError *error);
-
-/// @}
-
-/// \brief Bind Arrow data. This can be used for bulk inserts or
-///   prepared statements.
-///
-/// \param[in] statement The statement to bind to.
-/// \param[in] values The values to bind. The driver will call the
-///   release callback itself, although it may not do this until the
-///   statement is released.
-/// \param[in] schema The schema of the values to bind.
-/// \param[out] error An optional location to return an error message
-///   if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schema,
-                                 struct AdbcError *error);
-
-/// \brief Bind Arrow data. This can be used for bulk inserts or
-///   prepared statements.
-/// \param[in] statement The statement to bind to.
-/// \param[in] stream The values to bind. The driver will call the
-///   release callback itself, although it may not do this until the
-///   statement is released.
-/// \param[out] error An optional location to return an error message
-///   if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *stream,
-                                       struct AdbcError *error);
-
-/// \brief Cancel execution of an in-progress query.
-///
-/// This can be called during AdbcStatementExecuteQuery (or similar),
-/// or while consuming an ArrowArrayStream returned from such.
-/// Calling this function should make the other functions return
-/// ADBC_STATUS_CANCELLED (from ADBC functions) or ECANCELED (from
-/// methods of ArrowArrayStream).  (It is not guaranteed to, for
-/// instance, the result set may be buffered in memory already.)
-///
-/// This must always be thread-safe (other operations are not).  It is
-/// not necessarily signal-safe.
-///
-/// \since ADBC API revision 1.1.0
-///
-/// \param[in] statement The statement to cancel.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-///
-/// \return ADBC_STATUS_INVALID_STATE if there is no query to cancel.
-/// \return ADBC_STATUS_UNKNOWN if the query could not be cancelled.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementCancel(struct AdbcStatement *statement, struct AdbcError *error);
-
-/// \brief Get a string option of the statement.
-///
-/// This must always be thread-safe (other operations are not), though
-/// given the semantics here, it is not recommended to call GetOption
-/// concurrently with itself.
-///
-/// length must be provided and must be the size of the buffer pointed
-/// to by value.  If there is sufficient space, the driver will copy
-/// the option value (including the null terminator) to buffer and set
-/// length to the size of the actual value.  If the buffer is too
-/// small, no data will be written and length will be set to the
-/// required length.
-///
-/// In other words:
-///
-/// - If output length <= input length, value will contain a value
-///   with length bytes.
-/// - If output length > input length, nothing has been written to
-///   value.
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[in,out] length The length of value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement *statement, const char *key, char *value, size_t *length,
-                                      struct AdbcError *error);
-
-/// \brief Get a bytestring option of the statement.
-///
-/// This must always be thread-safe (other operations are not), though
-/// given the semantics here, it is not recommended to call
-/// GetOptionBytes concurrently with itself.
-///
-/// length must be provided and must be the size of the buffer pointed
-/// to by value.  If there is sufficient space, the driver will copy
-/// the option value to buffer and set length to the size of the
-/// actual value.  If the buffer is too small, no data will be written
-/// and length will be set to the required length.
-///
-/// In other words:
-///
-/// - If output length <= input length, value will contain a value
-///   with length bytes.
-/// - If output length > input length, nothing has been written to
-///   value.
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[in,out] length The option value length.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement *statement, const char *key, uint8_t *value,
-                                           size_t *length, struct AdbcError *error);
-
-/// \brief Get an integer option of the statement.
-///
-/// This must always be thread-safe (other operations are not).
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement *statement, const char *key, int64_t *value,
-                                         struct AdbcError *error);
-
-/// \brief Get a double option of the statement.
-///
-/// This must always be thread-safe (other operations are not).
-///
-/// For standard options, drivers must always support getting the
-/// option value (if they support getting option values at all) via
-/// the type specified in the option.  (For example, an option set via
-/// SetOptionDouble must be retrievable via GetOptionDouble.)  Drivers
-/// may also support getting a converted option value via other
-/// getters if needed.  (For example, getting the string
-/// representation of a double option.)
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to get.
-/// \param[out] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement *statement, const char *key, double *value,
-                                            struct AdbcError *error);
-
-/// \brief Get the schema for bound parameters.
-///
-/// This retrieves an Arrow schema describing the number, names, and
-/// types of the parameters in a parameterized statement.  The fields
-/// of the schema should be in order of the ordinal position of the
-/// parameters; named parameters should appear only once.
-///
-/// If the parameter does not have a name, or the name cannot be
-/// determined, the name of the corresponding field in the schema will
-/// be an empty string.  If the type cannot be determined, the type of
-/// the corresponding field will be NA (NullType).
-///
-/// This should be called after AdbcStatementPrepare.
-///
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the schema cannot be determined.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                               struct AdbcError *error);
-
-/// \brief Set a string option on a statement.
-/// \param[in] statement The statement.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized.
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
-                                      struct AdbcError *error);
-
-/// \brief Set a bytestring option on a statement.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[in] length The option value length.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement *statement, const char *key, const uint8_t *value,
-                                           size_t length, struct AdbcError *error);
-
-/// \brief Set an integer option on a statement.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement *statement, const char *key, int64_t value,
-                                         struct AdbcError *error);
-
-/// \brief Set a double option on a statement.
-///
-/// \since ADBC API revision 1.1.0
-/// \param[in] statement The statement.
-/// \param[in] key The option to set.
-/// \param[in] value The option value.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement *statement, const char *key, double value,
-                                            struct AdbcError *error);
-
-/// \addtogroup adbc-statement-partition
-/// @{
-
-/// \brief Execute a statement and get the results as a partitioned
-///   result set.
-///
-/// \param[in] statement The statement to execute.
-/// \param[out] schema The schema of the result set.
-/// \param[out] partitions The result partitions.
-/// \param[out] rows_affected The number of rows affected if known,
-///   else -1. Pass NULL if the client does not want this information.
-/// \param[out] error An optional location to return an error
-///   message if necessary.
-/// \return ADBC_STATUS_NOT_IMPLEMENTED if the driver does not support
-///   partitioned results
-ADBC_EXPORT
-AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                              struct AdbcPartitions *partitions, int64_t *rows_affected,
-                                              struct AdbcError *error);
-
-/// @}
-
-/// @}
-
-/// \addtogroup adbc-driver
-/// @{
-
-/// \brief Common entry point for drivers via the driver manager
-///   (which uses dlopen(3)/LoadLibrary). The driver manager is told
-///   to load a library and call a function of this type to load the
-///   driver.
-///
-/// Although drivers may choose any name for this function, the
-/// recommended name is "AdbcDriverInit", or a name derived from the
-/// name of the driver's shared library as follows: remove the 'lib'
-/// prefix (on Unix systems) and all file extensions, then PascalCase
-/// the driver name, append Init, and prepend Adbc (if not already
-/// there).  For example:
-///
-/// - libadbc_driver_sqlite.so.2.0.0 -> AdbcDriverSqliteInit
-/// - adbc_driver_sqlite.dll -> AdbcDriverSqliteInit
-/// - proprietary_driver.dll -> AdbcProprietaryDriverInit
-///
-/// \param[in] version The ADBC revision to attempt to initialize (see
-///   ADBC_VERSION_1_0_0).
-/// \param[out] driver The table of function pointers to
-///   initialize. Should be a pointer to the appropriate struct for
-///   the given version (see the documentation for the version).
-/// \param[out] error An optional location to return an error message
-///   if necessary.
-/// \return ADBC_STATUS_OK if the driver was initialized, or
-///   ADBC_STATUS_NOT_IMPLEMENTED if the version is not supported.  In
-///   that case, clients may retry with a different version.
-typedef AdbcStatusCode (*AdbcDriverInitFunc)(int version, void *driver, struct AdbcError *error);
-
-/// @}
-
-#endif // ADBC
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp b/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp
deleted file mode 100644
index 365de229a..000000000
--- a/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/adbc/adbc.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/adbc/adbc.h"
-
-#include <string>
-
-namespace duckdb_adbc {
-
-AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error);
-
-AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
-                                 struct AdbcError *error);
-
-AdbcStatusCode DatabaseInit(struct AdbcDatabase *database, struct AdbcError *error);
-
-AdbcStatusCode DatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error);
-
-AdbcStatusCode ConnectionNew(struct AdbcConnection *connection, struct AdbcError *error);
-
-AdbcStatusCode ConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value,
-                                   struct AdbcError *error);
-
-AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
-                              struct AdbcError *error);
-
-AdbcStatusCode ConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error);
-
-AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes,
-                                 size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error);
-
-AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
-                                    const char *db_schema, const char *table_name, const char **table_type,
-                                    const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error);
-
-AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *connection, const char *catalog, const char *db_schema,
-                                        const char *table_name, struct ArrowSchema *schema, struct AdbcError *error);
-
-AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,
-                                       struct AdbcError *error);
-
-AdbcStatusCode ConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
-                                       size_t serialized_length, struct ArrowArrayStream *out, struct AdbcError *error);
-
-AdbcStatusCode ConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error);
-
-AdbcStatusCode ConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error);
-
-AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
-                            struct AdbcError *error);
-
-AdbcStatusCode StatementRelease(struct AdbcStatement *statement, struct AdbcError *error);
-
-AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
-                                     int64_t *rows_affected, struct AdbcError *error);
-
-AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcError *error);
-
-AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error);
-
-AdbcStatusCode StatementSetSubstraitPlan(struct AdbcStatement *statement, const uint8_t *plan, size_t length,
-                                         struct AdbcError *error);
-
-AdbcStatusCode StatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schema,
-                             struct AdbcError *error);
-
-AdbcStatusCode StatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *stream,
-                                   struct AdbcError *error);
-
-AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                           struct AdbcError *error);
-
-AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
-                                  struct AdbcError *error);
-
-AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                          struct AdbcPartitions *partitions, int64_t *rows_affected,
-                                          struct AdbcError *error);
-
-void InitializeADBCError(AdbcError *error);
-
-} // namespace duckdb_adbc
-
-//! This method should only be called when the string is guaranteed to not be NULL
-void SetError(struct AdbcError *error, const std::string &message);
-// void SetError(struct AdbcError *error, const char *message);
diff --git a/src/duckdb/src/include/duckdb/common/adbc/driver_manager.h b/src/duckdb/src/include/duckdb/common/adbc/driver_manager.h
deleted file mode 100644
index a51eb0604..000000000
--- a/src/duckdb/src/include/duckdb/common/adbc/driver_manager.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#pragma once
-
-#include "duckdb/common/adbc/adbc.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef ADBC_DRIVER_MANAGER_H
-#define ADBC_DRIVER_MANAGER_H
-/// \brief Common entry point for drivers via the driver manager.
-///
-/// The driver manager can fill in default implementations of some
-/// ADBC functions for drivers. Drivers must implement a minimum level
-/// of functionality for this to be possible, however, and some
-/// functions must be implemented by the driver.
-///
-/// \param[in] driver_name An identifier for the driver (e.g. a path to a
-///   shared library on Linux).
-/// \param[in] entrypoint An identifier for the entrypoint (e.g. the
-///   symbol to call for AdbcDriverInitFunc on Linux).
-/// \param[in] version The ADBC revision to attempt to initialize.
-/// \param[out] driver The table of function pointers to initialize.
-/// \param[out] error An optional location to return an error message
-///   if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcLoadDriver(const char *driver_name, const char *entrypoint, int version, void *driver,
-                              struct AdbcError *error);
-
-/// \brief Common entry point for drivers via the driver manager.
-///
-/// The driver manager can fill in default implementations of some
-/// ADBC functions for drivers. Drivers must implement a minimum level
-/// of functionality for this to be possible, however, and some
-/// functions must be implemented by the driver.
-///
-/// \param[in] init_func The entrypoint to call.
-/// \param[in] version The ADBC revision to attempt to initialize.
-/// \param[out] driver The table of function pointers to initialize.
-/// \param[out] error An optional location to return an error message
-///   if necessary.
-ADBC_EXPORT
-AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int version, void *driver,
-                                          struct AdbcError *error);
-
-/// \brief Set the AdbcDriverInitFunc to use.
-///
-/// This is an extension to the ADBC API. The driver manager shims
-/// the AdbcDatabase* functions to allow you to specify the
-/// driver/entrypoint dynamically. This function lets you set the
-/// entrypoint explicitly, for applications that can dynamically
-/// load drivers on their own.
-ADBC_EXPORT
-AdbcStatusCode AdbcDriverManagerDatabaseSetInitFunc(struct AdbcDatabase *database, AdbcDriverInitFunc init_func,
-                                                    struct AdbcError *error);
-
-/// \brief Get a human-friendly description of a status code.
-ADBC_EXPORT
-const char *AdbcStatusCodeMessage(AdbcStatusCode code);
-
-#endif // ADBC_DRIVER_MANAGER_H
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/adbc/options.h b/src/duckdb/src/include/duckdb/common/adbc/options.h
deleted file mode 100644
index 6c9abb495..000000000
--- a/src/duckdb/src/include/duckdb/common/adbc/options.h
+++ /dev/null
@@ -1,64 +0,0 @@
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-// THIS FILE IS GENERATED BY apache/arrow, DO NOT EDIT MANUALLY //
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-/// Common options that haven't yet been formally standardized.
-/// https://github.com/apache/arrow-adbc/issues/1055
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/adbc/options.h
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// \brief The catalog of the table for bulk insert.
-///
-/// The type is char*.
-#define ADBC_INGEST_OPTION_TARGET_CATALOG "adbc.ingest.target_catalog"
-
-/// \brief The schema of the table for bulk insert.
-///
-/// The type is char*.
-#define ADBC_INGEST_OPTION_TARGET_DB_SCHEMA "adbc.ingest.target_db_schema"
-
-/// \brief Use a temporary table for ingestion.
-///
-/// The value should be ADBC_OPTION_VALUE_ENABLED or
-/// ADBC_OPTION_VALUE_DISABLED (the default).
-///
-/// This is not supported with ADBC_INGEST_OPTION_TARGET_CATALOG and
-/// ADBC_INGEST_OPTION_TARGET_DB_SCHEMA.
-///
-/// The type is char*.
-#define ADBC_INGEST_OPTION_TEMPORARY "adbc.ingest.temporary"
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/adbc/single_batch_array_stream.hpp b/src/duckdb/src/include/duckdb/common/adbc/single_batch_array_stream.hpp
deleted file mode 100644
index 8a9ec76d9..000000000
--- a/src/duckdb/src/include/duckdb/common/adbc/single_batch_array_stream.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// common/adbc/single_batch_array_stream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/adbc/adbc.h"
-
-namespace duckdb_adbc {
-
-struct SingleBatchArrayStream {
-	struct ArrowSchema schema;
-	struct ArrowArray batch;
-};
-
-AdbcStatusCode BatchToArrayStream(struct ArrowArray *values, struct ArrowSchema *schema,
-                                  struct ArrowArrayStream *stream, struct AdbcError *error);
-
-} // namespace duckdb_adbc
diff --git a/src/duckdb/src/include/duckdb/common/algorithm.hpp b/src/duckdb/src/include/duckdb/common/algorithm.hpp
deleted file mode 100644
index 0608166f3..000000000
--- a/src/duckdb/src/include/duckdb/common/algorithm.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/algorithm.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <algorithm>
-#include <cmath>
diff --git a/src/duckdb/src/include/duckdb/common/allocator.hpp b/src/duckdb/src/include/duckdb/common/allocator.hpp
deleted file mode 100644
index cd058645f..000000000
--- a/src/duckdb/src/include/duckdb/common/allocator.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-class Allocator;
-class AttachedDatabase;
-class ClientContext;
-class DatabaseInstance;
-class ExecutionContext;
-class ThreadContext;
-
-struct AllocatorDebugInfo;
-
-enum class AllocatorFreeType { REQUIRES_FREE, DOES_NOT_REQUIRE_FREE };
-
-struct PrivateAllocatorData {
-	PrivateAllocatorData();
-	virtual ~PrivateAllocatorData();
-
-	AllocatorFreeType free_type = AllocatorFreeType::REQUIRES_FREE;
-	unique_ptr<AllocatorDebugInfo> debug_info;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-typedef data_ptr_t (*allocate_function_ptr_t)(PrivateAllocatorData *private_data, idx_t size);
-typedef void (*free_function_ptr_t)(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-typedef data_ptr_t (*reallocate_function_ptr_t)(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-                                                idx_t size);
-
-class AllocatedData {
-public:
-	DUCKDB_API AllocatedData();
-	DUCKDB_API AllocatedData(Allocator &allocator, data_ptr_t pointer, idx_t allocated_size);
-	DUCKDB_API ~AllocatedData();
-	// disable copy constructors
-	AllocatedData(const AllocatedData &other) = delete;
-	AllocatedData &operator=(const AllocatedData &) = delete;
-	//! enable move constructors
-	DUCKDB_API AllocatedData(AllocatedData &&other) noexcept;
-	DUCKDB_API AllocatedData &operator=(AllocatedData &&) noexcept;
-
-	data_ptr_t get() { // NOLINT: matching std style
-		return pointer;
-	}
-	operator bool() const { // NOLINT: missing explicit
-		return pointer != nullptr;
-	}
-	const_data_ptr_t get() const { // NOLINT: matching std style
-		return pointer;
-	}
-	idx_t GetSize() const {
-		return allocated_size;
-	}
-	bool IsSet() {
-		return pointer;
-	}
-	void Reset();
-
-private:
-	optional_ptr<Allocator> allocator;
-	data_ptr_t pointer;
-	idx_t allocated_size;
-};
-
-class Allocator {
-	// 281TB ought to be enough for anybody
-	static constexpr const idx_t MAXIMUM_ALLOC_SIZE = 281474976710656ULL;
-
-public:
-	DUCKDB_API Allocator();
-	DUCKDB_API Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
-	                     reallocate_function_ptr_t reallocate_function_p,
-	                     unique_ptr<PrivateAllocatorData> private_data);
-	Allocator &operator=(Allocator &&allocator) noexcept = delete;
-	DUCKDB_API ~Allocator();
-
-	DUCKDB_API data_ptr_t AllocateData(idx_t size);
-	DUCKDB_API void FreeData(data_ptr_t pointer, idx_t size);
-	DUCKDB_API data_ptr_t ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t new_size);
-
-	AllocatedData Allocate(idx_t size) {
-		return AllocatedData(*this, AllocateData(size), size);
-	}
-	static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size);
-	static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-	static data_ptr_t DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                    idx_t size);
-	static Allocator &Get(ClientContext &context);
-	static Allocator &Get(DatabaseInstance &db);
-	static Allocator &Get(AttachedDatabase &db);
-
-	PrivateAllocatorData *GetPrivateData() {
-		return private_data.get();
-	}
-
-	DUCKDB_API static Allocator &DefaultAllocator();
-	DUCKDB_API static shared_ptr<Allocator> &DefaultAllocatorReference();
-
-	static bool SupportsFlush();
-	static optional_idx DecayDelay();
-	static void ThreadFlush(bool allocator_background_threads, idx_t threshold, idx_t thread_count);
-	static void ThreadIdle();
-	static void FlushAll();
-	static void SetBackgroundThreads(bool enable);
-
-private:
-	allocate_function_ptr_t allocate_function;
-	free_function_ptr_t free_function;
-	reallocate_function_ptr_t reallocate_function;
-
-	unique_ptr<PrivateAllocatorData> private_data;
-};
-
-template <class T>
-T *AllocateArray(idx_t size) {
-	return (T *)Allocator::DefaultAllocator().AllocateData(size * sizeof(T));
-}
-
-template <class T>
-void DeleteArray(T *ptr, idx_t size) {
-	Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), size * sizeof(T));
-}
-
-template <typename T, typename... ARGS>
-T *AllocateObject(ARGS &&... args) {
-	auto data = Allocator::DefaultAllocator().AllocateData(sizeof(T));
-	return new (data) T(std::forward<ARGS>(args)...);
-}
-
-template <typename T>
-void DestroyObject(T *ptr) {
-	ptr->~T();
-	Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), sizeof(T));
-}
-
-//! The BufferAllocator is a wrapper around the global allocator class that sends any allocations made through the
-//! buffer manager. This makes the buffer manager aware of the memory usage, allowing it to potentially free
-//! other blocks to make space in memory.
-//! Note that there is a cost to doing so (several atomic operations will be performed on allocation/free).
-//! As such this class should be used primarily for larger allocations.
-struct BufferAllocator {
-	DUCKDB_API static Allocator &Get(ClientContext &context);
-	DUCKDB_API static Allocator &Get(DatabaseInstance &db);
-	DUCKDB_API static Allocator &Get(AttachedDatabase &db);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/array.hpp b/src/duckdb/src/include/duckdb/common/array.hpp
deleted file mode 100644
index fc03178d1..000000000
--- a/src/duckdb/src/include/duckdb/common/array.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/array.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <array>
-
-namespace duckdb {
-using std::array;
-}
diff --git a/src/duckdb/src/include/duckdb/common/array_ptr.hpp b/src/duckdb/src/include/duckdb/common/array_ptr.hpp
deleted file mode 100644
index 6c268945c..000000000
--- a/src/duckdb/src/include/duckdb/common/array_ptr.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/array_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/memory_safety.hpp"
-
-namespace duckdb {
-
-template <class DATA_TYPE>
-class array_ptr_iterator { // NOLINT: match std naming style
-public:
-	array_ptr_iterator(DATA_TYPE *ptr, idx_t index, idx_t size) : ptr(ptr), index(index), size(size) {
-	}
-
-public:
-	array_ptr_iterator<DATA_TYPE> &operator++() {
-		index++;
-		if (index > size) {
-			index = size;
-		}
-		return *this;
-	}
-	bool operator!=(const array_ptr_iterator<DATA_TYPE> &other) const {
-		return ptr != other.ptr || index != other.index || size != other.size;
-	}
-	DATA_TYPE &operator*() const {
-		if (DUCKDB_UNLIKELY(index >= size)) {
-			throw InternalException("array_ptr iterator dereferenced while iterator is out of range");
-		}
-		return ptr[index];
-	}
-
-private:
-	DATA_TYPE *ptr;
-	idx_t index;
-	idx_t size;
-};
-
-//! array_ptr is a non-owning (optionally) bounds-checked pointer to an array
-template <class DATA_TYPE, bool SAFE = true>
-class array_ptr { // NOLINT: match std naming style
-public:
-	using iterator_type = array_ptr_iterator<DATA_TYPE>;
-
-private:
-	static inline void AssertNotNull(const bool null) {
-#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
-		return;
-#else
-		if (DUCKDB_UNLIKELY(null)) {
-			throw duckdb::InternalException("Attempted to construct an array_ptr from a NULL pointer");
-		}
-#endif
-	}
-
-	static inline void AssertIndexInBounds(idx_t index, idx_t size) {
-#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
-		return;
-#else
-		if (DUCKDB_UNLIKELY(index >= size)) {
-			throw InternalException("Attempted to access index %ld within array_ptr of size %ld", index, size);
-		}
-#endif
-	}
-
-public:
-	array_ptr(DATA_TYPE *ptr_p, idx_t count) : ptr(ptr_p), count(count) {
-		if (MemorySafety<SAFE>::ENABLED) {
-			AssertNotNull(!ptr);
-		}
-	}
-	explicit array_ptr(DATA_TYPE &ref) : ptr(&ref), count(1) {
-	}
-
-	const DATA_TYPE &operator[](idx_t idx) const {
-		if (MemorySafety<SAFE>::ENABLED) {
-			AssertIndexInBounds(idx, count);
-		}
-		return ptr[idx];
-	}
-
-	DATA_TYPE &operator[](idx_t idx) {
-		if (MemorySafety<SAFE>::ENABLED) {
-			AssertIndexInBounds(idx, count);
-		}
-		return ptr[idx];
-	}
-
-	idx_t size() const { // NOLINT: match std naming style
-		return count;
-	}
-
-	array_ptr_iterator<DATA_TYPE> begin() { // NOLINT: match std naming style
-		return array_ptr_iterator<DATA_TYPE>(ptr, 0, count);
-	}
-	array_ptr_iterator<DATA_TYPE> begin() const { // NOLINT: match std naming style
-		return array_ptr_iterator<const DATA_TYPE>(ptr, 0, count);
-	}
-	array_ptr_iterator<DATA_TYPE> cbegin() { // NOLINT: match std naming style
-		return array_ptr_iterator<const DATA_TYPE>(ptr, 0, count);
-	}
-	array_ptr_iterator<DATA_TYPE> end() { // NOLINT: match std naming style
-		return array_ptr_iterator<DATA_TYPE>(ptr, count, count);
-	}
-	array_ptr_iterator<DATA_TYPE> end() const { // NOLINT: match std naming style
-		return array_ptr_iterator<const DATA_TYPE>(ptr, count, count);
-	}
-	array_ptr_iterator<DATA_TYPE> cend() { // NOLINT: match std naming style
-		return array_ptr_iterator<const DATA_TYPE>(ptr, count, count);
-	}
-
-private:
-	DATA_TYPE *ptr;
-	idx_t count;
-};
-
-template <typename T>
-using unsafe_array_ptr = array_ptr<T, false>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp
deleted file mode 100644
index eedc63db9..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/arrow/arrow_buffer.hpp"
-#include "duckdb/main/client_properties.hpp"
-#include "duckdb/common/array.hpp"
-
-namespace duckdb {
-
-struct ArrowAppendData;
-
-//===--------------------------------------------------------------------===//
-// Arrow append data
-//===--------------------------------------------------------------------===//
-typedef void (*initialize_t)(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
-// append_data: The arrow array we're appending into
-// input: The data we're appending
-// from: The offset into the input we're scanning
-// to: The last index of the input we're scanning
-// input_size: The total size of the 'input' Vector.
-typedef void (*append_vector_t)(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
-typedef void (*finalize_t)(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
-
-// This struct is used to save state for appending a column
-// afterwards the ownership is passed to the arrow array, as 'private_data'
-// FIXME: we should separate the append state variables from the variables required by the ArrowArray into
-// ArrowAppendState
-struct ArrowAppendData {
-	explicit ArrowAppendData(ClientProperties &options_p) : options(options_p) {
-		dictionary.release = nullptr;
-		arrow_buffers.resize(3);
-	}
-
-	//! Getters for the Buffers
-	ArrowBuffer &GetValidityBuffer() {
-		return arrow_buffers[0];
-	}
-
-	ArrowBuffer &GetMainBuffer() {
-		return arrow_buffers[1];
-	}
-
-	ArrowBuffer &GetAuxBuffer() {
-		return arrow_buffers[2];
-	}
-
-	ArrowBuffer &GetBufferSizeBuffer() {
-		//! This is a special case, we resize it if necessary since it's a different size than set in the constructor
-		if (arrow_buffers.size() == 3) {
-			arrow_buffers.resize(4);
-		}
-		return arrow_buffers[3];
-	}
-
-	idx_t row_count = 0;
-	idx_t null_count = 0;
-
-	//! function pointers for construction
-	initialize_t initialize = nullptr;
-	append_vector_t append_vector = nullptr;
-	finalize_t finalize = nullptr;
-
-	//! child data (if any)
-	vector<unique_ptr<ArrowAppendData>> child_data;
-
-	//! the arrow array C API data, only set after Finalize
-	unique_ptr<ArrowArray> array;
-	duckdb::array<const void *, 4> buffers = {{nullptr, nullptr, nullptr, nullptr}};
-	vector<ArrowArray *> child_pointers;
-	//! Arrays so the children can be moved
-	vector<ArrowArray> child_arrays;
-	ArrowArray dictionary;
-
-	ClientProperties options;
-	//! Offset used to keep data positions when producing a mix of inlined and not-inlined arrow string views.
-	idx_t offset = 0;
-
-private:
-	//! The buffers of the arrow vector
-	vector<ArrowBuffer> arrow_buffers;
-};
-
-//===--------------------------------------------------------------------===//
-// Append Helper Functions
-//===--------------------------------------------------------------------===//
-
-static void GetBitPosition(idx_t row_idx, idx_t &current_byte, uint8_t &current_bit) {
-	current_byte = row_idx / 8;
-	current_bit = row_idx % 8;
-}
-
-static void UnsetBit(uint8_t *data, idx_t current_byte, uint8_t current_bit) {
-	data[current_byte] &= ~((uint64_t)1 << current_bit);
-}
-
-static void NextBit(idx_t &current_byte, uint8_t &current_bit) {
-	current_bit++;
-	if (current_bit == 8) {
-		current_byte++;
-		current_bit = 0;
-	}
-}
-
-static void ResizeValidity(ArrowBuffer &buffer, idx_t row_count) {
-	auto byte_count = (row_count + 7) / 8;
-	buffer.resize(byte_count, 0xFF);
-}
-
-static void SetNull(ArrowAppendData &append_data, uint8_t *validity_data, idx_t current_byte, uint8_t current_bit) {
-	UnsetBit(validity_data, current_byte, current_bit);
-	append_data.null_count++;
-}
-
-static void AppendValidity(ArrowAppendData &append_data, UnifiedVectorFormat &format, idx_t from, idx_t to) {
-	// resize the buffer, filling the validity buffer with all valid values
-	idx_t size = to - from;
-	ResizeValidity(append_data.GetValidityBuffer(), append_data.row_count + size);
-	if (format.validity.AllValid()) {
-		// if all values are valid we don't need to do anything else
-		return;
-	}
-
-	// otherwise we iterate through the validity mask
-	auto validity_data = (uint8_t *)append_data.GetValidityBuffer().data();
-	uint8_t current_bit;
-	idx_t current_byte;
-	GetBitPosition(append_data.row_count, current_byte, current_bit);
-	for (idx_t i = from; i < to; i++) {
-		auto source_idx = format.sel->get_index(i);
-		// append the validity mask
-		if (!format.validity.RowIsValid(source_idx)) {
-			SetNull(append_data, validity_data, current_byte, current_bit);
-		}
-		NextBit(current_byte, current_bit);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/bool_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/bool_data.hpp
deleted file mode 100644
index 59313faa3..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/bool_data.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-struct ArrowBoolData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/enum_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/enum_data.hpp
deleted file mode 100644
index 90473d9b5..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/enum_data.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/appender/scalar_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Enums
-//===--------------------------------------------------------------------===//
-
-// FIXME: support Large offsets (int64_t), this does not currently respect the 'arrow_large_buffer_size' setting
-
-template <class TGT>
-struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
-	static idx_t GetLength(string_t input) {
-		return input.GetSize();
-	}
-
-	static void WriteData(data_ptr_t target, string_t input) {
-		memcpy(target, input.GetData(), input.GetSize());
-	}
-
-	static void EnumAppendVector(ArrowAppendData &append_data, const Vector &input, idx_t size) {
-		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
-		auto &main_buffer = append_data.GetMainBuffer();
-		auto &aux_buffer = append_data.GetAuxBuffer();
-		// resize the validity mask and set up the validity buffer for iteration
-		ResizeValidity(append_data.GetValidityBuffer(), append_data.row_count + size);
-
-		// resize the offset buffer - the offset buffer holds the offsets into the child array
-		main_buffer.resize(main_buffer.size() + sizeof(int32_t) * (size + 1));
-		auto data = FlatVector::GetData<string_t>(input);
-		auto offset_data = main_buffer.GetData<int32_t>();
-		if (append_data.row_count == 0) {
-			// first entry
-			offset_data[0] = 0;
-		}
-		// now append the string data to the auxiliary buffer
-		// the auxiliary buffer's length depends on the string lengths, so we resize as required
-		auto last_offset = offset_data[append_data.row_count];
-		for (idx_t i = 0; i < size; i++) {
-			auto offset_idx = append_data.row_count + i + 1;
-
-			auto string_length = GetLength(data[i]);
-
-			// append the offset data
-			auto current_offset = UnsafeNumericCast<idx_t>(last_offset) + string_length;
-			offset_data[offset_idx] = UnsafeNumericCast<int32_t>(current_offset);
-
-			// resize the string buffer if required, and write the string data
-			aux_buffer.resize(current_offset);
-			WriteData(aux_buffer.data() + last_offset, data[i]);
-
-			last_offset = UnsafeNumericCast<int32_t>(current_offset);
-		}
-		append_data.row_count += size;
-	}
-
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		result.GetMainBuffer().reserve(capacity * sizeof(TGT));
-		// construct the enum child data
-		auto enum_data = ArrowAppender::InitializeChild(LogicalType::VARCHAR, EnumType::GetSize(type), result.options);
-		EnumAppendVector(*enum_data, EnumType::GetValuesInsertOrder(type), EnumType::GetSize(type));
-		result.child_data.push_back(std::move(enum_data));
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		result->n_buffers = 2;
-		result->buffers[1] = append_data.GetMainBuffer().data();
-		// finalize the enum child data, and assign it to the dictionary
-		result->dictionary = &append_data.dictionary;
-		append_data.dictionary =
-		    *ArrowAppender::FinalizeChild(LogicalType::VARCHAR, std::move(append_data.child_data[0]));
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/fixed_size_list_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/fixed_size_list_data.hpp
deleted file mode 100644
index 4ad609441..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/fixed_size_list_data.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-
-namespace duckdb {
-
-struct ArrowFixedSizeListData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/list.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/list.hpp
deleted file mode 100644
index 6ce97b528..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/list.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "duckdb/common/arrow/appender/bool_data.hpp"
-#include "duckdb/common/arrow/appender/enum_data.hpp"
-#include "duckdb/common/arrow/appender/fixed_size_list_data.hpp"
-#include "duckdb/common/arrow/appender/list_data.hpp"
-#include "duckdb/common/arrow/appender/list_view_data.hpp"
-#include "duckdb/common/arrow/appender/map_data.hpp"
-#include "duckdb/common/arrow/appender/scalar_data.hpp"
-#include "duckdb/common/arrow/appender/struct_data.hpp"
-#include "duckdb/common/arrow/appender/union_data.hpp"
-#include "duckdb/common/arrow/appender/varchar_data.hpp"
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/list_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/list_data.hpp
deleted file mode 100644
index 5f0f86215..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/list_data.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/arrow_appender.hpp"
-
-namespace duckdb {
-
-template <class BUFTYPE = int64_t>
-struct ArrowListData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		auto &child_type = ListType::GetChildType(type);
-		result.GetMainBuffer().reserve((capacity + 1) * sizeof(BUFTYPE));
-		auto child_buffer = ArrowAppender::InitializeChild(child_type, capacity, result.options);
-		result.child_data.push_back(std::move(child_buffer));
-	}
-
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		UnifiedVectorFormat format;
-		input.ToUnifiedFormat(input_size, format);
-		idx_t size = to - from;
-		vector<sel_t> child_indices;
-		AppendValidity(append_data, format, from, to);
-		AppendOffsets(append_data, format, from, to, child_indices);
-
-		// append the child vector of the list
-		SelectionVector child_sel(child_indices.data());
-		auto &child = ListVector::GetEntry(input);
-		auto child_size = child_indices.size();
-		Vector child_copy(child.GetType());
-		child_copy.Slice(child, child_sel, child_size);
-		append_data.child_data[0]->append_vector(*append_data.child_data[0], child_copy, 0, child_size, child_size);
-		append_data.row_count += size;
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		result->n_buffers = 2;
-		result->buffers[1] = append_data.GetMainBuffer().data();
-
-		auto &child_type = ListType::GetChildType(type);
-		ArrowAppender::AddChildren(append_data, 1);
-		result->children = append_data.child_pointers.data();
-		result->n_children = 1;
-		append_data.child_arrays[0] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[0]));
-	}
-
-public:
-	static void AppendOffsets(ArrowAppendData &append_data, UnifiedVectorFormat &format, idx_t from, idx_t to,
-	                          vector<sel_t> &child_sel) {
-		// resize the offset buffer - the offset buffer holds the offsets into the child array
-		idx_t size = to - from;
-		auto &main_buffer = append_data.GetMainBuffer();
-
-		main_buffer.resize(main_buffer.size() + sizeof(BUFTYPE) * (size + 1));
-		auto data = UnifiedVectorFormat::GetData<list_entry_t>(format);
-		auto offset_data = main_buffer.GetData<BUFTYPE>();
-		if (append_data.row_count == 0) {
-			// first entry
-			offset_data[0] = 0;
-		}
-		// set up the offsets using the list entries
-		auto last_offset = offset_data[append_data.row_count];
-		for (idx_t i = from; i < to; i++) {
-			auto source_idx = format.sel->get_index(i);
-			auto offset_idx = append_data.row_count + i + 1 - from;
-
-			if (!format.validity.RowIsValid(source_idx)) {
-				offset_data[offset_idx] = last_offset;
-				continue;
-			}
-
-			// append the offset data
-			auto list_length = data[source_idx].length;
-			if (std::is_same<BUFTYPE, int32_t>::value == true &&
-			    (uint64_t)last_offset + list_length > NumericLimits<int32_t>::Maximum()) {
-				throw InvalidInputException(
-				    "Arrow Appender: The maximum combined list offset for regular list buffers is "
-				    "%u but the offset of %lu exceeds this.\n* SET arrow_large_buffer_size=true to use large list "
-				    "buffers",
-				    NumericLimits<int32_t>::Maximum(), last_offset);
-			}
-			last_offset += list_length;
-			offset_data[offset_idx] = last_offset;
-
-			for (idx_t k = 0; k < list_length; k++) {
-				child_sel.push_back(UnsafeNumericCast<sel_t>(data[source_idx].offset + k));
-			}
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/list_view_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/list_view_data.hpp
deleted file mode 100644
index 158120c46..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/list_view_data.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/arrow_appender.hpp"
-
-namespace duckdb {
-
-template <class BUFTYPE = int64_t>
-struct ArrowListViewData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		auto &child_type = ListType::GetChildType(type);
-		result.GetMainBuffer().reserve(capacity * sizeof(BUFTYPE));
-		result.GetAuxBuffer().reserve(capacity * sizeof(BUFTYPE));
-
-		auto child_buffer = ArrowAppender::InitializeChild(child_type, capacity, result.options);
-		result.child_data.push_back(std::move(child_buffer));
-	}
-
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		UnifiedVectorFormat format;
-		input.ToUnifiedFormat(input_size, format);
-		idx_t size = to - from;
-		vector<sel_t> child_indices;
-		AppendValidity(append_data, format, from, to);
-		AppendListMetadata(append_data, format, from, to, child_indices);
-
-		// append the child vector of the list
-		SelectionVector child_sel(child_indices.data());
-		auto &child = ListVector::GetEntry(input);
-		auto child_size = child_indices.size();
-		Vector child_copy(child.GetType());
-		child_copy.Slice(child, child_sel, child_size);
-		append_data.child_data[0]->append_vector(*append_data.child_data[0], child_copy, 0, child_size, child_size);
-		append_data.row_count += size;
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		result->n_buffers = 3;
-		result->buffers[1] = append_data.GetMainBuffer().data();
-		result->buffers[2] = append_data.GetAuxBuffer().data();
-
-		auto &child_type = ListType::GetChildType(type);
-		ArrowAppender::AddChildren(append_data, 1);
-		result->children = append_data.child_pointers.data();
-		result->n_children = 1;
-		append_data.child_arrays[0] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[0]));
-	}
-
-public:
-	static void AppendListMetadata(ArrowAppendData &append_data, UnifiedVectorFormat &format, idx_t from, idx_t to,
-	                               vector<sel_t> &child_sel) {
-		// resize the offset buffer - the offset buffer holds the offsets into the child array
-		idx_t size = to - from;
-		append_data.GetMainBuffer().resize(append_data.GetMainBuffer().size() + sizeof(BUFTYPE) * size);
-		append_data.GetAuxBuffer().resize(append_data.GetAuxBuffer().size() + sizeof(BUFTYPE) * size);
-		auto data = UnifiedVectorFormat::GetData<list_entry_t>(format);
-		auto offset_data = append_data.GetMainBuffer().GetData<BUFTYPE>();
-		auto size_data = append_data.GetAuxBuffer().GetData<BUFTYPE>();
-
-		BUFTYPE last_offset =
-		    append_data.row_count ? offset_data[append_data.row_count - 1] + size_data[append_data.row_count - 1] : 0;
-		for (idx_t i = 0; i < size; i++) {
-			auto source_idx = format.sel->get_index(i + from);
-			auto offset_idx = append_data.row_count + i;
-
-			if (!format.validity.RowIsValid(source_idx)) {
-				offset_data[offset_idx] = last_offset;
-				size_data[offset_idx] = 0;
-				continue;
-			}
-
-			// append the offset data
-			auto list_length = data[source_idx].length;
-			if (std::is_same<BUFTYPE, int32_t>::value == true &&
-			    (uint64_t)last_offset + list_length > NumericLimits<int32_t>::Maximum()) {
-				throw InvalidInputException(
-				    "Arrow Appender: The maximum combined list offset for regular list buffers is "
-				    "%u but the offset of %lu exceeds this.\n* SET arrow_large_buffer_size=true to use large list "
-				    "buffers",
-				    NumericLimits<int32_t>::Maximum(), last_offset);
-			}
-			offset_data[offset_idx] = last_offset;
-			size_data[offset_idx] = UnsafeNumericCast<BUFTYPE>(list_length);
-			last_offset += list_length;
-
-			for (idx_t k = 0; k < list_length; k++) {
-				child_sel.push_back(UnsafeNumericCast<sel_t>(data[source_idx].offset + k));
-			}
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/map_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/map_data.hpp
deleted file mode 100644
index afc67decd..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/map_data.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/arrow_appender.hpp"
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/appender/list_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Maps
-//===--------------------------------------------------------------------===//
-template <class BUFTYPE = int64_t>
-struct ArrowMapData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		// map types are stored in a (too) clever way
-		// the main buffer holds the null values and the offsets
-		// then we have a single child, which is a struct of the map_type, and the key_type
-		result.GetMainBuffer().reserve((capacity + 1) * sizeof(BUFTYPE));
-
-		auto &key_type = MapType::KeyType(type);
-		auto &value_type = MapType::ValueType(type);
-		auto internal_struct = make_uniq<ArrowAppendData>(result.options);
-		internal_struct->child_data.push_back(ArrowAppender::InitializeChild(key_type, capacity, result.options));
-		internal_struct->child_data.push_back(ArrowAppender::InitializeChild(value_type, capacity, result.options));
-
-		result.child_data.push_back(std::move(internal_struct));
-	}
-
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		UnifiedVectorFormat format;
-		input.ToUnifiedFormat(input_size, format);
-		idx_t size = to - from;
-		AppendValidity(append_data, format, from, to);
-		vector<sel_t> child_indices;
-		ArrowListData<BUFTYPE>::AppendOffsets(append_data, format, from, to, child_indices);
-
-		SelectionVector child_sel(child_indices.data());
-		auto &key_vector = MapVector::GetKeys(input);
-		auto &value_vector = MapVector::GetValues(input);
-		auto list_size = child_indices.size();
-
-		auto &struct_data = *append_data.child_data[0];
-		auto &key_data = *struct_data.child_data[0];
-		auto &value_data = *struct_data.child_data[1];
-
-		Vector key_vector_copy(key_vector.GetType());
-		key_vector_copy.Slice(key_vector, child_sel, list_size);
-		Vector value_vector_copy(value_vector.GetType());
-		value_vector_copy.Slice(value_vector, child_sel, list_size);
-		key_data.append_vector(key_data, key_vector_copy, 0, list_size, list_size);
-		value_data.append_vector(value_data, value_vector_copy, 0, list_size, list_size);
-
-		append_data.row_count += size;
-		struct_data.row_count += size;
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		// set up the main map buffer
-		D_ASSERT(result);
-		result->n_buffers = 2;
-		result->buffers[1] = append_data.GetMainBuffer().data();
-
-		// the main map buffer has a single child: a struct
-		ArrowAppender::AddChildren(append_data, 1);
-		result->children = append_data.child_pointers.data();
-		result->n_children = 1;
-
-		auto &struct_data = *append_data.child_data[0];
-		auto struct_result = ArrowAppender::FinalizeChild(type, std::move(append_data.child_data[0]));
-
-		// Initialize the struct array data
-		const auto struct_child_count = 2;
-		ArrowAppender::AddChildren(struct_data, struct_child_count);
-		struct_result->children = struct_data.child_pointers.data();
-		struct_result->n_buffers = 1;
-		struct_result->n_children = struct_child_count;
-		struct_result->length = NumericCast<int64_t>(struct_data.child_data[0]->row_count);
-
-		append_data.child_arrays[0] = *struct_result;
-
-		D_ASSERT(struct_data.child_data[0]->row_count == struct_data.child_data[1]->row_count);
-
-		auto &key_type = MapType::KeyType(type);
-		auto &value_type = MapType::ValueType(type);
-		auto key_data = ArrowAppender::FinalizeChild(key_type, std::move(struct_data.child_data[0]));
-		struct_data.child_arrays[0] = *key_data;
-		struct_data.child_arrays[1] = *ArrowAppender::FinalizeChild(value_type, std::move(struct_data.child_data[1]));
-
-		// keys cannot have null values
-		if (key_data->null_count > 0) {
-			throw std::runtime_error("Arrow doesn't accept NULL keys on Maps");
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/scalar_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/scalar_data.hpp
deleted file mode 100644
index 00326a6a5..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/scalar_data.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/function/table/arrow.hpp"
-
-#include "duckdb/common/bswap.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Scalar Types
-//===--------------------------------------------------------------------===//
-struct ArrowScalarConverter {
-	template <class TGT, class SRC>
-	static TGT Operation(SRC input) {
-		return input;
-	}
-
-	static bool SkipNulls() {
-		return false;
-	}
-
-	template <class TGT>
-	static void SetNull(TGT &value) {
-	}
-};
-
-struct ArrowIntervalConverter {
-	template <class TGT, class SRC>
-	static TGT Operation(SRC input) {
-		ArrowInterval result;
-		result.months = input.months;
-		result.days = input.days;
-		result.nanoseconds = input.micros * Interval::NANOS_PER_MICRO;
-		return result;
-	}
-
-	static bool SkipNulls() {
-		return true;
-	}
-
-	template <class TGT>
-	static void SetNull(TGT &value) {
-	}
-};
-
-struct ArrowTimeTzConverter {
-	template <class TGT, class SRC>
-	static TGT Operation(SRC input) {
-		return input.time().micros;
-	}
-
-	static bool SkipNulls() {
-		return true;
-	}
-
-	template <class TGT>
-	static void SetNull(TGT &value) {
-	}
-};
-
-struct ArrowUUIDBlobConverter {
-	template <class TGT, class SRC>
-	static TGT Operation(hugeint_t input) {
-		// Turn into big-end
-		auto upper = BSwap(input.lower);
-		// flip Upper MSD
-		auto lower = BSwap(static_cast<int64_t>(static_cast<uint64_t>(input.upper) ^ (static_cast<uint64_t>(1) << 63)));
-		return {static_cast<int64_t>(upper), static_cast<uint64_t>(lower)};
-	}
-
-	static bool SkipNulls() {
-		return true;
-	}
-
-	template <class TGT>
-	static void SetNull(TGT &value) {
-	}
-};
-
-template <class TGT, class SRC = TGT, class OP = ArrowScalarConverter>
-struct ArrowScalarBaseData {
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		D_ASSERT(to >= from);
-		idx_t size = to - from;
-		D_ASSERT(size <= input_size);
-		UnifiedVectorFormat format;
-		input.ToUnifiedFormat(input_size, format);
-
-		// append the validity mask
-		AppendValidity(append_data, format, from, to);
-
-		// append the main data
-		auto &main_buffer = append_data.GetMainBuffer();
-		main_buffer.resize(main_buffer.size() + sizeof(TGT) * size);
-		auto data = UnifiedVectorFormat::GetData<SRC>(format);
-		auto result_data = main_buffer.GetData<TGT>();
-
-		for (idx_t i = from; i < to; i++) {
-			auto source_idx = format.sel->get_index(i);
-			auto result_idx = append_data.row_count + i - from;
-
-			if (OP::SkipNulls() && !format.validity.RowIsValid(source_idx)) {
-				OP::template SetNull<TGT>(result_data[result_idx]);
-				continue;
-			}
-			result_data[result_idx] = OP::template Operation<TGT, SRC>(data[source_idx]);
-		}
-		append_data.row_count += size;
-	}
-};
-
-template <class TGT, class SRC = TGT, class OP = ArrowScalarConverter>
-struct ArrowScalarData : public ArrowScalarBaseData<TGT, SRC, OP> {
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		result.GetMainBuffer().reserve(capacity * sizeof(TGT));
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		result->n_buffers = 2;
-		result->buffers[1] = append_data.GetMainBuffer().data();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/struct_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/struct_data.hpp
deleted file mode 100644
index de2514fc1..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/struct_data.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/appender/scalar_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Structs
-//===--------------------------------------------------------------------===//
-struct ArrowStructData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/union_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/union_data.hpp
deleted file mode 100644
index 8b2850fca..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/union_data.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Unions
-//===--------------------------------------------------------------------===//
-/**
- * Based on https://arrow.apache.org/docs/format/Columnar.html#union-layout &
- * https://arrow.apache.org/docs/format/CDataInterface.html
- */
-struct ArrowUnionData {
-public:
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp
deleted file mode 100644
index 6dc37652d..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/appender/append_data.hpp"
-#include "duckdb/common/arrow/appender/scalar_data.hpp"
-#include "duckdb/common/types/arrow_string_view_type.hpp"
-#include "duckdb/common/types/uuid.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Varchar
-//===--------------------------------------------------------------------===//
-struct ArrowVarcharConverter {
-	template <class SRC>
-	static idx_t GetLength(SRC input) {
-		return input.GetSize();
-	}
-
-	template <class SRC>
-	static void WriteData(data_ptr_t target, SRC input) {
-		memcpy(target, input.GetData(), input.GetSize());
-	}
-};
-
-struct ArrowUUIDConverter {
-	template <class SRC>
-	static idx_t GetLength(SRC input) {
-		return UUID::STRING_SIZE;
-	}
-
-	template <class SRC>
-	static void WriteData(data_ptr_t target, SRC input) {
-		UUID::ToString(input, char_ptr_cast(target));
-	}
-};
-
-template <class SRC = string_t, class OP = ArrowVarcharConverter, class BUFTYPE = int64_t>
-struct ArrowVarcharData {
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		result.GetMainBuffer().reserve((capacity + 1) * sizeof(BUFTYPE));
-		result.GetAuxBuffer().reserve(capacity);
-	}
-
-	template <bool LARGE_STRING>
-	static void AppendTemplated(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		idx_t size = to - from;
-		UnifiedVectorFormat format;
-		input.ToUnifiedFormat(input_size, format);
-		auto &main_buffer = append_data.GetMainBuffer();
-		auto &validity_buffer = append_data.GetValidityBuffer();
-		auto &aux_buffer = append_data.GetAuxBuffer();
-
-		// resize the validity mask and set up the validity buffer for iteration
-		ResizeValidity(validity_buffer, append_data.row_count + size);
-		auto validity_data = (uint8_t *)validity_buffer.data();
-
-		// resize the offset buffer - the offset buffer holds the offsets into the child array
-		main_buffer.resize(main_buffer.size() + sizeof(BUFTYPE) * (size + 1));
-		auto data = UnifiedVectorFormat::GetData<SRC>(format);
-		auto offset_data = main_buffer.GetData<BUFTYPE>();
-		if (append_data.row_count == 0) {
-			// first entry
-			offset_data[0] = 0;
-		}
-		// now append the string data to the auxiliary buffer
-		// the auxiliary buffer's length depends on the string lengths, so we resize as required
-		auto last_offset = offset_data[append_data.row_count];
-		for (idx_t i = from; i < to; i++) {
-			auto source_idx = format.sel->get_index(i);
-			auto offset_idx = append_data.row_count + i + 1 - from;
-
-			if (!format.validity.RowIsValid(source_idx)) {
-				uint8_t current_bit;
-				idx_t current_byte;
-				GetBitPosition(append_data.row_count + i - from, current_byte, current_bit);
-				SetNull(append_data, validity_data, current_byte, current_bit);
-				offset_data[offset_idx] = last_offset;
-				continue;
-			}
-
-			auto string_length = OP::GetLength(data[source_idx]);
-
-			// append the offset data
-			auto current_offset = UnsafeNumericCast<idx_t>(last_offset) + string_length;
-			if (!LARGE_STRING &&
-			    UnsafeNumericCast<idx_t>(last_offset) + string_length > NumericLimits<int32_t>::Maximum()) {
-				D_ASSERT(append_data.options.arrow_offset_size == ArrowOffsetSize::REGULAR);
-				throw InvalidInputException(
-				    "Arrow Appender: The maximum total string size for regular string buffers is "
-				    "%u but the offset of %lu exceeds this.\n* SET arrow_large_buffer_size=true to use large string "
-				    "buffers",
-				    NumericLimits<int32_t>::Maximum(), current_offset);
-			}
-			offset_data[offset_idx] = UnsafeNumericCast<BUFTYPE>(current_offset);
-
-			// resize the string buffer if required, and write the string data
-			aux_buffer.resize(current_offset);
-			OP::WriteData(aux_buffer.data() + last_offset, data[source_idx]);
-
-			last_offset = UnsafeNumericCast<BUFTYPE>(current_offset);
-		}
-		append_data.row_count += size;
-	}
-
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		if (append_data.options.arrow_offset_size == ArrowOffsetSize::REGULAR) {
-			// Check if the offset exceeds the max supported value
-			AppendTemplated<false>(append_data, input, from, to, input_size);
-		} else {
-			AppendTemplated<true>(append_data, input, from, to, input_size);
-		}
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		result->n_buffers = 3;
-		result->buffers[1] = append_data.GetMainBuffer().data();
-		result->buffers[2] = append_data.GetAuxBuffer().data();
-	}
-};
-
-struct ArrowVarcharToStringViewData {
-	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		result.GetMainBuffer().reserve((capacity) * sizeof(arrow_string_view_t));
-		result.GetAuxBuffer().reserve(capacity);
-		result.GetBufferSizeBuffer().reserve(sizeof(int64_t));
-	}
-
-	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
-		idx_t size = to - from;
-		UnifiedVectorFormat format;
-		input.ToUnifiedFormat(input_size, format);
-		auto &main_buffer = append_data.GetMainBuffer();
-		auto &validity_buffer = append_data.GetValidityBuffer();
-		auto &aux_buffer = append_data.GetAuxBuffer();
-		// resize the validity mask and set up the validity buffer for iteration
-		ResizeValidity(validity_buffer, append_data.row_count + size);
-		auto validity_data = (uint8_t *)validity_buffer.data();
-
-		main_buffer.resize(main_buffer.size() + sizeof(arrow_string_view_t) * (size));
-		// resize the offset buffer - the offset buffer holds the offsets into the child array
-		auto data = UnifiedVectorFormat::GetData<string_t>(format);
-		for (idx_t i = from; i < to; i++) {
-			auto result_idx = append_data.row_count + i - from;
-			auto arrow_data = main_buffer.GetData<arrow_string_view_t>();
-			auto source_idx = format.sel->get_index(i);
-			if (!format.validity.RowIsValid(source_idx)) {
-				// Null value
-				uint8_t current_bit;
-				idx_t current_byte;
-				GetBitPosition(result_idx, current_byte, current_bit);
-				SetNull(append_data, validity_data, current_byte, current_bit);
-				// We have to set these bytes to 0, for some reason
-				arrow_data[result_idx] = arrow_string_view_t(0, "");
-				continue;
-			}
-			// These two are now the same buffer
-			idx_t string_length = ArrowVarcharConverter::GetLength(data[source_idx]);
-			auto string_data = data[source_idx].GetData();
-			if (string_length <= ArrowStringViewConstants::MAX_INLINED_BYTES) {
-				//	This string is inlined
-				//  | Bytes 0-3  | Bytes 4-15                            |
-				//  |------------|---------------------------------------|
-				//  | length     | data (padded with 0)                  |
-				arrow_data[result_idx] = arrow_string_view_t(UnsafeNumericCast<int32_t>(string_length), string_data);
-			} else {
-				// This string is not inlined, we have to check a different buffer and offsets
-				//  | Bytes 0-3  | Bytes 4-7  | Bytes 8-11 | Bytes 12-15 |
-				//  |------------|------------|------------|-------------|
-				//  | length     | prefix     | buf. index | offset      |
-				arrow_data[result_idx] = arrow_string_view_t(UnsafeNumericCast<int32_t>(string_length), string_data, 0,
-				                                             UnsafeNumericCast<int32_t>(append_data.offset));
-				auto current_offset = append_data.offset + string_length;
-				aux_buffer.resize(current_offset);
-				ArrowVarcharConverter::WriteData(aux_buffer.data() + append_data.offset, data[source_idx]);
-				append_data.offset = current_offset;
-			}
-		}
-		append_data.row_count += size;
-	}
-
-	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
-		// We output four buffers
-		result->n_buffers = 4;
-		// Buffer 0 is the validity mask
-		// Buffer 1 is our string views (short/long strings)
-		result->buffers[1] = append_data.GetMainBuffer().data();
-		// Buffer 2 is our only data buffer, could theoretically be more [ buffers ]
-		result->buffers[2] = append_data.GetAuxBuffer().data();
-		// Buffer 3 is the data-buffer lengths buffer, and we also populate it in to finalize
-		reinterpret_cast<int64_t *>(append_data.GetBufferSizeBuffer().data())[0] =
-		    UnsafeNumericCast<int64_t>(append_data.offset);
-		result->buffers[3] = append_data.GetBufferSizeBuffer().data();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow.hpp
deleted file mode 100644
index 49bcb1d8b..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ARROW_FLAG_DICTIONARY_ORDERED
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef ARROW_C_DATA_INTERFACE
-#define ARROW_C_DATA_INTERFACE
-
-#define ARROW_FLAG_DICTIONARY_ORDERED 1
-#define ARROW_FLAG_NULLABLE           2
-#define ARROW_FLAG_MAP_KEYS_SORTED    4
-
-struct ArrowSchema {
-	//! Array type description
-	const char *format;
-	const char *name;
-	const char *metadata;
-	int64_t flags;
-	int64_t n_children;
-	struct ArrowSchema **children;
-	struct ArrowSchema *dictionary;
-
-	//! Release callback
-	void (*release)(struct ArrowSchema *);
-	//! Opaque producer-specific data
-	void *private_data;
-
-	//! Initialize all fields
-	void Init() {
-		flags = 0;
-		n_children = 0;
-		release = nullptr;
-		private_data = nullptr;
-	}
-};
-
-struct ArrowArray {
-	//! Array data description
-	int64_t length;
-	int64_t null_count;
-	int64_t offset;
-	int64_t n_buffers;
-	int64_t n_children;
-	const void **buffers;
-	struct ArrowArray **children;
-	struct ArrowArray *dictionary;
-
-	//! Release callback
-	void (*release)(struct ArrowArray *);
-	//! Opaque producer-specific data
-	void *private_data;
-
-	//! Initialize all fields
-	void Init() {
-		length = 0;
-		null_count = 0;
-		offset = 0;
-		n_buffers = 0;
-		n_children = 0;
-		release = nullptr;
-		private_data = nullptr;
-	}
-};
-#endif
-
-#ifndef ARROW_C_STREAM_INTERFACE
-#define ARROW_C_STREAM_INTERFACE
-// EXPERIMENTAL
-struct ArrowArrayStream {
-	// Callback to get the stream type
-	// (will be the same for all arrays in the stream).
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
-	// Callback to get the next array
-	// (if no error and the array is released, the stream has ended)
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
-
-	// Callback to get optional detailed error information.
-	// This must only be called if the last stream operation failed
-	// with a non-0 return code.  The returned pointer is only valid until
-	// the next operation on this stream (including release).
-	// If unavailable, NULL is returned.
-	const char *(*get_last_error)(struct ArrowArrayStream *);
-
-	// Release callback: release the stream's own resources.
-	// Note that arrays returned by `get_next` must be individually released.
-	void (*release)(struct ArrowArrayStream *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp
deleted file mode 100644
index 55a85a4aa..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_appender.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/arrow/arrow_converter.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
-
-namespace duckdb {
-
-struct ArrowAppendData;
-
-//! The ArrowAppender class can be used to incrementally construct an arrow array by appending data chunks into it
-class ArrowAppender {
-public:
-	DUCKDB_API ArrowAppender(vector<LogicalType> types_p, const idx_t initial_capacity, ClientProperties options);
-	DUCKDB_API ~ArrowAppender();
-
-public:
-	//! Append a data chunk to the underlying arrow array
-	DUCKDB_API void Append(DataChunk &input, idx_t from, idx_t to, idx_t input_size);
-	//! Returns the underlying arrow array
-	DUCKDB_API ArrowArray Finalize();
-	idx_t RowCount() const;
-	static void ReleaseArray(ArrowArray *array);
-	static ArrowArray *FinalizeChild(const LogicalType &type, unique_ptr<ArrowAppendData> append_data_p);
-	static unique_ptr<ArrowAppendData> InitializeChild(const LogicalType &type, const idx_t capacity,
-	                                                   ClientProperties &options);
-	static void AddChildren(ArrowAppendData &data, const idx_t count);
-
-private:
-	//! The types of the chunks that will be appended in
-	vector<LogicalType> types;
-	//! The root arrow append data
-	vector<unique_ptr<ArrowAppendData>> root_data;
-	//! The total row count that has been appended
-	idx_t row_count = 0;
-
-	ClientProperties options;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_buffer.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_buffer.hpp
deleted file mode 100644
index 0ff2e9fc7..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_buffer.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-struct ArrowSchema;
-
-namespace duckdb {
-
-struct ArrowBuffer {
-	static constexpr const idx_t MINIMUM_SHRINK_SIZE = 4096;
-
-	ArrowBuffer() : dataptr(nullptr), count(0), capacity(0) {
-	}
-	~ArrowBuffer() {
-		if (!dataptr) {
-			return;
-		}
-		free(dataptr);
-		dataptr = nullptr;
-		count = 0;
-		capacity = 0;
-	}
-	// disable copy constructors
-	ArrowBuffer(const ArrowBuffer &other) = delete;
-	ArrowBuffer &operator=(const ArrowBuffer &) = delete;
-	//! enable move constructors
-	ArrowBuffer(ArrowBuffer &&other) noexcept : count(0), capacity(0) {
-		std::swap(dataptr, other.dataptr);
-		std::swap(count, other.count);
-		std::swap(capacity, other.capacity);
-	}
-	ArrowBuffer &operator=(ArrowBuffer &&other) noexcept {
-		std::swap(dataptr, other.dataptr);
-		std::swap(count, other.count);
-		std::swap(capacity, other.capacity);
-		return *this;
-	}
-
-	void reserve(idx_t bytes) { // NOLINT
-		auto new_capacity = NextPowerOfTwo(bytes);
-		if (new_capacity <= capacity) {
-			return;
-		}
-		ReserveInternal(new_capacity);
-	}
-
-	void resize(idx_t bytes) { // NOLINT
-		reserve(bytes);
-		count = bytes;
-	}
-
-	void resize(idx_t bytes, data_t value) { // NOLINT
-		reserve(bytes);
-		for (idx_t i = count; i < bytes; i++) {
-			dataptr[i] = value;
-		}
-		count = bytes;
-	}
-
-	template <class T>
-	void push_back(T value) {
-		reserve(sizeof(T) * (count + 1));
-		reinterpret_cast<T *>(dataptr)[count] = value;
-		count++;
-	}
-
-	idx_t size() { // NOLINT
-		return count;
-	}
-
-	data_ptr_t data() { // NOLINT
-		return dataptr;
-	}
-
-	template <class T>
-	T *GetData() {
-		return reinterpret_cast<T *>(data());
-	}
-
-private:
-	void ReserveInternal(idx_t bytes) {
-		if (dataptr) {
-			dataptr = data_ptr_cast(realloc(dataptr, bytes));
-		} else {
-			dataptr = data_ptr_cast(malloc(bytes));
-		}
-		capacity = bytes;
-	}
-
-private:
-	data_ptr_t dataptr = nullptr;
-	idx_t count = 0;
-	idx_t capacity = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp
deleted file mode 100644
index 2f80fb4a9..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_converter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/main/client_properties.hpp"
-
-namespace duckdb {
-
-struct ArrowConverter {
-	DUCKDB_API static void ToArrowSchema(ArrowSchema *out_schema, const vector<LogicalType> &types,
-	                                     const vector<string> &names, const ClientProperties &options);
-	DUCKDB_API static void ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_merge_event.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_merge_event.hpp
deleted file mode 100644
index d6608fd7c..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_merge_event.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_merge_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/parallel/task.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/arrow/arrow_converter.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/main/chunk_scan_state/batched_data_collection.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/arrow/arrow_query_result.hpp"
-
-namespace duckdb {
-
-// Task to create one RecordBatch by (partially) scanning a BatchedDataCollection
-class ArrowBatchTask : public ExecutorTask {
-public:
-	ArrowBatchTask(ArrowQueryResult &result, vector<idx_t> record_batch_indices, Executor &executor,
-	               shared_ptr<Event> event_p, BatchCollectionChunkScanState scan_state, vector<string> names,
-	               idx_t batch_size);
-	void ProduceRecordBatches();
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
-
-private:
-	ArrowQueryResult &result;
-	vector<idx_t> record_batch_indices;
-	shared_ptr<Event> event;
-	idx_t batch_size;
-	vector<string> names;
-	BatchCollectionChunkScanState scan_state;
-};
-
-class ArrowMergeEvent : public BasePipelineEvent {
-public:
-	ArrowMergeEvent(ArrowQueryResult &result, BatchedDataCollection &batches, Pipeline &pipeline_p);
-
-public:
-	void Schedule() override;
-
-public:
-	ArrowQueryResult &result;
-	BatchedDataCollection &batches;
-
-private:
-	//! The max size of a record batch to output
-	idx_t record_batch_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp
deleted file mode 100644
index 667ae3c61..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb_python/arrow/arrow_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-
-class ArrowQueryResult : public QueryResult {
-public:
-	static constexpr const QueryResultType TYPE = QueryResultType::ARROW_RESULT;
-
-public:
-	friend class ClientContext;
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API ArrowQueryResult(StatementType statement_type, StatementProperties properties, vector<string> names_p,
-	                            vector<LogicalType> types_p, ClientProperties client_properties, idx_t batch_size);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API explicit ArrowQueryResult(ErrorData error);
-
-public:
-	//! Fetches a DataChunk from the query result.
-	//! This will consume the result (i.e. the result can only be scanned once with this function)
-	DUCKDB_API unique_ptr<DataChunk> Fetch() override;
-	DUCKDB_API unique_ptr<DataChunk> FetchRaw() override;
-	//! Converts the QueryResult to a string
-	DUCKDB_API string ToString() override;
-
-public:
-	vector<unique_ptr<ArrowArrayWrapper>> ConsumeArrays();
-	vector<unique_ptr<ArrowArrayWrapper>> &Arrays();
-	void SetArrowData(vector<unique_ptr<ArrowArrayWrapper>> arrays);
-	idx_t BatchSize() const;
-
-private:
-	vector<unique_ptr<ArrowArrayWrapper>> arrays;
-	idx_t batch_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp
deleted file mode 100644
index d49cade58..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/main/chunk_scan_state.hpp"
-#include "duckdb/main/client_properties.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/error_data.hpp"
-
-namespace duckdb {
-
-class QueryResult;
-class DataChunk;
-
-class ArrowUtil {
-public:
-	static bool TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out,
-	                          idx_t &result_count, ErrorData &error);
-	static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out);
-
-private:
-	static bool TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &out, ErrorData &error);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp
deleted file mode 100644
index 0639da539..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/helper.hpp"
-
-//! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
-namespace duckdb {
-
-class ArrowSchemaWrapper {
-public:
-	ArrowSchema arrow_schema;
-
-	ArrowSchemaWrapper() {
-		arrow_schema.release = nullptr;
-	}
-
-	~ArrowSchemaWrapper();
-};
-class ArrowArrayWrapper {
-public:
-	ArrowArray arrow_array;
-	ArrowArrayWrapper() {
-		arrow_array.length = 0;
-		arrow_array.release = nullptr;
-	}
-	ArrowArrayWrapper(ArrowArrayWrapper &&other) noexcept : arrow_array(other.arrow_array) {
-		other.arrow_array.release = nullptr;
-	}
-	~ArrowArrayWrapper();
-};
-
-class ArrowArrayStreamWrapper {
-public:
-	ArrowArrayStream arrow_array_stream;
-	int64_t number_of_rows;
-
-public:
-	void GetSchema(ArrowSchemaWrapper &schema);
-
-	virtual shared_ptr<ArrowArrayWrapper> GetNextChunk();
-
-	const char *GetError();
-
-	virtual ~ArrowArrayStreamWrapper();
-	ArrowArrayStreamWrapper() {
-		arrow_array_stream.release = nullptr;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/nanoarrow/nanoarrow.h b/src/duckdb/src/include/duckdb/common/arrow/nanoarrow/nanoarrow.h
deleted file mode 100644
index 50814d518..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/nanoarrow/nanoarrow.h
+++ /dev/null
@@ -1,462 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#ifndef NANOARROW_H_INCLUDED
-#define NANOARROW_H_INCLUDED
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "duckdb/common/arrow/arrow.hpp"
-
-namespace duckdb_nanoarrow {
-
-/// \file Arrow C Implementation
-///
-/// EXPERIMENTAL. Interface subject to change.
-
-/// \page object-model Object Model
-///
-/// Except where noted, objects are not thread-safe and clients should
-/// take care to serialize accesses to methods.
-///
-/// Because this library is intended to be vendored, it provides full type
-/// definitions and encourages clients to stack or statically allocate
-/// where convenient.
-
-/// \defgroup nanoarrow-malloc Memory management
-///
-/// Non-buffer members of a struct ArrowSchema and struct ArrowArray
-/// must be allocated using ArrowMalloc() or ArrowRealloc() and freed
-/// using ArrowFree for schemas and arrays allocated here. Buffer members
-/// are allocated using an ArrowBufferAllocator.
-
-/// \brief Allocate like malloc()
-void *ArrowMalloc(int64_t size);
-
-/// \brief Reallocate like realloc()
-void *ArrowRealloc(void *ptr, int64_t size);
-
-/// \brief Free a pointer allocated using ArrowMalloc() or ArrowRealloc().
-void ArrowFree(void *ptr);
-
-/// \brief Array buffer allocation and deallocation
-///
-/// Container for allocate, reallocate, and free methods that can be used
-/// to customize allocation and deallocation of buffers when constructing
-/// an ArrowArray.
-struct ArrowBufferAllocator {
-	/// \brief Allocate a buffer or return NULL if it cannot be allocated
-	uint8_t *(*allocate)(struct ArrowBufferAllocator *allocator, int64_t size);
-
-	/// \brief Reallocate a buffer or return NULL if it cannot be reallocated
-	uint8_t *(*reallocate)(struct ArrowBufferAllocator *allocator, uint8_t *ptr, int64_t old_size, int64_t new_size);
-
-	/// \brief Deallocate a buffer allocated by this allocator
-	void (*free)(struct ArrowBufferAllocator *allocator, uint8_t *ptr, int64_t size);
-
-	/// \brief Opaque data specific to the allocator
-	void *private_data;
-};
-
-/// \brief Return the default allocator
-///
-/// The default allocator uses ArrowMalloc(), ArrowRealloc(), and
-/// ArrowFree().
-struct ArrowBufferAllocator *ArrowBufferAllocatorDefault();
-
-/// }@
-
-/// \defgroup nanoarrow-errors Error handling primitives
-/// Functions generally return an errno-compatible error code; functions that
-/// need to communicate more verbose error information accept a pointer
-/// to an ArrowError. This can be stack or statically allocated. The
-/// content of the message is undefined unless an error code has been
-/// returned.
-
-/// \brief Error type containing a UTF-8 encoded message.
-struct ArrowError {
-	char message[1024];
-};
-
-/// \brief Return code for success.
-#define NANOARROW_OK 0
-
-/// \brief Represents an errno-compatible error code
-typedef int ArrowErrorCode;
-
-/// \brief Set the contents of an error using printf syntax
-ArrowErrorCode ArrowErrorSet(struct ArrowError *error, const char *fmt, ...);
-
-/// \brief Get the contents of an error
-const char *ArrowErrorMessage(struct ArrowError *error);
-
-/// }@
-
-/// \defgroup nanoarrow-utils Utility data structures
-
-/// \brief An non-owning view of a string
-struct ArrowStringView {
-	/// \brief A pointer to the start of the string
-	///
-	/// If n_bytes is 0, this value may be NULL.
-	const char *data;
-
-	/// \brief The size of the string in bytes,
-	///
-	/// (Not including the null terminator.)
-	int64_t n_bytes;
-};
-
-/// \brief Arrow type enumerator
-///
-/// These names are intended to map to the corresponding arrow::Type::type
-/// enumerator; however, the numeric values are specifically not equal
-/// (i.e., do not rely on numeric comparison).
-enum ArrowType {
-	NANOARROW_TYPE_UNINITIALIZED = 0,
-	NANOARROW_TYPE_NA = 1,
-	NANOARROW_TYPE_BOOL,
-	NANOARROW_TYPE_UINT8,
-	NANOARROW_TYPE_INT8,
-	NANOARROW_TYPE_UINT16,
-	NANOARROW_TYPE_INT16,
-	NANOARROW_TYPE_UINT32,
-	NANOARROW_TYPE_INT32,
-	NANOARROW_TYPE_UINT64,
-	NANOARROW_TYPE_INT64,
-	NANOARROW_TYPE_HALF_FLOAT,
-	NANOARROW_TYPE_FLOAT,
-	NANOARROW_TYPE_DOUBLE,
-	NANOARROW_TYPE_STRING,
-	NANOARROW_TYPE_BINARY,
-	NANOARROW_TYPE_FIXED_SIZE_BINARY,
-	NANOARROW_TYPE_DATE32,
-	NANOARROW_TYPE_DATE64,
-	NANOARROW_TYPE_TIMESTAMP,
-	NANOARROW_TYPE_TIME32,
-	NANOARROW_TYPE_TIME64,
-	NANOARROW_TYPE_INTERVAL_MONTHS,
-	NANOARROW_TYPE_INTERVAL_DAY_TIME,
-	NANOARROW_TYPE_DECIMAL128,
-	NANOARROW_TYPE_DECIMAL256,
-	NANOARROW_TYPE_LIST,
-	NANOARROW_TYPE_STRUCT,
-	NANOARROW_TYPE_SPARSE_UNION,
-	NANOARROW_TYPE_DENSE_UNION,
-	NANOARROW_TYPE_DICTIONARY,
-	NANOARROW_TYPE_MAP,
-	NANOARROW_TYPE_EXTENSION,
-	NANOARROW_TYPE_FIXED_SIZE_LIST,
-	NANOARROW_TYPE_DURATION,
-	NANOARROW_TYPE_LARGE_STRING,
-	NANOARROW_TYPE_LARGE_BINARY,
-	NANOARROW_TYPE_LARGE_LIST,
-	NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO
-};
-
-/// \brief Arrow time unit enumerator
-///
-/// These names and values map to the corresponding arrow::TimeUnit::type
-/// enumerator.
-enum ArrowTimeUnit {
-	NANOARROW_TIME_UNIT_SECOND = 0,
-	NANOARROW_TIME_UNIT_MILLI = 1,
-	NANOARROW_TIME_UNIT_MICRO = 2,
-	NANOARROW_TIME_UNIT_NANO = 3
-};
-
-/// }@
-
-/// \defgroup nanoarrow-schema Schema producer helpers
-/// These functions allocate, copy, and destroy ArrowSchema structures
-
-/// \brief Initialize the fields of a schema
-///
-/// Initializes the fields and release callback of schema_out. Caller
-/// is responsible for calling the schema->release callback if
-/// NANOARROW_OK is returned.
-ArrowErrorCode ArrowSchemaInit(struct ArrowSchema *schema, enum ArrowType type);
-
-/// \brief Initialize the fields of a fixed-size schema
-///
-/// Returns EINVAL for fixed_size <= 0 or for data_type that is not
-/// NANOARROW_TYPE_FIXED_SIZE_BINARY or NANOARROW_TYPE_FIXED_SIZE_LIST.
-ArrowErrorCode ArrowSchemaInitFixedSize(struct ArrowSchema *schema, enum ArrowType data_type, int32_t fixed_size);
-
-/// \brief Initialize the fields of a decimal schema
-///
-/// Returns EINVAL for scale <= 0 or for data_type that is not
-/// NANOARROW_TYPE_DECIMAL128 or NANOARROW_TYPE_DECIMAL256.
-ArrowErrorCode ArrowSchemaInitDecimal(struct ArrowSchema *schema, enum ArrowType data_type, int32_t decimal_precision,
-                                      int32_t decimal_scale);
-
-/// \brief Initialize the fields of a time, timestamp, or duration schema
-///
-/// Returns EINVAL for data_type that is not
-/// NANOARROW_TYPE_TIME32, NANOARROW_TYPE_TIME64,
-/// NANOARROW_TYPE_TIMESTAMP, or NANOARROW_TYPE_DURATION. The
-/// timezone parameter must be NULL for a non-timestamp data_type.
-ArrowErrorCode ArrowSchemaInitDateTime(struct ArrowSchema *schema, enum ArrowType data_type,
-                                       enum ArrowTimeUnit time_unit, const char *timezone);
-
-/// \brief Make a (recursive) copy of a schema
-///
-/// Allocates and copies fields of schema into schema_out.
-ArrowErrorCode ArrowSchemaDeepCopy(struct ArrowSchema *schema, struct ArrowSchema *schema_out);
-
-/// \brief Copy format into schema->format
-///
-/// schema must have been allocated using ArrowSchemaInit or
-/// ArrowSchemaDeepCopy.
-ArrowErrorCode ArrowSchemaSetFormat(struct ArrowSchema *schema, const char *format);
-
-/// \brief Copy name into schema->name
-///
-/// schema must have been allocated using ArrowSchemaInit or
-/// ArrowSchemaDeepCopy.
-ArrowErrorCode ArrowSchemaSetName(struct ArrowSchema *schema, const char *name);
-
-/// \brief Copy metadata into schema->metadata
-///
-/// schema must have been allocated using ArrowSchemaInit or
-/// ArrowSchemaDeepCopy.
-ArrowErrorCode ArrowSchemaSetMetadata(struct ArrowSchema *schema, const char *metadata);
-
-/// \brief Allocate the schema->children array
-///
-/// Includes the memory for each child struct ArrowSchema.
-/// schema must have been allocated using ArrowSchemaInit or
-/// ArrowSchemaDeepCopy.
-ArrowErrorCode ArrowSchemaAllocateChildren(struct ArrowSchema *schema, int64_t n_children);
-
-/// \brief Allocate the schema->dictionary member
-///
-/// schema must have been allocated using ArrowSchemaInit or
-/// ArrowSchemaDeepCopy.
-ArrowErrorCode ArrowSchemaAllocateDictionary(struct ArrowSchema *schema);
-
-/// \brief Reader for key/value pairs in schema metadata
-struct ArrowMetadataReader {
-	const char *metadata;
-	int64_t offset;
-	int32_t remaining_keys;
-};
-
-/// \brief Initialize an ArrowMetadataReader
-ArrowErrorCode ArrowMetadataReaderInit(struct ArrowMetadataReader *reader, const char *metadata);
-
-/// \brief Read the next key/value pair from an ArrowMetadataReader
-ArrowErrorCode ArrowMetadataReaderRead(struct ArrowMetadataReader *reader, struct ArrowStringView *key_out,
-                                       struct ArrowStringView *value_out);
-
-/// \brief The number of bytes in in a key/value metadata string
-int64_t ArrowMetadataSizeOf(const char *metadata);
-
-/// \brief Check for a key in schema metadata
-char ArrowMetadataHasKey(const char *metadata, const char *key);
-
-/// \brief Extract a value from schema metadata
-ArrowErrorCode ArrowMetadataGetValue(const char *metadata, const char *key, const char *default_value,
-                                     struct ArrowStringView *value_out);
-
-/// }@
-
-/// \defgroup nanoarrow-schema-view Schema consumer helpers
-
-/// \brief A non-owning view of a parsed ArrowSchema
-///
-/// Contains more readily extractable values than a raw ArrowSchema.
-/// Clients can stack or statically allocate this structure but are
-/// encouraged to use the provided getters to ensure forward
-/// compatiblity.
-struct ArrowSchemaView {
-	/// \brief A pointer to the schema represented by this view
-	struct ArrowSchema *schema;
-
-	/// \brief The data type represented by the schema
-	///
-	/// This value may be NANOARROW_TYPE_DICTIONARY if the schema has a
-	/// non-null dictionary member; datetime types are valid values.
-	/// This value will never be NANOARROW_TYPE_EXTENSION (see
-	/// extension_name and/or extension_metadata to check for
-	/// an extension type).
-	enum ArrowType data_type;
-
-	/// \brief The storage data type represented by the schema
-	///
-	/// This value will never be NANOARROW_TYPE_DICTIONARY, NANOARROW_TYPE_EXTENSION
-	/// or any datetime type. This value represents only the type required to
-	/// interpret the buffers in the array.
-	enum ArrowType storage_data_type;
-
-	/// \brief The extension type name if it exists
-	///
-	/// If the ARROW:extension:name key is present in schema.metadata,
-	/// extension_name.data will be non-NULL.
-	struct ArrowStringView extension_name;
-
-	/// \brief The extension type metadata if it exists
-	///
-	/// If the ARROW:extension:metadata key is present in schema.metadata,
-	/// extension_metadata.data will be non-NULL.
-	struct ArrowStringView extension_metadata;
-
-	/// \brief The expected number of buffers in a paired ArrowArray
-	int32_t n_buffers;
-
-	/// \brief The index of the validity buffer or -1 if one does not exist
-	int32_t validity_buffer_id;
-
-	/// \brief The index of the offset buffer or -1 if one does not exist
-	int32_t offset_buffer_id;
-
-	/// \brief The index of the data buffer or -1 if one does not exist
-	int32_t data_buffer_id;
-
-	/// \brief The index of the type_ids buffer or -1 if one does not exist
-	int32_t type_id_buffer_id;
-
-	/// \brief Format fixed size parameter
-	///
-	/// This value is set when parsing a fixed-size binary or fixed-size
-	/// list schema; this value is undefined for other types. For a
-	/// fixed-size binary schema this value is in bytes; for a fixed-size
-	/// list schema this value refers to the number of child elements for
-	/// each element of the parent.
-	int32_t fixed_size;
-
-	/// \brief Decimal bitwidth
-	///
-	/// This value is set when parsing a decimal type schema;
-	/// this value is undefined for other types.
-	int32_t decimal_bitwidth;
-
-	/// \brief Decimal precision
-	///
-	/// This value is set when parsing a decimal type schema;
-	/// this value is undefined for other types.
-	int32_t decimal_precision;
-
-	/// \brief Decimal scale
-	///
-	/// This value is set when parsing a decimal type schema;
-	/// this value is undefined for other types.
-	int32_t decimal_scale;
-
-	/// \brief Format time unit parameter
-	///
-	/// This value is set when parsing a date/time type. The value is
-	/// undefined for other types.
-	enum ArrowTimeUnit time_unit;
-
-	/// \brief Format timezone parameter
-	///
-	/// This value is set when parsing a timestamp type and represents
-	/// the timezone format parameter. The ArrowStrintgView points to
-	/// data within the schema and the value is undefined for other types.
-	struct ArrowStringView timezone;
-
-	/// \brief Union type ids parameter
-	///
-	/// This value is set when parsing a union type and represents
-	/// type ids parameter. The ArrowStringView points to
-	/// data within the schema and the value is undefined for other types.
-	struct ArrowStringView union_type_ids;
-};
-
-/// \brief Initialize an ArrowSchemaView
-ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView *schema_view, struct ArrowSchema *schema,
-                                   struct ArrowError *error);
-
-/// }@
-
-/// \defgroup nanoarrow-buffer-builder Growable buffer builders
-
-/// \brief An owning mutable view of a buffer
-struct ArrowBuffer {
-	/// \brief A pointer to the start of the buffer
-	///
-	/// If capacity_bytes is 0, this value may be NULL.
-	uint8_t *data;
-
-	/// \brief The size of the buffer in bytes
-	int64_t size_bytes;
-
-	/// \brief The capacity of the buffer in bytes
-	int64_t capacity_bytes;
-
-	/// \brief The allocator that will be used to reallocate and/or free the buffer
-	struct ArrowBufferAllocator *allocator;
-};
-
-/// \brief Initialize an ArrowBuffer
-///
-/// Initialize a buffer with a NULL, zero-size buffer using the default
-/// buffer allocator.
-void ArrowBufferInit(struct ArrowBuffer *buffer);
-
-/// \brief Set a newly-initialized buffer's allocator
-///
-/// Returns EINVAL if the buffer has already been allocated.
-ArrowErrorCode ArrowBufferSetAllocator(struct ArrowBuffer *buffer, struct ArrowBufferAllocator *allocator);
-
-/// \brief Reset an ArrowBuffer
-///
-/// Releases the buffer using the allocator's free method if
-/// the buffer's data member is non-null, sets the data member
-/// to NULL, and sets the buffer's size and capacity to 0.
-void ArrowBufferReset(struct ArrowBuffer *buffer);
-
-/// \brief Move an ArrowBuffer
-///
-/// Transfers the buffer data and lifecycle management to another
-/// address and resets buffer.
-void ArrowBufferMove(struct ArrowBuffer *buffer, struct ArrowBuffer *buffer_out);
-
-/// \brief Grow or shrink a buffer to a given capacity
-///
-/// When shrinking the capacity of the buffer, the buffer is only reallocated
-/// if shrink_to_fit is non-zero. Calling ArrowBufferResize() does not
-/// adjust the buffer's size member except to ensure that the invariant
-/// capacity >= size remains true.
-ArrowErrorCode ArrowBufferResize(struct ArrowBuffer *buffer, int64_t new_capacity_bytes, char shrink_to_fit);
-
-/// \brief Ensure a buffer has at least a given additional capacity
-///
-/// Ensures that the buffer has space to append at least
-/// additional_size_bytes, overallocating when required.
-ArrowErrorCode ArrowBufferReserve(struct ArrowBuffer *buffer, int64_t additional_size_bytes);
-
-/// \brief Write data to buffer and increment the buffer size
-///
-/// This function does not check that buffer has the required capacity
-void ArrowBufferAppendUnsafe(struct ArrowBuffer *buffer, const void *data, int64_t size_bytes);
-
-/// \brief Write data to buffer and increment the buffer size
-///
-/// This function writes and ensures that the buffer has the required capacity,
-/// possibly by reallocating the buffer. Like ArrowBufferReserve, this will
-/// overallocate when reallocation is required.
-ArrowErrorCode ArrowBufferAppend(struct ArrowBuffer *buffer, const void *data, int64_t size_bytes);
-
-/// }@
-
-} // namespace duckdb_nanoarrow
-
-#endif // NANOARROW_H_INCLUDED
diff --git a/src/duckdb/src/include/duckdb/common/arrow/nanoarrow/nanoarrow.hpp b/src/duckdb/src/include/duckdb/common/arrow/nanoarrow/nanoarrow.hpp
deleted file mode 100644
index d939badaf..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/nanoarrow/nanoarrow.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "duckdb/common/arrow/nanoarrow/nanoarrow.h"
-
-// Bring in the symbols from duckdb_nanoarrow into duckdb
-namespace duckdb {
-
-// using duckdb_nanoarrow::ArrowBuffer; //We have a variant of this that should be renamed
-using duckdb_nanoarrow::ArrowBufferAllocator;
-using duckdb_nanoarrow::ArrowError;
-using duckdb_nanoarrow::ArrowSchemaView;
-using duckdb_nanoarrow::ArrowStringView;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/physical_arrow_batch_collector.hpp b/src/duckdb/src/include/duckdb/common/arrow/physical_arrow_batch_collector.hpp
deleted file mode 100644
index 1fb162356..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/physical_arrow_batch_collector.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include "duckdb/execution/operator/helper/physical_batch_collector.hpp"
-
-namespace duckdb {
-
-class ArrowBatchGlobalState : public BatchCollectorGlobalState {
-public:
-	ArrowBatchGlobalState(ClientContext &context, const PhysicalBatchCollector &op)
-	    : BatchCollectorGlobalState(context, op) {
-	}
-};
-
-class PhysicalArrowBatchCollector : public PhysicalBatchCollector {
-public:
-	PhysicalArrowBatchCollector(PreparedStatementData &data, idx_t batch_size)
-	    : PhysicalBatchCollector(data), record_batch_size(batch_size) {
-	}
-
-public:
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-public:
-	//! User provided batch size
-	idx_t record_batch_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/physical_arrow_collector.hpp b/src/duckdb/src/include/duckdb/common/arrow/physical_arrow_collector.hpp
deleted file mode 100644
index cf58941aa..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/physical_arrow_collector.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#pragma once
-
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/execution/physical_operator_states.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/arrow/arrow_appender.hpp"
-
-namespace duckdb {
-
-struct ArrowCollectorGlobalState : public GlobalSinkState {
-public:
-	//! The result returned by GetResult
-	unique_ptr<QueryResult> result;
-	vector<unique_ptr<ArrowArrayWrapper>> chunks;
-	mutex glock;
-	shared_ptr<ClientContext> context;
-	idx_t tuple_count = 0;
-};
-
-struct ArrowCollectorLocalState : public LocalSinkState {
-public:
-	// The appender for the current chunk we're creating
-	unique_ptr<ArrowAppender> appender;
-	vector<unique_ptr<ArrowArrayWrapper>> finished_arrays;
-	idx_t tuple_count = 0;
-
-public:
-	void FinishArray() {
-		auto finished_array = make_uniq<ArrowArrayWrapper>();
-		auto row_count = appender->RowCount();
-		finished_array->arrow_array = appender->Finalize();
-		appender.reset();
-		finished_arrays.push_back(std::move(finished_array));
-		tuple_count += row_count;
-	}
-};
-
-class PhysicalArrowCollector : public PhysicalResultCollector {
-public:
-	PhysicalArrowCollector(PreparedStatementData &data, bool parallel, idx_t batch_size)
-	    : PhysicalResultCollector(data), record_batch_size(batch_size), parallel(parallel) {
-	}
-
-public:
-	static unique_ptr<PhysicalResultCollector> Create(ClientContext &context, PreparedStatementData &data,
-	                                                  idx_t batch_size);
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	bool ParallelSink() const override;
-	bool SinkOrderDependent() const override;
-
-public:
-	//! User provided batch size
-	idx_t record_batch_size;
-	bool parallel;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp b/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp
deleted file mode 100644
index f82e472dd..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/result_arrow_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/main/chunk_scan_state.hpp"
-
-namespace duckdb {
-class ResultArrowArrayStreamWrapper {
-public:
-	explicit ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result, idx_t batch_size);
-
-public:
-	ArrowArrayStream stream;
-	unique_ptr<QueryResult> result;
-	ErrorData last_error;
-	idx_t batch_size;
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	unique_ptr<ChunkScanState> scan_state;
-
-private:
-	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);
-	static int MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out);
-	static void MyStreamRelease(struct ArrowArrayStream *stream);
-	static const char *MyStreamGetLastError(struct ArrowArrayStream *stream);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp b/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp
deleted file mode 100644
index 833d455a8..000000000
--- a/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/schema_metadata.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/main/chunk_scan_state.hpp"
-
-namespace duckdb {
-class ArrowSchemaMetadata {
-public:
-	//! Constructor used to read a metadata schema, used when importing an arrow object
-	explicit ArrowSchemaMetadata(const char *metadata);
-	//! Constructor used to create a metadata schema, used when exporting an arrow object
-	ArrowSchemaMetadata() {};
-	//! Adds an option to the metadata
-	void AddOption(const string &key, const string &value);
-	//! Gets an option from the metadata, returns an empty string if it does not exist.
-	string GetOption(const string &key) const;
-	//! Transforms metadata to a char*, used when creating an arrow object
-	unsafe_unique_array<char> SerializeMetadata() const;
-	//! If the arrow extension is set
-	bool HasExtension() const;
-	//! If this extension type is an 'arrow.opaque', and the internal type and vendors match.
-	bool IsNonCanonicalType(const string &type, const string &vendor = "DuckDB") const;
-	//! Get the extension name if set, otherwise returns empty
-	string GetExtensionName() const;
-	//! Key for encode of the extension type name
-	static constexpr const char *ARROW_EXTENSION_NAME = "ARROW:extension:name";
-	//! Key for encode of the metadata key
-	static constexpr const char *ARROW_METADATA_KEY = "ARROW:extension:metadata";
-	//! Arrow Extension for non-canonical types.
-	static constexpr const char *ARROW_EXTENSION_NON_CANONICAL = "arrow.opaque";
-	//! Creates the metadata based on an extension name
-	static ArrowSchemaMetadata ArrowCanonicalType(const string &extension_name);
-	//! Creates the metadata based on an extension name
-	static ArrowSchemaMetadata DuckDBInternalType(const string &type_name);
-
-private:
-	//! The unordered map that holds the metadata
-	unordered_map<string, string> schema_metadata_map;
-	//! The extension metadata map, currently only used for internal types in arrow.opaque
-	unordered_map<string, string> extension_metadata_map;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/assert.hpp b/src/duckdb/src/include/duckdb/common/assert.hpp
deleted file mode 100644
index 916f5c1c7..000000000
--- a/src/duckdb/src/include/duckdb/common/assert.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/assert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/winapi.hpp"
-
-#pragma once
-
-// clang-format off
-#if ( \
-    /* Not a debug build */ \
-    !defined(DEBUG) && \
-    /* FORCE_ASSERT is not set (enables assertions even on release mode when set to true) */ \
-    !defined(DUCKDB_FORCE_ASSERT) && \
-    /* The project is not compiled for Microsoft Visual Studio */ \
-    !defined(__MVS__) \
-)
-// clang-format on
-
-//! On most builds, NDEBUG is defined, turning the assert call into a NO-OP
-//! Only the 'else' condition is supposed to check the assertions
-#include <assert.h>
-#define D_ASSERT assert
-namespace duckdb {
-DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);
-}
-
-#else
-namespace duckdb {
-DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);
-}
-
-#define D_ASSERT(condition) duckdb::DuckDBAssertInternal(bool(condition), #condition, __FILE__, __LINE__)
-
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/atomic.hpp b/src/duckdb/src/include/duckdb/common/atomic.hpp
deleted file mode 100644
index e86e6a69b..000000000
--- a/src/duckdb/src/include/duckdb/common/atomic.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/atomic.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <atomic>
-
-namespace duckdb {
-
-using std::atomic;
-
-//! NOTE: When repeatedly trying to atomically set a value in a loop, you can use as the loop condition:
-//! * std::atomic_compare_exchange_weak
-//! * std::atomic::compare_exchange_weak
-//! If not used as a loop condition, use:
-//! * std::atomic_compare_exchange_strong
-//! * std::atomic::compare_exchange_strong
-//! If this is not done correctly, we may get correctness issues when using older compiler versions (see: issue #14389)
-//! Performance may be optimized using std::memory_order, but NOT at the cost of correctness.
-//! For correct examples of this, see concurrentqueue.h
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/atomic_ptr.hpp b/src/duckdb/src/include/duckdb/common/atomic_ptr.hpp
deleted file mode 100644
index da2281d87..000000000
--- a/src/duckdb/src/include/duckdb/common/atomic_ptr.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/atomic_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-namespace duckdb {
-
-template <class T, bool SAFE = true>
-class atomic_ptr { // NOLINT: mimic std casing
-public:
-	atomic_ptr() noexcept : ptr(nullptr) {
-	}
-	atomic_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
-	}
-	atomic_ptr(T &ref) : ptr(&ref) { // NOLINT: allow implicit creation from reference
-	}
-	atomic_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
-	}
-	atomic_ptr(const shared_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from shared pointer
-	}
-
-	void CheckValid(const T *ptr) const {
-		if (MemorySafety<SAFE>::ENABLED) {
-			return;
-		}
-		if (!ptr) {
-			throw InternalException("Attempting to dereference an optional pointer that is not set");
-		}
-	}
-
-	T *GetPointer() {
-		auto res = ptr.load();
-		CheckValid(res);
-		return res;
-	}
-
-	const T *GetPointer() const {
-		auto res = ptr.load();
-		CheckValid(res);
-		return res;
-	}
-
-	operator bool() const { // NOLINT: allow implicit conversion to bool
-		return ptr;
-	}
-	T &operator*() {
-		return *GetPointer();
-	}
-	const T &operator*() const {
-		return *GetPointer();
-	}
-	T *operator->() {
-		return GetPointer();
-	}
-	const T *operator->() const {
-		return GetPointer();
-	}
-	T *get() { // NOLINT: mimic std casing
-		return GetPointer();
-	}
-	const T *get() const { // NOLINT: mimic std casing
-		return GetPointer();
-	}
-	// this looks dirty - but this is the default behavior of raw pointers
-	T *get_mutable() const { // NOLINT: mimic std casing
-		return GetPointer();
-	}
-
-	void set(T &ref) {
-		ptr = &ref;
-	}
-
-	void reset() {
-		ptr = nullptr;
-	}
-
-	bool operator==(const atomic_ptr<T> &rhs) const {
-		return ptr.load() == rhs.ptr.load();
-	}
-
-	bool operator!=(const atomic_ptr<T> &rhs) const {
-		return ptr.load() != rhs.ptr.load();
-	}
-
-private:
-	atomic<T *> ptr;
-};
-
-template <typename T>
-using unsafe_atomic_ptr = atomic_ptr<T, false>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/bind_helpers.hpp b/src/duckdb/src/include/duckdb/common/bind_helpers.hpp
deleted file mode 100644
index 992047628..000000000
--- a/src/duckdb/src/include/duckdb/common/bind_helpers.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bind_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-class Value;
-
-Value ConvertVectorToValue(vector<Value> set);
-vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &option_name);
-vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &option_name);
-vector<idx_t> ParseColumnsOrdered(const vector<Value> &set, vector<string> &names, const string &loption);
-vector<idx_t> ParseColumnsOrdered(const Value &value, vector<string> &names, const string &loption);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/bit_utils.hpp b/src/duckdb/src/include/duckdb/common/bit_utils.hpp
deleted file mode 100644
index 766e951e9..000000000
--- a/src/duckdb/src/include/duckdb/common/bit_utils.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bit_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct CountZeros {};
-
-template <>
-struct CountZeros<uint64_t> {
-	// see here: https://en.wikipedia.org/wiki/De_Bruijn_sequence
-	inline static idx_t Leading(const uint64_t value_in) {
-		if (!value_in) {
-			return 64;
-		}
-
-		uint64_t value = value_in;
-
-		constexpr uint64_t index64msb[] = {0,  47, 1,  56, 48, 27, 2,  60, 57, 49, 41, 37, 28, 16, 3,  61,
-		                                   54, 58, 35, 52, 50, 42, 21, 44, 38, 32, 29, 23, 17, 11, 4,  62,
-		                                   46, 55, 26, 59, 40, 36, 15, 53, 34, 51, 20, 43, 31, 22, 10, 45,
-		                                   25, 39, 14, 33, 19, 30, 9,  24, 13, 18, 8,  12, 7,  6,  5,  63};
-
-		constexpr uint64_t debruijn64msb = 0X03F79D71B4CB0A89;
-
-		value |= value >> 1;
-		value |= value >> 2;
-		value |= value >> 4;
-		value |= value >> 8;
-		value |= value >> 16;
-		value |= value >> 32;
-		auto result = 63 - index64msb[(value * debruijn64msb) >> 58];
-#ifdef __clang__
-		D_ASSERT(result == static_cast<uint64_t>(__builtin_clzl(value_in)));
-#endif
-		return result;
-	}
-	inline static idx_t Trailing(uint64_t value_in) {
-		if (!value_in) {
-			return 64;
-		}
-		uint64_t value = value_in;
-
-		constexpr uint64_t index64lsb[] = {63, 0,  58, 1,  59, 47, 53, 2,  60, 39, 48, 27, 54, 33, 42, 3,
-		                                   61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4,
-		                                   62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
-		                                   56, 45, 25, 31, 35, 16, 9,  12, 44, 24, 15, 8,  23, 7,  6,  5};
-		constexpr uint64_t debruijn64lsb = 0x07EDD5E59A4E28C2ULL;
-		auto result = index64lsb[((value & -value) * debruijn64lsb) >> 58];
-#ifdef __clang__
-		D_ASSERT(result == static_cast<uint64_t>(__builtin_ctzl(value_in)));
-#endif
-		return result;
-	}
-};
-
-template <>
-struct CountZeros<uint32_t> {
-	inline static idx_t Leading(uint32_t value) {
-		return CountZeros<uint64_t>::Leading(static_cast<uint64_t>(value)) - 32;
-	}
-	inline static idx_t Trailing(uint32_t value) {
-		return CountZeros<uint64_t>::Trailing(static_cast<uint64_t>(value));
-	}
-};
-
-template <>
-struct CountZeros<hugeint_t> {
-	inline static idx_t Leading(hugeint_t value) {
-		const uint64_t upper = static_cast<uint64_t>(value.upper);
-		const uint64_t lower = value.lower;
-
-		if (upper) {
-			return CountZeros<uint64_t>::Leading(upper);
-		} else if (lower) {
-			return 64 + CountZeros<uint64_t>::Leading(lower);
-		} else {
-			return 128;
-		}
-	}
-
-	inline static idx_t Trailing(hugeint_t value) {
-		const uint64_t upper = static_cast<uint64_t>(value.upper);
-		const uint64_t lower = value.lower;
-
-		if (lower) {
-			return CountZeros<uint64_t>::Trailing(lower);
-		} else if (upper) {
-			return 64 + CountZeros<uint64_t>::Trailing(upper);
-		} else {
-			return 128;
-		}
-	}
-};
-
-template <>
-struct CountZeros<uhugeint_t> {
-	inline static idx_t Leading(uhugeint_t value) {
-		const uint64_t upper = static_cast<uint64_t>(value.upper);
-		const uint64_t lower = value.lower;
-
-		if (upper) {
-			return CountZeros<uint64_t>::Leading(upper);
-		} else if (lower) {
-			return 64 + CountZeros<uint64_t>::Leading(lower);
-		} else {
-			return 128;
-		}
-	}
-
-	inline static idx_t Trailing(uhugeint_t value) {
-		const uint64_t upper = static_cast<uint64_t>(value.upper);
-		const uint64_t lower = value.lower;
-
-		if (lower) {
-			return CountZeros<uint64_t>::Trailing(lower);
-		} else if (upper) {
-			return 64 + CountZeros<uint64_t>::Trailing(upper);
-		} else {
-			return 128;
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/bitpacking.hpp b/src/duckdb/src/include/duckdb/common/bitpacking.hpp
deleted file mode 100644
index 06d12882a..000000000
--- a/src/duckdb/src/include/duckdb/common/bitpacking.hpp
+++ /dev/null
@@ -1,259 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bitpacking.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "bitpackinghelpers.h"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-using bitpacking_width_t = uint8_t;
-
-struct HugeIntPacker {
-	static void Pack(const uhugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width);
-	static void Unpack(const uint32_t *__restrict in, uhugeint_t *__restrict out, bitpacking_width_t width);
-};
-
-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;
-
-	// To ensure enough data is available, use GetRequiredSize() to determine the correct size for dst buffer
-	// Note: input should be aligned to BITPACKING_ALGORITHM_GROUP_SIZE for good performance.
-	template <class T, bool ASSUME_INPUT_ALIGNED = false>
-	inline static void PackBuffer(data_ptr_t dst, T *src, idx_t count, bitpacking_width_t width) {
-		if (ASSUME_INPUT_ALIGNED) {
-			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
-				PackGroup<T>(dst + (i * width) / 8, src + i, width);
-			}
-		} else {
-			idx_t misaligned_count = count % BITPACKING_ALGORITHM_GROUP_SIZE;
-			count -= misaligned_count;
-			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
-				PackGroup<T>(dst + (i * width) / 8, src + i, width);
-			}
-
-			// The input is not aligned to BITPACKING_ALGORITHM_GROUP_SIZE.
-			// Copy the unaligned count into a zero-initialized temporary group, and pack it.
-			if (misaligned_count) {
-				T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE] = {0};
-				memcpy(tmp_buffer, src + count, misaligned_count * sizeof(T));
-				PackGroup<T>(dst + (count * width) / 8, tmp_buffer, width);
-			}
-		}
-	}
-
-	// Unpacks a block of BITPACKING_ALGORITHM_GROUP_SIZE values
-	// Assumes both src and dst to be of the correct size
-	template <class T>
-	inline static void UnPackBuffer(data_ptr_t dst, data_ptr_t src, idx_t count, bitpacking_width_t width,
-	                                bool skip_sign_extension = false) {
-
-		for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
-			UnPackGroup<T>(dst + i * sizeof(T), src + (i * width) / 8, width, skip_sign_extension);
-		}
-	}
-
-	// 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, bool is_signed = NumericLimits<T>::IsSigned()>
-	inline static bitpacking_width_t MinimumBitWidth(T value) {
-		return FindMinimumBitWidth<T, is_signed, BYTE_ALIGNED>(value, value);
-	}
-
-	// Calculates the minimum required number of bits per value that can store all values
-	template <class T, bool is_signed = NumericLimits<T>::IsSigned()>
-	inline static bitpacking_width_t MinimumBitWidth(T *values, idx_t count) {
-		return FindMinimumBitWidth<T, is_signed, BYTE_ALIGNED>(values, count);
-	}
-
-	// Calculates the minimum required number of bits per value that can store all values,
-	// given a predetermined minimum and maximum value of the buffer
-	template <class T, bool is_signed = NumericLimits<T>::IsSigned()>
-	inline static bitpacking_width_t MinimumBitWidth(T minimum, T maximum) {
-		return FindMinimumBitWidth<T, is_signed, BYTE_ALIGNED>(minimum, maximum);
-	}
-
-	inline static idx_t GetRequiredSize(idx_t count, bitpacking_width_t width) {
-		count = RoundUpToAlgorithmGroupSize(count);
-		return ((count * width) / 8);
-	}
-
-	template <class T>
-	inline static T RoundUpToAlgorithmGroupSize(T num_to_round) {
-		int remainder = num_to_round % BITPACKING_ALGORITHM_GROUP_SIZE;
-		if (remainder == 0) {
-			return num_to_round;
-		}
-
-		return num_to_round + BITPACKING_ALGORITHM_GROUP_SIZE - NumericCast<idx_t>(remainder);
-	}
-
-private:
-	template <class T, bool is_signed, 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 (is_signed) {
-				if (values[i] < min_value) {
-					min_value = values[i];
-				}
-			}
-		}
-
-		return FindMinimumBitWidth<T, is_signed, round_to_next_byte>(min_value, max_value);
-	}
-
-	template <class T, bool is_signed, bool round_to_next_byte = false>
-	static bitpacking_width_t FindMinimumBitWidth(T min_value, T max_value) {
-		bitpacking_width_t bitwidth;
-		T value;
-
-		if (is_signed) {
-			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 {
-				value = MaxValue((T)-min_value, max_value);
-			}
-		} else {
-			value = max_value;
-		}
-
-		if (value == 0) {
-			return 0;
-		}
-
-		if (is_signed) {
-			bitwidth = 1;
-		} else {
-			bitwidth = 0;
-		}
-
-		while (value) {
-			bitwidth++;
-			value >>= 1;
-		}
-
-		bitwidth = GetEffectiveWidth<T>(bitwidth);
-
-		// Assert results are correct
-#ifdef DEBUG
-		if (bitwidth < sizeof(T) * 8 && bitwidth != 0) {
-			if (is_signed) {
-				D_ASSERT(max_value <= (T(1) << (bitwidth - 1)) - 1);
-				// D_ASSERT(min_value >= (T(-1) * ((T(1) << (bitwidth - 1)) - 1) - 1));
-			} else {
-				D_ASSERT(max_value <= (T(1) << (bitwidth)) - 1);
-			}
-		}
-#endif
-		if (round_to_next_byte) {
-			return (bitwidth / 8 + (bitwidth % 8 != 0)) * 8;
-		}
-		return bitwidth;
-	}
-
-	// Sign bit extension
-	template <class T, class T_U = typename MakeUnsigned<T>::type>
-	static void SignExtend(data_ptr_t dst, bitpacking_width_t width) {
-		T const mask = UnsafeNumericCast<T>(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 = UnsafeNumericCast<T>(T_U(value) & ((T_U(1) << width) - T_U(1)));
-			T result = (value ^ mask) - mask;
-			Store(result, dst + i * sizeof(T));
-		}
-	}
-
-	// Prevent compression at widths that are ineffective
-	template <class T>
-	static bitpacking_width_t GetEffectiveWidth(bitpacking_width_t width) {
-		bitpacking_width_t bits_of_type = sizeof(T) * 8;
-		bitpacking_width_t type_size = sizeof(T);
-		if (width + type_size > bits_of_type) {
-			return bits_of_type;
-		}
-		return width;
-	}
-
-	template <class T>
-	static inline void PackGroup(data_ptr_t dst, T *values, bitpacking_width_t width) {
-		if (std::is_same<T, int8_t>::value || std::is_same<T, uint8_t>::value) {
-			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint8_t *>(values), reinterpret_cast<uint8_t *>(dst),
-			                             static_cast<uint32_t>(width));
-		} else if (std::is_same<T, int16_t>::value || std::is_same<T, uint16_t>::value) {
-			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint16_t *>(values), reinterpret_cast<uint16_t *>(dst),
-			                             static_cast<uint32_t>(width));
-		} else if (std::is_same<T, int32_t>::value || std::is_same<T, uint32_t>::value) {
-			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint32_t *>(values), reinterpret_cast<uint32_t *>(dst),
-			                             static_cast<uint32_t>(width));
-		} else if (std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value) {
-			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint64_t *>(values), reinterpret_cast<uint32_t *>(dst),
-			                             static_cast<uint32_t>(width));
-		} else if (std::is_same<T, hugeint_t>::value || std::is_same<T, uhugeint_t>::value) {
-			HugeIntPacker::Pack(reinterpret_cast<const uhugeint_t *>(values), reinterpret_cast<uint32_t *>(dst), width);
-		} else {
-			throw InternalException("Unsupported type for bitpacking");
-		}
-	}
-
-	template <class T>
-	static inline void UnPackGroup(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
-	                               bool skip_sign_extension = false) {
-		if (std::is_same<T, int8_t>::value || std::is_same<T, uint8_t>::value) {
-			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint8_t *>(src), reinterpret_cast<uint8_t *>(dst),
-			                               static_cast<uint32_t>(width));
-		} else if (std::is_same<T, int16_t>::value || std::is_same<T, uint16_t>::value) {
-			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint16_t *>(src), reinterpret_cast<uint16_t *>(dst),
-			                               static_cast<uint32_t>(width));
-		} else if (std::is_same<T, int32_t>::value || std::is_same<T, uint32_t>::value) {
-			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uint32_t *>(dst),
-			                               static_cast<uint32_t>(width));
-		} else if (std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value) {
-			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uint64_t *>(dst),
-			                               static_cast<uint32_t>(width));
-		} else if (std::is_same<T, hugeint_t>::value || std::is_same<T, uhugeint_t>::value) {
-			HugeIntPacker::Unpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uhugeint_t *>(dst), width);
-		} else {
-			throw InternalException("Unsupported type for bitpacking");
-		}
-
-		if (NumericLimits<T>::IsSigned() && !skip_sign_extension && width > 0 && width < sizeof(T) * 8) {
-			SignExtend<T>(dst, width);
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/bitset.hpp b/src/duckdb/src/include/duckdb/common/bitset.hpp
deleted file mode 100644
index 608123503..000000000
--- a/src/duckdb/src/include/duckdb/common/bitset.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bitset.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <bitset>
-
-namespace duckdb {
-using std::bitset;
-}
diff --git a/src/duckdb/src/include/duckdb/common/box_renderer.hpp b/src/duckdb/src/include/duckdb/common/box_renderer.hpp
deleted file mode 100644
index aaed6b8b3..000000000
--- a/src/duckdb/src/include/duckdb/common/box_renderer.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/box_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/common/list.hpp"
-
-namespace duckdb {
-class ColumnDataCollection;
-class ColumnDataRowCollection;
-
-enum class ValueRenderAlignment { LEFT, MIDDLE, RIGHT };
-enum class RenderMode : uint8_t { ROWS, COLUMNS };
-
-enum class ResultRenderType { LAYOUT, COLUMN_NAME, COLUMN_TYPE, VALUE, NULL_VALUE, FOOTER };
-
-class BaseResultRenderer {
-public:
-	BaseResultRenderer();
-	virtual ~BaseResultRenderer();
-
-	virtual void RenderLayout(const string &text) = 0;
-	virtual void RenderColumnName(const string &text) = 0;
-	virtual void RenderType(const string &text) = 0;
-	virtual void RenderValue(const string &text, const LogicalType &type) = 0;
-	virtual void RenderNull(const string &text, const LogicalType &type) = 0;
-	virtual void RenderFooter(const string &text) = 0;
-
-	BaseResultRenderer &operator<<(char c);
-	BaseResultRenderer &operator<<(const string &val);
-
-	void Render(ResultRenderType render_mode, const string &val);
-	void SetValueType(const LogicalType &type);
-
-private:
-	LogicalType value_type;
-};
-
-class StringResultRenderer : public BaseResultRenderer {
-public:
-	void RenderLayout(const string &text) override;
-	void RenderColumnName(const string &text) override;
-	void RenderType(const string &text) override;
-	void RenderValue(const string &text, const LogicalType &type) override;
-	void RenderNull(const string &text, const LogicalType &type) override;
-	void RenderFooter(const string &text) override;
-
-	const string &str(); // NOLINT: mimic string stream
-
-private:
-	string result;
-};
-
-enum class LargeNumberRendering {
-	NONE = 0,   // render all numbers as-is
-	FOOTER = 1, // if there is a single row, adds a second footer row with a readable summarization of large numbers
-	ALL = 2     // renders all large numbers
-};
-
-struct BoxRendererConfig {
-	// a max_width of 0 means we default to the terminal width
-	idx_t max_width = 0;
-	// the maximum amount of rows to render
-	idx_t max_rows = 20;
-	// the limit that is applied prior to rendering
-	// if we are rendering exactly "limit" rows then a question mark is rendered instead
-	idx_t limit = 0;
-	// the max col width determines the maximum size of a single column
-	// note that the max col width is only used if the result does not fit on the screen
-	idx_t max_col_width = 20;
-	//! how to render NULL values
-	string null_value = "NULL";
-	//! Decimal separator (if any)
-	char decimal_separator = '\0';
-	//! Thousand separator (if any)
-	char thousand_separator = '\0';
-	//! Whether or not to render row-wise or column-wise
-	RenderMode render_mode = RenderMode::ROWS;
-	//! How to render large numbers
-	LargeNumberRendering large_number_rendering = LargeNumberRendering::NONE;
-
-#ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "\342\224\214"; // NOLINT: "┌";
-	const char *RTCORNER = "\342\224\220"; // NOLINT: "┐";
-	const char *LDCORNER = "\342\224\224"; // NOLINT: "└";
-	const char *RDCORNER = "\342\224\230"; // NOLINT: "┘";
-
-	const char *MIDDLE = "\342\224\274";  // NOLINT: "┼";
-	const char *TMIDDLE = "\342\224\254"; // NOLINT: "┬";
-	const char *LMIDDLE = "\342\224\234"; // NOLINT: "├";
-	const char *RMIDDLE = "\342\224\244"; // NOLINT: "┤";
-	const char *DMIDDLE = "\342\224\264"; // NOLINT: "┴";
-
-	const char *VERTICAL = "\342\224\202";   // NOLINT: "│";
-	const char *HORIZONTAL = "\342\224\200"; // NOLINT: "─";
-
-	const char *DOTDOTDOT = "\xE2\x80\xA6"; // NOLINT: "…";
-	const char *DOT = "\xC2\xB7";           // NOLINT: "·";
-	const idx_t DOTDOTDOT_LENGTH = 1;
-
-#else
-	// ASCII version
-	const char *LTCORNER = "<";
-	const char *RTCORNER = ">";
-	const char *LDCORNER = "<";
-	const char *RDCORNER = ">";
-
-	const char *MIDDLE = "+";
-	const char *TMIDDLE = "+";
-	const char *LMIDDLE = "+";
-	const char *RMIDDLE = "+";
-	const char *DMIDDLE = "+";
-
-	const char *VERTICAL = "|";
-	const char *HORIZONTAL = "-";
-
-	const char *DOTDOTDOT = "..."; // "...";
-	const char *DOT = ".";         // ".";
-	const idx_t DOTDOTDOT_LENGTH = 3;
-#endif
-};
-
-class BoxRenderer {
-	static const idx_t SPLIT_COLUMN;
-
-public:
-	explicit BoxRenderer(BoxRendererConfig config_p = BoxRendererConfig());
-
-	string ToString(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op);
-
-	void Render(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op,
-	            BaseResultRenderer &ss);
-	void Print(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op);
-
-private:
-	//! The configuration used for rendering
-	BoxRendererConfig config;
-
-private:
-	void RenderValue(BaseResultRenderer &ss, const string &value, idx_t column_width, ResultRenderType render_mode,
-	                 ValueRenderAlignment alignment = ValueRenderAlignment::MIDDLE);
-	string RenderType(const LogicalType &type);
-	ValueRenderAlignment TypeAlignment(const LogicalType &type);
-	string GetRenderValue(BaseResultRenderer &ss, ColumnDataRowCollection &rows, idx_t c, idx_t r,
-	                      const LogicalType &type, ResultRenderType &render_mode);
-	list<ColumnDataCollection> FetchRenderCollections(ClientContext &context, const ColumnDataCollection &result,
-	                                                  idx_t top_rows, idx_t bottom_rows);
-	list<ColumnDataCollection> PivotCollections(ClientContext &context, list<ColumnDataCollection> input,
-	                                            vector<string> &column_names, vector<LogicalType> &result_types,
-	                                            idx_t row_count);
-	vector<idx_t> ComputeRenderWidths(const vector<string> &names, const vector<LogicalType> &result_types,
-	                                  list<ColumnDataCollection> &collections, idx_t min_width, idx_t max_width,
-	                                  vector<idx_t> &column_map, idx_t &total_length);
-	void RenderHeader(const vector<string> &names, const vector<LogicalType> &result_types,
-	                  const vector<idx_t> &column_map, const vector<idx_t> &widths, const vector<idx_t> &boundaries,
-	                  idx_t total_length, bool has_results, BaseResultRenderer &renderer);
-	void RenderValues(const list<ColumnDataCollection> &collections, const vector<idx_t> &column_map,
-	                  const vector<idx_t> &widths, const vector<LogicalType> &result_types, BaseResultRenderer &ss);
-	void RenderRowCount(string row_count_str, string shown_str, const string &column_count_str,
-	                    const vector<idx_t> &boundaries, bool has_hidden_rows, bool has_hidden_columns,
-	                    idx_t total_length, idx_t row_count, idx_t column_count, idx_t minimum_row_length,
-	                    BaseResultRenderer &ss);
-
-	string FormatNumber(const string &input);
-	string ConvertRenderValue(const string &input, const LogicalType &type);
-	string ConvertRenderValue(const string &input);
-	//! Try to format a large number in a readable way (e.g. 1234567 -> 1.23 million)
-	string TryFormatLargeNumber(const string &numeric);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/bswap.hpp b/src/duckdb/src/include/duckdb/common/bswap.hpp
deleted file mode 100644
index fbcafb8f6..000000000
--- a/src/duckdb/src/include/duckdb/common/bswap.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bswap.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-#define BSWAP16(x) ((uint16_t)((((uint16_t)(x)&0xff00) >> 8) | (((uint16_t)(x)&0x00ff) << 8)))
-
-#define BSWAP32(x)                                                                                                     \
-	((uint32_t)((((uint32_t)(x)&0xff000000) >> 24) | (((uint32_t)(x)&0x00ff0000) >> 8) |                               \
-	            (((uint32_t)(x)&0x0000ff00) << 8) | (((uint32_t)(x)&0x000000ff) << 24)))
-
-#define BSWAP64(x)                                                                                                     \
-	((uint64_t)((((uint64_t)(x)&0xff00000000000000ull) >> 56) | (((uint64_t)(x)&0x00ff000000000000ull) >> 40) |        \
-	            (((uint64_t)(x)&0x0000ff0000000000ull) >> 24) | (((uint64_t)(x)&0x000000ff00000000ull) >> 8) |         \
-	            (((uint64_t)(x)&0x00000000ff000000ull) << 8) | (((uint64_t)(x)&0x0000000000ff0000ull) << 24) |         \
-	            (((uint64_t)(x)&0x000000000000ff00ull) << 40) | (((uint64_t)(x)&0x00000000000000ffull) << 56)))
-
-static inline uint8_t BSwap(const uint8_t &x) {
-	return x;
-}
-
-static inline uint16_t BSwap(const uint16_t &x) {
-	return BSWAP16(x);
-}
-
-static inline uint32_t BSwap(const uint32_t &x) {
-	return BSWAP32(x);
-}
-
-static inline uint64_t BSwap(const uint64_t &x) {
-	return BSWAP64(x);
-}
-
-static inline int64_t BSwap(const int64_t &x) {
-	return static_cast<int64_t>(BSWAP64(x));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/case_insensitive_map.hpp b/src/duckdb/src/include/duckdb/common/case_insensitive_map.hpp
deleted file mode 100644
index ba8350559..000000000
--- a/src/duckdb/src/include/duckdb/common/case_insensitive_map.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/case_insensitive_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/map.hpp"
-
-namespace duckdb {
-
-struct CaseInsensitiveStringHashFunction {
-	uint64_t operator()(const string &str) const {
-		return StringUtil::CIHash(str);
-	}
-};
-
-struct CaseInsensitiveStringEquality {
-	bool operator()(const string &a, const string &b) const {
-		return StringUtil::CIEquals(a, b);
-	}
-};
-
-template <typename T>
-using case_insensitive_map_t =
-    unordered_map<string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-struct CaseInsensitiveStringCompare {
-	bool operator()(const string &s1, const string &s2) const {
-		return StringUtil::CILessThan(s1, s2);
-	}
-};
-
-template <typename T>
-using case_insensitive_tree_t = map<string, T, CaseInsensitiveStringCompare>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/cgroups.hpp b/src/duckdb/src/include/duckdb/common/cgroups.hpp
deleted file mode 100644
index fcdbb730b..000000000
--- a/src/duckdb/src/include/duckdb/common/cgroups.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/cgroups.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/file_system.hpp"
-
-namespace duckdb {
-
-class CGroups {
-public:
-	static optional_idx GetMemoryLimit(FileSystem &fs);
-	static idx_t GetCPULimit(FileSystem &fs, idx_t physical_cores);
-
-private:
-	static optional_idx GetCGroupV2MemoryLimit(FileSystem &fs);
-	static optional_idx GetCGroupV1MemoryLimit(FileSystem &fs);
-	static string ReadCGroupPath(FileSystem &fs, const char *cgroup_file);
-	static string ReadMemoryCGroupPath(FileSystem &fs, const char *cgroup_file);
-	static optional_idx ReadCGroupValue(FileSystem &fs, const char *file_path);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/checksum.hpp b/src/duckdb/src/include/duckdb/common/checksum.hpp
deleted file mode 100644
index 425d6b1f5..000000000
--- a/src/duckdb/src/include/duckdb/common/checksum.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/checksum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//! Compute a checksum over a buffer of size size
-uint64_t Checksum(uint8_t *buffer, size_t size);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/chrono.hpp b/src/duckdb/src/include/duckdb/common/chrono.hpp
deleted file mode 100644
index c46e27b15..000000000
--- a/src/duckdb/src/include/duckdb/common/chrono.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/chrono.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <chrono>
-
-namespace duckdb {
-using std::chrono::duration;
-using std::chrono::duration_cast;
-using std::chrono::high_resolution_clock;
-using std::chrono::milliseconds;
-using std::chrono::nanoseconds;
-using std::chrono::system_clock;
-using std::chrono::time_point;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/column_index.hpp b/src/duckdb/src/include/duckdb/common/column_index.hpp
deleted file mode 100644
index 32d2e1828..000000000
--- a/src/duckdb/src/include/duckdb/common/column_index.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/column_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-struct ColumnIndex {
-	ColumnIndex() : index(DConstants::INVALID_INDEX) {
-	}
-	explicit ColumnIndex(idx_t index) : index(index) {
-	}
-	ColumnIndex(idx_t index, vector<ColumnIndex> child_indexes_p)
-	    : index(index), child_indexes(std::move(child_indexes_p)) {
-	}
-
-	inline bool operator==(const ColumnIndex &rhs) const {
-		return index == rhs.index;
-	}
-	inline bool operator!=(const ColumnIndex &rhs) const {
-		return index != rhs.index;
-	}
-	inline bool operator<(const ColumnIndex &rhs) const {
-		return index < rhs.index;
-	}
-	idx_t GetPrimaryIndex() const {
-		return index;
-	}
-	LogicalIndex ToLogical() const {
-		return LogicalIndex(index);
-	}
-	bool HasChildren() const {
-		return !child_indexes.empty();
-	}
-	idx_t ChildIndexCount() const {
-		return child_indexes.size();
-	}
-	const ColumnIndex &GetChildIndex(idx_t idx) const {
-		return child_indexes[idx];
-	}
-	ColumnIndex &GetChildIndex(idx_t idx) {
-		return child_indexes[idx];
-	}
-	const vector<ColumnIndex> &GetChildIndexes() const {
-		return child_indexes;
-	}
-	vector<ColumnIndex> &GetChildIndexesMutable() {
-		return child_indexes;
-	}
-	void AddChildIndex(ColumnIndex new_index) {
-		this->child_indexes.push_back(std::move(new_index));
-	}
-	bool IsRowIdColumn() const {
-		return index == DConstants::INVALID_INDEX;
-	}
-	void Serialize(Serializer &serializer) const;
-	static ColumnIndex Deserialize(Deserializer &deserializer);
-
-private:
-	idx_t index;
-	vector<ColumnIndex> child_indexes;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/common.hpp b/src/duckdb/src/include/duckdb/common/common.hpp
deleted file mode 100644
index e337721ce..000000000
--- a/src/duckdb/src/include/duckdb/common/common.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/common.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/vector.hpp"
diff --git a/src/duckdb/src/include/duckdb/common/compressed_file_system.hpp b/src/duckdb/src/include/duckdb/common/compressed_file_system.hpp
deleted file mode 100644
index ff6cffab8..000000000
--- a/src/duckdb/src/include/duckdb/common/compressed_file_system.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/compressed_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/file_system.hpp"
-
-namespace duckdb {
-class CompressedFile;
-
-struct StreamData {
-	// various buffers & pointers
-	bool write = false;
-	bool refresh = false;
-	unsafe_unique_array<data_t> in_buff;
-	unsafe_unique_array<data_t> out_buff;
-	data_ptr_t out_buff_start = nullptr;
-	data_ptr_t out_buff_end = nullptr;
-	data_ptr_t in_buff_start = nullptr;
-	data_ptr_t in_buff_end = nullptr;
-
-	idx_t in_buf_size = 0;
-	idx_t out_buf_size = 0;
-};
-
-struct StreamWrapper {
-	DUCKDB_API virtual ~StreamWrapper();
-
-	DUCKDB_API virtual void Initialize(CompressedFile &file, bool write) = 0;
-	DUCKDB_API virtual bool Read(StreamData &stream_data) = 0;
-	DUCKDB_API virtual void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer,
-	                              int64_t nr_bytes) = 0;
-	DUCKDB_API virtual void Close() = 0;
-};
-
-class CompressedFileSystem : public FileSystem {
-public:
-	DUCKDB_API int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	DUCKDB_API int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	DUCKDB_API void Reset(FileHandle &handle) override;
-
-	DUCKDB_API int64_t GetFileSize(FileHandle &handle) override;
-
-	DUCKDB_API bool OnDiskFile(FileHandle &handle) override;
-	DUCKDB_API bool CanSeek() override;
-
-	DUCKDB_API virtual unique_ptr<StreamWrapper> CreateStream() = 0;
-	DUCKDB_API virtual idx_t InBufferSize() = 0;
-	DUCKDB_API virtual idx_t OutBufferSize() = 0;
-};
-
-class CompressedFile : public FileHandle {
-public:
-	DUCKDB_API CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle> child_handle_p, const string &path);
-	DUCKDB_API ~CompressedFile() override;
-
-	DUCKDB_API idx_t GetProgress() override;
-
-	CompressedFileSystem &compressed_fs;
-	unique_ptr<FileHandle> child_handle;
-	//! Whether the file is opened for reading or for writing
-	bool write = false;
-	StreamData stream_data;
-
-public:
-	DUCKDB_API void Initialize(bool write);
-	DUCKDB_API int64_t ReadData(void *buffer, int64_t nr_bytes);
-	DUCKDB_API int64_t WriteData(data_ptr_t buffer, int64_t nr_bytes);
-	DUCKDB_API void Close() override;
-
-private:
-	idx_t current_position = 0;
-	unique_ptr<StreamWrapper> stream_wrapper;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/constants.hpp b/src/duckdb/src/include/duckdb/common/constants.hpp
deleted file mode 100644
index d4a0d7cda..000000000
--- a/src/duckdb/src/include/duckdb/common/constants.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/constants.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <memory>
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-class BinarySerializer;
-class BinaryDeserializer;
-class WriteStream;
-class ReadStream;
-
-//! inline std directives that we use frequently
-#ifndef DUCKDB_DEBUG_MOVE
-using std::move;
-#endif
-
-// NOTE: there is a copy of this in the Postgres' parser grammar (gram.y)
-#define DEFAULT_SCHEMA  "main"
-#define INVALID_SCHEMA  ""
-#define INVALID_CATALOG ""
-#define SYSTEM_CATALOG  "system"
-#define TEMP_CATALOG    "temp"
-#define IN_MEMORY_PATH  ":memory:"
-
-DUCKDB_API bool IsInvalidSchema(const string &str);
-DUCKDB_API bool IsInvalidCatalog(const string &str);
-
-//! Special value used to signify the ROW ID of a table
-DUCKDB_API extern const column_t COLUMN_IDENTIFIER_ROW_ID;
-DUCKDB_API bool IsRowIdColumnId(column_t column_id);
-
-//! The maximum row identifier used in tables
-extern const row_t MAX_ROW_ID;
-//! Transaction-local row IDs start at MAX_ROW_ID
-extern const row_t MAX_ROW_ID_LOCAL;
-
-extern const transaction_t TRANSACTION_ID_START;
-extern const transaction_t MAX_TRANSACTION_ID;
-extern const transaction_t MAXIMUM_QUERY_ID;
-extern const transaction_t NOT_DELETED_ID;
-
-extern const double PI;
-
-struct DConstants {
-	//! The value used to signify an invalid index entry
-	static constexpr const idx_t INVALID_INDEX = idx_t(-1);
-	//! The total maximum vector size (128GB)
-	static constexpr const idx_t MAX_VECTOR_SIZE = 1ULL << 37ULL;
-};
-
-struct LogicalIndex {
-	explicit LogicalIndex(idx_t index) : index(index) {
-	}
-
-	idx_t index;
-
-	inline bool operator==(const LogicalIndex &rhs) const {
-		return index == rhs.index;
-	};
-	inline bool operator!=(const LogicalIndex &rhs) const {
-		return index != rhs.index;
-	};
-	inline bool operator<(const LogicalIndex &rhs) const {
-		return index < rhs.index;
-	};
-	bool IsValid() {
-		return index != DConstants::INVALID_INDEX;
-	}
-};
-
-struct PhysicalIndex {
-	explicit PhysicalIndex(idx_t index) : index(index) {
-	}
-
-	idx_t index;
-
-	inline bool operator==(const PhysicalIndex &rhs) const {
-		return index == rhs.index;
-	};
-	inline bool operator!=(const PhysicalIndex &rhs) const {
-		return index != rhs.index;
-	};
-	inline bool operator<(const PhysicalIndex &rhs) const {
-		return index < rhs.index;
-	};
-	bool IsValid() {
-		return index != DConstants::INVALID_INDEX;
-	}
-};
-
-DUCKDB_API bool IsPowerOfTwo(uint64_t v);
-DUCKDB_API uint64_t NextPowerOfTwo(uint64_t v);
-DUCKDB_API uint64_t PreviousPowerOfTwo(uint64_t v);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/crypto/md5.hpp b/src/duckdb/src/include/duckdb/common/crypto/md5.hpp
deleted file mode 100644
index ab3134ff0..000000000
--- a/src/duckdb/src/include/duckdb/common/crypto/md5.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/crypto/md5.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-
-class MD5Context {
-public:
-	static constexpr idx_t MD5_HASH_LENGTH_BINARY = 16;
-	static constexpr idx_t MD5_HASH_LENGTH_TEXT = 32;
-
-public:
-	MD5Context();
-
-	void Add(const_data_ptr_t data, idx_t len) {
-		MD5Update(data, len);
-	}
-	void Add(const char *data);
-	void Add(string_t string) {
-		MD5Update(const_data_ptr_cast(string.GetData()), string.GetSize());
-	}
-	void Add(const string &data) {
-		MD5Update(const_data_ptr_cast(data.c_str()), data.size());
-	}
-
-	//! Write the 16-byte (binary) digest to the specified location
-	void Finish(data_ptr_t out_digest);
-	//! Write the 32-character digest (in hexadecimal format) to the specified location
-	void FinishHex(char *out_digest);
-	//! Returns the 32-character digest (in hexadecimal format) as a string
-	string FinishHex();
-
-private:
-	void MD5Update(const_data_ptr_t data, idx_t len);
-
-	uint32_t buf[4];
-	uint32_t bits[2];
-	unsigned char in[64];
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/deque.hpp b/src/duckdb/src/include/duckdb/common/deque.hpp
deleted file mode 100644
index f5c8ba990..000000000
--- a/src/duckdb/src/include/duckdb/common/deque.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/deque.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <deque>
-
-namespace duckdb {
-using std::deque;
-}
diff --git a/src/duckdb/src/include/duckdb/common/dl.hpp b/src/duckdb/src/include/duckdb/common/dl.hpp
deleted file mode 100644
index 0fe730bc0..000000000
--- a/src/duckdb/src/include/duckdb/common/dl.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/dl.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/windows.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/common/windows_util.hpp"
-
-#ifndef _WIN32
-#include <dlfcn.h>
-#else
-#define RTLD_NOW   0
-#define RTLD_LOCAL 0
-#endif
-
-namespace duckdb {
-
-#ifdef _WIN32
-
-inline void *dlopen(const char *file, int mode) {
-	if (!file) {
-		return (void *)GetModuleHandle(nullptr);
-	}
-	auto fpath = WindowsUtil::UTF8ToUnicode(file);
-	return (void *)LoadLibraryW(fpath.c_str());
-}
-
-inline void *dlsym(void *handle, const char *name) {
-	D_ASSERT(handle);
-	return (void *)GetProcAddress((HINSTANCE)handle, name);
-}
-
-inline std::string GetDLError(void) {
-	return LocalFileSystem::GetLastErrorAsString();
-}
-
-inline void dlclose(void *handle) {
-	D_ASSERT(handle);
-	FreeLibrary((HINSTANCE)handle);
-}
-
-#else
-
-inline std::string GetDLError(void) {
-	return dlerror();
-}
-
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enable_shared_from_this_ipp.hpp b/src/duckdb/src/include/duckdb/common/enable_shared_from_this_ipp.hpp
deleted file mode 100644
index 85cdd2205..000000000
--- a/src/duckdb/src/include/duckdb/common/enable_shared_from_this_ipp.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-namespace duckdb {
-
-template <class T>
-class enable_shared_from_this { // NOLINT: invalid case style
-public:
-	template <class U, bool SAFE>
-	friend class shared_ptr;
-
-private:
-	mutable weak_ptr<T> __weak_this_; // NOLINT: __weak_this_ is reserved
-
-protected:
-	constexpr enable_shared_from_this() noexcept {
-	}
-	enable_shared_from_this(enable_shared_from_this const &) noexcept { // NOLINT: not marked as explicit
-	}
-	enable_shared_from_this &operator=(enable_shared_from_this const &) noexcept {
-		return *this;
-	}
-	~enable_shared_from_this() {
-	}
-
-public:
-	shared_ptr<T> shared_from_this() { // NOLINT: invalid case style
-		return shared_ptr<T>(__weak_this_);
-	}
-	shared_ptr<T const> shared_from_this() const { // NOLINT: invalid case style
-		return shared_ptr<const T>(__weak_this_);
-	}
-
-#if _LIBCPP_STD_VER >= 17
-	weak_ptr<T> weak_from_this() noexcept { // NOLINT: invalid case style
-		return __weak_this_;
-	}
-
-	weak_ptr<const T> weak_from_this() const noexcept { // NOLINT: invalid case style
-		return __weak_this_;
-	}
-#endif // _LIBCPP_STD_VER >= 17
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/encryption_state.hpp b/src/duckdb/src/include/duckdb/common/encryption_state.hpp
deleted file mode 100644
index c471773c9..000000000
--- a/src/duckdb/src/include/duckdb/common/encryption_state.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/encryption_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-class EncryptionState {
-
-public:
-	DUCKDB_API EncryptionState();
-	DUCKDB_API virtual ~EncryptionState();
-
-public:
-	DUCKDB_API virtual bool IsOpenSSL();
-	DUCKDB_API virtual void InitializeEncryption(const_data_ptr_t iv, idx_t iv_len, const std::string *key);
-	DUCKDB_API virtual void InitializeDecryption(const_data_ptr_t iv, idx_t iv_len, const std::string *key);
-	DUCKDB_API virtual size_t Process(const_data_ptr_t in, idx_t in_len, data_ptr_t out, idx_t out_len);
-	DUCKDB_API virtual size_t Finalize(data_ptr_t out, idx_t out_len, data_ptr_t tag, idx_t tag_len);
-	DUCKDB_API virtual void GenerateRandomData(data_ptr_t data, idx_t len);
-
-public:
-	enum Mode { ENCRYPT, DECRYPT };
-};
-
-class EncryptionUtil {
-
-public:
-	DUCKDB_API explicit EncryptionUtil() {};
-
-public:
-	virtual shared_ptr<EncryptionState> CreateEncryptionState() const {
-		return make_shared_ptr<EncryptionState>();
-	}
-
-	virtual ~EncryptionUtil() {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enum_class_hash.hpp b/src/duckdb/src/include/duckdb/common/enum_class_hash.hpp
deleted file mode 100644
index 1de2c811f..000000000
--- a/src/duckdb/src/include/duckdb/common/enum_class_hash.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enum_class_hash.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <cstddef>
-
-namespace duckdb {
-/* For compatibility with older C++ STL, an explicit hash class
-   is required for enums with C++ sets and maps */
-struct EnumClassHash {
-	template <typename T>
-	std::size_t operator()(T t) const {
-		return static_cast<std::size_t>(t);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enum_util.hpp b/src/duckdb/src/include/duckdb/common/enum_util.hpp
deleted file mode 100644
index 852f43436..000000000
--- a/src/duckdb/src/include/duckdb/common/enum_util.hpp
+++ /dev/null
@@ -1,1438 +0,0 @@
-//-------------------------------------------------------------------------
-// This file is automatically generated by scripts/generate_enum_util.py
-// Do not edit this file manually, your changes will be overwritten
-// If you want to exclude an enum from serialization, add it to the blacklist in the script
-//
-// Note: The generated code will only work properly if the enum is a top level item in the duckdb namespace
-// If the enum is nested in a class, or in another namespace, the generated code will not compile.
-// You should move the enum to the duckdb namespace, manually write a specialization or add it to the blacklist
-//-------------------------------------------------------------------------
-
-
-#pragma once
-
-#include <stdint.h>
-#include "duckdb/common/string.hpp"
-
-namespace duckdb {
-
-struct EnumUtil {
-    // String -> Enum
-    template <class T>
-    static T FromString(const char *value) = delete;
-
-    template <class T>
-    static T FromString(const string &value) { return FromString<T>(value.c_str()); }
-
-    // Enum -> String
-    template <class T>
-    static const char *ToChars(T value) = delete;
-
-    template <class T>
-    static string ToString(T value) { return string(ToChars<T>(value)); }
-};
-
-enum class ARTAppendMode : uint8_t;
-
-enum class ARTConflictType : uint8_t;
-
-enum class AccessMode : uint8_t;
-
-enum class AggregateCombineType : uint8_t;
-
-enum class AggregateDistinctDependent : uint8_t;
-
-enum class AggregateHandling : uint8_t;
-
-enum class AggregateOrderDependent : uint8_t;
-
-enum class AggregateType : uint8_t;
-
-enum class AlterForeignKeyType : uint8_t;
-
-enum class AlterScalarFunctionType : uint8_t;
-
-enum class AlterTableFunctionType : uint8_t;
-
-enum class AlterTableType : uint8_t;
-
-enum class AlterType : uint8_t;
-
-enum class AlterViewType : uint8_t;
-
-enum class AppenderType : uint8_t;
-
-enum class ArrowDateTimeType : uint8_t;
-
-enum class ArrowOffsetSize : uint8_t;
-
-enum class ArrowTypeInfoType : uint8_t;
-
-enum class ArrowVariableSizeType : uint8_t;
-
-enum class BinderType : uint8_t;
-
-enum class BindingMode : uint8_t;
-
-enum class BitpackingMode : uint8_t;
-
-enum class BlockState : uint8_t;
-
-enum class CAPIResultSetType : uint8_t;
-
-enum class CSVState : uint8_t;
-
-enum class CTEMaterialize : uint8_t;
-
-enum class CatalogLookupBehavior : uint8_t;
-
-enum class CatalogType : uint8_t;
-
-enum class CheckpointAbort : uint8_t;
-
-enum class ChunkInfoType : uint8_t;
-
-enum class ColumnDataAllocatorType : uint8_t;
-
-enum class ColumnDataScanProperties : uint8_t;
-
-enum class ColumnSegmentType : uint8_t;
-
-enum class CompressedMaterializationDirection : uint8_t;
-
-enum class CompressionType : uint8_t;
-
-enum class CompressionValidity : uint8_t;
-
-enum class ConflictManagerMode : uint8_t;
-
-enum class ConstraintType : uint8_t;
-
-enum class CopyFunctionReturnType : uint8_t;
-
-enum class CopyOverwriteMode : uint8_t;
-
-enum class CopyToType : uint8_t;
-
-enum class DataFileType : uint8_t;
-
-enum class DateCastResult : uint8_t;
-
-enum class DatePartSpecifier : uint8_t;
-
-enum class DebugInitialize : uint8_t;
-
-enum class DefaultOrderByNullType : uint8_t;
-
-enum class DependencyEntryType : uint8_t;
-
-enum class DeprecatedIndexType : uint8_t;
-
-enum class DestroyBufferUpon : uint8_t;
-
-enum class DistinctType : uint8_t;
-
-enum class ErrorType : uint16_t;
-
-enum class ExceptionFormatValueType : uint8_t;
-
-enum class ExceptionType : uint8_t;
-
-enum class ExplainFormat : uint8_t;
-
-enum class ExplainOutputType : uint8_t;
-
-enum class ExplainType : uint8_t;
-
-enum class ExponentType : uint8_t;
-
-enum class ExpressionClass : uint8_t;
-
-enum class ExpressionType : uint8_t;
-
-enum class ExtensionABIType : uint8_t;
-
-enum class ExtensionInstallMode : uint8_t;
-
-enum class ExtensionLoadResult : uint8_t;
-
-enum class ExtensionUpdateResultTag : uint8_t;
-
-enum class ExtraDropInfoType : uint8_t;
-
-enum class ExtraTypeInfoType : uint8_t;
-
-enum class FileBufferType : uint8_t;
-
-enum class FileCompressionType : uint8_t;
-
-enum class FileExpandResult : uint8_t;
-
-enum class FileGlobOptions : uint8_t;
-
-enum class FileLockType : uint8_t;
-
-enum class FilterPropagateResult : uint8_t;
-
-enum class ForeignKeyType : uint8_t;
-
-enum class FunctionCollationHandling : uint8_t;
-
-enum class FunctionErrors : uint8_t;
-
-enum class FunctionNullHandling : uint8_t;
-
-enum class FunctionStability : uint8_t;
-
-enum class GateStatus : uint8_t;
-
-enum class HLLStorageType : uint8_t;
-
-enum class IndexConstraintType : uint8_t;
-
-enum class InsertColumnOrder : uint8_t;
-
-enum class InterruptMode : uint8_t;
-
-enum class JoinRefType : uint8_t;
-
-enum class JoinType : uint8_t;
-
-enum class KeywordCategory : uint8_t;
-
-enum class LimitNodeType : uint8_t;
-
-enum class LoadType : uint8_t;
-
-enum class LogicalOperatorType : uint8_t;
-
-enum class LogicalTypeId : uint8_t;
-
-enum class LookupResultType : uint8_t;
-
-enum class MacroType : uint8_t;
-
-enum class MapInvalidReason : uint8_t;
-
-enum class MemoryTag : uint8_t;
-
-enum class MetaPipelineType : uint8_t;
-
-enum class MetricsType : uint8_t;
-
-enum class NType : uint8_t;
-
-enum class NewLineIdentifier : uint8_t;
-
-enum class OnConflictAction : uint8_t;
-
-enum class OnCreateConflict : uint8_t;
-
-enum class OnEntryNotFound : uint8_t;
-
-enum class OperatorFinalizeResultType : uint8_t;
-
-enum class OperatorResultType : uint8_t;
-
-enum class OptimizerType : uint32_t;
-
-enum class OrderByNullType : uint8_t;
-
-enum class OrderPreservationType : uint8_t;
-
-enum class OrderType : uint8_t;
-
-enum class OutputStream : uint8_t;
-
-enum class ParseInfoType : uint8_t;
-
-enum class ParserExtensionResultType : uint8_t;
-
-enum class PartitionSortStage : uint8_t;
-
-enum class PartitionedColumnDataType : uint8_t;
-
-enum class PartitionedTupleDataType : uint8_t;
-
-enum class PendingExecutionResult : uint8_t;
-
-enum class PhysicalOperatorType : uint8_t;
-
-enum class PhysicalType : uint8_t;
-
-enum class PragmaType : uint8_t;
-
-enum class PreparedParamType : uint8_t;
-
-enum class PreparedStatementMode : uint8_t;
-
-enum class ProfilerPrintFormat : uint8_t;
-
-enum class QuantileSerializationType : uint8_t;
-
-enum class QueryNodeType : uint8_t;
-
-enum class QueryResultType : uint8_t;
-
-enum class QuoteRule : uint8_t;
-
-enum class RelationType : uint8_t;
-
-enum class RenderMode : uint8_t;
-
-enum class ResultModifierType : uint8_t;
-
-enum class SampleMethod : uint8_t;
-
-enum class SampleType : uint8_t;
-
-enum class SamplingState : uint8_t;
-
-enum class ScanType : uint8_t;
-
-enum class SecretDisplayType : uint8_t;
-
-enum class SecretPersistType : uint8_t;
-
-enum class SecretSerializationType : uint8_t;
-
-enum class SequenceInfo : uint8_t;
-
-enum class SetOperationType : uint8_t;
-
-enum class SetScope : uint8_t;
-
-enum class SetType : uint8_t;
-
-enum class SettingScope : uint8_t;
-
-enum class ShowType : uint8_t;
-
-enum class SimplifiedTokenType : uint8_t;
-
-enum class SinkCombineResultType : uint8_t;
-
-enum class SinkFinalizeType : uint8_t;
-
-enum class SinkNextBatchType : uint8_t;
-
-enum class SinkResultType : uint8_t;
-
-enum class SourceResultType : uint8_t;
-
-enum class StatementReturnType : uint8_t;
-
-enum class StatementType : uint8_t;
-
-enum class StatisticsType : uint8_t;
-
-enum class StatsInfo : uint8_t;
-
-enum class StrTimeSpecifier : uint8_t;
-
-enum class StreamExecutionResult : uint8_t;
-
-enum class SubqueryType : uint8_t;
-
-enum class TableColumnType : uint8_t;
-
-enum class TableFilterType : uint8_t;
-
-enum class TablePartitionInfo : uint8_t;
-
-enum class TableReferenceType : uint8_t;
-
-enum class TableScanType : uint8_t;
-
-enum class TaskExecutionMode : uint8_t;
-
-enum class TaskExecutionResult : uint8_t;
-
-enum class TemporaryBufferSize : uint64_t;
-
-enum class TemporaryCompressionLevel : int;
-
-enum class TimestampCastResult : uint8_t;
-
-enum class TransactionModifierType : uint8_t;
-
-enum class TransactionType : uint8_t;
-
-enum class TupleDataPinProperties : uint8_t;
-
-enum class UndoFlags : uint32_t;
-
-enum class UnionInvalidReason : uint8_t;
-
-enum class VectorAuxiliaryDataType : uint8_t;
-
-enum class VectorBufferType : uint8_t;
-
-enum class VectorType : uint8_t;
-
-enum class VerificationType : uint8_t;
-
-enum class VerifyExistenceType : uint8_t;
-
-enum class WALType : uint8_t;
-
-enum class WindowAggregationMode : uint32_t;
-
-enum class WindowBoundary : uint8_t;
-
-enum class WindowExcludeMode : uint8_t;
-
-
-template<>
-const char* EnumUtil::ToChars<ARTAppendMode>(ARTAppendMode value);
-
-template<>
-const char* EnumUtil::ToChars<ARTConflictType>(ARTConflictType value);
-
-template<>
-const char* EnumUtil::ToChars<AccessMode>(AccessMode value);
-
-template<>
-const char* EnumUtil::ToChars<AggregateCombineType>(AggregateCombineType value);
-
-template<>
-const char* EnumUtil::ToChars<AggregateDistinctDependent>(AggregateDistinctDependent value);
-
-template<>
-const char* EnumUtil::ToChars<AggregateHandling>(AggregateHandling value);
-
-template<>
-const char* EnumUtil::ToChars<AggregateOrderDependent>(AggregateOrderDependent value);
-
-template<>
-const char* EnumUtil::ToChars<AggregateType>(AggregateType value);
-
-template<>
-const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value);
-
-template<>
-const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value);
-
-template<>
-const char* EnumUtil::ToChars<AlterTableFunctionType>(AlterTableFunctionType value);
-
-template<>
-const char* EnumUtil::ToChars<AlterTableType>(AlterTableType value);
-
-template<>
-const char* EnumUtil::ToChars<AlterType>(AlterType value);
-
-template<>
-const char* EnumUtil::ToChars<AlterViewType>(AlterViewType value);
-
-template<>
-const char* EnumUtil::ToChars<AppenderType>(AppenderType value);
-
-template<>
-const char* EnumUtil::ToChars<ArrowDateTimeType>(ArrowDateTimeType value);
-
-template<>
-const char* EnumUtil::ToChars<ArrowOffsetSize>(ArrowOffsetSize value);
-
-template<>
-const char* EnumUtil::ToChars<ArrowTypeInfoType>(ArrowTypeInfoType value);
-
-template<>
-const char* EnumUtil::ToChars<ArrowVariableSizeType>(ArrowVariableSizeType value);
-
-template<>
-const char* EnumUtil::ToChars<BinderType>(BinderType value);
-
-template<>
-const char* EnumUtil::ToChars<BindingMode>(BindingMode value);
-
-template<>
-const char* EnumUtil::ToChars<BitpackingMode>(BitpackingMode value);
-
-template<>
-const char* EnumUtil::ToChars<BlockState>(BlockState value);
-
-template<>
-const char* EnumUtil::ToChars<CAPIResultSetType>(CAPIResultSetType value);
-
-template<>
-const char* EnumUtil::ToChars<CSVState>(CSVState value);
-
-template<>
-const char* EnumUtil::ToChars<CTEMaterialize>(CTEMaterialize value);
-
-template<>
-const char* EnumUtil::ToChars<CatalogLookupBehavior>(CatalogLookupBehavior value);
-
-template<>
-const char* EnumUtil::ToChars<CatalogType>(CatalogType value);
-
-template<>
-const char* EnumUtil::ToChars<CheckpointAbort>(CheckpointAbort value);
-
-template<>
-const char* EnumUtil::ToChars<ChunkInfoType>(ChunkInfoType value);
-
-template<>
-const char* EnumUtil::ToChars<ColumnDataAllocatorType>(ColumnDataAllocatorType value);
-
-template<>
-const char* EnumUtil::ToChars<ColumnDataScanProperties>(ColumnDataScanProperties value);
-
-template<>
-const char* EnumUtil::ToChars<ColumnSegmentType>(ColumnSegmentType value);
-
-template<>
-const char* EnumUtil::ToChars<CompressedMaterializationDirection>(CompressedMaterializationDirection value);
-
-template<>
-const char* EnumUtil::ToChars<CompressionType>(CompressionType value);
-
-template<>
-const char* EnumUtil::ToChars<CompressionValidity>(CompressionValidity value);
-
-template<>
-const char* EnumUtil::ToChars<ConflictManagerMode>(ConflictManagerMode value);
-
-template<>
-const char* EnumUtil::ToChars<ConstraintType>(ConstraintType value);
-
-template<>
-const char* EnumUtil::ToChars<CopyFunctionReturnType>(CopyFunctionReturnType value);
-
-template<>
-const char* EnumUtil::ToChars<CopyOverwriteMode>(CopyOverwriteMode value);
-
-template<>
-const char* EnumUtil::ToChars<CopyToType>(CopyToType value);
-
-template<>
-const char* EnumUtil::ToChars<DataFileType>(DataFileType value);
-
-template<>
-const char* EnumUtil::ToChars<DateCastResult>(DateCastResult value);
-
-template<>
-const char* EnumUtil::ToChars<DatePartSpecifier>(DatePartSpecifier value);
-
-template<>
-const char* EnumUtil::ToChars<DebugInitialize>(DebugInitialize value);
-
-template<>
-const char* EnumUtil::ToChars<DefaultOrderByNullType>(DefaultOrderByNullType value);
-
-template<>
-const char* EnumUtil::ToChars<DependencyEntryType>(DependencyEntryType value);
-
-template<>
-const char* EnumUtil::ToChars<DeprecatedIndexType>(DeprecatedIndexType value);
-
-template<>
-const char* EnumUtil::ToChars<DestroyBufferUpon>(DestroyBufferUpon value);
-
-template<>
-const char* EnumUtil::ToChars<DistinctType>(DistinctType value);
-
-template<>
-const char* EnumUtil::ToChars<ErrorType>(ErrorType value);
-
-template<>
-const char* EnumUtil::ToChars<ExceptionFormatValueType>(ExceptionFormatValueType value);
-
-template<>
-const char* EnumUtil::ToChars<ExceptionType>(ExceptionType value);
-
-template<>
-const char* EnumUtil::ToChars<ExplainFormat>(ExplainFormat value);
-
-template<>
-const char* EnumUtil::ToChars<ExplainOutputType>(ExplainOutputType value);
-
-template<>
-const char* EnumUtil::ToChars<ExplainType>(ExplainType value);
-
-template<>
-const char* EnumUtil::ToChars<ExponentType>(ExponentType value);
-
-template<>
-const char* EnumUtil::ToChars<ExpressionClass>(ExpressionClass value);
-
-template<>
-const char* EnumUtil::ToChars<ExpressionType>(ExpressionType value);
-
-template<>
-const char* EnumUtil::ToChars<ExtensionABIType>(ExtensionABIType value);
-
-template<>
-const char* EnumUtil::ToChars<ExtensionInstallMode>(ExtensionInstallMode value);
-
-template<>
-const char* EnumUtil::ToChars<ExtensionLoadResult>(ExtensionLoadResult value);
-
-template<>
-const char* EnumUtil::ToChars<ExtensionUpdateResultTag>(ExtensionUpdateResultTag value);
-
-template<>
-const char* EnumUtil::ToChars<ExtraDropInfoType>(ExtraDropInfoType value);
-
-template<>
-const char* EnumUtil::ToChars<ExtraTypeInfoType>(ExtraTypeInfoType value);
-
-template<>
-const char* EnumUtil::ToChars<FileBufferType>(FileBufferType value);
-
-template<>
-const char* EnumUtil::ToChars<FileCompressionType>(FileCompressionType value);
-
-template<>
-const char* EnumUtil::ToChars<FileExpandResult>(FileExpandResult value);
-
-template<>
-const char* EnumUtil::ToChars<FileGlobOptions>(FileGlobOptions value);
-
-template<>
-const char* EnumUtil::ToChars<FileLockType>(FileLockType value);
-
-template<>
-const char* EnumUtil::ToChars<FilterPropagateResult>(FilterPropagateResult value);
-
-template<>
-const char* EnumUtil::ToChars<ForeignKeyType>(ForeignKeyType value);
-
-template<>
-const char* EnumUtil::ToChars<FunctionCollationHandling>(FunctionCollationHandling value);
-
-template<>
-const char* EnumUtil::ToChars<FunctionErrors>(FunctionErrors value);
-
-template<>
-const char* EnumUtil::ToChars<FunctionNullHandling>(FunctionNullHandling value);
-
-template<>
-const char* EnumUtil::ToChars<FunctionStability>(FunctionStability value);
-
-template<>
-const char* EnumUtil::ToChars<GateStatus>(GateStatus value);
-
-template<>
-const char* EnumUtil::ToChars<HLLStorageType>(HLLStorageType value);
-
-template<>
-const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value);
-
-template<>
-const char* EnumUtil::ToChars<InsertColumnOrder>(InsertColumnOrder value);
-
-template<>
-const char* EnumUtil::ToChars<InterruptMode>(InterruptMode value);
-
-template<>
-const char* EnumUtil::ToChars<JoinRefType>(JoinRefType value);
-
-template<>
-const char* EnumUtil::ToChars<JoinType>(JoinType value);
-
-template<>
-const char* EnumUtil::ToChars<KeywordCategory>(KeywordCategory value);
-
-template<>
-const char* EnumUtil::ToChars<LimitNodeType>(LimitNodeType value);
-
-template<>
-const char* EnumUtil::ToChars<LoadType>(LoadType value);
-
-template<>
-const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value);
-
-template<>
-const char* EnumUtil::ToChars<LogicalTypeId>(LogicalTypeId value);
-
-template<>
-const char* EnumUtil::ToChars<LookupResultType>(LookupResultType value);
-
-template<>
-const char* EnumUtil::ToChars<MacroType>(MacroType value);
-
-template<>
-const char* EnumUtil::ToChars<MapInvalidReason>(MapInvalidReason value);
-
-template<>
-const char* EnumUtil::ToChars<MemoryTag>(MemoryTag value);
-
-template<>
-const char* EnumUtil::ToChars<MetaPipelineType>(MetaPipelineType value);
-
-template<>
-const char* EnumUtil::ToChars<MetricsType>(MetricsType value);
-
-template<>
-const char* EnumUtil::ToChars<NType>(NType value);
-
-template<>
-const char* EnumUtil::ToChars<NewLineIdentifier>(NewLineIdentifier value);
-
-template<>
-const char* EnumUtil::ToChars<OnConflictAction>(OnConflictAction value);
-
-template<>
-const char* EnumUtil::ToChars<OnCreateConflict>(OnCreateConflict value);
-
-template<>
-const char* EnumUtil::ToChars<OnEntryNotFound>(OnEntryNotFound value);
-
-template<>
-const char* EnumUtil::ToChars<OperatorFinalizeResultType>(OperatorFinalizeResultType value);
-
-template<>
-const char* EnumUtil::ToChars<OperatorResultType>(OperatorResultType value);
-
-template<>
-const char* EnumUtil::ToChars<OptimizerType>(OptimizerType value);
-
-template<>
-const char* EnumUtil::ToChars<OrderByNullType>(OrderByNullType value);
-
-template<>
-const char* EnumUtil::ToChars<OrderPreservationType>(OrderPreservationType value);
-
-template<>
-const char* EnumUtil::ToChars<OrderType>(OrderType value);
-
-template<>
-const char* EnumUtil::ToChars<OutputStream>(OutputStream value);
-
-template<>
-const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value);
-
-template<>
-const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value);
-
-template<>
-const char* EnumUtil::ToChars<PartitionSortStage>(PartitionSortStage value);
-
-template<>
-const char* EnumUtil::ToChars<PartitionedColumnDataType>(PartitionedColumnDataType value);
-
-template<>
-const char* EnumUtil::ToChars<PartitionedTupleDataType>(PartitionedTupleDataType value);
-
-template<>
-const char* EnumUtil::ToChars<PendingExecutionResult>(PendingExecutionResult value);
-
-template<>
-const char* EnumUtil::ToChars<PhysicalOperatorType>(PhysicalOperatorType value);
-
-template<>
-const char* EnumUtil::ToChars<PhysicalType>(PhysicalType value);
-
-template<>
-const char* EnumUtil::ToChars<PragmaType>(PragmaType value);
-
-template<>
-const char* EnumUtil::ToChars<PreparedParamType>(PreparedParamType value);
-
-template<>
-const char* EnumUtil::ToChars<PreparedStatementMode>(PreparedStatementMode value);
-
-template<>
-const char* EnumUtil::ToChars<ProfilerPrintFormat>(ProfilerPrintFormat value);
-
-template<>
-const char* EnumUtil::ToChars<QuantileSerializationType>(QuantileSerializationType value);
-
-template<>
-const char* EnumUtil::ToChars<QueryNodeType>(QueryNodeType value);
-
-template<>
-const char* EnumUtil::ToChars<QueryResultType>(QueryResultType value);
-
-template<>
-const char* EnumUtil::ToChars<QuoteRule>(QuoteRule value);
-
-template<>
-const char* EnumUtil::ToChars<RelationType>(RelationType value);
-
-template<>
-const char* EnumUtil::ToChars<RenderMode>(RenderMode value);
-
-template<>
-const char* EnumUtil::ToChars<ResultModifierType>(ResultModifierType value);
-
-template<>
-const char* EnumUtil::ToChars<SampleMethod>(SampleMethod value);
-
-template<>
-const char* EnumUtil::ToChars<SampleType>(SampleType value);
-
-template<>
-const char* EnumUtil::ToChars<SamplingState>(SamplingState value);
-
-template<>
-const char* EnumUtil::ToChars<ScanType>(ScanType value);
-
-template<>
-const char* EnumUtil::ToChars<SecretDisplayType>(SecretDisplayType value);
-
-template<>
-const char* EnumUtil::ToChars<SecretPersistType>(SecretPersistType value);
-
-template<>
-const char* EnumUtil::ToChars<SecretSerializationType>(SecretSerializationType value);
-
-template<>
-const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value);
-
-template<>
-const char* EnumUtil::ToChars<SetOperationType>(SetOperationType value);
-
-template<>
-const char* EnumUtil::ToChars<SetScope>(SetScope value);
-
-template<>
-const char* EnumUtil::ToChars<SetType>(SetType value);
-
-template<>
-const char* EnumUtil::ToChars<SettingScope>(SettingScope value);
-
-template<>
-const char* EnumUtil::ToChars<ShowType>(ShowType value);
-
-template<>
-const char* EnumUtil::ToChars<SimplifiedTokenType>(SimplifiedTokenType value);
-
-template<>
-const char* EnumUtil::ToChars<SinkCombineResultType>(SinkCombineResultType value);
-
-template<>
-const char* EnumUtil::ToChars<SinkFinalizeType>(SinkFinalizeType value);
-
-template<>
-const char* EnumUtil::ToChars<SinkNextBatchType>(SinkNextBatchType value);
-
-template<>
-const char* EnumUtil::ToChars<SinkResultType>(SinkResultType value);
-
-template<>
-const char* EnumUtil::ToChars<SourceResultType>(SourceResultType value);
-
-template<>
-const char* EnumUtil::ToChars<StatementReturnType>(StatementReturnType value);
-
-template<>
-const char* EnumUtil::ToChars<StatementType>(StatementType value);
-
-template<>
-const char* EnumUtil::ToChars<StatisticsType>(StatisticsType value);
-
-template<>
-const char* EnumUtil::ToChars<StatsInfo>(StatsInfo value);
-
-template<>
-const char* EnumUtil::ToChars<StrTimeSpecifier>(StrTimeSpecifier value);
-
-template<>
-const char* EnumUtil::ToChars<StreamExecutionResult>(StreamExecutionResult value);
-
-template<>
-const char* EnumUtil::ToChars<SubqueryType>(SubqueryType value);
-
-template<>
-const char* EnumUtil::ToChars<TableColumnType>(TableColumnType value);
-
-template<>
-const char* EnumUtil::ToChars<TableFilterType>(TableFilterType value);
-
-template<>
-const char* EnumUtil::ToChars<TablePartitionInfo>(TablePartitionInfo value);
-
-template<>
-const char* EnumUtil::ToChars<TableReferenceType>(TableReferenceType value);
-
-template<>
-const char* EnumUtil::ToChars<TableScanType>(TableScanType value);
-
-template<>
-const char* EnumUtil::ToChars<TaskExecutionMode>(TaskExecutionMode value);
-
-template<>
-const char* EnumUtil::ToChars<TaskExecutionResult>(TaskExecutionResult value);
-
-template<>
-const char* EnumUtil::ToChars<TemporaryBufferSize>(TemporaryBufferSize value);
-
-template<>
-const char* EnumUtil::ToChars<TemporaryCompressionLevel>(TemporaryCompressionLevel value);
-
-template<>
-const char* EnumUtil::ToChars<TimestampCastResult>(TimestampCastResult value);
-
-template<>
-const char* EnumUtil::ToChars<TransactionModifierType>(TransactionModifierType value);
-
-template<>
-const char* EnumUtil::ToChars<TransactionType>(TransactionType value);
-
-template<>
-const char* EnumUtil::ToChars<TupleDataPinProperties>(TupleDataPinProperties value);
-
-template<>
-const char* EnumUtil::ToChars<UndoFlags>(UndoFlags value);
-
-template<>
-const char* EnumUtil::ToChars<UnionInvalidReason>(UnionInvalidReason value);
-
-template<>
-const char* EnumUtil::ToChars<VectorAuxiliaryDataType>(VectorAuxiliaryDataType value);
-
-template<>
-const char* EnumUtil::ToChars<VectorBufferType>(VectorBufferType value);
-
-template<>
-const char* EnumUtil::ToChars<VectorType>(VectorType value);
-
-template<>
-const char* EnumUtil::ToChars<VerificationType>(VerificationType value);
-
-template<>
-const char* EnumUtil::ToChars<VerifyExistenceType>(VerifyExistenceType value);
-
-template<>
-const char* EnumUtil::ToChars<WALType>(WALType value);
-
-template<>
-const char* EnumUtil::ToChars<WindowAggregationMode>(WindowAggregationMode value);
-
-template<>
-const char* EnumUtil::ToChars<WindowBoundary>(WindowBoundary value);
-
-template<>
-const char* EnumUtil::ToChars<WindowExcludeMode>(WindowExcludeMode value);
-
-
-template<>
-ARTAppendMode EnumUtil::FromString<ARTAppendMode>(const char *value);
-
-template<>
-ARTConflictType EnumUtil::FromString<ARTConflictType>(const char *value);
-
-template<>
-AccessMode EnumUtil::FromString<AccessMode>(const char *value);
-
-template<>
-AggregateCombineType EnumUtil::FromString<AggregateCombineType>(const char *value);
-
-template<>
-AggregateDistinctDependent EnumUtil::FromString<AggregateDistinctDependent>(const char *value);
-
-template<>
-AggregateHandling EnumUtil::FromString<AggregateHandling>(const char *value);
-
-template<>
-AggregateOrderDependent EnumUtil::FromString<AggregateOrderDependent>(const char *value);
-
-template<>
-AggregateType EnumUtil::FromString<AggregateType>(const char *value);
-
-template<>
-AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value);
-
-template<>
-AlterScalarFunctionType EnumUtil::FromString<AlterScalarFunctionType>(const char *value);
-
-template<>
-AlterTableFunctionType EnumUtil::FromString<AlterTableFunctionType>(const char *value);
-
-template<>
-AlterTableType EnumUtil::FromString<AlterTableType>(const char *value);
-
-template<>
-AlterType EnumUtil::FromString<AlterType>(const char *value);
-
-template<>
-AlterViewType EnumUtil::FromString<AlterViewType>(const char *value);
-
-template<>
-AppenderType EnumUtil::FromString<AppenderType>(const char *value);
-
-template<>
-ArrowDateTimeType EnumUtil::FromString<ArrowDateTimeType>(const char *value);
-
-template<>
-ArrowOffsetSize EnumUtil::FromString<ArrowOffsetSize>(const char *value);
-
-template<>
-ArrowTypeInfoType EnumUtil::FromString<ArrowTypeInfoType>(const char *value);
-
-template<>
-ArrowVariableSizeType EnumUtil::FromString<ArrowVariableSizeType>(const char *value);
-
-template<>
-BinderType EnumUtil::FromString<BinderType>(const char *value);
-
-template<>
-BindingMode EnumUtil::FromString<BindingMode>(const char *value);
-
-template<>
-BitpackingMode EnumUtil::FromString<BitpackingMode>(const char *value);
-
-template<>
-BlockState EnumUtil::FromString<BlockState>(const char *value);
-
-template<>
-CAPIResultSetType EnumUtil::FromString<CAPIResultSetType>(const char *value);
-
-template<>
-CSVState EnumUtil::FromString<CSVState>(const char *value);
-
-template<>
-CTEMaterialize EnumUtil::FromString<CTEMaterialize>(const char *value);
-
-template<>
-CatalogLookupBehavior EnumUtil::FromString<CatalogLookupBehavior>(const char *value);
-
-template<>
-CatalogType EnumUtil::FromString<CatalogType>(const char *value);
-
-template<>
-CheckpointAbort EnumUtil::FromString<CheckpointAbort>(const char *value);
-
-template<>
-ChunkInfoType EnumUtil::FromString<ChunkInfoType>(const char *value);
-
-template<>
-ColumnDataAllocatorType EnumUtil::FromString<ColumnDataAllocatorType>(const char *value);
-
-template<>
-ColumnDataScanProperties EnumUtil::FromString<ColumnDataScanProperties>(const char *value);
-
-template<>
-ColumnSegmentType EnumUtil::FromString<ColumnSegmentType>(const char *value);
-
-template<>
-CompressedMaterializationDirection EnumUtil::FromString<CompressedMaterializationDirection>(const char *value);
-
-template<>
-CompressionType EnumUtil::FromString<CompressionType>(const char *value);
-
-template<>
-CompressionValidity EnumUtil::FromString<CompressionValidity>(const char *value);
-
-template<>
-ConflictManagerMode EnumUtil::FromString<ConflictManagerMode>(const char *value);
-
-template<>
-ConstraintType EnumUtil::FromString<ConstraintType>(const char *value);
-
-template<>
-CopyFunctionReturnType EnumUtil::FromString<CopyFunctionReturnType>(const char *value);
-
-template<>
-CopyOverwriteMode EnumUtil::FromString<CopyOverwriteMode>(const char *value);
-
-template<>
-CopyToType EnumUtil::FromString<CopyToType>(const char *value);
-
-template<>
-DataFileType EnumUtil::FromString<DataFileType>(const char *value);
-
-template<>
-DateCastResult EnumUtil::FromString<DateCastResult>(const char *value);
-
-template<>
-DatePartSpecifier EnumUtil::FromString<DatePartSpecifier>(const char *value);
-
-template<>
-DebugInitialize EnumUtil::FromString<DebugInitialize>(const char *value);
-
-template<>
-DefaultOrderByNullType EnumUtil::FromString<DefaultOrderByNullType>(const char *value);
-
-template<>
-DependencyEntryType EnumUtil::FromString<DependencyEntryType>(const char *value);
-
-template<>
-DeprecatedIndexType EnumUtil::FromString<DeprecatedIndexType>(const char *value);
-
-template<>
-DestroyBufferUpon EnumUtil::FromString<DestroyBufferUpon>(const char *value);
-
-template<>
-DistinctType EnumUtil::FromString<DistinctType>(const char *value);
-
-template<>
-ErrorType EnumUtil::FromString<ErrorType>(const char *value);
-
-template<>
-ExceptionFormatValueType EnumUtil::FromString<ExceptionFormatValueType>(const char *value);
-
-template<>
-ExceptionType EnumUtil::FromString<ExceptionType>(const char *value);
-
-template<>
-ExplainFormat EnumUtil::FromString<ExplainFormat>(const char *value);
-
-template<>
-ExplainOutputType EnumUtil::FromString<ExplainOutputType>(const char *value);
-
-template<>
-ExplainType EnumUtil::FromString<ExplainType>(const char *value);
-
-template<>
-ExponentType EnumUtil::FromString<ExponentType>(const char *value);
-
-template<>
-ExpressionClass EnumUtil::FromString<ExpressionClass>(const char *value);
-
-template<>
-ExpressionType EnumUtil::FromString<ExpressionType>(const char *value);
-
-template<>
-ExtensionABIType EnumUtil::FromString<ExtensionABIType>(const char *value);
-
-template<>
-ExtensionInstallMode EnumUtil::FromString<ExtensionInstallMode>(const char *value);
-
-template<>
-ExtensionLoadResult EnumUtil::FromString<ExtensionLoadResult>(const char *value);
-
-template<>
-ExtensionUpdateResultTag EnumUtil::FromString<ExtensionUpdateResultTag>(const char *value);
-
-template<>
-ExtraDropInfoType EnumUtil::FromString<ExtraDropInfoType>(const char *value);
-
-template<>
-ExtraTypeInfoType EnumUtil::FromString<ExtraTypeInfoType>(const char *value);
-
-template<>
-FileBufferType EnumUtil::FromString<FileBufferType>(const char *value);
-
-template<>
-FileCompressionType EnumUtil::FromString<FileCompressionType>(const char *value);
-
-template<>
-FileExpandResult EnumUtil::FromString<FileExpandResult>(const char *value);
-
-template<>
-FileGlobOptions EnumUtil::FromString<FileGlobOptions>(const char *value);
-
-template<>
-FileLockType EnumUtil::FromString<FileLockType>(const char *value);
-
-template<>
-FilterPropagateResult EnumUtil::FromString<FilterPropagateResult>(const char *value);
-
-template<>
-ForeignKeyType EnumUtil::FromString<ForeignKeyType>(const char *value);
-
-template<>
-FunctionCollationHandling EnumUtil::FromString<FunctionCollationHandling>(const char *value);
-
-template<>
-FunctionErrors EnumUtil::FromString<FunctionErrors>(const char *value);
-
-template<>
-FunctionNullHandling EnumUtil::FromString<FunctionNullHandling>(const char *value);
-
-template<>
-FunctionStability EnumUtil::FromString<FunctionStability>(const char *value);
-
-template<>
-GateStatus EnumUtil::FromString<GateStatus>(const char *value);
-
-template<>
-HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value);
-
-template<>
-IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value);
-
-template<>
-InsertColumnOrder EnumUtil::FromString<InsertColumnOrder>(const char *value);
-
-template<>
-InterruptMode EnumUtil::FromString<InterruptMode>(const char *value);
-
-template<>
-JoinRefType EnumUtil::FromString<JoinRefType>(const char *value);
-
-template<>
-JoinType EnumUtil::FromString<JoinType>(const char *value);
-
-template<>
-KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value);
-
-template<>
-LimitNodeType EnumUtil::FromString<LimitNodeType>(const char *value);
-
-template<>
-LoadType EnumUtil::FromString<LoadType>(const char *value);
-
-template<>
-LogicalOperatorType EnumUtil::FromString<LogicalOperatorType>(const char *value);
-
-template<>
-LogicalTypeId EnumUtil::FromString<LogicalTypeId>(const char *value);
-
-template<>
-LookupResultType EnumUtil::FromString<LookupResultType>(const char *value);
-
-template<>
-MacroType EnumUtil::FromString<MacroType>(const char *value);
-
-template<>
-MapInvalidReason EnumUtil::FromString<MapInvalidReason>(const char *value);
-
-template<>
-MemoryTag EnumUtil::FromString<MemoryTag>(const char *value);
-
-template<>
-MetaPipelineType EnumUtil::FromString<MetaPipelineType>(const char *value);
-
-template<>
-MetricsType EnumUtil::FromString<MetricsType>(const char *value);
-
-template<>
-NType EnumUtil::FromString<NType>(const char *value);
-
-template<>
-NewLineIdentifier EnumUtil::FromString<NewLineIdentifier>(const char *value);
-
-template<>
-OnConflictAction EnumUtil::FromString<OnConflictAction>(const char *value);
-
-template<>
-OnCreateConflict EnumUtil::FromString<OnCreateConflict>(const char *value);
-
-template<>
-OnEntryNotFound EnumUtil::FromString<OnEntryNotFound>(const char *value);
-
-template<>
-OperatorFinalizeResultType EnumUtil::FromString<OperatorFinalizeResultType>(const char *value);
-
-template<>
-OperatorResultType EnumUtil::FromString<OperatorResultType>(const char *value);
-
-template<>
-OptimizerType EnumUtil::FromString<OptimizerType>(const char *value);
-
-template<>
-OrderByNullType EnumUtil::FromString<OrderByNullType>(const char *value);
-
-template<>
-OrderPreservationType EnumUtil::FromString<OrderPreservationType>(const char *value);
-
-template<>
-OrderType EnumUtil::FromString<OrderType>(const char *value);
-
-template<>
-OutputStream EnumUtil::FromString<OutputStream>(const char *value);
-
-template<>
-ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value);
-
-template<>
-ParserExtensionResultType EnumUtil::FromString<ParserExtensionResultType>(const char *value);
-
-template<>
-PartitionSortStage EnumUtil::FromString<PartitionSortStage>(const char *value);
-
-template<>
-PartitionedColumnDataType EnumUtil::FromString<PartitionedColumnDataType>(const char *value);
-
-template<>
-PartitionedTupleDataType EnumUtil::FromString<PartitionedTupleDataType>(const char *value);
-
-template<>
-PendingExecutionResult EnumUtil::FromString<PendingExecutionResult>(const char *value);
-
-template<>
-PhysicalOperatorType EnumUtil::FromString<PhysicalOperatorType>(const char *value);
-
-template<>
-PhysicalType EnumUtil::FromString<PhysicalType>(const char *value);
-
-template<>
-PragmaType EnumUtil::FromString<PragmaType>(const char *value);
-
-template<>
-PreparedParamType EnumUtil::FromString<PreparedParamType>(const char *value);
-
-template<>
-PreparedStatementMode EnumUtil::FromString<PreparedStatementMode>(const char *value);
-
-template<>
-ProfilerPrintFormat EnumUtil::FromString<ProfilerPrintFormat>(const char *value);
-
-template<>
-QuantileSerializationType EnumUtil::FromString<QuantileSerializationType>(const char *value);
-
-template<>
-QueryNodeType EnumUtil::FromString<QueryNodeType>(const char *value);
-
-template<>
-QueryResultType EnumUtil::FromString<QueryResultType>(const char *value);
-
-template<>
-QuoteRule EnumUtil::FromString<QuoteRule>(const char *value);
-
-template<>
-RelationType EnumUtil::FromString<RelationType>(const char *value);
-
-template<>
-RenderMode EnumUtil::FromString<RenderMode>(const char *value);
-
-template<>
-ResultModifierType EnumUtil::FromString<ResultModifierType>(const char *value);
-
-template<>
-SampleMethod EnumUtil::FromString<SampleMethod>(const char *value);
-
-template<>
-SampleType EnumUtil::FromString<SampleType>(const char *value);
-
-template<>
-SamplingState EnumUtil::FromString<SamplingState>(const char *value);
-
-template<>
-ScanType EnumUtil::FromString<ScanType>(const char *value);
-
-template<>
-SecretDisplayType EnumUtil::FromString<SecretDisplayType>(const char *value);
-
-template<>
-SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value);
-
-template<>
-SecretSerializationType EnumUtil::FromString<SecretSerializationType>(const char *value);
-
-template<>
-SequenceInfo EnumUtil::FromString<SequenceInfo>(const char *value);
-
-template<>
-SetOperationType EnumUtil::FromString<SetOperationType>(const char *value);
-
-template<>
-SetScope EnumUtil::FromString<SetScope>(const char *value);
-
-template<>
-SetType EnumUtil::FromString<SetType>(const char *value);
-
-template<>
-SettingScope EnumUtil::FromString<SettingScope>(const char *value);
-
-template<>
-ShowType EnumUtil::FromString<ShowType>(const char *value);
-
-template<>
-SimplifiedTokenType EnumUtil::FromString<SimplifiedTokenType>(const char *value);
-
-template<>
-SinkCombineResultType EnumUtil::FromString<SinkCombineResultType>(const char *value);
-
-template<>
-SinkFinalizeType EnumUtil::FromString<SinkFinalizeType>(const char *value);
-
-template<>
-SinkNextBatchType EnumUtil::FromString<SinkNextBatchType>(const char *value);
-
-template<>
-SinkResultType EnumUtil::FromString<SinkResultType>(const char *value);
-
-template<>
-SourceResultType EnumUtil::FromString<SourceResultType>(const char *value);
-
-template<>
-StatementReturnType EnumUtil::FromString<StatementReturnType>(const char *value);
-
-template<>
-StatementType EnumUtil::FromString<StatementType>(const char *value);
-
-template<>
-StatisticsType EnumUtil::FromString<StatisticsType>(const char *value);
-
-template<>
-StatsInfo EnumUtil::FromString<StatsInfo>(const char *value);
-
-template<>
-StrTimeSpecifier EnumUtil::FromString<StrTimeSpecifier>(const char *value);
-
-template<>
-StreamExecutionResult EnumUtil::FromString<StreamExecutionResult>(const char *value);
-
-template<>
-SubqueryType EnumUtil::FromString<SubqueryType>(const char *value);
-
-template<>
-TableColumnType EnumUtil::FromString<TableColumnType>(const char *value);
-
-template<>
-TableFilterType EnumUtil::FromString<TableFilterType>(const char *value);
-
-template<>
-TablePartitionInfo EnumUtil::FromString<TablePartitionInfo>(const char *value);
-
-template<>
-TableReferenceType EnumUtil::FromString<TableReferenceType>(const char *value);
-
-template<>
-TableScanType EnumUtil::FromString<TableScanType>(const char *value);
-
-template<>
-TaskExecutionMode EnumUtil::FromString<TaskExecutionMode>(const char *value);
-
-template<>
-TaskExecutionResult EnumUtil::FromString<TaskExecutionResult>(const char *value);
-
-template<>
-TemporaryBufferSize EnumUtil::FromString<TemporaryBufferSize>(const char *value);
-
-template<>
-TemporaryCompressionLevel EnumUtil::FromString<TemporaryCompressionLevel>(const char *value);
-
-template<>
-TimestampCastResult EnumUtil::FromString<TimestampCastResult>(const char *value);
-
-template<>
-TransactionModifierType EnumUtil::FromString<TransactionModifierType>(const char *value);
-
-template<>
-TransactionType EnumUtil::FromString<TransactionType>(const char *value);
-
-template<>
-TupleDataPinProperties EnumUtil::FromString<TupleDataPinProperties>(const char *value);
-
-template<>
-UndoFlags EnumUtil::FromString<UndoFlags>(const char *value);
-
-template<>
-UnionInvalidReason EnumUtil::FromString<UnionInvalidReason>(const char *value);
-
-template<>
-VectorAuxiliaryDataType EnumUtil::FromString<VectorAuxiliaryDataType>(const char *value);
-
-template<>
-VectorBufferType EnumUtil::FromString<VectorBufferType>(const char *value);
-
-template<>
-VectorType EnumUtil::FromString<VectorType>(const char *value);
-
-template<>
-VerificationType EnumUtil::FromString<VerificationType>(const char *value);
-
-template<>
-VerifyExistenceType EnumUtil::FromString<VerifyExistenceType>(const char *value);
-
-template<>
-WALType EnumUtil::FromString<WALType>(const char *value);
-
-template<>
-WindowAggregationMode EnumUtil::FromString<WindowAggregationMode>(const char *value);
-
-template<>
-WindowBoundary EnumUtil::FromString<WindowBoundary>(const char *value);
-
-template<>
-WindowExcludeMode EnumUtil::FromString<WindowExcludeMode>(const char *value);
-
-
-}
diff --git a/src/duckdb/src/include/duckdb/common/enums/access_mode.hpp b/src/duckdb/src/include/duckdb/common/enums/access_mode.hpp
deleted file mode 100644
index bc1c61708..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/access_mode.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/access_mode.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class AccessMode : uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/aggregate_handling.hpp b/src/duckdb/src/include/duckdb/common/enums/aggregate_handling.hpp
deleted file mode 100644
index f11aec033..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/aggregate_handling.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/aggregate_handling.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===----
-enum class AggregateHandling : uint8_t {
-	STANDARD_HANDLING,     // standard handling as in the SELECT clause
-	NO_AGGREGATES_ALLOWED, // no aggregates allowed: any aggregates in this node will result in an error
-	FORCE_AGGREGATES       // force aggregates: any non-aggregate select list entry will become a GROUP
-};
-
-const char *ToString(AggregateHandling value);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/catalog_lookup_behavior.hpp b/src/duckdb/src/include/duckdb/common/enums/catalog_lookup_behavior.hpp
deleted file mode 100644
index b374662c6..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/catalog_lookup_behavior.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/catalog_lookup_behavior.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//! Enum used for indicating lookup behavior of specific catalog types
-// STANDARD means the catalog lookups are performed in a regular manner (i.e. according to the users' search path)
-// LOWER_PRIORITY means the catalog lookups are de-prioritized and we do lookups in other catalogs first
-// NEVER_LOOKUP means we never do lookups for this specific type in this catalog
-enum class CatalogLookupBehavior : uint8_t { STANDARD = 0, LOWER_PRIORITY = 1, NEVER_LOOKUP = 2 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/catalog_type.hpp b/src/duckdb/src/include/duckdb/common/enums/catalog_type.hpp
deleted file mode 100644
index 3e18e666e..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/catalog_type.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/catalog_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Catalog Types
-//===--------------------------------------------------------------------===//
-enum class CatalogType : uint8_t {
-	INVALID = 0,
-	TABLE_ENTRY = 1,
-	SCHEMA_ENTRY = 2,
-	VIEW_ENTRY = 3,
-	INDEX_ENTRY = 4,
-	PREPARED_STATEMENT = 5,
-	SEQUENCE_ENTRY = 6,
-	COLLATION_ENTRY = 7,
-	TYPE_ENTRY = 8,
-	DATABASE_ENTRY = 9,
-
-	// functions
-	TABLE_FUNCTION_ENTRY = 25,
-	SCALAR_FUNCTION_ENTRY = 26,
-	AGGREGATE_FUNCTION_ENTRY = 27,
-	PRAGMA_FUNCTION_ENTRY = 28,
-	COPY_FUNCTION_ENTRY = 29,
-	MACRO_ENTRY = 30,
-	TABLE_MACRO_ENTRY = 31,
-
-	// version info
-	DELETED_ENTRY = 51,
-	RENAMED_ENTRY = 52,
-
-	// secrets
-	SECRET_ENTRY = 71,
-	SECRET_TYPE_ENTRY = 72,
-	SECRET_FUNCTION_ENTRY = 73,
-
-	// dependency info
-	DEPENDENCY_ENTRY = 100
-
-};
-
-DUCKDB_API string CatalogTypeToString(CatalogType type);
-CatalogType CatalogTypeFromString(const string &type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/checkpoint_type.hpp b/src/duckdb/src/include/duckdb/common/enums/checkpoint_type.hpp
deleted file mode 100644
index 9ad3b4529..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/checkpoint_type.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/checkpoint_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class CheckpointWALAction {
-	//! Delete the WAL file after the checkpoint completes - generally done on shutdown
-	DELETE_WAL,
-	//! Leave the WAL file alone
-	DONT_DELETE_WAL
-};
-
-enum class CheckpointAction {
-	//! Checkpoint only if a checkpoint is required (i.e. the WAL has data in it that can be flushed)
-	CHECKPOINT_IF_REQUIRED,
-	//! Always checkpoint regardless of whether or not there is data in the WAL to flush
-	ALWAYS_CHECKPOINT
-};
-
-enum class CheckpointType {
-	//! Full checkpoints involve vacuuming deleted rows and updates
-	//! They can only be run if no transaction need to read old data (that would be cleaned up/vacuumed)
-	FULL_CHECKPOINT,
-	//! Concurrent checkpoints write committed data to disk but do less clean-up
-	//! They can be run even when active transactions need to read old data
-	CONCURRENT_CHECKPOINT
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/collation_type.hpp b/src/duckdb/src/include/duckdb/common/enums/collation_type.hpp
deleted file mode 100644
index bd1a6e95a..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/collation_type.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/collation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-enum class CollationType { ALL_COLLATIONS, COMBINABLE_COLLATIONS };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp b/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp
deleted file mode 100644
index a8753f12b..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/compression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-enum class CompressionType : uint8_t {
-	COMPRESSION_AUTO = 0,
-	COMPRESSION_UNCOMPRESSED = 1,
-	COMPRESSION_CONSTANT = 2, // internal only
-	COMPRESSION_RLE = 3,
-	COMPRESSION_DICTIONARY = 4,
-	COMPRESSION_PFOR_DELTA = 5,
-	COMPRESSION_BITPACKING = 6,
-	COMPRESSION_FSST = 7,
-	COMPRESSION_CHIMP = 8,
-	COMPRESSION_PATAS = 9,
-	COMPRESSION_ALP = 10,
-	COMPRESSION_ALPRD = 11,
-	COMPRESSION_ZSTD = 12,
-	COMPRESSION_ROARING = 13,
-	COMPRESSION_EMPTY = 14, // internal only
-	COMPRESSION_COUNT       // This has to stay the last entry of the type!
-};
-
-bool CompressionTypeIsDeprecated(CompressionType compression_type);
-vector<string> ListCompressionTypes(void);
-CompressionType CompressionTypeFromString(const string &str);
-string CompressionTypeToString(CompressionType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/copy_overwrite_mode.hpp b/src/duckdb/src/include/duckdb/common/enums/copy_overwrite_mode.hpp
deleted file mode 100644
index 89644f899..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/copy_overwrite_mode.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/copy_overwrite_mode.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-enum class CopyOverwriteMode : uint8_t {
-	COPY_ERROR_ON_CONFLICT = 0,
-	COPY_OVERWRITE = 1,
-	COPY_OVERWRITE_OR_IGNORE = 2,
-	COPY_APPEND = 3
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/cte_materialize.hpp b/src/duckdb/src/include/duckdb/common/enums/cte_materialize.hpp
deleted file mode 100644
index 356d298ab..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/cte_materialize.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/cte_materialize.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class CTEMaterialize : uint8_t {
-	CTE_MATERIALIZE_DEFAULT = 1, /* no option specified */
-	CTE_MATERIALIZE_ALWAYS = 2,  /* MATERIALIZED */
-	CTE_MATERIALIZE_NEVER = 3    /* NOT MATERIALIZED */
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/date_part_specifier.hpp b/src/duckdb/src/include/duckdb/common/enums/date_part_specifier.hpp
deleted file mode 100644
index 54e2790e1..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/date_part_specifier.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/date_part_specifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class DatePartSpecifier : uint8_t {
-	//	BIGINT values
-	YEAR,
-	MONTH,
-	DAY,
-	DECADE,
-	CENTURY,
-	MILLENNIUM,
-	MICROSECONDS,
-	MILLISECONDS,
-	SECOND,
-	MINUTE,
-	HOUR,
-	DOW,
-	ISODOW,
-	WEEK,
-	ISOYEAR,
-	QUARTER,
-	DOY,
-	YEARWEEK,
-	ERA,
-	TIMEZONE,
-	TIMEZONE_HOUR,
-	TIMEZONE_MINUTE,
-
-	//	DOUBLE values
-	EPOCH,
-	JULIAN_DAY,
-
-	//	Invalid
-	INVALID,
-
-	//	Type ranges
-	BEGIN_BIGINT = YEAR,
-	BEGIN_DOUBLE = EPOCH,
-	BEGIN_INVALID = INVALID,
-};
-
-inline bool IsBigintDatepart(DatePartSpecifier part_code) {
-	return size_t(part_code) < size_t(DatePartSpecifier::BEGIN_DOUBLE);
-}
-
-DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
-DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/debug_initialize.hpp b/src/duckdb/src/include/duckdb/common/enums/debug_initialize.hpp
deleted file mode 100644
index 5cf794e08..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/debug_initialize.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/debug_initialize.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class DebugInitialize : uint8_t { NO_INITIALIZE = 0, DEBUG_ZERO_INITIALIZE = 1, DEBUG_ONE_INITIALIZE = 2 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/destroy_buffer_upon.hpp b/src/duckdb/src/include/duckdb/common/enums/destroy_buffer_upon.hpp
deleted file mode 100644
index edc68a3db..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/destroy_buffer_upon.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/destroy_buffer_upon.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class DestroyBufferUpon : uint8_t {
-	BLOCK = 0,    //! Destroy the data buffer upon destroying the associated BlockHandle (block can be evicted)
-	EVICTION = 1, //! Destroy the data buffer upon eviction to storage (destroy instead of evict)
-	UNPIN = 2     //! Destroy the data buffer upon unpin (destroyed immediately, not added to eviction queue)
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/explain_format.hpp b/src/duckdb/src/include/duckdb/common/enums/explain_format.hpp
deleted file mode 100644
index 89cdc074c..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/explain_format.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/explain_format.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-
-namespace duckdb {
-
-enum class ExplainFormat : uint8_t { DEFAULT, TEXT, JSON, HTML, GRAPHVIZ };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp b/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp
deleted file mode 100644
index 858781aa9..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/expression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Predicate Expression Operation Types
-//===--------------------------------------------------------------------===//
-enum class ExpressionType : uint8_t {
-	INVALID = 0,
-
-	// explicitly cast left as right (right is integer in ValueType enum)
-	OPERATOR_CAST = 12,
-	// logical not operator
-	OPERATOR_NOT = 13,
-	// is null operator
-	OPERATOR_IS_NULL = 14,
-	// is not null operator
-	OPERATOR_IS_NOT_NULL = 15,
-
-	// -----------------------------
-	// Comparison Operators
-	// -----------------------------
-	// equal operator between left and right
-	COMPARE_EQUAL = 25,
-	// compare initial boundary
-	COMPARE_BOUNDARY_START = COMPARE_EQUAL,
-	// inequal operator between left and right
-	COMPARE_NOTEQUAL = 26,
-	// less than operator between left and right
-	COMPARE_LESSTHAN = 27,
-	// greater than operator between left and right
-	COMPARE_GREATERTHAN = 28,
-	// less than equal operator between left and right
-	COMPARE_LESSTHANOREQUALTO = 29,
-	// greater than equal operator between left and right
-	COMPARE_GREATERTHANOREQUALTO = 30,
-	// IN operator [left IN (right1, right2, ...)]
-	COMPARE_IN = 35,
-	// NOT IN operator [left NOT IN (right1, right2, ...)]
-	COMPARE_NOT_IN = 36,
-	// IS DISTINCT FROM operator
-	COMPARE_DISTINCT_FROM = 37,
-
-	COMPARE_BETWEEN = 38,
-	COMPARE_NOT_BETWEEN = 39,
-	// IS NOT DISTINCT FROM operator
-	COMPARE_NOT_DISTINCT_FROM = 40,
-	// compare final boundary
-	COMPARE_BOUNDARY_END = COMPARE_NOT_DISTINCT_FROM,
-
-	// -----------------------------
-	// Conjunction Operators
-	// -----------------------------
-	CONJUNCTION_AND = 50,
-	CONJUNCTION_OR = 51,
-
-	// -----------------------------
-	// Values
-	// -----------------------------
-	VALUE_CONSTANT = 75,
-	VALUE_PARAMETER = 76,
-	VALUE_TUPLE = 77,
-	VALUE_TUPLE_ADDRESS = 78,
-	VALUE_NULL = 79,
-	VALUE_VECTOR = 80,
-	VALUE_SCALAR = 81,
-	VALUE_DEFAULT = 82,
-
-	// -----------------------------
-	// Aggregates
-	// -----------------------------
-	AGGREGATE = 100,
-	BOUND_AGGREGATE = 101,
-	GROUPING_FUNCTION = 102,
-
-	// -----------------------------
-	// Window Functions
-	// -----------------------------
-	WINDOW_AGGREGATE = 110,
-
-	WINDOW_RANK = 120,
-	WINDOW_RANK_DENSE = 121,
-	WINDOW_NTILE = 122,
-	WINDOW_PERCENT_RANK = 123,
-	WINDOW_CUME_DIST = 124,
-	WINDOW_ROW_NUMBER = 125,
-
-	WINDOW_FIRST_VALUE = 130,
-	WINDOW_LAST_VALUE = 131,
-	WINDOW_LEAD = 132,
-	WINDOW_LAG = 133,
-	WINDOW_NTH_VALUE = 134,
-
-	// -----------------------------
-	// Functions
-	// -----------------------------
-	FUNCTION = 140,
-	BOUND_FUNCTION = 141,
-
-	// -----------------------------
-	// Operators
-	// -----------------------------
-	CASE_EXPR = 150,
-	OPERATOR_NULLIF = 151,
-	OPERATOR_COALESCE = 152,
-	ARRAY_EXTRACT = 153,
-	ARRAY_SLICE = 154,
-	STRUCT_EXTRACT = 155,
-	ARRAY_CONSTRUCTOR = 156,
-	ARROW = 157,
-
-	// -----------------------------
-	// Subquery IN/EXISTS
-	// -----------------------------
-	SUBQUERY = 175,
-
-	// -----------------------------
-	// Parser
-	// -----------------------------
-	STAR = 200,
-	TABLE_STAR = 201,
-	PLACEHOLDER = 202,
-	COLUMN_REF = 203,
-	FUNCTION_REF = 204,
-	TABLE_REF = 205,
-	LAMBDA_REF = 206,
-
-	// -----------------------------
-	// Miscellaneous
-	// -----------------------------
-	CAST = 225,
-	BOUND_REF = 227,
-	BOUND_COLUMN_REF = 228,
-	BOUND_UNNEST = 229,
-	COLLATE = 230,
-	LAMBDA = 231,
-	POSITIONAL_REFERENCE = 232,
-	BOUND_LAMBDA_REF = 233,
-	BOUND_EXPANDED = 234
-};
-
-//===--------------------------------------------------------------------===//
-// Expression Class
-//===--------------------------------------------------------------------===//
-enum class ExpressionClass : uint8_t {
-	INVALID = 0,
-	//===--------------------------------------------------------------------===//
-	// Parsed Expressions
-	//===--------------------------------------------------------------------===//
-	AGGREGATE = 1,
-	CASE = 2,
-	CAST = 3,
-	COLUMN_REF = 4,
-	COMPARISON = 5,
-	CONJUNCTION = 6,
-	CONSTANT = 7,
-	DEFAULT = 8,
-	FUNCTION = 9,
-	OPERATOR = 10,
-	STAR = 11,
-	SUBQUERY = 13,
-	WINDOW = 14,
-	PARAMETER = 15,
-	COLLATE = 16,
-	LAMBDA = 17,
-	POSITIONAL_REFERENCE = 18,
-	BETWEEN = 19,
-	LAMBDA_REF = 20,
-	//===--------------------------------------------------------------------===//
-	// Bound Expressions
-	//===--------------------------------------------------------------------===//
-	BOUND_AGGREGATE = 25,
-	BOUND_CASE = 26,
-	BOUND_CAST = 27,
-	BOUND_COLUMN_REF = 28,
-	BOUND_COMPARISON = 29,
-	BOUND_CONJUNCTION = 30,
-	BOUND_CONSTANT = 31,
-	BOUND_DEFAULT = 32,
-	BOUND_FUNCTION = 33,
-	BOUND_OPERATOR = 34,
-	BOUND_PARAMETER = 35,
-	BOUND_REF = 36,
-	BOUND_SUBQUERY = 37,
-	BOUND_WINDOW = 38,
-	BOUND_BETWEEN = 39,
-	BOUND_UNNEST = 40,
-	BOUND_LAMBDA = 41,
-	BOUND_LAMBDA_REF = 42,
-	//===--------------------------------------------------------------------===//
-	// Miscellaneous
-	//===--------------------------------------------------------------------===//
-	BOUND_EXPRESSION = 50,
-	BOUND_EXPANDED = 51
-};
-
-DUCKDB_API string ExpressionTypeToString(ExpressionType type);
-string ExpressionTypeToOperator(ExpressionType type);
-
-// Operator String to ExpressionType (e.g. + => OPERATOR_ADD)
-ExpressionType OperatorToExpressionType(const string &op);
-//! Negate a comparison expression, turning e.g. = into !=, or < into >=
-ExpressionType NegateComparisonExpression(ExpressionType type);
-//! Flip a comparison expression, turning e.g. < into >, or = into =
-ExpressionType FlipComparisonExpression(ExpressionType type);
-
-DUCKDB_API string ExpressionClassToString(ExpressionClass type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/file_compression_type.hpp b/src/duckdb/src/include/duckdb/common/enums/file_compression_type.hpp
deleted file mode 100644
index 77b66b392..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/file_compression_type.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/file_compression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class FileCompressionType : uint8_t { AUTO_DETECT = 0, UNCOMPRESSED = 1, GZIP = 2, ZSTD = 3 };
-
-FileCompressionType FileCompressionTypeFromString(const string &input);
-
-string CompressionExtensionFromType(const FileCompressionType type);
-
-bool IsFileCompressed(string path, FileCompressionType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/file_glob_options.hpp b/src/duckdb/src/include/duckdb/common/enums/file_glob_options.hpp
deleted file mode 100644
index 94f528d59..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/file_glob_options.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/file_glob_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class FileGlobOptions : uint8_t {
-	DISALLOW_EMPTY = 0,
-	ALLOW_EMPTY = 1,
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/filter_propagate_result.hpp b/src/duckdb/src/include/duckdb/common/enums/filter_propagate_result.hpp
deleted file mode 100644
index edf239eb9..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/filter_propagate_result.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/filter_propagate_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class FilterPropagateResult : uint8_t {
-	NO_PRUNING_POSSIBLE = 0,
-	FILTER_ALWAYS_TRUE = 1,
-	FILTER_ALWAYS_FALSE = 2,
-	FILTER_TRUE_OR_NULL = 3,
-	FILTER_FALSE_OR_NULL = 4
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp b/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp
deleted file mode 100644
index 3d37c53e0..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/function_errors.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-//! Whether or not a function can throw an error or not
-enum class FunctionErrors : uint8_t { CANNOT_ERROR = 0, CAN_THROW_RUNTIME_ERROR = 1 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/index_constraint_type.hpp b/src/duckdb/src/include/duckdb/common/enums/index_constraint_type.hpp
deleted file mode 100644
index 1e40dd4f3..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/index_constraint_type.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/index_constraint_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Index Constraint Types
-//===--------------------------------------------------------------------===//
-enum class IndexConstraintType : uint8_t {
-	NONE = 0,    // index is an index don't built to any constraint
-	UNIQUE = 1,  // index is an index built to enforce a UNIQUE constraint
-	PRIMARY = 2, // index is an index built to enforce a PRIMARY KEY constraint
-	FOREIGN = 3  // index is an index built to enforce a FOREIGN KEY constraint
-};
-
-//===--------------------------------------------------------------------===//
-// Index Types
-//===--------------------------------------------------------------------===//
-// NOTE: deprecated. Still necessary to read older duckdb files.
-enum class DeprecatedIndexType : uint8_t {
-	INVALID = 0,    // invalid index type
-	ART = 1,        // Adaptive Radix Tree
-	EXTENSION = 100 // Extension index
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/join_type.hpp b/src/duckdb/src/include/duckdb/common/enums/join_type.hpp
deleted file mode 100644
index 8ba8e2729..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/join_type.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/join_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Join Types
-//===--------------------------------------------------------------------===//
-enum class JoinType : uint8_t {
-	INVALID = 0, // invalid join type
-	LEFT = 1,    // left
-	RIGHT = 2,   // right
-	INNER = 3,   // inner
-	OUTER = 4,   // outer
-	SEMI = 5,    // LEFT SEMI join returns left side row ONLY if it has a join partner, no duplicates.
-	ANTI = 6,    // LEFT ANTI join returns left side row ONLY if it has NO join partner, no duplicates
-	MARK = 7,    // MARK join returns marker indicating whether or not there is a join partner (true), there is no join
-	             // partner (false)
-	SINGLE = 8,  // SINGLE join is like LEFT OUTER JOIN, BUT returns at most one join partner per entry on the LEFT side
-	             // (and NULL if no partner is found)
-	RIGHT_SEMI = 9, // RIGHT SEMI join is created by the optimizer when the children of a semi join need to be switched
-	                // so that the build side can be the smaller table
-	RIGHT_ANTI = 10 // RIGHT ANTI join is created by the optimizer when the children of an anti join need to be
-	                // switched so that the build side can be the smaller table
-};
-
-//! True if join is left or full outer join
-bool IsLeftOuterJoin(JoinType type);
-
-//! True if join is rght or full outer join
-bool IsRightOuterJoin(JoinType type);
-
-//! Whether the build side is propagated out of the join
-bool PropagatesBuildSide(JoinType type);
-
-//! Whether the JoinType has an inverse
-bool HasInverseJoinType(JoinType type);
-
-//! Gets the inverse JoinType, e.g., LEFT -> RIGHT
-JoinType InverseJoinType(JoinType type);
-
-// **DEPRECATED**: Use EnumUtil directly instead.
-string JoinTypeToString(JoinType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp b/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp
deleted file mode 100644
index 85b8c66bb..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/joinref_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Join Reference Types
-//===--------------------------------------------------------------------===//
-enum class JoinRefType : uint8_t {
-	REGULAR,    // Explicit conditions
-	NATURAL,    // Implied conditions
-	CROSS,      // No condition
-	POSITIONAL, // Positional condition
-	ASOF,       // AsOf conditions
-	DEPENDENT,  // Dependent join conditions
-};
-
-const char *ToString(JoinRefType value);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp b/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp
deleted file mode 100644
index 1375886ba..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/logical_operator_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Logical Operator Types
-//===--------------------------------------------------------------------===//
-enum class LogicalOperatorType : uint8_t {
-	LOGICAL_INVALID = 0,
-	LOGICAL_PROJECTION = 1,
-	LOGICAL_FILTER = 2,
-	LOGICAL_AGGREGATE_AND_GROUP_BY = 3,
-	LOGICAL_WINDOW = 4,
-	LOGICAL_UNNEST = 5,
-	LOGICAL_LIMIT = 6,
-	LOGICAL_ORDER_BY = 7,
-	LOGICAL_TOP_N = 8,
-	LOGICAL_COPY_TO_FILE = 10,
-	LOGICAL_DISTINCT = 11,
-	LOGICAL_SAMPLE = 12,
-	LOGICAL_PIVOT = 14,
-	LOGICAL_COPY_DATABASE = 15,
-
-	// -----------------------------
-	// Data sources
-	// -----------------------------
-	LOGICAL_GET = 25,
-	LOGICAL_CHUNK_GET = 26,
-	LOGICAL_DELIM_GET = 27,
-	LOGICAL_EXPRESSION_GET = 28,
-	LOGICAL_DUMMY_SCAN = 29,
-	LOGICAL_EMPTY_RESULT = 30,
-	LOGICAL_CTE_REF = 31,
-	// -----------------------------
-	// Joins
-	// -----------------------------
-	LOGICAL_JOIN = 50,
-	LOGICAL_DELIM_JOIN = 51,
-	LOGICAL_COMPARISON_JOIN = 52,
-	LOGICAL_ANY_JOIN = 53,
-	LOGICAL_CROSS_PRODUCT = 54,
-	LOGICAL_POSITIONAL_JOIN = 55,
-	LOGICAL_ASOF_JOIN = 56,
-	LOGICAL_DEPENDENT_JOIN = 57,
-	// -----------------------------
-	// SetOps
-	// -----------------------------
-	LOGICAL_UNION = 75,
-	LOGICAL_EXCEPT = 76,
-	LOGICAL_INTERSECT = 77,
-	LOGICAL_RECURSIVE_CTE = 78,
-	LOGICAL_MATERIALIZED_CTE = 79,
-
-	// -----------------------------
-	// Updates
-	// -----------------------------
-	LOGICAL_INSERT = 100,
-	LOGICAL_DELETE = 101,
-	LOGICAL_UPDATE = 102,
-
-	// -----------------------------
-	// Schema
-	// -----------------------------
-	LOGICAL_ALTER = 125,
-	LOGICAL_CREATE_TABLE = 126,
-	LOGICAL_CREATE_INDEX = 127,
-	LOGICAL_CREATE_SEQUENCE = 128,
-	LOGICAL_CREATE_VIEW = 129,
-	LOGICAL_CREATE_SCHEMA = 130,
-	LOGICAL_CREATE_MACRO = 131,
-	LOGICAL_DROP = 132,
-	LOGICAL_PRAGMA = 133,
-	LOGICAL_TRANSACTION = 134,
-	LOGICAL_CREATE_TYPE = 135,
-	LOGICAL_ATTACH = 136,
-	LOGICAL_DETACH = 137,
-
-	// -----------------------------
-	// Explain
-	// -----------------------------
-	LOGICAL_EXPLAIN = 150,
-
-	// -----------------------------
-	// Helpers
-	// -----------------------------
-	LOGICAL_PREPARE = 175,
-	LOGICAL_EXECUTE = 176,
-	LOGICAL_EXPORT = 177,
-	LOGICAL_VACUUM = 178,
-	LOGICAL_SET = 179,
-	LOGICAL_LOAD = 180,
-	LOGICAL_RESET = 181,
-	LOGICAL_UPDATE_EXTENSIONS = 182,
-
-	// -----------------------------
-	// Secrets
-	// -----------------------------
-	LOGICAL_CREATE_SECRET = 190,
-
-	LOGICAL_EXTENSION_OPERATOR = 255
-};
-
-DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp b/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp
deleted file mode 100644
index e38a720e4..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/memory_tag.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class MemoryTag : uint8_t {
-	BASE_TABLE = 0,
-	HASH_TABLE = 1,
-	PARQUET_READER = 2,
-	CSV_READER = 3,
-	ORDER_BY = 4,
-	ART_INDEX = 5,
-	COLUMN_DATA = 6,
-	METADATA = 7,
-	OVERFLOW_STRINGS = 8,
-	IN_MEMORY_TABLE = 9,
-	ALLOCATOR = 10,
-	EXTENSION = 11,
-	TRANSACTION = 12
-};
-
-static constexpr const idx_t MEMORY_TAG_COUNT = 13;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp b/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp
deleted file mode 100644
index c133faada..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//-------------------------------------------------------------------------
-//                         DuckDB
-//
-//
-// duckdb/common/enums/metrics_type.hpp
-// 
-// This file is automatically generated by scripts/generate_metric_enums.py
-// Do not edit this file manually, your changes will be overwritten
-//-------------------------------------------------------------------------
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/enums/optimizer_type.hpp"
-
-namespace duckdb {
-
-enum class MetricsType : uint8_t {
-    QUERY_NAME,
-    BLOCKED_THREAD_TIME,
-    CPU_TIME,
-    EXTRA_INFO,
-    CUMULATIVE_CARDINALITY,
-    OPERATOR_TYPE,
-    OPERATOR_CARDINALITY,
-    CUMULATIVE_ROWS_SCANNED,
-    OPERATOR_ROWS_SCANNED,
-    OPERATOR_TIMING,
-    RESULT_SET_SIZE,
-    LATENCY,
-    ROWS_RETURNED,
-    OPERATOR_NAME,
-    ALL_OPTIMIZERS,
-    CUMULATIVE_OPTIMIZER_TIMING,
-    PLANNER,
-    PLANNER_BINDING,
-    PHYSICAL_PLANNER,
-    PHYSICAL_PLANNER_COLUMN_BINDING,
-    PHYSICAL_PLANNER_RESOLVE_TYPES,
-    PHYSICAL_PLANNER_CREATE_PLAN,
-    OPTIMIZER_EXPRESSION_REWRITER,
-    OPTIMIZER_FILTER_PULLUP,
-    OPTIMIZER_FILTER_PUSHDOWN,
-    OPTIMIZER_EMPTY_RESULT_PULLUP,
-    OPTIMIZER_CTE_FILTER_PUSHER,
-    OPTIMIZER_REGEX_RANGE,
-    OPTIMIZER_IN_CLAUSE,
-    OPTIMIZER_JOIN_ORDER,
-    OPTIMIZER_DELIMINATOR,
-    OPTIMIZER_UNNEST_REWRITER,
-    OPTIMIZER_UNUSED_COLUMNS,
-    OPTIMIZER_STATISTICS_PROPAGATION,
-    OPTIMIZER_COMMON_SUBEXPRESSIONS,
-    OPTIMIZER_COMMON_AGGREGATE,
-    OPTIMIZER_COLUMN_LIFETIME,
-    OPTIMIZER_BUILD_SIDE_PROBE_SIDE,
-    OPTIMIZER_LIMIT_PUSHDOWN,
-    OPTIMIZER_TOP_N,
-    OPTIMIZER_COMPRESSED_MATERIALIZATION,
-    OPTIMIZER_DUPLICATE_GROUPS,
-    OPTIMIZER_REORDER_FILTER,
-    OPTIMIZER_SAMPLING_PUSHDOWN,
-    OPTIMIZER_JOIN_FILTER_PUSHDOWN,
-    OPTIMIZER_EXTENSION,
-    OPTIMIZER_MATERIALIZED_CTE,
-    OPTIMIZER_SUM_REWRITER,
-};
-
-struct MetricsTypeHashFunction {
-	uint64_t operator()(const MetricsType &index) const {
-		return std::hash<uint8_t>()(static_cast<uint8_t>(index));
-	}
-};
-
-typedef unordered_set<MetricsType, MetricsTypeHashFunction> profiler_settings_t;
-typedef unordered_map<MetricsType, Value, MetricsTypeHashFunction> profiler_metrics_t;
-
-class MetricsUtils {
-public:
-    static profiler_settings_t GetOptimizerMetrics();
-    static profiler_settings_t GetPhaseTimingMetrics();
-
-    static MetricsType GetOptimizerMetricByType(OptimizerType type);
-    static OptimizerType GetOptimizerTypeByMetric(MetricsType type);
-
-    static bool IsOptimizerMetric(MetricsType type);
-    static bool IsPhaseTimingMetric(MetricsType type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/on_create_conflict.hpp b/src/duckdb/src/include/duckdb/common/enums/on_create_conflict.hpp
deleted file mode 100644
index b9d0171d0..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/on_create_conflict.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/on_create_conflict.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class OnCreateConflict : uint8_t {
-	// Standard: throw error
-	ERROR_ON_CONFLICT,
-	// CREATE IF NOT EXISTS, silently do nothing on conflict
-	IGNORE_ON_CONFLICT,
-	// CREATE OR REPLACE
-	REPLACE_ON_CONFLICT,
-	// Update on conflict - only support for functions. Add a function overload if the function already exists.
-	ALTER_ON_CONFLICT
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/on_entry_not_found.hpp b/src/duckdb/src/include/duckdb/common/enums/on_entry_not_found.hpp
deleted file mode 100644
index 092f9cd0d..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/on_entry_not_found.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/on_entry_not_found.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class OnEntryNotFound : uint8_t { THROW_EXCEPTION = 0, RETURN_NULL = 1 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/operator_result_type.hpp b/src/duckdb/src/include/duckdb/common/enums/operator_result_type.hpp
deleted file mode 100644
index 5016ae2d2..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/operator_result_type.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/operator_result_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//! The OperatorResultType is used to indicate how data should flow around a regular (i.e. non-sink and non-source)
-//! physical operator
-//! There are four possible results:
-//! NEED_MORE_INPUT means the operator is done with the current input and can consume more input if available
-//! If there is more input the operator will be called with more input, otherwise the operator will not be called again.
-//! HAVE_MORE_OUTPUT means the operator is not finished yet with the current input.
-//! The operator will be called again with the same input.
-//! FINISHED means the operator has finished the entire pipeline and no more processing is necessary.
-//! The operator will not be called again, and neither will any other operators in this pipeline.
-//! BLOCKED means the operator does not want to be called right now. e.g. because its currently doing async I/O. The
-//! operator has set the interrupt state and the caller is expected to handle it. Note that intermediate operators
-//! should currently not emit this state.
-enum class OperatorResultType : uint8_t { NEED_MORE_INPUT, HAVE_MORE_OUTPUT, FINISHED, BLOCKED };
-
-//! OperatorFinalizeResultType is used to indicate whether operators have finished flushing their cached results.
-//! FINISHED means the operator has flushed all cached data.
-//! HAVE_MORE_OUTPUT means the operator contains more results.
-enum class OperatorFinalizeResultType : uint8_t { HAVE_MORE_OUTPUT, FINISHED };
-
-//! SourceResultType is used to indicate the result of data being pulled out of a source.
-//! There are three possible results:
-//! HAVE_MORE_OUTPUT means the source has more output, this flag should only be set when data is returned, empty results
-//! should only occur for the FINISHED and BLOCKED flags
-//! FINISHED means the source is exhausted
-//! BLOCKED means the source is currently blocked, e.g. by some async I/O
-enum class SourceResultType : uint8_t { HAVE_MORE_OUTPUT, FINISHED, BLOCKED };
-
-//! The SinkResultType is used to indicate the result of data flowing into a sink
-//! There are three possible results:
-//! NEED_MORE_INPUT means the sink needs more input
-//! FINISHED means the sink is finished executing, and more input will not change the result any further
-//! BLOCKED means the sink is currently blocked, e.g. by some async I/O.
-enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED, BLOCKED };
-
-// todo comment
-enum class SinkCombineResultType : uint8_t { FINISHED, BLOCKED };
-
-//! The SinkFinalizeType is used to indicate the result of a Finalize call on a sink
-//! There are two possible results:
-//! READY means the sink is ready for further processing
-//! NO_OUTPUT_POSSIBLE means the sink will never provide output, and any pipelines involving the sink can be skipped
-//! BLOCKED means the finalize call to the sink is currently blocked, e.g. by some async I/O.
-enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE, BLOCKED };
-
-//! The SinkNextBatchType is used to indicate the result of a NextBatch call on a sink
-//! There are two possible results:
-//! READY means the sink is ready for further processing
-//! BLOCKED means the NextBatch call to the sink is currently blocked, e.g. by some async I/O.
-enum class SinkNextBatchType : uint8_t { READY, BLOCKED };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp b/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp
deleted file mode 100644
index cfb7acb6a..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/optimizer_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-enum class OptimizerType : uint32_t {
-	INVALID = 0,
-	EXPRESSION_REWRITER,
-	FILTER_PULLUP,
-	FILTER_PUSHDOWN,
-	EMPTY_RESULT_PULLUP,
-	CTE_FILTER_PUSHER,
-	REGEX_RANGE,
-	IN_CLAUSE,
-	JOIN_ORDER,
-	DELIMINATOR,
-	UNNEST_REWRITER,
-	UNUSED_COLUMNS,
-	STATISTICS_PROPAGATION,
-	COMMON_SUBEXPRESSIONS,
-	COMMON_AGGREGATE,
-	COLUMN_LIFETIME,
-	BUILD_SIDE_PROBE_SIDE,
-	LIMIT_PUSHDOWN,
-	TOP_N,
-	COMPRESSED_MATERIALIZATION,
-	DUPLICATE_GROUPS,
-	REORDER_FILTER,
-	SAMPLING_PUSHDOWN,
-	JOIN_FILTER_PUSHDOWN,
-	EXTENSION,
-	MATERIALIZED_CTE,
-	SUM_REWRITER
-};
-
-string OptimizerTypeToString(OptimizerType type);
-OptimizerType OptimizerTypeFromString(const string &str);
-vector<string> ListAllOptimizers();
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/order_preservation_type.hpp b/src/duckdb/src/include/duckdb/common/enums/order_preservation_type.hpp
deleted file mode 100644
index d28edb20e..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/order_preservation_type.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/order_preservation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Order Preservation Type
-//===--------------------------------------------------------------------===//
-enum class OrderPreservationType : uint8_t {
-	NO_ORDER,        // the operator makes no guarantees on order preservation (i.e. it might re-order the entire input)
-	INSERTION_ORDER, // the operator maintains the order of the child operators
-	FIXED_ORDER      // the operator outputs rows in a fixed order that must be maintained (e.g. ORDER BY)
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/order_type.hpp b/src/duckdb/src/include/duckdb/common/enums/order_type.hpp
deleted file mode 100644
index a23457d23..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/order_type.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/order_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-enum class OrderType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, ASCENDING = 2, DESCENDING = 3 };
-
-enum class OrderByNullType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIRST = 2, NULLS_LAST = 3 };
-
-enum class DefaultOrderByNullType : uint8_t {
-	INVALID = 0,
-	NULLS_FIRST = 2,
-	NULLS_LAST = 3,
-	NULLS_FIRST_ON_ASC_LAST_ON_DESC = 4,
-	NULLS_LAST_ON_ASC_FIRST_ON_DESC = 5
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/output_type.hpp b/src/duckdb/src/include/duckdb/common/enums/output_type.hpp
deleted file mode 100644
index 587eb81a1..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/output_type.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/output_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class ExplainOutputType : uint8_t { ALL = 0, OPTIMIZED_ONLY = 1, PHYSICAL_ONLY = 2 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp b/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp
deleted file mode 100644
index 406ffbe9e..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/pending_execution_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class PendingExecutionResult : uint8_t {
-	RESULT_READY,
-	RESULT_NOT_READY,
-	EXECUTION_ERROR,
-	BLOCKED,
-	NO_TASKS_AVAILABLE,
-	EXECUTION_FINISHED
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp b/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp
deleted file mode 100644
index 607588c11..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/physical_operator_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Physical Operator Types
-//===--------------------------------------------------------------------===//
-enum class PhysicalOperatorType : uint8_t {
-	INVALID,
-	ORDER_BY,
-	LIMIT,
-	STREAMING_LIMIT,
-	LIMIT_PERCENT,
-	TOP_N,
-	WINDOW,
-	UNNEST,
-	UNGROUPED_AGGREGATE,
-	HASH_GROUP_BY,
-	PERFECT_HASH_GROUP_BY,
-	PARTITIONED_AGGREGATE,
-	FILTER,
-	PROJECTION,
-	COPY_TO_FILE,
-	BATCH_COPY_TO_FILE,
-	RESERVOIR_SAMPLE,
-	STREAMING_SAMPLE,
-	STREAMING_WINDOW,
-	PIVOT,
-	COPY_DATABASE,
-
-	// -----------------------------
-	// Scans
-	// -----------------------------
-	TABLE_SCAN,
-	DUMMY_SCAN,
-	COLUMN_DATA_SCAN,
-	CHUNK_SCAN,
-	RECURSIVE_CTE_SCAN,
-	CTE_SCAN,
-	DELIM_SCAN,
-	EXPRESSION_SCAN,
-	POSITIONAL_SCAN,
-	// -----------------------------
-	// Joins
-	// -----------------------------
-	BLOCKWISE_NL_JOIN,
-	NESTED_LOOP_JOIN,
-	HASH_JOIN,
-	CROSS_PRODUCT,
-	PIECEWISE_MERGE_JOIN,
-	IE_JOIN,
-	LEFT_DELIM_JOIN,
-	RIGHT_DELIM_JOIN,
-	POSITIONAL_JOIN,
-	ASOF_JOIN,
-	// -----------------------------
-	// SetOps
-	// -----------------------------
-	UNION,
-	RECURSIVE_CTE,
-	CTE,
-
-	// -----------------------------
-	// Updates
-	// -----------------------------
-	INSERT,
-	BATCH_INSERT,
-	DELETE_OPERATOR,
-	UPDATE,
-
-	// -----------------------------
-	// Schema
-	// -----------------------------
-	CREATE_TABLE,
-	CREATE_TABLE_AS,
-	BATCH_CREATE_TABLE_AS,
-	CREATE_INDEX,
-	ALTER,
-	CREATE_SEQUENCE,
-	CREATE_VIEW,
-	CREATE_SCHEMA,
-	CREATE_MACRO,
-	DROP,
-	PRAGMA,
-	TRANSACTION,
-	CREATE_TYPE,
-	ATTACH,
-	DETACH,
-
-	// -----------------------------
-	// Helpers
-	// -----------------------------
-	EXPLAIN,
-	EXPLAIN_ANALYZE,
-	EMPTY_RESULT,
-	EXECUTE,
-	PREPARE,
-	VACUUM,
-	EXPORT,
-	SET,
-	SET_VARIABLE,
-	LOAD,
-	INOUT_FUNCTION,
-	RESULT_COLLECTOR,
-	RESET,
-	EXTENSION,
-	VERIFY_VECTOR,
-	UPDATE_EXTENSIONS,
-
-	// -----------------------------
-	// Secret
-	// -----------------------------
-	CREATE_SECRET,
-};
-
-string PhysicalOperatorToString(PhysicalOperatorType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/prepared_statement_mode.hpp b/src/duckdb/src/include/duckdb/common/enums/prepared_statement_mode.hpp
deleted file mode 100644
index 520e4c002..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/prepared_statement_mode.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/prepared_statement_mode.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class PreparedStatementMode : uint8_t {
-	PREPARE_ONLY,
-	PREPARE_AND_EXECUTE,
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/profiler_format.hpp b/src/duckdb/src/include/duckdb/common/enums/profiler_format.hpp
deleted file mode 100644
index 1a416d546..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/profiler_format.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/profiler_format.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class ProfilerPrintFormat : uint8_t { QUERY_TREE, JSON, QUERY_TREE_OPTIMIZER, NO_OUTPUT, HTML, GRAPHVIZ };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/quantile_enum.hpp b/src/duckdb/src/include/duckdb/common/enums/quantile_enum.hpp
deleted file mode 100644
index bcb90b2ce..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/quantile_enum.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/quantile_enum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class QuantileSerializationType : uint8_t {
-	NON_DECIMAL = 0,
-	DECIMAL_DISCRETE,
-	DECIMAL_DISCRETE_LIST,
-	DECIMAL_CONTINUOUS,
-	DECIMAL_CONTINUOUS_LIST
-};
-
-}
diff --git a/src/duckdb/src/include/duckdb/common/enums/relation_type.hpp b/src/duckdb/src/include/duckdb/common/enums/relation_type.hpp
deleted file mode 100644
index 302b2f369..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/relation_type.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/relation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Catalog Types
-//===--------------------------------------------------------------------===//
-enum class RelationType : uint8_t {
-	INVALID_RELATION,
-	TABLE_RELATION,
-	PROJECTION_RELATION,
-	FILTER_RELATION,
-	EXPLAIN_RELATION,
-	CROSS_PRODUCT_RELATION,
-	JOIN_RELATION,
-	AGGREGATE_RELATION,
-	SET_OPERATION_RELATION,
-	DISTINCT_RELATION,
-	LIMIT_RELATION,
-	ORDER_RELATION,
-	CREATE_VIEW_RELATION,
-	CREATE_TABLE_RELATION,
-	INSERT_RELATION,
-	VALUE_LIST_RELATION,
-	MATERIALIZED_RELATION,
-	DELETE_RELATION,
-	UPDATE_RELATION,
-	WRITE_CSV_RELATION,
-	WRITE_PARQUET_RELATION,
-	READ_CSV_RELATION,
-	SUBQUERY_RELATION,
-	TABLE_FUNCTION_RELATION,
-	VIEW_RELATION,
-	QUERY_RELATION,
-	DELIM_JOIN_RELATION,
-	DELIM_GET_RELATION
-};
-
-string RelationTypeToString(RelationType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/scan_options.hpp b/src/duckdb/src/include/duckdb/common/enums/scan_options.hpp
deleted file mode 100644
index 31223e437..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/scan_options.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/scan_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class TableScanType : uint8_t {
-	//! Regular table scan: scan all tuples that are relevant for the current transaction
-	TABLE_SCAN_REGULAR = 0,
-	//! Scan all rows, including any deleted rows. Committed updates are merged in.
-	TABLE_SCAN_COMMITTED_ROWS = 1,
-	//! Scan all rows, including any deleted rows. Throws an exception if there are any uncommitted updates.
-	TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES = 2,
-	//! Scan all rows, excluding any permanently deleted rows.
-	//! Permanently deleted rows are rows which no transaction will ever need again.
-	TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED = 3,
-	//! Scan the latest committed rows
-	TABLE_SCAN_LATEST_COMMITTED_ROWS = 4
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/scan_vector_type.hpp b/src/duckdb/src/include/duckdb/common/enums/scan_vector_type.hpp
deleted file mode 100644
index 73224f40f..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/scan_vector_type.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/scan_vector_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class ScanVectorType { SCAN_ENTIRE_VECTOR, SCAN_FLAT_VECTOR };
-
-enum class ScanVectorMode { REGULAR_SCAN, SCAN_COMMITTED, SCAN_COMMITTED_NO_UPDATES };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/set_operation_type.hpp b/src/duckdb/src/include/duckdb/common/enums/set_operation_type.hpp
deleted file mode 100644
index 0cf5628ed..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/set_operation_type.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/set_operation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class SetOperationType : uint8_t { NONE = 0, UNION = 1, EXCEPT = 2, INTERSECT = 3, UNION_BY_NAME = 4 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/set_scope.hpp b/src/duckdb/src/include/duckdb/common/enums/set_scope.hpp
deleted file mode 100644
index 01cd72d08..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/set_scope.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/set_scope.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class SetScope : uint8_t {
-	AUTOMATIC = 0,
-	LOCAL = 1, /* unused */
-	SESSION = 2,
-	GLOBAL = 3,
-	VARIABLE = 4
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/set_type.hpp b/src/duckdb/src/include/duckdb/common/enums/set_type.hpp
deleted file mode 100644
index 0b5eedd20..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/set_type.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/set_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class SetType : uint8_t { SET = 0, RESET = 1 };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp b/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp
deleted file mode 100644
index 7b34674a8..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/statement_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Statement Types
-//===--------------------------------------------------------------------===//
-enum class StatementType : uint8_t {
-	INVALID_STATEMENT,      // invalid statement type
-	SELECT_STATEMENT,       // select statement type
-	INSERT_STATEMENT,       // insert statement type
-	UPDATE_STATEMENT,       // update statement type
-	CREATE_STATEMENT,       // create statement type
-	DELETE_STATEMENT,       // delete statement type
-	PREPARE_STATEMENT,      // prepare statement type
-	EXECUTE_STATEMENT,      // execute statement type
-	ALTER_STATEMENT,        // alter statement type
-	TRANSACTION_STATEMENT,  // transaction statement type,
-	COPY_STATEMENT,         // copy type
-	ANALYZE_STATEMENT,      // analyze type
-	VARIABLE_SET_STATEMENT, // variable set statement type
-	CREATE_FUNC_STATEMENT,  // create func statement type
-	EXPLAIN_STATEMENT,      // explain statement type
-	DROP_STATEMENT,         // DROP statement type
-	EXPORT_STATEMENT,       // EXPORT statement type
-	PRAGMA_STATEMENT,       // PRAGMA statement type
-	VACUUM_STATEMENT,       // VACUUM statement type
-	CALL_STATEMENT,         // CALL statement type
-	SET_STATEMENT,          // SET statement type
-	LOAD_STATEMENT,         // LOAD statement type
-	RELATION_STATEMENT,
-	EXTENSION_STATEMENT,
-	LOGICAL_PLAN_STATEMENT,
-	ATTACH_STATEMENT,
-	DETACH_STATEMENT,
-	MULTI_STATEMENT,
-	COPY_DATABASE_STATEMENT,
-	UPDATE_EXTENSIONS_STATEMENT,
-};
-
-DUCKDB_API string StatementTypeToString(StatementType type);
-
-enum class StatementReturnType : uint8_t {
-	QUERY_RESULT, // the statement returns a query result (e.g. for display to the user)
-	CHANGED_ROWS, // the statement returns a single row containing the number of changed rows (e.g. an insert stmt)
-	NOTHING       // the statement returns nothing
-};
-
-string StatementReturnTypeToString(StatementReturnType type);
-
-class Catalog;
-class ClientContext;
-
-//! A struct containing various properties of a SQL statement
-struct StatementProperties {
-	StatementProperties()
-	    : requires_valid_transaction(true), allow_stream_result(false), bound_all_parameters(true),
-	      return_type(StatementReturnType::QUERY_RESULT), parameter_count(0), always_require_rebind(false) {
-	}
-
-	struct CatalogIdentity {
-		idx_t catalog_oid;
-		optional_idx catalog_version;
-
-		bool operator==(const CatalogIdentity &rhs) const {
-			return catalog_oid == rhs.catalog_oid && catalog_version == rhs.catalog_version;
-		}
-
-		bool operator!=(const CatalogIdentity &rhs) const {
-			return !operator==(rhs);
-		}
-	};
-
-	//! The set of databases this statement will read from
-	unordered_map<string, CatalogIdentity> read_databases;
-	//! The set of databases this statement will modify
-	unordered_map<string, CatalogIdentity> modified_databases;
-	//! Whether or not the statement requires a valid transaction. Almost all statements require this, with the
-	//! exception of ROLLBACK
-	bool requires_valid_transaction;
-	//! Whether or not the result can be streamed to the client
-	bool allow_stream_result;
-	//! Whether or not all parameters have successfully had their types determined
-	bool bound_all_parameters;
-	//! What type of data the statement returns
-	StatementReturnType return_type;
-	//! The number of prepared statement parameters
-	idx_t parameter_count;
-	//! Whether or not the statement ALWAYS requires a rebind
-	bool always_require_rebind;
-
-	bool IsReadOnly() {
-		return modified_databases.empty();
-	}
-
-	void RegisterDBRead(Catalog &catalog, ClientContext &context);
-
-	void RegisterDBModify(Catalog &catalog, ClientContext &context);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/stream_execution_result.hpp b/src/duckdb/src/include/duckdb/common/enums/stream_execution_result.hpp
deleted file mode 100644
index 19ba824dd..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/stream_execution_result.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/stream_execution_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class StreamExecutionResult : uint8_t {
-	CHUNK_READY,
-	CHUNK_NOT_READY,
-	EXECUTION_ERROR,
-	EXECUTION_CANCELLED,
-	BLOCKED,
-	NO_TASKS_AVAILABLE,
-	EXECUTION_FINISHED
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/subquery_type.hpp b/src/duckdb/src/include/duckdb/common/enums/subquery_type.hpp
deleted file mode 100644
index 2415ef5b7..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/subquery_type.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/subquery_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Subquery Types
-//===--------------------------------------------------------------------===//
-enum class SubqueryType : uint8_t {
-	INVALID = 0,
-	SCALAR = 1,     // Regular scalar subquery
-	EXISTS = 2,     // EXISTS (SELECT...)
-	NOT_EXISTS = 3, // NOT EXISTS(SELECT...)
-	ANY = 4,        // x = ANY(SELECT...) OR x IN (SELECT...)
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp b/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp
deleted file mode 100644
index c1a1a47b2..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/tableref_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Table Reference Types
-//===--------------------------------------------------------------------===//
-enum class TableReferenceType : uint8_t {
-	INVALID = 0,         // invalid table reference type
-	BASE_TABLE = 1,      // base table reference
-	SUBQUERY = 2,        // output of a subquery
-	JOIN = 3,            // output of join
-	TABLE_FUNCTION = 5,  // table producing function
-	EXPRESSION_LIST = 6, // expression list
-	CTE = 7,             // Recursive CTE
-	EMPTY_FROM = 8,      // placeholder for empty FROM
-	PIVOT = 9,           // pivot statement
-	SHOW_REF = 10,       // SHOW statement
-	COLUMN_DATA = 11,    // column data collection
-	DELIM_GET = 12       // Delim get ref
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/undo_flags.hpp b/src/duckdb/src/include/duckdb/common/enums/undo_flags.hpp
deleted file mode 100644
index a91548bda..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/undo_flags.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/undo_flags.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class UndoFlags : uint32_t { // far too big but aligned (TM)
-	EMPTY_ENTRY = 0,
-	CATALOG_ENTRY = 1,
-	INSERT_TUPLE = 2,
-	DELETE_TUPLE = 3,
-	UPDATE_TUPLE = 4,
-	SEQUENCE_VALUE = 5
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/vector_type.hpp b/src/duckdb/src/include/duckdb/common/enums/vector_type.hpp
deleted file mode 100644
index 155df5fe9..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/vector_type.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/vector_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class VectorType : uint8_t {
-	FLAT_VECTOR,       // Flat vectors represent a standard uncompressed vector
-	FSST_VECTOR,       // Contains string data compressed with FSST
-	CONSTANT_VECTOR,   // Constant vector represents a single constant
-	DICTIONARY_VECTOR, // Dictionary vector represents a selection vector on top of another vector
-	SEQUENCE_VECTOR    // Sequence vector represents a sequence with a start point and an increment
-};
-
-string VectorTypeToString(VectorType type);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/enums/wal_type.hpp b/src/duckdb/src/include/duckdb/common/enums/wal_type.hpp
deleted file mode 100644
index fa84fa34b..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/wal_type.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/wal_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class WALType : uint8_t {
-	INVALID = 0,
-	// -----------------------------
-	// Catalog
-	// -----------------------------
-	CREATE_TABLE = 1,
-	DROP_TABLE = 2,
-
-	CREATE_SCHEMA = 3,
-	DROP_SCHEMA = 4,
-
-	CREATE_VIEW = 5,
-	DROP_VIEW = 6,
-
-	CREATE_SEQUENCE = 8,
-	DROP_SEQUENCE = 9,
-	SEQUENCE_VALUE = 10,
-
-	CREATE_MACRO = 11,
-	DROP_MACRO = 12,
-
-	CREATE_TYPE = 13,
-	DROP_TYPE = 14,
-
-	ALTER_INFO = 20,
-
-	CREATE_TABLE_MACRO = 21,
-	DROP_TABLE_MACRO = 22,
-
-	CREATE_INDEX = 23,
-	DROP_INDEX = 24,
-
-	// -----------------------------
-	// Data
-	// -----------------------------
-	USE_TABLE = 25,
-	INSERT_TUPLE = 26,
-	DELETE_TUPLE = 27,
-	UPDATE_TUPLE = 28,
-	ROW_GROUP_DATA = 29,
-	// -----------------------------
-	// Flush
-	// -----------------------------
-	WAL_VERSION = 98,
-	CHECKPOINT = 99,
-	WAL_FLUSH = 100
-};
-}
diff --git a/src/duckdb/src/include/duckdb/common/enums/window_aggregation_mode.hpp b/src/duckdb/src/include/duckdb/common/enums/window_aggregation_mode.hpp
deleted file mode 100644
index 2bbd1013e..000000000
--- a/src/duckdb/src/include/duckdb/common/enums/window_aggregation_mode.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/window_aggregation_mode.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-enum class WindowAggregationMode : uint32_t {
-	//! Use the window aggregate API if available
-	WINDOW = 0,
-	//! Don't use window, but use combine if available
-	COMBINE,
-	//! Don't use combine or window (compute each frame separately)
-	SEPARATE
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/error_data.hpp b/src/duckdb/src/include/duckdb/common/error_data.hpp
deleted file mode 100644
index 20b7541f6..000000000
--- a/src/duckdb/src/include/duckdb/common/error_data.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/error_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string.hpp"
-
-namespace duckdb {
-class ParsedExpression;
-class TableRef;
-
-class ErrorData {
-public:
-	//! Not initialized, default constructor
-	DUCKDB_API ErrorData();
-	//! From std::exception
-	DUCKDB_API ErrorData(const std::exception &ex); // NOLINT: allow implicit construction from exception
-	//! From a raw string and exception type
-	DUCKDB_API explicit ErrorData(ExceptionType type, const string &raw_message);
-	//! From a raw string
-	DUCKDB_API explicit ErrorData(const string &raw_message);
-
-public:
-	//! Throw the error
-	[[noreturn]] DUCKDB_API void Throw(const string &prepended_message = "") const;
-	//! Get the internal exception type of the error
-	DUCKDB_API const ExceptionType &Type() const;
-	//! Used in clients like C-API, creates the final message and returns a reference to it
-	DUCKDB_API const string &Message() const {
-		return final_message;
-	}
-	DUCKDB_API const string &RawMessage() const {
-		return raw_message;
-	}
-	DUCKDB_API bool operator==(const ErrorData &other) const;
-
-	inline bool HasError() const {
-		return initialized;
-	}
-	const unordered_map<string, string> &ExtraInfo() const {
-		return extra_info;
-	}
-
-	DUCKDB_API void FinalizeError();
-	DUCKDB_API void AddErrorLocation(const string &query);
-	DUCKDB_API void ConvertErrorToJSON();
-
-	DUCKDB_API void AddQueryLocation(optional_idx query_location);
-	DUCKDB_API void AddQueryLocation(QueryErrorContext error_context);
-	DUCKDB_API void AddQueryLocation(const ParsedExpression &ref);
-	DUCKDB_API void AddQueryLocation(const TableRef &ref);
-
-private:
-	//! Whether this ErrorData contains an exception or not
-	bool initialized;
-	//! The ExceptionType of the preserved exception
-	ExceptionType type;
-	//! The message the exception was constructed with (does not contain the Exception Type)
-	string raw_message;
-	//! The final message (stored in the preserved error for compatibility reasons with C-API)
-	string final_message;
-	//! Extra exception info
-	unordered_map<string, string> extra_info;
-
-private:
-	DUCKDB_API static string SanitizeErrorMessage(string error);
-	DUCKDB_API string ConstructFinalMessage() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception.hpp b/src/duckdb/src/include/duckdb/common/exception.hpp
deleted file mode 100644
index 71c4ff8b2..000000000
--- a/src/duckdb/src/include/duckdb/common/exception.hpp
+++ /dev/null
@@ -1,392 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception_format_value.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-#include <vector>
-#include <stdexcept>
-
-namespace duckdb {
-enum class PhysicalType : uint8_t;
-struct LogicalType;
-class Expression;
-class ParsedExpression;
-class QueryErrorContext;
-class TableRef;
-struct hugeint_t;
-class optional_idx; // NOLINT: matching std style
-
-inline void AssertRestrictFunction(const void *left_start, const void *left_end, const void *right_start,
-                                   const void *right_end, const char *fname, int linenr) {
-	// assert that the two pointers do not overlap
-#ifdef DEBUG
-	if (!(left_end <= right_start || right_end <= left_start)) {
-		printf("ASSERT RESTRICT FAILED: %s:%d\n", fname, linenr);
-		D_ASSERT(0);
-	}
-#endif
-}
-
-#define ASSERT_RESTRICT(left_start, left_end, right_start, right_end)                                                  \
-	AssertRestrictFunction(left_start, left_end, right_start, right_end, __FILE__, __LINE__)
-
-//===--------------------------------------------------------------------===//
-// Exception Types
-//===--------------------------------------------------------------------===//
-
-enum class ExceptionType : uint8_t {
-	INVALID = 0,          // invalid type
-	OUT_OF_RANGE = 1,     // value out of range error
-	CONVERSION = 2,       // conversion/casting error
-	UNKNOWN_TYPE = 3,     // unknown type
-	DECIMAL = 4,          // decimal related
-	MISMATCH_TYPE = 5,    // type mismatch
-	DIVIDE_BY_ZERO = 6,   // divide by 0
-	OBJECT_SIZE = 7,      // object size exceeded
-	INVALID_TYPE = 8,     // incompatible for operation
-	SERIALIZATION = 9,    // serialization
-	TRANSACTION = 10,     // transaction management
-	NOT_IMPLEMENTED = 11, // method not implemented
-	EXPRESSION = 12,      // expression parsing
-	CATALOG = 13,         // catalog related
-	PARSER = 14,          // parser related
-	PLANNER = 15,         // planner related
-	SCHEDULER = 16,       // scheduler related
-	EXECUTOR = 17,        // executor related
-	CONSTRAINT = 18,      // constraint related
-	INDEX = 19,           // index related
-	STAT = 20,            // stat related
-	CONNECTION = 21,      // connection related
-	SYNTAX = 22,          // syntax related
-	SETTINGS = 23,        // settings related
-	BINDER = 24,          // binder related
-	NETWORK = 25,         // network related
-	OPTIMIZER = 26,       // optimizer related
-	NULL_POINTER = 27,    // nullptr exception
-	IO = 28,              // IO exception
-	INTERRUPT = 29,       // interrupt
-	FATAL = 30,           // Fatal exceptions are non-recoverable, and render the entire DB in an unusable state
-	INTERNAL = 31,        // Internal exceptions indicate something went wrong internally (i.e. bug in the code base)
-	INVALID_INPUT = 32,   // Input or arguments error
-	OUT_OF_MEMORY = 33,   // out of memory
-	PERMISSION = 34,      // insufficient permissions
-	PARAMETER_NOT_RESOLVED = 35, // parameter types could not be resolved
-	PARAMETER_NOT_ALLOWED = 36,  // parameter types not allowed
-	DEPENDENCY = 37,             // dependency
-	HTTP = 38,
-	MISSING_EXTENSION = 39, // Thrown when an extension is used but not loaded
-	AUTOLOAD = 40,          // Thrown when an extension is used but not loaded
-	SEQUENCE = 41,
-	INVALID_CONFIGURATION =
-	    42 // An invalid configuration was detected (e.g. a Secret param was missing, or a required setting not found)
-};
-
-class Exception : public std::runtime_error {
-public:
-	DUCKDB_API Exception(ExceptionType exception_type, const string &message);
-	DUCKDB_API Exception(ExceptionType exception_type, const string &message,
-	                     const unordered_map<string, string> &extra_info);
-
-public:
-	DUCKDB_API static string ExceptionTypeToString(ExceptionType type);
-	DUCKDB_API static ExceptionType StringToExceptionType(const string &type);
-
-	template <typename... ARGS>
-	static string ConstructMessage(const string &msg, ARGS... params) {
-		const std::size_t num_args = sizeof...(ARGS);
-		if (num_args == 0) {
-			return msg;
-		}
-		std::vector<ExceptionFormatValue> values;
-		return ConstructMessageRecursive(msg, values, params...);
-	}
-
-	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const Expression &expr);
-	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const ParsedExpression &expr);
-	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const QueryErrorContext &error_context);
-	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const TableRef &ref);
-	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(optional_idx error_location);
-	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const string &subtype,
-	                                                                    optional_idx error_location);
-
-	DUCKDB_API static string ToJSON(ExceptionType type, const string &message);
-	DUCKDB_API static string ToJSON(ExceptionType type, const string &message,
-	                                const unordered_map<string, string> &extra_info);
-
-	DUCKDB_API static bool InvalidatesTransaction(ExceptionType exception_type);
-	DUCKDB_API static bool InvalidatesDatabase(ExceptionType exception_type);
-
-	DUCKDB_API static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values);
-
-	template <class T, typename... ARGS>
-	static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values, T param,
-	                                        ARGS... params) {
-		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
-		return ConstructMessageRecursive(msg, values, params...);
-	}
-
-	DUCKDB_API static bool UncaughtException();
-
-	DUCKDB_API static string GetStackTrace(idx_t max_depth = 120);
-	static string FormatStackTrace(const string &message = "") {
-		return (message + "\n" + GetStackTrace());
-	}
-
-	DUCKDB_API static void SetQueryLocation(optional_idx error_location, unordered_map<string, string> &extra_info);
-};
-
-//===--------------------------------------------------------------------===//
-// Exception derived classes
-//===--------------------------------------------------------------------===//
-class ConnectionException : public Exception {
-public:
-	DUCKDB_API explicit ConnectionException(const string &msg);
-
-	template <typename... ARGS>
-	explicit ConnectionException(const string &msg, ARGS... params)
-	    : ConnectionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class PermissionException : public Exception {
-public:
-	DUCKDB_API explicit PermissionException(const string &msg);
-
-	template <typename... ARGS>
-	explicit PermissionException(const string &msg, ARGS... params)
-	    : PermissionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class OutOfRangeException : public Exception {
-public:
-	DUCKDB_API explicit OutOfRangeException(const string &msg);
-
-	template <typename... ARGS>
-	explicit OutOfRangeException(const string &msg, ARGS... params)
-	    : OutOfRangeException(ConstructMessage(msg, params...)) {
-	}
-	DUCKDB_API OutOfRangeException(const int64_t value, const PhysicalType orig_type, const PhysicalType new_type);
-	DUCKDB_API OutOfRangeException(const hugeint_t value, const PhysicalType orig_type, const PhysicalType new_type);
-	DUCKDB_API OutOfRangeException(const double value, const PhysicalType orig_type, const PhysicalType new_type);
-	DUCKDB_API OutOfRangeException(const PhysicalType var_type, const idx_t length);
-};
-
-class OutOfMemoryException : public Exception {
-public:
-	DUCKDB_API explicit OutOfMemoryException(const string &msg);
-
-	template <typename... ARGS>
-	explicit OutOfMemoryException(const string &msg, ARGS... params)
-	    : OutOfMemoryException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class SyntaxException : public Exception {
-public:
-	DUCKDB_API explicit SyntaxException(const string &msg);
-
-	template <typename... ARGS>
-	explicit SyntaxException(const string &msg, ARGS... params) : SyntaxException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class ConstraintException : public Exception {
-public:
-	DUCKDB_API explicit ConstraintException(const string &msg);
-
-	template <typename... ARGS>
-	explicit ConstraintException(const string &msg, ARGS... params)
-	    : ConstraintException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class DependencyException : public Exception {
-public:
-	DUCKDB_API explicit DependencyException(const string &msg);
-
-	template <typename... ARGS>
-	explicit DependencyException(const string &msg, ARGS... params)
-	    : DependencyException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class IOException : public Exception {
-public:
-	DUCKDB_API explicit IOException(const string &msg);
-	DUCKDB_API explicit IOException(const string &msg, const unordered_map<string, string> &extra_info);
-	explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
-	}
-
-	template <typename... ARGS>
-	explicit IOException(const string &msg, ARGS... params) : IOException(ConstructMessage(msg, params...)) {
-	}
-
-	template <typename... ARGS>
-	explicit IOException(const string &msg, const unordered_map<string, string> &extra_info, ARGS... params)
-	    : IOException(ConstructMessage(msg, params...), extra_info) {
-	}
-};
-
-class MissingExtensionException : public Exception {
-public:
-	DUCKDB_API explicit MissingExtensionException(const string &msg);
-
-	template <typename... ARGS>
-	explicit MissingExtensionException(const string &msg, ARGS... params)
-	    : MissingExtensionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class NotImplementedException : public Exception {
-public:
-	DUCKDB_API explicit NotImplementedException(const string &msg);
-
-	template <typename... ARGS>
-	explicit NotImplementedException(const string &msg, ARGS... params)
-	    : NotImplementedException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class AutoloadException : public Exception {
-public:
-	DUCKDB_API explicit AutoloadException(const string &extension_name, const string &message);
-};
-
-class SerializationException : public Exception {
-public:
-	DUCKDB_API explicit SerializationException(const string &msg);
-
-	template <typename... ARGS>
-	explicit SerializationException(const string &msg, ARGS... params)
-	    : SerializationException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class SequenceException : public Exception {
-public:
-	DUCKDB_API explicit SequenceException(const string &msg);
-
-	template <typename... ARGS>
-	explicit SequenceException(const string &msg, ARGS... params)
-	    : SequenceException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class InterruptException : public Exception {
-public:
-	DUCKDB_API InterruptException();
-};
-
-class FatalException : public Exception {
-public:
-	explicit FatalException(const string &msg) : FatalException(ExceptionType::FATAL, msg) {
-	}
-	template <typename... ARGS>
-	explicit FatalException(const string &msg, ARGS... params) : FatalException(ConstructMessage(msg, params...)) {
-	}
-
-protected:
-	DUCKDB_API explicit FatalException(ExceptionType type, const string &msg);
-	template <typename... ARGS>
-	explicit FatalException(ExceptionType type, const string &msg, ARGS... params)
-	    : FatalException(type, ConstructMessage(msg, params...)) {
-	}
-};
-
-class InternalException : public Exception {
-public:
-	DUCKDB_API explicit InternalException(const string &msg);
-
-	template <typename... ARGS>
-	explicit InternalException(const string &msg, ARGS... params)
-	    : InternalException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class InvalidInputException : public Exception {
-public:
-	DUCKDB_API explicit InvalidInputException(const string &msg);
-	DUCKDB_API explicit InvalidInputException(const string &msg, const unordered_map<string, string> &extra_info);
-
-	template <typename... ARGS>
-	explicit InvalidInputException(const string &msg, ARGS... params)
-	    : InvalidInputException(ConstructMessage(msg, params...)) {
-	}
-	template <typename... ARGS>
-	explicit InvalidInputException(const Expression &expr, const string &msg, ARGS... params)
-	    : InvalidInputException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
-	}
-};
-
-class ExecutorException : public Exception {
-public:
-	DUCKDB_API explicit ExecutorException(const string &msg);
-
-	template <typename... ARGS>
-	explicit ExecutorException(const string &msg, ARGS... params)
-	    : ExecutorException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class InvalidConfigurationException : public Exception {
-public:
-	DUCKDB_API explicit InvalidConfigurationException(const string &msg);
-	DUCKDB_API explicit InvalidConfigurationException(const string &msg,
-	                                                  const unordered_map<string, string> &extra_info);
-
-	template <typename... ARGS>
-	explicit InvalidConfigurationException(const string &msg, ARGS... params)
-	    : InvalidConfigurationException(ConstructMessage(msg, params...)) {
-	}
-	template <typename... ARGS>
-	explicit InvalidConfigurationException(const Expression &expr, const string &msg, ARGS... params)
-	    : InvalidConfigurationException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
-	}
-};
-
-class InvalidTypeException : public Exception {
-public:
-	DUCKDB_API InvalidTypeException(PhysicalType type, const string &msg);
-	DUCKDB_API InvalidTypeException(const LogicalType &type, const string &msg);
-	DUCKDB_API explicit InvalidTypeException(const string &msg);
-};
-
-class TypeMismatchException : public Exception {
-public:
-	DUCKDB_API TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg);
-	DUCKDB_API TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg);
-	DUCKDB_API TypeMismatchException(optional_idx error_location, const LogicalType &type_1, const LogicalType &type_2,
-	                                 const string &msg);
-	DUCKDB_API explicit TypeMismatchException(const string &msg);
-};
-
-class ParameterNotAllowedException : public Exception {
-public:
-	DUCKDB_API explicit ParameterNotAllowedException(const string &msg);
-
-	template <typename... ARGS>
-	explicit ParameterNotAllowedException(const string &msg, ARGS... params)
-	    : ParameterNotAllowedException(ConstructMessage(msg, params...)) {
-	}
-};
-
-//! Special exception that should be thrown in the binder if parameter types could not be resolved
-//! This will cause prepared statements to be forcibly rebound with the actual parameter values
-//! This exception is fatal if thrown outside of the binder (i.e. it should never be thrown outside of the binder)
-class ParameterNotResolvedException : public Exception {
-public:
-	DUCKDB_API explicit ParameterNotResolvedException();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception/binder_exception.hpp b/src/duckdb/src/include/duckdb/common/exception/binder_exception.hpp
deleted file mode 100644
index 59e1b5e73..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/binder_exception.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception/binder_exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-
-namespace duckdb {
-
-class BinderException : public Exception {
-public:
-	DUCKDB_API explicit BinderException(const string &msg, const unordered_map<string, string> &extra_info);
-	DUCKDB_API explicit BinderException(const string &msg);
-
-	template <typename... ARGS>
-	explicit BinderException(const string &msg, ARGS... params) : BinderException(ConstructMessage(msg, params...)) {
-	}
-	template <typename... ARGS>
-	explicit BinderException(const TableRef &ref, const string &msg, ARGS... params)
-	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(ref)) {
-	}
-	template <typename... ARGS>
-	explicit BinderException(const ParsedExpression &expr, const string &msg, ARGS... params)
-	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
-	}
-	template <typename... ARGS>
-	explicit BinderException(const Expression &expr, const string &msg, ARGS... params)
-	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
-	}
-	template <typename... ARGS>
-	explicit BinderException(QueryErrorContext error_context, const string &msg, ARGS... params)
-	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_context)) {
-	}
-	template <typename... ARGS>
-	explicit BinderException(optional_idx error_location, const string &msg, ARGS... params)
-	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_location)) {
-	}
-
-	static BinderException ColumnNotFound(const string &name, const vector<string> &similar_bindings,
-	                                      QueryErrorContext context = QueryErrorContext());
-	static BinderException NoMatchingFunction(const string &name, const vector<LogicalType> &arguments,
-	                                          const vector<string> &candidates);
-	static BinderException Unsupported(ParsedExpression &expr, const string &message);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception/catalog_exception.hpp b/src/duckdb/src/include/duckdb/common/exception/catalog_exception.hpp
deleted file mode 100644
index 8b510d987..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/catalog_exception.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception/catalog_exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-class CatalogException : public Exception {
-public:
-	DUCKDB_API explicit CatalogException(const string &msg);
-	DUCKDB_API explicit CatalogException(const string &msg, const unordered_map<string, string> &extra_info);
-
-	template <typename... ARGS>
-	explicit CatalogException(const string &msg, ARGS... params) : CatalogException(ConstructMessage(msg, params...)) {
-	}
-	template <typename... ARGS>
-	explicit CatalogException(QueryErrorContext error_context, const string &msg, ARGS... params)
-	    : CatalogException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_context)) {
-	}
-
-	static CatalogException MissingEntry(CatalogType type, const string &name, const string &suggestion,
-	                                     QueryErrorContext context = QueryErrorContext());
-	static CatalogException MissingEntry(const string &type, const string &name, const vector<string> &suggestions,
-	                                     QueryErrorContext context = QueryErrorContext());
-	static CatalogException EntryAlreadyExists(CatalogType type, const string &name,
-	                                           QueryErrorContext context = QueryErrorContext());
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception/conversion_exception.hpp b/src/duckdb/src/include/duckdb/common/exception/conversion_exception.hpp
deleted file mode 100644
index 5330f46e6..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/conversion_exception.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception/conversion_exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-class ConversionException : public Exception {
-public:
-	DUCKDB_API explicit ConversionException(const string &msg);
-	DUCKDB_API explicit ConversionException(optional_idx error_location, const string &msg);
-	DUCKDB_API ConversionException(const PhysicalType orig_type, const PhysicalType new_type);
-	DUCKDB_API ConversionException(const LogicalType &orig_type, const LogicalType &new_type);
-
-	template <typename... ARGS>
-	explicit ConversionException(const string &msg, ARGS... params)
-	    : ConversionException(ConstructMessage(msg, params...)) {
-	}
-	template <typename... ARGS>
-	explicit ConversionException(optional_idx error_location, const string &msg, ARGS... params)
-	    : ConversionException(error_location, ConstructMessage(msg, params...)) {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception/http_exception.hpp b/src/duckdb/src/include/duckdb/common/exception/http_exception.hpp
deleted file mode 100644
index 87d11d139..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/http_exception.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception/http_exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-class HTTPException : public Exception {
-public:
-	template <typename>
-	struct ResponseShape {
-		typedef int status; // NOLINT
-	};
-
-	explicit HTTPException(const string &message) : Exception(ExceptionType::HTTP, message) {
-	}
-
-	template <class RESPONSE, typename ResponseShape<decltype(RESPONSE::status)>::status = 0, typename... ARGS>
-	explicit HTTPException(RESPONSE &response, const string &msg, ARGS... params)
-	    : HTTPException(response.status, response.body, response.headers, response.reason, msg, params...) {
-	}
-
-	template <typename>
-	struct ResponseWrapperShape {
-		typedef int code; // NOLINT
-	};
-
-	template <class RESPONSE, typename ResponseWrapperShape<decltype(RESPONSE::code)>::code = 0, typename... ARGS>
-	explicit HTTPException(RESPONSE &response, const string &msg, ARGS... params)
-	    : HTTPException(response.code, response.body, response.headers, response.error, msg, params...) {
-	}
-
-	template <class HEADERS, typename... ARGS>
-	explicit HTTPException(int status_code, const string &response_body, const HEADERS &headers, const string &reason,
-	                       const string &msg, ARGS... params)
-	    : Exception(ExceptionType::HTTP, ConstructMessage(msg, params...),
-	                HTTPExtraInfo(status_code, response_body, headers, reason)) {
-	}
-
-	template <class HEADERS>
-	static unordered_map<string, string> HTTPExtraInfo(int status_code, const string &response_body,
-	                                                   const HEADERS &headers, const string &reason) {
-		unordered_map<string, string> extra_info;
-		extra_info["status_code"] = to_string(status_code);
-		extra_info["reason"] = reason;
-		extra_info["response_body"] = response_body;
-		for (auto &entry : headers) {
-			extra_info["header_" + entry.first] = entry.second;
-		}
-		return extra_info;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception/list.hpp b/src/duckdb/src/include/duckdb/common/exception/list.hpp
deleted file mode 100644
index 532b77d7b..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/list.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/exception/catalog_exception.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/common/exception/http_exception.hpp"
-#include "duckdb/common/exception/parser_exception.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
diff --git a/src/duckdb/src/include/duckdb/common/exception/parser_exception.hpp b/src/duckdb/src/include/duckdb/common/exception/parser_exception.hpp
deleted file mode 100644
index 363a34457..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/parser_exception.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception/parser_exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-class ParserException : public Exception {
-public:
-	DUCKDB_API explicit ParserException(const string &msg);
-	DUCKDB_API explicit ParserException(const string &msg, const unordered_map<string, string> &extra_info);
-
-	template <typename... ARGS>
-	explicit ParserException(const string &msg, ARGS... params) : ParserException(ConstructMessage(msg, params...)) {
-	}
-	template <typename... ARGS>
-	explicit ParserException(optional_idx error_location, const string &msg, ARGS... params)
-	    : ParserException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_location)) {
-	}
-	template <typename... ARGS>
-	explicit ParserException(const ParsedExpression &expr, const string &msg, ARGS... params)
-	    : ParserException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
-	}
-
-	static ParserException SyntaxError(const string &query, const string &error_message, optional_idx error_location);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception/transaction_exception.hpp b/src/duckdb/src/include/duckdb/common/exception/transaction_exception.hpp
deleted file mode 100644
index f0164df69..000000000
--- a/src/duckdb/src/include/duckdb/common/exception/transaction_exception.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception/transaction_exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-class TransactionException : public Exception {
-public:
-	DUCKDB_API explicit TransactionException(const string &msg);
-
-	template <typename... ARGS>
-	explicit TransactionException(const string &msg, ARGS... params)
-	    : TransactionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/exception_format_value.hpp b/src/duckdb/src/include/duckdb/common/exception_format_value.hpp
deleted file mode 100644
index 34be78c09..000000000
--- a/src/duckdb/src/include/duckdb/common/exception_format_value.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception_format_value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/hugeint.hpp"
-
-#include <vector>
-
-namespace duckdb {
-
-// Helper class to support custom overloading
-// Escaping " and quoting the value with "
-class SQLIdentifier {
-public:
-	explicit SQLIdentifier(const string &raw_string) : raw_string(raw_string) {
-	}
-
-public:
-	string raw_string;
-};
-
-// Helper class to support custom overloading
-// Escaping ' and quoting the value with '
-class SQLString {
-public:
-	explicit SQLString(const string &raw_string) : raw_string(raw_string) {
-	}
-
-public:
-	string raw_string;
-};
-
-enum class PhysicalType : uint8_t;
-struct LogicalType;
-
-enum class ExceptionFormatValueType : uint8_t {
-	FORMAT_VALUE_TYPE_DOUBLE,
-	FORMAT_VALUE_TYPE_INTEGER,
-	FORMAT_VALUE_TYPE_STRING
-};
-
-struct ExceptionFormatValue {
-	DUCKDB_API ExceptionFormatValue(double dbl_val);     // NOLINT
-	DUCKDB_API ExceptionFormatValue(int64_t int_val);    // NOLINT
-	DUCKDB_API ExceptionFormatValue(string str_val);     // NOLINT
-	DUCKDB_API ExceptionFormatValue(hugeint_t hg_val);   // NOLINT
-	DUCKDB_API ExceptionFormatValue(uhugeint_t uhg_val); // NOLINT
-
-	ExceptionFormatValueType type;
-
-	double dbl_val = 0;
-	int64_t int_val = 0;
-	string str_val;
-
-public:
-	template <class T>
-	static ExceptionFormatValue CreateFormatValue(T value) {
-		return int64_t(value);
-	}
-	static string Format(const string &msg, std::vector<ExceptionFormatValue> &values);
-};
-
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLString value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLIdentifier value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(uhugeint_t value);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/extension_type_info.hpp b/src/duckdb/src/include/duckdb/common/extension_type_info.hpp
deleted file mode 100644
index b8ee0f440..000000000
--- a/src/duckdb/src/include/duckdb/common/extension_type_info.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-
-struct LogicalTypeModifier {
-public:
-	explicit LogicalTypeModifier(Value value_p) : value(std::move(value_p)) {
-	}
-	string ToString() const {
-		return label.empty() ? value.ToString() : label;
-	}
-
-public:
-	Value value;
-	string label;
-
-	void Serialize(Serializer &serializer) const;
-	static LogicalTypeModifier Deserialize(Deserializer &source);
-};
-
-struct ExtensionTypeInfo {
-	vector<LogicalTypeModifier> modifiers;
-	unordered_map<string, Value> properties;
-
-public:
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<ExtensionTypeInfo> Deserialize(Deserializer &source);
-	static bool Equals(optional_ptr<ExtensionTypeInfo> rhs, optional_ptr<ExtensionTypeInfo> lhs);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/extra_operator_info.hpp b/src/duckdb/src/include/duckdb/common/extra_operator_info.hpp
deleted file mode 100644
index 117be6c61..000000000
--- a/src/duckdb/src/include/duckdb/common/extra_operator_info.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/extra_operator_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-
-namespace duckdb {
-
-class ExtraOperatorInfo {
-public:
-	ExtraOperatorInfo() : file_filters(""), sample_options(nullptr) {
-	}
-	ExtraOperatorInfo(ExtraOperatorInfo &extra_info)
-	    : file_filters(extra_info.file_filters), sample_options(std::move(extra_info.sample_options)) {
-		if (extra_info.total_files.IsValid()) {
-			total_files = extra_info.total_files.GetIndex();
-		}
-		if (extra_info.filtered_files.IsValid()) {
-			filtered_files = extra_info.filtered_files.GetIndex();
-		}
-	}
-
-	//! Filters that have been pushed down into the main file list
-	string file_filters;
-	//! Total size of file list
-	optional_idx total_files;
-	//! Size of file list after applying filters
-	optional_idx filtered_files;
-	//! Sample options that have been pushed down into the table scan
-	unique_ptr<SampleOptions> sample_options;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/extra_type_info.hpp b/src/duckdb/src/include/duckdb/common/extra_type_info.hpp
deleted file mode 100644
index 8e9afe0d2..000000000
--- a/src/duckdb/src/include/duckdb/common/extra_type_info.hpp
+++ /dev/null
@@ -1,257 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/extra_type_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/extension_type_info.hpp"
-
-namespace duckdb {
-
-//! Extra Type Info Type
-enum class ExtraTypeInfoType : uint8_t {
-	INVALID_TYPE_INFO = 0,
-	GENERIC_TYPE_INFO = 1,
-	DECIMAL_TYPE_INFO = 2,
-	STRING_TYPE_INFO = 3,
-	LIST_TYPE_INFO = 4,
-	STRUCT_TYPE_INFO = 5,
-	ENUM_TYPE_INFO = 6,
-	USER_TYPE_INFO = 7,
-	AGGREGATE_STATE_TYPE_INFO = 8,
-	ARRAY_TYPE_INFO = 9,
-	ANY_TYPE_INFO = 10,
-	INTEGER_LITERAL_TYPE_INFO = 11
-};
-
-struct ExtraTypeInfo {
-	ExtraTypeInfoType type;
-	string alias;
-	unique_ptr<ExtensionTypeInfo> extension_info;
-
-	explicit ExtraTypeInfo(ExtraTypeInfoType type);
-	explicit ExtraTypeInfo(ExtraTypeInfoType type, string alias);
-	virtual ~ExtraTypeInfo();
-
-protected:
-	// copy	constructor (protected)
-	ExtraTypeInfo(const ExtraTypeInfo &other);
-	ExtraTypeInfo &operator=(const ExtraTypeInfo &other);
-
-public:
-	bool Equals(ExtraTypeInfo *other_p) const;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	virtual shared_ptr<ExtraTypeInfo> Copy() const;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-protected:
-	virtual bool EqualsInternal(ExtraTypeInfo *other_p) const;
-};
-
-struct DecimalTypeInfo : public ExtraTypeInfo {
-	DecimalTypeInfo(uint8_t width_p, uint8_t scale_p);
-
-	uint8_t width;
-	uint8_t scale;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	DecimalTypeInfo();
-};
-
-struct StringTypeInfo : public ExtraTypeInfo {
-	explicit StringTypeInfo(string collation_p);
-
-	string collation;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	StringTypeInfo();
-};
-
-struct ListTypeInfo : public ExtraTypeInfo {
-	explicit ListTypeInfo(LogicalType child_type_p);
-
-	LogicalType child_type;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	ListTypeInfo();
-};
-
-struct StructTypeInfo : public ExtraTypeInfo {
-	explicit StructTypeInfo(child_list_t<LogicalType> child_types_p);
-
-	child_list_t<LogicalType> child_types;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &deserializer);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	StructTypeInfo();
-};
-
-struct AggregateStateTypeInfo : public ExtraTypeInfo {
-	explicit AggregateStateTypeInfo(aggregate_state_t state_type_p);
-
-	aggregate_state_t state_type;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	AggregateStateTypeInfo();
-};
-
-struct UserTypeInfo : public ExtraTypeInfo {
-	explicit UserTypeInfo(string name_p);
-	UserTypeInfo(string name_p, vector<Value> modifiers_p);
-	UserTypeInfo(string catalog_p, string schema_p, string name_p, vector<Value> modifiers_p);
-
-	string catalog;
-	string schema;
-	string user_type_name;
-	vector<Value> user_type_modifiers;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	UserTypeInfo();
-};
-
-// If this type is primarily stored in the catalog or not. Enums from Pandas/Factors are not in the catalog.
-enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1 };
-
-struct EnumTypeInfo : public ExtraTypeInfo {
-	explicit EnumTypeInfo(Vector &values_insert_order_p, idx_t dict_size_p);
-	EnumTypeInfo(const EnumTypeInfo &) = delete;
-	EnumTypeInfo &operator=(const EnumTypeInfo &) = delete;
-
-public:
-	const EnumDictType &GetEnumDictType() const;
-	const Vector &GetValuesInsertOrder() const;
-	const idx_t &GetDictSize() const;
-	static PhysicalType DictType(idx_t size);
-
-	static LogicalType CreateType(Vector &ordered_data, idx_t size);
-
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	// Equalities are only used in enums with different catalog entries
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-	Vector values_insert_order;
-
-private:
-	EnumDictType dict_type;
-	idx_t dict_size;
-};
-
-struct ArrayTypeInfo : public ExtraTypeInfo {
-	LogicalType child_type;
-	uint32_t size;
-	explicit ArrayTypeInfo(LogicalType child_type_p, uint32_t size_p);
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &reader);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-};
-
-struct AnyTypeInfo : public ExtraTypeInfo {
-	AnyTypeInfo(LogicalType target_type, idx_t cast_score);
-
-	LogicalType target_type;
-	idx_t cast_score;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	AnyTypeInfo();
-};
-
-struct IntegerLiteralTypeInfo : public ExtraTypeInfo {
-	explicit IntegerLiteralTypeInfo(Value constant_value);
-
-	Value constant_value;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
-	shared_ptr<ExtraTypeInfo> Copy() const override;
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
-
-private:
-	IntegerLiteralTypeInfo();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/extra_type_info/enum_type_info.hpp b/src/duckdb/src/include/duckdb/common/extra_type_info/enum_type_info.hpp
deleted file mode 100644
index 3949caa8b..000000000
--- a/src/duckdb/src/include/duckdb/common/extra_type_info/enum_type_info.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/string_map_set.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct EnumTypeInfoTemplated : public EnumTypeInfo {
-	explicit EnumTypeInfoTemplated(Vector &values_insert_order_p, idx_t size_p)
-	    : EnumTypeInfo(values_insert_order_p, size_p) {
-		D_ASSERT(values_insert_order_p.GetType().InternalType() == PhysicalType::VARCHAR);
-
-		UnifiedVectorFormat vdata;
-		values_insert_order.ToUnifiedFormat(size_p, vdata);
-
-		auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-		for (idx_t i = 0; i < size_p; i++) {
-			auto idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(idx)) {
-				throw InternalException("Attempted to create ENUM type with NULL value");
-			}
-			if (values.count(data[idx]) > 0) {
-				throw InvalidInputException("Attempted to create ENUM type with duplicate value %s",
-				                            data[idx].GetString());
-			}
-			values[data[idx]] = UnsafeNumericCast<T>(i);
-		}
-	}
-
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &deserializer, uint32_t size) {
-		Vector values_insert_order(LogicalType::VARCHAR, size);
-		auto strings = FlatVector::GetData<string_t>(values_insert_order);
-
-		deserializer.ReadList(201, "values", [&](Deserializer::List &list, idx_t i) {
-			strings[i] = StringVector::AddStringOrBlob(values_insert_order, list.ReadElement<string>());
-		});
-		return make_shared_ptr<EnumTypeInfoTemplated>(values_insert_order, size);
-	}
-
-	const string_map_t<T> &GetValues() const {
-		return values;
-	}
-
-	EnumTypeInfoTemplated(const EnumTypeInfoTemplated &) = delete;
-	EnumTypeInfoTemplated &operator=(const EnumTypeInfoTemplated &) = delete;
-
-private:
-	string_map_t<T> values;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/fast_mem.hpp b/src/duckdb/src/include/duckdb/common/fast_mem.hpp
deleted file mode 100644
index f18130862..000000000
--- a/src/duckdb/src/include/duckdb/common/fast_mem.hpp
+++ /dev/null
@@ -1,1221 +0,0 @@
-//                         DuckDB
-//
-// duckdb/common/fast_mem.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-
-template <size_t SIZE>
-inline void MemcpyFixed(void *dest, const void *src) {
-	memcpy(dest, src, SIZE);
-}
-
-template <size_t SIZE>
-inline int MemcmpFixed(const void *str1, const void *str2) {
-	return memcmp(str1, str2, SIZE);
-}
-
-template <size_t SIZE>
-inline void MemsetFixed(void *ptr, int value) {
-	memset(ptr, value, SIZE);
-}
-
-namespace duckdb {
-
-//! This templated memcpy is significantly faster than std::memcpy,
-//! but only when you are calling memcpy with a const size in a loop.
-//! For instance `while (<cond>) { memcpy(<dest>, <src>, const_size); ... }`
-inline void FastMemcpy(void *dest, const void *src, const size_t size) {
-	// LCOV_EXCL_START
-	switch (size) {
-	case 0:
-		return;
-	case 1:
-		return MemcpyFixed<1>(dest, src);
-	case 2:
-		return MemcpyFixed<2>(dest, src);
-	case 3:
-		return MemcpyFixed<3>(dest, src);
-	case 4:
-		return MemcpyFixed<4>(dest, src);
-	case 5:
-		return MemcpyFixed<5>(dest, src);
-	case 6:
-		return MemcpyFixed<6>(dest, src);
-	case 7:
-		return MemcpyFixed<7>(dest, src);
-	case 8:
-		return MemcpyFixed<8>(dest, src);
-	case 9:
-		return MemcpyFixed<9>(dest, src);
-	case 10:
-		return MemcpyFixed<10>(dest, src);
-	case 11:
-		return MemcpyFixed<11>(dest, src);
-	case 12:
-		return MemcpyFixed<12>(dest, src);
-	case 13:
-		return MemcpyFixed<13>(dest, src);
-	case 14:
-		return MemcpyFixed<14>(dest, src);
-	case 15:
-		return MemcpyFixed<15>(dest, src);
-	case 16:
-		return MemcpyFixed<16>(dest, src);
-	case 17:
-		return MemcpyFixed<17>(dest, src);
-	case 18:
-		return MemcpyFixed<18>(dest, src);
-	case 19:
-		return MemcpyFixed<19>(dest, src);
-	case 20:
-		return MemcpyFixed<20>(dest, src);
-	case 21:
-		return MemcpyFixed<21>(dest, src);
-	case 22:
-		return MemcpyFixed<22>(dest, src);
-	case 23:
-		return MemcpyFixed<23>(dest, src);
-	case 24:
-		return MemcpyFixed<24>(dest, src);
-	case 25:
-		return MemcpyFixed<25>(dest, src);
-	case 26:
-		return MemcpyFixed<26>(dest, src);
-	case 27:
-		return MemcpyFixed<27>(dest, src);
-	case 28:
-		return MemcpyFixed<28>(dest, src);
-	case 29:
-		return MemcpyFixed<29>(dest, src);
-	case 30:
-		return MemcpyFixed<30>(dest, src);
-	case 31:
-		return MemcpyFixed<31>(dest, src);
-	case 32:
-		return MemcpyFixed<32>(dest, src);
-	case 33:
-		return MemcpyFixed<33>(dest, src);
-	case 34:
-		return MemcpyFixed<34>(dest, src);
-	case 35:
-		return MemcpyFixed<35>(dest, src);
-	case 36:
-		return MemcpyFixed<36>(dest, src);
-	case 37:
-		return MemcpyFixed<37>(dest, src);
-	case 38:
-		return MemcpyFixed<38>(dest, src);
-	case 39:
-		return MemcpyFixed<39>(dest, src);
-	case 40:
-		return MemcpyFixed<40>(dest, src);
-	case 41:
-		return MemcpyFixed<41>(dest, src);
-	case 42:
-		return MemcpyFixed<42>(dest, src);
-	case 43:
-		return MemcpyFixed<43>(dest, src);
-	case 44:
-		return MemcpyFixed<44>(dest, src);
-	case 45:
-		return MemcpyFixed<45>(dest, src);
-	case 46:
-		return MemcpyFixed<46>(dest, src);
-	case 47:
-		return MemcpyFixed<47>(dest, src);
-	case 48:
-		return MemcpyFixed<48>(dest, src);
-	case 49:
-		return MemcpyFixed<49>(dest, src);
-	case 50:
-		return MemcpyFixed<50>(dest, src);
-	case 51:
-		return MemcpyFixed<51>(dest, src);
-	case 52:
-		return MemcpyFixed<52>(dest, src);
-	case 53:
-		return MemcpyFixed<53>(dest, src);
-	case 54:
-		return MemcpyFixed<54>(dest, src);
-	case 55:
-		return MemcpyFixed<55>(dest, src);
-	case 56:
-		return MemcpyFixed<56>(dest, src);
-	case 57:
-		return MemcpyFixed<57>(dest, src);
-	case 58:
-		return MemcpyFixed<58>(dest, src);
-	case 59:
-		return MemcpyFixed<59>(dest, src);
-	case 60:
-		return MemcpyFixed<60>(dest, src);
-	case 61:
-		return MemcpyFixed<61>(dest, src);
-	case 62:
-		return MemcpyFixed<62>(dest, src);
-	case 63:
-		return MemcpyFixed<63>(dest, src);
-	case 64:
-		return MemcpyFixed<64>(dest, src);
-	case 65:
-		return MemcpyFixed<65>(dest, src);
-	case 66:
-		return MemcpyFixed<66>(dest, src);
-	case 67:
-		return MemcpyFixed<67>(dest, src);
-	case 68:
-		return MemcpyFixed<68>(dest, src);
-	case 69:
-		return MemcpyFixed<69>(dest, src);
-	case 70:
-		return MemcpyFixed<70>(dest, src);
-	case 71:
-		return MemcpyFixed<71>(dest, src);
-	case 72:
-		return MemcpyFixed<72>(dest, src);
-	case 73:
-		return MemcpyFixed<73>(dest, src);
-	case 74:
-		return MemcpyFixed<74>(dest, src);
-	case 75:
-		return MemcpyFixed<75>(dest, src);
-	case 76:
-		return MemcpyFixed<76>(dest, src);
-	case 77:
-		return MemcpyFixed<77>(dest, src);
-	case 78:
-		return MemcpyFixed<78>(dest, src);
-	case 79:
-		return MemcpyFixed<79>(dest, src);
-	case 80:
-		return MemcpyFixed<80>(dest, src);
-	case 81:
-		return MemcpyFixed<81>(dest, src);
-	case 82:
-		return MemcpyFixed<82>(dest, src);
-	case 83:
-		return MemcpyFixed<83>(dest, src);
-	case 84:
-		return MemcpyFixed<84>(dest, src);
-	case 85:
-		return MemcpyFixed<85>(dest, src);
-	case 86:
-		return MemcpyFixed<86>(dest, src);
-	case 87:
-		return MemcpyFixed<87>(dest, src);
-	case 88:
-		return MemcpyFixed<88>(dest, src);
-	case 89:
-		return MemcpyFixed<89>(dest, src);
-	case 90:
-		return MemcpyFixed<90>(dest, src);
-	case 91:
-		return MemcpyFixed<91>(dest, src);
-	case 92:
-		return MemcpyFixed<92>(dest, src);
-	case 93:
-		return MemcpyFixed<93>(dest, src);
-	case 94:
-		return MemcpyFixed<94>(dest, src);
-	case 95:
-		return MemcpyFixed<95>(dest, src);
-	case 96:
-		return MemcpyFixed<96>(dest, src);
-	case 97:
-		return MemcpyFixed<97>(dest, src);
-	case 98:
-		return MemcpyFixed<98>(dest, src);
-	case 99:
-		return MemcpyFixed<99>(dest, src);
-	case 100:
-		return MemcpyFixed<100>(dest, src);
-	case 101:
-		return MemcpyFixed<101>(dest, src);
-	case 102:
-		return MemcpyFixed<102>(dest, src);
-	case 103:
-		return MemcpyFixed<103>(dest, src);
-	case 104:
-		return MemcpyFixed<104>(dest, src);
-	case 105:
-		return MemcpyFixed<105>(dest, src);
-	case 106:
-		return MemcpyFixed<106>(dest, src);
-	case 107:
-		return MemcpyFixed<107>(dest, src);
-	case 108:
-		return MemcpyFixed<108>(dest, src);
-	case 109:
-		return MemcpyFixed<109>(dest, src);
-	case 110:
-		return MemcpyFixed<110>(dest, src);
-	case 111:
-		return MemcpyFixed<111>(dest, src);
-	case 112:
-		return MemcpyFixed<112>(dest, src);
-	case 113:
-		return MemcpyFixed<113>(dest, src);
-	case 114:
-		return MemcpyFixed<114>(dest, src);
-	case 115:
-		return MemcpyFixed<115>(dest, src);
-	case 116:
-		return MemcpyFixed<116>(dest, src);
-	case 117:
-		return MemcpyFixed<117>(dest, src);
-	case 118:
-		return MemcpyFixed<118>(dest, src);
-	case 119:
-		return MemcpyFixed<119>(dest, src);
-	case 120:
-		return MemcpyFixed<120>(dest, src);
-	case 121:
-		return MemcpyFixed<121>(dest, src);
-	case 122:
-		return MemcpyFixed<122>(dest, src);
-	case 123:
-		return MemcpyFixed<123>(dest, src);
-	case 124:
-		return MemcpyFixed<124>(dest, src);
-	case 125:
-		return MemcpyFixed<125>(dest, src);
-	case 126:
-		return MemcpyFixed<126>(dest, src);
-	case 127:
-		return MemcpyFixed<127>(dest, src);
-	case 128:
-		return MemcpyFixed<128>(dest, src);
-	case 129:
-		return MemcpyFixed<129>(dest, src);
-	case 130:
-		return MemcpyFixed<130>(dest, src);
-	case 131:
-		return MemcpyFixed<131>(dest, src);
-	case 132:
-		return MemcpyFixed<132>(dest, src);
-	case 133:
-		return MemcpyFixed<133>(dest, src);
-	case 134:
-		return MemcpyFixed<134>(dest, src);
-	case 135:
-		return MemcpyFixed<135>(dest, src);
-	case 136:
-		return MemcpyFixed<136>(dest, src);
-	case 137:
-		return MemcpyFixed<137>(dest, src);
-	case 138:
-		return MemcpyFixed<138>(dest, src);
-	case 139:
-		return MemcpyFixed<139>(dest, src);
-	case 140:
-		return MemcpyFixed<140>(dest, src);
-	case 141:
-		return MemcpyFixed<141>(dest, src);
-	case 142:
-		return MemcpyFixed<142>(dest, src);
-	case 143:
-		return MemcpyFixed<143>(dest, src);
-	case 144:
-		return MemcpyFixed<144>(dest, src);
-	case 145:
-		return MemcpyFixed<145>(dest, src);
-	case 146:
-		return MemcpyFixed<146>(dest, src);
-	case 147:
-		return MemcpyFixed<147>(dest, src);
-	case 148:
-		return MemcpyFixed<148>(dest, src);
-	case 149:
-		return MemcpyFixed<149>(dest, src);
-	case 150:
-		return MemcpyFixed<150>(dest, src);
-	case 151:
-		return MemcpyFixed<151>(dest, src);
-	case 152:
-		return MemcpyFixed<152>(dest, src);
-	case 153:
-		return MemcpyFixed<153>(dest, src);
-	case 154:
-		return MemcpyFixed<154>(dest, src);
-	case 155:
-		return MemcpyFixed<155>(dest, src);
-	case 156:
-		return MemcpyFixed<156>(dest, src);
-	case 157:
-		return MemcpyFixed<157>(dest, src);
-	case 158:
-		return MemcpyFixed<158>(dest, src);
-	case 159:
-		return MemcpyFixed<159>(dest, src);
-	case 160:
-		return MemcpyFixed<160>(dest, src);
-	case 161:
-		return MemcpyFixed<161>(dest, src);
-	case 162:
-		return MemcpyFixed<162>(dest, src);
-	case 163:
-		return MemcpyFixed<163>(dest, src);
-	case 164:
-		return MemcpyFixed<164>(dest, src);
-	case 165:
-		return MemcpyFixed<165>(dest, src);
-	case 166:
-		return MemcpyFixed<166>(dest, src);
-	case 167:
-		return MemcpyFixed<167>(dest, src);
-	case 168:
-		return MemcpyFixed<168>(dest, src);
-	case 169:
-		return MemcpyFixed<169>(dest, src);
-	case 170:
-		return MemcpyFixed<170>(dest, src);
-	case 171:
-		return MemcpyFixed<171>(dest, src);
-	case 172:
-		return MemcpyFixed<172>(dest, src);
-	case 173:
-		return MemcpyFixed<173>(dest, src);
-	case 174:
-		return MemcpyFixed<174>(dest, src);
-	case 175:
-		return MemcpyFixed<175>(dest, src);
-	case 176:
-		return MemcpyFixed<176>(dest, src);
-	case 177:
-		return MemcpyFixed<177>(dest, src);
-	case 178:
-		return MemcpyFixed<178>(dest, src);
-	case 179:
-		return MemcpyFixed<179>(dest, src);
-	case 180:
-		return MemcpyFixed<180>(dest, src);
-	case 181:
-		return MemcpyFixed<181>(dest, src);
-	case 182:
-		return MemcpyFixed<182>(dest, src);
-	case 183:
-		return MemcpyFixed<183>(dest, src);
-	case 184:
-		return MemcpyFixed<184>(dest, src);
-	case 185:
-		return MemcpyFixed<185>(dest, src);
-	case 186:
-		return MemcpyFixed<186>(dest, src);
-	case 187:
-		return MemcpyFixed<187>(dest, src);
-	case 188:
-		return MemcpyFixed<188>(dest, src);
-	case 189:
-		return MemcpyFixed<189>(dest, src);
-	case 190:
-		return MemcpyFixed<190>(dest, src);
-	case 191:
-		return MemcpyFixed<191>(dest, src);
-	case 192:
-		return MemcpyFixed<192>(dest, src);
-	case 193:
-		return MemcpyFixed<193>(dest, src);
-	case 194:
-		return MemcpyFixed<194>(dest, src);
-	case 195:
-		return MemcpyFixed<195>(dest, src);
-	case 196:
-		return MemcpyFixed<196>(dest, src);
-	case 197:
-		return MemcpyFixed<197>(dest, src);
-	case 198:
-		return MemcpyFixed<198>(dest, src);
-	case 199:
-		return MemcpyFixed<199>(dest, src);
-	case 200:
-		return MemcpyFixed<200>(dest, src);
-	case 201:
-		return MemcpyFixed<201>(dest, src);
-	case 202:
-		return MemcpyFixed<202>(dest, src);
-	case 203:
-		return MemcpyFixed<203>(dest, src);
-	case 204:
-		return MemcpyFixed<204>(dest, src);
-	case 205:
-		return MemcpyFixed<205>(dest, src);
-	case 206:
-		return MemcpyFixed<206>(dest, src);
-	case 207:
-		return MemcpyFixed<207>(dest, src);
-	case 208:
-		return MemcpyFixed<208>(dest, src);
-	case 209:
-		return MemcpyFixed<209>(dest, src);
-	case 210:
-		return MemcpyFixed<210>(dest, src);
-	case 211:
-		return MemcpyFixed<211>(dest, src);
-	case 212:
-		return MemcpyFixed<212>(dest, src);
-	case 213:
-		return MemcpyFixed<213>(dest, src);
-	case 214:
-		return MemcpyFixed<214>(dest, src);
-	case 215:
-		return MemcpyFixed<215>(dest, src);
-	case 216:
-		return MemcpyFixed<216>(dest, src);
-	case 217:
-		return MemcpyFixed<217>(dest, src);
-	case 218:
-		return MemcpyFixed<218>(dest, src);
-	case 219:
-		return MemcpyFixed<219>(dest, src);
-	case 220:
-		return MemcpyFixed<220>(dest, src);
-	case 221:
-		return MemcpyFixed<221>(dest, src);
-	case 222:
-		return MemcpyFixed<222>(dest, src);
-	case 223:
-		return MemcpyFixed<223>(dest, src);
-	case 224:
-		return MemcpyFixed<224>(dest, src);
-	case 225:
-		return MemcpyFixed<225>(dest, src);
-	case 226:
-		return MemcpyFixed<226>(dest, src);
-	case 227:
-		return MemcpyFixed<227>(dest, src);
-	case 228:
-		return MemcpyFixed<228>(dest, src);
-	case 229:
-		return MemcpyFixed<229>(dest, src);
-	case 230:
-		return MemcpyFixed<230>(dest, src);
-	case 231:
-		return MemcpyFixed<231>(dest, src);
-	case 232:
-		return MemcpyFixed<232>(dest, src);
-	case 233:
-		return MemcpyFixed<233>(dest, src);
-	case 234:
-		return MemcpyFixed<234>(dest, src);
-	case 235:
-		return MemcpyFixed<235>(dest, src);
-	case 236:
-		return MemcpyFixed<236>(dest, src);
-	case 237:
-		return MemcpyFixed<237>(dest, src);
-	case 238:
-		return MemcpyFixed<238>(dest, src);
-	case 239:
-		return MemcpyFixed<239>(dest, src);
-	case 240:
-		return MemcpyFixed<240>(dest, src);
-	case 241:
-		return MemcpyFixed<241>(dest, src);
-	case 242:
-		return MemcpyFixed<242>(dest, src);
-	case 243:
-		return MemcpyFixed<243>(dest, src);
-	case 244:
-		return MemcpyFixed<244>(dest, src);
-	case 245:
-		return MemcpyFixed<245>(dest, src);
-	case 246:
-		return MemcpyFixed<246>(dest, src);
-	case 247:
-		return MemcpyFixed<247>(dest, src);
-	case 248:
-		return MemcpyFixed<248>(dest, src);
-	case 249:
-		return MemcpyFixed<249>(dest, src);
-	case 250:
-		return MemcpyFixed<250>(dest, src);
-	case 251:
-		return MemcpyFixed<251>(dest, src);
-	case 252:
-		return MemcpyFixed<252>(dest, src);
-	case 253:
-		return MemcpyFixed<253>(dest, src);
-	case 254:
-		return MemcpyFixed<254>(dest, src);
-	case 255:
-		return MemcpyFixed<255>(dest, src);
-	case 256:
-		return MemcpyFixed<256>(dest, src);
-	default:
-		memcpy(dest, src, size);
-	}
-	// LCOV_EXCL_STOP
-}
-
-//! This templated memcmp is significantly faster than std::memcmp,
-//! but only when you are calling memcmp with a const size in a loop.
-//! For instance `while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }`
-inline int FastMemcmp(const void *str1, const void *str2, const size_t size) {
-	// LCOV_EXCL_START
-	switch (size) {
-	case 0:
-		return 0;
-	case 1:
-		return MemcmpFixed<1>(str1, str2);
-	case 2:
-		return MemcmpFixed<2>(str1, str2);
-	case 3:
-		return MemcmpFixed<3>(str1, str2);
-	case 4:
-		return MemcmpFixed<4>(str1, str2);
-	case 5:
-		return MemcmpFixed<5>(str1, str2);
-	case 6:
-		return MemcmpFixed<6>(str1, str2);
-	case 7:
-		return MemcmpFixed<7>(str1, str2);
-	case 8:
-		return MemcmpFixed<8>(str1, str2);
-	case 9:
-		return MemcmpFixed<9>(str1, str2);
-	case 10:
-		return MemcmpFixed<10>(str1, str2);
-	case 11:
-		return MemcmpFixed<11>(str1, str2);
-	case 12:
-		return MemcmpFixed<12>(str1, str2);
-	case 13:
-		return MemcmpFixed<13>(str1, str2);
-	case 14:
-		return MemcmpFixed<14>(str1, str2);
-	case 15:
-		return MemcmpFixed<15>(str1, str2);
-	case 16:
-		return MemcmpFixed<16>(str1, str2);
-	case 17:
-		return MemcmpFixed<17>(str1, str2);
-	case 18:
-		return MemcmpFixed<18>(str1, str2);
-	case 19:
-		return MemcmpFixed<19>(str1, str2);
-	case 20:
-		return MemcmpFixed<20>(str1, str2);
-	case 21:
-		return MemcmpFixed<21>(str1, str2);
-	case 22:
-		return MemcmpFixed<22>(str1, str2);
-	case 23:
-		return MemcmpFixed<23>(str1, str2);
-	case 24:
-		return MemcmpFixed<24>(str1, str2);
-	case 25:
-		return MemcmpFixed<25>(str1, str2);
-	case 26:
-		return MemcmpFixed<26>(str1, str2);
-	case 27:
-		return MemcmpFixed<27>(str1, str2);
-	case 28:
-		return MemcmpFixed<28>(str1, str2);
-	case 29:
-		return MemcmpFixed<29>(str1, str2);
-	case 30:
-		return MemcmpFixed<30>(str1, str2);
-	case 31:
-		return MemcmpFixed<31>(str1, str2);
-	case 32:
-		return MemcmpFixed<32>(str1, str2);
-	case 33:
-		return MemcmpFixed<33>(str1, str2);
-	case 34:
-		return MemcmpFixed<34>(str1, str2);
-	case 35:
-		return MemcmpFixed<35>(str1, str2);
-	case 36:
-		return MemcmpFixed<36>(str1, str2);
-	case 37:
-		return MemcmpFixed<37>(str1, str2);
-	case 38:
-		return MemcmpFixed<38>(str1, str2);
-	case 39:
-		return MemcmpFixed<39>(str1, str2);
-	case 40:
-		return MemcmpFixed<40>(str1, str2);
-	case 41:
-		return MemcmpFixed<41>(str1, str2);
-	case 42:
-		return MemcmpFixed<42>(str1, str2);
-	case 43:
-		return MemcmpFixed<43>(str1, str2);
-	case 44:
-		return MemcmpFixed<44>(str1, str2);
-	case 45:
-		return MemcmpFixed<45>(str1, str2);
-	case 46:
-		return MemcmpFixed<46>(str1, str2);
-	case 47:
-		return MemcmpFixed<47>(str1, str2);
-	case 48:
-		return MemcmpFixed<48>(str1, str2);
-	case 49:
-		return MemcmpFixed<49>(str1, str2);
-	case 50:
-		return MemcmpFixed<50>(str1, str2);
-	case 51:
-		return MemcmpFixed<51>(str1, str2);
-	case 52:
-		return MemcmpFixed<52>(str1, str2);
-	case 53:
-		return MemcmpFixed<53>(str1, str2);
-	case 54:
-		return MemcmpFixed<54>(str1, str2);
-	case 55:
-		return MemcmpFixed<55>(str1, str2);
-	case 56:
-		return MemcmpFixed<56>(str1, str2);
-	case 57:
-		return MemcmpFixed<57>(str1, str2);
-	case 58:
-		return MemcmpFixed<58>(str1, str2);
-	case 59:
-		return MemcmpFixed<59>(str1, str2);
-	case 60:
-		return MemcmpFixed<60>(str1, str2);
-	case 61:
-		return MemcmpFixed<61>(str1, str2);
-	case 62:
-		return MemcmpFixed<62>(str1, str2);
-	case 63:
-		return MemcmpFixed<63>(str1, str2);
-	case 64:
-		return MemcmpFixed<64>(str1, str2);
-	default:
-		return memcmp(str1, str2, size);
-	}
-	// LCOV_EXCL_STOP
-}
-
-inline void FastMemset(void *ptr, int value, size_t size) {
-	// LCOV_EXCL_START
-	switch (size) {
-	case 0:
-		return;
-	case 1:
-		return MemsetFixed<1>(ptr, value);
-	case 2:
-		return MemsetFixed<2>(ptr, value);
-	case 3:
-		return MemsetFixed<3>(ptr, value);
-	case 4:
-		return MemsetFixed<4>(ptr, value);
-	case 5:
-		return MemsetFixed<5>(ptr, value);
-	case 6:
-		return MemsetFixed<6>(ptr, value);
-	case 7:
-		return MemsetFixed<7>(ptr, value);
-	case 8:
-		return MemsetFixed<8>(ptr, value);
-	case 9:
-		return MemsetFixed<9>(ptr, value);
-	case 10:
-		return MemsetFixed<10>(ptr, value);
-	case 11:
-		return MemsetFixed<11>(ptr, value);
-	case 12:
-		return MemsetFixed<12>(ptr, value);
-	case 13:
-		return MemsetFixed<13>(ptr, value);
-	case 14:
-		return MemsetFixed<14>(ptr, value);
-	case 15:
-		return MemsetFixed<15>(ptr, value);
-	case 16:
-		return MemsetFixed<16>(ptr, value);
-	case 17:
-		return MemsetFixed<17>(ptr, value);
-	case 18:
-		return MemsetFixed<18>(ptr, value);
-	case 19:
-		return MemsetFixed<19>(ptr, value);
-	case 20:
-		return MemsetFixed<20>(ptr, value);
-	case 21:
-		return MemsetFixed<21>(ptr, value);
-	case 22:
-		return MemsetFixed<22>(ptr, value);
-	case 23:
-		return MemsetFixed<23>(ptr, value);
-	case 24:
-		return MemsetFixed<24>(ptr, value);
-	case 25:
-		return MemsetFixed<25>(ptr, value);
-	case 26:
-		return MemsetFixed<26>(ptr, value);
-	case 27:
-		return MemsetFixed<27>(ptr, value);
-	case 28:
-		return MemsetFixed<28>(ptr, value);
-	case 29:
-		return MemsetFixed<29>(ptr, value);
-	case 30:
-		return MemsetFixed<30>(ptr, value);
-	case 31:
-		return MemsetFixed<31>(ptr, value);
-	case 32:
-		return MemsetFixed<32>(ptr, value);
-	case 33:
-		return MemsetFixed<33>(ptr, value);
-	case 34:
-		return MemsetFixed<34>(ptr, value);
-	case 35:
-		return MemsetFixed<35>(ptr, value);
-	case 36:
-		return MemsetFixed<36>(ptr, value);
-	case 37:
-		return MemsetFixed<37>(ptr, value);
-	case 38:
-		return MemsetFixed<38>(ptr, value);
-	case 39:
-		return MemsetFixed<39>(ptr, value);
-	case 40:
-		return MemsetFixed<40>(ptr, value);
-	case 41:
-		return MemsetFixed<41>(ptr, value);
-	case 42:
-		return MemsetFixed<42>(ptr, value);
-	case 43:
-		return MemsetFixed<43>(ptr, value);
-	case 44:
-		return MemsetFixed<44>(ptr, value);
-	case 45:
-		return MemsetFixed<45>(ptr, value);
-	case 46:
-		return MemsetFixed<46>(ptr, value);
-	case 47:
-		return MemsetFixed<47>(ptr, value);
-	case 48:
-		return MemsetFixed<48>(ptr, value);
-	case 49:
-		return MemsetFixed<49>(ptr, value);
-	case 50:
-		return MemsetFixed<50>(ptr, value);
-	case 51:
-		return MemsetFixed<51>(ptr, value);
-	case 52:
-		return MemsetFixed<52>(ptr, value);
-	case 53:
-		return MemsetFixed<53>(ptr, value);
-	case 54:
-		return MemsetFixed<54>(ptr, value);
-	case 55:
-		return MemsetFixed<55>(ptr, value);
-	case 56:
-		return MemsetFixed<56>(ptr, value);
-	case 57:
-		return MemsetFixed<57>(ptr, value);
-	case 58:
-		return MemsetFixed<58>(ptr, value);
-	case 59:
-		return MemsetFixed<59>(ptr, value);
-	case 60:
-		return MemsetFixed<60>(ptr, value);
-	case 61:
-		return MemsetFixed<61>(ptr, value);
-	case 62:
-		return MemsetFixed<62>(ptr, value);
-	case 63:
-		return MemsetFixed<63>(ptr, value);
-	case 64:
-		return MemsetFixed<64>(ptr, value);
-	case 65:
-		return MemsetFixed<65>(ptr, value);
-	case 66:
-		return MemsetFixed<66>(ptr, value);
-	case 67:
-		return MemsetFixed<67>(ptr, value);
-	case 68:
-		return MemsetFixed<68>(ptr, value);
-	case 69:
-		return MemsetFixed<69>(ptr, value);
-	case 70:
-		return MemsetFixed<70>(ptr, value);
-	case 71:
-		return MemsetFixed<71>(ptr, value);
-	case 72:
-		return MemsetFixed<72>(ptr, value);
-	case 73:
-		return MemsetFixed<73>(ptr, value);
-	case 74:
-		return MemsetFixed<74>(ptr, value);
-	case 75:
-		return MemsetFixed<75>(ptr, value);
-	case 76:
-		return MemsetFixed<76>(ptr, value);
-	case 77:
-		return MemsetFixed<77>(ptr, value);
-	case 78:
-		return MemsetFixed<78>(ptr, value);
-	case 79:
-		return MemsetFixed<79>(ptr, value);
-	case 80:
-		return MemsetFixed<80>(ptr, value);
-	case 81:
-		return MemsetFixed<81>(ptr, value);
-	case 82:
-		return MemsetFixed<82>(ptr, value);
-	case 83:
-		return MemsetFixed<83>(ptr, value);
-	case 84:
-		return MemsetFixed<84>(ptr, value);
-	case 85:
-		return MemsetFixed<85>(ptr, value);
-	case 86:
-		return MemsetFixed<86>(ptr, value);
-	case 87:
-		return MemsetFixed<87>(ptr, value);
-	case 88:
-		return MemsetFixed<88>(ptr, value);
-	case 89:
-		return MemsetFixed<89>(ptr, value);
-	case 90:
-		return MemsetFixed<90>(ptr, value);
-	case 91:
-		return MemsetFixed<91>(ptr, value);
-	case 92:
-		return MemsetFixed<92>(ptr, value);
-	case 93:
-		return MemsetFixed<93>(ptr, value);
-	case 94:
-		return MemsetFixed<94>(ptr, value);
-	case 95:
-		return MemsetFixed<95>(ptr, value);
-	case 96:
-		return MemsetFixed<96>(ptr, value);
-	case 97:
-		return MemsetFixed<97>(ptr, value);
-	case 98:
-		return MemsetFixed<98>(ptr, value);
-	case 99:
-		return MemsetFixed<99>(ptr, value);
-	case 100:
-		return MemsetFixed<100>(ptr, value);
-	case 101:
-		return MemsetFixed<101>(ptr, value);
-	case 102:
-		return MemsetFixed<102>(ptr, value);
-	case 103:
-		return MemsetFixed<103>(ptr, value);
-	case 104:
-		return MemsetFixed<104>(ptr, value);
-	case 105:
-		return MemsetFixed<105>(ptr, value);
-	case 106:
-		return MemsetFixed<106>(ptr, value);
-	case 107:
-		return MemsetFixed<107>(ptr, value);
-	case 108:
-		return MemsetFixed<108>(ptr, value);
-	case 109:
-		return MemsetFixed<109>(ptr, value);
-	case 110:
-		return MemsetFixed<110>(ptr, value);
-	case 111:
-		return MemsetFixed<111>(ptr, value);
-	case 112:
-		return MemsetFixed<112>(ptr, value);
-	case 113:
-		return MemsetFixed<113>(ptr, value);
-	case 114:
-		return MemsetFixed<114>(ptr, value);
-	case 115:
-		return MemsetFixed<115>(ptr, value);
-	case 116:
-		return MemsetFixed<116>(ptr, value);
-	case 117:
-		return MemsetFixed<117>(ptr, value);
-	case 118:
-		return MemsetFixed<118>(ptr, value);
-	case 119:
-		return MemsetFixed<119>(ptr, value);
-	case 120:
-		return MemsetFixed<120>(ptr, value);
-	case 121:
-		return MemsetFixed<121>(ptr, value);
-	case 122:
-		return MemsetFixed<122>(ptr, value);
-	case 123:
-		return MemsetFixed<123>(ptr, value);
-	case 124:
-		return MemsetFixed<124>(ptr, value);
-	case 125:
-		return MemsetFixed<125>(ptr, value);
-	case 126:
-		return MemsetFixed<126>(ptr, value);
-	case 127:
-		return MemsetFixed<127>(ptr, value);
-	case 128:
-		return MemsetFixed<128>(ptr, value);
-	case 129:
-		return MemsetFixed<129>(ptr, value);
-	case 130:
-		return MemsetFixed<130>(ptr, value);
-	case 131:
-		return MemsetFixed<131>(ptr, value);
-	case 132:
-		return MemsetFixed<132>(ptr, value);
-	case 133:
-		return MemsetFixed<133>(ptr, value);
-	case 134:
-		return MemsetFixed<134>(ptr, value);
-	case 135:
-		return MemsetFixed<135>(ptr, value);
-	case 136:
-		return MemsetFixed<136>(ptr, value);
-	case 137:
-		return MemsetFixed<137>(ptr, value);
-	case 138:
-		return MemsetFixed<138>(ptr, value);
-	case 139:
-		return MemsetFixed<139>(ptr, value);
-	case 140:
-		return MemsetFixed<140>(ptr, value);
-	case 141:
-		return MemsetFixed<141>(ptr, value);
-	case 142:
-		return MemsetFixed<142>(ptr, value);
-	case 143:
-		return MemsetFixed<143>(ptr, value);
-	case 144:
-		return MemsetFixed<144>(ptr, value);
-	case 145:
-		return MemsetFixed<145>(ptr, value);
-	case 146:
-		return MemsetFixed<146>(ptr, value);
-	case 147:
-		return MemsetFixed<147>(ptr, value);
-	case 148:
-		return MemsetFixed<148>(ptr, value);
-	case 149:
-		return MemsetFixed<149>(ptr, value);
-	case 150:
-		return MemsetFixed<150>(ptr, value);
-	case 151:
-		return MemsetFixed<151>(ptr, value);
-	case 152:
-		return MemsetFixed<152>(ptr, value);
-	case 153:
-		return MemsetFixed<153>(ptr, value);
-	case 154:
-		return MemsetFixed<154>(ptr, value);
-	case 155:
-		return MemsetFixed<155>(ptr, value);
-	case 156:
-		return MemsetFixed<156>(ptr, value);
-	case 157:
-		return MemsetFixed<157>(ptr, value);
-	case 158:
-		return MemsetFixed<158>(ptr, value);
-	case 159:
-		return MemsetFixed<159>(ptr, value);
-	case 160:
-		return MemsetFixed<160>(ptr, value);
-	case 161:
-		return MemsetFixed<161>(ptr, value);
-	case 162:
-		return MemsetFixed<162>(ptr, value);
-	case 163:
-		return MemsetFixed<163>(ptr, value);
-	case 164:
-		return MemsetFixed<164>(ptr, value);
-	case 165:
-		return MemsetFixed<165>(ptr, value);
-	case 166:
-		return MemsetFixed<166>(ptr, value);
-	case 167:
-		return MemsetFixed<167>(ptr, value);
-	case 168:
-		return MemsetFixed<168>(ptr, value);
-	case 169:
-		return MemsetFixed<169>(ptr, value);
-	case 170:
-		return MemsetFixed<170>(ptr, value);
-	case 171:
-		return MemsetFixed<171>(ptr, value);
-	case 172:
-		return MemsetFixed<172>(ptr, value);
-	case 173:
-		return MemsetFixed<173>(ptr, value);
-	case 174:
-		return MemsetFixed<174>(ptr, value);
-	case 175:
-		return MemsetFixed<175>(ptr, value);
-	case 176:
-		return MemsetFixed<176>(ptr, value);
-	case 177:
-		return MemsetFixed<177>(ptr, value);
-	case 178:
-		return MemsetFixed<178>(ptr, value);
-	case 179:
-		return MemsetFixed<179>(ptr, value);
-	case 180:
-		return MemsetFixed<180>(ptr, value);
-	case 181:
-		return MemsetFixed<181>(ptr, value);
-	case 182:
-		return MemsetFixed<182>(ptr, value);
-	case 183:
-		return MemsetFixed<183>(ptr, value);
-	case 184:
-		return MemsetFixed<184>(ptr, value);
-	case 185:
-		return MemsetFixed<185>(ptr, value);
-	case 186:
-		return MemsetFixed<186>(ptr, value);
-	case 187:
-		return MemsetFixed<187>(ptr, value);
-	case 188:
-		return MemsetFixed<188>(ptr, value);
-	case 189:
-		return MemsetFixed<189>(ptr, value);
-	case 190:
-		return MemsetFixed<190>(ptr, value);
-	case 191:
-		return MemsetFixed<191>(ptr, value);
-	case 192:
-		return MemsetFixed<192>(ptr, value);
-	case 193:
-		return MemsetFixed<193>(ptr, value);
-	case 194:
-		return MemsetFixed<194>(ptr, value);
-	case 195:
-		return MemsetFixed<195>(ptr, value);
-	case 196:
-		return MemsetFixed<196>(ptr, value);
-	case 197:
-		return MemsetFixed<197>(ptr, value);
-	case 198:
-		return MemsetFixed<198>(ptr, value);
-	case 199:
-		return MemsetFixed<199>(ptr, value);
-	case 200:
-		return MemsetFixed<200>(ptr, value);
-	case 201:
-		return MemsetFixed<201>(ptr, value);
-	case 202:
-		return MemsetFixed<202>(ptr, value);
-	case 203:
-		return MemsetFixed<203>(ptr, value);
-	case 204:
-		return MemsetFixed<204>(ptr, value);
-	case 205:
-		return MemsetFixed<205>(ptr, value);
-	case 206:
-		return MemsetFixed<206>(ptr, value);
-	case 207:
-		return MemsetFixed<207>(ptr, value);
-	case 208:
-		return MemsetFixed<208>(ptr, value);
-	case 209:
-		return MemsetFixed<209>(ptr, value);
-	case 210:
-		return MemsetFixed<210>(ptr, value);
-	case 211:
-		return MemsetFixed<211>(ptr, value);
-	case 212:
-		return MemsetFixed<212>(ptr, value);
-	case 213:
-		return MemsetFixed<213>(ptr, value);
-	case 214:
-		return MemsetFixed<214>(ptr, value);
-	case 215:
-		return MemsetFixed<215>(ptr, value);
-	case 216:
-		return MemsetFixed<216>(ptr, value);
-	case 217:
-		return MemsetFixed<217>(ptr, value);
-	case 218:
-		return MemsetFixed<218>(ptr, value);
-	case 219:
-		return MemsetFixed<219>(ptr, value);
-	case 220:
-		return MemsetFixed<220>(ptr, value);
-	case 221:
-		return MemsetFixed<221>(ptr, value);
-	case 222:
-		return MemsetFixed<222>(ptr, value);
-	case 223:
-		return MemsetFixed<223>(ptr, value);
-	case 224:
-		return MemsetFixed<224>(ptr, value);
-	case 225:
-		return MemsetFixed<225>(ptr, value);
-	case 226:
-		return MemsetFixed<226>(ptr, value);
-	case 227:
-		return MemsetFixed<227>(ptr, value);
-	case 228:
-		return MemsetFixed<228>(ptr, value);
-	case 229:
-		return MemsetFixed<229>(ptr, value);
-	case 230:
-		return MemsetFixed<230>(ptr, value);
-	case 231:
-		return MemsetFixed<231>(ptr, value);
-	case 232:
-		return MemsetFixed<232>(ptr, value);
-	case 233:
-		return MemsetFixed<233>(ptr, value);
-	case 234:
-		return MemsetFixed<234>(ptr, value);
-	case 235:
-		return MemsetFixed<235>(ptr, value);
-	case 236:
-		return MemsetFixed<236>(ptr, value);
-	case 237:
-		return MemsetFixed<237>(ptr, value);
-	case 238:
-		return MemsetFixed<238>(ptr, value);
-	case 239:
-		return MemsetFixed<239>(ptr, value);
-	case 240:
-		return MemsetFixed<240>(ptr, value);
-	case 241:
-		return MemsetFixed<241>(ptr, value);
-	case 242:
-		return MemsetFixed<242>(ptr, value);
-	case 243:
-		return MemsetFixed<243>(ptr, value);
-	case 244:
-		return MemsetFixed<244>(ptr, value);
-	case 245:
-		return MemsetFixed<245>(ptr, value);
-	case 246:
-		return MemsetFixed<246>(ptr, value);
-	case 247:
-		return MemsetFixed<247>(ptr, value);
-	case 248:
-		return MemsetFixed<248>(ptr, value);
-	case 249:
-		return MemsetFixed<249>(ptr, value);
-	case 250:
-		return MemsetFixed<250>(ptr, value);
-	case 251:
-		return MemsetFixed<251>(ptr, value);
-	case 252:
-		return MemsetFixed<252>(ptr, value);
-	case 253:
-		return MemsetFixed<253>(ptr, value);
-	case 254:
-		return MemsetFixed<254>(ptr, value);
-	case 255:
-		return MemsetFixed<255>(ptr, value);
-	case 256:
-		return MemsetFixed<256>(ptr, value);
-	default:
-		memset(ptr, value, size);
-	}
-	// LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/file_buffer.hpp b/src/duckdb/src/include/duckdb/common/file_buffer.hpp
deleted file mode 100644
index 8db3e0d0c..000000000
--- a/src/duckdb/src/include/duckdb/common/file_buffer.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/enums/debug_initialize.hpp"
-
-namespace duckdb {
-class Allocator;
-struct FileHandle;
-
-enum class FileBufferType : uint8_t { BLOCK = 1, MANAGED_BUFFER = 2, TINY_BUFFER = 3 };
-
-static constexpr idx_t FILE_BUFFER_TYPE_COUNT = 3;
-
-//! The FileBuffer represents a buffer that can be read or written to a Direct IO FileHandle.
-class FileBuffer {
-public:
-	//! Allocates a buffer of the specified size, with room for additional header bytes
-	//! (typically 8 bytes). On return, this->AllocSize() >= this->size >= user_size.
-	//! Our allocation size will always be page-aligned, which is necessary to support
-	//! DIRECT_IO
-	FileBuffer(Allocator &allocator, FileBufferType type, uint64_t user_size);
-	FileBuffer(FileBuffer &source, FileBufferType type);
-
-	virtual ~FileBuffer();
-
-	Allocator &allocator;
-	//! The buffer that users can write to
-	data_ptr_t buffer;
-	//! The user-facing size of the buffer.
-	//! This is equivalent to internal_size - BLOCK_HEADER_SIZE.
-	uint64_t size;
-
-public:
-	//! Read into the FileBuffer from the specified location.
-	void Read(FileHandle &handle, uint64_t location);
-	//! Write the contents of the FileBuffer to the specified location.
-	void Write(FileHandle &handle, uint64_t location);
-
-	void Clear();
-
-	FileBufferType GetBufferType() const {
-		return type;
-	}
-
-	// Same rules as the constructor. We add room for a header, in addition to
-	// the requested user bytes. We then sector-align the result.
-	void Resize(uint64_t user_size);
-
-	uint64_t AllocSize() const {
-		return internal_size;
-	}
-	uint64_t Size() const {
-		return size;
-	}
-	data_ptr_t InternalBuffer() {
-		return internal_buffer;
-	}
-
-	struct MemoryRequirement {
-		idx_t alloc_size;
-		idx_t header_size;
-	};
-
-	MemoryRequirement CalculateMemory(uint64_t user_size);
-	void Initialize(DebugInitialize info);
-
-protected:
-	//! The type of the buffer.
-	FileBufferType type;
-	//! The pointer to the internal buffer that will be read from or written to.
-	//! This includes the buffer header.
-	data_ptr_t internal_buffer;
-	//! The aligned size as passed to the constructor.
-	//! This is the size that is read from or written to disk.
-	uint64_t internal_size;
-
-	void ReallocBuffer(idx_t new_size);
-	void Init();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/file_open_flags.hpp b/src/duckdb/src/include/duckdb/common/file_open_flags.hpp
deleted file mode 100644
index b469e338c..000000000
--- a/src/duckdb/src/include/duckdb/common/file_open_flags.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_open_flags.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/file_compression_type.hpp"
-
-namespace duckdb {
-
-enum class FileLockType : uint8_t { NO_LOCK = 0, READ_LOCK = 1, WRITE_LOCK = 2 };
-
-class FileOpenFlags {
-public:
-	static constexpr idx_t FILE_FLAGS_READ = idx_t(1 << 0);
-	static constexpr idx_t FILE_FLAGS_WRITE = idx_t(1 << 1);
-	static constexpr idx_t FILE_FLAGS_DIRECT_IO = idx_t(1 << 2);
-	static constexpr idx_t FILE_FLAGS_FILE_CREATE = idx_t(1 << 3);
-	static constexpr idx_t FILE_FLAGS_FILE_CREATE_NEW = idx_t(1 << 4);
-	static constexpr idx_t FILE_FLAGS_APPEND = idx_t(1 << 5);
-	static constexpr idx_t FILE_FLAGS_PRIVATE = idx_t(1 << 6);
-	static constexpr idx_t FILE_FLAGS_NULL_IF_NOT_EXISTS = idx_t(1 << 7);
-	static constexpr idx_t FILE_FLAGS_PARALLEL_ACCESS = idx_t(1 << 8);
-	static constexpr idx_t FILE_FLAGS_EXCLUSIVE_CREATE = idx_t(1 << 9);
-	static constexpr idx_t FILE_FLAGS_NULL_IF_EXISTS = idx_t(1 << 10);
-
-public:
-	FileOpenFlags() = default;
-	constexpr FileOpenFlags(idx_t flags) : flags(flags) { // NOLINT: allow implicit conversion
-	}
-	constexpr FileOpenFlags(FileLockType lock) : lock(lock) { // NOLINT: allow implicit conversion
-	}
-	constexpr FileOpenFlags(FileCompressionType compression) // NOLINT: allow implicit conversion
-	    : compression(compression) {
-	}
-	constexpr FileOpenFlags(idx_t flags, FileLockType lock, FileCompressionType compression)
-	    : flags(flags), lock(lock), compression(compression) {
-	}
-
-	static constexpr FileLockType MergeLock(FileLockType a, FileLockType b) {
-		return a == FileLockType::NO_LOCK ? b : a;
-	}
-
-	static constexpr FileCompressionType MergeCompression(FileCompressionType a, FileCompressionType b) {
-		return a == FileCompressionType::UNCOMPRESSED ? b : a;
-	}
-
-	inline constexpr FileOpenFlags operator|(FileOpenFlags b) const {
-		return FileOpenFlags(flags | b.flags, MergeLock(lock, b.lock), MergeCompression(compression, b.compression));
-	}
-	inline FileOpenFlags &operator|=(FileOpenFlags b) {
-		flags |= b.flags;
-		lock = MergeLock(lock, b.lock);
-		compression = MergeCompression(compression, b.compression);
-		return *this;
-	}
-
-	FileLockType Lock() {
-		return lock;
-	}
-
-	FileCompressionType Compression() {
-		return compression;
-	}
-
-	void SetCompression(FileCompressionType new_compression) {
-		compression = new_compression;
-	}
-
-	void Verify();
-
-	inline bool OpenForReading() const {
-		return flags & FILE_FLAGS_READ;
-	}
-	inline bool OpenForWriting() const {
-		return flags & FILE_FLAGS_WRITE;
-	}
-	inline bool DirectIO() const {
-		return flags & FILE_FLAGS_DIRECT_IO;
-	}
-	inline bool CreateFileIfNotExists() const {
-		return flags & FILE_FLAGS_FILE_CREATE;
-	}
-	inline bool OverwriteExistingFile() const {
-		return flags & FILE_FLAGS_FILE_CREATE_NEW;
-	}
-	inline bool OpenForAppending() const {
-		return flags & FILE_FLAGS_APPEND;
-	}
-	inline bool CreatePrivateFile() const {
-		return flags & FILE_FLAGS_PRIVATE;
-	}
-	inline bool ReturnNullIfNotExists() const {
-		return flags & FILE_FLAGS_NULL_IF_NOT_EXISTS;
-	}
-	inline bool RequireParallelAccess() const {
-		return flags & FILE_FLAGS_PARALLEL_ACCESS;
-	}
-	inline bool ExclusiveCreate() const {
-		return flags & FILE_FLAGS_EXCLUSIVE_CREATE;
-	}
-	inline bool ReturnNullIfExists() const {
-		return flags & FILE_FLAGS_NULL_IF_EXISTS;
-	}
-	inline idx_t GetFlagsInternal() const {
-		return flags;
-	}
-
-private:
-	idx_t flags = 0;
-	FileLockType lock = FileLockType::NO_LOCK;
-	FileCompressionType compression = FileCompressionType::UNCOMPRESSED;
-};
-
-class FileFlags {
-public:
-	//! Open file with read access
-	static constexpr FileOpenFlags FILE_FLAGS_READ = FileOpenFlags(FileOpenFlags::FILE_FLAGS_READ);
-	//! Open file with write access
-	static constexpr FileOpenFlags FILE_FLAGS_WRITE = FileOpenFlags(FileOpenFlags::FILE_FLAGS_WRITE);
-	//! Use direct IO when reading/writing to the file
-	static constexpr FileOpenFlags FILE_FLAGS_DIRECT_IO = FileOpenFlags(FileOpenFlags::FILE_FLAGS_DIRECT_IO);
-	//! Create file if not exists, can only be used together with WRITE
-	static constexpr FileOpenFlags FILE_FLAGS_FILE_CREATE = FileOpenFlags(FileOpenFlags::FILE_FLAGS_FILE_CREATE);
-	//! Always create a new file. If a file exists, the file is truncated. Cannot be used together with CREATE.
-	static constexpr FileOpenFlags FILE_FLAGS_FILE_CREATE_NEW =
-	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW);
-	//! Open file in append mode
-	static constexpr FileOpenFlags FILE_FLAGS_APPEND = FileOpenFlags(FileOpenFlags::FILE_FLAGS_APPEND);
-	//! Open file with restrictive permissions (600 on linux/mac) can only be used when creating, throws if file exists
-	static constexpr FileOpenFlags FILE_FLAGS_PRIVATE = FileOpenFlags(FileOpenFlags::FILE_FLAGS_PRIVATE);
-	//! Return NULL if the file does not exist instead of throwing an error
-	static constexpr FileOpenFlags FILE_FLAGS_NULL_IF_NOT_EXISTS =
-	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS);
-	//! Multiple threads may perform reads and writes in parallel
-	static constexpr FileOpenFlags FILE_FLAGS_PARALLEL_ACCESS =
-	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_PARALLEL_ACCESS);
-	//! Ensure that this call creates the file, throw is file exists
-	static constexpr FileOpenFlags FILE_FLAGS_EXCLUSIVE_CREATE =
-	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_EXCLUSIVE_CREATE);
-	//!  Return NULL if the file exist instead of throwing an error
-	static constexpr FileOpenFlags FILE_FLAGS_NULL_IF_EXISTS = FileOpenFlags(FileOpenFlags::FILE_FLAGS_NULL_IF_EXISTS);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/file_opener.hpp b/src/duckdb/src/include/duckdb/common/file_opener.hpp
deleted file mode 100644
index c985e8755..000000000
--- a/src/duckdb/src/include/duckdb/common/file_opener.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_opener.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/settings.hpp"
-
-namespace duckdb {
-
-struct CatalogTransaction;
-class SecretManager;
-class ClientContext;
-class Value;
-
-struct FileOpenerInfo {
-	string file_path;
-};
-
-//! Abstract type that provide client-specific context to FileSystem.
-class FileOpener {
-public:
-	FileOpener() {
-	}
-	virtual ~FileOpener() {};
-
-	virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info);
-	virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) = 0;
-	virtual optional_ptr<ClientContext> TryGetClientContext() = 0;
-	virtual optional_ptr<DatabaseInstance> TryGetDatabase() = 0;
-
-	DUCKDB_API static unique_ptr<CatalogTransaction> TryGetCatalogTransaction(optional_ptr<FileOpener> opener);
-	DUCKDB_API static optional_ptr<ClientContext> TryGetClientContext(optional_ptr<FileOpener> opener);
-	DUCKDB_API static optional_ptr<DatabaseInstance> TryGetDatabase(optional_ptr<FileOpener> opener);
-	DUCKDB_API static optional_ptr<SecretManager> TryGetSecretManager(optional_ptr<FileOpener> opener);
-	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key,
-	                                                           Value &result);
-	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key,
-	                                                           Value &result, FileOpenerInfo &info);
-
-	template <class TYPE>
-	static SettingLookupResult TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key, TYPE &result,
-	                                                optional_ptr<FileOpenerInfo> info) {
-		Value output;
-		SettingLookupResult lookup_result;
-
-		if (info) {
-			lookup_result = TryGetCurrentSetting(opener, key, output, *info);
-		} else {
-			lookup_result = TryGetCurrentSetting(opener, key, output, *info);
-		}
-
-		if (lookup_result) {
-			result = output.GetValue<TYPE>();
-		}
-		return lookup_result;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/file_system.hpp b/src/duckdb/src/include/duckdb/common/file_system.hpp
deleted file mode 100644
index e3aac6e9b..000000000
--- a/src/duckdb/src/include/duckdb/common/file_system.hpp
+++ /dev/null
@@ -1,266 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/file_compression_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/enums/file_glob_options.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/file_open_flags.hpp"
-#include <functional>
-
-#undef CreateDirectory
-#undef MoveFile
-#undef RemoveDirectory
-
-namespace duckdb {
-class AttachedDatabase;
-class ClientContext;
-class DatabaseInstance;
-class FileOpener;
-class FileSystem;
-
-enum class FileType {
-	//! Regular file
-	FILE_TYPE_REGULAR,
-	//! Directory
-	FILE_TYPE_DIR,
-	//! FIFO named pipe
-	FILE_TYPE_FIFO,
-	//! Socket
-	FILE_TYPE_SOCKET,
-	//! Symbolic link
-	FILE_TYPE_LINK,
-	//! Block device
-	FILE_TYPE_BLOCKDEV,
-	//! Character device
-	FILE_TYPE_CHARDEV,
-	//! Unknown or invalid file handle
-	FILE_TYPE_INVALID,
-};
-
-struct FileHandle {
-public:
-	DUCKDB_API FileHandle(FileSystem &file_system, string path, FileOpenFlags flags);
-	FileHandle(const FileHandle &) = delete;
-	DUCKDB_API virtual ~FileHandle();
-
-	DUCKDB_API int64_t Read(void *buffer, idx_t nr_bytes);
-	DUCKDB_API int64_t Write(void *buffer, idx_t nr_bytes);
-	DUCKDB_API void Read(void *buffer, idx_t nr_bytes, idx_t location);
-	DUCKDB_API void Write(void *buffer, idx_t nr_bytes, idx_t location);
-	DUCKDB_API void Seek(idx_t location);
-	DUCKDB_API void Reset();
-	DUCKDB_API idx_t SeekPosition();
-	DUCKDB_API void Sync();
-	DUCKDB_API void Truncate(int64_t new_size);
-	DUCKDB_API string ReadLine();
-	DUCKDB_API bool Trim(idx_t offset_bytes, idx_t length_bytes);
-	DUCKDB_API virtual idx_t GetProgress();
-	DUCKDB_API virtual FileCompressionType GetFileCompressionType();
-
-	DUCKDB_API bool CanSeek();
-	DUCKDB_API bool IsPipe();
-	DUCKDB_API bool OnDiskFile();
-	DUCKDB_API idx_t GetFileSize();
-	DUCKDB_API FileType GetType();
-
-	//! Closes the file handle.
-	DUCKDB_API virtual void Close() = 0;
-
-	string GetPath() const {
-		return path;
-	}
-
-	FileOpenFlags GetFlags() const {
-		return flags;
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-public:
-	FileSystem &file_system;
-	string path;
-	FileOpenFlags flags;
-};
-
-class FileSystem {
-public:
-	DUCKDB_API virtual ~FileSystem();
-
-public:
-	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
-	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
-	DUCKDB_API static FileSystem &Get(AttachedDatabase &db);
-
-	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
-	                                                   optional_ptr<FileOpener> opener = nullptr);
-
-	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Read().
-	DUCKDB_API virtual void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
-	//! Write exactly nr_bytes to the specified location in the file. Fails if nr_bytes could not be written. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Write().
-	DUCKDB_API virtual void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
-	//! Read nr_bytes from the specified file into the buffer, moving the file pointer forward by nr_bytes. Returns the
-	//! amount of bytes read.
-	DUCKDB_API virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
-	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
-	DUCKDB_API virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
-	//! Excise a range of the file. The OS can drop pages from the page-cache, and the file-system is free to deallocate
-	//! this range (sparse file support). Reads to the range will succeed but will return undefined data.
-	DUCKDB_API virtual bool Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes);
-
-	//! Returns the file size of a file handle, returns -1 on error
-	DUCKDB_API virtual int64_t GetFileSize(FileHandle &handle);
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	DUCKDB_API virtual time_t GetLastModifiedTime(FileHandle &handle);
-	//! Returns the file type of the attached handle
-	DUCKDB_API virtual FileType GetFileType(FileHandle &handle);
-	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
-	//! the file
-	DUCKDB_API virtual void Truncate(FileHandle &handle, int64_t new_size);
-
-	//! Check if a directory exists
-	DUCKDB_API virtual bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener = nullptr);
-	//! Create a directory if it does not exist
-	DUCKDB_API virtual void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr);
-	//! Recursively remove a directory and all files in it
-	DUCKDB_API virtual void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr);
-
-	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	DUCKDB_API virtual bool ListFiles(const string &directory,
-	                                  const std::function<void(const string &, bool)> &callback,
-	                                  FileOpener *opener = nullptr);
-
-	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
-	//! properties
-	DUCKDB_API virtual void MoveFile(const string &source, const string &target,
-	                                 optional_ptr<FileOpener> opener = nullptr);
-	//! Check if a file exists
-	DUCKDB_API virtual bool FileExists(const string &filename, optional_ptr<FileOpener> opener = nullptr);
-	//! Check if path is pipe
-	DUCKDB_API virtual bool IsPipe(const string &filename, optional_ptr<FileOpener> opener = nullptr);
-	//! Remove a file from disk
-	DUCKDB_API virtual void RemoveFile(const string &filename, optional_ptr<FileOpener> opener = nullptr);
-	//! Sync a file handle to disk
-	DUCKDB_API virtual void FileSync(FileHandle &handle);
-	//! Sets the working directory
-	DUCKDB_API static void SetWorkingDirectory(const string &path);
-	//! Gets the working directory
-	DUCKDB_API static string GetWorkingDirectory();
-	//! Gets the users home directory
-	DUCKDB_API static string GetHomeDirectory(optional_ptr<FileOpener> opener);
-	//! Gets the users home directory
-	DUCKDB_API virtual string GetHomeDirectory();
-	//! Expands a given path, including e.g. expanding the home directory of the user
-	DUCKDB_API static string ExpandPath(const string &path, optional_ptr<FileOpener> opener);
-	//! Expands a given path, including e.g. expanding the home directory of the user
-	DUCKDB_API virtual string ExpandPath(const string &path);
-	//! Returns the system-available memory in bytes. Returns DConstants::INVALID_INDEX if the system function fails.
-	DUCKDB_API static optional_idx GetAvailableMemory();
-	//! Returns the space available on the disk. Returns DConstants::INVALID_INDEX if the information was not available.
-	DUCKDB_API static optional_idx GetAvailableDiskSpace(const string &path);
-	//! Path separator for path
-	DUCKDB_API virtual string PathSeparator(const string &path);
-	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
-	DUCKDB_API bool IsPathAbsolute(const string &path);
-	//! Normalize an absolute path - the goal of normalizing is converting "\test.db" and "C:/test.db" into "C:\test.db"
-	//! so that the database system cache can correctly
-	DUCKDB_API string NormalizeAbsolutePath(const string &path);
-	//! Join two paths together
-	DUCKDB_API string JoinPath(const string &a, const string &path);
-	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
-	DUCKDB_API string ConvertSeparators(const string &path);
-	//! Extract the base name of a file (e.g. if the input is lib/example.dll the base name is 'example')
-	DUCKDB_API string ExtractBaseName(const string &path);
-	//! Extract the name of a file (e.g if the input is lib/example.dll the name is 'example.dll')
-	DUCKDB_API string ExtractName(const string &path);
-
-	//! Returns the value of an environment variable - or the empty string if it is not set
-	DUCKDB_API static string GetEnvVariable(const string &name);
-
-	//! Whether there is a glob in the string
-	DUCKDB_API static bool HasGlob(const string &str);
-	//! Runs a glob on the file system, returning a list of matching files
-	DUCKDB_API virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr);
-	DUCKDB_API vector<string> GlobFiles(const string &path, ClientContext &context,
-	                                    FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
-
-	//! registers a sub-file system to handle certain file name prefixes, e.g. http:// etc.
-	DUCKDB_API virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
-	DUCKDB_API virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
-
-	//! Unregister a sub-filesystem by name
-	DUCKDB_API virtual void UnregisterSubSystem(const string &name);
-
-	//! List registered sub-filesystems, including builtin ones
-	DUCKDB_API virtual vector<string> ListSubSystems();
-
-	//! Whether or not a sub-system can handle a specific file path
-	DUCKDB_API virtual bool CanHandleFile(const string &fpath);
-
-	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	DUCKDB_API virtual void Seek(FileHandle &handle, idx_t location);
-	//! Reset a file to the beginning (equivalent to Seek(handle, 0) for simple files)
-	DUCKDB_API virtual void Reset(FileHandle &handle);
-	DUCKDB_API virtual idx_t SeekPosition(FileHandle &handle);
-
-	//! If FS was manually set by the user
-	DUCKDB_API virtual bool IsManuallySet();
-	//! Whether or not we can seek into the file
-	DUCKDB_API virtual bool CanSeek();
-	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
-	//! in a file on-disk are much cheaper than e.g. random reads in a file over the network
-	DUCKDB_API virtual bool OnDiskFile(FileHandle &handle);
-
-	DUCKDB_API virtual unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write);
-
-	//! Create a LocalFileSystem.
-	DUCKDB_API static unique_ptr<FileSystem> CreateLocal();
-
-	//! Return the name of the filesytem. Used for forming diagnosis messages.
-	DUCKDB_API virtual std::string GetName() const = 0;
-
-	//! Whether or not a file is remote or local, based only on file path
-	DUCKDB_API static bool IsRemoteFile(const string &path);
-	DUCKDB_API static bool IsRemoteFile(const string &path, string &extension);
-
-	DUCKDB_API virtual void SetDisabledFileSystems(const vector<string> &names);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/filename_pattern.hpp b/src/duckdb/src/include/duckdb/common/filename_pattern.hpp
deleted file mode 100644
index 4ec3827f5..000000000
--- a/src/duckdb/src/include/duckdb/common/filename_pattern.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/filename_pattern.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/types/uuid.hpp"
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-
-class FilenamePattern {
-	friend Deserializer;
-
-public:
-	FilenamePattern() : base("data_"), pos(base.length()), uuid(false) {
-	}
-
-public:
-	void SetFilenamePattern(const string &pattern);
-	string CreateFilename(FileSystem &fs, const string &path, const string &extension, idx_t offset) const;
-
-	void Serialize(Serializer &serializer) const;
-	static FilenamePattern Deserialize(Deserializer &deserializer);
-
-	bool HasUUID() const {
-		return uuid;
-	}
-
-private:
-	string base;
-	idx_t pos;
-	bool uuid;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/fixed_size_map.hpp b/src/duckdb/src/include/duckdb/common/fixed_size_map.hpp
deleted file mode 100644
index 4d80a460b..000000000
--- a/src/duckdb/src/include/duckdb/common/fixed_size_map.hpp
+++ /dev/null
@@ -1,272 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/fixed_size_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/perfect_map_set.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-
-namespace duckdb {
-
-template <class T, bool is_const>
-class fixed_size_map_iterator; // NOLINT: match stl case
-
-//! Alternative to perfect_map_t when min/max keys are integral, small, and known
-template <class T>
-class fixed_size_map_t { // NOLINT: match stl case
-	friend class fixed_size_map_iterator<T, false>;
-	friend class fixed_size_map_iterator<T, true>;
-
-public:
-	using key_type = idx_t;
-	using mapped_type = T;
-	using occupied_mask = TemplatedValidityMask<uint8_t>;
-	using iterator = fixed_size_map_iterator<mapped_type, false>;
-	using const_iterator = fixed_size_map_iterator<mapped_type, true>;
-
-public:
-	explicit fixed_size_map_t(idx_t capacity_p = 0) : capacity(capacity_p) {
-		resize(capacity);
-	}
-
-	idx_t size() const { // NOLINT: match stl case
-		return count;
-	}
-
-	void resize(idx_t capacity_p) { // NOLINT: match stl case
-		capacity = capacity_p;
-		occupied = occupied_mask(capacity);
-		values = make_unsafe_uniq_array_uninitialized<mapped_type>(capacity + 1);
-		clear();
-	}
-
-	void clear() { // NOLINT: match stl case
-		count = 0;
-		occupied.SetAllInvalid(capacity);
-	}
-
-	mapped_type &operator[](const key_type &key) {
-		D_ASSERT(key < capacity);
-		count += 1 - occupied.RowIsValidUnsafe(key);
-		occupied.SetValidUnsafe(key);
-		return values[key];
-	}
-
-	const mapped_type &operator[](const key_type &key) const {
-		D_ASSERT(key < capacity);
-		return values[key];
-	}
-
-	iterator begin() { // NOLINT: match stl case
-		iterator result(*this, 0);
-		if (!occupied_mask::RowIsValid(occupied.GetValidityEntryUnsafe(0), 0)) {
-			++result;
-		}
-		return result;
-	}
-
-	const_iterator begin() const { // NOLINT: match stl case
-		const_iterator result(*this, 0);
-		if (!occupied_mask::RowIsValid(occupied.GetValidityEntryUnsafe(0), 0)) {
-			++result;
-		}
-		return result;
-	}
-
-	iterator end() { // NOLINT: match stl case
-		return iterator(*this, capacity);
-	}
-
-	const_iterator end() const { // NOLINT: match stl case
-		return const_iterator(*this, capacity);
-	}
-
-	iterator find(const key_type &index) { // NOLINT: match stl case
-		return occupied.RowIsValidUnsafe(index) ? iterator(*this, index) : end();
-	}
-
-	const_iterator find(const key_type &index) const { // NOLINT: match stl case
-		return occupied.RowIsValidUnsafe(index) ? const_iterator(*this, index) : end();
-	}
-
-private:
-	idx_t capacity;
-	idx_t count;
-
-	occupied_mask occupied;
-	unsafe_unique_array<mapped_type> values;
-};
-
-template <class T, bool is_const>
-class fixed_size_map_iterator { // NOLINT: match stl case
-public:
-	using key_type = idx_t;
-	using mapped_type = T;
-	using fixed_size_map_type = fixed_size_map_t<mapped_type>;
-	using map_type = typename std::conditional<is_const, const fixed_size_map_type, fixed_size_map_type>::type;
-	using occupied_mask = typename fixed_size_map_t<mapped_type>::occupied_mask;
-
-public:
-	fixed_size_map_iterator(map_type &map_p, key_type index) : map(map_p) {
-		occupied_mask::GetEntryIndex(index, entry_idx, idx_in_entry);
-	}
-
-	fixed_size_map_iterator &operator++() {
-		// Prefix increment
-		if (++idx_in_entry == occupied_mask::BITS_PER_VALUE) {
-			NextEntry();
-		}
-		// Loop until we find an occupied index, or until the end
-		auto end = map.end();
-		while (*this < end) {
-			const auto &entry = map.occupied.GetValidityEntryUnsafe(entry_idx);
-			if (entry == static_cast<uint8_t>(~occupied_mask::ValidityBuffer::MAX_ENTRY)) {
-				// Entire entry is unoccupied, skip
-				if (entry_idx == end.entry_idx) {
-					// This is the last entry
-					idx_in_entry = end.idx_in_entry;
-					break;
-				}
-				NextEntry();
-			} else {
-				// One or more occupied in entry, loop over it
-				const auto idx_to = entry_idx == end.entry_idx ? end.idx_in_entry : occupied_mask::BITS_PER_VALUE;
-				for (; idx_in_entry < idx_to; idx_in_entry++) {
-					if (map.occupied.RowIsValid(entry, idx_in_entry)) {
-						// We found an occupied index
-						return *this;
-					}
-				}
-				// We did not find an occupied index
-				if (*this != end) {
-					NextEntry();
-				}
-			}
-		}
-		return *this;
-	}
-
-	fixed_size_map_iterator operator++(int) {
-		fixed_size_map_iterator tmp = *this;
-		++(*this);
-		return tmp;
-	}
-
-	key_type GetKey() const {
-		return entry_idx * occupied_mask::BITS_PER_VALUE + idx_in_entry;
-	}
-
-	mapped_type &GetValue() {
-		return map.values[GetKey()];
-	}
-
-	const mapped_type &GetValue() const {
-		return map.values[GetKey()];
-	}
-
-	friend bool operator==(const fixed_size_map_iterator &a, const fixed_size_map_iterator &b) {
-		return a.entry_idx == b.entry_idx && a.idx_in_entry == b.idx_in_entry;
-	}
-
-	friend bool operator!=(const fixed_size_map_iterator &a, const fixed_size_map_iterator &b) {
-		return !(a == b);
-	}
-
-	friend bool operator<(const fixed_size_map_iterator &a, const fixed_size_map_iterator &b) {
-		if (a.entry_idx < b.entry_idx) {
-			return true;
-		}
-		if (a.entry_idx == b.entry_idx) {
-			return a.idx_in_entry < b.idx_in_entry;
-		}
-		return false;
-	}
-
-private:
-	void NextEntry() {
-		entry_idx++;
-		idx_in_entry = 0;
-	}
-
-private:
-	map_type &map;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-};
-
-//! A helper functor so we can template functions to use either a perfect map or a fixed size map
-
-// LCOV_EXCL_START
-template <class T, bool fixed>
-struct TemplatedMapGetter {
-private:
-	using key_type = idx_t;
-	using mapped_type = T;
-	using fixed_size_map_type = fixed_size_map_t<mapped_type>;
-	using perfect_map_type = perfect_map_t<mapped_type>;
-	using map_type = typename std::conditional<fixed, fixed_size_map_type, perfect_map_type>::type;
-	using iterator = typename map_type::iterator;
-	using const_iterator = typename map_type::const_iterator;
-
-public:
-	static key_type GetKey(const iterator &it) {
-		return GetKeyInternal(it);
-	}
-
-	static key_type GetKey(const const_iterator &it) {
-		return GetKeyInternal(it);
-	}
-
-	static mapped_type &GetValue(iterator &it) {
-		return GetValueInternal(it);
-	}
-
-	static const mapped_type &GetValue(const const_iterator &it) {
-		return GetValueInternal(it);
-	}
-
-private:
-	// Down here we overload instead of templating to circumvent this error:
-	// "Explicit specialization of struct 'Functor<fixed>' in non-namespace scope"
-	// Alternatively, we could define these outside of TemplatedMapGetter
-	// However, then we no longer have access to the MAPPED_TYPE template and the code becomes unreadable
-	static key_type GetKeyInternal(const typename perfect_map_type::iterator &it) {
-		return it->first;
-	}
-
-	static key_type GetKeyInternal(const typename perfect_map_type::const_iterator &it) {
-		return it->first;
-	}
-
-	static mapped_type &GetValueInternal(typename perfect_map_type::iterator &it) {
-		return it->second;
-	}
-
-	static const mapped_type &GetValueInternal(const typename perfect_map_type::const_iterator &it) {
-		return it->second;
-	}
-
-	static key_type GetKeyInternal(const typename fixed_size_map_type::iterator &it) {
-		return it.GetKey();
-	}
-
-	static key_type GetKeyInternal(const typename fixed_size_map_type::const_iterator &it) {
-		return it.GetKey();
-	}
-
-	static mapped_type &GetValueInternal(typename fixed_size_map_type::iterator &it) {
-		return it.GetValue();
-	}
-
-	static const mapped_type &GetValueInternal(const typename fixed_size_map_type::const_iterator &it) {
-		return it.GetValue();
-	}
-};
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/fsst.hpp b/src/duckdb/src/include/duckdb/common/fsst.hpp
deleted file mode 100644
index 47398d270..000000000
--- a/src/duckdb/src/include/duckdb/common/fsst.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/fsst.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-class Value;
-class Vector;
-struct string_t;
-
-class FSSTPrimitives {
-public:
-	static string_t DecompressValue(void *duckdb_fsst_decoder, Vector &result, const char *compressed_string,
-	                                const idx_t compressed_string_len, vector<unsigned char> &decompress_buffer);
-	static string DecompressValue(void *duckdb_fsst_decoder, const char *compressed_string,
-	                              const idx_t compressed_string_len, vector<unsigned char> &decompress_buffer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/fstream.hpp b/src/duckdb/src/include/duckdb/common/fstream.hpp
deleted file mode 100644
index ff8660923..000000000
--- a/src/duckdb/src/include/duckdb/common/fstream.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/fstream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <fstream>
-#include <iosfwd>
-
-namespace duckdb {
-using std::endl;
-using std::fstream;
-using std::ifstream;
-using std::ios;
-using std::ios_base;
-using std::ofstream;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/gzip_file_system.hpp b/src/duckdb/src/include/duckdb/common/gzip_file_system.hpp
deleted file mode 100644
index 5a9f5f123..000000000
--- a/src/duckdb/src/include/duckdb/common/gzip_file_system.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/gzip_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/compressed_file_system.hpp"
-
-namespace duckdb {
-
-class GZipFileSystem : public CompressedFileSystem {
-	// 32 KB
-	static constexpr const idx_t BUFFER_SIZE = 1u << 15;
-
-public:
-	unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) override;
-
-	std::string GetName() const override {
-		return "GZipFileSystem";
-	}
-
-	//! Verifies that a buffer contains a valid GZIP header
-	static void VerifyGZIPHeader(uint8_t gzip_hdr[], idx_t read_count);
-	static bool CheckIsZip(const char *length, idx_t size);
-
-	//! Consumes a byte stream as a gzip string, returning the decompressed string
-	static string UncompressGZIPString(const string &in);
-	static string UncompressGZIPString(const char *length, idx_t size);
-
-	unique_ptr<StreamWrapper> CreateStream() override;
-	idx_t InBufferSize() override;
-	idx_t OutBufferSize() override;
-};
-
-static constexpr const uint8_t GZIP_COMPRESSION_DEFLATE = 0x08;
-
-static constexpr const uint8_t GZIP_FLAG_ASCII = 0x1;
-static constexpr const uint8_t GZIP_FLAG_MULTIPART = 0x2;
-static constexpr const uint8_t GZIP_FLAG_EXTRA = 0x4;
-static constexpr const uint8_t GZIP_FLAG_NAME = 0x8;
-static constexpr const uint8_t GZIP_FLAG_COMMENT = 0x10;
-static constexpr const uint8_t GZIP_FLAG_ENCRYPT = 0x20;
-
-static constexpr const uint8_t GZIP_HEADER_MINSIZE = 10;
-// MAXSIZE should be the same as input buffer size
-static constexpr const idx_t GZIP_HEADER_MAXSIZE = 1u << 15;
-static constexpr const uint8_t GZIP_FOOTER_SIZE = 8;
-
-static constexpr const unsigned char GZIP_FLAG_UNSUPPORTED =
-    GZIP_FLAG_ASCII | GZIP_FLAG_MULTIPART | GZIP_FLAG_COMMENT | GZIP_FLAG_ENCRYPT;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/helper.hpp b/src/duckdb/src/include/duckdb/common/helper.hpp
deleted file mode 100644
index 758207c8d..000000000
--- a/src/duckdb/src/include/duckdb/common/helper.hpp
+++ /dev/null
@@ -1,260 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include <string.h>
-#include <type_traits>
-
-#ifdef _MSC_VER
-#define suint64_t int64_t
-#endif
-
-#if defined(_WIN32) || defined(_WIN64)
-#define DUCKDB_WINDOWS
-#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
-#define DUCKDB_POSIX
-#endif
-
-namespace duckdb {
-
-// explicit fallthrough for switch_statementss
-#ifndef __has_cpp_attribute // For backwards compatibility
-#define __has_cpp_attribute(x) 0
-#endif
-#if __has_cpp_attribute(clang::fallthrough)
-#define DUCKDB_EXPLICIT_FALLTHROUGH [[clang::fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define DUCKDB_EXPLICIT_FALLTHROUGH [[gnu::fallthrough]]
-#else
-#define DUCKDB_EXPLICIT_FALLTHROUGH
-#endif
-
-template <class... T>
-struct AlwaysFalse {
-	static constexpr bool VALUE = false;
-};
-
-template<typename T>
-using reference = std::reference_wrapper<T>;
-
-template<class DATA_TYPE, bool SAFE = true>
-struct TemplatedUniqueIf
-{
-    typedef unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, SAFE> templated_unique_single_t;
-};
-
-template<class DATA_TYPE, size_t N>
-struct TemplatedUniqueIf<DATA_TYPE[N]>
-{
-    typedef void TemplatedUniqueArrayKnownBound; // NOLINT: mimic std style
-};
-
-template<class DATA_TYPE, class... ARGS>
-inline 
-typename TemplatedUniqueIf<DATA_TYPE, true>::templated_unique_single_t
-make_uniq(ARGS&&... args) // NOLINT: mimic std style
-{
-    return unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, true>(new DATA_TYPE(std::forward<ARGS>(args)...));
-}
-
-template<class DATA_TYPE, class... ARGS>
-inline 
-shared_ptr<DATA_TYPE>
-make_shared_ptr(ARGS&&... args) // NOLINT: mimic std style
-{
-	return shared_ptr<DATA_TYPE>(std::make_shared<DATA_TYPE>(std::forward<ARGS>(args)...));
-}
-
-template<class DATA_TYPE, class... ARGS>
-inline 
-typename TemplatedUniqueIf<DATA_TYPE, false>::templated_unique_single_t
-make_unsafe_uniq(ARGS&&... args) // NOLINT: mimic std style
-{
-    return unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, false>(new DATA_TYPE(std::forward<ARGS>(args)...));
-}
-
-template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>
-make_uniq_array(size_t n) // NOLINT: mimic std style
-{
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>(new DATA_TYPE[n]());
-}
-
-template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>
-make_uniq_array_uninitialized(size_t n) // NOLINT: mimic std style
-{
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>(new DATA_TYPE[n]);
-}
-
-template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>
-make_unsafe_uniq_array(size_t n) // NOLINT: mimic std style
-{
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>(new DATA_TYPE[n]());
-}
-
-template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>
-make_unsafe_uniq_array_uninitialized(size_t n) // NOLINT: mimic std style
-{
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>(new DATA_TYPE[n]);
-}
-
-template<class DATA_TYPE, class... ARGS>
-    typename TemplatedUniqueIf<DATA_TYPE>::TemplatedUniqueArrayKnownBound
-    make_uniq(ARGS&&...) = delete; // NOLINT: mimic std style
-
-
-template <typename S, typename T, typename... ARGS>
-unique_ptr<S> make_uniq_base(ARGS &&... args) { // NOLINT: mimic std style
-	return unique_ptr<S>(new T(std::forward<ARGS>(args)...));
-}
-
-#ifdef DUCKDB_ENABLE_DEPRECATED_API
-template <typename S, typename T, typename... Args>
-unique_ptr<S> make_unique_base(Args &&... args) {
-	return unique_ptr<S>(new T(std::forward<Args>(args)...));
-}
-#endif // DUCKDB_ENABLE_DEPRECATED_API
-
-template <typename SRC, typename TGT>
-unique_ptr<TGT> unique_ptr_cast(unique_ptr<SRC> src) { // NOLINT: mimic std style
-	return unique_ptr<TGT>(static_cast<TGT *>(src.release()));
-}
-
-template <typename SRC, typename TGT>
-shared_ptr<TGT> shared_ptr_cast(shared_ptr<SRC> src) { // NOLINT: mimic std style
-	return shared_ptr<TGT>(std::static_pointer_cast<TGT, SRC>(src.internal));
-}
-
-struct SharedConstructor {
-	template <class T, typename... ARGS>
-	static shared_ptr<T> Create(ARGS &&...args) {
-		return make_shared_ptr<T>(std::forward<ARGS>(args)...);
-	}
-};
-
-struct UniqueConstructor {
-	template <class T, typename... ARGS>
-	static unique_ptr<T> Create(ARGS &&...args) {
-		return make_uniq<T>(std::forward<ARGS>(args)...);
-	}
-};
-
-#ifdef DUCKDB_DEBUG_MOVE
-template<class T>
-typename std::remove_reference<T>::type&& move(T&& t) noexcept {
-	// the nonsensical sizeof check ensures this is never instantiated
-	static_assert(sizeof(T) == 0, "Use std::move instead of unqualified move or duckdb::move");
-}
-#endif
-
-template <class T, class... ARGS>
-static duckdb::unique_ptr<T> make_unique(ARGS&&... __args) { // NOLINT: mimic std style
-#ifndef DUCKDB_ENABLE_DEPRECATED_API
-	static_assert(sizeof(T) == 0, "Use make_uniq instead of make_unique!");
-#endif // DUCKDB_ENABLE_DEPRECATED_API
-	return unique_ptr<T>(new T(std::forward<ARGS>(__args)...));
-}
-
-template <class T, class... ARGS>
-static duckdb::shared_ptr<T> make_shared(ARGS&&... __args) { // NOLINT: mimic std style
-#ifndef DUCKDB_ENABLE_DEPRECATED_API
-	static_assert(sizeof(T) == 0, "Use make_shared_ptr instead of make_shared!");
-#endif // DUCKDB_ENABLE_DEPRECATED_API
-	return shared_ptr<T>(new T(std::forward<ARGS>(__args)...));
-}
-
-template <typename T>
-constexpr T MaxValue(T a, T b) {
-	return a > b ? a : b;
-}
-
-template <typename T>
-constexpr T MinValue(T a, T b) {
-	return a < b ? a : b;
-}
-
-template <typename T>
-T AbsValue(T a) {
-	return a < 0 ? -a : a;
-}
-
-//! Align value (ceiling)
-template<class T, T val=8>
-static inline T AlignValue(T n) {
-	return ((n + (val - 1)) / val) * val;
-}
-
-template<class T, T val=8>
-constexpr inline T AlignValueFloor(T n) {
-	return (n / val) * val;
-}
-
-template<class T, T val=8>
-static inline bool ValueIsAligned(T n) {
-	return (n % val) == 0;
-}
-
-template <typename T>
-T SignValue(T a) {
-	return a < 0 ? -1 : 1;
-}
-
-template <typename T>
-const T Load(const_data_ptr_t ptr) {
-	T ret;
-	memcpy(&ret, ptr, sizeof(ret)); // NOLINT
-	return ret;
-}
-
-template <typename T>
-void Store(const T &val, data_ptr_t ptr) {
-	memcpy(ptr, (void *)&val, sizeof(val)); // NOLINT
-}
-
-//! This assigns a shared pointer, but ONLY assigns if "target" is not equal to "source"
-//! If this is often the case, this manner of assignment is significantly faster (~20X faster)
-//! Since it avoids the need of an atomic incref/decref at the cost of a single pointer comparison
-//! Benchmark: https://gist.github.com/Mytherin/4db3faa8e233c4a9b874b21f62bb4b96
-//! If the shared pointers are not the same, the penalty is very low (on the order of 1%~ slower)
-//! This method should always be preferred if there is a (reasonable) chance that the pointers are the same
-template<class T>
-void AssignSharedPointer(shared_ptr<T> &target, const shared_ptr<T> &source) {
-	if (target.get() != source.get()) {
-		target = source;
-	}
-}
-
-template<typename T>
-using const_reference = std::reference_wrapper<const T>;
-
-//! Returns whether or not two reference wrappers refer to the same object
-template<class T>
-bool RefersToSameObject(const reference<T> &a, const reference<T> &b) {
-	return &a.get() == &b.get();
-}
-
-template<class T>
-bool RefersToSameObject(const T &a, const T &b) {
-	return &a == &b;
-}
-
-template<class T, class SRC>
-void DynamicCastCheck(const SRC *source) {
-#ifndef __APPLE__
-	// Actual check is on the fact that dynamic_cast and reinterpret_cast are equivalent
-	D_ASSERT(reinterpret_cast<const T *>(source) == dynamic_cast<const T *>(source));
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/hive_partitioning.hpp b/src/duckdb/src/include/duckdb/common/hive_partitioning.hpp
deleted file mode 100644
index bf3a5549d..000000000
--- a/src/duckdb/src/include/duckdb/common/hive_partitioning.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/hive_partitioning.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/optimizer/filter_combiner.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/table_filter.hpp"
-
-#include <iostream>
-#include <sstream>
-
-namespace duckdb {
-struct MultiFilePushdownInfo;
-
-struct HivePartitioningFilterInfo {
-	unordered_map<string, column_t> column_map;
-	bool hive_enabled;
-	bool filename_enabled;
-};
-
-class HivePartitioning {
-public:
-	//! Parse a filename that follows the hive partitioning scheme
-	DUCKDB_API static std::map<string, string> Parse(const string &filename);
-	//! Prunes a list of filenames based on a set of filters, can be used by TableFunctions in the
-	//! pushdown_complex_filter function to skip files with filename-based filters. Also removes the filters that always
-	//! evaluate to true.
-	DUCKDB_API static void ApplyFiltersToFileList(ClientContext &context, vector<string> &files,
-	                                              vector<unique_ptr<Expression>> &filters,
-	                                              const HivePartitioningFilterInfo &filter_info,
-	                                              MultiFilePushdownInfo &info);
-
-	DUCKDB_API static Value GetValue(ClientContext &context, const string &key, const string &value,
-	                                 const LogicalType &type);
-	//! Escape a hive partition key or value using URL encoding
-	DUCKDB_API static string Escape(const string &input);
-	//! Unescape a hive partition key or value encoded using URL encoding
-	DUCKDB_API static string Unescape(const string &input);
-};
-
-struct HivePartitionKey {
-	//! Columns by which we want to partition
-	vector<Value> values;
-	//! Precomputed hash of values
-	hash_t hash;
-
-	struct Hash {
-		std::size_t operator()(const HivePartitionKey &k) const {
-			return k.hash;
-		}
-	};
-
-	struct Equality {
-		bool operator()(const HivePartitionKey &a, const HivePartitionKey &b) const {
-			if (a.values.size() != b.values.size()) {
-				return false;
-			}
-			for (idx_t i = 0; i < a.values.size(); i++) {
-				if (!Value::NotDistinctFrom(a.values[i], b.values[i])) {
-					return false;
-				}
-			}
-			return true;
-		}
-	};
-};
-
-//! Maps hive partitions to partition_ids
-typedef unordered_map<HivePartitionKey, idx_t, HivePartitionKey::Hash, HivePartitionKey::Equality> hive_partition_map_t;
-
-//! class shared between HivePartitionColumnData classes that synchronizes partition discovery between threads.
-//! each HivePartitionedColumnData will hold a local copy of the key->partition map
-class GlobalHivePartitionState {
-public:
-	mutex lock;
-	hive_partition_map_t partition_map;
-};
-
-class HivePartitionedColumnData : public PartitionedColumnData {
-public:
-	HivePartitionedColumnData(ClientContext &context, vector<LogicalType> types, vector<idx_t> partition_by_cols,
-	                          shared_ptr<GlobalHivePartitionState> global_state = nullptr);
-	void ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) override;
-
-	//! Reverse lookup map to reconstruct keys from a partition id
-	std::map<idx_t, const HivePartitionKey *> GetReverseMap();
-
-protected:
-	//! Register a newly discovered partition
-	idx_t RegisterNewPartition(HivePartitionKey key, PartitionedColumnDataAppendState &state);
-	//! Add a new partition with the given partition id
-	void AddNewPartition(HivePartitionKey key, idx_t partition_id, PartitionedColumnDataAppendState &state);
-
-private:
-	void InitializeKeys();
-
-protected:
-	//! Shared HivePartitionedColumnData should always have a global state to allow parallel key discovery
-	shared_ptr<GlobalHivePartitionState> global_state;
-	//! Thread-local copy of the partition map
-	hive_partition_map_t local_partition_map;
-	//! The columns that make up the key
-	vector<idx_t> group_by_columns;
-	//! Thread-local pre-allocated vector for hashes
-	Vector hashes_v;
-	//! Thread-local pre-allocated HivePartitionKeys
-	vector<HivePartitionKey> keys;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/http_util.hpp b/src/duckdb/src/include/duckdb/common/http_util.hpp
deleted file mode 100644
index 766534c30..000000000
--- a/src/duckdb/src/include/duckdb/common/http_util.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/http_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-class HTTPUtil {
-public:
-	static void ParseHTTPProxyHost(string &proxy_value, string &hostname_out, idx_t &port_out, idx_t default_port = 80);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/hugeint.hpp b/src/duckdb/src/include/duckdb/common/hugeint.hpp
deleted file mode 100644
index c9b54bd95..000000000
--- a/src/duckdb/src/include/duckdb/common/hugeint.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#pragma once
-
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/string.hpp"
-#include <stdint.h>
-#include "duckdb/common/typedefs.hpp"
-
-namespace duckdb {
-
-// Forward declaration to allow conversion between hugeint and uhugeint
-struct uhugeint_t; // NOLINT: use numeric casing
-
-struct hugeint_t { // NOLINT: use numeric casing
-public:
-	uint64_t lower;
-	int64_t upper;
-
-public:
-	hugeint_t() = default;
-	DUCKDB_API hugeint_t(int64_t value); // NOLINT: Allow implicit conversion from `int64_t`
-	constexpr hugeint_t(int64_t upper, uint64_t lower) : lower(lower), upper(upper) {
-	}
-	constexpr hugeint_t(const hugeint_t &rhs) = default;
-	constexpr hugeint_t(hugeint_t &&rhs) = default;
-	hugeint_t &operator=(const hugeint_t &rhs) = default;
-	hugeint_t &operator=(hugeint_t &&rhs) = default;
-
-	DUCKDB_API string ToString() const;
-
-	// comparison operators
-	DUCKDB_API bool operator==(const hugeint_t &rhs) const;
-	DUCKDB_API bool operator!=(const hugeint_t &rhs) const;
-	DUCKDB_API bool operator<=(const hugeint_t &rhs) const;
-	DUCKDB_API bool operator<(const hugeint_t &rhs) const;
-	DUCKDB_API bool operator>(const hugeint_t &rhs) const;
-	DUCKDB_API bool operator>=(const hugeint_t &rhs) const;
-
-	// arithmetic operators
-	DUCKDB_API hugeint_t operator+(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator-(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator*(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator/(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator%(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator-() const;
-
-	// bitwise operators
-	DUCKDB_API hugeint_t operator>>(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator<<(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator&(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator|(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator^(const hugeint_t &rhs) const;
-	DUCKDB_API hugeint_t operator~() const;
-
-	// in-place operators
-	DUCKDB_API hugeint_t &operator+=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator-=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator*=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator/=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator%=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator>>=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator<<=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator&=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator|=(const hugeint_t &rhs);
-	DUCKDB_API hugeint_t &operator^=(const hugeint_t &rhs);
-
-	// boolean operators
-	DUCKDB_API explicit operator bool() const;
-	DUCKDB_API bool operator!() const;
-
-	// cast operators -- doesn't check bounds/overflow/underflow
-	DUCKDB_API explicit operator uint8_t() const;
-	DUCKDB_API explicit operator uint16_t() const;
-	DUCKDB_API explicit operator uint32_t() const;
-	DUCKDB_API explicit operator uint64_t() const;
-	DUCKDB_API explicit operator int8_t() const;
-	DUCKDB_API explicit operator int16_t() const;
-	DUCKDB_API explicit operator int32_t() const;
-	DUCKDB_API explicit operator int64_t() const;
-	DUCKDB_API operator uhugeint_t() const; // NOLINT: Allow implicit conversion from `hugeint_t`
-};
-
-} // namespace duckdb
-
-namespace std {
-template <>
-struct hash<duckdb::hugeint_t> {
-	size_t operator()(const duckdb::hugeint_t &val) const {
-		using std::hash;
-		return hash<int64_t> {}(val.upper) ^ hash<uint64_t> {}(val.lower);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/index_map.hpp b/src/duckdb/src/include/duckdb/common/index_map.hpp
deleted file mode 100644
index eb97fd3dd..000000000
--- a/src/duckdb/src/include/duckdb/common/index_map.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/index_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-struct LogicalIndexHashFunction {
-	uint64_t operator()(const LogicalIndex &index) const {
-		return std::hash<idx_t>()(index.index);
-	}
-};
-
-struct PhysicalIndexHashFunction {
-	uint64_t operator()(const PhysicalIndex &index) const {
-		return std::hash<idx_t>()(index.index);
-	}
-};
-
-template <typename T>
-using logical_index_map_t = unordered_map<LogicalIndex, T, LogicalIndexHashFunction>;
-
-using logical_index_set_t = unordered_set<LogicalIndex, LogicalIndexHashFunction>;
-
-template <typename T>
-using physical_index_map_t = unordered_map<PhysicalIndex, T, PhysicalIndexHashFunction>;
-
-using physical_index_set_t = unordered_set<PhysicalIndex, PhysicalIndexHashFunction>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/index_vector.hpp b/src/duckdb/src/include/duckdb/common/index_vector.hpp
deleted file mode 100644
index d63bf2ca8..000000000
--- a/src/duckdb/src/include/duckdb/common/index_vector.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/index_vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-template <class T, class INDEX_TYPE>
-class IndexVector {
-public:
-	void push_back(T element) { // NOLINT: match stl API
-		internal_vector.push_back(std::move(element));
-	}
-
-	T &operator[](INDEX_TYPE idx) {
-		return internal_vector[idx.index];
-	}
-
-	const T &operator[](INDEX_TYPE idx) const {
-		return internal_vector[idx.index];
-	}
-
-	idx_t size() const { // NOLINT: match stl API
-		return internal_vector.size();
-	}
-
-	bool empty() const { // NOLINT: match stl API
-		return internal_vector.empty();
-	}
-
-	void reserve(idx_t size) { // NOLINT: match stl API
-		internal_vector.reserve(size);
-	}
-
-	typename vector<T>::iterator begin() { // NOLINT: match stl API
-		return internal_vector.begin();
-	}
-	typename vector<T>::iterator end() { // NOLINT: match stl API
-		return internal_vector.end();
-	}
-	typename vector<T>::const_iterator cbegin() { // NOLINT: match stl API
-		return internal_vector.cbegin();
-	}
-	typename vector<T>::const_iterator cend() { // NOLINT: match stl API
-		return internal_vector.cend();
-	}
-	typename vector<T>::const_iterator begin() const { // NOLINT: match stl API
-		return internal_vector.begin();
-	}
-	typename vector<T>::const_iterator end() const { // NOLINT: match stl API
-		return internal_vector.end();
-	}
-
-	void Serialize(Serializer &serializer) const {
-		serializer.WriteProperty(100, "internal_vector", internal_vector);
-	}
-
-	static IndexVector<T, INDEX_TYPE> Deserialize(Deserializer &deserializer) {
-		IndexVector<T, INDEX_TYPE> result;
-		deserializer.ReadProperty(100, "internal_vector", result.internal_vector);
-		return result;
-	}
-
-private:
-	vector<T> internal_vector;
-};
-
-template <typename T>
-using physical_index_vector_t = IndexVector<T, PhysicalIndex>;
-
-template <typename T>
-using logical_index_vector_t = IndexVector<T, LogicalIndex>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/insertion_order_preserving_map.hpp b/src/duckdb/src/include/duckdb/common/insertion_order_preserving_map.hpp
deleted file mode 100644
index fe694f362..000000000
--- a/src/duckdb/src/include/duckdb/common/insertion_order_preserving_map.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/insertion_order_preserving_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-template <typename V>
-class InsertionOrderPreservingMap {
-public:
-	typedef vector<pair<string, V>> VECTOR_TYPE; // NOLINT: matching name of std
-	typedef string key_type;                     // NOLINT: matching name of std
-
-public:
-	InsertionOrderPreservingMap() {
-	}
-
-private:
-	VECTOR_TYPE map;
-	case_insensitive_map_t<idx_t> map_idx;
-
-public:
-	vector<string> Keys() const {
-		vector<string> keys;
-		keys.resize(this->size());
-		for (auto &kv : map_idx) {
-			keys[kv.second] = kv.first;
-		}
-
-		return keys;
-	}
-
-	typename VECTOR_TYPE::iterator begin() { // NOLINT: match stl API
-		return map.begin();
-	}
-
-	typename VECTOR_TYPE::iterator end() { // NOLINT: match stl API
-		return map.end();
-	}
-
-	typename VECTOR_TYPE::const_iterator begin() const { // NOLINT: match stl API
-		return map.begin();
-	}
-
-	typename VECTOR_TYPE::const_iterator end() const { // NOLINT: match stl API
-		return map.end();
-	}
-
-	typename VECTOR_TYPE::reverse_iterator rbegin() { // NOLINT: match stl API
-		return map.rbegin();
-	}
-
-	typename VECTOR_TYPE::reverse_iterator rend() { // NOLINT: match stl API
-		return map.rend();
-	}
-
-	typename VECTOR_TYPE::iterator find(const string &key) { // NOLINT: match stl API
-		auto entry = map_idx.find(key);
-		if (entry == map_idx.end()) {
-			return map.end();
-		}
-		return map.begin() + static_cast<typename VECTOR_TYPE::difference_type>(entry->second);
-	}
-
-	typename VECTOR_TYPE::const_iterator find(const string &key) const { // NOLINT: match stl API
-		auto entry = map_idx.find(key);
-		if (entry == map_idx.end()) {
-			return map.end();
-		}
-		return map.begin() + static_cast<typename VECTOR_TYPE::difference_type>(entry->second);
-	}
-
-	idx_t size() const { // NOLINT: match stl API
-		return map_idx.size();
-	}
-
-	bool empty() const { // NOLINT: match stl API
-		return map_idx.empty();
-	}
-
-	void resize(idx_t nz) { // NOLINT: match stl API
-		map.resize(nz);
-	}
-
-	void insert(const string &key, V &&value) { // NOLINT: match stl API
-		if (contains(key)) {
-			return;
-		}
-		map.emplace_back(key, std::move(value));
-		map_idx[key] = map.size() - 1;
-	}
-
-	void insert(const string &key, const V &value) { // NOLINT: match stl API
-		if (contains(key)) {
-			return;
-		}
-		map.emplace_back(key, value);
-		map_idx[key] = map.size() - 1;
-	}
-
-	void insert(pair<string, V> &&value) { // NOLINT: match stl API
-		auto &key = value.first;
-		if (contains(key)) {
-			return;
-		}
-		map_idx[key] = map.size();
-		map.push_back(std::move(value));
-	}
-
-	void erase(typename VECTOR_TYPE::iterator it) { // NOLINT: match stl API
-		auto key = it->first;
-		auto idx = map_idx[key];
-		map.erase(it);
-		map_idx.erase(key);
-		for (auto &kv : map_idx) {
-			if (kv.second > idx) {
-				kv.second--;
-			}
-		}
-	}
-
-	bool contains(const string &key) const { // NOLINT: match stl API
-		return map_idx.find(key) != map_idx.end();
-	}
-
-	const V &at(const string &key) const { // NOLINT: match stl API
-		return map[map_idx.at(key)].second;
-	}
-
-	V &operator[](const string &key) {
-		if (!contains(key)) {
-			auto v = V();
-			insert(key, std::move(v));
-		}
-		return map[map_idx[key]].second;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/likely.hpp b/src/duckdb/src/include/duckdb/common/likely.hpp
deleted file mode 100644
index aea5ccb60..000000000
--- a/src/duckdb/src/include/duckdb/common/likely.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/likely.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#if __GNUC__
-#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (__builtin_expect(cond, expected_value))
-#else
-#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (cond)
-#endif
-
-#define DUCKDB_LIKELY(...)   DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 1)
-#define DUCKDB_UNLIKELY(...) DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 0)
diff --git a/src/duckdb/src/include/duckdb/common/limits.hpp b/src/duckdb/src/include/duckdb/common/limits.hpp
deleted file mode 100644
index 0662579ef..000000000
--- a/src/duckdb/src/include/duckdb/common/limits.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/limits.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/types.hpp"
-
-#include <type_traits>
-
-// Undef annoying windows macro
-#undef max
-
-#include <limits>
-
-namespace duckdb {
-
-template <class T>
-struct NumericLimits {
-	static constexpr T Minimum() {
-		return std::numeric_limits<T>::lowest();
-	}
-	static constexpr T Maximum() {
-		return std::numeric_limits<T>::max();
-	}
-	static constexpr bool IsSigned() {
-		return std::is_signed<T>::value;
-	}
-	static constexpr bool IsIntegral() {
-		return std::is_integral<T>::value || std::is_enum<T>::value;
-	}
-	static constexpr idx_t Digits();
-};
-
-template <>
-struct NumericLimits<hugeint_t> {
-	static constexpr hugeint_t Minimum() {
-		return {std::numeric_limits<int64_t>::lowest(), 0};
-	};
-	static constexpr hugeint_t Maximum() {
-		return {std::numeric_limits<int64_t>::max(), std::numeric_limits<uint64_t>::max()};
-	};
-	static constexpr bool IsSigned() {
-		return true;
-	}
-	static constexpr bool IsIntegral() {
-		return true;
-	}
-	static constexpr idx_t Digits() {
-		return 39;
-	}
-};
-
-template <>
-struct NumericLimits<uhugeint_t> {
-	static constexpr uhugeint_t Minimum() {
-		return {0, 0};
-	};
-	static constexpr uhugeint_t Maximum() {
-		return {std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max()};
-	};
-	static constexpr bool IsSigned() {
-		return false;
-	}
-	static constexpr bool IsIntegral() {
-		return true;
-	}
-	static constexpr idx_t Digits() {
-		return 39;
-	}
-};
-
-template <>
-constexpr idx_t NumericLimits<int8_t>::Digits() {
-	return 3;
-}
-
-template <>
-constexpr idx_t NumericLimits<int16_t>::Digits() {
-	return 5;
-}
-
-template <>
-constexpr idx_t NumericLimits<int32_t>::Digits() {
-	return 10;
-}
-
-template <>
-constexpr idx_t NumericLimits<int64_t>::Digits() {
-	return 19;
-}
-
-template <>
-constexpr idx_t NumericLimits<uint8_t>::Digits() {
-	return 3;
-}
-
-template <>
-constexpr idx_t NumericLimits<uint16_t>::Digits() {
-	return 5;
-}
-
-template <>
-constexpr idx_t NumericLimits<uint32_t>::Digits() {
-	return 10;
-}
-
-template <>
-constexpr idx_t NumericLimits<uint64_t>::Digits() {
-	return 20;
-}
-
-template <>
-constexpr idx_t NumericLimits<float>::Digits() {
-	return 127;
-}
-
-template <>
-constexpr idx_t NumericLimits<double>::Digits() {
-	return 250;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/list.hpp b/src/duckdb/src/include/duckdb/common/list.hpp
deleted file mode 100644
index 21b208953..000000000
--- a/src/duckdb/src/include/duckdb/common/list.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <list>
-
-namespace duckdb {
-using std::list;
-}
diff --git a/src/duckdb/src/include/duckdb/common/local_file_system.hpp b/src/duckdb/src/include/duckdb/common/local_file_system.hpp
deleted file mode 100644
index c2d38152a..000000000
--- a/src/duckdb/src/include/duckdb/common/local_file_system.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/local_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-
-namespace duckdb {
-
-class LocalFileSystem : public FileSystem {
-public:
-	unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
-	                                optional_ptr<FileOpener> opener = nullptr) override;
-
-	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Read().
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-	//! Write exactly nr_bytes to the specified location in the file. Fails if nr_bytes could not be written. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Write().
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-	//! Read nr_bytes from the specified file into the buffer, moving the file pointer forward by nr_bytes. Returns the
-	//! amount of bytes read.
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	//! Excise a range of the file. The file-system is free to deallocate this
-	//! range (sparse file support). Reads to the range will succeed but will return
-	//! undefined data.
-	bool Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) override;
-
-	//! Returns the file size of a file handle, returns -1 on error
-	int64_t GetFileSize(FileHandle &handle) override;
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	time_t GetLastModifiedTime(FileHandle &handle) override;
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	FileType GetFileType(FileHandle &handle) override;
-	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
-	//! the file
-	void Truncate(FileHandle &handle, int64_t new_size) override;
-
-	//! Check if a directory exists
-	bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener = nullptr) override;
-	//! Create a directory if it does not exist
-	void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr) override;
-	//! Recursively remove a directory and all files in it
-	void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr) override;
-	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-	               FileOpener *opener = nullptr) override;
-	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
-	//! properties
-	void MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener = nullptr) override;
-	//! Check if a file exists
-	bool FileExists(const string &filename, optional_ptr<FileOpener> opener = nullptr) override;
-
-	//! Check if path is a pipe
-	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener = nullptr) override;
-	//! Remove a file from disk
-	void RemoveFile(const string &filename, optional_ptr<FileOpener> opener = nullptr) override;
-	//! Sync a file handle to disk
-	void FileSync(FileHandle &handle) override;
-
-	//! Runs a glob on the file system, returning a list of matching files
-	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override;
-
-	bool CanHandleFile(const string &fpath) override {
-		//! Whether or not a sub-system can handle a specific file path
-		return false;
-	}
-
-	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	void Seek(FileHandle &handle, idx_t location) override;
-	//! Return the current seek posiiton in the file.
-	idx_t SeekPosition(FileHandle &handle) override;
-
-	//! Whether or not we can seek into the file
-	bool CanSeek() override;
-	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
-	//! in a file on-disk are much cheaper than e.g. random reads in a file over the network
-	bool OnDiskFile(FileHandle &handle) override;
-
-	std::string GetName() const override {
-		return "LocalFileSystem";
-	}
-
-	//! Returns the last Win32 error, in string format. Returns an empty string if there is no error, or on non-Windows
-	//! systems.
-	static std::string GetLastErrorAsString();
-
-	//! Checks a file is private (checks for 600 on linux/macos, TODO: currently always returns true on windows)
-	static bool IsPrivateFile(const string &path_p, FileOpener *opener);
-
-	// returns a C-string of the path that trims any file:/ prefix
-	static const char *NormalizeLocalPath(const string &path);
-
-private:
-	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	void SetFilePointer(FileHandle &handle, idx_t location);
-	idx_t GetFilePointer(FileHandle &handle);
-
-	vector<string> FetchFileWithoutGlob(const string &path, FileOpener *opener, bool absolute_path);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/map.hpp b/src/duckdb/src/include/duckdb/common/map.hpp
deleted file mode 100644
index cdcfdcdf1..000000000
--- a/src/duckdb/src/include/duckdb/common/map.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <map>
-
-namespace duckdb {
-using std::map;
-using std::multimap;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/memory_safety.hpp b/src/duckdb/src/include/duckdb/common/memory_safety.hpp
deleted file mode 100644
index 8974dd56d..000000000
--- a/src/duckdb/src/include/duckdb/common/memory_safety.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-namespace duckdb {
-
-template <bool IS_ENABLED>
-struct MemorySafety {
-#ifdef DEBUG
-	// In DEBUG mode safety is always on
-	static constexpr bool ENABLED = true;
-#else
-	static constexpr bool ENABLED = IS_ENABLED;
-#endif
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/multi_file_list.hpp b/src/duckdb/src/include/duckdb/common/multi_file_list.hpp
deleted file mode 100644
index 5adc321cb..000000000
--- a/src/duckdb/src/include/duckdb/common/multi_file_list.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/multi_file_list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
-#include "duckdb/common/extra_operator_info.hpp"
-
-namespace duckdb {
-class MultiFileList;
-
-enum class FileExpandResult : uint8_t { NO_FILES, SINGLE_FILE, MULTIPLE_FILES };
-
-struct MultiFileListScanData {
-	idx_t current_file_idx = DConstants::INVALID_INDEX;
-};
-
-class MultiFileListIterationHelper {
-public:
-	DUCKDB_API explicit MultiFileListIterationHelper(MultiFileList &collection);
-
-private:
-	MultiFileList &file_list;
-
-private:
-	class MultiFileListIterator;
-
-	class MultiFileListIterator {
-	public:
-		DUCKDB_API explicit MultiFileListIterator(MultiFileList *file_list);
-
-		optional_ptr<MultiFileList> file_list;
-		MultiFileListScanData file_scan_data;
-		string current_file;
-
-	public:
-		DUCKDB_API void Next();
-
-		DUCKDB_API MultiFileListIterator &operator++();
-		DUCKDB_API bool operator!=(const MultiFileListIterator &other) const;
-		DUCKDB_API const string &operator*() const;
-	};
-
-public:
-	MultiFileListIterator begin(); // NOLINT: match stl API
-	MultiFileListIterator end();   // NOLINT: match stl API
-};
-
-struct MultiFilePushdownInfo {
-	explicit MultiFilePushdownInfo(LogicalGet &get);
-	MultiFilePushdownInfo(idx_t table_index, const vector<string> &column_names, const vector<column_t> &column_ids,
-	                      ExtraOperatorInfo &extra_info);
-
-	idx_t table_index;
-	const vector<string> &column_names;
-	vector<column_t> column_ids;
-	vector<ColumnIndex> column_indexes;
-	ExtraOperatorInfo &extra_info;
-};
-
-//! Abstract class for lazily generated list of file paths/globs
-//! NOTE: subclasses are responsible for ensuring thread-safety
-class MultiFileList {
-public:
-	explicit MultiFileList(vector<string> paths, FileGlobOptions options);
-	virtual ~MultiFileList();
-
-	//! Returns the raw, unexpanded paths, pre-filter
-	const vector<string> GetPaths() const;
-
-	//! Get Iterator over the files for pretty for loops
-	MultiFileListIterationHelper Files();
-
-	//! Initialize a sequential scan over a file list
-	void InitializeScan(MultiFileListScanData &iterator);
-	//! Scan the next file into result_file, returns false when out of files
-	bool Scan(MultiFileListScanData &iterator, string &result_file);
-
-	//! Returns the first file or an empty string if GetTotalFileCount() == 0
-	string GetFirstFile();
-	//! Syntactic sugar for GetExpandResult() == FileExpandResult::NO_FILES
-	bool IsEmpty();
-
-	//! Virtual functions for subclasses
-public:
-	virtual unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context,
-	                                                        const MultiFileReaderOptions &options,
-	                                                        MultiFilePushdownInfo &info,
-	                                                        vector<unique_ptr<Expression>> &filters);
-	virtual unique_ptr<MultiFileList>
-	DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options, const vector<string> &names,
-	                      const vector<LogicalType> &types, const vector<column_t> &column_ids,
-	                      TableFilterSet &filters) const;
-
-	virtual vector<string> GetAllFiles() = 0;
-	virtual FileExpandResult GetExpandResult() = 0;
-	virtual idx_t GetTotalFileCount() = 0;
-
-	virtual unique_ptr<NodeStatistics> GetCardinality(ClientContext &context);
-
-protected:
-	//! Get the i-th expanded file
-	virtual string GetFile(idx_t i) = 0;
-
-protected:
-	//! The unexpanded input paths
-	const vector<string> paths;
-	//! Whether paths can expand to 0 files
-	const FileGlobOptions glob_options;
-};
-
-//! MultiFileList that takes a list of files and produces the same list of paths. Useful for quickly wrapping
-//! existing vectors of paths in a MultiFileList without changing any code
-class SimpleMultiFileList : public MultiFileList {
-public:
-	//! Construct a SimpleMultiFileList from a list of already expanded files
-	explicit SimpleMultiFileList(vector<string> paths);
-	//! Copy `paths` to `filtered_files` and apply the filters
-	unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-	                                                MultiFilePushdownInfo &info,
-	                                                vector<unique_ptr<Expression>> &filters) override;
-	unique_ptr<MultiFileList> DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-	                                                const vector<string> &names, const vector<LogicalType> &types,
-	                                                const vector<column_t> &column_ids,
-	                                                TableFilterSet &filters) const override;
-
-	//! Main MultiFileList API
-	vector<string> GetAllFiles() override;
-	FileExpandResult GetExpandResult() override;
-	idx_t GetTotalFileCount() override;
-
-protected:
-	//! Main MultiFileList API
-	string GetFile(idx_t i) override;
-};
-
-//! MultiFileList that takes a list of paths and produces a list of files with all globs expanded
-class GlobMultiFileList : public MultiFileList {
-public:
-	GlobMultiFileList(ClientContext &context, vector<string> paths, FileGlobOptions options);
-	//! Calls ExpandAll, then prunes the expanded_files using the hive/filename filters
-	unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-	                                                MultiFilePushdownInfo &info,
-	                                                vector<unique_ptr<Expression>> &filters) override;
-	unique_ptr<MultiFileList> DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-	                                                const vector<string> &names, const vector<LogicalType> &types,
-	                                                const vector<column_t> &column_ids,
-	                                                TableFilterSet &filters) const override;
-
-	//! Main MultiFileList API
-	vector<string> GetAllFiles() override;
-	FileExpandResult GetExpandResult() override;
-	idx_t GetTotalFileCount() override;
-
-protected:
-	//! Main MultiFileList API
-	string GetFile(idx_t i) override;
-
-	//! Get the i-th expanded file
-	string GetFileInternal(idx_t i);
-	//! Grabs the next path and expands it into Expanded paths: returns false if no more files to expand
-	bool ExpandNextPath();
-	//! Grabs the next path and expands it into Expanded paths: returns false if no more files to expand
-	bool ExpandPathInternal(idx_t &current_path, vector<string> &result) const;
-	//! Whether all files have been expanded
-	bool IsFullyExpanded() const;
-
-	//! The ClientContext for globbing
-	ClientContext &context;
-	//! The current path to expand
-	idx_t current_path;
-	//! The expanded files
-	vector<string> expanded_files;
-
-	mutable mutex lock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp b/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp
deleted file mode 100644
index 364f8641c..000000000
--- a/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp
+++ /dev/null
@@ -1,316 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/multi_file_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/file_glob_options.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
-#include "duckdb/common/multi_file_list.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/union_by_name.hpp"
-
-namespace duckdb {
-class TableFunction;
-class TableFunctionSet;
-class TableFilterSet;
-class LogicalGet;
-class Expression;
-class ClientContext;
-class DataChunk;
-
-struct HivePartitioningIndex {
-	HivePartitioningIndex(string value, idx_t index);
-
-	string value;
-	idx_t index;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static HivePartitioningIndex Deserialize(Deserializer &deserializer);
-};
-
-//! The bind data for the multi-file reader, obtained through MultiFileReader::BindReader
-struct MultiFileReaderBindData {
-	//! The index of the filename column (if any)
-	idx_t filename_idx = DConstants::INVALID_INDEX;
-	//! The set of hive partitioning indexes (if any)
-	vector<HivePartitioningIndex> hive_partitioning_indexes;
-	//! The index of the file_row_number column (if any)
-	idx_t file_row_number_idx = DConstants::INVALID_INDEX;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static MultiFileReaderBindData Deserialize(Deserializer &deserializer);
-};
-
-//! Global state for MultiFileReads
-struct MultiFileReaderGlobalState {
-	MultiFileReaderGlobalState(vector<LogicalType> extra_columns_p, optional_ptr<const MultiFileList> file_list_p)
-	    : extra_columns(std::move(extra_columns_p)), file_list(file_list_p) {};
-	virtual ~MultiFileReaderGlobalState();
-
-	//! extra columns that will be produced during scanning
-	const vector<LogicalType> extra_columns;
-	// the file list driving the current scan
-	const optional_ptr<const MultiFileList> file_list;
-
-	//! Indicates that the MultiFileReader has added columns to be scanned that are not in the projection
-	bool RequiresExtraColumns() {
-		return !extra_columns.empty();
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct MultiFileFilterEntry {
-	idx_t index = DConstants::INVALID_INDEX;
-	bool is_constant = false;
-};
-
-struct MultiFileConstantEntry {
-	MultiFileConstantEntry(idx_t column_id, Value value_p) : column_id(column_id), value(std::move(value_p)) {
-	}
-	//! The column id to apply the constant value to
-	idx_t column_id;
-	//! The constant value
-	Value value;
-};
-
-struct MultiFileReaderData {
-	//! The column ids to read from the file
-	vector<idx_t> column_ids;
-	//! The column indexes to read from the file
-	vector<ColumnIndex> column_indexes;
-	//! The mapping of column id -> result column id
-	//! The result chunk will be filled as follows: chunk.data[column_mapping[i]] = ReadColumn(column_ids[i]);
-	vector<idx_t> column_mapping;
-	//! Whether or not there are no columns to read. This can happen when a file only consists of constants
-	bool empty_columns = false;
-	//! Filters can point to either (1) local columns in the file, or (2) constant values in the `constant_map`
-	//! This map specifies where the to-be-filtered value can be found
-	vector<MultiFileFilterEntry> filter_map;
-	//! The set of table filters
-	optional_ptr<TableFilterSet> filters;
-	//! The constants that should be applied at the various positions
-	vector<MultiFileConstantEntry> constant_map;
-	//! Map of column_id -> cast, used when reading multiple files when files have diverging types
-	//! for the same column
-	unordered_map<column_t, LogicalType> cast_map;
-	//! (Optionally) The MultiFileReader-generated metadata corresponding to the currently read file
-	optional_idx file_list_idx;
-};
-
-//! The MultiFileReader class provides a set of helper methods to handle scanning from multiple files
-struct MultiFileReader {
-	virtual ~MultiFileReader();
-
-	//! Create a MultiFileReader for a specific TableFunction, using its function name for errors
-	DUCKDB_API static unique_ptr<MultiFileReader> Create(const TableFunction &table_function);
-	//! Create a default MultiFileReader, function_name is used for errors
-	DUCKDB_API static unique_ptr<MultiFileReader> CreateDefault(const string &function_name = "");
-
-	//! Create a LIST Value from a vector of strings (list of file paths)
-	static Value CreateValueFromFileList(const vector<string> &files);
-
-	//! Add the parameters for multi-file readers (e.g. union_by_name, filename) to a table function
-	DUCKDB_API static void AddParameters(TableFunction &table_function);
-	//! Creates a table function set from a single reader function (including e.g. list parameters, etc)
-	DUCKDB_API static TableFunctionSet CreateFunctionSet(TableFunction table_function);
-
-	//! Parse a Value containing 1 or more paths into a vector of paths. Note: no expansion is performed here
-	DUCKDB_API virtual vector<string> ParsePaths(const Value &input);
-	//! Create a MultiFileList from a vector of paths. Any globs will be expanded using the default filesystem
-	DUCKDB_API virtual shared_ptr<MultiFileList>
-	CreateFileList(ClientContext &context, const vector<string> &paths,
-	               FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
-	//! Shorthand for ParsePaths + CreateFileList
-	DUCKDB_API shared_ptr<MultiFileList> CreateFileList(ClientContext &context, const Value &input,
-	                                                    FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
-
-	//! Parse the named parameters of a multi-file reader
-	DUCKDB_API virtual bool ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options,
-	                                    ClientContext &context);
-	//! Perform filter pushdown into the MultiFileList. Returns a new MultiFileList if filters were pushed down
-	DUCKDB_API virtual unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context, MultiFileList &files,
-	                                                                   const MultiFileReaderOptions &options,
-	                                                                   MultiFilePushdownInfo &info,
-	                                                                   vector<unique_ptr<Expression>> &filters);
-	DUCKDB_API virtual unique_ptr<MultiFileList>
-	DynamicFilterPushdown(ClientContext &context, const MultiFileList &files, const MultiFileReaderOptions &options,
-	                      const vector<string> &names, const vector<LogicalType> &types,
-	                      const vector<column_t> &column_ids, TableFilterSet &filters);
-	//! Try to use the MultiFileReader for binding. Returns true if a bind could be made, returns false if the
-	//! MultiFileReader can not perform the bind and binding should be performed on 1 or more files in the MultiFileList
-	//! directly.
-	DUCKDB_API virtual bool Bind(MultiFileReaderOptions &options, MultiFileList &files,
-	                             vector<LogicalType> &return_types, vector<string> &names,
-	                             MultiFileReaderBindData &bind_data);
-	//! Bind the options of the multi-file reader, potentially emitting any extra columns that are required
-	DUCKDB_API virtual void BindOptions(MultiFileReaderOptions &options, MultiFileList &files,
-	                                    vector<LogicalType> &return_types, vector<string> &names,
-	                                    MultiFileReaderBindData &bind_data);
-
-	//! Initialize global state used by the MultiFileReader
-	DUCKDB_API virtual unique_ptr<MultiFileReaderGlobalState>
-	InitializeGlobalState(ClientContext &context, const MultiFileReaderOptions &file_options,
-	                      const MultiFileReaderBindData &bind_data, const MultiFileList &file_list,
-	                      const vector<LogicalType> &global_types, const vector<string> &global_names,
-	                      const vector<ColumnIndex> &global_column_ids);
-
-	//! Finalize the bind phase of the multi-file reader after we know (1) the required (output) columns, and (2) the
-	//! pushed down table filters
-	DUCKDB_API virtual void FinalizeBind(const MultiFileReaderOptions &file_options,
-	                                     const MultiFileReaderBindData &options, const string &filename,
-	                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
-	                                     const vector<string> &global_names,
-	                                     const vector<ColumnIndex> &global_column_ids, MultiFileReaderData &reader_data,
-	                                     ClientContext &context, optional_ptr<MultiFileReaderGlobalState> global_state);
-
-	//! Create all required mappings from the global types/names to the file-local types/names
-	DUCKDB_API virtual void CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
-	                                      const vector<string> &local_names, const vector<LogicalType> &global_types,
-	                                      const vector<string> &global_names,
-	                                      const vector<ColumnIndex> &global_column_ids,
-	                                      optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
-	                                      const string &initial_file, const MultiFileReaderBindData &options,
-	                                      optional_ptr<MultiFileReaderGlobalState> global_state);
-	//! Populated the filter_map
-	DUCKDB_API virtual void CreateFilterMap(const vector<LogicalType> &global_types,
-	                                        optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
-	                                        optional_ptr<MultiFileReaderGlobalState> global_state);
-
-	//! Finalize the reading of a chunk - applying any constants that are required
-	DUCKDB_API virtual void FinalizeChunk(ClientContext &context, const MultiFileReaderBindData &bind_data,
-	                                      const MultiFileReaderData &reader_data, DataChunk &chunk,
-	                                      optional_ptr<MultiFileReaderGlobalState> global_state);
-
-	//! Fetch the partition data for the current chunk
-	DUCKDB_API virtual void GetPartitionData(ClientContext &context, const MultiFileReaderBindData &bind_data,
-	                                         const MultiFileReaderData &reader_data,
-	                                         optional_ptr<MultiFileReaderGlobalState> global_state,
-	                                         const OperatorPartitionInfo &partition_info,
-	                                         OperatorPartitionData &partition_data);
-
-	template <class READER_CLASS, class RESULT_CLASS, class OPTIONS_CLASS>
-	MultiFileReaderBindData BindUnionReader(ClientContext &context, vector<LogicalType> &return_types,
-	                                        vector<string> &names, MultiFileList &files, RESULT_CLASS &result,
-	                                        OPTIONS_CLASS &options) {
-		D_ASSERT(options.file_options.union_by_name);
-		vector<string> union_col_names;
-		vector<LogicalType> union_col_types;
-
-		// obtain the set of union column names + types by unifying the types of all of the files
-		// note that this requires opening readers for each file and reading the metadata of each file
-		// note also that it requires fully expanding the MultiFileList
-		auto materialized_file_list = files.GetAllFiles();
-		auto union_readers = UnionByName::UnionCols<READER_CLASS>(context, materialized_file_list, union_col_types,
-		                                                          union_col_names, options);
-
-		std::move(union_readers.begin(), union_readers.end(), std::back_inserter(result.union_readers));
-		// perform the binding on the obtained set of names + types
-		MultiFileReaderBindData bind_data;
-		BindOptions(options.file_options, files, union_col_types, union_col_names, bind_data);
-		names = union_col_names;
-		return_types = union_col_types;
-		result.Initialize(context, result.union_readers[0]);
-		D_ASSERT(names.size() == return_types.size());
-		return bind_data;
-	}
-
-	template <class READER_CLASS, class RESULT_CLASS, class OPTIONS_CLASS>
-	MultiFileReaderBindData BindReader(ClientContext &context, vector<LogicalType> &return_types, vector<string> &names,
-	                                   MultiFileList &files, RESULT_CLASS &result, OPTIONS_CLASS &options) {
-		if (options.file_options.union_by_name) {
-			return BindUnionReader<READER_CLASS>(context, return_types, names, files, result, options);
-		} else {
-			shared_ptr<READER_CLASS> reader;
-			reader = make_shared_ptr<READER_CLASS>(context, files.GetFirstFile(), options);
-			return_types = reader->return_types;
-			names = reader->names;
-			result.Initialize(std::move(reader));
-			MultiFileReaderBindData bind_data;
-			BindOptions(options.file_options, files, return_types, names, bind_data);
-			return bind_data;
-		}
-	}
-
-	template <class READER_CLASS>
-	void InitializeReader(READER_CLASS &reader, const MultiFileReaderOptions &options,
-	                      const MultiFileReaderBindData &bind_data, const vector<LogicalType> &global_types,
-	                      const vector<string> &global_names, const vector<ColumnIndex> &global_column_ids,
-	                      optional_ptr<TableFilterSet> table_filters, const string &initial_file,
-	                      ClientContext &context, optional_ptr<MultiFileReaderGlobalState> global_state) {
-		FinalizeBind(options, bind_data, reader.GetFileName(), reader.GetNames(), global_types, global_names,
-		             global_column_ids, reader.reader_data, context, global_state);
-		CreateMapping(reader.GetFileName(), reader.GetTypes(), reader.GetNames(), global_types, global_names,
-		              global_column_ids, table_filters, reader.reader_data, initial_file, bind_data, global_state);
-		reader.reader_data.filters = table_filters;
-	}
-
-	template <class BIND_DATA>
-	static void PruneReaders(BIND_DATA &data, MultiFileList &file_list) {
-		unordered_set<string> file_set;
-
-		// Avoid materializing the file list if there's nothing to prune
-		if (!data.initial_reader && data.union_readers.empty()) {
-			return;
-		}
-
-		for (const auto &file : file_list.Files()) {
-			file_set.insert(file);
-		}
-
-		if (data.initial_reader) {
-			// check if the initial reader should still be read
-			auto entry = file_set.find(data.initial_reader->GetFileName());
-			if (entry == file_set.end()) {
-				data.initial_reader.reset();
-			}
-		}
-		for (idx_t r = 0; r < data.union_readers.size(); r++) {
-			if (!data.union_readers[r]) {
-				data.union_readers.erase_at(r);
-				r--;
-				continue;
-			}
-			// check if the union reader should still be read or not
-			auto entry = file_set.find(data.union_readers[r]->GetFileName());
-			if (entry == file_set.end()) {
-				data.union_readers.erase_at(r);
-				r--;
-				continue;
-			}
-		}
-	}
-
-	//! Get partition info
-	DUCKDB_API virtual TablePartitionInfo GetPartitionInfo(ClientContext &context,
-	                                                       const MultiFileReaderBindData &bind_data,
-	                                                       TableFunctionPartitionInput &input);
-
-protected:
-	virtual void CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
-	                               const vector<string> &local_names, const vector<LogicalType> &global_types,
-	                               const vector<string> &global_names, const vector<ColumnIndex> &global_column_ids,
-	                               MultiFileReaderData &reader_data, const string &initial_file,
-	                               optional_ptr<MultiFileReaderGlobalState> global_state);
-
-	//! Used in errors to report which function is using this MultiFileReader
-	string function_name;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp b/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp
deleted file mode 100644
index 99a0297f4..000000000
--- a/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/multi_file_reader_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-struct BindInfo;
-class MultiFileList;
-
-struct MultiFileReaderOptions {
-	bool filename = false;
-	bool hive_partitioning = false;
-	bool auto_detect_hive_partitioning = true;
-	bool union_by_name = false;
-	bool hive_types_autocast = true;
-	case_insensitive_map_t<LogicalType> hive_types_schema;
-
-	// Default/configurable name of the column containing the file names
-	static constexpr const char *DEFAULT_FILENAME_COLUMN = "filename";
-	string filename_column = DEFAULT_FILENAME_COLUMN;
-	// These are used to pass options through custom multifilereaders
-	case_insensitive_map_t<Value> custom_options;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
-	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
-	DUCKDB_API void AutoDetectHivePartitioning(MultiFileList &files, ClientContext &context);
-	DUCKDB_API static bool AutoDetectHivePartitioningInternal(MultiFileList &files, ClientContext &context);
-	DUCKDB_API void AutoDetectHiveTypesInternal(MultiFileList &files, ClientContext &context);
-	DUCKDB_API void VerifyHiveTypesArePartitions(const std::map<string, string> &partitions) const;
-	DUCKDB_API LogicalType GetHiveLogicalType(const string &hive_partition_column) const;
-	DUCKDB_API Value GetHivePartitionValue(const string &base, const string &entry, ClientContext &context) const;
-	DUCKDB_API bool AnySet();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/mutex.hpp b/src/duckdb/src/include/duckdb/common/mutex.hpp
deleted file mode 100644
index 1758c0ffd..000000000
--- a/src/duckdb/src/include/duckdb/common/mutex.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/mutex.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#ifdef __MVS__
-#include <time.h>
-#endif
-#include <mutex>
-
-namespace duckdb {
-using std::lock_guard;
-using std::mutex;
-using std::unique_lock;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/named_parameter_map.hpp b/src/duckdb/src/include/duckdb/common/named_parameter_map.hpp
deleted file mode 100644
index b39e81e11..000000000
--- a/src/duckdb/src/include/duckdb/common/named_parameter_map.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/named_parameter_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/types.hpp"
-namespace duckdb {
-
-using named_parameter_type_map_t = case_insensitive_map_t<LogicalType>;
-using named_parameter_map_t = case_insensitive_map_t<Value>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/numeric_utils.hpp b/src/duckdb/src/include/duckdb/common/numeric_utils.hpp
deleted file mode 100644
index 813213dde..000000000
--- a/src/duckdb/src/include/duckdb/common/numeric_utils.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/numeric_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <type_traits>
-
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/limits.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct MakeSigned {
-	using type = typename std::make_signed<T>::type;
-};
-
-template <>
-struct MakeSigned<hugeint_t> {
-	using type = hugeint_t;
-};
-
-template <>
-struct MakeSigned<uhugeint_t> {
-	using type = hugeint_t;
-};
-
-template <class T>
-struct MakeUnsigned {
-	using type = typename std::make_unsigned<T>::type;
-};
-
-template <>
-struct MakeUnsigned<hugeint_t> {
-	using type = uhugeint_t;
-};
-
-template <>
-struct MakeUnsigned<uhugeint_t> {
-	using type = uhugeint_t;
-};
-
-template <class TO, class FROM>
-static void ThrowNumericCastError(FROM in, TO minval, TO maxval) {
-	throw InternalException("Information loss on integer cast: value %d outside of target range [%d, %d]", in, minval,
-	                        maxval);
-}
-
-template <class TO, class FROM, bool are_same_type>
-struct NumericCastImpl;
-
-template <class TO, class FROM>
-struct NumericCastImpl<TO, FROM, true> {
-	static TO Convert(FROM val) {
-		return static_cast<TO>(val);
-	}
-};
-
-template <class TO, class FROM>
-struct NumericCastImpl<TO, FROM, false> {
-	static TO Convert(FROM val) {
-		// some dance around signed-unsigned integer comparison below
-		auto minval = NumericLimits<TO>::Minimum();
-		auto maxval = NumericLimits<TO>::Maximum();
-		auto unsigned_in = static_cast<typename MakeUnsigned<FROM>::type>(val);
-		auto unsigned_min = static_cast<typename MakeUnsigned<TO>::type>(minval);
-		auto unsigned_max = static_cast<typename MakeUnsigned<TO>::type>(maxval);
-		auto signed_in = static_cast<typename MakeSigned<FROM>::type>(val);
-		auto signed_min = static_cast<typename MakeSigned<TO>::type>(minval);
-		auto signed_max = static_cast<typename MakeSigned<TO>::type>(maxval);
-
-		if (!NumericLimits<FROM>::IsSigned() && !NumericLimits<TO>::IsSigned() &&
-		    (unsigned_in < unsigned_min || unsigned_in > unsigned_max)) {
-			ThrowNumericCastError(val, minval, maxval);
-		}
-
-		if (NumericLimits<FROM>::IsSigned() && NumericLimits<TO>::IsSigned() &&
-		    (signed_in < signed_min || signed_in > signed_max)) {
-			ThrowNumericCastError(val, minval, maxval);
-		}
-
-		if (NumericLimits<FROM>::IsSigned() != NumericLimits<TO>::IsSigned() &&
-		    (signed_in < signed_min || unsigned_in > unsigned_max)) {
-			ThrowNumericCastError(val, minval, maxval);
-		}
-
-		return static_cast<TO>(val);
-	}
-};
-
-// NumericCast
-// When: between same types, or when both types are integral
-// Checks: perform checked casts on range
-template <class TO, class FROM,
-          class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) ||
-                                          std::is_same<TO, FROM>::value>::type>
-TO NumericCast(FROM val) {
-	return NumericCastImpl<TO, FROM, std::is_same<TO, FROM>::value>::Convert(val);
-}
-
-// UnsafeNumericCast
-// When: between same types, or when both types are integral
-// Checks: perform checked casts on range (in DEBUG) otherwise no checks
-template <class TO, class FROM,
-          class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) ||
-                                          std::is_same<TO, FROM>::value>::type>
-TO UnsafeNumericCast(FROM in) {
-#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
-	return NumericCast<TO, FROM>(in);
-#endif
-	return static_cast<TO>(in);
-}
-
-// LossyNumericCast
-// When: between double/float to other convertible types
-// Checks: no checks performed (at the moment, to be improved adding range checks)
-template <class TO, class FROM>
-TO LossyNumericCast(FROM val) {
-	return static_cast<TO>(val);
-}
-
-// ExactNumericCast
-// When: between double/float to other convertible types
-// Checks: perform checks that casts are invertible (in DEBUG) otherwise no checks
-
-template <class TO>
-TO ExactNumericCast(double val) {
-	auto res = LossyNumericCast<TO>(val);
-#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
-	if (val != double(res)) {
-		throw InternalException("Information loss on double cast: value %lf outside of target range [%lf, %lf]", val,
-		                        double(res), double(res));
-	}
-#endif
-	return res;
-}
-
-template <class TO>
-TO ExactNumericCast(float val) {
-	auto res = LossyNumericCast<TO>(val);
-#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
-	if (val != float(res)) {
-		throw InternalException("Information loss on float cast: value %f outside of target range [%f, %f]", val,
-		                        float(res), float(res));
-	}
-#endif
-	return res;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/opener_file_system.hpp b/src/duckdb/src/include/duckdb/common/opener_file_system.hpp
deleted file mode 100644
index 216f393d6..000000000
--- a/src/duckdb/src/include/duckdb/common/opener_file_system.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/opener_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-
-namespace duckdb {
-
-// The OpenerFileSystem is wrapper for a file system that pushes an appropriate FileOpener into the various API calls
-class OpenerFileSystem : public FileSystem {
-public:
-	virtual FileSystem &GetFileSystem() const = 0;
-	virtual optional_ptr<FileOpener> GetOpener() const = 0;
-
-	void VerifyNoOpener(optional_ptr<FileOpener> opener);
-	void VerifyCanAccessDirectory(const string &path);
-	void VerifyCanAccessFile(const string &path);
-
-	unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
-	                                optional_ptr<FileOpener> opener = nullptr) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessFile(path);
-		return GetFileSystem().OpenFile(path, flags, GetOpener());
-	}
-
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		GetFileSystem().Read(handle, buffer, nr_bytes, location);
-	};
-
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		GetFileSystem().Write(handle, buffer, nr_bytes, location);
-	}
-
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return GetFileSystem().Read(handle, buffer, nr_bytes);
-	}
-
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return GetFileSystem().Write(handle, buffer, nr_bytes);
-	}
-
-	int64_t GetFileSize(FileHandle &handle) override {
-		return GetFileSystem().GetFileSize(handle);
-	}
-	time_t GetLastModifiedTime(FileHandle &handle) override {
-		return GetFileSystem().GetLastModifiedTime(handle);
-	}
-	FileType GetFileType(FileHandle &handle) override {
-		return GetFileSystem().GetFileType(handle);
-	}
-
-	void Truncate(FileHandle &handle, int64_t new_size) override {
-		GetFileSystem().Truncate(handle, new_size);
-	}
-
-	void FileSync(FileHandle &handle) override {
-		GetFileSystem().FileSync(handle);
-	}
-
-	bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessDirectory(directory);
-		return GetFileSystem().DirectoryExists(directory, GetOpener());
-	}
-	void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessDirectory(directory);
-		return GetFileSystem().CreateDirectory(directory, GetOpener());
-	}
-
-	void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessDirectory(directory);
-		return GetFileSystem().RemoveDirectory(directory, GetOpener());
-	}
-
-	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-	               FileOpener *opener = nullptr) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessDirectory(directory);
-		return GetFileSystem().ListFiles(directory, callback, GetOpener().get());
-	}
-
-	void MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessFile(source);
-		VerifyCanAccessFile(target);
-		GetFileSystem().MoveFile(source, target, GetOpener());
-	}
-
-	string GetHomeDirectory() override {
-		return FileSystem::GetHomeDirectory(GetOpener());
-	}
-
-	string ExpandPath(const string &path) override {
-		return FileSystem::ExpandPath(path, GetOpener());
-	}
-
-	bool FileExists(const string &filename, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessFile(filename);
-		return GetFileSystem().FileExists(filename, GetOpener());
-	}
-
-	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		return GetFileSystem().IsPipe(filename, GetOpener());
-	}
-	void RemoveFile(const string &filename, optional_ptr<FileOpener> opener) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessFile(filename);
-		GetFileSystem().RemoveFile(filename, GetOpener());
-	}
-
-	string PathSeparator(const string &path) override {
-		return GetFileSystem().PathSeparator(path);
-	}
-
-	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
-		VerifyNoOpener(opener);
-		VerifyCanAccessFile(path);
-		return GetFileSystem().Glob(path, GetOpener().get());
-	}
-
-	std::string GetName() const override {
-		return "OpenerFileSystem - " + GetFileSystem().GetName();
-	}
-
-	void RegisterSubSystem(unique_ptr<FileSystem> sub_fs) override {
-		GetFileSystem().RegisterSubSystem(std::move(sub_fs));
-	}
-
-	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override {
-		GetFileSystem().RegisterSubSystem(compression_type, std::move(fs));
-	}
-
-	void UnregisterSubSystem(const string &name) override {
-		GetFileSystem().UnregisterSubSystem(name);
-	}
-
-	void SetDisabledFileSystems(const vector<string> &names) override {
-		GetFileSystem().SetDisabledFileSystems(names);
-	}
-
-	vector<string> ListSubSystems() override {
-		return GetFileSystem().ListSubSystems();
-	}
-
-private:
-	void VerifyCanAccessFileInternal(const string &path, FileType type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/abs.hpp b/src/duckdb/src/include/duckdb/common/operator/abs.hpp
deleted file mode 100644
index 7b4514ad7..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/abs.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/abs.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/limits.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-struct AbsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return input < 0 ? -input : input;
-	}
-};
-
-template <>
-inline float AbsOperator::Operation(float input) {
-	return std::fabs(input);
-}
-
-template <>
-inline double AbsOperator::Operation(double input) {
-	return std::fabs(input);
-}
-
-template <>
-inline hugeint_t AbsOperator::Operation(hugeint_t input) {
-	const hugeint_t zero(0);
-	return (input < zero) ? -input : input;
-}
-
-struct TryAbsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return AbsOperator::Operation<TA, TR>(input);
-	}
-};
-
-template <>
-inline int8_t TryAbsOperator::Operation(int8_t input) {
-	if (input == NumericLimits<int8_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return AbsOperator::Operation<int8_t, int8_t>(input);
-}
-
-template <>
-inline int16_t TryAbsOperator::Operation(int16_t input) {
-	if (input == NumericLimits<int16_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return AbsOperator::Operation<int16_t, int16_t>(input);
-}
-
-template <>
-inline int32_t TryAbsOperator::Operation(int32_t input) {
-	if (input == NumericLimits<int32_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return AbsOperator::Operation<int32_t, int32_t>(input);
-}
-
-template <>
-inline int64_t TryAbsOperator::Operation(int64_t input) {
-	if (input == NumericLimits<int64_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return AbsOperator::Operation<int64_t, int64_t>(input);
-}
-
-template <>
-inline hugeint_t TryAbsOperator::Operation(hugeint_t input) {
-	if (input == NumericLimits<hugeint_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%s)", input.ToString());
-	}
-	return AbsOperator::Operation<hugeint_t, hugeint_t>(input);
-}
-
-template <>
-inline dtime_t TryAbsOperator::Operation(dtime_t input) {
-	return dtime_t(TryAbsOperator::Operation<int64_t, int64_t>(input.micros));
-}
-
-template <>
-inline interval_t TryAbsOperator::Operation(interval_t input) {
-	return {TryAbsOperator::Operation<int32_t, int32_t>(input.months),
-	        TryAbsOperator::Operation<int32_t, int32_t>(input.days),
-	        TryAbsOperator::Operation<int64_t, int64_t>(input.micros)};
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/add.hpp b/src/duckdb/src/include/duckdb/common/operator/add.hpp
deleted file mode 100644
index 75d79a774..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/add.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/add.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/type_util.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-struct AddOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left + right;
-	}
-};
-
-template <>
-float AddOperator::Operation(float left, float right);
-template <>
-double AddOperator::Operation(double left, double right);
-template <>
-date_t AddOperator::Operation(date_t left, int32_t right);
-template <>
-date_t AddOperator::Operation(int32_t left, date_t right);
-template <>
-timestamp_t AddOperator::Operation(date_t left, dtime_t right);
-template <>
-timestamp_t AddOperator::Operation(dtime_t left, date_t right);
-template <>
-timestamp_t AddOperator::Operation(date_t left, dtime_tz_t right);
-template <>
-timestamp_t AddOperator::Operation(dtime_tz_t left, date_t right);
-template <>
-interval_t AddOperator::Operation(interval_t left, interval_t right);
-template <>
-timestamp_t AddOperator::Operation(date_t left, interval_t right);
-template <>
-timestamp_t AddOperator::Operation(interval_t left, date_t right);
-template <>
-timestamp_t AddOperator::Operation(timestamp_t left, interval_t right);
-template <>
-timestamp_t AddOperator::Operation(interval_t left, timestamp_t right);
-
-struct TryAddOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryAddOperator");
-	}
-};
-
-template <>
-bool TryAddOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TryAddOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TryAddOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TryAddOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-template <>
-bool TryAddOperator::Operation(date_t left, int32_t right, date_t &result);
-
-template <>
-bool TryAddOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TryAddOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryAddOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-DUCKDB_API bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryAddOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result);
-template <>
-bool TryAddOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct AddOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryAddOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in addition of %s (%s + %s)!", TypeIdToString(GetTypeId<TA>()),
-			                          NumericHelper::ToString(left), NumericHelper::ToString(right));
-		}
-		return result;
-	}
-};
-
-struct TryDecimalAdd {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalAdd");
-	}
-};
-
-template <>
-bool TryDecimalAdd::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalAdd::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalAdd::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalAdd::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalAddOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalAdd::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in addition of DECIMAL(18) (%d + %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalAddOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-struct AddTimeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right);
-};
-
-template <>
-dtime_t AddTimeOperator::Operation(dtime_t left, interval_t right);
-template <>
-dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right);
-
-template <>
-dtime_tz_t AddTimeOperator::Operation(dtime_tz_t left, interval_t right);
-template <>
-dtime_tz_t AddTimeOperator::Operation(interval_t left, dtime_tz_t right);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/aggregate_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/aggregate_operators.hpp
deleted file mode 100644
index 583d862d0..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/aggregate_operators.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/aggregate_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include "duckdb/common/operator/comparison_operators.hpp"
-
-namespace duckdb {
-
-struct Min {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return LessThan::Operation(left, right) ? left : right;
-	}
-};
-
-struct Max {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return GreaterThan::Operation(left, right) ? left : right;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp
deleted file mode 100644
index d86b29d9c..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp
+++ /dev/null
@@ -1,1005 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/cast_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/operator/convert_to_string.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/exception/conversion_exception.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-
-namespace duckdb {
-struct CastParameters;
-struct ValidityMask;
-class Vector;
-
-struct TryCast {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
-	}
-};
-
-struct TryCastErrorMessage {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, CastParameters &parameters) {
-		throw NotImplementedException(parameters.query_location, "Unimplemented type for cast (%s -> %s)",
-		                              GetTypeId<SRC>(), GetTypeId<DST>());
-	}
-};
-
-struct TryCastErrorMessageCommaSeparated {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, CastParameters &parameters) {
-		throw NotImplementedException(parameters.query_location, "Unimplemented type for cast (%s -> %s)",
-		                              GetTypeId<SRC>(), GetTypeId<DST>());
-	}
-};
-
-template <class SRC, class DST>
-static string CastExceptionText(SRC input) {
-	if (std::is_same<SRC, string_t>()) {
-		return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
-		       TypeIdToString(GetTypeId<DST>());
-	}
-	if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
-		return "Type " + TypeIdToString(GetTypeId<SRC>()) + " with value " + ConvertToString::Operation<SRC>(input) +
-		       " can't be cast because the value is out of range for the destination type " +
-		       TypeIdToString(GetTypeId<DST>());
-	}
-	return "Type " + TypeIdToString(GetTypeId<SRC>()) + " with value " + ConvertToString::Operation<SRC>(input) +
-	       " can't be cast to the destination type " + TypeIdToString(GetTypeId<DST>());
-}
-
-struct Cast {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		DST result;
-		if (!TryCast::Operation(input, result)) {
-			throw InvalidInputException(CastExceptionText<SRC, DST>(input));
-		}
-		return result;
-	}
-};
-
-struct HandleCastError {
-	static void AssignError(const string &error_message, CastParameters &parameters);
-	static void AssignError(const string &error_message, string *error_message_ptr,
-	                        optional_idx error_location = optional_idx()) {
-		if (!error_message_ptr) {
-			throw ConversionException(error_location, error_message);
-		}
-		if (error_message_ptr->empty()) {
-			*error_message_ptr = error_message;
-		}
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Cast bool -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast hugeint_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uhugeint_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uhugeint_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast float -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(float input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast double -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(double input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// String -> Numeric Casts
-//===--------------------------------------------------------------------===//
-static inline bool TryCastStringBool(const char *input_data, idx_t input_size, bool &result, bool strict) {
-	switch (input_size) {
-	case 1: {
-		unsigned char c = static_cast<uint8_t>(std::tolower(*input_data));
-		if (c == 't' || (!strict && c == 'y') || (!strict && c == '1')) {
-			result = true;
-			return true;
-		} else if (c == 'f' || (!strict && c == 'n') || (!strict && c == '0')) {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	case 2: {
-		unsigned char n = static_cast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char o = static_cast<uint8_t>(std::tolower(input_data[1]));
-		if (n == 'n' && o == 'o') {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	case 3: {
-		unsigned char y = static_cast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char e = static_cast<uint8_t>(std::tolower(input_data[1]));
-		unsigned char s = static_cast<uint8_t>(std::tolower(input_data[2]));
-		if (y == 'y' && e == 'e' && s == 's') {
-			result = true;
-			return true;
-		}
-		return false;
-	}
-	case 4: {
-		unsigned char t = static_cast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char r = static_cast<uint8_t>(std::tolower(input_data[1]));
-		unsigned char u = static_cast<uint8_t>(std::tolower(input_data[2]));
-		unsigned char e = static_cast<uint8_t>(std::tolower(input_data[3]));
-		if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
-			result = true;
-			return true;
-		}
-		return false;
-	}
-	case 5: {
-		unsigned char f = static_cast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char a = static_cast<uint8_t>(std::tolower(input_data[1]));
-		unsigned char l = static_cast<uint8_t>(std::tolower(input_data[2]));
-		unsigned char s = static_cast<uint8_t>(std::tolower(input_data[3]));
-		unsigned char e = static_cast<uint8_t>(std::tolower(input_data[4]));
-		if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	default:
-		return false;
-	}
-}
-
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uhugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, double &result, bool strict);
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, float &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, double &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result,
-                                                             CastParameters &parameters);
-
-//===--------------------------------------------------------------------===//
-// Date Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(date_t input, date_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(date_t input, timestamp_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Time Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(dtime_t input, dtime_tz_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Time With Time Zone Casts (Offset)
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(dtime_tz_t input, dtime_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(dtime_tz_t input, dtime_tz_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Timestamp Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, date_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, dtime_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, dtime_tz_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_sec_t input, timestamp_sec_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_sec_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_ms_t input, timestamp_ms_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_ms_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_ns_t input, timestamp_ns_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_ns_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_tz_t input, timestamp_tz_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_tz_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Interval Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(interval_t input, interval_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// String -> Date Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, date_t &result, bool strict);
-template <>
-date_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> Time Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, dtime_t &result, bool strict);
-template <>
-dtime_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> TimeTZ Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict);
-template <>
-dtime_tz_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> Timestamp Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters &parameters);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, timestamp_ns_t &result, bool strict);
-template <>
-timestamp_t Cast::Operation(string_t input);
-template <>
-timestamp_ns_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> Interval Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastParameters &parameters);
-
-//===--------------------------------------------------------------------===//
-// string -> Non-Standard Timestamps
-//===--------------------------------------------------------------------===//
-struct TryCastToTimestampNS {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw InternalException("Unsupported type for try cast to timestamp (ns)");
-	}
-};
-
-struct TryCastToTimestampMS {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw InternalException("Unsupported type for try cast to timestamp (ms)");
-	}
-};
-
-struct TryCastToTimestampSec {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw InternalException("Unsupported type for try cast to timestamp (s)");
-	}
-};
-
-template <>
-DUCKDB_API bool TryCastToTimestampNS::Operation(string_t input, timestamp_ns_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool strict);
-
-template <>
-DUCKDB_API bool TryCastToTimestampNS::Operation(date_t input, timestamp_ns_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Non-Standard Timestamps -> string/timestamp types
-//===--------------------------------------------------------------------===//
-
-struct CastFromTimestampNS {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to string could not be performed!");
-	}
-};
-
-struct CastFromTimestampMS {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to string could not be performed!");
-	}
-};
-
-struct CastFromTimestampSec {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to string could not be performed!");
-	}
-};
-
-struct CastTimestampUsToMs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampUsToNs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampUsToSec {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampMsToDate {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to DATE could not be performed!");
-	}
-};
-
-struct CastTimestampMsToTime {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to TIME could not be performed!");
-	}
-};
-
-struct CastTimestampMsToUs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampMsToNs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to TIMESTAMP_NS could not be performed!");
-	}
-};
-
-struct CastTimestampNsToDate {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to DATE could not be performed!");
-	}
-};
-struct CastTimestampNsToTime {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to TIME could not be performed!");
-	}
-};
-struct CastTimestampNsToUs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampSecToDate {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to DATE could not be performed!");
-	}
-};
-struct CastTimestampSecToTime {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to TIME could not be performed!");
-	}
-};
-struct CastTimestampSecToMs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to TIMESTAMP_MS could not be performed!");
-	}
-};
-
-struct CastTimestampSecToUs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampSecToNs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to TIMESTAMP_NS could not be performed!");
-	}
-};
-
-template <>
-duckdb::timestamp_t CastTimestampUsToSec::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampUsToMs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampUsToNs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::date_t CastTimestampMsToDate::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::dtime_t CastTimestampMsToTime::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampMsToUs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampMsToNs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::date_t CastTimestampNsToDate::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::dtime_t CastTimestampNsToTime::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampNsToUs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::date_t CastTimestampSecToDate::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::dtime_t CastTimestampSecToTime::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampSecToMs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampSecToUs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampSecToNs::Operation(duckdb::timestamp_t input);
-
-template <>
-duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_ns_t input, Vector &result);
-template <>
-duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result);
-template <>
-duckdb::string_t CastFromTimestampSec::Operation(duckdb::timestamp_t input, Vector &result);
-
-//===--------------------------------------------------------------------===//
-// Blobs
-//===--------------------------------------------------------------------===//
-struct CastFromBlob {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast from blob could not be performed!");
-	}
-};
-template <>
-duckdb::string_t CastFromBlob::Operation(duckdb::string_t input, Vector &vector);
-
-struct CastFromBlobToBit {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw NotImplementedException("Cast from blob could not be performed!");
-	}
-};
-template <>
-string_t CastFromBlobToBit::Operation(string_t input, Vector &result);
-
-struct TryCastToBlob {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
-		throw InternalException("Unsupported type for try cast to blob");
-	}
-};
-template <>
-bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters);
-
-//===--------------------------------------------------------------------===//
-// Bits
-//===--------------------------------------------------------------------===//
-struct CastFromBitToString {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast from bit could not be performed!");
-	}
-};
-template <>
-duckdb::string_t CastFromBitToString::Operation(duckdb::string_t input, Vector &vector);
-
-struct CastFromBitToNumeric {
-	template <class SRC = string_t, class DST>
-	static inline bool Operation(SRC input, DST &result, CastParameters &parameters) {
-		D_ASSERT(input.GetSize() > 1);
-
-		// TODO: Allow conversion if the significant bytes of the bitstring can be cast to the target type
-		// Currently only allows bitstring -> numeric if the full bitstring fits inside the numeric type
-		if (input.GetSize() - 1 > sizeof(DST)) {
-			throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s",
-			                          GetTypeId<DST>());
-		}
-		Bit::BitToNumeric(input, result);
-		return (true);
-	}
-};
-template <>
-bool CastFromBitToNumeric::Operation(string_t input, bool &result, CastParameters &parameters);
-template <>
-bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, CastParameters &parameters);
-template <>
-bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, CastParameters &parameters);
-
-struct CastFromBitToBlob {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		D_ASSERT(input.GetSize() > 1);
-		return StringVector::AddStringOrBlob(result, Bit::BitToBlob(input));
-	}
-};
-
-struct TryCastToBit {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
-		throw InternalException("Unsupported type for try cast to bit");
-	}
-};
-
-template <>
-bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters);
-
-//===--------------------------------------------------------------------===//
-// UUID
-//===--------------------------------------------------------------------===//
-struct CastFromUUID {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast from uuid could not be performed!");
-	}
-};
-template <>
-duckdb::string_t CastFromUUID::Operation(duckdb::hugeint_t input, Vector &vector);
-
-struct TryCastToUUID {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
-		throw InternalException("Unsupported type for try cast to uuid");
-	}
-};
-
-template <>
-DUCKDB_API bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector,
-                                         CastParameters &parameters);
-
-//===--------------------------------------------------------------------===//
-// Pointers
-//===--------------------------------------------------------------------===//
-struct CastFromPointer {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast from pointer could not be performed!");
-	}
-};
-template <>
-duckdb::string_t CastFromPointer::Operation(uintptr_t input, Vector &vector);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp
deleted file mode 100644
index f1a6f6eb3..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/comparison_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Comparison Operations
-//===--------------------------------------------------------------------===//
-struct Equals {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right) {
-		return left == right;
-	}
-};
-struct NotEquals {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right) {
-		return !Equals::Operation(left, right);
-	}
-};
-
-struct GreaterThan {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right) {
-		return left > right;
-	}
-};
-
-struct GreaterThanEquals {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right) {
-		return !GreaterThan::Operation(right, left);
-	}
-};
-
-struct LessThan {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right) {
-		return GreaterThan::Operation(right, left);
-	}
-};
-
-struct LessThanEquals {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right) {
-		return !GreaterThan::Operation(left, right);
-	}
-};
-
-template <>
-DUCKDB_API bool Equals::Operation(const float &left, const float &right);
-template <>
-DUCKDB_API bool Equals::Operation(const double &left, const double &right);
-
-template <>
-DUCKDB_API bool GreaterThan::Operation(const float &left, const float &right);
-template <>
-DUCKDB_API bool GreaterThan::Operation(const double &left, const double &right);
-
-template <>
-DUCKDB_API bool GreaterThanEquals::Operation(const float &left, const float &right);
-template <>
-DUCKDB_API bool GreaterThanEquals::Operation(const double &left, const double &right);
-
-// Distinct semantics are from Postgres record sorting. NULL = NULL and not-NULL < NULL
-// Deferring to the non-distinct operations removes the need for further specialisation.
-// TODO: To reverse the semantics, swap left_null and right_null for comparisons
-struct DistinctFrom {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		if (left_null || right_null) {
-			return left_null != right_null;
-		}
-		return NotEquals::Operation(left, right);
-	}
-};
-
-struct NotDistinctFrom {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return !DistinctFrom::Operation(left, right, left_null, right_null);
-	}
-};
-
-struct DistinctGreaterThan {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		if (left_null || right_null) {
-			return !right_null;
-		}
-		return GreaterThan::Operation(left, right);
-	}
-};
-
-struct DistinctGreaterThanNullsFirst {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return DistinctGreaterThan::Operation(left, right, right_null, left_null);
-	}
-};
-
-struct DistinctGreaterThanEquals {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return !DistinctGreaterThan::Operation(right, left, right_null, left_null);
-	}
-};
-
-struct DistinctLessThan {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return DistinctGreaterThan::Operation(right, left, right_null, left_null);
-	}
-};
-
-struct DistinctLessThanNullsFirst {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return DistinctGreaterThan::Operation(right, left, left_null, right_null);
-	}
-};
-
-struct DistinctLessThanEquals {
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return !DistinctGreaterThan::Operation(left, right, left_null, right_null);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Comparison Operator Wrappers (so (Not)DistinctFrom have the same API)
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct ComparisonOperationWrapper {
-	static constexpr const bool COMPARE_NULL = false;
-
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		if (right_null || left_null) {
-			return false;
-		}
-		return OP::template Operation<T>(left, right);
-	}
-};
-
-template <>
-struct ComparisonOperationWrapper<DistinctFrom> {
-	static constexpr const bool COMPARE_NULL = true;
-
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return DistinctFrom::template Operation<T>(left, right, left_null, right_null);
-	}
-};
-
-template <>
-struct ComparisonOperationWrapper<NotDistinctFrom> {
-	static constexpr const bool COMPARE_NULL = true;
-
-	template <class T>
-	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
-		return NotDistinctFrom::template Operation<T>(left, right, left_null, right_null);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Specialized Boolean Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool GreaterThan::Operation(const bool &left, const bool &right) {
-	return !right && left;
-}
-//===--------------------------------------------------------------------===//
-// Specialized String Comparison Operations
-//===--------------------------------------------------------------------===//
-template <>
-inline bool Equals::Operation(const string_t &left, const string_t &right) {
-	return left == right;
-}
-
-template <>
-inline bool GreaterThan::Operation(const string_t &left, const string_t &right) {
-	return left > right;
-}
-
-//===--------------------------------------------------------------------===//
-// Specialized Interval Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool Equals::Operation(const interval_t &left, const interval_t &right) {
-	return Interval::Equals(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(const interval_t &left, const interval_t &right) {
-	return Interval::GreaterThan(left, right);
-}
-
-//===--------------------------------------------------------------------===//
-// Specialized Hugeint Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool Equals::Operation(const hugeint_t &left, const hugeint_t &right) {
-	return Hugeint::Equals(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(const hugeint_t &left, const hugeint_t &right) {
-	return Hugeint::GreaterThan(left, right);
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/constant_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/constant_operators.hpp
deleted file mode 100644
index 7c975269b..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/constant_operators.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/constant_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-struct PickLeft {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return left;
-	}
-};
-
-struct PickRight {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return right;
-	}
-};
-
-struct NOP {
-	template <class T>
-	static inline T Operation(T left) {
-		return left;
-	}
-};
-
-struct ConstantZero {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return 0;
-	}
-};
-
-struct ConstantOne {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return 1;
-	}
-};
-
-struct AddOne {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return right + 1;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/convert_to_string.hpp b/src/duckdb/src/include/duckdb/common/operator/convert_to_string.hpp
deleted file mode 100644
index 89a54424f..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/convert_to_string.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/convert_to_string.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/type_util.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-struct ConvertToString {
-	template <class SRC>
-	static inline string Operation(SRC input) {
-		throw InternalException("Unrecognized type for ConvertToString %s", GetTypeId<SRC>());
-	}
-};
-
-template <>
-DUCKDB_API string ConvertToString::Operation(bool input);
-template <>
-DUCKDB_API string ConvertToString::Operation(int8_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(int16_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(int32_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(int64_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(uint8_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(uint16_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(uint32_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(uint64_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(hugeint_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(uhugeint_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(float input);
-template <>
-DUCKDB_API string ConvertToString::Operation(double input);
-template <>
-DUCKDB_API string ConvertToString::Operation(interval_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(date_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(dtime_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(timestamp_t input);
-template <>
-DUCKDB_API string ConvertToString::Operation(string_t input);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/decimal_cast_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/decimal_cast_operators.hpp
deleted file mode 100644
index b6f8c054e..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/decimal_cast_operators.hpp
+++ /dev/null
@@ -1,715 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/decimal_cast_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/operator/integer_cast_operator.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Decimal Casts
-//===--------------------------------------------------------------------===//
-struct TryCastToDecimal {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-		throw NotImplementedException("Unimplemented type for TryCastToDecimal!");
-	}
-};
-
-struct TryCastToDecimalCommaSeparated {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-		throw NotImplementedException("Unimplemented type for TryCastToDecimal!");
-	}
-};
-
-struct TryCastFromDecimal {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-		throw NotImplementedException("Unimplemented type for TryCastFromDecimal!");
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> bool
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int8_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int16_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int32_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int64_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> hugeint_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uhugeint_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint8_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint16_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint32_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint64_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> float
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, float &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> double
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, hugeint_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, double &result, CastParameters &parameters, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> VARCHAR
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int16_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int32_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int64_t &result, CastParameters &parameters, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, CastParameters &parameters,
-                                            uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, CastParameters &parameters,
-                                                          uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, CastParameters &parameters,
-                                                          uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, CastParameters &parameters,
-                                                          uint8_t width, uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, CastParameters &parameters,
-                                                          uint8_t width, uint8_t scale);
-
-struct StringCastFromDecimal {
-	template <class SRC>
-	static inline string_t Operation(SRC input, uint8_t width, uint8_t scale, Vector &result) {
-		throw NotImplementedException("Unimplemented type for string cast!");
-	}
-};
-
-template <>
-string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result);
-template <>
-string_t StringCastFromDecimal::Operation(int32_t input, uint8_t width, uint8_t scale, Vector &result);
-template <>
-string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t scale, Vector &result);
-template <>
-string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result);
-
-//===--------------------------------------------------------------------===//
-// Cast VARCHAR <-> Decimal
-//===--------------------------------------------------------------------===//
-enum class ExponentType : uint8_t { NONE, POSITIVE, NEGATIVE };
-
-template <typename T>
-struct DecimalCastTraits {
-	using POWERS_OF_TEN_CLASS = NumericHelper;
-};
-
-template <>
-struct DecimalCastTraits<hugeint_t> {
-	using POWERS_OF_TEN_CLASS = Hugeint;
-};
-
-template <>
-struct DecimalCastTraits<uhugeint_t> {
-	using POWERS_OF_TEN_CLASS = Uhugeint;
-};
-
-template <class T>
-struct DecimalCastData {
-	using StoreType = T;
-	StoreType result;
-	uint8_t width;
-	uint8_t scale;
-	uint8_t digit_count;
-	uint8_t decimal_count;
-	//! Whether we have determined if the result should be rounded
-	bool round_set;
-	//! If the result should be rounded
-	bool should_round;
-	//! Only set when ALLOW_EXPONENT is enabled
-	uint8_t excessive_decimals;
-	ExponentType exponent_type;
-	StoreType limit;
-};
-
-struct DecimalCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &state, uint8_t digit) {
-		if (state.result == 0 && digit == 0) {
-			// leading zero's don't count towards the digit count
-			return true;
-		}
-		if (state.digit_count == state.width - state.scale) {
-			// width of decimal type is exceeded!
-			return false;
-		}
-		state.digit_count++;
-		if (NEGATIVE) {
-			if (state.result < (NumericLimits<typename T::StoreType>::Minimum() / 10)) {
-				return false;
-			}
-			state.result = state.result * 10 - digit;
-		} else {
-			if (state.result > (NumericLimits<typename T::StoreType>::Maximum() / 10)) {
-				return false;
-			}
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleHexDigit(T &state, uint8_t digit) {
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleBinaryDigit(T &state, uint8_t digit) {
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static void RoundUpResult(T &state) {
-		if (NEGATIVE) {
-			state.result -= 1;
-		} else {
-			state.result += 1;
-		}
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int32_t exponent) {
-		auto decimal_excess = (state.decimal_count > state.scale) ? state.decimal_count - state.scale : 0;
-		if (exponent > 0) {
-			state.exponent_type = ExponentType::POSITIVE;
-			// Positive exponents need up to 'exponent' amount of digits
-			// Everything beyond that amount needs to be truncated
-			if (decimal_excess > exponent) {
-				// We've allowed too many decimals
-				state.excessive_decimals = UnsafeNumericCast<uint8_t>(decimal_excess - exponent);
-				exponent = 0;
-			} else {
-				exponent -= decimal_excess;
-			}
-			D_ASSERT(exponent >= 0);
-		} else if (exponent < 0) {
-			state.exponent_type = ExponentType::NEGATIVE;
-		}
-		if (!Finalize<T, NEGATIVE>(state)) {
-			return false;
-		}
-		if (exponent < 0) {
-			bool round_up = false;
-			for (idx_t i = 0; i < idx_t(-int64_t(exponent)); i++) {
-				auto mod = state.result % 10;
-				round_up = NEGATIVE ? mod <= -5 : mod >= 5;
-				state.result /= 10;
-				if (state.result == 0) {
-					break;
-				}
-			}
-			if (round_up) {
-				RoundUpResult<T, NEGATIVE>(state);
-			}
-			return true;
-		} else {
-			// positive exponent: append 0's
-			for (idx_t i = 0; i < idx_t(exponent); i++) {
-				if (!HandleDigit<T, NEGATIVE>(state, 0)) {
-					return false;
-				}
-			}
-			return true;
-		}
-	}
-
-	template <class T, bool NEGATIVE, bool ALLOW_EXPONENT>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		if (state.decimal_count == state.scale && !state.round_set) {
-			// Determine whether the last registered decimal should be rounded or not
-			state.round_set = true;
-			state.should_round = digit >= 5;
-		}
-		if (!ALLOW_EXPONENT && state.decimal_count == state.scale) {
-			// we exceeded the amount of supported decimals
-			// however, we don't throw an error here
-			// we just truncate the decimal
-			return true;
-		}
-		//! If we expect an exponent, we need to preserve the decimals
-		//! But we don't want to overflow, so we prevent overflowing the result with this check
-		if (state.digit_count + state.decimal_count >= DecimalWidth<decltype(state.result)>::max) {
-			return true;
-		}
-		state.decimal_count++;
-		if (NEGATIVE) {
-			state.result = state.result * 10 - digit;
-		} else {
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool TruncateExcessiveDecimals(T &state) {
-		D_ASSERT(state.excessive_decimals);
-		bool round_up = false;
-		for (idx_t i = 0; i < state.excessive_decimals; i++) {
-			auto mod = state.result % 10;
-			round_up = NEGATIVE ? mod <= -5 : mod >= 5;
-			state.result /= static_cast<typename T::StoreType>(10.0);
-		}
-		//! Only round up when exponents are involved
-		if (state.exponent_type == ExponentType::POSITIVE && round_up) {
-			RoundUpResult<T, NEGATIVE>(state);
-		}
-		D_ASSERT(state.decimal_count > state.scale);
-		state.decimal_count = state.scale;
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool Finalize(T &state) {
-		if (state.exponent_type != ExponentType::POSITIVE && state.decimal_count > state.scale) {
-			//! Did not encounter an exponent, but ALLOW_EXPONENT was on
-			state.excessive_decimals = state.decimal_count - state.scale;
-		}
-		if (state.excessive_decimals && !TruncateExcessiveDecimals<T, NEGATIVE>(state)) {
-			return false;
-		}
-		if (state.exponent_type == ExponentType::NONE && state.round_set && state.should_round) {
-			RoundUpResult<T, NEGATIVE>(state);
-		}
-		//  if we have not gotten exactly "scale" decimals, we need to multiply the result
-		//  e.g. if we have a string "1.0" that is cast to a DECIMAL(9,3), the value needs to be 1000
-		//  but we have only gotten the value "10" so far, so we multiply by 1000
-		for (uint8_t i = state.decimal_count; i < state.scale; i++) {
-			state.result *= 10;
-		}
-		if (NEGATIVE) {
-			return state.result > -state.limit;
-		} else {
-			return state.result < state.limit;
-		}
-	}
-};
-
-template <class T, char decimal_separator = '.'>
-bool TryDecimalStringCast(string_t input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<T, decimal_separator>(input.GetData(), input.GetSize(), result, parameters, width,
-	                                                  scale);
-}
-
-template <class T, char decimal_separator = '.'>
-bool TryDecimalStringCast(const char *string_ptr, idx_t string_size, T &result, CastParameters &parameters,
-                          uint8_t width, uint8_t scale) {
-	DecimalCastData<T> state;
-	state.result = 0;
-	state.width = width;
-	state.scale = scale;
-	state.digit_count = 0;
-	state.decimal_count = 0;
-	state.excessive_decimals = 0;
-	state.exponent_type = ExponentType::NONE;
-	state.round_set = false;
-	state.should_round = false;
-	state.limit = UnsafeNumericCast<T>(DecimalCastTraits<T>::POWERS_OF_TEN_CLASS::POWERS_OF_TEN[width]);
-	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
-	        string_ptr, string_size, state, false)) {
-		string_t value(string_ptr, (uint32_t)string_size);
-		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", value.GetString(),
-		                                  (int)width, (int)scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = state.result;
-	return true;
-}
-
-template <class T, char decimal_separator = '.'>
-bool TryDecimalStringCast(const char *string_ptr, idx_t string_size, T &result, uint8_t width, uint8_t scale) {
-	DecimalCastData<T> state;
-	state.result = 0;
-	state.width = width;
-	state.scale = scale;
-	state.digit_count = 0;
-	state.decimal_count = 0;
-	state.excessive_decimals = 0;
-	state.exponent_type = ExponentType::NONE;
-	state.round_set = false;
-	state.should_round = false;
-	state.limit = UnsafeNumericCast<T>(DecimalCastTraits<T>::POWERS_OF_TEN_CLASS::POWERS_OF_TEN[width]);
-	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
-	        string_ptr, string_size, state, false)) {
-		return false;
-	}
-	result = state.result;
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/double_cast_operator.hpp b/src/duckdb/src/include/duckdb/common/operator/double_cast_operator.hpp
deleted file mode 100644
index 733a95d44..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/double_cast_operator.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/double_cast_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "fast_float/fast_float.h"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-template <class T>
-static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict, char decimal_separator = '.') {
-	// skip any spaces at the start
-	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
-		buf++;
-		len--;
-	}
-	if (len == 0) {
-		return false;
-	}
-	if (*buf == '+') {
-		if (strict) {
-			// plus is not allowed in strict mode
-			return false;
-		}
-		buf++;
-		len--;
-	}
-	if (strict && len >= 2) {
-		if (buf[0] == '0' && StringUtil::CharacterIsDigit(buf[1])) {
-			// leading zeros are not allowed in strict mode
-			return false;
-		}
-	}
-	auto endptr = buf + len;
-	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result, strict, decimal_separator);
-	if (parse_result.ec != std::errc()) {
-		return false;
-	}
-	auto current_end = parse_result.ptr;
-	if (!strict) {
-		while (current_end < endptr && StringUtil::CharacterIsSpace(*current_end)) {
-			current_end++;
-		}
-	}
-	return current_end == endptr;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/integer_cast_operator.hpp b/src/duckdb/src/include/duckdb/common/operator/integer_cast_operator.hpp
deleted file mode 100644
index 8bf694c42..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/integer_cast_operator.hpp
+++ /dev/null
@@ -1,460 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/integer_cast_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-namespace duckdb {
-template <typename T>
-struct IntegerCastData {
-	using ResultType = T;
-	using StoreType = T;
-	ResultType result;
-};
-
-struct IntegerCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &state, uint8_t digit) {
-		using store_t = typename T::StoreType;
-		if (NEGATIVE) {
-			if (DUCKDB_UNLIKELY(state.result < (NumericLimits<store_t>::Minimum() + digit) / 10)) {
-				return false;
-			}
-			state.result = UnsafeNumericCast<store_t>(state.result * 10 - digit);
-		} else {
-			if (DUCKDB_UNLIKELY(state.result > (NumericLimits<store_t>::Maximum() - digit) / 10)) {
-				return false;
-			}
-			state.result = UnsafeNumericCast<store_t>(state.result * 10 + digit);
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleHexDigit(T &state, uint8_t digit) {
-		using store_t = typename T::StoreType;
-		if (DUCKDB_UNLIKELY(state.result > (NumericLimits<store_t>::Maximum() - digit) / 16)) {
-			return false;
-		}
-		state.result = UnsafeNumericCast<store_t>(state.result * 16 + digit);
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleBinaryDigit(T &state, uint8_t digit) {
-		using store_t = typename T::StoreType;
-		if (DUCKDB_UNLIKELY(state.result > (NumericLimits<store_t>::Maximum() - digit) / 2)) {
-			return false;
-		}
-		state.result = UnsafeNumericCast<store_t>(state.result * 2 + digit);
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int16_t exponent) {
-		// Simple integers don't deal with Exponents
-		return false;
-	}
-
-	template <class T, bool NEGATIVE, bool ALLOW_EXPONENT>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		// Simple integers don't deal with Decimals
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool Finalize(T &state) {
-		return true;
-	}
-};
-
-template <typename T>
-struct IntegerDecimalCastData {
-	using ResultType = T;
-	using StoreType = int64_t;
-	StoreType result;
-	StoreType decimal;
-	uint16_t decimal_digits;
-};
-
-template <>
-struct IntegerDecimalCastData<uint64_t> {
-	using ResultType = uint64_t;
-	using StoreType = uint64_t;
-	StoreType result;
-	StoreType decimal;
-	uint16_t decimal_digits;
-};
-
-struct IntegerDecimalCastOperation : IntegerCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int16_t exponent) {
-		using store_t = typename T::StoreType;
-
-		int16_t e = exponent;
-		// Negative Exponent
-		if (e < 0) {
-			while (state.result != 0 && e++ < 0) {
-				state.decimal = state.result % 10;
-				state.result /= 10;
-			}
-			if (state.decimal < 0) {
-				state.decimal = -state.decimal;
-			}
-			state.decimal_digits = 1;
-			return Finalize<T, NEGATIVE>(state);
-		}
-
-		// Positive Exponent
-		while (state.result != 0 && e-- > 0) {
-			if (!TryMultiplyOperator::Operation(state.result, (store_t)10, state.result)) {
-				return false;
-			}
-		}
-
-		if (state.decimal == 0) {
-			return Finalize<T, NEGATIVE>(state);
-		}
-
-		// Handle decimals
-		e = UnsafeNumericCast<int16_t>(exponent - state.decimal_digits);
-		store_t remainder = 0;
-		if (e < 0) {
-			if (static_cast<uint16_t>(-e) <= NumericLimits<store_t>::Digits()) {
-				store_t power = 1;
-				while (e++ < 0) {
-					power *= 10;
-				}
-				remainder = state.decimal % power;
-				state.decimal /= power;
-			} else {
-				state.decimal = 0;
-			}
-		} else {
-			while (e-- > 0) {
-				if (!TryMultiplyOperator::Operation(state.decimal, (store_t)10, state.decimal)) {
-					return false;
-				}
-			}
-		}
-
-		state.decimal_digits -= exponent;
-
-		if (NEGATIVE) {
-			if (!TrySubtractOperator::Operation(state.result, state.decimal, state.result)) {
-				return false;
-			}
-		} else if (!TryAddOperator::Operation(state.result, state.decimal, state.result)) {
-			return false;
-		}
-		state.decimal = remainder;
-		return Finalize<T, NEGATIVE>(state);
-	}
-
-	template <class T, bool NEGATIVE, bool ALLOW_EXPONENT>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		using store_t = typename T::StoreType;
-		if (DUCKDB_UNLIKELY(state.decimal > (NumericLimits<store_t>::Maximum() - digit) / 10)) {
-			// Simply ignore any more decimals
-			return true;
-		}
-		state.decimal_digits++;
-		state.decimal = state.decimal * 10 + digit;
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool Finalize(T &state) {
-		using result_t = typename T::ResultType;
-		using store_t = typename T::StoreType;
-
-		result_t tmp;
-		if (!TryCast::Operation<store_t, result_t>(state.result, tmp)) {
-			return false;
-		}
-
-		while (state.decimal > 10) {
-			state.decimal /= 10;
-			state.decimal_digits--;
-		}
-
-		bool success = true;
-		if (state.decimal_digits == 1 && state.decimal >= 5) {
-			if (NEGATIVE) {
-				success = TrySubtractOperator::Operation(tmp, (result_t)1, tmp);
-			} else {
-				success = TryAddOperator::Operation(tmp, (result_t)1, tmp);
-			}
-		}
-		state.result = tmp;
-		return success;
-	}
-};
-
-template <class T, bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation, char decimal_separator = '.'>
-static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict) {
-	idx_t start_pos;
-	if (NEGATIVE) {
-		start_pos = 1;
-	} else {
-		if (*buf == '+') {
-			if (strict) {
-				// leading plus is not allowed in strict mode
-				return false;
-			}
-			start_pos = 1;
-		} else {
-			start_pos = 0;
-		}
-	}
-	idx_t pos = start_pos;
-	while (pos < len) {
-		if (!StringUtil::CharacterIsDigit(buf[pos])) {
-			// not a digit!
-			if (buf[pos] == decimal_separator) {
-				if (strict) {
-					return false;
-				}
-				bool number_before_period = pos > start_pos;
-				// decimal point: we accept decimal values for integers as well
-				// we just truncate them
-				// make sure everything after the period is a number
-				pos++;
-				idx_t start_digit = pos;
-				while (pos < len) {
-					if (!StringUtil::CharacterIsDigit(buf[pos])) {
-						break;
-					}
-					if (!OP::template HandleDecimal<T, NEGATIVE, ALLOW_EXPONENT>(
-					        result, UnsafeNumericCast<uint8_t>(buf[pos] - '0'))) {
-						return false;
-					}
-					pos++;
-
-					if (pos != len && buf[pos] == '_') {
-						// Skip one underscore if it is not the last character and followed by a digit
-						pos++;
-						if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {
-							return false;
-						}
-					}
-				}
-				// make sure there is either (1) one number after the period, or (2) one number before the period
-				// i.e. we accept "1." and ".1" as valid numbers, but not "."
-				if (!(number_before_period || pos > start_digit)) {
-					return false;
-				}
-				if (pos >= len) {
-					break;
-				}
-			}
-			if (StringUtil::CharacterIsSpace(buf[pos])) {
-				// skip any trailing spaces
-				while (++pos < len) {
-					if (!StringUtil::CharacterIsSpace(buf[pos])) {
-						return false;
-					}
-				}
-				break;
-			}
-			if (ALLOW_EXPONENT) {
-				if (buf[pos] == 'e' || buf[pos] == 'E') {
-					if (strict) {
-						return false;
-					}
-					if (pos == start_pos) {
-						return false;
-					}
-					pos++;
-					if (pos >= len) {
-						return false;
-					}
-					using ExponentData = IntegerCastData<int16_t>;
-					ExponentData exponent {};
-					int negative = buf[pos] == '-';
-					if (negative) {
-						if (!IntegerCastLoop<ExponentData, true, false, IntegerCastOperation, decimal_separator>(
-						        buf + pos, len - pos, exponent, strict)) {
-							return false;
-						}
-					} else {
-						if (!IntegerCastLoop<ExponentData, false, false, IntegerCastOperation, decimal_separator>(
-						        buf + pos, len - pos, exponent, strict)) {
-							return false;
-						}
-					}
-					return OP::template HandleExponent<T, NEGATIVE>(result, exponent.result);
-				}
-			}
-			return false;
-		}
-		auto digit = UnsafeNumericCast<uint8_t>(buf[pos++] - '0');
-		if (!OP::template HandleDigit<T, NEGATIVE>(result, digit)) {
-			return false;
-		}
-
-		if (pos != len && buf[pos] == '_' && !strict) {
-			// Skip one underscore if it is not the last character and followed by a digit
-			pos++;
-			if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {
-				return false;
-			}
-		}
-	}
-	if (!OP::template Finalize<T, NEGATIVE>(result)) {
-		return false;
-	}
-	return pos > start_pos;
-}
-
-template <class T, bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>
-static bool IntegerHexCastLoop(const char *buf, idx_t len, T &result, bool strict) {
-	if (ALLOW_EXPONENT || NEGATIVE) {
-		return false;
-	}
-	idx_t start_pos = 1;
-	idx_t pos = start_pos;
-	char current_char;
-	while (pos < len) {
-		current_char = StringUtil::CharacterToLower(buf[pos]);
-		if (!StringUtil::CharacterIsHex(current_char)) {
-			return false;
-		}
-		uint8_t digit;
-		if (current_char >= 'a') {
-			digit = UnsafeNumericCast<uint8_t>(current_char - 'a' + 10);
-		} else {
-			digit = UnsafeNumericCast<uint8_t>(current_char - '0');
-		}
-		pos++;
-
-		if (pos != len && buf[pos] == '_') {
-			// Skip one underscore if it is not the last character and followed by a hex
-			pos++;
-			if (pos == len || !StringUtil::CharacterIsHex(buf[pos])) {
-				return false;
-			}
-		}
-
-		if (!OP::template HandleHexDigit<T, NEGATIVE>(result, digit)) {
-			return false;
-		}
-	}
-	if (!OP::template Finalize<T, NEGATIVE>(result)) {
-		return false;
-	}
-	return pos > start_pos;
-}
-
-template <class T, bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>
-static bool IntegerBinaryCastLoop(const char *buf, idx_t len, T &result, bool strict) {
-	if (ALLOW_EXPONENT || NEGATIVE) {
-		return false;
-	}
-	idx_t start_pos = 1;
-	idx_t pos = start_pos;
-	uint8_t digit;
-	char current_char;
-	while (pos < len) {
-		current_char = buf[pos];
-		if (current_char == '0') {
-			digit = 0;
-		} else if (current_char == '1') {
-			digit = 1;
-		} else {
-			return false;
-		}
-		pos++;
-		if (pos != len && buf[pos] == '_') {
-			// Skip one underscore if it is not the last character and followed by a digit
-			pos++;
-			if (pos == len || (buf[pos] != '0' && buf[pos] != '1')) {
-				return false;
-			}
-		}
-
-		if (!OP::template HandleBinaryDigit<T, NEGATIVE>(result, digit)) {
-			return false;
-		}
-	}
-	if (!OP::template Finalize<T, NEGATIVE>(result)) {
-		return false;
-	}
-	return pos > start_pos;
-}
-
-template <class T, bool IS_SIGNED = true, bool ALLOW_EXPONENT = true, class OP = IntegerCastOperation,
-          bool ZERO_INITIALIZE = true, char decimal_separator = '.'>
-static bool TryIntegerCast(const char *buf, idx_t len, T &result, bool strict) {
-	// skip any spaces at the start
-	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
-		buf++;
-		len--;
-	}
-	if (len == 0) {
-		return false;
-	}
-	if (ZERO_INITIALIZE) {
-		memset(&result, 0, sizeof(T));
-	}
-	// if the number is negative, we set the negative flag and skip the negative sign
-	if (*buf == '-') {
-		if (!IS_SIGNED) {
-			// Need to check if its not -0
-			idx_t pos = 1;
-			while (pos < len) {
-				if (buf[pos++] != '0') {
-					return false;
-				}
-			}
-		}
-		return IntegerCastLoop<T, true, ALLOW_EXPONENT, OP, decimal_separator>(buf, len, result, strict);
-	}
-	if (len > 1 && *buf == '0') {
-		if (buf[1] == 'x' || buf[1] == 'X') {
-			// If it starts with 0x or 0X, we parse it as a hex value
-			buf++;
-			len--;
-			return IntegerHexCastLoop<T, false, false, OP>(buf, len, result, strict);
-		} else if (buf[1] == 'b' || buf[1] == 'B') {
-			// If it starts with 0b or 0B, we parse it as a binary value
-			buf++;
-			len--;
-			return IntegerBinaryCastLoop<T, false, false, OP>(buf, len, result, strict);
-		} else if (strict && StringUtil::CharacterIsDigit(buf[1])) {
-			// leading zeros are not allowed in strict mode
-			return false;
-		}
-	}
-	return IntegerCastLoop<T, false, ALLOW_EXPONENT, OP, decimal_separator>(buf, len, result, strict);
-}
-
-template <typename T, bool IS_SIGNED = true>
-static inline bool TrySimpleIntegerCast(const char *buf, idx_t len, T &result, bool strict) {
-	IntegerCastData<T> simple_data;
-	if (TryIntegerCast<IntegerCastData<T>, IS_SIGNED, false, IntegerCastOperation>(buf, len, simple_data, strict)) {
-		result = (T)simple_data.result;
-		return true;
-	}
-
-	// Simple integer cast failed, try again with decimals/exponents included
-	// FIXME: This could definitely be improved as some extra work is being done here. It is more important that
-	//  "normal" integers (without exponent/decimals) are still being parsed quickly.
-	IntegerDecimalCastData<T> cast_data;
-	if (TryIntegerCast<IntegerDecimalCastData<T>, IS_SIGNED, true, IntegerDecimalCastOperation>(buf, len, cast_data,
-	                                                                                            strict)) {
-		result = (T)cast_data.result;
-		return true;
-	}
-	return false;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/multiply.hpp b/src/duckdb/src/include/duckdb/common/operator/multiply.hpp
deleted file mode 100644
index 0fad42bd5..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/multiply.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/multiply.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/type_util.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-struct interval_t;
-
-struct MultiplyOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left * right;
-	}
-};
-
-template <>
-float MultiplyOperator::Operation(float left, float right);
-template <>
-double MultiplyOperator::Operation(double left, double right);
-template <>
-interval_t MultiplyOperator::Operation(interval_t left, int64_t right);
-template <>
-interval_t MultiplyOperator::Operation(int64_t left, interval_t right);
-
-struct TryMultiplyOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryMultiplyOperator");
-	}
-};
-
-template <>
-bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TryMultiplyOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TryMultiplyOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-DUCKDB_API bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-DUCKDB_API bool TryMultiplyOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-template <>
-DUCKDB_API bool TryMultiplyOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result);
-
-struct MultiplyOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryMultiplyOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in multiplication of %s (%s * %s)!", TypeIdToString(GetTypeId<TA>()),
-			                          NumericHelper::ToString(left), NumericHelper::ToString(right));
-		}
-		return result;
-	}
-};
-
-struct TryDecimalMultiply {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalMultiply");
-	}
-};
-
-template <>
-bool TryDecimalMultiply::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalMultiply::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalMultiplyOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalMultiply::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in multiplication of DECIMAL(18) (%d * %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/numeric_binary_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/numeric_binary_operators.hpp
deleted file mode 100644
index c85cd4f7f..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/numeric_binary_operators.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/numeric_binary_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-struct DivideOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		D_ASSERT(right != 0); // this should be checked before!
-		return left / right;
-	}
-};
-
-struct ModuloOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		D_ASSERT(right != 0);
-		return left % right;
-	}
-};
-
-template <>
-float DivideOperator::Operation(float left, float right);
-template <>
-double DivideOperator::Operation(double left, double right);
-template <>
-hugeint_t DivideOperator::Operation(hugeint_t left, hugeint_t right);
-template <>
-interval_t DivideOperator::Operation(interval_t left, int64_t right);
-
-template <>
-float ModuloOperator::Operation(float left, float right);
-template <>
-double ModuloOperator::Operation(double left, double right);
-template <>
-hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/numeric_cast.hpp b/src/duckdb/src/include/duckdb/common/operator/numeric_cast.hpp
deleted file mode 100644
index 939b570ec..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/numeric_cast.hpp
+++ /dev/null
@@ -1,613 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/numeric_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-//! Note: this should not be included directly, when these methods are required
-//! They should be used through the TryCast:: methods defined in 'cast_operators.hpp'
-//! This file produces 'unused static method' warnings/errors when included
-
-template <class SRC, class DST>
-static bool TryCastWithOverflowCheck(SRC value, DST &result) {
-	if (!Value::IsFinite<SRC>(value)) {
-		return false;
-	}
-	if (NumericLimits<SRC>::IsSigned() != NumericLimits<DST>::IsSigned()) {
-		if (NumericLimits<SRC>::IsSigned()) {
-			// signed to unsigned conversion
-			if (NumericLimits<SRC>::Digits() > NumericLimits<DST>::Digits()) {
-				if (value < 0 || value > (SRC)NumericLimits<DST>::Maximum()) {
-					return false;
-				}
-			} else {
-				if (value < 0) {
-					return false;
-				}
-			}
-			result = (DST)value;
-			return true;
-		} else {
-			// unsigned to signed conversion
-			if (NumericLimits<SRC>::Digits() >= NumericLimits<DST>::Digits()) {
-				if (value <= (SRC)NumericLimits<DST>::Maximum()) {
-					result = (DST)value;
-					return true;
-				}
-				return false;
-			} else {
-				result = (DST)value;
-				return true;
-			}
-		}
-	} else {
-		// same sign conversion
-		if (NumericLimits<DST>::Digits() >= NumericLimits<SRC>::Digits()) {
-			result = (DST)value;
-			return true;
-		} else {
-			if (value < SRC(NumericLimits<DST>::Minimum()) || value > SRC(NumericLimits<DST>::Maximum())) {
-				return false;
-			}
-			result = (DST)value;
-			return true;
-		}
-	}
-}
-
-template <class SRC, class T>
-bool TryCastWithOverflowCheckFloat(SRC value, T &result, SRC min, SRC max) {
-	if (!Value::IsFinite<SRC>(value)) {
-		return false;
-	}
-	if (!(value >= min && value < max)) {
-		return false;
-	}
-	// PG FLOAT => INT casts use statistical rounding.
-	result = static_cast<T>(std::nearbyint(value));
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int8_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int8_t>(value, result, -128.0f, 128.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int16_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int16_t>(value, result, -32768.0f, 32768.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int32_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int32_t>(value, result, -2147483648.0f, 2147483648.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int64_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int64_t>(value, result, -9223372036854775808.0f,
-	                                                     9223372036854775808.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, uint8_t &result) {
-	return TryCastWithOverflowCheckFloat<float, uint8_t>(value, result, 0.0f, 256.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, uint16_t &result) {
-	return TryCastWithOverflowCheckFloat<float, uint16_t>(value, result, 0.0f, 65536.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, uint32_t &result) {
-	return TryCastWithOverflowCheckFloat<float, uint32_t>(value, result, 0.0f, 4294967296.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, uint64_t &result) {
-	return TryCastWithOverflowCheckFloat<float, uint64_t>(value, result, 0.0f, 18446744073709551616.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int8_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int8_t>(value, result, -128.0, 128.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int16_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int16_t>(value, result, -32768.0, 32768.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int32_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int32_t>(value, result, -2147483648.0, 2147483648.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int64_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int64_t>(value, result, -9223372036854775808.0, 9223372036854775808.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, uint8_t &result) {
-	return TryCastWithOverflowCheckFloat<double, uint8_t>(value, result, 0.0, 256.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, uint16_t &result) {
-	return TryCastWithOverflowCheckFloat<double, uint16_t>(value, result, 0.0, 65536.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, uint32_t &result) {
-	return TryCastWithOverflowCheckFloat<double, uint32_t>(value, result, 0.0, 4294967296.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, uint64_t &result) {
-	return TryCastWithOverflowCheckFloat<double, uint64_t>(value, result, 0.0, 18446744073709551615.0);
-}
-template <>
-bool TryCastWithOverflowCheck(float input, float &result) {
-	result = input;
-	return true;
-}
-template <>
-bool TryCastWithOverflowCheck(float input, double &result) {
-	result = double(input);
-	return true;
-}
-template <>
-bool TryCastWithOverflowCheck(double input, double &result) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(double input, float &result) {
-	if (!Value::IsFinite(input)) {
-		result = float(input);
-		return true;
-	}
-	auto res = float(input);
-	if (!Value::FloatIsFinite(res)) {
-		return false;
-	}
-	result = res;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> bool
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(bool value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int8_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int16_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int32_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int64_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint8_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint16_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint32_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint64_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t input, bool &result) {
-	result = input.upper != 0 || input.lower != 0;
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t input, bool &result) {
-	result = input.upper != 0 || input.lower != 0;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast bool -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(bool value, int8_t &result) {
-	result = int8_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, int16_t &result) {
-	result = int16_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, int32_t &result) {
-	result = int32_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, int64_t &result) {
-	result = int64_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint8_t &result) {
-	result = uint8_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint16_t &result) {
-	result = uint16_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint32_t &result) {
-	result = uint32_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint64_t &result) {
-	result = uint64_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, float &result) {
-	result = float(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, double &result) {
-	result = double(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool input, hugeint_t &result) {
-	result.upper = 0;
-	result.lower = input ? 1 : 0;
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool input, uhugeint_t &result) {
-	result.upper = 0;
-	result.lower = input ? 1 : 0;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> hugeint
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(int8_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int16_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int32_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int64_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint8_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint16_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint32_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint64_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, hugeint_t &result) {
-	return Hugeint::TryConvert(std::nearbyintf(value), result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, hugeint_t &result) {
-	return Hugeint::TryConvert(std::nearbyint(value), result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, hugeint_t &result) {
-	result = value;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Hugeint -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int8_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int16_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int32_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int64_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint8_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint16_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint32_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint64_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uhugeint_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, float &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, double &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Uhugeint -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, int8_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, int16_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, int32_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, int64_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, uint8_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, uint16_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, uint32_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, uint64_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, hugeint_t &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, float &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, double &result) {
-	return Uhugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uhugeint_t value, uhugeint_t &result) {
-	result = value;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> uhugeint
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(int8_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int16_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int32_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int64_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint8_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint16_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint32_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint64_t value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(std::nearbyintf(value), result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, uhugeint_t &result) {
-	return Uhugeint::TryConvert(std::nearbyint(value), result);
-}
-
-struct NumericTryCastToBit {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		return StringVector::AddStringOrBlob(result, Bit::NumericToBit(input));
-	}
-};
-
-struct NumericTryCast {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		return TryCastWithOverflowCheck(input, result);
-	}
-};
-
-struct NumericCast {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		DST result;
-		if (!NumericTryCast::Operation(input, result)) {
-			throw InvalidInputException(CastExceptionText<SRC, DST>(input));
-		}
-		return result;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/string_cast.hpp b/src/duckdb/src/include/duckdb/common/operator/string_cast.hpp
deleted file mode 100644
index fac7a262a..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/string_cast.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/string_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-
-//! StringCast
-class Vector;
-
-struct StringCast {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw NotImplementedException("Unimplemented type for string cast!");
-	}
-};
-
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(bool input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int8_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int16_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int32_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int64_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint8_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint16_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint32_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint64_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(hugeint_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uhugeint_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(float input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(double input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(interval_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(date_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(dtime_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(timestamp_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(timestamp_ns_t input, Vector &result);
-
-//! Temporary casting for Time Zone types. TODO: turn casting into functions.
-struct StringCastTZ {
-	template <typename SRC>
-	static inline string_t Operation(SRC input, Vector &vector) {
-		return StringCast::Operation(input, vector);
-	}
-};
-
-template <>
-duckdb::string_t StringCastTZ::Operation(date_t input, Vector &result);
-template <>
-duckdb::string_t StringCastTZ::Operation(dtime_tz_t input, Vector &result);
-template <>
-duckdb::string_t StringCastTZ::Operation(timestamp_t input, Vector &result);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/operator/subtract.hpp b/src/duckdb/src/include/duckdb/common/operator/subtract.hpp
deleted file mode 100644
index 0f39c976c..000000000
--- a/src/duckdb/src/include/duckdb/common/operator/subtract.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/subtract.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/type_util.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-
-namespace duckdb {
-
-struct interval_t;
-struct date_t;
-struct timestamp_t;
-struct dtime_t;
-struct dtime_tz_t;
-
-struct SubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left - right;
-	}
-};
-
-template <>
-float SubtractOperator::Operation(float left, float right);
-template <>
-double SubtractOperator::Operation(double left, double right);
-template <>
-interval_t SubtractOperator::Operation(interval_t left, interval_t right);
-template <>
-int64_t SubtractOperator::Operation(date_t left, date_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, int32_t right);
-template <>
-timestamp_t SubtractOperator::Operation(date_t left, interval_t right);
-template <>
-timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right);
-template <>
-interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right);
-
-struct TrySubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TrySubtractOperator");
-	}
-};
-
-template <>
-bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-template <>
-bool TrySubtractOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result);
-
-struct SubtractOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TrySubtractOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtraction of %s (%s - %s)!", TypeIdToString(GetTypeId<TA>()),
-			                          NumericHelper::ToString(left), NumericHelper::ToString(right));
-		}
-		return result;
-	}
-};
-
-struct TryDecimalSubtract {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalSubtract");
-	}
-};
-
-template <>
-bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalSubtractOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalSubtract::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtract of DECIMAL(18) (%d - %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-struct SubtractTimeOperator {
-	template <class TA, class TB, class TR>
-	static TR Operation(TA left, TB right);
-};
-
-template <>
-dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right);
-
-template <>
-dtime_tz_t SubtractTimeOperator::Operation(dtime_tz_t left, interval_t right);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/optional_idx.hpp b/src/duckdb/src/include/duckdb/common/optional_idx.hpp
deleted file mode 100644
index fc88f8234..000000000
--- a/src/duckdb/src/include/duckdb/common/optional_idx.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/optional_idx.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-class optional_idx {
-	static constexpr const idx_t INVALID_INDEX = idx_t(-1);
-
-public:
-	optional_idx() : index(INVALID_INDEX) {
-	}
-	optional_idx(idx_t index) : index(index) { // NOLINT: allow implicit conversion from idx_t
-		if (index == INVALID_INDEX) {
-			throw InternalException("optional_idx cannot be initialized with an invalid index");
-		}
-	}
-
-	static optional_idx Invalid() {
-		return optional_idx();
-	}
-
-	bool IsValid() const {
-		return index != INVALID_INDEX;
-	}
-
-	void SetInvalid() {
-		index = INVALID_INDEX;
-	}
-
-	idx_t GetIndex() const {
-		if (index == INVALID_INDEX) {
-			throw InternalException("Attempting to get the index of an optional_idx that is not set");
-		}
-		return index;
-	}
-
-	inline bool operator==(const optional_idx &rhs) const {
-		return index == rhs.index;
-	}
-
-private:
-	idx_t index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/optional_ptr.hpp b/src/duckdb/src/include/duckdb/common/optional_ptr.hpp
deleted file mode 100644
index d2211e642..000000000
--- a/src/duckdb/src/include/duckdb/common/optional_ptr.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/optional_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-namespace duckdb {
-
-template <class T, bool SAFE = true>
-class optional_ptr { // NOLINT: mimic std casing
-public:
-	optional_ptr() noexcept : ptr(nullptr) {
-	}
-	optional_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
-	}
-	optional_ptr(T &ref) : ptr(&ref) { // NOLINT: allow implicit creation from reference
-	}
-	optional_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
-	}
-	optional_ptr(const shared_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from shared pointer
-	}
-
-	void CheckValid() const {
-		if (MemorySafety<SAFE>::ENABLED) {
-			if (!ptr) {
-				throw InternalException("Attempting to dereference an optional pointer that is not set");
-			}
-		}
-	}
-
-	operator bool() const { // NOLINT: allow implicit conversion to bool
-		return ptr;
-	}
-	T &operator*() {
-		CheckValid();
-		return *ptr;
-	}
-	const T &operator*() const {
-		CheckValid();
-		return *ptr;
-	}
-	T *operator->() {
-		CheckValid();
-		return ptr;
-	}
-	const T *operator->() const {
-		CheckValid();
-		return ptr;
-	}
-	T *get() { // NOLINT: mimic std casing
-		// CheckValid();
-		return ptr;
-	}
-	const T *get() const { // NOLINT: mimic std casing
-		// CheckValid();
-		return ptr;
-	}
-	// this looks dirty - but this is the default behavior of raw pointers
-	T *get_mutable() const { // NOLINT: mimic std casing
-		// CheckValid();
-		return ptr;
-	}
-
-	bool operator==(const optional_ptr<T> &rhs) const {
-		return ptr == rhs.ptr;
-	}
-
-	bool operator!=(const optional_ptr<T> &rhs) const {
-		return ptr != rhs.ptr;
-	}
-
-private:
-	T *ptr;
-};
-
-template <typename T>
-using unsafe_optional_ptr = optional_ptr<T, false>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/optionally_owned_ptr.hpp b/src/duckdb/src/include/duckdb/common/optionally_owned_ptr.hpp
deleted file mode 100644
index 1f904abd9..000000000
--- a/src/duckdb/src/include/duckdb/common/optionally_owned_ptr.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/optionally_owned_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-namespace duckdb {
-
-template <class T>
-class optionally_owned_ptr { // NOLINT: mimic std casing
-public:
-	optionally_owned_ptr() {
-	}
-	optionally_owned_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
-	}
-	optionally_owned_ptr(T &ref) : ptr(&ref) { // NOLINT: allow implicit creation from reference
-	}
-	optionally_owned_ptr(unique_ptr<T> &&owned_p) // NOLINT: allow implicit creation from moved unique_ptr
-	    : owned(std::move(owned_p)), ptr(owned) {
-	}
-	// Move constructor
-	optionally_owned_ptr(optionally_owned_ptr &&other) noexcept : owned(std::move(other.owned)), ptr(other.ptr) {
-		other.ptr = nullptr;
-	}
-	// Copy constructor
-	optionally_owned_ptr(const optionally_owned_ptr &other) = delete;
-
-	operator bool() const { // NOLINT: allow implicit conversion to bool
-		return ptr;
-	}
-	T &operator*() {
-		return *ptr;
-	}
-	const T &operator*() const {
-		return *ptr;
-	}
-	T *operator->() {
-		return ptr.get();
-	}
-	const T *operator->() const {
-		return ptr.get();
-	}
-	T *get() { // NOLINT: mimic std casing
-		return ptr.get();
-	}
-	const T *get() const { // NOLINT: mimic std casing
-		return ptr.get();
-	}
-	bool is_owned() const { // NOLINT: mimic std casing
-		return owned != nullptr;
-	}
-	// this looks dirty - but this is the default behavior of raw pointers
-	T *get_mutable() const { // NOLINT: mimic std casing
-		return ptr.get();
-	}
-
-	optionally_owned_ptr<T> &operator=(T &ref) {
-		owned = nullptr;
-		ptr = optional_ptr<T>(ref);
-		return *this;
-	}
-	optionally_owned_ptr<T> &operator=(T *ref) {
-		owned = nullptr;
-		ptr = optional_ptr<T>(ref);
-		return *this;
-	}
-
-	bool operator==(const optionally_owned_ptr<T> &rhs) const {
-		if (owned != rhs.owned) {
-			return false;
-		}
-		return ptr == rhs.ptr;
-	}
-
-	bool operator!=(const optionally_owned_ptr<T> &rhs) const {
-		return !(*this == rhs);
-	}
-
-private:
-	unique_ptr<T> owned;
-	optional_ptr<T> ptr;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/owning_string_map.hpp b/src/duckdb/src/include/duckdb/common/owning_string_map.hpp
deleted file mode 100644
index 4f1823bf8..000000000
--- a/src/duckdb/src/include/duckdb/common/owning_string_map.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/owning_string_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-#include <cstring>
-
-namespace duckdb {
-
-//! The owning string map is equivalent to string_map_t, except that it manages ownership of all data using the
-//! provided allocator
-template <class VALUE_TYPE, class STRING_MAP_TYPE = string_map_t<VALUE_TYPE>>
-class OwningStringMap {
-public:
-	using size_type = typename STRING_MAP_TYPE::size_type;
-	using key_type = typename STRING_MAP_TYPE::key_type;
-	using mapped_type = typename STRING_MAP_TYPE::mapped_type;
-	using value_type = typename STRING_MAP_TYPE::value_type;
-	using iterator = typename STRING_MAP_TYPE::iterator;
-	using const_iterator = typename STRING_MAP_TYPE::const_iterator;
-
-public:
-	explicit OwningStringMap(Allocator &allocator) : allocator(allocator), free_type(AllocatorFreeType::REQUIRES_FREE) {
-	}
-	explicit OwningStringMap(ArenaAllocator &allocator)
-	    : allocator(allocator.GetAllocator()), free_type(AllocatorFreeType::DOES_NOT_REQUIRE_FREE) {
-	}
-	~OwningStringMap() {
-		Destroy();
-	}
-
-	pair<iterator, bool> insert(value_type entry) { // NOLINT: match std style
-		if (entry.first.IsInlined()) {
-			return map.insert(std::move(entry));
-		} else {
-			return map.insert(make_pair(CopyString(entry.first), std::move(entry.second)));
-		}
-	}
-	size_type erase(const key_type &k) { // NOLINT: match std style
-		auto entry = map.find(k);
-		if (entry == map.end()) {
-			return 0;
-		}
-		string_t erase_string = entry->first;
-		map.erase(entry);
-		DestroyString(erase_string);
-		return 1;
-	}
-
-	void clear() { // NOLINT: match std style
-		Destroy();
-	}
-
-	size_type size() const noexcept { // NOLINT: match std style
-		return map.size();
-	}
-
-	bool empty() const noexcept { // NOLINT: match std style
-		return map.empty();
-	}
-	iterator begin() noexcept { // NOLINT: match std style
-		return map.begin();
-	}
-	const_iterator begin() const noexcept { // NOLINT: match std style
-		return map.begin();
-	}
-	iterator end() noexcept { // NOLINT: match std style
-		return map.end();
-	}
-	const_iterator end() const noexcept { // NOLINT: match std style
-		return map.end();
-	}
-	iterator find(const key_type &k) { // NOLINT: match std style
-		return map.find(k);
-	}
-	const_iterator find(const key_type &k) const { // NOLINT: match std style
-		return map.find(k);
-	}
-
-	mapped_type &operator[](const key_type &k) {
-		return GetOrCreate(k);
-	}
-	mapped_type &operator[](key_type &&k) {
-		return GetOrCreate(std::move(k));
-	}
-
-private:
-	inline string_t GetInsertionString(string_t input_str) {
-		if (input_str.IsInlined()) {
-			// inlined strings can be inserted directly
-			return input_str;
-		} else {
-			return CopyString(input_str);
-		}
-	}
-
-	inline string_t CopyString(string_t input_str) {
-		D_ASSERT(!input_str.IsInlined());
-		// if the string is not inlined we need to allocate space for it
-		auto input_str_size = UnsafeNumericCast<uint32_t>(input_str.GetSize());
-		auto string_memory = allocator.AllocateData(input_str_size);
-		// copy over the string
-		memcpy(string_memory, input_str.GetData(), input_str_size);
-		// now return the final string_t
-		return string_t(char_ptr_cast(string_memory), input_str_size);
-	}
-
-	mapped_type &GetOrCreate(key_type k) {
-		auto entry = map.find(k);
-		if (entry != map.end()) {
-			return entry->second;
-		}
-		auto result = insert(make_pair(k, mapped_type()));
-		return result.first->second;
-	}
-
-	void DestroyString(const string_t &str) const {
-		if (free_type != AllocatorFreeType::REQUIRES_FREE) {
-			return;
-		}
-		if (str.IsInlined()) {
-			return;
-		}
-		allocator.FreeData(data_ptr_cast(str.GetDataWriteable()), str.GetSize());
-	}
-
-	void Destroy() {
-		if (free_type == AllocatorFreeType::REQUIRES_FREE) {
-			for (auto &str : map) {
-				DestroyString(str.first);
-			}
-		}
-		map.clear();
-	}
-
-private:
-	Allocator &allocator;
-	STRING_MAP_TYPE map;
-	AllocatorFreeType free_type;
-};
-
-template <class T>
-using OrderedOwningStringMap = OwningStringMap<T, map<string_t, T>>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/pair.hpp b/src/duckdb/src/include/duckdb/common/pair.hpp
deleted file mode 100644
index 22d50f70e..000000000
--- a/src/duckdb/src/include/duckdb/common/pair.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/pair.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <utility>
-
-namespace duckdb {
-using std::make_pair;
-using std::pair;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/perfect_map_set.hpp b/src/duckdb/src/include/duckdb/common/perfect_map_set.hpp
deleted file mode 100644
index f686fc7a7..000000000
--- a/src/duckdb/src/include/duckdb/common/perfect_map_set.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/perfect_map_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-struct PerfectHash {
-	std::size_t operator()(const idx_t &h) const {
-		return h;
-	}
-};
-
-struct PerfectEquality {
-	bool operator()(const idx_t &a, const idx_t &b) const {
-		return a == b;
-	}
-};
-
-template <typename T>
-using perfect_map_t = unordered_map<idx_t, T, PerfectHash, PerfectEquality>;
-
-using perfect_set_t = unordered_set<idx_t, PerfectHash, PerfectEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/pipe_file_system.hpp b/src/duckdb/src/include/duckdb/common/pipe_file_system.hpp
deleted file mode 100644
index a84433d21..000000000
--- a/src/duckdb/src/include/duckdb/common/pipe_file_system.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/pipe_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-
-namespace duckdb {
-
-class PipeFileSystem : public FileSystem {
-public:
-	static unique_ptr<FileHandle> OpenPipe(unique_ptr<FileHandle> handle);
-
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	int64_t GetFileSize(FileHandle &handle) override;
-
-	void Reset(FileHandle &handle) override;
-	bool OnDiskFile(FileHandle &handle) override {
-		return false;
-	};
-	bool CanSeek() override {
-		return false;
-	}
-	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener) override {
-		return true;
-	}
-	void FileSync(FileHandle &handle) override;
-
-	std::string GetName() const override {
-		return "PipeFileSystem";
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/platform.hpp b/src/duckdb/src/include/duckdb/common/platform.hpp
deleted file mode 100644
index cba08883f..000000000
--- a/src/duckdb/src/include/duckdb/common/platform.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/platform.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-#include <string>
-
-// duplicated from string_util.h to avoid linking issues
-#ifndef DUCKDB_QUOTE_DEFINE
-#define DUCKDB_QUOTE_DEFINE_IMPL(x) #x
-#define DUCKDB_QUOTE_DEFINE(x)      DUCKDB_QUOTE_DEFINE_IMPL(x)
-#endif
-
-#if defined(_WIN32) || defined(__APPLE__) || defined(__FreeBSD__)
-#else
-#if !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#include <features.h>
-#ifndef __USE_GNU
-#define __MUSL__
-#endif
-#undef _GNU_SOURCE /* don't contaminate other includes unnecessarily */
-#else
-#include <features.h>
-#ifndef __USE_GNU
-#define __MUSL__
-#endif
-#endif
-#endif
-
-namespace duckdb {
-
-std::string DuckDBPlatform() { // NOLINT: allow definition in header
-#if defined(DUCKDB_CUSTOM_PLATFORM)
-	return DUCKDB_QUOTE_DEFINE(DUCKDB_CUSTOM_PLATFORM);
-#endif
-#if defined(DUCKDB_WASM_VERSION)
-	// DuckDB-Wasm requires CUSTOM_PLATFORM to be defined
-	static_assert(0, "DUCKDB_WASM_VERSION should rely on CUSTOM_PLATFORM being provided");
-#endif
-	std::string os = "linux";
-#if INTPTR_MAX == INT64_MAX
-	std::string arch = "amd64";
-#elif INTPTR_MAX == INT32_MAX
-	std::string arch = "i686";
-#else
-#error Unknown pointer size or missing size macros!
-#endif
-	std::string postfix = "";
-
-#ifdef _WIN32
-	os = "windows";
-#elif defined(__APPLE__)
-	os = "osx";
-#elif defined(__FreeBSD__)
-	os = "freebsd";
-#endif
-#if defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64)
-	arch = "arm64";
-#endif
-
-#if defined(__MUSL__)
-	if (os == "linux") {
-		postfix = "_musl";
-	}
-#elif !defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI == 0
-	if (os == "linux") {
-		postfix = "_gcc4";
-	}
-#endif
-
-#if defined(__ANDROID__)
-	postfix += "_android"; // using + because it may also be gcc4
-#endif
-#ifdef __MINGW32__
-	postfix = "_mingw";
-#endif
-// this is used for the windows R builds which use `mingw` equivalent extensions
-#ifdef DUCKDB_PLATFORM_RTOOLS
-	postfix = "_mingw";
-#endif
-	return os + "_" + arch + postfix;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/printer.hpp b/src/duckdb/src/include/duckdb/common/printer.hpp
deleted file mode 100644
index eba11c336..000000000
--- a/src/duckdb/src/include/duckdb/common/printer.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/printer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-enum class OutputStream : uint8_t { STREAM_STDOUT = 1, STREAM_STDERR = 2 };
-
-//! Printer is a static class that allows printing to logs or stdout/stderr
-class Printer {
-public:
-	//! Print the object to the stream
-	DUCKDB_API static void Print(OutputStream stream, const string &str);
-	//! Print the object to stderr
-	DUCKDB_API static void Print(const string &str);
-	//! Print the formatted object to the stream
-	template <typename... ARGS>
-	static void PrintF(OutputStream stream, const string &str, ARGS... params) {
-		Printer::Print(stream, StringUtil::Format(str, params...));
-	}
-	//! Print the formatted object to stderr
-	template <typename... ARGS>
-	static void PrintF(const string &str, ARGS... params) {
-		Printer::PrintF(OutputStream::STREAM_STDERR, str, std::forward<ARGS>(params)...);
-	}
-	//! Directly prints the string to stdout without a newline
-	DUCKDB_API static void RawPrint(OutputStream stream, const string &str);
-	//! Flush an output stream
-	DUCKDB_API static void Flush(OutputStream stream);
-	//! Whether or not we are printing to a terminal
-	DUCKDB_API static bool IsTerminal(OutputStream stream);
-	//! The terminal width
-	DUCKDB_API static idx_t TerminalWidth();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/profiler.hpp b/src/duckdb/src/include/duckdb/common/profiler.hpp
deleted file mode 100644
index 397efad80..000000000
--- a/src/duckdb/src/include/duckdb/common/profiler.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/profiler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-//! The profiler can be used to measure elapsed time
-template <typename T>
-class BaseProfiler {
-public:
-	//! Starts the timer
-	void Start() {
-		finished = false;
-		start = Tick();
-	}
-	//! Finishes timing
-	void End() {
-		end = Tick();
-		finished = true;
-	}
-
-	//! Returns the elapsed time in seconds. If End() has been called, returns
-	//! the total elapsed time. Otherwise returns how far along the timer is
-	//! right now.
-	double Elapsed() const {
-		auto measured_end = finished ? end : Tick();
-		return std::chrono::duration_cast<std::chrono::duration<double>>(measured_end - start).count();
-	}
-
-private:
-	time_point<T> Tick() const {
-		return T::now();
-	}
-	time_point<T> start;
-	time_point<T> end;
-	bool finished = false;
-};
-
-using Profiler = BaseProfiler<system_clock>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp b/src/duckdb/src/include/duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp
deleted file mode 100644
index 8c0c01ac4..000000000
--- a/src/duckdb/src/include/duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/progress_bar/progress_bar_display.hpp"
-#include "duckdb/common/unicode_bar.hpp"
-
-namespace duckdb {
-
-class TerminalProgressBarDisplay : public ProgressBarDisplay {
-public:
-	TerminalProgressBarDisplay() = default;
-	~TerminalProgressBarDisplay() override = default;
-
-public:
-	void Update(double percentage) override;
-	void Finish() override;
-
-private:
-	int32_t rendered_percentage = -1;
-	static constexpr const idx_t PARTIAL_BLOCK_COUNT = UnicodeBar::PartialBlocksCount();
-#ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *PROGRESS_EMPTY = " ";                                  // NOLINT
-	const char *const *PROGRESS_PARTIAL = UnicodeBar::PartialBlocks(); // NOLINT
-	const char *PROGRESS_BLOCK = UnicodeBar::FullBlock();              // NOLINT
-	const char *PROGRESS_START = "\xE2\x96\x95";                       // NOLINT
-	const char *PROGRESS_END = "\xE2\x96\x8F";                         // NOLINT
-#else
-	const char *PROGRESS_EMPTY = " ";
-	const char *const PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] = {" ", " ", " ", " ", " ", " ", " ", " "};
-	const char *PROGRESS_BLOCK = "=";
-	const char *PROGRESS_START = "[";
-	const char *PROGRESS_END = "]";
-#endif
-	static constexpr const idx_t PROGRESS_BAR_WIDTH = 60;
-
-private:
-	static int32_t NormalizePercentage(double percentage);
-	void PrintProgressInternal(int32_t percentage);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar.hpp b/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar.hpp
deleted file mode 100644
index 1686e8b13..000000000
--- a/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/progress_bar/progress_bar.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/profiler.hpp"
-#include "duckdb/common/progress_bar/progress_bar_display.hpp"
-
-namespace duckdb {
-
-struct ClientConfig;
-typedef unique_ptr<ProgressBarDisplay> (*progress_bar_display_create_func_t)();
-
-struct QueryProgress {
-	friend class ProgressBar;
-
-public:
-	QueryProgress();
-	void Initialize();
-	void Restart();
-	double GetPercentage();
-	uint64_t GetRowsProcesseed();
-	uint64_t GetTotalRowsToProcess();
-	QueryProgress &operator=(const QueryProgress &other);
-	QueryProgress(const QueryProgress &other);
-
-private:
-	atomic<double> percentage;
-	atomic<uint64_t> rows_processed;
-	atomic<uint64_t> total_rows_to_process;
-};
-
-class ProgressBar {
-public:
-	static unique_ptr<ProgressBarDisplay> DefaultProgressBarDisplay();
-	static void SystemOverrideCheck(ClientConfig &config);
-
-	explicit ProgressBar(
-	    Executor &executor, idx_t show_progress_after,
-	    progress_bar_display_create_func_t create_display_func = ProgressBar::DefaultProgressBarDisplay);
-
-	//! Starts the thread
-	void Start();
-	//! Updates the progress bar and prints it to the screen
-	void Update(bool final);
-	QueryProgress GetDetailedQueryProgress();
-	void PrintProgress(int percentage);
-	void FinishProgressBarPrint();
-	bool ShouldPrint(bool final) const;
-	bool PrintEnabled() const;
-
-private:
-	//! The executor
-	Executor &executor;
-	//! The profiler used to measure the time since the progress bar was started
-	Profiler profiler;
-	//! The time in ms after which to start displaying the progress bar
-	idx_t show_progress_after;
-	//! Keeps track of the total progress of a query
-	QueryProgress query_progress;
-	//! The display used to print the progress
-	unique_ptr<ProgressBarDisplay> display;
-	//! Whether or not profiling is supported for the current query
-	bool supported = true;
-	//! Whether the bar has already finished
-	bool finished = false;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar_display.hpp b/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar_display.hpp
deleted file mode 100644
index 815272ca4..000000000
--- a/src/duckdb/src/include/duckdb/common/progress_bar/progress_bar_display.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/progress_bar/progress_bar_display.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-class ProgressBarDisplay {
-public:
-	ProgressBarDisplay() {
-	}
-	virtual ~ProgressBarDisplay() {
-	}
-
-public:
-	virtual void Update(double percentage) = 0;
-	virtual void Finish() = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/queue.hpp b/src/duckdb/src/include/duckdb/common/queue.hpp
deleted file mode 100644
index d3e28d982..000000000
--- a/src/duckdb/src/include/duckdb/common/queue.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/queue.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <queue>
-
-namespace duckdb {
-using std::queue;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/radix.hpp b/src/duckdb/src/include/duckdb/common/radix.hpp
deleted file mode 100644
index dc22256c5..000000000
--- a/src/duckdb/src/include/duckdb/common/radix.hpp
+++ /dev/null
@@ -1,348 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/radix.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bswap.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/limits.hpp"
-
-#include <cfloat>
-#include <cstring> // strlen() on Solaris
-#include <limits.h>
-
-namespace duckdb {
-
-struct Radix {
-public:
-	static inline bool IsLittleEndian() {
-		int n = 1;
-		if (*char_ptr_cast(&n) == 1) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	template <class T>
-	static inline void EncodeData(data_ptr_t dataptr, T value) {
-		throw NotImplementedException("Cannot create data from this type");
-	}
-
-	template <class T>
-	static inline T DecodeData(const_data_ptr_t input) {
-		throw NotImplementedException("Cannot read data from this type");
-	}
-
-	static inline void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len) {
-		auto len = value.GetSize();
-		memcpy(dataptr, value.GetData(), MinValue(len, prefix_len));
-		if (len < prefix_len) {
-			memset(dataptr + len, '\0', prefix_len - len);
-		}
-	}
-
-	static inline uint8_t FlipSign(uint8_t key_byte) {
-		return key_byte ^ 128;
-	}
-
-	static inline uint32_t EncodeFloat(float x) {
-		uint32_t buff;
-		//! zero
-		if (x == 0) {
-			buff = 0;
-			buff |= (1u << 31);
-			return buff;
-		}
-
-		// nan
-		if (Value::IsNan(x)) {
-			return UINT_MAX;
-		}
-		//! infinity
-		if (x > FLT_MAX) {
-			return UINT_MAX - 1;
-		}
-		//! -infinity
-		if (x < -FLT_MAX) {
-			return 0;
-		}
-		buff = Load<uint32_t>(const_data_ptr_cast(&x));
-		if ((buff & (1U << 31)) == 0) { //! +0 and positive numbers
-			buff |= (1U << 31);
-		} else {          //! negative numbers
-			buff = ~buff; //! complement 1
-		}
-
-		return buff;
-	}
-
-	static inline float DecodeFloat(uint32_t input) {
-		// nan
-		if (input == UINT_MAX) {
-			return std::numeric_limits<float>::quiet_NaN();
-		}
-		if (input == UINT_MAX - 1) {
-			return std::numeric_limits<float>::infinity();
-		}
-		if (input == 0) {
-			return -std::numeric_limits<float>::infinity();
-		}
-		float result;
-		if (input & (1U << 31)) {
-			// positive numbers - flip sign bit
-			input = input ^ (1U << 31);
-		} else {
-			// negative numbers - invert
-			input = ~input;
-		}
-		Store<uint32_t>(input, data_ptr_cast(&result));
-		return result;
-	}
-
-	static inline uint64_t EncodeDouble(double x) {
-		uint64_t buff;
-		//! zero
-		if (x == 0) {
-			buff = 0;
-			buff += (1ULL << 63);
-			return buff;
-		}
-		// nan
-		if (Value::IsNan(x)) {
-			return ULLONG_MAX;
-		}
-		//! infinity
-		if (x > DBL_MAX) {
-			return ULLONG_MAX - 1;
-		}
-		//! -infinity
-		if (x < -DBL_MAX) {
-			return 0;
-		}
-		buff = Load<uint64_t>(const_data_ptr_cast(&x));
-		if (buff < (1ULL << 63)) { //! +0 and positive numbers
-			buff += (1ULL << 63);
-		} else {          //! negative numbers
-			buff = ~buff; //! complement 1
-		}
-		return buff;
-	}
-	static inline double DecodeDouble(uint64_t input) {
-		// nan
-		if (input == ULLONG_MAX) {
-			return std::numeric_limits<double>::quiet_NaN();
-		}
-		if (input == ULLONG_MAX - 1) {
-			return std::numeric_limits<double>::infinity();
-		}
-		if (input == 0) {
-			return -std::numeric_limits<double>::infinity();
-		}
-		double result;
-		if (input & (1ULL << 63)) {
-			// positive numbers - flip sign bit
-			input = input ^ (1ULL << 63);
-		} else {
-			// negative numbers - invert
-			input = ~input;
-		}
-		Store<uint64_t>(input, data_ptr_cast(&result));
-		return result;
-	}
-
-private:
-	template <class T>
-	static void EncodeSigned(data_ptr_t dataptr, T value);
-	template <class T>
-	static T DecodeSigned(const_data_ptr_t input);
-};
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, bool value) {
-	Store<uint8_t>(value ? 1 : 0, dataptr);
-}
-
-template <class T>
-void Radix::EncodeSigned(data_ptr_t dataptr, T value) {
-	using UNSIGNED = typename MakeUnsigned<T>::type;
-	UNSIGNED bytes;
-	Store<T>(value, data_ptr_cast(&bytes));
-	Store<UNSIGNED>(BSwap(bytes), dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int8_t value) {
-	EncodeSigned<int8_t>(dataptr, value);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int16_t value) {
-	EncodeSigned<int16_t>(dataptr, value);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int32_t value) {
-	EncodeSigned<int32_t>(dataptr, value);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int64_t value) {
-	EncodeSigned<int64_t>(dataptr, value);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint8_t value) {
-	Store<uint8_t>(value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint16_t value) {
-	Store<uint16_t>(BSwap(value), dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint32_t value) {
-	Store<uint32_t>(BSwap(value), dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint64_t value) {
-	Store<uint64_t>(BSwap(value), dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, hugeint_t value) {
-	EncodeData<int64_t>(dataptr, value.upper);
-	EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uhugeint_t value) {
-	EncodeData<uint64_t>(dataptr, value.upper);
-	EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, float value) {
-	uint32_t converted_value = EncodeFloat(value);
-	Store<uint32_t>(BSwap(converted_value), dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, double value) {
-	uint64_t converted_value = EncodeDouble(value);
-	Store<uint64_t>(BSwap(converted_value), dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, interval_t value) {
-	EncodeData<int32_t>(dataptr, value.months);
-	dataptr += sizeof(value.months);
-	EncodeData<int32_t>(dataptr, value.days);
-	dataptr += sizeof(value.days);
-	EncodeData<int64_t>(dataptr, value.micros);
-}
-
-template <>
-inline bool Radix::DecodeData(const_data_ptr_t input) {
-	return Load<uint8_t>(input) != 0;
-}
-
-template <class T>
-T Radix::DecodeSigned(const_data_ptr_t input) {
-	using UNSIGNED = typename MakeUnsigned<T>::type;
-	UNSIGNED bytes = Load<UNSIGNED>(input);
-	auto bytes_data = data_ptr_cast(&bytes);
-	bytes_data[0] = FlipSign(bytes_data[0]);
-	T result;
-	Store<UNSIGNED>(BSwap(bytes), data_ptr_cast(&result));
-	return result;
-}
-
-template <>
-inline int8_t Radix::DecodeData(const_data_ptr_t input) {
-	return DecodeSigned<int8_t>(input);
-}
-
-template <>
-inline int16_t Radix::DecodeData(const_data_ptr_t input) {
-	return DecodeSigned<int16_t>(input);
-}
-
-template <>
-inline int32_t Radix::DecodeData(const_data_ptr_t input) {
-	return DecodeSigned<int32_t>(input);
-}
-
-template <>
-inline int64_t Radix::DecodeData(const_data_ptr_t input) {
-	return DecodeSigned<int64_t>(input);
-}
-
-template <>
-inline uint8_t Radix::DecodeData(const_data_ptr_t input) {
-	return Load<uint8_t>(input);
-}
-
-template <>
-inline uint16_t Radix::DecodeData(const_data_ptr_t input) {
-	return BSwap(Load<uint16_t>(input));
-}
-
-template <>
-inline uint32_t Radix::DecodeData(const_data_ptr_t input) {
-	return BSwap(Load<uint32_t>(input));
-}
-
-template <>
-inline uint64_t Radix::DecodeData(const_data_ptr_t input) {
-	return BSwap(Load<uint64_t>(input));
-}
-
-template <>
-inline hugeint_t Radix::DecodeData(const_data_ptr_t input) {
-	hugeint_t result;
-	result.upper = DecodeData<int64_t>(input);
-	result.lower = DecodeData<uint64_t>(input + sizeof(int64_t));
-	return result;
-}
-
-template <>
-inline uhugeint_t Radix::DecodeData(const_data_ptr_t input) {
-	uhugeint_t result;
-	result.upper = DecodeData<uint64_t>(input);
-	result.lower = DecodeData<uint64_t>(input + sizeof(uint64_t));
-	return result;
-}
-
-template <>
-inline float Radix::DecodeData(const_data_ptr_t input) {
-	return DecodeFloat(BSwap(Load<uint32_t>(input)));
-}
-
-template <>
-inline double Radix::DecodeData(const_data_ptr_t input) {
-	return DecodeDouble(BSwap(Load<uint64_t>(input)));
-}
-
-template <>
-inline interval_t Radix::DecodeData(const_data_ptr_t input) {
-	interval_t result;
-	result.months = DecodeData<int32_t>(input);
-	result.days = DecodeData<int32_t>(input + sizeof(int32_t));
-	result.micros = DecodeData<int64_t>(input + sizeof(int32_t) + sizeof(int32_t));
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/radix_partitioning.hpp b/src/duckdb/src/include/duckdb/common/radix_partitioning.hpp
deleted file mode 100644
index 5c4a0e2a1..000000000
--- a/src/duckdb/src/include/duckdb/common/radix_partitioning.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/radix_partitioning.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bit_utils.hpp"
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/common/types/row/partitioned_tuple_data.hpp"
-
-namespace duckdb {
-
-class BufferManager;
-class Vector;
-struct UnifiedVectorFormat;
-struct SelectionVector;
-
-//! Generic radix partitioning functions
-struct RadixPartitioning {
-public:
-	//! 4096 partitions ought to be enough to go out-of-core properly
-	static constexpr const idx_t MAX_RADIX_BITS = 12;
-
-	//! The number of partitions for a given number of radix bits
-	static inline constexpr idx_t NumberOfPartitions(idx_t radix_bits) {
-		return idx_t(1) << radix_bits;
-	}
-
-	template <class T>
-	static inline idx_t RadixBits(T n) {
-		return sizeof(T) * 8 - CountZeros<T>::Leading(n);
-	}
-
-	//! Inverse of NumberOfPartitions, given a number of partitions, get the number of radix bits
-	static inline idx_t RadixBitsOfPowerOfTwo(idx_t n_partitions) {
-		D_ASSERT(IsPowerOfTwo(n_partitions));
-		return RadixBits(n_partitions) - 1;
-	}
-
-	//! Radix bits begin after uint16_t because these bits are used as salt in the aggregate HT
-	static inline constexpr idx_t Shift(idx_t radix_bits) {
-		return (sizeof(hash_t) - sizeof(uint16_t)) * 8 - radix_bits;
-	}
-
-	//! Mask of the radix bits of the hash
-	static inline constexpr hash_t Mask(idx_t radix_bits) {
-		return (hash_t(1 << radix_bits) - 1) << Shift(radix_bits);
-	}
-
-	//! Select using a cutoff on the radix bits of the hash
-	static idx_t Select(Vector &hashes, const SelectionVector *sel, idx_t count, idx_t radix_bits,
-	                    const ValidityMask &partition_mask, SelectionVector *true_sel, SelectionVector *false_sel);
-};
-
-//! RadixPartitionedColumnData is a PartitionedColumnData that partitions input based on the radix of a hash
-class RadixPartitionedColumnData : public PartitionedColumnData {
-public:
-	RadixPartitionedColumnData(ClientContext &context, vector<LogicalType> types, idx_t radix_bits, idx_t hash_col_idx);
-	RadixPartitionedColumnData(const RadixPartitionedColumnData &other);
-	~RadixPartitionedColumnData() override;
-
-	idx_t GetRadixBits() const {
-		return radix_bits;
-	}
-
-protected:
-	//===--------------------------------------------------------------------===//
-	// Radix Partitioning interface implementation
-	//===--------------------------------------------------------------------===//
-	idx_t BufferSize() const override {
-		switch (radix_bits) {
-		case 1:
-		case 2:
-		case 3:
-		case 4:
-			return GetBufferSize(1 << 1);
-		case 5:
-			return GetBufferSize(1 << 2);
-		case 6:
-			return GetBufferSize(1 << 3);
-		default:
-			return GetBufferSize(1 << 4);
-		}
-	}
-
-	void InitializeAppendStateInternal(PartitionedColumnDataAppendState &state) const override;
-	void ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) override;
-	idx_t MaxPartitionIndex() const override {
-		return RadixPartitioning::NumberOfPartitions(radix_bits) - 1;
-	}
-
-	static constexpr idx_t GetBufferSize(idx_t div) {
-		return STANDARD_VECTOR_SIZE / div == 0 ? 1 : STANDARD_VECTOR_SIZE / div;
-	}
-
-private:
-	//! The number of radix bits
-	const idx_t radix_bits;
-	//! The index of the column holding the hashes
-	const idx_t hash_col_idx;
-};
-
-//! RadixPartitionedTupleData is a PartitionedTupleData that partitions input based on the radix of a hash
-class RadixPartitionedTupleData : public PartitionedTupleData {
-public:
-	RadixPartitionedTupleData(BufferManager &buffer_manager, const TupleDataLayout &layout, idx_t radix_bits_p,
-	                          idx_t hash_col_idx_p);
-	RadixPartitionedTupleData(const RadixPartitionedTupleData &other);
-	~RadixPartitionedTupleData() override;
-
-	idx_t GetRadixBits() const {
-		return radix_bits;
-	}
-
-private:
-	void Initialize();
-
-protected:
-	//===--------------------------------------------------------------------===//
-	// Radix Partitioning interface implementation
-	//===--------------------------------------------------------------------===//
-	void InitializeAppendStateInternal(PartitionedTupleDataAppendState &state,
-	                                   TupleDataPinProperties properties) const override;
-	void ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input,
-	                             const SelectionVector &append_sel, const idx_t append_count) override;
-	void ComputePartitionIndices(Vector &row_locations, idx_t count, Vector &partition_indices) const override;
-	idx_t MaxPartitionIndex() const override {
-		return RadixPartitioning::NumberOfPartitions(radix_bits) - 1;
-	}
-
-	void RepartitionFinalizeStates(PartitionedTupleData &old_partitioned_data,
-	                               PartitionedTupleData &new_partitioned_data, PartitionedTupleDataAppendState &state,
-	                               idx_t finished_partition_idx) const override;
-
-private:
-	//! The number of radix bits
-	const idx_t radix_bits;
-	//! The index of the column holding the hashes
-	const idx_t hash_col_idx;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/random_engine.hpp b/src/duckdb/src/include/duckdb/common/random_engine.hpp
deleted file mode 100644
index 8a5a3097e..000000000
--- a/src/duckdb/src/include/duckdb/common/random_engine.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/random_engine.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/mutex.hpp"
-
-#include <random>
-
-namespace duckdb {
-class ClientContext;
-struct RandomState;
-
-class RandomEngine {
-public:
-	explicit RandomEngine(int64_t seed = -1);
-	~RandomEngine();
-
-	//! Generate a random number between min and max
-	double NextRandom(double min, double max);
-
-	//! Generate a random number between 0 and 1
-	double NextRandom();
-	//! Generate a random number between 0 and 1, using 32-bits as a base
-	double NextRandom32();
-	double NextRandom32(double min, double max);
-	uint32_t NextRandomInteger32(uint32_t min, uint32_t max);
-	uint32_t NextRandomInteger();
-	uint32_t NextRandomInteger(uint32_t min, uint32_t max);
-	uint64_t NextRandomInteger64();
-
-	void SetSeed(uint64_t seed);
-
-	static RandomEngine &Get(ClientContext &context);
-
-	mutex lock;
-
-private:
-	unique_ptr<RandomState> random_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/re2_regex.hpp b/src/duckdb/src/include/duckdb/common/re2_regex.hpp
deleted file mode 100644
index 9b33df56e..000000000
--- a/src/duckdb/src/include/duckdb/common/re2_regex.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// RE2 compatibility layer with std::regex
-
-#pragma once
-
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/string.hpp"
-#include <stdexcept>
-
-namespace duckdb_re2 {
-class RE2;
-
-enum class RegexOptions : uint8_t { NONE, CASE_INSENSITIVE };
-
-class Regex {
-public:
-	DUCKDB_API explicit Regex(const std::string &pattern, RegexOptions options = RegexOptions::NONE);
-	explicit Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
-	}
-	const duckdb_re2::RE2 &GetRegex() const {
-		return *regex;
-	}
-
-private:
-	duckdb::shared_ptr<duckdb_re2::RE2> regex;
-};
-
-struct GroupMatch {
-	std::string text;
-	uint32_t position;
-
-	const std::string &str() const { // NOLINT
-		return text;
-	}
-	operator std::string() const { // NOLINT: allow implicit cast
-		return text;
-	}
-};
-
-struct Match {
-	duckdb::vector<GroupMatch> groups;
-
-	GroupMatch &GetGroup(uint64_t index) {
-		if (index >= groups.size()) {
-			throw std::runtime_error("RE2: Match index is out of range");
-		}
-		return groups[index];
-	}
-
-	std::string str(uint64_t index) { // NOLINT
-		return GetGroup(index).text;
-	}
-
-	uint64_t position(uint64_t index) { // NOLINT
-		return GetGroup(index).position;
-	}
-
-	uint64_t length(uint64_t index) { // NOLINT
-		return GetGroup(index).text.size();
-	}
-
-	GroupMatch &operator[](uint64_t i) {
-		return GetGroup(i);
-	}
-};
-
-DUCKDB_API bool RegexSearch(const std::string &input, Match &match, const Regex &regex);
-DUCKDB_API bool RegexMatch(const std::string &input, Match &match, const Regex &regex);
-DUCKDB_API bool RegexMatch(const char *start, const char *end, Match &match, const Regex &regex);
-DUCKDB_API bool RegexMatch(const std::string &input, const Regex &regex);
-DUCKDB_API duckdb::vector<Match> RegexFindAll(const std::string &input, const Regex &regex);
-DUCKDB_API duckdb::vector<Match> RegexFindAll(const char *input_data, size_t input_size, const RE2 &regex);
-} // namespace duckdb_re2
diff --git a/src/duckdb/src/include/duckdb/common/reference_map.hpp b/src/duckdb/src/include/duckdb/common/reference_map.hpp
deleted file mode 100644
index 2d95f9978..000000000
--- a/src/duckdb/src/include/duckdb/common/reference_map.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/reference_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-class Expression;
-
-template <class T>
-struct ReferenceHashFunction {
-	uint64_t operator()(const reference<T> &ref) const {
-		return std::hash<void *>()((void *)&ref.get());
-	}
-};
-
-template <class T>
-struct ReferenceEquality {
-	bool operator()(const reference<T> &a, const reference<T> &b) const {
-		return &a.get() == &b.get();
-	}
-};
-
-template <typename T, typename TGT>
-using reference_map_t = unordered_map<reference<T>, TGT, ReferenceHashFunction<T>, ReferenceEquality<T>>;
-
-template <typename T>
-using reference_set_t = unordered_set<reference<T>, ReferenceHashFunction<T>, ReferenceEquality<T>>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/render_tree.hpp b/src/duckdb/src/include/duckdb/common/render_tree.hpp
deleted file mode 100644
index 0ef5a1b36..000000000
--- a/src/duckdb/src/include/duckdb/common/render_tree.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/render_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/main/profiling_node.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-struct RenderTreeNode {
-public:
-	static constexpr const char *CARDINALITY = "__cardinality__";
-	static constexpr const char *ESTIMATED_CARDINALITY = "__estimated_cardinality__";
-	static constexpr const char *TIMING = "__timing__";
-
-public:
-	struct Coordinate {
-	public:
-		Coordinate(idx_t x, idx_t y) : x(x), y(y) {
-		}
-
-	public:
-		idx_t x;
-		idx_t y;
-	};
-	RenderTreeNode(const string &name, InsertionOrderPreservingMap<string> extra_text)
-	    : name(name), extra_text(std::move(extra_text)) {
-	}
-
-public:
-	void AddChildPosition(idx_t x, idx_t y) {
-		child_positions.emplace_back(x, y);
-	}
-
-public:
-	string name;
-	InsertionOrderPreservingMap<string> extra_text;
-	vector<Coordinate> child_positions;
-};
-
-struct RenderTree {
-	RenderTree(idx_t width, idx_t height);
-
-	unique_array<unique_ptr<RenderTreeNode>> nodes;
-	idx_t width;
-	idx_t height;
-
-public:
-	static unique_ptr<RenderTree> CreateRenderTree(const LogicalOperator &op);
-	static unique_ptr<RenderTree> CreateRenderTree(const PhysicalOperator &op);
-	static unique_ptr<RenderTree> CreateRenderTree(const ProfilingNode &op);
-	static unique_ptr<RenderTree> CreateRenderTree(const Pipeline &op);
-
-public:
-	optional_ptr<RenderTreeNode> GetNode(idx_t x, idx_t y);
-	void SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node);
-	bool HasNode(idx_t x, idx_t y);
-	void SanitizeKeyNames();
-
-private:
-	idx_t GetPosition(idx_t x, idx_t y);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/row_operations/row_matcher.hpp b/src/duckdb/src/include/duckdb/common/row_operations/row_matcher.hpp
deleted file mode 100644
index 2b419b2f7..000000000
--- a/src/duckdb/src/include/duckdb/common/row_operations/row_matcher.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/row_operations/row_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-class Vector;
-class DataChunk;
-class TupleDataLayout;
-struct TupleDataVectorFormat;
-struct SelectionVector;
-struct MatchFunction;
-
-typedef idx_t (*match_function_t)(Vector &lhs_vector, const TupleDataVectorFormat &lhs_format, SelectionVector &sel,
-                                  const idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
-                                  const idx_t col_idx, const vector<MatchFunction> &child_functions,
-                                  SelectionVector *no_match_sel, idx_t &no_match_count);
-
-struct MatchFunction {
-	match_function_t function;
-	vector<MatchFunction> child_functions;
-};
-
-struct RowMatcher {
-public:
-	using Predicates = vector<ExpressionType>;
-
-	//! Initializes the RowMatcher, filling match_functions using layout and predicates
-	void Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates);
-
-	//! Initializes the RowMatcher, filling match_functions using layout and equality_predicates but only for the given
-	//! columns
-	void Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates,
-	                vector<column_t> &columns);
-
-	//! Given a DataChunk on the LHS, on which we've called TupleDataCollection::ToUnifiedFormat,
-	//! we match it with rows on the RHS, according to the given layout and locations.
-	//! Initially, 'sel' has 'count' entries which point to what needs to be compared.
-	//! After matching is done, this returns how many matching entries there are, which 'sel' is modified to point to
-	idx_t Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel, idx_t count,
-	            const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, SelectionVector *no_match_sel,
-	            idx_t &no_match_count);
-
-	//! Same as Match above, but only compares the column indexes in columns. Needs to be initialized with the same
-	//! columns.
-	idx_t Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel, idx_t count,
-	            const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, SelectionVector *no_match_sel,
-	            idx_t &no_match_count, const vector<column_t> &columns);
-
-private:
-	//! Gets the templated match function for a given column
-	MatchFunction GetMatchFunction(const bool no_match_sel, const LogicalType &type, const ExpressionType predicate);
-	template <bool NO_MATCH_SEL>
-	MatchFunction GetMatchFunction(const LogicalType &type, const ExpressionType predicate);
-	template <bool NO_MATCH_SEL, class T>
-	MatchFunction GetMatchFunction(const ExpressionType predicate);
-	template <bool NO_MATCH_SEL>
-	MatchFunction GetStructMatchFunction(const LogicalType &type, const ExpressionType predicate);
-	template <bool NO_MATCH_SEL>
-	MatchFunction GetListMatchFunction(const ExpressionType predicate);
-
-private:
-	vector<MatchFunction> match_functions;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp b/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp
deleted file mode 100644
index 06ae00f4e..000000000
--- a/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/row_operations/row_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-class ArenaAllocator;
-struct AggregateObject;
-struct AggregateFilterData;
-class DataChunk;
-class RowLayout;
-class TupleDataLayout;
-class RowDataCollection;
-struct SelectionVector;
-class StringHeap;
-class Vector;
-struct UnifiedVectorFormat;
-
-// The NestedValidity class help to set/get the validity from inside nested vectors
-class NestedValidity {
-	data_ptr_t list_validity_location;
-	data_ptr_t *struct_validity_locations;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	idx_t list_validity_offset;
-
-public:
-	explicit NestedValidity(data_ptr_t validitymask_location);
-	NestedValidity(data_ptr_t *validitymask_locations, idx_t child_vector_index);
-	void SetInvalid(idx_t idx);
-	bool IsValid(idx_t idx);
-	void OffsetListBy(idx_t offset);
-};
-
-struct RowOperationsState {
-	explicit RowOperationsState(ArenaAllocator &allocator) : allocator(allocator) {
-	}
-
-	ArenaAllocator &allocator;
-};
-
-// RowOperations contains a set of operations that operate on data using a RowLayout
-struct RowOperations {
-	//===--------------------------------------------------------------------===//
-	// Aggregation Operators
-	//===--------------------------------------------------------------------===//
-	//! initialize - unaligned addresses
-	static void InitializeStates(TupleDataLayout &layout, Vector &addresses, const SelectionVector &sel, idx_t count);
-	//! destructor - unaligned addresses, updated
-	static void DestroyStates(RowOperationsState &state, TupleDataLayout &layout, Vector &addresses, idx_t count);
-	//! update - aligned addresses
-	static void UpdateStates(RowOperationsState &state, AggregateObject &aggr, Vector &addresses, DataChunk &payload,
-	                         idx_t arg_idx, idx_t count);
-	//! filtered update - aligned addresses
-	static void UpdateFilteredStates(RowOperationsState &state, AggregateFilterData &filter_data, AggregateObject &aggr,
-	                                 Vector &addresses, DataChunk &payload, idx_t arg_idx);
-	//! combine - unaligned addresses, updated
-	static void CombineStates(RowOperationsState &state, TupleDataLayout &layout, Vector &sources, Vector &targets,
-	                          idx_t count);
-	//! finalize - unaligned addresses, updated
-	static void FinalizeStates(RowOperationsState &state, TupleDataLayout &layout, Vector &addresses, DataChunk &result,
-	                           idx_t aggr_idx);
-
-	//===--------------------------------------------------------------------===//
-	// Read/Write Operators
-	//===--------------------------------------------------------------------===//
-	//! Scatter group data to the rows. Initialises the ValidityMask.
-	static void Scatter(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
-	                    RowDataCollection &string_heap, const SelectionVector &sel, idx_t count);
-	//! Gather a single column.
-	//! If heap_ptr is not null, then the data is assumed to contain swizzled pointers,
-	//! which will be unswizzled in memory.
-	static void Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-	                   const idx_t count, const RowLayout &layout, const idx_t col_no, const idx_t build_size = 0,
-	                   data_ptr_t heap_ptr = nullptr);
-
-	//===--------------------------------------------------------------------===//
-	// Comparison Operators
-	//===--------------------------------------------------------------------===//
-	//! Compare a block of key data against the row values to produce an updated selection that matches
-	//! and a second (optional) selection of non-matching values.
-	//! Returns the number of matches remaining in the selection.
-	using Predicates = vector<ExpressionType>;
-
-	static idx_t Match(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout, Vector &rows,
-	                   const Predicates &predicates, SelectionVector &sel, idx_t count, SelectionVector *no_match,
-	                   idx_t &no_match_count);
-
-	//===--------------------------------------------------------------------===//
-	// Heap Operators
-	//===--------------------------------------------------------------------===//
-	//! Compute the entry sizes of a vector with variable size type (used before building heap buffer space).
-	static void ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-	                              const SelectionVector &sel, idx_t offset = 0);
-	//! Compute the entry sizes of vector data with variable size type (used before building heap buffer space).
-	static void ComputeEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t vcount,
-	                              idx_t ser_count, const SelectionVector &sel, idx_t offset = 0);
-	//! Scatter vector with variable size type to the heap.
-	static void HeapScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-	                        data_ptr_t *key_locations, optional_ptr<NestedValidity> parent_validity, idx_t offset = 0);
-	//! Scatter vector data with variable size type to the heap.
-	static void HeapScatterVData(UnifiedVectorFormat &vdata, PhysicalType type, const SelectionVector &sel,
-	                             idx_t ser_count, data_ptr_t *key_locations,
-	                             optional_ptr<NestedValidity> parent_validity, idx_t offset = 0);
-	//! Gather a single column with variable size type from the heap.
-	static void HeapGather(Vector &v, const idx_t &vcount, const SelectionVector &sel, data_ptr_t key_locations[],
-	                       optional_ptr<NestedValidity> parent_validity);
-
-	//===--------------------------------------------------------------------===//
-	// Sorting Operators
-	//===--------------------------------------------------------------------===//
-	//! Scatter vector data to the rows in radix-sortable format.
-	static void RadixScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-	                         data_ptr_t key_locations[], bool desc, bool has_null, bool nulls_first, idx_t prefix_len,
-	                         idx_t width, idx_t offset = 0);
-
-	//===--------------------------------------------------------------------===//
-	// Out-of-Core Operators
-	//===--------------------------------------------------------------------===//
-	//! Swizzles blob pointers to offset within heap row
-	static void SwizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count);
-	//! Swizzles the base pointer of each row to offset within heap block
-	static void SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-	                               const idx_t count, const idx_t base_offset = 0);
-	//! Copies 'count' heap rows that are pointed to by the rows at 'row_ptr' to 'heap_ptr' and swizzles the pointers
-	static void CopyHeapAndSwizzle(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-	                               data_ptr_t heap_ptr, const idx_t count);
-
-	//! Unswizzles the base offset within heap block the rows to pointers
-	static void UnswizzleHeapPointer(const RowLayout &layout, const data_ptr_t base_row_ptr,
-	                                 const data_ptr_t base_heap_ptr, const idx_t count);
-	//! Unswizzles all offsets back to pointers
-	static void UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
-	                              const data_ptr_t base_heap_ptr, const idx_t count);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp b/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp
deleted file mode 100644
index b291628a2..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/binary_deserializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/encoding_util.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-class BinaryDeserializer : public Deserializer {
-public:
-	explicit BinaryDeserializer(ReadStream &stream) : stream(stream) {
-		deserialize_enum_from_string = false;
-	}
-
-	template <class T>
-	unique_ptr<T> Deserialize() {
-		OnObjectBegin();
-		auto result = T::Deserialize(*this);
-		OnObjectEnd();
-		D_ASSERT(nesting_level == 0); // make sure we are at the root level
-		return result;
-	}
-
-	template <class T>
-	static unique_ptr<T> Deserialize(ReadStream &stream) {
-		BinaryDeserializer deserializer(stream);
-		return deserializer.template Deserialize<T>();
-	}
-
-	template <class T>
-	static unique_ptr<T> Deserialize(ReadStream &stream, ClientContext &context, bound_parameter_map_t &parameters) {
-		BinaryDeserializer deserializer(stream);
-		deserializer.Set<ClientContext &>(context);
-		deserializer.Set<bound_parameter_map_t &>(parameters);
-		return deserializer.template Deserialize<T>();
-	}
-
-	void Begin() {
-		OnObjectBegin();
-	}
-
-	void End() {
-		OnObjectEnd();
-		D_ASSERT(nesting_level == 0); // make sure we are at the root level
-	}
-
-	ReadStream &GetStream() {
-		return stream;
-	}
-
-private:
-	ReadStream &stream;
-	idx_t nesting_level = 0;
-
-	// Allow peeking 1 field ahead
-	bool has_buffered_field = false;
-	field_id_t buffered_field = 0;
-
-private:
-	field_id_t PeekField() {
-		if (!has_buffered_field) {
-			buffered_field = ReadPrimitive<field_id_t>();
-			has_buffered_field = true;
-		}
-		return buffered_field;
-	}
-	void ConsumeField() {
-		if (!has_buffered_field) {
-			buffered_field = ReadPrimitive<field_id_t>();
-		} else {
-			has_buffered_field = false;
-		}
-	}
-	field_id_t NextField() {
-		if (has_buffered_field) {
-			has_buffered_field = false;
-			return buffered_field;
-		}
-		return ReadPrimitive<field_id_t>();
-	}
-
-	void ReadData(data_ptr_t buffer, idx_t read_size) {
-		D_ASSERT(!has_buffered_field);
-		stream.ReadData(buffer, read_size);
-	}
-
-	template <class T>
-	T ReadPrimitive() {
-		T value;
-		ReadData(data_ptr_cast(&value), sizeof(T));
-		return value;
-	}
-
-	template <class T>
-	T VarIntDecode() {
-		// FIXME: maybe we should pass a source to EncodingUtil instead
-		uint8_t buffer[16] = {};
-		idx_t varint_size;
-		for (varint_size = 0; varint_size < 16; varint_size++) {
-			ReadData(buffer + varint_size, 1);
-			if (!(buffer[varint_size] & 0x80)) {
-				varint_size++;
-				break;
-			}
-		}
-		T value;
-		auto read_size = EncodingUtil::DecodeLEB128<T>(buffer, value);
-		D_ASSERT(read_size == varint_size);
-		(void)read_size;
-		return value;
-	}
-
-	//===--------------------------------------------------------------------===//
-	// Nested Types Hooks
-	//===--------------------------------------------------------------------===//
-	void OnPropertyBegin(const field_id_t field_id, const char *tag) final;
-	void OnPropertyEnd() final;
-	bool OnOptionalPropertyBegin(const field_id_t field_id, const char *tag) final;
-	void OnOptionalPropertyEnd(bool present) final;
-	void OnObjectBegin() final;
-	void OnObjectEnd() final;
-	idx_t OnListBegin() final;
-	void OnListEnd() final;
-	bool OnNullableBegin() final;
-	void OnNullableEnd() final;
-
-	//===--------------------------------------------------------------------===//
-	// Primitive Types
-	//===--------------------------------------------------------------------===//
-	bool ReadBool() final;
-	char ReadChar() final;
-	int8_t ReadSignedInt8() final;
-	uint8_t ReadUnsignedInt8() final;
-	int16_t ReadSignedInt16() final;
-	uint16_t ReadUnsignedInt16() final;
-	int32_t ReadSignedInt32() final;
-	uint32_t ReadUnsignedInt32() final;
-	int64_t ReadSignedInt64() final;
-	uint64_t ReadUnsignedInt64() final;
-	float ReadFloat() final;
-	double ReadDouble() final;
-	string ReadString() final;
-	hugeint_t ReadHugeInt() final;
-	uhugeint_t ReadUhugeInt() final;
-	void ReadDataPtr(data_ptr_t &ptr, idx_t count) final;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp b/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp
deleted file mode 100644
index 22d2c3f03..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/binary_serializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/serializer/encoding_util.hpp"
-#include "duckdb/common/serializer/serialization_data.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-
-namespace duckdb {
-
-class BinarySerializer : public Serializer {
-public:
-	explicit BinarySerializer(WriteStream &stream, SerializationOptions options_p = SerializationOptions())
-	    : stream(stream) {
-		options = std::move(options_p);
-		// Override the value set by the passed in SerializationOptions
-		options.serialize_enum_as_string = false;
-	}
-
-private:
-	struct DebugState {
-		unordered_set<const char *> seen_field_tags;
-		unordered_set<field_id_t> seen_field_ids;
-		vector<pair<const char *, field_id_t>> seen_fields;
-	};
-
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
-		stream.WriteData(buffer, write_size);
-	}
-
-	template <class T>
-	void Write(T element) {
-		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
-		WriteData(const_data_ptr_cast(&element), sizeof(T));
-	}
-	void WriteData(const char *ptr, idx_t write_size) {
-		WriteData(const_data_ptr_cast(ptr), write_size);
-	}
-
-	template <class T>
-	void VarIntEncode(T value) {
-		uint8_t buffer[16] = {};
-		auto write_size = EncodingUtil::EncodeLEB128<T>(buffer, value);
-		D_ASSERT(write_size <= sizeof(buffer));
-		WriteData(buffer, write_size);
-	}
-
-public:
-	template <class T>
-	static void Serialize(const T &value, WriteStream &stream, SerializationOptions options = SerializationOptions()) {
-		BinarySerializer serializer(stream, std::move(options));
-		serializer.OnObjectBegin();
-		value.Serialize(serializer);
-		serializer.OnObjectEnd();
-	}
-
-	void Begin() {
-		OnObjectBegin();
-	}
-	void End() {
-		OnObjectEnd();
-	}
-
-protected:
-	//-------------------------------------------------------------------------
-	// Nested Type Hooks
-	//-------------------------------------------------------------------------
-	// We serialize optional values as a message with a "present" flag, followed by the value.
-	void OnPropertyBegin(const field_id_t field_id, const char *tag) final;
-	void OnPropertyEnd() final;
-	void OnOptionalPropertyBegin(const field_id_t field_id, const char *tag, bool present) final;
-	void OnOptionalPropertyEnd(bool present) final;
-	void OnListBegin(idx_t count) final;
-	void OnListEnd() final;
-	void OnObjectBegin() final;
-	void OnObjectEnd() final;
-	void OnNullableBegin(bool present) final;
-	void OnNullableEnd() final;
-
-	//-------------------------------------------------------------------------
-	// Primitive Types
-	//-------------------------------------------------------------------------
-	void WriteNull() final;
-	void WriteValue(char value) final;
-	void WriteValue(uint8_t value) final;
-	void WriteValue(int8_t value) final;
-	void WriteValue(uint16_t value) final;
-	void WriteValue(int16_t value) final;
-	void WriteValue(uint32_t value) final;
-	void WriteValue(int32_t value) final;
-	void WriteValue(uint64_t value) final;
-	void WriteValue(int64_t value) final;
-	void WriteValue(hugeint_t value) final;
-	void WriteValue(uhugeint_t value) final;
-	void WriteValue(float value) final;
-	void WriteValue(double value) final;
-	void WriteValue(const string_t value) final;
-	void WriteValue(const string &value) final;
-	void WriteValue(const char *value) final;
-	void WriteValue(bool value) final;
-	void WriteDataPtr(const_data_ptr_t ptr, idx_t count) final;
-
-private:
-	vector<DebugState> debug_stack;
-	WriteStream &stream;
-
-protected:
-	duckdb::SerializationData data;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp b/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp
deleted file mode 100644
index f39062fe6..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_file_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-
-namespace duckdb {
-
-class BufferedFileReader : public ReadStream {
-public:
-	BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type = FileLockType::READ_LOCK,
-	                   optional_ptr<FileOpener> opener = nullptr);
-	BufferedFileReader(FileSystem &fs, unique_ptr<FileHandle> handle);
-
-	FileSystem &fs;
-	unsafe_unique_array<data_t> data;
-	idx_t offset;
-	idx_t read_data;
-	unique_ptr<FileHandle> handle;
-
-public:
-	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
-	//! Returns true if the reader has finished reading the entire file
-	bool Finished();
-
-	idx_t FileSize() {
-		return file_size;
-	}
-
-	//! Resets reading - beginning at position 0
-	void Reset();
-	void Seek(uint64_t location);
-	uint64_t CurrentOffset();
-
-private:
-	idx_t file_size;
-	idx_t total_read;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/buffered_file_writer.hpp b/src/duckdb/src/include/duckdb/common/serializer/buffered_file_writer.hpp
deleted file mode 100644
index 9b70b1730..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/buffered_file_writer.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_file_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/file_system.hpp"
-
-namespace duckdb {
-
-#define FILE_BUFFER_SIZE 4096
-
-class BufferedFileWriter : public WriteStream {
-public:
-	static constexpr FileOpenFlags DEFAULT_OPEN_FLAGS = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE;
-
-	//! Serializes to a buffer allocated by the serializer, will expand when
-	//! writing past the initial threshold
-	DUCKDB_API BufferedFileWriter(FileSystem &fs, const string &path, FileOpenFlags open_flags = DEFAULT_OPEN_FLAGS);
-
-	FileSystem &fs;
-	string path;
-	unsafe_unique_array<data_t> data;
-	idx_t offset;
-	idx_t total_written;
-	unique_ptr<FileHandle> handle;
-
-public:
-	DUCKDB_API void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-	//! Flush all changes to the file and then close the file
-	DUCKDB_API void Close();
-	//! Flush all changes and fsync the file to disk
-	DUCKDB_API void Sync();
-	//! Flush the buffer to the file (without sync)
-	DUCKDB_API void Flush();
-	//! Returns the current size of the file
-	DUCKDB_API idx_t GetFileSize();
-	//! Truncate the size to a previous size (given that size <= GetFileSize())
-	DUCKDB_API void Truncate(idx_t size);
-
-	DUCKDB_API idx_t GetTotalWritten() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/deserializer.hpp b/src/duckdb/src/include/duckdb/common/serializer/deserializer.hpp
deleted file mode 100644
index 835ea906e..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/deserializer.hpp
+++ /dev/null
@@ -1,560 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/deserializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/serializer/serialization_data.hpp"
-#include "duckdb/common/serializer/serialization_traits.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-
-namespace duckdb {
-
-class Deserializer {
-protected:
-	bool deserialize_enum_from_string = false;
-	SerializationData data;
-
-public:
-	virtual ~Deserializer() {
-	}
-
-	class List {
-		friend Deserializer;
-
-	private:
-		Deserializer &deserializer;
-		explicit List(Deserializer &deserializer) : deserializer(deserializer) {
-		}
-
-	public:
-		// Deserialize an element
-		template <class T>
-		T ReadElement();
-
-		//! Deserialize bytes
-		template <class T>
-		void ReadElement(data_ptr_t &ptr, idx_t size);
-
-		// Deserialize an object
-		template <class FUNC>
-		void ReadObject(FUNC f);
-	};
-
-public:
-	// Read into an existing value
-	template <typename T>
-	inline void ReadProperty(const field_id_t field_id, const char *tag, T &ret) {
-		OnPropertyBegin(field_id, tag);
-		ret = Read<T>();
-		OnPropertyEnd();
-	}
-
-	// Read and return a value
-	template <typename T>
-	inline T ReadProperty(const field_id_t field_id, const char *tag) {
-		OnPropertyBegin(field_id, tag);
-		auto ret = Read<T>();
-		OnPropertyEnd();
-		return ret;
-	}
-
-	// Default Value return
-	template <typename T>
-	inline T ReadPropertyWithDefault(const field_id_t field_id, const char *tag) {
-		if (!OnOptionalPropertyBegin(field_id, tag)) {
-			OnOptionalPropertyEnd(false);
-			return std::forward<T>(SerializationDefaultValue::GetDefault<T>());
-		}
-		auto ret = Read<T>();
-		OnOptionalPropertyEnd(true);
-		return ret;
-	}
-
-	template <typename T>
-	inline T ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T &&default_value) {
-		if (!OnOptionalPropertyBegin(field_id, tag)) {
-			OnOptionalPropertyEnd(false);
-			return std::forward<T>(default_value);
-		}
-		auto ret = Read<T>();
-		OnOptionalPropertyEnd(true);
-		return ret;
-	}
-
-	// Default value in place
-	template <typename T>
-	inline void ReadPropertyWithDefault(const field_id_t field_id, const char *tag, T &ret) {
-		if (!OnOptionalPropertyBegin(field_id, tag)) {
-			ret = std::forward<T>(SerializationDefaultValue::GetDefault<T>());
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		ret = Read<T>();
-		OnOptionalPropertyEnd(true);
-	}
-
-	template <typename T>
-	inline void ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T &ret, T &&default_value) {
-		if (!OnOptionalPropertyBegin(field_id, tag)) {
-			ret = std::forward<T>(default_value);
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		ret = Read<T>();
-		OnOptionalPropertyEnd(true);
-	}
-
-	template <typename T>
-	inline void ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, CSVOption<T> &ret,
-	                                            T &&default_value) {
-		if (!OnOptionalPropertyBegin(field_id, tag)) {
-			ret = std::forward<T>(default_value);
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		ret = Read<T>();
-		OnOptionalPropertyEnd(true);
-	}
-
-	// Special case:
-	// Read into an existing data_ptr_t
-	inline void ReadProperty(const field_id_t field_id, const char *tag, data_ptr_t ret, idx_t count) {
-		OnPropertyBegin(field_id, tag);
-		ReadDataPtr(ret, count);
-		OnPropertyEnd();
-	}
-
-	// Try to read a property, if it is not present, continue, otherwise read and discard the value
-	template <typename T>
-	inline void ReadDeletedProperty(const field_id_t field_id, const char *tag) {
-		// Try to read the property. If not present, great!
-		if (!OnOptionalPropertyBegin(field_id, tag)) {
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		// Otherwise read and discard the value
-		(void)Read<T>();
-		OnOptionalPropertyEnd(true);
-	}
-
-	//! Set a serialization property
-	template <class T>
-	void Set(T entry) {
-		return data.Set<T>(entry);
-	}
-
-	//! Retrieve the last set serialization property of this type
-	template <class T>
-	T Get() {
-		return data.Get<T>();
-	}
-
-	//! Unset a serialization property
-	template <class T>
-	void Unset() {
-		return data.Unset<T>();
-	}
-
-	SerializationData &GetSerializationData() {
-		return data;
-	}
-
-	void SetSerializationData(const SerializationData &other) {
-		data = other;
-	}
-
-	template <class FUNC>
-	void ReadList(const field_id_t field_id, const char *tag, FUNC func) {
-		OnPropertyBegin(field_id, tag);
-		auto size = OnListBegin();
-		List list {*this};
-		for (idx_t i = 0; i < size; i++) {
-			func(list, i);
-		}
-		OnListEnd();
-		OnPropertyEnd();
-	}
-
-	template <class FUNC>
-	void ReadObject(const field_id_t field_id, const char *tag, FUNC func) {
-		OnPropertyBegin(field_id, tag);
-		OnObjectBegin();
-		func(*this);
-		OnObjectEnd();
-		OnPropertyEnd();
-	}
-
-private:
-	// Deserialize anything implementing a Deserialize method
-	template <typename T = void>
-	inline typename std::enable_if<has_deserialize<T>::value, T>::type Read() {
-		OnObjectBegin();
-		auto val = T::Deserialize(*this);
-		OnObjectEnd();
-		return val;
-	}
-
-	// Deserialize a optionally_owned_ptr
-	template <class T, typename ELEMENT_TYPE = typename is_optionally_owned_ptr<T>::ELEMENT_TYPE>
-	inline typename std::enable_if<is_optionally_owned_ptr<T>::value, T>::type Read() {
-		return optionally_owned_ptr<ELEMENT_TYPE>(Read<unique_ptr<ELEMENT_TYPE>>());
-	}
-
-	// Deserialize unique_ptr if the element type has a Deserialize method
-	template <class T, typename ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE>
-	inline typename std::enable_if<is_unique_ptr<T>::value && has_deserialize<ELEMENT_TYPE>::value, T>::type Read() {
-		unique_ptr<ELEMENT_TYPE> ptr = nullptr;
-		auto is_present = OnNullableBegin();
-		if (is_present) {
-			OnObjectBegin();
-			ptr = ELEMENT_TYPE::Deserialize(*this);
-			OnObjectEnd();
-		}
-		OnNullableEnd();
-		return ptr;
-	}
-
-	// Deserialize a unique_ptr if the element type does not have a Deserialize method
-	template <class T, typename ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE>
-	inline typename std::enable_if<is_unique_ptr<T>::value && !has_deserialize<ELEMENT_TYPE>::value, T>::type Read() {
-		unique_ptr<ELEMENT_TYPE> ptr = nullptr;
-		auto is_present = OnNullableBegin();
-		if (is_present) {
-			OnObjectBegin();
-			ptr = make_uniq<ELEMENT_TYPE>(Read<ELEMENT_TYPE>());
-			OnObjectEnd();
-		}
-		OnNullableEnd();
-		return ptr;
-	}
-
-	// Deserialize shared_ptr
-	template <typename T = void>
-	inline typename std::enable_if<is_shared_ptr<T>::value, T>::type Read() {
-		using ELEMENT_TYPE = typename is_shared_ptr<T>::ELEMENT_TYPE;
-		shared_ptr<ELEMENT_TYPE> ptr = nullptr;
-		auto is_present = OnNullableBegin();
-		if (is_present) {
-			OnObjectBegin();
-			ptr = ELEMENT_TYPE::Deserialize(*this);
-			OnObjectEnd();
-		}
-		OnNullableEnd();
-		return ptr;
-	}
-
-	// Deserialize a vector
-	template <typename T = void>
-	inline typename std::enable_if<is_vector<T>::value, T>::type Read() {
-		using ELEMENT_TYPE = typename is_vector<T>::ELEMENT_TYPE;
-		T vec;
-		auto size = OnListBegin();
-		for (idx_t i = 0; i < size; i++) {
-			vec.push_back(Read<ELEMENT_TYPE>());
-		}
-		OnListEnd();
-		return vec;
-	}
-
-	template <typename T = void>
-	inline typename std::enable_if<is_unsafe_vector<T>::value, T>::type Read() {
-		using ELEMENT_TYPE = typename is_unsafe_vector<T>::ELEMENT_TYPE;
-		T vec;
-		auto size = OnListBegin();
-		for (idx_t i = 0; i < size; i++) {
-			vec.push_back(Read<ELEMENT_TYPE>());
-		}
-		OnListEnd();
-
-		return vec;
-	}
-
-	// Deserialize a map
-	template <typename T = void>
-	inline typename std::enable_if<is_unordered_map<T>::value, T>::type Read() {
-		using KEY_TYPE = typename is_unordered_map<T>::KEY_TYPE;
-		using VALUE_TYPE = typename is_unordered_map<T>::VALUE_TYPE;
-
-		T map;
-		auto size = OnListBegin();
-		for (idx_t i = 0; i < size; i++) {
-			OnObjectBegin();
-			auto key = ReadProperty<KEY_TYPE>(0, "key");
-			auto value = ReadProperty<VALUE_TYPE>(1, "value");
-			OnObjectEnd();
-			map[std::move(key)] = std::move(value);
-		}
-		OnListEnd();
-		return map;
-	}
-
-	template <typename T = void>
-	inline typename std::enable_if<is_map<T>::value, T>::type Read() {
-		using KEY_TYPE = typename is_map<T>::KEY_TYPE;
-		using VALUE_TYPE = typename is_map<T>::VALUE_TYPE;
-
-		T map;
-		auto size = OnListBegin();
-		for (idx_t i = 0; i < size; i++) {
-			OnObjectBegin();
-			auto key = ReadProperty<KEY_TYPE>(0, "key");
-			auto value = ReadProperty<VALUE_TYPE>(1, "value");
-			OnObjectEnd();
-			map[std::move(key)] = std::move(value);
-		}
-		OnListEnd();
-		return map;
-	}
-
-	template <typename T = void>
-	inline typename std::enable_if<is_insertion_preserving_map<T>::value, T>::type Read() {
-		using VALUE_TYPE = typename is_insertion_preserving_map<T>::VALUE_TYPE;
-
-		T map;
-		auto size = OnListBegin();
-		for (idx_t i = 0; i < size; i++) {
-			OnObjectBegin();
-			auto key = ReadProperty<string>(0, "key");
-			auto value = ReadProperty<VALUE_TYPE>(1, "value");
-			OnObjectEnd();
-			map[key] = std::move(value);
-		}
-		OnListEnd();
-		return map;
-	}
-
-	// Deserialize an unordered set
-	template <typename T = void>
-	inline typename std::enable_if<is_unordered_set<T>::value, T>::type Read() {
-		using ELEMENT_TYPE = typename is_unordered_set<T>::ELEMENT_TYPE;
-		auto size = OnListBegin();
-		T set;
-		for (idx_t i = 0; i < size; i++) {
-			set.insert(Read<ELEMENT_TYPE>());
-		}
-		OnListEnd();
-		return set;
-	}
-
-	// Deserialize a set
-	template <typename T = void>
-	inline typename std::enable_if<is_set<T>::value, T>::type Read() {
-		using ELEMENT_TYPE = typename is_set<T>::ELEMENT_TYPE;
-		auto size = OnListBegin();
-		T set;
-		for (idx_t i = 0; i < size; i++) {
-			set.insert(Read<ELEMENT_TYPE>());
-		}
-		OnListEnd();
-		return set;
-	}
-
-	// Deserialize a pair
-	template <typename T = void>
-	inline typename std::enable_if<is_pair<T>::value, T>::type Read() {
-		using FIRST_TYPE = typename is_pair<T>::FIRST_TYPE;
-		using SECOND_TYPE = typename is_pair<T>::SECOND_TYPE;
-		OnObjectBegin();
-		auto first = ReadProperty<FIRST_TYPE>(0, "first");
-		auto second = ReadProperty<SECOND_TYPE>(1, "second");
-		OnObjectEnd();
-		return std::make_pair(first, second);
-	}
-
-	// Deserialize a priority_queue
-	template <typename T = void>
-	inline typename std::enable_if<is_queue<T>::value, T>::type Read() {
-		using ELEMENT_TYPE = typename is_queue<T>::ELEMENT_TYPE;
-		T queue;
-		auto size = OnListBegin();
-		for (idx_t i = 0; i < size; i++) {
-			queue.emplace(Read<ELEMENT_TYPE>());
-		}
-		OnListEnd();
-		return queue;
-	}
-
-	// Primitive types
-	// Deserialize a bool
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, bool>::value, T>::type Read() {
-		return ReadBool();
-	}
-
-	// Deserialize a char
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, char>::value, T>::type Read() {
-		return ReadChar();
-	}
-
-	// Deserialize a int8_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, int8_t>::value, T>::type Read() {
-		return ReadSignedInt8();
-	}
-
-	// Deserialize a uint8_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, uint8_t>::value, T>::type Read() {
-		return ReadUnsignedInt8();
-	}
-
-	// Deserialize a int16_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, int16_t>::value, T>::type Read() {
-		return ReadSignedInt16();
-	}
-
-	// Deserialize a uint16_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, uint16_t>::value, T>::type Read() {
-		return ReadUnsignedInt16();
-	}
-
-	// Deserialize a int32_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, int32_t>::value, T>::type Read() {
-		return ReadSignedInt32();
-	}
-
-	// Deserialize a uint32_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, uint32_t>::value, T>::type Read() {
-		return ReadUnsignedInt32();
-	}
-
-	// Deserialize a int64_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, int64_t>::value, T>::type Read() {
-		return ReadSignedInt64();
-	}
-
-	// Deserialize a uint64_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, uint64_t>::value, T>::type Read() {
-		return ReadUnsignedInt64();
-	}
-
-	// Deserialize a float
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, float>::value, T>::type Read() {
-		return ReadFloat();
-	}
-
-	// Deserialize a double
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, double>::value, T>::type Read() {
-		return ReadDouble();
-	}
-
-	// Deserialize a string
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, string>::value, T>::type Read() {
-		return ReadString();
-	}
-
-	// Deserialize a Enum
-	template <typename T = void>
-	inline typename std::enable_if<std::is_enum<T>::value, T>::type Read() {
-		if (deserialize_enum_from_string) {
-			auto str = ReadString();
-			return EnumUtil::FromString<T>(str.c_str());
-		} else {
-			return (T)Read<typename std::underlying_type<T>::type>();
-		}
-	}
-
-	// Deserialize a hugeint_t
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, hugeint_t>::value, T>::type Read() {
-		return ReadHugeInt();
-	}
-
-	// Deserialize a uhugeint
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, uhugeint_t>::value, T>::type Read() {
-		return ReadUhugeInt();
-	}
-
-	// Deserialize a LogicalIndex
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, LogicalIndex>::value, T>::type Read() {
-		return LogicalIndex(ReadUnsignedInt64());
-	}
-
-	// Deserialize a PhysicalIndex
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, PhysicalIndex>::value, T>::type Read() {
-		return PhysicalIndex(ReadUnsignedInt64());
-	}
-
-	// Deserialize an optional_idx
-	template <typename T = void>
-	inline typename std::enable_if<std::is_same<T, optional_idx>::value, T>::type Read() {
-		auto idx = ReadUnsignedInt64();
-		return idx == DConstants::INVALID_INDEX ? optional_idx() : optional_idx(idx);
-	}
-
-protected:
-	// Hooks for subclasses to override to implement custom behavior
-	virtual void OnPropertyBegin(const field_id_t field_id, const char *tag) = 0;
-	virtual void OnPropertyEnd() = 0;
-	virtual bool OnOptionalPropertyBegin(const field_id_t field_id, const char *tag) = 0;
-	virtual void OnOptionalPropertyEnd(bool present) = 0;
-
-	virtual void OnObjectBegin() = 0;
-	virtual void OnObjectEnd() = 0;
-	virtual idx_t OnListBegin() = 0;
-	virtual void OnListEnd() = 0;
-	virtual bool OnNullableBegin() = 0;
-	virtual void OnNullableEnd() = 0;
-
-	// Handle primitive types, a serializer needs to implement these.
-	virtual bool ReadBool() = 0;
-	virtual char ReadChar() {
-		throw NotImplementedException("ReadChar not implemented");
-	}
-	virtual int8_t ReadSignedInt8() = 0;
-	virtual uint8_t ReadUnsignedInt8() = 0;
-	virtual int16_t ReadSignedInt16() = 0;
-	virtual uint16_t ReadUnsignedInt16() = 0;
-	virtual int32_t ReadSignedInt32() = 0;
-	virtual uint32_t ReadUnsignedInt32() = 0;
-	virtual int64_t ReadSignedInt64() = 0;
-	virtual uint64_t ReadUnsignedInt64() = 0;
-	virtual hugeint_t ReadHugeInt() = 0;
-	virtual uhugeint_t ReadUhugeInt() = 0;
-	virtual float ReadFloat() = 0;
-	virtual double ReadDouble() = 0;
-	virtual string ReadString() = 0;
-	virtual void ReadDataPtr(data_ptr_t &ptr, idx_t count) = 0;
-};
-
-template <class FUNC>
-void Deserializer::List::ReadObject(FUNC f) {
-	deserializer.OnObjectBegin();
-	f(deserializer);
-	deserializer.OnObjectEnd();
-}
-
-template <class T>
-T Deserializer::List::ReadElement() {
-	return deserializer.Read<T>();
-}
-
-template <class T>
-void Deserializer::List::ReadElement(data_ptr_t &ptr, idx_t size) {
-	deserializer.ReadDataPtr(ptr, size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/encoding_util.hpp b/src/duckdb/src/include/duckdb/common/serializer/encoding_util.hpp
deleted file mode 100644
index f30cf5790..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/encoding_util.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/encoding_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include <type_traits>
-
-namespace duckdb {
-
-struct EncodingUtil {
-
-	// Encode unsigned integer, returns the number of bytes written
-	template <class T>
-	static idx_t EncodeUnsignedLEB128(data_ptr_t target, T value) {
-		static_assert(std::is_integral<T>::value, "Must be integral");
-		static_assert(std::is_unsigned<T>::value, "Must be unsigned");
-		static_assert(sizeof(T) <= sizeof(uint64_t), "Must be uint64_t or smaller");
-
-		idx_t offset = 0;
-		do {
-			uint8_t byte = value & 0x7F;
-			value >>= 7;
-			if (value != 0) {
-				byte |= 0x80;
-			}
-			target[offset++] = byte;
-		} while (value != 0);
-		return offset;
-	}
-
-	// Decode unsigned integer, returns the number of bytes read
-	template <class T>
-	static idx_t DecodeUnsignedLEB128(const_data_ptr_t source, T &result) {
-		static_assert(std::is_integral<T>::value, "Must be integral");
-		static_assert(std::is_unsigned<T>::value, "Must be unsigned");
-		static_assert(sizeof(T) <= sizeof(uint64_t), "Must be uint64_t or smaller");
-
-		result = 0;
-		idx_t shift = 0;
-		idx_t offset = 0;
-		uint8_t byte;
-		do {
-			byte = source[offset++];
-			result |= static_cast<T>(byte & 0x7F) << shift;
-			shift += 7;
-		} while (byte & 0x80);
-
-		return offset;
-	}
-
-	// Encode signed integer, returns the number of bytes written
-	template <class T>
-	static idx_t EncodeSignedLEB128(data_ptr_t target, T value) {
-		static_assert(std::is_integral<T>::value, "Must be integral");
-		static_assert(std::is_signed<T>::value, "Must be signed");
-		static_assert(sizeof(T) <= sizeof(int64_t), "Must be int64_t or smaller");
-
-		idx_t offset = 0;
-		do {
-			uint8_t byte = value & 0x7F;
-			value >>= 7;
-
-			// Determine whether more bytes are needed
-			if ((value == 0 && (byte & 0x40) == 0) || (value == -1 && (byte & 0x40))) {
-				target[offset++] = byte;
-				break;
-			} else {
-				byte |= 0x80;
-				target[offset++] = byte;
-			}
-		} while (true);
-		return offset;
-	}
-
-	// Decode signed integer, returns the number of bytes read
-	template <class T>
-	static idx_t DecodeSignedLEB128(const_data_ptr_t source, T &result) {
-		static_assert(std::is_integral<T>::value, "Must be integral");
-		static_assert(std::is_signed<T>::value, "Must be signed");
-		static_assert(sizeof(T) <= sizeof(int64_t), "Must be int64_t or smaller");
-
-		// This is used to avoid undefined behavior when shifting into the sign bit
-		using unsigned_type = typename std::make_unsigned<T>::type;
-
-		result = 0;
-		idx_t shift = 0;
-		idx_t offset = 0;
-
-		uint8_t byte;
-		do {
-			byte = source[offset++];
-			result |= static_cast<unsigned_type>(byte & 0x7F) << shift;
-			shift += 7;
-		} while (byte & 0x80);
-
-		// Sign-extend if the most significant bit of the last byte is set
-		if (shift < sizeof(T) * 8 && (byte & 0x40)) {
-			result |= -(static_cast<unsigned_type>(1) << shift);
-		}
-		return offset;
-	}
-
-	template <class T>
-	static typename std::enable_if<std::is_signed<T>::value, idx_t>::type DecodeLEB128(const_data_ptr_t source,
-	                                                                                   T &result) {
-		return DecodeSignedLEB128(source, result);
-	}
-
-	template <class T>
-	static typename std::enable_if<std::is_unsigned<T>::value, idx_t>::type DecodeLEB128(const_data_ptr_t source,
-	                                                                                     T &result) {
-		return DecodeUnsignedLEB128(source, result);
-	}
-
-	template <class T>
-	static typename std::enable_if<std::is_signed<T>::value, idx_t>::type EncodeLEB128(data_ptr_t target, T value) {
-		return EncodeSignedLEB128(target, value);
-	}
-
-	template <class T>
-	static typename std::enable_if<std::is_unsigned<T>::value, idx_t>::type EncodeLEB128(data_ptr_t target, T value) {
-		return EncodeUnsignedLEB128(target, value);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp b/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp
deleted file mode 100644
index 863a99815..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/memory_stream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-namespace duckdb {
-
-class MemoryStream : public WriteStream, public ReadStream {
-private:
-	idx_t position;
-	idx_t capacity;
-	bool owns_data;
-	data_ptr_t data;
-
-public:
-	static constexpr idx_t DEFAULT_INITIAL_CAPACITY = 512;
-
-	// Create a new owning MemoryStream with an internal  backing buffer with the specified capacity. The stream will
-	// own the backing buffer, resize it when needed and free its memory when the stream is destroyed
-	explicit MemoryStream(idx_t capacity = DEFAULT_INITIAL_CAPACITY);
-
-	// Create a new non-owning MemoryStream over the specified external buffer and capacity. The stream will not take
-	// ownership of the backing buffer, will not attempt to resize it and will not free the memory when the stream
-	// is destroyed
-	explicit MemoryStream(data_ptr_t buffer, idx_t capacity);
-
-	// Cant copy!
-	MemoryStream(const MemoryStream &) = delete;
-	MemoryStream &operator=(const MemoryStream &) = delete;
-
-	MemoryStream(MemoryStream &&other) noexcept;
-	MemoryStream &operator=(MemoryStream &&other) noexcept;
-
-	~MemoryStream() override;
-
-	// Write data to the stream.
-	// Throws if the write would exceed the capacity of the stream and the backing buffer is not owned by the stream
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-
-	// Read data from the stream.
-	// Throws if the read would exceed the capacity of the stream
-	void ReadData(data_ptr_t buffer, idx_t read_size) override;
-
-	// Rewind the stream to the start, keeping the capacity and the backing buffer intact
-	void Rewind();
-
-	// Release ownership of the backing buffer and turn a owning stream into a non-owning one.
-	// The stream will no longer be responsible for freeing the data.
-	// The stream will also no longer attempt to automatically resize the buffer when the capacity is reached.
-	void Release();
-
-	// Get a pointer to the underlying backing buffer
-	data_ptr_t GetData() const;
-
-	// Get the current position in the stream
-	idx_t GetPosition() const;
-
-	// Get the capacity of the stream
-	idx_t GetCapacity() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/read_stream.hpp b/src/duckdb/src/include/duckdb/common/serializer/read_stream.hpp
deleted file mode 100644
index 18528d560..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/read_stream.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/read_stream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector.hpp"
-#include <type_traits>
-
-namespace duckdb {
-
-class ReadStream {
-public:
-	// Reads a set amount of data from the stream into the specified buffer and moves the stream forward accordingly
-	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
-
-	// Reads a type from the stream and moves the stream forward sizeof(T) bytes
-	// The type must be a standard layout type
-	template <class T>
-	T Read() {
-		static_assert(std::is_standard_layout<T>(), "Read element must be a standard layout data type");
-		T value;
-		ReadData(data_ptr_cast(&value), sizeof(T));
-		return value;
-	}
-
-	virtual ~ReadStream() {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/serialization_data.hpp b/src/duckdb/src/include/duckdb/common/serializer/serialization_data.hpp
deleted file mode 100644
index bdd52b572..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/serialization_data.hpp
+++ /dev/null
@@ -1,245 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/serialization_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/stack.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/enums/logical_operator_type.hpp"
-
-namespace duckdb {
-class ClientContext;
-class Catalog;
-class DatabaseInstance;
-class CompressionInfo;
-enum class ExpressionType : uint8_t;
-
-struct SerializationData {
-	struct CustomData {
-		virtual ~CustomData() = default;
-	};
-
-	stack<reference<ClientContext>> contexts;
-	stack<reference<DatabaseInstance>> databases;
-	stack<idx_t> enums;
-	stack<reference<bound_parameter_map_t>> parameter_data;
-	stack<const_reference<LogicalType>> types;
-	stack<const_reference<CompressionInfo>> compression_infos;
-	duckdb::unordered_map<std::string, duckdb::stack<duckdb::reference<CustomData>>> customs;
-
-	template <class T>
-	void Set(T entry) = delete;
-
-	template <class T>
-	T Get() = delete;
-
-	template <class T>
-	void Unset() = delete;
-
-	template <class T>
-	inline void AssertNotEmpty(const stack<T> &e) {
-		if (e.empty()) {
-			throw InternalException("SerializationData - unexpected empty stack");
-		}
-	}
-
-	template <typename T>
-	typename std::enable_if<std::is_base_of<CustomData, T>::value, T &>::type GetCustom() const {
-		std::string type = T::GetType();
-		auto iter = customs.find(type);
-		if (iter == customs.end()) {
-			throw duckdb::InternalException("SeserializationData - no stack for %s", type);
-		}
-		auto &stack = iter->second;
-		if (stack.empty()) {
-			throw duckdb::InternalException("SerializationData - unexpected empty stack for %s", type);
-		}
-		return dynamic_cast<T &>(stack.top().get());
-	}
-
-	template <typename T>
-	typename std::enable_if<std::is_base_of<CustomData, T>::value, void>::type SetCustom(T &data) {
-		std::string type = T::GetType();
-		auto iter = customs.find(type);
-		if (iter == customs.end()) {
-			iter = customs.emplace(type, duckdb::stack<duckdb::reference<CustomData>> {}).first;
-		}
-		auto &stack = iter->second;
-		stack.push(data);
-	}
-};
-
-template <>
-inline void SerializationData::Set(ExpressionType type) {
-	enums.push(idx_t(type));
-}
-
-template <>
-inline ExpressionType SerializationData::Get() {
-	AssertNotEmpty(enums);
-	return ExpressionType(enums.top());
-}
-
-template <>
-inline void SerializationData::Unset<ExpressionType>() {
-	AssertNotEmpty(enums);
-	enums.pop();
-}
-
-template <>
-inline void SerializationData::Set(LogicalOperatorType type) {
-	enums.push(idx_t(type));
-}
-
-template <>
-inline LogicalOperatorType SerializationData::Get() {
-	AssertNotEmpty(enums);
-	return LogicalOperatorType(enums.top());
-}
-
-template <>
-inline void SerializationData::Unset<LogicalOperatorType>() {
-	AssertNotEmpty(enums);
-	enums.pop();
-}
-
-template <>
-inline void SerializationData::Set(CompressionType type) {
-	enums.push(idx_t(type));
-}
-
-template <>
-inline CompressionType SerializationData::Get() {
-	AssertNotEmpty(enums);
-	return CompressionType(enums.top());
-}
-
-template <>
-inline void SerializationData::Unset<CompressionType>() {
-	AssertNotEmpty(enums);
-	enums.pop();
-}
-
-template <>
-inline void SerializationData::Set(CatalogType type) {
-	enums.push(idx_t(type));
-}
-
-template <>
-inline CatalogType SerializationData::Get() {
-	AssertNotEmpty(enums);
-	return CatalogType(enums.top());
-}
-
-template <>
-inline void SerializationData::Unset<CatalogType>() {
-	AssertNotEmpty(enums);
-	enums.pop();
-}
-
-template <>
-inline void SerializationData::Set(ClientContext &context) {
-	contexts.emplace(context);
-}
-
-template <>
-inline ClientContext &SerializationData::Get() {
-	AssertNotEmpty(contexts);
-	return contexts.top();
-}
-
-template <>
-inline void SerializationData::Unset<ClientContext>() {
-	AssertNotEmpty(contexts);
-	contexts.pop();
-}
-
-template <>
-inline void SerializationData::Set(DatabaseInstance &db) {
-	databases.emplace(db);
-}
-
-template <>
-inline DatabaseInstance &SerializationData::Get() {
-	AssertNotEmpty(databases);
-	return databases.top();
-}
-
-template <>
-inline void SerializationData::Unset<DatabaseInstance>() {
-	AssertNotEmpty(databases);
-	databases.pop();
-}
-
-template <>
-inline void SerializationData::Set(bound_parameter_map_t &context) {
-	parameter_data.emplace(context);
-}
-
-template <>
-inline bound_parameter_map_t &SerializationData::Get() {
-	AssertNotEmpty(parameter_data);
-	return parameter_data.top();
-}
-
-template <>
-inline void SerializationData::Unset<bound_parameter_map_t>() {
-	AssertNotEmpty(parameter_data);
-	parameter_data.pop();
-}
-
-template <>
-inline void SerializationData::Set(LogicalType &type) {
-	types.emplace(type);
-}
-
-template <>
-inline void SerializationData::Unset<LogicalType>() {
-	AssertNotEmpty(types);
-	types.pop();
-}
-
-template <>
-inline void SerializationData::Set(const LogicalType &type) {
-	types.emplace(type);
-}
-
-template <>
-inline const LogicalType &SerializationData::Get() {
-	AssertNotEmpty(types);
-	return types.top();
-}
-
-template <>
-inline void SerializationData::Unset<const LogicalType>() {
-	AssertNotEmpty(types);
-	types.pop();
-}
-
-template <>
-inline void SerializationData::Set(const CompressionInfo &compression_info) {
-	compression_infos.emplace(compression_info);
-}
-
-template <>
-inline const CompressionInfo &SerializationData::Get() {
-	AssertNotEmpty(compression_infos);
-	return compression_infos.top();
-}
-
-template <>
-inline void SerializationData::Unset<const CompressionInfo>() {
-	AssertNotEmpty(compression_infos);
-	compression_infos.pop();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp b/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp
deleted file mode 100644
index 5bde0f9a1..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp
+++ /dev/null
@@ -1,343 +0,0 @@
-#pragma once
-#include <type_traits>
-#include <cstdint>
-#include <atomic>
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/optionally_owned_ptr.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/insertion_order_preserving_map.hpp"
-
-namespace duckdb {
-
-class Serializer;   // Forward declare
-class Deserializer; // Forward declare
-
-typedef uint16_t field_id_t;
-const field_id_t MESSAGE_TERMINATOR_FIELD_ID = 0xFFFF;
-
-// Backport to c++11
-template <class...>
-using void_t = void;
-
-// NOLINTBEGIN: match STL case
-// Check for anything implementing a `void Serialize(Serializer &Serializer)` method
-template <typename T, typename = T>
-struct has_serialize : std::false_type {};
-
-template <typename T>
-struct has_serialize<
-    T, typename std::enable_if<
-           std::is_same<decltype(std::declval<T>().Serialize(std::declval<Serializer &>())), void>::value, T>::type>
-    : std::true_type {};
-
-template <typename T, typename = T>
-struct has_deserialize : std::false_type {};
-
-// Accept `static unique_ptr<T> Deserialize(Deserializer& deserializer)`
-template <typename T>
-struct has_deserialize<
-    T, typename std::enable_if<std::is_same<decltype(T::Deserialize), unique_ptr<T>(Deserializer &)>::value, T>::type>
-    : std::true_type {};
-
-// Accept `static shared_ptr<T> Deserialize(Deserializer& deserializer)`
-template <typename T>
-struct has_deserialize<
-    T, typename std::enable_if<std::is_same<decltype(T::Deserialize), shared_ptr<T>(Deserializer &)>::value, T>::type>
-    : std::true_type {};
-
-// Accept `static shared_ptr<T> Deserialize(Deserializer& deserializer)`
-template <typename T>
-struct has_deserialize<
-    T,
-    typename std::enable_if<std::is_same<decltype(T::Deserialize), std::shared_ptr<T>(Deserializer &)>::value, T>::type>
-    : std::true_type {};
-
-// Accept `static T Deserialize(Deserializer& deserializer)`
-template <typename T>
-struct has_deserialize<
-    T, typename std::enable_if<std::is_same<decltype(T::Deserialize), T(Deserializer &)>::value, T>::type>
-    : std::true_type {};
-
-// Check if T is a vector, and provide access to the inner type
-template <typename T>
-struct is_vector : std::false_type {};
-template <typename T>
-struct is_vector<typename duckdb::vector<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-template <typename T>
-struct is_unsafe_vector : std::false_type {};
-template <typename T>
-struct is_unsafe_vector<typename duckdb::unsafe_vector<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-// Check if T is a unordered map, and provide access to the inner type
-template <typename T>
-struct is_unordered_map : std::false_type {};
-template <typename... Args>
-struct is_unordered_map<typename duckdb::unordered_map<Args...>> : std::true_type {
-	typedef typename std::tuple_element<0, std::tuple<Args...>>::type KEY_TYPE;
-	typedef typename std::tuple_element<1, std::tuple<Args...>>::type VALUE_TYPE;
-	typedef typename std::tuple_element<2, std::tuple<Args...>>::type HASH_TYPE;
-	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
-};
-
-template <typename T>
-struct is_map : std::false_type {};
-template <typename... Args>
-struct is_map<typename duckdb::map<Args...>> : std::true_type {
-	typedef typename std::tuple_element<0, std::tuple<Args...>>::type KEY_TYPE;
-	typedef typename std::tuple_element<1, std::tuple<Args...>>::type VALUE_TYPE;
-	typedef typename std::tuple_element<2, std::tuple<Args...>>::type HASH_TYPE;
-	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
-};
-
-template <typename T>
-struct is_insertion_preserving_map : std::false_type {};
-template <typename... Args>
-struct is_insertion_preserving_map<typename duckdb::InsertionOrderPreservingMap<Args...>> : std::true_type {
-	typedef typename std::tuple_element<0, std::tuple<Args...>>::type VALUE_TYPE;
-};
-
-template <typename T>
-struct is_queue : std::false_type {};
-template <typename T>
-struct is_queue<typename std::priority_queue<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-template <typename T>
-struct is_unique_ptr : std::false_type {};
-template <typename T>
-struct is_unique_ptr<unique_ptr<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-template <typename T>
-struct is_shared_ptr : std::false_type {};
-template <typename T>
-struct is_shared_ptr<shared_ptr<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-template <typename T>
-struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-template <typename T>
-struct is_optional_ptr : std::false_type {};
-template <typename T>
-struct is_optional_ptr<optional_ptr<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-template <typename T>
-struct is_optionally_owned_ptr : std::false_type {};
-template <typename T>
-struct is_optionally_owned_ptr<optionally_owned_ptr<T>> : std::true_type {
-	typedef T ELEMENT_TYPE;
-};
-
-template <typename T>
-struct is_pair : std::false_type {};
-template <typename T, typename U>
-struct is_pair<std::pair<T, U>> : std::true_type {
-	typedef T FIRST_TYPE;
-	typedef U SECOND_TYPE;
-};
-
-template <typename T>
-struct is_unordered_set : std::false_type {};
-template <typename... Args>
-struct is_unordered_set<duckdb::unordered_set<Args...>> : std::true_type {
-	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
-	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
-	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
-};
-
-template <typename T>
-struct is_set : std::false_type {};
-template <typename... Args>
-struct is_set<duckdb::set<Args...>> : std::true_type {
-	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
-	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
-	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
-};
-
-template <typename T>
-struct is_atomic : std::false_type {};
-
-template <typename T>
-struct is_atomic<std::atomic<T>> : std::true_type {
-	typedef T TYPE;
-};
-
-// NOLINTEND
-
-struct SerializationDefaultValue {
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_atomic<T>::value, T>::type GetDefault() {
-		using INNER = typename is_atomic<T>::TYPE;
-		return static_cast<T>(GetDefault<INNER>());
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_atomic<T>::value, T>::type &value) {
-		using INNER = typename is_atomic<T>::TYPE;
-		return value == GetDefault<INNER>();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type GetDefault() {
-		return static_cast<T>(0);
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<std::is_arithmetic<T>::value, T>::type &value) {
-		return value == static_cast<T>(0);
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_unique_ptr<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_unique_ptr<T>::value, T>::type &value) {
-		return !value;
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_optional_ptr<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_optional_ptr<T>::value, T>::type &value) {
-		return !value;
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_optionally_owned_ptr<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_optionally_owned_ptr<T>::value, T>::type &value) {
-		return !value;
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_shared_ptr<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_shared_ptr<T>::value, T>::type &value) {
-		return !value;
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_vector<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_vector<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_queue<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_queue<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_unsafe_vector<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_unsafe_vector<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_unordered_set<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_unordered_set<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_unordered_map<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_unordered_map<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_map<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_map<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<is_insertion_preserving_map<T>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<is_insertion_preserving_map<T>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<std::is_same<T, string>::value, T>::type GetDefault() {
-		return T();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<std::is_same<T, string>::value, T>::type &value) {
-		return value.empty();
-	}
-
-	template <typename T = void>
-	static inline typename std::enable_if<std::is_same<T, optional_idx>::value, T>::type GetDefault() {
-		return optional_idx();
-	}
-
-	template <typename T = void>
-	static inline bool IsDefault(const typename std::enable_if<std::is_same<T, optional_idx>::value, T>::type &value) {
-		return !value.IsValid();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/serializer.hpp b/src/duckdb/src/include/duckdb/common/serializer/serializer.hpp
deleted file mode 100644
index 54b994e4b..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/serializer.hpp
+++ /dev/null
@@ -1,395 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/serializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/serializer/serialization_traits.hpp"
-#include "duckdb/common/serializer/serialization_data.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/optionally_owned_ptr.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/insertion_order_preserving_map.hpp"
-
-namespace duckdb {
-
-class SerializationOptions {
-public:
-	bool serialize_enum_as_string = false;
-	bool serialize_default_values = false;
-	SerializationCompatibility serialization_compatibility = SerializationCompatibility::Default();
-};
-
-class Serializer {
-protected:
-	SerializationOptions options;
-	SerializationData data;
-
-public:
-	virtual ~Serializer() {
-	}
-
-	bool ShouldSerialize(idx_t version_added) {
-		return options.serialization_compatibility.Compare(version_added);
-	}
-
-	class List {
-		friend Serializer;
-
-	private:
-		Serializer &serializer;
-		explicit List(Serializer &serializer) : serializer(serializer) {
-		}
-
-	public:
-		// Serialize an element
-		template <class T>
-		void WriteElement(const T &value);
-
-		//! Serialize bytes
-		void WriteElement(data_ptr_t ptr, idx_t size);
-
-		// Serialize an object
-		template <class FUNC>
-		void WriteObject(FUNC f);
-	};
-
-public:
-	SerializationData &GetSerializationData() {
-		return data;
-	}
-
-	void SetSerializationData(const SerializationData &other) {
-		data = other;
-	}
-
-	// Serialize a value
-	template <class T>
-	void WriteProperty(const field_id_t field_id, const char *tag, const T &value) {
-		OnPropertyBegin(field_id, tag);
-		WriteValue(value);
-		OnPropertyEnd();
-	}
-
-	// Default value
-	template <class T>
-	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const T &value) {
-		// If current value is default, don't write it
-		if (!options.serialize_default_values && SerializationDefaultValue::IsDefault<T>(value)) {
-			OnOptionalPropertyBegin(field_id, tag, false);
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		OnOptionalPropertyBegin(field_id, tag, true);
-		WriteValue(value);
-		OnOptionalPropertyEnd(true);
-	}
-
-	template <class T>
-	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const T &value, const T &&default_value) {
-		// If current value is default, don't write it
-		if (!options.serialize_default_values && (value == default_value)) {
-			OnOptionalPropertyBegin(field_id, tag, false);
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		OnOptionalPropertyBegin(field_id, tag, true);
-		WriteValue(value);
-		OnOptionalPropertyEnd(true);
-	}
-
-	// Specialization for Value (default Value comparison throws when comparing nulls)
-	template <class T>
-	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const CSVOption<T> &value,
-	                              const T &&default_value) {
-		// If current value is default, don't write it
-		if (!options.serialize_default_values && (value == default_value)) {
-			OnOptionalPropertyBegin(field_id, tag, false);
-			OnOptionalPropertyEnd(false);
-			return;
-		}
-		OnOptionalPropertyBegin(field_id, tag, true);
-		WriteValue(value.GetValue());
-		OnOptionalPropertyEnd(true);
-	}
-
-	// Special case: data_ptr_T
-	void WriteProperty(const field_id_t field_id, const char *tag, const_data_ptr_t ptr, idx_t count) {
-		OnPropertyBegin(field_id, tag);
-		WriteDataPtr(ptr, count);
-		OnPropertyEnd();
-	}
-
-	// Manually begin an object
-	template <class FUNC>
-	void WriteObject(const field_id_t field_id, const char *tag, FUNC f) {
-		OnPropertyBegin(field_id, tag);
-		OnObjectBegin();
-		f(*this);
-		OnObjectEnd();
-		OnPropertyEnd();
-	}
-
-	template <class FUNC>
-	void WriteList(const field_id_t field_id, const char *tag, idx_t count, FUNC func) {
-		OnPropertyBegin(field_id, tag);
-		OnListBegin(count);
-		List list {*this};
-		for (idx_t i = 0; i < count; i++) {
-			func(list, i);
-		}
-		OnListEnd();
-		OnPropertyEnd();
-	}
-
-protected:
-	template <typename T>
-	typename std::enable_if<std::is_enum<T>::value, void>::type WriteValue(const T value) {
-		if (options.serialize_enum_as_string) {
-			// Use the enum serializer to lookup tostring function
-			auto str = EnumUtil::ToChars(value);
-			WriteValue(str);
-		} else {
-			// Use the underlying type
-			WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
-		}
-	}
-
-	// Optionally Owned Pointer Ref
-	template <typename T>
-	void WriteValue(const optionally_owned_ptr<T> &ptr) {
-		WriteValue(ptr.get());
-	}
-
-	// Unique Pointer Ref
-	template <typename T>
-	void WriteValue(const unique_ptr<T> &ptr) {
-		WriteValue(ptr.get());
-	}
-
-	// Shared Pointer Ref
-	template <typename T>
-	void WriteValue(const shared_ptr<T> &ptr) {
-		WriteValue(ptr.get());
-	}
-
-	// Pointer
-	template <typename T>
-	void WriteValue(const T *ptr) {
-		if (ptr == nullptr) {
-			OnNullableBegin(false);
-			OnNullableEnd();
-		} else {
-			OnNullableBegin(true);
-			WriteValue(*ptr);
-			OnNullableEnd();
-		}
-	}
-
-	// Pair
-	template <class K, class V>
-	void WriteValue(const std::pair<K, V> &pair) {
-		OnObjectBegin();
-		WriteProperty(0, "first", pair.first);
-		WriteProperty(1, "second", pair.second);
-		OnObjectEnd();
-	}
-
-	// Reference Wrapper
-	template <class T>
-	void WriteValue(const reference<T> ref) {
-		WriteValue(ref.get());
-	}
-
-	// Vector
-	template <class T>
-	void WriteValue(const vector<T> &vec) {
-		auto count = vec.size();
-		OnListBegin(count);
-		for (auto &item : vec) {
-			WriteValue(item);
-		}
-		OnListEnd();
-	}
-
-	template <class T>
-	void WriteValue(const unsafe_vector<T> &vec) {
-		auto count = vec.size();
-		OnListBegin(count);
-		for (auto &item : vec) {
-			WriteValue(item);
-		}
-		OnListEnd();
-	}
-
-	// UnorderedSet
-	// Serialized the same way as a list/vector
-	template <class T, class HASH, class CMP>
-	void WriteValue(const duckdb::unordered_set<T, HASH, CMP> &set) {
-		auto count = set.size();
-		OnListBegin(count);
-		for (auto &item : set) {
-			WriteValue(item);
-		}
-		OnListEnd();
-	}
-
-	// Set
-	// Serialized the same way as a list/vector
-	template <class T, class HASH, class CMP>
-	void WriteValue(const duckdb::set<T, HASH, CMP> &set) {
-		auto count = set.size();
-		OnListBegin(count);
-		for (auto &item : set) {
-			WriteValue(item);
-		}
-		OnListEnd();
-	}
-
-	// Map
-	// serialized as a list of pairs
-	template <class K, class V, class HASH, class CMP>
-	void WriteValue(const duckdb::unordered_map<K, V, HASH, CMP> &map) {
-		auto count = map.size();
-		OnListBegin(count);
-		for (auto &item : map) {
-			OnObjectBegin();
-			WriteProperty(0, "key", item.first);
-			WriteProperty(1, "value", item.second);
-			OnObjectEnd();
-		}
-		OnListEnd();
-	}
-
-	// Map
-	// serialized as a list of pairs
-	template <class K, class V, class HASH, class CMP>
-	void WriteValue(const duckdb::map<K, V, HASH, CMP> &map) {
-		auto count = map.size();
-		OnListBegin(count);
-		for (auto &item : map) {
-			OnObjectBegin();
-			WriteProperty(0, "key", item.first);
-			WriteProperty(1, "value", item.second);
-			OnObjectEnd();
-		}
-		OnListEnd();
-	}
-
-	// Insertion Order Preserving Map
-	// serialized as a list of pairs
-	template <class V>
-	void WriteValue(const duckdb::InsertionOrderPreservingMap<V> &map) {
-		auto count = map.size();
-		OnListBegin(count);
-		for (auto &entry : map) {
-			OnObjectBegin();
-			WriteProperty(0, "key", entry.first);
-			WriteProperty(1, "value", entry.second);
-			OnObjectEnd();
-		}
-		OnListEnd();
-	}
-
-	// priority queue
-	template <typename T>
-	void WriteValue(const std::priority_queue<T> &queue) {
-		vector<T> placeholder;
-		auto queue_copy = std::priority_queue<T>(queue);
-		while (queue_copy.size() > 0) {
-			placeholder.emplace_back(queue_copy.top());
-			queue_copy.pop();
-		}
-		WriteValue(placeholder);
-	}
-
-	// class or struct implementing `Serialize(Serializer& Serializer)`;
-	template <typename T>
-	typename std::enable_if<has_serialize<T>::value>::type WriteValue(const T &value) {
-		OnObjectBegin();
-		value.Serialize(*this);
-		OnObjectEnd();
-	}
-
-protected:
-	// Hooks for subclasses to override to implement custom behavior
-	virtual void OnPropertyBegin(const field_id_t field_id, const char *tag) = 0;
-	virtual void OnPropertyEnd() = 0;
-	virtual void OnOptionalPropertyBegin(const field_id_t field_id, const char *tag, bool present) = 0;
-	virtual void OnOptionalPropertyEnd(bool present) = 0;
-	virtual void OnObjectBegin() = 0;
-	virtual void OnObjectEnd() = 0;
-	virtual void OnListBegin(idx_t count) = 0;
-	virtual void OnListEnd() = 0;
-	virtual void OnNullableBegin(bool present) = 0;
-	virtual void OnNullableEnd() = 0;
-
-	// Handle primitive types, a serializer needs to implement these.
-	virtual void WriteNull() = 0;
-	virtual void WriteValue(char value) {
-		throw NotImplementedException("Write char value not implemented");
-	}
-	virtual void WriteValue(bool value) = 0;
-	virtual void WriteValue(uint8_t value) = 0;
-	virtual void WriteValue(int8_t value) = 0;
-	virtual void WriteValue(uint16_t value) = 0;
-	virtual void WriteValue(int16_t value) = 0;
-	virtual void WriteValue(uint32_t value) = 0;
-	virtual void WriteValue(int32_t value) = 0;
-	virtual void WriteValue(uint64_t value) = 0;
-	virtual void WriteValue(int64_t value) = 0;
-	virtual void WriteValue(hugeint_t value) = 0;
-	virtual void WriteValue(uhugeint_t value) = 0;
-	virtual void WriteValue(float value) = 0;
-	virtual void WriteValue(double value) = 0;
-	virtual void WriteValue(const string_t value) = 0;
-	virtual void WriteValue(const string &value) = 0;
-	virtual void WriteValue(const char *str) = 0;
-	virtual void WriteDataPtr(const_data_ptr_t ptr, idx_t count) = 0;
-	void WriteValue(LogicalIndex value) {
-		WriteValue(value.index);
-	}
-	void WriteValue(PhysicalIndex value) {
-		WriteValue(value.index);
-	}
-	void WriteValue(optional_idx value) {
-		WriteValue(value.IsValid() ? value.GetIndex() : DConstants::INVALID_INDEX);
-	}
-};
-
-// We need to special case vector<bool> because elements of vector<bool> cannot be referenced
-template <>
-void Serializer::WriteValue(const vector<bool> &vec);
-
-// Specialization for Value (default Value comparison throws when comparing nulls)
-template <>
-void Serializer::WritePropertyWithDefault<Value>(const field_id_t field_id, const char *tag, const Value &value,
-                                                 const Value &&default_value);
-
-// List Impl
-template <class FUNC>
-void Serializer::List::WriteObject(FUNC f) {
-	serializer.OnObjectBegin();
-	f(serializer);
-	serializer.OnObjectEnd();
-}
-
-template <class T>
-void Serializer::List::WriteElement(const T &value) {
-	serializer.WriteValue(value);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/serializer/write_stream.hpp b/src/duckdb/src/include/duckdb/common/serializer/write_stream.hpp
deleted file mode 100644
index 667400aba..000000000
--- a/src/duckdb/src/include/duckdb/common/serializer/write_stream.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/write_stream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector.hpp"
-#include <type_traits>
-
-namespace duckdb {
-
-class WriteStream {
-public:
-	// Writes a set amount of data from the specified buffer into the stream and moves the stream forward accordingly
-	virtual void WriteData(const_data_ptr_t buffer, idx_t write_size) = 0;
-
-	// Writes a type into the stream and moves the stream forward sizeof(T) bytes
-	// The type must be a standard layout type
-	template <class T>
-	void Write(T element) {
-		static_assert(std::is_standard_layout<T>(), "Write element must be a standard layout data type");
-		WriteData(const_data_ptr_cast(&element), sizeof(T));
-	}
-
-	virtual ~WriteStream() {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/set.hpp b/src/duckdb/src/include/duckdb/common/set.hpp
deleted file mode 100644
index aee25d93e..000000000
--- a/src/duckdb/src/include/duckdb/common/set.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <set>
-
-namespace duckdb {
-using std::multiset;
-using std::set;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/shared_ptr.hpp b/src/duckdb/src/include/duckdb/common/shared_ptr.hpp
deleted file mode 100644
index eff60e3db..000000000
--- a/src/duckdb/src/include/duckdb/common/shared_ptr.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/shared_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/memory_safety.hpp"
-
-#include <memory>
-#include <type_traits>
-
-namespace duckdb {
-
-// This implementation is taken from the llvm-project, at this commit hash:
-// https://github.com/llvm/llvm-project/blob/08bb121835be432ac52372f92845950628ce9a4a/libcxx/include/__memory/shared_ptr.h#353
-// originally named '__compatible_with'
-
-#if _LIBCPP_STD_VER >= 17
-template <class U, class T>
-struct __bounded_convertible_to_unbounded : std::false_type {};
-
-template <class _Up, std::size_t _Np, class T>
-struct __bounded_convertible_to_unbounded<_Up[_Np], T> : std::is_same<std::remove_cv<T>, _Up[]> {};
-
-template <class U, class T>
-struct compatible_with_t : std::_Or<std::is_convertible<U *, T *>, __bounded_convertible_to_unbounded<U, T>> {};
-#else
-template <class U, class T>
-struct compatible_with_t : std::is_convertible<U *, T *> {}; // NOLINT: invalid case style
-#endif // _LIBCPP_STD_VER >= 17
-
-} // namespace duckdb
-
-#include "duckdb/common/shared_ptr_ipp.hpp"
-#include "duckdb/common/weak_ptr_ipp.hpp"
-#include "duckdb/common/enable_shared_from_this_ipp.hpp"
-
-namespace duckdb {
-
-template <typename T>
-using unsafe_shared_ptr = shared_ptr<T, false>;
-
-template <typename T>
-using unsafe_weak_ptr = weak_ptr<T, false>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp b/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp
deleted file mode 100644
index d046dc141..000000000
--- a/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp
+++ /dev/null
@@ -1,268 +0,0 @@
-namespace duckdb {
-
-template <typename T, bool SAFE = true>
-class weak_ptr;
-
-template <class T>
-class enable_shared_from_this;
-
-template <typename T, bool SAFE = true>
-class shared_ptr { // NOLINT: invalid case style
-public:
-	using original = std::shared_ptr<T>;
-	using element_type = typename original::element_type;
-	using weak_type = weak_ptr<T, SAFE>;
-
-private:
-	static inline void AssertNotNull(const bool null) {
-#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
-		return;
-#else
-		if (DUCKDB_UNLIKELY(null)) {
-			throw duckdb::InternalException("Attempted to dereference shared_ptr that is NULL!");
-		}
-#endif
-	}
-
-private:
-	template <class U, bool SAFE_P>
-	friend class weak_ptr;
-
-	template <class U, bool SAFE_P>
-	friend class shared_ptr;
-
-	template <typename U, typename S>
-	friend shared_ptr<S> shared_ptr_cast(shared_ptr<U> src); // NOLINT: invalid case style
-
-private:
-	original internal;
-
-public:
-	// Constructors
-	shared_ptr() : internal() {
-	}
-	shared_ptr(std::nullptr_t) : internal(nullptr) { // NOLINT: not marked as explicit
-	}
-
-	// From raw pointer of type U convertible to T
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	explicit shared_ptr(U *ptr) : internal(ptr) {
-		__enable_weak_this(internal.get(), internal.get());
-	}
-	// From raw pointer of type T with custom DELETER
-	template <typename DELETER>
-	shared_ptr(T *ptr, DELETER deleter) : internal(ptr, deleter) {
-		__enable_weak_this(internal.get(), internal.get());
-	}
-	// Aliasing constructor: shares ownership information with ref but contains ptr instead
-	// When the created shared_ptr goes out of scope, it will call the DELETER of ref, will not delete ptr
-	template <class U>
-	shared_ptr(const shared_ptr<U> &ref, T *ptr) noexcept : internal(ref.internal, ptr) {
-	}
-#if _LIBCPP_STD_VER >= 20
-	template <class U>
-	shared_ptr(shared_ptr<U> &&ref, T *ptr) noexcept : internal(std::move(ref.internal), ptr) {
-	}
-#endif
-
-	// Copy constructor, share ownership with ref
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	shared_ptr(const shared_ptr<U> &ref) noexcept : internal(ref.internal) { // NOLINT: not marked as explicit
-	}
-	shared_ptr(const shared_ptr &other) : internal(other.internal) { // NOLINT: not marked as explicit
-	}
-	// Move constructor, share ownership with ref
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	shared_ptr(shared_ptr<U> &&ref) noexcept // NOLINT: not marked as explicit
-	    : internal(std::move(ref.internal)) {
-	}
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	shared_ptr(shared_ptr<T> &&other) // NOLINT: not marked as explicit
-	    : internal(std::move(other.internal)) {
-	}
-
-	// Construct from std::shared_ptr
-	explicit shared_ptr(std::shared_ptr<T> other) : internal(other) {
-		// FIXME: should we __enable_weak_this here?
-		// *our* enable_shared_from_this hasn't initialized yet, so I think so?
-		__enable_weak_this(internal.get(), internal.get());
-	}
-
-	// Construct from weak_ptr
-	template <class U>
-	explicit shared_ptr(weak_ptr<U> other) : internal(other.internal) {
-	}
-
-	// Construct from unique_ptr, takes over ownership of the unique_ptr
-	template <class U, class DELETER, bool SAFE_P,
-	          typename std::enable_if<compatible_with_t<U, T>::value &&
-	                                      std::is_convertible<typename unique_ptr<U, DELETER>::pointer, T *>::value,
-	                                  int>::type = 0>
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	shared_ptr(unique_ptr<U, DELETER, SAFE_P> &&other) // NOLINT: not marked as explicit
-	    : internal(std::move(other)) {
-		__enable_weak_this(internal.get(), internal.get());
-	}
-
-	// Destructor
-	~shared_ptr() = default;
-
-	// Assign from shared_ptr copy
-	shared_ptr<T> &operator=(const shared_ptr &other) noexcept {
-		if (this == &other) {
-			return *this;
-		}
-		// Create a new shared_ptr using the copy constructor, then swap out the ownership to *this
-		shared_ptr(other).swap(*this);
-		return *this;
-	}
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	shared_ptr<T> &operator=(const shared_ptr<U> &other) {
-		shared_ptr(other).swap(*this);
-		return *this;
-	}
-
-	// Assign from moved shared_ptr
-	shared_ptr<T> &operator=(shared_ptr &&other) noexcept {
-		// Create a new shared_ptr using the move constructor, then swap out the ownership to *this
-		shared_ptr(std::move(other)).swap(*this);
-		return *this;
-	}
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	shared_ptr<T> &operator=(shared_ptr<U> &&other) {
-		shared_ptr(std::move(other)).swap(*this);
-		return *this;
-	}
-
-	// Assign from moved unique_ptr
-	template <class U, class DELETER, bool SAFE_P,
-	          typename std::enable_if<compatible_with_t<U, T>::value &&
-	                                      std::is_convertible<typename unique_ptr<U, DELETER>::pointer, T *>::value,
-	                                  int>::type = 0>
-	shared_ptr<T> &operator=(unique_ptr<U, DELETER, SAFE_P> &&ref) {
-		shared_ptr(std::move(ref)).swap(*this);
-		return *this;
-	}
-
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	void
-	reset() { // NOLINT: invalid case style
-		internal.reset();
-	}
-	template <typename U>
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	void
-	reset(U *ptr) { // NOLINT: invalid case style
-		internal.reset(ptr);
-	}
-	template <typename U, typename DELETER>
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	void
-	reset(U *ptr, DELETER deleter) { // NOLINT: invalid case style
-		internal.reset(ptr, deleter);
-	}
-
-	void swap(shared_ptr &r) noexcept { // NOLINT: invalid case style
-		internal.swap(r.internal);
-	}
-
-	T *get() const { // NOLINT: invalid case style
-		return internal.get();
-	}
-
-	long use_count() const { // NOLINT: invalid case style
-		return internal.use_count();
-	}
-
-	explicit operator bool() const noexcept {
-		return internal.operator bool();
-	}
-
-	typename std::add_lvalue_reference<T>::type operator*() const {
-		if (MemorySafety<SAFE>::ENABLED) {
-			const auto ptr = internal.get();
-			AssertNotNull(!ptr);
-			return *ptr;
-		} else {
-			return *internal;
-		}
-	}
-
-	T *operator->() const {
-		if (MemorySafety<SAFE>::ENABLED) {
-			const auto ptr = internal.get();
-			AssertNotNull(!ptr);
-			return ptr;
-		} else {
-			return internal.operator->();
-		}
-	}
-
-	// Relational operators
-	template <typename U>
-	bool operator==(const shared_ptr<U> &other) const noexcept {
-		return internal == other.internal;
-	}
-	template <typename U>
-	bool operator!=(const shared_ptr<U> &other) const noexcept {
-		return internal != other.internal;
-	}
-
-	bool operator==(std::nullptr_t) const noexcept {
-		return internal == nullptr;
-	}
-	bool operator!=(std::nullptr_t) const noexcept {
-		return internal != nullptr;
-	}
-
-	template <typename U>
-	bool operator<(const shared_ptr<U> &other) const noexcept {
-		return internal < other.internal;
-	}
-	template <typename U>
-	bool operator<=(const shared_ptr<U> &other) const noexcept {
-		return internal <= other.internal;
-	}
-	template <typename U>
-	bool operator>(const shared_ptr<U> &other) const noexcept {
-		return internal > other.internal;
-	}
-	template <typename U>
-	bool operator>=(const shared_ptr<U> &other) const noexcept {
-		return internal >= other.internal;
-	}
-
-private:
-	// This overload is used when the class inherits from 'enable_shared_from_this<U>'
-	template <class U, class V,
-	          typename std::enable_if<std::is_convertible<V *, const enable_shared_from_this<U> *>::value,
-	                                  int>::type = 0>
-	void __enable_weak_this(const enable_shared_from_this<U> *object, // NOLINT: invalid case style
-	                        V *ptr) noexcept {
-		typedef typename std::remove_cv<U>::type non_const_u_t;
-		if (object && object->__weak_this_.expired()) {
-			// __weak_this__ is the mutable variable returned by 'shared_from_this'
-			// it is initialized here
-			auto non_const = const_cast<non_const_u_t *>(static_cast<const U *>(ptr)); // NOLINT: const cast
-			object->__weak_this_ = shared_ptr<non_const_u_t>(*this, non_const);
-		}
-	}
-
-	void __enable_weak_this(...) noexcept { // NOLINT: invalid case style
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/sort/comparators.hpp b/src/duckdb/src/include/duckdb/common/sort/comparators.hpp
deleted file mode 100644
index 5f3cd3807..000000000
--- a/src/duckdb/src/include/duckdb/common/sort/comparators.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/comparators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-
-namespace duckdb {
-
-struct SortLayout;
-struct SBScanState;
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-struct Comparators {
-public:
-	//! Whether a tie between two blobs can be broken
-	static bool TieIsBreakable(const idx_t &col_idx, const data_ptr_t &row_ptr, const SortLayout &sort_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 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 SBScanState &left, const SBScanState &right,
-	                        const SortLayout &sort_layout, const bool &external);
-	//! Compare two fixed-size values
-	template <class T>
-	static int TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr);
-
-	//! Compare two values at the pointers (can be recursive if nested type)
-	static int CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type, bool valid);
-	//! Compares two fixed-size values at the given pointers
-	template <class T>
-	static int TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
-	//! Compares two string values at the given pointers
-	static int CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, bool valid);
-	//! Compares two struct values at the given pointers (recursive)
-	static int CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-	                                   const child_list_t<LogicalType> &types, bool valid);
-	static int CompareArrayAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type, bool valid,
-	                                  idx_t array_size);
-	//! Compare two list values at the pointers (can be recursive if nested type)
-	static int CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type, bool valid);
-	//! Compares a list of fixed-size values
-	template <class T>
-	static int TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const ValidityBytes &left_validity,
-	                                    const ValidityBytes &right_validity, const idx_t &count);
-
-	//! Unwizzles an offset into a pointer
-	static void UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type);
-	//! Swizzles a pointer into an offset
-	static void SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp b/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp
deleted file mode 100644
index c935a713a..000000000
--- a/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
-pdqsort.h - Pattern-defeating quicksort.
-
-Copyright (c) 2021 Orson Peters
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the
-authors be held liable for any damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including commercial
-applications, and to alter it and redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the
-    original software. If you use this software in a product, an acknowledgment in the product
-    documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as
-    being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-#include <algorithm>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <utility>
-
-namespace duckdb_pdqsort {
-
-using duckdb::data_ptr_t;
-using duckdb::data_t;
-using duckdb::FastMemcmp;
-using duckdb::FastMemcpy;
-using duckdb::idx_t;
-using duckdb::make_unsafe_uniq_array_uninitialized;
-using duckdb::unique_ptr;
-using duckdb::unsafe_unique_array;
-
-// NOLINTBEGIN
-
-enum {
-	// Partitions below this size are sorted using insertion sort.
-	insertion_sort_threshold = 24,
-
-	// Partitions above this size use Tukey's ninther to select the pivot.
-	ninther_threshold = 128,
-
-	// When we detect an already sorted partition, attempt an insertion sort that allows this
-	// amount of element moves before giving up.
-	partial_insertion_sort_limit = 8,
-
-	// Must be multiple of 8 due to loop unrolling, and < 256 to fit in unsigned char.
-	block_size = 64,
-
-	// Cacheline size, assumes power of two.
-	cacheline_size = 64
-
-};
-
-// Returns floor(log2(n)), assumes n > 0.
-template <class T>
-inline int log2(T n) {
-	int log = 0;
-	while (n >>= 1) {
-		++log;
-	}
-	return log;
-}
-
-struct PDQConstants {
-	PDQConstants(idx_t entry_size, idx_t comp_offset, idx_t comp_size, data_ptr_t end)
-	    : entry_size(entry_size), comp_offset(comp_offset), comp_size(comp_size),
-	      tmp_buf_ptr(make_unsafe_uniq_array_uninitialized<data_t>(entry_size)), tmp_buf(tmp_buf_ptr.get()),
-	      iter_swap_buf_ptr(make_unsafe_uniq_array_uninitialized<data_t>(entry_size)),
-	      iter_swap_buf(iter_swap_buf_ptr.get()),
-	      swap_offsets_buf_ptr(make_unsafe_uniq_array_uninitialized<data_t>(entry_size)),
-	      swap_offsets_buf(swap_offsets_buf_ptr.get()), end(end) {
-	}
-
-	const duckdb::idx_t entry_size;
-	const idx_t comp_offset;
-	const idx_t comp_size;
-
-	unsafe_unique_array<data_t> tmp_buf_ptr;
-	const data_ptr_t tmp_buf;
-
-	unsafe_unique_array<data_t> iter_swap_buf_ptr;
-	const data_ptr_t iter_swap_buf;
-
-	unsafe_unique_array<data_t> swap_offsets_buf_ptr;
-	const data_ptr_t swap_offsets_buf;
-
-	const data_ptr_t end;
-};
-
-struct PDQIterator {
-	PDQIterator(data_ptr_t ptr, const idx_t &entry_size) : ptr(ptr), entry_size(entry_size) {
-	}
-
-	inline PDQIterator(const PDQIterator &other) : ptr(other.ptr), entry_size(other.entry_size) {
-	}
-
-	inline const data_ptr_t &operator*() const {
-		return ptr;
-	}
-
-	inline PDQIterator &operator++() {
-		ptr += entry_size;
-		return *this;
-	}
-
-	inline PDQIterator &operator--() {
-		ptr -= entry_size;
-		return *this;
-	}
-
-	inline PDQIterator operator++(int) {
-		auto tmp = *this;
-		ptr += entry_size;
-		return tmp;
-	}
-
-	inline PDQIterator operator--(int) {
-		auto tmp = *this;
-		ptr -= entry_size;
-		return tmp;
-	}
-
-	inline PDQIterator operator+(const idx_t &i) const {
-		auto result = *this;
-		result.ptr += i * entry_size;
-		return result;
-	}
-
-	inline PDQIterator operator-(const idx_t &i) const {
-		PDQIterator result = *this;
-		result.ptr -= i * entry_size;
-		return result;
-	}
-
-	inline PDQIterator &operator=(const PDQIterator &other) {
-		D_ASSERT(entry_size == other.entry_size);
-		ptr = other.ptr;
-		return *this;
-	}
-
-	inline friend idx_t operator-(const PDQIterator &lhs, const PDQIterator &rhs) {
-		D_ASSERT(duckdb::NumericCast<idx_t>(*lhs - *rhs) % lhs.entry_size == 0);
-		D_ASSERT(*lhs - *rhs >= 0);
-		return duckdb::NumericCast<idx_t>(*lhs - *rhs) / lhs.entry_size;
-	}
-
-	inline friend bool operator<(const PDQIterator &lhs, const PDQIterator &rhs) {
-		return *lhs < *rhs;
-	}
-
-	inline friend bool operator>(const PDQIterator &lhs, const PDQIterator &rhs) {
-		return *lhs > *rhs;
-	}
-
-	inline friend bool operator>=(const PDQIterator &lhs, const PDQIterator &rhs) {
-		return *lhs >= *rhs;
-	}
-
-	inline friend bool operator<=(const PDQIterator &lhs, const PDQIterator &rhs) {
-		return *lhs <= *rhs;
-	}
-
-	inline friend bool operator==(const PDQIterator &lhs, const PDQIterator &rhs) {
-		return *lhs == *rhs;
-	}
-
-	inline friend bool operator!=(const PDQIterator &lhs, const PDQIterator &rhs) {
-		return *lhs != *rhs;
-	}
-
-private:
-	data_ptr_t ptr;
-	const idx_t &entry_size;
-};
-
-static inline bool comp(const data_ptr_t &l, const data_ptr_t &r, const PDQConstants &constants) {
-	D_ASSERT(l == constants.tmp_buf || l == constants.swap_offsets_buf || l < constants.end);
-	D_ASSERT(r == constants.tmp_buf || r == constants.swap_offsets_buf || r < constants.end);
-	return FastMemcmp(l + constants.comp_offset, r + constants.comp_offset, constants.comp_size) < 0;
-}
-
-static inline const data_ptr_t &GET_TMP(const data_ptr_t &src, const PDQConstants &constants) {
-	D_ASSERT(src != constants.tmp_buf && src != constants.swap_offsets_buf && src < constants.end);
-	FastMemcpy(constants.tmp_buf, src, constants.entry_size);
-	return constants.tmp_buf;
-}
-
-static inline const data_ptr_t &SWAP_OFFSETS_GET_TMP(const data_ptr_t &src, const PDQConstants &constants) {
-	D_ASSERT(src != constants.tmp_buf && src != constants.swap_offsets_buf && src < constants.end);
-	FastMemcpy(constants.swap_offsets_buf, src, constants.entry_size);
-	return constants.swap_offsets_buf;
-}
-
-static inline void MOVE(const data_ptr_t &dest, const data_ptr_t &src, const PDQConstants &constants) {
-	D_ASSERT(dest == constants.tmp_buf || dest == constants.swap_offsets_buf || dest < constants.end);
-	D_ASSERT(src == constants.tmp_buf || src == constants.swap_offsets_buf || src < constants.end);
-	FastMemcpy(dest, src, constants.entry_size);
-}
-
-static inline void iter_swap(const PDQIterator &lhs, const PDQIterator &rhs, const PDQConstants &constants) {
-	D_ASSERT(*lhs < constants.end);
-	D_ASSERT(*rhs < constants.end);
-	FastMemcpy(constants.iter_swap_buf, *lhs, constants.entry_size);
-	FastMemcpy(*lhs, *rhs, constants.entry_size);
-	FastMemcpy(*rhs, constants.iter_swap_buf, constants.entry_size);
-}
-
-// Sorts [begin, end) using insertion sort with the given comparison function.
-inline void insertion_sort(const PDQIterator &begin, const PDQIterator &end, const PDQConstants &constants) {
-	if (begin == end) {
-		return;
-	}
-
-	for (PDQIterator cur = begin + 1; cur != end; ++cur) {
-		PDQIterator sift = cur;
-		PDQIterator sift_1 = cur - 1;
-
-		// Compare first so we can avoid 2 moves for an element already positioned correctly.
-		if (comp(*sift, *sift_1, constants)) {
-			const auto &tmp = GET_TMP(*sift, constants);
-
-			do {
-				MOVE(*sift--, *sift_1, constants);
-			} while (sift != begin && comp(tmp, *--sift_1, constants));
-
-			MOVE(*sift, tmp, constants);
-		}
-	}
-}
-
-// Sorts [begin, end) using insertion sort with the given comparison function. Assumes
-// *(begin - 1) is an element smaller than or equal to any element in [begin, end).
-inline void unguarded_insertion_sort(const PDQIterator &begin, const PDQIterator &end, const PDQConstants &constants) {
-	if (begin == end) {
-		return;
-	}
-
-	for (PDQIterator cur = begin + 1; cur != end; ++cur) {
-		PDQIterator sift = cur;
-		PDQIterator sift_1 = cur - 1;
-
-		// Compare first so we can avoid 2 moves for an element already positioned correctly.
-		if (comp(*sift, *sift_1, constants)) {
-			const auto &tmp = GET_TMP(*sift, constants);
-
-			do {
-				MOVE(*sift--, *sift_1, constants);
-			} while (comp(tmp, *--sift_1, constants));
-
-			MOVE(*sift, tmp, constants);
-		}
-	}
-}
-
-// Attempts to use insertion sort on [begin, end). Will return false if more than
-// partial_insertion_sort_limit elements were moved, and abort sorting. Otherwise it will
-// successfully sort and return true.
-inline bool partial_insertion_sort(const PDQIterator &begin, const PDQIterator &end, const PDQConstants &constants) {
-	if (begin == end) {
-		return true;
-	}
-
-	std::size_t limit = 0;
-	for (PDQIterator cur = begin + 1; cur != end; ++cur) {
-		PDQIterator sift = cur;
-		PDQIterator sift_1 = cur - 1;
-
-		// Compare first so we can avoid 2 moves for an element already positioned correctly.
-		if (comp(*sift, *sift_1, constants)) {
-			const auto &tmp = GET_TMP(*sift, constants);
-
-			do {
-				MOVE(*sift--, *sift_1, constants);
-			} while (sift != begin && comp(tmp, *--sift_1, constants));
-
-			MOVE(*sift, tmp, constants);
-			limit += cur - sift;
-		}
-
-		if (limit > partial_insertion_sort_limit) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-inline void sort2(const PDQIterator &a, const PDQIterator &b, const PDQConstants &constants) {
-	if (comp(*b, *a, constants)) {
-		iter_swap(a, b, constants);
-	}
-}
-
-// Sorts the elements *a, *b and *c using comparison function comp.
-inline void sort3(const PDQIterator &a, const PDQIterator &b, const PDQIterator &c, const PDQConstants &constants) {
-	sort2(a, b, constants);
-	sort2(b, c, constants);
-	sort2(a, b, constants);
-}
-
-template <class T>
-inline T *align_cacheline(T *p) {
-#if defined(UINTPTR_MAX) && __cplusplus >= 201103L
-	std::uintptr_t ip = reinterpret_cast<std::uintptr_t>(p);
-#else
-	std::size_t ip = reinterpret_cast<std::size_t>(p);
-#endif
-	ip = (ip + cacheline_size - 1) & -duckdb::UnsafeNumericCast<uintptr_t>(cacheline_size);
-	return reinterpret_cast<T *>(ip);
-}
-
-inline void swap_offsets(const PDQIterator &first, const PDQIterator &last, unsigned char *offsets_l,
-                         unsigned char *offsets_r, size_t num, bool use_swaps, const PDQConstants &constants) {
-	if (use_swaps) {
-		// This case is needed for the descending distribution, where we need
-		// to have proper swapping for pdqsort to remain O(n).
-		for (size_t i = 0; i < num; ++i) {
-			iter_swap(first + offsets_l[i], last - offsets_r[i], constants);
-		}
-	} else if (num > 0) {
-		PDQIterator l = first + offsets_l[0];
-		PDQIterator r = last - offsets_r[0];
-		const auto &tmp = SWAP_OFFSETS_GET_TMP(*l, constants);
-		MOVE(*l, *r, constants);
-		for (size_t i = 1; i < num; ++i) {
-			l = first + offsets_l[i];
-			MOVE(*r, *l, constants);
-			r = last - offsets_r[i];
-			MOVE(*l, *r, constants);
-		}
-		MOVE(*r, tmp, constants);
-	}
-}
-
-// Partitions [begin, end) around pivot *begin using comparison function comp. Elements equal
-// to the pivot are put in the right-hand partition. Returns the position of the pivot after
-// partitioning and whether the passed sequence already was correctly partitioned. Assumes the
-// pivot is a median of at least 3 elements and that [begin, end) is at least
-// insertion_sort_threshold long. Uses branchless partitioning.
-inline std::pair<PDQIterator, bool> partition_right_branchless(const PDQIterator &begin, const PDQIterator &end,
-                                                               const PDQConstants &constants) {
-	// Move pivot into local for speed.
-	const auto &pivot = GET_TMP(*begin, constants);
-	PDQIterator first = begin;
-	PDQIterator last = end;
-
-	// Find the first element greater than or equal than the pivot (the median of 3 guarantees
-	// this exists).
-	while (comp(*++first, pivot, constants)) {
-	}
-
-	// Find the first element strictly smaller than the pivot. We have to guard this search if
-	// there was no element before *first.
-	if (first - 1 == begin) {
-		while (first < last && !comp(*--last, pivot, constants)) {
-		}
-	} else {
-		while (!comp(*--last, pivot, constants)) {
-		}
-	}
-
-	// If the first pair of elements that should be swapped to partition are the same element,
-	// the passed in sequence already was correctly partitioned.
-	bool already_partitioned = first >= last;
-	if (!already_partitioned) {
-		iter_swap(first, last, constants);
-		++first;
-
-		// The following branchless partitioning is derived from "BlockQuicksort: How Branch
-		// Mispredictions don’t affect Quicksort" by Stefan Edelkamp and Armin Weiss, but
-		// heavily micro-optimized.
-		unsigned char offsets_l_storage[block_size + cacheline_size];
-		unsigned char offsets_r_storage[block_size + cacheline_size];
-		unsigned char *offsets_l = align_cacheline(offsets_l_storage);
-		unsigned char *offsets_r = align_cacheline(offsets_r_storage);
-
-		PDQIterator offsets_l_base = first;
-		PDQIterator offsets_r_base = last;
-		size_t num_l, num_r, start_l, start_r;
-		num_l = num_r = start_l = start_r = 0;
-
-		while (first < last) {
-			// Fill up offset blocks with elements that are on the wrong side.
-			// First we determine how much elements are considered for each offset block.
-			size_t num_unknown = last - first;
-			size_t left_split = num_l == 0 ? (num_r == 0 ? num_unknown / 2 : num_unknown) : 0;
-			size_t right_split = num_r == 0 ? (num_unknown - left_split) : 0;
-
-			// Fill the offset blocks.
-			if (left_split >= block_size) {
-				for (unsigned char i = 0; i < block_size;) {
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-				}
-			} else {
-				for (unsigned char i = 0; i < left_split;) {
-					offsets_l[num_l] = i++;
-					num_l += !comp(*first, pivot, constants);
-					++first;
-				}
-			}
-
-			if (right_split >= block_size) {
-				for (unsigned char i = 0; i < block_size;) {
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-				}
-			} else {
-				for (unsigned char i = 0; i < right_split;) {
-					offsets_r[num_r] = ++i;
-					num_r += comp(*--last, pivot, constants);
-				}
-			}
-
-			// Swap elements and update block sizes and first/last boundaries.
-			size_t num = std::min(num_l, num_r);
-			swap_offsets(offsets_l_base, offsets_r_base, offsets_l + start_l, offsets_r + start_r, num, num_l == num_r,
-			             constants);
-			num_l -= num;
-			num_r -= num;
-			start_l += num;
-			start_r += num;
-
-			if (num_l == 0) {
-				start_l = 0;
-				offsets_l_base = first;
-			}
-
-			if (num_r == 0) {
-				start_r = 0;
-				offsets_r_base = last;
-			}
-		}
-
-		// We have now fully identified [first, last)'s proper position. Swap the last elements.
-		if (num_l) {
-			offsets_l += start_l;
-			while (num_l--) {
-				iter_swap(offsets_l_base + offsets_l[num_l], --last, constants);
-			}
-			first = last;
-		}
-		if (num_r) {
-			offsets_r += start_r;
-			while (num_r--) {
-				iter_swap(offsets_r_base - offsets_r[num_r], first, constants), ++first;
-			}
-			last = first;
-		}
-	}
-
-	// Put the pivot in the right place.
-	PDQIterator pivot_pos = first - 1;
-	MOVE(*begin, *pivot_pos, constants);
-	MOVE(*pivot_pos, pivot, constants);
-
-	return std::make_pair(pivot_pos, already_partitioned);
-}
-
-// Partitions [begin, end) around pivot *begin using comparison function comp. Elements equal
-// to the pivot are put in the right-hand partition. Returns the position of the pivot after
-// partitioning and whether the passed sequence already was correctly partitioned. Assumes the
-// pivot is a median of at least 3 elements and that [begin, end) is at least
-// insertion_sort_threshold long.
-inline std::pair<PDQIterator, bool> partition_right(const PDQIterator &begin, const PDQIterator &end,
-                                                    const PDQConstants &constants) {
-	// Move pivot into local for speed.
-	const auto &pivot = GET_TMP(*begin, constants);
-
-	PDQIterator first = begin;
-	PDQIterator last = end;
-
-	// Find the first element greater than or equal than the pivot (the median of 3 guarantees
-	// this exists).
-	while (comp(*++first, pivot, constants)) {
-	}
-
-	// Find the first element strictly smaller than the pivot. We have to guard this search if
-	// there was no element before *first.
-	if (first - 1 == begin) {
-		while (first < last && !comp(*--last, pivot, constants)) {
-		}
-	} else {
-		while (!comp(*--last, pivot, constants)) {
-		}
-	}
-
-	// If the first pair of elements that should be swapped to partition are the same element,
-	// the passed in sequence already was correctly partitioned.
-	bool already_partitioned = first >= last;
-
-	// Keep swapping pairs of elements that are on the wrong side of the pivot. Previously
-	// swapped pairs guard the searches, which is why the first iteration is special-cased
-	// above.
-	while (first < last) {
-		iter_swap(first, last, constants);
-		while (comp(*++first, pivot, constants)) {
-		}
-		while (!comp(*--last, pivot, constants)) {
-		}
-	}
-
-	// Put the pivot in the right place.
-	PDQIterator pivot_pos = first - 1;
-	MOVE(*begin, *pivot_pos, constants);
-	MOVE(*pivot_pos, pivot, constants);
-
-	return std::make_pair(pivot_pos, already_partitioned);
-}
-
-// Similar function to the one above, except elements equal to the pivot are put to the left of
-// the pivot and it doesn't check or return if the passed sequence already was partitioned.
-// Since this is rarely used (the many equal case), and in that case pdqsort already has O(n)
-// performance, no block quicksort is applied here for simplicity.
-inline PDQIterator partition_left(const PDQIterator &begin, const PDQIterator &end, const PDQConstants &constants) {
-	const auto &pivot = GET_TMP(*begin, constants);
-	PDQIterator first = begin;
-	PDQIterator last = end;
-
-	while (comp(pivot, *--last, constants)) {
-	}
-
-	if (last + 1 == end) {
-		while (first < last && !comp(pivot, *++first, constants)) {
-		}
-	} else {
-		while (!comp(pivot, *++first, constants)) {
-		}
-	}
-
-	while (first < last) {
-		iter_swap(first, last, constants);
-		while (comp(pivot, *--last, constants)) {
-		}
-		while (!comp(pivot, *++first, constants)) {
-		}
-	}
-
-	PDQIterator pivot_pos = last;
-	MOVE(*begin, *pivot_pos, constants);
-	MOVE(*pivot_pos, pivot, constants);
-
-	return pivot_pos;
-}
-
-template <bool Branchless>
-inline void pdqsort_loop(PDQIterator begin, const PDQIterator &end, const PDQConstants &constants, int bad_allowed,
-                         bool leftmost = true) {
-	// Use a while loop for tail recursion elimination.
-	while (true) {
-		idx_t size = end - begin;
-
-		// Insertion sort is faster for small arrays.
-		if (size < insertion_sort_threshold) {
-			if (leftmost) {
-				insertion_sort(begin, end, constants);
-			} else {
-				unguarded_insertion_sort(begin, end, constants);
-			}
-			return;
-		}
-
-		// Choose pivot as median of 3 or pseudomedian of 9.
-		idx_t s2 = size / 2;
-		if (size > ninther_threshold) {
-			sort3(begin, begin + s2, end - 1, constants);
-			sort3(begin + 1, begin + (s2 - 1), end - 2, constants);
-			sort3(begin + 2, begin + (s2 + 1), end - 3, constants);
-			sort3(begin + (s2 - 1), begin + s2, begin + (s2 + 1), constants);
-			iter_swap(begin, begin + s2, constants);
-		} else {
-			sort3(begin + s2, begin, end - 1, constants);
-		}
-
-		// If *(begin - 1) is the end of the right partition of a previous partition operation
-		// there is no element in [begin, end) that is smaller than *(begin - 1). Then if our
-		// pivot compares equal to *(begin - 1) we change strategy, putting equal elements in
-		// the left partition, greater elements in the right partition. We do not have to
-		// recurse on the left partition, since it's sorted (all equal).
-		if (!leftmost && !comp(*(begin - 1), *begin, constants)) {
-			begin = partition_left(begin, end, constants) + 1;
-			continue;
-		}
-
-		// Partition and get results.
-		std::pair<PDQIterator, bool> part_result =
-		    Branchless ? partition_right_branchless(begin, end, constants) : partition_right(begin, end, constants);
-		PDQIterator pivot_pos = part_result.first;
-		bool already_partitioned = part_result.second;
-
-		// Check for a highly unbalanced partition.
-		idx_t l_size = pivot_pos - begin;
-		idx_t r_size = end - (pivot_pos + 1);
-		bool highly_unbalanced = l_size < size / 8 || r_size < size / 8;
-
-		// If we got a highly unbalanced partition we shuffle elements to break many patterns.
-		if (highly_unbalanced) {
-			// If we had too many bad partitions, switch to heapsort to guarantee O(n log n).
-			//			if (--bad_allowed == 0) {
-			//				std::make_heap(begin, end, comp);
-			//				std::sort_heap(begin, end, comp);
-			//				return;
-			//			}
-
-			if (l_size >= insertion_sort_threshold) {
-				iter_swap(begin, begin + l_size / 4, constants);
-				iter_swap(pivot_pos - 1, pivot_pos - l_size / 4, constants);
-
-				if (l_size > ninther_threshold) {
-					iter_swap(begin + 1, begin + (l_size / 4 + 1), constants);
-					iter_swap(begin + 2, begin + (l_size / 4 + 2), constants);
-					iter_swap(pivot_pos - 2, pivot_pos - (l_size / 4 + 1), constants);
-					iter_swap(pivot_pos - 3, pivot_pos - (l_size / 4 + 2), constants);
-				}
-			}
-
-			if (r_size >= insertion_sort_threshold) {
-				iter_swap(pivot_pos + 1, pivot_pos + (1 + r_size / 4), constants);
-				iter_swap(end - 1, end - r_size / 4, constants);
-
-				if (r_size > ninther_threshold) {
-					iter_swap(pivot_pos + 2, pivot_pos + (2 + r_size / 4), constants);
-					iter_swap(pivot_pos + 3, pivot_pos + (3 + r_size / 4), constants);
-					iter_swap(end - 2, end - (1 + r_size / 4), constants);
-					iter_swap(end - 3, end - (2 + r_size / 4), constants);
-				}
-			}
-		} else {
-			// If we were decently balanced and we tried to sort an already partitioned
-			// sequence try to use insertion sort.
-			if (already_partitioned && partial_insertion_sort(begin, pivot_pos, constants) &&
-			    partial_insertion_sort(pivot_pos + 1, end, constants)) {
-				return;
-			}
-		}
-
-		// Sort the left partition first using recursion and do tail recursion elimination for
-		// the right-hand partition.
-		pdqsort_loop<Branchless>(begin, pivot_pos, constants, bad_allowed, leftmost);
-		begin = pivot_pos + 1;
-		leftmost = false;
-	}
-}
-
-inline void pdqsort(const PDQIterator &begin, const PDQIterator &end, const PDQConstants &constants) {
-	if (begin == end) {
-		return;
-	}
-	pdqsort_loop<false>(begin, end, constants, log2(end - begin));
-}
-
-inline void pdqsort_branchless(const PDQIterator &begin, const PDQIterator &end, const PDQConstants &constants) {
-	if (begin == end) {
-		return;
-	}
-	pdqsort_loop<true>(begin, end, constants, log2(end - begin));
-}
-// NOLINTEND
-
-} // namespace duckdb_pdqsort
diff --git a/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp b/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp
deleted file mode 100644
index d0ab3ed6a..000000000
--- a/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp
+++ /dev/null
@@ -1,247 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/partition_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-
-namespace duckdb {
-
-class PartitionGlobalHashGroup {
-public:
-	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
-	using Orders = vector<BoundOrderByNode>;
-	using Types = vector<LogicalType>;
-	using OrderMasks = unordered_map<idx_t, ValidityMask>;
-
-	PartitionGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
-	                         const Types &payload_types, bool external);
-
-	inline int ComparePartitions(const SBIterator &left, const SBIterator &right) {
-		int part_cmp = 0;
-		if (partition_layout.all_constant) {
-			part_cmp = FastMemcmp(left.entry_ptr, right.entry_ptr, partition_layout.comparison_size);
-		} else {
-			part_cmp = Comparators::CompareTuple(left.scan, right.scan, left.entry_ptr, right.entry_ptr,
-			                                     partition_layout, left.external);
-		}
-		return part_cmp;
-	}
-
-	void ComputeMasks(ValidityMask &partition_mask, OrderMasks &order_masks);
-
-	GlobalSortStatePtr global_sort;
-	atomic<idx_t> count;
-
-	// Mask computation
-	SortLayout partition_layout;
-};
-
-class PartitionGlobalSinkState {
-public:
-	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
-	using Orders = vector<BoundOrderByNode>;
-	using Types = vector<LogicalType>;
-
-	using GroupingPartition = unique_ptr<PartitionedTupleData>;
-	using GroupingAppend = unique_ptr<PartitionedTupleDataAppendState>;
-
-	static void GenerateOrderings(Orders &partitions, Orders &orders,
-	                              const vector<unique_ptr<Expression>> &partition_bys, const Orders &order_bys,
-	                              const vector<unique_ptr<BaseStatistics>> &partitions_stats);
-
-	PartitionGlobalSinkState(ClientContext &context, const vector<unique_ptr<Expression>> &partition_bys,
-	                         const vector<BoundOrderByNode> &order_bys, const Types &payload_types,
-	                         const vector<unique_ptr<BaseStatistics>> &partitions_stats, idx_t estimated_cardinality);
-	virtual ~PartitionGlobalSinkState() = default;
-
-	bool HasMergeTasks() const;
-
-	unique_ptr<RadixPartitionedTupleData> CreatePartition(idx_t new_bits) const;
-	void SyncPartitioning(const PartitionGlobalSinkState &other);
-
-	void UpdateLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
-	void CombineLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
-
-	virtual void OnBeginMerge() {};
-	virtual void OnSortedPartition(const idx_t hash_bin_p) {};
-
-	ClientContext &context;
-	BufferManager &buffer_manager;
-	Allocator &allocator;
-	mutex lock;
-
-	// OVER(PARTITION BY...) (hash grouping)
-	unique_ptr<RadixPartitionedTupleData> grouping_data;
-	//! Payload plus hash column
-	TupleDataLayout grouping_types;
-	//! The number of radix bits if this partition is being synced with another
-	idx_t fixed_bits;
-
-	// OVER(...) (sorting)
-	Orders partitions;
-	Orders orders;
-	const Types payload_types;
-	vector<HashGroupPtr> hash_groups;
-	bool external;
-	//	Reverse lookup from hash bins to non-empty hash groups
-	vector<size_t> bin_groups;
-
-	// OVER() (no sorting)
-	unique_ptr<RowDataCollection> rows;
-	unique_ptr<RowDataCollection> strings;
-
-	// Threading
-	idx_t memory_per_thread;
-	idx_t max_bits;
-	atomic<idx_t> count;
-
-private:
-	void ResizeGroupingData(idx_t cardinality);
-	void SyncLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
-};
-
-class PartitionLocalSinkState {
-public:
-	using LocalSortStatePtr = unique_ptr<LocalSortState>;
-
-	PartitionLocalSinkState(ClientContext &context, PartitionGlobalSinkState &gstate_p);
-
-	// Global state
-	PartitionGlobalSinkState &gstate;
-	Allocator &allocator;
-
-	//	Shared expression evaluation
-	ExpressionExecutor executor;
-	DataChunk group_chunk;
-	DataChunk payload_chunk;
-	size_t sort_cols;
-
-	// OVER(PARTITION BY...) (hash grouping)
-	unique_ptr<PartitionedTupleData> local_partition;
-	unique_ptr<PartitionedTupleDataAppendState> local_append;
-
-	// OVER(ORDER BY...) (only sorting)
-	LocalSortStatePtr local_sort;
-
-	// OVER() (no sorting)
-	RowLayout payload_layout;
-	unique_ptr<RowDataCollection> rows;
-	unique_ptr<RowDataCollection> strings;
-
-	//! Compute the hash values
-	void Hash(DataChunk &input_chunk, Vector &hash_vector);
-	//! Sink an input chunk
-	void Sink(DataChunk &input_chunk);
-	//! Merge the state into the global state.
-	void Combine();
-};
-
-enum class PartitionSortStage : uint8_t { INIT, SCAN, PREPARE, MERGE, SORTED, FINISHED };
-
-class PartitionLocalMergeState;
-
-class PartitionGlobalMergeState {
-public:
-	using GroupDataPtr = unique_ptr<TupleDataCollection>;
-
-	//	OVER(PARTITION BY...)
-	PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data, hash_t hash_bin);
-
-	//	OVER(ORDER BY...)
-	explicit PartitionGlobalMergeState(PartitionGlobalSinkState &sink);
-
-	bool IsFinished() const {
-		lock_guard<mutex> guard(lock);
-		return stage == PartitionSortStage::FINISHED;
-	}
-
-	bool AssignTask(PartitionLocalMergeState &local_state);
-	bool TryPrepareNextStage();
-	void CompleteTask();
-
-	PartitionGlobalSinkState &sink;
-	GroupDataPtr group_data;
-	PartitionGlobalHashGroup *hash_group;
-	const idx_t group_idx;
-	vector<column_t> column_ids;
-	TupleDataParallelScanState chunk_state;
-	GlobalSortState *global_sort;
-	const idx_t memory_per_thread;
-	const idx_t num_threads;
-
-private:
-	mutable mutex lock;
-	PartitionSortStage stage;
-	idx_t total_tasks;
-	idx_t tasks_assigned;
-	idx_t tasks_completed;
-};
-
-class PartitionLocalMergeState {
-public:
-	explicit PartitionLocalMergeState(PartitionGlobalSinkState &gstate);
-
-	bool TaskFinished() {
-		return finished;
-	}
-
-	void Prepare();
-	void Scan();
-	void Merge();
-	void Sorted();
-
-	void ExecuteTask();
-
-	PartitionGlobalMergeState *merge_state;
-	PartitionSortStage stage;
-	atomic<bool> finished;
-
-	//	Sorting buffers
-	ExpressionExecutor executor;
-	DataChunk sort_chunk;
-	DataChunk payload_chunk;
-};
-
-class PartitionGlobalMergeStates {
-public:
-	struct Callback {
-		virtual ~Callback() = default;
-
-		virtual bool HasError() const {
-			return false;
-		}
-	};
-
-	using PartitionGlobalMergeStatePtr = unique_ptr<PartitionGlobalMergeState>;
-
-	explicit PartitionGlobalMergeStates(PartitionGlobalSinkState &sink);
-
-	bool ExecuteTask(PartitionLocalMergeState &local_state, Callback &callback);
-
-	vector<PartitionGlobalMergeStatePtr> states;
-};
-
-class PartitionMergeEvent : public BasePipelineEvent {
-public:
-	PartitionMergeEvent(PartitionGlobalSinkState &gstate_p, Pipeline &pipeline_p, const PhysicalOperator &op_p)
-	    : BasePipelineEvent(pipeline_p), gstate(gstate_p), merge_states(gstate_p), op(op_p) {
-	}
-
-	PartitionGlobalSinkState &gstate;
-	PartitionGlobalMergeStates merge_states;
-	const PhysicalOperator &op;
-
-public:
-	void Schedule() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/sort/sort.hpp b/src/duckdb/src/include/duckdb/common/sort/sort.hpp
deleted file mode 100644
index c933da9f0..000000000
--- a/src/duckdb/src/include/duckdb/common/sort/sort.hpp
+++ /dev/null
@@ -1,288 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/sort.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/sort/sorted_block.hpp"
-#include "duckdb/common/types/row/row_data_collection.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-
-class RowLayout;
-struct LocalSortState;
-
-struct SortConstants {
-	static constexpr idx_t VALUES_PER_RADIX = 256;
-	static constexpr idx_t MSD_RADIX_LOCATIONS = VALUES_PER_RADIX + 1;
-	static constexpr idx_t INSERTION_SORT_THRESHOLD = 24;
-	static constexpr idx_t MSD_RADIX_SORT_SIZE_THRESHOLD = 4;
-};
-
-struct SortLayout {
-public:
-	SortLayout() {
-	}
-	explicit SortLayout(const vector<BoundOrderByNode> &orders);
-	SortLayout GetPrefixComparisonLayout(idx_t num_prefix_cols) const;
-
-public:
-	idx_t column_count;
-	vector<OrderType> order_types;
-	vector<OrderByNullType> order_by_null_types;
-	vector<LogicalType> logical_types;
-
-	bool all_constant;
-	vector<bool> constant_size;
-	vector<idx_t> column_sizes;
-	vector<idx_t> prefix_lengths;
-	vector<BaseStatistics *> stats;
-	vector<bool> has_null;
-
-	idx_t comparison_size;
-	idx_t entry_size;
-
-	RowLayout blob_layout;
-	unordered_map<idx_t, idx_t> sorting_to_blob_col;
-};
-
-struct GlobalSortState {
-public:
-	GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
-
-	//! Add local state sorted data to this global state
-	void AddLocalState(LocalSortState &local_sort_state);
-	//! Prepares the GlobalSortState for the merge sort phase (after completing radix sort phase)
-	void PrepareMergePhase();
-	//! Initializes the global sort state for another round of merging
-	void InitializeMergeRound();
-	//! Completes the cascaded merge sort round.
-	//! Pass true if you wish to use the radix data for further comparisons.
-	void CompleteMergeRound(bool keep_radix_data = false);
-	//! Print the sorted data to the console.
-	void Print();
-
-public:
-	//! The lock for updating the order global state
-	mutex lock;
-	//! The buffer manager
-	BufferManager &buffer_manager;
-
-	//! Sorting and payload layouts
-	const SortLayout sort_layout;
-	const RowLayout payload_layout;
-
-	//! Sorted data
-	vector<unique_ptr<SortedBlock>> sorted_blocks;
-	vector<vector<unique_ptr<SortedBlock>>> sorted_blocks_temp;
-	unique_ptr<SortedBlock> odd_one_out;
-
-	//! Pinned heap data (if sorting in memory)
-	vector<unique_ptr<RowDataBlock>> heap_blocks;
-	vector<BufferHandle> pinned_blocks;
-
-	//! Capacity (number of rows) used to initialize blocks
-	idx_t block_capacity;
-	//! Whether we are doing an external sort
-	bool external;
-
-	//! Progress in merge path stage
-	idx_t pair_idx;
-	idx_t num_pairs;
-	idx_t l_start;
-	idx_t r_start;
-};
-
-struct LocalSortState {
-public:
-	LocalSortState();
-
-	//! Initialize the layouts and RowDataCollections
-	void Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p);
-	//! Sink one DataChunk into the local sort state
-	void SinkChunk(DataChunk &sort, DataChunk &payload);
-	//! Size of accumulated data in bytes
-	idx_t SizeInBytes() const;
-	//! Sort the data accumulated so far
-	void Sort(GlobalSortState &global_sort_state, bool reorder_heap);
-	//! Concatenate the blocks held by a RowDataCollection into a single block
-	static unique_ptr<RowDataBlock> ConcatenateBlocks(RowDataCollection &row_data);
-
-private:
-	//! Sorts the data in the newly created SortedBlock
-	void SortInMemory();
-	//! Re-order the local state after sorting
-	void ReOrder(GlobalSortState &gstate, bool reorder_heap);
-	//! Re-order a SortedData object after sorting
-	void ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
-	             bool reorder_heap);
-
-public:
-	//! Whether this local state has been initialized
-	bool initialized;
-	//! The buffer manager
-	BufferManager *buffer_manager;
-	//! The sorting and payload layouts
-	const SortLayout *sort_layout;
-	const RowLayout *payload_layout;
-	//! Radix/memcmp sortable data
-	unique_ptr<RowDataCollection> radix_sorting_data;
-	//! Variable sized sorting data and accompanying heap
-	unique_ptr<RowDataCollection> blob_sorting_data;
-	unique_ptr<RowDataCollection> blob_sorting_heap;
-	//! Payload data and accompanying heap
-	unique_ptr<RowDataCollection> payload_data;
-	unique_ptr<RowDataCollection> payload_heap;
-	//! Sorted data
-	vector<unique_ptr<SortedBlock>> sorted_blocks;
-
-private:
-	//! Selection vector and addresses for scattering the data to rows
-	const SelectionVector &sel_ptr = *FlatVector::IncrementalSelectionVector();
-	Vector addresses = Vector(LogicalType::POINTER);
-};
-
-struct MergeSorter {
-public:
-	MergeSorter(GlobalSortState &state, BufferManager &buffer_manager);
-
-	//! 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(const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
-	//! Compare values within SortedBlocks using a global index
-	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();
-
-	//! Computes how the next 'count' tuples should be merged by setting the 'left_smaller' array
-	void ComputeMerge(const idx_t &count, bool left_smaller[]);
-
-	//! Merges the radix sorting blocks according to the 'left_smaller' array
-	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[], 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,
-	               const bool left_smaller[], idx_t &copied, const idx_t &count);
-	//! Flushes constant size rows into the result
-	void FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
-	               RowDataBlock &target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
-	               const idx_t &count);
-	//! Flushes blob rows and accompanying heap
-	void FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
-	                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);
-};
-
-struct SBIterator {
-	static int ComparisonValue(ExpressionType comparison);
-
-	SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0);
-
-	inline idx_t GetIndex() const {
-		return entry_idx;
-	}
-
-	inline void SetIndex(idx_t entry_idx_p) {
-		const auto new_block_idx = entry_idx_p / block_capacity;
-		if (new_block_idx != scan.block_idx) {
-			scan.SetIndices(new_block_idx, 0);
-			if (new_block_idx < block_count) {
-				scan.PinRadix(scan.block_idx);
-				block_ptr = scan.RadixPtr();
-				if (!all_constant) {
-					scan.PinData(*scan.sb->blob_sorting_data);
-				}
-			}
-		}
-
-		scan.entry_idx = entry_idx_p % block_capacity;
-		entry_ptr = block_ptr + scan.entry_idx * entry_size;
-		entry_idx = entry_idx_p;
-	}
-
-	inline SBIterator &operator++() {
-		if (++scan.entry_idx < block_capacity) {
-			entry_ptr += entry_size;
-			++entry_idx;
-		} else {
-			SetIndex(entry_idx + 1);
-		}
-
-		return *this;
-	}
-
-	inline SBIterator &operator--() {
-		if (scan.entry_idx) {
-			--scan.entry_idx;
-			--entry_idx;
-			entry_ptr -= entry_size;
-		} else {
-			SetIndex(entry_idx - 1);
-		}
-
-		return *this;
-	}
-
-	inline bool Compare(const SBIterator &other, const SortLayout &prefix) const {
-		int comp_res;
-		if (all_constant) {
-			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, prefix.comparison_size);
-		} else {
-			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, prefix, external);
-		}
-
-		return comp_res <= cmp;
-	}
-
-	inline bool Compare(const SBIterator &other) const {
-		return Compare(other, sort_layout);
-	}
-
-	// Fixed comparison parameters
-	const SortLayout &sort_layout;
-	const idx_t block_count;
-	const idx_t block_capacity;
-	const size_t entry_size;
-	const bool all_constant;
-	const bool external;
-	const int cmp;
-
-	// Iteration state
-	SBScanState scan;
-	idx_t entry_idx;
-	data_ptr_t block_ptr;
-	data_ptr_t entry_ptr;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/sort/sorted_block.hpp b/src/duckdb/src/include/duckdb/common/sort/sorted_block.hpp
deleted file mode 100644
index b6941bda2..000000000
--- a/src/duckdb/src/include/duckdb/common/sort/sorted_block.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/sorted_block.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/sort/comparators.hpp"
-#include "duckdb/common/types/row/row_data_collection_scanner.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-
-class BufferManager;
-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(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
-	//! Number of rows that this object holds
-	idx_t Count();
-	//! Initialize new block to write to
-	void CreateBlock();
-	//! Create a slice that holds the rows between the start and end indices
-	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<unique_ptr<RowDataBlock>> data_blocks;
-	vector<unique_ptr<RowDataBlock>> heap_blocks;
-	//! Whether the pointers in this sorted data are swizzled
-	bool swizzled;
-
-private:
-	//! The buffer manager
-	BufferManager &buffer_manager;
-	//! The global state
-	GlobalSortState &state;
-};
-
-//! Block that holds sorted rows: radix, blob and payload data
-struct SortedBlock {
-public:
-	SortedBlock(BufferManager &buffer_manager, GlobalSortState &gstate);
-	//! Number of rows that this object holds
-	idx_t Count() const;
-	//! Initialize this block to write data to
-	void InitializeWrite();
-	//! Init new block to write to
-	void CreateBlock();
-	//! 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, idx_t &entry_idx);
-
-	//! Size (in bytes) of the heap of this block
-	idx_t HeapSize() const;
-	//! Total size (in bytes) of this block
-	idx_t SizeInBytes() const;
-
-public:
-	//! Radix/memcmp sortable data
-	vector<unique_ptr<RowDataBlock>> radix_sorting_data;
-	//! Variable sized sorting data
-	unique_ptr<SortedData> blob_sorting_data;
-	//! Payload data
-	unique_ptr<SortedData> payload_data;
-
-private:
-	//! Buffer manager, global state, and sorting layout constants
-	BufferManager &buffer_manager;
-	GlobalSortState &state;
-	const SortLayout &sort_layout;
-	const RowLayout &payload_layout;
-};
-
-//! State used to scan a SortedBlock e.g. during merge sort
-struct SBScanState {
-public:
-	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;
-
-	BufferHandle radix_handle;
-
-	BufferHandle blob_sorting_data_handle;
-	BufferHandle blob_sorting_heap_handle;
-
-	BufferHandle payload_data_handle;
-	BufferHandle payload_heap_handle;
-};
-
-//! Used to scan the data into DataChunks after sorting
-struct PayloadScanner {
-public:
-	PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush = true);
-	explicit PayloadScanner(GlobalSortState &global_sort_state, bool flush = true);
-
-	//! Scan a single block
-	PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx, bool flush = false);
-
-	//! The type layout of the payload
-	inline const vector<LogicalType> &GetPayloadTypes() const {
-		return scanner->GetTypes();
-	}
-
-	//! The number of rows scanned so far
-	inline idx_t Scanned() const {
-		return scanner->Scanned();
-	}
-
-	//! The number of remaining rows
-	inline idx_t Remaining() const {
-		return scanner->Remaining();
-	}
-
-	//! Scans the next data chunk from the sorted data
-	void Scan(DataChunk &chunk);
-
-private:
-	//! The sorted data being scanned
-	unique_ptr<RowDataCollection> rows;
-	unique_ptr<RowDataCollection> heap;
-	//! The actual scanner
-	unique_ptr<RowDataCollectionScanner> scanner;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/stack.hpp b/src/duckdb/src/include/duckdb/common/stack.hpp
deleted file mode 100644
index 18e270806..000000000
--- a/src/duckdb/src/include/duckdb/common/stack.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/stack.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <stack>
-
-namespace duckdb {
-using std::stack;
-}
diff --git a/src/duckdb/src/include/duckdb/common/stack_checker.hpp b/src/duckdb/src/include/duckdb/common/stack_checker.hpp
deleted file mode 100644
index a2375e8ef..000000000
--- a/src/duckdb/src/include/duckdb/common/stack_checker.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/stack_checker.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-template <class RECURSIVE_CLASS>
-class StackChecker {
-public:
-	StackChecker(RECURSIVE_CLASS &recursive_class_p, idx_t stack_usage_p)
-	    : recursive_class(recursive_class_p), stack_usage(stack_usage_p) {
-		recursive_class.stack_depth += stack_usage;
-	}
-	~StackChecker() {
-		recursive_class.stack_depth -= stack_usage;
-	}
-	StackChecker(StackChecker &&other) noexcept
-	    : recursive_class(other.recursive_class), stack_usage(other.stack_usage) {
-		other.stack_usage = 0;
-	}
-	StackChecker(const StackChecker &) = delete;
-
-private:
-	RECURSIVE_CLASS &recursive_class;
-	idx_t stack_usage;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/stacktrace.hpp b/src/duckdb/src/include/duckdb/common/stacktrace.hpp
deleted file mode 100644
index eb3f8e693..000000000
--- a/src/duckdb/src/include/duckdb/common/stacktrace.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/stacktrace.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-class StackTrace {
-public:
-	static string GetStacktracePointers(idx_t max_depth = 120);
-	static string ResolveStacktraceSymbols(const string &pointers);
-
-	inline static string GetStackTrace(idx_t max_depth = 120) {
-		return ResolveStacktraceSymbols(GetStacktracePointers(max_depth));
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/string.hpp b/src/duckdb/src/include/duckdb/common/string.hpp
deleted file mode 100644
index 553a548d4..000000000
--- a/src/duckdb/src/include/duckdb/common/string.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/string.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <sstream>
-#include <string>
-
-namespace duckdb {
-using std::string;
-using std::stringstream;
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/string_map_set.hpp b/src/duckdb/src/include/duckdb/common/string_map_set.hpp
deleted file mode 100644
index 00600c421..000000000
--- a/src/duckdb/src/include/duckdb/common/string_map_set.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/string_map_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-struct StringHash {
-	std::size_t operator()(const string_t &k) const {
-		return Hash(k);
-	}
-};
-
-struct StringEquality {
-	bool operator()(const string_t &a, const string_t &b) const {
-		return Equals::Operation(a, b);
-	}
-};
-
-template <typename T>
-using string_map_t = unordered_map<string_t, T, StringHash, StringEquality>;
-
-using string_set_t = unordered_set<string_t, StringHash, StringEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/string_util.hpp b/src/duckdb/src/include/duckdb/common/string_util.hpp
deleted file mode 100644
index 7ccc80429..000000000
--- a/src/duckdb/src/include/duckdb/common/string_util.hpp
+++ /dev/null
@@ -1,329 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/string_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/vector.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-#ifndef DUCKDB_QUOTE_DEFINE
-// Preprocessor trick to allow text to be converted to C-string / string
-// Expecte use is:
-//	#ifdef SOME_DEFINE
-//	string str = DUCKDB_QUOTE_DEFINE(SOME_DEFINE)
-//	...do something with str
-//	#endif SOME_DEFINE
-#define DUCKDB_QUOTE_DEFINE_IMPL(x) #x
-#define DUCKDB_QUOTE_DEFINE(x)      DUCKDB_QUOTE_DEFINE_IMPL(x)
-#endif
-
-/**
- * String Utility Functions
- * Note that these are not the most efficient implementations (i.e., they copy
- * memory) and therefore they should only be used for debug messages and other
- * such things.
- */
-class StringUtil {
-public:
-	static string GenerateRandomName(idx_t length = 16);
-
-	static uint8_t GetHexValue(char c) {
-		if (c >= '0' && c <= '9') {
-			return UnsafeNumericCast<uint8_t>(c - '0');
-		}
-		if (c >= 'a' && c <= 'f') {
-			return UnsafeNumericCast<uint8_t>(c - 'a' + 10);
-		}
-		if (c >= 'A' && c <= 'F') {
-			return UnsafeNumericCast<uint8_t>(c - 'A' + 10);
-		}
-		throw InvalidInputException("Invalid input for hex digit: %s", string(1, c));
-	}
-	static uint8_t GetBinaryValue(char c) {
-		if (c >= '0' && c <= '1') {
-			return UnsafeNumericCast<uint8_t>(c - '0');
-		}
-		throw InvalidInputException("Invalid input for binary digit: %s", string(1, c));
-	}
-
-	static bool CharacterIsSpace(char c) {
-		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
-	}
-	static bool CharacterIsNewline(char c) {
-		return c == '\n' || c == '\r';
-	}
-	static bool CharacterIsDigit(char c) {
-		return c >= '0' && c <= '9';
-	}
-	static bool CharacterIsHex(char c) {
-		return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-	}
-	static char CharacterToUpper(char c) {
-		if (c >= 'a' && c <= 'z') {
-			return UnsafeNumericCast<char>(c - ('a' - 'A'));
-		}
-		return c;
-	}
-	static char CharacterToLower(char c) {
-		if (c >= 'A' && c <= 'Z') {
-			return UnsafeNumericCast<char>(c + ('a' - 'A'));
-		}
-		return c;
-	}
-	static bool CharacterIsAlpha(char c) {
-		return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-	}
-	static bool CharacterIsAlphaNumeric(char c) {
-		return CharacterIsAlpha(c) || CharacterIsDigit(c);
-	}
-	static bool CharacterIsOperator(char c) {
-		if (c == '_') {
-			return false;
-		}
-		if (c >= '!' && c <= '/') {
-			return true;
-		}
-		if (c >= ':' && c <= '@') {
-			return true;
-		}
-		if (c >= '[' && c <= '`') {
-			return true;
-		}
-		if (c >= '{' && c <= '~') {
-			return true;
-		}
-		return false;
-	}
-
-	template <class TO>
-	static vector<TO> ConvertStrings(const vector<string> &strings) {
-		vector<TO> result;
-		for (auto &string : strings) {
-			result.emplace_back(string);
-		}
-		return result;
-	}
-
-	static vector<SQLIdentifier> ConvertToSQLIdentifiers(const vector<string> &strings) {
-		return ConvertStrings<SQLIdentifier>(strings);
-	}
-
-	static vector<SQLString> ConvertToSQLStrings(const vector<string> &strings) {
-		return ConvertStrings<SQLString>(strings);
-	}
-
-	//! Returns true if the needle string exists in the haystack
-	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
-	DUCKDB_API static bool Contains(const string &haystack, const char &needle_char);
-
-	//! Returns the position of needle string within the haystack
-	DUCKDB_API static optional_idx Find(const string &haystack, const string &needle);
-
-	//! Returns true if the target string starts with the given prefix
-	DUCKDB_API static bool StartsWith(string str, string prefix);
-
-	//! Returns true if the target string <b>ends</b> with the given suffix.
-	DUCKDB_API static bool EndsWith(const string &str, const string &suffix);
-
-	//! Repeat a string multiple times
-	DUCKDB_API static string Repeat(const string &str, const idx_t n);
-
-	//! Split the input string based on newline char
-	DUCKDB_API static vector<string> Split(const string &str, char delimiter);
-
-	//! Split the input string, ignore delimiters within parentheses. Note: leading/trailing spaces are NOT stripped
-	DUCKDB_API static vector<string> SplitWithParentheses(const string &str, char delimiter = ',', char par_open = '(',
-	                                                      char par_close = ')');
-
-	//! Split the input string allong a quote. Note that any escaping is NOT supported.
-	DUCKDB_API static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
-
-	//! Join multiple strings into one string. Components are concatenated by the given separator
-	DUCKDB_API static string Join(const vector<string> &input, const string &separator);
-	DUCKDB_API static string Join(const set<string> &input, const string &separator);
-
-	//! Encode special URL characters in a string
-	DUCKDB_API static string URLEncode(const string &str, bool encode_slash = true);
-	DUCKDB_API static idx_t URLEncodeSize(const char *input, idx_t input_size, bool encode_slash = true);
-	DUCKDB_API static void URLEncodeBuffer(const char *input, idx_t input_size, char *output, bool encode_slash = true);
-	//! Decode URL escape sequences (e.g. %20) in a string
-	DUCKDB_API static string URLDecode(const string &str, bool plus_to_space = false);
-	DUCKDB_API static idx_t URLDecodeSize(const char *input, idx_t input_size, bool plus_to_space = false);
-	DUCKDB_API static void URLDecodeBuffer(const char *input, idx_t input_size, char *output,
-	                                       bool plus_to_space = false);
-
-	DUCKDB_API static idx_t ToUnsigned(const string &str);
-
-	template <class T>
-	static string ToString(const vector<T> &input, const string &separator) {
-		vector<string> input_list;
-		for (auto &i : input) {
-			input_list.push_back(i.ToString());
-		}
-		return StringUtil::Join(input_list, separator);
-	}
-
-	//! Join multiple items of container with given size, transformed to string
-	//! using function, into one string using the given separator
-	template <typename C, typename S, typename FUNC>
-	static string Join(const C &input, S count, const string &separator, FUNC f) {
-		// The result
-		std::string result;
-
-		// If the input isn't empty, append the first element. We do this so we
-		// don't need to introduce an if into the loop.
-		if (count > 0) {
-			result += f(input[0]);
-		}
-
-		// Append the remaining input components, after the first
-		for (size_t i = 1; i < count; i++) {
-			result += separator + f(input[i]);
-		}
-
-		return result;
-	}
-
-	//! Return a string that formats the give number of bytes
-	DUCKDB_API static string BytesToHumanReadableString(idx_t bytes, idx_t multiplier = 1024);
-
-	//! Convert a string to UPPERCASE
-	DUCKDB_API static string Upper(const string &str);
-
-	//! Convert a string to lowercase
-	DUCKDB_API static string Lower(const string &str);
-
-	//! Convert a string to Title Case
-	DUCKDB_API static string Title(const string &str);
-
-	DUCKDB_API static bool IsLower(const string &str);
-	DUCKDB_API static bool IsUpper(const string &str);
-
-	//! Case insensitive hash
-	DUCKDB_API static uint64_t CIHash(const string &str);
-
-	//! Case insensitive equals
-	DUCKDB_API static bool CIEquals(const string &l1, const string &l2);
-
-	//! Case insensitive compare
-	DUCKDB_API static bool CILessThan(const string &l1, const string &l2);
-
-	//! Case insensitive find, returns DConstants::INVALID_INDEX if not found
-	DUCKDB_API static idx_t CIFind(vector<string> &vec, const string &str);
-
-	//! Format a string using printf semantics
-	template <typename... ARGS>
-	static string Format(const string fmt_str, ARGS... params) {
-		return Exception::ConstructMessage(fmt_str, params...);
-	}
-
-	//! Split the input string into a vector of strings based on the split string
-	DUCKDB_API static vector<string> Split(const string &input, const string &split);
-
-	//! Remove the whitespace char in the left end of the string
-	DUCKDB_API static void LTrim(string &str);
-	//! Remove the whitespace char in the right end of the string
-	DUCKDB_API static void RTrim(string &str);
-	//! Remove the all chars from chars_to_trim char in the right end of the string
-	DUCKDB_API static void RTrim(string &str, const string &chars_to_trim);
-	//! Remove the whitespace char in the left and right end of the string
-	DUCKDB_API static void Trim(string &str);
-
-	DUCKDB_API static string Replace(string source, const string &from, const string &to);
-
-	//! Get the levenshtein distance from two strings
-	//! The not_equal_penalty is the penalty given when two characters in a string are not equal
-	//! The regular levenshtein distance has a not equal penalty of 1, which means changing a character is as expensive
-	//! as adding or removing one For similarity searches we often want to give extra weight to changing a character For
-	//! example: with an equal penalty of 1, "pg_am" is closer to "depdelay" than "depdelay_minutes"
-	//! with an equal penalty of 3, "depdelay_minutes" is closer to "depdelay" than to "pg_am"
-	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2, idx_t not_equal_penalty = 1);
-
-	//! Returns the similarity score between two strings (edit distance metric - lower is more similar)
-	DUCKDB_API static idx_t SimilarityScore(const string &s1, const string &s2);
-	//! Returns a normalized similarity rating between 0.0 - 1.0 (higher is more similar)
-	DUCKDB_API static double SimilarityRating(const string &s1, const string &s2);
-	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
-	//! The scores should be normalized between 0.0 and 1.0, where 1.0 is the highest score
-	//! At least one entry is returned (if there is one).
-	//! Strings are only returned if they have a score higher than the threshold.
-	DUCKDB_API static vector<string> TopNStrings(vector<pair<string, double>> scores, idx_t n = 5,
-	                                             double threshold = 0.5);
-	//! DEPRECATED: old TopNStrings method that uses the levenshtein distance metric instead of the normalized 0.0 - 1.0
-	//! rating
-	DUCKDB_API static vector<string> TopNStrings(const vector<pair<string, idx_t>> &scores, idx_t n = 5,
-	                                             idx_t threshold = 5);
-	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
-	//! with the given params.
-	DUCKDB_API static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
-	                                                 idx_t threshold = 5);
-	//! Computes the jaro winkler distance of each string in strings, and compares it to target, then returns
-	//! TopNStrings with the given params.
-	DUCKDB_API static vector<string> TopNJaroWinkler(const vector<string> &strings, const string &target, idx_t n = 5,
-	                                                 double threshold = 0.5);
-	DUCKDB_API static string CandidatesMessage(const vector<string> &candidates,
-	                                           const string &candidate = "Candidate bindings");
-
-	//! Generate an error message in the form of "{message_prefix}: nearest_string, nearest_string2, ...
-	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
-	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
-	                                                const string &message_prefix, idx_t n = 5);
-
-	//! Returns true if two null-terminated strings are equal or point to the same address.
-	//! Returns false if only one of the strings is nullptr
-	static bool Equals(const char *s1, const char *s2) {
-		if (s1 == s2) {
-			return true;
-		}
-		if (s1 == nullptr || s2 == nullptr) {
-			return false;
-		}
-		return strcmp(s1, s2) == 0;
-	}
-
-	//! JSON method that parses a { string: value } JSON blob
-	//! NOTE: this method ONLY parses a JSON {"key": "value"} object, it does not support ANYTHING else
-	//! NOTE: this method is not efficient
-	//! NOTE: this method is used in Exception construction - as such it does NOT throw on invalid JSON, instead an
-	//! empty map is returned
-	DUCKDB_API static unordered_map<string, string> ParseJSONMap(const string &json);
-	//! JSON method that constructs a { string: value } JSON map
-	//! This is the inverse of ParseJSONMap
-	//! NOTE: this method is not efficient
-	DUCKDB_API static string ExceptionToJSONMap(ExceptionType type, const string &message,
-	                                            const unordered_map<string, string> &map);
-
-	DUCKDB_API static string ToJSONMap(const unordered_map<string, string> &map);
-
-	DUCKDB_API static string GetFileName(const string &file_path);
-	DUCKDB_API static string GetFileExtension(const string &file_name);
-	DUCKDB_API static string GetFileStem(const string &file_name);
-	DUCKDB_API static string GetFilePath(const string &file_path);
-
-	struct EnumStringLiteral {
-		uint32_t number;
-		const char *string;
-	};
-
-	DUCKDB_API static uint32_t StringToEnum(const EnumStringLiteral enum_list[], idx_t enum_count,
-	                                        const char *enum_name, const char *str_value);
-	DUCKDB_API static const char *EnumToString(const EnumStringLiteral enum_list[], idx_t enum_count,
-	                                           const char *enum_name, uint32_t enum_value);
-	DUCKDB_API static const uint8_t ASCII_TO_LOWER_MAP[];
-	DUCKDB_API static const uint8_t ASCII_TO_UPPER_MAP[];
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/swap.hpp b/src/duckdb/src/include/duckdb/common/swap.hpp
deleted file mode 100644
index ef305da1f..000000000
--- a/src/duckdb/src/include/duckdb/common/swap.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/swap.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <utility>
-
-namespace duckdb {
-using std::swap;
-}
diff --git a/src/duckdb/src/include/duckdb/common/thread.hpp b/src/duckdb/src/include/duckdb/common/thread.hpp
deleted file mode 100644
index 7540dfc50..000000000
--- a/src/duckdb/src/include/duckdb/common/thread.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/thread.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <thread>
-
-namespace duckdb {
-using std::thread;
-}
diff --git a/src/duckdb/src/include/duckdb/common/to_string.hpp b/src/duckdb/src/include/duckdb/common/to_string.hpp
deleted file mode 100644
index f7afe6ee4..000000000
--- a/src/duckdb/src/include/duckdb/common/to_string.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/to_string.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-using std::to_string;
-}
diff --git a/src/duckdb/src/include/duckdb/common/tree_renderer.hpp b/src/duckdb/src/include/duckdb/common/tree_renderer.hpp
deleted file mode 100644
index 981836b63..000000000
--- a/src/duckdb/src/include/duckdb/common/tree_renderer.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/tree_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/profiling_node.hpp"
-#include "duckdb/common/render_tree.hpp"
-
-namespace duckdb {
-
-class TreeRenderer {
-public:
-	explicit TreeRenderer() {
-	}
-	virtual ~TreeRenderer() {
-	}
-
-public:
-	void ToStream(RenderTree &root, std::ostream &ss);
-	virtual void ToStreamInternal(RenderTree &root, std::ostream &ss) = 0;
-	static unique_ptr<TreeRenderer> CreateRenderer(ExplainFormat format);
-
-	virtual bool UsesRawKeyNames() {
-		return false;
-	}
-	virtual void Render(const ProfilingNode &op, std::ostream &ss) {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/tree_renderer/graphviz_tree_renderer.hpp b/src/duckdb/src/include/duckdb/common/tree_renderer/graphviz_tree_renderer.hpp
deleted file mode 100644
index a4ed7f75f..000000000
--- a/src/duckdb/src/include/duckdb/common/tree_renderer/graphviz_tree_renderer.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/graphviz_tree_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/profiling_node.hpp"
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/render_tree.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-class GRAPHVIZTreeRenderer : public TreeRenderer {
-public:
-	explicit GRAPHVIZTreeRenderer() {
-	}
-	~GRAPHVIZTreeRenderer() override {
-	}
-
-public:
-	string ToString(const LogicalOperator &op);
-	string ToString(const PhysicalOperator &op);
-	string ToString(const ProfilingNode &op);
-	string ToString(const Pipeline &op);
-
-	void Render(const LogicalOperator &op, std::ostream &ss);
-	void Render(const PhysicalOperator &op, std::ostream &ss);
-	void Render(const ProfilingNode &op, std::ostream &ss) override;
-	void Render(const Pipeline &op, std::ostream &ss);
-
-	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/tree_renderer/html_tree_renderer.hpp b/src/duckdb/src/include/duckdb/common/tree_renderer/html_tree_renderer.hpp
deleted file mode 100644
index e5d038a27..000000000
--- a/src/duckdb/src/include/duckdb/common/tree_renderer/html_tree_renderer.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/html_tree_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/profiling_node.hpp"
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/render_tree.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-class HTMLTreeRenderer : public TreeRenderer {
-public:
-	explicit HTMLTreeRenderer() {
-	}
-	~HTMLTreeRenderer() override {
-	}
-
-public:
-	string ToString(const LogicalOperator &op);
-	string ToString(const PhysicalOperator &op);
-	string ToString(const ProfilingNode &op);
-	string ToString(const Pipeline &op);
-
-	void Render(const LogicalOperator &op, std::ostream &ss);
-	void Render(const PhysicalOperator &op, std::ostream &ss);
-	void Render(const ProfilingNode &op, std::ostream &ss) override;
-	void Render(const Pipeline &op, std::ostream &ss);
-
-	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/tree_renderer/json_tree_renderer.hpp b/src/duckdb/src/include/duckdb/common/tree_renderer/json_tree_renderer.hpp
deleted file mode 100644
index 15e7c5037..000000000
--- a/src/duckdb/src/include/duckdb/common/tree_renderer/json_tree_renderer.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/json_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/profiling_node.hpp"
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/render_tree.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-class JSONTreeRenderer : public TreeRenderer {
-public:
-	explicit JSONTreeRenderer() {
-	}
-	~JSONTreeRenderer() override {
-	}
-
-public:
-	string ToString(const LogicalOperator &op);
-	string ToString(const PhysicalOperator &op);
-	string ToString(const ProfilingNode &op);
-	string ToString(const Pipeline &op);
-
-	void Render(const LogicalOperator &op, std::ostream &ss);
-	void Render(const PhysicalOperator &op, std::ostream &ss);
-	void Render(const ProfilingNode &op, std::ostream &ss) override;
-	void Render(const Pipeline &op, std::ostream &ss);
-
-	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/tree_renderer/text_tree_renderer.hpp b/src/duckdb/src/include/duckdb/common/tree_renderer/text_tree_renderer.hpp
deleted file mode 100644
index 1bf43191a..000000000
--- a/src/duckdb/src/include/duckdb/common/tree_renderer/text_tree_renderer.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/tree_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/profiling_node.hpp"
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/render_tree.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-struct TextTreeRendererConfig {
-	void EnableDetailed() {
-		max_extra_lines = 1000;
-		detailed = true;
-	}
-
-	void EnableStandard() {
-		max_extra_lines = 30;
-		detailed = false;
-	}
-
-	idx_t maximum_render_width = 240;
-	idx_t node_render_width = 29;
-	idx_t minimum_render_width = 15;
-	idx_t max_extra_lines = 30;
-	bool detailed = false;
-
-#ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "\342\224\214"; // NOLINT "┌";
-	const char *RTCORNER = "\342\224\220"; // NOLINT "┐";
-	const char *LDCORNER = "\342\224\224"; // NOLINT "└";
-	const char *RDCORNER = "\342\224\230"; // NOLINT "┘";
-
-	const char *MIDDLE = "\342\224\274";  // NOLINT "┼";
-	const char *TMIDDLE = "\342\224\254"; // NOLINT "┬";
-	const char *LMIDDLE = "\342\224\234"; // NOLINT "├";
-	const char *RMIDDLE = "\342\224\244"; // NOLINT "┤";
-	const char *DMIDDLE = "\342\224\264"; // NOLINT "┴";
-
-	const char *VERTICAL = "\342\224\202";   // NOLINT "│";
-	const char *HORIZONTAL = "\342\224\200"; // NOLINT "─";
-#else
-	// ASCII version
-	const char *LTCORNER = "<";
-	const char *RTCORNER = ">";
-	const char *LDCORNER = "<";
-	const char *RDCORNER = ">";
-
-	const char *MIDDLE = "+";
-	const char *TMIDDLE = "+";
-	const char *LMIDDLE = "+";
-	const char *RMIDDLE = "+";
-	const char *DMIDDLE = "+";
-
-	const char *VERTICAL = "|";
-	const char *HORIZONTAL = "-";
-#endif
-};
-
-class TextTreeRenderer : public TreeRenderer {
-public:
-	explicit TextTreeRenderer(TextTreeRendererConfig config_p = TextTreeRendererConfig()) : config(config_p) {
-	}
-	~TextTreeRenderer() override {
-	}
-
-public:
-	string ToString(const LogicalOperator &op);
-	string ToString(const PhysicalOperator &op);
-	string ToString(const ProfilingNode &op);
-	string ToString(const Pipeline &op);
-
-	void Render(const LogicalOperator &op, std::ostream &ss);
-	void Render(const PhysicalOperator &op, std::ostream &ss);
-	void Render(const ProfilingNode &op, std::ostream &ss) override;
-	void Render(const Pipeline &op, std::ostream &ss);
-
-	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
-
-	void EnableDetailed() {
-		config.EnableDetailed();
-	}
-	void EnableStandard() {
-		config.EnableStandard();
-	}
-	bool UsesRawKeyNames() override {
-		return true;
-	}
-
-private:
-	//! The configuration used for rendering
-	TextTreeRendererConfig config;
-
-private:
-	string ExtraInfoSeparator();
-	void RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y);
-	void RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y);
-	void RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y);
-
-	bool CanSplitOnThisChar(char l);
-	bool IsPadding(char l);
-	string RemovePadding(string l);
-	void SplitUpExtraInfo(const InsertionOrderPreservingMap<string> &extra_info, vector<string> &result,
-	                      idx_t max_lines);
-	void SplitStringBuffer(const string &source, vector<string> &result);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/type_util.hpp b/src/duckdb/src/include/duckdb/common/type_util.hpp
deleted file mode 100644
index d63f528ba..000000000
--- a/src/duckdb/src/include/duckdb/common/type_util.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/type_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/datetime.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-//! Returns the PhysicalType for the given type
-template <class T>
-PhysicalType GetTypeId() {
-	if (std::is_same<T, bool>()) {
-		return PhysicalType::BOOL;
-	} else if (std::is_same<T, int8_t>()) {
-		return PhysicalType::INT8;
-	} else if (std::is_same<T, int16_t>()) {
-		return PhysicalType::INT16;
-	} else if (std::is_same<T, int32_t>()) {
-		return PhysicalType::INT32;
-	} else if (std::is_same<T, int64_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, uint8_t>()) {
-		return PhysicalType::UINT8;
-	} else if (std::is_same<T, uint16_t>()) {
-		return PhysicalType::UINT16;
-	} else if (std::is_same<T, uint32_t>()) {
-		return PhysicalType::UINT32;
-	} else if (std::is_same<T, uint64_t>()) {
-		return PhysicalType::UINT64;
-	} else if (std::is_same<T, hugeint_t>()) {
-		return PhysicalType::INT128;
-	} else if (std::is_same<T, uhugeint_t>()) {
-		return PhysicalType::UINT128;
-	} else if (std::is_same<T, date_t>()) {
-		return PhysicalType::INT32;
-	} else if (std::is_same<T, dtime_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, timestamp_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, timestamp_sec_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, timestamp_ms_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, timestamp_ns_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, timestamp_tz_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, float>()) {
-		return PhysicalType::FLOAT;
-	} else if (std::is_same<T, double>()) {
-		return PhysicalType::DOUBLE;
-	} else if (std::is_same<T, const char *>() || std::is_same<T, char *>() || std::is_same<T, string_t>()) {
-		return PhysicalType::VARCHAR;
-	} else if (std::is_same<T, interval_t>()) {
-		return PhysicalType::INTERVAL;
-	} else {
-		return PhysicalType::INVALID;
-	}
-}
-
-template <class T>
-bool TypeIsNumber() {
-	return std::is_integral<T>() || std::is_floating_point<T>() || std::is_same<T, hugeint_t>() ||
-	       std::is_same<T, uhugeint_t>();
-}
-
-template <class T>
-bool IsValidType() {
-	return GetTypeId<T>() != PhysicalType::INVALID;
-}
-
-template <class T>
-bool IsIntegerType() {
-	return TypeIsIntegral(GetTypeId<T>());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/type_visitor.hpp b/src/duckdb/src/include/duckdb/common/type_visitor.hpp
deleted file mode 100644
index 9296a75db..000000000
--- a/src/duckdb/src/include/duckdb/common/type_visitor.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/type_visitor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-struct TypeVisitor {
-	template <class F>
-	static bool Contains(const LogicalType &type, F &&predicate);
-
-	static bool Contains(const LogicalType &type, LogicalTypeId type_id);
-
-	template <class F>
-	static LogicalType VisitReplace(const LogicalType &type, F &&func);
-};
-
-template <class F>
-inline LogicalType TypeVisitor::VisitReplace(const LogicalType &type, F &&func) {
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT: {
-		auto children = StructType::GetChildTypes(type);
-		for (auto &child : children) {
-			child.second = VisitReplace(child.second, func);
-		}
-		return func(LogicalType::STRUCT(children));
-	}
-	case LogicalTypeId::UNION: {
-		auto children = UnionType::CopyMemberTypes(type);
-		for (auto &child : children) {
-			child.second = VisitReplace(child.second, func);
-		}
-		return func(LogicalType::UNION(children));
-	}
-	case LogicalTypeId::LIST: {
-		auto child = ListType::GetChildType(type);
-		return func(LogicalType::LIST(VisitReplace(child, func)));
-	}
-	case LogicalTypeId::ARRAY: {
-		auto child = ArrayType::GetChildType(type);
-		return func(LogicalType::ARRAY(VisitReplace(child, func), ArrayType::GetSize(type)));
-	}
-	case LogicalTypeId::MAP: {
-		auto key = MapType::KeyType(type);
-		auto value = MapType::ValueType(type);
-		return func(LogicalType::MAP(VisitReplace(key, func), VisitReplace(value, func)));
-	}
-	default:
-		return func(type);
-	}
-}
-
-template <class F>
-inline bool TypeVisitor::Contains(const LogicalType &type, F &&predicate) {
-	if (predicate(type)) {
-		return true;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT: {
-		for (const auto &child : StructType::GetChildTypes(type)) {
-			if (Contains(child.second, predicate)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	case LogicalTypeId::UNION:
-		for (const auto &child : UnionType::CopyMemberTypes(type)) {
-			if (Contains(child.second, predicate)) {
-				return true;
-			}
-		}
-		return false;
-	case LogicalTypeId::LIST:
-		return Contains(ListType::GetChildType(type), predicate);
-	case LogicalTypeId::ARRAY:
-		return Contains(ArrayType::GetChildType(type), predicate);
-	case LogicalTypeId::MAP:
-		return Contains(MapType::KeyType(type), predicate) || Contains(MapType::ValueType(type), predicate);
-	default:
-		return false;
-	}
-}
-
-inline bool TypeVisitor::Contains(const LogicalType &type, LogicalTypeId type_id) {
-	return Contains(type, [&](const LogicalType &ty) { return ty.id() == type_id; });
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/typedefs.hpp b/src/duckdb/src/include/duckdb/common/typedefs.hpp
deleted file mode 100644
index a3bc4ac9a..000000000
--- a/src/duckdb/src/include/duckdb/common/typedefs.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/typedefs.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <cstdint>
-
-namespace duckdb {
-
-//! a saner size_t for loop indices etc
-typedef uint64_t idx_t;
-
-//! The type used for row identifiers
-typedef int64_t row_t;
-
-//! The type used for hashes
-typedef uint64_t hash_t;
-
-//! data pointers
-typedef uint8_t data_t;
-typedef data_t *data_ptr_t;
-typedef const data_t *const_data_ptr_t;
-
-//! Type used for the selection vector
-typedef uint32_t sel_t;
-//! Type used for transaction timestamps
-typedef idx_t transaction_t;
-
-//! Type used for column identifiers
-typedef idx_t column_t;
-//! Type used for storage (column) identifiers
-typedef idx_t storage_t;
-
-template <class SRC>
-data_ptr_t data_ptr_cast(SRC *src) { // NOLINT: naming
-	return reinterpret_cast<data_ptr_t>(src);
-}
-
-template <class SRC>
-const_data_ptr_t const_data_ptr_cast(const SRC *src) { // NOLINT: naming
-	return reinterpret_cast<const_data_ptr_t>(src);
-}
-
-template <class SRC>
-char *char_ptr_cast(SRC *src) { // NOLINT: naming
-	return reinterpret_cast<char *>(src);
-}
-
-template <class SRC>
-const char *const_char_ptr_cast(const SRC *src) { // NOLINT: naming
-	return reinterpret_cast<const char *>(src);
-}
-
-template <class SRC>
-const unsigned char *const_uchar_ptr_cast(const SRC *src) { // NOLINT: naming
-	return reinterpret_cast<const unsigned char *>(src);
-}
-
-template <class SRC>
-uintptr_t CastPointerToValue(SRC *src) {
-	return reinterpret_cast<uintptr_t>(src);
-}
-
-template <class SRC>
-uint64_t cast_pointer_to_uint64(SRC *src) {
-	return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src));
-}
-
-template <class SRC = data_t>
-SRC *cast_uint64_to_pointer(uint64_t value) {
-	return reinterpret_cast<SRC *>(static_cast<uintptr_t>(value));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types.hpp b/src/duckdb/src/include/duckdb/common/types.hpp
deleted file mode 100644
index 1bc43811a..000000000
--- a/src/duckdb/src/include/duckdb/common/types.hpp
+++ /dev/null
@@ -1,554 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/helper.hpp"
-
-#include <limits>
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-class Value;
-class TypeCatalogEntry;
-class Vector;
-class ClientContext;
-
-struct string_t; // NOLINT: mimic std casing
-
-template <class T>
-using child_list_t = vector<std::pair<std::string, T>>;
-//! FIXME: this should be a single_thread_ptr
-template <class T>
-using buffer_ptr = shared_ptr<T>;
-
-template <class T, typename... ARGS>
-buffer_ptr<T> make_buffer(ARGS &&...args) { // NOLINT: mimic std casing
-	return make_shared_ptr<T>(std::forward<ARGS>(args)...);
-}
-
-struct list_entry_t { // NOLINT: mimic std casing
-	list_entry_t() = default;
-	list_entry_t(uint64_t offset, uint64_t length) : offset(offset), length(length) {
-	}
-	inline constexpr bool operator!=(const list_entry_t &other) const {
-		return !(*this == other);
-	}
-	inline constexpr bool operator==(const list_entry_t &other) const {
-		return offset == other.offset && length == other.length;
-	}
-
-	uint64_t offset;
-	uint64_t length;
-};
-
-using union_tag_t = uint8_t;
-
-//===--------------------------------------------------------------------===//
-// Internal Types
-//===--------------------------------------------------------------------===//
-
-// taken from arrow's type.h
-enum class PhysicalType : uint8_t {
-	///// A NULL type having no physical storage
-	// NA = 0,
-
-	/// Boolean as 8 bit "bool" value
-	BOOL = 1,
-
-	/// Unsigned 8-bit little-endian integer
-	UINT8 = 2,
-
-	/// Signed 8-bit little-endian integer
-	INT8 = 3,
-
-	/// Unsigned 16-bit little-endian integer
-	UINT16 = 4,
-
-	/// Signed 16-bit little-endian integer
-	INT16 = 5,
-
-	/// Unsigned 32-bit little-endian integer
-	UINT32 = 6,
-
-	/// Signed 32-bit little-endian integer
-	INT32 = 7,
-
-	/// Unsigned 64-bit little-endian integer
-	UINT64 = 8,
-
-	/// Signed 64-bit little-endian integer
-	INT64 = 9,
-
-	///// 2-byte floating point value
-	// HALF_FLOAT = 10,
-
-	/// 4-byte floating point value
-	FLOAT = 11,
-
-	/// 8-byte floating point value
-	DOUBLE = 12,
-
-	///// UTF8 variable-length string as List<Char>
-	// STRING = 13,
-
-	///// Variable-length bytes (no guarantee of UTF8-ness)
-	// BINARY = 14,
-
-	///// Fixed-size binary. Each value occupies the same number of bytes
-	// FIXED_SIZE_BINARY = 15,
-
-	///// int32_t days since the UNIX epoch
-	// DATE32 = 16,
-
-	///// int64_t milliseconds since the UNIX epoch
-	// DATE64 = 17,
-
-	///// Exact timestamp encoded with int64 since UNIX epoch
-	///// Default unit millisecond
-	// TIMESTAMP = 18,
-
-	///// Time as signed 32-bit integer, representing either seconds or
-	///// milliseconds since midnight
-	// TIME32 = 19,
-
-	///// Time as signed 64-bit integer, representing either microseconds or
-	///// nanoseconds since midnight
-	// TIME64 = 20,
-
-	/// YEAR_MONTH or DAY_TIME interval in SQL style
-	INTERVAL = 21,
-
-	/// Precision- and scale-based decimal type. Storage type depends on the
-	/// parameters.
-	// DECIMAL = 22,
-
-	/// A list of some logical data type
-	LIST = 23,
-
-	/// Struct of logical types
-	STRUCT = 24,
-
-	///// Unions of logical types
-	// UNION = 25,
-
-	///// Dictionary-encoded type, also called "categorical" or "factor"
-	///// in other programming languages. Holds the dictionary value
-	///// type but not the dictionary itself, which is part of the
-	///// ArrayData struct
-	// DICTIONARY = 26,
-
-	///// Custom data type, implemented by user
-	// EXTENSION = 28,
-
-	///// Array with fixed length of some logical type (a fixed-size list)
-	ARRAY = 29,
-
-	///// Measure of elapsed time in either seconds, milliseconds, microseconds
-	///// or nanoseconds.
-	// DURATION = 30,
-
-	///// Like STRING, but with 64-bit offsets
-	// LARGE_STRING = 31,
-
-	///// Like BINARY, but with 64-bit offsets
-	// LARGE_BINARY = 32,
-
-	///// Like LIST, but with 64-bit offsets
-	// LARGE_LIST = 33,
-
-	/// DuckDB Extensions
-	VARCHAR = 200, // our own string representation, different from STRING and LARGE_STRING above
-	UINT128 = 203, // 128-bit unsigned integers
-	INT128 = 204, // 128-bit integers
-	UNKNOWN = 205, // Unknown physical type of user defined types
-	/// Boolean as 1 bit, LSB bit-packed ordering
-	BIT = 206,
-
-	INVALID = 255
-};
-
-//===--------------------------------------------------------------------===//
-// SQL Types
-//===--------------------------------------------------------------------===//
-enum class LogicalTypeId : uint8_t {
-	INVALID = 0,
-	SQLNULL = 1, /* NULL type, used for constant NULL */
-	UNKNOWN = 2, /* unknown type, used for parameter expressions */
-	ANY = 3,     /* ANY type, used for functions that accept any type as parameter */
-	USER = 4,    /* A User Defined Type (e.g., ENUMs before the binder) */
-	BOOLEAN = 10,
-	TINYINT = 11,
-	SMALLINT = 12,
-	INTEGER = 13,
-	BIGINT = 14,
-	DATE = 15,
-	TIME = 16,
-	TIMESTAMP_SEC = 17,
-	TIMESTAMP_MS = 18,
-	TIMESTAMP = 19, //! us
-	TIMESTAMP_NS = 20,
-	DECIMAL = 21,
-	FLOAT = 22,
-	DOUBLE = 23,
-	CHAR = 24,
-	VARCHAR = 25,
-	BLOB = 26,
-	INTERVAL = 27,
-	UTINYINT = 28,
-	USMALLINT = 29,
-	UINTEGER = 30,
-	UBIGINT = 31,
-	TIMESTAMP_TZ = 32,
-	TIME_TZ = 34,
-	BIT = 36,
-	STRING_LITERAL = 37, /* string literals, used for constant strings - only exists while binding */
-	INTEGER_LITERAL = 38,/* integer literals, used for constant integers - only exists while binding */
-	VARINT = 39,
-	UHUGEINT = 49,
-	HUGEINT = 50,
-	POINTER = 51,
-	VALIDITY = 53,
-	UUID = 54,
-
-	STRUCT = 100,
-	LIST = 101,
-	MAP = 102,
-	TABLE = 103,
-	ENUM = 104,
-	AGGREGATE_STATE = 105,
-	LAMBDA = 106,
-	UNION = 107,
-	ARRAY = 108
-};
-
-struct ExtraTypeInfo;
-struct ExtensionTypeInfo;
-
-struct aggregate_state_t; // NOLINT: mimic std casing
-
-struct LogicalType {
-	DUCKDB_API LogicalType();
-	DUCKDB_API LogicalType(LogicalTypeId id); // NOLINT: Allow implicit conversion from `LogicalTypeId`
-	DUCKDB_API LogicalType(LogicalTypeId id, shared_ptr<ExtraTypeInfo> type_info);
-	DUCKDB_API LogicalType(const LogicalType &other);
-	DUCKDB_API LogicalType(LogicalType &&other) noexcept;
-
-	DUCKDB_API ~LogicalType();
-
-	inline LogicalTypeId id() const { // NOLINT: mimic std casing
-		return id_;
-	}
-	inline PhysicalType InternalType() const {
-		return physical_type_;
-	}
-	inline const optional_ptr<ExtraTypeInfo> AuxInfo() const {
-		return type_info_.get();
-	}
-	inline bool IsNested() const {
-		auto internal = InternalType();
-		if (internal == PhysicalType::STRUCT) {
-			return true;
-		}
-		if (internal == PhysicalType::LIST) {
-			return true;
-		}
-		if (internal == PhysicalType::ARRAY) {
-			return true;
-		}
-		return false;
-	}
-
-	inline shared_ptr<ExtraTypeInfo> GetAuxInfoShrPtr() const {
-		return type_info_;
-	}
-
-	//! DeepCopy() will make a unique copy of any ExtraTypeInfo as well
-	LogicalType DeepCopy() const;
-
-	inline void CopyAuxInfo(const LogicalType &other) {
-		type_info_ = other.type_info_;
-	}
-	bool EqualTypeInfo(const LogicalType &rhs) const;
-
-	// copy assignment
-	inline LogicalType &operator=(const LogicalType &other) {
-		if (this == &other) {
-			return *this;
-		}
-		id_ = other.id_;
-		physical_type_ = other.physical_type_;
-		type_info_ = other.type_info_;
-		return *this;
-	}
-	// move assignment
-	inline LogicalType &operator=(LogicalType &&other) noexcept {
-		id_ = other.id_;
-		physical_type_ = other.physical_type_;
-		std::swap(type_info_, other.type_info_);
-		return *this;
-	}
-
-	DUCKDB_API bool operator==(const LogicalType &rhs) const;
-	inline bool operator!=(const LogicalType &rhs) const {
-		return !(*this == rhs);
-	}
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static LogicalType Deserialize(Deserializer &deserializer);
-
-	static bool TypeIsTimestamp(LogicalTypeId id) {
-		return (id == LogicalTypeId::TIMESTAMP || id == LogicalTypeId::TIMESTAMP_MS ||
-		        id == LogicalTypeId::TIMESTAMP_NS || id == LogicalTypeId::TIMESTAMP_SEC ||
-		        id == LogicalTypeId::TIMESTAMP_TZ);
-	}
-	static bool TypeIsTimestamp(const LogicalType &type) {
-		return TypeIsTimestamp(type.id());
-	}
-	DUCKDB_API string ToString() const;
-	DUCKDB_API bool IsIntegral() const;
-	DUCKDB_API bool IsNumeric() const;
-	DUCKDB_API bool IsTemporal() const;
-	DUCKDB_API hash_t Hash() const;
-	DUCKDB_API void SetAlias(string alias);
-	DUCKDB_API bool HasAlias() const;
-	DUCKDB_API string GetAlias() const;
-
-	DUCKDB_API bool HasExtensionInfo() const;
-	DUCKDB_API optional_ptr<const ExtensionTypeInfo> GetExtensionInfo() const;
-	DUCKDB_API optional_ptr<ExtensionTypeInfo> GetExtensionInfo();
-	DUCKDB_API void SetExtensionInfo(unique_ptr<ExtensionTypeInfo> info);
-
-	//! Returns the maximum logical type when combining the two types - or throws an exception if combining is not possible
-	DUCKDB_API static LogicalType MaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right);
-	DUCKDB_API static bool TryGetMaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right, LogicalType &result);
-	//! Forcibly returns a maximum logical type - similar to MaxLogicalType but never throws. As a fallback either left or right are returned.
-	DUCKDB_API static LogicalType ForceMaxLogicalType(const LogicalType &left, const LogicalType &right);
-	//! Normalize a type - removing literals
-	DUCKDB_API static LogicalType NormalizeType(const LogicalType &type);
-
-
-	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
-	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
-
-	DUCKDB_API void Verify() const;
-
-	DUCKDB_API bool IsValid() const;
-	DUCKDB_API bool IsComplete() const;
-
-	//! True, if this type supports in-place updates.
-	bool SupportsRegularUpdate() const;
-
-
-private:
-	LogicalTypeId id_; // NOLINT: allow this naming for legacy reasons
-	PhysicalType physical_type_; // NOLINT: allow this naming for legacy reasons
-	shared_ptr<ExtraTypeInfo> type_info_; // NOLINT: allow this naming for legacy reasons
-
-private:
-	PhysicalType GetInternalType();
-
-public:
-	static constexpr const LogicalTypeId SQLNULL = LogicalTypeId::SQLNULL;
-	static constexpr const LogicalTypeId UNKNOWN = LogicalTypeId::UNKNOWN;
-	static constexpr const LogicalTypeId BOOLEAN = LogicalTypeId::BOOLEAN;
-	static constexpr const LogicalTypeId TINYINT = LogicalTypeId::TINYINT;
-	static constexpr const LogicalTypeId UTINYINT = LogicalTypeId::UTINYINT;
-	static constexpr const LogicalTypeId SMALLINT = LogicalTypeId::SMALLINT;
-	static constexpr const LogicalTypeId USMALLINT = LogicalTypeId::USMALLINT;
-	static constexpr const LogicalTypeId INTEGER = LogicalTypeId::INTEGER;
-	static constexpr const LogicalTypeId UINTEGER = LogicalTypeId::UINTEGER;
-	static constexpr const LogicalTypeId BIGINT = LogicalTypeId::BIGINT;
-	static constexpr const LogicalTypeId UBIGINT = LogicalTypeId::UBIGINT;
-	static constexpr const LogicalTypeId FLOAT = LogicalTypeId::FLOAT;
-	static constexpr const LogicalTypeId DOUBLE = LogicalTypeId::DOUBLE;
-	static constexpr const LogicalTypeId DATE = LogicalTypeId::DATE;
-	static constexpr const LogicalTypeId TIMESTAMP = LogicalTypeId::TIMESTAMP;
-	static constexpr const LogicalTypeId TIMESTAMP_S = LogicalTypeId::TIMESTAMP_SEC;
-	static constexpr const LogicalTypeId TIMESTAMP_MS = LogicalTypeId::TIMESTAMP_MS;
-	static constexpr const LogicalTypeId TIMESTAMP_NS = LogicalTypeId::TIMESTAMP_NS;
-	static constexpr const LogicalTypeId TIME = LogicalTypeId::TIME;
-	static constexpr const LogicalTypeId TIMESTAMP_TZ = LogicalTypeId::TIMESTAMP_TZ;
-	static constexpr const LogicalTypeId TIME_TZ = LogicalTypeId::TIME_TZ;
-	static constexpr const LogicalTypeId VARCHAR = LogicalTypeId::VARCHAR;
-	static constexpr const LogicalTypeId ANY = LogicalTypeId::ANY;
-	static constexpr const LogicalTypeId BLOB = LogicalTypeId::BLOB;
-	static constexpr const LogicalTypeId BIT = LogicalTypeId::BIT;
-	static constexpr const LogicalTypeId VARINT = LogicalTypeId::VARINT;
-
-	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
-	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
-	static constexpr const LogicalTypeId UHUGEINT = LogicalTypeId::UHUGEINT;
-	static constexpr const LogicalTypeId UUID = LogicalTypeId::UUID;
-	static constexpr const LogicalTypeId HASH = LogicalTypeId::UBIGINT;
-	static constexpr const LogicalTypeId POINTER = LogicalTypeId::POINTER;
-	static constexpr const LogicalTypeId TABLE = LogicalTypeId::TABLE;
-	static constexpr const LogicalTypeId LAMBDA = LogicalTypeId::LAMBDA;
-	static constexpr const LogicalTypeId INVALID = LogicalTypeId::INVALID;
-	static constexpr const LogicalTypeId ROW_TYPE = LogicalTypeId::BIGINT;
-
-	// explicitly allowing these functions to be capitalized to be in-line with the remaining functions
-	DUCKDB_API static LogicalType DECIMAL(uint8_t width, uint8_t scale);                 // NOLINT
-	DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation);           // NOLINT
-	DUCKDB_API static LogicalType LIST(const LogicalType &child);                // NOLINT
-	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
-	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type); // NOLINT
-	DUCKDB_API static LogicalType MAP(const LogicalType &child);                 // NOLINT
-	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value);       // NOLINT
-	DUCKDB_API static LogicalType UNION(child_list_t<LogicalType> members);      // NOLINT
-	DUCKDB_API static LogicalType ARRAY(const LogicalType &child, optional_idx index);   // NOLINT
-	DUCKDB_API static LogicalType ENUM(Vector &ordered_data, idx_t size); // NOLINT
-	// ANY but with special rules (default is LogicalType::ANY, 5)
-	DUCKDB_API static LogicalType ANY_PARAMS(LogicalType target, idx_t cast_score = 5); // NOLINT
-	//! Integer literal of the specified value
-	DUCKDB_API static LogicalType INTEGER_LITERAL(const Value &constant);               // NOLINT
-	// DEPRECATED - provided for backwards compatibility
-	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
-	DUCKDB_API static LogicalType USER(const string &user_type_name);                              // NOLINT
-	DUCKDB_API static LogicalType USER(const string &user_type_name, const vector<Value> &user_type_mods); // NOLINT
-	DUCKDB_API static LogicalType USER(string catalog, string schema, string name, vector<Value> user_type_mods); // NOLINT
-	//! A list of all NUMERIC types (integral and floating point types)
-	DUCKDB_API static const vector<LogicalType> Numeric();
-	//! A list of all INTEGRAL types
-	DUCKDB_API static const vector<LogicalType> Integral();
-	//! A list of all REAL types
-	DUCKDB_API static const vector<LogicalType> Real();
-	//! A list of ALL SQL types
-	DUCKDB_API static const vector<LogicalType> AllTypes();
-
-public:
-	//! The JSON type lives in the JSON extension, but we need to define this here for special handling
-	static constexpr auto JSON_TYPE_NAME = "JSON";
-	DUCKDB_API static LogicalType JSON(); // NOLINT
-	DUCKDB_API bool IsJSONType() const;
-};
-
-struct DecimalType {
-	DUCKDB_API static uint8_t GetWidth(const LogicalType &type);
-	DUCKDB_API static uint8_t GetScale(const LogicalType &type);
-	DUCKDB_API static uint8_t MaxWidth();
-};
-
-struct StringType {
-	DUCKDB_API static string GetCollation(const LogicalType &type);
-};
-
-struct ListType {
-	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
-};
-
-struct UserType {
-	DUCKDB_API static const string &GetCatalog(const LogicalType &type);
-	DUCKDB_API static const string &GetSchema(const LogicalType &type);
-	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
-	DUCKDB_API static const vector<Value> &GetTypeModifiers(const LogicalType &type);
-	DUCKDB_API static vector<Value> &GetTypeModifiers(LogicalType &type);
-};
-
-struct EnumType {
-	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t &key);
-	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
-	DUCKDB_API static idx_t GetSize(const LogicalType &type);
-	DUCKDB_API static const string GetValue(const Value &val);
-	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
-	DUCKDB_API static string_t GetString(const LogicalType &type, idx_t pos);
-};
-
-struct StructType {
-	DUCKDB_API static const child_list_t<LogicalType> &GetChildTypes(const LogicalType &type);
-	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type, idx_t index);
-	DUCKDB_API static const string &GetChildName(const LogicalType &type, idx_t index);
-	DUCKDB_API static idx_t GetChildIndexUnsafe(const LogicalType &type, const string &name);
-	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
-	DUCKDB_API static bool IsUnnamed(const LogicalType &type);
-};
-
-struct MapType {
-	DUCKDB_API static const LogicalType &KeyType(const LogicalType &type);
-	DUCKDB_API static const LogicalType &ValueType(const LogicalType &type);
-};
-
-struct UnionType {
-	DUCKDB_API static const idx_t MAX_UNION_MEMBERS = 256;
-	DUCKDB_API static idx_t GetMemberCount(const LogicalType &type);
-	DUCKDB_API static const LogicalType &GetMemberType(const LogicalType &type, idx_t index);
-	DUCKDB_API static const string &GetMemberName(const LogicalType &type, idx_t index);
-	DUCKDB_API static const child_list_t<LogicalType> CopyMemberTypes(const LogicalType &type);
-};
-
-struct ArrayType {
-	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
-	DUCKDB_API static idx_t GetSize(const LogicalType &type);
-	DUCKDB_API static bool IsAnySize(const LogicalType &type);
-	DUCKDB_API static constexpr idx_t MAX_ARRAY_SIZE = 100000; // 100k for now
-	//! Recursively replace all ARRAY types to LIST types within the given type
-	DUCKDB_API static LogicalType ConvertToList(const LogicalType &type);
-};
-
-struct AggregateStateType {
-	DUCKDB_API static const string GetTypeName(const LogicalType &type);
-	DUCKDB_API static const aggregate_state_t &GetStateType(const LogicalType &type);
-};
-
-struct AnyType {
-	DUCKDB_API static LogicalType GetTargetType(const LogicalType &type);
-	DUCKDB_API static idx_t GetCastScore(const LogicalType &type);
-};
-
-struct IntegerLiteral {
-	//! Returns the type that this integer literal "prefers"
-	DUCKDB_API static LogicalType GetType(const LogicalType &type);
-	//! Whether or not the integer literal fits into the target numeric type
-	DUCKDB_API static bool FitsInType(const LogicalType &type, const LogicalType &target);
-};
-
-// **DEPRECATED**: Use EnumUtil directly instead.
-DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
-
-DUCKDB_API LogicalTypeId TransformStringToLogicalTypeId(const string &str);
-
-DUCKDB_API LogicalType TransformStringToLogicalType(const string &str);
-
-DUCKDB_API LogicalType TransformStringToLogicalType(const string &str, ClientContext &context);
-
-//! The PhysicalType used by the row identifiers column
-extern const PhysicalType ROW_TYPE;
-
-DUCKDB_API string TypeIdToString(PhysicalType type);
-DUCKDB_API idx_t GetTypeIdSize(PhysicalType type);
-DUCKDB_API bool TypeIsConstantSize(PhysicalType type);
-DUCKDB_API bool TypeIsIntegral(PhysicalType type);
-DUCKDB_API bool TypeIsNumeric(PhysicalType type);
-DUCKDB_API bool TypeIsInteger(PhysicalType type);
-
-bool ApproxEqual(float l, float r);
-bool ApproxEqual(double l, double r);
-
-struct aggregate_state_t {
-	aggregate_state_t() {
-	}
-	// NOLINTNEXTLINE: work around bug in clang-tidy
-	aggregate_state_t(string function_name_p, LogicalType return_type_p, vector<LogicalType> bound_argument_types_p)
-	    : function_name(std::move(function_name_p)), return_type(std::move(return_type_p)),
-	      bound_argument_types(std::move(bound_argument_types_p)) {
-	}
-
-	string function_name;
-	LogicalType return_type;
-	vector<LogicalType> bound_argument_types;
-};
-
-
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/arrow_aux_data.hpp b/src/duckdb/src/include/duckdb/common/types/arrow_aux_data.hpp
deleted file mode 100644
index cf6c176fe..000000000
--- a/src/duckdb/src/include/duckdb/common/types/arrow_aux_data.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/arrow_aux_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-
-namespace duckdb {
-
-struct ArrowAuxiliaryData : public VectorAuxiliaryData {
-	static constexpr const VectorAuxiliaryDataType TYPE = VectorAuxiliaryDataType::ARROW_AUXILIARY;
-	explicit ArrowAuxiliaryData(shared_ptr<ArrowArrayWrapper> arrow_array_p)
-	    : VectorAuxiliaryData(VectorAuxiliaryDataType::ARROW_AUXILIARY), arrow_array(std::move(arrow_array_p)) {
-	}
-	~ArrowAuxiliaryData() override {
-	}
-
-	shared_ptr<ArrowArrayWrapper> arrow_array;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/arrow_string_view_type.hpp b/src/duckdb/src/include/duckdb/common/types/arrow_string_view_type.hpp
deleted file mode 100644
index cf943612d..000000000
--- a/src/duckdb/src/include/duckdb/common/types/arrow_string_view_type.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/arrow_string_view_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-struct ArrowStringViewConstants {
-public:
-	static constexpr uint8_t MAX_INLINED_BYTES = 12 * sizeof(char);
-	static constexpr uint8_t PREFIX_BYTES = 4 * sizeof(char);
-
-public:
-	ArrowStringViewConstants() = delete;
-};
-
-union arrow_string_view_t {
-	arrow_string_view_t() {
-	}
-
-	//! Constructor for inlined arrow string views
-	arrow_string_view_t(int32_t length, const char *data) {
-		D_ASSERT(length <= ArrowStringViewConstants::MAX_INLINED_BYTES);
-		inlined.length = length;
-		memcpy(inlined.data, data, UnsafeNumericCast<idx_t>(length));
-		if (length < ArrowStringViewConstants::MAX_INLINED_BYTES) {
-			// have to 0 pad
-			uint8_t remaining_bytes = ArrowStringViewConstants::MAX_INLINED_BYTES - NumericCast<uint8_t>(length);
-
-			memset(&inlined.data[length], '\0', remaining_bytes);
-		}
-	}
-
-	//! Constructor for non-inlined arrow string views
-	arrow_string_view_t(int32_t length, const char *data, int32_t buffer_idx, int32_t offset) {
-		D_ASSERT(length > ArrowStringViewConstants::MAX_INLINED_BYTES);
-		ref.length = length;
-		memcpy(ref.prefix, data, ArrowStringViewConstants::PREFIX_BYTES);
-		ref.buffer_index = buffer_idx;
-		ref.offset = offset;
-	}
-
-	//! Representation of inlined arrow string views
-	struct {
-		int32_t length;
-		char data[ArrowStringViewConstants::MAX_INLINED_BYTES];
-	} inlined;
-
-	//! Representation of non-inlined arrow string views
-	struct {
-		int32_t length;
-		char prefix[ArrowStringViewConstants::PREFIX_BYTES];
-		int32_t buffer_index;
-		int32_t offset;
-	} ref;
-
-	int32_t Length() const {
-		return inlined.length;
-	}
-	bool IsInline() const {
-		return Length() <= ArrowStringViewConstants::MAX_INLINED_BYTES;
-	}
-
-	const char *GetInlineData() const {
-		return IsInline() ? inlined.data : ref.prefix;
-	}
-	int32_t GetBufferIndex() {
-		D_ASSERT(!IsInline());
-		return ref.buffer_index;
-	}
-	int32_t GetOffset() {
-		D_ASSERT(!IsInline());
-		return ref.offset;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/batched_data_collection.hpp b/src/duckdb/src/include/duckdb/common/types/batched_data_collection.hpp
deleted file mode 100644
index 8a5cc9e19..000000000
--- a/src/duckdb/src/include/duckdb/common/types/batched_data_collection.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/batched_chunk_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-class BufferManager;
-class ClientContext;
-
-using batch_map_t = map<idx_t, unique_ptr<ColumnDataCollection>>;
-using batch_iterator_t = typename batch_map_t::iterator;
-
-struct BatchedChunkIteratorRange {
-	batch_iterator_t begin;
-	batch_iterator_t end;
-};
-
-struct BatchedChunkScanState {
-	BatchedChunkIteratorRange range;
-	ColumnDataScanState scan_state;
-};
-
-//!  A BatchedDataCollection holds a number of data entries that are partitioned by batch index
-//! Scans over a BatchedDataCollection are ordered by batch index
-class BatchedDataCollection {
-public:
-	DUCKDB_API BatchedDataCollection(ClientContext &context, vector<LogicalType> types, bool buffer_managed = false);
-	DUCKDB_API BatchedDataCollection(ClientContext &context, vector<LogicalType> types, batch_map_t batches,
-	                                 bool buffer_managed = false);
-
-	//! Appends a datachunk with the given batch index to the batched collection
-	DUCKDB_API void Append(DataChunk &input, idx_t batch_index);
-
-	//! Merge the other batched chunk collection into this batched collection
-	DUCKDB_API void Merge(BatchedDataCollection &other);
-
-	// Initialize a scan over a range of batches of the batched chunk collection
-	void InitializeScan(BatchedChunkScanState &state, const BatchedChunkIteratorRange &range);
-
-	//! Initialize a scan over the batched chunk collection
-	DUCKDB_API void InitializeScan(BatchedChunkScanState &state);
-
-	//! Scan a chunk from the batched chunk collection, in-order of batch index
-	DUCKDB_API void Scan(BatchedChunkScanState &state, DataChunk &output);
-
-	//! Fetch a column data collection from the batched data collection - this consumes all of the data stored within
-	DUCKDB_API unique_ptr<ColumnDataCollection> FetchCollection();
-
-	//! Inspect how many tuples this batched data collection contains
-	DUCKDB_API idx_t Count() const;
-
-	//! Inspect the types of the collection
-	DUCKDB_API const vector<LogicalType> &Types() const;
-
-	//! Inspect how many batches this collection contains
-	DUCKDB_API idx_t BatchCount() const;
-
-	//! Retrieve the batch index of the nth batch in the collection
-	DUCKDB_API idx_t IndexToBatchIndex(idx_t index) const;
-
-	//! Inspect how big a given batch is
-	DUCKDB_API idx_t BatchSize(idx_t batch_index) const;
-
-	//! Inspect a given batch through a const reference
-	const ColumnDataCollection &Batch(idx_t batch_index) const;
-
-	//! Create an iterator range from the provided indices
-	BatchedChunkIteratorRange BatchRange(idx_t begin = 0, idx_t end = DConstants::INVALID_INDEX);
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print() const;
-
-private:
-	struct CachedCollection {
-		idx_t batch_index = DConstants::INVALID_INDEX;
-		ColumnDataCollection *collection = nullptr;
-		ColumnDataAppendState append_state;
-	};
-
-	ClientContext &context;
-	vector<LogicalType> types;
-	bool buffer_managed;
-	//! The data of the batched chunk collection - a set of batch_index -> ColumnDataCollection pointers
-	map<idx_t, unique_ptr<ColumnDataCollection>> data;
-	//! The last batch collection that was inserted into
-	CachedCollection last_collection;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/bit.hpp b/src/duckdb/src/include/duckdb/common/types/bit.hpp
deleted file mode 100644
index cbf599139..000000000
--- a/src/duckdb/src/include/duckdb/common/types/bit.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/bit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-
-using bitstring_t = duckdb::string_t;
-
-//! The Bit class is a static class that holds helper functions for the BIT type.
-class Bit {
-public:
-	//! Returns the number of bits in the bit string
-	DUCKDB_API static idx_t BitLength(bitstring_t bits);
-	//! Returns the number of set bits in the bit string
-	DUCKDB_API static idx_t BitCount(bitstring_t bits);
-	//! Returns the number of bytes in the bit string
-	DUCKDB_API static idx_t OctetLength(bitstring_t bits);
-	//! Extracts the nth bit from bit string; the first (leftmost) bit is indexed 0
-	DUCKDB_API static idx_t GetBit(bitstring_t bit_string, idx_t n);
-	//! Sets the nth bit in bit string to newvalue; the first (leftmost) bit is indexed 0
-	DUCKDB_API static void SetBit(bitstring_t &bit_string, idx_t n, idx_t new_value);
-	//! Returns first starting index of the specified substring within bits, or zero if it's not present.
-	DUCKDB_API static idx_t BitPosition(bitstring_t substring, bitstring_t bits);
-	//! Converts bits to a string, writing the output to the designated output string.
-	//! The string needs to have space for at least GetStringSize(bits) bytes.
-	DUCKDB_API static void ToString(bitstring_t bits, char *output);
-	DUCKDB_API static string ToString(bitstring_t bits);
-	//! Returns the bit size of a string -> bit conversion
-	DUCKDB_API static bool TryGetBitStringSize(string_t str, idx_t &result_size, string *error_message);
-	//! Convert a string to a bit. This function should ONLY be called after calling GetBitSize, since it does NOT
-	//! perform data validation.
-	DUCKDB_API static void ToBit(string_t str, bitstring_t &output);
-
-	DUCKDB_API static string ToBit(string_t str);
-
-	//! output needs to have enough space allocated before calling this function (blob size + 1)
-	DUCKDB_API static void BlobToBit(string_t blob, bitstring_t &output);
-
-	DUCKDB_API static string BlobToBit(string_t blob);
-
-	//! output_str needs to have enough space allocated before calling this function (sizeof(T) + 1)
-	template <class T>
-	static void NumericToBit(T numeric, bitstring_t &output_str);
-
-	template <class T>
-	static string NumericToBit(T numeric);
-
-	//! bit is expected to fit inside of output num (bit size <= sizeof(T) + 1)
-	template <class T>
-	static void BitToNumeric(bitstring_t bit, T &output_num);
-
-	template <class T>
-	static T BitToNumeric(bitstring_t bit);
-
-	//! bit is expected to fit inside of output_blob (bit size = output_blob + 1)
-	static void BitToBlob(bitstring_t bit, string_t &output_blob);
-
-	static string BitToBlob(bitstring_t bit);
-
-	//! Creates a new bitstring of determined length
-	DUCKDB_API static void BitString(const string_t &input, idx_t len, bitstring_t &result);
-	DUCKDB_API static void ExtendBitString(const bitstring_t &input, idx_t bit_length, bitstring_t &result);
-	DUCKDB_API static void SetEmptyBitString(bitstring_t &target, string_t &input);
-	DUCKDB_API static void SetEmptyBitString(bitstring_t &target, idx_t len);
-	DUCKDB_API static idx_t ComputeBitstringLen(idx_t len);
-
-	DUCKDB_API static void RightShift(const bitstring_t &bit_string, idx_t shift, bitstring_t &result);
-	DUCKDB_API static void LeftShift(const bitstring_t &bit_string, idx_t shift, bitstring_t &result);
-	DUCKDB_API static void BitwiseAnd(const bitstring_t &rhs, const bitstring_t &lhs, bitstring_t &result);
-	DUCKDB_API static void BitwiseOr(const bitstring_t &rhs, const bitstring_t &lhs, bitstring_t &result);
-	DUCKDB_API static void BitwiseXor(const bitstring_t &rhs, const bitstring_t &lhs, bitstring_t &result);
-	DUCKDB_API static void BitwiseNot(const bitstring_t &rhs, bitstring_t &result);
-
-	DUCKDB_API static void Verify(const bitstring_t &input);
-
-private:
-	static void Finalize(bitstring_t &str);
-	static idx_t GetBitInternal(bitstring_t bit_string, idx_t n);
-	static void SetBitInternal(bitstring_t &bit_string, idx_t n, idx_t new_value);
-	static idx_t GetBitIndex(idx_t n);
-	static uint8_t GetFirstByte(const bitstring_t &str);
-};
-
-//===--------------------------------------------------------------------===//
-// Bit Template definitions
-//===--------------------------------------------------------------------===//
-template <class T>
-void Bit::NumericToBit(T numeric, bitstring_t &output_str) {
-	D_ASSERT(output_str.GetSize() >= sizeof(T) + 1);
-
-	auto output = output_str.GetDataWriteable();
-	auto data = const_data_ptr_cast(&numeric);
-
-	*output = 0; // set padding to 0
-	++output;
-	for (idx_t idx = 0; idx < sizeof(T); ++idx) {
-		output[idx] = static_cast<char>(data[sizeof(T) - idx - 1]);
-	}
-	Bit::Finalize(output_str);
-}
-
-template <class T>
-string Bit::NumericToBit(T numeric) {
-	auto bit_len = sizeof(T) + 1;
-	auto buffer = make_unsafe_uniq_array_uninitialized<char>(bit_len);
-	bitstring_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit_len));
-	Bit::NumericToBit(numeric, output_str);
-	return output_str.GetString();
-}
-
-template <class T>
-T Bit::BitToNumeric(bitstring_t bit) {
-	T output;
-	Bit::BitToNumeric(bit, output);
-	return (output);
-}
-
-template <class T>
-void Bit::BitToNumeric(bitstring_t bit, T &output_num) {
-	D_ASSERT(bit.GetSize() <= sizeof(T) + 1);
-
-	output_num = 0;
-	auto data = const_data_ptr_cast(bit.GetData());
-	auto output = data_ptr_cast(&output_num);
-
-	idx_t padded_byte_idx = sizeof(T) - bit.GetSize() + 1;
-	output[sizeof(T) - 1 - padded_byte_idx] = GetFirstByte(bit);
-	for (idx_t idx = padded_byte_idx + 1; idx < sizeof(T); ++idx) {
-		output[sizeof(T) - 1 - idx] = data[1 + idx - padded_byte_idx];
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/blob.hpp b/src/duckdb/src/include/duckdb/common/types/blob.hpp
deleted file mode 100644
index 816224bef..000000000
--- a/src/duckdb/src/include/duckdb/common/types/blob.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/blob.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-struct CastParameters;
-
-//! The Blob class is a static class that holds helper functions for the Blob type.
-class Blob {
-public:
-	// map of integer -> hex value
-	static constexpr const char *HEX_TABLE = "0123456789ABCDEF";
-	// reverse map of byte -> integer value, or -1 for invalid hex values
-	static const int HEX_MAP[256];
-	//! map of index -> base64 character
-	static constexpr const char *BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-	//! padding character used in base64 encoding
-	static constexpr const char BASE64_PADDING = '=';
-
-public:
-	//! Returns the string size of a blob -> string conversion
-	DUCKDB_API static idx_t GetStringSize(string_t blob);
-	//! Converts a blob to a string, writing the output to the designated output string.
-	//! The string needs to have space for at least GetStringSize(blob) bytes.
-	DUCKDB_API static void ToString(string_t blob, char *output);
-	//! Convert a blob object to a string
-	DUCKDB_API static string ToString(string_t blob);
-
-	//! Returns the blob size of a string -> blob conversion
-	DUCKDB_API static bool TryGetBlobSize(string_t str, idx_t &result_size, CastParameters &parameters);
-	DUCKDB_API static idx_t GetBlobSize(string_t str);
-	DUCKDB_API static idx_t GetBlobSize(string_t str, CastParameters &parameters);
-	//! Convert a string to a blob. This function should ONLY be called after calling GetBlobSize, since it does NOT
-	//! perform data validation.
-	DUCKDB_API static void ToBlob(string_t str, data_ptr_t output);
-	//! Convert a string object to a blob
-	DUCKDB_API static string ToBlob(string_t str);
-	DUCKDB_API static string ToBlob(string_t str, CastParameters &parameters);
-
-	// base 64 conversion functions
-	//! Returns the string size of a blob -> base64 conversion
-	DUCKDB_API static idx_t ToBase64Size(string_t blob);
-	//! Converts a blob to a base64 string, output should have space for at least ToBase64Size(blob) bytes
-	DUCKDB_API static void ToBase64(string_t blob, char *output);
-
-	//! Returns the string size of a base64 string -> blob conversion
-	DUCKDB_API static idx_t FromBase64Size(string_t str);
-	//! Converts a base64 string to a blob, output should have space for at least FromBase64Size(blob) bytes
-	DUCKDB_API static void FromBase64(string_t str, data_ptr_t output, idx_t output_size);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/cast_helpers.hpp b/src/duckdb/src/include/duckdb/common/types/cast_helpers.hpp
deleted file mode 100644
index f0087ba30..000000000
--- a/src/duckdb/src/include/duckdb/common/types/cast_helpers.hpp
+++ /dev/null
@@ -1,410 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/cast_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "fmt/format.h"
-
-namespace duckdb {
-
-//! NumericHelper is a static class that holds helper functions for integers/doubles
-class NumericHelper {
-public:
-	static constexpr uint8_t CACHED_POWERS_OF_TEN = 20;
-	static const int64_t POWERS_OF_TEN[CACHED_POWERS_OF_TEN];
-	static const double DOUBLE_POWERS_OF_TEN[40];
-
-public:
-	template <class T>
-	static int UnsignedLength(T value);
-
-	template <class SIGNED, class UNSIGNED>
-	static int SignedLength(SIGNED value) {
-		int sign = -(value < 0);
-		UNSIGNED unsigned_value = UnsafeNumericCast<UNSIGNED>((value ^ sign) - sign);
-		return UnsignedLength(unsigned_value) - sign;
-	}
-
-	// Formats value in reverse and returns a pointer to the beginning.
-	template <class T>
-	static char *FormatUnsigned(T value, char *ptr) {
-		while (value >= 100) {
-			// Integer division is slow so do it for a group of two digits instead
-			// of for every digit. The idea comes from the talk by Alexandrescu
-			// "Three Optimization Tips for C++".
-			auto index = NumericCast<unsigned>((value % 100) * 2);
-			value /= 100;
-			*--ptr = duckdb_fmt::internal::data::digits[index + 1];
-			*--ptr = duckdb_fmt::internal::data::digits[index];
-		}
-		if (value < 10) {
-			*--ptr = NumericCast<char>('0' + value);
-			return ptr;
-		}
-		auto index = NumericCast<unsigned>(value * 2);
-		*--ptr = duckdb_fmt::internal::data::digits[index + 1];
-		*--ptr = duckdb_fmt::internal::data::digits[index];
-		return ptr;
-	}
-
-	template <class T>
-	static string_t FormatSigned(T value, Vector &vector) {
-		typedef typename MakeUnsigned<T>::type unsigned_t;
-		int8_t sign = -(value < 0);
-		unsigned_t unsigned_value = unsigned_t(value ^ T(sign)) + unsigned_t(AbsValue(sign));
-		auto length = UnsafeNumericCast<idx_t>(UnsignedLength<unsigned_t>(unsigned_value) + AbsValue(sign));
-		string_t result = StringVector::EmptyString(vector, length);
-		auto dataptr = result.GetDataWriteable();
-		auto endptr = dataptr + length;
-		endptr = FormatUnsigned(unsigned_value, endptr);
-		if (sign) {
-			*--endptr = '-';
-		}
-		result.Finalize();
-		return result;
-	}
-
-	template <class T>
-	static std::string ToString(T value) {
-		return std::to_string(value);
-	}
-};
-
-template <>
-int NumericHelper::UnsignedLength(uint8_t value);
-template <>
-int NumericHelper::UnsignedLength(uint16_t value);
-template <>
-int NumericHelper::UnsignedLength(uint32_t value);
-template <>
-int NumericHelper::UnsignedLength(uint64_t value);
-template <>
-int NumericHelper::UnsignedLength(hugeint_t value);
-
-template <>
-char *NumericHelper::FormatUnsigned(hugeint_t value, char *ptr);
-
-template <>
-std::string NumericHelper::ToString(hugeint_t value);
-
-template <>
-std::string NumericHelper::ToString(uhugeint_t value);
-
-template <>
-string_t NumericHelper::FormatSigned(hugeint_t value, Vector &vector);
-
-struct DecimalToString {
-	template <class SIGNED>
-	static int DecimalLength(SIGNED value, uint8_t width, uint8_t scale) {
-		using UNSIGNED = typename MakeUnsigned<SIGNED>::type;
-		if (scale == 0) {
-			// scale is 0: regular number
-			return NumericHelper::SignedLength<SIGNED, UNSIGNED>(value);
-		}
-		// length is max of either:
-		// scale + 2 OR
-		// integer length + 1
-		// scale + 2 happens when the number is in the range of (-1, 1)
-		// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
-		// integer length + 1 happens when the number is outside of that range
-		// in that case we print the integer number, but with one extra character ('.')
-		auto extra_characters = width > scale ? 2 : 1;
-		return MaxValue(scale + extra_characters + (value < 0 ? 1 : 0),
-		                NumericHelper::SignedLength<SIGNED, UNSIGNED>(value) + 1);
-	}
-
-	template <class SIGNED>
-	static void FormatDecimal(SIGNED value, uint8_t width, uint8_t scale, char *dst, idx_t len) {
-		using UNSIGNED = typename MakeUnsigned<SIGNED>::type;
-		char *end = dst + len;
-		if (value < 0) {
-			value = -value;
-			*dst = '-';
-		}
-		if (scale == 0) {
-			NumericHelper::FormatUnsigned<UNSIGNED>(UnsafeNumericCast<UNSIGNED>(value), end);
-			return;
-		}
-		// we write two numbers:
-		// the numbers BEFORE the decimal (major)
-		// and the numbers AFTER the decimal (minor)
-		auto minor =
-		    UnsafeNumericCast<UNSIGNED>(value) % UnsafeNumericCast<UNSIGNED>(NumericHelper::POWERS_OF_TEN[scale]);
-		auto major =
-		    UnsafeNumericCast<UNSIGNED>(value) / UnsafeNumericCast<UNSIGNED>(NumericHelper::POWERS_OF_TEN[scale]);
-		// write the number after the decimal
-		dst = NumericHelper::FormatUnsigned<UNSIGNED>(UnsafeNumericCast<UNSIGNED>(minor), end);
-		// (optionally) pad with zeros and add the decimal point
-		while (dst > (end - scale)) {
-			*--dst = '0';
-		}
-		*--dst = '.';
-		// now write the part before the decimal
-		D_ASSERT(width > scale || major == 0);
-		if (width > scale) {
-			// there are numbers after the comma
-			dst = NumericHelper::FormatUnsigned<UNSIGNED>(UnsafeNumericCast<UNSIGNED>(major), dst);
-		}
-	}
-
-	template <class SIGNED>
-	static string_t Format(SIGNED value, uint8_t width, uint8_t scale, Vector &vector) {
-		int len = DecimalLength<SIGNED>(value, width, scale);
-		string_t result = StringVector::EmptyString(vector, NumericCast<size_t>(len));
-		FormatDecimal<SIGNED>(value, width, scale, result.GetDataWriteable(), UnsafeNumericCast<idx_t>(len));
-		result.Finalize();
-		return result;
-	}
-};
-
-template <>
-int DecimalToString::DecimalLength(hugeint_t value, uint8_t width, uint8_t scale);
-
-template <>
-string_t DecimalToString::Format(hugeint_t value, uint8_t width, uint8_t scale, Vector &vector);
-
-template <>
-void DecimalToString::FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, char *dst, idx_t len);
-
-struct UhugeintToStringCast {
-	static string_t Format(uhugeint_t value, Vector &vector) {
-		std::string str = value.ToString();
-		string_t result = StringVector::EmptyString(vector, str.length());
-		auto data = result.GetDataWriteable();
-
-		memcpy(data, str.data(), str.length()); // NOLINT: null-termination not required
-		result.Finalize();
-		return result;
-	}
-};
-
-struct DateToStringCast {
-	static idx_t Length(int32_t date[], idx_t &year_length, bool &add_bc) {
-		// format is YYYY-MM-DD with optional (BC) at the end
-		// regular length is 10
-		idx_t length = 6;
-		year_length = 4;
-		add_bc = false;
-		if (date[0] <= 0) {
-			// add (BC) suffix
-			length += 5;
-			date[0] = -date[0] + 1;
-			add_bc = true;
-		}
-
-		// potentially add extra characters depending on length of year
-		year_length += date[0] >= 10000;
-		year_length += date[0] >= 100000;
-		year_length += date[0] >= 1000000;
-		year_length += date[0] >= 10000000;
-		length += year_length;
-		return length;
-	}
-
-	static void Format(char *data, int32_t date[], idx_t year_length, bool add_bc) {
-		// now we write the string, first write the year
-		auto endptr = data + year_length;
-		endptr = NumericHelper::FormatUnsigned(date[0], endptr);
-		// add optional leading zeros
-		while (endptr > data) {
-			*--endptr = '0';
-		}
-		// now write the month and day
-		auto ptr = data + year_length;
-		for (int i = 1; i <= 2; i++) {
-			ptr[0] = '-';
-			if (date[i] < 10) {
-				ptr[1] = '0';
-				ptr[2] = UnsafeNumericCast<char>('0' + date[i]);
-			} else {
-				auto index = UnsafeNumericCast<idx_t>(date[i] * 2);
-				ptr[1] = duckdb_fmt::internal::data::digits[index];
-				ptr[2] = duckdb_fmt::internal::data::digits[index + 1];
-			}
-			ptr += 3;
-		}
-		// optionally add BC to the end of the date
-		if (add_bc) {
-			memcpy(ptr, " (BC)", 5); // NOLINT
-		}
-	}
-};
-
-struct TimeToStringCast {
-	//! Format microseconds to a buffer of length 6. Returns the number of trailing zeros
-	static int32_t FormatMicros(int32_t microseconds, char micro_buffer[]) {
-		char *endptr = micro_buffer + 6;
-		endptr = NumericHelper::FormatUnsigned<int32_t>(microseconds, endptr);
-		while (endptr > micro_buffer) {
-			*--endptr = '0';
-		}
-		idx_t trailing_zeros = 0;
-		for (idx_t i = 5; i > 0; i--) {
-			if (micro_buffer[i] != '0') {
-				break;
-			}
-			trailing_zeros++;
-		}
-		return UnsafeNumericCast<int32_t>(trailing_zeros);
-	}
-
-	static idx_t Length(int32_t time[], char micro_buffer[]) {
-		// format is HH:MM:DD.MS
-		// microseconds come after the time with a period separator
-		idx_t length;
-		if (time[3] == 0) {
-			// no microseconds
-			// format is HH:MM:DD
-			length = 8;
-		} else {
-			length = 15;
-			// for microseconds, we truncate any trailing zeros (i.e. "90000" becomes ".9")
-			// first write the microseconds to the microsecond buffer
-			// we write backwards and pad with zeros to the left
-			// now we figure out how many digits we need to include by looking backwards
-			// and checking how many zeros we encounter
-			length -= NumericCast<idx_t>(FormatMicros(time[3], micro_buffer));
-		}
-		return length;
-	}
-
-	static void FormatTwoDigits(char *ptr, int32_t value) {
-		D_ASSERT(value >= 0 && value <= 99);
-		if (value < 10) {
-			ptr[0] = '0';
-			ptr[1] = UnsafeNumericCast<char>('0' + value);
-		} else {
-			auto index = UnsafeNumericCast<unsigned>(value * 2);
-			ptr[0] = duckdb_fmt::internal::data::digits[index];
-			ptr[1] = duckdb_fmt::internal::data::digits[index + 1];
-		}
-	}
-
-	static void Format(char *data, idx_t length, int32_t time[], char micro_buffer[]) {
-		// first write hour, month and day
-		auto ptr = data;
-		ptr[2] = ':';
-		ptr[5] = ':';
-		for (int i = 0; i <= 2; i++) {
-			FormatTwoDigits(ptr, time[i]);
-			ptr += 3;
-		}
-		if (length > 8) {
-			// write the micro seconds at the end
-			data[8] = '.';
-			memcpy(data + 9, micro_buffer, length - 9);
-		}
-	}
-};
-
-struct IntervalToStringCast {
-	static void FormatSignedNumber(int64_t value, char buffer[], idx_t &length) {
-		int sign = -(value < 0);
-		auto unsigned_value = NumericCast<uint64_t>((value ^ sign) - sign);
-		length += NumericCast<idx_t>(NumericHelper::UnsignedLength<uint64_t>(unsigned_value) - sign);
-		auto endptr = buffer + length;
-		endptr = NumericHelper::FormatUnsigned<uint64_t>(unsigned_value, endptr);
-		if (sign) {
-			*--endptr = '-';
-		}
-	}
-
-	static void FormatTwoDigits(int64_t value, char buffer[], idx_t &length) {
-		TimeToStringCast::FormatTwoDigits(buffer + length, UnsafeNumericCast<int32_t>(value));
-		length += 2;
-	}
-
-	static void FormatIntervalValue(int32_t value, char buffer[], idx_t &length, const char *name, idx_t name_len) {
-		if (value == 0) {
-			return;
-		}
-		if (length != 0) {
-			// space if there is already something in the buffer
-			buffer[length++] = ' ';
-		}
-		FormatSignedNumber(value, buffer, length);
-		// append the name together with a potential "s" (for plurals)
-		memcpy(buffer + length, name, name_len);
-		length += name_len;
-		if (value != 1 && value != -1) {
-			buffer[length++] = 's';
-		}
-	}
-
-	//! Formats an interval to a buffer, the buffer should be >=70 characters
-	//! years: 17 characters (max value: "-2147483647 years")
-	//! months: 9 (max value: "12 months")
-	//! days: 16 characters (max value: "-2147483647 days")
-	//! time: 24 characters (max value: -2562047788:00:00.123456)
-	//! spaces between all characters (+3 characters)
-	//! Total: 70 characters
-	//! Returns the length of the interval
-	static idx_t Format(interval_t interval, char buffer[]) {
-		idx_t length = 0;
-		if (interval.months != 0) {
-			int32_t years = interval.months / 12;
-			int32_t months = interval.months - years * 12;
-			// format the years and months
-			FormatIntervalValue(years, buffer, length, " year", 5);
-			FormatIntervalValue(months, buffer, length, " month", 6);
-		}
-		if (interval.days != 0) {
-			// format the days
-			FormatIntervalValue(interval.days, buffer, length, " day", 4);
-		}
-		if (interval.micros != 0) {
-			if (length != 0) {
-				// space if there is already something in the buffer
-				buffer[length++] = ' ';
-			}
-			int64_t micros = interval.micros;
-			if (micros < 0) {
-				// negative time: append negative sign
-				buffer[length++] = '-';
-			} else {
-				micros = -micros;
-			}
-			int64_t hour = -(micros / Interval::MICROS_PER_HOUR);
-			micros += hour * Interval::MICROS_PER_HOUR;
-			int64_t min = -(micros / Interval::MICROS_PER_MINUTE);
-			micros += min * Interval::MICROS_PER_MINUTE;
-			int64_t sec = -(micros / Interval::MICROS_PER_SEC);
-			micros += sec * Interval::MICROS_PER_SEC;
-			micros = -micros;
-
-			if (hour < 10) {
-				buffer[length++] = '0';
-			}
-			FormatSignedNumber(hour, buffer, length);
-			buffer[length++] = ':';
-			FormatTwoDigits(min, buffer, length);
-			buffer[length++] = ':';
-			FormatTwoDigits(sec, buffer, length);
-			if (micros != 0) {
-				buffer[length++] = '.';
-				auto trailing_zeros = TimeToStringCast::FormatMicros(NumericCast<int32_t>(micros), buffer + length);
-				length += NumericCast<idx_t>(6 - trailing_zeros);
-			}
-		} else if (length == 0) {
-			// empty interval: default to 00:00:00
-			memcpy(buffer, "00:00:00", 8); // NOLINT
-			return 8;
-		}
-		return length;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/column_data_allocator.hpp b/src/duckdb/src/include/duckdb/common/types/column/column_data_allocator.hpp
deleted file mode 100644
index 38a295320..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/column_data_allocator.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/column_data_allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-
-struct ChunkMetaData;
-struct VectorMetaData;
-
-struct BlockMetaData {
-	//! The underlying block handle
-	shared_ptr<BlockHandle> handle;
-	//! How much space is currently used within the block
-	uint32_t size;
-	//! How much space is available in the block
-	uint32_t capacity;
-
-	uint32_t Capacity();
-};
-
-class ColumnDataAllocator {
-public:
-	explicit ColumnDataAllocator(Allocator &allocator);
-	explicit ColumnDataAllocator(BufferManager &buffer_manager);
-	ColumnDataAllocator(ClientContext &context, ColumnDataAllocatorType allocator_type);
-	ColumnDataAllocator(ColumnDataAllocator &allocator);
-	~ColumnDataAllocator();
-
-	//! Returns an allocator object to allocate with. This returns the allocator in IN_MEMORY_ALLOCATOR, and a buffer
-	//! allocator in case of BUFFER_MANAGER_ALLOCATOR.
-	Allocator &GetAllocator();
-	//! Returns the buffer manager, if this is not an in-memory allocation.
-	BufferManager &GetBufferManager();
-	//! Returns the allocator type
-	ColumnDataAllocatorType GetType() {
-		return type;
-	}
-	void MakeShared() {
-		shared = true;
-	}
-	bool IsShared() const {
-		return shared;
-	}
-	idx_t BlockCount() const {
-		return blocks.size();
-	}
-	idx_t SizeInBytes() const {
-		idx_t total_size = 0;
-		for (const auto &block : blocks) {
-			total_size += block.size;
-		}
-		return total_size;
-	}
-	idx_t AllocationSize() const {
-		return allocated_size;
-	}
-	//! Sets the partition index of this tuple data collection
-	void SetPartitionIndex(idx_t index) {
-		D_ASSERT(!partition_index.IsValid());
-		D_ASSERT(blocks.empty() && allocated_data.empty());
-		partition_index = index;
-	}
-
-public:
-	void AllocateData(idx_t size, uint32_t &block_id, uint32_t &offset, ChunkManagementState *chunk_state);
-
-	void Initialize(ColumnDataAllocator &other);
-	void InitializeChunkState(ChunkManagementState &state, ChunkMetaData &meta_data);
-	data_ptr_t GetDataPointer(ChunkManagementState &state, uint32_t block_id, uint32_t offset);
-	void UnswizzlePointers(ChunkManagementState &state, Vector &result, idx_t v_offset, uint16_t count,
-	                       uint32_t block_id, uint32_t offset);
-
-	//! Prevents the block with the given id from being added to the eviction queue
-	void SetDestroyBufferUponUnpin(uint32_t block_id);
-
-private:
-	void AllocateEmptyBlock(idx_t size);
-	BufferHandle AllocateBlock(idx_t size);
-	BufferHandle Pin(uint32_t block_id);
-
-	bool HasBlocks() const {
-		return !blocks.empty();
-	}
-
-private:
-	void AllocateBuffer(idx_t size, uint32_t &block_id, uint32_t &offset, ChunkManagementState *chunk_state);
-	void AllocateMemory(idx_t size, uint32_t &block_id, uint32_t &offset, ChunkManagementState *chunk_state);
-	void AssignPointer(uint32_t &block_id, uint32_t &offset, data_ptr_t pointer);
-
-private:
-	ColumnDataAllocatorType type;
-	union {
-		//! The allocator object (if this is a IN_MEMORY_ALLOCATOR)
-		Allocator *allocator;
-		//! The buffer manager (if this is a BUFFER_MANAGER_ALLOCATOR)
-		BufferManager *buffer_manager;
-	} alloc;
-	//! The set of blocks used by the column data collection
-	vector<BlockMetaData> blocks;
-	//! The set of allocated data
-	vector<AllocatedData> allocated_data;
-	//! Whether this ColumnDataAllocator is shared across ColumnDataCollections that allocate in parallel
-	bool shared = false;
-	//! Lock used in case this ColumnDataAllocator is shared across threads
-	mutex lock;
-	//! Total allocated size
-	idx_t allocated_size = 0;
-	//! Partition index (optional, if partitioned)
-	optional_idx partition_index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp b/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp
deleted file mode 100644
index f02d49001..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp
+++ /dev/null
@@ -1,239 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/column_data_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/column/column_data_collection_iterators.hpp"
-
-namespace duckdb {
-class BufferManager;
-class BlockHandle;
-class ClientContext;
-struct ColumnDataCopyFunction;
-class ColumnDataAllocator;
-class ColumnDataCollection;
-class ColumnDataCollectionSegment;
-class ColumnDataRowCollection;
-
-//! The ColumnDataCollection represents a set of (buffer-managed) data stored in columnar format
-//! It is efficient to read and scan
-class ColumnDataCollection {
-public:
-	//! Constructs an in-memory column data collection from an allocator
-	DUCKDB_API ColumnDataCollection(Allocator &allocator, vector<LogicalType> types);
-	//! Constructs an empty (but valid) in-memory column data collection from an allocator
-	DUCKDB_API explicit ColumnDataCollection(Allocator &allocator);
-	//! Constructs a buffer-managed column data collection
-	DUCKDB_API ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types);
-	//! Constructs either an in-memory or a buffer-managed column data collection
-	DUCKDB_API ColumnDataCollection(ClientContext &context, vector<LogicalType> types,
-	                                ColumnDataAllocatorType type = ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
-	//! Creates a column data collection that inherits the blocks to write to. This allows blocks to be shared
-	//! between multiple column data collections and prevents wasting space.
-	//! Note that after one CDC inherits blocks from another, the other
-	//! cannot be written to anymore (i.e. we take ownership of the half-written blocks).
-	DUCKDB_API ColumnDataCollection(ColumnDataCollection &parent);
-	DUCKDB_API ColumnDataCollection(shared_ptr<ColumnDataAllocator> allocator, vector<LogicalType> types);
-	DUCKDB_API ~ColumnDataCollection();
-
-public:
-	//! The types of columns in the ColumnDataCollection
-	vector<LogicalType> &Types() {
-		return types;
-	}
-	const vector<LogicalType> &Types() const {
-		return types;
-	}
-
-	//! The amount of rows in the ColumnDataCollection
-	const idx_t &Count() const {
-		return count;
-	}
-
-	//! The amount of columns in the ColumnDataCollection
-	idx_t ColumnCount() const {
-		return types.size();
-	}
-
-	//! The size (in bytes) of this ColumnDataCollection
-	idx_t SizeInBytes() const;
-	//! The allocation size (in bytes) of this ColumnDataCollection - this property is cached
-	idx_t AllocationSize() const;
-	//! Sets the partition index of this ColumnDataCollection
-	void SetPartitionIndex(idx_t index);
-
-	//! Get the allocator
-	DUCKDB_API Allocator &GetAllocator() const;
-
-	//! Initializes an Append state - useful for optimizing many appends made to the same column data collection
-	DUCKDB_API void InitializeAppend(ColumnDataAppendState &state);
-	//! Append a DataChunk to this ColumnDataCollection using the specified append state
-	DUCKDB_API void Append(ColumnDataAppendState &state, DataChunk &new_chunk);
-
-	//! Initializes a chunk with the correct types that can be used to call Scan
-	DUCKDB_API void InitializeScanChunk(DataChunk &chunk) const;
-	//! Initializes a chunk with the correct types for a given scan state
-	DUCKDB_API void InitializeScanChunk(ColumnDataScanState &state, DataChunk &chunk) const;
-	//! Initializes a Scan state for scanning all columns
-	DUCKDB_API void
-	InitializeScan(ColumnDataScanState &state,
-	               ColumnDataScanProperties properties = ColumnDataScanProperties::ALLOW_ZERO_COPY) const;
-	//! Initializes a Scan state for scanning a subset of the columns
-	DUCKDB_API void
-	InitializeScan(ColumnDataScanState &state, vector<column_t> column_ids,
-	               ColumnDataScanProperties properties = ColumnDataScanProperties::ALLOW_ZERO_COPY) const;
-	//! Initialize a parallel scan over the column data collection over all columns
-	DUCKDB_API void
-	InitializeScan(ColumnDataParallelScanState &state,
-	               ColumnDataScanProperties properties = ColumnDataScanProperties::ALLOW_ZERO_COPY) const;
-	//! Initialize a parallel scan over the column data collection over a subset of the columns
-	DUCKDB_API void
-	InitializeScan(ColumnDataParallelScanState &state, vector<column_t> column_ids,
-	               ColumnDataScanProperties properties = ColumnDataScanProperties::ALLOW_ZERO_COPY) const;
-	//! Scans a DataChunk from the ColumnDataCollection
-	DUCKDB_API bool Scan(ColumnDataScanState &state, DataChunk &result) const;
-	//! Scans a DataChunk from the ColumnDataCollection
-	DUCKDB_API bool Scan(ColumnDataParallelScanState &state, ColumnDataLocalScanState &lstate, DataChunk &result) const;
-
-	//! Append a DataChunk directly to this ColumnDataCollection - calls InitializeAppend and Append internally
-	DUCKDB_API void Append(DataChunk &new_chunk);
-
-	//! Appends the other ColumnDataCollection to this, destroying the other data collection
-	DUCKDB_API void Combine(ColumnDataCollection &other);
-
-	DUCKDB_API void Verify();
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print() const;
-
-	DUCKDB_API void Reset();
-
-	//! Returns the number of data chunks present in the ColumnDataCollection
-	DUCKDB_API idx_t ChunkCount() const;
-	//! Fetch an individual chunk from the ColumnDataCollection
-	DUCKDB_API void FetchChunk(idx_t chunk_idx, DataChunk &result) const;
-
-	//! Constructs a class that can be iterated over to fetch individual chunks
-	//! Iterating over this is syntactic sugar over just calling Scan
-	DUCKDB_API ColumnDataChunkIterationHelper Chunks() const;
-	//! Constructs a class that can be iterated over to fetch individual chunks
-	//! Only the column indexes specified in the column_ids list are scanned
-	DUCKDB_API ColumnDataChunkIterationHelper Chunks(vector<column_t> column_ids) const;
-
-	//! Constructs a class that can be iterated over to fetch individual rows
-	//! Note that row iteration is slow, and the `.Chunks()` method should be used instead
-	DUCKDB_API ColumnDataRowIterationHelper Rows() const;
-
-	//! Returns a materialized set of all of the rows in the column data collection
-	//! Note that usage of this is slow - avoid using this unless the amount of rows is small, or if you do not care
-	//! about performance
-	DUCKDB_API ColumnDataRowCollection GetRows() const;
-
-	//! Compare two column data collections to another. If they are equal according to result equality rules,
-	//! return true. That means null values are equal, and approx equality is used for floating point values.
-	//! If they are not equal, return false and fill in the error message.
-	static bool ResultEquals(const ColumnDataCollection &left, const ColumnDataCollection &right, string &error_message,
-	                         bool ordered = false);
-
-	//! Obtains the next scan index to scan from
-	bool NextScanIndex(ColumnDataScanState &state, idx_t &chunk_index, idx_t &segment_index, idx_t &row_index) const;
-	//! Obtains the previous scan index to scan from
-	bool PrevScanIndex(ColumnDataScanState &state, idx_t &chunk_index, idx_t &segment_index, idx_t &row_index) const;
-	//! Scans at the indices (obtained from NextScanIndex)
-	void ScanAtIndex(ColumnDataParallelScanState &state, ColumnDataLocalScanState &lstate, DataChunk &result,
-	                 idx_t chunk_index, idx_t segment_index, idx_t row_index) const;
-
-	//! Seeks to the chunk _containing_ the row. Returns false if it is past the end.
-	//! Note that the returned chunk will likely not be aligned to the given row
-	//! but the scan state will provide the actual range
-	bool Seek(idx_t row_idx, ColumnDataScanState &state, DataChunk &result) const;
-
-	//! Initialize the column data collection
-	void Initialize(vector<LogicalType> types);
-
-	//! Get references to the string heaps in this ColumnDataCollection
-	vector<shared_ptr<StringHeap>> GetHeapReferences();
-	//! Get the allocator type of this ColumnDataCollection
-	ColumnDataAllocatorType GetAllocatorType() const;
-
-	//! Get a vector of the segments in this ColumnDataCollection
-	const vector<unique_ptr<ColumnDataCollectionSegment>> &GetSegments() const;
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<ColumnDataCollection> Deserialize(Deserializer &deserializer);
-
-private:
-	//! Creates a new segment within the ColumnDataCollection
-	void CreateSegment();
-
-	static ColumnDataCopyFunction GetCopyFunction(const LogicalType &type);
-
-private:
-	//! The Column Data Allocator
-	buffer_ptr<ColumnDataAllocator> allocator;
-	//! The types of the stored entries
-	vector<LogicalType> types;
-	//! The number of entries stored in the column data collection
-	idx_t count;
-	//! The data segments of the column data collection
-	vector<unique_ptr<ColumnDataCollectionSegment>> segments;
-	//! The set of copy functions
-	vector<ColumnDataCopyFunction> copy_functions;
-	//! When the column data collection is marked as finished - new tuples can no longer be appended to it
-	bool finished_append;
-	//! Partition index (optional, if partitioned)
-	optional_idx partition_index;
-};
-
-//! The ColumnDataRowCollection represents a set of materialized rows, as obtained from the ColumnDataCollection
-class ColumnDataRowCollection {
-public:
-	DUCKDB_API explicit ColumnDataRowCollection(const ColumnDataCollection &collection);
-
-public:
-	DUCKDB_API Value GetValue(idx_t column, idx_t index) const;
-
-public:
-	// container API
-	bool empty() const {     // NOLINT: match stl API
-		return rows.empty(); // NOLINT
-	}
-	idx_t size() const { // NOLINT: match stl API
-		return rows.size();
-	}
-
-	DUCKDB_API ColumnDataRow &operator[](idx_t i);
-	DUCKDB_API const ColumnDataRow &operator[](idx_t i) const;
-
-	vector<ColumnDataRow>::iterator begin() { // NOLINT: match stl API
-		return rows.begin();
-	}
-	vector<ColumnDataRow>::iterator end() { // NOLINT: match stl API
-		return rows.end();
-	}
-	vector<ColumnDataRow>::const_iterator cbegin() const { // NOLINT: match stl API
-		return rows.cbegin();
-	}
-	vector<ColumnDataRow>::const_iterator cend() const { // NOLINT: match stl API
-		return rows.cend();
-	}
-	vector<ColumnDataRow>::const_iterator begin() const { // NOLINT: match stl API
-		return rows.begin();
-	}
-	vector<ColumnDataRow>::const_iterator end() const { // NOLINT: match stl API
-		return rows.end();
-	}
-
-private:
-	vector<ColumnDataRow> rows;
-	vector<unique_ptr<DataChunk>> chunks;
-	ColumnDataScanState scan_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_iterators.hpp b/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_iterators.hpp
deleted file mode 100644
index b84b81d47..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_iterators.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/column_data_collection_iterators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_scan_states.hpp"
-
-namespace duckdb {
-class ColumnDataCollection;
-
-class ColumnDataChunkIterationHelper {
-public:
-	DUCKDB_API ColumnDataChunkIterationHelper(const ColumnDataCollection &collection, vector<column_t> column_ids);
-
-private:
-	const ColumnDataCollection &collection;
-	vector<column_t> column_ids;
-
-private:
-	class ColumnDataChunkIterator;
-
-	class ColumnDataChunkIterator {
-	public:
-		DUCKDB_API explicit ColumnDataChunkIterator(const ColumnDataCollection *collection_p,
-		                                            vector<column_t> column_ids);
-
-		const ColumnDataCollection *collection;
-		ColumnDataScanState scan_state;
-		shared_ptr<DataChunk> scan_chunk;
-		idx_t row_index;
-
-	public:
-		DUCKDB_API void Next();
-
-		DUCKDB_API ColumnDataChunkIterator &operator++();
-		DUCKDB_API bool operator!=(const ColumnDataChunkIterator &other) const;
-		DUCKDB_API DataChunk &operator*() const;
-	};
-
-public:
-	ColumnDataChunkIterator begin() { // NOLINT: match stl API
-		return ColumnDataChunkIterator(&collection, column_ids);
-	}
-	ColumnDataChunkIterator end() { // NOLINT: match stl API
-		return ColumnDataChunkIterator(nullptr, vector<column_t>());
-	}
-};
-
-class ColumnDataRowIterationHelper {
-public:
-	DUCKDB_API explicit ColumnDataRowIterationHelper(const ColumnDataCollection &collection);
-
-private:
-	const ColumnDataCollection &collection;
-
-private:
-	class ColumnDataRowIterator;
-
-	class ColumnDataRowIterator {
-	public:
-		DUCKDB_API explicit ColumnDataRowIterator(const ColumnDataCollection *collection_p);
-
-		const ColumnDataCollection *collection;
-		ColumnDataScanState scan_state;
-		shared_ptr<DataChunk> scan_chunk;
-		ColumnDataRow current_row;
-
-	public:
-		void Next();
-
-		DUCKDB_API ColumnDataRowIterator &operator++();
-		DUCKDB_API bool operator!=(const ColumnDataRowIterator &other) const;
-		DUCKDB_API const ColumnDataRow &operator*() const;
-	};
-
-public:
-	DUCKDB_API ColumnDataRowIterator begin(); // NOLINT: match stl API
-	DUCKDB_API ColumnDataRowIterator end();   // NOLINT: match stl API
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_segment.hpp b/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_segment.hpp
deleted file mode 100644
index 76ba2b90c..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_segment.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/column_data_collection_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_allocator.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-
-struct VectorChildIndex {
-	explicit VectorChildIndex(idx_t index = DConstants::INVALID_INDEX) : index(index) {
-	}
-
-	idx_t index;
-
-	bool IsValid() {
-		return index != DConstants::INVALID_INDEX;
-	}
-};
-
-struct VectorDataIndex {
-	explicit VectorDataIndex(idx_t index = DConstants::INVALID_INDEX) : index(index) {
-	}
-
-	idx_t index;
-
-	bool IsValid() {
-		return index != DConstants::INVALID_INDEX;
-	}
-};
-
-struct SwizzleMetaData {
-	SwizzleMetaData(VectorDataIndex child_index_p, uint16_t offset_p, uint16_t count_p)
-	    : child_index(child_index_p), offset(offset_p), count(count_p) {
-	}
-	//! Index of block storing heap
-	VectorDataIndex child_index;
-	//! Offset into the string_t vector
-	uint16_t offset;
-	//! Number of strings starting at 'offset' that have strings stored in the block with index 'child_index'
-	uint16_t count;
-};
-
-struct VectorMetaData {
-	//! Where the vector data lives
-	uint32_t block_id;
-	uint32_t offset;
-	//! The number of entries present in this vector
-	uint16_t count;
-	//! Meta data about string pointers
-	vector<SwizzleMetaData> swizzle_data;
-
-	//! Child data of this vector (used only for lists and structs)
-	//! Note: child indices are stored with one layer of indirection
-	//! The child_index here refers to the `child_indices` array in the ColumnDataCollectionSegment
-	//! The entry in the child_indices array then refers to the actual `VectorMetaData` index
-	//! In case of structs, the child_index refers to the FIRST child in the `child_indices` array
-	//! Subsequent children are stored consecutively, i.e.
-	//! first child: segment.child_indices[child_index + 0]
-	//! nth child  : segment.child_indices[child_index + (n - 1)]
-	VectorChildIndex child_index;
-	//! Next vector entry (in case there is more data - used only in case of children of lists)
-	VectorDataIndex next_data;
-};
-
-struct ChunkMetaData {
-	//! The set of vectors of the chunk
-	vector<VectorDataIndex> vector_data;
-	//! The block ids referenced by the chunk
-	unordered_set<uint32_t> block_ids;
-	//! The number of entries in the chunk
-	uint16_t count;
-};
-
-class ColumnDataCollectionSegment {
-public:
-	ColumnDataCollectionSegment(shared_ptr<ColumnDataAllocator> allocator, vector<LogicalType> types_p);
-
-	shared_ptr<ColumnDataAllocator> allocator;
-	//! The types of the chunks
-	vector<LogicalType> types;
-	//! The number of entries in the internal column data
-	idx_t count;
-	//! Set of chunk meta data
-	vector<ChunkMetaData> chunk_data;
-	//! Set of vector meta data
-	vector<VectorMetaData> vector_data;
-	//! The set of child indices
-	vector<VectorDataIndex> child_indices;
-	//! The string heap for the column data collection (only used for IN_MEMORY_ALLOCATOR)
-	shared_ptr<StringHeap> heap;
-
-public:
-	void AllocateNewChunk();
-	//! Allocate space for a vector of a specific type in the segment
-	VectorDataIndex AllocateVector(const LogicalType &type, ChunkMetaData &chunk_data,
-	                               ChunkManagementState *chunk_state = nullptr,
-	                               VectorDataIndex prev_index = VectorDataIndex());
-	//! Allocate space for a vector during append
-	VectorDataIndex AllocateVector(const LogicalType &type, ChunkMetaData &chunk_data,
-	                               ColumnDataAppendState &append_state, VectorDataIndex prev_index = VectorDataIndex());
-	//! Allocate space for string data during append (BUFFER_MANAGER_ALLOCATOR only)
-	VectorDataIndex AllocateStringHeap(idx_t size, ChunkMetaData &chunk_meta, ColumnDataAppendState &append_state,
-	                                   VectorDataIndex prev_index = VectorDataIndex());
-
-	void InitializeChunkState(idx_t chunk_index, ChunkManagementState &state);
-	void ReadChunk(idx_t chunk_index, ChunkManagementState &state, DataChunk &chunk,
-	               const vector<column_t> &column_ids);
-
-	idx_t ReadVector(ChunkManagementState &state, VectorDataIndex vector_index, Vector &result);
-
-	VectorDataIndex GetChildIndex(VectorChildIndex index, idx_t child_entry = 0);
-	VectorChildIndex AddChildIndex(VectorDataIndex index);
-	VectorChildIndex ReserveChildren(idx_t child_count);
-	void SetChildIndex(VectorChildIndex base_idx, idx_t child_number, VectorDataIndex index);
-
-	VectorMetaData &GetVectorData(VectorDataIndex index) {
-		D_ASSERT(index.index < vector_data.size());
-		return vector_data[index.index];
-	}
-
-	idx_t ChunkCount() const;
-	//! Get the total *used* size (not cached)
-	idx_t SizeInBytes() const;
-	//! Get the currently allocated size in bytes (cached)
-	idx_t AllocationSize() const;
-
-	void FetchChunk(idx_t chunk_idx, DataChunk &result);
-	void FetchChunk(idx_t chunk_idx, DataChunk &result, const vector<column_t> &column_ids);
-
-	void Verify();
-
-	static idx_t GetDataSize(idx_t type_size);
-	static validity_t *GetValidityPointerForWriting(data_ptr_t base_ptr, idx_t type_size);
-	static validity_t *GetValidityPointer(data_ptr_t base_ptr, idx_t type_size, idx_t count);
-
-private:
-	idx_t ReadVectorInternal(ChunkManagementState &state, VectorDataIndex vector_index, Vector &result);
-	VectorDataIndex AllocateVectorInternal(const LogicalType &type, ChunkMetaData &chunk_meta,
-	                                       ChunkManagementState *chunk_state);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/column_data_consumer.hpp b/src/duckdb/src/include/duckdb/common/types/column/column_data_consumer.hpp
deleted file mode 100644
index d056cf085..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/column_data_consumer.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/column_data_consumer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/types/column/column_data_collection_segment.hpp"
-#include "duckdb/common/types/column/column_data_scan_states.hpp"
-
-namespace duckdb {
-
-struct ColumnDataConsumerScanState {
-	ColumnDataAllocator *allocator = nullptr;
-	ChunkManagementState current_chunk_state;
-	idx_t chunk_index;
-};
-
-//! ColumnDataConsumer can scan a ColumnDataCollection, and consume it in the process, i.e., read blocks are deleted
-class ColumnDataConsumer {
-public:
-	struct ChunkReference {
-	public:
-		ChunkReference(ColumnDataCollectionSegment *segment_p, uint32_t chunk_index_p);
-		uint32_t GetMinimumBlockID() const;
-		friend bool operator<(const ChunkReference &lhs, const ChunkReference &rhs) {
-			// Sort by allocator first
-			if (lhs.segment->allocator.get() != rhs.segment->allocator.get()) {
-				return lhs.segment->allocator.get() < rhs.segment->allocator.get();
-			}
-			// Then by minimum block id
-			return lhs.GetMinimumBlockID() < rhs.GetMinimumBlockID();
-		}
-
-	public:
-		ColumnDataCollectionSegment *segment;
-		uint32_t chunk_index_in_segment;
-	};
-
-public:
-	ColumnDataConsumer(ColumnDataCollection &collection, vector<column_t> column_ids);
-
-	idx_t Count() const {
-		return collection.Count();
-	}
-
-	idx_t ChunkCount() const {
-		return chunk_count;
-	}
-
-public:
-	//! Initialize the scan of the ColumnDataCollection
-	void InitializeScan();
-	//! Assign a chunk to the scan state
-	bool AssignChunk(ColumnDataConsumerScanState &state);
-	//! Scan the assigned chunk
-	void ScanChunk(ColumnDataConsumerScanState &state, DataChunk &chunk) const;
-	//! Indicate that scanning the chunk is done
-	void FinishChunk(ColumnDataConsumerScanState &state);
-
-private:
-	void ConsumeChunks(idx_t delete_index_start, idx_t delete_index_end);
-
-private:
-	mutex lock;
-	//! The collection being scanned
-	ColumnDataCollection &collection;
-	//! The column ids to scan
-	vector<column_t> column_ids;
-	//! The number of chunk references
-	idx_t chunk_count;
-	//! The chunks (in order) to be scanned
-	vector<ChunkReference> chunk_references;
-	//! Current index into "chunks"
-	idx_t current_chunk_index;
-	//! Chunks currently in progress
-	unordered_set<idx_t> chunks_in_progress;
-	//! The data has been consumed up to this chunk index
-	idx_t chunk_delete_index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/column_data_scan_states.hpp b/src/duckdb/src/include/duckdb/common/types/column/column_data_scan_states.hpp
deleted file mode 100644
index c809520c6..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/column_data_scan_states.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/column_data_scan_states.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/mutex.hpp"
-
-namespace duckdb {
-
-enum class ColumnDataAllocatorType : uint8_t {
-	//! Use a buffer manager to allocate large chunks of memory that vectors then use
-	BUFFER_MANAGER_ALLOCATOR,
-	//! Use an in-memory allocator, allocating data for every chunk
-	//! This causes the column data collection to allocate blocks that are not tied to a buffer manager
-	IN_MEMORY_ALLOCATOR,
-	//! Use a buffer manager to allocate vectors, but use a StringHeap for strings
-	HYBRID
-};
-
-enum class ColumnDataScanProperties : uint8_t {
-	INVALID,
-	//! Allow zero copy scans - this introduces a dependency on the resulting vector on the scan state of the column
-	//! data collection, which means vectors might not be valid anymore after the next chunk is scanned.
-	ALLOW_ZERO_COPY,
-	//! Disallow zero-copy scans, always copying data into the target vector
-	//! As a result, data scanned will be valid even after the column data collection is destroyed
-	DISALLOW_ZERO_COPY
-};
-
-struct ChunkManagementState {
-	unordered_map<idx_t, BufferHandle> handles;
-	ColumnDataScanProperties properties = ColumnDataScanProperties::INVALID;
-};
-
-struct ColumnDataAppendState {
-	ChunkManagementState current_chunk_state;
-	vector<UnifiedVectorFormat> vector_data;
-};
-
-struct ColumnDataScanState {
-	ChunkManagementState current_chunk_state;
-	idx_t segment_index;
-	idx_t chunk_index;
-	idx_t current_row_index;
-	idx_t next_row_index;
-	ColumnDataScanProperties properties;
-	vector<column_t> column_ids;
-};
-
-struct ColumnDataParallelScanState {
-	ColumnDataScanState scan_state;
-	mutex lock;
-};
-
-struct ColumnDataLocalScanState {
-	ChunkManagementState current_chunk_state;
-	idx_t current_segment_index = DConstants::INVALID_INDEX;
-	idx_t current_row_index;
-};
-
-class ColumnDataRow {
-public:
-	ColumnDataRow(DataChunk &chunk, idx_t row_index, idx_t base_index);
-
-	DataChunk &chunk;
-	idx_t row_index;
-	idx_t base_index;
-
-public:
-	Value GetValue(idx_t column_index) const;
-	idx_t RowIndex() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/column/partitioned_column_data.hpp b/src/duckdb/src/include/duckdb/common/types/column/partitioned_column_data.hpp
deleted file mode 100644
index a16ee6370..000000000
--- a/src/duckdb/src/include/duckdb/common/types/column/partitioned_column_data.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/column/partitioned_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/fixed_size_map.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/perfect_map_set.hpp"
-#include "duckdb/common/types/column/column_data_allocator.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-
-//! Local state for parallel partitioning
-struct PartitionedColumnDataAppendState {
-public:
-	PartitionedColumnDataAppendState() : partition_indices(LogicalType::UBIGINT) {
-	}
-
-public:
-	Vector partition_indices;
-	SelectionVector partition_sel;
-
-	static constexpr idx_t MAP_THRESHOLD = 256;
-	perfect_map_t<list_entry_t> partition_entries;
-	fixed_size_map_t<list_entry_t> fixed_partition_entries;
-
-	DataChunk slice_chunk;
-
-	vector<unique_ptr<DataChunk>> partition_buffers;
-	vector<unique_ptr<ColumnDataAppendState>> partition_append_states;
-
-public:
-	template <bool fixed>
-	typename std::conditional<fixed, fixed_size_map_t<list_entry_t>, perfect_map_t<list_entry_t>>::type &GetMap() {
-		throw NotImplementedException("PartitionedColumnDataAppendState::GetMap for boolean value");
-	}
-
-	optional_idx GetPartitionIndexIfSinglePartition(const bool use_fixed_size_map) {
-		optional_idx result;
-		if (use_fixed_size_map) {
-			if (fixed_partition_entries.size() == 1) {
-				result = fixed_partition_entries.begin().GetKey();
-			}
-		} else {
-			if (partition_entries.size() == 1) {
-				result = partition_entries.begin()->first;
-			}
-		}
-		return result;
-	}
-};
-
-template <>
-inline perfect_map_t<list_entry_t> &PartitionedColumnDataAppendState::GetMap<false>() {
-	return partition_entries;
-}
-
-template <>
-inline fixed_size_map_t<list_entry_t> &PartitionedColumnDataAppendState::GetMap<true>() {
-	return fixed_partition_entries;
-}
-
-enum class PartitionedColumnDataType : uint8_t {
-	INVALID,
-	//! Radix partitioning on a hash column
-	RADIX,
-	//! Hive-style multi-field partitioning
-	HIVE
-};
-
-//! Shared allocators for parallel partitioning
-struct PartitionColumnDataAllocators {
-	mutex lock;
-	vector<shared_ptr<ColumnDataAllocator>> allocators;
-};
-
-//! PartitionedColumnData represents partitioned columnar data, which serves as an interface for different types of
-//! partitioning, e.g., radix, hive
-class PartitionedColumnData {
-public:
-	unique_ptr<PartitionedColumnData> CreateShared();
-	virtual ~PartitionedColumnData();
-
-public:
-	//! Initializes a local state for parallel partitioning that can be merged into this PartitionedColumnData
-	void InitializeAppendState(PartitionedColumnDataAppendState &state) const;
-	//! Appends a DataChunk to this PartitionedColumnData
-	void Append(PartitionedColumnDataAppendState &state, DataChunk &input);
-	//! Flushes any remaining data in the append state into this PartitionedColumnData
-	void FlushAppendState(PartitionedColumnDataAppendState &state);
-	//! Combine another PartitionedColumnData into this PartitionedColumnData
-	void Combine(PartitionedColumnData &other);
-	//! Get the partitions in this PartitionedColumnData
-	vector<unique_ptr<ColumnDataCollection>> &GetPartitions();
-
-protected:
-	//===--------------------------------------------------------------------===//
-	// Partitioning type implementation interface
-	//===--------------------------------------------------------------------===//
-	//! Size of the buffers in the append states for this type of partitioning (default 128)
-	virtual idx_t BufferSize() const {
-		return MinValue<idx_t>(128, STANDARD_VECTOR_SIZE);
-	}
-	//! Initialize a PartitionedColumnDataAppendState for this type of partitioning (optional)
-	virtual void InitializeAppendStateInternal(PartitionedColumnDataAppendState &state) const {
-	}
-	//! Compute the partition indices for this type of partitioning for the input DataChunk and store them in the
-	//! `partition_data` of the local state. If this type creates partitions on the fly (for, e.g., hive), this
-	//! function is also in charge of creating new partitions and mapping the input data to a partition index
-	virtual void ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) {
-		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedColumnData");
-	}
-	//!
-
-	//! Maximum partition index (optional)
-	virtual idx_t MaxPartitionIndex() const {
-		return DConstants::INVALID_INDEX;
-	}
-
-protected:
-	//! PartitionedColumnData can only be instantiated by derived classes
-	PartitionedColumnData(PartitionedColumnDataType type, ClientContext &context, vector<LogicalType> types);
-	PartitionedColumnData(const PartitionedColumnData &other);
-
-	//! If the buffer is half full, we append to the partition
-	inline idx_t HalfBufferSize() const {
-		D_ASSERT(IsPowerOfTwo(BufferSize()));
-		return BufferSize() / 2;
-	}
-	//! Create a new shared allocator
-	void CreateAllocator();
-	//! Whether to use fixed size map or regular map
-	bool UseFixedSizeMap() const;
-	//! Builds a selection vector in the Append state for the partitions
-	//! - returns true if everything belongs to the same partition - stores partition index in single_partition_idx
-	void BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) const;
-	template <bool fixed>
-	static void BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count);
-	//! Appends a DataChunk to this PartitionedColumnData
-	template <bool fixed>
-	void AppendInternal(PartitionedColumnDataAppendState &state, DataChunk &input);
-	//! Create a collection for a specific a partition
-	unique_ptr<ColumnDataCollection> CreatePartitionCollection(idx_t partition_index) const {
-		return make_uniq<ColumnDataCollection>(allocators->allocators[partition_index], types);
-	}
-	//! Create a DataChunk used for buffering appends to the partition
-	unique_ptr<DataChunk> CreatePartitionBuffer() const;
-
-protected:
-	PartitionedColumnDataType type;
-	ClientContext &context;
-	vector<LogicalType> types;
-
-	mutex lock;
-	shared_ptr<PartitionColumnDataAllocators> allocators;
-	vector<unique_ptr<ColumnDataCollection>> partitions;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/conflict_manager.hpp b/src/duckdb/src/include/duckdb/common/types/conflict_manager.hpp
deleted file mode 100644
index f120b91d9..000000000
--- a/src/duckdb/src/include/duckdb/common/types/conflict_manager.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/conflict_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/common/types/selection_vector.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class Index;
-class ConflictInfo;
-
-enum class ConflictManagerMode : uint8_t {
-	SCAN, // gather conflicts without throwing
-	THROW // throw on the conflicts that were not found during the scan
-};
-
-enum class LookupResultType : uint8_t { LOOKUP_MISS, LOOKUP_HIT, LOOKUP_NULL };
-
-class ConflictManager {
-public:
-	ConflictManager(VerifyExistenceType lookup_type, idx_t input_size,
-	                optional_ptr<ConflictInfo> conflict_info = nullptr);
-
-public:
-	// These methods return a boolean indicating whether we should throw or not
-	bool AddMiss(idx_t chunk_index);
-	bool AddHit(idx_t chunk_index, row_t row_id);
-	bool AddNull(idx_t chunk_index);
-	VerifyExistenceType LookupType() const;
-	// This should be called before using the conflicts selection vector
-	void Finalize();
-
-	Vector &RowIds();
-	const ConflictInfo &GetConflictInfo() const;
-	void FinishLookup();
-	void SetMode(ConflictManagerMode mode);
-
-	//! Returns a reference to all conflicts in this conflict manager.
-	const ManagedSelection &Conflicts() const;
-	//! Returns the number of conflicts in this conflict manager.
-	idx_t ConflictCount() const;
-	//! Adds an index and its respective delete_index to the conflict manager's matches.
-	void AddIndex(BoundIndex &index, optional_ptr<BoundIndex> delete_index);
-	//! Returns true, if the index is in this conflict manager.
-	bool MatchedIndex(BoundIndex &index);
-	//! Returns a reference to the matched indexes.
-	const vector<reference<BoundIndex>> &MatchedIndexes() const;
-	//! Returns a reference to the matched delete indexes.
-	const vector<optional_ptr<BoundIndex>> &MatchedDeleteIndexes() const;
-
-private:
-	bool IsConflict(LookupResultType type);
-	const unordered_set<idx_t> &InternalConflictSet() const;
-	Vector &InternalRowIds();
-	Vector &InternalIntermediate();
-	ManagedSelection &InternalSelection();
-	bool SingleIndexTarget() const;
-	bool ShouldThrow(idx_t chunk_index) const;
-	bool ShouldIgnoreNulls() const;
-	void AddConflictInternal(idx_t chunk_index, row_t row_id);
-	void AddToConflictSet(idx_t chunk_index);
-
-private:
-	VerifyExistenceType lookup_type;
-	idx_t input_size;
-	optional_ptr<ConflictInfo> conflict_info;
-	bool finalized = false;
-	ManagedSelection conflicts;
-	unique_ptr<Vector> row_ids;
-	// Used to check if a given conflict is part of the conflict target or not
-	unique_ptr<unordered_set<idx_t>> conflict_set;
-	// Contains 'input_size' booleans, indicating if a given index in the input chunk has a conflict
-	unique_ptr<Vector> intermediate_vector;
-	// Mapping from chunk_index to row_id
-	vector<row_t> row_id_map;
-	// Whether we have already found the one conflict target we're interested in
-	bool single_index_finished = false;
-	ConflictManagerMode mode;
-
-	//! Indexes matching the conflict target.
-	vector<reference<BoundIndex>> matched_indexes;
-	//! Delete indexes matching the conflict target.
-	vector<optional_ptr<BoundIndex>> matched_delete_indexes;
-	//! All matched indexes by their name, which is their unique identifier.
-	case_insensitive_set_t matched_index_names;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/constraint_conflict_info.hpp b/src/duckdb/src/include/duckdb/common/types/constraint_conflict_info.hpp
deleted file mode 100644
index 6ead1a0f5..000000000
--- a/src/duckdb/src/include/duckdb/common/types/constraint_conflict_info.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/selection_vector.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-class Index;
-
-class ConflictInfo {
-public:
-	explicit ConflictInfo(const unordered_set<column_t> &column_ids, bool only_check_unique = true)
-	    : column_ids(column_ids), only_check_unique(only_check_unique) {
-	}
-	const unordered_set<column_t> &column_ids;
-
-public:
-	bool ConflictTargetMatches(Index &index) const;
-
-public:
-	bool only_check_unique = true;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp b/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp
deleted file mode 100644
index cb6ebcba5..000000000
--- a/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/data_chunk.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/winapi.hpp"
-
-namespace duckdb {
-class Allocator;
-class ClientContext;
-class ExecutionContext;
-class VectorCache;
-class Serializer;
-class Deserializer;
-
-//!  A Data Chunk represents a set of vectors.
-/*!
-    The data chunk class is the intermediate representation used by the
-   execution engine of DuckDB. It effectively represents a subset of a relation.
-   It holds a set of vectors that all have the same length.
-
-    DataChunk is initialized using the DataChunk::Initialize function by
-   providing it with a vector of TypeIds for the Vector members. By default,
-   this function will also allocate a chunk of memory in the DataChunk for the
-   vectors and all the vectors will be referencing vectors to the data owned by
-   the chunk. The reason for this behavior is that the underlying vectors can
-   become referencing vectors to other chunks as well (i.e. in the case an
-   operator does not alter the data, such as a Filter operator which only adds a
-   selection vector).
-
-    In addition to holding the data of the vectors, the DataChunk also owns the
-   selection vector that underlying vectors can point to.
-*/
-class DataChunk {
-public:
-	//! Creates an empty DataChunk
-	DUCKDB_API DataChunk();
-	DUCKDB_API ~DataChunk();
-
-	//! The vectors owned by the DataChunk.
-	vector<Vector> data;
-
-public:
-	inline idx_t size() const { // NOLINT
-		return count;
-	}
-	inline idx_t ColumnCount() const {
-		return data.size();
-	}
-	inline void SetCardinality(idx_t count_p) {
-		D_ASSERT(count_p <= capacity);
-		this->count = count_p;
-	}
-	inline void SetCardinality(const DataChunk &other) {
-		SetCardinality(other.size());
-	}
-	inline idx_t GetCapacity() const {
-		return capacity;
-	}
-	inline void SetCapacity(idx_t capacity_p) {
-		this->capacity = capacity_p;
-	}
-	inline void SetCapacity(const DataChunk &other) {
-		SetCapacity(other.capacity);
-	}
-
-	DUCKDB_API Value GetValue(idx_t col_idx, idx_t index) const;
-	DUCKDB_API void SetValue(idx_t col_idx, idx_t index, const Value &val);
-
-	idx_t GetAllocationSize() const;
-
-	//! Returns true if all vectors in the DataChunk are constant
-	DUCKDB_API bool AllConstant() const;
-
-	//! Set the DataChunk to reference another data chunk
-	DUCKDB_API void Reference(DataChunk &chunk);
-	//! Set the DataChunk to own the data of data chunk, destroying the other chunk in the process
-	DUCKDB_API void Move(DataChunk &chunk);
-
-	//! Initializes a DataChunk with the given types and without any vector data allocation.
-	DUCKDB_API void InitializeEmpty(const vector<LogicalType> &types);
-
-	//! Initializes a DataChunk with the given types. Then, if the corresponding boolean in the initialize-vector is
-	//! true, it initializes the vector for that data type.
-	DUCKDB_API void Initialize(ClientContext &context, const vector<LogicalType> &types,
-	                           idx_t capacity = STANDARD_VECTOR_SIZE);
-	DUCKDB_API void Initialize(Allocator &allocator, const vector<LogicalType> &types,
-	                           idx_t capacity = STANDARD_VECTOR_SIZE);
-	DUCKDB_API void Initialize(ClientContext &context, const vector<LogicalType> &types, const vector<bool> &initialize,
-	                           idx_t capacity = STANDARD_VECTOR_SIZE);
-	DUCKDB_API void Initialize(Allocator &allocator, const vector<LogicalType> &types, const vector<bool> &initialize,
-	                           idx_t capacity = STANDARD_VECTOR_SIZE);
-
-	//! Append the other DataChunk to this one. The column count and types of
-	//! the two DataChunks have to match exactly. Throws an exception if there
-	//! is not enough space in the chunk and resize is not allowed.
-	DUCKDB_API void Append(const DataChunk &other, bool resize = false, SelectionVector *sel = nullptr,
-	                       idx_t count = 0);
-
-	//! Destroy all data and columns owned by this DataChunk
-	DUCKDB_API void Destroy();
-
-	//! Copies the data from this chunk to another chunk.
-	DUCKDB_API void Copy(DataChunk &other, idx_t offset = 0) const;
-	DUCKDB_API void Copy(DataChunk &other, const SelectionVector &sel, const idx_t source_count,
-	                     const idx_t offset = 0) const;
-
-	//! Splits the DataChunk in two
-	DUCKDB_API void Split(DataChunk &other, idx_t split_idx);
-
-	//! Fuses a DataChunk onto the right of this one, and destroys the other. Inverse of Split.
-	DUCKDB_API void Fuse(DataChunk &other);
-
-	//! Makes this DataChunk reference the specified columns in the other DataChunk
-	DUCKDB_API void ReferenceColumns(DataChunk &other, const vector<column_t> &column_ids);
-
-	//! Turn all the vectors from the chunk into flat vectors
-	DUCKDB_API void Flatten();
-
-	// FIXME: this is DUCKDB_API, might need conversion back to regular unique ptr?
-	DUCKDB_API unsafe_unique_array<UnifiedVectorFormat> ToUnifiedFormat();
-
-	DUCKDB_API void Slice(const SelectionVector &sel_vector, idx_t count);
-
-	//! Slice all Vectors from other.data[i] to data[i + 'col_offset']
-	//! Turning all Vectors into Dictionary Vectors, using 'sel'
-	DUCKDB_API void Slice(const DataChunk &other, const SelectionVector &sel, idx_t count, idx_t col_offset = 0);
-
-	//! Slice a DataChunk from "offset" to "offset + count"
-	DUCKDB_API void Slice(idx_t offset, idx_t count);
-
-	//! Resets the DataChunk to its state right after the DataChunk::Initialize
-	//! function was called. This sets the count to 0, and resets each member
-	//! Vector to point back to the data owned by this DataChunk.
-	DUCKDB_API void Reset();
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API void Deserialize(Deserializer &source);
-
-	//! Hashes the DataChunk to the target vector
-	DUCKDB_API void Hash(Vector &result);
-	//! Hashes specific vectors of the DataChunk to the target vector
-	DUCKDB_API void Hash(vector<idx_t> &column_ids, Vector &result);
-
-	//! Returns a list of types of the vectors of this data chunk
-	DUCKDB_API vector<LogicalType> GetTypes() const;
-
-	//! Converts this DataChunk to a printable string representation
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print() const;
-
-	DataChunk(const DataChunk &) = delete;
-
-	//! Verify that the DataChunk is in a consistent, not corrupt state. DEBUG
-	//! FUNCTION ONLY!
-	DUCKDB_API void Verify();
-
-private:
-	//! The amount of tuples stored in the data chunk
-	idx_t count;
-	//! The amount of tuples that can be stored in the data chunk
-	idx_t capacity;
-	//! Vector caches, used to store data when ::Initialize is called
-	vector<VectorCache> vector_caches;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/date.hpp b/src/duckdb/src/include/duckdb/common/types/date.hpp
deleted file mode 100644
index ea6b52ce7..000000000
--- a/src/duckdb/src/include/duckdb/common/types/date.hpp
+++ /dev/null
@@ -1,229 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/date.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/limits.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct timestamp_t; // NOLINT: primitive case
-
-//! Type used to represent dates (days since 1970-01-01)
-struct date_t { // NOLINT
-	int32_t days;
-
-	date_t() = default;
-	explicit inline date_t(int32_t days_p) : days(days_p) {
-	}
-
-	// explicit conversion
-	explicit inline operator int32_t() const {
-		return days;
-	}
-
-	// comparison operators
-	inline bool operator==(const date_t &rhs) const {
-		return days == rhs.days;
-	};
-	inline bool operator!=(const date_t &rhs) const {
-		return days != rhs.days;
-	};
-	inline bool operator<=(const date_t &rhs) const {
-		return days <= rhs.days;
-	};
-	inline bool operator<(const date_t &rhs) const {
-		return days < rhs.days;
-	};
-	inline bool operator>(const date_t &rhs) const {
-		return days > rhs.days;
-	};
-	inline bool operator>=(const date_t &rhs) const {
-		return days >= rhs.days;
-	};
-
-	// arithmetic operators
-	inline date_t operator+(const int32_t &days) const {
-		return date_t(this->days + days);
-	};
-	inline date_t operator-(const int32_t &days) const {
-		return date_t(this->days - days);
-	};
-
-	// in-place operators
-	inline date_t &operator+=(const int32_t &days) {
-		this->days += days;
-		return *this;
-	};
-	inline date_t &operator-=(const int32_t &days) {
-		this->days -= days;
-		return *this;
-	};
-
-	// special values
-	static inline date_t infinity() { // NOLINT
-		return date_t(NumericLimits<int32_t>::Maximum());
-	}                                  // NOLINT
-	static inline date_t ninfinity() { // NOLINT
-		return date_t(-NumericLimits<int32_t>::Maximum());
-	}                              // NOLINT
-	static inline date_t epoch() { // NOLINT
-		return date_t(0);
-	} // NOLINT
-};
-
-enum class DateCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_RANGE };
-
-//! The Date class is a static class that holds helper functions for the Date type.
-class Date {
-public:
-	static const char *PINF;  // NOLINT
-	static const char *NINF;  // NOLINT
-	static const char *EPOCH; // NOLINT
-
-	static const string_t MONTH_NAMES[12];
-	static const string_t MONTH_NAMES_ABBREVIATED[12];
-	static const string_t DAY_NAMES[7];
-	static const string_t DAY_NAMES_ABBREVIATED[7];
-	static const int32_t NORMAL_DAYS[13];
-	static const int32_t CUMULATIVE_DAYS[13];
-	static const int32_t LEAP_DAYS[13];
-	static const int32_t CUMULATIVE_LEAP_DAYS[13];
-	static const int32_t CUMULATIVE_YEAR_DAYS[401];
-	static const int8_t MONTH_PER_DAY_OF_YEAR[365];
-	static const int8_t LEAP_MONTH_PER_DAY_OF_YEAR[366];
-
-	// min date is 5877642-06-25 (BC) (-2^31+2)
-	constexpr static const int32_t DATE_MIN_YEAR = -5877641;
-	constexpr static const int32_t DATE_MIN_MONTH = 6;
-	constexpr static const int32_t DATE_MIN_DAY = 25;
-	// max date is 5881580-07-10 (2^31-2)
-	constexpr static const int32_t DATE_MAX_YEAR = 5881580;
-	constexpr static const int32_t DATE_MAX_MONTH = 7;
-	constexpr static const int32_t DATE_MAX_DAY = 10;
-	constexpr static const int32_t EPOCH_YEAR = 1970;
-
-	constexpr static const int32_t YEAR_INTERVAL = 400;
-	constexpr static const int32_t DAYS_PER_YEAR_INTERVAL = 146097;
-
-public:
-	//! Convert a string in the format "YYYY-MM-DD" to a date object
-	DUCKDB_API static date_t FromString(const string &str, bool strict = false);
-	//! Convert a string in the format "YYYY-MM-DD" to a date object
-	DUCKDB_API static date_t FromCString(const char *str, idx_t len, bool strict = false);
-	//! Convert a date object to a string in the format "YYYY-MM-DD"
-	DUCKDB_API static string ToString(date_t date);
-	//! Try to convert the string as a give "special" date (e.g, PINF, ...)
-	//! Returns true if it was successful and updates the scan pos.
-	DUCKDB_API static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special);
-	//! Try to convert text in a buffer to a date; returns true if parsing was successful
-	//! If the date was a "special" value, the special flag will be set.
-	DUCKDB_API static DateCastResult TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result,
-	                                                bool &special, bool strict = false);
-
-	//! Create a string "YYYY-MM-DD" from a specified (year, month, day)
-	//! combination
-	DUCKDB_API static string Format(int32_t year, int32_t month, int32_t day);
-
-	//! Extract the year, month and day from a given date object
-	DUCKDB_API static void Convert(date_t date, int32_t &out_year, int32_t &out_month, int32_t &out_day);
-	//! Create a Date object from a specified (year, month, day) combination
-	DUCKDB_API static date_t FromDate(int32_t year, int32_t month, int32_t day);
-	DUCKDB_API static bool TryFromDate(int32_t year, int32_t month, int32_t day, date_t &result);
-
-	//! Returns true if (year) is a leap year, and false otherwise
-	DUCKDB_API static bool IsLeapYear(int32_t year);
-
-	//! Returns true if the specified (year, month, day) combination is a valid
-	//! date
-	DUCKDB_API static bool IsValid(int32_t year, int32_t month, int32_t day);
-
-	//! Returns true if the specified date is finite
-	static inline bool IsFinite(date_t date) {
-		return date != date_t::infinity() && date != date_t::ninfinity();
-	}
-
-	//! The max number of days in a month of a given year
-	DUCKDB_API static int32_t MonthDays(int32_t year, int32_t month);
-
-	//! Extract the epoch from the date (seconds since 1970-01-01)
-	DUCKDB_API static int64_t Epoch(date_t date);
-	//! Extract the epoch from the date (nanoseconds since 1970-01-01)
-	DUCKDB_API static int64_t EpochNanoseconds(date_t date);
-	//! Extract the epoch from the date (microseconds since 1970-01-01)
-	DUCKDB_API static int64_t EpochMicroseconds(date_t date);
-	//! Extract the epoch from the date (milliseconds since 1970-01-01)
-	DUCKDB_API static int64_t EpochMilliseconds(date_t date);
-	//! Convert the epoch (seconds since 1970-01-01) to a date_t
-	DUCKDB_API static date_t EpochToDate(int64_t epoch);
-
-	//! Extract the number of days since epoch (days since 1970-01-01)
-	DUCKDB_API static int32_t EpochDays(date_t date);
-	//! Convert the epoch number of days to a date_t
-	DUCKDB_API static date_t EpochDaysToDate(int32_t epoch);
-
-	//! Extract year of a date entry
-	DUCKDB_API static int32_t ExtractYear(date_t date);
-	//! Extract month of a date entry
-	DUCKDB_API static int32_t ExtractMonth(date_t date);
-	//! Extract day of a date entry
-	DUCKDB_API static int32_t ExtractDay(date_t date);
-	//! Extract the day of the week (1-7)
-	DUCKDB_API static int32_t ExtractISODayOfTheWeek(date_t date);
-	//! Extract the day of the year
-	DUCKDB_API static int32_t ExtractDayOfTheYear(date_t date);
-	//! Extract the day of the year
-	DUCKDB_API static int64_t ExtractJulianDay(date_t date);
-	//! Extract the ISO week number
-	//! ISO weeks start on Monday and the first week of a year
-	//! contains January 4 of that year.
-	//! In the ISO week-numbering system, it is possible for early-January dates
-	//! to be part of the 52nd or 53rd week of the previous year.
-	DUCKDB_API static void ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week);
-	DUCKDB_API static int32_t ExtractISOWeekNumber(date_t date);
-	DUCKDB_API static int32_t ExtractISOYearNumber(date_t date);
-	//! Extract the week number as Python handles it.
-	//! Either Monday or Sunday is the first day of the week,
-	//! and any date before the first Monday/Sunday returns week 0
-	//! This is a bit more consistent because week numbers in a year are always incrementing
-	DUCKDB_API static int32_t ExtractWeekNumberRegular(date_t date, bool monday_first = true);
-	//! Returns the date of the monday of the current week.
-	DUCKDB_API static date_t GetMondayOfCurrentWeek(date_t date);
-
-	//! Helper function to parse two digits from a string (e.g. "30" -> 30, "03" -> 3, "3" -> 3)
-	DUCKDB_API static bool ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result);
-
-	DUCKDB_API static string FormatError(const string &str);
-	DUCKDB_API static string FormatError(string_t str);
-
-	DUCKDB_API static string RangeError(const string &str);
-	DUCKDB_API static string RangeError(string_t str);
-
-private:
-	static void ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset);
-};
-
-} // namespace duckdb
-
-namespace std {
-
-//! Date
-template <>
-struct hash<duckdb::date_t> {
-	std::size_t operator()(const duckdb::date_t &k) const {
-		using std::hash;
-		return hash<int32_t>()((int32_t)k);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/types/date_lookup_cache.hpp b/src/duckdb/src/include/duckdb/common/types/date_lookup_cache.hpp
deleted file mode 100644
index b276bbe32..000000000
--- a/src/duckdb/src/include/duckdb/common/types/date_lookup_cache.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/date_lookup_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-
-namespace duckdb {
-struct ValidityMask;
-
-template <class OP>
-class DateLookupCache {
-public:
-	using CACHE_TYPE = uint16_t;
-	constexpr static int32_t CACHE_MIN_DATE = 0;     // 1970-01-01
-	constexpr static int32_t CACHE_MAX_DATE = 29584; // 2050-12-31
-
-public:
-	DateLookupCache() {
-		BuildCache();
-	}
-
-	//! Extracts the component, or sets the validity mask to NULL if the date is infinite
-	int64_t ExtractElement(date_t date, ValidityMask &mask, idx_t idx) const {
-		if (DUCKDB_UNLIKELY(date.days < CACHE_MIN_DATE || date.days >= CACHE_MAX_DATE)) {
-			if (DUCKDB_UNLIKELY(!Value::IsFinite(date))) {
-				mask.SetInvalid(idx);
-				return 0;
-			}
-			return OP::template Operation<date_t, int64_t>(date);
-		}
-		return cache[GetDateCacheEntry(date)];
-	}
-	int64_t ExtractElement(timestamp_t ts, ValidityMask &mask, idx_t idx) const {
-		return ExtractElement(Timestamp::GetDate(ts), mask, idx);
-	}
-
-private:
-	static idx_t GetDateCacheEntry(date_t day) {
-		return UnsafeNumericCast<idx_t>(day.days - DateLookupCache::CACHE_MIN_DATE);
-	}
-
-	void BuildCache() {
-		D_ASSERT(CACHE_MAX_DATE > CACHE_MIN_DATE);
-		cache = make_unsafe_uniq_array_uninitialized<CACHE_TYPE>(CACHE_MAX_DATE - CACHE_MIN_DATE);
-		for (int32_t d = CACHE_MIN_DATE; d < CACHE_MAX_DATE; d++) {
-			date_t date(d);
-			auto cache_entry = OP::template Operation<date_t, int64_t>(date);
-			cache[GetDateCacheEntry(date)] = UnsafeNumericCast<CACHE_TYPE>(cache_entry);
-		}
-	}
-
-private:
-	unsafe_unique_array<CACHE_TYPE> cache;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/datetime.hpp b/src/duckdb/src/include/duckdb/common/types/datetime.hpp
deleted file mode 100644
index ccbb95524..000000000
--- a/src/duckdb/src/include/duckdb/common/types/datetime.hpp
+++ /dev/null
@@ -1,183 +0,0 @@
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-//! Type used to represent time (microseconds)
-struct dtime_t { // NOLINT
-	int64_t micros;
-
-	dtime_t() = default;
-	explicit inline dtime_t(int64_t micros_p) : micros(micros_p) {
-	}
-	inline dtime_t &operator=(int64_t micros_p) {
-		micros = micros_p;
-		return *this;
-	}
-
-	// explicit conversion
-	explicit inline operator int64_t() const {
-		return micros;
-	}
-	explicit inline operator double() const {
-		return static_cast<double>(micros);
-	}
-
-	// comparison operators
-	inline bool operator==(const dtime_t &rhs) const {
-		return micros == rhs.micros;
-	};
-	inline bool operator!=(const dtime_t &rhs) const {
-		return micros != rhs.micros;
-	};
-	inline bool operator<=(const dtime_t &rhs) const {
-		return micros <= rhs.micros;
-	};
-	inline bool operator<(const dtime_t &rhs) const {
-		return micros < rhs.micros;
-	};
-	inline bool operator>(const dtime_t &rhs) const {
-		return micros > rhs.micros;
-	};
-	inline bool operator>=(const dtime_t &rhs) const {
-		return micros >= rhs.micros;
-	};
-
-	// arithmetic operators
-	inline dtime_t operator+(const int64_t &micros) const {
-		return dtime_t(this->micros + micros);
-	};
-	inline dtime_t operator+(const double &micros) const {
-		return dtime_t(this->micros + int64_t(micros));
-	};
-	inline dtime_t operator-(const int64_t &micros) const {
-		return dtime_t(this->micros - micros);
-	};
-	inline dtime_t operator*(const idx_t &copies) const {
-		return dtime_t(this->micros * UnsafeNumericCast<int64_t>(copies));
-	};
-	inline dtime_t operator/(const idx_t &copies) const {
-		return dtime_t(this->micros / UnsafeNumericCast<int64_t>(copies));
-	};
-	inline int64_t operator-(const dtime_t &other) const {
-		return this->micros - other.micros;
-	};
-
-	// in-place operators
-	inline dtime_t &operator+=(const int64_t &micros) {
-		this->micros += micros;
-		return *this;
-	};
-	inline dtime_t &operator-=(const int64_t &micros) {
-		this->micros -= micros;
-		return *this;
-	};
-	inline dtime_t &operator+=(const dtime_t &other) {
-		this->micros += other.micros;
-		return *this;
-	};
-
-	// special values
-	static inline dtime_t allballs() { // NOLINT
-		return dtime_t(0);
-	} // NOLINT
-};
-
-struct dtime_tz_t { // NOLINT
-	static constexpr const int TIME_BITS = 40;
-	static constexpr const int OFFSET_BITS = 24;
-	static constexpr const uint64_t OFFSET_MASK = ~uint64_t(0) >> TIME_BITS;
-	static constexpr const int32_t MAX_OFFSET = 16 * 60 * 60 - 1; // ±15:59:59
-	static constexpr const int32_t MIN_OFFSET = -MAX_OFFSET;
-	static constexpr const uint64_t OFFSET_MICROS = 1000000;
-
-	uint64_t bits;
-
-	//	Offsets are reverse ordered e.g., 13:00:00+01 < 12:00:00+00 < 11:00:00-01
-	//	Because we encode them as the low order bits,
-	//	they are also biased into an unsigned integer: (-16, 16) => (32, 0)
-	static inline uint64_t encode_offset(int32_t offset) { // NOLINT
-		return uint64_t(MAX_OFFSET - offset);
-	}
-	static inline int32_t decode_offset(uint64_t bits) { // NOLINT
-		return MAX_OFFSET - int32_t(bits & OFFSET_MASK);
-	}
-
-	static inline uint64_t encode_micros(int64_t micros) { // NOLINT
-		return encode_micros(UnsafeNumericCast<uint64_t>(micros));
-	}
-	static inline uint64_t encode_micros(uint64_t micros) { // NOLINT
-		return micros << OFFSET_BITS;
-	}
-	static inline int64_t decode_micros(uint64_t bits) { // NOLINT
-		return int64_t(bits >> OFFSET_BITS);
-	}
-
-	dtime_tz_t() = default;
-
-	inline dtime_tz_t(dtime_t t, int32_t offset) : bits(encode_micros(t.micros) | encode_offset(offset)) {
-	}
-	explicit inline dtime_tz_t(uint64_t bits_p) : bits(bits_p) {
-	}
-
-	inline dtime_t time() const { // NOLINT
-		return dtime_t(decode_micros(bits));
-	}
-
-	inline int32_t offset() const { // NOLINT
-		return decode_offset(bits);
-	}
-
-	//	Times are compared after adjusting to offset +00:00:00, e.g., 13:01:00+01 > 12:00:00+00
-	//	Because we encode them as the high order bits,
-	//	they are biased by the maximum offset: (0, 24) => (0, 56)
-	inline uint64_t sort_key() const { // NOLINT
-		return bits + encode_micros((bits & OFFSET_MASK) * OFFSET_MICROS);
-	}
-
-	// comparison operators
-	inline bool operator==(const dtime_tz_t &rhs) const {
-		return bits == rhs.bits;
-	};
-	inline bool operator!=(const dtime_tz_t &rhs) const {
-		return bits != rhs.bits;
-	};
-	inline bool operator<=(const dtime_tz_t &rhs) const {
-		return sort_key() <= rhs.sort_key();
-	};
-	inline bool operator<(const dtime_tz_t &rhs) const {
-		return sort_key() < rhs.sort_key();
-	};
-	inline bool operator>(const dtime_tz_t &rhs) const {
-		return sort_key() > rhs.sort_key();
-	};
-	inline bool operator>=(const dtime_tz_t &rhs) const {
-		return sort_key() >= rhs.sort_key();
-	};
-};
-
-} // namespace duckdb
-
-namespace std {
-
-//! Time
-template <>
-struct hash<duckdb::dtime_t> {
-	std::size_t operator()(const duckdb::dtime_t &k) const {
-		using std::hash;
-		return hash<int64_t>()((int64_t)k);
-	}
-};
-
-template <>
-struct hash<duckdb::dtime_tz_t> {
-	std::size_t operator()(const duckdb::dtime_tz_t &k) const {
-		using std::hash;
-		return hash<uint64_t>()(k.bits);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/types/decimal.hpp b/src/duckdb/src/include/duckdb/common/types/decimal.hpp
deleted file mode 100644
index e08e544a1..000000000
--- a/src/duckdb/src/include/duckdb/common/types/decimal.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/decimal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-template <class PHYSICAL_TYPE>
-struct DecimalWidth {};
-
-template <>
-struct DecimalWidth<int16_t> {
-	static constexpr uint8_t max = 4;
-};
-
-template <>
-struct DecimalWidth<int32_t> {
-	static constexpr uint8_t max = 9;
-};
-
-template <>
-struct DecimalWidth<int64_t> {
-	static constexpr uint8_t max = 18;
-};
-
-template <>
-struct DecimalWidth<hugeint_t> {
-	static constexpr uint8_t max = 38;
-};
-
-//! The Decimal class is a static class that holds helper functions for the Decimal type
-class Decimal {
-public:
-	static constexpr uint8_t MAX_WIDTH_INT16 = DecimalWidth<int16_t>::max;
-	static constexpr uint8_t MAX_WIDTH_INT32 = DecimalWidth<int32_t>::max;
-	static constexpr uint8_t MAX_WIDTH_INT64 = DecimalWidth<int64_t>::max;
-	static constexpr uint8_t MAX_WIDTH_INT128 = DecimalWidth<hugeint_t>::max;
-	static constexpr uint8_t MAX_WIDTH_DECIMAL = MAX_WIDTH_INT128;
-
-public:
-	static string ToString(int16_t value, uint8_t width, uint8_t scale);
-	static string ToString(int32_t value, uint8_t width, uint8_t scale);
-	static string ToString(int64_t value, uint8_t width, uint8_t scale);
-	static string ToString(hugeint_t value, uint8_t width, uint8_t scale);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/hash.hpp b/src/duckdb/src/include/duckdb/common/types/hash.hpp
deleted file mode 100644
index b213f249e..000000000
--- a/src/duckdb/src/include/duckdb/common/types/hash.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hash.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-struct string_t;
-struct interval_t; // NOLINT
-
-// efficient hash function that maximizes the avalanche effect and minimizes
-// bias
-// see: https://nullprogram.com/blog/2018/07/31/
-
-inline hash_t MurmurHash64(uint64_t x) {
-	x ^= x >> 32;
-	x *= 0xd6e8feb86659fd93U;
-	x ^= x >> 32;
-	x *= 0xd6e8feb86659fd93U;
-	x ^= x >> 32;
-	return x;
-}
-
-inline hash_t MurmurHash32(uint32_t x) {
-	return MurmurHash64(x);
-}
-
-template <class T>
-hash_t Hash(T value) {
-	return MurmurHash32(static_cast<uint32_t>(value));
-}
-
-//! Combine two hashes by XORing them
-inline hash_t CombineHash(hash_t left, hash_t right) {
-	return left ^ right;
-}
-
-template <>
-DUCKDB_API hash_t Hash(uint64_t val);
-template <>
-DUCKDB_API hash_t Hash(int64_t val);
-template <>
-DUCKDB_API hash_t Hash(hugeint_t val);
-template <>
-DUCKDB_API hash_t Hash(uhugeint_t val);
-template <>
-DUCKDB_API hash_t Hash(float val);
-template <>
-DUCKDB_API hash_t Hash(double val);
-template <>
-DUCKDB_API hash_t Hash(const char *val);
-template <>
-DUCKDB_API hash_t Hash(char *val);
-template <>
-DUCKDB_API hash_t Hash(string_t val);
-template <>
-DUCKDB_API hash_t Hash(interval_t val);
-DUCKDB_API hash_t Hash(const char *val, size_t size);
-DUCKDB_API hash_t Hash(uint8_t *val, size_t size);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/hugeint.hpp b/src/duckdb/src/include/duckdb/common/types/hugeint.hpp
deleted file mode 100644
index 328c2ce15..000000000
--- a/src/duckdb/src/include/duckdb/common/types/hugeint.hpp
+++ /dev/null
@@ -1,229 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hugeint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/type_util.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-//! The Hugeint class contains static operations for the INT128 type
-class Hugeint {
-public:
-	constexpr static const char *HUGEINT_MINIMUM_STRING = "-170141183460469231731687303715884105728";
-
-	//! Convert a hugeint object to a string
-	static string ToString(hugeint_t input);
-
-	template <class T>
-	DUCKDB_API static bool TryCast(hugeint_t input, T &result);
-
-	template <class T>
-	static T Cast(hugeint_t input) {
-		T result = 0;
-		TryCast(input, result);
-		return result;
-	}
-
-	template <class T>
-	static bool TryConvert(T value, hugeint_t &result);
-
-	template <class T>
-	static hugeint_t Convert(T value) {
-		hugeint_t result;
-		if (!TryConvert(value, result)) { // LCOV_EXCL_START
-			throw OutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<hugeint_t>());
-		} // LCOV_EXCL_STOP
-		return result;
-	}
-
-	static bool TryNegate(hugeint_t input, hugeint_t &result);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static void NegateInPlace(hugeint_t &input) {
-		if (!TryNegate(input, input)) {
-			throw OutOfRangeException("Negation of HUGEINT is out of range!");
-		}
-	}
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static hugeint_t Negate(hugeint_t input) {
-		NegateInPlace<CHECK_OVERFLOW>(input);
-		return input;
-	}
-
-	static bool TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static hugeint_t Multiply(hugeint_t lhs, hugeint_t rhs) {
-		hugeint_t result;
-		if (!TryMultiply(lhs, rhs, result)) {
-			throw OutOfRangeException("Overflow in HUGEINT multiplication: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-		return result;
-	}
-
-	static bool TryDivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &result, hugeint_t &remainder);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static hugeint_t Divide(hugeint_t lhs, hugeint_t rhs) {
-		// No division by zero
-		if (rhs == 0) {
-			throw OutOfRangeException("Division of HUGEINT by zero!");
-		}
-
-		// division only has one reason to overflow: MINIMUM / -1
-		if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
-			throw OutOfRangeException("Overflow in HUGEINT division: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-		return Divide<false>(lhs, rhs);
-	}
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static hugeint_t Modulo(hugeint_t lhs, hugeint_t rhs) {
-		// No division by zero
-		if (rhs == 0) {
-			throw OutOfRangeException("Modulo of HUGEINT by zero: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-
-		// division only has one reason to overflow: MINIMUM / -1
-		if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
-			throw OutOfRangeException("Overflow in HUGEINT modulo: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-		return Modulo<false>(lhs, rhs);
-	}
-
-	static bool TryAddInPlace(hugeint_t &lhs, hugeint_t rhs);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static hugeint_t Add(hugeint_t lhs, hugeint_t rhs) {
-		if (!TryAddInPlace(lhs, rhs)) {
-			throw OutOfRangeException("Overflow in HUGEINT addition: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-		return lhs;
-	}
-
-	static bool TrySubtractInPlace(hugeint_t &lhs, hugeint_t rhs);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static hugeint_t Subtract(hugeint_t lhs, hugeint_t rhs) {
-		if (!TrySubtractInPlace(lhs, rhs)) {
-			throw OutOfRangeException("Underflow in HUGEINT addition: %s - %s", lhs.ToString(), rhs.ToString());
-		}
-		return lhs;
-	}
-
-	// DivMod -> returns the result of the division (lhs / rhs), and fills up the remainder
-	static hugeint_t DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder);
-	// DivMod but lhs MUST be positive, and rhs is a uint64_t
-	static hugeint_t DivModPositive(hugeint_t lhs, uint64_t rhs, uint64_t &remainder);
-
-	static int Sign(hugeint_t n);
-	static hugeint_t Abs(hugeint_t n);
-	// comparison operators
-	// note that everywhere here we intentionally use bitwise ops
-	// this is because they seem to be consistently much faster (benchmarked on a Macbook Pro)
-	static bool Equals(hugeint_t lhs, hugeint_t rhs) {
-		int lower_equals = lhs.lower == rhs.lower;
-		int upper_equals = lhs.upper == rhs.upper;
-		return lower_equals & upper_equals;
-	}
-
-	static bool NotEquals(hugeint_t lhs, hugeint_t rhs) {
-		int lower_not_equals = lhs.lower != rhs.lower;
-		int upper_not_equals = lhs.upper != rhs.upper;
-		return lower_not_equals | upper_not_equals;
-	}
-
-	static bool GreaterThan(hugeint_t lhs, hugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger = lhs.lower > rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger);
-	}
-
-	static bool GreaterThanEquals(hugeint_t lhs, hugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger_equals = lhs.lower >= rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger_equals);
-	}
-
-	static bool LessThan(hugeint_t lhs, hugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller = lhs.lower < rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller);
-	}
-
-	static bool LessThanEquals(hugeint_t lhs, hugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller_equals = lhs.lower <= rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller_equals);
-	}
-
-	static const hugeint_t POWERS_OF_TEN[40];
-};
-
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int8_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int16_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int32_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int64_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint8_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint16_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint32_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint64_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, hugeint_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uhugeint_t &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, float &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, double &result);
-template <>
-DUCKDB_API bool Hugeint::TryCast(hugeint_t input, long double &result);
-
-template <>
-bool Hugeint::TryConvert(int8_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(int16_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(int32_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(int64_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint8_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint16_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint32_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint64_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(float value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(double value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(long double value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(const char *value, hugeint_t &result);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp b/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp
deleted file mode 100644
index 284ee1a4b..000000000
--- a/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hyperloglog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bit_utils.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-enum class HLLStorageType : uint8_t {
-	HLL_V1 = 1, //! Redis HLL
-	HLL_V2 = 2, //! Our own implementation
-};
-
-class Serializer;
-class Deserializer;
-
-//! Algorithms from
-//! "New cardinality estimation algorithms for HyperLogLog sketches"
-//! Otmar Ertl, arXiv:1702.01284
-class HyperLogLog {
-public:
-	static constexpr idx_t P = 6;
-	static constexpr idx_t Q = 64 - P;
-	static constexpr idx_t M = 1 << P;
-	static constexpr double ALPHA = 0.721347520444481703680; // 1 / (2 log(2))
-
-public:
-	HyperLogLog() {
-		memset(k, 0, sizeof(k));
-	}
-
-	//! Algorithm 1
-	inline void InsertElement(hash_t h) {
-		const auto i = h & ((1 << P) - 1);
-		h >>= P;
-		h |= hash_t(1) << Q;
-		const uint8_t z = UnsafeNumericCast<uint8_t>(CountZeros<hash_t>::Trailing(h) + 1);
-		Update(i, z);
-	}
-
-	inline void Update(const idx_t &i, const uint8_t &z) {
-		k[i] = MaxValue<uint8_t>(k[i], z);
-	}
-
-	inline uint8_t GetRegister(const idx_t &i) const {
-		return k[i];
-	}
-
-	idx_t Count() const;
-
-	//! Algorithm 2
-	void Merge(const HyperLogLog &other);
-
-public:
-	//! Add data to this HLL
-	void Update(Vector &input, Vector &hashes, idx_t count);
-	//! Get copy of the HLL
-	unique_ptr<HyperLogLog> Copy() const;
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<HyperLogLog> Deserialize(Deserializer &deserializer);
-
-	//! Algorithm 4
-	void ExtractCounts(uint32_t *c) const;
-	//! Algorithm 6
-	static int64_t EstimateCardinality(uint32_t *c);
-
-private:
-	uint8_t k[M];
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/interval.hpp b/src/duckdb/src/include/duckdb/common/types/interval.hpp
deleted file mode 100644
index 825000d57..000000000
--- a/src/duckdb/src/include/duckdb/common/types/interval.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/interval.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-struct dtime_t;     // NOLINT: literal casing
-struct date_t;      // NOLINT: literal casing
-struct dtime_tz_t;  // NOLINT: literal casing
-struct timestamp_t; // NOLINT: literal casing
-
-class Serializer;
-class Deserializer;
-
-struct interval_t { // NOLINT
-	int32_t months;
-	int32_t days;
-	int64_t micros;
-
-	inline void Normalize(int64_t &months, int64_t &days, int64_t &micros) const;
-
-	// Normalize to interval bounds.
-	inline static void Borrow(const int64_t msf, int64_t &lsf, int32_t &f, const int64_t scale);
-	inline interval_t Normalize() const;
-
-	inline bool operator==(const interval_t &right) const {
-		//	Quick equality check
-		const auto &left = *this;
-		if (left.months == right.months && left.days == right.days && left.micros == right.micros) {
-			return true;
-		}
-
-		int64_t lmonths, ldays, lmicros;
-		int64_t rmonths, rdays, rmicros;
-		left.Normalize(lmonths, ldays, lmicros);
-		right.Normalize(rmonths, rdays, rmicros);
-
-		return lmonths == rmonths && ldays == rdays && lmicros == rmicros;
-	}
-	inline bool operator!=(const interval_t &right) const {
-		return !(*this == right);
-	}
-
-	inline bool operator>(const interval_t &right) const {
-		const auto &left = *this;
-		int64_t lmonths, ldays, lmicros;
-		int64_t rmonths, rdays, rmicros;
-		left.Normalize(lmonths, ldays, lmicros);
-		right.Normalize(rmonths, rdays, rmicros);
-
-		if (lmonths > rmonths) {
-			return true;
-		} else if (lmonths < rmonths) {
-			return false;
-		}
-		if (ldays > rdays) {
-			return true;
-		} else if (ldays < rdays) {
-			return false;
-		}
-		return lmicros > rmicros;
-	}
-
-	inline bool operator<(const interval_t &right) const {
-		return right > *this;
-	}
-
-	inline bool operator<=(const interval_t &right) const {
-		return !(*this > right);
-	}
-
-	inline bool operator>=(const interval_t &right) const {
-		return !(*this < right);
-	}
-
-	// Serialization
-	void Serialize(Serializer &serializer) const;
-	static interval_t Deserialize(Deserializer &source);
-};
-
-//! The Interval class is a static class that holds helper functions for the Interval
-//! type.
-class Interval {
-public:
-	static constexpr const int32_t MONTHS_PER_MILLENIUM = 12000;
-	static constexpr const int32_t MONTHS_PER_CENTURY = 1200;
-	static constexpr const int32_t MONTHS_PER_DECADE = 120;
-	static constexpr const int32_t MONTHS_PER_YEAR = 12;
-	static constexpr const int32_t MONTHS_PER_QUARTER = 3;
-	static constexpr const int32_t DAYS_PER_WEEK = 7;
-	//! only used for interval comparison/ordering purposes, in which case a month counts as 30 days
-	static constexpr const int64_t DAYS_PER_MONTH = 30;
-	static constexpr const int64_t DAYS_PER_YEAR = 365;
-	static constexpr const int64_t MSECS_PER_SEC = 1000;
-	static constexpr const int32_t SECS_PER_MINUTE = 60;
-	static constexpr const int32_t MINS_PER_HOUR = 60;
-	static constexpr const int32_t HOURS_PER_DAY = 24;
-	static constexpr const int32_t SECS_PER_HOUR = SECS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int32_t SECS_PER_DAY = SECS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int32_t SECS_PER_WEEK = SECS_PER_DAY * DAYS_PER_WEEK;
-
-	static constexpr const int64_t MICROS_PER_MSEC = 1000;
-	static constexpr const int64_t MICROS_PER_SEC = MICROS_PER_MSEC * MSECS_PER_SEC;
-	static constexpr const int64_t MICROS_PER_MINUTE = MICROS_PER_SEC * SECS_PER_MINUTE;
-	static constexpr const int64_t MICROS_PER_HOUR = MICROS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int64_t MICROS_PER_DAY = MICROS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int64_t MICROS_PER_WEEK = MICROS_PER_DAY * DAYS_PER_WEEK;
-	static constexpr const int64_t MICROS_PER_MONTH = MICROS_PER_DAY * DAYS_PER_MONTH;
-
-	static constexpr const int64_t NANOS_PER_MICRO = 1000;
-	static constexpr const int64_t NANOS_PER_MSEC = NANOS_PER_MICRO * MICROS_PER_MSEC;
-	static constexpr const int64_t NANOS_PER_SEC = NANOS_PER_MSEC * MSECS_PER_SEC;
-	static constexpr const int64_t NANOS_PER_MINUTE = NANOS_PER_SEC * SECS_PER_MINUTE;
-	static constexpr const int64_t NANOS_PER_HOUR = NANOS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int64_t NANOS_PER_DAY = NANOS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int64_t NANOS_PER_WEEK = NANOS_PER_DAY * DAYS_PER_WEEK;
-
-public:
-	//! Convert a string to an interval object
-	static bool FromString(const string &str, interval_t &result);
-	//! Convert a string to an interval object
-	static bool FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict);
-	//! Convert an interval object to a string
-	static string ToString(const interval_t &val);
-
-	//! Convert milliseconds to a normalised interval
-	DUCKDB_API static interval_t FromMicro(int64_t micros);
-
-	//! Get Interval in milliseconds
-	static int64_t GetMilli(const interval_t &val);
-
-	//! Get Interval in microseconds
-	static int64_t GetMicro(const interval_t &val);
-
-	//! Get Interval in Nanoseconds
-	static int64_t GetNanoseconds(const interval_t &val);
-
-	//! Returns the age between two timestamps (including 30 day months)
-	static interval_t GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2);
-
-	//! Returns the exact difference between two timestamps (days and seconds)
-	static interval_t GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2);
-
-	//! Returns the inverted interval
-	static interval_t Invert(interval_t interval);
-
-	//! Add an interval to a date
-	static date_t Add(date_t left, interval_t right);
-	//! Add an interval to a timestamp
-	static timestamp_t Add(timestamp_t left, interval_t right);
-	//! Add an interval to a time. In case the time overflows or underflows, modify the date by the overflow.
-	//! For example if we go from 23:00 to 02:00, we add a day to the date
-	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
-	static dtime_tz_t Add(dtime_tz_t left, interval_t right, date_t &date);
-
-	//! Comparison operators
-	inline static bool Equals(const interval_t &left, const interval_t &right) {
-		return left == right;
-	}
-	inline static bool GreaterThan(const interval_t &left, const interval_t &right) {
-		return left > right;
-	}
-};
-
-void interval_t::Normalize(int64_t &months, int64_t &days, int64_t &micros) const {
-	auto &input = *this;
-
-	//  Carry left
-	micros = input.micros;
-	int64_t carry_days = micros / Interval::MICROS_PER_DAY;
-	micros -= carry_days * Interval::MICROS_PER_DAY;
-
-	days = input.days;
-	days += carry_days;
-	int64_t carry_months = days / Interval::DAYS_PER_MONTH;
-	days -= carry_months * Interval::DAYS_PER_MONTH;
-
-	months = input.months;
-	months += carry_months;
-}
-
-void interval_t::Borrow(const int64_t msf, int64_t &lsf, int32_t &f, const int64_t scale) {
-	if (msf > NumericLimits<int32_t>::Maximum()) {
-		f = NumericLimits<int32_t>::Maximum();
-		lsf += (msf - f) * scale;
-	} else if (msf < NumericLimits<int32_t>::Minimum()) {
-		f = NumericLimits<int32_t>::Minimum();
-		lsf += (msf - f) * scale;
-	} else {
-		f = UnsafeNumericCast<int32_t>(msf);
-	}
-}
-
-interval_t interval_t::Normalize() const {
-	interval_t result;
-
-	int64_t mm;
-	int64_t dd;
-	Normalize(mm, dd, result.micros);
-
-	//  Borrow right on overflow
-	Borrow(mm, dd, result.months, Interval::DAYS_PER_MONTH);
-	Borrow(dd, result.micros, result.days, Interval::MICROS_PER_DAY);
-
-	return result;
-}
-
-} // namespace duckdb
-
-namespace std {
-template <>
-struct hash<duckdb::interval_t> {
-	size_t operator()(const duckdb::interval_t &val) const {
-		int64_t months, days, micros;
-		val.Normalize(months, days, micros);
-		using std::hash;
-
-		return hash<int32_t> {}(duckdb::UnsafeNumericCast<int32_t>(days)) ^
-		       hash<int32_t> {}(duckdb::UnsafeNumericCast<int32_t>(months)) ^ hash<int64_t> {}(micros);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/types/list_segment.hpp b/src/duckdb/src/include/duckdb/common/types/list_segment.hpp
deleted file mode 100644
index 85b5d075b..000000000
--- a/src/duckdb/src/include/duckdb/common/types/list_segment.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/list_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-#pragma once
-
-namespace duckdb {
-
-struct ListSegment {
-	constexpr const static uint16_t INITIAL_CAPACITY = 4;
-
-	uint16_t count;
-	uint16_t capacity;
-	ListSegment *next;
-};
-struct LinkedList {
-	LinkedList() : total_capacity(0), first_segment(nullptr), last_segment(nullptr) {};
-	LinkedList(idx_t total_capacity_p, ListSegment *first_segment_p, ListSegment *last_segment_p)
-	    : total_capacity(total_capacity_p), first_segment(first_segment_p), last_segment(last_segment_p) {
-	}
-
-	idx_t total_capacity;
-	ListSegment *first_segment;
-	ListSegment *last_segment;
-};
-
-// forward declarations
-struct ListSegmentFunctions;
-typedef ListSegment *(*create_segment_t)(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                         uint16_t capacity);
-typedef void (*write_data_to_segment_t)(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                        ListSegment *segment, RecursiveUnifiedVectorFormat &input_data,
-                                        idx_t &entry_idx);
-typedef void (*read_data_from_segment_t)(const ListSegmentFunctions &functions, const ListSegment *segment,
-                                         Vector &result, idx_t &total_count);
-
-struct ListSegmentFunctions {
-	create_segment_t create_segment;
-	write_data_to_segment_t write_data;
-	read_data_from_segment_t read_data;
-	uint16_t initial_capacity = ListSegment::INITIAL_CAPACITY;
-
-	vector<ListSegmentFunctions> child_functions;
-
-	void AppendRow(ArenaAllocator &allocator, LinkedList &linked_list, RecursiveUnifiedVectorFormat &input_data,
-	               idx_t &entry_idx) const;
-	void BuildListVector(const LinkedList &linked_list, Vector &result, idx_t total_count) const;
-};
-
-void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType &type);
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/null_value.hpp b/src/duckdb/src/include/duckdb/common/types/null_value.hpp
deleted file mode 100644
index ed96b721a..000000000
--- a/src/duckdb/src/include/duckdb/common/types/null_value.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/null_value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-
-#include <limits>
-#include <cstring>
-#include <cmath>
-
-namespace duckdb {
-
-//! Placeholder to insert in Vectors or to use for hashing NULLs
-template <class T>
-inline T NullValue() {
-	return std::numeric_limits<T>::min();
-}
-
-constexpr const char str_nil[2] = {'\200', '\0'};
-
-template <>
-inline const char *NullValue() {
-	D_ASSERT(str_nil[0] == '\200' && str_nil[1] == '\0');
-	return str_nil;
-}
-
-template <>
-inline string_t NullValue() {
-	return string_t(NullValue<const char *>());
-}
-
-template <>
-inline char *NullValue() {
-	return (char *)NullValue<const char *>(); // NOLINT
-}
-
-template <>
-inline string NullValue() {
-	return string(NullValue<const char *>());
-}
-
-template <>
-inline interval_t NullValue() {
-	interval_t null_value;
-	null_value.days = NullValue<int32_t>();
-	null_value.months = NullValue<int32_t>();
-	null_value.micros = NullValue<int64_t>();
-	return null_value;
-}
-
-template <>
-inline hugeint_t NullValue() {
-	hugeint_t min;
-	min.lower = 0;
-	min.upper = std::numeric_limits<int64_t>::min();
-	return min;
-}
-
-template <>
-inline float NullValue() {
-	return NAN;
-}
-
-template <>
-inline double NullValue() {
-	return NAN;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp b/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp
deleted file mode 100644
index 878b1bfa0..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/partitioned_tuple_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/fixed_size_map.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/perfect_map_set.hpp"
-#include "duckdb/common/types/row/tuple_data_allocator.hpp"
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-
-namespace duckdb {
-
-//! Local state for parallel partitioning
-struct PartitionedTupleDataAppendState {
-public:
-	PartitionedTupleDataAppendState() : partition_indices(LogicalType::UBIGINT) {
-	}
-
-public:
-	Vector partition_indices;
-	SelectionVector partition_sel;
-	SelectionVector reverse_partition_sel;
-
-	static constexpr idx_t MAP_THRESHOLD = 256;
-	perfect_map_t<list_entry_t> partition_entries;
-	fixed_size_map_t<list_entry_t> fixed_partition_entries;
-
-	unsafe_vector<unsafe_unique_ptr<TupleDataPinState>> partition_pin_states;
-	TupleDataChunkState chunk_state;
-
-public:
-	template <bool fixed>
-	typename std::conditional<fixed, fixed_size_map_t<list_entry_t>, perfect_map_t<list_entry_t>>::type &GetMap() {
-		throw NotImplementedException("PartitionedTupleDataAppendState::GetMap for boolean value");
-	}
-
-	optional_idx GetPartitionIndexIfSinglePartition(const bool use_fixed_size_map) {
-		optional_idx result;
-		if (use_fixed_size_map) {
-			if (fixed_partition_entries.size() == 1) {
-				result = fixed_partition_entries.begin().GetKey();
-			}
-		} else {
-			if (partition_entries.size() == 1) {
-				result = partition_entries.begin()->first;
-			}
-		}
-		return result;
-	}
-};
-
-template <>
-inline perfect_map_t<list_entry_t> &PartitionedTupleDataAppendState::GetMap<false>() {
-	return partition_entries;
-}
-
-template <>
-inline fixed_size_map_t<list_entry_t> &PartitionedTupleDataAppendState::GetMap<true>() {
-	return fixed_partition_entries;
-}
-
-enum class PartitionedTupleDataType : uint8_t {
-	INVALID,
-	//! Radix partitioning on a hash column
-	RADIX
-};
-
-//! Shared allocators for parallel partitioning
-struct PartitionTupleDataAllocators {
-	mutex lock;
-	vector<shared_ptr<TupleDataAllocator>> allocators;
-};
-
-//! PartitionedTupleData represents partitioned row data, which serves as an interface for different types of
-//! partitioning, e.g., radix, hive
-class PartitionedTupleData {
-public:
-	virtual ~PartitionedTupleData();
-
-public:
-	//! Get the layout of this PartitionedTupleData
-	const TupleDataLayout &GetLayout() const;
-	//! Get the partitioning type of this PartitionedTupleData
-	PartitionedTupleDataType GetType() const;
-	//! Initializes a local state for parallel partitioning that can be merged into this PartitionedTupleData
-	void InitializeAppendState(PartitionedTupleDataAppendState &state,
-	                           TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
-	//! Appends a DataChunk to this PartitionedTupleData
-	void Append(PartitionedTupleDataAppendState &state, DataChunk &input,
-	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	            const idx_t append_count = DConstants::INVALID_INDEX);
-	//! Appends a DataChunk to this PartitionedTupleData
-	//! - ToUnifiedFormat has already been called
-	void AppendUnified(PartitionedTupleDataAppendState &state, DataChunk &input,
-	                   const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	                   const idx_t append_count = DConstants::INVALID_INDEX);
-	//! Appends rows to this PartitionedTupleData
-	void Append(PartitionedTupleDataAppendState &state, TupleDataChunkState &input, const idx_t count);
-	//! Flushes any remaining data in the append state into this PartitionedTupleData
-	void FlushAppendState(PartitionedTupleDataAppendState &state);
-	//! Combine another PartitionedTupleData into this PartitionedTupleData
-	void Combine(PartitionedTupleData &other);
-	//! Resets this PartitionedTupleData
-	void Reset();
-	//! Repartition this PartitionedTupleData into the new PartitionedTupleData
-	void Repartition(PartitionedTupleData &new_partitioned_data);
-	//! Unpins the data
-	void Unpin();
-	//! Get the partitions in this PartitionedTupleData
-	unsafe_vector<unique_ptr<TupleDataCollection>> &GetPartitions();
-	//! Get the data of this PartitionedTupleData as a single unpartitioned TupleDataCollection
-	unique_ptr<TupleDataCollection> GetUnpartitioned();
-	//! Get the count of this PartitionedTupleData
-	idx_t Count() const;
-	//! Get the size (in bytes) of this PartitionedTupleData
-	idx_t SizeInBytes() const;
-	//! Get the number of partitions of this PartitionedTupleData
-	idx_t PartitionCount() const;
-	//! Get the count and size of the largest partition
-	void GetSizesAndCounts(vector<idx_t> &partition_sizes, vector<idx_t> &partition_counts) const;
-	//! Converts this PartitionedTupleData to a string representation
-	string ToString();
-	//! Prints the string representation of this PartitionedTupleData
-	void Print();
-
-protected:
-	//===--------------------------------------------------------------------===//
-	// Partitioning type implementation interface
-	//===--------------------------------------------------------------------===//
-	//! Initialize a PartitionedTupleDataAppendState for this type of partitioning (optional)
-	virtual void InitializeAppendStateInternal(PartitionedTupleDataAppendState &state,
-	                                           TupleDataPinProperties properties) const {
-	}
-	//! Compute the partition indices for this type of partitioning for the input DataChunk and store them in the
-	//! `partition_data` of the local state. If this type creates partitions on the fly (for, e.g., hive), this
-	//! function is also in charge of creating new partitions and mapping the input data to a partition index
-	virtual void ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input,
-	                                     const SelectionVector &append_sel, const idx_t append_count) {
-		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedTupleData");
-	}
-	//! Compute partition indices from rows (similar to function above)
-	virtual void ComputePartitionIndices(Vector &row_locations, idx_t append_count, Vector &partition_indices) const {
-		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedTupleData");
-	}
-	//! Maximum partition index (optional)
-	virtual idx_t MaxPartitionIndex() const {
-		return DConstants::INVALID_INDEX;
-	}
-
-	//! Finalize states while repartitioning - useful for unpinning blocks that are no longer needed (optional)
-	virtual void RepartitionFinalizeStates(PartitionedTupleData &old_partitioned_data,
-	                                       PartitionedTupleData &new_partitioned_data,
-	                                       PartitionedTupleDataAppendState &state, idx_t finished_partition_idx) const {
-	}
-
-protected:
-	//! PartitionedTupleData can only be instantiated by derived classes
-	PartitionedTupleData(PartitionedTupleDataType type, BufferManager &buffer_manager, const TupleDataLayout &layout);
-	PartitionedTupleData(const PartitionedTupleData &other);
-
-	//! Create a new shared allocator
-	void CreateAllocator();
-	//! Whether to use fixed size map or regular map
-	bool UseFixedSizeMap() const;
-	//! Builds a selection vector in the Append state for the partitions
-	//! - returns true if everything belongs to the same partition - stores partition index in single_partition_idx
-	void BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
-	                       const idx_t append_count) const;
-	template <bool fixed>
-	static void BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
-	                              const idx_t append_count);
-	//! Builds out the buffer space in the partitions
-	void BuildBufferSpace(PartitionedTupleDataAppendState &state);
-	template <bool fixed>
-	void BuildBufferSpace(PartitionedTupleDataAppendState &state);
-	//! Create a collection for a specific a partition
-	unique_ptr<TupleDataCollection> CreatePartitionCollection(idx_t partition_index) const {
-		if (allocators) {
-			return make_uniq<TupleDataCollection>(allocators->allocators[partition_index]);
-		} else {
-			return make_uniq<TupleDataCollection>(buffer_manager, layout);
-		}
-	}
-	//! Verify count/data size of this PartitionedTupleData
-	void Verify() const;
-
-protected:
-	PartitionedTupleDataType type;
-	BufferManager &buffer_manager;
-	const TupleDataLayout layout;
-	idx_t count;
-	idx_t data_size;
-
-	mutex lock;
-	shared_ptr<PartitionTupleDataAllocators> allocators;
-	unsafe_vector<unique_ptr<TupleDataCollection>> partitions;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp b/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp
deleted file mode 100644
index d49abf2c5..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/row_data_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-
-namespace duckdb {
-
-struct RowDataBlock {
-public:
-	RowDataBlock(MemoryTag tag, BufferManager &buffer_manager, idx_t capacity, idx_t entry_size)
-	    : capacity(capacity), entry_size(entry_size), count(0), byte_offset(0) {
-		auto size = MaxValue<idx_t>(buffer_manager.GetBlockSize(), capacity * entry_size);
-		auto buffer_handle = buffer_manager.Allocate(tag, size, false);
-		block = buffer_handle.GetBlockHandle();
-		D_ASSERT(BufferManager::GetAllocSize(size) == block->GetMemoryUsage());
-	}
-
-	explicit RowDataBlock(idx_t entry_size) : entry_size(entry_size) {
-	}
-	//! The buffer block handle
-	shared_ptr<BlockHandle> block;
-	//! Capacity (number of entries) and entry size that fit in this block
-	idx_t capacity;
-	const idx_t entry_size;
-	//! Number of entries currently in this block
-	idx_t count;
-	//! Write offset (if variable size entries)
-	idx_t byte_offset;
-
-private:
-	//! Implicit copying is not allowed
-	RowDataBlock(const RowDataBlock &) = delete;
-
-public:
-	unique_ptr<RowDataBlock> Copy() {
-		auto result = make_uniq<RowDataBlock>(entry_size);
-		result->block = block;
-		result->capacity = capacity;
-		result->count = count;
-		result->byte_offset = byte_offset;
-		return result;
-	}
-};
-
-struct BlockAppendEntry {
-	BlockAppendEntry(data_ptr_t baseptr, idx_t count) : baseptr(baseptr), count(count) {
-	}
-	data_ptr_t baseptr;
-	idx_t count;
-};
-
-class RowDataCollection {
-public:
-	RowDataCollection(BufferManager &buffer_manager, idx_t block_capacity, idx_t entry_size, bool keep_pinned = false);
-
-	unique_ptr<RowDataCollection> CloneEmpty(bool keep_pinned = false) const {
-		return make_uniq<RowDataCollection>(buffer_manager, block_capacity, entry_size, keep_pinned);
-	}
-
-	//! BufferManager
-	BufferManager &buffer_manager;
-	//! The total number of stored entries
-	idx_t count;
-	//! The number of entries per block
-	idx_t block_capacity;
-	//! Size of entries in the blocks
-	idx_t entry_size;
-	//! The blocks holding the main data
-	vector<unique_ptr<RowDataBlock>> blocks;
-	//! The blocks that this collection currently has pinned
-	vector<BufferHandle> pinned_blocks;
-	//! Whether the blocks should stay pinned (necessary for e.g. a heap)
-	const bool keep_pinned;
-
-public:
-	idx_t AppendToBlock(RowDataBlock &block, BufferHandle &handle, vector<BlockAppendEntry> &append_entries,
-	                    idx_t remaining, idx_t entry_sizes[]);
-	RowDataBlock &CreateBlock();
-	vector<BufferHandle> Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[],
-	                           const SelectionVector *sel = FlatVector::IncrementalSelectionVector());
-
-	void Merge(RowDataCollection &other);
-
-	void Clear() {
-		blocks.clear();
-		pinned_blocks.clear();
-		count = 0;
-	}
-
-	//! The size (in bytes) of this RowDataCollection
-	idx_t SizeInBytes() const {
-		VerifyBlockSizes();
-		idx_t size = 0;
-		for (auto &block : blocks) {
-			size += block->block->GetMemoryUsage();
-		}
-		return size;
-	}
-
-	//! Verifies that the block sizes are correct (Debug only)
-	void VerifyBlockSizes() const {
-#ifdef DEBUG
-		for (auto &block : blocks) {
-			D_ASSERT(block->block->GetMemoryUsage() == BufferManager::GetAllocSize(block->capacity * entry_size));
-		}
-#endif
-	}
-
-	static inline idx_t EntriesPerBlock(const idx_t width, const idx_t block_size) {
-		return block_size / width;
-	}
-
-private:
-	mutex rdc_lock;
-
-	//! Copying is not allowed
-	RowDataCollection(const RowDataCollection &) = delete;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp b/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp
deleted file mode 100644
index b805c0955..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/row_data_collection_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-
-namespace duckdb {
-
-class BufferHandle;
-class RowDataCollection;
-struct RowDataBlock;
-class DataChunk;
-
-//! Used to scan the data into DataChunks after sorting
-struct RowDataCollectionScanner {
-public:
-	using Types = vector<LogicalType>;
-
-	struct ScanState {
-		explicit ScanState(const RowDataCollectionScanner &scanner_p) : scanner(scanner_p), block_idx(0), entry_idx(0) {
-		}
-
-		void PinData();
-
-		//! The data layout
-		const RowDataCollectionScanner &scanner;
-
-		idx_t block_idx;
-		idx_t entry_idx;
-
-		BufferHandle data_handle;
-		BufferHandle heap_handle;
-
-		// We must pin ALL blocks we are going to gather from
-		vector<BufferHandle> pinned_blocks;
-	};
-
-	//! Ensure that heap blocks correspond to row blocks
-	static void AlignHeapBlocks(RowDataCollection &dst_block_collection, RowDataCollection &dst_string_heap,
-	                            RowDataCollection &src_block_collection, RowDataCollection &src_string_heap,
-	                            const RowLayout &layout);
-
-	RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external,
-	                         bool flush = true);
-
-	//	Single block scan
-	RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external,
-	                         idx_t block_idx, bool flush);
-
-	//! The type layout of the payload
-	inline const vector<LogicalType> &GetTypes() const {
-		return layout.GetTypes();
-	}
-
-	//! The number of rows in the collection
-	inline idx_t Count() const {
-		return total_count;
-	}
-
-	//! The number of rows scanned so far
-	inline idx_t Scanned() const {
-		return total_scanned;
-	}
-
-	//! The number of remaining rows
-	inline idx_t Remaining() const {
-		return total_count - total_scanned;
-	}
-
-	//! The number of remaining rows
-	inline idx_t BlockIndex() const {
-		return read_state.block_idx;
-	}
-
-	//! Swizzle the blocks for external scanning
-	//! Swizzling is all or nothing, so if we have scanned previously,
-	//! we need to re-swizzle.
-	void ReSwizzle();
-
-	void SwizzleBlock(idx_t block_idx);
-
-	//! Scans the next data chunk from the sorted data
-	void Scan(DataChunk &chunk);
-
-	//! Resets to the start and updates the flush flag
-	void Reset(bool flush = true);
-
-private:
-	//! The row data being scanned
-	RowDataCollection &rows;
-	//! The row heap being scanned
-	RowDataCollection &heap;
-	//! The data layout
-	const RowLayout layout;
-	//! Read state
-	ScanState read_state;
-	//! The total count of sorted_data
-	idx_t total_count;
-	//! The number of rows scanned so far
-	idx_t total_scanned;
-	//! Addresses used to gather from the sorted data
-	Vector addresses = Vector(LogicalType::POINTER);
-	//! Whether the blocks can be flushed to disk
-	const bool external;
-	//! Whether to flush the blocks after scanning
-	bool flush;
-	//! Whether we are unswizzling the blocks
-	const bool unswizzling;
-
-	//! Swizzle a single block
-	void SwizzleBlockInternal(RowDataBlock &data_block, RowDataBlock &heap_block);
-	//! Checks that the newest block is valid
-	void ValidateUnscannedBlock() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/row_layout.hpp b/src/duckdb/src/include/duckdb/common/types/row/row_layout.hpp
deleted file mode 100644
index 702cba4d2..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/row_layout.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/row_layout.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class RowLayout {
-public:
-	friend class TupleDataLayout;
-	using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-	//! Creates an empty RowLayout
-	RowLayout();
-
-public:
-	//! Initializes the RowLayout with the specified types to an empty RowLayout
-	void Initialize(vector<LogicalType> types, bool align = true);
-	//! Returns the number of data columns
-	inline idx_t ColumnCount() const {
-		return types.size();
-	}
-	//! Returns a list of the column types for this data chunk
-	inline const vector<LogicalType> &GetTypes() const {
-		return types;
-	}
-	//! Returns the total width required for each row, including padding
-	inline idx_t GetRowWidth() const {
-		return row_width;
-	}
-	//! Returns the offset to the start of the data
-	inline idx_t GetDataOffset() const {
-		return flag_width;
-	}
-	//! Returns the total width required for the data, including padding
-	inline idx_t GetDataWidth() const {
-		return data_width;
-	}
-	//! Returns the offset to the start of the aggregates
-	inline idx_t GetAggrOffset() const {
-		return flag_width + data_width;
-	}
-	//! Returns the column offsets into each row
-	inline const vector<idx_t> &GetOffsets() const {
-		return offsets;
-	}
-	//! Returns whether all columns in this layout are constant size
-	inline bool AllConstant() const {
-		return all_constant;
-	}
-	inline idx_t GetHeapOffset() const {
-		return heap_pointer_offset;
-	}
-
-private:
-	//! The types of the data columns
-	vector<LogicalType> types;
-	//! The width of the validity header
-	idx_t flag_width;
-	//! The width of the data portion
-	idx_t data_width;
-	//! The width of the entire row
-	idx_t row_width;
-	//! The offsets to the columns and aggregate data in each row
-	vector<idx_t> offsets;
-	//! Whether all columns in this layout are constant size
-	bool all_constant;
-	//! Offset to the pointer to the heap for each row
-	idx_t heap_pointer_offset;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_allocator.hpp b/src/duckdb/src/include/duckdb/common/types/row/tuple_data_allocator.hpp
deleted file mode 100644
index b68d3606b..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_allocator.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/tuple_data_allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/common/types/row/tuple_data_states.hpp"
-
-namespace duckdb {
-
-struct TupleDataSegment;
-struct TupleDataChunk;
-struct TupleDataChunkPart;
-
-struct TupleDataBlock {
-public:
-	TupleDataBlock(BufferManager &buffer_manager, idx_t capacity_p);
-
-	//! Disable copy constructors
-	TupleDataBlock(const TupleDataBlock &other) = delete;
-	TupleDataBlock &operator=(const TupleDataBlock &) = delete;
-
-	//! Enable move constructors
-	TupleDataBlock(TupleDataBlock &&other) noexcept;
-	TupleDataBlock &operator=(TupleDataBlock &&) noexcept;
-
-public:
-	//! Remaining capacity (in bytes)
-	idx_t RemainingCapacity() const {
-		D_ASSERT(size <= capacity);
-		return capacity - size;
-	}
-
-	//! Remaining capacity (in rows)
-	idx_t RemainingCapacity(idx_t row_width) const {
-		return RemainingCapacity() / row_width;
-	}
-
-public:
-	//! The underlying row block
-	shared_ptr<BlockHandle> handle;
-	//! Capacity (in bytes)
-	idx_t capacity;
-	//! Occupied size (in bytes)
-	idx_t size;
-};
-
-class TupleDataAllocator {
-public:
-	TupleDataAllocator(BufferManager &buffer_manager, const TupleDataLayout &layout);
-	TupleDataAllocator(TupleDataAllocator &allocator);
-
-	~TupleDataAllocator();
-
-	//! Get the buffer manager
-	BufferManager &GetBufferManager();
-	//! Get the buffer allocator
-	Allocator &GetAllocator();
-	//! Get the layout
-	const TupleDataLayout &GetLayout() const;
-	//! Number of row blocks
-	idx_t RowBlockCount() const;
-	//! Number of heap blocks
-	idx_t HeapBlockCount() const;
-	//! Sets the partition index of this tuple data allocator
-	void SetPartitionIndex(idx_t index);
-
-public:
-	//! Builds out the chunks for next append, given the metadata in the append state
-	void Build(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-	           const idx_t append_offset, const idx_t append_count);
-	//! Initializes a chunk, making its pointers valid
-	void InitializeChunkState(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-	                          idx_t chunk_idx, bool init_heap);
-	static void RecomputeHeapPointers(Vector &old_heap_ptrs, const SelectionVector &old_heap_sel,
-	                                  const data_ptr_t row_locations[], Vector &new_heap_ptrs, const idx_t offset,
-	                                  const idx_t count, const TupleDataLayout &layout, const idx_t base_col_offset);
-	//! Releases or stores any handles in the management state that are no longer required
-	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment, TupleDataChunk &chunk,
-	                           bool release_heap);
-	//! Releases or stores ALL handles in the management state
-	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment);
-	//! Sets 'can_destroy' to true for all blocks so they aren't added to the eviction queue
-	void SetDestroyBufferUponUnpin();
-
-private:
-	//! Builds out a single part (grabs the lock)
-	TupleDataChunkPart BuildChunkPart(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-	                                  const idx_t append_offset, const idx_t append_count, TupleDataChunk &chunk);
-	//! Internal function for InitializeChunkState
-	void InitializeChunkStateInternal(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, idx_t offset,
-	                                  bool recompute, bool init_heap_pointers, bool init_heap_sizes,
-	                                  unsafe_vector<reference<TupleDataChunkPart>> &parts);
-	//! Internal function for ReleaseOrStoreHandles
-	static void ReleaseOrStoreHandlesInternal(TupleDataSegment &segment,
-	                                          unsafe_vector<BufferHandle> &pinned_row_handles,
-	                                          perfect_map_t<BufferHandle> &handles, const perfect_set_t &block_ids,
-	                                          unsafe_vector<TupleDataBlock> &blocks, TupleDataPinProperties properties);
-	//! Pins the given row block
-	BufferHandle &PinRowBlock(TupleDataPinState &state, const TupleDataChunkPart &part);
-	//! Pins the given heap block
-	BufferHandle &PinHeapBlock(TupleDataPinState &state, const TupleDataChunkPart &part);
-	//! Gets the pointer to the rows for the given chunk part
-	data_ptr_t GetRowPointer(TupleDataPinState &state, const TupleDataChunkPart &part);
-	//! Gets the base pointer to the heap for the given chunk part
-	data_ptr_t GetBaseHeapPointer(TupleDataPinState &state, const TupleDataChunkPart &part);
-
-private:
-	//! The buffer manager
-	BufferManager &buffer_manager;
-	//! The layout of the data
-	const TupleDataLayout layout;
-	//! Partition index (optional, if partitioned)
-	optional_idx partition_index;
-	//! Blocks storing the fixed-size rows
-	unsafe_vector<TupleDataBlock> row_blocks;
-	//! Blocks storing the variable-size data of the fixed-size rows (e.g., string, list)
-	unsafe_vector<TupleDataBlock> heap_blocks;
-
-	//! Re-usable arrays used while building buffer space
-	unsafe_vector<reference<TupleDataChunkPart>> chunk_parts;
-	unsafe_vector<pair<idx_t, idx_t>> chunk_part_indices;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp b/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp
deleted file mode 100644
index 71b700922..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/tuple_data_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/common/types/row/tuple_data_segment.hpp"
-#include "duckdb/common/types/row/tuple_data_states.hpp"
-
-namespace duckdb {
-
-class TupleDataAllocator;
-struct TupleDataScatterFunction;
-struct TupleDataGatherFunction;
-struct RowOperationsState;
-
-typedef void (*tuple_data_scatter_function_t)(const Vector &source, const TupleDataVectorFormat &source_format,
-                                              const SelectionVector &append_sel, const idx_t append_count,
-                                              const TupleDataLayout &layout, const Vector &row_locations,
-                                              Vector &heap_locations, const idx_t col_idx,
-                                              const UnifiedVectorFormat &list_format,
-                                              const vector<TupleDataScatterFunction> &child_functions);
-
-struct TupleDataScatterFunction {
-	tuple_data_scatter_function_t function;
-	vector<TupleDataScatterFunction> child_functions;
-};
-
-typedef void (*tuple_data_gather_function_t)(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
-                                             const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                             const SelectionVector &target_sel, optional_ptr<Vector> list_vector,
-                                             const vector<TupleDataGatherFunction> &child_functions);
-
-struct TupleDataGatherFunction {
-	tuple_data_gather_function_t function;
-	vector<TupleDataGatherFunction> child_functions;
-};
-
-//! TupleDataCollection represents a set of buffer-managed data stored in row format
-//! FIXME: rename to RowDataCollection after we phase it out
-class TupleDataCollection {
-	friend class TupleDataChunkIterator;
-	friend class PartitionedTupleData;
-
-public:
-	//! Constructs a TupleDataCollection with the specified layout
-	TupleDataCollection(BufferManager &buffer_manager, const TupleDataLayout &layout);
-	//! Constructs a TupleDataCollection with the same (shared) allocator
-	explicit TupleDataCollection(shared_ptr<TupleDataAllocator> allocator);
-
-	~TupleDataCollection();
-
-public:
-	//! The layout of the stored rows
-	const TupleDataLayout &GetLayout() const;
-	//! The number of rows stored in the tuple data collection
-	const idx_t &Count() const;
-	//! The number of chunks stored in the tuple data collection
-	idx_t ChunkCount() const;
-	//! The size (in bytes) of the blocks held by this tuple data collection
-	idx_t SizeInBytes() const;
-	//! Unpins all held pins
-	void Unpin();
-	//! Sets the partition index of this tuple data collection
-	void SetPartitionIndex(idx_t index);
-
-	//! Gets the scatter function for the given type
-	static TupleDataScatterFunction GetScatterFunction(const LogicalType &type, bool within_collection = false);
-	//! Gets the gather function for the given type
-	static TupleDataGatherFunction GetGatherFunction(const LogicalType &type);
-
-	//! Initializes an Append state - useful for optimizing many appends made to the same tuple data collection
-	void InitializeAppend(TupleDataAppendState &append_state,
-	                      TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE);
-	//! Initializes an Append state - useful for optimizing many appends made to the same tuple data collection
-	void InitializeAppend(TupleDataAppendState &append_state, vector<column_t> column_ids,
-	                      TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE);
-	//! Initializes the Pin state of an Append state
-	//! - Useful for optimizing many appends made to the same tuple data collection
-	void InitializeAppend(TupleDataPinState &pin_state,
-	                      TupleDataPinProperties = TupleDataPinProperties::UNPIN_AFTER_DONE);
-	//! Initializes the Chunk state of an Append state
-	//! - Useful for optimizing many appends made to the same tuple data collection
-	void InitializeChunkState(TupleDataChunkState &chunk_state, vector<column_t> column_ids = {});
-	//! Initializes the Chunk state of an Append state
-	//! - Useful for optimizing many appends made to the same tuple data collection
-	static void InitializeChunkState(TupleDataChunkState &chunk_state, const vector<LogicalType> &types,
-	                                 vector<column_t> column_ids = {});
-	//! Append a DataChunk directly to this TupleDataCollection - calls InitializeAppend and Append internally
-	void Append(DataChunk &new_chunk, const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	            idx_t append_count = DConstants::INVALID_INDEX);
-	//! Append a DataChunk directly to this TupleDataCollection - calls InitializeAppend and Append internally
-	void Append(DataChunk &new_chunk, vector<column_t> column_ids,
-	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	            const idx_t append_count = DConstants::INVALID_INDEX);
-	//! Append a DataChunk to this TupleDataCollection using the specified Append state
-	void Append(TupleDataAppendState &append_state, DataChunk &new_chunk,
-	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	            const idx_t append_count = DConstants::INVALID_INDEX);
-	//! Append a DataChunk to this TupleDataCollection using the specified pin and Chunk states
-	void Append(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, DataChunk &new_chunk,
-	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	            const idx_t append_count = DConstants::INVALID_INDEX);
-	//! Append a DataChunk to this TupleDataCollection using the specified pin and Chunk states
-	//! - ToUnifiedFormat has already been called
-	void AppendUnified(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, DataChunk &new_chunk,
-	                   const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
-	                   const idx_t append_count = DConstants::INVALID_INDEX);
-
-	//! Creates a UnifiedVectorFormat in the given Chunk state for the given DataChunk
-	static void ToUnifiedFormat(TupleDataChunkState &chunk_state, DataChunk &new_chunk);
-	//! Gets the UnifiedVectorFormat from the Chunk state as an array
-	static void GetVectorData(const TupleDataChunkState &chunk_state, UnifiedVectorFormat result[]);
-	//! Resets the cached cache vectors (used for ARRAY/LIST casts)
-	static void ResetCachedCastVectors(TupleDataChunkState &chunk_state, const vector<column_t> &column_ids);
-	//! Computes the heap sizes for the new DataChunk that will be appended
-	static void ComputeHeapSizes(TupleDataChunkState &chunk_state, const DataChunk &new_chunk,
-	                             const SelectionVector &append_sel, const idx_t append_count);
-
-	//! Builds out the buffer space for the specified Chunk state
-	void Build(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, const idx_t append_offset,
-	           const idx_t append_count);
-	//! Scatters the given DataChunk to the rows in the specified Chunk state
-	void Scatter(TupleDataChunkState &chunk_state, const DataChunk &new_chunk, const SelectionVector &append_sel,
-	             const idx_t append_count) const;
-	//! Scatters the given Vector to the given column id to the rows in the specified Chunk state
-	void Scatter(TupleDataChunkState &chunk_state, const Vector &source, const column_t column_id,
-	             const SelectionVector &append_sel, const idx_t append_count) const;
-	//! Copy rows from input to the built Chunk state
-	void CopyRows(TupleDataChunkState &chunk_state, TupleDataChunkState &input, const SelectionVector &append_sel,
-	              const idx_t append_count) const;
-
-	//! Finalizes the Pin state, releasing or storing blocks
-	void FinalizePinState(TupleDataPinState &pin_state, TupleDataSegment &segment);
-	//! Finalizes the Pin state, releasing or storing blocks
-	void FinalizePinState(TupleDataPinState &pin_state);
-
-	//! Appends the other TupleDataCollection to this, destroying the other data collection
-	void Combine(TupleDataCollection &other);
-	//! Appends the other TupleDataCollection to this, destroying the other data collection
-	void Combine(unique_ptr<TupleDataCollection> other);
-	//! Resets the TupleDataCollection, clearing all data
-	void Reset();
-
-	//! Initializes a chunk with the correct types that can be used to call Append/Scan
-	void InitializeChunk(DataChunk &chunk) const;
-	//! Initializes a chunk with the correct types that can be used to call Append/Scan for the given columns
-	void InitializeChunk(DataChunk &chunk, const vector<column_t> &columns) const;
-	//! Initializes a chunk with the correct types for a given scan state
-	void InitializeScanChunk(TupleDataScanState &state, DataChunk &chunk) const;
-	//! Initializes a Scan state for scanning all columns
-	void InitializeScan(TupleDataScanState &state,
-	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
-	//! Initializes a Scan state for scanning a subset of the columns
-	void InitializeScan(TupleDataScanState &state, vector<column_t> column_ids,
-	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
-	//! Initialize a parallel scan over the tuple data collection over all columns
-	void InitializeScan(TupleDataParallelScanState &state,
-	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
-	//! Initialize a parallel scan over the tuple data collection over a subset of the columns
-	void InitializeScan(TupleDataParallelScanState &gstate, vector<column_t> column_ids,
-	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
-	//! Scans a DataChunk from the TupleDataCollection
-	bool Scan(TupleDataScanState &state, DataChunk &result);
-	//! Scans a DataChunk from the TupleDataCollection
-	bool Scan(TupleDataParallelScanState &gstate, TupleDataLocalScanState &lstate, DataChunk &result);
-	//! Whether the last scan has been completed on this TupleDataCollection
-	bool ScanComplete(const TupleDataScanState &state) const;
-
-	//! Gathers a DataChunk from the TupleDataCollection, given the specific row locations (requires full pin)
-	void Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count, DataChunk &result,
-	            const SelectionVector &target_sel, vector<unique_ptr<Vector>> &cached_cast_vectors) const;
-	//! Gathers a DataChunk (only the columns given by column_ids) from the TupleDataCollection,
-	//! given the specific row locations (requires full pin)
-	void Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count,
-	            const vector<column_t> &column_ids, DataChunk &result, const SelectionVector &target_sel,
-	            vector<unique_ptr<Vector>> &cached_cast_vectors) const;
-	//! Gathers a Vector (from the given column id) from the TupleDataCollection
-	//! given the specific row locations (requires full pin)
-	void Gather(Vector &row_locations, const SelectionVector &sel, const idx_t scan_count, const column_t column_id,
-	            Vector &result, const SelectionVector &target_sel, optional_ptr<Vector> cached_cast_vector) const;
-
-	//! Converts this TupleDataCollection to a string representation
-	string ToString();
-	//! Prints the string representation of this TupleDataCollection
-	void Print();
-
-	//! Verify that all blocks are pinned
-	void VerifyEverythingPinned() const;
-
-private:
-	//! Initializes the TupleDataCollection (called by the constructor)
-	void Initialize();
-	//! Gets all column ids
-	void GetAllColumnIDs(vector<column_t> &column_ids);
-	//! Adds a segment to this TupleDataCollection
-	void AddSegment(TupleDataSegment &&segment);
-
-	//! Computes the heap sizes for the specific Vector that will be appended
-	static void ComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v, TupleDataVectorFormat &source,
-	                             const SelectionVector &append_sel, const idx_t append_count);
-	//! Computes the heap sizes for the specific Vector that will be appended (within a list)
-	static void WithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                             TupleDataVectorFormat &source_format,
-	                                             const SelectionVector &append_sel, const idx_t append_count,
-	                                             const UnifiedVectorFormat &list_data);
-	//! Computes the heap sizes for the fixed-size type Vector that will be appended (within a list)
-	static void ComputeFixedWithinCollectionHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                                  TupleDataVectorFormat &source_format,
-	                                                  const SelectionVector &append_sel, const idx_t append_count,
-	                                                  const UnifiedVectorFormat &list_data);
-	//! Computes the heap sizes for the string Vector that will be appended (within a list)
-	static void StringWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                                   TupleDataVectorFormat &source_format,
-	                                                   const SelectionVector &append_sel, const idx_t append_count,
-	                                                   const UnifiedVectorFormat &list_data);
-	//! Computes the heap sizes for the struct Vector that will be appended (within a list)
-	static void StructWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                                   TupleDataVectorFormat &source_format,
-	                                                   const SelectionVector &append_sel, const idx_t append_count,
-	                                                   const UnifiedVectorFormat &list_data);
-	//! Computes the heap sizes for the list Vector that will be appended (within a list)
-	static void CollectionWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                                       TupleDataVectorFormat &source_format,
-	                                                       const SelectionVector &append_sel, const idx_t append_count,
-	                                                       const UnifiedVectorFormat &list_data);
-
-	//! Get the next segment/chunk index for the scan
-	bool NextScanIndex(TupleDataScanState &scan_state, idx_t &segment_index, idx_t &chunk_index);
-	//! Scans the chunk at the given segment/chunk indices
-	void ScanAtIndex(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, const vector<column_t> &column_ids,
-	                 idx_t segment_index, idx_t chunk_index, DataChunk &result);
-
-	//! Verify count/data size of this collection
-	void Verify() const;
-
-private:
-	//! The layout of the TupleDataCollection
-	const TupleDataLayout layout;
-	//! The TupleDataAllocator
-	shared_ptr<TupleDataAllocator> allocator;
-	//! The number of entries stored in the TupleDataCollection
-	idx_t count;
-	//! The size (in bytes) of this TupleDataCollection
-	idx_t data_size;
-	//! The data segments of the TupleDataCollection
-	unsafe_vector<TupleDataSegment> segments;
-	//! The set of scatter functions
-	vector<TupleDataScatterFunction> scatter_functions;
-	//! The set of gather functions
-	vector<TupleDataGatherFunction> gather_functions;
-	//! Partition index (optional, if partitioned)
-	optional_idx partition_index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_iterator.hpp b/src/duckdb/src/include/duckdb/common/types/row/tuple_data_iterator.hpp
deleted file mode 100644
index 40a8eb1ac..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_iterator.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/tuple_data_iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-
-namespace duckdb {
-
-class TupleDataChunkIterator {
-public:
-	//! Creates a TupleDataChunkIterator that iterates over all DataChunks in the TupleDataCollection
-	TupleDataChunkIterator(TupleDataCollection &collection, TupleDataPinProperties properties, bool init_heap);
-	//! Creates a TupleDataChunkIterator that iterates over the specified DataChunk range in the TupleDataCollection
-	TupleDataChunkIterator(TupleDataCollection &collection, TupleDataPinProperties properties, idx_t chunk_idx_from,
-	                       idx_t chunk_idx_to, bool init_heap);
-
-public:
-	//! Whether the iterator is done
-	bool Done() const;
-	//! Fetches the next STANDARD_VECTOR_SIZE row locations (and heap locations/sizes if init_heap is true)
-	bool Next();
-	//! Resets the scan indices to the start
-	void Reset();
-	//! Get the count of the current "DataChunk"
-	idx_t GetCurrentChunkCount() const;
-	//! Get the Chunk state of the scan state of this iterator
-	TupleDataChunkState &GetChunkState();
-	//! Get the array holding the row locations
-	data_ptr_t *GetRowLocations();
-	//! Get the array holding the heap locations
-	data_ptr_t *GetHeapLocations();
-	//! Get the array holding the heap sizes
-	idx_t *GetHeapSizes();
-
-private:
-	//! Initializes the row locations (and heap locations/sizes if init_heap is true) at the current scan indices
-	void InitializeCurrentChunk();
-
-private:
-	//! The collection being iterated over
-	TupleDataCollection &collection;
-	//! Whether or not to fetch the heap locations/sizes while iterating
-	bool init_heap;
-
-	//! Start indices
-	idx_t start_segment_idx;
-	idx_t start_chunk_idx;
-	//! End indices
-	idx_t end_segment_idx;
-	idx_t end_chunk_idx;
-
-	//! Current scan state and scan indices
-	TupleDataScanState state;
-	idx_t current_segment_idx;
-	idx_t current_chunk_idx;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_layout.hpp b/src/duckdb/src/include/duckdb/common/types/row/tuple_data_layout.hpp
deleted file mode 100644
index 4bb64c886..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_layout.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/tuple_data_layout.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/row/row_layout.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class TupleDataLayout {
-public:
-	using Aggregates = vector<AggregateObject>;
-	using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-	//! Creates an empty TupleDataLayout
-	TupleDataLayout();
-	//! Create a copy of this TupleDataLayout
-	TupleDataLayout Copy() const;
-
-public:
-	//! Initializes the TupleDataLayout with the specified types and aggregates to an empty TupleDataLayout
-	void Initialize(vector<LogicalType> types_p, Aggregates aggregates_p, bool align = true, bool heap_offset = true);
-	//! Initializes the TupleDataLayout with the specified types to an empty TupleDataLayout
-	void Initialize(vector<LogicalType> types, bool align = true, bool heap_offset = true);
-	//! Initializes the TupleDataLayout with the specified aggregates to an empty TupleDataLayout
-	void Initialize(Aggregates aggregates_p, bool align = true, bool heap_offset = true);
-
-	//! Returns the number of data columns
-	inline idx_t ColumnCount() const {
-		return types.size();
-	}
-	//! Returns a list of the column types for this data chunk
-	inline const vector<LogicalType> &GetTypes() const {
-		return types;
-	}
-	//! Returns the number of aggregates
-	inline idx_t AggregateCount() const {
-		return aggregates.size();
-	}
-	//! Returns a list of the aggregates for this data chunk
-	inline Aggregates &GetAggregates() {
-		return aggregates;
-	}
-	const inline Aggregates &GetAggregates() const {
-		return aggregates;
-	}
-	//! Returns a map from column id to the struct TupleDataLayout
-	const inline TupleDataLayout &GetStructLayout(idx_t col_idx) const {
-		D_ASSERT(struct_layouts->find(col_idx) != struct_layouts->end());
-		return struct_layouts->find(col_idx)->second;
-	}
-	//! Returns the total width required for each row, including padding
-	inline idx_t GetRowWidth() const {
-		return row_width;
-	}
-	//! Returns the offset to the start of the data
-	inline idx_t GetDataOffset() const {
-		return flag_width;
-	}
-	//! Returns the total width required for the data, including padding
-	inline idx_t GetDataWidth() const {
-		return data_width;
-	}
-	//! Returns the offset to the start of the aggregates
-	inline idx_t GetAggrOffset() const {
-		return flag_width + data_width;
-	}
-	//! Returns the total width required for the aggregates, including padding
-	inline idx_t GetAggrWidth() const {
-		return aggr_width;
-	}
-	//! Returns the column offsets into each row
-	inline const vector<idx_t> &GetOffsets() const {
-		return offsets;
-	}
-	//! Returns whether all columns in this layout are constant size
-	inline bool AllConstant() const {
-		return all_constant;
-	}
-	//! Gets offset to where heap size is stored
-	inline idx_t GetHeapSizeOffset() const {
-		return heap_size_offset;
-	}
-	//! Returns whether any of the aggregates have a destructor
-	inline bool HasDestructor() const {
-		return !aggr_destructor_idxs.empty();
-	}
-	//! Returns the indices of the aggregates that have destructors
-	inline const vector<idx_t> &GetAggregateDestructorIndices() const {
-		return aggr_destructor_idxs;
-	}
-
-private:
-	//! The types of the data columns
-	vector<LogicalType> types;
-	//! The aggregate functions
-	Aggregates aggregates;
-	//! Structs are a recursive TupleDataLayout
-	unique_ptr<unordered_map<idx_t, TupleDataLayout>> struct_layouts;
-	//! The width of the validity header
-	idx_t flag_width;
-	//! The width of the data portion
-	idx_t data_width;
-	//! The width of the aggregate state portion
-	idx_t aggr_width;
-	//! The width of the entire row
-	idx_t row_width;
-	//! The offsets to the columns and aggregate data in each row
-	vector<idx_t> offsets;
-	//! Whether all columns in this layout are constant size
-	bool all_constant;
-	//! Offset to the heap size of every row
-	idx_t heap_size_offset;
-	//! Indices of aggregate functions that have a destructor
-	vector<idx_t> aggr_destructor_idxs;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp b/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp
deleted file mode 100644
index cf6ee2767..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/tuple_data_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/perfect_map_set.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-class TupleDataAllocator;
-class TupleDataLayout;
-
-struct TupleDataChunkPart {
-public:
-	explicit TupleDataChunkPart(mutex &lock);
-
-	//! Disable copy constructors
-	TupleDataChunkPart(const TupleDataChunkPart &other) = delete;
-	TupleDataChunkPart &operator=(const TupleDataChunkPart &) = delete;
-
-	//! Enable move constructors
-	TupleDataChunkPart(TupleDataChunkPart &&other) noexcept;
-	TupleDataChunkPart &operator=(TupleDataChunkPart &&) noexcept;
-
-public:
-	//! Mark heap as empty
-	void SetHeapEmpty();
-
-public:
-	//! Index/offset of the row block
-	uint32_t row_block_index;
-	uint32_t row_block_offset;
-	//! Pointer/index/offset of the heap block
-	uint32_t heap_block_index;
-	uint32_t heap_block_offset;
-	data_ptr_t base_heap_ptr;
-	//! Total heap size for this chunk part
-	uint32_t total_heap_size;
-	//! Tuple count for this chunk part
-	uint32_t count;
-	//! Lock for recomputing heap pointers (owned by TupleDataChunk)
-	reference<mutex> lock;
-
-private:
-	//! Marker for empty heaps
-	static constexpr const uint32_t INVALID_INDEX = (uint32_t)-1;
-};
-
-struct TupleDataChunk {
-public:
-	TupleDataChunk();
-
-	//! Disable copy constructors
-	TupleDataChunk(const TupleDataChunk &other) = delete;
-	TupleDataChunk &operator=(const TupleDataChunk &) = delete;
-
-	//! Enable move constructors
-	TupleDataChunk(TupleDataChunk &&other) noexcept;
-	TupleDataChunk &operator=(TupleDataChunk &&) noexcept;
-
-	//! Add a part to this chunk
-	void AddPart(TupleDataChunkPart &&part, const TupleDataLayout &layout);
-	//! Tries to merge the last chunk part into the second-to-last one
-	void MergeLastChunkPart(const TupleDataLayout &layout);
-	//! Verify counts of the parts in this chunk
-	void Verify() const;
-
-public:
-	//! The parts of this chunk
-	unsafe_vector<TupleDataChunkPart> parts;
-	//! The row block ids referenced by the chunk
-	perfect_set_t row_block_ids;
-	//! The heap block ids referenced by the chunk
-	perfect_set_t heap_block_ids;
-	//! Tuple count for this chunk
-	idx_t count;
-	//! Lock for recomputing heap pointers
-	unsafe_unique_ptr<mutex> lock;
-};
-
-struct TupleDataSegment {
-public:
-	explicit TupleDataSegment(shared_ptr<TupleDataAllocator> allocator);
-
-	~TupleDataSegment();
-
-	//! Disable copy constructors
-	TupleDataSegment(const TupleDataSegment &other) = delete;
-	TupleDataSegment &operator=(const TupleDataSegment &) = delete;
-
-	//! Enable move constructors
-	TupleDataSegment(TupleDataSegment &&other) noexcept;
-	TupleDataSegment &operator=(TupleDataSegment &&) noexcept;
-
-	//! The number of chunks in this segment
-	idx_t ChunkCount() const;
-	//! The size (in bytes) of this segment
-	idx_t SizeInBytes() const;
-	//! Unpins all held pins
-	void Unpin();
-
-	//! Verify counts of the chunks in this segment
-	void Verify() const;
-	//! Verify that all blocks in this segment are pinned
-	void VerifyEverythingPinned() const;
-
-public:
-	//! The allocator for this segment
-	shared_ptr<TupleDataAllocator> allocator;
-	//! The chunks of this segment
-	unsafe_vector<TupleDataChunk> chunks;
-	//! The tuple count of this segment
-	idx_t count;
-	//! The data size of this segment
-	idx_t data_size;
-
-	//! Lock for modifying pinned_handles
-	mutex pinned_handles_lock;
-	//! Where handles to row blocks will be stored with TupleDataPinProperties::KEEP_EVERYTHING_PINNED
-	unsafe_vector<BufferHandle> pinned_row_handles;
-	//! Where handles to heap blocks will be stored with TupleDataPinProperties::KEEP_EVERYTHING_PINNED
-	unsafe_vector<BufferHandle> pinned_heap_handles;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_states.hpp b/src/duckdb/src/include/duckdb/common/types/row/tuple_data_states.hpp
deleted file mode 100644
index 36017da2a..000000000
--- a/src/duckdb/src/include/duckdb/common/types/row/tuple_data_states.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row/tuple_data_states.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/perfect_map_set.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector_cache.hpp"
-
-namespace duckdb {
-
-enum class TupleDataPinProperties : uint8_t {
-	INVALID,
-	//! Keeps all passed blocks pinned while scanning/iterating over the chunks (for both reading/writing)
-	KEEP_EVERYTHING_PINNED,
-	//! Unpins blocks after they are done (for both reading/writing)
-	UNPIN_AFTER_DONE,
-	//! Destroys blocks after they are done (for reading only)
-	DESTROY_AFTER_DONE,
-	//! Assumes all blocks are already pinned (for reading only)
-	ALREADY_PINNED
-};
-
-struct TupleDataPinState {
-	perfect_map_t<BufferHandle> row_handles;
-	perfect_map_t<BufferHandle> heap_handles;
-	TupleDataPinProperties properties = TupleDataPinProperties::INVALID;
-};
-
-struct CombinedListData {
-	CombinedListData() : combined_validity(STANDARD_VECTOR_SIZE) {
-	}
-	UnifiedVectorFormat combined_data;
-	buffer_ptr<SelectionData> selection_data;
-	list_entry_t combined_list_entries[STANDARD_VECTOR_SIZE];
-	ValidityMask combined_validity;
-};
-
-struct TupleDataVectorFormat {
-	const SelectionVector *original_sel;
-	SelectionVector original_owned_sel;
-
-	UnifiedVectorFormat unified;
-	vector<TupleDataVectorFormat> children;
-	unique_ptr<CombinedListData> combined_list_data;
-
-	// Optional: only used for ArrayVector to fake being a list vector
-	unsafe_unique_array<list_entry_t> array_list_entries;
-};
-
-struct TupleDataChunkState {
-	vector<TupleDataVectorFormat> vector_data;
-	vector<column_t> column_ids;
-
-	Vector row_locations = Vector(LogicalType::POINTER);
-	Vector heap_locations = Vector(LogicalType::POINTER);
-	Vector heap_sizes = Vector(LogicalType::UBIGINT);
-
-	vector<unique_ptr<Vector>> cached_cast_vectors;
-	vector<unique_ptr<VectorCache>> cached_cast_vector_cache;
-};
-
-struct TupleDataAppendState {
-	TupleDataPinState pin_state;
-	TupleDataChunkState chunk_state;
-};
-
-struct TupleDataScanState {
-	TupleDataPinState pin_state;
-	TupleDataChunkState chunk_state;
-	idx_t segment_index = DConstants::INVALID_INDEX;
-	idx_t chunk_index = DConstants::INVALID_INDEX;
-};
-
-struct TupleDataParallelScanState {
-	TupleDataScanState scan_state;
-	mutex lock;
-};
-
-using TupleDataLocalScanState = TupleDataScanState;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/sel_cache.hpp b/src/duckdb/src/include/duckdb/common/types/sel_cache.hpp
deleted file mode 100644
index d0c096e1e..000000000
--- a/src/duckdb/src/include/duckdb/common/types/sel_cache.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/sel_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-//! Selection vector cache used for caching vector slices
-struct SelCache {
-	unordered_map<sel_t *, buffer_ptr<VectorBuffer>> cache;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/selection_vector.hpp b/src/duckdb/src/include/duckdb/common/types/selection_vector.hpp
deleted file mode 100644
index 578aa25b8..000000000
--- a/src/duckdb/src/include/duckdb/common/types/selection_vector.hpp
+++ /dev/null
@@ -1,215 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/selection_vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-class VectorBuffer;
-
-struct SelectionData {
-	DUCKDB_API explicit SelectionData(idx_t count);
-
-	unsafe_unique_array<sel_t> owned_data;
-};
-
-struct SelectionVector {
-	SelectionVector() : sel_vector(nullptr) {
-	}
-	explicit SelectionVector(sel_t *sel) {
-		Initialize(sel);
-	}
-	explicit SelectionVector(idx_t count) {
-		Initialize(count);
-	}
-	SelectionVector(idx_t start, idx_t count) {
-		Initialize(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			set_index(i, start + i);
-		}
-	}
-	SelectionVector(const SelectionVector &sel_vector) {
-		Initialize(sel_vector);
-	}
-	explicit SelectionVector(buffer_ptr<SelectionData> data) {
-		Initialize(std::move(data));
-	}
-	SelectionVector &operator=(SelectionVector &&other) noexcept {
-		sel_vector = other.sel_vector;
-		other.sel_vector = nullptr;
-		selection_data = std::move(other.selection_data);
-		return *this;
-	}
-
-public:
-	static idx_t Inverted(const SelectionVector &src, SelectionVector &dst, idx_t source_size, idx_t count) {
-		idx_t src_idx = 0;
-		idx_t dst_idx = 0;
-		for (idx_t i = 0; i < count; i++) {
-			if (src_idx < source_size && src.get_index(src_idx) == i) {
-				src_idx++;
-				// This index is selected by 'src', skip it in 'dst'
-				continue;
-			}
-			// This index does not exist in 'src', add it to the selection of 'dst'
-			dst.set_index(dst_idx++, i);
-		}
-		return dst_idx;
-	}
-
-	void Initialize(sel_t *sel) {
-		selection_data.reset();
-		sel_vector = sel;
-	}
-	void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
-		selection_data = make_shared_ptr<SelectionData>(count);
-		sel_vector = selection_data->owned_data.get();
-	}
-	void Initialize(buffer_ptr<SelectionData> data) {
-		selection_data = std::move(data);
-		sel_vector = selection_data->owned_data.get();
-	}
-	void Initialize(const SelectionVector &other) {
-		selection_data = other.selection_data;
-		sel_vector = other.sel_vector;
-	}
-
-	inline void set_index(idx_t idx, idx_t loc) { // NOLINT: allow casing for legacy reasons
-		sel_vector[idx] = UnsafeNumericCast<sel_t>(loc);
-	}
-	inline void swap(idx_t i, idx_t j) { // NOLINT: allow casing for legacy reasons
-		sel_t tmp = sel_vector[i];
-		sel_vector[i] = sel_vector[j];
-		sel_vector[j] = tmp;
-	}
-	inline idx_t get_index(idx_t idx) const { // NOLINT: allow casing for legacy reasons
-		return sel_vector ? sel_vector[idx] : idx;
-	}
-	sel_t *data() { // NOLINT: allow casing for legacy reasons
-		return sel_vector;
-	}
-	const sel_t *data() const { // NOLINT: allow casing for legacy reasons
-		return sel_vector;
-	}
-	buffer_ptr<SelectionData> sel_data() { // NOLINT: allow casing for legacy reasons
-		return selection_data;
-	}
-	buffer_ptr<SelectionData> Slice(const SelectionVector &sel, idx_t count) const;
-
-	string ToString(idx_t count = 0) const;
-	void Print(idx_t count = 0) const;
-
-	inline sel_t &operator[](idx_t index) const {
-		return sel_vector[index];
-	}
-	inline bool IsSet() const {
-		return sel_vector;
-	}
-	void Verify(idx_t count, idx_t vector_size) const;
-
-private:
-	sel_t *sel_vector;
-	buffer_ptr<SelectionData> selection_data;
-};
-
-class OptionalSelection {
-public:
-	explicit OptionalSelection(SelectionVector *sel_p) {
-		Initialize(sel_p);
-	}
-	void Initialize(SelectionVector *sel_p) {
-		sel = sel_p;
-		if (sel) {
-			vec.Initialize(sel->data());
-			sel = &vec;
-		}
-	}
-
-	inline operator SelectionVector *() { // NOLINT: allow implicit conversion to SelectionVector
-		return sel;
-	}
-
-	inline void Append(idx_t &count, const idx_t idx) {
-		if (sel) {
-			sel->set_index(count, idx);
-		}
-		++count;
-	}
-
-	inline void Advance(idx_t completed) {
-		if (sel) {
-			sel->Initialize(sel->data() + completed);
-		}
-	}
-
-private:
-	SelectionVector *sel;
-	SelectionVector vec;
-};
-
-// Contains a selection vector, combined with a count
-class ManagedSelection {
-public:
-	explicit inline ManagedSelection(idx_t size, bool initialize = true)
-	    : initialized(initialize), size(size), internal_opt_selvec(nullptr) {
-		count = 0;
-		if (!initialized) {
-			return;
-		}
-		sel_vec.Initialize(size);
-		internal_opt_selvec.Initialize(&sel_vec);
-	}
-
-public:
-	bool Initialized() const {
-		return initialized;
-	}
-	void Initialize(idx_t new_size) {
-		D_ASSERT(!initialized);
-		this->size = new_size;
-		sel_vec.Initialize(new_size);
-		internal_opt_selvec.Initialize(&sel_vec);
-		initialized = true;
-	}
-
-	inline idx_t operator[](idx_t index) const {
-		D_ASSERT(index < size);
-		return sel_vec.get_index(index);
-	}
-	inline bool IndexMapsToLocation(idx_t idx, idx_t location) const {
-		return idx < count && sel_vec.get_index(idx) == location;
-	}
-	inline void Append(const idx_t idx) {
-		internal_opt_selvec.Append(count, idx);
-	}
-	inline idx_t Count() const {
-		return count;
-	}
-	inline idx_t Size() const {
-		return size;
-	}
-	inline const SelectionVector &Selection() const {
-		return sel_vec;
-	}
-	inline SelectionVector &Selection() {
-		return sel_vec;
-	}
-
-private:
-	bool initialized = false;
-	idx_t count;
-	idx_t size;
-	SelectionVector sel_vec;
-	OptionalSelection internal_opt_selvec;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/string_heap.hpp b/src/duckdb/src/include/duckdb/common/types/string_heap.hpp
deleted file mode 100644
index 2dac802ff..000000000
--- a/src/duckdb/src/include/duckdb/common/types/string_heap.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/string_heap.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-
-namespace duckdb {
-//! A string heap is the owner of a set of strings, strings can be inserted into
-//! it On every insert, a pointer to the inserted string is returned The
-//! returned pointer will remain valid until the StringHeap is destroyed
-class StringHeap {
-public:
-	DUCKDB_API explicit StringHeap(Allocator &allocator = Allocator::DefaultAllocator());
-
-	DUCKDB_API void Destroy();
-	DUCKDB_API void Move(StringHeap &other);
-
-	//! Add a string to the string heap, returns a pointer to the string
-	DUCKDB_API string_t AddString(const char *data, idx_t len);
-	//! Add a string to the string heap, returns a pointer to the string
-	DUCKDB_API string_t AddString(const char *data);
-	//! Add a string to the string heap, returns a pointer to the string
-	DUCKDB_API string_t AddString(const string &data);
-	//! Add a string to the string heap, returns a pointer to the string
-	DUCKDB_API string_t AddString(const string_t &data);
-	//! Add a blob to the string heap; blobs can be non-valid UTF8
-	DUCKDB_API string_t AddBlob(const string_t &data);
-	//! Add a blob to the string heap; blobs can be non-valid UTF8
-	DUCKDB_API string_t AddBlob(const char *data, idx_t len);
-	//! Allocates space for an empty string of size "len" on the heap
-	DUCKDB_API string_t EmptyString(idx_t len);
-
-	//! Size of strings
-	DUCKDB_API idx_t SizeInBytes() const;
-	//! Total allocation size (cached)
-	DUCKDB_API idx_t AllocationSize() const;
-
-private:
-	ArenaAllocator allocator;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/string_type.hpp b/src/duckdb/src/include/duckdb/common/types/string_type.hpp
deleted file mode 100644
index 0a88e3321..000000000
--- a/src/duckdb/src/include/duckdb/common/types/string_type.hpp
+++ /dev/null
@@ -1,246 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/string_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/hash.hpp"
-
-#include <cstring>
-#include <algorithm>
-
-namespace duckdb {
-
-struct string_t {
-	friend struct StringComparisonOperators;
-
-public:
-	static constexpr idx_t PREFIX_BYTES = 4 * sizeof(char);
-	static constexpr idx_t INLINE_BYTES = 12 * sizeof(char);
-	static constexpr idx_t HEADER_SIZE = sizeof(uint32_t) + PREFIX_BYTES;
-	static constexpr idx_t MAX_STRING_SIZE = NumericLimits<uint32_t>::Maximum();
-#ifndef DUCKDB_DEBUG_NO_INLINE
-	static constexpr idx_t PREFIX_LENGTH = PREFIX_BYTES;
-	static constexpr idx_t INLINE_LENGTH = INLINE_BYTES;
-#else
-	static constexpr idx_t PREFIX_LENGTH = 0;
-	static constexpr idx_t INLINE_LENGTH = 0;
-#endif
-
-	string_t() = default;
-	explicit string_t(uint32_t len) {
-		value.inlined.length = len;
-	}
-	string_t(const char *data, uint32_t len) {
-		value.inlined.length = len;
-		D_ASSERT(data || GetSize() == 0);
-		if (IsInlined()) {
-			// zero initialize the prefix first
-			// this makes sure that strings with length smaller than 4 still have an equal prefix
-			memset(value.inlined.inlined, 0, INLINE_BYTES);
-			if (GetSize() == 0) {
-				return;
-			}
-			// small string: inlined
-			memcpy(value.inlined.inlined, data, GetSize());
-		} else {
-			// large string: store pointer
-#ifndef DUCKDB_DEBUG_NO_INLINE
-			memcpy(value.pointer.prefix, data, PREFIX_LENGTH);
-#else
-			memset(value.pointer.prefix, 0, PREFIX_BYTES);
-#endif
-			value.pointer.ptr = (char *)data; // NOLINT
-		}
-	}
-
-	string_t(const char *data) // NOLINT: Allow implicit conversion from `const char*`
-	    : string_t(data, UnsafeNumericCast<uint32_t>(strlen(data))) {
-	}
-	string_t(const string &value) // NOLINT: Allow implicit conversion from `const char*`
-	    : string_t(value.c_str(), UnsafeNumericCast<uint32_t>(value.size())) {
-	}
-
-	bool IsInlined() const {
-		return GetSize() <= INLINE_LENGTH;
-	}
-
-	const char *GetData() const {
-		return IsInlined() ? const_char_ptr_cast(value.inlined.inlined) : value.pointer.ptr;
-	}
-	const char *GetDataUnsafe() const {
-		return GetData();
-	}
-
-	char *GetDataWriteable() const {
-		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr; // NOLINT
-	}
-
-	const char *GetPrefix() const {
-		return value.inlined.inlined;
-	}
-
-	char *GetPrefixWriteable() {
-		return value.inlined.inlined;
-	}
-
-	idx_t GetSize() const {
-		return value.inlined.length;
-	}
-
-	bool Empty() const {
-		return value.inlined.length == 0;
-	}
-
-	string GetString() const {
-		return string(GetData(), GetSize());
-	}
-
-	explicit operator string() const {
-		return GetString();
-	}
-
-	char *GetPointer() const {
-		D_ASSERT(!IsInlined());
-		return value.pointer.ptr;
-	}
-
-	void SetPointer(char *new_ptr) {
-		D_ASSERT(!IsInlined());
-		value.pointer.ptr = new_ptr;
-	}
-
-	void Finalize() {
-		// set trailing NULL byte
-		if (GetSize() <= INLINE_LENGTH) {
-			// fill prefix with zeros if the length is smaller than the prefix length
-			memset(value.inlined.inlined + GetSize(), 0, INLINE_BYTES - GetSize());
-		} else {
-			// copy the data into the prefix
-#ifndef DUCKDB_DEBUG_NO_INLINE
-			auto dataptr = GetData();
-			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
-#else
-			memset(value.pointer.prefix, 0, PREFIX_BYTES);
-#endif
-		}
-	}
-
-	void Verify() const;
-	void VerifyUTF8() const;
-	void VerifyCharacters() const;
-	void VerifyNull() const;
-
-	struct StringComparisonOperators {
-		static inline bool Equals(const string_t &a, const string_t &b) {
-#ifdef DUCKDB_DEBUG_NO_INLINE
-			if (a.GetSize() != b.GetSize()) {
-				return false;
-			}
-			return (memcmp(a.GetData(), b.GetData(), a.GetSize()) == 0);
-#endif
-			uint64_t a_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&a));
-			uint64_t b_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&b));
-			if (a_bulk_comp != b_bulk_comp) {
-				// Either length or prefix are different -> not equal
-				return false;
-			}
-			// they have the same length and same prefix!
-			a_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&a) + 8u);
-			b_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&b) + 8u);
-			if (a_bulk_comp == b_bulk_comp) {
-				// either they are both inlined (so compare equal) or point to the same string (so compare equal)
-				return true;
-			}
-			if (!a.IsInlined()) {
-				// 'long' strings of the same length -> compare pointed value
-				if (memcmp(a.value.pointer.ptr, b.value.pointer.ptr, a.GetSize()) == 0) {
-					return true;
-				}
-			}
-			// either they are short string of same length but different content
-			//     or they point to string with different content
-			//     either way, they can't represent the same underlying string
-			return false;
-		}
-		// compare up to shared length. if still the same, compare lengths
-		static bool GreaterThan(const string_t &left, const string_t &right) {
-			const uint32_t left_length = UnsafeNumericCast<uint32_t>(left.GetSize());
-			const uint32_t right_length = UnsafeNumericCast<uint32_t>(right.GetSize());
-			const uint32_t min_length = std::min<uint32_t>(left_length, right_length);
-
-#ifndef DUCKDB_DEBUG_NO_INLINE
-			uint32_t a_prefix = Load<uint32_t>(const_data_ptr_cast(left.GetPrefix()));
-			uint32_t b_prefix = Load<uint32_t>(const_data_ptr_cast(right.GetPrefix()));
-
-			// Utility to move 0xa1b2c3d4 into 0xd4c3b2a1, basically inverting the order byte-a-byte
-			auto byte_swap = [](uint32_t v) -> uint32_t {
-				uint32_t t1 = (v >> 16u) | (v << 16u);
-				uint32_t t2 = t1 & 0x00ff00ff;
-				uint32_t t3 = t1 & 0xff00ff00;
-				return (t2 << 8u) | (t3 >> 8u);
-			};
-
-			// Check on prefix -----
-			// We dont' need to mask since:
-			//	if the prefix is greater(after bswap), it will stay greater regardless of the extra bytes
-			// 	if the prefix is smaller(after bswap), it will stay smaller regardless of the extra bytes
-			//	if the prefix is equal, the extra bytes are guaranteed to be /0 for the shorter one
-
-			if (a_prefix != b_prefix) {
-				return byte_swap(a_prefix) > byte_swap(b_prefix);
-			}
-#endif
-			auto memcmp_res = memcmp(left.GetData(), right.GetData(), min_length);
-			return memcmp_res > 0 || (memcmp_res == 0 && left_length > right_length);
-		}
-	};
-
-	bool operator==(const string_t &r) const {
-		return StringComparisonOperators::Equals(*this, r);
-	}
-
-	bool operator!=(const string_t &r) const {
-		return !(*this == r);
-	}
-
-	bool operator>(const string_t &r) const {
-		return StringComparisonOperators::GreaterThan(*this, r);
-	}
-	bool operator<(const string_t &r) const {
-		return r > *this;
-	}
-
-private:
-	union {
-		struct {
-			uint32_t length;
-			char prefix[4];
-			char *ptr;
-		} pointer;
-		struct {
-			uint32_t length;
-			char inlined[12];
-		} inlined;
-	} value;
-};
-
-} // namespace duckdb
-
-namespace std {
-template <>
-struct hash<duckdb::string_t> {
-	size_t operator()(const duckdb::string_t &val) const {
-		return Hash(val);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/types/time.hpp b/src/duckdb/src/include/duckdb/common/types/time.hpp
deleted file mode 100644
index 74085b2ec..000000000
--- a/src/duckdb/src/include/duckdb/common/types/time.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/time.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/winapi.hpp"
-
-namespace duckdb {
-
-struct dtime_t;    // NOLINT
-struct dtime_tz_t; // NOLINT
-
-//! The Time class is a static class that holds helper functions for the Time
-//! type.
-class Time {
-public:
-	//! Convert a string in the format "hh:mm:ss" to a time object
-	DUCKDB_API static dtime_t FromString(const string &str, bool strict = false, optional_ptr<int32_t> nanos = nullptr);
-	DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false,
-	                                      optional_ptr<int32_t> nanos = nullptr);
-	DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false,
-	                                      optional_ptr<int32_t> nanos = nullptr);
-	DUCKDB_API static bool TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result,
-	                                        bool &has_offset, bool strict = false,
-	                                        optional_ptr<int32_t> nanos = nullptr);
-	// No hour limit
-	DUCKDB_API static bool TryConvertInterval(const char *buf, idx_t len, idx_t &pos, dtime_t &result,
-	                                          bool strict = false, optional_ptr<int32_t> nanos = nullptr);
-
-	//! Convert a time object to a string in the format "hh:mm:ss"
-	DUCKDB_API static string ToString(dtime_t time);
-	//! Convert a UTC offset to ±HH[:MM]
-	DUCKDB_API static string ToUTCOffset(int hour_offset, int minute_offset);
-
-	DUCKDB_API static dtime_t FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds = 0);
-	DUCKDB_API static int64_t ToNanoTime(int32_t hour, int32_t minute, int32_t second, int32_t nanoseconds = 0);
-
-	//! Normalize a TIME_TZ by adding the offset to the time part and returning the TIME
-	DUCKDB_API static dtime_t NormalizeTimeTZ(dtime_tz_t timetz);
-
-	//! Extract the time from a given timestamp object
-	DUCKDB_API static void Convert(dtime_t time, int32_t &out_hour, int32_t &out_min, int32_t &out_sec,
-	                               int32_t &out_micros);
-
-	DUCKDB_API static string ConversionError(const string &str);
-	DUCKDB_API static string ConversionError(string_t str);
-
-	DUCKDB_API static dtime_t FromTimeMs(int64_t time_ms);
-	DUCKDB_API static dtime_t FromTimeNs(int64_t time_ns);
-
-	DUCKDB_API static bool IsValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds);
-
-private:
-	static bool TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict,
-	                               optional_ptr<int32_t> nanos = nullptr);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/timestamp.hpp b/src/duckdb/src/include/duckdb/common/types/timestamp.hpp
deleted file mode 100644
index c56168251..000000000
--- a/src/duckdb/src/include/duckdb/common/types/timestamp.hpp
+++ /dev/null
@@ -1,252 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/timestamp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/winapi.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct date_t;     // NOLINT
-struct dtime_t;    // NOLINT
-struct dtime_tz_t; // NOLINT
-
-//! Type used to represent a TIMESTAMP. timestamp_t holds the microseconds since 1970-01-01.
-struct timestamp_t { // NOLINT
-	// NOTE: The unit of value is microseconds for timestamp_t, but it can be
-	// different for subclasses (e.g. it's nanos for timestamp_ns, etc).
-	int64_t value;
-
-	timestamp_t() = default;
-	explicit inline constexpr timestamp_t(int64_t micros) : value(micros) {
-	}
-	inline timestamp_t &operator=(int64_t micros) {
-		value = micros;
-		return *this;
-	}
-
-	// explicit conversion
-	explicit inline operator int64_t() const {
-		return value;
-	}
-
-	// comparison operators
-	inline bool operator==(const timestamp_t &rhs) const {
-		return value == rhs.value;
-	};
-	inline bool operator!=(const timestamp_t &rhs) const {
-		return value != rhs.value;
-	};
-	inline bool operator<=(const timestamp_t &rhs) const {
-		return value <= rhs.value;
-	};
-	inline bool operator<(const timestamp_t &rhs) const {
-		return value < rhs.value;
-	};
-	inline bool operator>(const timestamp_t &rhs) const {
-		return value > rhs.value;
-	};
-	inline bool operator>=(const timestamp_t &rhs) const {
-		return value >= rhs.value;
-	};
-
-	// arithmetic operators
-	timestamp_t operator+(const double &value) const;
-	int64_t operator-(const timestamp_t &other) const;
-
-	// in-place operators
-	timestamp_t &operator+=(const int64_t &delta);
-	timestamp_t &operator-=(const int64_t &delta);
-
-	// special values
-	static constexpr timestamp_t infinity() { // NOLINT
-		return timestamp_t(NumericLimits<int64_t>::Maximum());
-	}                                          // NOLINT
-	static constexpr timestamp_t ninfinity() { // NOLINT
-		return timestamp_t(-NumericLimits<int64_t>::Maximum());
-	}                                             // NOLINT
-	static constexpr inline timestamp_t epoch() { // NOLINT
-		return timestamp_t(0);
-	} // NOLINT
-};
-
-//! Type used to represent TIMESTAMP_S. timestamp_sec_t holds the seconds since 1970-01-01.
-struct timestamp_sec_t : public timestamp_t { // NOLINT
-	timestamp_sec_t() = default;
-	explicit inline constexpr timestamp_sec_t(int64_t seconds) : timestamp_t(seconds) {
-	}
-};
-
-//! Type used to represent TIMESTAMP_MS. timestamp_ms_t holds the milliseconds since 1970-01-01.
-struct timestamp_ms_t : public timestamp_t { // NOLINT
-	timestamp_ms_t() = default;
-	explicit inline constexpr timestamp_ms_t(int64_t millis) : timestamp_t(millis) {
-	}
-};
-
-//! Type used to represent TIMESTAMP_NS. timestamp_ns_t holds the nanoseconds since 1970-01-01.
-struct timestamp_ns_t : public timestamp_t { // NOLINT
-	timestamp_ns_t() = default;
-	explicit inline constexpr timestamp_ns_t(int64_t nanos) : timestamp_t(nanos) {
-	}
-};
-
-//! Type used to represent TIMESTAMPTZ. timestamp_tz_t holds the microseconds since 1970-01-01 (UTC).
-//! It is physically the same as timestamp_t, both hold microseconds since epoch.
-struct timestamp_tz_t : public timestamp_t { // NOLINT
-	timestamp_tz_t() = default;
-	explicit inline constexpr timestamp_tz_t(int64_t micros) : timestamp_t(micros) {
-	}
-	explicit inline constexpr timestamp_tz_t(timestamp_t ts) : timestamp_t(ts) {
-	}
-};
-
-enum class TimestampCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_NON_UTC_TIMEZONE, ERROR_RANGE };
-
-//! The static Timestamp class holds helper functions for the timestamp types.
-class Timestamp {
-public:
-	// min timestamp is 290308-12-22 (BC)
-	constexpr static const int32_t MIN_YEAR = -290308;
-	constexpr static const int32_t MIN_MONTH = 12;
-	constexpr static const int32_t MIN_DAY = 22;
-
-public:
-	//! Convert a string in the format "YYYY-MM-DD hh:mm:ss[.f][-+TH[:tm]]" to a timestamp object
-	DUCKDB_API static timestamp_t FromString(const string &str);
-	//! Convert a string where the offset can also be a time zone string: / [A_Za-z0-9/_]+/
-	//! If has_offset is true, then the result is an instant that was offset from UTC
-	//! If the tz is not empty, the result is still an instant, but the parts can be extracted and applied to the TZ
-	DUCKDB_API static TimestampCastResult TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result,
-	                                                            bool &has_offset, string_t &tz,
-	                                                            optional_ptr<int32_t> nanos = nullptr);
-	DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result,
-	                                                          optional_ptr<int32_t> nanos = nullptr);
-	DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_ns_t &result);
-	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len, optional_ptr<int32_t> nanos = nullptr);
-	//! Convert a date object to a string in the format "YYYY-MM-DD hh:mm:ss"
-	DUCKDB_API static string ToString(timestamp_t timestamp);
-
-	DUCKDB_API static date_t GetDate(timestamp_t timestamp);
-
-	DUCKDB_API static dtime_t GetTime(timestamp_t timestamp);
-	//! Create a Timestamp object from a specified (date, time) combination
-	DUCKDB_API static timestamp_t FromDatetime(date_t date, dtime_t time);
-	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_t time, timestamp_t &result);
-	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_tz_t timetz, timestamp_t &result);
-	//! Scale up to ns
-	DUCKDB_API static bool TryFromTimestampNanos(timestamp_t ts, int32_t nanos, timestamp_ns_t &result);
-
-	//! Is the character a valid part of a time zone name?
-	static inline bool CharacterIsTimeZone(char c) {
-		return StringUtil::CharacterIsAlpha(c) || StringUtil::CharacterIsDigit(c) || c == '_' || c == '/' || c == '+' ||
-		       c == '-';
-	}
-
-	//! True, if the timestamp is finite, else false.
-	static inline bool IsFinite(timestamp_t timestamp) {
-		return timestamp != timestamp_t::infinity() && timestamp != timestamp_t::ninfinity();
-	}
-
-	//! Extract the date and time from a given timestamp object
-	DUCKDB_API static void Convert(timestamp_t date, date_t &out_date, dtime_t &out_time);
-	//! Extract the date and time from a given timestamp object
-	DUCKDB_API static void Convert(timestamp_ns_t date, date_t &out_date, dtime_t &out_time, int32_t &out_nanos);
-	//! Returns current timestamp
-	DUCKDB_API static timestamp_t GetCurrentTimestamp();
-
-	//! Convert the epoch (in sec) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochSecondsPossiblyInfinite(int64_t s);
-	DUCKDB_API static timestamp_t FromEpochSeconds(int64_t s);
-	//! Convert the epoch (in ms) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochMsPossiblyInfinite(int64_t ms);
-	DUCKDB_API static timestamp_t FromEpochMs(int64_t ms);
-	//! Convert the epoch (in microseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochMicroSeconds(int64_t micros);
-	//! Convert the epoch (in nanoseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochNanoSecondsPossiblyInfinite(int64_t nanos);
-	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t nanos);
-
-	//! Construct ns timestamps from various epoch units
-	DUCKDB_API static timestamp_ns_t TimestampNsFromEpochMicros(int64_t micros);
-	DUCKDB_API static timestamp_ns_t TimestampNsFromEpochMillis(int64_t millis);
-
-	//! Try convert a timestamp to epoch (in nanoseconds)
-	DUCKDB_API static bool TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result);
-	//! Convert the epoch (in seconds) to a timestamp
-	DUCKDB_API static int64_t GetEpochSeconds(timestamp_t timestamp);
-	//! Convert the epoch (in ms) to a timestamp
-	DUCKDB_API static int64_t GetEpochMs(timestamp_t timestamp);
-	//! Convert a timestamp to epoch (in microseconds)
-	DUCKDB_API static int64_t GetEpochMicroSeconds(timestamp_t timestamp);
-	//! Convert a timestamp to epoch (in nanoseconds)
-	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_t timestamp);
-	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_ns_t timestamp);
-	//! Convert a timestamp to a rounded epoch at a given resolution.
-	DUCKDB_API static int64_t GetEpochRounded(timestamp_t timestamp, const int64_t power_of_ten);
-	//! Convert a timestamp to a Julian Day
-	DUCKDB_API static double GetJulianDay(timestamp_t timestamp);
-
-	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset,
-	                                         int &minute_offset);
-
-	DUCKDB_API static string FormatError(const string &str);
-	DUCKDB_API static string FormatError(string_t str);
-	DUCKDB_API static string UnsupportedTimezoneError(const string &str);
-	DUCKDB_API static string UnsupportedTimezoneError(string_t str);
-	DUCKDB_API static string RangeError(const string &str);
-	DUCKDB_API static string RangeError(string_t str);
-};
-
-} // namespace duckdb
-
-namespace std {
-
-//! Timestamp
-template <>
-struct hash<duckdb::timestamp_t> {
-	std::size_t operator()(const duckdb::timestamp_t &k) const {
-		using std::hash;
-		return hash<int64_t>()((int64_t)k);
-	}
-};
-template <>
-struct hash<duckdb::timestamp_ms_t> {
-	std::size_t operator()(const duckdb::timestamp_ms_t &k) const {
-		using std::hash;
-		return hash<int64_t>()((int64_t)k);
-	}
-};
-template <>
-struct hash<duckdb::timestamp_ns_t> {
-	std::size_t operator()(const duckdb::timestamp_ns_t &k) const {
-		using std::hash;
-		return hash<int64_t>()((int64_t)k);
-	}
-};
-template <>
-struct hash<duckdb::timestamp_sec_t> {
-	std::size_t operator()(const duckdb::timestamp_sec_t &k) const {
-		using std::hash;
-		return hash<int64_t>()((int64_t)k);
-	}
-};
-template <>
-struct hash<duckdb::timestamp_tz_t> {
-	std::size_t operator()(const duckdb::timestamp_tz_t &k) const {
-		using std::hash;
-		return hash<int64_t>()((int64_t)k);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/types/type_map.hpp b/src/duckdb/src/include/duckdb/common/types/type_map.hpp
deleted file mode 100644
index 0d3566fc3..000000000
--- a/src/duckdb/src/include/duckdb/common/types/type_map.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/type_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-struct LogicalTypeHashFunction {
-	uint64_t operator()(const LogicalType &type) const {
-		return (uint64_t)type.Hash();
-	}
-};
-
-struct LogicalTypeEquality {
-	bool operator()(const LogicalType &a, const LogicalType &b) const {
-		return a == b;
-	}
-};
-
-template <typename T>
-using type_map_t = unordered_map<LogicalType, T, LogicalTypeHashFunction, LogicalTypeEquality>;
-
-using type_set_t = unordered_set<LogicalType, LogicalTypeHashFunction, LogicalTypeEquality>;
-
-struct LogicalTypeIdHashFunction {
-	uint64_t operator()(const LogicalTypeId &type_id) const {
-		return duckdb::Hash<uint8_t>((uint8_t)type_id);
-	}
-};
-
-struct LogicalTypeIdEquality {
-	bool operator()(const LogicalTypeId &a, const LogicalTypeId &b) const {
-		return a == b;
-	}
-};
-
-template <typename T>
-using type_id_map_t = unordered_map<LogicalTypeId, T, LogicalTypeIdHashFunction, LogicalTypeIdEquality>;
-
-using type_id_set_t = unordered_set<LogicalTypeId, LogicalTypeIdHashFunction, LogicalTypeIdEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/uhugeint.hpp b/src/duckdb/src/include/duckdb/common/types/uhugeint.hpp
deleted file mode 100644
index b38df8dd9..000000000
--- a/src/duckdb/src/include/duckdb/common/types/uhugeint.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/uhugeint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/type_util.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-namespace duckdb {
-
-//! The uhugeint class contains static operations for the UINT128 type
-class Uhugeint {
-public:
-	//! Convert a uhugeint object to a string
-	static string ToString(uhugeint_t input);
-
-	template <class T>
-	DUCKDB_API static bool TryCast(uhugeint_t input, T &result);
-
-	template <class T>
-	static T Cast(uhugeint_t input) {
-		T result = 0;
-		TryCast(input, result);
-		return result;
-	}
-
-	template <class T>
-	static bool TryConvert(T value, uhugeint_t &result);
-
-	template <class T>
-	static uhugeint_t Convert(T value) {
-		uhugeint_t result;
-		if (!TryConvert(value, result)) { // LCOV_EXCL_START
-			throw OutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<uhugeint_t>());
-		} // LCOV_EXCL_STOP
-		return result;
-	}
-
-	static bool TryNegate(uhugeint_t input, uhugeint_t &result);
-
-	// "The negative of an unsigned quantity is computed by subtracting its value from 2^n, where n is the number of
-	// bits in the promoted operand."
-	template <bool CHECK_OVERFLOW = true>
-	inline static void NegateInPlace(uhugeint_t &input) {
-		if (!TryNegate(input, input)) {
-			throw OutOfRangeException("UHUGEINT is out of range");
-		}
-	}
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static uhugeint_t Negate(uhugeint_t input) {
-		NegateInPlace<CHECK_OVERFLOW>(input);
-		return input;
-	}
-
-	static bool TryMultiply(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static uhugeint_t Multiply(uhugeint_t lhs, uhugeint_t rhs) {
-		uhugeint_t result;
-		if (!TryMultiply(lhs, rhs, result)) {
-			throw OutOfRangeException("Overflow in UHUGEINT multiplication!: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-		return result;
-	}
-
-	static bool TryDivMod(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result, uhugeint_t &remainder);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static uhugeint_t Divide(uhugeint_t lhs, uhugeint_t rhs) {
-		// division between two same-size unsigned integers can only go wrong with division by zero
-		if (rhs == 0) {
-			throw OutOfRangeException("Division of UHUGEINT by zero!");
-		}
-		return Divide<false>(lhs, rhs);
-	}
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static uhugeint_t Modulo(uhugeint_t lhs, uhugeint_t rhs) {
-		if (rhs == 0) {
-			throw OutOfRangeException("Modulo of UHUGEINT by zero!");
-		}
-		return Modulo<false>(lhs, rhs);
-	}
-
-	static bool TryAddInPlace(uhugeint_t &lhs, uhugeint_t rhs);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static uhugeint_t Add(uhugeint_t lhs, uhugeint_t rhs) {
-		if (!TryAddInPlace(lhs, rhs)) {
-			throw OutOfRangeException("Overflow in UHUGEINT addition: %s + %s", lhs.ToString(), rhs.ToString());
-		}
-		return lhs;
-	}
-
-	static bool TrySubtractInPlace(uhugeint_t &lhs, uhugeint_t rhs);
-
-	template <bool CHECK_OVERFLOW = true>
-	inline static uhugeint_t Subtract(uhugeint_t lhs, uhugeint_t rhs) {
-		if (!TrySubtractInPlace(lhs, rhs)) {
-			throw OutOfRangeException("Underflow in HUGEINT addition: %s - %s", lhs.ToString(), rhs.ToString());
-		}
-		return lhs;
-	}
-
-	// DivMod -> returns the result of the division (lhs / rhs), and fills up the remainder
-	static uhugeint_t DivMod(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &remainder);
-
-	static int Sign(hugeint_t n);
-	static hugeint_t Abs(hugeint_t n);
-
-	// comparison operators
-	// note that everywhere here we intentionally use bitwise ops
-	// this is because they seem to be consistently much faster (benchmarked on a Macbook Pro)
-	static bool Equals(uhugeint_t lhs, uhugeint_t rhs) {
-		int lower_equals = lhs.lower == rhs.lower;
-		int upper_equals = lhs.upper == rhs.upper;
-		return lower_equals & upper_equals;
-	}
-
-	static bool NotEquals(uhugeint_t lhs, uhugeint_t rhs) {
-		int lower_not_equals = lhs.lower != rhs.lower;
-		int upper_not_equals = lhs.upper != rhs.upper;
-		return lower_not_equals | upper_not_equals;
-	}
-
-	static bool GreaterThan(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger = lhs.lower > rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger);
-	}
-
-	static bool GreaterThanEquals(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger_equals = lhs.lower >= rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger_equals);
-	}
-
-	static bool LessThan(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller = lhs.lower < rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller);
-	}
-
-	static bool LessThanEquals(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller_equals = lhs.lower <= rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller_equals);
-	}
-
-	static const uhugeint_t POWERS_OF_TEN[40];
-};
-
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int8_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int16_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int32_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int64_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint8_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint16_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint32_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint64_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, hugeint_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uhugeint_t &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, float &result);
-template <>
-DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, double &result);
-
-template <>
-bool Uhugeint::TryConvert(int8_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(int16_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(int32_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(int64_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(uint8_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(uint16_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(uint32_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(uint64_t value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(float value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(double value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(long double value, uhugeint_t &result);
-template <>
-bool Uhugeint::TryConvert(const char *value, uhugeint_t &result);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/uuid.hpp b/src/duckdb/src/include/duckdb/common/types/uuid.hpp
deleted file mode 100644
index bf5ade17a..000000000
--- a/src/duckdb/src/include/duckdb/common/types/uuid.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/uuid.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-class ClientContext;
-class RandomEngine;
-
-//! The UUID class contains static operations for the UUID type
-class UUID {
-public:
-	constexpr static const uint8_t STRING_SIZE = 36;
-	//! Convert a uuid string to a hugeint object
-	static bool FromString(const string &str, hugeint_t &result);
-	//! Convert a uuid string to a hugeint object
-	static bool FromCString(const char *str, idx_t len, hugeint_t &result) {
-		return FromString(string(str, 0, len), result);
-	}
-	//! Convert a hugeint object to a uuid style string
-	static void ToString(hugeint_t input, char *buf);
-
-	//! Convert a uhugeint_t object to a uuid value
-	static hugeint_t FromUHugeint(uhugeint_t input);
-	//! Convert a uuid value to a uhugeint_t object
-	static uhugeint_t ToUHugeint(hugeint_t input);
-
-	//! Convert a hugeint object to a uuid style string
-	static hugeint_t GenerateRandomUUID(RandomEngine &engine);
-	static hugeint_t GenerateRandomUUID();
-
-	//! Convert a hugeint object to a uuid style string
-	static string ToString(hugeint_t input) {
-		char buff[STRING_SIZE];
-		ToString(input, buff);
-		return string(buff, STRING_SIZE);
-	}
-
-	static hugeint_t FromString(const string &str) {
-		hugeint_t result;
-		FromString(str, result);
-		return result;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp b/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp
deleted file mode 100644
index 05583cddd..000000000
--- a/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp
+++ /dev/null
@@ -1,484 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/validity_mask.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-struct SelectionVector;
-struct ValidityMask;
-
-template <typename V>
-struct TemplatedValidityData {
-	static constexpr const idx_t BITS_PER_VALUE = sizeof(V) * 8;
-	static constexpr const V MAX_ENTRY = V(~V(0));
-
-public:
-	inline explicit TemplatedValidityData(idx_t count) {
-		auto entry_count = EntryCount(count);
-		owned_data = make_unsafe_uniq_array_uninitialized<V>(entry_count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			owned_data[entry_idx] = MAX_ENTRY;
-		}
-	}
-	inline TemplatedValidityData(const V *validity_mask, idx_t count) {
-		D_ASSERT(validity_mask);
-		auto entry_count = EntryCount(count);
-		owned_data = make_unsafe_uniq_array_uninitialized<V>(entry_count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			owned_data[entry_idx] = validity_mask[entry_idx];
-		}
-	}
-
-	unsafe_unique_array<V> owned_data;
-
-public:
-	static inline idx_t EntryCount(idx_t count) {
-		return (count + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE;
-	}
-};
-
-using validity_t = uint64_t;
-
-struct ValidityData : TemplatedValidityData<validity_t> {
-public:
-	DUCKDB_API explicit ValidityData(idx_t count);
-	DUCKDB_API ValidityData(const ValidityMask &original, idx_t count);
-};
-
-//! Type used for validity masks
-template <typename V>
-struct TemplatedValidityMask {
-	using ValidityBuffer = TemplatedValidityData<V>;
-
-public:
-	static constexpr const idx_t BITS_PER_VALUE = ValidityBuffer::BITS_PER_VALUE;
-	static constexpr const idx_t STANDARD_ENTRY_COUNT = (STANDARD_VECTOR_SIZE + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE;
-	static constexpr const idx_t STANDARD_MASK_SIZE = STANDARD_ENTRY_COUNT * sizeof(validity_t);
-
-public:
-	inline TemplatedValidityMask() : validity_mask(nullptr), capacity(STANDARD_VECTOR_SIZE) {
-	}
-	inline explicit TemplatedValidityMask(idx_t target_count) : validity_mask(nullptr), capacity(target_count) {
-	}
-	inline explicit TemplatedValidityMask(V *ptr, idx_t capacity) : validity_mask(ptr), capacity(capacity) {
-	}
-	inline TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
-		Copy(original, count);
-	}
-
-	static inline idx_t ValidityMaskSize(idx_t count = STANDARD_VECTOR_SIZE) {
-		return ValidityBuffer::EntryCount(count) * sizeof(V);
-	}
-	inline bool AllValid() const {
-		return !validity_mask;
-	}
-	inline bool CheckAllValid(idx_t count) const {
-		return CountValid(count) == count;
-	}
-	inline bool CheckAllInvalid(idx_t count) const {
-		return CountValid(count) == 0;
-	}
-
-	inline bool CheckAllValid(idx_t to, idx_t from) const {
-		if (AllValid()) {
-			return true;
-		}
-		for (idx_t i = from; i < to; i++) {
-			if (!RowIsValid(i)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	idx_t CountValid(const idx_t count) const {
-		if (AllValid() || count == 0) {
-			return count;
-		}
-
-		idx_t valid = 0;
-		const auto entry_count = EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count;) {
-			auto entry = GetValidityEntry(entry_idx++);
-			// Handle ragged end (if not exactly multiple of BITS_PER_VALUE)
-			if (entry_idx == entry_count && count % BITS_PER_VALUE != 0) {
-				idx_t idx_in_entry;
-				GetEntryIndex(count, entry_idx, idx_in_entry);
-				for (idx_t i = 0; i < idx_in_entry; ++i) {
-					valid += idx_t(RowIsValid(entry, i));
-				}
-				break;
-			}
-
-			// Handle all set
-			if (AllValid(entry)) {
-				valid += BITS_PER_VALUE;
-				continue;
-			}
-
-			// Count partial entry (Kernighan's algorithm)
-			while (entry) {
-				entry &= (entry - 1);
-				++valid;
-			}
-		}
-
-		return valid;
-	}
-
-	inline V *GetData() const {
-		return validity_mask;
-	}
-	inline void Reset(idx_t target_count_p = STANDARD_VECTOR_SIZE) {
-		validity_mask = nullptr;
-		validity_data.reset();
-		capacity = target_count_p;
-	}
-
-	static inline idx_t EntryCount(idx_t count) {
-		return ValidityBuffer::EntryCount(count);
-	}
-	inline V GetValidityEntry(idx_t entry_idx) const {
-		if (!validity_mask) {
-			return ValidityBuffer::MAX_ENTRY;
-		}
-		return GetValidityEntryUnsafe(entry_idx);
-	}
-	inline V &GetValidityEntryUnsafe(idx_t entry_idx) const {
-		return validity_mask[entry_idx];
-	}
-	static inline bool AllValid(V entry) {
-		// Check if all the tuples that are covered by this entry (usually 64) are valid
-		return entry == ValidityBuffer::MAX_ENTRY;
-	}
-	static inline bool NoneValid(V entry) {
-		return entry == 0;
-	}
-	static inline bool RowIsValid(const V &entry, const idx_t &idx_in_entry) {
-		return entry & (V(1) << V(idx_in_entry));
-	}
-	static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {
-		entry_idx = row_idx / BITS_PER_VALUE;
-		idx_in_entry = row_idx % BITS_PER_VALUE;
-	}
-	//! Get an entry that has first-n bits set as valid and rest set as invalid
-	static inline V EntryWithValidBits(idx_t n) {
-		if (n == 0) {
-			return V(0);
-		}
-		return ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - n);
-	}
-	static inline idx_t SizeInBytes(idx_t n) {
-		return (n + BITS_PER_VALUE - 1) / BITS_PER_VALUE;
-	}
-
-	//! RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a
-	//! not-null check
-	inline bool RowIsValidUnsafe(idx_t row_idx) const {
-		D_ASSERT(validity_mask);
-		idx_t entry_idx, idx_in_entry;
-		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
-		auto entry = GetValidityEntry(entry_idx);
-		return RowIsValid(entry, idx_in_entry);
-	}
-
-	//! Returns true if a row is valid (i.e. not null), false otherwise
-	inline bool RowIsValid(idx_t row_idx) const {
-#ifdef DEBUG
-		if (row_idx >= capacity) {
-			throw InternalException("ValidityMask::RowIsValid - row_idx %d is out-of-range for mask with capacity %llu",
-			                        row_idx, capacity);
-		}
-#endif
-		if (!validity_mask) {
-			return true;
-		}
-		return RowIsValidUnsafe(row_idx);
-	}
-
-	//! Same as SetValid, but skips a null check on validity_mask
-	inline void SetValidUnsafe(idx_t row_idx) {
-		D_ASSERT(validity_mask);
-		idx_t entry_idx, idx_in_entry;
-		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
-		validity_mask[entry_idx] |= (V(1) << V(idx_in_entry));
-	}
-
-	//! Marks the entry at the specified row index as valid (i.e. not-null)
-	inline void SetValid(idx_t row_idx) {
-#ifdef DEBUG
-		if (row_idx >= capacity) {
-			throw InternalException("ValidityMask::SetValid - row_idx %d is out-of-range for mask with capacity %llu",
-			                        row_idx, capacity);
-		}
-#endif
-		if (!validity_mask) {
-			// if AllValid() we don't need to do anything
-			// the row is already valid
-			return;
-		}
-		SetValidUnsafe(row_idx);
-	}
-
-	//! Marks the bit at the specified entry as invalid (i.e. null)
-	inline void SetInvalidUnsafe(idx_t entry_idx, idx_t idx_in_entry) {
-		D_ASSERT(validity_mask);
-		validity_mask[entry_idx] &= ~(V(1) << V(idx_in_entry));
-	}
-
-	//! Marks the bit at the specified row index as invalid (i.e. null)
-	inline void SetInvalidUnsafe(idx_t row_idx) {
-		idx_t entry_idx, idx_in_entry;
-		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
-		SetInvalidUnsafe(entry_idx, idx_in_entry);
-	}
-
-	//! Marks the entry at the specified row index as invalid (i.e. null)
-	inline void SetInvalid(idx_t row_idx) {
-#ifdef DEBUG
-		if (row_idx >= capacity) {
-			throw InternalException("ValidityMask::SetInvalid - row_idx %d is out-of-range for mask with capacity %llu",
-			                        row_idx, capacity);
-		}
-#endif
-		if (!validity_mask) {
-			Initialize(capacity);
-		}
-		SetInvalidUnsafe(row_idx);
-	}
-
-	//! Mark the entry at the specified index as either valid or invalid (non-null or null)
-	inline void Set(idx_t row_idx, bool valid) {
-		if (valid) {
-			SetValid(row_idx);
-		} else {
-			SetInvalid(row_idx);
-		}
-	}
-
-	//! Ensure the validity mask is writable, allocating space if it is not initialized
-	inline void EnsureWritable() {
-		if (!validity_mask) {
-			Initialize();
-		}
-	}
-
-	//! Marks exactly "count" bits in the validity mask as invalid (null)
-	inline void SetAllInvalid(idx_t count) {
-		EnsureWritable();
-		if (count == 0) {
-			return;
-		}
-		auto last_entry_index = ValidityBuffer::EntryCount(count) - 1;
-		for (idx_t i = 0; i < last_entry_index; i++) {
-			validity_mask[i] = 0;
-		}
-		auto last_entry_bits = count % BITS_PER_VALUE;
-		validity_mask[last_entry_index] =
-		    (last_entry_bits == 0) ? 0 : static_cast<V>(ValidityBuffer::MAX_ENTRY << (last_entry_bits));
-	}
-
-	//! Marks exactly "count" bits in the validity mask as valid (not null)
-	inline void SetAllValid(idx_t count) {
-		EnsureWritable();
-		if (count == 0) {
-			return;
-		}
-		auto last_entry_index = ValidityBuffer::EntryCount(count) - 1;
-		for (idx_t i = 0; i < last_entry_index; i++) {
-			validity_mask[i] = ValidityBuffer::MAX_ENTRY;
-		}
-		auto last_entry_bits = count % BITS_PER_VALUE;
-		validity_mask[last_entry_index] |= (last_entry_bits == 0)
-		                                       ? ValidityBuffer::MAX_ENTRY
-		                                       : ~static_cast<V>(ValidityBuffer::MAX_ENTRY << (last_entry_bits));
-	}
-
-	inline bool IsMaskSet() const {
-		if (validity_mask) {
-			return true;
-		}
-		return false;
-	}
-
-public:
-	inline void Initialize(validity_t *validity, idx_t new_capacity) {
-		validity_data.reset();
-		validity_mask = validity;
-		capacity = new_capacity;
-	}
-	inline void Initialize(const TemplatedValidityMask &other) {
-		validity_mask = other.validity_mask;
-		validity_data = other.validity_data;
-		capacity = other.capacity;
-	}
-	inline void Initialize(idx_t count) {
-		capacity = count;
-		validity_data = make_buffer<ValidityBuffer>(count);
-		validity_mask = validity_data->owned_data.get();
-	}
-	inline void Initialize() {
-		Initialize(capacity);
-	}
-	inline void Copy(const TemplatedValidityMask &other, idx_t count) {
-		capacity = count;
-		if (other.AllValid()) {
-			validity_data = nullptr;
-			validity_mask = nullptr;
-		} else {
-			validity_data = make_buffer<ValidityBuffer>(other.validity_mask, count);
-			validity_mask = validity_data->owned_data.get();
-		}
-	}
-
-protected:
-	V *validity_mask;
-	buffer_ptr<ValidityBuffer> validity_data;
-	idx_t capacity;
-};
-
-struct ValidityMask : public TemplatedValidityMask<validity_t> {
-public:
-	inline ValidityMask() : TemplatedValidityMask(nullptr, STANDARD_VECTOR_SIZE) {
-	}
-	inline explicit ValidityMask(idx_t capacity) : TemplatedValidityMask(capacity) {
-	}
-	inline explicit ValidityMask(validity_t *ptr, idx_t capacity) : TemplatedValidityMask(ptr, capacity) {
-	}
-	inline ValidityMask(const ValidityMask &original, idx_t count) : TemplatedValidityMask(original, count) {
-	}
-
-public:
-	DUCKDB_API void Resize(idx_t new_size);
-	DUCKDB_API idx_t Capacity() const;
-	DUCKDB_API void SliceInPlace(const ValidityMask &other, idx_t target_offset, idx_t source_offset, idx_t count);
-	DUCKDB_API void Slice(const ValidityMask &other, idx_t source_offset, idx_t count);
-	DUCKDB_API void CopySel(const ValidityMask &other, const SelectionVector &sel, idx_t source_offset,
-	                        idx_t target_offset, idx_t count);
-	DUCKDB_API void Combine(const ValidityMask &other, idx_t count);
-	DUCKDB_API string ToString(idx_t count) const;
-	DUCKDB_API string ToString() const;
-
-	DUCKDB_API static bool IsAligned(idx_t count);
-
-	void Write(WriteStream &writer, idx_t count);
-	void Read(ReadStream &reader, idx_t count);
-};
-
-//===--------------------------------------------------------------------===//
-// ValidityArray
-//===--------------------------------------------------------------------===//
-struct ValidityArray {
-	inline ValidityArray() {
-	}
-
-	inline bool AllValid() const {
-		return !validity_mask;
-	}
-
-	inline void Initialize(idx_t count, bool initial = true) {
-		capacity = count;
-		validity_data = make_unsafe_uniq_array<bool>(count);
-		validity_mask = validity_data.get();
-		memset(validity_mask, initial, sizeof(bool) * count);
-	}
-	inline void InitializeEmpty(idx_t count) {
-		capacity = count;
-	}
-
-	idx_t Capacity() const {
-		return capacity;
-	}
-
-	//! RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a
-	//! not-null check
-	inline bool RowIsValidUnsafe(idx_t row_idx) const {
-		D_ASSERT(validity_mask);
-		return validity_mask[row_idx];
-	}
-
-	//! Returns true if a row is valid (i.e. not null), false otherwise
-	inline bool RowIsValid(idx_t row_idx) const {
-#ifdef DEBUG
-		if (row_idx >= capacity) {
-			throw InternalException("ValidityData::RowIsValid - row_idx %d is out-of-range for mask with capacity %llu",
-			                        row_idx, capacity);
-		}
-#endif
-		if (!validity_mask) {
-			return true;
-		}
-		return RowIsValidUnsafe(row_idx);
-	}
-
-	//! Same as SetValid, but skips a null check on validity_mask
-	inline void SetValidUnsafe(idx_t row_idx) {
-		D_ASSERT(validity_mask);
-		validity_mask[row_idx] = true;
-	}
-
-	//! Marks the entry at the specified row index as valid (i.e. not-null)
-	inline void SetValid(idx_t row_idx) {
-#ifdef DEBUG
-		if (row_idx >= capacity) {
-			throw InternalException("ValidityData::SetValid - row_idx %d is out-of-range for mask with capacity %llu",
-			                        row_idx, capacity);
-		}
-#endif
-		if (!validity_mask) {
-			// if AllValid() we don't need to do anything
-			// the row is already valid
-			return;
-		}
-
-		SetValidUnsafe(row_idx);
-	}
-
-	inline void Pack(ValidityMask &mask, const idx_t count) const {
-		if (AllValid()) {
-			mask.Reset(count);
-			return;
-		}
-		mask.Initialize(count);
-
-		const auto entire_entries = count / ValidityMask::BITS_PER_VALUE;
-		const auto ragged = count % ValidityMask::BITS_PER_VALUE;
-		auto bits = mask.GetData();
-		idx_t row_idx = 0;
-		for (idx_t i = 0; i < entire_entries; ++i) {
-			validity_t entry = 0;
-			for (idx_t j = 0; j < ValidityMask::BITS_PER_VALUE; ++j) {
-				if (RowIsValidUnsafe(row_idx++)) {
-					entry |= validity_t(1) << j;
-				}
-			}
-			*bits++ = entry;
-		}
-		if (ragged) {
-			validity_t entry = 0;
-			for (idx_t j = 0; j < ragged; ++j) {
-				if (RowIsValidUnsafe(row_idx++)) {
-					entry |= validity_t(1) << j;
-				}
-			}
-			*bits++ = entry;
-		}
-	}
-
-private:
-	bool *validity_mask = nullptr;
-	unsafe_unique_array<bool> validity_data;
-	idx_t capacity = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/value.hpp b/src/duckdb/src/include/duckdb/common/types/value.hpp
deleted file mode 100644
index 079541587..000000000
--- a/src/duckdb/src/include/duckdb/common/types/value.hpp
+++ /dev/null
@@ -1,642 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/datetime.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-
-namespace duckdb {
-
-class CastFunctionSet;
-struct GetCastFunctionInput;
-struct ExtraValueInfo;
-
-//! The Value object holds a single arbitrary value of any type that can be
-//! stored in the database.
-class Value {
-	friend struct StringValue;
-	friend struct StructValue;
-	friend struct ListValue;
-	friend struct UnionValue;
-	friend struct ArrayValue;
-	friend struct MapValue;
-
-public:
-	//! Create an empty NULL value of the specified type
-	DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL);
-	//! Create an INTEGER value
-	DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
-	//! Create a BOOLEAN value
-	explicit DUCKDB_API Value(bool val);
-	//! Create a BIGINT value
-	DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
-	//! Create a FLOAT value
-	DUCKDB_API Value(float val); // NOLINT: Allow implicit conversion from `float`
-	//! Create a DOUBLE value
-	DUCKDB_API Value(double val); // NOLINT: Allow implicit conversion from `double`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(const char *val); // NOLINT: Allow implicit conversion from `const char *`
-	//! Create a NULL value
-	DUCKDB_API Value(std::nullptr_t val); // NOLINT: Allow implicit conversion from `nullptr_t`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(string val); // NOLINT: Allow implicit conversion from `string`
-	//! Copy constructor
-	DUCKDB_API Value(const Value &other);
-	//! Move constructor
-	DUCKDB_API Value(Value &&other) noexcept;
-	//! Destructor
-	DUCKDB_API ~Value();
-
-	// copy assignment
-	DUCKDB_API Value &operator=(const Value &other);
-	// move assignment
-	DUCKDB_API Value &operator=(Value &&other) noexcept;
-
-	inline LogicalType &GetTypeMutable() {
-		return type_;
-	}
-	inline const LogicalType &type() const { // NOLINT
-		return type_;
-	}
-	inline bool IsNull() const {
-		return is_null;
-	}
-
-	//! Create the lowest possible value of a given type (numeric only)
-	DUCKDB_API static Value MinimumValue(const LogicalType &type);
-	//! Create the highest possible value of a given type (numeric only)
-	DUCKDB_API static Value MaximumValue(const LogicalType &type);
-	//! Create the negative infinite value of a given type (numeric only)
-	DUCKDB_API static Value NegativeInfinity(const LogicalType &type);
-	//! Create the positive infinite value of a given type (numeric only)
-	DUCKDB_API static Value Infinity(const LogicalType &type);
-	//! Create a Numeric value of the specified type with the specified value
-	DUCKDB_API static Value Numeric(const LogicalType &type, int64_t value);
-	DUCKDB_API static Value Numeric(const LogicalType &type, hugeint_t value);
-	DUCKDB_API static Value Numeric(const LogicalType &type, uhugeint_t value);
-
-	//! Create a boolean Value from a specified value
-	DUCKDB_API static Value BOOLEAN(bool value);
-	//! Create a tinyint Value from a specified value
-	DUCKDB_API static Value TINYINT(int8_t value);
-	//! Create a smallint Value from a specified value
-	DUCKDB_API static Value SMALLINT(int16_t value);
-	//! Create an integer Value from a specified value
-	DUCKDB_API static Value INTEGER(int32_t value);
-	//! Create a bigint Value from a specified value
-	DUCKDB_API static Value BIGINT(int64_t value);
-	//! Create an unsigned tinyint Value from a specified value
-	DUCKDB_API static Value UTINYINT(uint8_t value);
-	//! Create an unsigned smallint Value from a specified value
-	DUCKDB_API static Value USMALLINT(uint16_t value);
-	//! Create an unsigned integer Value from a specified value
-	DUCKDB_API static Value UINTEGER(uint32_t value);
-	//! Create an unsigned bigint Value from a specified value
-	DUCKDB_API static Value UBIGINT(uint64_t value);
-	//! Create a hugeint Value from a specified value
-	DUCKDB_API static Value HUGEINT(hugeint_t value);
-	//! Create a uhugeint Value from a specified value
-	DUCKDB_API static Value UHUGEINT(uhugeint_t value);
-	//! Create a uuid Value from a specified value
-	DUCKDB_API static Value UUID(const string &value);
-	//! Create a uuid Value from a specified value
-	DUCKDB_API static Value UUID(hugeint_t value);
-	//! Create a hash Value from a specified value
-	DUCKDB_API static Value HASH(hash_t value);
-	//! Create a pointer Value from a specified value
-	DUCKDB_API static Value POINTER(uintptr_t value);
-	//! Create a date Value from a specified date
-	DUCKDB_API static Value DATE(date_t date);
-	//! Create a date Value from a specified date
-	DUCKDB_API static Value DATE(int32_t year, int32_t month, int32_t day);
-	//! Create a time Value from a specified time
-	DUCKDB_API static Value TIME(dtime_t time);
-	DUCKDB_API static Value TIMETZ(dtime_tz_t time);
-	//! Create a time Value from a specified time
-	DUCKDB_API static Value TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros);
-	//! Create a timestamp Value from a specified date/time combination.
-	DUCKDB_API static Value TIMESTAMP(date_t date, dtime_t time);
-	//! Create a timestamp Value from a specified value.
-	DUCKDB_API static Value TIMESTAMP(timestamp_t timestamp);
-	//! Create a timestamp_s Value from a specified value.
-	DUCKDB_API static Value TIMESTAMPSEC(timestamp_sec_t timestamp);
-	//! Create a timestamp_ms Value from a specified value.
-	DUCKDB_API static Value TIMESTAMPMS(timestamp_ms_t timestamp);
-	//! Create a timestamp_ns Value from a specified value.
-	DUCKDB_API static Value TIMESTAMPNS(timestamp_ns_t timestamp);
-	//! Create a timestamp_tz Value from a specified value.
-	DUCKDB_API static Value TIMESTAMPTZ(timestamp_tz_t timestamp);
-	//! Create a timestamp Value from a specified timestamp in separate values
-	DUCKDB_API static Value TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
-	                                  int32_t micros);
-	DUCKDB_API static Value INTERVAL(int32_t months, int32_t days, int64_t micros);
-	DUCKDB_API static Value INTERVAL(interval_t interval);
-
-	// Create a enum Value from a specified uint value
-	DUCKDB_API static Value ENUM(uint64_t value, const LogicalType &original_type);
-
-	// Decimal values
-	DUCKDB_API static Value DECIMAL(int16_t value, uint8_t width, uint8_t scale);
-	DUCKDB_API static Value DECIMAL(int32_t value, uint8_t width, uint8_t scale);
-	DUCKDB_API static Value DECIMAL(int64_t value, uint8_t width, uint8_t scale);
-	DUCKDB_API static Value DECIMAL(hugeint_t value, uint8_t width, uint8_t scale);
-	//! Create a float Value from a specified value
-	DUCKDB_API static Value FLOAT(float value);
-	//! Create a double Value from a specified value
-	DUCKDB_API static Value DOUBLE(double value);
-	//! Create a struct value with given list of entries
-	DUCKDB_API static Value STRUCT(child_list_t<Value> values);
-	DUCKDB_API static Value STRUCT(const LogicalType &type, vector<Value> struct_values);
-	//! Create a list value with the given entries
-	DUCKDB_API static Value LIST(const LogicalType &child_type, vector<Value> values);
-	//! Create a list value with the given entries
-	//! The type of the first value determines the list type. The list cannot be empty.
-	DUCKDB_API static Value LIST(vector<Value> values);
-	// Create an array value with the given entries
-	DUCKDB_API static Value ARRAY(const LogicalType &type, vector<Value> values);
-	//! Create a map value with the given entries
-	DUCKDB_API static Value MAP(const LogicalType &child_type, vector<Value> values);
-	//! Create a map value with the given entries
-	DUCKDB_API static Value MAP(const LogicalType &key_type, const LogicalType &value_type, vector<Value> keys,
-	                            vector<Value> values);
-	//! Create a map value from a set of key-value pairs
-	DUCKDB_API static Value MAP(const unordered_map<string, string> &kv_pairs);
-
-	//! Create a union value from a selected value and a tag from a set of alternatives.
-	DUCKDB_API static Value UNION(child_list_t<LogicalType> members, uint8_t tag, Value value);
-
-	//! Create a blob Value from a data pointer and a length: no bytes are interpreted
-	DUCKDB_API static Value BLOB(const_data_ptr_t data, idx_t len);
-	static Value BLOB_RAW(const string &data) { // NOLINT
-		return Value::BLOB(const_data_ptr_cast(data.c_str()), data.size());
-	}
-	//! Creates a blob by casting a specified string to a blob (i.e. interpreting \x characters)
-	DUCKDB_API static Value BLOB(const string &data);
-	//! Creates a bitstring by casting a specified string to a bitstring
-	DUCKDB_API static Value BIT(const_data_ptr_t data, idx_t len);
-	DUCKDB_API static Value BIT(const string &data);
-	DUCKDB_API static Value VARINT(const_data_ptr_t data, idx_t len);
-	DUCKDB_API static Value VARINT(const string &data);
-
-	//! Creates an aggregate state
-	DUCKDB_API static Value AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len); // NOLINT
-
-	template <class T>
-	T GetValue() const;
-	template <class T>
-	static Value CreateValue(T value) {
-		static_assert(AlwaysFalse<T>::VALUE, "No specialization exists for this type");
-		return Value(nullptr);
-	}
-	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the
-	// type of the value. Only use this if you know what you are doing.
-	template <class T>
-	T GetValueUnsafe() const;
-	//! Returns a reference to the internal value. This can only be used for primitive types.
-	template <class T>
-	T &GetReferenceUnsafe();
-
-	//! Return a copy of this value
-	Value Copy() const {
-		return Value(*this);
-	}
-
-	//! Hashes the Value
-	DUCKDB_API hash_t Hash() const;
-	//! Convert this value to a string
-	DUCKDB_API string ToString() const;
-	//! Convert this value to a SQL-parseable string
-	DUCKDB_API string ToSQLString() const;
-
-	DUCKDB_API uintptr_t GetPointer() const;
-
-	//! Cast this value to another type, throws exception if its not possible
-	DUCKDB_API Value CastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
-	                        bool strict = false) const;
-	DUCKDB_API Value CastAs(ClientContext &context, const LogicalType &target_type, bool strict = false) const;
-	DUCKDB_API Value DefaultCastAs(const LogicalType &target_type, bool strict = false) const;
-	//! Tries to cast this value to another type, and stores the result in "new_value"
-	DUCKDB_API bool TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
-	                          Value &new_value, string *error_message, bool strict = false) const;
-	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, Value &new_value,
-	                          string *error_message, bool strict = false) const;
-	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
-	                                 bool strict = false) const;
-	//! Tries to cast this value to another type, and stores the result in THIS value again
-	DUCKDB_API bool TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
-	                          bool strict = false);
-	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, bool strict = false);
-	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, bool strict = false);
-
-	DUCKDB_API void Reinterpret(LogicalType new_type);
-
-	//! Serializes a Value to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Deserializes a Value from a blob
-	DUCKDB_API static Value Deserialize(Deserializer &deserializer);
-
-	//===--------------------------------------------------------------------===//
-	// Comparison Operators
-	//===--------------------------------------------------------------------===//
-	DUCKDB_API bool operator==(const Value &rhs) const;
-	DUCKDB_API bool operator!=(const Value &rhs) const;
-	DUCKDB_API bool operator<(const Value &rhs) const;
-	DUCKDB_API bool operator>(const Value &rhs) const;
-	DUCKDB_API bool operator<=(const Value &rhs) const;
-	DUCKDB_API bool operator>=(const Value &rhs) const;
-
-	DUCKDB_API bool operator==(const int64_t &rhs) const;
-	DUCKDB_API bool operator!=(const int64_t &rhs) const;
-	DUCKDB_API bool operator<(const int64_t &rhs) const;
-	DUCKDB_API bool operator>(const int64_t &rhs) const;
-	DUCKDB_API bool operator<=(const int64_t &rhs) const;
-	DUCKDB_API bool operator>=(const int64_t &rhs) const;
-
-	DUCKDB_API static bool FloatIsFinite(float value);
-	DUCKDB_API static bool DoubleIsFinite(double value);
-	template <class T>
-	static bool IsNan(T value) {
-		throw InternalException("Unimplemented template type for Value::IsNan");
-	}
-	template <class T>
-	static bool IsFinite(T value) {
-		return true;
-	}
-	DUCKDB_API static bool StringIsValid(const char *str, idx_t length);
-	static bool StringIsValid(const string &str) {
-		return StringIsValid(str.c_str(), str.size());
-	}
-
-	//! Returns true if the values are (approximately) equivalent. Note this is NOT the SQL equivalence. For this
-	//! function, NULL values are equivalent and floating point values that are close are equivalent.
-	DUCKDB_API static bool ValuesAreEqual(CastFunctionSet &set, GetCastFunctionInput &get_input,
-	                                      const Value &result_value, const Value &value);
-	DUCKDB_API static bool ValuesAreEqual(ClientContext &context, const Value &result_value, const Value &value);
-	DUCKDB_API static bool DefaultValuesAreEqual(const Value &result_value, const Value &value);
-	//! Returns true if the values are not distinct from each other, following SQL semantics for NOT DISTINCT FROM.
-	DUCKDB_API static bool NotDistinctFrom(const Value &lvalue, const Value &rvalue);
-
-	friend std::ostream &operator<<(std::ostream &out, const Value &val) {
-		out << val.ToString();
-		return out;
-	}
-	DUCKDB_API void Print() const;
-
-private:
-	void SerializeInternal(Serializer &serializer, bool serialize_type) const;
-	static void SerializeChildren(Serializer &serializer, const vector<Value> &children,
-	                              const LogicalType &parent_type);
-
-private:
-	//! The logical of the value
-	LogicalType type_; // NOLINT
-
-	//! Whether or not the value is NULL
-	bool is_null;
-
-	//! The value of the object, if it is of a constant size Type
-	union Val {
-		bool boolean;
-		int8_t tinyint;
-		int16_t smallint;
-		int32_t integer;
-		int64_t bigint;
-		uint8_t utinyint;
-		uint16_t usmallint;
-		uint32_t uinteger;
-		uint64_t ubigint;
-		hugeint_t hugeint;
-		uhugeint_t uhugeint;
-		float float_;   // NOLINT
-		double double_; // NOLINT
-		uintptr_t pointer;
-		uint64_t hash;
-		date_t date;
-		dtime_t time;
-		dtime_tz_t timetz;
-		timestamp_t timestamp;
-		timestamp_sec_t timestamp_s;
-		timestamp_ms_t timestamp_ms;
-		timestamp_ns_t timestamp_ns;
-		timestamp_tz_t timestamp_tz;
-		interval_t interval;
-	} value_; // NOLINT
-
-	shared_ptr<ExtraValueInfo> value_info_; // NOLINT
-
-private:
-	template <class T>
-	T GetValueInternal() const;
-};
-
-//===--------------------------------------------------------------------===//
-// Type-specific getters
-//===--------------------------------------------------------------------===//
-// Note that these are equivalent to calling GetValueUnsafe<X>, meaning no cast will be performed
-// instead, an assertion will be triggered if the value is not of the correct type
-struct BooleanValue {
-	DUCKDB_API static bool Get(const Value &value);
-};
-
-struct TinyIntValue {
-	DUCKDB_API static int8_t Get(const Value &value);
-};
-
-struct SmallIntValue {
-	DUCKDB_API static int16_t Get(const Value &value);
-};
-
-struct IntegerValue {
-	DUCKDB_API static int32_t Get(const Value &value);
-};
-
-struct BigIntValue {
-	DUCKDB_API static int64_t Get(const Value &value);
-};
-
-struct HugeIntValue {
-	DUCKDB_API static hugeint_t Get(const Value &value);
-};
-
-struct UTinyIntValue {
-	DUCKDB_API static uint8_t Get(const Value &value);
-};
-
-struct USmallIntValue {
-	DUCKDB_API static uint16_t Get(const Value &value);
-};
-
-struct UIntegerValue {
-	DUCKDB_API static uint32_t Get(const Value &value);
-};
-
-struct UBigIntValue {
-	DUCKDB_API static uint64_t Get(const Value &value);
-};
-
-struct UhugeIntValue {
-	DUCKDB_API static uhugeint_t Get(const Value &value);
-};
-
-struct FloatValue {
-	DUCKDB_API static float Get(const Value &value);
-};
-
-struct DoubleValue {
-	DUCKDB_API static double Get(const Value &value);
-};
-
-struct StringValue {
-	DUCKDB_API static const string &Get(const Value &value);
-};
-
-struct DateValue {
-	DUCKDB_API static date_t Get(const Value &value);
-};
-
-struct TimeValue {
-	DUCKDB_API static dtime_t Get(const Value &value);
-};
-
-struct TimestampValue {
-	DUCKDB_API static timestamp_t Get(const Value &value);
-};
-
-struct TimestampSValue {
-	DUCKDB_API static timestamp_sec_t Get(const Value &value);
-};
-
-struct TimestampMSValue {
-	DUCKDB_API static timestamp_ms_t Get(const Value &value);
-};
-
-struct TimestampNSValue {
-	DUCKDB_API static timestamp_ns_t Get(const Value &value);
-};
-
-struct TimestampTZValue {
-	DUCKDB_API static timestamp_tz_t Get(const Value &value);
-};
-
-struct IntervalValue {
-	DUCKDB_API static interval_t Get(const Value &value);
-};
-
-struct StructValue {
-	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
-};
-
-struct MapValue {
-	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
-};
-
-struct ListValue {
-	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
-};
-
-struct ArrayValue {
-	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
-};
-
-struct UnionValue {
-	DUCKDB_API static const Value &GetValue(const Value &value);
-	DUCKDB_API static uint8_t GetTag(const Value &value);
-	DUCKDB_API static const LogicalType &GetType(const Value &value);
-};
-
-//! Return the internal integral value for any type that is stored as an integral value internally
-//! This can be used on values of type integer, uinteger, but also date, timestamp, decimal, etc
-struct IntegralValue {
-	static hugeint_t Get(const Value &value);
-};
-
-template <>
-Value DUCKDB_API Value::CreateValue(bool value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint8_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint16_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint32_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint64_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int8_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int16_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int32_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int64_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(hugeint_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uhugeint_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(date_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(dtime_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(dtime_tz_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(timestamp_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(timestamp_sec_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(timestamp_ms_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(timestamp_ns_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(timestamp_tz_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(const char *value);
-template <>
-Value DUCKDB_API Value::CreateValue(string value);
-template <>
-Value DUCKDB_API Value::CreateValue(string_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(float value);
-template <>
-Value DUCKDB_API Value::CreateValue(double value);
-template <>
-Value DUCKDB_API Value::CreateValue(interval_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(Value value);
-
-template <>
-DUCKDB_API bool Value::GetValue() const;
-template <>
-DUCKDB_API int8_t Value::GetValue() const;
-template <>
-DUCKDB_API int16_t Value::GetValue() const;
-template <>
-DUCKDB_API int32_t Value::GetValue() const;
-template <>
-DUCKDB_API int64_t Value::GetValue() const;
-template <>
-DUCKDB_API uint8_t Value::GetValue() const;
-template <>
-DUCKDB_API uint16_t Value::GetValue() const;
-template <>
-DUCKDB_API uint32_t Value::GetValue() const;
-template <>
-DUCKDB_API uint64_t Value::GetValue() const;
-template <>
-DUCKDB_API hugeint_t Value::GetValue() const;
-template <>
-DUCKDB_API uhugeint_t Value::GetValue() const;
-template <>
-DUCKDB_API string Value::GetValue() const;
-template <>
-DUCKDB_API float Value::GetValue() const;
-template <>
-DUCKDB_API double Value::GetValue() const;
-template <>
-DUCKDB_API date_t Value::GetValue() const;
-template <>
-DUCKDB_API dtime_t Value::GetValue() const;
-template <>
-DUCKDB_API dtime_tz_t Value::GetValue() const;
-template <>
-DUCKDB_API timestamp_t Value::GetValue() const;
-template <>
-DUCKDB_API timestamp_sec_t Value::GetValue() const;
-template <>
-DUCKDB_API timestamp_ms_t Value::GetValue() const;
-template <>
-DUCKDB_API timestamp_ns_t Value::GetValue() const;
-template <>
-DUCKDB_API timestamp_tz_t Value::GetValue() const;
-template <>
-DUCKDB_API interval_t Value::GetValue() const;
-template <>
-DUCKDB_API Value Value::GetValue() const;
-
-template <>
-DUCKDB_API bool Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int8_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int16_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int32_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int64_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API hugeint_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uhugeint_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint8_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint16_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint32_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint64_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API string Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API string_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API float Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API double Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API date_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API dtime_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API dtime_tz_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API timestamp_sec_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API timestamp_ms_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API timestamp_ns_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API timestamp_tz_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API interval_t Value::GetValueUnsafe() const;
-
-template <>
-DUCKDB_API bool Value::IsNan(float input);
-template <>
-DUCKDB_API bool Value::IsNan(double input);
-
-template <>
-DUCKDB_API bool Value::IsFinite(float input);
-template <>
-DUCKDB_API bool Value::IsFinite(double input);
-template <>
-DUCKDB_API bool Value::IsFinite(date_t input);
-template <>
-DUCKDB_API bool Value::IsFinite(timestamp_t input);
-template <>
-DUCKDB_API bool Value::IsFinite(timestamp_sec_t input);
-template <>
-DUCKDB_API bool Value::IsFinite(timestamp_ms_t input);
-template <>
-DUCKDB_API bool Value::IsFinite(timestamp_ns_t input);
-template <>
-DUCKDB_API bool Value::IsFinite(timestamp_tz_t input);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/value_map.hpp b/src/duckdb/src/include/duckdb/common/types/value_map.hpp
deleted file mode 100644
index dfe4d77de..000000000
--- a/src/duckdb/src/include/duckdb/common/types/value_map.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/value_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-struct ValueHashFunction {
-	uint64_t operator()(const Value &value) const {
-		return (uint64_t)value.Hash();
-	}
-};
-
-struct ValueEquality {
-	bool operator()(const Value &a, const Value &b) const {
-		return Value::NotDistinctFrom(a, b);
-	}
-};
-
-template <typename T>
-using value_map_t = unordered_map<Value, T, ValueHashFunction, ValueEquality>;
-
-using value_set_t = unordered_set<Value, ValueHashFunction, ValueEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/varint.hpp b/src/duckdb/src/include/duckdb/common/types/varint.hpp
deleted file mode 100644
index 7a4b5b485..000000000
--- a/src/duckdb/src/include/duckdb/common/types/varint.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/varint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-
-namespace duckdb {
-//! The Varint class is a static class that holds helper functions for the Varint type.
-class Varint {
-public:
-	//! Header size of a Varint is always 3 bytes.
-	DUCKDB_API static constexpr uint8_t VARINT_HEADER_SIZE = 3;
-	//! Verifies if a Varint is valid. i.e., if it has 3 header bytes. The header correctly represents the number of
-	//! data bytes, and the data bytes has no leading zero bytes.
-	DUCKDB_API static void Verify(const string_t &input);
-
-	//! Sets the header of a varint (i.e., char* blob), depending on the number of bytes that varint needs and if it's a
-	//! negative number
-	DUCKDB_API static void SetHeader(char *blob, uint64_t number_of_bytes, bool is_negative);
-	//! Initializes and returns a blob with value 0, allocated in Vector& result
-	DUCKDB_API static string_t InitializeVarintZero(Vector &result);
-	DUCKDB_API static string InitializeVarintZero();
-
-	//! Switch Case of To Varint Convertion
-	DUCKDB_API static BoundCastInfo NumericToVarintCastSwitch(const LogicalType &source);
-
-	//! ----------------------------------- Varchar Cast ----------------------------------- //
-	//! Function to prepare a varchar for conversion. We trim zero's, check for negative values, and what-not
-	//! Returns false if this is an invalid varchar
-	DUCKDB_API static bool VarcharFormatting(const string_t &value, idx_t &start_pos, idx_t &end_pos, bool &is_negative,
-	                                         bool &is_zero);
-
-	//! Converts a char to a Digit
-	DUCKDB_API static int CharToDigit(char c);
-	//! Converts a Digit to a char
-	DUCKDB_API static char DigitToChar(int digit);
-	//! Function to convert a string_t into a vector of bytes
-	DUCKDB_API static void GetByteArray(vector<uint8_t> &byte_array, bool &is_negative, const string_t &blob);
-	//! Function to create a VARINT blob from a byte array containing the absolute value, plus an is_negative bool
-	DUCKDB_API static string FromByteArray(uint8_t *data, idx_t size, bool is_negative);
-	//! Function to convert VARINT blob to a VARCHAR
-	DUCKDB_API static string VarIntToVarchar(const string_t &blob);
-	//! Function to convert Varchar to VARINT blob
-	DUCKDB_API static string VarcharToVarInt(const string_t &value);
-	//! ----------------------------------- Double Cast ----------------------------------- //
-	DUCKDB_API static bool VarintToDouble(const string_t &blob, double &result, bool &strict);
-};
-
-//! ----------------------------------- (u)Integral Cast ----------------------------------- //
-struct IntCastToVarInt {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		return IntToVarInt(result, input);
-	}
-};
-
-//! ----------------------------------- (u)HugeInt Cast ----------------------------------- //
-struct HugeintCastToVarInt {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw InternalException("Unsupported type for cast to VARINT");
-	}
-};
-
-struct TryCastToVarInt {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
-		throw InternalException("Unsupported type for try cast to VARINT");
-	}
-};
-
-template <>
-DUCKDB_API bool TryCastToVarInt::Operation(double double_value, string_t &result_value, Vector &result,
-                                           CastParameters &parameters);
-
-template <>
-DUCKDB_API bool TryCastToVarInt::Operation(float float_value, string_t &result_value, Vector &result,
-                                           CastParameters &parameters);
-
-template <>
-DUCKDB_API bool TryCastToVarInt::Operation(string_t input_value, string_t &result_value, Vector &result,
-                                           CastParameters &parameters);
-
-struct VarIntCastToVarchar {
-	template <class SRC>
-	DUCKDB_API static inline string_t Operation(SRC input, Vector &result) {
-		return StringVector::AddStringOrBlob(result, Varint::VarIntToVarchar(input));
-	}
-};
-
-struct VarintToDoubleCast {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		return Varint::VarintToDouble(input, result, strict);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/vector.hpp b/src/duckdb/src/include/duckdb/common/types/vector.hpp
deleted file mode 100644
index 61e0b714e..000000000
--- a/src/duckdb/src/include/duckdb/common/types/vector.hpp
+++ /dev/null
@@ -1,610 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bitset.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/vector_type.hpp"
-#include "duckdb/common/types/selection_vector.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-
-class VectorCache;
-class VectorStructBuffer;
-class VectorListBuffer;
-struct SelCache;
-
-struct UnifiedVectorFormat {
-	DUCKDB_API UnifiedVectorFormat();
-	// disable copy constructors
-	UnifiedVectorFormat(const UnifiedVectorFormat &other) = delete;
-	UnifiedVectorFormat &operator=(const UnifiedVectorFormat &) = delete;
-	//! enable move constructors
-	DUCKDB_API UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept;
-	DUCKDB_API UnifiedVectorFormat &operator=(UnifiedVectorFormat &&) noexcept;
-
-	const SelectionVector *sel;
-	data_ptr_t data;
-	ValidityMask validity;
-	SelectionVector owned_sel;
-
-	template <class T>
-	static inline const T *GetData(const UnifiedVectorFormat &format) {
-		return reinterpret_cast<const T *>(format.data);
-	}
-	template <class T>
-	static inline T *GetDataNoConst(UnifiedVectorFormat &format) {
-		return reinterpret_cast<T *>(format.data);
-	}
-};
-
-struct RecursiveUnifiedVectorFormat {
-	UnifiedVectorFormat unified;
-	vector<RecursiveUnifiedVectorFormat> children;
-	LogicalType logical_type;
-};
-
-//! This is a helper data structure. It contains all fields necessary to resize a vector.
-struct ResizeInfo {
-	ResizeInfo(Vector &vec, data_ptr_t data, optional_ptr<VectorBuffer> buffer, const idx_t multiplier)
-	    : vec(vec), data(data), buffer(buffer), multiplier(multiplier) {
-	}
-
-	Vector &vec;
-	data_ptr_t data;
-	optional_ptr<VectorBuffer> buffer;
-	idx_t multiplier;
-};
-
-struct ConsecutiveChildListInfo {
-	ConsecutiveChildListInfo() : is_constant(true), needs_slicing(false), child_list_info(list_entry_t(0, 0)) {
-	}
-	bool is_constant;
-	bool needs_slicing;
-	list_entry_t child_list_info;
-};
-
-//! Vector of values of a specified PhysicalType.
-class Vector {
-	friend struct ConstantVector;
-	friend struct DictionaryVector;
-	friend struct FlatVector;
-	friend struct ListVector;
-	friend struct StringVector;
-	friend struct FSSTVector;
-	friend struct StructVector;
-	friend struct UnionVector;
-	friend struct SequenceVector;
-	friend struct ArrayVector;
-
-	friend class DataChunk;
-	friend class VectorCacheBuffer;
-
-public:
-	//! Create a vector that references the other vector
-	DUCKDB_API Vector(Vector &other);
-	//! Create a vector that slices another vector
-	DUCKDB_API explicit Vector(const Vector &other, const SelectionVector &sel, idx_t count);
-	//! Create a vector that slices another vector between a pair of offsets
-	DUCKDB_API explicit Vector(const Vector &other, idx_t offset, idx_t end);
-	//! Create a vector of size one holding the passed on value
-	DUCKDB_API explicit Vector(const Value &value);
-	//! Create a vector of size tuple_count (non-standard)
-	DUCKDB_API explicit Vector(LogicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
-	//! Create an empty standard vector with a type, equivalent to calling Vector(type, true, false)
-	DUCKDB_API explicit Vector(const VectorCache &cache);
-	//! Create a non-owning vector that references the specified data
-	DUCKDB_API Vector(LogicalType type, data_ptr_t dataptr);
-	//! Create an owning vector that holds at most STANDARD_VECTOR_SIZE entries.
-	/*!
-	    Create a new vector
-	    If create_data is true, the vector will be an owning empty vector.
-	    If initialize_to_zero is true, the allocated data will be zero-initialized.
-	*/
-	DUCKDB_API Vector(LogicalType type, bool create_data, bool initialize_to_zero,
-	                  idx_t capacity = STANDARD_VECTOR_SIZE);
-	// implicit copying of Vectors is not allowed
-	Vector(const Vector &) = delete;
-	// but moving of vectors is allowed
-	DUCKDB_API Vector(Vector &&other) noexcept;
-
-public:
-	//! Create a vector that references the specified value.
-	DUCKDB_API void Reference(const Value &value);
-	//! Causes this vector to reference the data held by the other vector.
-	//! The type of the "other" vector should match the type of this vector
-	DUCKDB_API void Reference(const Vector &other);
-	//! Reinterpret the data of the other vector as the type of this vector
-	//! Note that this takes the data of the other vector as-is and places it in this vector
-	//! Without changing the type of this vector
-	DUCKDB_API void Reinterpret(const Vector &other);
-
-	//! Causes this vector to reference the data held by the other vector, changes the type if required.
-	DUCKDB_API void ReferenceAndSetType(const Vector &other);
-
-	//! Resets a vector from a vector cache.
-	//! This turns the vector back into an empty FlatVector with STANDARD_VECTOR_SIZE entries.
-	//! The VectorCache is used so this can be done without requiring any allocations.
-	DUCKDB_API void ResetFromCache(const VectorCache &cache);
-
-	//! Creates a reference to a slice of the other vector
-	DUCKDB_API void Slice(const Vector &other, idx_t offset, idx_t end);
-	//! Creates a reference to a slice of the other vector
-	DUCKDB_API void Slice(const Vector &other, const SelectionVector &sel, idx_t count);
-	//! Turns the vector into a dictionary vector with the specified dictionary
-	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count);
-	//! Slice the vector, keeping the result around in a cache or potentially using the cache instead of slicing
-	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count, SelCache &cache);
-	//! Turn this vector into a dictionary vector
-	DUCKDB_API void Dictionary(idx_t dictionary_size, const SelectionVector &sel, idx_t count);
-	//! Creates a reference to a dictionary of the other vector
-	DUCKDB_API void Dictionary(const Vector &dict, idx_t dictionary_size, const SelectionVector &sel, idx_t count);
-
-	//! Creates the data of this vector with the specified type. Any data that
-	//! is currently in the vector is destroyed.
-	DUCKDB_API void Initialize(bool initialize_to_zero = false, idx_t capacity = STANDARD_VECTOR_SIZE);
-
-	//! Converts this Vector to a printable string representation
-	DUCKDB_API string ToString(idx_t count) const;
-	DUCKDB_API void Print(idx_t count) const;
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print() const;
-
-	//! Flatten the vector, removing any compression and turning it into a FLAT_VECTOR
-	DUCKDB_API void Flatten(idx_t count);
-	DUCKDB_API void Flatten(const SelectionVector &sel, idx_t count);
-	//! Creates a UnifiedVectorFormat of a vector
-	//! The UnifiedVectorFormat allows efficient reading of vectors regardless of their vector type
-	//! It contains (1) a data pointer, (2) a validity mask, and (3) a selection vector
-	//! Access to the individual vector elements can be performed through data_pointer[sel_idx[i]]/validity[sel_idx[i]]
-	//! The most common vector types (flat, constant & dictionary) can be converted to the canonical format "for free"
-	//! ToUnifiedFormat was originally called Orrify, as a tribute to Orri Erling who came up with it
-	DUCKDB_API void ToUnifiedFormat(idx_t count, UnifiedVectorFormat &data);
-	//! Recursively calls UnifiedVectorFormat on a vector and its child vectors (for nested types)
-	static void RecursiveToUnifiedFormat(Vector &input, idx_t count, RecursiveUnifiedVectorFormat &data);
-
-	//! Turn the vector into a sequence vector
-	DUCKDB_API void Sequence(int64_t start, int64_t increment, idx_t count);
-
-	//! Verify that the Vector is in a consistent, not corrupt state. DEBUG
-	//! FUNCTION ONLY!
-	DUCKDB_API void Verify(idx_t count);
-	//! Asserts that the CheckMapValidity returns MapInvalidReason::VALID
-	DUCKDB_API static void VerifyMap(Vector &map, const SelectionVector &sel, idx_t count);
-	DUCKDB_API static void VerifyUnion(Vector &map, const SelectionVector &sel, idx_t count);
-	DUCKDB_API static void Verify(Vector &vector, const SelectionVector &sel, idx_t count);
-	DUCKDB_API void UTFVerify(idx_t count);
-	DUCKDB_API void UTFVerify(const SelectionVector &sel, idx_t count);
-
-	//! Returns the [index] element of the Vector as a Value.
-	DUCKDB_API Value GetValue(idx_t index) const;
-	//! Sets the [index] element of the Vector to the specified Value.
-	DUCKDB_API void SetValue(idx_t index, const Value &val);
-
-	inline void SetAuxiliary(buffer_ptr<VectorBuffer> new_buffer) {
-		auxiliary = std::move(new_buffer);
-	};
-
-	inline void CopyBuffer(Vector &other) {
-		buffer = other.buffer;
-		data = other.data;
-	}
-
-	//! Resizes the vector.
-	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
-	//! Returns a vector of ResizeInfo containing each (nested) vector to resize.
-	DUCKDB_API void FindResizeInfos(vector<ResizeInfo> &resize_infos, const idx_t multiplier);
-
-	DUCKDB_API void Serialize(Serializer &serializer, idx_t count);
-	DUCKDB_API void Deserialize(Deserializer &deserializer, idx_t count);
-
-	idx_t GetAllocationSize(idx_t cardinality) const;
-
-	// Getters
-	inline VectorType GetVectorType() const {
-		return vector_type;
-	}
-	inline const LogicalType &GetType() const {
-		return type;
-	}
-	inline data_ptr_t GetData() {
-		return data;
-	}
-
-	inline buffer_ptr<VectorBuffer> GetAuxiliary() {
-		return auxiliary;
-	}
-
-	inline buffer_ptr<VectorBuffer> GetBuffer() {
-		return buffer;
-	}
-
-	// Setters
-	DUCKDB_API void SetVectorType(VectorType vector_type);
-
-	// Transform vector to an equivalent dictionary vector
-	static void DebugTransformToDictionary(Vector &vector, idx_t count);
-	// Transform vector to an equivalent nested vector
-	static void DebugShuffleNestedVector(Vector &vector, idx_t count);
-
-private:
-	//! Returns the [index] element of the Vector as a Value.
-	static Value GetValue(const Vector &v, idx_t index);
-	//! Returns the [index] element of the Vector as a Value.
-	static Value GetValueInternal(const Vector &v, idx_t index);
-
-protected:
-	//! The vector type specifies how the data of the vector is physically stored (i.e. if it is a single repeated
-	//! constant, if it is compressed)
-	VectorType vector_type;
-	//! The type of the elements stored in the vector (e.g. integer, float)
-	LogicalType type;
-	//! A pointer to the data.
-	data_ptr_t data;
-	//! The validity mask of the vector
-	ValidityMask validity;
-	//! The main buffer holding the data of the vector
-	buffer_ptr<VectorBuffer> buffer;
-	//! The buffer holding auxiliary data of the vector
-	//! e.g. a string vector uses this to store strings
-	buffer_ptr<VectorBuffer> auxiliary;
-};
-
-//! The DictionaryBuffer holds a selection vector
-class VectorChildBuffer : public VectorBuffer {
-public:
-	explicit VectorChildBuffer(Vector vector)
-	    : VectorBuffer(VectorBufferType::VECTOR_CHILD_BUFFER), data(std::move(vector)) {
-	}
-
-public:
-	Vector data;
-};
-
-struct ConstantVector {
-	static inline const_data_ptr_t GetData(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR ||
-		         vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return vector.data;
-	}
-	static inline data_ptr_t GetData(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR ||
-		         vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return vector.data;
-	}
-	template <class T>
-	static inline const T *GetData(const Vector &vector) {
-		return (const T *)ConstantVector::GetData(vector);
-	}
-	template <class T>
-	static inline T *GetData(Vector &vector) {
-		return (T *)ConstantVector::GetData(vector);
-	}
-	static inline bool IsNull(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-		return !vector.validity.RowIsValid(0);
-	}
-	DUCKDB_API static void SetNull(Vector &vector, bool is_null);
-	static inline ValidityMask &Validity(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-		return vector.validity;
-	}
-	DUCKDB_API static const SelectionVector *ZeroSelectionVector(idx_t count, SelectionVector &owned_sel);
-	DUCKDB_API static const SelectionVector *ZeroSelectionVector();
-	//! Turns "vector" into a constant vector by referencing a value within the source vector
-	DUCKDB_API static void Reference(Vector &vector, Vector &source, idx_t position, idx_t count);
-
-	static const sel_t ZERO_VECTOR[STANDARD_VECTOR_SIZE];
-};
-
-struct DictionaryVector {
-	static void VerifyDictionary(const Vector &vector) {
-#ifdef DUCKDB_DEBUG_NO_SAFETY
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-#else
-		if (vector.GetVectorType() != VectorType::DICTIONARY_VECTOR) {
-			throw InternalException(
-			    "Operation requires a dictionary vector but a non-dictionary vector was encountered");
-		}
-#endif
-	}
-	static inline const SelectionVector &SelVector(const Vector &vector) {
-		VerifyDictionary(vector);
-		return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
-	}
-	static inline SelectionVector &SelVector(Vector &vector) {
-		VerifyDictionary(vector);
-		return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
-	}
-	static inline const Vector &Child(const Vector &vector) {
-		VerifyDictionary(vector);
-		return vector.auxiliary->Cast<VectorChildBuffer>().data;
-	}
-	static inline Vector &Child(Vector &vector) {
-		VerifyDictionary(vector);
-		return vector.auxiliary->Cast<VectorChildBuffer>().data;
-	}
-	static inline optional_idx DictionarySize(const Vector &vector) {
-		VerifyDictionary(vector);
-		return vector.buffer->Cast<DictionaryBuffer>().GetDictionarySize();
-	}
-	static inline const string &DictionaryId(const Vector &vector) {
-		VerifyDictionary(vector);
-		return vector.buffer->Cast<DictionaryBuffer>().GetDictionaryId();
-	}
-	static inline void SetDictionaryId(Vector &vector, string new_id) {
-		VerifyDictionary(vector);
-		vector.buffer->Cast<DictionaryBuffer>().SetDictionaryId(std::move(new_id));
-	}
-};
-
-struct FlatVector {
-	static void VerifyFlatVector(const Vector &vector) {
-#ifdef DUCKDB_DEBUG_NO_SAFETY
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-#else
-		if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
-			throw InternalException("Operation requires a flat vector but a non-flat vector was encountered");
-		}
-#endif
-	}
-
-	static inline data_ptr_t GetData(Vector &vector) {
-		return ConstantVector::GetData(vector);
-	}
-	template <class T>
-	static inline const T *GetData(const Vector &vector) {
-		return ConstantVector::GetData<T>(vector);
-	}
-	template <class T>
-	static inline T *GetData(Vector &vector) {
-		return ConstantVector::GetData<T>(vector);
-	}
-	static inline void SetData(Vector &vector, data_ptr_t data) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		vector.data = data;
-	}
-	template <class T>
-	static inline T GetValue(Vector &vector, idx_t idx) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return FlatVector::GetData<T>(vector)[idx];
-	}
-	static inline const ValidityMask &Validity(const Vector &vector) {
-		VerifyFlatVector(vector);
-		return vector.validity;
-	}
-	static inline ValidityMask &Validity(Vector &vector) {
-		VerifyFlatVector(vector);
-		return vector.validity;
-	}
-	static inline void SetValidity(Vector &vector, const ValidityMask &new_validity) {
-		VerifyFlatVector(vector);
-		vector.validity.Initialize(new_validity);
-	}
-	DUCKDB_API static void SetNull(Vector &vector, idx_t idx, bool is_null);
-	static inline bool IsNull(const Vector &vector, idx_t idx) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return !vector.validity.RowIsValid(idx);
-	}
-	DUCKDB_API static const SelectionVector *IncrementalSelectionVector();
-};
-
-struct ListVector {
-	static inline list_entry_t *GetData(Vector &v) {
-		if (v.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-			auto &child = DictionaryVector::Child(v);
-			return GetData(child);
-		}
-		return FlatVector::GetData<list_entry_t>(v);
-	}
-	//! Gets a reference to the underlying child-vector of a list
-	DUCKDB_API static const Vector &GetEntry(const Vector &vector);
-	//! Gets a reference to the underlying child-vector of a list
-	DUCKDB_API static Vector &GetEntry(Vector &vector);
-	//! Gets the total size of the underlying child-vector of a list
-	DUCKDB_API static idx_t GetListSize(const Vector &vector);
-	//! Sets the total size of the underlying child-vector of a list
-	DUCKDB_API static void SetListSize(Vector &vec, idx_t size);
-	//! Gets the total capacity of the underlying child-vector of a list
-	DUCKDB_API static idx_t GetListCapacity(const Vector &vector);
-	//! Sets the total capacity of the underlying child-vector of a list
-	DUCKDB_API static void Reserve(Vector &vec, idx_t required_capacity);
-	DUCKDB_API static void Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset = 0);
-	DUCKDB_API static void Append(Vector &target, const Vector &source, const SelectionVector &sel, idx_t source_size,
-	                              idx_t source_offset = 0);
-	DUCKDB_API static void PushBack(Vector &target, const Value &insert);
-	//! Returns the child_vector of list starting at offset until offset + count, and its length
-	DUCKDB_API static idx_t GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t count);
-	//! Returns information to only copy a section of a list child vector
-	DUCKDB_API static ConsecutiveChildListInfo GetConsecutiveChildListInfo(Vector &list, idx_t offset, idx_t count);
-	//! Slice and flatten a child vector to only contain a consecutive subsection of the child entries
-	DUCKDB_API static void GetConsecutiveChildSelVector(Vector &list, SelectionVector &sel, idx_t offset, idx_t count);
-	//! Share the entry of the other list vector
-	DUCKDB_API static void ReferenceEntry(Vector &vector, Vector &other);
-
-private:
-	template <class T>
-	static T &GetEntryInternal(T &vector);
-};
-
-struct StringVector {
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, const char *data, idx_t len);
-	//! Add a string or a blob to the string heap of the vector (auxiliary data)
-	//! This function is the same as ::AddString, except the added data does not need to be valid UTF8
-	DUCKDB_API static string_t AddStringOrBlob(Vector &vector, const char *data, idx_t len);
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, const char *data);
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, string_t data);
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, const string &data);
-	//! Add a string or a blob to the string heap of the vector (auxiliary data)
-	//! This function is the same as ::AddString, except the added data does not need to be valid UTF8
-	DUCKDB_API static string_t AddStringOrBlob(Vector &vector, string_t data);
-	//! Allocates an empty string of the specified size, and returns a writable pointer that can be used to store the
-	//! result of an operation
-	DUCKDB_API static string_t EmptyString(Vector &vector, idx_t len);
-	//! Adds a reference to a handle that stores strings of this vector
-	DUCKDB_API static void AddHandle(Vector &vector, BufferHandle handle);
-	//! Adds a reference to an unspecified vector buffer that stores strings of this vector
-	DUCKDB_API static void AddBuffer(Vector &vector, buffer_ptr<VectorBuffer> buffer);
-	//! Add a reference from this vector to the string heap of the provided vector
-	DUCKDB_API static void AddHeapReference(Vector &vector, Vector &other);
-};
-
-struct FSSTVector {
-	static inline const ValidityMask &Validity(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FSST_VECTOR);
-		return vector.validity;
-	}
-	static inline ValidityMask &Validity(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FSST_VECTOR);
-		return vector.validity;
-	}
-	static inline void SetValidity(Vector &vector, ValidityMask &new_validity) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FSST_VECTOR);
-		vector.validity.Initialize(new_validity);
-	}
-	static inline const_data_ptr_t GetCompressedData(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FSST_VECTOR);
-		return vector.data;
-	}
-	static inline data_ptr_t GetCompressedData(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FSST_VECTOR);
-		return vector.data;
-	}
-	template <class T>
-	static inline const T *GetCompressedData(const Vector &vector) {
-		return (const T *)FSSTVector::GetCompressedData(vector);
-	}
-	template <class T>
-	static inline T *GetCompressedData(Vector &vector) {
-		return (T *)FSSTVector::GetCompressedData(vector);
-	}
-	//! Decompresses an FSST_VECTOR into a FLAT_VECTOR. Note: validity is not copied.
-	static void DecompressVector(const Vector &src, Vector &dst, idx_t src_offset, idx_t dst_offset, idx_t copy_count,
-	                             const SelectionVector *sel);
-
-	DUCKDB_API static string_t AddCompressedString(Vector &vector, string_t data);
-	DUCKDB_API static string_t AddCompressedString(Vector &vector, const char *data, idx_t len);
-	DUCKDB_API static void RegisterDecoder(Vector &vector, buffer_ptr<void> &duckdb_fsst_decoder,
-	                                       const idx_t string_block_limit);
-	DUCKDB_API static void *GetDecoder(const Vector &vector);
-	DUCKDB_API static vector<unsigned char> &GetDecompressBuffer(const Vector &vector);
-	//! Setting the string count is required to be able to correctly flatten the vector
-	DUCKDB_API static void SetCount(Vector &vector, idx_t count);
-	DUCKDB_API static idx_t GetCount(Vector &vector);
-};
-
-enum class MapInvalidReason : uint8_t { VALID, NULL_KEY, DUPLICATE_KEY, NOT_ALIGNED, INVALID_PARAMS };
-
-struct MapVector {
-	DUCKDB_API static const Vector &GetKeys(const Vector &vector);
-	DUCKDB_API static const Vector &GetValues(const Vector &vector);
-	DUCKDB_API static Vector &GetKeys(Vector &vector);
-	DUCKDB_API static Vector &GetValues(Vector &vector);
-	DUCKDB_API static MapInvalidReason
-	CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
-	DUCKDB_API static void EvalMapInvalidReason(MapInvalidReason reason);
-	DUCKDB_API static void MapConversionVerify(Vector &vector, idx_t count);
-};
-
-struct StructVector {
-	DUCKDB_API static const vector<unique_ptr<Vector>> &GetEntries(const Vector &vector);
-	DUCKDB_API static vector<unique_ptr<Vector>> &GetEntries(Vector &vector);
-};
-
-struct ArrayVector {
-	//! Gets a reference to the underlying child-vector of an array
-	DUCKDB_API static const Vector &GetEntry(const Vector &vector);
-	//! Gets a reference to the underlying child-vector of an array
-	DUCKDB_API static Vector &GetEntry(Vector &vector);
-	//! Gets the total size of the underlying child-vector of an array
-	DUCKDB_API static idx_t GetTotalSize(const Vector &vector);
-
-private:
-	template <class T>
-	static T &GetEntryInternal(T &vector);
-};
-
-enum class UnionInvalidReason : uint8_t {
-	VALID,
-	TAG_OUT_OF_RANGE,
-	NO_MEMBERS,
-	VALIDITY_OVERLAP,
-	TAG_MISMATCH,
-	NULL_TAG
-};
-
-struct UnionVector {
-	// Unions are stored as structs, but the first child is always the "tag"
-	// vector, specifying the currently selected member for that row.
-	// The remaining children are the members of the union.
-	// INVARIANTS:
-	//	1.	Only one member vector (the one "selected" by the tag) can be
-	//		non-NULL in each row.
-	//
-	//	2.	The validity of the tag vector always matches the validity of the
-	//		union vector itself.
-	//
-	//  3.  A valid union cannot have a NULL tag, but the selected member can
-	//  	be NULL. therefore, there is a difference between a union that "is"
-	//  	NULL and a union that "holds" a NULL. The latter still has a valid
-	//  	tag.
-	//
-	//	4.	For each tag in the tag vector, 0 <= tag < |members|
-
-	//! Get the tag vector of a union vector
-	DUCKDB_API static const Vector &GetTags(const Vector &v);
-	DUCKDB_API static Vector &GetTags(Vector &v);
-
-	//! Try to get the tag at the specific flat index of the union vector. Returns false if the tag is NULL.
-	//! This will handle and map the index properly for constant and dictionary vectors internally.
-	DUCKDB_API static bool TryGetTag(const Vector &vector, idx_t index, union_tag_t &tag);
-
-	//! Get the member vector of a union vector by index
-	DUCKDB_API static const Vector &GetMember(const Vector &vector, idx_t member_index);
-	DUCKDB_API static Vector &GetMember(Vector &vector, idx_t member_index);
-
-	//! Set every entry in the UnionVector to a specific member.
-	//! This is useful to set the entire vector to a single member, e.g. when "creating"
-	//! a union to return in a function, when you only have one alternative to return.
-	//! if 'keep_tags_for_null' is false, the tags will be set to NULL where the member is NULL.
-	//! (the validity of the tag vector will match the selected member vector)
-	//! otherwise, they are all set to the 'tag'.
-	//! This will also handle invalidation of the non-selected members
-	DUCKDB_API static void SetToMember(Vector &vector, union_tag_t tag, Vector &member_vector, idx_t count,
-	                                   bool keep_tags_for_null);
-
-	DUCKDB_API static UnionInvalidReason
-	CheckUnionValidity(Vector &vector, idx_t count,
-	                   const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
-};
-
-struct SequenceVector {
-	static void GetSequence(const Vector &vector, int64_t &start, int64_t &increment, int64_t &sequence_count) {
-		D_ASSERT(vector.GetVectorType() == VectorType::SEQUENCE_VECTOR);
-		auto data = reinterpret_cast<int64_t *>(vector.buffer->GetData());
-		start = data[0];
-		increment = data[1];
-		sequence_count = data[2];
-	}
-	static void GetSequence(const Vector &vector, int64_t &start, int64_t &increment) {
-		int64_t sequence_count;
-		GetSequence(vector, start, increment, sequence_count);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp b/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp
deleted file mode 100644
index 00ee20c2b..000000000
--- a/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp
+++ /dev/null
@@ -1,325 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/vector_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/selection_vector.hpp"
-#include "duckdb/common/types/string_heap.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-
-class BufferHandle;
-class VectorBuffer;
-class Vector;
-
-enum class VectorBufferType : uint8_t {
-	STANDARD_BUFFER,     // standard buffer, holds a single array of data
-	DICTIONARY_BUFFER,   // dictionary buffer, holds a selection vector
-	VECTOR_CHILD_BUFFER, // vector child buffer: holds another vector
-	STRING_BUFFER,       // string buffer, holds a string heap
-	FSST_BUFFER,         // fsst compressed string buffer, holds a string heap, fsst symbol table and a string count
-	STRUCT_BUFFER,       // struct buffer, holds a ordered mapping from name to child vector
-	LIST_BUFFER,         // list buffer, holds a single flatvector child
-	MANAGED_BUFFER,      // managed buffer, holds a buffer managed by the buffermanager
-	OPAQUE_BUFFER,       // opaque buffer, can be created for example by the parquet reader
-	ARRAY_BUFFER         // array buffer, holds a single flatvector child
-};
-
-enum class VectorAuxiliaryDataType : uint8_t {
-	ARROW_AUXILIARY // Holds Arrow Chunks that this vector depends on
-};
-
-struct VectorAuxiliaryData {
-	explicit VectorAuxiliaryData(VectorAuxiliaryDataType type_p)
-	    : type(type_p) {
-
-	      };
-	VectorAuxiliaryDataType type;
-
-	virtual ~VectorAuxiliaryData() {
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast vector auxiliary data to type - type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast vector auxiliary data to type - type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//! The VectorBuffer is a class used by the vector to hold its data
-class VectorBuffer {
-public:
-	explicit VectorBuffer(VectorBufferType type) : buffer_type(type) {
-	}
-	explicit VectorBuffer(idx_t data_size) : buffer_type(VectorBufferType::STANDARD_BUFFER) {
-		if (data_size > 0) {
-			data = make_unsafe_uniq_array_uninitialized<data_t>(data_size);
-		}
-	}
-	explicit VectorBuffer(unsafe_unique_array<data_t> data_p)
-	    : buffer_type(VectorBufferType::STANDARD_BUFFER), data(std::move(data_p)) {
-	}
-	virtual ~VectorBuffer() {
-	}
-	VectorBuffer() {
-	}
-
-public:
-	data_ptr_t GetData() {
-		return data.get();
-	}
-
-	void SetData(unsafe_unique_array<data_t> new_data) {
-		data = std::move(new_data);
-	}
-
-	VectorAuxiliaryData *GetAuxiliaryData() {
-		return aux_data.get();
-	}
-
-	void SetAuxiliaryData(unique_ptr<VectorAuxiliaryData> aux_data_p) {
-		aux_data = std::move(aux_data_p);
-	}
-
-	void MoveAuxiliaryData(VectorBuffer &source_buffer) {
-		SetAuxiliaryData(std::move(source_buffer.aux_data));
-	}
-
-	static buffer_ptr<VectorBuffer> CreateStandardVector(PhysicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
-	static buffer_ptr<VectorBuffer> CreateConstantVector(PhysicalType type);
-	static buffer_ptr<VectorBuffer> CreateConstantVector(const LogicalType &logical_type);
-	static buffer_ptr<VectorBuffer> CreateStandardVector(const LogicalType &logical_type,
-	                                                     idx_t capacity = STANDARD_VECTOR_SIZE);
-
-	inline VectorBufferType GetBufferType() const {
-		return buffer_type;
-	}
-
-	inline VectorAuxiliaryDataType GetAuxiliaryDataType() const {
-		return aux_data->type;
-	}
-
-protected:
-	VectorBufferType buffer_type;
-	unique_ptr<VectorAuxiliaryData> aux_data;
-	unsafe_unique_array<data_t> data;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//! The DictionaryBuffer holds a selection vector
-class DictionaryBuffer : public VectorBuffer {
-public:
-	explicit DictionaryBuffer(const SelectionVector &sel)
-	    : VectorBuffer(VectorBufferType::DICTIONARY_BUFFER), sel_vector(sel) {
-	}
-	explicit DictionaryBuffer(buffer_ptr<SelectionData> data)
-	    : VectorBuffer(VectorBufferType::DICTIONARY_BUFFER), sel_vector(std::move(data)) {
-	}
-	explicit DictionaryBuffer(idx_t count = STANDARD_VECTOR_SIZE)
-	    : VectorBuffer(VectorBufferType::DICTIONARY_BUFFER), sel_vector(count) {
-	}
-
-public:
-	const SelectionVector &GetSelVector() const {
-		return sel_vector;
-	}
-	SelectionVector &GetSelVector() {
-		return sel_vector;
-	}
-	void SetSelVector(const SelectionVector &vector) {
-		this->sel_vector.Initialize(vector);
-	}
-	void SetDictionarySize(idx_t dict_size) {
-		dictionary_size = dict_size;
-	}
-	optional_idx GetDictionarySize() const {
-		return dictionary_size;
-	}
-	void SetDictionaryId(string id) {
-		dictionary_id = std::move(id);
-	}
-	const string &GetDictionaryId() const {
-		return dictionary_id;
-	}
-
-private:
-	SelectionVector sel_vector;
-	optional_idx dictionary_size;
-	//! A unique identifier for the dictionary that can be used to check if two dictionaries are equivalent
-	string dictionary_id;
-};
-
-class VectorStringBuffer : public VectorBuffer {
-public:
-	VectorStringBuffer();
-	explicit VectorStringBuffer(VectorBufferType type);
-
-public:
-	string_t AddString(const char *data, idx_t len) {
-		return heap.AddString(data, len);
-	}
-	string_t AddString(string_t data) {
-		return heap.AddString(data);
-	}
-	string_t AddBlob(string_t data) {
-		return heap.AddBlob(data.GetData(), data.GetSize());
-	}
-	string_t EmptyString(idx_t len) {
-		return heap.EmptyString(len);
-	}
-
-	void AddHeapReference(buffer_ptr<VectorBuffer> heap) {
-		references.push_back(std::move(heap));
-	}
-
-private:
-	//! The string heap of this buffer
-	StringHeap heap;
-	// References to additional vector buffers referenced by this string buffer
-	vector<buffer_ptr<VectorBuffer>> references;
-};
-
-class VectorFSSTStringBuffer : public VectorStringBuffer {
-public:
-	VectorFSSTStringBuffer();
-
-public:
-	void AddDecoder(buffer_ptr<void> &duckdb_fsst_decoder_p, const idx_t string_block_limit) {
-		duckdb_fsst_decoder = duckdb_fsst_decoder_p;
-		decompress_buffer.resize(string_block_limit + 1);
-	}
-	void *GetDecoder() {
-		return duckdb_fsst_decoder.get();
-	}
-	vector<unsigned char> &GetDecompressBuffer() {
-		return decompress_buffer;
-	}
-	void SetCount(idx_t count) {
-		total_string_count = count;
-	}
-	idx_t GetCount() {
-		return total_string_count;
-	}
-
-private:
-	buffer_ptr<void> duckdb_fsst_decoder;
-	idx_t total_string_count = 0;
-	vector<unsigned char> decompress_buffer;
-};
-
-class VectorStructBuffer : public VectorBuffer {
-public:
-	VectorStructBuffer();
-	explicit VectorStructBuffer(const LogicalType &struct_type, idx_t capacity = STANDARD_VECTOR_SIZE);
-	VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count);
-	~VectorStructBuffer() override;
-
-public:
-	const vector<unique_ptr<Vector>> &GetChildren() const {
-		return children;
-	}
-	vector<unique_ptr<Vector>> &GetChildren() {
-		return children;
-	}
-
-private:
-	//! child vectors used for nested data
-	vector<unique_ptr<Vector>> children;
-};
-
-class VectorListBuffer : public VectorBuffer {
-public:
-	explicit VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
-	explicit VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
-	~VectorListBuffer() override;
-
-public:
-	Vector &GetChild() {
-		return *child;
-	}
-	void Reserve(idx_t to_reserve);
-
-	void Append(const Vector &to_append, idx_t to_append_size, idx_t source_offset = 0);
-	void Append(const Vector &to_append, const SelectionVector &sel, idx_t to_append_size, idx_t source_offset = 0);
-
-	void PushBack(const Value &insert);
-
-	idx_t GetSize() {
-		return size;
-	}
-
-	idx_t GetCapacity() {
-		return capacity;
-	}
-
-	void SetCapacity(idx_t new_capacity);
-	void SetSize(idx_t new_size);
-
-private:
-	//! child vectors used for nested data
-	unique_ptr<Vector> child;
-	idx_t capacity = 0;
-	idx_t size = 0;
-};
-
-class VectorArrayBuffer : public VectorBuffer {
-public:
-	explicit VectorArrayBuffer(unique_ptr<Vector> child_vector, idx_t array_size, idx_t initial_capacity);
-	explicit VectorArrayBuffer(const LogicalType &array, idx_t initial = STANDARD_VECTOR_SIZE);
-	~VectorArrayBuffer() override;
-
-public:
-	Vector &GetChild();
-	idx_t GetArraySize();
-	idx_t GetChildSize();
-
-private:
-	unique_ptr<Vector> child;
-	// The size of each array in this buffer
-	idx_t array_size = 0;
-	// How many arrays are currently stored in this buffer
-	// The child vector has size (array_size * size)
-	idx_t size = 0;
-};
-
-//! The ManagedVectorBuffer holds a buffer handle
-class ManagedVectorBuffer : public VectorBuffer {
-public:
-	explicit ManagedVectorBuffer(BufferHandle handle);
-	~ManagedVectorBuffer() override;
-
-private:
-	BufferHandle handle;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/types/vector_cache.hpp b/src/duckdb/src/include/duckdb/common/types/vector_cache.hpp
deleted file mode 100644
index 490bcd145..000000000
--- a/src/duckdb/src/include/duckdb/common/types/vector_cache.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/vector_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-class Allocator;
-class Vector;
-
-//! The VectorCache holds cached vector data.
-//! It enables re-using the same memory for different vectors.
-class VectorCache {
-public:
-	//! Instantiate an empty vector cache.
-	DUCKDB_API VectorCache();
-	//! Instantiate a vector cache with the given type and capacity.
-	DUCKDB_API VectorCache(Allocator &allocator, const LogicalType &type, const idx_t capacity = STANDARD_VECTOR_SIZE);
-
-public:
-	buffer_ptr<VectorBuffer> buffer;
-
-public:
-	void ResetFromCache(Vector &result) const;
-	const LogicalType &GetType() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/uhugeint.hpp b/src/duckdb/src/include/duckdb/common/uhugeint.hpp
deleted file mode 100644
index a579e37e4..000000000
--- a/src/duckdb/src/include/duckdb/common/uhugeint.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#pragma once
-
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/string.hpp"
-#include <stdint.h>
-
-namespace duckdb {
-
-// Forward declaration to allow conversion between hugeint and uhugeint
-struct hugeint_t; // NOLINT
-
-struct uhugeint_t { // NOLINT
-public:
-	uint64_t lower;
-	uint64_t upper;
-
-public:
-	uhugeint_t() = default;
-	DUCKDB_API uhugeint_t(uint64_t value); // NOLINT: Allow implicit conversion from `uint64_t`
-	constexpr uhugeint_t(uint64_t upper, uint64_t lower) : lower(lower), upper(upper) {
-	}
-	constexpr uhugeint_t(const uhugeint_t &rhs) = default;
-	constexpr uhugeint_t(uhugeint_t &&rhs) = default;
-	uhugeint_t &operator=(const uhugeint_t &rhs) = default;
-	uhugeint_t &operator=(uhugeint_t &&rhs) = default;
-
-	DUCKDB_API string ToString() const;
-
-	// comparison operators
-	DUCKDB_API bool operator==(const uhugeint_t &rhs) const;
-	DUCKDB_API bool operator!=(const uhugeint_t &rhs) const;
-	DUCKDB_API bool operator<=(const uhugeint_t &rhs) const;
-	DUCKDB_API bool operator<(const uhugeint_t &rhs) const;
-	DUCKDB_API bool operator>(const uhugeint_t &rhs) const;
-	DUCKDB_API bool operator>=(const uhugeint_t &rhs) const;
-
-	// arithmetic operators
-	DUCKDB_API uhugeint_t operator+(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator-(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator*(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator/(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator%(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator-() const;
-
-	// bitwise operators
-	DUCKDB_API uhugeint_t operator>>(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator<<(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator&(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator|(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator^(const uhugeint_t &rhs) const;
-	DUCKDB_API uhugeint_t operator~() const;
-
-	// in-place operators
-	DUCKDB_API uhugeint_t &operator+=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator-=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator*=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator/=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator%=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator>>=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator<<=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator&=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator|=(const uhugeint_t &rhs);
-	DUCKDB_API uhugeint_t &operator^=(const uhugeint_t &rhs);
-
-	// boolean operators
-	DUCKDB_API explicit operator bool() const;
-	DUCKDB_API bool operator!() const;
-
-	// cast operators -- doesn't check bounds/overflow/underflow
-	DUCKDB_API explicit operator uint8_t() const;
-	DUCKDB_API explicit operator uint16_t() const;
-	DUCKDB_API explicit operator uint32_t() const;
-	DUCKDB_API explicit operator uint64_t() const;
-	DUCKDB_API explicit operator int8_t() const;
-	DUCKDB_API explicit operator int16_t() const;
-	DUCKDB_API explicit operator int32_t() const;
-	DUCKDB_API explicit operator int64_t() const;
-	DUCKDB_API operator hugeint_t() const; // NOLINT: Allow implicit conversion from `uhugeint_t`
-};
-
-} // namespace duckdb
-
-namespace std {
-template <>
-struct hash<duckdb::uhugeint_t> {
-	size_t operator()(const duckdb::uhugeint_t &val) const {
-		using std::hash;
-		return hash<uint64_t> {}(val.upper) ^ hash<uint64_t> {}(val.lower);
-	}
-};
-} // namespace std
diff --git a/src/duckdb/src/include/duckdb/common/unicode_bar.hpp b/src/duckdb/src/include/duckdb/common/unicode_bar.hpp
deleted file mode 100644
index 781d65532..000000000
--- a/src/duckdb/src/include/duckdb/common/unicode_bar.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/unicode_bar.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-namespace duckdb {
-struct UnicodeBar {
-private:
-	static constexpr idx_t PARTIAL_BLOCKS_COUNT = 8;
-
-public:
-	static constexpr idx_t PartialBlocksCount() {
-		return PARTIAL_BLOCKS_COUNT;
-	}
-
-	static const char *const *PartialBlocks() {
-		static const char *PARTIAL_BLOCKS[PARTIAL_BLOCKS_COUNT] = {" ",
-		                                                           "\xE2\x96\x8F",
-		                                                           "\xE2\x96\x8E",
-		                                                           "\xE2\x96\x8D",
-		                                                           "\xE2\x96\x8C",
-		                                                           "\xE2\x96\x8B",
-		                                                           "\xE2\x96\x8A",
-		                                                           "\xE2\x96\x89"};
-		return PARTIAL_BLOCKS;
-	}
-
-	static const char *FullBlock() {
-		return "\xE2\x96\x88";
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/union_by_name.hpp b/src/duckdb/src/include/duckdb/common/union_by_name.hpp
deleted file mode 100644
index 2282424ad..000000000
--- a/src/duckdb/src/include/duckdb/common/union_by_name.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/union_by_name.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/parallel/task_executor.hpp"
-
-namespace duckdb {
-
-template <class READER_TYPE, class OPTION_TYPE>
-class UnionByReaderTask : public BaseExecutorTask {
-public:
-	UnionByReaderTask(TaskExecutor &executor, ClientContext &context, const string &file, idx_t file_idx,
-	                  vector<typename READER_TYPE::UNION_READER_DATA> &readers, OPTION_TYPE &options)
-	    : BaseExecutorTask(executor), context(context), file_name(file), file_idx(file_idx), readers(readers),
-	      options(options) {
-	}
-
-	void ExecuteTask() override {
-		auto reader = make_uniq<READER_TYPE>(context, file_name, options);
-		readers[file_idx] = READER_TYPE::StoreUnionReader(std::move(reader), file_idx);
-	}
-
-private:
-	ClientContext &context;
-	const string &file_name;
-	idx_t file_idx;
-	vector<typename READER_TYPE::UNION_READER_DATA> &readers;
-	OPTION_TYPE &options;
-};
-
-class UnionByName {
-public:
-	static void CombineUnionTypes(const vector<string> &new_names, const vector<LogicalType> &new_types,
-	                              vector<LogicalType> &union_col_types, vector<string> &union_col_names,
-	                              case_insensitive_map_t<idx_t> &union_names_map);
-
-	//! Union all files(readers) by their col names
-	template <class READER_TYPE, class OPTION_TYPE>
-	static vector<typename READER_TYPE::UNION_READER_DATA>
-	UnionCols(ClientContext &context, const vector<string> &files, vector<LogicalType> &union_col_types,
-	          vector<string> &union_col_names, OPTION_TYPE &options) {
-		vector<typename READER_TYPE::UNION_READER_DATA> union_readers;
-		union_readers.resize(files.size());
-
-		TaskExecutor executor(context);
-		// schedule tasks for all files
-		for (idx_t file_idx = 0; file_idx < files.size(); ++file_idx) {
-			auto task = make_uniq<UnionByReaderTask<READER_TYPE, OPTION_TYPE>>(executor, context, files[file_idx],
-			                                                                   file_idx, union_readers, options);
-			executor.ScheduleTask(std::move(task));
-		}
-		// complete all tasks
-		executor.WorkOnTasks();
-
-		// now combine the result schemas
-		case_insensitive_map_t<idx_t> union_names_map;
-		for (auto &reader : union_readers) {
-			auto &col_names = reader->names;
-			auto &sql_types = reader->types;
-			CombineUnionTypes(col_names, sql_types, union_col_types, union_col_names, union_names_map);
-		}
-		return union_readers;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/unique_ptr.hpp b/src/duckdb/src/include/duckdb/common/unique_ptr.hpp
deleted file mode 100644
index 0689aeb66..000000000
--- a/src/duckdb/src/include/duckdb/common/unique_ptr.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/memory_safety.hpp"
-
-#include <memory>
-#include <type_traits>
-
-namespace duckdb {
-
-template <class DATA_TYPE, class DELETER = std::default_delete<DATA_TYPE>, bool SAFE = true>
-class unique_ptr : public std::unique_ptr<DATA_TYPE, DELETER> { // NOLINT: naming
-public:
-	using original = std::unique_ptr<DATA_TYPE, DELETER>;
-	using original::original; // NOLINT
-	using pointer = typename original::pointer;
-
-private:
-	static inline void AssertNotNull(const bool null) {
-#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
-		return;
-#else
-		if (DUCKDB_UNLIKELY(null)) {
-			throw duckdb::InternalException("Attempted to dereference unique_ptr that is NULL!");
-		}
-#endif
-	}
-
-public:
-	typename std::add_lvalue_reference<DATA_TYPE>::type operator*() const { // NOLINT: hiding on purpose
-		const auto ptr = original::get();
-		if (MemorySafety<SAFE>::ENABLED) {
-			AssertNotNull(!ptr);
-		}
-		return *ptr;
-	}
-
-	typename original::pointer operator->() const { // NOLINT: hiding on purpose
-		const auto ptr = original::get();
-		if (MemorySafety<SAFE>::ENABLED) {
-			AssertNotNull(!ptr);
-		}
-		return ptr;
-	}
-
-#ifdef DUCKDB_CLANG_TIDY
-	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
-	[[clang::reinitializes]]
-#endif
-	inline void
-	reset(typename original::pointer ptr = typename original::pointer()) noexcept { // NOLINT: hiding on purpose
-		original::reset(ptr);
-	}
-};
-
-// FIXME: DELETER is defined, but we use std::default_delete???
-template <class DATA_TYPE, class DELETER, bool SAFE>
-class unique_ptr<DATA_TYPE[], DELETER, SAFE> : public std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>> {
-public:
-	using original = std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>>;
-	using original::original;
-
-private:
-	static inline void AssertNotNull(const bool null) {
-#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
-		return;
-#else
-		if (DUCKDB_UNLIKELY(null)) {
-			throw duckdb::InternalException("Attempted to dereference unique_ptr that is NULL!");
-		}
-#endif
-	}
-
-public:
-	typename std::add_lvalue_reference<DATA_TYPE>::type operator[](size_t __i) const { // NOLINT: hiding on purpose
-		const auto ptr = original::get();
-		if (MemorySafety<SAFE>::ENABLED) {
-			AssertNotNull(!ptr);
-		}
-		return ptr[__i];
-	}
-};
-
-template <typename T>
-using unique_array = unique_ptr<T[], std::default_delete<T>, true>;
-
-template <typename T>
-using unsafe_unique_array = unique_ptr<T[], std::default_delete<T>, false>;
-
-template <typename T>
-using unsafe_unique_ptr = unique_ptr<T, std::default_delete<T>, false>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/unordered_map.hpp b/src/duckdb/src/include/duckdb/common/unordered_map.hpp
deleted file mode 100644
index 9e6d2b821..000000000
--- a/src/duckdb/src/include/duckdb/common/unordered_map.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/unordered_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <unordered_map>
-
-namespace duckdb {
-using std::unordered_map;
-}
diff --git a/src/duckdb/src/include/duckdb/common/unordered_set.hpp b/src/duckdb/src/include/duckdb/common/unordered_set.hpp
deleted file mode 100644
index 6d9defc0d..000000000
--- a/src/duckdb/src/include/duckdb/common/unordered_set.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/unordered_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <unordered_set>
-
-namespace duckdb {
-using std::unordered_set;
-}
diff --git a/src/duckdb/src/include/duckdb/common/value_operations/value_operations.hpp b/src/duckdb/src/include/duckdb/common/value_operations/value_operations.hpp
deleted file mode 100644
index 055f4e4da..000000000
--- a/src/duckdb/src/include/duckdb/common/value_operations/value_operations.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/value_operations/value_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-struct ValueOperations {
-	//===--------------------------------------------------------------------===//
-	// Comparison Operations
-	//===--------------------------------------------------------------------===//
-	// A == B
-	static bool Equals(const Value &left, const Value &right);
-	// A != B
-	static bool NotEquals(const Value &left, const Value &right);
-	// A > B
-	static bool GreaterThan(const Value &left, const Value &right);
-	// A >= B
-	static bool GreaterThanEquals(const Value &left, const Value &right);
-	// A < B
-	static bool LessThan(const Value &left, const Value &right);
-	// A <= B
-	static bool LessThanEquals(const Value &left, const Value &right);
-	//===--------------------------------------------------------------------===//
-	// Distinction Operations
-	//===--------------------------------------------------------------------===//
-	// A == B, NULLs equal
-	static bool NotDistinctFrom(const Value &left, const Value &right);
-	// A != B, NULLs equal
-	static bool DistinctFrom(const Value &left, const Value &right);
-	// A > B, NULLs last
-	static bool DistinctGreaterThan(const Value &left, const Value &right);
-	// A >= B, NULLs last
-	static bool DistinctGreaterThanEquals(const Value &left, const Value &right);
-	// A < B, NULLs last
-	static bool DistinctLessThan(const Value &left, const Value &right);
-	// A <= B, NULLs last
-	static bool DistinctLessThanEquals(const Value &left, const Value &right);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector.hpp b/src/duckdb/src/include/duckdb/common/vector.hpp
deleted file mode 100644
index 676adac20..000000000
--- a/src/duckdb/src/include/duckdb/common/vector.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/memory_safety.hpp"
-#include <vector>
-
-namespace duckdb {
-
-template <class DATA_TYPE, bool SAFE = true>
-class vector : public std::vector<DATA_TYPE, std::allocator<DATA_TYPE>> { // NOLINT: matching name of std
-public:
-	using original = std::vector<DATA_TYPE, std::allocator<DATA_TYPE>>;
-	using original::original;
-	using size_type = typename original::size_type;
-	using const_reference = typename original::const_reference;
-	using reference = typename original::reference;
-
-private:
-	static inline void AssertIndexInBounds(idx_t index, idx_t size) {
-#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
-		return;
-#else
-		if (DUCKDB_UNLIKELY(index >= size)) {
-			throw InternalException("Attempted to access index %ld within vector of size %ld", index, size);
-		}
-#endif
-	}
-
-public:
-#ifdef DUCKDB_CLANG_TIDY
-	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
-	[[clang::reinitializes]]
-#endif
-	inline void
-	clear() noexcept { // NOLINT: hiding on purpose
-		original::clear();
-	}
-
-	// Because we create the other constructor, the implicitly created constructor
-	// gets deleted, so we have to be explicit
-	vector() = default;
-	vector(original &&other) : original(std::move(other)) { // NOLINT: allow implicit conversion
-	}
-	template <bool INTERNAL_SAFE>
-	vector(vector<DATA_TYPE, INTERNAL_SAFE> &&other) : original(std::move(other)) { // NOLINT: allow implicit conversion
-	}
-
-	template <bool INTERNAL_SAFE = false>
-	inline typename original::reference get(typename original::size_type __n) { // NOLINT: hiding on purpose
-		if (MemorySafety<INTERNAL_SAFE>::ENABLED) {
-			AssertIndexInBounds(__n, original::size());
-		}
-		return original::operator[](__n);
-	}
-
-	template <bool INTERNAL_SAFE = false>
-	inline typename original::const_reference get(typename original::size_type __n) const { // NOLINT: hiding on purpose
-		if (MemorySafety<INTERNAL_SAFE>::ENABLED) {
-			AssertIndexInBounds(__n, original::size());
-		}
-		return original::operator[](__n);
-	}
-
-	typename original::reference operator[](typename original::size_type __n) { // NOLINT: hiding on purpose
-		return get<SAFE>(__n);
-	}
-	typename original::const_reference operator[](typename original::size_type __n) const { // NOLINT: hiding on purpose
-		return get<SAFE>(__n);
-	}
-
-	typename original::reference front() { // NOLINT: hiding on purpose
-		return get<SAFE>(0);
-	}
-
-	typename original::const_reference front() const { // NOLINT: hiding on purpose
-		return get<SAFE>(0);
-	}
-
-	typename original::reference back() { // NOLINT: hiding on purpose
-		if (MemorySafety<SAFE>::ENABLED && original::empty()) {
-			throw InternalException("'back' called on an empty vector!");
-		}
-		return get<SAFE>(original::size() - 1);
-	}
-
-	typename original::const_reference back() const { // NOLINT: hiding on purpose
-		if (MemorySafety<SAFE>::ENABLED && original::empty()) {
-			throw InternalException("'back' called on an empty vector!");
-		}
-		return get<SAFE>(original::size() - 1);
-	}
-
-	void unsafe_erase_at(idx_t idx) { // NOLINT: not using camelcase on purpose here
-		original::erase(original::begin() + static_cast<typename original::iterator::difference_type>(idx));
-	}
-
-	void erase_at(idx_t idx) { // NOLINT: not using camelcase on purpose here
-		if (MemorySafety<SAFE>::ENABLED && idx > original::size()) {
-			throw InternalException("Can't remove offset %d from vector of size %d", idx, original::size());
-		}
-		unsafe_erase_at(idx);
-	}
-};
-
-template <typename T>
-using unsafe_vector = vector<T, false>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp
deleted file mode 100644
index 6abe7ff1e..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp
+++ /dev/null
@@ -1,470 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/aggregate_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate_state.hpp"
-
-namespace duckdb {
-
-// structs
-struct AggregateInputData;
-
-// The bounds of a window frame
-struct FrameBounds {
-	FrameBounds() : start(0), end(0) {};
-	FrameBounds(idx_t start, idx_t end) : start(start), end(end) {};
-	idx_t start = 0;
-	idx_t end = 0;
-};
-
-// A set of window subframes for windowed EXCLUDE
-using SubFrames = vector<FrameBounds>;
-
-class AggregateExecutor {
-private:
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class STATE_TYPE, class OP>
-	static inline void NullaryFlatLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
-	                                   idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Operation<STATE_TYPE, OP>(*states[i], aggr_input_data, i);
-		}
-	}
-#endif
-
-	template <class STATE_TYPE, class OP>
-	static inline void NullaryScatterLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
-	                                      const SelectionVector &ssel, idx_t count) {
-
-		for (idx_t i = 0; i < count; i++) {
-			auto sidx = ssel.get_index(i);
-			OP::template Operation<STATE_TYPE, OP>(*states[sidx], aggr_input_data, sidx);
-		}
-	}
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryFlatLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                 STATE_TYPE **__restrict states, ValidityMask &mask, idx_t count) {
-		if (OP::IgnoreNull() && !mask.AllValid()) {
-			AggregateUnaryInput input(aggr_input_data, mask);
-			auto &base_idx = input.input_idx;
-			base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[base_idx], idata[base_idx], input);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[base_idx], idata[base_idx],
-							                                                   input);
-						}
-					}
-				}
-			}
-		} else {
-			AggregateUnaryInput input(aggr_input_data, mask);
-			auto &i = input.input_idx;
-			for (i = 0; i < count; i++) {
-				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[i], idata[i], input);
-			}
-		}
-	}
-#endif
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryScatterLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                    STATE_TYPE **__restrict states, const SelectionVector &isel,
-	                                    const SelectionVector &ssel, ValidityMask &mask, idx_t count) {
-		if (OP::IgnoreNull() && !mask.AllValid()) {
-			// potential NULL values and NULL values are ignored
-			AggregateUnaryInput input(aggr_input_data, mask);
-			for (idx_t i = 0; i < count; i++) {
-				input.input_idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				if (mask.RowIsValid(input.input_idx)) {
-					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[sidx], idata[input.input_idx], input);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			AggregateUnaryInput input(aggr_input_data, mask);
-			for (idx_t i = 0; i < count; i++) {
-				input.input_idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[sidx], idata[input.input_idx], input);
-			}
-		}
-	}
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryFlatUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                       STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask) {
-		AggregateUnaryInput input(aggr_input_data, mask);
-		auto &base_idx = input.input_idx;
-		base_idx = 0;
-		auto entry_count = ValidityMask::EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			auto validity_entry = mask.GetValidityEntry(entry_idx);
-			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-			if (!OP::IgnoreNull() || ValidityMask::AllValid(validity_entry)) {
-				// all valid: perform operation
-				for (; base_idx < next; base_idx++) {
-					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[base_idx], input);
-				}
-			} else if (ValidityMask::NoneValid(validity_entry)) {
-				// nothing valid: skip all
-				base_idx = next;
-				continue;
-			} else {
-				// partially valid: need to check individual elements for validity
-				idx_t start = base_idx;
-				for (; base_idx < next; base_idx++) {
-					if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-						OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[base_idx], input);
-					}
-				}
-			}
-		}
-	}
-#endif
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                   STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask,
-	                                   const SelectionVector &__restrict sel_vector) {
-		AggregateUnaryInput input(aggr_input_data, mask);
-		if (OP::IgnoreNull() && !mask.AllValid()) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				input.input_idx = sel_vector.get_index(i);
-				if (mask.RowIsValid(input.input_idx)) {
-					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[input.input_idx], input);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				input.input_idx = sel_vector.get_index(i);
-				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[input.input_idx], input);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static inline void BinaryScatterLoop(const A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
-	                                     const B_TYPE *__restrict bdata, STATE_TYPE **__restrict states, idx_t count,
-	                                     const SelectionVector &asel, const SelectionVector &bsel,
-	                                     const SelectionVector &ssel, ValidityMask &avalidity,
-	                                     ValidityMask &bvalidity) {
-		AggregateBinaryInput input(aggr_input_data, avalidity, bvalidity);
-		if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				input.lidx = asel.get_index(i);
-				input.ridx = bsel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				if (avalidity.RowIsValid(input.lidx) && bvalidity.RowIsValid(input.ridx)) {
-					OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*states[sidx], adata[input.lidx],
-					                                                       bdata[input.ridx], input);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				input.lidx = asel.get_index(i);
-				input.ridx = bsel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*states[sidx], adata[input.lidx],
-				                                                       bdata[input.ridx], input);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static inline void BinaryUpdateLoop(const A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
-	                                    const B_TYPE *__restrict bdata, STATE_TYPE *__restrict state, idx_t count,
-	                                    const SelectionVector &asel, const SelectionVector &bsel,
-	                                    ValidityMask &avalidity, ValidityMask &bvalidity) {
-		AggregateBinaryInput input(aggr_input_data, avalidity, bvalidity);
-		if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				input.lidx = asel.get_index(i);
-				input.ridx = bsel.get_index(i);
-				if (avalidity.RowIsValid(input.lidx) && bvalidity.RowIsValid(input.ridx)) {
-					OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*state, adata[input.lidx], bdata[input.ridx],
-					                                                       input);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				input.lidx = asel.get_index(i);
-				input.ridx = bsel.get_index(i);
-				OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*state, adata[input.lidx], bdata[input.ridx],
-				                                                       input);
-			}
-		}
-	}
-
-public:
-	template <class STATE_TYPE, class OP>
-	static void NullaryScatter(Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			OP::template ConstantOperation<STATE_TYPE, OP>(**sdata, aggr_input_data, count);
-#ifndef DUCKDB_SMALLER_BINARY
-		} else if (states.GetVectorType() == VectorType::FLAT_VECTOR) {
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			NullaryFlatLoop<STATE_TYPE, OP>(sdata, aggr_input_data, count);
-#endif
-		} else {
-			UnifiedVectorFormat sdata;
-			states.ToUnifiedFormat(count, sdata);
-			NullaryScatterLoop<STATE_TYPE, OP>((STATE_TYPE **)sdata.data, aggr_input_data, *sdata.sel, count);
-		}
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void NullaryUpdate(data_ptr_t state, AggregateInputData &aggr_input_data, idx_t count) {
-		OP::template ConstantOperation<STATE_TYPE, OP>(*reinterpret_cast<STATE_TYPE *>(state), aggr_input_data, count);
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static void UnaryScatter(Vector &input, Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
-				// constant NULL input in function that ignores NULL values
-				return;
-			}
-			// regular constant: get first state
-			auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			AggregateUnaryInput input_data(aggr_input_data, ConstantVector::Validity(input));
-			OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>(**sdata, *idata, input_data, count);
-#ifndef DUCKDB_SMALLER_BINARY
-		} else if (input.GetVectorType() == VectorType::FLAT_VECTOR &&
-		           states.GetVectorType() == VectorType::FLAT_VECTOR) {
-			auto idata = FlatVector::GetData<INPUT_TYPE>(input);
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			UnaryFlatLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, sdata, FlatVector::Validity(input),
-			                                          count);
-#endif
-		} else {
-			UnifiedVectorFormat idata, sdata;
-			input.ToUnifiedFormat(count, idata);
-			states.ToUnifiedFormat(count, sdata);
-			UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
-			                                             aggr_input_data, (STATE_TYPE **)sdata.data, *idata.sel,
-			                                             *sdata.sel, idata.validity, count);
-		}
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static void UnaryUpdate(Vector &input, AggregateInputData &aggr_input_data, data_ptr_t state, idx_t count) {
-		switch (input.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
-				return;
-			}
-			auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
-			AggregateUnaryInput input_data(aggr_input_data, ConstantVector::Validity(input));
-			OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>(*reinterpret_cast<STATE_TYPE *>(state), *idata,
-			                                                           input_data, count);
-			break;
-		}
-#ifndef DUCKDB_SMALLER_BINARY
-		case VectorType::FLAT_VECTOR: {
-			auto idata = FlatVector::GetData<INPUT_TYPE>(input);
-			UnaryFlatUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, (STATE_TYPE *)state, count,
-			                                                FlatVector::Validity(input));
-			break;
-		}
-#endif
-		default: {
-			UnifiedVectorFormat idata;
-			input.ToUnifiedFormat(count, idata);
-			UnaryUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
-			                                            aggr_input_data, (STATE_TYPE *)state, count, idata.validity,
-			                                            *idata.sel);
-			break;
-		}
-		}
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryScatter(AggregateInputData &aggr_input_data, Vector &a, Vector &b, Vector &states, idx_t count) {
-		UnifiedVectorFormat adata, bdata, sdata;
-
-		a.ToUnifiedFormat(count, adata);
-		b.ToUnifiedFormat(count, bdata);
-		states.ToUnifiedFormat(count, sdata);
-
-		BinaryScatterLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>(
-		    UnifiedVectorFormat::GetData<A_TYPE>(adata), aggr_input_data, UnifiedVectorFormat::GetData<B_TYPE>(bdata),
-		    (STATE_TYPE **)sdata.data, count, *adata.sel, *bdata.sel, *sdata.sel, adata.validity, bdata.validity);
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryUpdate(AggregateInputData &aggr_input_data, Vector &a, Vector &b, data_ptr_t state, idx_t count) {
-		UnifiedVectorFormat adata, bdata;
-
-		a.ToUnifiedFormat(count, adata);
-		b.ToUnifiedFormat(count, bdata);
-
-		BinaryUpdateLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>(
-		    UnifiedVectorFormat::GetData<A_TYPE>(adata), aggr_input_data, UnifiedVectorFormat::GetData<B_TYPE>(bdata),
-		    (STATE_TYPE *)state, count, *adata.sel, *bdata.sel, adata.validity, bdata.validity);
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void Combine(Vector &source, Vector &target, AggregateInputData &aggr_input_data, idx_t count) {
-		D_ASSERT(source.GetType().id() == LogicalTypeId::POINTER && target.GetType().id() == LogicalTypeId::POINTER);
-		auto sdata = FlatVector::GetData<const STATE_TYPE *>(source);
-		auto tdata = FlatVector::GetData<STATE_TYPE *>(target);
-
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Combine<STATE_TYPE, OP>(*sdata[i], *tdata[i], aggr_input_data);
-		}
-	}
-
-	template <class STATE_TYPE, class RESULT_TYPE, class OP>
-	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                     idx_t offset) {
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-			AggregateFinalizeData finalize_data(result, aggr_input_data);
-			OP::template Finalize<RESULT_TYPE, STATE_TYPE>(**sdata, *rdata, finalize_data);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-			AggregateFinalizeData finalize_data(result, aggr_input_data);
-			for (idx_t i = 0; i < count; i++) {
-				finalize_data.result_idx = i + offset;
-				OP::template Finalize<RESULT_TYPE, STATE_TYPE>(*sdata[i], rdata[finalize_data.result_idx],
-				                                               finalize_data);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void VoidFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                         idx_t offset) {
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			AggregateFinalizeData finalize_data(result, aggr_input_data);
-			OP::template Finalize<STATE_TYPE>(**sdata, finalize_data);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			AggregateFinalizeData finalize_data(result, aggr_input_data);
-			for (idx_t i = 0; i < count; i++) {
-				finalize_data.result_idx = i + offset;
-				OP::template Finalize<STATE_TYPE>(*sdata[i], finalize_data);
-			}
-		}
-	}
-
-	template <typename OP>
-	static void IntersectFrames(const SubFrames &lefts, const SubFrames &rights, OP &op) {
-		const auto cover_start = MinValue(rights[0].start, lefts[0].start);
-		const auto cover_end = MaxValue(rights.back().end, lefts.back().end);
-		const FrameBounds last(cover_end, cover_end);
-
-		//	Subframe indices
-		idx_t l = 0;
-		idx_t r = 0;
-		for (auto i = cover_start; i < cover_end;) {
-			uint8_t overlap = 0;
-
-			// Are we in the previous frame?
-			auto left = &last;
-			if (l < lefts.size()) {
-				left = &lefts[l];
-				overlap |= uint8_t(left->start <= i && i < left->end) << 0;
-			}
-
-			// Are we in the current frame?
-			auto right = &last;
-			if (r < rights.size()) {
-				right = &rights[r];
-				overlap |= uint8_t(right->start <= i && i < right->end) << 1;
-			}
-
-			auto limit = i;
-			switch (overlap) {
-			case 0x00:
-				// i ∉ F U P
-				limit = MinValue(right->start, left->start);
-				op.Neither(i, limit);
-				break;
-			case 0x01:
-				// i ∈ P \ F
-				limit = MinValue(left->end, right->start);
-				op.Left(i, limit);
-				break;
-			case 0x02:
-				// i ∈ F \ P
-				limit = MinValue(right->end, left->start);
-				op.Right(i, limit);
-				break;
-			case 0x03:
-			default:
-				D_ASSERT(overlap == 0x03);
-				// i ∈ F ∩ P
-				limit = MinValue(right->end, left->end);
-				op.Both(i, limit);
-				break;
-			}
-
-			// Advance  the subframe indices
-			i = limit;
-			l += (i == left->end);
-			r += (i == right->end);
-		}
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void Destroy(Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
-		auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Destroy<STATE_TYPE>(*sdata[i], aggr_input_data);
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/binary_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/binary_executor.hpp
deleted file mode 100644
index 57e669d5d..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/binary_executor.hpp
+++ /dev/null
@@ -1,547 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/binary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct DefaultNullCheckOperator {
-	template <class LEFT_TYPE, class RIGHT_TYPE>
-	static inline bool Operation(LEFT_TYPE left, RIGHT_TYPE right) {
-		return false;
-	}
-};
-
-struct BinaryStandardOperatorWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-	}
-
-	static bool AddsNulls() {
-		return false;
-	}
-};
-
-struct BinarySingleArgumentOperatorWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return OP::template Operation<LEFT_TYPE>(left, right);
-	}
-
-	static bool AddsNulls() {
-		return false;
-	}
-};
-
-struct BinaryLambdaWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return fun(left, right);
-	}
-
-	static bool AddsNulls() {
-		return false;
-	}
-};
-
-struct BinaryLambdaWrapperWithNulls {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return fun(left, right, mask, idx);
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-struct BinaryExecutor {
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
-	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static void ExecuteFlatLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                            RESULT_TYPE *__restrict result_data, idx_t count, ValidityMask &mask, FUNC fun) {
-		if (!LEFT_CONSTANT) {
-			ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
-		}
-		if (!RIGHT_CONSTANT) {
-			ASSERT_RESTRICT(rdata, rdata + count, result_data, result_data + count);
-		}
-
-		if (!mask.AllValid()) {
-			idx_t base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						auto lentry = ldata[LEFT_CONSTANT ? 0 : base_idx];
-						auto rentry = rdata[RIGHT_CONSTANT ? 0 : base_idx];
-						result_data[base_idx] =
-						    OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-						        fun, lentry, rentry, mask, base_idx);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							auto lentry = ldata[LEFT_CONSTANT ? 0 : base_idx];
-							auto rentry = rdata[RIGHT_CONSTANT ? 0 : base_idx];
-							result_data[base_idx] =
-							    OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-							        fun, lentry, rentry, mask, base_idx);
-						}
-					}
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto lentry = ldata[LEFT_CONSTANT ? 0 : i];
-				auto rentry = rdata[RIGHT_CONSTANT ? 0 : i];
-				result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-				    fun, lentry, rentry, mask, i);
-			}
-		}
-	}
-#endif
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteConstant(Vector &left, Vector &right, Vector &result, FUNC fun) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-		auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-		auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-
-		if (ConstantVector::IsNull(left) || ConstantVector::IsNull(right)) {
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		*result_data = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-		    fun, *ldata, *rdata, ConstantVector::Validity(result), 0);
-	}
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
-	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static void ExecuteFlat(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
-		auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
-
-		if ((LEFT_CONSTANT && ConstantVector::IsNull(left)) || (RIGHT_CONSTANT && ConstantVector::IsNull(right))) {
-			// either left or right is constant NULL: result is constant NULL
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &result_validity = FlatVector::Validity(result);
-		if (LEFT_CONSTANT) {
-			if (OPWRAPPER::AddsNulls()) {
-				result_validity.Copy(FlatVector::Validity(right), count);
-			} else {
-				FlatVector::SetValidity(result, FlatVector::Validity(right));
-			}
-		} else if (RIGHT_CONSTANT) {
-			if (OPWRAPPER::AddsNulls()) {
-				result_validity.Copy(FlatVector::Validity(left), count);
-			} else {
-				FlatVector::SetValidity(result, FlatVector::Validity(left));
-			}
-		} else {
-			if (OPWRAPPER::AddsNulls()) {
-				result_validity.Copy(FlatVector::Validity(left), count);
-				if (result_validity.AllValid()) {
-					result_validity.Copy(FlatVector::Validity(right), count);
-				} else {
-					result_validity.Combine(FlatVector::Validity(right), count);
-				}
-			} else {
-				FlatVector::SetValidity(result, FlatVector::Validity(left));
-				result_validity.Combine(FlatVector::Validity(right), count);
-			}
-		}
-		ExecuteFlatLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, result_data, count, result_validity, fun);
-	}
-#endif
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                               RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel,
-	                               const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lvalidity,
-	                               ValidityMask &rvalidity, ValidityMask &result_validity, FUNC fun) {
-		if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto lindex = lsel->get_index(i);
-				auto rindex = rsel->get_index(i);
-				if (lvalidity.RowIsValid(lindex) && rvalidity.RowIsValid(rindex)) {
-					auto lentry = ldata[lindex];
-					auto rentry = rdata[rindex];
-					result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-					    fun, lentry, rentry, result_validity, i);
-				} else {
-					result_validity.SetInvalid(i);
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto lentry = ldata[lsel->get_index(i)];
-				auto rentry = rdata[rsel->get_index(i)];
-				result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-				    fun, lentry, rentry, result_validity, i);
-			}
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteGeneric(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		UnifiedVectorFormat ldata, rdata;
-
-		left.ToUnifiedFormat(count, ldata);
-		right.ToUnifiedFormat(count, rdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-		ExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(
-		    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata),
-		    result_data, ldata.sel, rdata.sel, count, ldata.validity, rdata.validity, FlatVector::Validity(result),
-		    fun);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteSwitch(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		auto left_vector_type = left.GetVectorType();
-		auto right_vector_type = right.GetVectorType();
-		if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
-			ExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, fun);
-#ifndef DUCKDB_SMALLER_BINARY
-		} else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
-			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, true>(left, right, result,
-			                                                                                  count, fun);
-		} else if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
-			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, true, false>(left, right, result,
-			                                                                                  count, fun);
-		} else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
-			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, false>(left, right, result,
-			                                                                                   count, fun);
-#endif
-		} else {
-			ExecuteGeneric<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, count, fun);
-		}
-	}
-
-public:
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE)>>
-	static void Execute(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryLambdaWrapper, bool, FUNC>(left, right, result, count,
-		                                                                                   fun);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP,
-	          class OPWRAPPER = BinarySingleArgumentOperatorWrapper>
-	static void Execute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, bool>(left, right, result, count, false);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-	static void ExecuteStandard(Vector &left, Vector &right, Vector &result, idx_t count) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryStandardOperatorWrapper, OP, bool>(left, right, result,
-		                                                                                           count, false);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE, ValidityMask &, idx_t)>>
-	static void ExecuteWithNulls(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryLambdaWrapperWithNulls, bool, FUNC>(left, right, result,
-		                                                                                            count, fun);
-	}
-
-public:
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static idx_t SelectConstant(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                            SelectionVector *true_sel, SelectionVector *false_sel) {
-		auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-		auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-
-		// both sides are constant, return either 0 or the count
-		// in this case we do not fill in the result selection vector at all
-		if (ConstantVector::IsNull(left) || ConstantVector::IsNull(right) || !OP::Operation(*ldata, *rdata)) {
-			if (false_sel) {
-				for (idx_t i = 0; i < count; i++) {
-					false_sel->set_index(i, sel->get_index(i));
-				}
-			}
-			return 0;
-		} else {
-			if (true_sel) {
-				for (idx_t i = 0; i < count; i++) {
-					true_sel->set_index(i, sel->get_index(i));
-				}
-			}
-			return count;
-		}
-	}
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool HAS_TRUE_SEL,
-	          bool HAS_FALSE_SEL>
-	static inline idx_t SelectFlatLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                                   const SelectionVector *sel, idx_t count, ValidityMask &validity_mask,
-	                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-		idx_t base_idx = 0;
-		auto entry_count = ValidityMask::EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			auto validity_entry = validity_mask.GetValidityEntry(entry_idx);
-			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-			if (ValidityMask::AllValid(validity_entry)) {
-				// all valid: perform operation
-				for (; base_idx < next; base_idx++) {
-					idx_t result_idx = sel->get_index(base_idx);
-					idx_t lidx = LEFT_CONSTANT ? 0 : base_idx;
-					idx_t ridx = RIGHT_CONSTANT ? 0 : base_idx;
-					bool comparison_result = OP::Operation(ldata[lidx], rdata[ridx]);
-					if (HAS_TRUE_SEL) {
-						true_sel->set_index(true_count, result_idx);
-						true_count += comparison_result;
-					}
-					if (HAS_FALSE_SEL) {
-						false_sel->set_index(false_count, result_idx);
-						false_count += !comparison_result;
-					}
-				}
-			} else if (ValidityMask::NoneValid(validity_entry)) {
-				// nothing valid: skip all
-				if (HAS_FALSE_SEL) {
-					for (; base_idx < next; base_idx++) {
-						idx_t result_idx = sel->get_index(base_idx);
-						false_sel->set_index(false_count, result_idx);
-						false_count++;
-					}
-				}
-				base_idx = next;
-				continue;
-			} else {
-				// partially valid: need to check individual elements for validity
-				idx_t start = base_idx;
-				for (; base_idx < next; base_idx++) {
-					idx_t result_idx = sel->get_index(base_idx);
-					idx_t lidx = LEFT_CONSTANT ? 0 : base_idx;
-					idx_t ridx = RIGHT_CONSTANT ? 0 : base_idx;
-					bool comparison_result = ValidityMask::RowIsValid(validity_entry, base_idx - start) &&
-					                         OP::Operation(ldata[lidx], rdata[ridx]);
-					if (HAS_TRUE_SEL) {
-						true_sel->set_index(true_count, result_idx);
-						true_count += comparison_result;
-					}
-					if (HAS_FALSE_SEL) {
-						false_sel->set_index(false_count, result_idx);
-						false_count += !comparison_result;
-					}
-				}
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static inline idx_t SelectFlatLoopSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                                         const SelectionVector *sel, idx_t count, ValidityMask &mask,
-	                                         SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true, true>(
-			    ldata, rdata, sel, count, mask, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true, false>(
-			    ldata, rdata, sel, count, mask, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, false, true>(
-			    ldata, rdata, sel, count, mask, true_sel, false_sel);
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static idx_t SelectFlat(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                        SelectionVector *true_sel, SelectionVector *false_sel) {
-		auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
-		auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
-
-		if (LEFT_CONSTANT && ConstantVector::IsNull(left)) {
-			if (false_sel) {
-				for (idx_t i = 0; i < count; i++) {
-					false_sel->set_index(i, sel->get_index(i));
-				}
-			}
-			return 0;
-		}
-		if (RIGHT_CONSTANT && ConstantVector::IsNull(right)) {
-			if (false_sel) {
-				for (idx_t i = 0; i < count; i++) {
-					false_sel->set_index(i, sel->get_index(i));
-				}
-			}
-			return 0;
-		}
-
-		if (LEFT_CONSTANT) {
-			return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-			    ldata, rdata, sel, count, FlatVector::Validity(right), true_sel, false_sel);
-		} else if (RIGHT_CONSTANT) {
-			return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-			    ldata, rdata, sel, count, FlatVector::Validity(left), true_sel, false_sel);
-		} else {
-			ValidityMask combined_mask = FlatVector::Validity(left);
-			combined_mask.Combine(FlatVector::Validity(right), count);
-			return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-			    ldata, rdata, sel, count, combined_mask, true_sel, false_sel);
-		}
-	}
-#endif
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-#else
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-#endif
-	static inline idx_t
-	SelectGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                  const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-	                  const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
-	                  ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-#ifdef DUCKDB_SMALLER_BINARY
-		const bool HAS_TRUE_SEL = true_sel;
-		const bool HAS_FALSE_SEL = false_sel;
-		const bool NO_NULL = false;
-#endif
-		for (idx_t i = 0; i < count; i++) {
-			auto result_idx = result_sel->get_index(i);
-			auto lindex = lsel->get_index(i);
-			auto rindex = rsel->get_index(i);
-			if ((NO_NULL || (lvalidity.RowIsValid(lindex) && rvalidity.RowIsValid(rindex))) &&
-			    OP::Operation(ldata[lindex], rdata[rindex])) {
-				if (HAS_TRUE_SEL) {
-					true_sel->set_index(true_count++, result_idx);
-				}
-			} else {
-				if (HAS_FALSE_SEL) {
-					false_sel->set_index(false_count++, result_idx);
-				}
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
-	static inline idx_t
-	SelectGenericLoopSelSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                           const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-	                           const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
-	                           ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, true>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, false>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, false, true>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		}
-	}
-#endif
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static inline idx_t
-	SelectGenericLoopSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
-	                        const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-	                        const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
-	                        ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
-#ifndef DUCKDB_SMALLER_BINARY
-		if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
-			return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, false>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		} else {
-			return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, true>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		}
-#else
-		return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP>(ldata, rdata, lsel, rsel, result_sel, count, lvalidity,
-		                                                    rvalidity, true_sel, false_sel);
-#endif
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static idx_t SelectGeneric(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                           SelectionVector *true_sel, SelectionVector *false_sel) {
-		UnifiedVectorFormat ldata, rdata;
-
-		left.ToUnifiedFormat(count, ldata);
-		right.ToUnifiedFormat(count, rdata);
-
-		return SelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>(
-		    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata), ldata.sel,
-		    rdata.sel, sel, count, ldata.validity, rdata.validity, true_sel, false_sel);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel) {
-		if (!sel) {
-			sel = FlatVector::IncrementalSelectionVector();
-		}
-		if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			return SelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-#ifndef DUCKDB_SMALLER_BINARY
-		} else if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		           right.GetVectorType() == VectorType::FLAT_VECTOR) {
-			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(left, right, sel, count, true_sel, false_sel);
-		} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
-		           right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(left, right, sel, count, true_sel, false_sel);
-		} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
-		           right.GetVectorType() == VectorType::FLAT_VECTOR) {
-			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, false>(left, right, sel, count, true_sel, false_sel);
-#endif
-		} else {
-			return SelectGeneric<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/general_cast.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/general_cast.hpp
deleted file mode 100644
index ced182238..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/general_cast.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/general_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-struct VectorTryCastData {
-	VectorTryCastData(Vector &result_p, CastParameters &parameters) : result(result_p), parameters(parameters) {
-	}
-
-	Vector &result;
-	CastParameters &parameters;
-	bool all_converted = true;
-};
-
-struct HandleVectorCastError {
-	template <class RESULT_TYPE>
-	static RESULT_TYPE Operation(const string &error_message, ValidityMask &mask, idx_t idx,
-	                             VectorTryCastData &cast_data) {
-		HandleCastError::AssignError(error_message, cast_data.parameters);
-		cast_data.all_converted = false;
-		mask.SetInvalid(idx);
-		return NullValue<RESULT_TYPE>();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/generic_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/generic_executor.hpp
deleted file mode 100644
index 21ffd6b7c..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/generic_executor.hpp
+++ /dev/null
@@ -1,405 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/generic_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct PrimitiveTypeState {
-	UnifiedVectorFormat main_data;
-
-	void PrepareVector(Vector &input, idx_t count) {
-		input.ToUnifiedFormat(count, main_data);
-	}
-};
-
-template <class INPUT_TYPE>
-struct PrimitiveType {
-	PrimitiveType() = default;
-	PrimitiveType(INPUT_TYPE val) : val(val) { // NOLINT: allow implicit cast
-	}
-
-	INPUT_TYPE val;
-
-	using STRUCT_STATE = PrimitiveTypeState;
-
-	static bool ConstructType(STRUCT_STATE &state, idx_t i, PrimitiveType<INPUT_TYPE> &result) {
-		auto &vdata = state.main_data;
-		auto idx = vdata.sel->get_index(i);
-		auto ptr = UnifiedVectorFormat::GetData<INPUT_TYPE>(vdata);
-		result.val = ptr[idx];
-		return true;
-	}
-
-	static void AssignResult(Vector &result, idx_t i, PrimitiveType<INPUT_TYPE> value) {
-		auto result_data = FlatVector::GetData<INPUT_TYPE>(result);
-		result_data[i] = value.val;
-	}
-};
-
-template <idx_t CHILD_COUNT>
-struct StructTypeState {
-	UnifiedVectorFormat main_data;
-	UnifiedVectorFormat child_data[CHILD_COUNT];
-
-	void PrepareVector(Vector &input, idx_t count) {
-		auto &entries = StructVector::GetEntries(input);
-
-		input.ToUnifiedFormat(count, main_data);
-
-		for (idx_t i = 0; i < CHILD_COUNT; i++) {
-			entries[i]->ToUnifiedFormat(count, child_data[i]);
-		}
-	}
-};
-
-template <class A_TYPE>
-struct StructTypeUnary {
-	A_TYPE a_val;
-
-	using STRUCT_STATE = StructTypeState<1>;
-
-	static bool ConstructType(STRUCT_STATE &state, idx_t i, StructTypeUnary<A_TYPE> &result) {
-		auto &a_data = state.child_data[0];
-		auto a_idx = a_data.sel->get_index(i);
-		if (!a_data.validity.RowIsValid(a_idx)) {
-			return false;
-		}
-		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
-		result.a_val = a_ptr[a_idx];
-		return true;
-	}
-
-	static void AssignResult(Vector &result, idx_t i, StructTypeUnary<A_TYPE> value) {
-		auto &entries = StructVector::GetEntries(result);
-
-		auto a_data = FlatVector::GetData<A_TYPE>(*entries[0]);
-		a_data[i] = value.a_val;
-	}
-};
-
-template <class A_TYPE, class B_TYPE>
-struct StructTypeBinary {
-	A_TYPE a_val;
-	B_TYPE b_val;
-
-	using STRUCT_STATE = StructTypeState<2>;
-
-	static bool ConstructType(STRUCT_STATE &state, idx_t i, StructTypeBinary<A_TYPE, B_TYPE> &result) {
-		auto &a_data = state.child_data[0];
-		auto &b_data = state.child_data[1];
-
-		auto a_idx = a_data.sel->get_index(i);
-		auto b_idx = b_data.sel->get_index(i);
-		if (!a_data.validity.RowIsValid(a_idx) || !b_data.validity.RowIsValid(b_idx)) {
-			return false;
-		}
-		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
-		auto b_ptr = UnifiedVectorFormat::GetData<B_TYPE>(b_data);
-		result.a_val = a_ptr[a_idx];
-		result.b_val = b_ptr[b_idx];
-		return true;
-	}
-
-	static void AssignResult(Vector &result, idx_t i, StructTypeBinary<A_TYPE, B_TYPE> value) {
-		auto &entries = StructVector::GetEntries(result);
-
-		auto a_data = FlatVector::GetData<A_TYPE>(*entries[0]);
-		auto b_data = FlatVector::GetData<B_TYPE>(*entries[1]);
-		a_data[i] = value.a_val;
-		b_data[i] = value.b_val;
-	}
-};
-
-template <class A_TYPE, class B_TYPE, class C_TYPE>
-struct StructTypeTernary {
-	A_TYPE a_val;
-	B_TYPE b_val;
-	C_TYPE c_val;
-
-	using STRUCT_STATE = StructTypeState<3>;
-
-	static bool ConstructType(STRUCT_STATE &state, idx_t i, StructTypeTernary<A_TYPE, B_TYPE, C_TYPE> &result) {
-		auto &a_data = state.child_data[0];
-		auto &b_data = state.child_data[1];
-		auto &c_data = state.child_data[2];
-
-		auto a_idx = a_data.sel->get_index(i);
-		auto b_idx = b_data.sel->get_index(i);
-		auto c_idx = c_data.sel->get_index(i);
-		if (!a_data.validity.RowIsValid(a_idx) || !b_data.validity.RowIsValid(b_idx) ||
-		    !c_data.validity.RowIsValid(c_idx)) {
-			return false;
-		}
-		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
-		auto b_ptr = UnifiedVectorFormat::GetData<B_TYPE>(b_data);
-		auto c_ptr = UnifiedVectorFormat::GetData<C_TYPE>(c_data);
-		result.a_val = a_ptr[a_idx];
-		result.b_val = b_ptr[b_idx];
-		result.c_val = c_ptr[c_idx];
-		return true;
-	}
-
-	static void AssignResult(Vector &result, idx_t i, StructTypeTernary<A_TYPE, B_TYPE, C_TYPE> value) {
-		auto &entries = StructVector::GetEntries(result);
-
-		auto a_data = FlatVector::GetData<A_TYPE>(*entries[0]);
-		auto b_data = FlatVector::GetData<B_TYPE>(*entries[1]);
-		auto c_data = FlatVector::GetData<C_TYPE>(*entries[2]);
-		a_data[i] = value.a_val;
-		b_data[i] = value.b_val;
-		c_data[i] = value.c_val;
-	}
-};
-
-template <class A_TYPE, class B_TYPE, class C_TYPE, class D_TYPE>
-struct StructTypeQuaternary {
-	A_TYPE a_val;
-	B_TYPE b_val;
-	C_TYPE c_val;
-	D_TYPE d_val;
-
-	using STRUCT_STATE = StructTypeState<4>;
-
-	static bool ConstructType(STRUCT_STATE &state, idx_t i,
-	                          StructTypeQuaternary<A_TYPE, B_TYPE, C_TYPE, D_TYPE> &result) {
-		auto &a_data = state.child_data[0];
-		auto &b_data = state.child_data[1];
-		auto &c_data = state.child_data[2];
-		auto &d_data = state.child_data[3];
-
-		auto a_idx = a_data.sel->get_index(i);
-		auto b_idx = b_data.sel->get_index(i);
-		auto c_idx = c_data.sel->get_index(i);
-		auto d_idx = d_data.sel->get_index(i);
-		if (!a_data.validity.RowIsValid(a_idx) || !b_data.validity.RowIsValid(b_idx) ||
-		    !c_data.validity.RowIsValid(c_idx) || !d_data.validity.RowIsValid(d_idx)) {
-			return false;
-		}
-		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
-		auto b_ptr = UnifiedVectorFormat::GetData<B_TYPE>(b_data);
-		auto c_ptr = UnifiedVectorFormat::GetData<C_TYPE>(c_data);
-		auto d_ptr = UnifiedVectorFormat::GetData<D_TYPE>(d_data);
-		result.a_val = a_ptr[a_idx];
-		result.b_val = b_ptr[b_idx];
-		result.c_val = c_ptr[c_idx];
-		result.d_val = d_ptr[d_idx];
-		return true;
-	}
-
-	static void AssignResult(Vector &result, idx_t i, StructTypeQuaternary<A_TYPE, B_TYPE, C_TYPE, D_TYPE> value) {
-		auto &entries = StructVector::GetEntries(result);
-
-		auto a_data = FlatVector::GetData<A_TYPE>(*entries[0]);
-		auto b_data = FlatVector::GetData<B_TYPE>(*entries[1]);
-		auto c_data = FlatVector::GetData<C_TYPE>(*entries[2]);
-		auto d_data = FlatVector::GetData<D_TYPE>(*entries[3]);
-
-		a_data[i] = value.a_val;
-		b_data[i] = value.b_val;
-		c_data[i] = value.c_val;
-		d_data[i] = value.d_val;
-	}
-};
-
-template <class CHILD_TYPE>
-struct GenericListType {
-	vector<CHILD_TYPE> values;
-
-	using STRUCT_STATE = PrimitiveTypeState;
-
-	static bool ConstructType(STRUCT_STATE &state, idx_t i, GenericListType<CHILD_TYPE> &result) {
-		throw InternalException("FIXME: implement ConstructType for lists");
-	}
-
-	static void AssignResult(Vector &result, idx_t i, GenericListType<CHILD_TYPE> value) {
-		auto &child = ListVector::GetEntry(result);
-		auto current_size = ListVector::GetListSize(result);
-
-		// reserve space in the child element
-		auto list_size = value.values.size();
-		ListVector::Reserve(result, current_size + list_size);
-
-		auto list_entries = FlatVector::GetData<list_entry_t>(result);
-		list_entries[i].offset = current_size;
-		list_entries[i].length = list_size;
-
-		for (idx_t child_idx = 0; child_idx < list_size; child_idx++) {
-			CHILD_TYPE::AssignResult(child, current_size + child_idx, value.values[child_idx]);
-		}
-		ListVector::SetListSize(result, current_size + list_size);
-	}
-};
-
-//! The GenericExecutor can handle struct types in addition to primitive types
-struct GenericExecutor {
-private:
-	template <class A_TYPE, class RESULT_TYPE, class FUNC>
-	static void ExecuteUnaryInternal(Vector &input, Vector &result, idx_t count, FUNC &fun) {
-		auto constant = input.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-		typename A_TYPE::STRUCT_STATE state;
-		state.PrepareVector(input, count);
-
-		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
-			auto idx = state.main_data.sel->get_index(i);
-			if (!state.main_data.validity.RowIsValid(idx)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			A_TYPE input;
-			if (!A_TYPE::ConstructType(state, i, input)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			RESULT_TYPE::AssignResult(result, i, fun(input));
-		}
-		if (constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class RESULT_TYPE, class FUNC>
-	static void ExecuteBinaryInternal(Vector &a, Vector &b, Vector &result, idx_t count, FUNC &fun) {
-		auto constant =
-		    a.GetVectorType() == VectorType::CONSTANT_VECTOR && b.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-		typename A_TYPE::STRUCT_STATE a_state;
-		typename B_TYPE::STRUCT_STATE b_state;
-		a_state.PrepareVector(a, count);
-		b_state.PrepareVector(b, count);
-
-		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
-			auto a_idx = a_state.main_data.sel->get_index(i);
-			auto b_idx = b_state.main_data.sel->get_index(i);
-			if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			A_TYPE a_val;
-			B_TYPE b_val;
-			if (!A_TYPE::ConstructType(a_state, i, a_val) || !B_TYPE::ConstructType(b_state, i, b_val)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			RESULT_TYPE::AssignResult(result, i, fun(a_val, b_val));
-		}
-		if (constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class FUNC>
-	static void ExecuteTernaryInternal(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUNC &fun) {
-		auto constant = a.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		                b.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		                c.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-		typename A_TYPE::STRUCT_STATE a_state;
-		typename B_TYPE::STRUCT_STATE b_state;
-		typename C_TYPE::STRUCT_STATE c_state;
-
-		a_state.PrepareVector(a, count);
-		b_state.PrepareVector(b, count);
-		c_state.PrepareVector(c, count);
-
-		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
-			auto a_idx = a_state.main_data.sel->get_index(i);
-			auto b_idx = b_state.main_data.sel->get_index(i);
-			auto c_idx = c_state.main_data.sel->get_index(i);
-			if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx) ||
-			    !c_state.main_data.validity.RowIsValid(c_idx)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			A_TYPE a_val;
-			B_TYPE b_val;
-			C_TYPE c_val;
-			if (!A_TYPE::ConstructType(a_state, i, a_val) || !B_TYPE::ConstructType(b_state, i, b_val) ||
-			    !C_TYPE::ConstructType(c_state, i, c_val)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			RESULT_TYPE::AssignResult(result, i, fun(a_val, b_val, c_val));
-		}
-		if (constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class D_TYPE, class RESULT_TYPE, class FUNC>
-	static void ExecuteQuaternaryInternal(Vector &a, Vector &b, Vector &c, Vector &d, Vector &result, idx_t count,
-	                                      FUNC &fun) {
-		auto constant =
-		    a.GetVectorType() == VectorType::CONSTANT_VECTOR && b.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    c.GetVectorType() == VectorType::CONSTANT_VECTOR && d.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-		typename A_TYPE::STRUCT_STATE a_state;
-		typename B_TYPE::STRUCT_STATE b_state;
-		typename C_TYPE::STRUCT_STATE c_state;
-		typename D_TYPE::STRUCT_STATE d_state;
-
-		a_state.PrepareVector(a, count);
-		b_state.PrepareVector(b, count);
-		c_state.PrepareVector(c, count);
-		d_state.PrepareVector(d, count);
-
-		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
-			auto a_idx = a_state.main_data.sel->get_index(i);
-			auto b_idx = b_state.main_data.sel->get_index(i);
-			auto c_idx = c_state.main_data.sel->get_index(i);
-			auto d_idx = d_state.main_data.sel->get_index(i);
-			if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx) ||
-			    !c_state.main_data.validity.RowIsValid(c_idx) || !d_state.main_data.validity.RowIsValid(d_idx)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			A_TYPE a_val;
-			B_TYPE b_val;
-			C_TYPE c_val;
-			D_TYPE d_val;
-			if (!A_TYPE::ConstructType(a_state, i, a_val) || !B_TYPE::ConstructType(b_state, i, b_val) ||
-			    !C_TYPE::ConstructType(c_state, i, c_val) || !D_TYPE::ConstructType(d_state, i, d_val)) {
-				FlatVector::SetNull(result, i, true);
-				continue;
-			}
-			RESULT_TYPE::AssignResult(result, i, fun(a_val, b_val, c_val, d_val));
-		}
-		if (constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-
-public:
-	template <class A_TYPE, class RESULT_TYPE, class FUNC = std::function<RESULT_TYPE(A_TYPE)>>
-	static void ExecuteUnary(Vector &input, Vector &result, idx_t count, FUNC fun) {
-		ExecuteUnaryInternal<A_TYPE, RESULT_TYPE, FUNC>(input, result, count, fun);
-	}
-	template <class A_TYPE, class B_TYPE, class RESULT_TYPE, class FUNC = std::function<RESULT_TYPE(A_TYPE)>>
-	static void ExecuteBinary(Vector &a, Vector &b, Vector &result, idx_t count, FUNC fun) {
-		ExecuteBinaryInternal<A_TYPE, B_TYPE, RESULT_TYPE, FUNC>(a, b, result, count, fun);
-	}
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(A_TYPE)>>
-	static void ExecuteTernary(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUNC fun) {
-		ExecuteTernaryInternal<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, FUNC>(a, b, c, result, count, fun);
-	}
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class D_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(A_TYPE)>>
-	static void ExecuteQuaternary(Vector &a, Vector &b, Vector &c, Vector &d, Vector &result, idx_t count, FUNC fun) {
-		ExecuteQuaternaryInternal<A_TYPE, B_TYPE, C_TYPE, D_TYPE, RESULT_TYPE, FUNC>(a, b, c, d, result, count, fun);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/senary_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/senary_executor.hpp
deleted file mode 100644
index 490199163..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/senary_executor.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/senary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct SenaryExecutor {
-	static const size_t NCOLS = 6;
-
-	template <class TA, class TB, class TC, class TD, class TE, class TF, class TR,
-	          class FUN = std::function<TR(TA, TB, TC, TD, TE, TF)>>
-	static void Execute(DataChunk &input, Vector &result, FUN fun) {
-		D_ASSERT(input.ColumnCount() >= NCOLS);
-		const auto count = input.size();
-
-		bool all_constant = true;
-		bool any_null = false;
-		for (const auto &v : input.data) {
-			if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				if (ConstantVector::IsNull(v)) {
-					any_null = true;
-				}
-			} else {
-				all_constant = false;
-				break;
-			}
-		}
-
-		if (all_constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			if (any_null) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				auto adata = ConstantVector::GetData<TA>(input.data[0]);
-				auto bdata = ConstantVector::GetData<TB>(input.data[1]);
-				auto cdata = ConstantVector::GetData<TC>(input.data[2]);
-				auto ddata = ConstantVector::GetData<TD>(input.data[3]);
-				auto edata = ConstantVector::GetData<TE>(input.data[4]);
-				auto fdata = ConstantVector::GetData<TF>(input.data[5]);
-				auto result_data = ConstantVector::GetData<TR>(result);
-				result_data[0] = fun(*adata, *bdata, *cdata, *ddata, *edata, *fdata);
-			}
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<TR>(result);
-			auto &result_validity = FlatVector::Validity(result);
-
-			bool all_valid = true;
-			vector<UnifiedVectorFormat> vdata(NCOLS);
-			for (size_t c = 0; c < NCOLS; ++c) {
-				input.data[c].ToUnifiedFormat(count, vdata[c]);
-				all_valid = all_valid && vdata[c].validity.AllValid();
-			}
-
-			auto adata = (const TA *)(vdata[0].data);
-			auto bdata = (const TB *)(vdata[1].data);
-			auto cdata = (const TC *)(vdata[2].data);
-			auto ddata = (const TD *)(vdata[3].data);
-			auto edata = (const TE *)(vdata[4].data);
-			auto fdata = (const TF *)(vdata[5].data);
-
-			vector<idx_t> idx(NCOLS);
-			if (all_valid) {
-				for (idx_t r = 0; r < count; ++r) {
-					for (size_t c = 0; c < NCOLS; ++c) {
-						idx[c] = vdata[c].sel->get_index(r);
-					}
-					result_data[r] =
-					    fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]], fdata[idx[5]]);
-				}
-			} else {
-				for (idx_t r = 0; r < count; ++r) {
-					all_valid = true;
-					for (size_t c = 0; c < NCOLS; ++c) {
-						idx[c] = vdata[c].sel->get_index(r);
-						if (!vdata[c].validity.RowIsValid(idx[c])) {
-							result_validity.SetInvalid(r);
-							all_valid = false;
-							break;
-						}
-					}
-					if (all_valid) {
-						result_data[r] = fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]],
-						                     fdata[idx[5]]);
-					}
-				}
-			}
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/septenary_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/septenary_executor.hpp
deleted file mode 100644
index f727c0cc6..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/septenary_executor.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/septenary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct SeptenaryExecutor {
-	static const size_t NCOLS = 7;
-
-	template <class TA, class TB, class TC, class TD, class TE, class TF, class TG, class TR,
-	          class FUN = std::function<TR(TA, TB, TC, TD, TE, TF, TG)>>
-	static void Execute(DataChunk &input, Vector &result, FUN fun) {
-		D_ASSERT(input.ColumnCount() >= NCOLS);
-		const auto count = input.size();
-
-		bool all_constant = true;
-		bool any_null = false;
-		for (const auto &v : input.data) {
-			if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				if (ConstantVector::IsNull(v)) {
-					any_null = true;
-				}
-			} else {
-				all_constant = false;
-				break;
-			}
-		}
-
-		if (all_constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			if (any_null) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				auto adata = ConstantVector::GetData<TA>(input.data[0]);
-				auto bdata = ConstantVector::GetData<TB>(input.data[1]);
-				auto cdata = ConstantVector::GetData<TC>(input.data[2]);
-				auto ddata = ConstantVector::GetData<TD>(input.data[3]);
-				auto edata = ConstantVector::GetData<TE>(input.data[4]);
-				auto fdata = ConstantVector::GetData<TF>(input.data[5]);
-				auto gdata = ConstantVector::GetData<TG>(input.data[6]);
-				auto result_data = ConstantVector::GetData<TR>(result);
-				result_data[0] = fun(*adata, *bdata, *cdata, *ddata, *edata, *fdata, *gdata);
-			}
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<TR>(result);
-			auto &result_validity = FlatVector::Validity(result);
-
-			bool all_valid = true;
-			vector<UnifiedVectorFormat> vdata(NCOLS);
-			for (size_t c = 0; c < NCOLS; ++c) {
-				input.data[c].ToUnifiedFormat(count, vdata[c]);
-				all_valid = all_valid && vdata[c].validity.AllValid();
-			}
-
-			auto adata = (const TA *)(vdata[0].data);
-			auto bdata = (const TB *)(vdata[1].data);
-			auto cdata = (const TC *)(vdata[2].data);
-			auto ddata = (const TD *)(vdata[3].data);
-			auto edata = (const TE *)(vdata[4].data);
-			auto fdata = (const TF *)(vdata[5].data);
-			auto gdata = (const TG *)(vdata[6].data);
-
-			vector<idx_t> idx(NCOLS);
-			if (all_valid) {
-				for (idx_t r = 0; r < count; ++r) {
-					for (size_t c = 0; c < NCOLS; ++c) {
-						idx[c] = vdata[c].sel->get_index(r);
-					}
-					result_data[r] = fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]],
-					                     fdata[idx[5]], gdata[idx[6]]);
-				}
-			} else {
-				for (idx_t r = 0; r < count; ++r) {
-					all_valid = true;
-					for (size_t c = 0; c < NCOLS; ++c) {
-						idx[c] = vdata[c].sel->get_index(r);
-						if (!vdata[c].validity.RowIsValid(idx[c])) {
-							result_validity.SetInvalid(r);
-							all_valid = false;
-							break;
-						}
-					}
-					if (all_valid) {
-						result_data[r] = fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]],
-						                     fdata[idx[5]], gdata[idx[6]]);
-					}
-				}
-			}
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/ternary_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/ternary_executor.hpp
deleted file mode 100644
index 5fea2ab47..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/ternary_executor.hpp
+++ /dev/null
@@ -1,208 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/ternary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-template <class OP>
-struct TernaryStandardOperatorWrapper {
-	template <class FUN, class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUN fun, A_TYPE a, B_TYPE b, C_TYPE c, ValidityMask &mask, idx_t idx) {
-		return OP::template Operation<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(a, b, c);
-	}
-};
-
-struct TernaryLambdaWrapper {
-	template <class FUN, class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUN fun, A_TYPE a, B_TYPE b, C_TYPE c, ValidityMask &mask, idx_t idx) {
-		return fun(a, b, c);
-	}
-};
-
-struct TernaryLambdaWrapperWithNulls {
-	template <class FUN, class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUN fun, A_TYPE a, B_TYPE b, C_TYPE c, ValidityMask &mask, idx_t idx) {
-		return fun(a, b, c, mask, idx);
-	}
-};
-
-struct TernaryExecutor {
-private:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OPWRAPPER, class FUN>
-	static inline void ExecuteLoop(const A_TYPE *__restrict adata, const B_TYPE *__restrict bdata,
-	                               const C_TYPE *__restrict cdata, RESULT_TYPE *__restrict result_data, idx_t count,
-	                               const SelectionVector &asel, const SelectionVector &bsel,
-	                               const SelectionVector &csel, ValidityMask &avalidity, ValidityMask &bvalidity,
-	                               ValidityMask &cvalidity, ValidityMask &result_validity, FUN fun) {
-		if (!avalidity.AllValid() || !bvalidity.AllValid() || !cvalidity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				auto cidx = csel.get_index(i);
-				if (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx) && cvalidity.RowIsValid(cidx)) {
-					result_data[i] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
-					    fun, adata[aidx], bdata[bidx], cdata[cidx], result_validity, i);
-				} else {
-					result_validity.SetInvalid(i);
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				auto cidx = csel.get_index(i);
-				result_data[i] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
-				    fun, adata[aidx], bdata[bidx], cdata[cidx], result_validity, i);
-			}
-		}
-	}
-
-public:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OPWRAPPER, class FUN>
-	static void ExecuteGeneric(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun) {
-		if (a.GetVectorType() == VectorType::CONSTANT_VECTOR && b.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    c.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			if (ConstantVector::IsNull(a) || ConstantVector::IsNull(b) || ConstantVector::IsNull(c)) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				auto adata = ConstantVector::GetData<A_TYPE>(a);
-				auto bdata = ConstantVector::GetData<B_TYPE>(b);
-				auto cdata = ConstantVector::GetData<C_TYPE>(c);
-				auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-				auto &result_validity = ConstantVector::Validity(result);
-				result_data[0] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
-				    fun, adata[0], bdata[0], cdata[0], result_validity, 0);
-			}
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-
-			UnifiedVectorFormat adata, bdata, cdata;
-			a.ToUnifiedFormat(count, adata);
-			b.ToUnifiedFormat(count, bdata);
-			c.ToUnifiedFormat(count, cdata);
-
-			ExecuteLoop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OPWRAPPER>(
-			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
-			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), FlatVector::GetData<RESULT_TYPE>(result), count,
-			    *adata.sel, *bdata.sel, *cdata.sel, adata.validity, bdata.validity, cdata.validity,
-			    FlatVector::Validity(result), fun);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE,
-	          class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE)>>
-	static void Execute(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun) {
-		ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryLambdaWrapper, FUN>(a, b, c, result, count, fun);
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OP>
-	static void ExecuteStandard(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count) {
-		ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryStandardOperatorWrapper<OP>, bool>(a, b, c, result,
-		                                                                                              count, false);
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE,
-	          class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE, ValidityMask &, idx_t)>>
-	static void ExecuteWithNulls(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun) {
-		ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryLambdaWrapperWithNulls, FUN>(a, b, c, result, count,
-		                                                                                        fun);
-	}
-
-private:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-	static inline idx_t SelectLoop(const A_TYPE *__restrict adata, const B_TYPE *__restrict bdata,
-	                               const C_TYPE *__restrict cdata, const SelectionVector *result_sel, idx_t count,
-	                               const SelectionVector &asel, const SelectionVector &bsel,
-	                               const SelectionVector &csel, ValidityMask &avalidity, ValidityMask &bvalidity,
-	                               ValidityMask &cvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto result_idx = result_sel->get_index(i);
-			auto aidx = asel.get_index(i);
-			auto bidx = bsel.get_index(i);
-			auto cidx = csel.get_index(i);
-			bool comparison_result =
-			    (NO_NULL || (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx) && cvalidity.RowIsValid(cidx))) &&
-			    OP::Operation(adata[aidx], bdata[bidx], cdata[cidx]);
-			if (HAS_TRUE_SEL) {
-				true_sel->set_index(true_count, result_idx);
-				true_count += comparison_result;
-			}
-			if (HAS_FALSE_SEL) {
-				false_sel->set_index(false_count, result_idx);
-				false_count += !comparison_result;
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP, bool NO_NULL>
-	static inline idx_t SelectLoopSelSwitch(UnifiedVectorFormat &adata, UnifiedVectorFormat &bdata,
-	                                        UnifiedVectorFormat &cdata, const SelectionVector *sel, idx_t count,
-	                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, true>(
-			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
-			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
-			    adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, false>(
-			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
-			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
-			    adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, false, true>(
-			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
-			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
-			    adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP>
-	static inline idx_t SelectLoopSwitch(UnifiedVectorFormat &adata, UnifiedVectorFormat &bdata,
-	                                     UnifiedVectorFormat &cdata, const SelectionVector *sel, idx_t count,
-	                                     SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (!adata.validity.AllValid() || !bdata.validity.AllValid() || !cdata.validity.AllValid()) {
-			return SelectLoopSelSwitch<A_TYPE, B_TYPE, C_TYPE, OP, false>(adata, bdata, cdata, sel, count, true_sel,
-			                                                              false_sel);
-		} else {
-			return SelectLoopSelSwitch<A_TYPE, B_TYPE, C_TYPE, OP, true>(adata, bdata, cdata, sel, count, true_sel,
-			                                                             false_sel);
-		}
-	}
-
-public:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP>
-	static idx_t Select(Vector &a, Vector &b, Vector &c, const SelectionVector *sel, idx_t count,
-	                    SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (!sel) {
-			sel = FlatVector::IncrementalSelectionVector();
-		}
-		UnifiedVectorFormat adata, bdata, cdata;
-		a.ToUnifiedFormat(count, adata);
-		b.ToUnifiedFormat(count, bdata);
-		c.ToUnifiedFormat(count, cdata);
-
-		return SelectLoopSwitch<A_TYPE, B_TYPE, C_TYPE, OP>(adata, bdata, cdata, sel, count, true_sel, false_sel);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp
deleted file mode 100644
index 1a31822ff..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp
+++ /dev/null
@@ -1,318 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/unary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/enums/function_errors.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-struct UnaryOperatorWrapper {
-	template <class OP, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
-	}
-};
-
-struct UnaryLambdaWrapper {
-	template <class FUNC, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto fun = (FUNC *)dataptr;
-		return (*fun)(input);
-	}
-};
-
-struct GenericUnaryWrapper {
-	template <class OP, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, mask, idx, dataptr);
-	}
-};
-
-struct UnaryLambdaWrapperWithNulls {
-	template <class FUNC, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto fun = (FUNC *)dataptr;
-		return (*fun)(input, mask, idx);
-	}
-};
-
-template <class OP>
-struct UnaryStringOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto vector = reinterpret_cast<Vector *>(dataptr);
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, *vector);
-	}
-};
-
-struct UnaryExecutor {
-private:
-	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteLoop(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
-	                               const SelectionVector *__restrict sel_vector, ValidityMask &mask,
-	                               ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
-#ifdef DEBUG
-		// ldata may point to a compressed dictionary buffer which can be smaller than ldata + count
-		idx_t max_index = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel_vector->get_index(i);
-			max_index = MaxValue(max_index, idx);
-		}
-		ASSERT_RESTRICT(ldata, ldata + max_index, result_data, result_data + count);
-#endif
-
-		if (!mask.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel_vector->get_index(i);
-				if (mask.RowIsValidUnsafe(idx)) {
-					result_data[i] =
-					    OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(ldata[idx], result_mask, i, dataptr);
-				} else {
-					result_mask.SetInvalid(i);
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel_vector->get_index(i);
-				result_data[i] =
-				    OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(ldata[idx], result_mask, i, dataptr);
-			}
-		}
-	}
-
-#ifndef DUCKDB_SMALLER_BINARY
-	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteFlat(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
-	                               ValidityMask &mask, ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
-		ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
-
-		if (!mask.AllValid()) {
-			if (!adds_nulls) {
-				result_mask.Initialize(mask);
-			} else {
-				result_mask.Copy(mask, count);
-			}
-			idx_t base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						result_data[base_idx] = OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(
-						    ldata[base_idx], result_mask, base_idx, dataptr);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							D_ASSERT(mask.RowIsValid(base_idx));
-							result_data[base_idx] = OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(
-							    ldata[base_idx], result_mask, base_idx, dataptr);
-						}
-					}
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				result_data[i] =
-				    OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(ldata[i], result_mask, i, dataptr);
-			}
-		}
-	}
-#endif
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteStandard(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls,
-	                                   FunctionErrors errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR) {
-		switch (input.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-			auto ldata = ConstantVector::GetData<INPUT_TYPE>(input);
-
-			if (ConstantVector::IsNull(input)) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				ConstantVector::SetNull(result, false);
-				*result_data = OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(
-				    *ldata, ConstantVector::Validity(result), 0, dataptr);
-			}
-			break;
-		}
-#ifndef DUCKDB_SMALLER_BINARY
-		case VectorType::FLAT_VECTOR: {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-			auto ldata = FlatVector::GetData<INPUT_TYPE>(input);
-
-			ExecuteFlat<INPUT_TYPE, RESULT_TYPE, OPWRAPPER, OP>(ldata, result_data, count, FlatVector::Validity(input),
-			                                                    FlatVector::Validity(result), dataptr, adds_nulls);
-			break;
-		}
-		case VectorType::DICTIONARY_VECTOR: {
-			// dictionary vector - we can run the function ONLY on the dictionary in some cases
-			// we can only do this if the function does not throw errors
-			// we can execute the function on a value that is in the dictionary but that is not referenced
-			// if the function can throw errors - this will result in us (incorrectly) throwing an error
-			if (errors == FunctionErrors::CANNOT_ERROR) {
-				static constexpr idx_t DICTIONARY_THRESHOLD = 2;
-				auto dict_size = DictionaryVector::DictionarySize(input);
-				if (dict_size.IsValid() && dict_size.GetIndex() * DICTIONARY_THRESHOLD <= count) {
-					// we can operate directly on the dictionary if we have a dictionary size
-					// but this only makes sense if the dictionary size is smaller than the count by some factor
-					auto &dictionary_values = DictionaryVector::Child(input);
-					if (dictionary_values.GetVectorType() == VectorType::FLAT_VECTOR) {
-						// execute the function over the dictionary
-						auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-						auto ldata = FlatVector::GetData<INPUT_TYPE>(dictionary_values);
-						ExecuteFlat<INPUT_TYPE, RESULT_TYPE, OPWRAPPER, OP>(
-						    ldata, result_data, dict_size.GetIndex(), FlatVector::Validity(dictionary_values),
-						    FlatVector::Validity(result), dataptr, adds_nulls);
-						// slice the result with the original offsets
-						auto &offsets = DictionaryVector::SelVector(input);
-						result.Dictionary(result, dict_size.GetIndex(), offsets, count);
-						break;
-					}
-				}
-			}
-			DUCKDB_EXPLICIT_FALLTHROUGH;
-		}
-#endif
-		default: {
-			UnifiedVectorFormat vdata;
-			input.ToUnifiedFormat(count, vdata);
-
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-			auto ldata = UnifiedVectorFormat::GetData<INPUT_TYPE>(vdata);
-
-			ExecuteLoop<INPUT_TYPE, RESULT_TYPE, OPWRAPPER, OP>(ldata, result_data, count, vdata.sel, vdata.validity,
-			                                                    FlatVector::Validity(result), dataptr, adds_nulls);
-			break;
-		}
-		}
-	}
-
-public:
-	template <class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void Execute(Vector &input, Vector &result, idx_t count) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, UnaryOperatorWrapper, OP>(input, result, count, nullptr, false);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class FUNC = std::function<RESULT_TYPE(INPUT_TYPE)>>
-	static void Execute(Vector &input, Vector &result, idx_t count, FUNC fun,
-	                    FunctionErrors errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, UnaryLambdaWrapper, FUNC>(
-		    input, result, count, reinterpret_cast<void *>(&fun), false, errors);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void GenericExecute(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls = false) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, GenericUnaryWrapper, OP>(input, result, count, dataptr, adds_nulls);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(INPUT_TYPE, ValidityMask &, idx_t)>>
-	static void ExecuteWithNulls(Vector &input, Vector &result, idx_t count, FUNC fun) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, UnaryLambdaWrapperWithNulls, FUNC>(input, result, count, (void *)&fun,
-		                                                                            true);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void ExecuteString(Vector &input, Vector &result, idx_t count) {
-		UnaryExecutor::GenericExecute<INPUT_TYPE, RESULT_TYPE, UnaryStringOperator<OP>>(input, result, count,
-		                                                                                (void *)&result);
-	}
-
-private:
-	// Select logic copied from TernaryExecutor, but with a lambda instead of a static functor
-	template <class INPUT_TYPE, class FUNC = std::function<bool(INPUT_TYPE)>, bool NO_NULL, bool HAS_TRUE_SEL,
-	          bool HAS_FALSE_SEL>
-	static inline idx_t SelectLoop(const INPUT_TYPE *__restrict input_data, const SelectionVector *result_sel,
-	                               const idx_t count, FUNC fun, const SelectionVector &input_sel,
-	                               ValidityMask &input_validity, SelectionVector *true_sel,
-	                               SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			const auto result_idx = result_sel->get_index(i);
-			const auto idx = input_sel.get_index(i);
-			const bool comparison_result = (NO_NULL || input_validity.RowIsValid(idx)) && fun(input_data[idx]);
-			if (HAS_TRUE_SEL) {
-				true_sel->set_index(true_count, result_idx);
-				true_count += comparison_result;
-			}
-			if (HAS_FALSE_SEL) {
-				false_sel->set_index(false_count, result_idx);
-				false_count += !comparison_result;
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-
-	template <class INPUT_TYPE, class FUNC = std::function<bool(INPUT_TYPE)>, bool NO_NULL>
-	static inline idx_t SelectLoopSelSwitch(UnifiedVectorFormat &input_data, const SelectionVector *sel,
-	                                        const idx_t count, FUNC fun, SelectionVector *true_sel,
-	                                        SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectLoop<INPUT_TYPE, FUNC, NO_NULL, true, true>(
-			    UnifiedVectorFormat::GetData<INPUT_TYPE>(input_data), sel, count, fun, *input_data.sel,
-			    input_data.validity, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectLoop<INPUT_TYPE, FUNC, NO_NULL, true, false>(
-			    UnifiedVectorFormat::GetData<INPUT_TYPE>(input_data), sel, count, fun, *input_data.sel,
-			    input_data.validity, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectLoop<INPUT_TYPE, FUNC, NO_NULL, false, true>(
-			    UnifiedVectorFormat::GetData<INPUT_TYPE>(input_data), sel, count, fun, *input_data.sel,
-			    input_data.validity, true_sel, false_sel);
-		}
-	}
-
-	template <class INPUT_TYPE, class FUNC = std::function<bool(INPUT_TYPE)>>
-	static inline idx_t SelectLoopSwitch(UnifiedVectorFormat &input_data, const SelectionVector *sel, const idx_t count,
-	                                     FUNC fun, SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (!input_data.validity.AllValid()) {
-			return SelectLoopSelSwitch<INPUT_TYPE, FUNC, false>(input_data, sel, count, fun, true_sel, false_sel);
-		} else {
-			return SelectLoopSelSwitch<INPUT_TYPE, FUNC, true>(input_data, sel, count, fun, true_sel, false_sel);
-		}
-	}
-
-public:
-	template <class INPUT_TYPE, class FUNC = std::function<bool(INPUT_TYPE)>>
-	static idx_t Select(Vector &input, const SelectionVector *sel, const idx_t count, FUNC fun,
-	                    SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (!sel) {
-			sel = FlatVector::IncrementalSelectionVector();
-		}
-		UnifiedVectorFormat input_data;
-		input.ToUnifiedFormat(count, input_data);
-
-		return SelectLoopSwitch<INPUT_TYPE, FUNC>(input_data, sel, count, fun, true_sel, false_sel);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/vector_operations.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/vector_operations.hpp
deleted file mode 100644
index 20219ea42..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_operations/vector_operations.hpp
+++ /dev/null
@@ -1,204 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/vector_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-#include <functional>
-
-namespace duckdb {
-class CastFunctionSet;
-struct GetCastFunctionInput;
-
-// VectorOperations contains a set of operations that operate on sets of
-// vectors. In general, the operators must all have the same type, otherwise an
-// exception is thrown. Note that the functions underneath use restrict
-// pointers, hence the data that the vectors point to (and hence the vector
-// themselves) should not be equal! For example, if you call the function Add(A,
-// B, A) then ASSERT_RESTRICT will be triggered. Instead call AddInPlace(A, B)
-// or Add(A, B, C)
-struct VectorOperations {
-	//===--------------------------------------------------------------------===//
-	// In-Place Operators
-	//===--------------------------------------------------------------------===//
-	//! left += delta
-	static void AddInPlace(Vector &left, int64_t delta, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// NULL Operators
-	//===--------------------------------------------------------------------===//
-	//! result = IS NOT NULL(input)
-	static void IsNotNull(Vector &arg, Vector &result, idx_t count);
-	//! result = IS NULL (input)
-	static void IsNull(Vector &input, Vector &result, idx_t count);
-	// Returns whether or not arg vector has a NULL value
-	static bool HasNull(Vector &input, idx_t count);
-	static bool HasNotNull(Vector &input, idx_t count);
-	//! Count the number of not-NULL values.
-	static idx_t CountNotNull(Vector &input, const idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Boolean Operations
-	//===--------------------------------------------------------------------===//
-	// result = left && right
-	static void And(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left || right
-	static void Or(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = NOT(left)
-	static void Not(Vector &left, Vector &result, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Comparison Operations
-	//===--------------------------------------------------------------------===//
-	// result = left == right
-	static void Equals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left != right
-	static void NotEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left > right
-	static void GreaterThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left >= right
-	static void GreaterThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left < right
-	static void LessThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left <= right
-	static void LessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-
-	// result = A != B with nulls being equal
-	static void DistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A == B with nulls being equal
-	static void NotDistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A > B with nulls being maximal
-	static void DistinctGreaterThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A >= B with nulls being maximal
-	static void DistinctGreaterThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A < B with nulls being maximal
-	static void DistinctLessThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A <= B with nulls being maximal
-	static void DistinctLessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Select Comparisons
-	//===--------------------------------------------------------------------===//
-	static idx_t Equals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                    optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                    optional_ptr<ValidityMask> null_mask = nullptr);
-	static idx_t NotEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                       optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                       optional_ptr<ValidityMask> null_mask = nullptr);
-	static idx_t GreaterThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                         optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                         optional_ptr<ValidityMask> null_mask = nullptr);
-	static idx_t GreaterThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                               optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                               optional_ptr<ValidityMask> null_mask = nullptr);
-	static idx_t LessThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                      optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                      optional_ptr<ValidityMask> null_mask = nullptr);
-	static idx_t LessThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                            optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                            optional_ptr<ValidityMask> null_mask = nullptr);
-
-	// true := A != B with nulls being equal
-	static idx_t DistinctFrom(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                          optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel);
-	// true := A == B with nulls being equal
-	static idx_t NotDistinctFrom(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                             optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel);
-	// true := A > B with nulls being maximal
-	static idx_t DistinctGreaterThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                                 optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                                 optional_ptr<ValidityMask> null_mask = nullptr);
-	// true := A >= B with nulls being maximal
-	static idx_t DistinctGreaterThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-	                                       idx_t count, optional_ptr<SelectionVector> true_sel,
-	                                       optional_ptr<SelectionVector> false_sel,
-	                                       optional_ptr<ValidityMask> null_mask = nullptr);
-	// true := A < B with nulls being maximal
-	static idx_t DistinctLessThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                              optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                              optional_ptr<ValidityMask> null_mask = nullptr);
-	// true := A <= B with nulls being maximal
-	static idx_t DistinctLessThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-	                                    idx_t count, optional_ptr<SelectionVector> true_sel,
-	                                    optional_ptr<SelectionVector> false_sel,
-	                                    optional_ptr<ValidityMask> null_mask = nullptr);
-	// true := A > B with nulls being minimal
-	static idx_t DistinctGreaterThanNullsFirst(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-	                                           idx_t count, optional_ptr<SelectionVector> true_sel,
-	                                           optional_ptr<SelectionVector> false_sel,
-	                                           optional_ptr<ValidityMask> null_mask = nullptr);
-	// true := A < B with nulls being minimal
-	static idx_t DistinctLessThanNullsFirst(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
-	                                        idx_t count, optional_ptr<SelectionVector> true_sel,
-	                                        optional_ptr<SelectionVector> false_sel,
-	                                        optional_ptr<ValidityMask> null_mask = nullptr);
-
-	//===--------------------------------------------------------------------===//
-	// Nested Comparisons
-	//===--------------------------------------------------------------------===//
-	// true := A != B with nulls being equal
-	static idx_t NestedNotEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                             optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                             optional_ptr<ValidityMask> null_mask = nullptr);
-	// true := A == B with nulls being equal
-	static idx_t NestedEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
-	                          optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
-	                          optional_ptr<ValidityMask> null_mask = nullptr);
-
-	//===--------------------------------------------------------------------===//
-	// Hash functions
-	//===--------------------------------------------------------------------===//
-	// hashes = HASH(input)
-	static void Hash(Vector &input, Vector &hashes, idx_t count);
-	static void Hash(Vector &input, Vector &hashes, const SelectionVector &rsel, idx_t count);
-	// hashes ^= HASH(input)
-	static void CombineHash(Vector &hashes, Vector &input, idx_t count);
-	static void CombineHash(Vector &hashes, Vector &input, const SelectionVector &rsel, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Generate functions
-	//===--------------------------------------------------------------------===//
-	static void GenerateSequence(Vector &result, idx_t count, int64_t start = 0, int64_t increment = 1);
-	static void GenerateSequence(Vector &result, idx_t count, const SelectionVector &sel, int64_t start = 0,
-	                             int64_t increment = 1);
-	//===--------------------------------------------------------------------===//
-	// Helpers
-	//===--------------------------------------------------------------------===//
-	//! Cast the data from the source type to the target type. Any elements that could not be converted are turned into
-	//! NULLs. If any elements cannot be converted, returns false and fills in the error_message. If no error message is
-	//! provided, an exception is thrown instead.
-	DUCKDB_API static bool TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result,
-	                               idx_t count, string *error_message, bool strict = false,
-	                               const bool nullify_parent = false);
-	DUCKDB_API static bool DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message,
-	                                      bool strict = false);
-	DUCKDB_API static bool TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count,
-	                               string *error_message, bool strict = false, const bool nullify_parent = false);
-	//! Cast the data from the source type to the target type. Throws an exception if the cast fails.
-	DUCKDB_API static void Cast(ClientContext &context, Vector &source, Vector &result, idx_t count,
-	                            bool strict = false);
-	DUCKDB_API static void DefaultCast(Vector &source, Vector &result, idx_t count, bool strict = false);
-
-	// Copy the data of <source> to the target vector
-	static void Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
-	                 idx_t target_offset);
-	static void Copy(const Vector &source, Vector &target, const SelectionVector &sel, idx_t source_count,
-	                 idx_t source_offset, idx_t target_offset);
-	static void Copy(const Vector &source, Vector &target, const SelectionVector &sel, idx_t source_count,
-	                 idx_t source_offset, idx_t target_offset, idx_t copy_count);
-
-	// Copy the data of <source> to the target location, setting null values to
-	// NullValue<T>. Used to store data without separate NULL mask.
-	static void WriteToStorage(Vector &source, idx_t count, data_ptr_t target);
-	// Reads the data of <source> to the target vector, setting the nullmask
-	// for any NullValue<T> of source. Used to go back from storage to a proper vector
-	static void ReadFromStorage(data_ptr_t source, idx_t count, Vector &result);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/vector_size.hpp b/src/duckdb/src/include/duckdb/common/vector_size.hpp
deleted file mode 100644
index 3eb73b36b..000000000
--- a/src/duckdb/src/include/duckdb/common/vector_size.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_size.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-//! The default standard vector size
-#define DEFAULT_STANDARD_VECTOR_SIZE 2048U
-
-//! The vector size used in the execution engine
-#ifndef STANDARD_VECTOR_SIZE
-#define STANDARD_VECTOR_SIZE DEFAULT_STANDARD_VECTOR_SIZE
-#endif
-
-#if (STANDARD_VECTOR_SIZE & (STANDARD_VECTOR_SIZE - 1) != 0)
-#error The vector size must be a power of two
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp b/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp
deleted file mode 100644
index 110ad0487..000000000
--- a/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/virtual_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-// bunch of wrappers to allow registering protocol handlers
-class VirtualFileSystem : public FileSystem {
-public:
-	VirtualFileSystem();
-
-	unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
-	                                optional_ptr<FileOpener> opener = nullptr) override;
-
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	int64_t GetFileSize(FileHandle &handle) override;
-	time_t GetLastModifiedTime(FileHandle &handle) override;
-	FileType GetFileType(FileHandle &handle) override;
-
-	void Truncate(FileHandle &handle, int64_t new_size) override;
-
-	void FileSync(FileHandle &handle) override;
-
-	// need to look up correct fs for this
-	bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) override;
-	void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) override;
-
-	void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) override;
-
-	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-	               FileOpener *opener = nullptr) override;
-
-	void MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) override;
-
-	bool FileExists(const string &filename, optional_ptr<FileOpener> opener) override;
-
-	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener) override;
-	void RemoveFile(const string &filename, optional_ptr<FileOpener> opener) override;
-
-	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override;
-
-	void RegisterSubSystem(unique_ptr<FileSystem> fs) override;
-
-	void UnregisterSubSystem(const string &name) override;
-
-	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override;
-
-	vector<string> ListSubSystems() override;
-
-	std::string GetName() const override;
-
-	void SetDisabledFileSystems(const vector<string> &names) override;
-
-	string PathSeparator(const string &path) override;
-
-private:
-	FileSystem &FindFileSystem(const string &path);
-	FileSystem &FindFileSystemInternal(const string &path);
-
-private:
-	vector<unique_ptr<FileSystem>> sub_systems;
-	map<FileCompressionType, unique_ptr<FileSystem>> compressed_fs;
-	const unique_ptr<FileSystem> default_fs;
-	unordered_set<string> disabled_file_systems;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/weak_ptr_ipp.hpp b/src/duckdb/src/include/duckdb/common/weak_ptr_ipp.hpp
deleted file mode 100644
index 076fde953..000000000
--- a/src/duckdb/src/include/duckdb/common/weak_ptr_ipp.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-namespace duckdb {
-
-template <typename T, bool SAFE>
-class weak_ptr { // NOLINT: invalid case style
-public:
-	using original = std::weak_ptr<T>;
-	using element_type = typename original::element_type;
-
-private:
-	template <class U, bool SAFE_P>
-	friend class shared_ptr;
-
-private:
-	original internal;
-
-public:
-	// Constructors
-	weak_ptr() : internal() {
-	}
-
-	// NOLINTBEGIN
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	weak_ptr(shared_ptr<U, SAFE> const &ptr) noexcept : internal(ptr.internal) {
-	}
-	weak_ptr(weak_ptr const &other) noexcept : internal(other.internal) {
-	}
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	weak_ptr(weak_ptr<U> const &ptr) noexcept : internal(ptr.internal) {
-	}
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	weak_ptr(weak_ptr &&ptr) noexcept
-	    : internal(std::move(ptr.internal)) {
-	}
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-#ifdef DUCKDB_CLANG_TIDY
-	[[clang::reinitializes]]
-#endif
-	weak_ptr(weak_ptr<U> &&ptr) noexcept
-	    : internal(std::move(ptr.internal)) {
-	}
-	// NOLINTEND
-	// Destructor
-	~weak_ptr() = default;
-
-	// Assignment operators
-	weak_ptr &operator=(const weak_ptr &other) {
-		if (this == &other) {
-			return *this;
-		}
-		internal = other.internal;
-		return *this;
-	}
-
-	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
-	weak_ptr &operator=(const shared_ptr<U, SAFE> &ptr) {
-		internal = ptr.internal;
-		return *this;
-	}
-
-	// Modifiers
-#ifdef DUCKDB_CLANG_TIDY
-	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
-	[[clang::reinitializes]]
-#endif
-	void
-	reset() { // NOLINT: invalid case style
-		internal.reset();
-	}
-
-	// Observers
-	long use_count() const { // NOLINT: invalid case style
-		return internal.use_count();
-	}
-
-	bool expired() const { // NOLINT: invalid case style
-		return internal.expired();
-	}
-
-	shared_ptr<T, SAFE> lock() const { // NOLINT: invalid case style
-		return shared_ptr<T, SAFE>(internal.lock());
-	}
-
-	// Relational operators
-	template <typename U>
-	bool operator==(const weak_ptr<U> &other) const noexcept {
-		return internal == other.internal;
-	}
-
-	template <typename U>
-	bool operator!=(const weak_ptr<U> &other) const noexcept {
-		return internal != other.internal;
-	}
-
-	template <typename U>
-	bool operator<(const weak_ptr<U> &other) const noexcept {
-		return internal < other.internal;
-	}
-
-	template <typename U>
-	bool operator<=(const weak_ptr<U> &other) const noexcept {
-		return internal <= other.internal;
-	}
-
-	template <typename U>
-	bool operator>(const weak_ptr<U> &other) const noexcept {
-		return internal > other.internal;
-	}
-
-	template <typename U>
-	bool operator>=(const weak_ptr<U> &other) const noexcept {
-		return internal >= other.internal;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/common/winapi.hpp b/src/duckdb/src/include/duckdb/common/winapi.hpp
deleted file mode 100644
index 6579a9ce7..000000000
--- a/src/duckdb/src/include/duckdb/common/winapi.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/winapi.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#ifndef DUCKDB_API
-#if defined(_WIN32) && !defined(__MINGW32__)
-#ifdef DUCKDB_STATIC_BUILD
-#define DUCKDB_API
-#else
-#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
-#define DUCKDB_API __declspec(dllexport)
-#else
-#define DUCKDB_API __declspec(dllimport)
-#endif
-#endif
-#else
-#define DUCKDB_API
-#endif
-#endif
-
-#ifndef DUCKDB_EXTENSION_API
-#ifdef _WIN32
-#ifdef DUCKDB_STATIC_BUILD
-#define DUCKDB_EXTENSION_API
-#else
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
-#define DUCKDB_EXTENSION_API __declspec(dllexport)
-#else
-#define DUCKDB_EXTENSION_API
-#endif
-#endif
-#else
-#define DUCKDB_EXTENSION_API __attribute__((visibility("default")))
-#endif
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/windows.hpp b/src/duckdb/src/include/duckdb/common/windows.hpp
deleted file mode 100644
index dc1b56534..000000000
--- a/src/duckdb/src/include/duckdb/common/windows.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#if defined(_WIN32)
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-
-#ifndef _WINSOCKAPI_
-#define _WINSOCKAPI_
-#endif
-
-#include <windows.h>
-
-#undef CreateDirectory
-#undef MoveFile
-#undef RemoveDirectory
-
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/windows_undefs.hpp b/src/duckdb/src/include/duckdb/common/windows_undefs.hpp
deleted file mode 100644
index c991f32bf..000000000
--- a/src/duckdb/src/include/duckdb/common/windows_undefs.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/windows_undefs.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-// Do not add a header inclusion guard to this file. Otherwise these Win32 macros
-// may get defined and stomp on DuckDB symbols
-
-#ifdef WIN32
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-#ifdef ERROR
-#undef ERROR
-#endif
-
-#ifdef small
-#undef small
-#endif
-
-#ifdef CreateDirectory
-#undef CreateDirectory
-#endif
-
-#ifdef MoveFile
-#undef MoveFile
-#endif
-
-#ifdef RemoveDirectory
-#undef RemoveDirectory
-#endif
-
-#ifdef UUID
-#undef UUID
-#endif
-
-#endif
diff --git a/src/duckdb/src/include/duckdb/common/windows_util.hpp b/src/duckdb/src/include/duckdb/common/windows_util.hpp
deleted file mode 100644
index 18a02d097..000000000
--- a/src/duckdb/src/include/duckdb/common/windows_util.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/windows_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/windows.hpp"
-
-namespace duckdb {
-
-#ifdef DUCKDB_WINDOWS
-class WindowsUtil {
-public:
-	//! Windows helper functions
-	static std::wstring UTF8ToUnicode(const char *input);
-	static string UnicodeToUTF8(LPCWSTR input);
-	static string UTF8ToMBCS(const char *input, bool use_ansi = false);
-};
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/adaptive_filter.hpp b/src/duckdb/src/include/duckdb/execution/adaptive_filter.hpp
deleted file mode 100644
index 6aea5ab51..000000000
--- a/src/duckdb/src/include/duckdb/execution/adaptive_filter.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/adaptive_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/random_engine.hpp"
-
-namespace duckdb {
-
-struct AdaptiveFilterState {
-	time_point<high_resolution_clock> start_time;
-};
-
-class AdaptiveFilter {
-public:
-	explicit AdaptiveFilter(const Expression &expr);
-	explicit AdaptiveFilter(const TableFilterSet &table_filters);
-
-	vector<idx_t> permutation;
-
-public:
-	void AdaptRuntimeStatistics(double duration);
-
-	AdaptiveFilterState BeginFilter() const;
-	void EndFilter(AdaptiveFilterState state);
-
-private:
-	bool disable_permutations = false;
-
-	//! used for adaptive expression reordering
-	idx_t iteration_count = 0;
-	idx_t swap_idx = 0;
-	idx_t right_random_border = 0;
-	idx_t observe_interval = 0;
-	idx_t execute_interval = 0;
-	double runtime_sum = 0;
-	double prev_mean = 0;
-	bool observe = false;
-	bool warmup = false;
-	vector<idx_t> swap_likeliness;
-	RandomEngine generator;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp b/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp
deleted file mode 100644
index e44c90363..000000000
--- a/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp
+++ /dev/null
@@ -1,201 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/aggregate_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/row_operations/row_matcher.hpp"
-#include "duckdb/common/types/row/partitioned_tuple_data.hpp"
-#include "duckdb/execution/base_aggregate_hashtable.hpp"
-#include "duckdb/execution/ht_entry.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-
-class BlockHandle;
-class BufferHandle;
-
-struct FlushMoveState;
-
-//! GroupedAggregateHashTable is a linear probing HT that is used for computing
-//! aggregates
-/*!
-    GroupedAggregateHashTable is a HT that is used for computing aggregates. It takes
-   as input the set of groups and the types of the aggregates to compute and
-   stores them in the HT. It uses linear probing for collision resolution.
-*/
-
-class GroupedAggregateHashTable : public BaseAggregateHashTable {
-public:
-	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
-	                          vector<LogicalType> payload_types, const vector<BoundAggregateExpression *> &aggregates,
-	                          idx_t initial_capacity = InitialCapacity(), idx_t radix_bits = 0);
-	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
-	                          vector<LogicalType> payload_types, vector<AggregateObject> aggregates,
-	                          idx_t initial_capacity = InitialCapacity(), idx_t radix_bits = 0);
-	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types);
-	~GroupedAggregateHashTable() override;
-
-public:
-	//! The hash table load factor, when a resize is triggered
-	constexpr static double LOAD_FACTOR = 1.25;
-
-	//! Get the layout of this HT
-	const TupleDataLayout &GetLayout() const;
-	//! Number of groups in the HT
-	idx_t Count() const;
-	//! Initial capacity of the HT
-	static idx_t InitialCapacity();
-	//! Capacity that can hold 'count' entries without resizing
-	static idx_t GetCapacityForCount(idx_t count);
-	//! Current capacity of the HT
-	idx_t Capacity() const;
-	//! Threshold at which to resize the HT
-	idx_t ResizeThreshold() const;
-	static idx_t ResizeThreshold(idx_t capacity);
-
-	//! Add the given data to the HT, computing the aggregates grouped by the
-	//! data in the group chunk. When resize = true, aggregates will not be
-	//! computed but instead just assigned.
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, const unsafe_vector<idx_t> &filter);
-	idx_t AddChunk(DataChunk &groups, Vector &group_hashes, DataChunk &payload, const unsafe_vector<idx_t> &filter);
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, AggregateType filter);
-	optional_idx TryAddCompressedGroups(DataChunk &groups, DataChunk &payload, const unsafe_vector<idx_t> &filter);
-	optional_idx TryAddDictionaryGroups(DataChunk &groups, DataChunk &payload, const unsafe_vector<idx_t> &filter);
-	optional_idx TryAddConstantGroups(DataChunk &groups, DataChunk &payload, const unsafe_vector<idx_t> &filter);
-
-	//! Fetch the aggregates for specific groups from the HT and place them in the result
-	void FetchAggregates(DataChunk &groups, DataChunk &result);
-
-	//! Finds or creates groups in the hashtable using the specified group keys. The addresses vector will be filled
-	//! with pointers to the groups in the hash table, and the new_groups selection vector will point to the newly
-	//! created groups. The return value is the amount of newly created groups.
-	idx_t FindOrCreateGroups(DataChunk &groups, Vector &group_hashes, Vector &addresses_out,
-	                         SelectionVector &new_groups_out);
-	idx_t FindOrCreateGroups(DataChunk &groups, Vector &addresses_out, SelectionVector &new_groups_out);
-	void FindOrCreateGroups(DataChunk &groups, Vector &addresses_out);
-
-	const PartitionedTupleData &GetPartitionedData() const;
-	unique_ptr<PartitionedTupleData> AcquirePartitionedData();
-	void Abandon();
-	void Repartition();
-	shared_ptr<ArenaAllocator> GetAggregateAllocator();
-
-	//! Resize the HT to the specified size. Must be larger than the current size.
-	void Resize(idx_t size);
-	//! Resets the pointer table of the HT to all 0's
-	void ClearPointerTable();
-	//! Set the radix bits for this HT
-	void SetRadixBits(idx_t radix_bits);
-	//! Get the radix bits for this HT
-	idx_t GetRadixBits() const;
-	//! Get the total amount of data sunk into this HT
-	idx_t GetSinkCount() const;
-	//! Skips lookups from here on out
-	void SkipLookups();
-
-	//! Executes the filter(if any) and update the aggregates
-	void Combine(GroupedAggregateHashTable &other);
-	void Combine(TupleDataCollection &other_data, optional_ptr<atomic<double>> progress = nullptr);
-
-private:
-	//! Efficiently matches groups
-	RowMatcher row_matcher;
-
-	struct AggregateDictionaryState {
-		AggregateDictionaryState();
-
-		//! The current dictionary vector id (if any)
-		string dictionary_id;
-		DataChunk unique_values;
-		Vector hashes;
-		Vector new_dictionary_pointers;
-		SelectionVector unique_entries;
-		unique_ptr<Vector> dictionary_addresses;
-		unsafe_unique_array<bool> found_entry;
-		idx_t capacity = 0;
-	};
-
-	//! Append state
-	struct AggregateHTAppendState {
-		AggregateHTAppendState();
-
-		PartitionedTupleDataAppendState partitioned_append_state;
-		PartitionedTupleDataAppendState unpartitioned_append_state;
-
-		Vector ht_offsets;
-		Vector hash_salts;
-		SelectionVector group_compare_vector;
-		SelectionVector no_match_vector;
-		SelectionVector empty_vector;
-		SelectionVector new_groups;
-		Vector addresses;
-		unsafe_unique_array<UnifiedVectorFormat> group_data;
-		DataChunk group_chunk;
-		AggregateDictionaryState dict_state;
-	} state;
-
-	//! If we have this many or more radix bits, we use the unpartitioned data collection too
-	static constexpr idx_t UNPARTITIONED_RADIX_BITS_THRESHOLD = 3;
-	//! The number of radix bits to partition by
-	idx_t radix_bits;
-	//! The data of the HT
-	unique_ptr<PartitionedTupleData> partitioned_data;
-	unique_ptr<PartitionedTupleData> unpartitioned_data;
-
-	//! Predicates for matching groups (always ExpressionType::COMPARE_EQUAL)
-	vector<ExpressionType> predicates;
-
-	//! The number of groups in the HT
-	idx_t count;
-	//! The capacity of the HT. This can be increased using GroupedAggregateHashTable::Resize
-	idx_t capacity;
-	//! The hash map (pointer table) of the HT: allocated data and pointer into it
-	AllocatedData hash_map;
-	ht_entry_t *entries;
-	//! Offset of the hash column in the rows
-	idx_t hash_offset;
-	//! Bitmask for getting relevant bits from the hashes to determine the position
-	hash_t bitmask;
-
-	//! How many tuples went into this HT (before de-duplication)
-	idx_t sink_count;
-	//! If true, we just append, skipping HT lookups
-	bool skip_lookups;
-
-	//! The active arena allocator used by the aggregates for their internal state
-	shared_ptr<ArenaAllocator> aggregate_allocator;
-	//! Owning arena allocators that this HT has data from
-	vector<shared_ptr<ArenaAllocator>> stored_allocators;
-
-private:
-	//! Disabled the copy constructor
-	GroupedAggregateHashTable(const GroupedAggregateHashTable &) = delete;
-	//! Destroy the HT
-	void Destroy();
-
-	//! Initializes the PartitionedTupleData
-	void InitializePartitionedData();
-	//! Initializes the PartitionedTupleData that only has 1 partition
-	void InitializeUnpartitionedData();
-	//! Apply bitmask to get the entry in the HT
-	inline idx_t ApplyBitMask(hash_t hash) const;
-	//! Reinserts tuples (triggered by Resize)
-	void ReinsertTuples(PartitionedTupleData &data);
-
-	void UpdateAggregates(DataChunk &payload, const unsafe_vector<idx_t> &filter);
-
-	//! Does the actual group matching / creation
-	idx_t FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes, Vector &addresses,
-	                                 SelectionVector &new_groups);
-
-	//! Verify the pointer table of the HT
-	void Verify();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/base_aggregate_hashtable.hpp b/src/duckdb/src/include/duckdb/execution/base_aggregate_hashtable.hpp
deleted file mode 100644
index df4f72882..000000000
--- a/src/duckdb/src/include/duckdb/execution/base_aggregate_hashtable.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/base_aggregate_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-
-namespace duckdb {
-class BufferManager;
-
-class BaseAggregateHashTable {
-public:
-	BaseAggregateHashTable(ClientContext &context, Allocator &allocator, const vector<AggregateObject> &aggregates,
-	                       vector<LogicalType> payload_types);
-	virtual ~BaseAggregateHashTable() {
-	}
-
-protected:
-	Allocator &allocator;
-	BufferManager &buffer_manager;
-	//! A helper for managing offsets into the data buffers
-	TupleDataLayout layout;
-	//! The types of the payload columns stored in the hashtable
-	vector<LogicalType> payload_types;
-	//! Intermediate structures and data for aggregate filters
-	AggregateFilterDataSet filter_set;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/column_binding_resolver.hpp b/src/duckdb/src/include/duckdb/execution/column_binding_resolver.hpp
deleted file mode 100644
index f98aeb2cf..000000000
--- a/src/duckdb/src/include/duckdb/execution/column_binding_resolver.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/column_binding_resolver.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-//! The ColumnBindingResolver resolves ColumnBindings into base tables
-//! (table_index, column_index) into physical indices into the DataChunks that
-//! are used within the execution engine
-class ColumnBindingResolver : public LogicalOperatorVisitor {
-public:
-	explicit ColumnBindingResolver(bool verify_only = false);
-
-	void VisitOperator(LogicalOperator &op) override;
-	static void Verify(LogicalOperator &op);
-
-protected:
-	vector<ColumnBinding> bindings;
-	bool verify_only;
-
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	static unordered_set<idx_t> VerifyInternal(LogicalOperator &op);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/execution_context.hpp b/src/duckdb/src/include/duckdb/execution/execution_context.hpp
deleted file mode 100644
index 597094c38..000000000
--- a/src/duckdb/src/include/duckdb/execution/execution_context.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/execution_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-class ClientContext;
-class ThreadContext;
-class Pipeline;
-
-class ExecutionContext {
-public:
-	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p, optional_ptr<Pipeline> pipeline_p)
-	    : client(client_p), thread(thread_p), pipeline(pipeline_p) {
-	}
-
-	//! The client-global context; caution needs to be taken when used in parallel situations
-	ClientContext &client;
-	//! The thread-local context for this execution
-	ThreadContext &thread;
-	//! Reference to the pipeline for this execution, can be used for example by operators determine caching strategy
-	optional_ptr<Pipeline> pipeline;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/executor.hpp b/src/duckdb/src/include/duckdb/execution/executor.hpp
deleted file mode 100644
index 46315a989..000000000
--- a/src/duckdb/src/include/duckdb/execution/executor.hpp
+++ /dev/null
@@ -1,196 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/pending_execution_result.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/execution/task_error_manager.hpp"
-#include "duckdb/execution/progress_data.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-#include <condition_variable>
-
-namespace duckdb {
-class ClientContext;
-class DataChunk;
-class PhysicalOperator;
-class PipelineExecutor;
-class OperatorState;
-class QueryProfiler;
-class ThreadContext;
-class Task;
-
-struct PipelineEventStack;
-struct ProducerToken;
-struct ScheduleEventData;
-
-class Executor {
-	friend class Pipeline;
-	friend class PipelineTask;
-	friend class PipelineBuildState;
-
-public:
-	static constexpr idx_t WAIT_TIME = 20;
-
-public:
-	explicit Executor(ClientContext &context);
-	~Executor();
-
-	ClientContext &context;
-
-public:
-	static Executor &Get(ClientContext &context);
-
-	void Initialize(PhysicalOperator &physical_plan);
-	void Initialize(unique_ptr<PhysicalOperator> physical_plan);
-
-	void CancelTasks();
-	PendingExecutionResult ExecuteTask(bool dry_run = false);
-	void WaitForTask();
-	void SignalTaskRescheduled(lock_guard<mutex> &);
-
-	void Reset();
-
-	vector<LogicalType> GetTypes();
-
-	//! Push a new error
-	void PushError(ErrorData exception);
-
-	ErrorData GetError();
-
-	//! True if an error has been thrown
-	bool HasError();
-	//! Throw the exception that was pushed using PushError.
-	//! Should only be called if HasError returns true
-	void ThrowException();
-
-	//! Work on tasks for this specific executor, until there are no tasks remaining
-	void WorkOnTasks();
-
-	//! Flush a thread context into the client context
-	void Flush(ThreadContext &context);
-
-	//! Reschedules a task that was blocked
-	void RescheduleTask(shared_ptr<Task> &task);
-
-	//! Add the task to be rescheduled
-	void AddToBeRescheduled(shared_ptr<Task> &task);
-
-	//! Returns the progress of the pipelines
-	idx_t GetPipelinesProgress(ProgressData &progress);
-
-	void CompletePipeline() {
-		completed_pipelines++;
-	}
-	ProducerToken &GetToken() {
-		return *producer;
-	}
-	void AddEvent(shared_ptr<Event> event);
-
-	void AddRecursiveCTE(PhysicalOperator &rec_cte);
-	void ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines, vector<shared_ptr<Event>> &events);
-
-	//! Whether or not the root of the pipeline is a result collector object
-	bool HasResultCollector();
-	//! Whether or not the root of the pipeline is a streaming result collector object
-	bool HasStreamingResultCollector();
-	//! Returns the query result - can only be used if `HasResultCollector` returns true
-	unique_ptr<QueryResult> GetResult();
-
-	//! Returns true if all pipelines have been completed
-	bool ExecutionIsFinished();
-
-	void RegisterTask() {
-		executor_tasks++;
-	}
-	void UnregisterTask() {
-		executor_tasks--;
-	}
-
-	idx_t GetTotalPipelines() const {
-		return total_pipelines;
-	}
-
-	idx_t GetCompletedPipelines() const {
-		return completed_pipelines.load();
-	}
-
-private:
-	//! Check if the streaming query result is waiting to be fetched from, must hold the 'executor_lock'
-	bool ResultCollectorIsBlocked();
-	void InitializeInternal(PhysicalOperator &physical_plan);
-
-	void ScheduleEvents(const vector<shared_ptr<MetaPipeline>> &meta_pipelines);
-	void ScheduleEventsInternal(ScheduleEventData &event_data);
-
-	static void VerifyScheduledEvents(const ScheduleEventData &event_data);
-	static void VerifyScheduledEventsInternal(const idx_t i, const vector<reference<Event>> &vertices,
-	                                          vector<bool> &visited, vector<bool> &recursion_stack);
-
-	void SchedulePipeline(const shared_ptr<MetaPipeline> &pipeline, ScheduleEventData &event_data);
-
-	bool NextExecutor();
-
-	shared_ptr<Pipeline> CreateChildPipeline(Pipeline &current, PhysicalOperator &op);
-
-	void VerifyPipeline(Pipeline &pipeline);
-	void VerifyPipelines();
-
-private:
-	optional_ptr<PhysicalOperator> physical_plan;
-	unique_ptr<PhysicalOperator> owned_plan;
-
-	mutex executor_lock;
-	//! All pipelines of the query plan
-	vector<shared_ptr<Pipeline>> pipelines;
-	//! The root pipelines of the query
-	vector<shared_ptr<Pipeline>> root_pipelines;
-	//! The recursive CTE's in this query plan
-	vector<reference<PhysicalOperator>> recursive_ctes;
-	//! The pipeline executor for the root pipeline
-	unique_ptr<PipelineExecutor> root_executor;
-	//! The current root pipeline index
-	idx_t root_pipeline_idx;
-	//! The producer of this query
-	unique_ptr<ProducerToken> producer;
-	//! List of events
-	vector<shared_ptr<Event>> events;
-	//! The query profiler
-	shared_ptr<QueryProfiler> profiler;
-	//! Task error manager
-	TaskErrorManager error_manager;
-
-	//! The amount of completed pipelines of the query
-	atomic<idx_t> completed_pipelines;
-	//! The total amount of pipelines in the query
-	idx_t total_pipelines;
-	//! Whether or not execution is cancelled
-	bool cancelled;
-
-	//! The last pending execution result (if any)
-	PendingExecutionResult execution_result;
-	//! The current task in process (if any)
-	shared_ptr<Task> task;
-
-	//! Task that have been descheduled
-	unordered_map<Task *, shared_ptr<Task>> to_be_rescheduled_tasks;
-	//! The semaphore to signal task rescheduling
-	std::condition_variable task_reschedule;
-
-	//! Currently alive executor tasks
-	atomic<idx_t> executor_tasks;
-
-	//! Total time blocked while waiting on tasks. In ticks. One tick corresponds to WAIT_TIME.
-	atomic<idx_t> blocked_thread_time;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/expression_executor.hpp b/src/duckdb/src/include/duckdb/execution/expression_executor.hpp
deleted file mode 100644
index 7aeb3c2da..000000000
--- a/src/duckdb/src/include/duckdb/execution/expression_executor.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/expression_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/execution/expression_executor_state.hpp"
-#include "duckdb/planner/bound_tokens.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-class Allocator;
-class ExecutionContext;
-
-//! ExpressionExecutor is responsible for executing a set of expressions and storing the result in a data chunk
-class ExpressionExecutor {
-	friend class BoundIndex;
-
-public:
-	DUCKDB_API explicit ExpressionExecutor(ClientContext &context);
-	DUCKDB_API ExpressionExecutor(ClientContext &context, const Expression *expression);
-	DUCKDB_API ExpressionExecutor(ClientContext &context, const Expression &expression);
-	DUCKDB_API ExpressionExecutor(ClientContext &context, const vector<unique_ptr<Expression>> &expressions);
-	ExpressionExecutor(ExpressionExecutor &&) = delete;
-
-	//! The expressions of the executor
-	vector<const Expression *> expressions;
-	//! The data chunk of the current physical operator, used to resolve
-	//! column references and determines the output cardinality
-	DataChunk *chunk = nullptr;
-
-public:
-	bool HasContext();
-	ClientContext &GetContext();
-	Allocator &GetAllocator();
-
-	//! Add an expression to the set of to-be-executed expressions of the executor
-	DUCKDB_API void AddExpression(const Expression &expr);
-
-	//! Execute the set of expressions with the given input chunk and store the result in the output chunk
-	DUCKDB_API void Execute(DataChunk *input, DataChunk &result);
-	inline void Execute(DataChunk &input, DataChunk &result) {
-		Execute(&input, result);
-	}
-	inline void Execute(DataChunk &result) {
-		Execute(nullptr, result);
-	}
-
-	//! Execute the ExpressionExecutor and put the result in the result vector; this should only be used for expression
-	//! executors with a single expression
-	DUCKDB_API void ExecuteExpression(DataChunk &input, Vector &result);
-	//! Execute the ExpressionExecutor and put the result in the result vector; this should only be used for expression
-	//! executors with a single expression
-	DUCKDB_API void ExecuteExpression(Vector &result);
-	//! Execute the ExpressionExecutor and generate a selection vector from all true values in the result; this should
-	//! only be used with a single boolean expression
-	DUCKDB_API idx_t SelectExpression(DataChunk &input, SelectionVector &sel);
-
-	//! Execute the expression with index `expr_idx` and store the result in the result vector
-	DUCKDB_API void ExecuteExpression(idx_t expr_idx, Vector &result);
-	//! Evaluate a scalar expression and fold it into a single value
-	DUCKDB_API static Value EvaluateScalar(ClientContext &context, const Expression &expr,
-	                                       bool allow_unfoldable = false);
-	//! Try to evaluate a scalar expression and fold it into a single value, returns false if an exception is thrown
-	DUCKDB_API static bool TryEvaluateScalar(ClientContext &context, const Expression &expr, Value &result);
-
-	//! Initialize the state of a given expression
-	static unique_ptr<ExpressionState> InitializeState(const Expression &expr, ExpressionExecutorState &state);
-
-	inline void SetChunk(DataChunk *chunk) {
-		this->chunk = chunk;
-	}
-	inline void SetChunk(DataChunk &chunk) {
-		SetChunk(&chunk);
-	}
-
-	DUCKDB_API vector<unique_ptr<ExpressionExecutorState>> &GetStates();
-
-protected:
-	void Initialize(const Expression &expr, ExpressionExecutorState &state);
-
-	static unique_ptr<ExpressionState> InitializeState(const BoundReferenceExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundBetweenExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundCaseExpression &expr, ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundCastExpression &expr, ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundComparisonExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundConjunctionExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundConstantExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundFunctionExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundOperatorExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundParameterExpression &expr,
-	                                                   ExpressionExecutorState &state);
-
-	void Execute(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-
-	void Execute(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundCaseExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundCastExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-
-	void Execute(const BoundComparisonExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundConjunctionExpression &expr, ExpressionState *state, const SelectionVector *sel,
-	             idx_t count, Vector &result);
-	void Execute(const BoundConstantExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundFunctionExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundOperatorExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundParameterExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundReferenceExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-
-	//! Execute the (boolean-returning) expression and generate a selection vector with all entries that are "true" in
-	//! the result
-	idx_t Select(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             SelectionVector *true_sel, SelectionVector *false_sel);
-	idx_t DefaultSelect(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	                    SelectionVector *true_sel, SelectionVector *false_sel);
-
-	idx_t Select(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             SelectionVector *true_sel, SelectionVector *false_sel);
-	idx_t Select(const BoundComparisonExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             SelectionVector *true_sel, SelectionVector *false_sel);
-	idx_t Select(const BoundConjunctionExpression &expr, ExpressionState *state, const SelectionVector *sel,
-	             idx_t count, SelectionVector *true_sel, SelectionVector *false_sel);
-
-	//! Verify that the output of a step in the ExpressionExecutor is correct
-	void Verify(const Expression &expr, Vector &result, idx_t count);
-
-	void FillSwitch(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count);
-
-private:
-	//! Client context
-	optional_ptr<ClientContext> context;
-	//! The states of the expression executor; this holds any intermediates and temporary states of expressions
-	vector<unique_ptr<ExpressionExecutorState>> states;
-
-private:
-	// it is possible to create an expression executor without a ClientContext - but it should be avoided
-	DUCKDB_API ExpressionExecutor();
-	DUCKDB_API explicit ExpressionExecutor(const vector<unique_ptr<Expression>> &exprs);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp b/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp
deleted file mode 100644
index 780166fb8..000000000
--- a/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/expression_executor_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/function.hpp"
-
-namespace duckdb {
-class Expression;
-class ExpressionExecutor;
-struct ExpressionExecutorState;
-struct FunctionLocalState;
-
-struct ExpressionState {
-	ExpressionState(const Expression &expr, ExpressionExecutorState &root);
-	virtual ~ExpressionState() {
-	}
-
-	const Expression &expr;
-	ExpressionExecutorState &root;
-	vector<unique_ptr<ExpressionState>> child_states;
-	vector<LogicalType> types;
-	DataChunk intermediate_chunk;
-	vector<bool> initialize;
-
-public:
-	void AddChild(Expression &child_expr);
-	void Finalize();
-	Allocator &GetAllocator();
-	bool HasContext();
-	DUCKDB_API ClientContext &GetContext();
-
-	void Verify(ExpressionExecutorState &root);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct ExecuteFunctionState : public ExpressionState {
-	ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root);
-	~ExecuteFunctionState() override;
-
-	unique_ptr<FunctionLocalState> local_state;
-
-public:
-	static optional_ptr<FunctionLocalState> GetFunctionState(ExpressionState &state) {
-		return state.Cast<ExecuteFunctionState>().local_state.get();
-	}
-};
-
-struct ExpressionExecutorState {
-	ExpressionExecutorState();
-
-	unique_ptr<ExpressionState> root_state;
-	ExpressionExecutor *executor = nullptr;
-
-	void Verify();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/ht_entry.hpp b/src/duckdb/src/include/duckdb/execution/ht_entry.hpp
deleted file mode 100644
index 8be70f4ed..000000000
--- a/src/duckdb/src/include/duckdb/execution/ht_entry.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/ht_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-namespace duckdb {
-
-#if !defined(DISABLE_POINTER_SALT) && defined(__ANDROID__)
-// Google, why does Android need 18446744 TB of address space?
-#define DISABLE_POINTER_SALT
-#endif
-
-//! The ht_entry_t struct represents an individual entry within a hash table.
-/*!
-    This struct is used by the JoinHashTable and AggregateHashTable to store entries within the hash table. It stores
-    a pointer to the data and a salt value in a single hash_t and can return or modify the pointer and salt
-    individually.
-*/
-struct ht_entry_t { // NOLINT
-public:
-#ifdef DISABLE_POINTER_SALT
-	//! No salt, all pointer
-	static constexpr const hash_t SALT_MASK = 0x0000000000000000;
-	static constexpr const hash_t POINTER_MASK = 0xFFFFFFFFFFFFFFFF;
-#else
-	//! Upper 16 bits are salt, lower 48 bits are the pointer
-	static constexpr const hash_t SALT_MASK = 0xFFFF000000000000;
-	static constexpr const hash_t POINTER_MASK = 0x0000FFFFFFFFFFFF;
-#endif
-
-	ht_entry_t() noexcept : value(0) {
-	}
-
-	explicit ht_entry_t(hash_t value_p) noexcept : value(value_p) {
-	}
-
-	ht_entry_t(const hash_t &salt, const data_ptr_t &pointer)
-	    : value(cast_pointer_to_uint64(pointer) | (salt & SALT_MASK)) {
-	}
-
-	inline bool IsOccupied() const {
-		return value != 0;
-	}
-
-	//! Returns a pointer based on the stored value (asserts if the cell is occupied)
-	inline data_ptr_t GetPointer() const {
-		D_ASSERT(IsOccupied());
-		return GetPointerOrNull();
-	}
-
-	//! Returns a pointer based on the stored value
-	inline data_ptr_t GetPointerOrNull() const {
-		return cast_uint64_to_pointer(value & POINTER_MASK);
-	}
-
-	inline void SetPointer(const data_ptr_t &pointer) {
-		// Pointer shouldn't use upper bits
-		D_ASSERT((cast_pointer_to_uint64(pointer) & SALT_MASK) == 0);
-		// Value should have all 1's in the pointer area
-		D_ASSERT((value & POINTER_MASK) == POINTER_MASK);
-		// Set upper bits to 1 in pointer so the salt stays intact
-		value &= cast_pointer_to_uint64(pointer) | SALT_MASK;
-	}
-
-	// Returns the salt, leaves upper salt bits intact, sets lower bits to all 1's
-	static inline hash_t ExtractSalt(const hash_t &hash) {
-		return hash | POINTER_MASK;
-	}
-
-	inline hash_t GetSalt() const {
-		return ExtractSalt(value);
-	}
-
-	inline void SetSalt(const hash_t &salt) {
-		// Shouldn't be occupied when we set this
-		D_ASSERT(!IsOccupied());
-		// Salt should have all 1's in the pointer field
-		D_ASSERT((salt & POINTER_MASK) == POINTER_MASK);
-		// No need to mask, just put the whole thing there
-		value = salt;
-	}
-
-private:
-	hash_t value;
-};
-
-// uses an AND operation to apply the modulo operation instead of an if condition that could be branch mispredicted
-inline void IncrementAndWrap(idx_t &offset, const uint64_t &capacity_mask) {
-	++offset &= capacity_mask;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/art.hpp b/src/duckdb/src/include/duckdb/execution/index/art/art.hpp
deleted file mode 100644
index 31a560ad5..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/art.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/art.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/common/array.hpp"
-
-namespace duckdb {
-
-enum class VerifyExistenceType : uint8_t { APPEND = 0, APPEND_FK = 1, DELETE_FK = 2 };
-enum class ARTConflictType : uint8_t { NO_CONFLICT = 0, CONSTRAINT = 1, TRANSACTION = 2 };
-enum class ARTAppendMode : uint8_t { DEFAULT = 0, IGNORE_DUPLICATES = 1, INSERT_DUPLICATES = 2 };
-
-class ConflictManager;
-class ARTKey;
-class ARTKeySection;
-class FixedSizeAllocator;
-
-struct ARTIndexScanState;
-
-class ART : public BoundIndex {
-public:
-	friend class Leaf;
-
-public:
-	//! Index type name for the ART.
-	static constexpr const char *TYPE_NAME = "ART";
-	//! FixedSizeAllocator count of the ART.
-	static constexpr uint8_t ALLOCATOR_COUNT = 9;
-	//! FixedSizeAllocator count of deprecated ARTs.
-	static constexpr uint8_t DEPRECATED_ALLOCATOR_COUNT = ALLOCATOR_COUNT - 3;
-
-public:
-	ART(const string &name, const IndexConstraintType index_constraint_type, const vector<column_t> &column_ids,
-	    TableIOManager &table_io_manager, const vector<unique_ptr<Expression>> &unbound_expressions,
-	    AttachedDatabase &db,
-	    const shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr = nullptr,
-	    const IndexStorageInfo &info = IndexStorageInfo());
-
-	//! Create a index instance of this type.
-	static unique_ptr<BoundIndex> Create(CreateIndexInput &input) {
-		auto art = make_uniq<ART>(input.name, input.constraint_type, input.column_ids, input.table_io_manager,
-		                          input.unbound_expressions, input.db, nullptr, input.storage_info);
-		return std::move(art);
-	}
-
-	//! Plan index construction.
-	static unique_ptr<PhysicalOperator> CreatePlan(PlanIndexInput &input);
-
-	//! Root of the tree.
-	Node tree = Node();
-	//! Fixed-size allocators holding the ART nodes.
-	shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> allocators;
-	//! True, if the ART owns its data.
-	bool owns_data;
-	//! The number of bytes fitting in the prefix.
-	uint8_t prefix_count;
-	//! The append mode.
-	ARTAppendMode append_mode;
-
-public:
-	//! Try to initialize a scan on the ART with the given expression and filter.
-	unique_ptr<IndexScanState> TryInitializeScan(const Expression &expr, const Expression &filter_expr);
-	//! Perform a lookup on the ART, fetching up to max_count row IDs.
-	//! If all row IDs were fetched, it return true, else false.
-	bool Scan(IndexScanState &state, idx_t max_count, unsafe_vector<row_t> &row_ids);
-
-	//! Appends data to the locked index.
-	ErrorData Append(IndexLock &l, DataChunk &chunk, Vector &row_ids) override;
-	//! Appends data to the locked index and verifies constraint violations against a delete index.
-	ErrorData AppendWithDeleteIndex(IndexLock &l, DataChunk &chunk, Vector &row_ids,
-	                                optional_ptr<BoundIndex> delete_index) override;
-
-	//! Internally inserts a chunk.
-	ARTConflictType Insert(Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id, const GateStatus status,
-	                       optional_ptr<ART> delete_art);
-	//! Insert a chunk.
-	ErrorData Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids) override;
-	//! Insert a chunk and verifies constraint violations against a delete index.
-	ErrorData Insert(IndexLock &l, DataChunk &data, Vector &row_ids, optional_ptr<BoundIndex> delete_index) override;
-
-	//! Verify that data can be appended to the index without a constraint violation.
-	void VerifyAppend(DataChunk &chunk, optional_ptr<BoundIndex> delete_index,
-	                  optional_ptr<ConflictManager> manager) override;
-
-	//! Delete a chunk from the ART.
-	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_ids) override;
-	//! Drop the ART.
-	void CommitDrop(IndexLock &index_lock) override;
-
-	//! Construct an ART from a vector of sorted keys and their row IDs.
-	bool Construct(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids, const idx_t row_count);
-
-	//! Merge another ART into this ART. Both must be locked.
-	bool MergeIndexes(IndexLock &state, BoundIndex &other_index) override;
-
-	//! Vacuums the ART storage.
-	void Vacuum(IndexLock &state) override;
-
-	//! Returns ART storage serialization information.
-	IndexStorageInfo GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal) override;
-	//! Returns the in-memory usage of the ART.
-	idx_t GetInMemorySize(IndexLock &index_lock) override;
-
-	//! ART key generation.
-	template <bool IS_NOT_NULL = false>
-	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys);
-	static void GenerateKeyVectors(ArenaAllocator &allocator, DataChunk &input, Vector &row_ids,
-	                               unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_id_keys);
-
-	//! Verifies the nodes and optionally returns a string of the ART.
-	string VerifyAndToString(IndexLock &state, const bool only_verify) override;
-	//! Verifies that the node allocations match the node counts.
-	void VerifyAllocations(IndexLock &state) override;
-
-private:
-	bool SearchEqual(ARTKey &key, idx_t max_count, unsafe_vector<row_t> &row_ids);
-	bool SearchGreater(ARTKey &key, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids);
-	bool SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids);
-	bool SearchCloseRange(ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal, bool right_equal, idx_t max_count,
-	                      unsafe_vector<row_t> &row_ids);
-	const unsafe_optional_ptr<const Node> Lookup(const Node &node, const ARTKey &key, idx_t depth);
-
-	void InsertIntoEmpty(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-	                     const GateStatus status);
-	ARTConflictType InsertIntoInlined(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-	                                  const GateStatus status, optional_ptr<ART> delete_art);
-	ARTConflictType InsertIntoNode(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-	                               const GateStatus status, optional_ptr<ART> delete_art);
-
-	string GenerateErrorKeyName(DataChunk &input, idx_t row);
-	string GenerateConstraintErrorMessage(VerifyExistenceType verify_type, const string &key_name);
-	void VerifyLeaf(const Node &leaf, const ARTKey &key, optional_ptr<ART> delete_art, ConflictManager &manager,
-	                optional_idx &conflict_idx, idx_t i);
-	void VerifyConstraint(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, ConflictManager &manager) override;
-	string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
-	                                     DataChunk &input) override;
-
-	void Erase(Node &node, reference<const ARTKey> key, idx_t depth, reference<const ARTKey> row_id, GateStatus status);
-
-	bool ConstructInternal(const unsafe_vector<ARTKey> &keys, const unsafe_vector<ARTKey> &row_ids, Node &node,
-	                       ARTKeySection &section);
-
-	void InitializeMerge(unsafe_vector<idx_t> &upper_bounds);
-
-	void InitializeVacuum(unordered_set<uint8_t> &indexes);
-	void FinalizeVacuum(const unordered_set<uint8_t> &indexes);
-
-	void InitAllocators(const IndexStorageInfo &info);
-	void TransformToDeprecated();
-	void Deserialize(const BlockPointer &pointer);
-	void WritePartialBlocks(const bool v1_0_0_storage);
-	void SetPrefixCount(const IndexStorageInfo &info);
-
-	string VerifyAndToStringInternal(const bool only_verify);
-	void VerifyAllocationsInternal();
-};
-
-template <>
-void ART::GenerateKeys<>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys);
-
-template <>
-void ART::GenerateKeys<true>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp b/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp
deleted file mode 100644
index e19e3cbb9..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/art_key.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/radix.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-
-namespace duckdb {
-
-class ARTKey {
-public:
-	ARTKey();
-	ARTKey(data_ptr_t data, idx_t len);
-	ARTKey(ArenaAllocator &allocator, idx_t len);
-
-	idx_t len;
-	data_ptr_t data;
-
-public:
-	template <class T>
-	static inline ARTKey CreateARTKey(ArenaAllocator &allocator, T value) {
-		auto data = ARTKey::CreateData<T>(allocator, value);
-		return ARTKey(data, sizeof(value));
-	}
-
-	template <class T>
-	static inline ARTKey CreateARTKey(ArenaAllocator &allocator, Value &value) {
-		return CreateARTKey(allocator, value.GetValueUnsafe<T>());
-	}
-
-	template <class T>
-	static inline void CreateARTKey(ArenaAllocator &allocator, ARTKey &key, T value) {
-		key.data = ARTKey::CreateData<T>(allocator, value);
-		key.len = sizeof(value);
-	}
-
-	template <class T>
-	static inline void CreateARTKey(ArenaAllocator &allocator, ARTKey &key, Value value) {
-		key.data = ARTKey::CreateData<T>(allocator, value.GetValueUnsafe<T>());
-		key.len = sizeof(value);
-	}
-
-	static ARTKey CreateKey(ArenaAllocator &allocator, PhysicalType type, Value &value);
-
-public:
-	data_t &operator[](idx_t i) {
-		return data[i];
-	}
-	const data_t &operator[](idx_t i) const {
-		return data[i];
-	}
-	bool operator>(const ARTKey &key) const;
-	bool operator>=(const ARTKey &key) const;
-	bool operator==(const ARTKey &key) const;
-
-	inline bool ByteMatches(const ARTKey &other, idx_t depth) const {
-		return data[depth] == other[depth];
-	}
-	inline bool Empty() const {
-		return len == 0;
-	}
-
-	void Concat(ArenaAllocator &allocator, const ARTKey &other);
-	row_t GetRowId() const;
-	idx_t GetMismatchPos(const ARTKey &other, const idx_t start) const;
-
-private:
-	template <class T>
-	static inline data_ptr_t CreateData(ArenaAllocator &allocator, T value) {
-		auto data = allocator.Allocate(sizeof(value));
-		Radix::EncodeData<T>(data, value);
-		return data;
-	}
-};
-
-template <>
-ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, string_t value);
-template <>
-ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const char *value);
-template <>
-void ARTKey::CreateARTKey(ArenaAllocator &allocator, ARTKey &key, string_t value);
-
-class ARTKeySection {
-public:
-	ARTKeySection(idx_t start, idx_t end, idx_t depth, data_t byte);
-	ARTKeySection(idx_t start, idx_t end, const unsafe_vector<ARTKey> &keys, const ARTKeySection &section);
-
-	idx_t start;
-	idx_t end;
-	idx_t depth;
-	data_t key_byte;
-
-public:
-	void GetChildSections(unsafe_vector<ARTKeySection> &sections, const unsafe_vector<ARTKey> &keys);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/base_leaf.hpp b/src/duckdb/src/include/duckdb/execution/index/art/base_leaf.hpp
deleted file mode 100644
index 4b5c8125b..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/base_leaf.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/base_leaf.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-template <uint8_t CAPACITY, NType TYPE>
-class BaseLeaf {
-	friend class Node7Leaf;
-	friend class Node15Leaf;
-	friend class Node256Leaf;
-
-public:
-	BaseLeaf() = delete;
-	BaseLeaf(const BaseLeaf &) = delete;
-	BaseLeaf &operator=(const BaseLeaf &) = delete;
-
-private:
-	uint8_t count;
-	uint8_t key[CAPACITY];
-
-public:
-	//! Get a new BaseLeaf and initialize it.
-	static BaseLeaf &New(ART &art, Node &node) {
-		node = Node::GetAllocator(art, TYPE).New();
-		node.SetMetadata(static_cast<uint8_t>(TYPE));
-
-		auto &n = Node::Ref<BaseLeaf>(art, node, TYPE);
-		n.count = 0;
-		return n;
-	}
-
-	//! Returns true, if the byte exists, else false.
-	bool HasByte(uint8_t &byte) const {
-		for (uint8_t i = 0; i < count; i++) {
-			if (key[i] == byte) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	//! Get the first byte greater than or equal to the byte.
-	//! Returns true, if such a byte exists, else false.
-	bool GetNextByte(uint8_t &byte) const {
-		for (uint8_t i = 0; i < count; i++) {
-			if (key[i] >= byte) {
-				byte = key[i];
-				return true;
-			}
-		}
-		return false;
-	}
-
-private:
-	static void InsertByteInternal(BaseLeaf &n, const uint8_t byte);
-	static BaseLeaf &DeleteByteInternal(ART &art, Node &node, const uint8_t byte);
-};
-
-//! Node7Leaf holds up to seven sorted bytes.
-class Node7Leaf : public BaseLeaf<7, NType::NODE_7_LEAF> {
-	friend class Node15Leaf;
-
-public:
-	static constexpr NType NODE_7_LEAF = NType::NODE_7_LEAF;
-	static constexpr uint8_t CAPACITY = 7;
-	static constexpr idx_t AND_LAST_BYTE = 0xFFFFFFFFFFFFFF00;
-
-public:
-	//! Insert a byte.
-	static void InsertByte(ART &art, Node &node, const uint8_t byte);
-	//! Delete a byte.
-	static void DeleteByte(ART &art, Node &node, Node &prefix, const uint8_t byte, const ARTKey &row_id);
-
-private:
-	static void ShrinkNode15Leaf(ART &art, Node &node7_leaf, Node &node15_leaf);
-};
-
-//! Node15Leaf holds up to 15 sorted bytes.
-class Node15Leaf : public BaseLeaf<15, NType::NODE_15_LEAF> {
-	friend class Node7Leaf;
-	friend class Node256Leaf;
-
-public:
-	static constexpr NType NODE_15_LEAF = NType::NODE_15_LEAF;
-	static constexpr uint8_t CAPACITY = 15;
-
-public:
-	//! Insert a byte.
-	static void InsertByte(ART &art, Node &node, const uint8_t byte);
-	//! Delete a byte.
-	static void DeleteByte(ART &art, Node &node, const uint8_t byte);
-
-private:
-	static void GrowNode7Leaf(ART &art, Node &node15_leaf, Node &node7_leaf);
-	static void ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_leaf);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/base_node.hpp b/src/duckdb/src/include/duckdb/execution/index/art/base_node.hpp
deleted file mode 100644
index 2baa0eb89..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/base_node.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/base_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-template <uint8_t CAPACITY, NType TYPE>
-class BaseNode {
-	friend class Node4;
-	friend class Node16;
-	friend class Node48;
-
-public:
-	BaseNode() = delete;
-	BaseNode(const BaseNode &) = delete;
-	BaseNode &operator=(const BaseNode &) = delete;
-
-private:
-	uint8_t count;
-	uint8_t key[CAPACITY];
-	Node children[CAPACITY];
-
-public:
-	//! Get a new BaseNode and initialize it.
-	static BaseNode &New(ART &art, Node &node) {
-		node = Node::GetAllocator(art, TYPE).New();
-		node.SetMetadata(static_cast<uint8_t>(TYPE));
-
-		auto &n = Node::Ref<BaseNode>(art, node, TYPE);
-		n.count = 0;
-		return n;
-	}
-
-	//! Free the node and its children.
-	static void Free(ART &art, Node &node) {
-		auto &n = Node::Ref<BaseNode>(art, node, TYPE);
-		for (uint8_t i = 0; i < n.count; i++) {
-			Node::Free(art, n.children[i]);
-		}
-	}
-
-	//! Replace the child at byte.
-	static void ReplaceChild(BaseNode &n, const uint8_t byte, const Node child) {
-		D_ASSERT(n.count != 0);
-		for (uint8_t i = 0; i < n.count; i++) {
-			if (n.key[i] == byte) {
-				auto status = n.children[i].GetGateStatus();
-				n.children[i] = child;
-
-				if (status == GateStatus::GATE_SET && child.HasMetadata()) {
-					n.children[i].SetGateStatus(status);
-				}
-				return;
-			}
-		}
-	}
-
-	//! Get the child at byte.
-	static unsafe_optional_ptr<Node> GetChild(BaseNode &n, const uint8_t byte) {
-		for (uint8_t i = 0; i < n.count; i++) {
-			if (n.key[i] == byte) {
-				D_ASSERT(n.children[i].HasMetadata());
-				return &n.children[i];
-			}
-		}
-		return nullptr;
-	}
-
-	//! Get the first child greater than or equal to the byte.
-	static unsafe_optional_ptr<Node> GetNextChild(BaseNode &n, uint8_t &byte) {
-		for (uint8_t i = 0; i < n.count; i++) {
-			if (n.key[i] >= byte) {
-				byte = n.key[i];
-				return &n.children[i];
-			}
-		}
-		return nullptr;
-	}
-
-public:
-	template <class F>
-	static void Iterator(BaseNode<CAPACITY, TYPE> &n, F &&lambda) {
-		for (uint8_t i = 0; i < n.count; i++) {
-			lambda(n.children[i]);
-		}
-	}
-
-private:
-	static void InsertChildInternal(BaseNode &n, const uint8_t byte, const Node child);
-	static BaseNode &DeleteChildInternal(ART &art, Node &node, const uint8_t byte);
-};
-
-//! Node4 holds up to four children sorted by their key byte.
-class Node4 : public BaseNode<4, NType::NODE_4> {
-	friend class Node16;
-
-public:
-	static constexpr NType NODE_4 = NType::NODE_4;
-	static constexpr uint8_t CAPACITY = 4;
-
-public:
-	//! Insert a child at byte.
-	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child at byte.
-	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, const GateStatus status);
-
-private:
-	static void ShrinkNode16(ART &art, Node &node4, Node &node16);
-};
-
-class Node16 : public BaseNode<16, NType::NODE_16> {
-	friend class Node4;
-	friend class Node48;
-
-public:
-	static constexpr NType NODE_16 = NType::NODE_16;
-	static constexpr uint8_t CAPACITY = 16;
-
-public:
-	//! Insert a child at byte.
-	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child at byte.
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
-
-private:
-	static void GrowNode4(ART &art, Node &node16, Node &node4);
-	static void ShrinkNode48(ART &art, Node &node16, Node &node48);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/iterator.hpp b/src/duckdb/src/include/duckdb/execution/index/art/iterator.hpp
deleted file mode 100644
index 58a0f106d..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/iterator.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/common/stack.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-//! Keeps track of the byte leading to the currently active child of the node.
-struct IteratorEntry {
-	IteratorEntry(Node node, uint8_t byte) : node(node), byte(byte) {
-	}
-
-	Node node;
-	uint8_t byte = 0;
-};
-
-//! Keeps track of the current key in the iterator leading down to the top node in the stack.
-class IteratorKey {
-public:
-	//! Pushes a byte into the current key.
-	inline void Push(const uint8_t key_byte) {
-		key_bytes.push_back(key_byte);
-	}
-	//! Pops n bytes from the current key.
-	inline void Pop(const idx_t n) {
-		key_bytes.resize(key_bytes.size() - n);
-	}
-	//! Returns the byte at idx.
-	inline uint8_t &operator[](idx_t idx) {
-		D_ASSERT(idx < key_bytes.size());
-		return key_bytes[idx];
-	}
-	// Returns the number of key bytes.
-	inline idx_t Size() const {
-		return key_bytes.size();
-	}
-
-	//! Returns true, if key_bytes contains all bytes of key.
-	bool Contains(const ARTKey &key) const;
-	//! Returns true, if key_bytes is greater than [or equal to] the key.
-	bool GreaterThan(const ARTKey &key, const bool equal, const uint8_t nested_depth) const;
-
-private:
-	unsafe_vector<uint8_t> key_bytes;
-};
-
-class Iterator {
-public:
-	static constexpr uint8_t ROW_ID_SIZE = sizeof(row_t);
-
-public:
-	explicit Iterator(ART &art) : art(art), status(GateStatus::GATE_NOT_SET) {};
-	//! Holds the current key leading down to the top node on the stack.
-	IteratorKey current_key;
-
-public:
-	//! Scans the tree, starting at the current top node on the stack, and ending at upper_bound.
-	//! If upper_bound is the empty ARTKey, than there is no upper bound.
-	bool Scan(const ARTKey &upper_bound, const idx_t max_count, unsafe_vector<row_t> &row_ids, const bool equal);
-	//! Finds the minimum (leaf) of the current subtree.
-	void FindMinimum(const Node &node);
-	//! Finds the lower bound of the ART and adds the nodes to the stack. Returns false, if the lower
-	//! bound exceeds the maximum value of the ART.
-	bool LowerBound(const Node &node, const ARTKey &key, const bool equal, idx_t depth);
-
-	//! Returns the nested depth.
-	uint8_t GetNestedDepth() const {
-		return nested_depth;
-	}
-
-private:
-	//! The ART.
-	ART &art;
-	//! Stack of nodes from the root to the currently active node.
-	stack<IteratorEntry> nodes;
-	//! Last visited leaf node.
-	Node last_leaf = Node();
-	//! Holds the row ID of nested leaves.
-	uint8_t row_id[ROW_ID_SIZE];
-	//! True, if we passed a gate.
-	GateStatus status;
-	//! Depth in a nested leaf.
-	uint8_t nested_depth = 0;
-
-private:
-	//! Goes to the next leaf in the ART and sets it as last_leaf,
-	//! returns false if there is no next leaf.
-	bool Next();
-	//! Pop the top node from the stack of iterator entries and adjust the current key.
-	void PopNode();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp b/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp
deleted file mode 100644
index 6228e75e5..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/leaf.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-//! There are three types of leaves.
-//! 1. LEAF_INLINED: Inlines a row ID in a Node pointer.
-//! 2. LEAF: Deprecated. A list of Leaf nodes containing row IDs.
-//! 3. Nested leaves indicated by gate nodes. If an ART key contains multiple row IDs, then we use the row IDs as keys
-//! and create a nested ART behind the gate node. As row IDs are always unique, these nested ARTs never contain
-//! duplicates themselves.
-class Leaf {
-public:
-	static constexpr NType LEAF = NType::LEAF;
-	static constexpr NType INLINED = NType::LEAF_INLINED;
-	static constexpr uint8_t LEAF_SIZE = 4; // Deprecated.
-
-public:
-	Leaf() = delete;
-	Leaf(const Leaf &) = delete;
-	Leaf &operator=(const Leaf &) = delete;
-
-private:
-	uint8_t count;            // Deprecated.
-	row_t row_ids[LEAF_SIZE]; // Deprecated.
-	Node ptr;                 // Deprecated.
-
-public:
-	//! Inline a row ID into a node pointer.
-	static void New(Node &node, const row_t row_id);
-	//! Get a new non-inlined nested leaf node.
-	static void New(ART &art, reference<Node> &node, const unsafe_vector<ARTKey> &row_ids, const idx_t start,
-	                const idx_t count);
-
-	//! Merge two leaves. r_node must be INLINED.
-	static void MergeInlined(ART &art, Node &l_node, Node &r_node);
-
-	//! Insert a row ID into an inlined leaf.
-	static void InsertIntoInlined(ART &art, Node &node, const ARTKey &row_id, idx_t depth, const GateStatus status);
-
-	//! Transforms a deprecated leaf to a nested leaf.
-	static void TransformToNested(ART &art, Node &node);
-	//! Transforms a nested leaf to a deprecated leaf.
-	static void TransformToDeprecated(ART &art, Node &node);
-
-public:
-	//! Frees the linked list of leaves.
-	static void DeprecatedFree(ART &art, Node &node);
-	//! Fills the row_ids vector with the row IDs of this linked list of leaves.
-	//! Never pushes more than max_count row IDs.
-	static bool DeprecatedGetRowIds(ART &art, const Node &node, unsafe_vector<row_t> &row_ids, const idx_t max_count);
-	//! Vacuums the linked list of leaves.
-	static void DeprecatedVacuum(ART &art, Node &node);
-	//! Returns the string representation of the linked list of leaves, if only_verify is true.
-	//! Else, it traverses and verifies the linked list of leaves.
-	static string DeprecatedVerifyAndToString(ART &art, const Node &node, const bool only_verify);
-	//! Count the number of leaves.
-	void DeprecatedVerifyAllocations(ART &art, unordered_map<uint8_t, idx_t> &node_counts) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/node.hpp b/src/duckdb/src/include/duckdb/execution/index/art/node.hpp
deleted file mode 100644
index 316ecc5f2..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/node.hpp
+++ /dev/null
@@ -1,193 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/index_pointer.hpp"
-
-namespace duckdb {
-
-enum class NType : uint8_t {
-	PREFIX = 1,
-	LEAF = 2,
-	NODE_4 = 3,
-	NODE_16 = 4,
-	NODE_48 = 5,
-	NODE_256 = 6,
-	LEAF_INLINED = 7,
-	NODE_7_LEAF = 8,
-	NODE_15_LEAF = 9,
-	NODE_256_LEAF = 10,
-};
-
-enum class GateStatus : uint8_t {
-	GATE_NOT_SET = 0,
-	GATE_SET = 1,
-};
-
-class ART;
-class Prefix;
-class ARTKey;
-
-//! The Node is the pointer class of the ART index.
-//! It inherits from the IndexPointer, and adds ART-specific functionality.
-class Node : public IndexPointer {
-	friend class Prefix;
-
-public:
-	//! A gate sets the leftmost bit of the metadata, binary: 1000-0000.
-	static constexpr uint8_t AND_GATE = 0x80;
-	static constexpr idx_t AND_ROW_ID = 0x00FFFFFFFFFFFFFF;
-
-public:
-	//! Get a new pointer to a node and initialize it.
-	static void New(ART &art, Node &node, const NType type);
-	//! Free the node and its children.
-	static void Free(ART &art, Node &node);
-
-	//! Get a reference to the allocator.
-	static FixedSizeAllocator &GetAllocator(const ART &art, const NType type);
-	//! Get the index of a node type's allocator.
-	static uint8_t GetAllocatorIdx(const NType type);
-
-	//! Get a reference to a node.
-	template <class NODE>
-	static inline NODE &Ref(const ART &art, const Node ptr, const NType type) {
-		D_ASSERT(ptr.GetType() != NType::PREFIX);
-		return *(GetAllocator(art, type).Get<NODE>(ptr, !std::is_const<NODE>::value));
-	}
-	//! Get a node pointer, if the node is in memory, else nullptr.
-	template <class NODE>
-	static inline unsafe_optional_ptr<NODE> InMemoryRef(const ART &art, const Node ptr, const NType type) {
-		D_ASSERT(ptr.GetType() != NType::PREFIX);
-		return GetAllocator(art, type).GetIfLoaded<NODE>(ptr);
-	}
-
-	//! Replace the child at byte.
-	void ReplaceChild(const ART &art, const uint8_t byte, const Node child = Node()) const;
-	//! Insert the child at byte.
-	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child = Node());
-	//! Delete the child at byte.
-	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, const GateStatus status,
-	                        const ARTKey &row_id);
-
-	//! Get the immutable child at byte.
-	const unsafe_optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
-	//! Get the child at byte.
-	unsafe_optional_ptr<Node> GetChildMutable(ART &art, const uint8_t byte) const;
-	//! Get the first immutable child greater than or equal to the byte.
-	const unsafe_optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte) const;
-	//! Get the first child greater than or equal to the byte.
-	unsafe_optional_ptr<Node> GetNextChildMutable(ART &art, uint8_t &byte) const;
-	//! Returns true, if the byte exists, else false.
-	bool HasByte(ART &art, uint8_t &byte) const;
-	//! Get the first byte greater than or equal to the byte.
-	bool GetNextByte(ART &art, uint8_t &byte) const;
-
-	//! Returns the string representation of the node, if only_verify is false.
-	//! Else, it traverses and verifies the node.
-	string VerifyAndToString(ART &art, const bool only_verify) const;
-	//! Counts each node type.
-	void VerifyAllocations(ART &art, unordered_map<uint8_t, idx_t> &node_counts) const;
-
-	//! Returns the node type for a count.
-	static NType GetNodeType(const idx_t count);
-
-	//! Initialize a merge by incrementing the buffer IDs of a node and its children.
-	void InitMerge(ART &art, const unsafe_vector<idx_t> &upper_bounds);
-	//! Merge a node into this node.
-	bool Merge(ART &art, Node &other, const GateStatus status);
-
-	//! Vacuum all nodes exceeding their vacuum threshold.
-	void Vacuum(ART &art, const unordered_set<uint8_t> &indexes);
-
-	//! Transform the node storage to deprecated storage.
-	static void TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<FixedSizeAllocator> &allocator);
-
-	//! Returns the node type.
-	inline NType GetType() const {
-		return NType(GetMetadata() & ~AND_GATE);
-	}
-
-	//! True, if the node is a Node4, Node16, Node48, or Node256.
-	bool IsNode() const;
-	//! True, if the node is a Node7Leaf, Node15Leaf, or Node256Leaf.
-	bool IsLeafNode() const;
-	//! True, if the node is any leaf.
-	bool IsAnyLeaf() const;
-
-	//! Get the row ID (8th to 63rd bit).
-	inline row_t GetRowId() const {
-		return UnsafeNumericCast<row_t>(Get() & AND_ROW_ID);
-	}
-	//! Set the row ID (8th to 63rd bit).
-	inline void SetRowId(const row_t row_id) {
-		Set((Get() & AND_METADATA) | UnsafeNumericCast<idx_t>(row_id));
-	}
-
-	//! Returns the gate status of a node.
-	inline GateStatus GetGateStatus() const {
-		return (GetMetadata() & AND_GATE) == 0 ? GateStatus::GATE_NOT_SET : GateStatus::GATE_SET;
-	}
-	//! Sets the gate status of a node.
-	inline void SetGateStatus(const GateStatus status) {
-		switch (status) {
-		case GateStatus::GATE_SET:
-			D_ASSERT(GetType() != NType::LEAF_INLINED);
-			SetMetadata(GetMetadata() | AND_GATE);
-			break;
-		case GateStatus::GATE_NOT_SET:
-			SetMetadata(GetMetadata() & ~AND_GATE);
-			break;
-		}
-	}
-
-	//! Assign operator.
-	inline void operator=(const IndexPointer &ptr) {
-		Set(ptr.Get());
-	}
-
-private:
-	bool MergeNormalNodes(ART &art, Node &l_node, Node &r_node, uint8_t &byte, const GateStatus status);
-	void MergeLeafNodes(ART &art, Node &l_node, Node &r_node, uint8_t &byte);
-	bool MergeNodes(ART &art, Node &other, const GateStatus status);
-	bool PrefixContainsOther(ART &art, Node &l_node, Node &r_node, const uint8_t pos, const GateStatus status);
-	void MergeIntoNode4(ART &art, Node &l_node, Node &r_node, const uint8_t pos);
-	bool MergePrefixes(ART &art, Node &other, const GateStatus status);
-	bool MergeInternal(ART &art, Node &other, const GateStatus status);
-
-private:
-	template <class NODE>
-	static void InitMergeInternal(ART &art, NODE &n, const unsafe_vector<idx_t> &upper_bounds) {
-		NODE::Iterator(n, [&](Node &child) { child.InitMerge(art, upper_bounds); });
-	}
-
-	template <class NODE>
-	static void VacuumInternal(ART &art, NODE &n, const unordered_set<uint8_t> &indexes) {
-		NODE::Iterator(n, [&](Node &child) { child.Vacuum(art, indexes); });
-	}
-
-	template <class NODE>
-	static void TransformToDeprecatedInternal(ART &art, unsafe_optional_ptr<NODE> ptr,
-	                                          unsafe_unique_ptr<FixedSizeAllocator> &allocator) {
-		if (ptr) {
-			NODE::Iterator(*ptr, [&](Node &child) { Node::TransformToDeprecated(art, child, allocator); });
-		}
-	}
-
-	template <class NODE>
-	static void VerifyAllocationsInternal(ART &art, NODE &n, unordered_map<uint8_t, idx_t> &node_counts) {
-		NODE::Iterator(n, [&](const Node &child) { child.VerifyAllocations(art, node_counts); });
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/node256.hpp b/src/duckdb/src/include/duckdb/execution/index/art/node256.hpp
deleted file mode 100644
index 2b9f293ce..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/node256.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node256.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-//! Node256 holds up to 256 children. They are indexed by their key byte.
-class Node256 {
-	friend class Node48;
-
-public:
-	static constexpr NType NODE_256 = NType::NODE_256;
-	static constexpr uint16_t CAPACITY = 256;
-	static constexpr uint8_t SHRINK_THRESHOLD = 36;
-
-public:
-	Node256() = delete;
-	Node256(const Node256 &) = delete;
-	Node256 &operator=(const Node256 &) = delete;
-
-private:
-	uint16_t count;
-	Node children[CAPACITY];
-
-public:
-	//! Get a new Node256 and initialize it.
-	static Node256 &New(ART &art, Node &node);
-	//! Free the node and its children.
-	static void Free(ART &art, Node &node);
-
-	//! Insert a child at byte.
-	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child at byte.
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
-	//! Replace the child at byte.
-	void ReplaceChild(const uint8_t byte, const Node child);
-
-public:
-	template <class F, class NODE>
-	static void Iterator(NODE &n, F &&lambda) {
-		for (idx_t i = 0; i < CAPACITY; i++) {
-			if (n.children[i].HasMetadata()) {
-				lambda(n.children[i]);
-			}
-		}
-	}
-
-	template <class NODE>
-	static unsafe_optional_ptr<Node> GetChild(NODE &n, const uint8_t byte) {
-		if (n.children[byte].HasMetadata()) {
-			return &n.children[byte];
-		}
-		return nullptr;
-	}
-
-	template <class NODE>
-	static unsafe_optional_ptr<Node> GetNextChild(NODE &n, uint8_t &byte) {
-		for (idx_t i = byte; i < CAPACITY; i++) {
-			if (n.children[i].HasMetadata()) {
-				byte = UnsafeNumericCast<uint8_t>(i);
-				return &n.children[i];
-			}
-		}
-		return nullptr;
-	}
-
-private:
-	static Node256 &GrowNode48(ART &art, Node &node256, Node &node48);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/node256_leaf.hpp b/src/duckdb/src/include/duckdb/execution/index/art/node256_leaf.hpp
deleted file mode 100644
index e3a708d35..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/node256_leaf.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node256_leaf.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-
-namespace duckdb {
-
-//! Node256Leaf is a bitmask containing 256 bits.
-class Node256Leaf {
-	friend class Node15Leaf;
-
-public:
-	static constexpr NType NODE_256_LEAF = NType::NODE_256_LEAF;
-	static constexpr uint16_t CAPACITY = Node256::CAPACITY;
-
-public:
-	Node256Leaf() = delete;
-	Node256Leaf(const Node256Leaf &) = delete;
-	Node256Leaf &operator=(const Node256Leaf &) = delete;
-
-private:
-	uint16_t count;
-	validity_t mask[CAPACITY / sizeof(validity_t)];
-
-public:
-	//! Get a new Node256Leaf and initialize it.
-	static Node256Leaf &New(ART &art, Node &node);
-
-	//! Insert a byte.
-	static void InsertByte(ART &art, Node &node, const uint8_t byte);
-	//! Delete a byte.
-	static void DeleteByte(ART &art, Node &node, const uint8_t byte);
-
-	//! Returns true, if the byte exists, else false.
-	bool HasByte(uint8_t &byte);
-	//! Get the first byte greater or equal to the byte.
-	bool GetNextByte(uint8_t &byte);
-
-private:
-	static Node256Leaf &GrowNode15Leaf(ART &art, Node &node256_leaf, Node &node15_leaf);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp b/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp
deleted file mode 100644
index b0c25fad7..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node48.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-
-namespace duckdb {
-
-//! Node48 holds up to 48 children. The child_index array is indexed by the key byte.
-//! It contains the position of the child node in the children array.
-class Node48 {
-	friend class Node16;
-	friend class Node256;
-
-public:
-	static constexpr NType NODE_48 = NType::NODE_48;
-	static constexpr uint8_t CAPACITY = 48;
-	static constexpr uint8_t EMPTY_MARKER = 48;
-	static constexpr uint8_t SHRINK_THRESHOLD = 12;
-
-public:
-	Node48() = delete;
-	Node48(const Node48 &) = delete;
-	Node48 &operator=(const Node48 &) = delete;
-
-private:
-	uint8_t count;
-	uint8_t child_index[Node256::CAPACITY];
-	Node children[CAPACITY];
-
-public:
-	//! Get a new Node48 and initialize it.
-	static Node48 &New(ART &art, Node &node);
-	//! Free the node and its children.
-	static void Free(ART &art, Node &node);
-
-	//! Insert a child at byte.
-	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child at byte.
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
-	//! Replace the child at byte.
-	void ReplaceChild(const uint8_t byte, const Node child);
-
-public:
-	template <class F, class NODE>
-	static void Iterator(NODE &n, F &&lambda) {
-		for (idx_t i = 0; i < Node256::CAPACITY; i++) {
-			if (n.child_index[i] != EMPTY_MARKER) {
-				lambda(n.children[n.child_index[i]]);
-			}
-		}
-	}
-
-	template <class NODE>
-	static unsafe_optional_ptr<Node> GetChild(NODE &n, const uint8_t byte) {
-		if (n.child_index[byte] != Node48::EMPTY_MARKER) {
-			return &n.children[n.child_index[byte]];
-		}
-		return nullptr;
-	}
-
-	template <class NODE>
-	static unsafe_optional_ptr<Node> GetNextChild(NODE &n, uint8_t &byte) {
-		for (idx_t i = byte; i < Node256::CAPACITY; i++) {
-			if (n.child_index[i] != EMPTY_MARKER) {
-				byte = UnsafeNumericCast<uint8_t>(i);
-				return &n.children[n.child_index[i]];
-			}
-		}
-		return nullptr;
-	}
-
-private:
-	static Node48 &GrowNode16(ART &art, Node &node48, Node &node16);
-	static Node48 &ShrinkNode256(ART &art, Node &node48, Node &node256);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp b/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp
deleted file mode 100644
index 5d656c742..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/prefix.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/execution/index/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-class ARTKey;
-
-//! Prefix is a wrapper class to access a prefix.
-//! The prefix contains up to the ART's prefix size bytes and an additional byte for the count.
-//! It also contains a Node pointer to a child node.
-class Prefix {
-public:
-	static constexpr NType PREFIX = NType::PREFIX;
-
-	static constexpr uint8_t ROW_ID_SIZE = sizeof(row_t);
-	static constexpr uint8_t ROW_ID_COUNT = ROW_ID_SIZE - 1;
-	static constexpr uint8_t DEPRECATED_COUNT = 15;
-	static constexpr uint8_t METADATA_SIZE = sizeof(Node) + 1;
-
-public:
-	Prefix() = delete;
-	Prefix(const ART &art, const Node ptr_p, const bool is_mutable = false, const bool set_in_memory = false);
-	Prefix(unsafe_unique_ptr<FixedSizeAllocator> &allocator, const Node ptr_p, const idx_t count);
-
-	data_ptr_t data;
-	Node *ptr;
-	bool in_memory;
-
-public:
-	static inline uint8_t Count(const ART &art) {
-		return art.prefix_count;
-	}
-	static idx_t GetMismatchWithOther(const Prefix &l_prefix, const Prefix &r_prefix, const idx_t max_count);
-	static idx_t GetMismatchWithKey(ART &art, const Node &node, const ARTKey &key, idx_t &depth);
-	static uint8_t GetByte(const ART &art, const Node &node, const uint8_t pos);
-
-public:
-	//! Get a new list of prefix nodes. The node reference holds the last prefix of the list.
-	static void New(ART &art, reference<Node> &ref, const ARTKey &key, const idx_t depth, idx_t count);
-
-	//! Free the prefix and its child.
-	static void Free(ART &art, Node &node);
-
-	//! Initializes a merge by incrementing the buffer ID of the prefix and its child.
-	static void InitializeMerge(ART &art, Node &node, const unsafe_vector<idx_t> &upper_bounds);
-
-	//! Concatenates parent -> byte -> child. Special-handling, if
-	//! 1. the byte was in a gate node.
-	//! 2. the byte was in PREFIX_INLINED.
-	static void Concat(ART &art, Node &parent, uint8_t byte, const GateStatus old_status, const Node &child,
-	                   const GateStatus status);
-
-	//! Traverse a prefix and a key until
-	//! 1. a non-prefix node.
-	//! 2. a mismatching byte.
-	//! Early-out, if the next prefix is a gate node.
-	static idx_t Traverse(ART &art, reference<const Node> &node, const ARTKey &key, idx_t &depth);
-	static idx_t TraverseMutable(ART &art, reference<Node> &node, const ARTKey &key, idx_t &depth);
-
-	//! Traverse two prefixes to find
-	//! 1. that they match.
-	//! 2. that they mismatch.
-	//! 3. that one prefix contains the other prefix.
-	static bool Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &pos,
-	                     const GateStatus status);
-
-	//! Removes up to pos bytes from the prefix.
-	//! Shifts all subsequent bytes by pos. Frees empty nodes.
-	static void Reduce(ART &art, Node &node, const idx_t pos);
-	//! Splits the prefix at pos.
-	//! prefix_node points to the node that replaces the split byte.
-	//! child_node points to the remaining node after the split.
-	//! Returns INSIDE, if a gate node was freed, else OUTSIDE.
-	static GateStatus Split(ART &art, reference<Node> &node, Node &child, const uint8_t pos);
-
-	//! Insert a key into a prefix.
-	static ARTConflictType Insert(ART &art, Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id,
-	                              const GateStatus status, optional_ptr<ART> delete_art);
-
-	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
-	static string VerifyAndToString(ART &art, const Node &node, const bool only_verify);
-	//! Count the number of prefixes.
-	static void VerifyAllocations(ART &art, const Node &node, unordered_map<uint8_t, idx_t> &node_counts);
-
-	//! Vacuum the child of the node.
-	static void Vacuum(ART &art, Node &node, const unordered_set<uint8_t> &indexes);
-
-	//! Transform the child of the node.
-	static void TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<FixedSizeAllocator> &allocator);
-
-private:
-	static Prefix NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset,
-	                          const NType type);
-
-	static Prefix GetTail(ART &art, const Node &node);
-
-	static void ConcatGate(ART &art, Node &parent, uint8_t byte, const Node &child);
-	static void ConcatChildIsGate(ART &art, Node &parent, uint8_t byte, const Node &child);
-
-	Prefix Append(ART &art, const uint8_t byte);
-	void Append(ART &art, Node other);
-	Prefix TransformToDeprecatedAppend(ART &art, unsafe_unique_ptr<FixedSizeAllocator> &allocator, uint8_t byte);
-
-private:
-	template <class F, class NODE>
-	static void Iterator(ART &art, reference<NODE> &ref, const bool exit_gate, const bool is_mutable, F &&lambda) {
-		while (ref.get().HasMetadata() && ref.get().GetType() == PREFIX) {
-			Prefix prefix(art, ref, is_mutable);
-			lambda(prefix);
-
-			ref = *prefix.ptr;
-			if (exit_gate && ref.get().GetGateStatus() == GateStatus::GATE_SET) {
-				break;
-			}
-		}
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/bound_index.hpp b/src/duckdb/src/include/duckdb/execution/index/bound_index.hpp
deleted file mode 100644
index 522c7c78e..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/bound_index.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/bound_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/index_constraint_type.hpp"
-#include "duckdb/common/types/constraint_conflict_info.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/storage/index.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class TableIOManager;
-class Transaction;
-class ConflictManager;
-
-struct IndexLock;
-struct IndexScanState;
-
-//! The index is an abstract base class that serves as the basis for indexes
-class BoundIndex : public Index {
-public:
-	BoundIndex(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
-	           const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-	           const vector<unique_ptr<Expression>> &unbound_expressions, AttachedDatabase &db);
-
-	//! The physical types stored in the index
-	vector<PhysicalType> types;
-	//! The logical types of the expressions
-	vector<LogicalType> logical_types;
-
-	//! The name of the index
-	string name;
-	//! The index type (ART, B+-tree, Skip-List, ...)
-	string index_type;
-	//! The index constraint type
-	IndexConstraintType index_constraint_type;
-
-public:
-	bool IsBound() const override {
-		return true;
-	}
-
-	const string &GetIndexType() const override {
-		return index_type;
-	}
-
-	const string &GetIndexName() const override {
-		return name;
-	}
-
-	IndexConstraintType GetConstraintType() const override {
-		return index_constraint_type;
-	}
-
-public:
-	//! Obtains a lock on the index.
-	void InitializeLock(IndexLock &state);
-	//! Appends data to the locked index.
-	virtual ErrorData Append(IndexLock &l, DataChunk &chunk, Vector &row_ids) = 0;
-	//! Obtains a lock and calls Append while holding that lock.
-	ErrorData Append(DataChunk &chunk, Vector &row_ids);
-	//! Appends data to the locked index and verifies constraint violations against a delete index.
-	virtual ErrorData AppendWithDeleteIndex(IndexLock &l, DataChunk &chunk, Vector &row_ids,
-	                                        optional_ptr<BoundIndex> delete_index);
-	//! Obtains a lock and calls Append with an delete_index while holding that lock.
-	ErrorData AppendWithDeleteIndex(DataChunk &chunk, Vector &row_ids, optional_ptr<BoundIndex> delete_index);
-
-	//! Verify that data can be appended to the index without a constraint violation.
-	virtual void VerifyAppend(DataChunk &chunk, optional_ptr<BoundIndex> delete_index,
-	                          optional_ptr<ConflictManager> manager);
-	//! Verifies the constraint for a chunk of data.
-	virtual void VerifyConstraint(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, ConflictManager &manager);
-
-	//! Deletes all data from the index. The lock obtained from InitializeLock must be held
-	virtual void CommitDrop(IndexLock &index_lock) = 0;
-	//! Deletes all data from the index
-	void CommitDrop() override;
-	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
-	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
-	//! Obtains a lock and calls Delete while holding that lock
-	void Delete(DataChunk &entries, Vector &row_identifiers);
-
-	//! Insert a chunk.
-	virtual ErrorData Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids) = 0;
-	//! Insert a chunk and verifies constraint violations against a delete index.
-	virtual ErrorData Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids, optional_ptr<BoundIndex> delete_index);
-
-	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
-	//! index must also be locked during the merge
-	virtual bool MergeIndexes(IndexLock &state, BoundIndex &other_index) = 0;
-	//! Obtains a lock and calls MergeIndexes while holding that lock
-	bool MergeIndexes(BoundIndex &other_index);
-
-	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
-	virtual void Vacuum(IndexLock &state) = 0;
-	//! Obtains a lock and calls Vacuum while holding that lock
-	void Vacuum();
-
-	//! Returns the in-memory usage of the index. The lock obtained from InitializeLock must be held
-	virtual idx_t GetInMemorySize(IndexLock &state) = 0;
-	//! Returns the in-memory usage of the index
-	idx_t GetInMemorySize();
-
-	//! Returns the string representation of an index, or only traverses and verifies the index.
-	virtual string VerifyAndToString(IndexLock &state, const bool only_verify) = 0;
-	//! Obtains a lock and calls VerifyAndToString.
-	string VerifyAndToString(const bool only_verify);
-
-	//! Ensures that the node allocation counts match the node counts.
-	virtual void VerifyAllocations(IndexLock &state) = 0;
-	//! Obtains a lock and calls VerifyAllocations.
-	void VerifyAllocations();
-
-	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
-	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
-
-	//! Returns index storage serialization information.
-	virtual IndexStorageInfo GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal);
-
-	//! Execute the index expressions on an input chunk
-	void ExecuteExpressions(DataChunk &input, DataChunk &result);
-	static string AppendRowError(DataChunk &input, idx_t index);
-
-	//! Throw a constraint violation exception
-	virtual string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
-	                                             DataChunk &input) = 0;
-
-	vector<unique_ptr<Expression>> unbound_expressions;
-
-protected:
-	//! Lock used for any changes to the index
-	mutex lock;
-
-	//! Bound expressions used during expression execution
-	vector<unique_ptr<Expression>> bound_expressions;
-
-private:
-	//! Expression executor to execute the index expressions
-	ExpressionExecutor executor;
-
-	//! Bind the unbound expressions of the index
-	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/fixed_size_allocator.hpp b/src/duckdb/src/include/duckdb/execution/index/fixed_size_allocator.hpp
deleted file mode 100644
index 520e24376..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/fixed_size_allocator.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/fixed_size_allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/execution/index/fixed_size_buffer.hpp"
-#include "duckdb/execution/index/index_pointer.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/partial_block_manager.hpp"
-
-namespace duckdb {
-
-//! The FixedSizeAllocator provides pointers to fixed-size memory segments of pre-allocated memory buffers.
-//! The pointers are IndexPointers, and the leftmost byte (metadata) must always be zero.
-//! It is also possible to directly request a C++ pointer to the underlying segment of an index pointer.
-class FixedSizeAllocator {
-public:
-	//! We can vacuum 10% or more of the total in-memory footprint
-	static constexpr uint8_t VACUUM_THRESHOLD = 10;
-
-public:
-	//! Construct a new fixed-size allocator
-	FixedSizeAllocator(const idx_t segment_size, BlockManager &block_manager);
-
-	//! Block manager of the database instance
-	BlockManager &block_manager;
-	//! Buffer manager of the database instance
-	BufferManager &buffer_manager;
-
-public:
-	//! Get a new IndexPointer to a segment, might cause a new buffer allocation
-	IndexPointer New();
-	//! Free the segment of the IndexPointer
-	void Free(const IndexPointer ptr);
-
-	//! Returns a pointer of type T to a segment. If dirty is false, then T must be a const class.
-	template <class T>
-	inline unsafe_optional_ptr<T> Get(const IndexPointer ptr, const bool dirty = true) {
-		return (T *)Get(ptr, dirty);
-	}
-
-	//! Returns the data_ptr_t to a segment, and sets the dirty flag of the buffer containing that segment.
-	inline data_ptr_t Get(const IndexPointer ptr, const bool dirty = true) {
-		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
-		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
-
-		auto &buffer = buffers.find(ptr.GetBufferId())->second;
-		auto buffer_ptr = buffer.Get(dirty);
-		return buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
-	}
-
-	//! Returns a pointer of type T to a segment, or nullptr, if the buffer is not in memory.
-	template <class T>
-	inline unsafe_optional_ptr<T> GetIfLoaded(const IndexPointer ptr) {
-		return (T *)GetIfLoaded(ptr);
-	}
-
-	//! Returns the data_ptr_t to a segment, or nullptr, if the buffer is not in memory.
-	inline data_ptr_t GetIfLoaded(const IndexPointer ptr) {
-		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
-		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
-
-		auto &buffer = buffers.find(ptr.GetBufferId())->second;
-		if (!buffer.InMemory()) {
-			return nullptr;
-		}
-
-		auto buffer_ptr = buffer.Get();
-		auto raw_ptr = buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
-		return raw_ptr;
-	}
-
-	//! Resets the allocator, e.g., during 'DELETE FROM table'
-	void Reset();
-
-	//! Returns the in-memory size in bytes
-	idx_t GetInMemorySize() const;
-	//! Returns the segment size.
-	inline idx_t GetSegmentSize() const {
-		return segment_size;
-	}
-	//! Returns the total segment count.
-	inline idx_t GetSegmentCount() const {
-		return total_segment_count;
-	}
-
-	inline idx_t GetMaxSegmentsPerBuffer() const {
-		return available_segments_per_buffer;
-	}
-
-	//! Returns the upper bound of the available buffer IDs, i.e., upper_bound > max_buffer_id
-	idx_t GetUpperBoundBufferId() const;
-	//! Merge another FixedSizeAllocator into this allocator. Both must have the same segment size
-	void Merge(FixedSizeAllocator &other);
-
-	//! Initialize a vacuum operation, and return true, if the allocator needs a vacuum
-	bool InitializeVacuum();
-	//! Finalize a vacuum operation by freeing all vacuumed buffers
-	void FinalizeVacuum();
-	//! Returns true, if an IndexPointer qualifies for a vacuum operation, and false otherwise
-	inline bool NeedsVacuum(const IndexPointer ptr) const {
-		if (vacuum_buffers.find(ptr.GetBufferId()) != vacuum_buffers.end()) {
-			return true;
-		}
-		return false;
-	}
-	//! Vacuums an IndexPointer
-	IndexPointer VacuumPointer(const IndexPointer ptr);
-
-	//! Returns all FixedSizeAllocator information for serialization
-	FixedSizeAllocatorInfo GetInfo() const;
-	//! Serializes all in-memory buffers
-	void SerializeBuffers(PartialBlockManager &partial_block_manager);
-	//! Sets the allocation sizes and returns data to serialize each buffer
-	vector<IndexBufferInfo> InitSerializationToWAL();
-	//! Initialize a fixed-size allocator from allocator storage information
-	void Init(const FixedSizeAllocatorInfo &info);
-	//! Deserializes all metadata of older storage files
-	void Deserialize(MetadataManager &metadata_manager, const BlockPointer &block_pointer);
-	//! Removes empty buffers.
-	void RemoveEmptyBuffers();
-	//! Returns true, if the allocator does not contain any segments.
-	inline bool IsEmpty() {
-		return total_segment_count == 0;
-	}
-
-private:
-	//! Allocation size of one segment in a buffer
-	//! We only need this value to calculate bitmask_count, bitmask_offset, and
-	//! available_segments_per_buffer
-	idx_t segment_size;
-
-	//! Number of validity_t values in the bitmask
-	idx_t bitmask_count;
-	//! First starting byte of the payload (segments)
-	idx_t bitmask_offset;
-	//! Number of possible segment allocations per buffer
-	idx_t available_segments_per_buffer;
-
-	//! Total number of allocated segments in all buffers
-	//! We can recalculate this by iterating over all buffers
-	idx_t total_segment_count;
-
-	//! Buffers containing the segments
-	unordered_map<idx_t, FixedSizeBuffer> buffers;
-	//! Buffers with free space
-	unordered_set<idx_t> buffers_with_free_space;
-	//! Buffers qualifying for a vacuum (helper field to allow for fast NeedsVacuum checks)
-	unordered_set<idx_t> vacuum_buffers;
-
-private:
-	//! Returns an available buffer id
-	idx_t GetAvailableBufferId() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/fixed_size_buffer.hpp b/src/duckdb/src/include/duckdb/execution/index/fixed_size_buffer.hpp
deleted file mode 100644
index bf9b35d14..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/fixed_size_buffer.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/fixed_size_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/partial_block_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/block_manager.hpp"
-
-namespace duckdb {
-
-class FixedSizeAllocator;
-class MetadataWriter;
-
-struct PartialBlockForIndex : public PartialBlock {
-public:
-	PartialBlockForIndex(PartialBlockState state, BlockManager &block_manager,
-	                     const shared_ptr<BlockHandle> &block_handle);
-	~PartialBlockForIndex() override {};
-
-public:
-	void Flush(const idx_t free_space_left) override;
-	void Clear() override;
-	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
-};
-
-//! A fixed-size buffer holds fixed-size segments of data. It lazily deserializes a buffer, if on-disk and not
-//! yet in memory, and it only serializes dirty and non-written buffers to disk during
-//! serialization.
-class FixedSizeBuffer {
-public:
-	//! Constants for fast offset calculations in the bitmask
-	static constexpr idx_t BASE[] = {0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1};
-	static constexpr uint8_t SHIFT[] = {32, 16, 8, 4, 2, 1};
-
-public:
-	//! Constructor for a new in-memory buffer
-	explicit FixedSizeBuffer(BlockManager &block_manager);
-	//! Constructor for deserializing buffer metadata from disk
-	FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size,
-	                const BlockPointer &block_pointer);
-
-	//! Block manager of the database instance
-	BlockManager &block_manager;
-
-	//! The number of allocated segments
-	idx_t segment_count;
-	//! The size of allocated memory in this buffer (necessary for copying while pinning)
-	idx_t allocation_size;
-
-	//! True: the in-memory buffer is no longer consistent with a (possibly existing) copy on disk
-	bool dirty;
-	//! True: can be vacuumed after the vacuum operation
-	bool vacuum;
-
-	//! Partial block id and offset
-	BlockPointer block_pointer;
-
-public:
-	//! Returns true, if the buffer is in-memory
-	inline bool InMemory() const {
-		return buffer_handle.IsValid();
-	}
-	//! Returns true, if the block is on-disk
-	inline bool OnDisk() const {
-		return block_pointer.IsValid();
-	}
-	//! Returns a pointer to the buffer in memory, and calls Deserialize, if the buffer is not in memory
-	inline data_ptr_t Get(const bool dirty_p = true) {
-		if (!InMemory()) {
-			Pin();
-		}
-		if (dirty_p) {
-			dirty = dirty_p;
-		}
-		return buffer_handle.Ptr();
-	}
-	//! Destroys the in-memory buffer and the on-disk block
-	void Destroy();
-	//! Serializes a buffer (if dirty or not on disk)
-	void Serialize(PartialBlockManager &partial_block_manager, const idx_t available_segments, const idx_t segment_size,
-	               const idx_t bitmask_offset);
-	//! Pin a buffer (if not in-memory)
-	void Pin();
-	//! Returns the first free offset in a bitmask
-	uint32_t GetOffset(const idx_t bitmask_count, const idx_t available_segments);
-	//! Sets the allocation size, if dirty
-	void SetAllocationSize(const idx_t available_segments, const idx_t segment_size, const idx_t bitmask_offset);
-
-private:
-	//! The buffer handle of the in-memory buffer
-	BufferHandle buffer_handle;
-	//! The block handle of the on-disk buffer
-	shared_ptr<BlockHandle> block_handle;
-
-private:
-	//! Sets all uninitialized regions of a buffer in the respective partial block allocation
-	void SetUninitializedRegions(PartialBlockForIndex &p_block_for_index, const idx_t segment_size, const idx_t offset,
-	                             const idx_t bitmask_offset, const idx_t available_segments);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/index_pointer.hpp b/src/duckdb/src/include/duckdb/execution/index/index_pointer.hpp
deleted file mode 100644
index 0941adf34..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/index_pointer.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/index_pointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/typedefs.hpp"
-
-namespace duckdb {
-
-class IndexPointer {
-public:
-	//! Bit-shifting
-	static constexpr idx_t SHIFT_OFFSET = 32;
-	static constexpr idx_t SHIFT_METADATA = 56;
-	//! AND operations
-	static constexpr idx_t AND_OFFSET = 0x0000000000FFFFFF;
-	static constexpr idx_t AND_BUFFER_ID = 0x00000000FFFFFFFF;
-	static constexpr idx_t AND_METADATA = 0xFF00000000000000;
-
-public:
-	//! Constructs an empty IndexPointer
-	IndexPointer() : data(0) {};
-	//! Constructs an in-memory IndexPointer with a buffer ID and an offset
-	IndexPointer(const uint32_t buffer_id, const uint32_t offset) : data(0) {
-		auto shifted_offset = UnsafeNumericCast<idx_t>(offset) << SHIFT_OFFSET;
-		data += shifted_offset;
-		data += buffer_id;
-	};
-
-public:
-	//! Get data (all 64 bits)
-	inline idx_t Get() const {
-		return data;
-	}
-	//! Set data (all 64 bits)
-	inline void Set(const idx_t data_p) {
-		data = data_p;
-	}
-
-	//! Returns false, if the metadata is empty
-	inline bool HasMetadata() const {
-		return data & AND_METADATA;
-	}
-	//! Get metadata (zero to 7th bit)
-	inline uint8_t GetMetadata() const {
-		return data >> SHIFT_METADATA;
-	}
-	//! Set metadata (zero to 7th bit)
-	inline void SetMetadata(const uint8_t metadata) {
-		data &= ~AND_METADATA;
-		data |= UnsafeNumericCast<idx_t>(metadata) << SHIFT_METADATA;
-	}
-
-	//! Get the offset (8th to 23rd bit)
-	inline idx_t GetOffset() const {
-		auto offset = data >> SHIFT_OFFSET;
-		return offset & AND_OFFSET;
-	}
-	//! Get the buffer ID (24th to 63rd bit)
-	inline idx_t GetBufferId() const {
-		return data & AND_BUFFER_ID;
-	}
-
-	//! Resets the IndexPointer
-	inline void Clear() {
-		data = 0;
-	}
-
-	//! Adds an idx_t to a buffer ID, the rightmost 32 bits of data contain the buffer ID
-	inline void IncreaseBufferId(const idx_t summand) {
-		data += summand;
-	}
-
-	//! Comparison operator
-	inline bool operator==(const IndexPointer &ptr) const {
-		return data == ptr.data;
-	}
-
-private:
-	//! Data holds all the information contained in an IndexPointer
-	//! [0 - 7: metadata,
-	//! 8 - 23: offset, 24 - 63: buffer ID]
-	//! NOTE: we do not use bit fields because when using bit fields Windows compiles
-	//! the IndexPointer class into 16 bytes instead of the intended 8 bytes, doubling the
-	//! space requirements
-	//! https://learn.microsoft.com/en-us/cpp/cpp/cpp-bit-fields?view=msvc-170
-	idx_t data;
-};
-
-static_assert(sizeof(IndexPointer) == sizeof(idx_t), "Invalid size for IndexPointer.");
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/index_type.hpp b/src/duckdb/src/include/duckdb/execution/index/index_type.hpp
deleted file mode 100644
index 52d779f3d..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/index_type.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/index_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-class BoundIndex;
-class PhysicalOperator;
-class LogicalCreateIndex;
-enum class IndexConstraintType : uint8_t;
-class Expression;
-class TableIOManager;
-class AttachedDatabase;
-struct IndexStorageInfo;
-
-struct CreateIndexInput {
-	TableIOManager &table_io_manager;
-	AttachedDatabase &db;
-	IndexConstraintType constraint_type;
-	const string &name;
-	const vector<column_t> &column_ids;
-	const vector<unique_ptr<Expression>> &unbound_expressions;
-	const IndexStorageInfo &storage_info;
-	const case_insensitive_map_t<Value> &options;
-
-	CreateIndexInput(TableIOManager &table_io_manager, AttachedDatabase &db, IndexConstraintType constraint_type,
-	                 const string &name, const vector<column_t> &column_ids,
-	                 const vector<unique_ptr<Expression>> &unbound_expressions, const IndexStorageInfo &storage_info,
-	                 const case_insensitive_map_t<Value> &options)
-	    : table_io_manager(table_io_manager), db(db), constraint_type(constraint_type), name(name),
-	      column_ids(column_ids), unbound_expressions(unbound_expressions), storage_info(storage_info),
-	      options(options) {};
-};
-
-struct PlanIndexInput {
-	ClientContext &context;
-	LogicalCreateIndex &op;
-	unique_ptr<PhysicalOperator> &table_scan;
-
-	PlanIndexInput(ClientContext &context_p, LogicalCreateIndex &op_p, unique_ptr<PhysicalOperator> &table_scan_p)
-	    : context(context_p), op(op_p), table_scan(table_scan_p) {
-	}
-};
-
-typedef unique_ptr<BoundIndex> (*index_create_function_t)(CreateIndexInput &input);
-typedef unique_ptr<PhysicalOperator> (*index_plan_function_t)(PlanIndexInput &input);
-
-//! A index "type"
-class IndexType {
-public:
-	// The name of the index type
-	string name;
-
-	// Callbacks
-	index_plan_function_t create_plan = nullptr;
-	index_create_function_t create_instance = nullptr;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/index_type_set.hpp b/src/duckdb/src/include/duckdb/execution/index/index_type_set.hpp
deleted file mode 100644
index 9afe93e86..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/index_type_set.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/index_type_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/index_type.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-
-class IndexTypeSet {
-	mutex lock;
-	case_insensitive_map_t<IndexType> functions;
-
-public:
-	IndexTypeSet();
-	DUCKDB_API optional_ptr<IndexType> FindByName(const string &name);
-	DUCKDB_API void RegisterIndexType(const IndexType &index_type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/index/unbound_index.hpp b/src/duckdb/src/include/duckdb/execution/index/unbound_index.hpp
deleted file mode 100644
index 1c7f859ea..000000000
--- a/src/duckdb/src/include/duckdb/execution/index/unbound_index.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/unbound_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/index.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-
-namespace duckdb {
-
-class UnboundIndex final : public Index {
-private:
-	// The create info of the index
-	unique_ptr<CreateInfo> create_info;
-
-	// The serialized storage info of the index
-	IndexStorageInfo storage_info;
-
-public:
-	UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo storage_info, TableIOManager &table_io_manager,
-	             AttachedDatabase &db);
-
-	bool IsBound() const override {
-		return false;
-	}
-
-	const string &GetIndexType() const override {
-		return GetCreateInfo().index_type;
-	}
-
-	const string &GetIndexName() const override {
-		return GetCreateInfo().index_name;
-	}
-
-	IndexConstraintType GetConstraintType() const override {
-		return GetCreateInfo().constraint_type;
-	}
-
-	const CreateIndexInfo &GetCreateInfo() const {
-		return create_info->Cast<CreateIndexInfo>();
-	}
-
-	const IndexStorageInfo &GetStorageInfo() const {
-		return storage_info;
-	}
-
-	const vector<unique_ptr<ParsedExpression>> &GetParsedExpressions() const {
-		return GetCreateInfo().parsed_expressions;
-	}
-
-	const string &GetTableName() const {
-		return GetCreateInfo().table;
-	}
-
-	void CommitDrop() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp b/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp
deleted file mode 100644
index 441c3ecd8..000000000
--- a/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp
+++ /dev/null
@@ -1,432 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/join_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_consumer.hpp"
-#include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/row/partitioned_tuple_data.hpp"
-#include "duckdb/common/types/row/tuple_data_iterator.hpp"
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/ht_entry.hpp"
-
-namespace duckdb {
-
-class BufferManager;
-class BufferHandle;
-class ColumnDataCollection;
-struct ColumnDataAppendState;
-struct ClientConfig;
-
-struct JoinHTScanState {
-public:
-	JoinHTScanState(TupleDataCollection &collection, idx_t chunk_idx_from, idx_t chunk_idx_to,
-	                TupleDataPinProperties properties = TupleDataPinProperties::ALREADY_PINNED)
-	    : iterator(collection, properties, chunk_idx_from, chunk_idx_to, false), offset_in_chunk(0) {
-	}
-
-	TupleDataChunkIterator iterator;
-	idx_t offset_in_chunk;
-
-private:
-	//! Implicit copying is not allowed
-	JoinHTScanState(const JoinHTScanState &) = delete;
-};
-
-//! JoinHashTable is a linear probing HT that is used for computing joins
-/*!
-   The JoinHashTable concatenates incoming chunks inside a linked list of
-   data ptrs. The storage looks like this internally.
-   [SERIALIZED ROW][NEXT POINTER]
-   [SERIALIZED ROW][NEXT POINTER]
-   There is a separate hash map of pointers that point into this table.
-   This is what is used to resolve the hashes.
-   [POINTER]
-   [POINTER]
-   [POINTER]
-   The pointers are either NULL
-*/
-class JoinHashTable {
-public:
-	using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-	//! only compare salts with the ht entries if the capacity is larger than 8192 so
-	//! that it does not fit into the CPU cache
-	static constexpr const idx_t USE_SALT_THRESHOLD = 8192;
-
-	//! Scan structure that can be used to resume scans, as a single probe can
-	//! return 1024*N values (where N is the size of the HT). This is
-	//! returned by the JoinHashTable::Scan function and can be used to resume a
-	//! probe.
-	struct ScanStructure {
-		TupleDataChunkState &key_state;
-		//! Directly point to the entry in the hash table
-		Vector pointers;
-		idx_t count;
-		SelectionVector sel_vector;
-		SelectionVector chain_match_sel_vector;
-		SelectionVector chain_no_match_sel_vector;
-
-		// whether or not the given tuple has found a match
-		unsafe_unique_array<bool> found_match;
-		JoinHashTable &ht;
-		bool finished;
-		bool is_null;
-
-		// it records the RHS pointers for the result chunk
-		Vector rhs_pointers;
-		// it records the LHS sel vector for the result chunk
-		SelectionVector lhs_sel_vector;
-		// these two variable records the last match results
-		idx_t last_match_count;
-		SelectionVector last_sel_vector;
-
-		explicit ScanStructure(JoinHashTable &ht, TupleDataChunkState &key_state);
-		//! Get the next batch of data from the scan structure
-		void Next(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Are pointer chains all pointing to NULL?
-		bool PointersExhausted() const;
-
-	private:
-		//! Next operator for the inner join
-		void NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the semi join
-		void NextSemiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the anti join
-		void NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the RIGHT semi and anti join
-		void NextRightSemiOrAntiJoin(DataChunk &keys);
-		//! Next operator for the left outer join
-		void NextLeftJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the mark join
-		void NextMarkJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the single join
-		void NextSingleJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-
-		//! Scan the hashtable for matches of the specified keys, setting the found_match[] array to true or false
-		//! for every tuple
-		void ScanKeyMatches(DataChunk &keys);
-		template <bool MATCH>
-		void NextSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-
-		void ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &child, DataChunk &result);
-
-		idx_t ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector);
-
-		//! Update the data chunk compaction buffer
-		void UpdateCompactionBuffer(idx_t base_count, SelectionVector &result_vector, idx_t result_count);
-
-	public:
-		void AdvancePointers();
-		void AdvancePointers(const SelectionVector &sel, idx_t sel_count);
-		void GatherResult(Vector &result, const SelectionVector &result_vector, const SelectionVector &sel_vector,
-		                  const idx_t count, const idx_t col_idx);
-		void GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count, const idx_t col_idx);
-		void GatherResult(Vector &result, const idx_t count, const idx_t col_idx);
-		idx_t ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector *no_match_sel);
-	};
-
-public:
-	struct SharedState {
-		SharedState();
-
-		// The ptrs to the row to which a key should be inserted into during building
-		// or matched against during probing
-		Vector rhs_row_locations;
-		Vector salt_v;
-
-		SelectionVector salt_match_sel;
-		SelectionVector key_no_match_sel;
-	};
-
-	struct ProbeState : SharedState {
-		ProbeState();
-
-		Vector ht_offsets_v;
-		Vector ht_offsets_dense_v;
-
-		SelectionVector non_empty_sel;
-	};
-
-	struct InsertState : SharedState {
-		explicit InsertState(const JoinHashTable &ht);
-		/// Because of the index hick up
-		SelectionVector remaining_sel;
-		SelectionVector key_match_sel;
-
-		DataChunk lhs_data;
-		TupleDataChunkState chunk_state;
-	};
-
-	JoinHashTable(ClientContext &context, const vector<JoinCondition> &conditions, vector<LogicalType> build_types,
-	              JoinType type, const vector<idx_t> &output_columns);
-	~JoinHashTable();
-
-	//! Add the given data to the HT
-	void Build(PartitionedTupleDataAppendState &append_state, DataChunk &keys, DataChunk &input);
-	//! Merge another HT into this one
-	void Merge(JoinHashTable &other);
-	//! Combines the partitions in sink_collection into data_collection, as if it were not partitioned
-	void Unpartition();
-	//! Initialize the pointer table for the probe
-	void InitializePointerTable();
-	//! Finalize the build of the HT, constructing the actual hash table and making the HT ready for probing.
-	//! Finalize must be called before any call to Probe, and after Finalize is called Build should no longer be
-	//! ever called.
-	void Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel);
-	//! Probe the HT with the given input chunk, resulting in the given result
-	void Probe(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state, ProbeState &probe_state,
-	           optional_ptr<Vector> precomputed_hashes = nullptr);
-	//! Scan the HT to construct the full outer join result
-	void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result) const;
-
-	//! Fill the pointer with all the addresses from the hashtable for full scan
-	static idx_t FillWithHTOffsets(JoinHTScanState &state, Vector &addresses);
-
-	idx_t Count() const {
-		return data_collection->Count();
-	}
-	idx_t SizeInBytes() const {
-		return data_collection->SizeInBytes();
-	}
-
-	PartitionedTupleData &GetSinkCollection() {
-		return *sink_collection;
-	}
-
-	TupleDataCollection &GetDataCollection() {
-		return *data_collection;
-	}
-	bool NullValuesAreEqual(idx_t col_idx) const {
-		return null_values_are_equal[col_idx];
-	}
-
-	//! BufferManager
-	BufferManager &buffer_manager;
-	//! The join conditions
-	const vector<JoinCondition> &conditions;
-	//! The types of the keys used in equality comparison
-	vector<LogicalType> equality_types;
-	//! The types of the keys
-	vector<LogicalType> condition_types;
-	//! The types of all conditions
-	vector<LogicalType> build_types;
-	//! Positions of the columns that need to output
-	const vector<idx_t> &output_columns;
-	//! The comparison predicates that only contain equality predicates
-	vector<ExpressionType> equality_predicates;
-	//! The comparison predicates that contain non-equality predicates
-	vector<ExpressionType> non_equality_predicates;
-
-	//! The column indices of the equality predicates to be used to compare the rows
-	vector<column_t> equality_predicate_columns;
-	//! The column indices of the non-equality predicates to be used to compare the rows
-	vector<column_t> non_equality_predicate_columns;
-	//! Data column layout
-	TupleDataLayout layout;
-	//! Matches the equal condition rows during the build phase of the hash join to prevent
-	//! duplicates in a list because of hash-collisions
-	RowMatcher row_matcher_build;
-	//! Efficiently matches the non-equi rows during the probing phase, only there if non_equality_predicates is not
-	//! empty
-	unique_ptr<RowMatcher> row_matcher_probe;
-	//! Matches the same rows as the row_matcher, but also returns a vector for no matches
-	unique_ptr<RowMatcher> row_matcher_probe_no_match_sel;
-	//! Is true if there are predicates that are not equality predicates and we need to use the matchers during probing
-	bool needs_chain_matcher;
-
-	//! If there is more than one element in the chain, we need to scan the next elements of the chain
-	bool chains_longer_than_one;
-
-	//! The capacity of the HT. Is the same as hash_map.GetSize() / sizeof(ht_entry_t)
-	idx_t capacity = DConstants::INVALID_INDEX;
-	//! The size of an entry as stored in the HashTable
-	idx_t entry_size;
-	//! The total tuple size
-	idx_t tuple_size;
-	//! Next pointer offset in tuple, also used for the position of the hash, which then gets overwritten by the pointer
-	idx_t pointer_offset;
-	//! A constant false column for initialising right outer joins
-	Vector vfound;
-	//! The join type of the HT
-	JoinType join_type;
-	//! Whether or not the HT has been finalized
-	bool finalized;
-	//! Whether or not any of the key elements contain NULL
-	bool has_null;
-	//! Bitmask for getting relevant bits from the hashes to determine the position
-	uint64_t bitmask = DConstants::INVALID_INDEX;
-	//! Whether or not we error on multiple rows found per match in a SINGLE join
-	bool single_join_error_on_multiple_rows = true;
-
-	struct {
-		mutex mj_lock;
-		//! The types of the duplicate eliminated columns, only used in correlated MARK JOIN for flattening
-		//! ANY()/ALL() expressions
-		vector<LogicalType> correlated_types;
-		//! The aggregate expression nodes used by the HT
-		vector<unique_ptr<Expression>> correlated_aggregates;
-		//! The HT that holds the group counts for every correlated column
-		unique_ptr<GroupedAggregateHashTable> correlated_counts;
-		//! Group chunk used for aggregating into correlated_counts
-		DataChunk group_chunk;
-		//! Payload chunk used for aggregating into correlated_counts
-		DataChunk correlated_payload;
-		//! Result chunk used for aggregating into correlated_counts
-		DataChunk result_chunk;
-	} correlated_mark_join_info;
-
-private:
-	void InitializeScanStructure(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state,
-	                             const SelectionVector *&current_sel);
-	void Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes);
-
-	bool UseSalt() const;
-
-	//! Gets a pointer to the entry in the HT for each of the hashes_v using linear probing. Will update the
-	//! key_match_sel vector and the count argument to the number and position of the matches
-	void GetRowPointers(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &state, Vector &hashes_v,
-	                    const SelectionVector &sel, idx_t &count, Vector &pointers_result_v,
-	                    SelectionVector &match_sel);
-
-private:
-	//! Insert the given set of locations into the HT with the given set of hashes_v
-	void InsertHashes(Vector &hashes_v, idx_t count, TupleDataChunkState &chunk_state, InsertState &insert_statebool,
-	                  bool parallel);
-	//! Prepares keys by filtering NULLs
-	idx_t PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat> &vector_data, const SelectionVector *&current_sel,
-	                  SelectionVector &sel, bool build_side);
-
-	//! Lock for combining data_collection when merging HTs
-	mutex data_lock;
-	//! Partitioned data collection that the data is sunk into when building
-	unique_ptr<PartitionedTupleData> sink_collection;
-	//! The DataCollection holding the main data of the hash table
-	unique_ptr<TupleDataCollection> data_collection;
-
-	//! The hash map of the HT, created after finalization
-	AllocatedData hash_map;
-	ht_entry_t *entries = nullptr;
-	//! Whether or not NULL values are considered equal in each of the comparisons
-	vector<bool> null_values_are_equal;
-	//! An empty tuple that's a "dead end", can be used to stop chains early
-	unsafe_unique_array<data_t> dead_end;
-
-	//! Copying not allowed
-	JoinHashTable(const JoinHashTable &) = delete;
-
-public:
-	//===--------------------------------------------------------------------===//
-	// External Join
-	//===--------------------------------------------------------------------===//
-	static constexpr const idx_t INITIAL_RADIX_BITS = 4;
-
-	struct ProbeSpillLocalAppendState {
-		ProbeSpillLocalAppendState() {
-		}
-		//! Local partition and append state (if partitioned)
-		optional_ptr<PartitionedColumnData> local_partition;
-		optional_ptr<PartitionedColumnDataAppendState> local_partition_append_state;
-	};
-	//! ProbeSpill represents materialized probe-side data that could not be probed during PhysicalHashJoin::Execute
-	//! because the HashTable did not fit in memory. The ProbeSpill is not partitioned if the remaining data can be
-	//! dealt with in just 1 more round of probing, otherwise it is radix partitioned in the same way as the HashTable
-	struct ProbeSpill {
-	public:
-		ProbeSpill(JoinHashTable &ht, ClientContext &context, const vector<LogicalType> &probe_types);
-
-	public:
-		//! Create a state for a new thread
-		ProbeSpillLocalAppendState RegisterThread();
-		//! Append a chunk to this ProbeSpill
-		void Append(DataChunk &chunk, ProbeSpillLocalAppendState &local_state);
-		//! Finalize by merging the thread-local accumulated data
-		void Finalize();
-
-	public:
-		//! Prepare the next probe round
-		void PrepareNextProbe();
-		//! Scans and consumes the ColumnDataCollection
-		unique_ptr<ColumnDataConsumer> consumer;
-
-	private:
-		JoinHashTable &ht;
-		mutex lock;
-		ClientContext &context;
-
-		//! The types of the probe DataChunks
-		const vector<LogicalType> &probe_types;
-		//! The column ids
-		vector<column_t> column_ids;
-
-		//! The partitioned probe data and append states
-		unique_ptr<PartitionedColumnData> global_partitions;
-		vector<unique_ptr<PartitionedColumnData>> local_partitions;
-		vector<unique_ptr<PartitionedColumnDataAppendState>> local_partition_append_states;
-
-		//! The active probe data
-		unique_ptr<ColumnDataCollection> global_spill_collection;
-	};
-
-	idx_t GetRadixBits() const {
-		return radix_bits;
-	}
-
-	//! Capacity of the pointer table given the ht count
-	//! (minimum of 1024 to prevent collision chance for small HT's)
-	static idx_t PointerTableCapacity(idx_t count) {
-		return MaxValue<idx_t>(NextPowerOfTwo(count * 2), 1 << 10);
-	}
-	//! Size of the pointer table (in bytes)
-	static idx_t PointerTableSize(idx_t count) {
-		return PointerTableCapacity(count) * sizeof(data_ptr_t);
-	}
-
-	//! Get total size of HT if all partitions would be built
-	idx_t GetTotalSize(const vector<unique_ptr<JoinHashTable>> &local_hts, idx_t &max_partition_size,
-	                   idx_t &max_partition_count) const;
-	idx_t GetTotalSize(const vector<idx_t> &partition_sizes, const vector<idx_t> &partition_counts,
-	                   idx_t &max_partition_size, idx_t &max_partition_count) const;
-	//! Get the remaining size of the unbuilt partitions
-	idx_t GetRemainingSize() const;
-	//! Sets number of radix bits according to the max ht size
-	void SetRepartitionRadixBits(const idx_t max_ht_size, const idx_t max_partition_size,
-	                             const idx_t max_partition_count);
-	//! Initialized "current_partitions" and "completed_partitions"
-	void InitializePartitionMasks();
-	//! How many partitions are currently active
-	idx_t CurrentPartitionCount() const;
-	//! How many partitions are fully done
-	idx_t FinishedPartitionCount() const;
-	//! Partition this HT
-	void Repartition(JoinHashTable &global_ht);
-
-	//! Delete blocks that belong to the current partitioned HT
-	void Reset();
-	//! Build HT for the next partitioned probe round
-	bool PrepareExternalFinalize(const idx_t max_ht_size);
-	//! Probe whatever we can, sink the rest into a thread-local HT
-	void ProbeAndSpill(ScanStructure &scan_structure, DataChunk &probe_keys, TupleDataChunkState &key_state,
-	                   ProbeState &probe_state, DataChunk &probe_chunk, ProbeSpill &probe_spill,
-	                   ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk);
-
-private:
-	//! The current number of radix bits used to partition
-	idx_t radix_bits;
-
-	//! Bits set to 1 for currently active partitions
-	ValidityMask current_partitions;
-	//! Bits set to 1 for completed partitions
-	ValidityMask completed_partitions;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/merge_sort_tree.hpp b/src/duckdb/src/include/duckdb/execution/merge_sort_tree.hpp
deleted file mode 100644
index 672aaa56c..000000000
--- a/src/duckdb/src/include/duckdb/execution/merge_sort_tree.hpp
+++ /dev/null
@@ -1,732 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/merge_sort_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/array.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/vector_operations/aggregate_executor.hpp"
-#include <iomanip>
-#include <thread>
-
-namespace duckdb {
-
-// MIT License Text:
-//
-// Copyright 2022 salesforce.com, inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-// Implementation of a generic merge-sort-tree
-// Rewrite of the original, which was in C++17 and targeted for research,
-// instead of deployment.
-template <typename T>
-struct MergeSortTraits {
-	using return_type = T;
-	static const return_type SENTINEL() {
-		return NumericLimits<T>::Maximum();
-	};
-};
-
-template <typename... T>
-struct MergeSortTraits<std::tuple<T...>> {
-	using return_type = std::tuple<T...>;
-	static return_type SENTINEL() {
-		return std::tuple<T...> {MergeSortTraits<T>::SENTINEL()...};
-	};
-};
-
-template <typename... T>
-struct MergeSortTraits<std::pair<T...>> {
-	using return_type = std::pair<T...>;
-	static return_type SENTINEL() {
-		return std::pair<T...> {MergeSortTraits<T>::SENTINEL()...};
-	};
-};
-
-template <typename E = idx_t, typename O = idx_t, typename CMP = std::less<E>, uint64_t F = 32, uint64_t C = 32>
-struct MergeSortTree {
-	using ElementType = E;
-	using OffsetType = O;
-	using Elements = vector<ElementType>;
-	using Offsets = vector<OffsetType>;
-	using Level = pair<Elements, Offsets>;
-	using Tree = vector<Level>;
-
-	using RunElement = pair<ElementType, idx_t>;
-	using RunElements = array<RunElement, F>;
-	using Games = array<RunElement, F - 1>;
-
-	struct CompareElements {
-		explicit CompareElements(const CMP &cmp) : cmp(cmp) {
-		}
-
-		bool operator()(const RunElement &lhs, const RunElement &rhs) {
-			if (cmp(lhs.first, rhs.first)) {
-				return true;
-			}
-			if (cmp(rhs.first, lhs.first)) {
-				return false;
-			}
-			return lhs.second < rhs.second;
-		}
-
-		CMP cmp;
-	};
-
-	explicit MergeSortTree(const CMP &cmp = CMP()) : cmp(cmp) {
-	}
-
-	inline Elements &LowestLevel() {
-		return tree[0].first;
-	}
-
-	inline const Elements &LowestLevel() const {
-		return tree[0].first;
-	}
-
-	Elements &Allocate(idx_t count);
-
-	void Build();
-
-	idx_t SelectNth(const SubFrames &frames, idx_t n) const;
-
-	inline ElementType NthElement(idx_t i) const {
-		return tree.front().first[i];
-	}
-
-	template <typename L>
-	void AggregateLowerBound(const idx_t lower, const idx_t upper, const E needle, L aggregate) const;
-
-	Tree tree;
-	CompareElements cmp;
-
-	static constexpr auto FANOUT = F;
-	static constexpr auto CASCADING = C;
-
-protected:
-	//! Parallel build machinery
-	mutex build_lock;
-	atomic<idx_t> build_level;
-	atomic<idx_t> build_complete;
-	idx_t build_run;
-	idx_t build_run_length;
-	idx_t build_num_runs;
-
-	bool TryNextRun(idx_t &level_idx, idx_t &run_idx) {
-		const auto fanout = F;
-
-		lock_guard<mutex> stage_guard(build_lock);
-
-		// Finished with this level?
-		if (build_complete >= build_num_runs) {
-			++build_level;
-			if (build_level >= tree.size()) {
-				return false;
-			}
-
-			const auto count = LowestLevel().size();
-			build_run_length *= fanout;
-			build_num_runs = (count + build_run_length - 1) / build_run_length;
-			build_run = 0;
-			build_complete = 0;
-		}
-
-		// If all runs are in flight,
-		// yield until the next level is ready
-		if (build_run >= build_num_runs) {
-			return false;
-		}
-
-		level_idx = build_level;
-		run_idx = build_run++;
-
-		return true;
-	}
-
-	void BuildRun(idx_t level_idx, idx_t run_idx);
-
-	RunElement StartGames(Games &losers, const RunElements &elements, const RunElement &sentinel) {
-		const auto elem_nodes = elements.size();
-		const auto game_nodes = losers.size();
-		Games winners;
-
-		//	Play the first round of games,
-		//	placing the losers at the bottom of the game
-		const auto base_offset = game_nodes / 2;
-		auto losers_base = losers.data() + base_offset;
-		auto winners_base = winners.data() + base_offset;
-
-		const auto base_count = elem_nodes / 2;
-		for (idx_t i = 0; i < base_count; ++i) {
-			const auto &e0 = elements[i * 2 + 0];
-			const auto &e1 = elements[i * 2 + 1];
-			if (cmp(e0, e1)) {
-				losers_base[i] = e1;
-				winners_base[i] = e0;
-			} else {
-				losers_base[i] = e0;
-				winners_base[i] = e1;
-			}
-		}
-
-		//	Fill in any byes
-		if (elem_nodes % 2) {
-			winners_base[base_count] = elements.back();
-			losers_base[base_count] = sentinel;
-		}
-
-		//	Pad to a power of 2
-		const auto base_size = (game_nodes + 1) / 2;
-		for (idx_t i = (elem_nodes + 1) / 2; i < base_size; ++i) {
-			winners_base[i] = sentinel;
-			losers_base[i] = sentinel;
-		}
-
-		//	Play the winners against each other
-		//	and stick the losers in the upper levels of the tournament tree
-		for (idx_t i = base_offset; i-- > 0;) {
-			//	Indexing backwards
-			const auto &e0 = winners[i * 2 + 1];
-			const auto &e1 = winners[i * 2 + 2];
-			if (cmp(e0, e1)) {
-				losers[i] = e1;
-				winners[i] = e0;
-			} else {
-				losers[i] = e0;
-				winners[i] = e1;
-			}
-		}
-
-		//	Return the final winner
-		return winners[0];
-	}
-
-	RunElement ReplayGames(Games &losers, idx_t slot_idx, const RunElement &insert_val) {
-		RunElement smallest = insert_val;
-		//	Start at a fake level below
-		auto idx = slot_idx + losers.size();
-		do {
-			// Parent index
-			idx = (idx - 1) / 2;
-			// swap if out of order
-			if (cmp(losers[idx], smallest)) {
-				std::swap(losers[idx], smallest);
-			}
-		} while (idx);
-
-		return smallest;
-	}
-
-	static idx_t LowestCascadingLevel() {
-		idx_t level = 0;
-		idx_t level_width = 1;
-		while (level_width <= CASCADING) {
-			++level;
-			level_width *= FANOUT;
-		}
-		return level;
-	}
-
-public:
-	void Print() const {
-		std::ostringstream out;
-		const char *separator = "    ";
-		const char *group_separator = " || ";
-		idx_t level_width = 1;
-		idx_t number_width = 0;
-		for (auto &level : tree) {
-			for (auto &e : level.first) {
-				if (e) {
-					idx_t digits = ceil(log10(fabs(e))) + (e < 0);
-					if (digits > number_width) {
-						number_width = digits;
-					}
-				}
-			}
-		}
-		for (auto &level : tree) {
-			// Print the elements themself
-			{
-				out << 'd';
-				for (size_t i = 0; i < level.first.size(); ++i) {
-					out << ((i && i % level_width == 0) ? group_separator : separator);
-					out << std::setw(NumericCast<int32_t>(number_width)) << level.first[i];
-				}
-				out << '\n';
-			}
-			// Print the pointers
-			if (!level.second.empty()) {
-				idx_t run_cnt = (level.first.size() + level_width - 1) / level_width;
-				idx_t cascading_idcs_cnt = run_cnt * (2 + level_width / CASCADING) * FANOUT;
-				for (idx_t child_nr = 0; child_nr < FANOUT; ++child_nr) {
-					out << " ";
-					for (idx_t idx = 0; idx < cascading_idcs_cnt; idx += FANOUT) {
-						out << ((idx && ((idx / FANOUT) % (level_width / CASCADING + 2) == 0)) ? group_separator
-						                                                                       : separator);
-						out << std::setw(NumericCast<int32_t>(number_width)) << level.second[idx + child_nr];
-					}
-					out << '\n';
-				}
-			}
-			level_width *= FANOUT;
-		}
-
-		Printer::Print(out.str());
-	}
-};
-
-template <typename E, typename O, typename CMP, uint64_t F, uint64_t C>
-vector<E> &MergeSortTree<E, O, CMP, F, C>::Allocate(idx_t count) {
-	const auto fanout = F;
-	const auto cascading = C;
-	Elements lowest_level(count);
-	tree.emplace_back(Level(std::move(lowest_level), Offsets()));
-
-	for (idx_t child_run_length = 1; child_run_length < count;) {
-		const auto run_length = child_run_length * fanout;
-		const auto num_runs = (count + run_length - 1) / run_length;
-
-		Elements elements;
-		elements.resize(count);
-
-		//	Allocate cascading pointers only if there is room
-		Offsets cascades;
-		if (cascading > 0 && run_length > cascading) {
-			const auto num_cascades = fanout * num_runs * (run_length / cascading + 2);
-			cascades.resize(num_cascades);
-		}
-
-		//	Insert completed level and move up to the next one
-		tree.emplace_back(std::move(elements), std::move(cascades));
-		child_run_length = run_length;
-	}
-
-	//	Set up for parallel build
-	build_level = 1;
-	build_complete = 0;
-	build_run = 0;
-	build_run_length = fanout;
-	build_num_runs = (count + build_run_length - 1) / build_run_length;
-
-	return LowestLevel();
-}
-
-template <typename E, typename O, typename CMP, uint64_t F, uint64_t C>
-void MergeSortTree<E, O, CMP, F, C>::Build() {
-	//	Fan in parent levels until we are at the top
-	//	Note that we don't build the top layer as that would just be all the data.
-	while (build_level.load() < tree.size()) {
-		idx_t level_idx;
-		idx_t run_idx;
-		if (TryNextRun(level_idx, run_idx)) {
-			BuildRun(level_idx, run_idx);
-		} else {
-			std::this_thread::yield();
-		}
-	}
-}
-
-template <typename E, typename O, typename CMP, uint64_t F, uint64_t C>
-void MergeSortTree<E, O, CMP, F, C>::BuildRun(idx_t level_idx, idx_t run_idx) {
-	//	Create each parent run by merging the child runs using a tournament tree
-	// 	https://en.wikipedia.org/wiki/K-way_merge_algorithm
-	const auto fanout = F;
-	const auto cascading = C;
-
-	auto &elements = tree[level_idx].first;
-	auto &cascades = tree[level_idx].second;
-	const auto &child_level = tree[level_idx - 1];
-	const auto count = elements.size();
-
-	idx_t child_run_length = 1;
-	auto run_length = child_run_length * fanout;
-	for (idx_t l = 1; l < level_idx; ++l) {
-		child_run_length = run_length;
-		run_length *= fanout;
-	}
-
-	const RunElement SENTINEL(MergeSortTraits<ElementType>::SENTINEL(), MergeSortTraits<idx_t>::SENTINEL());
-
-	//	Position markers for scanning the children.
-	using Bounds = pair<OffsetType, OffsetType>;
-	array<Bounds, fanout> bounds;
-	//	Start with first element of each (sorted) child run
-	RunElements players;
-	const auto child_base = run_idx * run_length;
-	for (idx_t child_run = 0; child_run < fanout; ++child_run) {
-		const auto child_idx = child_base + child_run * child_run_length;
-		bounds[child_run] = {OffsetType(MinValue<idx_t>(child_idx, count)),
-		                     OffsetType(MinValue<idx_t>(child_idx + child_run_length, count))};
-		if (bounds[child_run].first != bounds[child_run].second) {
-			players[child_run] = {child_level.first[child_idx], child_run};
-		} else {
-			//	Empty child
-			players[child_run] = SENTINEL;
-		}
-	}
-
-	//	Play the first round and extract the winner
-	Games games;
-	auto element_idx = child_base;
-	auto cascade_idx = fanout * run_idx * (run_length / cascading + 2);
-	auto winner = StartGames(games, players, SENTINEL);
-	while (winner != SENTINEL) {
-		// Add fractional cascading pointers
-		// if we are on a fraction boundary
-		if (!cascades.empty() && element_idx % cascading == 0) {
-			for (idx_t i = 0; i < fanout; ++i) {
-				cascades[cascade_idx++] = bounds[i].first;
-			}
-		}
-
-		//	Insert new winner element into the current run
-		elements[element_idx++] = winner.first;
-		const auto child_run = winner.second;
-		auto &child_idx = bounds[child_run].first;
-		++child_idx;
-
-		//	Move to the next entry in the child run (if any)
-		if (child_idx < bounds[child_run].second) {
-			winner = ReplayGames(games, child_run, {child_level.first[child_idx], child_run});
-		} else {
-			winner = ReplayGames(games, child_run, SENTINEL);
-		}
-	}
-
-	// Add terminal cascade pointers to the end
-	if (!cascades.empty()) {
-		for (idx_t j = 0; j < 2; ++j) {
-			for (idx_t i = 0; i < fanout; ++i) {
-				cascades[cascade_idx++] = bounds[i].first;
-			}
-		}
-	}
-
-	++build_complete;
-}
-
-template <typename E, typename O, typename CMP, uint64_t F, uint64_t C>
-idx_t MergeSortTree<E, O, CMP, F, C>::SelectNth(const SubFrames &frames, idx_t n) const {
-	// Handle special case of a one-element tree
-	if (tree.size() < 2) {
-		return 0;
-	}
-
-	// 	The first level contains a single run,
-	//	so the only thing we need is any cascading pointers
-	auto level_no = tree.size() - 2;
-	idx_t level_width = 1;
-	for (idx_t i = 0; i < level_no; ++i) {
-		level_width *= FANOUT;
-	}
-
-	// Find Nth element in a top-down traversal
-	idx_t result = 0;
-
-	// First, handle levels with cascading pointers
-	const auto min_cascaded = LowestCascadingLevel();
-	if (level_no > min_cascaded) {
-		//	Initialise the cascade indicies from the previous level
-		using CascadeRange = pair<idx_t, idx_t>;
-		std::array<CascadeRange, 3> cascades;
-		const auto &level = tree[level_no + 1].first;
-		for (idx_t f = 0; f < frames.size(); ++f) {
-			const auto &frame = frames[f];
-			auto &cascade_idx = cascades[f];
-			const auto lower_idx =
-			    UnsafeNumericCast<idx_t>(std::lower_bound(level.begin(), level.end(), frame.start) - level.begin());
-			cascade_idx.first = lower_idx / CASCADING * FANOUT;
-			const auto upper_idx =
-			    UnsafeNumericCast<idx_t>(std::lower_bound(level.begin(), level.end(), frame.end) - level.begin());
-			cascade_idx.second = upper_idx / CASCADING * FANOUT;
-		}
-
-		// 	Walk the cascaded levels
-		for (; level_no >= min_cascaded; --level_no) {
-			//	The cascade indicies into this level are in the previous level
-			const auto &level_cascades = tree[level_no + 1].second;
-
-			// Go over all children until we found enough in range
-			const auto *level_data = tree[level_no].first.data();
-			while (true) {
-				idx_t matched = 0;
-				std::array<CascadeRange, 3> matches;
-				for (idx_t f = 0; f < frames.size(); ++f) {
-					const auto &frame = frames[f];
-					auto &cascade_idx = cascades[f];
-					auto &match = matches[f];
-
-					const auto lower_begin = level_data + level_cascades[cascade_idx.first];
-					const auto lower_end = level_data + level_cascades[cascade_idx.first + FANOUT];
-					match.first =
-					    UnsafeNumericCast<idx_t>(std::lower_bound(lower_begin, lower_end, frame.start) - level_data);
-
-					const auto upper_begin = level_data + level_cascades[cascade_idx.second];
-					const auto upper_end = level_data + level_cascades[cascade_idx.second + FANOUT];
-					match.second =
-					    UnsafeNumericCast<idx_t>(std::lower_bound(upper_begin, upper_end, frame.end) - level_data);
-
-					matched += idx_t(match.second - match.first);
-				}
-				if (matched > n) {
-					// 	Too much in this level, so move down to leftmost child candidate within the cascade range
-					for (idx_t f = 0; f < frames.size(); ++f) {
-						auto &cascade_idx = cascades[f];
-						auto &match = matches[f];
-						cascade_idx.first = (match.first / CASCADING + 2 * result) * FANOUT;
-						cascade_idx.second = (match.second / CASCADING + 2 * result) * FANOUT;
-					}
-					break;
-				}
-
-				//	Not enough in this child, so move right
-				for (idx_t f = 0; f < frames.size(); ++f) {
-					auto &cascade_idx = cascades[f];
-					++cascade_idx.first;
-					++cascade_idx.second;
-				}
-				++result;
-				n -= matched;
-			}
-			result *= FANOUT;
-			level_width /= FANOUT;
-		}
-	}
-
-	//	Continue with the uncascaded levels (except the first)
-	for (; level_no > 0; --level_no) {
-		const auto &level = tree[level_no].first;
-		auto range_begin = level.begin() + UnsafeNumericCast<int64_t>(result * level_width);
-		auto range_end = range_begin + UnsafeNumericCast<int64_t>(level_width);
-		while (range_end < level.end()) {
-			idx_t matched = 0;
-			for (idx_t f = 0; f < frames.size(); ++f) {
-				const auto &frame = frames[f];
-				const auto lower_match = std::lower_bound(range_begin, range_end, frame.start);
-				const auto upper_match = std::lower_bound(lower_match, range_end, frame.end);
-				matched += idx_t(upper_match - lower_match);
-			}
-			if (matched > n) {
-				// 	Too much in this level, so move down to leftmost child candidate
-				//	Since we have no cascade pointers left, this is just the start of the next level.
-				break;
-			}
-			//	Not enough in this child, so move right
-			range_begin = range_end;
-			range_end += UnsafeNumericCast<int64_t>(level_width);
-			++result;
-			n -= matched;
-		}
-		result *= FANOUT;
-		level_width /= FANOUT;
-	}
-
-	// The last level
-	const auto *level_data = tree[level_no].first.data();
-	++n;
-
-	const auto count = tree[level_no].first.size();
-	for (const auto limit = MinValue<idx_t>(result + FANOUT, count); result < limit; ++result) {
-		const auto v = level_data[result];
-		for (const auto &frame : frames) {
-			n -= (v >= frame.start) && (v < frame.end);
-		}
-		if (!n) {
-			break;
-		}
-	}
-
-	return result;
-}
-
-template <typename E, typename O, typename CMP, uint64_t F, uint64_t C>
-template <typename L>
-void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, const idx_t upper, const E needle,
-                                                         L aggregate) const {
-
-	if (lower >= upper) {
-		return;
-	}
-
-	D_ASSERT(upper <= tree[0].first.size());
-
-	using IdxRange = std::pair<idx_t, idx_t>;
-
-	// Find the entry point into the tree
-	IdxRange run_idx(lower, upper - 1);
-	idx_t level_width = 1;
-	idx_t level = 0;
-	IdxRange prev_run_idx;
-	IdxRange curr;
-	if (run_idx.first == run_idx.second) {
-		curr.first = curr.second = run_idx.first;
-	} else {
-		do {
-			prev_run_idx.second = run_idx.second;
-			run_idx.first /= FANOUT;
-			run_idx.second /= FANOUT;
-			level_width *= FANOUT;
-			++level;
-		} while (run_idx.first != run_idx.second);
-		curr.second = prev_run_idx.second * level_width / FANOUT;
-		curr.first = curr.second;
-	}
-
-	// Aggregate layers using the cascading indices
-	if (level > LowestCascadingLevel()) {
-		IdxRange cascading_idx;
-		// Find the initial cascading idcs
-		{
-			IdxRange entry;
-			entry.first = run_idx.first * level_width;
-			entry.second = std::min(entry.first + level_width, static_cast<idx_t>(tree[0].first.size()));
-			auto *level_data = tree[level].first.data();
-			auto entry_idx = NumericCast<idx_t>(
-			    std::lower_bound(level_data + entry.first, level_data + entry.second, needle) - level_data);
-			cascading_idx.first = cascading_idx.second =
-			    (entry_idx / CASCADING + 2 * (entry.first / level_width)) * FANOUT;
-
-			// We have to slightly shift the initial CASCADING idcs because at the top level
-			// we won't be exactly on a boundary
-			auto correction = (prev_run_idx.second - run_idx.second * FANOUT);
-			cascading_idx.first -= (FANOUT - correction);
-			cascading_idx.second += correction;
-		}
-
-		// Aggregate all layers until we reach a layer without cascading indices
-		// For the first layer, we already checked we have cascading indices available, otherwise
-		// we wouldn't have even searched the entry points. Hence, we use a `do-while` instead of `while`
-		do {
-			--level;
-			level_width /= FANOUT;
-			auto *level_data = tree[level].first.data();
-			auto &cascading_idcs = tree[level + 1].second;
-			// Left side of tree
-			// Handle all completely contained runs
-			cascading_idx.first += FANOUT - 1;
-			while (curr.first - lower >= level_width) {
-				// Search based on cascading info from previous level
-				const auto *search_begin = level_data + cascading_idcs[cascading_idx.first];
-				const auto *search_end = level_data + cascading_idcs[cascading_idx.first + FANOUT];
-				const auto run_pos = std::lower_bound(search_begin, search_end, needle, cmp.cmp) - level_data;
-				// Compute runBegin and pass it to our callback
-				const auto run_begin = curr.first - level_width;
-				aggregate(level, run_begin, NumericCast<idx_t>(run_pos));
-				// Update state for next round
-				curr.first -= level_width;
-				--cascading_idx.first;
-			}
-			// Handle the partial last run to find the cascading entry point for the next level
-			if (curr.first != lower) {
-				const auto *search_begin = level_data + cascading_idcs[cascading_idx.first];
-				const auto *search_end = level_data + cascading_idcs[cascading_idx.first + FANOUT];
-				auto idx = NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle, cmp.cmp) - level_data);
-				cascading_idx.first = (idx / CASCADING + 2 * (lower / level_width)) * FANOUT;
-			}
-
-			// Right side of tree
-			// Handle all completely contained runs
-			while (upper - curr.second >= level_width) {
-				// Search based on cascading info from previous level
-				const auto *search_begin = level_data + cascading_idcs[cascading_idx.second];
-				const auto *search_end = level_data + cascading_idcs[cascading_idx.second + FANOUT];
-				const auto run_pos = std::lower_bound(search_begin, search_end, needle, cmp.cmp) - level_data;
-				// Compute runBegin and pass it to our callback
-				const auto run_begin = curr.second;
-				aggregate(level, run_begin, NumericCast<idx_t>(run_pos));
-				// Update state for next round
-				curr.second += level_width;
-				++cascading_idx.second;
-			}
-			// Handle the partial last run to find the cascading entry point for the next level
-			if (curr.second != upper) {
-				const auto *search_begin = level_data + cascading_idcs[cascading_idx.second];
-				const auto *search_end = level_data + cascading_idcs[cascading_idx.second + FANOUT];
-				auto idx = NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle, cmp.cmp) - level_data);
-				cascading_idx.second = (idx / CASCADING + 2 * (upper / level_width)) * FANOUT;
-			}
-		} while (level >= LowestCascadingLevel());
-	}
-
-	// Handle lower levels which won't have cascading info
-	if (level) {
-		while (--level) {
-			level_width /= FANOUT;
-			auto *level_data = tree[level].first.data();
-			// Left side
-			while (curr.first - lower >= level_width) {
-				const auto *search_end = level_data + curr.first;
-				const auto *search_begin = search_end - level_width;
-				const auto run_pos =
-				    NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle, cmp.cmp) - level_data);
-				const auto run_begin = NumericCast<idx_t>(search_begin - level_data);
-				aggregate(level, run_begin, run_pos);
-				curr.first -= level_width;
-			}
-			// Right side
-			while (upper - curr.second >= level_width) {
-				const auto *search_begin = level_data + curr.second;
-				const auto *search_end = search_begin + level_width;
-				const auto run_pos =
-				    NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle, cmp.cmp) - level_data);
-				const auto run_begin = NumericCast<idx_t>(search_begin - level_data);
-				aggregate(level, run_begin, run_pos);
-				curr.second += level_width;
-			}
-		}
-	}
-
-	// The last layer
-	{
-		auto *level_data = tree[0].first.data();
-		// Left side
-		auto lower_it = lower;
-		while (lower_it != curr.first) {
-			const auto *search_begin = level_data + lower_it;
-			const auto run_begin = lower_it;
-			const auto run_pos = run_begin + cmp.cmp(*search_begin, needle);
-			aggregate(level, run_begin, run_pos);
-			++lower_it;
-		}
-		// Right side
-		while (curr.second != upper) {
-			const auto *search_begin = level_data + curr.second;
-			const auto run_begin = curr.second;
-			const auto run_pos = run_begin + cmp.cmp(*search_begin, needle);
-			aggregate(level, run_begin, run_pos);
-			++curr.second;
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/nested_loop_join.hpp b/src/duckdb/src/include/duckdb/execution/nested_loop_join.hpp
deleted file mode 100644
index b5f36ee0a..000000000
--- a/src/duckdb/src/include/duckdb/execution/nested_loop_join.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/nested_loop_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-class ColumnDataCollection;
-
-struct NestedLoopJoinInner {
-	static idx_t Perform(idx_t &ltuple, idx_t &rtuple, DataChunk &left_conditions, DataChunk &right_conditions,
-	                     SelectionVector &lvector, SelectionVector &rvector, const vector<JoinCondition> &conditions);
-};
-
-struct NestedLoopJoinMark {
-	static void Perform(DataChunk &left, ColumnDataCollection &right, bool found_match[],
-	                    const vector<JoinCondition> &conditions);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/aggregate_object.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/aggregate_object.hpp
deleted file mode 100644
index a67683f72..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/aggregate_object.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/aggregate_object.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-
-namespace duckdb {
-
-class BoundAggregateExpression;
-class BoundWindowExpression;
-
-struct FunctionDataWrapper {
-	explicit FunctionDataWrapper(unique_ptr<FunctionData> function_data_p) : function_data(std::move(function_data_p)) {
-	}
-
-	unique_ptr<FunctionData> function_data;
-};
-
-struct AggregateObject { // NOLINT: work-around bug in clang-tidy
-	AggregateObject(AggregateFunction function, FunctionData *bind_data, idx_t child_count, idx_t payload_size,
-	                AggregateType aggr_type, PhysicalType return_type, Expression *filter = nullptr);
-	explicit AggregateObject(BoundAggregateExpression *aggr);
-	explicit AggregateObject(const BoundWindowExpression &window);
-
-	FunctionData *GetFunctionData() const {
-		return bind_data_wrapper ? bind_data_wrapper->function_data.get() : nullptr;
-	}
-
-	AggregateFunction function;
-	shared_ptr<FunctionDataWrapper> bind_data_wrapper;
-	idx_t child_count;
-	idx_t payload_size;
-	AggregateType aggr_type;
-	PhysicalType return_type;
-	Expression *filter = nullptr;
-
-public:
-	bool IsDistinct() const {
-		return aggr_type == AggregateType::DISTINCT;
-	}
-	static vector<AggregateObject> CreateAggregateObjects(const vector<BoundAggregateExpression *> &bindings);
-};
-
-struct AggregateFilterData {
-	AggregateFilterData(ClientContext &context, Expression &filter_expr, const vector<LogicalType> &payload_types);
-
-	idx_t ApplyFilter(DataChunk &payload);
-
-	ExpressionExecutor filter_executor;
-	DataChunk filtered_payload;
-	SelectionVector true_sel;
-};
-
-struct AggregateFilterDataSet {
-	AggregateFilterDataSet();
-
-	vector<unique_ptr<AggregateFilterData>> filter_data;
-
-public:
-	void Initialize(ClientContext &context, const vector<AggregateObject> &aggregates,
-	                const vector<LogicalType> &payload_types);
-
-	AggregateFilterData &GetFilterData(idx_t aggr_idx);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp
deleted file mode 100644
index 59d2b7a06..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/execution/radix_partitioned_hashtable.hpp"
-
-namespace duckdb {
-
-class GroupedAggregateData;
-
-struct DistinctAggregateCollectionInfo {
-public:
-	DistinctAggregateCollectionInfo(const vector<unique_ptr<Expression>> &aggregates, vector<idx_t> indices);
-
-public:
-	// The indices of the aggregates that are distinct
-	unsafe_vector<idx_t> indices;
-	// The amount of radix_tables that are occupied
-	idx_t table_count;
-	//! Occupied tables, not equal to indices if aggregates share input data
-	vector<idx_t> table_indices;
-	//! This indirection is used to allow two aggregates to share the same input data
-	unordered_map<idx_t, idx_t> table_map;
-	const vector<unique_ptr<Expression>> &aggregates;
-	// Total amount of children of the distinct aggregates
-	idx_t total_child_count;
-
-public:
-	static unique_ptr<DistinctAggregateCollectionInfo> Create(vector<unique_ptr<Expression>> &aggregates);
-	const unsafe_vector<idx_t> &Indices() const;
-	bool AnyDistinct() const;
-
-private:
-	//! Returns the amount of tables that are occupied
-	idx_t CreateTableIndexMap();
-};
-
-struct DistinctAggregateData {
-public:
-	explicit DistinctAggregateData(const DistinctAggregateCollectionInfo &info);
-	DistinctAggregateData(const DistinctAggregateCollectionInfo &info, const GroupingSet &groups,
-	                      const vector<unique_ptr<Expression>> *group_expressions);
-	//! The data used by the hashtables
-	vector<unique_ptr<GroupedAggregateData>> grouped_aggregate_data;
-	//! The hashtables
-	vector<unique_ptr<RadixPartitionedHashTable>> radix_tables;
-	//! The groups (arguments)
-	vector<GroupingSet> grouping_sets;
-	const DistinctAggregateCollectionInfo &info;
-
-public:
-	bool IsDistinct(idx_t index) const;
-};
-
-struct DistinctAggregateState {
-public:
-	DistinctAggregateState(const DistinctAggregateData &data, ClientContext &client);
-
-	//! The executor
-	ExpressionExecutor child_executor;
-	//! The global sink states of the hash tables
-	vector<unique_ptr<GlobalSinkState>> radix_states;
-	//! Output chunks to receive distinct data from hashtables
-	vector<unique_ptr<DataChunk>> distinct_output_chunks;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp
deleted file mode 100644
index 422694204..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-class GroupedAggregateData {
-public:
-	GroupedAggregateData() {
-	}
-	//! The groups
-	vector<unique_ptr<Expression>> groups;
-	//! The set of GROUPING functions
-	vector<vector<idx_t>> grouping_functions;
-	//! The group types
-	vector<LogicalType> group_types;
-
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-	//! The payload types
-	vector<LogicalType> payload_types;
-	//! The aggregate return types
-	vector<LogicalType> aggregate_return_types;
-	//! Pointers to the aggregates
-	vector<BoundAggregateExpression *> bindings;
-	idx_t filter_count;
-
-public:
-	idx_t GroupCount() const;
-
-	const vector<vector<idx_t>> &GetGroupingFunctions() const;
-
-	void InitializeGroupby(vector<unique_ptr<Expression>> groups, vector<unique_ptr<Expression>> expressions,
-	                       vector<unsafe_vector<idx_t>> grouping_functions);
-
-	//! Initialize a GroupedAggregateData object for use with distinct aggregates
-	void InitializeDistinct(const unique_ptr<Expression> &aggregate, const vector<unique_ptr<Expression>> *groups_p);
-
-private:
-	void InitializeDistinctGroups(const vector<unique_ptr<Expression>> *groups);
-	void InitializeGroupbyGroups(vector<unique_ptr<Expression>> groups);
-	void SetGroupingFunctions(vector<unsafe_vector<idx_t>> &functions);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp
deleted file mode 100644
index 195d1fb99..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/execution/radix_partitioned_hashtable.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class BufferManager;
-class PhysicalHashAggregate;
-
-struct HashAggregateGroupingData {
-public:
-	HashAggregateGroupingData(GroupingSet &grouping_set_p, const GroupedAggregateData &grouped_aggregate_data,
-	                          unique_ptr<DistinctAggregateCollectionInfo> &info);
-
-public:
-	RadixPartitionedHashTable table_data;
-	unique_ptr<DistinctAggregateData> distinct_data;
-
-public:
-	bool HasDistinct() const;
-};
-
-struct HashAggregateGroupingGlobalState {
-public:
-	HashAggregateGroupingGlobalState(const HashAggregateGroupingData &data, ClientContext &context);
-	// Radix state of the GROUPING_SET ht
-	unique_ptr<GlobalSinkState> table_state;
-	// State of the DISTINCT aggregates of this GROUPING_SET
-	unique_ptr<DistinctAggregateState> distinct_state;
-};
-
-struct HashAggregateGroupingLocalState {
-public:
-	HashAggregateGroupingLocalState(const PhysicalHashAggregate &op, const HashAggregateGroupingData &data,
-	                                ExecutionContext &context);
-
-public:
-	// Radix state of the GROUPING_SET ht
-	unique_ptr<LocalSinkState> table_state;
-	// Local states of the DISTINCT aggregates hashtables
-	vector<unique_ptr<LocalSinkState>> distinct_states;
-};
-
-//! PhysicalHashAggregate is a group-by and aggregate implementation that uses a hash table to perform the grouping
-//! This only contains read-only variables, anything that is stateful instead gets stored in the Global/Local states
-class PhysicalHashAggregate : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::HASH_GROUP_BY;
-
-public:
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      idx_t estimated_cardinality);
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      vector<unique_ptr<Expression>> groups, idx_t estimated_cardinality);
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      vector<unique_ptr<Expression>> groups, vector<GroupingSet> grouping_sets,
-	                      vector<unsafe_vector<idx_t>> grouping_functions, idx_t estimated_cardinality);
-
-	//! The grouping sets
-	GroupedAggregateData grouped_aggregate_data;
-
-	vector<GroupingSet> grouping_sets;
-	//! The radix partitioned hash tables (one per grouping set)
-	vector<HashAggregateGroupingData> groupings;
-	unique_ptr<DistinctAggregateCollectionInfo> distinct_collection_info;
-	//! A recreation of the input chunk, with nulls for everything that isnt a group
-	vector<LogicalType> input_group_types;
-
-	// Filters given to Sink and friends
-	unsafe_vector<idx_t> non_distinct_filter;
-	unsafe_vector<idx_t> distinct_filter;
-
-	unordered_map<Expression *, size_t> filter_indexes;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	SinkFinalizeType FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context, GlobalSinkState &gstate,
-	                                  bool check_distinct) const;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-	//! Toggle multi-scan capability on a hash table, which prevents the scan of the aggregate from being destructive
-	//! If this is not toggled the GetData method will destroy the hash table as it is scanning it
-	static void SetMultiScan(GlobalSinkState &state);
-
-private:
-	//! When we only have distinct aggregates, we can delay adding groups to the main ht
-	bool CanSkipRegularSink() const;
-
-	//! Finalize the distinct aggregates
-	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
-	                                  GlobalSinkState &gstate) const;
-	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
-	//! Sink the distinct aggregates for a single grouping
-	void SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
-	                          idx_t grouping_idx) const;
-	//! Sink the distinct aggregates
-	void SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
-	//! Create groups in the main ht for groups that would otherwise get filtered out completely
-	SinkResultType SinkGroupsOnly(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                              DataChunk &input) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp
deleted file mode 100644
index 071a82ed1..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/execution/radix_partitioned_hashtable.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-//! PhysicalPartitionedAggregate is an aggregate operator that can only perform aggregates on data that is partitioned
-// by the grouping columns
-class PhysicalPartitionedAggregate : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PARTITIONED_AGGREGATE;
-
-public:
-	PhysicalPartitionedAggregate(ClientContext &context, vector<LogicalType> types,
-	                             vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> groups,
-	                             vector<column_t> partitions, idx_t estimated_cardinality);
-
-	//! The partitions over which this is grouped
-	vector<column_t> partitions;
-	//! The groups over which the aggregate is partitioned - note that this is only
-	vector<unique_ptr<Expression>> groups;
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	SinkNextBatchType NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	OperatorPartitionInfo RequiredPartitionInfo() const override;
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp
deleted file mode 100644
index 6171f1a8d..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/execution/base_aggregate_hashtable.hpp"
-
-namespace duckdb {
-class ClientContext;
-class PerfectAggregateHashTable;
-
-//! PhysicalPerfectHashAggregate performs a group-by and aggregation using a perfect hash table
-class PhysicalPerfectHashAggregate : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PERFECT_HASH_GROUP_BY;
-
-public:
-	PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types,
-	                             vector<unique_ptr<Expression>> aggregates, vector<unique_ptr<Expression>> groups,
-	                             const vector<unique_ptr<BaseStatistics>> &group_stats, vector<idx_t> required_bits,
-	                             idx_t estimated_cardinality);
-
-	//! The groups
-	vector<unique_ptr<Expression>> groups;
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	//! Create a perfect aggregate hash table for this node
-	unique_ptr<PerfectAggregateHashTable> CreateHT(Allocator &allocator, ClientContext &context) const;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-
-public:
-	//! The group types
-	vector<LogicalType> group_types;
-	//! The payload types
-	vector<LogicalType> payload_types;
-	//! The aggregates to be computed
-	vector<AggregateObject> aggregate_objects;
-	//! The minimum value of each of the groups
-	vector<Value> group_minima;
-	//! The number of bits we need to completely cover each of the groups
-	vector<idx_t> required_bits;
-
-	unordered_map<Expression *, size_t> filter_indexes;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_streaming_window.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_streaming_window.hpp
deleted file mode 100644
index a9b9f9b01..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_streaming_window.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! PhysicalStreamingWindow implements streaming window functions (i.e. with an empty OVER clause)
-class PhysicalStreamingWindow : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_WINDOW;
-
-	static bool IsStreamingFunction(ClientContext &context, unique_ptr<Expression> &expr);
-
-public:
-	PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-	                        idx_t estimated_cardinality,
-	                        PhysicalOperatorType type = PhysicalOperatorType::STREAMING_WINDOW);
-
-	//! The projection list of the WINDOW statement
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	OperatorFinalizeResultType FinalExecute(ExecutionContext &context, DataChunk &chunk, GlobalOperatorState &gstate,
-	                                        OperatorState &state) const final;
-
-	bool RequiresFinalExecute() const final {
-		return true;
-	}
-
-	OrderPreservationType OperatorOrder() const override {
-		return OrderPreservationType::FIXED_ORDER;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-private:
-	void ExecuteFunctions(ExecutionContext &context, DataChunk &chunk, DataChunk &delayed,
-	                      GlobalOperatorState &gstate_p, OperatorState &state_p) const;
-	void ExecuteInput(ExecutionContext &context, DataChunk &delayed, DataChunk &input, DataChunk &chunk,
-	                  GlobalOperatorState &gstate, OperatorState &state) const;
-	void ExecuteDelayed(ExecutionContext &context, DataChunk &delayed, DataChunk &input, DataChunk &chunk,
-	                    GlobalOperatorState &gstate, OperatorState &state) const;
-	void ExecuteShifted(ExecutionContext &context, DataChunk &delayed, DataChunk &input, DataChunk &chunk,
-	                    GlobalOperatorState &gstate, OperatorState &state) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp
deleted file mode 100644
index cd7d2a64a..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/execution/radix_partitioned_hashtable.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-//! PhysicalUngroupedAggregate is an aggregate operator that can only perform aggregates without any groups
-class PhysicalUngroupedAggregate : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNGROUPED_AGGREGATE;
-
-public:
-	PhysicalUngroupedAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                           idx_t estimated_cardinality);
-
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-	unique_ptr<DistinctAggregateData> distinct_data;
-	unique_ptr<DistinctAggregateCollectionInfo> distinct_collection_info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool SinkOrderDependent() const override;
-
-private:
-	//! Finalize the distinct aggregates
-	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
-	                                  GlobalSinkState &gstate) const;
-	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
-	//! Sink the distinct aggregates
-	void SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_window.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_window.hpp
deleted file mode 100644
index 5a485bca7..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_window.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-//! PhysicalWindow implements window functions
-//! It assumes that all functions have a common partitioning and ordering
-class PhysicalWindow : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::WINDOW;
-
-public:
-	PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
-	               PhysicalOperatorType type = PhysicalOperatorType::WINDOW);
-
-	//! The projection list of the WINDOW statement (may contain aggregates)
-	vector<unique_ptr<Expression>> select_list;
-	//! The window expression with the order clause
-	idx_t order_idx;
-	//! Whether or not the window is order dependent (only true if ANY window function contains neither an order nor a
-	//! partition clause)
-	bool is_order_dependent;
-
-public:
-	// Source interface
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-	OperatorPartitionData GetPartitionData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	                                       LocalSourceState &lstate,
-	                                       const OperatorPartitionInfo &partition_info) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-	bool SupportsPartitioning(const OperatorPartitionInfo &partition_info) const override;
-	OrderPreservationType SourceOrder() const override;
-
-	ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return !is_order_dependent;
-	}
-
-	bool SinkOrderDependent() const override {
-		return is_order_dependent;
-	}
-
-public:
-	idx_t MaxThreads(ClientContext &context);
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp b/src/duckdb/src/include/duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp
deleted file mode 100644
index cf1b13c55..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-
-namespace duckdb {
-struct DistinctAggregateData;
-struct LocalUngroupedAggregateState;
-
-struct UngroupedAggregateState {
-	explicit UngroupedAggregateState(const vector<unique_ptr<Expression>> &aggregate_expressions);
-	~UngroupedAggregateState();
-
-	void Move(UngroupedAggregateState &other);
-
-public:
-	//! Aggregates
-	const vector<unique_ptr<Expression>> &aggregate_expressions;
-	//! The aggregate values
-	vector<unsafe_unique_array<data_t>> aggregate_data;
-	//! The bind data
-	vector<optional_ptr<FunctionData>> bind_data;
-	//! The destructors
-	vector<aggregate_destructor_t> destructors;
-	//! Counts (used for verification)
-	unique_array<atomic<idx_t>> counts;
-};
-
-struct GlobalUngroupedAggregateState {
-public:
-	GlobalUngroupedAggregateState(Allocator &client_allocator, const vector<unique_ptr<Expression>> &aggregates)
-	    : client_allocator(client_allocator), allocator(client_allocator), state(aggregates) {
-	}
-
-	mutable mutex lock;
-	//! Client allocator
-	Allocator &client_allocator;
-	//! Global arena allocator
-	ArenaAllocator allocator;
-	//! Allocator pool
-	mutable vector<unique_ptr<ArenaAllocator>> stored_allocators;
-	//! The global aggregate state
-	UngroupedAggregateState state;
-
-public:
-	//! Create an ArenaAllocator with cross-thread lifetime
-	ArenaAllocator &CreateAllocator() const;
-	void Combine(LocalUngroupedAggregateState &other);
-	void CombineDistinct(LocalUngroupedAggregateState &other, DistinctAggregateData &distinct_data);
-	void Finalize(DataChunk &result, idx_t column_offset = 0);
-};
-
-struct LocalUngroupedAggregateState {
-public:
-	explicit LocalUngroupedAggregateState(GlobalUngroupedAggregateState &gstate);
-
-	//! Local arena allocator
-	ArenaAllocator &allocator;
-	//! The local aggregate state
-	UngroupedAggregateState state;
-
-public:
-	void Sink(DataChunk &payload_chunk, idx_t payload_idx, idx_t aggr_idx);
-};
-
-struct UngroupedAggregateExecuteState {
-public:
-	UngroupedAggregateExecuteState(ClientContext &context, const vector<unique_ptr<Expression>> &aggregates,
-	                               const vector<LogicalType> &child_types);
-
-	//! The set of aggregates
-	const vector<unique_ptr<Expression>> &aggregates;
-	//! The executor
-	ExpressionExecutor child_executor;
-	//! The payload chunk, containing all the Vectors for the aggregates
-	DataChunk aggregate_input_chunk;
-	//! Aggregate filter data set
-	AggregateFilterDataSet filter_set;
-
-public:
-	void Sink(LocalUngroupedAggregateState &state, DataChunk &input);
-	void Reset();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp
deleted file mode 100644
index 93b8bf9ac..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp
+++ /dev/null
@@ -1,359 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/base_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-class CSVFileScan;
-class ScannerResult {
-public:
-	ScannerResult(CSVStates &states, CSVStateMachine &state_machine, idx_t result_size);
-
-	static inline void SetQuoted(ScannerResult &result, idx_t quoted_position) {
-		if (!result.quoted) {
-			result.quoted_position = quoted_position;
-		}
-		result.quoted = true;
-		result.unquoted = true;
-	}
-
-	static inline void SetUnquoted(ScannerResult &result) {
-		if (result.states.states[0] == CSVState::UNQUOTED && result.states.states[1] == CSVState::UNQUOTED &&
-		    result.state_machine.dialect_options.state_machine_options.escape != '\0') {
-			// This means we touched an unescaped quote, we must go through the remove escape code to remove it.
-			result.escaped = true;
-		}
-		result.quoted = true;
-	}
-
-	static inline void SetEscaped(ScannerResult &result) {
-		result.escaped = true;
-	}
-	static inline void SetComment(ScannerResult &result, idx_t buffer_pos) {
-		result.comment = true;
-	}
-	static inline bool UnsetComment(ScannerResult &result, idx_t buffer_pos) {
-		result.comment = false;
-		return false;
-	}
-	static inline bool IsCommentSet(const ScannerResult &result) {
-		return result.comment == true;
-	}
-
-	//! Variable to keep information regarding quoted and escaped values
-	bool quoted = false;
-	//! If the current quoted value is unquoted
-	bool unquoted = false;
-	//! If the current value has been escaped
-	bool escaped = false;
-	//! Variable to keep track if we are in a comment row. Hence, won't add it
-	bool comment = false;
-	idx_t quoted_position = 0;
-
-	//! Size of the result
-	const idx_t result_size;
-
-	CSVStateMachine &state_machine;
-
-	void Print() const {
-		state_machine.Print();
-	}
-
-protected:
-	CSVStates &states;
-};
-
-//! This is the base of our CSV scanners.
-//! Scanners differ on what they are used for, and consequently have different performance benefits.
-class BaseScanner {
-public:
-	explicit BaseScanner(shared_ptr<CSVBufferManager> buffer_manager, shared_ptr<CSVStateMachine> state_machine,
-	                     shared_ptr<CSVErrorHandler> error_handler, bool sniffing = false,
-	                     shared_ptr<CSVFileScan> csv_file_scan = nullptr, CSVIterator iterator = {});
-
-	virtual ~BaseScanner() = default;
-
-	//! Returns true if the scanner is finished
-	bool FinishedFile() const;
-
-	//! Parses data into a output_chunk
-	virtual ScannerResult &ParseChunk();
-
-	//! Returns the result from the last Parse call. Shouts at you if you call it wrong
-	virtual ScannerResult &GetResult();
-
-	CSVIterator &GetIterator();
-
-	void SetIterator(const CSVIterator &it);
-
-	idx_t GetBoundaryIndex() const {
-		return iterator.GetBoundaryIdx();
-	}
-
-	idx_t GetLinesRead() const {
-		return lines_read;
-	}
-
-	CSVPosition GetIteratorPosition() const {
-		return iterator.pos;
-	}
-
-	CSVStateMachine &GetStateMachine() const;
-
-	shared_ptr<CSVFileScan> csv_file_scan;
-
-	//! If this scanner is being used for sniffing
-	bool sniffing = false;
-	//! The guy that handles errors
-	shared_ptr<CSVErrorHandler> error_handler;
-
-	//! Shared pointer to the state machine, this is used across multiple scanners
-	shared_ptr<CSVStateMachine> state_machine;
-
-	//! States
-	CSVStates states;
-
-	bool ever_quoted = false;
-
-	bool ever_escaped = false;
-
-	//! Shared pointer to the buffer_manager, this is shared across multiple scanners
-	shared_ptr<CSVBufferManager> buffer_manager;
-
-	//! Skips Notes and/or parts of the data, starting from the top.
-	//! notes are dirty lines on top of the file, before the actual data
-	static CSVIterator SkipCSVRows(shared_ptr<CSVBufferManager> buffer_manager,
-	                               const shared_ptr<CSVStateMachine> &state_machine, idx_t rows_to_skip);
-
-	inline static bool ContainsZeroByte(uint64_t v) {
-		return (v - UINT64_C(0x0101010101010101)) & ~(v)&UINT64_C(0x8080808080808080);
-	}
-
-protected:
-	//! Boundaries of this scanner
-	CSVIterator iterator;
-
-	//! Unique pointer to the buffer_handle, this is unique per scanner, since it also contains the necessary counters
-	//! To offload buffers to disk if necessary
-	shared_ptr<CSVBufferHandle> cur_buffer_handle;
-
-	//! Hold the current buffer ptr
-	char *buffer_handle_ptr = nullptr;
-
-	//! If this scanner has been initialized
-	bool initialized = false;
-	//! How many lines were read by this scanner
-	idx_t lines_read = 0;
-	idx_t bytes_read = 0;
-	//! Internal Functions used to perform the parsing
-	//! Initializes the scanner
-	virtual void Initialize();
-
-	//! Process one chunk
-	template <class T>
-	void Process(T &result) {
-		idx_t to_pos;
-		const bool has_escaped_value = state_machine->dialect_options.state_machine_options.escape != '\0';
-		const idx_t start_pos = iterator.pos.buffer_pos;
-		if (iterator.IsBoundarySet()) {
-			to_pos = iterator.GetEndPos();
-			if (to_pos > cur_buffer_handle->actual_size) {
-				to_pos = cur_buffer_handle->actual_size;
-			}
-		} else {
-			to_pos = cur_buffer_handle->actual_size;
-		}
-		while (iterator.pos.buffer_pos < to_pos) {
-			state_machine->Transition(states, buffer_handle_ptr[iterator.pos.buffer_pos]);
-			switch (states.states[1]) {
-			case CSVState::INVALID:
-				T::InvalidState(result);
-				iterator.pos.buffer_pos++;
-				bytes_read = iterator.pos.buffer_pos - start_pos;
-				return;
-			case CSVState::RECORD_SEPARATOR:
-				if (states.states[0] == CSVState::RECORD_SEPARATOR || states.states[0] == CSVState::NOT_SET) {
-					if (T::EmptyLine(result, iterator.pos.buffer_pos)) {
-						iterator.pos.buffer_pos++;
-						bytes_read = iterator.pos.buffer_pos - start_pos;
-						lines_read++;
-						return;
-					}
-					lines_read++;
-
-				} else if (states.states[0] != CSVState::CARRIAGE_RETURN) {
-					if (T::IsCommentSet(result)) {
-						if (T::UnsetComment(result, iterator.pos.buffer_pos)) {
-							iterator.pos.buffer_pos++;
-							bytes_read = iterator.pos.buffer_pos - start_pos;
-							lines_read++;
-							return;
-						}
-					} else {
-						if (T::AddRow(result, iterator.pos.buffer_pos)) {
-							iterator.pos.buffer_pos++;
-							bytes_read = iterator.pos.buffer_pos - start_pos;
-							lines_read++;
-							return;
-						}
-					}
-					lines_read++;
-				}
-				iterator.pos.buffer_pos++;
-				break;
-			case CSVState::CARRIAGE_RETURN:
-				if (states.states[0] == CSVState::RECORD_SEPARATOR || states.states[0] == CSVState::NOT_SET) {
-					if (T::EmptyLine(result, iterator.pos.buffer_pos)) {
-						iterator.pos.buffer_pos++;
-						bytes_read = iterator.pos.buffer_pos - start_pos;
-						lines_read++;
-						return;
-					}
-				} else if (states.states[0] != CSVState::CARRIAGE_RETURN) {
-					if (T::IsCommentSet(result)) {
-						if (T::UnsetComment(result, iterator.pos.buffer_pos)) {
-							iterator.pos.buffer_pos++;
-							bytes_read = iterator.pos.buffer_pos - start_pos;
-							lines_read++;
-							return;
-						}
-					} else {
-						if (T::AddRow(result, iterator.pos.buffer_pos)) {
-							iterator.pos.buffer_pos++;
-							bytes_read = iterator.pos.buffer_pos - start_pos;
-							lines_read++;
-							return;
-						}
-					}
-				}
-				iterator.pos.buffer_pos++;
-				lines_read++;
-				break;
-			case CSVState::DELIMITER:
-				T::AddValue(result, iterator.pos.buffer_pos);
-				iterator.pos.buffer_pos++;
-				break;
-			case CSVState::QUOTED: {
-				if ((states.states[0] == CSVState::UNQUOTED || states.states[0] == CSVState::MAYBE_QUOTED) &&
-				    has_escaped_value) {
-					T::SetEscaped(result);
-				}
-				ever_quoted = true;
-				T::SetQuoted(result, iterator.pos.buffer_pos);
-				iterator.pos.buffer_pos++;
-				while (iterator.pos.buffer_pos + 8 < to_pos) {
-					const uint64_t value =
-					    Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[iterator.pos.buffer_pos]));
-					if (ContainsZeroByte((value ^ state_machine->transition_array.quote) &
-					                     (value ^ state_machine->transition_array.escape))) {
-						break;
-					}
-					iterator.pos.buffer_pos += 8;
-				}
-
-				while (state_machine->transition_array
-				           .skip_quoted[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
-				       iterator.pos.buffer_pos < to_pos - 1) {
-					iterator.pos.buffer_pos++;
-				}
-			} break;
-			case CSVState::UNQUOTED: {
-				if (states.states[0] == CSVState::MAYBE_QUOTED) {
-					T::SetEscaped(result);
-				}
-				T::SetUnquoted(result);
-				iterator.pos.buffer_pos++;
-				break;
-			}
-			case CSVState::ESCAPE:
-			case CSVState::UNQUOTED_ESCAPE:
-			case CSVState::ESCAPED_RETURN:
-				T::SetEscaped(result);
-				ever_escaped = true;
-				iterator.pos.buffer_pos++;
-				break;
-			case CSVState::STANDARD: {
-				iterator.pos.buffer_pos++;
-				while (iterator.pos.buffer_pos + 8 < to_pos) {
-					uint64_t value =
-					    Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[iterator.pos.buffer_pos]));
-					if (ContainsZeroByte((value ^ state_machine->transition_array.delimiter) &
-					                     (value ^ state_machine->transition_array.new_line) &
-					                     (value ^ state_machine->transition_array.carriage_return) &
-					                     (value ^ state_machine->transition_array.escape) &
-					                     (value ^ state_machine->transition_array.comment))) {
-						break;
-					}
-					iterator.pos.buffer_pos += 8;
-				}
-				while (state_machine->transition_array
-				           .skip_standard[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
-				       iterator.pos.buffer_pos < to_pos - 1) {
-					iterator.pos.buffer_pos++;
-				}
-				break;
-			}
-			case CSVState::QUOTED_NEW_LINE:
-				T::QuotedNewLine(result);
-				iterator.pos.buffer_pos++;
-				break;
-			case CSVState::COMMENT: {
-				T::SetComment(result, iterator.pos.buffer_pos);
-				iterator.pos.buffer_pos++;
-				while (iterator.pos.buffer_pos + 8 < to_pos) {
-					const uint64_t value =
-					    Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[iterator.pos.buffer_pos]));
-					if (ContainsZeroByte((value ^ state_machine->transition_array.new_line) &
-					                     (value ^ state_machine->transition_array.carriage_return))) {
-						break;
-					}
-					iterator.pos.buffer_pos += 8;
-				}
-				while (state_machine->transition_array
-				           .skip_comment[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
-				       iterator.pos.buffer_pos < to_pos - 1) {
-					iterator.pos.buffer_pos++;
-				}
-				break;
-			}
-			default:
-				iterator.pos.buffer_pos++;
-				break;
-			}
-		}
-		bytes_read = iterator.pos.buffer_pos - start_pos;
-	}
-
-	//! Finalizes the process of the chunk
-	virtual void FinalizeChunkProcess();
-
-	//! Internal function for parse chunk
-	template <class T>
-	void ParseChunkInternal(T &result) {
-		if (iterator.done) {
-			return;
-		}
-		if (!initialized) {
-			Initialize();
-			initialized = true;
-		}
-		if (!iterator.done && cur_buffer_handle) {
-			Process(result);
-		}
-		FinalizeChunkProcess();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp
deleted file mode 100644
index 8cecfe500..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/column_count_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-
-namespace duckdb {
-
-//! Result of a sniffed tuples using the column count scanner
-struct ColumnCount {
-	//! Number of columns found in a row
-	idx_t number_of_columns = 0;
-	//! If all values from this row onwards are null
-	bool last_value_always_empty = true;
-	//! If this row is potentially a comment
-	bool is_comment = false;
-	//! If this row is potentially a mid-line comment
-	bool is_mid_comment = false;
-};
-
-class ColumnCountResult : public ScannerResult {
-public:
-	ColumnCountResult(CSVStates &states, CSVStateMachine &state_machine, idx_t result_size);
-	inline ColumnCount &operator[](size_t index) {
-		return column_counts[index];
-	}
-
-	vector<ColumnCount> column_counts;
-	idx_t current_column_count = 0;
-	bool error = false;
-	idx_t result_position = 0;
-	bool cur_line_starts_as_comment = false;
-	//! How many rows fit a given column count
-	map<idx_t, idx_t> rows_per_column_count;
-	//! Adds a Value to the result
-	static inline void AddValue(ColumnCountResult &result, idx_t buffer_pos);
-	//! Adds a Row to the result
-	static inline bool AddRow(ColumnCountResult &result, idx_t buffer_pos);
-	//! Behavior when hitting an invalid state
-	static inline void InvalidState(ColumnCountResult &result);
-	//! Handles QuotedNewline State
-	static inline void QuotedNewLine(ColumnCountResult &result);
-	//! Handles EmptyLine states
-	static inline bool EmptyLine(ColumnCountResult &result, idx_t buffer_pos);
-	//! Handles unset comment
-	static inline bool UnsetComment(ColumnCountResult &result, idx_t buffer_pos);
-
-	static inline void SetComment(ColumnCountResult &result, idx_t buffer_pos);
-
-	//! Returns the column count
-	idx_t GetMostFrequentColumnCount() const;
-
-	inline void InternalAddRow();
-};
-
-//! Scanner that goes over the CSV and figures out how many columns each row has. Used for dialect sniffing
-class ColumnCountScanner : public BaseScanner {
-public:
-	ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
-	                   shared_ptr<CSVErrorHandler> error_handler, idx_t result_size = STANDARD_VECTOR_SIZE,
-	                   CSVIterator iterator = {});
-
-	ColumnCountResult &ParseChunk() override;
-
-	ColumnCountResult &GetResult() override;
-
-	unique_ptr<StringValueScanner> UpgradeToStringValueScanner();
-
-private:
-	void Initialize() override;
-
-	void FinalizeChunkProcess() override;
-
-	ColumnCountResult result;
-
-	idx_t column_count;
-	idx_t result_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp
deleted file mode 100644
index 99ce3c5ba..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-
-namespace duckdb {
-
-class CSVBufferHandle {
-public:
-	CSVBufferHandle(BufferHandle handle_p, idx_t actual_size_p, idx_t requested_size_p, const bool is_final_buffer_p,
-	                idx_t file_idx_p, idx_t buffer_index_p)
-	    : handle(std::move(handle_p)), actual_size(actual_size_p), requested_size(requested_size_p),
-	      is_last_buffer(is_final_buffer_p), file_idx(file_idx_p), buffer_idx(buffer_index_p) {};
-	CSVBufferHandle() : actual_size(0), requested_size(0), is_last_buffer(false), file_idx(0), buffer_idx(0) {};
-	~CSVBufferHandle() {
-	}
-	//! Handle created during allocation
-	BufferHandle handle;
-	const idx_t actual_size;
-	const idx_t requested_size;
-	const bool is_last_buffer;
-	const idx_t file_idx;
-	const idx_t buffer_idx;
-	inline char *Ptr() {
-		return char_ptr_cast(handle.Ptr());
-	}
-};
-
-//! CSV Buffers are parts of a decompressed CSV File.
-//! For a decompressed file of 100Mb. With our Buffer size set to 32Mb, we would generate 4 buffers.
-//! One for the first 32Mb, second and third for the other 32Mb, and the last one with 4 Mb
-//! These buffers are actually used for sniffing and parsing!
-class CSVBuffer {
-public:
-	//! Constructor for Initial Buffer
-	CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
-	          idx_t &global_csv_current_position, idx_t file_number);
-
-	//! Constructor for `Next()` Buffers
-	CSVBuffer(CSVFileHandle &file_handle, ClientContext &context, idx_t buffer_size, idx_t global_csv_current_position,
-	          idx_t file_number_p, idx_t buffer_idx);
-
-	//! Creates a new buffer with the next part of the CSV File
-	shared_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number, bool &has_seaked);
-
-	//! Gets the buffer actual size
-	idx_t GetBufferSize() const;
-
-	//! If this buffer is the last buffer of the CSV File
-	bool IsCSVFileLastBuffer() const;
-
-	//! Allocates internal buffer, sets 'block' and 'handle' variables.
-	void AllocateBuffer(idx_t buffer_size);
-
-	void Reload(CSVFileHandle &file_handle);
-	//! Wrapper for the Pin Function, if it can seek, it means that the buffer might have been destroyed, hence we must
-	//! Scan it from the disk file again.
-	shared_ptr<CSVBufferHandle> Pin(CSVFileHandle &file_handle, bool &has_seeked);
-	//! Wrapper for the unpin
-	void Unpin();
-	char *Ptr() {
-		return char_ptr_cast(handle.Ptr());
-	}
-	bool IsUnloaded() {
-		return block->IsUnloaded();
-	}
-
-	//! By default, we use CSV_BUFFER_SIZE to allocate each buffer
-	static constexpr idx_t ROWS_PER_BUFFER = 16;
-	static constexpr idx_t MIN_ROWS_PER_BUFFER = 4;
-
-	bool last_buffer = false;
-
-private:
-	ClientContext &context;
-	//! Actual size can be smaller than the buffer size in case we allocate it too optimistically.
-	idx_t actual_buffer_size;
-	idx_t requested_size;
-	//! Global position from the CSV File where this buffer starts
-	idx_t global_csv_start = 0;
-	//! Number of the file that is in this buffer
-	idx_t file_number = 0;
-	//! If we can seek in the file or not.
-	bool can_seek;
-	//! If this file is being fed by a pipe.
-	bool is_pipe;
-	//! Buffer Index, used as a batch index for insertion-order preservation
-	idx_t buffer_idx = 0;
-	//! -------- Allocated Block ---------//
-	//! Block created in allocation
-	shared_ptr<BlockHandle> block;
-	BufferHandle handle;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp
deleted file mode 100644
index 6c9674229..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-
-namespace duckdb {
-class CSVBuffer;
-class CSVStateMachine;
-
-//! This class is used to manage the CSV buffers.  Buffers are cached when used for auto detection.
-//! When parsing, buffer are not cached and just returned.
-//! A CSV Buffer Manager is created for each separate CSV File.
-class CSVBufferManager {
-public:
-	CSVBufferManager(ClientContext &context, const CSVReaderOptions &options, const string &file_path,
-	                 const idx_t file_idx, bool per_file_single_threaded = false,
-	                 unique_ptr<CSVFileHandle> file_handle = nullptr);
-
-	//! Returns a buffer from a buffer id (starting from 0). If it's in the auto-detection then we cache new buffers
-	//! Otherwise we remove them from the cache if they are already there, or just return them bypassing the cache.
-	shared_ptr<CSVBufferHandle> GetBuffer(const idx_t buffer_idx);
-
-	void ResetBuffer(const idx_t buffer_idx);
-	//! unique_ptr to the file handle, gets stolen after sniffing
-	unique_ptr<CSVFileHandle> file_handle;
-	//! Initializes the buffer manager, during it's construction/reset
-	void Initialize();
-
-	void UnpinBuffer(const idx_t cache_idx);
-	//! Returns the buffer size set for this CSV buffer manager
-	idx_t GetBufferSize() const;
-	//! Returns the number of buffers in the cached_buffers cache
-	idx_t BufferCount() const;
-	//! If this buffer manager is done. In the context of a buffer manager it means that it read all buffers at least
-	//! once.
-	bool Done() const;
-
-	void ResetBufferManager();
-	string GetFilePath() const;
-
-	bool IsBlockUnloaded(idx_t block_idx);
-
-	idx_t GetBytesRead() const;
-
-	ClientContext &context;
-	idx_t skip_rows = 0;
-	bool sniffing = false;
-	const bool per_file_single_threaded;
-
-private:
-	//! Reads next buffer in reference to cached_buffers.front()
-	bool ReadNextAndCacheIt();
-	//! The file index this Buffer Manager refers to
-	const idx_t file_idx;
-	//! The file path this Buffer Manager refers to
-	const string file_path;
-	//! The cached buffers
-	vector<shared_ptr<CSVBuffer>> cached_buffers;
-	//! The last buffer it was accessed
-	shared_ptr<CSVBuffer> last_buffer;
-	idx_t global_csv_pos = 0;
-	//! The size of the buffer, if the csv file has a smaller size than this, we will use that instead to malloc less
-	idx_t buffer_size;
-	//! If this buffer manager is done (i.e., no more buffers to read beyond the ones that were cached
-	bool done = false;
-	idx_t bytes_read = 0;
-	//! Because the buffer manager can be accessed in Parallel we need a mutex.
-	mutex main_mutex;
-	//! If the file_handle used seek
-	bool has_seeked = false;
-	unordered_set<idx_t> reset_when_possible;
-	bool is_pipe;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_casting.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_casting.hpp
deleted file mode 100644
index cf921edc3..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_casting.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_casting.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-
-namespace duckdb {
-class CSVCast {
-	template <class OP, class T>
-	static bool TemplatedTryCastFloatingVector(const CSVReaderOptions &options, Vector &input_vector,
-	                                           Vector &result_vector, idx_t count, CastParameters &parameters,
-	                                           idx_t &line_error) {
-		D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-		bool all_converted = true;
-		idx_t row = 0;
-		UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-			T result;
-			if (!OP::Operation(input, result, parameters)) {
-				line_error = row;
-				all_converted = false;
-			} else {
-				row++;
-			}
-			return result;
-		});
-		return all_converted;
-	}
-
-	template <class OP, class T>
-	static bool TemplatedTryCastDecimalVector(const CSVReaderOptions &options, Vector &input_vector,
-	                                          Vector &result_vector, idx_t count, CastParameters &parameters,
-	                                          uint8_t width, uint8_t scale, idx_t &line_error) {
-		D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-		bool all_converted = true;
-		auto &validity_mask = FlatVector::Validity(result_vector);
-		idx_t cur_line = 0;
-		UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-			T result;
-			if (!OP::Operation(input, result, parameters, width, scale)) {
-				if (all_converted) {
-					line_error = cur_line;
-				}
-				validity_mask.SetInvalid(cur_line);
-				all_converted = false;
-				cur_line++;
-			} else {
-				cur_line++;
-			}
-			return result;
-		});
-		return all_converted;
-	}
-
-	struct TryCastDateOperator {
-		static bool Operation(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options, string_t input,
-		                      date_t &result, string &error_message) {
-			return options.at(LogicalTypeId::DATE).GetValue().TryParseDate(input, result, error_message);
-		}
-	};
-
-	struct TryCastTimestampOperator {
-		static bool Operation(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options, string_t input,
-		                      timestamp_t &result, string &error_message) {
-			return options.at(LogicalTypeId::TIMESTAMP).GetValue().TryParseTimestamp(input, result, error_message);
-		}
-	};
-
-	template <class OP, class T>
-	static bool TemplatedTryCastDateVector(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options,
-	                                       Vector &input_vector, Vector &result_vector, idx_t count,
-	                                       CastParameters &parameters, idx_t &line_error, bool nullify_error) {
-		D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-		bool all_converted = true;
-		idx_t cur_line = 0;
-		auto &validity_mask = FlatVector::Validity(result_vector);
-		UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-			T result;
-			if (!OP::Operation(options, input, result, *parameters.error_message)) {
-				if (all_converted) {
-					line_error = cur_line;
-				}
-				if (nullify_error) {
-					validity_mask.SetInvalid(cur_line);
-				}
-				all_converted = false;
-			}
-			cur_line++;
-			return result;
-		});
-		return all_converted;
-	}
-
-public:
-	static bool TryCastDateVector(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options, Vector &input_vector,
-	                              Vector &result_vector, idx_t count, CastParameters &parameters, idx_t &line_error,
-	                              bool nullify_error = false) {
-		return TemplatedTryCastDateVector<TryCastDateOperator, date_t>(options, input_vector, result_vector, count,
-		                                                               parameters, line_error, nullify_error);
-	}
-	static bool TryCastTimestampVector(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options,
-	                                   Vector &input_vector, Vector &result_vector, idx_t count,
-	                                   CastParameters &parameters, bool nullify_error = false) {
-		idx_t line_error;
-		return TemplatedTryCastDateVector<TryCastTimestampOperator, timestamp_t>(
-		    options, input_vector, result_vector, count, parameters, line_error, nullify_error);
-	}
-	static bool TryCastFloatingVectorCommaSeparated(const CSVReaderOptions &options, Vector &input_vector,
-	                                                Vector &result_vector, idx_t count, CastParameters &parameters,
-	                                                const LogicalType &result_type, idx_t &line_error) {
-		switch (result_type.InternalType()) {
-		case PhysicalType::DOUBLE:
-			return TemplatedTryCastFloatingVector<TryCastErrorMessageCommaSeparated, double>(
-			    options, input_vector, result_vector, count, parameters, line_error);
-		case PhysicalType::FLOAT:
-			return TemplatedTryCastFloatingVector<TryCastErrorMessageCommaSeparated, float>(
-			    options, input_vector, result_vector, count, parameters, line_error);
-		default:
-			throw InternalException("Unimplemented physical type for floating");
-		}
-	}
-
-	static bool TryCastDecimalVectorCommaSeparated(const CSVReaderOptions &options, Vector &input_vector,
-	                                               Vector &result_vector, idx_t count, CastParameters &parameters,
-	                                               const LogicalType &result_type, idx_t &line_error) {
-		auto width = DecimalType::GetWidth(result_type);
-		auto scale = DecimalType::GetScale(result_type);
-		switch (result_type.InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, int16_t>(
-			    options, input_vector, result_vector, count, parameters, width, scale, line_error);
-		case PhysicalType::INT32:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, int32_t>(
-			    options, input_vector, result_vector, count, parameters, width, scale, line_error);
-		case PhysicalType::INT64:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, int64_t>(
-			    options, input_vector, result_vector, count, parameters, width, scale, line_error);
-		case PhysicalType::INT128:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, hugeint_t>(
-			    options, input_vector, result_vector, count, parameters, width, scale, line_error);
-		default:
-			throw InternalException("Unimplemented physical type for decimal");
-		}
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp
deleted file mode 100644
index a31fd6190..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_error.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/header_value.hpp"
-
-namespace duckdb {
-class InternalAppender;
-class CSVFileScan;
-class CSVRejectsTable;
-struct ReadCSVData;
-
-//! Object that holds information on how many lines each csv batch read.
-class LinesPerBoundary {
-public:
-	LinesPerBoundary();
-	LinesPerBoundary(idx_t boundary_idx, idx_t lines_in_batch);
-
-	idx_t boundary_idx = 0;
-	idx_t lines_in_batch = 0;
-};
-
-enum CSVErrorType : uint8_t {
-	CAST_ERROR = 0,                //! If when casting a value from string to the column type fails
-	COLUMN_NAME_TYPE_MISMATCH = 1, //! If there is a mismatch between Column Names and Types
-	TOO_FEW_COLUMNS = 2,           //! If the CSV has too few columns
-	TOO_MANY_COLUMNS = 3,          //! If the CSV has too many  column
-	UNTERMINATED_QUOTES = 4,       //! If a quote is not terminated
-	SNIFFING = 5,          //! If something went wrong during sniffing and was not possible to find suitable candidates
-	MAXIMUM_LINE_SIZE = 6, //! Maximum line size was exceeded by a line in the CSV File
-	NULLPADDED_QUOTED_NEW_VALUE = 7, //! If the null_padding option is set, and we have quoted new values in parallel
-	INVALID_UNICODE = 8,             //! If we have invalid unicode values
-	INVALID_STATE = 9                //! If our CSV Scanner ended up in an invalid state
-};
-
-class CSVError {
-public:
-	CSVError() {};
-	CSVError(string error_message, CSVErrorType type, idx_t column_idx, string csv_row, LinesPerBoundary error_info,
-	         idx_t row_byte_position, optional_idx byte_position, const CSVReaderOptions &reader_options,
-	         const string &fixes, const string &current_path);
-	CSVError(string error_message, CSVErrorType type, LinesPerBoundary error_info);
-	//! Produces error messages for column name -> type mismatch.
-	static CSVError ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names);
-	//! Produces error messages for casting errors
-	static CSVError CastError(const CSVReaderOptions &options, string &column_name, string &cast_error,
-	                          idx_t column_idx, string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position,
-	                          optional_idx byte_position, LogicalTypeId type, const string &current_path);
-	//! Produces error for when the line size exceeds the maximum line size option
-	static CSVError LineSizeError(const CSVReaderOptions &options, LinesPerBoundary error_info, string &csv_row,
-	                              idx_t byte_position, const string &current_path);
-	//! Produces error for when the state machine reaches an invalid state
-	static CSVError InvalidState(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
-	                             string &csv_row, idx_t row_byte_position, optional_idx byte_position,
-	                             const string &current_path);
-	//! Produces an error message for a dialect sniffing error.
-	static CSVError SniffingError(const CSVReaderOptions &options, const string &search_space);
-	//! Produces an error message for a header sniffing error.
-	static CSVError HeaderSniffingError(const CSVReaderOptions &options, const vector<HeaderValue> &best_header_row,
-	                                    idx_t column_count, const string &delimiter);
-	//! Produces error messages for unterminated quoted values
-	static CSVError UnterminatedQuotesError(const CSVReaderOptions &options, idx_t current_column,
-	                                        LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-	                                        optional_idx byte_position, const string &current_path);
-	//! Produces error messages for null_padding option is set, and we have quoted new values in parallel
-	static CSVError NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info,
-	                                const string &current_path);
-	//! Produces error for incorrect (e.g., smaller and lower than the predefined) number of columns in a CSV Line
-	static CSVError IncorrectColumnAmountError(const CSVReaderOptions &state_machine, idx_t actual_columns,
-	                                           LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-	                                           optional_idx byte_position, const string &current_path);
-	static CSVError InvalidUTF8(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
-	                            string &csv_row, idx_t row_byte_position, optional_idx byte_position,
-	                            const string &current_path);
-
-	idx_t GetBoundaryIndex() const {
-		return error_info.boundary_idx;
-	}
-
-	//! We might want to remove newline in errors if we are doing them for the rejects tables
-	static void RemoveNewLine(string &error);
-
-	//! Actual error message
-	string error_message;
-	//! Full error message used in throws
-	//! 1. The Actual error
-	//! 2. How to fix it
-	//! 3. Options that generated the error
-	string full_error_message;
-	//! Error Type
-	CSVErrorType type {};
-	//! Column Index where error happened
-	idx_t column_idx {};
-	//! Original CSV row where error happened
-	string csv_row;
-	//! Line information regarding this error
-	LinesPerBoundary error_info;
-	//! Byte position of where the row starts
-	idx_t row_byte_position {};
-	//! Byte Position where error occurred.
-	optional_idx byte_position;
-};
-
-class CSVErrorHandler {
-public:
-	explicit CSVErrorHandler(bool ignore_errors = false);
-	//! Throws the error
-	void Error(const CSVError &csv_error, bool force_error = false);
-	//! If we have a cached error, and we can now error, we error.
-	void ErrorIfNeeded();
-	//! Throws an error if a given type exists
-	void ErrorIfTypeExists(CSVErrorType error_type);
-	//! Inserts a finished error info
-	void Insert(idx_t boundary_idx, idx_t rows);
-	idx_t GetLine(const LinesPerBoundary &error_info);
-	void NewMaxLineSize(idx_t scan_line_size);
-	//! Returns true if there are any errors
-	bool AnyErrors();
-	bool HasError(CSVErrorType error_type);
-	idx_t GetMaxLineLength();
-
-	void DontPrintErrorLine();
-
-	void SetIgnoreErrors(bool ignore_errors);
-	idx_t GetSize();
-
-	void FillRejectsTable(InternalAppender &errors_appender, idx_t file_idx, idx_t scan_idx, const CSVFileScan &file,
-	                      CSVRejectsTable &rejects, const ReadCSVData &bind_data, idx_t limit);
-
-private:
-	//! Private methods should always be locked by parent method.
-	//! If we should print the line of an error
-	bool PrintLineNumber(const CSVError &error) const;
-	//! Method that actually throws the error
-	void ThrowError(const CSVError &csv_error);
-	//! If we processed all boundaries before the one that error-ed
-	bool CanGetLine(idx_t boundary_index);
-	//! Return the 1-indexed line number
-	idx_t GetLineInternal(const LinesPerBoundary &error_info);
-	//! CSV Error Handler Mutex
-	mutex main_mutex;
-	//! Map of <boundary indexes> -> lines read
-	unordered_map<idx_t, LinesPerBoundary> lines_per_batch_map;
-	idx_t max_line_length = 0;
-	bool ignore_errors = false;
-	bool print_line = true;
-	//! Set of errors
-	vector<CSVError> errors;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_handle.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_handle.hpp
deleted file mode 100644
index c124bf092..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_handle.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_file_handle.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp"
-namespace duckdb {
-class Allocator;
-class FileSystem;
-struct CSVReaderOptions;
-
-class CSVFileHandle {
-public:
-	CSVFileHandle(DBConfig &config, unique_ptr<FileHandle> file_handle_p, const string &path_p,
-	              const CSVReaderOptions &options);
-
-	mutex main_mutex;
-
-	bool CanSeek() const;
-	void Seek(idx_t position) const;
-	bool OnDiskFile() const;
-	bool IsPipe() const;
-
-	void Reset();
-
-	idx_t FileSize() const;
-
-	bool FinishedReading() const;
-
-	idx_t Read(void *buffer, idx_t nr_bytes);
-
-	string ReadLine();
-
-	string GetFilePath();
-
-	static unique_ptr<FileHandle> OpenFileHandle(FileSystem &fs, Allocator &allocator, const string &path,
-	                                             FileCompressionType compression);
-	static unique_ptr<CSVFileHandle> OpenFile(DBConfig &config, FileSystem &fs, Allocator &allocator,
-	                                          const string &path, const CSVReaderOptions &options);
-	FileCompressionType compression_type;
-
-	double GetProgress() const;
-
-private:
-	unique_ptr<FileHandle> file_handle;
-	CSVEncoder encoder;
-	string path;
-	bool can_seek = false;
-	bool on_disk_file = false;
-	bool is_pipe = false;
-	idx_t uncompressed_bytes_read = 0;
-
-	idx_t file_size = 0;
-
-	idx_t requested_bytes = 0;
-	//! If we finished reading the file
-	bool finished = false;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp
deleted file mode 100644
index 3ebc88ff3..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_schema.hpp"
-
-namespace duckdb {
-struct ReadCSVData;
-class CSVFileScan;
-
-struct CSVUnionData {
-	~CSVUnionData();
-
-	string file_name;
-	vector<string> names;
-	vector<LogicalType> types;
-	CSVReaderOptions options;
-	unique_ptr<CSVFileScan> reader;
-
-	const string &GetFileName() {
-		return file_name;
-	}
-};
-
-//! Struct holding information over a CSV File we will scan
-class CSVFileScan {
-public:
-	using UNION_READER_DATA = unique_ptr<CSVUnionData>;
-
-public:
-	//! Constructor for when a CSV File Scan is being constructed over information acquired during sniffing
-	//! This means the options are alreadu set, and the buffer manager is already up and runinng.
-	CSVFileScan(ClientContext &context, shared_ptr<CSVBufferManager> buffer_manager,
-	            shared_ptr<CSVStateMachine> state_machine, const CSVReaderOptions &options,
-	            const ReadCSVData &bind_data, const vector<ColumnIndex> &column_ids, CSVSchema &file_schema);
-	//! Constructor for new CSV Files, we must initialize the buffer manager and the state machine
-	//! Path to this file
-	CSVFileScan(ClientContext &context, const string &file_path, const CSVReaderOptions &options, idx_t file_idx,
-	            const ReadCSVData &bind_data, const vector<ColumnIndex> &column_ids, CSVSchema &file_schema,
-	            bool per_file_single_threaded);
-
-	CSVFileScan(ClientContext &context, const string &file_name, const CSVReaderOptions &options);
-
-	void SetStart();
-	const string &GetFileName() const;
-	const vector<string> &GetNames();
-	const vector<LogicalType> &GetTypes();
-	void InitializeProjection();
-	void Finish();
-
-	static unique_ptr<CSVUnionData> StoreUnionReader(unique_ptr<CSVFileScan> scan_p, idx_t file_idx) {
-		auto data = make_uniq<CSVUnionData>();
-		if (file_idx == 0) {
-			data->file_name = scan_p->file_path;
-			data->options = scan_p->options;
-			data->names = scan_p->names;
-			data->types = scan_p->types;
-			data->reader = std::move(scan_p);
-		} else {
-			data->file_name = scan_p->file_path;
-			data->options = std::move(scan_p->options);
-			data->names = std::move(scan_p->names);
-			data->types = std::move(scan_p->types);
-		}
-		data->options.auto_detect = false;
-		return data;
-	}
-
-	//! Initialize the actual names and types to be scanned from the file
-	void InitializeFileNamesTypes();
-
-public:
-	const string file_path;
-	//! File Index
-	idx_t file_idx;
-	//! Buffer Manager for the CSV File
-	shared_ptr<CSVBufferManager> buffer_manager;
-	//! State Machine for this file
-	shared_ptr<CSVStateMachine> state_machine;
-	//! How many bytes were read up to this point
-	atomic<idx_t> bytes_read {0};
-	//! Size of this file
-	idx_t file_size;
-	//! Line Info used in error messages
-	shared_ptr<CSVErrorHandler> error_handler;
-	//! Whether or not this is an on-disk file
-	bool on_disk_file = true;
-
-	vector<string> names;
-	vector<LogicalType> types;
-	MultiFileReaderData reader_data;
-
-	vector<LogicalType> file_types;
-
-	//! Variables to handle projection pushdown
-	set<idx_t> projected_columns;
-	std::vector<std::pair<idx_t, idx_t>> projection_ids;
-
-	//! Options for this CSV Reader
-	CSVReaderOptions options;
-
-	CSVIterator start_iterator;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_option.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_option.hpp
deleted file mode 100644
index 90ef7943f..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_option.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_option.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/scalar/strftime_format.hpp"
-
-namespace duckdb {
-
-enum class NewLineIdentifier : uint8_t {
-	SINGLE_N = 1, // \n
-	CARRY_ON = 2, // \r\n
-	NOT_SET = 3,
-	SINGLE_R = 4 // \r
-
-};
-
-class Serializer;
-class Deserializer;
-
-//! Wrapper for CSV Options that can be manually set by the user
-//! It is important to make this difference for options that can be automatically sniffed AND manually set.
-template <typename T>
-struct CSVOption { // NOLINT: work-around bug in clang-tidy
-public:
-	CSVOption(T value_p) : value(value_p) { // NOLINT: allow implicit conversion from value
-	}
-	CSVOption(T value_p, bool set_by_user_p) : value(value_p), set_by_user(set_by_user_p) {
-	}
-
-	CSVOption() {};
-
-	//! Sets value.
-	//! If by user it also toggles the set_by user flag
-	void Set(T value_p, bool by_user = true) {
-		D_ASSERT(!(by_user && set_by_user));
-		if (!set_by_user) {
-			// If it's not set by user we can change the value
-			value = value_p;
-			set_by_user = by_user;
-		}
-	}
-
-	//! Sets value.
-	//! If by user it also toggles the set_by user flag
-	void Set(CSVOption value_p, bool by_user = true) {
-		D_ASSERT(!(by_user && set_by_user));
-		if (!set_by_user) {
-			// If it's not set by user we can change the value
-			value = value_p;
-			set_by_user = by_user;
-		}
-	}
-
-	// this is due to a hacky implementation in the read csv relation
-	void ChangeSetByUserTrue() {
-		set_by_user = true;
-	}
-
-	bool operator==(const CSVOption &other) const {
-		return value == other.value;
-	}
-
-	bool operator!=(const CSVOption &other) const {
-		return value != other.value;
-	}
-
-	bool operator==(const T &other) const {
-		return value == other;
-	}
-
-	bool operator!=(const T &other) const {
-		return value != other;
-	}
-	//! Returns CSV Option value
-	inline const T &GetValue() const {
-		return value;
-	}
-	bool IsSetByUser() const {
-		return set_by_user;
-	}
-
-	//! Returns a formatted string with information regarding how this option was set
-	string FormatSet() const {
-		if (set_by_user) {
-			return "(Set By User)";
-		}
-		return "(Auto-Detected)";
-	}
-
-	//! Returns a formatted string with the actual value of this option
-	string FormatValue() const {
-		return FormatValueInternal(value);
-	}
-
-	//! Serializes CSV Option
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-
-	//! Deserializes CSV Option
-	DUCKDB_API static CSVOption<T> Deserialize(Deserializer &deserializer);
-
-private:
-	//! If this option was manually set by the user
-	bool set_by_user = false;
-	T value;
-
-	//! --------------------------------------------------- //
-	//! Functions used to convert a value to a string
-	//! --------------------------------------------------- //
-
-	template <typename U>
-	std::string FormatValueInternal(const U &val) const {
-		throw InternalException("Type not accepted as CSV Option.");
-	}
-
-	std::string FormatValueInternal(const std::string &val) const {
-		return val;
-	}
-
-	std::string FormatValueInternal(const idx_t &val) const {
-		return to_string(val);
-	}
-
-	std::string FormatValueInternal(const char &val) const {
-		string char_val;
-		char_val += val;
-		return char_val;
-	}
-
-	std::string FormatValueInternal(const NewLineIdentifier &val) const {
-		switch (val) {
-		case NewLineIdentifier::SINGLE_N:
-			return "\\n";
-		case NewLineIdentifier::SINGLE_R:
-			return "\\r";
-		case NewLineIdentifier::CARRY_ON:
-			return "\\r\\n";
-		case NewLineIdentifier::NOT_SET:
-			return "Single-Line File";
-		default:
-			throw InternalException("Invalid Newline Detected.");
-		}
-	}
-
-	std::string FormatValueInternal(const StrpTimeFormat &val) const {
-		return val.format_specifier;
-	}
-
-	std::string FormatValueInternal(const bool &val) const {
-		if (val) {
-			return "true";
-		}
-		return "false";
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp
deleted file mode 100644
index 4e0ee86fd..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp
+++ /dev/null
@@ -1,207 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_reader_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
-#include "duckdb/execution/operator/csv_scanner/state_machine_options.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
-
-namespace duckdb {
-
-struct DialectOptions {
-	CSVStateMachineOptions state_machine_options;
-	//! Expected number of columns
-	idx_t num_cols = 0;
-	//! Whether the file has a header line
-	CSVOption<bool> header = false;
-	//! The date format to use (if any is specified)
-	map<LogicalTypeId, CSVOption<StrpTimeFormat>> date_format = {{LogicalTypeId::DATE, {}},
-	                                                             {LogicalTypeId::TIMESTAMP, {}}};
-	//! How many leading rows to skip
-	CSVOption<idx_t> skip_rows = 0;
-	idx_t rows_until_header = 0;
-};
-
-struct CSVReaderOptions {
-	CSVReaderOptions() {};
-	CSVReaderOptions(CSVOption<char> single_byte_delimiter, const CSVOption<string> &multi_byte_delimiter);
-	//===--------------------------------------------------------------------===//
-	// CommonCSVOptions
-	//===--------------------------------------------------------------------===//
-	//! See struct above.
-	DialectOptions dialect_options;
-	//! Whether we should ignore InvalidInput errors
-	CSVOption<bool> ignore_errors = false;
-	//! Whether we store CSV Errors in the rejects table or not
-	CSVOption<bool> store_rejects = false;
-	//! Rejects table name (Name of the table the store rejects errors)
-	CSVOption<string> rejects_table_name = {"reject_errors"};
-	//! Rejects Scan name  (Name of the table the store rejects scans)
-	CSVOption<string> rejects_scan_name = {"reject_scans"};
-	//! Rejects table entry limit (0 = no limit)
-	idx_t rejects_limit = 0;
-	//! Number of samples to buffer
-	idx_t buffer_sample_size = static_cast<idx_t>(STANDARD_VECTOR_SIZE * 50);
-	//! Specifies the strings that represents a null value
-	vector<string> null_str = {""};
-	//! Whether file is compressed or not, and if so which compression type
-	//! AUTO_DETECT (default; infer from file extension)
-	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
-	//! Option to convert quoted values to NULL values
-	bool allow_quoted_nulls = true;
-	char comment = '\0';
-
-	//===--------------------------------------------------------------------===//
-	// CSVAutoOptions
-	//===--------------------------------------------------------------------===//
-	//! SQL Type list mapping of name to SQL type index in sql_type_list
-	case_insensitive_map_t<idx_t> sql_types_per_column;
-	//! User-defined SQL type list
-	vector<LogicalType> sql_type_list;
-	//! User-defined name list
-	vector<string> name_list;
-	//! If the names and types were set by the columns parameter
-	bool columns_set = false;
-	//! Types considered as candidates for auto-detection ordered by descending specificity (~ from high to low)
-	vector<LogicalType> auto_type_candidates = {LogicalType::VARCHAR,   LogicalType::DOUBLE, LogicalType::BIGINT,
-	                                            LogicalType::TIMESTAMP, LogicalType::DATE,   LogicalType::TIME,
-	                                            LogicalType::BOOLEAN,   LogicalType::SQLNULL};
-	//! In case the sniffer found a mismatch error from user defined types or dialect
-	string sniffer_user_mismatch_error;
-	//! In case the sniffer found a mismatch error from user defined types or dialect
-	vector<bool> was_type_manually_set;
-	//===--------------------------------------------------------------------===//
-	// ReadCSVOptions
-	//===--------------------------------------------------------------------===//
-	//! Maximum CSV line size: specified because if we reach this amount, we likely have wrong delimiters (default: 2MB)
-	//! note that this is the guaranteed line length that will succeed, longer lines may be accepted if slightly above
-	static constexpr idx_t max_line_size_default = 2000000;
-	CSVOption<idx_t> maximum_line_size = max_line_size_default;
-	//! Whether header names shall be normalized
-	bool normalize_names = false;
-	//! True, if column with that index must skip null check
-	unordered_set<string> force_not_null_names;
-	//! True, if column with that index must skip null check
-	vector<bool> force_not_null;
-	//! Result size of sniffing phases
-	static constexpr idx_t sniff_size = 2048;
-
-	//! Number of sample chunks used in auto-detection
-	idx_t sample_size_chunks = 20480 / sniff_size;
-	//! Consider all columns to be of type varchar
-	bool all_varchar = false;
-	//! Whether to automatically detect dialect and datatypes
-	bool auto_detect = true;
-	//! The file path of the CSV file to read
-	string file_path;
-	//! Multi-file reader options
-	MultiFileReaderOptions file_options;
-	//! Buffer Size (Parallel Scan)
-	CSVOption<idx_t> buffer_size_option = CSVBuffer::ROWS_PER_BUFFER * max_line_size_default;
-	//! Decimal separator when reading as numeric
-	string decimal_separator = ".";
-	//! Whether  to pad rows that do not have enough columns with NULL values
-	bool null_padding = false;
-	//! If we should attempt to run parallel scanning over one file
-	bool parallel = true;
-
-	//! By default, our encoding is always UTF-8
-	string encoding = "utf-8";
-	//! User defined parameters for the csv function concatenated on a string
-	string user_defined_parameters;
-
-	//===--------------------------------------------------------------------===//
-	// WriteCSVOptions
-	//===--------------------------------------------------------------------===//
-	//! True, if column with that index must be quoted
-	vector<bool> force_quote;
-	//! Prefix/suffix/custom newline the entire file once (enables writing of files as JSON arrays)
-	string prefix;
-	string suffix;
-	string write_newline;
-
-	//! The date format to use for writing (if any is specified)
-	map<LogicalTypeId, Value> write_date_format = {{LogicalTypeId::DATE, Value()}, {LogicalTypeId::TIMESTAMP, Value()}};
-	//! Whether  a type format is specified
-	map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
-	//! If this reader is a multifile reader
-	bool multi_file_reader = false;
-
-	void Serialize(Serializer &serializer) const;
-	static CSVReaderOptions Deserialize(Deserializer &deserializer);
-
-	void SetCompression(const string &compression);
-
-	bool GetHeader() const;
-	void SetHeader(bool has_header);
-
-	string GetEscape() const;
-	void SetEscape(const string &escape);
-
-	idx_t GetSkipRows() const;
-	void SetSkipRows(int64_t rows);
-
-	void SetQuote(const string &quote);
-	string GetQuote() const;
-	void SetComment(const string &comment);
-	string GetComment() const;
-	void SetDelimiter(const string &delimiter);
-	string GetDelimiter() const;
-
-	//! If we can safely ignore errors (i.e., they are being ignored and not being stored in a rejects table)
-	bool IgnoreErrors() const;
-
-	string GetNewline() const;
-	void SetNewline(const string &input);
-
-	bool GetRFC4180() const;
-	void SetRFC4180(bool rfc4180);
-
-	char GetSingleByteDelimiter() const;
-	string GetMultiByteDelimiter() const;
-
-	//! Set an option that is supported by both reading and writing functions, called by
-	//! the SetReadOption and SetWriteOption methods
-	bool SetBaseOption(const string &loption, const Value &value, bool write_option = false);
-
-	//! loption - lowercase string
-	//! set - argument(s) to the option
-	//! expected_names - names expected if the option is "columns"
-	void SetReadOption(const string &loption, const Value &value, vector<string> &expected_names);
-	void SetWriteOption(const string &loption, const Value &value);
-	void SetDateFormat(LogicalTypeId type, const string &format, bool read_format);
-	void ToNamedParameters(named_parameter_map_t &out) const;
-	void FromNamedParameters(const named_parameter_map_t &in, ClientContext &context);
-	//! Verify options are not conflicting
-	void Verify();
-
-	string ToString(const string &current_file_path) const;
-	//! If the type for column with idx i was manually set
-	bool WasTypeManuallySet(idx_t i) const;
-
-	string NewLineIdentifierToString() const {
-		switch (dialect_options.state_machine_options.new_line.GetValue()) {
-		case NewLineIdentifier::SINGLE_N:
-			return "\\n";
-		case NewLineIdentifier::SINGLE_R:
-			return "\\r";
-		case NewLineIdentifier::CARRY_ON:
-			return "\\r\\n";
-		default:
-			return "";
-		}
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_schema.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_schema.hpp
deleted file mode 100644
index 3e7a90c99..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_schema.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_schema.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp"
-
-namespace duckdb {
-//! Basic CSV Column Info
-struct CSVColumnInfo {
-	CSVColumnInfo(string &name_p, LogicalType &type_p) : name(name_p), type(type_p) {
-	}
-	string name;
-	LogicalType type;
-};
-
-//! Basic CSV Schema
-struct CSVSchema {
-	explicit CSVSchema(const bool empty = false) : empty(empty) {
-	}
-
-	CSVSchema(vector<string> &names, vector<LogicalType> &types, const string &file_path, idx_t rows_read,
-	          const bool empty = false);
-
-	//! Initializes the schema based on names and types
-	void Initialize(const vector<string> &names, const vector<LogicalType> &types, const string &file_path);
-
-	//! If the schema is empty
-	bool Empty() const;
-
-	//! If the columns of the schema match
-	bool MatchColumns(const CSVSchema &other) const;
-
-	//! We merge two schemas by ensuring that the column types are compatible between both
-	void MergeSchemas(CSVSchema &other, bool null_padding);
-
-	//! What's the file path for the file that generated this schema
-	string GetPath() const;
-
-	//! How many columns we have in this schema
-	idx_t GetColumnCount() const;
-
-	//! Check if two schemas match.
-	bool SchemasMatch(string &error_message, SnifferResult &sniffer_result, const string &cur_file_path,
-	                  bool is_minimal_sniffer) const;
-
-	//! How many rows were read when generating this schema, this is only used for sniffing during the binder
-	idx_t GetRowsRead() const;
-
-	//! Get a vector with names
-	vector<string> GetNames() const;
-
-	//! Get a vector with types
-	vector<LogicalType> GetTypes() const;
-
-private:
-	//! If a type can be cast to another
-	static bool CanWeCastIt(LogicalTypeId source, LogicalTypeId destination);
-	vector<CSVColumnInfo> columns;
-	unordered_map<string, idx_t> name_idx_map;
-	string file_path;
-	idx_t rows_read = 0;
-	bool empty = false;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp
deleted file mode 100644
index 017ccfe39..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <cstdint>
-
-namespace duckdb {
-
-//! All States of CSV Parsing
-enum class CSVState : uint8_t {
-	STANDARD = 0,  //! Regular unquoted field state
-	DELIMITER = 1, //! State after encountering a field separator (e.g., ;) - This is always the last delimiter byte
-	//! ------------- Multi-byte Delimiter States (up to 4 bytes) ----------------------------------------------!//
-	DELIMITER_FIRST_BYTE = 2,  //! State when encountering the first delimiter byte of a multi-byte delimiter
-	DELIMITER_SECOND_BYTE = 3, //! State when encountering the second delimiter byte of a multi-byte delimiter
-	DELIMITER_THIRD_BYTE = 4,  //! State when encountering the third delimiter byte of a multi-byte delimiter
-	//! --------------------------------------------------------------------------------------------------------!//
-	RECORD_SEPARATOR = 5,  //! State after encountering a record separator (i.e., \n)
-	CARRIAGE_RETURN = 6,   //! State after encountering a carriage return(i.e., \r)
-	QUOTED = 7,            //! State when inside a quoted field
-	UNQUOTED = 8,          //! State when leaving a quoted field
-	ESCAPE = 9,            //! State when encountering an escape character (e.g., \)
-	INVALID = 10,          //! Got to an Invalid State, this should error.
-	NOT_SET = 11,          //! If the state is not set, usually the first state before getting the first character
-	QUOTED_NEW_LINE = 12,  //! If we have a quoted newline
-	EMPTY_SPACE = 13,      //! If we have empty spaces in the beginning and end of value
-	COMMENT = 14,          //! If we are in a comment state, and hence have to skip the whole line
-	STANDARD_NEWLINE = 15, //! State used for figuring out a new line.
-	UNQUOTED_ESCAPE = 16,  //! State when encountering an escape character (e.g., \) in an unquoted field
-	ESCAPED_RETURN = 17, //! State when the carriage return is preceded by an escape character (for '\r\n' newline only)
-	MAYBE_QUOTED = 18    //! We are potentially in a quoted value or the end of an unquoted value
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp
deleted file mode 100644
index 71eb1c11e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_state_machine.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp"
-
-namespace duckdb {
-
-//! State of necessary CSV States to parse file
-//! Current, previous, and state before the previous
-struct CSVStates {
-	void Initialize(CSVState initial_state = CSVState::NOT_SET) {
-		states[0] = initial_state;
-		states[1] = initial_state;
-	}
-	inline bool NewValue() const {
-		return states[1] == CSVState::DELIMITER;
-	}
-
-	inline bool NewRow() const {
-		// It is a new row, if the previous state is not a record separator, and the current one is
-		return states[0] != CSVState::RECORD_SEPARATOR && states[0] != CSVState::CARRIAGE_RETURN &&
-		       (states[1] == CSVState::RECORD_SEPARATOR || states[1] == CSVState::CARRIAGE_RETURN);
-	}
-
-	inline bool WasStandard() const {
-		return states[0] == CSVState::STANDARD;
-	}
-
-	inline bool EmptyLastValue() const {
-		// It is a new row, if the previous state is not a record separator, and the current one is
-		return (states[0] == CSVState::DELIMITER &&
-		        (states[1] == CSVState::RECORD_SEPARATOR || states[1] == CSVState::CARRIAGE_RETURN ||
-		         states[1] == CSVState::DELIMITER)) ||
-		       (states[0] == CSVState::STANDARD && states[1] == CSVState::DELIMITER);
-	}
-
-	inline bool EmptyLine() const {
-		return (states[1] == CSVState::CARRIAGE_RETURN || states[1] == CSVState::RECORD_SEPARATOR) &&
-		       (states[0] == CSVState::RECORD_SEPARATOR || states[0] == CSVState::NOT_SET);
-	}
-
-	inline bool IsDelimiterBytes() const {
-		return states[0] == CSVState::DELIMITER_FIRST_BYTE || states[0] == CSVState::DELIMITER_SECOND_BYTE ||
-		       states[0] == CSVState::DELIMITER_THIRD_BYTE;
-	}
-
-	inline bool IsDelimiter() const {
-		return states[1] == CSVState::DELIMITER;
-	}
-
-	inline bool IsNotSet() const {
-		return states[1] == CSVState::NOT_SET;
-	}
-
-	inline bool IsComment() const {
-		return states[1] == CSVState::COMMENT;
-	}
-
-	inline bool IsCurrentNewRow() const {
-		return states[1] == CSVState::RECORD_SEPARATOR || states[1] == CSVState::CARRIAGE_RETURN;
-	}
-
-	inline bool IsCarriageReturn() const {
-		return states[1] == CSVState::CARRIAGE_RETURN;
-	}
-
-	inline bool IsInvalid() const {
-		return states[1] == CSVState::INVALID;
-	}
-
-	inline bool IsQuoted() const {
-		return states[0] == CSVState::QUOTED;
-	}
-	inline bool IsUnquoted() const {
-		return states[0] == CSVState::UNQUOTED;
-	}
-	inline bool IsEscaped() const {
-		switch (states[1]) {
-		case CSVState::ESCAPE:
-		case CSVState::UNQUOTED_ESCAPE:
-		case CSVState::ESCAPED_RETURN:
-			return true;
-		case CSVState::QUOTED:
-			return states[0] == CSVState::UNQUOTED || states[0] == CSVState::MAYBE_QUOTED;
-		case CSVState::UNQUOTED:
-			return states[0] == CSVState::MAYBE_QUOTED;
-		default:
-			return false;
-		}
-	}
-	inline bool IsQuotedCurrent() const {
-		return states[1] == CSVState::QUOTED || states[1] == CSVState::QUOTED_NEW_LINE;
-	}
-	inline bool IsState(const CSVState state) const {
-		return states[1] == state;
-	}
-	inline bool WasState(const CSVState state) const {
-		return states[0] == state;
-	}
-	CSVState states[2];
-};
-
-//! The CSV State Machine comprises a state transition array (STA).
-//! The STA indicates the current state of parsing based on both the current and preceding characters.
-//! This reveals whether we are dealing with a Field, a New Line, a Delimiter, and so forth.
-//! The STA's creation depends on the provided quote, character, and delimiter options for that state machine.
-//! The motivation behind implementing an STA is to remove branching in regular CSV Parsing by predicting and detecting
-//! the states. Note: The State Machine is currently utilized solely in the CSV Sniffer.
-class CSVStateMachine {
-public:
-	explicit CSVStateMachine(CSVReaderOptions &options_p, const CSVStateMachineOptions &state_machine_options,
-	                         CSVStateMachineCache &csv_state_machine_cache_p);
-
-	explicit CSVStateMachine(const StateMachine &transition_array, const CSVReaderOptions &options);
-
-	//! Transition all states to next state, that depends on the current char
-	inline void Transition(CSVStates &states, char current_char) const {
-		states.states[0] = states.states[1];
-		states.states[1] = transition_array[static_cast<uint8_t>(current_char)][static_cast<uint8_t>(states.states[1])];
-	}
-
-	void Print() const {
-		std::cout << "State Machine Options" << '\n';
-		std::cout << "Delim: " << state_machine_options.delimiter.GetValue() << '\n';
-		std::cout << "Quote: " << state_machine_options.quote.GetValue() << '\n';
-		std::cout << "Escape: " << state_machine_options.escape.GetValue() << '\n';
-		std::cout << "Comment: " << state_machine_options.comment.GetValue() << '\n';
-		std::cout << "---------------------" << '\n';
-	}
-	//! The Transition Array is a Finite State Machine
-	//! It holds the transitions of all states, on all 256 possible different characters
-	const StateMachine &transition_array;
-	//! Options of this state machine
-	const CSVStateMachineOptions state_machine_options;
-	//! CSV Reader Options
-	const CSVReaderOptions &options;
-	//! Dialect options resulting from sniffing
-	DialectOptions dialect_options;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp
deleted file mode 100644
index 2980370d5..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/object_cache.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/execution/operator/csv_scanner/state_machine_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/quote_rules.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state.hpp"
-
-namespace duckdb {
-
-//! Class to wrap the state machine matrix
-class StateMachine {
-public:
-	static constexpr uint32_t NUM_STATES = 19;
-	static constexpr uint32_t NUM_TRANSITIONS = 256;
-	CSVState state_machine[NUM_TRANSITIONS][NUM_STATES];
-	//! Transitions where we might skip processing
-	//! For the Standard State
-	bool skip_standard[256];
-	//! For the Quoted State
-	bool skip_quoted[256];
-	//! For the Comment State
-	bool skip_comment[256];
-
-	uint64_t delimiter = 0;
-	uint64_t new_line = 0;
-	uint64_t carriage_return = 0;
-	uint64_t quote = 0;
-	uint64_t escape = 0;
-	uint64_t comment = 0;
-
-	const CSVState *operator[](const idx_t i) const {
-		return state_machine[i];
-	}
-
-	CSVState *operator[](const idx_t i) {
-		return state_machine[i];
-	}
-};
-
-//! Hash function used in out state machine cache, it hashes and combines all options used to generate a state machine
-struct HashCSVStateMachineConfig {
-	size_t operator()(CSVStateMachineOptions const &config) const noexcept {
-		auto h_delimiter = Hash(config.delimiter.GetValue().c_str());
-		auto h_quote = Hash(config.quote.GetValue());
-		auto h_escape = Hash(config.escape.GetValue());
-		auto h_newline = Hash(static_cast<uint8_t>(config.new_line.GetValue()));
-		auto h_comment = Hash(static_cast<uint8_t>(config.comment.GetValue()));
-		return CombineHash(h_delimiter, CombineHash(h_quote, CombineHash(h_escape, CombineHash(h_newline, h_comment))));
-	}
-};
-
-//! The CSVStateMachineCache caches state machines, although small ~2kb, the actual creation of multiple State Machines
-//! can become a bottleneck on sniffing, when reading very small csv files.
-//! Hence, the cache stores State Machines based on their different delimiter|quote|escape options.
-class CSVStateMachineCache : public ObjectCacheEntry {
-public:
-	CSVStateMachineCache();
-	~CSVStateMachineCache() override = default;
-	//! Gets a state machine from the cache, if it's not from one the default options
-	//! It first caches it, then returns it.
-	static CSVStateMachineCache &Get(ClientContext &context);
-
-	//! Gets a state machine from the cache, if it's not from one the default options
-	//! It first caches it, then returns it.
-	const StateMachine &Get(const CSVStateMachineOptions &state_machine_options);
-
-	static string ObjectType() {
-		return "CSV_STATE_MACHINE_CACHE";
-	}
-
-	string GetObjectType() override {
-		return ObjectType();
-	}
-
-private:
-	void Insert(const CSVStateMachineOptions &state_machine_options);
-	//! Cache on delimiter|quote|escape|newline
-	unordered_map<CSVStateMachineOptions, StateMachine, HashCSVStateMachineConfig> state_machine_cache;
-	//! Default value for options used to initialize CSV State Machine Cache
-
-	//! Because the state machine cache can be accessed in Parallel we need a mutex.
-	mutex main_mutex;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_validator.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_validator.hpp
deleted file mode 100644
index 20d031707..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_validator.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/csv_validator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-//! Information used to validate
-struct ValidatorLine {
-	ValidatorLine(idx_t start_pos_p, idx_t end_pos_p) : start_pos(start_pos_p), end_pos(end_pos_p) {
-	}
-	const idx_t start_pos;
-	const idx_t end_pos;
-};
-
-struct ThreadLines {
-	ThreadLines() {};
-	//! Validate everything is as it should be, returns true if it's all good, false o.w.
-	void Verify() const;
-
-	void Insert(idx_t thread, ValidatorLine line_info);
-
-	string Print() const;
-
-private:
-	map<idx_t, ValidatorLine> thread_lines;
-	//! We allow up to 2 bytes of error margin (basically \r\n)
-	static constexpr idx_t error_margin = 2;
-};
-
-//! The validator works by double-checking that threads started and ended in the right positions
-struct CSVValidator {
-	CSVValidator() {
-	}
-	//! Validate that all files are good
-	void Verify() const;
-
-	//! Inserts line_info to a given thread index of a given file.
-	void Insert(idx_t file_idx, idx_t thread, ValidatorLine line_info);
-
-	string Print(idx_t file_idx) const;
-
-private:
-	//! Per file thread lines.
-	vector<ThreadLines> per_file_thread_lines;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp
deleted file mode 100644
index 764d9694d..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/function/encoding_function.hpp"
-
-namespace duckdb {
-
-struct DBConfig;
-
-//! Struct that holds encoder buffers
-struct CSVEncoderBuffer {
-	CSVEncoderBuffer() : encoded_buffer_size(0) {};
-	void Initialize(idx_t encoded_buffer_size);
-
-	char *Ptr() const;
-
-	idx_t GetCapacity() const;
-
-	idx_t GetSize() const;
-
-	void SetSize(const idx_t buffer_size);
-
-	bool HasDataToRead() const;
-
-	void Reset();
-	idx_t cur_pos = 0;
-	//! The actual encoded buffer size, from the last file_handle read.
-	idx_t actual_encoded_buffer_size = 0;
-
-private:
-	//! The encoded buffer, we only have one per file, so we cache it and make sure to pass over unused bytes.
-	std::unique_ptr<char[]> encoded_buffer;
-	//! The encoded buffer size is defined as buffer_size/GetRatio()
-	idx_t encoded_buffer_size;
-};
-
-class CSVEncoder {
-public:
-	//! Constructor, basically takes an encoding and the output buffer size
-	CSVEncoder(DBConfig &config, const string &encoding_name, idx_t buffer_size);
-	//! Main encode function, it reads the file into an encoded buffer and converts it to the output buffer
-	idx_t Encode(FileHandle &file_handle_input, char *output_buffer, const idx_t decoded_buffer_size);
-	string encoding_name;
-
-private:
-	//! The actual encoded buffer
-	CSVEncoderBuffer encoded_buffer;
-	//! Potential remaining bytes
-	CSVEncoderBuffer remaining_bytes_buffer;
-	//! Actual Encoding Function
-	optional_ptr<EncodingFunction> encoding_function;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp
deleted file mode 100644
index 5381071ab..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/global_csv_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_validator.hpp"
-
-namespace duckdb {
-
-//! CSV Global State is used in the CSV Reader Table Function, it controls what each thread
-struct CSVGlobalState : public GlobalTableFunctionState {
-	CSVGlobalState(ClientContext &context, const shared_ptr<CSVBufferManager> &buffer_manager_p,
-	               const CSVReaderOptions &options, idx_t system_threads_p, const vector<string> &files,
-	               vector<ColumnIndex> column_ids_p, const ReadCSVData &bind_data);
-
-	~CSVGlobalState() override {
-	}
-
-	//! Generates a CSV Scanner, with information regarding the piece of buffer it should be read.
-	//! In case it returns a nullptr it means we are done reading these files.
-	unique_ptr<StringValueScanner> Next(optional_ptr<StringValueScanner> previous_scanner);
-
-	void FillRejectsTable() const;
-
-	void DecrementThread();
-
-	//! Returns Current Progress of this CSV Read
-	double GetProgress(const ReadCSVData &bind_data) const;
-
-	//! Calculates the Max Threads that will be used by this CSV Reader
-	idx_t MaxThreads() const override;
-
-	bool IsDone() const;
-
-private:
-	//! Reference to the client context that created this scan
-	ClientContext &context;
-
-	vector<shared_ptr<CSVFileScan>> file_scans;
-
-	//! Mutex to lock when getting next batch of bytes (Parallel Only)
-	mutable mutex main_mutex;
-
-	//! Basically max number of threads in DuckDB
-	idx_t system_threads;
-
-	//! Number of threads being used in this scanner
-	idx_t running_threads = 1;
-	//! The column ids to read
-	vector<ColumnIndex> column_ids;
-
-	string sniffer_mismatch_error;
-
-	bool finished = false;
-
-	const ReadCSVData &bind_data;
-
-	CSVSchema file_schema;
-
-	bool single_threaded = false;
-
-	atomic<idx_t> scanner_idx;
-
-	atomic<idx_t> last_file_idx;
-	shared_ptr<CSVBufferUsage> current_buffer_in_use;
-
-	unordered_map<idx_t, idx_t> threads_per_file;
-	//! We hold information on the current scanner boundary
-	CSVIterator current_boundary;
-
-	CSVValidator validator;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/header_value.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/header_value.hpp
deleted file mode 100644
index 65e244272..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/header_value.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/header_value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/string_type.hpp"
-
-namespace duckdb {
-struct HeaderValue {
-	HeaderValue() : is_null(true) {
-	}
-	explicit HeaderValue(const string_t value_p) {
-		value = value_p.GetString();
-	}
-	bool IsNull() {
-		return is_null;
-	}
-	bool is_null = false;
-	string value;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/quote_rules.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/quote_rules.hpp
deleted file mode 100644
index 4579eb11d..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/quote_rules.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/quote_rules.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-//! Different Rules regarding possible combinations of Quote and Escape Values for CSV Dialects.
-//! Each rule has a comment on the possible combinations.
-enum class QuoteRule : uint8_t {
-	QUOTES_RFC = 0,   //! quote = " escape = (\0 || " || ')
-	QUOTES_OTHER = 1, //! quote = ( " || ' ) escape = '\\'
-	NO_QUOTES = 2     //! quote = \0 escape = \0
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp
deleted file mode 100644
index da796d79e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/scanner_boundary.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/fast_mem.hpp"
-
-//! We all need boundaries every now and then, CSV Scans also need them
-//! This class keeps track of what a scan should read, so which buffer and from where to where
-//! As in real life, much like my childhood country, the rules are not really enforced.
-//! So the end boundaries of a Scanner Boundary can and will be pushed.
-//! In practice this means that a scanner is tolerated to read one line over it's end.
-namespace duckdb {
-
-//! Information stored in the buffer
-struct CSVBoundary {
-	CSVBoundary(idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t end_pos);
-	CSVBoundary();
-	void Print() const;
-	//! Start Buffer index of the file where we start scanning
-	idx_t buffer_idx = 0;
-	//! Start Buffer position of the buffer of the file where we start scanning
-	//! This position moves as we move through the buffer
-	idx_t buffer_pos = 0;
-	//! The boundary index relative to the total scan, only used for parallel reading to enforce
-	//! Insertion Order
-	idx_t boundary_idx = 0;
-	//! Last position this iterator should read.
-	idx_t end_pos;
-};
-
-struct CSVPosition {
-	CSVPosition(idx_t buffer_idx, idx_t buffer_pos);
-	CSVPosition();
-	//! Start Buffer index of the file where we start scanning
-	idx_t buffer_idx = 0;
-	//! Start Buffer position of the buffer of the file where we start scanning
-	//! This position moves as we move through the buffer
-	idx_t buffer_pos = 0;
-};
-struct CSVIterator {
-public:
-	CSVIterator();
-
-	void Print() const;
-	//! Moves the boundary to the next one to be scanned, if there are no next boundaries, it returns False
-	//! Otherwise, if there are boundaries, it returns True
-	bool Next(CSVBufferManager &buffer_manager, const CSVReaderOptions &reader_options);
-	//! If boundary is set
-	bool IsBoundarySet() const;
-
-	//! Getters
-	idx_t GetEndPos() const;
-	idx_t GetBufferIdx() const;
-	idx_t GetBoundaryIdx() const;
-
-	void SetCurrentPositionToBoundary();
-
-	void SetCurrentBoundaryToPosition(bool single_threaded, const CSVReaderOptions &reader_options);
-
-	void SetStart(idx_t pos);
-	void SetEnd(idx_t pos);
-
-	// Gets the current position for the file
-	idx_t GetGlobalCurrentPos() const;
-
-	//! Checks if we are done with this iterator
-	void CheckIfDone();
-
-	static idx_t BytesPerThread(const CSVReaderOptions &reader_options);
-
-	static constexpr idx_t ROWS_PER_THREAD = 4;
-
-	CSVPosition pos;
-
-	bool done = false;
-
-	bool first_one = true;
-
-	idx_t buffer_size;
-
-private:
-	//! The original setting
-	CSVBoundary boundary;
-	//! Sometimes life knows no boundaries.
-	//! The boundaries don't have to be set for single-threaded execution.
-	bool is_set;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/skip_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/skip_scanner.hpp
deleted file mode 100644
index 7d2205968..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/skip_scanner.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/skip_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
-
-namespace duckdb {
-
-class SkipResult : public ScannerResult {
-public:
-	SkipResult(CSVStates &states, CSVStateMachine &state_machine, idx_t rows_to_skip);
-
-	idx_t row_count = 0;
-	idx_t rows_to_skip;
-
-	//! Adds a Value to the result
-	static inline void AddValue(SkipResult &result, const idx_t buffer_pos);
-	//! Adds a Row to the result
-	static inline bool AddRow(SkipResult &result, const idx_t buffer_pos);
-	//! Behavior when hitting an invalid state
-	static inline void InvalidState(SkipResult &result);
-	//! Handles EmptyLine states
-	static inline bool EmptyLine(SkipResult &result, const idx_t buffer_pos);
-	//! Handles QuotedNewline State
-	static inline void QuotedNewLine(SkipResult &result);
-	//! Code to unset comment
-	static inline bool UnsetComment(SkipResult &result, idx_t buffer_pos);
-	//! Internal code to add a row
-	inline void InternalAddRow();
-};
-
-//! Scanner used to skip lines in a CSV File
-class SkipScanner : public BaseScanner {
-public:
-	SkipScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
-	            shared_ptr<CSVErrorHandler> error_handler, idx_t rows_to_skip);
-
-	SkipResult &ParseChunk() override;
-
-	SkipResult &GetResult() override;
-
-private:
-	void Initialize() override;
-
-	void FinalizeChunkProcess() override;
-
-	SkipResult result;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp
deleted file mode 100644
index 5715d25db..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp
+++ /dev/null
@@ -1,247 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/execution/operator/csv_scanner/quote_rules.hpp"
-#include "duckdb/execution/operator/csv_scanner/column_count_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_schema.hpp"
-#include "duckdb/execution/operator/csv_scanner/header_value.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp"
-
-namespace duckdb {
-struct DateTimestampSniffing {
-	bool initialized = false;
-	bool had_match = false;
-	vector<string> format;
-	idx_t initial_size;
-};
-
-//! All the options that will be used to sniff the dialect of the CSV file
-struct DialectCandidates {
-	//! The constructor populates all of our the options that will be used in our sniffer search space
-	explicit DialectCandidates(const CSVStateMachineOptions &options);
-
-	//! Static functions to get defaults of the search space
-	static vector<string> GetDefaultDelimiter();
-
-	static vector<vector<char>> GetDefaultQuote();
-
-	static vector<QuoteRule> GetDefaultQuoteRule();
-
-	static vector<vector<char>> GetDefaultEscape();
-
-	static vector<char> GetDefaultComment();
-
-	string Print();
-
-	//! Candidates for the delimiter
-	vector<string> delim_candidates;
-	//! Candidates for the comment
-	vector<char> comment_candidates;
-	//! Quote-Rule Candidates
-	vector<QuoteRule> quote_rule_candidates;
-	//! Candidates for the quote option
-	unordered_map<uint8_t, vector<char>> quote_candidates_map;
-	//! Candidates for the escape option
-	unordered_map<uint8_t, vector<char>> escape_candidates_map;
-};
-
-//! This represents the data related to columns that have been set by the user
-//! e.g., from a copy command
-struct SetColumns {
-	SetColumns(const vector<LogicalType> *types_p, const vector<string> *names_p) : types(types_p), names(names_p) {
-		if (!types) {
-			D_ASSERT(!types && !names);
-		} else {
-			D_ASSERT(types->size() == names->size());
-		}
-	}
-	SetColumns() {};
-	//! Return Types that were detected
-	const vector<LogicalType> *types = nullptr;
-	//! Column Names that were detected
-	const vector<string> *names = nullptr;
-	//! If columns are set
-	bool IsSet() const;
-	//! How many columns
-	idx_t Size() const;
-	//! Helper function that checks if candidate is acceptable based on the number of columns it produces
-	inline bool IsCandidateUnacceptable(const idx_t num_cols, bool null_padding, bool ignore_errors,
-	                                    bool last_value_always_empty) const {
-		if (!IsSet() || ignore_errors) {
-			// We can't say its unacceptable if it's not set or if we ignore errors
-			return false;
-		}
-		idx_t size = Size();
-		// If the columns are set and there is a mismatch with the expected number of columns, with null_padding and
-		// ignore_errors not set, we don't have a suitable candidate.
-		// Note that we compare with max_columns_found + 1, because some broken files have the behaviour where two
-		// columns are represented as: | col 1 | col_2 |
-		if (num_cols == size || num_cols == size + last_value_always_empty) {
-			// Good Candidate
-			return false;
-		}
-		// if we detected more columns than we have set, it's all good because we can null-pad them
-		if (null_padding && num_cols > size) {
-			return false;
-		}
-
-		// Unacceptable
-		return true;
-	}
-};
-
-//! Struct used to know if we have a date or timestamp type already identified in this CSV File
-struct HasType {
-	bool date = false;
-	bool timestamp = false;
-};
-
-//! Sniffer that detects Header, Dialect and Types of CSV Files
-class CSVSniffer {
-public:
-	explicit CSVSniffer(CSVReaderOptions &options_p, shared_ptr<CSVBufferManager> buffer_manager_p,
-	                    CSVStateMachineCache &state_machine_cache, bool default_null_to_varchar = true);
-
-	//! Main method that sniffs the CSV file, returns the types, names and options as a result
-	//! CSV Sniffing consists of five steps:
-	//! 1. Dialect Detection: Generate the CSV Options (delimiter, quote, escape, etc.)
-	//! 2. Type Detection: Figures out the types of the columns (For one chunk)
-	//! 3. Type Refinement: Refines the types of the columns for the remaining chunks
-	//! 4. Header Detection: Figures out if  the CSV file has a header and produces the names of the columns
-	//! 5. Type Replacement: Replaces the types of the columns if the user specified them
-	SnifferResult SniffCSV(bool force_match = false);
-
-	//! I call it adaptive, since that's a sexier term.
-	//! In practice this Function that only sniffs the first two rows, to verify if a header exists and what are the
-	//! data types It does this considering a priorly set CSV schema. If there is a mismatch of the schema it runs the
-	//! full on blazing all guns sniffer, if that still fails it tells the user to union_by_name.
-	//! It returns the projection order.
-	SnifferResult AdaptiveSniff(const CSVSchema &file_schema);
-
-	//! Function that only sniffs the first two rows, to verify if a header exists and what are the data types
-	AdaptiveSnifferResult MinimalSniff();
-
-	static NewLineIdentifier DetectNewLineDelimiter(CSVBufferManager &buffer_manager);
-
-	//! If a string_t value can be cast to a type
-	static bool CanYouCastIt(ClientContext &context, const string_t value, const LogicalType &type,
-	                         const DialectOptions &dialect_options, const bool is_null, const char decimal_separator);
-
-	idx_t LinesSniffed() const;
-
-private:
-	//! CSV State Machine Cache
-	CSVStateMachineCache &state_machine_cache;
-	//! Highest number of columns found
-	idx_t max_columns_found = 0;
-	//! Current Candidates being considered
-	vector<unique_ptr<ColumnCountScanner>> candidates;
-	//! Reference to original CSV Options, it will be modified as a result of the sniffer.
-	CSVReaderOptions &options;
-	//! Buffer being used on sniffer
-	shared_ptr<CSVBufferManager> buffer_manager;
-	//! Information regarding columns that were set by user/query
-	SetColumns set_columns;
-	shared_ptr<CSVErrorHandler> error_handler;
-	shared_ptr<CSVErrorHandler> detection_error_handler;
-	//! Number of lines sniffed in this sniffer
-	idx_t lines_sniffed;
-	//! Sets the result options
-	void SetResultOptions() const;
-
-	//! ------------------------------------------------------//
-	//! ----------------- Dialect Detection ----------------- //
-	//! ------------------------------------------------------//
-	//! First phase of auto detection: detect CSV dialect (i.e. delimiter, quote rules, etc)
-	void DetectDialect();
-	//! Functions called in the main DetectDialect(); function
-	//! 1. Generates the search space candidates for the state machines
-	void GenerateStateMachineSearchSpace(vector<unique_ptr<ColumnCountScanner>> &column_count_scanners,
-	                                     const DialectCandidates &dialect_candidates);
-
-	//! 2. Analyzes if dialect candidate is a good candidate to be considered, if so, it adds it to the candidates
-	void AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner>, idx_t &rows_read, idx_t &best_consistent_rows,
-	                             idx_t &prev_padding_count, idx_t &min_ignored_rows);
-	//! 3. Refine Candidates over remaining chunks
-	void RefineCandidates();
-
-	//! Checks if candidate still produces good values for the next chunk
-	bool RefineCandidateNextChunk(ColumnCountScanner &candidate) const;
-
-	//! ------------------------------------------------------//
-	//! ------------------- Type Detection ------------------ //
-	//! ------------------------------------------------------//
-	//! Second phase of auto-detection: detect types, format template candidates
-	//! ordered by descending specificity (~ from high to low)
-	void DetectTypes();
-	//! Change the date format for the type to the string
-	//! Try to cast a string value to the specified sql type
-	static void SetDateFormat(CSVStateMachine &candidate, const string &format_specifier,
-	                          const LogicalTypeId &sql_type);
-
-	//! Function that initialized the necessary variables used for date and timestamp detection
-	void InitializeDateAndTimeStampDetection(CSVStateMachine &candidate, const string &separator,
-	                                         const LogicalType &sql_type);
-	//! Sets user defined date and time formats (if any)
-	void SetUserDefinedDateTimeFormat(CSVStateMachine &candidate) const;
-	//! Functions that performs detection for date and timestamp formats
-	void DetectDateAndTimeStampFormats(CSVStateMachine &candidate, const LogicalType &sql_type, const string &separator,
-	                                   const string_t &dummy_val);
-	//! Sniffs the types from a data chunk
-	void SniffTypes(DataChunk &data_chunk, CSVStateMachine &state_machine,
-	                unordered_map<idx_t, vector<LogicalType>> &info_sql_types_candidates, idx_t start_idx_detection);
-
-	//! Variables for Type Detection
-	//! Format Candidates for Date and Timestamp Types
-	const map<LogicalTypeId, vector<const char *>> format_template_candidates = {
-	    {LogicalTypeId::DATE, {"%m-%d-%Y", "%m-%d-%y", "%d-%m-%Y", "%d-%m-%y", "%Y-%m-%d", "%y-%m-%d"}},
-	    {LogicalTypeId::TIMESTAMP,
-	     {"%Y-%m-%d %H:%M:%S.%f", "%m-%d-%Y %I:%M:%S %p", "%m-%d-%y %I:%M:%S %p", "%d-%m-%Y %H:%M:%S",
-	      "%d-%m-%y %H:%M:%S", "%Y-%m-%d %H:%M:%S", "%y-%m-%d %H:%M:%S"}},
-	};
-	unordered_map<idx_t, vector<LogicalType>> best_sql_types_candidates_per_column_idx;
-	map<LogicalTypeId, vector<string>> best_format_candidates;
-	unique_ptr<StringValueScanner> best_candidate;
-	vector<HeaderValue> best_header_row;
-	//! Variable used for sniffing date and timestamp
-	map<LogicalTypeId, DateTimestampSniffing> format_candidates;
-	map<LogicalTypeId, DateTimestampSniffing> original_format_candidates;
-
-	//! ------------------------------------------------------//
-	//! ------------------ Type Refinement ------------------ //
-	//! ------------------------------------------------------//
-	void RefineTypes();
-	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
-	vector<LogicalType> detected_types;
-	//! If when finding a SQLNULL type in type detection we default it to varchar
-	const bool default_null_to_varchar;
-	//! ------------------------------------------------------//
-	//! ------------------ Header Detection ----------------- //
-	//! ------------------------------------------------------//
-	void DetectHeader();
-	static bool DetectHeaderWithSetColumn(ClientContext &context, vector<HeaderValue> &best_header_row,
-	                                      const SetColumns &set_columns, CSVReaderOptions &options);
-	static vector<string>
-	DetectHeaderInternal(ClientContext &context, vector<HeaderValue> &best_header_row, CSVStateMachine &state_machine,
-	                     const SetColumns &set_columns,
-	                     unordered_map<idx_t, vector<LogicalType>> &best_sql_types_candidates_per_column_idx,
-	                     CSVReaderOptions &options, CSVErrorHandler &error_handler);
-	vector<string> names;
-
-	//! ------------------------------------------------------//
-	//! ------------------ Type Replacement ----------------- //
-	//! ------------------------------------------------------//
-	void ReplaceTypes();
-	vector<bool> manually_set;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp
deleted file mode 100644
index 2a8e0de19..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-//! Struct to store the result of the Sniffer
-struct SnifferResult {
-	SnifferResult(vector<LogicalType> return_types_p, vector<string> names_p)
-	    : return_types(std::move(return_types_p)), names(std::move(names_p)) {
-	}
-	//! Return Types that were detected
-	vector<LogicalType> return_types;
-	//! Column Names that were detected
-	vector<string> names;
-};
-
-struct AdaptiveSnifferResult : SnifferResult {
-	AdaptiveSnifferResult(vector<LogicalType> return_types_p, vector<string> names_p, bool more_than_one_row_p)
-	    : SnifferResult(std::move(return_types_p), std::move(names_p)), more_than_one_row(more_than_one_row_p) {
-	}
-	bool more_than_one_row;
-	SnifferResult ToSnifferResult() {
-		return {return_types, names};
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine_options.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine_options.hpp
deleted file mode 100644
index 53b306585..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine_options.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/state_machine_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
-
-namespace duckdb {
-//! Struct that holds the configuration of a CSV State Machine
-//! Basically which char, quote and escape were used to generate it.
-struct CSVStateMachineOptions {
-	CSVStateMachineOptions() {};
-	CSVStateMachineOptions(string delimiter_p, char quote_p, char escape_p, char comment_p,
-	                       NewLineIdentifier new_line_p, bool rfc_4180_p)
-	    : delimiter(std::move(delimiter_p)), quote(quote_p), escape(escape_p), comment(comment_p), new_line(new_line_p),
-	      rfc_4180(rfc_4180_p) {};
-
-	//! Delimiter to separate columns within each line
-	CSVOption<string> delimiter {","};
-	//! Quote used for columns that contain reserved characters, e.g '
-	CSVOption<char> quote = '\"';
-	//! Escape character to escape quote character
-	CSVOption<char> escape = '\0';
-	//! Comment character to skip a line
-	CSVOption<char> comment = '\0';
-	//! New Line separator
-	CSVOption<NewLineIdentifier> new_line = NewLineIdentifier::NOT_SET;
-	//! RFC 4180 conformance
-	CSVOption<bool> rfc_4180 = false;
-
-	bool operator==(const CSVStateMachineOptions &other) const {
-		return delimiter == other.delimiter && quote == other.quote && escape == other.escape &&
-		       new_line == other.new_line && comment == other.comment && rfc_4180 == other.rfc_4180;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp
deleted file mode 100644
index a2a3d5372..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp
+++ /dev/null
@@ -1,373 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/string_value_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
-#include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_validator.hpp"
-namespace duckdb {
-
-struct CSVBufferUsage {
-	CSVBufferUsage(CSVBufferManager &buffer_manager_p, idx_t buffer_idx_p)
-	    : buffer_manager(buffer_manager_p), buffer_idx(buffer_idx_p) {
-
-	                                        };
-	~CSVBufferUsage() {
-		buffer_manager.ResetBuffer(buffer_idx);
-	}
-	CSVBufferManager &buffer_manager;
-	idx_t buffer_idx;
-};
-
-//! Class that keeps track of line starts, used for line size verification
-class LinePosition {
-public:
-	LinePosition() {
-	}
-	LinePosition(idx_t buffer_idx_p, idx_t buffer_pos_p, idx_t buffer_size_p)
-	    : buffer_pos(buffer_pos_p), buffer_size(buffer_size_p), buffer_idx(buffer_idx_p) {
-	}
-
-	idx_t operator-(const LinePosition &other) const {
-		if (other.buffer_idx == buffer_idx) {
-			return buffer_pos - other.buffer_pos;
-		}
-		return other.buffer_size - other.buffer_pos + buffer_pos;
-	}
-
-	bool operator==(const LinePosition &other) const {
-		return buffer_pos == other.buffer_pos && buffer_idx == other.buffer_idx && buffer_size == other.buffer_size;
-	}
-
-	idx_t GetGlobalPosition(idx_t requested_buffer_size, bool first_char_nl = false) const {
-		return requested_buffer_size * buffer_idx + buffer_pos + first_char_nl;
-	}
-	idx_t buffer_pos = 0;
-	idx_t buffer_size = 0;
-	idx_t buffer_idx = 0;
-};
-
-//! Keeps track of start and end of line positions in regard to the CSV file
-class FullLinePosition {
-public:
-	FullLinePosition() {};
-	LinePosition begin;
-	LinePosition end;
-
-	//! Reconstructs the current line to be used in error messages
-	string ReconstructCurrentLine(bool &first_char_nl,
-	                              unordered_map<idx_t, shared_ptr<CSVBufferHandle>> &buffer_handles,
-	                              bool reconstruct_line) const;
-};
-
-class StringValueResult;
-
-class CurrentError {
-public:
-	CurrentError(CSVErrorType type, idx_t col_idx_p, idx_t chunk_idx_p, const LinePosition &error_position_p,
-	             idx_t current_line_size_p)
-	    : type(type), col_idx(col_idx_p), chunk_idx(chunk_idx_p), current_line_size(current_line_size_p),
-	      error_position(error_position_p) {};
-	//! Error Type (e.g., Cast, Wrong # of columns, ...)
-	CSVErrorType type;
-	//! Column index related to the CSV File columns
-	idx_t col_idx;
-	//! Column index related to the produced chunk (i.e., with projection applied)
-	idx_t chunk_idx;
-	//! Current CSV Line size in Bytes
-	idx_t current_line_size;
-	//! Error Message produced
-	string error_message;
-	//! Exact Position where the error happened
-	LinePosition error_position;
-
-	friend bool operator==(const CurrentError &error, CSVErrorType other) {
-		return error.type == other;
-	}
-};
-
-class LineError {
-public:
-	explicit LineError(const idx_t scan_id_p, const bool ignore_errors_p)
-	    : is_error_in_line(false), ignore_errors(ignore_errors_p), scan_id(scan_id_p) {};
-	//! We clear up our CurrentError Vector
-	void Reset() {
-		current_errors.clear();
-		is_error_in_line = false;
-	}
-	void Insert(const CSVErrorType &type, const idx_t &col_idx, const idx_t &chunk_idx,
-	            const LinePosition &error_position, const idx_t current_line_size = 0) {
-		is_error_in_line = true;
-		if (!ignore_errors) {
-			// We store it for later
-			current_errors.push_back({type, col_idx, chunk_idx, error_position, current_line_size});
-			current_errors.back().current_line_size = current_line_size;
-		}
-	}
-	//! Set that we currently have an error, but don't really store them
-	void SetError() {
-		is_error_in_line = true;
-	}
-	//! Dirty hack for adding cast message
-	void ModifyErrorMessageOfLastError(string error_message) {
-		D_ASSERT(!current_errors.empty() && current_errors.back().type == CSVErrorType::CAST_ERROR);
-		current_errors.back().error_message = std::move(error_message);
-	}
-
-	bool HasErrorType(CSVErrorType type) const {
-		for (auto &error : current_errors) {
-			if (type == error.type) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	bool HandleErrors(StringValueResult &result);
-
-	bool HasError() const {
-		return !current_errors.empty();
-	}
-
-	idx_t Size() const {
-		return current_errors.size();
-	}
-
-private:
-	vector<CurrentError> current_errors;
-	bool is_error_in_line;
-	bool ignore_errors;
-	idx_t scan_id;
-};
-
-struct ParseTypeInfo {
-	ParseTypeInfo() {};
-	ParseTypeInfo(const LogicalType &type, bool validate_utf_8_p) : validate_utf8(validate_utf_8_p) {
-		type_id = type.id();
-		internal_type = type.InternalType();
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			// We only care about these if we have a decimal value
-			type.GetDecimalProperties(width, scale);
-		}
-	}
-
-	bool validate_utf8;
-	LogicalTypeId type_id;
-	PhysicalType internal_type;
-	uint8_t scale;
-	uint8_t width;
-};
-
-class StringValueResult : public ScannerResult {
-public:
-	StringValueResult(CSVStates &states, CSVStateMachine &state_machine,
-	                  const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator,
-	                  idx_t result_size_p, idx_t buffer_position, CSVErrorHandler &error_handler, CSVIterator &iterator,
-	                  bool store_line_size, shared_ptr<CSVFileScan> csv_file_scan, idx_t &lines_read, bool sniffing,
-	                  string path, idx_t scan_id);
-
-	~StringValueResult();
-
-	//! Information on the vector
-	unsafe_vector<void *> vector_ptr;
-	unsafe_vector<ValidityMask *> validity_mask;
-
-	//! Variables to iterate over the CSV buffers
-	LinePosition last_position;
-	char *buffer_ptr;
-	idx_t buffer_size;
-	idx_t position_before_comment;
-
-	//! CSV Options that impact the parsing
-	const uint32_t number_of_columns;
-	const bool null_padding;
-	const bool ignore_errors;
-
-	const idx_t extra_delimiter_bytes = 0;
-
-	unsafe_unique_array<const char *> null_str_ptr;
-	unsafe_unique_array<idx_t> null_str_size;
-	idx_t null_str_count;
-
-	//! Internal Data Chunk used for flushing
-	DataChunk parse_chunk;
-	int64_t number_of_rows = 0;
-	idx_t cur_col_id = 0;
-	bool figure_out_new_line = false;
-	//! Information to properly handle errors
-	CSVErrorHandler &error_handler;
-	CSVIterator &iterator;
-	//! Line position of the current line
-	FullLinePosition current_line_position;
-	//! Used for CSV line reconstruction on flushed errors
-	unordered_map<idx_t, FullLinePosition> line_positions_per_row;
-	bool store_line_size = false;
-	bool added_last_line = false;
-	bool quoted_new_line = false;
-
-	unsafe_unique_array<ParseTypeInfo> parse_types;
-	vector<string> names;
-
-	shared_ptr<CSVFileScan> csv_file_scan;
-	idx_t &lines_read;
-	//! Information regarding projected columns
-	unsafe_unique_array<bool> projected_columns;
-	bool projecting_columns = false;
-	idx_t chunk_col_id = 0;
-
-	//! We must ensure that we keep the buffers alive until processing the query result
-	unordered_map<idx_t, shared_ptr<CSVBufferHandle>> buffer_handles;
-
-	//! Requested size of buffers (i.e., either 32Mb or set by buffer_size parameter)
-	idx_t requested_size;
-
-	//! Errors happening in the current line (if any)
-	LineError current_errors;
-	StrpTimeFormat date_format, timestamp_format;
-	bool sniffing;
-
-	char decimal_separator;
-
-	//! We store borked rows so we can generate multiple errors during flushing
-	unordered_set<idx_t> borked_rows;
-
-	const string path;
-
-	//! Variable used when trying to figure out where a new segment starts, we must always start from a Valid
-	//! (i.e., non-comment) line.
-	bool first_line_is_comment = false;
-
-	//! Specialized code for quoted values, makes sure to remove quotes and escapes
-	static inline void AddQuotedValue(StringValueResult &result, const idx_t buffer_pos);
-	//! Specialized code for possibly escaped values, makes sure to remove escapes
-	static inline void AddPossiblyEscapedValue(StringValueResult &result, const idx_t buffer_pos, const char *value_ptr,
-	                                           const idx_t length, const bool empty);
-	//! Adds a Value to the result
-	static inline void AddValue(StringValueResult &result, const idx_t buffer_pos);
-	//! Adds a Row to the result
-	static inline bool AddRow(StringValueResult &result, const idx_t buffer_pos);
-	//! Behavior when hitting an invalid state
-	static inline void InvalidState(StringValueResult &result);
-	//! Handles QuotedNewline State
-	static inline void QuotedNewLine(StringValueResult &result);
-	void NullPaddingQuotedNewlineCheck() const;
-	//! Handles EmptyLine states
-	static inline bool EmptyLine(StringValueResult &result, const idx_t buffer_pos);
-	inline bool AddRowInternal();
-	//! Force the throw of a Unicode error
-	void HandleUnicodeError(idx_t col_idx, LinePosition &error_position);
-	bool HandleTooManyColumnsError(const char *value_ptr, const idx_t size);
-	inline void AddValueToVector(const char *value_ptr, const idx_t size, bool allocate = false);
-	static inline void SetComment(StringValueResult &result, idx_t buffer_pos);
-	static inline bool UnsetComment(StringValueResult &result, idx_t buffer_pos);
-
-	inline idx_t HandleMultiDelimiter(const idx_t buffer_pos) const;
-
-	DataChunk &ToChunk();
-	//! Resets the state of the result
-	void Reset();
-
-	//! BOM skipping (https://en.wikipedia.org/wiki/Byte_order_mark)
-	void SkipBOM() const;
-	//! If we should Print Error Lines
-	//! We only really care about error lines if we are going to error or store them in a rejects table
-	bool PrintErrorLine() const;
-	//! Removes last added line, usually because we figured out later on that it's an ill-formed line
-	//! or that it does not fit our schema
-	void RemoveLastLine();
-};
-
-struct ValidRowInfo {
-	ValidRowInfo(bool is_valid_p, idx_t start_pos_p, idx_t end_buffer_idx_p, idx_t end_pos_p, bool last_state_quote_p)
-	    : is_valid(is_valid_p), start_pos(start_pos_p), end_buffer_idx(end_buffer_idx_p), end_pos(end_pos_p),
-	      last_state_quote(last_state_quote_p) {};
-	ValidRowInfo() : is_valid(false), start_pos(0), end_buffer_idx(0), end_pos(0) {};
-
-	bool is_valid;
-	idx_t start_pos;
-	idx_t end_buffer_idx;
-	idx_t end_pos;
-	bool last_state_quote = false;
-};
-//! Our dialect scanner basically goes over the CSV and actually parses the values to a DuckDB vector of string_t
-class StringValueScanner : public BaseScanner {
-public:
-	StringValueScanner(idx_t scanner_idx, const shared_ptr<CSVBufferManager> &buffer_manager,
-	                   const shared_ptr<CSVStateMachine> &state_machine,
-	                   const shared_ptr<CSVErrorHandler> &error_handler, const shared_ptr<CSVFileScan> &csv_file_scan,
-	                   bool sniffing = false, const CSVIterator &boundary = {},
-	                   idx_t result_size = STANDARD_VECTOR_SIZE);
-
-	StringValueScanner(const shared_ptr<CSVBufferManager> &buffer_manager,
-	                   const shared_ptr<CSVStateMachine> &state_machine,
-	                   const shared_ptr<CSVErrorHandler> &error_handler, idx_t result_size = STANDARD_VECTOR_SIZE,
-	                   const CSVIterator &boundary = {});
-
-	StringValueResult &ParseChunk() override;
-
-	//! Flushes the result to the insert_chunk
-	void Flush(DataChunk &insert_chunk);
-
-	//! Function that creates and returns a non-boundary CSV Scanner, can be used for internal csv reading.
-	static unique_ptr<StringValueScanner> GetCSVScanner(ClientContext &context, CSVReaderOptions &options);
-
-	bool FinishedIterator() const;
-
-	//! Creates a new string with all escaped values removed
-	static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, char quote, Vector &vector);
-
-	//! If we can directly cast the type when consuming the CSV file, or we have to do it later
-	static bool CanDirectlyCast(const LogicalType &type, bool icu_loaded);
-
-	//! Gets validation line information
-	ValidatorLine GetValidationLine();
-
-	const idx_t scanner_idx;
-	//! We use the max of idx_t to signify this is a line finder scanner.
-	static constexpr idx_t LINE_FINDER_ID = NumericLimits<idx_t>::Maximum();
-
-	//! Variable that manages buffer tracking
-	shared_ptr<CSVBufferUsage> buffer_tracker;
-
-private:
-	void Initialize() override;
-
-	void FinalizeChunkProcess() override;
-
-	//! Function used to process values that go over the first buffer, extra allocation might be necessary
-	void ProcessOverBufferValue();
-
-	void ProcessExtraRow();
-	//! Function used to move from one buffer to the other, if necessary
-	bool MoveToNextBuffer();
-
-	//! -------- Functions used to figure out where lines start ---------!//
-	//! Main function, sets the correct start
-	void SetStart();
-	//! From a given initial state, it skips until we reach the until_state
-	bool SkipUntilState(CSVState initial_state, CSVState until_state, CSVIterator &current_iterator,
-	                    bool &quoted) const;
-	//! If the current row we found is valid
-	bool IsRowValid(CSVIterator &current_iterator) const;
-	ValidRowInfo TryRow(CSVState state, idx_t start_pos, idx_t end_pos) const;
-	bool FirstValueEndsOnQuote(CSVIterator iterator) const;
-
-	StringValueResult result;
-	vector<LogicalType> types;
-	//! True Position where this scanner started scanning(i.e., after figuring out where the first line starts)
-	idx_t start_pos;
-	//! Pointer to the previous buffer handle, necessary for over-buffer values
-	shared_ptr<CSVBufferHandle> previous_buffer_handle;
-	//! Strict state machine, is basically a state machine with rfc 4180 set to true, used to figure out new line.
-	shared_ptr<CSVStateMachine> state_machine_strict;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/filter/physical_filter.hpp b/src/duckdb/src/include/duckdb/execution/operator/filter/physical_filter.hpp
deleted file mode 100644
index 9b49457cb..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/filter/physical_filter.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/filter/physical_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! PhysicalFilter represents a filter operator. It removes non-matching tuples
-//! from the result. Note that it does not physically change the data, it only
-//! adds a selection vector to the chunk.
-class PhysicalFilter : public CachingPhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::FILTER;
-
-public:
-	PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality);
-
-	//! The filter expression
-	unique_ptr<Expression> expression;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-protected:
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp
deleted file mode 100644
index 29a58c7a6..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_batch_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-
-namespace duckdb {
-
-class PhysicalBatchCollector : public PhysicalResultCollector {
-public:
-	explicit PhysicalBatchCollector(PreparedStatementData &data);
-
-public:
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	OperatorPartitionInfo RequiredPartitionInfo() const override {
-		return OperatorPartitionInfo::BatchIndex();
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class BatchCollectorGlobalState : public GlobalSinkState {
-public:
-	BatchCollectorGlobalState(ClientContext &context, const PhysicalBatchCollector &op) : data(context, op.types) {
-	}
-
-	mutex glock;
-	BatchedDataCollection data;
-	unique_ptr<QueryResult> result;
-};
-
-class BatchCollectorLocalState : public LocalSinkState {
-public:
-	BatchCollectorLocalState(ClientContext &context, const PhysicalBatchCollector &op) : data(context, op.types) {
-	}
-
-	BatchedDataCollection data;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp
deleted file mode 100644
index 1ab923968..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/common/queue.hpp"
-
-namespace duckdb {
-
-class BufferedBatchCollectorLocalState : public LocalSinkState {
-public:
-	BufferedBatchCollectorLocalState();
-
-public:
-	idx_t current_batch = 0;
-};
-
-class PhysicalBufferedBatchCollector : public PhysicalResultCollector {
-public:
-	explicit PhysicalBufferedBatchCollector(PreparedStatementData &data);
-
-public:
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkNextBatchType NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	OperatorPartitionInfo RequiredPartitionInfo() const override {
-		return OperatorPartitionInfo::BatchIndex();
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool IsStreaming() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_collector.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_collector.hpp
deleted file mode 100644
index 501358455..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_collector.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_buffered_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/main/buffered_data/simple_buffered_data.hpp"
-
-namespace duckdb {
-
-class PhysicalBufferedCollector : public PhysicalResultCollector {
-public:
-	PhysicalBufferedCollector(PreparedStatementData &data, bool parallel);
-
-	bool parallel;
-
-public:
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool ParallelSink() const override;
-	bool SinkOrderDependent() const override;
-	bool IsStreaming() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_create_secret.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_create_secret.hpp
deleted file mode 100644
index 0a303b2df..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_create_secret.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_pragma.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalCreateSecret represents the CREATE SECRET operator
-class PhysicalCreateSecret : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SECRET;
-
-public:
-	PhysicalCreateSecret(CreateSecretInfo info_p, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_SECRET, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info_p)) {
-	}
-
-	CreateSecretInfo info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_execute.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_execute.hpp
deleted file mode 100644
index 46b1e38c2..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_execute.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_execute.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-
-namespace duckdb {
-
-class PhysicalExecute : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXECUTE;
-
-public:
-	explicit PhysicalExecute(PhysicalOperator &plan);
-
-	PhysicalOperator &plan;
-	unique_ptr<PhysicalOperator> owned_plan;
-	shared_ptr<PreparedStatementData> prepared;
-
-public:
-	vector<const_reference<PhysicalOperator>> GetChildren() const override;
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_explain_analyze.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_explain_analyze.hpp
deleted file mode 100644
index 05f329b7b..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_explain_analyze.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_explain_analyze.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
-
-namespace duckdb {
-
-class PhysicalExplainAnalyze : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPLAIN_ANALYZE;
-
-public:
-	explicit PhysicalExplainAnalyze(vector<LogicalType> types, ExplainFormat format)
-	    : PhysicalOperator(PhysicalOperatorType::EXPLAIN_ANALYZE, std::move(types), 1), format(format) {
-	}
-
-public:
-	ExplainFormat format;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit.hpp
deleted file mode 100644
index 47f01b2b5..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_limit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-//! PhyisicalLimit represents the LIMIT operator
-class PhysicalLimit : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LIMIT;
-
-	static constexpr const idx_t MAX_LIMIT_VALUE = 1ULL << 62ULL;
-
-public:
-	PhysicalLimit(vector<LogicalType> types, BoundLimitNode limit_val, BoundLimitNode offset_val,
-	              idx_t estimated_cardinality);
-
-	BoundLimitNode limit_val;
-	BoundLimitNode offset_val;
-
-public:
-	bool SinkOrderDependent() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	OperatorPartitionInfo RequiredPartitionInfo() const override {
-		return OperatorPartitionInfo::BatchIndex();
-	}
-
-public:
-	static void SetInitialLimits(const BoundLimitNode &limit_val, const BoundLimitNode &offset_val, optional_idx &limit,
-	                             optional_idx &offset);
-	static bool ComputeOffset(ExecutionContext &context, DataChunk &input, optional_idx &limit, optional_idx &offset,
-	                          idx_t current_offset, idx_t &max_element, const BoundLimitNode &limit_val,
-	                          const BoundLimitNode &offset_val);
-	static bool HandleOffset(DataChunk &input, idx_t &current_offset, idx_t offset, idx_t limit);
-	static Value GetDelimiter(ExecutionContext &context, DataChunk &input, const Expression &expr);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit_percent.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit_percent.hpp
deleted file mode 100644
index 723822ec1..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit_percent.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_limit_percent.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-//! PhyisicalLimitPercent represents the LIMIT PERCENT operator
-class PhysicalLimitPercent : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LIMIT_PERCENT;
-
-public:
-	PhysicalLimitPercent(vector<LogicalType> types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p,
-	                     idx_t estimated_cardinality);
-
-	BoundLimitNode limit_val;
-	BoundLimitNode offset_val;
-
-public:
-	bool SinkOrderDependent() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_load.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_load.hpp
deleted file mode 100644
index 4511ff01a..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_load.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_vacuum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/load_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalLoad represents an extension LOAD operation
-class PhysicalLoad : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LOAD;
-
-public:
-	explicit PhysicalLoad(unique_ptr<LoadInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::LOAD, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<LoadInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_materialized_collector.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_materialized_collector.hpp
deleted file mode 100644
index 78dacbe77..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_materialized_collector.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_materialized_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/common/types/column/column_data_scan_states.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-
-class PhysicalMaterializedCollector : public PhysicalResultCollector {
-public:
-	PhysicalMaterializedCollector(PreparedStatementData &data, bool parallel);
-
-	bool parallel;
-
-public:
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool ParallelSink() const override;
-	bool SinkOrderDependent() const override;
-};
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class MaterializedCollectorGlobalState : public GlobalSinkState {
-public:
-	mutex glock;
-	unique_ptr<ColumnDataCollection> collection;
-	shared_ptr<ClientContext> context;
-};
-
-class MaterializedCollectorLocalState : public LocalSinkState {
-public:
-	unique_ptr<ColumnDataCollection> collection;
-	ColumnDataAppendState append_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_pragma.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_pragma.hpp
deleted file mode 100644
index 9dfc40c0e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_pragma.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_pragma.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/bound_pragma_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalPragma represents the PRAGMA operator
-class PhysicalPragma : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PRAGMA;
-
-public:
-	PhysicalPragma(unique_ptr<BoundPragmaInfo> info_p, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::PRAGMA, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info_p)) {
-	}
-
-	//! The context of the call
-	unique_ptr<BoundPragmaInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_prepare.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_prepare.hpp
deleted file mode 100644
index 961feca1e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_prepare.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_prepare.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/common/enums/physical_operator_type.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-
-namespace duckdb {
-
-class PhysicalPrepare : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PREPARE;
-
-public:
-	PhysicalPrepare(string name_p, shared_ptr<PreparedStatementData> prepared, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::PREPARE, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      name(std::move(name_p)), prepared(std::move(prepared)) {
-	}
-
-	string name;
-	shared_ptr<PreparedStatementData> prepared;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reservoir_sample.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reservoir_sample.hpp
deleted file mode 100644
index e4a581dca..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reservoir_sample.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_reservoir_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-
-namespace duckdb {
-
-//! PhysicalReservoirSample represents a sample taken using reservoir sampling,
-//! which is a blocking sampling method
-
-class PhysicalReservoirSample : public PhysicalOperator {
-public:
-	PhysicalReservoirSample(vector<LogicalType> types, unique_ptr<SampleOptions> options, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::RESERVOIR_SAMPLE, std::move(types), estimated_cardinality),
-	      options(std::move(options)) {
-	}
-
-	unique_ptr<SampleOptions> options;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	bool ParallelSink() const override {
-		return !options->repeatable;
-	}
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reset.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reset.hpp
deleted file mode 100644
index c3e69e4a1..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reset.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_reset.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-struct DBConfig;
-struct ExtensionOption;
-
-//! PhysicalReset represents a RESET operation (e.g. RESET a = 42)
-class PhysicalReset : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RESET;
-
-public:
-	PhysicalReset(const std::string &name_p, SetScope scope_p, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::RESET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),
-	      scope(scope_p) {
-	}
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	const std::string name;
-	const SetScope scope;
-
-private:
-	void ResetExtensionVariable(ExecutionContext &context, DBConfig &config, ExtensionOption &extension_option) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_result_collector.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_result_collector.hpp
deleted file mode 100644
index 0032e06c6..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_result_collector.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_result_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/common/enums/statement_type.hpp"
-
-namespace duckdb {
-class PreparedStatementData;
-
-//! PhysicalResultCollector is an abstract class that is used to generate the final result of a query
-class PhysicalResultCollector : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RESULT_COLLECTOR;
-
-public:
-	explicit PhysicalResultCollector(PreparedStatementData &data);
-
-	StatementType statement_type;
-	StatementProperties properties;
-	PhysicalOperator &plan;
-	vector<string> names;
-
-public:
-	static unique_ptr<PhysicalResultCollector> GetResultCollector(ClientContext &context, PreparedStatementData &data);
-
-public:
-	//! The final method used to fetch the query result from this operator
-	virtual unique_ptr<QueryResult> GetResult(GlobalSinkState &state) = 0;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	vector<const_reference<PhysicalOperator>> GetChildren() const override;
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	//! Whether this is a streaming result collector
-	virtual bool IsStreaming() const {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp
deleted file mode 100644
index cc1446018..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-struct DBConfig;
-struct ExtensionOption;
-
-//! PhysicalSet represents a SET operation (e.g. SET a = 42)
-class PhysicalSet : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::SET;
-
-public:
-	PhysicalSet(const string &name_p, Value value_p, SetScope scope_p, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::SET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),
-	      value(std::move(value_p)), scope(scope_p) {
-	}
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-	static void SetExtensionVariable(ClientContext &context, ExtensionOption &extension_option, const string &name,
-	                                 SetScope scope, const Value &value);
-
-public:
-	const string name;
-	const Value value;
-	const SetScope scope;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set_variable.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set_variable.hpp
deleted file mode 100644
index 8cb818e55..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set_variable.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_set_variable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-//! PhysicalSet represents a SET of a variable (e.g. SET $a = 42)
-class PhysicalSetVariable : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::SET_VARIABLE;
-
-public:
-	PhysicalSetVariable(string name, idx_t estimated_cardinality);
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	const string name;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_limit.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_limit.hpp
deleted file mode 100644
index 22cdc00d8..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_limit.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_streaming_limit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-class PhysicalStreamingLimit : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_LIMIT;
-
-public:
-	PhysicalStreamingLimit(vector<LogicalType> types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p,
-	                       idx_t estimated_cardinality, bool parallel);
-
-	BoundLimitNode limit_val;
-	BoundLimitNode offset_val;
-	bool parallel;
-
-public:
-	// Operator interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	OrderPreservationType OperatorOrder() const override;
-	bool ParallelOperator() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_sample.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_sample.hpp
deleted file mode 100644
index dafaf849f..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_sample.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_streaming_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-
-namespace duckdb {
-
-//! PhysicalStreamingSample represents a streaming sample using either system or bernoulli sampling
-class PhysicalStreamingSample : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_SAMPLE;
-
-public:
-	PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage, int64_t seed,
-	                        idx_t estimated_cardinality);
-
-	SampleMethod method;
-	double percentage;
-	int64_t seed;
-
-public:
-	// Operator interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-private:
-	void SystemSample(DataChunk &input, DataChunk &result, OperatorState &state) const;
-	void BernoulliSample(DataChunk &input, DataChunk &result, OperatorState &state) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_transaction.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_transaction.hpp
deleted file mode 100644
index 3a2fee929..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_transaction.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/transaction_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalTransaction represents a transaction operator (e.g. BEGIN or COMMIT)
-class PhysicalTransaction : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TRANSACTION;
-
-public:
-	explicit PhysicalTransaction(unique_ptr<TransactionInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::TRANSACTION, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<TransactionInfo> info;
-
-public:
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_update_extensions.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_update_extensions.hpp
deleted file mode 100644
index bb5024b56..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_update_extensions.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// src/include/duckdb/execution/operator/helper/physical_update_extensions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/update_extensions_info.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-namespace duckdb {
-
-struct UpdateExtensionsGlobalState : public GlobalSourceState {
-	UpdateExtensionsGlobalState() : offset(0) {
-	}
-
-	vector<ExtensionUpdateResult> update_result_entries;
-	idx_t offset;
-};
-
-//! PhysicalUpdateExtensions represents an extension UPDATE operation
-class PhysicalUpdateExtensions : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UPDATE_EXTENSIONS;
-
-public:
-	explicit PhysicalUpdateExtensions(unique_ptr<UpdateExtensionsInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::UPDATE_EXTENSIONS,
-	                       {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
-	                        LogicalType::VARCHAR},
-	                       estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<UpdateExtensionsInfo> info;
-
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_vacuum.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_vacuum.hpp
deleted file mode 100644
index 1bc3d5360..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_vacuum.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_vacuum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalVacuum represents a VACUUM operation (i.e. VACUUM or ANALYZE)
-class PhysicalVacuum : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::VACUUM;
-
-public:
-	PhysicalVacuum(unique_ptr<VacuumInfo> info, optional_ptr<TableCatalogEntry> table,
-	               unordered_map<idx_t, idx_t> column_id_map, idx_t estimated_cardinality);
-
-	unique_ptr<VacuumInfo> info;
-	optional_ptr<TableCatalogEntry> table;
-	unordered_map<idx_t, idx_t> column_id_map;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return info->has_table;
-	}
-
-	bool ParallelSink() const override {
-		return IsSink();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_verify_vector.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_verify_vector.hpp
deleted file mode 100644
index ce774c554..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_verify_vector.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_verify_vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! The PhysicalVerifyVector operator is a streaming operator that emits the same data as it ingests - but in a
-//! different format
-// There are different configurations
-// * Dictionary: Transform every vector into a dictionary vector where the underlying vector has gaps and is reversed
-//       i.e. original: FLAT [1, 2, 3]
-//            modified: BASE: [NULL, 3, NULL, 2, NULL, 1]   OFFSETS: [5, 3, 1]
-// * Constant: Decompose every DataChunk into single-row constant vectors
-//       i.e. original: FLAT [1, 2, 3]
-//            modified: chunk #1 - CONSTANT [1]
-//                      chunk #2 - CONSTANT [2]
-//                      chunk #3 - CONSTANT [3]
-// * Sequence & Constant: Decompose every DataChunk into constant or sequence vectors based on the longest possibility
-//            original:  a: [1, 1, 20, 15, 13]   b: [1, 10, 100, 101, 102]
-//            modified:  chunk #1 - a: CONSTANT [1, 1]          b: DICTIONARY [1, 10]
-//                       chunk #2 - a: DICTIONARY [20, 15, 13]  b: SEQUENCE [100, 101, 102]
-// * Nested Shuffle: Reshuffle list vectors so that offsets are not contiguous
-//            original: [[1, 2], [3, 4]] - BASE: [1, 2, 3, 4] LISTS: [offset: 0, length: 2][offset: 2, length: 2]
-//            modified: [[1, 2], [3, 4]] - BASE: [3, 4, 1, 2] LISTS: [offset: 2, length: 2][offset: 0, length: 2]
-class PhysicalVerifyVector : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::VERIFY_VECTOR;
-
-public:
-	explicit PhysicalVerifyVector(unique_ptr<PhysicalOperator> child);
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/join_filter_pushdown.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/join_filter_pushdown.hpp
deleted file mode 100644
index 3a5663c6a..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/join_filter_pushdown.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/join_filter_pushdown.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/table_filter.hpp"
-
-namespace duckdb {
-class DataChunk;
-class DynamicTableFilterSet;
-class LogicalGet;
-class JoinHashTable;
-struct GlobalUngroupedAggregateState;
-struct LocalUngroupedAggregateState;
-
-struct JoinFilterPushdownColumn {
-	//! The probe column index to which this filter should be applied
-	ColumnBinding probe_column_index;
-};
-
-struct JoinFilterGlobalState {
-	~JoinFilterGlobalState();
-
-	//! Global Min/Max aggregates for filter pushdown
-	unique_ptr<GlobalUngroupedAggregateState> global_aggregate_state;
-};
-
-struct JoinFilterLocalState {
-	~JoinFilterLocalState();
-
-	//! Local Min/Max aggregates for filter pushdown
-	unique_ptr<LocalUngroupedAggregateState> local_aggregate_state;
-};
-
-struct JoinFilterPushdownFilter {
-	//! The dynamic table filter set where to push filters into
-	shared_ptr<DynamicTableFilterSet> dynamic_filters;
-	//! The columns for which we should generate filters
-	vector<JoinFilterPushdownColumn> columns;
-};
-
-struct PushdownFilterTarget {
-	PushdownFilterTarget(LogicalGet &get, vector<JoinFilterPushdownColumn> columns_p)
-	    : get(get), columns(std::move(columns_p)) {
-	}
-
-	LogicalGet &get;
-	vector<JoinFilterPushdownColumn> columns;
-};
-
-struct JoinFilterPushdownInfo {
-	//! The join condition indexes for which we compute the min/max aggregates
-	vector<idx_t> join_condition;
-	//! The probes to push the filter into
-	vector<JoinFilterPushdownFilter> probe_info;
-	//! Min/Max aggregates
-	vector<unique_ptr<Expression>> min_max_aggregates;
-
-public:
-	unique_ptr<JoinFilterGlobalState> GetGlobalState(ClientContext &context, const PhysicalOperator &op) const;
-	unique_ptr<JoinFilterLocalState> GetLocalState(JoinFilterGlobalState &gstate) const;
-
-	void Sink(DataChunk &chunk, JoinFilterLocalState &lstate) const;
-	void Combine(JoinFilterGlobalState &gstate, JoinFilterLocalState &lstate) const;
-	unique_ptr<DataChunk> Finalize(ClientContext &context, JoinHashTable &ht, JoinFilterGlobalState &gstate,
-	                               const PhysicalOperator &op) const;
-
-private:
-	void PushInFilter(const JoinFilterPushdownFilter &info, JoinHashTable &ht, const PhysicalOperator &op,
-	                  idx_t filter_idx, idx_t filter_col_idx) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp
deleted file mode 100644
index b90a26767..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/outer_join_marker.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-struct OuterJoinGlobalScanState {
-	mutex lock;
-	ColumnDataCollection *data = nullptr;
-	ColumnDataParallelScanState global_scan;
-};
-
-struct OuterJoinLocalScanState {
-	DataChunk scan_chunk;
-	SelectionVector match_sel;
-	ColumnDataLocalScanState local_scan;
-};
-
-class OuterJoinMarker {
-public:
-	explicit OuterJoinMarker(bool enabled);
-
-	bool Enabled() {
-		return enabled;
-	}
-	//! Initializes the outer join counter
-	void Initialize(idx_t count);
-	//! Resets the outer join counter
-	void Reset();
-
-	//! Sets an indiivdual match
-	void SetMatch(idx_t position);
-
-	//! Sets multiple matches
-	void SetMatches(const SelectionVector &sel, idx_t count, idx_t base_idx = 0);
-
-	//! Constructs a left-join result based on which tuples have not found matches
-	void ConstructLeftJoinResult(DataChunk &left, DataChunk &result);
-
-	//! Returns the maximum number of threads that can be associated with an right-outer join scan
-	idx_t MaxThreads() const;
-
-	//! Initialize a scan
-	void InitializeScan(ColumnDataCollection &data, OuterJoinGlobalScanState &gstate);
-
-	//! Initialize a local scan
-	void InitializeScan(OuterJoinGlobalScanState &gstate, OuterJoinLocalScanState &lstate);
-
-	//! Perform the scan
-	void Scan(OuterJoinGlobalScanState &gstate, OuterJoinLocalScanState &lstate, DataChunk &result);
-
-	//! Read-only matches vector
-	const bool *GetMatches() const {
-		return found_match.get();
-	}
-
-private:
-	bool enabled;
-	unsafe_unique_array<bool> found_match;
-	idx_t count;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp
deleted file mode 100644
index 0affaf4cc..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/perfect_hash_join_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/execution/join_hashtable.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class HashJoinOperatorState;
-class HashJoinGlobalSinkState;
-class PhysicalHashJoin;
-
-struct PerfectHashJoinStats {
-	Value build_min;
-	Value build_max;
-	bool is_build_small = false;
-	bool is_build_dense = false;
-	idx_t build_range = 0;
-};
-
-//! PhysicalHashJoin represents a hash loop join between two tables
-class PerfectHashJoinExecutor {
-	using PerfectHashTable = vector<Vector>;
-
-public:
-	PerfectHashJoinExecutor(const PhysicalHashJoin &join, JoinHashTable &ht);
-
-public:
-	bool CanDoPerfectHashJoin(const PhysicalHashJoin &op, const Value &min, const Value &max);
-
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context);
-	OperatorResultType ProbePerfectHashTable(ExecutionContext &context, DataChunk &input, DataChunk &lhs_output_columns,
-	                                         DataChunk &chunk, OperatorState &state);
-	bool BuildPerfectHashTable(LogicalType &type);
-
-private:
-	void FillSelectionVectorSwitchProbe(Vector &source, SelectionVector &build_sel_vec, SelectionVector &probe_sel_vec,
-	                                    idx_t count, idx_t &probe_sel_count);
-	template <typename T>
-	void TemplatedFillSelectionVectorProbe(Vector &source, SelectionVector &build_sel_vec,
-	                                       SelectionVector &probe_sel_vec, idx_t count, idx_t &prob_sel_count);
-
-	bool FillSelectionVectorSwitchBuild(Vector &source, SelectionVector &sel_vec, SelectionVector &seq_sel_vec,
-	                                    idx_t count);
-	template <typename T>
-	bool TemplatedFillSelectionVectorBuild(Vector &source, SelectionVector &sel_vec, SelectionVector &seq_sel_vec,
-	                                       idx_t count);
-	bool FullScanHashTable(LogicalType &key_type);
-
-private:
-	const PhysicalHashJoin &join;
-	JoinHashTable &ht;
-	//! Columnar perfect hash table
-	PerfectHashTable perfect_hash_table;
-	//! Build statistics
-	PerfectHashJoinStats perfect_join_statistics;
-	//! Stores the occurrences of each value in the build side
-	unsafe_unique_array<bool> bitmap_build_idx;
-	//! Stores the number of unique keys in the build side
-	idx_t unique_keys = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp
deleted file mode 100644
index 467eafe6e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_asof_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-//! PhysicalAsOfJoin represents an as-of join between two tables
-class PhysicalAsOfJoin : public PhysicalComparisonJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ASOF_JOIN;
-
-public:
-	PhysicalAsOfJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right);
-
-	vector<LogicalType> join_key_types;
-	vector<column_t> null_sensitive;
-	ExpressionType comparison_type;
-
-	// Equalities
-	vector<unique_ptr<Expression>> lhs_partitions;
-	vector<unique_ptr<Expression>> rhs_partitions;
-
-	// Inequality Only
-	vector<BoundOrderByNode> lhs_orders;
-	vector<BoundOrderByNode> rhs_orders;
-
-	// Projection mappings
-	vector<column_t> right_projection_map;
-
-public:
-	// Operator Interface
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-protected:
-	// CachingOperator Interface
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_blockwise_nl_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_blockwise_nl_join.hpp
deleted file mode 100644
index e6ec48410..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_blockwise_nl_join.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_blockwise_nl_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_join.hpp"
-
-namespace duckdb {
-
-//! PhysicalBlockwiseNLJoin represents a nested loop join between two tables on arbitrary expressions. This is different
-//! from the PhysicalNestedLoopJoin in that it does not require expressions to be comparisons between the LHS and the
-//! RHS.
-class PhysicalBlockwiseNLJoin : public PhysicalJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BLOCKWISE_NL_JOIN;
-
-public:
-	PhysicalBlockwiseNLJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                        unique_ptr<Expression> condition, JoinType join_type, idx_t estimated_cardinality);
-
-	unique_ptr<Expression> condition;
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-protected:
-	// CachingOperatorState Interface
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return PropagatesBuildSide(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_comparison_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_comparison_join.hpp
deleted file mode 100644
index d2413d46c..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_comparison_join.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_comparison_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/join/physical_join.hpp"
-#include "duckdb/execution/operator/join/join_filter_pushdown.hpp"
-
-namespace duckdb {
-class ColumnDataCollection;
-struct ColumnDataScanState;
-class LogicalGet;
-
-//! PhysicalJoin represents the base class of the join operators
-class PhysicalComparisonJoin : public PhysicalJoin {
-public:
-	PhysicalComparisonJoin(LogicalOperator &op, PhysicalOperatorType type, vector<JoinCondition> cond,
-	                       JoinType join_type, idx_t estimated_cardinality);
-
-	vector<JoinCondition> conditions;
-	//! Scans where we should push generated filters into (if any)
-	unique_ptr<JoinFilterPushdownInfo> filter_pushdown;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	//! Re-order join conditions so that equality predicates are first, followed by other predicates
-	static void ReorderConditions(vector<JoinCondition> &conditions);
-
-	//! Construct the join result of a join with an empty RHS
-	static void ConstructEmptyJoinResult(JoinType type, bool has_null, DataChunk &input, DataChunk &result);
-	//! Construct the remainder of a Full Outer Join based on which tuples in the RHS found no match
-	static void ConstructFullOuterJoinResult(bool *found_match, ColumnDataCollection &input, DataChunk &result,
-	                                         ColumnDataScanState &scan_state);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_cross_product.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_cross_product.hpp
deleted file mode 100644
index 8091bb3c5..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_cross_product.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_cross_product.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-//! PhysicalCrossProduct represents a cross product between two tables
-class PhysicalCrossProduct : public CachingPhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CROSS_PRODUCT;
-
-public:
-	PhysicalCrossProduct(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-	                     unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality);
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	OrderPreservationType OperatorOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-protected:
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-};
-
-class CrossProductExecutor {
-public:
-	explicit CrossProductExecutor(ColumnDataCollection &rhs);
-
-	OperatorResultType Execute(DataChunk &input, DataChunk &output);
-
-	// returns if the left side is scanned as a constant vector
-	bool ScanLHS() {
-		return scan_input_chunk;
-	}
-
-	// returns the position in the chunk of chunk scanned as a constant input vector
-	idx_t PositionInChunk() {
-		return position_in_chunk;
-	}
-
-	idx_t ScanPosition() {
-		return scan_state.current_row_index;
-	}
-
-private:
-	void Reset(DataChunk &input, DataChunk &output);
-	bool NextValue(DataChunk &input, DataChunk &output);
-
-private:
-	ColumnDataCollection &rhs;
-	ColumnDataScanState scan_state;
-	DataChunk scan_chunk;
-	idx_t position_in_chunk;
-	bool initialized;
-	bool finished;
-	bool scan_input_chunk;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_delim_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_delim_join.hpp
deleted file mode 100644
index f12fe76ec..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_delim_join.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class PhysicalHashAggregate;
-
-//! PhysicalDelimJoin represents a join where either the LHS or RHS will be duplicate eliminated and pushed into a
-//! PhysicalColumnDataScan in the other side. Implementations are PhysicalLeftDelimJoin and PhysicalRightDelimJoin
-class PhysicalDelimJoin : public PhysicalOperator {
-public:
-	PhysicalDelimJoin(PhysicalOperatorType type, vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-	                  vector<const_reference<PhysicalOperator>> delim_scans, idx_t estimated_cardinality,
-	                  optional_idx delim_idx);
-
-	unique_ptr<PhysicalOperator> join;
-	unique_ptr<PhysicalHashAggregate> distinct;
-	vector<const_reference<PhysicalOperator>> delim_scans;
-
-	optional_idx delim_idx;
-
-public:
-	vector<const_reference<PhysicalOperator>> GetChildren() const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp
deleted file mode 100644
index 849423a25..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_hash_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/execution/join_hashtable.hpp"
-#include "duckdb/execution/operator/join/perfect_hash_join_executor.hpp"
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-
-namespace duckdb {
-
-//! PhysicalHashJoin represents a hash loop join between two tables
-class PhysicalHashJoin : public PhysicalComparisonJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::HASH_JOIN;
-
-	struct JoinProjectionColumns {
-		vector<idx_t> col_idxs;
-		vector<LogicalType> col_types;
-	};
-
-public:
-	PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                 vector<JoinCondition> cond, JoinType join_type, const vector<idx_t> &left_projection_map,
-	                 const vector<idx_t> &right_projection_map, vector<LogicalType> delim_types,
-	                 idx_t estimated_cardinality, unique_ptr<JoinFilterPushdownInfo> pushdown_info);
-	PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                 vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
-
-	//! Initialize HT for this operator
-	unique_ptr<JoinHashTable> InitializeHashTable(ClientContext &context) const;
-
-	//! The types of the join keys
-	vector<LogicalType> condition_types;
-
-	//! The indices/types of the payload columns
-	JoinProjectionColumns payload_columns;
-	//! The indices/types of the lhs columns that need to be output
-	JoinProjectionColumns lhs_output_columns;
-	//! The indices/types of the rhs columns that need to be output
-	JoinProjectionColumns rhs_output_columns;
-
-	//! Duplicate eliminated types; only used for delim_joins (i.e. correlated subqueries)
-	vector<LogicalType> delim_types;
-
-	//! Join Keys statistics (optional)
-	vector<unique_ptr<BaseStatistics>> join_stats;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-protected:
-	// CachingOperator Interface
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
-
-	//! Becomes a source when it is an external join
-	bool IsSource() const override {
-		return true;
-	}
-
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	void PrepareFinalize(ClientContext &context, GlobalSinkState &global_state) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_iejoin.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_iejoin.hpp
deleted file mode 100644
index 5c0183726..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_iejoin.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_range_join.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-//! PhysicalIEJoin represents a two inequality range join between
-//! two tables
-class PhysicalIEJoin : public PhysicalRangeJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::IE_JOIN;
-
-public:
-	PhysicalIEJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	               vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
-
-	vector<LogicalType> join_key_types;
-	vector<BoundOrderByNode> lhs_orders;
-	vector<BoundOrderByNode> rhs_orders;
-
-public:
-	// CachingOperator Interface
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-	ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const override;
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-
-private:
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	void ResolveComplexJoin(ExecutionContext &context, DataChunk &result, LocalSourceState &state) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_join.hpp
deleted file mode 100644
index 98afb8c83..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_join.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! PhysicalJoin represents the base class of the join operators
-class PhysicalJoin : public CachingPhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INVALID;
-
-public:
-	PhysicalJoin(LogicalOperator &op, PhysicalOperatorType type, JoinType join_type, idx_t estimated_cardinality);
-
-	JoinType join_type;
-
-public:
-	bool EmptyResultIfRHSIsEmpty() const;
-
-	static bool HasNullValues(DataChunk &chunk);
-	static void ConstructSemiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]);
-	static void ConstructAntiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]);
-	static void ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &left, DataChunk &result, bool found_match[],
-	                                    bool has_null);
-
-public:
-	static void BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipeline, PhysicalOperator &op,
-	                               bool build_rhs = true);
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
-	OrderPreservationType OperatorOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_left_delim_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_left_delim_join.hpp
deleted file mode 100644
index a051aa63e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_left_delim_join.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_left_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-
-namespace duckdb {
-
-//! PhysicalLeftDelimJoin represents a join where the LHS will be duplicate eliminated and pushed into a
-//! PhysicalColumnDataScan in the RHS.
-class PhysicalLeftDelimJoin : public PhysicalDelimJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LEFT_DELIM_JOIN;
-
-public:
-	PhysicalLeftDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-	                      vector<const_reference<PhysicalOperator>> delim_scans, idx_t estimated_cardinality,
-	                      optional_idx delim_idx);
-
-public:
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	void PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_nested_loop_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_nested_loop_join.hpp
deleted file mode 100644
index 85fef3ff0..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_nested_loop_join.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_nested_loop_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! PhysicalNestedLoopJoin represents a nested loop join between two tables
-class PhysicalNestedLoopJoin : public PhysicalComparisonJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::NESTED_LOOP_JOIN;
-
-public:
-	PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                       vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-protected:
-	// CachingOperator Interface
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return PropagatesBuildSide(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	static bool IsSupported(const vector<JoinCondition> &conditions, JoinType join_type);
-
-public:
-	//! Returns a list of the types of the join conditions
-	vector<LogicalType> GetJoinTypes() const;
-
-private:
-	// resolve joins that output max N elements (SEMI, ANTI, MARK)
-	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state) const;
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	OperatorResultType ResolveComplexJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                      OperatorState &state) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_piecewise_merge_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
deleted file mode 100644
index 6164f83fe..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_range_join.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-class MergeJoinGlobalState;
-
-//! PhysicalPiecewiseMergeJoin represents a piecewise merge loop join between
-//! two tables
-class PhysicalPiecewiseMergeJoin : public PhysicalRangeJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PIECEWISE_MERGE_JOIN;
-
-public:
-	PhysicalPiecewiseMergeJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left,
-	                           unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-	                           idx_t estimated_cardinality);
-
-	vector<LogicalType> join_key_types;
-	vector<BoundOrderByNode> lhs_orders;
-	vector<BoundOrderByNode> rhs_orders;
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-protected:
-	// CachingOperator Interface
-	OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return PropagatesBuildSide(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-private:
-	// resolve joins that output max N elements (SEMI, ANTI, MARK)
-	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state) const;
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	OperatorResultType ResolveComplexJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                      OperatorState &state) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_positional_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_positional_join.hpp
deleted file mode 100644
index 409229ef0..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_positional_join.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_positional_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-
-//! PhysicalPositionalJoin represents a cross product between two tables
-class PhysicalPositionalJoin : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::POSITIONAL_JOIN;
-
-public:
-	PhysicalPositionalJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-	                       unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality);
-
-public:
-	// Operator Interface
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_range_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_range_join.hpp
deleted file mode 100644
index 23b2084f5..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_range_join.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/common/sort/sort.hpp"
-
-namespace duckdb {
-
-struct GlobalSortState;
-
-//! PhysicalRangeJoin represents one or more inequality range join predicates between
-//! two tables
-class PhysicalRangeJoin : public PhysicalComparisonJoin {
-public:
-	class LocalSortedTable {
-	public:
-		LocalSortedTable(ClientContext &context, const PhysicalRangeJoin &op, const idx_t child);
-
-		void Sink(DataChunk &input, GlobalSortState &global_sort_state);
-
-		inline void Sort(GlobalSortState &global_sort_state) {
-			local_sort_state.Sort(global_sort_state, true);
-		}
-
-		//! The hosting operator
-		const PhysicalRangeJoin &op;
-		//! The local sort state
-		LocalSortState local_sort_state;
-		//! Local copy of the sorting expression executor
-		ExpressionExecutor executor;
-		//! Holds a vector of incoming sorting columns
-		DataChunk keys;
-		//! The number of NULL values
-		idx_t has_null;
-		//! The total number of rows
-		idx_t count;
-
-	private:
-		// Merge the NULLs of all non-DISTINCT predicates into the primary so they sort to the end.
-		idx_t MergeNulls(Vector &primary, const vector<JoinCondition> &conditions);
-	};
-
-	class GlobalSortedTable {
-	public:
-		GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout,
-		                  const PhysicalOperator &op);
-
-		inline idx_t Count() const {
-			return count;
-		}
-
-		inline idx_t BlockCount() const {
-			if (global_sort_state.sorted_blocks.empty()) {
-				return 0;
-			}
-			D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-			return global_sort_state.sorted_blocks[0]->radix_sorting_data.size();
-		}
-
-		inline idx_t BlockSize(idx_t i) const {
-			return global_sort_state.sorted_blocks[0]->radix_sorting_data[i]->count;
-		}
-
-		void Combine(LocalSortedTable &ltable);
-		void IntializeMatches();
-		void Print();
-
-		//! Starts the sorting process.
-		void Finalize(Pipeline &pipeline, Event &event);
-		//! Schedules tasks to merge sort the current child's data during a Finalize phase
-		void ScheduleMergeTasks(Pipeline &pipeline, Event &event);
-
-		//! The hosting operator
-		const PhysicalOperator &op;
-		GlobalSortState global_sort_state;
-		//! Whether or not the RHS has NULL values
-		atomic<idx_t> has_null;
-		//! The total number of rows in the RHS
-		atomic<idx_t> count;
-		//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-		unsafe_unique_array<bool> found_match;
-		//! Memory usage per thread
-		idx_t memory_per_thread;
-	};
-
-public:
-	PhysicalRangeJoin(LogicalComparisonJoin &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
-	                  unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-	                  idx_t estimated_cardinality);
-
-	// Projection mappings
-	using ProjectionMapping = vector<column_t>;
-	ProjectionMapping left_projection_map;
-	ProjectionMapping right_projection_map;
-
-	//!	The full set of types (left + right child)
-	vector<LogicalType> unprojected_types;
-
-public:
-	// Gather the result values and slice the payload columns to those values.
-	// Returns a buffer handle to the pinned heap block (if any)
-	static BufferHandle SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-	                                       const SelectionVector &result, const idx_t result_count,
-	                                       const idx_t left_cols = 0);
-	// Apply a tail condition to the current selection
-	static idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
-	                            const SelectionVector *sel, idx_t count, SelectionVector *true_sel);
-
-	//!	Utility to project full width internal chunks to projected results
-	void ProjectResult(DataChunk &chunk, DataChunk &result) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/join/physical_right_delim_join.hpp b/src/duckdb/src/include/duckdb/execution/operator/join/physical_right_delim_join.hpp
deleted file mode 100644
index 5393df4be..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/join/physical_right_delim_join.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_right_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-
-namespace duckdb {
-
-//! PhysicalRightDelimJoin represents a join where the RHS will be duplicate eliminated and pushed into a
-//! PhysicalColumnDataScan in the LHS.
-class PhysicalRightDelimJoin : public PhysicalDelimJoin {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RIGHT_DELIM_JOIN;
-
-public:
-	PhysicalRightDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-	                       vector<const_reference<PhysicalOperator>> delim_scans, idx_t estimated_cardinality,
-	                       optional_idx delim_idx);
-
-public:
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	void PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/order/physical_order.hpp b/src/duckdb/src/include/duckdb/execution/operator/order/physical_order.hpp
deleted file mode 100644
index b62fea5dd..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/order/physical_order.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/order/physical_order.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-
-class OrderGlobalSinkState;
-
-//! Physically re-orders the input data
-class PhysicalOrder : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ORDER_BY;
-
-public:
-	PhysicalOrder(vector<LogicalType> types, vector<BoundOrderByNode> orders, vector<idx_t> projections,
-	              idx_t estimated_cardinality);
-
-	//! Input data
-	vector<BoundOrderByNode> orders;
-	vector<idx_t> projections;
-
-public:
-	// Source interface
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-	OperatorPartitionData GetPartitionData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	                                       LocalSourceState &lstate,
-	                                       const OperatorPartitionInfo &partition_info) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-	bool ParallelSource() const override {
-		return true;
-	}
-
-	bool SupportsPartitioning(const OperatorPartitionInfo &partition_info) const override {
-		if (partition_info.RequiresPartitionColumns()) {
-			return false;
-		}
-		return true;
-	}
-
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::FIXED_ORDER;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	//! Schedules tasks to merge the data during the Finalize phase
-	static void ScheduleMergeTasks(Pipeline &pipeline, Event &event, OrderGlobalSinkState &state);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/order/physical_top_n.hpp b/src/duckdb/src/include/duckdb/execution/operator/order/physical_top_n.hpp
deleted file mode 100644
index a7d5559fb..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/order/physical_top_n.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/order/physical_top_n.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-struct DynamicFilterData;
-
-//! Represents a physical ordering of the data. Note that this will not change
-//! the data but only add a selection vector.
-class PhysicalTopN : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TOP_N;
-
-public:
-	PhysicalTopN(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t limit, idx_t offset,
-	             shared_ptr<DynamicFilterData> dynamic_filter, idx_t estimated_cardinality);
-	~PhysicalTopN() override;
-
-	vector<BoundOrderByNode> orders;
-	idx_t limit;
-	idx_t offset;
-	//! Dynamic table filter (if any)
-	shared_ptr<DynamicFilterData> dynamic_filter;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::FIXED_ORDER;
-	}
-
-public:
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_memory_manager.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_memory_manager.hpp
deleted file mode 100644
index 6ae171242..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_memory_manager.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/batch_memory_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/temporary_memory_manager.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-class BatchMemoryManager : public StateWithBlockableTasks {
-public:
-	BatchMemoryManager(ClientContext &context, idx_t initial_memory_request)
-	    : context(context), unflushed_memory_usage(0), min_batch_index(0), available_memory(0),
-	      can_increase_memory(true) {
-		memory_state = TemporaryMemoryManager::Get(context).Register(context);
-		SetMemorySize(initial_memory_request);
-	}
-
-private:
-	ClientContext &context;
-	//! Temporary memory state
-	unique_ptr<TemporaryMemoryState> memory_state;
-	//! Total memory usage of unflushed rows
-	atomic<idx_t> unflushed_memory_usage;
-	//! Minimum batch size
-	atomic<idx_t> min_batch_index;
-	//! The available memory for unflushed rows
-	atomic<idx_t> available_memory;
-	//! Whether or not we can request additional memory
-	bool can_increase_memory;
-
-public:
-	void SetMemorySize(idx_t size) {
-		// request at most 1/4th of all available memory
-		idx_t total_max_memory = BufferManager::GetBufferManager(context).GetQueryMaxMemory();
-		idx_t request_cap = total_max_memory / 4;
-
-		size = MinValue<idx_t>(size, request_cap);
-		if (size <= available_memory) {
-			return;
-		}
-
-		memory_state->SetRemainingSizeAndUpdateReservation(context, size);
-		auto next_reservation = memory_state->GetReservation();
-		if (available_memory >= next_reservation) {
-			// we tried to ask for more memory but were declined
-			// stop asking for more memory
-			can_increase_memory = false;
-		}
-		available_memory = next_reservation;
-	}
-
-	void IncreaseMemory() {
-		if (!can_increase_memory) {
-			return;
-		}
-		SetMemorySize(available_memory * 2);
-	}
-
-	bool OutOfMemory(idx_t batch_index) {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-		// alternative verify - always report that we are out of memory to test this code path
-		return true;
-#else
-		if (unflushed_memory_usage >= available_memory) {
-			auto guard = Lock();
-			if (batch_index > min_batch_index) {
-				// exceeded available memory and we are not the minimum batch index- try to increase it
-				IncreaseMemory();
-				if (unflushed_memory_usage >= available_memory) {
-					// STILL out of memory
-					return true;
-				}
-			}
-		}
-		return false;
-#endif
-	}
-
-	void UpdateMinBatchIndex(idx_t current_min_batch_index) {
-		if (min_batch_index >= current_min_batch_index) {
-			return;
-		}
-		auto guard = Lock();
-		auto new_batch_index = MaxValue<idx_t>(min_batch_index, current_min_batch_index);
-		if (new_batch_index != min_batch_index) {
-			// new batch index! unblock all tasks
-			min_batch_index = new_batch_index;
-			UnblockTasks(guard);
-		}
-	}
-
-	idx_t AvailableMemory() const {
-		return available_memory;
-	}
-
-	idx_t GetUnflushedMemory() {
-		return unflushed_memory_usage;
-	}
-
-	void IncreaseUnflushedMemory(idx_t memory_increase) {
-		unflushed_memory_usage += memory_increase;
-	}
-
-	void ReduceUnflushedMemory(idx_t memory_reduction) {
-		if (unflushed_memory_usage < memory_reduction) {
-			throw InternalException("Reducing unflushed memory usage below zero!?");
-		} else {
-			unflushed_memory_usage -= memory_reduction;
-		}
-	}
-
-	bool IsMinimumBatchIndex(idx_t batch_index) {
-		return batch_index <= min_batch_index;
-	}
-
-	void FinalCheck() {
-		if (unflushed_memory_usage != 0) {
-			throw InternalException("Unflushed memory usage is not zero at finalize but %llu",
-			                        unflushed_memory_usage.load());
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_task_manager.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_task_manager.hpp
deleted file mode 100644
index 5be0d4284..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/batch_task_manager.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/batch_task_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/temporary_memory_manager.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/common/queue.hpp"
-
-namespace duckdb {
-
-template <class TASK>
-class BatchTaskManager {
-public:
-	void AddTask(unique_ptr<TASK> task) {
-		lock_guard<mutex> l(task_lock);
-		task_queue.push(std::move(task));
-	}
-
-	unique_ptr<TASK> GetTask() {
-		lock_guard<mutex> l(task_lock);
-		if (task_queue.empty()) {
-			return nullptr;
-		}
-		auto entry = std::move(task_queue.front());
-		task_queue.pop();
-		return entry;
-	}
-
-	idx_t TaskCount() {
-		lock_guard<mutex> l(task_lock);
-		return task_queue.size();
-	}
-
-private:
-	mutex task_lock;
-	//! The task queue for the batch copy to file
-	queue<unique_ptr<TASK>> task_queue;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_rejects_table.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_rejects_table.hpp
deleted file mode 100644
index 7b88e0de8..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_rejects_table.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "duckdb/storage/object_cache.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/string.hpp"
-
-namespace duckdb {
-
-struct ReadCSVData;
-class TableCatalogEntry;
-class ClientContext;
-
-class CSVRejectsTable : public ObjectCacheEntry {
-public:
-	CSVRejectsTable(string rejects_scan, string rejects_error)
-	    : count(0), scan_table(std::move(rejects_scan)), errors_table(std::move(rejects_error)) {
-	}
-	mutex write_lock;
-	string name;
-	idx_t count;
-	string scan_table;
-	string errors_table;
-
-	static shared_ptr<CSVRejectsTable> GetOrCreate(ClientContext &context, const string &rejects_scan,
-	                                               const string &rejects_error);
-
-	void InitializeTable(ClientContext &context, const ReadCSVData &options);
-	TableCatalogEntry &GetErrorsTable(ClientContext &context);
-	TableCatalogEntry &GetScansTable(ClientContext &context);
-
-	idx_t GetCurrentFileIndex(idx_t query_id);
-
-	static string ObjectType() {
-		return "csv_rejects_table_cache";
-	}
-
-	string GetObjectType() override {
-		return ObjectType();
-	}
-
-private:
-	//! Current File Index being used in the query
-	idx_t current_file_idx = 0;
-	//! Current Query ID being executed
-	idx_t current_query_id = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp
deleted file mode 100644
index 56f8a43a5..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/filename_pattern.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-
-namespace duckdb {
-struct FixedRawBatchData;
-
-class PhysicalBatchCopyToFile : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BATCH_COPY_TO_FILE;
-
-public:
-	PhysicalBatchCopyToFile(vector<LogicalType> types, CopyFunction function, unique_ptr<FunctionData> bind_data,
-	                        idx_t estimated_cardinality);
-
-	CopyFunction function;
-	unique_ptr<FunctionData> bind_data;
-	string file_path;
-	bool use_tmp_file;
-	CopyFunctionReturnType return_type;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkNextBatchType NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const override;
-
-	OperatorPartitionInfo RequiredPartitionInfo() const override {
-		return OperatorPartitionInfo::BatchIndex();
-	}
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	void AddLocalBatch(ClientContext &context, GlobalSinkState &gstate, LocalSinkState &state) const;
-	void AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index,
-	                     unique_ptr<FixedRawBatchData> collection) const;
-	void RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index,
-	                        bool final = false) const;
-	void FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p) const;
-	bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const;
-	void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const;
-	SinkFinalizeType FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp
deleted file mode 100644
index 57c349280..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_batch_insert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/persistent/physical_insert.hpp"
-
-namespace duckdb {
-
-class PhysicalBatchInsert : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BATCH_INSERT;
-
-public:
-	//! INSERT INTO
-	PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry &table,
-	                    physical_index_vector_t<idx_t> column_index_map, vector<unique_ptr<Expression>> bound_defaults,
-	                    vector<unique_ptr<BoundConstraint>> bound_constraints, idx_t estimated_cardinality);
-	//! CREATE TABLE AS
-	PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
-	                    idx_t estimated_cardinality);
-
-	//! The map from insert column index to table column index
-	physical_index_vector_t<idx_t> column_index_map;
-	//! The table to insert into
-	optional_ptr<TableCatalogEntry> insert_table;
-	//! The insert types
-	vector<LogicalType> insert_types;
-	//! The default expressions of the columns for which no value is provided
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! The bound constraints for the table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	//! Table schema, in case of CREATE TABLE AS
-	optional_ptr<SchemaCatalogEntry> schema;
-	//! Create table info, in case of CREATE TABLE AS
-	unique_ptr<BoundCreateTableInfo> info;
-	// Which action to perform on conflict
-	OnConflictAction action_type;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkNextBatchType NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	OperatorPartitionInfo RequiredPartitionInfo() const override {
-		return OperatorPartitionInfo::BatchIndex();
-	}
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-private:
-	bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const;
-	void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_database.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_database.hpp
deleted file mode 100644
index 8110c7072..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_database.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_copy_database.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/operator/logical_copy_database.hpp"
-
-namespace duckdb {
-
-class PhysicalCopyDatabase : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::COPY_DATABASE;
-
-public:
-	PhysicalCopyDatabase(vector<LogicalType> types, idx_t estimated_cardinality, unique_ptr<CopyDatabaseInfo> info_p);
-	~PhysicalCopyDatabase() override;
-
-	unique_ptr<CopyDatabaseInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp
deleted file mode 100644
index 6201e671b..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_copy_to_file.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/copy_overwrite_mode.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/filename_pattern.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-
-namespace duckdb {
-
-//! Copy the contents of a query into a table
-class PhysicalCopyToFile : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::COPY_TO_FILE;
-
-public:
-	PhysicalCopyToFile(vector<LogicalType> types, CopyFunction function, unique_ptr<FunctionData> bind_data,
-	                   idx_t estimated_cardinality);
-
-	CopyFunction function;
-	unique_ptr<FunctionData> bind_data;
-	string file_path;
-	bool use_tmp_file;
-	FilenamePattern filename_pattern;
-	string file_extension;
-	CopyOverwriteMode overwrite_mode;
-	bool parallel;
-	bool per_thread_output;
-	optional_idx file_size_bytes;
-	bool rotate;
-	CopyFunctionReturnType return_type;
-
-	bool partition_output;
-	bool write_partition_columns;
-	vector<idx_t> partition_columns;
-	vector<string> names;
-	vector<LogicalType> expected_types;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool SinkOrderDependent() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return per_thread_output || partition_output || parallel;
-	}
-
-	static void MoveTmpFile(ClientContext &context, const string &tmp_file_path);
-	static string GetNonTmpFile(ClientContext &context, const string &tmp_file_path);
-
-	string GetTrimmedPath(ClientContext &context) const;
-
-private:
-	unique_ptr<GlobalFunctionData> CreateFileState(ClientContext &context, GlobalSinkState &sink,
-	                                               StorageLockKey &global_lock) const;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_delete.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_delete.hpp
deleted file mode 100644
index e9c9c24c0..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_delete.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_delete.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-
-namespace duckdb {
-class DataTable;
-
-//! Physically delete data from a table
-class PhysicalDelete : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DELETE_OPERATOR;
-
-public:
-	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
-	               vector<unique_ptr<BoundConstraint>> bound_constraints, idx_t row_id_index,
-	               idx_t estimated_cardinality, bool return_chunk);
-
-	TableCatalogEntry &tableref;
-	DataTable &table;
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	idx_t row_id_index;
-	bool return_chunk;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_export.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_export.hpp
deleted file mode 100644
index fd7f4981f..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_export.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_export.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <utility>
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
-
-namespace duckdb {
-
-struct ExportEntries {
-	vector<reference<CatalogEntry>> schemas;
-	vector<reference<CatalogEntry>> custom_types;
-	vector<reference<CatalogEntry>> sequences;
-	vector<reference<CatalogEntry>> tables;
-	vector<reference<CatalogEntry>> views;
-	vector<reference<CatalogEntry>> indexes;
-	vector<reference<CatalogEntry>> macros;
-};
-
-//! Parse a file from disk using a specified copy function and return the set of chunks retrieved from the file
-class PhysicalExport : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPORT;
-
-public:
-	PhysicalExport(vector<LogicalType> types, CopyFunction function, unique_ptr<CopyInfo> info,
-	               idx_t estimated_cardinality, unique_ptr<BoundExportData> exported_tables);
-
-	//! The copy function to use to read the file
-	CopyFunction function;
-	//! The binding info containing the set of options for reading the file
-	unique_ptr<CopyInfo> info;
-	//! The table info for each table that will be exported
-	unique_ptr<BoundExportData> exported_tables;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-	static void ExtractEntries(ClientContext &context, vector<reference<SchemaCatalogEntry>> &schemas,
-	                           ExportEntries &result);
-	static catalog_entry_vector_t GetNaiveExportOrder(ClientContext &context, Catalog &catalog);
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool ParallelSink() const override {
-		return true;
-	}
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp
deleted file mode 100644
index ccb113c4f..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_insert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/common/index_vector.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/storage/table/delete_state.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class InsertGlobalState : public GlobalSinkState {
-public:
-	explicit InsertGlobalState(ClientContext &context, const vector<LogicalType> &return_types, DuckTableEntry &table);
-
-public:
-	mutex lock;
-	DuckTableEntry &table;
-	idx_t insert_count;
-	bool initialized;
-	LocalAppendState append_state;
-	ColumnDataCollection return_collection;
-};
-
-class InsertLocalState : public LocalSinkState {
-public:
-public:
-	InsertLocalState(ClientContext &context, const vector<LogicalType> &types,
-	                 const vector<unique_ptr<Expression>> &bound_defaults,
-	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-
-public:
-	ConstraintState &GetConstraintState(DataTable &table, TableCatalogEntry &table_ref);
-	TableDeleteState &GetDeleteState(DataTable &table, TableCatalogEntry &table_ref, ClientContext &context);
-
-public:
-	//! The chunk that ends up getting inserted
-	DataChunk insert_chunk;
-	//! The chunk containing the tuples that become an update (if DO UPDATE)
-	DataChunk update_chunk;
-	ExpressionExecutor default_executor;
-	TableAppendState local_append_state;
-	unique_ptr<RowGroupCollection> local_collection;
-	optional_ptr<OptimisticDataWriter> writer;
-	// Rows that have been updated by a DO UPDATE conflict
-	unordered_set<row_t> updated_rows;
-	idx_t update_count = 0;
-	unique_ptr<ConstraintState> constraint_state;
-	const vector<unique_ptr<BoundConstraint>> &bound_constraints;
-	//! The delete state for ON CONFLICT handling that is rewritten into DELETE + INSERT.
-	unique_ptr<TableDeleteState> delete_state;
-	//! The append chunk for ON CONFLICT handling that is rewritting into DELETE + INSERT.
-	DataChunk append_chunk;
-};
-
-//! Physically insert a set of data into a table
-class PhysicalInsert : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INSERT;
-
-public:
-	//! INSERT INTO
-	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry &table, physical_index_vector_t<idx_t> column_index_map,
-	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<BoundConstraint>> bound_constraints,
-	               vector<unique_ptr<Expression>> set_expressions, vector<PhysicalIndex> set_columns,
-	               vector<LogicalType> set_types, idx_t estimated_cardinality, bool return_chunk, bool parallel,
-	               OnConflictAction action_type, unique_ptr<Expression> on_conflict_condition,
-	               unique_ptr<Expression> do_update_condition, unordered_set<column_t> on_conflict_filter,
-	               vector<column_t> columns_to_fetch, bool update_is_del_and_insert);
-	//! CREATE TABLE AS
-	PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
-	               idx_t estimated_cardinality, bool parallel);
-
-	//! The map from insert column index to table column index
-	physical_index_vector_t<idx_t> column_index_map;
-	//! The table to insert into
-	optional_ptr<TableCatalogEntry> insert_table;
-	//! The insert types
-	vector<LogicalType> insert_types;
-	//! The default expressions of the columns for which no value is provided
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! The bound constraints for the table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	//! If the returning statement is present, return the whole chunk
-	bool return_chunk;
-	//! Table schema, in case of CREATE TABLE AS
-	optional_ptr<SchemaCatalogEntry> schema;
-	//! Create table info, in case of CREATE TABLE AS
-	unique_ptr<BoundCreateTableInfo> info;
-	//! Whether or not the INSERT can be executed in parallel
-	//! This insert is not order preserving if executed in parallel
-	bool parallel;
-	// Which action to perform on conflict
-	OnConflictAction action_type;
-
-	// The DO UPDATE set expressions, if 'action_type' is UPDATE
-	vector<unique_ptr<Expression>> set_expressions;
-	// Which columns are targeted by the set expressions
-	vector<PhysicalIndex> set_columns;
-	// The types of the columns targeted by a SET expression
-	vector<LogicalType> set_types;
-
-	// Condition for the ON CONFLICT clause
-	unique_ptr<Expression> on_conflict_condition;
-	// Condition for the DO UPDATE clause
-	unique_ptr<Expression> do_update_condition;
-	// The column ids to apply the ON CONFLICT on
-	unordered_set<column_t> conflict_target;
-	//! True, if the INSERT OR REPLACE requires delete + insert.
-	bool update_is_del_and_insert;
-
-	// Column ids from the original table to fetch
-	vector<StorageIndex> columns_to_fetch;
-	// Matching types to the column ids to fetch
-	vector<LogicalType> types_to_fetch;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return parallel;
-	}
-
-	bool SinkOrderDependent() const override {
-		return true;
-	}
-
-public:
-	static void GetInsertInfo(const BoundCreateTableInfo &info, vector<LogicalType> &insert_types,
-	                          vector<unique_ptr<Expression>> &bound_defaults);
-	static void ResolveDefaults(const TableCatalogEntry &table, DataChunk &chunk,
-	                            const physical_index_vector_t<idx_t> &column_index_map,
-	                            ExpressionExecutor &defaults_executor, DataChunk &result);
-
-protected:
-	void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
-	                                    ClientContext &client) const;
-	//! Returns the amount of updated tuples
-	void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table, Vector &row_ids,
-	                       DataChunk &result) const;
-	idx_t OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertGlobalState &gstate,
-	                         InsertLocalState &lstate) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_update.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_update.hpp
deleted file mode 100644
index d86b805e0..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_update.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_update.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-
-namespace duckdb {
-class DataTable;
-
-//! Physically update data in a table
-class PhysicalUpdate : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UPDATE;
-
-public:
-	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
-	               vector<PhysicalIndex> columns, vector<unique_ptr<Expression>> expressions,
-	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<BoundConstraint>> bound_constraints,
-	               idx_t estimated_cardinality, bool return_chunk);
-
-	TableCatalogEntry &tableref;
-	DataTable &table;
-	vector<PhysicalIndex> columns;
-	vector<unique_ptr<Expression>> expressions;
-	vector<unique_ptr<Expression>> bound_defaults;
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	bool update_is_del_and_insert;
-	//! If the returning statement is present, return the whole chunk
-	bool return_chunk;
-	//! Set to true, if we are updating an index column.
-	bool index_update;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_pivot.hpp b/src/duckdb/src/include/duckdb/execution/operator/projection/physical_pivot.hpp
deleted file mode 100644
index badb073d8..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_pivot.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_pivot.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/planner/tableref/bound_pivotref.hpp"
-
-namespace duckdb {
-
-//! PhysicalPivot implements the physical PIVOT operation
-class PhysicalPivot : public PhysicalOperator {
-public:
-	PhysicalPivot(vector<LogicalType> types, unique_ptr<PhysicalOperator> child, BoundPivotInfo bound_pivot);
-
-	BoundPivotInfo bound_pivot;
-	//! The map for pivot value -> column index
-	string_map_t<idx_t> pivot_map;
-	//! The empty aggregate values
-	vector<Value> empty_aggregates;
-
-public:
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_projection.hpp b/src/duckdb/src/include/duckdb/execution/operator/projection/physical_projection.hpp
deleted file mode 100644
index 04ecb32bf..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_projection.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_projection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class PhysicalProjection : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PROJECTION;
-
-public:
-	PhysicalProjection(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-	                   idx_t estimated_cardinality);
-
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	static unique_ptr<PhysicalOperator>
-	CreateJoinProjection(vector<LogicalType> proj_types, const vector<LogicalType> &lhs_types,
-	                     const vector<LogicalType> &rhs_types, const vector<idx_t> &left_projection_map,
-	                     const vector<idx_t> &right_projection_map, const idx_t estimated_cardinality);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp b/src/duckdb/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp
deleted file mode 100644
index f505f4166..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_tableinout_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/table_function.hpp"
-
-namespace duckdb {
-
-class PhysicalTableInOutFunction : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INOUT_FUNCTION;
-
-public:
-	PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
-	                           unique_ptr<FunctionData> bind_data_p, vector<ColumnIndex> column_ids_p,
-	                           idx_t estimated_cardinality, vector<column_t> projected_input);
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-	OperatorFinalizeResultType FinalExecute(ExecutionContext &context, DataChunk &chunk, GlobalOperatorState &gstate,
-	                                        OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresFinalExecute() const override {
-		return function.in_out_function_final;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-private:
-	//! The table function
-	TableFunction function;
-	//! Bind data of the function
-	unique_ptr<FunctionData> bind_data;
-	//! The set of column ids to fetch
-	vector<ColumnIndex> column_ids;
-	//! The set of input columns to project out
-	vector<column_t> projected_input;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_unnest.hpp b/src/duckdb/src/include/duckdb/execution/operator/projection/physical_unnest.hpp
deleted file mode 100644
index 194001353..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/projection/physical_unnest.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_unnest.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! PhysicalUnnest implements the physical UNNEST operation
-class PhysicalUnnest : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNNEST;
-
-public:
-	PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
-	               PhysicalOperatorType type = PhysicalOperatorType::UNNEST);
-
-	//! The projection list of the UNNEST
-	//! E.g. SELECT 1, UNNEST([1]), UNNEST([2, 3]); has two UNNESTs in its select_list
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-public:
-	static unique_ptr<OperatorState> GetState(ExecutionContext &context,
-	                                          const vector<unique_ptr<Expression>> &select_list);
-	//! Executes the UNNEST operator internally and emits a chunk of unnested data. If include_input is set, then
-	//! the resulting chunk also contains vectors for all non-UNNEST columns in the projection. If include_input is
-	//! not set, then the UNNEST behaves as a table function and only emits the unnested data.
-	static OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                          OperatorState &state, const vector<unique_ptr<Expression>> &select_list,
-	                                          bool include_input = true);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp b/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp
deleted file mode 100644
index 10a770538..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_column_data_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/optionally_owned_ptr.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-//! The PhysicalColumnDataScan scans a ColumnDataCollection
-class PhysicalColumnDataScan : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INVALID;
-
-public:
-	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality,
-	                       optionally_owned_ptr<ColumnDataCollection> collection);
-
-	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality,
-	                       idx_t cte_index);
-
-	//! (optionally owned) column data collection to scan
-	optionally_owned_ptr<ColumnDataCollection> collection;
-
-	idx_t cte_index;
-	optional_idx delim_index;
-
-public:
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_dummy_scan.hpp b/src/duckdb/src/include/duckdb/execution/operator/scan/physical_dummy_scan.hpp
deleted file mode 100644
index 3e20636e9..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_dummy_scan.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_dummy_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class PhysicalDummyScan : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DUMMY_SCAN;
-
-public:
-	explicit PhysicalDummyScan(vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DUMMY_SCAN, std::move(types), estimated_cardinality) {
-	}
-
-public:
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_empty_result.hpp b/src/duckdb/src/include/duckdb/execution/operator/scan/physical_empty_result.hpp
deleted file mode 100644
index 9d3b0daac..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_empty_result.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_empty_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class PhysicalEmptyResult : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EMPTY_RESULT;
-
-public:
-	explicit PhysicalEmptyResult(vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::EMPTY_RESULT, std::move(types), estimated_cardinality) {
-	}
-
-public:
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_expression_scan.hpp b/src/duckdb/src/include/duckdb/execution/operator/scan/physical_expression_scan.hpp
deleted file mode 100644
index b934bd69e..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_expression_scan.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_expression_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! The PhysicalExpressionScan scans a set of expressions
-class PhysicalExpressionScan : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPRESSION_SCAN;
-
-public:
-	PhysicalExpressionScan(vector<LogicalType> types, vector<vector<unique_ptr<Expression>>> expressions,
-	                       idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::EXPRESSION_SCAN, std::move(types), estimated_cardinality),
-	      expressions(std::move(expressions)) {
-	}
-
-	//! The set of expressions to scan
-	vector<vector<unique_ptr<Expression>>> expressions;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-public:
-	bool IsFoldable() const;
-	void EvaluateExpression(ClientContext &context, idx_t expression_idx, optional_ptr<DataChunk> child_chunk,
-	                        DataChunk &result, optional_ptr<DataChunk> temp_chunk_ptr = nullptr) const;
-
-private:
-	void EvaluateExpressionInternal(ClientContext &context, idx_t expression_idx, optional_ptr<DataChunk> child_chunk,
-	                                DataChunk &result, DataChunk &temp_chunk) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_positional_scan.hpp b/src/duckdb/src/include/duckdb/execution/operator/scan/physical_positional_scan.hpp
deleted file mode 100644
index 2a39fb239..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_positional_scan.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_positional_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-namespace duckdb {
-
-//! Represents a scan of a base table
-class PhysicalPositionalScan : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::POSITIONAL_SCAN;
-
-public:
-	//! Regular Table Scan
-	PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-	                       unique_ptr<PhysicalOperator> right);
-
-	//! The child table functions
-	vector<unique_ptr<PhysicalOperator>> child_tables;
-
-public:
-	bool Equals(const PhysicalOperator &other) const override;
-	vector<const_reference<PhysicalOperator>> GetChildren() const override;
-
-public:
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp b/src/duckdb/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp
deleted file mode 100644
index 45ac1e34c..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_table_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/common/extra_operator_info.hpp"
-#include "duckdb/common/column_index.hpp"
-
-namespace duckdb {
-
-//! Represents a scan of a base table
-class PhysicalTableScan : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TABLE_SCAN;
-
-public:
-	//! Table scan that immediately projects out filter columns that are unused in the remainder of the query plan
-	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
-	                  vector<LogicalType> returned_types, vector<ColumnIndex> column_ids, vector<idx_t> projection_ids,
-	                  vector<string> names, unique_ptr<TableFilterSet> table_filters, idx_t estimated_cardinality,
-	                  ExtraOperatorInfo extra_info, vector<Value> parameters);
-
-	//! The table function
-	TableFunction function;
-	//! Bind data of the function
-	unique_ptr<FunctionData> bind_data;
-	//! The types of ALL columns that can be returned by the table function
-	vector<LogicalType> returned_types;
-	//! The column ids used within the table function
-	vector<ColumnIndex> column_ids;
-	//! The projected-out column ids
-	vector<idx_t> projection_ids;
-	//! The names of the columns
-	vector<string> names;
-	//! The table filters
-	unique_ptr<TableFilterSet> table_filters;
-	//! Currently stores info related to filters pushed down into MultiFileLists and sample rate pushed down into the
-	//! table scan
-	ExtraOperatorInfo extra_info;
-	//! Parameters
-	vector<Value> parameters;
-	//! Contains a reference to dynamically generated table filters (through e.g. a join up in the tree)
-	shared_ptr<DynamicTableFilterSet> dynamic_filters;
-
-public:
-	string GetName() const override;
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	bool Equals(const PhysicalOperator &other) const override;
-
-public:
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-	OperatorPartitionData GetPartitionData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	                                       LocalSourceState &lstate,
-	                                       const OperatorPartitionInfo &partition_info) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	bool ParallelSource() const override;
-
-	bool SupportsPartitioning(const OperatorPartitionInfo &partition_info) const override;
-
-	ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_alter.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_alter.hpp
deleted file mode 100644
index dfa05fa72..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_alter.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_alter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalAlter represents an ALTER TABLE command
-class PhysicalAlter : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ALTER;
-
-public:
-	explicit PhysicalAlter(unique_ptr<AlterInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::ALTER, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<AlterInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_attach.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_attach.hpp
deleted file mode 100644
index 5fab731de..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_attach.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_attach.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalLoad represents an extension LOAD operation
-class PhysicalAttach : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ATTACH;
-
-public:
-	explicit PhysicalAttach(unique_ptr<AttachInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::ATTACH, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<AttachInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_art_index.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_art_index.hpp
deleted file mode 100644
index cc3178386..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_art_index.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_art_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-#include <fstream>
-
-namespace duckdb {
-
-class DuckTableEntry;
-
-//! Physical index creation operator.
-class PhysicalCreateARTIndex : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_INDEX;
-
-public:
-	PhysicalCreateARTIndex(LogicalOperator &op, TableCatalogEntry &table, const vector<column_t> &column_ids,
-	                       unique_ptr<CreateIndexInfo> info, vector<unique_ptr<Expression>> unbound_expressions,
-	                       idx_t estimated_cardinality, const bool sorted,
-	                       unique_ptr<AlterTableInfo> alter_table_info = nullptr);
-
-	//! The table to create the index for.
-	DuckTableEntry &table;
-	//! The list of column IDs of the index.
-	vector<column_t> storage_ids;
-	//! Index creation information.
-	unique_ptr<CreateIndexInfo> info;
-	//! Unbound expressions of the indexed columns.
-	vector<unique_ptr<Expression>> unbound_expressions;
-	//! True, if the pipeline sorts the index data prior to index creation.
-	const bool sorted;
-	//! Alter table information for adding indexes.
-	unique_ptr<AlterTableInfo> alter_table_info;
-
-public:
-	//! Source interface, NOP for this operator
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	//! Sink interface, thread-local sink states. Contains an index for each state.
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	//! Sink interface, global sink state. Contains the global index.
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	//! Sink for unsorted data: insert iteratively.
-	SinkResultType SinkUnsorted(OperatorSinkInput &input) const;
-	//! Sink for sorted data: build + merge.
-	SinkResultType SinkSorted(OperatorSinkInput &input) const;
-
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          OperatorSinkFinalizeInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_function.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_function.hpp
deleted file mode 100644
index e28f229aa..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_function.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalCreateFunction represents a CREATE FUNCTION command
-class PhysicalCreateFunction : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_MACRO;
-
-public:
-	explicit PhysicalCreateFunction(unique_ptr<CreateMacroInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_MACRO, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<CreateMacroInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_schema.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_schema.hpp
deleted file mode 100644
index c3b2e3950..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_schema.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_schema.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalCreateSchema represents a CREATE SCHEMA command
-class PhysicalCreateSchema : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SCHEMA;
-
-public:
-	explicit PhysicalCreateSchema(unique_ptr<CreateSchemaInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_SCHEMA, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<CreateSchemaInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_sequence.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_sequence.hpp
deleted file mode 100644
index 13a3e1da7..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_sequence.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_sequence.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalCreateSequence represents a CREATE SEQUENCE command
-class PhysicalCreateSequence : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SEQUENCE;
-
-public:
-	explicit PhysicalCreateSequence(unique_ptr<CreateSequenceInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_SEQUENCE, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<CreateSequenceInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_table.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_table.hpp
deleted file mode 100644
index 18b0339e0..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_table.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-
-namespace duckdb {
-
-//! Physically CREATE TABLE statement
-class PhysicalCreateTable : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TABLE;
-
-public:
-	PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
-	                    idx_t estimated_cardinality);
-
-	//! Schema to insert to
-	SchemaCatalogEntry &schema;
-	//! Table name to create
-	unique_ptr<BoundCreateTableInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp
deleted file mode 100644
index 1d5a5036b..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalCreateType represents a CREATE TYPE command
-class PhysicalCreateType : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TYPE;
-
-public:
-	explicit PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality);
-
-	unique_ptr<CreateTypeInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	bool IsSink() const override {
-		return !children.empty();
-	}
-
-	bool ParallelSink() const override {
-		return false;
-	}
-
-	bool SinkOrderDependent() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_view.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_view.hpp
deleted file mode 100644
index 9533ad761..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_view.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_view.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalCreateView represents a CREATE VIEW command
-class PhysicalCreateView : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_VIEW;
-
-public:
-	explicit PhysicalCreateView(unique_ptr<CreateViewInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_VIEW, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<CreateViewInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_detach.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_detach.hpp
deleted file mode 100644
index 61a05a0fc..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_detach.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_detach.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/detach_info.hpp"
-
-namespace duckdb {
-
-class PhysicalDetach : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DETACH;
-
-public:
-	explicit PhysicalDetach(unique_ptr<DetachInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DETACH, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<DetachInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_drop.hpp b/src/duckdb/src/include/duckdb/execution/operator/schema/physical_drop.hpp
deleted file mode 100644
index ac7dbb55d..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/schema/physical_drop.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_drop.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-
-namespace duckdb {
-
-//! PhysicalDrop represents a DROP [...] command
-class PhysicalDrop : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DROP;
-
-public:
-	explicit PhysicalDrop(unique_ptr<DropInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DROP, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info)) {
-	}
-
-	unique_ptr<DropInfo> info;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/set/physical_cte.hpp b/src/duckdb/src/include/duckdb/execution/operator/set/physical_cte.hpp
deleted file mode 100644
index 3ce30ce67..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/set/physical_cte.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/set/physical_cte.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class RecursiveCTEState;
-
-class PhysicalCTE : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CTE;
-
-public:
-	PhysicalCTE(string ctename, idx_t table_index, vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
-	            unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality);
-	~PhysicalCTE() override;
-
-	vector<const_reference<PhysicalOperator>> cte_scans;
-
-	shared_ptr<ColumnDataCollection> working_table;
-
-	idx_t table_index;
-	string ctename;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-
-	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool SinkOrderDependent() const override {
-		return false;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp b/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp
deleted file mode 100644
index 37292df9d..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/set/physical_recursive_cte.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class RecursiveCTEState;
-
-class PhysicalRecursiveCTE : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RECURSIVE_CTE;
-
-public:
-	PhysicalRecursiveCTE(string ctename, idx_t table_index, vector<LogicalType> types, bool union_all,
-	                     unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
-	                     idx_t estimated_cardinality);
-	~PhysicalRecursiveCTE() override;
-
-	string ctename;
-	idx_t table_index;
-
-	bool union_all;
-	shared_ptr<ColumnDataCollection> working_table;
-	shared_ptr<MetaPipeline> recursive_meta_pipeline;
-
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-
-private:
-	//! Probe Hash Table and eliminate duplicate rows
-	idx_t ProbeHT(DataChunk &chunk, RecursiveCTEState &state) const;
-
-	void ExecuteRecursivePipelines(ExecutionContext &context) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/operator/set/physical_union.hpp b/src/duckdb/src/include/duckdb/execution/operator/set/physical_union.hpp
deleted file mode 100644
index ffb87d6cd..000000000
--- a/src/duckdb/src/include/duckdb/execution/operator/set/physical_union.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/set/physical_union.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-class PhysicalUnion : public PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNION;
-
-public:
-	PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
-	              idx_t estimated_cardinality, bool allow_out_of_order);
-
-	bool allow_out_of_order;
-
-public:
-	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
-	vector<const_reference<PhysicalOperator>> GetSources() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/partition_info.hpp b/src/duckdb/src/include/duckdb/execution/partition_info.hpp
deleted file mode 100644
index 8a56f77fb..000000000
--- a/src/duckdb/src/include/duckdb/execution/partition_info.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/partition_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-enum class PartitionInfo { NONE, REQUIRES_BATCH_INDEX };
-
-struct ColumnPartitionData {
-	explicit ColumnPartitionData(Value partition_val) : min_val(partition_val), max_val(std::move(partition_val)) {
-	}
-
-	Value min_val;
-	Value max_val;
-};
-
-struct SourcePartitionInfo {
-	//! The current batch index
-	//! This is only set in case RequiresBatchIndex() is true, and the source has support for it (SupportsBatchIndex())
-	//! Otherwise this is left on INVALID_INDEX
-	//! The batch index is a globally unique, increasing index that should be used to maintain insertion order
-	//! //! in conjunction with parallelism
-	optional_idx batch_index;
-	//! The minimum batch index that any thread is currently actively reading
-	optional_idx min_batch_index;
-	//! Column partition data
-	vector<ColumnPartitionData> partition_data;
-};
-
-struct OperatorPartitionInfo {
-	OperatorPartitionInfo() = default;
-	explicit OperatorPartitionInfo(bool batch_index) : batch_index(batch_index) {
-	}
-	explicit OperatorPartitionInfo(vector<column_t> partition_columns_p)
-	    : partition_columns(std::move(partition_columns_p)) {
-	}
-
-	bool batch_index = false;
-	vector<column_t> partition_columns;
-
-	static OperatorPartitionInfo NoPartitionInfo() {
-		return OperatorPartitionInfo(false);
-	}
-	static OperatorPartitionInfo BatchIndex() {
-		return OperatorPartitionInfo(true);
-	}
-	static OperatorPartitionInfo PartitionColumns(vector<column_t> columns) {
-		return OperatorPartitionInfo(std::move(columns));
-	}
-	bool RequiresPartitionColumns() const {
-		return !partition_columns.empty();
-	}
-	bool RequiresBatchIndex() const {
-		return batch_index;
-	}
-	bool AnyRequired() const {
-		return RequiresPartitionColumns() || RequiresBatchIndex();
-	}
-};
-
-struct OperatorPartitionData {
-	explicit OperatorPartitionData(idx_t batch_index) : batch_index(batch_index) {
-	}
-
-	idx_t batch_index;
-	vector<ColumnPartitionData> partition_data;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/perfect_aggregate_hashtable.hpp b/src/duckdb/src/include/duckdb/execution/perfect_aggregate_hashtable.hpp
deleted file mode 100644
index 211c27b36..000000000
--- a/src/duckdb/src/include/duckdb/execution/perfect_aggregate_hashtable.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/perfect_aggregate_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/base_aggregate_hashtable.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-
-namespace duckdb {
-
-class PerfectAggregateHashTable : public BaseAggregateHashTable {
-public:
-	PerfectAggregateHashTable(ClientContext &context, Allocator &allocator, const vector<LogicalType> &group_types,
-	                          vector<LogicalType> payload_types_p, vector<AggregateObject> aggregate_objects,
-	                          vector<Value> group_minima, vector<idx_t> required_bits);
-	~PerfectAggregateHashTable() override;
-
-public:
-	//! Add the given data to the HT
-	void AddChunk(DataChunk &groups, DataChunk &payload);
-
-	//! Combines the target perfect aggregate HT into this one
-	void Combine(PerfectAggregateHashTable &other);
-
-	//! Scan the HT starting from the scan_position
-	void Scan(idx_t &scan_position, DataChunk &result);
-
-protected:
-	Vector addresses;
-	//! The required bits per group
-	vector<idx_t> required_bits;
-	//! The total required bits for the HT (this determines the max capacity)
-	idx_t total_required_bits;
-	//! The total amount of groups
-	idx_t total_groups;
-	//! The tuple size
-	idx_t tuple_size;
-	//! The number of grouping columns
-	idx_t grouping_columns;
-
-	// The actual pointer to the data
-	data_ptr_t data;
-	//! The owned data of the HT
-	unsafe_unique_array<data_t> owned_data;
-	//! Information on whether or not a specific group has any entries
-	unsafe_unique_array<bool> group_is_set;
-
-	//! The minimum values for each of the group columns
-	vector<Value> group_minima;
-
-	//! Reused selection vector
-	SelectionVector sel;
-
-	//! The active arena allocator used by the aggregates for their internal state
-	unique_ptr<ArenaAllocator> aggregate_allocator;
-	//! Owning arena allocators that this HT has data from
-	vector<unique_ptr<ArenaAllocator>> stored_allocators;
-
-private:
-	//! Destroy the perfect aggregate HT (called automatically by the destructor)
-	void Destroy();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/physical_operator.hpp b/src/duckdb/src/include/duckdb/execution/physical_operator.hpp
deleted file mode 100644
index 50529d594..000000000
--- a/src/duckdb/src/include/duckdb/execution/physical_operator.hpp
+++ /dev/null
@@ -1,273 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/operator_result_type.hpp"
-#include "duckdb/common/enums/physical_operator_type.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/execution/progress_data.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/execution/physical_operator_states.hpp"
-#include "duckdb/common/enums/order_preservation_type.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/execution/partition_info.hpp"
-
-namespace duckdb {
-class Event;
-class Executor;
-class PhysicalOperator;
-class Pipeline;
-class PipelineBuildState;
-class MetaPipeline;
-
-//! PhysicalOperator is the base class of the physical operators present in the
-//! execution plan
-class PhysicalOperator {
-public:
-	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INVALID;
-
-public:
-	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
-	    : type(type), types(std::move(types)), estimated_cardinality(estimated_cardinality) {
-	}
-
-	virtual ~PhysicalOperator() {
-	}
-
-	//! The physical operator type
-	PhysicalOperatorType type;
-	//! The set of children of the operator
-	vector<unique_ptr<PhysicalOperator>> children;
-	//! The types returned by this physical operator
-	vector<LogicalType> types;
-	//! The estimated cardinality of this physical operator
-	idx_t estimated_cardinality;
-
-	//! The global sink state of this operator
-	unique_ptr<GlobalSinkState> sink_state;
-	//! The global state of this operator
-	unique_ptr<GlobalOperatorState> op_state;
-	//! Lock for (re)setting any of the operator states
-	mutex lock;
-
-public:
-	virtual string GetName() const;
-	virtual InsertionOrderPreservingMap<string> ParamsToString() const {
-		return InsertionOrderPreservingMap<string>();
-	}
-	static void SetEstimatedCardinality(InsertionOrderPreservingMap<string> &result, idx_t estimated_cardinality);
-	virtual string ToString(ExplainFormat format = ExplainFormat::DEFAULT) const;
-	void Print() const;
-	virtual vector<const_reference<PhysicalOperator>> GetChildren() const;
-
-	//! Return a vector of the types that will be returned by this operator
-	const vector<LogicalType> &GetTypes() const {
-		return types;
-	}
-
-	virtual bool Equals(const PhysicalOperator &other) const {
-		return false;
-	}
-
-	//! Functions to help decide how to set up pipeline dependencies
-	idx_t EstimatedThreadCount() const;
-	bool CanSaturateThreads(ClientContext &context) const;
-
-	virtual void Verify();
-
-public:
-	// Operator interface
-	virtual unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const;
-	virtual unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const;
-	virtual OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const;
-	virtual OperatorFinalizeResultType FinalExecute(ExecutionContext &context, DataChunk &chunk,
-	                                                GlobalOperatorState &gstate, OperatorState &state) const;
-
-	virtual bool ParallelOperator() const {
-		return false;
-	}
-
-	virtual bool RequiresFinalExecute() const {
-		return false;
-	}
-
-	//! The influence the operator has on order (insertion order means no influence)
-	virtual OrderPreservationType OperatorOrder() const {
-		return OrderPreservationType::INSERTION_ORDER;
-	}
-
-public:
-	// Source interface
-	virtual unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                         GlobalSourceState &gstate) const;
-	virtual unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const;
-	virtual SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const;
-
-	virtual OperatorPartitionData GetPartitionData(ExecutionContext &context, DataChunk &chunk,
-	                                               GlobalSourceState &gstate, LocalSourceState &lstate,
-	                                               const OperatorPartitionInfo &partition_info) const;
-
-	virtual bool IsSource() const {
-		return false;
-	}
-
-	virtual bool ParallelSource() const {
-		return false;
-	}
-
-	virtual bool SupportsPartitioning(const OperatorPartitionInfo &partition_info) const {
-		if (partition_info.AnyRequired()) {
-			return false;
-		}
-		return true;
-	}
-
-	//! The type of order emitted by the operator (as a source)
-	virtual OrderPreservationType SourceOrder() const {
-		return OrderPreservationType::INSERTION_ORDER;
-	}
-
-	//! Returns the current progress percentage, or a negative value if progress bars are not supported
-	virtual ProgressData GetProgress(ClientContext &context, GlobalSourceState &gstate) const;
-
-	//! Returns the current progress percentage, or a negative value if progress bars are not supported
-	virtual ProgressData GetSinkProgress(ClientContext &context, GlobalSinkState &gstate,
-	                                     const ProgressData source_progress) const {
-		return source_progress;
-	}
-
-public:
-	// Sink interface
-
-	//! The sink method is called constantly with new input, as long as new input is available. Note that this method
-	//! CAN be called in parallel, proper locking is needed when accessing dat
-	//! a inside the GlobalSinkState.
-	virtual SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
-	//! The combine is called when a single thread has completed execution of its part of the pipeline, it is the final
-	//! time that a specific LocalSinkState is accessible. This method can be called in parallel while other Sink() or
-	//! Combine() calls are active on the same GlobalSinkState.
-	virtual SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const;
-	//! (optional) function that will be called before Finalize
-	//! For now, its only use is to to communicate memory usage in multi-join pipelines through TemporaryMemoryManager
-	virtual void PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const;
-	//! The finalize is called when ALL threads are finished execution. It is called only once per pipeline, and is
-	//! entirely single threaded.
-	//! If Finalize returns SinkResultType::Finished, the sink is marked as finished
-	virtual SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                                  OperatorSinkFinalizeInput &input) const;
-	//! For sinks with RequiresBatchIndex set to true, when a new batch starts being processed this method is called
-	//! This allows flushing of the current batch (e.g. to disk)
-	virtual SinkNextBatchType NextBatch(ExecutionContext &context, OperatorSinkNextBatchInput &input) const;
-
-	virtual unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const;
-	virtual unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const;
-
-	//! The maximum amount of memory the operator should use per thread.
-	static idx_t GetMaxThreadMemory(ClientContext &context);
-
-	//! Whether operator caching is allowed in the current execution context
-	static bool OperatorCachingAllowed(ExecutionContext &context);
-
-	virtual bool IsSink() const {
-		return false;
-	}
-
-	virtual bool ParallelSink() const {
-		return false;
-	}
-
-	virtual OperatorPartitionInfo RequiredPartitionInfo() const {
-		return OperatorPartitionInfo::NoPartitionInfo();
-	}
-
-	//! Whether or not the sink operator depends on the order of the input chunks
-	//! If this is set to true, we cannot do things like caching intermediate vectors
-	virtual bool SinkOrderDependent() const {
-		return false;
-	}
-
-public:
-	// Pipeline construction
-	virtual vector<const_reference<PhysicalOperator>> GetSources() const;
-	bool AllSourcesSupportBatchIndex() const;
-
-	virtual void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (TARGET::TYPE != PhysicalOperatorType::INVALID && type != TARGET::TYPE) {
-			throw InternalException("Failed to cast physical operator to type - physical operator type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (TARGET::TYPE != PhysicalOperatorType::INVALID && type != TARGET::TYPE) {
-			throw InternalException("Failed to cast physical operator to type - physical operator type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//! Contains state for the CachingPhysicalOperator
-class CachingOperatorState : public OperatorState {
-public:
-	~CachingOperatorState() override {
-	}
-
-	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-	}
-
-	unique_ptr<DataChunk> cached_chunk;
-	bool initialized = false;
-	//! Whether or not the chunk can be cached
-	bool can_cache_chunk = false;
-};
-
-//! Base class that caches output from child Operator class. Note that Operators inheriting from this class should also
-//! inherit their state class from the CachingOperatorState.
-class CachingPhysicalOperator : public PhysicalOperator {
-public:
-	static constexpr const idx_t CACHE_THRESHOLD = 64;
-	CachingPhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality);
-
-	bool caching_supported;
-
-public:
-	//! This Execute will prevent small chunks from entering the pipeline, buffering them until a bigger chunk is
-	//! created.
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const final;
-	//! FinalExecute is used here to send out the remainder of the chunk (< STANDARD_VECTOR_SIZE) that we still had
-	//! cached.
-	OperatorFinalizeResultType FinalExecute(ExecutionContext &context, DataChunk &chunk, GlobalOperatorState &gstate,
-	                                        OperatorState &state) const final;
-
-	bool RequiresFinalExecute() const final {
-		return caching_supported;
-	}
-
-protected:
-	//! Child classes need to implement the ExecuteInternal method instead of the Execute
-	virtual OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                           GlobalOperatorState &gstate, OperatorState &state) const = 0;
-
-private:
-	bool CanCacheType(const LogicalType &type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp b/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp
deleted file mode 100644
index 9c0d6df1f..000000000
--- a/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp
+++ /dev/null
@@ -1,182 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_operator_states.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/operator_result_type.hpp"
-#include "duckdb/common/enums/physical_operator_type.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/execution/partition_info.hpp"
-
-namespace duckdb {
-class Event;
-class Executor;
-class PhysicalOperator;
-class Pipeline;
-class PipelineBuildState;
-class MetaPipeline;
-class InterruptState;
-
-// LCOV_EXCL_START
-class OperatorState {
-public:
-	virtual ~OperatorState() {
-	}
-
-	virtual void Finalize(const PhysicalOperator &op, ExecutionContext &context) {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class GlobalOperatorState {
-public:
-	virtual ~GlobalOperatorState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class GlobalSinkState : public StateWithBlockableTasks {
-public:
-	GlobalSinkState() : state(SinkFinalizeType::READY) {
-	}
-	virtual ~GlobalSinkState() {
-	}
-
-	SinkFinalizeType state;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-	virtual idx_t MaxThreads(idx_t source_max_threads) {
-		return source_max_threads;
-	}
-};
-
-class LocalSinkState {
-public:
-	virtual ~LocalSinkState() {
-	}
-
-	//! Source partition info
-	SourcePartitionInfo partition_info;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class GlobalSourceState : public StateWithBlockableTasks {
-public:
-	virtual ~GlobalSourceState() {
-	}
-
-	virtual idx_t MaxThreads() {
-		return 1;
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class LocalSourceState {
-public:
-	virtual ~LocalSourceState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct OperatorSinkInput {
-	GlobalSinkState &global_state;
-	LocalSinkState &local_state;
-	InterruptState &interrupt_state;
-};
-
-struct OperatorSourceInput {
-	GlobalSourceState &global_state;
-	LocalSourceState &local_state;
-	InterruptState &interrupt_state;
-};
-
-struct OperatorSinkCombineInput {
-	GlobalSinkState &global_state;
-	LocalSinkState &local_state;
-	InterruptState &interrupt_state;
-};
-
-struct OperatorSinkFinalizeInput {
-	GlobalSinkState &global_state;
-	InterruptState &interrupt_state;
-};
-
-struct OperatorSinkNextBatchInput {
-	GlobalSinkState &global_state;
-	LocalSinkState &local_state;
-	InterruptState &interrupt_state;
-};
-
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp b/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp
deleted file mode 100644
index 51797f589..000000000
--- a/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_plan_generator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_tokens.hpp"
-#include "duckdb/planner/joinside.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-class ClientContext;
-class ColumnDataCollection;
-
-//! The physical plan generator generates a physical execution plan from a
-//! logical query plan
-class PhysicalPlanGenerator {
-public:
-	explicit PhysicalPlanGenerator(ClientContext &context);
-	~PhysicalPlanGenerator();
-
-	LogicalDependencyList dependencies;
-	//! Recursive CTEs require at least one ChunkScan, referencing the working_table.
-	//! This data structure is used to establish it.
-	unordered_map<idx_t, shared_ptr<ColumnDataCollection>> recursive_cte_tables;
-	//! Materialized CTE ids must be collected.
-	unordered_map<idx_t, vector<const_reference<PhysicalOperator>>> materialized_ctes;
-
-public:
-	//! Creates a plan from the logical operator. This involves resolving column bindings and generating physical
-	//! operator nodes.
-	unique_ptr<PhysicalOperator> CreatePlan(unique_ptr<LogicalOperator> logical);
-
-	//! Whether or not we can (or should) use a batch-index based operator for executing the given sink
-	static bool UseBatchIndex(ClientContext &context, PhysicalOperator &plan);
-	//! Whether or not we should preserve insertion order for executing the given sink
-	static bool PreserveInsertionOrder(ClientContext &context, PhysicalOperator &plan);
-
-protected:
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalOperator &op);
-
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAggregate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAnyJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalColumnDataGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalComparisonJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCopyDatabase &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateTable &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateIndex &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateSecret &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCrossProduct &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelete &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDistinct &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDummyScan &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalEmptyResult &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExpressionGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExport &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalFilter &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimit &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalOrder &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalTopN &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPositionalJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalProjection &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalInsert &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCopyToFile &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExplain &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSetOperation &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalUpdate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPrepare &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalWindow &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExecute &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPragma &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSample &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalReset &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSimple &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalVacuum &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalUnnest &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalMaterializedCTE &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPivot &op);
-
-	unique_ptr<PhysicalOperator> PlanAsOfJoin(LogicalComparisonJoin &op);
-	unique_ptr<PhysicalOperator> PlanComparisonJoin(LogicalComparisonJoin &op);
-	unique_ptr<PhysicalOperator> PlanDelimJoin(LogicalComparisonJoin &op);
-	unique_ptr<PhysicalOperator> ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
-	                                                         vector<unique_ptr<Expression>> &expressions,
-	                                                         vector<unique_ptr<Expression>> &groups);
-
-private:
-	bool PreserveInsertionOrder(PhysicalOperator &plan);
-	bool UseBatchIndex(PhysicalOperator &plan);
-
-public:
-	idx_t delim_index = 0;
-
-private:
-	ClientContext &context;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/progress_data.hpp b/src/duckdb/src/include/duckdb/execution/progress_data.hpp
deleted file mode 100644
index 1d234d653..000000000
--- a/src/duckdb/src/include/duckdb/execution/progress_data.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/progress_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-
-namespace duckdb {
-
-struct ProgressData {
-	double done = 0.0;
-	double total = 0.0;
-	bool invalid = false;
-
-public:
-	double ProgressDone() const {
-		// ProgressDone requires a valid state
-		D_ASSERT(IsValid());
-
-		return done / total;
-	}
-
-	void Add(const ProgressData &other) {
-		// Add is unchecked, propagating invalid
-		done += other.done;
-		total += other.total;
-		invalid = invalid || other.invalid;
-	}
-	void Normalize(const double target = 1.0) {
-		// Normalize checks only `target`, propagating invalid
-		D_ASSERT(target > 0.0);
-		if (IsValid()) {
-			if (total > 0.0) {
-				done /= total;
-			}
-			total = 1.0;
-			done *= target;
-			total *= target;
-		} else {
-			SetInvalid();
-		}
-	}
-	void SetInvalid() {
-		invalid = true;
-		done = 0.0;
-		total = 1.0;
-	}
-	bool IsValid() const {
-		return (!invalid) && (done >= 0.0) && (done <= total) && (total >= 0.0);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/radix_partitioned_hashtable.hpp b/src/duckdb/src/include/duckdb/execution/radix_partitioned_hashtable.hpp
deleted file mode 100644
index b14ebb173..000000000
--- a/src/duckdb/src/include/duckdb/execution/radix_partitioned_hashtable.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/radix_partitioned_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/execution/progress_data.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-
-namespace duckdb {
-
-class GroupedAggregateHashTable;
-struct AggregatePartition;
-
-class RadixPartitionedHashTable {
-public:
-	RadixPartitionedHashTable(GroupingSet &grouping_set, const GroupedAggregateData &op);
-	unique_ptr<GroupedAggregateHashTable> CreateHT(ClientContext &context, const idx_t capacity,
-	                                               const idx_t radix_bits) const;
-
-public:
-	GroupingSet &grouping_set;
-	//! The indices specified in the groups_count that do not appear in the grouping_set
-	unsafe_vector<idx_t> null_groups;
-	const GroupedAggregateData &op;
-	vector<LogicalType> group_types;
-	//! The GROUPING values that belong to this hash table
-	vector<Value> grouping_values;
-
-public:
-	//! Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const;
-
-	void Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input, DataChunk &aggregate_input_chunk,
-	          const unsafe_vector<idx_t> &filter) const;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const;
-	void Finalize(ClientContext &context, GlobalSinkState &gstate) const;
-
-public:
-	//! Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const;
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context) const;
-
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, GlobalSinkState &sink,
-	                         OperatorSourceInput &input) const;
-
-	ProgressData GetProgress(ClientContext &context, GlobalSinkState &sink_p, GlobalSourceState &gstate) const;
-
-	const TupleDataLayout &GetLayout() const;
-	idx_t MaxThreads(GlobalSinkState &sink) const;
-	static void SetMultiScan(GlobalSinkState &sink);
-
-private:
-	void SetGroupingValues();
-	void PopulateGroupChunk(DataChunk &group_chunk, DataChunk &input_chunk) const;
-
-	TupleDataLayout layout;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/reservoir_sample.hpp b/src/duckdb/src/include/duckdb/execution/reservoir_sample.hpp
deleted file mode 100644
index b794328bb..000000000
--- a/src/duckdb/src/include/duckdb/execution/reservoir_sample.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/reservoir_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-
-#include "duckdb/common/queue.hpp"
-
-// Originally intended to be the vector size, but in order to run on
-// vector size = 2, we had to change it.
-#define FIXED_SAMPLE_SIZE 2048
-
-namespace duckdb {
-
-enum class SampleType : uint8_t { BLOCKING_SAMPLE = 0, RESERVOIR_SAMPLE = 1, RESERVOIR_PERCENTAGE_SAMPLE = 2 };
-
-enum class SamplingState : uint8_t { RANDOM = 0, RESERVOIR = 1 };
-
-class ReservoirRNG : public RandomEngine {
-public:
-	// return type must be called result type to be a valid URNG
-	typedef uint32_t result_type;
-
-	explicit ReservoirRNG(int64_t seed) : RandomEngine(seed) {};
-
-	result_type operator()() {
-		return NextRandomInteger();
-	};
-
-	static constexpr result_type min() {
-		return NumericLimits<result_type>::Minimum();
-	};
-	static constexpr result_type max() {
-		return NumericLimits<result_type>::Maximum();
-	};
-};
-
-//! Resevoir sampling is based on the 2005 paper "Weighted Random Sampling" by Efraimidis and Spirakis
-class BaseReservoirSampling {
-public:
-	explicit BaseReservoirSampling(int64_t seed);
-	BaseReservoirSampling();
-
-	void InitializeReservoirWeights(idx_t cur_size, idx_t sample_size);
-
-	void SetNextEntry();
-
-	void ReplaceElementWithIndex(idx_t entry_index, double with_weight, bool pop = true);
-	void ReplaceElement(double with_weight = -1);
-
-	void UpdateMinWeightThreshold();
-
-	//! Go from the naive sampling to the reservoir sampling
-	//! Naive samping will not collect weights, but when we serialize
-	//! we need to serialize weights again.
-	void FillWeights(SelectionVector &sel, idx_t &sel_size);
-
-	unique_ptr<BaseReservoirSampling> Copy();
-
-	//! The random generator
-	ReservoirRNG random;
-
-	//! The next element to sample
-	idx_t next_index_to_sample;
-	//! The reservoir threshold of the current min entry
-	double min_weight_threshold;
-	//! The reservoir index of the current min entry
-	idx_t min_weighted_entry_index;
-	//! The current count towards next index (i.e. we will replace an entry in next_index - current_count tuples)
-	//! The number of entries "seen" before choosing one that will go in our reservoir sample.
-	idx_t num_entries_to_skip_b4_next_sample;
-	//! when collecting a sample in parallel, we want to know how many values each thread has seen
-	//! so we can collect the samples from the thread local states in a uniform manner
-	idx_t num_entries_seen_total;
-	//! Priority queue of [random element, index] for each of the elements in the sample
-	std::priority_queue<std::pair<double, idx_t>> reservoir_weights;
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<BaseReservoirSampling> Deserialize(Deserializer &deserializer);
-
-	static double GetMinWeightFromTuplesSeen(idx_t rows_seen_total);
-	// static unordered_map<idx_t, double> tuples_to_min_weight_map;
-	// Blocking sample is a virtual class. It should be allowed to see the weights and
-	// of tuples in the sample. The blocking sample can then easily maintain statisitcal properties
-	// from the sample point of view.
-	friend class BlockingSample;
-};
-
-class BlockingSample {
-public:
-	static constexpr const SampleType TYPE = SampleType::BLOCKING_SAMPLE;
-
-	unique_ptr<BaseReservoirSampling> base_reservoir_sample;
-	//! The sample type
-	SampleType type;
-	//! has the sample been destroyed due to updates to the referenced table
-	bool destroyed;
-
-public:
-	explicit BlockingSample(int64_t seed = -1)
-	    : base_reservoir_sample(make_uniq<BaseReservoirSampling>(seed)), type(SampleType::BLOCKING_SAMPLE),
-	      destroyed(false) {
-	}
-	virtual ~BlockingSample() {
-	}
-
-	//! Add a chunk of data to the sample
-	virtual void AddToReservoir(DataChunk &input) = 0;
-	virtual unique_ptr<BlockingSample> Copy() const = 0;
-	virtual void Finalize() = 0;
-	virtual void Destroy();
-
-	//! Fetches a chunk from the sample. destroy = true should only be used when
-	//! querying from a sample defined in a query and not a duckdb_table_sample.
-	virtual unique_ptr<DataChunk> GetChunk() = 0;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
-
-	//! Helper functions needed to merge two reservoirs while respecting weights of sampled rows
-	std::pair<double, idx_t> PopFromWeightQueue();
-	double GetMinWeightThreshold();
-	idx_t GetPriorityQueueSize();
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE && TARGET::TYPE != SampleType::BLOCKING_SAMPLE) {
-			throw InternalException("Failed to cast sample to type - sample type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE && TARGET::TYPE != SampleType::BLOCKING_SAMPLE) {
-			throw InternalException("Failed to cast sample to type - sample type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class ReservoirChunk {
-public:
-	ReservoirChunk() {
-	}
-
-	DataChunk chunk;
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<ReservoirChunk> Deserialize(Deserializer &deserializer);
-
-	unique_ptr<ReservoirChunk> Copy() const;
-};
-
-struct SelectionVectorHelper {
-	SelectionVector sel;
-	uint32_t size;
-};
-
-class ReservoirSample : public BlockingSample {
-public:
-	static constexpr const SampleType TYPE = SampleType::RESERVOIR_SAMPLE;
-
-	constexpr static idx_t FIXED_SAMPLE_SIZE_MULTIPLIER = 10;
-	constexpr static idx_t FAST_TO_SLOW_THRESHOLD = 60;
-
-	// If the table has less than 204800 rows, this is the percentage
-	// of values we save when serializing/returning a sample.
-	constexpr static double SAVE_PERCENTAGE = 0.01;
-
-	ReservoirSample(Allocator &allocator, idx_t sample_count, int64_t seed = 1);
-	explicit ReservoirSample(idx_t sample_count, unique_ptr<ReservoirChunk> = nullptr);
-
-	//! methods used to help with serializing and deserializing
-	void EvictOverBudgetSamples();
-	void ExpandSerializedSample();
-
-	SamplingState GetSamplingState() const;
-
-	//! Vacuum the Reservoir Sample so it throws away tuples that are not in the
-	//! reservoir weights or in the selection vector
-	void Vacuum();
-
-	//! Transform To sample based on reservoir sampling paper
-	void ConvertToReservoirSample();
-
-	//! Get the capactiy of the data chunk reserved for storing samples
-	idx_t GetReservoirChunkCapacity() const;
-
-	//! If for_serialization=true then the sample_chunk is not padded with extra spaces for
-	//! future sampling values
-	unique_ptr<BlockingSample> Copy() const override;
-
-	//! create the first chunk called by AddToReservoir()
-	idx_t FillReservoir(DataChunk &chunk);
-	//! Add a chunk of data to the sample
-	void AddToReservoir(DataChunk &input) override;
-	//! Merge two Reservoir Samples. Other must be a reservoir sample
-	void Merge(unique_ptr<BlockingSample> other);
-
-	void ShuffleSel(SelectionVector &sel, idx_t range, idx_t size) const;
-
-	//! Update the sample by pushing new sample rows to the end of the sample_chunk.
-	//! The new sample rows are the tuples rows resulting from applying sel to other
-	void UpdateSampleAppend(DataChunk &this_, DataChunk &other, SelectionVector &other_sel, idx_t append_count) const;
-
-	idx_t GetTuplesSeen() const;
-	idx_t NumSamplesCollected() const;
-	idx_t GetActiveSampleCount() const;
-	static bool ValidSampleType(const LogicalType &type);
-
-	// get the chunk from Reservoir chunk
-	DataChunk &Chunk();
-
-	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
-	//! sample is completely built.
-	// unique_ptr<DataChunk> GetChunkAndDestroy() override;
-	unique_ptr<DataChunk> GetChunk() override;
-	void Destroy() override;
-	void Finalize() override;
-	void Verify();
-
-	idx_t GetSampleCount();
-
-	// map is [index in input chunk] -> [index in sample chunk]. Both are zero-based
-	// [index in sample chunk] is incremented by 1
-	// index in input chunk have random values, however, they are increasing.
-	// The base_reservoir_sampling gets updated however, so the indexes point to (sample_chunk_offset +
-	// index_in_sample_chunk) this data is used to make a selection vector to copy samples from the input chunk to the
-	// sample chunk
-	//! Get indexes from current sample that can be replaced.
-	SelectionVectorHelper GetReplacementIndexes(idx_t sample_chunk_offset, idx_t theoretical_chunk_length);
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
-
-private:
-	// when we serialize, we may have collected too many samples since we fill a standard vector size, then
-	// truncate if the table is still <=204800 values. The problem is, in our weights, we store indexes into
-	// the selection vector. If throw away values at selection vector index i = 5 , we need to update all indexes
-	// i > 5. Otherwise we will have indexes in the weights that are greater than the length of our sample.
-	void NormalizeWeights();
-
-	SelectionVectorHelper GetReplacementIndexesSlow(const idx_t sample_chunk_offset, const idx_t chunk_length);
-	SelectionVectorHelper GetReplacementIndexesFast(const idx_t sample_chunk_offset, const idx_t chunk_length);
-	void SimpleMerge(ReservoirSample &other);
-	void WeightedMerge(ReservoirSample &other_sample);
-
-	// Helper methods for Shrink().
-	// Shrink has different logic depending on if the Reservoir sample is still in
-	// "Random" mode or in "reservoir" mode. This function creates a new sample chunk
-	// to copy the old sample chunk into
-	unique_ptr<ReservoirChunk> CreateNewSampleChunk(vector<LogicalType> &types, idx_t size) const;
-
-	// Get a vector where each index is a random int in the range 0, size.
-	// This is used to shuffle selection vector indexes
-	vector<uint32_t> GetRandomizedVector(uint32_t range, uint32_t size) const;
-
-	idx_t sample_count;
-	Allocator &allocator;
-	unique_ptr<ReservoirChunk> reservoir_chunk;
-	bool stats_sample;
-	SelectionVector sel;
-	idx_t sel_size;
-};
-
-//! The reservoir sample sample_size class maintains a streaming sample of variable size
-class ReservoirSamplePercentage : public BlockingSample {
-	constexpr static idx_t RESERVOIR_THRESHOLD = 100000;
-
-public:
-	static constexpr const SampleType TYPE = SampleType::RESERVOIR_PERCENTAGE_SAMPLE;
-
-	ReservoirSamplePercentage(Allocator &allocator, double percentage, int64_t seed = -1);
-	ReservoirSamplePercentage(double percentage, int64_t seed, idx_t reservoir_sample_size);
-	explicit ReservoirSamplePercentage(double percentage, int64_t seed = -1);
-
-	//! Add a chunk of data to the sample
-	void AddToReservoir(DataChunk &input) override;
-
-	unique_ptr<BlockingSample> Copy() const override;
-
-	//! Fetches a chunk from the sample. If destory = true this method is descructive
-	unique_ptr<DataChunk> GetChunk() override;
-	void Finalize() override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
-
-private:
-	Allocator &allocator;
-	//! The sample_size to sample
-	double sample_percentage;
-	//! The fixed sample size of the sub-reservoirs
-	idx_t reservoir_sample_size;
-
-	//! The current sample
-	unique_ptr<ReservoirSample> current_sample;
-
-	//! The set of finished samples of the reservoir sample
-	vector<unique_ptr<ReservoirSample>> finished_samples;
-
-	//! The amount of tuples that have been processed so far (not put in the reservoir, just processed)
-	idx_t current_count = 0;
-	//! Whether or not the stream is finalized. The stream is automatically finalized on the first call to
-	//! GetChunkAndShrink();
-	bool is_finalized;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/execution/task_error_manager.hpp b/src/duckdb/src/include/duckdb/execution/task_error_manager.hpp
deleted file mode 100644
index 4d7e64493..000000000
--- a/src/duckdb/src/include/duckdb/execution/task_error_manager.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/task_error_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class TaskErrorManager {
-public:
-	void PushError(ErrorData error) {
-		lock_guard<mutex> elock(error_lock);
-		this->exceptions.push_back(std::move(error));
-	}
-
-	ErrorData GetError() {
-		lock_guard<mutex> elock(error_lock);
-		D_ASSERT(!exceptions.empty());
-
-		// FIXME: Should we try to get the biggest priority error?
-		// In case the first exception is a StandardException but a regular Exception or a FatalException occurred
-		// Maybe we should throw the more critical exception instead, as that changes behavior.
-		auto &entry = exceptions[0];
-		return entry;
-	}
-
-	bool HasError() {
-		lock_guard<mutex> elock(error_lock);
-		return !exceptions.empty();
-	}
-
-	void ThrowException() {
-		lock_guard<mutex> elock(error_lock);
-		D_ASSERT(!exceptions.empty());
-		auto &entry = exceptions[0];
-		entry.Throw();
-	}
-
-	void Reset() {
-		lock_guard<mutex> elock(error_lock);
-		exceptions.clear();
-	}
-
-private:
-	mutex error_lock;
-	//! Exceptions that occurred during the execution of the current query
-	vector<ErrorData> exceptions;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/aggregate/distributive_function_utils.hpp b/src/duckdb/src/include/duckdb/function/aggregate/distributive_function_utils.hpp
deleted file mode 100644
index 9f32d453f..000000000
--- a/src/duckdb/src/include/duckdb/function/aggregate/distributive_function_utils.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/distributive_function_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CountFunctionBase {
-	static AggregateFunction GetFunction();
-};
-
-struct FirstFunctionGetter {
-	static AggregateFunction GetFunction(const LogicalType &type);
-};
-
-struct MinFunction {
-	static AggregateFunction GetFunction();
-};
-
-struct MaxFunction {
-	static AggregateFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/aggregate/distributive_functions.hpp b/src/duckdb/src/include/duckdb/function/aggregate/distributive_functions.hpp
deleted file mode 100644
index 7d6eb3274..000000000
--- a/src/duckdb/src/include/duckdb/function/aggregate/distributive_functions.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/aggregate/distributive_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CountStarFun {
-	static constexpr const char *Name = "count_star";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static AggregateFunction GetFunction();
-};
-
-struct CountFun {
-	static constexpr const char *Name = "count";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the number of non-null values in arg.";
-	static constexpr const char *Example = "count(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct FirstFun {
-	static constexpr const char *Name = "first";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the first value (null or non-null) from arg. This function is affected by ordering.";
-	static constexpr const char *Example = "first(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct ArbitraryFun {
-	using ALIAS = FirstFun;
-
-	static constexpr const char *Name = "arbitrary";
-};
-
-struct LastFun {
-	static constexpr const char *Name = "last";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the last value of a column. This function is affected by ordering.";
-	static constexpr const char *Example = "last(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct AnyValueFun {
-	static constexpr const char *Name = "any_value";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the first non-null value from arg. This function is affected by ordering.";
-	static constexpr const char *Example = "";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct MinFun {
-	static constexpr const char *Name = "min";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the minimum value present in arg.";
-	static constexpr const char *Example = "min(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-struct MaxFun {
-	static constexpr const char *Name = "max";
-	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the maximum value present in arg.";
-	static constexpr const char *Example = "max(A)";
-
-	static AggregateFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/aggregate/minmax_n_helpers.hpp b/src/duckdb/src/include/duckdb/function/aggregate/minmax_n_helpers.hpp
deleted file mode 100644
index 9c59d11cb..000000000
--- a/src/duckdb/src/include/duckdb/function/aggregate/minmax_n_helpers.hpp
+++ /dev/null
@@ -1,402 +0,0 @@
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/arena_allocator.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/enums/order_type.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-
-namespace duckdb {
-
-// For basic types
-template <class T>
-struct HeapEntry {
-	T value;
-
-	void Assign(ArenaAllocator &allocator, const T &val) {
-		value = val;
-	}
-};
-
-// For strings that require arena allocation
-template <>
-struct HeapEntry<string_t> {
-	string_t value;
-	uint32_t capacity;
-	data_ptr_t allocated_data;
-
-	HeapEntry() : value(), capacity(0), allocated_data(nullptr) {
-	}
-
-	// Not copyable
-	HeapEntry(const HeapEntry &other) = delete;
-	HeapEntry &operator=(const HeapEntry &other) = delete;
-
-	// But movable
-	HeapEntry(HeapEntry &&other) noexcept {
-		if (other.value.IsInlined()) {
-			value = other.value;
-			capacity = 0;
-			allocated_data = nullptr;
-		} else {
-			capacity = other.capacity;
-			allocated_data = other.allocated_data;
-			value = string_t(const_char_ptr_cast(allocated_data), UnsafeNumericCast<uint32_t>(other.value.GetSize()));
-			other.allocated_data = nullptr;
-		}
-	}
-
-	HeapEntry &operator=(HeapEntry &&other) noexcept {
-		if (other.value.IsInlined()) {
-			value = other.value;
-		} else {
-			capacity = other.capacity;
-			allocated_data = other.allocated_data;
-			value = string_t(const_char_ptr_cast(allocated_data), UnsafeNumericCast<uint32_t>(other.value.GetSize()));
-			other.allocated_data = nullptr;
-		}
-		return *this;
-	}
-
-	void Assign(ArenaAllocator &allocator, const string_t &new_val) {
-		if (new_val.IsInlined()) {
-			value = new_val;
-			return;
-		}
-
-		// Short path for first assignment
-		if (allocated_data == nullptr) {
-			auto new_size = UnsafeNumericCast<uint32_t>(new_val.GetSize());
-			auto new_capacity = NextPowerOfTwo(new_size);
-			if (new_capacity > string_t::MAX_STRING_SIZE) {
-				throw InvalidInputException("Resulting string/blob too large!");
-			}
-			capacity = UnsafeNumericCast<uint32_t>(new_capacity);
-			allocated_data = allocator.Allocate(capacity);
-			memcpy(allocated_data, new_val.GetData(), new_size);
-			value = string_t(const_char_ptr_cast(allocated_data), new_size);
-			return;
-		}
-
-		// double allocation until value fits
-		if (capacity < new_val.GetSize()) {
-			auto old_size = capacity;
-			capacity *= 2;
-			while (capacity < new_val.GetSize()) {
-				capacity *= 2;
-			}
-			allocated_data = allocator.Reallocate(allocated_data, old_size, capacity);
-		}
-		auto new_size = UnsafeNumericCast<uint32_t>(new_val.GetSize());
-		memcpy(allocated_data, new_val.GetData(), new_size);
-		value = string_t(const_char_ptr_cast(allocated_data), new_size);
-	}
-};
-
-template <class T, class T_COMPARATOR>
-class UnaryAggregateHeap {
-public:
-	UnaryAggregateHeap() = default;
-
-	explicit UnaryAggregateHeap(idx_t capacity_p) : capacity(capacity_p) {
-		heap.reserve(capacity);
-	}
-
-	void Initialize(const idx_t capacity_p) {
-		capacity = capacity_p;
-		heap.reserve(capacity);
-	}
-
-	bool IsEmpty() const {
-		return heap.empty();
-	}
-	idx_t Size() const {
-		return heap.size();
-	}
-	idx_t Capacity() const {
-		return capacity;
-	}
-
-	void Insert(ArenaAllocator &allocator, const T &value) {
-		D_ASSERT(capacity != 0); // must be initialized
-
-		// If the heap is not full, insert the value into a new slot
-		if (heap.size() < capacity) {
-			heap.emplace_back();
-			heap.back().Assign(allocator, value);
-			std::push_heap(heap.begin(), heap.end(), Compare);
-		}
-		// If the heap is full, check if the value is greater than the smallest value in the heap
-		// If it is, assign the new value to the slot and re-heapify
-		else if (T_COMPARATOR::Operation(value, heap.front().value)) {
-			std::pop_heap(heap.begin(), heap.end(), Compare);
-			heap.back().Assign(allocator, value);
-			std::push_heap(heap.begin(), heap.end(), Compare);
-		}
-		D_ASSERT(std::is_heap(heap.begin(), heap.end(), Compare));
-	}
-
-	void Insert(ArenaAllocator &allocator, const UnaryAggregateHeap &other) {
-		for (auto &slot : other.heap) {
-			Insert(allocator, slot.value);
-		}
-	}
-
-	vector<HeapEntry<T>> &SortAndGetHeap() {
-		std::sort_heap(heap.begin(), heap.end(), Compare);
-		return heap;
-	}
-
-	static const T &GetValue(const HeapEntry<T> &slot) {
-		return slot.value;
-	}
-
-private:
-	static bool Compare(const HeapEntry<T> &left, const HeapEntry<T> &right) {
-		return T_COMPARATOR::Operation(left.value, right.value);
-	}
-
-	vector<HeapEntry<T>> heap;
-	idx_t capacity;
-};
-
-template <class K, class V, class K_COMPARATOR>
-class BinaryAggregateHeap {
-	using STORAGE_TYPE = pair<HeapEntry<K>, HeapEntry<V>>;
-
-public:
-	BinaryAggregateHeap() = default;
-
-	explicit BinaryAggregateHeap(idx_t capacity_p) : capacity(capacity_p) {
-		heap.reserve(capacity);
-	}
-
-	void Initialize(const idx_t capacity_p) {
-		capacity = capacity_p;
-		heap.reserve(capacity);
-	}
-
-	bool IsEmpty() const {
-		return heap.empty();
-	}
-	idx_t Size() const {
-		return heap.size();
-	}
-	idx_t Capacity() const {
-		return capacity;
-	}
-
-	void Insert(ArenaAllocator &allocator, const K &key, const V &value) {
-		D_ASSERT(capacity != 0); // must be initialized
-
-		// If the heap is not full, insert the value into a new slot
-		if (heap.size() < capacity) {
-			heap.emplace_back();
-			heap.back().first.Assign(allocator, key);
-			heap.back().second.Assign(allocator, value);
-			std::push_heap(heap.begin(), heap.end(), Compare);
-		}
-		// If the heap is full, check if the value is greater than the smallest value in the heap
-		// If it is, assign the new value to the slot and re-heapify
-		else if (K_COMPARATOR::Operation(key, heap.front().first.value)) {
-			std::pop_heap(heap.begin(), heap.end(), Compare);
-			heap.back().first.Assign(allocator, key);
-			heap.back().second.Assign(allocator, value);
-			std::push_heap(heap.begin(), heap.end(), Compare);
-		}
-		D_ASSERT(std::is_heap(heap.begin(), heap.end(), Compare));
-	}
-
-	void Insert(ArenaAllocator &allocator, const BinaryAggregateHeap &other) {
-		for (auto &slot : other.heap) {
-			Insert(allocator, slot.first.value, slot.second.value);
-		}
-	}
-
-	vector<STORAGE_TYPE> &SortAndGetHeap() {
-		std::sort_heap(heap.begin(), heap.end(), Compare);
-		return heap;
-	}
-
-	static const V &GetValue(const STORAGE_TYPE &slot) {
-		return slot.second.value;
-	}
-
-private:
-	static bool Compare(const STORAGE_TYPE &left, const STORAGE_TYPE &right) {
-		return K_COMPARATOR::Operation(left.first.value, right.first.value);
-	}
-
-	vector<STORAGE_TYPE> heap;
-	idx_t capacity;
-};
-
-//------------------------------------------------------------------------------
-// Specializations for fixed size types, strings, and anything else (using sortkey)
-//------------------------------------------------------------------------------
-template <class T>
-struct MinMaxFixedValue {
-	using TYPE = T;
-	using EXTRA_STATE = bool;
-
-	static TYPE Create(const UnifiedVectorFormat &format, const idx_t idx) {
-		return UnifiedVectorFormat::GetData<T>(format)[idx];
-	}
-
-	static void Assign(Vector &vector, const idx_t idx, const TYPE &value) {
-		FlatVector::GetData<T>(vector)[idx] = value;
-	}
-
-	// Nothing to do here
-	static EXTRA_STATE CreateExtraState(Vector &input, idx_t count) {
-		return false;
-	}
-
-	static void PrepareData(Vector &input, const idx_t count, EXTRA_STATE &, UnifiedVectorFormat &format) {
-		input.ToUnifiedFormat(count, format);
-	}
-};
-
-struct MinMaxStringValue {
-	using TYPE = string_t;
-	using EXTRA_STATE = bool;
-
-	static TYPE Create(const UnifiedVectorFormat &format, const idx_t idx) {
-		return UnifiedVectorFormat::GetData<string_t>(format)[idx];
-	}
-
-	static void Assign(Vector &vector, const idx_t idx, const TYPE &value) {
-		FlatVector::GetData<string_t>(vector)[idx] = StringVector::AddStringOrBlob(vector, value);
-	}
-
-	// Nothing to do here
-	static EXTRA_STATE CreateExtraState(Vector &input, idx_t count) {
-		return false;
-	}
-
-	static void PrepareData(Vector &input, const idx_t count, EXTRA_STATE &, UnifiedVectorFormat &format) {
-		input.ToUnifiedFormat(count, format);
-	}
-};
-
-// Use sort key to serialize/deserialize values
-struct MinMaxFallbackValue {
-	using TYPE = string_t;
-	using EXTRA_STATE = Vector;
-
-	static TYPE Create(const UnifiedVectorFormat &format, const idx_t idx) {
-		return UnifiedVectorFormat::GetData<string_t>(format)[idx];
-	}
-
-	static void Assign(Vector &vector, const idx_t idx, const TYPE &value) {
-		OrderModifiers modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-		CreateSortKeyHelpers::DecodeSortKey(value, vector, idx, modifiers);
-	}
-
-	static EXTRA_STATE CreateExtraState(Vector &input, idx_t count) {
-		return Vector(LogicalTypeId::BLOB);
-	}
-
-	static void PrepareData(Vector &input, const idx_t count, EXTRA_STATE &extra_state, UnifiedVectorFormat &format) {
-		const OrderModifiers modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-		CreateSortKeyHelpers::CreateSortKeyWithValidity(input, extra_state, modifiers, count);
-		input.Flatten(count);
-		extra_state.ToUnifiedFormat(count, format);
-	}
-};
-
-//------------------------------------------------------------------------------
-// MinMaxN Operation (common for both ArgMinMaxN and MinMaxN)
-//------------------------------------------------------------------------------
-struct MinMaxNOperation {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		new (&state) STATE();
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input) {
-		if (!source.is_initialized) {
-			// source is empty, nothing to do
-			return;
-		}
-
-		if (!target.is_initialized) {
-			target.Initialize(source.heap.Capacity());
-		} else if (source.heap.Capacity() != target.heap.Capacity()) {
-			throw InvalidInputException("Mismatched n values in min/max/arg_min/arg_max");
-		}
-
-		// Merge the heaps
-		target.heap.Insert(aggr_input.allocator, source.heap);
-	}
-
-	template <class STATE>
-	static void Finalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
-
-		UnifiedVectorFormat state_format;
-		state_vector.ToUnifiedFormat(count, state_format);
-
-		const auto states = UnifiedVectorFormat::GetData<STATE *>(state_format);
-		auto &mask = FlatVector::Validity(result);
-
-		const auto old_len = ListVector::GetListSize(result);
-
-		// Count the number of new entries
-		idx_t new_entries = 0;
-		for (idx_t i = 0; i < count; i++) {
-			const auto state_idx = state_format.sel->get_index(i);
-			auto &state = *states[state_idx];
-			new_entries += state.heap.Size();
-		}
-
-		// Resize the list vector to fit the new entries
-		ListVector::Reserve(result, old_len + new_entries);
-
-		const auto list_entries = FlatVector::GetData<list_entry_t>(result);
-		auto &child_data = ListVector::GetEntry(result);
-
-		idx_t current_offset = old_len;
-		for (idx_t i = 0; i < count; i++) {
-			const auto rid = i + offset;
-			const auto state_idx = state_format.sel->get_index(i);
-			auto &state = *states[state_idx];
-
-			if (!state.is_initialized || state.heap.IsEmpty()) {
-				mask.SetInvalid(rid);
-				continue;
-			}
-
-			// Add the entries to the list vector
-			auto &list_entry = list_entries[rid];
-			list_entry.offset = current_offset;
-			list_entry.length = state.heap.Size();
-
-			// Turn the heap into a sorted list, invalidating the heap property
-			auto &heap = state.heap.SortAndGetHeap();
-
-			for (const auto &slot : heap) {
-				STATE::VAL_TYPE::Assign(child_data, current_offset++, state.heap.GetValue(slot));
-			}
-		}
-
-		D_ASSERT(current_offset == old_len + new_entries);
-		ListVector::SetListSize(result, current_offset);
-		result.Verify(count);
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		state.~STATE();
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/aggregate/sort_key_helpers.hpp b/src/duckdb/src/include/duckdb/function/aggregate/sort_key_helpers.hpp
deleted file mode 100644
index f1ecb86f9..000000000
--- a/src/duckdb/src/include/duckdb/function/aggregate/sort_key_helpers.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/sort_key_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/function/create_sort_key.hpp"
-
-namespace duckdb {
-
-struct AggregateSortKeyHelpers {
-	template <class STATE, class OP, OrderType ORDER_TYPE = OrderType::ASCENDING, bool IGNORE_NULLS = true>
-	static void UnaryUpdate(Vector inputs[], AggregateInputData &input_data, idx_t input_count, Vector &state_vector,
-	                        idx_t count) {
-		D_ASSERT(input_count == 1);
-		auto &input = inputs[0];
-
-		Vector sort_key(LogicalType::BLOB);
-		auto modifiers = OrderModifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST);
-		CreateSortKeyHelpers::CreateSortKey(input, count, modifiers, sort_key);
-
-		UnifiedVectorFormat idata;
-		if (IGNORE_NULLS) {
-			input.ToUnifiedFormat(count, idata);
-		}
-
-		UnifiedVectorFormat kdata;
-		sort_key.ToUnifiedFormat(count, kdata);
-
-		UnifiedVectorFormat sdata;
-		state_vector.ToUnifiedFormat(count, sdata);
-
-		auto key_data = UnifiedVectorFormat::GetData<string_t>(kdata);
-		auto states = UnifiedVectorFormat::GetData<STATE *>(sdata);
-		for (idx_t i = 0; i < count; i++) {
-			const auto sidx = sdata.sel->get_index(i);
-			if (IGNORE_NULLS) {
-				auto idx = idata.sel->get_index(i);
-				if (!idata.validity.RowIsValid(idx)) {
-					continue;
-				}
-			}
-			const auto key_idx = kdata.sel->get_index(i);
-			auto &state = *states[sidx];
-			OP::template Execute<string_t, STATE, OP>(state, key_data[key_idx], input_data);
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/aggregate_function.hpp b/src/duckdb/src/include/duckdb/function/aggregate_function.hpp
deleted file mode 100644
index e63533d5c..000000000
--- a/src/duckdb/src/include/duckdb/function/aggregate_function.hpp
+++ /dev/null
@@ -1,336 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/array.hpp"
-#include "duckdb/common/vector_operations/aggregate_executor.hpp"
-#include "duckdb/function/aggregate_state.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BufferManager;
-
-//! A half-open range of frame boundary values _relative to the current row_
-//! This is why they are signed values.
-struct FrameDelta {
-	FrameDelta() : begin(0), end(0) {};
-	FrameDelta(int64_t begin, int64_t end) : begin(begin), end(end) {};
-	int64_t begin = 0;
-	int64_t end = 0;
-};
-
-//! The half-open ranges of frame boundary values relative to the current row
-using FrameStats = array<FrameDelta, 2>;
-
-//! The partition data for custom window functions
-//! Note that if the inputs is nullptr then the column count is 0,
-//! but the row count will still be valid
-class ColumnDataCollection;
-struct WindowPartitionInput {
-	WindowPartitionInput(ClientContext &context, const ColumnDataCollection *inputs, idx_t count,
-	                     vector<column_t> &column_ids, vector<bool> &all_valid, const ValidityMask &filter_mask,
-	                     const FrameStats &stats)
-	    : context(context), inputs(inputs), count(count), column_ids(column_ids), all_valid(all_valid),
-	      filter_mask(filter_mask), stats(stats) {
-	}
-	ClientContext &context;
-	const ColumnDataCollection *inputs;
-	idx_t count;
-	vector<column_t> column_ids;
-	vector<bool> all_valid;
-	const ValidityMask &filter_mask;
-	const FrameStats stats;
-};
-
-//! The type used for sizing hashed aggregate function states
-typedef idx_t (*aggregate_size_t)(const AggregateFunction &function);
-//! The type used for initializing hashed aggregate function states
-typedef void (*aggregate_initialize_t)(const AggregateFunction &function, data_ptr_t state);
-//! The type used for updating hashed aggregate functions
-typedef void (*aggregate_update_t)(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-                                   Vector &state, idx_t count);
-//! The type used for combining hashed aggregate states
-typedef void (*aggregate_combine_t)(Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count);
-//! The type used for finalizing hashed aggregate function payloads
-typedef void (*aggregate_finalize_t)(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                                     idx_t offset);
-//! The type used for propagating statistics in aggregate functions (optional)
-typedef unique_ptr<BaseStatistics> (*aggregate_statistics_t)(ClientContext &context, BoundAggregateExpression &expr,
-                                                             AggregateStatisticsInput &input);
-//! Binds the scalar function and creates the function data
-typedef unique_ptr<FunctionData> (*bind_aggregate_function_t)(ClientContext &context, AggregateFunction &function,
-                                                              vector<unique_ptr<Expression>> &arguments);
-//! The type used for the aggregate destructor method. NOTE: this method is used in destructors and MAY NOT throw.
-typedef void (*aggregate_destructor_t)(Vector &state, AggregateInputData &aggr_input_data, idx_t count);
-
-//! The type used for updating simple (non-grouped) aggregate functions
-typedef void (*aggregate_simple_update_t)(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-                                          data_ptr_t state, idx_t count);
-
-//! The type used for computing complex/custom windowed aggregate functions (optional)
-typedef void (*aggregate_window_t)(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-                                   const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &subframes,
-                                   Vector &result, idx_t rid);
-
-//! The type used for initializing shared complex/custom windowed aggregate state (optional)
-typedef void (*aggregate_wininit_t)(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-                                    data_ptr_t g_state);
-
-typedef void (*aggregate_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                      const AggregateFunction &function);
-typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(Deserializer &deserializer, AggregateFunction &function);
-
-struct AggregateFunctionInfo {
-	DUCKDB_API virtual ~AggregateFunctionInfo();
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-enum class AggregateDestructorType {
-	STANDARD,
-	// legacy destructors allow non-trivial destructors in aggregate states
-	// these might not be trivial to off-load to disk
-	LEGACY
-};
-
-class AggregateFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
-public:
-	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
-	                  aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,
-	                  aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                  FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
-	                  aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
-	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
-	                  aggregate_window_t window = nullptr, aggregate_serialize_t serialize = nullptr,
-	                  aggregate_deserialize_t deserialize = nullptr)
-	    : BaseScalarFunction(name, arguments, return_type, FunctionStability::CONSISTENT,
-	                         LogicalType(LogicalTypeId::INVALID), null_handling),
-	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
-	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT),
-	      distinct_dependent(AggregateDistinctDependent::DISTINCT_DEPENDENT) {
-	}
-
-	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
-	                  aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,
-	                  aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                  aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
-	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
-	                  aggregate_window_t window = nullptr, aggregate_serialize_t serialize = nullptr,
-	                  aggregate_deserialize_t deserialize = nullptr)
-	    : BaseScalarFunction(name, arguments, return_type, FunctionStability::CONSISTENT,
-	                         LogicalType(LogicalTypeId::INVALID)),
-	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
-	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT),
-	      distinct_dependent(AggregateDistinctDependent::DISTINCT_DEPENDENT) {
-	}
-
-	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
-	                  aggregate_initialize_t initialize, aggregate_update_t update, aggregate_combine_t combine,
-	                  aggregate_finalize_t finalize,
-	                  FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
-	                  aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
-	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
-	                  aggregate_window_t window = nullptr, aggregate_serialize_t serialize = nullptr,
-	                  aggregate_deserialize_t deserialize = nullptr)
-	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize,
-	                        null_handling, simple_update, bind, destructor, statistics, window, serialize,
-	                        deserialize) {
-	}
-
-	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
-	                  aggregate_initialize_t initialize, aggregate_update_t update, aggregate_combine_t combine,
-	                  aggregate_finalize_t finalize, aggregate_simple_update_t simple_update = nullptr,
-	                  bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                  aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr,
-	                  aggregate_serialize_t serialize = nullptr, aggregate_deserialize_t deserialize = nullptr)
-	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize,
-	                        FunctionNullHandling::DEFAULT_NULL_HANDLING, simple_update, bind, destructor, statistics,
-	                        window, serialize, deserialize) {
-	}
-	//! The hashed aggregate state sizing function
-	aggregate_size_t state_size;
-	//! The hashed aggregate state initialization function
-	aggregate_initialize_t initialize;
-	//! The hashed aggregate update state function
-	aggregate_update_t update;
-	//! The hashed aggregate combine states function
-	aggregate_combine_t combine;
-	//! The hashed aggregate finalization function
-	aggregate_finalize_t finalize;
-	//! The simple aggregate update function (may be null)
-	aggregate_simple_update_t simple_update;
-	//! The windowed aggregate custom function (may be null)
-	aggregate_window_t window;
-	//! The windowed aggregate custom initialization function (may be null)
-	aggregate_wininit_t window_init = nullptr;
-
-	//! The bind function (may be null)
-	bind_aggregate_function_t bind;
-	//! The destructor method (may be null)
-	aggregate_destructor_t destructor;
-
-	//! The statistics propagation function (may be null)
-	aggregate_statistics_t statistics;
-
-	aggregate_serialize_t serialize;
-	aggregate_deserialize_t deserialize;
-	//! Whether or not the aggregate is order dependent
-	AggregateOrderDependent order_dependent;
-	//! Whether or not the aggregate is affect by distinct modifiers
-	AggregateDistinctDependent distinct_dependent;
-	//! Additional function info, passed to the bind
-	shared_ptr<AggregateFunctionInfo> function_info;
-
-	bool operator==(const AggregateFunction &rhs) const {
-		return state_size == rhs.state_size && initialize == rhs.initialize && update == rhs.update &&
-		       combine == rhs.combine && finalize == rhs.finalize && window == rhs.window;
-	}
-	bool operator!=(const AggregateFunction &rhs) const {
-		return !(*this == rhs);
-	}
-
-public:
-	template <class STATE, class RESULT_TYPE, class OP>
-	static AggregateFunction NullaryAggregate(LogicalType return_type) {
-		return AggregateFunction(
-		    {}, return_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-		    AggregateFunction::NullaryScatterUpdate<STATE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-		    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::NullaryUpdate<STATE, OP>);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP,
-	          AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
-	static AggregateFunction
-	UnaryAggregate(const LogicalType &input_type, LogicalType return_type,
-	               FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING) {
-		return AggregateFunction({input_type}, return_type, AggregateFunction::StateSize<STATE>,
-		                         AggregateFunction::StateInitialize<STATE, OP, destructor_type>,
-		                         AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>,
-		                         AggregateFunction::StateCombine<STATE, OP>,
-		                         AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, null_handling,
-		                         AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP,
-	          AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
-	static AggregateFunction UnaryAggregateDestructor(LogicalType input_type, LogicalType return_type) {
-		auto aggregate = UnaryAggregate<STATE, INPUT_TYPE, RESULT_TYPE, OP, destructor_type>(input_type, return_type);
-		aggregate.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-		return aggregate;
-	}
-
-	template <class STATE, class A_TYPE, class B_TYPE, class RESULT_TYPE, class OP,
-	          AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
-	static AggregateFunction BinaryAggregate(const LogicalType &a_type, const LogicalType &b_type,
-	                                         LogicalType return_type) {
-		return AggregateFunction({a_type, b_type}, return_type, AggregateFunction::StateSize<STATE>,
-		                         AggregateFunction::StateInitialize<STATE, OP, destructor_type>,
-		                         AggregateFunction::BinaryScatterUpdate<STATE, A_TYPE, B_TYPE, OP>,
-		                         AggregateFunction::StateCombine<STATE, OP>,
-		                         AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>,
-		                         AggregateFunction::BinaryUpdate<STATE, A_TYPE, B_TYPE, OP>);
-	}
-
-public:
-	template <class STATE>
-	static idx_t StateSize(const AggregateFunction &) {
-		return sizeof(STATE);
-	}
-
-	template <class STATE, class OP, AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
-	static void StateInitialize(const AggregateFunction &, data_ptr_t state) {
-		// FIXME: we should remove the "destructor_type" option in the future
-#if !defined(__GNUC__) || (__GNUC__ >= 5)
-		static_assert(std::is_trivially_move_constructible<STATE>::value ||
-		                  destructor_type == AggregateDestructorType::LEGACY,
-		              "Aggregate state must be trivially move constructible");
-#endif
-		OP::Initialize(*reinterpret_cast<STATE *>(state));
-	}
-
-	template <class STATE, class OP>
-	static void NullaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-	                                 Vector &states, idx_t count) {
-		D_ASSERT(input_count == 0);
-		AggregateExecutor::NullaryScatter<STATE, OP>(states, aggr_input_data, count);
-	}
-
-	template <class STATE, class OP>
-	static void NullaryUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                          idx_t count) {
-		D_ASSERT(input_count == 0);
-		AggregateExecutor::NullaryUpdate<STATE, OP>(state, aggr_input_data, count);
-	}
-
-	template <class STATE, class T, class OP>
-	static void UnaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-	                               Vector &states, idx_t count) {
-		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryScatter<STATE, T, OP>(inputs[0], states, aggr_input_data, count);
-	}
-
-	template <class STATE, class INPUT_TYPE, class OP>
-	static void UnaryUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                        idx_t count) {
-		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryUpdate<STATE, INPUT_TYPE, OP>(inputs[0], aggr_input_data, state, count);
-	}
-
-	template <class STATE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-	                                Vector &states, idx_t count) {
-		D_ASSERT(input_count == 2);
-		AggregateExecutor::BinaryScatter<STATE, A_TYPE, B_TYPE, OP>(aggr_input_data, inputs[0], inputs[1], states,
-		                                                            count);
-	}
-
-	template <class STATE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                         idx_t count) {
-		D_ASSERT(input_count == 2);
-		AggregateExecutor::BinaryUpdate<STATE, A_TYPE, B_TYPE, OP>(aggr_input_data, inputs[0], inputs[1], state, count);
-	}
-
-	template <class STATE, class OP>
-	static void StateCombine(Vector &source, Vector &target, AggregateInputData &aggr_input_data, idx_t count) {
-		AggregateExecutor::Combine<STATE, OP>(source, target, aggr_input_data, count);
-	}
-
-	template <class STATE, class RESULT_TYPE, class OP>
-	static void StateFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                          idx_t offset) {
-		AggregateExecutor::Finalize<STATE, RESULT_TYPE, OP>(states, aggr_input_data, result, count, offset);
-	}
-
-	template <class STATE, class OP>
-	static void StateVoidFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                              idx_t offset) {
-		AggregateExecutor::VoidFinalize<STATE, OP>(states, aggr_input_data, result, count, offset);
-	}
-
-	template <class STATE, class OP>
-	static void StateDestroy(Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
-		AggregateExecutor::Destroy<STATE, OP>(states, aggr_input_data, count);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/aggregate_state.hpp b/src/duckdb/src/include/duckdb/function/aggregate_state.hpp
deleted file mode 100644
index bb0d096df..000000000
--- a/src/duckdb/src/include/duckdb/function/aggregate_state.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/node_statistics.hpp"
-
-namespace duckdb {
-
-enum class AggregateType : uint8_t { NON_DISTINCT = 1, DISTINCT = 2 };
-//! Whether or not the input order influences the result of the aggregate
-enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DEPENDENT = 2 };
-//! Whether or not the input distinctness influences the result of the aggregate
-enum class AggregateDistinctDependent : uint8_t { DISTINCT_DEPENDENT = 1, NOT_DISTINCT_DEPENDENT = 2 };
-//! Whether or not the combiner needs to preserve the source
-enum class AggregateCombineType : uint8_t { PRESERVE_INPUT = 1, ALLOW_DESTRUCTIVE = 2 };
-
-class BoundAggregateExpression;
-
-struct AggregateInputData {
-	AggregateInputData(optional_ptr<FunctionData> bind_data_p, ArenaAllocator &allocator_p,
-	                   AggregateCombineType combine_type_p = AggregateCombineType::PRESERVE_INPUT)
-	    : bind_data(bind_data_p), allocator(allocator_p), combine_type(combine_type_p) {
-	}
-	optional_ptr<FunctionData> bind_data;
-	ArenaAllocator &allocator;
-	AggregateCombineType combine_type;
-};
-
-struct AggregateUnaryInput {
-	AggregateUnaryInput(AggregateInputData &input_p, ValidityMask &input_mask_p)
-	    : input(input_p), input_mask(input_mask_p), input_idx(0) {
-	}
-
-	AggregateInputData &input;
-	ValidityMask &input_mask;
-	idx_t input_idx;
-
-	inline bool RowIsValid() {
-		return input_mask.RowIsValid(input_idx);
-	}
-};
-
-struct AggregateBinaryInput {
-	AggregateBinaryInput(AggregateInputData &input_p, ValidityMask &left_mask_p, ValidityMask &right_mask_p)
-	    : input(input_p), left_mask(left_mask_p), right_mask(right_mask_p) {
-	}
-
-	AggregateInputData &input;
-	ValidityMask &left_mask;
-	ValidityMask &right_mask;
-	idx_t lidx;
-	idx_t ridx;
-};
-
-struct AggregateFinalizeData {
-	AggregateFinalizeData(Vector &result_p, AggregateInputData &input_p)
-	    : result(result_p), input(input_p), result_idx(0) {
-	}
-
-	Vector &result;
-	AggregateInputData &input;
-	idx_t result_idx;
-
-	inline void ReturnNull() {
-		switch (result.GetVectorType()) {
-		case VectorType::FLAT_VECTOR:
-			FlatVector::SetNull(result, result_idx, true);
-			break;
-		case VectorType::CONSTANT_VECTOR:
-			ConstantVector::SetNull(result, true);
-			break;
-		default:
-			throw InternalException("Invalid result vector type for aggregate");
-		}
-	}
-
-	inline string_t ReturnString(string_t value) {
-		return StringVector::AddStringOrBlob(result, value);
-	}
-};
-
-struct AggregateStatisticsInput {
-	AggregateStatisticsInput(optional_ptr<FunctionData> bind_data_p, vector<BaseStatistics> &child_stats_p,
-	                         optional_ptr<NodeStatistics> node_stats_p)
-	    : bind_data(bind_data_p), child_stats(child_stats_p), node_stats(node_stats_p) {
-	}
-
-	optional_ptr<FunctionData> bind_data;
-	vector<BaseStatistics> &child_stats;
-	optional_ptr<NodeStatistics> node_stats;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/built_in_functions.hpp b/src/duckdb/src/include/duckdb/function/built_in_functions.hpp
deleted file mode 100644
index fb8ef3166..000000000
--- a/src/duckdb/src/include/duckdb/function/built_in_functions.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/built_in_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/catalog/catalog_transaction.hpp"
-
-namespace duckdb {
-
-class BuiltinFunctions {
-public:
-	BuiltinFunctions(CatalogTransaction transaction, Catalog &catalog);
-	~BuiltinFunctions();
-
-	//! Initialize a catalog with all built-in functions
-	void Initialize();
-
-public:
-	void AddFunction(AggregateFunctionSet set);
-	void AddFunction(AggregateFunction function);
-	void AddFunction(ScalarFunctionSet set);
-	void AddFunction(PragmaFunction function);
-	void AddFunction(const string &name, PragmaFunctionSet functions);
-	void AddFunction(ScalarFunction function);
-	void AddFunction(const vector<string> &names, ScalarFunction function);
-	void AddFunction(TableFunctionSet set);
-	void AddFunction(TableFunction function);
-	void AddFunction(CopyFunction function);
-
-	void AddCollation(string name, ScalarFunction function, bool combinable = false,
-	                  bool not_required_for_equality = false);
-
-private:
-	CatalogTransaction transaction;
-	Catalog &catalog;
-
-private:
-	template <class T>
-	void Register() {
-		T::RegisterFunction(*this);
-	}
-
-	// table-producing functions
-	void RegisterTableScanFunctions();
-	void RegisterSQLiteFunctions();
-	void RegisterReadFunctions();
-	void RegisterTableFunctions();
-	void RegisterArrowFunctions();
-	void RegisterSnifferFunction();
-
-	void RegisterExtensionOverloads();
-
-	// pragmas
-	void RegisterPragmaFunctions();
-
-	void AddExtensionFunction(ScalarFunctionSet set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp b/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp
deleted file mode 100644
index fe950d0d1..000000000
--- a/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast/bound_cast_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/cast/default_casts.hpp"
-
-namespace duckdb {
-
-struct ListBoundCastData : public BoundCastData {
-	explicit ListBoundCastData(BoundCastInfo child_cast) : child_cast_info(std::move(child_cast)) {
-	}
-
-	BoundCastInfo child_cast_info;
-	static unique_ptr<BoundCastData> BindListToListCast(BindCastInput &input, const LogicalType &source,
-	                                                    const LogicalType &target);
-	static unique_ptr<FunctionLocalState> InitListLocalState(CastLocalStateParameters &parameters);
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<ListBoundCastData>(child_cast_info.Copy());
-	}
-};
-
-struct ArrayBoundCastData : public BoundCastData {
-	explicit ArrayBoundCastData(BoundCastInfo child_cast) : child_cast_info(std::move(child_cast)) {
-	}
-
-	BoundCastInfo child_cast_info;
-
-	static unique_ptr<BoundCastData> BindArrayToArrayCast(BindCastInput &input, const LogicalType &source,
-	                                                      const LogicalType &target);
-	static unique_ptr<FunctionLocalState> InitArrayLocalState(CastLocalStateParameters &parameters);
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<ArrayBoundCastData>(child_cast_info.Copy());
-	}
-};
-
-struct ListCast {
-	static bool ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-};
-
-struct StructBoundCastData : public BoundCastData {
-	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p, vector<idx_t> source_indexes_p,
-	                    vector<idx_t> target_indexes_p, vector<idx_t> target_null_indexes_p)
-	    : child_cast_info(std::move(child_casts)), target(std::move(target_p)),
-	      source_indexes(std::move(source_indexes_p)), target_indexes(std::move(target_indexes_p)),
-	      target_null_indexes(std::move(target_null_indexes_p)) {
-		D_ASSERT(child_cast_info.size() == source_indexes.size());
-		D_ASSERT(source_indexes.size() == target_indexes.size());
-	}
-	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p)
-	    : child_cast_info(std::move(child_casts)), target(std::move(target_p)) {
-		for (idx_t i = 0; i < child_cast_info.size(); i++) {
-			source_indexes.push_back(i);
-			target_indexes.push_back(i);
-		}
-	}
-
-	vector<BoundCastInfo> child_cast_info;
-	LogicalType target;
-	vector<idx_t> source_indexes;
-	vector<idx_t> target_indexes;
-	vector<idx_t> target_null_indexes;
-
-	static unique_ptr<BoundCastData> BindStructToStructCast(BindCastInput &input, const LogicalType &source,
-	                                                        const LogicalType &target);
-	static unique_ptr<FunctionLocalState> InitStructCastLocalState(CastLocalStateParameters &parameters);
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		vector<BoundCastInfo> copy_info;
-		for (auto &info : child_cast_info) {
-			copy_info.push_back(info.Copy());
-		}
-		return make_uniq<StructBoundCastData>(std::move(copy_info), target, source_indexes, target_indexes,
-		                                      target_null_indexes);
-	}
-};
-
-struct StructCastLocalState : public FunctionLocalState {
-public:
-	vector<unique_ptr<FunctionLocalState>> local_states;
-};
-
-struct MapBoundCastData : public BoundCastData {
-	MapBoundCastData(BoundCastInfo key_cast, BoundCastInfo value_cast)
-	    : key_cast(std::move(key_cast)), value_cast(std::move(value_cast)) {
-	}
-
-	BoundCastInfo key_cast;
-	BoundCastInfo value_cast;
-
-	static unique_ptr<BoundCastData> BindMapToMapCast(BindCastInput &input, const LogicalType &source,
-	                                                  const LogicalType &target);
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<MapBoundCastData>(key_cast.Copy(), value_cast.Copy());
-	}
-};
-
-struct MapCastLocalState : public FunctionLocalState {
-public:
-	unique_ptr<FunctionLocalState> key_state;
-	unique_ptr<FunctionLocalState> value_state;
-};
-
-struct UnionBoundCastData : public BoundCastData {
-	UnionBoundCastData(union_tag_t member_idx, string name, LogicalType type, int64_t cost,
-	                   BoundCastInfo member_cast_info)
-	    : tag(member_idx), name(std::move(name)), type(std::move(type)), cost(cost),
-	      member_cast_info(std::move(member_cast_info)) {
-	}
-
-	union_tag_t tag;
-	string name;
-	LogicalType type;
-	int64_t cost;
-	BoundCastInfo member_cast_info;
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<UnionBoundCastData>(tag, name, type, cost, member_cast_info.Copy());
-	}
-
-	static bool SortByCostAscending(const UnionBoundCastData &left, const UnionBoundCastData &right) {
-		return left.cost < right.cost;
-	}
-};
-
-struct StructToUnionCast {
-public:
-	static bool AllowImplicitCastFromStruct(const LogicalType &source, const LogicalType &target);
-	static bool Cast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-	static unique_ptr<BoundCastData> BindData(BindCastInput &input, const LogicalType &source,
-	                                          const LogicalType &target);
-	static BoundCastInfo Bind(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/cast/cast_function_set.hpp b/src/duckdb/src/include/duckdb/function/cast/cast_function_set.hpp
deleted file mode 100644
index d019592ac..000000000
--- a/src/duckdb/src/include/duckdb/function/cast/cast_function_set.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast/cast_function_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/cast/default_casts.hpp"
-
-namespace duckdb {
-struct MapCastInfo;
-struct MapCastNode;
-struct DBConfig;
-
-typedef BoundCastInfo (*bind_cast_function_t)(BindCastInput &input, const LogicalType &source,
-                                              const LogicalType &target);
-typedef int64_t (*implicit_cast_cost_t)(const LogicalType &from, const LogicalType &to);
-
-struct GetCastFunctionInput {
-	explicit GetCastFunctionInput(optional_ptr<ClientContext> context = nullptr) : context(context) {
-	}
-	explicit GetCastFunctionInput(ClientContext &context) : context(&context) {
-	}
-
-	optional_ptr<ClientContext> context;
-	optional_idx query_location;
-};
-
-struct BindCastFunction {
-	BindCastFunction(bind_cast_function_t function, // NOLINT: allow implicit cast
-	                 unique_ptr<BindCastInfo> info = nullptr);
-
-	bind_cast_function_t function;
-	unique_ptr<BindCastInfo> info;
-};
-
-class CastFunctionSet {
-public:
-	CastFunctionSet();
-	explicit CastFunctionSet(DBConfig &config);
-
-public:
-	DUCKDB_API static CastFunctionSet &Get(ClientContext &context);
-	DUCKDB_API static CastFunctionSet &Get(DatabaseInstance &db);
-
-	//! Returns a cast function (from source -> target)
-	//! Note that this always returns a function - since a cast is ALWAYS possible if the value is NULL
-	DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target,
-	                                         GetCastFunctionInput &input);
-	//! Returns the implicit cast cost of casting from source -> target
-	//! -1 means an implicit cast is not possible
-	DUCKDB_API int64_t ImplicitCastCost(const LogicalType &source, const LogicalType &target);
-	//! Register a new cast function from source to target
-	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
-	                                     int64_t implicit_cast_cost = -1);
-	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target,
-	                                     bind_cast_function_t bind, int64_t implicit_cast_cost = -1);
-
-private:
-	optional_ptr<DBConfig> config;
-	vector<BindCastFunction> bind_functions;
-	//! If any custom cast functions have been defined using RegisterCastFunction, this holds the map
-	optional_ptr<MapCastInfo> map_info;
-
-private:
-	void RegisterCastFunction(const LogicalType &source, const LogicalType &target, MapCastNode node);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp b/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp
deleted file mode 100644
index a8e486a98..000000000
--- a/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast/default_casts.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/function/scalar_function.hpp"
-
-namespace duckdb {
-
-class CastFunctionSet;
-struct FunctionLocalState;
-
-//! Extra data that can be attached to a bind function of a cast, and is available during binding
-struct BindCastInfo {
-	DUCKDB_API virtual ~BindCastInfo();
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//! Extra data that can be returned by the bind of a cast, and is available during execution of a cast
-struct BoundCastData {
-	DUCKDB_API virtual ~BoundCastData();
-
-	DUCKDB_API virtual unique_ptr<BoundCastData> Copy() const = 0;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct CastParameters {
-	CastParameters() {
-	}
-	CastParameters(bool strict, string *error_message) : CastParameters(nullptr, strict, error_message, nullptr) {
-	}
-	CastParameters(BoundCastData *cast_data, bool strict, string *error_message,
-	               optional_ptr<FunctionLocalState> local_state, bool nullify_parent_p = false)
-	    : cast_data(cast_data), strict(strict), error_message(error_message), local_state(local_state),
-	      nullify_parent(nullify_parent_p) {
-	}
-	CastParameters(CastParameters &parent, optional_ptr<BoundCastData> cast_data,
-	               optional_ptr<FunctionLocalState> local_state)
-	    : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message), local_state(local_state),
-	      query_location(parent.query_location) {
-	}
-
-	//! The bound cast data (if any)
-	optional_ptr<BoundCastData> cast_data;
-	//! whether or not to enable strict casting
-	bool strict = false;
-	// out: error message in case cast has failed
-	string *error_message = nullptr;
-	//! Local state
-	optional_ptr<FunctionLocalState> local_state;
-	//! Query location (if any)
-	optional_idx query_location;
-	//! In the case of a nested type, when facing a cast error, if we nullify the parent
-	bool nullify_parent = false;
-};
-
-struct CastLocalStateParameters {
-	CastLocalStateParameters(optional_ptr<ClientContext> context_p, optional_ptr<BoundCastData> cast_data_p)
-	    : context(context_p), cast_data(cast_data_p) {
-	}
-	CastLocalStateParameters(ClientContext &context_p, optional_ptr<BoundCastData> cast_data_p)
-	    : context(&context_p), cast_data(cast_data_p) {
-	}
-	CastLocalStateParameters(CastLocalStateParameters &parent, optional_ptr<BoundCastData> cast_data_p)
-	    : context(parent.context), cast_data(cast_data_p) {
-	}
-
-	optional_ptr<ClientContext> context;
-	//! The bound cast data (if any)
-	optional_ptr<BoundCastData> cast_data;
-};
-
-typedef bool (*cast_function_t)(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-typedef unique_ptr<FunctionLocalState> (*init_cast_local_state_t)(CastLocalStateParameters &parameters);
-
-struct BoundCastInfo {
-	DUCKDB_API
-	BoundCastInfo( // NOLINT: allow explicit cast from cast_function_t
-	    cast_function_t function, unique_ptr<BoundCastData> cast_data = nullptr,
-	    init_cast_local_state_t init_local_state = nullptr);
-	cast_function_t function;
-	init_cast_local_state_t init_local_state;
-	unique_ptr<BoundCastData> cast_data;
-
-public:
-	BoundCastInfo Copy() const;
-};
-
-struct BindCastInput {
-	DUCKDB_API BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCastInfo> info,
-	                         optional_ptr<ClientContext> context);
-
-	CastFunctionSet &function_set;
-	optional_ptr<BindCastInfo> info;
-	optional_ptr<ClientContext> context;
-	optional_idx query_location;
-
-public:
-	DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target);
-};
-
-struct DefaultCasts {
-	DUCKDB_API static BoundCastInfo GetDefaultCastFunction(BindCastInput &input, const LogicalType &source,
-	                                                       const LogicalType &target);
-
-	DUCKDB_API static bool NopCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-	DUCKDB_API static bool TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-	DUCKDB_API static bool ReinterpretCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-
-private:
-	static BoundCastInfo BlobCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo BitCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo DateCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo DecimalCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo EnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo IntervalCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo ArrayCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo NumericCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo PointerCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo StringCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo StructCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo TimeCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo TimeTzCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo TimestampCastSwitch(BindCastInput &input, const LogicalType &source,
-	                                         const LogicalType &target);
-	static BoundCastInfo TimestampTzCastSwitch(BindCastInput &input, const LogicalType &source,
-	                                           const LogicalType &target);
-	static BoundCastInfo TimestampNsCastSwitch(BindCastInput &input, const LogicalType &source,
-	                                           const LogicalType &target);
-	static BoundCastInfo TimestampMsCastSwitch(BindCastInput &input, const LogicalType &source,
-	                                           const LogicalType &target);
-	static BoundCastInfo TimestampSecCastSwitch(BindCastInput &input, const LogicalType &source,
-	                                            const LogicalType &target);
-	static BoundCastInfo UnionCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo UUIDCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo VarintCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo ImplicitToUnionCast(BindCastInput &input, const LogicalType &source,
-	                                         const LogicalType &target);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/cast/vector_cast_helpers.hpp b/src/duckdb/src/include/duckdb/function/cast/vector_cast_helpers.hpp
deleted file mode 100644
index 9766df4e3..000000000
--- a/src/duckdb/src/include/duckdb/function/cast/vector_cast_helpers.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast/vector_cast_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/general_cast.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/string_map_set.hpp"
-
-namespace duckdb {
-
-template <class OP>
-struct VectorStringCastOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto result = reinterpret_cast<Vector *>(dataptr);
-		return OP::template Operation<INPUT_TYPE>(input, *result);
-	}
-};
-
-template <class OP>
-struct VectorTryCastOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output))) {
-			return output;
-		}
-		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
-		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, *data);
-	}
-};
-
-template <class OP>
-struct VectorTryCastStrictOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->parameters.strict))) {
-			return output;
-		}
-		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, *data);
-	}
-};
-
-template <class OP>
-struct VectorTryCastErrorOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->parameters))) {
-			return output;
-		}
-		bool has_error = data->parameters.error_message && !data->parameters.error_message->empty();
-		return HandleVectorCastError::Operation<RESULT_TYPE>(
-		    has_error ? *data->parameters.error_message : CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask, idx,
-		    *data);
-	}
-};
-
-template <class OP>
-struct VectorTryCastStringOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(
-		        OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->result, data->parameters))) {
-			return output;
-		}
-		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, *data);
-	}
-};
-
-struct VectorDecimalCastData {
-	VectorDecimalCastData(Vector &result, CastParameters &parameters, uint8_t width_p, uint8_t scale_p)
-	    : vector_cast_data(result, parameters), width(width_p), scale(scale_p) {
-	}
-
-	VectorTryCastData vector_cast_data;
-	uint8_t width;
-	uint8_t scale;
-};
-
-template <class OP>
-struct VectorDecimalCastOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = reinterpret_cast<VectorDecimalCastData *>(dataptr);
-		RESULT_TYPE result_value;
-		if (!OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, result_value, data->vector_cast_data.parameters,
-		                                                     data->width, data->scale)) {
-			return HandleVectorCastError::Operation<RESULT_TYPE>("Failed to cast decimal value", mask, idx,
-			                                                     data->vector_cast_data);
-		}
-		return result_value;
-	}
-};
-
-struct VectorCastHelpers {
-	template <class SRC, class DST, class OP>
-	static bool TemplatedCastLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		UnaryExecutor::Execute<SRC, DST, OP>(source, result, count);
-		return true;
-	}
-
-	template <class SRC, class DST, class OP>
-	static bool TemplatedTryCastLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		VectorTryCastData input(result, parameters);
-		UnaryExecutor::GenericExecute<SRC, DST, OP>(source, result, count, &input, parameters.error_message);
-		return input.all_converted;
-	}
-
-	template <class SRC, class DST, class OP>
-	static bool TryCastLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		return TemplatedTryCastLoop<SRC, DST, VectorTryCastOperator<OP>>(source, result, count, parameters);
-	}
-
-	template <class SRC, class DST, class OP>
-	static bool TryCastStrictLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		return TemplatedTryCastLoop<SRC, DST, VectorTryCastStrictOperator<OP>>(source, result, count, parameters);
-	}
-
-	template <class SRC, class DST, class OP>
-	static bool TryCastErrorLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		return TemplatedTryCastLoop<SRC, DST, VectorTryCastErrorOperator<OP>>(source, result, count, parameters);
-	}
-
-	template <class SRC, class DST, class OP>
-	static bool TryCastStringLoop(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		return TemplatedTryCastLoop<SRC, DST, VectorTryCastStringOperator<OP>>(source, result, count, parameters);
-	}
-
-	template <class SRC, class OP>
-	static bool StringCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		D_ASSERT(result.GetType().InternalType() == PhysicalType::VARCHAR);
-		UnaryExecutor::GenericExecute<SRC, string_t, VectorStringCastOperator<OP>>(source, result, count,
-		                                                                           (void *)&result);
-		return true;
-	}
-
-	template <class SRC, class T, class OP>
-	static bool TemplatedDecimalCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters,
-	                                 uint8_t width, uint8_t scale) {
-		VectorDecimalCastData input(result, parameters, width, scale);
-		UnaryExecutor::GenericExecute<SRC, T, VectorDecimalCastOperator<OP>>(source, result, count, (void *)&input,
-		                                                                     parameters.error_message);
-		return input.vector_cast_data.all_converted;
-	}
-
-	template <class T>
-	static bool ToDecimalCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &result_type = result.GetType();
-		auto width = DecimalType::GetWidth(result_type);
-		auto scale = DecimalType::GetScale(result_type);
-		switch (result_type.InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedDecimalCast<T, int16_t, TryCastToDecimal>(source, result, count, parameters, width, scale);
-		case PhysicalType::INT32:
-			return TemplatedDecimalCast<T, int32_t, TryCastToDecimal>(source, result, count, parameters, width, scale);
-		case PhysicalType::INT64:
-			return TemplatedDecimalCast<T, int64_t, TryCastToDecimal>(source, result, count, parameters, width, scale);
-		case PhysicalType::INT128:
-			return TemplatedDecimalCast<T, hugeint_t, TryCastToDecimal>(source, result, count, parameters, width,
-			                                                            scale);
-		default:
-			throw InternalException("Unimplemented internal type for decimal");
-		}
-	}
-};
-
-struct VectorStringToList {
-	static idx_t CountPartsList(const string_t &input);
-	static bool SplitStringList(const string_t &input, string_t *child_data, idx_t &child_start, Vector &child);
-	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
-	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
-	                                       const SelectionVector *sel);
-};
-
-struct VectorStringToArray {
-	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
-	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
-	                                       const SelectionVector *sel);
-};
-
-struct VectorStringToStruct {
-	static bool SplitStruct(const string_t &input, vector<unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
-	                        string_map_t<idx_t> &child_names, vector<reference<ValidityMask>> &child_masks);
-	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
-	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
-	                                       const SelectionVector *sel);
-};
-
-struct VectorStringToMap {
-	static idx_t CountPartsMap(const string_t &input);
-	static bool SplitStringMap(const string_t &input, string_t *child_key_data, string_t *child_val_data,
-	                           idx_t &child_start, Vector &varchar_key, Vector &varchar_val);
-	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
-	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
-	                                       const SelectionVector *sel);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/cast_rules.hpp b/src/duckdb/src/include/duckdb/function/cast_rules.hpp
deleted file mode 100644
index ff61efeda..000000000
--- a/src/duckdb/src/include/duckdb/function/cast_rules.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast_rules.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-//! Contains a list of rules for casting
-class CastRules {
-public:
-	//! Returns the cost of performing an implicit cost from "from" to "to", or -1 if an implicit cast is not possible
-	static int64_t ImplicitCast(const LogicalType &from, const LogicalType &to);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/compression/compression.hpp b/src/duckdb/src/include/duckdb/function/compression/compression.hpp
deleted file mode 100644
index adf5364b7..000000000
--- a/src/duckdb/src/include/duckdb/function/compression/compression.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/compression/compression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ConstantFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct UncompressedFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct RLEFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct BitpackingFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct DictionaryCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct ChimpCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct PatasCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct AlpCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct AlpRDCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct FSSTFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct ZSTDFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
-};
-
-struct RoaringCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-struct EmptyValidityCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(const PhysicalType physical_type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/compression_function.hpp b/src/duckdb/src/include/duckdb/function/compression_function.hpp
deleted file mode 100644
index b0546a5a2..000000000
--- a/src/duckdb/src/include/duckdb/function/compression_function.hpp
+++ /dev/null
@@ -1,314 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/compression_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-class ColumnData;
-struct ColumnDataCheckpointData;
-class ColumnSegment;
-class SegmentStatistics;
-class TableFilter;
-struct ColumnSegmentState;
-
-struct ColumnFetchState;
-struct ColumnScanState;
-struct PrefetchState;
-struct SegmentScanState;
-
-class CompressionInfo {
-public:
-	explicit CompressionInfo(const idx_t block_size) : block_size(block_size) {
-	}
-
-public:
-	//! The size below which the segment is compacted on flushing.
-	idx_t GetCompactionFlushLimit() const {
-		return block_size / 5 * 4;
-	}
-	//! The block size for blocks using this compression.
-	idx_t GetBlockSize() const {
-		return block_size;
-	}
-
-private:
-	idx_t block_size;
-};
-
-struct AnalyzeState {
-	explicit AnalyzeState(const CompressionInfo &info) : info(info) {};
-	virtual ~AnalyzeState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-	CompressionInfo info;
-};
-
-struct CompressionState {
-	explicit CompressionState(const CompressionInfo &info) : info(info) {};
-	virtual ~CompressionState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-	CompressionInfo info;
-};
-
-struct CompressedSegmentState {
-	virtual ~CompressedSegmentState() {
-	}
-
-	//! Display info for PRAGMA storage_info
-	virtual string GetSegmentInfo() const { // LCOV_EXCL_START
-		return "";
-	} // LCOV_EXCL_STOP
-
-	//! Get the block ids of additional pages created by the segment
-	virtual vector<block_id_t> GetAdditionalBlocks() const { // LCOV_EXCL_START
-		return vector<block_id_t>();
-	} // LCOV_EXCL_STOP
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct CompressionAppendState {
-	explicit CompressionAppendState(BufferHandle handle_p) : handle(std::move(handle_p)) {
-	}
-	virtual ~CompressionAppendState() {
-	}
-
-	BufferHandle handle;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-//! The analyze functions are used to determine whether or not to use this compression method
-//! The system first determines the potential compression methods to use based on the physical type of the column
-//! After that the following steps are taken:
-//! 1. The init_analyze is called to initialize the analyze state of every candidate compression method
-//! 2. The analyze method is called with all of the input data in the order in which it must be stored.
-//!    analyze can return "false". In that case, the compression method is taken out of consideration early.
-//! 3. The final_analyze method is called, which should return a score for the compression method
-
-//! The system then decides which compression function to use based on the analyzed score (returned from final_analyze)
-typedef unique_ptr<AnalyzeState> (*compression_init_analyze_t)(ColumnData &col_data, PhysicalType type);
-typedef bool (*compression_analyze_t)(AnalyzeState &state, Vector &input, idx_t count);
-typedef idx_t (*compression_final_analyze_t)(AnalyzeState &state);
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-typedef unique_ptr<CompressionState> (*compression_init_compression_t)(ColumnDataCheckpointData &checkpoint_data,
-                                                                       unique_ptr<AnalyzeState> state);
-typedef void (*compression_compress_data_t)(CompressionState &state, Vector &scan_vector, idx_t count);
-typedef void (*compression_compress_finalize_t)(CompressionState &state);
-
-//===--------------------------------------------------------------------===//
-// Uncompress / Scan
-//===--------------------------------------------------------------------===//
-typedef void (*compression_init_prefetch_t)(ColumnSegment &segment, PrefetchState &prefetch_state);
-typedef unique_ptr<SegmentScanState> (*compression_init_segment_scan_t)(ColumnSegment &segment);
-
-//! Function prototype used for reading an entire vector (STANDARD_VECTOR_SIZE)
-typedef void (*compression_scan_vector_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                          Vector &result);
-//! Function prototype used for reading an arbitrary ('scan_count') number of values
-typedef void (*compression_scan_partial_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                           Vector &result, idx_t result_offset);
-//! Function prototype used for reading a subset of the values of a vector indicated by a selection vector
-typedef void (*compression_select_t)(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-                                     const SelectionVector &sel, idx_t sel_count);
-//! Function prototype used for applying a filter to a vector while scanning that vector
-typedef void (*compression_filter_t)(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-                                     SelectionVector &sel, idx_t &sel_count, const TableFilter &filter);
-//! Function prototype used for reading a single value
-typedef void (*compression_fetch_row_t)(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                                        idx_t result_idx);
-//! Function prototype used for skipping 'skip_count' values, non-trivial if random-access is not supported for the
-//! compressed data.
-typedef void (*compression_skip_t)(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count);
-
-//===--------------------------------------------------------------------===//
-// Append (optional)
-//===--------------------------------------------------------------------===//
-typedef unique_ptr<CompressedSegmentState> (*compression_init_segment_t)(
-    ColumnSegment &segment, block_id_t block_id, optional_ptr<ColumnSegmentState> segment_state);
-typedef unique_ptr<CompressionAppendState> (*compression_init_append_t)(ColumnSegment &segment);
-typedef idx_t (*compression_append_t)(CompressionAppendState &append_state, ColumnSegment &segment,
-                                      SegmentStatistics &stats, UnifiedVectorFormat &data, idx_t offset, idx_t count);
-typedef idx_t (*compression_finalize_append_t)(ColumnSegment &segment, SegmentStatistics &stats);
-typedef void (*compression_revert_append_t)(ColumnSegment &segment, idx_t start_row);
-
-//===--------------------------------------------------------------------===//
-// Serialization (optional)
-//===--------------------------------------------------------------------===//
-//! Function prototype for serializing the segment state
-typedef unique_ptr<ColumnSegmentState> (*compression_serialize_state_t)(ColumnSegment &segment);
-//! Function prototype for deserializing the segment state
-typedef unique_ptr<ColumnSegmentState> (*compression_deserialize_state_t)(Deserializer &deserializer);
-//! Function prototype for cleaning up the segment state when the column data is dropped
-typedef void (*compression_cleanup_state_t)(ColumnSegment &segment);
-
-enum class CompressionValidity : uint8_t { REQUIRES_VALIDITY, NO_VALIDITY_REQUIRED };
-
-class CompressionFunction {
-public:
-	CompressionFunction(CompressionType type, PhysicalType data_type, compression_init_analyze_t init_analyze,
-	                    compression_analyze_t analyze, compression_final_analyze_t final_analyze,
-	                    compression_init_compression_t init_compression, compression_compress_data_t compress,
-	                    compression_compress_finalize_t compress_finalize, compression_init_segment_scan_t init_scan,
-	                    compression_scan_vector_t scan_vector, compression_scan_partial_t scan_partial,
-	                    compression_fetch_row_t fetch_row, compression_skip_t skip,
-	                    compression_init_segment_t init_segment = nullptr,
-	                    compression_init_append_t init_append = nullptr, compression_append_t append = nullptr,
-	                    compression_finalize_append_t finalize_append = nullptr,
-	                    compression_revert_append_t revert_append = nullptr,
-	                    compression_serialize_state_t serialize_state = nullptr,
-	                    compression_deserialize_state_t deserialize_state = nullptr,
-	                    compression_cleanup_state_t cleanup_state = nullptr,
-	                    compression_init_prefetch_t init_prefetch = nullptr, compression_select_t select = nullptr,
-	                    compression_filter_t filter = nullptr)
-	    : type(type), data_type(data_type), init_analyze(init_analyze), analyze(analyze), final_analyze(final_analyze),
-	      init_compression(init_compression), compress(compress), compress_finalize(compress_finalize),
-	      init_prefetch(init_prefetch), init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial),
-	      select(select), filter(filter), fetch_row(fetch_row), skip(skip), init_segment(init_segment),
-	      init_append(init_append), append(append), finalize_append(finalize_append), revert_append(revert_append),
-	      serialize_state(serialize_state), deserialize_state(deserialize_state), cleanup_state(cleanup_state) {
-	}
-
-	//! Compression type
-	CompressionType type;
-	//! The data type this function can compress
-	PhysicalType data_type;
-
-	//! Analyze step: determine which compression function is the most effective
-	//! init_analyze is called once to set up the analyze state
-	compression_init_analyze_t init_analyze;
-	//! analyze is called several times (once per vector in the row group)
-	//! analyze should return true, unless compression is no longer possible with this compression method
-	//! in that case false should be returned
-	compression_analyze_t analyze;
-	//! final_analyze should return the score of the compression function
-	//! ideally this is the exact number of bytes required to store the data
-	//! this is not required/enforced: it can be an estimate as well
-	//! also this function can return DConstants::INVALID_INDEX to skip this compression method
-	compression_final_analyze_t final_analyze;
-
-	//! Compression step: actually compress the data
-	//! init_compression is called once to set up the comperssion state
-	compression_init_compression_t init_compression;
-	//! compress is called several times (once per vector in the row group)
-	compression_compress_data_t compress;
-	//! compress_finalize is called after
-	compression_compress_finalize_t compress_finalize;
-
-	//! Initialize prefetch state with required I/O data to scan this segment
-	compression_init_prefetch_t init_prefetch;
-	//! init_scan is called to set up the scan state
-	compression_init_segment_scan_t init_scan;
-	//! scan_vector scans an entire vector using the scan state
-	compression_scan_vector_t scan_vector;
-	//! scan_partial scans a subset of a vector
-	//! this can request > vector_size as well
-	//! this is used if a vector crosses segment boundaries, or for child columns of lists
-	compression_scan_partial_t scan_partial;
-	//! scan a subset of a vector
-	compression_select_t select;
-	//! Scan and apply a filter to a vector while scanning
-	compression_filter_t filter;
-	//! fetch an individual row from the compressed vector
-	//! used for index lookups
-	compression_fetch_row_t fetch_row;
-	//! Skip forward in the compressed segment
-	compression_skip_t skip;
-
-	// Append functions
-	//! This only really needs to be defined for uncompressed segments
-
-	//! Initialize a compressed segment (optional)
-	compression_init_segment_t init_segment;
-	//! Initialize the append state (optional)
-	compression_init_append_t init_append;
-	//! Append to the compressed segment (optional)
-	compression_append_t append;
-	//! Finalize an append to the segment
-	compression_finalize_append_t finalize_append;
-	//! Revert append (optional)
-	compression_revert_append_t revert_append;
-
-	// State serialize functions
-	//! This is only necessary if the segment state has information that must be written to disk in the metadata
-
-	//! Serialize the segment state to the metadata (optional)
-	compression_serialize_state_t serialize_state;
-	//! Deserialize the segment state to the metadata (optional)
-	compression_deserialize_state_t deserialize_state;
-	//! Cleanup the segment state (optional)
-	compression_cleanup_state_t cleanup_state;
-
-	//! Whether the validity mask should be separately compressed
-	//! or this compression function can also be used to decompress the validity
-	CompressionValidity validity = CompressionValidity::REQUIRES_VALIDITY;
-};
-
-//! The set of compression functions
-struct CompressionFunctionSet {
-	mutex lock;
-	map<CompressionType, map<PhysicalType, CompressionFunction>> functions;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/copy_function.hpp b/src/duckdb/src/include/duckdb/function/copy_function.hpp
deleted file mode 100644
index 00e4f4da4..000000000
--- a/src/duckdb/src/include/duckdb/function/copy_function.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/copy_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-
-namespace duckdb {
-
-class Binder;
-struct BoundStatement;
-class ColumnDataCollection;
-class ExecutionContext;
-
-struct LocalFunctionData {
-	virtual ~LocalFunctionData() = default;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct GlobalFunctionData {
-	virtual ~GlobalFunctionData() = default;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct PreparedBatchData {
-	virtual ~PreparedBatchData() = default;
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct CopyFunctionBindInput {
-	explicit CopyFunctionBindInput(const CopyInfo &info_p) : info(info_p) {
-	}
-
-	const CopyInfo &info;
-
-	string file_extension;
-};
-
-struct CopyToSelectInput {
-	ClientContext &context;
-	case_insensitive_map_t<vector<Value>> &options;
-	vector<unique_ptr<Expression>> select_list;
-	CopyToType copy_to_type;
-};
-
-enum class CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };
-
-typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);
-typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyFunctionBindInput &input,
-                                                   const vector<string> &names, const vector<LogicalType> &sql_types);
-typedef unique_ptr<LocalFunctionData> (*copy_to_initialize_local_t)(ExecutionContext &context, FunctionData &bind_data);
-typedef unique_ptr<GlobalFunctionData> (*copy_to_initialize_global_t)(ClientContext &context, FunctionData &bind_data,
-                                                                      const string &file_path);
-typedef void (*copy_to_sink_t)(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                               LocalFunctionData &lstate, DataChunk &input);
-typedef void (*copy_to_combine_t)(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                                  LocalFunctionData &lstate);
-typedef void (*copy_to_finalize_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate);
-
-typedef void (*copy_to_serialize_t)(Serializer &serializer, const FunctionData &bind_data,
-                                    const CopyFunction &function);
-
-typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(Deserializer &deserializer, CopyFunction &function);
-
-typedef unique_ptr<FunctionData> (*copy_from_bind_t)(ClientContext &context, CopyInfo &info,
-                                                     vector<string> &expected_names,
-                                                     vector<LogicalType> &expected_types);
-typedef CopyFunctionExecutionMode (*copy_to_execution_mode_t)(bool preserve_insertion_order, bool supports_batch_index);
-
-typedef unique_ptr<PreparedBatchData> (*copy_prepare_batch_t)(ClientContext &context, FunctionData &bind_data,
-                                                              GlobalFunctionData &gstate,
-                                                              unique_ptr<ColumnDataCollection> collection);
-typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                                   PreparedBatchData &batch);
-typedef idx_t (*copy_desired_batch_size_t)(ClientContext &context, FunctionData &bind_data);
-
-typedef bool (*copy_rotate_files_t)(FunctionData &bind_data, const optional_idx &file_size_bytes);
-
-typedef bool (*copy_rotate_next_file_t)(GlobalFunctionData &gstate, FunctionData &bind_data,
-                                        const optional_idx &file_size_bytes);
-
-typedef vector<unique_ptr<Expression>> (*copy_to_select_t)(CopyToSelectInput &input);
-
-enum class CopyFunctionReturnType : uint8_t { CHANGED_ROWS = 0, CHANGED_ROWS_AND_FILE_LIST = 1 };
-vector<string> GetCopyFunctionReturnNames(CopyFunctionReturnType return_type);
-vector<LogicalType> GetCopyFunctionReturnLogicalTypes(CopyFunctionReturnType return_type);
-
-class CopyFunction : public Function { // NOLINT: work-around bug in clang-tidy
-public:
-	explicit CopyFunction(const string &name)
-	    : Function(name), plan(nullptr), copy_to_select(nullptr), copy_to_bind(nullptr),
-	      copy_to_initialize_local(nullptr), copy_to_initialize_global(nullptr), copy_to_sink(nullptr),
-	      copy_to_combine(nullptr), copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr),
-	      flush_batch(nullptr), desired_batch_size(nullptr), rotate_files(nullptr), rotate_next_file(nullptr),
-	      serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
-	}
-
-	//! Plan rewrite copy function
-	copy_to_plan_t plan;
-
-	copy_to_select_t copy_to_select;
-	copy_to_bind_t copy_to_bind;
-	copy_to_initialize_local_t copy_to_initialize_local;
-	copy_to_initialize_global_t copy_to_initialize_global;
-	copy_to_sink_t copy_to_sink;
-	copy_to_combine_t copy_to_combine;
-	copy_to_finalize_t copy_to_finalize;
-	copy_to_execution_mode_t execution_mode;
-
-	copy_prepare_batch_t prepare_batch;
-	copy_flush_batch_t flush_batch;
-	copy_desired_batch_size_t desired_batch_size;
-
-	copy_rotate_files_t rotate_files;
-	copy_rotate_next_file_t rotate_next_file;
-
-	copy_to_serialize_t serialize;
-	copy_to_deserialize_t deserialize;
-
-	copy_from_bind_t copy_from_bind;
-	TableFunction copy_from_function;
-
-	string extension;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/create_sort_key.hpp b/src/duckdb/src/include/duckdb/function/create_sort_key.hpp
deleted file mode 100644
index ab5e6bc19..000000000
--- a/src/duckdb/src/include/duckdb/function/create_sort_key.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/create_sort_key.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct OrderModifiers {
-	OrderModifiers(OrderType order_type, OrderByNullType null_type) : order_type(order_type), null_type(null_type) {
-	}
-
-	OrderType order_type;
-	OrderByNullType null_type;
-
-	bool operator==(const OrderModifiers &other) const {
-		return order_type == other.order_type && null_type == other.null_type;
-	}
-
-	static OrderModifiers Parse(const string &val) {
-		auto lcase = StringUtil::Replace(StringUtil::Lower(val), "_", " ");
-		OrderType order_type;
-		if (StringUtil::StartsWith(lcase, "asc")) {
-			order_type = OrderType::ASCENDING;
-		} else if (StringUtil::StartsWith(lcase, "desc")) {
-			order_type = OrderType::DESCENDING;
-		} else {
-			throw BinderException("create_sort_key modifier must start with either ASC or DESC");
-		}
-		OrderByNullType null_type;
-		if (StringUtil::EndsWith(lcase, "nulls first")) {
-			null_type = OrderByNullType::NULLS_FIRST;
-		} else if (StringUtil::EndsWith(lcase, "nulls last")) {
-			null_type = OrderByNullType::NULLS_LAST;
-		} else {
-			throw BinderException("create_sort_key modifier must end with either NULLS FIRST or NULLS LAST");
-		}
-		return OrderModifiers(order_type, null_type);
-	}
-};
-
-struct CreateSortKeyHelpers {
-	static void CreateSortKey(DataChunk &input, const vector<OrderModifiers> &modifiers, Vector &result);
-	static void CreateSortKey(Vector &input, idx_t input_count, OrderModifiers modifiers, Vector &result);
-	static void DecodeSortKey(string_t sort_key, Vector &result, idx_t result_idx, OrderModifiers modifiers);
-	static void DecodeSortKey(string_t sort_key, DataChunk &result, idx_t result_idx,
-	                          const vector<OrderModifiers> &modifiers);
-	static void CreateSortKeyWithValidity(Vector &input, Vector &result, const OrderModifiers &modifiers,
-	                                      const idx_t count);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/encoding_function.hpp b/src/duckdb/src/include/duckdb/function/encoding_function.hpp
deleted file mode 100644
index f9e042e11..000000000
--- a/src/duckdb/src/include/duckdb/function/encoding_function.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/encoding_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-struct DBConfig;
-
-//! Decode function, basically takes information about the decoded and the encoded buffers.
-typedef void (*encode_t)(const char *encoded_buffer, idx_t &encoded_buffer_current_position,
-                         const idx_t encoded_buffer_size, char *decoded_buffer, idx_t &decoded_buffer_current_position,
-                         const idx_t decoded_buffer_size, char *remaining_bytes_buffer, idx_t &remaining_bytes_size);
-
-class EncodingFunction {
-public:
-	EncodingFunction() : encode_function(nullptr), ratio(0), bytes_per_iteration(0) {
-	}
-
-	EncodingFunction(const string &encode_type, encode_t encode_function, const idx_t ratio,
-	                 const idx_t bytes_per_iteration)
-	    : encoding_type(encode_type), encode_function(encode_function), ratio(ratio),
-	      bytes_per_iteration(bytes_per_iteration) {
-		D_ASSERT(ratio > 0);
-		D_ASSERT(encode_function);
-		D_ASSERT(bytes_per_iteration > 0);
-	};
-
-	~EncodingFunction() {};
-
-	string GetType() const {
-		return encoding_type;
-	}
-	encode_t GetFunction() const {
-		return encode_function;
-	}
-	idx_t GetRatio() const {
-		return ratio;
-	}
-	idx_t GetBytesPerIteration() const {
-		return bytes_per_iteration;
-	}
-
-private:
-	//! The encoding type of this function (e.g., utf-8)
-	string encoding_type;
-	//! The actual encoding function
-	encode_t encode_function;
-	//! Ratio of the max size this encoded buffer could ever reach on a decoded buffer
-	idx_t ratio;
-	//! How many bytes in the decoded buffer one iteration of the encoded function can cause.
-	//! e.g., one iteration of Latin-1 to UTF-8 can generate max 2 bytes.
-	//! However, one iteration of UTF-16 to UTF-8, can generate up to 3 UTF-8 bytes.
-	idx_t bytes_per_iteration;
-};
-
-//! The set of encoding functions
-struct EncodingFunctionSet {
-	EncodingFunctionSet() {};
-	static void Initialize(DBConfig &config);
-	mutex lock;
-	case_insensitive_map_t<EncodingFunction> functions;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/function.hpp b/src/duckdb/src/include/duckdb/function/function.hpp
deleted file mode 100644
index 9d39ef2f5..000000000
--- a/src/duckdb/src/include/duckdb/function/function.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/named_parameter_map.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/main/external_dependencies.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/enums/function_errors.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-class Catalog;
-class ClientContext;
-class Expression;
-class ExpressionExecutor;
-class Transaction;
-
-class AggregateFunction;
-class AggregateFunctionSet;
-class CopyFunction;
-class PragmaFunction;
-class PragmaFunctionSet;
-class ScalarFunctionSet;
-class ScalarFunction;
-class TableFunctionSet;
-class TableFunction;
-class SimpleFunction;
-
-struct PragmaInfo;
-
-//! The default null handling is NULL in, NULL out
-enum class FunctionNullHandling : uint8_t { DEFAULT_NULL_HANDLING = 0, SPECIAL_HANDLING = 1 };
-//! The stability of the function, used by the optimizer
-//! CONSISTENT              -> this function always returns the same result when given the same input, no variance
-//! CONSISTENT_WITHIN_QUERY -> this function returns the same result WITHIN the same query/transaction
-//!                            but the result might change across queries (e.g. NOW(), CURRENT_TIME)
-//! VOLATILE                -> the result of this function might change per row (e.g. RANDOM())
-enum class FunctionStability : uint8_t { CONSISTENT = 0, VOLATILE = 1, CONSISTENT_WITHIN_QUERY = 2 };
-
-//! How to handle collations
-//! PROPAGATE_COLLATIONS        -> this function combines collation from its inputs and emits them again (default)
-//! PUSH_COMBINABLE_COLLATIONS  -> combinable collations are executed for the input arguments
-//! IGNORE_COLLATIONS           -> collations are completely ignored by the function
-enum class FunctionCollationHandling : uint8_t {
-	PROPAGATE_COLLATIONS = 0,
-	PUSH_COMBINABLE_COLLATIONS = 1,
-	IGNORE_COLLATIONS = 2
-};
-
-struct FunctionData {
-	DUCKDB_API virtual ~FunctionData();
-
-	DUCKDB_API virtual unique_ptr<FunctionData> Copy() const = 0;
-	DUCKDB_API virtual bool Equals(const FunctionData &other) const = 0;
-	DUCKDB_API static bool Equals(const FunctionData *left, const FunctionData *right);
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-	// FIXME: this function should be removed in the future
-	template <class TARGET>
-	TARGET &CastNoConst() const {
-		return const_cast<TARGET &>(Cast<TARGET>()); // NOLINT: FIXME
-	}
-};
-
-struct TableFunctionData : public FunctionData {
-	// used to pass on projections to table functions that support them. NB, can contain COLUMN_IDENTIFIER_ROW_ID
-	vector<idx_t> column_ids;
-
-	DUCKDB_API ~TableFunctionData() override;
-
-	DUCKDB_API unique_ptr<FunctionData> Copy() const override;
-	DUCKDB_API bool Equals(const FunctionData &other) const override;
-};
-
-struct FunctionParameters {
-	vector<Value> values;
-	named_parameter_map_t named_parameters;
-};
-
-//! Function is the base class used for any type of function (scalar, aggregate or simple function)
-class Function {
-public:
-	DUCKDB_API explicit Function(string name);
-	DUCKDB_API virtual ~Function();
-
-	//! The name of the function
-	string name;
-	//! Additional Information to specify function from it's name
-	string extra_info;
-
-public:
-	//! Returns the formatted string name(arg1, arg2, ...)
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const LogicalType &varargs = LogicalType::INVALID);
-	//! Returns the formatted string name(arg1, arg2..) -> return_type
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const LogicalType &varargs, const LogicalType &return_type);
-	//! Returns the formatted string name(arg1, arg2.., np1=a, np2=b, ...)
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const named_parameter_type_map_t &named_parameters);
-
-	//! Used in the bind to erase an argument from a function
-	DUCKDB_API static void EraseArgument(SimpleFunction &bound_function, vector<unique_ptr<Expression>> &arguments,
-	                                     idx_t argument_index);
-};
-
-class SimpleFunction : public Function {
-public:
-	DUCKDB_API SimpleFunction(string name, vector<LogicalType> arguments,
-	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-	DUCKDB_API ~SimpleFunction() override;
-
-	//! The set of arguments of the function
-	vector<LogicalType> arguments;
-	//! The set of original arguments of the function - only set if Function::EraseArgument is called
-	//! Used for (de)serialization purposes
-	vector<LogicalType> original_arguments;
-	//! The type of varargs to support, or LogicalTypeId::INVALID if the function does not accept variable length
-	//! arguments
-	LogicalType varargs;
-
-public:
-	DUCKDB_API virtual string ToString() const;
-
-	DUCKDB_API bool HasVarArgs() const;
-};
-
-class SimpleNamedParameterFunction : public SimpleFunction {
-public:
-	DUCKDB_API SimpleNamedParameterFunction(string name, vector<LogicalType> arguments,
-	                                        LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-	DUCKDB_API ~SimpleNamedParameterFunction() override;
-
-	//! The named parameters of the function
-	named_parameter_type_map_t named_parameters;
-
-public:
-	DUCKDB_API string ToString() const override;
-	DUCKDB_API bool HasNamedParameters() const;
-};
-
-class BaseScalarFunction : public SimpleFunction {
-public:
-	DUCKDB_API BaseScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-	                              FunctionStability stability,
-	                              LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                              FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
-	                              FunctionErrors errors = FunctionErrors::CANNOT_ERROR);
-	DUCKDB_API ~BaseScalarFunction() override;
-
-	//! Return type of the function
-	LogicalType return_type;
-	//! The stability of the function (see FunctionStability enum for more info)
-	FunctionStability stability;
-	//! How this function handles NULL values
-	FunctionNullHandling null_handling;
-	//! Whether or not this function can throw an error
-	FunctionErrors errors;
-	//! Collation handling of the function
-	FunctionCollationHandling collation_handling;
-
-	static BaseScalarFunction SetReturnsError(BaseScalarFunction &function) {
-		function.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR;
-		return function;
-	}
-
-public:
-	DUCKDB_API hash_t Hash() const;
-
-	DUCKDB_API string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/function_binder.hpp b/src/duckdb/src/include/duckdb/function/function_binder.hpp
deleted file mode 100644
index 3bec4d379..000000000
--- a/src/duckdb/src/include/duckdb/function/function_binder.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/error_data.hpp"
-
-namespace duckdb {
-
-//! The FunctionBinder class is responsible for binding functions
-class FunctionBinder {
-public:
-	DUCKDB_API explicit FunctionBinder(Binder &binder);
-	DUCKDB_API explicit FunctionBinder(ClientContext &context);
-
-	optional_ptr<Binder> binder;
-	ClientContext &context;
-
-public:
-	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
-	//! returns optional_idx() and sets error if none could be found
-	DUCKDB_API optional_idx BindFunction(const string &name, ScalarFunctionSet &functions,
-	                                     const vector<LogicalType> &arguments, ErrorData &error);
-	DUCKDB_API optional_idx BindFunction(const string &name, ScalarFunctionSet &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, ErrorData &error);
-	//! Bind an aggregate function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns optional_idx() and sets error if none could be found
-	DUCKDB_API optional_idx BindFunction(const string &name, AggregateFunctionSet &functions,
-	                                     const vector<LogicalType> &arguments, ErrorData &error);
-	DUCKDB_API optional_idx BindFunction(const string &name, AggregateFunctionSet &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, ErrorData &error);
-	//! Bind a table function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns optional_idx() and sets error if none could be found
-	DUCKDB_API optional_idx BindFunction(const string &name, TableFunctionSet &functions,
-	                                     const vector<LogicalType> &arguments, ErrorData &error);
-	DUCKDB_API optional_idx BindFunction(const string &name, TableFunctionSet &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, ErrorData &error);
-	//! Bind a pragma function from the set of functions and input arguments
-	DUCKDB_API optional_idx BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
-	                                     ErrorData &error);
-
-	DUCKDB_API unique_ptr<Expression> BindScalarFunction(const string &schema, const string &name,
-	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
-	                                                     bool is_operator = false,
-	                                                     optional_ptr<Binder> binder = nullptr);
-	DUCKDB_API unique_ptr<Expression> BindScalarFunction(ScalarFunctionCatalogEntry &function,
-	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
-	                                                     bool is_operator = false,
-	                                                     optional_ptr<Binder> binder = nullptr);
-
-	DUCKDB_API unique_ptr<Expression> BindScalarFunction(ScalarFunction bound_function,
-	                                                     vector<unique_ptr<Expression>> children,
-	                                                     bool is_operator = false,
-	                                                     optional_ptr<Binder> binder = nullptr);
-
-	DUCKDB_API unique_ptr<BoundAggregateExpression>
-	BindAggregateFunction(AggregateFunction bound_function, vector<unique_ptr<Expression>> children,
-	                      unique_ptr<Expression> filter = nullptr,
-	                      AggregateType aggr_type = AggregateType::NON_DISTINCT);
-
-	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
-	                                           const vector<unique_ptr<Expression>> &groups);
-	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr);
-
-private:
-	//! Cast a set of expressions to the arguments of this function
-	void CastToFunctionArguments(SimpleFunction &function, vector<unique_ptr<Expression>> &children);
-	optional_idx BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
-	optional_idx BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
-
-	template <class T>
-	vector<idx_t> BindFunctionsFromArguments(const string &name, FunctionSet<T> &functions,
-	                                         const vector<LogicalType> &arguments, ErrorData &error);
-
-	template <class T>
-	optional_idx MultipleCandidateException(const string &name, FunctionSet<T> &functions,
-	                                        vector<idx_t> &candidate_functions, const vector<LogicalType> &arguments,
-	                                        ErrorData &error);
-
-	template <class T>
-	optional_idx BindFunctionFromArguments(const string &name, FunctionSet<T> &functions,
-	                                       const vector<LogicalType> &arguments, ErrorData &error);
-
-	vector<LogicalType> GetLogicalTypesFromExpressions(vector<unique_ptr<Expression>> &arguments);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/function_list.hpp b/src/duckdb/src/include/duckdb/function/function_list.hpp
deleted file mode 100644
index feccb823b..000000000
--- a/src/duckdb/src/include/duckdb/function/function_list.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function_list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-
-namespace duckdb {
-
-typedef ScalarFunction (*get_scalar_function_t)();
-typedef ScalarFunctionSet (*get_scalar_function_set_t)();
-typedef AggregateFunction (*get_aggregate_function_t)();
-typedef AggregateFunctionSet (*get_aggregate_function_set_t)();
-
-struct StaticFunctionDefinition {
-	const char *name;
-	const char *parameters;
-	const char *description;
-	const char *example;
-	get_scalar_function_t get_function;
-	get_scalar_function_set_t get_function_set;
-	get_aggregate_function_t get_aggregate_function;
-	get_aggregate_function_set_t get_aggregate_function_set;
-};
-
-class Catalog;
-struct CatalogTransaction;
-
-struct FunctionList {
-	static const StaticFunctionDefinition *GetInternalFunctionList();
-	static void RegisterFunctions(Catalog &catalog, CatalogTransaction transaction);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/function_serialization.hpp b/src/duckdb/src/include/duckdb/function/function_serialization.hpp
deleted file mode 100644
index 8f8ed65f2..000000000
--- a/src/duckdb/src/include/duckdb/function/function_serialization.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function_serialization.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-class FunctionSerializer {
-public:
-	template <class FUNC>
-	static void Serialize(Serializer &serializer, const FUNC &function, optional_ptr<FunctionData> bind_info) {
-		D_ASSERT(!function.name.empty());
-		serializer.WriteProperty(500, "name", function.name);
-		serializer.WriteProperty(501, "arguments", function.arguments);
-		serializer.WriteProperty(502, "original_arguments", function.original_arguments);
-		bool has_serialize = function.serialize;
-		serializer.WriteProperty(503, "has_serialize", has_serialize);
-		if (has_serialize) {
-			serializer.WriteObject(504, "function_data",
-			                       [&](Serializer &obj) { function.serialize(obj, bind_info, function); });
-			D_ASSERT(function.deserialize);
-		}
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC DeserializeFunction(ClientContext &context, CatalogType catalog_type, const string &name,
-	                                vector<LogicalType> arguments, vector<LogicalType> original_arguments) {
-		auto &func_catalog = Catalog::GetEntry(context, catalog_type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
-		if (func_catalog.type != catalog_type) {
-			throw InternalException("DeserializeFunction - cant find catalog entry for function %s", name);
-		}
-		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
-		auto function = functions.functions.GetFunctionByArguments(
-		    context, original_arguments.empty() ? arguments : original_arguments);
-		function.arguments = std::move(arguments);
-		function.original_arguments = std::move(original_arguments);
-		return function;
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static pair<FUNC, bool> DeserializeBase(Deserializer &deserializer, CatalogType catalog_type) {
-		auto &context = deserializer.Get<ClientContext &>();
-		auto name = deserializer.ReadProperty<string>(500, "name");
-		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
-		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>(502, "original_arguments");
-		auto function = DeserializeFunction<FUNC, CATALOG_ENTRY>(context, catalog_type, name, std::move(arguments),
-		                                                         std::move(original_arguments));
-		auto has_serialize = deserializer.ReadProperty<bool>(503, "has_serialize");
-		return make_pair(std::move(function), has_serialize);
-	}
-
-	template <class FUNC>
-	static unique_ptr<FunctionData> FunctionDeserialize(Deserializer &deserializer, FUNC &function) {
-		if (!function.deserialize) {
-			throw SerializationException("Function requires deserialization but no deserialization function for %s",
-			                             function.name);
-		}
-		unique_ptr<FunctionData> result;
-		deserializer.ReadObject(504, "function_data",
-		                        [&](Deserializer &obj) { result = function.deserialize(obj, function); });
-		return result;
-	}
-
-	static bool TypeRequiresAssignment(const LogicalType &type) {
-		switch (type.id()) {
-		case LogicalTypeId::SQLNULL:
-		case LogicalTypeId::ANY:
-		case LogicalTypeId::INVALID:
-			return true;
-		case LogicalTypeId::DECIMAL:
-		case LogicalTypeId::UNION:
-		case LogicalTypeId::MAP:
-			if (!type.AuxInfo()) {
-				return true;
-			}
-			return false;
-		case LogicalTypeId::LIST:
-			if (!type.AuxInfo()) {
-				return true;
-			}
-			return TypeRequiresAssignment(ListType::GetChildType(type));
-		case LogicalTypeId::ARRAY:
-			if (!type.AuxInfo()) {
-				return true;
-			}
-			return TypeRequiresAssignment(ArrayType::GetChildType(type));
-		case LogicalTypeId::STRUCT:
-			if (!type.AuxInfo()) {
-				return true;
-			}
-			if (StructType::GetChildCount(type) == 0) {
-				return true;
-			}
-			return false;
-		default:
-			return false;
-		}
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static pair<FUNC, unique_ptr<FunctionData>> Deserialize(Deserializer &deserializer, CatalogType catalog_type,
-	                                                        vector<unique_ptr<Expression>> &children,
-	                                                        LogicalType return_type) { // NOLINT: clang-tidy bug
-		auto &context = deserializer.Get<ClientContext &>();
-		auto entry = DeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
-		auto &function = entry.first;
-		auto has_serialize = entry.second;
-
-		unique_ptr<FunctionData> bind_data;
-		if (has_serialize) {
-			deserializer.Set<const LogicalType &>(return_type);
-			bind_data = FunctionDeserialize<FUNC>(deserializer, function);
-			deserializer.Unset<LogicalType>();
-		} else if (function.bind) {
-			try {
-				bind_data = function.bind(context, function, children);
-			} catch (std::exception &ex) {
-				ErrorData error(ex);
-				throw SerializationException("Error during bind of function in deserialization: %s",
-				                             error.RawMessage());
-			}
-		}
-		if (TypeRequiresAssignment(function.return_type)) {
-			function.return_type = std::move(return_type);
-		}
-		return make_pair(std::move(function), std::move(bind_data));
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/function_set.hpp b/src/duckdb/src/include/duckdb/function/function_set.hpp
deleted file mode 100644
index 3a0a223b1..000000000
--- a/src/duckdb/src/include/duckdb/function/function_set.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/pragma_function.hpp"
-
-namespace duckdb {
-
-template <class T>
-class FunctionSet {
-public:
-	explicit FunctionSet(string name) : name(std::move(name)) {
-	}
-
-	//! The name of the function set
-	string name;
-	//! The set of functions.
-	vector<T> functions;
-
-public:
-	void AddFunction(T function) {
-		functions.push_back(std::move(function));
-	}
-	idx_t Size() {
-		return functions.size();
-	}
-	T GetFunctionByOffset(idx_t offset) {
-		D_ASSERT(offset < functions.size());
-		return functions[offset];
-	}
-	T &GetFunctionReferenceByOffset(idx_t offset) {
-		D_ASSERT(offset < functions.size());
-		return functions[offset];
-	}
-	bool MergeFunctionSet(FunctionSet<T> new_functions, bool override = false) {
-		D_ASSERT(!new_functions.functions.empty());
-		for (auto &new_func : new_functions.functions) {
-			bool overwritten = false;
-			for (auto &func : functions) {
-				if (new_func.Equal(func)) {
-					// function overload already exists
-					if (override) {
-						// override it
-						overwritten = true;
-						func = new_func;
-					} else {
-						// throw an error
-						return false;
-					}
-					break;
-				}
-			}
-			if (!overwritten) {
-				functions.push_back(new_func);
-			}
-		}
-		return true;
-	}
-};
-
-class ScalarFunctionSet : public FunctionSet<ScalarFunction> {
-public:
-	DUCKDB_API explicit ScalarFunctionSet();
-	DUCKDB_API explicit ScalarFunctionSet(string name);
-	DUCKDB_API explicit ScalarFunctionSet(ScalarFunction fun);
-
-	DUCKDB_API ScalarFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
-};
-
-class AggregateFunctionSet : public FunctionSet<AggregateFunction> {
-public:
-	DUCKDB_API explicit AggregateFunctionSet();
-	DUCKDB_API explicit AggregateFunctionSet(string name);
-	DUCKDB_API explicit AggregateFunctionSet(AggregateFunction fun);
-
-	DUCKDB_API AggregateFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
-};
-
-class TableFunctionSet : public FunctionSet<TableFunction> {
-public:
-	DUCKDB_API explicit TableFunctionSet(string name);
-	DUCKDB_API explicit TableFunctionSet(TableFunction fun);
-
-	TableFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
-};
-
-class PragmaFunctionSet : public FunctionSet<PragmaFunction> {
-public:
-	DUCKDB_API explicit PragmaFunctionSet(string name);
-	DUCKDB_API explicit PragmaFunctionSet(PragmaFunction fun);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/lambda_functions.hpp b/src/duckdb/src/include/duckdb/function/lambda_functions.hpp
deleted file mode 100644
index a47894a39..000000000
--- a/src/duckdb/src/include/duckdb/function/lambda_functions.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/lambda_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/execution/expression_executor_state.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-struct ListLambdaBindData : public FunctionData {
-public:
-	ListLambdaBindData(const LogicalType &return_type, unique_ptr<Expression> lambda_expr, const bool has_index = false)
-	    : return_type(return_type), lambda_expr(std::move(lambda_expr)), has_index(has_index) {};
-
-	//! Return type of the scalar function
-	LogicalType return_type;
-	//! Lambda expression that the expression executor executes
-	unique_ptr<Expression> lambda_expr;
-	//! True, if the last parameter in a lambda parameter list represents the index of the current list element
-	bool has_index;
-
-public:
-	bool Equals(const FunctionData &other_p) const override;
-	unique_ptr<FunctionData> Copy() const override;
-
-	//! Serializes a lambda function's bind data
-	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                      const ScalarFunction &function);
-	//! Deserializes a lambda function's bind data
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &);
-};
-
-class LambdaFunctions {
-public:
-	//! Returns the parameter type for binary lambdas
-	static LogicalType BindBinaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type);
-	//! Returns the parameter type for ternary lambdas
-	static LogicalType BindTernaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type);
-
-	//! Checks for NULL list parameter and prepared statements and adds bound cast expression
-	static unique_ptr<FunctionData> ListLambdaPrepareBind(vector<unique_ptr<Expression>> &arguments,
-	                                                      ClientContext &context, ScalarFunction &bound_function);
-
-	//! Returns the ListLambdaBindData containing the lambda expression
-	static unique_ptr<FunctionData> ListLambdaBind(ClientContext &, ScalarFunction &bound_function,
-	                                               vector<unique_ptr<Expression>> &arguments,
-	                                               const bool has_index = false);
-
-	//! Internally executes list_transform
-	static void ListTransformFunction(DataChunk &args, ExpressionState &state, Vector &result);
-	//! Internally executes list_filter
-	static void ListFilterFunction(DataChunk &args, ExpressionState &state, Vector &result);
-	//! Internally executes list_reduce
-	static void ListReduceFunction(DataChunk &args, ExpressionState &state, Vector &result);
-
-public:
-	//! Lambda expressions can only be executed on one STANDARD_VECTOR_SIZE list child elements at a time, so for
-	//! list_transform and list_filter we need to prepare the input vectors for the lambda expression.  In list_reduce
-	//! the input size can never exceed row_count so it doesn't need ColumnInfo.
-	struct ColumnInfo {
-		explicit ColumnInfo(Vector &vector) : vector(vector), sel(SelectionVector(STANDARD_VECTOR_SIZE)) {};
-
-		//! The original vector taken from args
-		reference<Vector> vector;
-		//! The selection vector to slice the original vector
-		SelectionVector sel;
-		//! The unified vector format of the original vector
-		UnifiedVectorFormat format;
-	};
-
-	//! LambdaInfo sets up and stores the information needed by all lambda functions
-	struct LambdaInfo {
-		explicit LambdaInfo(DataChunk &args, ExpressionState &state, Vector &result, bool &result_is_null)
-		    : result(result), row_count(args.size()), is_all_constant(args.AllConstant()) {
-			Vector &list_column = args.data[0];
-
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			result_validity = &FlatVector::Validity(result);
-
-			if (list_column.GetType().id() == LogicalTypeId::SQLNULL) {
-				result.SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result, true);
-				result_is_null = true;
-				return;
-			}
-
-			// get the lambda expression
-			auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-			auto &bind_info = func_expr.bind_info->Cast<ListLambdaBindData>();
-			lambda_expr = bind_info.lambda_expr;
-			is_volatile = lambda_expr->IsVolatile();
-			has_index = bind_info.has_index;
-
-			// get the list column entries
-			list_column.ToUnifiedFormat(row_count, list_column_format);
-			list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_column_format);
-			child_vector = &ListVector::GetEntry(list_column);
-
-			// get the lambda column data for all other input vectors
-			column_infos = LambdaFunctions::GetColumnInfo(args, row_count);
-		};
-
-		const list_entry_t *list_entries;
-		UnifiedVectorFormat list_column_format;
-		optional_ptr<Vector> child_vector;
-		Vector &result;
-		optional_ptr<ValidityMask> result_validity;
-		vector<ColumnInfo> column_infos;
-		optional_ptr<Expression> lambda_expr;
-
-		const idx_t row_count;
-		bool has_index;
-		bool is_volatile;
-		const bool is_all_constant;
-	};
-
-	static vector<ColumnInfo> GetColumnInfo(DataChunk &args, const idx_t row_count);
-	static vector<reference<ColumnInfo>> GetMutableColumnInfo(vector<ColumnInfo> &data);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/macro_function.hpp b/src/duckdb/src/include/duckdb/function/macro_function.hpp
deleted file mode 100644
index b76a3087a..000000000
--- a/src/duckdb/src/include/duckdb/function/macro_function.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO = 2 };
-
-struct MacroBindResult {
-	explicit MacroBindResult(string error_p) : error(std::move(error_p)) {
-	}
-	explicit MacroBindResult(idx_t function_idx) : function_idx(function_idx) {
-	}
-
-	optional_idx function_idx;
-	string error;
-};
-
-class MacroFunction {
-public:
-	explicit MacroFunction(MacroType type);
-
-	//! The type
-	MacroType type;
-	//! The positional parameters
-	vector<unique_ptr<ParsedExpression>> parameters;
-	//! The default parameters and their associated values
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> default_parameters;
-
-public:
-	virtual ~MacroFunction() {
-	}
-
-	void CopyProperties(MacroFunction &other) const;
-
-	virtual unique_ptr<MacroFunction> Copy() const = 0;
-
-	static MacroBindResult BindMacroFunction(const vector<unique_ptr<MacroFunction>> &macro_functions,
-	                                         const string &name, FunctionExpression &function_expr,
-	                                         vector<unique_ptr<ParsedExpression>> &positionals,
-	                                         unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
-
-	virtual string ToSQL() const;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast macro to type - macro type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast macro to type - macro type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/partition_stats.hpp b/src/duckdb/src/include/duckdb/function/partition_stats.hpp
deleted file mode 100644
index d703ddbe1..000000000
--- a/src/duckdb/src/include/duckdb/function/partition_stats.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/partition_stats.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-//! How a table is partitioned by a given set of columns
-enum class TablePartitionInfo : uint8_t {
-	NOT_PARTITIONED,         // the table is not partitioned by the given set of columns
-	SINGLE_VALUE_PARTITIONS, // each partition has exactly one unique value (e.g. bounds = [1,1][2,2][3,3])
-	OVERLAPPING_PARTITIONS,  // the partitions overlap **only** at the boundaries (e.g. bounds = [1,2][2,3][3,4]
-	DISJOINT_PARTITIONS      // the partitions are disjoint (e.g. bounds = [1,2][3,4][5,6])
-};
-
-enum class CountType { COUNT_EXACT, COUNT_APPROXIMATE };
-
-struct PartitionStatistics {
-	PartitionStatistics();
-
-	//! The row id start
-	idx_t row_start;
-	//! The amount of rows in the partition
-	idx_t count;
-	//! Whether or not the count is exact or approximate
-	CountType count_type;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/pragma/pragma_functions.hpp b/src/duckdb/src/include/duckdb/function/pragma/pragma_functions.hpp
deleted file mode 100644
index 9cef9078a..000000000
--- a/src/duckdb/src/include/duckdb/function/pragma/pragma_functions.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/pragma/pragma_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/pragma_function.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct PragmaQueries {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaFunctions {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-string PragmaShowTables();
-string PragmaShowTablesExpanded();
-string PragmaShowDatabases();
-string PragmaShowVariables();
-string PragmaShow(const string &table_name);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/pragma_function.hpp b/src/duckdb/src/include/duckdb/function/pragma_function.hpp
deleted file mode 100644
index 91f55f3af..000000000
--- a/src/duckdb/src/include/duckdb/function/pragma_function.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/pragma_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-//! Return a substitute query to execute instead of this pragma statement
-typedef string (*pragma_query_t)(ClientContext &context, const FunctionParameters &parameters);
-//! Execute the main pragma function
-typedef void (*pragma_function_t)(ClientContext &context, const FunctionParameters &parameters);
-
-//! Pragma functions are invoked by calling PRAGMA x
-//! Pragma functions come in three types:
-//! * Call: function call, e.g. PRAGMA table_info('tbl')
-//!   -> call statements can take multiple parameters
-//! * Statement: statement without parameters, e.g. PRAGMA show_tables
-//!   -> this is similar to a call pragma but without parameters
-//! Pragma functions can either return a new query to execute (pragma_query_t)
-//! or they can
-class PragmaFunction : public SimpleNamedParameterFunction { // NOLINT: work-around bug in clang-tidy
-public:
-	// Call
-	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,
-	                                            LogicalType varargs = LogicalType::INVALID);
-	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_function_t function,
-	                                            vector<LogicalType> arguments,
-	                                            LogicalType varargs = LogicalType::INVALID);
-	// Statement
-	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_query_t query);
-	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_function_t function);
-
-	DUCKDB_API string ToString() const override;
-
-public:
-	PragmaType type;
-
-	pragma_query_t query;
-	pragma_function_t function;
-	named_parameter_type_map_t named_parameters;
-
-private:
-	PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
-	               vector<LogicalType> arguments, LogicalType varargs);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/register_function_list_helper.hpp b/src/duckdb/src/include/duckdb/function/register_function_list_helper.hpp
deleted file mode 100644
index fc389cff2..000000000
--- a/src/duckdb/src/include/duckdb/function/register_function_list_helper.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/register_function_list_helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-
-namespace duckdb {
-
-static void FillFunctionParameters(FunctionDescription &function_description, const char *function_name,
-                                   vector<string> &parameters, vector<string> &descriptions, vector<string> &examples) {
-	for (string &parameter : parameters) {
-		vector<string> parameter_name_type = StringUtil::Split(parameter, "::");
-		if (parameter_name_type.size() == 1) {
-			function_description.parameter_names.push_back(std::move(parameter_name_type[0]));
-			function_description.parameter_types.push_back(LogicalType::ANY);
-		} else if (parameter_name_type.size() == 2) {
-			function_description.parameter_names.push_back(std::move(parameter_name_type[0]));
-			function_description.parameter_types.push_back(DBConfig::ParseLogicalType(parameter_name_type[1]));
-		} else {
-			throw InternalException("Ill formed function variant for function '%s'", function_name);
-		}
-	}
-}
-
-template <class FunctionDefinition, class T>
-static void FillFunctionDescriptions(const FunctionDefinition &function, T &info) {
-	vector<string> variants = StringUtil::Split(function.parameters, '\1');
-	vector<string> descriptions = StringUtil::Split(function.description, '\1');
-	vector<string> examples = StringUtil::Split(function.example, '\1');
-
-	// add single variant for functions that take no arguments
-	if (variants.empty()) {
-		variants.push_back("");
-	}
-
-	for (idx_t variant_index = 0; variant_index < variants.size(); variant_index++) {
-		FunctionDescription function_description;
-		// parameter_names and parameter_types
-		vector<string> parameters = StringUtil::SplitWithParentheses(variants[variant_index], ',');
-		FillFunctionParameters(function_description, function.name, parameters, descriptions, examples);
-		// description
-		if (descriptions.size() == variants.size()) {
-			function_description.description = descriptions[variant_index];
-		} else if (descriptions.size() == 1) {
-			function_description.description = descriptions[0];
-		} else if (!descriptions.empty()) {
-			throw InternalException("Incorrect number of function descriptions for function '%s'", function.name);
-		}
-		// examples
-		if (examples.size() == variants.size()) {
-			function_description.examples = StringUtil::Split(examples[variant_index], '\2');
-		} else if (examples.size() == 1) {
-			function_description.examples = StringUtil::Split(examples[0], '\2');
-		} else if (!examples.empty()) {
-			throw InternalException("Incorrect number of function examples for function '%s'", function.name);
-		}
-		info.descriptions.push_back(std::move(function_description));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/replacement_scan.hpp b/src/duckdb/src/include/duckdb/function/replacement_scan.hpp
deleted file mode 100644
index 75ce069a8..000000000
--- a/src/duckdb/src/include/duckdb/function/replacement_scan.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/replacement_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/enums/file_compression_type.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class TableRef;
-
-struct ReplacementScanData {
-public:
-	virtual ~ReplacementScanData() {
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct ReplacementScanInput {
-public:
-	explicit ReplacementScanInput(const string &catalog_name, const string &schema_name, const string &table_name)
-	    : catalog_name(catalog_name), schema_name(schema_name), table_name(table_name) {
-	}
-
-public:
-	const string &catalog_name;
-	const string &schema_name;
-	const string &table_name;
-};
-
-typedef unique_ptr<TableRef> (*replacement_scan_t)(ClientContext &context, ReplacementScanInput &input,
-                                                   optional_ptr<ReplacementScanData> data);
-
-//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
-//! This allows you to do e.g. SELECT * FROM 'filename.csv', and automatically convert this into a CSV scan
-struct ReplacementScan {
-	explicit ReplacementScan(replacement_scan_t function, unique_ptr<ReplacementScanData> data_p = nullptr)
-	    : function(function), data(std::move(data_p)) {
-	}
-
-	static bool CanReplace(const string &table_name, const vector<string> &extensions) {
-		auto lower_name = StringUtil::Lower(table_name);
-
-		if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::GZIP))) {
-			lower_name = lower_name.substr(0, lower_name.size() - 3);
-		} else if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::ZSTD))) {
-			lower_name = lower_name.substr(0, lower_name.size() - 4);
-		}
-
-		for (auto &extension : extensions) {
-			if (StringUtil::EndsWith(lower_name, "." + extension) ||
-			    StringUtil::Contains(lower_name, "." + extension + "?")) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	static string GetFullPath(const string &catalog, const string &schema, const string &table) {
-		string table_name = catalog;
-		if (!schema.empty()) {
-			table_name += (!table_name.empty() ? "." : "") + schema;
-		}
-		table_name += (!table_name.empty() ? "." : "") + table;
-		return table_name;
-	}
-
-	static string GetFullPath(ReplacementScanInput &input) {
-		return GetFullPath(input.catalog_name, input.schema_name, input.table_name);
-	}
-
-	replacement_scan_t function;
-	unique_ptr<ReplacementScanData> data;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp
deleted file mode 100644
index f9e4fe930..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp
+++ /dev/null
@@ -1,180 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/compressed_materialization_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct InternalCompressIntegralUtinyintFun {
-	static constexpr const char *Name = "__internal_compress_integral_utinyint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalCompressIntegralUsmallintFun {
-	static constexpr const char *Name = "__internal_compress_integral_usmallint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalCompressIntegralUintegerFun {
-	static constexpr const char *Name = "__internal_compress_integral_uinteger";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalCompressIntegralUbigintFun {
-	static constexpr const char *Name = "__internal_compress_integral_ubigint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalCompressStringUtinyintFun {
-	static constexpr const char *Name = "__internal_compress_string_utinyint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct InternalCompressStringUsmallintFun {
-	static constexpr const char *Name = "__internal_compress_string_usmallint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct InternalCompressStringUintegerFun {
-	static constexpr const char *Name = "__internal_compress_string_uinteger";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct InternalCompressStringUbigintFun {
-	static constexpr const char *Name = "__internal_compress_string_ubigint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct InternalCompressStringHugeintFun {
-	static constexpr const char *Name = "__internal_compress_string_hugeint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct InternalDecompressIntegralSmallintFun {
-	static constexpr const char *Name = "__internal_decompress_integral_smallint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralIntegerFun {
-	static constexpr const char *Name = "__internal_decompress_integral_integer";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralBigintFun {
-	static constexpr const char *Name = "__internal_decompress_integral_bigint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralHugeintFun {
-	static constexpr const char *Name = "__internal_decompress_integral_hugeint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralUsmallintFun {
-	static constexpr const char *Name = "__internal_decompress_integral_usmallint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralUintegerFun {
-	static constexpr const char *Name = "__internal_decompress_integral_uinteger";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralUbigintFun {
-	static constexpr const char *Name = "__internal_decompress_integral_ubigint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressIntegralUhugeintFun {
-	static constexpr const char *Name = "__internal_decompress_integral_uhugeint";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct InternalDecompressStringFun {
-	static constexpr const char *Name = "__internal_decompress_string";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_utils.hpp b/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_utils.hpp
deleted file mode 100644
index 8609999a9..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_utils.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/compressed_materialization_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CMUtils {
-	//! The types we compress integral types to
-	static const vector<LogicalType> IntegralTypes();
-	//! The types we compress strings to
-	static const vector<LogicalType> StringTypes();
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments);
-};
-
-//! Needed for (de)serialization without binding
-enum class CompressedMaterializationDirection : uint8_t { INVALID = 0, COMPRESS = 1, DECOMPRESS = 2 };
-
-struct CMIntegralCompressFun {
-	static ScalarFunction GetFunction(const LogicalType &input_type, const LogicalType &result_type);
-};
-
-struct CMIntegralDecompressFun {
-	static ScalarFunction GetFunction(const LogicalType &input_type, const LogicalType &result_type);
-};
-
-struct CMStringCompressFun {
-	static ScalarFunction GetFunction(const LogicalType &result_type);
-};
-
-struct CMStringDecompressFun {
-	static ScalarFunction GetFunction(const LogicalType &input_type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/date_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/date_functions.hpp
deleted file mode 100644
index 8aac94b28..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/date_functions.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/date_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct StrfTimeFun {
-	static constexpr const char *Name = "strftime";
-	static constexpr const char *Parameters = "data,format";
-	static constexpr const char *Description = "Converts a date to a string according to the format string.";
-	static constexpr const char *Example = "strftime(date '1992-01-01', '%a, %-d %B %Y')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StrpTimeFun {
-	static constexpr const char *Name = "strptime";
-	static constexpr const char *Parameters = "text::VARCHAR,format::VARCHAR\1text::VARCHAR,format-list::VARCHAR[]";
-	static constexpr const char *Description = "Converts the string text to timestamp according to the format string. Throws an error on failure. To return NULL on failure, use try_strptime.\1Converts the string text to timestamp applying the format strings in the list until one succeeds. Throws an error on failure. To return NULL on failure, use try_strptime.";
-	static constexpr const char *Example = "strptime('Wed, 1 January 1992 - 08:38:40 PM', '%a, %-d %B %Y - %I:%M:%S %p')\1strptime('4/15/2023 10:56:00', ['%d/%m/%Y %H:%M:%S', '%m/%d/%Y %H:%M:%S'])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct TryStrpTimeFun {
-	static constexpr const char *Name = "try_strptime";
-	static constexpr const char *Parameters = "text,format";
-	static constexpr const char *Description = "Converts the string text to timestamp according to the format string. Returns NULL on failure.";
-	static constexpr const char *Example = "try_strptime('Wed, 1 January 1992 - 08:38:40 PM', '%a, %-d %B %Y - %I:%M:%S %p')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/generic_common.hpp b/src/duckdb/src/include/duckdb/function/scalar/generic_common.hpp
deleted file mode 100644
index f4a4089e6..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/generic_common.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/generic_common.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-class BoundFunctionExpression;
-
-struct ConstantOrNull {
-	static unique_ptr<FunctionData> Bind(Value value);
-	static bool IsConstantOrNull(BoundFunctionExpression &expr, const Value &val);
-};
-
-struct ExportAggregateFunctionBindData : public FunctionData {
-	unique_ptr<BoundAggregateExpression> aggregate;
-	explicit ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p);
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct ExportAggregateFunction {
-	static unique_ptr<BoundAggregateExpression> Bind(unique_ptr<BoundAggregateExpression> child_aggregate);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp
deleted file mode 100644
index fd2865e6c..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/generic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ConstantOrNullFun {
-	static constexpr const char *Name = "constant_or_null";
-	static constexpr const char *Parameters = "arg1,arg2";
-	static constexpr const char *Description = "If arg2 is NULL, return NULL. Otherwise, return arg1.";
-	static constexpr const char *Example = "constant_or_null(42, NULL)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct GetVariableFun {
-	static constexpr const char *Name = "getvariable";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ErrorFun {
-	static constexpr const char *Name = "error";
-	static constexpr const char *Parameters = "message";
-	static constexpr const char *Description = "Throws the given error message";
-	static constexpr const char *Example = "error('access_mode')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CreateSortKeyFun {
-	static constexpr const char *Name = "create_sort_key";
-	static constexpr const char *Parameters = "parameters...";
-	static constexpr const char *Description = "Constructs a binary-comparable sort key based on a set of input parameters and sort qualifiers";
-	static constexpr const char *Example = "create_sort_key('A', 'DESC')";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp b/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp
deleted file mode 100644
index 1c091e7da..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#pragma once
-#include "duckdb/function/create_sort_key.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-
-namespace duckdb {
-
-template <class T, bool RETURN_POSITION>
-idx_t ListSearchSimpleOp(Vector &list_vec, Vector &source_vec, Vector &target_vec, Vector &result, idx_t count) {
-
-	UnifiedVectorFormat source_format;
-	const auto source_count = ListVector::GetListSize(list_vec);
-	source_vec.ToUnifiedFormat(source_count, source_format);
-	const auto source_data = UnifiedVectorFormat::GetData<T>(source_format);
-
-	using RETURN_TYPE = typename std::conditional<RETURN_POSITION, int32_t, int8_t>::type;
-
-	idx_t total_matches = 0;
-
-	BinaryExecutor::ExecuteWithNulls<list_entry_t, T, RETURN_TYPE>(
-	    list_vec, target_vec, result, count,
-	    [&](const list_entry_t &list, const T &target, ValidityMask &validity, idx_t out_idx) -> RETURN_TYPE {
-		    if (list.length == 0) {
-			    if (RETURN_POSITION) {
-				    validity.SetInvalid(out_idx);
-			    }
-			    return 0;
-		    }
-
-		    for (auto i = list.offset; i < list.offset + list.length; i++) {
-			    const auto entry_idx = source_format.sel->get_index(i);
-			    if (source_format.validity.RowIsValid(entry_idx) &&
-			        Equals::Operation<T>(source_data[entry_idx], target)) {
-				    total_matches++;
-				    return RETURN_POSITION ? UnsafeNumericCast<RETURN_TYPE>(1 + i - list.offset) : 1;
-			    }
-		    }
-
-		    if (RETURN_POSITION) {
-			    validity.SetInvalid(out_idx);
-		    }
-		    return 0;
-	    });
-
-	return total_matches;
-}
-
-template <bool RETURN_POSITION>
-idx_t ListSearchNestedOp(Vector &list_vec, Vector &source_vec, Vector &target_vec, Vector &result_vec,
-                         const idx_t target_count) {
-	// Set up sort keys for nested types.
-	auto source_count = ListVector::GetListSize(list_vec);
-	Vector source_sort_key_vec(LogicalType::BLOB, source_count);
-	Vector target_sort_key_vec(LogicalType::BLOB, target_count);
-
-	const OrderModifiers order_modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
-	CreateSortKeyHelpers::CreateSortKeyWithValidity(source_vec, source_sort_key_vec, order_modifiers, source_count);
-	CreateSortKeyHelpers::CreateSortKeyWithValidity(target_vec, target_sort_key_vec, order_modifiers, target_count);
-
-	return ListSearchSimpleOp<string_t, RETURN_POSITION>(list_vec, source_sort_key_vec, target_sort_key_vec, result_vec,
-	                                                     target_count);
-}
-
-//! "Search" each list in the list vector for the corresponding value in the target vector, returning either
-//! true/false or the position of the value in the list. The result vector is populated with the result of the search.
-//! usually the "source" vector is the list child vector, but it is passed separately to enable searching nested
-//! children, for example when searching the keys of a MAP vectors.
-template <bool RETURN_POSITION>
-idx_t ListSearchOp(Vector &list_v, Vector &source_v, Vector &target_v, Vector &result_v, idx_t target_count) {
-	const auto type = target_v.GetType().InternalType();
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return ListSearchSimpleOp<int8_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::INT16:
-		return ListSearchSimpleOp<int16_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::INT32:
-		return ListSearchSimpleOp<int32_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::INT64:
-		return ListSearchSimpleOp<int64_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::INT128:
-		return ListSearchSimpleOp<hugeint_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::UINT8:
-		return ListSearchSimpleOp<uint8_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::UINT16:
-		return ListSearchSimpleOp<uint16_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::UINT32:
-		return ListSearchSimpleOp<uint32_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::UINT64:
-		return ListSearchSimpleOp<uint64_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::UINT128:
-		return ListSearchSimpleOp<uhugeint_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::FLOAT:
-		return ListSearchSimpleOp<float, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::DOUBLE:
-		return ListSearchSimpleOp<double, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::VARCHAR:
-		return ListSearchSimpleOp<string_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::INTERVAL:
-		return ListSearchSimpleOp<interval_t, RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-	case PhysicalType::ARRAY:
-		return ListSearchNestedOp<RETURN_POSITION>(list_v, source_v, target_v, result_v, target_count);
-	default:
-		throw NotImplementedException("This function has not been implemented for logical type %s",
-		                              TypeIdToString(type));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/list_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/list_functions.hpp
deleted file mode 100644
index 577b643f6..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/list_functions.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/list_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct ListSelectFun {
-	static constexpr const char *Name = "list_select";
-	static constexpr const char *Parameters = "value_list,index_list";
-	static constexpr const char *Description = "Returns a list based on the elements selected by the index_list.";
-	static constexpr const char *Example = "list_select([10, 20, 30, 40], [1, 4])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArraySelectFun {
-	using ALIAS = ListSelectFun;
-
-	static constexpr const char *Name = "array_select";
-};
-
-struct ListWhereFun {
-	static constexpr const char *Name = "list_where";
-	static constexpr const char *Parameters = "value_list,mask_list";
-	static constexpr const char *Description = "Returns a list with the BOOLEANs in mask_list applied as a mask to the value_list.";
-	static constexpr const char *Example = "list_where([10, 20, 30, 40], [true, false, false, true])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayWhereFun {
-	using ALIAS = ListWhereFun;
-
-	static constexpr const char *Name = "array_where";
-};
-
-struct ListContainsFun {
-	static constexpr const char *Name = "list_contains";
-	static constexpr const char *Parameters = "list,element";
-	static constexpr const char *Description = "Returns true if the list contains the element.";
-	static constexpr const char *Example = "list_contains([1, 2, NULL], 1)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayContainsFun {
-	using ALIAS = ListContainsFun;
-
-	static constexpr const char *Name = "array_contains";
-};
-
-struct ListHasFun {
-	using ALIAS = ListContainsFun;
-
-	static constexpr const char *Name = "list_has";
-};
-
-struct ArrayHasFun {
-	using ALIAS = ListContainsFun;
-
-	static constexpr const char *Name = "array_has";
-};
-
-struct ListPositionFun {
-	static constexpr const char *Name = "list_position";
-	static constexpr const char *Parameters = "list,element";
-	static constexpr const char *Description = "Returns the index of the element if the list contains the element. If the element is not found, it returns NULL.";
-	static constexpr const char *Example = "list_position([1, 2, NULL], 2)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ListIndexofFun {
-	using ALIAS = ListPositionFun;
-
-	static constexpr const char *Name = "list_indexof";
-};
-
-struct ArrayPositionFun {
-	using ALIAS = ListPositionFun;
-
-	static constexpr const char *Name = "array_position";
-};
-
-struct ArrayIndexofFun {
-	using ALIAS = ListPositionFun;
-
-	static constexpr const char *Name = "array_indexof";
-};
-
-struct ListZipFun {
-	static constexpr const char *Name = "list_zip";
-	static constexpr const char *Parameters = "list1,list2,...";
-	static constexpr const char *Description = "Zips k LISTs to a new LIST whose length will be that of the longest list. Its elements are structs of k elements from each list list_1, …, list_k, missing elements are replaced with NULL. If truncate is set, all lists are truncated to the smallest list length.";
-	static constexpr const char *Example = "list_zip([1, 2], [3, 4], [5, 6])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ArrayZipFun {
-	using ALIAS = ListZipFun;
-
-	static constexpr const char *Name = "array_zip";
-};
-
-struct ListExtractFun {
-	static constexpr const char *Name = "list_extract";
-	static constexpr const char *Parameters = "list,index";
-	static constexpr const char *Description = "Extract the indexth (1-based) value from the list.";
-	static constexpr const char *Example = "list_extract([4, 5, 6], 3)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ListElementFun {
-	using ALIAS = ListExtractFun;
-
-	static constexpr const char *Name = "list_element";
-};
-
-struct ListResizeFun {
-	static constexpr const char *Name = "list_resize";
-	static constexpr const char *Parameters = "list,size[,value]";
-	static constexpr const char *Description = "Resizes the list to contain size elements. Initializes new elements with value or NULL if value is not set.";
-	static constexpr const char *Example = "list_resize([1, 2, 3], 5, 0)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayResizeFun {
-	using ALIAS = ListResizeFun;
-
-	static constexpr const char *Name = "array_resize";
-};
-
-struct ArrayExtractFun {
-	static constexpr const char *Name = "array_extract";
-	static constexpr const char *Parameters = "list,index";
-	static constexpr const char *Description = "Extract the indexth (1-based) value from the array.";
-	static constexpr const char *Example = "array_extract('DuckDB', 2)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/map_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/map_functions.hpp
deleted file mode 100644
index 5814a00e3..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/map_functions.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/map_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct MapContainsFun {
-	static constexpr const char *Name = "map_contains";
-	static constexpr const char *Parameters = "map,key";
-	static constexpr const char *Description = "Checks if a map contains a given key.";
-	static constexpr const char *Example = "map_contains(MAP {'key1': 10, 'key2': 20, 'key3': 30}, 'key2')";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp
deleted file mode 100644
index 07b16a151..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/nested_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-struct ListArgFunctor {
-	static Vector &GetList(Vector &list) {
-		return list;
-	}
-	static idx_t GetListSize(Vector &list) {
-		return ListVector::GetListSize(list);
-	}
-	static Vector &GetEntry(Vector &list) {
-		return ListVector::GetEntry(list);
-	}
-};
-
-struct ContainsFunctor {
-	static inline bool Initialize() {
-		return false;
-	}
-	static inline bool UpdateResultEntries(idx_t child_idx) {
-		return true;
-	}
-};
-
-struct PositionFunctor {
-	static inline int32_t Initialize() {
-		return 0;
-	}
-	static inline int32_t UpdateResultEntries(idx_t child_idx) {
-		return UnsafeNumericCast<int32_t>(child_idx + 1);
-	}
-};
-
-struct MapUtil {
-	static void ReinterpretMap(Vector &target, Vector &other, idx_t count);
-};
-
-struct VariableReturnBindData : public FunctionData {
-	LogicalType stype;
-
-	explicit VariableReturnBindData(LogicalType stype_p) : stype(std::move(stype_p)) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<VariableReturnBindData>(stype);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<VariableReturnBindData>();
-		return stype == other.stype;
-	}
-	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-	                      const ScalarFunction &function) {
-		auto &info = bind_data->Cast<VariableReturnBindData>();
-		serializer.WriteProperty(100, "variable_return_type", info.stype);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &bound_function) {
-		auto stype = deserializer.ReadProperty<LogicalType>(100, "variable_return_type");
-		return make_uniq<VariableReturnBindData>(std::move(stype));
-	}
-};
-
-template <class T, class MAP_TYPE = map<T, idx_t>>
-struct HistogramAggState {
-	MAP_TYPE *hist;
-};
-
-unique_ptr<FunctionData> GetBindData(idx_t index);
-ScalarFunction GetKeyExtractFunction();
-ScalarFunction GetIndexExtractFunction();
-ScalarFunction GetExtractAtFunction();
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/operator_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/operator_functions.hpp
deleted file mode 100644
index dbb7a1461..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/operator_functions.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/operator_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct OperatorAddFun {
-	static constexpr const char *Name = "+";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct AddFun {
-	using ALIAS = OperatorAddFun;
-
-	static constexpr const char *Name = "add";
-};
-
-struct OperatorSubtractFun {
-	static constexpr const char *Name = "-";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SubtractFun {
-	using ALIAS = OperatorSubtractFun;
-
-	static constexpr const char *Name = "subtract";
-};
-
-struct OperatorMultiplyFun {
-	static constexpr const char *Name = "*";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MultiplyFun {
-	using ALIAS = OperatorMultiplyFun;
-
-	static constexpr const char *Name = "multiply";
-};
-
-struct OperatorFloatDivideFun {
-	static constexpr const char *Name = "/";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct OperatorIntegerDivideFun {
-	static constexpr const char *Name = "//";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct DivideFun {
-	using ALIAS = OperatorIntegerDivideFun;
-
-	static constexpr const char *Name = "divide";
-};
-
-struct OperatorModuloFun {
-	static constexpr const char *Name = "%";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ModFun {
-	using ALIAS = OperatorModuloFun;
-
-	static constexpr const char *Name = "mod";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/operators.hpp b/src/duckdb/src/include/duckdb/function/scalar/operators.hpp
deleted file mode 100644
index f23c5c3bc..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/operators.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct AddFunction {
-	static ScalarFunction GetFunction(const LogicalType &type);
-	static ScalarFunction GetFunction(const LogicalType &left_type, const LogicalType &right_type);
-};
-
-struct SubtractFunction {
-	static ScalarFunction GetFunction(const LogicalType &type);
-	static ScalarFunction GetFunction(const LogicalType &left_type, const LogicalType &right_type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp b/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp
deleted file mode 100644
index fa6a3e91f..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/regexp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-#include "re2/re2.h"
-#include "duckdb/function/built_in_functions.hpp"
-#include "re2/stringpiece.h"
-
-namespace duckdb {
-
-namespace regexp_util {
-
-bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string);
-void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr);
-void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr);
-
-inline duckdb_re2::StringPiece CreateStringPiece(const string_t &input) {
-	return duckdb_re2::StringPiece(input.GetData(), input.GetSize());
-}
-
-inline string_t Extract(const string_t &input, Vector &result, const RE2 &re, const duckdb_re2::StringPiece &rewrite) {
-	string extracted;
-	RE2::Extract(input.GetString(), re, rewrite, &extracted);
-	return StringVector::AddString(result, extracted.c_str(), extracted.size());
-}
-
-} // namespace regexp_util
-
-struct RegexpExtractAll {
-	static void Execute(DataChunk &args, ExpressionState &state, Vector &result);
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments);
-	static unique_ptr<FunctionLocalState> InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
-	                                                     FunctionData *bind_data);
-};
-
-struct RegexpBaseBindData : public FunctionData {
-	RegexpBaseBindData();
-	RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern = true);
-	~RegexpBaseBindData() override;
-
-	duckdb_re2::RE2::Options options;
-	string constant_string;
-	bool constant_pattern;
-
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct RegexpMatchesBindData : public RegexpBaseBindData {
-	RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern);
-	RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern,
-	                      string range_min, string range_max, bool range_success);
-
-	string range_min;
-	string range_max;
-	bool range_success;
-
-	unique_ptr<FunctionData> Copy() const override;
-};
-
-struct RegexpReplaceBindData : public RegexpBaseBindData {
-	RegexpReplaceBindData();
-	RegexpReplaceBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern,
-	                      bool global_replace);
-
-	bool global_replace;
-
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct RegexpExtractBindData : public RegexpBaseBindData {
-	RegexpExtractBindData();
-	RegexpExtractBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern,
-	                      string group_string);
-
-	string group_string;
-	duckdb_re2::StringPiece rewrite;
-
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct RegexStringPieceArgs {
-	RegexStringPieceArgs() : size(0), capacity(0), group_buffer(nullptr) {
-	}
-	void Init(idx_t size) {
-		this->size = size;
-		// Allocate for one extra, for the all-encompassing match group
-		this->capacity = size + 1;
-		group_buffer = AllocateArray<duckdb_re2::StringPiece>(capacity);
-	}
-	void SetSize(idx_t size) {
-		this->size = size;
-		if (size + 1 > capacity) {
-			Clear();
-			Init(size);
-		}
-	}
-
-	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) noexcept {
-		this->size = other.size;
-		this->capacity = other.capacity;
-		this->group_buffer = other.group_buffer;
-		other.size = 0;
-		other.capacity = 0;
-		other.group_buffer = nullptr;
-		return *this;
-	}
-
-	~RegexStringPieceArgs() {
-		Clear();
-	}
-
-private:
-	void Clear() {
-		DeleteArray<duckdb_re2::StringPiece>(group_buffer, capacity);
-		group_buffer = nullptr;
-
-		size = 0;
-		capacity = 0;
-	}
-
-public:
-	idx_t size;
-	//! The currently allocated capacity for the groups
-	idx_t capacity;
-	//! Used by ExtractAll to pre-allocate the storage for the groups
-	duckdb_re2::StringPiece *group_buffer;
-};
-
-struct RegexLocalState : public FunctionLocalState {
-	explicit RegexLocalState(RegexpBaseBindData &info, bool extract_all = false)
-	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
-	                       info.options) {
-		if (extract_all) {
-			auto group_count_p = constant_pattern.NumberOfCapturingGroups();
-			if (group_count_p != -1) {
-				group_buffer.Init(NumericCast<idx_t>(group_count_p));
-			}
-		}
-		D_ASSERT(info.constant_pattern);
-	}
-
-	RE2 constant_pattern;
-	//! Used by regexp_extract_all to pre-allocate the args
-	RegexStringPieceArgs group_buffer;
-};
-
-unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                   FunctionData *bind_data);
-unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/sequence_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/sequence_functions.hpp
deleted file mode 100644
index d7f6eb01a..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/sequence_functions.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/sequence_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CurrvalFun {
-	static constexpr const char *Name = "currval";
-	static constexpr const char *Parameters = "'sequence_name'";
-	static constexpr const char *Description = "Return the current value of the sequence. Note that nextval must be called at least once prior to calling currval.";
-	static constexpr const char *Example = "currval('my_sequence_name')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NextvalFun {
-	static constexpr const char *Name = "nextval";
-	static constexpr const char *Parameters = "'sequence_name'";
-	static constexpr const char *Description = "Return the following value of the sequence.";
-	static constexpr const char *Example = "nextval('my_sequence_name')";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/sequence_utils.hpp b/src/duckdb/src/include/duckdb/function/scalar/sequence_utils.hpp
deleted file mode 100644
index 642e53f9c..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/sequence_utils.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/sequence_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct NextvalBindData : public FunctionData {
-	explicit NextvalBindData(SequenceCatalogEntry &sequence) : sequence(sequence), create_info(sequence.GetInfo()) {
-	}
-
-	//! The sequence to use for the nextval computation; only if the sequence is a constant
-	SequenceCatalogEntry &sequence;
-
-	//! The CreateInfo for the above sequence, if it exists
-	unique_ptr<CreateInfo> create_info;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<NextvalBindData>(sequence);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<NextvalBindData>();
-		return RefersToSameObject(sequence, other.sequence);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp b/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp
deleted file mode 100644
index 7392be254..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/strftime_format.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/common/vector.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-enum class StrTimeSpecifier : uint8_t {
-	ABBREVIATED_WEEKDAY_NAME = 0,    // %a - Abbreviated weekday name. (Sun, Mon, ...)
-	FULL_WEEKDAY_NAME = 1,           // %A Full weekday name. (Sunday, Monday, ...)
-	WEEKDAY_DECIMAL = 2,             // %w - Weekday as a decimal number. (0, 1, ..., 6)
-	DAY_OF_MONTH_PADDED = 3,         // %d - Day of the month as a zero-padded decimal. (01, 02, ..., 31)
-	DAY_OF_MONTH = 4,                // %-d - Day of the month as a decimal number. (1, 2, ..., 30)
-	ABBREVIATED_MONTH_NAME = 5,      // %b - Abbreviated month name. (Jan, Feb, ..., Dec)
-	FULL_MONTH_NAME = 6,             // %B - Full month name. (January, February, ...)
-	MONTH_DECIMAL_PADDED = 7,        // %m - Month as a zero-padded decimal number. (01, 02, ..., 12)
-	MONTH_DECIMAL = 8,               // %-m - Month as a decimal number. (1, 2, ..., 12)
-	YEAR_WITHOUT_CENTURY_PADDED = 9, // %y - Year without century as a zero-padded decimal number. (00, 01, ..., 99)
-	YEAR_WITHOUT_CENTURY = 10,       // %-y - Year without century as a decimal number. (0, 1, ..., 99)
-	YEAR_DECIMAL = 11,               // %Y - Year with century as a decimal number. (2013, 2019 etc.)
-	HOUR_24_PADDED = 12,             // %H - Hour (24-hour clock) as a zero-padded decimal number. (00, 01, ..., 23)
-	HOUR_24_DECIMAL = 13,            // %-H - Hour (24-hour clock) as a decimal number. (0, 1, ..., 23)
-	HOUR_12_PADDED = 14,             // %I - Hour (12-hour clock) as a zero-padded decimal number. (01, 02, ..., 12)
-	HOUR_12_DECIMAL = 15,            // %-I - Hour (12-hour clock) as a decimal number. (1, 2, ... 12)
-	AM_PM = 16,                      // %p - Locale’s AM or PM. (AM, PM)
-	MINUTE_PADDED = 17,              // %M - Minute as a zero-padded decimal number. (00, 01, ..., 59)
-	MINUTE_DECIMAL = 18,             // %-M - Minute as a decimal number. (0, 1, ..., 59)
-	SECOND_PADDED = 19,              // %S - Second as a zero-padded decimal number. (00, 01, ..., 59)
-	SECOND_DECIMAL = 20,             // %-S - Second as a decimal number. (0, 1, ..., 59)
-	MICROSECOND_PADDED = 21,         // %f - Microsecond as a decimal number, zero-padded on the left. (000000 - 999999)
-	MILLISECOND_PADDED = 22,         // %g - Millisecond as a decimal number, zero-padded on the left. (000 - 999)
-	UTC_OFFSET = 23,                 // %z - UTC offset in the form +HHMM or -HHMM. ( )
-	TZ_NAME = 24,                    // %Z - Time zone name. ( )
-	DAY_OF_YEAR_PADDED = 25,         // %j - Day of the year as a zero-padded decimal number. (001, 002, ..., 366)
-	DAY_OF_YEAR_DECIMAL = 26,        // %-j - Day of the year as a decimal number. (1, 2, ..., 366)
-	WEEK_NUMBER_PADDED_SUN_FIRST =
-	    27, // %U - Week number of the year (Sunday as the first day of the week). All days in a new year preceding the
-	        // first Sunday are considered to be in week 0. (00, 01, ..., 53)
-	WEEK_NUMBER_PADDED_MON_FIRST =
-	    28, // %W - Week number of the year (Monday as the first day of the week). All days in a new year preceding the
-	        // first Monday are considered to be in week 0. (00, 01, ..., 53)
-	LOCALE_APPROPRIATE_DATE_AND_TIME =
-	    29, // %c - Locale’s appropriate date and time representation. (Mon Sep 30 07:06:05 2013)
-	LOCALE_APPROPRIATE_DATE = 30, // %x - Locale’s appropriate date representation. (09/30/13)
-	LOCALE_APPROPRIATE_TIME = 31, // %X - Locale’s appropriate time representation. (07:06:05)
-	NANOSECOND_PADDED = 32, // %n - Nanosecond as a decimal number, zero-padded on the left. (000000000 - 999999999)
-	// Python 3.6 ISO directives https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
-	YEAR_ISO =
-	    33, // %G - ISO 8601 year with century representing the year that contains the greater part of the ISO week
-	WEEKDAY_ISO = 34,     // %u - ISO 8601 weekday as a decimal number where 1 is Monday (1..7)
-	WEEK_NUMBER_ISO = 35, // %V - ISO 8601 week as a decimal number with Monday as the first day of the week.
-	                      // Week 01 is the week containing Jan 4. (01..53)
-};
-
-struct StrTimeFormat {
-public:
-	virtual ~StrTimeFormat() {
-	}
-
-	DUCKDB_API static string ParseFormatSpecifier(const string &format_string, StrTimeFormat &format);
-
-	inline bool HasFormatSpecifier(StrTimeSpecifier s) const {
-		return std::find(specifiers.begin(), specifiers.end(), s) != specifiers.end();
-	}
-	//! If the string format is empty
-	DUCKDB_API bool Empty() const;
-
-	//! The full format specifier, for error messages
-	string format_specifier;
-
-protected:
-	//! The format specifiers
-	vector<StrTimeSpecifier> specifiers;
-	//! The literals that appear in between the format specifiers
-	//! The following must hold: literals.size() = specifiers.size() + 1
-	//! Format is literals[0], specifiers[0], literals[1], ..., specifiers[n - 1], literals[n]
-	vector<string> literals;
-	//! The constant size that appears in the format string
-	idx_t constant_size = 0;
-	//! The max numeric width of the specifier (if it is parsed as a number), or -1 if it is not a number
-	vector<int> numeric_width;
-
-protected:
-	void AddLiteral(string literal);
-	DUCKDB_API virtual void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier);
-};
-
-struct StrfTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in clang-tidy
-	DUCKDB_API idx_t GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name);
-
-	DUCKDB_API void FormatStringNS(date_t date, int32_t data[8], const char *tz_name, char *target) const;
-	DUCKDB_API void FormatString(date_t date, int32_t data[8], const char *tz_name, char *target);
-	void FormatString(date_t date, dtime_t time, char *target);
-
-	DUCKDB_API static string Format(timestamp_t timestamp, const string &format);
-
-	DUCKDB_API void ConvertDateVector(Vector &input, Vector &result, idx_t count);
-	DUCKDB_API void ConvertTimestampVector(Vector &input, Vector &result, idx_t count);
-	DUCKDB_API void ConvertTimestampNSVector(Vector &input, Vector &result, idx_t count);
-
-protected:
-	//! The variable-length specifiers. To determine total string size, these need to be checked.
-	vector<StrTimeSpecifier> var_length_specifiers;
-	//! Whether or not the current specifier is a special "date" specifier (i.e. one that requires a date_t object to
-	//! generate)
-	vector<bool> is_date_specifier;
-
-protected:
-	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
-	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, int32_t data[8], const char *tz_name);
-	idx_t GetLength(date_t date, int32_t data[8], const char *tz_name) const;
-
-	string_t ConvertTimestampValue(const timestamp_t &input, Vector &result) const;
-	string_t ConvertTimestampValue(const timestamp_ns_t &input, Vector &result) const;
-
-	char *WriteString(char *target, const string_t &str) const;
-	char *Write2(char *target, uint8_t value) const;
-	char *WritePadded2(char *target, uint32_t value) const;
-	char *WritePadded3(char *target, uint32_t value) const;
-	char *WritePadded(char *target, uint32_t value, size_t padding) const;
-	bool IsDateSpecifier(StrTimeSpecifier specifier);
-	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target) const;
-	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, size_t tz_len,
-	                             char *target) const;
-};
-
-struct StrpTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in clang-tidy
-public:
-	StrpTimeFormat();
-
-	//! Type-safe parsing argument
-	struct ParseResult {
-		int32_t data[8]; // year, month, day, hour, min, sec, ns, offset
-		string tz;
-		string error_message;
-		optional_idx error_position;
-
-		bool is_special;
-		date_t special;
-
-		int32_t GetMicros() const;
-
-		date_t ToDate();
-		dtime_t ToTime();
-		int64_t ToTimeNS();
-		timestamp_t ToTimestamp();
-		timestamp_ns_t ToTimestampNS();
-
-		bool TryToDate(date_t &result);
-		bool TryToTime(dtime_t &result);
-		bool TryToTimestamp(timestamp_t &result);
-		bool TryToTimestampNS(timestamp_ns_t &result);
-
-		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
-	};
-
-public:
-	bool operator!=(const StrpTimeFormat &other) const {
-		return format_specifier != other.format_specifier;
-	}
-	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
-
-	DUCKDB_API bool Parse(string_t str, ParseResult &result, bool strict = false) const;
-
-	DUCKDB_API bool Parse(const char *data, size_t size, ParseResult &result, bool strict = false) const;
-
-	DUCKDB_API bool TryParseDate(const char *data, size_t size, date_t &result) const;
-	DUCKDB_API bool TryParseTimestamp(const char *data, size_t size, timestamp_t &result) const;
-	DUCKDB_API bool TryParseTimestampNS(const char *data, size_t size, timestamp_ns_t &result) const;
-
-	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message) const;
-	DUCKDB_API bool TryParseTime(string_t str, dtime_t &result, string &error_message) const;
-	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message) const;
-	DUCKDB_API bool TryParseTimestampNS(string_t str, timestamp_ns_t &result, string &error_message) const;
-
-	void Serialize(Serializer &serializer) const;
-	static StrpTimeFormat Deserialize(Deserializer &deserializer);
-
-protected:
-	static string FormatStrpTimeError(const string &input, optional_idx position);
-	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
-	int NumericSpecifierWidth(StrTimeSpecifier specifier);
-	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
-	                           idx_t collection_count) const;
-
-private:
-	explicit StrpTimeFormat(const string &format_string);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/string_common.hpp b/src/duckdb/src/include/duckdb/function/scalar/string_common.hpp
deleted file mode 100644
index 4cf00d8c4..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/string_common.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-bool IsAscii(const char *input, idx_t n);
-idx_t LowerLength(const char *input_data, idx_t input_length);
-void LowerCase(const char *input_data, idx_t input_length, char *result_data);
-idx_t FindStrInStr(const string_t &haystack_s, const string_t &needle_s);
-idx_t FindStrInStr(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle, idx_t needle_size);
-string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t length);
-string_t SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length);
-string_t SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length);
-
-ScalarFunction GetStringContains();
-DUCKDB_API bool Glob(const char *s, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark = true);
-
-static inline bool IsCharacter(char c) {
-	return (c & 0xc0) != 0x80;
-}
-
-template <class TA, class TR>
-static inline TR Length(TA input) {
-	auto input_data = input.GetData();
-	auto input_length = input.GetSize();
-	TR length = 0;
-	for (idx_t i = 0; i < input_length; i++) {
-		length += IsCharacter(input_data[i]);
-	}
-	return length;
-}
-
-template <class TA, class TR>
-static inline TR GraphemeCount(TA input) {
-	auto input_data = input.GetData();
-	auto input_length = input.GetSize();
-	for (idx_t i = 0; i < input_length; i++) {
-		if (input_data[i] & 0x80) {
-			// non-ascii character: use grapheme iterator on remainder of string
-			return UnsafeNumericCast<TR>(Utf8Proc::GraphemeCount(input_data, input_length));
-		}
-	}
-	return UnsafeNumericCast<TR>(input_length);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp
deleted file mode 100644
index ffca2c073..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp
+++ /dev/null
@@ -1,456 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/string_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct UpperFun {
-	static constexpr const char *Name = "upper";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert string to upper case.";
-	static constexpr const char *Example = "upper('Hello')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct UcaseFun {
-	using ALIAS = UpperFun;
-
-	static constexpr const char *Name = "ucase";
-};
-
-struct LowerFun {
-	static constexpr const char *Name = "lower";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert string to lower case";
-	static constexpr const char *Example = "lower('Hello')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LcaseFun {
-	using ALIAS = LowerFun;
-
-	static constexpr const char *Name = "lcase";
-};
-
-struct ConcatWsFun {
-	static constexpr const char *Name = "concat_ws";
-	static constexpr const char *Parameters = "separator,string,...";
-	static constexpr const char *Description = "Concatenate strings together separated by the specified separator.";
-	static constexpr const char *Example = "concat_ws(', ', 'Banana', 'Apple', 'Melon')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ConcatFun {
-	static constexpr const char *Name = "concat";
-	static constexpr const char *Parameters = "string,...";
-	static constexpr const char *Description = "Concatenate many strings together.";
-	static constexpr const char *Example = "concat('Hello', ' ', 'World')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ListConcatFun {
-	static constexpr const char *Name = "list_concat";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Concatenates two lists.";
-	static constexpr const char *Example = "list_concat([2, 3], [4, 5, 6])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ListCatFun {
-	using ALIAS = ListConcatFun;
-
-	static constexpr const char *Name = "list_cat";
-};
-
-struct ArrayConcatFun {
-	using ALIAS = ListConcatFun;
-
-	static constexpr const char *Name = "array_concat";
-};
-
-struct ArrayCatFun {
-	using ALIAS = ListConcatFun;
-
-	static constexpr const char *Name = "array_cat";
-};
-
-struct ConcatOperatorFun {
-	static constexpr const char *Name = "||";
-	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Concatenates two lists.";
-	static constexpr const char *Example = "list_concat([2, 3], [4, 5, 6])";
-
-	static ScalarFunction GetFunction();
-};
-
-struct PrefixFun {
-	static constexpr const char *Name = "prefix";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct SuffixFun {
-	static constexpr const char *Name = "suffix";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct EndsWithFun {
-	using ALIAS = SuffixFun;
-
-	static constexpr const char *Name = "ends_with";
-};
-
-struct ContainsFun {
-	static constexpr const char *Name = "contains";
-	static constexpr const char *Parameters = "string::VARCHAR,search_string::VARCHAR\1list::ANY[],element::ANY\1map::MAP(ANY,ANY),key::ANY";
-	static constexpr const char *Description = "Returns true if search_string is found within string.\1Returns true if the list contains the element.\1Checks if a map contains a given key.";
-	static constexpr const char *Example = "contains('abc', 'a')\1contains([1, 2, NULL], 1)\1contains(MAP {'key1': 10, 'key2': 20, 'key3': 30}, 'key2')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StripAccentsFun {
-	static constexpr const char *Name = "strip_accents";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Strips accents from string.";
-	static constexpr const char *Example = "strip_accents('mühleisen')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NFCNormalizeFun {
-	static constexpr const char *Name = "nfc_normalize";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert string to Unicode NFC normalized string. Useful for comparisons and ordering if text data is mixed between NFC normalized and not.";
-	static constexpr const char *Example = "nfc_normalize('ardèch')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LengthFun {
-	static constexpr const char *Name = "length";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Number of characters in string.";
-	static constexpr const char *Example = "length('Hello🦆')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct LenFun {
-	using ALIAS = LengthFun;
-
-	static constexpr const char *Name = "len";
-};
-
-struct StrlenFun {
-	static constexpr const char *Name = "strlen";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Number of bytes in string.";
-	static constexpr const char *Example = "strlen('🦆')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct BitLengthFun {
-	static constexpr const char *Name = "bit_length";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct OctetLengthFun {
-	static constexpr const char *Name = "octet_length";
-	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Number of bytes in blob.";
-	static constexpr const char *Example = "octet_length('\\xAA\\xBB'::BLOB)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct LengthGraphemeFun {
-	static constexpr const char *Name = "length_grapheme";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Number of grapheme clusters in string.";
-	static constexpr const char *Example = "length_grapheme('🤦🏼‍♂️🤦🏽‍♀️')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct ArrayLengthFun {
-	static constexpr const char *Name = "array_length";
-	static constexpr const char *Parameters = "list";
-	static constexpr const char *Description = "Returns the length of the list.";
-	static constexpr const char *Example = "array_length([1,2,3])";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SubstringFun {
-	static constexpr const char *Name = "substring";
-	static constexpr const char *Parameters = "string,start,length";
-	static constexpr const char *Description = "Extract substring of length characters starting from character start. Note that a start value of 1 refers to the first character of the string.";
-	static constexpr const char *Example = "substring('Hello', 2, 2)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SubstrFun {
-	using ALIAS = SubstringFun;
-
-	static constexpr const char *Name = "substr";
-};
-
-struct SubstringGraphemeFun {
-	static constexpr const char *Name = "substring_grapheme";
-	static constexpr const char *Parameters = "string,start,length";
-	static constexpr const char *Description = "Extract substring of length grapheme clusters starting from character start. Note that a start value of 1 refers to the first character of the string.";
-	static constexpr const char *Example = "substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3, 2)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StringSplitFun {
-	static constexpr const char *Name = "string_split";
-	static constexpr const char *Parameters = "string,separator";
-	static constexpr const char *Description = "Splits the string along the separator";
-	static constexpr const char *Example = "string_split('hello-world', '-')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct StrSplitFun {
-	using ALIAS = StringSplitFun;
-
-	static constexpr const char *Name = "str_split";
-};
-
-struct StringToArrayFun {
-	using ALIAS = StringSplitFun;
-
-	static constexpr const char *Name = "string_to_array";
-};
-
-struct SplitFun {
-	using ALIAS = StringSplitFun;
-
-	static constexpr const char *Name = "split";
-};
-
-struct StringSplitRegexFun {
-	static constexpr const char *Name = "string_split_regex";
-	static constexpr const char *Parameters = "string,separator";
-	static constexpr const char *Description = "Splits the string along the regex";
-	static constexpr const char *Example = "string_split_regex('hello␣world; 42', ';?␣')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StrSplitRegexFun {
-	using ALIAS = StringSplitRegexFun;
-
-	static constexpr const char *Name = "str_split_regex";
-};
-
-struct RegexpSplitToArrayFun {
-	using ALIAS = StringSplitRegexFun;
-
-	static constexpr const char *Name = "regexp_split_to_array";
-};
-
-struct RegexpFun {
-	static constexpr const char *Name = "regexp_full_match";
-	static constexpr const char *Parameters = "string,regex[,options]";
-	static constexpr const char *Description = "Returns true if the entire string matches the regex. A set of optional options can be set.";
-	static constexpr const char *Example = "regexp_full_match('anabanana', '(an)*')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct RegexpMatchesFun {
-	static constexpr const char *Name = "regexp_matches";
-	static constexpr const char *Parameters = "string,pattern[,options]";
-	static constexpr const char *Description = "Returns true if string contains the regexp pattern, false otherwise. A set of optional options can be set.";
-	static constexpr const char *Example = "regexp_matches('anabanana', '(an)*')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct RegexpReplaceFun {
-	static constexpr const char *Name = "regexp_replace";
-	static constexpr const char *Parameters = "string,pattern,replacement[,options]";
-	static constexpr const char *Description = "If string contains the regexp pattern, replaces the matching part with replacement. A set of optional options can be set.";
-	static constexpr const char *Example = "regexp_replace('hello', '[lo]', '-')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct RegexpExtractFun {
-	static constexpr const char *Name = "regexp_extract";
-	static constexpr const char *Parameters = "string,pattern[,group = 0][,options]";
-	static constexpr const char *Description = "If string contains the regexp pattern, returns the capturing group specified by optional parameter group. The group must be a constant value. If no group is given, it defaults to 0. A set of optional options can be set.";
-	static constexpr const char *Example = "regexp_extract('abc', '([a-z])(b)', 1)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct RegexpExtractAllFun {
-	static constexpr const char *Name = "regexp_extract_all";
-	static constexpr const char *Parameters = "string, regex[, group = 0][, options]";
-	static constexpr const char *Description = "Split the string along the regex and extract all occurrences of group. A set of optional options can be set.";
-	static constexpr const char *Example = "regexp_extract_all('hello_world', '([a-z ]+)_?', 1)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct RegexpEscapeFun {
-	static constexpr const char *Name = "regexp_escape";
-	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Escapes all potentially meaningful regexp characters in the input string";
-	static constexpr const char *Example = "regexp_escape('https://duckdb.org')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LikeFun {
-	static constexpr const char *Name = "~~";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NotLikeFun {
-	static constexpr const char *Name = "!~~";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct GlobPatternFun {
-	static constexpr const char *Name = "~~~";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct ILikeFun {
-	static constexpr const char *Name = "~~*";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NotILikeFun {
-	static constexpr const char *Name = "!~~*";
-	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct LikeEscapeFun {
-	static constexpr const char *Name = "like_escape";
-	static constexpr const char *Parameters = "string,like_specifier,escape_character";
-	static constexpr const char *Description = "Returns true if the string matches the like_specifier (see Pattern Matching) using case-sensitive matching. escape_character is used to search for wildcard characters in the string.";
-	static constexpr const char *Example = "like_escape('a%c', 'a$%c', '$')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NotLikeEscapeFun {
-	static constexpr const char *Name = "not_like_escape";
-	static constexpr const char *Parameters = "string,like_specifier,escape_character";
-	static constexpr const char *Description = "Returns false if the string matches the like_specifier (see Pattern Matching) using case-sensitive matching. escape_character is used to search for wildcard characters in the string.";
-	static constexpr const char *Example = "not_like_escape('a%c', 'a$%c', '$')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct IlikeEscapeFun {
-	static constexpr const char *Name = "ilike_escape";
-	static constexpr const char *Parameters = "string,like_specifier,escape_character";
-	static constexpr const char *Description = "Returns true if the string matches the like_specifier (see Pattern Matching) using case-insensitive matching. escape_character is used to search for wildcard characters in the string.";
-	static constexpr const char *Example = "ilike_escape('A%c', 'a$%C', '$')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct NotIlikeEscapeFun {
-	static constexpr const char *Name = "not_ilike_escape";
-	static constexpr const char *Parameters = "string,like_specifier,escape_character";
-	static constexpr const char *Description = "Returns false if the string matches the like_specifier (see Pattern Matching) using case-insensitive matching. escape_character is used to search for wildcard characters in the string.";
-	static constexpr const char *Example = "not_ilike_escape('A%c', 'a$%C', '$')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MD5Fun {
-	static constexpr const char *Name = "md5";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Returns the MD5 hash of the value as a string";
-	static constexpr const char *Example = "md5('123')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct MD5NumberFun {
-	static constexpr const char *Name = "md5_number";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Returns the MD5 hash of the value as an INT128";
-	static constexpr const char *Example = "md5_number('123')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SHA1Fun {
-	static constexpr const char *Name = "sha1";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Returns the SHA1 hash of the value";
-	static constexpr const char *Example = "sha1('hello')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct SHA256Fun {
-	static constexpr const char *Name = "sha256";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Returns the SHA256 hash of the value";
-	static constexpr const char *Example = "sha256('hello')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/struct_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/struct_functions.hpp
deleted file mode 100644
index fa11d636f..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/struct_functions.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/struct_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct StructExtractFun {
-	static constexpr const char *Name = "struct_extract";
-	static constexpr const char *Parameters = "struct,'entry'";
-	static constexpr const char *Description = "Extract the named entry from the STRUCT.";
-	static constexpr const char *Example = "struct_extract({'i': 3, 'v2': 3, 'v3': 0}, 'i')";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StructExtractAtFun {
-	static constexpr const char *Name = "struct_extract_at";
-	static constexpr const char *Parameters = "struct,'entry'";
-	static constexpr const char *Description = "Extract the entry from the STRUCT by position (starts at 1!).";
-	static constexpr const char *Example = "struct_extract_at({'i': 3, 'v2': 3, 'v3': 0}, 2)";
-
-	static ScalarFunctionSet GetFunctions();
-};
-
-struct StructPackFun {
-	static constexpr const char *Name = "struct_pack";
-	static constexpr const char *Parameters = "name:=any,...";
-	static constexpr const char *Description = "Create a STRUCT containing the argument values. The entry name will be the bound variable name.";
-	static constexpr const char *Example = "struct_pack(i := 4, s := 'string')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct RowFun {
-	static constexpr const char *Name = "row";
-	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Create an unnamed STRUCT (tuple) containing the argument values.";
-	static constexpr const char *Example = "row(i, i % 4, i / 4)";
-
-	static ScalarFunction GetFunction();
-};
-
-struct StructConcatFun {
-	static constexpr const char *Name = "struct_concat";
-	static constexpr const char *Parameters = "struct,struct,...";
-	static constexpr const char *Description = "Merge the multiple STRUCTs into a single STRUCT.";
-	static constexpr const char *Example = "struct_concat(struct_pack(i := 4), struct_pack(s := 'string'))";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/struct_utils.hpp b/src/duckdb/src/include/duckdb/function/scalar/struct_utils.hpp
deleted file mode 100644
index d92acd59e..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/struct_utils.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/struct_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct StructExtractBindData : public FunctionData {
-	explicit StructExtractBindData(idx_t index) : index(index) {
-	}
-
-	idx_t index;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StructExtractBindData>(index);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<StructExtractBindData>();
-		return index == other.index;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp
deleted file mode 100644
index c7a2fe269..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// function/scalar/system_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_functions.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct FinalizeFun {
-	static constexpr const char *Name = "finalize";
-	static constexpr const char *Parameters = "col0";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-struct CombineFun {
-	static constexpr const char *Name = "combine";
-	static constexpr const char *Parameters = "col0,col1";
-	static constexpr const char *Description = "";
-	static constexpr const char *Example = "";
-
-	static ScalarFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar_function.hpp b/src/duckdb/src/include/duckdb/function/scalar_function.hpp
deleted file mode 100644
index 236356b9a..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar_function.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor_state.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-
-struct FunctionLocalState {
-	DUCKDB_API virtual ~FunctionLocalState();
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct ScalarFunctionInfo {
-	DUCKDB_API virtual ~ScalarFunctionInfo();
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class Binder;
-class BoundFunctionExpression;
-class ScalarFunctionCatalogEntry;
-
-struct StatementProperties;
-
-struct FunctionStatisticsInput {
-	FunctionStatisticsInput(BoundFunctionExpression &expr_p, optional_ptr<FunctionData> bind_data_p,
-	                        vector<BaseStatistics> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
-	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
-	}
-
-	BoundFunctionExpression &expr;
-	optional_ptr<FunctionData> bind_data;
-	vector<BaseStatistics> &child_stats;
-	unique_ptr<Expression> *expr_ptr;
-};
-
-struct FunctionModifiedDatabasesInput {
-	FunctionModifiedDatabasesInput(optional_ptr<FunctionData> bind_data_p, StatementProperties &properties)
-	    : bind_data(bind_data_p), properties(properties) {
-	}
-
-	optional_ptr<FunctionData> bind_data;
-	StatementProperties &properties;
-};
-
-struct FunctionBindExpressionInput {
-	FunctionBindExpressionInput(ClientContext &context_p, optional_ptr<FunctionData> bind_data_p,
-	                            BoundFunctionExpression &function_p)
-	    : context(context_p), bind_data(bind_data_p), function(function_p) {
-	}
-
-	ClientContext &context;
-	optional_ptr<FunctionData> bind_data;
-	BoundFunctionExpression &function;
-};
-
-struct ScalarFunctionBindInput {
-	explicit ScalarFunctionBindInput(Binder &binder) : binder(binder) {
-	}
-
-	Binder &binder;
-};
-
-//! The scalar function type
-typedef std::function<void(DataChunk &, ExpressionState &, Vector &)> scalar_function_t;
-//! The type to bind the scalar function and to create the function data
-typedef unique_ptr<FunctionData> (*bind_scalar_function_t)(ClientContext &context, ScalarFunction &bound_function,
-                                                           vector<unique_ptr<Expression>> &arguments);
-typedef unique_ptr<FunctionData> (*bind_scalar_function_extended_t)(ScalarFunctionBindInput &bind_input,
-                                                                    ScalarFunction &bound_function,
-                                                                    vector<unique_ptr<Expression>> &arguments);
-//! The type to initialize a thread local state for the scalar function
-typedef unique_ptr<FunctionLocalState> (*init_local_state_t)(ExpressionState &state,
-                                                             const BoundFunctionExpression &expr,
-                                                             FunctionData *bind_data);
-//! The type to propagate statistics for this scalar function
-typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &context, FunctionStatisticsInput &input);
-//! The type to bind lambda-specific parameter types
-typedef LogicalType (*bind_lambda_function_t)(const idx_t parameter_idx, const LogicalType &list_child_type);
-//! The type to bind lambda-specific parameter types
-typedef void (*get_modified_databases_t)(ClientContext &context, FunctionModifiedDatabasesInput &input);
-
-typedef void (*function_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                     const ScalarFunction &function);
-typedef unique_ptr<FunctionData> (*function_deserialize_t)(Deserializer &deserializer, ScalarFunction &function);
-
-//! The type to bind lambda-specific parameter types
-typedef unique_ptr<Expression> (*function_bind_expression_t)(FunctionBindExpressionInput &input);
-
-class ScalarFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
-public:
-	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-	                          scalar_function_t function, bind_scalar_function_t bind = nullptr,
-	                          bind_scalar_function_extended_t bind_extended = nullptr,
-	                          function_statistics_t statistics = nullptr, init_local_state_t init_local_state = nullptr,
-	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                          FunctionStability stability = FunctionStability::CONSISTENT,
-	                          FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
-	                          bind_lambda_function_t bind_lambda = nullptr);
-
-	DUCKDB_API ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-	                          bind_scalar_function_t bind = nullptr,
-	                          bind_scalar_function_extended_t bind_extended = nullptr,
-	                          function_statistics_t statistics = nullptr, init_local_state_t init_local_state = nullptr,
-	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                          FunctionStability stability = FunctionStability::CONSISTENT,
-	                          FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
-	                          bind_lambda_function_t bind_lambda = nullptr);
-
-	//! The main scalar function to execute
-	scalar_function_t function;
-	//! The bind function (if any)
-	bind_scalar_function_t bind;
-	//! The bind function that receives extra input to perform more complex binding operations (if any)
-	bind_scalar_function_extended_t bind_extended = nullptr;
-	//! Init thread local state for the function (if any)
-	init_local_state_t init_local_state;
-	//! The statistics propagation function (if any)
-	function_statistics_t statistics;
-	//! The lambda bind function (if any)
-	bind_lambda_function_t bind_lambda;
-	//! Function to bind the result function expression directly (if any)
-	function_bind_expression_t bind_expression;
-	//! Gets the modified databases (if any)
-	get_modified_databases_t get_modified_databases;
-
-	function_serialize_t serialize;
-	function_deserialize_t deserialize;
-	//! Additional function info, passed to the bind
-	shared_ptr<ScalarFunctionInfo> function_info;
-
-	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
-	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
-
-	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
-
-public:
-	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
-
-	template <class TA, class TR, class OP>
-	static void UnaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() >= 1);
-		UnaryExecutor::Execute<TA, TR, OP>(input.data[0], result, input.size());
-	}
-
-	template <class TA, class TB, class TR, class OP>
-	static void BinaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() == 2);
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, OP>(input.data[0], input.data[1], result, input.size());
-	}
-
-	template <class TA, class TB, class TC, class TR, class OP>
-	static void TernaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() == 3);
-		TernaryExecutor::ExecuteStandard<TA, TB, TC, TR, OP>(input.data[0], input.data[1], input.data[2], result,
-		                                                     input.size());
-	}
-
-public:
-	template <class OP>
-	static scalar_function_t GetScalarUnaryFunction(const LogicalType &type) {
-		scalar_function_t function;
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-			function = &ScalarFunction::UnaryFunction<int8_t, int8_t, OP>;
-			break;
-		case LogicalTypeId::SMALLINT:
-			function = &ScalarFunction::UnaryFunction<int16_t, int16_t, OP>;
-			break;
-		case LogicalTypeId::INTEGER:
-			function = &ScalarFunction::UnaryFunction<int32_t, int32_t, OP>;
-			break;
-		case LogicalTypeId::BIGINT:
-			function = &ScalarFunction::UnaryFunction<int64_t, int64_t, OP>;
-			break;
-		case LogicalTypeId::UTINYINT:
-			function = &ScalarFunction::UnaryFunction<uint8_t, uint8_t, OP>;
-			break;
-		case LogicalTypeId::USMALLINT:
-			function = &ScalarFunction::UnaryFunction<uint16_t, uint16_t, OP>;
-			break;
-		case LogicalTypeId::UINTEGER:
-			function = &ScalarFunction::UnaryFunction<uint32_t, uint32_t, OP>;
-			break;
-		case LogicalTypeId::UBIGINT:
-			function = &ScalarFunction::UnaryFunction<uint64_t, uint64_t, OP>;
-			break;
-		case LogicalTypeId::HUGEINT:
-			function = &ScalarFunction::UnaryFunction<hugeint_t, hugeint_t, OP>;
-			break;
-		case LogicalTypeId::UHUGEINT:
-			function = &ScalarFunction::UnaryFunction<uhugeint_t, uhugeint_t, OP>;
-			break;
-		case LogicalTypeId::FLOAT:
-			function = &ScalarFunction::UnaryFunction<float, float, OP>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			function = &ScalarFunction::UnaryFunction<double, double, OP>;
-			break;
-		default:
-			throw InternalException("Unimplemented type for GetScalarUnaryFunction");
-		}
-		return function;
-	}
-
-	template <class TR, class OP>
-	static scalar_function_t GetScalarUnaryFunctionFixedReturn(const LogicalType &type) {
-		scalar_function_t function;
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-			function = &ScalarFunction::UnaryFunction<int8_t, TR, OP>;
-			break;
-		case LogicalTypeId::SMALLINT:
-			function = &ScalarFunction::UnaryFunction<int16_t, TR, OP>;
-			break;
-		case LogicalTypeId::INTEGER:
-			function = &ScalarFunction::UnaryFunction<int32_t, TR, OP>;
-			break;
-		case LogicalTypeId::BIGINT:
-			function = &ScalarFunction::UnaryFunction<int64_t, TR, OP>;
-			break;
-		case LogicalTypeId::UTINYINT:
-			function = &ScalarFunction::UnaryFunction<uint8_t, TR, OP>;
-			break;
-		case LogicalTypeId::USMALLINT:
-			function = &ScalarFunction::UnaryFunction<uint16_t, TR, OP>;
-			break;
-		case LogicalTypeId::UINTEGER:
-			function = &ScalarFunction::UnaryFunction<uint32_t, TR, OP>;
-			break;
-		case LogicalTypeId::UBIGINT:
-			function = &ScalarFunction::UnaryFunction<uint64_t, TR, OP>;
-			break;
-		case LogicalTypeId::HUGEINT:
-			function = &ScalarFunction::UnaryFunction<hugeint_t, TR, OP>;
-			break;
-		case LogicalTypeId::UHUGEINT:
-			function = &ScalarFunction::UnaryFunction<uhugeint_t, TR, OP>;
-			break;
-		case LogicalTypeId::FLOAT:
-			function = &ScalarFunction::UnaryFunction<float, TR, OP>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			function = &ScalarFunction::UnaryFunction<double, TR, OP>;
-			break;
-		default:
-			throw InternalException("Unimplemented type for GetScalarUnaryFunctionFixedReturn");
-		}
-		return function;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp b/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp
deleted file mode 100644
index cddaeb9db..000000000
--- a/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-//! The SelectStatement of the view
-#include "duckdb/function/macro_function.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-class ScalarMacroFunction : public MacroFunction {
-public:
-	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
-
-public:
-	explicit ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
-	ScalarMacroFunction(void);
-
-	//! The macro expression
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	unique_ptr<MacroFunction> Copy() const override;
-
-	string ToSQL() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/arrow.hpp b/src/duckdb/src/include/duckdb/function/table/arrow.hpp
deleted file mode 100644
index 7db6cd363..000000000
--- a/src/duckdb/src/include/duckdb/function/table/arrow.hpp
+++ /dev/null
@@ -1,238 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/arrow.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/thread.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
-
-namespace duckdb {
-
-struct ArrowInterval {
-	int32_t months;
-	int32_t days;
-	int64_t nanoseconds;
-
-	inline bool operator==(const ArrowInterval &rhs) const {
-		return this->days == rhs.days && this->months == rhs.months && this->nanoseconds == rhs.nanoseconds;
-	}
-};
-
-struct ArrowProjectedColumns {
-	unordered_map<idx_t, string> projection_map;
-	vector<string> columns;
-	// Map from filter index to column index
-	unordered_map<idx_t, idx_t> filter_to_col;
-};
-
-struct ArrowStreamParameters {
-	ArrowProjectedColumns projected_columns;
-	TableFilterSet *filters;
-};
-
-typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(uintptr_t stream_factory_ptr,
-                                                                        ArrowStreamParameters &parameters);
-typedef void (*stream_factory_get_schema_t)(ArrowArrayStream *stream_factory_ptr, ArrowSchema &schema);
-
-struct ArrowScanFunctionData : public TableFunctionData {
-public:
-	ArrowScanFunctionData(stream_factory_produce_t scanner_producer_p, uintptr_t stream_factory_ptr_p,
-	                      shared_ptr<DependencyItem> dependency = nullptr)
-	    : lines_read(0), stream_factory_ptr(stream_factory_ptr_p), scanner_producer(scanner_producer_p),
-	      dependency(std::move(dependency)) {
-	}
-	vector<LogicalType> all_types;
-	atomic<idx_t> lines_read;
-	ArrowSchemaWrapper schema_root;
-	idx_t rows_per_thread;
-	//! Pointer to the scanner factory
-	uintptr_t stream_factory_ptr;
-	//! Pointer to the scanner factory produce
-	stream_factory_produce_t scanner_producer;
-	//! The (optional) dependency of this function (used in Python for example)
-	shared_ptr<DependencyItem> dependency;
-	//! Arrow table data
-	ArrowTableType arrow_table;
-	//! Whether projection pushdown is enabled on the scan
-	bool projection_pushdown_enabled = true;
-};
-
-struct ArrowRunEndEncodingState {
-public:
-	ArrowRunEndEncodingState() {
-	}
-
-public:
-	unique_ptr<Vector> run_ends;
-	unique_ptr<Vector> values;
-
-public:
-	void Reset() {
-		run_ends.reset();
-		values.reset();
-	}
-};
-
-struct ArrowScanLocalState;
-struct ArrowArrayScanState {
-public:
-	explicit ArrowArrayScanState(ArrowScanLocalState &state);
-
-public:
-	ArrowScanLocalState &state;
-	// Hold ownership over the Arrow Arrays owned by DuckDB to allow for zero-copy
-	shared_ptr<ArrowArrayWrapper> owned_data;
-	unordered_map<idx_t, unique_ptr<ArrowArrayScanState>> children;
-	// Optionally holds the pointer that was used to create the cached dictionary
-	optional_ptr<ArrowArray> arrow_dictionary = nullptr;
-	// Cache the (optional) dictionary of this array
-	unique_ptr<Vector> dictionary;
-	//! Run-end-encoding state
-	ArrowRunEndEncodingState run_end_encoding;
-
-public:
-	ArrowArrayScanState &GetChild(idx_t child_idx);
-	void AddDictionary(unique_ptr<Vector> dictionary_p, ArrowArray *arrow_dict);
-	bool HasDictionary() const;
-	bool CacheOutdated(ArrowArray *dictionary) const;
-	Vector &GetDictionary();
-	ArrowRunEndEncodingState &RunEndEncoding() {
-		return run_end_encoding;
-	}
-
-public:
-	void Reset() {
-		// Note: dictionary is not reset
-		// the dictionary should be the same for every array scanned of this column
-		run_end_encoding.Reset();
-		for (auto &child : children) {
-			child.second->Reset();
-		}
-		owned_data.reset();
-	}
-};
-
-struct ArrowScanLocalState : public LocalTableFunctionState {
-public:
-	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(current_chunk.release()) {
-	}
-
-public:
-	unique_ptr<ArrowArrayStreamWrapper> stream;
-	shared_ptr<ArrowArrayWrapper> chunk;
-	idx_t chunk_offset = 0;
-	idx_t batch_index = 0;
-	vector<column_t> column_ids;
-	unordered_map<idx_t, unique_ptr<ArrowArrayScanState>> array_states;
-	TableFilterSet *filters = nullptr;
-	//! The DataChunk containing all read columns (even filter columns that are immediately removed)
-	DataChunk all_columns;
-
-public:
-	void Reset() {
-		chunk_offset = 0;
-		for (auto &col : array_states) {
-			col.second->Reset();
-		}
-	}
-	ArrowArrayScanState &GetState(idx_t child_idx) {
-		auto it = array_states.find(child_idx);
-		if (it == array_states.end()) {
-			auto child_p = make_uniq<ArrowArrayScanState>(*this);
-			auto &child = *child_p;
-			array_states.emplace(child_idx, std::move(child_p));
-			return child;
-		}
-		return *it->second;
-	}
-};
-
-struct ArrowScanGlobalState : public GlobalTableFunctionState {
-	unique_ptr<ArrowArrayStreamWrapper> stream;
-	mutex main_mutex;
-	idx_t max_threads = 1;
-	idx_t batch_index = 0;
-	bool done = false;
-
-	vector<idx_t> projection_ids;
-	vector<LogicalType> scanned_types;
-
-	idx_t MaxThreads() const override {
-		return max_threads;
-	}
-
-	bool CanRemoveFilterColumns() const {
-		return !projection_ids.empty();
-	}
-};
-
-struct ArrowTableFunction {
-public:
-	static void RegisterFunction(BuiltinFunctions &set);
-
-public:
-	//! Binds an arrow table
-	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
-	                                              vector<LogicalType> &return_types, vector<string> &names);
-	static unique_ptr<FunctionData> ArrowScanBindDumb(ClientContext &context, TableFunctionBindInput &input,
-	                                                  vector<LogicalType> &return_types, vector<string> &names);
-	//! Actual conversion from Arrow to DuckDB
-	static void ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data,
-	                          DataChunk &output, idx_t start, bool arrow_scan_is_projected = true,
-	                          idx_t rowid_column_index = COLUMN_IDENTIFIER_ROW_ID);
-
-	//! Get next scan state
-	static bool ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-	                                       ArrowScanLocalState &state, ArrowScanGlobalState &parallel_state);
-
-	//! Initialize Global State
-	static unique_ptr<GlobalTableFunctionState> ArrowScanInitGlobal(ClientContext &context,
-	                                                                TableFunctionInitInput &input);
-
-	//! Initialize Local State
-	static unique_ptr<LocalTableFunctionState> ArrowScanInitLocalInternal(ClientContext &context,
-	                                                                      TableFunctionInitInput &input,
-	                                                                      GlobalTableFunctionState *global_state);
-	static unique_ptr<LocalTableFunctionState> ArrowScanInitLocal(ExecutionContext &context,
-	                                                              TableFunctionInitInput &input,
-	                                                              GlobalTableFunctionState *global_state);
-
-	//! Scan Function
-	static void ArrowScanFunction(ClientContext &context, TableFunctionInput &data, DataChunk &output);
-	static void PopulateArrowTableType(ArrowTableType &arrow_table, ArrowSchemaWrapper &schema_p, vector<string> &names,
-	                                   vector<LogicalType> &return_types);
-
-protected:
-	//! Defines Maximum Number of Threads
-	static idx_t ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data);
-
-	//! Allows parallel Create Table / Insertion
-	static OperatorPartitionData ArrowGetPartitionData(ClientContext &context, TableFunctionGetPartitionInput &input);
-
-	//! Specify if a given type can be pushed-down by the arrow engine
-	static bool ArrowPushdownType(const LogicalType &type);
-	//! -----Utility Functions:-----
-	//! Gets Arrow Table's Cardinality
-	static unique_ptr<NodeStatistics> ArrowScanCardinality(ClientContext &context, const FunctionData *bind_data);
-	//! Gets the progress on the table scan, used for Progress Bars
-	static double ArrowProgress(ClientContext &context, const FunctionData *bind_data,
-	                            const GlobalTableFunctionState *global_state);
-
-public:
-	//! Helper function to get the DuckDB logical type
-	static unique_ptr<ArrowType> GetArrowLogicalType(ArrowSchema &schema);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp
deleted file mode 100644
index 5c2b710a1..000000000
--- a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/arrow_duck_schema.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <utility>
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/function/table/arrow/arrow_type_info.hpp"
-
-namespace duckdb {
-
-class ArrowType {
-public:
-	//! From a DuckDB type
-	explicit ArrowType(LogicalType type_p, unique_ptr<ArrowTypeInfo> type_info = nullptr)
-	    : type(std::move(type_p)), type_info(std::move(type_info)) {
-	}
-	explicit ArrowType(string error_message_p, bool not_implemented_p = false)
-	    : type(LogicalTypeId::INVALID), type_info(nullptr), error_message(std::move(error_message_p)),
-	      not_implemented(not_implemented_p) {
-	}
-
-public:
-	LogicalType GetDuckType(bool use_dictionary = false) const;
-
-	void SetDictionary(unique_ptr<ArrowType> dictionary);
-	bool HasDictionary() const;
-	const ArrowType &GetDictionary() const;
-
-	bool RunEndEncoded() const;
-	void SetRunEndEncoded();
-
-	template <class T>
-	const T &GetTypeInfo() const {
-		return type_info->Cast<T>();
-	}
-	void ThrowIfInvalid() const;
-
-private:
-	LogicalType type;
-	//! Hold the optional type if the array is a dictionary
-	unique_ptr<ArrowType> dictionary_type;
-	//! Is run-end-encoded
-	bool run_end_encoded = false;
-	unique_ptr<ArrowTypeInfo> type_info;
-	//! Error message in case of an invalid type (i.e., from an unsupported extension)
-	string error_message;
-	//! In case of an error do we throw not implemented?
-	bool not_implemented = false;
-};
-
-using arrow_column_map_t = unordered_map<idx_t, unique_ptr<ArrowType>>;
-
-struct ArrowTableType {
-public:
-	void AddColumn(idx_t index, unique_ptr<ArrowType> type);
-	const arrow_column_map_t &GetColumns() const;
-
-private:
-	arrow_column_map_t arrow_convert_data;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp
deleted file mode 100644
index fa8358496..000000000
--- a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/arrow/arrow_type_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/function/table/arrow/enum/arrow_type_info_type.hpp"
-#include "duckdb/function/table/arrow/enum/arrow_datetime_type.hpp"
-#include "duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-class ArrowType;
-
-struct ArrowTypeInfo {
-public:
-	explicit ArrowTypeInfo(ArrowTypeInfoType type);
-	virtual ~ArrowTypeInfo();
-
-	ArrowTypeInfoType type;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast ArrowTypeInfo, type mismatch (expected: %s, got: %s)",
-			                        EnumUtil::ToString(TARGET::TYPE), EnumUtil::ToString(type));
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast ArrowTypeInfo, type mismatch (expected: %s, got: %s)",
-			                        EnumUtil::ToString(TARGET::TYPE), EnumUtil::ToString(type));
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct ArrowStructInfo : public ArrowTypeInfo {
-public:
-	static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::STRUCT;
-
-public:
-	explicit ArrowStructInfo(vector<unique_ptr<ArrowType>> children);
-	~ArrowStructInfo() override;
-
-public:
-	idx_t ChildCount() const;
-	const ArrowType &GetChild(idx_t index) const;
-	const vector<unique_ptr<ArrowType>> &GetChildren() const;
-
-private:
-	vector<unique_ptr<ArrowType>> children;
-};
-
-struct ArrowDateTimeInfo : public ArrowTypeInfo {
-public:
-	static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::DATE_TIME;
-
-public:
-	explicit ArrowDateTimeInfo(ArrowDateTimeType size);
-	~ArrowDateTimeInfo() override;
-
-public:
-	ArrowDateTimeType GetDateTimeType() const;
-
-private:
-	ArrowDateTimeType size_type;
-};
-
-struct ArrowStringInfo : public ArrowTypeInfo {
-public:
-	static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::STRING;
-
-public:
-	explicit ArrowStringInfo(ArrowVariableSizeType size);
-	explicit ArrowStringInfo(idx_t fixed_size);
-	~ArrowStringInfo() override;
-
-public:
-	ArrowVariableSizeType GetSizeType() const;
-	idx_t FixedSize() const;
-
-private:
-	ArrowVariableSizeType size_type;
-	idx_t fixed_size;
-};
-
-struct ArrowListInfo : public ArrowTypeInfo {
-public:
-	static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::LIST;
-
-public:
-	static unique_ptr<ArrowListInfo> ListView(unique_ptr<ArrowType> child, ArrowVariableSizeType size);
-	static unique_ptr<ArrowListInfo> List(unique_ptr<ArrowType> child, ArrowVariableSizeType size);
-	~ArrowListInfo() override;
-
-public:
-	ArrowVariableSizeType GetSizeType() const;
-	bool IsView() const;
-	ArrowType &GetChild() const;
-
-private:
-	explicit ArrowListInfo(unique_ptr<ArrowType> child, ArrowVariableSizeType size);
-
-private:
-	ArrowVariableSizeType size_type;
-	bool is_view = false;
-	unique_ptr<ArrowType> child;
-};
-
-struct ArrowArrayInfo : public ArrowTypeInfo {
-public:
-	static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::ARRAY;
-
-public:
-	explicit ArrowArrayInfo(unique_ptr<ArrowType> child, idx_t fixed_size);
-	~ArrowArrayInfo() override;
-
-public:
-	idx_t FixedSize() const;
-	ArrowType &GetChild() const;
-
-private:
-	unique_ptr<ArrowType> child;
-	idx_t fixed_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_datetime_type.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_datetime_type.hpp
deleted file mode 100644
index 41f987385..000000000
--- a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_datetime_type.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Arrow Time/Date Types
-//===--------------------------------------------------------------------===//
-enum class ArrowDateTimeType : uint8_t {
-	MILLISECONDS,
-	MICROSECONDS,
-	NANOSECONDS,
-	SECONDS,
-	DAYS,
-	MONTHS,
-	MONTH_DAY_NANO
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp
deleted file mode 100644
index e478e1531..000000000
--- a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-namespace duckdb {
-
-enum class ArrowTypeInfoType : uint8_t { LIST, STRUCT, DATE_TIME, STRING, ARRAY };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp
deleted file mode 100644
index be85abc9b..000000000
--- a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Arrow Variable Size Types
-//===--------------------------------------------------------------------===//
-enum class ArrowVariableSizeType : uint8_t { NORMAL, FIXED_SIZE, SUPER_SIZE, VIEW };
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/list.hpp b/src/duckdb/src/include/duckdb/function/table/list.hpp
deleted file mode 100644
index da9633d98..000000000
--- a/src/duckdb/src/include/duckdb/function/table/list.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/function/table/range.hpp"
-#include "duckdb/function/table/summary.hpp"
-#include "duckdb/function/table/files.hpp"
diff --git a/src/duckdb/src/include/duckdb/function/table/range.hpp b/src/duckdb/src/include/duckdb/function/table/range.hpp
deleted file mode 100644
index 6070fb257..000000000
--- a/src/duckdb/src/include/duckdb/function/table/range.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/range.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct CheckpointFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct GlobTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RangeTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RepeatTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RepeatRowTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UnnestTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CSVSnifferFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReadBlobFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReadTextFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct QueryTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/read_csv.hpp b/src/duckdb/src/include/duckdb/function/table/read_csv.hpp
deleted file mode 100644
index 67ab686b3..000000000
--- a/src/duckdb/src/include/duckdb/function/table/read_csv.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/read_csv.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_buffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
-
-namespace duckdb {
-class BaseScanner;
-class StringValueScanner;
-
-class ReadCSV {
-public:
-	static unique_ptr<CSVFileHandle> OpenCSV(const string &file_path, const CSVReaderOptions &options,
-	                                         ClientContext &context);
-};
-
-struct BaseCSVData : public TableFunctionData {
-	//! The file path of the CSV file to read or write
-	vector<string> files;
-	//! The CSV reader options
-	CSVReaderOptions options;
-	//! Offsets for generated columns
-	idx_t filename_col_idx {};
-	idx_t hive_partition_col_idx {};
-
-	void Finalize();
-};
-
-struct WriteCSVData : public BaseCSVData {
-	WriteCSVData(string file_path, vector<LogicalType> sql_types, vector<string> names)
-	    : sql_types(std::move(sql_types)) {
-		files.push_back(std::move(file_path));
-		options.name_list = std::move(names);
-		if (options.dialect_options.state_machine_options.escape == '\0') {
-			options.dialect_options.state_machine_options.escape = options.dialect_options.state_machine_options.quote;
-		}
-	}
-
-	//! The SQL types to write
-	vector<LogicalType> sql_types;
-	//! The newline string to write
-	string newline = "\n";
-	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
-	idx_t flush_size = 4096ULL * 8ULL;
-	//! For each byte whether the CSV file requires quotes when containing the byte
-	unsafe_unique_array<bool> requires_quotes;
-	//! Expressions used to convert the input into strings
-	vector<unique_ptr<Expression>> cast_expressions;
-};
-
-struct ColumnInfo {
-	ColumnInfo() {
-	}
-	ColumnInfo(vector<std::string> names_p, vector<LogicalType> types_p) {
-		names = std::move(names_p);
-		types = std::move(types_p);
-	}
-	void Serialize(Serializer &serializer) const;
-	static ColumnInfo Deserialize(Deserializer &deserializer);
-
-	vector<std::string> names;
-	vector<LogicalType> types;
-};
-
-struct ReadCSVData : public BaseCSVData {
-	ReadCSVData();
-	//! The expected SQL types to read from the file
-	vector<LogicalType> csv_types;
-	//! The expected SQL names to be read from the file
-	vector<string> csv_names;
-	//! If the sql types from the file were manually set
-	vector<bool> manually_set;
-	//! The expected SQL types to be returned from the read - including added constants (e.g. filename, hive partitions)
-	vector<LogicalType> return_types;
-	//! The expected SQL names to be returned from the read - including added constants (e.g. filename, hive partitions)
-	vector<string> return_names;
-	//! The buffer manager (if any): this is used when automatic detection is used during binding.
-	//! In this case, some CSV buffers have already been read and can be reused.
-	shared_ptr<CSVBufferManager> buffer_manager;
-	unique_ptr<CSVFileScan> initial_reader;
-	//! The union readers are created (when csv union_by_name option is on) during binding
-	//! Those readers can be re-used during ReadCSVFunction
-	vector<unique_ptr<CSVUnionData>> union_readers;
-	//! Reader bind data
-	MultiFileReaderBindData reader_bind;
-
-	vector<ColumnInfo> column_info;
-
-	void Initialize(unique_ptr<CSVFileScan> &reader) {
-		this->initial_reader = std::move(reader);
-	}
-	void Initialize(ClientContext &, unique_ptr<CSVUnionData> &data) {
-		this->initial_reader = std::move(data->reader);
-	}
-	void FinalizeRead(ClientContext &context);
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<ReadCSVData> Deserialize(Deserializer &deserializer);
-};
-
-struct CSVCopyFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReadCSVTableFunction {
-	static TableFunction GetFunction();
-	static TableFunction GetAutoFunction();
-	static void ReadCSVAddNamedParameters(TableFunction &table_function);
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/summary.hpp b/src/duckdb/src/include/duckdb/function/table/summary.hpp
deleted file mode 100644
index 8d4300e11..000000000
--- a/src/duckdb/src/include/duckdb/function/table/summary.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/summary.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct SummaryTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/system_functions.hpp b/src/duckdb/src/include/duckdb/function/table/system_functions.hpp
deleted file mode 100644
index 689b55201..000000000
--- a/src/duckdb/src/include/duckdb/function/table/system_functions.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/system_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-
-struct PragmaCollations {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaTableInfo {
-	static void GetColumnInfo(TableCatalogEntry &table, const ColumnDefinition &column, DataChunk &output, idx_t index);
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaStorageInfo {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaMetadataInfo {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaVersion {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaPlatform {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaDatabaseSize {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSchemasFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBColumnsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBConstraintsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSecretsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBWhichSecretFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBDatabasesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBDependenciesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBExtensionsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBFunctionsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBKeywordsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBIndexesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBMemoryFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBOptimizersFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSequencesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSettingsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBTablesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBTableSample {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBTemporaryFilesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBTypesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBVariablesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBViewsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TestType {
-	TestType(LogicalType type_p, string name_p)
-	    : type(std::move(type_p)), name(std::move(name_p)), min_value(Value::MinimumValue(type)),
-	      max_value(Value::MaximumValue(type)) {
-	}
-	TestType(LogicalType type_p, string name_p, Value min, Value max)
-	    : type(std::move(type_p)), name(std::move(name_p)), min_value(std::move(min)), max_value(std::move(max)) {
-	}
-
-	LogicalType type;
-	string name;
-	Value min_value;
-	Value max_value;
-};
-
-struct TestAllTypesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-	static vector<TestType> GetTestTypes(bool large_enum = false);
-};
-
-struct TestVectorTypesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaUserAgent {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp
deleted file mode 100644
index e5c88e84f..000000000
--- a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/table_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/function/built_in_functions.hpp"
-
-namespace duckdb {
-class DuckTableEntry;
-class TableCatalogEntry;
-
-struct TableScanBindData : public TableFunctionData {
-	explicit TableScanBindData(DuckTableEntry &table) : table(table), is_index_scan(false), is_create_index(false) {
-	}
-
-	//! The table to scan.
-	DuckTableEntry &table;
-	//! The old purpose of this field has been deprecated.
-	//! We now use it to express an index scan in the ANALYZE call.
-	//! I.e., we const-cast the bind data and set this to true, if we opt for an index scan.
-	bool is_index_scan;
-	//! Whether or not the table scan is for index creation.
-	bool is_create_index;
-
-public:
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<TableScanBindData>();
-		return &other.table == &table;
-	}
-};
-
-//! The table scan function represents a sequential or index scan over one of DuckDB's base tables.
-struct TableScanFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-	static TableFunction GetFunction();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table_function.hpp b/src/duckdb/src/include/duckdb/function/table_function.hpp
deleted file mode 100644
index 6293100ef..000000000
--- a/src/duckdb/src/include/duckdb/function/table_function.hpp
+++ /dev/null
@@ -1,391 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/operator_result_type.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/planner/bind_context.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/storage/statistics/node_statistics.hpp"
-#include "duckdb/common/column_index.hpp"
-#include "duckdb/function/partition_stats.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-class BaseStatistics;
-class LogicalDependencyList;
-class LogicalGet;
-class TableFunction;
-class TableFilterSet;
-class TableCatalogEntry;
-struct MultiFileReader;
-struct OperatorPartitionData;
-struct OperatorPartitionInfo;
-
-struct TableFunctionInfo {
-	DUCKDB_API virtual ~TableFunctionInfo();
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct GlobalTableFunctionState {
-public:
-	// value returned from MaxThreads when as many threads as possible should be used
-	constexpr static const int64_t MAX_THREADS = 999999999;
-
-public:
-	DUCKDB_API virtual ~GlobalTableFunctionState();
-
-	virtual idx_t MaxThreads() const {
-		return 1;
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct LocalTableFunctionState {
-	DUCKDB_API virtual ~LocalTableFunctionState();
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct TableFunctionBindInput {
-	TableFunctionBindInput(vector<Value> &inputs, named_parameter_map_t &named_parameters,
-	                       vector<LogicalType> &input_table_types, vector<string> &input_table_names,
-	                       optional_ptr<TableFunctionInfo> info, optional_ptr<Binder> binder,
-	                       TableFunction &table_function, const TableFunctionRef &ref)
-	    : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types),
-	      input_table_names(input_table_names), info(info), binder(binder), table_function(table_function), ref(ref) {
-	}
-
-	vector<Value> &inputs;
-	named_parameter_map_t &named_parameters;
-	vector<LogicalType> &input_table_types;
-	vector<string> &input_table_names;
-	optional_ptr<TableFunctionInfo> info;
-	optional_ptr<Binder> binder;
-	TableFunction &table_function;
-	const TableFunctionRef &ref;
-};
-
-struct TableFunctionInitInput {
-	TableFunctionInitInput(optional_ptr<const FunctionData> bind_data_p, vector<column_t> column_ids_p,
-	                       const vector<idx_t> &projection_ids_p, optional_ptr<TableFilterSet> filters_p,
-	                       optional_ptr<SampleOptions> sample_options_p = nullptr)
-	    : bind_data(bind_data_p), column_ids(std::move(column_ids_p)), projection_ids(projection_ids_p),
-	      filters(filters_p), sample_options(sample_options_p) {
-		for (auto &col_id : column_ids) {
-			column_indexes.emplace_back(col_id);
-		}
-	}
-
-	TableFunctionInitInput(optional_ptr<const FunctionData> bind_data_p, vector<ColumnIndex> column_indexes_p,
-	                       const vector<idx_t> &projection_ids_p, optional_ptr<TableFilterSet> filters_p,
-	                       optional_ptr<SampleOptions> sample_options_p = nullptr)
-	    : bind_data(bind_data_p), column_indexes(std::move(column_indexes_p)), projection_ids(projection_ids_p),
-	      filters(filters_p), sample_options(sample_options_p) {
-		for (auto &col_id : column_indexes) {
-			column_ids.emplace_back(col_id.GetPrimaryIndex());
-		}
-	}
-
-	optional_ptr<const FunctionData> bind_data;
-	vector<column_t> column_ids;
-	vector<ColumnIndex> column_indexes;
-	const vector<idx_t> projection_ids;
-	optional_ptr<TableFilterSet> filters;
-	optional_ptr<SampleOptions> sample_options;
-
-	bool CanRemoveFilterColumns() const {
-		if (projection_ids.empty()) {
-			// No filter columns to remove.
-			return false;
-		}
-		if (projection_ids.size() == column_ids.size()) {
-			// Filter column is used in remainder of plan, so we cannot remove it.
-			return false;
-		}
-		// Fewer columns need to be projected out than that we scan.
-		return true;
-	}
-};
-
-struct TableFunctionInput {
-public:
-	TableFunctionInput(optional_ptr<const FunctionData> bind_data_p,
-	                   optional_ptr<LocalTableFunctionState> local_state_p,
-	                   optional_ptr<GlobalTableFunctionState> global_state_p)
-	    : bind_data(bind_data_p), local_state(local_state_p), global_state(global_state_p) {
-	}
-
-public:
-	optional_ptr<const FunctionData> bind_data;
-	optional_ptr<LocalTableFunctionState> local_state;
-	optional_ptr<GlobalTableFunctionState> global_state;
-};
-
-struct TableFunctionPartitionInput {
-	TableFunctionPartitionInput(optional_ptr<const FunctionData> bind_data_p, const vector<column_t> &partition_ids)
-	    : bind_data(bind_data_p), partition_ids(partition_ids) {
-	}
-
-	optional_ptr<const FunctionData> bind_data;
-	const vector<column_t> &partition_ids;
-};
-
-struct TableFunctionToStringInput {
-	TableFunctionToStringInput(const TableFunction &table_function_p, optional_ptr<const FunctionData> bind_data_p)
-	    : table_function(table_function_p), bind_data(bind_data_p) {
-	}
-	const TableFunction &table_function;
-	optional_ptr<const FunctionData> bind_data;
-};
-
-struct TableFunctionGetPartitionInput {
-public:
-	TableFunctionGetPartitionInput(optional_ptr<const FunctionData> bind_data_p,
-	                               optional_ptr<LocalTableFunctionState> local_state_p,
-	                               optional_ptr<GlobalTableFunctionState> global_state_p,
-	                               const OperatorPartitionInfo &partition_info_p)
-	    : bind_data(bind_data_p), local_state(local_state_p), global_state(global_state_p),
-	      partition_info(partition_info_p) {
-	}
-
-public:
-	optional_ptr<const FunctionData> bind_data;
-	optional_ptr<LocalTableFunctionState> local_state;
-	optional_ptr<GlobalTableFunctionState> global_state;
-	const OperatorPartitionInfo &partition_info;
-};
-
-struct GetPartitionStatsInput {
-	GetPartitionStatsInput(const TableFunction &table_function_p, optional_ptr<const FunctionData> bind_data_p)
-	    : table_function(table_function_p), bind_data(bind_data_p) {
-	}
-
-	const TableFunction &table_function;
-	optional_ptr<const FunctionData> bind_data;
-};
-
-enum class ScanType : uint8_t { TABLE, PARQUET, EXTERNAL };
-
-struct BindInfo {
-public:
-	explicit BindInfo(ScanType type_p) : type(type_p) {};
-	explicit BindInfo(TableCatalogEntry &table) : type(ScanType::TABLE), table(&table) {};
-
-	unordered_map<string, Value> options;
-	ScanType type;
-	optional_ptr<TableCatalogEntry> table;
-
-	void InsertOption(const string &name, Value value) { // NOLINT: work-around bug in clang-tidy
-		if (options.find(name) != options.end()) {
-			throw InternalException("This option already exists");
-		}
-		options.emplace(name, std::move(value));
-	}
-	template <class T>
-	T GetOption(const string &name) {
-		if (options.find(name) == options.end()) {
-			throw InternalException("This option does not exist");
-		}
-		return options[name].GetValue<T>();
-	}
-	template <class T>
-	vector<T> GetOptionList(const string &name) {
-		if (options.find(name) == options.end()) {
-			throw InternalException("This option does not exist");
-		}
-		auto option = options[name];
-		if (option.type().id() != LogicalTypeId::LIST) {
-			throw InternalException("This option is not a list");
-		}
-		vector<T> result;
-		auto list_children = ListValue::GetChildren(option);
-		for (auto &child : list_children) {
-			result.emplace_back(child.GetValue<T>());
-		}
-		return result;
-	}
-};
-
-typedef unique_ptr<FunctionData> (*table_function_bind_t)(ClientContext &context, TableFunctionBindInput &input,
-                                                          vector<LogicalType> &return_types, vector<string> &names);
-typedef unique_ptr<TableRef> (*table_function_bind_replace_t)(ClientContext &context, TableFunctionBindInput &input);
-typedef unique_ptr<GlobalTableFunctionState> (*table_function_init_global_t)(ClientContext &context,
-                                                                             TableFunctionInitInput &input);
-typedef unique_ptr<LocalTableFunctionState> (*table_function_init_local_t)(ExecutionContext &context,
-                                                                           TableFunctionInitInput &input,
-                                                                           GlobalTableFunctionState *global_state);
-typedef unique_ptr<BaseStatistics> (*table_statistics_t)(ClientContext &context, const FunctionData *bind_data,
-                                                         column_t column_index);
-typedef void (*table_function_t)(ClientContext &context, TableFunctionInput &data, DataChunk &output);
-typedef OperatorResultType (*table_in_out_function_t)(ExecutionContext &context, TableFunctionInput &data,
-                                                      DataChunk &input, DataChunk &output);
-typedef OperatorFinalizeResultType (*table_in_out_function_final_t)(ExecutionContext &context, TableFunctionInput &data,
-                                                                    DataChunk &output);
-typedef OperatorPartitionData (*table_function_get_partition_data_t)(ClientContext &context,
-                                                                     TableFunctionGetPartitionInput &input);
-
-typedef BindInfo (*table_function_get_bind_info_t)(const optional_ptr<FunctionData> bind_data);
-
-typedef unique_ptr<MultiFileReader> (*table_function_get_multi_file_reader_t)(const TableFunction &);
-
-typedef bool (*table_function_supports_pushdown_type_t)(const LogicalType &type);
-
-typedef double (*table_function_progress_t)(ClientContext &context, const FunctionData *bind_data,
-                                            const GlobalTableFunctionState *global_state);
-typedef void (*table_function_dependency_t)(LogicalDependencyList &dependencies, const FunctionData *bind_data);
-typedef unique_ptr<NodeStatistics> (*table_function_cardinality_t)(ClientContext &context,
-                                                                   const FunctionData *bind_data);
-typedef void (*table_function_pushdown_complex_filter_t)(ClientContext &context, LogicalGet &get,
-                                                         FunctionData *bind_data,
-                                                         vector<unique_ptr<Expression>> &filters);
-typedef InsertionOrderPreservingMap<string> (*table_function_to_string_t)(TableFunctionToStringInput &input);
-
-typedef void (*table_function_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                           const TableFunction &function);
-typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(Deserializer &deserializer, TableFunction &function);
-
-typedef void (*table_function_type_pushdown_t)(ClientContext &context, optional_ptr<FunctionData> bind_data,
-                                               const unordered_map<idx_t, LogicalType> &new_column_types);
-typedef TablePartitionInfo (*table_function_get_partition_info_t)(ClientContext &context,
-                                                                  TableFunctionPartitionInput &input);
-
-typedef vector<PartitionStatistics> (*table_function_get_partition_stats_t)(ClientContext &context,
-                                                                            GetPartitionStatsInput &input);
-
-//! When to call init_global to initialize the table function
-enum class TableFunctionInitialization { INITIALIZE_ON_EXECUTE, INITIALIZE_ON_SCHEDULE };
-
-class TableFunction : public SimpleNamedParameterFunction { // NOLINT: work-around bug in clang-tidy
-public:
-	DUCKDB_API
-	TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
-	              table_function_bind_t bind = nullptr, table_function_init_global_t init_global = nullptr,
-	              table_function_init_local_t init_local = nullptr);
-	DUCKDB_API
-	TableFunction(const vector<LogicalType> &arguments, table_function_t function, table_function_bind_t bind = nullptr,
-	              table_function_init_global_t init_global = nullptr, table_function_init_local_t init_local = nullptr);
-	DUCKDB_API TableFunction();
-
-	//! Bind function
-	//! This function is used for determining the return type of a table producing function and returning bind data
-	//! The returned FunctionData object should be constant and should not be changed during execution.
-	table_function_bind_t bind;
-	//! (Optional) Bind replace function
-	//! This function is called before the regular bind function. It allows returning a TableRef that will be used to
-	//! to generate a logical plan that replaces the LogicalGet of a regularly bound TableFunction. The BindReplace can
-	//! also return a nullptr to indicate a regular bind needs to be performed instead.
-	table_function_bind_replace_t bind_replace;
-	//! (Optional) global init function
-	//! Initialize the global operator state of the function.
-	//! The global operator state is used to keep track of the progress in the table function and is shared between
-	//! all threads working on the table function.
-	table_function_init_global_t init_global;
-	//! (Optional) local init function
-	//! Initialize the local operator state of the function.
-	//! The local operator state is used to keep track of the progress in the table function and is thread-local.
-	table_function_init_local_t init_local;
-	//! The main function
-	table_function_t function;
-	//! The table in-out function (if this is an in-out function)
-	table_in_out_function_t in_out_function;
-	//! The table in-out final function (if this is an in-out function)
-	table_in_out_function_final_t in_out_function_final;
-	//! (Optional) statistics function
-	//! Returns the statistics of a specified column
-	table_statistics_t statistics;
-	//! (Optional) dependency function
-	//! Sets up which catalog entries this table function depend on
-	table_function_dependency_t dependency;
-	//! (Optional) cardinality function
-	//! Returns the expected cardinality of this scan
-	table_function_cardinality_t cardinality;
-	//! (Optional) pushdown a set of arbitrary filter expressions, rather than only simple comparisons with a constant
-	//! Any functions remaining in the expression list will be pushed as a regular filter after the scan
-	table_function_pushdown_complex_filter_t pushdown_complex_filter;
-	//! (Optional) function for rendering the operator to a string in profiling output
-	table_function_to_string_t to_string;
-	//! (Optional) return how much of the table we have scanned up to this point (% of the data)
-	table_function_progress_t table_scan_progress;
-	//! (Optional) returns the partition info of the current scan operator
-	table_function_get_partition_data_t get_partition_data;
-	//! (Optional) returns extra bind info
-	table_function_get_bind_info_t get_bind_info;
-	//! (Optional) pushes down type information to scanner, returns true if pushdown was successful
-	table_function_type_pushdown_t type_pushdown;
-	//! (Optional) allows injecting a custom MultiFileReader implementation
-	table_function_get_multi_file_reader_t get_multi_file_reader;
-	//! (Optional) If this scanner supports filter pushdown, but not to all data types
-	table_function_supports_pushdown_type_t supports_pushdown_type;
-	//! Get partition info of the table
-	table_function_get_partition_info_t get_partition_info;
-	//! (Optional) get a list of all the partition stats of the table
-	table_function_get_partition_stats_t get_partition_stats;
-
-	table_function_serialize_t serialize;
-	table_function_deserialize_t deserialize;
-	bool verify_serialization = true;
-
-	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added
-	//! that filters out unused columns.
-	bool projection_pushdown;
-	//! Whether or not the table function supports filter pushdown. If not supported a filter will be added
-	//! that applies the table filter directly.
-	bool filter_pushdown;
-	//! Whether or not the table function can immediately prune out filter columns that are unused in the remainder of
-	//! the query plan, e.g., "SELECT i FROM tbl WHERE j = 42;" - j does not need to leave the table function at all
-	bool filter_prune;
-	//! Whether or not the table function supports sampling pushdown. If not supported a sample will be taken after the
-	//! table function.
-	bool sampling_pushdown;
-	//! Additional function info, passed to the bind
-	shared_ptr<TableFunctionInfo> function_info;
-
-	//! When to call init_global
-	//! By default init_global is called when the pipeline is ready for execution
-	//! If this is set to `INITIALIZE_ON_SCHEDULE` the table function is initialized when the query is scheduled
-	TableFunctionInitialization global_initialization = TableFunctionInitialization::INITIALIZE_ON_EXECUTE;
-
-	DUCKDB_API bool Equal(const TableFunction &rhs) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/table_macro_function.hpp b/src/duckdb/src/include/duckdb/function/table_macro_function.hpp
deleted file mode 100644
index 779d40ef6..000000000
--- a/src/duckdb/src/include/duckdb/function/table_macro_function.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/macro_function.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-class TableMacroFunction : public MacroFunction {
-public:
-	static constexpr const MacroType TYPE = MacroType::TABLE_MACRO;
-
-public:
-	explicit TableMacroFunction(unique_ptr<QueryNode> query_node);
-	TableMacroFunction(void);
-
-	//! The main query node
-	unique_ptr<QueryNode> query_node;
-
-public:
-	unique_ptr<MacroFunction> Copy() const override;
-
-	string ToSQL() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/to_interval.hpp b/src/duckdb/src/include/duckdb/function/to_interval.hpp
deleted file mode 100644
index 3ef1e82c1..000000000
--- a/src/duckdb/src/include/duckdb/function/to_interval.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/to_interval.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-
-namespace duckdb {
-
-struct ToSecondsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<TA, int64_t, int64_t>(input, Interval::MICROS_PER_SEC, result.micros)) {
-			throw OutOfRangeException("Interval value %s seconds out of range", NumericHelper::ToString(input));
-		}
-		return result;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/udf_function.hpp b/src/duckdb/src/include/duckdb/function/udf_function.hpp
deleted file mode 100644
index 571a49af4..000000000
--- a/src/duckdb/src/include/duckdb/function/udf_function.hpp
+++ /dev/null
@@ -1,385 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/udf_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-
-namespace duckdb {
-
-// NOLINTBEGIN
-
-struct UDFWrapper {
-public:
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateScalarFunction(const string &name, TR (*udf_func)(ARGS...)) {
-		const std::size_t num_template_argc = sizeof...(ARGS);
-		switch (num_template_argc) {
-		case 1:
-			return CreateUnaryFunction<TR, ARGS...>(name, udf_func);
-		case 2:
-			return CreateBinaryFunction<TR, ARGS...>(name, udf_func);
-		case 3:
-			return CreateTernaryFunction<TR, ARGS...>(name, udf_func);
-		default: // LCOV_EXCL_START
-			throw std::runtime_error("UDF function only supported until ternary!");
-		} // LCOV_EXCL_STOP
-	}
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateScalarFunction(const string &name, const vector<LogicalType> &args,
-	                                                     const LogicalType &ret_type, TR (*udf_func)(ARGS...)) {
-		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("Return type doesn't match with the first template type.");
-		} // LCOV_EXCL_STOP
-
-		const std::size_t num_template_types = sizeof...(ARGS);
-		if (num_template_types != args.size()) { // LCOV_EXCL_START
-			throw std::runtime_error(
-			    "The number of templated types should be the same quantity of the LogicalType arguments.");
-		} // LCOV_EXCL_STOP
-
-		switch (num_template_types) {
-		case 1:
-			return CreateUnaryFunction<TR, ARGS...>(name, args, ret_type, udf_func);
-		case 2:
-			return CreateBinaryFunction<TR, ARGS...>(name, args, ret_type, udf_func);
-		case 3:
-			return CreateTernaryFunction<TR, ARGS...>(name, args, ret_type, udf_func);
-		default: // LCOV_EXCL_START
-			throw std::runtime_error("UDF function only supported until ternary!");
-		} // LCOV_EXCL_STOP
-	}
-
-	template <typename TR, typename... ARGS>
-	inline static void RegisterFunction(const string &name, scalar_function_t udf_function, ClientContext &context,
-	                                    LogicalType varargs = LogicalType(LogicalTypeId::INVALID)) {
-		vector<LogicalType> arguments;
-		GetArgumentTypesRecursive<ARGS...>(arguments);
-
-		LogicalType ret_type = GetArgumentType<TR>();
-
-		RegisterFunction(name, arguments, ret_type, std::move(udf_function), context, std::move(varargs));
-	}
-
-	static void RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
-	                             scalar_function_t udf_function, ClientContext &context,
-	                             LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-
-	//--------------------------------- Aggregate UDFs ------------------------------------//
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	inline static AggregateFunction CreateAggregateFunction(const string &name) {
-		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	inline static AggregateFunction CreateAggregateFunction(const string &name) {
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	inline static AggregateFunction CreateAggregateFunction(const string &name, const LogicalType &ret_type,
-	                                                        const LogicalType &input_type) {
-		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("The return argument don't match!");
-		} // LCOV_EXCL_STOP
-
-		if (!TypesMatch<TA>(input_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("The input argument don't match!");
-		} // LCOV_EXCL_STOP
-
-		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name, ret_type, input_type);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	inline static AggregateFunction CreateAggregateFunction(const string &name, const LogicalType &ret_type,
-	                                                        const LogicalType &input_type_a,
-	                                                        const LogicalType &input_type_b) {
-		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("The return argument don't match!");
-		}
-
-		if (!TypesMatch<TA>(input_type_a)) {
-			throw std::runtime_error("The first input argument don't match!");
-		}
-
-		if (!TypesMatch<TB>(input_type_b)) {
-			throw std::runtime_error("The second input argument don't match!");
-		} // LCOV_EXCL_STOP
-
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_type_a, input_type_b);
-	}
-
-	//! A generic CreateAggregateFunction ---------------------------------------------------------------------------//
-	inline static AggregateFunction
-	CreateAggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
-	                        aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,
-	                        aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                        aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
-	                        aggregate_destructor_t destructor = nullptr) {
-
-		AggregateFunction aggr_function(name, arguments, return_type, state_size, initialize, update, combine, finalize,
-		                                simple_update, bind, destructor);
-		aggr_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-		return aggr_function;
-	}
-
-	static void RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context,
-	                                 LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-
-private:
-	//-------------------------------- Templated functions --------------------------------//
-	struct UnaryUDFExecutor {
-		template <class INPUT_TYPE, class RESULT_TYPE>
-		static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-			typedef RESULT_TYPE (*unary_function_t)(INPUT_TYPE);
-			auto udf = (unary_function_t)dataptr;
-			return udf(input);
-		}
-	};
-
-	template <typename TR, typename TA>
-	inline static scalar_function_t CreateUnaryFunction(const string &name, TR (*udf_func)(TA)) {
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			UnaryExecutor::GenericExecute<TA, TR, UnaryUDFExecutor>(input.data[0], result, input.size(),
-			                                                        (void *)udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename TA, typename TB>
-	inline static scalar_function_t CreateBinaryFunction(const string &name, TR (*udf_func)(TA, TB)) {
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			BinaryExecutor::Execute<TA, TB, TR>(input.data[0], input.data[1], result, input.size(), udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename TA, typename TB, typename TC>
-	inline static scalar_function_t CreateTernaryFunction(const string &name, TR (*udf_func)(TA, TB, TC)) {
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			TernaryExecutor::Execute<TA, TB, TC, TR>(input.data[0], input.data[1], input.data[2], result, input.size(),
-			                                         udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateUnaryFunction(const string &name,
-	                                                    TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for unary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateBinaryFunction(const string &name,
-	                                                     TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for binary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateTernaryFunction(const string &name,
-	                                                      TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for ternary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename T>
-	inline static LogicalType GetArgumentType() {
-		if (std::is_same<T, bool>()) {
-			return LogicalType(LogicalTypeId::BOOLEAN);
-		} else if (std::is_same<T, int8_t>()) {
-			return LogicalType(LogicalTypeId::TINYINT);
-		} else if (std::is_same<T, int16_t>()) {
-			return LogicalType(LogicalTypeId::SMALLINT);
-		} else if (std::is_same<T, int32_t>()) {
-			return LogicalType(LogicalTypeId::INTEGER);
-		} else if (std::is_same<T, int64_t>()) {
-			return LogicalType(LogicalTypeId::BIGINT);
-		} else if (std::is_same<T, float>()) {
-			return LogicalType(LogicalTypeId::FLOAT);
-		} else if (std::is_same<T, double>()) {
-			return LogicalType(LogicalTypeId::DOUBLE);
-		} else if (std::is_same<T, string_t>()) {
-			return LogicalType(LogicalTypeId::VARCHAR);
-		} else { // LCOV_EXCL_START
-			throw std::runtime_error("Unrecognized type!");
-		} // LCOV_EXCL_STOP
-	}
-
-	template <typename TA, typename TB, typename... ARGS>
-	inline static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
-		arguments.push_back(GetArgumentType<TA>());
-		GetArgumentTypesRecursive<TB, ARGS...>(arguments);
-	}
-
-	template <typename TA>
-	inline static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
-		arguments.push_back(GetArgumentType<TA>());
-	}
-
-private:
-	//-------------------------------- Argumented functions --------------------------------//
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateUnaryFunction(const string &name, const vector<LogicalType> &args,
-	                                                    const LogicalType &ret_type,
-	                                                    TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for unary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename TA>
-	inline static scalar_function_t CreateUnaryFunction(const string &name, const vector<LogicalType> &args,
-	                                                    const LogicalType &ret_type, TR (*udf_func)(TA)) {
-		if (args.size() != 1) { // LCOV_EXCL_START
-			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 1!");
-		}
-		if (!TypesMatch<TA>(args[0])) {
-			throw std::runtime_error("The first arguments don't match!");
-		} // LCOV_EXCL_STOP
-
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			UnaryExecutor::GenericExecute<TA, TR, UnaryUDFExecutor>(input.data[0], result, input.size(),
-			                                                        (void *)udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateBinaryFunction(const string &name, const vector<LogicalType> &args,
-	                                                     const LogicalType &ret_type,
-	                                                     TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for binary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename TA, typename TB>
-	inline static scalar_function_t CreateBinaryFunction(const string &name, const vector<LogicalType> &args,
-	                                                     const LogicalType &ret_type, TR (*udf_func)(TA, TB)) {
-		if (args.size() != 2) { // LCOV_EXCL_START
-			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 2!");
-		}
-		if (!TypesMatch<TA>(args[0])) {
-			throw std::runtime_error("The first arguments don't match!");
-		}
-		if (!TypesMatch<TB>(args[1])) {
-			throw std::runtime_error("The second arguments don't match!");
-		} // LCOV_EXCL_STOP
-
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) {
-			BinaryExecutor::Execute<TA, TB, TR>(input.data[0], input.data[1], result, input.size(), udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename... ARGS>
-	inline static scalar_function_t CreateTernaryFunction(const string &name, const vector<LogicalType> &args,
-	                                                      const LogicalType &ret_type,
-	                                                      TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for ternary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename TA, typename TB, typename TC>
-	inline static scalar_function_t CreateTernaryFunction(const string &name, const vector<LogicalType> &args,
-	                                                      const LogicalType &ret_type, TR (*udf_func)(TA, TB, TC)) {
-		if (args.size() != 3) { // LCOV_EXCL_START
-			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 3!");
-		}
-		if (!TypesMatch<TA>(args[0])) {
-			throw std::runtime_error("The first arguments don't match!");
-		}
-		if (!TypesMatch<TB>(args[1])) {
-			throw std::runtime_error("The second arguments don't match!");
-		}
-		if (!TypesMatch<TC>(args[2])) {
-			throw std::runtime_error("The second arguments don't match!");
-		} // LCOV_EXCL_STOP
-
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			TernaryExecutor::Execute<TA, TB, TC, TR>(input.data[0], input.data[1], input.data[2], result, input.size(),
-			                                         udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename T>
-	inline static bool TypesMatch(const LogicalType &sql_type) {
-		switch (sql_type.id()) {
-		case LogicalTypeId::BOOLEAN:
-			return std::is_same<T, bool>();
-		case LogicalTypeId::TINYINT:
-			return std::is_same<T, int8_t>();
-		case LogicalTypeId::SMALLINT:
-			return std::is_same<T, int16_t>();
-		case LogicalTypeId::INTEGER:
-			return std::is_same<T, int32_t>();
-		case LogicalTypeId::BIGINT:
-			return std::is_same<T, int64_t>();
-		case LogicalTypeId::DATE:
-			return std::is_same<T, date_t>();
-		case LogicalTypeId::TIME:
-			return std::is_same<T, dtime_t>();
-		case LogicalTypeId::TIME_TZ:
-			return std::is_same<T, dtime_tz_t>();
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return std::is_same<T, timestamp_t>();
-		case LogicalTypeId::FLOAT:
-			return std::is_same<T, float>();
-		case LogicalTypeId::DOUBLE:
-			return std::is_same<T, double>();
-		case LogicalTypeId::VARCHAR:
-		case LogicalTypeId::CHAR:
-		case LogicalTypeId::BLOB:
-			return std::is_same<T, string_t>();
-		default: // LCOV_EXCL_START
-			throw std::runtime_error("Type is not supported!");
-		} // LCOV_EXCL_STOP
-	}
-
-private:
-	//-------------------------------- Aggregate functions --------------------------------//
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	inline static AggregateFunction CreateUnaryAggregateFunction(const string &name) {
-		LogicalType return_type = GetArgumentType<TR>();
-		LogicalType input_type = GetArgumentType<TA>();
-		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name, return_type, input_type);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	inline static AggregateFunction CreateUnaryAggregateFunction(const string &name, const LogicalType &ret_type,
-	                                                             const LogicalType &input_type) {
-		AggregateFunction aggr_function =
-		    AggregateFunction::UnaryAggregate<STATE, TR, TA, UDF_OP>(input_type, ret_type);
-		aggr_function.name = name;
-		return aggr_function;
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name) {
-		LogicalType return_type = GetArgumentType<TR>();
-		LogicalType input_type_a = GetArgumentType<TA>();
-		LogicalType input_type_b = GetArgumentType<TB>();
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, return_type, input_type_a, input_type_b);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name, const LogicalType &ret_type,
-	                                                              const LogicalType &input_type_a,
-	                                                              const LogicalType &input_type_b) {
-		AggregateFunction aggr_function =
-		    AggregateFunction::BinaryAggregate<STATE, TA, TB, TR, UDF_OP>(input_type_a, input_type_b, ret_type);
-		aggr_function.name = name;
-		return aggr_function;
-	}
-}; // end UDFWrapper
-
-// NOLINTEND
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp
deleted file mode 100644
index efc782b8c..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_aggregate_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_executor.hpp"
-#include "duckdb/common/enums/window_aggregation_mode.hpp"
-#include "duckdb/function/window/window_aggregator.hpp"
-
-namespace duckdb {
-
-class WindowAggregateExecutor : public WindowExecutor {
-public:
-	WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared,
-	                        WindowAggregationMode mode);
-
-	void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx, WindowExecutorGlobalState &gstate,
-	          WindowExecutorLocalState &lstate) const override;
-	void Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-	              CollectionPtr collection) const override;
-
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
-
-	const WindowAggregationMode mode;
-
-	// aggregate computation algorithm
-	unique_ptr<WindowAggregator> aggregator;
-
-	// FILTER reference expression in sink_chunk
-	unique_ptr<Expression> filter_ref;
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_aggregate_states.hpp b/src/duckdb/src/include/duckdb/function/window/window_aggregate_states.hpp
deleted file mode 100644
index 1382a522c..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_aggregate_states.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_aggregate_states.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-
-namespace duckdb {
-
-struct WindowAggregateStates {
-	explicit WindowAggregateStates(const AggregateObject &aggr);
-	~WindowAggregateStates() {
-		Destroy();
-	}
-
-	//! The number of states
-	idx_t GetCount() const {
-		return states.size() / state_size;
-	}
-	data_ptr_t *GetData() {
-		return FlatVector::GetData<data_ptr_t>(*statef);
-	}
-	data_ptr_t GetStatePtr(idx_t idx) {
-		return states.data() + idx * state_size;
-	}
-	const_data_ptr_t GetStatePtr(idx_t idx) const {
-		return states.data() + idx * state_size;
-	}
-	//! Initialise all the states
-	void Initialize(idx_t count);
-	//! Combine the states into the target
-	void Combine(WindowAggregateStates &target,
-	             AggregateCombineType combine_type = AggregateCombineType::PRESERVE_INPUT);
-	//! Finalize the states into an output vector
-	void Finalize(Vector &result);
-	//! Destroy the states
-	void Destroy();
-
-	//! A description of the aggregator
-	const AggregateObject aggr;
-	//! The size of each state
-	const idx_t state_size;
-	//! The allocator to use
-	ArenaAllocator allocator;
-	//! Data pointer that contains the state data
-	vector<data_t> states;
-	//! Reused result state container for the window functions
-	unique_ptr<Vector> statef;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp
deleted file mode 100644
index 1caa6326d..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_aggregator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
-#include "duckdb/function/window/window_boundaries_state.hpp"
-
-namespace duckdb {
-
-class WindowCollection;
-class WindowCursor;
-struct WindowSharedExpressions;
-
-class WindowAggregatorState {
-public:
-	WindowAggregatorState();
-	virtual ~WindowAggregatorState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-	//! Allocator for aggregates
-	ArenaAllocator allocator;
-};
-
-class WindowAggregator {
-public:
-	using CollectionPtr = optional_ptr<WindowCollection>;
-
-	template <typename OP>
-	static void EvaluateSubFrames(const DataChunk &bounds, const WindowExcludeMode exclude_mode, idx_t count,
-	                              idx_t row_idx, SubFrames &frames, OP operation) {
-		auto begins = FlatVector::GetData<const idx_t>(bounds.data[FRAME_BEGIN]);
-		auto ends = FlatVector::GetData<const idx_t>(bounds.data[FRAME_END]);
-		auto peer_begin = FlatVector::GetData<const idx_t>(bounds.data[PEER_BEGIN]);
-		auto peer_end = FlatVector::GetData<const idx_t>(bounds.data[PEER_END]);
-
-		for (idx_t i = 0, cur_row = row_idx; i < count; ++i, ++cur_row) {
-			idx_t nframes = 0;
-			if (exclude_mode == WindowExcludeMode::NO_OTHER) {
-				auto begin = begins[i];
-				auto end = ends[i];
-				frames[nframes++] = FrameBounds(begin, end);
-			} else {
-				//	The frame_exclusion option allows rows around the current row to be excluded from the frame,
-				//	even if they would be included according to the frame start and frame end options.
-				//	EXCLUDE CURRENT ROW excludes the current row from the frame.
-				//	EXCLUDE GROUP excludes the current row and its ordering peers from the frame.
-				//	EXCLUDE TIES excludes any peers of the current row from the frame, but not the current row itself.
-				//	EXCLUDE NO OTHERS simply specifies explicitly the default behavior
-				//	of not excluding the current row or its peers.
-				//	https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-WINDOW-FUNCTIONS
-				//
-				//	For the sake of the client, we make some guarantees about the subframes:
-				//	* They are in order left-to-right
-				//	* They do not intersect
-				//	* start <= end
-				//	* The number is always the same
-				//
-				//	Since we always have peer_begin <= cur_row < cur_row + 1 <= peer_end
-				//	this is not too hard to arrange, but it may be that some subframes are contiguous,
-				//	and some are empty.
-
-				//	WindowExcludePart::LEFT
-				const auto frame_begin = begins[i];
-				const auto frame_end = ends[i];
-				auto begin = frame_begin;
-				auto end = (exclude_mode == WindowExcludeMode::CURRENT_ROW) ? cur_row : peer_begin[i];
-				end = MinValue(end, frame_end);
-				end = MaxValue(end, frame_begin);
-				frames[nframes++] = FrameBounds(begin, end);
-
-				// with EXCLUDE TIES, in addition to the frame part right of the peer group's end,
-				// we also need to consider the current row
-				if (exclude_mode == WindowExcludeMode::TIES) {
-					begin = MinValue(MaxValue(cur_row, frame_begin), frame_end);
-					end = MaxValue(MinValue(cur_row + 1, frame_end), frame_begin);
-					frames[nframes++] = FrameBounds(begin, end);
-				}
-
-				//	WindowExcludePart::RIGHT
-				end = frame_end;
-				begin = (exclude_mode == WindowExcludeMode::CURRENT_ROW) ? (cur_row + 1) : peer_end[i];
-				begin = MaxValue(begin, frame_begin);
-				begin = MinValue(begin, frame_end);
-				frames[nframes++] = FrameBounds(begin, end);
-			}
-
-			operation(i);
-		}
-	}
-
-	explicit WindowAggregator(const BoundWindowExpression &wexpr);
-	WindowAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
-	virtual ~WindowAggregator();
-
-	//	Threading states
-	virtual unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                         const ValidityMask &partition_mask) const;
-	virtual unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const = 0;
-
-	//	Build
-	virtual void Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-	                  DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered);
-	virtual void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	                      const FrameStats &stats);
-
-	//	Probe
-	virtual void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	                      Vector &result, idx_t count, idx_t row_idx) const = 0;
-
-	//! The window function
-	const BoundWindowExpression &wexpr;
-	//! A description of the aggregator
-	const AggregateObject aggr;
-	//! The argument types for the function
-	vector<LogicalType> arg_types;
-	//! The result type of the window function
-	const LogicalType result_type;
-	//! The size of a single aggregate state
-	const idx_t state_size;
-	//! The window exclusion clause
-	const WindowExcludeMode exclude_mode;
-	//! Partition collection column indicies
-	vector<column_t> child_idx;
-};
-
-class WindowAggregatorGlobalState : public WindowAggregatorState {
-public:
-	WindowAggregatorGlobalState(ClientContext &context, const WindowAggregator &aggregator_p, idx_t group_count)
-	    : context(context), aggregator(aggregator_p), aggr(aggregator.wexpr), locals(0), finalized(0) {
-
-		if (aggr.filter) {
-			// 	Start with all invalid and set the ones that pass
-			filter_mask.Initialize(group_count, false);
-		} else {
-			filter_mask.InitializeEmpty(group_count);
-		}
-	}
-
-	//! The context we are in
-	ClientContext &context;
-
-	//! The aggregator data
-	const WindowAggregator &aggregator;
-
-	//! The aggregate function
-	const AggregateObject aggr;
-
-	//! The filtered rows in inputs.
-	ValidityArray filter_mask;
-
-	//! Lock for single threading
-	mutable mutex lock;
-
-	//! Count of local tasks
-	mutable std::atomic<idx_t> locals;
-
-	//! Number of finalised states
-	std::atomic<idx_t> finalized;
-};
-
-class WindowAggregatorLocalState : public WindowAggregatorState {
-public:
-	using CollectionPtr = optional_ptr<WindowCollection>;
-
-	static void InitSubFrames(SubFrames &frames, const WindowExcludeMode exclude_mode);
-
-	WindowAggregatorLocalState() {
-	}
-
-	void Sink(WindowAggregatorGlobalState &gastate, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t row_idx);
-	virtual void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection);
-
-	//! The state used for reading the collection
-	unique_ptr<WindowCursor> cursor;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp b/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp
deleted file mode 100644
index 35e0fdb68..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp
+++ /dev/null
@@ -1,153 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_boundaries_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/window/window_collection.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/common/vector_operations/aggregate_executor.hpp"
-
-namespace duckdb {
-
-class BoundWindowExpression;
-
-//	Column indexes of the bounds chunk
-enum WindowBounds : uint8_t {
-	PARTITION_BEGIN,
-	PARTITION_END,
-	PEER_BEGIN,
-	PEER_END,
-	VALID_BEGIN,
-	VALID_END,
-	FRAME_BEGIN,
-	FRAME_END
-};
-
-// C++ 11 won't do this automatically...
-struct WindowBoundsHash {
-	inline uint64_t operator()(const WindowBounds &value) const {
-		return value;
-	}
-};
-
-using WindowBoundsSet = unordered_set<WindowBounds, WindowBoundsHash>;
-
-struct WindowInputExpression {
-	WindowInputExpression(DataChunk &chunk, column_t col_idx)
-	    : ptype(PhysicalType::INVALID), scalar(true), chunk(chunk), col_idx(col_idx) {
-		if (col_idx < chunk.data.size()) {
-			auto &col = chunk.data[col_idx];
-			ptype = col.GetType().InternalType();
-			scalar = (col.GetVectorType() == VectorType::CONSTANT_VECTOR);
-			if (!scalar && col.GetVectorType() != VectorType::FLAT_VECTOR) {
-				col.Flatten(chunk.size());
-			}
-		}
-	}
-
-	inline PhysicalType InternalType() const {
-		return ptype;
-	}
-
-	template <typename T>
-	inline T GetCell(idx_t i) const {
-		D_ASSERT(!chunk.data.empty());
-		const auto data = FlatVector::GetData<T>(chunk.data[col_idx]);
-		return data[scalar ? 0 : i];
-	}
-
-	inline bool CellIsNull(idx_t i) const {
-		D_ASSERT(!chunk.data.empty());
-		auto &col = chunk.data[col_idx];
-
-		if (scalar) {
-			return ConstantVector::IsNull(col);
-		}
-		return FlatVector::IsNull(col, i);
-	}
-
-	inline void CopyCell(Vector &target, idx_t target_offset, idx_t width = 1) const {
-		D_ASSERT(!chunk.data.empty());
-		auto &source = chunk.data[col_idx];
-		auto source_offset = scalar ? 0 : target_offset;
-		VectorOperations::Copy(source, target, source_offset + width, source_offset, target_offset);
-	}
-
-private:
-	PhysicalType ptype;
-	bool scalar;
-	DataChunk &chunk;
-	const column_t col_idx;
-};
-
-struct WindowBoundariesState {
-
-	static bool HasPrecedingRange(const BoundWindowExpression &wexpr);
-	static bool HasFollowingRange(const BoundWindowExpression &wexpr);
-	static WindowBoundsSet GetWindowBounds(const BoundWindowExpression &wexpr);
-	static idx_t FindNextStart(const ValidityMask &mask, idx_t l, const idx_t r, idx_t &n);
-	static idx_t FindPrevStart(const ValidityMask &mask, const idx_t l, idx_t r, idx_t &n);
-
-	WindowBoundariesState(const BoundWindowExpression &wexpr, const idx_t input_size);
-
-	// Generate the partition start indices
-	void PartitionBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-	                    const ValidityMask &partition_mask);
-	void PartitionEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-	                  const ValidityMask &partition_mask);
-	void PeerBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-	               const ValidityMask &partition_mask, const ValidityMask &order_mask);
-	void PeerEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, const ValidityMask &partition_mask,
-	             const ValidityMask &order_mask);
-	void ValidBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump,
-	                const ValidityMask &partition_mask, const ValidityMask &order_mask,
-	                optional_ptr<WindowCursor> range);
-	void ValidEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump, const ValidityMask &partition_mask,
-	              const ValidityMask &order_mask, optional_ptr<WindowCursor> range);
-	void FrameBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, WindowInputExpression &boundary_begin,
-	                optional_ptr<WindowCursor> range);
-	void FrameEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, WindowInputExpression &boundary_end,
-	              optional_ptr<WindowCursor> range);
-
-	static void ClampFrame(const idx_t count, idx_t *values, const idx_t *begin, const idx_t *end) {
-		for (idx_t i = 0; i < count; ++i) {
-			values[i] = MinValue(MaxValue(values[i], begin[i]), end[i]);
-		}
-	}
-
-	void Bounds(DataChunk &bounds, idx_t row_idx, optional_ptr<WindowCursor> range, const idx_t count,
-	            WindowInputExpression &boundary_start, WindowInputExpression &boundary_end,
-	            const ValidityMask &partition_mask, const ValidityMask &order_mask);
-
-	// Cached lookups
-	WindowBoundsSet required;
-	const ExpressionType type;
-	const idx_t input_size;
-	const WindowBoundary start_boundary;
-	const WindowBoundary end_boundary;
-	const size_t partition_count;
-	const size_t order_count;
-	const OrderType range_sense;
-	const bool has_preceding_range;
-	const bool has_following_range;
-
-	// Carried between chunks
-	idx_t next_pos = 0;
-	idx_t partition_start = 0;
-	idx_t partition_end = 0;
-	idx_t peer_start = 0;
-	idx_t valid_start = 0;
-	idx_t valid_end = 0;
-
-	FrameBounds prev;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_collection.hpp b/src/duckdb/src/include/duckdb/function/window/window_collection.hpp
deleted file mode 100644
index d946a1d79..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_collection.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-namespace duckdb {
-
-// A wrapper for building ColumnDataCollections in parallel
-class WindowCollection {
-public:
-	using ColumnDataCollectionPtr = unique_ptr<ColumnDataCollection>;
-	using ColumnDataCollectionSpec = pair<idx_t, optional_ptr<ColumnDataCollection>>;
-	using ColumnSet = unordered_set<column_t>;
-
-	WindowCollection(BufferManager &buffer_manager, idx_t count, const vector<LogicalType> &types);
-
-	idx_t ColumnCount() const {
-		return types.size();
-	}
-
-	idx_t size() const { // NOLINT
-		return count;
-	}
-
-	const vector<LogicalType> &GetTypes() const {
-		return types;
-	}
-
-	//! Update a thread-local collection for appending data to a given row
-	void GetCollection(idx_t row_idx, ColumnDataCollectionSpec &spec);
-	//! Single-threaded, idempotent ordered combining of all the appended data.
-	void Combine(const ColumnSet &build_validity);
-
-	//! The collection data. May be null if the column count is 0.
-	ColumnDataCollectionPtr inputs;
-	//! Global validity mask
-	vector<atomic<bool>> all_valids;
-	//! Optional validity mask for the entire collection
-	vector<ValidityMask> validities;
-
-	//! The collection columns
-	const vector<LogicalType> types;
-	//! The collection rows
-	const idx_t count;
-
-	//! Guard for range updates
-	mutex lock;
-	//! The paging buffer manager to use
-	BufferManager &buffer_manager;
-	//! The component column data collections
-	vector<ColumnDataCollectionPtr> collections;
-	//! The (sorted) collection ranges
-	using Range = pair<idx_t, idx_t>;
-	vector<Range> ranges;
-};
-
-class WindowBuilder {
-public:
-	explicit WindowBuilder(WindowCollection &collection);
-
-	//! Add a new chunk at the given index
-	void Sink(DataChunk &chunk, idx_t input_idx);
-
-	//! The collection we are helping to build
-	WindowCollection &collection;
-	//! The thread's current input collection
-	using ColumnDataCollectionSpec = WindowCollection::ColumnDataCollectionSpec;
-	ColumnDataCollectionSpec sink;
-	//! The state used for appending to the collection
-	ColumnDataAppendState appender;
-	//! Are all the sunk rows valid?
-	bool all_valid = true;
-};
-
-class WindowCursor {
-public:
-	WindowCursor(const WindowCollection &paged, column_t col_idx);
-	WindowCursor(const WindowCollection &paged, vector<column_t> column_ids);
-
-	//! Is the scan in range?
-	inline bool RowIsVisible(idx_t row_idx) const {
-		return (row_idx < state.next_row_index && state.current_row_index <= row_idx);
-	}
-	//! The offset of the row in the given state
-	inline sel_t RowOffset(idx_t row_idx) const {
-		D_ASSERT(RowIsVisible(row_idx));
-		return UnsafeNumericCast<sel_t>(row_idx - state.current_row_index);
-	}
-	//! Scan the next chunk
-	inline bool Scan() {
-		return paged.inputs->Scan(state, chunk);
-	}
-	//! Seek to the given row
-	inline idx_t Seek(idx_t row_idx) {
-		if (!RowIsVisible(row_idx)) {
-			D_ASSERT(paged.inputs.get());
-			paged.inputs->Seek(row_idx, state, chunk);
-		}
-		return RowOffset(row_idx);
-	}
-	//! Check a collection cell for nullity
-	bool CellIsNull(idx_t col_idx, idx_t row_idx) {
-		D_ASSERT(chunk.ColumnCount() > col_idx);
-		auto index = Seek(row_idx);
-		auto &source = chunk.data[col_idx];
-		return FlatVector::IsNull(source, index);
-	}
-	//! Read a typed cell
-	template <typename T>
-	T GetCell(idx_t col_idx, idx_t row_idx) {
-		D_ASSERT(chunk.ColumnCount() > col_idx);
-		auto index = Seek(row_idx);
-		auto &source = chunk.data[col_idx];
-		const auto data = FlatVector::GetData<T>(source);
-		return data[index];
-	}
-	//! Copy a single value
-	void CopyCell(idx_t col_idx, idx_t row_idx, Vector &target, idx_t target_offset) {
-		D_ASSERT(chunk.ColumnCount() > col_idx);
-		auto index = Seek(row_idx);
-		auto &source = chunk.data[col_idx];
-		VectorOperations::Copy(source, target, index + 1, index, target_offset);
-	}
-
-	unique_ptr<WindowCursor> Copy() const {
-		return make_uniq<WindowCursor>(paged, state.column_ids);
-	}
-
-	//! The pageable data
-	const WindowCollection &paged;
-	//! The state used for reading the collection
-	ColumnDataScanState state;
-	//! The data chunk read into
-	DataChunk chunk;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp
deleted file mode 100644
index c3ca63f36..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_constant_aggregator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_aggregator.hpp"
-
-namespace duckdb {
-
-class WindowConstantAggregator : public WindowAggregator {
-public:
-	static bool CanAggregate(const BoundWindowExpression &wexpr);
-
-	static BoundWindowExpression &RebindAggregate(ClientContext &context, BoundWindowExpression &wexpr);
-
-	WindowConstantAggregator(BoundWindowExpression &wexpr, WindowSharedExpressions &shared, ClientContext &context);
-	~WindowConstantAggregator() override {
-	}
-
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	void Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-	          DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-	          idx_t filtered) override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp
deleted file mode 100644
index ab664ca59..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_custom_aggregator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_aggregator.hpp"
-
-namespace duckdb {
-
-class WindowCustomAggregator : public WindowAggregator {
-public:
-	static bool CanAggregate(const BoundWindowExpression &wexpr, WindowAggregationMode mode);
-
-	WindowCustomAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
-	~WindowCustomAggregator() override;
-
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp
deleted file mode 100644
index 7fe9040c0..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_distinct_aggregator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_aggregator.hpp"
-
-namespace duckdb {
-
-class WindowDistinctAggregator : public WindowAggregator {
-public:
-	static bool CanAggregate(const BoundWindowExpression &wexpr);
-
-	WindowDistinctAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared,
-	                         ClientContext &context);
-
-	//	Build
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	void Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered) override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	//	Evaluate
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
-
-	//! Context for sorting
-	ClientContext &context;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_executor.hpp b/src/duckdb/src/include/duckdb/function/window/window_executor.hpp
deleted file mode 100644
index 44d3a9050..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_executor.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_boundaries_state.hpp"
-#include "duckdb/function/window/window_collection.hpp"
-
-namespace duckdb {
-
-class WindowCollection;
-
-struct WindowSharedExpressions;
-
-class WindowExecutorState {
-public:
-	WindowExecutorState() {};
-	virtual ~WindowExecutorState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class WindowExecutor;
-
-class WindowExecutorGlobalState : public WindowExecutorState {
-public:
-	using CollectionPtr = optional_ptr<WindowCollection>;
-
-	WindowExecutorGlobalState(const WindowExecutor &executor, const idx_t payload_count,
-	                          const ValidityMask &partition_mask, const ValidityMask &order_mask);
-
-	const WindowExecutor &executor;
-
-	const idx_t payload_count;
-	const ValidityMask &partition_mask;
-	const ValidityMask &order_mask;
-	vector<LogicalType> arg_types;
-};
-
-class WindowExecutorLocalState : public WindowExecutorState {
-public:
-	using CollectionPtr = optional_ptr<WindowCollection>;
-
-	explicit WindowExecutorLocalState(const WindowExecutorGlobalState &gstate);
-
-	virtual void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx);
-	virtual void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection);
-
-	//! The state used for reading the range collection
-	unique_ptr<WindowCursor> range_cursor;
-};
-
-class WindowExecutorBoundsState : public WindowExecutorLocalState {
-public:
-	explicit WindowExecutorBoundsState(const WindowExecutorGlobalState &gstate);
-	~WindowExecutorBoundsState() override {
-	}
-
-	virtual void UpdateBounds(WindowExecutorGlobalState &gstate, idx_t row_idx, DataChunk &eval_chunk,
-	                          optional_ptr<WindowCursor> range);
-
-	// Frame management
-	const ValidityMask &partition_mask;
-	const ValidityMask &order_mask;
-	DataChunk bounds;
-	WindowBoundariesState state;
-};
-
-class WindowExecutor {
-public:
-	using CollectionPtr = optional_ptr<WindowCollection>;
-
-	WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-	virtual ~WindowExecutor() {
-	}
-
-	virtual unique_ptr<WindowExecutorGlobalState>
-	GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask, const ValidityMask &order_mask) const;
-	virtual unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const;
-
-	virtual void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx,
-	                  WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate) const;
-
-	virtual void Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-	                      CollectionPtr collection) const;
-
-	void Evaluate(idx_t row_idx, DataChunk &eval_chunk, Vector &result, WindowExecutorLocalState &lstate,
-	              WindowExecutorGlobalState &gstate) const;
-
-	// The function
-	const BoundWindowExpression &wexpr;
-	ClientContext &context;
-
-	// evaluate frame expressions, if needed
-	column_t boundary_start_idx = DConstants::INVALID_INDEX;
-	column_t boundary_end_idx = DConstants::INVALID_INDEX;
-
-	// evaluate RANGE expressions, if needed
-	optional_ptr<Expression> range_expr;
-	column_t range_idx = DConstants::INVALID_INDEX;
-
-protected:
-	virtual void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-	                              DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_index_tree.hpp b/src/duckdb/src/include/duckdb/function/window/window_index_tree.hpp
deleted file mode 100644
index e9f9f4014..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_index_tree.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_index_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_merge_sort_tree.hpp"
-
-namespace duckdb {
-
-class WindowIndexTree;
-
-class WindowIndexTreeLocalState : public WindowMergeSortTreeLocalState {
-public:
-	explicit WindowIndexTreeLocalState(WindowIndexTree &index_tree);
-
-	//! Process sorted leaf data
-	void BuildLeaves() override;
-
-	//! The index tree we are building
-	WindowIndexTree &index_tree;
-};
-
-class WindowIndexTree : public WindowMergeSortTree {
-public:
-	WindowIndexTree(ClientContext &context, const vector<BoundOrderByNode> &orders, const vector<column_t> &sort_idx,
-	                const idx_t count);
-	WindowIndexTree(ClientContext &context, const BoundOrderModifier &order_bys, const vector<column_t> &sort_idx,
-	                const idx_t count);
-	~WindowIndexTree() override = default;
-
-	unique_ptr<WindowAggregatorState> GetLocalState() override;
-
-	//! Find the Nth index in the set of subframes
-	idx_t SelectNth(const SubFrames &frames, idx_t n) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_merge_sort_tree.hpp b/src/duckdb/src/include/duckdb/function/window/window_merge_sort_tree.hpp
deleted file mode 100644
index 6faecbbf8..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_merge_sort_tree.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_merge_sort_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/merge_sort_tree.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-#include "duckdb/function/window/window_aggregator.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/sort/partition_state.hpp"
-
-namespace duckdb {
-
-class WindowMergeSortTree;
-
-class WindowMergeSortTreeLocalState : public WindowAggregatorState {
-public:
-	explicit WindowMergeSortTreeLocalState(WindowMergeSortTree &index_tree);
-
-	//! Add a chunk to the local sort
-	void SinkChunk(DataChunk &chunk, const idx_t row_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered);
-	//! Sort the data
-	void Sort();
-	//! Process sorted leaf data
-	virtual void BuildLeaves() = 0;
-
-	//! The index tree we are building
-	WindowMergeSortTree &window_tree;
-	//! Thread-local sorting data
-	optional_ptr<LocalSortState> local_sort;
-	//! Buffer for the sort keys
-	DataChunk sort_chunk;
-	//! Buffer for the payload data
-	DataChunk payload_chunk;
-	//! Build stage
-	PartitionSortStage build_stage = PartitionSortStage::INIT;
-	//! Build task number
-	idx_t build_task;
-
-private:
-	void ExecuteSortTask();
-};
-
-class WindowMergeSortTree {
-public:
-	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
-	using LocalSortStatePtr = unique_ptr<LocalSortState>;
-
-	WindowMergeSortTree(ClientContext &context, const vector<BoundOrderByNode> &orders,
-	                    const vector<column_t> &sort_idx, const idx_t count, bool unique = false);
-	virtual ~WindowMergeSortTree() = default;
-
-	virtual unique_ptr<WindowAggregatorState> GetLocalState() = 0;
-
-	//! Make a local sort for a thread
-	optional_ptr<LocalSortState> AddLocalSort();
-
-	//! Thread-safe post-sort cleanup
-	virtual void CleanupSort();
-
-	//! Sort state machine
-	bool TryPrepareSortStage(WindowMergeSortTreeLocalState &lstate);
-	//! Build the MST in parallel from the sorted data
-	void Build();
-
-	//! The query context
-	ClientContext &context;
-	//! Thread memory limit
-	const idx_t memory_per_thread;
-	//! The column indices for sorting
-	const vector<column_t> sort_idx;
-	//! The sorted data
-	GlobalSortStatePtr global_sort;
-	//! Finalize guard
-	mutex lock;
-	//! Local sort set
-	vector<LocalSortStatePtr> local_sorts;
-	//! Finalize stage
-	atomic<PartitionSortStage> build_stage;
-	//! Tasks launched
-	idx_t total_tasks = 0;
-	//! Tasks launched
-	idx_t tasks_assigned = 0;
-	//! Tasks landed
-	atomic<idx_t> tasks_completed;
-	//! The block starts (the scanner doesn't know this) plus the total count
-	vector<idx_t> block_starts;
-
-	// Merge sort trees for various sizes
-	// Smaller is probably not worth the effort.
-	using MergeSortTree32 = MergeSortTree<uint32_t, uint32_t>;
-	using MergeSortTree64 = MergeSortTree<uint64_t, uint64_t>;
-	unique_ptr<MergeSortTree32> mst32;
-	unique_ptr<MergeSortTree64> mst64;
-
-protected:
-	//! Find the starts of all the blocks
-	//! Returns the total number of rows
-	virtual idx_t MeasurePayloadBlocks();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp
deleted file mode 100644
index 1fdf497ee..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_naive_aggregator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_aggregator.hpp"
-
-namespace duckdb {
-
-class WindowAggregateExecutor;
-
-// Used for validation
-class WindowNaiveAggregator : public WindowAggregator {
-public:
-	WindowNaiveAggregator(const WindowAggregateExecutor &executor, WindowSharedExpressions &shared);
-	~WindowNaiveAggregator() override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
-
-	//! The parent executor
-	const WindowAggregateExecutor &executor;
-	//! The column indices of any ORDER BY argument expressions
-	vector<column_t> arg_order_idx;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp
deleted file mode 100644
index 9afb7e970..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_rank_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_executor.hpp"
-
-namespace duckdb {
-
-class WindowPeerExecutor : public WindowExecutor {
-public:
-	WindowPeerExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
-
-	//! The column indices of any ORDER BY argument expressions
-	vector<column_t> arg_order_idx;
-};
-
-class WindowRankExecutor : public WindowPeerExecutor {
-public:
-	WindowRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-class WindowDenseRankExecutor : public WindowPeerExecutor {
-public:
-	WindowDenseRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-class WindowPercentRankExecutor : public WindowPeerExecutor {
-public:
-	WindowPercentRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-class WindowCumeDistExecutor : public WindowPeerExecutor {
-public:
-	WindowCumeDistExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp
deleted file mode 100644
index be9bf4713..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_rownumber_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_executor.hpp"
-
-namespace duckdb {
-
-class WindowRowNumberExecutor : public WindowExecutor {
-public:
-	WindowRowNumberExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
-
-	//! The evaluation index of the NTILE column
-	column_t ntile_idx = DConstants::INVALID_INDEX;
-	//! The column indices of any ORDER BY argument expressions
-	vector<column_t> arg_order_idx;
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-// NTILE is just scaled ROW_NUMBER
-class WindowNtileExecutor : public WindowRowNumberExecutor {
-public:
-	WindowNtileExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp b/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp
deleted file mode 100644
index 0b574b959..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_segment_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_aggregator.hpp"
-
-namespace duckdb {
-
-class WindowSegmentTree : public WindowAggregator {
-public:
-	static bool CanAggregate(const BoundWindowExpression &wexpr);
-
-	WindowSegmentTree(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
-
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	void Evaluate(const WindowAggregatorState &gstate, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_shared_expressions.hpp b/src/duckdb/src/include/duckdb/function/window/window_shared_expressions.hpp
deleted file mode 100644
index fa4a40d10..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_shared_expressions.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_shared_expressions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/expression_map.hpp"
-
-namespace duckdb {
-
-class ExpressionExecutor;
-class DataChunk;
-
-//! A shared set of expressions
-struct WindowSharedExpressions {
-	struct Shared {
-		column_t size = 0;
-		expression_map_t<vector<column_t>> columns;
-	};
-
-	//! Register a shared expression in a shared set
-	static column_t RegisterExpr(const unique_ptr<Expression> &expr, Shared &shared);
-
-	//! Register a shared collection expression
-	column_t RegisterCollection(const unique_ptr<Expression> &expr, bool build_validity) {
-		auto result = RegisterExpr(expr, coll_shared);
-		if (build_validity) {
-			coll_validity.insert(result);
-		}
-		return result;
-	}
-	//! Register a shared collection expression
-	inline column_t RegisterSink(const unique_ptr<Expression> &expr) {
-		return RegisterExpr(expr, sink_shared);
-	}
-	//! Register a shared evaluation expression
-	inline column_t RegisterEvaluate(const unique_ptr<Expression> &expr) {
-		return RegisterExpr(expr, eval_shared);
-	}
-
-	//! Expression layout
-	static vector<optional_ptr<const Expression>> GetSortedExpressions(Shared &shared);
-
-	//! Expression execution utility
-	static void PrepareExecutors(Shared &shared, ExpressionExecutor &exec, DataChunk &chunk);
-
-	//! Prepare collection expressions
-	inline void PrepareCollection(ExpressionExecutor &exec, DataChunk &chunk) {
-		PrepareExecutors(coll_shared, exec, chunk);
-	}
-
-	//! Prepare collection expressions
-	inline void PrepareSink(ExpressionExecutor &exec, DataChunk &chunk) {
-		PrepareExecutors(sink_shared, exec, chunk);
-	}
-
-	//! Prepare collection expressions
-	inline void PrepareEvaluate(ExpressionExecutor &exec, DataChunk &chunk) {
-		PrepareExecutors(eval_shared, exec, chunk);
-	}
-
-	//! Fully materialised shared expressions
-	Shared coll_shared;
-	//! Sink shared expressions
-	Shared sink_shared;
-	//! Evaluate shared expressions
-	Shared eval_shared;
-	//! Requested collection validity masks
-	unordered_set<column_t> coll_validity;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_token_tree.hpp b/src/duckdb/src/include/duckdb/function/window/window_token_tree.hpp
deleted file mode 100644
index 4df4dab8f..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_token_tree.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_token_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_merge_sort_tree.hpp"
-
-namespace duckdb {
-
-// Builds a merge sort tree that uses integer tokens for the comparison values instead of the sort keys.
-class WindowTokenTree : public WindowMergeSortTree {
-public:
-	WindowTokenTree(ClientContext &context, const vector<BoundOrderByNode> &orders, const vector<column_t> &sort_idx,
-	                const idx_t count, bool unique = false)
-	    : WindowMergeSortTree(context, orders, sort_idx, count, unique) {
-	}
-	WindowTokenTree(ClientContext &context, const BoundOrderModifier &order_bys, const vector<column_t> &sort_idx,
-	                const idx_t count, bool unique = false)
-	    : WindowTokenTree(context, order_bys.orders, sort_idx, count, unique) {
-	}
-
-	unique_ptr<WindowAggregatorState> GetLocalState() override;
-
-	//! Thread-safe post-sort cleanup
-	void CleanupSort() override;
-
-	//! Find the rank of the row within the range
-	idx_t Rank(const idx_t lower, const idx_t upper, const idx_t row_idx) const;
-
-	//! Find the next peer after the row and within the range
-	idx_t PeerEnd(const idx_t lower, const idx_t upper, const idx_t row_idx) const;
-
-	//! Peer boundaries.
-	vector<uint8_t> deltas;
-
-protected:
-	//! Find the starts of all the blocks
-	idx_t MeasurePayloadBlocks() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp
deleted file mode 100644
index 1c734e1f8..000000000
--- a/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/window/window_value_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/window/window_executor.hpp"
-
-namespace duckdb {
-
-// Base class for non-aggregate functions that have a payload
-class WindowValueExecutor : public WindowExecutor {
-public:
-	WindowValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-	void Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-	              CollectionPtr collection) const override;
-
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
-
-	//! The column index of the value column
-	column_t child_idx = DConstants::INVALID_INDEX;
-	//! The column index of the Nth column
-	column_t nth_idx = DConstants::INVALID_INDEX;
-	//! The column index of the offset column
-	column_t offset_idx = DConstants::INVALID_INDEX;
-	//! The column index of the default value column
-	column_t default_idx = DConstants::INVALID_INDEX;
-	//! The column indices of any ORDER BY argument expressions
-	vector<column_t> arg_order_idx;
-};
-
-class WindowLeadLagExecutor : public WindowValueExecutor {
-public:
-	WindowLeadLagExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-class WindowFirstValueExecutor : public WindowValueExecutor {
-public:
-	WindowFirstValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-class WindowLastValueExecutor : public WindowValueExecutor {
-public:
-	WindowLastValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-class WindowNthValueExecutor : public WindowValueExecutor {
-public:
-	WindowNthValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
-
-protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/logging/http_logger.hpp b/src/duckdb/src/include/duckdb/logging/http_logger.hpp
deleted file mode 100644
index 1ea9fa70e..000000000
--- a/src/duckdb/src/include/duckdb/logging/http_logger.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/logging/http_logger.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/fstream.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/main/client_context.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-//! This has to be templated because we have two namespaces:
-//! 1. duckdb_httplib
-//! 2. duckdb_httplib_openssl
-//! These have essentially the same code, but we cannot convert between them
-//! We get around that by templating everything, which requires implementing everything in the header
-class HTTPLogger {
-public:
-	explicit HTTPLogger(ClientContext &context_p) : context(context_p) {
-	}
-
-public:
-	template <class REQUEST, class RESPONSE>
-	std::function<void(const REQUEST &, const RESPONSE &)> GetLogger() {
-		return [&](const REQUEST &req, const RESPONSE &res) {
-			Log(req, res);
-		};
-	}
-
-private:
-	template <class STREAM, class REQUEST, class RESPONSE>
-	static inline void TemplatedWriteRequests(STREAM &out, const REQUEST &req, const RESPONSE &res) {
-		out << "HTTP Request:\n";
-		out << "\t" << req.method << " " << req.path << "\n";
-		for (auto &entry : req.headers) {
-			out << "\t" << entry.first << ": " << entry.second << "\n";
-		}
-		out << "\nHTTP Response:\n";
-		out << "\t" << res.status << " " << res.reason << " " << req.version << "\n";
-		for (auto &entry : res.headers) {
-			out << "\t" << entry.first << ": " << entry.second << "\n";
-		}
-		out << "\n";
-	}
-
-	template <class REQUEST, class RESPONSE>
-	void Log(const REQUEST &req, const RESPONSE &res) {
-		const auto &config = ClientConfig::GetConfig(context);
-		D_ASSERT(config.enable_http_logging);
-
-		lock_guard<mutex> guard(lock);
-		if (config.http_logging_output.empty()) {
-			stringstream out;
-			TemplatedWriteRequests(out, req, res);
-			Printer::Print(out.str());
-		} else {
-			ofstream out(config.http_logging_output, ios::app);
-			TemplatedWriteRequests(out, req, res);
-			out.close();
-			// Throw an IO exception if it fails to write to the file
-			if (out.fail()) {
-				throw IOException("Failed to write HTTP log to file \"%s\": %s", config.http_logging_output,
-				                  strerror(errno));
-			}
-		}
-	}
-
-private:
-	ClientContext &context;
-	mutex lock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/appender.hpp b/src/duckdb/src/include/duckdb/main/appender.hpp
deleted file mode 100644
index 0f0f0a4ff..000000000
--- a/src/duckdb/src/include/duckdb/main/appender.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/appender.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/table_description.hpp"
-
-namespace duckdb {
-
-class ColumnDataCollection;
-class ClientContext;
-class DuckDB;
-class TableCatalogEntry;
-class Connection;
-
-enum class AppenderType : uint8_t {
-	LOGICAL, // Cast input -> LogicalType
-	PHYSICAL // Cast input -> PhysicalType
-};
-
-//! The Appender class can be used to append elements to a table.
-class BaseAppender {
-public:
-	//! The amount of tuples that are gathered in the column data collection before flushing.
-	static constexpr const idx_t DEFAULT_FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100ULL;
-
-protected:
-	//! The allocator for the column data collection.
-	Allocator &allocator;
-	//! The column types of the associated table.
-	vector<LogicalType> types;
-	//! The active column types.
-	vector<LogicalType> active_types;
-	//! The buffered to-be-appended data.
-	unique_ptr<ColumnDataCollection> collection;
-	//! The active chunk for row-based appends.
-	DataChunk chunk;
-	//! The currently active column of row-based appends.
-	idx_t column = 0;
-	//! The type of the appender.
-	AppenderType appender_type;
-	//! The amount of rows after which the appender flushes automatically.
-	idx_t flush_count = DEFAULT_FLUSH_COUNT;
-
-protected:
-	DUCKDB_API BaseAppender(Allocator &allocator, const AppenderType type);
-	DUCKDB_API BaseAppender(Allocator &allocator, vector<LogicalType> types, const AppenderType type,
-	                        const idx_t flush_count = DEFAULT_FLUSH_COUNT);
-
-public:
-	DUCKDB_API virtual ~BaseAppender();
-
-	//! Begins a new row append, after calling this the other AppendX() functions
-	//! should be called the correct amount of times. After that,
-	//! EndRow() should be called.
-	DUCKDB_API void BeginRow();
-	//! Finishes appending the current row.
-	DUCKDB_API void EndRow();
-
-	// Append functions
-	template <class T>
-	void Append(T value) = delete;
-	DUCKDB_API void Append(DataChunk &target, const Value &value, idx_t col, idx_t row);
-
-	DUCKDB_API void Append(const char *value, uint32_t length);
-
-	// prepared statements
-	template <typename... ARGS>
-	void AppendRow(ARGS... args) {
-		BeginRow();
-		AppendRowRecursive(args...);
-	}
-
-	//! Commit the changes made by the appender.
-	DUCKDB_API void Flush();
-	//! Flush the changes made by the appender and close it. The appender cannot be used after this point
-	DUCKDB_API void Close();
-	//! Returns the active types of the appender.
-	const vector<LogicalType> &GetActiveTypes() const;
-
-	idx_t CurrentColumn() const {
-		return column;
-	}
-	DUCKDB_API void AppendDataChunk(DataChunk &value);
-
-	//! Appends a column to the active column list.
-	//! Immediately flushes all previous data.
-	virtual void AddColumn(const string &name) = 0;
-	//! Removes all columns from the active column list.
-	//! Immediately flushes all previous data.
-	virtual void ClearColumns() = 0;
-
-protected:
-	void Destructor();
-	virtual void FlushInternal(ColumnDataCollection &collection) = 0;
-	void InitializeChunk();
-	void FlushChunk();
-
-	template <class T>
-	void AppendValueInternal(T value);
-	template <class SRC, class DST>
-	void AppendValueInternal(Vector &vector, SRC input);
-	template <class SRC, class DST>
-	void AppendDecimalValueInternal(Vector &vector, SRC input);
-
-	void AppendRowRecursive() {
-		EndRow();
-	}
-
-	template <typename T, typename... ARGS>
-	void AppendRowRecursive(T value, ARGS... args) {
-		Append<T>(value);
-		AppendRowRecursive(args...);
-	}
-
-	void AppendValue(const Value &value);
-	void AppendValue(DataChunk target, const Value &value);
-};
-
-class Appender : public BaseAppender {
-	//! A shared pointer to the context of this appender.
-	shared_ptr<ClientContext> context;
-	//! The table description including the column names.
-	unique_ptr<TableDescription> description;
-	//! All table default values.
-	unordered_map<column_t, Value> default_values;
-
-	//! If not empty, then this holds all logical column IDs of columns provided by the appender.
-	//! Any other columns default to NULL, or their default values.
-	vector<LogicalIndex> column_ids;
-
-public:
-	DUCKDB_API Appender(Connection &con, const string &database_name, const string &schema_name,
-	                    const string &table_name);
-	DUCKDB_API Appender(Connection &con, const string &schema_name, const string &table_name);
-	DUCKDB_API Appender(Connection &con, const string &table_name);
-	DUCKDB_API ~Appender() override;
-
-public:
-	void AppendDefault();
-	void AppendDefault(DataChunk &chunk, idx_t col, idx_t row);
-	void AddColumn(const string &name) override;
-	void ClearColumns() override;
-
-protected:
-	void FlushInternal(ColumnDataCollection &collection) override;
-	Value GetDefaultValue(idx_t column);
-};
-
-class InternalAppender : public BaseAppender {
-	//! The client context
-	ClientContext &context;
-	//! The internal table entry to append to
-	TableCatalogEntry &table;
-
-public:
-	DUCKDB_API InternalAppender(ClientContext &context, TableCatalogEntry &table,
-	                            const idx_t flush_count = DEFAULT_FLUSH_COUNT);
-	DUCKDB_API ~InternalAppender() override;
-
-protected:
-	void FlushInternal(ColumnDataCollection &collection) override;
-	void AddColumn(const string &name) override;
-	void ClearColumns() override;
-};
-
-template <>
-DUCKDB_API void BaseAppender::Append(bool value);
-template <>
-DUCKDB_API void BaseAppender::Append(int8_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(int16_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(int32_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(int64_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(hugeint_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uhugeint_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint8_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint16_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint32_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint64_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(float value);
-template <>
-DUCKDB_API void BaseAppender::Append(double value);
-template <>
-DUCKDB_API void BaseAppender::Append(date_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(dtime_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(timestamp_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(interval_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(const char *value);
-template <>
-DUCKDB_API void BaseAppender::Append(string_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(Value value);
-template <>
-DUCKDB_API void BaseAppender::Append(std::nullptr_t value);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/attached_database.hpp b/src/duckdb/src/include/duckdb/main/attached_database.hpp
deleted file mode 100644
index 098edf9f7..000000000
--- a/src/duckdb/src/include/duckdb/main/attached_database.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/attached_database.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/storage/storage_options.hpp"
-
-namespace duckdb {
-class Catalog;
-class DatabaseInstance;
-class StorageManager;
-class TransactionManager;
-class StorageExtension;
-class DatabaseManager;
-
-struct AttachInfo;
-
-enum class AttachedDatabaseType {
-	READ_WRITE_DATABASE,
-	READ_ONLY_DATABASE,
-	SYSTEM_DATABASE,
-	TEMP_DATABASE,
-};
-
-//! AttachOptions holds information about a database we plan to attach. These options are generalized, i.e.,
-//! they have to apply to any database file type (duckdb, sqlite, etc.).
-struct AttachOptions {
-	//! Constructor for databases we attach outside of the ATTACH DATABASE statement.
-	explicit AttachOptions(const DBConfigOptions &options);
-	//! Constructor for databases we attach when using ATTACH DATABASE.
-	AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMode default_access_mode);
-
-	//! Defaults to the access mode configured in the DBConfig, unless specified otherwise.
-	AccessMode access_mode;
-	//! The file format type. The default type is a duckdb database file, but other file formats are possible.
-	string db_type;
-	//! Set of remaining (key, value) options
-	unordered_map<string, Value> options;
-	//! (optionally) a catalog can be provided with a default table
-	QualifiedName default_table;
-};
-
-//! The AttachedDatabase represents an attached database instance.
-class AttachedDatabase : public CatalogEntry {
-public:
-	//! Create the built-in system database (without storage).
-	explicit AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type = AttachedDatabaseType::SYSTEM_DATABASE);
-	//! Create an attached database instance with the specified name and storage.
-	AttachedDatabase(DatabaseInstance &db, Catalog &catalog, string name, string file_path,
-	                 const AttachOptions &options);
-	//! Create an attached database instance with the specified storage extension.
-	AttachedDatabase(DatabaseInstance &db, Catalog &catalog, StorageExtension &ext, ClientContext &context, string name,
-	                 const AttachInfo &info, const AttachOptions &options);
-	~AttachedDatabase() override;
-
-	//! Initializes the catalog and storage of the attached database.
-	void Initialize(StorageOptions options = StorageOptions());
-	void Close();
-
-	Catalog &ParentCatalog() override;
-	const Catalog &ParentCatalog() const override;
-	StorageManager &GetStorageManager();
-	Catalog &GetCatalog();
-	TransactionManager &GetTransactionManager();
-	DatabaseInstance &GetDatabase() {
-		return db;
-	}
-
-	optional_ptr<StorageExtension> GetStorageExtension() {
-		return storage_extension;
-	}
-
-	const string &GetName() const {
-		return name;
-	}
-	bool IsSystem() const;
-	bool IsTemporary() const;
-	bool IsReadOnly() const;
-	bool IsInitialDatabase() const;
-	void SetInitialDatabase();
-	void SetReadOnlyDatabase();
-
-	static bool NameIsReserved(const string &name);
-	static string ExtractDatabaseName(const string &dbpath, FileSystem &fs);
-
-private:
-	DatabaseInstance &db;
-	unique_ptr<StorageManager> storage;
-	unique_ptr<Catalog> catalog;
-	unique_ptr<TransactionManager> transaction_manager;
-	AttachedDatabaseType type;
-	optional_ptr<Catalog> parent_catalog;
-	optional_ptr<StorageExtension> storage_extension;
-	bool is_initial_database = false;
-	bool is_closed = false;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/buffered_data/batched_buffered_data.hpp b/src/duckdb/src/include/duckdb/main/buffered_data/batched_buffered_data.hpp
deleted file mode 100644
index c3ffadbe2..000000000
--- a/src/duckdb/src/include/duckdb/main/buffered_data/batched_buffered_data.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/batched_buffered_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/common/deque.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/main/buffered_data/simple_buffered_data.hpp"
-#include "duckdb/common/map.hpp"
-
-namespace duckdb {
-
-class StreamQueryResult;
-
-class InProgressBatch {
-public:
-	//! The chunks that make up the batch
-	deque<unique_ptr<DataChunk>> chunks;
-	//! Whether the batch is completed (NextBatch has been called)
-	bool completed = false;
-};
-
-class BatchedBufferedData : public BufferedData {
-public:
-	static constexpr const BufferedData::Type TYPE = BufferedData::Type::BATCHED;
-
-public:
-	explicit BatchedBufferedData(weak_ptr<ClientContext> context);
-
-public:
-	void Append(const DataChunk &chunk, idx_t batch);
-	void BlockSink(const InterruptState &blocked_sink, idx_t batch);
-
-	bool ShouldBlockBatch(idx_t batch);
-	StreamExecutionResult ExecuteTaskInternal(StreamQueryResult &result, ClientContextLock &context_lock) override;
-	unique_ptr<DataChunk> Scan() override;
-	void UpdateMinBatchIndex(idx_t min_batch_index);
-	bool IsMinimumBatchIndex(lock_guard<mutex> &lock, idx_t batch);
-	void CompleteBatch(idx_t batch);
-	bool BufferIsEmpty();
-	void UnblockSinks() override;
-
-	inline idx_t ReadQueueCapacity() const {
-		return read_queue_capacity;
-	}
-	inline idx_t BufferCapacity() const {
-		return buffer_capacity;
-	}
-
-private:
-	void ResetReplenishState();
-	void MoveCompletedBatches(lock_guard<mutex> &lock);
-
-private:
-	//! The buffer where chunks are written before they are ready to be read.
-	map<idx_t, InProgressBatch> buffer;
-	idx_t buffer_capacity;
-	atomic<idx_t> buffer_byte_count;
-
-	//! The queue containing the chunks that can be read.
-	deque<unique_ptr<DataChunk>> read_queue;
-	idx_t read_queue_capacity;
-	atomic<idx_t> read_queue_byte_count;
-
-	map<idx_t, InterruptState> blocked_sinks;
-
-	idx_t min_batch;
-	//! Debug variable to verify that order is preserved correctly.
-	idx_t lowest_moved_batch = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/buffered_data/buffered_data.hpp b/src/duckdb/src/include/duckdb/main/buffered_data/buffered_data.hpp
deleted file mode 100644
index 0f32675ce..000000000
--- a/src/duckdb/src/include/duckdb/main/buffered_data/buffered_data.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/buffered_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/execution/physical_operator_states.hpp"
-#include "duckdb/common/enums/pending_execution_result.hpp"
-#include "duckdb/common/enums/stream_execution_result.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-
-namespace duckdb {
-
-class StreamQueryResult;
-class ClientContextLock;
-
-class BufferedData {
-protected:
-	enum class Type { SIMPLE, BATCHED };
-
-public:
-	BufferedData(Type type, weak_ptr<ClientContext> context_p);
-	virtual ~BufferedData();
-
-public:
-	StreamExecutionResult ReplenishBuffer(StreamQueryResult &result, ClientContextLock &context_lock);
-	virtual StreamExecutionResult ExecuteTaskInternal(StreamQueryResult &result, ClientContextLock &context_lock) = 0;
-	virtual unique_ptr<DataChunk> Scan() = 0;
-	virtual void UnblockSinks() = 0;
-	shared_ptr<ClientContext> GetContext() {
-		return context.lock();
-	}
-	bool Closed() const {
-		if (context.expired()) {
-			return true;
-		}
-		auto c = context.lock();
-		return c == nullptr;
-	}
-	void Close() {
-		context.reset();
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (TARGET::TYPE != type) {
-			throw InternalException("Failed to cast buffered data to type - buffered data type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (TARGET::TYPE != type) {
-			throw InternalException("Failed to cast buffered data to type - buffered data type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-protected:
-	Type type;
-	//! This is weak to avoid a cyclical reference
-	weak_ptr<ClientContext> context;
-	//! The maximum amount of memory we should keep buffered
-	idx_t total_buffer_size;
-	//! Protect against populate/fetch race condition
-	mutex glock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/buffered_data/simple_buffered_data.hpp b/src/duckdb/src/include/duckdb/main/buffered_data/simple_buffered_data.hpp
deleted file mode 100644
index 967cc1ab7..000000000
--- a/src/duckdb/src/include/duckdb/main/buffered_data/simple_buffered_data.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/simple_buffered_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/buffered_data/buffered_data.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-
-namespace duckdb {
-
-class StreamQueryResult;
-class ClientContextLock;
-
-class SimpleBufferedData : public BufferedData {
-public:
-	static constexpr const BufferedData::Type TYPE = BufferedData::Type::SIMPLE;
-
-public:
-	explicit SimpleBufferedData(weak_ptr<ClientContext> context);
-	~SimpleBufferedData() override;
-
-public:
-	void Append(const DataChunk &chunk);
-	void BlockSink(const InterruptState &blocked_sink);
-	bool BufferIsFull();
-	void UnblockSinks() override;
-	StreamExecutionResult ExecuteTaskInternal(StreamQueryResult &result, ClientContextLock &context_lock) override;
-	unique_ptr<DataChunk> Scan() override;
-	inline idx_t BufferSize() const {
-		return buffer_size;
-	}
-
-private:
-	//! Our handles to reschedule the blocked sink tasks
-	queue<InterruptState> blocked_sinks;
-	//! The queue of chunks
-	queue<unique_ptr<DataChunk>> buffered_chunks;
-	//! The current capacity of the buffer (tuples)
-	atomic<idx_t> buffered_count;
-	//! The amount of tuples we should buffer
-	idx_t buffer_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp b/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp
deleted file mode 100644
index c00425420..000000000
--- a/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/capi/capi_internal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/main/appender.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-#include "duckdb/main/db_instance_cache.hpp"
-
-#include <cstring>
-#include <cassert>
-
-#ifdef _WIN32
-#ifndef strdup
-#define strdup _strdup
-#endif
-#endif
-
-namespace duckdb {
-
-struct DBInstanceCacheWrapper {
-	unique_ptr<DBInstanceCache> instance_cache;
-};
-
-struct DatabaseWrapper {
-	shared_ptr<DuckDB> database;
-};
-
-struct PreparedStatementWrapper {
-	//! Map of name -> values
-	case_insensitive_map_t<BoundParameterData> values;
-	unique_ptr<PreparedStatement> statement;
-};
-
-struct ExtractStatementsWrapper {
-	vector<unique_ptr<SQLStatement>> statements;
-	string error;
-};
-
-struct PendingStatementWrapper {
-	unique_ptr<PendingQueryResult> statement;
-	bool allow_streaming;
-};
-
-struct ArrowResultWrapper {
-	unique_ptr<MaterializedQueryResult> result;
-	unique_ptr<DataChunk> current_chunk;
-};
-
-struct AppenderWrapper {
-	unique_ptr<Appender> appender;
-	string error;
-};
-
-struct TableDescriptionWrapper {
-	unique_ptr<TableDescription> description;
-	string error;
-};
-
-enum class CAPIResultSetType : uint8_t {
-	CAPI_RESULT_TYPE_NONE = 0,
-	CAPI_RESULT_TYPE_MATERIALIZED,
-	CAPI_RESULT_TYPE_STREAMING,
-	CAPI_RESULT_TYPE_DEPRECATED
-};
-
-struct DuckDBResultData {
-	//! The underlying query result
-	unique_ptr<QueryResult> result;
-	// Results can only use either the new API or the old API, not a mix of the two
-	// They start off as "none" and switch to one or the other when an API method is used
-	CAPIResultSetType result_set_type;
-};
-
-duckdb_type ConvertCPPTypeToC(const LogicalType &type);
-LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type);
-idx_t GetCTypeSize(duckdb_type type);
-duckdb_state DuckDBTranslateResult(unique_ptr<QueryResult> result, duckdb_result *out);
-bool DeprecatedMaterializeResult(duckdb_result *result);
-duckdb_statement_type StatementTypeToC(duckdb::StatementType statement_type);
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/capi/cast/from_decimal.hpp b/src/duckdb/src/include/duckdb/main/capi/cast/from_decimal.hpp
deleted file mode 100644
index 2a9bf7644..000000000
--- a/src/duckdb/src/include/duckdb/main/capi/cast/from_decimal.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/capi/capi_cast_from_decimal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/capi/cast/utils.hpp"
-
-namespace duckdb {
-
-//! DECIMAL -> ?
-template <class RESULT_TYPE>
-bool CastDecimalCInternal(duckdb_result *source, RESULT_TYPE &result, idx_t col, idx_t row) {
-	auto result_data = (duckdb::DuckDBResultData *)source->internal_data;
-	auto &query_result = result_data->result;
-	auto &source_type = query_result->types[col];
-	auto width = duckdb::DecimalType::GetWidth(source_type);
-	auto scale = duckdb::DecimalType::GetScale(source_type);
-	void *source_address = UnsafeFetchPtr<hugeint_t>(source, col, row);
-
-	CastParameters parameters;
-	switch (source_type.InternalType()) {
-	case duckdb::PhysicalType::INT16:
-		return duckdb::TryCastFromDecimal::Operation<int16_t, RESULT_TYPE>(UnsafeFetchFromPtr<int16_t>(source_address),
-		                                                                   result, parameters, width, scale);
-	case duckdb::PhysicalType::INT32:
-		return duckdb::TryCastFromDecimal::Operation<int32_t, RESULT_TYPE>(UnsafeFetchFromPtr<int32_t>(source_address),
-		                                                                   result, parameters, width, scale);
-	case duckdb::PhysicalType::INT64:
-		return duckdb::TryCastFromDecimal::Operation<int64_t, RESULT_TYPE>(UnsafeFetchFromPtr<int64_t>(source_address),
-		                                                                   result, parameters, width, scale);
-	case duckdb::PhysicalType::INT128:
-		return duckdb::TryCastFromDecimal::Operation<hugeint_t, RESULT_TYPE>(
-		    UnsafeFetchFromPtr<hugeint_t>(source_address), result, parameters, width, scale);
-	default:
-		throw duckdb::InternalException("Unimplemented internal type for decimal");
-	}
-}
-
-//! DECIMAL -> VARCHAR
-template <>
-bool CastDecimalCInternal(duckdb_result *source, duckdb_string &result, idx_t col, idx_t row);
-
-//! DECIMAL -> DECIMAL (internal fetch)
-template <>
-bool CastDecimalCInternal(duckdb_result *source, duckdb_decimal &result, idx_t col, idx_t row);
-
-//! DECIMAL -> ...
-template <class RESULT_TYPE>
-RESULT_TYPE TryCastDecimalCInternal(duckdb_result *source, idx_t col, idx_t row) {
-	RESULT_TYPE result_value;
-	try {
-		if (!CastDecimalCInternal<RESULT_TYPE>(source, result_value, col, row)) {
-			return FetchDefaultValue::Operation<RESULT_TYPE>();
-		}
-	} catch (...) {
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	}
-	return result_value;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/capi/cast/generic.hpp b/src/duckdb/src/include/duckdb/main/capi/cast/generic.hpp
deleted file mode 100644
index 1f797ce25..000000000
--- a/src/duckdb/src/include/duckdb/main/capi/cast/generic.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/capi/cast/generic_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types/date.hpp"
-
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/capi/cast/utils.hpp"
-#include "duckdb/main/capi/cast/from_decimal.hpp"
-
-namespace duckdb {
-
-template <class RESULT_TYPE, class OP = duckdb::TryCast>
-RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanFetchValue(result, col, row)) {
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	}
-	switch (result->deprecated_columns[col].deprecated_type) {
-	case DUCKDB_TYPE_BOOLEAN:
-		return TryCastCInternal<bool, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_TINYINT:
-		return TryCastCInternal<int8_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_SMALLINT:
-		return TryCastCInternal<int16_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_INTEGER:
-		return TryCastCInternal<int32_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_BIGINT:
-		return TryCastCInternal<int64_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UTINYINT:
-		return TryCastCInternal<uint8_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_USMALLINT:
-		return TryCastCInternal<uint16_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UINTEGER:
-		return TryCastCInternal<uint32_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UBIGINT:
-		return TryCastCInternal<uint64_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_FLOAT:
-		return TryCastCInternal<float, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_DOUBLE:
-		return TryCastCInternal<double, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_DATE:
-		return TryCastCInternal<date_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_TIME:
-		return TryCastCInternal<dtime_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_TIMESTAMP:
-		return TryCastCInternal<timestamp_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_HUGEINT:
-		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UHUGEINT:
-		return TryCastCInternal<uhugeint_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_DECIMAL:
-		return TryCastDecimalCInternal<RESULT_TYPE>(result, col, row);
-	case DUCKDB_TYPE_INTERVAL:
-		return TryCastCInternal<interval_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_VARCHAR:
-		return TryCastCInternal<char *, RESULT_TYPE, FromCStringCastWrapper<OP>>(result, col, row);
-	case DUCKDB_TYPE_BLOB:
-		return TryCastCInternal<duckdb_blob, RESULT_TYPE, FromCBlobCastWrapper>(result, col, row);
-	default: { // LCOV_EXCL_START
-		// Invalid type for C to C++ conversion. Internally, we set the null mask to NULL.
-		// This is a deprecated code path. Use the Vector Interface for nested and complex types.
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	} // LCOV_EXCL_STOP
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/capi/cast/to_decimal.hpp b/src/duckdb/src/include/duckdb/main/capi/cast/to_decimal.hpp
deleted file mode 100644
index 39c4ab7e7..000000000
--- a/src/duckdb/src/include/duckdb/main/capi/cast/to_decimal.hpp
+++ /dev/null
@@ -1,141 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/capi/capi_cast_from_decimal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/capi/cast/utils.hpp"
-
-namespace duckdb {
-
-template <class INTERNAL_TYPE>
-struct ToCDecimalCastWrapper {
-	template <class SOURCE_TYPE>
-	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters &parameters, uint8_t width,
-	                      uint8_t scale) {
-		throw NotImplementedException("Type not implemented for CDecimalCastWrapper");
-	}
-};
-
-//! Hugeint
-template <>
-struct ToCDecimalCastWrapper<hugeint_t> {
-	template <class SOURCE_TYPE>
-	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters &parameters, uint8_t width,
-	                      uint8_t scale) {
-		hugeint_t intermediate_result;
-
-		if (!TryCastToDecimal::Operation<SOURCE_TYPE, hugeint_t>(input, intermediate_result, parameters, width,
-		                                                         scale)) {
-			result = FetchDefaultValue::Operation<duckdb_decimal>();
-			return false;
-		}
-		result.scale = scale;
-		result.width = width;
-
-		duckdb_hugeint hugeint_value;
-		hugeint_value.upper = intermediate_result.upper;
-		hugeint_value.lower = intermediate_result.lower;
-		result.value = hugeint_value;
-		return true;
-	}
-};
-
-//! FIXME: reduce duplication here by just matching on the signed-ness of the type
-//! INTERNAL_TYPE = int16_t
-template <>
-struct ToCDecimalCastWrapper<int16_t> {
-	template <class SOURCE_TYPE>
-	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters &parameters, uint8_t width,
-	                      uint8_t scale) {
-		int16_t intermediate_result;
-
-		if (!TryCastToDecimal::Operation<SOURCE_TYPE, int16_t>(input, intermediate_result, parameters, width, scale)) {
-			result = FetchDefaultValue::Operation<duckdb_decimal>();
-			return false;
-		}
-		hugeint_t hugeint_result = Hugeint::Convert(intermediate_result);
-
-		result.scale = scale;
-		result.width = width;
-
-		duckdb_hugeint hugeint_value;
-		hugeint_value.upper = hugeint_result.upper;
-		hugeint_value.lower = hugeint_result.lower;
-		result.value = hugeint_value;
-		return true;
-	}
-};
-//! INTERNAL_TYPE = int32_t
-template <>
-struct ToCDecimalCastWrapper<int32_t> {
-	template <class SOURCE_TYPE>
-	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters &parameters, uint8_t width,
-	                      uint8_t scale) {
-		int32_t intermediate_result;
-
-		if (!TryCastToDecimal::Operation<SOURCE_TYPE, int32_t>(input, intermediate_result, parameters, width, scale)) {
-			result = FetchDefaultValue::Operation<duckdb_decimal>();
-			return false;
-		}
-		hugeint_t hugeint_result = Hugeint::Convert(intermediate_result);
-
-		result.scale = scale;
-		result.width = width;
-
-		duckdb_hugeint hugeint_value;
-		hugeint_value.upper = hugeint_result.upper;
-		hugeint_value.lower = hugeint_result.lower;
-		result.value = hugeint_value;
-		return true;
-	}
-};
-//! INTERNAL_TYPE = int64_t
-template <>
-struct ToCDecimalCastWrapper<int64_t> {
-	template <class SOURCE_TYPE>
-	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, CastParameters &parameters, uint8_t width,
-	                      uint8_t scale) {
-		int64_t intermediate_result;
-
-		if (!TryCastToDecimal::Operation<SOURCE_TYPE, int64_t>(input, intermediate_result, parameters, width, scale)) {
-			result = FetchDefaultValue::Operation<duckdb_decimal>();
-			return false;
-		}
-		hugeint_t hugeint_result = Hugeint::Convert(intermediate_result);
-
-		result.scale = scale;
-		result.width = width;
-
-		duckdb_hugeint hugeint_value;
-		hugeint_value.upper = hugeint_result.upper;
-		hugeint_value.lower = hugeint_result.lower;
-		result.value = hugeint_value;
-		return true;
-	}
-};
-
-template <class SOURCE_TYPE, class OP>
-duckdb_decimal TryCastToDecimalCInternal(SOURCE_TYPE source, uint8_t width, uint8_t scale) {
-	duckdb_decimal result;
-	try {
-		CastParameters parameters;
-		if (!OP::template Operation<SOURCE_TYPE>(source, result, parameters, width, scale)) {
-			return FetchDefaultValue::Operation<duckdb_decimal>();
-		}
-	} catch (...) {
-		return FetchDefaultValue::Operation<duckdb_decimal>();
-	}
-	return result;
-}
-
-template <class SOURCE_TYPE, class OP>
-duckdb_decimal TryCastToDecimalCInternal(duckdb_result *result, idx_t col, idx_t row, uint8_t width, uint8_t scale) {
-	return TryCastToDecimalCInternal<SOURCE_TYPE, OP>(UnsafeFetch<SOURCE_TYPE>(result, col, row), width, scale);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/capi/cast/utils.hpp b/src/duckdb/src/include/duckdb/main/capi/cast/utils.hpp
deleted file mode 100644
index aafed19cb..000000000
--- a/src/duckdb/src/include/duckdb/main/capi/cast/utils.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/capi/cast/utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Unsafe Fetch (for internal use only)
-//===--------------------------------------------------------------------===//
-template <class T>
-T UnsafeFetchFromPtr(void *pointer) {
-	return *((T *)pointer);
-}
-
-template <class T>
-void *UnsafeFetchPtr(duckdb_result *result, idx_t col, idx_t row) {
-	D_ASSERT(row < result->deprecated_row_count);
-	return (void *)&(((T *)result->deprecated_columns[col].deprecated_data)[row]);
-}
-
-template <class T>
-T UnsafeFetch(duckdb_result *result, idx_t col, idx_t row) {
-	return UnsafeFetchFromPtr<T>(UnsafeFetchPtr<T>(result, col, row));
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Default Value
-//===--------------------------------------------------------------------===//
-struct FetchDefaultValue {
-	template <class T>
-	static T Operation() {
-		return 0;
-	}
-};
-
-template <>
-duckdb_decimal FetchDefaultValue::Operation();
-template <>
-date_t FetchDefaultValue::Operation();
-template <>
-dtime_t FetchDefaultValue::Operation();
-template <>
-timestamp_t FetchDefaultValue::Operation();
-template <>
-interval_t FetchDefaultValue::Operation();
-template <>
-char *FetchDefaultValue::Operation();
-template <>
-duckdb_string FetchDefaultValue::Operation();
-template <>
-duckdb_blob FetchDefaultValue::Operation();
-
-//===--------------------------------------------------------------------===//
-// String Casts
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct FromCStringCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
-		string_t input(input_str);
-		return OP::template Operation<string_t, RESULT_TYPE>(input, result);
-	}
-};
-
-template <class OP>
-struct ToCStringCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input, RESULT_TYPE &result) {
-		Vector result_vector(LogicalType::VARCHAR, nullptr);
-		auto result_string = OP::template Operation<SOURCE_TYPE>(input, result_vector);
-		auto result_size = result_string.GetSize();
-		auto result_data = result_string.GetData();
-
-		char *allocated_data = char_ptr_cast(duckdb_malloc(result_size + 1));
-		memcpy(allocated_data, result_data, result_size);
-		allocated_data[result_size] = '\0';
-		result.data = allocated_data;
-		result.size = result_size;
-		return true;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Blob Casts
-//===--------------------------------------------------------------------===//
-struct FromCBlobCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
-		return false;
-	}
-};
-
-template <>
-bool FromCBlobCastWrapper::Operation(duckdb_blob input, duckdb_string &result);
-
-template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
-RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
-	RESULT_TYPE result_value;
-	try {
-		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
-		                                                      result_value)) {
-			return FetchDefaultValue::Operation<RESULT_TYPE>();
-		}
-	} catch (...) {
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	}
-	return result_value;
-}
-
-} // namespace duckdb
-
-bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row);
-bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row);
diff --git a/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp b/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp
deleted file mode 100644
index 71e6d18bc..000000000
--- a/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp
+++ /dev/null
@@ -1,895 +0,0 @@
-#pragma once
-
-#include "duckdb.h"
-
-//===--------------------------------------------------------------------===//
-// Function pointer struct
-//===--------------------------------------------------------------------===//
-typedef struct {
-	// v1.2.0
-	duckdb_state (*duckdb_open)(const char *path, duckdb_database *out_database);
-	duckdb_state (*duckdb_open_ext)(const char *path, duckdb_database *out_database, duckdb_config config,
-	                                char **out_error);
-	void (*duckdb_close)(duckdb_database *database);
-	duckdb_state (*duckdb_connect)(duckdb_database database, duckdb_connection *out_connection);
-	void (*duckdb_interrupt)(duckdb_connection connection);
-	duckdb_query_progress_type (*duckdb_query_progress)(duckdb_connection connection);
-	void (*duckdb_disconnect)(duckdb_connection *connection);
-	const char *(*duckdb_library_version)();
-	duckdb_state (*duckdb_create_config)(duckdb_config *out_config);
-	size_t (*duckdb_config_count)();
-	duckdb_state (*duckdb_get_config_flag)(size_t index, const char **out_name, const char **out_description);
-	duckdb_state (*duckdb_set_config)(duckdb_config config, const char *name, const char *option);
-	void (*duckdb_destroy_config)(duckdb_config *config);
-	duckdb_state (*duckdb_query)(duckdb_connection connection, const char *query, duckdb_result *out_result);
-	void (*duckdb_destroy_result)(duckdb_result *result);
-	const char *(*duckdb_column_name)(duckdb_result *result, idx_t col);
-	duckdb_type (*duckdb_column_type)(duckdb_result *result, idx_t col);
-	duckdb_statement_type (*duckdb_result_statement_type)(duckdb_result result);
-	duckdb_logical_type (*duckdb_column_logical_type)(duckdb_result *result, idx_t col);
-	idx_t (*duckdb_column_count)(duckdb_result *result);
-	idx_t (*duckdb_rows_changed)(duckdb_result *result);
-	const char *(*duckdb_result_error)(duckdb_result *result);
-	duckdb_error_type (*duckdb_result_error_type)(duckdb_result *result);
-	duckdb_result_type (*duckdb_result_return_type)(duckdb_result result);
-	void *(*duckdb_malloc)(size_t size);
-	void (*duckdb_free)(void *ptr);
-	idx_t (*duckdb_vector_size)();
-	bool (*duckdb_string_is_inlined)(duckdb_string_t string);
-	uint32_t (*duckdb_string_t_length)(duckdb_string_t string);
-	const char *(*duckdb_string_t_data)(duckdb_string_t *string);
-	duckdb_date_struct (*duckdb_from_date)(duckdb_date date);
-	duckdb_date (*duckdb_to_date)(duckdb_date_struct date);
-	bool (*duckdb_is_finite_date)(duckdb_date date);
-	duckdb_time_struct (*duckdb_from_time)(duckdb_time time);
-	duckdb_time_tz (*duckdb_create_time_tz)(int64_t micros, int32_t offset);
-	duckdb_time_tz_struct (*duckdb_from_time_tz)(duckdb_time_tz micros);
-	duckdb_time (*duckdb_to_time)(duckdb_time_struct time);
-	duckdb_timestamp_struct (*duckdb_from_timestamp)(duckdb_timestamp ts);
-	duckdb_timestamp (*duckdb_to_timestamp)(duckdb_timestamp_struct ts);
-	bool (*duckdb_is_finite_timestamp)(duckdb_timestamp ts);
-	double (*duckdb_hugeint_to_double)(duckdb_hugeint val);
-	duckdb_hugeint (*duckdb_double_to_hugeint)(double val);
-	double (*duckdb_uhugeint_to_double)(duckdb_uhugeint val);
-	duckdb_uhugeint (*duckdb_double_to_uhugeint)(double val);
-	duckdb_decimal (*duckdb_double_to_decimal)(double val, uint8_t width, uint8_t scale);
-	double (*duckdb_decimal_to_double)(duckdb_decimal val);
-	duckdb_state (*duckdb_prepare)(duckdb_connection connection, const char *query,
-	                               duckdb_prepared_statement *out_prepared_statement);
-	void (*duckdb_destroy_prepare)(duckdb_prepared_statement *prepared_statement);
-	const char *(*duckdb_prepare_error)(duckdb_prepared_statement prepared_statement);
-	idx_t (*duckdb_nparams)(duckdb_prepared_statement prepared_statement);
-	const char *(*duckdb_parameter_name)(duckdb_prepared_statement prepared_statement, idx_t index);
-	duckdb_type (*duckdb_param_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-	duckdb_logical_type (*duckdb_param_logical_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-	duckdb_state (*duckdb_clear_bindings)(duckdb_prepared_statement prepared_statement);
-	duckdb_statement_type (*duckdb_prepared_statement_type)(duckdb_prepared_statement statement);
-	duckdb_state (*duckdb_bind_value)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val);
-	duckdb_state (*duckdb_bind_parameter_index)(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
-	                                            const char *name);
-	duckdb_state (*duckdb_bind_boolean)(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val);
-	duckdb_state (*duckdb_bind_int8)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val);
-	duckdb_state (*duckdb_bind_int16)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val);
-	duckdb_state (*duckdb_bind_int32)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val);
-	duckdb_state (*duckdb_bind_int64)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val);
-	duckdb_state (*duckdb_bind_hugeint)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                    duckdb_hugeint val);
-	duckdb_state (*duckdb_bind_uhugeint)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                     duckdb_uhugeint val);
-	duckdb_state (*duckdb_bind_decimal)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                    duckdb_decimal val);
-	duckdb_state (*duckdb_bind_uint8)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val);
-	duckdb_state (*duckdb_bind_uint16)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val);
-	duckdb_state (*duckdb_bind_uint32)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val);
-	duckdb_state (*duckdb_bind_uint64)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val);
-	duckdb_state (*duckdb_bind_float)(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val);
-	duckdb_state (*duckdb_bind_double)(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val);
-	duckdb_state (*duckdb_bind_date)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val);
-	duckdb_state (*duckdb_bind_time)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val);
-	duckdb_state (*duckdb_bind_timestamp)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                      duckdb_timestamp val);
-	duckdb_state (*duckdb_bind_timestamp_tz)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                         duckdb_timestamp val);
-	duckdb_state (*duckdb_bind_interval)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                     duckdb_interval val);
-	duckdb_state (*duckdb_bind_varchar)(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val);
-	duckdb_state (*duckdb_bind_varchar_length)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                           const char *val, idx_t length);
-	duckdb_state (*duckdb_bind_blob)(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
-	                                 idx_t length);
-	duckdb_state (*duckdb_bind_null)(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-	duckdb_state (*duckdb_execute_prepared)(duckdb_prepared_statement prepared_statement, duckdb_result *out_result);
-	idx_t (*duckdb_extract_statements)(duckdb_connection connection, const char *query,
-	                                   duckdb_extracted_statements *out_extracted_statements);
-	duckdb_state (*duckdb_prepare_extracted_statement)(duckdb_connection connection,
-	                                                   duckdb_extracted_statements extracted_statements, idx_t index,
-	                                                   duckdb_prepared_statement *out_prepared_statement);
-	const char *(*duckdb_extract_statements_error)(duckdb_extracted_statements extracted_statements);
-	void (*duckdb_destroy_extracted)(duckdb_extracted_statements *extracted_statements);
-	duckdb_state (*duckdb_pending_prepared)(duckdb_prepared_statement prepared_statement,
-	                                        duckdb_pending_result *out_result);
-	void (*duckdb_destroy_pending)(duckdb_pending_result *pending_result);
-	const char *(*duckdb_pending_error)(duckdb_pending_result pending_result);
-	duckdb_pending_state (*duckdb_pending_execute_task)(duckdb_pending_result pending_result);
-	duckdb_pending_state (*duckdb_pending_execute_check_state)(duckdb_pending_result pending_result);
-	duckdb_state (*duckdb_execute_pending)(duckdb_pending_result pending_result, duckdb_result *out_result);
-	bool (*duckdb_pending_execution_is_finished)(duckdb_pending_state pending_state);
-	void (*duckdb_destroy_value)(duckdb_value *value);
-	duckdb_value (*duckdb_create_varchar)(const char *text);
-	duckdb_value (*duckdb_create_varchar_length)(const char *text, idx_t length);
-	duckdb_value (*duckdb_create_bool)(bool input);
-	duckdb_value (*duckdb_create_int8)(int8_t input);
-	duckdb_value (*duckdb_create_uint8)(uint8_t input);
-	duckdb_value (*duckdb_create_int16)(int16_t input);
-	duckdb_value (*duckdb_create_uint16)(uint16_t input);
-	duckdb_value (*duckdb_create_int32)(int32_t input);
-	duckdb_value (*duckdb_create_uint32)(uint32_t input);
-	duckdb_value (*duckdb_create_uint64)(uint64_t input);
-	duckdb_value (*duckdb_create_int64)(int64_t val);
-	duckdb_value (*duckdb_create_hugeint)(duckdb_hugeint input);
-	duckdb_value (*duckdb_create_uhugeint)(duckdb_uhugeint input);
-	duckdb_value (*duckdb_create_float)(float input);
-	duckdb_value (*duckdb_create_double)(double input);
-	duckdb_value (*duckdb_create_date)(duckdb_date input);
-	duckdb_value (*duckdb_create_time)(duckdb_time input);
-	duckdb_value (*duckdb_create_time_tz_value)(duckdb_time_tz value);
-	duckdb_value (*duckdb_create_timestamp)(duckdb_timestamp input);
-	duckdb_value (*duckdb_create_interval)(duckdb_interval input);
-	duckdb_value (*duckdb_create_blob)(const uint8_t *data, idx_t length);
-	duckdb_value (*duckdb_create_varint)(duckdb_varint input);
-	duckdb_value (*duckdb_create_decimal)(duckdb_decimal input);
-	duckdb_value (*duckdb_create_bit)(duckdb_bit input);
-	duckdb_value (*duckdb_create_uuid)(duckdb_uhugeint input);
-	bool (*duckdb_get_bool)(duckdb_value val);
-	int8_t (*duckdb_get_int8)(duckdb_value val);
-	uint8_t (*duckdb_get_uint8)(duckdb_value val);
-	int16_t (*duckdb_get_int16)(duckdb_value val);
-	uint16_t (*duckdb_get_uint16)(duckdb_value val);
-	int32_t (*duckdb_get_int32)(duckdb_value val);
-	uint32_t (*duckdb_get_uint32)(duckdb_value val);
-	int64_t (*duckdb_get_int64)(duckdb_value val);
-	uint64_t (*duckdb_get_uint64)(duckdb_value val);
-	duckdb_hugeint (*duckdb_get_hugeint)(duckdb_value val);
-	duckdb_uhugeint (*duckdb_get_uhugeint)(duckdb_value val);
-	float (*duckdb_get_float)(duckdb_value val);
-	double (*duckdb_get_double)(duckdb_value val);
-	duckdb_date (*duckdb_get_date)(duckdb_value val);
-	duckdb_time (*duckdb_get_time)(duckdb_value val);
-	duckdb_time_tz (*duckdb_get_time_tz)(duckdb_value val);
-	duckdb_timestamp (*duckdb_get_timestamp)(duckdb_value val);
-	duckdb_interval (*duckdb_get_interval)(duckdb_value val);
-	duckdb_logical_type (*duckdb_get_value_type)(duckdb_value val);
-	duckdb_blob (*duckdb_get_blob)(duckdb_value val);
-	duckdb_varint (*duckdb_get_varint)(duckdb_value val);
-	duckdb_decimal (*duckdb_get_decimal)(duckdb_value val);
-	duckdb_bit (*duckdb_get_bit)(duckdb_value val);
-	duckdb_uhugeint (*duckdb_get_uuid)(duckdb_value val);
-	char *(*duckdb_get_varchar)(duckdb_value value);
-	duckdb_value (*duckdb_create_struct_value)(duckdb_logical_type type, duckdb_value *values);
-	duckdb_value (*duckdb_create_list_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
-	duckdb_value (*duckdb_create_array_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
-	idx_t (*duckdb_get_map_size)(duckdb_value value);
-	duckdb_value (*duckdb_get_map_key)(duckdb_value value, idx_t index);
-	duckdb_value (*duckdb_get_map_value)(duckdb_value value, idx_t index);
-	bool (*duckdb_is_null_value)(duckdb_value value);
-	duckdb_value (*duckdb_create_null_value)();
-	idx_t (*duckdb_get_list_size)(duckdb_value value);
-	duckdb_value (*duckdb_get_list_child)(duckdb_value value, idx_t index);
-	duckdb_value (*duckdb_create_enum_value)(duckdb_logical_type type, uint64_t value);
-	uint64_t (*duckdb_get_enum_value)(duckdb_value value);
-	duckdb_value (*duckdb_get_struct_child)(duckdb_value value, idx_t index);
-	duckdb_logical_type (*duckdb_create_logical_type)(duckdb_type type);
-	char *(*duckdb_logical_type_get_alias)(duckdb_logical_type type);
-	void (*duckdb_logical_type_set_alias)(duckdb_logical_type type, const char *alias);
-	duckdb_logical_type (*duckdb_create_list_type)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_create_array_type)(duckdb_logical_type type, idx_t array_size);
-	duckdb_logical_type (*duckdb_create_map_type)(duckdb_logical_type key_type, duckdb_logical_type value_type);
-	duckdb_logical_type (*duckdb_create_union_type)(duckdb_logical_type *member_types, const char **member_names,
-	                                                idx_t member_count);
-	duckdb_logical_type (*duckdb_create_struct_type)(duckdb_logical_type *member_types, const char **member_names,
-	                                                 idx_t member_count);
-	duckdb_logical_type (*duckdb_create_enum_type)(const char **member_names, idx_t member_count);
-	duckdb_logical_type (*duckdb_create_decimal_type)(uint8_t width, uint8_t scale);
-	duckdb_type (*duckdb_get_type_id)(duckdb_logical_type type);
-	uint8_t (*duckdb_decimal_width)(duckdb_logical_type type);
-	uint8_t (*duckdb_decimal_scale)(duckdb_logical_type type);
-	duckdb_type (*duckdb_decimal_internal_type)(duckdb_logical_type type);
-	duckdb_type (*duckdb_enum_internal_type)(duckdb_logical_type type);
-	uint32_t (*duckdb_enum_dictionary_size)(duckdb_logical_type type);
-	char *(*duckdb_enum_dictionary_value)(duckdb_logical_type type, idx_t index);
-	duckdb_logical_type (*duckdb_list_type_child_type)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_array_type_child_type)(duckdb_logical_type type);
-	idx_t (*duckdb_array_type_array_size)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_map_type_key_type)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_map_type_value_type)(duckdb_logical_type type);
-	idx_t (*duckdb_struct_type_child_count)(duckdb_logical_type type);
-	char *(*duckdb_struct_type_child_name)(duckdb_logical_type type, idx_t index);
-	duckdb_logical_type (*duckdb_struct_type_child_type)(duckdb_logical_type type, idx_t index);
-	idx_t (*duckdb_union_type_member_count)(duckdb_logical_type type);
-	char *(*duckdb_union_type_member_name)(duckdb_logical_type type, idx_t index);
-	duckdb_logical_type (*duckdb_union_type_member_type)(duckdb_logical_type type, idx_t index);
-	void (*duckdb_destroy_logical_type)(duckdb_logical_type *type);
-	duckdb_state (*duckdb_register_logical_type)(duckdb_connection con, duckdb_logical_type type,
-	                                             duckdb_create_type_info info);
-	duckdb_data_chunk (*duckdb_create_data_chunk)(duckdb_logical_type *types, idx_t column_count);
-	void (*duckdb_destroy_data_chunk)(duckdb_data_chunk *chunk);
-	void (*duckdb_data_chunk_reset)(duckdb_data_chunk chunk);
-	idx_t (*duckdb_data_chunk_get_column_count)(duckdb_data_chunk chunk);
-	duckdb_vector (*duckdb_data_chunk_get_vector)(duckdb_data_chunk chunk, idx_t col_idx);
-	idx_t (*duckdb_data_chunk_get_size)(duckdb_data_chunk chunk);
-	void (*duckdb_data_chunk_set_size)(duckdb_data_chunk chunk, idx_t size);
-	duckdb_logical_type (*duckdb_vector_get_column_type)(duckdb_vector vector);
-	void *(*duckdb_vector_get_data)(duckdb_vector vector);
-	uint64_t *(*duckdb_vector_get_validity)(duckdb_vector vector);
-	void (*duckdb_vector_ensure_validity_writable)(duckdb_vector vector);
-	void (*duckdb_vector_assign_string_element)(duckdb_vector vector, idx_t index, const char *str);
-	void (*duckdb_vector_assign_string_element_len)(duckdb_vector vector, idx_t index, const char *str, idx_t str_len);
-	duckdb_vector (*duckdb_list_vector_get_child)(duckdb_vector vector);
-	idx_t (*duckdb_list_vector_get_size)(duckdb_vector vector);
-	duckdb_state (*duckdb_list_vector_set_size)(duckdb_vector vector, idx_t size);
-	duckdb_state (*duckdb_list_vector_reserve)(duckdb_vector vector, idx_t required_capacity);
-	duckdb_vector (*duckdb_struct_vector_get_child)(duckdb_vector vector, idx_t index);
-	duckdb_vector (*duckdb_array_vector_get_child)(duckdb_vector vector);
-	bool (*duckdb_validity_row_is_valid)(uint64_t *validity, idx_t row);
-	void (*duckdb_validity_set_row_validity)(uint64_t *validity, idx_t row, bool valid);
-	void (*duckdb_validity_set_row_invalid)(uint64_t *validity, idx_t row);
-	void (*duckdb_validity_set_row_valid)(uint64_t *validity, idx_t row);
-	duckdb_scalar_function (*duckdb_create_scalar_function)();
-	void (*duckdb_destroy_scalar_function)(duckdb_scalar_function *scalar_function);
-	void (*duckdb_scalar_function_set_name)(duckdb_scalar_function scalar_function, const char *name);
-	void (*duckdb_scalar_function_set_varargs)(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-	void (*duckdb_scalar_function_set_special_handling)(duckdb_scalar_function scalar_function);
-	void (*duckdb_scalar_function_set_volatile)(duckdb_scalar_function scalar_function);
-	void (*duckdb_scalar_function_add_parameter)(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-	void (*duckdb_scalar_function_set_return_type)(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-	void (*duckdb_scalar_function_set_extra_info)(duckdb_scalar_function scalar_function, void *extra_info,
-	                                              duckdb_delete_callback_t destroy);
-	void (*duckdb_scalar_function_set_function)(duckdb_scalar_function scalar_function,
-	                                            duckdb_scalar_function_t function);
-	duckdb_state (*duckdb_register_scalar_function)(duckdb_connection con, duckdb_scalar_function scalar_function);
-	void *(*duckdb_scalar_function_get_extra_info)(duckdb_function_info info);
-	void (*duckdb_scalar_function_set_error)(duckdb_function_info info, const char *error);
-	duckdb_scalar_function_set (*duckdb_create_scalar_function_set)(const char *name);
-	void (*duckdb_destroy_scalar_function_set)(duckdb_scalar_function_set *scalar_function_set);
-	duckdb_state (*duckdb_add_scalar_function_to_set)(duckdb_scalar_function_set set, duckdb_scalar_function function);
-	duckdb_state (*duckdb_register_scalar_function_set)(duckdb_connection con, duckdb_scalar_function_set set);
-	duckdb_aggregate_function (*duckdb_create_aggregate_function)();
-	void (*duckdb_destroy_aggregate_function)(duckdb_aggregate_function *aggregate_function);
-	void (*duckdb_aggregate_function_set_name)(duckdb_aggregate_function aggregate_function, const char *name);
-	void (*duckdb_aggregate_function_add_parameter)(duckdb_aggregate_function aggregate_function,
-	                                                duckdb_logical_type type);
-	void (*duckdb_aggregate_function_set_return_type)(duckdb_aggregate_function aggregate_function,
-	                                                  duckdb_logical_type type);
-	void (*duckdb_aggregate_function_set_functions)(duckdb_aggregate_function aggregate_function,
-	                                                duckdb_aggregate_state_size state_size,
-	                                                duckdb_aggregate_init_t state_init,
-	                                                duckdb_aggregate_update_t update,
-	                                                duckdb_aggregate_combine_t combine,
-	                                                duckdb_aggregate_finalize_t finalize);
-	void (*duckdb_aggregate_function_set_destructor)(duckdb_aggregate_function aggregate_function,
-	                                                 duckdb_aggregate_destroy_t destroy);
-	duckdb_state (*duckdb_register_aggregate_function)(duckdb_connection con,
-	                                                   duckdb_aggregate_function aggregate_function);
-	void (*duckdb_aggregate_function_set_special_handling)(duckdb_aggregate_function aggregate_function);
-	void (*duckdb_aggregate_function_set_extra_info)(duckdb_aggregate_function aggregate_function, void *extra_info,
-	                                                 duckdb_delete_callback_t destroy);
-	void *(*duckdb_aggregate_function_get_extra_info)(duckdb_function_info info);
-	void (*duckdb_aggregate_function_set_error)(duckdb_function_info info, const char *error);
-	duckdb_aggregate_function_set (*duckdb_create_aggregate_function_set)(const char *name);
-	void (*duckdb_destroy_aggregate_function_set)(duckdb_aggregate_function_set *aggregate_function_set);
-	duckdb_state (*duckdb_add_aggregate_function_to_set)(duckdb_aggregate_function_set set,
-	                                                     duckdb_aggregate_function function);
-	duckdb_state (*duckdb_register_aggregate_function_set)(duckdb_connection con, duckdb_aggregate_function_set set);
-	duckdb_table_function (*duckdb_create_table_function)();
-	void (*duckdb_destroy_table_function)(duckdb_table_function *table_function);
-	void (*duckdb_table_function_set_name)(duckdb_table_function table_function, const char *name);
-	void (*duckdb_table_function_add_parameter)(duckdb_table_function table_function, duckdb_logical_type type);
-	void (*duckdb_table_function_add_named_parameter)(duckdb_table_function table_function, const char *name,
-	                                                  duckdb_logical_type type);
-	void (*duckdb_table_function_set_extra_info)(duckdb_table_function table_function, void *extra_info,
-	                                             duckdb_delete_callback_t destroy);
-	void (*duckdb_table_function_set_bind)(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
-	void (*duckdb_table_function_set_init)(duckdb_table_function table_function, duckdb_table_function_init_t init);
-	void (*duckdb_table_function_set_local_init)(duckdb_table_function table_function,
-	                                             duckdb_table_function_init_t init);
-	void (*duckdb_table_function_set_function)(duckdb_table_function table_function, duckdb_table_function_t function);
-	void (*duckdb_table_function_supports_projection_pushdown)(duckdb_table_function table_function, bool pushdown);
-	duckdb_state (*duckdb_register_table_function)(duckdb_connection con, duckdb_table_function function);
-	void *(*duckdb_bind_get_extra_info)(duckdb_bind_info info);
-	void (*duckdb_bind_add_result_column)(duckdb_bind_info info, const char *name, duckdb_logical_type type);
-	idx_t (*duckdb_bind_get_parameter_count)(duckdb_bind_info info);
-	duckdb_value (*duckdb_bind_get_parameter)(duckdb_bind_info info, idx_t index);
-	duckdb_value (*duckdb_bind_get_named_parameter)(duckdb_bind_info info, const char *name);
-	void (*duckdb_bind_set_bind_data)(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
-	void (*duckdb_bind_set_cardinality)(duckdb_bind_info info, idx_t cardinality, bool is_exact);
-	void (*duckdb_bind_set_error)(duckdb_bind_info info, const char *error);
-	void *(*duckdb_init_get_extra_info)(duckdb_init_info info);
-	void *(*duckdb_init_get_bind_data)(duckdb_init_info info);
-	void (*duckdb_init_set_init_data)(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
-	idx_t (*duckdb_init_get_column_count)(duckdb_init_info info);
-	idx_t (*duckdb_init_get_column_index)(duckdb_init_info info, idx_t column_index);
-	void (*duckdb_init_set_max_threads)(duckdb_init_info info, idx_t max_threads);
-	void (*duckdb_init_set_error)(duckdb_init_info info, const char *error);
-	void *(*duckdb_function_get_extra_info)(duckdb_function_info info);
-	void *(*duckdb_function_get_bind_data)(duckdb_function_info info);
-	void *(*duckdb_function_get_init_data)(duckdb_function_info info);
-	void *(*duckdb_function_get_local_init_data)(duckdb_function_info info);
-	void (*duckdb_function_set_error)(duckdb_function_info info, const char *error);
-	void (*duckdb_add_replacement_scan)(duckdb_database db, duckdb_replacement_callback_t replacement, void *extra_data,
-	                                    duckdb_delete_callback_t delete_callback);
-	void (*duckdb_replacement_scan_set_function_name)(duckdb_replacement_scan_info info, const char *function_name);
-	void (*duckdb_replacement_scan_add_parameter)(duckdb_replacement_scan_info info, duckdb_value parameter);
-	void (*duckdb_replacement_scan_set_error)(duckdb_replacement_scan_info info, const char *error);
-	duckdb_value (*duckdb_profiling_info_get_metrics)(duckdb_profiling_info info);
-	idx_t (*duckdb_profiling_info_get_child_count)(duckdb_profiling_info info);
-	duckdb_profiling_info (*duckdb_profiling_info_get_child)(duckdb_profiling_info info, idx_t index);
-	duckdb_state (*duckdb_appender_create)(duckdb_connection connection, const char *schema, const char *table,
-	                                       duckdb_appender *out_appender);
-	duckdb_state (*duckdb_appender_create_ext)(duckdb_connection connection, const char *catalog, const char *schema,
-	                                           const char *table, duckdb_appender *out_appender);
-	idx_t (*duckdb_appender_column_count)(duckdb_appender appender);
-	duckdb_logical_type (*duckdb_appender_column_type)(duckdb_appender appender, idx_t col_idx);
-	const char *(*duckdb_appender_error)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_flush)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_close)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_destroy)(duckdb_appender *appender);
-	duckdb_state (*duckdb_appender_add_column)(duckdb_appender appender, const char *name);
-	duckdb_state (*duckdb_appender_clear_columns)(duckdb_appender appender);
-	duckdb_state (*duckdb_append_data_chunk)(duckdb_appender appender, duckdb_data_chunk chunk);
-	duckdb_state (*duckdb_table_description_create)(duckdb_connection connection, const char *schema, const char *table,
-	                                                duckdb_table_description *out);
-	duckdb_state (*duckdb_table_description_create_ext)(duckdb_connection connection, const char *catalog,
-	                                                    const char *schema, const char *table,
-	                                                    duckdb_table_description *out);
-	void (*duckdb_table_description_destroy)(duckdb_table_description *table_description);
-	const char *(*duckdb_table_description_error)(duckdb_table_description table_description);
-	duckdb_state (*duckdb_column_has_default)(duckdb_table_description table_description, idx_t index, bool *out);
-	char *(*duckdb_table_description_get_column_name)(duckdb_table_description table_description, idx_t index);
-	void (*duckdb_execute_tasks)(duckdb_database database, idx_t max_tasks);
-	duckdb_task_state (*duckdb_create_task_state)(duckdb_database database);
-	void (*duckdb_execute_tasks_state)(duckdb_task_state state);
-	idx_t (*duckdb_execute_n_tasks_state)(duckdb_task_state state, idx_t max_tasks);
-	void (*duckdb_finish_execution)(duckdb_task_state state);
-	bool (*duckdb_task_state_is_finished)(duckdb_task_state state);
-	void (*duckdb_destroy_task_state)(duckdb_task_state state);
-	bool (*duckdb_execution_is_finished)(duckdb_connection con);
-	duckdb_data_chunk (*duckdb_fetch_chunk)(duckdb_result result);
-	duckdb_cast_function (*duckdb_create_cast_function)();
-	void (*duckdb_cast_function_set_source_type)(duckdb_cast_function cast_function, duckdb_logical_type source_type);
-	void (*duckdb_cast_function_set_target_type)(duckdb_cast_function cast_function, duckdb_logical_type target_type);
-	void (*duckdb_cast_function_set_implicit_cast_cost)(duckdb_cast_function cast_function, int64_t cost);
-	void (*duckdb_cast_function_set_function)(duckdb_cast_function cast_function, duckdb_cast_function_t function);
-	void (*duckdb_cast_function_set_extra_info)(duckdb_cast_function cast_function, void *extra_info,
-	                                            duckdb_delete_callback_t destroy);
-	void *(*duckdb_cast_function_get_extra_info)(duckdb_function_info info);
-	duckdb_cast_mode (*duckdb_cast_function_get_cast_mode)(duckdb_function_info info);
-	void (*duckdb_cast_function_set_error)(duckdb_function_info info, const char *error);
-	void (*duckdb_cast_function_set_row_error)(duckdb_function_info info, const char *error, idx_t row,
-	                                           duckdb_vector output);
-	duckdb_state (*duckdb_register_cast_function)(duckdb_connection con, duckdb_cast_function cast_function);
-	void (*duckdb_destroy_cast_function)(duckdb_cast_function *cast_function);
-	bool (*duckdb_is_finite_timestamp_s)(duckdb_timestamp_s ts);
-	bool (*duckdb_is_finite_timestamp_ms)(duckdb_timestamp_ms ts);
-	bool (*duckdb_is_finite_timestamp_ns)(duckdb_timestamp_ns ts);
-	duckdb_value (*duckdb_create_timestamp_tz)(duckdb_timestamp input);
-	duckdb_value (*duckdb_create_timestamp_s)(duckdb_timestamp_s input);
-	duckdb_value (*duckdb_create_timestamp_ms)(duckdb_timestamp_ms input);
-	duckdb_value (*duckdb_create_timestamp_ns)(duckdb_timestamp_ns input);
-	duckdb_timestamp (*duckdb_get_timestamp_tz)(duckdb_value val);
-	duckdb_timestamp_s (*duckdb_get_timestamp_s)(duckdb_value val);
-	duckdb_timestamp_ms (*duckdb_get_timestamp_ms)(duckdb_value val);
-	duckdb_timestamp_ns (*duckdb_get_timestamp_ns)(duckdb_value val);
-	duckdb_state (*duckdb_append_value)(duckdb_appender appender, duckdb_value value);
-	duckdb_profiling_info (*duckdb_get_profiling_info)(duckdb_connection connection);
-	duckdb_value (*duckdb_profiling_info_get_value)(duckdb_profiling_info info, const char *key);
-	duckdb_state (*duckdb_appender_begin_row)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_end_row)(duckdb_appender appender);
-	duckdb_state (*duckdb_append_default)(duckdb_appender appender);
-	duckdb_state (*duckdb_append_bool)(duckdb_appender appender, bool value);
-	duckdb_state (*duckdb_append_int8)(duckdb_appender appender, int8_t value);
-	duckdb_state (*duckdb_append_int16)(duckdb_appender appender, int16_t value);
-	duckdb_state (*duckdb_append_int32)(duckdb_appender appender, int32_t value);
-	duckdb_state (*duckdb_append_int64)(duckdb_appender appender, int64_t value);
-	duckdb_state (*duckdb_append_hugeint)(duckdb_appender appender, duckdb_hugeint value);
-	duckdb_state (*duckdb_append_uint8)(duckdb_appender appender, uint8_t value);
-	duckdb_state (*duckdb_append_uint16)(duckdb_appender appender, uint16_t value);
-	duckdb_state (*duckdb_append_uint32)(duckdb_appender appender, uint32_t value);
-	duckdb_state (*duckdb_append_uint64)(duckdb_appender appender, uint64_t value);
-	duckdb_state (*duckdb_append_uhugeint)(duckdb_appender appender, duckdb_uhugeint value);
-	duckdb_state (*duckdb_append_float)(duckdb_appender appender, float value);
-	duckdb_state (*duckdb_append_double)(duckdb_appender appender, double value);
-	duckdb_state (*duckdb_append_date)(duckdb_appender appender, duckdb_date value);
-	duckdb_state (*duckdb_append_time)(duckdb_appender appender, duckdb_time value);
-	duckdb_state (*duckdb_append_timestamp)(duckdb_appender appender, duckdb_timestamp value);
-	duckdb_state (*duckdb_append_interval)(duckdb_appender appender, duckdb_interval value);
-	duckdb_state (*duckdb_append_varchar)(duckdb_appender appender, const char *val);
-	duckdb_state (*duckdb_append_varchar_length)(duckdb_appender appender, const char *val, idx_t length);
-	duckdb_state (*duckdb_append_blob)(duckdb_appender appender, const void *data, idx_t length);
-	duckdb_state (*duckdb_append_null)(duckdb_appender appender);
-	// These functions have been deprecated and may be removed in future versions of DuckDB
-
-	idx_t (*duckdb_row_count)(duckdb_result *result);
-	void *(*duckdb_column_data)(duckdb_result *result, idx_t col);
-	bool *(*duckdb_nullmask_data)(duckdb_result *result, idx_t col);
-	duckdb_data_chunk (*duckdb_result_get_chunk)(duckdb_result result, idx_t chunk_index);
-	bool (*duckdb_result_is_streaming)(duckdb_result result);
-	idx_t (*duckdb_result_chunk_count)(duckdb_result result);
-	bool (*duckdb_value_boolean)(duckdb_result *result, idx_t col, idx_t row);
-	int8_t (*duckdb_value_int8)(duckdb_result *result, idx_t col, idx_t row);
-	int16_t (*duckdb_value_int16)(duckdb_result *result, idx_t col, idx_t row);
-	int32_t (*duckdb_value_int32)(duckdb_result *result, idx_t col, idx_t row);
-	int64_t (*duckdb_value_int64)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_hugeint (*duckdb_value_hugeint)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_uhugeint (*duckdb_value_uhugeint)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_decimal (*duckdb_value_decimal)(duckdb_result *result, idx_t col, idx_t row);
-	uint8_t (*duckdb_value_uint8)(duckdb_result *result, idx_t col, idx_t row);
-	uint16_t (*duckdb_value_uint16)(duckdb_result *result, idx_t col, idx_t row);
-	uint32_t (*duckdb_value_uint32)(duckdb_result *result, idx_t col, idx_t row);
-	uint64_t (*duckdb_value_uint64)(duckdb_result *result, idx_t col, idx_t row);
-	float (*duckdb_value_float)(duckdb_result *result, idx_t col, idx_t row);
-	double (*duckdb_value_double)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_date (*duckdb_value_date)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_time (*duckdb_value_time)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_timestamp (*duckdb_value_timestamp)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_interval (*duckdb_value_interval)(duckdb_result *result, idx_t col, idx_t row);
-	char *(*duckdb_value_varchar)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_string (*duckdb_value_string)(duckdb_result *result, idx_t col, idx_t row);
-	char *(*duckdb_value_varchar_internal)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_string (*duckdb_value_string_internal)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_blob (*duckdb_value_blob)(duckdb_result *result, idx_t col, idx_t row);
-	bool (*duckdb_value_is_null)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_state (*duckdb_execute_prepared_streaming)(duckdb_prepared_statement prepared_statement,
-	                                                  duckdb_result *out_result);
-	duckdb_state (*duckdb_pending_prepared_streaming)(duckdb_prepared_statement prepared_statement,
-	                                                  duckdb_pending_result *out_result);
-	duckdb_state (*duckdb_query_arrow)(duckdb_connection connection, const char *query, duckdb_arrow *out_result);
-	duckdb_state (*duckdb_query_arrow_schema)(duckdb_arrow result, duckdb_arrow_schema *out_schema);
-	duckdb_state (*duckdb_prepared_arrow_schema)(duckdb_prepared_statement prepared, duckdb_arrow_schema *out_schema);
-	void (*duckdb_result_arrow_array)(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array);
-	duckdb_state (*duckdb_query_arrow_array)(duckdb_arrow result, duckdb_arrow_array *out_array);
-	idx_t (*duckdb_arrow_column_count)(duckdb_arrow result);
-	idx_t (*duckdb_arrow_row_count)(duckdb_arrow result);
-	idx_t (*duckdb_arrow_rows_changed)(duckdb_arrow result);
-	const char *(*duckdb_query_arrow_error)(duckdb_arrow result);
-	void (*duckdb_destroy_arrow)(duckdb_arrow *result);
-	void (*duckdb_destroy_arrow_stream)(duckdb_arrow_stream *stream_p);
-	duckdb_state (*duckdb_execute_prepared_arrow)(duckdb_prepared_statement prepared_statement,
-	                                              duckdb_arrow *out_result);
-	duckdb_state (*duckdb_arrow_scan)(duckdb_connection connection, const char *table_name, duckdb_arrow_stream arrow);
-	duckdb_state (*duckdb_arrow_array_scan)(duckdb_connection connection, const char *table_name,
-	                                        duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
-	                                        duckdb_arrow_stream *out_stream);
-	duckdb_data_chunk (*duckdb_stream_fetch_chunk)(duckdb_result result);
-	// Exposing the instance cache
-
-	duckdb_instance_cache (*duckdb_create_instance_cache)();
-	duckdb_state (*duckdb_get_or_create_from_cache)(duckdb_instance_cache instance_cache, const char *path,
-	                                                duckdb_database *out_database, duckdb_config config,
-	                                                char **out_error);
-	void (*duckdb_destroy_instance_cache)(duckdb_instance_cache *instance_cache);
-	// New append functions that are added
-
-	duckdb_state (*duckdb_append_default_to_chunk)(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col,
-	                                               idx_t row);
-} duckdb_ext_api_v1;
-
-//===--------------------------------------------------------------------===//
-// Struct Create Method
-//===--------------------------------------------------------------------===//
-inline duckdb_ext_api_v1 CreateAPIv1() {
-	duckdb_ext_api_v1 result;
-	result.duckdb_open = duckdb_open;
-	result.duckdb_open_ext = duckdb_open_ext;
-	result.duckdb_close = duckdb_close;
-	result.duckdb_connect = duckdb_connect;
-	result.duckdb_interrupt = duckdb_interrupt;
-	result.duckdb_query_progress = duckdb_query_progress;
-	result.duckdb_disconnect = duckdb_disconnect;
-	result.duckdb_library_version = duckdb_library_version;
-	result.duckdb_create_config = duckdb_create_config;
-	result.duckdb_config_count = duckdb_config_count;
-	result.duckdb_get_config_flag = duckdb_get_config_flag;
-	result.duckdb_set_config = duckdb_set_config;
-	result.duckdb_destroy_config = duckdb_destroy_config;
-	result.duckdb_query = duckdb_query;
-	result.duckdb_destroy_result = duckdb_destroy_result;
-	result.duckdb_column_name = duckdb_column_name;
-	result.duckdb_column_type = duckdb_column_type;
-	result.duckdb_result_statement_type = duckdb_result_statement_type;
-	result.duckdb_column_logical_type = duckdb_column_logical_type;
-	result.duckdb_column_count = duckdb_column_count;
-	result.duckdb_rows_changed = duckdb_rows_changed;
-	result.duckdb_result_error = duckdb_result_error;
-	result.duckdb_result_error_type = duckdb_result_error_type;
-	result.duckdb_result_return_type = duckdb_result_return_type;
-	result.duckdb_malloc = duckdb_malloc;
-	result.duckdb_free = duckdb_free;
-	result.duckdb_vector_size = duckdb_vector_size;
-	result.duckdb_string_is_inlined = duckdb_string_is_inlined;
-	result.duckdb_string_t_length = duckdb_string_t_length;
-	result.duckdb_string_t_data = duckdb_string_t_data;
-	result.duckdb_from_date = duckdb_from_date;
-	result.duckdb_to_date = duckdb_to_date;
-	result.duckdb_is_finite_date = duckdb_is_finite_date;
-	result.duckdb_from_time = duckdb_from_time;
-	result.duckdb_create_time_tz = duckdb_create_time_tz;
-	result.duckdb_from_time_tz = duckdb_from_time_tz;
-	result.duckdb_to_time = duckdb_to_time;
-	result.duckdb_from_timestamp = duckdb_from_timestamp;
-	result.duckdb_to_timestamp = duckdb_to_timestamp;
-	result.duckdb_is_finite_timestamp = duckdb_is_finite_timestamp;
-	result.duckdb_hugeint_to_double = duckdb_hugeint_to_double;
-	result.duckdb_double_to_hugeint = duckdb_double_to_hugeint;
-	result.duckdb_uhugeint_to_double = duckdb_uhugeint_to_double;
-	result.duckdb_double_to_uhugeint = duckdb_double_to_uhugeint;
-	result.duckdb_double_to_decimal = duckdb_double_to_decimal;
-	result.duckdb_decimal_to_double = duckdb_decimal_to_double;
-	result.duckdb_prepare = duckdb_prepare;
-	result.duckdb_destroy_prepare = duckdb_destroy_prepare;
-	result.duckdb_prepare_error = duckdb_prepare_error;
-	result.duckdb_nparams = duckdb_nparams;
-	result.duckdb_parameter_name = duckdb_parameter_name;
-	result.duckdb_param_type = duckdb_param_type;
-	result.duckdb_param_logical_type = duckdb_param_logical_type;
-	result.duckdb_clear_bindings = duckdb_clear_bindings;
-	result.duckdb_prepared_statement_type = duckdb_prepared_statement_type;
-	result.duckdb_bind_value = duckdb_bind_value;
-	result.duckdb_bind_parameter_index = duckdb_bind_parameter_index;
-	result.duckdb_bind_boolean = duckdb_bind_boolean;
-	result.duckdb_bind_int8 = duckdb_bind_int8;
-	result.duckdb_bind_int16 = duckdb_bind_int16;
-	result.duckdb_bind_int32 = duckdb_bind_int32;
-	result.duckdb_bind_int64 = duckdb_bind_int64;
-	result.duckdb_bind_hugeint = duckdb_bind_hugeint;
-	result.duckdb_bind_uhugeint = duckdb_bind_uhugeint;
-	result.duckdb_bind_decimal = duckdb_bind_decimal;
-	result.duckdb_bind_uint8 = duckdb_bind_uint8;
-	result.duckdb_bind_uint16 = duckdb_bind_uint16;
-	result.duckdb_bind_uint32 = duckdb_bind_uint32;
-	result.duckdb_bind_uint64 = duckdb_bind_uint64;
-	result.duckdb_bind_float = duckdb_bind_float;
-	result.duckdb_bind_double = duckdb_bind_double;
-	result.duckdb_bind_date = duckdb_bind_date;
-	result.duckdb_bind_time = duckdb_bind_time;
-	result.duckdb_bind_timestamp = duckdb_bind_timestamp;
-	result.duckdb_bind_timestamp_tz = duckdb_bind_timestamp_tz;
-	result.duckdb_bind_interval = duckdb_bind_interval;
-	result.duckdb_bind_varchar = duckdb_bind_varchar;
-	result.duckdb_bind_varchar_length = duckdb_bind_varchar_length;
-	result.duckdb_bind_blob = duckdb_bind_blob;
-	result.duckdb_bind_null = duckdb_bind_null;
-	result.duckdb_execute_prepared = duckdb_execute_prepared;
-	result.duckdb_extract_statements = duckdb_extract_statements;
-	result.duckdb_prepare_extracted_statement = duckdb_prepare_extracted_statement;
-	result.duckdb_extract_statements_error = duckdb_extract_statements_error;
-	result.duckdb_destroy_extracted = duckdb_destroy_extracted;
-	result.duckdb_pending_prepared = duckdb_pending_prepared;
-	result.duckdb_destroy_pending = duckdb_destroy_pending;
-	result.duckdb_pending_error = duckdb_pending_error;
-	result.duckdb_pending_execute_task = duckdb_pending_execute_task;
-	result.duckdb_pending_execute_check_state = duckdb_pending_execute_check_state;
-	result.duckdb_execute_pending = duckdb_execute_pending;
-	result.duckdb_pending_execution_is_finished = duckdb_pending_execution_is_finished;
-	result.duckdb_destroy_value = duckdb_destroy_value;
-	result.duckdb_create_varchar = duckdb_create_varchar;
-	result.duckdb_create_varchar_length = duckdb_create_varchar_length;
-	result.duckdb_create_bool = duckdb_create_bool;
-	result.duckdb_create_int8 = duckdb_create_int8;
-	result.duckdb_create_uint8 = duckdb_create_uint8;
-	result.duckdb_create_int16 = duckdb_create_int16;
-	result.duckdb_create_uint16 = duckdb_create_uint16;
-	result.duckdb_create_int32 = duckdb_create_int32;
-	result.duckdb_create_uint32 = duckdb_create_uint32;
-	result.duckdb_create_uint64 = duckdb_create_uint64;
-	result.duckdb_create_int64 = duckdb_create_int64;
-	result.duckdb_create_hugeint = duckdb_create_hugeint;
-	result.duckdb_create_uhugeint = duckdb_create_uhugeint;
-	result.duckdb_create_float = duckdb_create_float;
-	result.duckdb_create_double = duckdb_create_double;
-	result.duckdb_create_date = duckdb_create_date;
-	result.duckdb_create_time = duckdb_create_time;
-	result.duckdb_create_time_tz_value = duckdb_create_time_tz_value;
-	result.duckdb_create_timestamp = duckdb_create_timestamp;
-	result.duckdb_create_interval = duckdb_create_interval;
-	result.duckdb_create_blob = duckdb_create_blob;
-	result.duckdb_create_varint = duckdb_create_varint;
-	result.duckdb_create_decimal = duckdb_create_decimal;
-	result.duckdb_create_bit = duckdb_create_bit;
-	result.duckdb_create_uuid = duckdb_create_uuid;
-	result.duckdb_get_bool = duckdb_get_bool;
-	result.duckdb_get_int8 = duckdb_get_int8;
-	result.duckdb_get_uint8 = duckdb_get_uint8;
-	result.duckdb_get_int16 = duckdb_get_int16;
-	result.duckdb_get_uint16 = duckdb_get_uint16;
-	result.duckdb_get_int32 = duckdb_get_int32;
-	result.duckdb_get_uint32 = duckdb_get_uint32;
-	result.duckdb_get_int64 = duckdb_get_int64;
-	result.duckdb_get_uint64 = duckdb_get_uint64;
-	result.duckdb_get_hugeint = duckdb_get_hugeint;
-	result.duckdb_get_uhugeint = duckdb_get_uhugeint;
-	result.duckdb_get_float = duckdb_get_float;
-	result.duckdb_get_double = duckdb_get_double;
-	result.duckdb_get_date = duckdb_get_date;
-	result.duckdb_get_time = duckdb_get_time;
-	result.duckdb_get_time_tz = duckdb_get_time_tz;
-	result.duckdb_get_timestamp = duckdb_get_timestamp;
-	result.duckdb_get_interval = duckdb_get_interval;
-	result.duckdb_get_value_type = duckdb_get_value_type;
-	result.duckdb_get_blob = duckdb_get_blob;
-	result.duckdb_get_varint = duckdb_get_varint;
-	result.duckdb_get_decimal = duckdb_get_decimal;
-	result.duckdb_get_bit = duckdb_get_bit;
-	result.duckdb_get_uuid = duckdb_get_uuid;
-	result.duckdb_get_varchar = duckdb_get_varchar;
-	result.duckdb_create_struct_value = duckdb_create_struct_value;
-	result.duckdb_create_list_value = duckdb_create_list_value;
-	result.duckdb_create_array_value = duckdb_create_array_value;
-	result.duckdb_get_map_size = duckdb_get_map_size;
-	result.duckdb_get_map_key = duckdb_get_map_key;
-	result.duckdb_get_map_value = duckdb_get_map_value;
-	result.duckdb_is_null_value = duckdb_is_null_value;
-	result.duckdb_create_null_value = duckdb_create_null_value;
-	result.duckdb_get_list_size = duckdb_get_list_size;
-	result.duckdb_get_list_child = duckdb_get_list_child;
-	result.duckdb_create_enum_value = duckdb_create_enum_value;
-	result.duckdb_get_enum_value = duckdb_get_enum_value;
-	result.duckdb_get_struct_child = duckdb_get_struct_child;
-	result.duckdb_create_logical_type = duckdb_create_logical_type;
-	result.duckdb_logical_type_get_alias = duckdb_logical_type_get_alias;
-	result.duckdb_logical_type_set_alias = duckdb_logical_type_set_alias;
-	result.duckdb_create_list_type = duckdb_create_list_type;
-	result.duckdb_create_array_type = duckdb_create_array_type;
-	result.duckdb_create_map_type = duckdb_create_map_type;
-	result.duckdb_create_union_type = duckdb_create_union_type;
-	result.duckdb_create_struct_type = duckdb_create_struct_type;
-	result.duckdb_create_enum_type = duckdb_create_enum_type;
-	result.duckdb_create_decimal_type = duckdb_create_decimal_type;
-	result.duckdb_get_type_id = duckdb_get_type_id;
-	result.duckdb_decimal_width = duckdb_decimal_width;
-	result.duckdb_decimal_scale = duckdb_decimal_scale;
-	result.duckdb_decimal_internal_type = duckdb_decimal_internal_type;
-	result.duckdb_enum_internal_type = duckdb_enum_internal_type;
-	result.duckdb_enum_dictionary_size = duckdb_enum_dictionary_size;
-	result.duckdb_enum_dictionary_value = duckdb_enum_dictionary_value;
-	result.duckdb_list_type_child_type = duckdb_list_type_child_type;
-	result.duckdb_array_type_child_type = duckdb_array_type_child_type;
-	result.duckdb_array_type_array_size = duckdb_array_type_array_size;
-	result.duckdb_map_type_key_type = duckdb_map_type_key_type;
-	result.duckdb_map_type_value_type = duckdb_map_type_value_type;
-	result.duckdb_struct_type_child_count = duckdb_struct_type_child_count;
-	result.duckdb_struct_type_child_name = duckdb_struct_type_child_name;
-	result.duckdb_struct_type_child_type = duckdb_struct_type_child_type;
-	result.duckdb_union_type_member_count = duckdb_union_type_member_count;
-	result.duckdb_union_type_member_name = duckdb_union_type_member_name;
-	result.duckdb_union_type_member_type = duckdb_union_type_member_type;
-	result.duckdb_destroy_logical_type = duckdb_destroy_logical_type;
-	result.duckdb_register_logical_type = duckdb_register_logical_type;
-	result.duckdb_create_data_chunk = duckdb_create_data_chunk;
-	result.duckdb_destroy_data_chunk = duckdb_destroy_data_chunk;
-	result.duckdb_data_chunk_reset = duckdb_data_chunk_reset;
-	result.duckdb_data_chunk_get_column_count = duckdb_data_chunk_get_column_count;
-	result.duckdb_data_chunk_get_vector = duckdb_data_chunk_get_vector;
-	result.duckdb_data_chunk_get_size = duckdb_data_chunk_get_size;
-	result.duckdb_data_chunk_set_size = duckdb_data_chunk_set_size;
-	result.duckdb_vector_get_column_type = duckdb_vector_get_column_type;
-	result.duckdb_vector_get_data = duckdb_vector_get_data;
-	result.duckdb_vector_get_validity = duckdb_vector_get_validity;
-	result.duckdb_vector_ensure_validity_writable = duckdb_vector_ensure_validity_writable;
-	result.duckdb_vector_assign_string_element = duckdb_vector_assign_string_element;
-	result.duckdb_vector_assign_string_element_len = duckdb_vector_assign_string_element_len;
-	result.duckdb_list_vector_get_child = duckdb_list_vector_get_child;
-	result.duckdb_list_vector_get_size = duckdb_list_vector_get_size;
-	result.duckdb_list_vector_set_size = duckdb_list_vector_set_size;
-	result.duckdb_list_vector_reserve = duckdb_list_vector_reserve;
-	result.duckdb_struct_vector_get_child = duckdb_struct_vector_get_child;
-	result.duckdb_array_vector_get_child = duckdb_array_vector_get_child;
-	result.duckdb_validity_row_is_valid = duckdb_validity_row_is_valid;
-	result.duckdb_validity_set_row_validity = duckdb_validity_set_row_validity;
-	result.duckdb_validity_set_row_invalid = duckdb_validity_set_row_invalid;
-	result.duckdb_validity_set_row_valid = duckdb_validity_set_row_valid;
-	result.duckdb_create_scalar_function = duckdb_create_scalar_function;
-	result.duckdb_destroy_scalar_function = duckdb_destroy_scalar_function;
-	result.duckdb_scalar_function_set_name = duckdb_scalar_function_set_name;
-	result.duckdb_scalar_function_set_varargs = duckdb_scalar_function_set_varargs;
-	result.duckdb_scalar_function_set_special_handling = duckdb_scalar_function_set_special_handling;
-	result.duckdb_scalar_function_set_volatile = duckdb_scalar_function_set_volatile;
-	result.duckdb_scalar_function_add_parameter = duckdb_scalar_function_add_parameter;
-	result.duckdb_scalar_function_set_return_type = duckdb_scalar_function_set_return_type;
-	result.duckdb_scalar_function_set_extra_info = duckdb_scalar_function_set_extra_info;
-	result.duckdb_scalar_function_set_function = duckdb_scalar_function_set_function;
-	result.duckdb_register_scalar_function = duckdb_register_scalar_function;
-	result.duckdb_scalar_function_get_extra_info = duckdb_scalar_function_get_extra_info;
-	result.duckdb_scalar_function_set_error = duckdb_scalar_function_set_error;
-	result.duckdb_create_scalar_function_set = duckdb_create_scalar_function_set;
-	result.duckdb_destroy_scalar_function_set = duckdb_destroy_scalar_function_set;
-	result.duckdb_add_scalar_function_to_set = duckdb_add_scalar_function_to_set;
-	result.duckdb_register_scalar_function_set = duckdb_register_scalar_function_set;
-	result.duckdb_create_aggregate_function = duckdb_create_aggregate_function;
-	result.duckdb_destroy_aggregate_function = duckdb_destroy_aggregate_function;
-	result.duckdb_aggregate_function_set_name = duckdb_aggregate_function_set_name;
-	result.duckdb_aggregate_function_add_parameter = duckdb_aggregate_function_add_parameter;
-	result.duckdb_aggregate_function_set_return_type = duckdb_aggregate_function_set_return_type;
-	result.duckdb_aggregate_function_set_functions = duckdb_aggregate_function_set_functions;
-	result.duckdb_aggregate_function_set_destructor = duckdb_aggregate_function_set_destructor;
-	result.duckdb_register_aggregate_function = duckdb_register_aggregate_function;
-	result.duckdb_aggregate_function_set_special_handling = duckdb_aggregate_function_set_special_handling;
-	result.duckdb_aggregate_function_set_extra_info = duckdb_aggregate_function_set_extra_info;
-	result.duckdb_aggregate_function_get_extra_info = duckdb_aggregate_function_get_extra_info;
-	result.duckdb_aggregate_function_set_error = duckdb_aggregate_function_set_error;
-	result.duckdb_create_aggregate_function_set = duckdb_create_aggregate_function_set;
-	result.duckdb_destroy_aggregate_function_set = duckdb_destroy_aggregate_function_set;
-	result.duckdb_add_aggregate_function_to_set = duckdb_add_aggregate_function_to_set;
-	result.duckdb_register_aggregate_function_set = duckdb_register_aggregate_function_set;
-	result.duckdb_create_table_function = duckdb_create_table_function;
-	result.duckdb_destroy_table_function = duckdb_destroy_table_function;
-	result.duckdb_table_function_set_name = duckdb_table_function_set_name;
-	result.duckdb_table_function_add_parameter = duckdb_table_function_add_parameter;
-	result.duckdb_table_function_add_named_parameter = duckdb_table_function_add_named_parameter;
-	result.duckdb_table_function_set_extra_info = duckdb_table_function_set_extra_info;
-	result.duckdb_table_function_set_bind = duckdb_table_function_set_bind;
-	result.duckdb_table_function_set_init = duckdb_table_function_set_init;
-	result.duckdb_table_function_set_local_init = duckdb_table_function_set_local_init;
-	result.duckdb_table_function_set_function = duckdb_table_function_set_function;
-	result.duckdb_table_function_supports_projection_pushdown = duckdb_table_function_supports_projection_pushdown;
-	result.duckdb_register_table_function = duckdb_register_table_function;
-	result.duckdb_bind_get_extra_info = duckdb_bind_get_extra_info;
-	result.duckdb_bind_add_result_column = duckdb_bind_add_result_column;
-	result.duckdb_bind_get_parameter_count = duckdb_bind_get_parameter_count;
-	result.duckdb_bind_get_parameter = duckdb_bind_get_parameter;
-	result.duckdb_bind_get_named_parameter = duckdb_bind_get_named_parameter;
-	result.duckdb_bind_set_bind_data = duckdb_bind_set_bind_data;
-	result.duckdb_bind_set_cardinality = duckdb_bind_set_cardinality;
-	result.duckdb_bind_set_error = duckdb_bind_set_error;
-	result.duckdb_init_get_extra_info = duckdb_init_get_extra_info;
-	result.duckdb_init_get_bind_data = duckdb_init_get_bind_data;
-	result.duckdb_init_set_init_data = duckdb_init_set_init_data;
-	result.duckdb_init_get_column_count = duckdb_init_get_column_count;
-	result.duckdb_init_get_column_index = duckdb_init_get_column_index;
-	result.duckdb_init_set_max_threads = duckdb_init_set_max_threads;
-	result.duckdb_init_set_error = duckdb_init_set_error;
-	result.duckdb_function_get_extra_info = duckdb_function_get_extra_info;
-	result.duckdb_function_get_bind_data = duckdb_function_get_bind_data;
-	result.duckdb_function_get_init_data = duckdb_function_get_init_data;
-	result.duckdb_function_get_local_init_data = duckdb_function_get_local_init_data;
-	result.duckdb_function_set_error = duckdb_function_set_error;
-	result.duckdb_add_replacement_scan = duckdb_add_replacement_scan;
-	result.duckdb_replacement_scan_set_function_name = duckdb_replacement_scan_set_function_name;
-	result.duckdb_replacement_scan_add_parameter = duckdb_replacement_scan_add_parameter;
-	result.duckdb_replacement_scan_set_error = duckdb_replacement_scan_set_error;
-	result.duckdb_profiling_info_get_metrics = duckdb_profiling_info_get_metrics;
-	result.duckdb_profiling_info_get_child_count = duckdb_profiling_info_get_child_count;
-	result.duckdb_profiling_info_get_child = duckdb_profiling_info_get_child;
-	result.duckdb_appender_create = duckdb_appender_create;
-	result.duckdb_appender_create_ext = duckdb_appender_create_ext;
-	result.duckdb_appender_column_count = duckdb_appender_column_count;
-	result.duckdb_appender_column_type = duckdb_appender_column_type;
-	result.duckdb_appender_error = duckdb_appender_error;
-	result.duckdb_appender_flush = duckdb_appender_flush;
-	result.duckdb_appender_close = duckdb_appender_close;
-	result.duckdb_appender_destroy = duckdb_appender_destroy;
-	result.duckdb_appender_add_column = duckdb_appender_add_column;
-	result.duckdb_appender_clear_columns = duckdb_appender_clear_columns;
-	result.duckdb_append_data_chunk = duckdb_append_data_chunk;
-	result.duckdb_table_description_create = duckdb_table_description_create;
-	result.duckdb_table_description_create_ext = duckdb_table_description_create_ext;
-	result.duckdb_table_description_destroy = duckdb_table_description_destroy;
-	result.duckdb_table_description_error = duckdb_table_description_error;
-	result.duckdb_column_has_default = duckdb_column_has_default;
-	result.duckdb_table_description_get_column_name = duckdb_table_description_get_column_name;
-	result.duckdb_execute_tasks = duckdb_execute_tasks;
-	result.duckdb_create_task_state = duckdb_create_task_state;
-	result.duckdb_execute_tasks_state = duckdb_execute_tasks_state;
-	result.duckdb_execute_n_tasks_state = duckdb_execute_n_tasks_state;
-	result.duckdb_finish_execution = duckdb_finish_execution;
-	result.duckdb_task_state_is_finished = duckdb_task_state_is_finished;
-	result.duckdb_destroy_task_state = duckdb_destroy_task_state;
-	result.duckdb_execution_is_finished = duckdb_execution_is_finished;
-	result.duckdb_fetch_chunk = duckdb_fetch_chunk;
-	result.duckdb_create_cast_function = duckdb_create_cast_function;
-	result.duckdb_cast_function_set_source_type = duckdb_cast_function_set_source_type;
-	result.duckdb_cast_function_set_target_type = duckdb_cast_function_set_target_type;
-	result.duckdb_cast_function_set_implicit_cast_cost = duckdb_cast_function_set_implicit_cast_cost;
-	result.duckdb_cast_function_set_function = duckdb_cast_function_set_function;
-	result.duckdb_cast_function_set_extra_info = duckdb_cast_function_set_extra_info;
-	result.duckdb_cast_function_get_extra_info = duckdb_cast_function_get_extra_info;
-	result.duckdb_cast_function_get_cast_mode = duckdb_cast_function_get_cast_mode;
-	result.duckdb_cast_function_set_error = duckdb_cast_function_set_error;
-	result.duckdb_cast_function_set_row_error = duckdb_cast_function_set_row_error;
-	result.duckdb_register_cast_function = duckdb_register_cast_function;
-	result.duckdb_destroy_cast_function = duckdb_destroy_cast_function;
-	result.duckdb_is_finite_timestamp_s = duckdb_is_finite_timestamp_s;
-	result.duckdb_is_finite_timestamp_ms = duckdb_is_finite_timestamp_ms;
-	result.duckdb_is_finite_timestamp_ns = duckdb_is_finite_timestamp_ns;
-	result.duckdb_create_timestamp_tz = duckdb_create_timestamp_tz;
-	result.duckdb_create_timestamp_s = duckdb_create_timestamp_s;
-	result.duckdb_create_timestamp_ms = duckdb_create_timestamp_ms;
-	result.duckdb_create_timestamp_ns = duckdb_create_timestamp_ns;
-	result.duckdb_get_timestamp_tz = duckdb_get_timestamp_tz;
-	result.duckdb_get_timestamp_s = duckdb_get_timestamp_s;
-	result.duckdb_get_timestamp_ms = duckdb_get_timestamp_ms;
-	result.duckdb_get_timestamp_ns = duckdb_get_timestamp_ns;
-	result.duckdb_append_value = duckdb_append_value;
-	result.duckdb_get_profiling_info = duckdb_get_profiling_info;
-	result.duckdb_profiling_info_get_value = duckdb_profiling_info_get_value;
-	result.duckdb_appender_begin_row = duckdb_appender_begin_row;
-	result.duckdb_appender_end_row = duckdb_appender_end_row;
-	result.duckdb_append_default = duckdb_append_default;
-	result.duckdb_append_bool = duckdb_append_bool;
-	result.duckdb_append_int8 = duckdb_append_int8;
-	result.duckdb_append_int16 = duckdb_append_int16;
-	result.duckdb_append_int32 = duckdb_append_int32;
-	result.duckdb_append_int64 = duckdb_append_int64;
-	result.duckdb_append_hugeint = duckdb_append_hugeint;
-	result.duckdb_append_uint8 = duckdb_append_uint8;
-	result.duckdb_append_uint16 = duckdb_append_uint16;
-	result.duckdb_append_uint32 = duckdb_append_uint32;
-	result.duckdb_append_uint64 = duckdb_append_uint64;
-	result.duckdb_append_uhugeint = duckdb_append_uhugeint;
-	result.duckdb_append_float = duckdb_append_float;
-	result.duckdb_append_double = duckdb_append_double;
-	result.duckdb_append_date = duckdb_append_date;
-	result.duckdb_append_time = duckdb_append_time;
-	result.duckdb_append_timestamp = duckdb_append_timestamp;
-	result.duckdb_append_interval = duckdb_append_interval;
-	result.duckdb_append_varchar = duckdb_append_varchar;
-	result.duckdb_append_varchar_length = duckdb_append_varchar_length;
-	result.duckdb_append_blob = duckdb_append_blob;
-	result.duckdb_append_null = duckdb_append_null;
-	result.duckdb_row_count = duckdb_row_count;
-	result.duckdb_column_data = duckdb_column_data;
-	result.duckdb_nullmask_data = duckdb_nullmask_data;
-	result.duckdb_result_get_chunk = duckdb_result_get_chunk;
-	result.duckdb_result_is_streaming = duckdb_result_is_streaming;
-	result.duckdb_result_chunk_count = duckdb_result_chunk_count;
-	result.duckdb_value_boolean = duckdb_value_boolean;
-	result.duckdb_value_int8 = duckdb_value_int8;
-	result.duckdb_value_int16 = duckdb_value_int16;
-	result.duckdb_value_int32 = duckdb_value_int32;
-	result.duckdb_value_int64 = duckdb_value_int64;
-	result.duckdb_value_hugeint = duckdb_value_hugeint;
-	result.duckdb_value_uhugeint = duckdb_value_uhugeint;
-	result.duckdb_value_decimal = duckdb_value_decimal;
-	result.duckdb_value_uint8 = duckdb_value_uint8;
-	result.duckdb_value_uint16 = duckdb_value_uint16;
-	result.duckdb_value_uint32 = duckdb_value_uint32;
-	result.duckdb_value_uint64 = duckdb_value_uint64;
-	result.duckdb_value_float = duckdb_value_float;
-	result.duckdb_value_double = duckdb_value_double;
-	result.duckdb_value_date = duckdb_value_date;
-	result.duckdb_value_time = duckdb_value_time;
-	result.duckdb_value_timestamp = duckdb_value_timestamp;
-	result.duckdb_value_interval = duckdb_value_interval;
-	result.duckdb_value_varchar = duckdb_value_varchar;
-	result.duckdb_value_string = duckdb_value_string;
-	result.duckdb_value_varchar_internal = duckdb_value_varchar_internal;
-	result.duckdb_value_string_internal = duckdb_value_string_internal;
-	result.duckdb_value_blob = duckdb_value_blob;
-	result.duckdb_value_is_null = duckdb_value_is_null;
-	result.duckdb_execute_prepared_streaming = duckdb_execute_prepared_streaming;
-	result.duckdb_pending_prepared_streaming = duckdb_pending_prepared_streaming;
-	result.duckdb_query_arrow = duckdb_query_arrow;
-	result.duckdb_query_arrow_schema = duckdb_query_arrow_schema;
-	result.duckdb_prepared_arrow_schema = duckdb_prepared_arrow_schema;
-	result.duckdb_result_arrow_array = duckdb_result_arrow_array;
-	result.duckdb_query_arrow_array = duckdb_query_arrow_array;
-	result.duckdb_arrow_column_count = duckdb_arrow_column_count;
-	result.duckdb_arrow_row_count = duckdb_arrow_row_count;
-	result.duckdb_arrow_rows_changed = duckdb_arrow_rows_changed;
-	result.duckdb_query_arrow_error = duckdb_query_arrow_error;
-	result.duckdb_destroy_arrow = duckdb_destroy_arrow;
-	result.duckdb_destroy_arrow_stream = duckdb_destroy_arrow_stream;
-	result.duckdb_execute_prepared_arrow = duckdb_execute_prepared_arrow;
-	result.duckdb_arrow_scan = duckdb_arrow_scan;
-	result.duckdb_arrow_array_scan = duckdb_arrow_array_scan;
-	result.duckdb_stream_fetch_chunk = duckdb_stream_fetch_chunk;
-	result.duckdb_create_instance_cache = duckdb_create_instance_cache;
-	result.duckdb_get_or_create_from_cache = duckdb_get_or_create_from_cache;
-	result.duckdb_destroy_instance_cache = duckdb_destroy_instance_cache;
-	result.duckdb_append_default_to_chunk = duckdb_append_default_to_chunk;
-	return result;
-}
-
-#define DUCKDB_EXTENSION_API_VERSION_MAJOR  1
-#define DUCKDB_EXTENSION_API_VERSION_MINOR  2
-#define DUCKDB_EXTENSION_API_VERSION_PATCH  0
-#define DUCKDB_EXTENSION_API_VERSION_STRING "v1.2.0"
diff --git a/src/duckdb/src/include/duckdb/main/chunk_scan_state.hpp b/src/duckdb/src/include/duckdb/main/chunk_scan_state.hpp
deleted file mode 100644
index 68f113ffc..000000000
--- a/src/duckdb/src/include/duckdb/main/chunk_scan_state.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/error_data.hpp"
-
-namespace duckdb {
-
-class DataChunk;
-
-//! Abstract chunk fetcher
-class ChunkScanState {
-public:
-	explicit ChunkScanState();
-	virtual ~ChunkScanState();
-
-public:
-	ChunkScanState(const ChunkScanState &other) = delete;
-	ChunkScanState(ChunkScanState &&other) = default;
-	ChunkScanState &operator=(const ChunkScanState &other) = delete;
-	ChunkScanState &operator=(ChunkScanState &&other) = default;
-
-public:
-	virtual bool LoadNextChunk(ErrorData &error) = 0;
-	virtual bool HasError() const = 0;
-	virtual ErrorData &GetError() = 0;
-	virtual const vector<LogicalType> &Types() const = 0;
-	virtual const vector<string> &Names() const = 0;
-	idx_t CurrentOffset() const;
-	idx_t RemainingInChunk() const;
-	DataChunk &CurrentChunk();
-	bool ChunkIsEmpty() const;
-	bool Finished() const;
-	bool ScanStarted() const;
-	void IncreaseOffset(idx_t increment, bool unsafe = false);
-
-protected:
-	idx_t offset = 0;
-	bool finished = false;
-	unique_ptr<DataChunk> current_chunk;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/chunk_scan_state/batched_data_collection.hpp b/src/duckdb/src/include/duckdb/main/chunk_scan_state/batched_data_collection.hpp
deleted file mode 100644
index b9310661e..000000000
--- a/src/duckdb/src/include/duckdb/main/chunk_scan_state/batched_data_collection.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "duckdb/main/chunk_scan_state.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
-#include "duckdb/common/error_data.hpp"
-
-namespace duckdb {
-
-class BatchCollectionChunkScanState : public ChunkScanState {
-public:
-	BatchCollectionChunkScanState(BatchedDataCollection &collection, BatchedChunkIteratorRange &range,
-	                              ClientContext &context);
-	~BatchCollectionChunkScanState() override;
-
-public:
-	BatchCollectionChunkScanState(const BatchCollectionChunkScanState &other) = delete;
-	BatchCollectionChunkScanState &operator=(const BatchCollectionChunkScanState &other) = delete;
-	BatchCollectionChunkScanState(BatchCollectionChunkScanState &&other) = default;
-
-public:
-	bool LoadNextChunk(ErrorData &error) override;
-	bool HasError() const override;
-	ErrorData &GetError() override;
-	const vector<LogicalType> &Types() const override;
-	const vector<string> &Names() const override;
-
-private:
-	void InternalLoad(ErrorData &error);
-
-private:
-	BatchedDataCollection &collection;
-	BatchedChunkScanState state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/chunk_scan_state/query_result.hpp b/src/duckdb/src/include/duckdb/main/chunk_scan_state/query_result.hpp
deleted file mode 100644
index 37df093ab..000000000
--- a/src/duckdb/src/include/duckdb/main/chunk_scan_state/query_result.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "duckdb/main/chunk_scan_state.hpp"
-#include "duckdb/common/error_data.hpp"
-
-namespace duckdb {
-
-class QueryResult;
-
-class QueryResultChunkScanState : public ChunkScanState {
-public:
-	explicit QueryResultChunkScanState(QueryResult &result);
-	~QueryResultChunkScanState() override;
-
-public:
-	bool LoadNextChunk(ErrorData &error) override;
-	bool HasError() const override;
-	ErrorData &GetError() override;
-	const vector<LogicalType> &Types() const override;
-	const vector<string> &Names() const override;
-
-private:
-	bool InternalLoad(ErrorData &error);
-
-private:
-	QueryResult &result;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_config.hpp b/src/duckdb/src/include/duckdb/main/client_config.hpp
deleted file mode 100644
index 8b919c821..000000000
--- a/src/duckdb/src/include/duckdb/main/client_config.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_config.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/output_type.hpp"
-#include "duckdb/common/enums/profiler_format.hpp"
-#include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/main/profiling_info.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class PhysicalResultCollector;
-class PreparedStatementData;
-class HTTPLogger;
-
-typedef std::function<unique_ptr<PhysicalResultCollector>(ClientContext &context, PreparedStatementData &data)>
-    get_result_collector_t;
-
-struct ClientConfig {
-	//! The home directory used by the system (if any)
-	string home_directory;
-	//! If the query profiler is enabled or not.
-	bool enable_profiler = false;
-	//! If detailed query profiling is enabled
-	bool enable_detailed_profiling = false;
-	//! The format to print query profiling information in (default: query_tree), if enabled.
-	ProfilerPrintFormat profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
-	//! The file to save query profiling information to, instead of printing it to the console
-	//! (empty = print to console)
-	string profiler_save_location;
-	//! The custom settings for the profiler
-	//! (empty = use the default settings)
-	profiler_settings_t profiler_settings = ProfilingInfo::DefaultSettings();
-
-	//! Allows suppressing profiler output, even if enabled. We turn on the profiler on all test runs but don't want
-	//! to output anything
-	bool emit_profiler_output = true;
-
-	//! system-wide progress bar disable.
-	const char *system_progress_bar_disable_reason = nullptr;
-	//! If the progress bar is enabled or not.
-	bool enable_progress_bar = false;
-	//! If the print of the progress bar is enabled
-	bool print_progress_bar = true;
-	//! The wait time before showing the progress bar
-	int wait_time = 2000;
-
-	//! Preserve identifier case while parsing.
-	//! If false, all unquoted identifiers are lower-cased (e.g. "MyTable" -> "mytable").
-	bool preserve_identifier_case = true;
-	//! The maximum expression depth limit in the parser
-	idx_t max_expression_depth = 1000;
-
-	//! Whether or not aggressive query verification is enabled
-	bool query_verification_enabled = false;
-	//! Whether or not verification of external operators is enabled, used for testing
-	bool verify_external = false;
-	//! Whether or not verification of fetch row code is enabled, used for testing
-	bool verify_fetch_row = false;
-	//! Whether or not we should verify the serializer
-	bool verify_serializer = false;
-	//! Enable the running of optimizers
-	bool enable_optimizer = true;
-	//! Enable caching operators
-	bool enable_caching_operators = true;
-	//! Force parallelism of small tables, used for testing
-	bool verify_parallelism = false;
-	//! Force out-of-core computation for operators that support it, used for testing
-	bool force_external = false;
-	//! Force disable cross product generation when hyper graph isn't connected, used for testing
-	bool force_no_cross_product = false;
-	//! Force use of IEJoin to implement AsOfJoin, used for testing
-	bool force_asof_iejoin = false;
-	//! Force use of fetch row instead of scan, used for testing
-	bool force_fetch_row = false;
-	//! Use range joins for inequalities, even if there are equality predicates
-	bool prefer_range_joins = false;
-	//! If this context should also try to use the available replacement scans
-	//! True by default
-	bool use_replacement_scans = true;
-	//! Maximum bits allowed for using a perfect hash table (i.e. the perfect HT can hold up to 2^perfect_ht_threshold
-	//! elements)
-	idx_t perfect_ht_threshold = 12;
-	//! The maximum number of rows to accumulate before sorting ordered aggregates.
-	idx_t ordered_aggregate_threshold = (idx_t(1) << 18);
-	//! The number of rows to accumulate before flushing during a partitioned write
-	idx_t partitioned_write_flush_threshold = idx_t(1) << idx_t(19);
-	//! The amount of rows we can keep open before we close and flush them during a partitioned write
-	idx_t partitioned_write_max_open_files = idx_t(100);
-	//! The number of rows we need on either table to choose a nested loop join
-	idx_t nested_loop_join_threshold = 5;
-	//! The number of rows we need on either table to choose a merge join over an IE join
-	idx_t merge_join_threshold = 1000;
-
-	//! The maximum amount of memory to keep buffered in a streaming query result. Default: 1mb.
-	idx_t streaming_buffer_size = 1000000;
-
-	//! Callback to create a progress bar display
-	progress_bar_display_create_func_t display_create_func = nullptr;
-
-	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
-	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
-
-	//! The maximum amount of pivot columns
-	idx_t pivot_limit = 100000;
-
-	//! The threshold at which we switch from using filtered aggregates to LIST with a dedicated pivot operator
-	idx_t pivot_filter_threshold = 20;
-
-	//! The maximum amount of OR filters we generate dynamically from a hash join
-	idx_t dynamic_or_filter_threshold = 50;
-
-	//! Whether or not the "/" division operator defaults to integer division or floating point division
-	bool integer_division = false;
-	//! When a scalar subquery returns multiple rows - return a random row instead of returning an error
-	bool scalar_subquery_error_on_multiple_rows = true;
-	//! Use IEE754-compliant floating point operations (returning NAN instead of errors/NULL)
-	bool ieee_floating_point_ops = true;
-	//! Allow ordering by non-integer literals - ordering by such literals has no effect
-	bool order_by_non_integer_literal = false;
-
-	//! Output error messages as structured JSON instead of as a raw string
-	bool errors_as_json = false;
-
-	//! Generic options
-	case_insensitive_map_t<Value> set_variables;
-
-	//! Variables set by the user
-	case_insensitive_map_t<Value> user_variables;
-
-	//! Function that is used to create the result collector for a materialized result
-	//! Defaults to PhysicalMaterializedCollector
-	get_result_collector_t result_collector = nullptr;
-
-	//! If HTTP logging is enabled or not.
-	bool enable_http_logging = false;
-	//! The file to save query HTTP logging information to, instead of printing it to the console
-	//! (empty = print to console)
-	string http_logging_output;
-
-public:
-	static ClientConfig &GetConfig(ClientContext &context);
-	static const ClientConfig &GetConfig(const ClientContext &context);
-
-	bool AnyVerification() {
-		return query_verification_enabled || verify_external || verify_serializer || verify_fetch_row;
-	}
-
-	void SetUserVariable(const string &name, Value value) {
-		user_variables[name] = std::move(value);
-	}
-
-	bool GetUserVariable(const string &name, Value &result) {
-		auto entry = user_variables.find(name);
-		if (entry == user_variables.end()) {
-			return false;
-		}
-		result = entry->second;
-		return true;
-	}
-
-	void ResetUserVariable(const string &name) {
-		user_variables.erase(name);
-	}
-
-	template <class OP>
-	static typename OP::RETURN_TYPE GetSetting(const ClientContext &context) {
-		return OP::GetSetting(context).template GetValue<typename OP::RETURN_TYPE>();
-	}
-
-	template <class OP>
-	static Value GetSettingValue(const ClientContext &context) {
-		return OP::GetSetting(context);
-	}
-
-public:
-	void SetDefaultStreamingBufferSize();
-};
-
-struct ScopedConfigSetting {
-public:
-	using config_modify_func_t = std::function<void(ClientConfig &config)>;
-
-public:
-	explicit ScopedConfigSetting(ClientConfig &config, config_modify_func_t set_f = nullptr,
-	                             config_modify_func_t unset_f = nullptr)
-	    : config(config), set(std::move(set_f)), unset(std::move(unset_f)) {
-		if (set) {
-			set(config);
-		}
-	}
-	~ScopedConfigSetting() {
-		if (unset) {
-			unset(config);
-		}
-	}
-
-public:
-	ClientConfig &config;
-	config_modify_func_t set;
-	config_modify_func_t unset;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_context.hpp b/src/duckdb/src/include/duckdb/main/client_context.hpp
deleted file mode 100644
index 6f5115cb1..000000000
--- a/src/duckdb/src/include/duckdb/main/client_context.hpp
+++ /dev/null
@@ -1,317 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/deque.hpp"
-#include "duckdb/common/enums/pending_execution_result.hpp"
-#include "duckdb/common/enums/prepared_statement_mode.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/main/client_context_state.hpp"
-#include "duckdb/main/client_properties.hpp"
-#include "duckdb/main/external_dependencies.hpp"
-#include "duckdb/main/pending_query_result.hpp"
-#include "duckdb/main/prepared_statement.hpp"
-#include "duckdb/main/settings.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/main/table_description.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-#include "duckdb/transaction/transaction_context.hpp"
-
-namespace duckdb {
-class Appender;
-class Catalog;
-class CatalogSearchPath;
-class ColumnDataCollection;
-class DatabaseInstance;
-class FileOpener;
-class LogicalOperator;
-class PreparedStatementData;
-class Relation;
-class BufferedFileWriter;
-class QueryProfiler;
-class ClientContextLock;
-struct CreateScalarFunctionInfo;
-class ScalarFunctionCatalogEntry;
-struct ActiveQueryContext;
-struct ParserOptions;
-class SimpleBufferedData;
-class BufferedData;
-struct ClientData;
-class ClientContextState;
-class RegisteredStateManager;
-
-struct PendingQueryParameters {
-	//! Prepared statement parameters (if any)
-	optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters;
-	//! Whether or not a stream result should be allowed
-	bool allow_stream_result = false;
-};
-
-//! The ClientContext holds information relevant to the current client session
-//! during execution
-class ClientContext : public enable_shared_from_this<ClientContext> {
-	friend class PendingQueryResult;  // LockContext
-	friend class BufferedData;        // ExecuteTaskInternal
-	friend class SimpleBufferedData;  // ExecuteTaskInternal
-	friend class BatchedBufferedData; // ExecuteTaskInternal
-	friend class StreamQueryResult;   // LockContext
-	friend class ConnectionManager;
-
-public:
-	DUCKDB_API explicit ClientContext(shared_ptr<DatabaseInstance> db);
-	DUCKDB_API ~ClientContext();
-
-	//! The database that this client is connected to
-	shared_ptr<DatabaseInstance> db;
-	//! Whether or not the query is interrupted
-	atomic<bool> interrupted;
-	//! Set of optional states (e.g. Caches) that can be held by the ClientContext
-	unique_ptr<RegisteredStateManager> registered_state;
-	//! The client configuration
-	ClientConfig config;
-	//! The set of client-specific data
-	unique_ptr<ClientData> client_data;
-	//! Data for the currently running transaction
-	TransactionContext transaction;
-
-public:
-	MetaTransaction &ActiveTransaction() {
-		return transaction.ActiveTransaction();
-	}
-
-	//! Interrupt execution of a query
-	DUCKDB_API void Interrupt();
-	DUCKDB_API void CancelTransaction();
-
-	//! Enable query profiling
-	DUCKDB_API void EnableProfiling();
-	//! Disable query profiling
-	DUCKDB_API void DisableProfiling();
-
-	//! Issue a query, returning a QueryResult. The QueryResult can be either a StreamQueryResult or a
-	//! MaterializedQueryResult. The StreamQueryResult will only be returned in the case of a successful SELECT
-	//! statement.
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &query, bool allow_stream_result);
-	DUCKDB_API unique_ptr<QueryResult> Query(unique_ptr<SQLStatement> statement, bool allow_stream_result);
-
-	//! Issues a query to the database and returns a Pending Query Result. Note that "query" may only contain
-	//! a single statement.
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query, bool allow_stream_result);
-	//! Issues a query to the database and returns a Pending Query Result
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement,
-	                                                       bool allow_stream_result);
-
-	//! Create a pending query with a list of parameters
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement,
-	                                                       case_insensitive_map_t<BoundParameterData> &values,
-	                                                       bool allow_stream_result);
-	DUCKDB_API unique_ptr<PendingQueryResult>
-	PendingQuery(const string &query, case_insensitive_map_t<BoundParameterData> &values, bool allow_stream_result);
-
-	//! Destroy the client context
-	DUCKDB_API void Destroy();
-
-	//! Get the table info of a specific table, or nullptr if it cannot be found.
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &database_name, const string &schema_name,
-	                                                  const string &table_name);
-	//! Get the table info of a specific table, or nullptr if it cannot be found. Uses INVALID_CATALOG.
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &schema_name, const string &table_name);
-	//! Appends a DataChunk and its default columns to the specified table.
-	DUCKDB_API void Append(TableDescription &description, ColumnDataCollection &collection,
-	                       optional_ptr<const vector<LogicalIndex>> column_ids = nullptr);
-
-	//! Try to bind a relation in the current client context; either throws an exception or fills the result_columns
-	//! list with the set of returned columns
-	DUCKDB_API void TryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns);
-
-	//! Internal function for try bind relation. It does not require a client-context lock.
-	DUCKDB_API void InternalTryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns);
-
-	//! Execute a relation
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const shared_ptr<Relation> &relation,
-	                                                       bool allow_stream_result);
-	DUCKDB_API unique_ptr<QueryResult> Execute(const shared_ptr<Relation> &relation);
-
-	//! Prepare a query
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(const string &query);
-	//! Directly prepare a SQL statement
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(unique_ptr<SQLStatement> statement);
-
-	//! Create a pending query result from a prepared statement with the given name and set of parameters
-	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
-	//! modified in between the prepared statement being bound and the prepared statement being run.
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query,
-	                                                       shared_ptr<PreparedStatementData> &prepared,
-	                                                       const PendingQueryParameters &parameters);
-
-	//! Execute a prepared statement with the given name and set of parameters
-	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
-	//! modified in between the prepared statement being bound and the prepared statement being run.
-	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           case_insensitive_map_t<BoundParameterData> &values,
-	                                           bool allow_stream_result = true);
-	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           const PendingQueryParameters &parameters);
-
-	//! Gets current percentage of the query's progress, returns 0 in case the progress bar is disabled.
-	DUCKDB_API QueryProgress GetQueryProgress();
-
-	//! Register function in the temporary schema
-	DUCKDB_API void RegisterFunction(CreateFunctionInfo &info);
-
-	//! Parse statements from a query
-	DUCKDB_API vector<unique_ptr<SQLStatement>> ParseStatements(const string &query);
-
-	//! Extract the logical plan of a query
-	DUCKDB_API unique_ptr<LogicalOperator> ExtractPlan(const string &query);
-	DUCKDB_API void HandlePragmaStatements(vector<unique_ptr<SQLStatement>> &statements);
-
-	//! Runs a function with a valid transaction context, potentially starting a transaction if the context is in auto
-	//! commit mode.
-	DUCKDB_API void RunFunctionInTransaction(const std::function<void(void)> &fun,
-	                                         bool requires_valid_transaction = true);
-	//! Same as RunFunctionInTransaction, but does not obtain a lock on the client context or check for validation
-	DUCKDB_API void RunFunctionInTransactionInternal(ClientContextLock &lock, const std::function<void(void)> &fun,
-	                                                 bool requires_valid_transaction = true);
-
-	//! Equivalent to CURRENT_SETTING(key) SQL function.
-	DUCKDB_API SettingLookupResult TryGetCurrentSetting(const std::string &key, Value &result) const;
-
-	//! Returns the parser options for this client context
-	DUCKDB_API ParserOptions GetParserOptions() const;
-
-	//! Whether or not the given result object (streaming query result or pending query result) is active
-	DUCKDB_API bool IsActiveResult(ClientContextLock &lock, BaseQueryResult &result);
-
-	//! Returns the current executor
-	Executor &GetExecutor();
-
-	//! Returns the current query string (if any)
-	const string &GetCurrentQuery();
-
-	//! Fetch a list of table names that are required for a given query
-	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
-
-	DUCKDB_API ClientProperties GetClientProperties() const;
-
-	//! Returns true if execution of the current query is finished
-	DUCKDB_API bool ExecutionIsFinished();
-
-	//! Process an error for display to the user
-	DUCKDB_API void ProcessError(ErrorData &error, const string &query) const;
-
-private:
-	//! Parse statements and resolve pragmas from a query
-	bool ParseStatements(ClientContextLock &lock, const string &query, vector<unique_ptr<SQLStatement>> &result,
-	                     ErrorData &error);
-	//! Issues a query to the database and returns a Pending Query Result
-	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &lock, unique_ptr<SQLStatement> statement,
-	                                                    const PendingQueryParameters &parameters, bool verify = true);
-	unique_ptr<QueryResult> ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query);
-
-	//! Parse statements from a query
-	vector<unique_ptr<SQLStatement>> ParseStatementsInternal(ClientContextLock &lock, const string &query);
-	//! Perform aggressive query verification of a SELECT statement. Only called when query_verification_enabled is
-	//! true.
-	ErrorData VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-	                      optional_ptr<case_insensitive_map_t<BoundParameterData>> values = nullptr);
-
-	void InitialCleanup(ClientContextLock &lock);
-	//! Internal clean up, does not lock. Caller must hold the context_lock.
-	void CleanupInternal(ClientContextLock &lock, BaseQueryResult *result = nullptr,
-	                     bool invalidate_transaction = false);
-	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
-	                                                                   unique_ptr<SQLStatement> statement,
-	                                                                   shared_ptr<PreparedStatementData> &prepared,
-	                                                                   const PendingQueryParameters &parameters);
-	unique_ptr<PendingQueryResult> PendingPreparedStatement(ClientContextLock &lock, const string &query,
-	                                                        shared_ptr<PreparedStatementData> statement_p,
-	                                                        const PendingQueryParameters &parameters);
-	unique_ptr<PendingQueryResult> PendingPreparedStatementInternal(ClientContextLock &lock,
-	                                                                shared_ptr<PreparedStatementData> statement_p,
-	                                                                const PendingQueryParameters &parameters);
-	void CheckIfPreparedStatementIsExecutable(PreparedStatementData &statement);
-
-	//! Internally prepare a SQL statement. Caller must hold the context_lock.
-	shared_ptr<PreparedStatementData>
-	CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-	                        optional_ptr<case_insensitive_map_t<BoundParameterData>> values = nullptr,
-	                        PreparedStatementMode mode = PreparedStatementMode::PREPARE_ONLY);
-	unique_ptr<PendingQueryResult> PendingStatementInternal(ClientContextLock &lock, const string &query,
-	                                                        unique_ptr<SQLStatement> statement,
-	                                                        const PendingQueryParameters &parameters);
-	unique_ptr<QueryResult> RunStatementInternal(ClientContextLock &lock, const string &query,
-	                                             unique_ptr<SQLStatement> statement, bool allow_stream_result,
-	                                             optional_ptr<case_insensitive_map_t<BoundParameterData>> params,
-	                                             bool verify = true);
-	unique_ptr<PreparedStatement> PrepareInternal(ClientContextLock &lock, unique_ptr<SQLStatement> statement);
-	void LogQueryInternal(ClientContextLock &lock, const string &query);
-
-	unique_ptr<QueryResult> FetchResultInternal(ClientContextLock &lock, PendingQueryResult &pending);
-
-	unique_ptr<ClientContextLock> LockContext();
-
-	void BeginQueryInternal(ClientContextLock &lock, const string &query);
-	ErrorData EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction,
-	                           optional_ptr<ErrorData> previous_error);
-
-	//! Wait until a task is available to execute
-	void WaitForTask(ClientContextLock &lock, BaseQueryResult &result);
-	PendingExecutionResult ExecuteTaskInternal(ClientContextLock &lock, BaseQueryResult &result, bool dry_run = false);
-
-	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatementInternal(
-	    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-	    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters);
-
-	unique_ptr<PendingQueryResult> PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
-	                                                            shared_ptr<PreparedStatementData> &prepared,
-	                                                            const PendingQueryParameters &parameters);
-
-	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &, const shared_ptr<Relation> &relation,
-	                                                    bool allow_stream_result);
-
-	void RebindPreparedStatement(ClientContextLock &lock, const string &query,
-	                             shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters);
-
-	template <class T>
-	unique_ptr<T> ErrorResult(ErrorData error, const string &query = string());
-
-	shared_ptr<PreparedStatementData>
-	CreatePreparedStatementInternal(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-	                                optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
-
-private:
-	//! Lock on using the ClientContext in parallel
-	mutex context_lock;
-	//! The currently active query context
-	unique_ptr<ActiveQueryContext> active_query;
-	//! The current query progress
-	QueryProgress query_progress;
-};
-
-class ClientContextLock {
-public:
-	explicit ClientContextLock(mutex &context_lock) : client_guard(context_lock) {
-	}
-
-	~ClientContextLock() {
-	}
-
-private:
-	lock_guard<mutex> client_guard;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp b/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp
deleted file mode 100644
index 061ed8526..000000000
--- a/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context_file_opener.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_opener.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-
-//! ClientContext-specific FileOpener implementation.
-//! This object is owned by ClientContext and never outlives it.
-class ClientContextFileOpener : public FileOpener {
-public:
-	explicit ClientContextFileOpener(ClientContext &context_p) : context(context_p) {
-	}
-
-	SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) override;
-	SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override;
-
-	optional_ptr<ClientContext> TryGetClientContext() override {
-		return &context;
-	}
-	optional_ptr<DatabaseInstance> TryGetDatabase() override;
-
-private:
-	ClientContext &context;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_context_state.hpp b/src/duckdb/src/include/duckdb/main/client_context_state.hpp
deleted file mode 100644
index e7a10593f..000000000
--- a/src/duckdb/src/include/duckdb/main/client_context_state.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/prepared_statement_mode.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/valid_checker.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/client_context.hpp"
-#include <mutex>
-
-namespace duckdb {
-class ClientContext;
-class ErrorData;
-class MetaTransaction;
-class PreparedStatementData;
-class SQLStatement;
-struct PendingQueryParameters;
-class RegisteredStateManager;
-
-enum class RebindQueryInfo { DO_NOT_REBIND, ATTEMPT_TO_REBIND };
-
-struct PreparedStatementCallbackInfo {
-	PreparedStatementCallbackInfo(PreparedStatementData &prepared_statement, const PendingQueryParameters &parameters)
-	    : prepared_statement(prepared_statement), parameters(parameters) {
-	}
-
-	PreparedStatementData &prepared_statement;
-	const PendingQueryParameters &parameters;
-};
-
-//! ClientContextState is virtual base class for ClientContext-local (or Query-Local, using QueryEnd callback) state
-//! e.g. caches that need to live as long as a ClientContext or Query.
-class ClientContextState {
-public:
-	virtual ~ClientContextState() = default;
-	virtual void QueryBegin(ClientContext &context) {
-	}
-	virtual void QueryEnd() {
-	}
-	virtual void QueryEnd(ClientContext &context) {
-		QueryEnd();
-	}
-	virtual void QueryEnd(ClientContext &context, optional_ptr<ErrorData> error) {
-		QueryEnd(context);
-	}
-	virtual void TransactionBegin(MetaTransaction &transaction, ClientContext &context) {
-	}
-	virtual void TransactionCommit(MetaTransaction &transaction, ClientContext &context) {
-	}
-	virtual void TransactionRollback(MetaTransaction &transaction, ClientContext &context) {
-	}
-	virtual void TransactionRollback(MetaTransaction &transaction, ClientContext &context,
-	                                 optional_ptr<ErrorData> error) {
-		TransactionRollback(transaction, context);
-	}
-	virtual bool CanRequestRebind() {
-		return false;
-	}
-	virtual RebindQueryInfo OnPlanningError(ClientContext &context, SQLStatement &statement, ErrorData &error) {
-		return RebindQueryInfo::DO_NOT_REBIND;
-	}
-	virtual RebindQueryInfo OnFinalizePrepare(ClientContext &context, PreparedStatementData &prepared_statement,
-	                                          PreparedStatementMode mode) {
-		return RebindQueryInfo::DO_NOT_REBIND;
-	}
-	virtual RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementCallbackInfo &info,
-	                                          RebindQueryInfo current_rebind) {
-		return RebindQueryInfo::DO_NOT_REBIND;
-	}
-	virtual void WriteProfilingInformation(std::ostream &ss) {
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class RegisteredStateManager {
-public:
-	template <class T, typename... ARGS>
-	shared_ptr<T> GetOrCreate(const string &key, ARGS &&... args) {
-		lock_guard<mutex> l(lock);
-		auto lookup = registered_state.find(key);
-		if (lookup != registered_state.end()) {
-			return shared_ptr_cast<ClientContextState, T>(lookup->second);
-		}
-		auto cache = make_shared_ptr<T>(std::forward<ARGS>(args)...);
-		registered_state[key] = cache;
-		return cache;
-	}
-
-	template <class T>
-	shared_ptr<T> Get(const string &key) {
-		lock_guard<mutex> l(lock);
-		auto lookup = registered_state.find(key);
-		if (lookup == registered_state.end()) {
-			return nullptr;
-		}
-		return shared_ptr_cast<ClientContextState, T>(lookup->second);
-	}
-
-	void Insert(const string &key, shared_ptr<ClientContextState> state_p) {
-		lock_guard<mutex> l(lock);
-		registered_state.insert(make_pair(key, std::move(state_p)));
-	}
-
-	void Remove(const string &key) {
-		lock_guard<mutex> l(lock);
-		registered_state.erase(key);
-	}
-
-	vector<shared_ptr<ClientContextState>> States() {
-		lock_guard<mutex> l(lock);
-		vector<shared_ptr<ClientContextState>> states;
-		for (auto &entry : registered_state) {
-			states.push_back(entry.second);
-		}
-		return states;
-	}
-
-private:
-	mutex lock;
-	unordered_map<string, shared_ptr<ClientContextState>> registered_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_context_wrapper.hpp b/src/duckdb/src/include/duckdb/main/client_context_wrapper.hpp
deleted file mode 100644
index 41c102255..000000000
--- a/src/duckdb/src/include/duckdb/main/client_context_wrapper.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/parser/column_definition.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-
-class Relation;
-
-class ClientContextWrapper {
-public:
-	virtual ~ClientContextWrapper() = default;
-	explicit ClientContextWrapper(const shared_ptr<ClientContext> &context);
-	shared_ptr<ClientContext> GetContext();
-	shared_ptr<ClientContext> TryGetContext();
-	virtual void TryBindRelation(Relation &relation, vector<ColumnDefinition> &columns);
-
-private:
-	weak_ptr<ClientContext> client_context;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_data.hpp b/src/duckdb/src/include/duckdb/main/client_data.hpp
deleted file mode 100644
index b3e326267..000000000
--- a/src/duckdb/src/include/duckdb/main/client_data.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/output_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp"
-
-namespace duckdb {
-class AttachedDatabase;
-class BufferedFileWriter;
-class ClientContext;
-class CatalogSearchPath;
-class FileOpener;
-class FileSystem;
-class HTTPState;
-class QueryProfiler;
-class PreparedStatementData;
-class SchemaCatalogEntry;
-class HTTPLogger;
-class RandomEngine;
-
-struct ClientData {
-	explicit ClientData(ClientContext &context);
-	~ClientData();
-
-	//! Query profiler
-	shared_ptr<QueryProfiler> profiler;
-
-	//! HTTP logger
-	shared_ptr<HTTPLogger> http_logger;
-
-	//! The set of temporary objects that belong to this client
-	shared_ptr<AttachedDatabase> temporary_objects;
-	//! The set of bound prepared statements that belong to this client
-	case_insensitive_map_t<shared_ptr<PreparedStatementData>> prepared_statements;
-
-	//! The writer used to log queries (if logging is enabled)
-	unique_ptr<BufferedFileWriter> log_query_writer;
-	//! The random generator used by random(). Its seed value can be set by setseed().
-	unique_ptr<RandomEngine> random_engine;
-
-	//! The catalog search path
-	unique_ptr<CatalogSearchPath> catalog_search_path;
-
-	//! The file opener of the client context
-	unique_ptr<FileOpener> file_opener;
-
-	//! The clients' file system wrapper
-	unique_ptr<FileSystem> client_file_system;
-
-	//! The file search path
-	string file_search_path;
-
-	//! The Max Line Length Size of Last Query Executed on a CSV File. (Only used for testing)
-	//! FIXME: this should not be done like this
-	bool debug_set_max_line_length = false;
-	idx_t debug_max_line_length = 0;
-
-public:
-	DUCKDB_API static ClientData &Get(ClientContext &context);
-	DUCKDB_API static const ClientData &Get(const ClientContext &context);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/client_properties.hpp b/src/duckdb/src/include/duckdb/main/client_properties.hpp
deleted file mode 100644
index 8619e8deb..000000000
--- a/src/duckdb/src/include/duckdb/main/client_properties.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_properties.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-enum class ArrowOffsetSize : uint8_t { REGULAR, LARGE };
-
-//! A set of properties from the client context that can be used to interpret the query result
-struct ClientProperties {
-	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p, bool arrow_use_list_view_p,
-	                 bool produce_arrow_string_view_p, bool lossless_conversion)
-	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p),
-	      arrow_use_list_view(arrow_use_list_view_p), arrow_lossless_conversion(lossless_conversion) {
-	}
-	ClientProperties() {};
-	string time_zone = "UTC";
-	ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR;
-	bool arrow_use_list_view = false;
-	bool produce_arrow_string_view = false;
-	bool arrow_lossless_conversion = false;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/config.hpp b/src/duckdb/src/include/duckdb/main/config.hpp
deleted file mode 100644
index 604ef264b..000000000
--- a/src/duckdb/src/include/duckdb/main/config.hpp
+++ /dev/null
@@ -1,414 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/config.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/cgroups.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/encryption_state.hpp"
-#include "duckdb/common/enums/access_mode.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/common/enums/optimizer_type.hpp"
-#include "duckdb/common/enums/order_type.hpp"
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/common/enums/window_aggregation_mode.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/execution/index/index_type_set.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/replacement_scan.hpp"
-#include "duckdb/main/client_properties.hpp"
-#include "duckdb/optimizer/optimizer_extension.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/parser_extension.hpp"
-#include "duckdb/planner/operator_extension.hpp"
-#include "duckdb/storage/compression/bitpacking.hpp"
-#include "duckdb/function/encoding_function.hpp"
-
-namespace duckdb {
-
-class BufferManager;
-class BufferPool;
-class CastFunctionSet;
-class CollationBinding;
-class ClientContext;
-class ErrorManager;
-class CompressionFunction;
-class TableFunctionRef;
-class OperatorExtension;
-class StorageExtension;
-class ExtensionCallback;
-class SecretManager;
-class CompressionInfo;
-class EncryptionUtil;
-
-struct CompressionFunctionSet;
-struct DBConfig;
-
-enum class CheckpointAbort : uint8_t {
-	NO_ABORT = 0,
-	DEBUG_ABORT_BEFORE_TRUNCATE = 1,
-	DEBUG_ABORT_BEFORE_HEADER = 2,
-	DEBUG_ABORT_AFTER_FREE_LIST_WRITE = 3
-};
-
-typedef void (*set_global_function_t)(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-typedef void (*set_local_function_t)(ClientContext &context, const Value &parameter);
-typedef void (*reset_global_function_t)(DatabaseInstance *db, DBConfig &config);
-typedef void (*reset_local_function_t)(ClientContext &context);
-typedef Value (*get_setting_function_t)(const ClientContext &context);
-
-struct ConfigurationOption {
-	const char *name;
-	const char *description;
-	const char *parameter_type;
-	set_global_function_t set_global;
-	set_local_function_t set_local;
-	reset_global_function_t reset_global;
-	reset_local_function_t reset_local;
-	get_setting_function_t get_setting;
-};
-
-typedef void (*set_option_callback_t)(ClientContext &context, SetScope scope, Value &parameter);
-
-struct ExtensionOption {
-	// NOLINTNEXTLINE: work around bug in clang-tidy
-	ExtensionOption(string description_p, LogicalType type_p, set_option_callback_t set_function_p,
-	                Value default_value_p)
-	    : description(std::move(description_p)), type(std::move(type_p)), set_function(set_function_p),
-	      default_value(std::move(default_value_p)) {
-	}
-
-	string description;
-	LogicalType type;
-	set_option_callback_t set_function;
-	Value default_value;
-};
-
-class SerializationCompatibility {
-public:
-	static SerializationCompatibility FromString(const string &input);
-	static SerializationCompatibility Default();
-	static SerializationCompatibility Latest();
-
-public:
-	bool Compare(idx_t property_version) const;
-
-public:
-	//! The user provided version
-	string duckdb_version;
-	//! The max version that should be serialized
-	idx_t serialization_version;
-	//! Whether this was set by a manual SET/PRAGMA or default
-	bool manually_set;
-
-protected:
-	SerializationCompatibility() = default;
-};
-
-struct DBConfigOptions {
-	//! Database file path. May be empty for in-memory mode
-	string database_path;
-	//! Database type. If empty, automatically extracted from `database_path`, where a `type:path` syntax is expected
-	string database_type;
-	//! Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)
-	AccessMode access_mode = AccessMode::AUTOMATIC;
-	//! Checkpoint when WAL reaches this size (default: 16MB)
-	idx_t checkpoint_wal_size = 1 << 24;
-	//! Whether or not to use Direct IO, bypassing operating system buffers
-	bool use_direct_io = false;
-	//! Whether extensions should be loaded on start-up
-	bool load_extensions = true;
-#ifdef DUCKDB_EXTENSION_AUTOLOAD_DEFAULT
-	//! Whether known extensions are allowed to be automatically loaded when a query depends on them
-	bool autoload_known_extensions = DUCKDB_EXTENSION_AUTOLOAD_DEFAULT;
-#else
-	bool autoload_known_extensions = false;
-#endif
-#ifdef DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT
-	//! Whether known extensions are allowed to be automatically installed when a query depends on them
-	bool autoinstall_known_extensions = DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT;
-#else
-	bool autoinstall_known_extensions = false;
-#endif
-	//! Override for the default extension repository
-	string custom_extension_repo = "";
-	//! Override for the default autoload extension repository
-	string autoinstall_extension_repo = "";
-	//! The maximum memory used by the database system (in bytes). Default: 80% of System available memory
-	idx_t maximum_memory = DConstants::INVALID_INDEX;
-	//! The maximum size of the 'temp_directory' folder when set (in bytes). Default: 90% of available disk space.
-	idx_t maximum_swap_space = DConstants::INVALID_INDEX;
-	//! The maximum amount of CPU threads used by the database system. Default: all available.
-	idx_t maximum_threads = DConstants::INVALID_INDEX;
-	//! The number of external threads that work on DuckDB tasks. Default: 1.
-	//! Must be smaller or equal to maximum_threads.
-	idx_t external_threads = 1;
-	//! Whether or not to create and use a temporary directory to store intermediates that do not fit in memory
-	bool use_temporary_directory = true;
-	//! Directory to store temporary structures that do not fit in memory
-	string temporary_directory;
-	//! Whether or not to invoke filesystem trim on free blocks after checkpoint. This will reclaim
-	//! space for sparse files, on platforms that support it.
-	bool trim_free_blocks = false;
-	//! Record timestamps of buffer manager unpin() events. Usable by custom eviction policies.
-	bool buffer_manager_track_eviction_timestamps = false;
-	//! Whether or not to allow printing unredacted secrets
-	bool allow_unredacted_secrets = false;
-	//! The collation type of the database
-	string collation = string();
-	//! The order type used when none is specified (default: ASC)
-	OrderType default_order_type = OrderType::ASCENDING;
-	//! NULL ordering used when none is specified (default: NULLS LAST)
-	DefaultOrderByNullType default_null_order = DefaultOrderByNullType::NULLS_LAST;
-	//! enable COPY and related commands
-	bool enable_external_access = true;
-	//! Whether or not the global http metadata cache is used
-	bool http_metadata_cache_enable = false;
-	//! HTTP Proxy config as 'hostname:port'
-	string http_proxy;
-	//! HTTP Proxy username for basic auth
-	string http_proxy_username;
-	//! HTTP Proxy password for basic auth
-	string http_proxy_password;
-	//! Force checkpoint when CHECKPOINT is called or on shutdown, even if no changes have been made
-	bool force_checkpoint = false;
-	//! Run a checkpoint on successful shutdown and delete the WAL, to leave only a single database file behind
-	bool checkpoint_on_shutdown = true;
-	//! Serialize the metadata on checkpoint with compatibility for a given DuckDB version.
-	SerializationCompatibility serialization_compatibility = SerializationCompatibility::Default();
-	//! Debug flag that decides when a checkpoing should be aborted. Only used for testing purposes.
-	CheckpointAbort checkpoint_abort = CheckpointAbort::NO_ABORT;
-	//! Initialize the database with the standard set of DuckDB functions
-	//! You should probably not touch this unless you know what you are doing
-	bool initialize_default_database = true;
-	//! The set of disabled optimizers (default empty)
-	set<OptimizerType> disabled_optimizers;
-	//! The average string length required to use ZSTD compression.
-	uint64_t zstd_min_string_length = 4096;
-	//! Force a specific compression method to be used when checkpointing (if available)
-	CompressionType force_compression = CompressionType::COMPRESSION_AUTO;
-	//! Force a specific bitpacking mode to be used when using the bitpacking compression method
-	BitpackingMode force_bitpacking_mode = BitpackingMode::AUTO;
-	//! Debug setting for window aggregation mode: (window, combine, separate)
-	WindowAggregationMode window_mode = WindowAggregationMode::WINDOW;
-	//! Whether preserving insertion order should be preserved
-	bool preserve_insertion_order = true;
-	//! Whether Arrow Arrays use Large or Regular buffers
-	ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR;
-	//! Whether LISTs should produce Arrow ListViews
-	bool arrow_use_list_view = false;
-	//! Whenever a DuckDB type does not have a clear native or canonical extension match in Arrow, export the types
-	//! with a duckdb.type_name extension name
-	bool arrow_lossless_conversion = false;
-	//! Whether when producing arrow objects we produce string_views or regular strings
-	bool produce_arrow_string_views = false;
-	//! Database configuration variables as controlled by SET
-	case_insensitive_map_t<Value> set_variables;
-	//! Database configuration variable default values;
-	case_insensitive_map_t<Value> set_variable_defaults;
-	//! Directory to store extension binaries in
-	string extension_directory;
-	//! Whether unsigned extensions should be loaded
-	bool allow_unsigned_extensions = false;
-	//! Whether community extensions should be loaded
-	bool allow_community_extensions = true;
-	//! Whether extensions with missing metadata should be loaded
-	bool allow_extensions_metadata_mismatch = false;
-	//! Enable emitting FSST Vectors
-	bool enable_fsst_vectors = false;
-	//! Enable VIEWs to create dependencies
-	bool enable_view_dependencies = false;
-	//! Enable macros to create dependencies
-	bool enable_macro_dependencies = false;
-	//! Start transactions immediately in all attached databases - instead of lazily when a database is referenced
-	bool immediate_transaction_mode = false;
-	//! Debug setting - how to initialize  blocks in the storage layer when allocating
-	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
-	//! The set of user-provided options
-	case_insensitive_map_t<Value> user_options;
-	//! The set of unrecognized (other) options
-	case_insensitive_map_t<Value> unrecognized_options;
-	//! Whether or not the configuration settings can be altered
-	bool lock_configuration = false;
-	//! Whether to print bindings when printing the plan (debug mode only)
-	static bool debug_print_bindings; // NOLINT: debug setting
-	//! The peak allocation threshold at which to flush the allocator after completing a task (1 << 27, ~128MB)
-	idx_t allocator_flush_threshold = 134217728ULL;
-	//! If bulk deallocation larger than this occurs, flush outstanding allocations (1 << 30, ~1GB)
-	idx_t allocator_bulk_deallocation_flush_threshold = 536870912ULL;
-	//! Whether the allocator background thread is enabled
-	bool allocator_background_threads = false;
-	//! DuckDB API surface
-	string duckdb_api;
-	//! Metadata from DuckDB callers
-	string custom_user_agent;
-	//! Use old implicit casting style (i.e. allow everything to be implicitly casted to VARCHAR)
-	bool old_implicit_casting = false;
-	//! The default block allocation size for new duckdb database files (new as-in, they do not yet exist).
-	idx_t default_block_alloc_size = DUCKDB_BLOCK_ALLOC_SIZE;
-	//!  Whether or not to abort if a serialization exception is thrown during WAL playback (when reading truncated WAL)
-	bool abort_on_wal_failure = false;
-	//! The index_scan_percentage sets a threshold for index scans.
-	//! If fewer than MAX(index_scan_max_count, index_scan_percentage * total_row_count)
-	//! rows match, we perform an index scan instead of a table scan.
-	double index_scan_percentage = 0.001;
-	//! The index_scan_max_count sets a threshold for index scans.
-	//! If fewer than MAX(index_scan_max_count, index_scan_percentage * total_row_count)
-	//! rows match, we perform an index scan instead of a table scan.
-	idx_t index_scan_max_count = STANDARD_VECTOR_SIZE;
-	//! The maximum number of schemas we will look through for "did you mean..." style errors in the catalog
-	idx_t catalog_error_max_schemas = 100;
-	//!  Whether or not to always write to the WAL file, even if this is not required
-	bool debug_skip_checkpoint_on_commit = false;
-	//! The maximum amount of vacuum tasks to schedule during a checkpoint
-	idx_t max_vacuum_tasks = 100;
-	//! Paths that are explicitly allowed, even if enable_external_access is false
-	unordered_set<string> allowed_paths;
-	//! Directories that are explicitly allowed, even if enable_external_access is false
-	set<string> allowed_directories;
-
-	bool operator==(const DBConfigOptions &other) const;
-};
-
-struct DBConfig {
-	friend class DatabaseInstance;
-	friend class StorageManager;
-
-public:
-	DUCKDB_API DBConfig();
-	explicit DUCKDB_API DBConfig(bool read_only);
-	DUCKDB_API DBConfig(const case_insensitive_map_t<Value> &config_dict, bool read_only);
-	DUCKDB_API ~DBConfig();
-
-	mutex config_lock;
-	//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
-	vector<ReplacementScan> replacement_scans;
-
-	//! Extra parameters that can be SET for loaded extensions
-	case_insensitive_map_t<ExtensionOption> extension_parameters;
-	//! The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g.
-	//! RamFS or something similar)
-	unique_ptr<FileSystem> file_system;
-	//! Secret manager
-	unique_ptr<SecretManager> secret_manager;
-	//! The allocator used by the system
-	unique_ptr<Allocator> allocator;
-	//! Database configuration options
-	DBConfigOptions options;
-	//! Extensions made to the parser
-	vector<ParserExtension> parser_extensions;
-	//! Extensions made to the optimizer
-	vector<OptimizerExtension> optimizer_extensions;
-	//! Error manager
-	unique_ptr<ErrorManager> error_manager;
-	//! A reference to the (shared) default allocator (Allocator::DefaultAllocator)
-	shared_ptr<Allocator> default_allocator;
-	//! Extensions made to binder
-	vector<unique_ptr<OperatorExtension>> operator_extensions;
-	//! Extensions made to storage
-	case_insensitive_map_t<duckdb::unique_ptr<StorageExtension>> storage_extensions;
-	//! A buffer pool can be shared across multiple databases (if desired).
-	shared_ptr<BufferPool> buffer_pool;
-	//! Provide a custom buffer manager implementation (if desired).
-	shared_ptr<BufferManager> buffer_manager;
-	//! Set of callbacks that can be installed by extensions
-	vector<unique_ptr<ExtensionCallback>> extension_callbacks;
-	//! Encryption Util for OpenSSL
-	shared_ptr<EncryptionUtil> encryption_util;
-
-public:
-	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);
-	DUCKDB_API static DBConfig &GetConfig(DatabaseInstance &db);
-	DUCKDB_API static DBConfig &Get(AttachedDatabase &db);
-	DUCKDB_API static const DBConfig &GetConfig(const ClientContext &context);
-	DUCKDB_API static const DBConfig &GetConfig(const DatabaseInstance &db);
-	DUCKDB_API static vector<ConfigurationOption> GetOptions();
-	DUCKDB_API static idx_t GetOptionCount();
-	DUCKDB_API static vector<string> GetOptionNames();
-	DUCKDB_API static bool IsInMemoryDatabase(const char *database_path);
-
-	DUCKDB_API void AddExtensionOption(const string &name, string description, LogicalType parameter,
-	                                   const Value &default_value = Value(), set_option_callback_t function = nullptr);
-	//! Fetch an option by index. Returns a pointer to the option, or nullptr if out of range
-	DUCKDB_API static optional_ptr<const ConfigurationOption> GetOptionByIndex(idx_t index);
-	//! Fetch an option by name. Returns a pointer to the option, or nullptr if none exists.
-	DUCKDB_API static optional_ptr<const ConfigurationOption> GetOptionByName(const string &name);
-	DUCKDB_API void SetOption(const ConfigurationOption &option, const Value &value);
-	DUCKDB_API void SetOption(DatabaseInstance *db, const ConfigurationOption &option, const Value &value);
-	DUCKDB_API void SetOptionByName(const string &name, const Value &value);
-	DUCKDB_API void SetOptionsByName(const case_insensitive_map_t<Value> &values);
-	DUCKDB_API void ResetOption(DatabaseInstance *db, const ConfigurationOption &option);
-	DUCKDB_API void SetOption(const string &name, Value value);
-	DUCKDB_API void ResetOption(const string &name);
-	static LogicalType ParseLogicalType(const string &type);
-
-	DUCKDB_API void CheckLock(const string &name);
-
-	DUCKDB_API static idx_t ParseMemoryLimit(const string &arg);
-
-	//! Returns the list of possible compression functions for the physical type.
-	DUCKDB_API vector<reference<CompressionFunction>> GetCompressionFunctions(const PhysicalType physical_type);
-	//! Returns the compression function matching the compression and physical type.
-	DUCKDB_API optional_ptr<CompressionFunction> GetCompressionFunction(CompressionType type,
-	                                                                    const PhysicalType physical_type);
-
-	//! Returns the encode function matching the encoding name.
-	DUCKDB_API optional_ptr<EncodingFunction> GetEncodeFunction(const string &name) const;
-	DUCKDB_API void RegisterEncodeFunction(const EncodingFunction &function) const;
-
-	//! Returns the encode function names.
-	DUCKDB_API vector<reference<EncodingFunction>> GetLoadedEncodedFunctions() const;
-	bool operator==(const DBConfig &other);
-	bool operator!=(const DBConfig &other);
-
-	DUCKDB_API CastFunctionSet &GetCastFunctions();
-	DUCKDB_API CollationBinding &GetCollationBinding();
-	DUCKDB_API IndexTypeSet &GetIndexTypes();
-	static idx_t GetSystemMaxThreads(FileSystem &fs);
-	static idx_t GetSystemAvailableMemory(FileSystem &fs);
-	static optional_idx ParseMemoryLimitSlurm(const string &arg);
-	void SetDefaultMaxMemory();
-	void SetDefaultTempDirectory();
-
-	OrderType ResolveOrder(OrderType order_type) const;
-	OrderByNullType ResolveNullOrder(OrderType order_type, OrderByNullType null_type) const;
-	const string UserAgent() const;
-
-	template <class OP>
-	typename OP::RETURN_TYPE GetSetting(const ClientContext &context) {
-		std::lock_guard<mutex> lock(config_lock);
-		return OP::GetSetting(context).template GetValue<typename OP::RETURN_TYPE>();
-	}
-
-	template <class OP>
-	Value GetSettingValue(const ClientContext &context) {
-		std::lock_guard<mutex> lock(config_lock);
-		return OP::GetSetting(context);
-	}
-
-	bool CanAccessFile(const string &path, FileType type);
-	void AddAllowedDirectory(const string &path);
-	void AddAllowedPath(const string &path);
-	string SanitizeAllowedPath(const string &path) const;
-
-private:
-	unique_ptr<CompressionFunctionSet> compression_functions;
-	unique_ptr<EncodingFunctionSet> encoding_functions;
-	unique_ptr<CastFunctionSet> cast_functions;
-	unique_ptr<CollationBinding> collation_bindings;
-	unique_ptr<IndexTypeSet> index_types;
-	bool is_user_config = true;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/connection.hpp b/src/duckdb/src/include/duckdb/main/connection.hpp
deleted file mode 100644
index d0935ca8e..000000000
--- a/src/duckdb/src/include/duckdb/main/connection.hpp
+++ /dev/null
@@ -1,265 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/connection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/profiler_format.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/function/udf_function.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/main/pending_query_result.hpp"
-#include "duckdb/main/prepared_statement.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/relation.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/main/table_description.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/main/profiling_node.hpp"
-
-namespace duckdb {
-
-class ColumnDataCollection;
-class ClientContext;
-
-class DatabaseInstance;
-class DuckDB;
-class LogicalOperator;
-class SelectStatement;
-struct CSVReaderOptions;
-
-typedef void (*warning_callback_t)(std::string);
-
-//! A connection to a database. This represents a (client) connection that can
-//! be used to query the database.
-class Connection {
-public:
-	DUCKDB_API explicit Connection(DuckDB &database);
-	DUCKDB_API explicit Connection(DatabaseInstance &database);
-	// disable copy constructors
-	Connection(const Connection &other) = delete;
-	Connection &operator=(const Connection &) = delete;
-	//! enable move constructors
-	DUCKDB_API Connection(Connection &&other) noexcept;
-	DUCKDB_API Connection &operator=(Connection &&) noexcept;
-	DUCKDB_API ~Connection();
-
-	shared_ptr<ClientContext> context;
-	warning_callback_t warning_cb;
-
-public:
-	//! Returns query profiling information for the current query
-	DUCKDB_API string GetProfilingInformation(ProfilerPrintFormat format = ProfilerPrintFormat::QUERY_TREE);
-
-	//! Returns the first node of the query profiling tree
-	DUCKDB_API optional_ptr<ProfilingNode> GetProfilingTree();
-
-	//! Interrupt execution of the current query
-	DUCKDB_API void Interrupt();
-
-	//! Enable query profiling
-	DUCKDB_API void EnableProfiling();
-	//! Disable query profiling
-	DUCKDB_API void DisableProfiling();
-
-	//! Enable aggressive verification/testing of queries, should only be used in testing
-	DUCKDB_API void EnableQueryVerification();
-	DUCKDB_API void DisableQueryVerification();
-	//! Force parallel execution, even for smaller tables. Should only be used in testing.
-	DUCKDB_API void ForceParallelism();
-
-	//! Issues a query to the database and returns a QueryResult. This result can be either a StreamQueryResult or a
-	//! MaterializedQueryResult. The result can be stepped through with calls to Fetch(). Note that there can only be
-	//! one active StreamQueryResult per Connection object. Calling SendQuery() will invalidate any previously existing
-	//! StreamQueryResult.
-	DUCKDB_API unique_ptr<QueryResult> SendQuery(const string &query);
-	//! Issues a query to the database and materializes the result (if necessary). Always returns a
-	//! MaterializedQueryResult.
-	DUCKDB_API unique_ptr<MaterializedQueryResult> Query(const string &query);
-	//! Issues a query to the database and materializes the result (if necessary). Always returns a
-	//! MaterializedQueryResult.
-	DUCKDB_API unique_ptr<MaterializedQueryResult> Query(unique_ptr<SQLStatement> statement);
-	// prepared statements
-	template <typename... ARGS>
-	unique_ptr<QueryResult> Query(const string &query, ARGS... args) {
-		vector<Value> values;
-		return QueryParamsRecursive(query, values, args...);
-	}
-
-	//! Issues a query to the database and returns a Pending Query Result. Note that "query" may only contain
-	//! a single statement.
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query, bool allow_stream_result = false);
-	//! Issues a query to the database and returns a Pending Query Result
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement,
-	                                                       bool allow_stream_result = false);
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement,
-	                                                       case_insensitive_map_t<BoundParameterData> &named_values,
-	                                                       bool allow_stream_result = false);
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query,
-	                                                       case_insensitive_map_t<BoundParameterData> &named_values,
-	                                                       bool allow_stream_result = false);
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query, vector<Value> &values,
-	                                                       bool allow_stream_result = false);
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement, vector<Value> &values,
-	                                                       bool allow_stream_result = false);
-
-	//! Prepare the specified query, returning a prepared statement object
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(const string &query);
-	//! Prepare the specified statement, returning a prepared statement object
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(unique_ptr<SQLStatement> statement);
-
-	//! Get the table info of a specific table, or nullptr if it cannot be found.
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &database_name, const string &schema_name,
-	                                                  const string &table_name);
-	//! Get the table info of a specific table, or nullptr if it cannot be found. Uses INVALID_CATALOG.
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &schema_name, const string &table_name);
-	//! Get the table info of a specific table, or nullptr if it cannot be found. Uses INVALID_CATALOG and
-	//! DEFAULT_SCHEMA.
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &table_name);
-
-	//! Extract a set of SQL statements from a specific query
-	DUCKDB_API vector<unique_ptr<SQLStatement>> ExtractStatements(const string &query);
-	//! Extract the logical plan that corresponds to a query
-	DUCKDB_API unique_ptr<LogicalOperator> ExtractPlan(const string &query);
-
-	//! Appends a DataChunk to the specified table
-	DUCKDB_API void Append(TableDescription &description, DataChunk &chunk);
-	//! Appends a ColumnDataCollection to the specified table
-	DUCKDB_API void Append(TableDescription &description, ColumnDataCollection &collection);
-
-	//! Returns a relation that produces a table from this connection
-	DUCKDB_API shared_ptr<Relation> Table(const string &tname);
-	DUCKDB_API shared_ptr<Relation> Table(const string &schema_name, const string &table_name);
-	//! Returns a relation that produces a view from this connection
-	DUCKDB_API shared_ptr<Relation> View(const string &tname);
-	DUCKDB_API shared_ptr<Relation> View(const string &schema_name, const string &table_name);
-	//! Returns a relation that calls a specified table function
-	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname);
-	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values,
-	                                              const named_parameter_map_t &named_parameters);
-	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values);
-	//! Returns a relation that produces values
-	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values);
-	DUCKDB_API shared_ptr<Relation> Values(vector<vector<unique_ptr<ParsedExpression>>> &&values);
-	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values, const vector<string> &column_names,
-	                                       const string &alias = "values");
-	DUCKDB_API shared_ptr<Relation> Values(const string &values);
-	DUCKDB_API shared_ptr<Relation> Values(const string &values, const vector<string> &column_names,
-	                                       const string &alias = "values");
-
-	//! Reads CSV file
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const vector<string> &csv_input, named_parameter_map_t &&options);
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_input, named_parameter_map_t &&options);
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
-
-	//! Reads Parquet file
-	DUCKDB_API shared_ptr<Relation> ReadParquet(const string &parquet_file, bool binary_as_string);
-	//! Returns a relation from a query
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, const string &alias = "queryrelation",
-	                                                  const string &error = "Expected a single SELECT statement");
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(unique_ptr<SelectStatement> select_stmt,
-	                                                  const string &alias = "queryrelation", const string &query = "");
-
-	//! Returns a substrait BLOB from a valid query
-	DUCKDB_API string GetSubstrait(const string &query);
-	//! Returns a Query Result from a substrait blob
-	DUCKDB_API unique_ptr<QueryResult> FromSubstrait(const string &proto);
-	//! Returns a substrait BLOB from a valid query
-	DUCKDB_API string GetSubstraitJSON(const string &query);
-	//! Returns a Query Result from a substrait JSON
-	DUCKDB_API unique_ptr<QueryResult> FromSubstraitJSON(const string &json);
-	DUCKDB_API void BeginTransaction();
-	DUCKDB_API void Commit();
-	DUCKDB_API void Rollback();
-	DUCKDB_API void SetAutoCommit(bool auto_commit);
-	DUCKDB_API bool IsAutoCommit();
-	DUCKDB_API bool HasActiveTransaction();
-
-	//! Fetch a list of table names that are required for a given query
-	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
-
-	// NOLINTBEGIN
-	template <typename TR, typename... ARGS>
-	void CreateScalarFunction(const string &name, TR (*udf_func)(ARGS...)) {
-		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, ARGS...>(name, udf_func);
-		UDFWrapper::RegisterFunction<TR, ARGS...>(name, function, *context);
-	}
-
-	template <typename TR, typename... ARGS>
-	void CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                          TR (*udf_func)(ARGS...)) {
-		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, ARGS...>(name, args, ret_type, udf_func);
-		UDFWrapper::RegisterFunction(name, args, ret_type, function, *context);
-	}
-
-	template <typename TR, typename... ARGS>
-	void CreateVectorizedFunction(const string &name, scalar_function_t udf_func,
-	                              LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction<TR, ARGS...>(name, udf_func, *context, std::move(varargs));
-	}
-
-	void CreateVectorizedFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                              scalar_function_t udf_func, LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction(name, std::move(args), std::move(ret_type), std::move(udf_func), *context,
-		                             std::move(varargs));
-	}
-
-	//------------------------------------- Aggreate Functions ----------------------------------------//
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	void CreateAggregateFunction(const string &name) {
-		AggregateFunction function = UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA>(name);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	void CreateAggregateFunction(const string &name) {
-		AggregateFunction function = UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_type_a) {
-		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA>(name, ret_type, input_type_a);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_type_a,
-	                             LogicalType input_type_b) {
-		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_type_a, input_type_b);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	void CreateAggregateFunction(const string &name, const vector<LogicalType> &arguments,
-	                             const LogicalType &return_type, aggregate_size_t state_size,
-	                             aggregate_initialize_t initialize, aggregate_update_t update,
-	                             aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                             aggregate_simple_update_t simple_update = nullptr,
-	                             bind_aggregate_function_t bind = nullptr,
-	                             aggregate_destructor_t destructor = nullptr) {
-		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction(name, arguments, return_type, state_size, initialize, update, combine,
-		                                        finalize, simple_update, bind, destructor);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-	// NOLINTEND
-
-private:
-	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values);
-
-	template <typename T, typename... ARGS>
-	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values, T value, ARGS... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return QueryParamsRecursive(query, values, args...);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/connection_manager.hpp b/src/duckdb/src/include/duckdb/main/connection_manager.hpp
deleted file mode 100644
index bb21a2760..000000000
--- a/src/duckdb/src/include/duckdb/main/connection_manager.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/connection_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-
-class ConnectionManager {
-public:
-	ConnectionManager();
-
-	void AddConnection(ClientContext &context);
-	void RemoveConnection(ClientContext &context);
-
-	vector<shared_ptr<ClientContext>> GetConnectionList();
-	const reference_map_t<ClientContext, weak_ptr<ClientContext>> &GetConnectionListReference() const {
-		return connections;
-	}
-	idx_t GetConnectionCount() const;
-
-	static ConnectionManager &Get(DatabaseInstance &db);
-	static ConnectionManager &Get(ClientContext &context);
-
-private:
-	mutable mutex connections_lock;
-	reference_map_t<ClientContext, weak_ptr<ClientContext>> connections;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/database.hpp b/src/duckdb/src/include/duckdb/main/database.hpp
deleted file mode 100644
index 12bb6fbee..000000000
--- a/src/duckdb/src/include/duckdb/main/database.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/database.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/valid_checker.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/extension.hpp"
-#include "duckdb/main/capi/extension_api.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-#include "duckdb/main/settings.hpp"
-
-namespace duckdb {
-class BufferManager;
-class DatabaseManager;
-class StorageManager;
-class Catalog;
-class TransactionManager;
-class ConnectionManager;
-class FileSystem;
-class TaskScheduler;
-class ObjectCache;
-struct AttachInfo;
-struct AttachOptions;
-class DatabaseFileSystem;
-struct DatabaseCacheEntry;
-
-struct ExtensionInfo {
-	bool is_loaded;
-	unique_ptr<ExtensionInstallInfo> install_info;
-	unique_ptr<ExtensionLoadedInfo> load_info;
-};
-
-class DatabaseInstance : public enable_shared_from_this<DatabaseInstance> {
-	friend class DuckDB;
-
-public:
-	DUCKDB_API DatabaseInstance();
-	DUCKDB_API ~DatabaseInstance();
-
-	DBConfig config;
-
-public:
-	BufferPool &GetBufferPool() const;
-	DUCKDB_API SecretManager &GetSecretManager();
-	DUCKDB_API BufferManager &GetBufferManager();
-	DUCKDB_API const BufferManager &GetBufferManager() const;
-	DUCKDB_API DatabaseManager &GetDatabaseManager();
-	DUCKDB_API FileSystem &GetFileSystem();
-	DUCKDB_API TaskScheduler &GetScheduler();
-	DUCKDB_API ObjectCache &GetObjectCache();
-	DUCKDB_API ConnectionManager &GetConnectionManager();
-	DUCKDB_API ValidChecker &GetValidChecker();
-	DUCKDB_API void SetExtensionLoaded(const string &extension_name, ExtensionInstallInfo &install_info);
-
-	DUCKDB_API const duckdb_ext_api_v1 GetExtensionAPIV1();
-
-	idx_t NumberOfThreads();
-
-	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
-	DUCKDB_API static const DatabaseInstance &GetDatabase(const ClientContext &context);
-
-	DUCKDB_API const unordered_map<string, ExtensionInfo> &GetExtensions();
-	DUCKDB_API bool ExtensionIsLoaded(const string &name);
-
-	DUCKDB_API SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) const;
-
-	unique_ptr<AttachedDatabase> CreateAttachedDatabase(ClientContext &context, const AttachInfo &info,
-	                                                    const AttachOptions &options);
-
-	void AddExtensionInfo(const string &name, const ExtensionLoadedInfo &info);
-	void SetDatabaseCacheEntry(shared_ptr<DatabaseCacheEntry> entry);
-
-private:
-	void Initialize(const char *path, DBConfig *config);
-	void LoadExtensionSettings();
-	void CreateMainDatabase();
-
-	void Configure(DBConfig &config, const char *path);
-
-private:
-	shared_ptr<BufferManager> buffer_manager;
-	unique_ptr<DatabaseManager> db_manager;
-	unique_ptr<TaskScheduler> scheduler;
-	unique_ptr<ObjectCache> object_cache;
-	unique_ptr<ConnectionManager> connection_manager;
-	unordered_map<string, ExtensionInfo> loaded_extensions_info;
-	ValidChecker db_validity;
-	unique_ptr<DatabaseFileSystem> db_file_system;
-	shared_ptr<DatabaseCacheEntry> db_cache_entry;
-
-	duckdb_ext_api_v1 (*create_api_v1)();
-};
-
-//! The database object. This object holds the catalog and all the
-//! database-specific meta information.
-class DuckDB {
-public:
-	DUCKDB_API explicit DuckDB(const char *path = nullptr, DBConfig *config = nullptr);
-	DUCKDB_API explicit DuckDB(const string &path, DBConfig *config = nullptr);
-	DUCKDB_API explicit DuckDB(DatabaseInstance &instance);
-
-	DUCKDB_API ~DuckDB();
-
-	//! Reference to the actual database instance
-	shared_ptr<DatabaseInstance> instance;
-
-public:
-	// Load a statically loaded extension by its class
-	template <class T>
-	void LoadStaticExtension() {
-		T extension;
-		if (ExtensionIsLoaded(extension.Name())) {
-			return;
-		}
-		extension.Load(*this);
-		ExtensionInstallInfo install_info;
-		install_info.mode = ExtensionInstallMode::STATICALLY_LINKED;
-		install_info.version = extension.Version();
-		instance->SetExtensionLoaded(extension.Name(), install_info);
-	}
-
-	// DEPRECATED function that some extensions may still use to call their own Load method from the
-	// _init function of their loadable extension. Don't use this. Instead opt for a static LoadInternal function called
-	// from both the _init function and the Extension::Load. (see autocomplete extension)
-	// TODO: when to remove this function?
-	template <class T>
-	void LoadExtension() {
-		T extension;
-		extension.Load(*this);
-	}
-
-	DUCKDB_API FileSystem &GetFileSystem();
-
-	DUCKDB_API idx_t NumberOfThreads();
-	DUCKDB_API static const char *SourceID();
-	DUCKDB_API static const char *LibraryVersion();
-	DUCKDB_API static idx_t StandardVectorSize();
-	DUCKDB_API static string Platform();
-	DUCKDB_API bool ExtensionIsLoaded(const string &name);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/database_file_opener.hpp b/src/duckdb/src/include/duckdb/main/database_file_opener.hpp
deleted file mode 100644
index 024956aaa..000000000
--- a/src/duckdb/src/include/duckdb/main/database_file_opener.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/database_file_opener.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/common/opener_file_system.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-
-class DatabaseFileOpener : public FileOpener {
-public:
-	explicit DatabaseFileOpener(DatabaseInstance &db_p) : db(db_p) {
-	}
-
-	SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override {
-		return db.TryGetCurrentSetting(key, result);
-	}
-
-	optional_ptr<ClientContext> TryGetClientContext() override {
-		return nullptr;
-	}
-
-	optional_ptr<DatabaseInstance> TryGetDatabase() override {
-		return &db;
-	}
-
-private:
-	DatabaseInstance &db;
-};
-
-class DatabaseFileSystem : public OpenerFileSystem {
-public:
-	explicit DatabaseFileSystem(DatabaseInstance &db_p) : db(db_p), database_opener(db_p) {
-	}
-
-	FileSystem &GetFileSystem() const override {
-		auto &config = DBConfig::GetConfig(db);
-		return *config.file_system;
-	}
-	optional_ptr<FileOpener> GetOpener() const override {
-		return &database_opener;
-	}
-
-private:
-	DatabaseInstance &db;
-	mutable DatabaseFileOpener database_opener;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/database_manager.hpp b/src/duckdb/src/include/duckdb/main/database_manager.hpp
deleted file mode 100644
index c193c979f..000000000
--- a/src/duckdb/src/include/duckdb/main/database_manager.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/database_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/access_mode.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-
-namespace duckdb {
-class AttachedDatabase;
-class Catalog;
-class CatalogEntryRetriever;
-class CatalogSet;
-class ClientContext;
-class DatabaseInstance;
-class TaskScheduler;
-struct AttachOptions;
-
-//! The DatabaseManager is a class that sits at the root of all attached databases
-class DatabaseManager {
-	friend class Catalog;
-
-public:
-	explicit DatabaseManager(DatabaseInstance &db);
-	~DatabaseManager();
-
-public:
-	static DatabaseManager &Get(DatabaseInstance &db);
-	static DatabaseManager &Get(ClientContext &db);
-	static DatabaseManager &Get(AttachedDatabase &db);
-
-	//! Initializes the system catalog of the attached SYSTEM_DATABASE.
-	void InitializeSystemCatalog();
-	//! Get an attached database by its name
-	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
-	//! Attach a new database
-	optional_ptr<AttachedDatabase> AttachDatabase(ClientContext &context, const AttachInfo &info,
-	                                              const AttachOptions &options);
-	//! Detach an existing database
-	void DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found);
-	//! Returns a reference to the system catalog
-	Catalog &GetSystemCatalog();
-
-	static const string &GetDefaultDatabase(ClientContext &context);
-	void SetDefaultDatabase(ClientContext &context, const string &new_value);
-
-	//! Inserts a path to name mapping to the database paths map
-	void InsertDatabasePath(ClientContext &context, const string &path, const string &name);
-	//! Erases a path from the database paths map
-	void EraseDatabasePath(const string &path);
-
-	//! Returns the database type. This might require checking the header of the file, in which case the file handle is
-	//! necessary. We can only grab the file handle, if it is not yet held, even for uncommitted changes. Thus, we have
-	//! to lock for this operation.
-	void GetDatabaseType(ClientContext &context, AttachInfo &info, const DBConfig &config, AttachOptions &options);
-	//! Scans the catalog set and adds each committed database entry, and each database entry of the current
-	//! transaction, to a vector holding AttachedDatabase references
-	vector<reference<AttachedDatabase>> GetDatabases(ClientContext &context);
-	//! Removes all databases from the catalog set. This is necessary for the database instance's destructor,
-	//! as the database manager has to be alive when destroying the catalog set objects.
-	void ResetDatabases(unique_ptr<TaskScheduler> &scheduler);
-
-	transaction_t GetNewQueryNumber() {
-		return current_query_number++;
-	}
-	transaction_t ActiveQueryNumber() const {
-		return current_query_number;
-	}
-	idx_t NextOid() {
-		return next_oid++;
-	}
-	bool HasDefaultDatabase() {
-		return !default_database.empty();
-	}
-	//! Gets a list of all attached database paths
-	vector<string> GetAttachedDatabasePaths();
-
-private:
-	//! Returns a database with a specified path
-	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
-	void CheckPathConflict(ClientContext &context, const string &path);
-
-private:
-	//! The system database is a special database that holds system entries (e.g. functions)
-	unique_ptr<AttachedDatabase> system;
-	//! The set of attached databases
-	unique_ptr<CatalogSet> databases;
-	//! The next object id handed out by the NextOid method
-	atomic<idx_t> next_oid;
-	//! The current query number
-	atomic<transaction_t> current_query_number;
-	//! The current default database
-	string default_database;
-
-	//! The lock to add entries to the database path map
-	mutex db_paths_lock;
-	//! A set containing all attached database path
-	//! This allows to attach many databases efficiently, and to avoid attaching the
-	//! same file path twice
-	case_insensitive_set_t db_paths;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/database_path_and_type.hpp b/src/duckdb/src/include/duckdb/main/database_path_and_type.hpp
deleted file mode 100644
index cbf2a56f3..000000000
--- a/src/duckdb/src/include/duckdb/main/database_path_and_type.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/database_path_and_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <string>
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-struct DBPathAndType {
-	//! Parse database extension type and rest of path from combined form (type:path)
-	static void ExtractExtensionPrefix(string &path, string &db_type);
-	//! Check the magic bytes of a file and set the database type based on that
-	static void CheckMagicBytes(FileSystem &fs, string &path, string &db_type);
-
-	//! Run ExtractExtensionPrefix followed by CheckMagicBytes
-	static void ResolveDatabaseType(FileSystem &fs, string &path, string &db_type);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp b/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp
deleted file mode 100644
index b71d07e76..000000000
--- a/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/db_instance_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/function/replacement_scan.hpp"
-#include <functional>
-
-namespace duckdb {
-class DBInstanceCache;
-
-struct DatabaseCacheEntry {
-	explicit DatabaseCacheEntry(const shared_ptr<DuckDB> &database);
-	~DatabaseCacheEntry();
-
-	weak_ptr<DuckDB> database;
-};
-
-class DBInstanceCache {
-public:
-	DBInstanceCache() {
-	}
-
-	//! Gets a DB Instance from the cache if already exists (Fails if the configurations do not match)
-	shared_ptr<DuckDB> GetInstance(const string &database, const DBConfig &config_dict);
-
-	//! Creates and caches a new DB Instance (Fails if a cached instance already exists)
-	shared_ptr<DuckDB> CreateInstance(const string &database, DBConfig &config_dict, bool cache_instance = true,
-	                                  const std::function<void(DuckDB &)> &on_create = nullptr);
-
-	//! Either returns an existing entry, or creates and caches a new DB Instance
-	shared_ptr<DuckDB> GetOrCreateInstance(const string &database, DBConfig &config_dict, bool cache_instance,
-	                                       const std::function<void(DuckDB &)> &on_create = nullptr);
-
-private:
-	//! A map with the cached instances <absolute_path/instance>
-	unordered_map<string, weak_ptr<DatabaseCacheEntry>> db_instances;
-
-	//! Lock to alter cache
-	mutex cache_lock;
-
-private:
-	shared_ptr<DuckDB> GetInstanceInternal(const string &database, const DBConfig &config_dict);
-	shared_ptr<DuckDB> CreateInstanceInternal(const string &database, DBConfig &config_dict, bool cache_instance,
-	                                          const std::function<void(DuckDB &)> &on_create);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/error_manager.hpp b/src/duckdb/src/include/duckdb/main/error_manager.hpp
deleted file mode 100644
index bb3fcc944..000000000
--- a/src/duckdb/src/include/duckdb/main/error_manager.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/error_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/map.hpp"
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-class TransactionException;
-
-enum class ErrorType : uint16_t {
-	// error message types
-	UNSIGNED_EXTENSION = 0,
-	INVALIDATED_TRANSACTION = 1,
-	INVALIDATED_DATABASE = 2,
-
-	// this should always be the last value
-	ERROR_COUNT,
-	INVALID = 65535,
-};
-
-//! The error manager class is responsible for formatting error messages
-//! It allows for error messages to be overridden by extensions and clients
-class ErrorManager {
-public:
-	template <typename... ARGS>
-	string FormatException(ErrorType error_type, ARGS... params) {
-		vector<ExceptionFormatValue> values;
-		return FormatExceptionRecursive(error_type, values, params...);
-	}
-
-	DUCKDB_API string FormatExceptionRecursive(ErrorType error_type, vector<ExceptionFormatValue> &values);
-
-	template <class T, typename... ARGS>
-	string FormatExceptionRecursive(ErrorType error_type, vector<ExceptionFormatValue> &values, T param,
-	                                ARGS... params) {
-		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
-		return FormatExceptionRecursive(error_type, values, params...);
-	}
-
-	template <typename... ARGS>
-	static string FormatException(ClientContext &context, ErrorType error_type, ARGS... params) {
-		return Get(context).FormatException(error_type, params...);
-	}
-
-	DUCKDB_API static InvalidInputException InvalidUnicodeError(const string &input, const string &context);
-	DUCKDB_API static FatalException InvalidatedDatabase(ClientContext &context, const string &invalidated_msg);
-	DUCKDB_API static TransactionException InvalidatedTransaction(ClientContext &context);
-
-	//! Adds a custom error for a specific error type
-	void AddCustomError(ErrorType type, string new_error);
-
-	DUCKDB_API static ErrorManager &Get(ClientContext &context);
-	DUCKDB_API static ErrorManager &Get(DatabaseInstance &context);
-
-private:
-	map<ErrorType, string> custom_errors;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/extension.hpp b/src/duckdb/src/include/duckdb/main/extension.hpp
deleted file mode 100644
index 53de1481d..000000000
--- a/src/duckdb/src/include/duckdb/main/extension.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/winapi.hpp"
-
-namespace duckdb {
-class DuckDB;
-
-//! The Extension class is the base class used to define extensions
-class Extension {
-public:
-	DUCKDB_API virtual ~Extension();
-
-	DUCKDB_API virtual void Load(DuckDB &db) = 0;
-	DUCKDB_API virtual std::string Name() = 0;
-	DUCKDB_API virtual std::string Version() const {
-		return "";
-	}
-};
-
-enum class ExtensionABIType : uint8_t {
-	UNKNOWN = 0,
-	//! Uses C++ ABI, version needs to match precisely
-	CPP = 1,
-	//! Uses C ABI using the duckdb_ext_api_v1 struct, version needs to be equal or higher
-	C_STRUCT = 2,
-	//! Uses C ABI using the duckdb_ext_api_v1 struct including "unstable" functions, version needs to match precisely
-	C_STRUCT_UNSTABLE = 3
-};
-
-//! The parsed extension metadata footer
-struct ParsedExtensionMetaData {
-	static constexpr const idx_t FOOTER_SIZE = 512;
-	static constexpr const idx_t SIGNATURE_SIZE = 256;
-	static constexpr const char *EXPECTED_MAGIC_VALUE = {
-	    "4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
-
-	string magic_value;
-
-	ExtensionABIType abi_type;
-
-	string platform;
-	// (For ExtensionABIType::CPP or ExtensionABIType::C_STRUCT_UNSTABLE) the DuckDB version this extension is compiled
-	// for
-	string duckdb_version;
-	// (only for ExtensionABIType::C_STRUCT) the CAPI version of the C_STRUCT (Currently interpreted as the minimum
-	// DuckDB version)
-	string duckdb_capi_version;
-	string extension_version;
-	string signature;
-	string extension_abi_metadata;
-
-	bool AppearsValid() {
-		return magic_value == EXPECTED_MAGIC_VALUE;
-	}
-
-	// Returns an error string describing which parts of the metadata are mismatcheds
-	string GetInvalidMetadataError();
-};
-
-struct VersioningUtils {
-	//! Note: only supports format v{major}.{minor}.{patch}
-	static bool ParseSemver(string &semver, idx_t &major_out, idx_t &minor_out, idx_t &patch_out);
-
-	//! Note: only supports format v{major}.{minor}.{patch}
-	static bool IsSupportedCAPIVersion(string &capi_version_string);
-	static bool IsSupportedCAPIVersion(idx_t major, idx_t minor, idx_t patch);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/extension/generated_extension_loader.hpp b/src/duckdb/src/include/duckdb/main/extension/generated_extension_loader.hpp
deleted file mode 100644
index eb98d38cb..000000000
--- a/src/duckdb/src/include/duckdb/main/extension/generated_extension_loader.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension/generated_extension_loader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/database.hpp"
-
-#if defined(GENERATED_EXTENSION_HEADERS) && !defined(DUCKDB_AMALGAMATION)
-#include "duckdb/common/common.hpp"
-#include "generated_extension_headers.hpp"
-
-namespace duckdb {
-
-//! Looks through the CMake-generated list of extensions that are linked into DuckDB currently to try load <extension>
-bool TryLoadLinkedExtension(DuckDB &db, const string &extension);
-
-const vector<string> &LinkedExtensions();
-const vector<string> &LoadedExtensionTestPaths();
-
-} // namespace duckdb
-#endif
diff --git a/src/duckdb/src/include/duckdb/main/extension_entries.hpp b/src/duckdb/src/include/duckdb/main/extension_entries.hpp
deleted file mode 100644
index b0d0c0c41..000000000
--- a/src/duckdb/src/include/duckdb/main/extension_entries.hpp
+++ /dev/null
@@ -1,1074 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension_entries.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-
-// NOTE: this file is generated by scripts/generate_extensions_function.py.
-// Example usage to refresh one extension (replace "icu" with the desired extension):
-// GENERATE_EXTENSION_ENTRIES=1 make debug
-// python3 scripts/generate_extensions_function.py --extensions icu --shell build/debug/duckdb --extension_dir
-// build/debug
-
-// Check out the check-load-install-extensions  job in .github/workflows/LinuxRelease.yml for more details
-
-namespace duckdb {
-
-struct ExtensionEntry {
-	char name[48];
-	char extension[48];
-};
-
-struct ExtensionFunctionEntry {
-	char name[48];
-	char extension[48];
-	CatalogType type;
-};
-
-struct ExtensionFunctionOverloadEntry {
-	char name[48];
-	char extension[48];
-	CatalogType type;
-	char signature[96];
-};
-
-static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
-    {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"<<", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"<<=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"<=>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"<@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {">>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {">>=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"@>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"^", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"^@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"abs", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"acos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"acosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"add_numbers_together", "demo_capi", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"alias", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"approx_count_distinct", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"approx_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"approx_top_k", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"arg_max", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"arg_max_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"arg_min", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"arg_min_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"argmax", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"argmin", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"array_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"array_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_cross_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"array_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"ascii", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"asin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"asinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"atan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"atan2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"atanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"avg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"bar", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"bit_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"bit_count", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"bit_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"bit_position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"bit_xor", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"bitstring", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"bitstring_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"bool_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"bool_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"broadcast", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"can_cast_implicitly", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"cardinality", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"cbrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"ceil", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"ceiling", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"check_peg_parser", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"chr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"corr", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"cos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"cosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"cot", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"count_if", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"countif", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"covar_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"covar_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"current_database", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"current_query", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"current_schema", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"current_schemas", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"current_setting", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"damerau_levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"dbgen", "tpch", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"degrees", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"delta_scan", "delta", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"drop_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"dsdgen", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"editdist3", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"element_at", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"entropy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"enum_code", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"enum_first", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"enum_last", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"enum_range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"enum_range_boundary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"epoch_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"epoch_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"epoch_us", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"equi_width_bins", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"even", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"excel_text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"exp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"factorial", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"family", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"favg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"flatten", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"floor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"format", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"format_bytes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"formatreadabledecimalsize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"formatreadablesize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"from_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"from_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"from_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"from_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"from_json_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"from_substrait", "substrait", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"from_substrait_json", "substrait", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"fsum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"fuzz_all_functions", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"gamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"gcd", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"gen_random_uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"get_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"get_current_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"get_substrait", "substrait", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"get_substrait_json", "substrait", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"greatest", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"greatest_common_divisor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"group_concat", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"hamming", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"hash", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"histogram", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"histogram_exact", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"html_escape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"html_unescape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ar", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ar_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_as", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_az", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_be", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_bg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_bn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_bo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_br", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_bs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ceb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_chr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_cs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_cy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_da", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_de", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_de_at", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_dsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_dz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ee", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_el", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_en", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_en_us", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_eo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_es", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_et", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fa_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fil", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fr_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_fy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ga", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_gl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_gu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ha", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_haw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_he", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_he_il", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_hi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_hr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_hsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_hu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_hy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_id_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ig", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_is", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_it", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ja", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ka", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_kk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_kl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_km", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_kn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ko", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_kok", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ku", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ky", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_lb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_lkt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ln", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_lo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_lt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_lv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_mk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ml", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_mn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_mr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ms", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_mt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_my", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_nb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_nb_no", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ne", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_nl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_nn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_noaccent", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_om", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_or", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_pa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_pa_in", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_pl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ps", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_pt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ro", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ru", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_se", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_si", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_smn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sq", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sr_ba", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sr_me", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sr_rs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_sw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ta", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_te", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_th", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_tk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_to", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_tr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ug", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_uk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_ur", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_uz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_vi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_wae", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_wo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_xh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_yi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_yo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_yue", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_yue_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zh_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zh_hk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zh_mo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zh_sg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zh_tw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_collate_zu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"icu_sort_key", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"in_search_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"instr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"is_histogram_other_bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"isfinite", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"isinf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"isnan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"jaccard", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"jaro_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"jaro_winkler_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json", "json", CatalogType::MACRO_ENTRY},
-    {"json_array", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_array_length", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_contains", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"json_exists", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_extract_string", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_group_array", "json", CatalogType::MACRO_ENTRY},
-    {"json_group_object", "json", CatalogType::MACRO_ENTRY},
-    {"json_group_structure", "json", CatalogType::MACRO_ENTRY},
-    {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_pretty", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_structure", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_transform", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"json_value", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"kahan_sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"kurtosis", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"kurtosis_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"lcm", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"least", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"least_common_multiple", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"left", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"left_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"lgamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"list_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_pack", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"list_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"listagg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"ln", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"log", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"log10", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"log2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"lpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"ltrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"mad", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map_concat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map_from_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map_keys", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"map_values", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"max_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"mean", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"median", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"min_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"mismatches", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"mode", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"mysql_clear_cache", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"mysql_execute", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"mysql_query", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"nanosecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"netmask", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"network", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"nextafter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"normalized_interval", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"now", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"ord", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"parquet_bloom_probe", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"parquet_scan", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"parquet_schema", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"parse_dirname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"parse_dirpath", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"parse_filename", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"parse_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"pi", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"postgres_execute", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"pow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"power", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"pragma_rtree_index_info", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"printf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"product", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"quantile_cont", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"quantile_disc", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"radians", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"random", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_json_objects_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_ndjson", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_ndjson_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_ndjson_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"read_xlsx", "excel", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"regr_avgx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_avgy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_count", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_intercept", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_r2", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_slope", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_sxx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_sxy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"right_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"round", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"rpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"rtree_index_dump", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"rtree_index_scan", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"rtrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"scan_arrow_ipc", "arrow", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"sem", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"set_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"setseed", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"sign", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"signbit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"sin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"sinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"skewness", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"sqlite_attach", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"sqlite_scan", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"sqlsmith", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"sqrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_area", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_buffer", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_centroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_collect", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_collectionextract", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_contains", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_containsproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_convexhull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_coveredby", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_covers", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_crosses", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_difference", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_distance_sphere", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_dwithin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_dwithin_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_endpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_envelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_extent_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"st_extent_approx", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_generatepoints", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_intersects_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_isclosed", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_isempty", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_isring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_issimple", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_isvalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_length", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_list_proj_crs", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_mmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_mmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_multi", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_ngeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_ninteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_normalize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_npoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_numgeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_numinteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_numpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_overlaps", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_perimeter", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_perimeter_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_point", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_point2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_point2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_point3d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_points", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_read_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_readosm", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_readshp", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_shortestline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_touches", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_transform", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_union", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_union_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"st_within", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_x", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_xmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_xmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_y", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_ymax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"starts_with", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"stats", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"stddev", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"stddev_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"stddev_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"tan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"tanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"timetz_byte_comparable", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_arrow_ipc", "arrow", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"to_base", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_centuries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_days", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_decades", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_hours", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_microseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_millennia", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_milliseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_minutes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_months", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_quarters", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_seconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_weeks", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"to_years", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"tpcds", "tpcds", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"tpcds_answers", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"tpcds_queries", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY},
-    {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"transaction_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"translate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"trim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"txid_current", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"typeof", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"unbin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"unhex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"unicode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"union_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"union_tag", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"union_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"unpivot_list", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"url_decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"url_encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"var_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"var_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"variance", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"vector_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"vss_join", "vss", CatalogType::TABLE_MACRO_ENTRY},
-    {"vss_match", "vss", CatalogType::TABLE_MACRO_ENTRY},
-    {"xor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"|", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"~", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-}; // END_OF_EXTENSION_FUNCTIONS
-
-static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] = {
-    {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>INTERVAL"},
-    {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP,TIMESTAMP>INTERVAL"},
-    {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>INTERVAL"},
-    {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ,TIMESTAMPTZ>INTERVAL"},
-    {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"century", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE,DATE>BIGINT"},
-    {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIME,TIME>BIGINT"},
-    {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP,TIMESTAMP>BIGINT"},
-    {"date_diff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,INTERVAL>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIME>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMETZ>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],DATE>STRUCT()"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],INTERVAL>STRUCT()"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIME>STRUCT()"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIMESTAMP>STRUCT()"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIMETZ>STRUCT()"},
-    {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ>BIGINT"},
-    {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIMESTAMPTZ>STRUCT()"},
-    {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE,DATE>BIGINT"},
-    {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIME,TIME>BIGINT"},
-    {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP,TIMESTAMP>BIGINT"},
-    {"date_sub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ>BIGINT"},
-    {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE>TIMESTAMP"},
-    {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,INTERVAL>INTERVAL"},
-    {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP>TIMESTAMP"},
-    {"date_trunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ>TIMESTAMPTZ"},
-    {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE,DATE>BIGINT"},
-    {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIME,TIME>BIGINT"},
-    {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP,TIMESTAMP>BIGINT"},
-    {"datediff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,INTERVAL>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIME>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMETZ>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],DATE>STRUCT()"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],INTERVAL>STRUCT()"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIME>STRUCT()"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIMESTAMP>STRUCT()"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIMETZ>STRUCT()"},
-    {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ>BIGINT"},
-    {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR[],TIMESTAMPTZ>STRUCT()"},
-    {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE,DATE>BIGINT"},
-    {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIME,TIME>BIGINT"},
-    {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP,TIMESTAMP>BIGINT"},
-    {"datesub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ>BIGINT"},
-    {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,DATE>TIMESTAMP"},
-    {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,INTERVAL>INTERVAL"},
-    {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP>TIMESTAMP"},
-    {"datetrunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ>TIMESTAMPTZ"},
-    {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>VARCHAR"},
-    {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>VARCHAR"},
-    {"dayname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>VARCHAR"},
-    {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"dayofmonth", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"dayofweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"dayofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"decade", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>DOUBLE"},
-    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>DOUBLE"},
-    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIME>DOUBLE"},
-    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>DOUBLE"},
-    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMETZ>DOUBLE"},
-    {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>DOUBLE"},
-    {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"era", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "BIGINT>BIGINT[]"},
-    {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "BIGINT,BIGINT>BIGINT[]"},
-    {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "BIGINT,BIGINT,BIGINT>BIGINT[]"},
-    {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY,
-     "TIMESTAMP,TIMESTAMP,INTERVAL>TIMESTAMP[]"},
-    {"generate_series", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL>TIMESTAMPTZ[]"},
-    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIME>BIGINT"},
-    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMETZ>BIGINT"},
-    {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"isodow", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"isoyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>DOUBLE"},
-    {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>DOUBLE"},
-    {"julian", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>DOUBLE"},
-    {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>DATE"},
-    {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>DATE"},
-    {"last_day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>DATE"},
-    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIME>BIGINT"},
-    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMETZ>BIGINT"},
-    {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"millennium", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIME>BIGINT"},
-    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMETZ>BIGINT"},
-    {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIME>BIGINT"},
-    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMETZ>BIGINT"},
-    {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"month", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>VARCHAR"},
-    {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>VARCHAR"},
-    {"monthname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>VARCHAR"},
-    {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"quarter", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "BIGINT>BIGINT[]"},
-    {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "BIGINT,BIGINT>BIGINT[]"},
-    {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "BIGINT,BIGINT,BIGINT>BIGINT[]"},
-    {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP,TIMESTAMP,INTERVAL>TIMESTAMP[]"},
-    {"range", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL>TIMESTAMPTZ[]"},
-    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIME>BIGINT"},
-    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMETZ>BIGINT"},
-    {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,DATE>DATE"},
-    {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,DATE,DATE>DATE"},
-    {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,DATE,INTERVAL>DATE"},
-    {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMP>TIMESTAMP"},
-    {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMP,INTERVAL>TIMESTAMP"},
-    {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMP,TIMESTAMP>TIMESTAMP"},
-    {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMPTZ>TIMESTAMPTZ"},
-    {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMPTZ,INTERVAL>TIMESTAMPTZ"},
-    {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMPTZ,TIMESTAMPTZ>TIMESTAMPTZ"},
-    {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMESTAMPTZ,VARCHAR>TIMESTAMPTZ"},
-    {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL,TIMETZ>TIMETZ"},
-    {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMP>TIMESTAMPTZ"},
-    {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMESTAMPTZ>TIMESTAMP"},
-    {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "VARCHAR,TIMETZ>TIMETZ"},
-    {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"timezone_hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"timezone_minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"week", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"weekday", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"weekofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"year", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-    {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "DATE>BIGINT"},
-    {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "INTERVAL>BIGINT"},
-    {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMP>BIGINT"},
-    {"yearweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "TIMESTAMPTZ>BIGINT"},
-}; // END_OF_EXTENSION_FUNCTION_OVERLOADS
-
-static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
-    {"azure_account_name", "azure"},
-    {"azure_context_caching", "azure"},
-    {"azure_credential_chain", "azure"},
-    {"azure_endpoint", "azure"},
-    {"azure_http_proxy", "azure"},
-    {"azure_http_stats", "azure"},
-    {"azure_proxy_password", "azure"},
-    {"azure_proxy_user_name", "azure"},
-    {"azure_read_buffer_size", "azure"},
-    {"azure_read_transfer_chunk_size", "azure"},
-    {"azure_read_transfer_concurrency", "azure"},
-    {"azure_storage_connection_string", "azure"},
-    {"azure_transport_option_type", "azure"},
-    {"binary_as_string", "parquet"},
-    {"ca_cert_file", "httpfs"},
-    {"calendar", "icu"},
-    {"disable_parquet_prefetching", "parquet"},
-    {"enable_geoparquet_conversion", "parquet"},
-    {"enable_server_cert_verification", "httpfs"},
-    {"force_download", "httpfs"},
-    {"hf_max_per_page", "httpfs"},
-    {"hnsw_ef_search", "vss"},
-    {"hnsw_enable_experimental_persistence", "vss"},
-    {"http_keep_alive", "httpfs"},
-    {"http_retries", "httpfs"},
-    {"http_retry_backoff", "httpfs"},
-    {"http_retry_wait_ms", "httpfs"},
-    {"http_timeout", "httpfs"},
-    {"mysql_bit1_as_boolean", "mysql_scanner"},
-    {"mysql_debug_show_queries", "mysql_scanner"},
-    {"mysql_experimental_filter_pushdown", "mysql_scanner"},
-    {"mysql_tinyint1_as_boolean", "mysql_scanner"},
-    {"parquet_metadata_cache", "parquet"},
-    {"pg_array_as_varchar", "postgres_scanner"},
-    {"pg_connection_cache", "postgres_scanner"},
-    {"pg_connection_limit", "postgres_scanner"},
-    {"pg_debug_show_queries", "postgres_scanner"},
-    {"pg_experimental_filter_pushdown", "postgres_scanner"},
-    {"pg_null_byte_replacement", "postgres_scanner"},
-    {"pg_pages_per_task", "postgres_scanner"},
-    {"pg_use_binary_copy", "postgres_scanner"},
-    {"pg_use_ctid_scan", "postgres_scanner"},
-    {"prefetch_all_parquet_files", "parquet"},
-    {"s3_access_key_id", "httpfs"},
-    {"s3_endpoint", "httpfs"},
-    {"s3_region", "httpfs"},
-    {"s3_secret_access_key", "httpfs"},
-    {"s3_session_token", "httpfs"},
-    {"s3_uploader_max_filesize", "httpfs"},
-    {"s3_uploader_max_parts_per_file", "httpfs"},
-    {"s3_uploader_thread_limit", "httpfs"},
-    {"s3_url_compatibility_mode", "httpfs"},
-    {"s3_url_style", "httpfs"},
-    {"s3_use_ssl", "httpfs"},
-    {"sqlite_all_varchar", "sqlite_scanner"},
-    {"timezone", "icu"},
-}; // END_OF_EXTENSION_SETTINGS
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = {{"parquet", "parquet"},
-                                                              {"json", "json"}}; // END_OF_EXTENSION_COPY_FUNCTIONS
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_TYPES[] = {
-    {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = {
-    {"af", "icu"},    {"am", "icu"},    {"ar", "icu"},     {"ar_sa", "icu"}, {"as", "icu"},    {"az", "icu"},
-    {"be", "icu"},    {"bg", "icu"},    {"bn", "icu"},     {"bo", "icu"},    {"br", "icu"},    {"bs", "icu"},
-    {"ca", "icu"},    {"ceb", "icu"},   {"chr", "icu"},    {"cs", "icu"},    {"cy", "icu"},    {"da", "icu"},
-    {"de", "icu"},    {"de_at", "icu"}, {"dsb", "icu"},    {"dz", "icu"},    {"ee", "icu"},    {"el", "icu"},
-    {"en", "icu"},    {"en_us", "icu"}, {"eo", "icu"},     {"es", "icu"},    {"et", "icu"},    {"fa", "icu"},
-    {"fa_af", "icu"}, {"ff", "icu"},    {"fi", "icu"},     {"fil", "icu"},   {"fo", "icu"},    {"fr", "icu"},
-    {"fr_ca", "icu"}, {"fy", "icu"},    {"ga", "icu"},     {"gl", "icu"},    {"gu", "icu"},    {"ha", "icu"},
-    {"haw", "icu"},   {"he", "icu"},    {"he_il", "icu"},  {"hi", "icu"},    {"hr", "icu"},    {"hsb", "icu"},
-    {"hu", "icu"},    {"hy", "icu"},    {"id", "icu"},     {"id_id", "icu"}, {"ig", "icu"},    {"is", "icu"},
-    {"it", "icu"},    {"ja", "icu"},    {"ka", "icu"},     {"kk", "icu"},    {"kl", "icu"},    {"km", "icu"},
-    {"kn", "icu"},    {"ko", "icu"},    {"kok", "icu"},    {"ku", "icu"},    {"ky", "icu"},    {"lb", "icu"},
-    {"lkt", "icu"},   {"ln", "icu"},    {"lo", "icu"},     {"lt", "icu"},    {"lv", "icu"},    {"mk", "icu"},
-    {"ml", "icu"},    {"mn", "icu"},    {"mr", "icu"},     {"ms", "icu"},    {"mt", "icu"},    {"my", "icu"},
-    {"nb", "icu"},    {"nb_no", "icu"}, {"ne", "icu"},     {"nl", "icu"},    {"nn", "icu"},    {"om", "icu"},
-    {"or", "icu"},    {"pa", "icu"},    {"pa_in", "icu"},  {"pl", "icu"},    {"ps", "icu"},    {"pt", "icu"},
-    {"ro", "icu"},    {"ru", "icu"},    {"sa", "icu"},     {"se", "icu"},    {"si", "icu"},    {"sk", "icu"},
-    {"sl", "icu"},    {"smn", "icu"},   {"sq", "icu"},     {"sr", "icu"},    {"sr_ba", "icu"}, {"sr_me", "icu"},
-    {"sr_rs", "icu"}, {"sv", "icu"},    {"sw", "icu"},     {"ta", "icu"},    {"te", "icu"},    {"th", "icu"},
-    {"tk", "icu"},    {"to", "icu"},    {"tr", "icu"},     {"ug", "icu"},    {"uk", "icu"},    {"ur", "icu"},
-    {"uz", "icu"},    {"vi", "icu"},    {"wae", "icu"},    {"wo", "icu"},    {"xh", "icu"},    {"yi", "icu"},
-    {"yo", "icu"},    {"yue", "icu"},   {"yue_cn", "icu"}, {"zh", "icu"},    {"zh_cn", "icu"}, {"zh_hk", "icu"},
-    {"zh_mo", "icu"}, {"zh_sg", "icu"}, {"zh_tw", "icu"},  {"zu", "icu"}}; // END_OF_EXTENSION_COLLATIONS
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = {
-    {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"},  {"s3n://", "httpfs"},
-    {"gcs://", "httpfs"},  {"gs://", "httpfs"},    {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"},
-    {"abfss://", "azure"}, {"hf://", "httpfs"}}; // END_OF_EXTENSION_FILE_PREFIXES
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_FILE_POSTFIXES[] = {
-    {".parquet", "parquet"}, {".json", "json"},    {".jsonl", "json"},  {".ndjson", "json"},
-    {".shp", "spatial"},     {".gpkg", "spatial"}, {".fgb", "spatial"}, {".xlsx", "excel"},
-}; // END_OF_EXTENSION_FILE_POSTFIXES
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = {{".parquet?", "parquet"},
-                                                             {".json?", "json"},
-                                                             {".ndjson?", ".jsonl?"},
-                                                             {".jsonl?", ".ndjson?"}}; // EXTENSION_FILE_CONTAINS
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_SECRET_TYPES[] = {
-    {"s3", "httpfs"},           {"r2", "httpfs"},
-    {"gcs", "httpfs"},          {"azure", "azure"},
-    {"huggingface", "httpfs"},  {"bearer", "httpfs"},
-    {"mysql", "mysql_scanner"}, {"postgres", "postgres_scanner"}}; // EXTENSION_SECRET_TYPES
-
-// Note: these are currently hardcoded in scripts/generate_extensions_function.py
-// TODO: automate by passing though to script via duckdb
-static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = {
-    {"s3/config", "httpfs"},
-    {"gcs/config", "httpfs"},
-    {"r2/config", "httpfs"},
-    {"s3/credential_chain", "aws"},
-    {"gcs/credential_chain", "aws"},
-    {"r2/credential_chain", "aws"},
-    {"azure/access_token", "azure"},
-    {"azure/config", "azure"},
-    {"azure/credential_chain", "azure"},
-    {"azure/service_principal", "azure"},
-    {"huggingface/config", "httfps"},
-    {"huggingface/credential_chain", "httpfs"},
-    {"bearer/config", "httpfs"},
-    {"mysql/config", "mysql_scanner"},
-    {"postgres/config", "postgres_scanner"}}; // EXTENSION_SECRET_PROVIDERS
-
-static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {
-    "aws",   "azure", "autocomplete", "core_functions", "delta",   "excel",          "fts",      "httpfs",
-    "inet",  "icu",   "json",         "mysql_scanner",  "parquet", "sqlite_scanner", "sqlsmith", "postgres_scanner",
-    "tpcds", "tpch"}; // END_OF_AUTOLOADABLE_EXTENSIONS
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/extension_helper.hpp b/src/duckdb/src/include/duckdb/main/extension_helper.hpp
deleted file mode 100644
index 7a7c3ed9e..000000000
--- a/src/duckdb/src/include/duckdb/main/extension_helper.hpp
+++ /dev/null
@@ -1,259 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension_helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#include "duckdb/main/extension_entries.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-
-#include <string>
-
-namespace duckdb {
-
-class DuckDB;
-class HTTPLogger;
-
-enum class ExtensionLoadResult : uint8_t { LOADED_EXTENSION = 0, EXTENSION_UNKNOWN = 1, NOT_LOADED = 2 };
-
-struct DefaultExtension {
-	const char *name;
-	const char *description;
-	bool statically_loaded;
-};
-
-struct ExtensionAlias {
-	const char *alias;
-	const char *extension;
-};
-
-struct ExtensionInitResult {
-	string filename;
-	string filebase;
-	ExtensionABIType abi_type = ExtensionABIType::UNKNOWN;
-
-	// The deserialized install from the `<ext>.duckdb_extension.info` file
-	unique_ptr<ExtensionInstallInfo> install_info;
-
-	void *lib_hdl;
-};
-
-// Tags describe what happened during the updating process
-enum class ExtensionUpdateResultTag : uint8_t {
-	// Fallback for when installation information is missing
-	UNKNOWN = 0,
-
-	// Either a fresh file was downloaded and versions are identical
-	NO_UPDATE_AVAILABLE = 1,
-	// Only extensions from repositories can be updated
-	NOT_A_REPOSITORY = 2,
-	// Only known, currently installed extensions can be updated
-	NOT_INSTALLED = 3,
-	// Statically loaded extensions can not be updated; they are baked into the DuckDB executable
-	STATICALLY_LOADED = 4,
-	// This means the .info file written during installation was missing or malformed
-	MISSING_INSTALL_INFO = 5,
-
-	// The extension was re-downloaded from the repository, but due to a lack of version information
-	// its impossible to tell if the extension is actually updated
-	REDOWNLOADED = 254,
-	// The version was updated to a new version
-	UPDATED = 255,
-};
-
-struct ExtensionUpdateResult {
-	ExtensionUpdateResultTag tag = ExtensionUpdateResultTag::UNKNOWN;
-
-	string extension_name;
-	string repository;
-
-	string extension_version;
-	string prev_version;
-	string installed_version;
-};
-
-struct ExtensionInstallOptions {
-	//! Install from a different repository that the default one
-	optional_ptr<ExtensionRepository> repository;
-	//! Install a specific version of the extension
-	string version;
-
-	//! Overwrite existing installation
-	bool force_install = false;
-	//! Use etags to avoid downloading unchanged extension files
-	bool use_etags = false;
-	//! Throw an error when installing an extension with a different origin than the one that is installed
-	bool throw_on_origin_mismatch = false;
-};
-
-class ExtensionHelper {
-public:
-	static void LoadAllExtensions(DuckDB &db);
-
-	static ExtensionLoadResult LoadExtension(DuckDB &db, const std::string &extension);
-
-	//! Install an extension
-	static unique_ptr<ExtensionInstallInfo> InstallExtension(ClientContext &context, const string &extension,
-	                                                         ExtensionInstallOptions &options);
-	static unique_ptr<ExtensionInstallInfo> InstallExtension(DatabaseInstance &db, FileSystem &fs,
-	                                                         const string &extension, ExtensionInstallOptions &options);
-	//! Load an extension
-	static void LoadExternalExtension(ClientContext &context, const string &extension);
-	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension);
-
-	//! Autoload an extension (depending on config, potentially a nop. Throws when installation fails)
-	static void AutoLoadExtension(ClientContext &context, const string &extension_name);
-	static void AutoLoadExtension(DatabaseInstance &db, const string &extension_name);
-
-	//! Autoload an extension (depending on config, potentially a nop. Returns false on failure)
-	DUCKDB_API static bool TryAutoLoadExtension(DatabaseInstance &db, const string &extension_name) noexcept;
-	DUCKDB_API static bool TryAutoLoadExtension(ClientContext &context, const string &extension_name) noexcept;
-
-	//! Update all extensions, return a vector of extension names that were updated;
-	static vector<ExtensionUpdateResult> UpdateExtensions(ClientContext &context);
-	//! Update a specific extension
-	static ExtensionUpdateResult UpdateExtension(ClientContext &context, const string &extension_name);
-
-	//! Get the extension directory base on the current config
-	static string ExtensionDirectory(ClientContext &context);
-	static string ExtensionDirectory(DatabaseInstance &db, FileSystem &fs);
-
-	// Get the extension directory path
-	static string GetExtensionDirectoryPath(ClientContext &context);
-	static string GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs);
-
-	static bool CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata,
-	                                    const bool allow_community_extensions);
-	static ParsedExtensionMetaData ParseExtensionMetaData(const char *metadata) noexcept;
-	static ParsedExtensionMetaData ParseExtensionMetaData(FileHandle &handle);
-
-	//! Get the extension url template, containing placeholders for version, platform and extension name
-	static string ExtensionUrlTemplate(optional_ptr<const DatabaseInstance> db, const ExtensionRepository &repository,
-	                                   const string &version);
-	//! Return the extension url template with the variables replaced
-	static string ExtensionFinalizeUrlTemplate(const string &url, const string &name);
-
-	//! Default extensions are all extensions that DuckDB knows and expect to be available (both in-tree and
-	//! out-of-tree)
-	static idx_t DefaultExtensionCount();
-	static DefaultExtension GetDefaultExtension(idx_t index);
-
-	//! Extension can have aliases
-	static idx_t ExtensionAliasCount();
-	static ExtensionAlias GetExtensionAlias(idx_t index);
-
-	//! Get public signing keys for extension signing
-	static const vector<string> GetPublicKeys(bool allow_community_extension = false);
-
-	// Returns extension name, or empty string if not a replacement open path
-	static string ExtractExtensionPrefixFromPath(const string &path);
-
-	// Returns the user-readable name of a repository URL
-	static string GetRepositoryName(const string &repository_base_url);
-
-	//! Apply any known extension aliases, return the lowercase name
-	static string ApplyExtensionAlias(const string &extension_name);
-
-	static string GetExtensionName(const string &extension);
-	static bool IsFullPath(const string &extension);
-
-	//! Lookup a name + type in an ExtensionFunctionEntry list
-	template <size_t N>
-	static vector<pair<string, CatalogType>>
-	FindExtensionInFunctionEntries(const string &name, const ExtensionFunctionEntry (&entries)[N]) {
-		auto lcase = StringUtil::Lower(name);
-
-		vector<pair<string, CatalogType>> result;
-		for (idx_t i = 0; i < N; i++) {
-			auto &element = entries[i];
-			if (element.name == lcase) {
-				result.push_back(make_pair(element.extension, element.type));
-			}
-		}
-		return result;
-	}
-
-	template <idx_t N>
-	static idx_t ArraySize(const ExtensionEntry (&entries)[N]) {
-		return N;
-	}
-
-	template <idx_t N>
-	static const ExtensionEntry *GetArrayEntry(const ExtensionEntry (&entries)[N], idx_t entry) {
-		if (entry >= N) {
-			return nullptr;
-		}
-		return entries + entry;
-	}
-
-	//! Lookup a name in an ExtensionEntry list
-	template <idx_t N>
-	static string FindExtensionInEntries(const string &name, const ExtensionEntry (&entries)[N]) {
-		auto lcase = StringUtil::Lower(name);
-
-		auto it =
-		    std::find_if(entries, entries + N, [&](const ExtensionEntry &element) { return element.name == lcase; });
-
-		if (it != entries + N && it->name == lcase) {
-			return it->extension;
-		}
-		return "";
-	}
-
-	//! Lookup a name in an extension entry and try to autoload it
-	template <idx_t N>
-	static void TryAutoloadFromEntry(DatabaseInstance &db, const string &entry, const ExtensionEntry (&entries)[N]) {
-		auto &dbconfig = DBConfig::GetConfig(db);
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-		if (dbconfig.options.autoload_known_extensions) {
-			auto extension_name = ExtensionHelper::FindExtensionInEntries(entry, entries);
-			if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
-				ExtensionHelper::AutoLoadExtension(db, extension_name);
-			}
-		}
-#endif
-	}
-
-	//! Whether an extension can be autoloaded (i.e. it's registered as an autoloadable extension in
-	//! extension_entries.hpp)
-	static bool CanAutoloadExtension(const string &ext_name);
-
-	//! Utility functions for creating meaningful error messages regarding missing extensions
-	static string WrapAutoLoadExtensionErrorMsg(ClientContext &context, const string &base_error,
-	                                            const string &extension_name);
-	static string AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error,
-	                                                const string &extension_name);
-	static string AddExtensionInstallHintToErrorMsg(DatabaseInstance &db, const string &base_error,
-	                                                const string &extension_name);
-
-	//! For tagged releases we use the tag, else we use the git commit hash
-	static const string GetVersionDirectoryName();
-
-	static bool IsRelease(const string &version_tag);
-	static bool CreateSuggestions(const string &extension_name, string &message);
-
-private:
-	static unique_ptr<ExtensionInstallInfo> InstallExtensionInternal(DatabaseInstance &db, FileSystem &fs,
-	                                                                 const string &local_path, const string &extension,
-	                                                                 ExtensionInstallOptions &options,
-	                                                                 optional_ptr<HTTPLogger> http_logger = nullptr,
-	                                                                 optional_ptr<ClientContext> context = nullptr);
-	static const vector<string> PathComponents();
-	static string DefaultExtensionFolder(FileSystem &fs);
-	static bool AllowAutoInstall(const string &extension);
-	static ExtensionInitResult InitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension);
-	static bool TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension,
-	                           ExtensionInitResult &result, string &error);
-	//! Version tags occur with and without 'v', tag in extension path is always with 'v'
-	static const string NormalizeVersionTag(const string &version_tag);
-
-private:
-	static ExtensionLoadResult LoadExtensionInternal(DuckDB &db, const std::string &extension, bool initial_load);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/extension_install_info.hpp b/src/duckdb/src/include/duckdb/main/extension_install_info.hpp
deleted file mode 100644
index 6ccd1a115..000000000
--- a/src/duckdb/src/include/duckdb/main/extension_install_info.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension_install_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/main/config.hpp"
-
-#pragma once
-
-namespace duckdb {
-class FileSystem;
-
-enum class ExtensionInstallMode : uint8_t {
-	// Fallback for when install info is missing
-	UNKNOWN = 0,
-	//! Extension was installed using a url deduced from a repository base url
-	REPOSITORY = 1,
-	//! Extension was install from a custom path, this could be either local or remote
-	CUSTOM_PATH = 2,
-	//! Extension was statically linked
-	STATICALLY_LINKED = 3,
-	//! Extension is not installed, for example the extension might be directly loaded without installing
-	NOT_INSTALLED = 4
-};
-
-struct ExtensionLoadedInfo {
-	string description;
-};
-
-class ExtensionInstallInfo {
-public:
-	//! How the extension was installed
-	ExtensionInstallMode mode = ExtensionInstallMode::UNKNOWN;
-	//! (optional) Full path where the extension came from
-	string full_path;
-	//! (optional) Repository url where the extension came from
-	string repository_url;
-	//! (optional) Version of the extension
-	string version;
-	//! (optional) ETag of last fetched resource
-	string etag;
-
-	void Serialize(Serializer &serializer) const;
-
-	//! Try to read install info. returns ExtensionInstallMode::UNKNOWN on missing file, and throws on corrupt file
-	static unique_ptr<ExtensionInstallInfo> TryReadInfoFile(FileSystem &fs, const string &info_file_path,
-	                                                        const string &extension_name);
-
-	static unique_ptr<ExtensionInstallInfo> Deserialize(Deserializer &deserializer);
-};
-
-struct ExtensionRepository {
-	//! All currently available repositories
-	static constexpr const char *CORE_REPOSITORY_URL = "http://extensions.duckdb.org";
-	static constexpr const char *CORE_NIGHTLY_REPOSITORY_URL = "http://nightly-extensions.duckdb.org";
-	static constexpr const char *COMMUNITY_REPOSITORY_URL = "http://community-extensions.duckdb.org";
-
-	//! Debugging repositories (target local, relative paths that are produced by DuckDB's build system)
-	static constexpr const char *BUILD_DEBUG_REPOSITORY_PATH = "./build/debug/repository";
-	static constexpr const char *BUILD_RELEASE_REPOSITORY_PATH = "./build/release/repository";
-
-	//! The default is CORE
-	static constexpr const char *DEFAULT_REPOSITORY_URL = CORE_REPOSITORY_URL;
-
-	//! Returns the repository name is this is a known repository, or the full url if it is not
-	static string GetRepository(const string &repository_url);
-	//! Try to convert a repository to a url, will return empty string if the repository is unknown
-	static string TryGetRepositoryUrl(const string &repository);
-	//! Try to convert a url to a known repository name, will return empty string if the repository is unknown
-	static string TryConvertUrlToKnownRepository(const string &url);
-
-	//! Get the default repository, optionally passing a config to allow
-	static ExtensionRepository GetDefaultRepository(optional_ptr<DBConfig> config);
-	static ExtensionRepository GetDefaultRepository(ClientContext &context);
-
-	static ExtensionRepository GetCoreRepository();
-	static ExtensionRepository GetRepositoryByUrl(const string &url);
-
-	ExtensionRepository();
-	ExtensionRepository(const string &name, const string &url);
-
-	//! Print the name if it has one, or the full path if not
-	string ToReadableString();
-
-	//! Repository name
-	string name;
-	//! Repository path/url
-	string path;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/extension_util.hpp b/src/duckdb/src/include/duckdb/main/extension_util.hpp
deleted file mode 100644
index 598320b82..000000000
--- a/src/duckdb/src/include/duckdb/main/extension_util.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/secret/secret.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-
-namespace duckdb {
-struct CreateMacroInfo;
-struct CreateCollationInfo;
-struct CreateAggregateFunctionInfo;
-struct CreateScalarFunctionInfo;
-struct CreateTableFunctionInfo;
-class DatabaseInstance;
-
-//! The ExtensionUtil class contains methods that are useful for extensions
-class ExtensionUtil {
-public:
-	//! Register a new DuckDB extension
-	DUCKDB_API static void RegisterExtension(DatabaseInstance &db, const string &name, const ExtensionLoadedInfo &info);
-	//! Register a new scalar function - merge overloads if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateScalarFunctionInfo info);
-	//! Register a new aggregate function - merge overloads if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunction function);
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunctionSet function);
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateAggregateFunctionInfo info);
-	//! Register a new table function - merge overloads if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunctionSet function);
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateTableFunctionInfo info);
-	//! Register a new pragma function - throw an exception if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunction function);
-	//! Register a new pragma function set - throw an exception if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function);
-
-	//! Register a CreateSecretFunction
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateSecretFunction function);
-
-	//! Register a new copy function - throw an exception if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CopyFunction function);
-	//! Register a new macro function - throw an exception if the function already exists
-	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info);
-
-	//! Register a new collation
-	DUCKDB_API static void RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info);
-
-	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
-	DUCKDB_API static ScalarFunctionCatalogEntry &GetFunction(DatabaseInstance &db, const string &name);
-	DUCKDB_API static TableFunctionCatalogEntry &GetTableFunction(DatabaseInstance &db, const string &name);
-	DUCKDB_API static optional_ptr<CatalogEntry> TryGetFunction(DatabaseInstance &db, const string &name);
-	DUCKDB_API static optional_ptr<CatalogEntry> TryGetTableFunction(DatabaseInstance &db, const string &name);
-
-	//! Add a function overload
-	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
-	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet function);
-	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);
-
-	//! Registers a new type
-	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
-	                                    bind_logical_type_function_t bind_function = nullptr);
-
-	//! Registers a new secret type
-	DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type);
-
-	//! Registers a cast between two types
-	DUCKDB_API static void RegisterCastFunction(DatabaseInstance &db, const LogicalType &source,
-	                                            const LogicalType &target, BoundCastInfo function,
-	                                            int64_t implicit_cast_cost = -1);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/external_dependencies.hpp b/src/duckdb/src/include/duckdb/main/external_dependencies.hpp
deleted file mode 100644
index ed6afd4a9..000000000
--- a/src/duckdb/src/include/duckdb/main/external_dependencies.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/external_dependencies.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include <functional>
-
-#pragma once
-
-namespace duckdb {
-
-class DependencyItem {
-public:
-	virtual ~DependencyItem() {};
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-using dependency_scan_t = std::function<void(const string &name, shared_ptr<DependencyItem> item)>;
-
-class ExternalDependency {
-public:
-	explicit ExternalDependency() {
-	}
-	~ExternalDependency() {
-	}
-
-public:
-	void AddDependency(const string &name, shared_ptr<DependencyItem> item) {
-		objects[name] = std::move(item);
-	}
-	shared_ptr<DependencyItem> GetDependency(const string &name) const {
-		auto it = objects.find(name);
-		if (it == objects.end()) {
-			return nullptr;
-		}
-		return it->second;
-	}
-	void ScanDependencies(const dependency_scan_t &callback) {
-		for (auto &kv : objects) {
-			callback(kv.first, kv.second);
-		}
-	}
-
-private:
-	//! The objects encompassed by this dependency
-	case_insensitive_map_t<shared_ptr<DependencyItem>> objects;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/materialized_query_result.hpp b/src/duckdb/src/include/duckdb/main/materialized_query_result.hpp
deleted file mode 100644
index 25c50d980..000000000
--- a/src/duckdb/src/include/duckdb/main/materialized_query_result.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/materialized_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/query_result.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-
-class MaterializedQueryResult : public QueryResult {
-public:
-	static constexpr const QueryResultType TYPE = QueryResultType::MATERIALIZED_RESULT;
-
-public:
-	friend class ClientContext;
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
-	                                   vector<string> names, unique_ptr<ColumnDataCollection> collection,
-	                                   ClientProperties client_properties);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API explicit MaterializedQueryResult(ErrorData error);
-
-public:
-	//! Fetches a DataChunk from the query result.
-	//! This will consume the result (i.e. the result can only be scanned once with this function)
-	DUCKDB_API unique_ptr<DataChunk> Fetch() override;
-	DUCKDB_API unique_ptr<DataChunk> FetchRaw() override;
-	//! Converts the QueryResult to a string
-	DUCKDB_API string ToString() override;
-	DUCKDB_API string ToBox(ClientContext &context, const BoxRendererConfig &config) override;
-
-	//! Gets the (index) value of the (column index) column.
-	//! Note: this is very slow. Scanning over the underlying collection is much faster.
-	DUCKDB_API Value GetValue(idx_t column, idx_t index);
-
-	template <class T>
-	T GetValue(idx_t column, idx_t index) {
-		auto value = GetValue(column, index);
-		return (T)value.GetValue<int64_t>();
-	}
-
-	DUCKDB_API idx_t RowCount() const;
-
-	//! Returns a reference to the underlying column data collection
-	ColumnDataCollection &Collection();
-
-	//! Takes ownership of the collection, 'collection' is null after this operation
-	unique_ptr<ColumnDataCollection> TakeCollection();
-
-private:
-	unique_ptr<ColumnDataCollection> collection;
-	//! Row collection, only created if GetValue is called
-	unique_ptr<ColumnDataRowCollection> row_collection;
-	//! Scan state for Fetch calls
-	ColumnDataScanState scan_state;
-	bool scan_initialized;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/pending_query_result.hpp b/src/duckdb/src/include/duckdb/main/pending_query_result.hpp
deleted file mode 100644
index 72fe9405f..000000000
--- a/src/duckdb/src/include/duckdb/main/pending_query_result.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/pending_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/common/enums/pending_execution_result.hpp"
-#include "duckdb/execution/executor.hpp"
-
-namespace duckdb {
-class ClientContext;
-class ClientContextLock;
-class PreparedStatementData;
-
-class PendingQueryResult : public BaseQueryResult {
-	friend class ClientContext;
-
-public:
-	static constexpr const QueryResultType TYPE = QueryResultType::PENDING_RESULT;
-
-public:
-	DUCKDB_API PendingQueryResult(shared_ptr<ClientContext> context, PreparedStatementData &statement,
-	                              vector<LogicalType> types, bool allow_stream_result);
-	DUCKDB_API explicit PendingQueryResult(ErrorData error_message);
-	DUCKDB_API ~PendingQueryResult() override;
-	DUCKDB_API bool AllowStreamResult() const;
-
-public:
-	//! Executes a single task within the query, returning whether or not the query is ready.
-	//! If this returns RESULT_READY, the Execute function can be called to obtain a pointer to the result.
-	//! If this returns RESULT_NOT_READY, the ExecuteTask function should be called again.
-	//! If this returns EXECUTION_ERROR, an error occurred during execution.
-	//! If this returns NO_TASKS_AVAILABLE, this means currently no meaningful work can be done by the current executor,
-	//!	    but tasks may become available in the future.
-	//! The error message can be obtained by calling GetError() on the PendingQueryResult.
-	DUCKDB_API PendingExecutionResult ExecuteTask();
-	DUCKDB_API PendingExecutionResult CheckPulse();
-	//! Halt execution of the thread until a Task is ready to be executed (use with caution)
-	void WaitForTask();
-
-	//! Returns the result of the query as an actual query result.
-	//! This returns (mostly) instantly if ExecuteTask has been called until RESULT_READY was returned.
-	DUCKDB_API unique_ptr<QueryResult> Execute();
-
-	DUCKDB_API void Close();
-
-	//! Function to determine whether execution is considered finished
-	DUCKDB_API static bool IsResultReady(PendingExecutionResult result);
-	DUCKDB_API static bool IsExecutionFinished(PendingExecutionResult result);
-
-private:
-	shared_ptr<ClientContext> context;
-	bool allow_stream_result;
-
-private:
-	void CheckExecutableInternal(ClientContextLock &lock);
-
-	PendingExecutionResult ExecuteTaskInternal(ClientContextLock &lock);
-	unique_ptr<QueryResult> ExecuteInternal(ClientContextLock &lock);
-	unique_ptr<ClientContextLock> LockContext();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/prepared_statement.hpp b/src/duckdb/src/include/duckdb/main/prepared_statement.hpp
deleted file mode 100644
index a391f6ac4..000000000
--- a/src/duckdb/src/include/duckdb/main/prepared_statement.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/prepared_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/main/pending_query_result.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-
-namespace duckdb {
-class ClientContext;
-class PreparedStatementData;
-
-//! A prepared statement
-class PreparedStatement {
-public:
-	//! Create a successfully prepared prepared statement object with the given name
-	DUCKDB_API PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data,
-	                             string query, case_insensitive_map_t<idx_t> named_param_map);
-	//! Create a prepared statement that was not successfully prepared
-	DUCKDB_API explicit PreparedStatement(ErrorData error);
-
-	DUCKDB_API ~PreparedStatement();
-
-public:
-	//! The client context this prepared statement belongs to
-	shared_ptr<ClientContext> context;
-	//! The prepared statement data
-	shared_ptr<PreparedStatementData> data;
-	//! The query that is being prepared
-	string query;
-	//! Whether or not the statement was successfully prepared
-	bool success;
-	//! The error message (if success = false)
-	ErrorData error;
-	//! The parameter mapping
-	case_insensitive_map_t<idx_t> named_param_map;
-
-public:
-	//! Returns the stored error message
-	DUCKDB_API const string &GetError();
-	//! Returns the stored error object
-	DUCKDB_API ErrorData &GetErrorObject();
-	//! Returns whether or not an error occurred
-	DUCKDB_API bool HasError() const;
-	//! Returns the number of columns in the result
-	DUCKDB_API idx_t ColumnCount();
-	//! Returns the statement type of the underlying prepared statement object
-	DUCKDB_API StatementType GetStatementType();
-	//! Returns the underlying statement properties
-	DUCKDB_API StatementProperties GetStatementProperties();
-	//! Returns the result SQL types of the prepared statement
-	DUCKDB_API const vector<LogicalType> &GetTypes();
-	//! Returns the result names of the prepared statement
-	DUCKDB_API const vector<string> &GetNames();
-	//! Returns the map of parameter index to the expected type of parameter
-	DUCKDB_API case_insensitive_map_t<LogicalType> GetExpectedParameterTypes() const;
-
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	template <typename... ARGS>
-	unique_ptr<PendingQueryResult> PendingQuery(ARGS... args) {
-		vector<Value> values;
-		return PendingQueryRecursive(values, args...);
-	}
-
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
-
-	//! Create a pending query result of the prepared statement with the given set named arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(case_insensitive_map_t<BoundParameterData> &named_values,
-	                                                       bool allow_stream_result = true);
-
-	//! Execute the prepared statement with the given set of values
-	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
-
-	//! Execute the prepared statement with the given set of named+unnamed values
-	DUCKDB_API unique_ptr<QueryResult> Execute(case_insensitive_map_t<BoundParameterData> &named_values,
-	                                           bool allow_stream_result = true);
-
-	//! Execute the prepared statement with the given set of arguments
-	template <typename... ARGS>
-	unique_ptr<QueryResult> Execute(ARGS... args) {
-		vector<Value> values;
-		return ExecuteRecursive(values, args...);
-	}
-
-	template <class PAYLOAD>
-	static string ExcessValuesException(const case_insensitive_map_t<idx_t> &parameters,
-	                                    const case_insensitive_map_t<PAYLOAD> &values) {
-		// Too many values
-		set<string> excess_set;
-		for (auto &pair : values) {
-			auto &name = pair.first;
-			if (!parameters.count(name)) {
-				excess_set.insert(name);
-			}
-		}
-		vector<string> excess_values;
-		for (auto &val : excess_set) {
-			excess_values.push_back(val);
-		}
-		return StringUtil::Format("Parameter argument/count mismatch, identifiers of the excess parameters: %s",
-		                          StringUtil::Join(excess_values, ", "));
-	}
-
-	template <class PAYLOAD>
-	static string MissingValuesException(const case_insensitive_map_t<idx_t> &parameters,
-	                                     const case_insensitive_map_t<PAYLOAD> &values) {
-		// Missing values
-		set<string> missing_set;
-		for (auto &pair : parameters) {
-			auto &name = pair.first;
-			if (!values.count(name)) {
-				missing_set.insert(name);
-			}
-		}
-		vector<string> missing_values;
-		for (auto &val : missing_set) {
-			missing_values.push_back(val);
-		}
-		return StringUtil::Format("Values were not provided for the following prepared statement parameters: %s",
-		                          StringUtil::Join(missing_values, ", "));
-	}
-
-	template <class PAYLOAD>
-	static void VerifyParameters(const case_insensitive_map_t<PAYLOAD> &provided,
-	                             const case_insensitive_map_t<idx_t> &expected) {
-		if (expected.size() == provided.size()) {
-			// Same amount of identifiers, if
-			for (auto &pair : expected) {
-				auto &identifier = pair.first;
-				if (!provided.count(identifier)) {
-					throw InvalidInputException(MissingValuesException(expected, provided));
-				}
-			}
-			return;
-		}
-		// Mismatch in expected and provided parameters/values
-		if (expected.size() > provided.size()) {
-			throw InvalidInputException(MissingValuesException(expected, provided));
-		} else {
-			D_ASSERT(provided.size() > expected.size());
-			throw InvalidInputException(ExcessValuesException(expected, provided));
-		}
-	}
-
-private:
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {
-		return PendingQuery(values);
-	}
-
-	template <typename T, typename... ARGS>
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values, T value, ARGS... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return PendingQueryRecursive(values, args...);
-	}
-
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values) {
-		return Execute(values);
-	}
-
-	template <typename T, typename... ARGS>
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values, T value, ARGS... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return ExecuteRecursive(values, args...);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/prepared_statement_data.hpp b/src/duckdb/src/include/duckdb/main/prepared_statement_data.hpp
deleted file mode 100644
index 40d741545..000000000
--- a/src/duckdb/src/include/duckdb/main/prepared_statement_data.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/prepared_statement_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-class ClientContext;
-class PhysicalOperator;
-class SQLStatement;
-
-class PreparedStatementData {
-public:
-	DUCKDB_API explicit PreparedStatementData(StatementType type);
-	DUCKDB_API ~PreparedStatementData();
-
-	StatementType statement_type;
-	//! The unbound SQL statement that was prepared
-	unique_ptr<SQLStatement> unbound_statement;
-	//! The fully prepared physical plan of the prepared statement
-	unique_ptr<PhysicalOperator> plan;
-
-	//! The result names of the transaction
-	vector<string> names;
-	//! The result types of the transaction
-	vector<LogicalType> types;
-
-	//! The statement properties
-	StatementProperties properties;
-
-	//! The map of parameter index to the actual value entry
-	bound_parameter_map_t value_map;
-	//! Whether we are creating a streaming result or not
-	bool is_streaming = false;
-
-public:
-	void CheckParameterCount(idx_t parameter_count);
-	//! Whether or not the prepared statement data requires the query to rebound for the given parameters
-	bool RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
-	//! Bind a set of values to the prepared statement data
-	DUCKDB_API void Bind(case_insensitive_map_t<BoundParameterData> values);
-	//! Get the expected SQL Type of the bound parameter
-	DUCKDB_API LogicalType GetType(const string &identifier);
-	//! Try to get the expected SQL Type of the bound parameter
-	DUCKDB_API bool TryGetType(const string &identifier, LogicalType &result);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/profiling_info.hpp b/src/duckdb/src/include/duckdb/main/profiling_info.hpp
deleted file mode 100644
index a57166153..000000000
--- a/src/duckdb/src/include/duckdb/main/profiling_info.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/profiling_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/output_type.hpp"
-#include "duckdb/common/enums/profiler_format.hpp"
-#include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/enums/metric_type.hpp"
-
-namespace duckdb_yyjson {
-struct yyjson_mut_doc;
-struct yyjson_mut_val;
-} // namespace duckdb_yyjson
-
-namespace duckdb {
-
-class ProfilingInfo {
-public:
-	//! Enabling a metric adds it to this set.
-	profiler_settings_t settings;
-	//! This set contains the expanded to-be-collected metrics, which can differ from 'settings'.
-	profiler_settings_t expanded_settings;
-	//! Contains all enabled metrics.
-	profiler_metrics_t metrics;
-	//! Additional metrics.
-	// FIXME: move to metrics.
-	InsertionOrderPreservingMap<string> extra_info;
-
-public:
-	ProfilingInfo() = default;
-	explicit ProfilingInfo(const profiler_settings_t &n_settings, const idx_t depth = 0);
-	ProfilingInfo(ProfilingInfo &) = default;
-	ProfilingInfo &operator=(ProfilingInfo const &) = default;
-
-public:
-	static profiler_settings_t DefaultSettings();
-	static profiler_settings_t DefaultRootSettings();
-	static profiler_settings_t DefaultOperatorSettings();
-
-public:
-	void ResetMetrics();
-	//! Returns true, if the query profiler must collect this metric.
-	static bool Enabled(const profiler_settings_t &settings, const MetricsType metric);
-	//! Expand metrics depending on the collection of other metrics.
-	static void Expand(profiler_settings_t &settings, const MetricsType metric);
-
-public:
-	string GetMetricAsString(const MetricsType metric) const;
-	void WriteMetricsToJSON(duckdb_yyjson::yyjson_mut_doc *doc, duckdb_yyjson::yyjson_mut_val *destination);
-
-public:
-	template <class METRIC_TYPE>
-	METRIC_TYPE GetMetricValue(const MetricsType type) const {
-		auto val = metrics.at(type);
-		return val.GetValue<METRIC_TYPE>();
-	}
-
-	template <class METRIC_TYPE>
-	void AddToMetric(const MetricsType type, const Value &value) {
-		D_ASSERT(!metrics[type].IsNull());
-		if (metrics.find(type) == metrics.end()) {
-			metrics[type] = value;
-			return;
-		}
-		auto new_value = metrics[type].GetValue<METRIC_TYPE>() + value.GetValue<METRIC_TYPE>();
-		metrics[type] = Value::CreateValue(new_value);
-	}
-
-	template <class METRIC_TYPE>
-	void AddToMetric(const MetricsType type, const METRIC_TYPE &value) {
-		auto new_value = Value::CreateValue(value);
-		return AddToMetric<METRIC_TYPE>(type, new_value);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/profiling_node.hpp b/src/duckdb/src/include/duckdb/main/profiling_node.hpp
deleted file mode 100644
index 04d49d108..000000000
--- a/src/duckdb/src/include/duckdb/main/profiling_node.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/profiling_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/deque.hpp"
-#include "duckdb/common/enums/profiler_format.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/profiler.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/execution/expression_executor_state.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/main/profiling_info.hpp"
-
-namespace duckdb {
-
-//! Recursive tree mirroring the operator tree.
-class ProfilingNode {
-public:
-	explicit ProfilingNode() {
-	}
-	virtual ~ProfilingNode() {};
-
-private:
-	ProfilingInfo profiling_info;
-
-public:
-	idx_t depth = 0;
-	vector<unique_ptr<ProfilingNode>> children;
-
-public:
-	idx_t GetChildCount() {
-		return children.size();
-	}
-	ProfilingInfo &GetProfilingInfo() {
-		return profiling_info;
-	}
-	const ProfilingInfo &GetProfilingInfo() const {
-		return profiling_info;
-	}
-	optional_ptr<ProfilingNode> GetChild(idx_t idx) {
-		return children[idx].get();
-	}
-	optional_ptr<ProfilingNode> AddChild(unique_ptr<ProfilingNode> child) {
-		children.push_back(std::move(child));
-		return children.back().get();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/query_profiler.hpp b/src/duckdb/src/include/duckdb/main/query_profiler.hpp
deleted file mode 100644
index 1de54e9a1..000000000
--- a/src/duckdb/src/include/duckdb/main/query_profiler.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/query_profiler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/deque.hpp"
-#include "duckdb/common/enums/profiler_format.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/profiler.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/execution/expression_executor_state.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/main/profiling_info.hpp"
-#include "duckdb/main/profiling_node.hpp"
-
-#include <stack>
-
-namespace duckdb {
-class ClientContext;
-class ExpressionExecutor;
-class ProfilingNode;
-class PhysicalOperator;
-class SQLStatement;
-
-struct OperatorInformation {
-	explicit OperatorInformation(double time_p = 0, idx_t elements_returned_p = 0, idx_t elements_scanned_p = 0,
-	                             idx_t result_set_size_p = 0)
-	    : time(time_p), elements_returned(elements_returned_p), result_set_size(result_set_size_p) {
-	}
-
-	double time;
-	idx_t elements_returned;
-	idx_t result_set_size;
-	string name;
-	InsertionOrderPreservingMap<string> extra_info;
-
-	void AddTime(double n_time) {
-		time += n_time;
-	}
-
-	void AddReturnedElements(idx_t n_elements) {
-		elements_returned += n_elements;
-	}
-
-	void AddResultSetSize(idx_t n_result_set_size) {
-		result_set_size += n_result_set_size;
-	}
-};
-
-//! The OperatorProfiler measures timings of individual operators
-//! This class exists once for all operators and collects `OperatorInfo` for each operator
-class OperatorProfiler {
-	friend class QueryProfiler;
-
-public:
-	DUCKDB_API explicit OperatorProfiler(ClientContext &context);
-	~OperatorProfiler() {
-	}
-
-public:
-	DUCKDB_API void StartOperator(optional_ptr<const PhysicalOperator> phys_op);
-	DUCKDB_API void EndOperator(optional_ptr<DataChunk> chunk);
-
-	//! Adds the timings in the OperatorProfiler (tree) to the QueryProfiler (tree).
-	DUCKDB_API void Flush(const PhysicalOperator &phys_op);
-	DUCKDB_API OperatorInformation &GetOperatorInfo(const PhysicalOperator &phys_op);
-
-public:
-	ClientContext &context;
-
-private:
-	//! Whether or not the profiler is enabled
-	bool enabled;
-	//! Sub-settings for the operator profiler
-	profiler_settings_t settings;
-
-	//! The timer used to time the execution time of the individual Physical Operators
-	Profiler op;
-	//! The stack of Physical Operators that are currently active
-	optional_ptr<const PhysicalOperator> active_operator;
-	//! A mapping of physical operators to profiled operator information.
-	reference_map_t<const PhysicalOperator, OperatorInformation> operator_infos;
-};
-
-struct QueryInfo {
-	QueryInfo() : blocked_thread_time(0) {};
-	string query_name;
-	double blocked_thread_time;
-};
-
-//! The QueryProfiler can be used to measure timings of queries
-class QueryProfiler {
-public:
-	DUCKDB_API explicit QueryProfiler(ClientContext &context);
-
-public:
-	// Propagate save_location, enabled, detailed_enabled and automatic_print_format.
-	void Propagate(QueryProfiler &qp);
-
-	using TreeMap = reference_map_t<const PhysicalOperator, reference<ProfilingNode>>;
-
-private:
-	unique_ptr<ProfilingNode> CreateTree(const PhysicalOperator &root, const profiler_settings_t &settings,
-	                                     const idx_t depth = 0);
-	void Render(const ProfilingNode &node, std::ostream &str) const;
-	string RenderDisabledMessage(ProfilerPrintFormat format) const;
-
-public:
-	DUCKDB_API bool IsEnabled() const;
-	DUCKDB_API bool IsDetailedEnabled() const;
-	DUCKDB_API ProfilerPrintFormat GetPrintFormat(ExplainFormat format = ExplainFormat::DEFAULT) const;
-	DUCKDB_API bool PrintOptimizerOutput() const;
-	DUCKDB_API string GetSaveLocation() const;
-
-	DUCKDB_API static QueryProfiler &Get(ClientContext &context);
-
-	DUCKDB_API void StartQuery(string query, bool is_explain_analyze = false, bool start_at_optimizer = false);
-	DUCKDB_API void EndQuery();
-
-	DUCKDB_API void StartExplainAnalyze();
-
-	//! Adds the timings gathered by an OperatorProfiler to this query profiler
-	DUCKDB_API void Flush(OperatorProfiler &profiler);
-	//! Adds the top level query information to the global profiler.
-	DUCKDB_API void SetInfo(const double &blocked_thread_time);
-
-	DUCKDB_API void StartPhase(MetricsType phase_metric);
-	DUCKDB_API void EndPhase();
-
-	DUCKDB_API void Initialize(const PhysicalOperator &root);
-
-	DUCKDB_API string QueryTreeToString() const;
-	DUCKDB_API void QueryTreeToStream(std::ostream &str) const;
-	DUCKDB_API void Print();
-
-	//! return the printed as a string. Unlike ToString, which is always formatted as a string,
-	//! the return value is formatted based on the current print format (see GetPrintFormat()).
-	DUCKDB_API string ToString(ExplainFormat format = ExplainFormat::DEFAULT) const;
-	DUCKDB_API string ToString(ProfilerPrintFormat format) const;
-
-	static InsertionOrderPreservingMap<string> JSONSanitize(const InsertionOrderPreservingMap<string> &input);
-	static string JSONSanitize(const string &text);
-	static string DrawPadded(const string &str, idx_t width);
-	DUCKDB_API string ToJSON() const;
-	DUCKDB_API void WriteToFile(const char *path, string &info) const;
-
-	idx_t OperatorSize() {
-		return tree_map.size();
-	}
-
-	void Finalize(ProfilingNode &node);
-
-	//! Return the root of the query tree
-	optional_ptr<ProfilingNode> GetRoot() {
-		return root.get();
-	}
-
-private:
-	ClientContext &context;
-
-	//! Whether or not the query profiler is running
-	bool running;
-	//! The lock used for accessing the global query profiler or flushing information to it from a thread
-	mutable std::mutex lock;
-
-	//! Whether or not the query requires profiling
-	bool query_requires_profiling;
-
-	//! The root of the query tree
-	unique_ptr<ProfilingNode> root;
-
-	//! Top level query information.
-	QueryInfo query_info;
-	//! The timer used to time the execution time of the entire query
-	Profiler main_query;
-	//! A map of a Physical Operator pointer to a tree node
-	TreeMap tree_map;
-	//! Whether or not we are running as part of a explain_analyze query
-	bool is_explain_analyze;
-
-public:
-	const TreeMap &GetTreeMap() const {
-		return tree_map;
-	}
-
-private:
-	//! The timer used to time the individual phases of the planning process
-	Profiler phase_profiler;
-	//! A mapping of the phase names to the timings
-	using PhaseTimingStorage = unordered_map<MetricsType, double, MetricsTypeHashFunction>;
-	PhaseTimingStorage phase_timings;
-	using PhaseTimingItem = PhaseTimingStorage::value_type;
-	//! The stack of currently active phases
-	vector<MetricsType> phase_stack;
-
-private:
-	void MoveOptimizerPhasesToRoot();
-
-	//! Check whether or not an operator type requires query profiling. If none of the ops in a query require profiling
-	//! no profiling information is output.
-	bool OperatorRequiresProfiling(PhysicalOperatorType op_type);
-	ExplainFormat GetExplainFormat(ProfilerPrintFormat format) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/query_result.hpp b/src/duckdb/src/include/duckdb/main/query_result.hpp
deleted file mode 100644
index af9e3817c..000000000
--- a/src/duckdb/src/include/duckdb/main/query_result.hpp
+++ /dev/null
@@ -1,207 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/main/client_properties.hpp"
-
-namespace duckdb {
-struct BoxRendererConfig;
-
-enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT, ARROW_RESULT };
-
-class BaseQueryResult {
-public:
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-	                           vector<LogicalType> types, vector<string> names);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API BaseQueryResult(QueryResultType type, ErrorData error);
-	DUCKDB_API virtual ~BaseQueryResult();
-
-	//! The type of the result (MATERIALIZED or STREAMING)
-	QueryResultType type;
-	//! The type of the statement that created this result
-	StatementType statement_type;
-	//! Properties of the statement
-	StatementProperties properties;
-	//! The SQL types of the result
-	vector<LogicalType> types;
-	//! The names of the result
-	vector<string> names;
-
-public:
-	[[noreturn]] DUCKDB_API void ThrowError(const string &prepended_message = "") const;
-	DUCKDB_API void SetError(ErrorData error);
-	DUCKDB_API bool HasError() const;
-	DUCKDB_API const ExceptionType &GetErrorType() const;
-	DUCKDB_API const std::string &GetError();
-	DUCKDB_API ErrorData &GetErrorObject();
-	DUCKDB_API idx_t ColumnCount();
-
-protected:
-	//! Whether or not execution was successful
-	bool success;
-	//! The error (in case execution was not successful)
-	ErrorData error;
-};
-
-//! The QueryResult object holds the result of a query. It can either be a MaterializedQueryResult, in which case the
-//! result contains the entire result set, or a StreamQueryResult in which case the Fetch method can be called to
-//! incrementally fetch data from the database.
-class QueryResult : public BaseQueryResult {
-public:
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API QueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-	                       vector<LogicalType> types, vector<string> names, ClientProperties client_properties);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API QueryResult(QueryResultType type, ErrorData error);
-	DUCKDB_API ~QueryResult() override;
-
-	//! Properties from the client context
-	ClientProperties client_properties;
-	//! The next result (if any)
-	unique_ptr<QueryResult> next;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast query result to type - query result type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast query result to type - query result type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-public:
-	//! Deduplicate column names for interop with external libraries
-	static void DeduplicateColumns(vector<string> &names);
-
-public:
-	//! Returns the name of the column for the given index
-	DUCKDB_API const string &ColumnName(idx_t index) const;
-	//! Fetches a DataChunk of normalized (flat) vectors from the query result.
-	//! Returns nullptr if there are no more results to fetch.
-	DUCKDB_API virtual unique_ptr<DataChunk> Fetch();
-	//! Fetches a DataChunk from the query result. The vectors are not normalized and hence any vector types can be
-	//! returned.
-	DUCKDB_API virtual unique_ptr<DataChunk> FetchRaw() = 0;
-	//! Converts the QueryResult to a string
-	DUCKDB_API virtual string ToString() = 0;
-	//! Converts the QueryResult to a box-rendered string
-	DUCKDB_API virtual string ToBox(ClientContext &context, const BoxRendererConfig &config);
-	//! Prints the QueryResult to the console
-	DUCKDB_API void Print();
-	//! Returns true if the two results are identical; false otherwise. Note that this method is destructive; it calls
-	//! Fetch() until both results are exhausted. The data in the results will be lost.
-	DUCKDB_API bool Equals(QueryResult &other);
-
-	bool TryFetch(unique_ptr<DataChunk> &result, ErrorData &error) {
-		try {
-			result = Fetch();
-			return success;
-		} catch (std::exception &ex) {
-			error = ErrorData(ex);
-			return false;
-		} catch (...) {
-			error = ErrorData("Unknown error in Fetch");
-			return false;
-		}
-	}
-
-private:
-	class QueryResultIterator;
-	class QueryResultRow {
-	public:
-		explicit QueryResultRow(QueryResultIterator &iterator_p, idx_t row_idx) : iterator(iterator_p), row(0) {
-		}
-
-		QueryResultIterator &iterator;
-		idx_t row;
-
-		template <class T>
-		T GetValue(idx_t col_idx) const {
-			return iterator.chunk->GetValue(col_idx, row).GetValue<T>();
-		}
-	};
-	//! The row-based query result iterator. Invoking the
-	class QueryResultIterator {
-	public:
-		explicit QueryResultIterator(optional_ptr<QueryResult> result_p)
-		    : current_row(*this, 0), result(result_p), base_row(0) {
-			if (result) {
-				chunk = shared_ptr<DataChunk>(result->Fetch().release());
-				if (!chunk) {
-					result = nullptr;
-				}
-			}
-		}
-
-		QueryResultRow current_row;
-		shared_ptr<DataChunk> chunk;
-		optional_ptr<QueryResult> result;
-		idx_t base_row;
-
-	public:
-		void Next() {
-			if (!chunk) {
-				return;
-			}
-			current_row.row++;
-			if (current_row.row >= chunk->size()) {
-				base_row += chunk->size();
-				chunk = shared_ptr<DataChunk>(result->Fetch().release());
-				current_row.row = 0;
-				if (!chunk || chunk->size() == 0) {
-					// exhausted all rows
-					base_row = 0;
-					result = nullptr;
-					chunk.reset();
-				}
-			}
-		}
-
-		QueryResultIterator &operator++() {
-			Next();
-			return *this;
-		}
-		bool operator!=(const QueryResultIterator &other) const {
-			return result != other.result || base_row != other.base_row || current_row.row != other.current_row.row;
-		}
-		const QueryResultRow &operator*() const {
-			return current_row;
-		}
-	};
-
-public:
-	QueryResultIterator begin() { // NOLINT: match stl API
-		return QueryResultIterator(this);
-	}
-	QueryResultIterator end() { // NOLINT: match stl API
-		return QueryResultIterator(nullptr);
-	}
-
-protected:
-	DUCKDB_API string HeaderToString();
-
-private:
-	QueryResult(const QueryResult &) = delete;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation.hpp b/src/duckdb/src/include/duckdb/main/relation.hpp
deleted file mode 100644
index 37b137aae..000000000
--- a/src/duckdb/src/include/duckdb/main/relation.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enums/relation_type.hpp"
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/named_parameter_map.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_context_wrapper.hpp"
-#include "duckdb/main/external_dependencies.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-struct BoundStatement;
-
-class Binder;
-class LogicalOperator;
-class QueryNode;
-class TableRef;
-
-static string CreateRelationAlias(RelationType type, const string &alias) {
-	if (!alias.empty()) {
-		return alias;
-	}
-	return StringUtil::Format("%s_%s", EnumUtil::ToString(type), StringUtil::GenerateRandomName());
-}
-
-class RelationContextWrapper : public ClientContextWrapper {
-public:
-	~RelationContextWrapper() override = default;
-	explicit RelationContextWrapper(const shared_ptr<ClientContext> &context) : ClientContextWrapper(context) {};
-
-	explicit RelationContextWrapper(const ClientContextWrapper &context) : ClientContextWrapper(context) {};
-
-	void TryBindRelation(Relation &relation, vector<ColumnDefinition> &columns) override {
-		GetContext()->InternalTryBindRelation(relation, columns);
-	}
-
-private:
-	weak_ptr<ClientContext> client_context;
-};
-
-class Relation : public enable_shared_from_this<Relation> {
-public:
-	Relation(const shared_ptr<ClientContext> &context_p, const RelationType type) : type(type) {
-		context = make_shared_ptr<ClientContextWrapper>(context_p);
-	}
-	Relation(const shared_ptr<ClientContextWrapper> &context, RelationType type, const string &alias_p = "")
-	    : context(context), type(type), alias(CreateRelationAlias(type, alias_p)) {
-	}
-
-	Relation(const shared_ptr<RelationContextWrapper> &context, RelationType type, const string &alias_p = "")
-	    : context(context), type(type), alias(CreateRelationAlias(type, alias_p)) {
-	}
-
-	virtual ~Relation() = default;
-
-	shared_ptr<ClientContextWrapper> context;
-	RelationType type;
-	const string alias;
-	vector<shared_ptr<ExternalDependency>> external_dependencies;
-
-public:
-	DUCKDB_API virtual const vector<ColumnDefinition> &Columns() = 0;
-	DUCKDB_API virtual unique_ptr<QueryNode> GetQueryNode();
-	DUCKDB_API virtual BoundStatement Bind(Binder &binder);
-	DUCKDB_API virtual string GetAlias();
-
-	DUCKDB_API unique_ptr<QueryResult> ExecuteOrThrow();
-	DUCKDB_API unique_ptr<QueryResult> Execute();
-	DUCKDB_API string ToString();
-	DUCKDB_API virtual string ToString(idx_t depth) = 0;
-
-	DUCKDB_API void Print();
-	DUCKDB_API void Head(idx_t limit = 10);
-
-	DUCKDB_API shared_ptr<Relation> CreateView(const string &name, bool replace = true, bool temporary = false);
-	DUCKDB_API shared_ptr<Relation> CreateView(const string &schema_name, const string &name, bool replace = true,
-	                                           bool temporary = false);
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &sql) const;
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &name, const string &sql);
-
-	//! Explain the query plan of this relation
-	DUCKDB_API unique_ptr<QueryResult> Explain(ExplainType type = ExplainType::EXPLAIN_STANDARD,
-	                                           ExplainFormat explain_format = ExplainFormat::DEFAULT);
-
-	DUCKDB_API virtual unique_ptr<TableRef> GetTableRef();
-	virtual bool IsReadOnly() {
-		return true;
-	}
-	DUCKDB_API void TryBindRelation(vector<ColumnDefinition> &columns);
-
-public:
-	// PROJECT
-	DUCKDB_API shared_ptr<Relation> Project(const string &select_list);
-	DUCKDB_API shared_ptr<Relation> Project(const string &expression, const string &alias);
-	DUCKDB_API shared_ptr<Relation> Project(const string &select_list, const vector<string> &aliases);
-	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions);
-	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions, const vector<string> &aliases);
-	DUCKDB_API shared_ptr<Relation> Project(vector<unique_ptr<ParsedExpression>> expressions,
-	                                        const vector<string> &aliases);
-
-	// FILTER
-	DUCKDB_API shared_ptr<Relation> Filter(const string &expression);
-	DUCKDB_API shared_ptr<Relation> Filter(unique_ptr<ParsedExpression> expression);
-	DUCKDB_API shared_ptr<Relation> Filter(const vector<string> &expressions);
-
-	// LIMIT
-	DUCKDB_API shared_ptr<Relation> Limit(int64_t n, int64_t offset = 0);
-
-	// ORDER
-	DUCKDB_API shared_ptr<Relation> Order(const string &expression);
-	DUCKDB_API shared_ptr<Relation> Order(const vector<string> &expressions);
-	DUCKDB_API shared_ptr<Relation> Order(vector<OrderByNode> expressions);
-
-	// JOIN operation
-	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
-	                                     JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
-	shared_ptr<Relation> Join(const shared_ptr<Relation> &other, vector<unique_ptr<ParsedExpression>> condition,
-	                          JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
-
-	// CROSS PRODUCT operation
-	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other,
-	                                             JoinRefType join_ref_type = JoinRefType::CROSS);
-
-	// SET operations
-	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);
-	DUCKDB_API shared_ptr<Relation> Except(const shared_ptr<Relation> &other);
-	DUCKDB_API shared_ptr<Relation> Intersect(const shared_ptr<Relation> &other);
-
-	// DISTINCT operation
-	DUCKDB_API shared_ptr<Relation> Distinct();
-
-	// AGGREGATES
-	DUCKDB_API shared_ptr<Relation> Aggregate(const string &aggregate_list);
-	DUCKDB_API shared_ptr<Relation> Aggregate(const vector<string> &aggregates);
-	DUCKDB_API shared_ptr<Relation> Aggregate(vector<unique_ptr<ParsedExpression>> expressions);
-	DUCKDB_API shared_ptr<Relation> Aggregate(const string &aggregate_list, const string &group_list);
-	DUCKDB_API shared_ptr<Relation> Aggregate(const vector<string> &aggregates, const vector<string> &groups);
-	DUCKDB_API shared_ptr<Relation> Aggregate(vector<unique_ptr<ParsedExpression>> expressions,
-	                                          const string &group_list);
-
-	// ALIAS
-	DUCKDB_API shared_ptr<Relation> Alias(const string &alias);
-
-	//! Insert the data from this relation into a table
-	DUCKDB_API shared_ptr<Relation> InsertRel(const string &schema_name, const string &table_name);
-	DUCKDB_API void Insert(const string &table_name);
-	DUCKDB_API void Insert(const string &schema_name, const string &table_name);
-	//! Insert a row (i.e.,list of values) into a table
-	DUCKDB_API void Insert(const vector<vector<Value>> &values);
-	DUCKDB_API void Insert(vector<vector<unique_ptr<ParsedExpression>>> &&expressions);
-	//! Create a table and insert the data from this relation into that table
-	DUCKDB_API shared_ptr<Relation> CreateRel(const string &schema_name, const string &table_name,
-	                                          bool temporary = false,
-	                                          OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT);
-	DUCKDB_API void Create(const string &table_name, bool temporary = false,
-	                       OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT);
-	DUCKDB_API void Create(const string &schema_name, const string &table_name, bool temporary = false,
-	                       OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT);
-
-	//! Write a relation to a CSV file
-	DUCKDB_API shared_ptr<Relation>
-	WriteCSVRel(const string &csv_file,
-	            case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
-	DUCKDB_API void WriteCSV(const string &csv_file,
-	                         case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
-	//! Write a relation to a Parquet file
-	DUCKDB_API shared_ptr<Relation>
-	WriteParquetRel(const string &parquet_file,
-	                case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
-	DUCKDB_API void
-	WriteParquet(const string &parquet_file,
-	             case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
-
-	//! Update a table, can only be used on a TableRelation
-	DUCKDB_API virtual void Update(const string &update, const string &condition = string());
-	DUCKDB_API virtual void Update(vector<string> column_names, vector<unique_ptr<ParsedExpression>> &&update,
-	                               unique_ptr<ParsedExpression> condition = nullptr);
-	//! Delete from a table, can only be used on a TableRelation
-	DUCKDB_API virtual void Delete(const string &condition = string());
-	//! Create a relation from calling a table in/out function on the input relation
-	//! Create a relation from calling a table in/out function on the input relation
-	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values);
-	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values,
-	                                              const named_parameter_map_t &named_parameters);
-
-public:
-	//! Whether or not the relation inherits column bindings from its child or not, only relevant for binding
-	virtual bool InheritsColumnBindings() {
-		return false;
-	}
-	virtual Relation *ChildRelation() {
-		return nullptr;
-	}
-	void AddExternalDependency(shared_ptr<ExternalDependency> dependency);
-	DUCKDB_API vector<shared_ptr<ExternalDependency>> GetAllDependencies();
-
-protected:
-	DUCKDB_API static string RenderWhitespace(idx_t depth);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp
deleted file mode 100644
index 45daad4a0..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/aggregate_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-
-namespace duckdb {
-
-class AggregateRelation : public Relation {
-public:
-	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
-	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                             GroupByNode groups);
-	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                             vector<unique_ptr<ParsedExpression>> groups);
-
-	vector<unique_ptr<ParsedExpression>> expressions;
-	GroupByNode groups;
-	vector<ColumnDefinition> columns;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/create_table_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/create_table_relation.hpp
deleted file mode 100644
index 7d5462941..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/create_table_relation.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/create_table_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class CreateTableRelation : public Relation {
-public:
-	CreateTableRelation(shared_ptr<Relation> child, string schema_name, string table_name, bool temporary,
-	                    OnCreateConflict on_conflict);
-
-	shared_ptr<Relation> child;
-	string schema_name;
-	string table_name;
-	vector<ColumnDefinition> columns;
-	bool temporary;
-	OnCreateConflict on_conflict;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/create_view_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/create_view_relation.hpp
deleted file mode 100644
index cb826a86c..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/create_view_relation.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/create_view_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class CreateViewRelation : public Relation {
-public:
-	CreateViewRelation(shared_ptr<Relation> child, string view_name, bool replace, bool temporary);
-	CreateViewRelation(shared_ptr<Relation> child, string schema_name, string view_name, bool replace, bool temporary);
-
-	shared_ptr<Relation> child;
-	string schema_name;
-	string view_name;
-	bool replace;
-	bool temporary;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/cross_product_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/cross_product_relation.hpp
deleted file mode 100644
index 82fc828b6..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/cross_product_relation.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/cross_product_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-
-namespace duckdb {
-
-class CrossProductRelation : public Relation {
-public:
-	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                                JoinRefType join_ref_type = JoinRefType::CROSS);
-
-	shared_ptr<Relation> left;
-	shared_ptr<Relation> right;
-	JoinRefType ref_type;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/delete_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/delete_relation.hpp
deleted file mode 100644
index d72a48bd4..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/delete_relation.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/delete_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class DeleteRelation : public Relation {
-public:
-	DeleteRelation(shared_ptr<ClientContextWrapper> &context, unique_ptr<ParsedExpression> condition,
-	               string schema_name, string table_name);
-
-	vector<ColumnDefinition> columns;
-	unique_ptr<ParsedExpression> condition;
-	string schema_name;
-	string table_name;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/delim_get_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/delim_get_relation.hpp
deleted file mode 100644
index e78446527..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/delim_get_relation.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/delim_get_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class DelimGetRelation : public Relation {
-public:
-	DUCKDB_API DelimGetRelation(const shared_ptr<ClientContext> &context, vector<LogicalType> chunk_types);
-
-	vector<LogicalType> chunk_types;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/distinct_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/distinct_relation.hpp
deleted file mode 100644
index 18209e1a5..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/distinct_relation.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/distinct_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class DistinctRelation : public Relation {
-public:
-	explicit DistinctRelation(shared_ptr<Relation> child);
-
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/explain_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/explain_relation.hpp
deleted file mode 100644
index 888583b2b..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/explain_relation.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/explain_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class ExplainRelation : public Relation {
-public:
-	explicit ExplainRelation(shared_ptr<Relation> child, ExplainType type = ExplainType::EXPLAIN_STANDARD,
-	                         ExplainFormat format = ExplainFormat::DEFAULT);
-
-	shared_ptr<Relation> child;
-	vector<ColumnDefinition> columns;
-	ExplainType type;
-	ExplainFormat format;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/filter_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/filter_relation.hpp
deleted file mode 100644
index 2a87a02dc..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/filter_relation.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/filter_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class FilterRelation : public Relation {
-public:
-	DUCKDB_API FilterRelation(shared_ptr<Relation> child, unique_ptr<ParsedExpression> condition);
-
-	unique_ptr<ParsedExpression> condition;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/insert_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/insert_relation.hpp
deleted file mode 100644
index 3695cde7b..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/insert_relation.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/insert_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class InsertRelation : public Relation {
-public:
-	InsertRelation(shared_ptr<Relation> child, string schema_name, string table_name);
-
-	shared_ptr<Relation> child;
-	string schema_name;
-	string table_name;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/join_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/join_relation.hpp
deleted file mode 100644
index f7d4671ee..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/join_relation.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/join_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-
-namespace duckdb {
-
-class JoinRelation : public Relation {
-public:
-	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                        unique_ptr<ParsedExpression> condition, JoinType type,
-	                        JoinRefType join_ref_type = JoinRefType::REGULAR);
-	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
-	                        JoinType type, JoinRefType join_ref_type = JoinRefType::REGULAR);
-
-	shared_ptr<Relation> left;
-	shared_ptr<Relation> right;
-	unique_ptr<ParsedExpression> condition;
-	vector<string> using_columns;
-	JoinType join_type;
-	JoinRefType join_ref_type;
-	vector<ColumnDefinition> columns;
-
-	vector<unique_ptr<ParsedExpression>> duplicate_eliminated_columns;
-	bool delim_flipped = false;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/limit_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/limit_relation.hpp
deleted file mode 100644
index 4edc1ae4b..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/limit_relation.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/limit_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class LimitRelation : public Relation {
-public:
-	DUCKDB_API LimitRelation(shared_ptr<Relation> child, int64_t limit, int64_t offset);
-
-	int64_t limit;
-	int64_t offset;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/materialized_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/materialized_relation.hpp
deleted file mode 100644
index 2911fae4e..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/materialized_relation.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/materialized_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class MaterializedRelation : public Relation {
-public:
-	MaterializedRelation(const shared_ptr<ClientContext> &context, unique_ptr<ColumnDataCollection> &&collection,
-	                     vector<string> names, string alias = "materialized");
-	vector<ColumnDefinition> columns;
-	string alias;
-	shared_ptr<ColumnDataCollection> collection;
-
-public:
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-	unique_ptr<TableRef> GetTableRef() override;
-	unique_ptr<QueryNode> GetQueryNode() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/order_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/order_relation.hpp
deleted file mode 100644
index 604ea6895..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/order_relation.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/order_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-
-namespace duckdb {
-
-class OrderRelation : public Relation {
-public:
-	DUCKDB_API OrderRelation(shared_ptr<Relation> child, vector<OrderByNode> orders);
-
-	vector<OrderByNode> orders;
-	shared_ptr<Relation> child;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/projection_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/projection_relation.hpp
deleted file mode 100644
index 11110a7c4..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/projection_relation.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/projection_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class ProjectionRelation : public Relation {
-public:
-	DUCKDB_API ProjectionRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                              vector<string> aliases);
-
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<ColumnDefinition> columns;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/query_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/query_relation.hpp
deleted file mode 100644
index bdb035652..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/query_relation.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/query_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-class SelectStatement;
-
-class QueryRelation : public Relation {
-public:
-	QueryRelation(const shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias,
-	              const string &query = "");
-	~QueryRelation() override;
-
-	unique_ptr<SelectStatement> select_stmt;
-	string query;
-	string alias;
-	vector<ColumnDefinition> columns;
-
-public:
-	static unique_ptr<SelectStatement> ParseStatement(ClientContext &context, const string &query, const string &error);
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-	BoundStatement Bind(Binder &binder) override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-private:
-	unique_ptr<SelectStatement> GetSelectStatement();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/read_csv_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/read_csv_relation.hpp
deleted file mode 100644
index 0590cf6a9..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/read_csv_relation.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/read_csv_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/main/relation/table_function_relation.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-class ReadCSVRelation : public TableFunctionRelation {
-public:
-	ReadCSVRelation(const shared_ptr<ClientContext> &context, const vector<string> &csv_files,
-	                named_parameter_map_t &&options, string alias = string());
-
-	string alias;
-
-protected:
-	void InitializeAlias(const vector<string> &input);
-
-public:
-	string GetAlias() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/read_json_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/read_json_relation.hpp
deleted file mode 100644
index aee96ac19..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/read_json_relation.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "duckdb/main/relation/table_function_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/named_parameter_map.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class ReadJSONRelation : public TableFunctionRelation {
-public:
-	ReadJSONRelation(const shared_ptr<ClientContext> &context, string json_file, named_parameter_map_t options,
-	                 bool auto_detect, string alias = "");
-	ReadJSONRelation(const shared_ptr<ClientContext> &context, vector<string> &json_file, named_parameter_map_t options,
-	                 bool auto_detect, string alias = "");
-	~ReadJSONRelation() override;
-	string json_file;
-	string alias;
-
-public:
-	string GetAlias() override;
-
-private:
-	void InitializeAlias(const vector<string> &input);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/setop_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/setop_relation.hpp
deleted file mode 100644
index 77920bf9e..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/setop_relation.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/setop_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/common/enums/set_operation_type.hpp"
-
-namespace duckdb {
-
-class SetOpRelation : public Relation {
-public:
-	SetOpRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, SetOperationType setop_type,
-	              bool setop_all = false);
-
-	shared_ptr<Relation> left;
-	shared_ptr<Relation> right;
-	SetOperationType setop_type;
-	vector<ColumnDefinition> columns;
-	bool setop_all;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/subquery_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/subquery_relation.hpp
deleted file mode 100644
index 0c9c9e50d..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/subquery_relation.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/subquery_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class SubqueryRelation : public Relation {
-public:
-	SubqueryRelation(shared_ptr<Relation> child, const string &alias);
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return child->InheritsColumnBindings();
-	}
-	Relation *ChildRelation() override {
-		return child->ChildRelation();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/table_function_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/table_function_relation.hpp
deleted file mode 100644
index 8781d7125..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/table_function_relation.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/table_function_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class TableFunctionRelation : public Relation {
-public:
-	TableFunctionRelation(const shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
-	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr,
-	                      bool auto_init = true);
-	TableFunctionRelation(const shared_ptr<RelationContextWrapper> &context, string name, vector<Value> parameters,
-	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr,
-	                      bool auto_init = true);
-	TableFunctionRelation(const shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
-	                      shared_ptr<Relation> input_relation_p = nullptr, bool auto_init = true);
-	~TableFunctionRelation() override {
-	}
-
-	string name;
-	vector<Value> parameters;
-	named_parameter_map_t named_parameters;
-	vector<ColumnDefinition> columns;
-	shared_ptr<Relation> input_relation;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-	void AddNamedParameter(const string &name, Value argument);
-	void RemoveNamedParameterIfExists(const string &name);
-	void SetNamedParameters(named_parameter_map_t &&named_parameters);
-
-private:
-	void InitializeColumns();
-
-private:
-	//! Whether or not to auto initialize the columns on construction
-	bool auto_initialize;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/table_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/table_relation.hpp
deleted file mode 100644
index 9c2fddcec..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/table_relation.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/table_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/main/table_description.hpp"
-
-namespace duckdb {
-
-class TableRelation : public Relation {
-public:
-	TableRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
-	TableRelation(const shared_ptr<RelationContextWrapper> &context, unique_ptr<TableDescription> description);
-
-	unique_ptr<TableDescription> description;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-
-	void Update(const string &update, const string &condition = string()) override;
-	void Update(vector<string> column_names, vector<unique_ptr<ParsedExpression>> &&update,
-	            unique_ptr<ParsedExpression> condition = nullptr) override;
-	void Delete(const string &condition = string()) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/update_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/update_relation.hpp
deleted file mode 100644
index f46739dde..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/update_relation.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/update_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class UpdateRelation : public Relation {
-public:
-	UpdateRelation(shared_ptr<ClientContextWrapper> &context, unique_ptr<ParsedExpression> condition,
-	               string schema_name, string table_name, vector<string> update_columns,
-	               vector<unique_ptr<ParsedExpression>> expressions);
-
-	vector<ColumnDefinition> columns;
-	unique_ptr<ParsedExpression> condition;
-	string schema_name;
-	string table_name;
-	vector<string> update_columns;
-	vector<unique_ptr<ParsedExpression>> expressions;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/value_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/value_relation.hpp
deleted file mode 100644
index 9b5ae5257..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/value_relation.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/value_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class ValueRelation : public Relation {
-public:
-	ValueRelation(const shared_ptr<ClientContext> &context, const vector<vector<Value>> &values, vector<string> names,
-	              string alias = "values");
-	ValueRelation(const shared_ptr<ClientContext> &context, vector<vector<unique_ptr<ParsedExpression>>> &&expressions,
-	              vector<string> names, string alias = "values");
-	ValueRelation(const shared_ptr<RelationContextWrapper> &context, const vector<vector<Value>> &values,
-	              vector<string> names, string alias = "values");
-	ValueRelation(const shared_ptr<RelationContextWrapper> &context,
-	              vector<vector<unique_ptr<ParsedExpression>>> &&expressions, vector<string> names,
-	              string alias = "values");
-	ValueRelation(const shared_ptr<ClientContext> &context, const string &values, vector<string> names,
-	              string alias = "values");
-
-	vector<vector<unique_ptr<ParsedExpression>>> expressions;
-	vector<string> names;
-	vector<ColumnDefinition> columns;
-	string alias;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/view_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/view_relation.hpp
deleted file mode 100644
index 529817d60..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/view_relation.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/view_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class ViewRelation : public Relation {
-public:
-	ViewRelation(const shared_ptr<ClientContext> &context, string schema_name, string view_name);
-	ViewRelation(const shared_ptr<RelationContextWrapper> &context, string schema_name, string view_name);
-	ViewRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableRef> ref, const string &view_name);
-
-	string schema_name;
-	string view_name;
-	vector<ColumnDefinition> columns;
-	unique_ptr<TableRef> premade_tableref;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/write_csv_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/write_csv_relation.hpp
deleted file mode 100644
index 99d2ebe8e..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/write_csv_relation.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/write_csv_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class WriteCSVRelation : public Relation {
-public:
-	WriteCSVRelation(shared_ptr<Relation> child, string csv_file, case_insensitive_map_t<vector<Value>> options);
-
-	shared_ptr<Relation> child;
-	string csv_file;
-	vector<ColumnDefinition> columns;
-	case_insensitive_map_t<vector<Value>> options;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp
deleted file mode 100644
index d32089212..000000000
--- a/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/write_parquet_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class WriteParquetRelation : public Relation {
-public:
-	WriteParquetRelation(shared_ptr<Relation> child, string parquet_file,
-	                     case_insensitive_map_t<vector<Value>> options);
-
-	shared_ptr<Relation> child;
-	string parquet_file;
-	vector<ColumnDefinition> columns;
-	case_insensitive_map_t<vector<Value>> options;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/secret/default_secrets.hpp b/src/duckdb/src/include/duckdb/main/secret/default_secrets.hpp
deleted file mode 100644
index 99a81cbb6..000000000
--- a/src/duckdb/src/include/duckdb/main/secret/default_secrets.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/secret/default_secrets.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-class ClientContext;
-class BaseSecret;
-struct CreateSecretInput;
-class SecretManager;
-struct SecretType;
-class CreateSecretFunction;
-
-struct CreateHTTPSecretFunctions {
-public:
-	//! Get the default secret types
-	static vector<SecretType> GetDefaultSecretTypes();
-	//! Get the default secret functions
-	static vector<CreateSecretFunction> GetDefaultSecretFunctions();
-
-protected:
-	//! HTTP secret CONFIG provider
-	static unique_ptr<BaseSecret> CreateHTTPSecretFromConfig(ClientContext &context, CreateSecretInput &input);
-	//! HTTP secret ENV provider
-	static unique_ptr<BaseSecret> CreateHTTPSecretFromEnv(ClientContext &context, CreateSecretInput &input);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/secret/secret.hpp b/src/duckdb/src/include/duckdb/main/secret/secret.hpp
deleted file mode 100644
index ee721d7f8..000000000
--- a/src/duckdb/src/include/duckdb/main/secret/secret.hpp
+++ /dev/null
@@ -1,325 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/secret/secret.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/named_parameter_map.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-class BaseSecret;
-struct SecretEntry;
-struct FileOpenerInfo;
-
-//! Whether a secret is persistent or temporary
-enum class SecretPersistType : uint8_t { DEFAULT, TEMPORARY, PERSISTENT };
-
-//! Input passed to a CreateSecretFunction
-struct CreateSecretInput {
-	//! type
-	string type;
-	//! mode
-	string provider;
-	//! should the secret be persisted?
-	string storage_type;
-	//! (optional) alias provided by user
-	string name;
-	//! (optional) scope provided by user
-	vector<string> scope;
-	//! (optional) named parameter map, each create secret function has defined it's own set of these
-	case_insensitive_map_t<Value> options;
-};
-
-typedef unique_ptr<BaseSecret> (*secret_deserializer_t)(Deserializer &deserializer, BaseSecret base_secret);
-typedef unique_ptr<BaseSecret> (*create_secret_function_t)(ClientContext &context, CreateSecretInput &input);
-
-//! A CreateSecretFunction is a function adds a provider for a secret type.
-class CreateSecretFunction {
-public:
-	string secret_type;
-	string provider;
-	create_secret_function_t function;
-	named_parameter_type_map_t named_parameters;
-};
-
-//! CreateSecretFunctionsSet contains multiple functions of a single type, identified by the provider. The provider
-//! should be seen as the method of secret creation. (e.g. user-provided config, env variables, auto-detect)
-class CreateSecretFunctionSet {
-public:
-	explicit CreateSecretFunctionSet(string &name) : name(name) {};
-
-public:
-	bool ProviderExists(const string &provider_name);
-	void AddFunction(CreateSecretFunction &function, OnCreateConflict on_conflict);
-	CreateSecretFunction &GetFunction(const string &provider);
-
-protected:
-	//! Create Secret Function type name
-	string name;
-	//! Maps of provider -> function
-	case_insensitive_map_t<CreateSecretFunction> functions;
-};
-
-//! Determines whether the secrets are allowed to be shown
-enum class SecretDisplayType : uint8_t { REDACTED, UNREDACTED };
-
-//! Secret types contain the base settings of a secret
-struct SecretType {
-	//! Unique name identifying the secret type
-	string name;
-	//! The deserialization function for the type
-	secret_deserializer_t deserializer;
-	//! Provider to use when non is specified
-	string default_provider;
-};
-
-enum class SecretSerializationType : uint8_t {
-	//! The secret is serialized with a custom serialization function
-	CUSTOM = 0,
-	//! The secret has been serialized as a KeyValueSecret
-	KEY_VALUE_SECRET = 1
-};
-
-//! Base class from which BaseSecret classes can be made.
-class BaseSecret {
-	friend class SecretManager;
-
-public:
-	BaseSecret(vector<string> prefix_paths_p, string type_p, string provider_p, string name_p)
-	    : prefix_paths(std::move(prefix_paths_p)), type(std::move(type_p)), provider(std::move(provider_p)),
-	      name(std::move(name_p)), serializable(false) {
-		D_ASSERT(!type.empty());
-	}
-	BaseSecret(const BaseSecret &other)
-	    : prefix_paths(other.prefix_paths), type(other.type), provider(other.provider), name(other.name),
-	      serializable(other.serializable) {
-		D_ASSERT(!type.empty());
-	}
-	virtual ~BaseSecret() = default;
-
-	//! The score of how well this secret's scope matches the path (by default: the length of the longest matching
-	//! prefix)
-	virtual int64_t MatchScore(const string &path) const;
-	//! Prints the secret as a string
-	virtual string ToString(SecretDisplayType mode = SecretDisplayType::REDACTED) const;
-	//! Serialize this secret
-	virtual void Serialize(Serializer &serializer) const;
-
-	virtual unique_ptr<const BaseSecret> Clone() const {
-		D_ASSERT(typeid(BaseSecret) == typeid(*this));
-		return make_uniq<BaseSecret>(*this);
-	}
-
-	//! Getters
-	const vector<string> &GetScope() const {
-		return prefix_paths;
-	}
-	const string &GetType() const {
-		return type;
-	}
-	const string &GetProvider() const {
-		return provider;
-	}
-	const string &GetName() const {
-		return name;
-	}
-	bool IsSerializable() const {
-		return serializable;
-	}
-
-protected:
-	//! Helper function to serialize the base BaseSecret class variables
-	virtual void SerializeBaseSecret(Serializer &serializer) const final;
-
-	//! prefixes to which the secret applies
-	vector<string> prefix_paths;
-
-	//! Type of secret
-	string type;
-	//! Provider of the secret
-	string provider;
-	//! Name of the secret
-	string name;
-	//! Whether the secret can be serialized/deserialized
-	bool serializable;
-};
-
-//! The KeyValueSecret is a class that implements a Secret as a set of key -> values. This class can be used
-//! for most use-cases of secrets as secrets generally tend to fit in a key value map.
-class KeyValueSecret : public BaseSecret {
-public:
-	KeyValueSecret(const vector<string> &prefix_paths, const string &type, const string &provider, const string &name)
-	    : BaseSecret(prefix_paths, type, provider, name) {
-		D_ASSERT(!type.empty());
-		serializable = true;
-	}
-	explicit KeyValueSecret(const BaseSecret &secret)
-	    : BaseSecret(secret.GetScope(), secret.GetType(), secret.GetProvider(), secret.GetName()) {
-		serializable = true;
-	};
-	KeyValueSecret(const KeyValueSecret &secret)
-	    : BaseSecret(secret.GetScope(), secret.GetType(), secret.GetProvider(), secret.GetName()) {
-		secret_map = secret.secret_map;
-		redact_keys = secret.redact_keys;
-		serializable = true;
-	};
-	KeyValueSecret(KeyValueSecret &&secret) noexcept
-	    : BaseSecret(std::move(secret.prefix_paths), std::move(secret.type), std::move(secret.provider),
-	                 std::move(secret.name)) {
-		secret_map = std::move(secret.secret_map);
-		redact_keys = std::move(secret.redact_keys);
-		serializable = true;
-	};
-
-	//! Print the secret as a key value map in the format 'key1=value;key2=value2'
-	string ToString(SecretDisplayType mode = SecretDisplayType::REDACTED) const override;
-	void Serialize(Serializer &serializer) const override;
-
-	//! Tries to get the value at key <key>, depending on error_on_missing will throw or return Value()
-	Value TryGetValue(const string &key, bool error_on_missing = false) const;
-
-	// FIXME: use serialization scripts
-	template <class TYPE>
-	static unique_ptr<BaseSecret> Deserialize(Deserializer &deserializer, BaseSecret base_secret) {
-		auto result = make_uniq<TYPE>(base_secret);
-		Value secret_map_value;
-		deserializer.ReadProperty(201, "secret_map", secret_map_value);
-
-		for (const auto &entry : ListValue::GetChildren(secret_map_value)) {
-			auto kv_struct = StructValue::GetChildren(entry);
-			result->secret_map[kv_struct[0].ToString()] = kv_struct[1];
-		}
-
-		Value redact_set_value;
-		deserializer.ReadProperty(202, "redact_keys", redact_set_value);
-		for (const auto &entry : ListValue::GetChildren(redact_set_value)) {
-			result->redact_keys.insert(entry.ToString());
-		}
-
-		return duckdb::unique_ptr_cast<TYPE, BaseSecret>(std::move(result));
-	}
-
-	unique_ptr<const BaseSecret> Clone() const override {
-		return make_uniq<KeyValueSecret>(*this);
-	}
-
-	// Get a value from the secret
-	bool TryGetValue(const string &key, Value &result) const {
-		auto lookup = secret_map.find(key);
-		if (lookup == secret_map.end()) {
-			return false;
-		}
-		result = lookup->second;
-		return true;
-	}
-
-	bool TrySetValue(const string &key, const CreateSecretInput &input) {
-		auto lookup = input.options.find(key);
-		if (lookup != input.options.end()) {
-			secret_map[key] = lookup->second;
-			return true;
-		}
-		return false;
-	}
-
-	//! the map of key -> values that make up the secret
-	case_insensitive_tree_t<Value> secret_map;
-	//! keys that are sensitive and should be redacted
-	case_insensitive_set_t redact_keys;
-};
-
-// Helper class to fetch secret parameters in a cascading way. The idea being that in many cases there is a direct
-// connection between a KeyValueSecret key and a setting and we want to:
-// - check if the secret has a specific key, if so return the corresponding value
-// - check if a setting exists, if so return its value
-// - return a default value
-
-class KeyValueSecretReader {
-public:
-	//! Manually pass in a secret reference
-	KeyValueSecretReader(const KeyValueSecret &secret_p, FileOpener &opener_p) : secret(secret_p) {};
-
-	//! Initializes the KeyValueSecretReader by fetching the secret automatically
-	KeyValueSecretReader(FileOpener &opener_p, optional_ptr<FileOpenerInfo> info, const char **secret_types,
-	                     idx_t secret_types_len);
-	KeyValueSecretReader(FileOpener &opener_p, optional_ptr<FileOpenerInfo> info, const char *secret_type);
-
-	//! Initialize KeyValueSecretReader from a db instance
-	KeyValueSecretReader(DatabaseInstance &db, const char **secret_types, idx_t secret_types_len, string path);
-	KeyValueSecretReader(DatabaseInstance &db, const char *secret_type, string path);
-
-	// Initialize KeyValueSecretReader from a client context
-	KeyValueSecretReader(ClientContext &context, const char **secret_types, idx_t secret_types_len, string path);
-	KeyValueSecretReader(ClientContext &context, const char *secret_type, string path);
-
-	~KeyValueSecretReader();
-
-	//! Lookup a KeyValueSecret value
-	SettingLookupResult TryGetSecretKey(const string &secret_key, Value &result);
-	//! Lookup a KeyValueSecret value or a setting
-	SettingLookupResult TryGetSecretKeyOrSetting(const string &secret_key, const string &setting_name, Value &result);
-	//! Lookup a KeyValueSecret value or a setting, throws InvalidInputException on not found
-	Value GetSecretKey(const string &secret_key);
-	//! Lookup a KeyValueSecret value or a setting, throws InvalidInputException on not found
-	Value GetSecretKeyOrSetting(const string &secret_key, const string &setting_name);
-
-	//! Templating around TryGetSecretKey
-	template <class TYPE>
-	SettingLookupResult TryGetSecretKey(const string &secret_key, TYPE &value_out) {
-		Value result;
-		auto lookup_result = TryGetSecretKey(secret_key, result);
-		if (lookup_result) {
-			value_out = result.GetValue<TYPE>();
-		}
-		return lookup_result;
-	}
-
-	//! Templating around TryGetSecretOrSetting
-	template <class TYPE>
-	SettingLookupResult TryGetSecretKeyOrSetting(const string &secret_key, const string &setting_name,
-	                                             TYPE &value_out) {
-		Value result;
-		auto lookup_result = TryGetSecretKeyOrSetting(secret_key, setting_name, result);
-		if (lookup_result) {
-			value_out = result.GetValue<TYPE>();
-		}
-		return lookup_result;
-	}
-
-	// Like a templated GetSecretOrSetting but instead of throwing on not found, return the default value
-	template <class TYPE>
-	TYPE GetSecretKeyOrSettingOrDefault(const string &secret_key, const string &setting_name, TYPE default_value) {
-		TYPE result;
-		if (TryGetSecretKeyOrSetting(secret_key, setting_name, result)) {
-			return result;
-		}
-		return default_value;
-	}
-
-protected:
-	void Initialize(const char **secret_types, idx_t secret_types_len);
-
-	[[noreturn]] void ThrowNotFoundError(const string &secret_key);
-	[[noreturn]] void ThrowNotFoundError(const string &secret_key, const string &setting_name);
-
-	//! Fetching the secret
-	optional_ptr<const KeyValueSecret> secret;
-	//! Optionally an owning pointer to the secret entry
-	shared_ptr<SecretEntry> secret_entry;
-
-	//! Secrets/settings will be fetched either through a context (local + global settings) or a databaseinstance
-	//! (global only)
-	optional_ptr<DatabaseInstance> db;
-	optional_ptr<ClientContext> context;
-
-	string path;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp b/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp
deleted file mode 100644
index 7b1549ec2..000000000
--- a/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp
+++ /dev/null
@@ -1,225 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/secret/duck_secret_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/default/default_generator.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/main/secret/secret.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/main/secret/secret_storage.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-
-namespace duckdb {
-class SecretManager;
-struct DBConfig;
-class SchemaCatalogEntry;
-
-//! Return value of a Secret Lookup
-struct SecretMatch {
-public:
-	SecretMatch() : secret_entry(nullptr), score(NumericLimits<int64_t>::Minimum()) {
-	}
-
-	SecretMatch(const SecretMatch &other)
-	    : secret_entry((other.secret_entry != nullptr) ? make_uniq<SecretEntry>(*other.secret_entry) : nullptr),
-	      score(other.score) {
-	}
-
-	SecretMatch(SecretEntry &secret_entry, int64_t score)
-	    : secret_entry(make_uniq<SecretEntry>(secret_entry)), score(score) {
-	}
-
-	SecretMatch &operator=(const SecretMatch &other) {
-		this->secret_entry = (other.secret_entry != nullptr) ? make_uniq<SecretEntry>(*other.secret_entry) : nullptr;
-		this->score = other.score;
-		return *this;
-	};
-
-	//! Get the secret
-	const BaseSecret &GetSecret() const;
-
-	bool HasMatch() {
-		return secret_entry != nullptr;
-	}
-
-	unique_ptr<SecretEntry> secret_entry;
-	int64_t score;
-};
-
-//! A Secret Entry in the secret manager
-struct SecretEntry {
-public:
-	explicit SecretEntry(unique_ptr<const BaseSecret> secret) : secret(secret != nullptr ? secret->Clone() : nullptr) {
-	}
-	SecretEntry(const SecretEntry &other)
-	    : persist_type(other.persist_type), storage_mode(other.storage_mode),
-	      secret((other.secret != nullptr) ? other.secret->Clone() : nullptr) {
-	}
-
-	//! Whether the secret is persistent
-	SecretPersistType persist_type;
-	//! The storage backend of the secret
-	string storage_mode;
-	//! The secret pointer
-	unique_ptr<const BaseSecret> secret;
-};
-
-struct SecretManagerConfig {
-	static constexpr const bool DEFAULT_ALLOW_PERSISTENT_SECRETS = true;
-	//! The default persistence type for secrets
-	SecretPersistType default_persist_type = SecretPersistType::TEMPORARY;
-	//! Secret Path can be changed by until the secret manager is initialized, after that it will be set automatically
-	string secret_path = "";
-	//! The default secret path is determined on startup and can be used to reset the secret path
-	string default_secret_path = "";
-	//! The storage type for persistent secrets when none is specified;
-	string default_persistent_storage = "";
-	//! Persistent secrets are enabled by default
-	bool allow_persistent_secrets = DEFAULT_ALLOW_PERSISTENT_SECRETS;
-};
-
-//! The Secret Manager for DuckDB. Can handle both temporary and persistent secrets
-class SecretManager {
-	friend struct SecretEntry;
-
-public:
-	explicit SecretManager() = default;
-	virtual ~SecretManager() = default;
-
-	//! The default storage backends
-	static constexpr const char *TEMPORARY_STORAGE_NAME = "memory";
-	static constexpr const char *LOCAL_FILE_STORAGE_NAME = "local_file";
-
-	//! Static Helper Functions
-	DUCKDB_API static SecretManager &Get(ClientContext &context);
-	DUCKDB_API static SecretManager &Get(DatabaseInstance &db);
-
-	// Initialize the secret manager with the DB instance
-	DUCKDB_API void Initialize(DatabaseInstance &db);
-	//! Load a secret storage
-	DUCKDB_API void LoadSecretStorage(unique_ptr<SecretStorage> storage);
-
-	//! Deserialize a secret by automatically selecting the correct deserializer, secret_path can be set to improve
-	//! error hints
-	DUCKDB_API unique_ptr<BaseSecret> DeserializeSecret(Deserializer &deserializer, const string &secret_path = "");
-	//! Register a new SecretType
-	DUCKDB_API void RegisterSecretType(SecretType &type);
-	//! Lookup a SecretType
-	DUCKDB_API SecretType LookupType(const string &type);
-	//! Register a Secret Function i.e. a secret provider for a secret type
-	DUCKDB_API void RegisterSecretFunction(CreateSecretFunction function, OnCreateConflict on_conflict);
-	//! Register a secret by providing a secret manually
-	DUCKDB_API unique_ptr<SecretEntry> RegisterSecret(CatalogTransaction transaction,
-	                                                  unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
-	                                                  SecretPersistType persist_type, const string &storage = "");
-	//! Create a secret from a CreateSecretInfo
-	DUCKDB_API unique_ptr<SecretEntry> CreateSecret(ClientContext &context, const CreateSecretInfo &info);
-	//! The Bind for create secret is done by the secret manager
-	DUCKDB_API BoundStatement BindCreateSecret(CatalogTransaction transaction, CreateSecretInfo &info);
-	//! Lookup the best matching secret by matching the secret scopes to the path
-	DUCKDB_API SecretMatch LookupSecret(CatalogTransaction transaction, const string &path, const string &type);
-	//! Get a secret by name, optionally from a specific storage
-	DUCKDB_API unique_ptr<SecretEntry> GetSecretByName(CatalogTransaction transaction, const string &name,
-	                                                   const string &storage = "");
-	//! Delete a secret by name, optionally by providing the storage to drop from
-	DUCKDB_API void DropSecretByName(CatalogTransaction transaction, const string &name,
-	                                 OnEntryNotFound on_entry_not_found,
-	                                 SecretPersistType persist_type = SecretPersistType::DEFAULT,
-	                                 const string &storage = "");
-	//! List all secrets from all secret storages
-	DUCKDB_API vector<SecretEntry> AllSecrets(CatalogTransaction transaction);
-
-	//! Secret Manager settings
-	DUCKDB_API virtual void SetEnablePersistentSecrets(bool enabled);
-	DUCKDB_API virtual void ResetEnablePersistentSecrets();
-	DUCKDB_API virtual bool PersistentSecretsEnabled();
-
-	DUCKDB_API virtual void SetDefaultStorage(const string &storage);
-	DUCKDB_API virtual void ResetDefaultStorage();
-	DUCKDB_API virtual string DefaultStorage();
-
-	DUCKDB_API virtual void SetPersistentSecretPath(const string &path);
-	DUCKDB_API virtual void ResetPersistentSecretPath();
-	DUCKDB_API virtual string PersistentSecretPath();
-
-	//! Utility functions
-	DUCKDB_API void DropSecretByName(ClientContext &context, const string &name, OnEntryNotFound on_entry_not_found,
-	                                 SecretPersistType persist_type = SecretPersistType::DEFAULT,
-	                                 const string &storage = "");
-
-private:
-	//! Register a secret type
-	void RegisterSecretTypeInternal(SecretType &type);
-	//! Lookup a SecretType, throws if not found
-	SecretType LookupTypeInternal(const string &type);
-	//! Try to lookup a SecretType
-	bool TryLookupTypeInternal(const string &type, SecretType &type_out);
-	//! Register a secret provider
-	void RegisterSecretFunctionInternal(CreateSecretFunction function, OnCreateConflict on_conflict);
-	//! Lookup a CreateSecretFunction
-	optional_ptr<CreateSecretFunction> LookupFunctionInternal(const string &type, const string &provider);
-	//! Register a new Secret
-	unique_ptr<SecretEntry> RegisterSecretInternal(CatalogTransaction transaction, unique_ptr<const BaseSecret> secret,
-	                                               OnCreateConflict on_conflict, SecretPersistType persist_type,
-	                                               const string &storage = "");
-	//! Initialize the secret catalog_set and persistent secrets (lazily)
-	void InitializeSecrets(CatalogTransaction transaction);
-	//! Load a secret storage
-	void LoadSecretStorageInternal(unique_ptr<SecretStorage> storage);
-
-	//! Autoload extension for specific secret type
-	void AutoloadExtensionForType(const string &type);
-	//! Autoload extension for specific secret function
-	void AutoloadExtensionForFunction(const string &type, const string &provider);
-
-	//! Will throw appropriate error message when type not found
-	[[noreturn]] void ThrowTypeNotFoundError(const string &type, const string &secret_path = "");
-	[[noreturn]] void ThrowProviderNotFoundError(const string &type, const string &provider, bool was_default = false);
-
-	//! Thread-safe accessors for secret_storages
-	vector<reference<SecretStorage>> GetSecretStorages();
-	optional_ptr<SecretStorage> GetSecretStorage(const string &name);
-
-	//! Throw an exception if the secret manager is initialized
-	void ThrowOnSettingChangeIfInitialized();
-
-	//! Lock for types, functions, settings and storages
-	mutex manager_lock;
-	//! Secret functions;
-	case_insensitive_map_t<CreateSecretFunctionSet> secret_functions;
-	//! Secret types;
-	case_insensitive_map_t<SecretType> secret_types;
-	//! Map of all registered SecretStorages
-	case_insensitive_map_t<unique_ptr<SecretStorage>> secret_storages;
-	//! While false, secret manager settings can still be changed
-	atomic<bool> initialized {false};
-	//! Configuration for secret manager
-	SecretManagerConfig config;
-	//! Pointer to current db instance
-	optional_ptr<DatabaseInstance> db;
-};
-
-//! The DefaultGenerator for persistent secrets. This is used to store lazy loaded secrets in the catalog
-class DefaultSecretGenerator : public DefaultGenerator {
-public:
-	DefaultSecretGenerator(Catalog &catalog, SecretManager &secret_manager, case_insensitive_set_t &persistent_secrets);
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(CatalogTransaction transaction, const string &entry_name) override;
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-
-protected:
-	unique_ptr<CatalogEntry> CreateDefaultEntryInternal(const string &entry_name);
-
-	SecretManager &secret_manager;
-	case_insensitive_set_t persistent_secrets;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/secret/secret_storage.hpp b/src/duckdb/src/include/duckdb/main/secret/secret_storage.hpp
deleted file mode 100644
index 5649411d8..000000000
--- a/src/duckdb/src/include/duckdb/main/secret/secret_storage.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/secret/secret_storage.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/on_create_conflict.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-class BaseSecret;
-class Catalog;
-class CatalogSet;
-struct CatalogTransaction;
-class DatabaseInstance;
-struct SecretMatch;
-struct SecretEntry;
-class SecretManager;
-
-//! Base class for SecretStorage API
-class SecretStorage {
-	friend class SecretManager;
-
-public:
-	explicit SecretStorage(const string &name, const int64_t tie_break_offset)
-	    : storage_name(name), tie_break_offset(tie_break_offset), persistent(false) {};
-	virtual ~SecretStorage() = default;
-
-	//! Default storage backend offsets
-	static const int64_t TEMPORARY_STORAGE_OFFSET = 10;
-	static const int64_t LOCAL_FILE_STORAGE_OFFSET = 20;
-
-public:
-	//! SecretStorage API
-
-	//! Get the storage name (e.g. local_file, :memory:)
-	virtual string &GetName() {
-		return storage_name;
-	};
-
-	//! Store a secret
-	virtual unique_ptr<SecretEntry> StoreSecret(unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
-	                                            optional_ptr<CatalogTransaction> transaction = nullptr) = 0;
-	//! Get all secrets
-	virtual vector<SecretEntry> AllSecrets(optional_ptr<CatalogTransaction> transaction = nullptr) = 0;
-	//! Drop secret by name
-	virtual void DropSecretByName(const string &name, OnEntryNotFound on_entry_not_found,
-	                              optional_ptr<CatalogTransaction> transaction = nullptr) = 0;
-	//! Get best match
-	virtual SecretMatch LookupSecret(const string &path, const string &type,
-	                                 optional_ptr<CatalogTransaction> transaction = nullptr) = 0;
-	//! Get a secret by name
-	virtual unique_ptr<SecretEntry> GetSecretByName(const string &name,
-	                                                optional_ptr<CatalogTransaction> transaction = nullptr) = 0;
-
-	//! Returns include_in_lookups, used to create secret storage
-	virtual bool IncludeInLookups() {
-		return true;
-	}
-
-	virtual bool Persistent() const {
-		return persistent;
-	}
-
-protected:
-	//! Helper function to select the best matching secret within a storage. Tie-breaks within a storage are broken
-	//! by secret name by default.
-	static SecretMatch SelectBestMatch(SecretEntry &secret_entry, const string &path, int64_t offset,
-	                                   SecretMatch &current_best);
-
-	//! Name of the storage backend (e.g. temporary, file, etc)
-	string storage_name;
-	//! Offset associated to this storage for tie-breaking secrets between storages
-	const int64_t tie_break_offset;
-	//! Whether entries in this storage will survive duckdb reboots
-	bool persistent;
-};
-
-//! Wrapper struct around a SecretEntry to allow storing it
-struct SecretCatalogEntry : public InCatalogEntry {
-public:
-	SecretCatalogEntry(unique_ptr<SecretEntry> secret_p, Catalog &catalog);
-	SecretCatalogEntry(unique_ptr<const BaseSecret> secret_p, Catalog &catalog);
-
-	//! The secret to store in a catalog
-	unique_ptr<SecretEntry> secret;
-};
-
-//! Base Implementation for catalog set based secret storage
-class CatalogSetSecretStorage : public SecretStorage {
-public:
-	CatalogSetSecretStorage(DatabaseInstance &db_instance, const string &name_p, const int64_t offset)
-	    : SecretStorage(name_p, offset), db(db_instance) {};
-
-public:
-	//! SecretStorage API
-	string &GetName() override {
-		return storage_name;
-	};
-
-	unique_ptr<SecretEntry> StoreSecret(unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
-	                                    optional_ptr<CatalogTransaction> transaction = nullptr) override;
-	vector<SecretEntry> AllSecrets(optional_ptr<CatalogTransaction> transaction = nullptr) override;
-	void DropSecretByName(const string &name, OnEntryNotFound on_entry_not_found,
-	                      optional_ptr<CatalogTransaction> transaction = nullptr) override;
-	SecretMatch LookupSecret(const string &path, const string &type,
-	                         optional_ptr<CatalogTransaction> transaction = nullptr) override;
-	unique_ptr<SecretEntry> GetSecretByName(const string &name,
-	                                        optional_ptr<CatalogTransaction> transaction = nullptr) override;
-
-protected:
-	//! Callback called on Store to allow child classes to implement persistence.
-	virtual void WriteSecret(const BaseSecret &secret, OnCreateConflict on_conflict);
-	virtual void RemoveSecret(const string &name, OnEntryNotFound on_entry_not_found);
-	//! Returns the CatalogTransaction in `transaction` if not set, return the System transaction
-	CatalogTransaction GetTransactionOrDefault(optional_ptr<CatalogTransaction> transaction);
-
-	//! CatalogSet containing the secrets
-	unique_ptr<CatalogSet> secrets;
-	//! DB instance for accessing the system catalog transaction
-	DatabaseInstance &db;
-};
-
-class TemporarySecretStorage : public CatalogSetSecretStorage {
-public:
-	TemporarySecretStorage(const string &name_p, DatabaseInstance &db_p)
-	    : CatalogSetSecretStorage(db_p, name_p, TEMPORARY_STORAGE_OFFSET) {
-		secrets = make_uniq<CatalogSet>(Catalog::GetSystemCatalog(db));
-		persistent = false;
-	}
-
-protected:
-};
-
-class LocalFileSecretStorage : public CatalogSetSecretStorage {
-public:
-	LocalFileSecretStorage(SecretManager &manager, DatabaseInstance &db, const string &name_p,
-	                       const string &secret_path);
-
-protected:
-	//! Implements the writes to disk
-	void WriteSecret(const BaseSecret &secret, OnCreateConflict on_conflict) override;
-	//! Implements the deletes from disk
-	void RemoveSecret(const string &secret, OnEntryNotFound on_entry_not_found) override;
-
-	//! Set of persistent secrets that are lazily loaded
-	case_insensitive_set_t persistent_secrets;
-	//! Path that is searched for secrets;
-	string secret_path;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/settings.hpp b/src/duckdb/src/include/duckdb/main/settings.hpp
deleted file mode 100644
index 4e89c3416..000000000
--- a/src/duckdb/src/include/duckdb/main/settings.hpp
+++ /dev/null
@@ -1,1121 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/settings.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-struct DBConfig;
-
-const string GetDefaultUserAgent();
-
-enum class SettingScope : uint8_t {
-	//! Setting is from the global Setting scope
-	GLOBAL,
-	//! Setting is from the local Setting scope
-	LOCAL,
-	//! Setting was not feteched from settings, but it was fetched from a secret instead
-	SECRET,
-	//! The setting was not found or invalid in some other way
-	INVALID
-};
-
-struct SettingLookupResult {
-public:
-	SettingLookupResult() : scope(SettingScope::INVALID) {
-	}
-	explicit SettingLookupResult(SettingScope scope) : scope(scope) {
-		D_ASSERT(scope != SettingScope::INVALID);
-	}
-
-public:
-	operator bool() { // NOLINT: allow implicit conversion to bool
-		return scope != SettingScope::INVALID;
-	}
-
-public:
-	SettingScope GetScope() {
-		D_ASSERT(scope != SettingScope::INVALID);
-		return scope;
-	}
-
-private:
-	SettingScope scope = SettingScope::INVALID;
-};
-
-//===----------------------------------------------------------------------===//
-// This code is autogenerated from 'update_settings_header_file.py'.
-// Please do not make any changes directly here, as they will be overwritten.
-//
-// Start of the auto-generated list of settings structures
-//===----------------------------------------------------------------------===//
-
-struct AccessModeSetting {
-	using RETURN_TYPE = AccessMode;
-	static constexpr const char *Name = "access_mode";
-	static constexpr const char *Description = "Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllocatorBackgroundThreadsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "allocator_background_threads";
-	static constexpr const char *Description = "Whether to enable the allocator background thread.";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllocatorBulkDeallocationFlushThresholdSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "allocator_bulk_deallocation_flush_threshold";
-	static constexpr const char *Description =
-	    "If a bulk deallocation larger than this occurs, flush outstanding allocations.";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllocatorFlushThresholdSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "allocator_flush_threshold";
-	static constexpr const char *Description =
-	    "Peak allocation threshold at which to flush the allocator after completing a task.";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowCommunityExtensionsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "allow_community_extensions";
-	static constexpr const char *Description = "Allow to load community built extensions";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowExtensionsMetadataMismatchSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "allow_extensions_metadata_mismatch";
-	static constexpr const char *Description = "Allow to load extensions with not compatible metadata";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowPersistentSecretsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "allow_persistent_secrets";
-	static constexpr const char *Description =
-	    "Allow the creation of persistent secrets, that are stored and loaded on restarts";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowUnredactedSecretsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "allow_unredacted_secrets";
-	static constexpr const char *Description = "Allow printing unredacted secrets";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowUnsignedExtensionsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "allow_unsigned_extensions";
-	static constexpr const char *Description = "Allow to load extensions with invalid or missing signatures";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowedDirectoriesSetting {
-	using RETURN_TYPE = vector<string>;
-	static constexpr const char *Name = "allowed_directories";
-	static constexpr const char *Description = "List of directories/prefixes that are ALWAYS allowed to be queried - "
-	                                           "even when enable_external_access is false";
-	static constexpr const char *InputType = "VARCHAR[]";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AllowedPathsSetting {
-	using RETURN_TYPE = vector<string>;
-	static constexpr const char *Name = "allowed_paths";
-	static constexpr const char *Description =
-	    "List of files that are ALWAYS allowed to be queried - even when enable_external_access is false";
-	static constexpr const char *InputType = "VARCHAR[]";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ArrowLargeBufferSizeSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "arrow_large_buffer_size";
-	static constexpr const char *Description =
-	    "Whether Arrow buffers for strings, blobs, uuids and bits should be exported using large buffers";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ArrowLosslessConversionSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "arrow_lossless_conversion";
-	static constexpr const char *Description =
-	    "Whenever a DuckDB type does not have a clear native or canonical extension match in Arrow, export the types "
-	    "with a duckdb.type_name extension name.";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ArrowOutputListViewSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "arrow_output_list_view";
-	static constexpr const char *Description =
-	    "Whether export to Arrow format should use ListView as the physical layout for LIST columns";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AutoinstallExtensionRepositorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "autoinstall_extension_repository";
-	static constexpr const char *Description =
-	    "Overrides the custom endpoint for extension installation on autoloading";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AutoinstallKnownExtensionsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "autoinstall_known_extensions";
-	static constexpr const char *Description =
-	    "Whether known extensions are allowed to be automatically installed when a query depends on them";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct AutoloadKnownExtensionsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "autoload_known_extensions";
-	static constexpr const char *Description =
-	    "Whether known extensions are allowed to be automatically loaded when a query depends on them";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct CatalogErrorMaxSchemasSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "catalog_error_max_schemas";
-	static constexpr const char *Description =
-	    "The maximum number of schemas the system will scan for \"did you mean...\" style errors in the catalog";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct CheckpointThresholdSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "checkpoint_threshold";
-	static constexpr const char *Description =
-	    "The WAL size threshold at which to automatically trigger a checkpoint (e.g. 1GB)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct CustomExtensionRepositorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "custom_extension_repository";
-	static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct CustomProfilingSettingsSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "custom_profiling_settings";
-	static constexpr const char *Description = "Accepts a JSON enabling custom metrics";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct CustomUserAgentSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "custom_user_agent";
-	static constexpr const char *Description = "Metadata from DuckDB callers";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DebugAsofIejoinSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "debug_asof_iejoin";
-	static constexpr const char *Description = "DEBUG SETTING: force use of IEJoin to implement AsOf joins";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DebugCheckpointAbortSetting {
-	using RETURN_TYPE = CheckpointAbort;
-	static constexpr const char *Name = "debug_checkpoint_abort";
-	static constexpr const char *Description =
-	    "DEBUG SETTING: trigger an abort while checkpointing for testing purposes";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DebugForceExternalSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "debug_force_external";
-	static constexpr const char *Description =
-	    "DEBUG SETTING: force out-of-core computation for operators that support it, used for testing";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DebugForceNoCrossProductSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "debug_force_no_cross_product";
-	static constexpr const char *Description =
-	    "DEBUG SETTING: Force disable cross product generation when hyper graph isn't connected, used for testing";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DebugSkipCheckpointOnCommitSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "debug_skip_checkpoint_on_commit";
-	static constexpr const char *Description = "DEBUG SETTING: skip checkpointing on commit";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DebugWindowModeSetting {
-	using RETURN_TYPE = WindowAggregationMode;
-	static constexpr const char *Name = "debug_window_mode";
-	static constexpr const char *Description = "DEBUG SETTING: switch window mode to use";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DefaultBlockSizeSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "default_block_size";
-	static constexpr const char *Description =
-	    "The default block size for new duckdb database files (new as-in, they do not yet exist).";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DefaultCollationSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "default_collation";
-	static constexpr const char *Description = "The collation setting used when none is specified";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DefaultNullOrderSetting {
-	using RETURN_TYPE = DefaultOrderByNullType;
-	static constexpr const char *Name = "default_null_order";
-	static constexpr const char *Description = "NULL ordering used when none is specified (NULLS_FIRST or NULLS_LAST)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DefaultOrderSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "default_order";
-	static constexpr const char *Description = "The order type used when none is specified (ASC or DESC)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DefaultSecretStorageSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "default_secret_storage";
-	static constexpr const char *Description = "Allows switching the default storage for secrets";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DisabledFilesystemsSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "disabled_filesystems";
-	static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DisabledOptimizersSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "disabled_optimizers";
-	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DuckDBAPISetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "duckdb_api";
-	static constexpr const char *Description = "DuckDB API surface";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct DynamicOrFilterThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "dynamic_or_filter_threshold";
-	static constexpr const char *Description =
-	    "The maximum amount of OR filters we generate dynamically from a hash join";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableExternalAccessSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_external_access";
-	static constexpr const char *Description =
-	    "Allow the database to access external state (through e.g. loading/installing modules, COPY TO/FROM, CSV "
-	    "readers, pandas replacement scans, etc)";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableFSSTVectorsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_fsst_vectors";
-	static constexpr const char *Description =
-	    "Allow scans on FSST compressed segments to emit compressed vectors to utilize late decompression";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableHTTPLoggingSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_http_logging";
-	static constexpr const char *Description = "Enables HTTP logging";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableHTTPMetadataCacheSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_http_metadata_cache";
-	static constexpr const char *Description = "Whether or not the global http metadata is used to cache HTTP metadata";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableMacroDependenciesSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_macro_dependencies";
-	static constexpr const char *Description =
-	    "Enable created MACROs to create dependencies on the referenced objects (such as tables)";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableObjectCacheSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_object_cache";
-	static constexpr const char *Description = "[PLACEHOLDER] Legacy setting - does nothing";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableProfilingSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "enable_profiling";
-	static constexpr const char *Description =
-	    "Enables profiling, and sets the output format (JSON, QUERY_TREE, QUERY_TREE_OPTIMIZER)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableProgressBarSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_progress_bar";
-	static constexpr const char *Description =
-	    "Enables the progress bar, printing progress to the terminal for long queries";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static bool OnLocalSet(ClientContext &context, const Value &input);
-	static bool OnLocalReset(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableProgressBarPrintSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_progress_bar_print";
-	static constexpr const char *Description =
-	    "Controls the printing of the progress bar, when 'enable_progress_bar' is true";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct EnableViewDependenciesSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "enable_view_dependencies";
-	static constexpr const char *Description =
-	    "Enable created VIEWs to create dependencies on the referenced objects (such as tables)";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ErrorsAsJSONSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "errors_as_json";
-	static constexpr const char *Description = "Output error messages as structured JSON instead of as a raw string";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ExplainOutputSetting {
-	using RETURN_TYPE = ExplainOutputType;
-	static constexpr const char *Name = "explain_output";
-	static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ExtensionDirectorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "extension_directory";
-	static constexpr const char *Description = "Set the directory to store extensions in";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ExternalThreadsSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "external_threads";
-	static constexpr const char *Description = "The number of external threads that work on DuckDB tasks.";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct FileSearchPathSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "file_search_path";
-	static constexpr const char *Description = "A comma separated list of directories to search for input files";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ForceBitpackingModeSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "force_bitpacking_mode";
-	static constexpr const char *Description = "DEBUG SETTING: forces a specific bitpacking mode";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ForceCompressionSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "force_compression";
-	static constexpr const char *Description = "DEBUG SETTING: forces a specific compression method to be used";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct HomeDirectorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "home_directory";
-	static constexpr const char *Description = "Sets the home directory used by the system";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct HTTPLoggingOutputSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "http_logging_output";
-	static constexpr const char *Description =
-	    "The file to which HTTP logging output should be saved, or empty to print to the terminal";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct HTTPProxySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "http_proxy";
-	static constexpr const char *Description = "HTTP proxy host";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct HTTPProxyPasswordSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "http_proxy_password";
-	static constexpr const char *Description = "Password for HTTP proxy";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct HTTPProxyUsernameSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "http_proxy_username";
-	static constexpr const char *Description = "Username for HTTP proxy";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct IEEEFloatingPointOpsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "ieee_floating_point_ops";
-	static constexpr const char *Description =
-	    "Use IEE754-compliant floating point operations (returning NAN instead of errors/NULL).";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ImmediateTransactionModeSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "immediate_transaction_mode";
-	static constexpr const char *Description =
-	    "Whether transactions should be started lazily when needed, or immediately when BEGIN TRANSACTION is called";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct IndexScanMaxCountSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "index_scan_max_count";
-	static constexpr const char *Description =
-	    "The maximum index scan count sets a threshold for index scans. If fewer than MAX(index_scan_max_count, "
-	    "index_scan_percentage * total_row_count) rows match, we perform an index scan instead of a table scan.";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct IndexScanPercentageSetting {
-	using RETURN_TYPE = double;
-	static constexpr const char *Name = "index_scan_percentage";
-	static constexpr const char *Description =
-	    "The index scan percentage sets a threshold for index scans. If fewer than MAX(index_scan_max_count, "
-	    "index_scan_percentage * total_row_count) rows match, we perform an index scan instead of a table scan.";
-	static constexpr const char *InputType = "DOUBLE";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct IntegerDivisionSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "integer_division";
-	static constexpr const char *Description =
-	    "Whether or not the / operator defaults to integer division, or to floating point division";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct LockConfigurationSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "lock_configuration";
-	static constexpr const char *Description = "Whether or not the configuration can be altered";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct LogQueryPathSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "log_query_path";
-	static constexpr const char *Description =
-	    "Specifies the path to which queries should be logged (default: NULL, queries are not logged)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct MaxExpressionDepthSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "max_expression_depth";
-	static constexpr const char *Description =
-	    "The maximum expression depth limit in the parser. WARNING: increasing this setting and using very deep "
-	    "expressions might lead to stack overflow errors.";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct MaxMemorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "max_memory";
-	static constexpr const char *Description = "The maximum memory of the system (e.g. 1GB)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct MaxTempDirectorySizeSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "max_temp_directory_size";
-	static constexpr const char *Description =
-	    "The maximum amount of data stored inside the 'temp_directory' (when set) (e.g. 1GB)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct MaxVacuumTasksSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "max_vacuum_tasks";
-	static constexpr const char *Description = "The maximum vacuum tasks to schedule during a checkpoint.";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct MergeJoinThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "merge_join_threshold";
-	static constexpr const char *Description = "The number of rows we need on either table to choose a merge join";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct NestedLoopJoinThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "nested_loop_join_threshold";
-	static constexpr const char *Description =
-	    "The number of rows we need on either table to choose a nested loop join";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct OldImplicitCastingSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "old_implicit_casting";
-	static constexpr const char *Description = "Allow implicit casting to/from VARCHAR";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct OrderByNonIntegerLiteralSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "order_by_non_integer_literal";
-	static constexpr const char *Description =
-	    "Allow ordering by non-integer literals - ordering by such literals has no effect.";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct OrderedAggregateThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "ordered_aggregate_threshold";
-	static constexpr const char *Description = "The number of rows to accumulate before sorting, used for tuning";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static bool OnLocalSet(ClientContext &context, const Value &input);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PartitionedWriteFlushThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "partitioned_write_flush_threshold";
-	static constexpr const char *Description =
-	    "The threshold in number of rows after which we flush a thread state when writing using PARTITION_BY";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PartitionedWriteMaxOpenFilesSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "partitioned_write_max_open_files";
-	static constexpr const char *Description =
-	    "The maximum amount of files the system can keep open before flushing to disk when writing using PARTITION_BY";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PasswordSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "password";
-	static constexpr const char *Description = "The password to use. Ignored for legacy compatibility.";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PerfectHtThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "perfect_ht_threshold";
-	static constexpr const char *Description = "Threshold in bytes for when to use a perfect hash table";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PivotFilterThresholdSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "pivot_filter_threshold";
-	static constexpr const char *Description =
-	    "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PivotLimitSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "pivot_limit";
-	static constexpr const char *Description = "The maximum number of pivot columns in a pivot statement";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PreferRangeJoinsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "prefer_range_joins";
-	static constexpr const char *Description = "Force use of range joins with mixed predicates";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PreserveIdentifierCaseSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "preserve_identifier_case";
-	static constexpr const char *Description =
-	    "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct PreserveInsertionOrderSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "preserve_insertion_order";
-	static constexpr const char *Description =
-	    "Whether or not to preserve insertion order. If set to false the system is allowed to re-order any results "
-	    "that do not contain ORDER BY clauses.";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ProduceArrowStringViewSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "produce_arrow_string_view";
-	static constexpr const char *Description =
-	    "Whether strings should be produced by DuckDB in Utf8View format instead of Utf8";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ProfileOutputSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "profile_output";
-	static constexpr const char *Description =
-	    "The file to which profile output should be saved, or empty to print to the terminal";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ProfilingModeSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "profiling_mode";
-	static constexpr const char *Description = "The profiling mode (STANDARD or DETAILED)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ProgressBarTimeSetting {
-	using RETURN_TYPE = int64_t;
-	static constexpr const char *Name = "progress_bar_time";
-	static constexpr const char *Description =
-	    "Sets the time (in milliseconds) how long a query needs to take before we start printing a progress bar";
-	static constexpr const char *InputType = "BIGINT";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ScalarSubqueryErrorOnMultipleRowsSetting {
-	using RETURN_TYPE = bool;
-	static constexpr const char *Name = "scalar_subquery_error_on_multiple_rows";
-	static constexpr const char *Description =
-	    "When a scalar subquery returns multiple rows - return a random row instead of returning an error.";
-	static constexpr const char *InputType = "BOOLEAN";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct SchemaSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "schema";
-	static constexpr const char *Description =
-	    "Sets the default search schema. Equivalent to setting search_path to a single value.";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct SearchPathSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "search_path";
-	static constexpr const char *Description =
-	    "Sets the default catalog search path as a comma-separated list of values";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct SecretDirectorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "secret_directory";
-	static constexpr const char *Description = "Set the directory to which persistent secrets are stored";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct StorageCompatibilityVersionSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "storage_compatibility_version";
-	static constexpr const char *Description = "Serialize on checkpoint with compatibility for a given duckdb version";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct StreamingBufferSizeSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "streaming_buffer_size";
-	static constexpr const char *Description =
-	    "The maximum memory to buffer between fetching from a streaming result (e.g. 1GB)";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static void ResetLocal(ClientContext &context);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct TempDirectorySetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "temp_directory";
-	static constexpr const char *Description = "Set the directory to which to write temp files";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ThreadsSetting {
-	using RETURN_TYPE = int64_t;
-	static constexpr const char *Name = "threads";
-	static constexpr const char *Description = "The number of total threads used by the system.";
-	static constexpr const char *InputType = "BIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct UsernameSetting {
-	using RETURN_TYPE = string;
-	static constexpr const char *Name = "username";
-	static constexpr const char *Description = "The username to use. Ignored for legacy compatibility.";
-	static constexpr const char *InputType = "VARCHAR";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-struct ZstdMinStringLengthSetting {
-	using RETURN_TYPE = idx_t;
-	static constexpr const char *Name = "zstd_min_string_length";
-	static constexpr const char *Description =
-	    "The (average) length at which to enable ZSTD compression, defaults to 4096";
-	static constexpr const char *InputType = "UBIGINT";
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(const ClientContext &context);
-};
-
-//===----------------------------------------------------------------------===//
-// End of the auto-generated list of settings structures
-//===--------------------------------------------------------------------===//
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/stream_query_result.hpp b/src/duckdb/src/include/duckdb/main/stream_query_result.hpp
deleted file mode 100644
index 3c04a364c..000000000
--- a/src/duckdb/src/include/duckdb/main/stream_query_result.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/stream_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/winapi.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/common/enums/stream_execution_result.hpp"
-#include "duckdb/main/buffered_data/simple_buffered_data.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class ClientContextLock;
-class Executor;
-class MaterializedQueryResult;
-class PreparedStatementData;
-
-class StreamQueryResult : public QueryResult {
-	friend class ClientContext;
-
-public:
-	static constexpr const QueryResultType TYPE = QueryResultType::STREAM_RESULT;
-
-public:
-	//! Create a successful StreamQueryResult. StreamQueryResults should always be successful initially (it makes no
-	//! sense to stream an error).
-	DUCKDB_API StreamQueryResult(StatementType statement_type, StatementProperties properties,
-	                             vector<LogicalType> types, vector<string> names, ClientProperties client_properties,
-	                             shared_ptr<BufferedData> buffered_data);
-	DUCKDB_API explicit StreamQueryResult(ErrorData error);
-	DUCKDB_API ~StreamQueryResult() override;
-
-public:
-	static bool IsChunkReady(StreamExecutionResult result);
-	//! Reschedules the tasks that work on producing a result chunk, returning when at least one task can be executed
-	DUCKDB_API void WaitForTask();
-	//! Executes a single task within the final pipeline, returning whether or not a chunk is ready to be fetched
-	DUCKDB_API StreamExecutionResult ExecuteTask();
-	//! Fetches a DataChunk from the query result.
-	DUCKDB_API unique_ptr<DataChunk> FetchRaw() override;
-	//! Converts the QueryResult to a string
-	DUCKDB_API string ToString() override;
-	//! Materializes the query result and turns it into a materialized query result
-	DUCKDB_API unique_ptr<MaterializedQueryResult> Materialize();
-
-	DUCKDB_API bool IsOpen();
-
-	//! Closes the StreamQueryResult
-	DUCKDB_API void Close();
-
-	//! The client context this StreamQueryResult belongs to
-	shared_ptr<ClientContext> context;
-
-private:
-	StreamExecutionResult ExecuteTaskInternal(ClientContextLock &lock);
-	unique_ptr<DataChunk> FetchInternal(ClientContextLock &lock);
-	unique_ptr<ClientContextLock> LockContext();
-	void CheckExecutableInternal(ClientContextLock &lock);
-	bool IsOpenInternal(ClientContextLock &lock);
-
-private:
-	shared_ptr<BufferedData> buffered_data;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/table_description.hpp b/src/duckdb/src/include/duckdb/main/table_description.hpp
deleted file mode 100644
index d1b7f6561..000000000
--- a/src/duckdb/src/include/duckdb/main/table_description.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/table_description.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/column_definition.hpp"
-
-namespace duckdb {
-
-class TableDescription {
-public:
-	TableDescription(const string &database_name, const string &schema_name, const string &table_name)
-	    : database(database_name), schema(schema_name), table(table_name) {};
-
-	TableDescription() = delete;
-
-public:
-	//! The database of the table.
-	string database;
-	//! The schema of the table.
-	string schema;
-	//! The name of the table.
-	string table;
-	//! True, if the catalog is readonly.
-	bool readonly;
-	//! The columns of the table.
-	vector<ColumnDefinition> columns;
-
-public:
-	idx_t PhysicalColumnCount() const {
-		idx_t count = 0;
-		for (auto &column : columns) {
-			if (column.Generated()) {
-				continue;
-			}
-			count++;
-		}
-		D_ASSERT(count != 0);
-		return count;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/main/valid_checker.hpp b/src/duckdb/src/include/duckdb/main/valid_checker.hpp
deleted file mode 100644
index bf563509f..000000000
--- a/src/duckdb/src/include/duckdb/main/valid_checker.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/valid_checker.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/mutex.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-class MetaTransaction;
-
-class ValidChecker {
-public:
-	ValidChecker();
-
-	DUCKDB_API static ValidChecker &Get(DatabaseInstance &db);
-	DUCKDB_API static ValidChecker &Get(MetaTransaction &transaction);
-
-	DUCKDB_API void Invalidate(string error);
-	DUCKDB_API bool IsInvalidated();
-	DUCKDB_API string InvalidatedMessage();
-
-	template <class T>
-	static bool IsInvalidated(T &o) {
-		return Get(o).IsInvalidated();
-	}
-	template <class T>
-	static void Invalidate(T &o, string error) {
-		Get(o).Invalidate(std::move(error));
-	}
-
-	template <class T>
-	static string InvalidatedMessage(T &o) {
-		return Get(o).InvalidatedMessage();
-	}
-
-private:
-	//! Set to true if a fatal exception has occurred
-	mutex invalidate_lock;
-	atomic<bool> is_invalidated;
-	string invalidated_msg;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/build_probe_side_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/build_probe_side_optimizer.hpp
deleted file mode 100644
index e60938745..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/build_probe_side_optimizer.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/build_side_probe_side_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-struct BuildSize {
-	double left_side;
-	double right_side;
-
-	// Initialize with 1 so the build side is just the cardinality if types aren't
-	// known.
-	BuildSize() : left_side(1), right_side(1) {
-	}
-};
-
-class BuildProbeSideOptimizer : LogicalOperatorVisitor {
-private:
-	static constexpr idx_t COLUMN_COUNT_PENALTY = 2;
-	static constexpr double PREFER_RIGHT_DEEP_PENALTY = 0.15;
-
-public:
-	explicit BuildProbeSideOptimizer(ClientContext &context, LogicalOperator &op);
-	void VisitOperator(LogicalOperator &op) override;
-	void VisitExpression(unique_ptr<Expression> *expression) override {};
-
-private:
-	void TryFlipJoinChildren(LogicalOperator &op) const;
-	static idx_t ChildHasJoins(LogicalOperator &op);
-
-	static BuildSize GetBuildSizes(const LogicalOperator &op, idx_t lhs_cardinality, idx_t rhs_cardinality);
-	static double GetBuildSize(vector<LogicalType> types, idx_t cardinality);
-
-private:
-	ClientContext &context;
-	vector<ColumnBinding> preferred_on_probe_side;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/column_binding_replacer.hpp b/src/duckdb/src/include/duckdb/optimizer/column_binding_replacer.hpp
deleted file mode 100644
index 63fb16e83..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/column_binding_replacer.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/column_binding_replacer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-struct ReplacementBinding {
-public:
-	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding);
-	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding, LogicalType new_type);
-
-public:
-	ColumnBinding old_binding;
-	ColumnBinding new_binding;
-
-	bool replace_type;
-	LogicalType new_type;
-};
-
-//! The ColumnBindingReplacer updates column bindings (e.g., after changing the operator plan), utility for optimizers
-class ColumnBindingReplacer : LogicalOperatorVisitor {
-public:
-	ColumnBindingReplacer();
-
-public:
-	//! Update each operator of the plan
-	void VisitOperator(LogicalOperator &op) override;
-	//! Visit an expression and update its column bindings
-	void VisitExpression(unique_ptr<Expression> *expression) override;
-
-public:
-	//! Contains all bindings that need to be updated
-	vector<ReplacementBinding> replacement_bindings;
-
-	//! Do not recurse further than this operator (optional)
-	optional_ptr<LogicalOperator> stop_operator;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/column_lifetime_analyzer.hpp b/src/duckdb/src/include/duckdb/optimizer/column_lifetime_analyzer.hpp
deleted file mode 100644
index d6fe5b72b..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/column_lifetime_analyzer.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/column_lifetime_analyzer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-class BoundColumnRefExpression;
-
-//! The ColumnLifetimeAnalyzer optimizer traverses the logical operator tree and ensures that columns are removed from
-//! the plan when no longer required
-class ColumnLifetimeAnalyzer : public LogicalOperatorVisitor {
-public:
-	explicit ColumnLifetimeAnalyzer(Optimizer &optimizer_p, LogicalOperator &root_p, bool is_root = false)
-	    : optimizer(optimizer_p), root(root_p), everything_referenced(is_root) {
-	}
-
-	void VisitOperator(LogicalOperator &op) override;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundReferenceExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	Optimizer &optimizer;
-	LogicalOperator &root;
-	//! Whether or not all the columns are referenced. This happens in the case of the root expression (because the
-	//! output implicitly refers all the columns below it)
-	bool everything_referenced;
-	//! The set of column references
-	column_binding_set_t column_references;
-
-private:
-	void VisitOperatorInternal(LogicalOperator &op);
-	void StandardVisitOperator(LogicalOperator &op);
-	void ExtractUnusedColumnBindings(const vector<ColumnBinding> &bindings, column_binding_set_t &unused_bindings);
-	static void GenerateProjectionMap(vector<ColumnBinding> bindings, column_binding_set_t &unused_bindings,
-	                                  vector<idx_t> &map);
-	void Verify(LogicalOperator &op);
-	void AddVerificationProjection(unique_ptr<LogicalOperator> &child);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/common_aggregate_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/common_aggregate_optimizer.hpp
deleted file mode 100644
index 0728b2267..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/common_aggregate_optimizer.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/common_aggregate_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-//! The CommonAggregateOptimizer optimizer eliminates duplicate aggregates from aggregate nodes
-class CommonAggregateOptimizer : public LogicalOperatorVisitor {
-public:
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	void StandardVisitOperator(LogicalOperator &op);
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	void ExtractCommonAggregates(LogicalAggregate &aggr);
-
-private:
-	column_binding_map_t<ColumnBinding> aggregate_map;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/compressed_materialization.hpp b/src/duckdb/src/include/duckdb/optimizer/compressed_materialization.hpp
deleted file mode 100644
index 7df8e328d..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/compressed_materialization.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/compressed_materialization.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-class ClientContext;
-class LogicalOperator;
-
-struct CMChildInfo {
-public:
-	CMChildInfo(LogicalOperator &op, const column_binding_set_t &referenced_bindings);
-
-public:
-	//! Bindings and types before compressing
-	vector<ColumnBinding> bindings_before;
-	vector<LogicalType> &types;
-	//! Whether the input binding is eligible for compression
-	vector<bool> can_compress;
-
-	//! Bindings after compressing (projection on top)
-	vector<ColumnBinding> bindings_after;
-};
-
-struct CMBindingInfo {
-public:
-	explicit CMBindingInfo(ColumnBinding binding, const LogicalType &type);
-
-public:
-	ColumnBinding binding;
-
-	//! Type before compressing
-	LogicalType type;
-	bool needs_decompression;
-	unique_ptr<BaseStatistics> stats;
-};
-
-struct CompressedMaterializationInfo {
-public:
-	CompressedMaterializationInfo(LogicalOperator &op, vector<idx_t> &&child_idxs,
-	                              const column_binding_set_t &referenced_bindings);
-
-public:
-	//! Mapping from incoming bindings to outgoing bindings
-	column_binding_map_t<CMBindingInfo> binding_map;
-
-	//! Operator child info
-	vector<idx_t> child_idxs;
-	vector<CMChildInfo> child_info;
-};
-
-struct CompressExpression {
-public:
-	CompressExpression(unique_ptr<Expression> expression, unique_ptr<BaseStatistics> stats);
-
-public:
-	unique_ptr<Expression> expression;
-	unique_ptr<BaseStatistics> stats;
-};
-
-typedef column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map_t;
-
-//! The CompressedMaterialization optimizer compressed columns using projections, based on available statistics,
-//! but only if the data enters a materializing operator
-class CompressedMaterialization {
-private:
-	//! Somewhat defensive constants that try to limit when compressed materialization is triggered for joins
-	static constexpr idx_t JOIN_BUILD_CARDINALITY_THRESHOLD = 1048576;
-	static constexpr double JOIN_CARDINALITY_RATIO_THRESHOLD = 8;
-
-public:
-	CompressedMaterialization(Optimizer &optimizer, LogicalOperator &root, statistics_map_t &statistics_map);
-
-	void Compress(unique_ptr<LogicalOperator> &op);
-
-private:
-	//! Compress materializing operators
-	void CompressAggregate(unique_ptr<LogicalOperator> &op);
-	void CompressComparisonJoin(unique_ptr<LogicalOperator> &op);
-	void CompressDistinct(unique_ptr<LogicalOperator> &op);
-	void CompressOrder(unique_ptr<LogicalOperator> &op);
-
-	//! Update statistics after compressing
-	void UpdateAggregateStats(unique_ptr<LogicalOperator> &op);
-	void UpdateComparisonJoinStats(unique_ptr<LogicalOperator> &op);
-	void UpdateOrderStats(unique_ptr<LogicalOperator> &op);
-
-	//! Adds bindings referenced in expression to referenced_bindings
-	static void GetReferencedBindings(const Expression &expression, column_binding_set_t &referenced_bindings);
-	//! Updates CMBindingInfo in the binding_map in info
-	void UpdateBindingInfo(CompressedMaterializationInfo &info, const ColumnBinding &binding, bool needs_decompression);
-
-	//! Create (de)compress projections around the operator
-	void CreateProjections(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
-	bool TryCompressChild(CompressedMaterializationInfo &info, const CMChildInfo &child_info,
-	                      vector<unique_ptr<CompressExpression>> &compress_expressions);
-	void CreateCompressProjection(unique_ptr<LogicalOperator> &child_op,
-	                              vector<unique_ptr<CompressExpression>> compress_exprs,
-	                              CompressedMaterializationInfo &info, CMChildInfo &child_info);
-	void CreateDecompressProjection(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
-
-	//! Create expressions that apply a scalar compression function
-	unique_ptr<CompressExpression> GetCompressExpression(const ColumnBinding &binding, const LogicalType &type,
-	                                                     const bool &can_compress);
-	unique_ptr<CompressExpression> GetCompressExpression(unique_ptr<Expression> input, const BaseStatistics &stats);
-	unique_ptr<CompressExpression> GetIntegralCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
-	unique_ptr<CompressExpression> GetStringCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
-
-	//! Create an expression that applies a scalar decompression function
-	unique_ptr<Expression> GetDecompressExpression(unique_ptr<Expression> input, const LogicalType &result_type,
-	                                               const BaseStatistics &stats);
-	unique_ptr<Expression> GetIntegralDecompress(unique_ptr<Expression> input, const LogicalType &result_type,
-	                                             const BaseStatistics &stats);
-	unique_ptr<Expression> GetStringDecompress(unique_ptr<Expression> input, const LogicalType &result_type,
-	                                           const BaseStatistics &stats);
-
-private:
-	Optimizer &optimizer;
-	ClientContext &context;
-	//! The root of the query plan
-	optional_ptr<LogicalOperator> root;
-	//! The map of ColumnBinding -> statistics for the various nodes
-	statistics_map_t &statistics_map;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/cse_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/cse_optimizer.hpp
deleted file mode 100644
index feb05db65..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/cse_optimizer.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/cse_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-class Binder;
-struct CSEReplacementState;
-
-//! The CommonSubExpression optimizer traverses the expressions of a LogicalOperator to look for duplicate expressions
-//! if there are any, it pushes a projection under the operator that resolves these expressions
-class CommonSubExpressionOptimizer : public LogicalOperatorVisitor {
-public:
-	explicit CommonSubExpressionOptimizer(Binder &binder) : binder(binder) {
-	}
-
-public:
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	//! First iteration: count how many times each expression occurs
-	void CountExpressions(Expression &expr, CSEReplacementState &state);
-	//! Second iteration: perform the actual replacement of the duplicate expressions with common subexpressions nodes
-	void PerformCSEReplacement(unique_ptr<Expression> &expr, CSEReplacementState &state);
-
-	//! Main method to extract common subexpressions
-	void ExtractCommonSubExpresions(LogicalOperator &op);
-
-private:
-	Binder &binder;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/cte_filter_pusher.hpp b/src/duckdb/src/include/duckdb/optimizer/cte_filter_pusher.hpp
deleted file mode 100644
index 4923dd5da..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/cte_filter_pusher.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/cte_filter_pusher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/insertion_order_preserving_map.hpp"
-
-namespace duckdb {
-
-class LogicalOperator;
-class Optimizer;
-
-class CTEFilterPusher {
-public:
-	explicit CTEFilterPusher(Optimizer &optimizer);
-	//! Finds all materialized CTEs and pushes OR filters into them (if applicable)
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-
-private:
-	//! CTE info needed for creating OR filters that can be pushed down
-	struct MaterializedCTEInfo {
-		explicit MaterializedCTEInfo(LogicalOperator &materialized_cte);
-		LogicalOperator &materialized_cte;
-		vector<reference<LogicalOperator>> filters;
-		bool all_cte_refs_are_filtered;
-	};
-
-private:
-	//! Find all materialized CTEs and their refs
-	void FindCandidates(LogicalOperator &op);
-	//! Creates an OR filter and pushes it into a materialized CTE
-	void PushFilterIntoCTE(MaterializedCTEInfo &info);
-
-private:
-	//! The optimizer
-	Optimizer &optimizer;
-	//! Mapping from CTE index to CTE info, order preserving so deepest CTEs are done first
-	InsertionOrderPreservingMap<unique_ptr<MaterializedCTEInfo>> cte_info_map;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/deliminator.hpp b/src/duckdb/src/include/duckdb/optimizer/deliminator.hpp
deleted file mode 100644
index fb6d1d913..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/deliminator.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/deliminator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-
-namespace duckdb {
-
-struct DelimCandidate;
-
-//! The Deliminator optimizer traverses the logical operator tree and removes any redundant DelimGets/DelimJoins
-class Deliminator {
-public:
-	Deliminator() {
-	}
-	//! Perform DelimJoin elimination
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-
-private:
-	//! Finds DelimJoins and their corresponding DelimGets
-	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates);
-	void FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate, idx_t depth = 0);
-	//! Whether the DelimJoin is selective
-	bool HasSelection(const LogicalOperator &delim_join);
-	//! Remove joins with a DelimGet
-	bool RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
-	                            unique_ptr<LogicalOperator> &join, bool &all_equality_conditions);
-	bool RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
-	                                      unique_ptr<LogicalOperator> &join,
-	                                      const vector<ReplacementBinding> &replacement_bindings);
-	void TrySwitchSingleToLeft(LogicalComparisonJoin &delim_join);
-
-private:
-	optional_ptr<LogicalOperator> root;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/empty_result_pullup.hpp b/src/duckdb/src/include/duckdb/optimizer/empty_result_pullup.hpp
deleted file mode 100644
index 8959c0ecc..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/empty_result_pullup.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/deliminator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-
-namespace duckdb {
-
-//! The EmptyResultPullup Optimizer traverses the logical operator tree and Pulls up empty operators when possible
-class EmptyResultPullup : LogicalOperatorVisitor {
-public:
-	EmptyResultPullup() {
-	}
-
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-
-private:
-	unique_ptr<LogicalOperator> PullUpEmptyJoinChildren(unique_ptr<LogicalOperator> op);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp b/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp
deleted file mode 100644
index 12512a32f..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/expression_heuristics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-class ExpressionHeuristics : public LogicalOperatorVisitor {
-public:
-	explicit ExpressionHeuristics(Optimizer &optimizer) : optimizer(optimizer) {
-	}
-
-	Optimizer &optimizer;
-	unique_ptr<LogicalOperator> root;
-
-public:
-	//! Search for filters to be reordered
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-	//! Reorder the expressions of a filter
-	void ReorderExpressions(vector<unique_ptr<Expression>> &expressions);
-	//! Return the cost of an expression
-	idx_t Cost(Expression &expr);
-
-	unique_ptr<Expression> VisitReplace(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	//! Override this function to search for filter operators
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	unordered_map<std::string, idx_t> function_costs = {
-	    {"+", 5},       {"-", 5},    {"&", 5},          {"#", 5},
-	    {">>", 5},      {"<<", 5},   {"abs", 5},        {"*", 10},
-	    {"%", 10},      {"/", 15},   {"date_part", 20}, {"year", 20},
-	    {"round", 100}, {"~~", 200}, {"!~~", 200},      {"regexp_matches", 200},
-	    {"||", 200}};
-
-	idx_t ExpressionCost(BoundBetweenExpression &expr);
-	idx_t ExpressionCost(BoundCaseExpression &expr);
-	idx_t ExpressionCost(BoundCastExpression &expr);
-	idx_t ExpressionCost(BoundComparisonExpression &expr);
-	idx_t ExpressionCost(BoundConjunctionExpression &expr);
-	idx_t ExpressionCost(BoundFunctionExpression &expr);
-	idx_t ExpressionCost(BoundOperatorExpression &expr, ExpressionType expr_type);
-	idx_t ExpressionCost(PhysicalType return_type, idx_t multiplier);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/expression_rewriter.hpp b/src/duckdb/src/include/duckdb/optimizer/expression_rewriter.hpp
deleted file mode 100644
index e0bf154d6..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/expression_rewriter.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/expression_rewriter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-//! The ExpressionRewriter performs a set of fixed rewrite rules on the expressions that occur in a SQL statement
-class ExpressionRewriter : public LogicalOperatorVisitor {
-public:
-	explicit ExpressionRewriter(ClientContext &context) : context(context) {
-	}
-
-public:
-	//! The set of rules as known by the Expression Rewriter
-	vector<unique_ptr<Rule>> rules;
-
-	ClientContext &context;
-
-public:
-	void VisitOperator(LogicalOperator &op) override;
-	void VisitExpression(unique_ptr<Expression> *expression) override;
-
-	// Generates either a constant_or_null(child) expression
-	static unique_ptr<Expression> ConstantOrNull(unique_ptr<Expression> child, Value value);
-	static unique_ptr<Expression> ConstantOrNull(vector<unique_ptr<Expression>> children, Value value);
-
-private:
-	//! Apply a set of rules to a specific expression
-	static unique_ptr<Expression> ApplyRules(LogicalOperator &op, const vector<reference<Rule>> &rules,
-	                                         unique_ptr<Expression> expr, bool &changes_made, bool is_root = false);
-
-	optional_ptr<LogicalOperator> op;
-	vector<reference<Rule>> to_apply_rules;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/filter_combiner.hpp b/src/duckdb/src/include/duckdb/optimizer/filter_combiner.hpp
deleted file mode 100644
index 68e22573a..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/filter_combiner.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/filter_combiner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-
-#include "duckdb/storage/data_table.hpp"
-#include <functional>
-#include <map>
-
-namespace duckdb {
-class Optimizer;
-
-enum class ValueComparisonResult { PRUNE_LEFT, PRUNE_RIGHT, UNSATISFIABLE_CONDITION, PRUNE_NOTHING };
-enum class FilterResult { UNSATISFIABLE, SUCCESS, UNSUPPORTED };
-
-//! The FilterCombiner combines several filters and generates a logically equivalent set that is more efficient
-//! Amongst others:
-//! (1) it prunes obsolete filter conditions: i.e. [X > 5 and X > 7] => [X > 7]
-//! (2) it generates new filters for expressions in the same equivalence set: i.e. [X = Y and X = 500] => [Y = 500]
-//! (3) it prunes branches that have unsatisfiable filters: i.e. [X = 5 AND X > 6] => FALSE, prune branch
-class FilterCombiner {
-public:
-	explicit FilterCombiner(ClientContext &context);
-	explicit FilterCombiner(Optimizer &optimizer);
-
-	ClientContext &context;
-
-public:
-	struct ExpressionValueInformation {
-		Value constant;
-		ExpressionType comparison_type;
-	};
-
-	FilterResult AddFilter(unique_ptr<Expression> expr);
-
-	//! Returns whether or not a set of integral values is a dense range (i.e. 1, 2, 3, 4, 5)
-	//! If this returns true - this sorts "in_list" as a side-effect
-	static bool IsDenseRange(vector<Value> &in_list);
-	static bool ContainsNull(vector<Value> &in_list);
-
-	void GenerateFilters(const std::function<void(unique_ptr<Expression> filter)> &callback);
-	bool HasFilters();
-	TableFilterSet GenerateTableScanFilters(const vector<ColumnIndex> &column_ids);
-	// vector<unique_ptr<TableFilter>> GenerateZonemapChecks(vector<idx_t> &column_ids, vector<unique_ptr<TableFilter>>
-	// &pushed_filters);
-
-private:
-	FilterResult AddFilter(Expression &expr);
-	FilterResult AddBoundComparisonFilter(Expression &expr);
-	FilterResult AddTransitiveFilters(BoundComparisonExpression &comparison, bool is_root = true);
-	unique_ptr<Expression> FindTransitiveFilter(Expression &expr);
-	// unordered_map<idx_t, std::pair<Value *, Value *>>
-	// FindZonemapChecks(vector<idx_t> &column_ids, unordered_set<idx_t> &not_constants, Expression *filter);
-	Expression &GetNode(Expression &expr);
-	idx_t GetEquivalenceSet(Expression &expr);
-	FilterResult AddConstantComparison(vector<ExpressionValueInformation> &info_list, ExpressionValueInformation info);
-	//
-	//	//! Functions used to push and generate OR Filters
-	//	void LookUpConjunctions(Expression *expr);
-	//	bool BFSLookUpConjunctions(BoundConjunctionExpression *conjunction);
-	//	void VerifyOrsToPush(Expression &expr);
-	//
-	//	bool UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr);
-	//	bool UpdateFilterByColumn(BoundColumnRefExpression *column_ref, BoundComparisonExpression *comparison_expr);
-	//	void GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids);
-	//
-	//	template <typename CONJUNCTION_TYPE>
-	//	void GenerateConjunctionFilter(BoundConjunctionExpression *conjunction, ConjunctionFilter *last_conj_filter) {
-	//		auto new_filter = NextConjunctionFilter<CONJUNCTION_TYPE>(conjunction);
-	//		auto conj_filter_ptr = (ConjunctionFilter *)new_filter.get();
-	//		last_conj_filter->child_filters.push_back(std::move(new_filter));
-	//		last_conj_filter = conj_filter_ptr;
-	//	}
-	//
-	//	template <typename CONJUNCTION_TYPE>
-	//	unique_ptr<TableFilter> NextConjunctionFilter(BoundConjunctionExpression *conjunction) {
-	//		unique_ptr<ConjunctionFilter> conj_filter = make_uniq<CONJUNCTION_TYPE>();
-	//		for (auto &expr : conjunction->children) {
-	//			auto comp_expr = (BoundComparisonExpression *)expr.get();
-	//			auto &const_expr =
-	//			    (comp_expr->left->type == ExpressionType::VALUE_CONSTANT) ? *comp_expr->left : *comp_expr->right;
-	//			auto const_value = ExpressionExecutor::EvaluateScalar(const_expr);
-	//			auto const_filter = make_uniq<ConstantFilter>(comp_expr->type, const_value);
-	//			conj_filter->child_filters.push_back(std::move(const_filter));
-	//		}
-	//		return std::move(conj_filter);
-	//	}
-
-private:
-	vector<unique_ptr<Expression>> remaining_filters;
-
-	expression_map_t<unique_ptr<Expression>> stored_expressions;
-	expression_map_t<idx_t> equivalence_set_map;
-	unordered_map<idx_t, vector<ExpressionValueInformation>> constant_values;
-	unordered_map<idx_t, vector<reference<Expression>>> equivalence_map;
-	idx_t set_index = 0;
-	//
-	//	//! Structures used for OR Filters
-	//
-	//	struct ConjunctionsToPush {
-	//		BoundConjunctionExpression *root_or;
-	//
-	//		// only preserve AND if there is a single column in the expression
-	//		bool preserve_and = true;
-	//
-	//		// conjunction chain for this column
-	//		vector<unique_ptr<BoundConjunctionExpression>> conjunctions;
-	//	};
-	//
-	//	expression_map_t<vector<unique_ptr<ConjunctionsToPush>>> map_col_conjunctions;
-	//	vector<BoundColumnRefExpression *> vec_colref_insertion_order;
-	//
-	//	BoundConjunctionExpression *cur_root_or;
-	//	BoundConjunctionExpression *cur_conjunction;
-	//
-	//	BoundColumnRefExpression *cur_colref_to_push;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/filter_pullup.hpp b/src/duckdb/src/include/duckdb/optimizer/filter_pullup.hpp
deleted file mode 100644
index a35fbaab9..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/filter_pullup.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/filter_pullup.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class FilterPullup {
-public:
-	explicit FilterPullup(bool pullup = false, bool add_column = false)
-	    : can_pullup(pullup), can_add_column(add_column) {
-	}
-
-	//! Perform filter pullup
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-
-private:
-	vector<unique_ptr<Expression>> filters_expr_pullup;
-
-	// only pull up filters when there is a fork
-	bool can_pullup = false;
-
-	// identifiy case the branch is a set operation (INTERSECT or EXCEPT)
-	bool can_add_column = false;
-
-private:
-	// Generate logical filters pulled up
-	unique_ptr<LogicalOperator> GeneratePullupFilter(unique_ptr<LogicalOperator> child,
-	                                                 vector<unique_ptr<Expression>> &expressions);
-
-	//! Pull up a LogicalFilter op
-	unique_ptr<LogicalOperator> PullupFilter(unique_ptr<LogicalOperator> op);
-
-	//! Pull up filter in a LogicalProjection op
-	unique_ptr<LogicalOperator> PullupProjection(unique_ptr<LogicalOperator> op);
-
-	//! Pull up filter in a LogicalCrossProduct op
-	unique_ptr<LogicalOperator> PullupCrossProduct(unique_ptr<LogicalOperator> op);
-
-	unique_ptr<LogicalOperator> PullupJoin(unique_ptr<LogicalOperator> op);
-
-	// PPullup filter in a left join
-	unique_ptr<LogicalOperator> PullupFromLeft(unique_ptr<LogicalOperator> op);
-
-	// Pullup filter in a inner join
-	unique_ptr<LogicalOperator> PullupInnerJoin(unique_ptr<LogicalOperator> op);
-
-	// Pullup filter in LogicalIntersect or LogicalExcept op
-	unique_ptr<LogicalOperator> PullupSetOperation(unique_ptr<LogicalOperator> op);
-
-	unique_ptr<LogicalOperator> PullupBothSide(unique_ptr<LogicalOperator> op);
-
-	// Finish pull up at this operator
-	unique_ptr<LogicalOperator> FinishPullup(unique_ptr<LogicalOperator> op);
-
-	// special treatment for SetOperations and projections
-	void ProjectSetOperation(LogicalProjection &proj);
-
-}; // end FilterPullup
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/filter_pushdown.hpp b/src/duckdb/src/include/duckdb/optimizer/filter_pushdown.hpp
deleted file mode 100644
index 94706d210..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/filter_pushdown.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/filter_pushdown.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/optimizer/filter_combiner.hpp"
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-
-class FilterPushdown {
-public:
-	explicit FilterPushdown(Optimizer &optimizer, bool convert_mark_joins = true);
-
-	//! Perform filter pushdown
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-	//! Return a reference to the client context (from the optimizer)
-	ClientContext &GetContext();
-
-	void CheckMarkToSemi(LogicalOperator &op, unordered_set<idx_t> &table_bindings);
-
-	struct Filter {
-		unordered_set<idx_t> bindings;
-		unique_ptr<Expression> filter;
-
-		Filter() {
-		}
-		explicit Filter(unique_ptr<Expression> filter) : filter(std::move(filter)) {
-		}
-
-		void ExtractBindings();
-	};
-
-private:
-	Optimizer &optimizer;
-	FilterCombiner combiner;
-	bool convert_mark_joins;
-
-	vector<unique_ptr<Filter>> filters;
-	//! Push down a LogicalAggregate op
-	unique_ptr<LogicalOperator> PushdownAggregate(unique_ptr<LogicalOperator> op);
-	//! Push down a distinct operator
-	unique_ptr<LogicalOperator> PushdownDistinct(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalFilter op
-	unique_ptr<LogicalOperator> PushdownFilter(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalCrossProduct op
-	unique_ptr<LogicalOperator> PushdownCrossProduct(unique_ptr<LogicalOperator> op);
-	//! Push down a join operator
-	unique_ptr<LogicalOperator> PushdownJoin(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalProjection op
-	unique_ptr<LogicalOperator> PushdownProjection(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalProjection op
-	unique_ptr<LogicalOperator> PushdownUnnest(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalSetOperation op
-	unique_ptr<LogicalOperator> PushdownSetOperation(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalGet op
-	unique_ptr<LogicalOperator> PushdownGet(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalLimit op
-	unique_ptr<LogicalOperator> PushdownLimit(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalWindow op
-	unique_ptr<LogicalOperator> PushdownWindow(unique_ptr<LogicalOperator> op);
-	// Pushdown an inner join
-	unique_ptr<LogicalOperator> PushdownInnerJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                              unordered_set<idx_t> &right_bindings);
-	// Pushdown a left join
-	unique_ptr<LogicalOperator> PushdownLeftJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                             unordered_set<idx_t> &right_bindings);
-
-	unique_ptr<LogicalOperator> PushdownSemiAntiJoin(unique_ptr<LogicalOperator> op);
-	// Pushdown a mark join
-	unique_ptr<LogicalOperator> PushdownMarkJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                             unordered_set<idx_t> &right_bindings);
-	// Pushdown a single join
-	unique_ptr<LogicalOperator> PushdownSingleJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                               unordered_set<idx_t> &right_bindings);
-
-	// AddLogicalFilter used to add an extra LogicalFilter at this level,
-	// because in some cases, some expressions can not be pushed down.
-	unique_ptr<LogicalOperator> AddLogicalFilter(unique_ptr<LogicalOperator> op,
-	                                             vector<unique_ptr<Expression>> expressions);
-	//! Push any remaining filters into a LogicalFilter at this level
-	unique_ptr<LogicalOperator> PushFinalFilters(unique_ptr<LogicalOperator> op);
-	// Finish pushing down at this operator, creating a LogicalFilter to store any of the stored filters and recursively
-	// pushing down into its children (if any)
-	unique_ptr<LogicalOperator> FinishPushdown(unique_ptr<LogicalOperator> op);
-	//! Adds a filter to the set of filters. Returns FilterResult::UNSATISFIABLE if the subtree should be stripped, or
-	//! FilterResult::SUCCESS otherwise
-	FilterResult AddFilter(unique_ptr<Expression> expr);
-	//! Extract filter bindings to compare them with expressions in an operator and determine if the filter
-	//! can be pushed down
-	void ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindings);
-	//! Generate filters from the current set of filters stored in the FilterCombiner
-	void GenerateFilters();
-	//! if there are filters in this FilterPushdown node, push them into the combiner
-	void PushFilters();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/in_clause_rewriter.hpp b/src/duckdb/src/include/duckdb/optimizer/in_clause_rewriter.hpp
deleted file mode 100644
index 51af6e127..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/in_clause_rewriter.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/in_clause_rewriter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-class ClientContext;
-class Optimizer;
-
-class InClauseRewriter : public LogicalOperatorVisitor {
-public:
-	explicit InClauseRewriter(ClientContext &context, Optimizer &optimizer) : context(context), optimizer(optimizer) {
-	}
-
-	ClientContext &context;
-	Optimizer &optimizer;
-	optional_ptr<LogicalOperator> current_op;
-	unique_ptr<LogicalOperator> root;
-
-public:
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-
-	unique_ptr<Expression> VisitReplace(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_filter_pushdown_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/join_filter_pushdown_optimizer.hpp
deleted file mode 100644
index aef9ba055..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_filter_pushdown_optimizer.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_filter_pushdown_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-
-namespace duckdb {
-class Optimizer;
-struct JoinFilterPushdownColumn;
-struct PushdownFilterTarget;
-
-//! The JoinFilterPushdownOptimizer links comparison joins to data sources to enable dynamic execution-time filter
-//! pushdown
-class JoinFilterPushdownOptimizer : public LogicalOperatorVisitor {
-public:
-	explicit JoinFilterPushdownOptimizer(Optimizer &optimizer);
-
-public:
-	void VisitOperator(LogicalOperator &op) override;
-	static void GetPushdownFilterTargets(LogicalOperator &op, vector<JoinFilterPushdownColumn> columns,
-	                                     vector<PushdownFilterTarget> &targets);
-
-private:
-	void GenerateJoinFilters(LogicalComparisonJoin &join);
-
-private:
-	Optimizer &optimizer;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp
deleted file mode 100644
index 8aec1cd02..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/cardinality_estimator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/optimizer/join_order/query_graph.hpp"
-
-#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
-
-namespace duckdb {
-
-class FilterInfo;
-
-struct DenomInfo {
-	DenomInfo(JoinRelationSet &numerator_relations, double filter_strength, double denominator)
-	    : numerator_relations(numerator_relations), filter_strength(filter_strength), denominator(denominator) {
-	}
-
-	JoinRelationSet &numerator_relations;
-	double filter_strength;
-	double denominator;
-};
-
-struct RelationsToTDom {
-	//! column binding sets that are equivalent in a join plan.
-	//! if you have A.x = B.y and B.y = C.z, then one set is {A.x, B.y, C.z}.
-	column_binding_set_t equivalent_relations;
-	//!	the estimated total domains of the equivalent relations determined using HLL
-	idx_t tdom_hll;
-	//! the estimated total domains of each relation without using HLL
-	idx_t tdom_no_hll;
-	bool has_tdom_hll;
-	vector<optional_ptr<FilterInfo>> filters;
-	vector<string> column_names;
-
-	explicit RelationsToTDom(const column_binding_set_t &column_binding_set)
-	    : equivalent_relations(column_binding_set), tdom_hll(0), tdom_no_hll(NumericLimits<idx_t>::Maximum()),
-	      has_tdom_hll(false) {};
-};
-
-class FilterInfoWithTotalDomains {
-public:
-	FilterInfoWithTotalDomains(optional_ptr<FilterInfo> filter_info, RelationsToTDom &relation2tdom)
-	    : filter_info(filter_info), tdom_hll(relation2tdom.tdom_hll), tdom_no_hll(relation2tdom.tdom_no_hll),
-	      has_tdom_hll(relation2tdom.has_tdom_hll) {
-	}
-
-	optional_ptr<FilterInfo> filter_info;
-	//!	the estimated total domains of the equivalent relations determined using HLL
-	idx_t tdom_hll;
-	//! the estimated total domains of each relation without using HLL
-	idx_t tdom_no_hll;
-	bool has_tdom_hll;
-};
-
-struct Subgraph2Denominator {
-	optional_ptr<JoinRelationSet> relations;
-	optional_ptr<JoinRelationSet> numerator_relations;
-	double denom;
-
-	Subgraph2Denominator() : relations(nullptr), numerator_relations(nullptr), denom(1) {};
-};
-
-class CardinalityHelper {
-public:
-	CardinalityHelper() {
-	}
-	explicit CardinalityHelper(double cardinality_before_filters)
-	    : cardinality_before_filters(cardinality_before_filters) {};
-
-public:
-	// must be a double. Otherwise we can lose significance between different join orders.
-	// our cardinality estimator severely underestimates cardinalities for 3+ joins. However,
-	// if one join order has an estimate of 0.8, and another has an estimate of 0.6, rounding
-	// them means there is no estimated difference, when in reality there could be a very large
-	// difference.
-	double cardinality_before_filters;
-
-	vector<string> table_names_joined;
-	vector<string> column_names;
-};
-
-class CardinalityEstimator {
-public:
-	static constexpr double DEFAULT_SEMI_ANTI_SELECTIVITY = 5;
-	static constexpr double DEFAULT_LT_GT_MULTIPLIER = 2.5;
-	explicit CardinalityEstimator() {};
-
-private:
-	vector<RelationsToTDom> relations_to_tdoms;
-	unordered_map<string, CardinalityHelper> relation_set_2_cardinality;
-	JoinRelationSetManager set_manager;
-	vector<RelationStats> relation_stats;
-
-public:
-	void RemoveEmptyTotalDomains();
-	void UpdateTotalDomains(optional_ptr<JoinRelationSet> set, RelationStats &stats);
-	void InitEquivalentRelations(const vector<unique_ptr<FilterInfo>> &filter_infos);
-
-	void InitCardinalityEstimatorProps(optional_ptr<JoinRelationSet> set, RelationStats &stats);
-
-	//! cost model needs estimated cardinalities to the fraction since the formula captures
-	//! distinct count selectivities and multiplicities. Hence the template
-	template <class T>
-	T EstimateCardinalityWithSet(JoinRelationSet &new_set);
-
-	//! used for debugging.
-	void AddRelationNamesToTdoms(vector<RelationStats> &stats);
-	void PrintRelationToTdomInfo();
-
-private:
-	double GetNumerator(JoinRelationSet &set);
-	DenomInfo GetDenominator(JoinRelationSet &set);
-
-	bool SingleColumnFilter(FilterInfo &filter_info);
-	vector<idx_t> DetermineMatchingEquivalentSets(optional_ptr<FilterInfo> filter_info);
-	//! Given a filter, add the column bindings to the matching equivalent set at the index
-	//! given in matching equivalent sets.
-	//! If there are multiple equivalence sets, they are merged.
-	void AddToEquivalenceSets(optional_ptr<FilterInfo> filter_info, vector<idx_t> matching_equivalent_sets);
-
-	double CalculateUpdatedDenom(Subgraph2Denominator left, Subgraph2Denominator right,
-	                             FilterInfoWithTotalDomains &filter);
-	JoinRelationSet &UpdateNumeratorRelations(Subgraph2Denominator left, Subgraph2Denominator right,
-	                                          FilterInfoWithTotalDomains &filter);
-
-	void AddRelationTdom(FilterInfo &filter_info);
-	bool EmptyFilter(FilterInfo &filter_info);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp
deleted file mode 100644
index d6a9245b8..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/cost_model.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
-
-namespace duckdb {
-
-class QueryGraphManager;
-
-class CostModel {
-public:
-	explicit CostModel(QueryGraphManager &query_graph_manager);
-
-private:
-	//! query graph storing relation manager information
-	QueryGraphManager &query_graph_manager;
-
-public:
-	void InitCostModel();
-
-	//! Compute cost of a join relation set
-	double ComputeCost(DPJoinNode &left, DPJoinNode &right);
-
-	//! Cardinality Estimator used to calculate cost
-	CardinalityEstimator cardinality_estimator;
-
-private:
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp
deleted file mode 100644
index b68f9a0a4..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/join_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/optimizer/join_order/query_graph.hpp"
-
-namespace duckdb {
-
-struct NeighborInfo;
-
-class DPJoinNode {
-public:
-	//! Represents a node in the join plan
-	JoinRelationSet &set;
-	//! information on how left and right are connected
-	optional_ptr<NeighborInfo> info;
-	bool is_leaf;
-	//! left and right plans
-	JoinRelationSet &left_set;
-	JoinRelationSet &right_set;
-
-	//! The cost of the join node. The cost is stored here so that the cost of
-	//! a join node stays in sync with how the join node is constructed. Storing the cost in an unordered_set
-	//! in the cost model is error prone. If the plan enumerator join node is updated and not the cost model
-	//! the whole Join Order Optimizer can start exhibiting undesired behavior.
-	double cost;
-	//! used only to populate logical operators with estimated cardinalities after the best join plan has been found.
-	idx_t cardinality;
-
-	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
-	DPJoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinRelationSet &left, JoinRelationSet &right,
-	           double cost);
-
-	//! Create a leaf node in the join tree
-	//! set cost to 0 for leaf nodes
-	//! cost will be the cost to *produce* an intermediate table
-	explicit DPJoinNode(JoinRelationSet &set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp
deleted file mode 100644
index 921e03a21..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/join_order_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/optimizer/join_order/query_graph.hpp"
-#include "duckdb/optimizer/join_order/query_graph_manager.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-class JoinOrderOptimizer {
-public:
-	explicit JoinOrderOptimizer(ClientContext &context);
-	JoinOrderOptimizer CreateChildOptimizer();
-
-public:
-	//! Perform join reordering inside a plan
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan, optional_ptr<RelationStats> stats = nullptr);
-	//! Adds/gets materialized CTE stats
-	void AddMaterializedCTEStats(idx_t index, RelationStats &&stats);
-	RelationStats GetMaterializedCTEStats(idx_t index);
-	//! Adds/gets delim scan stats
-	void AddDelimScanStats(RelationStats &stats);
-	RelationStats GetDelimScanStats();
-
-private:
-	ClientContext &context;
-
-	//! manages the query graph, relations, and edges between relations
-	QueryGraphManager query_graph_manager;
-
-	//! The set of filters extracted from the query graph
-	vector<unique_ptr<Expression>> filters;
-	//! The set of filter infos created from the extracted filters
-	vector<unique_ptr<FilterInfo>> filter_infos;
-	//! A map of all expressions a given expression has to be equivalent to. This is used to add "implied join edges".
-	//! i.e. in the join A=B AND B=C, the equivalence set of {B} is {A, C}, thus we can add an implied join edge {A = C}
-	expression_map_t<vector<FilterInfo *>> equivalence_sets;
-
-	CardinalityEstimator cardinality_estimator;
-
-	unordered_set<std::string> join_nodes_in_full_plan;
-
-	//! Mapping from materialized CTE index to stats
-	unordered_map<idx_t, RelationStats> materialized_cte_stats;
-	//! Stats of Delim Scans of the Delim Join that is currently being optimized
-	optional_ptr<RelationStats> delim_scan_stats;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp
deleted file mode 100644
index 7b040c1b5..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/join_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-//! Set of relations, used in the join graph.
-struct JoinRelationSet {
-	JoinRelationSet(unsafe_unique_array<idx_t> relations, idx_t count) : relations(std::move(relations)), count(count) {
-	}
-
-	string ToString() const;
-
-	unsafe_unique_array<idx_t> relations;
-	idx_t count;
-
-	static bool IsSubset(JoinRelationSet &super, JoinRelationSet &sub);
-};
-
-//! The JoinRelationTree is a structure holding all the created JoinRelationSet objects and allowing fast lookup on to
-//! them
-class JoinRelationSetManager {
-public:
-	//! Contains a node with a JoinRelationSet and child relations
-	// FIXME: this structure is inefficient, could use a bitmap for lookup instead (todo: profile)
-	struct JoinRelationTreeNode {
-		unique_ptr<JoinRelationSet> relation;
-		unordered_map<idx_t, unique_ptr<JoinRelationTreeNode>> children;
-	};
-
-public:
-	//! Create or get a JoinRelationSet from a single node with the given index
-	JoinRelationSet &GetJoinRelation(idx_t index);
-	//! Create or get a JoinRelationSet from a set of relation bindings
-	JoinRelationSet &GetJoinRelation(const unordered_set<idx_t> &bindings);
-	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
-	JoinRelationSet &GetJoinRelation(unsafe_unique_array<idx_t> relations, idx_t count);
-	//! Union two sets of relations together and create a new relation set
-	JoinRelationSet &Union(JoinRelationSet &left, JoinRelationSet &right);
-	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)
-	// JoinRelationSet *Difference(JoinRelationSet *left, JoinRelationSet *right);
-	string ToString() const;
-	void Print();
-
-private:
-	JoinRelationTreeNode root;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/plan_enumerator.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/plan_enumerator.hpp
deleted file mode 100644
index 29e867953..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/plan_enumerator.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/plan_enumerator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
-#include "duckdb/optimizer/join_order/query_graph.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/cost_model.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-class QueryGraphManager;
-
-class PlanEnumerator {
-public:
-	explicit PlanEnumerator(QueryGraphManager &query_graph_manager, CostModel &cost_model,
-	                        const QueryGraphEdges &query_graph)
-	    : query_graph(query_graph), query_graph_manager(query_graph_manager), cost_model(cost_model) {
-	}
-
-	static constexpr idx_t THRESHOLD_TO_SWAP_TO_APPROXIMATE = 12;
-
-	//! Perform the join order solving
-	void SolveJoinOrder();
-	void InitLeafPlans();
-
-	const reference_map_t<JoinRelationSet, unique_ptr<DPJoinNode>> &GetPlans() const;
-
-private:
-	//! The set of edges used in the join optimizer
-	QueryGraphEdges const &query_graph;
-	//! The total amount of join pairs that have been considered
-	idx_t pairs = 0;
-	//! Grant access to the set manager and the relation manager
-	QueryGraphManager &query_graph_manager;
-	//! Cost model to evaluate cost of joins
-	CostModel &cost_model;
-	//! A map to store the optimal join plan found for a specific JoinRelationSet*
-	reference_map_t<JoinRelationSet, unique_ptr<DPJoinNode>> plans;
-
-	unordered_set<string> join_nodes_in_full_plan;
-
-	unique_ptr<DPJoinNode> CreateJoinTree(JoinRelationSet &set,
-	                                      const vector<reference<NeighborInfo>> &possible_connections, DPJoinNode &left,
-	                                      DPJoinNode &right);
-
-	//! Emit a pair as a potential join candidate. Returns the best plan found for the (left, right) connection (either
-	//! the newly created plan, or an existing plan)
-	DPJoinNode &EmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
-	//! Tries to emit a potential join candidate pair. Returns false if too many pairs have already been emitted,
-	//! cancelling the dynamic programming step.
-	bool TryEmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
-
-	bool EnumerateCmpRecursive(JoinRelationSet &left, JoinRelationSet &right, unordered_set<idx_t> &exclusion_set);
-	//! Emit a relation set node
-	bool EmitCSG(JoinRelationSet &node);
-	//! Enumerate the possible connected subgraphs that can be joined together in the join graph
-	bool EnumerateCSGRecursive(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set);
-	//! Generate cross product edges inside the side
-	void GenerateCrossProducts();
-
-	//! Solve the join order exactly using dynamic programming. Returns true if it was completed successfully (i.e. did
-	//! not time-out)
-	bool SolveJoinOrderExactly();
-	//! Solve the join order approximately using a greedy algorithm
-	void SolveJoinOrderApproximately();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp
deleted file mode 100644
index e5ac67138..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/query_graph.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/relation_manager.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/planner/column_binding.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-class FilterInfo;
-
-struct NeighborInfo {
-	explicit NeighborInfo(optional_ptr<JoinRelationSet> neighbor) : neighbor(neighbor) {
-	}
-
-	optional_ptr<JoinRelationSet> neighbor;
-	vector<optional_ptr<FilterInfo>> filters;
-};
-
-//! The QueryGraph contains edges between relations and allows edges to be created/queried
-class QueryGraphEdges {
-public:
-	//! Contains a node with info about neighboring relations and child edge infos
-	struct QueryEdge {
-		vector<unique_ptr<NeighborInfo>> neighbors;
-		unordered_map<idx_t, unique_ptr<QueryEdge>> children;
-	};
-
-public:
-	string ToString() const;
-	void Print();
-
-	//! Returns a connection if there is an edge that connects these two sets, or nullptr otherwise
-	const vector<reference<NeighborInfo>> GetConnections(JoinRelationSet &node, JoinRelationSet &other) const;
-	//! Enumerate the neighbors of a specific node that do not belong to any of the exclusion_set. Note that if a
-	//! neighbor has multiple nodes, this function will return the lowest entry in that set.
-	const vector<idx_t> GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) const;
-
-	//! Enumerate all neighbors of a given JoinRelationSet node
-	void EnumerateNeighbors(JoinRelationSet &node, const std::function<bool(NeighborInfo &)> &callback) const;
-	//! Create an edge in the edge_set
-	void CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> info);
-
-private:
-	//! Get the QueryEdge of a specific node
-	optional_ptr<QueryEdge> GetQueryEdge(JoinRelationSet &left);
-
-	void EnumerateNeighborsDFS(JoinRelationSet &node, reference<QueryEdge> info, idx_t index,
-	                           const std::function<bool(NeighborInfo &)> &callback) const;
-
-	QueryEdge root;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp
deleted file mode 100644
index e98868115..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/query_graph_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/optimizer/join_order/query_graph.hpp"
-#include "duckdb/optimizer/join_order/relation_manager.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-class QueryGraphEdges;
-
-struct GenerateJoinRelation {
-	GenerateJoinRelation(optional_ptr<JoinRelationSet> set, unique_ptr<LogicalOperator> op_p)
-	    : set(set), op(std::move(op_p)) {
-	}
-
-	optional_ptr<JoinRelationSet> set;
-	unique_ptr<LogicalOperator> op;
-};
-
-//! Filter info struct that is used by the cardinality estimator to set the initial cardinality
-//! but is also eventually transformed into a query edge.
-class FilterInfo {
-public:
-	FilterInfo(unique_ptr<Expression> filter, JoinRelationSet &set, idx_t filter_index,
-	           JoinType join_type = JoinType::INNER)
-	    : filter(std::move(filter)), set(set), filter_index(filter_index), join_type(join_type) {
-	}
-
-public:
-	unique_ptr<Expression> filter;
-	reference<JoinRelationSet> set;
-	idx_t filter_index;
-	JoinType join_type;
-	optional_ptr<JoinRelationSet> left_set;
-	optional_ptr<JoinRelationSet> right_set;
-	ColumnBinding left_binding;
-	ColumnBinding right_binding;
-
-	void SetLeftSet(optional_ptr<JoinRelationSet> left_set_new);
-	void SetRightSet(optional_ptr<JoinRelationSet> right_set_new);
-};
-
-//! The QueryGraphManager manages the process of extracting the reorderable and nonreorderable operations
-//! from the logical plan and creating the intermediate structures needed by the plan enumerator.
-//! When the plan enumerator finishes, the Query Graph Manger can then recreate the logical plan.
-class QueryGraphManager {
-public:
-	explicit QueryGraphManager(ClientContext &context) : relation_manager(context), context(context) {
-	}
-
-	//! manage relations and the logical operators they represent
-	RelationManager relation_manager;
-
-	//! A structure holding all the created JoinRelationSet objects
-	JoinRelationSetManager set_manager;
-
-	ClientContext &context;
-
-	//! Extract the join relations, optimizing non-reoderable relations when encountered
-	bool Build(JoinOrderOptimizer &optimizer, LogicalOperator &op);
-
-	//! Reconstruct the logical plan using the plan found by the plan enumerator
-	unique_ptr<LogicalOperator> Reconstruct(unique_ptr<LogicalOperator> plan);
-
-	//! Get a reference to the QueryGraphEdges structure that stores edges between
-	//! nodes and hypernodes.
-	const QueryGraphEdges &GetQueryGraphEdges() const;
-
-	//! Get a list of the join filters in the join plan than eventually are
-	//! transformed into the query graph edges
-	const vector<unique_ptr<FilterInfo>> &GetFilterBindings() const;
-
-	//! Plan enumerator may not find a full plan and therefore will need to create cross
-	//! products to create edges.
-	void CreateQueryGraphCrossProduct(JoinRelationSet &left, JoinRelationSet &right);
-
-	//! A map to store the optimal join plan found for a specific JoinRelationSet*
-	optional_ptr<const reference_map_t<JoinRelationSet, unique_ptr<DPJoinNode>>> plans;
-
-private:
-	vector<reference<LogicalOperator>> filter_operators;
-
-	//! Filter information including the column_bindings that join filters
-	//! used by the cardinality estimator to estimate distinct counts
-	vector<unique_ptr<FilterInfo>> filters_and_bindings;
-
-	QueryGraphEdges query_graph;
-
-	void GetColumnBinding(Expression &expression, ColumnBinding &binding);
-
-	void CreateHyperGraphEdges();
-
-	GenerateJoinRelation GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinRelationSet &set);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp
deleted file mode 100644
index 3b8fda1c6..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/relation_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-
-class JoinOrderOptimizer;
-class FilterInfo;
-
-//! Represents a single relation and any metadata accompanying that relation
-struct SingleJoinRelation {
-	LogicalOperator &op;
-	optional_ptr<LogicalOperator> parent;
-	RelationStats stats;
-
-	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent) : op(op), parent(parent) {
-	}
-	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, RelationStats stats)
-	    : op(op), parent(parent), stats(std::move(stats)) {
-	}
-};
-
-class RelationManager {
-public:
-	explicit RelationManager(ClientContext &context) : context(context) {
-	}
-
-	idx_t NumRelations();
-
-	bool ExtractJoinRelations(JoinOrderOptimizer &optimizer, LogicalOperator &input_op,
-	                          vector<reference<LogicalOperator>> &filter_operators,
-	                          optional_ptr<LogicalOperator> parent = nullptr);
-
-	//! for each join filter in the logical plan op, extract the relations that are referred to on
-	//! both sides of the join filter, along with the tables & indexes.
-	vector<unique_ptr<FilterInfo>> ExtractEdges(LogicalOperator &op,
-	                                            vector<reference<LogicalOperator>> &filter_operators,
-	                                            JoinRelationSetManager &set_manager);
-
-	//! Extract the set of relations referred to inside an expression
-	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
-	void AddRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, const RelationStats &stats);
-
-	void AddAggregateOrWindowRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent,
-	                                  const RelationStats &stats, LogicalOperatorType op_type);
-	vector<unique_ptr<SingleJoinRelation>> GetRelations();
-
-	const vector<RelationStats> GetRelationStats();
-	//! A mapping of base table index -> index into relations array (relation number)
-	unordered_map<idx_t, idx_t> relation_mapping;
-
-	bool CrossProductWithRelationAllowed(idx_t relation_id);
-
-	void PrintRelationStats();
-
-private:
-	ClientContext &context;
-	//! Set of all relations considered in the join optimizer
-	vector<unique_ptr<SingleJoinRelation>> relations;
-	unordered_set<idx_t> no_cross_product_relations;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp
deleted file mode 100644
index 8a4b7035f..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/statistics_extractor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class CardinalityEstimator;
-
-struct DistinctCount {
-	idx_t distinct_count;
-	bool from_hll;
-};
-
-struct ExpressionBinding {
-	bool found_expression = false;
-	ColumnBinding child_binding;
-	bool expression_is_constant = false;
-};
-
-struct RelationStats {
-	// column_id -> estimated distinct count for column
-	vector<DistinctCount> column_distinct_count;
-	idx_t cardinality;
-	double filter_strength = 1;
-	bool stats_initialized = false;
-
-	// for debug, column names and tables
-	vector<string> column_names;
-	string table_name;
-
-	RelationStats() : cardinality(1), filter_strength(1), stats_initialized(false) {
-	}
-};
-
-class RelationStatisticsHelper {
-public:
-	static constexpr double DEFAULT_SELECTIVITY = 0.2;
-
-public:
-	static idx_t InspectTableFilter(idx_t cardinality, idx_t column_index, TableFilter &filter,
-	                                BaseStatistics &base_stats);
-	//	static idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &filter,
-	//	                                  BaseStatistics &base_stats);
-	//! Extract Statistics from a LogicalGet.
-	static RelationStats ExtractGetStats(LogicalGet &get, ClientContext &context);
-	static RelationStats ExtractDelimGetStats(LogicalDelimGet &delim_get, ClientContext &context);
-	//! Create the statistics for a projection using the statistics of the operator that sits underneath the
-	//! projection. Then also create statistics for any extra columns the projection creates.
-	static RelationStats ExtractDummyScanStats(LogicalDummyScan &dummy_scan, ClientContext &context);
-	static RelationStats ExtractExpressionGetStats(LogicalExpressionGet &expression_get, ClientContext &context);
-	//! All relation extractors for blocking relations
-	static RelationStats ExtractProjectionStats(LogicalProjection &proj, RelationStats &child_stats);
-	static RelationStats ExtractAggregationStats(LogicalAggregate &aggr, RelationStats &child_stats);
-	static RelationStats ExtractWindowStats(LogicalWindow &window, RelationStats &child_stats);
-	static RelationStats ExtractEmptyResultStats(LogicalEmptyResult &empty);
-	//! Called after reordering a query plan with potentially 2+ relations.
-	static RelationStats CombineStatsOfReorderableOperator(vector<ColumnBinding> &bindings,
-	                                                       vector<RelationStats> relation_stats);
-	//! Called after reordering a query plan with potentially 2+ relations.
-	static RelationStats CombineStatsOfNonReorderableOperator(LogicalOperator &op, vector<RelationStats> child_stats);
-	static void CopyRelationStats(RelationStats &to, const RelationStats &from);
-
-private:
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/limit_pushdown.hpp b/src/duckdb/src/include/duckdb/optimizer/limit_pushdown.hpp
deleted file mode 100644
index ad31ae314..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/limit_pushdown.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/limit_pushdown.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class Optimizer;
-
-class LimitPushdown {
-public:
-	//! Optimize PROJECTION + LIMIT to LIMIT + Projection
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-	//! Whether we can perform the optimization on this operator
-	static bool CanOptimize(LogicalOperator &op);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/expression_matcher.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/expression_matcher.hpp
deleted file mode 100644
index 8df4fb94b..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/expression_matcher.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/expression_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/optimizer/matcher/expression_type_matcher.hpp"
-#include "duckdb/optimizer/matcher/set_matcher.hpp"
-#include "duckdb/optimizer/matcher/type_matcher.hpp"
-#include "duckdb/optimizer/matcher/function_matcher.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! The ExpressionMatcher class contains a set of matchers that can be used to pattern match Expressions
-class ExpressionMatcher {
-public:
-	explicit ExpressionMatcher(ExpressionClass type = ExpressionClass::INVALID) : expr_class(type) {
-	}
-	virtual ~ExpressionMatcher() {
-	}
-
-	//! Checks if the given expression matches this ExpressionMatcher. If it does, the expression is appended to the
-	//! bindings list and true is returned. Otherwise, false is returned.
-	virtual bool Match(Expression &expr, vector<reference<Expression>> &bindings);
-
-	//! The ExpressionClass of the to-be-matched expression. ExpressionClass::INVALID for ANY.
-	ExpressionClass expr_class;
-	//! Matcher for the ExpressionType of the operator (nullptr for ANY)
-	unique_ptr<ExpressionTypeMatcher> expr_type;
-	//! Matcher for the return_type of the expression (nullptr for ANY)
-	unique_ptr<TypeMatcher> type;
-};
-
-//! The ExpressionEqualityMatcher matches on equality with another (given) expression
-class ExpressionEqualityMatcher : public ExpressionMatcher {
-public:
-	explicit ExpressionEqualityMatcher(const Expression &expr)
-	    : ExpressionMatcher(ExpressionClass::INVALID), expression(expr) {
-	}
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-
-private:
-	const Expression &expression;
-};
-
-class ConstantExpressionMatcher : public ExpressionMatcher {
-public:
-	ConstantExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CONSTANT) {
-	}
-};
-
-class CaseExpressionMatcher : public ExpressionMatcher {
-public:
-	CaseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CASE) {
-	}
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-class ComparisonExpressionMatcher : public ExpressionMatcher {
-public:
-	ComparisonExpressionMatcher()
-	    : ExpressionMatcher(ExpressionClass::BOUND_COMPARISON), policy(SetMatcher::Policy::INVALID) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-class CastExpressionMatcher : public ExpressionMatcher {
-public:
-	CastExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CAST) {
-	}
-	//! The matcher for the child expressions
-	unique_ptr<ExpressionMatcher> matcher;
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-class InClauseExpressionMatcher : public ExpressionMatcher {
-public:
-	InClauseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_OPERATOR) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-class ConjunctionExpressionMatcher : public ExpressionMatcher {
-public:
-	ConjunctionExpressionMatcher()
-	    : ExpressionMatcher(ExpressionClass::BOUND_CONJUNCTION), policy(SetMatcher::Policy::INVALID) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-class FunctionExpressionMatcher : public ExpressionMatcher {
-public:
-	FunctionExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_FUNCTION) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-	//! The function name to match
-	unique_ptr<FunctionMatcher> function;
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-class AggregateExpressionMatcher : public ExpressionMatcher {
-public:
-	AggregateExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_AGGREGATE) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-	//! The function name to match
-	unique_ptr<FunctionMatcher> function;
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-//! The FoldableConstant matcher matches any expression that is foldable into a constant by the ExpressionExecutor (i.e.
-//! scalar but not aggregate/window/parameter)
-class FoldableConstantMatcher : public ExpressionMatcher {
-public:
-	FoldableConstantMatcher() : ExpressionMatcher(ExpressionClass::INVALID) {
-	}
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-//! The stable expression matcher matches only stable expressions (non-volatile)
-class StableExpressionMatcher : public ExpressionMatcher {
-public:
-	StableExpressionMatcher() : ExpressionMatcher(ExpressionClass::INVALID) {
-	}
-
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/expression_type_matcher.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/expression_type_matcher.hpp
deleted file mode 100644
index 2f884577e..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/expression_type_matcher.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/expression_type_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/vector.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-//! The ExpressionTypeMatcher class contains a set of matchers that can be used to pattern match ExpressionTypes
-class ExpressionTypeMatcher {
-public:
-	virtual ~ExpressionTypeMatcher() {
-	}
-
-	virtual bool Match(ExpressionType type) = 0;
-};
-
-//! The SpecificExpressionTypeMatcher class matches a single specified Expression type
-class SpecificExpressionTypeMatcher : public ExpressionTypeMatcher {
-public:
-	explicit SpecificExpressionTypeMatcher(ExpressionType type) : type(type) {
-	}
-
-	bool Match(ExpressionType type) override {
-		return type == this->type;
-	}
-
-private:
-	ExpressionType type;
-};
-
-//! The ManyExpressionTypeMatcher class matches a set of ExpressionTypes
-class ManyExpressionTypeMatcher : public ExpressionTypeMatcher {
-public:
-	explicit ManyExpressionTypeMatcher(vector<ExpressionType> types) : types(std::move(types)) {
-	}
-
-	bool Match(ExpressionType type) override {
-		return std::find(types.begin(), types.end(), type) != types.end();
-	}
-
-private:
-	vector<ExpressionType> types;
-};
-
-//! The ComparisonExpressionTypeMatcher class matches a comparison expression
-class ComparisonExpressionTypeMatcher : public ExpressionTypeMatcher {
-public:
-	bool Match(ExpressionType type) override {
-		return type == ExpressionType::COMPARE_EQUAL || type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-		       type == ExpressionType::COMPARE_LESSTHANOREQUALTO || type == ExpressionType::COMPARE_LESSTHAN ||
-		       type == ExpressionType::COMPARE_GREATERTHAN;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/function_matcher.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/function_matcher.hpp
deleted file mode 100644
index 162789c3e..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/function_matcher.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/function_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include <algorithm>
-
-namespace duckdb {
-
-//! The FunctionMatcher class contains a set of matchers that can be used to pattern match specific functions
-class FunctionMatcher {
-public:
-	virtual ~FunctionMatcher() {
-	}
-
-	virtual bool Match(const string &name) = 0;
-
-	static bool Match(unique_ptr<FunctionMatcher> &matcher, const string &name) {
-		if (!matcher) {
-			return true;
-		}
-		return matcher->Match(name);
-	}
-};
-
-//! The SpecificFunctionMatcher class matches a single specified function name
-class SpecificFunctionMatcher : public FunctionMatcher {
-public:
-	explicit SpecificFunctionMatcher(string name_p) : name(std::move(name_p)) {
-	}
-
-	bool Match(const string &matched_name) override {
-		return matched_name == this->name;
-	}
-
-private:
-	string name;
-};
-
-//! The ManyFunctionMatcher class matches a set of functions
-class ManyFunctionMatcher : public FunctionMatcher {
-public:
-	explicit ManyFunctionMatcher(unordered_set<string> names_p) : names(std::move(names_p)) {
-	}
-
-	bool Match(const string &name) override {
-		return names.find(name) != names.end();
-	}
-
-private:
-	unordered_set<string> names;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/logical_operator_matcher.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/logical_operator_matcher.hpp
deleted file mode 100644
index fe6b548f7..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/logical_operator_matcher.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/logical_operator_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/logical_operator_type.hpp"
-
-namespace duckdb {
-
-//! The LogicalOperatorMatcher class contains a set of matchers that can be used to match LogicalOperators
-class LogicalOperatorMatcher {
-public:
-	virtual ~LogicalOperatorMatcher() {
-	}
-
-	virtual bool Match(LogicalOperatorType type) = 0;
-};
-
-//! The SpecificLogicalTypeMatcher class matches only a single specified LogicalOperatorType
-class SpecificLogicalTypeMatcher : public LogicalOperatorMatcher {
-public:
-	explicit SpecificLogicalTypeMatcher(LogicalOperatorType type) : type(type) {
-	}
-
-	bool Match(LogicalOperatorType type) override {
-		return type == this->type;
-	}
-
-private:
-	LogicalOperatorType type;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/set_matcher.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/set_matcher.hpp
deleted file mode 100644
index 11a991d2f..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/set_matcher.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/set_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-class SetMatcher {
-public:
-	//! The policy used by the SetMatcher
-	enum class Policy {
-		//! All entries have to be matched, and the matches have to be ordered
-		ORDERED,
-		//! All entries have to be matched, but the order of the matches does not matter
-		UNORDERED,
-		//! Only some entries have to be matched, the order of the matches does not matter
-		SOME,
-		//! Only some entries have to be matched. The order of the matches does matter.
-		SOME_ORDERED,
-		//! Not initialized
-		INVALID
-	};
-
-	/* The double {{}} in the intializer for excluded_entries is intentional, workaround for bug in gcc-4.9 */
-	template <class T, class MATCHER>
-	static bool MatchRecursive(vector<unique_ptr<MATCHER>> &matchers, vector<reference<T>> &entries,
-	                           vector<reference<T>> &bindings, unordered_set<idx_t> excluded_entries, idx_t m_idx = 0) {
-		if (m_idx == matchers.size()) {
-			// matched all matchers!
-			return true;
-		}
-		// try to find a match for the current matcher (m_idx)
-		idx_t previous_binding_count = bindings.size();
-		for (idx_t e_idx = 0; e_idx < entries.size(); e_idx++) {
-			// first check if this entry has already been matched
-			if (excluded_entries.find(e_idx) != excluded_entries.end()) {
-				// it has been matched: skip this entry
-				continue;
-			}
-			// otherwise check if the current matcher matches this entry
-			if (matchers[m_idx]->Match(entries[e_idx], bindings)) {
-				// m_idx matches e_idx!
-				// check if we can find a complete match for this path
-				// first add e_idx to the new set of excluded entries
-				unordered_set<idx_t> new_excluded_entries;
-				new_excluded_entries = excluded_entries;
-				new_excluded_entries.insert(e_idx);
-				// then match the next matcher in the set
-				if (MatchRecursive(matchers, entries, bindings, new_excluded_entries, m_idx + 1)) {
-					// we found a match for this path! success
-					return true;
-				} else {
-					// we did not find a match! remove any bindings we added in the call to Match()
-					bindings.erase(bindings.begin() + NumericCast<int64_t>(previous_binding_count), bindings.end());
-				}
-			}
-		}
-		return false;
-	}
-
-	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<reference<T>> &entries,
-	                  vector<reference<T>> &bindings, Policy policy) {
-		if (policy == Policy::ORDERED) {
-			// ordered policy, count has to match
-			if (matchers.size() != entries.size()) {
-				return false;
-			}
-			// now entries have to match in order
-			for (idx_t i = 0; i < matchers.size(); i++) {
-				if (!matchers[i]->Match(entries[i], bindings)) {
-					return false;
-				}
-			}
-			return true;
-		} else if (policy == Policy::SOME_ORDERED) {
-			if (entries.size() < matchers.size()) {
-				return false;
-			}
-			// now provided entries have to match in order
-			for (idx_t i = 0; i < matchers.size(); i++) {
-				if (!matchers[i]->Match(entries[i], bindings)) {
-					return false;
-				}
-			}
-			return true;
-		} else {
-			if (policy == Policy::UNORDERED && matchers.size() != entries.size()) {
-				// unordered policy, count does not match: no match
-				return false;
-			} else if (policy == Policy::SOME && matchers.size() > entries.size()) {
-				// some policy, every matcher has to match a unique entry
-				// this is not possible if there are more matchers than entries
-				return false;
-			}
-			// now perform the actual matching
-			// every matcher has to match a UNIQUE entry
-			// we perform this matching in a recursive way
-			unordered_set<idx_t> excluded_entries;
-			if (!MatchRecursive(matchers, entries, bindings, excluded_entries)) {
-				return false;
-			}
-			return true;
-		}
-	}
-
-	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<unique_ptr<T>> &entries,
-	                  vector<reference<T>> &bindings, Policy policy) {
-		// convert vector of unique_ptr to vector of normal pointers
-		vector<reference<T>> ptr_entries;
-		for (auto &entry : entries) {
-			ptr_entries.push_back(*entry);
-		}
-		// then just call the normal match function
-		return Match(matchers, ptr_entries, bindings, policy);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/type_matcher.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/type_matcher.hpp
deleted file mode 100644
index 892f35f30..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/type_matcher.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/type_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-//! The TypeMatcher class contains a set of matchers that can be used to pattern match TypeIds for Rules
-class TypeMatcher {
-public:
-	virtual ~TypeMatcher() {
-	}
-
-	virtual bool Match(const LogicalType &type) = 0;
-};
-
-//! The SpecificTypeMatcher class matches only a single specified type
-class SpecificTypeMatcher : public TypeMatcher {
-public:
-	explicit SpecificTypeMatcher(LogicalType type) : type(std::move(type)) {
-	}
-
-	bool Match(const LogicalType &type_p) override {
-		return type_p == this->type;
-	}
-
-private:
-	LogicalType type;
-};
-//! The SpecificTypeMatcher class matches only a type out of a set of types
-class SetTypesMatcher : public TypeMatcher {
-public:
-	explicit SetTypesMatcher(vector<LogicalType> types_p) : types(std::move(types_p)) {
-	}
-
-	bool Match(const LogicalType &type_p) override {
-		for (auto &type : types) {
-			if (type == type_p) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-private:
-	vector<LogicalType> types;
-};
-
-//! The NumericTypeMatcher class matches any numeric type (DECIMAL, INTEGER, etc...)
-class NumericTypeMatcher : public TypeMatcher {
-public:
-	bool Match(const LogicalType &type) override {
-		return type.IsNumeric();
-	}
-};
-
-//! The IntegerTypeMatcher class matches only integer types (INTEGER, SMALLINT, TINYINT, BIGINT)
-class IntegerTypeMatcher : public TypeMatcher {
-public:
-	bool Match(const LogicalType &type) override {
-		return type.IsIntegral();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/matcher/type_matcher_id.hpp b/src/duckdb/src/include/duckdb/optimizer/matcher/type_matcher_id.hpp
deleted file mode 100644
index 9bd83f138..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/matcher/type_matcher_id.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/type_matcher_id.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/optimizer/matcher/type_matcher.hpp"
-namespace duckdb {
-
-//! The TypeMatcherId class contains a set of matchers that can be used to pattern match TypeIds for Rules
-class TypeMatcherId : public TypeMatcher {
-public:
-	explicit TypeMatcherId(LogicalTypeId type_id_p) : type_id(type_id_p) {
-	}
-
-	bool Match(const LogicalType &type) override {
-		return type.id() == this->type_id;
-	}
-
-private:
-	LogicalTypeId type_id;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/optimizer.hpp
deleted file mode 100644
index 5b0dea218..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/optimizer.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/common/enums/optimizer_type.hpp"
-
-#include <functional>
-
-namespace duckdb {
-class Binder;
-
-class Optimizer {
-public:
-	Optimizer(Binder &binder, ClientContext &context);
-
-	//! Optimize a plan by running specialized optimizers
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
-	//! Return a reference to the client context of this optimizer
-	ClientContext &GetContext();
-	//! Whether the specific optimizer is disabled
-	bool OptimizerDisabled(OptimizerType type);
-	static bool OptimizerDisabled(ClientContext &context, OptimizerType type);
-
-public:
-	ClientContext &context;
-	Binder &binder;
-	ExpressionRewriter rewriter;
-
-private:
-	void RunBuiltInOptimizers();
-	void RunOptimizer(OptimizerType type, const std::function<void()> &callback);
-	void Verify(LogicalOperator &op);
-
-public:
-	// helper functions
-	unique_ptr<Expression> BindScalarFunction(const string &name, unique_ptr<Expression> c1);
-	unique_ptr<Expression> BindScalarFunction(const string &name, unique_ptr<Expression> c1, unique_ptr<Expression> c2);
-
-private:
-	unique_ptr<LogicalOperator> plan;
-
-private:
-	unique_ptr<Expression> BindScalarFunction(const string &name, vector<unique_ptr<Expression>> children);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp b/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp
deleted file mode 100644
index 6ccc6277c..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/optimizer_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-class ClientContext;
-
-//! The OptimizerExtensionInfo holds static information relevant to the optimizer extension
-struct OptimizerExtensionInfo {
-	virtual ~OptimizerExtensionInfo() {
-	}
-};
-
-struct OptimizerExtensionInput {
-	ClientContext &context;
-	Optimizer &optimizer;
-	optional_ptr<OptimizerExtensionInfo> info;
-};
-
-typedef void (*optimize_function_t)(OptimizerExtensionInput &input, unique_ptr<LogicalOperator> &plan);
-
-class OptimizerExtension {
-public:
-	//! The parse function of the parser extension.
-	//! Takes a query string as input and returns ParserExtensionParseData (on success) or an error
-	optimize_function_t optimize_function;
-
-	//! Additional parser info passed to the parse function
-	shared_ptr<OptimizerExtensionInfo> optimizer_info;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/regex_range_filter.hpp b/src/duckdb/src/include/duckdb/optimizer/regex_range_filter.hpp
deleted file mode 100644
index 36714f263..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/regex_range_filter.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/regex_range_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-
-class RegexRangeFilter {
-public:
-	RegexRangeFilter() {
-	}
-	//! Perform filter pushdown
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/remove_duplicate_groups.hpp b/src/duckdb/src/include/duckdb/optimizer/remove_duplicate_groups.hpp
deleted file mode 100644
index 2abf8bb3e..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/remove_duplicate_groups.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/remove_duplicate_groups.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-
-class BoundColumnRefExpression;
-
-//! The RemoveDuplicateGroups optimizer traverses the logical operator tree and removes any duplicate aggregate groups
-//! Duplicate groups may be introduced when joins columns are removed, e.g., by Deliminator or RemoveUnusedColumns
-class RemoveDuplicateGroups : public LogicalOperatorVisitor {
-public:
-	RemoveDuplicateGroups() {
-	}
-
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	void VisitAggregate(LogicalAggregate &aggr);
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	//! The map of column references
-	column_binding_map_t<vector<reference<BoundColumnRefExpression>>> column_references;
-	//! Stored expressions (kept around so we don't have dangling pointers)
-	vector<unique_ptr<Expression>> stored_expressions;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp b/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp
deleted file mode 100644
index a05a1d722..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/remove_unused_columns.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/column_index.hpp"
-
-namespace duckdb {
-class Binder;
-class BoundColumnRefExpression;
-class ClientContext;
-
-struct ReferencedColumn {
-	vector<reference<BoundColumnRefExpression>> bindings;
-	vector<ColumnIndex> child_columns;
-};
-
-//! The RemoveUnusedColumns optimizer traverses the logical operator tree and removes any columns that are not required
-class RemoveUnusedColumns : public LogicalOperatorVisitor {
-public:
-	RemoveUnusedColumns(Binder &binder, ClientContext &context, bool is_root = false)
-	    : binder(binder), context(context), everything_referenced(is_root) {
-	}
-
-	void VisitOperator(LogicalOperator &op) override;
-	void VisitExpression(unique_ptr<Expression> *expression) override;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundReferenceExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	Binder &binder;
-	ClientContext &context;
-	//! Whether or not all the columns are referenced. This happens in the case of the root expression (because the
-	//! output implicitly refers all the columns below it)
-	bool everything_referenced;
-	//! The map of column references
-	column_binding_map_t<ReferencedColumn> column_references;
-
-private:
-	template <class T>
-	void ClearUnusedExpressions(vector<T> &list, idx_t table_idx, bool replace = true);
-
-	//! Add a reference to the column in its entirey
-	void AddBinding(BoundColumnRefExpression &col);
-	//! Add a reference to a sub-section of the column
-	void AddBinding(BoundColumnRefExpression &col, ColumnIndex child_column);
-	//! Perform a replacement of the ColumnBinding, iterating over all the currently found column references and
-	//! replacing the bindings
-	void ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding);
-
-	bool HandleStructExtract(Expression &expr);
-
-	bool HandleStructExtractRecursive(Expression &expr, optional_ptr<BoundColumnRefExpression> &colref,
-	                                  vector<idx_t> &indexes);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule.hpp b/src/duckdb/src/include/duckdb/optimizer/rule.hpp
deleted file mode 100644
index 30061a294..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/optimizer/matcher/logical_operator_matcher.hpp"
-
-namespace duckdb {
-class ExpressionRewriter;
-
-class Rule {
-public:
-	explicit Rule(ExpressionRewriter &rewriter) : rewriter(rewriter) {
-	}
-	virtual ~Rule() {
-	}
-
-	//! The expression rewriter this rule belongs to
-	ExpressionRewriter &rewriter;
-	//! The expression matcher of the rule
-	unique_ptr<ExpressionMatcher> root;
-
-	ClientContext &GetContext() const;
-	virtual unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-	                                     bool &fixed_point, bool is_root) = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/arithmetic_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/arithmetic_simplification.hpp
deleted file mode 100644
index cea57a9fc..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/arithmetic_simplification.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/arithmetic_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The Arithmetic Simplification rule applies arithmetic expressions to which the answer is known (e.g. X + 0 => X, X *
-// 0 => 0)
-class ArithmeticSimplificationRule : public Rule {
-public:
-	explicit ArithmeticSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/case_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/case_simplification.hpp
deleted file mode 100644
index 5c99d3e06..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/case_simplification.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/case_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The Case Simplification rule rewrites cases with a constant check (i.e. [CASE WHEN 1=1 THEN x ELSE y END] => x)
-class CaseSimplificationRule : public Rule {
-public:
-	explicit CaseSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/comparison_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/comparison_simplification.hpp
deleted file mode 100644
index b1e477d83..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/comparison_simplification.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/comparison_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The Comparison Simplification rule rewrites comparisons with a constant NULL (i.e. [x = NULL] => [NULL])
-class ComparisonSimplificationRule : public Rule {
-public:
-	explicit ComparisonSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/conjunction_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/conjunction_simplification.hpp
deleted file mode 100644
index 7f22821e6..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/conjunction_simplification.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/conjunction_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The Conjunction Simplification rule rewrites conjunctions with a constant
-class ConjunctionSimplificationRule : public Rule {
-public:
-	explicit ConjunctionSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> RemoveExpression(BoundConjunctionExpression &conj, const Expression &expr);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/constant_folding.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/constant_folding.hpp
deleted file mode 100644
index aba6ce9c7..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/constant_folding.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/constant_folding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// Fold any constant scalar expressions into a single constant (i.e. [2 + 2] => [4], [2 = 2] => [True], etc...)
-class ConstantFoldingRule : public Rule {
-public:
-	explicit ConstantFoldingRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/date_part_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/date_part_simplification.hpp
deleted file mode 100644
index e328acd25..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/date_part_simplification.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/date_part_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The DatePart Simplification rule rewrites date_part with a constant specifier into a specialized function (e.g.
-// date_part('year', x) => year(x))
-class DatePartSimplificationRule : public Rule {
-public:
-	explicit DatePartSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp
deleted file mode 100644
index 65123b96b..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/parser/expression_map.hpp"
-
-namespace duckdb {
-
-class DistinctAggregateOptimizer : public Rule {
-public:
-	explicit DistinctAggregateOptimizer(ExpressionRewriter &rewriter);
-
-	static unique_ptr<Expression> Apply(ClientContext &context, BoundAggregateExpression &aggr, bool &changes_made);
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-class DistinctWindowedOptimizer : public Rule {
-public:
-	explicit DistinctWindowedOptimizer(ExpressionRewriter &rewriter);
-
-	static unique_ptr<Expression> Apply(ClientContext &context, BoundWindowExpression &wexpr, bool &changes_made);
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/distributivity.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/distributivity.hpp
deleted file mode 100644
index b0c29b7c1..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/distributivity.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/distributivity.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/parser/expression_map.hpp"
-
-namespace duckdb {
-
-// (X AND B) OR (X AND C) OR (X AND D) = X AND (B OR C OR D)
-class DistributivityRule : public Rule {
-public:
-	explicit DistributivityRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-private:
-	void AddExpressionSet(Expression &expr, expression_set_t &set);
-	unique_ptr<Expression> ExtractExpression(BoundConjunctionExpression &conj, idx_t idx, Expression &expr);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/empty_needle_removal.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/empty_needle_removal.hpp
deleted file mode 100644
index 3ce21e774..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/empty_needle_removal.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/empty_needle_removal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The Empty_needle_removal Optimization rule folds some foldable ConstantExpression
-//(e.g.: PREFIX('xyz', '') is TRUE, PREFIX(NULL, '') is NULL, so rewrite PREFIX(x, '') to TRUE_OR_NULL(x)
-class EmptyNeedleRemovalRule : public Rule {
-public:
-	explicit EmptyNeedleRemovalRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/enum_comparison.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/enum_comparison.hpp
deleted file mode 100644
index 10d893301..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/enum_comparison.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/enum_comparison.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The Enum Comparison rule rewrites cases where two Enums are compared on an equality check
-class EnumComparisonRule : public Rule {
-public:
-	explicit EnumComparisonRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/equal_or_null_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/equal_or_null_simplification.hpp
deleted file mode 100644
index f80c1dfe0..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/equal_or_null_simplification.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/equal_or_null_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// Rewrite
-// a=b OR (a IS NULL AND b IS NULL) to a IS NOT DISTINCT FROM b
-class EqualOrNullSimplification : public Rule {
-public:
-	explicit EqualOrNullSimplification(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/in_clause_simplification.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/in_clause_simplification.hpp
deleted file mode 100644
index 0afabeae8..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/in_clause_simplification.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/in_clause_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The in clause simplification rule rewrites cases where left is a column ref with a cast and right are constant values
-class InClauseSimplificationRule : public Rule {
-public:
-	explicit InClauseSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/join_dependent_filter.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/join_dependent_filter.hpp
deleted file mode 100644
index 4cb48b21b..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/join_dependent_filter.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/join_filter_derivation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-//! Join-dependent filter derivation as proposed in https://homepages.cwi.nl/~boncz/snb-challenge/chokepoints-tpctc.pdf
-//! This rule inspects filters like this:
-//!     SELECT *
-//!     FROM nation n1
-//!     JOIN nation n2
-//!     ON ((n1.n_name = 'FRANCE'
-//!            AND n2.n_name = 'GERMANY')
-//!        OR (n1.n_name = 'GERMANY'
-//!            AND n2.n_name = 'FRANCE'));
-//! The join filter as a whole cannot be pushed down, because it references tables from both sides.
-//! However, we can derive from this two filters that can be pushed down, namely:
-//!     WHERE (n1.n_name = 'FRANCE' OR n1.n_name = 'GERMANY')
-//!      AND (n2.n_name = 'GERMANY' OR n2.n_name = 'FRANCE')
-//! By adding this filter, we can reduce both sides of the join before performing the join on the original condition.
-class JoinDependentFilterRule : public Rule {
-public:
-	explicit JoinDependentFilterRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/like_optimizations.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/like_optimizations.hpp
deleted file mode 100644
index c2bcf6a72..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/like_optimizations.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/like_optimizations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-
-namespace duckdb {
-
-// The Like Optimization rule rewrites LIKE to optimized scalar functions (e.g.: prefix, suffix, and contains)
-class LikeOptimizationRule : public Rule {
-public:
-	explicit LikeOptimizationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression &expr, ScalarFunction function, string pattern,
-	                                 bool is_not_like);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/list.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/list.hpp
deleted file mode 100644
index 361de546d..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/list.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/optimizer/rule/arithmetic_simplification.hpp"
-#include "duckdb/optimizer/rule/case_simplification.hpp"
-#include "duckdb/optimizer/rule/comparison_simplification.hpp"
-#include "duckdb/optimizer/rule/conjunction_simplification.hpp"
-#include "duckdb/optimizer/rule/constant_folding.hpp"
-#include "duckdb/optimizer/rule/date_part_simplification.hpp"
-#include "duckdb/optimizer/rule/distributivity.hpp"
-#include "duckdb/optimizer/rule/empty_needle_removal.hpp"
-#include "duckdb/optimizer/rule/like_optimizations.hpp"
-#include "duckdb/optimizer/rule/move_constants.hpp"
-#include "duckdb/optimizer/rule/enum_comparison.hpp"
-#include "duckdb/optimizer/rule/regex_optimizations.hpp"
-#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"
-#include "duckdb/optimizer/rule/timestamp_comparison.hpp"
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/move_constants.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/move_constants.hpp
deleted file mode 100644
index 343fe590d..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/move_constants.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/move_constants.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-
-namespace duckdb {
-
-// The MoveConstantsRule moves constants to the same side of an expression, e.g. if we have an expression x + 1 = 5000
-// then this will turn it into x = 4999.
-class MoveConstantsRule : public Rule {
-public:
-	explicit MoveConstantsRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp
deleted file mode 100644
index 1b757e78c..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/parser/expression_map.hpp"
-
-namespace duckdb {
-
-class OrderedAggregateOptimizer : public Rule {
-public:
-	explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter);
-
-	static unique_ptr<Expression> Apply(ClientContext &context, BoundAggregateExpression &aggr,
-	                                    vector<unique_ptr<Expression>> &groups, bool &changes_made);
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/regex_optimizations.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/regex_optimizations.hpp
deleted file mode 100644
index 1f914ec1c..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/regex_optimizations.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/like_optimizations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-
-namespace duckdb {
-
-class RegexOptimizationRule : public Rule {
-public:
-	explicit RegexOptimizationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,
-	                                 bool is_not_like);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/rule/timestamp_comparison.hpp b/src/duckdb/src/include/duckdb/optimizer/rule/timestamp_comparison.hpp
deleted file mode 100644
index a38ed64a8..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/rule/timestamp_comparison.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/timestamp_comparison.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/optimizer/rule.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-
-namespace duckdb {
-
-class TimeStampComparison : public Rule {
-public:
-	explicit TimeStampComparison(ClientContext &context, ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,
-	                                 bool is_not_like);
-
-private:
-	ClientContext &context;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/sampling_pushdown.hpp b/src/duckdb/src/include/duckdb/optimizer/sampling_pushdown.hpp
deleted file mode 100644
index 78c67a199..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/sampling_pushdown.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/sampling_pushdown.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-namespace duckdb {
-class LocigalOperator;
-class Optimizer;
-
-class SamplingPushdown {
-public:
-	//! Optimize SYSTEM SAMPLING + SCAN to SAMPLE SCAN
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp b/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp
deleted file mode 100644
index be98b7789..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/statistics_propagator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/planner/bound_tokens.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_tokens.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/node_statistics.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-class ClientContext;
-class LogicalOperator;
-class TableFilter;
-struct BoundOrderByNode;
-
-class StatisticsPropagator {
-public:
-	StatisticsPropagator(Optimizer &optimizer, LogicalOperator &root);
-
-	unique_ptr<NodeStatistics> PropagateStatistics(unique_ptr<LogicalOperator> &node_ptr);
-
-	column_binding_map_t<unique_ptr<BaseStatistics>> GetStatisticsMap() {
-		return std::move(statistics_map);
-	}
-
-private:
-	//! Propagate statistics through an operator
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOperator &node, unique_ptr<LogicalOperator> &node_ptr);
-
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalFilter &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalGet &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalJoin &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalPositionalJoin &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalProjection &op, unique_ptr<LogicalOperator> &node_ptr);
-	void PropagateStatistics(LogicalComparisonJoin &op, unique_ptr<LogicalOperator> &node_ptr);
-	void PropagateStatistics(LogicalAnyJoin &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalSetOperation &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalAggregate &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalCrossProduct &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalLimit &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOrder &op, unique_ptr<LogicalOperator> &node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalWindow &op, unique_ptr<LogicalOperator> &node_ptr);
-
-	unique_ptr<NodeStatistics> PropagateChildren(LogicalOperator &node, unique_ptr<LogicalOperator> &node_ptr);
-
-	//! Return statistics from a constant value
-	unique_ptr<BaseStatistics> StatisticsFromValue(const Value &input);
-	//! Run a comparison with two sets of statistics, returns if the comparison will always returns true/false or not
-	FilterPropagateResult PropagateComparison(BaseStatistics &left, BaseStatistics &right, ExpressionType comparison);
-
-	//! Update filter statistics from a filter with a constant
-	void UpdateFilterStatistics(BaseStatistics &input, ExpressionType comparison_type, const Value &constant);
-	//! Update statistics from a filter between two stats
-	void UpdateFilterStatistics(BaseStatistics &lstats, BaseStatistics &rstats, ExpressionType comparison_type);
-	//! Update filter statistics from a generic comparison
-	void UpdateFilterStatistics(Expression &left, Expression &right, ExpressionType comparison_type);
-	//! Update filter statistics from an expression
-	void UpdateFilterStatistics(Expression &condition);
-	//! Set the statistics of a specific column binding to not contain null values
-	void SetStatisticsNotNull(ColumnBinding binding);
-
-	//! Run a comparison between the statistics and the table filter; returns the prune result
-	FilterPropagateResult PropagateTableFilter(BaseStatistics &stats, TableFilter &filter);
-	//! Update filter statistics from a TableFilter
-	void UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter);
-
-	//! Add cardinalities together (i.e. new max is stats.max + new_stats.max): used for union
-	void AddCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats);
-	//! Multiply the cardinalities together (i.e. new max cardinality is stats.max * new_stats.max): used for
-	//! joins/cross products
-	void MultiplyCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats);
-	//! Creates and pushes down a filter based on join statistics
-	void CreateFilterFromJoinStats(unique_ptr<LogicalOperator> &child, unique_ptr<Expression> &expr,
-	                               const BaseStatistics &stats_before, const BaseStatistics &stats_after);
-
-	unique_ptr<BaseStatistics> PropagateExpression(unique_ptr<Expression> &expr);
-	unique_ptr<BaseStatistics> PropagateExpression(Expression &expr, unique_ptr<Expression> &expr_ptr);
-	//! Run a comparison between the statistics and the table filter; returns the prune result
-	unique_ptr<BaseStatistics> PropagateExpression(BoundAggregateExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundBetweenExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundCaseExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundCastExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundConjunctionExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundFunctionExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundComparisonExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundConstantExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundColumnRefExpression &expr, unique_ptr<Expression> &expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundOperatorExpression &expr, unique_ptr<Expression> &expr_ptr);
-
-	//! Try to execute aggregates using only the statistics if possible
-	void TryExecuteAggregates(LogicalAggregate &op, unique_ptr<LogicalOperator> &node_ptr);
-	void ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node);
-
-	bool ExpressionIsConstant(Expression &expr, const Value &val);
-	bool ExpressionIsConstantOrNull(Expression &expr, const Value &val);
-
-private:
-	Optimizer &optimizer;
-	ClientContext &context;
-	//! The root of the query plan
-	optional_ptr<LogicalOperator> root;
-	//! The map of ColumnBinding -> statistics for the various nodes
-	column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map;
-	//! Node stats for the current node
-	unique_ptr<NodeStatistics> node_stats;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/sum_rewriter.hpp b/src/duckdb/src/include/duckdb/optimizer/sum_rewriter.hpp
deleted file mode 100644
index 18cff911c..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/sum_rewriter.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/sum_rewriter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-class ExpressionMatcher;
-class Optimizer;
-
-//! Rewrites SUM(x + C) into SUM(x) + C * COUNT(x)
-class SumRewriterOptimizer : public LogicalOperatorVisitor {
-public:
-	explicit SumRewriterOptimizer(Optimizer &optimizer);
-	~SumRewriterOptimizer() override;
-
-	void Optimize(unique_ptr<LogicalOperator> &op);
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	void StandardVisitOperator(LogicalOperator &op);
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	void RewriteSums(unique_ptr<LogicalOperator> &aggr);
-
-private:
-	Optimizer &optimizer;
-	column_binding_map_t<ColumnBinding> aggregate_map;
-	unique_ptr<ExpressionMatcher> sum_matcher;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/topn_optimizer.hpp b/src/duckdb/src/include/duckdb/optimizer/topn_optimizer.hpp
deleted file mode 100644
index aab077005..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/topn_optimizer.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/topn_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-class LogicalOperator;
-class LogicalTopN;
-class Optimizer;
-
-class TopN {
-public:
-	//! Optimize ORDER BY + LIMIT to TopN
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-	//! Whether we can perform the optimization on this operator
-	static bool CanOptimize(LogicalOperator &op);
-
-private:
-	void PushdownDynamicFilters(LogicalTopN &op);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/optimizer/unnest_rewriter.hpp b/src/duckdb/src/include/duckdb/optimizer/unnest_rewriter.hpp
deleted file mode 100644
index 842d5ef2c..000000000
--- a/src/duckdb/src/include/duckdb/optimizer/unnest_rewriter.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/unnest_rewriter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class Optimizer;
-
-struct ReplaceBinding {
-	ReplaceBinding() {};
-	ReplaceBinding(ColumnBinding old_binding, ColumnBinding new_binding)
-	    : old_binding(old_binding), new_binding(new_binding) {
-	}
-	ColumnBinding old_binding;
-	ColumnBinding new_binding;
-};
-
-struct LHSBinding {
-	LHSBinding() {};
-	LHSBinding(ColumnBinding binding, LogicalType type_p) : binding(binding), type(std::move(type_p)) {
-	}
-	ColumnBinding binding;
-	LogicalType type;
-	string alias;
-};
-
-//! The UnnestRewriterPlanUpdater updates column bindings after changing the operator plan
-class UnnestRewriterPlanUpdater : LogicalOperatorVisitor {
-public:
-	UnnestRewriterPlanUpdater() {
-	}
-	//! Update each operator of the plan after moving an UNNEST into a projection
-	void VisitOperator(LogicalOperator &op) override;
-	//! Visit an expression and update its column bindings after moving and UNNEST into a projection
-	void VisitExpression(unique_ptr<Expression> *expression) override;
-
-	//! Contains all bindings that need to be updated
-	vector<ReplaceBinding> replace_bindings;
-	//! Stores the table index of the former child of the LOGICAL_UNNEST
-	idx_t overwritten_tbl_idx;
-};
-
-//! The UnnestRewriter optimizer traverses the logical operator tree and rewrites duplicate
-//! eliminated joins that contain UNNESTs by moving the UNNESTs into the projection of
-//! the SELECT
-class UnnestRewriter {
-public:
-	UnnestRewriter() {
-	}
-	//! Rewrite duplicate eliminated joins with UNNESTs
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-
-private:
-	//! Find delim joins that contain an UNNEST
-	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<reference<unique_ptr<LogicalOperator>>> &candidates);
-	//! Rewrite a delim join that contains an UNNEST
-	bool RewriteCandidate(unique_ptr<LogicalOperator> &candidate);
-	//! Update the bindings of the RHS sequence of LOGICAL_PROJECTION(s)
-	void UpdateRHSBindings(unique_ptr<LogicalOperator> &plan, unique_ptr<LogicalOperator> &candidate,
-	                       UnnestRewriterPlanUpdater &updater);
-	//! Update the bindings of the BOUND_UNNEST expression of the LOGICAL_UNNEST
-	void UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater, unique_ptr<LogicalOperator> &candidate);
-
-	//! Store all delim columns of the delim join
-	void GetDelimColumns(LogicalOperator &op);
-	//! Store all LHS expressions of the LOGICAL_PROJECTION
-	void GetLHSExpressions(LogicalOperator &op);
-
-	//! Keep track of the delim columns to find the correct UNNEST column
-	vector<ColumnBinding> delim_columns;
-	//! Store the column bindings of the LHS child of the LOGICAL_DELIM_JOIN
-	vector<LHSBinding> lhs_bindings;
-	//! Stores the table index of the former child of the LOGICAL_UNNEST
-	idx_t overwritten_tbl_idx;
-	//! The number of distinct columns to unnest
-	idx_t distinct_unnest_count;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/base_pipeline_event.hpp b/src/duckdb/src/include/duckdb/parallel/base_pipeline_event.hpp
deleted file mode 100644
index a4d909eb9..000000000
--- a/src/duckdb/src/include/duckdb/parallel/base_pipeline_event.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/base_pipeline_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-
-namespace duckdb {
-
-//! A BasePipelineEvent is used as the basis of any event that belongs to a specific pipeline
-class BasePipelineEvent : public Event {
-public:
-	explicit BasePipelineEvent(shared_ptr<Pipeline> pipeline);
-	explicit BasePipelineEvent(Pipeline &pipeline);
-
-	void PrintPipeline() override {
-		pipeline->Print();
-	}
-
-	//! The pipeline that this event belongs to
-	shared_ptr<Pipeline> pipeline;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/concurrentqueue.hpp b/src/duckdb/src/include/duckdb/parallel/concurrentqueue.hpp
deleted file mode 100644
index 7c277ac49..000000000
--- a/src/duckdb/src/include/duckdb/parallel/concurrentqueue.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//===----------------------------------------------------------------------===//
-//						 DuckDB
-//
-// duckdb/parallel/concurrentqueue.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#ifndef DUCKDB_NO_THREADS
-#include "concurrentqueue.h"
-#else
-
-#include <cstddef>
-#include <deque>
-#include <queue>
-
-namespace duckdb_moodycamel {
-
-template <typename T>
-class ConcurrentQueue;
-template <typename T>
-class BlockingConcurrentQueue;
-
-struct ProducerToken {
-	//! Constructor
-	template <typename T, typename Traits>
-	explicit ProducerToken(ConcurrentQueue<T> &);
-	//! Constructor
-	template <typename T, typename Traits>
-	explicit ProducerToken(BlockingConcurrentQueue<T> &);
-	//! Constructor
-	ProducerToken(ProducerToken &&) {
-	}
-	//! Is valid token?
-	inline bool valid() const {
-		return true;
-	}
-};
-
-template <typename T>
-class ConcurrentQueue {
-private:
-	//! The standard library queue.
-	std::queue<T, std::deque<T>> q;
-
-public:
-	//! Default constructor.
-	ConcurrentQueue() = default;
-	//! Constructor reserving capacity.
-	explicit ConcurrentQueue(size_t capacity) {
-		q.reserve(capacity);
-	}
-
-	//! Enqueue an item.
-	template <typename U>
-	bool enqueue(U &&item) {
-		q.push(std::forward<U>(item));
-		return true;
-	}
-	//! Try to dequeue an item.
-	bool try_dequeue(T &item) {
-		if (q.empty()) {
-			return false;
-		}
-		item = std::move(q.front());
-		q.pop();
-		return true;
-	}
-	//! Get the size of the queue.
-	size_t size_approx() const {
-		return q.size();
-	}
-	//! Dequeues several elements from the queue.
-	//! Returns the number of elements dequeued.
-	template <typename It>
-	size_t try_dequeue_bulk(It itemFirst, size_t max) {
-		for (size_t i = 0; i < max; i++) {
-			if (!try_dequeue(*itemFirst)) {
-				return i;
-			}
-			itemFirst++;
-		}
-		return max;
-	}
-};
-
-} // namespace duckdb_moodycamel
-
-#endif
diff --git a/src/duckdb/src/include/duckdb/parallel/event.hpp b/src/duckdb/src/include/duckdb/parallel/event.hpp
deleted file mode 100644
index f259cf55a..000000000
--- a/src/duckdb/src/include/duckdb/parallel/event.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-class Executor;
-class Task;
-
-class Event : public enable_shared_from_this<Event> {
-public:
-	explicit Event(Executor &executor);
-	virtual ~Event() = default;
-
-public:
-	virtual void Schedule() = 0;
-	//! Called right after the event is finished
-	virtual void FinishEvent() {
-	}
-	//! Called after the event is entirely finished
-	virtual void FinalizeFinish() {
-	}
-
-	void FinishTask();
-	void Finish();
-
-	void AddDependency(Event &event);
-	bool HasDependencies() const {
-		return total_dependencies != 0;
-	}
-	const vector<reference<Event>> &GetParentsVerification() const;
-
-	void CompleteDependency();
-
-	void SetTasks(vector<shared_ptr<Task>> tasks);
-
-	void InsertEvent(shared_ptr<Event> replacement_event);
-
-	bool IsFinished() const {
-		return finished;
-	}
-
-	virtual void PrintPipeline() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-protected:
-	Executor &executor;
-	//! The current threads working on the event
-	atomic<idx_t> finished_tasks;
-	//! The maximum amount of threads that can work on the event
-	atomic<idx_t> total_tasks;
-
-	//! The amount of completed dependencies
-	//! The event can only be started after the dependencies have finished executing
-	atomic<idx_t> finished_dependencies;
-	//! The total amount of dependencies
-	idx_t total_dependencies;
-
-	//! The events that depend on this event to run
-	vector<weak_ptr<Event>> parents;
-	//! Raw pointers to the parents (used for verification only)
-	vector<reference<Event>> parents_raw;
-
-	//! Whether or not the event is finished executing
-	atomic<bool> finished;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/executor_task.hpp b/src/duckdb/src/include/duckdb/parallel/executor_task.hpp
deleted file mode 100644
index d4d483b88..000000000
--- a/src/duckdb/src/include/duckdb/parallel/executor_task.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/executor_task.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/task.hpp"
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-class PhysicalOperator;
-class ThreadContext;
-
-//! Execute a task within an executor, including exception handling
-//! This should be used within queries
-class ExecutorTask : public Task {
-public:
-	ExecutorTask(Executor &executor, shared_ptr<Event> event);
-	ExecutorTask(ClientContext &context, shared_ptr<Event> event, const PhysicalOperator &op);
-	~ExecutorTask() override;
-
-public:
-	void Deschedule() override;
-	void Reschedule() override;
-
-public:
-	Executor &executor;
-	shared_ptr<Event> event;
-	unique_ptr<ThreadContext> thread_context;
-	optional_ptr<const PhysicalOperator> op;
-
-public:
-	virtual TaskExecutionResult ExecuteTask(TaskExecutionMode mode) = 0;
-	TaskExecutionResult Execute(TaskExecutionMode mode) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/interrupt.hpp b/src/duckdb/src/include/duckdb/parallel/interrupt.hpp
deleted file mode 100644
index d5e8dcfc1..000000000
--- a/src/duckdb/src/include/duckdb/parallel/interrupt.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/interrupt.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/enums/operator_result_type.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/parallel/task.hpp"
-
-#include <condition_variable>
-
-namespace duckdb {
-
-//! InterruptMode specifies how operators should block/unblock, note that this will happen transparently to the
-//! operator, as the operator only needs to return a BLOCKED result and call the callback using the InterruptState.
-//! NO_INTERRUPTS: No blocking mode is specified, an error will be thrown when the operator blocks. Should only be used
-//!                when manually calling operators of which is known they will never block.
-//! TASK:          A weak pointer to a task is provided. On the callback, this task will be signalled. If the Task has
-//!                been deleted, this callback becomes a NOP. This is the preferred way to await blocked pipelines.
-//! BLOCKING:	   The caller has blocked awaiting some synchronization primitive to wait for the callback.
-enum class InterruptMode : uint8_t { NO_INTERRUPTS, TASK, BLOCKING };
-
-//! Synchronization primitive used to await a callback in InterruptMode::BLOCKING.
-struct InterruptDoneSignalState {
-	//! Called by the callback to signal the interrupt is over
-	void Signal();
-	//! Await the callback signalling the interrupt is over
-	void Await();
-
-protected:
-	mutex lock;
-	std::condition_variable cv;
-	bool done = false;
-};
-
-//! State required to make the callback after some asynchronous operation within an operator source / sink.
-class InterruptState {
-public:
-	//! Default interrupt state will be set to InterruptMode::NO_INTERRUPTS and throw an error on use of Callback()
-	InterruptState();
-	//! Register the task to be interrupted and set mode to InterruptMode::TASK, the preferred way to handle interrupts
-	explicit InterruptState(weak_ptr<Task> task);
-	//! Register signal state and set mode to InterruptMode::BLOCKING, used for code paths without Task.
-	explicit InterruptState(weak_ptr<InterruptDoneSignalState> done_signal);
-
-	//! Perform the callback to indicate the Interrupt is over
-	DUCKDB_API void Callback() const;
-
-protected:
-	//! Current interrupt mode
-	InterruptMode mode;
-	//! Task ptr for InterruptMode::TASK
-	weak_ptr<Task> current_task;
-	//! Signal state for InterruptMode::BLOCKING
-	weak_ptr<InterruptDoneSignalState> signal_state;
-};
-
-class StateWithBlockableTasks {
-public:
-	unique_lock<mutex> Lock() {
-		return unique_lock<mutex>(lock);
-	}
-
-	void PreventBlocking(const unique_lock<mutex> &guard) {
-		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
-		can_block = false;
-	}
-
-	//! Add a task to 'blocked_tasks' before returning SourceResultType::BLOCKED (must hold the lock)
-	bool BlockTask(const unique_lock<mutex> &guard, const InterruptState &interrupt_state) {
-		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
-		if (can_block) {
-			blocked_tasks.push_back(interrupt_state);
-			return true;
-		}
-		return false;
-	}
-
-	//! Unblock all tasks (must hold the lock)
-	bool UnblockTasks(const unique_lock<mutex> &guard) {
-		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
-		if (blocked_tasks.empty()) {
-			return false;
-		}
-		for (auto &entry : blocked_tasks) {
-			entry.Callback();
-		}
-		blocked_tasks.clear();
-		return true;
-	}
-
-	SinkResultType BlockSink(const unique_lock<mutex> &guard, const InterruptState &interrupt_state) {
-		return BlockTask(guard, interrupt_state) ? SinkResultType::BLOCKED : SinkResultType::FINISHED;
-	}
-
-	SourceResultType BlockSource(const unique_lock<mutex> &guard, const InterruptState &interrupt_state) {
-		return BlockTask(guard, interrupt_state) ? SourceResultType::BLOCKED : SourceResultType::FINISHED;
-	}
-
-private:
-	//! Whether we can block tasks
-	atomic<bool> can_block {true};
-	//! Global lock, acquired by calling Lock()
-	mutable mutex lock;
-	//! Tasks that are currently blocked
-	mutable vector<InterruptState> blocked_tasks;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/meta_pipeline.hpp b/src/duckdb/src/include/duckdb/parallel/meta_pipeline.hpp
deleted file mode 100644
index 3722946a4..000000000
--- a/src/duckdb/src/include/duckdb/parallel/meta_pipeline.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/meta_pipeline.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-
-namespace duckdb {
-
-enum class MetaPipelineType : uint8_t {
-	REGULAR = 0,   //! The shared sink is regular
-	JOIN_BUILD = 1 //! The shared sink is a join build
-};
-
-//! MetaPipeline represents a set of pipelines that all have the same sink
-class MetaPipeline : public enable_shared_from_this<MetaPipeline> {
-	//! We follow these rules when building:
-	//! 1. For joins, build out the blocking side before going down the probe side
-	//!     - The current streaming pipeline will have a dependency on it (dependency across MetaPipelines)
-	//!     - Unions of this streaming pipeline will automatically inherit this dependency
-	//! 2. Build child pipelines last (e.g., Hash Join becomes source after probe is done: scan HT for FULL OUTER JOIN)
-	//!     - 'last' means after building out all other pipelines associated with this operator
-	//!     - The child pipeline automatically has dependencies (within this MetaPipeline) on:
-	//!         * The 'current' streaming pipeline
-	//!         * And all pipelines that were added to the MetaPipeline after 'current'
-public:
-	//! Create a MetaPipeline with the given sink
-	MetaPipeline(Executor &executor, PipelineBuildState &state, optional_ptr<PhysicalOperator> sink,
-	             MetaPipelineType type = MetaPipelineType::REGULAR);
-
-public:
-	//! Get the Executor for this MetaPipeline
-	Executor &GetExecutor() const;
-	//! Get the PipelineBuildState for this MetaPipeline
-	PipelineBuildState &GetState() const;
-	//! Get the sink operator for this MetaPipeline
-	optional_ptr<PhysicalOperator> GetSink() const;
-	//! Get the parent pipeline
-	optional_ptr<Pipeline> GetParent() const;
-
-	//! Get the initial pipeline of this MetaPipeline
-	shared_ptr<Pipeline> &GetBasePipeline();
-	//! Get the pipelines of this MetaPipeline
-	void GetPipelines(vector<shared_ptr<Pipeline>> &result, bool recursive);
-	//! Get the MetaPipeline children of this MetaPipeline
-	void GetMetaPipelines(vector<shared_ptr<MetaPipeline>> &result, bool recursive, bool skip);
-	//! Recursively gets the last child added
-	MetaPipeline &GetLastChild();
-	//! Get the dependencies of the Pipelines of this MetaPipeline
-	const reference_map_t<Pipeline, vector<reference<Pipeline>>> &GetDependencies() const;
-	//! Whether the sink of this pipeline is a join build
-	MetaPipelineType Type() const;
-	//! Whether this MetaPipeline has a recursive CTE
-	bool HasRecursiveCTE() const;
-	//! Set the flag that this MetaPipeline is a recursive CTE pipeline
-	void SetRecursiveCTE();
-	//! Assign a batch index to the given pipeline
-	void AssignNextBatchIndex(Pipeline &pipeline);
-	//! Let 'dependant' depend on all pipeline that were created since 'start',
-	//! where 'including' determines whether 'start' is added to the dependencies
-	vector<shared_ptr<Pipeline>> AddDependenciesFrom(Pipeline &dependant, const Pipeline &start, bool including);
-	//! Recursively makes all children of this MetaPipeline depend on the given Pipeline
-	void AddRecursiveDependencies(const vector<shared_ptr<Pipeline>> &new_dependencies, const MetaPipeline &last_child);
-	//! Make sure that the given pipeline has its own PipelineFinishEvent (e.g., for IEJoin - double Finalize)
-	void AddFinishEvent(Pipeline &pipeline);
-	//! Whether the pipeline needs its own PipelineFinishEvent
-	bool HasFinishEvent(Pipeline &pipeline) const;
-	//! Whether this pipeline is part of a PipelineFinishEvent
-	optional_ptr<Pipeline> GetFinishGroup(Pipeline &pipeline) const;
-
-public:
-	//! Build the MetaPipeline with 'op' as the first operator (excl. the shared sink)
-	void Build(PhysicalOperator &op);
-	//! Ready all the pipelines (recursively)
-	void Ready() const;
-
-	//! Create an empty pipeline within this MetaPipeline
-	Pipeline &CreatePipeline();
-	//! Create a union pipeline (clone of 'current')
-	Pipeline &CreateUnionPipeline(Pipeline &current, bool order_matters);
-	//! Create a child pipeline op 'current' starting at 'op',
-	//! where 'last_pipeline' is the last pipeline added before building out 'current'
-	void CreateChildPipeline(Pipeline &current, PhysicalOperator &op, Pipeline &last_pipeline);
-	//! Create a MetaPipeline child that 'current' depends on
-	MetaPipeline &CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op,
-	                                      MetaPipelineType type = MetaPipelineType::REGULAR);
-
-private:
-	//! The executor for all MetaPipelines in the query plan
-	Executor &executor;
-	//! The PipelineBuildState for all MetaPipelines in the query plan
-	PipelineBuildState &state;
-	//! Parent pipeline (optional)
-	optional_ptr<Pipeline> parent;
-	//! The sink of all pipelines within this MetaPipeline
-	optional_ptr<PhysicalOperator> sink;
-	//! The type of this MetaPipeline (regular, join build)
-	MetaPipelineType type;
-	//! Whether this MetaPipeline is a the recursive pipeline of a recursive CTE
-	bool recursive_cte;
-	//! All pipelines with a different source, but the same sink
-	vector<shared_ptr<Pipeline>> pipelines;
-	//! Dependencies of Pipelines of this MetaPipeline
-	reference_map_t<Pipeline, vector<reference<Pipeline>>> pipeline_dependencies;
-	//! Other MetaPipelines that this MetaPipeline depends on
-	vector<shared_ptr<MetaPipeline>> children;
-	//! Next batch index
-	idx_t next_batch_index;
-	//! Pipelines (other than the base pipeline) that need their own PipelineFinishEvent (e.g., for IEJoin)
-	reference_set_t<Pipeline> finish_pipelines;
-	//! Mapping from pipeline (e.g., child or union) to finish pipeline
-	reference_map_t<Pipeline, Pipeline &> finish_map;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline.hpp
deleted file mode 100644
index 34dcdd447..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-
-namespace duckdb {
-
-class Executor;
-class Event;
-class MetaPipeline;
-class PipelineExecutor;
-class Pipeline;
-
-class PipelineTask : public ExecutorTask {
-	static constexpr const idx_t PARTIAL_CHUNK_COUNT = 50;
-
-public:
-	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p);
-
-	Pipeline &pipeline;
-	unique_ptr<PipelineExecutor> pipeline_executor;
-
-public:
-	const PipelineExecutor &GetPipelineExecutor() const;
-	bool TaskBlockedOnResult() const override;
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
-};
-
-class PipelineBuildState {
-public:
-	//! How much to increment batch indexes when multiple pipelines share the same source
-	constexpr static idx_t BATCH_INCREMENT = 10000000000000;
-
-public:
-	//! Duplicate eliminated join scan dependencies
-	reference_map_t<const PhysicalOperator, reference<Pipeline>> delim_join_dependencies;
-	//! Materialized CTE scan dependencies
-	reference_map_t<const PhysicalOperator, reference<Pipeline>> cte_dependencies;
-
-public:
-	void SetPipelineSource(Pipeline &pipeline, PhysicalOperator &op);
-	void SetPipelineSink(Pipeline &pipeline, optional_ptr<PhysicalOperator> op, idx_t sink_pipeline_count);
-	void SetPipelineOperators(Pipeline &pipeline, vector<reference<PhysicalOperator>> operators);
-	void AddPipelineOperator(Pipeline &pipeline, PhysicalOperator &op);
-	shared_ptr<Pipeline> CreateChildPipeline(Executor &executor, Pipeline &pipeline, PhysicalOperator &op);
-
-	optional_ptr<PhysicalOperator> GetPipelineSource(Pipeline &pipeline);
-	optional_ptr<PhysicalOperator> GetPipelineSink(Pipeline &pipeline);
-	vector<reference<PhysicalOperator>> GetPipelineOperators(Pipeline &pipeline);
-};
-
-//! The Pipeline class represents an execution pipeline starting at a
-class Pipeline : public enable_shared_from_this<Pipeline> {
-	friend class Executor;
-	friend class PipelineExecutor;
-	friend class PipelineEvent;
-	friend class PipelineFinishEvent;
-	friend class PipelineBuildState;
-	friend class MetaPipeline;
-
-public:
-	explicit Pipeline(Executor &execution_context);
-
-	Executor &executor;
-
-public:
-	ClientContext &GetClientContext();
-
-	void AddDependency(shared_ptr<Pipeline> &pipeline);
-
-	void Ready();
-	void Reset();
-	void ResetSink();
-	void ResetSource(bool force);
-	void ClearSource();
-	void Schedule(shared_ptr<Event> &event);
-	void PrepareFinalize();
-
-	string ToString() const;
-	void Print() const;
-	void PrintDependencies() const;
-
-	//! Returns query progress
-	bool GetProgress(ProgressData &progress_data);
-
-	//! Returns a list of all operators (including source and sink) involved in this pipeline
-	vector<reference<PhysicalOperator>> GetOperators();
-	vector<const_reference<PhysicalOperator>> GetOperators() const;
-
-	optional_ptr<PhysicalOperator> GetSink() {
-		return sink;
-	}
-
-	optional_ptr<PhysicalOperator> GetSource() {
-		return source;
-	}
-
-	//! Returns whether any of the operators in the pipeline care about preserving order
-	bool IsOrderDependent() const;
-
-	//! Registers a new batch index for a pipeline executor - returns the current minimum batch index
-	idx_t RegisterNewBatchIndex();
-
-	//! Updates the batch index of a pipeline (and returns the new minimum batch index)
-	idx_t UpdateBatchIndex(idx_t old_index, idx_t new_index);
-
-private:
-	//! Whether or not the pipeline has been readied
-	bool ready;
-	//! Whether or not the pipeline has been initialized
-	atomic<bool> initialized;
-	//! The source of this pipeline
-	optional_ptr<PhysicalOperator> source;
-	//! The chain of intermediate operators
-	vector<reference<PhysicalOperator>> operators;
-	//! The sink (i.e. destination) for data; this is e.g. a hash table to-be-built
-	optional_ptr<PhysicalOperator> sink;
-
-	//! The global source state
-	unique_ptr<GlobalSourceState> source_state;
-
-	//! The parent pipelines (i.e. pipelines that are dependent on this pipeline to finish)
-	vector<weak_ptr<Pipeline>> parents;
-	//! The dependencies of this pipeline
-	vector<weak_ptr<Pipeline>> dependencies;
-
-	//! The base batch index of this pipeline
-	idx_t base_batch_index = 0;
-	//! Lock for accessing the set of batch indexes
-	mutex batch_lock;
-	//! The set of batch indexes that are currently being processed
-	//! Despite batch indexes being unique - this is a multiset
-	//! The reason is that when we start a new pipeline we insert the current minimum batch index as a placeholder
-	//! Which leads to duplicate entries in the set of active batch indexes
-	multiset<idx_t> batch_indexes;
-
-private:
-	void ScheduleSequentialTask(shared_ptr<Event> &event);
-	bool LaunchScanTasks(shared_ptr<Event> &event, idx_t max_threads);
-
-	bool ScheduleParallel(shared_ptr<Event> &event);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline_complete_event.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline_complete_event.hpp
deleted file mode 100644
index 753aa8511..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline_complete_event.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_complete_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/event.hpp"
-
-namespace duckdb {
-class Executor;
-
-class PipelineCompleteEvent : public Event {
-public:
-	PipelineCompleteEvent(Executor &executor, bool complete_pipeline_p);
-
-	bool complete_pipeline;
-
-public:
-	void Schedule() override;
-	void FinalizeFinish() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline_event.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline_event.hpp
deleted file mode 100644
index a2448c1ba..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline_event.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/base_pipeline_event.hpp"
-
-namespace duckdb {
-
-//! A PipelineEvent is responsible for scheduling a pipeline
-class PipelineEvent : public BasePipelineEvent {
-public:
-	explicit PipelineEvent(shared_ptr<Pipeline> pipeline);
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline_executor.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline_executor.hpp
deleted file mode 100644
index 9781e6fb8..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline_executor.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/common/stack.hpp"
-
-#include <functional>
-
-namespace duckdb {
-class Executor;
-
-//! The result of executing a PipelineExecutor
-enum class PipelineExecuteResult {
-	//! PipelineExecutor is fully executed: the source is completely exhausted
-	FINISHED,
-	//! PipelineExecutor is not yet fully executed and can be called again immediately
-	NOT_FINISHED,
-	//! The PipelineExecutor was interrupted and should not be called again until the interrupt is handled as specified
-	//! in the InterruptMode
-	INTERRUPTED
-};
-
-class ExecutionBudget {
-public:
-	explicit ExecutionBudget(idx_t maximum) : processed(0), maximum_to_process(maximum) {
-	}
-
-public:
-	bool Next() {
-		if (IsDepleted()) {
-			return false;
-		}
-		processed++;
-		return true;
-	}
-	bool IsDepleted() const {
-		return processed >= maximum_to_process;
-	}
-
-private:
-	idx_t processed;
-	idx_t maximum_to_process;
-};
-
-//! The Pipeline class represents an execution pipeline
-class PipelineExecutor {
-public:
-	PipelineExecutor(ClientContext &context, Pipeline &pipeline);
-
-	//! Fully execute a pipeline with a source and a sink until the source is completely exhausted
-	PipelineExecuteResult Execute();
-	//! Execute a pipeline with a source and a sink until finished, or until max_chunks were processed from the source
-	//! Returns true if execution is finished, false if Execute should be called again
-	PipelineExecuteResult Execute(idx_t max_chunks);
-
-	//! Called after depleting the source: finalizes the execution of this pipeline executor
-	//! This should only be called once per PipelineExecutor.
-	PipelineExecuteResult PushFinalize();
-
-	bool RemainingSinkChunk() const;
-
-	//! Initializes a chunk with the types that will flow out of the chunk
-	void InitializeChunk(DataChunk &chunk);
-	//! Execute a pipeline without a sink, and retrieve a single DataChunk
-	//! Returns an empty chunk when finished.
-
-	//! Registers the task in the interrupt_state to allow Source/Sink operators to block the task
-	void SetTaskForInterrupts(weak_ptr<Task> current_task);
-
-private:
-	//! The pipeline to process
-	Pipeline &pipeline;
-	//! The thread context of this executor
-	ThreadContext thread;
-	//! The total execution context of this executor
-	ExecutionContext context;
-
-	//! Intermediate chunks for the operators
-	vector<unique_ptr<DataChunk>> intermediate_chunks;
-	//! Intermediate states for the operators
-	vector<unique_ptr<OperatorState>> intermediate_states;
-
-	//! The local source state
-	unique_ptr<LocalSourceState> local_source_state;
-	//! The local sink state (if any)
-	unique_ptr<LocalSinkState> local_sink_state;
-	//! The interrupt state, holding required information for sink/source operators to block
-	InterruptState interrupt_state;
-
-	//! The final chunk used for moving data into the sink
-	DataChunk final_chunk;
-
-	//! The operators that are not yet finished executing and have data remaining
-	//! If the stack of in_process_operators is empty, we fetch from the source instead
-	stack<idx_t> in_process_operators;
-	//! Whether or not the pipeline has been finalized (used for verification only)
-	bool finalized = false;
-	//! Whether or not the pipeline has finished processing
-	int32_t finished_processing_idx = -1;
-	//! Partition info that is used by this executor
-	OperatorPartitionInfo required_partition_info;
-
-	//! Source has indicated it is exhausted
-	bool exhausted_source = false;
-	//! Flushing of intermediate operators has started
-	bool started_flushing = false;
-	//! Flushing of caching operators is done
-	bool done_flushing = false;
-
-	//! This flag is set when the pipeline gets interrupted by the Sink -> the final_chunk should be re-sink-ed.
-	bool remaining_sink_chunk = false;
-
-	//! This flag is set when the pipeline gets interrupted by NextBatch -> NextBatch should be called again and the
-	//! source_chunk should be sent through the pipeline
-	bool next_batch_blocked = false;
-
-	//! Current operator being flushed
-	idx_t flushing_idx;
-	//! Whether the current flushing_idx should be flushed: this needs to be stored to make flushing code re-entrant
-	bool should_flush_current_idx = true;
-
-private:
-	void StartOperator(PhysicalOperator &op);
-	void EndOperator(PhysicalOperator &op, optional_ptr<DataChunk> chunk);
-
-	//! Reset the operator index to the first operator
-	void GoToSource(idx_t &current_idx, idx_t initial_idx);
-	SourceResultType FetchFromSource(DataChunk &result);
-
-	void FinishProcessing(int32_t operator_idx = -1);
-	bool IsFinished();
-
-	//! Wrappers for sink/source calls to respective operators
-	SourceResultType GetData(DataChunk &chunk, OperatorSourceInput &input);
-	SinkResultType Sink(DataChunk &chunk, OperatorSinkInput &input);
-
-	OperatorResultType ExecutePushInternal(DataChunk &input, ExecutionBudget &chunk_budget, idx_t initial_idx = 0);
-	//! Pushes a chunk through the pipeline and returns a single result chunk
-	//! Returns whether or not a new input chunk is needed, or whether or not we are finished
-	OperatorResultType Execute(DataChunk &input, DataChunk &result, idx_t initial_index = 0);
-
-	//! Notifies the sink that a new batch has started
-	SinkNextBatchType NextBatch(DataChunk &source_chunk);
-
-	//! Tries to flush all state from intermediate operators. Will return true if all state is flushed, false in the
-	//! case of a blocked sink.
-	bool TryFlushCachingOperators(ExecutionBudget &chunk_budget);
-
-	static bool CanCacheType(const LogicalType &type);
-	void CacheChunk(DataChunk &input, idx_t operator_idx);
-
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	//! Debugging state: number of times blocked
-	int debug_blocked_sink_count = 0;
-	int debug_blocked_source_count = 0;
-	int debug_blocked_combine_count = 0;
-	int debug_blocked_next_batch_count = 0;
-	//! Number of times the Sink/Source will block before actually returning data
-	int debug_blocked_target_count = 1;
-#endif
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline_finish_event.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline_finish_event.hpp
deleted file mode 100644
index 1a486a61f..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline_finish_event.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_finish_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/base_pipeline_event.hpp"
-
-namespace duckdb {
-class Executor;
-
-class PipelineFinishEvent : public BasePipelineEvent {
-public:
-	explicit PipelineFinishEvent(shared_ptr<Pipeline> pipeline);
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline_initialize_event.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline_initialize_event.hpp
deleted file mode 100644
index 664717dc4..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline_initialize_event.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_finish_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/base_pipeline_event.hpp"
-
-namespace duckdb {
-
-class Executor;
-
-class PipelineInitializeEvent : public BasePipelineEvent {
-public:
-	explicit PipelineInitializeEvent(shared_ptr<Pipeline> pipeline);
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline_prepare_finish_event.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline_prepare_finish_event.hpp
deleted file mode 100644
index 162f4323d..000000000
--- a/src/duckdb/src/include/duckdb/parallel/pipeline_prepare_finish_event.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_pre_finish_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/base_pipeline_event.hpp"
-
-namespace duckdb {
-class Executor;
-
-class PipelinePrepareFinishEvent : public BasePipelineEvent {
-public:
-	explicit PipelinePrepareFinishEvent(shared_ptr<Pipeline> pipeline);
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/task.hpp b/src/duckdb/src/include/duckdb/parallel/task.hpp
deleted file mode 100644
index 2bcafeeaa..000000000
--- a/src/duckdb/src/include/duckdb/parallel/task.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/task.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-class ClientContext;
-class Executor;
-class Task;
-class DatabaseInstance;
-struct ProducerToken;
-
-enum class TaskExecutionMode : uint8_t { PROCESS_ALL, PROCESS_PARTIAL };
-
-enum class TaskExecutionResult : uint8_t { TASK_FINISHED, TASK_NOT_FINISHED, TASK_ERROR, TASK_BLOCKED };
-
-//! Generic parallel task
-class Task : public enable_shared_from_this<Task> {
-public:
-	virtual ~Task() {
-	}
-
-public:
-	//! Execute the task in the specified execution mode
-	//! If mode is PROCESS_ALL, Execute should always finish processing and return TASK_FINISHED
-	//! If mode is PROCESS_PARTIAL, Execute can return TASK_NOT_FINISHED, in which case Execute will be called again
-	//! In case of an error, TASK_ERROR is returned
-	//! In case the task has interrupted, BLOCKED is returned.
-	virtual TaskExecutionResult Execute(TaskExecutionMode mode) = 0;
-
-	//! Descheduling a task ensures the task is not executed, but remains available for rescheduling as long as
-	//! required, generally until some code in an operator calls the InterruptState::Callback() method of a state of the
-	//! InterruptMode::TASK mode.
-	virtual void Deschedule() {
-		throw InternalException("Cannot deschedule task of base Task class");
-	};
-
-	//! Ensures a task is rescheduled to the correct queue
-	virtual void Reschedule() {
-		throw InternalException("Cannot reschedule task of base Task class");
-	}
-
-	virtual bool TaskBlockedOnResult() const {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/task_counter.hpp b/src/duckdb/src/include/duckdb/parallel/task_counter.hpp
deleted file mode 100644
index 53683b5d1..000000000
--- a/src/duckdb/src/include/duckdb/parallel/task_counter.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/task_counter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parallel/task_scheduler.hpp"
-
-namespace duckdb {
-
-class TaskCounter {
-public:
-	explicit TaskCounter(TaskScheduler &scheduler_p)
-	    : scheduler(scheduler_p), token(scheduler_p.CreateProducer()), task_count(0), tasks_completed(0) {
-	}
-
-	virtual void AddTask(shared_ptr<Task> task) {
-		++task_count;
-		scheduler.ScheduleTask(*token, std::move(task));
-	}
-
-	virtual void FinishTask() const {
-		++tasks_completed;
-	}
-
-	virtual void Finish() {
-		while (tasks_completed < task_count) {
-			shared_ptr<Task> task;
-			if (scheduler.GetTaskFromProducer(*token, task)) {
-				task->Execute();
-				task.reset();
-			}
-		}
-	}
-
-private:
-	TaskScheduler &scheduler;
-	unique_ptr<ProducerToken> token;
-	size_t task_count;
-	mutable atomic<size_t> tasks_completed;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/task_executor.hpp b/src/duckdb/src/include/duckdb/parallel/task_executor.hpp
deleted file mode 100644
index 191b6df9d..000000000
--- a/src/duckdb/src/include/duckdb/parallel/task_executor.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/task_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/parallel/task.hpp"
-#include "duckdb/execution/task_error_manager.hpp"
-
-namespace duckdb {
-class TaskScheduler;
-
-//! The TaskExecutor is a helper class that enables parallel scheduling and execution of tasks
-class TaskExecutor {
-public:
-	explicit TaskExecutor(ClientContext &context);
-	explicit TaskExecutor(TaskScheduler &scheduler);
-	~TaskExecutor();
-
-	//! Push an error into the TaskExecutor
-	void PushError(ErrorData error);
-	//! Whether or not any task has encountered an error
-	bool HasError();
-	//! Throw an error that was encountered during execution (if HasError() is true)
-	void ThrowError();
-
-	//! Schedule a new task
-	void ScheduleTask(unique_ptr<Task> task);
-	//! Label a task as finished
-	void FinishTask();
-
-	//! Work on tasks until all tasks are finished. Throws an exception if any error occurred while executing the tasks.
-	void WorkOnTasks();
-
-	//! Get a task - returns true if a task was found
-	bool GetTask(shared_ptr<Task> &task);
-
-private:
-	TaskScheduler &scheduler;
-	TaskErrorManager error_manager;
-	unique_ptr<ProducerToken> token;
-	atomic<idx_t> completed_tasks;
-	atomic<idx_t> total_tasks;
-};
-
-class BaseExecutorTask : public Task {
-public:
-	explicit BaseExecutorTask(TaskExecutor &executor);
-
-	virtual void ExecuteTask() = 0;
-	TaskExecutionResult Execute(TaskExecutionMode mode) override;
-
-protected:
-	TaskExecutor &executor;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp b/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp
deleted file mode 100644
index c40e8e10d..000000000
--- a/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/task_scheduler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parallel/task.hpp"
-
-namespace duckdb {
-
-struct ConcurrentQueue;
-struct QueueProducerToken;
-class ClientContext;
-class DatabaseInstance;
-class TaskScheduler;
-
-struct SchedulerThread;
-
-struct ProducerToken {
-	ProducerToken(TaskScheduler &scheduler, unique_ptr<QueueProducerToken> token);
-	~ProducerToken();
-
-	TaskScheduler &scheduler;
-	unique_ptr<QueueProducerToken> token;
-	mutex producer_lock;
-};
-
-//! The TaskScheduler is responsible for managing tasks and threads
-class TaskScheduler {
-	// timeout for semaphore wait, default 5ms
-	constexpr static int64_t TASK_TIMEOUT_USECS = 5000;
-
-public:
-	explicit TaskScheduler(DatabaseInstance &db);
-	~TaskScheduler();
-
-	DUCKDB_API static TaskScheduler &GetScheduler(ClientContext &context);
-	DUCKDB_API static TaskScheduler &GetScheduler(DatabaseInstance &db);
-
-	unique_ptr<ProducerToken> CreateProducer();
-	//! Schedule a task to be executed by the task scheduler
-	void ScheduleTask(ProducerToken &producer, shared_ptr<Task> task);
-	//! Fetches a task from a specific producer, returns true if successful or false if no tasks were available
-	bool GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &task);
-	//! Run tasks forever until "marker" is set to false, "marker" must remain valid until the thread is joined
-	void ExecuteForever(atomic<bool> *marker);
-	//! Run tasks until `marker` is set to false, `max_tasks` have been completed, or until there are no more tasks
-	//! available. Returns the number of tasks that were completed.
-	idx_t ExecuteTasks(atomic<bool> *marker, idx_t max_tasks);
-	//! Run tasks until `max_tasks` have been completed, or until there are no more tasks available
-	void ExecuteTasks(idx_t max_tasks);
-
-	//! Sets the amount of background threads to be used for execution, based on the number of total threads
-	//! and the number of external threads. External threads, e.g. the main thread, will also be used for execution.
-	//! Launches `total_threads - external_threads` background worker threads.
-	void SetThreads(idx_t total_threads, idx_t external_threads);
-
-	void RelaunchThreads();
-
-	//! Returns the number of threads
-	DUCKDB_API int32_t NumberOfThreads();
-
-	//! Send signals to n threads, signalling for them to wake up and attempt to execute a task
-	void Signal(idx_t n);
-
-	//! Yield to other threads
-	static void YieldThread();
-
-	//! Set the allocator flush threshold
-	void SetAllocatorFlushTreshold(idx_t threshold);
-	//! Sets the allocator background thread
-	void SetAllocatorBackgroundThreads(bool enable);
-
-	//! Get the number of the CPU on which the calling thread is currently executing.
-	//! Fallback to calling thread id if CPU number is not available.
-	//! Result do not need to be exact 'return 0' is a valid fallback strategy
-	static idx_t GetEstimatedCPUId();
-
-private:
-	void RelaunchThreadsInternal(int32_t n);
-
-private:
-	DatabaseInstance &db;
-	//! The task queue
-	unique_ptr<ConcurrentQueue> queue;
-	//! Lock for modifying the thread count
-	mutex thread_lock;
-	//! The active background threads of the task scheduler
-	vector<unique_ptr<SchedulerThread>> threads;
-	//! Markers used by the various threads, if the markers are set to "false" the thread execution is stopped
-	vector<unique_ptr<atomic<bool>>> markers;
-	//! The threshold after which to flush the allocator after completing a task
-	atomic<idx_t> allocator_flush_threshold;
-	//! Whether allocator background threads are enabled
-	atomic<bool> allocator_background_threads;
-	//! Requested thread count (set by the 'threads' setting)
-	atomic<int32_t> requested_thread_count;
-	//! The amount of threads currently running
-	atomic<int32_t> current_thread_count;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parallel/thread_context.hpp b/src/duckdb/src/include/duckdb/parallel/thread_context.hpp
deleted file mode 100644
index 90097e7f0..000000000
--- a/src/duckdb/src/include/duckdb/parallel/thread_context.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/thread_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/query_profiler.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-//! The ThreadContext holds thread-local info for parallel usage
-class ThreadContext {
-public:
-	explicit ThreadContext(ClientContext &context);
-
-	//! The operator profiler for the individual thread context
-	OperatorProfiler profiler;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/base_expression.hpp b/src/duckdb/src/include/duckdb/parser/base_expression.hpp
deleted file mode 100644
index 7e339e2b9..000000000
--- a/src/duckdb/src/include/duckdb/parser/base_expression.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/base_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-//!  The BaseExpression class is a base class that can represent any expression
-//!  part of a SQL statement.
-class BaseExpression {
-public:
-	//! Create an Expression
-	BaseExpression(ExpressionType type, ExpressionClass expression_class)
-	    : type(type), expression_class(expression_class) {
-	}
-	virtual ~BaseExpression() {
-	}
-
-	//! Returns the class of the expression
-	ExpressionClass GetExpressionClass() const {
-		return expression_class;
-	}
-
-	//! Returns the type of the expression
-	ExpressionType GetExpressionType() const {
-		return type;
-	}
-
-	//! Sets the type of the expression unsafely. In general expressions are immutable and should not be changed after
-	//! creation. Only use this if you know what you are doing.
-	void SetExpressionTypeUnsafe(ExpressionType new_type) {
-		type = new_type;
-	}
-
-	//! Returns the location in the query (if any)
-	optional_idx GetQueryLocation() const {
-		return query_location;
-	}
-
-	//! Sets the location in the query
-	void SetQueryLocation(optional_idx location) {
-		query_location = location;
-	}
-
-	//! Returns true if the expression has a non-empty alias
-	bool HasAlias() const {
-		return !alias.empty();
-	}
-
-	//! Returns the alias of the expression
-	const string &GetAlias() const {
-		return alias;
-	}
-
-	//! Sets the alias of the expression
-	void SetAlias(const string &alias_p) {
-		alias = alias_p;
-	}
-
-	//! Sets the alias of the expression
-	void SetAlias(string &&alias_p) {
-		alias = std::move(alias_p);
-	}
-
-	//! Clears the alias of the expression
-	void ClearAlias() {
-		alias.clear();
-	}
-
-	// TODO: Make the following protected
-	// protected:
-
-	//! Type of the expression
-	ExpressionType type;
-
-	//! The expression class of the node
-	ExpressionClass expression_class;
-
-	//! The alias of the expression,
-	string alias;
-
-	//! The location in the query (if any)
-	optional_idx query_location;
-
-public:
-	//! Returns true if this expression is an aggregate or not.
-	/*!
-	 Examples:
-
-	 (1) SUM(a) + 1 -- True
-
-	 (2) a + 1 -- False
-	 */
-	virtual bool IsAggregate() const = 0;
-	//! Returns true if the expression has a window function or not
-	virtual bool IsWindow() const = 0;
-	//! Returns true if the query contains a subquery
-	virtual bool HasSubquery() const = 0;
-	//! Returns true if expression does not contain a group ref or col ref or parameter
-	virtual bool IsScalar() const = 0;
-	//! Returns true if the expression has a parameter
-	virtual bool HasParameter() const = 0;
-
-	//! Get the name of the expression
-	virtual string GetName() const;
-	//! Convert the Expression to a String
-	virtual string ToString() const = 0;
-	//! Print the expression to stdout
-	void Print() const;
-
-	//! Creates a hash value of this expression. It is important that if two expressions are identical (i.e.
-	//! Expression::Equals() returns true), that their hash value is identical as well.
-	virtual hash_t Hash() const = 0;
-	//! Returns true if this expression is equal to another expression
-	virtual bool Equals(const BaseExpression &other) const;
-
-	static bool Equals(const BaseExpression &left, const BaseExpression &right) {
-		return left.Equals(right);
-	}
-	bool operator==(const BaseExpression &rhs) const {
-		return Equals(rhs);
-	}
-
-	virtual void Verify() const;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (expression_class != TARGET::TYPE) {
-			throw InternalException("Failed to cast expression to type - expression type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (expression_class != TARGET::TYPE) {
-			throw InternalException("Failed to cast expression to type - expression type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/column_definition.hpp b/src/duckdb/src/include/duckdb/parser/column_definition.hpp
deleted file mode 100644
index fa5cc8d38..000000000
--- a/src/duckdb/src/include/duckdb/parser/column_definition.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/column_definition.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-struct RenameColumnInfo;
-struct RenameTableInfo;
-
-class ColumnDefinition;
-
-//! A column of a table.
-class ColumnDefinition {
-public:
-	DUCKDB_API ColumnDefinition(string name, LogicalType type);
-	DUCKDB_API ColumnDefinition(string name, LogicalType type, unique_ptr<ParsedExpression> expression,
-	                            TableColumnType category);
-
-public:
-	//! default_value
-	const ParsedExpression &DefaultValue() const;
-	bool HasDefaultValue() const;
-	void SetDefaultValue(unique_ptr<ParsedExpression> default_value);
-
-	//! type
-	DUCKDB_API const LogicalType &Type() const;
-	LogicalType &TypeMutable();
-	void SetType(const LogicalType &type);
-
-	//! name
-	DUCKDB_API const string &Name() const;
-	void SetName(const string &name);
-
-	//! comment
-	DUCKDB_API const Value &Comment() const;
-	void SetComment(const Value &comment);
-
-	//! compression_type
-	const duckdb::CompressionType &CompressionType() const;
-	void SetCompressionType(duckdb::CompressionType compression_type);
-
-	//! storage_oid
-	const storage_t &StorageOid() const;
-	void SetStorageOid(storage_t storage_oid);
-
-	LogicalIndex Logical() const;
-	PhysicalIndex Physical() const;
-
-	//! oid
-	const column_t &Oid() const;
-	void SetOid(column_t oid);
-
-	//! category
-	const TableColumnType &Category() const;
-	//! Whether this column is a Generated Column
-	bool Generated() const;
-	DUCKDB_API ColumnDefinition Copy() const;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &deserializer);
-
-	//===--------------------------------------------------------------------===//
-	// Generated Columns (VIRTUAL)
-	//===--------------------------------------------------------------------===//
-
-	ParsedExpression &GeneratedExpressionMutable();
-	const ParsedExpression &GeneratedExpression() const;
-	void SetGeneratedExpression(unique_ptr<ParsedExpression> expression);
-	void ChangeGeneratedExpressionType(const LogicalType &type);
-	void GetListOfDependencies(vector<string> &dependencies) const;
-
-	string GetName() const;
-
-	LogicalType GetType() const;
-
-private:
-	//! The name of the entry
-	string name;
-	//! The type of the column
-	LogicalType type;
-	//! Compression Type used for this column
-	duckdb::CompressionType compression_type = duckdb::CompressionType::COMPRESSION_AUTO;
-	//! The index of the column in the storage of the table
-	storage_t storage_oid = DConstants::INVALID_INDEX;
-	//! The index of the column in the table
-	idx_t oid = DConstants::INVALID_INDEX;
-	//! The category of the column
-	TableColumnType category = TableColumnType::STANDARD;
-	//! The default value of the column (for non-generated columns)
-	//! The generated column expression (for generated columns)
-	unique_ptr<ParsedExpression> expression;
-	//! Comment on this column
-	Value comment;
-	//! Tags on this column
-	unordered_map<string, string> tags;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/column_list.hpp b/src/duckdb/src/include/duckdb/parser/column_list.hpp
deleted file mode 100644
index 7bf9cc173..000000000
--- a/src/duckdb/src/include/duckdb/parser/column_list.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/column_list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/column_definition.hpp"
-
-namespace duckdb {
-
-//! A set of column definitions
-class ColumnList {
-public:
-	class ColumnListIterator;
-
-public:
-	DUCKDB_API explicit ColumnList(bool allow_duplicate_names = false);
-	DUCKDB_API explicit ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names = false);
-
-	DUCKDB_API void AddColumn(ColumnDefinition column);
-	void Finalize();
-
-	DUCKDB_API const ColumnDefinition &GetColumn(LogicalIndex index) const;
-	DUCKDB_API const ColumnDefinition &GetColumn(PhysicalIndex index) const;
-	DUCKDB_API const ColumnDefinition &GetColumn(const string &name) const;
-	DUCKDB_API ColumnDefinition &GetColumnMutable(LogicalIndex index);
-	DUCKDB_API ColumnDefinition &GetColumnMutable(PhysicalIndex index);
-	DUCKDB_API ColumnDefinition &GetColumnMutable(const string &name);
-	DUCKDB_API vector<string> GetColumnNames() const;
-	DUCKDB_API vector<LogicalType> GetColumnTypes() const;
-
-	DUCKDB_API bool ColumnExists(const string &name) const;
-
-	DUCKDB_API LogicalIndex GetColumnIndex(string &column_name) const;
-	DUCKDB_API PhysicalIndex LogicalToPhysical(LogicalIndex index) const;
-	DUCKDB_API LogicalIndex PhysicalToLogical(PhysicalIndex index) const;
-
-	idx_t LogicalColumnCount() const {
-		return columns.size();
-	}
-	idx_t PhysicalColumnCount() const {
-		return physical_columns.size();
-	}
-	bool empty() const { // NOLINT: match stl API
-		return columns.empty();
-	}
-
-	ColumnList Copy() const;
-	void Serialize(Serializer &serializer) const;
-	static ColumnList Deserialize(Deserializer &deserializer);
-
-	DUCKDB_API ColumnListIterator Logical() const;
-	DUCKDB_API ColumnListIterator Physical() const;
-
-	void SetAllowDuplicates(bool allow_duplicates) {
-		allow_duplicate_names = allow_duplicates;
-	}
-
-private:
-	vector<ColumnDefinition> columns;
-	//! A map of column name to column index
-	case_insensitive_map_t<column_t> name_map;
-	//! The set of physical columns
-	vector<idx_t> physical_columns;
-	//! Allow duplicate names or not
-	bool allow_duplicate_names;
-
-private:
-	void AddToNameMap(ColumnDefinition &column);
-
-public:
-	// logical iterator
-	class ColumnListIterator {
-	public:
-		ColumnListIterator(const ColumnList &list, bool physical) : list(list), physical(physical) {
-		}
-
-	private:
-		const ColumnList &list;
-		bool physical;
-
-	private:
-		class ColumnLogicalIteratorInternal {
-		public:
-			ColumnLogicalIteratorInternal(const ColumnList &list, bool physical, idx_t pos, idx_t end)
-			    : list(list), physical(physical), pos(pos), end(end) {
-			}
-
-			const ColumnList &list;
-			bool physical;
-			idx_t pos;
-			idx_t end;
-
-		public:
-			ColumnLogicalIteratorInternal &operator++() {
-				pos++;
-				return *this;
-			}
-			bool operator!=(const ColumnLogicalIteratorInternal &other) const {
-				return pos != other.pos || end != other.end || &list != &other.list;
-			}
-			const ColumnDefinition &operator*() const {
-				if (physical) {
-					return list.GetColumn(PhysicalIndex(pos));
-				} else {
-					return list.GetColumn(LogicalIndex(pos));
-				}
-			}
-		};
-
-	public:
-		idx_t Size() {
-			return physical ? list.PhysicalColumnCount() : list.LogicalColumnCount();
-		}
-
-		ColumnLogicalIteratorInternal begin() { // NOLINT: match stl API
-			return ColumnLogicalIteratorInternal(list, physical, 0, Size());
-		}
-		ColumnLogicalIteratorInternal end() { // NOLINT: match stl API
-			return ColumnLogicalIteratorInternal(list, physical, Size(), Size());
-		}
-	};
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/common_table_expression_info.hpp b/src/duckdb/src/include/duckdb/parser/common_table_expression_info.hpp
deleted file mode 100644
index 80d7c8970..000000000
--- a/src/duckdb/src/include/duckdb/parser/common_table_expression_info.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/common_table_expression_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/common/enums/cte_materialize.hpp"
-
-namespace duckdb {
-
-class SelectStatement;
-
-struct CommonTableExpressionInfo {
-	vector<string> aliases;
-	unique_ptr<SelectStatement> query;
-	CTEMaterialize materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<CommonTableExpressionInfo> Deserialize(Deserializer &deserializer);
-	unique_ptr<CommonTableExpressionInfo> Copy();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/constraint.hpp b/src/duckdb/src/include/duckdb/parser/constraint.hpp
deleted file mode 100644
index 2d19d5ec3..000000000
--- a/src/duckdb/src/include/duckdb/parser/constraint.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-
-//===--------------------------------------------------------------------===//
-// Constraint Types
-//===--------------------------------------------------------------------===//
-enum class ConstraintType : uint8_t {
-	INVALID = 0,     // invalid constraint type
-	NOT_NULL = 1,    // NOT NULL constraint
-	CHECK = 2,       // CHECK constraint
-	UNIQUE = 3,      // UNIQUE constraint
-	FOREIGN_KEY = 4, // FOREIGN KEY constraint
-};
-
-enum class ForeignKeyType : uint8_t {
-	FK_TYPE_PRIMARY_KEY_TABLE = 0,   // main table
-	FK_TYPE_FOREIGN_KEY_TABLE = 1,   // referencing table
-	FK_TYPE_SELF_REFERENCE_TABLE = 2 // self refrencing table
-};
-
-struct ForeignKeyInfo {
-	ForeignKeyType type;
-	string schema;
-	//! if type is FK_TYPE_FOREIGN_KEY_TABLE, means main key table, if type is FK_TYPE_PRIMARY_KEY_TABLE, means foreign
-	//! key table
-	string table;
-	//! The set of main key table's column's index
-	vector<PhysicalIndex> pk_keys;
-	//! The set of foreign key table's column's index
-	vector<PhysicalIndex> fk_keys;
-};
-
-//! Constraint is the base class of any type of table constraint.
-class Constraint {
-public:
-	DUCKDB_API explicit Constraint(ConstraintType type);
-	DUCKDB_API virtual ~Constraint();
-
-	ConstraintType type;
-
-public:
-	DUCKDB_API virtual string ToString() const = 0;
-	DUCKDB_API void Print() const;
-
-	DUCKDB_API virtual unique_ptr<Constraint> Copy() const = 0;
-
-	DUCKDB_API virtual void Serialize(Serializer &serializer) const;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp b/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp
deleted file mode 100644
index cba2a61fb..000000000
--- a/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/check_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-//! The CheckConstraint contains an expression that must evaluate to TRUE for
-//! every row in a table
-class CheckConstraint : public Constraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::CHECK;
-
-public:
-	DUCKDB_API explicit CheckConstraint(unique_ptr<ParsedExpression> expression);
-
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp b/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp
deleted file mode 100644
index 7601a2322..000000000
--- a/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/foreign_key_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class ForeignKeyConstraint : public Constraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::FOREIGN_KEY;
-
-public:
-	DUCKDB_API ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info);
-
-	//! The set of main key table's columns
-	vector<string> pk_columns;
-	//! The set of foreign key table's columns
-	vector<string> fk_columns;
-	ForeignKeyInfo info;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
-
-private:
-	ForeignKeyConstraint();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/constraints/list.hpp b/src/duckdb/src/include/duckdb/parser/constraints/list.hpp
deleted file mode 100644
index bec392cf7..000000000
--- a/src/duckdb/src/include/duckdb/parser/constraints/list.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "duckdb/parser/constraints/check_constraint.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
diff --git a/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp b/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp
deleted file mode 100644
index d148065d1..000000000
--- a/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/not_null_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/constraint.hpp"
-
-namespace duckdb {
-
-class NotNullConstraint : public Constraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::NOT_NULL;
-
-public:
-	DUCKDB_API explicit NotNullConstraint(LogicalIndex index);
-	DUCKDB_API ~NotNullConstraint() override;
-
-	//! Column index this constraint pertains to
-	LogicalIndex index;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp b/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp
deleted file mode 100644
index a3811160a..000000000
--- a/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/unique_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/enums/index_constraint_type.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/parser/constraint.hpp"
-
-namespace duckdb {
-
-class UniqueConstraint : public Constraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::UNIQUE;
-
-public:
-	DUCKDB_API UniqueConstraint(const LogicalIndex index, const bool is_primary_key);
-	DUCKDB_API UniqueConstraint(vector<string> columns, const bool is_primary_key);
-
-public:
-	DUCKDB_API string ToString() const override;
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
-
-	//! Returns true, if the constraint is a PRIMARY KEY constraint.
-	bool IsPrimaryKey() const;
-	//! Returns true, if the constraint is defined on a single column.
-	bool HasIndex() const;
-	//! Returns the column index on which the constraint is defined.
-	LogicalIndex GetIndex() const;
-	//! Sets the column index of the constraint.
-	void SetIndex(const LogicalIndex new_index);
-	//! Returns a constant reference to the column names on which the constraint is defined.
-	const vector<string> &GetColumnNames() const;
-	//! Returns a mutable reference to the column names on which the constraint is defined.
-	vector<string> &GetColumnNamesMutable();
-	//! Returns the column indexes on which the constraint is defined.
-	vector<LogicalIndex> GetLogicalIndexes(const ColumnList &columns) const;
-	//! Get the name of the constraint.
-	string GetName(const string &table_name) const;
-	//! Sets a single column name. Does nothing, if the name is already set.
-	void SetColumnName(const string &name);
-
-private:
-	UniqueConstraint();
-
-#ifdef DUCKDB_API_1_0
-private:
-#else
-public:
-#endif
-
-	//! The indexed column of the constraint. Only used for single-column constraints, invalid otherwise.
-	LogicalIndex index;
-	//! The names of the columns on which this constraint is defined. Only set if the index field is not set.
-	vector<string> columns;
-	//! Whether this is a PRIMARY KEY constraint, or a UNIQUE constraint.
-	bool is_primary_key;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp
deleted file mode 100644
index d8e474936..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/between_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class BetweenExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BETWEEN;
-
-public:
-	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
-	                             unique_ptr<ParsedExpression> upper);
-
-	unique_ptr<ParsedExpression> input;
-	unique_ptr<ParsedExpression> lower;
-	unique_ptr<ParsedExpression> upper;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const BetweenExpression &a, const BetweenExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return "(" + entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " +
-		       entry.upper->ToString() + ")";
-	}
-
-private:
-	BetweenExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp
deleted file mode 100644
index 6d8a380b7..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/bound_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! BoundExpression is an intermediate dummy class used by the binder. It is a ParsedExpression but holds an Expression.
-//! It represents a successfully bound expression. It is used in the Binder to prevent re-binding of already bound parts
-//! when dealing with subqueries.
-class BoundExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_EXPRESSION;
-
-public:
-	explicit BoundExpression(unique_ptr<Expression> expr);
-
-	unique_ptr<Expression> expr;
-
-public:
-	static unique_ptr<Expression> &GetExpression(ParsedExpression &expr);
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp
deleted file mode 100644
index 8478f05b8..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/case_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-struct CaseCheck {
-	unique_ptr<ParsedExpression> when_expr;
-	unique_ptr<ParsedExpression> then_expr;
-
-	void Serialize(Serializer &serializer) const;
-	static CaseCheck Deserialize(Deserializer &deserializer);
-};
-
-//! The CaseExpression represents a CASE expression in the query
-class CaseExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::CASE;
-
-public:
-	DUCKDB_API CaseExpression();
-
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const CaseExpression &a, const CaseExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string case_str = "CASE ";
-		for (auto &check : entry.case_checks) {
-			case_str += " WHEN (" + check.when_expr->ToString() + ")";
-			case_str += " THEN (" + check.then_expr->ToString() + ")";
-		}
-		case_str += " ELSE " + entry.else_expr->ToString();
-		case_str += " END";
-		return case_str;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp
deleted file mode 100644
index 7c48e0dde..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/cast_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-//! CastExpression represents a type cast from one SQL type to another SQL type
-class CastExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::CAST;
-
-public:
-	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
-
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The type to cast to
-	LogicalType cast_type;
-	//! Whether or not this is a try_cast expression
-	bool try_cast;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const CastExpression &a, const CastExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
-		       entry.cast_type.ToString() + ")";
-	}
-
-private:
-	CastExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp
deleted file mode 100644
index 6f3bcac6e..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/collate_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-//! CollateExpression represents a COLLATE statement
-class CollateExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::COLLATE;
-
-public:
-	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
-
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The collation clause
-	string collation;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const CollateExpression &a, const CollateExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-private:
-	CollateExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp
deleted file mode 100644
index 408dcaab3..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/columnref_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-struct BindingAlias;
-
-//! Represents a reference to a column from either the FROM clause or from an
-//! alias
-class ColumnRefExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::COLUMN_REF;
-
-public:
-	//! Specify both the column and table name
-	ColumnRefExpression(string column_name, string table_name);
-	//! Specify both the column and table alias
-	ColumnRefExpression(string column_name, const BindingAlias &alias);
-	//! Only specify the column name, the table name will be derived later
-	explicit ColumnRefExpression(string column_name);
-	//! Specify a set of names
-	explicit ColumnRefExpression(vector<string> column_names);
-
-	//! The stack of names in order of which they appear (column_names[0].column_names[1].column_names[2]....)
-	vector<string> column_names;
-
-public:
-	bool IsQualified() const;
-	const string &GetColumnName() const;
-	const string &GetTableName() const;
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string GetName() const override;
-	string ToString() const override;
-
-	static bool Equal(const ColumnRefExpression &a, const ColumnRefExpression &b);
-	hash_t Hash() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-private:
-	ColumnRefExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp
deleted file mode 100644
index 01371f5fd..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/comparison_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
-//! and has two children.
-class ComparisonExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::COMPARISON;
-
-public:
-	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                unique_ptr<ParsedExpression> right);
-
-	unique_ptr<ParsedExpression> left;
-	unique_ptr<ParsedExpression> right;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const ComparisonExpression &a, const ComparisonExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return StringUtil::Format("(%s %s %s)", entry.left->ToString(),
-		                          ExpressionTypeToOperator(entry.GetExpressionType()), entry.right->ToString());
-	}
-
-private:
-	explicit ComparisonExpression(ExpressionType type);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp
deleted file mode 100644
index 3e343df9f..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/conjunction_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::CONJUNCTION;
-
-public:
-	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                 unique_ptr<ParsedExpression> right);
-
-	vector<unique_ptr<ParsedExpression>> children;
-
-public:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
-
-	string ToString() const override;
-
-	static bool Equal(const ConjunctionExpression &a, const ConjunctionExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string result = "(" + entry.children[0]->ToString();
-		for (idx_t i = 1; i < entry.children.size(); i++) {
-			result += " " + ExpressionTypeToOperator(entry.GetExpressionType()) + " " + entry.children[i]->ToString();
-		}
-		return result + ")";
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp
deleted file mode 100644
index 9da6085f9..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/constant_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-//! ConstantExpression represents a constant value in the query
-class ConstantExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::CONSTANT;
-
-public:
-	DUCKDB_API explicit ConstantExpression(Value val);
-
-	//! The constant value referenced
-	Value value;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const ConstantExpression &a, const ConstantExpression &b);
-	hash_t Hash() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-private:
-	ConstantExpression();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp
deleted file mode 100644
index e7bc89b71..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/default_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::DEFAULT;
-
-public:
-	DefaultExpression();
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp
deleted file mode 100644
index 4fc292753..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/function_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-
-namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::FUNCTION;
-
-public:
-	DUCKDB_API FunctionExpression(string catalog_name, string schema_name, const string &function_name,
-	                              vector<unique_ptr<ParsedExpression>> children,
-	                              unique_ptr<ParsedExpression> filter = nullptr,
-	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
-	                              bool is_operator = false, bool export_state = false);
-	DUCKDB_API FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                              unique_ptr<ParsedExpression> filter = nullptr,
-	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
-	                              bool is_operator = false, bool export_state = false);
-
-	//! Catalog of the function
-	string catalog;
-	//! Schema of the function
-	string schema;
-	//! Function name
-	string function_name;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-	//! List of arguments to the function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter;
-	//! Modifier representing an ORDER BY, only used for aggregates
-	unique_ptr<OrderModifier> order_bys;
-	//! whether this function should export its state or not
-	bool export_state;
-
-public:
-	string ToString() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	static bool Equal(const FunctionExpression &a, const FunctionExpression &b);
-	hash_t Hash() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-	void Verify() const override;
-
-	//! Returns true, if the function has a lambda expression as a child.
-	bool IsLambdaFunction() const;
-
-public:
-	template <class T, class BASE, class ORDER_MODIFIER = OrderModifier>
-	static string ToString(const T &entry, const string &catalog, const string &schema, const string &function_name,
-	                       bool is_operator = false, bool distinct = false, BASE *filter = nullptr,
-	                       ORDER_MODIFIER *order_bys = nullptr, bool export_state = false, bool add_alias = false) {
-		if (is_operator) {
-			// built-in operator
-			D_ASSERT(!distinct);
-			if (entry.children.size() == 1) {
-				if (StringUtil::Contains(function_name, "__postfix")) {
-					return "((" + entry.children[0]->ToString() + ")" +
-					       StringUtil::Replace(function_name, "__postfix", "") + ")";
-				} else {
-					return function_name + "(" + entry.children[0]->ToString() + ")";
-				}
-			} else if (entry.children.size() == 2) {
-				return StringUtil::Format("(%s %s %s)", entry.children[0]->ToString(), function_name,
-				                          entry.children[1]->ToString());
-			}
-		}
-		// standard function call
-		string result;
-		if (!catalog.empty()) {
-			result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
-		}
-		if (!schema.empty()) {
-			result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(function_name);
-		result += "(";
-		if (distinct) {
-			result += "DISTINCT ";
-		}
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
-			return child->GetAlias().empty() || !add_alias
-			           ? child->ToString()
-			           : StringUtil::Format("%s := %s", SQLIdentifier(child->GetAlias()), child->ToString());
-		});
-		// ordered aggregate
-		if (order_bys && !order_bys->orders.empty()) {
-			if (entry.children.empty()) {
-				result += ") WITHIN GROUP (";
-			}
-			result += " ORDER BY ";
-			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
-				if (i > 0) {
-					result += ", ";
-				}
-				result += order_bys->orders[i].ToString();
-			}
-		}
-		result += ")";
-
-		// filtered aggregate
-		if (filter) {
-			result += " FILTER (WHERE " + filter->ToString() + ")";
-		}
-
-		if (export_state) {
-			result += " EXPORT_STATE";
-		}
-
-		return result;
-	}
-
-private:
-	FunctionExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp
deleted file mode 100644
index f3b2c8cc6..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/lambda_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-//! LambdaExpression represents either:
-//! 	1. A lambda function that can be used for, e.g., mapping an expression to a list
-//! 	2. An OperatorExpression with the "->" operator (JSON)
-//! Lambda expressions are written in the form of "params -> expr", e.g., "x -> x + 1"
-class LambdaExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::LAMBDA;
-
-public:
-	LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr);
-
-	//! The LHS of a lambda expression or the JSON "->"-operator. We need the context
-	//! to determine if the LHS is a list of column references (lambda parameters) or an expression (JSON)
-	unique_ptr<ParsedExpression> lhs;
-	//! The lambda or JSON expression (RHS)
-	unique_ptr<ParsedExpression> expr;
-
-public:
-	//! Returns a vector to the column references in the LHS expression, and fills the error message,
-	//! if the LHS is not a valid lambda parameter list
-	vector<reference<ParsedExpression>> ExtractColumnRefExpressions(string &error_message);
-	//! Returns the error message for an invalid lambda parameter list
-	static string InvalidParametersErrorMessage();
-	//! Returns true, if the column_name is a lambda parameter name
-	static bool IsLambdaParameter(const vector<unordered_set<string>> &lambda_params, const string &column_name);
-
-	string ToString() const override;
-	static bool Equal(const LambdaExpression &a, const LambdaExpression &b);
-	hash_t Hash() const override;
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-private:
-	LambdaExpression();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/lambdaref_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/lambdaref_expression.hpp
deleted file mode 100644
index 6fafaa5eb..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/lambdaref_expression.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/lambdaref_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-
-struct DummyBinding;
-
-//! Represents a reference to a lambda parameter
-class LambdaRefExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::LAMBDA_REF;
-
-public:
-	//! Constructs a LambdaRefExpression from a lambda_idx and a column_name. We do not specify a table name,
-	//! because we use dummy tables to bind lambda parameters
-	LambdaRefExpression(idx_t lambda_idx, string column_name_p);
-
-	//! The index of the lambda parameter in the lambda_bindings vector
-	idx_t lambda_idx;
-	//! The name of the lambda parameter (in a specific Binding in lambda_bindings)
-	string column_name;
-
-public:
-	bool IsScalar() const override;
-	string GetName() const override;
-	string ToString() const override;
-	hash_t Hash() const override;
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	//! Traverses the lambda_bindings to find a matching binding for the column_name
-	static unique_ptr<ParsedExpression> FindMatchingBinding(optional_ptr<vector<DummyBinding>> &lambda_bindings,
-	                                                        const string &parameter_name);
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/list.hpp b/src/duckdb/src/include/duckdb/parser/expression/list.hpp
deleted file mode 100644
index 0114a55a2..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/list.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/expression/between_expression.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/collate_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/lambdaref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/default_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
diff --git a/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp
deleted file mode 100644
index 3bcf38146..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/operator_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-//! Represents a built-in operator expression
-class OperatorExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::OPERATOR;
-
-public:
-	DUCKDB_API explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
-	                                       unique_ptr<ParsedExpression> right = nullptr);
-	DUCKDB_API OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-
-	vector<unique_ptr<ParsedExpression>> children;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const OperatorExpression &a, const OperatorExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		auto op = ExpressionTypeToOperator(entry.GetExpressionType());
-		if (!op.empty()) {
-			// use the operator string to represent the operator
-			D_ASSERT(entry.children.size() == 2);
-			return entry.children[0]->ToString() + " " + op + " " + entry.children[1]->ToString();
-		}
-		switch (entry.GetExpressionType()) {
-		case ExpressionType::COMPARE_IN:
-		case ExpressionType::COMPARE_NOT_IN: {
-			string op_type = entry.GetExpressionType() == ExpressionType::COMPARE_IN ? " IN " : " NOT IN ";
-			string in_child = entry.children[0]->ToString();
-			string child_list = "(";
-			for (idx_t i = 1; i < entry.children.size(); i++) {
-				if (i > 1) {
-					child_list += ", ";
-				}
-				child_list += entry.children[i]->ToString();
-			}
-			child_list += ")";
-			return "(" + in_child + op_type + child_list + ")";
-		}
-		case ExpressionType::OPERATOR_NOT: {
-			string result = "(";
-			result += ExpressionTypeToString(entry.GetExpressionType());
-			result += " ";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += ")";
-			return result;
-		}
-		case ExpressionType::GROUPING_FUNCTION:
-		case ExpressionType::OPERATOR_COALESCE: {
-			string result = ExpressionTypeToString(entry.GetExpressionType());
-			result += "(";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += ")";
-			return result;
-		}
-		case ExpressionType::OPERATOR_IS_NULL:
-			return "(" + entry.children[0]->ToString() + " IS NULL)";
-		case ExpressionType::OPERATOR_IS_NOT_NULL:
-			return "(" + entry.children[0]->ToString() + " IS NOT NULL)";
-		case ExpressionType::ARRAY_EXTRACT:
-			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + "]";
-		case ExpressionType::ARRAY_SLICE: {
-			string begin = entry.children[1]->ToString();
-			if (begin == "[]") {
-				begin = "";
-			}
-			string end = entry.children[2]->ToString();
-			if (end == "[]") {
-				if (entry.children.size() == 4) {
-					end = "-";
-				} else {
-					end = "";
-				}
-			}
-			if (entry.children.size() == 4) {
-				return entry.children[0]->ToString() + "[" + begin + ":" + end + ":" + entry.children[3]->ToString() +
-				       "]";
-			}
-			return entry.children[0]->ToString() + "[" + begin + ":" + end + "]";
-		}
-		case ExpressionType::STRUCT_EXTRACT: {
-			if (entry.children[1]->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
-				return string();
-			}
-			auto child_string = entry.children[1]->ToString();
-			D_ASSERT(child_string.size() >= 3);
-			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
-			return StringUtil::Format("(%s).%s", entry.children[0]->ToString(),
-			                          SQLIdentifier(child_string.substr(1, child_string.size() - 2)));
-		}
-		case ExpressionType::ARRAY_CONSTRUCTOR: {
-			string result = "(ARRAY[";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += "])";
-			return result;
-		}
-		default:
-			throw InternalException("Unrecognized operator type");
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp
deleted file mode 100644
index ac97ecbbf..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/parameter_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-// Parameters come in three different types:
-// auto-increment:
-//	token: '?'
-//	name: -
-//	number: 0
-// positional:
-//	token: '$<number>'
-//	name: -
-//	number: <number>
-// named:
-//	token: '$<name>'
-//	name: <name>
-//	number: 0
-enum class PreparedParamType : uint8_t { AUTO_INCREMENT, POSITIONAL, NAMED, INVALID };
-
-class ParameterExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::PARAMETER;
-
-public:
-	ParameterExpression();
-
-	string identifier;
-
-public:
-	bool IsScalar() const override {
-		return true;
-	}
-	bool HasParameter() const override {
-		return true;
-	}
-
-	string ToString() const override;
-
-	static bool Equal(const ParameterExpression &a, const ParameterExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp
deleted file mode 100644
index 9943551b0..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/positional_reference_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::POSITIONAL_REFERENCE;
-
-public:
-	DUCKDB_API explicit PositionalReferenceExpression(idx_t index);
-
-	idx_t index;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	static bool Equal(const PositionalReferenceExpression &a, const PositionalReferenceExpression &b);
-	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-private:
-	PositionalReferenceExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp
deleted file mode 100644
index c35ef2029..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/star_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/parser/qualified_name_set.hpp"
-
-namespace duckdb {
-
-//! Represents a * expression in the SELECT clause
-class StarExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::STAR;
-
-public:
-	explicit StarExpression(string relation_name = string());
-
-	//! The relation name in case of tbl.*, or empty if this is a normal *
-	string relation_name;
-	//! List of columns to exclude from the STAR expression
-	qualified_column_set_t exclude_list;
-	//! List of columns to replace with another expression
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
-	//! List of columns to rename
-	qualified_column_map_t<string> rename_list;
-	//! The expression to select the columns (regular expression or list)
-	unique_ptr<ParsedExpression> expr;
-	//! Whether or not this is a COLUMNS expression
-	bool columns = false;
-	//! Whether the columns are unpacked
-	bool unpacked = false;
-
-public:
-	string ToString() const override;
-
-	static bool Equal(const StarExpression &a, const StarExpression &b);
-	static bool IsStar(const ParsedExpression &a);
-	static bool IsColumns(const ParsedExpression &a);
-	static bool IsColumnsUnpacked(const ParsedExpression &a);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-public:
-	// these methods exist for backwards compatibility of (de)serialization
-	StarExpression(const case_insensitive_set_t &exclude_list, qualified_column_set_t qualified_set);
-
-	case_insensitive_set_t SerializedExcludeList() const;
-	qualified_column_set_t SerializedQualifiedExcludeList() const;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp
deleted file mode 100644
index b01bda765..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/subquery_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/subquery_type.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-
-namespace duckdb {
-
-//! Represents a subquery
-class SubqueryExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::SUBQUERY;
-
-public:
-	SubqueryExpression();
-
-	//! The actual subquery
-	unique_ptr<SelectStatement> subquery;
-	//! The subquery type
-	SubqueryType subquery_type;
-	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
-	//! subquery)
-	unique_ptr<ParsedExpression> child;
-	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
-	ExpressionType comparison_type;
-
-public:
-	bool HasSubquery() const override {
-		return true;
-	}
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	static bool Equal(const SubqueryExpression &a, const SubqueryExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp
deleted file mode 100644
index e41f4ad82..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp
+++ /dev/null
@@ -1,265 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/window_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-enum class WindowBoundary : uint8_t {
-	INVALID = 0,
-	UNBOUNDED_PRECEDING = 1,
-	UNBOUNDED_FOLLOWING = 2,
-	CURRENT_ROW_RANGE = 3,
-	CURRENT_ROW_ROWS = 4,
-	EXPR_PRECEDING_ROWS = 5,
-	EXPR_FOLLOWING_ROWS = 6,
-	EXPR_PRECEDING_RANGE = 7,
-	EXPR_FOLLOWING_RANGE = 8
-};
-
-//! Represents the window exclusion mode
-enum class WindowExcludeMode : uint8_t { NO_OTHER = 0, CURRENT_ROW = 1, GROUP = 2, TIES = 3 };
-
-const char *ToString(WindowBoundary value);
-
-//! The WindowExpression represents a window function in the query. They are a special case of aggregates which is why
-//! they inherit from them.
-class WindowExpression : public ParsedExpression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::WINDOW;
-
-public:
-	WindowExpression(ExpressionType type, string catalog_name, string schema_name, const string &function_name);
-
-	//! Catalog of the aggregate function
-	string catalog;
-	//! Schema of the aggregate function
-	string schema;
-	//! Name of the aggregate function
-	string function_name;
-	//! The child expression of the main window function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! The set of expressions to partition by
-	vector<unique_ptr<ParsedExpression>> partitions;
-	//! The set of ordering clauses
-	vector<OrderByNode> orders;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter_expr;
-	//! True to ignore NULL values
-	bool ignore_nulls;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! The window boundaries
-	WindowBoundary start = WindowBoundary::INVALID;
-	WindowBoundary end = WindowBoundary::INVALID;
-	//! The EXCLUDE clause
-	WindowExcludeMode exclude_clause = WindowExcludeMode::NO_OTHER;
-
-	unique_ptr<ParsedExpression> start_expr;
-	unique_ptr<ParsedExpression> end_expr;
-	//! Offset and default expressions for WINDOW_LEAD and WINDOW_LAG functions
-	unique_ptr<ParsedExpression> offset_expr;
-	unique_ptr<ParsedExpression> default_expr;
-
-	//! The set of argument ordering clauses
-	//! These are distinct from the frame ordering clauses e.g., the "x" in
-	//! FIRST_VALUE(a ORDER BY x) OVER (PARTITION BY p ORDER BY s)
-	vector<OrderByNode> arg_orders;
-
-public:
-	bool IsWindow() const override {
-		return true;
-	}
-
-	//! Convert the Expression to a String
-	string ToString() const override;
-
-	static bool Equal(const WindowExpression &a, const WindowExpression &b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-	static ExpressionType WindowToExpressionType(string &fun_name);
-
-public:
-	template <class T, class BASE, class ORDER_NODE>
-	static string ToString(const T &entry, const string &schema, const string &function_name) {
-		// Start with function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
-		result += "(";
-		if (entry.children.size()) {
-			//	Only one DISTINCT is allowed (on the first argument)
-			int distincts = entry.distinct ? 0 : 1;
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
-				return (distincts++ ? "" : "DISTINCT ") + child->ToString();
-			});
-		}
-		// Lead/Lag extra arguments
-		if (entry.offset_expr.get()) {
-			result += ", ";
-			result += entry.offset_expr->ToString();
-		}
-		if (entry.default_expr.get()) {
-			result += ", ";
-			result += entry.default_expr->ToString();
-		}
-		// ORDER BY arguments
-		if (!entry.arg_orders.empty()) {
-			result += " ORDER BY ";
-			result += StringUtil::Join(entry.arg_orders, entry.arg_orders.size(), ", ",
-			                           [](const ORDER_NODE &order) { return order.ToString(); });
-		}
-
-		// IGNORE NULLS
-		if (entry.ignore_nulls) {
-			result += " IGNORE NULLS";
-		}
-		// FILTER
-		if (entry.filter_expr) {
-			result += ") FILTER (WHERE " + entry.filter_expr->ToString();
-		}
-
-		// Over clause
-		result += ") OVER (";
-		string sep;
-
-		// Partitions
-		if (!entry.partitions.empty()) {
-			result += "PARTITION BY ";
-			result += StringUtil::Join(entry.partitions, entry.partitions.size(), ", ",
-			                           [](const unique_ptr<BASE> &partition) { return partition->ToString(); });
-			sep = " ";
-		}
-
-		// Orders
-		if (!entry.orders.empty()) {
-			result += sep;
-			result += "ORDER BY ";
-			result += StringUtil::Join(entry.orders, entry.orders.size(), ", ",
-			                           [](const ORDER_NODE &order) { return order.ToString(); });
-			sep = " ";
-		}
-
-		// Rows/Range
-		string units = "ROWS";
-		string from;
-		switch (entry.start) {
-		case WindowBoundary::CURRENT_ROW_RANGE:
-		case WindowBoundary::CURRENT_ROW_ROWS:
-			from = "CURRENT ROW";
-			units = (entry.start == WindowBoundary::CURRENT_ROW_RANGE) ? "RANGE" : "ROWS";
-			break;
-		case WindowBoundary::UNBOUNDED_PRECEDING:
-			if (entry.end != WindowBoundary::CURRENT_ROW_RANGE) {
-				from = "UNBOUNDED PRECEDING";
-			}
-			break;
-		case WindowBoundary::EXPR_PRECEDING_ROWS:
-		case WindowBoundary::EXPR_PRECEDING_RANGE:
-			from = entry.start_expr->ToString() + " PRECEDING";
-			units = (entry.start == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		case WindowBoundary::EXPR_FOLLOWING_RANGE:
-			from = entry.start_expr->ToString() + " FOLLOWING";
-			units = (entry.start == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		default:
-			throw InternalException("Unrecognized FROM in WindowExpression");
-		}
-
-		string to;
-		switch (entry.end) {
-		case WindowBoundary::CURRENT_ROW_RANGE:
-			if (entry.start != WindowBoundary::UNBOUNDED_PRECEDING) {
-				to = "CURRENT ROW";
-				units = "RANGE";
-			}
-			break;
-		case WindowBoundary::CURRENT_ROW_ROWS:
-			to = "CURRENT ROW";
-			units = "ROWS";
-			break;
-		case WindowBoundary::UNBOUNDED_PRECEDING:
-			to = "UNBOUNDED PRECEDING";
-			break;
-		case WindowBoundary::UNBOUNDED_FOLLOWING:
-			to = "UNBOUNDED FOLLOWING";
-			break;
-		case WindowBoundary::EXPR_PRECEDING_ROWS:
-		case WindowBoundary::EXPR_PRECEDING_RANGE:
-			to = entry.end_expr->ToString() + " PRECEDING";
-			units = (entry.end == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		case WindowBoundary::EXPR_FOLLOWING_RANGE:
-			to = entry.end_expr->ToString() + " FOLLOWING";
-			units = (entry.end == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		default:
-			throw InternalException("Unrecognized TO in WindowExpression");
-		}
-		if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) {
-			// if we have an explicit EXCLUDE we always need to fill in from/to
-			if (from.empty()) {
-				from = "UNBOUNDED PRECEDING";
-			}
-			if (to.empty()) {
-				to = "CURRENT ROW";
-				units = "RANGE";
-			}
-		}
-
-		if (!from.empty() || !to.empty()) {
-			result += sep + units;
-		}
-		if (!from.empty() && !to.empty()) {
-			result += " BETWEEN ";
-			result += from;
-			result += " AND ";
-			result += to;
-		} else if (!from.empty()) {
-			result += " ";
-			result += from;
-		} else if (!to.empty()) {
-			result += " ";
-			result += to;
-		}
-
-		if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) {
-			result += " EXCLUDE ";
-		}
-		switch (entry.exclude_clause) {
-		case WindowExcludeMode::CURRENT_ROW:
-			result += "CURRENT ROW";
-			break;
-		case WindowExcludeMode::GROUP:
-			result += "GROUP";
-			break;
-		case WindowExcludeMode::TIES:
-			result += "TIES";
-			break;
-		default:
-			break;
-		}
-
-		result += ")";
-
-		return result;
-	}
-
-private:
-	explicit WindowExpression(ExpressionType type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression_map.hpp b/src/duckdb/src/include/duckdb/parser/expression_map.hpp
deleted file mode 100644
index 75ecd78e8..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression_map.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/parser/base_expression.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-class Expression;
-
-template <class T>
-struct ExpressionHashFunction {
-	uint64_t operator()(const reference<T> &expr) const {
-		return (uint64_t)expr.get().Hash();
-	}
-};
-
-template <class T>
-struct ExpressionEquality {
-	bool operator()(const reference<T> &a, const reference<T> &b) const {
-		return a.get().Equals(b.get());
-	}
-};
-
-template <typename T>
-using expression_map_t =
-    unordered_map<reference<Expression>, T, ExpressionHashFunction<Expression>, ExpressionEquality<Expression>>;
-
-using expression_set_t =
-    unordered_set<reference<Expression>, ExpressionHashFunction<Expression>, ExpressionEquality<Expression>>;
-
-template <typename T>
-using parsed_expression_map_t = unordered_map<reference<ParsedExpression>, T, ExpressionHashFunction<ParsedExpression>,
-                                              ExpressionEquality<ParsedExpression>>;
-
-using parsed_expression_set_t = unordered_set<reference<ParsedExpression>, ExpressionHashFunction<ParsedExpression>,
-                                              ExpressionEquality<ParsedExpression>>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/expression_util.hpp b/src/duckdb/src/include/duckdb/parser/expression_util.hpp
deleted file mode 100644
index 24112d1f0..000000000
--- a/src/duckdb/src/include/duckdb/parser/expression_util.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/base_expression.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-class ParsedExpression;
-class Expression;
-
-class ExpressionUtil {
-public:
-	//! ListEquals: check if a list of two expressions is equal (order is important)
-	static bool ListEquals(const vector<unique_ptr<ParsedExpression>> &a,
-	                       const vector<unique_ptr<ParsedExpression>> &b);
-	static bool ListEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b);
-	//! SetEquals: check if two sets of expressions are equal (order is not important)
-	static bool SetEquals(const vector<unique_ptr<ParsedExpression>> &a, const vector<unique_ptr<ParsedExpression>> &b);
-	static bool SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b);
-
-private:
-	template <class T>
-	static bool ExpressionListEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
-	template <class T, class EXPRESSION_MAP>
-	static bool ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/group_by_node.hpp b/src/duckdb/src/include/duckdb/parser/group_by_node.hpp
deleted file mode 100644
index 02a8eeccf..000000000
--- a/src/duckdb/src/include/duckdb/parser/group_by_node.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/group_by_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-using GroupingSet = set<idx_t>;
-
-class GroupByNode {
-public:
-	//! The total set of all group expressions
-	vector<unique_ptr<ParsedExpression>> group_expressions;
-	//! The different grouping sets as they map to the group expressions
-	vector<GroupingSet> grouping_sets;
-
-public:
-	GroupByNode Copy() {
-		GroupByNode node;
-		node.group_expressions.reserve(group_expressions.size());
-		for (auto &expr : group_expressions) {
-			node.group_expressions.push_back(expr->Copy());
-		}
-		node.grouping_sets = grouping_sets;
-		return node;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp b/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp
deleted file mode 100644
index d53951105..000000000
--- a/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/keyword_helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/parser/simplified_token.hpp"
-
-namespace duckdb {
-
-class KeywordHelper {
-public:
-	//! Returns true if the given text matches a keyword of the parser
-	static bool IsKeyword(const string &text);
-
-	static KeywordCategory KeywordCategoryType(const string &text);
-
-	static string EscapeQuotes(const string &text, char quote = '"');
-
-	//! Returns true if the given string needs to be quoted when written as an identifier
-	static bool RequiresQuotes(const string &text, bool allow_caps = true);
-
-	//! Writes a string that is quoted
-	static string WriteQuoted(const string &text, char quote = '\'');
-
-	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
-	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp
deleted file mode 100644
index 7e47a2e88..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/alter_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-
-namespace duckdb {
-
-enum class AlterType : uint8_t {
-	INVALID = 0,
-	ALTER_TABLE = 1,
-	ALTER_VIEW = 2,
-	ALTER_SEQUENCE = 3,
-	CHANGE_OWNERSHIP = 4,
-	ALTER_SCALAR_FUNCTION = 5,
-	ALTER_TABLE_FUNCTION = 6,
-	SET_COMMENT = 7,
-	SET_COLUMN_COMMENT = 8
-};
-
-struct AlterEntryData {
-	AlterEntryData() {
-	}
-	AlterEntryData(string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
-	    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), name(std::move(name_p)),
-	      if_not_found(if_not_found) {
-	}
-
-	string catalog;
-	string schema;
-	string name;
-	OnEntryNotFound if_not_found;
-};
-
-struct AlterInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::ALTER_INFO;
-
-public:
-	AlterInfo(AlterType type, string catalog, string schema, string name, OnEntryNotFound if_not_found);
-	~AlterInfo() override;
-
-	AlterType type;
-	//! if exists
-	OnEntryNotFound if_not_found;
-	//! Catalog name to alter
-	string catalog;
-	//! Schema name to alter
-	string schema;
-	//! Entry name to alter
-	string name;
-	//! Allow altering internal entries
-	bool allow_internal;
-
-public:
-	virtual CatalogType GetCatalogType() const = 0;
-	virtual unique_ptr<AlterInfo> Copy() const = 0;
-	virtual string ToString() const = 0;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-
-	virtual string GetColumnName() const {
-		return "";
-	};
-
-	AlterEntryData GetAlterEntryData() const;
-	bool IsAddPrimaryKey() const;
-
-protected:
-	explicit AlterInfo(AlterType type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_scalar_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/alter_scalar_function_info.hpp
deleted file mode 100644
index f3a209462..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_scalar_function_info.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/alter_scalar_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-
-namespace duckdb {
-struct CreateScalarFunctionInfo;
-
-//===--------------------------------------------------------------------===//
-// Alter Scalar Function
-//===--------------------------------------------------------------------===//
-enum class AlterScalarFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
-
-struct AlterScalarFunctionInfo : public AlterInfo {
-	AlterScalarFunctionInfo(AlterScalarFunctionType type, AlterEntryData data);
-	~AlterScalarFunctionInfo() override;
-
-	AlterScalarFunctionType alter_scalar_function_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-};
-
-//===--------------------------------------------------------------------===//
-// AddScalarFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-struct AddScalarFunctionOverloadInfo : public AlterScalarFunctionInfo {
-	AddScalarFunctionOverloadInfo(AlterEntryData data, unique_ptr<CreateScalarFunctionInfo> new_overloads);
-	~AddScalarFunctionOverloadInfo() override;
-
-	unique_ptr<CreateScalarFunctionInfo> new_overloads;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_function_info.hpp
deleted file mode 100644
index fc7944c3f..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_function_info.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/alter_scalar_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Alter Table Function
-//===--------------------------------------------------------------------===//
-enum class AlterTableFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
-
-struct AlterTableFunctionInfo : public AlterInfo {
-	AlterTableFunctionInfo(AlterTableFunctionType type, AlterEntryData data);
-	~AlterTableFunctionInfo() override;
-
-	AlterTableFunctionType alter_table_function_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-};
-
-//===--------------------------------------------------------------------===//
-// AddTableFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-struct AddTableFunctionOverloadInfo : public AlterTableFunctionInfo {
-	AddTableFunctionOverloadInfo(AlterEntryData data, TableFunctionSet new_overloads);
-	~AddTableFunctionOverloadInfo() override;
-
-	TableFunctionSet new_overloads;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp
deleted file mode 100644
index 9506b1519..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp
+++ /dev/null
@@ -1,370 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/alter_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-
-namespace duckdb {
-
-enum class AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
-
-//===--------------------------------------------------------------------===//
-// Change Ownership
-//===--------------------------------------------------------------------===//
-struct ChangeOwnershipInfo : public AlterInfo {
-	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog, string entry_schema, string entry_name,
-	                    string owner_schema, string owner_name, OnEntryNotFound if_not_found);
-
-	// Catalog type refers to the entry type, since this struct is usually built from an
-	// ALTER <TYPE> <schema>.<name> OWNED BY <owner_schema>.<owner_name> statement
-	// here it is only possible to know the type of who is to be owned
-	CatalogType entry_catalog_type;
-
-	string owner_schema;
-	string owner_name;
-
-public:
-	CatalogType GetCatalogType() const override;
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
-
-	explicit ChangeOwnershipInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// Set Comment
-//===--------------------------------------------------------------------===//
-struct SetCommentInfo : public AlterInfo {
-	SetCommentInfo(CatalogType entry_catalog_type, string entry_catalog, string entry_schema, string entry_name,
-	               Value new_comment_value_p, OnEntryNotFound if_not_found);
-
-	CatalogType entry_catalog_type;
-	Value comment_value;
-
-public:
-	CatalogType GetCatalogType() const override;
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
-
-	explicit SetCommentInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// Alter Table
-//===--------------------------------------------------------------------===//
-enum class AlterTableType : uint8_t {
-	INVALID = 0,
-	RENAME_COLUMN = 1,
-	RENAME_TABLE = 2,
-	ADD_COLUMN = 3,
-	REMOVE_COLUMN = 4,
-	ALTER_COLUMN_TYPE = 5,
-	SET_DEFAULT = 6,
-	FOREIGN_KEY_CONSTRAINT = 7,
-	SET_NOT_NULL = 8,
-	DROP_NOT_NULL = 9,
-	SET_COLUMN_COMMENT = 10,
-	ADD_CONSTRAINT = 11
-};
-
-struct AlterTableInfo : public AlterInfo {
-	AlterTableInfo(AlterTableType type, AlterEntryData data);
-	~AlterTableInfo() override;
-
-	AlterTableType alter_table_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
-
-protected:
-	explicit AlterTableInfo(AlterTableType type);
-};
-
-//===--------------------------------------------------------------------===//
-// RenameColumnInfo
-//===--------------------------------------------------------------------===//
-struct RenameColumnInfo : public AlterTableInfo {
-	RenameColumnInfo(AlterEntryData data, string old_name_p, string new_name_p);
-	~RenameColumnInfo() override;
-
-	//! Column old name
-	string old_name;
-	//! Column new name
-	string new_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	RenameColumnInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// RenameTableInfo
-//===--------------------------------------------------------------------===//
-struct RenameTableInfo : public AlterTableInfo {
-	RenameTableInfo(AlterEntryData data, string new_name);
-	~RenameTableInfo() override;
-
-	//! Relation new name
-	string new_table_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	RenameTableInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// AddColumnInfo
-//===--------------------------------------------------------------------===//
-struct AddColumnInfo : public AlterTableInfo {
-	AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists);
-	~AddColumnInfo() override;
-
-	//! New column
-	ColumnDefinition new_column;
-	//! Whether or not an error should be thrown if the column exist
-	bool if_column_not_exists;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	explicit AddColumnInfo(ColumnDefinition new_column);
-};
-
-//===--------------------------------------------------------------------===//
-// RemoveColumnInfo
-//===--------------------------------------------------------------------===//
-struct RemoveColumnInfo : public AlterTableInfo {
-	RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade);
-	~RemoveColumnInfo() override;
-
-	//! The column to remove
-	string removed_column;
-	//! Whether or not an error should be thrown if the column does not exist
-	bool if_column_exists;
-	//! Whether or not the column should be removed if a dependency conflict arises (used by GENERATED columns)
-	bool cascade;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-	string GetColumnName() const override {
-		return removed_column;
-	}
-
-private:
-	RemoveColumnInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// ChangeColumnTypeInfo
-//===--------------------------------------------------------------------===//
-struct ChangeColumnTypeInfo : public AlterTableInfo {
-	ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
-	                     unique_ptr<ParsedExpression> expression);
-	~ChangeColumnTypeInfo() override;
-
-	//! The column name to alter
-	string column_name;
-	//! The target type of the column
-	LogicalType target_type;
-	//! The expression used for data conversion
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-	string GetColumnName() const override {
-		return column_name;
-	};
-
-private:
-	ChangeColumnTypeInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// SetDefaultInfo
-//===--------------------------------------------------------------------===//
-struct SetDefaultInfo : public AlterTableInfo {
-	SetDefaultInfo(AlterEntryData data, string column_name, unique_ptr<ParsedExpression> new_default);
-	~SetDefaultInfo() override;
-
-	//! The column name to alter
-	string column_name;
-	//! The expression used for data conversion
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	SetDefaultInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// AlterForeignKeyInfo
-//===--------------------------------------------------------------------===//
-struct AlterForeignKeyInfo : public AlterTableInfo {
-	AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns, vector<string> fk_columns,
-	                    vector<PhysicalIndex> pk_keys, vector<PhysicalIndex> fk_keys, AlterForeignKeyType type);
-	~AlterForeignKeyInfo() override;
-
-	string fk_table;
-	vector<string> pk_columns;
-	vector<string> fk_columns;
-	vector<PhysicalIndex> pk_keys;
-	vector<PhysicalIndex> fk_keys;
-	AlterForeignKeyType type;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	AlterForeignKeyInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// SetNotNullInfo
-//===--------------------------------------------------------------------===//
-struct SetNotNullInfo : public AlterTableInfo {
-	SetNotNullInfo(AlterEntryData data, string column_name);
-	~SetNotNullInfo() override;
-
-	//! The column name to alter
-	string column_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	SetNotNullInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// DropNotNullInfo
-//===--------------------------------------------------------------------===//
-struct DropNotNullInfo : public AlterTableInfo {
-	DropNotNullInfo(AlterEntryData data, string column_name);
-	~DropNotNullInfo() override;
-
-	//! The column name to alter
-	string column_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	DropNotNullInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// Alter View
-//===--------------------------------------------------------------------===//
-enum class AlterViewType : uint8_t { INVALID = 0, RENAME_VIEW = 1 };
-
-struct AlterViewInfo : public AlterInfo {
-	AlterViewInfo(AlterViewType type, AlterEntryData data);
-	~AlterViewInfo() override;
-
-	AlterViewType alter_view_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
-
-protected:
-	explicit AlterViewInfo(AlterViewType type);
-};
-
-//===--------------------------------------------------------------------===//
-// RenameViewInfo
-//===--------------------------------------------------------------------===//
-struct RenameViewInfo : public AlterViewInfo {
-	RenameViewInfo(AlterEntryData data, string new_name);
-	~RenameViewInfo() override;
-
-	//! Relation new name
-	string new_view_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterViewInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	RenameViewInfo();
-};
-
-//===--------------------------------------------------------------------===//
-// AddConstraintInfo
-//===--------------------------------------------------------------------===//
-struct AddConstraintInfo : public AlterTableInfo {
-	AddConstraintInfo(AlterEntryData data, unique_ptr<Constraint> constraint);
-	~AddConstraintInfo() override;
-
-	//! The constraint to add.
-	unique_ptr<Constraint> constraint;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-private:
-	AddConstraintInfo();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/attach_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/attach_info.hpp
deleted file mode 100644
index 835dd9a4c..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/attach_info.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/attach_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/enums/on_create_conflict.hpp"
-#include "duckdb/storage/storage_options.hpp"
-
-namespace duckdb {
-
-struct AttachInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::ATTACH_INFO;
-
-public:
-	AttachInfo() : ParseInfo(TYPE) {
-	}
-
-	//! The alias of the attached database
-	string name;
-	//! The path to the attached database
-	string path;
-	//! Set of (key, value) options
-	unordered_map<string, Value> options;
-	//! What to do on create conflict
-	OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
-
-public:
-	//! Returns the storage options
-	StorageOptions GetStorageOptions() const;
-	//! Copies this AttachInfo and returns an unique pointer to the new AttachInfo.
-	unique_ptr<AttachInfo> Copy() const;
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/bound_pragma_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/bound_pragma_info.hpp
deleted file mode 100644
index 763e98a2b..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/bound_pragma_info.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/bound_pragma_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-#include "duckdb/function/pragma_function.hpp"
-
-namespace duckdb {
-
-struct BoundPragmaInfo {
-	BoundPragmaInfo(PragmaFunction function_p, vector<Value> parameters_p, named_parameter_map_t named_parameters_p)
-	    : function(std::move(function_p)), parameters(std::move(parameters_p)),
-	      named_parameters(std::move(named_parameters_p)) {
-	}
-
-	PragmaFunction function;
-	//! Parameter list (if any)
-	vector<Value> parameters;
-	//! Named parameter list (if any)
-	named_parameter_map_t named_parameters;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/comment_on_column_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/comment_on_column_info.hpp
deleted file mode 100644
index 60aa36ef0..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/comment_on_column_info.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/comment_on_column_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-
-namespace duckdb {
-class CatalogEntryRetriever;
-class ClientContext;
-class CatalogEntry;
-
-struct SetColumnCommentInfo : public AlterInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::COMMENT_ON_COLUMN_INFO;
-
-public:
-	SetColumnCommentInfo();
-	SetColumnCommentInfo(string catalog, string schema, string name, string column_name, Value comment_value,
-	                     OnEntryNotFound if_not_found);
-
-	//! The resolved Catalog Type
-	CatalogType catalog_entry_type;
-
-	//! name of the column to comment on
-	string column_name;
-	//! The comment, can be NULL or a string
-	Value comment_value;
-
-public:
-	optional_ptr<CatalogEntry> TryResolveCatalogEntry(CatalogEntryRetriever &retriever);
-	unique_ptr<AlterInfo> Copy() const override;
-	CatalogType GetCatalogType() const override;
-	string ToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/copy_database_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/copy_database_info.hpp
deleted file mode 100644
index 09b375bd5..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/copy_database_info.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/copy_database_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-
-namespace duckdb {
-
-struct CopyDatabaseInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::COPY_DATABASE_INFO;
-
-public:
-	explicit CopyDatabaseInfo() : ParseInfo(TYPE), target_database(INVALID_CATALOG) {
-	}
-
-	explicit CopyDatabaseInfo(const string &target_database) : ParseInfo(TYPE), target_database(target_database) {
-	}
-
-	// The destination database to which catalog entries are being copied
-	string target_database;
-
-	// The catalog entries that are going to be created in the destination DB
-	vector<unique_ptr<CreateInfo>> entries;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/copy_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/copy_info.hpp
deleted file mode 100644
index 46cb8358c..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/copy_info.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/copy_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-class QueryNode;
-
-struct CopyInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::COPY_INFO;
-
-public:
-	CopyInfo() : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(DEFAULT_SCHEMA) {
-	}
-
-	//! The catalog name to copy to/from
-	string catalog;
-	//! The schema name to copy to/from
-	string schema;
-	//! The table name to copy to/from
-	string table;
-	//! List of columns to copy to/from
-	vector<string> select_list;
-	//! Whether or not this is a copy to file (false) or copy from a file (true)
-	bool is_from;
-	//! The file format of the external file
-	string format;
-	//! The file path to copy to/from
-	string file_path;
-	//! Set of (key, value) options
-	case_insensitive_map_t<vector<Value>> options;
-	// The SQL statement used instead of a table when copying data out to a file
-	unique_ptr<QueryNode> select_statement;
-
-public:
-	static string CopyOptionsToString(const string &format, const case_insensitive_map_t<vector<Value>> &options);
-
-public:
-	unique_ptr<CopyInfo> Copy() const;
-	string ToString() const;
-	string TablePartToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_aggregate_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_aggregate_function_info.hpp
deleted file mode 100644
index bcec8d7c1..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function);
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set);
-
-	AggregateFunctionSet functions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_collation_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_collation_info.hpp
deleted file mode 100644
index 09dea0570..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_collation_info.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_collation_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/function/scalar_function.hpp"
-
-namespace duckdb {
-
-struct CreateCollationInfo : public CreateInfo {
-	DUCKDB_API CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p,
-	                               bool not_required_for_equality_p);
-
-	//! The name of the collation
-	string name;
-	//! The collation function to push in case collation is required
-	ScalarFunction function;
-	//! Whether or not the collation can be combined with other collations.
-	bool combinable;
-	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
-	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
-	//! speeds up processing.
-	bool not_required_for_equality;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_copy_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_copy_function_info.hpp
deleted file mode 100644
index 40eafbc91..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_copy_function_info.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_copy_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/function/copy_function.hpp"
-
-namespace duckdb {
-
-struct CreateCopyFunctionInfo : public CreateInfo {
-	DUCKDB_API explicit CreateCopyFunctionInfo(CopyFunction function);
-
-	//! Function name
-	string name;
-	//! The table function
-	CopyFunction function;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_function_info.hpp
deleted file mode 100644
index 355a11f7d..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_function_info.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/function/function.hpp"
-
-namespace duckdb {
-
-struct FunctionDescription {
-	//! Parameter types (if any)
-	vector<LogicalType> parameter_types;
-	//! Parameter names (if any)
-	vector<string> parameter_names;
-	//! The description (if any)
-	string description;
-	//! Examples (if any)
-	vector<string> examples;
-};
-
-struct CreateFunctionInfo : public CreateInfo {
-	explicit CreateFunctionInfo(CatalogType type, string schema = DEFAULT_SCHEMA);
-
-	//! Function name
-	string name;
-	//! Function description
-	vector<FunctionDescription> descriptions;
-
-	DUCKDB_API void CopyFunctionProperties(CreateFunctionInfo &other) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp
deleted file mode 100644
index 6cc6e84ce..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_index_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/enums/index_constraint_type.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-struct CreateIndexInfo : public CreateInfo {
-	CreateIndexInfo();
-	CreateIndexInfo(const CreateIndexInfo &info);
-
-	//! The table name of the underlying table
-	string table;
-	//! The name of the index
-	string index_name;
-
-	//! Options values (WITH ...)
-	case_insensitive_map_t<Value> options;
-
-	//! The index type (ART, B+-tree, Skip-List, ...)
-	string index_type;
-	//! The index constraint type
-	IndexConstraintType constraint_type;
-	//! The column ids of the indexed table
-	vector<column_t> column_ids;
-	//! The set of expressions to index by
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> parsed_expressions;
-
-	//! The types of the logical columns (necessary for scanning the table during CREATE INDEX)
-	vector<LogicalType> scan_types;
-	//! The names of the logical columns (necessary for scanning the table during CREATE INDEX)
-	vector<string> names;
-
-public:
-	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
-	string ToString() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	vector<string> ExpressionsToList() const;
-	string ExpressionsToString() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp
deleted file mode 100644
index 1af6c9790..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/enums/on_create_conflict.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-
-namespace duckdb {
-struct AlterInfo;
-
-struct CreateInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::CREATE_INFO;
-
-public:
-	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA, string catalog_p = INVALID_CATALOG)
-	    : ParseInfo(TYPE), type(type), catalog(std::move(catalog_p)), schema(std::move(schema)),
-	      on_conflict(OnCreateConflict::ERROR_ON_CONFLICT), temporary(false), internal(false) {
-	}
-	~CreateInfo() override {
-	}
-
-	//! The to-be-created catalog type
-	CatalogType type;
-	//! The catalog name of the entry
-	string catalog;
-	//! The schema name of the entry
-	string schema;
-	//! What to do on create conflict
-	OnCreateConflict on_conflict;
-	//! Whether or not the entry is temporary
-	bool temporary;
-	//! Whether or not the entry is an internal entry
-	bool internal;
-	//! The SQL string of the CREATE statement
-	string sql;
-	//! The inherent dependencies of the created entry
-	LogicalDependencyList dependencies;
-	//! User provided comment
-	Value comment;
-	//! Key-value tags with additional metadata
-	unordered_map<string, string> tags;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	virtual unique_ptr<CreateInfo> Copy() const = 0;
-
-	DUCKDB_API void CopyProperties(CreateInfo &other) const;
-	//! Generates an alter statement from the create statement - used for OnCreateConflict::ALTER_ON_CONFLICT
-	DUCKDB_API virtual unique_ptr<AlterInfo> GetAlterInfo() const;
-
-	virtual string ToString() const {
-		throw NotImplementedException("ToString not supported for this type of CreateInfo: '%s'",
-		                              EnumUtil::ToString(info_type));
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp
deleted file mode 100644
index 2a770fa11..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_macro_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/function/macro_function.hpp"
-
-namespace duckdb {
-
-struct CreateMacroInfo : public CreateFunctionInfo {
-	explicit CreateMacroInfo(CatalogType type);
-
-	vector<unique_ptr<MacroFunction>> macros;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-
-	string ToString() const override;
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	//! This is a weird function that exists only for backwards compatibility of serialization
-	//! Essentially we used to only support a single function in the CreateMacroInfo
-	//! In order to not break backwards/forwards compatibility, we serialize the first function in the old manner
-	//! Extra functions are serialized if present in a separate field
-	vector<unique_ptr<MacroFunction>> GetAllButFirstFunction() const;
-	//! This is a weird constructor that exists only for serialization, similarly to GetAllButFirstFunction
-	CreateMacroInfo(CatalogType type, unique_ptr<MacroFunction> function,
-	                vector<unique_ptr<MacroFunction>> extra_functions);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_pragma_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_pragma_function_info.hpp
deleted file mode 100644
index 2e8d9a73d..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_pragma_function_info.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_pragma_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/function/pragma_function.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
-	DUCKDB_API explicit CreatePragmaFunctionInfo(PragmaFunction function);
-	DUCKDB_API CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions);
-
-	PragmaFunctionSet functions;
-
-public:
-	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_scalar_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_scalar_function_info.hpp
deleted file mode 100644
index 12aee6052..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_scalar_function_info.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_scalar_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CreateScalarFunctionInfo : public CreateFunctionInfo {
-	DUCKDB_API explicit CreateScalarFunctionInfo(ScalarFunction function);
-	DUCKDB_API explicit CreateScalarFunctionInfo(ScalarFunctionSet set);
-
-	ScalarFunctionSet functions;
-
-public:
-	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
-	DUCKDB_API unique_ptr<AlterInfo> GetAlterInfo() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp
deleted file mode 100644
index 39ab3a89e..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_schema_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-
-namespace duckdb {
-
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo();
-
-public:
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	unique_ptr<CreateInfo> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp
deleted file mode 100644
index dfe81249c..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_secret_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/secret/secret.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-#include "duckdb/common/named_parameter_map.hpp"
-
-namespace duckdb {
-
-struct CreateSecretInfo : public CreateInfo { // NOLINT: work-around bug in clang-tidy
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::CREATE_SECRET_INFO;
-
-public:
-	explicit CreateSecretInfo(OnCreateConflict on_conflict, SecretPersistType persist_type);
-	//! How to handle conflict
-	OnCreateConflict on_conflict;
-	//! Whether the secret can be persisted
-	SecretPersistType persist_type;
-	//! The type of secret
-	string type;
-	//! Which storage to use (empty for default)
-	string storage_type;
-	//! (optionally) the provider of the secret credentials
-	string provider;
-	//! (optionally) the name of the secret
-	string name;
-	//! (optionally) the scope of the secret
-	vector<string> scope;
-	//! Named parameter list (if any)
-	case_insensitive_map_t<Value> options;
-
-	unique_ptr<CreateInfo> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp
deleted file mode 100644
index ebb1fb452..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_sequence_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/common/limits.hpp"
-
-namespace duckdb {
-
-enum class SequenceInfo : uint8_t {
-	// Sequence start
-	SEQ_START,
-	// Sequence increment
-	SEQ_INC,
-	// Sequence minimum value
-	SEQ_MIN,
-	// Sequence maximum value
-	SEQ_MAX,
-	// Sequence cycle option
-	SEQ_CYCLE,
-	// Sequence owner table
-	SEQ_OWN
-};
-
-struct CreateSequenceInfo : public CreateInfo {
-	CreateSequenceInfo();
-
-	//! Sequence name to create
-	string name;
-	//! Usage count of the sequence
-	uint64_t usage_count;
-	//! The increment value
-	int64_t increment;
-	//! The minimum value of the sequence
-	int64_t min_value;
-	//! The maximum value of the sequence
-	int64_t max_value;
-	//! The start value of the sequence
-	int64_t start_value;
-	//! Whether or not the sequence cycles
-	bool cycle;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-
-public:
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_function_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_function_info.hpp
deleted file mode 100644
index 1e64b6c60..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_function_info.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_table_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/function/function_set.hpp"
-
-namespace duckdb {
-
-struct CreateTableFunctionInfo : public CreateFunctionInfo {
-	DUCKDB_API explicit CreateTableFunctionInfo(TableFunction function);
-	DUCKDB_API explicit CreateTableFunctionInfo(TableFunctionSet set);
-
-	//! The table functions
-	TableFunctionSet functions;
-
-public:
-	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
-	DUCKDB_API unique_ptr<AlterInfo> GetAlterInfo() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp
deleted file mode 100644
index 20a8bd788..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/catalog/catalog_entry/column_dependency_manager.hpp"
-#include "duckdb/parser/column_list.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-struct CreateTableInfo : public CreateInfo {
-	DUCKDB_API CreateTableInfo();
-	DUCKDB_API CreateTableInfo(string catalog, string schema, string name);
-	DUCKDB_API CreateTableInfo(SchemaCatalogEntry &schema, string name);
-
-	//! Table name to insert to
-	string table;
-	//! List of columns of the table
-	ColumnList columns;
-	//! List of constraints on the table
-	vector<unique_ptr<Constraint>> constraints;
-	//! CREATE TABLE as QUERY
-	unique_ptr<SelectStatement> query;
-
-public:
-	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp
deleted file mode 100644
index 6b50064a1..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_type_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-
-namespace duckdb {
-
-struct BindLogicalTypeInput {
-	ClientContext &context;
-	const LogicalType &base_type;
-	const vector<Value> &modifiers;
-};
-
-//! The type to bind type modifiers to a type
-typedef LogicalType (*bind_logical_type_function_t)(const BindLogicalTypeInput &input);
-
-struct CreateTypeInfo : public CreateInfo {
-	CreateTypeInfo();
-	CreateTypeInfo(string name_p, LogicalType type_p, bind_logical_type_function_t bind_function_p = nullptr);
-
-	//! Name of the Type
-	string name;
-	//! Logical Type
-	LogicalType type;
-	//! Used by create enum from query
-	unique_ptr<SQLStatement> query;
-	//! Bind type modifiers to the type
-	bind_logical_type_function_t bind_function;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp
deleted file mode 100644
index 272ac1169..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_view_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-struct CreateViewInfo : public CreateInfo {
-public:
-	CreateViewInfo();
-	CreateViewInfo(SchemaCatalogEntry &schema, string view_name);
-	CreateViewInfo(string catalog_p, string schema_p, string view_name);
-
-public:
-	//! View name
-	string view_name;
-	//! Aliases of the view
-	vector<string> aliases;
-	//! Return types
-	vector<LogicalType> types;
-	//! Names of the query
-	vector<string> names;
-	//! Comments on columns of the query. Note: vector can be empty when no comments are set
-	vector<Value> column_comments;
-	//! The SelectStatement of the view
-	unique_ptr<SelectStatement> query;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override;
-
-	//! Gets a bound CreateViewInfo object from a SELECT statement and a view name, schema name, etc
-	DUCKDB_API static unique_ptr<CreateViewInfo> FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info);
-	//! Gets a bound CreateViewInfo object from a CREATE VIEW statement
-	DUCKDB_API static unique_ptr<CreateViewInfo> FromCreateView(ClientContext &context, const string &sql);
-	//! Parse a SELECT statement from a SQL string
-	DUCKDB_API static unique_ptr<SelectStatement> ParseSelect(const string &sql);
-
-	DUCKDB_API void Serialize(Serializer &serializer) const override;
-	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp
deleted file mode 100644
index a97bafcb9..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/detach_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-
-namespace duckdb {
-
-struct DetachInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::DETACH_INFO;
-
-public:
-	DetachInfo();
-
-	//! The alias of the attached database
-	string name;
-	//! Whether to throw an exception if alias is not found
-	OnEntryNotFound if_not_found;
-
-public:
-	unique_ptr<DetachInfo> Copy() const;
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp
deleted file mode 100644
index 40955edcb..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/drop_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/parser/parsed_data/extra_drop_info.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-
-namespace duckdb {
-struct ExtraDropInfo;
-
-struct DropInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::DROP_INFO;
-
-public:
-	DropInfo();
-	DropInfo(const DropInfo &info);
-
-	//! The catalog type to drop
-	CatalogType type;
-	//! Catalog name to drop from, if any
-	string catalog;
-	//! Schema name to drop from, if any
-	string schema;
-	//! Element name to drop
-	string name;
-	//! Ignore if the entry does not exist instead of failing
-	OnEntryNotFound if_not_found = OnEntryNotFound::THROW_EXCEPTION;
-	//! Cascade drop (drop all dependents instead of throwing an error if there
-	//! are any)
-	bool cascade = false;
-	//! Allow dropping of internal system entries
-	bool allow_drop_internal = false;
-	//! Extra info related to this drop
-	unique_ptr<ExtraDropInfo> extra_drop_info;
-
-public:
-	virtual unique_ptr<DropInfo> Copy() const;
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp
deleted file mode 100644
index 192def09f..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/exported_table_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-struct ExportedTableData {
-	//! Name of the exported table
-	string table_name;
-
-	//! Name of the schema
-	string schema_name;
-
-	//! Name of the database
-	string database_name;
-
-	//! Path to be exported
-	string file_path;
-	//! Not Null columns, if any
-	vector<string> not_null_columns;
-
-	void Serialize(Serializer &serializer) const;
-	static ExportedTableData Deserialize(Deserializer &deserializer);
-};
-
-struct ExportedTableInfo {
-	ExportedTableInfo(TableCatalogEntry &entry, ExportedTableData table_data_p, vector<string> &not_null_columns_p);
-	ExportedTableInfo(ClientContext &context, ExportedTableData table_data);
-
-	TableCatalogEntry &entry;
-	ExportedTableData table_data;
-
-	void Serialize(Serializer &serializer) const;
-	static ExportedTableInfo Deserialize(Deserializer &deserializer);
-
-private:
-	static TableCatalogEntry &GetEntry(ClientContext &context, const ExportedTableData &table_data);
-};
-
-struct BoundExportData : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::BOUND_EXPORT_DATA;
-
-public:
-	BoundExportData() : ParseInfo(TYPE) {
-	}
-
-	vector<ExportedTableInfo> data;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/extra_drop_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/extra_drop_info.hpp
deleted file mode 100644
index 2812469de..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/extra_drop_info.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/drop_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/secret/secret.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-
-namespace duckdb {
-
-enum class ExtraDropInfoType : uint8_t {
-	INVALID = 0,
-
-	SECRET_INFO = 1
-};
-
-struct ExtraDropInfo {
-	explicit ExtraDropInfo(ExtraDropInfoType info_type) : info_type(info_type) {
-	}
-	virtual ~ExtraDropInfo() {
-	}
-
-	ExtraDropInfoType info_type;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-	virtual unique_ptr<ExtraDropInfo> Copy() const = 0;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<ExtraDropInfo> Deserialize(Deserializer &deserializer);
-};
-
-struct ExtraDropSecretInfo : public ExtraDropInfo {
-	ExtraDropSecretInfo();
-	ExtraDropSecretInfo(const ExtraDropSecretInfo &info);
-
-	//! Secret Persistence
-	SecretPersistType persist_mode;
-	//! (optional) the name of the storage to drop from
-	string secret_storage;
-
-public:
-	unique_ptr<ExtraDropInfo> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ExtraDropInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp
deleted file mode 100644
index bc092a413..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/load_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-
-namespace duckdb {
-
-enum class LoadType : uint8_t { LOAD, INSTALL, FORCE_INSTALL };
-
-struct LoadInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::LOAD_INFO;
-
-public:
-	LoadInfo() : ParseInfo(TYPE) {
-	}
-
-	string filename;
-	string repository;
-	bool repo_is_alias;
-	string version;
-	LoadType load_type;
-
-public:
-	unique_ptr<LoadInfo> Copy() const;
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp
deleted file mode 100644
index 8810c6c98..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/parse_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-
-namespace duckdb {
-
-enum class CatalogType : uint8_t;
-
-enum class ParseInfoType : uint8_t {
-	ALTER_INFO,
-	ATTACH_INFO,
-	COPY_INFO,
-	CREATE_INFO,
-	CREATE_SECRET_INFO,
-	DETACH_INFO,
-	DROP_INFO,
-	BOUND_EXPORT_DATA,
-	LOAD_INFO,
-	PRAGMA_INFO,
-	SHOW_SELECT_INFO,
-	TRANSACTION_INFO,
-	VACUUM_INFO,
-	COMMENT_ON_INFO,
-	COMMENT_ON_COLUMN_INFO,
-	COPY_DATABASE_INFO,
-	UPDATE_EXTENSIONS_INFO
-};
-
-struct ParseInfo {
-	explicit ParseInfo(ParseInfoType info_type) : info_type(info_type) {
-	}
-	virtual ~ParseInfo() {
-	}
-
-	ParseInfoType info_type;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-	static string QualifierToString(const string &catalog, const string &schema, const string &name);
-	static string TypeToString(CatalogType type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/pragma_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/pragma_info.hpp
deleted file mode 100644
index bbf01242e..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/pragma_info.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/pragma_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/named_parameter_map.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-enum class PragmaType : uint8_t { PRAGMA_STATEMENT, PRAGMA_CALL };
-
-struct PragmaInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::PRAGMA_INFO;
-
-public:
-	PragmaInfo() : ParseInfo(TYPE) {
-	}
-
-	//! Name of the PRAGMA statement
-	string name;
-	//! Parameter list (if any)
-	vector<unique_ptr<ParsedExpression>> parameters;
-	//! Named parameter list (if any)
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> named_parameters;
-
-public:
-	unique_ptr<PragmaInfo> Copy() const;
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp
deleted file mode 100644
index dadbcfe92..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/sample_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-// Invalid is 255 because previously stored databases have SampleMethods according to the current ENUMS and we need to
-// maintain that
-enum class SampleMethod : uint8_t { SYSTEM_SAMPLE = 0, BERNOULLI_SAMPLE = 1, RESERVOIR_SAMPLE = 2, INVALID = 255 };
-
-// **DEPRECATED**: Use EnumUtil directly instead.
-string SampleMethodToString(SampleMethod method);
-
-class SampleOptions {
-
-public:
-	explicit SampleOptions(int64_t seed_ = -1);
-
-	Value sample_size;
-	bool is_percentage;
-	SampleMethod method;
-	optional_idx seed = optional_idx::Invalid();
-	bool repeatable;
-
-	unique_ptr<SampleOptions> Copy();
-	void SetSeed(idx_t new_seed);
-	static bool Equals(SampleOptions *a, SampleOptions *b);
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<SampleOptions> Deserialize(Deserializer &deserializer);
-	int64_t GetSeed() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/show_select_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/show_select_info.hpp
deleted file mode 100644
index 117e8fd13..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/show_select_info.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/show_select_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-struct ShowSelectInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::SHOW_SELECT_INFO;
-
-public:
-	ShowSelectInfo() : ParseInfo(TYPE) {
-	}
-
-	//! Types of projected columns
-	vector<LogicalType> types;
-	//! The QueryNode of select query
-	unique_ptr<QueryNode> query;
-	//! Aliases of projected columns
-	vector<string> aliases;
-	//! Whether or not we are requesting a summary or a describe
-	bool is_summary;
-
-	unique_ptr<ShowSelectInfo> Copy() {
-		auto result = make_uniq<ShowSelectInfo>();
-		result->types = types;
-		result->query = query->Copy();
-		result->aliases = aliases;
-		result->is_summary = is_summary;
-		return result;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp
deleted file mode 100644
index ffbc5f128..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/transaction_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-
-namespace duckdb {
-
-enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
-
-enum class TransactionModifierType : uint8_t {
-	TRANSACTION_DEFAULT_MODIFIER,
-	TRANSACTION_READ_ONLY,
-	TRANSACTION_READ_WRITE
-};
-
-struct TransactionInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::TRANSACTION_INFO;
-
-public:
-	explicit TransactionInfo(TransactionType type);
-
-	//! The type of transaction statement
-	TransactionType type;
-	//! Whether or not a transaction can make modifications to the database
-	TransactionModifierType modifier;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-
-	string ToString() const;
-	unique_ptr<TransactionInfo> Copy() const;
-
-private:
-	TransactionInfo();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/update_extensions_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/update_extensions_info.hpp
deleted file mode 100644
index b43ab8953..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/update_extensions_info.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/update_extensions_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-
-namespace duckdb {
-
-struct UpdateExtensionsInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::UPDATE_EXTENSIONS_INFO;
-
-public:
-	UpdateExtensionsInfo() : ParseInfo(TYPE) {
-	}
-
-	vector<string> extensions_to_update;
-
-public:
-	unique_ptr<UpdateExtensionsInfo> Copy() const {
-		auto result = make_uniq<UpdateExtensionsInfo>();
-		result->extensions_to_update = extensions_to_update;
-		return result;
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp
deleted file mode 100644
index 5540d38a2..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/vacuum_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-
-struct VacuumOptions {
-	VacuumOptions() : vacuum(false), analyze(false) {
-	}
-
-	bool vacuum;
-	bool analyze;
-
-	void Serialize(Serializer &serializer) const;
-	static VacuumOptions Deserialize(Deserializer &deserializer);
-};
-
-struct VacuumInfo : public ParseInfo {
-public:
-	static constexpr const ParseInfoType TYPE = ParseInfoType::VACUUM_INFO;
-
-public:
-	explicit VacuumInfo(VacuumOptions options);
-
-	const VacuumOptions options;
-	vector<string> columns;
-	bool has_table;
-	unique_ptr<TableRef> ref;
-
-public:
-	unique_ptr<VacuumInfo> Copy();
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_expression.hpp b/src/duckdb/src/include/duckdb/parser/parsed_expression.hpp
deleted file mode 100644
index 46acfe9e6..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_expression.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/base_expression.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/expression_util.hpp"
-
-namespace duckdb {
-class Deserializer;
-class Serializer;
-
-//!  The ParsedExpression class is a base class that can represent any expression
-//!  part of a SQL statement.
-/*!
- The ParsedExpression class is a base class that can represent any expression
- part of a SQL statement. This is, for example, a column reference in a SELECT
- clause, but also operators, aggregates or filters. The Expression is emitted by the parser and does not contain any
- information about bindings to the catalog or to the types. ParsedExpressions are transformed into regular Expressions
- in the Binder.
- */
-class ParsedExpression : public BaseExpression {
-public:
-	//! Create an Expression
-	ParsedExpression(ExpressionType type, ExpressionClass expression_class) : BaseExpression(type, expression_class) {
-	}
-
-public:
-	bool IsAggregate() const override;
-	bool IsWindow() const override;
-	bool HasSubquery() const override;
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-	hash_t Hash() const override;
-
-	//! Create a copy of this expression
-	virtual unique_ptr<ParsedExpression> Copy() const = 0;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
-
-	static bool Equals(const unique_ptr<ParsedExpression> &left, const unique_ptr<ParsedExpression> &right);
-	static bool ListEquals(const vector<unique_ptr<ParsedExpression>> &left,
-	                       const vector<unique_ptr<ParsedExpression>> &right);
-
-protected:
-	//! Copy base Expression properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(const ParsedExpression &other) {
-		type = other.type;
-		expression_class = other.expression_class;
-		alias = other.alias;
-		query_location = other.query_location;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_expression_iterator.hpp b/src/duckdb/src/include/duckdb/parser/parsed_expression_iterator.hpp
deleted file mode 100644
index 2440149a3..000000000
--- a/src/duckdb/src/include/duckdb/parser/parsed_expression_iterator.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_expression_iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/tokens.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-class ParsedExpressionIterator {
-public:
-	static void EnumerateChildren(const ParsedExpression &expression,
-	                              const std::function<void(const ParsedExpression &child)> &callback);
-	static void EnumerateChildren(ParsedExpression &expr, const std::function<void(ParsedExpression &child)> &callback);
-	static void EnumerateChildren(ParsedExpression &expr,
-	                              const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-
-	static void EnumerateTableRefChildren(TableRef &ref,
-	                                      const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
-	                                      const std::function<void(TableRef &ref)> &ref_callback = DefaultRefCallback);
-	static void
-	EnumerateQueryNodeChildren(QueryNode &node,
-	                           const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
-	                           const std::function<void(TableRef &ref)> &ref_callback = DefaultRefCallback);
-
-	static void
-	EnumerateQueryNodeModifiers(QueryNode &node,
-	                            const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback);
-
-private:
-	static void DefaultRefCallback(TableRef &ref) {}; // NOP
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parser.hpp b/src/duckdb/src/include/duckdb/parser/parser.hpp
deleted file mode 100644
index 54cf89fb7..000000000
--- a/src/duckdb/src/include/duckdb/parser/parser.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parser.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/parser/simplified_token.hpp"
-#include "duckdb/parser/parser_options.hpp"
-
-namespace duckdb_libpgquery {
-struct PGNode;
-struct PGList;
-} // namespace duckdb_libpgquery
-
-namespace duckdb {
-
-class GroupByNode;
-
-//! The parser is responsible for parsing the query and converting it into a set
-//! of parsed statements. The parsed statements can then be converted into a
-//! plan and executed.
-class Parser {
-public:
-	explicit Parser(ParserOptions options = ParserOptions());
-
-	//! The parsed SQL statements from an invocation to ParseQuery.
-	vector<unique_ptr<SQLStatement>> statements;
-
-public:
-	//! Attempts to parse a query into a series of SQL statements. Returns
-	//! whether or not the parsing was successful. If the parsing was
-	//! successful, the parsed statements will be stored in the statements
-	//! variable.
-	void ParseQuery(const string &query);
-
-	//! Tokenize a query, returning the raw tokens together with their locations
-	static vector<SimplifiedToken> Tokenize(const string &query);
-
-	//! Tokenize an error message, returning the raw tokens together with their locations
-	static vector<SimplifiedToken> TokenizeError(const string &error_msg);
-
-	//! Returns true if the given text matches a keyword of the parser
-	static KeywordCategory IsKeyword(const string &text);
-	//! Returns a list of all keywords in the parser
-	static vector<ParserKeyword> KeywordList();
-
-	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
-	DUCKDB_API static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
-	                                                                           ParserOptions options = ParserOptions());
-	//! Parses a list of GROUP BY expressions
-	static GroupByNode ParseGroupByList(const string &group_by, ParserOptions options = ParserOptions());
-	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
-	static vector<OrderByNode> ParseOrderList(const string &select_list, ParserOptions options = ParserOptions());
-	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)
-	static void ParseUpdateList(const string &update_list, vector<string> &update_columns,
-	                            vector<unique_ptr<ParsedExpression>> &expressions,
-	                            ParserOptions options = ParserOptions());
-	//! Parses a VALUES list (i.e. the list of expressions after a VALUES clause)
-	static vector<vector<unique_ptr<ParsedExpression>>> ParseValuesList(const string &value_list,
-	                                                                    ParserOptions options = ParserOptions());
-	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
-	static ColumnList ParseColumnList(const string &column_list, ParserOptions options = ParserOptions());
-
-	static bool StripUnicodeSpaces(const string &query_str, string &new_query);
-
-private:
-	ParserOptions options;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parser_extension.hpp b/src/duckdb/src/include/duckdb/parser/parser_extension.hpp
deleted file mode 100644
index 164a45c34..000000000
--- a/src/duckdb/src/include/duckdb/parser/parser_extension.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parser_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/function/table_function.hpp"
-
-namespace duckdb {
-
-//! The ParserExtensionInfo holds static information relevant to the parser extension
-//! It is made available in the parse_function, and will be kept alive as long as the database system is kept alive
-struct ParserExtensionInfo {
-	virtual ~ParserExtensionInfo() {
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Parse
-//===--------------------------------------------------------------------===//
-enum class ParserExtensionResultType : uint8_t { PARSE_SUCCESSFUL, DISPLAY_ORIGINAL_ERROR, DISPLAY_EXTENSION_ERROR };
-
-//! The ParserExtensionParseData holds the result of a successful parse step
-//! It will be passed along to the subsequent plan function
-struct ParserExtensionParseData {
-	virtual ~ParserExtensionParseData() {
-	}
-
-	virtual unique_ptr<ParserExtensionParseData> Copy() const = 0;
-	virtual string ToString() const = 0;
-};
-
-struct ParserExtensionParseResult {
-	ParserExtensionParseResult() : type(ParserExtensionResultType::DISPLAY_ORIGINAL_ERROR) {
-	}
-	explicit ParserExtensionParseResult(string error_p)
-	    : type(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), error(std::move(error_p)) {
-	}
-	explicit ParserExtensionParseResult(unique_ptr<ParserExtensionParseData> parse_data_p)
-	    : type(ParserExtensionResultType::PARSE_SUCCESSFUL), parse_data(std::move(parse_data_p)) {
-	}
-
-	//! Whether or not parsing was successful
-	ParserExtensionResultType type;
-	//! The parse data (if successful)
-	unique_ptr<ParserExtensionParseData> parse_data;
-	//! The error message (if unsuccessful)
-	string error;
-	//! The error location (if unsuccessful)
-	optional_idx error_location;
-};
-
-typedef ParserExtensionParseResult (*parse_function_t)(ParserExtensionInfo *info, const string &query);
-//===--------------------------------------------------------------------===//
-// Plan
-//===--------------------------------------------------------------------===//
-struct ParserExtensionPlanResult { // NOLINT: work-around bug in clang-tidy
-	//! The table function to execute
-	TableFunction function;
-	//! Parameters to the function
-	vector<Value> parameters;
-	//! The set of databases that will be modified by this statement (empty for a read-only statement)
-	unordered_map<string, StatementProperties::CatalogIdentity> modified_databases;
-	//! Whether or not the statement requires a valid transaction to be executed
-	bool requires_valid_transaction = true;
-	//! What type of result set the statement returns
-	StatementReturnType return_type = StatementReturnType::NOTHING;
-};
-
-typedef ParserExtensionPlanResult (*plan_function_t)(ParserExtensionInfo *info, ClientContext &context,
-                                                     unique_ptr<ParserExtensionParseData> parse_data);
-
-//===--------------------------------------------------------------------===//
-// ParserExtension
-//===--------------------------------------------------------------------===//
-class ParserExtension {
-public:
-	//! The parse function of the parser extension.
-	//! Takes a query string as input and returns ParserExtensionParseData (on success) or an error
-	parse_function_t parse_function;
-
-	//! The plan function of the parser extension
-	//! Takes as input the result of the parse_function, and outputs various properties of the resulting plan
-	plan_function_t plan_function;
-
-	//! Additional parser info passed to the parse function
-	shared_ptr<ParserExtensionInfo> parser_info;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/parser_options.hpp b/src/duckdb/src/include/duckdb/parser/parser_options.hpp
deleted file mode 100644
index d388fb116..000000000
--- a/src/duckdb/src/include/duckdb/parser/parser_options.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parser_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-class ParserExtension;
-
-struct ParserOptions {
-	bool preserve_identifier_case = true;
-	bool integer_division = false;
-	idx_t max_expression_depth = 1000;
-	const vector<ParserExtension> *extensions = nullptr;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/qualified_name.hpp b/src/duckdb/src/include/duckdb/parser/qualified_name.hpp
deleted file mode 100644
index b17abbab6..000000000
--- a/src/duckdb/src/include/duckdb/parser/qualified_name.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/qualified_name.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/exception/parser_exception.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/binding_alias.hpp"
-
-namespace duckdb {
-
-struct QualifiedName {
-	string catalog;
-	string schema;
-	string name;
-
-	//! Parse the (optional) schema and a name from a string in the format of e.g. "schema"."table"; if there is no dot
-	//! the schema will be set to INVALID_SCHEMA
-	static QualifiedName Parse(const string &input);
-	string ToString() const;
-};
-
-struct QualifiedColumnName {
-	QualifiedColumnName();
-	QualifiedColumnName(string column_p); // NOLINT: allow implicit conversion from string to column name
-	QualifiedColumnName(string table_p, string column_p);
-	QualifiedColumnName(const BindingAlias &alias, string column_p);
-
-	string catalog;
-	string schema;
-	string table;
-	string column;
-
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const;
-	static QualifiedColumnName Deserialize(Deserializer &deserializer);
-
-	bool IsQualified() const;
-
-	bool operator==(const QualifiedColumnName &rhs) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/qualified_name_set.hpp b/src/duckdb/src/include/duckdb/parser/qualified_name_set.hpp
deleted file mode 100644
index c17cde85d..000000000
--- a/src/duckdb/src/include/duckdb/parser/qualified_name_set.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/qualified_name_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/unordered_set.hpp"
-
-namespace duckdb {
-
-struct QualifiedColumnHashFunction {
-	uint64_t operator()(const QualifiedColumnName &a) const {
-		// hash only on the column name - since we match based on the shortest possible match
-		return StringUtil::CIHash(a.column);
-	}
-};
-
-struct QualifiedColumnEquality {
-	bool operator()(const QualifiedColumnName &a, const QualifiedColumnName &b) const {
-		// qualified column names follow a prefix comparison
-		// so "tbl.i"  and "i" are equivalent, as are "schema.tbl.i" and "i"
-		// but "tbl.i" and "tbl2.i" are not equivalent
-		if (!a.catalog.empty() && !b.catalog.empty() && !StringUtil::CIEquals(a.catalog, b.catalog)) {
-			return false;
-		}
-		if (!a.schema.empty() && !b.schema.empty() && !StringUtil::CIEquals(a.schema, b.schema)) {
-			return false;
-		}
-		if (!a.table.empty() && !b.table.empty() && !StringUtil::CIEquals(a.table, b.table)) {
-			return false;
-		}
-		return StringUtil::CIEquals(a.column, b.column);
-	}
-};
-
-using qualified_column_set_t = unordered_set<QualifiedColumnName, QualifiedColumnHashFunction, QualifiedColumnEquality>;
-
-template <class T>
-using qualified_column_map_t =
-    unordered_map<QualifiedColumnName, T, QualifiedColumnHashFunction, QualifiedColumnEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/query_error_context.hpp b/src/duckdb/src/include/duckdb/parser/query_error_context.hpp
deleted file mode 100644
index cec72b142..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_error_context.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_error_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/exception_format_value.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-class QueryErrorContext {
-public:
-	explicit QueryErrorContext(optional_idx query_location_p = optional_idx()) : query_location(query_location_p) {
-	}
-
-	//! The location in which the error should be thrown
-	optional_idx query_location;
-
-public:
-	static string Format(const string &query, const string &error_message, optional_idx error_loc,
-	                     bool add_line_indicator = true);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/query_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node.hpp
deleted file mode 100644
index ec03da095..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_node.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/parser/common_table_expression_info.hpp"
-#include "duckdb/common/insertion_order_preserving_map.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-class Deserializer;
-class Serializer;
-
-enum class QueryNodeType : uint8_t {
-	SELECT_NODE = 1,
-	SET_OPERATION_NODE = 2,
-	BOUND_SUBQUERY_NODE = 3,
-	RECURSIVE_CTE_NODE = 4,
-	CTE_NODE = 5
-};
-
-struct CommonTableExpressionInfo;
-
-class CommonTableExpressionMap {
-public:
-	CommonTableExpressionMap();
-
-	InsertionOrderPreservingMap<unique_ptr<CommonTableExpressionInfo>> map;
-
-public:
-	string ToString() const;
-	CommonTableExpressionMap Copy() const;
-
-	void Serialize(Serializer &serializer) const;
-	// static void Deserialize(Deserializer &deserializer, CommonTableExpressionMap &ret);
-	static CommonTableExpressionMap Deserialize(Deserializer &deserializer);
-};
-
-class QueryNode {
-public:
-	explicit QueryNode(QueryNodeType type) : type(type) {
-	}
-	virtual ~QueryNode() {
-	}
-
-	//! The type of the query node, either SetOperation or Select
-	QueryNodeType type;
-	//! The set of result modifiers associated with this query node
-	vector<unique_ptr<ResultModifier>> modifiers;
-	//! CTEs (used by SelectNode and SetOperationNode)
-	CommonTableExpressionMap cte_map;
-
-	virtual const vector<unique_ptr<ParsedExpression>> &GetSelectList() const = 0;
-
-public:
-	//! Convert the query node to a string
-	virtual string ToString() const = 0;
-
-	virtual bool Equals(const QueryNode *other) const;
-
-	//! Create a copy of this QueryNode
-	virtual unique_ptr<QueryNode> Copy() const = 0;
-
-	string ResultModifiersToString() const;
-
-	//! Adds a distinct modifier to the query node
-	void AddDistinct();
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<QueryNode> Deserialize(Deserializer &deserializer);
-
-protected:
-	//! Copy base QueryNode properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(QueryNode &other) const;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast query node to type - query node type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast query node to type - query node type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/query_node/cte_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node/cte_node.hpp
deleted file mode 100644
index b41b194a5..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_node/cte_node.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class CTENode : public QueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::CTE_NODE;
-
-public:
-	CTENode() : QueryNode(QueryNodeType::CTE_NODE) {
-	}
-
-	string ctename;
-	//! The query of the CTE
-	unique_ptr<QueryNode> query;
-	//! Child
-	unique_ptr<QueryNode> child;
-	//! Aliases of the CTE node
-	vector<string> aliases;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return query->GetSelectList();
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-	//! Deserializes a blob back into a QueryNode
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/query_node/list.hpp b/src/duckdb/src/include/duckdb/parser/query_node/list.hpp
deleted file mode 100644
index 94bfd3438..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_node/list.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
diff --git a/src/duckdb/src/include/duckdb/parser/query_node/recursive_cte_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node/recursive_cte_node.hpp
deleted file mode 100644
index a69bf0032..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_node/recursive_cte_node.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/recursive_cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class RecursiveCTENode : public QueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::RECURSIVE_CTE_NODE;
-
-public:
-	RecursiveCTENode() : QueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
-	}
-
-	string ctename;
-	bool union_all;
-	//! The left side of the set operation
-	unique_ptr<QueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<QueryNode> right;
-	//! Aliases of the recursive CTE node
-	vector<string> aliases;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return left->GetSelectList();
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-	//! Deserializes a blob back into a QueryNode
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp
deleted file mode 100644
index 62aa9c0b2..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/select_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/common/enums/aggregate_handling.hpp"
-
-namespace duckdb {
-
-//! SelectNode represents a standard SELECT statement
-class SelectNode : public QueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::SELECT_NODE;
-
-public:
-	DUCKDB_API SelectNode();
-
-	//! The projection list
-	vector<unique_ptr<ParsedExpression>> select_list;
-	//! The FROM clause
-	unique_ptr<TableRef> from_table;
-	//! The WHERE clause
-	unique_ptr<ParsedExpression> where_clause;
-	//! list of groups
-	GroupByNode groups;
-	//! HAVING clause
-	unique_ptr<ParsedExpression> having;
-	//! QUALIFY clause
-	unique_ptr<ParsedExpression> qualify;
-	//! Aggregate handling during binding
-	AggregateHandling aggregate_handling;
-	//! The SAMPLE clause
-	unique_ptr<SampleOptions> sample;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return select_list;
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-
-	//! Deserializes a blob back into a QueryNode
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<QueryNode> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp
deleted file mode 100644
index 02f2d371d..000000000
--- a/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/set_operation_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_operation_type.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class SetOperationNode : public QueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::SET_OPERATION_NODE;
-
-public:
-	SetOperationNode() : QueryNode(QueryNodeType::SET_OPERATION_NODE) {
-	}
-
-	//! The type of set operation
-	SetOperationType setop_type = SetOperationType::NONE;
-	//! whether the ALL modifier was used or not
-	bool setop_all = false;
-	//! The left side of the set operation
-	unique_ptr<QueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<QueryNode> right;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return left->GetSelectList();
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-	//! Deserializes a blob back into a QueryNode
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/result_modifier.hpp b/src/duckdb/src/include/duckdb/parser/result_modifier.hpp
deleted file mode 100644
index f1d796527..000000000
--- a/src/duckdb/src/include/duckdb/parser/result_modifier.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/result_modifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/enums/order_type.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-class Deserializer;
-class Serializer;
-
-enum class ResultModifierType : uint8_t {
-	LIMIT_MODIFIER = 1,
-	ORDER_MODIFIER = 2,
-	DISTINCT_MODIFIER = 3,
-	LIMIT_PERCENT_MODIFIER = 4
-};
-
-const char *ToString(ResultModifierType value);
-ResultModifierType ResultModifierFromString(const char *value);
-
-//! A ResultModifier
-class ResultModifier {
-public:
-	explicit ResultModifier(ResultModifierType type) : type(type) {
-	}
-	virtual ~ResultModifier() {
-	}
-
-	ResultModifierType type;
-
-public:
-	//! Returns true if the two result modifiers are equivalent
-	virtual bool Equals(const ResultModifier &other) const;
-
-	//! Create a copy of this ResultModifier
-	virtual unique_ptr<ResultModifier> Copy() const = 0;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast result modifier to type - result modifier type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast result modifier to type - result modifier type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//! Single node in ORDER BY statement
-struct OrderByNode {
-	OrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<ParsedExpression> expression)
-	    : type(type), null_order(null_order), expression(std::move(expression)) {
-	}
-
-	//! Sort order, ASC or DESC
-	OrderType type;
-	//! The NULL sort order, NULLS_FIRST or NULLS_LAST
-	OrderByNullType null_order;
-	//! Expression to order by
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const;
-	static OrderByNode Deserialize(Deserializer &deserializer);
-};
-
-class LimitModifier : public ResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_MODIFIER;
-
-public:
-	LimitModifier() : ResultModifier(ResultModifierType::LIMIT_MODIFIER) {
-	}
-
-	//! LIMIT count
-	unique_ptr<ParsedExpression> limit;
-	//! OFFSET
-	unique_ptr<ParsedExpression> offset;
-
-public:
-	bool Equals(const ResultModifier &other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &deserializer);
-};
-
-class OrderModifier : public ResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::ORDER_MODIFIER;
-
-public:
-	OrderModifier() : ResultModifier(ResultModifierType::ORDER_MODIFIER) {
-	}
-
-	//! List of order nodes
-	vector<OrderByNode> orders;
-
-public:
-	bool Equals(const ResultModifier &other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &deserializer);
-
-	static bool Equals(const unique_ptr<OrderModifier> &left, const unique_ptr<OrderModifier> &right);
-};
-
-class DistinctModifier : public ResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::DISTINCT_MODIFIER;
-
-public:
-	DistinctModifier() : ResultModifier(ResultModifierType::DISTINCT_MODIFIER) {
-	}
-
-	//! list of distinct on targets (if any)
-	vector<unique_ptr<ParsedExpression>> distinct_on_targets;
-
-public:
-	bool Equals(const ResultModifier &other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &deserializer);
-};
-
-class LimitPercentModifier : public ResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_PERCENT_MODIFIER;
-
-public:
-	LimitPercentModifier() : ResultModifier(ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-	}
-
-	//! LIMIT %
-	unique_ptr<ParsedExpression> limit;
-	//! OFFSET
-	unique_ptr<ParsedExpression> offset;
-
-public:
-	bool Equals(const ResultModifier &other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/simplified_token.hpp b/src/duckdb/src/include/duckdb/parser/simplified_token.hpp
deleted file mode 100644
index 7a50824d0..000000000
--- a/src/duckdb/src/include/duckdb/parser/simplified_token.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/simplified_token.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-//! Simplified tokens are a simplified (dense) representation of the lexer
-//! Used for simple syntax highlighting in the tests
-enum class SimplifiedTokenType : uint8_t {
-	SIMPLIFIED_TOKEN_IDENTIFIER,
-	SIMPLIFIED_TOKEN_NUMERIC_CONSTANT,
-	SIMPLIFIED_TOKEN_STRING_CONSTANT,
-	SIMPLIFIED_TOKEN_OPERATOR,
-	SIMPLIFIED_TOKEN_KEYWORD,
-	SIMPLIFIED_TOKEN_COMMENT,
-	SIMPLIFIED_TOKEN_ERROR
-};
-
-struct SimplifiedToken {
-	SimplifiedTokenType type;
-	idx_t start;
-};
-
-enum class KeywordCategory : uint8_t {
-	KEYWORD_RESERVED,
-	KEYWORD_UNRESERVED,
-	KEYWORD_TYPE_FUNC,
-	KEYWORD_COL_NAME,
-	KEYWORD_NONE
-};
-
-struct ParserKeyword {
-	string name;
-	KeywordCategory category;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/sql_statement.hpp b/src/duckdb/src/include/duckdb/parser/sql_statement.hpp
deleted file mode 100644
index b9d03a07e..000000000
--- a/src/duckdb/src/include/duckdb/parser/sql_statement.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/sql_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/named_parameter_map.hpp"
-
-namespace duckdb {
-
-//! SQLStatement is the base class of any type of SQL statement.
-class SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::INVALID_STATEMENT;
-
-public:
-	explicit SQLStatement(StatementType type) : type(type) {
-	}
-	virtual ~SQLStatement() {
-	}
-
-	//! The statement type
-	StatementType type;
-	//! The statement location within the query string
-	idx_t stmt_location = 0;
-	//! The statement length within the query string
-	idx_t stmt_length = 0;
-	//! The map of named parameter to param index
-	case_insensitive_map_t<idx_t> named_param_map;
-	//! The query text that corresponds to this SQL statement
-	string query;
-
-protected:
-	SQLStatement(const SQLStatement &other) = default;
-
-public:
-	virtual string ToString() const = 0;
-	//! Create a copy of this SelectStatement
-	DUCKDB_API virtual unique_ptr<SQLStatement> Copy() const = 0;
-
-public:
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE && TARGET::TYPE != StatementType::INVALID_STATEMENT) {
-			throw InternalException("Failed to cast statement to type - statement type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE && TARGET::TYPE != StatementType::INVALID_STATEMENT) {
-			throw InternalException("Failed to cast statement to type - statement type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/alter_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/alter_statement.hpp
deleted file mode 100644
index 08b26eb47..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/alter_statement.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/alter_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class AlterStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::ALTER_STATEMENT;
-
-public:
-	AlterStatement();
-
-	unique_ptr<AlterInfo> info;
-
-protected:
-	AlterStatement(const AlterStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/attach_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/attach_statement.hpp
deleted file mode 100644
index 6ee7fb4e5..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/attach_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/attach_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class AttachStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::ATTACH_STATEMENT;
-
-public:
-	AttachStatement();
-
-	unique_ptr<AttachInfo> info;
-
-protected:
-	AttachStatement(const AttachStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/call_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/call_statement.hpp
deleted file mode 100644
index afd5d256a..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/call_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/call_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class CallStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::CALL_STATEMENT;
-
-public:
-	CallStatement();
-
-	unique_ptr<ParsedExpression> function;
-
-protected:
-	CallStatement(const CallStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/copy_database_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/copy_database_statement.hpp
deleted file mode 100644
index d206bc5f6..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/copy_database_statement.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/copy_database_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-enum class CopyDatabaseType { COPY_SCHEMA, COPY_DATA };
-
-class CopyDatabaseStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::COPY_DATABASE_STATEMENT;
-
-public:
-	CopyDatabaseStatement(string from_database, string to_database, CopyDatabaseType copy_type);
-
-	string from_database;
-	string to_database;
-	CopyDatabaseType copy_type;
-
-protected:
-	CopyDatabaseStatement(const CopyDatabaseStatement &other);
-
-public:
-	DUCKDB_API unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-
-private:
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/copy_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/copy_statement.hpp
deleted file mode 100644
index b9318bd6e..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/copy_statement.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/copy_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-enum class CopyToType : uint8_t { COPY_TO_FILE, EXPORT_DATABASE };
-
-class CopyStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::COPY_STATEMENT;
-
-public:
-	CopyStatement();
-
-	unique_ptr<CopyInfo> info;
-
-	string ToString() const override;
-
-protected:
-	CopyStatement(const CopyStatement &other);
-
-public:
-	DUCKDB_API unique_ptr<SQLStatement> Copy() const override;
-
-private:
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/create_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/create_statement.hpp
deleted file mode 100644
index 74177d873..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/create_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/create_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class CreateStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::CREATE_STATEMENT;
-
-public:
-	CreateStatement();
-
-	unique_ptr<CreateInfo> info;
-
-protected:
-	CreateStatement(const CreateStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/delete_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/delete_statement.hpp
deleted file mode 100644
index b1dcd72f8..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/delete_statement.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/delete_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-class DeleteStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::DELETE_STATEMENT;
-
-public:
-	DeleteStatement();
-
-	unique_ptr<ParsedExpression> condition;
-	unique_ptr<TableRef> table;
-	vector<unique_ptr<TableRef>> using_clauses;
-	vector<unique_ptr<ParsedExpression>> returning_list;
-	//! CTEs
-	CommonTableExpressionMap cte_map;
-
-protected:
-	DeleteStatement(const DeleteStatement &other);
-
-public:
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/detach_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/detach_statement.hpp
deleted file mode 100644
index 64ab65cf1..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/detach_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/detach_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/detach_info.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class DetachStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::DETACH_STATEMENT;
-
-public:
-	DetachStatement();
-
-	unique_ptr<DetachInfo> info;
-
-protected:
-	DetachStatement(const DetachStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/drop_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/drop_statement.hpp
deleted file mode 100644
index 8b865494e..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/drop_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/drop_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class DropStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::DROP_STATEMENT;
-
-public:
-	DropStatement();
-
-	unique_ptr<DropInfo> info;
-
-protected:
-	DropStatement(const DropStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/execute_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/execute_statement.hpp
deleted file mode 100644
index 2a15165dc..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/execute_statement.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/execute_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class ExecuteStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::EXECUTE_STATEMENT;
-
-public:
-	ExecuteStatement();
-
-	string name;
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> named_values;
-
-protected:
-	ExecuteStatement(const ExecuteStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/explain_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/explain_statement.hpp
deleted file mode 100644
index 7a30b6b64..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/explain_statement.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/explain_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
-
-namespace duckdb {
-
-enum class ExplainType : uint8_t { EXPLAIN_STANDARD, EXPLAIN_ANALYZE };
-
-class ExplainStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::EXPLAIN_STATEMENT;
-
-public:
-	explicit ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD,
-	                          ExplainFormat explain_format = ExplainFormat::DEFAULT);
-
-	unique_ptr<SQLStatement> stmt;
-	ExplainType explain_type;
-	ExplainFormat explain_format = ExplainFormat::DEFAULT;
-
-protected:
-	ExplainStatement(const ExplainStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string OptionsToString() const;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/export_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/export_statement.hpp
deleted file mode 100644
index 97430a930..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/export_statement.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/export_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-
-namespace duckdb {
-
-class ExportStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::EXPORT_STATEMENT;
-
-public:
-	explicit ExportStatement(unique_ptr<CopyInfo> info);
-
-	unique_ptr<CopyInfo> info;
-	string database;
-
-protected:
-	ExportStatement(const ExportStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/extension_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/extension_statement.hpp
deleted file mode 100644
index ddc2aab27..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/extension_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/extension_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parser_extension.hpp"
-
-namespace duckdb {
-
-class ExtensionStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::EXTENSION_STATEMENT;
-
-public:
-	ExtensionStatement(ParserExtension extension, unique_ptr<ParserExtensionParseData> parse_data);
-
-	//! The ParserExtension this statement was generated from
-	ParserExtension extension;
-	//! The parse data for this specific statement
-	unique_ptr<ParserExtensionParseData> parse_data;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp
deleted file mode 100644
index 8174b5cb2..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/insert_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-
-namespace duckdb {
-class ExpressionListRef;
-class UpdateSetInfo;
-
-enum class OnConflictAction : uint8_t {
-	THROW,
-	NOTHING,
-	UPDATE,
-	REPLACE // Only used in transform/bind step, changed to UPDATE later
-};
-
-enum class InsertColumnOrder : uint8_t { INSERT_BY_POSITION = 0, INSERT_BY_NAME = 1 };
-
-class OnConflictInfo {
-public:
-	OnConflictInfo();
-
-public:
-	unique_ptr<OnConflictInfo> Copy() const;
-
-public:
-	OnConflictAction action_type;
-
-	vector<string> indexed_columns;
-	//! The SET information (if action_type == UPDATE)
-	unique_ptr<UpdateSetInfo> set_info;
-	//! The condition determining whether we apply the DO .. for conflicts that arise
-	unique_ptr<ParsedExpression> condition;
-
-protected:
-	OnConflictInfo(const OnConflictInfo &other);
-};
-
-class InsertStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::INSERT_STATEMENT;
-
-public:
-	InsertStatement();
-
-	//! The select statement to insert from
-	unique_ptr<SelectStatement> select_statement;
-	//! Column names to insert into
-	vector<string> columns;
-
-	//! Table name to insert to
-	string table;
-	//! Schema name to insert to
-	string schema;
-	//! The catalog name to insert to
-	string catalog;
-
-	//! keep track of optional returningList if statement contains a RETURNING keyword
-	vector<unique_ptr<ParsedExpression>> returning_list;
-
-	unique_ptr<OnConflictInfo> on_conflict_info;
-	unique_ptr<TableRef> table_ref;
-
-	//! CTEs
-	CommonTableExpressionMap cte_map;
-
-	//! Whether or not this a DEFAULT VALUES
-	bool default_values = false;
-
-	//! INSERT BY POSITION or INSERT BY NAME
-	InsertColumnOrder column_order = InsertColumnOrder::INSERT_BY_POSITION;
-
-protected:
-	InsertStatement(const InsertStatement &other);
-
-public:
-	static string OnConflictActionToString(OnConflictAction action);
-
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-
-	//! If the INSERT statement is inserted DIRECTLY from a values list (i.e. INSERT INTO tbl VALUES (...)) this returns
-	//! the expression list Otherwise, this returns NULL
-	optional_ptr<ExpressionListRef> GetValuesList() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/list.hpp b/src/duckdb/src/include/duckdb/parser/statement/list.hpp
deleted file mode 100644
index a0d04ce59..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/list.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/statement/attach_statement.hpp"
-#include "duckdb/parser/statement/call_statement.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/statement/copy_database_statement.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/statement/delete_statement.hpp"
-#include "duckdb/parser/statement/detach_statement.hpp"
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/parser/statement/execute_statement.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/parser/statement/extension_statement.hpp"
-#include "duckdb/parser/statement/export_statement.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/statement/load_statement.hpp"
-#include "duckdb/parser/statement/logical_plan_statement.hpp"
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/statement/prepare_statement.hpp"
-#include "duckdb/parser/statement/relation_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/statement/set_statement.hpp"
-#include "duckdb/parser/statement/transaction_statement.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/parser/statement/update_extensions_statement.hpp"
-#include "duckdb/parser/statement/vacuum_statement.hpp"
diff --git a/src/duckdb/src/include/duckdb/parser/statement/load_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/load_statement.hpp
deleted file mode 100644
index 3667adb79..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/load_statement.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/load_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parsed_data/load_info.hpp"
-
-namespace duckdb {
-
-class LoadStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::LOAD_STATEMENT;
-
-public:
-	LoadStatement();
-
-protected:
-	LoadStatement(const LoadStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-
-	unique_ptr<LoadInfo> info;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/logical_plan_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/logical_plan_statement.hpp
deleted file mode 100644
index 398003359..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/logical_plan_statement.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/logical_plan_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalPlanStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::LOGICAL_PLAN_STATEMENT;
-
-public:
-	explicit LogicalPlanStatement(unique_ptr<LogicalOperator> plan_p)
-	    : SQLStatement(StatementType::LOGICAL_PLAN_STATEMENT), plan(std::move(plan_p)) {};
-
-	unique_ptr<LogicalOperator> plan;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override {
-		throw NotImplementedException("PLAN_STATEMENT");
-	}
-	string ToString() const override {
-		throw NotImplementedException("PLAN STATEMENT");
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/multi_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/multi_statement.hpp
deleted file mode 100644
index 42a26ff6c..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/multi_statement.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/multi_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class MultiStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::MULTI_STATEMENT;
-
-public:
-	MultiStatement();
-
-	vector<unique_ptr<SQLStatement>> statements;
-
-protected:
-	MultiStatement(const MultiStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/pragma_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/pragma_statement.hpp
deleted file mode 100644
index 249c468b3..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/pragma_statement.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/pragma_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class PragmaStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::PRAGMA_STATEMENT;
-
-public:
-	PragmaStatement();
-
-	unique_ptr<PragmaInfo> info;
-
-protected:
-	PragmaStatement(const PragmaStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/prepare_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/prepare_statement.hpp
deleted file mode 100644
index c2be75989..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/prepare_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/prepare_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-
-namespace duckdb {
-
-class PrepareStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::PREPARE_STATEMENT;
-
-public:
-	PrepareStatement();
-
-	unique_ptr<SQLStatement> statement;
-	string name;
-
-protected:
-	PrepareStatement(const PrepareStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/relation_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/relation_statement.hpp
deleted file mode 100644
index b3acb75e3..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/relation_statement.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/relation_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/main/relation.hpp"
-
-namespace duckdb {
-
-class RelationStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::RELATION_STATEMENT;
-
-public:
-	explicit RelationStatement(shared_ptr<Relation> relation);
-
-	shared_ptr<Relation> relation;
-
-protected:
-	RelationStatement(const RelationStatement &other) = default;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp
deleted file mode 100644
index d0fd8b4d5..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/select_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-class QueryNode;
-class Serializer;
-class Deserializer;
-
-//! SelectStatement is a typical SELECT clause
-class SelectStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::SELECT_STATEMENT;
-
-public:
-	SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
-	}
-
-	//! The main query node
-	unique_ptr<QueryNode> node;
-
-protected:
-	SelectStatement(const SelectStatement &other);
-
-public:
-	//! Convert the SELECT statement to a string
-
-	DUCKDB_API string ToString() const override;
-	//! Create a copy of this SelectStatement
-	DUCKDB_API unique_ptr<SQLStatement> Copy() const override;
-	//! Whether or not the statements are equivalent
-	bool Equals(const SQLStatement &other) const;
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<SelectStatement> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/set_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/set_statement.hpp
deleted file mode 100644
index 1818820db..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/set_statement.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/set_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/common/enums/set_type.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-
-namespace duckdb {
-
-class SetStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::SET_STATEMENT;
-
-protected:
-	SetStatement(string name_p, SetScope scope_p, SetType type_p);
-	SetStatement(const SetStatement &other) = default;
-
-public:
-	string name;
-	SetScope scope;
-	SetType set_type;
-};
-
-class SetVariableStatement : public SetStatement {
-public:
-	SetVariableStatement(string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p);
-
-protected:
-	SetVariableStatement(const SetVariableStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-
-public:
-	unique_ptr<ParsedExpression> value;
-};
-
-class ResetVariableStatement : public SetStatement {
-public:
-	ResetVariableStatement(std::string name_p, SetScope scope_p);
-
-protected:
-	ResetVariableStatement(const ResetVariableStatement &other) = default;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/transaction_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/transaction_statement.hpp
deleted file mode 100644
index 3fb5f54fd..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/transaction_statement.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/transaction_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parsed_data/transaction_info.hpp"
-
-namespace duckdb {
-
-class TransactionStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::TRANSACTION_STATEMENT;
-
-public:
-	explicit TransactionStatement(unique_ptr<TransactionInfo> info);
-
-	unique_ptr<TransactionInfo> info;
-
-protected:
-	TransactionStatement(const TransactionStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/update_extensions_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/update_extensions_statement.hpp
deleted file mode 100644
index 2c361b336..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/update_extensions_statement.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/update_extensions_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/parsed_data/update_extensions_info.hpp"
-
-namespace duckdb {
-
-class UpdateExtensionsStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::UPDATE_EXTENSIONS_STATEMENT;
-
-public:
-	UpdateExtensionsStatement();
-	unique_ptr<UpdateExtensionsInfo> info;
-
-protected:
-	UpdateExtensionsStatement(const UpdateExtensionsStatement &other);
-
-public:
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/update_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/update_statement.hpp
deleted file mode 100644
index 5b156c5a3..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/update_statement.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/update_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-class UpdateSetInfo {
-public:
-	UpdateSetInfo();
-
-public:
-	unique_ptr<UpdateSetInfo> Copy() const;
-
-public:
-	// The condition that needs to be met to perform the update
-	unique_ptr<ParsedExpression> condition;
-	// The columns to update
-	vector<string> columns;
-	// The set expressions to execute
-	vector<unique_ptr<ParsedExpression>> expressions;
-
-protected:
-	UpdateSetInfo(const UpdateSetInfo &other);
-};
-
-class UpdateStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::UPDATE_STATEMENT;
-
-public:
-	UpdateStatement();
-
-	unique_ptr<TableRef> table;
-	unique_ptr<TableRef> from_table;
-	//! keep track of optional returningList if statement contains a RETURNING keyword
-	vector<unique_ptr<ParsedExpression>> returning_list;
-	unique_ptr<UpdateSetInfo> set_info;
-	//! CTEs
-	CommonTableExpressionMap cte_map;
-
-protected:
-	UpdateStatement(const UpdateStatement &other);
-
-public:
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/statement/vacuum_statement.hpp b/src/duckdb/src/include/duckdb/parser/statement/vacuum_statement.hpp
deleted file mode 100644
index 07b04d1cd..000000000
--- a/src/duckdb/src/include/duckdb/parser/statement/vacuum_statement.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/vacuum_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-class VacuumStatement : public SQLStatement {
-public:
-	static constexpr const StatementType TYPE = StatementType::VACUUM_STATEMENT;
-
-public:
-	explicit VacuumStatement(const VacuumOptions &options);
-
-	unique_ptr<VacuumInfo> info;
-
-protected:
-	VacuumStatement(const VacuumStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-	string ToString() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref.hpp b/src/duckdb/src/include/duckdb/parser/tableref.hpp
deleted file mode 100644
index 62890e3b3..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/enums/tableref_type.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/main/external_dependencies.hpp"
-
-namespace duckdb {
-
-//! Represents a generic expression that returns a table.
-class TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::INVALID;
-
-public:
-	explicit TableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~TableRef() {
-	}
-
-	TableReferenceType type;
-	string alias;
-	//! Sample options (if any)
-	unique_ptr<SampleOptions> sample;
-	//! The location in the query (if any)
-	optional_idx query_location;
-	//! External dependencies of this table function
-	shared_ptr<ExternalDependency> external_dependency;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
-
-public:
-	//! Convert the object to a string
-	virtual string ToString() const = 0;
-	string BaseToString(string result) const;
-	string BaseToString(string result, const vector<string> &column_name_alias) const;
-	void Print();
-
-	virtual bool Equals(const TableRef &other) const;
-	static bool Equals(const unique_ptr<TableRef> &left, const unique_ptr<TableRef> &right);
-
-	virtual unique_ptr<TableRef> Copy() = 0;
-
-	//! Copy the properties of this table ref to the target
-	void CopyProperties(TableRef &target) const;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<TableRef> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE && TARGET::TYPE != TableReferenceType::INVALID) {
-			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE && TARGET::TYPE != TableReferenceType::INVALID) {
-			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp
deleted file mode 100644
index b841559ea..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/basetableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/table_description.hpp"
-#include "duckdb/parser/tableref.hpp"
-
-namespace duckdb {
-
-//! Represents a TableReference to a base table in a catalog and schema.
-class BaseTableRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::BASE_TABLE;
-
-public:
-	BaseTableRef()
-	    : TableRef(TableReferenceType::BASE_TABLE), catalog_name(INVALID_CATALOG), schema_name(INVALID_SCHEMA) {
-	}
-	explicit BaseTableRef(const TableDescription &description)
-	    : TableRef(TableReferenceType::BASE_TABLE), catalog_name(description.database), schema_name(description.schema),
-	      table_name(description.table) {
-	}
-
-	//! The catalog name.
-	string catalog_name;
-	//! The schema name.
-	string schema_name;
-	//! The table name.
-	string table_name;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-	unique_ptr<TableRef> Copy() override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/column_data_ref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/column_data_ref.hpp
deleted file mode 100644
index b6a108e2f..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/column_data_ref.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/column_data_ref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/common/optionally_owned_ptr.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-
-//! Represents a TableReference to a materialized result
-class ColumnDataRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::COLUMN_DATA;
-
-public:
-	explicit ColumnDataRef(shared_ptr<ColumnDataCollection> collection)
-	    : TableRef(TableReferenceType::COLUMN_DATA), collection(std::move(collection)) {
-	}
-	ColumnDataRef(shared_ptr<ColumnDataCollection> collection, vector<string> expected_names)
-	    : TableRef(TableReferenceType::COLUMN_DATA), expected_names(std::move(expected_names)),
-	      collection(std::move(collection)) {
-	}
-
-public:
-	//! The set of expected names
-	vector<string> expected_names;
-	//! The collection to scan
-	shared_ptr<ColumnDataCollection> collection;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a ColumnDataRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/delimgetref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/delimgetref.hpp
deleted file mode 100644
index ea6889362..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/delimgetref.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/delimgetref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/tableref.hpp"
-
-namespace duckdb {
-
-class DelimGetRef : public TableRef {
-
-public:
-	explicit DelimGetRef(const vector<LogicalType> &types_p) : TableRef(TableReferenceType::DELIM_GET), types(types_p) {
-		for (idx_t i = 0; i < types.size(); i++) {
-			string column_name = "__internal_delim_get_" + std::to_string(i);
-			internal_aliases.emplace_back(column_name);
-		}
-	}
-
-	vector<string> internal_aliases;
-	vector<LogicalType> types;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp
deleted file mode 100644
index 20483e561..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/emptytableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/tableref.hpp"
-
-namespace duckdb {
-
-class EmptyTableRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::EMPTY_FROM;
-
-public:
-	EmptyTableRef() : TableRef(TableReferenceType::EMPTY_FROM) {
-	}
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a DummyTableRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp
deleted file mode 100644
index 7d0bd86e1..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/expressionlistref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-//! Represents an expression list as generated by a VALUES statement
-class ExpressionListRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::EXPRESSION_LIST;
-
-public:
-	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
-	}
-
-	//! Value list, only used for VALUES statement
-	vector<vector<unique_ptr<ParsedExpression>>> values;
-	//! Expected SQL types
-	vector<LogicalType> expected_types;
-	//! The set of expected names
-	vector<string> expected_names;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a ExpressionListRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp
deleted file mode 100644
index 1b9f8f988..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/joinref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-//! Represents a JOIN between two expressions
-class JoinRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::JOIN;
-
-public:
-	explicit JoinRef(JoinRefType ref_type = JoinRefType::REGULAR)
-	    : TableRef(TableReferenceType::JOIN), type(JoinType::INNER), ref_type(ref_type) {
-	}
-
-	//! The left hand side of the join
-	unique_ptr<TableRef> left;
-	//! The right hand side of the join
-	unique_ptr<TableRef> right;
-	//! The join condition
-	unique_ptr<ParsedExpression> condition;
-	//! The join type
-	JoinType type;
-	//! Join condition type
-	JoinRefType ref_type;
-	//! The set of USING columns (if any)
-	vector<string> using_columns;
-	//! Duplicate eliminated columns (if any)
-	vector<unique_ptr<ParsedExpression>> duplicate_eliminated_columns;
-	//! If we have duplicate eliminated columns if the delim is flipped
-	bool delim_flipped = false;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a JoinRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/list.hpp b/src/duckdb/src/include/duckdb/parser/tableref/list.hpp
deleted file mode 100644
index c84a82b58..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/list.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/parser/tableref/column_data_ref.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/parser/tableref/showref.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp
deleted file mode 100644
index ec19f5d66..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/pivotref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-
-namespace duckdb {
-
-struct PivotColumnEntry {
-	//! The set of values to match on (PIVOT only)
-	vector<Value> values;
-	//! The expression (UNPIVOT only)
-	unique_ptr<ParsedExpression> expr;
-	//! The alias of the pivot column entry
-	string alias;
-
-	bool Equals(const PivotColumnEntry &other) const;
-	PivotColumnEntry Copy() const;
-
-	void Serialize(Serializer &serializer) const;
-	static PivotColumnEntry Deserialize(Deserializer &source);
-};
-
-struct PivotValueElement {
-	vector<Value> values;
-	string name;
-};
-
-struct PivotColumn {
-	//! The set of expressions to pivot on
-	vector<unique_ptr<ParsedExpression>> pivot_expressions;
-	//! The set of unpivot names
-	vector<string> unpivot_names;
-	//! The set of values to pivot on
-	vector<PivotColumnEntry> entries;
-	//! The enum to read pivot values from (if any)
-	string pivot_enum;
-	//! Subquery (if any) - used during transform only
-	unique_ptr<QueryNode> subquery;
-
-	string ToString() const;
-	bool Equals(const PivotColumn &other) const;
-	PivotColumn Copy() const;
-
-	void Serialize(Serializer &serializer) const;
-	static PivotColumn Deserialize(Deserializer &source);
-};
-
-//! Represents a PIVOT or UNPIVOT expression
-class PivotRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::PIVOT;
-
-public:
-	explicit PivotRef() : TableRef(TableReferenceType::PIVOT), include_nulls(false) {
-	}
-
-	//! The source table of the pivot
-	unique_ptr<TableRef> source;
-	//! The aggregates to compute over the pivot (PIVOT only)
-	vector<unique_ptr<ParsedExpression>> aggregates;
-	//! The names of the unpivot expressions (UNPIVOT only)
-	vector<string> unpivot_names;
-	//! The set of pivots
-	vector<PivotColumn> pivots;
-	//! The groups to pivot over. If none are specified all columns not included in the pivots/aggregate are chosen.
-	vector<string> groups;
-	//! Whether or not to include nulls in the result (UNPIVOT only)
-	bool include_nulls;
-	//! The set of values to pivot on (bound pivot only)
-	vector<PivotValueElement> bound_pivot_values;
-	//! The set of bound group names (bound pivot only)
-	vector<string> bound_group_names;
-	//! The set of bound aggregate names (bound pivot only)
-	vector<string> bound_aggregate_names;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a PivotRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp
deleted file mode 100644
index fdd98e21b..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/showref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-enum class ShowType : uint8_t { SUMMARY, DESCRIBE };
-
-//! Represents a SHOW/DESCRIBE/SUMMARIZE statement
-class ShowRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::SHOW_REF;
-
-public:
-	ShowRef();
-
-	//! The table name (if any)
-	string table_name;
-	//! The QueryNode of select query (if any)
-	unique_ptr<QueryNode> query;
-	//! Whether or not we are requesting a summary or a describe
-	ShowType show_type;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a ExpressionListRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp
deleted file mode 100644
index f93b45ab3..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/subqueryref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/tableref.hpp"
-
-namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::SUBQUERY;
-
-private:
-	SubqueryRef();
-
-public:
-	DUCKDB_API explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
-
-	//! The subquery
-	unique_ptr<SelectStatement> subquery;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a SubqueryRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp
deleted file mode 100644
index 51c4fd8e3..000000000
--- a/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/table_function_ref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-
-namespace duckdb {
-//! Represents a Table producing function
-class TableFunctionRef : public TableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::TABLE_FUNCTION;
-
-public:
-	DUCKDB_API TableFunctionRef();
-
-	unique_ptr<ParsedExpression> function;
-
-	// if the function takes a subquery as argument its in here
-	unique_ptr<SelectStatement> subquery;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const TableRef &other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a BaseTableRef
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/tokens.hpp b/src/duckdb/src/include/duckdb/parser/tokens.hpp
deleted file mode 100644
index d18adfd44..000000000
--- a/src/duckdb/src/include/duckdb/parser/tokens.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tokens.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Statements
-//===--------------------------------------------------------------------===//
-class SQLStatement;
-
-class AlterStatement;
-class AttachStatement;
-class CallStatement;
-class CopyStatement;
-class CreateStatement;
-class DetachStatement;
-class DeleteStatement;
-class DropStatement;
-class ExtensionStatement;
-class InsertStatement;
-class SelectStatement;
-class TransactionStatement;
-class UpdateStatement;
-class UpdateExtensionsStatement;
-class PrepareStatement;
-class ExecuteStatement;
-class PragmaStatement;
-class ExplainStatement;
-class ExportStatement;
-class VacuumStatement;
-class RelationStatement;
-class SetStatement;
-class SetVariableStatement;
-class ResetVariableStatement;
-class LoadStatement;
-class LogicalPlanStatement;
-class MultiStatement;
-class CopyDatabaseStatement;
-
-//===--------------------------------------------------------------------===//
-// Query Node
-//===--------------------------------------------------------------------===//
-class QueryNode;
-class SelectNode;
-class SetOperationNode;
-class RecursiveCTENode;
-class CTENode;
-
-//===--------------------------------------------------------------------===//
-// Expressions
-//===--------------------------------------------------------------------===//
-class ParsedExpression;
-
-class BetweenExpression;
-class CaseExpression;
-class CastExpression;
-class CollateExpression;
-class ColumnRefExpression;
-class ComparisonExpression;
-class ConjunctionExpression;
-class ConstantExpression;
-class DefaultExpression;
-class FunctionExpression;
-class LambdaExpression;
-class OperatorExpression;
-class ParameterExpression;
-class PositionalReferenceExpression;
-class StarExpression;
-class SubqueryExpression;
-class WindowExpression;
-
-//===--------------------------------------------------------------------===//
-// Constraints
-//===--------------------------------------------------------------------===//
-class Constraint;
-
-class NotNullConstraint;
-class CheckConstraint;
-class UniqueConstraint;
-class ForeignKeyConstraint;
-
-//===--------------------------------------------------------------------===//
-// TableRefs
-//===--------------------------------------------------------------------===//
-class TableRef;
-
-class BaseTableRef;
-class JoinRef;
-class SubqueryRef;
-class TableFunctionRef;
-class EmptyTableRef;
-class ExpressionListRef;
-class ColumnDataRef;
-class PivotRef;
-class ShowRef;
-
-//===--------------------------------------------------------------------===//
-// Other
-//===--------------------------------------------------------------------===//
-class SampleOptions;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/parser/transformer.hpp b/src/duckdb/src/include/duckdb/parser/transformer.hpp
deleted file mode 100644
index 00833a526..000000000
--- a/src/duckdb/src/include/duckdb/parser/transformer.hpp
+++ /dev/null
@@ -1,395 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/transformer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/stack_checker.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/parser/tokens.hpp"
-#include "nodes/parsenodes.hpp"
-#include "nodes/primnodes.hpp"
-#include "pg_definitions.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/common/enums/on_entry_not_found.hpp"
-
-namespace duckdb {
-
-class ColumnDefinition;
-struct OrderByNode;
-struct CopyInfo;
-struct CommonTableExpressionInfo;
-struct GroupingExpressionMap;
-class OnConflictInfo;
-class UpdateSetInfo;
-class MacroFunction;
-struct ParserOptions;
-struct PivotColumn;
-struct PivotColumnEntry;
-
-//! The transformer class is responsible for transforming the internal Postgres
-//! parser representation into the DuckDB representation
-class Transformer {
-	friend class StackChecker<Transformer>;
-
-	struct CreatePivotEntry {
-		string enum_name;
-		unique_ptr<SelectNode> base;
-		unique_ptr<ParsedExpression> column;
-		unique_ptr<QueryNode> subquery;
-		bool has_parameters;
-	};
-
-public:
-	explicit Transformer(ParserOptions &options);
-	Transformer(Transformer &parent);
-	~Transformer();
-
-	//! Transforms a Postgres parse tree into a set of SQL Statements
-	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
-	string NodetypeToString(duckdb_libpgquery::PGNodeTag type);
-
-	idx_t ParamCount() const;
-
-private:
-	optional_ptr<Transformer> parent;
-	//! Parser options
-	ParserOptions &options;
-	//! The current prepared statement parameter index
-	idx_t prepared_statement_parameter_index = 0;
-	//! Map from named parameter to parameter index;
-	case_insensitive_map_t<idx_t> named_param_map;
-	//! Last parameter type
-	PreparedParamType last_param_type = PreparedParamType::INVALID;
-	//! Holds window expressions defined by name. We need those when transforming the expressions referring to them.
-	case_insensitive_map_t<duckdb_libpgquery::PGWindowDef *> window_clauses;
-	//! The set of pivot entries to create
-	vector<unique_ptr<CreatePivotEntry>> pivot_entries;
-	//! Sets of stored CTEs, if any
-	vector<CommonTableExpressionMap *> stored_cte_map;
-	//! Whether or not we are currently binding a window definition
-	bool in_window_definition = false;
-
-	void Clear();
-	bool InWindowDefinition();
-
-	Transformer &RootTransformer();
-	const Transformer &RootTransformer() const;
-	void SetParamCount(idx_t new_count);
-	void ClearParameters();
-	void SetParam(const string &name, idx_t index, PreparedParamType type);
-	bool GetParam(const string &name, idx_t &index, PreparedParamType type);
-
-	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column,
-	                   unique_ptr<QueryNode> subquery, bool has_parameters);
-	unique_ptr<SQLStatement> GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry);
-	bool HasPivotEntries();
-	idx_t PivotEntryCount();
-	vector<unique_ptr<CreatePivotEntry>> &GetPivotEntries();
-	void PivotEntryCheck(const string &type);
-	void ExtractCTEsRecursive(CommonTableExpressionMap &cte_map);
-
-private:
-	//! Transforms a Postgres statement into a single SQL statement
-	unique_ptr<SQLStatement> TransformStatement(duckdb_libpgquery::PGNode &stmt);
-	//! Transforms a Postgres statement into a single SQL statement
-	unique_ptr<SQLStatement> TransformStatementInternal(duckdb_libpgquery::PGNode &stmt);
-	//===--------------------------------------------------------------------===//
-	// Statement transformation
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a SelectStatement
-	unique_ptr<SelectStatement> TransformSelectStmt(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true);
-	unique_ptr<SelectStatement> TransformSelectStmt(duckdb_libpgquery::PGNode &node, bool is_select = true);
-	//! Transform a Postgres T_AlterStmt node into a AlterStatement
-	unique_ptr<AlterStatement> TransformAlter(duckdb_libpgquery::PGAlterTableStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGRenameStmt node into a RenameStatement
-	unique_ptr<AlterStatement> TransformRename(duckdb_libpgquery::PGRenameStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateTable(duckdb_libpgquery::PGCreateStmt &node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateTableAs(duckdb_libpgquery::PGCreateTableAsStmt &stmt);
-	//! Transform a Postgres node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateSchema(duckdb_libpgquery::PGCreateSchemaStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateSeqStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateSequence(duckdb_libpgquery::PGCreateSeqStmt &node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGViewStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateView(duckdb_libpgquery::PGViewStmt &node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGIndexStmt node into CreateStatement
-	unique_ptr<CreateStatement> TransformCreateIndex(duckdb_libpgquery::PGIndexStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateFunctionStmt node into CreateStatement
-	unique_ptr<CreateStatement> TransformCreateFunction(duckdb_libpgquery::PGCreateFunctionStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
-	unique_ptr<CreateStatement> TransformCreateType(duckdb_libpgquery::PGCreateTypeStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
-	unique_ptr<AlterStatement> TransformCommentOn(duckdb_libpgquery::PGCommentOnStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGAlterSeqStmt node into CreateStatement
-	unique_ptr<AlterStatement> TransformAlterSequence(duckdb_libpgquery::PGAlterSeqStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGDropStmt node into a Drop[Table,Schema]Statement
-	unique_ptr<SQLStatement> TransformDrop(duckdb_libpgquery::PGDropStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGInsertStmt node into a InsertStatement
-	unique_ptr<InsertStatement> TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt);
-
-	//! Transform a Postgres duckdb_libpgquery::T_PGOnConflictClause node into a OnConflictInfo
-	unique_ptr<OnConflictInfo> TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node,
-	                                                     const string &relname);
-	//! Transform a ON CONFLICT shorthand into a OnConflictInfo
-	unique_ptr<OnConflictInfo> DummyOnConflictClause(duckdb_libpgquery::PGOnConflictActionAlias type,
-	                                                 const string &relname);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCopyStmt node into a CopyStatement
-	unique_ptr<CopyStatement> TransformCopy(duckdb_libpgquery::PGCopyStmt &stmt);
-	void TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpgquery::PGList> options);
-	void TransformCreateSecretOptions(CreateSecretInfo &info, optional_ptr<duckdb_libpgquery::PGList> options);
-	//! Transform a Postgres duckdb_libpgquery::T_PGTransactionStmt node into a TransactionStatement
-	unique_ptr<TransactionStatement> TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt);
-	//! Transform a Postgres T_DeleteStatement node into a DeleteStatement
-	unique_ptr<DeleteStatement> TransformDelete(duckdb_libpgquery::PGDeleteStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGUpdateStmt node into a UpdateStatement
-	unique_ptr<UpdateStatement> TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGUpdateExtensionsStmt node into a UpdateExtensionsStatement
-	unique_ptr<UpdateExtensionsStatement> TransformUpdateExtensions(duckdb_libpgquery::PGUpdateExtensionsStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGPragmaStmt node into a PragmaStatement
-	unique_ptr<SQLStatement> TransformPragma(duckdb_libpgquery::PGPragmaStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGExportStmt node into a ExportStatement
-	unique_ptr<ExportStatement> TransformExport(duckdb_libpgquery::PGExportStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGImportStmt node into a PragmaStatement
-	unique_ptr<PragmaStatement> TransformImport(duckdb_libpgquery::PGImportStmt &stmt);
-	unique_ptr<ExplainStatement> TransformExplain(duckdb_libpgquery::PGExplainStmt &stmt);
-	unique_ptr<SQLStatement> TransformVacuum(duckdb_libpgquery::PGVacuumStmt &stmt);
-	unique_ptr<QueryNode> TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt);
-	unique_ptr<SelectStatement> TransformShowStmt(duckdb_libpgquery::PGVariableShowStmt &stmt);
-	unique_ptr<QueryNode> TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt);
-	unique_ptr<SelectStatement> TransformShowSelectStmt(duckdb_libpgquery::PGVariableShowSelectStmt &stmt);
-	unique_ptr<AttachStatement> TransformAttach(duckdb_libpgquery::PGAttachStmt &stmt);
-	unique_ptr<DetachStatement> TransformDetach(duckdb_libpgquery::PGDetachStmt &stmt);
-	unique_ptr<SetStatement> TransformUse(duckdb_libpgquery::PGUseStmt &stmt);
-	unique_ptr<SQLStatement> TransformCopyDatabase(duckdb_libpgquery::PGCopyDatabaseStmt &stmt);
-	unique_ptr<CreateStatement> TransformSecret(duckdb_libpgquery::PGCreateSecretStmt &stmt);
-	unique_ptr<DropStatement> TransformDropSecret(duckdb_libpgquery::PGDropSecretStmt &stmt);
-
-	unique_ptr<PrepareStatement> TransformPrepare(duckdb_libpgquery::PGPrepareStmt &stmt);
-	unique_ptr<ExecuteStatement> TransformExecute(duckdb_libpgquery::PGExecuteStmt &stmt);
-	unique_ptr<CallStatement> TransformCall(duckdb_libpgquery::PGCallStmt &stmt);
-	unique_ptr<DropStatement> TransformDeallocate(duckdb_libpgquery::PGDeallocateStmt &stmt);
-	unique_ptr<QueryNode> TransformPivotStatement(duckdb_libpgquery::PGSelectStmt &select);
-	unique_ptr<SQLStatement> CreatePivotStatement(unique_ptr<SQLStatement> statement);
-	PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot);
-	vector<PivotColumn> TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot);
-	static bool TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry,
-	                                 bool root_entry = true);
-
-	//===--------------------------------------------------------------------===//
-	// SetStatement Transform
-	//===--------------------------------------------------------------------===//
-	unique_ptr<SetStatement> TransformSet(duckdb_libpgquery::PGVariableSetStmt &set);
-	unique_ptr<SetStatement> TransformSetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt);
-	unique_ptr<SetStatement> TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt);
-
-	unique_ptr<SQLStatement> TransformCheckpoint(duckdb_libpgquery::PGCheckPointStmt &stmt);
-	unique_ptr<LoadStatement> TransformLoad(duckdb_libpgquery::PGLoadStmt &stmt);
-
-	//===--------------------------------------------------------------------===//
-	// Query Node Transform
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode
-	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGNode &select, bool is_select = true);
-	unique_ptr<QueryNode> TransformSelectNodeInternal(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true);
-	unique_ptr<QueryNode> TransformSelectInternal(duckdb_libpgquery::PGSelectStmt &select);
-	void TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node);
-
-	//===--------------------------------------------------------------------===//
-	// Expression Transform
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres boolean expression into an Expression
-	unique_ptr<ParsedExpression> TransformBoolExpr(duckdb_libpgquery::PGBoolExpr &root);
-	//! Transform a Postgres case expression into an Expression
-	unique_ptr<ParsedExpression> TransformCase(duckdb_libpgquery::PGCaseExpr &root);
-	//! Transform a Postgres type cast into an Expression
-	unique_ptr<ParsedExpression> TransformTypeCast(duckdb_libpgquery::PGTypeCast &root);
-	//! Transform a Postgres coalesce into an Expression
-	unique_ptr<ParsedExpression> TransformCoalesce(duckdb_libpgquery::PGAExpr &root);
-	//! Transform a Postgres column reference into an Expression
-	unique_ptr<ParsedExpression> TransformColumnRef(duckdb_libpgquery::PGColumnRef &root);
-	//! Transform a Postgres constant value into an Expression
-	unique_ptr<ConstantExpression> TransformValue(duckdb_libpgquery::PGValue val);
-	//! Transform a Postgres operator into an Expression
-	unique_ptr<ParsedExpression> TransformAExpr(duckdb_libpgquery::PGAExpr &root);
-	unique_ptr<ParsedExpression> TransformAExprInternal(duckdb_libpgquery::PGAExpr &root);
-	//! Transform a Postgres abstract expression into an Expression
-	unique_ptr<ParsedExpression> TransformExpression(optional_ptr<duckdb_libpgquery::PGNode> node);
-	unique_ptr<ParsedExpression> TransformExpression(duckdb_libpgquery::PGNode &node);
-	//! Transform a Postgres function call into an Expression
-	unique_ptr<ParsedExpression> TransformFuncCall(duckdb_libpgquery::PGFuncCall &root);
-	//! Transform a Postgres boolean expression into an Expression
-	unique_ptr<ParsedExpression> TransformInterval(duckdb_libpgquery::PGIntervalConstant &root);
-	//! Transform a Postgres lambda node [e.g. (x, y) -> x + y] into a lambda expression
-	unique_ptr<ParsedExpression> TransformLambda(duckdb_libpgquery::PGLambdaFunction &node);
-	//! Transform a Postgres array access node (e.g. x[1] or x[1:3])
-	unique_ptr<ParsedExpression> TransformArrayAccess(duckdb_libpgquery::PGAIndirection &node);
-	//! Transform a positional reference (e.g. #1)
-	unique_ptr<ParsedExpression> TransformPositionalReference(duckdb_libpgquery::PGPositionalReference &node);
-	unique_ptr<ParsedExpression> TransformStarExpression(duckdb_libpgquery::PGAStar &node);
-	unique_ptr<ParsedExpression> TransformBooleanTest(duckdb_libpgquery::PGBooleanTest &node);
-
-	//! Transform a Postgres constant value into an Expression
-	unique_ptr<ParsedExpression> TransformConstant(duckdb_libpgquery::PGAConst &c);
-	unique_ptr<ParsedExpression> TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc &n);
-	unique_ptr<ParsedExpression> TransformResTarget(duckdb_libpgquery::PGResTarget &root);
-	unique_ptr<ParsedExpression> TransformNullTest(duckdb_libpgquery::PGNullTest &root);
-	unique_ptr<ParsedExpression> TransformParamRef(duckdb_libpgquery::PGParamRef &node);
-	unique_ptr<ParsedExpression> TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr &root);
-
-	//! Transform multi assignment reference into an Expression
-	unique_ptr<ParsedExpression> TransformMultiAssignRef(duckdb_libpgquery::PGMultiAssignRef &root);
-
-	unique_ptr<ParsedExpression> TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction &node);
-
-	unique_ptr<ParsedExpression> TransformSubquery(duckdb_libpgquery::PGSubLink &root);
-	//===--------------------------------------------------------------------===//
-	// Constraints transform
-	//===--------------------------------------------------------------------===//
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGConstraint &constraint);
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGConstraint &constraint, ColumnDefinition &column,
-	                                           idx_t index);
-
-	//===--------------------------------------------------------------------===//
-	// Update transform
-	//===--------------------------------------------------------------------===//
-	unique_ptr<UpdateSetInfo> TransformUpdateSetInfo(duckdb_libpgquery::PGList *target_list,
-	                                                 duckdb_libpgquery::PGNode *where_clause);
-
-	//===--------------------------------------------------------------------===//
-	// Index transform
-	//===--------------------------------------------------------------------===//
-	vector<unique_ptr<ParsedExpression>> TransformIndexParameters(duckdb_libpgquery::PGList &list,
-	                                                              const string &relation_name);
-
-	//===--------------------------------------------------------------------===//
-	// Collation transform
-	//===--------------------------------------------------------------------===//
-	unique_ptr<ParsedExpression> TransformCollateExpr(duckdb_libpgquery::PGCollateClause &collate);
-
-	string TransformCollation(optional_ptr<duckdb_libpgquery::PGCollateClause> collate);
-
-	ColumnDefinition TransformColumnDefinition(duckdb_libpgquery::PGColumnDef &cdef);
-	//===--------------------------------------------------------------------===//
-	// Helpers
-	//===--------------------------------------------------------------------===//
-	OnCreateConflict TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict);
-	string TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias);
-	vector<string> TransformStringList(duckdb_libpgquery::PGList *list);
-	void TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map);
-	static unique_ptr<QueryNode> TransformMaterializedCTE(unique_ptr<QueryNode> root);
-	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr &node,
-	                                                  CommonTableExpressionInfo &info);
-
-	unique_ptr<ParsedExpression> TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child);
-	unique_ptr<ParsedExpression> TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
-	                                                     unique_ptr<ParsedExpression> right);
-	static bool ConstructConstantFromExpression(const ParsedExpression &expr, Value &value);
-	//===--------------------------------------------------------------------===//
-	// TableRef transform
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres node into a TableRef
-	unique_ptr<TableRef> TransformTableRefNode(duckdb_libpgquery::PGNode &n);
-	//! Transform a Postgres FROM clause into a TableRef
-	unique_ptr<TableRef> TransformFrom(optional_ptr<duckdb_libpgquery::PGList> root);
-	//! Transform a Postgres table reference into a TableRef
-	unique_ptr<TableRef> TransformRangeVar(duckdb_libpgquery::PGRangeVar &root);
-	//! Transform a Postgres table-producing function into a TableRef
-	unique_ptr<TableRef> TransformRangeFunction(duckdb_libpgquery::PGRangeFunction &root);
-	//! Transform a Postgres join node into a TableRef
-	unique_ptr<TableRef> TransformJoin(duckdb_libpgquery::PGJoinExpr &root);
-	//! Transform a Postgres pivot node into a TableRef
-	unique_ptr<TableRef> TransformPivot(duckdb_libpgquery::PGPivotExpr &root);
-	//! Transform a table producing subquery into a TableRef
-	unique_ptr<TableRef> TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect &root);
-	//! Transform a VALUES list into a set of expressions
-	unique_ptr<TableRef> TransformValuesList(duckdb_libpgquery::PGList *list);
-
-	//! Transform a range var into a (schema) qualified name
-	QualifiedName TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root);
-
-	//! Transform a Postgres TypeName string into a LogicalType (non-LIST types)
-	LogicalType TransformTypeNameInternal(duckdb_libpgquery::PGTypeName &name);
-	//! Transform a Postgres TypeName string into a LogicalType
-	LogicalType TransformTypeName(duckdb_libpgquery::PGTypeName &name);
-
-	//! Transform a list of type modifiers into a list of values
-	vector<Value> TransformTypeModifiers(duckdb_libpgquery::PGTypeName &name);
-
-	//! Transform a Postgres GROUP BY expression into a list of Expression
-	bool TransformGroupBy(optional_ptr<duckdb_libpgquery::PGList> group, SelectNode &result);
-	void TransformGroupByNode(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map, SelectNode &result,
-	                          vector<GroupingSet> &result_sets);
-	void AddGroupByExpression(unique_ptr<ParsedExpression> expression, GroupingExpressionMap &map, GroupByNode &result,
-	                          vector<idx_t> &result_set);
-	void TransformGroupByExpression(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map, GroupByNode &result,
-	                                vector<idx_t> &result_set);
-	//! Transform a Postgres ORDER BY expression into an OrderByDescription
-	bool TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result);
-
-	//! Transform to a IN or NOT IN expression
-	unique_ptr<ParsedExpression> TransformInExpression(const string &name, duckdb_libpgquery::PGAExpr &root);
-
-	//! Transform a Postgres SELECT clause into a list of Expressions
-	void TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result);
-
-	//! Transform a Postgres PARTITION BY/ORDER BY specification into lists of expressions
-	void TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr,
-	                        const char *window_name = nullptr);
-	//! Transform a Postgres window frame specification into frame expressions
-	void TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr);
-
-	unique_ptr<SampleOptions> TransformSampleOptions(optional_ptr<duckdb_libpgquery::PGNode> options);
-	//! Returns true if an expression is only a star (i.e. "*", without any other decorators)
-	bool ExpressionIsEmptyStar(ParsedExpression &expr);
-
-	OnEntryNotFound TransformOnEntryNotFound(bool missing_ok);
-
-	Vector PGListToVector(optional_ptr<duckdb_libpgquery::PGList> column_list, idx_t &size);
-	vector<string> TransformConflictTarget(duckdb_libpgquery::PGList &list);
-
-	unique_ptr<MacroFunction> TransformMacroFunction(duckdb_libpgquery::PGFunctionDefinition &function);
-
-	void ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
-	                                 duckdb_libpgquery::PGNode *arg);
-
-public:
-	static void SetQueryLocation(ParsedExpression &expr, int query_location);
-	static void SetQueryLocation(TableRef &ref, int query_location);
-
-private:
-	//! Current stack depth
-	idx_t stack_depth;
-
-	void InitializeStackCheck();
-	StackChecker<Transformer> StackCheck(idx_t extra_stack = 1);
-
-public:
-	template <class T>
-	static T &PGCast(duckdb_libpgquery::PGNode &node) {
-		return reinterpret_cast<T &>(node);
-	}
-	template <class T>
-	static optional_ptr<T> PGPointerCast(void *ptr) {
-		return optional_ptr<T>(reinterpret_cast<T *>(ptr));
-	}
-};
-
-vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bind_context.hpp b/src/duckdb/src/include/duckdb/planner/bind_context.hpp
deleted file mode 100644
index 8234805e7..000000000
--- a/src/duckdb/src/include/duckdb/planner/bind_context.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bind_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/column_index.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/qualified_name_set.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/table_binding.hpp"
-
-namespace duckdb {
-class Binder;
-class LogicalGet;
-class BoundQueryNode;
-
-class StarExpression;
-
-class TableCatalogEntry;
-class TableFunctionCatalogEntry;
-
-struct UsingColumnSet {
-	BindingAlias primary_binding;
-	vector<BindingAlias> bindings;
-};
-
-enum class ColumnBindType { EXPAND_GENERATED_COLUMNS, DO_NOT_EXPAND_GENERATED_COLUMNS };
-
-//! The BindContext object keeps track of all the tables and columns that are
-//! encountered during the binding process.
-class BindContext {
-public:
-	explicit BindContext(Binder &binder);
-
-	//! Keep track of recursive CTE references
-	case_insensitive_map_t<shared_ptr<idx_t>> cte_references;
-
-public:
-	//! Given a column name, find the matching table it belongs to. Throws an
-	//! exception if no table has a column of the given name.
-	optional_ptr<Binding> GetMatchingBinding(const string &column_name);
-	//! Like GetMatchingBinding, but instead of throwing an error if multiple tables have the same binding it will
-	//! return a list of all the matching ones
-	vector<reference<Binding>> GetMatchingBindings(const string &column_name);
-	//! Like GetMatchingBindings, but returns the top 3 most similar bindings (in levenshtein distance) instead of the
-	//! matching ones
-	vector<string> GetSimilarBindings(const string &column_name);
-
-	optional_ptr<Binding> GetCTEBinding(const string &ctename);
-	//! Binds a column expression to the base table. Returns the bound expression
-	//! or throws an exception if the column could not be bound.
-	BindResult BindColumn(ColumnRefExpression &colref, idx_t depth);
-	string BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name);
-	unique_ptr<ColumnRefExpression> PositionToColumn(PositionalReferenceExpression &ref);
-
-	unique_ptr<ParsedExpression> ExpandGeneratedColumn(TableBinding &table_binding, const string &column_name);
-
-	unique_ptr<ParsedExpression>
-	CreateColumnReference(const string &table_name, const string &column_name,
-	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
-	unique_ptr<ParsedExpression>
-	CreateColumnReference(const string &schema_name, const string &table_name, const string &column_name,
-	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
-	unique_ptr<ParsedExpression>
-	CreateColumnReference(const string &catalog_name, const string &schema_name, const string &table_name,
-	                      const string &column_name,
-	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
-	unique_ptr<ParsedExpression>
-	CreateColumnReference(const BindingAlias &table_alias, const string &column_name,
-	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
-
-	//! Generate column expressions for all columns that are present in the
-	//! referenced tables. This is used to resolve the * expression in a
-	//! selection list.
-	void GenerateAllColumnExpressions(StarExpression &expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
-
-	const vector<unique_ptr<Binding>> &GetBindingsList() {
-		return bindings_list;
-	}
-	vector<BindingAlias> GetBindingAliases();
-
-	void GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types);
-
-	//! Adds a base table with the given alias to the BindContext.
-	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  vector<ColumnIndex> &bound_column_ids, StandardEntry &entry, bool add_row_id = true);
-	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  vector<ColumnIndex> &bound_column_ids, const string &table_name);
-	//! Adds a call to a table function with the given alias to the BindContext.
-	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
-	                      const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
-	                      optional_ptr<StandardEntry> entry);
-	//! Adds a table view with a given alias to the BindContext.
-	void AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery, ViewCatalogEntry &view);
-	//! Adds a subquery with a given alias to the BindContext.
-	void AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery);
-	//! Adds a subquery with a given alias to the BindContext.
-	void AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery);
-	//! Adds a binding to a catalog entry with a given alias to the BindContext.
-	void AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
-	                     const vector<LogicalType> &types, StandardEntry &entry);
-	//! Adds a base table with the given alias to the BindContext.
-	void AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
-	                       const vector<LogicalType> &types);
-
-	//! Adds a base table with the given alias to the CTE BindContext.
-	//! We need this to correctly bind recursive CTEs with multiple references.
-	void AddCTEBinding(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types);
-
-	//! Add an implicit join condition (e.g. USING (x))
-	void AddUsingBinding(const string &column_name, UsingColumnSet &set);
-
-	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
-
-	//! Returns any using column set for the given column name, or nullptr if there is none. On conflict (multiple using
-	//! column sets with the same name) throw an exception.
-	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name);
-	//! Returns any using column set for the given column name, or nullptr if there is none
-	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name, const BindingAlias &binding);
-	//! Erase a using binding from the set of using bindings
-	void RemoveUsingBinding(const string &column_name, UsingColumnSet &set);
-	//! Transfer a using binding from one bind context to this bind context
-	void TransferUsingBinding(BindContext &current_context, optional_ptr<UsingColumnSet> current_set,
-	                          UsingColumnSet &new_set, const string &using_column);
-
-	//! Fetch the actual column name from the given binding, or throws if none exists
-	//! This can be different from "column_name" because of case insensitivity
-	//! (e.g. "column_name" might return "COLUMN_NAME")
-	string GetActualColumnName(const BindingAlias &binding_alias, const string &column_name);
-	string GetActualColumnName(Binding &binding, const string &column_name);
-
-	case_insensitive_map_t<shared_ptr<Binding>> GetCTEBindings() {
-		return cte_bindings;
-	}
-	void SetCTEBindings(case_insensitive_map_t<shared_ptr<Binding>> bindings) {
-		cte_bindings = std::move(bindings);
-	}
-
-	//! Alias a set of column names for the specified table, using the original names if there are not enough aliases
-	//! specified.
-	static vector<string> AliasColumnNames(const string &table_name, const vector<string> &names,
-	                                       const vector<string> &column_aliases);
-
-	//! Add all the bindings from a BindContext to this BindContext. The other BindContext is destroyed in the process.
-	void AddContext(BindContext other);
-	//! For semi and anti joins we remove the binding context of the right table after binding the condition.
-	void RemoveContext(const vector<BindingAlias> &aliases);
-
-	//! Gets a binding of the specified name. Returns a nullptr and sets the out_error if the binding could not be
-	//! found.
-	optional_ptr<Binding> GetBinding(const string &name, ErrorData &out_error);
-
-	optional_ptr<Binding> GetBinding(const BindingAlias &alias, ErrorData &out_error);
-
-	optional_ptr<Binding> GetBinding(const BindingAlias &alias, const string &column_name, ErrorData &out_error);
-
-	//! Get all bindings that match a specific binding alias - returns an error if none match
-	vector<reference<Binding>> GetBindings(const BindingAlias &alias, ErrorData &out_error);
-
-private:
-	void AddBinding(unique_ptr<Binding> binding);
-	static string AmbiguityException(const BindingAlias &alias, const vector<reference<Binding>> &bindings);
-
-private:
-	Binder &binder;
-	//! The list of bindings in insertion order
-	vector<unique_ptr<Binding>> bindings_list;
-	//! The set of columns used in USING join conditions
-	case_insensitive_map_t<reference_set_t<UsingColumnSet>> using_columns;
-	//! Using column sets
-	vector<unique_ptr<UsingColumnSet>> using_column_sets;
-
-	//! The set of CTE bindings
-	case_insensitive_map_t<shared_ptr<Binding>> cte_bindings;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/binder.hpp b/src/duckdb/src/include/duckdb/planner/binder.hpp
deleted file mode 100644
index 0cd7c0e6a..000000000
--- a/src/duckdb/src/include/duckdb/planner/binder.hpp
+++ /dev/null
@@ -1,437 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/parser/tableref/delimgetref.hpp"
-#include "duckdb/parser/tokens.hpp"
-#include "duckdb/planner/bind_context.hpp"
-#include "duckdb/planner/bound_statement.hpp"
-#include "duckdb/planner/bound_tokens.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/joinside.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/tableref/bound_delimgetref.hpp"
-
-namespace duckdb {
-class BoundResultModifier;
-class BoundSelectNode;
-class ClientContext;
-class ExpressionBinder;
-class LimitModifier;
-class OrderBinder;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class TableMacroCatalogEntry;
-class UpdateSetInfo;
-class LogicalProjection;
-class LogicalVacuum;
-
-class ColumnList;
-class ExternalDependency;
-class TableFunction;
-class TableStorageInfo;
-class BoundConstraint;
-
-struct CreateInfo;
-struct BoundCreateTableInfo;
-struct CommonTableExpressionInfo;
-struct BoundParameterMap;
-struct BoundPragmaInfo;
-struct BoundLimitNode;
-struct PivotColumnEntry;
-struct UnpivotEntry;
-
-enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES, EXTRACT_REPLACEMENT_SCANS };
-enum class BinderType : uint8_t { REGULAR_BINDER, VIEW_BINDER };
-
-struct CorrelatedColumnInfo {
-	ColumnBinding binding;
-	LogicalType type;
-	string name;
-	idx_t depth;
-
-	// NOLINTNEXTLINE - work-around bug in clang-tidy
-	CorrelatedColumnInfo(ColumnBinding binding, LogicalType type_p, string name_p, idx_t depth)
-	    : binding(binding), type(std::move(type_p)), name(std::move(name_p)), depth(depth) {
-	}
-	explicit CorrelatedColumnInfo(BoundColumnRefExpression &expr)
-	    : CorrelatedColumnInfo(expr.binding, expr.return_type, expr.GetName(), expr.depth) {
-	}
-
-	bool operator==(const CorrelatedColumnInfo &rhs) const {
-		return binding == rhs.binding;
-	}
-};
-
-//! Bind the parsed query tree to the actual columns present in the catalog.
-/*!
-  The binder is responsible for binding tables and columns to actual physical
-  tables and columns in the catalog. In the process, it also resolves types of
-  all expressions.
-*/
-class Binder : public enable_shared_from_this<Binder> {
-	friend class ExpressionBinder;
-	friend class RecursiveDependentJoinPlanner;
-
-public:
-	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, optional_ptr<Binder> parent = nullptr,
-	                                                  BinderType binder_type = BinderType::REGULAR_BINDER);
-
-	//! The client context
-	ClientContext &context;
-	//! A mapping of names to common table expressions
-	case_insensitive_map_t<reference<CommonTableExpressionInfo>> CTE_bindings; // NOLINT
-	//! The CTEs that have already been bound
-	reference_set_t<CommonTableExpressionInfo> bound_ctes;
-	//! The bind context
-	BindContext bind_context;
-	//! The set of correlated columns bound by this binder (FIXME: this should probably be an unordered_set and not a
-	//! vector)
-	vector<CorrelatedColumnInfo> correlated_columns;
-	//! The set of parameter expressions bound by this binder
-	optional_ptr<BoundParameterMap> parameters;
-	//! The alias for the currently processing subquery, if it exists
-	string alias;
-	//! Macro parameter bindings (if any)
-	optional_ptr<DummyBinding> macro_binding;
-	//! The intermediate lambda bindings to bind nested lambdas (if any)
-	optional_ptr<vector<DummyBinding>> lambda_bindings;
-
-	unordered_map<idx_t, LogicalOperator *> recursive_ctes;
-
-public:
-	DUCKDB_API BoundStatement Bind(SQLStatement &statement);
-	DUCKDB_API BoundStatement Bind(QueryNode &node);
-
-	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
-	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema);
-	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema,
-	                                                     vector<unique_ptr<Expression>> &bound_defaults);
-	static unique_ptr<BoundCreateTableInfo> BindCreateTableCheckpoint(unique_ptr<CreateInfo> info,
-	                                                                  SchemaCatalogEntry &schema);
-
-	static vector<unique_ptr<BoundConstraint>> BindConstraints(ClientContext &context,
-	                                                           const vector<unique_ptr<Constraint>> &constraints,
-	                                                           const string &table_name, const ColumnList &columns);
-	vector<unique_ptr<BoundConstraint>> BindConstraints(const vector<unique_ptr<Constraint>> &constraints,
-	                                                    const string &table_name, const ColumnList &columns);
-	vector<unique_ptr<BoundConstraint>> BindConstraints(const TableCatalogEntry &table);
-	vector<unique_ptr<BoundConstraint>> BindNewConstraints(vector<unique_ptr<Constraint>> &constraints,
-	                                                       const string &table_name, const ColumnList &columns);
-	unique_ptr<BoundConstraint> BindConstraint(Constraint &constraint, const string &table, const ColumnList &columns);
-	unique_ptr<BoundConstraint> BindUniqueConstraint(Constraint &constraint, const string &table,
-	                                                 const ColumnList &columns);
-
-	BoundStatement BindAlterAddIndex(BoundStatement &result, CatalogEntry &entry, unique_ptr<AlterInfo> alter_info);
-
-	void SetCatalogLookupCallback(catalog_entry_callback_t callback);
-	void BindCreateViewInfo(CreateViewInfo &base);
-	SchemaCatalogEntry &BindSchema(CreateInfo &info);
-	SchemaCatalogEntry &BindCreateFunctionInfo(CreateInfo &info);
-
-	//! Check usage, and cast named parameters to their types
-	static void BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
-	                                QueryErrorContext &error_context, string &func_name);
-	unique_ptr<BoundPragmaInfo> BindPragma(PragmaInfo &info, QueryErrorContext error_context);
-
-	unique_ptr<BoundTableRef> Bind(TableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundTableRef &ref);
-
-	//! Generates an unused index for a table
-	idx_t GenerateTableIndex();
-
-	optional_ptr<CatalogEntry> GetCatalogEntry(CatalogType type, const string &catalog, const string &schema,
-	                                           const string &name, OnEntryNotFound on_entry_not_found,
-	                                           QueryErrorContext &error_context);
-
-	//! Add a common table expression to the binder
-	void AddCTE(const string &name, CommonTableExpressionInfo &cte);
-	//! Find all candidate common table expression by name; returns empty vector if none exists
-	vector<reference<CommonTableExpressionInfo>> FindCTE(const string &name, bool skip = false);
-
-	bool CTEIsAlreadyBound(CommonTableExpressionInfo &cte);
-
-	//! Add the view to the set of currently bound views - used for detecting recursive view definitions
-	void AddBoundView(ViewCatalogEntry &view);
-
-	void PushExpressionBinder(ExpressionBinder &binder);
-	void PopExpressionBinder();
-	void SetActiveBinder(ExpressionBinder &binder);
-	ExpressionBinder &GetActiveBinder();
-	bool HasActiveBinder();
-
-	vector<reference<ExpressionBinder>> &GetActiveBinders();
-
-	void MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other);
-	//! Add a correlated column to this binder (if it does not exist)
-	void AddCorrelatedColumn(const CorrelatedColumnInfo &info);
-
-	unique_ptr<LogicalOperator> BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
-	                                          UpdateSetInfo &set_info, TableCatalogEntry &table,
-	                                          vector<PhysicalIndex> &columns);
-	void BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert &insert, UpdateSetInfo &set_info,
-	                                TableCatalogEntry &table, TableStorageInfo &storage_info);
-	void BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt);
-
-	void BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator> &root);
-
-	static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema);
-	void BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog = nullptr,
-	                     const string &schema = INVALID_SCHEMA);
-
-	optional_ptr<Binding> GetMatchingBinding(const string &table_name, const string &column_name, ErrorData &error);
-	optional_ptr<Binding> GetMatchingBinding(const string &schema_name, const string &table_name,
-	                                         const string &column_name, ErrorData &error);
-	optional_ptr<Binding> GetMatchingBinding(const string &catalog_name, const string &schema_name,
-	                                         const string &table_name, const string &column_name, ErrorData &error);
-
-	void SetBindingMode(BindingMode mode);
-	BindingMode GetBindingMode();
-	void AddTableName(string table_name);
-	void AddReplacementScan(const string &table_name, unique_ptr<TableRef> replacement);
-	const unordered_set<string> &GetTableNames();
-	case_insensitive_map_t<unique_ptr<TableRef>> &GetReplacementScans();
-	optional_ptr<SQLStatement> GetRootStatement() {
-		return root_statement;
-	}
-	CatalogEntryRetriever &EntryRetriever() {
-		return entry_retriever;
-	}
-	//! Returns a ColumnRefExpression after it was resolved (i.e. past the STAR expression/USING clauses)
-	static optional_ptr<ParsedExpression> GetResolvedColumnExpression(ParsedExpression &root_expr);
-
-	void SetCanContainNulls(bool can_contain_nulls);
-	void SetAlwaysRequireRebind();
-
-	StatementProperties &GetStatementProperties();
-
-private:
-	//! The parent binder (if any)
-	shared_ptr<Binder> parent;
-	//! The vector of active binders
-	vector<reference<ExpressionBinder>> active_binders;
-	//! The count of bound_tables
-	idx_t bound_tables;
-	//! Whether or not the binder has any unplanned dependent joins that still need to be planned/flattened
-	bool has_unplanned_dependent_joins = false;
-	//! Whether or not outside dependent joins have been planned and flattened
-	bool is_outside_flattened = true;
-	//! What kind of node we are binding using this binder
-	BinderType binder_type = BinderType::REGULAR_BINDER;
-	//! Whether or not the binder can contain NULLs as the root of expressions
-	bool can_contain_nulls = false;
-	//! The root statement of the query that is currently being parsed
-	optional_ptr<SQLStatement> root_statement;
-	//! Binding mode
-	BindingMode mode = BindingMode::STANDARD_BINDING;
-	//! Table names extracted for BindingMode::EXTRACT_NAMES
-	unordered_set<string> table_names;
-	//! Replacement Scans extracted for BindingMode::EXTRACT_REPLACEMENT_SCANS
-	case_insensitive_map_t<unique_ptr<TableRef>> replacement_scans;
-	//! The set of bound views
-	reference_set_t<ViewCatalogEntry> bound_views;
-	//! Used to retrieve CatalogEntry's
-	CatalogEntryRetriever entry_retriever;
-	//! Unnamed subquery index
-	idx_t unnamed_subquery_index = 1;
-	//! Statement properties
-	StatementProperties prop;
-
-private:
-	//! Get the root binder (binder with no parent)
-	Binder &GetRootBinder();
-	//! Determine the depth of the binder
-	idx_t GetBinderDepth() const;
-	//! Bind the expressions of generated columns to check for errors
-	void BindGeneratedColumns(BoundCreateTableInfo &info);
-	//! Bind the default values of the columns of a table
-	void BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults,
-	                       const string &catalog = "", const string &schema = "");
-	//! Bind a limit value (LIMIT or OFFSET)
-	BoundLimitNode BindLimitValue(OrderBinder &order_binder, unique_ptr<ParsedExpression> limit_val, bool is_percentage,
-	                              bool is_offset);
-
-	//! Move correlated expressions from the child binder to this binder
-	void MoveCorrelatedExpressions(Binder &other);
-
-	//! Tries to bind the table name with replacement scans
-	unique_ptr<BoundTableRef> BindWithReplacementScan(ClientContext &context, BaseTableRef &ref);
-
-	template <class T>
-	BoundStatement BindWithCTE(T &statement);
-	BoundStatement Bind(SelectStatement &stmt);
-	BoundStatement Bind(InsertStatement &stmt);
-	BoundStatement Bind(CopyStatement &stmt, CopyToType copy_to_type);
-	BoundStatement Bind(DeleteStatement &stmt);
-	BoundStatement Bind(UpdateStatement &stmt);
-	BoundStatement Bind(CreateStatement &stmt);
-	BoundStatement Bind(DropStatement &stmt);
-	BoundStatement Bind(AlterStatement &stmt);
-	BoundStatement Bind(PrepareStatement &stmt);
-	BoundStatement Bind(ExecuteStatement &stmt);
-	BoundStatement Bind(TransactionStatement &stmt);
-	BoundStatement Bind(PragmaStatement &stmt);
-	BoundStatement Bind(ExplainStatement &stmt);
-	BoundStatement Bind(VacuumStatement &stmt);
-	BoundStatement Bind(RelationStatement &stmt);
-	BoundStatement Bind(CallStatement &stmt);
-	BoundStatement Bind(ExportStatement &stmt);
-	BoundStatement Bind(ExtensionStatement &stmt);
-	BoundStatement Bind(SetStatement &stmt);
-	BoundStatement Bind(SetVariableStatement &stmt);
-	BoundStatement Bind(ResetVariableStatement &stmt);
-	BoundStatement Bind(LoadStatement &stmt);
-	BoundStatement Bind(LogicalPlanStatement &stmt);
-	BoundStatement Bind(AttachStatement &stmt);
-	BoundStatement Bind(DetachStatement &stmt);
-	BoundStatement Bind(CopyDatabaseStatement &stmt);
-	BoundStatement Bind(UpdateExtensionsStatement &stmt);
-
-	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry &table,
-	                             const string &alias, idx_t update_table_index,
-	                             unique_ptr<LogicalOperator> child_operator, BoundStatement result);
-
-	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func, idx_t depth);
-
-	unique_ptr<BoundCTENode> BindMaterializedCTE(CommonTableExpressionMap &cte_map);
-	unique_ptr<BoundCTENode> BindCTE(CTENode &statement);
-	//! Materializes CTEs if this is expected to improve performance
-	bool OptimizeCTEs(QueryNode &node);
-
-	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
-	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
-	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
-	unique_ptr<BoundQueryNode> BindNode(CTENode &node);
-	unique_ptr<BoundQueryNode> BindNode(QueryNode &node);
-
-	unique_ptr<LogicalOperator> VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root);
-	unique_ptr<LogicalOperator> CreatePlan(BoundRecursiveCTENode &node);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node, unique_ptr<LogicalOperator> base);
-	unique_ptr<LogicalOperator> CreatePlan(BoundSelectNode &statement);
-	unique_ptr<LogicalOperator> CreatePlan(BoundSetOperationNode &node);
-	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);
-
-	unique_ptr<BoundTableRef> BindJoin(Binder &parent, TableRef &ref);
-	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
-	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
-	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte = nullptr);
-	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
-	unique_ptr<BoundTableRef> Bind(EmptyTableRef &ref);
-	unique_ptr<BoundTableRef> Bind(DelimGetRef &ref);
-	unique_ptr<BoundTableRef> Bind(ExpressionListRef &ref);
-	unique_ptr<BoundTableRef> Bind(ColumnDataRef &ref);
-	unique_ptr<BoundTableRef> Bind(PivotRef &expr);
-	unique_ptr<BoundTableRef> Bind(ShowRef &ref);
-
-	unique_ptr<SelectNode> BindPivot(PivotRef &expr, vector<unique_ptr<ParsedExpression>> all_columns);
-	unique_ptr<SelectNode> BindUnpivot(Binder &child_binder, PivotRef &expr,
-	                                   vector<unique_ptr<ParsedExpression>> all_columns,
-	                                   unique_ptr<ParsedExpression> &where_clause);
-	unique_ptr<BoundTableRef> BindBoundPivot(PivotRef &expr);
-	void ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry, vector<UnpivotEntry> &unpivot_entries);
-	void ExtractUnpivotColumnName(ParsedExpression &expr, vector<string> &result);
-
-	bool BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
-	                                 vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
-	                                 vector<Value> &parameters, named_parameter_map_t &named_parameters,
-	                                 unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error);
-	void BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-	                                 unique_ptr<BoundSubqueryRef> &subquery);
-	unique_ptr<LogicalOperator> BindTableFunction(TableFunction &function, vector<Value> parameters);
-	unique_ptr<LogicalOperator> BindTableFunctionInternal(TableFunction &table_function, const TableFunctionRef &ref,
-	                                                      vector<Value> parameters,
-	                                                      named_parameter_map_t named_parameters,
-	                                                      vector<LogicalType> input_table_types,
-	                                                      vector<string> input_table_names);
-
-	unique_ptr<LogicalOperator> CreatePlan(BoundBaseTableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundJoinRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundSubqueryRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundTableFunction &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundEmptyTableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundExpressionListRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundColumnDataRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCTERef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundPivotRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundDelimGetRef &ref);
-
-	BoundStatement BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type);
-	BoundStatement BindCopyFrom(CopyStatement &stmt);
-
-	void PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result);
-	void BindModifiers(BoundQueryNode &result, idx_t table_index, const vector<string> &names,
-	                   const vector<LogicalType> &sql_types, const SelectBindState &bind_state);
-
-	unique_ptr<BoundResultModifier> BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod);
-	unique_ptr<BoundResultModifier> BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod);
-	unique_ptr<Expression> BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr);
-
-	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);
-
-	void PlanSubqueries(unique_ptr<Expression> &expr, unique_ptr<LogicalOperator> &root);
-	unique_ptr<Expression> PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root);
-	unique_ptr<LogicalOperator> PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                                            vector<CorrelatedColumnInfo> &correlated_columns,
-	                                            JoinType join_type = JoinType::INNER,
-	                                            unique_ptr<Expression> condition = nullptr);
-
-	unique_ptr<LogicalOperator> CastLogicalOperatorToTypes(vector<LogicalType> &source_types,
-	                                                       vector<LogicalType> &target_types,
-	                                                       unique_ptr<LogicalOperator> op);
-
-	BindingAlias FindBinding(const string &using_column, const string &join_side);
-	bool TryFindBinding(const string &using_column, const string &join_side, BindingAlias &result);
-
-	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
-	BindingAlias RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
-	                                  const string &column_name, const string &join_side);
-
-	void AddCTEMap(CommonTableExpressionMap &cte_map);
-
-	void ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
-	                           vector<unique_ptr<ParsedExpression>> &new_select_list);
-	void ExpandStarExpression(unique_ptr<ParsedExpression> expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
-	bool FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpression **star, bool is_root, bool in_columns);
-	void ReplaceUnpackedStarExpression(unique_ptr<ParsedExpression> &expr,
-	                                   vector<unique_ptr<ParsedExpression>> &replacements);
-	void ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement);
-	void BindWhereStarExpression(unique_ptr<ParsedExpression> &expr);
-
-	//! If only a schema name is provided (e.g. "a.b") then figure out if "a" is a schema or a catalog name
-	void BindSchemaOrCatalog(string &catalog_name, string &schema_name);
-	const string BindCatalog(string &catalog_name);
-	SchemaCatalogEntry &BindCreateSchema(CreateInfo &info);
-
-	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
-
-	unique_ptr<LogicalOperator> BindCopyDatabaseSchema(Catalog &source_catalog, const string &target_database_name);
-	unique_ptr<LogicalOperator> BindCopyDatabaseData(Catalog &source_catalog, const string &target_database_name);
-
-	unique_ptr<BoundTableRef> BindShowQuery(ShowRef &ref);
-	unique_ptr<BoundTableRef> BindShowTable(ShowRef &ref);
-	unique_ptr<BoundTableRef> BindSummarize(ShowRef &ref);
-
-	unique_ptr<LogicalOperator> UnionOperators(vector<unique_ptr<LogicalOperator>> nodes);
-
-private:
-	Binder(ClientContext &context, shared_ptr<Binder> parent, BinderType binder_type);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/binding_alias.hpp b/src/duckdb/src/include/duckdb/planner/binding_alias.hpp
deleted file mode 100644
index 2d85b521e..000000000
--- a/src/duckdb/src/include/duckdb/planner/binding_alias.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/binding_alias.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-class StandardEntry;
-
-struct BindingAlias {
-	BindingAlias();
-	explicit BindingAlias(string alias);
-	BindingAlias(string schema, string alias);
-	BindingAlias(string catalog, string schema, string alias);
-	explicit BindingAlias(const StandardEntry &entry);
-
-	bool IsSet() const;
-	const string &GetAlias() const;
-
-	const string &GetCatalog() const {
-		return catalog;
-	}
-	const string &GetSchema() const {
-		return schema;
-	}
-
-	bool Matches(const BindingAlias &other) const;
-	bool operator==(const BindingAlias &other) const;
-	string ToString() const;
-
-private:
-	string catalog;
-	string schema;
-	string alias;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_constraint.hpp b/src/duckdb/src/include/duckdb/planner/bound_constraint.hpp
deleted file mode 100644
index c8205e48d..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_constraint.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-//! Bound equivalent of Constraint
-class BoundConstraint {
-public:
-	explicit BoundConstraint(ConstraintType type) : type(type) {};
-	virtual ~BoundConstraint() {
-	}
-
-	ConstraintType type;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast constraint to type - bound constraint type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast constraint to type - bound constraint type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_parameter_map.hpp b/src/duckdb/src/include/duckdb/planner/bound_parameter_map.hpp
deleted file mode 100644
index 33ce5cf00..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_parameter_map.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_parameter_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-class ParameterExpression;
-class BoundParameterExpression;
-
-using bound_parameter_map_t = case_insensitive_map_t<shared_ptr<BoundParameterData>>;
-
-struct BoundParameterMap {
-public:
-	explicit BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data);
-
-public:
-	LogicalType GetReturnType(const string &identifier);
-
-	bound_parameter_map_t *GetParametersPtr();
-
-	const bound_parameter_map_t &GetParameters();
-
-	const case_insensitive_map_t<BoundParameterData> &GetParameterData();
-
-	unique_ptr<BoundParameterExpression> BindParameterExpression(ParameterExpression &expr);
-
-	//! Flag to indicate that we need to rebind this prepared statement before execution
-	bool rebind = false;
-
-private:
-	shared_ptr<BoundParameterData> CreateOrGetData(const string &identifier);
-	void CreateNewParameter(const string &id, const shared_ptr<BoundParameterData> &param_data);
-
-private:
-	bound_parameter_map_t parameters;
-	// Pre-provided parameter data if populated
-	case_insensitive_map_t<BoundParameterData> &parameter_data;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_query_node.hpp b/src/duckdb/src/include/duckdb/planner/bound_query_node.hpp
deleted file mode 100644
index cd5a78b6a..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_query_node.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_query_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-//! Bound equivalent of QueryNode
-class BoundQueryNode {
-public:
-	explicit BoundQueryNode(QueryNodeType type) : type(type) {
-	}
-	virtual ~BoundQueryNode() {
-	}
-
-	//! The type of the query node, either SetOperation or Select
-	QueryNodeType type;
-	//! The result modifiers that should be applied to this query node
-	vector<unique_ptr<BoundResultModifier>> modifiers;
-
-	//! The names returned by this QueryNode.
-	vector<string> names;
-	//! The types returned by this QueryNode.
-	vector<LogicalType> types;
-
-public:
-	virtual idx_t GetRootIndex() = 0;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast bound query node to type - query node type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast bound query node to type - query node type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp b/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp
deleted file mode 100644
index ab0b64dde..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp
+++ /dev/null
@@ -1,176 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_result_modifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/planner/bound_statement.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-//! A ResultModifier
-class BoundResultModifier {
-public:
-	explicit BoundResultModifier(ResultModifierType type);
-	virtual ~BoundResultModifier();
-
-	ResultModifierType type;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast result modifier to type - result modifier type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast result modifier to type - result modifier type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct BoundOrderByNode {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::ORDER_MODIFIER;
-
-public:
-	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression);
-	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression,
-	                 unique_ptr<BaseStatistics> stats);
-
-	OrderType type;
-	OrderByNullType null_order;
-	unique_ptr<Expression> expression;
-	unique_ptr<BaseStatistics> stats;
-
-public:
-	BoundOrderByNode Copy() const;
-	bool Equals(const BoundOrderByNode &other) const;
-	string ToString() const;
-
-	void Serialize(Serializer &serializer) const;
-	static BoundOrderByNode Deserialize(Deserializer &deserializer);
-};
-
-enum class LimitNodeType : uint8_t {
-	UNSET = 0,
-	CONSTANT_VALUE = 1,
-	CONSTANT_PERCENTAGE = 2,
-	EXPRESSION_VALUE = 3,
-	EXPRESSION_PERCENTAGE = 4
-};
-
-struct BoundLimitNode {
-public:
-	BoundLimitNode();
-	BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage,
-	               unique_ptr<Expression> expression);
-
-public:
-	static BoundLimitNode ConstantValue(int64_t value);
-	static BoundLimitNode ConstantPercentage(double percentage);
-	static BoundLimitNode ExpressionValue(unique_ptr<Expression> expression);
-	static BoundLimitNode ExpressionPercentage(unique_ptr<Expression> expression);
-
-	LimitNodeType Type() const {
-		return type;
-	}
-
-	//! Returns the constant value, only valid if Type() == CONSTANT_VALUE
-	idx_t GetConstantValue() const;
-	//! Returns the constant percentage, only valid if Type() == CONSTANT_PERCENTAGE
-	double GetConstantPercentage() const;
-	//! Returns the constant percentage, only valid if Type() == EXPRESSION_VALUE
-	const Expression &GetValueExpression() const;
-	//! Returns the constant percentage, only valid if Type() == EXPRESSION_PERCENTAGE
-	const Expression &GetPercentageExpression() const;
-
-	//! Returns a pointer to the expression - should only be used for limit-agnostic optimizations.
-	//! Prefer using the methods above in other scenarios.
-	unique_ptr<Expression> &GetExpression() {
-		return expression;
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static BoundLimitNode Deserialize(Deserializer &deserializer);
-
-private:
-	LimitNodeType type = LimitNodeType::UNSET;
-	//! Integer value, if value is a constant non-percentage
-	idx_t constant_integer = 0;
-	//! Percentage value, if value is a constant percentage
-	double constant_percentage = -1;
-	//! Expression in case node is not constant
-	unique_ptr<Expression> expression;
-
-private:
-	explicit BoundLimitNode(int64_t constant_value);
-	explicit BoundLimitNode(double percentage_value);
-	explicit BoundLimitNode(unique_ptr<Expression> expression, bool is_percentage);
-};
-
-class BoundLimitModifier : public BoundResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_MODIFIER;
-
-public:
-	BoundLimitModifier();
-
-	//! LIMIT
-	BoundLimitNode limit_val;
-	//! OFFSET
-	BoundLimitNode offset_val;
-};
-
-class BoundOrderModifier : public BoundResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::ORDER_MODIFIER;
-
-public:
-	BoundOrderModifier();
-
-	//! List of order nodes
-	vector<BoundOrderByNode> orders;
-
-	unique_ptr<BoundOrderModifier> Copy() const;
-	static bool Equals(const BoundOrderModifier &left, const BoundOrderModifier &right);
-	static bool Equals(const unique_ptr<BoundOrderModifier> &left, const unique_ptr<BoundOrderModifier> &right);
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<BoundOrderModifier> Deserialize(Deserializer &deserializer);
-
-	//! Remove unneeded/duplicate order elements.
-	//! Returns true of orders is not empty.
-	static bool Simplify(vector<BoundOrderByNode> &orders, const vector<unique_ptr<Expression>> &groups);
-	bool Simplify(const vector<unique_ptr<Expression>> &groups);
-};
-
-enum class DistinctType : uint8_t { DISTINCT = 0, DISTINCT_ON = 1 };
-
-class BoundDistinctModifier : public BoundResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::DISTINCT_MODIFIER;
-
-public:
-	BoundDistinctModifier();
-
-	//! Whether or not this is a DISTINCT or DISTINCT ON
-	DistinctType distinct_type;
-	//! list of distinct on targets
-	vector<unique_ptr<Expression>> target_distincts;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_statement.hpp b/src/duckdb/src/include/duckdb/planner/bound_statement.hpp
deleted file mode 100644
index bb1f7bfec..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_statement.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class LogicalOperator;
-struct LogicalType;
-
-struct BoundStatement {
-	unique_ptr<LogicalOperator> plan;
-	vector<LogicalType> types;
-	vector<string> names;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_tableref.hpp b/src/duckdb/src/include/duckdb/planner/bound_tableref.hpp
deleted file mode 100644
index 0a831c54a..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_tableref.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_tableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/tableref_type.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-
-namespace duckdb {
-
-class BoundTableRef {
-public:
-	explicit BoundTableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~BoundTableRef() {
-	}
-
-	//! The type of table reference
-	TableReferenceType type;
-	//! The sample options (if any)
-	unique_ptr<SampleOptions> sample;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast bound table ref to type - table ref type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast bound table ref to type - table ref type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/bound_tokens.hpp b/src/duckdb/src/include/duckdb/planner/bound_tokens.hpp
deleted file mode 100644
index 978003488..000000000
--- a/src/duckdb/src/include/duckdb/planner/bound_tokens.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_tokens.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Query Node
-//===--------------------------------------------------------------------===//
-class BoundQueryNode;
-class BoundSelectNode;
-class BoundSetOperationNode;
-class BoundRecursiveCTENode;
-class BoundCTENode;
-
-//===--------------------------------------------------------------------===//
-// Expressions
-//===--------------------------------------------------------------------===//
-class Expression;
-
-class BoundAggregateExpression;
-class BoundBetweenExpression;
-class BoundCaseExpression;
-class BoundCastExpression;
-class BoundColumnRefExpression;
-class BoundComparisonExpression;
-class BoundConjunctionExpression;
-class BoundConstantExpression;
-class BoundDefaultExpression;
-class BoundFunctionExpression;
-class BoundOperatorExpression;
-class BoundParameterExpression;
-class BoundReferenceExpression;
-class BoundSubqueryExpression;
-class BoundUnnestExpression;
-class BoundWindowExpression;
-
-//===--------------------------------------------------------------------===//
-// TableRefs
-//===--------------------------------------------------------------------===//
-class BoundTableRef;
-
-class BoundBaseTableRef;
-class BoundJoinRef;
-class BoundSubqueryRef;
-class BoundTableFunction;
-class BoundEmptyTableRef;
-class BoundExpressionListRef;
-class BoundColumnDataRef;
-class BoundCTERef;
-class BoundPivotRef;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/collation_binding.hpp b/src/duckdb/src/include/duckdb/planner/collation_binding.hpp
deleted file mode 100644
index aa82a71a2..000000000
--- a/src/duckdb/src/include/duckdb/planner/collation_binding.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/collation_binding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/common/enums/collation_type.hpp"
-
-namespace duckdb {
-struct MapCastInfo;
-struct MapCastNode;
-struct DBConfig;
-
-typedef bool (*try_push_collation_t)(ClientContext &context, unique_ptr<Expression> &source,
-                                     const LogicalType &sql_type, CollationType type);
-
-struct CollationCallback {
-	explicit CollationCallback(try_push_collation_t try_push_collation_p) : try_push_collation(try_push_collation_p) {
-	}
-
-	try_push_collation_t try_push_collation;
-};
-
-class CollationBinding {
-public:
-	CollationBinding();
-
-public:
-	DUCKDB_API static CollationBinding &Get(ClientContext &context);
-	DUCKDB_API static CollationBinding &Get(DatabaseInstance &db);
-
-	DUCKDB_API void RegisterCollation(CollationCallback callback);
-	DUCKDB_API bool PushCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
-	                              CollationType type) const;
-
-private:
-	vector<CollationCallback> collations;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/column_binding.hpp b/src/duckdb/src/include/duckdb/planner/column_binding.hpp
deleted file mode 100644
index 0972e1b4e..000000000
--- a/src/duckdb/src/include/duckdb/planner/column_binding.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/column_binding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/to_string.hpp"
-
-#include <functional>
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-
-struct ColumnBinding {
-	idx_t table_index;
-	// This index is local to a Binding, and has no meaning outside of the context of the Binding that created it
-	idx_t column_index;
-
-	ColumnBinding() : table_index(DConstants::INVALID_INDEX), column_index(DConstants::INVALID_INDEX) {
-	}
-	ColumnBinding(idx_t table, idx_t column) : table_index(table), column_index(column) {
-	}
-
-	string ToString() const {
-		return "#[" + to_string(table_index) + "." + to_string(column_index) + "]";
-	}
-
-	bool operator==(const ColumnBinding &rhs) const {
-		return table_index == rhs.table_index && column_index == rhs.column_index;
-	}
-
-	bool operator!=(const ColumnBinding &rhs) const {
-		return !(*this == rhs);
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static ColumnBinding Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/column_binding_map.hpp b/src/duckdb/src/include/duckdb/planner/column_binding_map.hpp
deleted file mode 100644
index 8c1b84f0e..000000000
--- a/src/duckdb/src/include/duckdb/planner/column_binding_map.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/column_binding_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/column_binding.hpp"
-
-namespace duckdb {
-
-struct ColumnBindingHashFunction {
-	uint64_t operator()(const ColumnBinding &a) const {
-		return CombineHash(Hash<idx_t>(a.table_index), Hash<idx_t>(a.column_index));
-	}
-};
-
-struct ColumnBindingEquality {
-	bool operator()(const ColumnBinding &a, const ColumnBinding &b) const {
-		return a == b;
-	}
-};
-
-template <typename T>
-using column_binding_map_t = unordered_map<ColumnBinding, T, ColumnBindingHashFunction, ColumnBindingEquality>;
-
-using column_binding_set_t = unordered_set<ColumnBinding, ColumnBindingHashFunction, ColumnBindingEquality>;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/constraints/bound_check_constraint.hpp b/src/duckdb/src/include/duckdb/planner/constraints/bound_check_constraint.hpp
deleted file mode 100644
index 8dd343282..000000000
--- a/src/duckdb/src/include/duckdb/planner/constraints/bound_check_constraint.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_check_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/common/index_map.hpp"
-
-namespace duckdb {
-
-//! The CheckConstraint contains an expression that must evaluate to TRUE for
-//! every row in a table
-class BoundCheckConstraint : public BoundConstraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::CHECK;
-
-public:
-	BoundCheckConstraint() : BoundConstraint(ConstraintType::CHECK) {
-	}
-
-	//! The expression
-	unique_ptr<Expression> expression;
-	//! The columns used by the CHECK constraint
-	physical_index_set_t bound_columns;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/constraints/bound_foreign_key_constraint.hpp b/src/duckdb/src/include/duckdb/planner/constraints/bound_foreign_key_constraint.hpp
deleted file mode 100644
index 6f90dee58..000000000
--- a/src/duckdb/src/include/duckdb/planner/constraints/bound_foreign_key_constraint.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_foreign_key_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/common/index_map.hpp"
-
-namespace duckdb {
-
-class BoundForeignKeyConstraint : public BoundConstraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::FOREIGN_KEY;
-
-public:
-	BoundForeignKeyConstraint(ForeignKeyInfo info_p, physical_index_set_t pk_key_set_p,
-	                          physical_index_set_t fk_key_set_p)
-	    : BoundConstraint(ConstraintType::FOREIGN_KEY), info(std::move(info_p)), pk_key_set(std::move(pk_key_set_p)),
-	      fk_key_set(std::move(fk_key_set_p)) {
-#ifdef DEBUG
-		D_ASSERT(info.pk_keys.size() == pk_key_set.size());
-		for (auto &key : info.pk_keys) {
-			D_ASSERT(pk_key_set.find(key) != pk_key_set.end());
-		}
-		D_ASSERT(info.fk_keys.size() == fk_key_set.size());
-		for (auto &key : info.fk_keys) {
-			D_ASSERT(fk_key_set.find(key) != fk_key_set.end());
-		}
-#endif
-	}
-
-	ForeignKeyInfo info;
-	//! The same keys but stored as an unordered set
-	physical_index_set_t pk_key_set;
-	//! The same keys but stored as an unordered set
-	physical_index_set_t fk_key_set;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/constraints/bound_not_null_constraint.hpp b/src/duckdb/src/include/duckdb/planner/constraints/bound_not_null_constraint.hpp
deleted file mode 100644
index 915517cf5..000000000
--- a/src/duckdb/src/include/duckdb/planner/constraints/bound_not_null_constraint.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_not_null_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_constraint.hpp"
-
-namespace duckdb {
-
-class BoundNotNullConstraint : public BoundConstraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::NOT_NULL;
-
-public:
-	explicit BoundNotNullConstraint(PhysicalIndex index) : BoundConstraint(ConstraintType::NOT_NULL), index(index) {
-	}
-
-	//! Column index this constraint pertains to
-	PhysicalIndex index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp b/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp
deleted file mode 100644
index b03f6ffef..000000000
--- a/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_unique_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/common/index_map.hpp"
-
-namespace duckdb {
-
-class BoundUniqueConstraint : public BoundConstraint {
-public:
-	static constexpr const ConstraintType TYPE = ConstraintType::UNIQUE;
-
-public:
-	BoundUniqueConstraint(vector<PhysicalIndex> keys_p, physical_index_set_t key_set_p, const bool is_primary_key)
-	    : BoundConstraint(ConstraintType::UNIQUE), keys(std::move(keys_p)), key_set(std::move(key_set_p)),
-	      is_primary_key(is_primary_key) {
-
-#ifdef DEBUG
-		D_ASSERT(keys.size() == key_set.size());
-		for (auto &key : keys) {
-			D_ASSERT(key_set.find(key) != key_set.end());
-		}
-#endif
-	}
-
-	//! The keys that define the unique constraint.
-	vector<PhysicalIndex> keys;
-	//! The same keys but stored as an unordered set.
-	physical_index_set_t key_set;
-	//! Whether this is a PRIMARY KEY constraint, or a UNIQUE constraint.
-	bool is_primary_key;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/constraints/list.hpp b/src/duckdb/src/include/duckdb/planner/constraints/list.hpp
deleted file mode 100644
index 396d0177e..000000000
--- a/src/duckdb/src/include/duckdb/planner/constraints/list.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-#include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
diff --git a/src/duckdb/src/include/duckdb/planner/expression.hpp b/src/duckdb/src/include/duckdb/planner/expression.hpp
deleted file mode 100644
index 97094bbde..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/base_expression.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-class ClientContext;
-
-//!  The Expression class represents a bound Expression with a return type
-class Expression : public BaseExpression {
-public:
-	Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type);
-	~Expression() override;
-
-	//! The return type of the expression
-	LogicalType return_type;
-	//! Expression statistics (if any) - ONLY USED FOR VERIFICATION
-	unique_ptr<BaseStatistics> verification_stats;
-
-public:
-	bool IsAggregate() const override;
-	bool IsWindow() const override;
-	bool HasSubquery() const override;
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-
-	virtual bool IsVolatile() const;
-	virtual bool IsConsistent() const;
-	virtual bool PropagatesNullValues() const;
-	virtual bool IsFoldable() const;
-	virtual bool CanThrow() const;
-
-	hash_t Hash() const override;
-
-	bool Equals(const BaseExpression &other) const override {
-		if (!BaseExpression::Equals(other)) {
-			return false;
-		}
-		return return_type == reinterpret_cast<const Expression &>(other).return_type;
-	}
-	static bool Equals(const Expression &left, const Expression &right) {
-		return left.Equals(right);
-	}
-	static bool Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right);
-	static bool ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right);
-	//! Create a copy of this expression
-	virtual unique_ptr<Expression> Copy() const = 0;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-
-protected:
-	//! Copy base Expression properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(const Expression &other) {
-		type = other.type;
-		expression_class = other.expression_class;
-		alias = other.alias;
-		return_type = other.return_type;
-		query_location = other.query_location;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp
deleted file mode 100644
index 9bbd5678e..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_aggregate_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include <memory>
-
-namespace duckdb {
-
-class BoundAggregateExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_AGGREGATE;
-
-public:
-	BoundAggregateExpression(AggregateFunction function, vector<unique_ptr<Expression>> children,
-	                         unique_ptr<Expression> filter, unique_ptr<FunctionData> bind_info,
-	                         AggregateType aggr_type);
-
-	//! The bound function expression
-	AggregateFunction function;
-	//! List of arguments to the function
-	vector<unique_ptr<Expression>> children;
-	//! The bound function data (if any)
-	unique_ptr<FunctionData> bind_info;
-	//! The aggregate type (distinct or non-distinct)
-	AggregateType aggr_type;
-
-	//! Filter for this aggregate
-	unique_ptr<Expression> filter;
-	//! The order by expression for this aggregate - if any
-	unique_ptr<BoundOrderModifier> order_bys;
-
-public:
-	bool IsDistinct() const {
-		return aggr_type == AggregateType::DISTINCT;
-	}
-
-	bool IsAggregate() const override {
-		return true;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-	bool PropagatesNullValues() const override;
-
-	string ToString() const override;
-
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression &other) const override;
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_between_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_between_expression.hpp
deleted file mode 100644
index 06d426a81..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_between_expression.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_between_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundBetweenExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_BETWEEN;
-
-public:
-	BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower, unique_ptr<Expression> upper,
-	                       bool lower_inclusive, bool upper_inclusive);
-
-	unique_ptr<Expression> input;
-	unique_ptr<Expression> lower;
-	unique_ptr<Expression> upper;
-	bool lower_inclusive;
-	bool upper_inclusive;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-
-public:
-	ExpressionType LowerComparisonType() {
-		return lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO : ExpressionType::COMPARE_GREATERTHAN;
-	}
-	ExpressionType UpperComparisonType() {
-		return upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
-	}
-
-private:
-	BoundBetweenExpression();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp
deleted file mode 100644
index fc554019b..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_case_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-struct BoundCaseCheck {
-	unique_ptr<Expression> when_expr;
-	unique_ptr<Expression> then_expr;
-
-	void Serialize(Serializer &serializer) const;
-	static BoundCaseCheck Deserialize(Deserializer &deserializer);
-};
-
-class BoundCaseExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CASE;
-
-public:
-	explicit BoundCaseExpression(LogicalType type);
-	BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,
-	                    unique_ptr<Expression> else_expr);
-
-	vector<BoundCaseCheck> case_checks;
-	unique_ptr<Expression> else_expr;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp
deleted file mode 100644
index c625fb4f9..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_cast_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/function/cast/default_casts.hpp"
-
-namespace duckdb {
-
-class BoundCastExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CAST;
-
-public:
-	BoundCastExpression(unique_ptr<Expression> child, LogicalType target_type, BoundCastInfo bound_cast,
-	                    bool try_cast = false);
-
-	//! The child type
-	unique_ptr<Expression> child;
-	//! Whether to use try_cast or not. try_cast converts cast failures into NULLs instead of throwing an error.
-	bool try_cast;
-	//! The bound cast info
-	BoundCastInfo bound_cast;
-
-public:
-	LogicalType source_type() { // NOLINT: allow casing for legacy reasons
-		D_ASSERT(child->return_type.IsValid());
-		return child->return_type;
-	}
-
-	//! Cast an expression to the specified SQL type, using only the built-in SQL casts
-	static unique_ptr<Expression> AddDefaultCastToType(unique_ptr<Expression> expr, const LogicalType &target_type,
-	                                                   bool try_cast = false);
-	//! Cast an expression to the specified SQL type if required
-	DUCKDB_API static unique_ptr<Expression> AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
-	                                                       const LogicalType &target_type, bool try_cast = false);
-
-	//! If the expression returns an array, cast it to return a list with the same child type. Otherwise do nothing.
-	DUCKDB_API static unique_ptr<Expression> AddArrayCastToList(ClientContext &context, unique_ptr<Expression> expr);
-
-	//! Returns true if a cast is invertible (i.e. CAST(s -> t -> s) = s for all values of s). This is not true for e.g.
-	//! boolean casts, because that can be e.g. -1 -> TRUE -> 1. This is necessary to prevent some optimizer bugs.
-	static bool CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type);
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	bool CanThrow() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-
-private:
-	BoundCastExpression(ClientContext &context, unique_ptr<Expression> child, LogicalType target_type);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp
deleted file mode 100644
index 3f6e79a4e..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_columnref_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! A BoundColumnRef expression represents a ColumnRef expression that was bound to an actual table and column index. It
-//! is not yet executable, however. The ColumnBindingResolver transforms the BoundColumnRefExpressions into
-//! BoundExpressions, which refer to indexes into the physical chunks that pass through the executor.
-class BoundColumnRefExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_COLUMN_REF;
-
-public:
-	BoundColumnRefExpression(LogicalType type, ColumnBinding binding, idx_t depth = 0);
-	BoundColumnRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t depth = 0);
-
-	//! Column index set by the binder, used to generate the final BoundExpression
-	ColumnBinding binding;
-	//! The subquery depth (i.e. depth 0 = current query, depth 1 = parent query, depth 2 = parent of parent, etc...).
-	//! This is only non-zero for correlated expressions inside subqueries.
-	idx_t depth;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-	string GetName() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_comparison_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_comparison_expression.hpp
deleted file mode 100644
index b4fe53d50..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_comparison_expression.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_comparison_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundComparisonExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_COMPARISON;
-
-public:
-	BoundComparisonExpression(ExpressionType type, unique_ptr<Expression> left, unique_ptr<Expression> right);
-
-	unique_ptr<Expression> left;
-	unique_ptr<Expression> right;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-
-public:
-	static LogicalType BindComparison(ClientContext &context, const LogicalType &left_type,
-	                                  const LogicalType &right_type, ExpressionType comparison_type);
-	static bool TryBindComparison(ClientContext &context, const LogicalType &left_type, const LogicalType &right_type,
-	                              LogicalType &result_type, ExpressionType comparison_type);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_conjunction_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_conjunction_expression.hpp
deleted file mode 100644
index e83f78f57..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_conjunction_expression.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_conjunction_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundConjunctionExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CONJUNCTION;
-
-public:
-	explicit BoundConjunctionExpression(ExpressionType type);
-	BoundConjunctionExpression(ExpressionType type, unique_ptr<Expression> left, unique_ptr<Expression> right);
-
-	vector<unique_ptr<Expression>> children;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	bool PropagatesNullValues() const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_constant_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_constant_expression.hpp
deleted file mode 100644
index 40b8ac8af..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_constant_expression.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_constant_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundConstantExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CONSTANT;
-
-public:
-	explicit BoundConstantExpression(Value value);
-
-	Value value;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp
deleted file mode 100644
index 2ed9622d4..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_default_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundDefaultExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_DEFAULT;
-
-public:
-	explicit BoundDefaultExpression(LogicalType type = LogicalType())
-	    : Expression(ExpressionType::VALUE_DEFAULT, ExpressionClass::BOUND_DEFAULT, std::move(type)) {
-	}
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override {
-		return "DEFAULT";
-	}
-
-	unique_ptr<Expression> Copy() const override {
-		return make_uniq<BoundDefaultExpression>(return_type);
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_expanded_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_expanded_expression.hpp
deleted file mode 100644
index 390e641c0..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_expanded_expression.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_expanded_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! BoundExpression is an intermediate dummy expression used by the binder.
-//! It holds a set of expressions that will be "expanded" in the select list of a query
-class BoundExpandedExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_EXPANDED;
-
-public:
-	explicit BoundExpandedExpression(vector<unique_ptr<Expression>> expanded_expressions);
-
-	vector<unique_ptr<Expression>> expanded_expressions;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp
deleted file mode 100644
index 1698670bf..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_function_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-class ScalarFunctionCatalogEntry;
-
-//! Represents a function call that has been bound to a base function
-class BoundFunctionExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_FUNCTION;
-
-public:
-	BoundFunctionExpression(LogicalType return_type, ScalarFunction bound_function,
-	                        vector<unique_ptr<Expression>> arguments, unique_ptr<FunctionData> bind_info,
-	                        bool is_operator = false);
-
-	//! The bound function expression
-	ScalarFunction function;
-	//! List of child-expressions of the function
-	vector<unique_ptr<Expression>> children;
-	//! The bound function data (if any)
-	unique_ptr<FunctionData> bind_info;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-
-public:
-	bool IsVolatile() const override;
-	bool IsConsistent() const override;
-	bool IsFoldable() const override;
-	bool CanThrow() const override;
-	string ToString() const override;
-	bool PropagatesNullValues() const override;
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-	void Verify() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_lambda_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_lambda_expression.hpp
deleted file mode 100644
index 8206ee9c8..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_lambda_expression.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_lambda_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/parser/expression/lambda_expression.hpp"
-
-namespace duckdb {
-
-class BoundLambdaExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_LAMBDA;
-
-public:
-	BoundLambdaExpression(ExpressionType type_p, LogicalType return_type_p, unique_ptr<Expression> lambda_expr_p,
-	                      idx_t parameter_count_p);
-
-	//! The lambda expression that we'll use in the expression executor during execution
-	unique_ptr<Expression> lambda_expr;
-	//! Non-lambda constants, column references, and outer lambda parameters that we need to pass
-	//! into the execution chunk
-	vector<unique_ptr<Expression>> captures;
-	//! The number of lhs parameters of the lambda function
-	idx_t parameter_count;
-
-public:
-	string ToString() const override;
-	bool Equals(const BaseExpression &other) const override;
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp
deleted file mode 100644
index f3fd9f20c..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_lambdaref_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! A BoundLambdaRef expression represents a LambdaRef expression that was bound to an lambda parameter
-//! in the lambda bindings vector. When capturing lambdas, the BoundLambdaRef becomes a
-//! BoundReferenceExpression, indexing the corresponding lambda parameter in the lambda bindings vector,
-//! which refers to the physical chunk of the lambda parameter during execution.
-class BoundLambdaRefExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_LAMBDA_REF;
-
-public:
-	BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_idx, idx_t depth = 0);
-	BoundLambdaRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t lambda_idx, idx_t depth = 0);
-	//! Column index set by the binder, used to generate the final BoundExpression
-	ColumnBinding binding;
-	//! The index of the lambda parameter in the lambda bindings vector
-	idx_t lambda_idx;
-	//! The subquery depth (i.e. depth 0 = current query, depth 1 = parent query, depth 2 = parent of parent, etc...).
-	//! This is only non-zero for correlated expressions inside subqueries.
-	idx_t depth;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_operator_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_operator_expression.hpp
deleted file mode 100644
index c0a2e2e0d..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_operator_expression.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_operator_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundOperatorExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_OPERATOR;
-
-public:
-	BoundOperatorExpression(ExpressionType type, LogicalType return_type);
-
-	vector<unique_ptr<Expression>> children;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp
deleted file mode 100644
index 181751c1e..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_parameter_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-namespace duckdb {
-
-struct BoundParameterData {
-public:
-	BoundParameterData() {
-	}
-	explicit BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
-	}
-	BoundParameterData(Value val, LogicalType type_p) : value(std::move(val)), return_type(std::move(type_p)) {
-	}
-
-private:
-	Value value;
-
-public:
-	LogicalType return_type;
-
-public:
-	void SetValue(Value val) {
-		value = std::move(val);
-	}
-
-	const Value &GetValue() const {
-		return value;
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static shared_ptr<BoundParameterData> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp
deleted file mode 100644
index 92db0a041..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_parameter_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
-
-namespace duckdb {
-
-class BoundParameterExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_PARAMETER;
-
-public:
-	explicit BoundParameterExpression(const string &identifier);
-
-	string identifier;
-	shared_ptr<BoundParameterData> parameter_data;
-
-public:
-	//! Invalidate a bound parameter expression - forcing a rebind on any subsequent filters
-	DUCKDB_API static void Invalidate(Expression &expr);
-	//! Invalidate all parameters within an expression
-	DUCKDB_API static void InvalidateRecursive(Expression &expr);
-
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-	bool IsFoldable() const override;
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-
-private:
-	BoundParameterExpression(bound_parameter_map_t &global_parameter_set, string identifier, LogicalType return_type,
-	                         shared_ptr<BoundParameterData> parameter_data);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp
deleted file mode 100644
index 23c894a50..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_reference_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! A BoundReferenceExpression represents a physical index into a DataChunk
-class BoundReferenceExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_REF;
-
-public:
-	BoundReferenceExpression(string alias, LogicalType type, idx_t index);
-	BoundReferenceExpression(LogicalType type, storage_t index);
-
-	//! Index used to access data in the chunks
-	storage_t index;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp
deleted file mode 100644
index 31501dd8c..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_subquery_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/subquery_type.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-class BoundSubqueryExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_SUBQUERY;
-
-public:
-	explicit BoundSubqueryExpression(LogicalType return_type);
-
-	bool IsCorrelated() const {
-		return !binder->correlated_columns.empty();
-	}
-
-	//! The binder used to bind the subquery node
-	shared_ptr<Binder> binder;
-	//! The bound subquery node
-	unique_ptr<BoundQueryNode> subquery;
-	//! The subquery type
-	SubqueryType subquery_type;
-	//! the child expressions to compare with (in case of IN, ANY, ALL operators)
-	vector<unique_ptr<Expression>> children;
-	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators)
-	ExpressionType comparison_type;
-	//! The LogicalTypes of the subquery result. Only used for ANY expressions.
-	vector<LogicalType> child_types;
-	//! The target LogicalType of the subquery result (i.e. to which type it should be casted, if child_type <>
-	//! child_target). Only used for ANY expressions.
-	LogicalType child_target;
-
-public:
-	bool HasSubquery() const override {
-		return true;
-	}
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	bool PropagatesNullValues() const override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp
deleted file mode 100644
index 51906548c..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_unnest_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! Represents a function call that has been bound to a base function
-class BoundUnnestExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_UNNEST;
-
-public:
-	explicit BoundUnnestExpression(LogicalType return_type);
-
-	unique_ptr<Expression> child;
-
-public:
-	bool IsFoldable() const override;
-	string ToString() const override;
-
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp
deleted file mode 100644
index acd76a42f..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_window_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-class AggregateFunction;
-
-class BoundWindowExpression : public Expression {
-public:
-	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_WINDOW;
-
-public:
-	BoundWindowExpression(ExpressionType type, LogicalType return_type, unique_ptr<AggregateFunction> aggregate,
-	                      unique_ptr<FunctionData> bind_info);
-
-	//! The bound aggregate function
-	unique_ptr<AggregateFunction> aggregate;
-	//! The bound function info
-	unique_ptr<FunctionData> bind_info;
-	//! The child expressions of the main window function
-	vector<unique_ptr<Expression>> children;
-	//! The set of expressions to partition by
-	vector<unique_ptr<Expression>> partitions;
-	//! Statistics belonging to the partitions expressions
-	vector<unique_ptr<BaseStatistics>> partitions_stats;
-	//! The set of ordering clauses
-	vector<BoundOrderByNode> orders;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<Expression> filter_expr;
-	//! True to ignore NULL values
-	bool ignore_nulls;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! The window boundaries
-	WindowBoundary start = WindowBoundary::INVALID;
-	WindowBoundary end = WindowBoundary::INVALID;
-	//! The EXCLUDE clause
-	WindowExcludeMode exclude_clause = WindowExcludeMode::NO_OTHER;
-
-	unique_ptr<Expression> start_expr;
-	unique_ptr<Expression> end_expr;
-	//! Offset and default expressions for WINDOW_LEAD and WINDOW_LAG functions
-	unique_ptr<Expression> offset_expr;
-	unique_ptr<Expression> default_expr;
-
-	//! The set of argument ordering clauses
-	//! These are distinct from the frame ordering clauses e.g., the "x" in
-	//! FIRST_VALUE(a ORDER BY x) OVER (PARTITION BY p ORDER BY s)
-	vector<BoundOrderByNode> arg_orders;
-
-	//! Statistics belonging to the other expressions (start, end, offset, default)
-	vector<unique_ptr<BaseStatistics>> expr_stats;
-
-public:
-	bool IsWindow() const override {
-		return true;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	//! The number of ordering clauses the functions share
-	static idx_t GetSharedOrders(const vector<BoundOrderByNode> &lhs, const vector<BoundOrderByNode> &rhs);
-	idx_t GetSharedOrders(const BoundWindowExpression &other) const;
-
-	bool PartitionsAreEquivalent(const BoundWindowExpression &other) const;
-	bool KeysAreCompatible(const BoundWindowExpression &other) const;
-	bool Equals(const BaseExpression &other) const override;
-
-	unique_ptr<Expression> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression/list.hpp b/src/duckdb/src/include/duckdb/planner/expression/list.hpp
deleted file mode 100644
index 0a0e9efee..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression/list.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_lambda_expression.hpp"
-#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder.hpp
deleted file mode 100644
index c73ea546d..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder.hpp
+++ /dev/null
@@ -1,232 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/stack_checker.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/parser/expression/lambdaref_expression.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/tokens.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/catalog/catalog_entry_retriever.hpp"
-#include "duckdb/planner/expression/bound_lambda_expression.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/common/enums/collation_type.hpp"
-
-namespace duckdb {
-
-class Binder;
-class ClientContext;
-class QueryNode;
-
-class ScalarFunctionCatalogEntry;
-class AggregateFunctionCatalogEntry;
-class ScalarMacroCatalogEntry;
-class CatalogEntry;
-class SimpleFunction;
-
-struct DummyBinding;
-struct SelectBindState;
-
-struct BoundColumnReferenceInfo {
-	string name;
-	optional_idx query_location;
-};
-
-struct BindResult {
-	BindResult() {
-	}
-	explicit BindResult(const Exception &ex) : error(ex) {
-	}
-	explicit BindResult(const string &error_msg) : error(ExceptionType::BINDER, error_msg) {
-	}
-	explicit BindResult(ErrorData error) : error(std::move(error)) {
-	}
-	explicit BindResult(unique_ptr<Expression> expr) : expression(std::move(expr)) {
-	}
-
-	bool HasError() const {
-		return error.HasError();
-	}
-	void SetError(const string &error_message) {
-		error = ErrorData(ExceptionType::BINDER, error_message);
-	}
-
-	unique_ptr<Expression> expression;
-	ErrorData error;
-};
-
-class ExpressionBinder {
-	friend class StackChecker<ExpressionBinder>;
-
-public:
-	ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder = false);
-	virtual ~ExpressionBinder();
-
-	//! The target type that should result from the binder. If the result is not of this type, a cast to this type will
-	//! be added. Defaults to INVALID.
-	LogicalType target_type;
-
-	optional_ptr<DummyBinding> macro_binding;
-	optional_ptr<vector<DummyBinding>> lambda_bindings;
-
-public:
-	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, optional_ptr<LogicalType> result_type = nullptr,
-	                            bool root_expression = true);
-
-	//! Returns whether or not any columns have been bound by the expression binder
-	bool HasBoundColumns() {
-		return !bound_columns.empty();
-	}
-	const vector<BoundColumnReferenceInfo> &GetBoundColumns() {
-		return bound_columns;
-	}
-
-	void SetCatalogLookupCallback(catalog_entry_callback_t callback);
-	ErrorData Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false);
-
-	//! Returns the STRUCT_EXTRACT operator expression
-	unique_ptr<ParsedExpression> CreateStructExtract(unique_ptr<ParsedExpression> base, const string &field_name);
-	//! Returns a STRUCT_PACK function expression
-	unique_ptr<ParsedExpression> CreateStructPack(ColumnRefExpression &col_ref);
-
-	BindResult BindQualifiedColumnName(ColumnRefExpression &colref, const string &table_name);
-
-	//! Returns a qualified column reference from a column name
-	unique_ptr<ParsedExpression> QualifyColumnName(const string &column_name, ErrorData &error);
-	//! Returns a qualified column reference from a column reference with column_names.size() > 2
-	unique_ptr<ParsedExpression> QualifyColumnNameWithManyDots(ColumnRefExpression &col_ref, ErrorData &error);
-	//! Returns a qualified column reference from a column reference
-	virtual unique_ptr<ParsedExpression> QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error);
-	//! Enables special-handling of lambda parameters by tracking them in the lambda_params vector
-	void QualifyColumnNamesInLambda(FunctionExpression &function, vector<unordered_set<string>> &lambda_params);
-	//! Recursively qualifies the column references in the (children) of the expression. Passes on the
-	//! within_function_expression state from outer expressions, or sets it
-	void QualifyColumnNames(unique_ptr<ParsedExpression> &expr, vector<unordered_set<string>> &lambda_params,
-	                        const bool within_function_expression = false);
-	//! Entry point for qualifying the column references of the expression
-	static void QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr);
-	static void QualifyColumnNames(ExpressionBinder &binder, unique_ptr<ParsedExpression> &expr);
-
-	static bool PushCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
-	                          CollationType type = CollationType::ALL_COLLATIONS);
-	static void TestCollation(ClientContext &context, const string &collation);
-
-	BindResult BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr, ErrorData error_message);
-
-	void BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, ErrorData &error);
-	static void ExtractCorrelatedExpressions(Binder &binder, Expression &expr);
-
-	static bool ContainsNullType(const LogicalType &type);
-	static LogicalType ExchangeNullType(const LogicalType &type);
-	static bool ContainsType(const LogicalType &type, LogicalTypeId target);
-	static LogicalType ExchangeType(const LogicalType &type, LogicalTypeId target, LogicalType new_type);
-
-	virtual bool TryBindAlias(ColumnRefExpression &colref, bool root_expression, BindResult &result);
-	virtual bool QualifyColumnAlias(const ColumnRefExpression &colref);
-
-	//! Bind the given expression. Unlike Bind(), this does *not* mute the given ParsedExpression.
-	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
-	virtual BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                                  bool root_expression = false);
-
-	//! FIXME: Generalise this for extensibility.
-	//! Recursively replaces macro parameters with the provided input parameters.
-	void ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr, vector<unordered_set<string>> &lambda_params);
-	//! Enables special-handling of lambda parameters during macro replacement by tracking them in the lambda_params
-	//! vector.
-	void ReplaceMacroParametersInLambda(FunctionExpression &function, vector<unordered_set<string>> &lambda_params);
-	//! Recursively qualifies column references in ON CONFLICT DO UPDATE SET expressions.
-	void DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
-	                        vector<unordered_set<string>> &lambda_params);
-	//! Enables special-handling of lambda parameters during ON CONFLICT TO UPDATE SET qualification by tracking them in
-	//! the lambda_params vector.
-	void DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name,
-	                                vector<unordered_set<string>> &lambda_params);
-
-	static LogicalType GetExpressionReturnType(const Expression &expr);
-
-private:
-	//! Current stack depth
-	idx_t stack_depth = DConstants::INVALID_INDEX;
-
-	void InitializeStackCheck();
-	StackChecker<ExpressionBinder> StackCheck(const ParsedExpression &expr, idx_t extra_stack = 1);
-
-protected:
-	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
-	BindResult BindExpression(CaseExpression &expr, idx_t depth);
-	BindResult BindExpression(CollateExpression &expr, idx_t depth);
-	BindResult BindExpression(CastExpression &expr, idx_t depth);
-	BindResult BindExpression(ColumnRefExpression &expr, idx_t depth, bool root_expression);
-	BindResult BindExpression(LambdaRefExpression &expr, idx_t depth);
-	BindResult BindExpression(ComparisonExpression &expr, idx_t depth);
-	BindResult BindExpression(ConjunctionExpression &expr, idx_t depth);
-	BindResult BindExpression(ConstantExpression &expr, idx_t depth);
-	BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr<ParsedExpression> &expr_ptr);
-	BindResult BindExpression(LambdaExpression &expr, idx_t depth, const LogicalType &list_child_type,
-	                          optional_ptr<bind_lambda_function_t> bind_lambda_function);
-	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
-	BindResult BindExpression(ParameterExpression &expr, idx_t depth);
-	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
-	BindResult BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression);
-
-	void TransformCapturedLambdaColumn(unique_ptr<Expression> &original, unique_ptr<Expression> &replacement,
-	                                   BoundLambdaExpression &bound_lambda_expr,
-	                                   const optional_ptr<bind_lambda_function_t> bind_lambda_function,
-	                                   const LogicalType &list_child_type);
-	void CaptureLambdaColumns(BoundLambdaExpression &bound_lambda_expr, unique_ptr<Expression> &expr,
-	                          const optional_ptr<bind_lambda_function_t> bind_lambda_function,
-	                          const LogicalType &list_child_type);
-
-	virtual unique_ptr<ParsedExpression> GetSQLValueFunction(const string &column_name);
-
-	LogicalType ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children);
-	LogicalType ResolveCoalesceType(OperatorExpression &op, vector<unique_ptr<Expression>> &children);
-	LogicalType ResolveNotType(OperatorExpression &op, vector<unique_ptr<Expression>> &children);
-
-	BindResult BindUnsupportedExpression(ParsedExpression &expr, idx_t depth, const string &message);
-
-protected:
-	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
-	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
-	virtual BindResult BindLambdaFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
-	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth);
-	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression);
-	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry &macro, idx_t depth,
-	                             unique_ptr<ParsedExpression> &expr_ptr);
-	void UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func,
-	                           unique_ptr<ParsedExpression> &expr);
-
-	virtual string UnsupportedAggregateMessage();
-	virtual string UnsupportedUnnestMessage();
-	optional_ptr<CatalogEntry> GetCatalogEntry(CatalogType type, const string &catalog, const string &schema,
-	                                           const string &name, OnEntryNotFound on_entry_not_found,
-	                                           QueryErrorContext &error_context);
-
-	Binder &binder;
-	ClientContext &context;
-	optional_ptr<ExpressionBinder> stored_binder;
-	vector<BoundColumnReferenceInfo> bound_columns;
-
-	//! Returns true if the function name is an alias for the UNNEST function
-	static bool IsUnnestFunction(const string &function_name);
-	BindResult TryBindLambdaOrJson(FunctionExpression &function, idx_t depth, CatalogEntry &func);
-
-	unique_ptr<ParsedExpression> QualifyColumnNameWithManyDotsInternal(ColumnRefExpression &col_ref, ErrorData &error,
-	                                                                   idx_t &struct_extract_start);
-	virtual void ThrowIfUnnestInLambda(const ColumnBinding &column_binding);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/aggregate_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/aggregate_binder.hpp
deleted file mode 100644
index 84075d9f4..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/aggregate_binder.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/aggregate_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The AggregateBinder is responsible for binding aggregate statements extracted from a SELECT clause (by the
-//! SelectBinder)
-class AggregateBinder : public ExpressionBinder {
-	friend class SelectBinder;
-
-public:
-	AggregateBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/alter_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/alter_binder.hpp
deleted file mode 100644
index dd77e2b0f..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/alter_binder.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/alter_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! The AlterBinder binds expressions in ALTER statements.
-class AlterBinder : public ExpressionBinder {
-public:
-	AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table, vector<LogicalIndex> &bound_columns,
-	            LogicalType target_type);
-
-protected:
-	BindResult BindLambdaReference(LambdaRefExpression &expr, idx_t depth);
-	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth);
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-
-private:
-	TableCatalogEntry &table;
-	vector<LogicalIndex> &bound_columns;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp
deleted file mode 100644
index 1fb875c77..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/base_select_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-class BoundColumnRefExpression;
-class WindowExpression;
-
-class BoundSelectNode;
-
-struct BoundGroupInformation {
-	parsed_expression_map_t<idx_t> map;
-	case_insensitive_map_t<idx_t> alias_map;
-	unordered_map<idx_t, idx_t> collated_groups;
-};
-
-//! The BaseSelectBinder is the base binder of the SELECT, HAVING and QUALIFY binders. It can bind aggregates and window
-//! functions.
-class BaseSelectBinder : public ExpressionBinder {
-public:
-	BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
-
-	bool BoundAggregates() {
-		return bound_aggregate;
-	}
-	void ResetBindings() {
-		this->bound_aggregate = false;
-		this->bound_columns.clear();
-	}
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth) override;
-
-	bool inside_window;
-	bool bound_aggregate = false;
-
-	BoundSelectNode &node;
-	BoundGroupInformation &info;
-
-protected:
-	BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth) override;
-
-	//! Binds a WINDOW expression and returns the result.
-	virtual BindResult BindWindow(WindowExpression &expr, idx_t depth);
-	virtual BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
-
-	idx_t TryBindGroup(ParsedExpression &expr);
-	BindResult BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/check_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/check_binder.hpp
deleted file mode 100644
index 51bd9c29a..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/check_binder.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/check_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/common/index_map.hpp"
-#include "duckdb/parser/column_list.hpp"
-
-namespace duckdb {
-//! The CHECK binder is responsible for binding an expression within a CHECK constraint
-class CheckBinder : public ExpressionBinder {
-public:
-	CheckBinder(Binder &binder, ClientContext &context, string table, const ColumnList &columns,
-	            physical_index_set_t &bound_columns);
-
-	string table;
-	const ColumnList &columns;
-	physical_index_set_t &bound_columns;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	BindResult BindCheckColumn(ColumnRefExpression &expr);
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/column_alias_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/column_alias_binder.hpp
deleted file mode 100644
index d70e65c7d..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/column_alias_binder.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/column_alias_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-class ColumnRefExpression;
-struct SelectBindState;
-
-//! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
-class ColumnAliasBinder {
-public:
-	explicit ColumnAliasBinder(SelectBindState &bind_state);
-
-	bool BindAlias(ExpressionBinder &enclosing_binder, unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	               bool root_expression, BindResult &result);
-	// Check if the column reference is an SELECT item alias.
-	bool QualifyColumnAlias(const ColumnRefExpression &colref);
-
-private:
-	SelectBindState &bind_state;
-	unordered_set<idx_t> visited_select_indexes;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/constant_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/constant_binder.hpp
deleted file mode 100644
index 026b3b605..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/constant_binder.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/constant_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The Constant binder can bind ONLY constant foldable expressions (i.e. no subqueries, column refs, etc)
-class ConstantBinder : public ExpressionBinder {
-public:
-	ConstantBinder(Binder &binder, ClientContext &context, string clause);
-
-	//! The location where this binder is used, used for error messages
-	string clause;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/group_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/group_binder.hpp
deleted file mode 100644
index 2fab45e30..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/group_binder.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/group_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-class ConstantExpression;
-class ColumnRefExpression;
-struct SelectBindState;
-
-//! The GROUP binder is responsible for binding expressions in the GROUP BY clause
-class GroupBinder : public ExpressionBinder {
-public:
-	GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-	            SelectBindState &bind_state, case_insensitive_map_t<idx_t> &group_alias_map);
-
-	//! The unbound root expression
-	unique_ptr<ParsedExpression> unbound_expression;
-	//! The group index currently being bound
-	idx_t bind_index;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
-
-	string UnsupportedAggregateMessage() override;
-
-	BindResult BindSelectRef(idx_t entry);
-	BindResult BindColumnRef(ColumnRefExpression &expr);
-	BindResult BindConstant(ConstantExpression &expr);
-	bool TryBindAlias(ColumnRefExpression &colref, bool root_expression, BindResult &result) override;
-
-	SelectNode &node;
-	SelectBindState &bind_state;
-	case_insensitive_map_t<idx_t> &group_alias_map;
-	unordered_set<idx_t> used_aliases;
-
-	idx_t group_index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp
deleted file mode 100644
index b111cc368..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/having_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder/base_select_binder.hpp"
-#include "duckdb/planner/expression_binder/column_alias_binder.hpp"
-#include "duckdb/common/enums/aggregate_handling.hpp"
-
-namespace duckdb {
-
-//! The HAVING binder is responsible for binding an expression within the HAVING clause of a SQL statement.
-class HavingBinder : public BaseSelectBinder {
-public:
-	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	             AggregateHandling aggregate_handling);
-
-protected:
-	BindResult BindLambdaReference(LambdaRefExpression &expr, idx_t depth);
-	BindResult BindWindow(WindowExpression &expr, idx_t depth) override;
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
-
-	unique_ptr<ParsedExpression> QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error) override;
-
-private:
-	ColumnAliasBinder column_alias_binder;
-	AggregateHandling aggregate_handling;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp
deleted file mode 100644
index f8972d13e..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/index_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/execution/index/unbound_index.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-class BoundColumnRefExpression;
-
-//! The IndexBinder binds indexes and expressions within index statements.
-class IndexBinder : public ExpressionBinder {
-public:
-	IndexBinder(Binder &binder, ClientContext &context, optional_ptr<TableCatalogEntry> table = nullptr,
-	            optional_ptr<CreateIndexInfo> info = nullptr);
-
-	unique_ptr<BoundIndex> BindIndex(const UnboundIndex &index);
-	unique_ptr<LogicalOperator> BindCreateIndex(ClientContext &context, unique_ptr<CreateIndexInfo> create_index_info,
-	                                            TableCatalogEntry &table_entry, unique_ptr<LogicalOperator> plan,
-	                                            unique_ptr<AlterTableInfo> alter_table_info);
-
-	static void InitCreateIndexInfo(LogicalGet &get, CreateIndexInfo &info, const string &schema);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-	string UnsupportedAggregateMessage() override;
-
-private:
-	// Only for WAL replay.
-	optional_ptr<TableCatalogEntry> table;
-	optional_ptr<CreateIndexInfo> info;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/insert_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/insert_binder.hpp
deleted file mode 100644
index 555445a21..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/insert_binder.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/insert_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The INSERT binder is responsible for binding expressions within the VALUES of an INSERT statement
-class InsertBinder : public ExpressionBinder {
-public:
-	InsertBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/lateral_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/lateral_binder.hpp
deleted file mode 100644
index eb68a0cdf..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/lateral_binder.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/lateral_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-class ColumnAliasBinder;
-
-//! The LATERAL binder is responsible for binding an expression within a LATERAL join
-class LateralBinder : public ExpressionBinder {
-public:
-	LateralBinder(Binder &binder, ClientContext &context);
-
-	bool HasCorrelatedColumns() const {
-		return !correlated_columns.empty();
-	}
-
-	static void ReduceExpressionDepth(LogicalOperator &op, const vector<CorrelatedColumnInfo> &info);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-
-private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
-	void ExtractCorrelatedColumns(Expression &expr);
-
-private:
-	vector<CorrelatedColumnInfo> correlated_columns;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp
deleted file mode 100644
index b2838c191..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/order_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-
-namespace duckdb {
-class Binder;
-class Expression;
-class SelectNode;
-struct SelectBindState;
-
-//! The ORDER binder is responsible for binding an expression within the ORDER BY clause of a SQL statement
-class OrderBinder {
-public:
-	OrderBinder(vector<reference<Binder>> binders, SelectBindState &bind_state);
-	OrderBinder(vector<reference<Binder>> binders, SelectNode &node, SelectBindState &bind_state);
-
-public:
-	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
-
-	bool HasExtraList() const {
-		return extra_list;
-	}
-	const vector<reference<Binder>> &GetBinders() const {
-		return binders;
-	}
-
-	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
-
-	//! Sets the query component, for error messages
-	void SetQueryComponent(string component = string());
-
-private:
-	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, const idx_t index);
-	unique_ptr<Expression> BindConstant(ParsedExpression &expr);
-	optional_idx TryGetProjectionReference(ParsedExpression &expr) const;
-
-private:
-	vector<reference<Binder>> binders;
-	optional_ptr<vector<unique_ptr<ParsedExpression>>> extra_list;
-	SelectBindState &bind_state;
-	string query_component = "ORDER BY";
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/qualify_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/qualify_binder.hpp
deleted file mode 100644
index d7cbbf5b7..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/qualify_binder.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/qualify_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder/base_select_binder.hpp"
-#include "duckdb/planner/expression_binder/column_alias_binder.hpp"
-
-namespace duckdb {
-struct SelectBindState;
-
-//! The QUALIFY binder is responsible for binding an expression within the QUALIFY clause of a SQL statement
-class QualifyBinder : public BaseSelectBinder {
-public:
-	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
-
-protected:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
-
-private:
-	ColumnAliasBinder column_alias_binder;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/relation_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/relation_binder.hpp
deleted file mode 100644
index ebf44990c..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/relation_binder.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/relation_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The relation binder is a binder used to bind expressions in the relation API
-class RelationBinder : public ExpressionBinder {
-public:
-	RelationBinder(Binder &binder, ClientContext &context, string op);
-
-	string op;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/returning_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/returning_binder.hpp
deleted file mode 100644
index bf8e838d1..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/returning_binder.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/returning_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
-class ReturningBinder : public ExpressionBinder {
-public:
-	ReturningBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/select_bind_state.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/select_bind_state.hpp
deleted file mode 100644
index d11d94731..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/select_bind_state.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/select_bind_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-
-namespace duckdb {
-
-//! Bind state during a SelectNode
-struct SelectBindState {
-	// Mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
-	case_insensitive_map_t<idx_t> alias_map;
-	parsed_expression_map_t<idx_t> projection_map;
-	//! The original unparsed expressions. This is exported after binding, because the binding might change the
-	//! expressions (e.g. when a * clause is present)
-	vector<unique_ptr<ParsedExpression>> original_expressions;
-
-public:
-	unique_ptr<ParsedExpression> BindAlias(idx_t index);
-
-	void SetExpressionIsVolatile(idx_t index);
-	void SetExpressionHasSubquery(idx_t index);
-
-	bool AliasHasSubquery(idx_t index) const;
-
-	void AddExpandedColumn(idx_t expand_count);
-	void AddRegularColumn();
-	idx_t GetFinalIndex(idx_t index) const;
-
-private:
-	//! The set of referenced aliases
-	unordered_set<idx_t> referenced_aliases;
-	//! The set of expressions that is volatile
-	unordered_set<idx_t> volatile_expressions;
-	//! The set of expressions that contains a subquery
-	unordered_set<idx_t> subquery_expressions;
-	//! Column indices after expansion of Expanded expressions (e.g. UNNEST(STRUCT) clauses)
-	vector<idx_t> expanded_column_indices;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/select_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/select_binder.hpp
deleted file mode 100644
index d191cd3ef..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/select_binder.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/select_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder/base_select_binder.hpp"
-
-namespace duckdb {
-
-//! The SELECT binder is responsible for binding an expression within the SELECT clause of a SQL statement
-class SelectBinder : public BaseSelectBinder {
-public:
-	SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
-
-protected:
-	void ThrowIfUnnestInLambda(const ColumnBinding &column_binding) override;
-	BindResult BindUnnest(FunctionExpression &function, idx_t depth, bool root_expression) override;
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
-
-	bool QualifyColumnAlias(const ColumnRefExpression &colref) override;
-	unique_ptr<ParsedExpression> GetSQLValueFunction(const string &column_name) override;
-
-protected:
-	idx_t unnest_level = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp
deleted file mode 100644
index 9e14a852e..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/table_function_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The table function binder can bind standard table function parameters (i.e., non-table-in-out functions)
-class TableFunctionBinder : public ExpressionBinder {
-public:
-	TableFunctionBinder(Binder &binder, ClientContext &context, string table_function_name = string());
-
-protected:
-	BindResult BindLambdaReference(LambdaRefExpression &expr, idx_t depth);
-	BindResult BindColumnReference(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression);
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-
-private:
-	string table_function_name;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/update_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/update_binder.hpp
deleted file mode 100644
index 383800bb7..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/update_binder.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/update_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-//! The UPDATE binder is responsible for binding an expression within an UPDATE statement
-class UpdateBinder : public ExpressionBinder {
-public:
-	UpdateBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/where_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/where_binder.hpp
deleted file mode 100644
index 20c443120..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_binder/where_binder.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/where_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-class ColumnAliasBinder;
-
-//! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
-class WhereBinder : public ExpressionBinder {
-public:
-	WhereBinder(Binder &binder, ClientContext &context, optional_ptr<ColumnAliasBinder> column_alias_binder = nullptr);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-	bool QualifyColumnAlias(const ColumnRefExpression &colref) override;
-
-private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
-
-	optional_ptr<ColumnAliasBinder> column_alias_binder;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/expression_iterator.hpp b/src/duckdb/src/include/duckdb/planner/expression_iterator.hpp
deleted file mode 100644
index 36825b3ac..000000000
--- a/src/duckdb/src/include/duckdb/planner/expression_iterator.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/planner/expression.hpp"
-
-#include <functional>
-
-namespace duckdb {
-class BoundQueryNode;
-class BoundTableRef;
-
-class ExpressionIterator {
-public:
-	static void EnumerateChildren(const Expression &expression,
-	                              const std::function<void(const Expression &child)> &callback);
-	static void EnumerateChildren(Expression &expression, const std::function<void(Expression &child)> &callback);
-	static void EnumerateChildren(Expression &expression,
-	                              const std::function<void(unique_ptr<Expression> &child)> &callback);
-
-	static void EnumerateExpression(unique_ptr<Expression> &expr,
-	                                const std::function<void(Expression &child)> &callback);
-};
-
-class BoundNodeVisitor {
-public:
-	virtual ~BoundNodeVisitor() = default;
-
-	virtual void VisitBoundQueryNode(BoundQueryNode &op);
-	virtual void VisitBoundTableRef(BoundTableRef &ref);
-	virtual void VisitExpression(unique_ptr<Expression> &expression);
-
-protected:
-	// The VisitExpressionChildren method is called at the end of every call to VisitExpression to recursively visit all
-	// expressions in an expression tree. It can be overloaded to prevent automatically visiting the entire tree.
-	virtual void VisitExpressionChildren(Expression &expression);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/extension_callback.hpp b/src/duckdb/src/include/duckdb/planner/extension_callback.hpp
deleted file mode 100644
index 060d29236..000000000
--- a/src/duckdb/src/include/duckdb/planner/extension_callback.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/extension_callback.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-
-class ExtensionCallback {
-public:
-	virtual ~ExtensionCallback() {
-	}
-
-	//! Called when a new connection is opened
-	virtual void OnConnectionOpened(ClientContext &context) {
-	}
-	//! Called when a connection is closed
-	virtual void OnConnectionClosed(ClientContext &context) {
-	}
-	//! Called after an extension is finished loading
-	virtual void OnExtensionLoaded(DatabaseInstance &db, const string &name) {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp
deleted file mode 100644
index 49fcf6e95..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/conjunction_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-class ConjunctionFilter : public TableFilter {
-public:
-	explicit ConjunctionFilter(TableFilterType filter_type_p) : TableFilter(filter_type_p) {
-	}
-
-	~ConjunctionFilter() override {
-	}
-
-	//! The filters of this conjunction
-	vector<unique_ptr<TableFilter>> child_filters;
-
-public:
-	bool Equals(const TableFilter &other) const override {
-		return TableFilter::Equals(other);
-	}
-};
-
-class ConjunctionOrFilter : public ConjunctionFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::CONJUNCTION_OR;
-
-public:
-	ConjunctionOrFilter();
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-class ConjunctionAndFilter : public ConjunctionFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::CONJUNCTION_AND;
-
-public:
-	ConjunctionAndFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp
deleted file mode 100644
index 613821859..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/constant_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-
-namespace duckdb {
-
-class ConstantFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::CONSTANT_COMPARISON;
-
-public:
-	ConstantFilter(ExpressionType comparison_type, Value constant);
-
-	//! The comparison type (e.g. COMPARE_EQUAL, COMPARE_GREATERTHAN, COMPARE_LESSTHAN, ...)
-	ExpressionType comparison_type;
-	//! The constant value to filter on
-	Value constant;
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/dynamic_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/dynamic_filter.hpp
deleted file mode 100644
index fbb32faff..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/dynamic_filter.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/dynamic_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-
-namespace duckdb {
-
-struct DynamicFilterData {
-	mutex lock;
-	unique_ptr<TableFilter> filter;
-	bool initialized = false;
-
-	void SetValue(Value val);
-	void Reset();
-};
-
-class DynamicFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::DYNAMIC_FILTER;
-
-public:
-	DynamicFilter();
-	explicit DynamicFilter(shared_ptr<DynamicFilterData> filter_data);
-
-	//! The shared, dynamic filter data
-	shared_ptr<DynamicFilterData> filter_data;
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp
deleted file mode 100644
index 19e3862a3..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/in_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/types/value.hpp"
-
-namespace duckdb {
-
-class InFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::IN_FILTER;
-
-public:
-	explicit InFilter(vector<Value> values);
-	InFilter(vector<Value> values, bool origin_is_hash_join);
-
-	vector<Value> values;
-	bool origin_is_hash_join;
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp
deleted file mode 100644
index 212ef3861..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/null_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-
-namespace duckdb {
-
-class IsNullFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::IS_NULL;
-
-public:
-	IsNullFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-class IsNotNullFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::IS_NOT_NULL;
-
-public:
-	IsNotNullFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp
deleted file mode 100644
index d694674d8..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/optional_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-
-namespace duckdb {
-
-class OptionalFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::OPTIONAL_FILTER;
-
-public:
-	explicit OptionalFilter(unique_ptr<TableFilter> filter = nullptr);
-
-	string ToString(const string &column_name) override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-
-public:
-	// optional child filters
-	unique_ptr<TableFilter> child_filter;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/filter/struct_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/struct_filter.hpp
deleted file mode 100644
index 05e806d36..000000000
--- a/src/duckdb/src/include/duckdb/planner/filter/struct_filter.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/constant_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-
-namespace duckdb {
-
-class StructFilter : public TableFilter {
-public:
-	static constexpr const TableFilterType TYPE = TableFilterType::STRUCT_EXTRACT;
-
-public:
-	StructFilter(idx_t child_idx, string child_name, unique_ptr<TableFilter> child_filter);
-
-	//! The field index to filter on
-	idx_t child_idx;
-
-	//! The field name to filter on
-	string child_name;
-
-	//! The child filter
-	unique_ptr<TableFilter> child_filter;
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-	unique_ptr<TableFilter> Copy() const override;
-	unique_ptr<Expression> ToExpression(const Expression &column) const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/joinside.hpp b/src/duckdb/src/include/duckdb/planner/joinside.hpp
deleted file mode 100644
index aa655e3e2..000000000
--- a/src/duckdb/src/include/duckdb/planner/joinside.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/joinside.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! JoinCondition represents a left-right comparison join condition
-struct JoinCondition {
-public:
-	JoinCondition() {
-	}
-
-	//! Turns the JoinCondition into an expression; note that this destroys the JoinCondition as the expression inherits
-	//! the left/right expressions
-	static unique_ptr<Expression> CreateExpression(JoinCondition cond);
-	static unique_ptr<Expression> CreateExpression(vector<JoinCondition> conditions);
-
-	void Serialize(Serializer &serializer) const;
-	static JoinCondition Deserialize(Deserializer &deserializer);
-
-public:
-	unique_ptr<Expression> left;
-	unique_ptr<Expression> right;
-	ExpressionType comparison;
-};
-
-class JoinSide {
-public:
-	enum JoinValue : uint8_t { NONE, LEFT, RIGHT, BOTH };
-
-	JoinSide() = default;
-	constexpr JoinSide(JoinValue val) : value(val) { // NOLINT: Allow implicit conversion from `join_value`
-	}
-
-	bool operator==(JoinSide a) const {
-		return value == a.value;
-	}
-	bool operator!=(JoinSide a) const {
-		return value != a.value;
-	}
-
-	static JoinSide CombineJoinSide(JoinSide left, JoinSide right);
-	static JoinSide GetJoinSide(idx_t table_binding, const unordered_set<idx_t> &left_bindings,
-	                            const unordered_set<uint64_t> &right_bindings);
-	static JoinSide GetJoinSide(Expression &expression, const unordered_set<idx_t> &left_bindings,
-	                            const unordered_set<idx_t> &right_bindings);
-	static JoinSide GetJoinSide(const unordered_set<idx_t> &bindings, const unordered_set<idx_t> &left_bindings,
-	                            const unordered_set<idx_t> &right_bindings);
-
-private:
-	JoinValue value;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/logical_operator.hpp b/src/duckdb/src/include/duckdb/planner/logical_operator.hpp
deleted file mode 100644
index e7f533bdd..000000000
--- a/src/duckdb/src/include/duckdb/planner/logical_operator.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/logical_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/insertion_order_preserving_map.hpp"
-
-#include <algorithm>
-#include <functional>
-
-namespace duckdb {
-
-//! LogicalOperator is the base class of the logical operators present in the
-//! logical query tree
-class LogicalOperator {
-public:
-	explicit LogicalOperator(LogicalOperatorType type);
-	LogicalOperator(LogicalOperatorType type, vector<unique_ptr<Expression>> expressions);
-	virtual ~LogicalOperator();
-
-	//! The type of the logical operator
-	LogicalOperatorType type;
-	//! The set of children of the operator
-	vector<unique_ptr<LogicalOperator>> children;
-	//! The set of expressions contained within the operator, if any
-	vector<unique_ptr<Expression>> expressions;
-	//! The types returned by this logical operator. Set by calling LogicalOperator::ResolveTypes.
-	vector<LogicalType> types;
-	//! Estimated Cardinality
-	idx_t estimated_cardinality;
-	bool has_estimated_cardinality;
-
-public:
-	virtual vector<ColumnBinding> GetColumnBindings();
-	static string ColumnBindingsToString(const vector<ColumnBinding> &bindings);
-	void PrintColumnBindings();
-	static vector<ColumnBinding> GenerateColumnBindings(idx_t table_idx, idx_t column_count);
-	static vector<LogicalType> MapTypes(const vector<LogicalType> &types, const vector<idx_t> &projection_map);
-	static vector<ColumnBinding> MapBindings(const vector<ColumnBinding> &types, const vector<idx_t> &projection_map);
-
-	//! Resolve the types of the logical operator and its children
-	void ResolveOperatorTypes();
-
-	virtual string GetName() const;
-	virtual InsertionOrderPreservingMap<string> ParamsToString() const;
-	virtual string ToString(ExplainFormat format = ExplainFormat::DEFAULT) const;
-	DUCKDB_API void Print();
-	//! Debug method: verify that the integrity of expressions & child nodes are maintained
-	virtual void Verify(ClientContext &context);
-
-	void AddChild(unique_ptr<LogicalOperator> child);
-	virtual idx_t EstimateCardinality(ClientContext &context);
-	void SetEstimatedCardinality(idx_t _estimated_cardinality);
-	void SetParamsEstimatedCardinality(InsertionOrderPreservingMap<string> &result) const;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	virtual unique_ptr<LogicalOperator> Copy(ClientContext &context) const;
-
-	virtual bool RequireOptimizer() const {
-		return true;
-	}
-
-	//! Allows LogicalOperators to opt out of serialization
-	virtual bool SupportSerialization() const {
-		return true;
-	};
-
-	virtual bool HasProjectionMap() const {
-		return false;
-	}
-
-	//! Returns the set of table indexes of this operator
-	virtual vector<idx_t> GetTableIndex() const;
-
-protected:
-	//! Resolve types for this specific operator
-	virtual void ResolveTypes() = 0;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
-			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
-			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/logical_operator_visitor.hpp b/src/duckdb/src/include/duckdb/planner/logical_operator_visitor.hpp
deleted file mode 100644
index b11065f67..000000000
--- a/src/duckdb/src/include/duckdb/planner/logical_operator_visitor.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/logical_operator_visitor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/planner/bound_tokens.hpp"
-#include "duckdb/planner/logical_tokens.hpp"
-
-#include <functional>
-
-namespace duckdb {
-//! The LogicalOperatorVisitor is an abstract base class that implements the
-//! Visitor pattern on LogicalOperator.
-class LogicalOperatorVisitor {
-public:
-	virtual ~LogicalOperatorVisitor() {
-	}
-
-	virtual void VisitOperator(LogicalOperator &op);
-	virtual void VisitExpression(unique_ptr<Expression> *expression);
-
-	static void EnumerateExpressions(LogicalOperator &op,
-	                                 const std::function<void(unique_ptr<Expression> *child)> &callback);
-
-protected:
-	//! Automatically calls the Visit method for LogicalOperator children of the current operator. Can be overloaded to
-	//! change this behavior.
-	void VisitOperatorChildren(LogicalOperator &op);
-	//! Automatically calls the Visit method for Expression children of the current operator. Can be overloaded to
-	//! change this behavior.
-	void VisitOperatorExpressions(LogicalOperator &op);
-	//! Alternatives for VisitOperatorChildren for operators that have a projection map
-	void VisitOperatorWithProjectionMapChildren(LogicalOperator &op);
-	void VisitChildOfOperatorWithProjectionMap(LogicalOperator &child, vector<idx_t> &projection_map);
-
-	// The VisitExpressionChildren method is called at the end of every call to VisitExpression to recursively visit all
-	// expressions in an expression tree. It can be overloaded to prevent automatically visiting the entire tree.
-	virtual void VisitExpressionChildren(Expression &expression);
-
-	virtual unique_ptr<Expression> VisitReplace(BoundAggregateExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundBetweenExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundCaseExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundCastExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundComparisonExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundConstantExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundDefaultExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundFunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundReferenceExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundParameterExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundWindowExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundUnnestExpression &expr, unique_ptr<Expression> *expr_ptr);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp b/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp
deleted file mode 100644
index 910507642..000000000
--- a/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/logical_tokens.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-class LogicalOperator;
-
-class LogicalAggregate;
-class LogicalAnyJoin;
-class LogicalColumnDataGet;
-class LogicalComparisonJoin;
-class LogicalCopyDatabase;
-class LogicalCopyToFile;
-class LogicalCreate;
-class LogicalCreateTable;
-class LogicalCreateIndex;
-class LogicalCreateTable;
-class LogicalCreateSecret;
-class LogicalCrossProduct;
-class LogicalCTERef;
-class LogicalDelete;
-class LogicalDelimGet;
-class LogicalDistinct;
-class LogicalDummyScan;
-class LogicalEmptyResult;
-class LogicalExecute;
-class LogicalExplain;
-class LogicalExport;
-class LogicalExpressionGet;
-class LogicalFilter;
-class LogicalGet;
-class LogicalInsert;
-class LogicalJoin;
-class LogicalLimit;
-class LogicalOrder;
-class LogicalPivot;
-class LogicalPositionalJoin;
-class LogicalPragma;
-class LogicalPrepare;
-class LogicalProjection;
-class LogicalRecursiveCTE;
-class LogicalMaterializedCTE;
-class LogicalSetOperation;
-class LogicalSample;
-class LogicalSimple;
-class LogicalVacuum;
-class LogicalSet;
-class LogicalReset;
-class LogicalTopN;
-class LogicalUnnest;
-class LogicalUpdate;
-class LogicalWindow;
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/list.hpp b/src/duckdb/src/include/duckdb/planner/operator/list.hpp
deleted file mode 100644
index 3fe4cb03a..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/list.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_copy_database.hpp"
-#include "duckdb/planner/operator/logical_copy_to_file.hpp"
-#include "duckdb/planner/operator/logical_create.hpp"
-#include "duckdb/planner/operator/logical_create_index.hpp"
-#include "duckdb/planner/operator/logical_create_table.hpp"
-#include "duckdb/planner/operator/logical_create_secret.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_cteref.hpp"
-#include "duckdb/planner/operator/logical_delete.hpp"
-#include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_execute.hpp"
-#include "duckdb/planner/operator/logical_explain.hpp"
-#include "duckdb/planner/operator/logical_export.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
-#include "duckdb/planner/operator/logical_extension_operator.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_insert.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_materialized_cte.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/planner/operator/logical_pivot.hpp"
-#include "duckdb/planner/operator/logical_positional_join.hpp"
-#include "duckdb/planner/operator/logical_pragma.hpp"
-#include "duckdb/planner/operator/logical_prepare.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_recursive_cte.hpp"
-#include "duckdb/planner/operator/logical_reset.hpp"
-#include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/planner/operator/logical_set.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include "duckdb/planner/operator/logical_top_n.hpp"
-#include "duckdb/planner/operator/logical_unnest.hpp"
-#include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/planner/operator/logical_vacuum.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp
deleted file mode 100644
index 0b730890c..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-
-namespace duckdb {
-
-//! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
-//! operator.
-class LogicalAggregate : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY;
-
-public:
-	LogicalAggregate(idx_t group_index, idx_t aggregate_index, vector<unique_ptr<Expression>> select_list);
-
-	//! The table index for the groups of the LogicalAggregate
-	idx_t group_index;
-	//! The table index for the aggregates of the LogicalAggregate
-	idx_t aggregate_index;
-	//! The table index for the GROUPING function calls of the LogicalAggregate
-	idx_t groupings_index;
-	//! The set of groups (optional).
-	vector<unique_ptr<Expression>> groups;
-	//! The set of grouping sets (optional).
-	vector<GroupingSet> grouping_sets;
-	//! The list of grouping function calls (optional)
-	vector<unsafe_vector<idx_t>> grouping_functions;
-	//! Group statistics (optional)
-	vector<unique_ptr<BaseStatistics>> group_stats;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	idx_t EstimateCardinality(ClientContext &context) override;
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_any_join.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_any_join.hpp
deleted file mode 100644
index d9ce03c95..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_any_join.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_any_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-
-namespace duckdb {
-
-//! LogicalAnyJoin represents a join with an arbitrary expression as JoinCondition
-class LogicalAnyJoin : public LogicalJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ANY_JOIN;
-
-public:
-	explicit LogicalAnyJoin(JoinType type);
-
-	//! The JoinCondition on which this join is performed
-	unique_ptr<Expression> condition;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_column_data_get.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_column_data_get.hpp
deleted file mode 100644
index 6d27b679e..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_column_data_get.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_column_data_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/common/optionally_owned_ptr.hpp"
-
-namespace duckdb {
-
-//! LogicalColumnDataGet represents a scan operation from a ColumnDataCollection
-class LogicalColumnDataGet : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CHUNK_GET;
-
-public:
-	LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types, unique_ptr<ColumnDataCollection> collection);
-	LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types, ColumnDataCollection &to_scan);
-	LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types,
-	                     optionally_owned_ptr<ColumnDataCollection> to_scan);
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The types of the chunk
-	vector<LogicalType> chunk_types;
-	//! (optionally owned) column data collection
-	optionally_owned_ptr<ColumnDataCollection> collection;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = chunk_types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_comparison_join.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_comparison_join.hpp
deleted file mode 100644
index e361a2a6e..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_comparison_join.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_comparison_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/joinside.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/execution/operator/join/join_filter_pushdown.hpp"
-
-namespace duckdb {
-
-//! LogicalComparisonJoin represents a join that involves comparisons between the LHS and RHS
-class LogicalComparisonJoin : public LogicalJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
-
-public:
-	explicit LogicalComparisonJoin(JoinType type,
-	                               LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-
-	//! The conditions of the join
-	vector<JoinCondition> conditions;
-	//! Used for duplicate-eliminated MARK joins
-	vector<LogicalType> mark_types;
-	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
-	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
-	//! If this is a DelimJoin, whether it has been flipped to de-duplicating the RHS instead
-	bool delim_flipped = false;
-	//! (If join_type == MARK) can this comparison join be converted from a mark join to semi
-	bool convert_mark_to_semi = true;
-	//! Scans where we should push generated filters into (if any)
-	unique_ptr<JoinFilterPushdownInfo> filter_pushdown;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-public:
-	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
-	                                              unique_ptr<LogicalOperator> left_child,
-	                                              unique_ptr<LogicalOperator> right_child,
-	                                              unique_ptr<Expression> condition);
-	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
-	                                              unique_ptr<LogicalOperator> left_child,
-	                                              unique_ptr<LogicalOperator> right_child,
-	                                              vector<JoinCondition> conditions,
-	                                              vector<unique_ptr<Expression>> arbitrary_expressions);
-
-	static void ExtractJoinConditions(ClientContext &context, JoinType type, JoinRefType ref_type,
-	                                  unique_ptr<LogicalOperator> &left_child, unique_ptr<LogicalOperator> &right_child,
-	                                  unique_ptr<Expression> condition, vector<JoinCondition> &conditions,
-	                                  vector<unique_ptr<Expression>> &arbitrary_expressions);
-	static void ExtractJoinConditions(ClientContext &context, JoinType type, JoinRefType ref_type,
-	                                  unique_ptr<LogicalOperator> &left_child, unique_ptr<LogicalOperator> &right_child,
-	                                  vector<unique_ptr<Expression>> &expressions, vector<JoinCondition> &conditions,
-	                                  vector<unique_ptr<Expression>> &arbitrary_expressions);
-	static void ExtractJoinConditions(ClientContext &context, JoinType type, JoinRefType ref_type,
-	                                  unique_ptr<LogicalOperator> &left_child, unique_ptr<LogicalOperator> &right_child,
-	                                  const unordered_set<idx_t> &left_bindings,
-	                                  const unordered_set<idx_t> &right_bindings,
-	                                  vector<unique_ptr<Expression>> &expressions, vector<JoinCondition> &conditions,
-	                                  vector<unique_ptr<Expression>> &arbitrary_expressions);
-
-	bool HasEquality(idx_t &range_count) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_copy_database.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_copy_database.hpp
deleted file mode 100644
index 1fc5ef47c..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_copy_database.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_copy_database.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/copy_database_info.hpp"
-
-namespace duckdb {
-
-class LogicalCopyDatabase : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_COPY_DATABASE;
-
-public:
-	explicit LogicalCopyDatabase(unique_ptr<CopyDatabaseInfo> info_p);
-	~LogicalCopyDatabase() override;
-
-	unique_ptr<CopyDatabaseInfo> info;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	explicit LogicalCopyDatabase(unique_ptr<ParseInfo> info_p);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_copy_to_file.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_copy_to_file.hpp
deleted file mode 100644
index 5ec454b0e..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_copy_to_file.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_copy_to_file.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/copy_overwrite_mode.hpp"
-#include "duckdb/common/filename_pattern.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalCopyToFile : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_COPY_TO_FILE;
-
-public:
-	LogicalCopyToFile(CopyFunction function, unique_ptr<FunctionData> bind_data, unique_ptr<CopyInfo> copy_info)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_TO_FILE), function(std::move(function)),
-	      bind_data(std::move(bind_data)), copy_info(std::move(copy_info)) {
-	}
-	CopyFunction function;
-	unique_ptr<FunctionData> bind_data;
-	unique_ptr<CopyInfo> copy_info;
-
-	std::string file_path;
-	bool use_tmp_file;
-	FilenamePattern filename_pattern;
-	string file_extension;
-	CopyOverwriteMode overwrite_mode;
-	bool per_thread_output;
-	optional_idx file_size_bytes;
-	bool rotate;
-	CopyFunctionReturnType return_type;
-
-	bool partition_output;
-	bool write_partition_columns;
-	vector<idx_t> partition_columns;
-	vector<string> names;
-	vector<LogicalType> expected_types;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-	idx_t EstimateCardinality(ClientContext &context) override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	static vector<LogicalType> GetTypesWithoutPartitions(const vector<LogicalType> &col_types,
-	                                                     const vector<idx_t> &part_cols, bool write_part_cols);
-	static vector<string> GetNamesWithoutPartitions(const vector<string> &col_names, const vector<column_t> &part_cols,
-	                                                bool write_part_cols);
-
-protected:
-	void ResolveTypes() override {
-		types = GetCopyFunctionReturnLogicalTypes(return_type);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_create.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_create.hpp
deleted file mode 100644
index 02429563d..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_create.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_create.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-
-namespace duckdb {
-
-//! LogicalCreate represents a CREATE operator
-class LogicalCreate : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
-
-public:
-	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info,
-	              optional_ptr<SchemaCatalogEntry> schema = nullptr);
-
-	optional_ptr<SchemaCatalogEntry> schema;
-	unique_ptr<CreateInfo> info;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	LogicalCreate(LogicalOperatorType type, ClientContext &context, unique_ptr<CreateInfo> info);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_create_index.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_create_index.hpp
deleted file mode 100644
index 2f04c7ee4..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_create_index.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_create_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/table_function.hpp"
-
-namespace duckdb {
-
-class LogicalCreateIndex : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_INDEX;
-
-public:
-	LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
-	                   TableCatalogEntry &table_p, unique_ptr<AlterTableInfo> alter_table_info = nullptr);
-
-	//! Index creation information.
-	unique_ptr<CreateIndexInfo> info;
-	//! The table to create the index for.
-	TableCatalogEntry &table;
-	// Alter table information.
-	unique_ptr<AlterTableInfo> alter_table_info;
-	//! Unbound expressions of the indexed columns.
-	vector<unique_ptr<Expression>> unbound_expressions;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info, vector<unique_ptr<Expression>> expressions,
-	                   unique_ptr<ParseInfo> alter_info);
-	TableCatalogEntry &BindTable(ClientContext &context, CreateIndexInfo &info_p);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_create_secret.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_create_secret.hpp
deleted file mode 100644
index 9a780bd28..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_create_secret.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// planner/operator/logical_create_secret.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalCreateSecret represents a simple logical operator that only passes on the parse info
-class LogicalCreateSecret : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_SECRET;
-
-public:
-	explicit LogicalCreateSecret(CreateSecretInfo info_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_SECRET), info(std::move(info_p)) {
-	}
-
-	CreateSecretInfo info;
-
-public:
-	idx_t EstimateCardinality(ClientContext &context) override {
-		return 1;
-	};
-
-	//! Skips the serialization check in VerifyPlan
-	bool SupportSerialization() const override {
-		return false;
-	}
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp
deleted file mode 100644
index 294d285b8..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_create_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalCreateTable : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_TABLE;
-
-public:
-	LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info);
-
-	//! Schema to insert to
-	SchemaCatalogEntry &schema;
-	//! Create Table information
-	unique_ptr<BoundCreateTableInfo> info;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	LogicalCreateTable(ClientContext &context, unique_ptr<CreateInfo> info);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_cross_product.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_cross_product.hpp
deleted file mode 100644
index 47d49af61..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_cross_product.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_cross_product.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_unconditional_join.hpp"
-
-namespace duckdb {
-
-//! LogicalCrossProduct represents a cross product between two relations
-class LogicalCrossProduct : public LogicalUnconditionalJoin {
-	LogicalCrossProduct() : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {};
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CROSS_PRODUCT;
-
-public:
-	LogicalCrossProduct(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
-
-public:
-	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp
deleted file mode 100644
index 32eaaeea3..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_cteref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/common/enums/cte_materialize.hpp"
-
-namespace duckdb {
-
-//! LogicalCTERef represents a reference to a recursive CTE
-class LogicalCTERef : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CTE_REF;
-
-public:
-	LogicalCTERef(idx_t table_index, idx_t cte_index, vector<LogicalType> types, vector<string> colnames,
-	              CTEMaterialize materialized_cte)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CTE_REF), table_index(table_index), cte_index(cte_index),
-	      correlated_columns(0), materialized_cte(materialized_cte) {
-		D_ASSERT(types.size() > 0);
-		chunk_types = std::move(types);
-		bound_columns = std::move(colnames);
-	}
-
-	vector<string> bound_columns;
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! CTE index
-	idx_t cte_index;
-	//! The types of the chunk
-	vector<LogicalType> chunk_types;
-	//! Number of correlated columns
-	idx_t correlated_columns;
-	//! Does this operator read a materialized CTE?
-	CTEMaterialize materialized_cte;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, chunk_types.size());
-	}
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = chunk_types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp
deleted file mode 100644
index 513370ea2..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delete.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-class LogicalDelete : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELETE;
-
-public:
-	explicit LogicalDelete(TableCatalogEntry &table, idx_t table_index);
-
-	TableCatalogEntry &table;
-	idx_t table_index;
-	bool return_chunk;
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	vector<ColumnBinding> GetColumnBindings() override;
-	void ResolveTypes() override;
-
-private:
-	LogicalDelete(ClientContext &context, const unique_ptr<CreateInfo> &table_info);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp
deleted file mode 100644
index c3970b11f..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delim_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalDelimGet represents a duplicate eliminated scan belonging to a DelimJoin
-class LogicalDelimGet : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELIM_GET;
-
-public:
-	LogicalDelimGet(idx_t table_index, vector<LogicalType> types)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELIM_GET), table_index(table_index) {
-		D_ASSERT(!types.empty());
-		chunk_types = std::move(types);
-	}
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The types of the chunk
-	vector<LogicalType> chunk_types;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, chunk_types.size());
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = chunk_types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_dependent_join.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_dependent_join.hpp
deleted file mode 100644
index 769aa180b..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_dependent_join.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_dependent_join.hpp
-//
-// logical_dependent_join represents a logical operator for lateral joins that
-// is planned but not yet flattened
-//
-// This construct only exists during planning and should not exist in the plan
-// once flattening is complete. Although the same information can be kept in the
-// join itself, creating a new construct makes the code cleaner and easier to
-// understand.
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-class LogicalDependentJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DEPENDENT_JOIN;
-
-public:
-	explicit LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                              vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
-	                              unique_ptr<Expression> condition);
-
-	//! The conditions of the join
-	unique_ptr<Expression> join_condition;
-	//! The list of columns that have correlations with the right
-	vector<CorrelatedColumnInfo> correlated_columns;
-
-public:
-	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                                          vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
-	                                          unique_ptr<Expression> condition);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp
deleted file mode 100644
index c09a6aeac..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_distinct.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-//! LogicalDistinct filters duplicate entries from its child operator
-class LogicalDistinct : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DISTINCT;
-
-public:
-	explicit LogicalDistinct(DistinctType distinct_type);
-	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type);
-
-	//! Whether or not this is a DISTINCT or DISTINCT ON
-	DistinctType distinct_type;
-	//! The set of distinct targets
-	vector<unique_ptr<Expression>> distinct_targets;
-	//! The order by modifier (optional, only for distinct on)
-	unique_ptr<BoundOrderModifier> order_by;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp
deleted file mode 100644
index 8071fd0b2..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_dummy_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalDummyScan represents a dummy scan returning a single row
-class LogicalDummyScan : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DUMMY_SCAN;
-
-public:
-	explicit LogicalDummyScan(idx_t table_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DUMMY_SCAN), table_index(table_index) {
-	}
-
-	idx_t table_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(table_index, 0)};
-	}
-
-	idx_t EstimateCardinality(ClientContext &context) override {
-		return 1;
-	}
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		if (types.empty()) {
-			types.emplace_back(LogicalType::INTEGER);
-		}
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp
deleted file mode 100644
index 5185ddc66..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_empty_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalEmptyResult returns an empty result. This is created by the optimizer if it can reason that certain parts of
-//! the tree will always return an empty result.
-class LogicalEmptyResult : public LogicalOperator {
-	LogicalEmptyResult();
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-
-public:
-	explicit LogicalEmptyResult(unique_ptr<LogicalOperator> op);
-
-	//! The set of return types of the empty result
-	vector<LogicalType> return_types;
-	//! The columns that would be bound at this location (if the subtree was not optimized away)
-	vector<ColumnBinding> bindings;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return bindings;
-	}
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	idx_t EstimateCardinality(ClientContext &context) override {
-		return 0;
-	}
-
-protected:
-	void ResolveTypes() override {
-		this->types = return_types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp
deleted file mode 100644
index 0c6eff24c..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_execute.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalExecute : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXECUTE;
-
-public:
-	explicit LogicalExecute(shared_ptr<PreparedStatementData> prepared_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXECUTE), prepared(std::move(prepared_p)) {
-		D_ASSERT(prepared);
-		types = prepared->types;
-	}
-
-	shared_ptr<PreparedStatementData> prepared;
-
-public:
-	//! Skips the serialization check in VerifyPlan
-	bool SupportSerialization() const override {
-		return false;
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = prepared->types;
-	}
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(0, types.size());
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp
deleted file mode 100644
index 6fa451caa..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_explain.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalExplain : public LogicalOperator {
-	explicit LogicalExplain(ExplainType explain_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {};
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPLAIN;
-
-public:
-	LogicalExplain(unique_ptr<LogicalOperator> plan, ExplainType explain_type, ExplainFormat explain_format)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type),
-	      explain_format(explain_format) {
-		children.push_back(std::move(plan));
-	}
-
-	ExplainType explain_type;
-	ExplainFormat explain_format;
-	string physical_plan;
-	string logical_plan_unopt;
-	string logical_plan_opt;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override {
-		return 3;
-	}
-	//! Skips the serialization check in VerifyPlan
-	bool SupportSerialization() const override {
-		return false;
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
-	}
-	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(0, 0), ColumnBinding(0, 1)};
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_export.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_export.hpp
deleted file mode 100644
index 2115f09f8..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_export.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_export.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
-
-namespace duckdb {
-
-class LogicalExport : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPORT;
-
-public:
-	LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info, unique_ptr<BoundExportData> exported_tables);
-
-	unique_ptr<CopyInfo> copy_info;
-	CopyFunction function;
-	unique_ptr<BoundExportData> exported_tables;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	LogicalExport(ClientContext &context, unique_ptr<ParseInfo> copy_info, unique_ptr<ParseInfo> exported_tables);
-
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-
-	CopyFunction GetCopyFunction(ClientContext &context, CopyInfo &info);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp
deleted file mode 100644
index cf6180b16..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_expression_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalExpressionGet represents a scan operation over a set of to-be-executed expressions
-class LogicalExpressionGet : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPRESSION_GET;
-
-public:
-	LogicalExpressionGet(idx_t table_index, vector<LogicalType> types,
-	                     vector<vector<unique_ptr<Expression>>> expressions)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPRESSION_GET), table_index(table_index),
-	      expr_types(std::move(types)), expressions(std::move(expressions)) {
-	}
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The types of the expressions
-	vector<LogicalType> expr_types;
-	//! The set of expressions
-	vector<vector<unique_ptr<Expression>>> expressions;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, expr_types.size());
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	idx_t EstimateCardinality(ClientContext &context) override {
-		return expressions.size();
-	}
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = expr_types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp
deleted file mode 100644
index a7d60ca3f..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_extension_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator_extension.hpp"
-
-namespace duckdb {
-
-class ColumnBindingResolver;
-
-struct LogicalExtensionOperator : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR;
-
-public:
-	LogicalExtensionOperator() : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR) {
-	}
-	explicit LogicalExtensionOperator(vector<unique_ptr<Expression>> expressions)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR, std::move(expressions)) {
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;
-
-	virtual void ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings);
-	virtual string GetExtensionName() const;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp
deleted file mode 100644
index b6f8323a6..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalFilter represents a filter operation (e.g. WHERE or HAVING clause)
-class LogicalFilter : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_FILTER;
-
-public:
-	explicit LogicalFilter(unique_ptr<Expression> expression);
-	LogicalFilter();
-
-	vector<idx_t> projection_map;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	bool HasProjectionMap() const override {
-		return !projection_map.empty();
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	bool SplitPredicates() {
-		return SplitPredicates(expressions);
-	}
-	//! Splits up the predicates of the LogicalFilter into a set of predicates
-	//! separated by AND Returns whether or not any splits were made
-	static bool SplitPredicates(vector<unique_ptr<Expression>> &expressions);
-
-protected:
-	void ResolveTypes() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp
deleted file mode 100644
index 0a73d12cb..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/extra_operator_info.hpp"
-
-namespace duckdb {
-class DynamicTableFilterSet;
-
-//! LogicalGet represents a scan operation from a data source
-class LogicalGet : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_GET;
-
-public:
-	LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
-	           vector<LogicalType> returned_types, vector<string> returned_names,
-	           LogicalType rowid_type = LogicalType(LogicalType::ROW_TYPE));
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The function that is called
-	TableFunction function;
-	//! The bind data of the function
-	unique_ptr<FunctionData> bind_data;
-	//! The types of ALL columns that can be returned by the table function
-	vector<LogicalType> returned_types;
-	//! The names of ALL columns that can be returned by the table function
-	vector<string> names;
-	//! Columns that are used outside the scan
-	vector<idx_t> projection_ids;
-	//! Filters pushed down for table scan
-	TableFilterSet table_filters;
-	//! The set of input parameters for the table function
-	vector<Value> parameters;
-	//! The set of named input parameters for the table function
-	named_parameter_map_t named_parameters;
-	//! The set of named input table types for the table-in table-out function
-	vector<LogicalType> input_table_types;
-	//! The set of named input table names for the table-in table-out function
-	vector<string> input_table_names;
-	//! For a table-in-out function, the set of projected input columns
-	vector<column_t> projected_input;
-	//! Currently stores File Filters (as strings) applied by hive partitioning/complex filter pushdown and sample rate
-	//! pushed down into the table scan
-	//! Stored so the can be included in explain output
-	ExtraOperatorInfo extra_info;
-	//! Contains a reference to dynamically generated table filters (through e.g. a join up in the tree)
-	shared_ptr<DynamicTableFilterSet> dynamic_filters;
-
-	string GetName() const override;
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-	//! Returns the underlying table that is being scanned, or nullptr if there is none
-	optional_ptr<TableCatalogEntry> GetTable() const;
-
-public:
-	void SetColumnIds(vector<ColumnIndex> &&column_ids);
-	void AddColumnId(column_t column_id);
-	void ClearColumnIds();
-	const vector<ColumnIndex> &GetColumnIds() const;
-	vector<ColumnIndex> &GetMutableColumnIds();
-	vector<ColumnBinding> GetColumnBindings() override;
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-	vector<idx_t> GetTableIndex() const override;
-	//! Skips the serialization check in VerifyPlan
-	bool SupportSerialization() const override {
-		return function.verify_serialization;
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	LogicalType GetRowIdType() const {
-		return rowid_type;
-	}
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	LogicalGet();
-
-private:
-	//! Bound column IDs
-	vector<ColumnIndex> column_ids;
-
-	//! The type of the rowid column
-	LogicalType rowid_type = LogicalType(LogicalType::ROW_TYPE);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp
deleted file mode 100644
index c20c33a54..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_insert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/common/index_vector.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-class Index;
-
-//! LogicalInsert represents an insertion of data into a base table
-class LogicalInsert : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INSERT;
-
-public:
-	LogicalInsert(TableCatalogEntry &table, idx_t table_index);
-
-	vector<vector<unique_ptr<Expression>>> insert_values;
-	//! The insertion map ([table_index -> index in result, or DConstants::INVALID_INDEX if not specified])
-	physical_index_vector_t<idx_t> column_index_map;
-	//! The expected types for the INSERT statement (obtained from the column types)
-	vector<LogicalType> expected_types;
-	//! The base table to insert into
-	TableCatalogEntry &table;
-	idx_t table_index;
-	//! if returning option is used, return actual chunk to projection
-	bool return_chunk;
-	//! The default statements used by the table
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! The constraints used by the table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-
-	//! Which action to take on conflict
-	OnConflictAction action_type;
-	// The types that the DO UPDATE .. SET (expressions) are cast to
-	vector<LogicalType> expected_set_types;
-	// The (distinct) column ids to apply the ON CONFLICT on
-	unordered_set<column_t> on_conflict_filter;
-	// The WHERE clause of the conflict_target (ON CONFLICT .. WHERE <condition>)
-	unique_ptr<Expression> on_conflict_condition;
-	// The WHERE clause of the DO UPDATE clause
-	unique_ptr<Expression> do_update_condition;
-	// The columns targeted by the DO UPDATE SET expressions
-	vector<PhysicalIndex> set_columns;
-	// The types of the columns targeted by the DO UPDATE SET expressions
-	vector<LogicalType> set_types;
-	// The table_index referring to the column references qualified with 'excluded'
-	idx_t excluded_table_index = 0;
-	// The columns to fetch from the 'destination' table
-	vector<column_t> columns_to_fetch;
-	// The columns to fetch from the 'source' table
-	vector<column_t> source_columns;
-	//! True, if the INSERT OR REPLACE requires delete + insert.
-	bool update_is_del_and_insert;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	vector<ColumnBinding> GetColumnBindings() override;
-	void ResolveTypes() override;
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-private:
-	LogicalInsert(ClientContext &context, const unique_ptr<CreateInfo> table_info);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_join.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_join.hpp
deleted file mode 100644
index 9e278886c..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_join.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-//! LogicalJoin represents a join between two relations
-class LogicalJoin : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
-
-public:
-	explicit LogicalJoin(JoinType type, LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_JOIN);
-
-	// Gets the set of table references that are reachable from this node
-	static void GetTableReferences(LogicalOperator &op, unordered_set<idx_t> &bindings);
-	static void GetExpressionBindings(Expression &expr, unordered_set<idx_t> &bindings);
-
-	bool HasProjectionMap() const override {
-		return !left_projection_map.empty() || !right_projection_map.empty();
-	}
-
-	//! The type of the join (INNER, OUTER, etc...)
-	JoinType join_type;
-	//! Table index used to refer to the MARK column (in case of a MARK join)
-	idx_t mark_index {};
-	//! The columns of the LHS that are output by the join
-	vector<idx_t> left_projection_map;
-	//! The columns of the RHS that are output by the join
-	vector<idx_t> right_projection_map;
-	//! Join Keys statistics (optional)
-	vector<unique_ptr<BaseStatistics>> join_stats;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp
deleted file mode 100644
index a8becefec..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_limit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-//! LogicalLimit represents a LIMIT clause
-class LogicalLimit : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_LIMIT;
-
-public:
-	LogicalLimit(BoundLimitNode limit_val, BoundLimitNode offset_val);
-
-	BoundLimitNode limit_val;
-	BoundLimitNode offset_val;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp
deleted file mode 100644
index 93c575253..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_materialized_cte.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalMaterializedCTE : public LogicalOperator {
-	explicit LogicalMaterializedCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
-	}
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_MATERIALIZED_CTE;
-
-public:
-	LogicalMaterializedCTE(string ctename_p, idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> cte,
-	                       unique_ptr<LogicalOperator> child)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE), table_index(table_index),
-	      column_count(column_count), ctename(std::move(ctename_p)) {
-		children.push_back(std::move(cte));
-		children.push_back(std::move(child));
-	}
-
-	idx_t table_index;
-	idx_t column_count;
-	string ctename;
-
-public:
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[1]->GetColumnBindings();
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	vector<idx_t> GetTableIndex() const override;
-
-protected:
-	void ResolveTypes() override {
-		types = children[1]->types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp
deleted file mode 100644
index a7bdf50d8..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_order.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-//! LogicalOrder represents an ORDER BY clause, sorting the data
-class LogicalOrder : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ORDER_BY;
-
-public:
-	explicit LogicalOrder(vector<BoundOrderByNode> orders);
-
-	vector<BoundOrderByNode> orders;
-	vector<idx_t> projection_map;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	bool HasProjectionMap() const override {
-		return !projection_map.empty();
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	InsertionOrderPreservingMap<string> ParamsToString() const override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp
deleted file mode 100644
index 26d569dae..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_pivot.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/planner/tableref/bound_pivotref.hpp"
-
-namespace duckdb {
-
-class LogicalPivot : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PIVOT;
-
-public:
-	LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info);
-
-	idx_t pivot_index;
-	//! The bound pivot info
-	BoundPivotInfo bound_pivot;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	LogicalPivot();
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp
deleted file mode 100644
index c3aea8e7b..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_positional_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_unconditional_join.hpp"
-
-namespace duckdb {
-
-//! LogicalPositionalJoin represents a row-wise join between two relations
-class LogicalPositionalJoin : public LogicalUnconditionalJoin {
-	LogicalPositionalJoin() : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_POSITIONAL_JOIN) {};
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_POSITIONAL_JOIN;
-
-public:
-	LogicalPositionalJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
-
-public:
-	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_pragma.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_pragma.hpp
deleted file mode 100644
index 37fa70f83..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_pragma.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_pragma.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/bound_pragma_info.hpp"
-
-namespace duckdb {
-
-//! LogicalPragma represents a simple logical operator that only passes on the parse info
-class LogicalPragma : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PRAGMA;
-
-public:
-	explicit LogicalPragma(unique_ptr<BoundPragmaInfo> info_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PRAGMA), info(std::move(info_p)) {
-	}
-
-	unique_ptr<BoundPragmaInfo> info;
-
-public:
-	idx_t EstimateCardinality(ClientContext &context) override;
-	//! Skips the serialization check in VerifyPlan
-	bool SupportSerialization() const override {
-		return false;
-	}
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_prepare.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_prepare.hpp
deleted file mode 100644
index 58279c08a..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_prepare.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_prepare.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class TableCatalogEntry;
-
-class LogicalPrepare : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PREPARE;
-
-public:
-	LogicalPrepare(string name_p, shared_ptr<PreparedStatementData> prepared, unique_ptr<LogicalOperator> logical_plan)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(std::move(name_p)),
-	      prepared(std::move(prepared)) {
-		if (logical_plan) {
-			children.push_back(std::move(logical_plan));
-		}
-	}
-
-	string name;
-	shared_ptr<PreparedStatementData> prepared;
-
-public:
-	idx_t EstimateCardinality(ClientContext &context) override;
-	//! Skips the serialization check in VerifyPlan
-	bool SupportSerialization() const override {
-		return false;
-	}
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-
-	bool RequireOptimizer() const override {
-		if (!prepared->properties.bound_all_parameters) {
-			return false;
-		}
-		return children[0]->RequireOptimizer();
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp
deleted file mode 100644
index 54a3dfef6..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_projection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalProjection represents the projection list in a SELECT clause
-class LogicalProjection : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PROJECTION;
-
-public:
-	LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list);
-
-	idx_t table_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp
deleted file mode 100644
index c118b41fe..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_recursive_cte.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-class LogicalRecursiveCTE : public LogicalOperator {
-	LogicalRecursiveCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
-	}
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_RECURSIVE_CTE;
-
-public:
-	LogicalRecursiveCTE(string ctename_p, idx_t table_index, idx_t column_count, bool union_all,
-	                    unique_ptr<LogicalOperator> top, unique_ptr<LogicalOperator> bottom)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all),
-	      ctename(std::move(ctename_p)), table_index(table_index), column_count(column_count) {
-		children.push_back(std::move(top));
-		children.push_back(std::move(bottom));
-	}
-
-	bool union_all;
-	string ctename;
-	idx_t table_index;
-	idx_t column_count;
-	vector<CorrelatedColumnInfo> correlated_columns;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, column_count);
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp
deleted file mode 100644
index 6131b6f88..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_reset.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
-
-namespace duckdb {
-
-class LogicalReset : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_RESET;
-
-public:
-	LogicalReset(std::string name_p, SetScope scope_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RESET), name(std::move(name_p)), scope(scope_p) {
-	}
-
-	std::string name;
-	SetScope scope;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp
deleted file mode 100644
index 7bce81409..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-
-namespace duckdb {
-
-//! LogicalSample represents a SAMPLE clause
-class LogicalSample : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_SAMPLE;
-
-public:
-	LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child);
-
-	//! The sample options
-	unique_ptr<SampleOptions> sample_options;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-protected:
-	void ResolveTypes() override;
-
-private:
-	LogicalSample();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp
deleted file mode 100644
index ff3aa5098..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_scope.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
-
-namespace duckdb {
-
-class LogicalSet : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_SET;
-
-public:
-	LogicalSet(std::string name_p, Value value_p, SetScope scope_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_SET), name(std::move(name_p)), value(std::move(value_p)),
-	      scope(scope_p) {
-	}
-
-	std::string name;
-	Value value;
-	SetScope scope;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp
deleted file mode 100644
index 0dbfc43cd..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_set_operation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-class LogicalSetOperation : public LogicalOperator {
-	LogicalSetOperation(idx_t table_index, idx_t column_count, LogicalOperatorType type, bool setop_all,
-	                    bool allow_out_of_order)
-	    : LogicalOperator(type), table_index(table_index), column_count(column_count), setop_all(setop_all),
-	      allow_out_of_order(allow_out_of_order) {
-	}
-
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
-
-public:
-	LogicalSetOperation(idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> top,
-	                    unique_ptr<LogicalOperator> bottom, LogicalOperatorType type, bool setop_all,
-	                    bool allow_out_of_order = true)
-	    : LogicalOperator(type), table_index(table_index), column_count(column_count), setop_all(setop_all),
-	      allow_out_of_order(allow_out_of_order) {
-		D_ASSERT(type == LogicalOperatorType::LOGICAL_UNION || type == LogicalOperatorType::LOGICAL_EXCEPT ||
-		         type == LogicalOperatorType::LOGICAL_INTERSECT);
-		children.push_back(std::move(top));
-		children.push_back(std::move(bottom));
-	}
-
-	idx_t table_index;
-	idx_t column_count;
-	bool setop_all;
-	//! Whether or not UNION statements can be executed out of order
-	bool allow_out_of_order;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, column_count);
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp
deleted file mode 100644
index f1b595975..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_simple.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalSimple represents a simple logical operator that only passes on the parse info
-class LogicalSimple : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
-
-public:
-	LogicalSimple(LogicalOperatorType type, unique_ptr<ParseInfo> info) : LogicalOperator(type), info(std::move(info)) {
-	}
-
-	unique_ptr<ParseInfo> info;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp
deleted file mode 100644
index 6a2f38ab6..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_top_n.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-struct DynamicFilterData;
-
-//! LogicalTopN represents a comibination of ORDER BY and LIMIT clause, using Min/Max Heap
-class LogicalTopN : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_TOP_N;
-
-public:
-	LogicalTopN(vector<BoundOrderByNode> orders, idx_t limit, idx_t offset);
-	~LogicalTopN() override;
-
-	vector<BoundOrderByNode> orders;
-	//! The maximum amount of elements to emit
-	idx_t limit;
-	//! The offset from the start to begin emitting elements
-	idx_t offset;
-	//! Dynamic table filter (if any)
-	shared_ptr<DynamicFilterData> dynamic_filter;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_unconditional_join.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_unconditional_join.hpp
deleted file mode 100644
index c25509bbf..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_unconditional_join.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_unconditional_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalUnconditionalJoin represents a join between two relations
-//! where the join condition is implicit (cross product, position, etc.)
-class LogicalUnconditionalJoin : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
-
-public:
-	explicit LogicalUnconditionalJoin(LogicalOperatorType logical_type) : LogicalOperator(logical_type) {};
-
-public:
-	LogicalUnconditionalJoin(LogicalOperatorType logical_type, unique_ptr<LogicalOperator> left,
-	                         unique_ptr<LogicalOperator> right);
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp
deleted file mode 100644
index 7a5f3d464..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_unnest.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalUnnest represents the logical UNNEST operator.
-class LogicalUnnest : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_UNNEST;
-
-public:
-	explicit LogicalUnnest(idx_t unnest_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UNNEST), unnest_index(unnest_index) {
-	}
-
-	idx_t unnest_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp
deleted file mode 100644
index 587341ab0..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_update.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-class LogicalUpdate : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_UPDATE;
-
-public:
-	explicit LogicalUpdate(TableCatalogEntry &table);
-
-	//! The base table to update
-	TableCatalogEntry &table;
-	//! table catalog index
-	idx_t table_index;
-	//! if returning option is used, return the update chunk
-	bool return_chunk;
-	vector<PhysicalIndex> columns;
-	vector<unique_ptr<Expression>> bound_defaults;
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	bool update_is_del_and_insert;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-	string GetName() const override;
-
-protected:
-	vector<ColumnBinding> GetColumnBindings() override;
-	void ResolveTypes() override;
-
-private:
-	LogicalUpdate(ClientContext &context, const unique_ptr<CreateInfo> &table_info);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_vacuum.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_vacuum.hpp
deleted file mode 100644
index 2ecf1088c..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_vacuum.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_vacuum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-//! LogicalVacuum represents a simple logical operator that only passes on the parse info
-class LogicalVacuum : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_VACUUM;
-
-public:
-	LogicalVacuum();
-	explicit LogicalVacuum(unique_ptr<VacuumInfo> info);
-
-public:
-	VacuumInfo &GetInfo() {
-		return *info;
-	}
-
-	TableCatalogEntry &GetTable();
-	bool HasTable() const;
-	void SetTable(TableCatalogEntry &table_p);
-
-public:
-	optional_ptr<TableCatalogEntry> table;
-	unordered_map<idx_t, idx_t> column_id_map;
-	unique_ptr<VacuumInfo> info;
-
-public:
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp
deleted file mode 100644
index 45a0667da..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
-//! operator.
-class LogicalWindow : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_WINDOW;
-
-public:
-	explicit LogicalWindow(idx_t window_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_WINDOW), window_index(window_index) {
-	}
-
-	idx_t window_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
-	vector<idx_t> GetTableIndex() const override;
-	string GetName() const override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator_extension.hpp b/src/duckdb/src/include/duckdb/planner/operator_extension.hpp
deleted file mode 100644
index b14b640d1..000000000
--- a/src/duckdb/src/include/duckdb/planner/operator_extension.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-//! The OperatorExtensionInfo holds static information relevant to the operator extension
-struct OperatorExtensionInfo {
-	virtual ~OperatorExtensionInfo() {
-	}
-};
-
-typedef BoundStatement (*bind_function_t)(ClientContext &context, Binder &binder, OperatorExtensionInfo *info,
-                                          SQLStatement &statement);
-
-// forward declaration to avoid circular reference
-struct LogicalExtensionOperator;
-
-class OperatorExtension {
-public:
-	bind_function_t Bind; // NOLINT: backwards compatibility
-
-	//! Additional info passed to the CreatePlan & Bind functions
-	shared_ptr<OperatorExtensionInfo> operator_info;
-
-	virtual std::string GetName() = 0;
-	virtual unique_ptr<LogicalExtensionOperator> Deserialize(Deserializer &deserializer) = 0;
-
-	virtual ~OperatorExtension() {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_function_info.hpp b/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_function_info.hpp
deleted file mode 100644
index 7224037cd..000000000
--- a/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_function_info.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/parsed_data/bound_create_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-
-struct BoundCreateFunctionInfo {
-	explicit BoundCreateFunctionInfo(SchemaCatalogEntry &schema, unique_ptr<CreateInfo> base)
-	    : schema(schema), base(std::move(base)) {
-	}
-
-	//! The schema to create the table in
-	SchemaCatalogEntry &schema;
-	//! The base CreateInfo object
-	unique_ptr<CreateInfo> base;
-
-	CreateMacroInfo &Base() {
-		return (CreateMacroInfo &)*base;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp b/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp
deleted file mode 100644
index 049aca822..000000000
--- a/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/parsed_data/bound_create_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/storage/table/persistent_table_data.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/catalog/catalog_entry/column_dependency_manager.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-
-struct BoundCreateTableInfo {
-	explicit BoundCreateTableInfo(SchemaCatalogEntry &schema, unique_ptr<CreateInfo> base_p)
-	    : schema(schema), base(std::move(base_p)) {
-		D_ASSERT(base);
-	}
-
-	//! The schema to create the table in
-	SchemaCatalogEntry &schema;
-	//! The base CreateInfo object
-	unique_ptr<CreateInfo> base;
-	//! Column dependency manager of the table
-	ColumnDependencyManager column_dependency_manager;
-	//! List of constraints on the table
-	vector<unique_ptr<Constraint>> constraints;
-	//! Dependents of the table (in e.g. default values)
-	LogicalDependencyList dependencies;
-	//! The existing table data on disk (if any)
-	unique_ptr<PersistentTableData> data;
-	//! CREATE TABLE from QUERY
-	unique_ptr<LogicalOperator> query;
-	//! Indexes created by this table
-	vector<IndexStorageInfo> indexes;
-
-	CreateTableInfo &Base() {
-		D_ASSERT(base);
-		return base->Cast<CreateTableInfo>();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/planner.hpp b/src/duckdb/src/include/duckdb/planner/planner.hpp
deleted file mode 100644
index 985567839..000000000
--- a/src/duckdb/src/include/duckdb/planner/planner.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/planner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
-
-namespace duckdb {
-class ClientContext;
-class PreparedStatementData;
-
-//! The planner creates a logical query plan from the parsed SQL statements
-//! using the Binder and LogicalPlanGenerator.
-class Planner {
-	friend class Binder;
-
-public:
-	explicit Planner(ClientContext &context);
-
-public:
-	unique_ptr<LogicalOperator> plan;
-	vector<string> names;
-	vector<LogicalType> types;
-	case_insensitive_map_t<BoundParameterData> parameter_data;
-
-	shared_ptr<Binder> binder;
-	ClientContext &context;
-
-	StatementProperties properties;
-	bound_parameter_map_t value_map;
-
-public:
-	void CreatePlan(unique_ptr<SQLStatement> statement);
-	static void VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op,
-	                       optional_ptr<bound_parameter_map_t> map = nullptr);
-
-private:
-	void CreatePlan(SQLStatement &statement);
-	shared_ptr<PreparedStatementData> PrepareSQLStatement(unique_ptr<SQLStatement> statement);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/pragma_handler.hpp b/src/duckdb/src/include/duckdb/planner/pragma_handler.hpp
deleted file mode 100644
index 361a6a768..000000000
--- a/src/duckdb/src/include/duckdb/planner/pragma_handler.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/pragma_handler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/parser/statement/pragma_statement.hpp"
-
-namespace duckdb {
-class ClientContext;
-class ClientContextLock;
-class SQLStatement;
-struct PragmaInfo;
-
-//! Pragma handler is responsible for converting certain pragma statements into new queries
-class PragmaHandler {
-public:
-	explicit PragmaHandler(ClientContext &context);
-
-	void HandlePragmaStatements(ClientContextLock &lock, vector<unique_ptr<SQLStatement>> &statements);
-
-private:
-	ClientContext &context;
-
-private:
-	//! Handles a pragma statement, returns whether the statement was expanded, if it was expanded the 'resulting_query'
-	//! contains the statement(s) to replace the current one
-	bool HandlePragma(SQLStatement &statement, string &resulting_query);
-
-	void HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/query_node/bound_cte_node.hpp b/src/duckdb/src/include/duckdb/planner/query_node/bound_cte_node.hpp
deleted file mode 100644
index 00b3f94a3..000000000
--- a/src/duckdb/src/include/duckdb/planner/query_node/bound_cte_node.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-
-class BoundCTENode : public BoundQueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::CTE_NODE;
-
-public:
-	BoundCTENode() : BoundQueryNode(QueryNodeType::CTE_NODE) {
-	}
-
-	//! Keep track of the CTE name this node represents
-	string ctename;
-
-	//! The cte node
-	unique_ptr<BoundQueryNode> query;
-	//! The child node
-	unique_ptr<BoundQueryNode> child;
-	//! Index used by the set operation
-	idx_t setop_index;
-	//! The binder used by the query side of the CTE
-	shared_ptr<Binder> query_binder;
-	//! The binder used by the child side of the CTE
-	shared_ptr<Binder> child_binder;
-
-public:
-	idx_t GetRootIndex() override {
-		return child->GetRootIndex();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/query_node/bound_recursive_cte_node.hpp b/src/duckdb/src/include/duckdb/planner/query_node/bound_recursive_cte_node.hpp
deleted file mode 100644
index 0e9b3dddf..000000000
--- a/src/duckdb/src/include/duckdb/planner/query_node/bound_recursive_cte_node.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_recursive_cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-
-//! Bound equivalent of SetOperationNode
-class BoundRecursiveCTENode : public BoundQueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::RECURSIVE_CTE_NODE;
-
-public:
-	BoundRecursiveCTENode() : BoundQueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
-	}
-
-	//! Keep track of the CTE name this node represents
-	string ctename;
-
-	bool union_all;
-	//! The left side of the set operation
-	unique_ptr<BoundQueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<BoundQueryNode> right;
-
-	//! Index used by the set operation
-	idx_t setop_index;
-	//! The binder used by the left side of the set operation
-	shared_ptr<Binder> left_binder;
-	//! The binder used by the right side of the set operation
-	shared_ptr<Binder> right_binder;
-
-public:
-	idx_t GetRootIndex() override {
-		return setop_index;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/query_node/bound_select_node.hpp b/src/duckdb/src/include/duckdb/planner/query_node/bound_select_node.hpp
deleted file mode 100644
index b3a22966a..000000000
--- a/src/duckdb/src/include/duckdb/planner/query_node/bound_select_node.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_select_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-
-namespace duckdb {
-
-class BoundGroupByNode {
-public:
-	//! The total set of all group expressions
-	vector<unique_ptr<Expression>> group_expressions;
-	//! The different grouping sets as they map to the group expressions
-	vector<GroupingSet> grouping_sets;
-};
-
-struct BoundUnnestNode {
-	//! The index of the UNNEST node
-	idx_t index;
-	//! The set of expressions
-	vector<unique_ptr<Expression>> expressions;
-};
-
-//! Bound equivalent of SelectNode
-class BoundSelectNode : public BoundQueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::SELECT_NODE;
-
-public:
-	BoundSelectNode() : BoundQueryNode(QueryNodeType::SELECT_NODE) {
-	}
-
-	//! Bind information
-	SelectBindState bind_state;
-	//! The projection list
-	vector<unique_ptr<Expression>> select_list;
-	//! The FROM clause
-	unique_ptr<BoundTableRef> from_table;
-	//! The WHERE clause
-	unique_ptr<Expression> where_clause;
-	//! list of groups
-	BoundGroupByNode groups;
-	//! HAVING clause
-	unique_ptr<Expression> having;
-	//! QUALIFY clause
-	unique_ptr<Expression> qualify;
-	//! SAMPLE clause
-	unique_ptr<SampleOptions> sample_options;
-
-	//! The amount of columns in the final result
-	idx_t column_count;
-	//! The amount of bound columns in the select list
-	idx_t bound_column_count = 0;
-
-	//! Index used by the LogicalProjection
-	idx_t projection_index;
-
-	//! Group index used by the LogicalAggregate (only used if HasAggregation is true)
-	idx_t group_index;
-	//! Table index for the projection child of the group op
-	idx_t group_projection_index;
-	//! Aggregate index used by the LogicalAggregate (only used if HasAggregation is true)
-	idx_t aggregate_index;
-	//! Index used for GROUPINGS column references
-	idx_t groupings_index;
-	//! Aggregate functions to compute (only used if HasAggregation is true)
-	vector<unique_ptr<Expression>> aggregates;
-
-	//! GROUPING function calls
-	vector<unsafe_vector<idx_t>> grouping_functions;
-
-	//! Map from aggregate function to aggregate index (used to eliminate duplicate aggregates)
-	expression_map_t<idx_t> aggregate_map;
-
-	//! Window index used by the LogicalWindow (only used if HasWindow is true)
-	idx_t window_index;
-	//! Window functions to compute (only used if HasWindow is true)
-	vector<unique_ptr<Expression>> windows;
-
-	//! Unnest expression
-	unordered_map<idx_t, BoundUnnestNode> unnests;
-
-	//! Index of pruned node
-	idx_t prune_index;
-	bool need_prune = false;
-
-public:
-	idx_t GetRootIndex() override {
-		return need_prune ? prune_index : projection_index;
-	}
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/query_node/bound_set_operation_node.hpp b/src/duckdb/src/include/duckdb/planner/query_node/bound_set_operation_node.hpp
deleted file mode 100644
index e3ce0457e..000000000
--- a/src/duckdb/src/include/duckdb/planner/query_node/bound_set_operation_node.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_set_operation_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/set_operation_type.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-
-//! Bound equivalent of SetOperationNode
-class BoundSetOperationNode : public BoundQueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::SET_OPERATION_NODE;
-
-public:
-	BoundSetOperationNode() : BoundQueryNode(QueryNodeType::SET_OPERATION_NODE) {
-	}
-
-	//! The type of set operation
-	SetOperationType setop_type = SetOperationType::NONE;
-	//! whether the ALL modifier was used or not
-	bool setop_all = false;
-	//! The left side of the set operation
-	unique_ptr<BoundQueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<BoundQueryNode> right;
-
-	//! Index used by the set operation
-	idx_t setop_index;
-	//! The binder used by the left side of the set operation
-	shared_ptr<Binder> left_binder;
-	//! The binder used by the right side of the set operation
-	shared_ptr<Binder> right_binder;
-
-	//! Exprs used by the UNION BY NAME opeartons to add a new projection
-	vector<unique_ptr<Expression>> left_reorder_exprs;
-	vector<unique_ptr<Expression>> right_reorder_exprs;
-
-	//! The exprs of the child node may be rearranged(UNION BY NAME),
-	//! this vector records the new index of the expression after rearrangement
-	//! used by GatherAlias(...) function to create new reorder index
-	vector<idx_t> left_reorder_idx;
-	vector<idx_t> right_reorder_idx;
-
-public:
-	idx_t GetRootIndex() override {
-		return setop_index;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/query_node/list.hpp b/src/duckdb/src/include/duckdb/planner/query_node/list.hpp
deleted file mode 100644
index 5c7dbda94..000000000
--- a/src/duckdb/src/include/duckdb/planner/query_node/list.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "duckdb/planner/query_node/bound_recursive_cte_node.hpp"
-#include "duckdb/planner/query_node/bound_cte_node.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/query_node/bound_set_operation_node.hpp"
diff --git a/src/duckdb/src/include/duckdb/planner/subquery/flatten_dependent_join.hpp b/src/duckdb/src/include/duckdb/planner/subquery/flatten_dependent_join.hpp
deleted file mode 100644
index 9b7ad0353..000000000
--- a/src/duckdb/src/include/duckdb/planner/subquery/flatten_dependent_join.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/flatten_dependent_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! The FlattenDependentJoins class is responsible for pushing the dependent join down into the plan to create a
-//! flattened subquery
-struct FlattenDependentJoins {
-	FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated, bool perform_delim = true,
-	                      bool any_join = false);
-
-	//! Detects which Logical Operators have correlated expressions that they are dependent upon, filling the
-	//! has_correlated_expressions map.
-	bool DetectCorrelatedExpressions(LogicalOperator &op, bool lateral = false, idx_t lateral_depth = 0);
-
-	//! Mark entire subtree of Logical Operators as correlated by adding them to the has_correlated_expressions map.
-	bool MarkSubtreeCorrelated(LogicalOperator &op);
-
-	//! Push the dependent join down a LogicalOperator
-	unique_ptr<LogicalOperator> PushDownDependentJoin(unique_ptr<LogicalOperator> plan,
-	                                                  bool propagates_null_values = true);
-
-	Binder &binder;
-	ColumnBinding base_binding;
-	idx_t delim_offset;
-	idx_t data_offset;
-	reference_map_t<LogicalOperator, bool> has_correlated_expressions;
-	column_binding_map_t<idx_t> correlated_map;
-	column_binding_map_t<idx_t> replacement_map;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-	vector<LogicalType> delim_types;
-
-	bool perform_delim;
-	bool any_join;
-
-private:
-	unique_ptr<LogicalOperator> PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan,
-	                                                          bool &parent_propagate_null_values, idx_t lateral_depth);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/subquery/has_correlated_expressions.hpp b/src/duckdb/src/include/duckdb/planner/subquery/has_correlated_expressions.hpp
deleted file mode 100644
index 6b238ffcc..000000000
--- a/src/duckdb/src/include/duckdb/planner/subquery/has_correlated_expressions.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/has_correlated_expressions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! Helper class to recursively detect correlated expressions inside a single LogicalOperator
-class HasCorrelatedExpressions : public LogicalOperatorVisitor {
-public:
-	explicit HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated, bool lateral = false,
-	                                  idx_t lateral_depth = 0);
-
-	void VisitOperator(LogicalOperator &op) override;
-
-	bool has_correlated_expressions;
-	bool lateral;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-	// Tracks number of nested laterals
-	idx_t lateral_depth;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/subquery/recursive_dependent_join_planner.hpp b/src/duckdb/src/include/duckdb/planner/subquery/recursive_dependent_join_planner.hpp
deleted file mode 100644
index ea7b627bd..000000000
--- a/src/duckdb/src/include/duckdb/planner/subquery/recursive_dependent_join_planner.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/recursive_dependent_join_planner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-namespace duckdb {
-
-class Binder;
-
-/*
- * Recursively plan subqueries and flatten dependent joins from outermost to innermost (like peeling an onion).
- */
-class RecursiveDependentJoinPlanner : public LogicalOperatorVisitor {
-public:
-	explicit RecursiveDependentJoinPlanner(Binder &binder) : binder(binder) {
-	}
-	void VisitOperator(LogicalOperator &op) override;
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	unique_ptr<LogicalOperator> root;
-	Binder &binder;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/subquery/rewrite_correlated_expressions.hpp b/src/duckdb/src/include/duckdb/planner/subquery/rewrite_correlated_expressions.hpp
deleted file mode 100644
index f69f63c84..000000000
--- a/src/duckdb/src/include/duckdb/planner/subquery/rewrite_correlated_expressions.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/rewrite_correlated_expressions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! Helper class to rewrite correlated expressions within a single LogicalOperator
-class RewriteCorrelatedExpressions : public LogicalOperatorVisitor {
-public:
-	RewriteCorrelatedExpressions(ColumnBinding base_binding, column_binding_map_t<idx_t> &correlated_map,
-	                             idx_t lateral_depth, bool recursive_rewrite = false);
-
-	void VisitOperator(LogicalOperator &op) override;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	ColumnBinding base_binding;
-	column_binding_map_t<idx_t> &correlated_map;
-	// To keep track of the number of dependent joins encountered
-	idx_t lateral_depth;
-	// This flag is used to determine if the rewrite should recursively update the bindings for all
-	// bound columns ref in the plan, and update the depths to match the new source
-	bool recursive_rewrite;
-};
-
-//! Helper class that rewrites COUNT aggregates into a CASE expression turning NULL into 0 after a LEFT OUTER JOIN
-class RewriteCountAggregates : public LogicalOperatorVisitor {
-public:
-	explicit RewriteCountAggregates(column_binding_map_t<idx_t> &replacement_map);
-
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-	column_binding_map_t<idx_t> &replacement_map;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/subquery/rewrite_cte_scan.hpp b/src/duckdb/src/include/duckdb/planner/subquery/rewrite_cte_scan.hpp
deleted file mode 100644
index e2c507e73..000000000
--- a/src/duckdb/src/include/duckdb/planner/subquery/rewrite_cte_scan.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/rewrite_cte_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-//! Helper class to rewrite correlated cte scans within a single LogicalOperator
-class RewriteCTEScan : public LogicalOperatorVisitor {
-public:
-	RewriteCTEScan(idx_t table_index, const vector<CorrelatedColumnInfo> &correlated_columns);
-
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	idx_t table_index;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/table_binding.hpp b/src/duckdb/src/include/duckdb/planner/table_binding.hpp
deleted file mode 100644
index 50631f57a..000000000
--- a/src/duckdb/src/include/duckdb/planner/table_binding.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/table_binding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/planner/binding_alias.hpp"
-#include "duckdb/common/column_index.hpp"
-
-namespace duckdb {
-class BindContext;
-class BoundQueryNode;
-class ColumnRefExpression;
-class SubqueryRef;
-class LogicalGet;
-class TableCatalogEntry;
-class TableFunctionCatalogEntry;
-class BoundTableFunction;
-class StandardEntry;
-struct ColumnBinding;
-
-enum class BindingType { BASE, TABLE, DUMMY, CATALOG_ENTRY };
-
-//! A Binding represents a binding to a table, table-producing function or subquery with a specified table index.
-struct Binding {
-	Binding(BindingType binding_type, BindingAlias alias, vector<LogicalType> types, vector<string> names, idx_t index,
-	        LogicalType rowid_type = LogicalType(LogicalType::ROW_TYPE));
-	virtual ~Binding() = default;
-
-	//! The type of Binding
-	BindingType binding_type;
-	//! The alias of the binding
-	BindingAlias alias;
-	//! The table index of the binding
-	idx_t index;
-	//! The types of the bound columns
-	vector<LogicalType> types;
-	//! Column names of the subquery
-	vector<string> names;
-	//! Name -> index for the names
-	case_insensitive_map_t<column_t> name_map;
-
-	LogicalType rowid_type;
-
-public:
-	bool TryGetBindingIndex(const string &column_name, column_t &column_index);
-	column_t GetBindingIndex(const string &column_name);
-	bool HasMatchingBinding(const string &column_name);
-	virtual ErrorData ColumnNotFoundError(const string &column_name) const;
-	virtual BindResult Bind(ColumnRefExpression &colref, idx_t depth);
-	virtual optional_ptr<StandardEntry> GetStandardEntry();
-	string GetAlias() const;
-
-	static BindingAlias GetAlias(const string &explicit_alias, const StandardEntry &entry);
-	static BindingAlias GetAlias(const string &explicit_alias, optional_ptr<StandardEntry> entry);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (binding_type != TARGET::TYPE) {
-			throw InternalException("Failed to cast binding to type - binding type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (binding_type != TARGET::TYPE) {
-			throw InternalException("Failed to cast binding to type - binding type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct EntryBinding : public Binding {
-public:
-	static constexpr const BindingType TYPE = BindingType::CATALOG_ENTRY;
-
-public:
-	EntryBinding(const string &alias, vector<LogicalType> types, vector<string> names, idx_t index,
-	             StandardEntry &entry);
-	StandardEntry &entry;
-
-public:
-	optional_ptr<StandardEntry> GetStandardEntry() override;
-};
-
-//! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
-//! node for projection pushdown purposes.
-struct TableBinding : public Binding {
-public:
-	static constexpr const BindingType TYPE = BindingType::TABLE;
-
-public:
-	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names,
-	             vector<ColumnIndex> &bound_column_ids, optional_ptr<StandardEntry> entry, idx_t index,
-	             bool add_row_id = false);
-
-	//! A reference to the set of bound column ids
-	vector<ColumnIndex> &bound_column_ids;
-	//! The underlying catalog entry (if any)
-	optional_ptr<StandardEntry> entry;
-
-public:
-	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &column_name);
-	BindResult Bind(ColumnRefExpression &colref, idx_t depth) override;
-	optional_ptr<StandardEntry> GetStandardEntry() override;
-	ErrorData ColumnNotFoundError(const string &column_name) const override;
-	// These are columns that are present in the name_map, appearing in the order that they're bound
-	const vector<ColumnIndex> &GetBoundColumnIds() const;
-
-protected:
-	ColumnBinding GetColumnBinding(column_t column_index);
-};
-
-//! DummyBinding is like the Binding, except the alias and index are set by default.
-//! Used for binding lambdas and macro parameters.
-struct DummyBinding : public Binding {
-public:
-	static constexpr const BindingType TYPE = BindingType::DUMMY;
-	// NOTE: changing this string conflicts with the storage version
-	static constexpr const char *DUMMY_NAME = "0_macro_parameters";
-
-public:
-	DummyBinding(vector<LogicalType> types, vector<string> names, string dummy_name);
-
-	//! Arguments (for macros)
-	vector<unique_ptr<ParsedExpression>> *arguments;
-	//! The name of the dummy binding
-	string dummy_name;
-
-public:
-	//! Binding macros
-	BindResult Bind(ColumnRefExpression &col_ref, idx_t depth) override;
-	//! Binding lambdas
-	BindResult Bind(LambdaRefExpression &lambda_ref, idx_t depth);
-
-	//! Returns a copy of the col_ref parameter as a parsed expression
-	unique_ptr<ParsedExpression> ParamToArg(ColumnRefExpression &col_ref);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/table_filter.hpp b/src/duckdb/src/include/duckdb/planner/table_filter.hpp
deleted file mode 100644
index b39d529b0..000000000
--- a/src/duckdb/src/include/duckdb/planner/table_filter.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/table_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/common/column_index.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-class Expression;
-class PhysicalOperator;
-class PhysicalTableScan;
-
-enum class TableFilterType : uint8_t {
-	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
-	IS_NULL = 1,             // C IS NULL
-	IS_NOT_NULL = 2,         // C IS NOT NULL
-	CONJUNCTION_OR = 3,      // OR of different filters
-	CONJUNCTION_AND = 4,     // AND of different filters
-	STRUCT_EXTRACT = 5,      // filter applies to child-column of struct
-	OPTIONAL_FILTER = 6,     // executing filter is not required for query correctness
-	IN_FILTER = 7,           // col IN (C1, C2, C3, ...)
-	DYNAMIC_FILTER = 8       // dynamic filters can be updated at run-time
-};
-
-//! TableFilter represents a filter pushed down into the table scan.
-class TableFilter {
-public:
-	explicit TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
-	}
-	virtual ~TableFilter() {
-	}
-
-	TableFilterType filter_type;
-
-public:
-	//! Returns true if the statistics indicate that the segment can contain values that satisfy that filter
-	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
-	virtual string ToString(const string &column_name) = 0;
-	string DebugToString();
-	virtual unique_ptr<TableFilter> Copy() const = 0;
-	virtual bool Equals(const TableFilter &other) const {
-		return filter_type != other.filter_type;
-	}
-	virtual unique_ptr<Expression> ToExpression(const Expression &column) const = 0;
-
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (filter_type != TARGET::TYPE) {
-			throw InternalException("Failed to cast to type - table filter type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (filter_type != TARGET::TYPE) {
-			throw InternalException("Failed to cast to type - table filter type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class TableFilterSet {
-public:
-	unordered_map<idx_t, unique_ptr<TableFilter>> filters;
-
-public:
-	void PushFilter(const ColumnIndex &col_idx, unique_ptr<TableFilter> filter);
-
-	bool Equals(TableFilterSet &other) {
-		if (filters.size() != other.filters.size()) {
-			return false;
-		}
-		for (auto &entry : filters) {
-			auto other_entry = other.filters.find(entry.first);
-			if (other_entry == other.filters.end()) {
-				return false;
-			}
-			if (!entry.second->Equals(*other_entry->second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	static bool Equals(TableFilterSet *left, TableFilterSet *right) {
-		if (left == right) {
-			return true;
-		}
-		if (!left || !right) {
-			return false;
-		}
-		return left->Equals(*right);
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static TableFilterSet Deserialize(Deserializer &deserializer);
-};
-
-class DynamicTableFilterSet {
-public:
-	void ClearFilters(const PhysicalOperator &op);
-	void PushFilter(const PhysicalOperator &op, idx_t column_index, unique_ptr<TableFilter> filter);
-
-	bool HasFilters() const;
-	unique_ptr<TableFilterSet> GetFinalTableFilters(const PhysicalTableScan &scan,
-	                                                optional_ptr<TableFilterSet> existing_filters) const;
-
-private:
-	mutable mutex lock;
-	reference_map_t<const PhysicalOperator, unique_ptr<TableFilterSet>> filters;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_basetableref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_basetableref.hpp
deleted file mode 100644
index b1f7f6f46..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_basetableref.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_basetableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! Represents a TableReference to a base table in the schema
-class BoundBaseTableRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::BASE_TABLE;
-
-public:
-	BoundBaseTableRef(TableCatalogEntry &table, unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(std::move(get)) {
-	}
-
-	TableCatalogEntry &table;
-	unique_ptr<LogicalOperator> get;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_column_data_ref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_column_data_ref.hpp
deleted file mode 100644
index 025bc4712..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_column_data_ref.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_column_data_ref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/common/optionally_owned_ptr.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-
-namespace duckdb {
-//! Represents a TableReference to a base table in the schema
-class BoundColumnDataRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::COLUMN_DATA;
-
-public:
-	explicit BoundColumnDataRef(optionally_owned_ptr<ColumnDataCollection> collection)
-	    : BoundTableRef(TableReferenceType::COLUMN_DATA), collection(std::move(collection)) {
-	}
-	//! The (optionally owned) materialized column data to scan
-	optionally_owned_ptr<ColumnDataCollection> collection;
-	//! The index in the bind context
-	idx_t bind_index;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_cteref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_cteref.hpp
deleted file mode 100644
index 2e9db3ba9..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_cteref.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_cteref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-
-namespace duckdb {
-
-class BoundCTERef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::CTE;
-
-public:
-	BoundCTERef(idx_t bind_index, idx_t cte_index, CTEMaterialize materialized_cte)
-	    : BoundTableRef(TableReferenceType::CTE), bind_index(bind_index), cte_index(cte_index),
-	      materialized_cte(materialized_cte) {
-	}
-
-	//! The set of columns bound to this base table reference
-	vector<string> bound_columns;
-	//! The types of the values list
-	vector<LogicalType> types;
-	//! The index in the bind context
-	idx_t bind_index;
-	//! The index of the cte
-	idx_t cte_index;
-	//! Is this a reference to a materialized CTE?
-	CTEMaterialize materialized_cte;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_delimgetref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_delimgetref.hpp
deleted file mode 100644
index 7b1022482..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_delimgetref.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_delimgetref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-
-namespace duckdb {
-
-class BoundDelimGetRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::DELIM_GET;
-
-public:
-	BoundDelimGetRef(idx_t bind_index, const vector<LogicalType> &column_types_p)
-	    : BoundTableRef(TableReferenceType::DELIM_GET), bind_index(bind_index), column_types(column_types_p) {
-	}
-	idx_t bind_index;
-	vector<LogicalType> column_types;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_dummytableref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_dummytableref.hpp
deleted file mode 100644
index 3a68f5166..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_dummytableref.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_dummytableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-
-namespace duckdb {
-
-//! Represents a cross product
-class BoundEmptyTableRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::EMPTY_FROM;
-
-public:
-	explicit BoundEmptyTableRef(idx_t bind_index)
-	    : BoundTableRef(TableReferenceType::EMPTY_FROM), bind_index(bind_index) {
-	}
-	idx_t bind_index;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_expressionlistref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_expressionlistref.hpp
deleted file mode 100644
index 7fc563dda..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_expressionlistref.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_expressionlistref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-//! Represents a TableReference to a base table in the schema
-class BoundExpressionListRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::EXPRESSION_LIST;
-
-public:
-	BoundExpressionListRef() : BoundTableRef(TableReferenceType::EXPRESSION_LIST) {
-	}
-
-	//! The bound VALUES list
-	vector<vector<unique_ptr<Expression>>> values;
-	//! The generated names of the values list
-	vector<string> names;
-	//! The types of the values list
-	vector<LogicalType> types;
-	//! The index in the bind context
-	idx_t bind_index;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_joinref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_joinref.hpp
deleted file mode 100644
index 38c83c95f..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_joinref.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_joinref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enums/joinref_type.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-//! Represents a join
-class BoundJoinRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::JOIN;
-
-public:
-	explicit BoundJoinRef(JoinRefType ref_type)
-	    : BoundTableRef(TableReferenceType::JOIN), type(JoinType::INNER), ref_type(ref_type), lateral(false) {
-	}
-
-	//! The binder used to bind the LHS of the join
-	shared_ptr<Binder> left_binder;
-	//! The binder used to bind the RHS of the join
-	shared_ptr<Binder> right_binder;
-	//! The left hand side of the join
-	unique_ptr<BoundTableRef> left;
-	//! The right hand side of the join
-	unique_ptr<BoundTableRef> right;
-	//! The join condition
-	unique_ptr<Expression> condition;
-	//! Duplicate Eliminated Columns (if any)
-	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
-	//! If the delim is flipped
-	bool delim_flipped;
-	//! The join type
-	JoinType type;
-	//! Join condition type
-	JoinRefType ref_type;
-	//! Whether or not this is a lateral join
-	bool lateral;
-	//! The correlated columns of the right-side with the left-side
-	vector<CorrelatedColumnInfo> correlated_columns;
-	//! The mark index, for mark joins generated by the relational API
-	idx_t mark_index {};
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp
deleted file mode 100644
index 3219f6307..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_pivotref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-
-namespace duckdb {
-
-struct BoundPivotInfo {
-	//! The number of group columns
-	idx_t group_count;
-	//! The set of types
-	vector<LogicalType> types;
-	//! The set of values to pivot on
-	vector<string> pivot_values;
-	//! The set of aggregate functions that is being executed
-	vector<unique_ptr<Expression>> aggregates;
-
-	void Serialize(Serializer &serializer) const;
-	static BoundPivotInfo Deserialize(Deserializer &deserializer);
-};
-
-class BoundPivotRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::PIVOT;
-
-public:
-	explicit BoundPivotRef() : BoundTableRef(TableReferenceType::PIVOT) {
-	}
-
-	idx_t bind_index;
-	//! The binder used to bind the child of the pivot
-	shared_ptr<Binder> child_binder;
-	//! The child node of the pivot
-	unique_ptr<BoundTableRef> child;
-	//! The bound pivot info
-	BoundPivotInfo bound_pivot;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_pos_join_ref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_pos_join_ref.hpp
deleted file mode 100644
index 4cb057e41..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_pos_join_ref.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_pos_join_ref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-
-namespace duckdb {
-
-//! Represents a positional join
-class BoundPositionalJoinRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::POSITIONAL_JOIN;
-
-public:
-	BoundPositionalJoinRef() : BoundTableRef(TableReferenceType::POSITIONAL_JOIN), lateral(false) {
-	}
-
-	//! The binder used to bind the LHS of the positional join
-	shared_ptr<Binder> left_binder;
-	//! The binder used to bind the RHS of the positional join
-	shared_ptr<Binder> right_binder;
-	//! The left hand side of the positional join
-	unique_ptr<BoundTableRef> left;
-	//! The right hand side of the positional join
-	unique_ptr<BoundTableRef> right;
-	//! Whether or not this is a lateral positional join
-	bool lateral;
-	//! The correlated columns of the right-side with the left-side
-	vector<CorrelatedColumnInfo> correlated_columns;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_subqueryref.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_subqueryref.hpp
deleted file mode 100644
index 2d1061c98..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_subqueryref.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_subqueryref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-
-namespace duckdb {
-
-//! Represents a cross product
-class BoundSubqueryRef : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::SUBQUERY;
-
-public:
-	BoundSubqueryRef(shared_ptr<Binder> binder_p, unique_ptr<BoundQueryNode> subquery)
-	    : BoundTableRef(TableReferenceType::SUBQUERY), binder(std::move(binder_p)), subquery(std::move(subquery)) {
-	}
-
-	//! The binder used to bind the subquery
-	shared_ptr<Binder> binder;
-	//! The bound subquery node (if any)
-	unique_ptr<BoundQueryNode> subquery;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/bound_table_function.hpp b/src/duckdb/src/include/duckdb/planner/tableref/bound_table_function.hpp
deleted file mode 100644
index 6aafe2b36..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/bound_table_function.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_table_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-
-namespace duckdb {
-
-//! Represents a reference to a table-producing function call
-class BoundTableFunction : public BoundTableRef {
-public:
-	static constexpr const TableReferenceType TYPE = TableReferenceType::TABLE_FUNCTION;
-
-public:
-	explicit BoundTableFunction(unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::TABLE_FUNCTION), get(std::move(get)) {
-	}
-
-	unique_ptr<LogicalOperator> get;
-	unique_ptr<BoundSubqueryRef> subquery;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/tableref/list.hpp b/src/duckdb/src/include/duckdb/planner/tableref/list.hpp
deleted file mode 100644
index 79a00ce62..000000000
--- a/src/duckdb/src/include/duckdb/planner/tableref/list.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/tableref/bound_cteref.hpp"
-#include "duckdb/planner/tableref/bound_dummytableref.hpp"
-#include "duckdb/planner/tableref/bound_expressionlistref.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-#include "duckdb/planner/tableref/bound_column_data_ref.hpp"
-#include "duckdb/planner/tableref/bound_table_function.hpp"
-#include "duckdb/planner/tableref/bound_pivotref.hpp"
-#include "duckdb/parser/tableref/delimgetref.hpp"
-#include "duckdb/planner/tableref/bound_delimgetref.hpp"
diff --git a/src/duckdb/src/include/duckdb/storage/arena_allocator.hpp b/src/duckdb/src/include/duckdb/storage/arena_allocator.hpp
deleted file mode 100644
index d76aeccb6..000000000
--- a/src/duckdb/src/include/duckdb/storage/arena_allocator.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/arena_allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-struct ArenaChunk {
-	ArenaChunk(Allocator &allocator, idx_t size);
-	~ArenaChunk();
-
-	AllocatedData data;
-	idx_t current_position;
-	idx_t maximum_size;
-	unsafe_unique_ptr<ArenaChunk> next;
-	ArenaChunk *prev;
-};
-
-class ArenaAllocator {
-public:
-	static constexpr const idx_t ARENA_ALLOCATOR_INITIAL_CAPACITY = 2048;
-	static constexpr const idx_t ARENA_ALLOCATOR_MAX_CAPACITY = 1ULL << 24ULL; // 16MB
-
-public:
-	DUCKDB_API explicit ArenaAllocator(Allocator &allocator, idx_t initial_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY);
-	DUCKDB_API ~ArenaAllocator();
-
-	DUCKDB_API data_ptr_t Allocate(idx_t size);
-	DUCKDB_API data_ptr_t Reallocate(data_ptr_t pointer, idx_t old_size, idx_t size);
-
-	DUCKDB_API data_ptr_t AllocateAligned(idx_t size);
-	DUCKDB_API data_ptr_t ReallocateAligned(data_ptr_t pointer, idx_t old_size, idx_t size);
-
-	//! Increment the internal cursor (if required) so the next allocation is guaranteed to be aligned to 8 bytes
-	DUCKDB_API void AlignNext();
-
-	//! Resets the current head and destroys all previous arena chunks
-	DUCKDB_API void Reset();
-	DUCKDB_API void Destroy();
-	DUCKDB_API void Move(ArenaAllocator &allocator);
-
-	DUCKDB_API ArenaChunk *GetHead();
-	DUCKDB_API ArenaChunk *GetTail();
-
-	DUCKDB_API bool IsEmpty() const;
-	//! Get the total *used* size (not cached)
-	DUCKDB_API idx_t SizeInBytes() const;
-	//! Get the currently allocated size in bytes (cached, read from "allocated_size")
-	DUCKDB_API idx_t AllocationSize() const;
-
-	//! Returns an "Allocator" wrapper for this arena allocator
-	Allocator &GetAllocator() {
-		return arena_allocator;
-	}
-
-private:
-	//! Internal allocator that is used by the arena allocator
-	Allocator &allocator;
-	idx_t initial_capacity;
-	unsafe_unique_ptr<ArenaChunk> head;
-	ArenaChunk *tail;
-	//! An allocator wrapper using this arena allocator
-	Allocator arena_allocator;
-	//! The total allocated size
-	idx_t allocated_size = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/block.hpp b/src/duckdb/src/include/duckdb/storage/block.hpp
deleted file mode 100644
index 74074b21e..000000000
--- a/src/duckdb/src/include/duckdb/storage/block.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/block.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-
-class Block : public FileBuffer {
-public:
-	Block(Allocator &allocator, const block_id_t id, const idx_t block_size);
-	Block(Allocator &allocator, block_id_t id, uint32_t internal_size);
-	Block(FileBuffer &source, block_id_t id);
-
-	block_id_t id;
-};
-
-struct BlockPointer {
-	BlockPointer(block_id_t block_id_p, uint32_t offset_p) : block_id(block_id_p), offset(offset_p) {
-	}
-	BlockPointer() : block_id(INVALID_BLOCK), offset(0) {
-	}
-
-	block_id_t block_id;
-	uint32_t offset;
-	uint32_t unused_padding {0};
-
-	bool IsValid() const {
-		return block_id != INVALID_BLOCK;
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static BlockPointer Deserialize(Deserializer &source);
-};
-
-struct MetaBlockPointer {
-	MetaBlockPointer(idx_t block_pointer, uint32_t offset_p) : block_pointer(block_pointer), offset(offset_p) {
-	}
-	MetaBlockPointer() : block_pointer(DConstants::INVALID_INDEX), offset(0) {
-	}
-
-	idx_t block_pointer;
-	uint32_t offset;
-	uint32_t unused_padding {0};
-
-	bool IsValid() const {
-		return block_pointer != DConstants::INVALID_INDEX;
-	}
-	block_id_t GetBlockId() const;
-	uint32_t GetBlockIndex() const;
-
-	void Serialize(Serializer &serializer) const;
-	static MetaBlockPointer Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/block_manager.hpp b/src/duckdb/src/include/duckdb/storage/block_manager.hpp
deleted file mode 100644
index d93f417d1..000000000
--- a/src/duckdb/src/include/duckdb/storage/block_manager.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-class BlockHandle;
-class BufferHandle;
-class BufferManager;
-class ClientContext;
-class DatabaseInstance;
-class MetadataManager;
-
-//! BlockManager is an abstract representation to manage blocks on DuckDB. When writing or reading blocks, the
-//! BlockManager creates and accesses blocks. The concrete types implement specific block storage strategies.
-class BlockManager {
-public:
-	BlockManager() = delete;
-	BlockManager(BufferManager &buffer_manager, const optional_idx block_alloc_size_p);
-	virtual ~BlockManager() = default;
-
-	//! The buffer manager
-	BufferManager &buffer_manager;
-
-public:
-	//! Creates a new block inside the block manager
-	virtual unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) = 0;
-	virtual unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) = 0;
-	//! Return the next free block id
-	virtual block_id_t GetFreeBlockId() = 0;
-	virtual block_id_t PeekFreeBlockId() = 0;
-	//! Returns whether or not a specified block is the root block
-	virtual bool IsRootBlock(MetaBlockPointer root) = 0;
-	//! Mark a block as "free"; free blocks are immediately added to the free list and can be immediately overwritten
-	virtual void MarkBlockAsFree(block_id_t block_id) = 0;
-	//! Mark a block as "used"; either the block is removed from the free list, or the reference count is incremented
-	virtual void MarkBlockAsUsed(block_id_t block_id) = 0;
-	//! Mark a block as "modified"; modified blocks are added to the free list after a checkpoint (i.e. their data is
-	//! assumed to be rewritten)
-	virtual void MarkBlockAsModified(block_id_t block_id) = 0;
-	//! Increase the reference count of a block. The block should hold at least one reference before this method is
-	//! called.
-	virtual void IncreaseBlockReferenceCount(block_id_t block_id) = 0;
-	//! Get the first meta block id
-	virtual idx_t GetMetaBlock() = 0;
-	//! Read the content of the block from disk
-	virtual void Read(Block &block) = 0;
-	//! Read the content of the block from disk
-	virtual void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) = 0;
-	//! Writes the block to disk
-	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
-	//! Writes the block to disk
-	void Write(Block &block) {
-		Write(block, block.id);
-	}
-	//! Write the header; should be the final step of a checkpoint
-	virtual void WriteHeader(DatabaseHeader header) = 0;
-
-	//! Returns the number of total blocks
-	virtual idx_t TotalBlocks() = 0;
-	//! Returns the number of free blocks
-	virtual idx_t FreeBlocks() = 0;
-	//! Whether or not the attached database is a remote file (e.g. attached over s3/https)
-	virtual bool IsRemote() {
-		return false;
-	}
-	//! Whether or not the attached database is in-memory
-	virtual bool InMemory() = 0;
-
-	//! Sync changes made to the block manager
-	virtual void FileSync() = 0;
-	//! Truncate the underlying database file after a checkpoint
-	virtual void Truncate();
-
-	//! Register a block with the given block id in the base file
-	shared_ptr<BlockHandle> RegisterBlock(block_id_t block_id);
-	//! Convert an existing in-memory buffer into a persistent disk-backed block
-	shared_ptr<BlockHandle> ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block,
-	                                            BufferHandle old_handle);
-	shared_ptr<BlockHandle> ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block);
-
-	void UnregisterBlock(BlockHandle &block);
-	//! UnregisterBlock, only accepts non-temporary block ids
-	void UnregisterBlock(block_id_t id);
-
-	//! Returns a reference to the metadata manager of this block manager.
-	MetadataManager &GetMetadataManager();
-	//! Returns the block allocation size of this block manager.
-	inline idx_t GetBlockAllocSize() const {
-		return block_alloc_size.GetIndex();
-	}
-	//! Returns the possibly invalid block allocation size of this block manager.
-	inline optional_idx GetOptionalBlockAllocSize() const {
-		return block_alloc_size;
-	}
-	//! Returns the block size of this block manager.
-	inline idx_t GetBlockSize() const {
-		return block_alloc_size.GetIndex() - Storage::DEFAULT_BLOCK_HEADER_SIZE;
-	}
-	//! Sets the block allocation size. This should only happen when initializing an existing database.
-	//! When initializing an existing database, we construct the block manager before reading the file header,
-	//! which contains the file's actual block allocation size.
-	void SetBlockAllocSize(const optional_idx block_alloc_size_p) {
-		if (block_alloc_size.IsValid()) {
-			throw InternalException("the block allocation size must be set once");
-		}
-		block_alloc_size = block_alloc_size_p.GetIndex();
-	}
-
-	//! Verify the block usage count
-	virtual void VerifyBlocks(const unordered_map<block_id_t, idx_t> &block_usage_count) {
-	}
-
-private:
-	//! The lock for the set of blocks
-	mutex blocks_lock;
-	//! A mapping of block id -> BlockHandle
-	unordered_map<block_id_t, weak_ptr<BlockHandle>> blocks;
-	//! The metadata manager
-	unique_ptr<MetadataManager> metadata_manager;
-	//! The allocation size of blocks managed by this block manager. Defaults to DEFAULT_BLOCK_ALLOC_SIZE
-	//! for in-memory block managers. Default to default_block_alloc_size for file-backed block managers.
-	//! This is NOT the actual memory available on a block (block_size).
-	optional_idx block_alloc_size;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp b/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp
deleted file mode 100644
index 1f7970d5d..000000000
--- a/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp
+++ /dev/null
@@ -1,213 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/block_handle.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/destroy_buffer_upon.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-class BlockManager;
-class BufferHandle;
-class BufferPool;
-class DatabaseInstance;
-
-enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
-
-struct BufferPoolReservation {
-	MemoryTag tag;
-	idx_t size {0};
-	BufferPool &pool;
-
-	BufferPoolReservation(MemoryTag tag, BufferPool &pool);
-	BufferPoolReservation(const BufferPoolReservation &) = delete;
-	BufferPoolReservation &operator=(const BufferPoolReservation &) = delete;
-
-	BufferPoolReservation(BufferPoolReservation &&) noexcept;
-	BufferPoolReservation &operator=(BufferPoolReservation &&) noexcept;
-
-	~BufferPoolReservation();
-
-	void Resize(idx_t new_size);
-	void Merge(BufferPoolReservation src);
-};
-
-struct TempBufferPoolReservation : BufferPoolReservation {
-	TempBufferPoolReservation(MemoryTag tag, BufferPool &pool, idx_t size) : BufferPoolReservation(tag, pool) {
-		Resize(size);
-	}
-	TempBufferPoolReservation(TempBufferPoolReservation &&) = default;
-	~TempBufferPoolReservation() {
-		Resize(0);
-	}
-};
-
-using BlockLock = unique_lock<mutex>;
-
-class BlockHandle : public enable_shared_from_this<BlockHandle> {
-public:
-	BlockHandle(BlockManager &block_manager, block_id_t block_id, MemoryTag tag);
-	BlockHandle(BlockManager &block_manager, block_id_t block_id, MemoryTag tag, unique_ptr<FileBuffer> buffer,
-	            DestroyBufferUpon destroy_buffer_upon, idx_t block_size, BufferPoolReservation &&reservation);
-	~BlockHandle();
-
-	BlockManager &block_manager;
-
-public:
-	block_id_t BlockId() const {
-		return block_id;
-	}
-
-	idx_t EvictionSequenceNumber() const {
-		return eviction_seq_num;
-	}
-
-	idx_t NextEvictionSequenceNumber() {
-		return ++eviction_seq_num;
-	}
-
-	int32_t Readers() const {
-		return readers;
-	}
-	int32_t DecrementReaders() {
-		return --readers;
-	}
-
-	inline bool IsSwizzled() const {
-		return !unswizzled;
-	}
-
-	inline void SetSwizzling(const char *unswizzler) {
-		unswizzled = unswizzler;
-	}
-
-	MemoryTag GetMemoryTag() const {
-		return tag;
-	}
-
-	inline void SetDestroyBufferUpon(DestroyBufferUpon destroy_buffer_upon_p) {
-		destroy_buffer_upon = destroy_buffer_upon_p;
-	}
-
-	inline bool MustAddToEvictionQueue() const {
-		return destroy_buffer_upon != DestroyBufferUpon::UNPIN;
-	}
-
-	inline bool MustWriteToTemporaryFile() const {
-		return destroy_buffer_upon == DestroyBufferUpon::BLOCK;
-	}
-
-	inline idx_t GetMemoryUsage() const {
-		return memory_usage;
-	}
-
-	bool IsUnloaded() const {
-		return state == BlockState::BLOCK_UNLOADED;
-	}
-
-	void SetEvictionQueueIndex(const idx_t index) {
-		// can only be set once
-		D_ASSERT(eviction_queue_idx == DConstants::INVALID_INDEX);
-		// MANAGED_BUFFER only (at least, for now)
-		D_ASSERT(GetBufferType() == FileBufferType::MANAGED_BUFFER);
-		eviction_queue_idx = index;
-	}
-
-	idx_t GetEvictionQueueIndex() const {
-		return eviction_queue_idx;
-	}
-
-	FileBufferType GetBufferType() const {
-		return buffer_type;
-	}
-
-	BlockState GetState() const {
-		return state;
-	}
-
-	int64_t GetLRUTimestamp() const {
-		return lru_timestamp_msec;
-	}
-
-	void SetLRUTimestamp(int64_t timestamp_msec) {
-		lru_timestamp_msec = timestamp_msec;
-	}
-
-	BlockLock GetLock() {
-		return BlockLock(lock);
-	}
-
-	//! Gets a reference to the buffer - the lock must be held
-	unique_ptr<FileBuffer> &GetBuffer(BlockLock &l);
-
-	void ChangeMemoryUsage(BlockLock &l, int64_t delta);
-	BufferPoolReservation &GetMemoryCharge(BlockLock &l);
-	//! Merge a new memory reservation
-	void MergeMemoryReservation(BlockLock &, BufferPoolReservation reservation);
-	//! Resize the memory allocation
-	void ResizeMemory(BlockLock &, idx_t alloc_size);
-
-	//! Resize the actual buffer
-	void ResizeBuffer(BlockLock &, idx_t block_size, int64_t memory_delta);
-	BufferHandle Load(unique_ptr<FileBuffer> buffer = nullptr);
-	BufferHandle LoadFromBuffer(BlockLock &l, data_ptr_t data, unique_ptr<FileBuffer> reusable_buffer,
-	                            BufferPoolReservation reservation);
-	unique_ptr<FileBuffer> UnloadAndTakeBlock(BlockLock &);
-	void Unload(BlockLock &);
-
-	//! Returns whether or not the block can be unloaded
-	//! Note that while this method does not require a lock, whether or not a block can be unloaded can change if the
-	//! lock is not held
-	bool CanUnload() const;
-
-	void ConvertToPersistent(BlockLock &, BlockHandle &new_block, unique_ptr<FileBuffer> new_buffer);
-
-private:
-	void VerifyMutex(unique_lock<mutex> &l) const;
-
-private:
-	//! The block-level lock
-	mutex lock;
-	//! Whether or not the block is loaded/unloaded
-	atomic<BlockState> state;
-	//! Amount of concurrent readers
-	atomic<int32_t> readers;
-	//! The block id of the block
-	const block_id_t block_id;
-	//! Memory tag
-	const MemoryTag tag;
-	//! File buffer type
-	const FileBufferType buffer_type;
-	//! Pointer to loaded data (if any)
-	unique_ptr<FileBuffer> buffer;
-	//! Internal eviction sequence number
-	atomic<idx_t> eviction_seq_num;
-	//! LRU timestamp (for age-based eviction)
-	atomic<int64_t> lru_timestamp_msec;
-	//! When to destroy the data buffer
-	atomic<DestroyBufferUpon> destroy_buffer_upon;
-	//! The memory usage of the block (when loaded). If we are pinning/loading
-	//! an unloaded block, this tells us how much memory to reserve.
-	atomic<idx_t> memory_usage;
-	//! Current memory reservation / usage
-	BufferPoolReservation memory_charge;
-	//! Does the block contain any memory pointers?
-	const char *unswizzled;
-	//! Index for eviction queue (FileBufferType::MANAGED_BUFFER only, for now)
-	atomic<idx_t> eviction_queue_idx;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/buffer/buffer_handle.hpp b/src/duckdb/src/include/duckdb/storage/buffer/buffer_handle.hpp
deleted file mode 100644
index 32ae0ee5f..000000000
--- a/src/duckdb/src/include/duckdb/storage/buffer/buffer_handle.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/buffer_handle.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/file_buffer.hpp"
-
-namespace duckdb {
-class BlockHandle;
-class FileBuffer;
-
-class BufferHandle {
-public:
-	DUCKDB_API BufferHandle();
-	DUCKDB_API explicit BufferHandle(shared_ptr<BlockHandle> handle, optional_ptr<FileBuffer> node);
-	DUCKDB_API ~BufferHandle();
-	// disable copy constructors
-	BufferHandle(const BufferHandle &other) = delete;
-	BufferHandle &operator=(const BufferHandle &) = delete;
-	//! enable move constructors
-	DUCKDB_API BufferHandle(BufferHandle &&other) noexcept;
-	DUCKDB_API BufferHandle &operator=(BufferHandle &&) noexcept;
-
-public:
-	//! Returns whether or not the BufferHandle is valid.
-	DUCKDB_API bool IsValid() const;
-	//! Returns a pointer to the buffer data. Handle must be valid.
-	inline data_ptr_t Ptr() const {
-		D_ASSERT(IsValid());
-		return node->buffer;
-	}
-	//! Returns a pointer to the buffer data. Handle must be valid.
-	inline data_ptr_t Ptr() {
-		D_ASSERT(IsValid());
-		return node->buffer;
-	}
-	//! Gets the underlying file buffer. Handle must be valid.
-	DUCKDB_API FileBuffer &GetFileBuffer();
-	//! Destroys the buffer handle
-	DUCKDB_API void Destroy();
-
-	const shared_ptr<BlockHandle> &GetBlockHandle() const {
-		return handle;
-	}
-
-private:
-	//! The block handle
-	shared_ptr<BlockHandle> handle;
-	//! The managed buffer node
-	optional_ptr<FileBuffer> node;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp b/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp
deleted file mode 100644
index f4548e430..000000000
--- a/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/buffer_pool.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/array.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-
-namespace duckdb {
-
-class TemporaryMemoryManager;
-struct EvictionQueue;
-
-struct BufferEvictionNode {
-	BufferEvictionNode() {
-	}
-	BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t eviction_seq_num);
-
-	weak_ptr<BlockHandle> handle;
-	idx_t handle_sequence_number;
-
-	bool CanUnload(BlockHandle &handle_p);
-	shared_ptr<BlockHandle> TryGetBlockHandle();
-};
-
-//! The BufferPool is in charge of handling memory management for one or more databases. It defines memory limits
-//! and implements priority eviction among all users of the pool.
-class BufferPool {
-	friend class BlockHandle;
-	friend class BlockManager;
-	friend class BufferManager;
-	friend class StandardBufferManager;
-
-public:
-	BufferPool(idx_t maximum_memory, bool track_eviction_timestamps, idx_t allocator_bulk_deallocation_flush_threshold);
-	virtual ~BufferPool();
-
-	//! Set a new memory limit to the buffer pool, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetLimit(idx_t limit, const char *exception_postscript);
-
-	//! If bulk deallocation larger than this occurs, flush outstanding allocations
-	void SetAllocatorBulkDeallocationFlushThreshold(idx_t threshold);
-	idx_t GetAllocatorBulkDeallocationFlushThreshold();
-
-	void UpdateUsedMemory(MemoryTag tag, int64_t size);
-
-	idx_t GetUsedMemory() const;
-
-	idx_t GetMaxMemory() const;
-
-	virtual idx_t GetQueryMaxMemory() const;
-
-	TemporaryMemoryManager &GetTemporaryMemoryManager();
-
-protected:
-	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
-	//! (i.e. not enough blocks could be evicted)
-	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
-	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
-	//! Returns a pair. result.first indicates if eviction was successful. result.second contains the
-	//! reservation handle, which can be moved to the BlockHandle that will own the reservation.
-	struct EvictionResult {
-		bool success;
-		TempBufferPoolReservation reservation;
-	};
-	virtual EvictionResult EvictBlocks(MemoryTag tag, idx_t extra_memory, idx_t memory_limit,
-	                                   unique_ptr<FileBuffer> *buffer = nullptr);
-	virtual EvictionResult EvictBlocksInternal(EvictionQueue &queue, MemoryTag tag, idx_t extra_memory,
-	                                           idx_t memory_limit, unique_ptr<FileBuffer> *buffer = nullptr);
-
-	//! Purge all blocks that haven't been pinned within the last N seconds
-	idx_t PurgeAgedBlocks(uint32_t max_age_sec);
-	idx_t PurgeAgedBlocksInternal(EvictionQueue &queue, uint32_t max_age_sec, int64_t now, int64_t limit);
-	//! Garbage collect dead nodes in the eviction queue.
-	void PurgeQueue(const BlockHandle &handle);
-	//! Add a buffer handle to the eviction queue. Returns true, if the queue is
-	//! ready to be purged, and false otherwise.
-	bool AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-	//! Gets the eviction queue for the specified type
-	EvictionQueue &GetEvictionQueueForBlockHandle(const BlockHandle &handle);
-	//! Increments the dead nodes for the queue with specified type
-	void IncrementDeadNodes(const BlockHandle &handle);
-
-	//! How many eviction queues we have for the different FileBufferTypes
-	static constexpr idx_t BLOCK_QUEUE_SIZE = 1;
-	static constexpr idx_t MANAGED_BUFFER_QUEUE_SIZE = 6;
-	static constexpr idx_t TINY_BUFFER_QUEUE_SIZE = 1;
-	//! Mapping and priority order for the eviction queues
-	const array<idx_t, FILE_BUFFER_TYPE_COUNT> eviction_queue_sizes;
-
-protected:
-	enum class MemoryUsageCaches {
-		FLUSH,
-		NO_FLUSH,
-	};
-
-	struct MemoryUsage {
-		//! The maximum difference between memory statistics and actual usage is 2MB (64 * 32k)
-		static constexpr idx_t MEMORY_USAGE_CACHE_COUNT = 64;
-		static constexpr idx_t MEMORY_USAGE_CACHE_THRESHOLD = 32 << 10;
-		static constexpr idx_t TOTAL_MEMORY_USAGE_INDEX = MEMORY_TAG_COUNT;
-		using MemoryUsageCounters = array<atomic<int64_t>, MEMORY_TAG_COUNT + 1>;
-
-		//! global memory usage counters
-		MemoryUsageCounters memory_usage;
-		//! cache memory usage to improve performance
-		array<MemoryUsageCounters, MEMORY_USAGE_CACHE_COUNT> memory_usage_caches;
-
-		MemoryUsage();
-
-		idx_t GetUsedMemory(MemoryUsageCaches cache) {
-			return GetUsedMemory(TOTAL_MEMORY_USAGE_INDEX, cache);
-		}
-
-		idx_t GetUsedMemory(MemoryTag tag, MemoryUsageCaches cache) {
-			return GetUsedMemory((idx_t)tag, cache);
-		}
-
-		idx_t GetUsedMemory(idx_t index, MemoryUsageCaches cache) {
-			if (cache == MemoryUsageCaches::NO_FLUSH) {
-				auto used_memory = memory_usage[index].load(std::memory_order_relaxed);
-				return used_memory > 0 ? static_cast<idx_t>(used_memory) : 0;
-			}
-			int64_t cached = 0;
-			for (auto &cache : memory_usage_caches) {
-				cached += cache[index].exchange(0, std::memory_order_relaxed);
-			}
-			auto used_memory = memory_usage[index].fetch_add(cached, std::memory_order_relaxed) + cached;
-			return used_memory > 0 ? static_cast<idx_t>(used_memory) : 0;
-		}
-
-		void UpdateUsedMemory(MemoryTag tag, int64_t size);
-	};
-
-	//! The lock for changing the memory limit
-	mutex limit_lock;
-	//! The maximum amount of memory that the buffer manager can keep (in bytes)
-	atomic<idx_t> maximum_memory;
-	//! If bulk deallocation larger than this occurs, flush outstanding allocations
-	atomic<idx_t> allocator_bulk_deallocation_flush_threshold;
-	//! Record timestamps of buffer manager unpin() events. Usable by custom eviction policies.
-	bool track_eviction_timestamps;
-	//! Eviction queues
-	vector<unique_ptr<EvictionQueue>> queues;
-	//! Memory manager for concurrently used temporary memory, e.g., for physical operators
-	unique_ptr<TemporaryMemoryManager> temporary_memory_manager;
-	//! To improve performance, MemoryUsage maintains counter caches based on current cpu or thread id,
-	//! and only updates the global counter when the cache value exceeds a threshold.
-	//! Therefore, the statistics may have slight differences from the actual memory usage.
-	mutable MemoryUsage memory_usage;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/buffer/temporary_file_information.hpp b/src/duckdb/src/include/duckdb/storage/buffer/temporary_file_information.hpp
deleted file mode 100644
index 4da97844a..000000000
--- a/src/duckdb/src/include/duckdb/storage/buffer/temporary_file_information.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
-
-namespace duckdb {
-
-struct MemoryInformation {
-	MemoryTag tag;
-	idx_t size;
-	idx_t evicted_data;
-};
-
-struct TemporaryFileInformation {
-	string path;
-	idx_t size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp b/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp
deleted file mode 100644
index f497aa1db..000000000
--- a/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
-#include "duckdb/storage/buffer/temporary_file_information.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-class Allocator;
-class BufferPool;
-class TemporaryMemoryManager;
-
-class BufferManager {
-	friend class BufferHandle;
-	friend class BlockHandle;
-	friend class BlockManager;
-
-public:
-	BufferManager() {
-	}
-	virtual ~BufferManager() {
-	}
-
-public:
-	virtual BufferHandle Allocate(MemoryTag tag, idx_t block_size, bool can_destroy = true) = 0;
-	//! Reallocate an in-memory buffer that is pinned.
-	virtual void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) = 0;
-	virtual BufferHandle Pin(shared_ptr<BlockHandle> &handle) = 0;
-	//! Prefetch a series of blocks. Note that this is a performance suggestion.
-	virtual void Prefetch(vector<shared_ptr<BlockHandle>> &handles) = 0;
-	virtual void Unpin(shared_ptr<BlockHandle> &handle) = 0;
-
-	//! Returns the currently allocated memory
-	virtual idx_t GetUsedMemory() const = 0;
-	//! Returns the maximum available memory
-	virtual idx_t GetMaxMemory() const = 0;
-	//! Returns the currently used swap space
-	virtual idx_t GetUsedSwap() = 0;
-	//! Returns the maximum swap space that can be used
-	virtual optional_idx GetMaxSwap() const = 0;
-	//! Returns the block allocation size for buffer-managed blocks.
-	virtual idx_t GetBlockAllocSize() const = 0;
-	//! Returns the block size for buffer-managed blocks.
-	virtual idx_t GetBlockSize() const = 0;
-
-	//! Returns a new block of transient memory.
-	virtual shared_ptr<BlockHandle> RegisterTransientMemory(const idx_t size, const idx_t block_size);
-	//! Returns a new block of memory that is smaller than the block size setting.
-	virtual shared_ptr<BlockHandle> RegisterSmallMemory(const idx_t size);
-	virtual shared_ptr<BlockHandle> RegisterSmallMemory(MemoryTag tag, const idx_t size);
-
-	virtual DUCKDB_API Allocator &GetBufferAllocator();
-	virtual DUCKDB_API void ReserveMemory(idx_t size);
-	virtual DUCKDB_API void FreeReservedMemory(idx_t size);
-	virtual vector<MemoryInformation> GetMemoryUsageInfo() const = 0;
-	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	virtual void SetMemoryLimit(idx_t limit = (idx_t)-1);
-	virtual void SetSwapLimit(optional_idx limit = optional_idx());
-
-	virtual vector<TemporaryFileInformation> GetTemporaryFiles();
-	virtual const string &GetTemporaryDirectory() const;
-	virtual void SetTemporaryDirectory(const string &new_dir);
-	virtual bool HasTemporaryDirectory() const;
-
-	//! Construct a managed buffer.
-	virtual unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
-	                                                      FileBufferType type = FileBufferType::MANAGED_BUFFER);
-	//! Get the underlying buffer pool responsible for managing the buffers
-	virtual BufferPool &GetBufferPool() const;
-
-	virtual DatabaseInstance &GetDatabase() = 0;
-	// Static methods
-	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
-	DUCKDB_API static const BufferManager &GetBufferManager(const DatabaseInstance &db);
-	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
-	DUCKDB_API static const BufferManager &GetBufferManager(const ClientContext &context);
-	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);
-
-	static idx_t GetAllocSize(const idx_t block_size) {
-		return AlignValue<idx_t, Storage::SECTOR_SIZE>(block_size + Storage::DEFAULT_BLOCK_HEADER_SIZE);
-	}
-	//! Returns the maximum available memory for a given query
-	idx_t GetQueryMaxMemory() const;
-
-	//! Get the manager that assigns reservations for temporary memory, e.g., for query intermediates
-	virtual TemporaryMemoryManager &GetTemporaryMemoryManager();
-
-protected:
-	virtual void PurgeQueue(const BlockHandle &handle) = 0;
-	virtual void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-	virtual void WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer);
-	virtual unique_ptr<FileBuffer> ReadTemporaryBuffer(MemoryTag tag, BlockHandle &block,
-	                                                   unique_ptr<FileBuffer> buffer);
-	virtual void DeleteTemporaryFile(BlockHandle &block);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint/row_group_writer.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint/row_group_writer.hpp
deleted file mode 100644
index d52313902..000000000
--- a/src/duckdb/src/include/duckdb/storage/checkpoint/row_group_writer.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/row_group_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/checkpoint_manager.hpp"
-
-namespace duckdb {
-struct ColumnCheckpointState;
-class CheckpointWriter;
-class ColumnData;
-class ColumnSegment;
-class RowGroup;
-class BaseStatistics;
-class SegmentStatistics;
-
-// Writes data for an entire row group.
-class RowGroupWriter {
-public:
-	RowGroupWriter(TableCatalogEntry &table, PartialBlockManager &partial_block_manager)
-	    : table(table), partial_block_manager(partial_block_manager) {
-	}
-	virtual ~RowGroupWriter() {
-	}
-
-	CompressionType GetColumnCompressionType(idx_t i);
-
-	virtual CheckpointType GetCheckpointType() const = 0;
-	virtual MetadataWriter &GetPayloadWriter() = 0;
-
-	PartialBlockManager &GetPartialBlockManager() {
-		return partial_block_manager;
-	}
-
-protected:
-	TableCatalogEntry &table;
-	PartialBlockManager &partial_block_manager;
-};
-
-// Writes data for an entire row group.
-class SingleFileRowGroupWriter : public RowGroupWriter {
-public:
-	SingleFileRowGroupWriter(TableCatalogEntry &table, PartialBlockManager &partial_block_manager,
-	                         TableDataWriter &writer, MetadataWriter &table_data_writer);
-
-public:
-	CheckpointType GetCheckpointType() const override;
-	MetadataWriter &GetPayloadWriter() override;
-
-private:
-	//! Underlying writer object
-	TableDataWriter &writer;
-	//! MetadataWriter is a cursor on a given BlockManager. This returns the
-	//! cursor against which we should write payload data for the specified RowGroup.
-	MetadataWriter &table_data_writer;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp
deleted file mode 100644
index 2b49a4cbc..000000000
--- a/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/string_checkpoint_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/function/compression_function.hpp"
-
-namespace duckdb {
-struct UncompressedStringSegmentState;
-
-class OverflowStringWriter {
-public:
-	virtual ~OverflowStringWriter() {
-	}
-
-	virtual void WriteString(UncompressedStringSegmentState &state, string_t string, block_id_t &result_block,
-	                         int32_t &result_offset) = 0;
-	virtual void Flush() = 0;
-};
-
-struct StringBlock {
-	shared_ptr<BlockHandle> block;
-	idx_t offset;
-	idx_t size;
-	unique_ptr<StringBlock> next;
-};
-
-struct UncompressedStringSegmentState : public CompressedSegmentState {
-	~UncompressedStringSegmentState() override;
-
-	//! The string block holding strings that do not fit in the main block
-	//! FIXME: this should be replaced by a heap that also allows freeing of unused strings
-	unique_ptr<StringBlock> head;
-	//! Map of block id to string block
-	unordered_map<block_id_t, reference<StringBlock>> overflow_blocks;
-	//! Overflow string writer (if any), if not set overflow strings will be written to memory blocks
-	unique_ptr<OverflowStringWriter> overflow_writer;
-	//! The set of overflow blocks written to disk (if any)
-	vector<block_id_t> on_disk_blocks;
-
-public:
-	shared_ptr<BlockHandle> GetHandle(BlockManager &manager, block_id_t block_id);
-
-	void RegisterBlock(BlockManager &manager, block_id_t block_id);
-
-	string GetSegmentInfo() const override {
-		if (on_disk_blocks.empty()) {
-			return "";
-		}
-		string result = StringUtil::Join(on_disk_blocks, on_disk_blocks.size(), ", ",
-		                                 [&](block_id_t block) { return to_string(block); });
-		return "Overflow String Block Ids: " + result;
-	}
-
-	vector<block_id_t> GetAdditionalBlocks() const override {
-		return on_disk_blocks;
-	}
-
-private:
-	mutex block_lock;
-	unordered_map<block_id_t, shared_ptr<BlockHandle>> handles;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_reader.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_reader.hpp
deleted file mode 100644
index 20ca6d4d3..000000000
--- a/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_reader.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/table_data_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/checkpoint_manager.hpp"
-
-namespace duckdb {
-struct BoundCreateTableInfo;
-
-//! The table data reader is responsible for reading the data of a table from the block manager
-class TableDataReader {
-public:
-	TableDataReader(MetadataReader &reader, BoundCreateTableInfo &info);
-
-	void ReadTableData();
-
-private:
-	MetadataReader &reader;
-	BoundCreateTableInfo &info;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_writer.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_writer.hpp
deleted file mode 100644
index a606b5615..000000000
--- a/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_writer.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/table_data_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/checkpoint/row_group_writer.hpp"
-
-namespace duckdb {
-class DuckTableEntry;
-class TableStatistics;
-
-//! The table data writer is responsible for writing the data of a table to
-//! storage.
-//
-//! This is meant to encapsulate and abstract:
-//!  - Storage/encoding of table metadata (block pointers)
-//!  - Mapping management of data block locations
-//! Abstraction will support, for example: tiering, versioning, or splitting into multiple block managers.
-class TableDataWriter {
-public:
-	explicit TableDataWriter(TableCatalogEntry &table);
-	virtual ~TableDataWriter();
-
-public:
-	void WriteTableData(Serializer &metadata_serializer);
-
-	CompressionType GetColumnCompressionType(idx_t i);
-
-	virtual void FinalizeTable(const TableStatistics &global_stats, DataTableInfo *info, Serializer &serializer) = 0;
-	virtual unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) = 0;
-
-	virtual void AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> writer);
-	virtual CheckpointType GetCheckpointType() const = 0;
-
-	TaskScheduler &GetScheduler();
-	DatabaseInstance &GetDatabase();
-
-protected:
-	DuckTableEntry &table;
-	//! Pointers to the start of each row group.
-	vector<RowGroupPointer> row_group_pointers;
-};
-
-class SingleFileTableDataWriter : public TableDataWriter {
-public:
-	SingleFileTableDataWriter(SingleFileCheckpointWriter &checkpoint_manager, TableCatalogEntry &table,
-	                          MetadataWriter &table_data_writer);
-
-public:
-	void FinalizeTable(const TableStatistics &global_stats, DataTableInfo *info, Serializer &serializer) override;
-	unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) override;
-	CheckpointType GetCheckpointType() const override;
-
-private:
-	SingleFileCheckpointWriter &checkpoint_manager;
-	//! Writes the actual table data
-	MetadataWriter &table_data_writer;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp
deleted file mode 100644
index ff9f4c14d..000000000
--- a/src/duckdb/src/include/duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/checkpoint/string_checkpoint_state.hpp"
-
-namespace duckdb {
-
-class WriteOverflowStringsToDisk : public OverflowStringWriter {
-public:
-	explicit WriteOverflowStringsToDisk(PartialBlockManager &partial_block_manager);
-	~WriteOverflowStringsToDisk() override;
-
-	//! The block manager
-	PartialBlockManager &partial_block_manager;
-
-	//! Temporary buffer
-	BufferHandle handle;
-	//! The block on-disk to which we are writing
-	block_id_t block_id;
-	//! The offset within the current block
-	idx_t offset;
-
-public:
-	void WriteString(UncompressedStringSegmentState &state, string_t string, block_id_t &result_block,
-	                 int32_t &result_offset) override;
-	void Flush() override;
-
-private:
-	void AllocateNewBlock(UncompressedStringSegmentState &state, block_id_t new_block_id);
-	idx_t GetStringSpace() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint_manager.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint_manager.hpp
deleted file mode 100644
index cb0455deb..000000000
--- a/src/duckdb/src/include/duckdb/storage/checkpoint_manager.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/partial_block_manager.hpp"
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-class ClientContext;
-class ColumnSegment;
-class MetadataReader;
-class SchemaCatalogEntry;
-class SequenceCatalogEntry;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class TypeCatalogEntry;
-
-class CheckpointWriter {
-public:
-	explicit CheckpointWriter(AttachedDatabase &db) : db(db) {
-	}
-	virtual ~CheckpointWriter() {
-	}
-
-	//! The database
-	AttachedDatabase &db;
-
-	virtual MetadataManager &GetMetadataManager() = 0;
-	virtual MetadataWriter &GetMetadataWriter() = 0;
-	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) = 0;
-
-protected:
-	virtual void WriteEntry(CatalogEntry &entry, Serializer &serializer);
-	virtual void WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer);
-	virtual void WriteTable(TableCatalogEntry &table, Serializer &serializer) = 0;
-	virtual void WriteView(ViewCatalogEntry &table, Serializer &serializer);
-	virtual void WriteSequence(SequenceCatalogEntry &table, Serializer &serializer);
-	virtual void WriteMacro(ScalarMacroCatalogEntry &table, Serializer &serializer);
-	virtual void WriteTableMacro(TableMacroCatalogEntry &table, Serializer &serializer);
-	virtual void WriteIndex(IndexCatalogEntry &index_catalog_entry, Serializer &serializer);
-	virtual void WriteType(TypeCatalogEntry &type, Serializer &serializer);
-};
-
-class CheckpointReader {
-public:
-	explicit CheckpointReader(Catalog &catalog) : catalog(catalog) {
-	}
-	virtual ~CheckpointReader() {
-	}
-
-protected:
-	Catalog &catalog;
-
-protected:
-	virtual void LoadCheckpoint(CatalogTransaction transaction, MetadataReader &reader);
-	virtual void ReadEntry(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadSchema(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadTable(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadView(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadSequence(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadMacro(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadTableMacro(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadIndex(CatalogTransaction transaction, Deserializer &deserializer);
-	virtual void ReadType(CatalogTransaction transaction, Deserializer &deserializer);
-
-	virtual void ReadTableData(CatalogTransaction transaction, Deserializer &deserializer,
-	                           BoundCreateTableInfo &bound_info);
-};
-
-class SingleFileCheckpointReader final : public CheckpointReader {
-public:
-	explicit SingleFileCheckpointReader(SingleFileStorageManager &storage)
-	    : CheckpointReader(Catalog::GetCatalog(storage.GetAttached())), storage(storage) {
-	}
-
-	void LoadFromStorage();
-	MetadataManager &GetMetadataManager();
-
-	//! The database
-	SingleFileStorageManager &storage;
-};
-
-//! CheckpointWriter is responsible for checkpointing the database
-class SingleFileRowGroupWriter;
-class SingleFileTableDataWriter;
-
-class SingleFileCheckpointWriter final : public CheckpointWriter {
-	friend class SingleFileRowGroupWriter;
-	friend class SingleFileTableDataWriter;
-
-public:
-	SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager, CheckpointType checkpoint_type);
-
-	//! Checkpoint the current state of the WAL and flush it to the main storage. This should be called BEFORE any
-	//! connection is available because right now the checkpointing cannot be done online. (TODO)
-	void CreateCheckpoint();
-
-	MetadataWriter &GetMetadataWriter() override;
-	MetadataManager &GetMetadataManager() override;
-	unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) override;
-
-	BlockManager &GetBlockManager();
-	CheckpointType GetCheckpointType() const {
-		return checkpoint_type;
-	}
-
-public:
-	void WriteTable(TableCatalogEntry &table, Serializer &serializer) override;
-
-private:
-	//! The metadata writer is responsible for writing schema information
-	unique_ptr<MetadataWriter> metadata_writer;
-	//! The table data writer is responsible for writing the DataPointers used by the table chunks
-	unique_ptr<MetadataWriter> table_metadata_writer;
-	//! Because this is single-file storage, we can share partial blocks across
-	//! an entire checkpoint.
-	PartialBlockManager partial_block_manager;
-	//! Checkpoint type
-	CheckpointType checkpoint_type;
-	//! Block usage count for verification purposes
-	unordered_map<block_id_t, idx_t> verify_block_usage_count;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/algorithm/alp.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/algorithm/alp.hpp
deleted file mode 100644
index f99ed09b0..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/algorithm/alp.hpp
+++ /dev/null
@@ -1,409 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/algorithm/alp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/storage/compression/alp/alp_constants.hpp"
-#include "duckdb/storage/compression/alp/alp_utils.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-namespace alp {
-
-struct AlpEncodingIndices {
-	uint8_t exponent;
-	uint8_t factor;
-
-	AlpEncodingIndices(uint8_t exponent, uint8_t factor) : exponent(exponent), factor(factor) {
-	}
-
-	AlpEncodingIndices() : exponent(0), factor(0) {
-	}
-};
-
-struct AlpEncodingIndicesEquality {
-	bool operator()(const AlpEncodingIndices &a, const AlpEncodingIndices &b) const {
-		return a.exponent == b.exponent && a.factor == b.factor;
-	}
-};
-
-struct AlpEncodingIndicesHash {
-	hash_t operator()(const AlpEncodingIndices &encoding_indices) const {
-		hash_t h1 = Hash<uint8_t>(encoding_indices.exponent);
-		hash_t h2 = Hash<uint8_t>(encoding_indices.factor);
-		return CombineHash(h1, h2);
-	}
-};
-
-struct AlpCombination {
-	AlpEncodingIndices encoding_indices;
-	uint64_t n_appearances;
-	uint64_t estimated_compression_size;
-
-	AlpCombination(AlpEncodingIndices encoding_indices, uint64_t n_appearances, uint64_t estimated_compression_size)
-	    : encoding_indices(encoding_indices), n_appearances(n_appearances),
-	      estimated_compression_size(estimated_compression_size) {
-	}
-};
-
-template <class T, bool EMPTY>
-class AlpCompressionState {
-public:
-	AlpCompressionState() : vector_encoding_indices(0, 0), exceptions_count(0), bit_width(0) {
-	}
-
-	void Reset() {
-		vector_encoding_indices = {0, 0};
-		exceptions_count = 0;
-		bit_width = 0;
-	}
-
-	void ResetCombinations() {
-		best_k_combinations.clear();
-	}
-
-public:
-	AlpEncodingIndices vector_encoding_indices;
-	uint16_t exceptions_count;
-	uint16_t bit_width;
-	uint64_t bp_size;
-	uint64_t frame_of_reference;
-	int64_t encoded_integers[AlpConstants::ALP_VECTOR_SIZE];
-	T exceptions[AlpConstants::ALP_VECTOR_SIZE];
-	uint16_t exceptions_positions[AlpConstants::ALP_VECTOR_SIZE];
-	vector<AlpCombination> best_k_combinations;
-	uint8_t values_encoded[AlpConstants::ALP_VECTOR_SIZE * 8];
-};
-
-template <class T, bool EMPTY>
-struct AlpCompression {
-	using State = AlpCompressionState<T, EMPTY>;
-	static constexpr uint8_t EXACT_TYPE_BITSIZE = sizeof(T) * 8;
-
-	/*
-	 * Check for special values which are impossible for ALP to encode
-	 * because they cannot be cast to int64 without an undefined behaviour
-	 */
-	static bool IsImpossibleToEncode(T n) {
-		return !Value::IsFinite(n) || Value::IsNan(n) || n > AlpConstants::ENCODING_UPPER_LIMIT ||
-		       n < AlpConstants::ENCODING_LOWER_LIMIT || (n == 0.0 && std::signbit(n)); //! Verification for -0.0
-	}
-
-	/*
-	 * Conversion from a Floating-Point number to Int64 without rounding
-	 */
-	static int64_t NumberToInt64(T n) {
-		if (IsImpossibleToEncode(n)) {
-			return ExactNumericCast<int64_t>(AlpConstants::ENCODING_UPPER_LIMIT);
-		}
-		n = n + AlpTypedConstants<T>::MAGIC_NUMBER - AlpTypedConstants<T>::MAGIC_NUMBER;
-		return LossyNumericCast<int64_t>(n);
-	}
-
-	/*
-	 * Encoding a single value with ALP
-	 */
-	static int64_t EncodeValue(T value, AlpEncodingIndices encoding_indices) {
-		T tmp_encoded_value = value * AlpTypedConstants<T>::EXP_ARR[encoding_indices.exponent] *
-		                      AlpTypedConstants<T>::FRAC_ARR[encoding_indices.factor];
-		int64_t encoded_value = NumberToInt64(tmp_encoded_value);
-		return encoded_value;
-	}
-
-	/*
-	 * Decoding a single value with ALP
-	 */
-	static T DecodeValue(int64_t encoded_value, AlpEncodingIndices encoding_indices) {
-		//! The cast to T is needed to prevent a signed integer overflow
-		T decoded_value = static_cast<T>(encoded_value) * AlpConstants::FACT_ARR[encoding_indices.factor] *
-		                  AlpTypedConstants<T>::FRAC_ARR[encoding_indices.exponent];
-		return decoded_value;
-	}
-
-	/*
-	 * Return TRUE if c1 is a better combination than c2
-	 * First criteria is number of times it appears as best combination
-	 * Second criteria is the estimated compression size
-	 * Third criteria is bigger exponent
-	 * Fourth criteria is bigger factor
-	 */
-	static bool CompareALPCombinations(const AlpCombination &c1, const AlpCombination &c2) {
-		return (c1.n_appearances > c2.n_appearances) ||
-		       (c1.n_appearances == c2.n_appearances &&
-		        (c1.estimated_compression_size < c2.estimated_compression_size)) ||
-		       ((c1.n_appearances == c2.n_appearances &&
-		         c1.estimated_compression_size == c2.estimated_compression_size) &&
-		        (c2.encoding_indices.exponent < c1.encoding_indices.exponent)) ||
-		       ((c1.n_appearances == c2.n_appearances &&
-		         c1.estimated_compression_size == c2.estimated_compression_size &&
-		         c2.encoding_indices.exponent == c1.encoding_indices.exponent) &&
-		        (c2.encoding_indices.factor < c1.encoding_indices.factor));
-	}
-
-	/*
-	 * Dry compress a vector (ideally a sample) to estimate ALP compression size given a exponent and factor
-	 */
-	template <bool PENALIZE_EXCEPTIONS>
-	static uint64_t DryCompressToEstimateSize(const vector<T> &input_vector, AlpEncodingIndices encoding_indices) {
-		idx_t n_values = input_vector.size();
-		idx_t exceptions_count = 0;
-		idx_t non_exceptions_count = 0;
-		uint32_t estimated_bits_per_value = 0;
-		uint64_t estimated_compression_size = 0;
-		int64_t max_encoded_value = NumericLimits<int64_t>::Minimum();
-		int64_t min_encoded_value = NumericLimits<int64_t>::Maximum();
-
-		for (const T &value : input_vector) {
-			int64_t encoded_value = EncodeValue(value, encoding_indices);
-			T decoded_value = DecodeValue(encoded_value, encoding_indices);
-			if (decoded_value == value) {
-				non_exceptions_count++;
-				max_encoded_value = MaxValue(encoded_value, max_encoded_value);
-				min_encoded_value = MinValue(encoded_value, min_encoded_value);
-				continue;
-			}
-			exceptions_count++;
-		}
-
-		// We penalize combinations which yields to almost all exceptions
-		if (PENALIZE_EXCEPTIONS && non_exceptions_count < 2) {
-			return NumericLimits<uint64_t>::Maximum();
-		}
-
-		// Evaluate factor/exponent compression size (we optimize for FOR)
-		uint64_t delta = (static_cast<uint64_t>(max_encoded_value) - static_cast<uint64_t>(min_encoded_value));
-		estimated_bits_per_value = ExactNumericCast<uint32_t>(std::ceil(std::log2(delta + 1)));
-		estimated_compression_size += n_values * estimated_bits_per_value;
-		estimated_compression_size +=
-		    exceptions_count * (EXACT_TYPE_BITSIZE + (AlpConstants::EXCEPTION_POSITION_SIZE * 8));
-		return estimated_compression_size;
-	}
-
-	/*
-	 * Find the best combinations of factor-exponent from each vector sampled from a rowgroup
-	 * This function is called once per segment
-	 * This operates over ALP first level samples
-	 */
-	static void FindTopKCombinations(const vector<vector<T>> &vectors_sampled, State &state) {
-		state.ResetCombinations();
-
-		unordered_map<AlpEncodingIndices, uint64_t, AlpEncodingIndicesHash, AlpEncodingIndicesEquality>
-		    best_k_combinations_hash;
-		// For each vector sampled
-		for (auto &sampled_vector : vectors_sampled) {
-			idx_t n_samples = sampled_vector.size();
-			AlpEncodingIndices best_encoding_indices = {AlpTypedConstants<T>::MAX_EXPONENT,
-			                                            AlpTypedConstants<T>::MAX_EXPONENT};
-
-			//! We start our optimization with the worst possible total bits obtained from compression
-			idx_t best_total_bits = (n_samples * (EXACT_TYPE_BITSIZE + AlpConstants::EXCEPTION_POSITION_SIZE * 8)) +
-			                        (n_samples * EXACT_TYPE_BITSIZE);
-
-			// N of appearances is irrelevant at this phase; we search for the best compression for the vector
-			AlpCombination best_combination = {best_encoding_indices, 0, best_total_bits};
-			//! We try all combinations in search for the one which minimize the compression size
-			for (int8_t exp_idx = AlpTypedConstants<T>::MAX_EXPONENT; exp_idx >= 0; exp_idx--) {
-				for (int8_t factor_idx = exp_idx; factor_idx >= 0; factor_idx--) {
-					AlpEncodingIndices current_encoding_indices = {(uint8_t)exp_idx, (uint8_t)factor_idx};
-					uint64_t estimated_compression_size =
-					    DryCompressToEstimateSize<true>(sampled_vector, current_encoding_indices);
-					AlpCombination current_combination = {current_encoding_indices, 0, estimated_compression_size};
-					if (CompareALPCombinations(current_combination, best_combination)) {
-						best_combination = current_combination;
-					}
-				}
-			}
-			best_k_combinations_hash[best_combination.encoding_indices]++;
-		}
-
-		// Convert our hash to a Combination vector to be able to sort
-		// Note that this vector is always small (< 10 combinations)
-		vector<AlpCombination> best_k_combinations;
-		for (auto const &combination : best_k_combinations_hash) {
-			best_k_combinations.emplace_back(
-			    combination.first,  // Encoding Indices
-			    combination.second, // N of times it appeared (hash value)
-			    0 // Compression size is irrelevant at this phase since we compare combinations from different vectors
-			);
-		}
-		sort(best_k_combinations.begin(), best_k_combinations.end(), CompareALPCombinations);
-
-		// Save k' best combinations
-		for (idx_t i = 0; i < MinValue(AlpConstants::MAX_COMBINATIONS, (uint8_t)best_k_combinations.size()); i++) {
-			state.best_k_combinations.push_back(best_k_combinations[i]);
-		}
-	}
-
-	/*
-	 * Find the best combination of factor-exponent for a vector from within the best k combinations
-	 * This is ALP second level sampling
-	 */
-	static void FindBestFactorAndExponent(const T *input_vector, idx_t n_values, State &state) {
-		//! We sample equidistant values within a vector; to do this we skip a fixed number of values
-		vector<T> vector_sample;
-		auto idx_increments = MaxValue<uint32_t>(
-		    1, ExactNumericCast<uint32_t>(std::ceil((double)n_values / AlpConstants::SAMPLES_PER_VECTOR)));
-		for (idx_t i = 0; i < n_values; i += idx_increments) {
-			vector_sample.push_back(input_vector[i]);
-		}
-
-		AlpEncodingIndices best_encoding_indices = {0, 0};
-		uint64_t best_total_bits = NumericLimits<uint64_t>::Maximum();
-		idx_t worse_total_bits_counter = 0;
-
-		//! We try each K combination in search for the one which minimize the compression size in the vector
-		for (auto &combination : state.best_k_combinations) {
-			uint64_t estimated_compression_size =
-			    DryCompressToEstimateSize<false>(vector_sample, combination.encoding_indices);
-
-			// If current compression size is worse (higher) or equal than the current best combination
-			if (estimated_compression_size >= best_total_bits) {
-				worse_total_bits_counter += 1;
-				// Early exit strategy
-				if (worse_total_bits_counter == AlpConstants::SAMPLING_EARLY_EXIT_THRESHOLD) {
-					break;
-				}
-				continue;
-			}
-			// Otherwise we replace the best and continue trying with the next combination
-			best_total_bits = estimated_compression_size;
-			best_encoding_indices = combination.encoding_indices;
-			worse_total_bits_counter = 0;
-		}
-		state.vector_encoding_indices = best_encoding_indices;
-	}
-
-	/*
-	 * ALP Compress
-	 */
-	static void Compress(const T *input_vector, idx_t n_values, const uint16_t *vector_null_positions,
-	                     idx_t nulls_count, State &state) {
-		if (state.best_k_combinations.size() > 1) {
-			FindBestFactorAndExponent(input_vector, n_values, state);
-		} else {
-			state.vector_encoding_indices = state.best_k_combinations[0].encoding_indices;
-		}
-
-		// Encoding Floating-Point to Int64
-		//! We encode all the values regardless of their correctness to recover the original floating-point
-		uint16_t exceptions_idx = 0;
-		for (idx_t i = 0; i < n_values; i++) {
-			T actual_value = input_vector[i];
-			int64_t encoded_value = EncodeValue(actual_value, state.vector_encoding_indices);
-			T decoded_value = DecodeValue(encoded_value, state.vector_encoding_indices);
-			state.encoded_integers[i] = encoded_value;
-			//! We detect exceptions using a predicated comparison
-			auto is_exception = (decoded_value != actual_value);
-			state.exceptions_positions[exceptions_idx] = UnsafeNumericCast<uint16_t>(i);
-			exceptions_idx += is_exception;
-		}
-
-		// Finding first non exception value
-		int64_t a_non_exception_value = 0;
-		for (idx_t i = 0; i < n_values; i++) {
-			if (i != state.exceptions_positions[i]) {
-				a_non_exception_value = state.encoded_integers[i];
-				break;
-			}
-		}
-		// Replacing that first non exception value on the vector exceptions
-		for (idx_t i = 0; i < exceptions_idx; i++) {
-			idx_t exception_pos = state.exceptions_positions[i];
-			T actual_value = input_vector[exception_pos];
-			state.encoded_integers[exception_pos] = a_non_exception_value;
-			state.exceptions[i] = actual_value;
-		}
-		state.exceptions_count = exceptions_idx;
-
-		// Replacing nulls with that first non exception value
-		for (idx_t i = 0; i < nulls_count; i++) {
-			uint16_t null_value_pos = vector_null_positions[i];
-			state.encoded_integers[null_value_pos] = a_non_exception_value;
-		}
-
-		// Analyze FFOR
-		auto min_value = NumericLimits<int64_t>::Maximum();
-		auto max_value = NumericLimits<int64_t>::Minimum();
-		for (idx_t i = 0; i < n_values; i++) {
-			max_value = MaxValue(max_value, state.encoded_integers[i]);
-			min_value = MinValue(min_value, state.encoded_integers[i]);
-		}
-		uint64_t min_max_diff = (static_cast<uint64_t>(max_value) - static_cast<uint64_t>(min_value));
-
-		auto *u_encoded_integers = reinterpret_cast<uint64_t *>(state.encoded_integers);
-		auto const u_min_value = static_cast<uint64_t>(min_value);
-
-		// Subtract FOR
-		if (!EMPTY) { //! We only execute the FOR if we are writing the data
-			for (idx_t i = 0; i < n_values; i++) {
-				u_encoded_integers[i] -= u_min_value;
-			}
-		}
-
-		auto bit_width = BitpackingPrimitives::MinimumBitWidth<uint64_t, false>(min_max_diff);
-		auto bp_size = BitpackingPrimitives::GetRequiredSize(n_values, bit_width);
-		if (!EMPTY && bit_width > 0) { //! We only execute the BP if we are writing the data
-			BitpackingPrimitives::PackBuffer<uint64_t, false>(state.values_encoded, u_encoded_integers, n_values,
-			                                                  bit_width);
-		}
-		state.bit_width = bit_width;                                 // in bits
-		state.bp_size = bp_size;                                     // in bytes
-		state.frame_of_reference = static_cast<uint64_t>(min_value); // understood this can be negative
-	}
-
-	/*
-	 * Overload without specifying nulls
-	 */
-	static void Compress(const T *input_vector, idx_t n_values, State &state) {
-		Compress(input_vector, n_values, nullptr, 0, state);
-	}
-};
-
-template <class T>
-struct AlpDecompression {
-	static void Decompress(uint8_t *for_encoded, T *output, idx_t count, uint8_t vector_factor, uint8_t vector_exponent,
-	                       uint16_t exceptions_count, T *exceptions, const uint16_t *exceptions_positions,
-	                       uint64_t frame_of_reference, uint8_t bit_width) {
-		AlpEncodingIndices encoding_indices = {vector_exponent, vector_factor};
-
-		// Bit Unpacking
-		uint8_t for_decoded[AlpConstants::ALP_VECTOR_SIZE * 8] = {0};
-		if (bit_width > 0) {
-			BitpackingPrimitives::UnPackBuffer<uint64_t>(for_decoded, for_encoded, count, bit_width);
-		}
-		auto *encoded_integers = reinterpret_cast<uint64_t *>(data_ptr_cast(for_decoded));
-
-		// unFOR
-		for (idx_t i = 0; i < count; i++) {
-			encoded_integers[i] += frame_of_reference;
-		}
-
-		// Decoding
-		for (idx_t i = 0; i < count; i++) {
-			auto encoded_integer = static_cast<int64_t>(encoded_integers[i]);
-			output[i] = alp::AlpCompression<T, true>::DecodeValue(encoded_integer, encoding_indices);
-		}
-
-		// Exceptions Patching
-		for (idx_t i = 0; i < exceptions_count; i++) {
-			output[exceptions_positions[i]] = static_cast<T>(exceptions[i]);
-		}
-	}
-};
-
-} // namespace alp
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_analyze.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_analyze.hpp
deleted file mode 100644
index 62858d4f7..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_analyze.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_analyze.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/alp/algorithm/alp.hpp"
-#include "duckdb/storage/compression/alp/alp_constants.hpp"
-#include "duckdb/storage/compression/alp/alp_utils.hpp"
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-template <class T>
-struct AlpAnalyzeState : public AnalyzeState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	explicit AlpAnalyzeState(const CompressionInfo &info) : AnalyzeState(info), state() {
-	}
-
-	idx_t total_bytes_used = 0;
-	idx_t current_bytes_used_in_segment = 0;
-	idx_t vectors_sampled_count = 0;
-	idx_t total_values_count = 0;
-	idx_t vectors_count = 0;
-	vector<vector<T>> rowgroup_sample;
-	vector<vector<T>> complete_vectors_sampled;
-	alp::AlpCompressionState<T, true> state;
-
-public:
-	// Returns the required space to hyphotetically store the compressed segment
-	void FlushSegment() {
-		// We add the size of the segment header (the pointer to the metadata)
-		total_bytes_used += current_bytes_used_in_segment + AlpConstants::METADATA_POINTER_SIZE;
-		current_bytes_used_in_segment = 0;
-	}
-
-	// Returns the required space to hyphotetically store the compressed vector
-	idx_t RequiredSpace() const {
-		idx_t required_space =
-		    state.bp_size + state.exceptions_count * (sizeof(EXACT_TYPE) + AlpConstants::EXCEPTION_POSITION_SIZE) +
-		    AlpConstants::EXPONENT_SIZE + AlpConstants::FACTOR_SIZE + AlpConstants::EXCEPTIONS_COUNT_SIZE +
-		    AlpConstants::FOR_SIZE + AlpConstants::BIT_WIDTH_SIZE + AlpConstants::METADATA_POINTER_SIZE;
-		return required_space;
-	}
-
-	void FlushVector() {
-		current_bytes_used_in_segment += RequiredSpace();
-		state.Reset();
-	}
-
-	// Check if we have enough space in the segment to hyphotetically store the compressed vector
-	bool HasEnoughSpace() {
-		idx_t bytes_to_be_used = AlignValue(current_bytes_used_in_segment + RequiredSpace());
-		// We have enough space if the already used space + the required space for a new vector
-		// does not exceed the space of the block - the segment header (the pointer to the metadata)
-		return bytes_to_be_used <= (info.GetBlockSize() - AlpConstants::METADATA_POINTER_SIZE);
-	}
-
-	idx_t TotalUsedBytes() const {
-		return AlignValue(total_bytes_used);
-	}
-};
-
-template <class T>
-unique_ptr<AnalyzeState> AlpInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<AlpAnalyzeState<T>>(info);
-}
-
-/*
- * ALP Analyze step only pushes the needed samples to estimate the compression size in the finalize step
- */
-template <class T>
-bool AlpAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = (AlpAnalyzeState<T> &)state;
-	bool must_skip_current_vector = alp::AlpUtils::MustSkipSamplingFromCurrentVector(
-	    analyze_state.vectors_count, analyze_state.vectors_sampled_count, count);
-	analyze_state.vectors_count += 1;
-	analyze_state.total_values_count += count;
-	if (must_skip_current_vector) {
-		return true;
-	}
-
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-	auto data = UnifiedVectorFormat::GetData<T>(vdata);
-
-	alp::AlpSamplingParameters sampling_params = alp::AlpUtils::GetSamplingParameters(count);
-
-	vector<uint16_t> current_vector_null_positions(sampling_params.n_lookup_values, 0);
-	vector<T> current_vector_values(sampling_params.n_lookup_values, 0);
-	vector<T> current_vector_sample(sampling_params.n_sampled_values, 0);
-
-	// Storing the entire sampled vector
-	//! We need to store the entire sampled vector to perform the 'analyze' compression in it
-	idx_t nulls_idx = 0;
-	// We optimize by doing a different loop when there are no nulls
-	if (vdata.validity.AllValid()) {
-		for (idx_t i = 0; i < sampling_params.n_lookup_values; i++) {
-			auto idx = vdata.sel->get_index(i);
-			T value = data[idx];
-			current_vector_values[i] = value;
-		}
-	} else {
-		for (idx_t i = 0; i < sampling_params.n_lookup_values; i++) {
-			auto idx = vdata.sel->get_index(i);
-			T value = data[idx];
-			//! We resolve null values with a predicated comparison
-			bool is_null = !vdata.validity.RowIsValid(idx);
-			current_vector_null_positions[nulls_idx] = UnsafeNumericCast<uint16_t>(i);
-			nulls_idx += is_null;
-			current_vector_values[i] = value;
-		}
-		alp::AlpUtils::FindAndReplaceNullsInVector<T>(current_vector_values.data(),
-		                                              current_vector_null_positions.data(),
-		                                              sampling_params.n_lookup_values, nulls_idx);
-	}
-
-	// Storing the sample of that vector
-	idx_t sample_idx = 0;
-	for (idx_t i = 0; i < sampling_params.n_lookup_values; i += sampling_params.n_sampled_increments) {
-		current_vector_sample[sample_idx] = current_vector_values[i];
-		sample_idx++;
-	}
-	D_ASSERT(sample_idx == sampling_params.n_sampled_values);
-
-	//! A std::move is needed to avoid a copy of the pushed vector
-	analyze_state.complete_vectors_sampled.push_back(std::move(current_vector_values));
-	analyze_state.rowgroup_sample.push_back(std::move(current_vector_sample));
-	analyze_state.vectors_sampled_count++;
-	return true;
-}
-
-/*
- * Estimate the compression size of ALP using the taken samples
- */
-template <class T>
-idx_t AlpFinalAnalyze(AnalyzeState &state) {
-	auto &analyze_state = (AlpAnalyzeState<T> &)state;
-
-	// Finding the Top K combinations of Exponent and Factor
-	alp::AlpCompression<T, true>::FindTopKCombinations(analyze_state.rowgroup_sample, analyze_state.state);
-
-	// Encode the entire sampled vectors to estimate a compression size
-	idx_t compressed_values = 0;
-	for (auto &vector_to_compress : analyze_state.complete_vectors_sampled) {
-		alp::AlpCompression<T, true>::Compress(vector_to_compress.data(), vector_to_compress.size(),
-		                                       analyze_state.state);
-		if (!analyze_state.HasEnoughSpace()) {
-			analyze_state.FlushSegment();
-		}
-		analyze_state.FlushVector();
-		compressed_values += vector_to_compress.size();
-	}
-
-	// Flush last unfinished segment
-	analyze_state.FlushSegment();
-
-	if (compressed_values == 0) {
-		return DConstants::INVALID_INDEX;
-	}
-
-	// We estimate the size by taking into account the portion of the values we took
-	const auto factor_of_sampling = analyze_state.total_values_count / compressed_values;
-	const auto final_analyze_size = analyze_state.TotalUsedBytes() * factor_of_sampling;
-	return final_analyze_size; // return size of data in bytes
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp
deleted file mode 100644
index 5ba58dcf6..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp
+++ /dev/null
@@ -1,284 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_compress.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/compression/alp/algorithm/alp.hpp"
-#include "duckdb/storage/compression/alp/alp_analyze.hpp"
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-template <class T>
-struct AlpCompressionState : public CompressionState {
-
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	AlpCompressionState(ColumnDataCheckpointData &checkpoint_data, AlpAnalyzeState<T> *analyze_state)
-	    : CompressionState(analyze_state->info), checkpoint_data(checkpoint_data),
-	      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ALP)) {
-		CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-
-		//! Combinations found on the analyze step are needed for compression
-		state.best_k_combinations = analyze_state->state.best_k_combinations;
-	}
-
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	idx_t vector_idx = 0;
-	idx_t nulls_idx = 0;
-	idx_t vectors_flushed = 0;
-	idx_t data_bytes_used = 0;
-
-	data_ptr_t data_ptr;     // Pointer to next free spot in segment;
-	data_ptr_t metadata_ptr; // Reverse pointer to the next free spot for the metadata; used in decoding to SKIP vectors
-	uint32_t next_vector_byte_index_start = AlpConstants::HEADER_SIZE;
-
-	T input_vector[AlpConstants::ALP_VECTOR_SIZE];
-	uint16_t vector_null_positions[AlpConstants::ALP_VECTOR_SIZE];
-
-	alp::AlpCompressionState<T, false> state;
-
-public:
-	// Returns the space currently used in the segment (in bytes)
-	idx_t UsedSpace() const {
-		return AlpConstants::METADATA_POINTER_SIZE + data_bytes_used;
-	}
-
-	// Returns the required space to store the newly compressed vector
-	idx_t RequiredSpace() {
-		idx_t required_space =
-		    state.bp_size + (state.exceptions_count * (sizeof(EXACT_TYPE) + AlpConstants::EXCEPTION_POSITION_SIZE)) +
-		    AlpConstants::EXPONENT_SIZE + AlpConstants::FACTOR_SIZE + AlpConstants::EXCEPTIONS_COUNT_SIZE +
-		    AlpConstants::FOR_SIZE + AlpConstants::BIT_WIDTH_SIZE;
-		return required_space;
-	}
-
-	bool HasEnoughSpace() {
-		//! If [start of block + used space + required space] is more than whats left (current position
-		//! of metadata pointer - the size of a new metadata pointer)
-		if ((handle.Ptr() + AlignValue(UsedSpace() + RequiredSpace())) >=
-		    (metadata_ptr - AlpConstants::METADATA_POINTER_SIZE)) {
-			return false;
-		}
-		return true;
-	}
-
-	void ResetVector() {
-		state.Reset();
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start,
-		                                                                info.GetBlockSize(), info.GetBlockSize());
-		current_segment = std::move(compressed_segment);
-
-		auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db);
-		handle = buffer_manager.Pin(current_segment->block);
-
-		// The pointer to the start of the compressed data.
-		data_ptr = handle.Ptr() + current_segment->GetBlockOffset() + AlpConstants::HEADER_SIZE;
-		// The pointer to the start of the metadata.
-		metadata_ptr = handle.Ptr() + current_segment->GetBlockOffset() + info.GetBlockSize();
-		next_vector_byte_index_start = AlpConstants::HEADER_SIZE;
-	}
-
-	void CompressVector() {
-		if (nulls_idx) {
-			alp::AlpUtils::FindAndReplaceNullsInVector<T>(input_vector, vector_null_positions, vector_idx, nulls_idx);
-		}
-		alp::AlpCompression<T, false>::Compress(input_vector, vector_idx, vector_null_positions, nulls_idx, state);
-		//! Check if the compressed vector fits on current segment
-		if (!HasEnoughSpace()) {
-			auto row_start = current_segment->start + current_segment->count;
-			FlushSegment();
-			CreateEmptySegment(row_start);
-		}
-
-		if (vector_idx != nulls_idx) { //! At least there is one valid value in the vector
-			for (idx_t i = 0; i < vector_idx; i++) {
-				current_segment->stats.statistics.UpdateNumericStats<T>(input_vector[i]);
-			}
-		}
-		current_segment->count += vector_idx;
-		FlushVector();
-	}
-
-	// Stores the vector and its metadata
-	void FlushVector() {
-		Store<uint8_t>(state.vector_encoding_indices.exponent, data_ptr);
-		data_ptr += AlpConstants::EXPONENT_SIZE;
-
-		Store<uint8_t>(state.vector_encoding_indices.factor, data_ptr);
-		data_ptr += AlpConstants::FACTOR_SIZE;
-
-		Store<uint16_t>(state.exceptions_count, data_ptr);
-		data_ptr += AlpConstants::EXCEPTIONS_COUNT_SIZE;
-
-		Store<uint64_t>(state.frame_of_reference, data_ptr);
-		data_ptr += AlpConstants::FOR_SIZE;
-
-		Store<uint8_t>(UnsafeNumericCast<uint8_t>(state.bit_width), data_ptr);
-		data_ptr += AlpConstants::BIT_WIDTH_SIZE;
-
-		memcpy((void *)data_ptr, (void *)state.values_encoded, state.bp_size);
-		// We should never go out of bounds in the values_encoded array
-		D_ASSERT((AlpConstants::ALP_VECTOR_SIZE * 8) >= state.bp_size);
-
-		data_ptr += state.bp_size;
-
-		if (state.exceptions_count > 0) {
-			memcpy((void *)data_ptr, (void *)state.exceptions, sizeof(EXACT_TYPE) * state.exceptions_count);
-			data_ptr += sizeof(EXACT_TYPE) * state.exceptions_count;
-			memcpy((void *)data_ptr, (void *)state.exceptions_positions,
-			       AlpConstants::EXCEPTION_POSITION_SIZE * state.exceptions_count);
-			data_ptr += AlpConstants::EXCEPTION_POSITION_SIZE * state.exceptions_count;
-		}
-
-		data_bytes_used += state.bp_size +
-		                   (state.exceptions_count * (sizeof(EXACT_TYPE) + AlpConstants::EXCEPTION_POSITION_SIZE)) +
-		                   AlpConstants::EXPONENT_SIZE + AlpConstants::FACTOR_SIZE +
-		                   AlpConstants::EXCEPTIONS_COUNT_SIZE + AlpConstants::FOR_SIZE + AlpConstants::BIT_WIDTH_SIZE;
-
-		// Write pointer to the vector data (metadata)
-		metadata_ptr -= sizeof(uint32_t);
-		Store<uint32_t>(next_vector_byte_index_start, metadata_ptr);
-		next_vector_byte_index_start = NumericCast<uint32_t>(UsedSpace());
-
-		vectors_flushed++;
-		vector_idx = 0;
-		nulls_idx = 0;
-		ResetVector();
-	}
-
-	void FlushSegment() {
-		auto &checkpoint_state = checkpoint_data.GetCheckpointState();
-		auto dataptr = handle.Ptr();
-
-		idx_t metadata_offset = AlignValue(UsedSpace());
-
-		// Verify that the metadata_ptr is not smaller than the space used by the data
-		D_ASSERT(dataptr + metadata_offset <= metadata_ptr);
-
-		auto bytes_used_by_metadata = UnsafeNumericCast<idx_t>(dataptr + info.GetBlockSize() - metadata_ptr);
-
-		// Initially the total segment size is the size of the block
-		auto total_segment_size = info.GetBlockSize();
-
-		//! We compact the block if the space used is less than a threshold
-		const auto used_space_percentage =
-		    static_cast<float>(metadata_offset + bytes_used_by_metadata) / static_cast<float>(total_segment_size);
-		if (used_space_percentage < AlpConstants::COMPACT_BLOCK_THRESHOLD) {
-#ifdef DEBUG
-			//! Copy the first 4 bytes of the metadata
-			uint32_t verify_bytes;
-			memcpy((void *)&verify_bytes, metadata_ptr, 4);
-#endif
-			memmove(dataptr + metadata_offset, metadata_ptr, bytes_used_by_metadata);
-#ifdef DEBUG
-			//! Now assert that the memmove was correct
-			D_ASSERT(verify_bytes == *(uint32_t *)(dataptr + metadata_offset));
-#endif
-			total_segment_size = metadata_offset + bytes_used_by_metadata;
-		}
-
-		// Store the offset to the end of metadata (to be used as a backwards pointer in decoding)
-		Store<uint32_t>(NumericCast<uint32_t>(total_segment_size), dataptr);
-
-		checkpoint_state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size);
-		data_bytes_used = 0;
-		vectors_flushed = 0;
-	}
-
-	void Finalize() {
-		if (vector_idx != 0) {
-			CompressVector();
-			D_ASSERT(vector_idx == 0);
-		}
-		FlushSegment();
-		current_segment.reset();
-	}
-
-	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = UnifiedVectorFormat::GetData<T>(vdata);
-		idx_t values_left_in_data = count;
-		idx_t offset_in_data = 0;
-		while (values_left_in_data > 0) {
-			// We calculate until which value in data we must go to fill the input_vector
-			// to avoid checking if input_vector is filled in each iteration
-			auto values_to_fill_alp_input =
-			    MinValue<idx_t>(AlpConstants::ALP_VECTOR_SIZE - vector_idx, values_left_in_data);
-			if (vdata.validity.AllValid()) { //! We optimize a loop when there are no null
-				for (idx_t i = 0; i < values_to_fill_alp_input; i++) {
-					auto idx = vdata.sel->get_index(offset_in_data + i);
-					T value = data[idx];
-					input_vector[vector_idx + i] = value;
-				}
-			} else {
-				for (idx_t i = 0; i < values_to_fill_alp_input; i++) {
-					auto idx = vdata.sel->get_index(offset_in_data + i);
-					T value = data[idx];
-					bool is_null = !vdata.validity.RowIsValid(idx);
-					//! We resolve null values with a predicated comparison
-					vector_null_positions[nulls_idx] = UnsafeNumericCast<uint16_t>(vector_idx + i);
-					nulls_idx += is_null;
-					input_vector[vector_idx + i] = value;
-				}
-			}
-			offset_in_data += values_to_fill_alp_input;
-			values_left_in_data -= values_to_fill_alp_input;
-			vector_idx += values_to_fill_alp_input;
-			// We still need this check since we could have an incomplete input_vector at the end of data
-			if (vector_idx == AlpConstants::ALP_VECTOR_SIZE) {
-				CompressVector();
-				D_ASSERT(vector_idx == 0);
-			}
-		}
-	}
-};
-
-template <class T>
-unique_ptr<CompressionState> AlpInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                unique_ptr<AnalyzeState> state) {
-	return make_uniq<AlpCompressionState<T>>(checkpoint_data, (AlpAnalyzeState<T> *)state.get());
-}
-
-template <class T>
-void AlpCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (AlpCompressionState<T> &)state_p;
-	UnifiedVectorFormat vdata;
-	scan_vector.ToUnifiedFormat(count, vdata);
-	state.Append(vdata, count);
-}
-
-template <class T>
-void AlpFinalizeCompress(CompressionState &state_p) {
-	auto &state = (AlpCompressionState<T> &)state_p;
-	state.Finalize();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_constants.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_constants.hpp
deleted file mode 100644
index cf9766177..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_constants.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_constants.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-class AlpConstants {
-public:
-	static constexpr uint32_t ALP_VECTOR_SIZE = 1024;
-	static constexpr uint32_t RG_SAMPLES = 8;
-	static constexpr uint16_t SAMPLES_PER_VECTOR = 32;
-	// We calculate how many equidistant vector we must jump within a rowgroup
-	static constexpr uint32_t RG_SAMPLES_DUCKDB_JUMP = (DEFAULT_ROW_GROUP_SIZE / RG_SAMPLES) / STANDARD_VECTOR_SIZE;
-
-	static constexpr uint8_t HEADER_SIZE = sizeof(uint32_t);
-	static constexpr uint8_t EXPONENT_SIZE = sizeof(uint8_t);
-	static constexpr uint8_t FACTOR_SIZE = sizeof(uint8_t);
-	static constexpr uint8_t EXCEPTIONS_COUNT_SIZE = sizeof(uint16_t);
-	static constexpr uint8_t EXCEPTION_POSITION_SIZE = sizeof(uint16_t);
-	static constexpr uint8_t FOR_SIZE = sizeof(uint64_t);
-	static constexpr uint8_t BIT_WIDTH_SIZE = sizeof(uint8_t);
-	static constexpr uint8_t METADATA_POINTER_SIZE = sizeof(uint32_t);
-
-	static constexpr uint8_t SAMPLING_EARLY_EXIT_THRESHOLD = 2;
-
-	static constexpr double COMPACT_BLOCK_THRESHOLD = 0.80;
-
-	// Largest double which fits into an int64
-	static constexpr double ENCODING_UPPER_LIMIT = 9223372036854774784.0;
-	static constexpr double ENCODING_LOWER_LIMIT = -9223372036854774784.0;
-
-	static constexpr uint8_t MAX_COMBINATIONS = 5;
-
-	static constexpr const int64_t FACT_ARR[] = {1,
-	                                             10,
-	                                             100,
-	                                             1000,
-	                                             10000,
-	                                             100000,
-	                                             1000000,
-	                                             10000000,
-	                                             100000000,
-	                                             1000000000,
-	                                             10000000000,
-	                                             100000000000,
-	                                             1000000000000,
-	                                             10000000000000,
-	                                             100000000000000,
-	                                             1000000000000000,
-	                                             10000000000000000,
-	                                             100000000000000000,
-	                                             1000000000000000000};
-};
-
-template <class T>
-struct AlpTypedConstants {};
-
-template <>
-struct AlpTypedConstants<float> {
-
-	static constexpr float MAGIC_NUMBER = 12582912.0; //! 2^22 + 2^23
-	static constexpr uint8_t MAX_EXPONENT = 10;
-
-	static constexpr const float EXP_ARR[] = {1.0F,         10.0F,         100.0F,        1000.0F,
-	                                          10000.0F,     100000.0F,     1000000.0F,    10000000.0F,
-	                                          100000000.0F, 1000000000.0F, 10000000000.0F};
-
-	static constexpr float FRAC_ARR[] = {1.0F,      0.1F,       0.01F,       0.001F,       0.0001F,      0.00001F,
-	                                     0.000001F, 0.0000001F, 0.00000001F, 0.000000001F, 0.0000000001F};
-};
-
-template <>
-struct AlpTypedConstants<double> {
-
-	static constexpr double MAGIC_NUMBER = 6755399441055744.0; //! 2^51 + 2^52
-	static constexpr uint8_t MAX_EXPONENT = 18;                //! 10^18 is the maximum int64
-
-	static constexpr const double EXP_ARR[] = {1.0,
-	                                           10.0,
-	                                           100.0,
-	                                           1000.0,
-	                                           10000.0,
-	                                           100000.0,
-	                                           1000000.0,
-	                                           10000000.0,
-	                                           100000000.0,
-	                                           1000000000.0,
-	                                           10000000000.0,
-	                                           100000000000.0,
-	                                           1000000000000.0,
-	                                           10000000000000.0,
-	                                           100000000000000.0,
-	                                           1000000000000000.0,
-	                                           10000000000000000.0,
-	                                           100000000000000000.0,
-	                                           1000000000000000000.0,
-	                                           10000000000000000000.0,
-	                                           100000000000000000000.0,
-	                                           1000000000000000000000.0,
-	                                           10000000000000000000000.0,
-	                                           100000000000000000000000.0};
-
-	static constexpr double FRAC_ARR[] = {1.0,
-	                                      0.1,
-	                                      0.01,
-	                                      0.001,
-	                                      0.0001,
-	                                      0.00001,
-	                                      0.000001,
-	                                      0.0000001,
-	                                      0.00000001,
-	                                      0.000000001,
-	                                      0.0000000001,
-	                                      0.00000000001,
-	                                      0.000000000001,
-	                                      0.0000000000001,
-	                                      0.00000000000001,
-	                                      0.000000000000001,
-	                                      0.0000000000000001,
-	                                      0.00000000000000001,
-	                                      0.000000000000000001,
-	                                      0.0000000000000000001,
-	                                      0.00000000000000000001};
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_fetch.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_fetch.hpp
deleted file mode 100644
index 54a9964d4..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_fetch.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_fetch.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/alp/alp_scan.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-namespace duckdb {
-
-template <class T>
-void AlpFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	AlpScanState<T> scan_state(segment);
-	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
-	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);
-	result_data[result_idx] = (EXACT_TYPE)0;
-
-	if (scan_state.VectorFinished() && scan_state.total_value_count < scan_state.count) {
-		scan_state.LoadVector(scan_state.vector_state.decoded_values);
-	}
-	scan_state.vector_state.Scan((uint8_t *)(result_data + result_idx), 1);
-	scan_state.total_value_count++;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp
deleted file mode 100644
index 28b52b848..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/alp/algorithm/alp.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct AlpVectorState {
-public:
-	void Reset() {
-		index = 0;
-	}
-
-	// Scan of the data itself
-	template <bool SKIP = false>
-	void Scan(uint8_t *dest, idx_t count) {
-		if (!SKIP) {
-			memcpy(dest, (void *)(decoded_values + index), sizeof(T) * count);
-		}
-		index += count;
-	}
-
-	template <bool SKIP>
-	void LoadValues(T *value_buffer, idx_t count) {
-		if (SKIP) {
-			return;
-		}
-		value_buffer[0] = (T)0;
-		alp::AlpDecompression<T>::Decompress(for_encoded, value_buffer, count, v_factor, v_exponent, exceptions_count,
-		                                     exceptions, exceptions_positions, frame_of_reference, bit_width);
-	}
-
-public:
-	idx_t index;
-	T decoded_values[AlpConstants::ALP_VECTOR_SIZE];
-	T exceptions[AlpConstants::ALP_VECTOR_SIZE];
-	uint16_t exceptions_positions[AlpConstants::ALP_VECTOR_SIZE];
-	uint8_t for_encoded[AlpConstants::ALP_VECTOR_SIZE * 8];
-	uint8_t v_exponent;
-	uint8_t v_factor;
-	uint16_t exceptions_count;
-	uint64_t frame_of_reference;
-	uint8_t bit_width;
-};
-
-template <class T>
-struct AlpScanState : public SegmentScanState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	explicit AlpScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		handle = buffer_manager.Pin(segment.block);
-		// ScanStates never exceed the boundaries of a Segment,
-		// but are not guaranteed to start at the beginning of the Block
-		segment_data = handle.Ptr() + segment.GetBlockOffset();
-		auto metadata_offset = Load<uint32_t>(segment_data);
-		metadata_ptr = segment_data + metadata_offset;
-	}
-
-	BufferHandle handle;
-	data_ptr_t metadata_ptr;
-	data_ptr_t segment_data;
-	idx_t total_value_count = 0;
-	AlpVectorState<T> vector_state;
-
-	ColumnSegment &segment;
-	idx_t count;
-
-	idx_t LeftInVector() const {
-		return AlpConstants::ALP_VECTOR_SIZE - (total_value_count % AlpConstants::ALP_VECTOR_SIZE);
-	}
-
-	inline bool VectorFinished() const {
-		return (total_value_count % AlpConstants::ALP_VECTOR_SIZE) == 0;
-	}
-
-	// Scan up to a vector boundary
-	template <class EXACT_TYPE, bool SKIP = false>
-	void ScanVector(T *values, idx_t vector_size) {
-		D_ASSERT(vector_size <= AlpConstants::ALP_VECTOR_SIZE);
-		D_ASSERT(vector_size <= LeftInVector());
-		if (VectorFinished() && total_value_count < count) {
-			if (vector_size == AlpConstants::ALP_VECTOR_SIZE) {
-				LoadVector<SKIP>(values);
-				total_value_count += vector_size;
-				return;
-			} else {
-				// Even if SKIP is given, the vector size is not big enough to be able to fully skip the entire vector
-				LoadVector<false>(vector_state.decoded_values);
-			}
-		}
-		vector_state.template Scan<SKIP>((uint8_t *)values, vector_size);
-
-		total_value_count += vector_size;
-	}
-
-	// Using the metadata, we can avoid loading any of the data if we don't care about the vector at all
-	void SkipVector() {
-		// Skip the offset indicating where the data starts
-		metadata_ptr -= AlpConstants::METADATA_POINTER_SIZE;
-		idx_t vector_size = MinValue((idx_t)AlpConstants::ALP_VECTOR_SIZE, count - total_value_count);
-		total_value_count += vector_size;
-	}
-
-	template <bool SKIP = false>
-	void LoadVector(T *value_buffer) {
-		vector_state.Reset();
-
-		// Load the offset (metadata) indicating where the vector data starts
-		metadata_ptr -= AlpConstants::METADATA_POINTER_SIZE;
-		auto data_byte_offset = Load<uint32_t>(metadata_ptr);
-		D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize());
-
-		idx_t vector_size = MinValue((idx_t)AlpConstants::ALP_VECTOR_SIZE, (count - total_value_count));
-
-		data_ptr_t vector_ptr = segment_data + data_byte_offset;
-
-		// Load the vector data
-		vector_state.v_exponent = Load<uint8_t>(vector_ptr);
-		vector_ptr += AlpConstants::EXPONENT_SIZE;
-
-		vector_state.v_factor = Load<uint8_t>(vector_ptr);
-		vector_ptr += AlpConstants::FACTOR_SIZE;
-
-		vector_state.exceptions_count = Load<uint16_t>(vector_ptr);
-		vector_ptr += AlpConstants::EXCEPTIONS_COUNT_SIZE;
-
-		vector_state.frame_of_reference = Load<uint64_t>(vector_ptr);
-		vector_ptr += AlpConstants::FOR_SIZE;
-
-		vector_state.bit_width = Load<uint8_t>(vector_ptr);
-		vector_ptr += AlpConstants::BIT_WIDTH_SIZE;
-
-		D_ASSERT(vector_state.exceptions_count <= vector_size);
-		D_ASSERT(vector_state.v_exponent <= AlpTypedConstants<T>::MAX_EXPONENT);
-		D_ASSERT(vector_state.v_factor <= vector_state.v_exponent);
-		D_ASSERT(vector_state.bit_width <= sizeof(uint64_t) * 8);
-
-		if (vector_state.bit_width > 0) {
-			auto bp_size = BitpackingPrimitives::GetRequiredSize(vector_size, vector_state.bit_width);
-			memcpy(vector_state.for_encoded, (void *)vector_ptr, bp_size);
-			vector_ptr += bp_size;
-		}
-
-		if (vector_state.exceptions_count > 0) {
-			memcpy(vector_state.exceptions, (void *)vector_ptr, sizeof(EXACT_TYPE) * vector_state.exceptions_count);
-			vector_ptr += sizeof(EXACT_TYPE) * vector_state.exceptions_count;
-			memcpy(vector_state.exceptions_positions, (void *)vector_ptr,
-			       AlpConstants::EXCEPTION_POSITION_SIZE * vector_state.exceptions_count);
-		}
-
-		// Decode all the vector values to the specified 'value_buffer'
-		vector_state.template LoadValues<SKIP>(value_buffer, vector_size);
-	}
-
-public:
-	//! Skip the next 'skip_count' values, we don't store the values
-	void Skip(ColumnSegment &col_segment, idx_t skip_count) {
-		if (total_value_count != 0 && !VectorFinished()) {
-			// Finish skipping the current vector
-			idx_t to_skip = MinValue<idx_t>(skip_count, LeftInVector());
-			ScanVector<T, true>(nullptr, to_skip);
-			skip_count -= to_skip;
-		}
-		// Figure out how many entire vectors we can skip
-		// For these vectors, we don't even need to process the metadata or values
-		idx_t vectors_to_skip = skip_count / AlpConstants::ALP_VECTOR_SIZE;
-		for (idx_t i = 0; i < vectors_to_skip; i++) {
-			SkipVector();
-		}
-		skip_count -= AlpConstants::ALP_VECTOR_SIZE * vectors_to_skip;
-		if (skip_count == 0) {
-			return;
-		}
-		// For the last vector that this skip (partially) touches, we do need to
-		// load the metadata and values into the vector_state because
-		// we don't know exactly how many they are
-		ScanVector<T, true>(nullptr, skip_count);
-	}
-};
-
-template <class T>
-unique_ptr<SegmentScanState> AlpInitScan(ColumnSegment &segment) {
-	auto result = make_uniq_base<SegmentScanState, AlpScanState<T>>(segment);
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void AlpScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                    idx_t result_offset) {
-	auto &scan_state = (AlpScanState<T> &)*state.scan_state;
-
-	// Get the pointer to the result values
-	auto current_result_ptr = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	current_result_ptr += result_offset;
-
-	idx_t scanned = 0;
-	while (scanned < scan_count) {
-		const auto remaining = scan_count - scanned;
-		const idx_t to_scan = MinValue(remaining, scan_state.LeftInVector());
-
-		scan_state.template ScanVector<T>(current_result_ptr + scanned, to_scan);
-		scanned += to_scan;
-	}
-}
-
-template <class T>
-void AlpSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = (AlpScanState<T> &)*state.scan_state;
-	scan_state.Skip(segment, skip_count);
-}
-
-template <class T>
-void AlpScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	AlpScanPartial<T>(segment, state, scan_count, result, 0);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_utils.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_utils.hpp
deleted file mode 100644
index b9c0e6eab..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_utils.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/alp/alp_constants.hpp"
-#include "duckdb/storage/compression/patas/patas.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-namespace alp {
-
-struct AlpSamplingParameters {
-	uint32_t n_lookup_values;
-	uint32_t n_sampled_increments;
-	uint32_t n_sampled_values;
-
-	AlpSamplingParameters(uint32_t n_lookup_values, uint32_t n_sampled_increments, uint32_t n_sampled_values)
-	    : n_lookup_values(n_lookup_values), n_sampled_increments(n_sampled_increments),
-	      n_sampled_values(n_sampled_values) {
-	}
-};
-
-class AlpUtils {
-public:
-	AlpUtils() {
-	}
-
-public:
-	static AlpSamplingParameters GetSamplingParameters(idx_t current_vector_n_values) {
-
-		auto n_lookup_values =
-		    NumericCast<uint32_t>(MinValue(current_vector_n_values, (idx_t)AlpConstants::ALP_VECTOR_SIZE));
-		//! We sample equidistant values within a vector; to do this we jump a fixed number of values
-		uint32_t n_sampled_increments = MaxValue<uint32_t>(
-		    1, ExactNumericCast<uint32_t>(std::ceil((double)n_lookup_values / AlpConstants::SAMPLES_PER_VECTOR)));
-		uint32_t n_sampled_values =
-		    ExactNumericCast<uint32_t>(std::ceil((double)n_lookup_values / n_sampled_increments));
-		D_ASSERT(n_sampled_values < AlpConstants::ALP_VECTOR_SIZE);
-
-		AlpSamplingParameters sampling_params = {n_lookup_values, n_sampled_increments, n_sampled_values};
-		return sampling_params;
-	}
-
-	static bool MustSkipSamplingFromCurrentVector(idx_t vectors_count, idx_t vectors_sampled_count,
-	                                              idx_t current_vector_n_values) {
-		//! We sample equidistant vectors; to do this we skip a fixed values of vectors
-		bool must_select_rowgroup_samples = (vectors_count % AlpConstants::RG_SAMPLES_DUCKDB_JUMP) == 0;
-
-		//! If we are not in the correct jump, we do not take sample from this vector
-		if (!must_select_rowgroup_samples) {
-			return true;
-		}
-
-		//! We do not take samples of non-complete duckdb vectors (usually the last one)
-		//! Except in the case of too little data
-		if (current_vector_n_values < AlpConstants::SAMPLES_PER_VECTOR && vectors_sampled_count != 0) {
-			return true;
-		}
-		return false;
-	}
-
-	template <class T>
-	static T FindFirstValueNotInPositionsArray(const T *input_vector, const uint16_t *positions, idx_t values_count) {
-		T a_non_special_value = 0;
-		for (idx_t i = 0; i < values_count; i++) {
-			if (i != positions[i]) {
-				a_non_special_value = input_vector[i];
-				break;
-			}
-		}
-		return a_non_special_value;
-	}
-
-	template <class T>
-	static void ReplaceValueInVectorPositions(T *input_vector, const uint16_t *positions_to_replace,
-	                                          idx_t special_values_count, T value_to_replace) {
-		for (idx_t i = 0; i < special_values_count; i++) {
-			uint16_t null_value_pos = positions_to_replace[i];
-			input_vector[null_value_pos] = value_to_replace;
-		}
-	}
-
-	template <class T>
-	static void FindAndReplaceNullsInVector(T *input_vector, const uint16_t *vector_null_positions, idx_t values_count,
-	                                        idx_t nulls_count) {
-		if (nulls_count == 0) {
-			return;
-		}
-		T a_non_null_value = FindFirstValueNotInPositionsArray(input_vector, vector_null_positions, values_count);
-		ReplaceValueInVectorPositions(input_vector, vector_null_positions, nulls_count, a_non_null_value);
-	}
-};
-
-} // namespace alp
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/algorithm/alprd.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/algorithm/alprd.hpp
deleted file mode 100644
index 1dac66f4a..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alprd/algorithm/alprd.hpp
+++ /dev/null
@@ -1,239 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alprd/algorithm/alprd.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/storage/compression/alprd/alprd_constants.hpp"
-
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-namespace alp {
-
-struct AlpRDLeftPartInfo {
-	uint32_t count;
-	uint64_t hash;
-	AlpRDLeftPartInfo(uint32_t count, uint64_t hash) : count(count), hash(hash) {
-	}
-};
-
-template <class T, bool EMPTY>
-class AlpRDCompressionState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	AlpRDCompressionState() : right_bit_width(0), left_bit_width(0), exceptions_count(0) {
-	}
-
-	void Reset() {
-		left_bit_packed_size = 0;
-		right_bit_packed_size = 0;
-		exceptions_count = 0;
-	}
-
-public:
-	uint8_t right_bit_width; // 'right' & 'left' refer to the respective parts of the floating numbers after splitting
-	uint8_t left_bit_width;
-	uint16_t exceptions_count;
-	uint8_t right_parts_encoded[AlpRDConstants::ALP_VECTOR_SIZE * 8];
-	uint8_t left_parts_encoded[AlpRDConstants::ALP_VECTOR_SIZE * 8];
-	uint16_t left_parts_dict[AlpRDConstants::MAX_DICTIONARY_SIZE];
-	uint16_t exceptions[AlpRDConstants::ALP_VECTOR_SIZE];
-	uint16_t exceptions_positions[AlpRDConstants::ALP_VECTOR_SIZE];
-	idx_t left_bit_packed_size;
-	idx_t right_bit_packed_size;
-	unordered_map<uint16_t, uint16_t> left_parts_dict_map;
-	uint8_t actual_dictionary_size;
-};
-
-template <class T, bool EMPTY>
-struct AlpRDCompression {
-	using State = AlpRDCompressionState<T, EMPTY>;
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-	static constexpr uint8_t EXACT_TYPE_BITSIZE = sizeof(EXACT_TYPE) * 8;
-
-	/*
-	 * Estimate the bits per value of ALPRD within a sample
-	 */
-	static double EstimateCompressionSize(uint8_t right_bit_width, uint8_t left_bit_width, uint16_t exceptions_count,
-	                                      uint64_t sample_count) {
-		double exceptions_size =
-		    exceptions_count * ((AlpRDConstants::EXCEPTION_POSITION_SIZE + AlpRDConstants::EXCEPTION_SIZE) * 8);
-		double estimated_size =
-		    right_bit_width + left_bit_width + (exceptions_size / static_cast<double>(sample_count));
-		return estimated_size;
-	}
-
-	template <bool PERSIST_DICT>
-	static double BuildLeftPartsDictionary(const vector<EXACT_TYPE> &values, uint8_t right_bit_width, State &state) {
-		unordered_map<EXACT_TYPE, int32_t> left_parts_hash;
-		vector<AlpRDLeftPartInfo> left_parts_sorted_repetitions;
-
-		// Building a hash for all the left parts and how many times they appear
-		for (auto &value : values) {
-			auto left_tmp = value >> right_bit_width;
-			left_parts_hash[left_tmp]++;
-		}
-
-		// We build a vector from the hash to be able to sort it by repetition count
-		left_parts_sorted_repetitions.reserve(left_parts_hash.size());
-		for (auto &hash_pair : left_parts_hash) {
-			left_parts_sorted_repetitions.emplace_back(hash_pair.second, hash_pair.first);
-		}
-		sort(left_parts_sorted_repetitions.begin(), left_parts_sorted_repetitions.end(),
-		     [](const AlpRDLeftPartInfo &a, const AlpRDLeftPartInfo &b) { return a.count > b.count; });
-
-		// Exceptions are left parts which do not fit in the fixed dictionary size
-		uint32_t exceptions_count = 0;
-		for (idx_t i = AlpRDConstants::MAX_DICTIONARY_SIZE; i < left_parts_sorted_repetitions.size(); i++) {
-			exceptions_count += left_parts_sorted_repetitions[i].count;
-		}
-
-		// The left parts bit width after compression is determined by how many elements are in the dictionary
-		uint64_t actual_dictionary_size =
-		    MinValue<uint64_t>(AlpRDConstants::MAX_DICTIONARY_SIZE, left_parts_sorted_repetitions.size());
-		uint8_t left_bit_width =
-		    MaxValue<uint8_t>(1, ExactNumericCast<uint8_t>(std::ceil(std::log2(actual_dictionary_size))));
-
-		if (PERSIST_DICT) {
-			for (idx_t dict_idx = 0; dict_idx < actual_dictionary_size; dict_idx++) {
-				//! The dict keys are mapped to the left part themselves
-				state.left_parts_dict[dict_idx] =
-				    UnsafeNumericCast<uint16_t>(left_parts_sorted_repetitions[dict_idx].hash);
-				state.left_parts_dict_map.insert({state.left_parts_dict[dict_idx], dict_idx});
-			}
-			//! Pararelly we store a map of the dictionary to quickly resolve exceptions during encoding
-			for (idx_t i = actual_dictionary_size + 1; i < left_parts_sorted_repetitions.size(); i++) {
-				state.left_parts_dict_map.insert({left_parts_sorted_repetitions[i].hash, i});
-			}
-			state.left_bit_width = left_bit_width;
-			state.right_bit_width = right_bit_width;
-			state.actual_dictionary_size = UnsafeNumericCast<uint8_t>(actual_dictionary_size);
-
-			D_ASSERT(state.left_bit_width > 0 && state.right_bit_width > 0 &&
-			         state.left_bit_width <= AlpRDConstants::MAX_DICTIONARY_BIT_WIDTH &&
-			         state.actual_dictionary_size <= AlpRDConstants::MAX_DICTIONARY_SIZE);
-		}
-
-		double estimated_size = EstimateCompressionSize(right_bit_width, left_bit_width,
-		                                                UnsafeNumericCast<uint16_t>(exceptions_count), values.size());
-		return estimated_size;
-	}
-
-	static double FindBestDictionary(const vector<EXACT_TYPE> &values, State &state) {
-		uint8_t right_bit_width = 0;
-		double best_dict_size = NumericLimits<int32_t>::Maximum();
-		//! Finding the best position to CUT the values
-		for (idx_t i = 1; i <= AlpRDConstants::CUTTING_LIMIT; i++) {
-			uint8_t candidate_right_bit_width = UnsafeNumericCast<uint8_t>(EXACT_TYPE_BITSIZE - i);
-			double estimated_size = BuildLeftPartsDictionary<false>(values, candidate_right_bit_width, state);
-			if (estimated_size <= best_dict_size) {
-				right_bit_width = candidate_right_bit_width;
-				best_dict_size = estimated_size;
-			}
-			// TODO: We could implement an early exit mechanism similar to normal ALP
-		}
-		double estimated_size = BuildLeftPartsDictionary<true>(values, right_bit_width, state);
-		return estimated_size;
-	}
-
-	static void Compress(const EXACT_TYPE *input_vector, idx_t n_values, State &state) {
-
-		uint64_t right_parts[AlpRDConstants::ALP_VECTOR_SIZE];
-		uint16_t left_parts[AlpRDConstants::ALP_VECTOR_SIZE];
-
-		// Cutting the floating point values
-		for (idx_t i = 0; i < n_values; i++) {
-			EXACT_TYPE tmp = input_vector[i];
-			right_parts[i] = tmp & ((1ULL << state.right_bit_width) - 1);
-			left_parts[i] = UnsafeNumericCast<uint16_t>(tmp >> state.right_bit_width);
-		}
-
-		// Dictionary encoding for left parts
-		for (idx_t i = 0; i < n_values; i++) {
-			uint16_t dictionary_index;
-			auto dictionary_key = left_parts[i];
-			if (state.left_parts_dict_map.find(dictionary_key) == state.left_parts_dict_map.end()) {
-				//! If not found on the dictionary we store the smallest non-key index as exception (the dict size)
-				dictionary_index = state.actual_dictionary_size;
-			} else {
-				dictionary_index = state.left_parts_dict_map[dictionary_key];
-			}
-			left_parts[i] = dictionary_index;
-
-			//! Left parts not found in the dictionary are stored as exceptions
-			if (dictionary_index >= state.actual_dictionary_size) {
-				state.exceptions[state.exceptions_count] = dictionary_key;
-				state.exceptions_positions[state.exceptions_count] = UnsafeNumericCast<uint16_t>(i);
-				state.exceptions_count++;
-			}
-		}
-
-		auto right_bit_packed_size = BitpackingPrimitives::GetRequiredSize(n_values, state.right_bit_width);
-		auto left_bit_packed_size = BitpackingPrimitives::GetRequiredSize(n_values, state.left_bit_width);
-
-		if (!EMPTY) {
-			// Bitpacking Left and Right parts
-			BitpackingPrimitives::PackBuffer<uint16_t, false>(state.left_parts_encoded, left_parts, n_values,
-			                                                  state.left_bit_width);
-			BitpackingPrimitives::PackBuffer<uint64_t, false>(state.right_parts_encoded, right_parts, n_values,
-			                                                  state.right_bit_width);
-		}
-
-		state.left_bit_packed_size = left_bit_packed_size;
-		state.right_bit_packed_size = right_bit_packed_size;
-	}
-};
-
-template <class T>
-struct AlpRDDecompression {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	static void Decompress(uint8_t *left_encoded, uint8_t *right_encoded, const uint16_t *left_parts_dict,
-	                       EXACT_TYPE *output, idx_t values_count, uint16_t exceptions_count,
-	                       const uint16_t *exceptions, const uint16_t *exceptions_positions, uint8_t left_bit_width,
-	                       uint8_t right_bit_width) {
-
-		uint8_t left_decoded[AlpRDConstants::ALP_VECTOR_SIZE * 8] = {0};
-		uint8_t right_decoded[AlpRDConstants::ALP_VECTOR_SIZE * 8] = {0};
-
-		// Bitunpacking left and right parts
-		BitpackingPrimitives::UnPackBuffer<uint16_t>(left_decoded, left_encoded, values_count, left_bit_width);
-		BitpackingPrimitives::UnPackBuffer<EXACT_TYPE>(right_decoded, right_encoded, values_count, right_bit_width);
-
-		uint16_t *left_parts = reinterpret_cast<uint16_t *>(data_ptr_cast(left_decoded));
-		EXACT_TYPE *right_parts = reinterpret_cast<EXACT_TYPE *>(data_ptr_cast(right_decoded));
-
-		// Decoding
-		for (idx_t i = 0; i < values_count; i++) {
-			uint16_t left = left_parts_dict[left_parts[i]];
-			EXACT_TYPE right = right_parts[i];
-			output[i] = (static_cast<EXACT_TYPE>(left) << right_bit_width) | right;
-		}
-
-		// Exceptions Patching (exceptions only occur in left parts)
-		for (idx_t i = 0; i < exceptions_count; i++) {
-			EXACT_TYPE right = right_parts[exceptions_positions[i]];
-			uint16_t left = exceptions[i];
-			output[exceptions_positions[i]] = (static_cast<EXACT_TYPE>(left) << right_bit_width) | right;
-		}
-	}
-};
-
-} // namespace alp
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_analyze.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_analyze.hpp
deleted file mode 100644
index a51853bbd..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_analyze.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alprd/alprd_analyze.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/alp/alp_constants.hpp"
-#include "duckdb/storage/compression/alp/alp_utils.hpp"
-#include "duckdb/storage/compression/alprd/algorithm/alprd.hpp"
-#include "duckdb/storage/compression/alprd/alprd_constants.hpp"
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-template <class T>
-struct AlpRDAnalyzeState : public AnalyzeState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	explicit AlpRDAnalyzeState(const CompressionInfo &info) : AnalyzeState(info), state() {
-	}
-
-	idx_t vectors_count = 0;
-	idx_t total_values_count = 0;
-	idx_t vectors_sampled_count = 0;
-	vector<EXACT_TYPE> rowgroup_sample;
-	alp::AlpRDCompressionState<T, true> state;
-};
-
-template <class T>
-unique_ptr<AnalyzeState> AlpRDInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<AlpRDAnalyzeState<T>>(info);
-}
-
-/*
- * ALPRD Analyze step only pushes the needed samples to estimate the compression size in the finalize step
- */
-template <class T>
-bool AlpRDAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-	auto &analyze_state = (AlpRDAnalyzeState<T> &)state;
-
-	bool must_skip_current_vector = alp::AlpUtils::MustSkipSamplingFromCurrentVector(
-	    analyze_state.vectors_count, analyze_state.vectors_sampled_count, count);
-	analyze_state.vectors_count += 1;
-	analyze_state.total_values_count += count;
-	if (must_skip_current_vector) {
-		return true;
-	}
-
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-	auto data = UnifiedVectorFormat::GetData<T>(vdata);
-
-	alp::AlpSamplingParameters sampling_params = alp::AlpUtils::GetSamplingParameters(count);
-
-	vector<uint16_t> current_vector_null_positions(sampling_params.n_lookup_values, 0);
-	vector<EXACT_TYPE> current_vector_sample(sampling_params.n_sampled_values, 0);
-
-	// Storing the sample of that vector
-	idx_t sample_idx = 0;
-	idx_t nulls_idx = 0;
-	// We optimize by doing a different loop when there are no nulls
-	if (vdata.validity.AllValid()) {
-		for (idx_t i = 0; i < sampling_params.n_lookup_values; i += sampling_params.n_sampled_increments) {
-			auto idx = vdata.sel->get_index(i);
-			EXACT_TYPE value = Load<EXACT_TYPE>(const_data_ptr_cast(&data[idx]));
-			current_vector_sample[sample_idx] = value;
-			sample_idx++;
-		}
-	} else {
-		for (idx_t i = 0; i < sampling_params.n_lookup_values; i += sampling_params.n_sampled_increments) {
-			auto idx = vdata.sel->get_index(i);
-			EXACT_TYPE value = Load<EXACT_TYPE>(const_data_ptr_cast(&data[idx]));
-			current_vector_sample[sample_idx] = value;
-			//! We resolve null values with a predicated comparison
-			bool is_null = !vdata.validity.RowIsValid(idx);
-			current_vector_null_positions[nulls_idx] = UnsafeNumericCast<uint16_t>(sample_idx);
-			nulls_idx += is_null;
-			sample_idx++;
-		}
-		alp::AlpUtils::FindAndReplaceNullsInVector<EXACT_TYPE>(current_vector_sample.data(),
-		                                                       current_vector_null_positions.data(),
-		                                                       sampling_params.n_sampled_values, nulls_idx);
-	}
-
-	D_ASSERT(sample_idx == sampling_params.n_sampled_values);
-
-	// Pushing the sampled vector samples into the rowgroup samples
-	for (auto &value : current_vector_sample) {
-		analyze_state.rowgroup_sample.push_back(value);
-	}
-
-	analyze_state.vectors_sampled_count++;
-	return true;
-}
-
-/*
- * Estimate the compression size of ALPRD using the taken samples
- */
-template <class T>
-idx_t AlpRDFinalAnalyze(AnalyzeState &state) {
-	auto &analyze_state = (AlpRDAnalyzeState<T> &)state;
-	if (analyze_state.total_values_count == 0) {
-		return DConstants::INVALID_INDEX;
-	}
-	double factor_of_sampling = 1 / ((double)analyze_state.rowgroup_sample.size() / analyze_state.total_values_count);
-
-	// Finding which is the best dictionary for the sample
-	double estimated_bits_per_value =
-	    alp::AlpRDCompression<T, true>::FindBestDictionary(analyze_state.rowgroup_sample, analyze_state.state);
-	double estimated_compressed_bits = estimated_bits_per_value * analyze_state.rowgroup_sample.size();
-	double estimed_compressed_bytes = estimated_compressed_bits / 8;
-
-	//! Overhead per segment: [Pointer to metadata + right bitwidth + left bitwidth + n dict elems] + Dictionary Size
-	double per_segment_overhead = AlpRDConstants::HEADER_SIZE + AlpRDConstants::MAX_DICTIONARY_SIZE_BYTES;
-
-	//! Overhead per vector: Pointer to data + Exceptions count
-	double per_vector_overhead = AlpRDConstants::METADATA_POINTER_SIZE + AlpRDConstants::EXCEPTIONS_COUNT_SIZE;
-
-	uint32_t n_vectors = LossyNumericCast<uint32_t>(
-	    std::ceil((double)analyze_state.total_values_count / AlpRDConstants::ALP_VECTOR_SIZE));
-
-	auto estimated_size = (estimed_compressed_bytes * factor_of_sampling) + (n_vectors * per_vector_overhead);
-	uint32_t estimated_n_blocks = LossyNumericCast<uint32_t>(
-	    std::ceil(estimated_size / (static_cast<double>(state.info.GetBlockSize()) - per_segment_overhead)));
-
-	auto final_analyze_size = estimated_size + (estimated_n_blocks * per_segment_overhead);
-	return LossyNumericCast<idx_t>(final_analyze_size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp
deleted file mode 100644
index 6b732e664..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp
+++ /dev/null
@@ -1,299 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alprd/alprd_compress.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/compression/alp/alp_constants.hpp"
-#include "duckdb/storage/compression/alprd/algorithm/alprd.hpp"
-#include "duckdb/storage/compression/alprd/alprd_analyze.hpp"
-#include "duckdb/storage/compression/alprd/alprd_constants.hpp"
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-template <class T>
-struct AlpRDCompressionState : public CompressionState {
-
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	AlpRDCompressionState(ColumnDataCheckpointData &checkpoint_data, AlpRDAnalyzeState<T> *analyze_state)
-	    : CompressionState(analyze_state->info), checkpoint_data(checkpoint_data),
-	      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ALPRD)) {
-		//! State variables from the analyze step that are needed for compression
-		state.left_parts_dict_map = std::move(analyze_state->state.left_parts_dict_map);
-		state.left_bit_width = analyze_state->state.left_bit_width;
-		state.right_bit_width = analyze_state->state.right_bit_width;
-		state.actual_dictionary_size = analyze_state->state.actual_dictionary_size;
-		actual_dictionary_size_bytes = state.actual_dictionary_size * AlpRDConstants::DICTIONARY_ELEMENT_SIZE;
-		next_vector_byte_index_start = AlpRDConstants::HEADER_SIZE + actual_dictionary_size_bytes;
-		memcpy((void *)state.left_parts_dict, (void *)analyze_state->state.left_parts_dict,
-		       actual_dictionary_size_bytes);
-		CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-	}
-
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	idx_t vector_idx = 0;
-	idx_t nulls_idx = 0;
-	idx_t vectors_flushed = 0;
-	idx_t data_bytes_used = 0;
-
-	data_ptr_t data_ptr;     // Pointer to next free spot in segment;
-	data_ptr_t metadata_ptr; // Reverse pointer to the next free spot for the metadata; used in decoding to SKIP vectors
-	uint32_t actual_dictionary_size_bytes;
-	uint32_t next_vector_byte_index_start;
-
-	EXACT_TYPE input_vector[AlpRDConstants::ALP_VECTOR_SIZE];
-	uint16_t vector_null_positions[AlpRDConstants::ALP_VECTOR_SIZE];
-
-	alp::AlpRDCompressionState<T, false> state;
-
-public:
-	// Returns the space currently used in the segment (in bytes)
-	idx_t UsedSpace() const {
-		//! [Pointer to metadata + right bitwidth] + Dictionary Size + Bytes already used in the segment
-		return AlpRDConstants::HEADER_SIZE + actual_dictionary_size_bytes + data_bytes_used;
-	}
-
-	// Returns the required space to store the newly compressed vector
-	idx_t RequiredSpace() {
-		idx_t required_space =
-		    state.left_bit_packed_size + state.right_bit_packed_size +
-		    state.exceptions_count * (AlpRDConstants::EXCEPTION_SIZE + AlpRDConstants::EXCEPTION_POSITION_SIZE) +
-		    AlpRDConstants::EXCEPTIONS_COUNT_SIZE;
-		return required_space;
-	}
-
-	bool HasEnoughSpace() {
-		//! If [start of block + used space + required space] is more than whats left (current position
-		//! of metadata pointer - the size of a new metadata pointer)
-		if ((handle.Ptr() + AlignValue(UsedSpace() + RequiredSpace())) >=
-		    (metadata_ptr - AlpRDConstants::METADATA_POINTER_SIZE)) {
-			return false;
-		}
-		return true;
-	}
-
-	void ResetVector() {
-		state.Reset();
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start,
-		                                                                info.GetBlockSize(), info.GetBlockSize());
-		current_segment = std::move(compressed_segment);
-
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
-		handle = buffer_manager.Pin(current_segment->block);
-
-		// The pointer to the start of the compressed data.
-		data_ptr = handle.Ptr() + current_segment->GetBlockOffset() + AlpRDConstants::HEADER_SIZE +
-		           actual_dictionary_size_bytes;
-		// The pointer to the start of the metadata.
-		metadata_ptr = handle.Ptr() + current_segment->GetBlockOffset() + info.GetBlockSize();
-		next_vector_byte_index_start = AlpRDConstants::HEADER_SIZE + actual_dictionary_size_bytes;
-	}
-
-	void CompressVector() {
-		if (nulls_idx) {
-			alp::AlpUtils::FindAndReplaceNullsInVector<EXACT_TYPE>(input_vector, vector_null_positions, vector_idx,
-			                                                       nulls_idx);
-		}
-		alp::AlpRDCompression<T, false>::Compress(input_vector, vector_idx, state);
-		//! Check if the compressed vector fits on current segment
-		if (!HasEnoughSpace()) {
-			auto row_start = current_segment->start + current_segment->count;
-			FlushSegment();
-			CreateEmptySegment(row_start);
-		}
-		if (vector_idx != nulls_idx) { //! At least there is one valid value in the vector
-			for (idx_t i = 0; i < vector_idx; i++) {
-				T floating_point_value = Load<T>(const_data_ptr_cast(&input_vector[i]));
-				current_segment->stats.statistics.UpdateNumericStats<T>(floating_point_value);
-			}
-		}
-		current_segment->count += vector_idx;
-		FlushVector();
-	}
-
-	// Stores the vector and its metadata
-	void FlushVector() {
-		Store<uint16_t>(state.exceptions_count, data_ptr);
-		data_ptr += AlpRDConstants::EXCEPTIONS_COUNT_SIZE;
-
-		memcpy((void *)data_ptr, (void *)state.left_parts_encoded, state.left_bit_packed_size);
-		data_ptr += state.left_bit_packed_size;
-
-		memcpy((void *)data_ptr, (void *)state.right_parts_encoded, state.right_bit_packed_size);
-		data_ptr += state.right_bit_packed_size;
-
-		if (state.exceptions_count > 0) {
-			memcpy((void *)data_ptr, (void *)state.exceptions, AlpRDConstants::EXCEPTION_SIZE * state.exceptions_count);
-			data_ptr += AlpRDConstants::EXCEPTION_SIZE * state.exceptions_count;
-			memcpy((void *)data_ptr, (void *)state.exceptions_positions,
-			       AlpRDConstants::EXCEPTION_POSITION_SIZE * state.exceptions_count);
-			data_ptr += AlpRDConstants::EXCEPTION_POSITION_SIZE * state.exceptions_count;
-		}
-
-		data_bytes_used +=
-		    state.left_bit_packed_size + state.right_bit_packed_size +
-		    (state.exceptions_count * (AlpRDConstants::EXCEPTION_SIZE + AlpRDConstants::EXCEPTION_POSITION_SIZE)) +
-		    AlpRDConstants::EXCEPTIONS_COUNT_SIZE;
-
-		// Write pointer to the vector data (metadata)
-		metadata_ptr -= AlpRDConstants::METADATA_POINTER_SIZE;
-		Store<uint32_t>(next_vector_byte_index_start, metadata_ptr);
-		next_vector_byte_index_start = NumericCast<uint32_t>(UsedSpace());
-
-		vectors_flushed++;
-		vector_idx = 0;
-		nulls_idx = 0;
-		ResetVector();
-	}
-
-	void FlushSegment() {
-		auto &checkpoint_state = checkpoint_data.GetCheckpointState();
-		auto dataptr = handle.Ptr();
-
-		idx_t metadata_offset = AlignValue(UsedSpace());
-
-		// Verify that the metadata_ptr is not smaller than the space used by the data
-		D_ASSERT(dataptr + metadata_offset <= metadata_ptr);
-
-		auto bytes_used_by_metadata = UnsafeNumericCast<idx_t>(dataptr + info.GetBlockSize() - metadata_ptr);
-
-		// Initially the total segment size is the size of the block
-		auto total_segment_size = info.GetBlockSize();
-
-		//! We compact the block if the space used is less than a threshold
-		const auto used_space_percentage =
-		    static_cast<float>(metadata_offset + bytes_used_by_metadata) / static_cast<float>(total_segment_size);
-		if (used_space_percentage < AlpConstants::COMPACT_BLOCK_THRESHOLD) {
-#ifdef DEBUG
-			//! Copy the first 4 bytes of the metadata
-			uint32_t verify_bytes;
-			memcpy((void *)&verify_bytes, metadata_ptr, 4);
-#endif
-			memmove(dataptr + metadata_offset, metadata_ptr, bytes_used_by_metadata);
-#ifdef DEBUG
-			//! Now assert that the memmove was correct
-			D_ASSERT(verify_bytes == *(uint32_t *)(dataptr + metadata_offset));
-#endif
-			total_segment_size = metadata_offset + bytes_used_by_metadata;
-		}
-
-		// Store the offset to the end of metadata (to be used as a backwards pointer in decoding)
-		Store<uint32_t>(NumericCast<uint32_t>(total_segment_size), dataptr);
-		dataptr += AlpRDConstants::METADATA_POINTER_SIZE;
-
-		// Store the right bw for the segment
-		Store<uint8_t>(state.right_bit_width, dataptr);
-		dataptr += AlpRDConstants::RIGHT_BIT_WIDTH_SIZE;
-
-		// Store the left bw for the segment
-		Store<uint8_t>(state.left_bit_width, dataptr);
-		dataptr += AlpRDConstants::LEFT_BIT_WIDTH_SIZE;
-
-		// Store the actual number of elements on the dictionary of the segment
-		Store<uint8_t>(state.actual_dictionary_size, dataptr);
-		dataptr += AlpRDConstants::N_DICTIONARY_ELEMENTS_SIZE;
-
-		// Store the Dictionary
-		memcpy((void *)dataptr, (void *)state.left_parts_dict, actual_dictionary_size_bytes);
-
-		checkpoint_state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size);
-		data_bytes_used = 0;
-		vectors_flushed = 0;
-	}
-
-	void Finalize() {
-		if (vector_idx != 0) {
-			CompressVector();
-		}
-		FlushSegment();
-		current_segment.reset();
-	}
-
-	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = UnifiedVectorFormat::GetData<T>(vdata);
-		idx_t values_left_in_data = count;
-		idx_t offset_in_data = 0;
-		while (values_left_in_data > 0) {
-			// We calculate until which value in data we must go to fill the input_vector
-			// to avoid checking if input_vector is filled in each iteration
-			auto values_to_fill_alp_input =
-			    MinValue<idx_t>(AlpConstants::ALP_VECTOR_SIZE - vector_idx, values_left_in_data);
-			if (vdata.validity.AllValid()) { //! We optimize a loop when there are no null
-				for (idx_t i = 0; i < values_to_fill_alp_input; i++) {
-					auto idx = vdata.sel->get_index(offset_in_data + i);
-					EXACT_TYPE value = Load<EXACT_TYPE>(const_data_ptr_cast(&data[idx]));
-					input_vector[vector_idx + i] = value;
-				}
-			} else {
-				for (idx_t i = 0; i < values_to_fill_alp_input; i++) {
-					auto idx = vdata.sel->get_index(offset_in_data + i);
-					EXACT_TYPE value = Load<EXACT_TYPE>(const_data_ptr_cast(&data[idx]));
-					bool is_null = !vdata.validity.RowIsValid(idx);
-					//! We resolve null values with a predicated comparison
-					vector_null_positions[nulls_idx] = UnsafeNumericCast<uint16_t>(vector_idx + i);
-					nulls_idx += is_null;
-					input_vector[vector_idx + i] = value;
-				}
-			}
-			offset_in_data += values_to_fill_alp_input;
-			values_left_in_data -= values_to_fill_alp_input;
-			vector_idx += values_to_fill_alp_input;
-			// We still need this check since we could have an incomplete input_vector at the end of data
-			if (vector_idx == AlpConstants::ALP_VECTOR_SIZE) {
-				CompressVector();
-				D_ASSERT(vector_idx == 0);
-			}
-		}
-	}
-};
-
-template <class T>
-unique_ptr<CompressionState> AlpRDInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                  unique_ptr<AnalyzeState> state) {
-	return make_uniq<AlpRDCompressionState<T>>(checkpoint_data, (AlpRDAnalyzeState<T> *)state.get());
-}
-
-template <class T>
-void AlpRDCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (AlpRDCompressionState<T> &)state_p;
-	UnifiedVectorFormat vdata;
-	scan_vector.ToUnifiedFormat(count, vdata);
-	state.Append(vdata, count);
-}
-
-template <class T>
-void AlpRDFinalizeCompress(CompressionState &state_p) {
-	auto &state = (AlpRDCompressionState<T> &)state_p;
-	state.Finalize();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_constants.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_constants.hpp
deleted file mode 100644
index 521551e2d..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_constants.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alprd/alprd_constants.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-class AlpRDConstants {
-public:
-	static constexpr uint32_t ALP_VECTOR_SIZE = 1024;
-
-	static constexpr uint8_t MAX_DICTIONARY_BIT_WIDTH = 3;
-	static constexpr uint8_t MAX_DICTIONARY_SIZE = (1 << MAX_DICTIONARY_BIT_WIDTH); // 8
-	static constexpr uint8_t CUTTING_LIMIT = 16;
-	static constexpr uint8_t DICTIONARY_ELEMENT_SIZE = sizeof(uint16_t);
-	static constexpr uint8_t MAX_DICTIONARY_SIZE_BYTES = MAX_DICTIONARY_SIZE * DICTIONARY_ELEMENT_SIZE;
-
-	static constexpr uint8_t EXCEPTION_SIZE = sizeof(uint16_t);
-	static constexpr uint8_t METADATA_POINTER_SIZE = sizeof(uint32_t);
-	static constexpr uint8_t EXCEPTIONS_COUNT_SIZE = sizeof(uint16_t);
-	static constexpr uint8_t EXCEPTION_POSITION_SIZE = sizeof(uint16_t);
-	static constexpr uint8_t RIGHT_BIT_WIDTH_SIZE = sizeof(uint8_t);
-	static constexpr uint8_t LEFT_BIT_WIDTH_SIZE = sizeof(uint8_t);
-	static constexpr uint8_t N_DICTIONARY_ELEMENTS_SIZE = sizeof(uint8_t);
-	static constexpr uint8_t HEADER_SIZE =
-	    METADATA_POINTER_SIZE + RIGHT_BIT_WIDTH_SIZE + LEFT_BIT_WIDTH_SIZE +
-	    N_DICTIONARY_ELEMENTS_SIZE; // Pointer to metadata + Right BW + Left BW + Dict Elems
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_fetch.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_fetch.hpp
deleted file mode 100644
index 359230198..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_fetch.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alp/alp_fetch.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/alprd/alprd_scan.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-namespace duckdb {
-
-template <class T>
-void AlpRDFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-	AlpRDScanState<T> scan_state(segment);
-	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
-	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);
-	result_data[result_idx] = (EXACT_TYPE)0;
-
-	if (scan_state.VectorFinished() && scan_state.total_value_count < scan_state.count) {
-		scan_state.LoadVector(scan_state.vector_state.decoded_values);
-	}
-	scan_state.vector_state.Scan((uint8_t *)(result_data + result_idx), 1);
-	scan_state.total_value_count++;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp
deleted file mode 100644
index 48f3e1a33..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp
+++ /dev/null
@@ -1,251 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/alprd/alprd_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/alprd/algorithm/alprd.hpp"
-#include "duckdb/storage/compression/alprd/alprd_constants.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct AlpRDVectorState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	void Reset() {
-		index = 0;
-	}
-
-	// Scan of the data itself
-	template <bool SKIP = false>
-	void Scan(uint8_t *dest, idx_t count) {
-		if (!SKIP) {
-			memcpy(dest, (void *)(decoded_values + index), sizeof(T) * count);
-		}
-		index += count;
-	}
-
-	template <bool SKIP>
-	void LoadValues(EXACT_TYPE *values_buffer, idx_t count) {
-		if (SKIP) {
-			return;
-		}
-		values_buffer[0] = (EXACT_TYPE)0;
-		alp::AlpRDDecompression<T>::Decompress(left_encoded, right_encoded, left_parts_dict, values_buffer, count,
-		                                       exceptions_count, exceptions, exceptions_positions, left_bit_width,
-		                                       right_bit_width);
-	}
-
-public:
-	idx_t index;
-	uint8_t left_encoded[AlpRDConstants::ALP_VECTOR_SIZE * 8];
-	uint8_t right_encoded[AlpRDConstants::ALP_VECTOR_SIZE * 8];
-	EXACT_TYPE decoded_values[AlpRDConstants::ALP_VECTOR_SIZE];
-	uint16_t exceptions[AlpRDConstants::ALP_VECTOR_SIZE];
-	uint16_t exceptions_positions[AlpRDConstants::ALP_VECTOR_SIZE];
-	uint16_t exceptions_count;
-	uint8_t right_bit_width;
-	uint8_t left_bit_width;
-	uint16_t left_parts_dict[AlpRDConstants::MAX_DICTIONARY_SIZE];
-};
-
-template <class T>
-struct AlpRDScanState : public SegmentScanState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	explicit AlpRDScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-
-		handle = buffer_manager.Pin(segment.block);
-		// ScanStates never exceed the boundaries of a Segment,
-		// but are not guaranteed to start at the beginning of the Block
-		segment_data = handle.Ptr() + segment.GetBlockOffset();
-		auto metadata_offset = Load<uint32_t>(segment_data);
-		metadata_ptr = segment_data + metadata_offset;
-
-		// Load the Right Bit Width which is in the segment header after the pointer to the first metadata
-		vector_state.right_bit_width = Load<uint8_t>(segment_data + AlpRDConstants::METADATA_POINTER_SIZE);
-		vector_state.left_bit_width =
-		    Load<uint8_t>(segment_data + AlpRDConstants::METADATA_POINTER_SIZE + AlpRDConstants::RIGHT_BIT_WIDTH_SIZE);
-
-		uint8_t actual_dictionary_size =
-		    Load<uint8_t>(segment_data + AlpRDConstants::METADATA_POINTER_SIZE + AlpRDConstants::RIGHT_BIT_WIDTH_SIZE +
-		                  AlpRDConstants::LEFT_BIT_WIDTH_SIZE);
-		uint8_t actual_dictionary_size_bytes = actual_dictionary_size * AlpRDConstants::DICTIONARY_ELEMENT_SIZE;
-
-		// Load the left parts dictionary which is after the segment header and is of a fixed size
-		memcpy(vector_state.left_parts_dict, (void *)(segment_data + AlpRDConstants::HEADER_SIZE),
-		       actual_dictionary_size_bytes);
-	}
-
-	BufferHandle handle;
-	data_ptr_t metadata_ptr;
-	data_ptr_t segment_data;
-	idx_t total_value_count = 0;
-	AlpRDVectorState<T> vector_state;
-
-	ColumnSegment &segment;
-	idx_t count;
-
-	idx_t LeftInVector() const {
-		return AlpRDConstants::ALP_VECTOR_SIZE - (total_value_count % AlpRDConstants::ALP_VECTOR_SIZE);
-	}
-
-	inline bool VectorFinished() const {
-		return (total_value_count % AlpRDConstants::ALP_VECTOR_SIZE) == 0;
-	}
-
-	// Scan up to a vector boundary
-	template <class EXACT_TYPE, bool SKIP = false>
-	void ScanVector(EXACT_TYPE *values, idx_t vector_size) {
-		D_ASSERT(vector_size <= AlpRDConstants::ALP_VECTOR_SIZE);
-		D_ASSERT(vector_size <= LeftInVector());
-		if (VectorFinished() && total_value_count < count) {
-			if (vector_size == AlpRDConstants::ALP_VECTOR_SIZE) {
-				LoadVector<SKIP>(values);
-				total_value_count += vector_size;
-				return;
-			} else {
-				// Even if SKIP is given, the vector size is not big enough to be able to fully skip the entire vector
-				LoadVector<false>(vector_state.decoded_values);
-			}
-		}
-		vector_state.template Scan<SKIP>((uint8_t *)values, vector_size);
-
-		total_value_count += vector_size;
-	}
-
-	// Using the metadata, we can avoid loading any of the data if we don't care about the vector at all
-	void SkipVector() {
-		// Skip the offset indicating where the data starts
-		metadata_ptr -= AlpRDConstants::METADATA_POINTER_SIZE;
-		idx_t vector_size = MinValue((idx_t)AlpRDConstants::ALP_VECTOR_SIZE, count - total_value_count);
-		total_value_count += vector_size;
-	}
-
-	template <bool SKIP = false>
-	void LoadVector(EXACT_TYPE *value_buffer) {
-		vector_state.Reset();
-
-		// Load the offset (metadata) indicating where the vector data starts
-		metadata_ptr -= AlpRDConstants::METADATA_POINTER_SIZE;
-		auto data_byte_offset = Load<uint32_t>(metadata_ptr);
-		D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize());
-
-		idx_t vector_size = MinValue((idx_t)AlpRDConstants::ALP_VECTOR_SIZE, (count - total_value_count));
-
-		data_ptr_t vector_ptr = segment_data + data_byte_offset;
-
-		// Load the vector data
-		vector_state.exceptions_count = Load<uint16_t>(vector_ptr);
-		vector_ptr += AlpRDConstants::EXCEPTIONS_COUNT_SIZE;
-		D_ASSERT(vector_state.exceptions_count <= vector_size);
-
-		auto left_bp_size = BitpackingPrimitives::GetRequiredSize(vector_size, vector_state.left_bit_width);
-		auto right_bp_size = BitpackingPrimitives::GetRequiredSize(vector_size, vector_state.right_bit_width);
-
-		memcpy(vector_state.left_encoded, (void *)vector_ptr, left_bp_size);
-		vector_ptr += left_bp_size;
-
-		memcpy(vector_state.right_encoded, (void *)vector_ptr, right_bp_size);
-		vector_ptr += right_bp_size;
-
-		if (vector_state.exceptions_count > 0) {
-			memcpy(vector_state.exceptions, (void *)vector_ptr,
-			       AlpRDConstants::EXCEPTION_SIZE * vector_state.exceptions_count);
-			vector_ptr += AlpRDConstants::EXCEPTION_SIZE * vector_state.exceptions_count;
-			memcpy(vector_state.exceptions_positions, (void *)vector_ptr,
-			       AlpRDConstants::EXCEPTION_POSITION_SIZE * vector_state.exceptions_count);
-		}
-
-		// Decode all the vector values to the specified 'value_buffer'
-		vector_state.template LoadValues<SKIP>(value_buffer, vector_size);
-	}
-
-public:
-	//! Skip the next 'skip_count' values, we don't store the values
-	void Skip(ColumnSegment &col_segment, idx_t skip_count) {
-		if (total_value_count != 0 && !VectorFinished()) {
-			// Finish skipping the current vector
-			idx_t to_skip = MinValue<idx_t>(skip_count, LeftInVector());
-			ScanVector<EXACT_TYPE, true>(nullptr, to_skip);
-			skip_count -= to_skip;
-		}
-		// Figure out how many entire vectors we can skip
-		// For these vectors, we don't even need to process the metadata or values
-		idx_t vectors_to_skip = skip_count / AlpRDConstants::ALP_VECTOR_SIZE;
-		for (idx_t i = 0; i < vectors_to_skip; i++) {
-			SkipVector();
-		}
-		skip_count -= AlpRDConstants::ALP_VECTOR_SIZE * vectors_to_skip;
-		if (skip_count == 0) {
-			return;
-		}
-		// For the last vector that this skip (partially) touches, we do need to
-		// load the metadata and values into the vector_state because
-		// we don't know exactly how many they are
-		ScanVector<EXACT_TYPE, true>(nullptr, skip_count);
-	}
-};
-
-template <class T>
-unique_ptr<SegmentScanState> AlpRDInitScan(ColumnSegment &segment) {
-	auto result = make_uniq_base<SegmentScanState, AlpRDScanState<T>>(segment);
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void AlpRDScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                      idx_t result_offset) {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-	auto &scan_state = (AlpRDScanState<T> &)*state.scan_state;
-
-	// Get the pointer to the result values
-	auto current_result_ptr = FlatVector::GetData<EXACT_TYPE>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	current_result_ptr += result_offset;
-
-	idx_t scanned = 0;
-	while (scanned < scan_count) {
-		const auto remaining = scan_count - scanned;
-		const idx_t to_scan = MinValue(remaining, scan_state.LeftInVector());
-
-		scan_state.template ScanVector<EXACT_TYPE>(current_result_ptr + scanned, to_scan);
-		scanned += to_scan;
-	}
-}
-
-template <class T>
-void AlpRDSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = (AlpRDScanState<T> &)*state.scan_state;
-	scan_state.Skip(segment, skip_count);
-}
-
-template <class T>
-void AlpRDScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	AlpRDScanPartial<T>(segment, state, scan_count, result, 0);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp b/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp
deleted file mode 100644
index 6b87e5bb1..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/bitpacking.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-enum class BitpackingMode : uint8_t { INVALID, AUTO, CONSTANT, CONSTANT_DELTA, DELTA_FOR, FOR };
-
-BitpackingMode BitpackingModeFromString(const string &str);
-string BitpackingModeToString(const BitpackingMode &mode);
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_reader.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_reader.hpp
deleted file mode 100644
index a2910e63e..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_reader.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/algorithm/chimp/bit_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-//! Every byte read touches at most 2 bytes (1 if it's perfectly aligned)
-//! Within a byte we need to mask off the bits that we're interested in
-
-struct BitReader {
-private:
-	//! Align the masks to the right
-	static constexpr uint8_t MASKS[] = {
-	    0,   // 0b00000000,
-	    128, // 0b10000000,
-	    192, // 0b11000000,
-	    224, // 0b11100000,
-	    240, // 0b11110000,
-	    248, // 0b11111000,
-	    252, // 0b11111100,
-	    254, // 0b11111110,
-	    255, // 0b11111111,
-	    // These later masks are for the cases where index + SIZE exceeds 8
-	    254, // 0b11111110,
-	    252, // 0b11111100,
-	    248, // 0b11111000,
-	    240, // 0b11110000,
-	    224, // 0b11100000,
-	    192, // 0b11000000,
-	    128, // 0b10000000,
-	};
-
-	static constexpr uint8_t REMAINDER_MASKS[] = {
-	    0,   0, 0, 0, 0, 0, 0, 0, 0,
-	    128, // 0b10000000,
-	    192, // 0b11000000,
-	    224, // 0b11100000,
-	    240, // 0b11110000,
-	    248, // 0b11111000,
-	    252, // 0b11111100,
-	    254, // 0b11111110,
-	    255, // 0b11111111,
-	};
-
-public:
-public:
-	BitReader() : input(nullptr), index(0) {
-	}
-	uint8_t *input;
-	uint32_t index;
-
-public:
-	void SetStream(uint8_t *input) {
-		this->input = input;
-		index = 0;
-	}
-
-	inline uint8_t BitIndex() const {
-		return (index & 7);
-	}
-	inline uint64_t ByteIndex() const {
-		return (index >> 3);
-	}
-
-	inline uint8_t InnerReadByte(const uint8_t &offset) {
-		uint8_t result = static_cast<uint8_t>(input[ByteIndex() + offset] << BitIndex()) |
-		                 ((input[ByteIndex() + offset + 1] & REMAINDER_MASKS[8 + BitIndex()]) >> (8 - BitIndex()));
-		return result;
-	}
-
-	//! index: 4
-	//! size: 7
-	//! input: [12345678][12345678]
-	//! result:   [-AAAA  BBB]
-	//!
-	//! Result contains 4 bits from the first byte (making up the most significant bits)
-	//! And 3 bits from the second byte (the least significant bits)
-	inline uint8_t InnerRead(const uint8_t &size, const uint8_t &offset) {
-		const uint8_t right_shift = 8 - size;
-		const uint8_t bit_remainder = (8 - ((size + BitIndex()) - 8)) & 7;
-		// The least significant bits are positioned at the far right of the byte
-
-		// Create a mask given the size and index
-		// Take the first byte
-		// Left-shift it by index, to line up the bits we're interested in with the mask
-		// Get the mask for the given size
-		// Bit-wise AND the byte and the mask together
-		// Right-shift this result (the most significant bits)
-
-		// Sometimes we will need to read from the second byte
-		// But to make this branchless, we will perform what is basically a no-op if this condition is not true
-		// SPILL = (index + size >= 8)
-		//
-		// If SPILL is true:
-		// The REMAINDER_MASKS gives us the mask for the bits we're interested in
-		// We bit-wise AND these together (no need to shift anything because the index is essentially zero for this new
-		// byte) And we then right-shift these bits in place (to the right of the previous bits)
-		const bool spill_to_next_byte = (size + BitIndex() >= 8);
-		uint8_t result =
-		    ((input[ByteIndex() + offset] << BitIndex()) & MASKS[size]) >> right_shift |
-		    ((input[ByteIndex() + offset + spill_to_next_byte] & REMAINDER_MASKS[size + BitIndex()]) >> bit_remainder);
-		return result;
-	}
-
-	template <class T, uint8_t BYTES>
-	inline T ReadBytes(const uint8_t &remainder) {
-		T result = 0;
-		if (BYTES > 0) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(0));
-		}
-		if (BYTES > 1) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(1));
-		}
-		if (BYTES > 2) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(2));
-		}
-		if (BYTES > 3) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(3));
-		}
-		if (BYTES > 4) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(4));
-		}
-		if (BYTES > 5) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(5));
-		}
-		if (BYTES > 6) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(6));
-		}
-		if (BYTES > 7) {
-			result = UnsafeNumericCast<T>(result << 8 | InnerReadByte(7));
-		}
-		result = UnsafeNumericCast<T>(result << remainder | InnerRead(remainder, BYTES));
-		index += (BYTES << 3) + remainder;
-		return result;
-	}
-
-	template <class T>
-	inline T ReadBytes(const uint8_t &bytes, const uint8_t &remainder) {
-		T result = 0;
-		for (uint8_t i = 0; i < bytes; i++) {
-			result = result << 8 | InnerReadByte(i);
-		}
-		result = result << remainder | InnerRead(remainder, bytes);
-		index += static_cast<uint32_t>(bytes << 3) + remainder;
-		return result;
-	}
-
-	template <class T, uint8_t SIZE>
-	inline T ReadValue() {
-		constexpr uint8_t BYTES = (SIZE >> 3);
-		constexpr uint8_t REMAINDER = (SIZE & 7);
-		return ReadBytes<T, BYTES>(REMAINDER);
-	}
-
-	template <class T>
-	inline T ReadValue(const uint8_t &size) {
-		const uint8_t bytes = size >> 3; // divide by 8;
-		const uint8_t remainder = size & 7;
-		return ReadBytes<T>(bytes, remainder);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_utils.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_utils.hpp
deleted file mode 100644
index f75571c60..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_utils.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/algorithm/bit_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-template <class R>
-struct BitUtils {
-	static constexpr R Mask(unsigned int const bits) {
-		return UnsafeNumericCast<R>((((uint64_t)(bits < (sizeof(R) * 8))) << (bits & ((sizeof(R) * 8) - 1))) - 1U);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_reader.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_reader.hpp
deleted file mode 100644
index fae2fb037..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_reader.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/algorithm/byte_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-class ByteReader {
-public:
-	ByteReader() : buffer(nullptr), index(0) {
-	}
-
-public:
-	void SetStream(const uint8_t *buffer) {
-		this->buffer = buffer;
-		index = 0;
-	}
-
-	size_t Index() const {
-		return index;
-	}
-
-	template <class T>
-	T ReadValue() {
-		auto result = Load<T>(buffer + index);
-		index += sizeof(T);
-		return result;
-	}
-
-	template <class T, uint8_t SIZE>
-	T ReadValue() {
-		return ReadValue<T>(SIZE);
-	}
-
-	template <class T>
-	inline T ReadValue(uint8_t bytes, uint8_t trailing_zero) {
-		T result = 0;
-		switch (bytes) {
-			// LCOV_EXCL_START
-		case 1:
-			result = Load<uint8_t>(buffer + index);
-			index++;
-			return result;
-		case 2:
-			result = Load<uint16_t>(buffer + index);
-			index += 2;
-			return result;
-		case 3:
-			memcpy(&result, (void *)(buffer + index), 3);
-			index += 3;
-			return result;
-		case 4:
-			result = Load<uint32_t>(buffer + index);
-			index += 4;
-			return result;
-		case 5:
-			memcpy(&result, (void *)(buffer + index), 5);
-			index += 5;
-			return result;
-		case 6:
-			memcpy(&result, (void *)(buffer + index), 6);
-			index += 6;
-			return result;
-		case 7:
-			memcpy(&result, (void *)(buffer + index), 7);
-			index += 7;
-			return result;
-			// LCOV_EXCL_STOP
-		default:
-			if (trailing_zero < 8) {
-				result = Load<T>(buffer + index);
-				index += sizeof(T);
-				return result;
-			}
-			return result;
-		}
-	}
-
-private:
-	const uint8_t *buffer;
-	uint32_t index;
-};
-
-template <>
-inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
-	uint32_t result = 0;
-	switch (bytes) {
-	case 0:
-		// LCOV_EXCL_START
-		if (trailing_zero < 8) {
-			result = Load<uint32_t>(buffer + index);
-			index += sizeof(uint32_t);
-			return result;
-		}
-		return result;
-	case 1:
-		result = Load<uint8_t>(buffer + index);
-		index++;
-		return result;
-	case 2:
-		result = Load<uint16_t>(buffer + index);
-		index += 2;
-		return result;
-	case 3:
-		memcpy(&result, (void *)(buffer + index), 3);
-		index += 3;
-		return result;
-	case 4:
-		result = Load<uint32_t>(buffer + index);
-		index += 4;
-		return result;
-		// LCOV_EXCL_STOP
-	default:
-		throw InternalException("Write of %llu bytes attempted into address pointing to 4 byte value", bytes);
-	}
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_writer.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_writer.hpp
deleted file mode 100644
index 76e1e3156..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_writer.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/algorithm/byte_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-template <bool EMPTY>
-class ByteWriter {
-public:
-	ByteWriter() : buffer(nullptr), index(0) {
-	}
-
-public:
-	idx_t BytesWritten() const {
-		return index;
-	}
-
-	void Flush() {
-	}
-
-	void ByteAlign() {
-	}
-
-	void SetStream(uint8_t *buffer) {
-		this->buffer = buffer;
-		this->index = 0;
-	}
-
-	template <class T, uint8_t SIZE>
-	void WriteValue(const T &value) {
-		const uint8_t bytes = (SIZE >> 3) + ((SIZE & 7) != 0);
-		if (!EMPTY) {
-			memcpy((void *)(buffer + index), &value, bytes);
-		}
-		index += bytes;
-	}
-
-	template <class T>
-	void WriteValue(const T &value, const uint8_t &size) {
-		const uint8_t bytes = (size >> 3) + ((size & 7) != 0);
-		if (!EMPTY) {
-			memcpy((void *)(buffer + index), &value, bytes);
-		}
-		index += bytes;
-	}
-
-private:
-private:
-	uint8_t *buffer;
-	idx_t index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp128.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp128.hpp
deleted file mode 100644
index 277e30b6a..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp128.hpp
+++ /dev/null
@@ -1,293 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/algorithm/chimp128.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/ring_buffer.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/packed_data.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/bit_utils.hpp"
-
-#include "duckdb/storage/compression/chimp/algorithm/bit_reader.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/output_bit_stream.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Compression
-//===--------------------------------------------------------------------===//
-
-template <class CHIMP_TYPE, bool EMPTY>
-struct Chimp128CompressionState {
-
-	Chimp128CompressionState() : ring_buffer(), previous_leading_zeros(NumericLimits<uint8_t>::Maximum()) {
-		previous_value = 0;
-	}
-
-	inline void SetLeadingZeros(int32_t value = NumericLimits<uint8_t>::Maximum()) {
-		this->previous_leading_zeros = value;
-	}
-
-	void Flush() {
-		leading_zero_buffer.Flush();
-	}
-
-	// Reset the state
-	void Reset() {
-		first = true;
-		ring_buffer.Reset();
-		SetLeadingZeros();
-		leading_zero_buffer.Reset();
-		flag_buffer.Reset();
-		packed_data_buffer.Reset();
-		previous_value = 0;
-	}
-
-	CHIMP_TYPE BitsWritten() const {
-		return output.BitsWritten() + leading_zero_buffer.BitsWritten() + flag_buffer.BitsWritten() +
-		       (packed_data_buffer.index * 16);
-	}
-
-	OutputBitStream<EMPTY> output; // The stream to write to
-	LeadingZeroBuffer<EMPTY> leading_zero_buffer;
-	FlagBuffer<EMPTY> flag_buffer;
-	PackedDataBuffer<EMPTY> packed_data_buffer;
-	RingBuffer<CHIMP_TYPE> ring_buffer; //! The ring buffer that holds the previous values
-	uint8_t previous_leading_zeros;     //! The leading zeros of the reference value
-	CHIMP_TYPE previous_value = 0;
-	bool first = true;
-};
-
-template <class CHIMP_TYPE, bool EMPTY>
-class Chimp128Compression {
-public:
-	using State = Chimp128CompressionState<CHIMP_TYPE, EMPTY>;
-
-	//! The amount of bits needed to store an index between 0-127
-	static constexpr uint8_t INDEX_BITS_SIZE = 7;
-	static constexpr uint8_t BIT_SIZE = sizeof(CHIMP_TYPE) * 8;
-
-	static constexpr uint8_t TRAILING_ZERO_THRESHOLD = SignificantBits<CHIMP_TYPE>::size + INDEX_BITS_SIZE;
-
-	static void Store(CHIMP_TYPE in, State &state) {
-		if (state.first) {
-			WriteFirst(in, state);
-		} else {
-			CompressValue(in, state);
-		}
-	}
-
-	//! Write the content of the bit buffer to the stream
-	static void Flush(State &state) {
-		if (!EMPTY) {
-			state.output.Flush();
-		}
-	}
-
-	static void WriteFirst(CHIMP_TYPE in, State &state) {
-		state.ring_buffer.template Insert<true>(in);
-		state.output.template WriteValue<CHIMP_TYPE, BIT_SIZE>(in);
-		state.previous_value = in;
-		state.first = false;
-	}
-
-	static void CompressValue(CHIMP_TYPE in, State &state) {
-
-		auto key = state.ring_buffer.Key(in);
-		CHIMP_TYPE xor_result;
-		uint8_t previous_index;
-		uint32_t trailing_zeros = 0;
-		bool trailing_zeros_exceed_threshold = false;
-		const CHIMP_TYPE reference_index = state.ring_buffer.IndexOf(key);
-
-		// Find the reference value to use when compressing the current value
-		if (((int64_t)state.ring_buffer.Size() - (int64_t)reference_index) < (int64_t)ChimpConstants::BUFFER_SIZE) {
-			// The reference index is within 128 values, we can use it
-			auto current_index = state.ring_buffer.IndexOf(key);
-			if (current_index > state.ring_buffer.Size()) {
-				current_index = 0;
-			}
-			auto reference_value = state.ring_buffer.Value(current_index % ChimpConstants::BUFFER_SIZE);
-			CHIMP_TYPE tempxor_result = (CHIMP_TYPE)in ^ reference_value;
-			trailing_zeros = CountZeros<CHIMP_TYPE>::Trailing(tempxor_result);
-			trailing_zeros_exceed_threshold = trailing_zeros > TRAILING_ZERO_THRESHOLD;
-			if (trailing_zeros_exceed_threshold) {
-				previous_index = current_index % ChimpConstants::BUFFER_SIZE;
-				xor_result = tempxor_result;
-			} else {
-				previous_index = state.ring_buffer.Size() % ChimpConstants::BUFFER_SIZE;
-				xor_result = (CHIMP_TYPE)in ^ state.ring_buffer.Value(previous_index);
-			}
-		} else {
-			// Reference index is not in range, use the directly previous value
-			previous_index = state.ring_buffer.Size() % ChimpConstants::BUFFER_SIZE;
-			xor_result = (CHIMP_TYPE)in ^ state.ring_buffer.Value(previous_index);
-		}
-
-		// Compress the value
-		if (xor_result == 0) {
-			state.flag_buffer.Insert(ChimpConstants::Flags::VALUE_IDENTICAL);
-			state.output.template WriteValue<uint8_t, INDEX_BITS_SIZE>(previous_index);
-			state.SetLeadingZeros();
-		} else {
-			// Values are not identical
-			auto leading_zeros_raw = CountZeros<CHIMP_TYPE>::Leading(xor_result);
-			uint8_t leading_zeros = ChimpConstants::Compression::LEADING_ROUND[leading_zeros_raw];
-
-			if (trailing_zeros_exceed_threshold) {
-				state.flag_buffer.Insert(ChimpConstants::Flags::TRAILING_EXCEEDS_THRESHOLD);
-				uint32_t significant_bits = BIT_SIZE - leading_zeros - trailing_zeros;
-				auto result = PackedDataUtils<CHIMP_TYPE>::Pack(
-				    reference_index, ChimpConstants::Compression::LEADING_REPRESENTATION[leading_zeros],
-				    significant_bits);
-				state.packed_data_buffer.Insert(result & 0xFFFF);
-				state.output.template WriteValue<CHIMP_TYPE>(xor_result >> trailing_zeros, significant_bits);
-				state.SetLeadingZeros();
-			} else if (leading_zeros == state.previous_leading_zeros) {
-				state.flag_buffer.Insert(ChimpConstants::Flags::LEADING_ZERO_EQUALITY);
-				int32_t significant_bits = BIT_SIZE - leading_zeros;
-				state.output.template WriteValue<CHIMP_TYPE>(xor_result, significant_bits);
-			} else {
-				state.flag_buffer.Insert(ChimpConstants::Flags::LEADING_ZERO_LOAD);
-				const int32_t significant_bits = BIT_SIZE - leading_zeros;
-				state.leading_zero_buffer.Insert(ChimpConstants::Compression::LEADING_REPRESENTATION[leading_zeros]);
-				state.output.template WriteValue<CHIMP_TYPE>(xor_result, significant_bits);
-				state.SetLeadingZeros(leading_zeros);
-			}
-		}
-		state.previous_value = in;
-		state.ring_buffer.Insert(in);
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Decompression
-//===--------------------------------------------------------------------===//
-
-template <class CHIMP_TYPE>
-struct Chimp128DecompressionState {
-public:
-	Chimp128DecompressionState() : reference_value(0), first(true) {
-		ResetZeros();
-	}
-
-	void Reset() {
-		ResetZeros();
-		reference_value = 0;
-		ring_buffer.Reset();
-		first = true;
-	}
-
-	inline void ResetZeros() {
-		leading_zeros = NumericLimits<uint8_t>::Maximum();
-		trailing_zeros = 0;
-	}
-
-	inline void SetLeadingZeros(uint8_t value) {
-		leading_zeros = value;
-	}
-
-	inline void SetTrailingZeros(uint8_t value) {
-		D_ASSERT(value <= sizeof(CHIMP_TYPE) * 8);
-		trailing_zeros = value;
-	}
-
-	uint8_t LeadingZeros() const {
-		return leading_zeros;
-	}
-	uint8_t TrailingZeros() const {
-		return trailing_zeros;
-	}
-
-	BitReader input;
-	uint8_t leading_zeros;
-	uint8_t trailing_zeros;
-	CHIMP_TYPE reference_value = 0;
-	RingBuffer<CHIMP_TYPE> ring_buffer;
-
-	bool first;
-};
-
-template <class CHIMP_TYPE>
-struct Chimp128Decompression {
-public:
-	using DecompressState = Chimp128DecompressionState<CHIMP_TYPE>;
-
-	static constexpr uint8_t INDEX_BITS_SIZE = 7;
-	static constexpr uint8_t BIT_SIZE = sizeof(CHIMP_TYPE) * 8;
-
-	static inline void UnpackPackedData(uint16_t packed_data, UnpackedData &dest) {
-		return PackedDataUtils<CHIMP_TYPE>::Unpack(packed_data, dest);
-	}
-
-	static inline CHIMP_TYPE Load(ChimpConstants::Flags flag, uint8_t leading_zeros[], uint32_t &leading_zero_index,
-	                              UnpackedData unpacked_data[], uint32_t &unpacked_index, DecompressState &state) {
-		if (DUCKDB_UNLIKELY(state.first)) {
-			return LoadFirst(state);
-		} else {
-			return DecompressValue(flag, leading_zeros, leading_zero_index, unpacked_data, unpacked_index, state);
-		}
-	}
-
-	static inline CHIMP_TYPE LoadFirst(DecompressState &state) {
-		CHIMP_TYPE result = state.input.template ReadValue<CHIMP_TYPE, sizeof(CHIMP_TYPE) * 8>();
-		state.ring_buffer.template InsertScan<true>(result);
-		state.first = false;
-		state.reference_value = result;
-		return result;
-	}
-
-	static inline CHIMP_TYPE DecompressValue(ChimpConstants::Flags flag, uint8_t leading_zeros[],
-	                                         uint32_t &leading_zero_index, UnpackedData unpacked_data[],
-	                                         uint32_t &unpacked_index, DecompressState &state) {
-		CHIMP_TYPE result;
-		switch (flag) {
-		case ChimpConstants::Flags::VALUE_IDENTICAL: {
-			//! Value is identical to previous value
-			auto index = state.input.template ReadValue<uint8_t, 7>();
-			result = UnsafeNumericCast<CHIMP_TYPE>(state.ring_buffer.Value(index));
-			break;
-		}
-		case ChimpConstants::Flags::TRAILING_EXCEEDS_THRESHOLD: {
-			const UnpackedData &unpacked = unpacked_data[unpacked_index++];
-			state.leading_zeros = unpacked.leading_zero;
-			state.trailing_zeros = BIT_SIZE - unpacked.significant_bits - state.leading_zeros;
-			result = state.input.template ReadValue<CHIMP_TYPE>(unpacked.significant_bits);
-			result <<= state.trailing_zeros;
-			result ^= state.ring_buffer.Value(unpacked.index);
-			break;
-		}
-		case ChimpConstants::Flags::LEADING_ZERO_EQUALITY: {
-			result = state.input.template ReadValue<CHIMP_TYPE>(BIT_SIZE - state.leading_zeros);
-			result ^= state.reference_value;
-			break;
-		}
-		case ChimpConstants::Flags::LEADING_ZERO_LOAD: {
-			state.leading_zeros = leading_zeros[leading_zero_index++];
-			D_ASSERT(state.leading_zeros <= BIT_SIZE);
-			result = state.input.template ReadValue<CHIMP_TYPE>(BIT_SIZE - state.leading_zeros);
-			result ^= state.reference_value;
-			break;
-		}
-		default:
-			throw InternalException("Chimp compression flag with value %d not recognized", flag);
-		}
-		state.reference_value = result;
-		state.ring_buffer.InsertScan(result);
-		return result;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp
deleted file mode 100644
index 9318c4845..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-
-namespace duckdb {
-
-template <class T>
-struct SignificantBits {};
-
-template <>
-struct SignificantBits<uint64_t> {
-	static constexpr uint8_t size = 6;
-	static constexpr uint8_t mask = ((uint8_t)1 << size) - 1;
-};
-
-template <>
-struct SignificantBits<uint32_t> {
-	static constexpr uint8_t size = 5;
-	static constexpr uint8_t mask = ((uint8_t)1 << size) - 1;
-};
-
-struct ChimpConstants {
-	struct Compression {
-		static constexpr uint8_t LEADING_ROUND[] = {0,  0,  0,  0,  0,  0,  0,  0,  8,  8,  8,  8,  12, 12, 12, 12,
-		                                            16, 16, 18, 18, 20, 20, 22, 22, 24, 24, 24, 24, 24, 24, 24, 24,
-		                                            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-		                                            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24};
-		static constexpr uint8_t LEADING_REPRESENTATION[] = {
-		    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
-		    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
-	};
-	struct Decompression {
-		static constexpr uint8_t LEADING_REPRESENTATION[] = {0, 8, 12, 16, 18, 20, 22, 24};
-	};
-	static constexpr uint8_t BUFFER_SIZE = 128;
-	enum class Flags : uint8_t {
-		VALUE_IDENTICAL = 0,
-		TRAILING_EXCEEDS_THRESHOLD = 1,
-		LEADING_ZERO_EQUALITY = 2,
-		LEADING_ZERO_LOAD = 3
-	};
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp
deleted file mode 100644
index f5c0d70ba..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/flag_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-#ifdef DEBUG
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/assert.hpp"
-#endif
-
-namespace duckdb {
-
-struct FlagBufferConstants {
-	static constexpr uint8_t MASKS[4] = {
-	    192, // 0b1100 0000,
-	    48,  // 0b0011 0000,
-	    12,  // 0b0000 1100,
-	    3,   // 0b0000 0011,
-	};
-
-	static constexpr uint8_t SHIFTS[4] = {6, 4, 2, 0};
-};
-
-// This class is responsible for writing and reading the flag bits
-// Only the last group is potentially not 1024 (GROUP_SIZE) values in size
-// But we can determine from the count of the segment whether this is the case or not
-// So we can just read/write from left to right
-template <bool EMPTY>
-class FlagBuffer {
-
-public:
-	FlagBuffer() : counter(0), buffer(nullptr) {
-	}
-
-public:
-	void SetBuffer(uint8_t *buffer) {
-		this->buffer = buffer;
-		this->counter = 0;
-	}
-	void Reset() {
-		this->counter = 0;
-#ifdef DEBUG
-		this->flags.clear();
-#endif
-	}
-
-#ifdef DEBUG
-	uint8_t ExtractValue(uint32_t value, uint8_t index) {
-		return (value & FlagBufferConstants::MASKS[index]) >> FlagBufferConstants::SHIFTS[index];
-	}
-#endif
-
-	uint64_t BitsWritten() const {
-		return counter * 2ULL;
-	}
-
-	void Insert(ChimpConstants::Flags value) {
-		if (!EMPTY) {
-			if ((counter & 3) == 0) {
-				// Start the new byte fresh
-				buffer[counter >> 2] = 0;
-#ifdef DEBUG
-				flags.clear();
-#endif
-			}
-#ifdef DEBUG
-			flags.push_back((uint8_t)value);
-#endif
-			buffer[counter >> 2] |= (((uint8_t)value & 3) << FlagBufferConstants::SHIFTS[counter & 3]);
-#ifdef DEBUG
-			// Verify that the bits are serialized correctly
-			D_ASSERT(flags[counter & 3] == ExtractValue(buffer[counter >> 2], counter & 3));
-#endif
-		}
-		counter++;
-	}
-	inline uint8_t Extract() {
-		const uint8_t result = (buffer[counter >> 2] & FlagBufferConstants::MASKS[counter & 3]) >>
-		                       FlagBufferConstants::SHIFTS[counter & 3];
-		counter++;
-		return result;
-	}
-
-	uint32_t BytesUsed() const {
-		return (counter >> 2) + ((counter & 3) != 0);
-	}
-
-	uint32_t FlagCount() const {
-		return counter;
-	}
-
-private:
-private:
-	uint32_t counter = 0;
-	uint8_t *buffer;
-#ifdef DEBUG
-	vector<uint8_t> flags;
-#endif
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp
deleted file mode 100644
index c4b23cfd9..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/leading_zero_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#ifdef DEBUG
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/assert.hpp"
-#endif
-
-namespace duckdb {
-
-//! This class is in charge of storing the leading_zero_bits, which are of a fixed size
-//! These are packed together so that the rest of the data can be byte-aligned
-//! The leading zero bit data is read from left to right
-
-struct LeadingZeroBufferConstants {
-	static constexpr uint32_t MASKS[8] = {
-	    7,        // 0b 00000000 00000000 00000000 00000111,
-	    56,       // 0b 00000000 00000000 00000000 00111000,
-	    448,      // 0b 00000000 00000000 00000001 11000000,
-	    3584,     // 0b 00000000 00000000 00001110 00000000,
-	    28672,    // 0b 00000000 00000000 01110000 00000000,
-	    229376,   // 0b 00000000 00000011 10000000 00000000,
-	    1835008,  // 0b 00000000 00011100 00000000 00000000,
-	    14680064, // 0b 00000000 11100000 00000000 00000000,
-	};
-
-	// We're not using the last byte (the most significant) of the 4 bytes we're accessing
-	static constexpr uint8_t SHIFTS[8] = {0, 3, 6, 9, 12, 15, 18, 21};
-};
-
-template <bool EMPTY>
-class LeadingZeroBuffer {
-
-public:
-	static constexpr uint32_t CHIMP_GROUP_SIZE = 1024;
-	static constexpr uint32_t LEADING_ZERO_BITS_SIZE = 3;
-	static constexpr uint32_t LEADING_ZERO_BLOCK_SIZE = 8;
-	static constexpr uint32_t LEADING_ZERO_BLOCK_BIT_SIZE = LEADING_ZERO_BLOCK_SIZE * LEADING_ZERO_BITS_SIZE;
-	static constexpr uint32_t MAX_LEADING_ZERO_BLOCKS = CHIMP_GROUP_SIZE / LEADING_ZERO_BLOCK_SIZE;
-	static constexpr uint32_t MAX_BITS_USED_BY_ZERO_BLOCKS = MAX_LEADING_ZERO_BLOCKS * LEADING_ZERO_BLOCK_BIT_SIZE;
-	static constexpr uint32_t MAX_BYTES_USED_BY_ZERO_BLOCKS = MAX_BITS_USED_BY_ZERO_BLOCKS / 8;
-
-	// Add an extra byte to prevent heap buffer overflow on the last group, because we'll be addressing 4 bytes each
-	static constexpr uint32_t BUFFER_SIZE =
-	    MAX_BYTES_USED_BY_ZERO_BLOCKS + (sizeof(uint32_t) - (LEADING_ZERO_BLOCK_BIT_SIZE / 8));
-
-	template <typename T>
-	const T Load(const uint8_t *ptr) {
-		T ret;
-		memcpy(&ret, ptr, sizeof(ret));
-		return ret;
-	}
-
-public:
-	LeadingZeroBuffer() : current(0), counter(0), buffer(nullptr) {
-	}
-	void SetBuffer(uint8_t *buffer) {
-		// Set the internal buffer, when inserting this should be BUFFER_SIZE bytes in length
-		// This buffer does not need to be zero-initialized for inserting
-		this->buffer = buffer;
-		this->counter = 0;
-	}
-	void Flush() {
-		if ((counter & 7) != 0) {
-			FlushBuffer();
-		}
-	}
-
-	uint64_t BitsWritten() const {
-		return counter * 3ULL;
-	}
-
-	// Reset the counter, but don't replace the buffer
-	void Reset() {
-		this->counter = 0;
-		current = 0;
-#ifdef DEBUG
-		flags.clear();
-#endif
-	}
-
-public:
-#ifdef DEBUG
-	uint8_t ExtractValue(uint32_t value, uint8_t index) {
-		return NumericCast<uint8_t>((value & LeadingZeroBufferConstants::MASKS[index]) >>
-		                            LeadingZeroBufferConstants::SHIFTS[index]);
-	}
-#endif
-
-	inline uint64_t BlockIndex() const {
-		return ((counter >> 3ULL) * (LEADING_ZERO_BLOCK_BIT_SIZE / 8ULL));
-	}
-
-	void FlushBuffer() {
-		if (EMPTY) {
-			return;
-		}
-		const auto buffer_idx = BlockIndex();
-		memcpy((void *)(buffer + buffer_idx), (uint8_t *)&current, 3);
-#ifdef DEBUG
-		// Verify that the bits are copied correctly
-
-		uint32_t temp_value = 0;
-		memcpy(reinterpret_cast<uint8_t *>(&temp_value), (void *)(buffer + buffer_idx), 3);
-		for (idx_t i = 0; i < flags.size(); i++) {
-			D_ASSERT(flags[i] == ExtractValue(temp_value, i));
-		}
-		flags.clear();
-#endif
-	}
-
-	void Insert(const uint8_t &value) {
-		if (!EMPTY) {
-#ifdef DEBUG
-			flags.push_back(value);
-#endif
-			current |= (value & 7) << LeadingZeroBufferConstants::SHIFTS[counter & 7];
-#ifdef DEBUG
-			// Verify that the bits are serialized correctly
-			D_ASSERT(flags[counter & 7] == ExtractValue(current, counter & 7));
-#endif
-
-			if ((counter & (LEADING_ZERO_BLOCK_SIZE - 1)) == 7) {
-				FlushBuffer();
-				current = 0;
-			}
-		}
-		counter++;
-	}
-
-	inline uint8_t Extract() {
-		const auto buffer_idx = BlockIndex();
-		auto const temp = Load<uint32_t>(buffer + buffer_idx);
-
-		const uint8_t result = UnsafeNumericCast<uint8_t>((temp & LeadingZeroBufferConstants::MASKS[counter & 7]) >>
-		                                                  LeadingZeroBufferConstants::SHIFTS[counter & 7]);
-		counter++;
-		return result;
-	}
-	idx_t GetCount() const {
-		return counter;
-	}
-	idx_t BlockCount() const {
-		return (counter >> 3) + ((counter & 7) != 0);
-	}
-
-private:
-private:
-	uint32_t current;
-	uint32_t counter = 0; // block_index * 8
-	uint8_t *buffer;
-#ifdef DEBUG
-	vector<uint8_t> flags;
-#endif
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/output_bit_stream.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/output_bit_stream.hpp
deleted file mode 100644
index 3364e3220..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/output_bit_stream.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/output_bit_stream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.h"
-#include "duckdb/common/assert.hpp"
-
-#include "duckdb/storage/compression/chimp/algorithm/bit_utils.hpp"
-
-namespace duckdb {
-
-// This class writes arbitrary amounts of bits to a stream
-// The way these bits are written is most-significant bit first
-// For example if 6 bits are given as:    0b0011 1111
-// The bits are written to the stream as: 0b1111 1100
-template <bool EMPTY>
-class OutputBitStream {
-	using INTERNAL_TYPE = uint8_t;
-
-public:
-	friend class BitStreamWriter;
-	friend class EmptyWriter;
-	OutputBitStream()
-	    : stream(nullptr), current(0), free_bits(INTERNAL_TYPE_BITSIZE), stream_index(0), bits_written(0) {
-	}
-
-public:
-	static constexpr uint8_t INTERNAL_TYPE_BITSIZE = sizeof(INTERNAL_TYPE) * 8;
-
-	idx_t BytesWritten() const {
-		return (bits_written >> 3) + ((bits_written & 7) != 0);
-	}
-
-	idx_t BitsWritten() const {
-		return bits_written;
-	}
-
-	void Flush() {
-		if (free_bits == INTERNAL_TYPE_BITSIZE) {
-			// the bit buffer is empty, nothing to write
-			return;
-		}
-		WriteToStream();
-	}
-
-	void SetStream(uint8_t *output_stream) {
-		stream = output_stream;
-		stream_index = 0;
-		bits_written = 0;
-		free_bits = INTERNAL_TYPE_BITSIZE;
-		current = 0;
-	}
-
-	uint64_t *Stream() {
-		return (uint64_t *)stream;
-	}
-
-	idx_t BitSize() const {
-		return (stream_index * INTERNAL_TYPE_BITSIZE) + (INTERNAL_TYPE_BITSIZE - free_bits);
-	}
-
-	template <class T>
-	void WriteRemainder(T value, uint8_t i) {
-		if (sizeof(T) * 8 > 32) {
-			if (i == 64) {
-				WriteToStream(((uint64_t)value >> 56) & 0xFF);
-			}
-			if (i > 55) {
-				WriteToStream(((uint64_t)value >> 48) & 0xFF);
-			}
-			if (i > 47) {
-				WriteToStream(((uint64_t)value >> 40) & 0xFF);
-			}
-			if (i > 39) {
-				WriteToStream(((uint64_t)value >> 32) & 0xFF);
-			}
-		}
-		if (i > 31) {
-			WriteToStream((value >> 24) & 0xFF);
-		}
-		if (i > 23) {
-			WriteToStream((value >> 16) & 0xFF);
-		}
-		if (i > 15) {
-			WriteToStream((value >> 8) & 0xFF);
-		}
-		if (i > 7) {
-			WriteToStream(value);
-		}
-	}
-
-	template <class T, uint8_t VALUE_SIZE>
-	void WriteValue(T value) {
-		bits_written += VALUE_SIZE;
-		if (EMPTY) {
-			return;
-		}
-		if (FitsInCurrent(VALUE_SIZE)) {
-			//! If we can write the entire value in one go
-			WriteInCurrent<VALUE_SIZE>((INTERNAL_TYPE)value);
-			return;
-		}
-		auto i = VALUE_SIZE - free_bits;
-		const uint8_t queue = i & 7;
-
-		if (free_bits != 0) {
-			// Reset the number of free bits
-			WriteInCurrent(value >> i, free_bits);
-		}
-		if (queue != 0) {
-			// We dont fill the entire 'current' buffer,
-			// so we can write these to 'current' first without flushing to the stream
-			// And then write the remaining bytes directly to the stream
-			i -= queue;
-			WriteInCurrent((INTERNAL_TYPE)value, queue);
-			value >>= queue;
-		}
-		WriteRemainder<T>(value, i);
-	}
-
-	template <class T>
-	void WriteValue(T value, const uint8_t &value_size) {
-		bits_written += value_size;
-		if (EMPTY) {
-			return;
-		}
-		if (FitsInCurrent(value_size)) {
-			//! If we can write the entire value in one go
-			WriteInCurrent((INTERNAL_TYPE)value, value_size);
-			return;
-		}
-		auto i = value_size - free_bits;
-		const uint8_t queue = i & 7;
-
-		if (free_bits != 0) {
-			// Reset the number of free bits
-			WriteInCurrent(value >> i, free_bits);
-		}
-		if (queue != 0) {
-			// We dont fill the entire 'current' buffer,
-			// so we can write these to 'current' first without flushing to the stream
-			// And then write the remaining bytes directly to the stream
-			i -= queue;
-			WriteInCurrent((INTERNAL_TYPE)value, queue);
-			value >>= queue;
-		}
-		WriteRemainder<T>(value, i);
-	}
-
-private:
-	void WriteBit(bool value) {
-		auto &byte = GetCurrentByte();
-		if (value) {
-			byte = byte | GetMask();
-		}
-		DecreaseFreeBits();
-	}
-
-	bool FitsInCurrent(uint8_t bits) {
-		return free_bits >= bits;
-	}
-	INTERNAL_TYPE GetMask() const {
-		return (INTERNAL_TYPE)1 << free_bits;
-	}
-
-	INTERNAL_TYPE &GetCurrentByte() {
-		return current;
-	}
-	//! Write a value of type INTERNAL_TYPE directly to the stream
-	void WriteToStream(INTERNAL_TYPE value) {
-		stream[stream_index++] = value;
-	}
-	void WriteToStream() {
-		stream[stream_index++] = current;
-		current = 0;
-		free_bits = INTERNAL_TYPE_BITSIZE;
-	}
-	void DecreaseFreeBits(uint8_t value = 1) {
-		D_ASSERT(free_bits >= value);
-		free_bits -= value;
-		if (free_bits == 0) {
-			WriteToStream();
-		}
-	}
-	void WriteInCurrent(INTERNAL_TYPE value, uint8_t value_size) {
-		D_ASSERT(INTERNAL_TYPE_BITSIZE >= value_size);
-		const auto shift_amount = free_bits - value_size;
-		current |= (value & BitUtils<INTERNAL_TYPE>::Mask(value_size)) << shift_amount;
-		DecreaseFreeBits(value_size);
-	}
-
-	template <uint8_t VALUE_SIZE = INTERNAL_TYPE_BITSIZE>
-	void WriteInCurrent(INTERNAL_TYPE value) {
-		D_ASSERT(INTERNAL_TYPE_BITSIZE >= VALUE_SIZE);
-		const auto shift_amount = free_bits - VALUE_SIZE;
-		current |= (value & BitUtils<INTERNAL_TYPE>::Mask(VALUE_SIZE)) << shift_amount;
-		DecreaseFreeBits(VALUE_SIZE);
-	}
-
-private:
-	uint8_t *stream; //! The stream we're writing our output to
-
-	INTERNAL_TYPE current; //! The current value we're writing into (zero-initialized)
-	uint8_t free_bits;     //! How many bits are still unwritten in 'current'
-	idx_t stream_index;    //! Index used to keep track of which index we're at in the stream
-
-	idx_t bits_written; //! The total amount of bits written to this stream
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/packed_data.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/packed_data.hpp
deleted file mode 100644
index 932719ded..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/packed_data.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/packed_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-#include "duckdb.h"
-
-namespace duckdb {
-
-struct UnpackedData {
-	uint8_t leading_zero;
-	uint8_t significant_bits;
-	uint8_t index;
-};
-
-template <class CHIMP_TYPE>
-struct PackedDataUtils {
-private:
-	static constexpr uint8_t INDEX_BITS_SIZE = 7;
-	static constexpr uint8_t LEADING_BITS_SIZE = 3;
-
-	static constexpr uint8_t INDEX_MASK = ((uint8_t)1 << INDEX_BITS_SIZE) - 1;
-	static constexpr uint8_t LEADING_MASK = ((uint8_t)1 << LEADING_BITS_SIZE) - 1;
-
-	static constexpr uint8_t INDEX_SHIFT_AMOUNT = (sizeof(uint16_t) * 8) - INDEX_BITS_SIZE;
-	static constexpr uint8_t LEADING_SHIFT_AMOUNT = INDEX_SHIFT_AMOUNT - LEADING_BITS_SIZE;
-
-public:
-	//|----------------|	//! packed_data(16) bits
-	// IIIIIII				//! Index (7 bits, shifted by 9)
-	//        LLL			//! LeadingZeros (3 bits, shifted by 6)
-	//           SSSSSS 	//! SignificantBits (6 bits)
-	static inline void Unpack(uint16_t packed_data, UnpackedData &dest) {
-		dest.index = packed_data >> INDEX_SHIFT_AMOUNT & INDEX_MASK;
-		dest.leading_zero = packed_data >> LEADING_SHIFT_AMOUNT & LEADING_MASK;
-		dest.significant_bits = packed_data & SignificantBits<CHIMP_TYPE>::mask;
-		//  Verify that combined, this is not bigger than the full size of the type
-		D_ASSERT(dest.significant_bits + dest.leading_zero <= (sizeof(CHIMP_TYPE) * 8));
-	}
-
-	static inline uint16_t Pack(uint8_t index, uint8_t leading_zero, uint8_t significant_bits) {
-		static constexpr uint8_t BIT_SIZE = (sizeof(CHIMP_TYPE) * 8);
-
-		uint16_t result = 0;
-		result += ((uint32_t)BIT_SIZE << 3) * (ChimpConstants::BUFFER_SIZE + index);
-		result += BIT_SIZE * (leading_zero & 7);
-		if (BIT_SIZE == 32) {
-			// Shift the result by 1 to occupy the 16th bit
-			result <<= 1;
-		}
-		result += (significant_bits & 63);
-
-		return result;
-	}
-};
-
-template <bool EMPTY>
-struct PackedDataBuffer {
-public:
-	PackedDataBuffer() : index(0), buffer(nullptr) {
-	}
-
-public:
-	void SetBuffer(uint16_t *buffer) {
-		this->buffer = buffer;
-		this->index = 0;
-	}
-
-	void Reset() {
-		this->index = 0;
-	}
-
-	inline void Insert(uint16_t packed_data) {
-		if (!EMPTY) {
-			buffer[index] = packed_data;
-		}
-		index++;
-	}
-
-	idx_t index;
-	uint16_t *buffer;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/ring_buffer.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/ring_buffer.hpp
deleted file mode 100644
index 04980e926..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/ring_buffer.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/ring_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-
-namespace duckdb {
-
-template <class CHIMP_TYPE>
-class RingBuffer {
-public:
-	static constexpr uint8_t RING_SIZE = ChimpConstants::BUFFER_SIZE;
-	static constexpr uint64_t LEAST_SIGNIFICANT_BIT_COUNT = SignificantBits<CHIMP_TYPE>::size + 7 + 1;
-	static constexpr uint64_t LEAST_SIGNIFICANT_BIT_MASK = (1 << LEAST_SIGNIFICANT_BIT_COUNT) - 1;
-	static constexpr uint16_t INDICES_SIZE = 1 << LEAST_SIGNIFICANT_BIT_COUNT; // 16384
-
-public:
-	void Reset() {
-		index = 0;
-	}
-
-	RingBuffer() : index(0) {
-	}
-	template <bool FIRST = false>
-	void Insert(uint64_t value) {
-		if (!FIRST) {
-			index++;
-		}
-		buffer[index % RING_SIZE] = value;
-		indices[Key(value)] = index;
-	}
-	template <bool FIRST = false>
-	void InsertScan(uint64_t value) {
-		if (!FIRST) {
-			index++;
-		}
-		buffer[index % RING_SIZE] = value;
-	}
-	inline const uint64_t &Top() const {
-		return buffer[index % RING_SIZE];
-	}
-	//! Get the index where values that produce this 'key' are stored
-	inline const uint64_t &IndexOf(const uint64_t &key) const {
-		return indices[key];
-	}
-	//! Get the value at position 'index' of the buffer
-	inline const uint64_t &Value(const uint8_t &index_p) const {
-		return buffer[index_p];
-	}
-	//! Get the amount of values that are inserted
-	inline const uint64_t &Size() const {
-		return index;
-	}
-	inline uint64_t Key(const uint64_t &value) const {
-		return value & LEAST_SIGNIFICANT_BIT_MASK;
-	}
-
-private:
-	uint64_t buffer[RING_SIZE] = {};     //! Stores the corresponding values
-	uint64_t index = 0;                  //! Keeps track of the index of the current value
-	uint64_t indices[INDICES_SIZE] = {}; //! Stores the corresponding indices
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp.hpp
deleted file mode 100644
index 27de5c206..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/chimp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/algorithm/chimp128.hpp"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/function/compression_function.hpp"
-
-namespace duckdb {
-
-using byte_index_t = uint32_t;
-
-template <class T>
-struct ChimpType {};
-
-template <>
-struct ChimpType<double> {
-	using TYPE = uint64_t;
-};
-
-template <>
-struct ChimpType<float> {
-	using TYPE = uint32_t;
-};
-
-class ChimpPrimitives {
-public:
-	static constexpr uint32_t CHIMP_SEQUENCE_SIZE = 1024;
-	static constexpr uint8_t MAX_BYTES_PER_VALUE = sizeof(double) + 1; // extra wiggle room
-	static constexpr uint8_t HEADER_SIZE = sizeof(uint32_t);
-	static constexpr uint8_t FLAG_BIT_SIZE = 2;
-	static constexpr uint32_t LEADING_ZERO_BLOCK_BUFFERSIZE = 1 + (CHIMP_SEQUENCE_SIZE / 8) * 3;
-};
-
-//! Where all the magic happens
-template <class T, bool EMPTY>
-struct ChimpState {
-public:
-	using CHIMP_TYPE = typename ChimpType<T>::TYPE;
-
-	ChimpState() : chimp() {
-	}
-	Chimp128CompressionState<CHIMP_TYPE, EMPTY> chimp;
-
-public:
-	void AssignDataBuffer(uint8_t *data_out) {
-		chimp.output.SetStream(data_out);
-	}
-
-	void AssignFlagBuffer(uint8_t *flag_out) {
-		chimp.flag_buffer.SetBuffer(flag_out);
-	}
-
-	void AssignPackedDataBuffer(uint16_t *packed_data_out) {
-		chimp.packed_data_buffer.SetBuffer(packed_data_out);
-	}
-
-	void AssignLeadingZeroBuffer(uint8_t *leading_zero_out) {
-		chimp.leading_zero_buffer.SetBuffer(leading_zero_out);
-	}
-
-	void Flush() {
-		chimp.output.Flush();
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_analyze.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_analyze.hpp
deleted file mode 100644
index 4976e2ca8..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_analyze.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/chimp_analyze.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/chimp.hpp"
-#include "duckdb/function/compression_function.hpp"
-
-namespace duckdb {
-
-struct EmptyChimpWriter;
-
-template <class T>
-struct ChimpAnalyzeState : public AnalyzeState {};
-
-template <class T>
-unique_ptr<AnalyzeState> ChimpInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	// This compression type is deprecated
-	return nullptr;
-}
-
-template <class T>
-bool ChimpAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	throw InternalException("Chimp has been deprecated, can no longer be used to compress data");
-	return false;
-}
-
-template <class T>
-idx_t ChimpFinalAnalyze(AnalyzeState &state) {
-	throw InternalException("Chimp has been deprecated, can no longer be used to compress data");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp
deleted file mode 100644
index ae120027c..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/chimp_compress.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/chimp.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/chimp/chimp_analyze.hpp"
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-template <class T>
-struct ChimpCompressionState : public CompressionState {};
-
-// Compression Functions
-
-template <class T>
-unique_ptr<CompressionState> ChimpInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                  unique_ptr<AnalyzeState> state) {
-	throw InternalException("Chimp has been deprecated, can no longer be used to compress data");
-	return nullptr;
-}
-
-template <class T>
-void ChimpCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	throw InternalException("Chimp has been deprecated, can no longer be used to compress data");
-}
-
-template <class T>
-void ChimpFinalizeCompress(CompressionState &state_p) {
-	throw InternalException("Chimp has been deprecated, can no longer be used to compress data");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_fetch.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_fetch.hpp
deleted file mode 100644
index 5d6be51e6..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_fetch.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/chimp_fetch.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/chimp.hpp"
-#include "duckdb/storage/compression/chimp/chimp_scan.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-namespace duckdb {
-
-template <class T>
-void ChimpFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
-
-	ChimpScanState<T> scan_state(segment);
-	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
-	auto result_data = FlatVector::GetData<INTERNAL_TYPE>(result);
-
-	if (scan_state.GroupFinished() && scan_state.total_value_count < scan_state.segment_count) {
-		scan_state.LoadGroup(scan_state.group_state.values);
-	}
-	scan_state.group_state.Scan(&result_data[result_idx], 1);
-
-	scan_state.total_value_count++;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp
deleted file mode 100644
index de11979cb..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp
+++ /dev/null
@@ -1,293 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/chimp/chimp_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/chimp.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-#include "duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-template <class CHIMP_TYPE>
-struct ChimpGroupState {
-public:
-	void Init(uint8_t *data) {
-		chimp_state.input.SetStream(data);
-		Reset();
-	}
-
-	void Reset() {
-		chimp_state.Reset();
-		index = 0;
-	}
-
-	bool Started() const {
-		return !!index;
-	}
-
-	// Assuming the group is completely full
-	idx_t RemainingInGroup() const {
-		return ChimpPrimitives::CHIMP_SEQUENCE_SIZE - index;
-	}
-
-	void Scan(CHIMP_TYPE *dest, idx_t count) {
-		memcpy(dest, (void *)(values + index), count * sizeof(CHIMP_TYPE));
-		index += count;
-	}
-
-	void LoadFlags(uint8_t *packed_data, idx_t group_size) {
-		FlagBuffer<false> flag_buffer;
-		flag_buffer.SetBuffer(packed_data);
-		flags[0] = ChimpConstants::Flags::VALUE_IDENTICAL; // First value doesn't require a flag
-		for (idx_t i = 0; i < group_size; i++) {
-			flags[1 + i] = (ChimpConstants::Flags)flag_buffer.Extract();
-		}
-		max_flags_to_read = group_size;
-		index = 0;
-	}
-
-	void LoadLeadingZeros(uint8_t *packed_data, idx_t leading_zero_block_size) {
-#ifdef DEBUG
-		idx_t flag_one_count = 0;
-		for (idx_t i = 0; i < max_flags_to_read; i++) {
-			flag_one_count += flags[1 + i] == ChimpConstants::Flags::LEADING_ZERO_LOAD;
-		}
-		// There are 8 leading zero values packed in one block, the block could be partially filled
-		flag_one_count = AlignValue<idx_t, 8>(flag_one_count);
-		D_ASSERT(flag_one_count == leading_zero_block_size);
-#endif
-		LeadingZeroBuffer<false> leading_zero_buffer;
-		leading_zero_buffer.SetBuffer(packed_data);
-		for (idx_t i = 0; i < leading_zero_block_size; i++) {
-			leading_zeros[i] = ChimpConstants::Decompression::LEADING_REPRESENTATION[leading_zero_buffer.Extract()];
-		}
-		max_leading_zeros_to_read = leading_zero_block_size;
-		leading_zero_index = 0;
-	}
-
-	idx_t CalculatePackedDataCount() const {
-		idx_t count = 0;
-		for (idx_t i = 0; i < max_flags_to_read; i++) {
-			count += flags[1 + i] == ChimpConstants::Flags::TRAILING_EXCEEDS_THRESHOLD;
-		}
-		return count;
-	}
-
-	void LoadPackedData(uint16_t *packed_data, idx_t packed_data_block_count) {
-		for (idx_t i = 0; i < packed_data_block_count; i++) {
-			PackedDataUtils<CHIMP_TYPE>::Unpack(packed_data[i], unpacked_data_blocks[i]);
-			if (unpacked_data_blocks[i].significant_bits == 0) {
-				unpacked_data_blocks[i].significant_bits = 64;
-			}
-			unpacked_data_blocks[i].leading_zero =
-			    ChimpConstants::Decompression::LEADING_REPRESENTATION[unpacked_data_blocks[i].leading_zero];
-		}
-		unpacked_index = 0;
-		max_packed_data_to_read = packed_data_block_count;
-	}
-
-	void LoadValues(CHIMP_TYPE *result, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			result[i] = Chimp128Decompression<CHIMP_TYPE>::Load(flags[i], leading_zeros, leading_zero_index,
-			                                                    unpacked_data_blocks, unpacked_index, chimp_state);
-		}
-	}
-
-public:
-	uint32_t leading_zero_index;
-	uint32_t unpacked_index;
-
-	ChimpConstants::Flags flags[ChimpPrimitives::CHIMP_SEQUENCE_SIZE + 1];
-	uint8_t leading_zeros[ChimpPrimitives::CHIMP_SEQUENCE_SIZE + 1];
-	UnpackedData unpacked_data_blocks[ChimpPrimitives::CHIMP_SEQUENCE_SIZE];
-
-	CHIMP_TYPE values[ChimpPrimitives::CHIMP_SEQUENCE_SIZE];
-
-private:
-	idx_t index;
-	idx_t max_leading_zeros_to_read;
-	idx_t max_flags_to_read;
-	idx_t max_packed_data_to_read;
-	Chimp128DecompressionState<CHIMP_TYPE> chimp_state;
-};
-
-template <class T>
-struct ChimpScanState : public SegmentScanState {
-public:
-	using CHIMP_TYPE = typename ChimpType<T>::TYPE;
-
-	explicit ChimpScanState(ColumnSegment &segment) : segment(segment), segment_count(segment.count) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-
-		handle = buffer_manager.Pin(segment.block);
-		auto dataptr = handle.Ptr();
-		// ScanStates never exceed the boundaries of a Segment,
-		// but are not guaranteed to start at the beginning of the Block
-		auto start_of_data_segment = dataptr + segment.GetBlockOffset() + ChimpPrimitives::HEADER_SIZE;
-		group_state.Init(start_of_data_segment);
-		auto metadata_offset = Load<uint32_t>(dataptr + segment.GetBlockOffset());
-		metadata_ptr = dataptr + segment.GetBlockOffset() + metadata_offset;
-	}
-
-	BufferHandle handle;
-	data_ptr_t metadata_ptr;
-	idx_t total_value_count = 0;
-	ChimpGroupState<CHIMP_TYPE> group_state;
-
-	ColumnSegment &segment;
-	idx_t segment_count;
-
-	idx_t LeftInGroup() const {
-		return ChimpPrimitives::CHIMP_SEQUENCE_SIZE - (total_value_count % ChimpPrimitives::CHIMP_SEQUENCE_SIZE);
-	}
-
-	bool GroupFinished() const {
-		return (total_value_count % ChimpPrimitives::CHIMP_SEQUENCE_SIZE) == 0;
-	}
-
-	template <class CHIMP_TYPE>
-	void ScanGroup(CHIMP_TYPE *values, idx_t group_size) {
-		D_ASSERT(group_size <= ChimpPrimitives::CHIMP_SEQUENCE_SIZE);
-		D_ASSERT(group_size <= LeftInGroup());
-
-		if (GroupFinished() && total_value_count < segment_count) {
-			if (group_size == ChimpPrimitives::CHIMP_SEQUENCE_SIZE) {
-				LoadGroup(values);
-				total_value_count += group_size;
-				return;
-			} else {
-				LoadGroup(group_state.values);
-			}
-		}
-		group_state.Scan(values, group_size);
-		total_value_count += group_size;
-	}
-
-	void LoadGroup(CHIMP_TYPE *value_buffer) {
-
-		//! FIXME: If we change the order of this to flag -> leading_zero_blocks -> packed_data
-		//! We can leave out the leading zero block count as well, because it can be derived from
-		//! Extracting all the flags and counting the 3's
-
-		// Load the offset indicating where a groups data starts
-		metadata_ptr -= sizeof(uint32_t);
-		auto data_byte_offset = Load<uint32_t>(metadata_ptr);
-		D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize());
-		//  Only used for point queries
-		(void)data_byte_offset;
-
-		// Load how many blocks of leading zero bits we have
-		metadata_ptr -= sizeof(uint8_t);
-		auto leading_zero_block_count = Load<uint8_t>(metadata_ptr);
-		D_ASSERT(leading_zero_block_count <= ChimpPrimitives::CHIMP_SEQUENCE_SIZE / 8);
-
-		// Load the leading zero block count
-		metadata_ptr -= 3ULL * leading_zero_block_count;
-		const auto leading_zero_block_ptr = metadata_ptr;
-
-		// Figure out how many flags there are
-		D_ASSERT(segment_count >= total_value_count);
-		auto group_size = MinValue<idx_t>(segment_count - total_value_count, ChimpPrimitives::CHIMP_SEQUENCE_SIZE);
-		// Reduce by one, because the first value of a group does not have a flag
-		auto flag_count = group_size - 1;
-		uint16_t flag_byte_count = AlignValue<uint16_t, 4>(UnsafeNumericCast<uint16_t>(flag_count)) / 4;
-
-		// Load the flags
-		metadata_ptr -= flag_byte_count;
-		auto flags = metadata_ptr;
-		group_state.LoadFlags(flags, flag_count);
-
-		// Load the leading zero blocks
-		group_state.LoadLeadingZeros(leading_zero_block_ptr, (uint32_t)leading_zero_block_count * 8);
-
-		// Load packed data blocks
-		auto packed_data_block_count = group_state.CalculatePackedDataCount();
-		metadata_ptr -= packed_data_block_count * 2;
-		if ((uint64_t)metadata_ptr & 1) {
-			// Align on a two-byte boundary
-			metadata_ptr--;
-		}
-		group_state.LoadPackedData((uint16_t *)metadata_ptr, packed_data_block_count);
-
-		group_state.Reset();
-
-		// Load all values for the group
-		group_state.LoadValues(value_buffer, group_size);
-	}
-
-public:
-	//! Skip the next 'skip_count' values, we don't store the values
-	// TODO: use the metadata to determine if we can skip a group
-	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
-		INTERNAL_TYPE buffer[ChimpPrimitives::CHIMP_SEQUENCE_SIZE];
-
-		while (skip_count) {
-			auto skip_size = MinValue(skip_count, LeftInGroup());
-			ScanGroup<CHIMP_TYPE>(buffer, skip_size);
-			skip_count -= skip_size;
-		}
-	}
-};
-
-template <class T>
-unique_ptr<SegmentScanState> ChimpInitScan(ColumnSegment &segment) {
-	auto result = make_uniq_base<SegmentScanState, ChimpScanState<T>>(segment);
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void ChimpScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                      idx_t result_offset) {
-	using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
-	auto &scan_state = state.scan_state->Cast<ChimpScanState<T>>();
-
-	T *result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto current_result_ptr = (INTERNAL_TYPE *)(result_data + result_offset);
-
-	idx_t scanned = 0;
-	while (scanned < scan_count) {
-		idx_t to_scan = MinValue(scan_count - scanned, scan_state.LeftInGroup());
-		scan_state.template ScanGroup<INTERNAL_TYPE>(current_result_ptr + scanned, to_scan);
-		scanned += to_scan;
-	}
-}
-
-template <class T>
-void ChimpSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = state.scan_state->Cast<ChimpScanState<T>>();
-	scan_state.Skip(segment, skip_count);
-}
-
-template <class T>
-void ChimpScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	ChimpScanPartial<T>(segment, state, scan_count, result, 0);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/dictionary/analyze.hpp b/src/duckdb/src/include/duckdb/storage/compression/dictionary/analyze.hpp
deleted file mode 100644
index 99eb72156..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/dictionary/analyze.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include "duckdb/storage/compression/dictionary/common.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct DictionaryAnalyzeState : public DictionaryCompressionState {
-public:
-	explicit DictionaryAnalyzeState(const CompressionInfo &info);
-
-public:
-	bool LookupString(string_t str) override;
-	void AddNewString(string_t str) override;
-	void AddLastLookup() override;
-	void AddNull() override;
-	bool CalculateSpaceRequirements(bool new_string, idx_t string_size) override;
-	void Flush(bool final = false) override;
-	void Verify() override;
-
-public:
-	idx_t segment_count;
-	idx_t current_tuple_count;
-	idx_t current_unique_count;
-	idx_t current_dict_size;
-	StringHeap heap;
-	string_set_t current_set;
-	bitpacking_width_t current_width;
-	bitpacking_width_t next_width;
-};
-
-struct DictionaryCompressionAnalyzeState : public AnalyzeState {
-public:
-	explicit DictionaryCompressionAnalyzeState(const CompressionInfo &info)
-	    : AnalyzeState(info), analyze_state(make_uniq<DictionaryAnalyzeState>(info)) {
-	}
-
-public:
-	unique_ptr<DictionaryAnalyzeState> analyze_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/dictionary/common.hpp b/src/duckdb/src/include/duckdb/storage/compression/dictionary/common.hpp
deleted file mode 100644
index 79bd094bf..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/dictionary/common.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/storage/string_uncompressed.hpp"
-
-namespace duckdb {
-
-typedef struct {
-	uint32_t dict_size;
-	uint32_t dict_end;
-	uint32_t index_buffer_offset;
-	uint32_t index_buffer_count;
-	uint32_t bitpacking_width;
-} dictionary_compression_header_t;
-
-struct DictionaryCompression {
-public:
-	static constexpr float MINIMUM_COMPRESSION_RATIO = 1.2F;
-	//! Dictionary header size at the beginning of the string segment (offset + length)
-	static constexpr uint16_t DICTIONARY_HEADER_SIZE = sizeof(dictionary_compression_header_t);
-
-public:
-	static bool HasEnoughSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-	                           bitpacking_width_t packing_width, const idx_t block_size);
-	static idx_t RequiredSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-	                           bitpacking_width_t packing_width);
-
-	static StringDictionaryContainer GetDictionary(ColumnSegment &segment, BufferHandle &handle);
-	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer container);
-};
-
-//! Abstract class managing the compression state for size analysis or compression.
-class DictionaryCompressionState : public CompressionState {
-public:
-	explicit DictionaryCompressionState(const CompressionInfo &info);
-	~DictionaryCompressionState() override;
-
-public:
-	bool UpdateState(Vector &scan_vector, idx_t count);
-
-protected:
-	// Should verify the State
-	virtual void Verify() = 0;
-	// Performs a lookup of str, storing the result internally
-	virtual bool LookupString(string_t str) = 0;
-	// Add the most recently looked up str to compression state
-	virtual void AddLastLookup() = 0;
-	// Add string to the state that is known to not be seen yet
-	virtual void AddNewString(string_t str) = 0;
-	// Add a null value to the compression state
-	virtual void AddNull() = 0;
-	// Needs to be called before adding a value. Will return false if a flush is required first.
-	virtual bool CalculateSpaceRequirements(bool new_string, idx_t string_size) = 0;
-	// Flush the segment to disk if compressing or reset the counters if analyzing
-	virtual void Flush(bool final = false) = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp b/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp
deleted file mode 100644
index 09f1f44bd..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/storage/compression/dictionary/common.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-
-namespace duckdb {
-
-// Dictionary compression uses a combination of bitpacking and a dictionary to compress string segments. The data is
-// stored across three buffers: the index buffer, the selection buffer and the dictionary. Firstly the Index buffer
-// contains the offsets into the dictionary which are also used to determine the string lengths. Each value in the
-// dictionary gets a single unique index in the index buffer. Secondly, the selection buffer maps the tuples to an index
-// in the index buffer. The selection buffer is compressed with bitpacking. Finally, the dictionary contains simply all
-// the unique strings without lengths or null termination as we can deduce the lengths from the index buffer. The
-// addition of the selection buffer is done for two reasons: firstly, to allow the scan to emit dictionary vectors by
-// scanning the whole dictionary at once and then scanning the selection buffer for each emitted vector. Secondly, it
-// allows for efficient bitpacking compression as the selection values should remain relatively small.
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-struct DictionaryCompressionCompressState : public DictionaryCompressionState {
-public:
-	DictionaryCompressionCompressState(ColumnDataCheckpointData &checkpoint_data_p, const CompressionInfo &info);
-
-public:
-	void CreateEmptySegment(idx_t row_start);
-	void Verify() override;
-	bool LookupString(string_t str) override;
-	void AddNewString(string_t str) override;
-	void AddNull() override;
-	void AddLastLookup() override;
-	bool CalculateSpaceRequirements(bool new_string, idx_t string_size) override;
-	void Flush(bool final = false) override;
-	idx_t Finalize();
-
-public:
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-
-	// State regarding current segment
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle current_handle;
-	StringDictionaryContainer current_dictionary;
-	data_ptr_t current_end_ptr;
-
-	// Buffers and map for current segment
-	string_map_t<uint32_t> current_string_map;
-	vector<uint32_t> index_buffer;
-	vector<uint32_t> selection_buffer;
-
-	bitpacking_width_t current_width = 0;
-	bitpacking_width_t next_width = 0;
-
-	// Result of latest LookupString call
-	uint32_t latest_lookup_result;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/dictionary/decompression.hpp b/src/duckdb/src/include/duckdb/storage/compression/dictionary/decompression.hpp
deleted file mode 100644
index 1656ec718..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/dictionary/decompression.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "duckdb/storage/compression/dictionary/common.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-// FIXME: why is this StringScanState when we also define: `BufferHandle handle` ???
-struct CompressedStringScanState : public StringScanState {
-public:
-	explicit CompressedStringScanState(BufferHandle &&handle_p)
-	    : StringScanState(), owned_handle(std::move(handle_p)), handle(owned_handle) {
-	}
-	explicit CompressedStringScanState(BufferHandle &handle_p) : StringScanState(), owned_handle(), handle(handle_p) {
-	}
-
-public:
-	void Initialize(ColumnSegment &segment, bool initialize_dictionary = true);
-	void ScanToFlatVector(Vector &result, idx_t result_offset, idx_t start, idx_t scan_count);
-	void ScanToDictionaryVector(ColumnSegment &segment, Vector &result, idx_t result_offset, idx_t start,
-	                            idx_t scan_count);
-
-private:
-	string_t FetchStringFromDict(int32_t dict_offset, uint16_t string_len);
-	uint16_t GetStringLength(sel_t index);
-
-public:
-	BufferHandle owned_handle;
-	optional_ptr<BufferHandle> handle;
-
-	bitpacking_width_t current_width;
-	buffer_ptr<SelectionVector> sel_vec;
-	idx_t sel_vec_size = 0;
-
-	//! Start of the block (pointing to the dictionary_header)
-	data_ptr_t baseptr;
-	//! Start of the data (pointing to the start of the selection buffer)
-	data_ptr_t base_data;
-	uint32_t *index_buffer_ptr;
-	uint32_t index_buffer_count;
-
-	buffer_ptr<Vector> dictionary;
-	idx_t dictionary_size;
-	StringDictionaryContainer dict;
-	idx_t block_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp b/src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp
deleted file mode 100644
index 89abe1ce7..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#pragma once
-
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-
-namespace duckdb {
-
-class EmptyValidityCompression {
-public:
-	struct EmptyValidityCompressionState : public CompressionState {
-	public:
-		explicit EmptyValidityCompressionState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info)
-		    : CompressionState(info),
-		      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_EMPTY)),
-		      checkpoint_data(checkpoint_data) {
-		}
-		~EmptyValidityCompressionState() override {
-		}
-
-	public:
-		optional_ptr<CompressionFunction> function;
-		ColumnDataCheckpointData &checkpoint_data;
-		idx_t count = 0;
-		idx_t non_nulls = 0;
-	};
-	struct EmptyValiditySegmentScanState : public SegmentScanState {
-		EmptyValiditySegmentScanState() {
-		}
-	};
-
-public:
-	static CompressionFunction CreateFunction() {
-		return CompressionFunction(CompressionType::COMPRESSION_EMPTY, PhysicalType::BIT, nullptr, nullptr, nullptr,
-		                           InitCompression, Compress, FinalizeCompress, InitScan, Scan, ScanPartial, FetchRow,
-		                           Skip, InitSegment);
-	}
-
-public:
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointData &checkpoint_data,
-	                                                    unique_ptr<AnalyzeState> state_p) {
-		return make_uniq<EmptyValidityCompressionState>(checkpoint_data, state_p->info);
-	}
-	static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-		auto &state = state_p.Cast<EmptyValidityCompressionState>();
-		UnifiedVectorFormat format;
-		scan_vector.ToUnifiedFormat(count, format);
-		state.non_nulls += format.validity.CountValid(count);
-		state.count += count;
-	}
-	static void FinalizeCompress(CompressionState &state_p) {
-		auto &state = state_p.Cast<EmptyValidityCompressionState>();
-		auto &checkpoint_data = state.checkpoint_data;
-
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-		auto row_start = checkpoint_data.GetRowGroup().start;
-
-		auto &info = state.info;
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, *state.function, type, row_start,
-		                                                                info.GetBlockSize(), info.GetBlockSize());
-		compressed_segment->count = state.count;
-		if (state.non_nulls != state.count) {
-			compressed_segment->stats.statistics.SetHasNullFast();
-		}
-		if (state.non_nulls != 0) {
-			compressed_segment->stats.statistics.SetHasNoNullFast();
-		}
-
-		auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase());
-		auto handle = buffer_manager.Pin(compressed_segment->block);
-
-		auto &checkpoint_state = checkpoint_data.GetCheckpointState();
-		checkpoint_state.FlushSegment(std::move(compressed_segment), std::move(handle), 0);
-	}
-	static unique_ptr<SegmentScanState> InitScan(ColumnSegment &segment) {
-		return make_uniq<EmptyValiditySegmentScanState>();
-	}
-	static void ScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                        idx_t result_offset) {
-		return;
-	}
-	static void Scan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-		return;
-	}
-	static void FetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                     idx_t result_idx) {
-		return;
-	}
-	static void Skip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-		return;
-	}
-	static unique_ptr<CompressedSegmentState> InitSegment(ColumnSegment &segment, block_id_t block_id,
-	                                                      optional_ptr<ColumnSegmentState> segment_state) {
-		return nullptr;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/algorithm/patas.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/algorithm/patas.hpp
deleted file mode 100644
index 6dcddcb2d..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/algorithm/patas.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/patas/algorithm/patas.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/algorithm/byte_writer.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/ring_buffer.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/byte_reader.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/packed_data.hpp"
-#include "duckdb/storage/compression/patas/shared.hpp"
-#include "duckdb/common/bit_utils.hpp"
-
-namespace duckdb {
-
-namespace patas {
-
-template <class EXACT_TYPE, bool EMPTY>
-class PatasCompressionState {
-public:
-	PatasCompressionState() : index(0), first(true) {
-	}
-
-public:
-	void Reset() {
-		index = 0;
-		first = true;
-		ring_buffer.Reset();
-		packed_data_buffer.Reset();
-	}
-	void SetOutputBuffer(uint8_t *output) {
-		byte_writer.SetStream(output);
-		Reset();
-	}
-	idx_t Index() const {
-		return index;
-	}
-
-public:
-	void UpdateMetadata(uint8_t trailing_zero, uint8_t byte_count, uint8_t index_diff) {
-		if (!EMPTY) {
-			packed_data_buffer.Insert(PackedDataUtils<EXACT_TYPE>::Pack(index_diff, byte_count, trailing_zero));
-		}
-		index++;
-	}
-
-public:
-	ByteWriter<EMPTY> byte_writer;
-	PackedDataBuffer<EMPTY> packed_data_buffer;
-	idx_t index;
-	RingBuffer<EXACT_TYPE> ring_buffer;
-	bool first;
-};
-
-template <class EXACT_TYPE, bool EMPTY>
-struct PatasCompression {
-	using State = PatasCompressionState<EXACT_TYPE, EMPTY>;
-	static constexpr uint8_t EXACT_TYPE_BITSIZE = sizeof(EXACT_TYPE) * 8;
-
-	static void Store(EXACT_TYPE value, State &state) {
-		if (state.first) {
-			StoreFirst(value, state);
-		} else {
-			StoreCompressed(value, state);
-		}
-	}
-
-	static void StoreFirst(EXACT_TYPE value, State &state) {
-		// write first value, uncompressed
-		state.ring_buffer.template Insert<true>(value);
-		state.byte_writer.template WriteValue<EXACT_TYPE, EXACT_TYPE_BITSIZE>(value);
-		state.first = false;
-		state.UpdateMetadata(0, sizeof(EXACT_TYPE), 0);
-	}
-
-	static void StoreCompressed(EXACT_TYPE value, State &state) {
-		auto key = state.ring_buffer.Key(value);
-		uint64_t reference_index = state.ring_buffer.IndexOf(key);
-
-		// Find the reference value to use when compressing the current value
-		const bool exceeds_highest_index = reference_index > state.ring_buffer.Size();
-		const bool difference_too_big =
-		    ((state.ring_buffer.Size() + 1) - reference_index) >= ChimpConstants::BUFFER_SIZE;
-		if (exceeds_highest_index || difference_too_big) {
-			// Reference index is not in range, use the directly previous value
-			reference_index = state.ring_buffer.Size();
-		}
-		const auto reference_value = state.ring_buffer.Value(reference_index % ChimpConstants::BUFFER_SIZE);
-
-		// XOR with previous value
-		EXACT_TYPE xor_result = value ^ reference_value;
-
-		// Figure out the trailing zeros (max 6 bits)
-		const uint8_t trailing_zero = CountZeros<EXACT_TYPE>::Trailing(xor_result);
-		const uint8_t leading_zero = CountZeros<EXACT_TYPE>::Leading(xor_result);
-
-		const bool is_equal = xor_result == 0;
-
-		// Figure out the significant bytes (max 3 bits)
-		const uint8_t significant_bits = !is_equal * (EXACT_TYPE_BITSIZE - trailing_zero - leading_zero);
-		const uint8_t significant_bytes = (significant_bits >> 3) + ((significant_bits & 7) != 0);
-
-		// Avoid an invalid shift error when xor_result is 0
-		state.byte_writer.template WriteValue<EXACT_TYPE>(xor_result >> (trailing_zero - is_equal), significant_bits);
-
-		state.ring_buffer.Insert(value);
-		const uint8_t index_difference = state.ring_buffer.Size() - reference_index;
-		state.UpdateMetadata(trailing_zero - is_equal, significant_bytes, index_difference);
-	}
-};
-
-// Decompression
-
-template <class EXACT_TYPE>
-struct PatasDecompression {
-	static inline EXACT_TYPE DecompressValue(ByteReader &byte_reader, uint8_t byte_count, uint8_t trailing_zero,
-	                                         EXACT_TYPE previous) {
-		return (byte_reader.ReadValue<EXACT_TYPE>(byte_count, trailing_zero) << trailing_zero) ^ previous;
-	}
-};
-
-} // namespace patas
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas.hpp
deleted file mode 100644
index ff08b1fe4..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/patas/patas.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/patas/algorithm/patas.hpp"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/function/compression_function.hpp"
-
-namespace duckdb {
-
-using byte_index_t = uint32_t;
-
-//! FIXME: replace ChimpType with this
-template <class T>
-struct FloatingToExact {};
-
-template <>
-struct FloatingToExact<double> {
-	using TYPE = uint64_t;
-};
-
-template <>
-struct FloatingToExact<float> {
-	using TYPE = uint32_t;
-};
-
-template <class T, bool EMPTY>
-struct PatasState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	explicit PatasState(void *state_p = nullptr) : data_ptr(state_p), patas_state() {
-	}
-	//! The Compress/Analyze State
-	void *data_ptr;
-	patas::PatasCompressionState<EXACT_TYPE, EMPTY> patas_state;
-
-public:
-	void AssignDataBuffer(uint8_t *data_out) {
-		patas_state.SetOutputBuffer(data_out);
-	}
-
-	template <class OP>
-	bool Update(T uncompressed_value, bool is_valid) {
-		OP::template Operation<T>(uncompressed_value, is_valid, data_ptr);
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_analyze.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_analyze.hpp
deleted file mode 100644
index c86d2538d..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_analyze.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/patas/patas_analyze.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/function/compression_function.hpp"
-
-namespace duckdb {
-
-struct EmptyPatasWriter;
-
-template <class T>
-struct PatasAnalyzeState : public AnalyzeState {};
-
-template <class T>
-unique_ptr<AnalyzeState> PatasInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	// This compression type is deprecated
-	return nullptr;
-}
-
-template <class T>
-bool PatasAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	throw InternalException("Patas has been deprecated, can no longer be used to compress data");
-	return false;
-}
-
-template <class T>
-idx_t PatasFinalAnalyze(AnalyzeState &state) {
-	throw InternalException("Patas has been deprecated, can no longer be used to compress data");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp
deleted file mode 100644
index b33e1a6a0..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/patas/patas_compress.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/patas/patas_analyze.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-// State
-
-template <class T>
-struct PatasCompressionState : public CompressionState {};
-
-// Compression Functions
-
-template <class T>
-unique_ptr<CompressionState> PatasInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                  unique_ptr<AnalyzeState> state) {
-	throw InternalException("Patas has been deprecated, can no longer be used to compress data");
-	return nullptr;
-}
-
-template <class T>
-void PatasCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	throw InternalException("Patas has been deprecated, can no longer be used to compress data");
-}
-
-template <class T>
-void PatasFinalizeCompress(CompressionState &state_p) {
-	throw InternalException("Patas has been deprecated, can no longer be used to compress data");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_fetch.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_fetch.hpp
deleted file mode 100644
index 8e20ae67f..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_fetch.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/patas/patas_fetch.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/patas/patas.hpp"
-#include "duckdb/storage/compression/patas/patas_scan.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-namespace duckdb {
-
-template <class T>
-void PatasFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	PatasScanState<T> scan_state(segment);
-	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
-	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);
-	result_data[result_idx] = (EXACT_TYPE)0;
-
-	if (scan_state.GroupFinished() && scan_state.total_value_count < scan_state.count) {
-		scan_state.LoadGroup(scan_state.group_state.values);
-	}
-	scan_state.group_state.Scan((uint8_t *)(result_data + result_idx), 1);
-	scan_state.total_value_count++;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp
deleted file mode 100644
index 69cbdff43..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp
+++ /dev/null
@@ -1,242 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/storage/compression/chimp/chimp_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/compression/chimp/chimp.hpp"
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-//! Do not change order of these variables
-struct PatasUnpackedValueStats {
-	uint8_t significant_bytes;
-	uint8_t trailing_zeros;
-	uint8_t index_diff;
-};
-
-template <class EXACT_TYPE>
-struct PatasGroupState {
-public:
-	void Init(uint8_t *data) {
-		byte_reader.SetStream(data);
-	}
-
-	idx_t BytesRead() const {
-		return byte_reader.Index();
-	}
-
-	void Reset() {
-		index = 0;
-	}
-
-	void LoadPackedData(uint16_t *packed_data, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			auto &unpacked = unpacked_data[i];
-			PackedDataUtils<EXACT_TYPE>::Unpack(packed_data[i], (UnpackedData &)unpacked);
-		}
-	}
-
-	template <bool SKIP = false>
-	void Scan(uint8_t *dest, idx_t count) {
-		if (!SKIP) {
-			memcpy(dest, (void *)(values + index), sizeof(EXACT_TYPE) * count);
-		}
-		index += count;
-	}
-
-	template <bool SKIP>
-	void LoadValues(EXACT_TYPE *value_buffer, idx_t count) {
-		if (SKIP) {
-			return;
-		}
-		value_buffer[0] = (EXACT_TYPE)0;
-		for (idx_t i = 0; i < count; i++) {
-			value_buffer[i] = patas::PatasDecompression<EXACT_TYPE>::DecompressValue(
-			    byte_reader, unpacked_data[i].significant_bytes, unpacked_data[i].trailing_zeros,
-			    value_buffer[i - unpacked_data[i].index_diff]);
-		}
-	}
-
-public:
-	idx_t index;
-	PatasUnpackedValueStats unpacked_data[PatasPrimitives::PATAS_GROUP_SIZE];
-	EXACT_TYPE values[PatasPrimitives::PATAS_GROUP_SIZE];
-
-private:
-	ByteReader byte_reader;
-};
-
-template <class T>
-struct PatasScanState : public SegmentScanState {
-public:
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-	explicit PatasScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-
-		handle = buffer_manager.Pin(segment.block);
-		// ScanStates never exceed the boundaries of a Segment,
-		// but are not guaranteed to start at the beginning of the Block
-		segment_data = handle.Ptr() + segment.GetBlockOffset();
-		auto metadata_offset = Load<uint32_t>(segment_data);
-		metadata_ptr = segment_data + metadata_offset;
-	}
-
-	BufferHandle handle;
-	data_ptr_t metadata_ptr;
-	data_ptr_t segment_data;
-	idx_t total_value_count = 0;
-	PatasGroupState<EXACT_TYPE> group_state;
-
-	ColumnSegment &segment;
-	idx_t count;
-
-	idx_t LeftInGroup() const {
-		return PatasPrimitives::PATAS_GROUP_SIZE - (total_value_count % PatasPrimitives::PATAS_GROUP_SIZE);
-	}
-
-	inline bool GroupFinished() const {
-		return (total_value_count % PatasPrimitives::PATAS_GROUP_SIZE) == 0;
-	}
-
-	// Scan up to a group boundary
-	template <class EXACT_TYPE, bool SKIP = false>
-	void ScanGroup(EXACT_TYPE *values, idx_t group_size) {
-		D_ASSERT(group_size <= PatasPrimitives::PATAS_GROUP_SIZE);
-		D_ASSERT(group_size <= LeftInGroup());
-
-		if (GroupFinished() && total_value_count < count) {
-			if (group_size == PatasPrimitives::PATAS_GROUP_SIZE) {
-				LoadGroup<SKIP>(values);
-				total_value_count += group_size;
-				return;
-			} else {
-				// Even if SKIP is given, group size is not big enough to be able to fully skip the entire group
-				LoadGroup<false>(group_state.values);
-			}
-		}
-		group_state.template Scan<SKIP>((uint8_t *)values, group_size);
-
-		total_value_count += group_size;
-	}
-
-	// Using the metadata, we can avoid loading any of the data if we don't care about the group at all
-	void SkipGroup() {
-		// Skip the offset indicating where the data starts
-		metadata_ptr -= sizeof(uint32_t);
-		idx_t group_size = MinValue((idx_t)PatasPrimitives::PATAS_GROUP_SIZE, count - total_value_count);
-		// Skip the blocks of packed data
-		metadata_ptr -= sizeof(uint16_t) * group_size;
-
-		total_value_count += group_size;
-	}
-
-	template <bool SKIP = false>
-	void LoadGroup(EXACT_TYPE *value_buffer) {
-		group_state.Reset();
-
-		// Load the offset indicating where a groups data starts
-		metadata_ptr -= sizeof(uint32_t);
-		auto data_byte_offset = Load<uint32_t>(metadata_ptr);
-		D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize());
-
-		// Initialize the byte_reader with the data values for the group
-		group_state.Init(segment_data + data_byte_offset);
-
-		idx_t group_size = MinValue((idx_t)PatasPrimitives::PATAS_GROUP_SIZE, (count - total_value_count));
-
-		// Read the compacted blocks of (7 + 6 + 3 bits) value stats
-		metadata_ptr -= sizeof(uint16_t) * group_size;
-		group_state.LoadPackedData((uint16_t *)metadata_ptr, group_size);
-
-		// Read all the values to the specified 'value_buffer'
-		group_state.template LoadValues<SKIP>(value_buffer, group_size);
-	}
-
-public:
-	//! Skip the next 'skip_count' values, we don't store the values
-	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-
-		if (total_value_count != 0 && !GroupFinished()) {
-			// Finish skipping the current group
-			idx_t to_skip = LeftInGroup();
-			skip_count -= to_skip;
-			ScanGroup<EXACT_TYPE, true>(nullptr, to_skip);
-		}
-		// Figure out how many entire groups we can skip
-		// For these groups, we don't even need to process the metadata or values
-		idx_t groups_to_skip = skip_count / PatasPrimitives::PATAS_GROUP_SIZE;
-		for (idx_t i = 0; i < groups_to_skip; i++) {
-			SkipGroup();
-		}
-		skip_count -= PatasPrimitives::PATAS_GROUP_SIZE * groups_to_skip;
-		if (skip_count == 0) {
-			return;
-		}
-		// For the last group that this skip (partially) touches, we do need to
-		// load the metadata and values into the group_state
-		ScanGroup<EXACT_TYPE, true>(nullptr, skip_count);
-	}
-};
-
-template <class T>
-unique_ptr<SegmentScanState> PatasInitScan(ColumnSegment &segment) {
-	auto result = make_uniq_base<SegmentScanState, PatasScanState<T>>(segment);
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void PatasScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                      idx_t result_offset) {
-	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-	auto &scan_state = (PatasScanState<T> &)*state.scan_state;
-
-	// Get the pointer to the result values
-	auto current_result_ptr = FlatVector::GetData<EXACT_TYPE>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	current_result_ptr += result_offset;
-
-	idx_t scanned = 0;
-	while (scanned < scan_count) {
-		const auto remaining = scan_count - scanned;
-		const idx_t to_scan = MinValue(remaining, scan_state.LeftInGroup());
-
-		scan_state.template ScanGroup<EXACT_TYPE>(current_result_ptr + scanned, to_scan);
-		scanned += to_scan;
-	}
-}
-
-template <class T>
-void PatasSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = (PatasScanState<T> &)*state.scan_state;
-	scan_state.Skip(segment, skip_count);
-}
-
-template <class T>
-void PatasScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	PatasScanPartial<T>(segment, state, scan_count, result, 0);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/shared.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/shared.hpp
deleted file mode 100644
index a26143aea..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/patas/shared.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-namespace duckdb {
-
-class PatasPrimitives {
-public:
-	static constexpr uint32_t PATAS_GROUP_SIZE = 1024;
-	static constexpr uint8_t HEADER_SIZE = sizeof(uint32_t);
-	static constexpr uint8_t BYTECOUNT_BITSIZE = 3;
-	static constexpr uint8_t INDEX_BITSIZE = 7;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/roaring/appender.hpp b/src/duckdb/src/include/duckdb/storage/compression/roaring/appender.hpp
deleted file mode 100644
index 31972d4c8..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/roaring/appender.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/roaring/appender.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/compression/roaring/roaring.hpp"
-
-namespace duckdb {
-
-namespace roaring {
-
-template <class STATE_TYPE>
-struct RoaringStateAppender {
-public:
-	RoaringStateAppender() = delete;
-
-public:
-	static void AppendBytes(STATE_TYPE &state, validity_t entry, idx_t bits) {
-		D_ASSERT(bits <= ValidityMask::BITS_PER_VALUE);
-
-		idx_t full_bytes = bits / 8;
-		idx_t last_bits = bits % 8;
-		for (idx_t i = 0; i < full_bytes; i++) {
-			// Create a mask for the byte we care about (least to most significant byte)
-			auto bitmask = ValidityUncompressed::UPPER_MASKS[8] >> ((7 - i) * 8);
-			// Shift to the least significant bits so we can use it to index our bitmask table
-			auto array_index = static_cast<uint8_t>((entry & bitmask) >> (i * 8));
-			STATE_TYPE::HandleByte(state, array_index);
-		}
-
-		if (DUCKDB_UNLIKELY(last_bits != 0)) {
-			auto bitmask = ValidityUncompressed::UPPER_MASKS[8] >> ((7 - full_bytes) * 8);
-			auto array_index = static_cast<uint8_t>((entry & bitmask) >> (full_bytes * 8));
-			STATE_TYPE::HandleRaggedByte(state, array_index, last_bits);
-		}
-	}
-
-	static void AppendVector(STATE_TYPE &state, Vector &input, idx_t input_size) {
-		UnifiedVectorFormat unified;
-		input.ToUnifiedFormat(input_size, unified);
-		auto &validity = unified.validity;
-
-		if (validity.AllValid()) {
-			// All bits are set implicitly
-			idx_t appended = 0;
-			while (appended < input_size) {
-				idx_t to_append =
-				    MinValue<idx_t>(ROARING_CONTAINER_SIZE - STATE_TYPE::Count(state), input_size - appended);
-				STATE_TYPE::HandleAllValid(state, to_append);
-				if (STATE_TYPE::Count(state) == ROARING_CONTAINER_SIZE) {
-					STATE_TYPE::Flush(state);
-				}
-				appended += to_append;
-			}
-		} else {
-			// There is a validity mask
-			idx_t appended = 0;
-			while (appended < input_size) {
-				idx_t to_append =
-				    MinValue<idx_t>(ROARING_CONTAINER_SIZE - STATE_TYPE::Count(state), input_size - appended);
-
-				// Deal with a ragged start, when 'appended' isn't a multiple of ValidityMask::BITS_PER_VALUE
-				// then we need to process the remainder of the entry
-				idx_t entry_offset = appended / ValidityMask::BITS_PER_VALUE;
-				auto previous_entry_remainder = appended % ValidityMask::BITS_PER_VALUE;
-				if (DUCKDB_UNLIKELY(previous_entry_remainder != 0)) {
-					auto validity_entry = validity.GetValidityEntry(entry_offset);
-
-					idx_t to_process = ValidityMask::BITS_PER_VALUE - previous_entry_remainder;
-					validity_t mask;
-					if (to_append < to_process) {
-						// Limit the amount of bits to set
-						auto left_bits = to_process - to_append;
-						to_process = to_append;
-						mask = ValidityUncompressed::UPPER_MASKS[to_process] >> left_bits;
-					} else {
-						mask = ValidityUncompressed::UPPER_MASKS[to_process];
-					}
-
-					auto masked_entry = (validity_entry & mask) >> previous_entry_remainder;
-					if (masked_entry == ValidityUncompressed::LOWER_MASKS[to_process]) {
-						// All bits are set
-						STATE_TYPE::HandleAllValid(state, to_process);
-					} else if (masked_entry == 0) {
-						// None of the bits are set
-						STATE_TYPE::HandleNoneValid(state, to_process);
-					} else {
-						// Mixed set/unset bits
-						AppendBytes(state, masked_entry, to_process);
-					}
-
-					to_append -= to_process;
-					appended += to_process;
-					entry_offset++;
-				}
-
-				auto entry_count = to_append / ValidityMask::BITS_PER_VALUE;
-				for (idx_t entry_index = 0; entry_index < entry_count; entry_index++) {
-					// get the validity entry at this index
-					auto validity_entry = validity.GetValidityEntry(entry_offset + entry_index);
-					if (ValidityMask::AllValid(validity_entry)) {
-						// All bits are set
-						STATE_TYPE::HandleAllValid(state, ValidityMask::BITS_PER_VALUE);
-					} else if (ValidityMask::NoneValid(validity_entry)) {
-						// None of the bits are set
-						STATE_TYPE::HandleNoneValid(state, ValidityMask::BITS_PER_VALUE);
-					} else {
-						// Mixed set/unset bits
-						AppendBytes(state, validity_entry, ValidityMask::BITS_PER_VALUE);
-					}
-				}
-
-				// Deal with a ragged end, when the validity entry isn't entirely used
-				idx_t remainder = to_append % ValidityMask::BITS_PER_VALUE;
-				if (DUCKDB_UNLIKELY(remainder != 0)) {
-					auto validity_entry = validity.GetValidityEntry(entry_offset + entry_count);
-					auto masked = validity_entry & ValidityUncompressed::LOWER_MASKS[remainder];
-					if (masked == ValidityUncompressed::LOWER_MASKS[remainder]) {
-						// All bits are set
-						STATE_TYPE::HandleAllValid(state, remainder);
-					} else if (masked == 0) {
-						// None of the bits are set
-						STATE_TYPE::HandleNoneValid(state, remainder);
-					} else {
-						AppendBytes(state, validity_entry, remainder);
-					}
-				}
-
-				if (STATE_TYPE::Count(state) == ROARING_CONTAINER_SIZE) {
-					STATE_TYPE::Flush(state);
-				}
-				appended += to_append;
-			}
-		}
-	}
-};
-
-} // namespace roaring
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp
deleted file mode 100644
index 7a2d1ddaa..000000000
--- a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp
+++ /dev/null
@@ -1,616 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/compression/roaring/roaring.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-namespace roaring {
-
-//! Used for compressed runs/arrays
-static constexpr uint16_t COMPRESSED_SEGMENT_SIZE = 256;
-//! compresed segment size is 256, instead of division we can make use of shifting
-static constexpr uint16_t COMPRESSED_SEGMENT_SHIFT_AMOUNT = 8;
-//! The amount of values that are encoded per container
-static constexpr idx_t ROARING_CONTAINER_SIZE = 2048;
-static constexpr bool NULLS = true;
-static constexpr bool NON_NULLS = false;
-static constexpr uint16_t UNCOMPRESSED_SIZE = (ROARING_CONTAINER_SIZE / sizeof(validity_t));
-static constexpr uint16_t COMPRESSED_SEGMENT_COUNT = (ROARING_CONTAINER_SIZE / COMPRESSED_SEGMENT_SIZE);
-
-static constexpr uint16_t MAX_RUN_IDX = (UNCOMPRESSED_SIZE - COMPRESSED_SEGMENT_COUNT) / (sizeof(uint8_t) * 2);
-static constexpr uint16_t MAX_ARRAY_IDX = (UNCOMPRESSED_SIZE - COMPRESSED_SEGMENT_COUNT) / (sizeof(uint8_t) * 1);
-//! The value used to indicate that a container is a bitset container
-static constexpr uint16_t BITSET_CONTAINER_SENTINEL_VALUE = MAX_ARRAY_IDX + 1;
-static constexpr uint16_t COMPRESSED_ARRAY_THRESHOLD = 8;
-static constexpr uint16_t COMPRESSED_RUN_THRESHOLD = 4;
-
-static constexpr uint16_t CONTAINER_TYPE_BITWIDTH = 2;
-static constexpr uint16_t RUN_CONTAINER_SIZE_BITWIDTH = 7;
-static constexpr uint16_t ARRAY_CONTAINER_SIZE_BITWIDTH = 8;
-
-//! This can be increased, but requires additional changes beyond just changing the constant
-static_assert(MAX_RUN_IDX < NumericLimits<uint8_t>::Maximum(), "The run size is encoded in a maximum of 8 bits");
-
-//! This can be increased, but requires additional changes beyond just changing the constant
-static_assert(BITSET_CONTAINER_SENTINEL_VALUE < NumericLimits<uint8_t>::Maximum(),
-              "The array/bitset size is encoded in a maximum of 8 bits");
-
-static_assert(ROARING_CONTAINER_SIZE % COMPRESSED_SEGMENT_SIZE == 0,
-              "The (maximum) container size has to be cleanly divisable by the segment size");
-
-static_assert((1 << RUN_CONTAINER_SIZE_BITWIDTH) - 1 >= MAX_RUN_IDX,
-              "The bitwidth used to store the size of a run container has to be big enough to store the maximum size");
-static_assert(
-    (1 << ARRAY_CONTAINER_SIZE_BITWIDTH) - 1 >= MAX_ARRAY_IDX + 1,
-    "The bitwidth used to store the size of an array/bitset container has to be big enough to store the maximum size");
-
-void SetInvalidRange(ValidityMask &result, idx_t start, idx_t end);
-
-struct RunContainerRLEPair {
-	uint16_t start;
-	uint16_t length;
-};
-
-enum class ContainerType : uint8_t { RUN_CONTAINER, ARRAY_CONTAINER, BITSET_CONTAINER };
-
-struct ContainerMetadata {
-public:
-	bool operator==(const ContainerMetadata &other) const {
-		if (container_type != other.container_type) {
-			return false;
-		}
-		if (count != other.count) {
-			return false;
-		}
-		if (nulls != other.nulls) {
-			return false;
-		}
-		return true;
-	}
-
-	static ContainerMetadata CreateMetadata(uint16_t count, uint16_t array_null, uint16_t array_non_null,
-	                                        uint16_t runs);
-
-	static ContainerMetadata RunContainer(uint16_t runs) {
-		auto res = ContainerMetadata();
-		res.container_type = ContainerType::RUN_CONTAINER;
-		res.nulls = true;
-		res.count = runs;
-		return res;
-	}
-
-	static ContainerMetadata ArrayContainer(uint16_t array_size, bool nulls) {
-		auto res = ContainerMetadata();
-		res.container_type = ContainerType::ARRAY_CONTAINER;
-		res.nulls = nulls;
-		res.count = array_size;
-		return res;
-	}
-
-	static ContainerMetadata BitsetContainer(uint16_t container_size) {
-		auto res = ContainerMetadata();
-		res.container_type = ContainerType::BITSET_CONTAINER;
-		res.nulls = true;
-		res.count = container_size;
-		return res;
-	}
-
-public:
-	idx_t GetDataSizeInBytes(idx_t container_size) const;
-	bool IsUncompressed() const {
-		return container_type == ContainerType::BITSET_CONTAINER;
-	}
-	bool IsRun() const {
-		return container_type == ContainerType::RUN_CONTAINER;
-	}
-	bool IsInverted() const {
-		return nulls;
-	}
-	bool IsArray() const {
-		return container_type == ContainerType::ARRAY_CONTAINER;
-	}
-	idx_t NumberOfRuns() const {
-		D_ASSERT(IsRun());
-		return count;
-	}
-	idx_t Cardinality() const {
-		D_ASSERT(IsArray());
-		return count;
-	}
-
-public:
-	ContainerType container_type;
-	//! Whether nulls are being encoded or non-nulls
-	bool nulls;
-	//! The amount (meaning depends on container_type)
-	uint16_t count;
-
-private:
-	ContainerMetadata() {
-	}
-};
-
-struct ContainerMetadataCollection {
-	static constexpr uint8_t IS_RUN_FLAG = 1 << 1;
-	static constexpr uint8_t IS_INVERTED_FLAG = 1 << 0;
-
-public:
-	ContainerMetadataCollection();
-
-public:
-	void AddMetadata(ContainerMetadata metadata);
-	idx_t GetMetadataSizeForSegment() const;
-	idx_t GetMetadataSize(idx_t container_count, idx_t run_containers, idx_t array_containers) const;
-	idx_t GetRunContainerCount() const;
-	idx_t GetArrayAndBitsetContainerCount() const;
-	void FlushSegment();
-	void Reset();
-	// Write the metadata for the current segment
-	idx_t Serialize(data_ptr_t dest) const;
-	void Deserialize(data_ptr_t src, idx_t container_count);
-
-private:
-	void AddBitsetContainer();
-	void AddArrayContainer(idx_t amount, bool is_inverted);
-	void AddRunContainer(idx_t amount, bool is_inverted);
-	void AddContainerType(bool is_run, bool is_inverted);
-
-public:
-	//! Encode for each container in the lower 2 bits if the container 'is_run' and 'is_inverted'
-	vector<uint8_t> container_type;
-	//! Encode for each run container the length
-	vector<uint8_t> number_of_runs;
-	//! Encode for each array/bitset container the length
-	vector<uint8_t> cardinality;
-
-	idx_t count_in_segment = 0;
-	idx_t runs_in_segment = 0;
-	idx_t arrays_in_segment = 0;
-};
-
-struct ContainerMetadataCollectionScanner {
-public:
-	explicit ContainerMetadataCollectionScanner(ContainerMetadataCollection &collection);
-
-public:
-	ContainerMetadata GetNext();
-
-public:
-	const ContainerMetadataCollection &collection;
-	idx_t array_idx = 0;
-	idx_t run_idx = 0;
-	idx_t idx = 0;
-};
-
-struct BitmaskTableEntry {
-	uint8_t first_bit_set : 1;
-	uint8_t last_bit_set : 1;
-	uint8_t valid_count : 6;
-	uint8_t run_count;
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct RoaringAnalyzeState : public AnalyzeState {
-public:
-	explicit RoaringAnalyzeState(const CompressionInfo &info);
-
-public:
-	// RoaringStateAppender interface:
-
-	static void HandleByte(RoaringAnalyzeState &state, uint8_t array_index);
-	static void HandleRaggedByte(RoaringAnalyzeState &state, uint8_t array_index, idx_t relevant_bits);
-	static void HandleAllValid(RoaringAnalyzeState &state, idx_t amount);
-	static void HandleNoneValid(RoaringAnalyzeState &state, idx_t amount);
-	static idx_t Count(RoaringAnalyzeState &state);
-	static void Flush(RoaringAnalyzeState &state);
-
-public:
-	ContainerMetadata GetResult();
-	bool HasEnoughSpaceInSegment(idx_t required_space);
-	void FlushSegment();
-	void FlushContainer();
-	void Analyze(Vector &input, idx_t count);
-
-public:
-	unsafe_unique_array<BitmaskTableEntry> bitmask_table;
-
-	//! Analyze phase
-
-	//! The amount of set bits found
-	uint16_t one_count = 0;
-	//! The amount of unset bits found
-	uint16_t zero_count = 0;
-	//! The amount of runs (of 0's) so far
-	uint16_t run_count = 0;
-	//! Whether the last bit was set or not
-	bool last_bit_set;
-	//! The total amount of bits covered (one_count + zero_count)
-	uint16_t count = 0;
-
-	//! Flushed analyze data
-
-	//! The space used by the current segment
-	idx_t space_used = 0;
-	//! The total amount of segments to write
-	idx_t segment_count = 0;
-	//! The amount of values in the current segment;
-	idx_t current_count = 0;
-	//! The total amount of data to serialize
-	idx_t total_count = 0;
-
-	//! The total amount of bytes used to compress the whole segment
-	idx_t total_size = 0;
-	//! The container metadata, determining the type of each container to use during compression
-	ContainerMetadataCollection metadata_collection;
-	vector<ContainerMetadata> container_metadata;
-};
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-
-struct ContainerCompressionState {
-	using append_func_t = void (*)(ContainerCompressionState &, bool, uint16_t);
-
-public:
-	ContainerCompressionState();
-
-public:
-	void Append(bool null, uint16_t amount = 1);
-	void OverrideArray(data_ptr_t destination, bool nulls, idx_t count);
-	void OverrideRun(data_ptr_t destination, idx_t count);
-	void OverrideUncompressed(data_ptr_t destination);
-	void Finalize();
-	ContainerMetadata GetResult();
-	void Reset();
-
-public:
-	//! Buffered append state (we don't want to append every bit separately)
-	uint16_t length = 0;
-	bool last_bit_set;
-
-	//! Total amount of values covered by the container
-	uint16_t appended_count = 0;
-	//! How many of the total are null
-	uint16_t null_count = 0;
-	bool last_is_null = false;
-
-	RunContainerRLEPair *runs;
-	uint8_t *compressed_runs;
-	uint8_t *compressed_arrays[2];
-	uint16_t *arrays[2];
-
-	//! The runs (for sequential nulls)
-	RunContainerRLEPair base_runs[COMPRESSED_RUN_THRESHOLD];
-	//! The indices (for nulls | non-nulls)
-	uint16_t base_arrays[2][COMPRESSED_ARRAY_THRESHOLD];
-
-	uint16_t run_idx;
-	uint16_t array_idx[2];
-
-	uint8_t *array_counts[2];
-	uint8_t *run_counts;
-
-	uint8_t base_compressed_arrays[2][MAX_ARRAY_IDX];
-	uint8_t base_compressed_runs[MAX_RUN_IDX * 2];
-	uint8_t base_array_counts[2][COMPRESSED_SEGMENT_COUNT];
-	uint8_t base_run_counts[COMPRESSED_SEGMENT_COUNT];
-
-	validity_t *uncompressed = nullptr;
-	//! Whether the state has been finalized
-	bool finalized = false;
-	//! The function called to append to the state
-	append_func_t append_function;
-};
-
-struct RoaringCompressState : public CompressionState {
-public:
-	explicit RoaringCompressState(ColumnDataCheckpointData &checkpoint_data, unique_ptr<AnalyzeState> analyze_state_p);
-
-public:
-	//! RoaringStateAppender interface
-	static void HandleByte(RoaringCompressState &state, uint8_t array_index);
-	static void HandleRaggedByte(RoaringCompressState &state, uint8_t array_index, idx_t relevant_bits);
-	static void HandleAllValid(RoaringCompressState &state, idx_t amount);
-	static void HandleNoneValid(RoaringCompressState &state, idx_t amount);
-	static idx_t Count(RoaringCompressState &state);
-	static void Flush(RoaringCompressState &state);
-
-public:
-	idx_t GetContainerIndex();
-	idx_t GetRemainingSpace();
-	bool CanStore(idx_t container_size, const ContainerMetadata &metadata);
-	void InitializeContainer();
-	void CreateEmptySegment(idx_t row_start);
-	void FlushSegment();
-	void Finalize();
-	void FlushContainer();
-	void NextContainer();
-	void Compress(Vector &input, idx_t count);
-
-public:
-	unique_ptr<AnalyzeState> owned_analyze_state;
-	RoaringAnalyzeState &analyze_state;
-
-	ContainerCompressionState container_state;
-	ContainerMetadataCollection metadata_collection;
-	vector<ContainerMetadata> &container_metadata;
-
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	// Ptr to next free spot in segment;
-	data_ptr_t data_ptr;
-	// Ptr to next free spot for storing
-	data_ptr_t metadata_ptr;
-	//! The amount of values already compressed
-	idx_t total_count = 0;
-};
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-
-struct ContainerScanState {
-public:
-	ContainerScanState(idx_t container_index_p, idx_t container_size)
-	    : container_index(container_index_p), container_size(container_size) {
-	}
-	virtual ~ContainerScanState() {
-	}
-
-public:
-	virtual void ScanPartial(Vector &result, idx_t result_offset, idx_t to_scan) = 0;
-	virtual void Skip(idx_t count) = 0;
-	virtual void Verify() const = 0;
-
-public:
-	//! The index of the container
-	idx_t container_index;
-	//! The size of the container (how many values does it hold)
-	idx_t container_size;
-	//! How much of the container is already consumed
-	idx_t scanned_count = 0;
-};
-
-struct ContainerSegmentScan {
-public:
-	explicit ContainerSegmentScan(data_ptr_t data);
-	ContainerSegmentScan(const ContainerSegmentScan &other) = delete;
-	ContainerSegmentScan(ContainerSegmentScan &&other) = delete;
-	ContainerSegmentScan &operator=(const ContainerSegmentScan &other) = delete;
-	ContainerSegmentScan &operator=(ContainerSegmentScan &&other) = delete;
-
-public:
-	// Returns the base of the current segment, forwarding the index if the segment is depleted of values
-	uint16_t operator++(int);
-
-private:
-	//! The COMPRESSED_SEGMENT_COUNT unsigned bytes indicating for each segment (256 bytes) of the container how many
-	//! values are in the segment
-	uint8_t *segments;
-	uint8_t index;
-	uint8_t count;
-};
-
-//! RUN Container
-
-struct RunContainerScanState : public ContainerScanState {
-public:
-	RunContainerScanState(idx_t container_index, idx_t container_size, idx_t count, data_ptr_t data_p);
-
-public:
-	void ScanPartial(Vector &result, idx_t result_offset, idx_t to_scan) override;
-	void Skip(idx_t to_skip) override;
-	void Verify() const override;
-
-protected:
-	virtual void LoadNextRun();
-
-protected:
-	RunContainerRLEPair run;
-	bool finished = false;
-	idx_t run_index = 0;
-	idx_t count;
-	data_ptr_t data;
-};
-
-struct CompressedRunContainerScanState : public RunContainerScanState {
-public:
-	CompressedRunContainerScanState(idx_t container_index, idx_t container_size, idx_t count, data_ptr_t segments,
-	                                data_ptr_t data);
-
-protected:
-	void LoadNextRun() override;
-	void Verify() const override;
-
-private:
-	data_ptr_t segments;
-	ContainerSegmentScan segment;
-};
-
-//! ARRAY Container
-
-template <bool INVERTED>
-struct ArrayContainerScanState : public ContainerScanState {
-public:
-	ArrayContainerScanState(idx_t container_index, idx_t container_size, idx_t count, data_ptr_t data_p)
-	    : ContainerScanState(container_index, container_size), data(data_p), count(count) {
-	}
-
-public:
-	virtual void LoadNextValue() {
-		if (array_index >= count) {
-			finished = true;
-			return;
-		}
-		value = reinterpret_cast<uint16_t *>(data)[array_index];
-		array_index++;
-	}
-
-public:
-	void ScanPartial(Vector &result, idx_t result_offset, idx_t to_scan) override {
-		auto &result_mask = FlatVector::Validity(result);
-
-		// This method assumes that the validity mask starts off as having all bits set for the entries that are being
-		// scanned.
-
-		if (!INVERTED) {
-			// If we are mapping valid entries, that means the majority of the bits are invalid
-			// so we set everything to invalid and only flip the bits that are present in the array
-			SetInvalidRange(result_mask, result_offset, result_offset + to_scan);
-		}
-
-		if (!array_index) {
-			LoadNextValue();
-		}
-		// At least one of the entries to scan is set
-		while (!finished) {
-			if (value >= scanned_count + to_scan) {
-				break;
-			}
-			if (value < scanned_count) {
-				LoadNextValue();
-				continue;
-			}
-			auto index = value - scanned_count;
-			if (INVERTED) {
-				result_mask.SetInvalid(result_offset + index);
-			} else {
-				result_mask.SetValid(result_offset + index);
-			}
-			LoadNextValue();
-		}
-		scanned_count += to_scan;
-	}
-
-	void Skip(idx_t to_skip) override {
-		idx_t end = scanned_count + to_skip;
-		if (!array_index) {
-			LoadNextValue();
-		}
-		while (!finished && value < end) {
-			LoadNextValue();
-		}
-		// In case array_index has already reached count
-		scanned_count = end;
-	}
-
-	void Verify() const override {
-#ifdef DEBUG
-		uint16_t index = 0;
-		auto array = reinterpret_cast<uint16_t *>(data);
-		for (uint16_t i = 0; i < count; i++) {
-			D_ASSERT(!i || array[i] > index);
-			index = array[i];
-		}
-#endif
-	}
-
-protected:
-	uint16_t value;
-	data_ptr_t data;
-	bool finished = false;
-	const idx_t count;
-	idx_t array_index = 0;
-};
-
-template <bool INVERTED>
-struct CompressedArrayContainerScanState : public ArrayContainerScanState<INVERTED> {
-public:
-	CompressedArrayContainerScanState(idx_t container_index, idx_t container_size, idx_t count, data_ptr_t segments,
-	                                  data_ptr_t data)
-	    : ArrayContainerScanState<INVERTED>(container_index, container_size, count, data), segments(segments),
-	      segment(segments) {
-		D_ASSERT(count >= COMPRESSED_ARRAY_THRESHOLD);
-	}
-
-public:
-	void LoadNextValue() override {
-		if (this->array_index >= this->count) {
-			this->finished = true;
-			return;
-		}
-		this->value = segment++;
-		this->value += reinterpret_cast<uint8_t *>(this->data)[this->array_index];
-		this->array_index++;
-	}
-	void Verify() const override {
-#ifdef DEBUG
-		uint16_t index = 0;
-		ContainerSegmentScan verify_segment(segments);
-		for (uint16_t i = 0; i < this->count; i++) {
-			// Get the value
-			uint16_t new_index = verify_segment++;
-			new_index += reinterpret_cast<uint8_t *>(this->data)[i];
-
-			D_ASSERT(!i || new_index > index);
-			index = new_index;
-		}
-#endif
-	}
-
-private:
-	data_ptr_t segments;
-	ContainerSegmentScan segment;
-};
-
-//! BITSET Container
-
-struct BitsetContainerScanState : public ContainerScanState {
-public:
-	BitsetContainerScanState(idx_t container_index, idx_t count, validity_t *bitset);
-
-public:
-	void ScanPartial(Vector &result, idx_t result_offset, idx_t to_scan) override;
-	void Skip(idx_t to_skip) override;
-	void Verify() const override;
-
-public:
-	validity_t *bitset;
-};
-
-struct RoaringScanState : public SegmentScanState {
-public:
-	explicit RoaringScanState(ColumnSegment &segment);
-
-public:
-	idx_t SkipVector(const ContainerMetadata &metadata);
-	bool UseContainerStateCache(idx_t container_index, idx_t internal_offset);
-	ContainerMetadata GetContainerMetadata(idx_t container_index);
-	data_ptr_t GetStartOfContainerData(idx_t container_index);
-	ContainerScanState &LoadContainer(idx_t container_index, idx_t internal_offset);
-	void ScanInternal(ContainerScanState &scan_state, idx_t to_scan, Vector &result, idx_t offset);
-	idx_t GetContainerIndex(idx_t start_index, idx_t &offset);
-	void ScanPartial(idx_t start_idx, Vector &result, idx_t offset, idx_t count);
-	void Skip(ContainerScanState &scan_state, idx_t skip_count);
-
-public:
-	BufferHandle handle;
-	ColumnSegment &segment;
-	unique_ptr<ContainerScanState> current_container;
-	data_ptr_t data_ptr;
-	ContainerMetadataCollection metadata_collection;
-	vector<ContainerMetadata> container_metadata;
-	vector<idx_t> data_start_position;
-};
-
-} // namespace roaring
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/data_pointer.hpp b/src/duckdb/src/include/duckdb/storage/data_pointer.hpp
deleted file mode 100644
index 43f1a1ee1..000000000
--- a/src/duckdb/src/include/duckdb/storage/data_pointer.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/data_pointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/common/enums/compression_type.hpp"
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-
-struct ColumnSegmentState {
-	virtual ~ColumnSegmentState() {
-	}
-
-	virtual void Serialize(Serializer &serializer) const = 0;
-	static unique_ptr<ColumnSegmentState> Deserialize(Deserializer &deserializer);
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-public:
-	vector<block_id_t> blocks;
-};
-
-struct DataPointer {
-	explicit DataPointer(BaseStatistics stats);
-	// disable copy constructors
-	DataPointer(const DataPointer &other) = delete;
-	DataPointer &operator=(const DataPointer &) = delete;
-	//! enable move constructors
-	DUCKDB_API DataPointer(DataPointer &&other) noexcept;
-	DUCKDB_API DataPointer &operator=(DataPointer &&) noexcept;
-
-	uint64_t row_start;
-	uint64_t tuple_count;
-	BlockPointer block_pointer;
-	CompressionType compression_type;
-	//! Type-specific statistics of the segment
-	BaseStatistics statistics;
-	//! Serialized segment state
-	unique_ptr<ColumnSegmentState> segment_state;
-
-	void Serialize(Serializer &serializer) const;
-	static DataPointer Deserialize(Deserializer &source);
-};
-
-struct RowGroupPointer {
-	uint64_t row_start;
-	uint64_t tuple_count;
-	//! The data pointers of the column segments stored in the row group
-	vector<MetaBlockPointer> data_pointers;
-	//! Data pointers to the delete information of the row group (if any)
-	vector<MetaBlockPointer> deletes_pointers;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/data_table.hpp b/src/duckdb/src/include/duckdb/storage/data_table.hpp
deleted file mode 100644
index 39795ed1b..000000000
--- a/src/duckdb/src/include/duckdb/storage/data_table.hpp
+++ /dev/null
@@ -1,287 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/data_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/index_constraint_type.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-#include "duckdb/storage/index.hpp"
-#include "duckdb/storage/statistics/column_statistics.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/data_table_info.hpp"
-#include "duckdb/storage/table/persistent_table_data.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/table/row_group_collection.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/transaction/local_storage.hpp"
-
-namespace duckdb {
-
-class BoundForeignKeyConstraint;
-class ClientContext;
-class ColumnDataCollection;
-class ColumnDefinition;
-class DataTable;
-class DuckTransaction;
-class OptimisticDataWriter;
-class RowGroup;
-class StorageManager;
-class TableCatalogEntry;
-class TableIOManager;
-class Transaction;
-class WriteAheadLog;
-class TableDataWriter;
-class ConflictManager;
-class TableScanState;
-struct TableDeleteState;
-struct ConstraintState;
-struct TableUpdateState;
-enum class VerifyExistenceType : uint8_t;
-
-//! DataTable represents a physical table on disk
-class DataTable {
-public:
-	//! Constructs a new data table from an (optional) set of persistent segments
-	DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager, const string &schema,
-	          const string &table, vector<ColumnDefinition> column_definitions_p,
-	          unique_ptr<PersistentTableData> data = nullptr);
-	//! Constructs a DataTable as a delta on an existing data table with a newly added column
-	DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression &default_value);
-	//! Constructs a DataTable as a delta on an existing data table but with one column removed
-	DataTable(ClientContext &context, DataTable &parent, idx_t removed_column);
-	//! Constructs a DataTable as a delta on an existing data table but with one column changed type
-	DataTable(ClientContext &context, DataTable &parent, idx_t changed_idx, const LogicalType &target_type,
-	          const vector<StorageIndex> &bound_columns, Expression &cast_expr);
-	//! Constructs a DataTable as a delta on an existing data table but with one column added new constraint
-	DataTable(ClientContext &context, DataTable &parent, BoundConstraint &constraint);
-
-	//! A reference to the database instance
-	AttachedDatabase &db;
-
-public:
-	AttachedDatabase &GetAttached();
-	TableIOManager &GetTableIOManager();
-
-	bool IsTemporary() const;
-
-	//! Returns a list of types of the table
-	vector<LogicalType> GetTypes();
-	const vector<ColumnDefinition> &Columns() const;
-
-	void InitializeScan(DuckTransaction &transaction, TableScanState &state, const vector<StorageIndex> &column_ids,
-	                    TableFilterSet *table_filters = nullptr);
-
-	//! Returns the maximum amount of threads that should be assigned to scan this data table
-	idx_t MaxThreads(ClientContext &context) const;
-	void InitializeParallelScan(ClientContext &context, ParallelTableScanState &state);
-	bool NextParallelScan(ClientContext &context, ParallelTableScanState &state, TableScanState &scan_state);
-
-	//! Scans up to STANDARD_VECTOR_SIZE elements from the table starting
-	//! from offset and store them in result. Offset is incremented with how many
-	//! elements were returned.
-	//! Returns true if all pushed down filters were executed during data fetching
-	void Scan(DuckTransaction &transaction, DataChunk &result, TableScanState &state);
-
-	//! Fetch data from the specific row identifiers from the base table
-	void Fetch(DuckTransaction &transaction, DataChunk &result, const vector<StorageIndex> &column_ids,
-	           const Vector &row_ids, idx_t fetch_count, ColumnFetchState &state);
-
-	//! Initializes appending to transaction-local storage
-	void InitializeLocalAppend(LocalAppendState &state, TableCatalogEntry &table, ClientContext &context,
-	                           const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-	//! Initializes only the delete-indexes of the transaction-local storage
-	void InitializeLocalStorage(LocalAppendState &state, TableCatalogEntry &table, ClientContext &context,
-	                            const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-	//! Append a DataChunk to the transaction-local storage of the table.
-	void LocalAppend(LocalAppendState &state, ClientContext &context, DataChunk &chunk, bool unsafe);
-	//! Finalizes a transaction-local append
-	void FinalizeLocalAppend(LocalAppendState &state);
-	//! Append a chunk to the transaction-local storage of this table and update the delete indexes.
-	void LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
-	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints, Vector &row_ids,
-	                 DataChunk &delete_chunk);
-	//! Append a chunk to the transaction-local storage of this table.
-	void LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
-	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-	//! Append a column data collection with default values to the transaction-local storage of this table.
-	void LocalAppend(TableCatalogEntry &table, ClientContext &context, ColumnDataCollection &collection,
-	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints,
-	                 optional_ptr<const vector<LogicalIndex>> column_ids);
-	//! Merge a row group collection into the transaction-local storage
-	void LocalMerge(ClientContext &context, RowGroupCollection &collection);
-	//! Creates an optimistic writer for this table - used for optimistically writing parallel appends
-	OptimisticDataWriter &CreateOptimisticWriter(ClientContext &context);
-	void FinalizeOptimisticWriter(ClientContext &context, OptimisticDataWriter &writer);
-
-	unique_ptr<TableDeleteState> InitializeDelete(TableCatalogEntry &table, ClientContext &context,
-	                                              const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-	//! Delete the entries with the specified row identifier from the table
-	idx_t Delete(TableDeleteState &state, ClientContext &context, Vector &row_ids, idx_t count);
-
-	unique_ptr<TableUpdateState> InitializeUpdate(TableCatalogEntry &table, ClientContext &context,
-	                                              const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-	//! Update the entries with the specified row identifier from the table
-	void Update(TableUpdateState &state, ClientContext &context, Vector &row_ids,
-	            const vector<PhysicalIndex> &column_ids, DataChunk &data);
-	//! Update a single (sub-)column along a column path
-	//! The column_path vector is a *path* towards a column within the table
-	//! i.e. if we have a table with a single column S STRUCT(A INT, B INT)
-	//! and we update the validity mask of "S.B"
-	//! the column path is:
-	//! 0 (first column of table)
-	//! -> 1 (second subcolumn of struct)
-	//! -> 0 (first subcolumn of INT)
-	//! This method should only be used from the WAL replay. It does not verify update constraints.
-	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
-	                  const vector<column_t> &column_path, DataChunk &updates);
-
-	//! Fetches an append lock
-	void AppendLock(TableAppendState &state);
-	//! Begin appending structs to this table, obtaining necessary locks, etc
-	void InitializeAppend(DuckTransaction &transaction, TableAppendState &state);
-	//! Append a chunk to the table using the AppendState obtained from InitializeAppend
-	void Append(DataChunk &chunk, TableAppendState &state);
-	//! Finalize an append
-	void FinalizeAppend(DuckTransaction &transaction, TableAppendState &state);
-	//! Commit the append
-	void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count);
-	//! Write a segment of the table to the WAL
-	void WriteToLog(DuckTransaction &transaction, WriteAheadLog &log, idx_t row_start, idx_t count,
-	                optional_ptr<StorageCommitState> commit_state);
-	//! Revert a set of appends made by the given AppendState, used to revert appends in the event of an error during
-	//! commit (e.g. because of an I/O exception)
-	void RevertAppend(DuckTransaction &transaction, idx_t start_row, idx_t count);
-	void RevertAppendInternal(idx_t start_row);
-
-	void ScanTableSegment(DuckTransaction &transaction, idx_t start_row, idx_t count,
-	                      const std::function<void(DataChunk &chunk)> &function);
-
-	//! Merge a row group collection directly into this table - appending it to the end of the table without copying
-	void MergeStorage(RowGroupCollection &data, TableIndexList &indexes, optional_ptr<StorageCommitState> commit_state);
-
-	//! Append a chunk with the row ids [row_start, ..., row_start + chunk.size()] to all indexes of the table.
-	//! Returns empty ErrorData, if the append was successful.
-	ErrorData AppendToIndexes(optional_ptr<TableIndexList> delete_indexes, DataChunk &chunk, row_t row_start);
-	static ErrorData AppendToIndexes(TableIndexList &indexes, optional_ptr<TableIndexList> delete_indexes,
-	                                 DataChunk &chunk, row_t row_start);
-	//! Remove a chunk with the row ids [row_start, ..., row_start + chunk.size()] from all indexes of the table
-	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start);
-	//! Remove the chunk with the specified set of row identifiers from all indexes of the table
-	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, Vector &row_identifiers);
-	//! Remove the row identifiers from all the indexes of the table
-	void RemoveFromIndexes(Vector &row_identifiers, idx_t count);
-
-	void SetAsRoot() {
-		this->is_root = true;
-	}
-
-	bool IsRoot() {
-		return this->is_root;
-	}
-
-	//! Get statistics of a physical column within the table
-	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id);
-
-	//! Get table sample
-	unique_ptr<BlockingSample> GetSample();
-	//! Sets statistics of a physical column within the table
-	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
-
-	//! Obtains a shared lock to prevent checkpointing while operations are running
-	unique_ptr<StorageLockKey> GetSharedCheckpointLock();
-	//! Obtains a lock during a checkpoint operation that prevents other threads from reading this table
-	unique_ptr<StorageLockKey> GetCheckpointLock();
-	//! Checkpoint the table to the specified table data writer
-	void Checkpoint(TableDataWriter &writer, Serializer &serializer);
-	void CommitDropTable();
-	void CommitDropColumn(idx_t index);
-
-	idx_t ColumnCount() const;
-	idx_t GetTotalRows() const;
-
-	vector<ColumnSegmentInfo> GetColumnSegmentInfo();
-	static bool IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type);
-
-	//! Scans the next chunk for the CREATE INDEX operator
-	bool CreateIndexScan(TableScanState &state, DataChunk &result, TableScanType type);
-	//! Returns true, if the index name is unique (i.e., no PK, UNIQUE, FK constraint has the same name)
-	//! FIXME: This is only necessary until we treat all indexes as catalog entries, allowing to alter constraints
-	bool IndexNameIsUnique(const string &name);
-
-	//! Initialize constraint verification state
-	unique_ptr<ConstraintState> InitializeConstraintState(TableCatalogEntry &table,
-	                                                      const vector<unique_ptr<BoundConstraint>> &bound_constraints);
-	//! Verify constraints with a chunk from the Append containing all columns of the table
-	void VerifyAppendConstraints(ConstraintState &constraint_state, ClientContext &context, DataChunk &chunk,
-	                             optional_ptr<LocalTableStorage> local_storage, optional_ptr<ConflictManager> manager);
-
-	shared_ptr<DataTableInfo> &GetDataTableInfo();
-
-	void InitializeIndexes(ClientContext &context);
-	bool HasIndexes() const;
-	bool HasUniqueIndexes() const;
-	bool HasForeignKeyIndex(const vector<PhysicalIndex> &keys, ForeignKeyType type);
-	void SetIndexStorageInfo(vector<IndexStorageInfo> index_storage_info);
-	void VacuumIndexes();
-	void CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_t count);
-
-	string GetTableName() const;
-	void SetTableName(string new_name);
-
-	TableStorageInfo GetStorageInfo();
-
-	idx_t GetRowGroupSize() const;
-
-	static void VerifyUniqueIndexes(TableIndexList &indexes, optional_ptr<LocalTableStorage> storage, DataChunk &chunk,
-	                                optional_ptr<ConflictManager> manager);
-
-	//! AddIndex initializes an index and adds it to the table's index list.
-	//! It is either empty, or initialized via its index storage information.
-	void AddIndex(const ColumnList &columns, const vector<LogicalIndex> &column_indexes, const IndexConstraintType type,
-	              const IndexStorageInfo &info);
-	//! AddIndex moves an index to this table's index list.
-	void AddIndex(unique_ptr<Index> index);
-
-	//! Returns a list of the partition stats
-	vector<PartitionStatistics> GetPartitionStats(ClientContext &context);
-
-private:
-	//! Verify the new added constraints against current persistent&local data
-	void VerifyNewConstraint(LocalStorage &local_storage, DataTable &parent, const BoundConstraint &constraint);
-
-	//! Verify constraints with a chunk from the Update containing only the specified column_ids
-	void VerifyUpdateConstraints(ConstraintState &state, ClientContext &context, DataChunk &chunk,
-	                             const vector<PhysicalIndex> &column_ids);
-	//! Verify constraints with a chunk from the Delete containing all columns of the table
-	void VerifyDeleteConstraints(TableDeleteState &state, ClientContext &context, DataChunk &chunk);
-
-	void InitializeScanWithOffset(DuckTransaction &transaction, TableScanState &state,
-	                              const vector<StorageIndex> &column_ids, idx_t start_row, idx_t end_row);
-
-	void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context, DataChunk &chunk,
-	                                VerifyExistenceType verify_type);
-	void VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-	                                      DataChunk &chunk);
-	void VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-	                                      DataChunk &chunk);
-
-private:
-	//! The table info
-	shared_ptr<DataTableInfo> info;
-	//! The set of physical columns stored by this DataTable
-	vector<ColumnDefinition> column_definitions;
-	//! Lock for appending entries to the table
-	mutex append_lock;
-	//! The row groups of the table
-	shared_ptr<RowGroupCollection> row_groups;
-	//! Whether or not the data table is the root DataTable for this table; the root DataTable is the newest version
-	//! that can be appended to
-	atomic<bool> is_root;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/database_size.hpp b/src/duckdb/src/include/duckdb/storage/database_size.hpp
deleted file mode 100644
index 79dee4bc8..000000000
--- a/src/duckdb/src/include/duckdb/storage/database_size.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/database_size.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-struct DatabaseSize {
-	idx_t total_blocks = 0;
-	idx_t block_size = 0;
-	idx_t free_blocks = 0;
-	idx_t used_blocks = 0;
-	idx_t bytes = 0;
-	idx_t wal_size = 0;
-};
-
-struct MetadataBlockInfo {
-	block_id_t block_id;
-	idx_t total_blocks;
-	vector<idx_t> free_list;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/in_memory_block_manager.hpp b/src/duckdb/src/include/duckdb/storage/in_memory_block_manager.hpp
deleted file mode 100644
index ef01d92e5..000000000
--- a/src/duckdb/src/include/duckdb/storage/in_memory_block_manager.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/in_memory_block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/storage/block_manager.hpp"
-
-namespace duckdb {
-
-//! InMemoryBlockManager is an implementation for a BlockManager
-class InMemoryBlockManager : public BlockManager {
-public:
-	using BlockManager::BlockManager;
-
-	// LCOV_EXCL_START
-	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database - ConvertBlock!");
-	}
-	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database - CreateBlock!");
-	}
-	block_id_t GetFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database - GetFreeBlockId!");
-	}
-	block_id_t PeekFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database - PeekFreeBlockId!");
-	}
-	bool IsRootBlock(MetaBlockPointer root) override {
-		throw InternalException("Cannot perform IO in in-memory database - IsRootBlock!");
-	}
-	void MarkBlockAsFree(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsFree!");
-	}
-	void MarkBlockAsUsed(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsUsed!");
-	}
-	void MarkBlockAsModified(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsModified!");
-	}
-	void IncreaseBlockReferenceCount(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database - IncreaseBlockReferenceCount!");
-	}
-	idx_t GetMetaBlock() override {
-		throw InternalException("Cannot perform IO in in-memory database - GetMetaBlock!");
-	}
-	void Read(Block &block) override {
-		throw InternalException("Cannot perform IO in in-memory database - Read!");
-	}
-	void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) override {
-		throw InternalException("Cannot perform IO in in-memory database - ReadBlocks!");
-	}
-	void Write(FileBuffer &block, block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database - Write!");
-	}
-	void WriteHeader(DatabaseHeader header) override {
-		throw InternalException("Cannot perform IO in in-memory database - WriteHeader!");
-	}
-	bool InMemory() override {
-		return true;
-	}
-	void FileSync() override {
-		throw InternalException("Cannot perform IO in in-memory database - FileSync!");
-	}
-	idx_t TotalBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database - TotalBlocks!");
-	}
-	idx_t FreeBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database - FreeBlocks!");
-	}
-	// LCOV_EXCL_STOP
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/index.hpp b/src/duckdb/src/include/duckdb/storage/index.hpp
deleted file mode 100644
index 2b624c2c1..000000000
--- a/src/duckdb/src/include/duckdb/storage/index.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/index_constraint_type.hpp"
-#include "duckdb/common/types/constraint_conflict_info.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class TableIOManager;
-class Transaction;
-class ConflictManager;
-
-struct IndexLock;
-struct IndexScanState;
-
-//! The index is an abstract base class that serves as the basis for indexes
-class Index {
-protected:
-	Index(const vector<column_t> &column_ids, TableIOManager &table_io_manager, AttachedDatabase &db);
-
-	//! The logical column ids of the indexed table
-	vector<column_t> column_ids;
-	//! Unordered set of column_ids used by the index
-	unordered_set<column_t> column_id_set;
-
-public:
-	//! Associated table io manager
-	TableIOManager &table_io_manager;
-	//! Attached database instance
-	AttachedDatabase &db;
-
-public:
-	virtual ~Index() = default;
-
-	//! Returns true if the index is a bound index, and false otherwise
-	virtual bool IsBound() const = 0;
-
-	//! The index type (ART, B+-tree, Skip-List, ...)
-	virtual const string &GetIndexType() const = 0;
-
-	//! The name of the index
-	virtual const string &GetIndexName() const = 0;
-
-	//! The index constraint type
-	virtual IndexConstraintType GetConstraintType() const = 0;
-
-	//! Returns unique flag
-	bool IsUnique() const {
-		auto type = GetConstraintType();
-		return type == IndexConstraintType::UNIQUE || type == IndexConstraintType::PRIMARY;
-	}
-
-	//! Returns primary key flag
-	bool IsPrimary() const {
-		auto index_constraint_type = GetConstraintType();
-		return (index_constraint_type == IndexConstraintType::PRIMARY);
-	}
-
-	//! Returns foreign key flag
-	bool IsForeign() const {
-		auto index_constraint_type = GetConstraintType();
-		return (index_constraint_type == IndexConstraintType::FOREIGN);
-	}
-
-	const vector<column_t> &GetColumnIds() const {
-		return column_ids;
-	}
-
-	const unordered_set<column_t> &GetColumnIdSet() const {
-		return column_id_set;
-	}
-
-	// All indexes can be dropped, even if they are unbound
-	virtual void CommitDrop() = 0;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/index_storage_info.hpp b/src/duckdb/src/include/duckdb/storage/index_storage_info.hpp
deleted file mode 100644
index d5e71ae48..000000000
--- a/src/duckdb/src/include/duckdb/storage/index_storage_info.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/index_storage_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-//! Information to serialize a FixedSizeAllocator, which holds the index data
-struct FixedSizeAllocatorInfo {
-	idx_t segment_size;
-	vector<idx_t> buffer_ids;
-	vector<BlockPointer> block_pointers;
-	vector<idx_t> segment_counts;
-	vector<idx_t> allocation_sizes;
-	vector<idx_t> buffers_with_free_space;
-
-	void Serialize(Serializer &serializer) const;
-	static FixedSizeAllocatorInfo Deserialize(Deserializer &deserializer);
-};
-
-//! Information to serialize an index buffer to the WAL
-struct IndexBufferInfo {
-	IndexBufferInfo(data_ptr_t buffer_ptr, const idx_t allocation_size)
-	    : buffer_ptr(buffer_ptr), allocation_size(allocation_size) {
-	}
-
-	data_ptr_t buffer_ptr;
-	idx_t allocation_size;
-};
-
-//! Index (de)serialization information.
-struct IndexStorageInfo {
-	IndexStorageInfo() {};
-	explicit IndexStorageInfo(const string &name) : name(name) {};
-
-	//! The name.
-	string name;
-	//! The storage root.
-	idx_t root;
-	//! Any index specialization can provide additional key-Value settings via this map.
-	case_insensitive_map_t<Value> options;
-	//! Serialization information for fixed-size allocator memory.
-	vector<FixedSizeAllocatorInfo> allocator_infos;
-
-	//! Contains all buffer pointers and their allocation size for serializing to the WAL.
-	//! First dimension: All fixed-size allocators.
-	//! Second dimension: The buffers of each fixed-size allocator.
-	vector<vector<IndexBufferInfo>> buffers;
-
-	//! The root block pointer of the index. Necessary to support older storage files.
-	BlockPointer root_block_ptr;
-
-	//! Returns true, if IndexStorageInfo holds information to deserialize an index.
-	bool IsValid() const {
-		return root_block_ptr.IsValid() || !allocator_infos.empty();
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static IndexStorageInfo Deserialize(Deserializer &deserializer);
-};
-
-//! Additional index information for tables
-struct IndexInfo {
-	bool is_unique;
-	bool is_primary;
-	bool is_foreign;
-	unordered_set<column_t> column_set;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/magic_bytes.hpp b/src/duckdb/src/include/duckdb/storage/magic_bytes.hpp
deleted file mode 100644
index b6f7f68da..000000000
--- a/src/duckdb/src/include/duckdb/storage/magic_bytes.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/magic_bytes.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-class FileSystem;
-
-enum class DataFileType : uint8_t {
-	FILE_DOES_NOT_EXIST, // file does not exist
-	DUCKDB_FILE,         // duckdb database file
-	SQLITE_FILE,         // sqlite database file
-	PARQUET_FILE         // parquet file
-};
-
-class MagicBytes {
-public:
-	static DataFileType CheckMagicBytes(FileSystem &fs, const string &path);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp b/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp
deleted file mode 100644
index 28110eceb..000000000
--- a/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/metadata/metadata_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-struct MetadataBlockInfo;
-
-struct MetadataBlock {
-	shared_ptr<BlockHandle> block;
-	block_id_t block_id;
-	vector<uint8_t> free_blocks;
-
-	void Write(WriteStream &sink);
-	static MetadataBlock Read(ReadStream &source);
-
-	idx_t FreeBlocksToInteger();
-	void FreeBlocksFromInteger(idx_t blocks);
-};
-
-struct MetadataPointer {
-	idx_t block_index : 56;
-	uint8_t index : 8;
-};
-
-struct MetadataHandle {
-	MetadataPointer pointer;
-	BufferHandle handle;
-};
-
-class MetadataManager {
-public:
-	//! The amount of metadata blocks per storage block
-	static constexpr const idx_t METADATA_BLOCK_COUNT = 64;
-
-public:
-	MetadataManager(BlockManager &block_manager, BufferManager &buffer_manager);
-	~MetadataManager();
-
-	MetadataHandle AllocateHandle();
-	MetadataHandle Pin(const MetadataPointer &pointer);
-
-	MetaBlockPointer GetDiskPointer(const MetadataPointer &pointer, uint32_t offset = 0);
-	MetadataPointer FromDiskPointer(MetaBlockPointer pointer);
-	MetadataPointer RegisterDiskPointer(MetaBlockPointer pointer);
-
-	static BlockPointer ToBlockPointer(MetaBlockPointer meta_pointer, const idx_t metadata_block_size);
-	static MetaBlockPointer FromBlockPointer(BlockPointer block_pointer, const idx_t metadata_block_size);
-
-	//! Flush all blocks to disk
-	void Flush();
-
-	void MarkBlocksAsModified();
-	void ClearModifiedBlocks(const vector<MetaBlockPointer> &pointers);
-
-	vector<MetadataBlockInfo> GetMetadataInfo() const;
-	vector<shared_ptr<BlockHandle>> GetBlocks() const;
-	idx_t BlockCount();
-
-	void Write(WriteStream &sink);
-	void Read(ReadStream &source);
-
-	idx_t GetMetadataBlockSize() const;
-
-protected:
-	BlockManager &block_manager;
-	BufferManager &buffer_manager;
-	unordered_map<block_id_t, MetadataBlock> blocks;
-	unordered_map<block_id_t, idx_t> modified_blocks;
-
-protected:
-	block_id_t AllocateNewBlock();
-	block_id_t PeekNextBlockId();
-	block_id_t GetNextBlockId();
-
-	void AddBlock(MetadataBlock new_block, bool if_exists = false);
-	void AddAndRegisterBlock(MetadataBlock block);
-	void ConvertToTransient(MetadataBlock &block);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp b/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp
deleted file mode 100644
index 1acb60fe2..000000000
--- a/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/metadata/metadata_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-
-namespace duckdb {
-
-enum class BlockReaderType { EXISTING_BLOCKS, REGISTER_BLOCKS };
-
-class MetadataReader : public ReadStream {
-public:
-	MetadataReader(MetadataManager &manager, MetaBlockPointer pointer,
-	               optional_ptr<vector<MetaBlockPointer>> read_pointers = nullptr,
-	               BlockReaderType type = BlockReaderType::EXISTING_BLOCKS);
-	MetadataReader(MetadataManager &manager, BlockPointer pointer);
-	~MetadataReader() override;
-
-public:
-	//! Read content of size read_size into the buffer
-	void ReadData(data_ptr_t buffer, idx_t read_size) override;
-
-	MetaBlockPointer GetMetaBlockPointer();
-
-	MetadataManager &GetMetadataManager() {
-		return manager;
-	}
-
-private:
-	data_ptr_t BasePtr();
-	data_ptr_t Ptr();
-
-	void ReadNextBlock();
-
-	MetadataPointer FromDiskPointer(MetaBlockPointer pointer);
-
-private:
-	MetadataManager &manager;
-	BlockReaderType type;
-	MetadataHandle block;
-	MetadataPointer next_pointer;
-	bool has_next_block;
-	optional_ptr<vector<MetaBlockPointer>> read_pointers;
-	idx_t index;
-	idx_t offset;
-	idx_t next_offset;
-	idx_t capacity;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp b/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp
deleted file mode 100644
index 206451b77..000000000
--- a/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/metadata/metadata_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-
-namespace duckdb {
-
-class MetadataWriter : public WriteStream {
-public:
-	explicit MetadataWriter(MetadataManager &manager,
-	                        optional_ptr<vector<MetaBlockPointer>> written_pointers = nullptr);
-	MetadataWriter(const MetadataWriter &) = delete;
-	MetadataWriter &operator=(const MetadataWriter &) = delete;
-	~MetadataWriter() override;
-
-public:
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-	void Flush();
-
-	BlockPointer GetBlockPointer();
-	MetaBlockPointer GetMetaBlockPointer();
-	MetadataManager &GetManager() {
-		return manager;
-	}
-
-protected:
-	virtual MetadataHandle NextHandle();
-
-private:
-	data_ptr_t BasePtr();
-	data_ptr_t Ptr();
-
-	void NextBlock();
-
-private:
-	MetadataManager &manager;
-	MetadataHandle block;
-	MetadataPointer current_pointer;
-	optional_ptr<vector<MetaBlockPointer>> written_pointers;
-	idx_t capacity;
-	idx_t offset;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/object_cache.hpp b/src/duckdb/src/include/duckdb/storage/object_cache.hpp
deleted file mode 100644
index 96c3bf718..000000000
--- a/src/duckdb/src/include/duckdb/storage/object_cache.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/object_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-
-namespace duckdb {
-
-//! ObjectCache is the base class for objects caches in DuckDB
-class ObjectCacheEntry {
-public:
-	virtual ~ObjectCacheEntry() {
-	}
-
-	virtual string GetObjectType() = 0;
-};
-
-class ObjectCache {
-public:
-	shared_ptr<ObjectCacheEntry> GetObject(const string &key) {
-		lock_guard<mutex> glock(lock);
-		auto entry = cache.find(key);
-		if (entry == cache.end()) {
-			return nullptr;
-		}
-		return entry->second;
-	}
-
-	template <class T>
-	shared_ptr<T> Get(const string &key) {
-		shared_ptr<ObjectCacheEntry> object = GetObject(key);
-		if (!object || object->GetObjectType() != T::ObjectType()) {
-			return nullptr;
-		}
-		return shared_ptr_cast<ObjectCacheEntry, T>(object);
-	}
-
-	template <class T, class... ARGS>
-	shared_ptr<T> GetOrCreate(const string &key, ARGS &&... args) {
-		lock_guard<mutex> glock(lock);
-
-		auto entry = cache.find(key);
-		if (entry == cache.end()) {
-			auto value = make_shared_ptr<T>(args...);
-			cache[key] = value;
-			return value;
-		}
-		auto object = entry->second;
-		if (!object || object->GetObjectType() != T::ObjectType()) {
-			return nullptr;
-		}
-		return shared_ptr_cast<ObjectCacheEntry, T>(object);
-	}
-
-	void Put(string key, shared_ptr<ObjectCacheEntry> value) {
-		lock_guard<mutex> glock(lock);
-		cache.insert(make_pair(std::move(key), std::move(value)));
-	}
-
-	void Delete(const string &key) {
-		lock_guard<mutex> glock(lock);
-		cache.erase(key);
-	}
-
-	DUCKDB_API static ObjectCache &GetObjectCache(ClientContext &context);
-
-private:
-	//! Object Cache
-	unordered_map<string, shared_ptr<ObjectCacheEntry>> cache;
-	mutex lock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/optimistic_data_writer.hpp b/src/duckdb/src/include/duckdb/storage/optimistic_data_writer.hpp
deleted file mode 100644
index 802d51bad..000000000
--- a/src/duckdb/src/include/duckdb/storage/optimistic_data_writer.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/optimistic_data_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/row_group_collection.hpp"
-
-namespace duckdb {
-class PartialBlockManager;
-
-class OptimisticDataWriter {
-public:
-	explicit OptimisticDataWriter(DataTable &table);
-	OptimisticDataWriter(DataTable &table, OptimisticDataWriter &parent);
-	~OptimisticDataWriter();
-
-	//! Write a new row group to disk (if possible)
-	void WriteNewRowGroup(RowGroupCollection &row_groups);
-	//! Write the last row group of a collection to disk
-	void WriteLastRowGroup(RowGroupCollection &row_groups);
-	//! Final flush of the optimistic writer - fully flushes the partial block manager
-	void FinalFlush();
-	//! Flushes a specific row group to disk
-	void FlushToDisk(RowGroup &row_group);
-	//! Merge the partially written blocks from one optimistic writer into another
-	void Merge(OptimisticDataWriter &other);
-	//! Rollback
-	void Rollback();
-
-private:
-	//! Prepare a write to disk
-	bool PrepareWrite();
-
-private:
-	//! The table
-	DataTable &table;
-	//! The partial block manager (if we created one yet)
-	unique_ptr<PartialBlockManager> partial_manager;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp b/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp
deleted file mode 100644
index b46ea65ad..000000000
--- a/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/partial_block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-class ClientContext;
-class ColumnSegment;
-class MetadataReader;
-class SchemaCatalogEntry;
-class SequenceCatalogEntry;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class TypeCatalogEntry;
-
-//! Regions that require zero-initialization to avoid leaking memory
-struct UninitializedRegion {
-	idx_t start;
-	idx_t end;
-};
-
-//! The current state of a partial block
-struct PartialBlockState {
-	//! The block id of the partial block
-	block_id_t block_id;
-	//! The total bytes that we can assign to this block
-	uint32_t block_size;
-	//! Next allocation offset, and also the current allocation size
-	uint32_t offset;
-	//! The number of times that this block has been used for partial allocations
-	uint32_t block_use_count;
-};
-
-struct PartialBlock {
-	PartialBlock(PartialBlockState state, BlockManager &block_manager, const shared_ptr<BlockHandle> &block_handle);
-	virtual ~PartialBlock() {
-	}
-
-	//! The current state of a partial block
-	PartialBlockState state;
-	//! All uninitialized regions on this block, we need to zero-initialize them when flushing
-	vector<UninitializedRegion> uninitialized_regions;
-	//! The block manager of the partial block manager
-	BlockManager &block_manager;
-	//! The block handle of the underlying block that this partial block writes to
-	shared_ptr<BlockHandle> block_handle;
-
-public:
-	//! Add regions that need zero-initialization to avoid leaking memory
-	void AddUninitializedRegion(const idx_t start, const idx_t end);
-	//! Flush the block to disk and zero-initialize any free space and uninitialized regions
-	virtual void Flush(const idx_t free_space_left) = 0;
-	void FlushInternal(const idx_t free_space_left);
-	virtual void Merge(PartialBlock &other, idx_t offset, idx_t other_size) = 0;
-	virtual void Clear() = 0;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-};
-
-struct PartialBlockAllocation {
-	//! The BlockManager owning the block_id
-	BlockManager *block_manager {nullptr};
-	//! The number of assigned bytes to the caller
-	uint32_t allocation_size;
-	//! The current state of the partial block
-	PartialBlockState state;
-	//! Arbitrary state related to the partial block storage
-	unique_ptr<PartialBlock> partial_block;
-};
-
-enum class PartialBlockType { FULL_CHECKPOINT, APPEND_TO_TABLE };
-
-//! Enables sharing blocks across some scope. Scope is whatever we want to share
-//! blocks across. It may be an entire checkpoint or just a single row group.
-//! In any case, they must share a block manager.
-class PartialBlockManager {
-public:
-	//! Max number of shared references to a block. No effective limit by default.
-	static constexpr const idx_t DEFAULT_MAX_USE_COUNT = 1u << 20;
-	//! No point letting map size grow unbounded. We'll drop blocks with the
-	//! least free space first.
-	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1u << 31;
-
-public:
-	PartialBlockManager(BlockManager &block_manager, PartialBlockType partial_block_type,
-	                    optional_idx max_partial_block_size = optional_idx(),
-	                    uint32_t max_use_count = DEFAULT_MAX_USE_COUNT);
-	virtual ~PartialBlockManager();
-
-public:
-	PartialBlockAllocation GetBlockAllocation(uint32_t segment_size);
-
-	//! Register a partially filled block that is filled with "segment_size" entries
-	void RegisterPartialBlock(PartialBlockAllocation allocation);
-
-	//! Clear remaining blocks without writing them to disk
-	void ClearBlocks();
-
-	//! Rollback all data written by this partial block manager
-	void Rollback();
-
-	//! Merge this block manager into another one
-	void Merge(PartialBlockManager &other);
-
-	//! Flush any remaining partial blocks to disk
-	void FlushPartialBlocks();
-
-	unique_lock<mutex> GetLock() {
-		return unique_lock<mutex>(partial_block_lock);
-	}
-
-	//! Returns a reference to the underlying block manager.
-	BlockManager &GetBlockManager() const;
-
-	//! Registers a block as "written" by this partial block manager
-	void AddWrittenBlock(block_id_t block);
-
-protected:
-	BlockManager &block_manager;
-	PartialBlockType partial_block_type;
-	mutex partial_block_lock;
-	//! A map of (available space -> PartialBlock) for partially filled blocks
-	//! This is a multimap because there might be outstanding partial blocks with
-	//! the same amount of left-over space
-	multimap<idx_t, unique_ptr<PartialBlock>> partially_filled_blocks;
-	//! The set of written blocks
-	unordered_set<block_id_t> written_blocks;
-
-	//! The maximum size (in bytes) at which a partial block will be considered a partial block
-	uint32_t max_partial_block_size;
-	uint32_t max_use_count;
-
-protected:
-	virtual void AllocateBlock(PartialBlockState &state, uint32_t segment_size);
-	//! Try to obtain a partially filled block that can fit "segment_size" bytes
-	//! If successful, returns true and returns the block_id and offset_in_block to write to
-	//! Otherwise, returns false
-	bool GetPartialBlock(idx_t segment_size, unique_ptr<PartialBlock> &state);
-
-	bool HasBlockAllocation(uint32_t segment_size);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp b/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp
deleted file mode 100644
index fb6dd6c0e..000000000
--- a/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/segment/uncompressed.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_segment.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-
-struct UncompressedFunctions {
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointData &checkpoint_data,
-	                                                    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);
-	static void AlignedScan(data_ptr_t input, idx_t input_start, Vector &result, idx_t scan_count);
-	static void UnalignedScan(data_ptr_t input, idx_t input_size, idx_t input_start, Vector &result,
-	                          idx_t result_offset, idx_t scan_count);
-
-public:
-	static const validity_t LOWER_MASKS[65];
-	static const validity_t UPPER_MASKS[65];
-};
-
-struct StringUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
-	static idx_t GetStringBlockLimit(const idx_t block_size) {
-		return MinValue(AlignValueFloor(block_size / 4), DEFAULT_STRING_BLOCK_LIMIT);
-	}
-
-public:
-	//! The default maximum string size for sufficiently big block sizes
-	static constexpr idx_t DEFAULT_STRING_BLOCK_LIMIT = 4096;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp b/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp
deleted file mode 100644
index 5e34305bd..000000000
--- a/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/single_file_block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-class DatabaseInstance;
-struct MetadataHandle;
-
-struct StorageManagerOptions {
-	bool read_only = false;
-	bool use_direct_io = false;
-	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
-	optional_idx block_alloc_size = optional_idx();
-};
-
-//! SingleFileBlockManager is an implementation for a BlockManager which manages blocks in a single file
-class SingleFileBlockManager : public BlockManager {
-	//! The location in the file where the block writing starts
-	static constexpr uint64_t BLOCK_START = Storage::FILE_HEADER_SIZE * 3;
-
-public:
-	SingleFileBlockManager(AttachedDatabase &db, const string &path, const StorageManagerOptions &options);
-
-	FileOpenFlags GetFileFlags(bool create_new) const;
-	//! Creates a new database.
-	void CreateNewDatabase();
-	//! Loads an existing database. We pass the provided block allocation size as a parameter
-	//! to detect inconsistencies with the file header.
-	void LoadExistingDatabase();
-
-	//! Creates a new Block using the specified block_id and returns a pointer
-	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override;
-	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override;
-	//! Return the next free block id
-	block_id_t GetFreeBlockId() override;
-	//! Check the next free block id - but do not assign or allocate it
-	block_id_t PeekFreeBlockId() override;
-	//! Returns whether or not a specified block is the root block
-	bool IsRootBlock(MetaBlockPointer root) override;
-	//! Mark a block as free (immediately re-writeable)
-	void MarkBlockAsFree(block_id_t block_id) override;
-	//! Mark a block as used (no longer re-writeable)
-	void MarkBlockAsUsed(block_id_t block_id) override;
-	//! Mark a block as modified (re-writeable after a checkpoint)
-	void MarkBlockAsModified(block_id_t block_id) override;
-	//! Increase the reference count of a block. The block should hold at least one reference
-	void IncreaseBlockReferenceCount(block_id_t block_id) override;
-	//! Return the meta block id
-	idx_t GetMetaBlock() override;
-	//! Read the content of the block from disk
-	void Read(Block &block) override;
-	//! Read the content of a range of blocks into a buffer
-	void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) override;
-	//! Write the given block to disk
-	void Write(FileBuffer &block, block_id_t block_id) override;
-	//! Write the header to disk, this is the final step of the checkpointing process
-	void WriteHeader(DatabaseHeader header) override;
-	//! Sync changes to the underlying file
-	void FileSync() override;
-	//! Truncate the underlying database file after a checkpoint
-	void Truncate() override;
-
-	bool InMemory() override {
-		return false;
-	}
-	//! Returns the number of total blocks
-	idx_t TotalBlocks() override;
-	//! Returns the number of free blocks
-	idx_t FreeBlocks() override;
-	//! Whether or not the attached database is a remote file
-	bool IsRemote() override;
-
-private:
-	//! Loads the free list of the file.
-	void LoadFreeList();
-	//! Initializes the database header. We pass the provided block allocation size as a parameter
-	//!	to detect inconsistencies with the file header.
-	void Initialize(const DatabaseHeader &header, const optional_idx block_alloc_size);
-
-	void ReadAndChecksum(FileBuffer &handle, uint64_t location) const;
-	void ChecksumAndWrite(FileBuffer &handle, uint64_t location) const;
-
-	idx_t GetBlockLocation(block_id_t block_id);
-
-	//! Return the blocks to which we will write the free list and modified blocks
-	vector<MetadataHandle> GetFreeListBlocks();
-	void TrimFreeBlocks();
-
-	void IncreaseBlockReferenceCountInternal(block_id_t block_id);
-
-	//! Verify the block usage count
-	void VerifyBlocks(const unordered_map<block_id_t, idx_t> &block_usage_count) override;
-
-private:
-	AttachedDatabase &db;
-	//! The active DatabaseHeader, either 0 (h1) or 1 (h2)
-	uint8_t active_header;
-	//! The path where the file is stored
-	string path;
-	//! The file handle
-	unique_ptr<FileHandle> handle;
-	//! The buffer used to read/write to the headers
-	FileBuffer header_buffer;
-	//! The list of free blocks that can be written to currently
-	set<block_id_t> free_list;
-	//! The list of blocks that were freed since the last checkpoint.
-	set<block_id_t> newly_freed_list;
-	//! The list of multi-use blocks (i.e. blocks that have >1 reference in the file)
-	//! When a multi-use block is marked as modified, the reference count is decreased by 1 instead of directly
-	//! Appending the block to the modified_blocks list
-	unordered_map<block_id_t, uint32_t> multi_use_blocks;
-	//! The list of blocks that will be added to the free list
-	unordered_set<block_id_t> modified_blocks;
-	//! The current meta block id
-	idx_t meta_block;
-	//! The current maximum block id, this id will be given away first after the free_list runs out
-	block_id_t max_block;
-	//! The block id where the free list can be found
-	idx_t free_list_id;
-	//! The current header iteration count
-	uint64_t iteration_count;
-	//! The storage manager options
-	StorageManagerOptions options;
-	//! Lock for performing various operations in the single file block manager
-	mutex block_lock;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp b/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp
deleted file mode 100644
index 93c348a6a..000000000
--- a/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/standard_buffer_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-class BlockManager;
-class TemporaryMemoryManager;
-class DatabaseInstance;
-class TemporaryDirectoryHandle;
-struct EvictionQueue;
-
-//! The BufferManager is in charge of handling memory management for a single database. It cooperatively shares a
-//! BufferPool with other BufferManagers, belonging to different databases. It hands out memory buffers that can
-//! be used by the database internally, and offers configuration options specific to a database, which need not be
-//! shared by the BufferPool, including whether to support swapping temp buffers to disk, and where to swap them to.
-class StandardBufferManager : public BufferManager {
-	friend class BufferHandle;
-	friend class BlockHandle;
-	friend class BlockManager;
-
-public:
-	StandardBufferManager(DatabaseInstance &db, string temp_directory);
-	~StandardBufferManager() override;
-
-public:
-	static unique_ptr<StandardBufferManager> CreateBufferManager(DatabaseInstance &db, string temp_directory);
-	static unique_ptr<FileBuffer> ReadTemporaryBufferInternal(BufferManager &buffer_manager, FileHandle &handle,
-	                                                          idx_t position, idx_t size,
-	                                                          unique_ptr<FileBuffer> reusable_buffer);
-
-	//! Registers a transient memory buffer.
-	shared_ptr<BlockHandle> RegisterTransientMemory(const idx_t size, const idx_t block_size) final;
-	//! Registers an in-memory buffer that cannot be unloaded until it is destroyed.
-	//! This buffer can be small (smaller than the block size of the temporary block manager).
-	//! Unpin and Pin are NOPs on this block of memory.
-	shared_ptr<BlockHandle> RegisterSmallMemory(MemoryTag tag, const idx_t size) final;
-
-	idx_t GetUsedMemory() const final;
-	idx_t GetMaxMemory() const final;
-	idx_t GetUsedSwap() final;
-	optional_idx GetMaxSwap() const final;
-	//! Returns the block allocation size for buffer-managed blocks.
-	idx_t GetBlockAllocSize() const final;
-	//! Returns the block size for buffer-managed blocks.
-	idx_t GetBlockSize() const final;
-
-	//! Allocate an in-memory buffer with a single pin.
-	//! The allocated memory is released when the buffer handle is destroyed.
-	DUCKDB_API BufferHandle Allocate(MemoryTag tag, idx_t block_size, bool can_destroy = true) final;
-
-	//! Reallocate an in-memory buffer that is pinned.
-	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) final;
-
-	BufferHandle Pin(shared_ptr<BlockHandle> &handle) final;
-	void Prefetch(vector<shared_ptr<BlockHandle>> &handles) final;
-	void Unpin(shared_ptr<BlockHandle> &handle) final;
-
-	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetMemoryLimit(idx_t limit = (idx_t)-1) final;
-	void SetSwapLimit(optional_idx limit = optional_idx()) final;
-
-	//! Returns information about memory usage
-	vector<MemoryInformation> GetMemoryUsageInfo() const override;
-
-	//! Returns a list of all temporary files
-	vector<TemporaryFileInformation> GetTemporaryFiles() final;
-
-	const string &GetTemporaryDirectory() const final {
-		return temporary_directory.path;
-	}
-
-	void SetTemporaryDirectory(const string &new_dir) final;
-
-	DUCKDB_API Allocator &GetBufferAllocator() final;
-
-	DatabaseInstance &GetDatabase() override {
-		return db;
-	}
-
-	//! Construct a managed buffer.
-	unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
-	                                              FileBufferType type = FileBufferType::MANAGED_BUFFER) override;
-
-	DUCKDB_API void ReserveMemory(idx_t size) final;
-	DUCKDB_API void FreeReservedMemory(idx_t size) final;
-	bool HasTemporaryDirectory() const final;
-
-protected:
-	//! Helper
-	template <typename... ARGS>
-	TempBufferPoolReservation EvictBlocksOrThrow(MemoryTag tag, idx_t memory_delta, unique_ptr<FileBuffer> *buffer,
-	                                             ARGS...);
-
-	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
-	//! not the buffer can be destroyed instead of evicted,
-	//! if true, it will be destroyed,
-	//! if false, it will be written to a temporary file so it can be reloaded
-	//! If we want to change this, e.g., to immediately destroy the buffer upon unpinning,
-	//! we can call BlockHandle::SetDestroyBufferUpon
-	//! The resulting buffer will already be allocated, but needs to be pinned in order to be used.
-	//! This needs to be private to prevent creating blocks without ever pinning them:
-	//! blocks that are never pinned are never added to the eviction queue
-	shared_ptr<BlockHandle> RegisterMemory(MemoryTag tag, idx_t block_size, bool can_destroy);
-
-	//! Garbage collect eviction queue
-	void PurgeQueue(const BlockHandle &handle) final;
-
-	BufferPool &GetBufferPool() const final;
-	TemporaryMemoryManager &GetTemporaryMemoryManager() final;
-
-	//! Write a temporary buffer to disk
-	void WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) final;
-	//! Read a temporary buffer from disk
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(MemoryTag tag, BlockHandle &block,
-	                                           unique_ptr<FileBuffer> buffer = nullptr) final;
-	//! Get the path of the temporary buffer
-	string GetTemporaryPath(block_id_t id);
-
-	void DeleteTemporaryFile(BlockHandle &block) final;
-
-	void RequireTemporaryDirectory();
-
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle) final;
-
-	const char *InMemoryWarning();
-
-	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
-	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-	static data_ptr_t BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                         idx_t size);
-
-	//! When the BlockHandle reaches 0 readers, this creates a new FileBuffer for this BlockHandle and
-	//! overwrites the data within with garbage. Any readers that do not hold the pin will notice
-	void VerifyZeroReaders(BlockLock &l, shared_ptr<BlockHandle> &handle);
-
-	void BatchRead(vector<shared_ptr<BlockHandle>> &handles, const map<block_id_t, idx_t> &load_map,
-	               block_id_t first_block, block_id_t last_block);
-
-protected:
-	// These are stored here because temp_directory creation is lazy
-	// so we need to store information related to the temporary directory before it's created
-	struct TemporaryFileData {
-		//! The directory name where temporary files are stored
-		string path;
-		//! Lock for creating the temp handle (marked mutable so 'GetMaxSwap' can be const)
-		mutable mutex lock;
-		//! Handle for the temporary directory
-		unique_ptr<TemporaryDirectoryHandle> handle;
-		//! The maximum swap space that can be used
-		optional_idx maximum_swap_space = optional_idx();
-	};
-
-protected:
-	//! The database instance
-	DatabaseInstance &db;
-	//! The buffer pool
-	BufferPool &buffer_pool;
-	//! The variables related to temporary file management
-	TemporaryFileData temporary_directory;
-	//! The temporary id used for managed buffers
-	atomic<block_id_t> temporary_id;
-	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
-	Allocator buffer_allocator;
-	//! Block manager for temp data
-	unique_ptr<BlockManager> temp_block_manager;
-	//! Temporary evicted memory data per tag
-	atomic<idx_t> evicted_data_per_tag[MEMORY_TAG_COUNT];
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/array_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/array_stats.hpp
deleted file mode 100644
index 7a37abc88..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/array_stats.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/array_stats.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-struct SelectionVector;
-class Vector;
-class Serializer;
-class Deserializer;
-
-struct ArrayStats {
-	DUCKDB_API static void Construct(BaseStatistics &stats);
-	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
-	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
-
-	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats);
-	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats);
-	DUCKDB_API static void SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats);
-
-	DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer);
-	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
-
-	DUCKDB_API static string ToString(const BaseStatistics &stats);
-
-	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp b/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp
deleted file mode 100644
index e4aae58a5..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp
+++ /dev/null
@@ -1,161 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/base_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/statistics/numeric_stats.hpp"
-#include "duckdb/storage/statistics/string_stats.hpp"
-
-namespace duckdb {
-struct SelectionVector;
-
-class Serializer;
-class Deserializer;
-
-class Vector;
-struct UnifiedVectorFormat;
-
-enum class StatsInfo : uint8_t {
-	CAN_HAVE_NULL_VALUES = 0,
-	CANNOT_HAVE_NULL_VALUES = 1,
-	CAN_HAVE_VALID_VALUES = 2,
-	CANNOT_HAVE_VALID_VALUES = 3,
-	CAN_HAVE_NULL_AND_VALID_VALUES = 4
-};
-
-enum class StatisticsType : uint8_t { NUMERIC_STATS, STRING_STATS, LIST_STATS, STRUCT_STATS, BASE_STATS, ARRAY_STATS };
-
-class BaseStatistics {
-	friend struct NumericStats;
-	friend struct StringStats;
-	friend struct StructStats;
-	friend struct ListStats;
-	friend struct ArrayStats;
-
-public:
-	DUCKDB_API ~BaseStatistics();
-	// disable copy constructors
-	BaseStatistics(const BaseStatistics &other) = delete;
-	BaseStatistics &operator=(const BaseStatistics &) = delete;
-	//! enable move constructors
-	DUCKDB_API BaseStatistics(BaseStatistics &&other) noexcept;
-	DUCKDB_API BaseStatistics &operator=(BaseStatistics &&) noexcept;
-
-public:
-	//! Creates a set of statistics for data that is unknown, i.e. "has_null" is true, "has_no_null" is true, etc
-	//! This can be used in case nothing is known about the data - or can be used as a baseline when only a few things
-	//! are known
-	static BaseStatistics CreateUnknown(LogicalType type);
-	//! Creates statistics for an empty database, i.e. "has_null" is false, "has_no_null" is false, etc
-	//! This is used when incrementally constructing statistics by constantly adding new values
-	static BaseStatistics CreateEmpty(LogicalType type);
-
-	DUCKDB_API StatisticsType GetStatsType() const;
-	DUCKDB_API static StatisticsType GetStatsType(const LogicalType &type);
-
-	DUCKDB_API bool CanHaveNull() const;
-	DUCKDB_API bool CanHaveNoNull() const;
-
-	void SetDistinctCount(idx_t distinct_count);
-
-	bool IsConstant() const;
-
-	const LogicalType &GetType() const {
-		return type;
-	}
-
-	void Set(StatsInfo info);
-	void CombineValidity(BaseStatistics &left, BaseStatistics &right);
-	void CopyValidity(BaseStatistics &stats);
-	//! Set that the CURRENT level can have null values
-	//! Note that this is not correct for nested types unless this information is propagated in a different manner
-	//! Use Set(StatsInfo::CAN_HAVE_NULL_VALUES) in the general case
-	inline void SetHasNullFast() {
-		has_null = true;
-	}
-	//! Set that the CURRENT level can have valiod values
-	//! Note that this is not correct for nested types unless this information is propagated in a different manner
-	//! Use Set(StatsInfo::CAN_HAVE_VALID_VALUES) in the general case
-	inline void SetHasNoNullFast() {
-		has_no_null = true;
-	}
-	void SetHasNull();
-	void SetHasNoNull();
-
-	void Merge(const BaseStatistics &other);
-
-	void Copy(const BaseStatistics &other);
-
-	BaseStatistics Copy() const;
-	unique_ptr<BaseStatistics> ToUnique() const;
-	void CopyBase(const BaseStatistics &orig);
-
-	void Serialize(Serializer &serializer) const;
-	static BaseStatistics Deserialize(Deserializer &deserializer);
-
-	//! Verify that a vector does not violate the statistics
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
-	void Verify(Vector &vector, idx_t count) const;
-
-	string ToString() const;
-
-	idx_t GetDistinctCount();
-	static BaseStatistics FromConstant(const Value &input);
-
-	template <class T>
-	void UpdateNumericStats(T new_value) {
-		D_ASSERT(GetStatsType() == StatisticsType::NUMERIC_STATS);
-		NumericStats::Update(stats_union.numeric_data, new_value);
-	}
-
-private:
-	BaseStatistics();
-	explicit BaseStatistics(LogicalType type);
-
-	static void Construct(BaseStatistics &stats, LogicalType type);
-
-	void InitializeUnknown();
-	void InitializeEmpty();
-
-	static BaseStatistics CreateUnknownType(LogicalType type);
-	static BaseStatistics CreateEmptyType(LogicalType type);
-	static BaseStatistics FromConstantType(const Value &input);
-
-private:
-	//! The type of the logical segment
-	LogicalType type;
-	//! Whether or not the segment can contain NULL values
-	bool has_null;
-	//! Whether or not the segment can contain values that are not null
-	bool has_no_null;
-	// estimate that one may have even if distinct_stats==nullptr
-	idx_t distinct_count;
-	//! Numeric and String stats
-	union {
-		//! Numeric stats data, for numeric stats
-		NumericStatsData numeric_data;
-		//! String stats data, for string stats
-		StringStatsData string_data;
-	} stats_union;
-	//! Child stats (for LIST and STRUCT)
-	unsafe_unique_array<BaseStatistics> child_stats;
-};
-
-template <>
-inline void BaseStatistics::UpdateNumericStats<interval_t>(interval_t new_value) {
-}
-template <>
-inline void BaseStatistics::UpdateNumericStats<list_entry_t>(list_entry_t new_value) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/column_statistics.hpp b/src/duckdb/src/include/duckdb/storage/statistics/column_statistics.hpp
deleted file mode 100644
index 12f8d5672..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/column_statistics.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/column_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-
-namespace duckdb {
-class Serializer;
-
-class ColumnStatistics {
-public:
-	explicit ColumnStatistics(BaseStatistics stats_p);
-	ColumnStatistics(BaseStatistics stats_p, unique_ptr<DistinctStatistics> distinct_stats_p);
-
-public:
-	static shared_ptr<ColumnStatistics> CreateEmptyStats(const LogicalType &type);
-
-	void Merge(ColumnStatistics &other);
-
-	void UpdateDistinctStatistics(Vector &v, idx_t count, Vector &hashes);
-
-	BaseStatistics &Statistics();
-
-	bool HasDistinctStats();
-	DistinctStatistics &DistinctStats();
-	void SetDistinct(unique_ptr<DistinctStatistics> distinct_stats);
-
-	shared_ptr<ColumnStatistics> Copy() const;
-
-	void Serialize(Serializer &serializer) const;
-	static shared_ptr<ColumnStatistics> Deserialize(Deserializer &source);
-
-private:
-	BaseStatistics stats;
-	//! The approximate count distinct stats of the column
-	unique_ptr<DistinctStatistics> distinct_stats;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/distinct_statistics.hpp b/src/duckdb/src/include/duckdb/storage/statistics/distinct_statistics.hpp
deleted file mode 100644
index aaa4acb0e..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/distinct_statistics.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/distinct_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/types/hyperloglog.hpp"
-
-namespace duckdb {
-class Vector;
-class Serializer;
-class Deserializer;
-
-class DistinctStatistics {
-public:
-	DistinctStatistics();
-	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
-
-	//! The HLL of the table
-	unique_ptr<HyperLogLog> log;
-	//! How many values have been sampled into the HLL
-	atomic<idx_t> sample_count;
-	//! How many values have been inserted (before sampling)
-	atomic<idx_t> total_count;
-
-public:
-	void Merge(const DistinctStatistics &other);
-
-	unique_ptr<DistinctStatistics> Copy() const;
-
-	void UpdateSample(Vector &new_data, idx_t count, Vector &hashes);
-	void Update(Vector &new_data, idx_t count, Vector &hashes);
-
-	string ToString() const;
-	idx_t GetCount() const;
-
-	static bool TypeIsSupported(const LogicalType &type);
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &deserializer);
-
-private:
-	void UpdateInternal(Vector &update, idx_t count, Vector &hashes);
-
-private:
-	//! For distinct statistics we sample the input to speed up insertions
-	static constexpr double BASE_SAMPLE_RATE = 0.1;
-	//! For integers, we sample more: likely to be join keys (and hashing is cheaper than, e.g., strings)
-	static constexpr double INTEGRAL_SAMPLE_RATE = 0.3;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/list_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/list_stats.hpp
deleted file mode 100644
index 8dfb2f437..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/list_stats.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/list_stats.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-struct SelectionVector;
-class Vector;
-
-struct ListStats {
-	DUCKDB_API static void Construct(BaseStatistics &stats);
-	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
-	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
-
-	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats);
-	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats);
-	DUCKDB_API static void SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats);
-
-	DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer);
-	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
-
-	DUCKDB_API static string ToString(const BaseStatistics &stats);
-
-	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/node_statistics.hpp b/src/duckdb/src/include/duckdb/storage/statistics/node_statistics.hpp
deleted file mode 100644
index 31b5c3dcf..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/node_statistics.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/node_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-class NodeStatistics {
-public:
-	NodeStatistics() : has_estimated_cardinality(false), has_max_cardinality(false) {
-	}
-	explicit NodeStatistics(idx_t estimated_cardinality)
-	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(false) {
-	}
-	NodeStatistics(idx_t estimated_cardinality, idx_t max_cardinality)
-	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(true),
-	      max_cardinality(max_cardinality) {
-	}
-
-	//! Whether or not the node has an estimated cardinality specified
-	bool has_estimated_cardinality;
-	//! The estimated cardinality at the specified node
-	idx_t estimated_cardinality;
-	//! Whether or not the node has a maximum cardinality specified
-	bool has_max_cardinality;
-	//! The max possible cardinality at the specified node
-	idx_t max_cardinality;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats.hpp
deleted file mode 100644
index 342a6f30b..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/numeric_stats.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/statistics/numeric_stats_union.hpp"
-#include "duckdb/common/array_ptr.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-struct SelectionVector;
-class Vector;
-
-struct NumericStatsData {
-	//! Whether or not the value has a max value
-	bool has_min;
-	//! Whether or not the segment has a min value
-	bool has_max;
-	//! The minimum value of the segment
-	NumericValueUnion min;
-	//! The maximum value of the segment
-	NumericValueUnion max;
-};
-
-struct NumericStats {
-	//! Unknown statistics - i.e. "has_min" is false, "has_max" is false
-	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
-	//! Empty statistics - i.e. "min = MaxValue<type>, max = MinValue<type>"
-	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
-
-	//! Returns true if the stats has a constant value
-	DUCKDB_API static bool IsConstant(const BaseStatistics &stats);
-	//! Returns true if the stats has both a min and max value defined
-	DUCKDB_API static bool HasMinMax(const BaseStatistics &stats);
-	//! Returns true if the stats has a min value defined
-	DUCKDB_API static bool HasMin(const BaseStatistics &stats);
-	//! Returns true if the stats has a max value defined
-	DUCKDB_API static bool HasMax(const BaseStatistics &stats);
-	//! Returns the min value - throws an exception if there is no min value
-	DUCKDB_API static Value Min(const BaseStatistics &stats);
-	//! Returns the max value - throws an exception if there is no max value
-	DUCKDB_API static Value Max(const BaseStatistics &stats);
-	//! Sets the min value of the statistics
-	DUCKDB_API static void SetMin(BaseStatistics &stats, const Value &val);
-	//! Sets the max value of the statistics
-	DUCKDB_API static void SetMax(BaseStatistics &stats, const Value &val);
-
-	template <class T>
-	static void SetMax(BaseStatistics &stats, T val) {
-		auto &nstats = GetDataUnsafe(stats);
-		nstats.has_max = true;
-		nstats.max.GetReferenceUnsafe<T>() = val;
-	}
-
-	template <class T>
-	static void SetMin(BaseStatistics &stats, T val) {
-		auto &nstats = GetDataUnsafe(stats);
-		nstats.has_min = true;
-		nstats.min.GetReferenceUnsafe<T>() = val;
-	}
-
-	//! Check whether or not a given comparison with a constant could possibly be satisfied by rows given the statistics
-	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-	                                                     array_ptr<Value> constants);
-
-	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other_p);
-
-	DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer);
-	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &stats);
-
-	DUCKDB_API static string ToString(const BaseStatistics &stats);
-
-	template <class T>
-	static inline void UpdateValue(T new_value, T &min, T &max) {
-		min = LessThan::Operation(new_value, min) ? new_value : min;
-		max = GreaterThan::Operation(new_value, max) ? new_value : max;
-	}
-	template <class T>
-	static inline void Update(NumericStatsData &nstats, T new_value) {
-		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
-	}
-
-	static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
-
-	template <class T>
-	static T GetMin(const BaseStatistics &stats) {
-		return NumericStats::Min(stats).GetValueUnsafe<T>();
-	}
-	template <class T>
-	static T GetMax(const BaseStatistics &stats) {
-		return NumericStats::Max(stats).GetValueUnsafe<T>();
-	}
-	template <class T>
-	static T GetMinUnsafe(const BaseStatistics &stats);
-	template <class T>
-	static T GetMaxUnsafe(const BaseStatistics &stats);
-
-private:
-	static NumericStatsData &GetDataUnsafe(BaseStatistics &stats);
-	static const NumericStatsData &GetDataUnsafe(const BaseStatistics &stats);
-	static Value MinOrNull(const BaseStatistics &stats);
-	static Value MaxOrNull(const BaseStatistics &stats);
-	template <class T>
-	static void TemplatedVerify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats_union.hpp b/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats_union.hpp
deleted file mode 100644
index 72d254f17..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats_union.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/numeric_stats_union.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-
-namespace duckdb {
-
-struct NumericValueUnion {
-	union Val {
-		bool boolean;
-		int8_t tinyint;
-		int16_t smallint;
-		int32_t integer;
-		int64_t bigint;
-		uint8_t utinyint;
-		uint16_t usmallint;
-		uint32_t uinteger;
-		uint64_t ubigint;
-		hugeint_t hugeint;
-		uhugeint_t uhugeint;
-		float float_;   // NOLINT
-		double double_; // NOLINT
-	} value_;           // NOLINT
-
-	template <class T>
-	T &GetReferenceUnsafe();
-};
-
-template <>
-DUCKDB_API inline bool &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.boolean;
-}
-
-template <>
-DUCKDB_API inline int8_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.tinyint;
-}
-
-template <>
-DUCKDB_API inline int16_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.smallint;
-}
-
-template <>
-DUCKDB_API inline int32_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.integer;
-}
-
-template <>
-DUCKDB_API inline int64_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.bigint;
-}
-
-template <>
-DUCKDB_API inline hugeint_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.hugeint;
-}
-
-template <>
-DUCKDB_API inline uhugeint_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.uhugeint;
-}
-
-template <>
-DUCKDB_API inline uint8_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.utinyint;
-}
-
-template <>
-DUCKDB_API inline uint16_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.usmallint;
-}
-
-template <>
-DUCKDB_API inline uint32_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.uinteger;
-}
-
-template <>
-DUCKDB_API inline uint64_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.ubigint;
-}
-
-template <>
-DUCKDB_API inline float &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.float_;
-}
-
-template <>
-DUCKDB_API inline double &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.double_;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/segment_statistics.hpp b/src/duckdb/src/include/duckdb/storage/statistics/segment_statistics.hpp
deleted file mode 100644
index 2690308ba..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/segment_statistics.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/segment_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-class SegmentStatistics {
-public:
-	explicit SegmentStatistics(LogicalType type);
-	explicit SegmentStatistics(BaseStatistics statistics);
-
-	//! Type-specific statistics of the segment
-	BaseStatistics statistics;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/string_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/string_stats.hpp
deleted file mode 100644
index 6ae410bea..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/string_stats.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/string_stats.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/array_ptr.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-struct SelectionVector;
-class Vector;
-
-struct StringStatsData {
-	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
-
-	//! The minimum value of the segment, potentially truncated
-	data_t min[MAX_STRING_MINMAX_SIZE];
-	//! The maximum value of the segment, potentially truncated
-	data_t max[MAX_STRING_MINMAX_SIZE];
-	//! Whether or not the column can contain unicode characters
-	bool has_unicode;
-	//! Whether or not the maximum string length is known
-	bool has_max_string_length;
-	//! The maximum string length in bytes
-	uint32_t max_string_length;
-};
-
-struct StringStats {
-	//! Unknown statistics - i.e. "has_unicode" is true, "max_string_length" is unknown, "min" is \0, max is \xFF
-	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
-	//! Empty statistics - i.e. "has_unicode" is false, "max_string_length" is 0, "min" is \xFF, max is \x00
-	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
-	//! Whether or not the statistics have a maximum string length defined
-	DUCKDB_API static bool HasMaxStringLength(const BaseStatistics &stats);
-	//! Returns the maximum string length, or throws an exception if !HasMaxStringLength()
-	DUCKDB_API static uint32_t MaxStringLength(const BaseStatistics &stats);
-	//! Whether or not the strings can contain unicode
-	DUCKDB_API static bool CanContainUnicode(const BaseStatistics &stats);
-	//! Returns the min value (up to a length of StringStatsData::MAX_STRING_MINMAX_SIZE)
-	DUCKDB_API static string Min(const BaseStatistics &stats);
-	//! Returns the max value (up to a length of StringStatsData::MAX_STRING_MINMAX_SIZE)
-	DUCKDB_API static string Max(const BaseStatistics &stats);
-
-	//! Resets the max string length so HasMaxStringLength() is false
-	DUCKDB_API static void ResetMaxStringLength(BaseStatistics &stats);
-	//! FIXME: make this part of Set on statistics
-	DUCKDB_API static void SetContainsUnicode(BaseStatistics &stats);
-
-	DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer);
-	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
-
-	DUCKDB_API static string ToString(const BaseStatistics &stats);
-
-	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-	                                                     array_ptr<Value> constants);
-	DUCKDB_API static FilterPropagateResult CheckZonemap(const_data_ptr_t min_data, idx_t min_len,
-	                                                     const_data_ptr_t max_data, idx_t max_len,
-	                                                     ExpressionType comparison_type, const string &value);
-
-	DUCKDB_API static void Update(BaseStatistics &stats, const string_t &value);
-	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
-
-private:
-	static StringStatsData &GetDataUnsafe(BaseStatistics &stats);
-	static const StringStatsData &GetDataUnsafe(const BaseStatistics &stats);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/statistics/struct_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/struct_stats.hpp
deleted file mode 100644
index 38b992f73..000000000
--- a/src/duckdb/src/include/duckdb/storage/statistics/struct_stats.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/struct_stats.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-struct SelectionVector;
-class Vector;
-
-struct StructStats {
-	DUCKDB_API static void Construct(BaseStatistics &stats);
-	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
-	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
-
-	DUCKDB_API static const BaseStatistics *GetChildStats(const BaseStatistics &stats);
-	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats, idx_t i);
-	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats, idx_t i);
-	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats);
-	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, unique_ptr<BaseStatistics> new_stats);
-
-	DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer);
-	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
-
-	DUCKDB_API static string ToString(const BaseStatistics &stats);
-
-	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
-	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/storage_extension.hpp b/src/duckdb/src/include/duckdb/storage/storage_extension.hpp
deleted file mode 100644
index eece0b096..000000000
--- a/src/duckdb/src/include/duckdb/storage/storage_extension.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/access_mode.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-
-namespace duckdb {
-class AttachedDatabase;
-struct AttachInfo;
-class Catalog;
-class TransactionManager;
-
-//! The StorageExtensionInfo holds static information relevant to the storage extension
-struct StorageExtensionInfo {
-	virtual ~StorageExtensionInfo() {
-	}
-};
-
-typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_info, ClientContext &context,
-                                                 AttachedDatabase &db, const string &name, AttachInfo &info,
-                                                 AccessMode access_mode);
-typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
-                                                                       AttachedDatabase &db, Catalog &catalog);
-
-class StorageExtension {
-public:
-	attach_function_t attach;
-	create_transaction_manager_t create_transaction_manager;
-
-	//! Additional info passed to the various storage functions
-	shared_ptr<StorageExtensionInfo> storage_info;
-
-	virtual ~StorageExtension() {
-	}
-
-	virtual void OnCheckpointStart(AttachedDatabase &db, CheckpointOptions checkpoint_options) {
-	}
-
-	virtual void OnCheckpointEnd(AttachedDatabase &db, CheckpointOptions checkpoint_options) {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/storage_index.hpp b/src/duckdb/src/include/duckdb/storage/storage_index.hpp
deleted file mode 100644
index 38ba99976..000000000
--- a/src/duckdb/src/include/duckdb/storage/storage_index.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-
-struct StorageIndex {
-	StorageIndex() : index(DConstants::INVALID_INDEX) {
-	}
-	explicit StorageIndex(idx_t index) : index(index) {
-	}
-	StorageIndex(idx_t index, vector<StorageIndex> child_indexes_p)
-	    : index(index), child_indexes(std::move(child_indexes_p)) {
-	}
-
-	inline bool operator==(const StorageIndex &rhs) const {
-		return index == rhs.index;
-	}
-	inline bool operator!=(const StorageIndex &rhs) const {
-		return index != rhs.index;
-	}
-	inline bool operator<(const StorageIndex &rhs) const {
-		return index < rhs.index;
-	}
-	idx_t GetPrimaryIndex() const {
-		return index;
-	}
-	PhysicalIndex ToPhysical() const {
-		return PhysicalIndex(index);
-	}
-	bool HasChildren() const {
-		return !child_indexes.empty();
-	}
-	idx_t ChildIndexCount() const {
-		return child_indexes.size();
-	}
-	const StorageIndex &GetChildIndex(idx_t idx) const {
-		return child_indexes[idx];
-	}
-	StorageIndex &GetChildIndex(idx_t idx) {
-		return child_indexes[idx];
-	}
-	const vector<StorageIndex> &GetChildIndexes() const {
-		return child_indexes;
-	}
-	void AddChildIndex(StorageIndex new_index) {
-		this->child_indexes.push_back(std::move(new_index));
-	}
-	void SetIndex(idx_t new_index) {
-		index = new_index;
-	}
-	bool IsRowIdColumn() const {
-		return index == DConstants::INVALID_INDEX;
-	}
-
-private:
-	idx_t index;
-	vector<StorageIndex> child_indexes;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/storage_info.hpp b/src/duckdb/src/include/duckdb/storage/storage_info.hpp
deleted file mode 100644
index a2047d720..000000000
--- a/src/duckdb/src/include/duckdb/storage/storage_info.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-struct FileHandle;
-
-//! The standard row group size
-#define DEFAULT_ROW_GROUP_SIZE 122880ULL
-//! The definition of an invalid block
-#define INVALID_BLOCK (-1)
-//! The maximum block id is 2^62
-#define MAXIMUM_BLOCK 4611686018427388000LL
-
-//! The default block allocation size.
-#define DEFAULT_BLOCK_ALLOC_SIZE 262144ULL
-//! The configurable block allocation size.
-#ifndef DUCKDB_BLOCK_ALLOC_SIZE
-#define DUCKDB_BLOCK_ALLOC_SIZE DEFAULT_BLOCK_ALLOC_SIZE
-#endif
-
-using block_id_t = int64_t;
-
-struct Storage {
-	//! The size of a hard disk sector, only really needed for Direct IO
-	constexpr static idx_t SECTOR_SIZE = 4096U;
-	//! The size of the headers. This should be small and written more or less atomically by the hard disk. We default
-	//! to the page size, which is 4KB. (1 << 12)
-	constexpr static idx_t FILE_HEADER_SIZE = 4096U;
-	//! The maximum row group size
-	constexpr static const idx_t MAX_ROW_GROUP_SIZE = 1ULL << 30ULL;
-
-	//! The minimum block allocation size. This is the minimum size we test in our nightly tests.
-	constexpr static idx_t MIN_BLOCK_ALLOC_SIZE = 16384ULL;
-	//! The maximum block allocation size. This is the maximum size currently supported by duckdb.
-	constexpr static idx_t MAX_BLOCK_ALLOC_SIZE = 262144ULL;
-	//! The default block header size for blocks written to storage.
-	constexpr static idx_t DEFAULT_BLOCK_HEADER_SIZE = sizeof(idx_t);
-	//! The default block size.
-	constexpr static idx_t DEFAULT_BLOCK_SIZE = DEFAULT_BLOCK_ALLOC_SIZE - DEFAULT_BLOCK_HEADER_SIZE;
-
-	//! Ensures that a user-provided block allocation size matches all requirements.
-	static void VerifyBlockAllocSize(const idx_t block_alloc_size);
-};
-
-//! The version number of the database storage format
-extern const uint64_t VERSION_NUMBER;
-string GetDuckDBVersion(idx_t version_number);
-optional_idx GetStorageVersion(const char *version_string);
-optional_idx GetSerializationVersion(const char *version_string);
-vector<string> GetSerializationCandidates();
-
-//! The MainHeader is the first header in the storage file. The MainHeader is typically written only once for a database
-//! file.
-struct MainHeader {
-	static constexpr idx_t MAX_VERSION_SIZE = 32;
-	static constexpr idx_t MAGIC_BYTE_SIZE = 4;
-	static constexpr idx_t MAGIC_BYTE_OFFSET = Storage::DEFAULT_BLOCK_HEADER_SIZE;
-	static constexpr idx_t FLAG_COUNT = 4;
-	//! The magic bytes in front of the file should be "DUCK"
-	static const char MAGIC_BYTES[];
-	//! The version of the database
-	uint64_t version_number;
-	//! The set of flags used by the database
-	uint64_t flags[FLAG_COUNT];
-	static void CheckMagicBytes(FileHandle &handle);
-
-	string LibraryGitDesc() {
-		return string(char_ptr_cast(library_git_desc), 0, MAX_VERSION_SIZE);
-	}
-	string LibraryGitHash() {
-		return string(char_ptr_cast(library_git_hash), 0, MAX_VERSION_SIZE);
-	}
-
-	void Write(WriteStream &ser);
-	static MainHeader Read(ReadStream &source);
-
-private:
-	data_t library_git_desc[MAX_VERSION_SIZE];
-	data_t library_git_hash[MAX_VERSION_SIZE];
-};
-
-//! The DatabaseHeader contains information about the current state of the database. Every storage file has two
-//! DatabaseHeaders. On startup, the DatabaseHeader with the highest iteration count is used as the active header. When
-//! a checkpoint is performed, the active DatabaseHeader is switched by increasing the iteration count of the
-//! DatabaseHeader.
-struct DatabaseHeader {
-	//! The iteration count, increases by 1 every time the storage is checkpointed.
-	uint64_t iteration;
-	//! A pointer to the initial meta block
-	idx_t meta_block;
-	//! A pointer to the block containing the free list
-	idx_t free_list;
-	//! The number of blocks that is in the file as of this database header. If the file is larger than BLOCK_SIZE *
-	//! block_count any blocks appearing AFTER block_count are implicitly part of the free_list.
-	uint64_t block_count;
-	//! The allocation size of blocks in this database file. Defaults to default_block_alloc_size (DBConfig).
-	idx_t block_alloc_size;
-	//! The vector size of the database file
-	idx_t vector_size;
-
-	void Write(WriteStream &ser);
-	static DatabaseHeader Read(ReadStream &source);
-};
-
-//! Detect mismatching constant values when compiling
-
-#if (DEFAULT_ROW_GROUP_SIZE % STANDARD_VECTOR_SIZE != 0)
-#error The row group size must be a multiple of the vector size
-#endif
-#if (DEFAULT_ROW_GROUP_SIZE < STANDARD_VECTOR_SIZE)
-#error Row groups must be able to hold at least one vector
-#endif
-#if (DEFAULT_BLOCK_ALLOC_SIZE & (DEFAULT_BLOCK_ALLOC_SIZE - 1) != 0)
-#error The default block allocation size must be a power of two
-#endif
-#if (DUCKDB_BLOCK_ALLOC_SIZE & (DUCKDB_BLOCK_ALLOC_SIZE - 1) != 0)
-#error The duckdb block allocation size must be a power of two
-#endif
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/storage_lock.hpp b/src/duckdb/src/include/duckdb/storage/storage_lock.hpp
deleted file mode 100644
index 739aef764..000000000
--- a/src/duckdb/src/include/duckdb/storage/storage_lock.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_lock.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-
-namespace duckdb {
-struct StorageLockInternals;
-
-enum class StorageLockType { SHARED = 0, EXCLUSIVE = 1 };
-
-class StorageLockKey {
-public:
-	StorageLockKey(shared_ptr<StorageLockInternals> internals, StorageLockType type);
-	~StorageLockKey();
-
-	StorageLockType GetType() const {
-		return type;
-	}
-
-private:
-	shared_ptr<StorageLockInternals> internals;
-	StorageLockType type;
-};
-
-class StorageLock {
-public:
-	StorageLock();
-	~StorageLock();
-
-	//! Get an exclusive lock
-	unique_ptr<StorageLockKey> GetExclusiveLock();
-	//! Get a shared lock
-	unique_ptr<StorageLockKey> GetSharedLock();
-	//! Try to get an exclusive lock - if we cannot get it immediately we return `nullptr`
-	unique_ptr<StorageLockKey> TryGetExclusiveLock();
-	//! This is a special method that only exists for checkpointing
-	//! This method takes a shared lock, and returns an exclusive lock if the parameter is the only active shared lock
-	//! If this method succeeds, we have **both** a shared and exclusive lock active (which normally is not allowed)
-	//! But this behavior is required for checkpointing
-	unique_ptr<StorageLockKey> TryUpgradeCheckpointLock(StorageLockKey &lock);
-
-private:
-	shared_ptr<StorageLockInternals> internals;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/storage_manager.hpp b/src/duckdb/src/include/duckdb/storage/storage_manager.hpp
deleted file mode 100644
index b72d3972d..000000000
--- a/src/duckdb/src/include/duckdb/storage/storage_manager.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/helper.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/storage/database_size.hpp"
-#include "duckdb/common/enums/checkpoint_type.hpp"
-#include "duckdb/storage/storage_options.hpp"
-
-namespace duckdb {
-class BlockManager;
-class Catalog;
-class CheckpointWriter;
-class DatabaseInstance;
-class TransactionManager;
-class TableCatalogEntry;
-struct PersistentCollectionData;
-
-class StorageCommitState {
-public:
-	// Destruction of this object, without prior call to FlushCommit,
-	// will roll back the committed changes.
-	virtual ~StorageCommitState() {
-	}
-
-	//! Revert the commit
-	virtual void RevertCommit() = 0;
-	// Make the commit persistent
-	virtual void FlushCommit() = 0;
-
-	virtual void AddRowGroupData(DataTable &table, idx_t start_index, idx_t count,
-	                             unique_ptr<PersistentCollectionData> row_group_data) = 0;
-	virtual optional_ptr<PersistentCollectionData> GetRowGroupData(DataTable &table, idx_t start_index,
-	                                                               idx_t &count) = 0;
-	virtual bool HasRowGroupData() {
-		return false;
-	}
-};
-
-struct CheckpointOptions {
-	CheckpointOptions()
-	    : wal_action(CheckpointWALAction::DONT_DELETE_WAL), action(CheckpointAction::CHECKPOINT_IF_REQUIRED),
-	      type(CheckpointType::FULL_CHECKPOINT) {
-	}
-
-	CheckpointWALAction wal_action;
-	CheckpointAction action;
-	CheckpointType type;
-};
-
-//! StorageManager is responsible for managing the physical storage of the
-//! database on disk
-class StorageManager {
-public:
-	StorageManager(AttachedDatabase &db, string path, bool read_only);
-	virtual ~StorageManager();
-
-public:
-	static StorageManager &Get(AttachedDatabase &db);
-	static StorageManager &Get(Catalog &catalog);
-
-	//! Initialize a database or load an existing database from the database file path. The block_alloc_size is
-	//! either set, or invalid. If invalid, then DuckDB defaults to the default_block_alloc_size (DBConfig),
-	//! or the file's block allocation size, if it is an existing database.
-	void Initialize(StorageOptions options);
-
-	DatabaseInstance &GetDatabase();
-	AttachedDatabase &GetAttached() {
-		return db;
-	}
-
-	//! Gets the size of the WAL, or zero, if there is no WAL.
-	idx_t GetWALSize();
-	//! Gets the WAL of the StorageManager, or nullptr, if there is no WAL.
-	optional_ptr<WriteAheadLog> GetWAL();
-	//! Deletes the WAL file, and resets the unique pointer.
-	void ResetWAL();
-
-	//! Returns the database file path
-	string GetDBPath() const {
-		return path;
-	}
-	bool IsLoaded() const {
-		return load_complete;
-	}
-	//! The path to the WAL, derived from the database file path
-	string GetWALPath();
-	bool InMemory();
-
-	virtual bool AutomaticCheckpoint(idx_t estimated_wal_bytes) = 0;
-	virtual unique_ptr<StorageCommitState> GenStorageCommitState(WriteAheadLog &wal) = 0;
-	virtual bool IsCheckpointClean(MetaBlockPointer checkpoint_id) = 0;
-	virtual void CreateCheckpoint(CheckpointOptions options = CheckpointOptions()) = 0;
-	virtual DatabaseSize GetDatabaseSize() = 0;
-	virtual vector<MetadataBlockInfo> GetMetadataInfo() = 0;
-	virtual shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) = 0;
-	virtual BlockManager &GetBlockManager() = 0;
-
-protected:
-	virtual void LoadDatabase(StorageOptions options) = 0;
-
-protected:
-	//! The database this storage manager belongs to
-	AttachedDatabase &db;
-	//! The path of the database
-	string path;
-	//! The WriteAheadLog of the storage manager
-	unique_ptr<WriteAheadLog> wal;
-	//! Whether or not the database is opened in read-only mode
-	bool read_only;
-	//! When loading a database, we do not yet set the wal-field. Therefore, GetWriteAheadLog must
-	//! return nullptr when loading a database
-	bool load_complete = false;
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-//! Stores database in a single file.
-class SingleFileStorageManager : public StorageManager {
-public:
-	SingleFileStorageManager() = delete;
-	SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only);
-
-	//! The BlockManager to read/store meta information and data in blocks
-	unique_ptr<BlockManager> block_manager;
-	//! TableIoManager
-	unique_ptr<TableIOManager> table_io_manager;
-
-public:
-	bool AutomaticCheckpoint(idx_t estimated_wal_bytes) override;
-	unique_ptr<StorageCommitState> GenStorageCommitState(WriteAheadLog &wal) override;
-	bool IsCheckpointClean(MetaBlockPointer checkpoint_id) override;
-	void CreateCheckpoint(CheckpointOptions options) override;
-	DatabaseSize GetDatabaseSize() override;
-	vector<MetadataBlockInfo> GetMetadataInfo() override;
-	shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) override;
-	BlockManager &GetBlockManager() override;
-
-protected:
-	void LoadDatabase(StorageOptions options) override;
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/storage_options.hpp b/src/duckdb/src/include/duckdb/storage/storage_options.hpp
deleted file mode 100644
index 8935f09a5..000000000
--- a/src/duckdb/src/include/duckdb/storage/storage_options.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-struct StorageOptions {
-	//! The allocation size of blocks for this attached database file (if any)
-	optional_idx block_alloc_size;
-	//! The row group size for this attached database (if any)
-	optional_idx row_group_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp b/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp
deleted file mode 100644
index 981d4e4ef..000000000
--- a/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp
+++ /dev/null
@@ -1,244 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/string_uncompressed.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/checkpoint/string_checkpoint_state.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-struct StringDictionaryContainer {
-	//! The size of the dictionary
-	uint32_t size;
-	//! The end of the dictionary, which defaults to the block size.
-	uint32_t end;
-
-	void Verify(const idx_t block_size) {
-		D_ASSERT(size <= block_size);
-		D_ASSERT(end <= block_size);
-		D_ASSERT(size <= end);
-	}
-};
-
-struct StringScanState : public SegmentScanState {
-	BufferHandle handle;
-};
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-struct SerializedStringSegmentState : public ColumnSegmentState {
-public:
-	SerializedStringSegmentState();
-	explicit SerializedStringSegmentState(vector<block_id_t> blocks_p);
-
-public:
-	void Serialize(Serializer &serializer) const override;
-};
-
-struct UncompressedStringStorage {
-public:
-	//! Dictionary header size at the beginning of the string segment (offset + length)
-	static constexpr uint16_t DICTIONARY_HEADER_SIZE = sizeof(uint32_t) + sizeof(uint32_t);
-	//! Marker used in length field to indicate the presence of a big string
-	static constexpr uint16_t BIG_STRING_MARKER = (uint16_t)-1;
-	//! Base size of big string marker (block id + offset)
-	static constexpr idx_t BIG_STRING_MARKER_BASE_SIZE = sizeof(block_id_t) + sizeof(int32_t);
-	//! The marker size of the big string
-	static constexpr idx_t BIG_STRING_MARKER_SIZE = BIG_STRING_MARKER_BASE_SIZE;
-
-public:
-	static unique_ptr<AnalyzeState> StringInitAnalyze(ColumnData &col_data, PhysicalType type);
-	static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count);
-	static idx_t StringFinalAnalyze(AnalyzeState &state_p);
-	static unique_ptr<SegmentScanState> StringInitScan(ColumnSegment &segment);
-	static void StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                              idx_t result_offset);
-	static void StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result);
-	static void Select(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-	                   const SelectionVector &sel, idx_t sel_count);
-
-	static void StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                           idx_t result_idx);
-	static unique_ptr<CompressedSegmentState> StringInitSegment(ColumnSegment &segment, block_id_t block_id,
-	                                                            optional_ptr<ColumnSegmentState> segment_state);
-
-	static unique_ptr<CompressionAppendState> StringInitAppend(ColumnSegment &segment) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		// This block was initialized in StringInitSegment
-		auto handle = buffer_manager.Pin(segment.block);
-		return make_uniq<CompressionAppendState>(std::move(handle));
-	}
-
-	static idx_t StringAppend(CompressionAppendState &append_state, ColumnSegment &segment, SegmentStatistics &stats,
-	                          UnifiedVectorFormat &data, idx_t offset, idx_t count) {
-		return StringAppendBase(append_state.handle, segment, stats, data, offset, count);
-	}
-
-	static idx_t StringAppendBase(ColumnSegment &segment, SegmentStatistics &stats, UnifiedVectorFormat &data,
-	                              idx_t offset, idx_t count) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		auto handle = buffer_manager.Pin(segment.block);
-		return StringAppendBase(handle, segment, stats, data, offset, count);
-	}
-
-	static idx_t StringAppendBase(BufferHandle &handle, ColumnSegment &segment, SegmentStatistics &stats,
-	                              UnifiedVectorFormat &data, idx_t offset, idx_t count) {
-		D_ASSERT(segment.GetBlockOffset() == 0);
-		auto handle_ptr = handle.Ptr();
-		auto source_data = UnifiedVectorFormat::GetData<string_t>(data);
-		auto result_data = reinterpret_cast<int32_t *>(handle_ptr + DICTIONARY_HEADER_SIZE);
-		auto dictionary_size = reinterpret_cast<uint32_t *>(handle_ptr);
-		auto dictionary_end = reinterpret_cast<uint32_t *>(handle_ptr + sizeof(uint32_t));
-
-		idx_t remaining_space = RemainingSpace(segment, handle);
-		auto base_count = segment.count.load();
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = data.sel->get_index(offset + i);
-			auto target_idx = base_count + i;
-			if (remaining_space < sizeof(int32_t)) {
-				// string index does not fit in the block at all
-				segment.count += i;
-				return i;
-			}
-			remaining_space -= sizeof(int32_t);
-			if (!data.validity.RowIsValid(source_idx)) {
-				// null value is stored as a copy of the last value, this is done to be able to efficiently do the
-				// string_length calculation
-				if (target_idx > 0) {
-					result_data[target_idx] = result_data[target_idx - 1];
-				} else {
-					result_data[target_idx] = 0;
-				}
-				continue;
-			}
-			auto end = handle.Ptr() + *dictionary_end;
-
-#ifdef DEBUG
-			GetDictionary(segment, handle).Verify(segment.GetBlockManager().GetBlockSize());
-#endif
-			// Unknown string, continue
-			// non-null value, check if we can fit it within the block
-			idx_t string_length = source_data[source_idx].GetSize();
-
-			// determine whether or not we have space in the block for this string
-			bool use_overflow_block = false;
-			idx_t required_space = string_length;
-			if (DUCKDB_UNLIKELY(required_space >=
-			                    StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize()))) {
-				// string exceeds block limit, store in overflow block and only write a marker here
-				required_space = BIG_STRING_MARKER_SIZE;
-				use_overflow_block = true;
-			}
-			if (DUCKDB_UNLIKELY(required_space > remaining_space)) {
-				// no space remaining: return how many tuples we ended up writing
-				segment.count += i;
-				return i;
-			}
-
-			// we have space: write the string
-			UpdateStringStats(stats, source_data[source_idx]);
-
-			if (DUCKDB_UNLIKELY(use_overflow_block)) {
-				// write to overflow blocks
-				block_id_t block;
-				int32_t current_offset;
-				// write the string into the current string block
-				WriteString(segment, source_data[source_idx], block, current_offset);
-				*dictionary_size += BIG_STRING_MARKER_SIZE;
-				remaining_space -= BIG_STRING_MARKER_SIZE;
-				auto dict_pos = end - *dictionary_size;
-
-				// write a big string marker into the dictionary
-				WriteStringMarker(dict_pos, block, current_offset);
-
-				// place the dictionary offset into the set of vectors
-				// note: for overflow strings we write negative value
-
-				// dictionary_size is an uint32_t value, so we can cast up.
-				D_ASSERT(NumericCast<idx_t>(*dictionary_size) <= segment.GetBlockManager().GetBlockSize());
-				result_data[target_idx] = -NumericCast<int32_t>((*dictionary_size));
-			} else {
-				// string fits in block, append to dictionary and increment dictionary position
-				D_ASSERT(string_length < NumericLimits<uint16_t>::Maximum());
-				*dictionary_size += required_space;
-				remaining_space -= required_space;
-				auto dict_pos = end - *dictionary_size;
-				// now write the actual string data into the dictionary
-				memcpy(dict_pos, source_data[source_idx].GetData(), string_length);
-
-				// dictionary_size is an uint32_t value, so we can cast up.
-				D_ASSERT(NumericCast<idx_t>(*dictionary_size) <= segment.GetBlockManager().GetBlockSize());
-				// Place the dictionary offset into the set of vectors.
-				result_data[target_idx] = NumericCast<int32_t>(*dictionary_size);
-			}
-			D_ASSERT(RemainingSpace(segment, handle) <= segment.GetBlockManager().GetBlockSize());
-#ifdef DEBUG
-			GetDictionary(segment, handle).Verify(segment.GetBlockManager().GetBlockSize());
-#endif
-		}
-		segment.count += count;
-		return count;
-	}
-
-	static idx_t FinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats);
-
-public:
-	static inline void UpdateStringStats(SegmentStatistics &stats, const string_t &new_value) {
-		StringStats::Update(stats.statistics, new_value);
-	}
-
-	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer dict);
-	static StringDictionaryContainer GetDictionary(ColumnSegment &segment, BufferHandle &handle);
-	static idx_t RemainingSpace(ColumnSegment &segment, BufferHandle &handle);
-	static void WriteString(ColumnSegment &segment, string_t string, block_id_t &result_block, int32_t &result_offset);
-	static void WriteStringMemory(ColumnSegment &segment, string_t string, block_id_t &result_block,
-	                              int32_t &result_offset);
-	static string_t ReadOverflowString(ColumnSegment &segment, Vector &result, block_id_t block, int32_t offset);
-	static string_t ReadString(data_ptr_t target, int32_t offset, uint32_t string_length);
-	static string_t ReadStringWithLength(data_ptr_t target, int32_t offset);
-	static void WriteStringMarker(data_ptr_t target, block_id_t block_id, int32_t offset);
-	static void ReadStringMarker(data_ptr_t target, block_id_t &block_id, int32_t &offset);
-
-	inline static string_t FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict, Vector &result,
-	                                           data_ptr_t base_ptr, int32_t dict_offset, uint32_t string_length) {
-		D_ASSERT(dict_offset <= NumericCast<int32_t>(segment.GetBlockManager().GetBlockSize()));
-		if (DUCKDB_LIKELY(dict_offset >= 0)) {
-			// regular string - fetch from dictionary
-			auto dict_end = base_ptr + dict.end;
-			auto dict_pos = dict_end - dict_offset;
-
-			auto str_ptr = char_ptr_cast(dict_pos);
-			return string_t(str_ptr, string_length);
-		} else {
-			// read overflow string
-			block_id_t block_id;
-			int32_t offset;
-			ReadStringMarker(base_ptr + dict.end - AbsValue<int32_t>(dict_offset), block_id, offset);
-
-			return ReadOverflowString(segment, result, block_id, offset);
-		}
-	}
-
-	static unique_ptr<ColumnSegmentState> SerializeState(ColumnSegment &segment);
-	static unique_ptr<ColumnSegmentState> DeserializeState(Deserializer &deserializer);
-	static void CleanupState(ColumnSegment &segment);
-};
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/append_state.hpp b/src/duckdb/src/include/duckdb/storage/table/append_state.hpp
deleted file mode 100644
index 0a5c7b170..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/append_state.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/append_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/planner/bound_constraint.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/transaction/transaction_data.hpp"
-
-namespace duckdb {
-class ColumnSegment;
-class DataTable;
-class LocalTableStorage;
-class RowGroup;
-class UpdateSegment;
-class TableCatalogEntry;
-
-struct TableAppendState;
-
-struct ColumnAppendState {
-	//! The current segment of the append
-	ColumnSegment *current;
-	//! Child append states
-	vector<ColumnAppendState> child_appends;
-	//! The write lock that is held by the append
-	unique_ptr<StorageLockKey> lock;
-	//! The compression append state
-	unique_ptr<CompressionAppendState> append_state;
-};
-
-struct RowGroupAppendState {
-	explicit RowGroupAppendState(TableAppendState &parent_p) : parent(parent_p) {
-	}
-
-	//! The parent append state
-	TableAppendState &parent;
-	//! The current row_group we are appending to
-	RowGroup *row_group;
-	//! The column append states
-	unsafe_unique_array<ColumnAppendState> states;
-	//! Offset within the row_group
-	idx_t offset_in_row_group;
-};
-
-struct IndexLock {
-	unique_lock<mutex> index_lock;
-};
-
-struct TableAppendState {
-	TableAppendState();
-	~TableAppendState();
-
-	RowGroupAppendState row_group_append_state;
-	unique_lock<mutex> append_lock;
-	row_t row_start;
-	row_t current_row;
-	//! The total number of rows appended by the append operation
-	idx_t total_append_count;
-	//! The first row-group that has been appended to
-	RowGroup *start_row_group;
-	//! The transaction data
-	TransactionData transaction;
-	//! Table statistics
-	TableStatistics stats;
-	//! Cached hash vector
-	Vector hashes;
-};
-
-struct ConstraintState {
-	explicit ConstraintState(TableCatalogEntry &table_p, const vector<unique_ptr<BoundConstraint>> &bound_constraints)
-	    : table(table_p), bound_constraints(bound_constraints) {
-	}
-
-	TableCatalogEntry &table;
-	const vector<unique_ptr<BoundConstraint>> &bound_constraints;
-};
-
-struct LocalAppendState {
-	TableAppendState append_state;
-	LocalTableStorage *storage;
-	unique_ptr<ConstraintState> constraint_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp
deleted file mode 100644
index 2a0ec1d07..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/array_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/validity_column_data.hpp"
-
-namespace duckdb {
-
-//! List column data represents a list
-class ArrayColumnData : public ColumnData {
-public:
-	ArrayColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                LogicalType type, optional_ptr<ColumnData> parent = nullptr);
-
-	//! The child-column of the list
-	unique_ptr<ColumnData> child_column;
-	//! The validity column data of the array
-	ValidityColumnData validity;
-
-public:
-	void SetStart(idx_t new_start) override;
-	FilterPropagateResult CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-
-	void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override;
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	           idx_t scan_count) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-	                    idx_t scan_count) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group,
-	                                                        PartialBlockManager &partial_block_manager) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
-
-	bool IsPersistent() override;
-	PersistentColumnData Serialize() override;
-	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
-
-	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-	                          vector<duckdb::ColumnSegmentInfo> &result) override;
-
-	void Verify(RowGroup &parent) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp b/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp
deleted file mode 100644
index 44b92dd74..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/chunk_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/common/atomic.hpp"
-
-namespace duckdb {
-class RowGroup;
-struct SelectionVector;
-class Transaction;
-struct TransactionData;
-struct DeleteInfo;
-class Serializer;
-class Deserializer;
-
-enum class ChunkInfoType : uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };
-
-class ChunkInfo {
-public:
-	ChunkInfo(idx_t start, ChunkInfoType type) : start(start), type(type) {
-	}
-	virtual ~ChunkInfo() {
-	}
-
-	//! The row index of the first row
-	idx_t start;
-	//! The ChunkInfo type
-	ChunkInfoType type;
-
-public:
-	//! Gets up to max_count entries from the chunk info. If the ret is 0>ret>max_count, the selection vector is filled
-	//! with the tuples
-	virtual idx_t GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) = 0;
-	virtual idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-	                                    SelectionVector &sel_vector, idx_t max_count) = 0;
-	//! Returns whether or not a single row in the ChunkInfo should be used or not for the given transaction
-	virtual bool Fetch(TransactionData transaction, row_t row) = 0;
-	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
-	virtual idx_t GetCommittedDeletedCount(idx_t max_count) = 0;
-	virtual bool Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const;
-
-	virtual bool HasDeletes() const = 0;
-
-	virtual void Write(WriteStream &writer) const;
-	static unique_ptr<ChunkInfo> Read(ReadStream &reader);
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast chunk info to type - query result type mismatch");
-		}
-		return reinterpret_cast<TARGET &>(*this);
-	}
-
-	template <class TARGET>
-	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
-			throw InternalException("Failed to cast chunk info to type - query result type mismatch");
-		}
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-class ChunkConstantInfo : public ChunkInfo {
-public:
-	static constexpr const ChunkInfoType TYPE = ChunkInfoType::CONSTANT_INFO;
-
-public:
-	explicit ChunkConstantInfo(idx_t start);
-
-	transaction_t insert_id;
-	transaction_t delete_id;
-
-public:
-	idx_t GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) override;
-	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-	                            SelectionVector &sel_vector, idx_t max_count) override;
-	bool Fetch(TransactionData transaction, row_t row) override;
-	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
-	idx_t GetCommittedDeletedCount(idx_t max_count) override;
-	bool Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const override;
-
-	bool HasDeletes() const override;
-
-	void Write(WriteStream &writer) const override;
-	static unique_ptr<ChunkInfo> Read(ReadStream &reader);
-
-private:
-	template <class OP>
-	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                            idx_t max_count) const;
-};
-
-class ChunkVectorInfo : public ChunkInfo {
-public:
-	static constexpr const ChunkInfoType TYPE = ChunkInfoType::VECTOR_INFO;
-
-public:
-	explicit ChunkVectorInfo(idx_t start);
-
-	//! The transaction ids of the transactions that inserted the tuples (if any)
-	transaction_t inserted[STANDARD_VECTOR_SIZE];
-	transaction_t insert_id;
-	bool same_inserted_id;
-
-	//! The transaction ids of the transactions that deleted the tuples (if any)
-	transaction_t deleted[STANDARD_VECTOR_SIZE];
-	bool any_deleted;
-
-public:
-	idx_t GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                   idx_t max_count) const;
-	idx_t GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) override;
-	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-	                            SelectionVector &sel_vector, idx_t max_count) override;
-	bool Fetch(TransactionData transaction, row_t row) override;
-	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
-	bool Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const override;
-	idx_t GetCommittedDeletedCount(idx_t max_count) override;
-
-	void Append(idx_t start, idx_t end, transaction_t commit_id);
-
-	//! Performs a delete in the ChunkVectorInfo - returns how many tuples were actually deleted
-	//! The number of rows that were actually deleted might be lower than the input count
-	//! In case we delete rows that were already deleted
-	//! Note that "rows" is written to to reflect the row ids that were actually deleted
-	//! i.e. after calling this function, rows will hold [0..actual_delete_count] row ids of the actually deleted tuples
-	idx_t Delete(transaction_t transaction_id, row_t rows[], idx_t count);
-	void CommitDelete(transaction_t commit_id, const DeleteInfo &info);
-
-	bool HasDeletes() const override;
-
-	void Write(WriteStream &writer) const override;
-	static unique_ptr<ChunkInfo> Read(ReadStream &reader);
-
-private:
-	template <class OP>
-	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                            idx_t max_count) const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp b/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp
deleted file mode 100644
index 09c8985f2..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_checkpoint_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/storage/partial_block_manager.hpp"
-
-namespace duckdb {
-class ColumnData;
-class DatabaseInstance;
-class RowGroup;
-class PartialBlockManager;
-class TableDataWriter;
-
-struct ColumnCheckpointState {
-	ColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, PartialBlockManager &partial_block_manager);
-	virtual ~ColumnCheckpointState();
-
-	RowGroup &row_group;
-	ColumnData &column_data;
-	ColumnSegmentTree new_tree;
-	vector<DataPointer> data_pointers;
-	unique_ptr<BaseStatistics> global_stats;
-
-protected:
-	PartialBlockManager &partial_block_manager;
-
-public:
-	virtual unique_ptr<BaseStatistics> GetStatistics();
-
-	virtual void FlushSegmentInternal(unique_ptr<ColumnSegment> segment, idx_t segment_size);
-	virtual void FlushSegment(unique_ptr<ColumnSegment> segment, BufferHandle handle, idx_t segment_size);
-	virtual PersistentColumnData ToPersistentData();
-
-	PartialBlockManager &GetPartialBlockManager() {
-		return partial_block_manager;
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct PartialBlockForCheckpoint : public PartialBlock {
-	struct PartialColumnSegment {
-		PartialColumnSegment(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block)
-		    : data(data), segment(segment), offset_in_block(offset_in_block) {
-		}
-
-		ColumnData &data;
-		ColumnSegment &segment;
-		uint32_t offset_in_block;
-	};
-
-public:
-	PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
-	                          BlockManager &block_manager);
-	~PartialBlockForCheckpoint() override;
-
-	// We will copy all segment data into the memory of the shared block.
-	// Once the block is full (or checkpoint is complete) we'll invoke Flush().
-	// This will cause the block to get written to storage (via BlockManger::ConvertToPersistent),
-	// and all segments to have their references updated (via ColumnSegment::ConvertToPersistent)
-	vector<PartialColumnSegment> segments;
-
-public:
-	bool IsFlushed();
-	void Flush(const idx_t free_space_left) override;
-	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
-	void AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block);
-	void Clear() override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/column_data.hpp
deleted file mode 100644
index adb3ed056..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/column_data.hpp
+++ /dev/null
@@ -1,303 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/table/persistent_table_data.hpp"
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/storage/table/segment_tree.hpp"
-#include "duckdb/storage/table/column_segment_tree.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/enums/scan_vector_type.hpp"
-#include "duckdb/common/serializer/serialization_traits.hpp"
-#include "duckdb/common/atomic_ptr.hpp"
-
-namespace duckdb {
-class ColumnData;
-class ColumnSegment;
-class DatabaseInstance;
-class RowGroup;
-class RowGroupWriter;
-class TableDataWriter;
-class TableStorageInfo;
-struct DataTableInfo;
-struct PrefetchState;
-struct RowGroupWriteInfo;
-struct TableScanOptions;
-struct TransactionData;
-struct PersistentColumnData;
-
-using column_segment_vector_t = vector<SegmentNode<ColumnSegment>>;
-
-struct ColumnCheckpointInfo {
-	ColumnCheckpointInfo(RowGroupWriteInfo &info, idx_t column_idx) : info(info), column_idx(column_idx) {
-	}
-
-	RowGroupWriteInfo &info;
-	idx_t column_idx;
-
-public:
-	CompressionType GetCompressionType();
-};
-
-class ColumnData {
-	friend class ColumnDataCheckpointer;
-
-public:
-	ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
-	           optional_ptr<ColumnData> parent);
-	virtual ~ColumnData();
-
-	//! The start row
-	idx_t start;
-	//! The count of the column data
-	atomic<idx_t> count;
-	//! The block manager
-	BlockManager &block_manager;
-	//! Table info for the column
-	DataTableInfo &info;
-	//! The column index of the column, either within the parent table or within the parent
-	idx_t column_index;
-	//! The type of the column
-	LogicalType type;
-
-public:
-	virtual FilterPropagateResult CheckZonemap(ColumnScanState &state, TableFilter &filter);
-
-	BlockManager &GetBlockManager() {
-		return block_manager;
-	}
-	DatabaseInstance &GetDatabase() const;
-	DataTableInfo &GetTableInfo() const;
-	virtual idx_t GetMaxEntry();
-
-	idx_t GetAllocationSize() const {
-		return allocation_size;
-	}
-	optional_ptr<const CompressionFunction> GetCompressionFunction() const {
-		return compression.get();
-	}
-
-	bool HasParent() const {
-		return parent != nullptr;
-	}
-	const ColumnData &Parent() const {
-		D_ASSERT(HasParent());
-		return *parent;
-	}
-
-	virtual void SetStart(idx_t new_start);
-	//! The root type of the column
-	const LogicalType &RootType() const;
-	//! Whether or not the column has any updates
-	bool HasUpdates() const;
-	bool HasChanges(idx_t start_row, idx_t end_row) const;
-	//! Whether or not we can scan an entire vector
-	virtual ScanVectorType GetVectorScanType(ColumnScanState &state, idx_t scan_count, Vector &result);
-
-	//! Initialize prefetch state with required I/O data for the next N rows
-	virtual void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows);
-	//! Initialize a scan of the column
-	virtual void InitializeScan(ColumnScanState &state);
-	//! Initialize a scan starting at the specified offset
-	virtual void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx);
-	//! Scan the next vector from the column
-	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result);
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates);
-	virtual idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                   idx_t scan_count);
-	virtual idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-	                            idx_t scan_count);
-
-	virtual void ScanCommittedRange(idx_t row_group_start, idx_t offset_in_row_group, idx_t count, Vector &result);
-	virtual idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count);
-
-	//! Select
-	virtual void Filter(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                    SelectionVector &sel, idx_t &count, const TableFilter &filter);
-	virtual void Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                    SelectionVector &sel, idx_t count);
-	virtual void SelectCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel,
-	                             idx_t count, bool allow_updates);
-
-	//! Skip the scan forward by "count" rows
-	virtual void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE);
-
-	//! Initialize an appending phase for this column
-	virtual void InitializeAppend(ColumnAppendState &state);
-	//! Append a vector of type [type] to the end of the column
-	virtual void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count);
-	//! Append a vector of type [type] to the end of the column
-	void Append(ColumnAppendState &state, Vector &vector, idx_t count);
-	virtual void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count);
-	//! Revert a set of appends to the ColumnData
-	virtual void RevertAppend(row_t start_row);
-
-	//! Fetch the vector from the column data that belongs to this specific row
-	virtual idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result);
-	//! Fetch a specific row id and append it to the vector
-	virtual void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	                      idx_t result_idx);
-
-	virtual void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	                    idx_t update_count);
-	virtual void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                          row_t *row_ids, idx_t update_count, idx_t depth);
-	virtual unique_ptr<BaseStatistics> GetUpdateStatistics();
-
-	virtual void CommitDropColumn();
-
-	virtual unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group,
-	                                                                PartialBlockManager &partial_block_manager);
-	virtual unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info);
-
-	virtual void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
-	                            Vector &scan_vector);
-
-	virtual bool IsPersistent();
-	vector<DataPointer> GetDataPointers();
-
-	virtual PersistentColumnData Serialize();
-	void InitializeColumn(PersistentColumnData &column_data);
-	virtual void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats);
-	static shared_ptr<ColumnData> Deserialize(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-	                                          idx_t start_row, ReadStream &source, const LogicalType &type);
-
-	virtual void GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path, vector<ColumnSegmentInfo> &result);
-	virtual void Verify(RowGroup &parent);
-
-	FilterPropagateResult CheckZonemap(TableFilter &filter);
-
-	static shared_ptr<ColumnData> CreateColumn(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-	                                           idx_t start_row, const LogicalType &type,
-	                                           optional_ptr<ColumnData> parent = nullptr);
-	static unique_ptr<ColumnData> CreateColumnUnique(BlockManager &block_manager, DataTableInfo &info,
-	                                                 idx_t column_index, idx_t start_row, const LogicalType &type,
-	                                                 optional_ptr<ColumnData> parent = nullptr);
-
-	void MergeStatistics(const BaseStatistics &other);
-	void MergeIntoStatistics(BaseStatistics &other);
-	unique_ptr<BaseStatistics> GetStatistics();
-
-protected:
-	//! Append a transient segment
-	void AppendTransientSegment(SegmentLock &l, idx_t start_row);
-	void AppendSegment(SegmentLock &l, unique_ptr<ColumnSegment> segment);
-
-	void BeginScanVectorInternal(ColumnScanState &state);
-	//! Scans a base vector from the column
-	idx_t ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, ScanVectorType scan_type);
-	//! Scans a vector from the column merged with any potential updates
-	idx_t ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                 idx_t target_scan, ScanVectorType scan_type, ScanVectorMode mode);
-	idx_t ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                 idx_t target_scan, ScanVectorMode mode);
-	void SelectVector(ColumnScanState &state, Vector &result, idx_t target_count, const SelectionVector &sel,
-	                  idx_t sel_count);
-	void FilterVector(ColumnScanState &state, Vector &result, idx_t target_count, SelectionVector &sel,
-	                  idx_t &sel_count, const TableFilter &filter);
-
-	void ClearUpdates();
-	void FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result, idx_t scan_count,
-	                  bool allow_updates, bool scan_committed);
-	void FetchUpdateRow(TransactionData transaction, row_t row_id, Vector &result, idx_t result_idx);
-	void UpdateInternal(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	                    idx_t update_count, Vector &base_vector);
-
-	idx_t GetVectorCount(idx_t vector_index) const;
-
-private:
-	void UpdateCompressionFunction(SegmentLock &l, const CompressionFunction &function);
-
-protected:
-	//! The segments holding the data of this column segment
-	ColumnSegmentTree data;
-	//! The lock for the updates
-	mutable mutex update_lock;
-	//! The updates for this column segment
-	unique_ptr<UpdateSegment> updates;
-	//! The lock for the stats
-	mutable mutex stats_lock;
-	//! The stats of the root segment
-	unique_ptr<SegmentStatistics> stats;
-	//! Total transient allocation size
-	idx_t allocation_size;
-
-private:
-	//! The parent column (if any)
-	optional_ptr<ColumnData> parent;
-	//!	The compression function used by the ColumnData
-	//! This is empty if the segments have mixed compression or the ColumnData is empty
-	atomic_ptr<const CompressionFunction> compression;
-};
-
-struct PersistentColumnData {
-	explicit PersistentColumnData(PhysicalType physical_type);
-	PersistentColumnData(PhysicalType physical_type, vector<DataPointer> pointers);
-	// disable copy constructors
-	PersistentColumnData(const PersistentColumnData &other) = delete;
-	PersistentColumnData &operator=(const PersistentColumnData &) = delete;
-	//! enable move constructors
-	PersistentColumnData(PersistentColumnData &&other) noexcept = default;
-	PersistentColumnData &operator=(PersistentColumnData &&) = default;
-	~PersistentColumnData();
-
-	PhysicalType physical_type;
-	vector<DataPointer> pointers;
-	vector<PersistentColumnData> child_columns;
-	bool has_updates = false;
-
-	void Serialize(Serializer &serializer) const;
-	static PersistentColumnData Deserialize(Deserializer &deserializer);
-	void DeserializeField(Deserializer &deserializer, field_id_t field_idx, const char *field_name,
-	                      const LogicalType &type);
-	bool HasUpdates() const;
-};
-
-struct PersistentRowGroupData {
-	explicit PersistentRowGroupData(vector<LogicalType> types);
-	PersistentRowGroupData() = default;
-	// disable copy constructors
-	PersistentRowGroupData(const PersistentRowGroupData &other) = delete;
-	PersistentRowGroupData &operator=(const PersistentRowGroupData &) = delete;
-	//! enable move constructors
-	PersistentRowGroupData(PersistentRowGroupData &&other) noexcept = default;
-	PersistentRowGroupData &operator=(PersistentRowGroupData &&) = default;
-	~PersistentRowGroupData() = default;
-
-	vector<LogicalType> types;
-	vector<PersistentColumnData> column_data;
-	idx_t start;
-	idx_t count;
-
-	void Serialize(Serializer &serializer) const;
-	static PersistentRowGroupData Deserialize(Deserializer &deserializer);
-	bool HasUpdates() const;
-};
-
-struct PersistentCollectionData {
-	PersistentCollectionData() = default;
-	// disable copy constructors
-	PersistentCollectionData(const PersistentCollectionData &other) = delete;
-	PersistentCollectionData &operator=(const PersistentCollectionData &) = delete;
-	//! enable move constructors
-	PersistentCollectionData(PersistentCollectionData &&other) noexcept = default;
-	PersistentCollectionData &operator=(PersistentCollectionData &&) = default;
-	~PersistentCollectionData() = default;
-
-	vector<PersistentRowGroupData> row_group_data;
-
-	void Serialize(Serializer &serializer) const;
-	static PersistentCollectionData Deserialize(Deserializer &deserializer);
-	bool HasUpdates() const;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp b/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp
deleted file mode 100644
index 0db0e6fbc..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_data_checkpointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-
-namespace duckdb {
-struct TableScanOptions;
-
-//! Holds state related to a single column during compression
-struct ColumnDataCheckpointData {
-public:
-	//! Default constructor used when column data does not need to be checkpointed
-	ColumnDataCheckpointData() {
-	}
-	ColumnDataCheckpointData(ColumnCheckpointState &checkpoint_state, ColumnData &col_data, DatabaseInstance &db,
-	                         RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info)
-	    : checkpoint_state(checkpoint_state), col_data(col_data), db(db), row_group(row_group),
-	      checkpoint_info(checkpoint_info) {
-	}
-
-public:
-	CompressionFunction &GetCompressionFunction(CompressionType type);
-	const LogicalType &GetType() const;
-	ColumnData &GetColumnData();
-	RowGroup &GetRowGroup();
-	ColumnCheckpointState &GetCheckpointState();
-	DatabaseInstance &GetDatabase();
-
-private:
-	optional_ptr<ColumnCheckpointState> checkpoint_state;
-	optional_ptr<ColumnData> col_data;
-	optional_ptr<DatabaseInstance> db;
-	optional_ptr<RowGroup> row_group;
-	optional_ptr<ColumnCheckpointInfo> checkpoint_info;
-};
-
-struct CheckpointAnalyzeResult {
-public:
-	//! Default constructor, returned when the column data doesn't require checkpoint
-	CheckpointAnalyzeResult() {
-	}
-	CheckpointAnalyzeResult(unique_ptr<AnalyzeState> &&analyze_state, CompressionFunction &function)
-	    : analyze_state(std::move(analyze_state)), function(function) {
-	}
-
-public:
-	unique_ptr<AnalyzeState> analyze_state;
-	optional_ptr<CompressionFunction> function;
-};
-
-class ColumnDataCheckpointer {
-public:
-	ColumnDataCheckpointer(vector<reference<ColumnCheckpointState>> &states, DatabaseInstance &db, RowGroup &row_group,
-	                       ColumnCheckpointInfo &checkpoint_info);
-
-public:
-	void Checkpoint();
-	void FinalizeCheckpoint();
-
-private:
-	void ScanSegments(const std::function<void(Vector &, idx_t)> &callback);
-	vector<CheckpointAnalyzeResult> DetectBestCompressionMethod();
-	void WriteToDisk();
-	bool HasChanges(ColumnData &col_data);
-	void WritePersistentSegments(ColumnCheckpointState &state);
-	void InitAnalyze();
-	void DropSegments();
-	bool ValidityCoveredByBasedata(vector<CheckpointAnalyzeResult> &result);
-
-private:
-	vector<reference<ColumnCheckpointState>> &checkpoint_states;
-	DatabaseInstance &db;
-	RowGroup &row_group;
-	Vector intermediate;
-	ColumnCheckpointInfo &checkpoint_info;
-
-	vector<bool> has_changes;
-	//! For every column data that is being checkpointed, the applicable functions
-	vector<vector<optional_ptr<CompressionFunction>>> compression_functions;
-	//! For every column data that is being checkpointed, the analyze state of functions being tried
-	vector<vector<unique_ptr<AnalyzeState>>> analyze_states;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp b/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp
deleted file mode 100644
index 45d2db0c0..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/scan_vector_type.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/table/segment_base.hpp"
-
-namespace duckdb {
-class ColumnSegment;
-class BlockManager;
-class ColumnData;
-class DatabaseInstance;
-class Transaction;
-class BaseStatistics;
-class UpdateSegment;
-class TableFilter;
-struct ColumnFetchState;
-struct ColumnScanState;
-struct ColumnAppendState;
-struct PrefetchState;
-
-enum class ColumnSegmentType : uint8_t { TRANSIENT, PERSISTENT };
-//! TableFilter represents a filter pushed down into the table scan.
-
-class ColumnSegment : public SegmentBase<ColumnSegment> {
-public:
-	//! Construct a column segment.
-	ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, const LogicalType &type,
-	              const ColumnSegmentType segment_type, const idx_t start, const idx_t count,
-	              CompressionFunction &function_p, BaseStatistics statistics, const block_id_t block_id_p,
-	              const idx_t offset, const idx_t segment_size_p,
-	              unique_ptr<ColumnSegmentState> segment_state_p = nullptr);
-	//! Construct a column segment from another column segment.
-	//! The other column segment becomes invalid (std::move).
-	ColumnSegment(ColumnSegment &other, const idx_t start);
-	~ColumnSegment();
-
-public:
-	static unique_ptr<ColumnSegment> CreatePersistentSegment(DatabaseInstance &db, BlockManager &block_manager,
-	                                                         block_id_t id, idx_t offset, const LogicalType &type_p,
-	                                                         idx_t start, idx_t count, CompressionType compression_type,
-	                                                         BaseStatistics statistics,
-	                                                         unique_ptr<ColumnSegmentState> segment_state);
-	static unique_ptr<ColumnSegment> CreateTransientSegment(DatabaseInstance &db, CompressionFunction &function,
-	                                                        const LogicalType &type, const idx_t start,
-	                                                        const idx_t segment_size, const idx_t block_size);
-
-public:
-	void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state);
-	void InitializeScan(ColumnScanState &state);
-	//! Scan one vector from this segment
-	void Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset, ScanVectorType scan_type);
-	//! Scan a subset of a vector (defined by the selection vector)
-	void Select(ColumnScanState &state, idx_t scan_count, Vector &result, const SelectionVector &sel, idx_t sel_count);
-	//! Scan one vector while applying a filter to the vector, returning only the matching elements
-	void Filter(ColumnScanState &state, idx_t scan_count, Vector &result, SelectionVector &sel, idx_t &sel_count,
-	            const TableFilter &filter);
-	//! Fetch a value of the specific row id and append it to the result
-	void FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx);
-
-	static idx_t FilterSelection(SelectionVector &sel, Vector &vector, UnifiedVectorFormat &vdata,
-	                             const TableFilter &filter, idx_t scan_count, idx_t &approved_tuple_count);
-
-	//! Skip a scan forward to the row_index specified in the scan state
-	void Skip(ColumnScanState &state);
-
-	// The maximum size of the buffer (in bytes)
-	idx_t SegmentSize() const;
-	//! Resize the block
-	void Resize(idx_t segment_size);
-	const CompressionFunction &GetCompressionFunction();
-
-	//! Initialize an append of this segment. Appends are only supported on transient segments.
-	void InitializeAppend(ColumnAppendState &state);
-	//! Appends a (part of) vector to the segment, returns the amount of entries successfully appended
-	idx_t Append(ColumnAppendState &state, UnifiedVectorFormat &data, idx_t offset, idx_t count);
-	//! Finalize the segment for appending - no more appends can follow on this segment
-	//! The segment should be compacted as much as possible
-	//! Returns the number of bytes occupied within the segment
-	idx_t FinalizeAppend(ColumnAppendState &state);
-	//! Revert an append made to this segment
-	void RevertAppend(idx_t start_row);
-
-	//! Convert a transient in-memory segment into a persistent segment blocked by an on-disk block.
-	//! Only used during checkpointing.
-	void ConvertToPersistent(optional_ptr<BlockManager> block_manager, block_id_t block_id);
-	//! Updates pointers to refer to the given block and offset. This is only used
-	//! when sharing a block among segments. This is invoked only AFTER the block is written.
-	void MarkAsPersistent(shared_ptr<BlockHandle> block, uint32_t offset_in_block);
-	//! Gets a data pointer from a persistent column segment
-	DataPointer GetDataPointer();
-
-	block_id_t GetBlockId() {
-		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT);
-		return block_id;
-	}
-
-	//! Returns the block manager handling this segment. For transient segments, this might be the temporary block
-	//! manager. Later, we possibly convert this (transient) segment to a persistent segment. In that case, there
-	//! exists another block manager handling the ColumnData, of which this segment is a part.
-	BlockManager &GetBlockManager() const {
-		return block->block_manager;
-	}
-
-	idx_t GetBlockOffset() {
-		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT || offset == 0);
-		return offset;
-	}
-
-	idx_t GetRelativeIndex(idx_t row_index) {
-		D_ASSERT(row_index >= this->start);
-		D_ASSERT(row_index <= this->start + this->count);
-		return row_index - this->start;
-	}
-
-	optional_ptr<CompressedSegmentState> GetSegmentState() {
-		return segment_state.get();
-	}
-
-	void CommitDropSegment();
-
-private:
-	void Scan(ColumnScanState &state, idx_t scan_count, Vector &result);
-	void ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset);
-
-public:
-	//! The database instance
-	DatabaseInstance &db;
-	//! The type stored in the column
-	LogicalType type;
-	//! The size of the type
-	idx_t type_size;
-	//! The column segment type (transient or persistent)
-	ColumnSegmentType segment_type;
-	//! The statistics for the segment
-	SegmentStatistics stats;
-	//! The block that this segment relates to
-	shared_ptr<BlockHandle> block;
-
-private:
-	//! The compression function
-	reference<CompressionFunction> function;
-	//! The block id that this segment relates to (persistent segment only)
-	block_id_t block_id;
-	//! The offset into the block (persistent segment only)
-	idx_t offset;
-	//! The allocated segment size, which is bounded by Storage::BLOCK_SIZE
-	idx_t segment_size;
-	//! Storage associated with the compressed segment
-	unique_ptr<CompressedSegmentState> segment_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/column_segment_tree.hpp b/src/duckdb/src/include/duckdb/storage/table/column_segment_tree.hpp
deleted file mode 100644
index d1fa796b2..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/column_segment_tree.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_segment_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/segment_tree.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-
-namespace duckdb {
-
-class ColumnSegmentTree : public SegmentTree<ColumnSegment> {};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/data_table_info.hpp b/src/duckdb/src/include/duckdb/storage/table/data_table_info.hpp
deleted file mode 100644
index fbc2e443b..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/data_table_info.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/data_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/table/table_index_list.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-class TableIOManager;
-
-struct DataTableInfo {
-	friend class DataTable;
-
-public:
-	DataTableInfo(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, string schema, string table);
-
-	//! Initialize any unknown indexes whose types might now be present after an extension load, optionally throwing an
-	//! exception if an index can't be initialized
-	void InitializeIndexes(ClientContext &context, const char *index_type = nullptr);
-
-	//! Whether or not the table is temporary
-	bool IsTemporary() const;
-
-	AttachedDatabase &GetDB() {
-		return db;
-	}
-
-	TableIOManager &GetIOManager() {
-		return *table_io_manager;
-	}
-
-	TableIndexList &GetIndexes() {
-		return indexes;
-	}
-	const vector<IndexStorageInfo> &GetIndexStorageInfo() const {
-		return index_storage_infos;
-	}
-	unique_ptr<StorageLockKey> GetSharedLock() {
-		return checkpoint_lock.GetSharedLock();
-	}
-
-	string GetSchemaName();
-	string GetTableName();
-	void SetTableName(string name);
-
-private:
-	//! The database instance of the table
-	AttachedDatabase &db;
-	//! The table IO manager
-	shared_ptr<TableIOManager> table_io_manager;
-	//! Lock for modifying the name
-	mutex name_lock;
-	//! The schema of the table
-	string schema;
-	//! The name of the table
-	string table;
-	//! The physical list of indexes of this table
-	TableIndexList indexes;
-	//! Index storage information of the indexes created by this table
-	vector<IndexStorageInfo> index_storage_infos;
-	//! Lock held while checkpointing
-	StorageLock checkpoint_lock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/delete_state.hpp b/src/duckdb/src/include/duckdb/storage/table/delete_state.hpp
deleted file mode 100644
index d3a05eeeb..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/delete_state.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/delete_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/append_state.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-struct TableDeleteState {
-	unique_ptr<ConstraintState> constraint_state;
-	bool has_delete_constraints = false;
-	DataChunk verify_chunk;
-	vector<StorageIndex> col_ids;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp
deleted file mode 100644
index c4ec56740..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/list_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/validity_column_data.hpp"
-
-namespace duckdb {
-
-//! List column data represents a list
-class ListColumnData : public ColumnData {
-public:
-	ListColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-	               LogicalType type, optional_ptr<ColumnData> parent = nullptr);
-
-	//! The child-column of the list
-	unique_ptr<ColumnData> child_column;
-	//! The validity column data of the list
-	ValidityColumnData validity;
-
-public:
-	void SetStart(idx_t new_start) override;
-	FilterPropagateResult CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-
-	void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override;
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	           idx_t scan_count) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-	                    idx_t scan_count) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group,
-	                                                        PartialBlockManager &partial_block_manager) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
-
-	bool IsPersistent() override;
-	PersistentColumnData Serialize() override;
-	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
-
-	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-	                          vector<duckdb::ColumnSegmentInfo> &result) override;
-
-private:
-	uint64_t FetchListOffset(idx_t row_idx);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/persistent_table_data.hpp b/src/duckdb/src/include/duckdb/storage/table/persistent_table_data.hpp
deleted file mode 100644
index f5eb6d9aa..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/persistent_table_data.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/persistent_table_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-
-namespace duckdb {
-class BaseStatistics;
-
-class PersistentTableData {
-public:
-	explicit PersistentTableData(idx_t column_count);
-	~PersistentTableData();
-
-	TableStatistics table_stats;
-	idx_t total_rows;
-	idx_t row_group_count;
-	MetaBlockPointer block_pointer;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/row_group.hpp b/src/duckdb/src/include/duckdb/storage/table/row_group.hpp
deleted file mode 100644
index 16a535a4e..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/row_group.hpp
+++ /dev/null
@@ -1,213 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/row_group.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/enums/scan_options.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/storage/table/segment_base.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/common/enums/checkpoint_type.hpp"
-#include "duckdb/storage/storage_index.hpp"
-#include "duckdb/function/partition_stats.hpp"
-
-namespace duckdb {
-class AttachedDatabase;
-class BlockManager;
-class ColumnData;
-class DatabaseInstance;
-class DataTable;
-class PartialBlockManager;
-struct DataTableInfo;
-class ExpressionExecutor;
-class RowGroupCollection;
-class RowGroupWriter;
-class UpdateSegment;
-class TableStatistics;
-struct ColumnSegmentInfo;
-class Vector;
-struct ColumnCheckpointState;
-struct PersistentColumnData;
-struct PersistentRowGroupData;
-struct RowGroupPointer;
-struct TransactionData;
-class CollectionScanState;
-class TableFilterSet;
-struct ColumnFetchState;
-struct RowGroupAppendState;
-class MetadataManager;
-class RowVersionManager;
-class ScanFilterInfo;
-class StorageCommitState;
-
-struct RowGroupWriteInfo {
-	RowGroupWriteInfo(PartialBlockManager &manager, const vector<CompressionType> &compression_types,
-	                  CheckpointType checkpoint_type = CheckpointType::FULL_CHECKPOINT)
-	    : manager(manager), compression_types(compression_types), checkpoint_type(checkpoint_type) {
-	}
-
-	PartialBlockManager &manager;
-	const vector<CompressionType> &compression_types;
-	CheckpointType checkpoint_type;
-};
-
-struct RowGroupWriteData {
-	vector<unique_ptr<ColumnCheckpointState>> states;
-	vector<BaseStatistics> statistics;
-};
-
-class RowGroup : public SegmentBase<RowGroup> {
-public:
-	friend class ColumnData;
-
-public:
-	RowGroup(RowGroupCollection &collection, idx_t start, idx_t count);
-	RowGroup(RowGroupCollection &collection, RowGroupPointer pointer);
-	RowGroup(RowGroupCollection &collection, PersistentRowGroupData &data);
-	~RowGroup();
-
-private:
-	//! The RowGroupCollection this row-group is a part of
-	reference<RowGroupCollection> collection;
-	//! The version info of the row_group (inserted and deleted tuple info)
-	atomic<optional_ptr<RowVersionManager>> version_info;
-	//! The owned version info of the row_group (inserted and deleted tuple info)
-	shared_ptr<RowVersionManager> owned_version_info;
-	//! The column data of the row_group
-	vector<shared_ptr<ColumnData>> columns;
-
-public:
-	void MoveToCollection(RowGroupCollection &collection, idx_t new_start);
-	RowGroupCollection &GetCollection() {
-		return collection.get();
-	}
-	BlockManager &GetBlockManager();
-	DataTableInfo &GetTableInfo();
-
-	unique_ptr<RowGroup> AlterType(RowGroupCollection &collection, const LogicalType &target_type, idx_t changed_idx,
-	                               ExpressionExecutor &executor, CollectionScanState &scan_state,
-	                               DataChunk &scan_chunk);
-	unique_ptr<RowGroup> AddColumn(RowGroupCollection &collection, ColumnDefinition &new_column,
-	                               ExpressionExecutor &executor, Vector &intermediate);
-	unique_ptr<RowGroup> RemoveColumn(RowGroupCollection &collection, idx_t removed_column);
-
-	void CommitDrop();
-	void CommitDropColumn(idx_t index);
-
-	void InitializeEmpty(const vector<LogicalType> &types);
-
-	//! Initialize a scan over this row_group
-	bool InitializeScan(CollectionScanState &state);
-	bool InitializeScanWithOffset(CollectionScanState &state, idx_t vector_offset);
-	//! Checks the given set of table filters against the row-group statistics. Returns false if the entire row group
-	//! can be skipped.
-	bool CheckZonemap(ScanFilterInfo &filters);
-	//! Checks the given set of table filters against the per-segment statistics. Returns false if any segments were
-	//! skipped.
-	bool CheckZonemapSegments(CollectionScanState &state);
-	void Scan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
-	void ScanCommitted(CollectionScanState &state, DataChunk &result, TableScanType type);
-
-	idx_t GetSelVector(TransactionData transaction, idx_t vector_idx, SelectionVector &sel_vector, idx_t max_count);
-	idx_t GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
-	                            SelectionVector &sel_vector, idx_t max_count);
-
-	//! For a specific row, returns true if it should be used for the transaction and false otherwise.
-	bool Fetch(TransactionData transaction, idx_t row);
-	//! Fetch a specific row from the row_group and insert it into the result at the specified index
-	void FetchRow(TransactionData transaction, ColumnFetchState &state, const vector<StorageIndex> &column_ids,
-	              row_t row_id, DataChunk &result, idx_t result_idx);
-
-	//! Append count rows to the version info
-	void AppendVersionInfo(TransactionData transaction, idx_t count);
-	//! Commit a previous append made by RowGroup::AppendVersionInfo
-	void CommitAppend(transaction_t commit_id, idx_t start, idx_t count);
-	//! Revert a previous append made by RowGroup::AppendVersionInfo
-	void RevertAppend(idx_t start);
-	//! Clean up append states that can either be compressed or deleted
-	void CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_t count);
-
-	//! Delete the given set of rows in the version manager
-	idx_t Delete(TransactionData transaction, DataTable &table, row_t *row_ids, idx_t count);
-
-	RowGroupWriteData WriteToDisk(RowGroupWriteInfo &info);
-	//! Returns the number of committed rows (count - committed deletes)
-	idx_t GetCommittedRowCount();
-	RowGroupWriteData WriteToDisk(RowGroupWriter &writer);
-	RowGroupPointer Checkpoint(RowGroupWriteData write_data, RowGroupWriter &writer, TableStatistics &global_stats);
-	bool IsPersistent() const;
-	PersistentRowGroupData SerializeRowGroupInfo() const;
-
-	void InitializeAppend(RowGroupAppendState &append_state);
-	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);
-
-	void Update(TransactionData transaction, DataChunk &updates, row_t *ids, idx_t offset, idx_t count,
-	            const vector<PhysicalIndex> &column_ids);
-	//! Update a single column; corresponds to DataTable::UpdateColumn
-	//! This method should only be called from the WAL
-	void UpdateColumn(TransactionData transaction, DataChunk &updates, Vector &row_ids,
-	                  const vector<column_t> &column_path);
-
-	void MergeStatistics(idx_t column_idx, const BaseStatistics &other);
-	void MergeIntoStatistics(idx_t column_idx, BaseStatistics &other);
-	void MergeIntoStatistics(TableStatistics &other);
-	unique_ptr<BaseStatistics> GetStatistics(idx_t column_idx);
-
-	void GetColumnSegmentInfo(idx_t row_group_index, vector<ColumnSegmentInfo> &result);
-	PartitionStatistics GetPartitionStats() const;
-
-	idx_t GetAllocationSize() const {
-		return allocation_size;
-	}
-
-	void Verify();
-
-	void NextVector(CollectionScanState &state);
-
-	idx_t DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count);
-	RowVersionManager &GetOrCreateVersionInfo();
-
-	// Serialization
-	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
-	static RowGroupPointer Deserialize(Deserializer &deserializer);
-
-	idx_t GetRowGroupSize() const;
-
-private:
-	optional_ptr<RowVersionManager> GetVersionInfo();
-	shared_ptr<RowVersionManager> GetOrCreateVersionInfoPtr();
-	shared_ptr<RowVersionManager> GetOrCreateVersionInfoInternal();
-	void SetVersionInfo(shared_ptr<RowVersionManager> version);
-
-	ColumnData &GetColumn(storage_t c);
-	ColumnData &GetColumn(const StorageIndex &c);
-	idx_t GetColumnCount() const;
-	vector<shared_ptr<ColumnData>> &GetColumns();
-
-	template <TableScanType TYPE>
-	void TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
-
-	vector<MetaBlockPointer> CheckpointDeletes(MetadataManager &manager);
-
-	bool HasUnloadedDeletes() const;
-
-private:
-	mutex row_group_lock;
-	vector<MetaBlockPointer> column_pointers;
-	unique_ptr<atomic<bool>[]> is_loaded;
-	vector<MetaBlockPointer> deletes_pointers;
-	atomic<bool> deletes_is_loaded;
-	idx_t allocation_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp b/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp
deleted file mode 100644
index 19aa64520..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/row_group_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/table/segment_tree.hpp"
-#include "duckdb/storage/statistics/column_statistics.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/storage/storage_index.hpp"
-
-namespace duckdb {
-
-struct ParallelTableScanState;
-struct ParallelCollectionScanState;
-class CreateIndexScanState;
-class CollectionScanState;
-class PersistentTableData;
-class TableDataWriter;
-class TableIndexList;
-class TableStatistics;
-struct TableAppendState;
-class DuckTransaction;
-class BoundConstraint;
-class RowGroupSegmentTree;
-class StorageCommitState;
-struct ColumnSegmentInfo;
-class MetadataManager;
-struct VacuumState;
-struct CollectionCheckpointState;
-struct PersistentCollectionData;
-class CheckpointTask;
-class TableIOManager;
-
-class RowGroupCollection {
-public:
-	RowGroupCollection(shared_ptr<DataTableInfo> info, TableIOManager &io_manager, vector<LogicalType> types,
-	                   idx_t row_start, idx_t total_rows = 0);
-	RowGroupCollection(shared_ptr<DataTableInfo> info, BlockManager &block_manager, vector<LogicalType> types,
-	                   idx_t row_start, idx_t total_rows, idx_t row_group_size);
-
-public:
-	idx_t GetTotalRows() const;
-	Allocator &GetAllocator() const;
-
-	void Initialize(PersistentCollectionData &data);
-	void Initialize(PersistentTableData &data);
-	void InitializeEmpty();
-
-	bool IsEmpty() const;
-
-	void AppendRowGroup(SegmentLock &l, idx_t start_row);
-	//! Get the nth row-group, negative numbers start from the back (so -1 is the last row group, etc)
-	RowGroup *GetRowGroup(int64_t index);
-	void Verify();
-
-	void InitializeScan(CollectionScanState &state, const vector<StorageIndex> &column_ids,
-	                    TableFilterSet *table_filters);
-	void InitializeCreateIndexScan(CreateIndexScanState &state);
-	void InitializeScanWithOffset(CollectionScanState &state, const vector<StorageIndex> &column_ids, idx_t start_row,
-	                              idx_t end_row);
-	static bool InitializeScanInRowGroup(CollectionScanState &state, RowGroupCollection &collection,
-	                                     RowGroup &row_group, idx_t vector_index, idx_t max_row);
-	void InitializeParallelScan(ParallelCollectionScanState &state);
-	bool NextParallelScan(ClientContext &context, ParallelCollectionScanState &state, CollectionScanState &scan_state);
-
-	bool Scan(DuckTransaction &transaction, const vector<StorageIndex> &column_ids,
-	          const std::function<bool(DataChunk &chunk)> &fun);
-	bool Scan(DuckTransaction &transaction, const std::function<bool(DataChunk &chunk)> &fun);
-
-	void Fetch(TransactionData transaction, DataChunk &result, const vector<StorageIndex> &column_ids,
-	           const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state);
-
-	//! Initialize an append of a variable number of rows. FinalizeAppend must be called after appending is done.
-	void InitializeAppend(TableAppendState &state);
-	//! Initialize an append with a variable number of rows. FinalizeAppend should not be called after appending is
-	//! done.
-	void InitializeAppend(TransactionData transaction, TableAppendState &state);
-	//! Appends to the row group collection. Returns true if a new row group has been created to append to
-	bool Append(DataChunk &chunk, TableAppendState &state);
-	//! FinalizeAppend flushes an append with a variable number of rows.
-	void FinalizeAppend(TransactionData transaction, TableAppendState &state);
-	void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count);
-	void RevertAppendInternal(idx_t start_row);
-	void CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_t count);
-
-	void MergeStorage(RowGroupCollection &data, optional_ptr<DataTable> table,
-	                  optional_ptr<StorageCommitState> commit_state);
-	bool IsPersistent() const;
-
-	void RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count);
-
-	idx_t Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count);
-	void Update(TransactionData transaction, row_t *ids, const vector<PhysicalIndex> &column_ids, DataChunk &updates);
-	void UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
-	                  DataChunk &updates);
-
-	void Checkpoint(TableDataWriter &writer, TableStatistics &global_stats);
-
-	void InitializeVacuumState(CollectionCheckpointState &checkpoint_state, VacuumState &state,
-	                           vector<SegmentNode<RowGroup>> &segments);
-	bool ScheduleVacuumTasks(CollectionCheckpointState &checkpoint_state, VacuumState &state, idx_t segment_idx,
-	                         bool schedule_vacuum);
-	unique_ptr<CheckpointTask> GetCheckpointTask(CollectionCheckpointState &checkpoint_state, idx_t segment_idx);
-
-	void CommitDropColumn(idx_t index);
-	void CommitDropTable();
-
-	vector<PartitionStatistics> GetPartitionStats() const;
-	vector<ColumnSegmentInfo> GetColumnSegmentInfo();
-	const vector<LogicalType> &GetTypes() const;
-
-	shared_ptr<RowGroupCollection> AddColumn(ClientContext &context, ColumnDefinition &new_column,
-	                                         ExpressionExecutor &default_executor);
-	shared_ptr<RowGroupCollection> RemoveColumn(idx_t col_idx);
-	shared_ptr<RowGroupCollection> AlterType(ClientContext &context, idx_t changed_idx, const LogicalType &target_type,
-	                                         vector<StorageIndex> bound_columns, Expression &cast_expr);
-	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
-
-	void CopyStats(TableStatistics &stats);
-	unique_ptr<BaseStatistics> CopyStats(column_t column_id);
-	unique_ptr<BlockingSample> GetSample();
-	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
-
-	AttachedDatabase &GetAttached();
-	BlockManager &GetBlockManager() {
-		return block_manager;
-	}
-	MetadataManager &GetMetadataManager();
-	DataTableInfo &GetTableInfo() {
-		return *info;
-	}
-
-	idx_t GetAllocationSize() const {
-		return allocation_size;
-	}
-
-	idx_t GetRowGroupSize() const {
-		return row_group_size;
-	}
-
-private:
-	bool IsEmpty(SegmentLock &) const;
-
-private:
-	//! BlockManager
-	BlockManager &block_manager;
-	//! The row group size of the row group collection
-	const idx_t row_group_size;
-	//! The number of rows in the table
-	atomic<idx_t> total_rows;
-	//! The data table info
-	shared_ptr<DataTableInfo> info;
-	//! The column types of the row group collection
-	vector<LogicalType> types;
-	idx_t row_start;
-	//! The segment trees holding the various row_groups of the table
-	shared_ptr<RowGroupSegmentTree> row_groups;
-	//! Table statistics
-	TableStatistics stats;
-	//! Allocation size, only tracked for appends
-	idx_t allocation_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/row_group_segment_tree.hpp b/src/duckdb/src/include/duckdb/storage/table/row_group_segment_tree.hpp
deleted file mode 100644
index 948107531..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/row_group_segment_tree.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/row_group_segment_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/segment_tree.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-
-namespace duckdb {
-struct DataTableInfo;
-class PersistentTableData;
-class MetadataReader;
-
-class RowGroupSegmentTree : public SegmentTree<RowGroup, true> {
-public:
-	explicit RowGroupSegmentTree(RowGroupCollection &collection);
-	~RowGroupSegmentTree() override;
-
-	void Initialize(PersistentTableData &data);
-
-protected:
-	unique_ptr<RowGroup> LoadSegment() override;
-
-	RowGroupCollection &collection;
-	idx_t current_row_group;
-	idx_t max_row_group;
-	unique_ptr<MetadataReader> reader;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/row_version_manager.hpp b/src/duckdb/src/include/duckdb/storage/table/row_version_manager.hpp
deleted file mode 100644
index bb0d0056b..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/row_version_manager.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/row_version_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/vector_size.hpp"
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/mutex.hpp"
-
-namespace duckdb {
-
-struct DeleteInfo;
-class MetadataManager;
-struct MetaBlockPointer;
-
-class RowVersionManager {
-public:
-	explicit RowVersionManager(idx_t start) noexcept;
-
-	idx_t GetStart() {
-		return start;
-	}
-	void SetStart(idx_t start);
-	idx_t GetCommittedDeletedCount(idx_t count);
-
-	idx_t GetSelVector(TransactionData transaction, idx_t vector_idx, SelectionVector &sel_vector, idx_t max_count);
-	idx_t GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
-	                            SelectionVector &sel_vector, idx_t max_count);
-	bool Fetch(TransactionData transaction, idx_t row);
-
-	void AppendVersionInfo(TransactionData transaction, idx_t count, idx_t row_group_start, idx_t row_group_end);
-	void CommitAppend(transaction_t commit_id, idx_t row_group_start, idx_t count);
-	void RevertAppend(idx_t start_row);
-	void CleanupAppend(transaction_t lowest_active_transaction, idx_t row_group_start, idx_t count);
-
-	idx_t DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count);
-	void CommitDelete(idx_t vector_idx, transaction_t commit_id, const DeleteInfo &info);
-
-	vector<MetaBlockPointer> Checkpoint(MetadataManager &manager);
-	static shared_ptr<RowVersionManager> Deserialize(MetaBlockPointer delete_pointer, MetadataManager &manager,
-	                                                 idx_t start);
-
-private:
-	mutex version_lock;
-	idx_t start;
-	vector<unique_ptr<ChunkInfo>> vector_info;
-	bool has_changes;
-	vector<MetaBlockPointer> storage_pointers;
-
-private:
-	optional_ptr<ChunkInfo> GetChunkInfo(idx_t vector_idx);
-	ChunkVectorInfo &GetVectorInfo(idx_t vector_idx);
-	void FillVectorInfo(idx_t vector_idx);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp b/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp
deleted file mode 100644
index e94381a65..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp
+++ /dev/null
@@ -1,306 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/scan_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/common/enums/scan_options.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/storage/table/segment_lock.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/storage/storage_index.hpp"
-
-namespace duckdb {
-class AdaptiveFilter;
-class ColumnSegment;
-class LocalTableStorage;
-class CollectionScanState;
-class Index;
-class RowGroup;
-class RowGroupCollection;
-class UpdateSegment;
-class TableScanState;
-class ColumnSegment;
-class ColumnSegmentTree;
-class ValiditySegment;
-class TableFilterSet;
-class ColumnData;
-class DuckTransaction;
-class RowGroupSegmentTree;
-class TableFilter;
-struct AdaptiveFilterState;
-struct TableScanOptions;
-struct ScanSamplingInfo;
-
-struct SegmentScanState {
-	virtual ~SegmentScanState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-struct IndexScanState {
-	virtual ~IndexScanState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
-typedef unordered_map<block_id_t, BufferHandle> buffer_handle_set_t;
-
-struct ColumnScanState {
-	//! The column segment that is currently being scanned
-	ColumnSegment *current = nullptr;
-	//! Column segment tree
-	ColumnSegmentTree *segment_tree = nullptr;
-	//! The current row index of the scan
-	idx_t row_index = 0;
-	//! The internal row index (i.e. the position of the SegmentScanState)
-	idx_t internal_index = 0;
-	//! Segment scan state
-	unique_ptr<SegmentScanState> scan_state;
-	//! Child states of the vector
-	vector<ColumnScanState> child_states;
-	//! Whether or not InitializeState has been called for this segment
-	bool initialized = false;
-	//! If this segment has already been checked for skipping purposes
-	bool segment_checked = false;
-	//! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more
-	//! than one Segment, we need to keep the scan states of the previous segments around
-	vector<unique_ptr<SegmentScanState>> previous_states;
-	//! The last read offset in the child state (used for LIST columns only)
-	idx_t last_offset = 0;
-	//! Whether or not we should scan a specific child column
-	vector<bool> scan_child_column;
-	//! Contains TableScan level config for scanning
-	optional_ptr<TableScanOptions> scan_options;
-
-public:
-	void Initialize(const LogicalType &type, const vector<StorageIndex> &children,
-	                optional_ptr<TableScanOptions> options);
-	void Initialize(const LogicalType &type, optional_ptr<TableScanOptions> options);
-	//! Move the scan state forward by "count" rows (including all child states)
-	void Next(idx_t count);
-	//! Move ONLY this state forward by "count" rows (i.e. not the child states)
-	void NextInternal(idx_t count);
-};
-
-struct ColumnFetchState {
-	//! The set of pinned block handles for this set of fetches
-	buffer_handle_set_t handles;
-	//! Any child states of the fetch
-	vector<unique_ptr<ColumnFetchState>> child_states;
-
-	BufferHandle &GetOrInsertHandle(ColumnSegment &segment);
-};
-
-struct ScanFilter {
-	ScanFilter(idx_t index, const vector<StorageIndex> &column_ids, TableFilter &filter);
-
-	idx_t scan_column_index;
-	idx_t table_column_index;
-	TableFilter &filter;
-	bool always_true;
-
-	bool IsAlwaysTrue() const {
-		return always_true;
-	}
-};
-
-class ScanFilterInfo {
-public:
-	~ScanFilterInfo();
-
-	void Initialize(TableFilterSet &filters, const vector<StorageIndex> &column_ids);
-
-	const vector<ScanFilter> &GetFilterList() const {
-		return filter_list;
-	}
-
-	optional_ptr<AdaptiveFilter> GetAdaptiveFilter();
-	AdaptiveFilterState BeginFilter() const;
-	void EndFilter(AdaptiveFilterState state);
-
-	//! Whether or not there is any filter we need to execute
-	bool HasFilters() const;
-
-	//! Whether or not there is a filter we need to execute for this column currently
-	bool ColumnHasFilters(idx_t col_idx);
-
-	//! Resets any SetFilterAlwaysTrue flags
-	void CheckAllFilters();
-	//! Labels the filters for this specific column as always true
-	//! We do not need to execute them anymore until CheckAllFilters is called
-	void SetFilterAlwaysTrue(idx_t filter_idx);
-
-private:
-	//! The table filters (if any)
-	optional_ptr<TableFilterSet> table_filters;
-	//! Adaptive filter info (if any)
-	unique_ptr<AdaptiveFilter> adaptive_filter;
-	//! The set of filters
-	vector<ScanFilter> filter_list;
-	//! Whether or not the column has a filter active right now
-	unsafe_vector<bool> column_has_filter;
-	//! Whether or not the column has a filter active at all
-	unsafe_vector<bool> base_column_has_filter;
-	//! The amount of filters that are always true currently
-	idx_t always_true_filters = 0;
-};
-
-class CollectionScanState {
-public:
-	explicit CollectionScanState(TableScanState &parent_p);
-
-	//! The current row_group we are scanning
-	RowGroup *row_group;
-	//! The vector index within the row_group
-	idx_t vector_index;
-	//! The maximum row within the row group
-	idx_t max_row_group_row;
-	//! Child column scans
-	unsafe_unique_array<ColumnScanState> column_scans;
-	//! Row group segment tree
-	RowGroupSegmentTree *row_groups;
-	//! The total maximum row index
-	idx_t max_row;
-	//! The current batch index
-	idx_t batch_index;
-	//! The valid selection
-	SelectionVector valid_sel;
-
-	RandomEngine random;
-
-public:
-	void Initialize(const vector<LogicalType> &types);
-	const vector<StorageIndex> &GetColumnIds();
-	ScanFilterInfo &GetFilterInfo();
-	ScanSamplingInfo &GetSamplingInfo();
-	TableScanOptions &GetOptions();
-	bool Scan(DuckTransaction &transaction, DataChunk &result);
-	bool ScanCommitted(DataChunk &result, TableScanType type);
-	bool ScanCommitted(DataChunk &result, SegmentLock &l, TableScanType type);
-
-private:
-	TableScanState &parent;
-};
-
-struct ScanSamplingInfo {
-	//! Whether or not to do a system sample during scanning
-	bool do_system_sample = false;
-	//! The sampling rate to use
-	double sample_rate;
-};
-
-struct TableScanOptions {
-	//! Fetch rows one-at-a-time instead of using the regular scans.
-	bool force_fetch_row = false;
-};
-
-class CheckpointLock {
-public:
-	explicit CheckpointLock(unique_ptr<StorageLockKey> lock_p) : lock(std::move(lock_p)) {
-	}
-
-private:
-	unique_ptr<StorageLockKey> lock;
-};
-
-class TableScanState {
-public:
-	TableScanState();
-	~TableScanState();
-
-	//! The underlying table scan state
-	CollectionScanState table_state;
-	//! Transaction-local scan state
-	CollectionScanState local_state;
-	//! Options for scanning
-	TableScanOptions options;
-	//! Shared lock over the checkpoint to prevent checkpoints while reading
-	shared_ptr<CheckpointLock> checkpoint_lock;
-	//! Filter info
-	ScanFilterInfo filters;
-	//! Sampling info
-	ScanSamplingInfo sampling_info;
-
-public:
-	void Initialize(vector<StorageIndex> column_ids, optional_ptr<TableFilterSet> table_filters = nullptr,
-	                optional_ptr<SampleOptions> table_sampling = nullptr);
-
-	const vector<StorageIndex> &GetColumnIds();
-
-	ScanFilterInfo &GetFilterInfo();
-
-	ScanSamplingInfo &GetSamplingInfo();
-
-private:
-	//! The column identifiers of the scan
-	vector<StorageIndex> column_ids;
-};
-
-struct ParallelCollectionScanState {
-	ParallelCollectionScanState();
-
-	//! The row group collection we are scanning
-	RowGroupCollection *collection;
-	RowGroup *current_row_group;
-	idx_t vector_index;
-	idx_t max_row;
-	idx_t batch_index;
-	atomic<idx_t> processed_rows;
-	mutex lock;
-};
-
-struct ParallelTableScanState {
-	//! Parallel scan state for the table
-	ParallelCollectionScanState scan_state;
-	//! Parallel scan state for the transaction-local state
-	ParallelCollectionScanState local_state;
-	//! Shared lock over the checkpoint to prevent checkpoints while reading
-	shared_ptr<CheckpointLock> checkpoint_lock;
-};
-
-struct PrefetchState {
-	~PrefetchState();
-
-	void AddBlock(shared_ptr<BlockHandle> block);
-
-	vector<shared_ptr<BlockHandle>> blocks;
-};
-
-class CreateIndexScanState : public TableScanState {
-public:
-	vector<unique_ptr<StorageLockKey>> locks;
-	unique_lock<mutex> append_lock;
-	SegmentLock segment_lock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/segment_base.hpp b/src/duckdb/src/include/duckdb/storage/table/segment_base.hpp
deleted file mode 100644
index b71587bf8..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/segment_base.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/segment_base.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/atomic.hpp"
-
-namespace duckdb {
-
-template <class T>
-class SegmentBase {
-public:
-	SegmentBase(idx_t start, idx_t count) : start(start), count(count), next(nullptr) {
-	}
-	T *Next() {
-#ifndef DUCKDB_R_BUILD
-		return next.load();
-#else
-		return next;
-#endif
-	}
-
-	//! The start row id of this chunk
-	idx_t start;
-	//! The amount of entries in this storage chunk
-	atomic<idx_t> count;
-	//! The next segment after this one
-#ifndef DUCKDB_R_BUILD
-	atomic<T *> next;
-#else
-	T *next;
-#endif
-	//! The index within the segment tree
-	idx_t index;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/segment_lock.hpp b/src/duckdb/src/include/duckdb/storage/table/segment_lock.hpp
deleted file mode 100644
index 22ed6ceec..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/segment_lock.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/segment_lock.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/mutex.hpp"
-
-namespace duckdb {
-
-struct SegmentLock {
-public:
-	SegmentLock() {
-	}
-	explicit SegmentLock(mutex &lock) : lock(lock) {
-	}
-	// disable copy constructors
-	SegmentLock(const SegmentLock &other) = delete;
-	SegmentLock &operator=(const SegmentLock &) = delete;
-	//! enable move constructors
-	SegmentLock(SegmentLock &&other) noexcept {
-		std::swap(lock, other.lock);
-	}
-	SegmentLock &operator=(SegmentLock &&other) noexcept {
-		std::swap(lock, other.lock);
-		return *this;
-	}
-
-private:
-	unique_lock<mutex> lock;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp b/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp
deleted file mode 100644
index 1a461ac37..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp
+++ /dev/null
@@ -1,358 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/segment_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/table/segment_lock.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-template <class T>
-struct SegmentNode {
-	idx_t row_start;
-	unique_ptr<T> node;
-};
-
-//! The SegmentTree maintains a list of all segments of a specific column in a table, and allows searching for a segment
-//! by row number
-template <class T, bool SUPPORTS_LAZY_LOADING = false>
-class SegmentTree {
-private:
-	class SegmentIterationHelper;
-
-public:
-	explicit SegmentTree() : finished_loading(true) {
-	}
-	virtual ~SegmentTree() {
-	}
-
-	//! Locks the segment tree. All methods to the segment tree either lock the segment tree, or take an already
-	//! obtained lock.
-	SegmentLock Lock() {
-		return SegmentLock(node_lock);
-	}
-
-	bool IsEmpty(SegmentLock &l) {
-		return GetRootSegment(l) == nullptr;
-	}
-
-	//! Gets a pointer to the first segment. Useful for scans.
-	T *GetRootSegment() {
-		auto l = Lock();
-		return GetRootSegment(l);
-	}
-
-	T *GetRootSegment(SegmentLock &l) {
-		if (nodes.empty()) {
-			LoadNextSegment(l);
-		}
-		return GetRootSegmentInternal();
-	}
-	//! Obtains ownership of the data of the segment tree
-	vector<SegmentNode<T>> MoveSegments(SegmentLock &l) {
-		LoadAllSegments(l);
-		return std::move(nodes);
-	}
-	vector<SegmentNode<T>> MoveSegments() {
-		auto l = Lock();
-		return MoveSegments(l);
-	}
-
-	const vector<SegmentNode<T>> &ReferenceSegments(SegmentLock &l) {
-		LoadAllSegments(l);
-		return nodes;
-	}
-	const vector<SegmentNode<T>> &ReferenceSegments() {
-		auto l = Lock();
-		return ReferenceSegments(l);
-	}
-
-	idx_t GetSegmentCount() {
-		auto l = Lock();
-		return GetSegmentCount(l);
-	}
-	idx_t GetSegmentCount(SegmentLock &l) {
-		return nodes.size();
-	}
-	//! Gets a pointer to the nth segment. Negative numbers start from the back.
-	T *GetSegmentByIndex(int64_t index) {
-		auto l = Lock();
-		return GetSegmentByIndex(l, index);
-	}
-	T *GetSegmentByIndex(SegmentLock &l, int64_t index) {
-		if (index < 0) {
-			// load all segments
-			LoadAllSegments(l);
-			index += nodes.size();
-			if (index < 0) {
-				return nullptr;
-			}
-			return nodes[UnsafeNumericCast<idx_t>(index)].node.get();
-		} else {
-			// lazily load segments until we reach the specific segment
-			while (idx_t(index) >= nodes.size() && LoadNextSegment(l)) {
-			}
-			if (idx_t(index) >= nodes.size()) {
-				return nullptr;
-			}
-			return nodes[UnsafeNumericCast<idx_t>(index)].node.get();
-		}
-	}
-	//! Gets the next segment
-	T *GetNextSegment(T *segment) {
-		if (!SUPPORTS_LAZY_LOADING) {
-			return segment->Next();
-		}
-		if (finished_loading) {
-			return segment->Next();
-		}
-		auto l = Lock();
-		return GetNextSegment(l, segment);
-	}
-	T *GetNextSegment(SegmentLock &l, T *segment) {
-		if (!segment) {
-			return nullptr;
-		}
-#ifdef DEBUG
-		D_ASSERT(nodes[segment->index].node.get() == segment);
-#endif
-		return GetSegmentByIndex(l, UnsafeNumericCast<int64_t>(segment->index + 1));
-	}
-
-	//! Gets a pointer to the last segment. Useful for appends.
-	T *GetLastSegment(SegmentLock &l) {
-		LoadAllSegments(l);
-		if (nodes.empty()) {
-			return nullptr;
-		}
-		return nodes.back().node.get();
-	}
-	//! Gets a pointer to a specific column segment for the given row
-	T *GetSegment(idx_t row_number) {
-		auto l = Lock();
-		return GetSegment(l, row_number);
-	}
-	T *GetSegment(SegmentLock &l, idx_t row_number) {
-		return nodes[GetSegmentIndex(l, row_number)].node.get();
-	}
-
-	//! Append a column segment to the tree
-	void AppendSegmentInternal(SegmentLock &l, unique_ptr<T> segment) {
-		D_ASSERT(segment);
-		// add the node to the list of nodes
-		if (!nodes.empty()) {
-			nodes.back().node->next = segment.get();
-		}
-		SegmentNode<T> node;
-		segment->index = nodes.size();
-		segment->next = nullptr;
-		node.row_start = segment->start;
-		node.node = std::move(segment);
-		nodes.push_back(std::move(node));
-	}
-	void AppendSegment(unique_ptr<T> segment) {
-		auto l = Lock();
-		AppendSegment(l, std::move(segment));
-	}
-	void AppendSegment(SegmentLock &l, unique_ptr<T> segment) {
-		LoadAllSegments(l);
-		AppendSegmentInternal(l, std::move(segment));
-	}
-	//! Debug method, check whether the segment is in the segment tree
-	bool HasSegment(T *segment) {
-		auto l = Lock();
-		return HasSegment(l, segment);
-	}
-	bool HasSegment(SegmentLock &, T *segment) {
-		return segment->index < nodes.size() && nodes[segment->index].node.get() == segment;
-	}
-
-	//! Erase all segments after a specific segment
-	void EraseSegments(SegmentLock &l, idx_t segment_start) {
-		LoadAllSegments(l);
-		if (segment_start >= nodes.size() - 1) {
-			return;
-		}
-		nodes.erase(nodes.begin() + UnsafeNumericCast<int64_t>(segment_start) + 1, nodes.end());
-	}
-
-	//! Get the segment index of the column segment for the given row
-	idx_t GetSegmentIndex(SegmentLock &l, idx_t row_number) {
-		idx_t segment_index;
-		if (TryGetSegmentIndex(l, row_number, segment_index)) {
-			return segment_index;
-		}
-		string error;
-		error = StringUtil::Format("Attempting to find row number \"%lld\" in %lld nodes\n", row_number, nodes.size());
-		for (idx_t i = 0; i < nodes.size(); i++) {
-			error += StringUtil::Format("Node %lld: Start %lld, Count %lld", i, nodes[i].row_start,
-			                            nodes[i].node->count.load());
-		}
-		throw InternalException("Could not find node in column segment tree!\n%s%s", error, Exception::GetStackTrace());
-	}
-
-	bool TryGetSegmentIndex(SegmentLock &l, idx_t row_number, idx_t &result) {
-		// load segments until the row number is within bounds
-		while (nodes.empty() || (row_number >= (nodes.back().row_start + nodes.back().node->count))) {
-			if (!LoadNextSegment(l)) {
-				break;
-			}
-		}
-		if (nodes.empty()) {
-			return false;
-		}
-		idx_t lower = 0;
-		idx_t upper = nodes.size() - 1;
-		// binary search to find the node
-		while (lower <= upper) {
-			idx_t index = (lower + upper) / 2;
-			D_ASSERT(index < nodes.size());
-			auto &entry = nodes[index];
-			D_ASSERT(entry.row_start == entry.node->start);
-			if (row_number < entry.row_start) {
-				upper = index - 1;
-			} else if (row_number >= entry.row_start + entry.node->count) {
-				lower = index + 1;
-			} else {
-				result = index;
-				return true;
-			}
-		}
-		return false;
-	}
-
-	void Verify(SegmentLock &) {
-#ifdef DEBUG
-		idx_t base_start = nodes.empty() ? 0 : nodes[0].node->start;
-		for (idx_t i = 0; i < nodes.size(); i++) {
-			D_ASSERT(nodes[i].row_start == nodes[i].node->start);
-			D_ASSERT(nodes[i].node->start == base_start);
-			base_start += nodes[i].node->count;
-		}
-#endif
-	}
-	void Verify() {
-#ifdef DEBUG
-		auto l = Lock();
-		Verify(l);
-#endif
-	}
-
-	SegmentIterationHelper Segments() {
-		return SegmentIterationHelper(*this);
-	}
-
-	void Reinitialize() {
-		if (nodes.empty()) {
-			return;
-		}
-		idx_t offset = nodes[0].node->start;
-		for (auto &entry : nodes) {
-			if (entry.node->start != offset) {
-				throw InternalException("In SegmentTree::Reinitialize - gap found between nodes!");
-			}
-			entry.row_start = offset;
-			offset += entry.node->count;
-		}
-	}
-
-protected:
-	atomic<bool> finished_loading;
-
-	//! Load the next segment - only used when lazily loading
-	virtual unique_ptr<T> LoadSegment() {
-		return nullptr;
-	}
-
-private:
-	//! The nodes in the tree, can be binary searched
-	vector<SegmentNode<T>> nodes;
-	//! Lock to access or modify the nodes
-	mutex node_lock;
-
-private:
-	T *GetRootSegmentInternal() {
-		return nodes.empty() ? nullptr : nodes[0].node.get();
-	}
-
-	class SegmentIterationHelper {
-	public:
-		explicit SegmentIterationHelper(SegmentTree &tree) : tree(tree) {
-		}
-
-	private:
-		SegmentTree &tree;
-
-	private:
-		class SegmentIterator {
-		public:
-			SegmentIterator(SegmentTree &tree_p, T *current_p) : tree(tree_p), current(current_p) {
-			}
-
-			SegmentTree &tree;
-			T *current;
-
-		public:
-			void Next() {
-				current = tree.GetNextSegment(current);
-			}
-
-			SegmentIterator &operator++() {
-				Next();
-				return *this;
-			}
-			bool operator!=(const SegmentIterator &other) const {
-				return current != other.current;
-			}
-			T &operator*() const {
-				D_ASSERT(current);
-				return *current;
-			}
-		};
-
-	public:
-		SegmentIterator begin() { // NOLINT: match stl API
-			return SegmentIterator(tree, tree.GetRootSegment());
-		}
-		SegmentIterator end() { // NOLINT: match stl API
-			return SegmentIterator(tree, nullptr);
-		}
-	};
-
-	//! Load the next segment, if there are any left to load
-	bool LoadNextSegment(SegmentLock &l) {
-		if (!SUPPORTS_LAZY_LOADING) {
-			return false;
-		}
-		if (finished_loading) {
-			return false;
-		}
-		auto result = LoadSegment();
-		if (result) {
-			AppendSegmentInternal(l, std::move(result));
-			return true;
-		}
-		return false;
-	}
-
-	//! Load all segments, if there are any left to load
-	void LoadAllSegments(SegmentLock &l) {
-		if (!SUPPORTS_LAZY_LOADING) {
-			return;
-		}
-		while (LoadNextSegment(l)) {
-		}
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp
deleted file mode 100644
index 97fbc889c..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/standard_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/validity_column_data.hpp"
-
-namespace duckdb {
-
-//! Standard column data represents a regular flat column (e.g. a column of type INTEGER or STRING)
-class StandardColumnData : public ColumnData {
-public:
-	StandardColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                   LogicalType type, optional_ptr<ColumnData> parent = nullptr);
-
-	//! The validity column data
-	ValidityColumnData validity;
-
-public:
-	void SetStart(idx_t new_start) override;
-
-	ScanVectorType GetVectorScanType(ColumnScanState &state, idx_t scan_count, Vector &result) override;
-	void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override;
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	           idx_t target_count) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-	                    idx_t target_count) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void Filter(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	            SelectionVector &sel, idx_t &count, const TableFilter &filter) override;
-	void Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	            SelectionVector &sel, idx_t sel_count) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group,
-	                                                        PartialBlockManager &partial_block_manager) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
-	void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
-	                    Vector &scan_vector) override;
-
-	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-	                          vector<duckdb::ColumnSegmentInfo> &result) override;
-
-	bool IsPersistent() override;
-	PersistentColumnData Serialize() override;
-	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
-
-	void Verify(RowGroup &parent) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp
deleted file mode 100644
index 0d5d79231..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/struct_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/validity_column_data.hpp"
-
-namespace duckdb {
-
-//! Struct column data represents a struct
-class StructColumnData : public ColumnData {
-public:
-	StructColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                 LogicalType type, optional_ptr<ColumnData> parent = nullptr);
-
-	//! The sub-columns of the struct
-	vector<unique_ptr<ColumnData>> sub_columns;
-	//! The validity column data of the struct
-	ValidityColumnData validity;
-
-public:
-	void SetStart(idx_t new_start) override;
-	idx_t GetMaxEntry() override;
-
-	void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override;
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	           idx_t scan_count) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-	                    idx_t scan_count) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group,
-	                                                        PartialBlockManager &partial_block_manager) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
-
-	bool IsPersistent() override;
-	PersistentColumnData Serialize() override;
-	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
-
-	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-	                          vector<duckdb::ColumnSegmentInfo> &result) override;
-
-	void Verify(RowGroup &parent) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/table_index_list.hpp b/src/duckdb/src/include/duckdb/storage/table/table_index_list.hpp
deleted file mode 100644
index 6ae66836e..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/table_index_list.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/table_index_list.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/storage/index.hpp"
-
-namespace duckdb {
-
-class ConflictManager;
-
-struct IndexStorageInfo;
-struct DataTableInfo;
-
-class TableIndexList {
-public:
-	//! Scan the indexes, invoking the callback method for every entry.
-	template <class T>
-	void Scan(T &&callback) {
-		lock_guard<mutex> lock(indexes_lock);
-		for (auto &index : indexes) {
-			if (callback(*index)) {
-				break;
-			}
-		}
-	}
-
-	//! Scan the indexes, invoking the callback method for every bound entry of type T.
-	template <class T, class FUNC>
-	void ScanBound(FUNC &&callback) {
-		lock_guard<mutex> lock(indexes_lock);
-		for (auto &index : indexes) {
-			if (index->IsBound() && T::TYPE_NAME == index->GetIndexType()) {
-				if (callback(index->Cast<T>())) {
-					break;
-				}
-			}
-		}
-	}
-
-	// Bind any unbound indexes of type T and invoke the callback method.
-	template <class T, class FUNC>
-	void BindAndScan(ClientContext &context, DataTableInfo &table_info, FUNC &&callback) {
-		// FIXME: optimize this by only looping through the indexes once without re-acquiring the lock.
-		InitializeIndexes(context, table_info, T::TYPE_NAME);
-		ScanBound<T>(callback);
-	}
-
-	//! Returns a reference to the indexes.
-	const vector<unique_ptr<Index>> &Indexes() const {
-		return indexes;
-	}
-	//! Adds an index to the list of indexes.
-	void AddIndex(unique_ptr<Index> index);
-	//! Removes an index from the list of indexes.
-	void RemoveIndex(const string &name);
-	//! Removes all remaining memory of an index after dropping the catalog entry.
-	void CommitDrop(const string &name);
-	//! Returns true, if the index name does not exist.
-	bool NameIsUnique(const string &name);
-	//! Returns an optional pointer to the index matching the name.
-	optional_ptr<BoundIndex> Find(const string &name);
-	//! Initializes unknown indexes that are possibly present after an extension load, optionally throwing an exception
-	//! on failure.
-	void InitializeIndexes(ClientContext &context, DataTableInfo &table_info, const char *index_type = nullptr);
-	//! Returns true, if there are no indexes in this list.
-	bool Empty();
-	//! Returns the number of indexes in this list.
-	idx_t Count();
-	//! Overwrite this list with the other list.
-	void Move(TableIndexList &other);
-	//! Find the foreign key matching the keys.
-	Index *FindForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, const ForeignKeyType fk_type);
-	//! Verify a foreign key constraint.
-	void VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, DataChunk &chunk, ConflictManager &conflict_manager);
-	//! Get the combined column ids of the indexes in this list.
-	unordered_set<column_t> GetRequiredColumns();
-	//! Serialize all indexes of this table.
-	vector<IndexStorageInfo> GetStorageInfos(const case_insensitive_map_t<Value> &options);
-
-private:
-	mutex indexes_lock;
-	// Indexes associated with the table.
-	vector<unique_ptr<Index>> indexes;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp b/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp
deleted file mode 100644
index 628023dfd..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/table_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/execution/reservoir_sample.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/storage/statistics/column_statistics.hpp"
-
-namespace duckdb {
-class ColumnList;
-class PersistentTableData;
-class Serializer;
-class Deserializer;
-
-class TableStatisticsLock {
-public:
-	explicit TableStatisticsLock(mutex &l) : guard(l) {
-	}
-
-	lock_guard<mutex> guard;
-};
-
-class TableStatistics {
-public:
-	void Initialize(const vector<LogicalType> &types, PersistentTableData &data);
-	void InitializeEmpty(const vector<LogicalType> &types);
-
-	void InitializeAddColumn(TableStatistics &parent, const LogicalType &new_column_type);
-	void InitializeRemoveColumn(TableStatistics &parent, idx_t removed_column);
-	void InitializeAlterType(TableStatistics &parent, idx_t changed_idx, const LogicalType &new_type);
-	void InitializeAddConstraint(TableStatistics &parent);
-
-	void MergeStats(TableStatistics &other);
-	void MergeStats(idx_t i, BaseStatistics &stats);
-	void MergeStats(TableStatisticsLock &lock, idx_t i, BaseStatistics &stats);
-
-	void CopyStats(TableStatistics &other);
-	void CopyStats(TableStatisticsLock &lock, TableStatistics &other);
-	unique_ptr<BaseStatistics> CopyStats(idx_t i);
-	//! Get a reference to the stats - this requires us to hold the lock.
-	//! The reference can only be safely accessed while the lock is held
-	ColumnStatistics &GetStats(TableStatisticsLock &lock, idx_t i);
-	//! Get a reference to the table sample - this requires us to hold the lock.
-	BlockingSample &GetTableSampleRef(TableStatisticsLock &lock);
-	//! Take ownership of the sample, needed for merging. Requires the lock
-	unique_ptr<BlockingSample> GetTableSample(TableStatisticsLock &lock);
-	void SetTableSample(TableStatisticsLock &lock, unique_ptr<BlockingSample> sample);
-
-	void DestroyTableSample(TableStatisticsLock &lock) const;
-	void AppendToTableSample(TableStatisticsLock &lock, unique_ptr<BlockingSample> sample);
-
-	bool Empty();
-
-	unique_ptr<TableStatisticsLock> GetLock();
-
-	void Serialize(Serializer &serializer) const;
-	void Deserialize(Deserializer &deserializer, ColumnList &columns);
-
-private:
-	//! The statistics lock
-	shared_ptr<mutex> stats_lock;
-	//! Column statistics
-	vector<shared_ptr<ColumnStatistics>> column_stats;
-	//! The table sample
-	unique_ptr<BlockingSample> table_sample;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp b/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp
deleted file mode 100644
index a0e325c31..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/update_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/common/types/string_heap.hpp"
-#include "duckdb/transaction/undo_buffer_allocator.hpp"
-
-namespace duckdb {
-class ColumnData;
-class DataTable;
-class Vector;
-struct UpdateInfo;
-struct UpdateNode;
-struct UndoBufferAllocator;
-
-class UpdateSegment {
-public:
-	explicit UpdateSegment(ColumnData &column_data);
-	~UpdateSegment();
-
-	ColumnData &column_data;
-
-public:
-	bool HasUpdates() const;
-	bool HasUncommittedUpdates(idx_t vector_index);
-	bool HasUpdates(idx_t vector_index) const;
-	bool HasUpdates(idx_t start_row_idx, idx_t end_row_idx);
-
-	void FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result);
-	void FetchCommitted(idx_t vector_index, Vector &result);
-	void FetchCommittedRange(idx_t start_row, idx_t count, Vector &result);
-	void Update(TransactionData transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
-	            Vector &base_data);
-	void FetchRow(TransactionData transaction, idx_t row_id, Vector &result, idx_t result_idx);
-
-	void RollbackUpdate(UpdateInfo &info);
-	void CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo &info);
-	void CleanupUpdate(UpdateInfo &info);
-
-	unique_ptr<BaseStatistics> GetStatistics();
-	StringHeap &GetStringHeap() {
-		return heap;
-	}
-
-private:
-	//! The lock for the update segment
-	mutable StorageLock lock;
-	//! The root node (if any)
-	unique_ptr<UpdateNode> root;
-	//! Update statistics
-	SegmentStatistics stats;
-	//! Stats lock
-	mutex stats_lock;
-	//! Internal type size
-	idx_t type_size;
-	//! String heap, only used for strings
-	StringHeap heap;
-
-public:
-	typedef void (*initialize_update_function_t)(UpdateInfo &base_info, Vector &base_data, UpdateInfo &update_info,
-	                                             Vector &update, const SelectionVector &sel);
-	typedef void (*merge_update_function_t)(UpdateInfo &base_info, Vector &base_data, UpdateInfo &update_info,
-	                                        Vector &update, row_t *ids, idx_t count, const SelectionVector &sel);
-	typedef void (*fetch_update_function_t)(transaction_t start_time, transaction_t transaction_id, UpdateInfo &info,
-	                                        Vector &result);
-	typedef void (*fetch_committed_function_t)(UpdateInfo &info, Vector &result);
-	typedef void (*fetch_committed_range_function_t)(UpdateInfo &info, idx_t start, idx_t end, idx_t result_offset,
-	                                                 Vector &result);
-	typedef void (*fetch_row_function_t)(transaction_t start_time, transaction_t transaction_id, UpdateInfo &info,
-	                                     idx_t row_idx, Vector &result, idx_t result_idx);
-	typedef void (*rollback_update_function_t)(UpdateInfo &base_info, UpdateInfo &rollback_info);
-	typedef idx_t (*statistics_update_function_t)(UpdateSegment *segment, SegmentStatistics &stats, Vector &update,
-	                                              idx_t count, SelectionVector &sel);
-
-private:
-	initialize_update_function_t initialize_update_function;
-	merge_update_function_t merge_update_function;
-	fetch_update_function_t fetch_update_function;
-	fetch_committed_function_t fetch_committed_function;
-	fetch_committed_range_function_t fetch_committed_range;
-	fetch_row_function_t fetch_row_function;
-	rollback_update_function_t rollback_update_function;
-	statistics_update_function_t statistics_update_function;
-
-private:
-	UndoBufferPointer GetUpdateNode(idx_t vector_idx) const;
-	void InitializeUpdateInfo(idx_t vector_idx);
-	void InitializeUpdateInfo(UpdateInfo &info, row_t *ids, const SelectionVector &sel, idx_t count, idx_t vector_index,
-	                          idx_t vector_offset);
-};
-
-struct UpdateNode {
-	explicit UpdateNode(BufferManager &manager);
-	~UpdateNode();
-
-	UndoBufferAllocator allocator;
-	vector<UndoBufferPointer> info;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/update_state.hpp b/src/duckdb/src/include/duckdb/storage/table/update_state.hpp
deleted file mode 100644
index 0a8193c54..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/update_state.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/update_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/append_state.hpp"
-
-namespace duckdb {
-class TableCatalogEntry;
-
-struct TableUpdateState {
-	unique_ptr<ConstraintState> constraint_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table/validity_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/validity_column_data.hpp
deleted file mode 100644
index 286a5343b..000000000
--- a/src/duckdb/src/include/duckdb/storage/table/validity_column_data.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/validity_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/column_data.hpp"
-
-namespace duckdb {
-
-//! Validity column data represents the validity data (i.e. which values are null)
-class ValidityColumnData : public ColumnData {
-	friend class StandardColumnData;
-
-public:
-	ValidityColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                   ColumnData &parent);
-
-public:
-	FilterPropagateResult CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-	void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) override;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table_io_manager.hpp b/src/duckdb/src/include/duckdb/storage/table_io_manager.hpp
deleted file mode 100644
index babe17274..000000000
--- a/src/duckdb/src/include/duckdb/storage/table_io_manager.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table_io_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-class BlockManager;
-class DataTable;
-class MetadataManager;
-
-class TableIOManager {
-public:
-	virtual ~TableIOManager() {
-	}
-
-	//! Obtains a reference to the TableIOManager of a specific table
-	static TableIOManager &Get(DataTable &table);
-
-	//! The block manager used for managing index data
-	virtual BlockManager &GetIndexBlockManager() = 0;
-
-	//! The block manager used for storing row group data
-	virtual BlockManager &GetBlockManagerForRowData() = 0;
-
-	virtual MetadataManager &GetMetadataManager() = 0;
-
-	//! Returns the target row group size for the table
-	virtual idx_t GetRowGroupSize() const = 0;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/table_storage_info.hpp b/src/duckdb/src/include/duckdb/storage/table_storage_info.hpp
deleted file mode 100644
index 493dd320a..000000000
--- a/src/duckdb/src/include/duckdb/storage/table_storage_info.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table_storage_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/index_storage_info.hpp"
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-//! Column segment information
-struct ColumnSegmentInfo {
-	idx_t row_group_index;
-	idx_t column_id;
-	string column_path;
-	idx_t segment_idx;
-	string segment_type;
-	idx_t segment_start;
-	idx_t segment_count;
-	string compression_type;
-	string segment_stats;
-	bool has_updates;
-	bool persistent;
-	block_id_t block_id;
-	vector<block_id_t> additional_blocks;
-	idx_t block_offset;
-	string segment_info;
-};
-
-//! Table storage information
-class TableStorageInfo {
-public:
-	//! The (estimated) cardinality of the table
-	optional_idx cardinality;
-	//! Info of the indexes of a table
-	vector<IndexInfo> index_info;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/temporary_file_manager.hpp b/src/duckdb/src/include/duckdb/storage/temporary_file_manager.hpp
deleted file mode 100644
index 780b113ee..000000000
--- a/src/duckdb/src/include/duckdb/storage/temporary_file_manager.hpp
+++ /dev/null
@@ -1,352 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/temporary_file_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/array.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/enum_class_hash.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-class TemporaryFileManager;
-
-//===--------------------------------------------------------------------===//
-// TemporaryBufferSize
-//===--------------------------------------------------------------------===//
-static constexpr uint64_t TEMPORARY_BUFFER_SIZE_GRANULARITY = 32ULL * 1024ULL;
-
-enum class TemporaryBufferSize : uint64_t {
-	INVALID = 0,
-	S32K = 32768,
-	S64K = 65536,
-	S96K = 98304,
-	S128K = 131072,
-	S160K = 163840,
-	S192K = 196608,
-	S224K = 229376,
-	DEFAULT = DEFAULT_BLOCK_ALLOC_SIZE,
-};
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileIdentifier/TemporaryFileIndex
-//===--------------------------------------------------------------------===//
-struct TemporaryFileIdentifier {
-public:
-	TemporaryFileIdentifier();
-	TemporaryFileIdentifier(TemporaryBufferSize size, idx_t file_index);
-
-public:
-	//! Whether this temporary file identifier is valid (fields have been set)
-	bool IsValid() const;
-
-public:
-	//! The size of the buffers within the temp file
-	TemporaryBufferSize size;
-	//! The index of the temp file
-	optional_idx file_index;
-};
-
-struct TemporaryFileIndex {
-public:
-	TemporaryFileIndex();
-	TemporaryFileIndex(TemporaryFileIdentifier identifier, idx_t block_index);
-
-public:
-	//! Whether this temporary file index is valid (fields have been set)
-	bool IsValid() const;
-
-public:
-	//! The identifier for the temporary file
-	TemporaryFileIdentifier identifier;
-	//! The block index within the temporary file
-	optional_idx block_index;
-};
-
-//===--------------------------------------------------------------------===//
-// BlockIndexManager
-//===--------------------------------------------------------------------===//
-struct BlockIndexManager {
-public:
-	BlockIndexManager();
-	explicit BlockIndexManager(TemporaryFileManager &manager);
-
-public:
-	//! Obtains a new block index from the index manager
-	idx_t GetNewBlockIndex(TemporaryBufferSize size);
-	//! Removes an index from the block manager (returns true if the max_index has been altered)
-	bool RemoveIndex(idx_t index, TemporaryBufferSize size);
-	//! Get the maximum block index
-	idx_t GetMaxIndex() const;
-	//! Whether there are free blocks available within the file
-	bool HasFreeBlocks() const;
-
-private:
-	//! Get/set max block index
-	idx_t GetNewBlockIndexInternal(TemporaryBufferSize size);
-	void SetMaxIndex(idx_t new_index, TemporaryBufferSize size);
-
-private:
-	//! The maximum block index
-	idx_t max_index;
-	//! Free indexes within the file
-	set<idx_t> free_indexes;
-	//! Used indexes within the file
-	set<idx_t> indexes_in_use;
-	//! The TemporaryFileManager that "owns" this BlockIndexManager
-	optional_ptr<TemporaryFileManager> manager;
-};
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileHandle
-//===--------------------------------------------------------------------===//
-class TemporaryFileHandle {
-	constexpr static idx_t MAX_ALLOWED_INDEX_BASE = 4000;
-
-public:
-	TemporaryFileHandle(TemporaryFileManager &manager, TemporaryFileIdentifier identifier, idx_t temp_file_count);
-
-public:
-	struct TemporaryFileLock {
-	public:
-		explicit TemporaryFileLock(mutex &mutex);
-
-	public:
-		lock_guard<mutex> lock;
-	};
-
-public:
-	//! Try to get an index of where to write in this file. Returns an invalid index if full
-	TemporaryFileIndex TryGetBlockIndex();
-	//! Remove block index from this TemporaryFileHandle
-	void EraseBlockIndex(block_id_t block_index);
-
-	//! Read/Write temporary buffers at given positions in this file (potentially compressed)
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(idx_t block_index, unique_ptr<FileBuffer> reusable_buffer) const;
-	void WriteTemporaryBuffer(FileBuffer &buffer, idx_t block_index, AllocatedData &compressed_buffer) const;
-
-	//! Deletes the file if there are no more blocks
-	bool DeleteIfEmpty();
-	//! Get information about this temporary file
-	TemporaryFileInformation GetTemporaryFile();
-
-private:
-	//! Create temporary file if it did not exist yet
-	void CreateFileIfNotExists(TemporaryFileLock &);
-	//! Remove block index from this file
-	void RemoveTempBlockIndex(TemporaryFileLock &, idx_t index);
-	//! Get the position of a block in the file
-	idx_t GetPositionInFile(idx_t index) const;
-
-private:
-	//! Reference to the DB instance
-	DatabaseInstance &db;
-	//! The identifier (size/file index) of this TemporaryFileHandle
-	const TemporaryFileIdentifier identifier;
-	//! The maximum allowed index
-	const idx_t max_allowed_index;
-	//! File path/handle
-	const string path;
-	unique_ptr<FileHandle> handle;
-	//! Lock for concurrent access and block index manager
-	mutex file_lock;
-	BlockIndexManager index_manager;
-};
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileMap
-//===--------------------------------------------------------------------===//
-class TemporaryFileMap {
-private:
-	template <class T>
-	using temporary_buffer_size_map_t = unordered_map<TemporaryBufferSize, T, EnumClassHash>;
-	using temporary_file_map_t = unordered_map<idx_t, unique_ptr<TemporaryFileHandle>>;
-
-public:
-	explicit TemporaryFileMap(TemporaryFileManager &manager);
-	void Clear();
-
-public:
-	//! Gets the map for the given size
-	temporary_file_map_t &GetMapForSize(TemporaryBufferSize size);
-
-	//! Get/create/erase a TemporaryFileHandle for a size/index
-	optional_ptr<TemporaryFileHandle> GetFile(const TemporaryFileIdentifier &identifier);
-	TemporaryFileHandle &CreateFile(const TemporaryFileIdentifier &identifier);
-	void EraseFile(const TemporaryFileIdentifier &identifier);
-
-private:
-	TemporaryFileManager &manager;
-	temporary_buffer_size_map_t<temporary_file_map_t> files;
-};
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileCompressionLevel/TemporaryFileCompressionAdaptivity
-//===--------------------------------------------------------------------===//
-enum class TemporaryCompressionLevel : int {
-	ZSTD_MINUS_FIVE = -5,
-	ZSTD_MINUS_THREE = -3,
-	ZSTD_MINUS_ONE = -1,
-	UNCOMPRESSED = 0,
-	ZSTD_ONE = 1,
-	ZSTD_THREE = 3,
-	ZSTD_FIVE = 5,
-};
-
-class TemporaryFileCompressionAdaptivity {
-public:
-	TemporaryFileCompressionAdaptivity();
-
-public:
-	//! Get current time in nanoseconds to measure write times
-	static int64_t GetCurrentTimeNanos();
-	//! Get the compression level to use based on current write times
-	TemporaryCompressionLevel GetCompressionLevel();
-	//! Update write time for given compression level
-	void Update(TemporaryCompressionLevel level, int64_t time_before_ns);
-
-private:
-	//! Convert from level to index into write time array and back
-	static TemporaryCompressionLevel IndexToLevel(idx_t index);
-	static idx_t LevelToIndex(TemporaryCompressionLevel level);
-	//! Min/max compression levels
-	static TemporaryCompressionLevel MinimumCompressionLevel();
-	static TemporaryCompressionLevel MaximumCompressionLevel();
-
-private:
-	//! The value to initialize the atomic write counters to
-	static constexpr int64_t INITIAL_NS = 50000;
-	//! How many compression levels we adapt between
-	static constexpr idx_t LEVELS = 6;
-	//! Bias towards compressed writes: we only choose uncompressed if it is more than 2x faster than compressed
-	static constexpr double DURATION_RATIO_THRESHOLD = 2.0;
-	//! Probability to deviate from the current best write behavior (1 in 20)
-	static constexpr double COMPRESSION_DEVIATION = 0.5;
-	//! Weight to use for moving weighted average
-	static constexpr int64_t WEIGHT = 16;
-
-	//! Random engine to (sometimes) randomize compression
-	RandomEngine random_engine;
-	//! Duration of the last uncompressed write
-	int64_t last_uncompressed_write_ns;
-	//! Duration of the last compressed writes
-	int64_t last_compressed_writes_ns[LEVELS];
-};
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileManager
-//===--------------------------------------------------------------------===//
-class TemporaryFileManager {
-	friend struct BlockIndexManager;
-	friend class TemporaryFileHandle;
-
-public:
-	TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p);
-	~TemporaryFileManager();
-
-private:
-	struct CompressionResult {
-		TemporaryBufferSize size;
-		TemporaryCompressionLevel level;
-	};
-
-public:
-	struct TemporaryFileManagerLock {
-	public:
-		explicit TemporaryFileManagerLock(mutex &mutex);
-
-	public:
-		lock_guard<mutex> lock;
-	};
-
-	//! Create/Read/Update/Delete operations for temporary buffers
-	void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer);
-	bool HasTemporaryBuffer(block_id_t block_id);
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> reusable_buffer);
-	void DeleteTemporaryBuffer(block_id_t id);
-
-	//! Get the list of temporary files and their sizes
-	vector<TemporaryFileInformation> GetTemporaryFiles();
-
-	//! Get/set maximum swap space
-	optional_idx GetMaxSwapSpace() const;
-	void SetMaxSwapSpace(optional_idx limit);
-
-	//! Get temporary file size
-	idx_t GetTotalUsedSpaceInBytes() const;
-	//! Register temporary file size growth
-	void IncreaseSizeOnDisk(idx_t amount);
-	//! Register temporary file size decrease
-	void DecreaseSizeOnDisk(idx_t amount);
-
-private:
-	//! Compress buffer, write it in compressed_buffer and return the size/level
-	CompressionResult CompressBuffer(TemporaryFileCompressionAdaptivity &compression_adaptivity, FileBuffer &buffer,
-	                                 AllocatedData &compressed_buffer);
-
-	//! Create file name for given size/index
-	string CreateTemporaryFileName(const TemporaryFileIdentifier &identifier) const;
-
-	//! Get/erase a temporary block
-	TemporaryFileIndex GetTempBlockIndex(TemporaryFileManagerLock &, block_id_t id);
-	void EraseUsedBlock(TemporaryFileManagerLock &lock, block_id_t id, TemporaryFileHandle &handle,
-	                    TemporaryFileIndex index);
-
-	//! Get/erase a temporary file handle
-	optional_ptr<TemporaryFileHandle> GetFileHandle(TemporaryFileManagerLock &,
-	                                                const TemporaryFileIdentifier &identifier);
-	void EraseFileHandle(TemporaryFileManagerLock &, const TemporaryFileIdentifier &identifier);
-
-private:
-	//! Reference to the DB instance
-	DatabaseInstance &db;
-	//! The temporary directory
-	string temp_directory;
-	//! Lock for parallel access
-	mutex manager_lock;
-	//! The set of active temporary file handles
-	TemporaryFileMap files;
-	//! Map of block_id -> temporary file position
-	unordered_map<block_id_t, TemporaryFileIndex> used_blocks;
-	//! Map of TemporaryBufferSize -> manager of in-use temporary file indexes
-	unordered_map<TemporaryBufferSize, BlockIndexManager, EnumClassHash> index_managers;
-	//! The size in bytes of the temporary files that are currently alive
-	atomic<idx_t> size_on_disk;
-	//! The max amount of disk space that can be used
-	idx_t max_swap_space;
-	//! How many compression adaptivities we have so that threads don't all share the same one
-	static constexpr idx_t COMPRESSION_ADAPTIVITIES = 64;
-	//! Class that oversees when/how much to compress
-	array<TemporaryFileCompressionAdaptivity, COMPRESSION_ADAPTIVITIES> compression_adaptivities;
-};
-
-//===--------------------------------------------------------------------===//
-// TemporaryDirectoryHandle
-//===--------------------------------------------------------------------===//
-class TemporaryDirectoryHandle {
-public:
-	TemporaryDirectoryHandle(DatabaseInstance &db, string path_p, optional_idx max_swap_space);
-	~TemporaryDirectoryHandle();
-
-public:
-	TemporaryFileManager &GetTempFile() const;
-
-private:
-	DatabaseInstance &db;
-	string temp_directory;
-	bool created_directory = false;
-	unique_ptr<TemporaryFileManager> temp_file;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/temporary_memory_manager.hpp b/src/duckdb/src/include/duckdb/storage/temporary_memory_manager.hpp
deleted file mode 100644
index c0e0829d4..000000000
--- a/src/duckdb/src/include/duckdb/storage/temporary_memory_manager.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/temporary_memory_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class TemporaryMemoryManager;
-
-//! State of the temporary memory to be managed concurrently with other states
-//! As long as this is within scope, it is active
-class TemporaryMemoryState {
-	friend class TemporaryMemoryManager;
-
-private:
-	TemporaryMemoryState(TemporaryMemoryManager &temporary_memory_manager, idx_t minimum_reservation);
-
-public:
-	~TemporaryMemoryState();
-
-public:
-	//! Set the remaining size needed for this state (NOTE: does not update the reservation!)
-	void SetRemainingSize(idx_t new_remaining_size);
-	//! Set the remaining size needed for this state and update the reservation
-	void SetRemainingSizeAndUpdateReservation(ClientContext &context, idx_t new_remaining_size);
-	//! Set the remaining size to 0 (NOTE: updates the reservation to 0 as well)
-	void SetZero();
-	//! Get the remaining size that was set for this state
-	idx_t GetRemainingSize() const;
-	//! Set the minimum reservation for this state
-	void SetMinimumReservation(idx_t new_minimum_reservation);
-	//! Get the minimum reservation for this state
-	idx_t GetMinimumReservation() const;
-	//! Updates the reservation based on current remaining size
-	void UpdateReservation(ClientContext &context);
-	//! Get the reservation of this state
-	idx_t GetReservation() const;
-	//! Set the materialization penalty for this state
-	void SetMaterializationPenalty(idx_t new_materialization_penalty);
-	//! Get the materialization penalty for this state
-	idx_t GetMaterializationPenalty() const;
-
-private:
-	//! The TemporaryMemoryManager that owns this state
-	TemporaryMemoryManager &temporary_memory_manager;
-
-	//! The remaining size needed if it could fit fully in memory
-	atomic<idx_t> remaining_size;
-	//! The minimum reservation for this state
-	atomic<idx_t> minimum_reservation;
-	//! How much memory this operator has reserved
-	atomic<idx_t> reservation;
-	//! The weight used for determining the reservation for this state
-	atomic<idx_t> materialization_penalty;
-};
-
-//! TemporaryMemoryManager is a one-of class owned by the buffer pool that tries to dynamically assign memory
-//! to concurrent states, such that their combined memory usage does not exceed the limit
-class TemporaryMemoryManager {
-	//! TemporaryMemoryState is a friend class so it can access the private methods of this class,
-	//! but it should not access the private fields!
-	friend class TemporaryMemoryState;
-
-public:
-	TemporaryMemoryManager();
-
-private:
-	//! TemporaryMemoryState is initialized with a minimum reservation guarantee, which is the minimum of
-	//! MINIMUM_RESERVATION_PER_STATE_PER_THREAD and MINIMUM_RESERVATION_MEMORY_LIMIT_DIVISOR.
-
-	//! 512 blocks per state per thread, which is 0.125GB per thread for DEFAULT_BLOCK_ALLOC_SIZE.
-	static constexpr idx_t MINIMUM_RESERVATION_PER_STATE_PER_THREAD = 512ULL * DEFAULT_BLOCK_ALLOC_SIZE;
-	//! 1/16th of the available main memory.
-	static constexpr idx_t MINIMUM_RESERVATION_MEMORY_LIMIT_DIVISOR = 16ULL;
-
-	//! The maximum ratio of the memory limit that we reserve using the TemporaryMemoryManager
-	static constexpr double MAXIMUM_MEMORY_LIMIT_RATIO = 0.8;
-	//! The maximum ratio of the remaining memory that we reserve per TemporaryMemoryState
-	static constexpr double MAXIMUM_FREE_MEMORY_RATIO = 2.0 / 3.0;
-
-public:
-	//! Get the TemporaryMemoryManager
-	static TemporaryMemoryManager &Get(ClientContext &context);
-	//! Register a TemporaryMemoryState
-	unique_ptr<TemporaryMemoryState> Register(ClientContext &context);
-
-private:
-	//! Locks the TemporaryMemoryManager
-	unique_lock<mutex> Lock();
-	//! Unregister a TemporaryMemoryState (called by the destructor of TemporaryMemoryState)
-	void Unregister(TemporaryMemoryState &temporary_memory_state);
-	//! Update memory_limit, has_temporary_directory, and num_threads (must hold the lock)
-	void UpdateConfiguration(ClientContext &context);
-	//! Update the TemporaryMemoryState to the new remaining size, and updates the reservation (must hold the lock)
-	void UpdateState(ClientContext &context, TemporaryMemoryState &temporary_memory_state);
-	//! Set the remaining size of a TemporaryMemoryState (must hold the lock)
-	void SetRemainingSize(TemporaryMemoryState &temporary_memory_state, idx_t new_remaining_size);
-	//! Set the reservation of a TemporaryMemoryState (must hold the lock)
-	void SetReservation(TemporaryMemoryState &temporary_memory_state, idx_t new_reservation);
-	//! Computes optimal reservation of a TemporaryMemoryState based on a cost function
-	idx_t ComputeReservation(const TemporaryMemoryState &temporary_memory_state) const;
-	//! Verify internal counts (must hold the lock)
-	void Verify() const;
-
-private:
-	//! Lock because TemporaryMemoryManager is used concurrently
-	mutex lock;
-
-	//! Memory limit of the buffer pool
-	idx_t memory_limit = DConstants::INVALID_INDEX;
-	//! Whether there is a temporary directory that we can offload blocks to
-	bool has_temporary_directory = false;
-	//! Number of threads
-	idx_t num_threads = DConstants::INVALID_INDEX;
-	//! Max memory per query
-	idx_t query_max_memory = DConstants::INVALID_INDEX;
-
-	//! Currently active states
-	reference_set_t<TemporaryMemoryState> active_states;
-	//! The sum of reservations of all active states
-	idx_t reservation;
-	//! The sum of the remaining size of all active states
-	idx_t remaining_size;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp b/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp
deleted file mode 100644
index 8b2acc112..000000000
--- a/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/write_ahead_log.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/common/enums/wal_type.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-struct AlterInfo;
-
-class AttachedDatabase;
-class Catalog;
-class DatabaseInstance;
-class SchemaCatalogEntry;
-class SequenceCatalogEntry;
-class ScalarMacroCatalogEntry;
-class ViewCatalogEntry;
-class TypeCatalogEntry;
-class TableCatalogEntry;
-class Transaction;
-class TransactionManager;
-class WriteAheadLogDeserializer;
-struct PersistentCollectionData;
-
-enum class WALInitState { NO_WAL, UNINITIALIZED, UNINITIALIZED_REQUIRES_TRUNCATE, INITIALIZED };
-
-//! The WriteAheadLog (WAL) is a log that is used to provide durability. Prior
-//! to committing a transaction it writes the changes the transaction made to
-//! the database to the log, which can then be replayed upon startup in case the
-//! server crashes or is shut down.
-class WriteAheadLog {
-public:
-	//! Initialize the WAL in the specified directory
-	explicit WriteAheadLog(AttachedDatabase &database, const string &wal_path, idx_t wal_size = 0ULL,
-	                       WALInitState state = WALInitState::NO_WAL);
-	virtual ~WriteAheadLog();
-
-public:
-	//! Replay and initialize the WAL
-	static unique_ptr<WriteAheadLog> Replay(FileSystem &fs, AttachedDatabase &database, const string &wal_path);
-
-	//! Gets the total bytes written to the WAL since startup
-	idx_t GetWALSize() const;
-	//! Gets the total bytes written to the WAL since startup
-	idx_t GetTotalWritten() const;
-
-	//! A WAL is initialized, if a writer to a file exists.
-	bool Initialized() const;
-	//! Initializes the file of the WAL by creating the file writer.
-	BufferedFileWriter &Initialize();
-
-	void WriteVersion();
-
-	virtual void WriteCreateTable(const TableCatalogEntry &entry);
-	void WriteDropTable(const TableCatalogEntry &entry);
-
-	void WriteCreateSchema(const SchemaCatalogEntry &entry);
-	void WriteDropSchema(const SchemaCatalogEntry &entry);
-
-	void WriteCreateView(const ViewCatalogEntry &entry);
-	void WriteDropView(const ViewCatalogEntry &entry);
-
-	void WriteCreateSequence(const SequenceCatalogEntry &entry);
-	void WriteDropSequence(const SequenceCatalogEntry &entry);
-	void WriteSequenceValue(SequenceValue val);
-
-	void WriteCreateMacro(const ScalarMacroCatalogEntry &entry);
-	void WriteDropMacro(const ScalarMacroCatalogEntry &entry);
-
-	void WriteCreateTableMacro(const TableMacroCatalogEntry &entry);
-	void WriteDropTableMacro(const TableMacroCatalogEntry &entry);
-
-	void WriteCreateIndex(const IndexCatalogEntry &entry);
-	void WriteDropIndex(const IndexCatalogEntry &entry);
-
-	void WriteCreateType(const TypeCatalogEntry &entry);
-	void WriteDropType(const TypeCatalogEntry &entry);
-	//! Sets the table used for subsequent insert/delete/update commands
-	void WriteSetTable(const string &schema, const string &table);
-
-	void WriteAlter(CatalogEntry &entry, const AlterInfo &info);
-
-	void WriteInsert(DataChunk &chunk);
-	void WriteRowGroupData(const PersistentCollectionData &data);
-	void WriteDelete(DataChunk &chunk);
-	//! Write a single (sub-) column update to the WAL. Chunk must be a pair of (COL, ROW_ID).
-	//! The column_path vector is a *path* towards a column within the table
-	//! i.e. if we have a table with a single column S STRUCT(A INT, B INT)
-	//! and we update the validity mask of "S.B"
-	//! the column path is:
-	//! 0 (first column of table)
-	//! -> 1 (second subcolumn of struct)
-	//! -> 0 (first subcolumn of INT)
-	void WriteUpdate(DataChunk &chunk, const vector<column_t> &column_path);
-
-	//! Truncate the WAL to a previous size, and clear anything currently set in the writer
-	void Truncate(idx_t size);
-	//! Delete the WAL file on disk. The WAL should not be used after this point.
-	void Delete();
-	void Flush();
-
-	void WriteCheckpoint(MetaBlockPointer meta_block);
-
-protected:
-	static unique_ptr<WriteAheadLog> ReplayInternal(AttachedDatabase &database, unique_ptr<FileHandle> handle);
-
-protected:
-	AttachedDatabase &database;
-	mutex wal_lock;
-	unique_ptr<BufferedFileWriter> writer;
-	string wal_path;
-	atomic<idx_t> wal_size;
-	atomic<WALInitState> init_state;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/append_info.hpp b/src/duckdb/src/include/duckdb/transaction/append_info.hpp
deleted file mode 100644
index 8d06fe256..000000000
--- a/src/duckdb/src/include/duckdb/transaction/append_info.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/append_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-class DataTable;
-
-struct AppendInfo {
-	DataTable *table;
-	idx_t start_row;
-	idx_t count;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/cleanup_state.hpp b/src/duckdb/src/include/duckdb/transaction/cleanup_state.hpp
deleted file mode 100644
index 0de2faabd..000000000
--- a/src/duckdb/src/include/duckdb/transaction/cleanup_state.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/cleanup_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/transaction/undo_buffer.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_map.hpp"
-
-namespace duckdb {
-
-class DataTable;
-
-struct DeleteInfo;
-struct UpdateInfo;
-
-class CleanupState {
-public:
-	explicit CleanupState(transaction_t lowest_active_transaction);
-	~CleanupState();
-
-	// all tables with indexes that possibly need a vacuum (after e.g. a delete)
-	unordered_map<string, optional_ptr<DataTable>> indexed_tables;
-
-public:
-	void CleanupEntry(UndoFlags type, data_ptr_t data);
-
-private:
-	//! Lowest active transaction
-	transaction_t lowest_active_transaction;
-	// data for index cleanup
-	optional_ptr<DataTable> current_table;
-	DataChunk chunk;
-	row_t row_numbers[STANDARD_VECTOR_SIZE];
-	idx_t count;
-
-private:
-	void CleanupDelete(DeleteInfo &info);
-	void CleanupUpdate(UpdateInfo &info);
-
-	void Flush();
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/commit_state.hpp b/src/duckdb/src/include/duckdb/transaction/commit_state.hpp
deleted file mode 100644
index 382de7296..000000000
--- a/src/duckdb/src/include/duckdb/transaction/commit_state.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/commit_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/transaction/undo_buffer.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-class DataChunk;
-class DuckTransaction;
-class WriteAheadLog;
-class ClientContext;
-
-struct DataTableInfo;
-struct DeleteInfo;
-struct UpdateInfo;
-
-class CommitState {
-public:
-	explicit CommitState(DuckTransaction &transaction, transaction_t commit_id);
-
-public:
-	void CommitEntry(UndoFlags type, data_ptr_t data);
-	void RevertCommit(UndoFlags type, data_ptr_t data);
-
-private:
-	void CommitEntryDrop(CatalogEntry &entry, data_ptr_t extra_data);
-
-private:
-	DuckTransaction &transaction;
-	transaction_t commit_id;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/delete_info.hpp b/src/duckdb/src/include/duckdb/transaction/delete_info.hpp
deleted file mode 100644
index 99b02320c..000000000
--- a/src/duckdb/src/include/duckdb/transaction/delete_info.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/delete_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-class DataTable;
-class RowVersionManager;
-
-struct DeleteInfo {
-	DataTable *table;
-	RowVersionManager *version_info;
-	idx_t vector_idx;
-	idx_t count;
-	idx_t base_row;
-	//! Whether or not row ids are consecutive (0, 1, 2, ..., count).
-	//! If this is true no rows are stored and `rows` should not be accessed.
-	bool is_consecutive;
-
-	uint16_t *GetRows() {
-		if (is_consecutive) {
-			throw InternalException("DeleteInfo is consecutive - rows are not accessible");
-		}
-		return rows;
-	}
-	const uint16_t *GetRows() const {
-		if (is_consecutive) {
-			throw InternalException("DeleteInfo is consecutive - rows are not accessible");
-		}
-		return rows;
-	}
-
-private:
-	//! The per-vector row identifiers (actual row id is base_row + rows[x])
-	uint16_t rows[1];
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/duck_transaction.hpp b/src/duckdb/src/include/duckdb/transaction/duck_transaction.hpp
deleted file mode 100644
index e17c048be..000000000
--- a/src/duckdb/src/include/duckdb/transaction/duck_transaction.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/duck_transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/transaction/undo_buffer.hpp"
-
-namespace duckdb {
-class CheckpointLock;
-class RowGroupCollection;
-class RowVersionManager;
-class DuckTransactionManager;
-class StorageLockKey;
-class StorageCommitState;
-struct DataTableInfo;
-struct UndoBufferProperties;
-
-class DuckTransaction : public Transaction {
-public:
-	DuckTransaction(DuckTransactionManager &manager, ClientContext &context, transaction_t start_time,
-	                transaction_t transaction_id, idx_t catalog_version);
-	~DuckTransaction() override;
-
-	//! The start timestamp of this transaction
-	transaction_t start_time;
-	//! The transaction id of this transaction
-	transaction_t transaction_id;
-	//! The commit id of this transaction, if it has successfully been committed
-	transaction_t commit_id;
-	//! Highest active query when the transaction finished, used for cleaning up
-	transaction_t highest_active_query;
-
-	atomic<idx_t> catalog_version;
-
-public:
-	static DuckTransaction &Get(ClientContext &context, AttachedDatabase &db);
-	static DuckTransaction &Get(ClientContext &context, Catalog &catalog);
-	LocalStorage &GetLocalStorage();
-
-	void PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data, idx_t extra_data_size);
-
-	void SetReadWrite() override;
-
-	bool ShouldWriteToWAL(AttachedDatabase &db);
-	ErrorData WriteToWAL(AttachedDatabase &db, unique_ptr<StorageCommitState> &commit_state) noexcept;
-	//! Commit the current transaction with the given commit identifier. Returns an error message if the transaction
-	//! commit failed, or an empty string if the commit was sucessful
-	ErrorData Commit(AttachedDatabase &db, transaction_t commit_id,
-	                 unique_ptr<StorageCommitState> commit_state) noexcept;
-	//! Returns whether or not a commit of this transaction should trigger an automatic checkpoint
-	bool AutomaticCheckpoint(AttachedDatabase &db, const UndoBufferProperties &properties);
-
-	//! Rollback
-	ErrorData Rollback();
-	//! Cleanup the undo buffer
-	void Cleanup(transaction_t lowest_active_transaction);
-
-	bool ChangesMade();
-	UndoBufferProperties GetUndoProperties();
-
-	void PushDelete(DataTable &table, RowVersionManager &info, idx_t vector_idx, row_t rows[], idx_t count,
-	                idx_t base_row);
-	void PushSequenceUsage(SequenceCatalogEntry &entry, const SequenceData &data);
-	void PushAppend(DataTable &table, idx_t row_start, idx_t row_count);
-	UndoBufferReference CreateUpdateInfo(idx_t type_size, idx_t entries);
-
-	bool IsDuckTransaction() const override {
-		return true;
-	}
-
-	unique_ptr<StorageLockKey> TryGetCheckpointLock();
-	bool HasWriteLock() const {
-		return write_lock.get();
-	}
-
-	void UpdateCollection(shared_ptr<RowGroupCollection> &collection);
-
-	//! Get a shared lock on a table
-	shared_ptr<CheckpointLock> SharedLockTable(DataTableInfo &info);
-
-private:
-	DuckTransactionManager &transaction_manager;
-	//! The undo buffer is used to store old versions of rows that are updated
-	//! or deleted
-	UndoBuffer undo_buffer;
-	//! The set of uncommitted appends for the transaction
-	unique_ptr<LocalStorage> storage;
-	//! Write lock
-	unique_ptr<StorageLockKey> write_lock;
-	//! Lock for accessing sequence_usage
-	mutex sequence_lock;
-	//! Map of all sequences that were used during the transaction and the value they had in this transaction
-	reference_map_t<SequenceCatalogEntry, reference<SequenceValue>> sequence_usage;
-	//! Collections that are updated by this transaction
-	reference_map_t<RowGroupCollection, shared_ptr<RowGroupCollection>> updated_collections;
-	//! Lock for the active_locks map
-	mutex active_locks_lock;
-	struct ActiveTableLock {
-		mutex checkpoint_lock_mutex; // protects access to the checkpoint_lock field in this class
-		weak_ptr<CheckpointLock> checkpoint_lock;
-	};
-	//! Active locks on tables
-	reference_map_t<DataTableInfo, unique_ptr<ActiveTableLock>> active_locks;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/duck_transaction_manager.hpp b/src/duckdb/src/include/duckdb/transaction/duck_transaction_manager.hpp
deleted file mode 100644
index deaaf0b4d..000000000
--- a/src/duckdb/src/include/duckdb/transaction/duck_transaction_manager.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/duck_transaction_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/common/enums/checkpoint_type.hpp"
-
-namespace duckdb {
-class DuckTransaction;
-struct UndoBufferProperties;
-
-//! The Transaction Manager is responsible for creating and managing
-//! transactions
-class DuckTransactionManager : public TransactionManager {
-public:
-	explicit DuckTransactionManager(AttachedDatabase &db);
-	~DuckTransactionManager() override;
-
-public:
-	static DuckTransactionManager &Get(AttachedDatabase &db);
-
-	//! Start a new transaction
-	Transaction &StartTransaction(ClientContext &context) override;
-	//! Commit the given transaction
-	ErrorData CommitTransaction(ClientContext &context, Transaction &transaction) override;
-	//! Rollback the given transaction
-	void RollbackTransaction(Transaction &transaction) override;
-
-	void Checkpoint(ClientContext &context, bool force = false) override;
-
-	transaction_t LowestActiveId() const {
-		return lowest_active_id;
-	}
-	transaction_t LowestActiveStart() const {
-		return lowest_active_start;
-	}
-	transaction_t GetLastCommit() const {
-		return last_commit;
-	}
-
-	bool IsDuckTransactionManager() override {
-		return true;
-	}
-
-	//! Obtains a shared lock to the checkpoint lock
-	unique_ptr<StorageLockKey> SharedCheckpointLock();
-	unique_ptr<StorageLockKey> TryUpgradeCheckpointLock(StorageLockKey &lock);
-
-	//! Returns the current version of the catalog (incremented whenever anything changes, not stored between restarts)
-	DUCKDB_API idx_t GetCatalogVersion(Transaction &transaction);
-
-	void PushCatalogEntry(Transaction &transaction_p, CatalogEntry &entry, data_ptr_t extra_data = nullptr,
-	                      idx_t extra_data_size = 0);
-
-protected:
-	struct CheckpointDecision {
-		explicit CheckpointDecision(string reason_p);
-		explicit CheckpointDecision(CheckpointType type);
-		~CheckpointDecision();
-
-		bool can_checkpoint;
-		string reason;
-		CheckpointType type;
-	};
-
-private:
-	//! Generates a new commit timestamp
-	transaction_t GetCommitTimestamp();
-	//! Remove the given transaction from the list of active transactions
-	void RemoveTransaction(DuckTransaction &transaction) noexcept;
-	//! Remove the given transaction from the list of active transactions
-	void RemoveTransaction(DuckTransaction &transaction, bool store_transaction) noexcept;
-
-	//! Whether or not we can checkpoint
-	CheckpointDecision CanCheckpoint(DuckTransaction &transaction, unique_ptr<StorageLockKey> &checkpoint_lock,
-	                                 const UndoBufferProperties &properties);
-
-private:
-	//! The current start timestamp used by transactions
-	transaction_t current_start_timestamp;
-	//! The current transaction ID used by transactions
-	transaction_t current_transaction_id;
-	//! The lowest active transaction id
-	atomic<transaction_t> lowest_active_id;
-	//! The lowest active transaction timestamp
-	atomic<transaction_t> lowest_active_start;
-	//! The last commit timestamp
-	atomic<transaction_t> last_commit;
-	//! Set of currently running transactions
-	vector<unique_ptr<DuckTransaction>> active_transactions;
-	//! Set of recently committed transactions
-	vector<unique_ptr<DuckTransaction>> recently_committed_transactions;
-	//! Transactions awaiting GC
-	vector<unique_ptr<DuckTransaction>> old_transactions;
-	//! The lock used for transaction operations
-	mutex transaction_lock;
-	//! The checkpoint lock
-	StorageLock checkpoint_lock;
-	//! Lock necessary to start transactions only - used by FORCE CHECKPOINT to prevent new transactions from starting
-	mutex start_transaction_lock;
-	//! Mutex used to control writes to the WAL - separate from the transaction lock
-	mutex wal_lock;
-
-	atomic<idx_t> last_uncommitted_catalog_version = {TRANSACTION_ID_START};
-	idx_t last_committed_version = 0;
-
-protected:
-	virtual void OnCommitCheckpointDecision(const CheckpointDecision &decision, DuckTransaction &transaction) {
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/local_storage.hpp b/src/duckdb/src/include/duckdb/transaction/local_storage.hpp
deleted file mode 100644
index 453a7ce44..000000000
--- a/src/duckdb/src/include/duckdb/transaction/local_storage.hpp
+++ /dev/null
@@ -1,176 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/local_storage.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/table/row_group_collection.hpp"
-#include "duckdb/storage/table/table_index_list.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/storage/optimistic_data_writer.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/reference_map.hpp"
-
-namespace duckdb {
-class AttachedDatabase;
-class Catalog;
-class DataTable;
-class StorageCommitState;
-class Transaction;
-class WriteAheadLog;
-struct LocalAppendState;
-struct TableAppendState;
-
-class LocalTableStorage : public enable_shared_from_this<LocalTableStorage> {
-public:
-	// Create a new LocalTableStorage
-	explicit LocalTableStorage(ClientContext &context, DataTable &table);
-	// Create a LocalTableStorage from an ALTER TYPE
-	LocalTableStorage(ClientContext &context, DataTable &table, LocalTableStorage &parent, idx_t changed_idx,
-	                  const LogicalType &target_type, const vector<StorageIndex> &bound_columns, Expression &cast_expr);
-	// Create a LocalTableStorage from a DROP COLUMN
-	LocalTableStorage(DataTable &table, LocalTableStorage &parent, idx_t drop_idx);
-	// Create a LocalTableStorage from an ADD COLUMN
-	LocalTableStorage(ClientContext &context, DataTable &table, LocalTableStorage &parent, ColumnDefinition &new_column,
-	                  ExpressionExecutor &default_executor);
-	~LocalTableStorage();
-
-	reference<DataTable> table_ref;
-
-	Allocator &allocator;
-	//! The main chunk collection holding the data
-	shared_ptr<RowGroupCollection> row_groups;
-	//! The set of unique append indexes.
-	TableIndexList append_indexes;
-	//! The set of delete indexes.
-	TableIndexList delete_indexes;
-	//! The number of deleted rows
-	idx_t deleted_rows;
-	//! The main optimistic data writer
-	OptimisticDataWriter optimistic_writer;
-	//! The set of all optimistic data writers associated with this table
-	vector<unique_ptr<OptimisticDataWriter>> optimistic_writers;
-	//! Whether or not storage was merged
-	bool merged_storage = false;
-	//! Whether or not the storage was dropped
-	bool is_dropped = false;
-
-public:
-	void InitializeScan(CollectionScanState &state, optional_ptr<TableFilterSet> table_filters = nullptr);
-	//! Write a new row group to disk (if possible)
-	void WriteNewRowGroup();
-	void FlushBlocks();
-	void Rollback();
-	idx_t EstimatedSize();
-
-	void AppendToIndexes(DuckTransaction &transaction, TableAppendState &append_state, bool append_to_table);
-	ErrorData AppendToIndexes(DuckTransaction &transaction, RowGroupCollection &source, TableIndexList &index_list,
-	                          const vector<LogicalType> &table_types, row_t &start_row);
-	void AppendToDeleteIndexes(Vector &row_ids, DataChunk &delete_chunk);
-
-	//! Creates an optimistic writer for this table
-	OptimisticDataWriter &CreateOptimisticWriter();
-	void FinalizeOptimisticWriter(OptimisticDataWriter &writer);
-};
-
-class LocalTableManager {
-public:
-	shared_ptr<LocalTableStorage> MoveEntry(DataTable &table);
-	reference_map_t<DataTable, shared_ptr<LocalTableStorage>> MoveEntries();
-	optional_ptr<LocalTableStorage> GetStorage(DataTable &table) const;
-	LocalTableStorage &GetOrCreateStorage(ClientContext &context, DataTable &table);
-	idx_t EstimatedSize() const;
-	bool IsEmpty() const;
-	void InsertEntry(DataTable &table, shared_ptr<LocalTableStorage> entry);
-
-private:
-	mutable mutex table_storage_lock;
-	reference_map_t<DataTable, shared_ptr<LocalTableStorage>> table_storage;
-};
-
-//! The LocalStorage class holds appends that have not been committed yet
-class LocalStorage {
-public:
-	struct CommitState {
-		CommitState();
-		~CommitState();
-
-		reference_map_t<DataTable, unique_ptr<TableAppendState>> append_states;
-	};
-
-public:
-	explicit LocalStorage(ClientContext &context, DuckTransaction &transaction);
-
-	static LocalStorage &Get(DuckTransaction &transaction);
-	static LocalStorage &Get(ClientContext &context, AttachedDatabase &db);
-	static LocalStorage &Get(ClientContext &context, Catalog &catalog);
-
-	//! Initialize a scan of the local storage
-	void InitializeScan(DataTable &table, CollectionScanState &state, optional_ptr<TableFilterSet> table_filters);
-	//! Scan
-	void Scan(CollectionScanState &state, const vector<StorageIndex> &column_ids, DataChunk &result);
-
-	void InitializeParallelScan(DataTable &table, ParallelCollectionScanState &state);
-	bool NextParallelScan(ClientContext &context, DataTable &table, ParallelCollectionScanState &state,
-	                      CollectionScanState &scan_state);
-
-	//! Begin appending to the local storage
-	void InitializeAppend(LocalAppendState &state, DataTable &table);
-	//! Initialize the storage and its indexes, but no row groups.
-	void InitializeStorage(LocalAppendState &state, DataTable &table);
-	//! Append a chunk to the local storage
-	static void Append(LocalAppendState &state, DataChunk &chunk);
-	//! Finish appending to the local storage
-	static void FinalizeAppend(LocalAppendState &state);
-	//! Merge a row group collection into the transaction-local storage
-	void LocalMerge(DataTable &table, RowGroupCollection &collection);
-	//! Create an optimistic writer for the specified table
-	OptimisticDataWriter &CreateOptimisticWriter(DataTable &table);
-	void FinalizeOptimisticWriter(DataTable &table, OptimisticDataWriter &writer);
-
-	//! Delete a set of rows from the local storage
-	idx_t Delete(DataTable &table, Vector &row_ids, idx_t count);
-	//! Update a set of rows in the local storage
-	void Update(DataTable &table, Vector &row_ids, const vector<PhysicalIndex> &column_ids, DataChunk &data);
-
-	//! Commits the local storage, writing it to the WAL and completing the commit
-	void Commit(optional_ptr<StorageCommitState> commit_state);
-	//! Rollback the local storage
-	void Rollback();
-
-	bool ChangesMade() noexcept;
-	idx_t EstimatedSize();
-
-	void DropTable(DataTable &table);
-	bool Find(DataTable &table);
-
-	idx_t AddedRows(DataTable &table);
-	vector<PartitionStatistics> GetPartitionStats(DataTable &table) const;
-
-	void AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
-	               ExpressionExecutor &default_executor);
-	void DropColumn(DataTable &old_dt, DataTable &new_dt, idx_t removed_column);
-	void ChangeType(DataTable &old_dt, DataTable &new_dt, idx_t changed_idx, const LogicalType &target_type,
-	                const vector<StorageIndex> &bound_columns, Expression &cast_expr);
-
-	void MoveStorage(DataTable &old_dt, DataTable &new_dt);
-	void FetchChunk(DataTable &table, Vector &row_ids, idx_t count, const vector<StorageIndex> &col_ids,
-	                DataChunk &chunk, ColumnFetchState &fetch_state);
-	TableIndexList &GetIndexes(DataTable &table);
-	optional_ptr<LocalTableStorage> GetStorage(DataTable &table);
-
-	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
-
-private:
-	ClientContext &context;
-	DuckTransaction &transaction;
-	LocalTableManager table_manager;
-
-	void Flush(DataTable &table, LocalTableStorage &storage, optional_ptr<StorageCommitState> commit_state);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/meta_transaction.hpp b/src/duckdb/src/include/duckdb/transaction/meta_transaction.hpp
deleted file mode 100644
index d6730276b..000000000
--- a/src/duckdb/src/include/duckdb/transaction/meta_transaction.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/meta_transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/main/valid_checker.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/error_data.hpp"
-
-namespace duckdb {
-class AttachedDatabase;
-class ClientContext;
-class Transaction;
-
-//! The MetaTransaction manages multiple transactions for different attached databases
-class MetaTransaction {
-public:
-	DUCKDB_API MetaTransaction(ClientContext &context, timestamp_t start_timestamp);
-
-	ClientContext &context;
-	//! The timestamp when the transaction started
-	timestamp_t start_timestamp;
-	//! The validity checker of the transaction
-	ValidChecker transaction_validity;
-	//! The active query number
-	transaction_t active_query;
-
-public:
-	DUCKDB_API static MetaTransaction &Get(ClientContext &context);
-	timestamp_t GetCurrentTransactionStartTimestamp() const {
-		return start_timestamp;
-	}
-
-	Transaction &GetTransaction(AttachedDatabase &db);
-	optional_ptr<Transaction> TryGetTransaction(AttachedDatabase &db);
-	void RemoveTransaction(AttachedDatabase &db);
-
-	ErrorData Commit();
-	void Rollback();
-
-	idx_t GetActiveQuery();
-	void SetActiveQuery(transaction_t query_number);
-
-	void SetReadOnly();
-	bool IsReadOnly() const;
-	void ModifyDatabase(AttachedDatabase &db);
-	optional_ptr<AttachedDatabase> ModifiedDatabase() {
-		return modified_database;
-	}
-	const vector<reference<AttachedDatabase>> &OpenedTransactions() const {
-		return all_transactions;
-	}
-
-private:
-	//! Lock to prevent all_transactions and transactions from getting out of sync
-	mutex lock;
-	//! The set of active transactions for each database
-	reference_map_t<AttachedDatabase, reference<Transaction>> transactions;
-	//! The set of transactions in order of when they were started
-	vector<reference<AttachedDatabase>> all_transactions;
-	//! The database we are modifying - we can only modify one database per transaction
-	optional_ptr<AttachedDatabase> modified_database;
-	//! Whether or not the meta transaction is marked as read only
-	bool is_read_only;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/rollback_state.hpp b/src/duckdb/src/include/duckdb/transaction/rollback_state.hpp
deleted file mode 100644
index 3195c2a6a..000000000
--- a/src/duckdb/src/include/duckdb/transaction/rollback_state.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/rollback_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/transaction/undo_buffer.hpp"
-
-namespace duckdb {
-class DataChunk;
-class DataTable;
-class DuckTransaction;
-class WriteAheadLog;
-
-class RollbackState {
-public:
-	explicit RollbackState(DuckTransaction &transaction);
-
-public:
-	void RollbackEntry(UndoFlags type, data_ptr_t data);
-
-private:
-	DuckTransaction &transaction;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/transaction.hpp b/src/duckdb/src/include/duckdb/transaction/transaction.hpp
deleted file mode 100644
index db0a90eee..000000000
--- a/src/duckdb/src/include/duckdb/transaction/transaction.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/transaction/transaction_data.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/atomic.hpp"
-
-namespace duckdb {
-class SequenceCatalogEntry;
-class SchemaCatalogEntry;
-
-class AttachedDatabase;
-class ColumnData;
-class ClientContext;
-class CatalogEntry;
-class DataTable;
-class DatabaseInstance;
-class LocalStorage;
-class MetaTransaction;
-class TransactionManager;
-class WriteAheadLog;
-
-class ChunkVectorInfo;
-
-struct DeleteInfo;
-struct UpdateInfo;
-
-//! The transaction object holds information about a currently running or past
-//! transaction
-class Transaction {
-public:
-	DUCKDB_API Transaction(TransactionManager &manager, ClientContext &context);
-	DUCKDB_API virtual ~Transaction();
-
-	TransactionManager &manager;
-	weak_ptr<ClientContext> context;
-	//! The current active query for the transaction. Set to MAXIMUM_QUERY_ID if
-	//! no query is active.
-	atomic<transaction_t> active_query;
-
-public:
-	DUCKDB_API static Transaction &Get(ClientContext &context, AttachedDatabase &db);
-	DUCKDB_API static Transaction &Get(ClientContext &context, Catalog &catalog);
-	//! Returns the transaction for the given context if it has already been started
-	DUCKDB_API static optional_ptr<Transaction> TryGet(ClientContext &context, AttachedDatabase &db);
-
-	//! Whether or not the transaction has made any modifications to the database so far
-	DUCKDB_API bool IsReadOnly();
-	//! Promotes the transaction to a read-write transaction
-	DUCKDB_API virtual void SetReadWrite();
-
-	virtual bool IsDuckTransaction() const {
-		return false;
-	}
-
-public:
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-
-private:
-	bool is_read_only;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/transaction_context.hpp b/src/duckdb/src/include/duckdb/transaction/transaction_context.hpp
deleted file mode 100644
index 4c09fb7a9..000000000
--- a/src/duckdb/src/include/duckdb/transaction/transaction_context.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class MetaTransaction;
-class Transaction;
-class TransactionManager;
-
-//! The transaction context keeps track of all the information relating to the
-//! current transaction
-class TransactionContext {
-public:
-	explicit TransactionContext(ClientContext &context);
-	~TransactionContext();
-
-	MetaTransaction &ActiveTransaction() {
-		if (!current_transaction) {
-			throw InternalException("TransactionContext::ActiveTransaction called without active transaction");
-		}
-		return *current_transaction;
-	}
-
-	bool HasActiveTransaction() const {
-		return current_transaction.get();
-	}
-
-	void BeginTransaction();
-	void Commit();
-	void Rollback(optional_ptr<ErrorData>);
-	void ClearTransaction();
-
-	void SetAutoCommit(bool value);
-	bool IsAutoCommit() const {
-		return auto_commit;
-	}
-
-	void SetReadOnly();
-
-	idx_t GetActiveQuery();
-	void ResetActiveQuery();
-	void SetActiveQuery(transaction_t query_number);
-
-private:
-	ClientContext &context;
-	bool auto_commit;
-
-	unique_ptr<MetaTransaction> current_transaction;
-
-	TransactionContext(const TransactionContext &) = delete;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/transaction_data.hpp b/src/duckdb/src/include/duckdb/transaction/transaction_data.hpp
deleted file mode 100644
index e182627db..000000000
--- a/src/duckdb/src/include/duckdb/transaction/transaction_data.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-namespace duckdb {
-class DuckTransaction;
-class Transaction;
-
-struct TransactionData {
-	TransactionData(DuckTransaction &transaction_p); // NOLINT: allow implicit conversion
-	TransactionData(transaction_t transaction_id_p, transaction_t start_time_p);
-
-	optional_ptr<DuckTransaction> transaction;
-	transaction_t transaction_id;
-	transaction_t start_time;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/transaction_manager.hpp b/src/duckdb/src/include/duckdb/transaction/transaction_manager.hpp
deleted file mode 100644
index c117ab09e..000000000
--- a/src/duckdb/src/include/duckdb/transaction/transaction_manager.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/atomic.hpp"
-
-namespace duckdb {
-
-class AttachedDatabase;
-class ClientContext;
-class Catalog;
-struct ClientLockWrapper;
-class DatabaseInstance;
-class Transaction;
-
-//! The Transaction Manager is responsible for creating and managing
-//! transactions
-class TransactionManager {
-public:
-	explicit TransactionManager(AttachedDatabase &db);
-	virtual ~TransactionManager();
-
-	//! Start a new transaction
-	virtual Transaction &StartTransaction(ClientContext &context) = 0;
-	//! Commit the given transaction. Returns a non-empty error message on failure.
-	virtual ErrorData CommitTransaction(ClientContext &context, Transaction &transaction) = 0;
-	//! Rollback the given transaction
-	virtual void RollbackTransaction(Transaction &transaction) = 0;
-
-	virtual void Checkpoint(ClientContext &context, bool force = false) = 0;
-
-	static TransactionManager &Get(AttachedDatabase &db);
-
-	virtual bool IsDuckTransactionManager() {
-		return false;
-	}
-
-	AttachedDatabase &GetDB() {
-		return db;
-	}
-
-protected:
-	//! The attached database
-	AttachedDatabase &db;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp b/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp
deleted file mode 100644
index 7218bb876..000000000
--- a/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/undo_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/enums/undo_flags.hpp"
-#include "duckdb/transaction/undo_buffer_allocator.hpp"
-
-namespace duckdb {
-class BufferManager;
-class DuckTransaction;
-class StorageCommitState;
-class WriteAheadLog;
-struct UndoBufferPointer;
-
-struct UndoBufferProperties {
-	idx_t estimated_size = 0;
-	bool has_updates = false;
-	bool has_deletes = false;
-	bool has_index_deletes = false;
-	bool has_catalog_changes = false;
-	bool has_dropped_entries = false;
-};
-
-//! The undo buffer of a transaction is used to hold previous versions of tuples
-//! that might be required in the future (because of rollbacks or previous
-//! transactions accessing them)
-class UndoBuffer {
-public:
-	struct IteratorState {
-		BufferHandle handle;
-		optional_ptr<UndoBufferEntry> current;
-		data_ptr_t start;
-		data_ptr_t end;
-	};
-
-public:
-	explicit UndoBuffer(DuckTransaction &transaction, ClientContext &context);
-
-	//! Write a specified entry to the undo buffer
-	UndoBufferReference CreateEntry(UndoFlags type, idx_t len);
-
-	bool ChangesMade();
-	UndoBufferProperties GetProperties();
-
-	//! Cleanup the undo buffer
-	void Cleanup(transaction_t lowest_active_transaction);
-	//! Commit the changes made in the UndoBuffer: should be called on commit
-	void WriteToWAL(WriteAheadLog &wal, optional_ptr<StorageCommitState> commit_state);
-	//! Commit the changes made in the UndoBuffer: should be called on commit
-	void Commit(UndoBuffer::IteratorState &iterator_state, transaction_t commit_id);
-	//! Revert committed changes made in the UndoBuffer up until the currently committed state
-	void RevertCommit(UndoBuffer::IteratorState &iterator_state, transaction_t transaction_id);
-	//! Rollback the changes made in this UndoBuffer: should be called on
-	//! rollback
-	void Rollback();
-
-private:
-	DuckTransaction &transaction;
-	UndoBufferAllocator allocator;
-
-private:
-	template <class T>
-	void IterateEntries(UndoBuffer::IteratorState &state, T &&callback);
-	template <class T>
-	void IterateEntries(UndoBuffer::IteratorState &state, UndoBuffer::IteratorState &end_state, T &&callback);
-	template <class T>
-	void ReverseIterateEntries(T &&callback);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/undo_buffer_allocator.hpp b/src/duckdb/src/include/duckdb/transaction/undo_buffer_allocator.hpp
deleted file mode 100644
index a318fe8ff..000000000
--- a/src/duckdb/src/include/duckdb/transaction/undo_buffer_allocator.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/undo_buffer_allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-class BufferManager;
-class BlockHandle;
-struct UndoBufferEntry;
-struct UndoBufferPointer;
-
-struct UndoBufferEntry {
-	explicit UndoBufferEntry(BufferManager &buffer_manager) : buffer_manager(buffer_manager) {
-	}
-	~UndoBufferEntry();
-
-	BufferManager &buffer_manager;
-	shared_ptr<BlockHandle> block;
-	idx_t position = 0;
-	idx_t capacity = 0;
-	unique_ptr<UndoBufferEntry> next;
-	optional_ptr<UndoBufferEntry> prev;
-};
-
-struct UndoBufferReference {
-	UndoBufferReference() : entry(nullptr), position(0) {
-	}
-	UndoBufferReference(UndoBufferEntry &entry_p, BufferHandle handle_p, idx_t position)
-	    : entry(&entry_p), handle(std::move(handle_p)), position(position) {
-	}
-
-	optional_ptr<UndoBufferEntry> entry;
-	BufferHandle handle;
-	idx_t position;
-
-	data_ptr_t Ptr() {
-		return handle.Ptr() + position;
-	}
-	bool IsSet() const {
-		return entry;
-	}
-
-	UndoBufferPointer GetBufferPointer();
-};
-
-struct UndoBufferPointer {
-	UndoBufferPointer() : entry(nullptr), position(0) {
-	}
-	UndoBufferPointer(UndoBufferEntry &entry_p, idx_t position) : entry(&entry_p), position(position) {
-	}
-
-	UndoBufferEntry *entry;
-	idx_t position;
-
-	UndoBufferReference Pin() const;
-	bool IsSet() const {
-		return entry;
-	}
-};
-
-struct UndoBufferAllocator {
-	explicit UndoBufferAllocator(BufferManager &buffer_manager);
-
-	UndoBufferReference Allocate(idx_t alloc_len);
-
-	BufferManager &buffer_manager;
-	unique_ptr<UndoBufferEntry> head;
-	optional_ptr<UndoBufferEntry> tail;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/update_info.hpp b/src/duckdb/src/include/duckdb/transaction/update_info.hpp
deleted file mode 100644
index 7cccd923e..000000000
--- a/src/duckdb/src/include/duckdb/transaction/update_info.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/update_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/types/validity_mask.hpp"
-#include "duckdb/transaction/undo_buffer_allocator.hpp"
-#include "duckdb/common/atomic.hpp"
-
-namespace duckdb {
-class UpdateSegment;
-struct DataTableInfo;
-
-//! UpdateInfo is a class that represents a set of updates applied to a single vector.
-//! The UpdateInfo struct contains metadata associated with the update.
-//! After the UpdateInfo, we must ALWAYS allocate the list of tuples and the data as contiguous arrays:
-//! [UpdateInfo][TUPLES (sel_t[max])][DATA (T[max])]
-//! The required allocation size can be obtained using UpdateInfo::GetAllocSize
-struct UpdateInfo {
-	//! The update segment that this update info affects
-	UpdateSegment *segment;
-	//! The column index of which column we are updating
-	idx_t column_index;
-	//! The version number
-	atomic<transaction_t> version_number;
-	//! The vector index within the uncompressed segment
-	idx_t vector_index;
-	//! The amount of updated tuples
-	sel_t N; // NOLINT
-	//! The maximum amount of tuples that can fit into this UpdateInfo
-	sel_t max;
-	//! The previous update info (or nullptr if it is the base)
-	UndoBufferPointer prev;
-	//! The next update info in the chain (or nullptr if it is the last)
-	UndoBufferPointer next;
-
-	//! The row ids of the tuples that have been updated. This should always be kept sorted!
-	sel_t *GetTuples();
-
-	//! The update values
-	data_ptr_t GetValues();
-
-	template <class T>
-	T *GetData() {
-		return reinterpret_cast<T *>(GetValues());
-	}
-
-	bool AppliesToTransaction(transaction_t start_time, transaction_t transaction_id) {
-		// these tuples were either committed AFTER this transaction started or are not committed yet, use
-		// tuples stored in this version
-		return version_number > start_time && version_number != transaction_id;
-	}
-
-	//! Loop over the update chain and execute the specified callback on all UpdateInfo's that are relevant for that
-	//! transaction in-order of newest to oldest
-	template <class T>
-	static void UpdatesForTransaction(UpdateInfo &current, transaction_t start_time, transaction_t transaction_id,
-	                                  T &&callback) {
-		if (current.AppliesToTransaction(start_time, transaction_id)) {
-			callback(current);
-		}
-		auto update_ptr = current.next;
-		while (update_ptr.IsSet()) {
-			auto pin = update_ptr.Pin();
-			auto &info = Get(pin);
-			if (info.AppliesToTransaction(start_time, transaction_id)) {
-				callback(info);
-			}
-			update_ptr = info.next;
-		}
-	}
-
-	Value GetValue(idx_t index);
-	string ToString();
-	void Print();
-	void Verify();
-	bool HasPrev() const;
-	bool HasNext() const;
-	static UpdateInfo &Get(UndoBufferReference &entry);
-	//! Returns the total allocation size for an UpdateInfo entry, together with space for the tuple data
-	static idx_t GetAllocSize(idx_t type_size);
-	//! Initialize an UpdateInfo struct that has been allocated using GetAllocSize (i.e. has extra space after it)
-	static void Initialize(UpdateInfo &info, transaction_t transaction_id);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/transaction/wal_write_state.hpp b/src/duckdb/src/include/duckdb/transaction/wal_write_state.hpp
deleted file mode 100644
index aad1a672c..000000000
--- a/src/duckdb/src/include/duckdb/transaction/wal_write_state.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/wal_write_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/transaction/undo_buffer.hpp"
-#include "duckdb/common/vector_size.hpp"
-
-namespace duckdb {
-class CatalogEntry;
-class DataChunk;
-class DuckTransaction;
-class WriteAheadLog;
-class ClientContext;
-
-struct DataTableInfo;
-struct DeleteInfo;
-struct UpdateInfo;
-
-class WALWriteState {
-public:
-	explicit WALWriteState(DuckTransaction &transaction, WriteAheadLog &log,
-	                       optional_ptr<StorageCommitState> commit_state);
-
-public:
-	void CommitEntry(UndoFlags type, data_ptr_t data);
-
-private:
-	void SwitchTable(DataTableInfo *table, UndoFlags new_op);
-
-	void WriteCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data);
-	void WriteDelete(DeleteInfo &info);
-	void WriteUpdate(UpdateInfo &info);
-
-private:
-	DuckTransaction &transaction;
-	WriteAheadLog &log;
-	optional_ptr<StorageCommitState> commit_state;
-
-	optional_ptr<DataTableInfo> current_table_info;
-
-	unique_ptr<DataChunk> delete_chunk;
-	unique_ptr<DataChunk> update_chunk;
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/copied_statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/copied_statement_verifier.hpp
deleted file mode 100644
index 0e1d021c4..000000000
--- a/src/duckdb/src/include/duckdb/verification/copied_statement_verifier.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/copied_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class CopiedStatementVerifier : public StatementVerifier {
-public:
-	explicit CopiedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                                 optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement_p,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier.hpp
deleted file mode 100644
index af21d57d8..000000000
--- a/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/deserialized_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class DeserializedStatementVerifier : public StatementVerifier {
-public:
-	explicit DeserializedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                                       optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/external_statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/external_statement_verifier.hpp
deleted file mode 100644
index a46d97661..000000000
--- a/src/duckdb/src/include/duckdb/verification/external_statement_verifier.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/external_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class ExternalStatementVerifier : public StatementVerifier {
-public:
-	explicit ExternalStatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                                   optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-
-	bool ForceExternal() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/fetch_row_verifier.hpp b/src/duckdb/src/include/duckdb/verification/fetch_row_verifier.hpp
deleted file mode 100644
index f4b75761d..000000000
--- a/src/duckdb/src/include/duckdb/verification/fetch_row_verifier.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/unoptimized_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class FetchRowVerifier : public StatementVerifier {
-public:
-	explicit FetchRowVerifier(unique_ptr<SQLStatement> statement_p,
-	                          optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement_p,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-
-	bool ForceFetchRow() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/no_operator_caching_verifier.hpp b/src/duckdb/src/include/duckdb/verification/no_operator_caching_verifier.hpp
deleted file mode 100644
index 66b99db29..000000000
--- a/src/duckdb/src/include/duckdb/verification/no_operator_caching_verifier.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/unoptimized_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class NoOperatorCachingVerifier : public StatementVerifier {
-public:
-	explicit NoOperatorCachingVerifier(unique_ptr<SQLStatement> statement_p,
-	                                   optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement_p,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-
-	bool DisableOperatorCaching() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/parsed_statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/parsed_statement_verifier.hpp
deleted file mode 100644
index d689eecb3..000000000
--- a/src/duckdb/src/include/duckdb/verification/parsed_statement_verifier.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/parsed_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class ParsedStatementVerifier : public StatementVerifier {
-public:
-	explicit ParsedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                                 optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-
-	bool RequireEquality() const override {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/prepared_statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/prepared_statement_verifier.hpp
deleted file mode 100644
index c34598c9b..000000000
--- a/src/duckdb/src/include/duckdb/verification/prepared_statement_verifier.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/prepared_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class PreparedStatementVerifier : public StatementVerifier {
-public:
-	explicit PreparedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                                   optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement_p,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-
-	bool Run(ClientContext &context, const string &query,
-	         const std::function<unique_ptr<QueryResult>(const string &, unique_ptr<SQLStatement>,
-	                                                     optional_ptr<case_insensitive_map_t<BoundParameterData>>)>
-	             &run) override;
-
-private:
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> values;
-	unique_ptr<SQLStatement> prepare_statement;
-	unique_ptr<SQLStatement> execute_statement;
-	unique_ptr<SQLStatement> dealloc_statement;
-
-private:
-	void Extract();
-	void ConvertConstants(unique_ptr<ParsedExpression> &child);
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/statement_verifier.hpp
deleted file mode 100644
index 63d52393e..000000000
--- a/src/duckdb/src/include/duckdb/verification/statement_verifier.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-
-namespace duckdb {
-
-enum class VerificationType : uint8_t {
-	ORIGINAL,
-	COPIED,
-	DESERIALIZED,
-	PARSED,
-	UNOPTIMIZED,
-	NO_OPERATOR_CACHING,
-	PREPARED,
-	EXTERNAL,
-	FETCH_ROW_AS_SCAN,
-
-	INVALID
-};
-
-class StatementVerifier {
-public:
-	StatementVerifier(VerificationType type, string name, unique_ptr<SQLStatement> statement_p,
-	                  optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
-	explicit StatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                           optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
-	static unique_ptr<StatementVerifier> Create(VerificationType type, const SQLStatement &statement_p,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
-	virtual ~StatementVerifier() noexcept;
-
-	//! Check whether expressions in this verifier and the other verifier match
-	void CheckExpressions(const StatementVerifier &other) const;
-	//! Check whether expressions within this verifier match
-	void CheckExpressions() const;
-
-	//! Run the select statement and store the result
-	virtual bool
-	Run(ClientContext &context, const string &query,
-	    const std::function<unique_ptr<QueryResult>(const string &, unique_ptr<SQLStatement>,
-	                                                optional_ptr<case_insensitive_map_t<BoundParameterData>>)> &run);
-	//! Compare this verifier's results with another verifier
-	string CompareResults(const StatementVerifier &other);
-
-public:
-	const VerificationType type;
-	const string name;
-	unique_ptr<SelectStatement> statement;
-	optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters;
-	const vector<unique_ptr<ParsedExpression>> &select_list;
-	unique_ptr<MaterializedQueryResult> materialized_result;
-
-	virtual bool RequireEquality() const {
-		return true;
-	}
-
-	virtual bool DisableOptimizer() const {
-		return false;
-	}
-
-	virtual bool DisableOperatorCaching() const {
-		return false;
-	}
-
-	virtual bool ForceExternal() const {
-		return false;
-	}
-
-	virtual bool ForceFetchRow() const {
-		return false;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/verification/unoptimized_statement_verifier.hpp b/src/duckdb/src/include/duckdb/verification/unoptimized_statement_verifier.hpp
deleted file mode 100644
index 6521bb9c6..000000000
--- a/src/duckdb/src/include/duckdb/verification/unoptimized_statement_verifier.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/unoptimized_statement_verifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-class UnoptimizedStatementVerifier : public StatementVerifier {
-public:
-	explicit UnoptimizedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-	                                      optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement_p,
-	                                            optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters);
-
-	bool DisableOptimizer() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb_extension.h b/src/duckdb/src/include/duckdb_extension.h
deleted file mode 100644
index 47c6a7f87..000000000
--- a/src/duckdb/src/include/duckdb_extension.h
+++ /dev/null
@@ -1,1027 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                         DuckDB
-//
-// duckdb_extension.h
-//
-//
-//===----------------------------------------------------------------------===//
-//
-// !!!!!!!
-// WARNING: this file is autogenerated by scripts/generate_c_api.py, manual changes will be overwritten
-// !!!!!!!
-
-// WARNING: this API is not yet stable, meaning it is only guaranteed to work for this specific DuckDB version.
-
-#pragma once
-
-#include "duckdb.h"
-
-//===--------------------------------------------------------------------===//
-// Util Macros
-//===--------------------------------------------------------------------===//
-
-#ifdef __cplusplus
-#define DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN  extern "C" {
-#define DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE }
-#else
-#define DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN
-#define DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE
-#endif
-
-#define DUCKDB_EXTENSION_GLUE_HELPER(x, y) x##y
-#define DUCKDB_EXTENSION_GLUE(x, y)        DUCKDB_EXTENSION_GLUE_HELPER(x, y)
-#define DUCKDB_EXTENSION_STR_HELPER(x)     #x
-#define DUCKDB_EXTENSION_STR(x)            DUCKDB_EXTENSION_STR_HELPER(x)
-#define DUCKDB_EXTENSION_SEMVER_STRING(major, minor, patch)                                                            \
-	"v" DUCKDB_EXTENSION_STR_HELPER(major) "." DUCKDB_EXTENSION_STR_HELPER(minor) "." DUCKDB_EXTENSION_STR_HELPER(patch)
-
-//===--------------------------------------------------------------------===//
-// Versioning
-//===--------------------------------------------------------------------===//
-//! Set version to latest if no explicit version is defined
-
-#if !defined(DUCKDB_EXTENSION_API_VERSION_MAJOR) && !defined(DUCKDB_EXTENSION_API_VERSION_MINOR) &&                    \
-    !defined(DUCKDB_EXTENSION_API_VERSION_PATCH)
-#define DUCKDB_EXTENSION_API_VERSION_MAJOR 1
-#define DUCKDB_EXTENSION_API_VERSION_MINOR 2
-#define DUCKDB_EXTENSION_API_VERSION_PATCH 0
-#elif !(defined(DUCKDB_EXTENSION_API_VERSION_MAJOR) && defined(DUCKDB_EXTENSION_API_VERSION_MINOR) &&                  \
-        defined(DUCKDB_EXTENSION_API_VERSION_PATCH))
-#error "either all or none of the  DUCKDB_EXTENSION_API_VERSION_ defines should be defined"
-#endif
-
-//! Set the DUCKDB_EXTENSION_API_VERSION_STRING which is passed to DuckDB on extension load
-#ifdef DUCKDB_EXTENSION_API_UNSTABLE_VERSION
-#define DUCKDB_EXTENSION_API_VERSION_STRING DUCKDB_EXTENSION_API_UNSTABLE_VERSION
-#else
-#define DUCKDB_EXTENSION_API_VERSION_STRING                                                                            \
-	DUCKDB_EXTENSION_SEMVER_STRING(DUCKDB_EXTENSION_API_VERSION_MAJOR, DUCKDB_EXTENSION_API_VERSION_MINOR,             \
-	                               DUCKDB_EXTENSION_API_VERSION_PATCH)
-#endif
-
-#if DUCKDB_EXTENSION_API_VERSION_MAJOR != 1
-#error "This version of the extension API header only supports API VERSION v1.x.x"
-#endif
-
-//===--------------------------------------------------------------------===//
-// Function pointer struct
-//===--------------------------------------------------------------------===//
-typedef struct {
-#if DUCKDB_EXTENSION_API_VERSION_MINOR > 2 ||                                                                          \
-    (DUCKDB_EXTENSION_API_VERSION_MINOR == 2 && DUCKDB_EXTENSION_API_VERSION_PATCH >= 0) // v1.2.0
-	duckdb_state (*duckdb_open)(const char *path, duckdb_database *out_database);
-	duckdb_state (*duckdb_open_ext)(const char *path, duckdb_database *out_database, duckdb_config config,
-	                                char **out_error);
-	void (*duckdb_close)(duckdb_database *database);
-	duckdb_state (*duckdb_connect)(duckdb_database database, duckdb_connection *out_connection);
-	void (*duckdb_interrupt)(duckdb_connection connection);
-	duckdb_query_progress_type (*duckdb_query_progress)(duckdb_connection connection);
-	void (*duckdb_disconnect)(duckdb_connection *connection);
-	const char *(*duckdb_library_version)();
-	duckdb_state (*duckdb_create_config)(duckdb_config *out_config);
-	size_t (*duckdb_config_count)();
-	duckdb_state (*duckdb_get_config_flag)(size_t index, const char **out_name, const char **out_description);
-	duckdb_state (*duckdb_set_config)(duckdb_config config, const char *name, const char *option);
-	void (*duckdb_destroy_config)(duckdb_config *config);
-	duckdb_state (*duckdb_query)(duckdb_connection connection, const char *query, duckdb_result *out_result);
-	void (*duckdb_destroy_result)(duckdb_result *result);
-	const char *(*duckdb_column_name)(duckdb_result *result, idx_t col);
-	duckdb_type (*duckdb_column_type)(duckdb_result *result, idx_t col);
-	duckdb_statement_type (*duckdb_result_statement_type)(duckdb_result result);
-	duckdb_logical_type (*duckdb_column_logical_type)(duckdb_result *result, idx_t col);
-	idx_t (*duckdb_column_count)(duckdb_result *result);
-	idx_t (*duckdb_rows_changed)(duckdb_result *result);
-	const char *(*duckdb_result_error)(duckdb_result *result);
-	duckdb_error_type (*duckdb_result_error_type)(duckdb_result *result);
-	duckdb_result_type (*duckdb_result_return_type)(duckdb_result result);
-	void *(*duckdb_malloc)(size_t size);
-	void (*duckdb_free)(void *ptr);
-	idx_t (*duckdb_vector_size)();
-	bool (*duckdb_string_is_inlined)(duckdb_string_t string);
-	uint32_t (*duckdb_string_t_length)(duckdb_string_t string);
-	const char *(*duckdb_string_t_data)(duckdb_string_t *string);
-	duckdb_date_struct (*duckdb_from_date)(duckdb_date date);
-	duckdb_date (*duckdb_to_date)(duckdb_date_struct date);
-	bool (*duckdb_is_finite_date)(duckdb_date date);
-	duckdb_time_struct (*duckdb_from_time)(duckdb_time time);
-	duckdb_time_tz (*duckdb_create_time_tz)(int64_t micros, int32_t offset);
-	duckdb_time_tz_struct (*duckdb_from_time_tz)(duckdb_time_tz micros);
-	duckdb_time (*duckdb_to_time)(duckdb_time_struct time);
-	duckdb_timestamp_struct (*duckdb_from_timestamp)(duckdb_timestamp ts);
-	duckdb_timestamp (*duckdb_to_timestamp)(duckdb_timestamp_struct ts);
-	bool (*duckdb_is_finite_timestamp)(duckdb_timestamp ts);
-	double (*duckdb_hugeint_to_double)(duckdb_hugeint val);
-	duckdb_hugeint (*duckdb_double_to_hugeint)(double val);
-	double (*duckdb_uhugeint_to_double)(duckdb_uhugeint val);
-	duckdb_uhugeint (*duckdb_double_to_uhugeint)(double val);
-	duckdb_decimal (*duckdb_double_to_decimal)(double val, uint8_t width, uint8_t scale);
-	double (*duckdb_decimal_to_double)(duckdb_decimal val);
-	duckdb_state (*duckdb_prepare)(duckdb_connection connection, const char *query,
-	                               duckdb_prepared_statement *out_prepared_statement);
-	void (*duckdb_destroy_prepare)(duckdb_prepared_statement *prepared_statement);
-	const char *(*duckdb_prepare_error)(duckdb_prepared_statement prepared_statement);
-	idx_t (*duckdb_nparams)(duckdb_prepared_statement prepared_statement);
-	const char *(*duckdb_parameter_name)(duckdb_prepared_statement prepared_statement, idx_t index);
-	duckdb_type (*duckdb_param_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-	duckdb_logical_type (*duckdb_param_logical_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-	duckdb_state (*duckdb_clear_bindings)(duckdb_prepared_statement prepared_statement);
-	duckdb_statement_type (*duckdb_prepared_statement_type)(duckdb_prepared_statement statement);
-	duckdb_state (*duckdb_bind_value)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val);
-	duckdb_state (*duckdb_bind_parameter_index)(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
-	                                            const char *name);
-	duckdb_state (*duckdb_bind_boolean)(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val);
-	duckdb_state (*duckdb_bind_int8)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val);
-	duckdb_state (*duckdb_bind_int16)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val);
-	duckdb_state (*duckdb_bind_int32)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val);
-	duckdb_state (*duckdb_bind_int64)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val);
-	duckdb_state (*duckdb_bind_hugeint)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                    duckdb_hugeint val);
-	duckdb_state (*duckdb_bind_uhugeint)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                     duckdb_uhugeint val);
-	duckdb_state (*duckdb_bind_decimal)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                    duckdb_decimal val);
-	duckdb_state (*duckdb_bind_uint8)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val);
-	duckdb_state (*duckdb_bind_uint16)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val);
-	duckdb_state (*duckdb_bind_uint32)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val);
-	duckdb_state (*duckdb_bind_uint64)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val);
-	duckdb_state (*duckdb_bind_float)(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val);
-	duckdb_state (*duckdb_bind_double)(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val);
-	duckdb_state (*duckdb_bind_date)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val);
-	duckdb_state (*duckdb_bind_time)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val);
-	duckdb_state (*duckdb_bind_timestamp)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                      duckdb_timestamp val);
-	duckdb_state (*duckdb_bind_timestamp_tz)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                         duckdb_timestamp val);
-	duckdb_state (*duckdb_bind_interval)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                     duckdb_interval val);
-	duckdb_state (*duckdb_bind_varchar)(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val);
-	duckdb_state (*duckdb_bind_varchar_length)(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-	                                           const char *val, idx_t length);
-	duckdb_state (*duckdb_bind_blob)(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
-	                                 idx_t length);
-	duckdb_state (*duckdb_bind_null)(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-	duckdb_state (*duckdb_execute_prepared)(duckdb_prepared_statement prepared_statement, duckdb_result *out_result);
-	idx_t (*duckdb_extract_statements)(duckdb_connection connection, const char *query,
-	                                   duckdb_extracted_statements *out_extracted_statements);
-	duckdb_state (*duckdb_prepare_extracted_statement)(duckdb_connection connection,
-	                                                   duckdb_extracted_statements extracted_statements, idx_t index,
-	                                                   duckdb_prepared_statement *out_prepared_statement);
-	const char *(*duckdb_extract_statements_error)(duckdb_extracted_statements extracted_statements);
-	void (*duckdb_destroy_extracted)(duckdb_extracted_statements *extracted_statements);
-	duckdb_state (*duckdb_pending_prepared)(duckdb_prepared_statement prepared_statement,
-	                                        duckdb_pending_result *out_result);
-	void (*duckdb_destroy_pending)(duckdb_pending_result *pending_result);
-	const char *(*duckdb_pending_error)(duckdb_pending_result pending_result);
-	duckdb_pending_state (*duckdb_pending_execute_task)(duckdb_pending_result pending_result);
-	duckdb_pending_state (*duckdb_pending_execute_check_state)(duckdb_pending_result pending_result);
-	duckdb_state (*duckdb_execute_pending)(duckdb_pending_result pending_result, duckdb_result *out_result);
-	bool (*duckdb_pending_execution_is_finished)(duckdb_pending_state pending_state);
-	void (*duckdb_destroy_value)(duckdb_value *value);
-	duckdb_value (*duckdb_create_varchar)(const char *text);
-	duckdb_value (*duckdb_create_varchar_length)(const char *text, idx_t length);
-	duckdb_value (*duckdb_create_bool)(bool input);
-	duckdb_value (*duckdb_create_int8)(int8_t input);
-	duckdb_value (*duckdb_create_uint8)(uint8_t input);
-	duckdb_value (*duckdb_create_int16)(int16_t input);
-	duckdb_value (*duckdb_create_uint16)(uint16_t input);
-	duckdb_value (*duckdb_create_int32)(int32_t input);
-	duckdb_value (*duckdb_create_uint32)(uint32_t input);
-	duckdb_value (*duckdb_create_uint64)(uint64_t input);
-	duckdb_value (*duckdb_create_int64)(int64_t val);
-	duckdb_value (*duckdb_create_hugeint)(duckdb_hugeint input);
-	duckdb_value (*duckdb_create_uhugeint)(duckdb_uhugeint input);
-	duckdb_value (*duckdb_create_float)(float input);
-	duckdb_value (*duckdb_create_double)(double input);
-	duckdb_value (*duckdb_create_date)(duckdb_date input);
-	duckdb_value (*duckdb_create_time)(duckdb_time input);
-	duckdb_value (*duckdb_create_time_tz_value)(duckdb_time_tz value);
-	duckdb_value (*duckdb_create_timestamp)(duckdb_timestamp input);
-	duckdb_value (*duckdb_create_interval)(duckdb_interval input);
-	duckdb_value (*duckdb_create_blob)(const uint8_t *data, idx_t length);
-	duckdb_value (*duckdb_create_varint)(duckdb_varint input);
-	duckdb_value (*duckdb_create_decimal)(duckdb_decimal input);
-	duckdb_value (*duckdb_create_bit)(duckdb_bit input);
-	duckdb_value (*duckdb_create_uuid)(duckdb_uhugeint input);
-	bool (*duckdb_get_bool)(duckdb_value val);
-	int8_t (*duckdb_get_int8)(duckdb_value val);
-	uint8_t (*duckdb_get_uint8)(duckdb_value val);
-	int16_t (*duckdb_get_int16)(duckdb_value val);
-	uint16_t (*duckdb_get_uint16)(duckdb_value val);
-	int32_t (*duckdb_get_int32)(duckdb_value val);
-	uint32_t (*duckdb_get_uint32)(duckdb_value val);
-	int64_t (*duckdb_get_int64)(duckdb_value val);
-	uint64_t (*duckdb_get_uint64)(duckdb_value val);
-	duckdb_hugeint (*duckdb_get_hugeint)(duckdb_value val);
-	duckdb_uhugeint (*duckdb_get_uhugeint)(duckdb_value val);
-	float (*duckdb_get_float)(duckdb_value val);
-	double (*duckdb_get_double)(duckdb_value val);
-	duckdb_date (*duckdb_get_date)(duckdb_value val);
-	duckdb_time (*duckdb_get_time)(duckdb_value val);
-	duckdb_time_tz (*duckdb_get_time_tz)(duckdb_value val);
-	duckdb_timestamp (*duckdb_get_timestamp)(duckdb_value val);
-	duckdb_interval (*duckdb_get_interval)(duckdb_value val);
-	duckdb_logical_type (*duckdb_get_value_type)(duckdb_value val);
-	duckdb_blob (*duckdb_get_blob)(duckdb_value val);
-	duckdb_varint (*duckdb_get_varint)(duckdb_value val);
-	duckdb_decimal (*duckdb_get_decimal)(duckdb_value val);
-	duckdb_bit (*duckdb_get_bit)(duckdb_value val);
-	duckdb_uhugeint (*duckdb_get_uuid)(duckdb_value val);
-	char *(*duckdb_get_varchar)(duckdb_value value);
-	duckdb_value (*duckdb_create_struct_value)(duckdb_logical_type type, duckdb_value *values);
-	duckdb_value (*duckdb_create_list_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
-	duckdb_value (*duckdb_create_array_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
-	idx_t (*duckdb_get_map_size)(duckdb_value value);
-	duckdb_value (*duckdb_get_map_key)(duckdb_value value, idx_t index);
-	duckdb_value (*duckdb_get_map_value)(duckdb_value value, idx_t index);
-	bool (*duckdb_is_null_value)(duckdb_value value);
-	duckdb_value (*duckdb_create_null_value)();
-	idx_t (*duckdb_get_list_size)(duckdb_value value);
-	duckdb_value (*duckdb_get_list_child)(duckdb_value value, idx_t index);
-	duckdb_value (*duckdb_create_enum_value)(duckdb_logical_type type, uint64_t value);
-	uint64_t (*duckdb_get_enum_value)(duckdb_value value);
-	duckdb_value (*duckdb_get_struct_child)(duckdb_value value, idx_t index);
-	duckdb_logical_type (*duckdb_create_logical_type)(duckdb_type type);
-	char *(*duckdb_logical_type_get_alias)(duckdb_logical_type type);
-	void (*duckdb_logical_type_set_alias)(duckdb_logical_type type, const char *alias);
-	duckdb_logical_type (*duckdb_create_list_type)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_create_array_type)(duckdb_logical_type type, idx_t array_size);
-	duckdb_logical_type (*duckdb_create_map_type)(duckdb_logical_type key_type, duckdb_logical_type value_type);
-	duckdb_logical_type (*duckdb_create_union_type)(duckdb_logical_type *member_types, const char **member_names,
-	                                                idx_t member_count);
-	duckdb_logical_type (*duckdb_create_struct_type)(duckdb_logical_type *member_types, const char **member_names,
-	                                                 idx_t member_count);
-	duckdb_logical_type (*duckdb_create_enum_type)(const char **member_names, idx_t member_count);
-	duckdb_logical_type (*duckdb_create_decimal_type)(uint8_t width, uint8_t scale);
-	duckdb_type (*duckdb_get_type_id)(duckdb_logical_type type);
-	uint8_t (*duckdb_decimal_width)(duckdb_logical_type type);
-	uint8_t (*duckdb_decimal_scale)(duckdb_logical_type type);
-	duckdb_type (*duckdb_decimal_internal_type)(duckdb_logical_type type);
-	duckdb_type (*duckdb_enum_internal_type)(duckdb_logical_type type);
-	uint32_t (*duckdb_enum_dictionary_size)(duckdb_logical_type type);
-	char *(*duckdb_enum_dictionary_value)(duckdb_logical_type type, idx_t index);
-	duckdb_logical_type (*duckdb_list_type_child_type)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_array_type_child_type)(duckdb_logical_type type);
-	idx_t (*duckdb_array_type_array_size)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_map_type_key_type)(duckdb_logical_type type);
-	duckdb_logical_type (*duckdb_map_type_value_type)(duckdb_logical_type type);
-	idx_t (*duckdb_struct_type_child_count)(duckdb_logical_type type);
-	char *(*duckdb_struct_type_child_name)(duckdb_logical_type type, idx_t index);
-	duckdb_logical_type (*duckdb_struct_type_child_type)(duckdb_logical_type type, idx_t index);
-	idx_t (*duckdb_union_type_member_count)(duckdb_logical_type type);
-	char *(*duckdb_union_type_member_name)(duckdb_logical_type type, idx_t index);
-	duckdb_logical_type (*duckdb_union_type_member_type)(duckdb_logical_type type, idx_t index);
-	void (*duckdb_destroy_logical_type)(duckdb_logical_type *type);
-	duckdb_state (*duckdb_register_logical_type)(duckdb_connection con, duckdb_logical_type type,
-	                                             duckdb_create_type_info info);
-	duckdb_data_chunk (*duckdb_create_data_chunk)(duckdb_logical_type *types, idx_t column_count);
-	void (*duckdb_destroy_data_chunk)(duckdb_data_chunk *chunk);
-	void (*duckdb_data_chunk_reset)(duckdb_data_chunk chunk);
-	idx_t (*duckdb_data_chunk_get_column_count)(duckdb_data_chunk chunk);
-	duckdb_vector (*duckdb_data_chunk_get_vector)(duckdb_data_chunk chunk, idx_t col_idx);
-	idx_t (*duckdb_data_chunk_get_size)(duckdb_data_chunk chunk);
-	void (*duckdb_data_chunk_set_size)(duckdb_data_chunk chunk, idx_t size);
-	duckdb_logical_type (*duckdb_vector_get_column_type)(duckdb_vector vector);
-	void *(*duckdb_vector_get_data)(duckdb_vector vector);
-	uint64_t *(*duckdb_vector_get_validity)(duckdb_vector vector);
-	void (*duckdb_vector_ensure_validity_writable)(duckdb_vector vector);
-	void (*duckdb_vector_assign_string_element)(duckdb_vector vector, idx_t index, const char *str);
-	void (*duckdb_vector_assign_string_element_len)(duckdb_vector vector, idx_t index, const char *str, idx_t str_len);
-	duckdb_vector (*duckdb_list_vector_get_child)(duckdb_vector vector);
-	idx_t (*duckdb_list_vector_get_size)(duckdb_vector vector);
-	duckdb_state (*duckdb_list_vector_set_size)(duckdb_vector vector, idx_t size);
-	duckdb_state (*duckdb_list_vector_reserve)(duckdb_vector vector, idx_t required_capacity);
-	duckdb_vector (*duckdb_struct_vector_get_child)(duckdb_vector vector, idx_t index);
-	duckdb_vector (*duckdb_array_vector_get_child)(duckdb_vector vector);
-	bool (*duckdb_validity_row_is_valid)(uint64_t *validity, idx_t row);
-	void (*duckdb_validity_set_row_validity)(uint64_t *validity, idx_t row, bool valid);
-	void (*duckdb_validity_set_row_invalid)(uint64_t *validity, idx_t row);
-	void (*duckdb_validity_set_row_valid)(uint64_t *validity, idx_t row);
-	duckdb_scalar_function (*duckdb_create_scalar_function)();
-	void (*duckdb_destroy_scalar_function)(duckdb_scalar_function *scalar_function);
-	void (*duckdb_scalar_function_set_name)(duckdb_scalar_function scalar_function, const char *name);
-	void (*duckdb_scalar_function_set_varargs)(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-	void (*duckdb_scalar_function_set_special_handling)(duckdb_scalar_function scalar_function);
-	void (*duckdb_scalar_function_set_volatile)(duckdb_scalar_function scalar_function);
-	void (*duckdb_scalar_function_add_parameter)(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-	void (*duckdb_scalar_function_set_return_type)(duckdb_scalar_function scalar_function, duckdb_logical_type type);
-	void (*duckdb_scalar_function_set_extra_info)(duckdb_scalar_function scalar_function, void *extra_info,
-	                                              duckdb_delete_callback_t destroy);
-	void (*duckdb_scalar_function_set_function)(duckdb_scalar_function scalar_function,
-	                                            duckdb_scalar_function_t function);
-	duckdb_state (*duckdb_register_scalar_function)(duckdb_connection con, duckdb_scalar_function scalar_function);
-	void *(*duckdb_scalar_function_get_extra_info)(duckdb_function_info info);
-	void (*duckdb_scalar_function_set_error)(duckdb_function_info info, const char *error);
-	duckdb_scalar_function_set (*duckdb_create_scalar_function_set)(const char *name);
-	void (*duckdb_destroy_scalar_function_set)(duckdb_scalar_function_set *scalar_function_set);
-	duckdb_state (*duckdb_add_scalar_function_to_set)(duckdb_scalar_function_set set, duckdb_scalar_function function);
-	duckdb_state (*duckdb_register_scalar_function_set)(duckdb_connection con, duckdb_scalar_function_set set);
-	duckdb_aggregate_function (*duckdb_create_aggregate_function)();
-	void (*duckdb_destroy_aggregate_function)(duckdb_aggregate_function *aggregate_function);
-	void (*duckdb_aggregate_function_set_name)(duckdb_aggregate_function aggregate_function, const char *name);
-	void (*duckdb_aggregate_function_add_parameter)(duckdb_aggregate_function aggregate_function,
-	                                                duckdb_logical_type type);
-	void (*duckdb_aggregate_function_set_return_type)(duckdb_aggregate_function aggregate_function,
-	                                                  duckdb_logical_type type);
-	void (*duckdb_aggregate_function_set_functions)(duckdb_aggregate_function aggregate_function,
-	                                                duckdb_aggregate_state_size state_size,
-	                                                duckdb_aggregate_init_t state_init,
-	                                                duckdb_aggregate_update_t update,
-	                                                duckdb_aggregate_combine_t combine,
-	                                                duckdb_aggregate_finalize_t finalize);
-	void (*duckdb_aggregate_function_set_destructor)(duckdb_aggregate_function aggregate_function,
-	                                                 duckdb_aggregate_destroy_t destroy);
-	duckdb_state (*duckdb_register_aggregate_function)(duckdb_connection con,
-	                                                   duckdb_aggregate_function aggregate_function);
-	void (*duckdb_aggregate_function_set_special_handling)(duckdb_aggregate_function aggregate_function);
-	void (*duckdb_aggregate_function_set_extra_info)(duckdb_aggregate_function aggregate_function, void *extra_info,
-	                                                 duckdb_delete_callback_t destroy);
-	void *(*duckdb_aggregate_function_get_extra_info)(duckdb_function_info info);
-	void (*duckdb_aggregate_function_set_error)(duckdb_function_info info, const char *error);
-	duckdb_aggregate_function_set (*duckdb_create_aggregate_function_set)(const char *name);
-	void (*duckdb_destroy_aggregate_function_set)(duckdb_aggregate_function_set *aggregate_function_set);
-	duckdb_state (*duckdb_add_aggregate_function_to_set)(duckdb_aggregate_function_set set,
-	                                                     duckdb_aggregate_function function);
-	duckdb_state (*duckdb_register_aggregate_function_set)(duckdb_connection con, duckdb_aggregate_function_set set);
-	duckdb_table_function (*duckdb_create_table_function)();
-	void (*duckdb_destroy_table_function)(duckdb_table_function *table_function);
-	void (*duckdb_table_function_set_name)(duckdb_table_function table_function, const char *name);
-	void (*duckdb_table_function_add_parameter)(duckdb_table_function table_function, duckdb_logical_type type);
-	void (*duckdb_table_function_add_named_parameter)(duckdb_table_function table_function, const char *name,
-	                                                  duckdb_logical_type type);
-	void (*duckdb_table_function_set_extra_info)(duckdb_table_function table_function, void *extra_info,
-	                                             duckdb_delete_callback_t destroy);
-	void (*duckdb_table_function_set_bind)(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
-	void (*duckdb_table_function_set_init)(duckdb_table_function table_function, duckdb_table_function_init_t init);
-	void (*duckdb_table_function_set_local_init)(duckdb_table_function table_function,
-	                                             duckdb_table_function_init_t init);
-	void (*duckdb_table_function_set_function)(duckdb_table_function table_function, duckdb_table_function_t function);
-	void (*duckdb_table_function_supports_projection_pushdown)(duckdb_table_function table_function, bool pushdown);
-	duckdb_state (*duckdb_register_table_function)(duckdb_connection con, duckdb_table_function function);
-	void *(*duckdb_bind_get_extra_info)(duckdb_bind_info info);
-	void (*duckdb_bind_add_result_column)(duckdb_bind_info info, const char *name, duckdb_logical_type type);
-	idx_t (*duckdb_bind_get_parameter_count)(duckdb_bind_info info);
-	duckdb_value (*duckdb_bind_get_parameter)(duckdb_bind_info info, idx_t index);
-	duckdb_value (*duckdb_bind_get_named_parameter)(duckdb_bind_info info, const char *name);
-	void (*duckdb_bind_set_bind_data)(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
-	void (*duckdb_bind_set_cardinality)(duckdb_bind_info info, idx_t cardinality, bool is_exact);
-	void (*duckdb_bind_set_error)(duckdb_bind_info info, const char *error);
-	void *(*duckdb_init_get_extra_info)(duckdb_init_info info);
-	void *(*duckdb_init_get_bind_data)(duckdb_init_info info);
-	void (*duckdb_init_set_init_data)(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
-	idx_t (*duckdb_init_get_column_count)(duckdb_init_info info);
-	idx_t (*duckdb_init_get_column_index)(duckdb_init_info info, idx_t column_index);
-	void (*duckdb_init_set_max_threads)(duckdb_init_info info, idx_t max_threads);
-	void (*duckdb_init_set_error)(duckdb_init_info info, const char *error);
-	void *(*duckdb_function_get_extra_info)(duckdb_function_info info);
-	void *(*duckdb_function_get_bind_data)(duckdb_function_info info);
-	void *(*duckdb_function_get_init_data)(duckdb_function_info info);
-	void *(*duckdb_function_get_local_init_data)(duckdb_function_info info);
-	void (*duckdb_function_set_error)(duckdb_function_info info, const char *error);
-	void (*duckdb_add_replacement_scan)(duckdb_database db, duckdb_replacement_callback_t replacement, void *extra_data,
-	                                    duckdb_delete_callback_t delete_callback);
-	void (*duckdb_replacement_scan_set_function_name)(duckdb_replacement_scan_info info, const char *function_name);
-	void (*duckdb_replacement_scan_add_parameter)(duckdb_replacement_scan_info info, duckdb_value parameter);
-	void (*duckdb_replacement_scan_set_error)(duckdb_replacement_scan_info info, const char *error);
-	duckdb_value (*duckdb_profiling_info_get_metrics)(duckdb_profiling_info info);
-	idx_t (*duckdb_profiling_info_get_child_count)(duckdb_profiling_info info);
-	duckdb_profiling_info (*duckdb_profiling_info_get_child)(duckdb_profiling_info info, idx_t index);
-	duckdb_state (*duckdb_appender_create)(duckdb_connection connection, const char *schema, const char *table,
-	                                       duckdb_appender *out_appender);
-	duckdb_state (*duckdb_appender_create_ext)(duckdb_connection connection, const char *catalog, const char *schema,
-	                                           const char *table, duckdb_appender *out_appender);
-	idx_t (*duckdb_appender_column_count)(duckdb_appender appender);
-	duckdb_logical_type (*duckdb_appender_column_type)(duckdb_appender appender, idx_t col_idx);
-	const char *(*duckdb_appender_error)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_flush)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_close)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_destroy)(duckdb_appender *appender);
-	duckdb_state (*duckdb_appender_add_column)(duckdb_appender appender, const char *name);
-	duckdb_state (*duckdb_appender_clear_columns)(duckdb_appender appender);
-	duckdb_state (*duckdb_append_data_chunk)(duckdb_appender appender, duckdb_data_chunk chunk);
-	duckdb_state (*duckdb_table_description_create)(duckdb_connection connection, const char *schema, const char *table,
-	                                                duckdb_table_description *out);
-	duckdb_state (*duckdb_table_description_create_ext)(duckdb_connection connection, const char *catalog,
-	                                                    const char *schema, const char *table,
-	                                                    duckdb_table_description *out);
-	void (*duckdb_table_description_destroy)(duckdb_table_description *table_description);
-	const char *(*duckdb_table_description_error)(duckdb_table_description table_description);
-	duckdb_state (*duckdb_column_has_default)(duckdb_table_description table_description, idx_t index, bool *out);
-	char *(*duckdb_table_description_get_column_name)(duckdb_table_description table_description, idx_t index);
-	void (*duckdb_execute_tasks)(duckdb_database database, idx_t max_tasks);
-	duckdb_task_state (*duckdb_create_task_state)(duckdb_database database);
-	void (*duckdb_execute_tasks_state)(duckdb_task_state state);
-	idx_t (*duckdb_execute_n_tasks_state)(duckdb_task_state state, idx_t max_tasks);
-	void (*duckdb_finish_execution)(duckdb_task_state state);
-	bool (*duckdb_task_state_is_finished)(duckdb_task_state state);
-	void (*duckdb_destroy_task_state)(duckdb_task_state state);
-	bool (*duckdb_execution_is_finished)(duckdb_connection con);
-	duckdb_data_chunk (*duckdb_fetch_chunk)(duckdb_result result);
-	duckdb_cast_function (*duckdb_create_cast_function)();
-	void (*duckdb_cast_function_set_source_type)(duckdb_cast_function cast_function, duckdb_logical_type source_type);
-	void (*duckdb_cast_function_set_target_type)(duckdb_cast_function cast_function, duckdb_logical_type target_type);
-	void (*duckdb_cast_function_set_implicit_cast_cost)(duckdb_cast_function cast_function, int64_t cost);
-	void (*duckdb_cast_function_set_function)(duckdb_cast_function cast_function, duckdb_cast_function_t function);
-	void (*duckdb_cast_function_set_extra_info)(duckdb_cast_function cast_function, void *extra_info,
-	                                            duckdb_delete_callback_t destroy);
-	void *(*duckdb_cast_function_get_extra_info)(duckdb_function_info info);
-	duckdb_cast_mode (*duckdb_cast_function_get_cast_mode)(duckdb_function_info info);
-	void (*duckdb_cast_function_set_error)(duckdb_function_info info, const char *error);
-	void (*duckdb_cast_function_set_row_error)(duckdb_function_info info, const char *error, idx_t row,
-	                                           duckdb_vector output);
-	duckdb_state (*duckdb_register_cast_function)(duckdb_connection con, duckdb_cast_function cast_function);
-	void (*duckdb_destroy_cast_function)(duckdb_cast_function *cast_function);
-	bool (*duckdb_is_finite_timestamp_s)(duckdb_timestamp_s ts);
-	bool (*duckdb_is_finite_timestamp_ms)(duckdb_timestamp_ms ts);
-	bool (*duckdb_is_finite_timestamp_ns)(duckdb_timestamp_ns ts);
-	duckdb_value (*duckdb_create_timestamp_tz)(duckdb_timestamp input);
-	duckdb_value (*duckdb_create_timestamp_s)(duckdb_timestamp_s input);
-	duckdb_value (*duckdb_create_timestamp_ms)(duckdb_timestamp_ms input);
-	duckdb_value (*duckdb_create_timestamp_ns)(duckdb_timestamp_ns input);
-	duckdb_timestamp (*duckdb_get_timestamp_tz)(duckdb_value val);
-	duckdb_timestamp_s (*duckdb_get_timestamp_s)(duckdb_value val);
-	duckdb_timestamp_ms (*duckdb_get_timestamp_ms)(duckdb_value val);
-	duckdb_timestamp_ns (*duckdb_get_timestamp_ns)(duckdb_value val);
-	duckdb_state (*duckdb_append_value)(duckdb_appender appender, duckdb_value value);
-	duckdb_profiling_info (*duckdb_get_profiling_info)(duckdb_connection connection);
-	duckdb_value (*duckdb_profiling_info_get_value)(duckdb_profiling_info info, const char *key);
-	duckdb_state (*duckdb_appender_begin_row)(duckdb_appender appender);
-	duckdb_state (*duckdb_appender_end_row)(duckdb_appender appender);
-	duckdb_state (*duckdb_append_default)(duckdb_appender appender);
-	duckdb_state (*duckdb_append_bool)(duckdb_appender appender, bool value);
-	duckdb_state (*duckdb_append_int8)(duckdb_appender appender, int8_t value);
-	duckdb_state (*duckdb_append_int16)(duckdb_appender appender, int16_t value);
-	duckdb_state (*duckdb_append_int32)(duckdb_appender appender, int32_t value);
-	duckdb_state (*duckdb_append_int64)(duckdb_appender appender, int64_t value);
-	duckdb_state (*duckdb_append_hugeint)(duckdb_appender appender, duckdb_hugeint value);
-	duckdb_state (*duckdb_append_uint8)(duckdb_appender appender, uint8_t value);
-	duckdb_state (*duckdb_append_uint16)(duckdb_appender appender, uint16_t value);
-	duckdb_state (*duckdb_append_uint32)(duckdb_appender appender, uint32_t value);
-	duckdb_state (*duckdb_append_uint64)(duckdb_appender appender, uint64_t value);
-	duckdb_state (*duckdb_append_uhugeint)(duckdb_appender appender, duckdb_uhugeint value);
-	duckdb_state (*duckdb_append_float)(duckdb_appender appender, float value);
-	duckdb_state (*duckdb_append_double)(duckdb_appender appender, double value);
-	duckdb_state (*duckdb_append_date)(duckdb_appender appender, duckdb_date value);
-	duckdb_state (*duckdb_append_time)(duckdb_appender appender, duckdb_time value);
-	duckdb_state (*duckdb_append_timestamp)(duckdb_appender appender, duckdb_timestamp value);
-	duckdb_state (*duckdb_append_interval)(duckdb_appender appender, duckdb_interval value);
-	duckdb_state (*duckdb_append_varchar)(duckdb_appender appender, const char *val);
-	duckdb_state (*duckdb_append_varchar_length)(duckdb_appender appender, const char *val, idx_t length);
-	duckdb_state (*duckdb_append_blob)(duckdb_appender appender, const void *data, idx_t length);
-	duckdb_state (*duckdb_append_null)(duckdb_appender appender);
-#endif
-
-// These functions have been deprecated and may be removed in future versions of DuckDB
-#ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE
-	idx_t (*duckdb_row_count)(duckdb_result *result);
-	void *(*duckdb_column_data)(duckdb_result *result, idx_t col);
-	bool *(*duckdb_nullmask_data)(duckdb_result *result, idx_t col);
-	duckdb_data_chunk (*duckdb_result_get_chunk)(duckdb_result result, idx_t chunk_index);
-	bool (*duckdb_result_is_streaming)(duckdb_result result);
-	idx_t (*duckdb_result_chunk_count)(duckdb_result result);
-	bool (*duckdb_value_boolean)(duckdb_result *result, idx_t col, idx_t row);
-	int8_t (*duckdb_value_int8)(duckdb_result *result, idx_t col, idx_t row);
-	int16_t (*duckdb_value_int16)(duckdb_result *result, idx_t col, idx_t row);
-	int32_t (*duckdb_value_int32)(duckdb_result *result, idx_t col, idx_t row);
-	int64_t (*duckdb_value_int64)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_hugeint (*duckdb_value_hugeint)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_uhugeint (*duckdb_value_uhugeint)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_decimal (*duckdb_value_decimal)(duckdb_result *result, idx_t col, idx_t row);
-	uint8_t (*duckdb_value_uint8)(duckdb_result *result, idx_t col, idx_t row);
-	uint16_t (*duckdb_value_uint16)(duckdb_result *result, idx_t col, idx_t row);
-	uint32_t (*duckdb_value_uint32)(duckdb_result *result, idx_t col, idx_t row);
-	uint64_t (*duckdb_value_uint64)(duckdb_result *result, idx_t col, idx_t row);
-	float (*duckdb_value_float)(duckdb_result *result, idx_t col, idx_t row);
-	double (*duckdb_value_double)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_date (*duckdb_value_date)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_time (*duckdb_value_time)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_timestamp (*duckdb_value_timestamp)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_interval (*duckdb_value_interval)(duckdb_result *result, idx_t col, idx_t row);
-	char *(*duckdb_value_varchar)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_string (*duckdb_value_string)(duckdb_result *result, idx_t col, idx_t row);
-	char *(*duckdb_value_varchar_internal)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_string (*duckdb_value_string_internal)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_blob (*duckdb_value_blob)(duckdb_result *result, idx_t col, idx_t row);
-	bool (*duckdb_value_is_null)(duckdb_result *result, idx_t col, idx_t row);
-	duckdb_state (*duckdb_execute_prepared_streaming)(duckdb_prepared_statement prepared_statement,
-	                                                  duckdb_result *out_result);
-	duckdb_state (*duckdb_pending_prepared_streaming)(duckdb_prepared_statement prepared_statement,
-	                                                  duckdb_pending_result *out_result);
-	duckdb_state (*duckdb_query_arrow)(duckdb_connection connection, const char *query, duckdb_arrow *out_result);
-	duckdb_state (*duckdb_query_arrow_schema)(duckdb_arrow result, duckdb_arrow_schema *out_schema);
-	duckdb_state (*duckdb_prepared_arrow_schema)(duckdb_prepared_statement prepared, duckdb_arrow_schema *out_schema);
-	void (*duckdb_result_arrow_array)(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array);
-	duckdb_state (*duckdb_query_arrow_array)(duckdb_arrow result, duckdb_arrow_array *out_array);
-	idx_t (*duckdb_arrow_column_count)(duckdb_arrow result);
-	idx_t (*duckdb_arrow_row_count)(duckdb_arrow result);
-	idx_t (*duckdb_arrow_rows_changed)(duckdb_arrow result);
-	const char *(*duckdb_query_arrow_error)(duckdb_arrow result);
-	void (*duckdb_destroy_arrow)(duckdb_arrow *result);
-	void (*duckdb_destroy_arrow_stream)(duckdb_arrow_stream *stream_p);
-	duckdb_state (*duckdb_execute_prepared_arrow)(duckdb_prepared_statement prepared_statement,
-	                                              duckdb_arrow *out_result);
-	duckdb_state (*duckdb_arrow_scan)(duckdb_connection connection, const char *table_name, duckdb_arrow_stream arrow);
-	duckdb_state (*duckdb_arrow_array_scan)(duckdb_connection connection, const char *table_name,
-	                                        duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
-	                                        duckdb_arrow_stream *out_stream);
-	duckdb_data_chunk (*duckdb_stream_fetch_chunk)(duckdb_result result);
-#endif
-
-// Exposing the instance cache
-#ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE
-	duckdb_instance_cache (*duckdb_create_instance_cache)();
-	duckdb_state (*duckdb_get_or_create_from_cache)(duckdb_instance_cache instance_cache, const char *path,
-	                                                duckdb_database *out_database, duckdb_config config,
-	                                                char **out_error);
-	void (*duckdb_destroy_instance_cache)(duckdb_instance_cache *instance_cache);
-#endif
-
-// New append functions that are added
-#ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE
-	duckdb_state (*duckdb_append_default_to_chunk)(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col,
-	                                               idx_t row);
-#endif
-
-} duckdb_ext_api_v1;
-
-//===--------------------------------------------------------------------===//
-// Typedefs mapping functions to struct entries
-//===--------------------------------------------------------------------===//
-// Version v1.2.0
-#define duckdb_open                                    duckdb_ext_api.duckdb_open
-#define duckdb_open_ext                                duckdb_ext_api.duckdb_open_ext
-#define duckdb_close                                   duckdb_ext_api.duckdb_close
-#define duckdb_connect                                 duckdb_ext_api.duckdb_connect
-#define duckdb_interrupt                               duckdb_ext_api.duckdb_interrupt
-#define duckdb_query_progress                          duckdb_ext_api.duckdb_query_progress
-#define duckdb_disconnect                              duckdb_ext_api.duckdb_disconnect
-#define duckdb_library_version                         duckdb_ext_api.duckdb_library_version
-#define duckdb_create_config                           duckdb_ext_api.duckdb_create_config
-#define duckdb_config_count                            duckdb_ext_api.duckdb_config_count
-#define duckdb_get_config_flag                         duckdb_ext_api.duckdb_get_config_flag
-#define duckdb_set_config                              duckdb_ext_api.duckdb_set_config
-#define duckdb_destroy_config                          duckdb_ext_api.duckdb_destroy_config
-#define duckdb_query                                   duckdb_ext_api.duckdb_query
-#define duckdb_destroy_result                          duckdb_ext_api.duckdb_destroy_result
-#define duckdb_column_name                             duckdb_ext_api.duckdb_column_name
-#define duckdb_column_type                             duckdb_ext_api.duckdb_column_type
-#define duckdb_result_statement_type                   duckdb_ext_api.duckdb_result_statement_type
-#define duckdb_column_logical_type                     duckdb_ext_api.duckdb_column_logical_type
-#define duckdb_column_count                            duckdb_ext_api.duckdb_column_count
-#define duckdb_rows_changed                            duckdb_ext_api.duckdb_rows_changed
-#define duckdb_result_error                            duckdb_ext_api.duckdb_result_error
-#define duckdb_result_error_type                       duckdb_ext_api.duckdb_result_error_type
-#define duckdb_result_return_type                      duckdb_ext_api.duckdb_result_return_type
-#define duckdb_malloc                                  duckdb_ext_api.duckdb_malloc
-#define duckdb_free                                    duckdb_ext_api.duckdb_free
-#define duckdb_vector_size                             duckdb_ext_api.duckdb_vector_size
-#define duckdb_string_is_inlined                       duckdb_ext_api.duckdb_string_is_inlined
-#define duckdb_string_t_length                         duckdb_ext_api.duckdb_string_t_length
-#define duckdb_string_t_data                           duckdb_ext_api.duckdb_string_t_data
-#define duckdb_from_date                               duckdb_ext_api.duckdb_from_date
-#define duckdb_to_date                                 duckdb_ext_api.duckdb_to_date
-#define duckdb_is_finite_date                          duckdb_ext_api.duckdb_is_finite_date
-#define duckdb_from_time                               duckdb_ext_api.duckdb_from_time
-#define duckdb_create_time_tz                          duckdb_ext_api.duckdb_create_time_tz
-#define duckdb_from_time_tz                            duckdb_ext_api.duckdb_from_time_tz
-#define duckdb_to_time                                 duckdb_ext_api.duckdb_to_time
-#define duckdb_from_timestamp                          duckdb_ext_api.duckdb_from_timestamp
-#define duckdb_to_timestamp                            duckdb_ext_api.duckdb_to_timestamp
-#define duckdb_is_finite_timestamp                     duckdb_ext_api.duckdb_is_finite_timestamp
-#define duckdb_is_finite_timestamp_s                   duckdb_ext_api.duckdb_is_finite_timestamp_s
-#define duckdb_is_finite_timestamp_ms                  duckdb_ext_api.duckdb_is_finite_timestamp_ms
-#define duckdb_is_finite_timestamp_ns                  duckdb_ext_api.duckdb_is_finite_timestamp_ns
-#define duckdb_hugeint_to_double                       duckdb_ext_api.duckdb_hugeint_to_double
-#define duckdb_double_to_hugeint                       duckdb_ext_api.duckdb_double_to_hugeint
-#define duckdb_uhugeint_to_double                      duckdb_ext_api.duckdb_uhugeint_to_double
-#define duckdb_double_to_uhugeint                      duckdb_ext_api.duckdb_double_to_uhugeint
-#define duckdb_double_to_decimal                       duckdb_ext_api.duckdb_double_to_decimal
-#define duckdb_decimal_to_double                       duckdb_ext_api.duckdb_decimal_to_double
-#define duckdb_prepare                                 duckdb_ext_api.duckdb_prepare
-#define duckdb_destroy_prepare                         duckdb_ext_api.duckdb_destroy_prepare
-#define duckdb_prepare_error                           duckdb_ext_api.duckdb_prepare_error
-#define duckdb_nparams                                 duckdb_ext_api.duckdb_nparams
-#define duckdb_parameter_name                          duckdb_ext_api.duckdb_parameter_name
-#define duckdb_param_type                              duckdb_ext_api.duckdb_param_type
-#define duckdb_param_logical_type                      duckdb_ext_api.duckdb_param_logical_type
-#define duckdb_clear_bindings                          duckdb_ext_api.duckdb_clear_bindings
-#define duckdb_prepared_statement_type                 duckdb_ext_api.duckdb_prepared_statement_type
-#define duckdb_bind_value                              duckdb_ext_api.duckdb_bind_value
-#define duckdb_bind_parameter_index                    duckdb_ext_api.duckdb_bind_parameter_index
-#define duckdb_bind_boolean                            duckdb_ext_api.duckdb_bind_boolean
-#define duckdb_bind_int8                               duckdb_ext_api.duckdb_bind_int8
-#define duckdb_bind_int16                              duckdb_ext_api.duckdb_bind_int16
-#define duckdb_bind_int32                              duckdb_ext_api.duckdb_bind_int32
-#define duckdb_bind_int64                              duckdb_ext_api.duckdb_bind_int64
-#define duckdb_bind_hugeint                            duckdb_ext_api.duckdb_bind_hugeint
-#define duckdb_bind_uhugeint                           duckdb_ext_api.duckdb_bind_uhugeint
-#define duckdb_bind_decimal                            duckdb_ext_api.duckdb_bind_decimal
-#define duckdb_bind_uint8                              duckdb_ext_api.duckdb_bind_uint8
-#define duckdb_bind_uint16                             duckdb_ext_api.duckdb_bind_uint16
-#define duckdb_bind_uint32                             duckdb_ext_api.duckdb_bind_uint32
-#define duckdb_bind_uint64                             duckdb_ext_api.duckdb_bind_uint64
-#define duckdb_bind_float                              duckdb_ext_api.duckdb_bind_float
-#define duckdb_bind_double                             duckdb_ext_api.duckdb_bind_double
-#define duckdb_bind_date                               duckdb_ext_api.duckdb_bind_date
-#define duckdb_bind_time                               duckdb_ext_api.duckdb_bind_time
-#define duckdb_bind_timestamp                          duckdb_ext_api.duckdb_bind_timestamp
-#define duckdb_bind_timestamp_tz                       duckdb_ext_api.duckdb_bind_timestamp_tz
-#define duckdb_bind_interval                           duckdb_ext_api.duckdb_bind_interval
-#define duckdb_bind_varchar                            duckdb_ext_api.duckdb_bind_varchar
-#define duckdb_bind_varchar_length                     duckdb_ext_api.duckdb_bind_varchar_length
-#define duckdb_bind_blob                               duckdb_ext_api.duckdb_bind_blob
-#define duckdb_bind_null                               duckdb_ext_api.duckdb_bind_null
-#define duckdb_execute_prepared                        duckdb_ext_api.duckdb_execute_prepared
-#define duckdb_extract_statements                      duckdb_ext_api.duckdb_extract_statements
-#define duckdb_prepare_extracted_statement             duckdb_ext_api.duckdb_prepare_extracted_statement
-#define duckdb_extract_statements_error                duckdb_ext_api.duckdb_extract_statements_error
-#define duckdb_destroy_extracted                       duckdb_ext_api.duckdb_destroy_extracted
-#define duckdb_pending_prepared                        duckdb_ext_api.duckdb_pending_prepared
-#define duckdb_destroy_pending                         duckdb_ext_api.duckdb_destroy_pending
-#define duckdb_pending_error                           duckdb_ext_api.duckdb_pending_error
-#define duckdb_pending_execute_task                    duckdb_ext_api.duckdb_pending_execute_task
-#define duckdb_pending_execute_check_state             duckdb_ext_api.duckdb_pending_execute_check_state
-#define duckdb_execute_pending                         duckdb_ext_api.duckdb_execute_pending
-#define duckdb_pending_execution_is_finished           duckdb_ext_api.duckdb_pending_execution_is_finished
-#define duckdb_destroy_value                           duckdb_ext_api.duckdb_destroy_value
-#define duckdb_create_varchar                          duckdb_ext_api.duckdb_create_varchar
-#define duckdb_create_varchar_length                   duckdb_ext_api.duckdb_create_varchar_length
-#define duckdb_create_bool                             duckdb_ext_api.duckdb_create_bool
-#define duckdb_create_int8                             duckdb_ext_api.duckdb_create_int8
-#define duckdb_create_uint8                            duckdb_ext_api.duckdb_create_uint8
-#define duckdb_create_int16                            duckdb_ext_api.duckdb_create_int16
-#define duckdb_create_uint16                           duckdb_ext_api.duckdb_create_uint16
-#define duckdb_create_int32                            duckdb_ext_api.duckdb_create_int32
-#define duckdb_create_uint32                           duckdb_ext_api.duckdb_create_uint32
-#define duckdb_create_uint64                           duckdb_ext_api.duckdb_create_uint64
-#define duckdb_create_int64                            duckdb_ext_api.duckdb_create_int64
-#define duckdb_create_hugeint                          duckdb_ext_api.duckdb_create_hugeint
-#define duckdb_create_uhugeint                         duckdb_ext_api.duckdb_create_uhugeint
-#define duckdb_create_varint                           duckdb_ext_api.duckdb_create_varint
-#define duckdb_create_decimal                          duckdb_ext_api.duckdb_create_decimal
-#define duckdb_create_float                            duckdb_ext_api.duckdb_create_float
-#define duckdb_create_double                           duckdb_ext_api.duckdb_create_double
-#define duckdb_create_date                             duckdb_ext_api.duckdb_create_date
-#define duckdb_create_time                             duckdb_ext_api.duckdb_create_time
-#define duckdb_create_time_tz_value                    duckdb_ext_api.duckdb_create_time_tz_value
-#define duckdb_create_timestamp                        duckdb_ext_api.duckdb_create_timestamp
-#define duckdb_create_timestamp_tz                     duckdb_ext_api.duckdb_create_timestamp_tz
-#define duckdb_create_timestamp_s                      duckdb_ext_api.duckdb_create_timestamp_s
-#define duckdb_create_timestamp_ms                     duckdb_ext_api.duckdb_create_timestamp_ms
-#define duckdb_create_timestamp_ns                     duckdb_ext_api.duckdb_create_timestamp_ns
-#define duckdb_create_interval                         duckdb_ext_api.duckdb_create_interval
-#define duckdb_create_blob                             duckdb_ext_api.duckdb_create_blob
-#define duckdb_create_bit                              duckdb_ext_api.duckdb_create_bit
-#define duckdb_create_uuid                             duckdb_ext_api.duckdb_create_uuid
-#define duckdb_get_bool                                duckdb_ext_api.duckdb_get_bool
-#define duckdb_get_int8                                duckdb_ext_api.duckdb_get_int8
-#define duckdb_get_uint8                               duckdb_ext_api.duckdb_get_uint8
-#define duckdb_get_int16                               duckdb_ext_api.duckdb_get_int16
-#define duckdb_get_uint16                              duckdb_ext_api.duckdb_get_uint16
-#define duckdb_get_int32                               duckdb_ext_api.duckdb_get_int32
-#define duckdb_get_uint32                              duckdb_ext_api.duckdb_get_uint32
-#define duckdb_get_int64                               duckdb_ext_api.duckdb_get_int64
-#define duckdb_get_uint64                              duckdb_ext_api.duckdb_get_uint64
-#define duckdb_get_hugeint                             duckdb_ext_api.duckdb_get_hugeint
-#define duckdb_get_uhugeint                            duckdb_ext_api.duckdb_get_uhugeint
-#define duckdb_get_varint                              duckdb_ext_api.duckdb_get_varint
-#define duckdb_get_decimal                             duckdb_ext_api.duckdb_get_decimal
-#define duckdb_get_float                               duckdb_ext_api.duckdb_get_float
-#define duckdb_get_double                              duckdb_ext_api.duckdb_get_double
-#define duckdb_get_date                                duckdb_ext_api.duckdb_get_date
-#define duckdb_get_time                                duckdb_ext_api.duckdb_get_time
-#define duckdb_get_time_tz                             duckdb_ext_api.duckdb_get_time_tz
-#define duckdb_get_timestamp                           duckdb_ext_api.duckdb_get_timestamp
-#define duckdb_get_timestamp_tz                        duckdb_ext_api.duckdb_get_timestamp_tz
-#define duckdb_get_timestamp_s                         duckdb_ext_api.duckdb_get_timestamp_s
-#define duckdb_get_timestamp_ms                        duckdb_ext_api.duckdb_get_timestamp_ms
-#define duckdb_get_timestamp_ns                        duckdb_ext_api.duckdb_get_timestamp_ns
-#define duckdb_get_interval                            duckdb_ext_api.duckdb_get_interval
-#define duckdb_get_value_type                          duckdb_ext_api.duckdb_get_value_type
-#define duckdb_get_blob                                duckdb_ext_api.duckdb_get_blob
-#define duckdb_get_bit                                 duckdb_ext_api.duckdb_get_bit
-#define duckdb_get_uuid                                duckdb_ext_api.duckdb_get_uuid
-#define duckdb_get_varchar                             duckdb_ext_api.duckdb_get_varchar
-#define duckdb_create_struct_value                     duckdb_ext_api.duckdb_create_struct_value
-#define duckdb_create_list_value                       duckdb_ext_api.duckdb_create_list_value
-#define duckdb_create_array_value                      duckdb_ext_api.duckdb_create_array_value
-#define duckdb_get_map_size                            duckdb_ext_api.duckdb_get_map_size
-#define duckdb_get_map_key                             duckdb_ext_api.duckdb_get_map_key
-#define duckdb_get_map_value                           duckdb_ext_api.duckdb_get_map_value
-#define duckdb_is_null_value                           duckdb_ext_api.duckdb_is_null_value
-#define duckdb_create_null_value                       duckdb_ext_api.duckdb_create_null_value
-#define duckdb_get_list_size                           duckdb_ext_api.duckdb_get_list_size
-#define duckdb_get_list_child                          duckdb_ext_api.duckdb_get_list_child
-#define duckdb_create_enum_value                       duckdb_ext_api.duckdb_create_enum_value
-#define duckdb_get_enum_value                          duckdb_ext_api.duckdb_get_enum_value
-#define duckdb_get_struct_child                        duckdb_ext_api.duckdb_get_struct_child
-#define duckdb_create_logical_type                     duckdb_ext_api.duckdb_create_logical_type
-#define duckdb_logical_type_get_alias                  duckdb_ext_api.duckdb_logical_type_get_alias
-#define duckdb_logical_type_set_alias                  duckdb_ext_api.duckdb_logical_type_set_alias
-#define duckdb_create_list_type                        duckdb_ext_api.duckdb_create_list_type
-#define duckdb_create_array_type                       duckdb_ext_api.duckdb_create_array_type
-#define duckdb_create_map_type                         duckdb_ext_api.duckdb_create_map_type
-#define duckdb_create_union_type                       duckdb_ext_api.duckdb_create_union_type
-#define duckdb_create_struct_type                      duckdb_ext_api.duckdb_create_struct_type
-#define duckdb_create_enum_type                        duckdb_ext_api.duckdb_create_enum_type
-#define duckdb_create_decimal_type                     duckdb_ext_api.duckdb_create_decimal_type
-#define duckdb_get_type_id                             duckdb_ext_api.duckdb_get_type_id
-#define duckdb_decimal_width                           duckdb_ext_api.duckdb_decimal_width
-#define duckdb_decimal_scale                           duckdb_ext_api.duckdb_decimal_scale
-#define duckdb_decimal_internal_type                   duckdb_ext_api.duckdb_decimal_internal_type
-#define duckdb_enum_internal_type                      duckdb_ext_api.duckdb_enum_internal_type
-#define duckdb_enum_dictionary_size                    duckdb_ext_api.duckdb_enum_dictionary_size
-#define duckdb_enum_dictionary_value                   duckdb_ext_api.duckdb_enum_dictionary_value
-#define duckdb_list_type_child_type                    duckdb_ext_api.duckdb_list_type_child_type
-#define duckdb_array_type_child_type                   duckdb_ext_api.duckdb_array_type_child_type
-#define duckdb_array_type_array_size                   duckdb_ext_api.duckdb_array_type_array_size
-#define duckdb_map_type_key_type                       duckdb_ext_api.duckdb_map_type_key_type
-#define duckdb_map_type_value_type                     duckdb_ext_api.duckdb_map_type_value_type
-#define duckdb_struct_type_child_count                 duckdb_ext_api.duckdb_struct_type_child_count
-#define duckdb_struct_type_child_name                  duckdb_ext_api.duckdb_struct_type_child_name
-#define duckdb_struct_type_child_type                  duckdb_ext_api.duckdb_struct_type_child_type
-#define duckdb_union_type_member_count                 duckdb_ext_api.duckdb_union_type_member_count
-#define duckdb_union_type_member_name                  duckdb_ext_api.duckdb_union_type_member_name
-#define duckdb_union_type_member_type                  duckdb_ext_api.duckdb_union_type_member_type
-#define duckdb_destroy_logical_type                    duckdb_ext_api.duckdb_destroy_logical_type
-#define duckdb_register_logical_type                   duckdb_ext_api.duckdb_register_logical_type
-#define duckdb_create_data_chunk                       duckdb_ext_api.duckdb_create_data_chunk
-#define duckdb_destroy_data_chunk                      duckdb_ext_api.duckdb_destroy_data_chunk
-#define duckdb_data_chunk_reset                        duckdb_ext_api.duckdb_data_chunk_reset
-#define duckdb_data_chunk_get_column_count             duckdb_ext_api.duckdb_data_chunk_get_column_count
-#define duckdb_data_chunk_get_vector                   duckdb_ext_api.duckdb_data_chunk_get_vector
-#define duckdb_data_chunk_get_size                     duckdb_ext_api.duckdb_data_chunk_get_size
-#define duckdb_data_chunk_set_size                     duckdb_ext_api.duckdb_data_chunk_set_size
-#define duckdb_vector_get_column_type                  duckdb_ext_api.duckdb_vector_get_column_type
-#define duckdb_vector_get_data                         duckdb_ext_api.duckdb_vector_get_data
-#define duckdb_vector_get_validity                     duckdb_ext_api.duckdb_vector_get_validity
-#define duckdb_vector_ensure_validity_writable         duckdb_ext_api.duckdb_vector_ensure_validity_writable
-#define duckdb_vector_assign_string_element            duckdb_ext_api.duckdb_vector_assign_string_element
-#define duckdb_vector_assign_string_element_len        duckdb_ext_api.duckdb_vector_assign_string_element_len
-#define duckdb_list_vector_get_child                   duckdb_ext_api.duckdb_list_vector_get_child
-#define duckdb_list_vector_get_size                    duckdb_ext_api.duckdb_list_vector_get_size
-#define duckdb_list_vector_set_size                    duckdb_ext_api.duckdb_list_vector_set_size
-#define duckdb_list_vector_reserve                     duckdb_ext_api.duckdb_list_vector_reserve
-#define duckdb_struct_vector_get_child                 duckdb_ext_api.duckdb_struct_vector_get_child
-#define duckdb_array_vector_get_child                  duckdb_ext_api.duckdb_array_vector_get_child
-#define duckdb_validity_row_is_valid                   duckdb_ext_api.duckdb_validity_row_is_valid
-#define duckdb_validity_set_row_validity               duckdb_ext_api.duckdb_validity_set_row_validity
-#define duckdb_validity_set_row_invalid                duckdb_ext_api.duckdb_validity_set_row_invalid
-#define duckdb_validity_set_row_valid                  duckdb_ext_api.duckdb_validity_set_row_valid
-#define duckdb_create_scalar_function                  duckdb_ext_api.duckdb_create_scalar_function
-#define duckdb_destroy_scalar_function                 duckdb_ext_api.duckdb_destroy_scalar_function
-#define duckdb_scalar_function_set_name                duckdb_ext_api.duckdb_scalar_function_set_name
-#define duckdb_scalar_function_set_varargs             duckdb_ext_api.duckdb_scalar_function_set_varargs
-#define duckdb_scalar_function_set_special_handling    duckdb_ext_api.duckdb_scalar_function_set_special_handling
-#define duckdb_scalar_function_set_volatile            duckdb_ext_api.duckdb_scalar_function_set_volatile
-#define duckdb_scalar_function_add_parameter           duckdb_ext_api.duckdb_scalar_function_add_parameter
-#define duckdb_scalar_function_set_return_type         duckdb_ext_api.duckdb_scalar_function_set_return_type
-#define duckdb_scalar_function_set_extra_info          duckdb_ext_api.duckdb_scalar_function_set_extra_info
-#define duckdb_scalar_function_set_function            duckdb_ext_api.duckdb_scalar_function_set_function
-#define duckdb_register_scalar_function                duckdb_ext_api.duckdb_register_scalar_function
-#define duckdb_scalar_function_get_extra_info          duckdb_ext_api.duckdb_scalar_function_get_extra_info
-#define duckdb_scalar_function_set_error               duckdb_ext_api.duckdb_scalar_function_set_error
-#define duckdb_create_scalar_function_set              duckdb_ext_api.duckdb_create_scalar_function_set
-#define duckdb_destroy_scalar_function_set             duckdb_ext_api.duckdb_destroy_scalar_function_set
-#define duckdb_add_scalar_function_to_set              duckdb_ext_api.duckdb_add_scalar_function_to_set
-#define duckdb_register_scalar_function_set            duckdb_ext_api.duckdb_register_scalar_function_set
-#define duckdb_create_aggregate_function               duckdb_ext_api.duckdb_create_aggregate_function
-#define duckdb_destroy_aggregate_function              duckdb_ext_api.duckdb_destroy_aggregate_function
-#define duckdb_aggregate_function_set_name             duckdb_ext_api.duckdb_aggregate_function_set_name
-#define duckdb_aggregate_function_add_parameter        duckdb_ext_api.duckdb_aggregate_function_add_parameter
-#define duckdb_aggregate_function_set_return_type      duckdb_ext_api.duckdb_aggregate_function_set_return_type
-#define duckdb_aggregate_function_set_functions        duckdb_ext_api.duckdb_aggregate_function_set_functions
-#define duckdb_aggregate_function_set_destructor       duckdb_ext_api.duckdb_aggregate_function_set_destructor
-#define duckdb_register_aggregate_function             duckdb_ext_api.duckdb_register_aggregate_function
-#define duckdb_aggregate_function_set_special_handling duckdb_ext_api.duckdb_aggregate_function_set_special_handling
-#define duckdb_aggregate_function_set_extra_info       duckdb_ext_api.duckdb_aggregate_function_set_extra_info
-#define duckdb_aggregate_function_get_extra_info       duckdb_ext_api.duckdb_aggregate_function_get_extra_info
-#define duckdb_aggregate_function_set_error            duckdb_ext_api.duckdb_aggregate_function_set_error
-#define duckdb_create_aggregate_function_set           duckdb_ext_api.duckdb_create_aggregate_function_set
-#define duckdb_destroy_aggregate_function_set          duckdb_ext_api.duckdb_destroy_aggregate_function_set
-#define duckdb_add_aggregate_function_to_set           duckdb_ext_api.duckdb_add_aggregate_function_to_set
-#define duckdb_register_aggregate_function_set         duckdb_ext_api.duckdb_register_aggregate_function_set
-#define duckdb_create_table_function                   duckdb_ext_api.duckdb_create_table_function
-#define duckdb_destroy_table_function                  duckdb_ext_api.duckdb_destroy_table_function
-#define duckdb_table_function_set_name                 duckdb_ext_api.duckdb_table_function_set_name
-#define duckdb_table_function_add_parameter            duckdb_ext_api.duckdb_table_function_add_parameter
-#define duckdb_table_function_add_named_parameter      duckdb_ext_api.duckdb_table_function_add_named_parameter
-#define duckdb_table_function_set_extra_info           duckdb_ext_api.duckdb_table_function_set_extra_info
-#define duckdb_table_function_set_bind                 duckdb_ext_api.duckdb_table_function_set_bind
-#define duckdb_table_function_set_init                 duckdb_ext_api.duckdb_table_function_set_init
-#define duckdb_table_function_set_local_init           duckdb_ext_api.duckdb_table_function_set_local_init
-#define duckdb_table_function_set_function             duckdb_ext_api.duckdb_table_function_set_function
-#define duckdb_table_function_supports_projection_pushdown                                                             \
-	duckdb_ext_api.duckdb_table_function_supports_projection_pushdown
-#define duckdb_register_table_function              duckdb_ext_api.duckdb_register_table_function
-#define duckdb_bind_get_extra_info                  duckdb_ext_api.duckdb_bind_get_extra_info
-#define duckdb_bind_add_result_column               duckdb_ext_api.duckdb_bind_add_result_column
-#define duckdb_bind_get_parameter_count             duckdb_ext_api.duckdb_bind_get_parameter_count
-#define duckdb_bind_get_parameter                   duckdb_ext_api.duckdb_bind_get_parameter
-#define duckdb_bind_get_named_parameter             duckdb_ext_api.duckdb_bind_get_named_parameter
-#define duckdb_bind_set_bind_data                   duckdb_ext_api.duckdb_bind_set_bind_data
-#define duckdb_bind_set_cardinality                 duckdb_ext_api.duckdb_bind_set_cardinality
-#define duckdb_bind_set_error                       duckdb_ext_api.duckdb_bind_set_error
-#define duckdb_init_get_extra_info                  duckdb_ext_api.duckdb_init_get_extra_info
-#define duckdb_init_get_bind_data                   duckdb_ext_api.duckdb_init_get_bind_data
-#define duckdb_init_set_init_data                   duckdb_ext_api.duckdb_init_set_init_data
-#define duckdb_init_get_column_count                duckdb_ext_api.duckdb_init_get_column_count
-#define duckdb_init_get_column_index                duckdb_ext_api.duckdb_init_get_column_index
-#define duckdb_init_set_max_threads                 duckdb_ext_api.duckdb_init_set_max_threads
-#define duckdb_init_set_error                       duckdb_ext_api.duckdb_init_set_error
-#define duckdb_function_get_extra_info              duckdb_ext_api.duckdb_function_get_extra_info
-#define duckdb_function_get_bind_data               duckdb_ext_api.duckdb_function_get_bind_data
-#define duckdb_function_get_init_data               duckdb_ext_api.duckdb_function_get_init_data
-#define duckdb_function_get_local_init_data         duckdb_ext_api.duckdb_function_get_local_init_data
-#define duckdb_function_set_error                   duckdb_ext_api.duckdb_function_set_error
-#define duckdb_add_replacement_scan                 duckdb_ext_api.duckdb_add_replacement_scan
-#define duckdb_replacement_scan_set_function_name   duckdb_ext_api.duckdb_replacement_scan_set_function_name
-#define duckdb_replacement_scan_add_parameter       duckdb_ext_api.duckdb_replacement_scan_add_parameter
-#define duckdb_replacement_scan_set_error           duckdb_ext_api.duckdb_replacement_scan_set_error
-#define duckdb_get_profiling_info                   duckdb_ext_api.duckdb_get_profiling_info
-#define duckdb_profiling_info_get_value             duckdb_ext_api.duckdb_profiling_info_get_value
-#define duckdb_profiling_info_get_metrics           duckdb_ext_api.duckdb_profiling_info_get_metrics
-#define duckdb_profiling_info_get_child_count       duckdb_ext_api.duckdb_profiling_info_get_child_count
-#define duckdb_profiling_info_get_child             duckdb_ext_api.duckdb_profiling_info_get_child
-#define duckdb_appender_create                      duckdb_ext_api.duckdb_appender_create
-#define duckdb_appender_create_ext                  duckdb_ext_api.duckdb_appender_create_ext
-#define duckdb_appender_column_count                duckdb_ext_api.duckdb_appender_column_count
-#define duckdb_appender_column_type                 duckdb_ext_api.duckdb_appender_column_type
-#define duckdb_appender_error                       duckdb_ext_api.duckdb_appender_error
-#define duckdb_appender_flush                       duckdb_ext_api.duckdb_appender_flush
-#define duckdb_appender_close                       duckdb_ext_api.duckdb_appender_close
-#define duckdb_appender_destroy                     duckdb_ext_api.duckdb_appender_destroy
-#define duckdb_appender_add_column                  duckdb_ext_api.duckdb_appender_add_column
-#define duckdb_appender_clear_columns               duckdb_ext_api.duckdb_appender_clear_columns
-#define duckdb_appender_begin_row                   duckdb_ext_api.duckdb_appender_begin_row
-#define duckdb_appender_end_row                     duckdb_ext_api.duckdb_appender_end_row
-#define duckdb_append_default                       duckdb_ext_api.duckdb_append_default
-#define duckdb_append_bool                          duckdb_ext_api.duckdb_append_bool
-#define duckdb_append_int8                          duckdb_ext_api.duckdb_append_int8
-#define duckdb_append_int16                         duckdb_ext_api.duckdb_append_int16
-#define duckdb_append_int32                         duckdb_ext_api.duckdb_append_int32
-#define duckdb_append_int64                         duckdb_ext_api.duckdb_append_int64
-#define duckdb_append_hugeint                       duckdb_ext_api.duckdb_append_hugeint
-#define duckdb_append_uint8                         duckdb_ext_api.duckdb_append_uint8
-#define duckdb_append_uint16                        duckdb_ext_api.duckdb_append_uint16
-#define duckdb_append_uint32                        duckdb_ext_api.duckdb_append_uint32
-#define duckdb_append_uint64                        duckdb_ext_api.duckdb_append_uint64
-#define duckdb_append_uhugeint                      duckdb_ext_api.duckdb_append_uhugeint
-#define duckdb_append_float                         duckdb_ext_api.duckdb_append_float
-#define duckdb_append_double                        duckdb_ext_api.duckdb_append_double
-#define duckdb_append_date                          duckdb_ext_api.duckdb_append_date
-#define duckdb_append_time                          duckdb_ext_api.duckdb_append_time
-#define duckdb_append_timestamp                     duckdb_ext_api.duckdb_append_timestamp
-#define duckdb_append_interval                      duckdb_ext_api.duckdb_append_interval
-#define duckdb_append_varchar                       duckdb_ext_api.duckdb_append_varchar
-#define duckdb_append_varchar_length                duckdb_ext_api.duckdb_append_varchar_length
-#define duckdb_append_blob                          duckdb_ext_api.duckdb_append_blob
-#define duckdb_append_null                          duckdb_ext_api.duckdb_append_null
-#define duckdb_append_value                         duckdb_ext_api.duckdb_append_value
-#define duckdb_append_data_chunk                    duckdb_ext_api.duckdb_append_data_chunk
-#define duckdb_table_description_create             duckdb_ext_api.duckdb_table_description_create
-#define duckdb_table_description_create_ext         duckdb_ext_api.duckdb_table_description_create_ext
-#define duckdb_table_description_destroy            duckdb_ext_api.duckdb_table_description_destroy
-#define duckdb_table_description_error              duckdb_ext_api.duckdb_table_description_error
-#define duckdb_column_has_default                   duckdb_ext_api.duckdb_column_has_default
-#define duckdb_table_description_get_column_name    duckdb_ext_api.duckdb_table_description_get_column_name
-#define duckdb_execute_tasks                        duckdb_ext_api.duckdb_execute_tasks
-#define duckdb_create_task_state                    duckdb_ext_api.duckdb_create_task_state
-#define duckdb_execute_tasks_state                  duckdb_ext_api.duckdb_execute_tasks_state
-#define duckdb_execute_n_tasks_state                duckdb_ext_api.duckdb_execute_n_tasks_state
-#define duckdb_finish_execution                     duckdb_ext_api.duckdb_finish_execution
-#define duckdb_task_state_is_finished               duckdb_ext_api.duckdb_task_state_is_finished
-#define duckdb_destroy_task_state                   duckdb_ext_api.duckdb_destroy_task_state
-#define duckdb_execution_is_finished                duckdb_ext_api.duckdb_execution_is_finished
-#define duckdb_fetch_chunk                          duckdb_ext_api.duckdb_fetch_chunk
-#define duckdb_create_cast_function                 duckdb_ext_api.duckdb_create_cast_function
-#define duckdb_cast_function_set_source_type        duckdb_ext_api.duckdb_cast_function_set_source_type
-#define duckdb_cast_function_set_target_type        duckdb_ext_api.duckdb_cast_function_set_target_type
-#define duckdb_cast_function_set_implicit_cast_cost duckdb_ext_api.duckdb_cast_function_set_implicit_cast_cost
-#define duckdb_cast_function_set_function           duckdb_ext_api.duckdb_cast_function_set_function
-#define duckdb_cast_function_set_extra_info         duckdb_ext_api.duckdb_cast_function_set_extra_info
-#define duckdb_cast_function_get_extra_info         duckdb_ext_api.duckdb_cast_function_get_extra_info
-#define duckdb_cast_function_get_cast_mode          duckdb_ext_api.duckdb_cast_function_get_cast_mode
-#define duckdb_cast_function_set_error              duckdb_ext_api.duckdb_cast_function_set_error
-#define duckdb_cast_function_set_row_error          duckdb_ext_api.duckdb_cast_function_set_row_error
-#define duckdb_register_cast_function               duckdb_ext_api.duckdb_register_cast_function
-#define duckdb_destroy_cast_function                duckdb_ext_api.duckdb_destroy_cast_function
-
-// Version unstable_deprecated
-#define duckdb_row_count                  duckdb_ext_api.duckdb_row_count
-#define duckdb_column_data                duckdb_ext_api.duckdb_column_data
-#define duckdb_nullmask_data              duckdb_ext_api.duckdb_nullmask_data
-#define duckdb_result_get_chunk           duckdb_ext_api.duckdb_result_get_chunk
-#define duckdb_result_is_streaming        duckdb_ext_api.duckdb_result_is_streaming
-#define duckdb_result_chunk_count         duckdb_ext_api.duckdb_result_chunk_count
-#define duckdb_value_boolean              duckdb_ext_api.duckdb_value_boolean
-#define duckdb_value_int8                 duckdb_ext_api.duckdb_value_int8
-#define duckdb_value_int16                duckdb_ext_api.duckdb_value_int16
-#define duckdb_value_int32                duckdb_ext_api.duckdb_value_int32
-#define duckdb_value_int64                duckdb_ext_api.duckdb_value_int64
-#define duckdb_value_hugeint              duckdb_ext_api.duckdb_value_hugeint
-#define duckdb_value_uhugeint             duckdb_ext_api.duckdb_value_uhugeint
-#define duckdb_value_decimal              duckdb_ext_api.duckdb_value_decimal
-#define duckdb_value_uint8                duckdb_ext_api.duckdb_value_uint8
-#define duckdb_value_uint16               duckdb_ext_api.duckdb_value_uint16
-#define duckdb_value_uint32               duckdb_ext_api.duckdb_value_uint32
-#define duckdb_value_uint64               duckdb_ext_api.duckdb_value_uint64
-#define duckdb_value_float                duckdb_ext_api.duckdb_value_float
-#define duckdb_value_double               duckdb_ext_api.duckdb_value_double
-#define duckdb_value_date                 duckdb_ext_api.duckdb_value_date
-#define duckdb_value_time                 duckdb_ext_api.duckdb_value_time
-#define duckdb_value_timestamp            duckdb_ext_api.duckdb_value_timestamp
-#define duckdb_value_interval             duckdb_ext_api.duckdb_value_interval
-#define duckdb_value_varchar              duckdb_ext_api.duckdb_value_varchar
-#define duckdb_value_string               duckdb_ext_api.duckdb_value_string
-#define duckdb_value_varchar_internal     duckdb_ext_api.duckdb_value_varchar_internal
-#define duckdb_value_string_internal      duckdb_ext_api.duckdb_value_string_internal
-#define duckdb_value_blob                 duckdb_ext_api.duckdb_value_blob
-#define duckdb_value_is_null              duckdb_ext_api.duckdb_value_is_null
-#define duckdb_execute_prepared_streaming duckdb_ext_api.duckdb_execute_prepared_streaming
-#define duckdb_pending_prepared_streaming duckdb_ext_api.duckdb_pending_prepared_streaming
-#define duckdb_query_arrow                duckdb_ext_api.duckdb_query_arrow
-#define duckdb_query_arrow_schema         duckdb_ext_api.duckdb_query_arrow_schema
-#define duckdb_prepared_arrow_schema      duckdb_ext_api.duckdb_prepared_arrow_schema
-#define duckdb_result_arrow_array         duckdb_ext_api.duckdb_result_arrow_array
-#define duckdb_query_arrow_array          duckdb_ext_api.duckdb_query_arrow_array
-#define duckdb_arrow_column_count         duckdb_ext_api.duckdb_arrow_column_count
-#define duckdb_arrow_row_count            duckdb_ext_api.duckdb_arrow_row_count
-#define duckdb_arrow_rows_changed         duckdb_ext_api.duckdb_arrow_rows_changed
-#define duckdb_query_arrow_error          duckdb_ext_api.duckdb_query_arrow_error
-#define duckdb_destroy_arrow              duckdb_ext_api.duckdb_destroy_arrow
-#define duckdb_destroy_arrow_stream       duckdb_ext_api.duckdb_destroy_arrow_stream
-#define duckdb_execute_prepared_arrow     duckdb_ext_api.duckdb_execute_prepared_arrow
-#define duckdb_arrow_scan                 duckdb_ext_api.duckdb_arrow_scan
-#define duckdb_arrow_array_scan           duckdb_ext_api.duckdb_arrow_array_scan
-#define duckdb_stream_fetch_chunk         duckdb_ext_api.duckdb_stream_fetch_chunk
-
-// Version unstable_instance_cache
-#define duckdb_create_instance_cache    duckdb_ext_api.duckdb_create_instance_cache
-#define duckdb_get_or_create_from_cache duckdb_ext_api.duckdb_get_or_create_from_cache
-#define duckdb_destroy_instance_cache   duckdb_ext_api.duckdb_destroy_instance_cache
-
-// Version unstable_new_append_functions
-#define duckdb_append_default_to_chunk duckdb_ext_api.duckdb_append_default_to_chunk
-
-//===--------------------------------------------------------------------===//
-// Struct Global Macros
-//===--------------------------------------------------------------------===//
-// This goes in the c/c++ file containing the entrypoint (handle
-#define DUCKDB_EXTENSION_GLOBAL duckdb_ext_api_v1 duckdb_ext_api = {0};
-// Initializes the C Extension API: First thing to call in the extension entrypoint
-#define DUCKDB_EXTENSION_API_INIT(info, access, minimum_api_version)                                                   \
-	duckdb_ext_api_v1 *res = (duckdb_ext_api_v1 *)access->get_api(info, minimum_api_version);                          \
-	if (!res) {                                                                                                        \
-		return false;                                                                                                  \
-	};                                                                                                                 \
-	duckdb_ext_api = *res;
-
-// Place in global scope of any C/C++ file that needs to access the extension API
-#define DUCKDB_EXTENSION_EXTERN extern duckdb_ext_api_v1 duckdb_ext_api;
-
-#ifdef _WIN32
-#define DUCKDB_CAPI_ENTRY_VISIBILITY __declspec(dllexport)
-#else
-#define DUCKDB_CAPI_ENTRY_VISIBILITY __attribute__((visibility("default")))
-#endif
-
-//===--------------------------------------------------------------------===//
-// Entrypoint Macros
-//===--------------------------------------------------------------------===//
-
-// Note: the DUCKDB_EXTENSION_ENTRYPOINT macro requires DUCKDB_EXTENSION_NAME to be set.
-
-#ifdef DUCKDB_EXTENSION_NAME
-
-// Main entrypoint: opens (and closes) a connection automatically for the extension to register its functionality
-// through
-#define DUCKDB_EXTENSION_ENTRYPOINT                                                                                    \
-	DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(            \
-	    duckdb_connection connection, duckdb_extension_info info, struct duckdb_extension_access * access);            \
-	DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_CAPI_ENTRY_VISIBILITY DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \
-	    DUCKDB_EXTENSION_NAME, _init_c_api)(duckdb_extension_info info, struct duckdb_extension_access * access) {     \
-		DUCKDB_EXTENSION_API_INIT(info, access, DUCKDB_EXTENSION_API_VERSION_STRING);                                  \
-		duckdb_database *db = access->get_database(info);                                                              \
-		duckdb_connection conn;                                                                                        \
-		if (duckdb_connect(*db, &conn) == DuckDBError) {                                                               \
-			access->set_error(info, "Failed to open connection to database");                                          \
-			return false;                                                                                              \
-		}                                                                                                              \
-		bool init_result = DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(conn, info, access);     \
-		duckdb_disconnect(&conn);                                                                                      \
-		return init_result;                                                                                            \
-	}                                                                                                                  \
-	DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)
-
-// Custom entrypoint: just forwards the info and access
-#define DUCKDB_EXTENSION_ENTRYPOINT_CUSTOM                                                                             \
-	DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(            \
-	    duckdb_extension_info info, struct duckdb_extension_access * access);                                          \
-	DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_CAPI_ENTRY_VISIBILITY DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \
-	    DUCKDB_EXTENSION_NAME, _init_c_api)(duckdb_extension_info info, struct duckdb_extension_access * access) {     \
-		DUCKDB_EXTENSION_API_INIT(info, access, DUCKDB_EXTENSION_API_VERSION_STRING);                                  \
-		return DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(info, access);                       \
-	}                                                                                                                  \
-	DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)
-#endif
diff --git a/src/duckdb/src/main/appender.cpp b/src/duckdb/src/main/appender.cpp
deleted file mode 100644
index 11a5753a6..000000000
--- a/src/duckdb/src/main/appender.cpp
+++ /dev/null
@@ -1,581 +0,0 @@
-#include "duckdb/main/appender.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/connection.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-BaseAppender::BaseAppender(Allocator &allocator, const AppenderType type_p)
-    : allocator(allocator), column(0), appender_type(type_p) {
-}
-
-BaseAppender::BaseAppender(Allocator &allocator_p, vector<LogicalType> types_p, const AppenderType type_p,
-                           const idx_t flush_count_p)
-    : allocator(allocator_p), types(std::move(types_p)), collection(make_uniq<ColumnDataCollection>(allocator, types)),
-      column(0), appender_type(type_p), flush_count(flush_count_p) {
-	InitializeChunk();
-}
-
-BaseAppender::~BaseAppender() {
-}
-
-void BaseAppender::Destructor() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	// Flush any remaining chunks, if we are not cleaning up as part of an exception stack unwind wrapped in a
-	// try/catch. Close() can throw if the table was dropped in the meantime.
-	try {
-		Close();
-	} catch (...) { // NOLINT
-	}
-}
-
-const vector<LogicalType> &BaseAppender::GetActiveTypes() const {
-	if (active_types.empty()) {
-		return types;
-	}
-	return active_types;
-}
-
-InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p, const idx_t flush_count_p)
-    : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL, flush_count_p),
-      context(context_p), table(table_p) {
-}
-
-InternalAppender::~InternalAppender() {
-	Destructor();
-}
-
-Appender::Appender(Connection &con, const string &database_name, const string &schema_name, const string &table_name)
-    : BaseAppender(Allocator::DefaultAllocator(), AppenderType::LOGICAL), context(con.context) {
-
-	description = con.TableInfo(database_name, schema_name, table_name);
-	if (!description) {
-		throw CatalogException(StringUtil::Format("Table \"%s.%s\" could not be found", schema_name, table_name));
-	}
-	if (description->readonly) {
-		throw InvalidInputException("Cannot append to a readonly database.");
-	}
-
-	vector<optional_ptr<const ParsedExpression>> defaults;
-	for (auto &column : description->columns) {
-		if (column.Generated()) {
-			continue;
-		}
-		types.push_back(column.Type());
-		defaults.push_back(column.HasDefaultValue() ? &column.DefaultValue() : nullptr);
-	}
-
-	auto binder = Binder::CreateBinder(*context);
-	context->RunFunctionInTransaction([&]() {
-		for (idx_t i = 0; i < types.size(); i++) {
-			auto &type = types[i];
-			auto &expr = defaults[i];
-
-			if (!expr) {
-				// The default value is NULL.
-				default_values[i] = Value(type);
-				continue;
-			}
-
-			auto default_copy = expr->Copy();
-			D_ASSERT(!default_copy->HasParameter());
-
-			ConstantBinder default_binder(*binder, *context, "DEFAULT value");
-			default_binder.target_type = type;
-			auto bound_default = default_binder.Bind(default_copy);
-
-			if (!bound_default->IsFoldable()) {
-				// Not supported yet.
-				continue;
-			}
-
-			Value result_value;
-			auto eval_success = ExpressionExecutor::TryEvaluateScalar(*context, *bound_default, result_value);
-			// Insert the default Value.
-			if (eval_success) {
-				default_values[i] = result_value;
-			}
-		}
-	});
-
-	InitializeChunk();
-	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
-}
-
-Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
-    : Appender(con, INVALID_CATALOG, schema_name, table_name) {
-}
-
-Appender::Appender(Connection &con, const string &table_name)
-    : Appender(con, INVALID_CATALOG, DEFAULT_SCHEMA, table_name) {
-}
-
-Appender::~Appender() {
-	Destructor();
-}
-
-void BaseAppender::InitializeChunk() {
-	chunk.Destroy();
-	chunk.Initialize(allocator, GetActiveTypes());
-}
-
-void BaseAppender::BeginRow() {
-}
-
-void BaseAppender::EndRow() {
-	// Ensure that all columns have been appended to.
-	if (column != chunk.ColumnCount()) {
-		throw InvalidInputException("Call to EndRow before all columns have been appended to!");
-	}
-	column = 0;
-	chunk.SetCardinality(chunk.size() + 1);
-	if (chunk.size() >= STANDARD_VECTOR_SIZE) {
-		FlushChunk();
-	}
-}
-
-template <class SRC, class DST>
-void BaseAppender::AppendValueInternal(Vector &col, SRC input) {
-	FlatVector::GetData<DST>(col)[chunk.size()] = Cast::Operation<SRC, DST>(input);
-}
-
-template <class SRC, class DST>
-void BaseAppender::AppendDecimalValueInternal(Vector &col, SRC input) {
-	switch (appender_type) {
-	case AppenderType::LOGICAL: {
-		auto &type = col.GetType();
-		D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		CastParameters parameters;
-		auto &result = FlatVector::GetData<DST>(col)[chunk.size()];
-		TryCastToDecimal::Operation<SRC, DST>(input, result, parameters, width, scale);
-		return;
-	}
-	case AppenderType::PHYSICAL: {
-		AppendValueInternal<SRC, DST>(col, input);
-		return;
-	}
-	default:
-		throw InternalException("Type not implemented for AppenderType");
-	}
-}
-
-template <class T>
-void BaseAppender::AppendValueInternal(T input) {
-	if (column >= GetActiveTypes().size()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	auto &col = chunk.data[column];
-	switch (col.GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		AppendValueInternal<T, bool>(col, input);
-		break;
-	case LogicalTypeId::UTINYINT:
-		AppendValueInternal<T, uint8_t>(col, input);
-		break;
-	case LogicalTypeId::TINYINT:
-		AppendValueInternal<T, int8_t>(col, input);
-		break;
-	case LogicalTypeId::USMALLINT:
-		AppendValueInternal<T, uint16_t>(col, input);
-		break;
-	case LogicalTypeId::SMALLINT:
-		AppendValueInternal<T, int16_t>(col, input);
-		break;
-	case LogicalTypeId::UINTEGER:
-		AppendValueInternal<T, uint32_t>(col, input);
-		break;
-	case LogicalTypeId::INTEGER:
-		AppendValueInternal<T, int32_t>(col, input);
-		break;
-	case LogicalTypeId::UBIGINT:
-		AppendValueInternal<T, uint64_t>(col, input);
-		break;
-	case LogicalTypeId::BIGINT:
-		AppendValueInternal<T, int64_t>(col, input);
-		break;
-	case LogicalTypeId::HUGEINT:
-		AppendValueInternal<T, hugeint_t>(col, input);
-		break;
-	case LogicalTypeId::UHUGEINT:
-		AppendValueInternal<T, uhugeint_t>(col, input);
-		break;
-	case LogicalTypeId::FLOAT:
-		AppendValueInternal<T, float>(col, input);
-		break;
-	case LogicalTypeId::DOUBLE:
-		AppendValueInternal<T, double>(col, input);
-		break;
-	case LogicalTypeId::DECIMAL:
-		switch (col.GetType().InternalType()) {
-		case PhysicalType::INT16:
-			AppendDecimalValueInternal<T, int16_t>(col, input);
-			break;
-		case PhysicalType::INT32:
-			AppendDecimalValueInternal<T, int32_t>(col, input);
-			break;
-		case PhysicalType::INT64:
-			AppendDecimalValueInternal<T, int64_t>(col, input);
-			break;
-		case PhysicalType::INT128:
-			AppendDecimalValueInternal<T, hugeint_t>(col, input);
-			break;
-		default:
-			throw InternalException("Internal type not recognized for Decimal");
-		}
-		break;
-	case LogicalTypeId::DATE:
-		AppendValueInternal<T, date_t>(col, input);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		AppendValueInternal<T, timestamp_t>(col, input);
-		break;
-	case LogicalTypeId::TIME:
-		AppendValueInternal<T, dtime_t>(col, input);
-		break;
-	case LogicalTypeId::TIME_TZ:
-		AppendValueInternal<T, dtime_tz_t>(col, input);
-		break;
-	case LogicalTypeId::INTERVAL:
-		AppendValueInternal<T, interval_t>(col, input);
-		break;
-	case LogicalTypeId::VARCHAR:
-		FlatVector::GetData<string_t>(col)[chunk.size()] = StringCast::Operation<T>(input, col);
-		break;
-	default:
-		AppendValue(Value::CreateValue<T>(input));
-		return;
-	}
-	column++;
-}
-
-template <>
-void BaseAppender::Append(bool value) {
-	AppendValueInternal<bool>(value);
-}
-
-template <>
-void BaseAppender::Append(int8_t value) {
-	AppendValueInternal<int8_t>(value);
-}
-
-template <>
-void BaseAppender::Append(int16_t value) {
-	AppendValueInternal<int16_t>(value);
-}
-
-template <>
-void BaseAppender::Append(int32_t value) {
-	AppendValueInternal<int32_t>(value);
-}
-
-template <>
-void BaseAppender::Append(int64_t value) {
-	AppendValueInternal<int64_t>(value);
-}
-
-template <>
-void BaseAppender::Append(hugeint_t value) {
-	AppendValueInternal<hugeint_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uhugeint_t value) {
-	AppendValueInternal<uhugeint_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint8_t value) {
-	AppendValueInternal<uint8_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint16_t value) {
-	AppendValueInternal<uint16_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint32_t value) {
-	AppendValueInternal<uint32_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint64_t value) {
-	AppendValueInternal<uint64_t>(value);
-}
-
-template <>
-void BaseAppender::Append(const char *value) {
-	AppendValueInternal<string_t>(string_t(value));
-}
-
-void BaseAppender::Append(const char *value, uint32_t length) {
-	AppendValueInternal<string_t>(string_t(value, length));
-}
-
-template <>
-void BaseAppender::Append(string_t value) {
-	AppendValueInternal<string_t>(value);
-}
-
-template <>
-void BaseAppender::Append(float value) {
-	AppendValueInternal<float>(value);
-}
-
-template <>
-void BaseAppender::Append(double value) {
-	AppendValueInternal<double>(value);
-}
-
-template <>
-void BaseAppender::Append(date_t value) {
-	AppendValueInternal<date_t>(value);
-}
-
-template <>
-void BaseAppender::Append(dtime_t value) {
-	AppendValueInternal<dtime_t>(value);
-}
-
-template <>
-void BaseAppender::Append(timestamp_t value) {
-	AppendValueInternal<timestamp_t>(value);
-}
-
-template <>
-void BaseAppender::Append(interval_t value) {
-	AppendValueInternal<interval_t>(value);
-}
-
-template <>
-void BaseAppender::Append(Value value) { // NOLINT: template stuff
-	if (column >= chunk.ColumnCount()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	AppendValue(value);
-}
-
-void duckdb::BaseAppender::Append(DataChunk &target, const Value &value, idx_t col, idx_t row) {
-	if (col >= target.ColumnCount()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	if (row >= target.GetCapacity()) {
-		throw InvalidInputException("Too many rows for chunk!");
-	}
-
-	if (value.type() == target.GetTypes()[col]) {
-		target.SetValue(col, row, value);
-	} else {
-		Value new_value;
-		string error_msg;
-		if (value.DefaultTryCastAs(target.GetTypes()[col], new_value, &error_msg)) {
-			target.SetValue(col, row, new_value);
-		} else {
-			throw InvalidInputException("type mismatch in Append, expected %s, got %s for column %d",
-			                            target.GetTypes()[col], value.type(), col);
-		}
-	}
-}
-
-template <>
-void BaseAppender::Append(std::nullptr_t value) {
-	if (column >= chunk.ColumnCount()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	auto &col = chunk.data[column++];
-	FlatVector::SetNull(col, chunk.size(), true);
-}
-
-void BaseAppender::AppendValue(const Value &value) {
-	chunk.SetValue(column, chunk.size(), value);
-	column++;
-}
-
-void BaseAppender::AppendDataChunk(DataChunk &chunk_p) {
-	auto chunk_types = chunk_p.GetTypes();
-	auto &appender_types = GetActiveTypes();
-
-	// Early-out, if types match.
-	if (chunk_types == appender_types) {
-		collection->Append(chunk_p);
-		if (collection->Count() >= flush_count) {
-			Flush();
-		}
-		return;
-	}
-
-	auto count = chunk_p.ColumnCount();
-	if (count != appender_types.size()) {
-		throw InvalidInputException("incorrect column count in AppendDataChunk, expected %d, got %d",
-		                            appender_types.size(), count);
-	}
-
-	// We try to cast the chunk.
-	auto size = chunk_p.size();
-	DataChunk cast_chunk;
-	cast_chunk.Initialize(allocator, appender_types);
-	cast_chunk.SetCardinality(size);
-
-	for (idx_t i = 0; i < count; i++) {
-		if (chunk_p.data[i].GetType() == appender_types[i]) {
-			cast_chunk.data[i].Reference(chunk_p.data[i]);
-			continue;
-		}
-
-		string error_msg;
-		auto success = VectorOperations::DefaultTryCast(chunk_p.data[i], cast_chunk.data[i], size, &error_msg);
-		if (!success) {
-			throw InvalidInputException("type mismatch in AppendDataChunk, expected %s, got %s for column %d",
-			                            appender_types[i].ToString(), chunk_p.data[i].GetType().ToString(), i);
-		}
-	}
-
-	collection->Append(cast_chunk);
-	if (collection->Count() >= flush_count) {
-		Flush();
-	}
-}
-
-void BaseAppender::FlushChunk() {
-	if (chunk.size() == 0) {
-		return;
-	}
-	collection->Append(chunk);
-	chunk.Reset();
-	if (collection->Count() >= flush_count) {
-		Flush();
-	}
-}
-
-void BaseAppender::Flush() {
-	// Check that all vectors have the same length before appending.
-	if (column != 0) {
-		throw InvalidInputException("Failed to Flush appender: incomplete append to row!");
-	}
-
-	FlushChunk();
-	if (collection->Count() == 0) {
-		return;
-	}
-
-	FlushInternal(*collection);
-	collection->Reset();
-	column = 0;
-}
-
-void Appender::FlushInternal(ColumnDataCollection &collection) {
-	context->Append(*description, collection, &column_ids);
-}
-
-void Appender::AppendDefault() {
-	auto value = GetDefaultValue(column);
-	Append(value);
-}
-
-void duckdb::Appender::AppendDefault(DataChunk &chunk, idx_t col, idx_t row) {
-	auto value = GetDefaultValue(col);
-	Append(chunk, value, col, row);
-}
-
-Value Appender::GetDefaultValue(idx_t column) {
-	auto index = column;
-
-	if (!column_ids.empty()) {
-		if (column >= column_ids.size()) {
-			throw InvalidInputException("Column index out of bounds");
-		}
-		index = column_ids[column].index;
-	}
-
-	auto it = default_values.find(index);
-	if (it == default_values.end()) {
-		auto &name = description->columns[index].Name();
-		throw NotImplementedException(
-		    "AppendDefault is not supported for column \"%s\": not a foldable default expressions.", name);
-	}
-	return it->second;
-}
-
-void Appender::AddColumn(const string &name) {
-	Flush();
-
-	auto exists = false;
-	for (idx_t col_idx = 0; col_idx < description->columns.size(); col_idx++) {
-		auto &col_def = description->columns[col_idx];
-		if (col_def.Name() != name) {
-			continue;
-		}
-
-		// Ensure that we are not adding a generated column.
-		if (col_def.Generated()) {
-			throw InvalidInputException("cannot add a generated column to the appender");
-		}
-
-		// Ensure that we haven't added this column before.
-		for (const auto &column_id : column_ids) {
-			if (column_id == col_def.Logical()) {
-				throw InvalidInputException("cannot add the same column twice");
-			}
-		}
-
-		active_types.push_back(col_def.Type());
-		column_ids.push_back(col_def.Logical());
-		exists = true;
-		break;
-	}
-	if (!exists) {
-		throw InvalidInputException("the column must exist in the table");
-	}
-
-	InitializeChunk();
-	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
-}
-
-void Appender::ClearColumns() {
-	Flush();
-	column_ids.clear();
-	active_types.clear();
-
-	InitializeChunk();
-	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
-}
-
-void InternalAppender::FlushInternal(ColumnDataCollection &collection) {
-	auto binder = Binder::CreateBinder(context);
-	auto bound_constraints = binder->BindConstraints(table);
-	table.GetStorage().LocalAppend(table, context, collection, bound_constraints, nullptr);
-}
-
-void InternalAppender::AddColumn(const string &name) {
-	throw InternalException("AddColumn not implemented for InternalAppender");
-}
-
-void InternalAppender::ClearColumns() {
-	throw InternalException("ClearColumns not implemented for InternalAppender");
-}
-
-void BaseAppender::Close() {
-	if (column == 0 || column == GetActiveTypes().size()) {
-		Flush();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/attached_database.cpp b/src/duckdb/src/main/attached_database.cpp
deleted file mode 100644
index 51546d6c3..000000000
--- a/src/duckdb/src/main/attached_database.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-#include "duckdb/main/attached_database.hpp"
-
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/main/database_path_and_type.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Attach Options
-//===--------------------------------------------------------------------===//
-
-AttachOptions::AttachOptions(const DBConfigOptions &options)
-    : access_mode(options.access_mode), db_type(options.database_type) {
-}
-
-AttachOptions::AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMode default_access_mode)
-    : access_mode(default_access_mode) {
-
-	for (auto &entry : info->options) {
-		if (entry.first == "readonly" || entry.first == "read_only") {
-			// Extract the read access mode.
-
-			auto read_only = BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
-			if (read_only) {
-				access_mode = AccessMode::READ_ONLY;
-			} else {
-				access_mode = AccessMode::READ_WRITE;
-			}
-			continue;
-		}
-
-		if (entry.first == "readwrite" || entry.first == "read_write") {
-			// Extract the write access mode.
-			auto read_write = BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
-			if (!read_write) {
-				access_mode = AccessMode::READ_ONLY;
-			} else {
-				access_mode = AccessMode::READ_WRITE;
-			}
-			continue;
-		}
-
-		if (entry.first == "type") {
-			// Extract the database type.
-			db_type = StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR));
-			continue;
-		}
-
-		if (entry.first == "default_table") {
-			default_table = QualifiedName::Parse(StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR)));
-			continue;
-		}
-
-		options[entry.first] = entry.second;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Attached Database
-//===--------------------------------------------------------------------===//
-
-AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY,
-                   type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG, 0),
-      db(db), type(type) {
-
-	// This database does not have storage, or uses temporary_objects for in-memory storage.
-	D_ASSERT(type == AttachedDatabaseType::TEMP_DATABASE || type == AttachedDatabaseType::SYSTEM_DATABASE);
-	if (type == AttachedDatabaseType::TEMP_DATABASE) {
-		storage = make_uniq<SingleFileStorageManager>(*this, string(IN_MEMORY_PATH), false);
-	}
-
-	catalog = make_uniq<DuckCatalog>(*this);
-	transaction_manager = make_uniq<DuckTransactionManager>(*this);
-	internal = true;
-}
-
-AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, string name_p, string file_path_p,
-                                   const AttachOptions &options)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p) {
-
-	if (options.access_mode == AccessMode::READ_ONLY) {
-		type = AttachedDatabaseType::READ_ONLY_DATABASE;
-	} else {
-		type = AttachedDatabaseType::READ_WRITE_DATABASE;
-	}
-	for (auto &entry : options.options) {
-		if (StringUtil::CIEquals(entry.first, "block_size")) {
-			continue;
-		}
-		if (StringUtil::CIEquals(entry.first, "row_group_size")) {
-			continue;
-		}
-		throw BinderException("Unrecognized option for attach \"%s\"", entry.first);
-	}
-
-	// We create the storage after the catalog to guarantee we allow extensions to instantiate the DuckCatalog.
-	catalog = make_uniq<DuckCatalog>(*this);
-	auto read_only = options.access_mode == AccessMode::READ_ONLY;
-	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), read_only);
-	transaction_manager = make_uniq<DuckTransactionManager>(*this);
-	internal = true;
-}
-
-AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, StorageExtension &storage_extension_p,
-                                   ClientContext &context, string name_p, const AttachInfo &info,
-                                   const AttachOptions &options)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p),
-      storage_extension(&storage_extension_p) {
-
-	if (options.access_mode == AccessMode::READ_ONLY) {
-		type = AttachedDatabaseType::READ_ONLY_DATABASE;
-	} else {
-		type = AttachedDatabaseType::READ_WRITE_DATABASE;
-	}
-
-	StorageExtensionInfo *storage_info = storage_extension->storage_info.get();
-	catalog = storage_extension->attach(storage_info, context, *this, name, *info.Copy(), options.access_mode);
-	if (!catalog) {
-		throw InternalException("AttachedDatabase - attach function did not return a catalog");
-	}
-	if (catalog->IsDuckCatalog()) {
-		// The attached database uses the DuckCatalog.
-		auto read_only = options.access_mode == AccessMode::READ_ONLY;
-		storage = make_uniq<SingleFileStorageManager>(*this, info.path, read_only);
-	}
-	transaction_manager = storage_extension->create_transaction_manager(storage_info, *this, *catalog);
-	if (!transaction_manager) {
-		throw InternalException(
-		    "AttachedDatabase - create_transaction_manager function did not return a transaction manager");
-	}
-	internal = true;
-}
-
-AttachedDatabase::~AttachedDatabase() {
-	Close();
-}
-
-bool AttachedDatabase::IsSystem() const {
-	D_ASSERT(!storage || type != AttachedDatabaseType::SYSTEM_DATABASE);
-	return type == AttachedDatabaseType::SYSTEM_DATABASE;
-}
-
-bool AttachedDatabase::IsTemporary() const {
-	return type == AttachedDatabaseType::TEMP_DATABASE;
-}
-bool AttachedDatabase::IsReadOnly() const {
-	return type == AttachedDatabaseType::READ_ONLY_DATABASE;
-}
-
-bool AttachedDatabase::NameIsReserved(const string &name) {
-	return name == DEFAULT_SCHEMA || name == TEMP_CATALOG || name == SYSTEM_CATALOG;
-}
-
-string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &fs) {
-	if (dbpath.empty() || dbpath == IN_MEMORY_PATH) {
-		return "memory";
-	}
-	auto name = fs.ExtractBaseName(dbpath);
-	if (NameIsReserved(name)) {
-		name += "_db";
-	}
-	return name;
-}
-
-void AttachedDatabase::Initialize(StorageOptions options) {
-	if (IsSystem()) {
-		catalog->Initialize(true);
-	} else {
-		catalog->Initialize(false);
-	}
-	if (storage) {
-		storage->Initialize(options);
-	}
-}
-
-StorageManager &AttachedDatabase::GetStorageManager() {
-	if (!storage) {
-		throw InternalException("Internal system catalog does not have storage");
-	}
-	return *storage;
-}
-
-Catalog &AttachedDatabase::GetCatalog() {
-	return *catalog;
-}
-
-TransactionManager &AttachedDatabase::GetTransactionManager() {
-	return *transaction_manager;
-}
-
-Catalog &AttachedDatabase::ParentCatalog() {
-	return *parent_catalog;
-}
-
-const Catalog &AttachedDatabase::ParentCatalog() const {
-	return *parent_catalog;
-}
-
-bool AttachedDatabase::IsInitialDatabase() const {
-	return is_initial_database;
-}
-
-void AttachedDatabase::SetInitialDatabase() {
-	is_initial_database = true;
-}
-
-void AttachedDatabase::SetReadOnlyDatabase() {
-	type = AttachedDatabaseType::READ_ONLY_DATABASE;
-}
-
-void AttachedDatabase::Close() {
-	D_ASSERT(catalog);
-	if (is_closed) {
-		return;
-	}
-	is_closed = true;
-
-	if (!IsSystem() && !catalog->InMemory()) {
-		db.GetDatabaseManager().EraseDatabasePath(catalog->GetDBPath());
-	}
-
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	if (!storage) {
-		return;
-	}
-
-	// shutting down: attempt to checkpoint the database
-	// but only if we are not cleaning up as part of an exception unwind
-	try {
-		if (!storage->InMemory()) {
-			auto &config = DBConfig::GetConfig(db);
-			if (!config.options.checkpoint_on_shutdown) {
-				return;
-			}
-			CheckpointOptions options;
-			options.wal_action = CheckpointWALAction::DELETE_WAL;
-			storage->CreateCheckpoint(options);
-		}
-	} catch (...) { // NOLINT
-	}
-
-	if (Allocator::SupportsFlush()) {
-		Allocator::FlushAll();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/buffered_data/batched_buffered_data.cpp b/src/duckdb/src/main/buffered_data/batched_buffered_data.cpp
deleted file mode 100644
index 3c593374c..000000000
--- a/src/duckdb/src/main/buffered_data/batched_buffered_data.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-#include "duckdb/main/buffered_data/batched_buffered_data.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp"
-#include "duckdb/common/stack.hpp"
-
-namespace duckdb {
-
-void BatchedBufferedData::BlockSink(const InterruptState &blocked_sink, idx_t batch) {
-	lock_guard<mutex> lock(glock);
-	D_ASSERT(!blocked_sinks.count(batch));
-	blocked_sinks.emplace(batch, blocked_sink);
-}
-
-BatchedBufferedData::BatchedBufferedData(weak_ptr<ClientContext> context)
-    : BufferedData(BufferedData::Type::BATCHED, std::move(context)), buffer_byte_count(0), read_queue_byte_count(0),
-      min_batch(0) {
-	read_queue_capacity = (idx_t)(static_cast<double>(total_buffer_size) * 0.6);
-	buffer_capacity = (idx_t)(static_cast<double>(total_buffer_size) * 0.4);
-}
-
-bool BatchedBufferedData::ShouldBlockBatch(idx_t batch) {
-	lock_guard<mutex> lock(glock);
-	bool is_minimum = IsMinimumBatchIndex(lock, batch);
-	if (is_minimum) {
-		// If there is room in the read queue, we want to process the minimum batch
-		return read_queue_byte_count >= ReadQueueCapacity();
-	}
-	return buffer_byte_count >= BufferCapacity();
-}
-
-bool BatchedBufferedData::BufferIsEmpty() {
-	lock_guard<mutex> lock(glock);
-	return read_queue.empty();
-}
-
-bool BatchedBufferedData::IsMinimumBatchIndex(lock_guard<mutex> &lock, idx_t batch) {
-	return min_batch == batch;
-}
-
-void BatchedBufferedData::UnblockSinks() {
-	lock_guard<mutex> lock(glock);
-	stack<idx_t> to_remove;
-	for (auto it = blocked_sinks.begin(); it != blocked_sinks.end(); it++) {
-		auto batch = it->first;
-		auto &blocked_sink = it->second;
-		const bool is_minimum = IsMinimumBatchIndex(lock, batch);
-		if (is_minimum) {
-			if (read_queue_byte_count >= ReadQueueCapacity()) {
-				continue;
-			}
-		} else {
-			if (buffer_byte_count >= BufferCapacity()) {
-				continue;
-			}
-		}
-		blocked_sink.Callback();
-		to_remove.push(batch);
-	}
-	while (!to_remove.empty()) {
-		auto batch = to_remove.top();
-		to_remove.pop();
-		blocked_sinks.erase(batch);
-	}
-}
-
-void BatchedBufferedData::MoveCompletedBatches(lock_guard<mutex> &lock) {
-	stack<idx_t> to_remove;
-	for (auto &it : buffer) {
-		auto batch_index = it.first;
-		auto &in_progress_batch = it.second;
-		if (batch_index > min_batch) {
-			break;
-		}
-		D_ASSERT(in_progress_batch.completed || batch_index == min_batch);
-		// min_batch - took longer than others
-		// min_batch+1 - completed before min_batch
-		// min_batch+2 - completed before min_batch
-		// new min_batch
-		//
-		// To preserve the order, the completed batches have to be processed before we can start scanning the "new
-		// min_batch"
-		auto &chunks = in_progress_batch.chunks;
-
-		idx_t batch_allocation_size = 0;
-		for (auto it = chunks.begin(); it != chunks.end(); it++) {
-			auto chunk = std::move(*it);
-			auto allocation_size = chunk->GetAllocationSize();
-			batch_allocation_size += allocation_size;
-			read_queue.push_back(std::move(chunk));
-		}
-		// Verification to make sure we're not breaking the order by moving batches before the previous ones have
-		// finished
-		if (lowest_moved_batch > batch_index) {
-			throw InternalException("Lowest moved batch is %d, attempted to move %d afterwards\nAttempted to move %d "
-			                        "chunks, of %d bytes in total\nmin_batch is %d",
-			                        lowest_moved_batch, batch_index, chunks.size(), batch_allocation_size, min_batch);
-		}
-		D_ASSERT(lowest_moved_batch <= batch_index);
-		lowest_moved_batch = batch_index;
-
-		buffer_byte_count -= batch_allocation_size;
-		read_queue_byte_count += batch_allocation_size;
-		to_remove.push(batch_index);
-	}
-	while (!to_remove.empty()) {
-		auto batch_index = to_remove.top();
-		to_remove.pop();
-		buffer.erase(batch_index);
-	}
-}
-
-void BatchedBufferedData::UpdateMinBatchIndex(idx_t min_batch_index) {
-	lock_guard<mutex> lock(glock);
-
-	auto old_min_batch = min_batch;
-	auto new_min_batch = MaxValue(old_min_batch, min_batch_index);
-	if (new_min_batch == min_batch) {
-		// No change, early out
-		return;
-	}
-	min_batch = new_min_batch;
-	MoveCompletedBatches(lock);
-}
-
-StreamExecutionResult BatchedBufferedData::ExecuteTaskInternal(StreamQueryResult &result,
-                                                               ClientContextLock &context_lock) {
-	auto cc = context.lock();
-	if (!cc) {
-		return StreamExecutionResult::EXECUTION_CANCELLED;
-	}
-
-	if (!BufferIsEmpty()) {
-		// The buffer isn't empty yet, just return
-		return StreamExecutionResult::CHUNK_READY;
-	}
-	// Unblock any pending sinks if the buffer isnt full
-	UnblockSinks();
-	// Let the executor run until the buffer is no longer empty
-	auto execution_result = cc->ExecuteTaskInternal(context_lock, result);
-	if (!BufferIsEmpty()) {
-		return StreamExecutionResult::CHUNK_READY;
-	}
-	if (execution_result == PendingExecutionResult::BLOCKED ||
-	    execution_result == PendingExecutionResult::RESULT_READY) {
-		return StreamExecutionResult::BLOCKED;
-	}
-	if (result.HasError()) {
-		Close();
-	}
-	switch (execution_result) {
-	case PendingExecutionResult::NO_TASKS_AVAILABLE:
-	case PendingExecutionResult::RESULT_NOT_READY:
-		return StreamExecutionResult::CHUNK_NOT_READY;
-	case PendingExecutionResult::EXECUTION_FINISHED:
-		return StreamExecutionResult::EXECUTION_FINISHED;
-	case PendingExecutionResult::EXECUTION_ERROR:
-		return StreamExecutionResult::EXECUTION_ERROR;
-	default:
-		throw InternalException("No conversion from PendingExecutionResult (%s) -> StreamExecutionResult",
-		                        EnumUtil::ToString(execution_result));
-	}
-}
-
-void BatchedBufferedData::CompleteBatch(idx_t batch) {
-	lock_guard<mutex> lock(glock);
-	auto it = buffer.find(batch);
-	if (it == buffer.end()) {
-		return;
-	}
-
-	auto &in_progress_batch = it->second;
-	in_progress_batch.completed = true;
-}
-
-unique_ptr<DataChunk> BatchedBufferedData::Scan() {
-	unique_ptr<DataChunk> chunk;
-	lock_guard<mutex> lock(glock);
-	if (!read_queue.empty()) {
-		chunk = std::move(read_queue.front());
-		read_queue.pop_front();
-		auto allocation_size = chunk->GetAllocationSize();
-		read_queue_byte_count -= allocation_size;
-	} else {
-		context.reset();
-		D_ASSERT(blocked_sinks.empty());
-		D_ASSERT(buffer.empty());
-		return nullptr;
-	}
-	return chunk;
-}
-
-void BatchedBufferedData::Append(const DataChunk &to_append, idx_t batch) {
-	// We should never find any chunks with a smaller batch index than the minimum
-
-	auto chunk = make_uniq<DataChunk>();
-	chunk->Initialize(Allocator::DefaultAllocator(), to_append.GetTypes());
-	to_append.Copy(*chunk, 0);
-	auto allocation_size = chunk->GetAllocationSize();
-
-	lock_guard<mutex> lock(glock);
-	D_ASSERT(batch >= min_batch);
-	auto is_minimum = IsMinimumBatchIndex(lock, batch);
-	if (is_minimum) {
-		for (auto &it : buffer) {
-			auto batch_index = it.first;
-			if (batch_index >= min_batch) {
-				break;
-			}
-			// There should not be any batches in the buffer that are lower or equal to the minimum batch index
-			throw InternalException("Batches remaining in buffer");
-		}
-		read_queue.push_back(std::move(chunk));
-		read_queue_byte_count += allocation_size;
-	} else {
-		auto &in_progress_batch = buffer[batch];
-		auto &chunks = in_progress_batch.chunks;
-		in_progress_batch.completed = false;
-		buffer_byte_count += allocation_size;
-		chunks.push_back(std::move(chunk));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/buffered_data/buffered_data.cpp b/src/duckdb/src/main/buffered_data/buffered_data.cpp
deleted file mode 100644
index 156539815..000000000
--- a/src/duckdb/src/main/buffered_data/buffered_data.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/main/buffered_data/buffered_data.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-BufferedData::BufferedData(Type type, weak_ptr<ClientContext> context_p) : type(type), context(std::move(context_p)) {
-	auto client_context = context.lock();
-	auto &config = ClientConfig::GetConfig(*client_context);
-	total_buffer_size = config.streaming_buffer_size;
-}
-
-BufferedData::~BufferedData() {
-}
-
-StreamExecutionResult BufferedData::ReplenishBuffer(StreamQueryResult &result, ClientContextLock &context_lock) {
-	auto cc = context.lock();
-	if (!cc) {
-		return StreamExecutionResult::EXECUTION_CANCELLED;
-	}
-
-	StreamExecutionResult execution_result;
-	while (!StreamQueryResult::IsChunkReady(execution_result = ExecuteTaskInternal(result, context_lock))) {
-		if (execution_result == StreamExecutionResult::BLOCKED) {
-			UnblockSinks();
-			cc->WaitForTask(context_lock, result);
-		}
-	}
-	if (result.HasError()) {
-		Close();
-	}
-	return execution_result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp b/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp
deleted file mode 100644
index 4b6a3a534..000000000
--- a/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "duckdb/main/buffered_data/simple_buffered_data.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-SimpleBufferedData::SimpleBufferedData(weak_ptr<ClientContext> context)
-    : BufferedData(BufferedData::Type::SIMPLE, std::move(context)) {
-	buffered_count = 0;
-	buffer_size = total_buffer_size;
-}
-
-SimpleBufferedData::~SimpleBufferedData() {
-}
-
-void SimpleBufferedData::BlockSink(const InterruptState &blocked_sink) {
-	lock_guard<mutex> lock(glock);
-	blocked_sinks.push(blocked_sink);
-}
-
-bool SimpleBufferedData::BufferIsFull() {
-	return buffered_count >= BufferSize();
-}
-
-void SimpleBufferedData::UnblockSinks() {
-	auto cc = context.lock();
-	if (!cc) {
-		return;
-	}
-	(void)cc;
-
-	if (buffered_count >= BufferSize()) {
-		return;
-	}
-	// Reschedule enough blocked sinks to populate the buffer
-	lock_guard<mutex> lock(glock);
-	while (!blocked_sinks.empty()) {
-		auto &blocked_sink = blocked_sinks.front();
-		if (buffered_count >= BufferSize()) {
-			// We have unblocked enough sinks already
-			break;
-		}
-		blocked_sink.Callback();
-		blocked_sinks.pop();
-	}
-}
-
-StreamExecutionResult SimpleBufferedData::ExecuteTaskInternal(StreamQueryResult &result,
-                                                              ClientContextLock &context_lock) {
-	auto cc = context.lock();
-	if (!cc) {
-		return StreamExecutionResult::EXECUTION_CANCELLED;
-	}
-	if (!cc->IsActiveResult(context_lock, result)) {
-		return StreamExecutionResult::EXECUTION_CANCELLED;
-	}
-	if (BufferIsFull()) {
-		// The buffer isn't empty yet, just return
-		return StreamExecutionResult::CHUNK_READY;
-	}
-	UnblockSinks();
-	// Let the executor run until the buffer is no longer empty
-	auto execution_result = cc->ExecuteTaskInternal(context_lock, result);
-	if (buffered_count >= BufferSize()) {
-		return StreamExecutionResult::CHUNK_READY;
-	}
-	if (execution_result == PendingExecutionResult::BLOCKED ||
-	    execution_result == PendingExecutionResult::RESULT_READY) {
-		return StreamExecutionResult::BLOCKED;
-	}
-	if (result.HasError()) {
-		Close();
-	}
-	switch (execution_result) {
-	case PendingExecutionResult::NO_TASKS_AVAILABLE:
-	case PendingExecutionResult::RESULT_NOT_READY:
-		return StreamExecutionResult::CHUNK_NOT_READY;
-	case PendingExecutionResult::EXECUTION_FINISHED:
-		return StreamExecutionResult::EXECUTION_FINISHED;
-	case PendingExecutionResult::EXECUTION_ERROR:
-		return StreamExecutionResult::EXECUTION_ERROR;
-	default:
-		throw InternalException("No conversion from PendingExecutionResult (%s) -> StreamExecutionResult",
-		                        EnumUtil::ToString(execution_result));
-	}
-}
-
-unique_ptr<DataChunk> SimpleBufferedData::Scan() {
-	if (Closed()) {
-		return nullptr;
-	}
-
-	lock_guard<mutex> lock(glock);
-	if (buffered_chunks.empty()) {
-		Close();
-		return nullptr;
-	}
-	auto chunk = std::move(buffered_chunks.front());
-	buffered_chunks.pop();
-
-	if (chunk) {
-		auto allocation_size = chunk->GetAllocationSize();
-		buffered_count -= allocation_size;
-	}
-	return chunk;
-}
-
-void SimpleBufferedData::Append(const DataChunk &to_append) {
-	auto chunk = make_uniq<DataChunk>();
-	chunk->Initialize(Allocator::DefaultAllocator(), to_append.GetTypes());
-	to_append.Copy(*chunk, 0);
-	auto allocation_size = chunk->GetAllocationSize();
-
-	unique_lock<mutex> lock(glock);
-	buffered_count += allocation_size;
-	buffered_chunks.push(std::move(chunk));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/capi/aggregate_function-c.cpp b/src/duckdb/src/main/capi/aggregate_function-c.cpp
deleted file mode 100644
index 43ddfdbc0..000000000
--- a/src/duckdb/src/main/capi/aggregate_function-c.cpp
+++ /dev/null
@@ -1,327 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct CAggregateFunctionInfo : public AggregateFunctionInfo {
-	~CAggregateFunctionInfo() override {
-		if (extra_info && delete_callback) {
-			delete_callback(extra_info);
-		}
-		extra_info = nullptr;
-		delete_callback = nullptr;
-	}
-
-	duckdb_aggregate_state_size state_size = nullptr;
-	duckdb_aggregate_init_t state_init = nullptr;
-	duckdb_aggregate_update_t update = nullptr;
-	duckdb_aggregate_combine_t combine = nullptr;
-	duckdb_aggregate_finalize_t finalize = nullptr;
-	duckdb_aggregate_destroy_t destroy = nullptr;
-	duckdb_function_info extra_info = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-};
-
-struct CAggregateExecuteInfo {
-	explicit CAggregateExecuteInfo(CAggregateFunctionInfo &info) : info(info) {
-	}
-
-	CAggregateFunctionInfo &info;
-	bool success = true;
-	string error;
-};
-
-struct CAggregateFunctionBindData : public FunctionData {
-	explicit CAggregateFunctionBindData(CAggregateFunctionInfo &info) : info(info) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<CAggregateFunctionBindData>(info);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<CAggregateFunctionBindData>();
-		return info.extra_info == other.info.extra_info && info.update == other.info.update &&
-		       info.combine == other.info.combine && info.finalize == other.info.finalize;
-	}
-
-	CAggregateFunctionInfo &info;
-};
-
-duckdb::AggregateFunction &GetCAggregateFunction(duckdb_aggregate_function function) {
-	return *reinterpret_cast<duckdb::AggregateFunction *>(function);
-}
-
-duckdb::AggregateFunctionSet &GetCAggregateFunctionSet(duckdb_aggregate_function_set function_set) {
-	return *reinterpret_cast<duckdb::AggregateFunctionSet *>(function_set);
-}
-
-unique_ptr<FunctionData> CAPIAggregateBind(ClientContext &context, AggregateFunction &function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	auto &info = function.function_info->Cast<CAggregateFunctionInfo>();
-	return make_uniq<CAggregateFunctionBindData>(info);
-}
-
-idx_t CAPIAggregateStateSize(const AggregateFunction &function) {
-	auto &function_info = function.function_info->Cast<duckdb::CAggregateFunctionInfo>();
-	CAggregateExecuteInfo exec_info(function_info);
-	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-	auto result = function_info.state_size(c_function_info);
-	if (!exec_info.success) {
-		throw InvalidInputException(exec_info.error);
-	}
-	return result;
-}
-
-void CAPIAggregateStateInit(const AggregateFunction &function, data_ptr_t state) {
-	auto &function_info = function.function_info->Cast<duckdb::CAggregateFunctionInfo>();
-	CAggregateExecuteInfo exec_info(function_info);
-	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-	function_info.state_init(c_function_info, reinterpret_cast<duckdb_aggregate_state>(state));
-	if (!exec_info.success) {
-		throw InvalidInputException(exec_info.error);
-	}
-}
-
-void CAPIAggregateUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &state,
-                         idx_t count) {
-	DataChunk chunk;
-	for (idx_t c = 0; c < input_count; c++) {
-		inputs[c].Flatten(count);
-		chunk.data.emplace_back(inputs[c]);
-	}
-	chunk.SetCardinality(count);
-
-	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
-	auto c_input_chunk = reinterpret_cast<duckdb_data_chunk>(&chunk);
-
-	CAggregateExecuteInfo exec_info(bind_data.info);
-	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-	bind_data.info.update(c_function_info, c_input_chunk, state_data);
-	if (!exec_info.success) {
-		throw InvalidInputException(exec_info.error);
-	}
-}
-
-void CAPIAggregateCombine(Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
-	state.Flatten(count);
-	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto input_state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
-	auto result_state_data = FlatVector::GetData<duckdb_aggregate_state>(combined);
-	CAggregateExecuteInfo exec_info(bind_data.info);
-	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-	bind_data.info.combine(c_function_info, input_state_data, result_state_data, count);
-	if (!exec_info.success) {
-		throw InvalidInputException(exec_info.error);
-	}
-}
-
-void CAPIAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                           idx_t offset) {
-	state.Flatten(count);
-	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto input_state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
-	auto result_vector = reinterpret_cast<duckdb_vector>(&result);
-
-	CAggregateExecuteInfo exec_info(bind_data.info);
-	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-	bind_data.info.finalize(c_function_info, input_state_data, result_vector, count, offset);
-	if (!exec_info.success) {
-		throw InvalidInputException(exec_info.error);
-	}
-}
-
-void CAPIAggregateDestructor(Vector &state, AggregateInputData &aggr_input_data, idx_t count) {
-	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto input_state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
-	bind_data.info.destroy(input_state_data, count);
-}
-
-} // namespace duckdb
-
-using duckdb::GetCAggregateFunction;
-
-duckdb_aggregate_function duckdb_create_aggregate_function() {
-	auto function = new duckdb::AggregateFunction("", {}, duckdb::LogicalType::INVALID, duckdb::CAPIAggregateStateSize,
-	                                              duckdb::CAPIAggregateStateInit, duckdb::CAPIAggregateUpdate,
-	                                              duckdb::CAPIAggregateCombine, duckdb::CAPIAggregateFinalize, nullptr,
-	                                              duckdb::CAPIAggregateBind);
-	function->function_info = duckdb::make_shared_ptr<duckdb::CAggregateFunctionInfo>();
-	return reinterpret_cast<duckdb_aggregate_function>(function);
-}
-
-void duckdb_destroy_aggregate_function(duckdb_aggregate_function *function) {
-	if (function && *function) {
-		auto aggregate_function = reinterpret_cast<duckdb::AggregateFunction *>(*function);
-		delete aggregate_function;
-		*function = nullptr;
-	}
-}
-
-void duckdb_aggregate_function_set_name(duckdb_aggregate_function function, const char *name) {
-	if (!function || !name) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	aggregate_function.name = name;
-}
-
-void duckdb_aggregate_function_add_parameter(duckdb_aggregate_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	aggregate_function.arguments.push_back(*logical_type);
-}
-
-void duckdb_aggregate_function_set_return_type(duckdb_aggregate_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	aggregate_function.return_type = *logical_type;
-}
-
-void duckdb_aggregate_function_set_functions(duckdb_aggregate_function function, duckdb_aggregate_state_size state_size,
-                                             duckdb_aggregate_init_t state_init, duckdb_aggregate_update_t update,
-                                             duckdb_aggregate_combine_t combine, duckdb_aggregate_finalize_t finalize) {
-	if (!function || !state_size || !state_init || !update || !combine || !finalize) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	auto &function_info = aggregate_function.function_info->Cast<duckdb::CAggregateFunctionInfo>();
-	function_info.state_size = state_size;
-	function_info.state_init = state_init;
-	function_info.update = update;
-	function_info.combine = combine;
-	function_info.finalize = finalize;
-}
-
-void duckdb_aggregate_function_set_destructor(duckdb_aggregate_function function, duckdb_aggregate_destroy_t destroy) {
-	if (!function || !destroy) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	auto &function_info = aggregate_function.function_info->Cast<duckdb::CAggregateFunctionInfo>();
-	function_info.destroy = destroy;
-	aggregate_function.destructor = duckdb::CAPIAggregateDestructor;
-}
-
-duckdb_state duckdb_register_aggregate_function(duckdb_connection connection, duckdb_aggregate_function function) {
-	if (!connection || !function) {
-		return DuckDBError;
-	}
-
-	auto &aggregate_function = GetCAggregateFunction(function);
-	duckdb::AggregateFunctionSet set(aggregate_function.name);
-	set.AddFunction(aggregate_function);
-	return duckdb_register_aggregate_function_set(connection, reinterpret_cast<duckdb_aggregate_function_set>(&set));
-}
-
-void duckdb_aggregate_function_set_special_handling(duckdb_aggregate_function function) {
-	if (!function) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	aggregate_function.null_handling = duckdb::FunctionNullHandling::SPECIAL_HANDLING;
-}
-
-void duckdb_aggregate_function_set_extra_info(duckdb_aggregate_function function, void *extra_info,
-                                              duckdb_delete_callback_t destroy) {
-	if (!function || !extra_info) {
-		return;
-	}
-	auto &aggregate_function = GetCAggregateFunction(function);
-	auto &function_info = aggregate_function.function_info->Cast<duckdb::CAggregateFunctionInfo>();
-	function_info.extra_info = static_cast<duckdb_function_info>(extra_info);
-	function_info.delete_callback = destroy;
-}
-
-duckdb::CAggregateExecuteInfo &GetCAggregateExecuteInfo(duckdb_function_info info) {
-	D_ASSERT(info);
-	return *reinterpret_cast<duckdb::CAggregateExecuteInfo *>(info);
-}
-
-void *duckdb_aggregate_function_get_extra_info(duckdb_function_info info_p) {
-	auto &exec_info = GetCAggregateExecuteInfo(info_p);
-	return exec_info.info.extra_info;
-}
-
-void duckdb_aggregate_function_set_error(duckdb_function_info info_p, const char *error) {
-	auto &exec_info = GetCAggregateExecuteInfo(info_p);
-	exec_info.error = error;
-	exec_info.success = false;
-}
-
-duckdb_aggregate_function_set duckdb_create_aggregate_function_set(const char *name) {
-	if (!name || !*name) {
-		return nullptr;
-	}
-	auto function_set = new duckdb::AggregateFunctionSet(name);
-	return reinterpret_cast<duckdb_aggregate_function_set>(function_set);
-}
-
-void duckdb_destroy_aggregate_function_set(duckdb_aggregate_function_set *set) {
-	if (set && *set) {
-		auto aggregate_function_set = reinterpret_cast<duckdb::AggregateFunctionSet *>(*set);
-		delete aggregate_function_set;
-		*set = nullptr;
-	}
-}
-
-duckdb_state duckdb_add_aggregate_function_to_set(duckdb_aggregate_function_set set,
-                                                  duckdb_aggregate_function function) {
-	if (!set || !function) {
-		return DuckDBError;
-	}
-	auto &aggregate_function_set = duckdb::GetCAggregateFunctionSet(set);
-	auto &aggregate_function = GetCAggregateFunction(function);
-	aggregate_function_set.AddFunction(aggregate_function);
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_register_aggregate_function_set(duckdb_connection connection,
-                                                    duckdb_aggregate_function_set function_set) {
-	if (!connection || !function_set) {
-		return DuckDBError;
-	}
-	auto &set = duckdb::GetCAggregateFunctionSet(function_set);
-	for (idx_t idx = 0; idx < set.Size(); idx++) {
-		auto &aggregate_function = set.GetFunctionReferenceByOffset(idx);
-		auto &info = aggregate_function.function_info->Cast<duckdb::CAggregateFunctionInfo>();
-
-		if (aggregate_function.name.empty() || !info.update || !info.combine || !info.finalize) {
-			return DuckDBError;
-		}
-		if (duckdb::TypeVisitor::Contains(aggregate_function.return_type, duckdb::LogicalTypeId::INVALID) ||
-		    duckdb::TypeVisitor::Contains(aggregate_function.return_type, duckdb::LogicalTypeId::ANY)) {
-			return DuckDBError;
-		}
-		for (const auto &argument : aggregate_function.arguments) {
-			if (duckdb::TypeVisitor::Contains(argument, duckdb::LogicalTypeId::INVALID)) {
-				return DuckDBError;
-			}
-		}
-	}
-
-	try {
-		auto con = reinterpret_cast<duckdb::Connection *>(connection);
-		con->context->RunFunctionInTransaction([&]() {
-			auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
-			duckdb::CreateAggregateFunctionInfo sf_info(set);
-			catalog.CreateFunction(*con->context, sf_info);
-		});
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
diff --git a/src/duckdb/src/main/capi/appender-c.cpp b/src/duckdb/src/main/capi/appender-c.cpp
deleted file mode 100644
index cab3291f2..000000000
--- a/src/duckdb/src/main/capi/appender-c.cpp
+++ /dev/null
@@ -1,309 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-using duckdb::Appender;
-using duckdb::AppenderWrapper;
-using duckdb::Connection;
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::ErrorData;
-using duckdb::hugeint_t;
-using duckdb::interval_t;
-using duckdb::string_t;
-using duckdb::timestamp_t;
-using duckdb::uhugeint_t;
-
-duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
-                                    duckdb_appender *out_appender) {
-	return duckdb_appender_create_ext(connection, INVALID_CATALOG, schema, table, out_appender);
-}
-
-duckdb_state duckdb_appender_create_ext(duckdb_connection connection, const char *catalog, const char *schema,
-                                        const char *table, duckdb_appender *out_appender) {
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-
-	if (!connection || !table || !out_appender) {
-		return DuckDBError;
-	}
-	if (catalog == nullptr) {
-		catalog = INVALID_CATALOG;
-	}
-	if (schema == nullptr) {
-		schema = DEFAULT_SCHEMA;
-	}
-
-	auto wrapper = new AppenderWrapper();
-	*out_appender = (duckdb_appender)wrapper;
-	try {
-		wrapper->appender = duckdb::make_uniq<Appender>(*conn, catalog, schema, table);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		wrapper->error = error.RawMessage();
-		return DuckDBError;
-	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown create appender error";
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_appender_destroy(duckdb_appender *appender) {
-	if (!appender || !*appender) {
-		return DuckDBError;
-	}
-	auto state = duckdb_appender_close(*appender);
-	auto wrapper = reinterpret_cast<AppenderWrapper *>(*appender);
-	if (wrapper) {
-		delete wrapper;
-	}
-	*appender = nullptr;
-	return state;
-}
-
-template <class FUN>
-duckdb_state duckdb_appender_run_function(duckdb_appender appender, FUN &&function) {
-	if (!appender) {
-		return DuckDBError;
-	}
-	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
-	if (!wrapper->appender) {
-		return DuckDBError;
-	}
-	try {
-		function(*wrapper->appender);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		wrapper->error = error.RawMessage();
-		return DuckDBError;
-	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown appender error.";
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_appender_add_column(duckdb_appender appender, const char *name) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AddColumn(name); });
-}
-
-duckdb_state duckdb_appender_clear_columns(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.ClearColumns(); });
-}
-
-const char *duckdb_appender_error(duckdb_appender appender) {
-	if (!appender) {
-		return nullptr;
-	}
-	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
-	if (wrapper->error.empty()) {
-		return nullptr;
-	}
-	return wrapper->error.c_str();
-}
-
-duckdb_state duckdb_appender_begin_row(duckdb_appender appender) {
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_appender_end_row(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.EndRow(); });
-}
-
-template <class T>
-duckdb_state duckdb_append_internal(duckdb_appender appender, T value) {
-	if (!appender) {
-		return DuckDBError;
-	}
-	auto *appender_instance = reinterpret_cast<AppenderWrapper *>(appender);
-	try {
-		appender_instance->appender->Append<T>(value);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		appender_instance->error = error.RawMessage();
-		return DuckDBError;
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_append_default(duckdb_appender appender) {
-	if (!appender) {
-		return DuckDBError;
-	}
-	auto *appender_instance = reinterpret_cast<AppenderWrapper *>(appender);
-
-	try {
-		appender_instance->appender->AppendDefault();
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		appender_instance->error = error.RawMessage();
-		return DuckDBError;
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_append_default_to_chunk(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, idx_t row) {
-	if (!appender || !chunk) {
-		return DuckDBError;
-	}
-
-	auto *appender_instance = reinterpret_cast<AppenderWrapper *>(appender);
-
-	auto data_chunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-
-	try {
-		appender_instance->appender->AppendDefault(*data_chunk, col, row);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		appender_instance->error = error.RawMessage();
-		return DuckDBError;
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_append_bool(duckdb_appender appender, bool value) {
-	return duckdb_append_internal<bool>(appender, value);
-}
-
-duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value) {
-	return duckdb_append_internal<int8_t>(appender, value);
-}
-
-duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value) {
-	return duckdb_append_internal<int16_t>(appender, value);
-}
-
-duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value) {
-	return duckdb_append_internal<int32_t>(appender, value);
-}
-
-duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value) {
-	return duckdb_append_internal<int64_t>(appender, value);
-}
-
-duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value) {
-	hugeint_t internal;
-	internal.lower = value.lower;
-	internal.upper = value.upper;
-	return duckdb_append_internal<hugeint_t>(appender, internal);
-}
-
-duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value) {
-	return duckdb_append_internal<uint8_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value) {
-	return duckdb_append_internal<uint16_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value) {
-	return duckdb_append_internal<uint32_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value) {
-	return duckdb_append_internal<uint64_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uhugeint(duckdb_appender appender, duckdb_uhugeint value) {
-	uhugeint_t internal;
-	internal.lower = value.lower;
-	internal.upper = value.upper;
-	return duckdb_append_internal<uhugeint_t>(appender, internal);
-}
-
-duckdb_state duckdb_append_float(duckdb_appender appender, float value) {
-	return duckdb_append_internal<float>(appender, value);
-}
-
-duckdb_state duckdb_append_double(duckdb_appender appender, double value) {
-	return duckdb_append_internal<double>(appender, value);
-}
-
-duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value) {
-	return duckdb_append_internal<date_t>(appender, date_t(value.days));
-}
-
-duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value) {
-	return duckdb_append_internal<dtime_t>(appender, dtime_t(value.micros));
-}
-
-duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value) {
-	return duckdb_append_internal<timestamp_t>(appender, timestamp_t(value.micros));
-}
-
-duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value) {
-	interval_t interval;
-	interval.months = value.months;
-	interval.days = value.days;
-	interval.micros = value.micros;
-	return duckdb_append_internal<interval_t>(appender, interval);
-}
-
-duckdb_state duckdb_append_null(duckdb_appender appender) {
-	return duckdb_append_internal<std::nullptr_t>(appender, nullptr);
-}
-
-duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val) {
-	return duckdb_append_internal<const char *>(appender, val);
-}
-
-duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length) {
-	return duckdb_append_internal<string_t>(appender, string_t(val, duckdb::UnsafeNumericCast<uint32_t>(length)));
-}
-
-duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length) {
-	auto value = duckdb::Value::BLOB((duckdb::const_data_ptr_t)data, length);
-	return duckdb_append_internal<duckdb::Value>(appender, value);
-}
-
-duckdb_state duckdb_appender_flush(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.Flush(); });
-}
-
-duckdb_state duckdb_appender_close(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.Close(); });
-}
-
-idx_t duckdb_appender_column_count(duckdb_appender appender) {
-	if (!appender) {
-		return 0;
-	}
-
-	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
-	if (!wrapper->appender) {
-		return 0;
-	}
-
-	return wrapper->appender->GetActiveTypes().size();
-}
-
-duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx) {
-	if (!appender || col_idx >= duckdb_appender_column_count(appender)) {
-		return nullptr;
-	}
-
-	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
-	if (!wrapper->appender) {
-		return nullptr;
-	}
-
-	auto &logical_type = wrapper->appender->GetActiveTypes()[col_idx];
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(logical_type));
-}
-
-duckdb_state duckdb_append_value(duckdb_appender appender, duckdb_value value) {
-	return duckdb_append_internal<duckdb::Value>(appender, *(reinterpret_cast<duckdb::Value *>(value)));
-}
-
-duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return DuckDBError;
-	}
-	auto data_chunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AppendDataChunk(*data_chunk); });
-}
diff --git a/src/duckdb/src/main/capi/arrow-c.cpp b/src/duckdb/src/main/capi/arrow-c.cpp
deleted file mode 100644
index f74d9e22f..000000000
--- a/src/duckdb/src/main/capi/arrow-c.cpp
+++ /dev/null
@@ -1,328 +0,0 @@
-#include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/arrow/arrow_converter.hpp"
-#include "duckdb/function/table/arrow.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-
-using duckdb::ArrowConverter;
-using duckdb::ArrowResultWrapper;
-using duckdb::Connection;
-using duckdb::DataChunk;
-using duckdb::LogicalType;
-using duckdb::MaterializedQueryResult;
-using duckdb::PreparedStatementWrapper;
-using duckdb::QueryResult;
-using duckdb::QueryResultType;
-
-duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result) {
-	Connection *conn = (Connection *)connection;
-	auto wrapper = new ArrowResultWrapper();
-	wrapper->result = conn->Query(query);
-	*out_result = (duckdb_arrow)wrapper;
-	return !wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
-}
-
-duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema) {
-	if (!out_schema) {
-		return DuckDBSuccess;
-	}
-	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	try {
-		ArrowConverter::ToArrowSchema((ArrowSchema *)*out_schema, wrapper->result->types, wrapper->result->names,
-		                              wrapper->result->client_properties);
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared, duckdb_arrow_schema *out_schema) {
-	if (!out_schema) {
-		return DuckDBSuccess;
-	}
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared);
-	if (!wrapper || !wrapper->statement || !wrapper->statement->data) {
-		return DuckDBError;
-	}
-	auto properties = wrapper->statement->context->GetClientProperties();
-	duckdb::vector<duckdb::LogicalType> prepared_types;
-	duckdb::vector<duckdb::string> prepared_names;
-
-	auto count = wrapper->statement->data->properties.parameter_count;
-	for (idx_t i = 0; i < count; i++) {
-		// Every prepared parameter type is UNKNOWN, which we need to map to NULL according to the spec of
-		// 'AdbcStatementGetParameterSchema'
-		auto type = LogicalType::SQLNULL;
-
-		// FIXME: we don't support named parameters yet, but when we do, this needs to be updated
-		auto name = std::to_string(i);
-		prepared_types.push_back(std::move(type));
-		prepared_names.push_back(name);
-	}
-
-	auto result_schema = (ArrowSchema *)*out_schema;
-	if (!result_schema) {
-		return DuckDBError;
-	}
-
-	if (result_schema->release) {
-		// Need to release the existing schema before we overwrite it
-		result_schema->release(result_schema);
-		D_ASSERT(!result_schema->release);
-	}
-
-	ArrowConverter::ToArrowSchema(result_schema, prepared_types, prepared_names, properties);
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array) {
-	if (!out_array) {
-		return DuckDBSuccess;
-	}
-	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	auto success = wrapper->result->TryFetch(wrapper->current_chunk, wrapper->result->GetErrorObject());
-	if (!success) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	if (!wrapper->current_chunk || wrapper->current_chunk->size() == 0) {
-		return DuckDBSuccess;
-	}
-	ArrowConverter::ToArrowArray(*wrapper->current_chunk, reinterpret_cast<ArrowArray *>(*out_array),
-	                             wrapper->result->client_properties);
-	return DuckDBSuccess;
-}
-
-void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array) {
-	if (!out_array) {
-		return;
-	}
-	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
-	ArrowConverter::ToArrowArray(*dchunk, reinterpret_cast<ArrowArray *>(*out_array),
-	                             result_data.result->client_properties);
-}
-
-idx_t duckdb_arrow_row_count(duckdb_arrow result) {
-	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	if (wrapper->result->HasError()) {
-		return 0;
-	}
-	return wrapper->result->RowCount();
-}
-
-idx_t duckdb_arrow_column_count(duckdb_arrow result) {
-	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	return wrapper->result->ColumnCount();
-}
-
-idx_t duckdb_arrow_rows_changed(duckdb_arrow result) {
-	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	if (wrapper->result->HasError()) {
-		return 0;
-	}
-	idx_t rows_changed = 0;
-	auto &collection = wrapper->result->Collection();
-	idx_t row_count = collection.Count();
-	if (row_count > 0 && wrapper->result->properties.return_type == duckdb::StatementReturnType::CHANGED_ROWS) {
-		auto rows = collection.GetRows();
-		D_ASSERT(row_count == 1);
-		D_ASSERT(rows.size() == 1);
-		rows_changed = duckdb::NumericCast<idx_t>(rows[0].GetValue(0).GetValue<int64_t>());
-	}
-	return rows_changed;
-}
-
-const char *duckdb_query_arrow_error(duckdb_arrow result) {
-	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	return wrapper->result->GetError().c_str();
-}
-
-void duckdb_destroy_arrow(duckdb_arrow *result) {
-	if (*result) {
-		auto wrapper = reinterpret_cast<ArrowResultWrapper *>(*result);
-		delete wrapper;
-		*result = nullptr;
-	}
-}
-
-void duckdb_destroy_arrow_stream(duckdb_arrow_stream *stream_p) {
-
-	auto stream = reinterpret_cast<ArrowArrayStream *>(*stream_p);
-	if (!stream) {
-		return;
-	}
-	if (stream->release) {
-		stream->release(stream);
-	}
-	D_ASSERT(!stream->release);
-
-	delete stream;
-	*stream_p = nullptr;
-}
-
-duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement, duckdb_arrow *out_result) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError() || !out_result) {
-		return DuckDBError;
-	}
-	auto arrow_wrapper = new ArrowResultWrapper();
-	auto result = wrapper->statement->Execute(wrapper->values, false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	arrow_wrapper->result = duckdb::unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
-	*out_result = reinterpret_cast<duckdb_arrow>(arrow_wrapper);
-	return !arrow_wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
-}
-
-namespace arrow_array_stream_wrapper {
-namespace {
-struct PrivateData {
-	ArrowSchema *schema;
-	ArrowArray *array;
-	bool done = false;
-};
-
-// LCOV_EXCL_START
-// This function is never called, but used to set ArrowSchema's release functions to a non-null NOOP.
-void EmptySchemaRelease(ArrowSchema *schema) {
-	schema->release = nullptr;
-}
-// LCOV_EXCL_STOP
-
-void EmptyArrayRelease(ArrowArray *array) {
-	array->release = nullptr;
-}
-
-void EmptyStreamRelease(ArrowArrayStream *stream) {
-	stream->release = nullptr;
-}
-
-void FactoryGetSchema(ArrowArrayStream *stream, ArrowSchema &schema) {
-	stream->get_schema(stream, &schema);
-
-	// Need to nullify the root schema's release function here, because streams don't allow us to set the release
-	// function. For the schema's children, we nullify the release functions in `duckdb_arrow_scan`, so we don't need to
-	// handle them again here. We set this to nullptr and not EmptySchemaRelease to prevent ArrowSchemaWrapper's
-	// destructor from destroying the schema (it's the caller's responsibility).
-	schema.release = nullptr;
-}
-
-int GetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out) {
-	auto private_data = static_cast<arrow_array_stream_wrapper::PrivateData *>((stream->private_data));
-	if (private_data->schema == nullptr) {
-		return DuckDBError;
-	}
-
-	*out = *private_data->schema;
-	out->release = EmptySchemaRelease;
-	return DuckDBSuccess;
-}
-
-int GetNext(struct ArrowArrayStream *stream, struct ArrowArray *out) {
-	auto private_data = static_cast<arrow_array_stream_wrapper::PrivateData *>((stream->private_data));
-	*out = *private_data->array;
-	if (private_data->done) {
-		out->release = nullptr;
-	} else {
-		out->release = EmptyArrayRelease;
-	}
-
-	private_data->done = true;
-	return DuckDBSuccess;
-}
-
-duckdb::unique_ptr<duckdb::ArrowArrayStreamWrapper> FactoryGetNext(uintptr_t stream_factory_ptr,
-                                                                   duckdb::ArrowStreamParameters &parameters) {
-	auto stream = reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr);
-	auto ret = duckdb::make_uniq<duckdb::ArrowArrayStreamWrapper>();
-	ret->arrow_array_stream = *stream;
-	ret->arrow_array_stream.release = EmptyStreamRelease;
-	return ret;
-}
-
-// LCOV_EXCL_START
-// This function is never be called, because it's used to construct a stream wrapping around a caller-supplied
-// ArrowArray. Thus, the stream itself cannot produce an error.
-const char *GetLastError(struct ArrowArrayStream *stream) {
-	return nullptr;
-}
-// LCOV_EXCL_STOP
-
-void Release(struct ArrowArrayStream *stream) {
-	if (stream->private_data != nullptr) {
-		delete reinterpret_cast<PrivateData *>(stream->private_data);
-	}
-
-	stream->private_data = nullptr;
-	stream->release = nullptr;
-}
-
-duckdb_state Ingest(duckdb_connection connection, const char *table_name, struct ArrowArrayStream *input) {
-	try {
-		auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
-		cconn
-		    ->TableFunction("arrow_scan", {duckdb::Value::POINTER((uintptr_t)input),
-		                                   duckdb::Value::POINTER((uintptr_t)FactoryGetNext),
-		                                   duckdb::Value::POINTER((uintptr_t)FactoryGetSchema)})
-		    ->CreateView(table_name, true, false);
-	} catch (...) { // LCOV_EXCL_START
-		// Tried covering this in tests, but it proved harder than expected. At the time of writing:
-		// - Passing any name to `CreateView` worked without throwing an exception
-		// - Passing a null Arrow array worked without throwing an exception
-		// - Passing an invalid schema (without any columns) led to an InternalException with SIGABRT, which is meant to
-		//   be un-catchable. This case likely needs to be handled gracefully within `arrow_scan`.
-		// Ref: https://discord.com/channels/909674491309850675/921100573732909107/1115230468699336785
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-
-	return DuckDBSuccess;
-}
-} // namespace
-} // namespace arrow_array_stream_wrapper
-
-duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name, duckdb_arrow_stream arrow) {
-	auto stream = reinterpret_cast<ArrowArrayStream *>(arrow);
-
-	// Backup release functions - we nullify children schema release functions because we don't want to release on
-	// behalf of the caller, downstream in our code. Note that Arrow releases target immediate children, but aren't
-	// recursive. So we only back up immediate children here and restore their functions.
-	ArrowSchema schema;
-	if (stream->get_schema(stream, &schema) == DuckDBError) {
-		return DuckDBError;
-	}
-
-	typedef void (*release_fn_t)(ArrowSchema *);
-	std::vector<release_fn_t> release_fns(duckdb::NumericCast<idx_t>(schema.n_children));
-	for (idx_t i = 0; i < duckdb::NumericCast<idx_t>(schema.n_children); i++) {
-		auto child = schema.children[i];
-		release_fns[i] = child->release;
-		child->release = arrow_array_stream_wrapper::EmptySchemaRelease;
-	}
-
-	auto ret = arrow_array_stream_wrapper::Ingest(connection, table_name, stream);
-
-	// Restore release functions.
-	for (idx_t i = 0; i < duckdb::NumericCast<idx_t>(schema.n_children); i++) {
-		schema.children[i]->release = release_fns[i];
-	}
-
-	return ret;
-}
-
-duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *table_name,
-                                     duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
-                                     duckdb_arrow_stream *out_stream) {
-	auto private_data = new arrow_array_stream_wrapper::PrivateData;
-	private_data->schema = reinterpret_cast<ArrowSchema *>(arrow_schema);
-	private_data->array = reinterpret_cast<ArrowArray *>(arrow_array);
-	private_data->done = false;
-
-	ArrowArrayStream *stream = new ArrowArrayStream;
-	*out_stream = reinterpret_cast<duckdb_arrow_stream>(stream);
-	stream->get_schema = arrow_array_stream_wrapper::GetSchema;
-	stream->get_next = arrow_array_stream_wrapper::GetNext;
-	stream->get_last_error = arrow_array_stream_wrapper::GetLastError;
-	stream->release = arrow_array_stream_wrapper::Release;
-	stream->private_data = private_data;
-
-	return duckdb_arrow_scan(connection, table_name, reinterpret_cast<duckdb_arrow_stream>(stream));
-}
diff --git a/src/duckdb/src/main/capi/cast/from_decimal-c.cpp b/src/duckdb/src/main/capi/cast/from_decimal-c.cpp
deleted file mode 100644
index e6bc6f98c..000000000
--- a/src/duckdb/src/main/capi/cast/from_decimal-c.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#include "duckdb/main/capi/cast/from_decimal.hpp"
-#include "duckdb/common/types/decimal.hpp"
-
-namespace duckdb {
-
-//! DECIMAL -> VARCHAR
-template <>
-bool CastDecimalCInternal(duckdb_result *source, duckdb_string &result, idx_t col, idx_t row) {
-	auto result_data = (duckdb::DuckDBResultData *)source->internal_data;
-	auto &query_result = result_data->result;
-	auto &source_type = query_result->types[col];
-	auto width = duckdb::DecimalType::GetWidth(source_type);
-	auto scale = duckdb::DecimalType::GetScale(source_type);
-	duckdb::Vector result_vec(duckdb::LogicalType::VARCHAR, false, false);
-	duckdb::string_t result_string;
-	void *source_address = UnsafeFetchPtr<hugeint_t>(source, col, row);
-	switch (source_type.InternalType()) {
-	case duckdb::PhysicalType::INT16:
-		result_string = duckdb::StringCastFromDecimal::Operation<int16_t>(UnsafeFetchFromPtr<int16_t>(source_address),
-		                                                                  width, scale, result_vec);
-		break;
-	case duckdb::PhysicalType::INT32:
-		result_string = duckdb::StringCastFromDecimal::Operation<int32_t>(UnsafeFetchFromPtr<int32_t>(source_address),
-		                                                                  width, scale, result_vec);
-		break;
-	case duckdb::PhysicalType::INT64:
-		result_string = duckdb::StringCastFromDecimal::Operation<int64_t>(UnsafeFetchFromPtr<int64_t>(source_address),
-		                                                                  width, scale, result_vec);
-		break;
-	case duckdb::PhysicalType::INT128:
-		result_string = duckdb::StringCastFromDecimal::Operation<hugeint_t>(
-		    UnsafeFetchFromPtr<hugeint_t>(source_address), width, scale, result_vec);
-		break;
-	default:
-		throw duckdb::InternalException("Unimplemented internal type for decimal");
-	}
-	result.data = reinterpret_cast<char *>(duckdb_malloc(sizeof(char) * (result_string.GetSize() + 1)));
-	memcpy(result.data, result_string.GetData(), result_string.GetSize());
-	result.data[result_string.GetSize()] = '\0';
-	result.size = result_string.GetSize();
-	return true;
-}
-
-template <class INTERNAL_TYPE>
-duckdb_hugeint FetchInternals(void *source_address) {
-	throw duckdb::NotImplementedException("FetchInternals not implemented for internal type");
-}
-
-template <>
-duckdb_hugeint FetchInternals<int16_t>(void *source_address) {
-	duckdb_hugeint result;
-	int16_t intermediate_result;
-
-	if (!TryCast::Operation<int16_t, int16_t>(UnsafeFetchFromPtr<int16_t>(source_address), intermediate_result)) {
-		intermediate_result = FetchDefaultValue::Operation<int16_t>();
-	}
-	hugeint_t hugeint_result = Hugeint::Cast<int16_t>(intermediate_result);
-	result.lower = hugeint_result.lower;
-	result.upper = hugeint_result.upper;
-	return result;
-}
-template <>
-duckdb_hugeint FetchInternals<int32_t>(void *source_address) {
-	duckdb_hugeint result;
-	int32_t intermediate_result;
-
-	if (!TryCast::Operation<int32_t, int32_t>(UnsafeFetchFromPtr<int32_t>(source_address), intermediate_result)) {
-		intermediate_result = FetchDefaultValue::Operation<int32_t>();
-	}
-	hugeint_t hugeint_result = Hugeint::Cast<int32_t>(intermediate_result);
-	result.lower = hugeint_result.lower;
-	result.upper = hugeint_result.upper;
-	return result;
-}
-template <>
-duckdb_hugeint FetchInternals<int64_t>(void *source_address) {
-	duckdb_hugeint result;
-	int64_t intermediate_result;
-
-	if (!TryCast::Operation<int64_t, int64_t>(UnsafeFetchFromPtr<int64_t>(source_address), intermediate_result)) {
-		intermediate_result = FetchDefaultValue::Operation<int64_t>();
-	}
-	hugeint_t hugeint_result = Hugeint::Cast<int64_t>(intermediate_result);
-	result.lower = hugeint_result.lower;
-	result.upper = hugeint_result.upper;
-	return result;
-}
-template <>
-duckdb_hugeint FetchInternals<hugeint_t>(void *source_address) {
-	duckdb_hugeint result;
-	hugeint_t intermediate_result;
-
-	if (!TryCast::Operation<hugeint_t, hugeint_t>(UnsafeFetchFromPtr<hugeint_t>(source_address), intermediate_result)) {
-		intermediate_result = FetchDefaultValue::Operation<hugeint_t>();
-	}
-	result.lower = intermediate_result.lower;
-	result.upper = intermediate_result.upper;
-	return result;
-}
-
-//! DECIMAL -> DECIMAL (internal fetch)
-template <>
-bool CastDecimalCInternal(duckdb_result *source, duckdb_decimal &result, idx_t col, idx_t row) {
-	auto result_data = (duckdb::DuckDBResultData *)source->internal_data;
-	result_data->result->types[col].GetDecimalProperties(result.width, result.scale);
-	auto source_address = UnsafeFetchPtr<hugeint_t>(source, col, row);
-
-	if (result.width > duckdb::Decimal::MAX_WIDTH_INT64) {
-		result.value = FetchInternals<hugeint_t>(source_address);
-	} else if (result.width > duckdb::Decimal::MAX_WIDTH_INT32) {
-		result.value = FetchInternals<int64_t>(source_address);
-	} else if (result.width > duckdb::Decimal::MAX_WIDTH_INT16) {
-		result.value = FetchInternals<int32_t>(source_address);
-	} else {
-		result.value = FetchInternals<int16_t>(source_address);
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/capi/cast/utils-c.cpp b/src/duckdb/src/main/capi/cast/utils-c.cpp
deleted file mode 100644
index 3bcc0b3ae..000000000
--- a/src/duckdb/src/main/capi/cast/utils-c.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "duckdb/main/capi/cast/utils.hpp"
-
-namespace duckdb {
-
-template <>
-duckdb_decimal FetchDefaultValue::Operation() {
-	duckdb_decimal result;
-	result.scale = 0;
-	result.width = 0;
-	result.value = {0, 0};
-	return result;
-}
-
-template <>
-date_t FetchDefaultValue::Operation() {
-	date_t result;
-	result.days = 0;
-	return result;
-}
-
-template <>
-dtime_t FetchDefaultValue::Operation() {
-	dtime_t result;
-	result.micros = 0;
-	return result;
-}
-
-template <>
-timestamp_t FetchDefaultValue::Operation() {
-	timestamp_t result;
-	result.value = 0;
-	return result;
-}
-
-template <>
-interval_t FetchDefaultValue::Operation() {
-	interval_t result;
-	result.months = 0;
-	result.days = 0;
-	result.micros = 0;
-	return result;
-}
-
-template <>
-char *FetchDefaultValue::Operation() {
-	return nullptr;
-}
-
-template <>
-duckdb_string FetchDefaultValue::Operation() {
-	duckdb_string result;
-	result.data = nullptr;
-	result.size = 0;
-	return result;
-}
-
-template <>
-duckdb_blob FetchDefaultValue::Operation() {
-	duckdb_blob result;
-	result.data = nullptr;
-	result.size = 0;
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Blob Casts
-//===--------------------------------------------------------------------===//
-
-template <>
-bool FromCBlobCastWrapper::Operation(duckdb_blob input, duckdb_string &result) {
-	string_t input_str(const_char_ptr_cast(input.data), UnsafeNumericCast<uint32_t>(input.size));
-	return ToCStringCastWrapper<duckdb::CastFromBlob>::template Operation<string_t, duckdb_string>(input_str, result);
-}
-
-} // namespace duckdb
-
-bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result) {
-		return false;
-	}
-	if (!duckdb::DeprecatedMaterializeResult(result)) {
-		return false;
-	}
-	if (col >= result->deprecated_column_count || row >= result->deprecated_row_count) {
-		return false;
-	}
-	return true;
-}
-
-bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanUseDeprecatedFetch(result, col, row)) {
-		return false;
-	}
-	if (result->deprecated_columns[col].deprecated_nullmask[row]) {
-		return false;
-	}
-	return true;
-}
diff --git a/src/duckdb/src/main/capi/cast_function-c.cpp b/src/duckdb/src/main/capi/cast_function-c.cpp
deleted file mode 100644
index 39a5d90a7..000000000
--- a/src/duckdb/src/main/capi/cast_function-c.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-
-namespace duckdb {
-struct CCastExecuteInfo {
-	CastParameters &parameters;
-	string error_message;
-
-	explicit CCastExecuteInfo(CastParameters &parameters) : parameters(parameters), error_message() {
-	}
-};
-
-struct CCastFunction {
-	unique_ptr<LogicalType> source_type;
-	unique_ptr<LogicalType> target_type;
-	int64_t implicit_cast_cost = -1;
-
-	duckdb_cast_function_t function;
-	duckdb_function_info extra_info = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-};
-
-struct CCastFunctionUserData {
-
-	duckdb_function_info data_ptr = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-
-	CCastFunctionUserData(duckdb_function_info data_ptr_p, duckdb_delete_callback_t delete_callback_p)
-	    : data_ptr(data_ptr_p), delete_callback(delete_callback_p) {
-	}
-
-	~CCastFunctionUserData() {
-		if (data_ptr && delete_callback) {
-			delete_callback(data_ptr);
-		}
-		data_ptr = nullptr;
-		delete_callback = nullptr;
-	}
-};
-
-struct CCastFunctionData final : public BoundCastData {
-	duckdb_cast_function_t function;
-	shared_ptr<CCastFunctionUserData> extra_info;
-
-	explicit CCastFunctionData(duckdb_cast_function_t function_p, shared_ptr<CCastFunctionUserData> extra_info_p)
-	    : function(function_p), extra_info(std::move(extra_info_p)) {
-	}
-
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<CCastFunctionData>(function, extra_info);
-	}
-};
-
-static bool CAPICastFunction(Vector &input, Vector &output, idx_t count, CastParameters &parameters) {
-
-	const auto is_const = input.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	input.Flatten(count);
-
-	CCastExecuteInfo exec_info(parameters);
-	const auto &data = parameters.cast_data->Cast<CCastFunctionData>();
-
-	auto c_input = reinterpret_cast<duckdb_vector>(&input);
-	auto c_output = reinterpret_cast<duckdb_vector>(&output);
-	auto c_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-
-	const auto success = data.function(c_info, count, c_input, c_output);
-
-	if (!success) {
-		HandleCastError::AssignError(exec_info.error_message, parameters);
-	}
-
-	if (is_const && count == 1 && (success || !parameters.strict)) {
-		output.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	return success;
-}
-
-} // namespace duckdb
-
-duckdb_cast_function duckdb_create_cast_function() {
-	const auto function = new duckdb::CCastFunction();
-	return reinterpret_cast<duckdb_cast_function>(function);
-}
-
-void duckdb_cast_function_set_source_type(duckdb_cast_function cast_function, duckdb_logical_type source_type) {
-	if (!cast_function || !source_type) {
-		return;
-	}
-	const auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(source_type));
-	auto &cast = *(reinterpret_cast<duckdb::CCastFunction *>(cast_function));
-	cast.source_type = duckdb::make_uniq<duckdb::LogicalType>(logical_type);
-}
-
-void duckdb_cast_function_set_target_type(duckdb_cast_function cast_function, duckdb_logical_type target_type) {
-	if (!cast_function || !target_type) {
-		return;
-	}
-	const auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(target_type));
-	auto &cast = *(reinterpret_cast<duckdb::CCastFunction *>(cast_function));
-	cast.target_type = duckdb::make_uniq<duckdb::LogicalType>(logical_type);
-}
-
-void duckdb_cast_function_set_implicit_cast_cost(duckdb_cast_function cast_function, int64_t cost) {
-	if (!cast_function) {
-		return;
-	}
-	auto &custom_type = *(reinterpret_cast<duckdb::CCastFunction *>(cast_function));
-	custom_type.implicit_cast_cost = cost;
-}
-
-void duckdb_cast_function_set_function(duckdb_cast_function cast_function, duckdb_cast_function_t function) {
-	if (!cast_function || !function) {
-		return;
-	}
-	auto &cast = *(reinterpret_cast<duckdb::CCastFunction *>(cast_function));
-	cast.function = function;
-}
-
-duckdb_cast_mode duckdb_cast_function_get_cast_mode(duckdb_function_info info) {
-	const auto &cast_info = *reinterpret_cast<duckdb::CCastExecuteInfo *>(info);
-	return cast_info.parameters.error_message == nullptr ? DUCKDB_CAST_NORMAL : DUCKDB_CAST_TRY;
-}
-
-void duckdb_cast_function_set_error(duckdb_function_info info, const char *error) {
-	auto &cast_info = *reinterpret_cast<duckdb::CCastExecuteInfo *>(info);
-	cast_info.error_message = error;
-}
-
-void duckdb_cast_function_set_row_error(duckdb_function_info info, const char *error, idx_t row, duckdb_vector output) {
-	auto &cast_info = *reinterpret_cast<duckdb::CCastExecuteInfo *>(info);
-	cast_info.error_message = error;
-	if (!output) {
-		return;
-	}
-	auto &output_vector = *reinterpret_cast<duckdb::Vector *>(output);
-	duckdb::FlatVector::SetNull(output_vector, row, true);
-}
-
-void duckdb_cast_function_set_extra_info(duckdb_cast_function cast_function, void *extra_info,
-                                         duckdb_delete_callback_t destroy) {
-	if (!cast_function || !extra_info) {
-		return;
-	}
-	auto &cast = *reinterpret_cast<duckdb::CCastFunction *>(cast_function);
-	cast.extra_info = static_cast<duckdb_function_info>(extra_info);
-	cast.delete_callback = destroy;
-}
-
-void *duckdb_cast_function_get_extra_info(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &cast_info = *reinterpret_cast<duckdb::CCastExecuteInfo *>(info);
-	auto &cast_data = cast_info.parameters.cast_data->Cast<duckdb::CCastFunctionData>();
-	return cast_data.extra_info->data_ptr;
-}
-
-duckdb_state duckdb_register_cast_function(duckdb_connection connection, duckdb_cast_function cast_function) {
-	if (!connection || !cast_function) {
-		return DuckDBError;
-	}
-	auto &cast = *reinterpret_cast<duckdb::CCastFunction *>(cast_function);
-	if (!cast.source_type || !cast.target_type || !cast.function) {
-		return DuckDBError;
-	}
-
-	const auto &source_type = *cast.source_type;
-	const auto &target_type = *cast.target_type;
-
-	if (duckdb::TypeVisitor::Contains(source_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(source_type, duckdb::LogicalTypeId::ANY)) {
-		return DuckDBError;
-	}
-
-	if (duckdb::TypeVisitor::Contains(target_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(target_type, duckdb::LogicalTypeId::ANY)) {
-		return DuckDBError;
-	}
-
-	try {
-		const auto con = reinterpret_cast<duckdb::Connection *>(connection);
-		con->context->RunFunctionInTransaction([&]() {
-			auto &config = duckdb::DBConfig::GetConfig(*con->context);
-			auto &casts = config.GetCastFunctions();
-
-			auto extra_info =
-			    duckdb::make_shared_ptr<duckdb::CCastFunctionUserData>(cast.extra_info, cast.delete_callback);
-			auto cast_data = duckdb::make_uniq<duckdb::CCastFunctionData>(cast.function, std::move(extra_info));
-			duckdb::BoundCastInfo cast_info(duckdb::CAPICastFunction, std::move(cast_data));
-			casts.RegisterCastFunction(source_type, target_type, std::move(cast_info), cast.implicit_cast_cost);
-		});
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-void duckdb_destroy_cast_function(duckdb_cast_function *cast_function) {
-	if (!cast_function || !*cast_function) {
-		return;
-	}
-	const auto function = reinterpret_cast<duckdb::CCastFunction *>(*cast_function);
-	delete function;
-	*cast_function = nullptr;
-}
diff --git a/src/duckdb/src/main/capi/config-c.cpp b/src/duckdb/src/main/capi/config-c.cpp
deleted file mode 100644
index 68605056d..000000000
--- a/src/duckdb/src/main/capi/config-c.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-using duckdb::DBConfig;
-using duckdb::Value;
-
-// config
-duckdb_state duckdb_create_config(duckdb_config *out_config) {
-	if (!out_config) {
-		return DuckDBError;
-	}
-	try {
-		*out_config = nullptr;
-		auto config = new DBConfig();
-		*out_config = reinterpret_cast<duckdb_config>(config);
-		config->SetOptionByName("duckdb_api", "capi");
-	} catch (...) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-size_t duckdb_config_count() {
-	return DBConfig::GetOptionCount() + duckdb::ExtensionHelper::ArraySize(duckdb::EXTENSION_SETTINGS);
-}
-
-duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description) {
-	auto option = DBConfig::GetOptionByIndex(index);
-	if (option) {
-		if (out_name) {
-			*out_name = option->name;
-		}
-		if (out_description) {
-			*out_description = option->description;
-		}
-		return DuckDBSuccess;
-	}
-
-	// extension index?
-	auto entry = duckdb::ExtensionHelper::GetArrayEntry(duckdb::EXTENSION_SETTINGS, index - DBConfig::GetOptionCount());
-	if (!entry) {
-		return DuckDBError;
-	}
-	if (out_name) {
-		*out_name = entry->name;
-	}
-	if (out_description) {
-		*out_description = entry->extension;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option) {
-	if (!config || !name || !option) {
-		return DuckDBError;
-	}
-
-	try {
-		auto db_config = (DBConfig *)config;
-		db_config->SetOptionByName(name, Value(option));
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-void duckdb_destroy_config(duckdb_config *config) {
-	if (!config) {
-		return;
-	}
-	if (*config) {
-		auto db_config = (DBConfig *)*config;
-		delete db_config;
-		*config = nullptr;
-	}
-}
diff --git a/src/duckdb/src/main/capi/data_chunk-c.cpp b/src/duckdb/src/main/capi/data_chunk-c.cpp
deleted file mode 100644
index b549e74df..000000000
--- a/src/duckdb/src/main/capi/data_chunk-c.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/type_visitor.hpp"
-
-#include <string.h>
-
-duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *column_types, idx_t column_count) {
-	if (!column_types) {
-		return nullptr;
-	}
-	duckdb::vector<duckdb::LogicalType> types;
-	for (idx_t i = 0; i < column_count; i++) {
-		auto logical_type = reinterpret_cast<duckdb::LogicalType *>(column_types[i]);
-		if (duckdb::TypeVisitor::Contains(*logical_type, duckdb::LogicalTypeId::INVALID) ||
-		    duckdb::TypeVisitor::Contains(*logical_type, duckdb::LogicalTypeId::ANY)) {
-			return nullptr;
-		}
-		types.push_back(*logical_type);
-	}
-
-	auto result = new duckdb::DataChunk();
-	try {
-		result->Initialize(duckdb::Allocator::DefaultAllocator(), types);
-	} catch (...) {
-		delete result;
-		return nullptr;
-	}
-
-	return reinterpret_cast<duckdb_data_chunk>(result);
-}
-
-void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk) {
-	if (chunk && *chunk) {
-		auto data_chunk = reinterpret_cast<duckdb::DataChunk *>(*chunk);
-		delete data_chunk;
-		*chunk = nullptr;
-	}
-}
-
-void duckdb_data_chunk_reset(duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return;
-	}
-	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	dchunk->Reset();
-}
-
-idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return 0;
-	}
-	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	return dchunk->ColumnCount();
-}
-
-duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx) {
-	if (!chunk || col_idx >= duckdb_data_chunk_get_column_count(chunk)) {
-		return nullptr;
-	}
-	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	return reinterpret_cast<duckdb_vector>(&dchunk->data[col_idx]);
-}
-
-idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return 0;
-	}
-	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	return dchunk->size();
-}
-
-void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size) {
-	if (!chunk) {
-		return;
-	}
-	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	dchunk->SetCardinality(size);
-}
-
-duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(v->GetType()));
-}
-
-void *duckdb_vector_get_data(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return duckdb::FlatVector::GetData(*v);
-}
-
-uint64_t *duckdb_vector_get_validity(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return duckdb::FlatVector::Validity(*v).GetData();
-}
-
-void duckdb_vector_ensure_validity_writable(duckdb_vector vector) {
-	if (!vector) {
-		return;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	auto &validity = duckdb::FlatVector::Validity(*v);
-	validity.EnsureWritable();
-}
-
-void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str) {
-	duckdb_vector_assign_string_element_len(vector, index, str, strlen(str));
-}
-
-void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str, idx_t str_len) {
-	if (!vector) {
-		return;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*v);
-	data[index] = duckdb::StringVector::AddStringOrBlob(*v, str, str_len);
-}
-
-duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return reinterpret_cast<duckdb_vector>(&duckdb::ListVector::GetEntry(*v));
-}
-
-idx_t duckdb_list_vector_get_size(duckdb_vector vector) {
-	if (!vector) {
-		return 0;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return duckdb::ListVector::GetListSize(*v);
-}
-
-duckdb_state duckdb_list_vector_set_size(duckdb_vector vector, idx_t size) {
-	if (!vector) {
-		return duckdb_state::DuckDBError;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	duckdb::ListVector::SetListSize(*v, size);
-	return duckdb_state::DuckDBSuccess;
-}
-
-duckdb_state duckdb_list_vector_reserve(duckdb_vector vector, idx_t required_capacity) {
-	if (!vector) {
-		return duckdb_state::DuckDBError;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	duckdb::ListVector::Reserve(*v, required_capacity);
-	return duckdb_state::DuckDBSuccess;
-}
-
-duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return reinterpret_cast<duckdb_vector>(duckdb::StructVector::GetEntries(*v)[index].get());
-}
-
-duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = reinterpret_cast<duckdb::Vector *>(vector);
-	return reinterpret_cast<duckdb_vector>(&duckdb::ArrayVector::GetEntry(*v));
-}
-
-bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row) {
-	if (!validity) {
-		return true;
-	}
-	idx_t entry_idx = row / 64;
-	idx_t idx_in_entry = row % 64;
-	return validity[entry_idx] & ((idx_t)1 << idx_in_entry);
-}
-
-void duckdb_validity_set_row_validity(uint64_t *validity, idx_t row, bool valid) {
-	if (valid) {
-		duckdb_validity_set_row_valid(validity, row);
-	} else {
-		duckdb_validity_set_row_invalid(validity, row);
-	}
-}
-
-void duckdb_validity_set_row_invalid(uint64_t *validity, idx_t row) {
-	if (!validity) {
-		return;
-	}
-	idx_t entry_idx = row / 64;
-	idx_t idx_in_entry = row % 64;
-	validity[entry_idx] &= ~((uint64_t)1 << idx_in_entry);
-}
-
-void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row) {
-	if (!validity) {
-		return;
-	}
-	idx_t entry_idx = row / 64;
-	idx_t idx_in_entry = row % 64;
-	validity[entry_idx] |= (uint64_t)1 << idx_in_entry;
-}
diff --git a/src/duckdb/src/main/capi/datetime-c.cpp b/src/duckdb/src/main/capi/datetime-c.cpp
deleted file mode 100644
index 9e19128a8..000000000
--- a/src/duckdb/src/main/capi/datetime-c.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-
-using duckdb::Date;
-using duckdb::Time;
-using duckdb::Timestamp;
-
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::timestamp_ms_t;
-using duckdb::timestamp_ns_t;
-using duckdb::timestamp_sec_t;
-using duckdb::timestamp_t;
-
-duckdb_date_struct duckdb_from_date(duckdb_date date) {
-	int32_t year, month, day;
-	Date::Convert(date_t(date.days), year, month, day);
-
-	duckdb_date_struct result;
-	result.year = year;
-	result.month = duckdb::UnsafeNumericCast<int8_t>(month);
-	result.day = duckdb::UnsafeNumericCast<int8_t>(day);
-	return result;
-}
-
-duckdb_date duckdb_to_date(duckdb_date_struct date) {
-	duckdb_date result;
-	result.days = Date::FromDate(date.year, date.month, date.day).days;
-	return result;
-}
-
-bool duckdb_is_finite_date(duckdb_date date) {
-	return Date::IsFinite(date_t(date.days));
-}
-
-duckdb_time_struct duckdb_from_time(duckdb_time time) {
-	int32_t hour, minute, second, micros;
-	Time::Convert(dtime_t(time.micros), hour, minute, second, micros);
-
-	duckdb_time_struct result;
-	result.hour = duckdb::UnsafeNumericCast<int8_t>(hour);
-	result.min = duckdb::UnsafeNumericCast<int8_t>(minute);
-	result.sec = duckdb::UnsafeNumericCast<int8_t>(second);
-	result.micros = micros;
-	return result;
-}
-
-duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz input) {
-	duckdb_time_tz_struct result;
-	duckdb_time time;
-
-	duckdb::dtime_tz_t time_tz(input.bits);
-
-	time.micros = time_tz.time().micros;
-
-	result.time = duckdb_from_time(time);
-	result.offset = time_tz.offset();
-	return result;
-}
-
-duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset) {
-	duckdb_time_tz time;
-	time.bits = duckdb::dtime_tz_t(duckdb::dtime_t(micros), offset).bits;
-	return time;
-}
-
-duckdb_time duckdb_to_time(duckdb_time_struct time) {
-	duckdb_time result;
-	result.micros = Time::FromTime(time.hour, time.min, time.sec, time.micros).micros;
-	return result;
-}
-
-duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts) {
-	date_t date;
-	dtime_t time;
-	Timestamp::Convert(timestamp_t(ts.micros), date, time);
-
-	duckdb_date ddate;
-	ddate.days = date.days;
-
-	duckdb_time dtime;
-	dtime.micros = time.micros;
-
-	duckdb_timestamp_struct result;
-	result.date = duckdb_from_date(ddate);
-	result.time = duckdb_from_time(dtime);
-	return result;
-}
-
-duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts) {
-	date_t date = date_t(duckdb_to_date(ts.date).days);
-	dtime_t time = dtime_t(duckdb_to_time(ts.time).micros);
-
-	duckdb_timestamp result;
-	result.micros = Timestamp::FromDatetime(date, time).value;
-	return result;
-}
-
-bool duckdb_is_finite_timestamp(duckdb_timestamp ts) {
-	return Timestamp::IsFinite(timestamp_t(ts.micros));
-}
-
-bool duckdb_is_finite_timestamp_s(duckdb_timestamp_s ts) {
-	return Timestamp::IsFinite(timestamp_sec_t(ts.seconds));
-}
-
-bool duckdb_is_finite_timestamp_ms(duckdb_timestamp_ms ts) {
-	return Timestamp::IsFinite(timestamp_ms_t(ts.millis));
-}
-
-bool duckdb_is_finite_timestamp_ns(duckdb_timestamp_ns ts) {
-	return Timestamp::IsFinite(timestamp_ns_t(ts.nanos));
-}
diff --git a/src/duckdb/src/main/capi/duckdb-c.cpp b/src/duckdb/src/main/capi/duckdb-c.cpp
deleted file mode 100644
index ad47d7448..000000000
--- a/src/duckdb/src/main/capi/duckdb-c.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-
-using duckdb::Connection;
-using duckdb::DatabaseWrapper;
-using duckdb::DBConfig;
-using duckdb::DBInstanceCacheWrapper;
-using duckdb::DuckDB;
-using duckdb::ErrorData;
-
-duckdb_instance_cache duckdb_create_instance_cache() {
-	auto wrapper = new DBInstanceCacheWrapper();
-	wrapper->instance_cache = duckdb::make_uniq<duckdb::DBInstanceCache>();
-	return reinterpret_cast<duckdb_instance_cache>(wrapper);
-}
-
-void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache) {
-	if (instance_cache && *instance_cache) {
-		auto wrapper = reinterpret_cast<DBInstanceCacheWrapper *>(*instance_cache);
-		delete wrapper;
-		*instance_cache = nullptr;
-	}
-}
-
-duckdb_state duckdb_open_internal(DBInstanceCacheWrapper *cache, const char *path, duckdb_database *out,
-                                  duckdb_config config, char **out_error) {
-	auto wrapper = new DatabaseWrapper();
-	try {
-		DBConfig default_config;
-		default_config.SetOptionByName("duckdb_api", "capi");
-
-		DBConfig *db_config = &default_config;
-		DBConfig *user_config = reinterpret_cast<DBConfig *>(config);
-		if (user_config) {
-			db_config = user_config;
-		}
-
-		if (cache) {
-			wrapper->database = cache->instance_cache->GetOrCreateInstance(path, *db_config, true);
-		} else {
-			wrapper->database = duckdb::make_shared_ptr<DuckDB>(path, db_config);
-		}
-
-	} catch (std::exception &ex) {
-		if (out_error) {
-			ErrorData parsed_error(ex);
-			*out_error = strdup(parsed_error.Message().c_str());
-		}
-		delete wrapper;
-		return DuckDBError;
-
-	} catch (...) { // LCOV_EXCL_START
-		if (out_error) {
-			*out_error = strdup("Unknown error");
-		}
-		delete wrapper;
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-
-	*out = reinterpret_cast<duckdb_database>(wrapper);
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path,
-                                             duckdb_database *out_database, duckdb_config config, char **out_error) {
-	if (!instance_cache) {
-		if (out_error) {
-			*out_error = strdup("instance cache cannot be nullptr");
-		}
-		return DuckDBError;
-	}
-	auto cache = reinterpret_cast<DBInstanceCacheWrapper *>(instance_cache);
-	return duckdb_open_internal(cache, path, out_database, config, out_error);
-}
-
-duckdb_state duckdb_open_ext(const char *path, duckdb_database *out, duckdb_config config, char **error) {
-	return duckdb_open_internal(nullptr, path, out, config, error);
-}
-
-duckdb_state duckdb_open(const char *path, duckdb_database *out) {
-	return duckdb_open_ext(path, out, nullptr, nullptr);
-}
-
-void duckdb_close(duckdb_database *database) {
-	if (database && *database) {
-		auto wrapper = reinterpret_cast<DatabaseWrapper *>(*database);
-		delete wrapper;
-		*database = nullptr;
-	}
-}
-
-duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) {
-	if (!database || !out) {
-		return DuckDBError;
-	}
-
-	auto wrapper = reinterpret_cast<DatabaseWrapper *>(database);
-	Connection *connection;
-	try {
-		connection = new Connection(*wrapper->database);
-	} catch (...) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-
-	*out = reinterpret_cast<duckdb_connection>(connection);
-	return DuckDBSuccess;
-}
-
-void duckdb_interrupt(duckdb_connection connection) {
-	if (!connection) {
-		return;
-	}
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	conn->Interrupt();
-}
-
-duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection) {
-	duckdb_query_progress_type query_progress_type;
-	query_progress_type.percentage = -1;
-	query_progress_type.total_rows_to_process = 0;
-	query_progress_type.rows_processed = 0;
-	if (!connection) {
-		return query_progress_type;
-	}
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	auto query_progress = conn->context->GetQueryProgress();
-	query_progress_type.total_rows_to_process = query_progress.GetTotalRowsToProcess();
-	query_progress_type.rows_processed = query_progress.GetRowsProcesseed();
-	query_progress_type.percentage = query_progress.GetPercentage();
-	return query_progress_type;
-}
-
-void duckdb_disconnect(duckdb_connection *connection) {
-	if (connection && *connection) {
-		Connection *conn = reinterpret_cast<Connection *>(*connection);
-		delete conn;
-		*connection = nullptr;
-	}
-}
-
-duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out) {
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	auto result = conn->Query(query);
-	return DuckDBTranslateResult(std::move(result), out);
-}
-
-const char *duckdb_library_version() {
-	return DuckDB::LibraryVersion();
-}
diff --git a/src/duckdb/src/main/capi/duckdb_value-c.cpp b/src/duckdb/src/main/capi/duckdb_value-c.cpp
deleted file mode 100644
index 7f75691bc..000000000
--- a/src/duckdb/src/main/capi/duckdb_value-c.cpp
+++ /dev/null
@@ -1,539 +0,0 @@
-#include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/varint.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-
-using duckdb::LogicalTypeId;
-
-static duckdb_value WrapValue(duckdb::Value *value) {
-	return reinterpret_cast<duckdb_value>(value);
-}
-
-static duckdb::LogicalType &UnwrapType(duckdb_logical_type type) {
-	return *(reinterpret_cast<duckdb::LogicalType *>(type));
-}
-
-static duckdb::Value &UnwrapValue(duckdb_value value) {
-	return *(reinterpret_cast<duckdb::Value *>(value));
-}
-void duckdb_destroy_value(duckdb_value *value) {
-	if (value && *value) {
-		auto &unwrap_value = UnwrapValue(*value);
-		delete &unwrap_value;
-		*value = nullptr;
-	}
-}
-
-duckdb_value duckdb_create_varchar_length(const char *text, idx_t length) {
-	return WrapValue(new duckdb::Value(std::string(text, length)));
-}
-
-duckdb_value duckdb_create_varchar(const char *text) {
-	return duckdb_create_varchar_length(text, strlen(text));
-}
-
-template <class T>
-static duckdb_value CAPICreateValue(T input) {
-	return WrapValue(new duckdb::Value(duckdb::Value::CreateValue<T>(input)));
-}
-
-template <class T, LogicalTypeId TYPE_ID>
-static T CAPIGetValue(duckdb_value val) {
-	auto &v = UnwrapValue(val);
-	if (!v.DefaultTryCastAs(TYPE_ID)) {
-		return duckdb::NullValue<T>();
-	}
-	return v.GetValue<T>();
-}
-
-duckdb_value duckdb_create_bool(bool input) {
-	return CAPICreateValue(input);
-}
-bool duckdb_get_bool(duckdb_value val) {
-	return CAPIGetValue<bool, LogicalTypeId::BOOLEAN>(val);
-}
-duckdb_value duckdb_create_int8(int8_t input) {
-	return CAPICreateValue(input);
-}
-int8_t duckdb_get_int8(duckdb_value val) {
-	return CAPIGetValue<int8_t, LogicalTypeId::TINYINT>(val);
-}
-duckdb_value duckdb_create_uint8(uint8_t input) {
-	return CAPICreateValue(input);
-}
-uint8_t duckdb_get_uint8(duckdb_value val) {
-	return CAPIGetValue<uint8_t, LogicalTypeId::UTINYINT>(val);
-}
-duckdb_value duckdb_create_int16(int16_t input) {
-	return CAPICreateValue(input);
-}
-int16_t duckdb_get_int16(duckdb_value val) {
-	return CAPIGetValue<int16_t, LogicalTypeId::SMALLINT>(val);
-}
-duckdb_value duckdb_create_uint16(uint16_t input) {
-	return CAPICreateValue(input);
-}
-uint16_t duckdb_get_uint16(duckdb_value val) {
-	return CAPIGetValue<uint16_t, LogicalTypeId::USMALLINT>(val);
-}
-duckdb_value duckdb_create_int32(int32_t input) {
-	return CAPICreateValue(input);
-}
-int32_t duckdb_get_int32(duckdb_value val) {
-	return CAPIGetValue<int32_t, LogicalTypeId::INTEGER>(val);
-}
-duckdb_value duckdb_create_uint32(uint32_t input) {
-	return CAPICreateValue(input);
-}
-uint32_t duckdb_get_uint32(duckdb_value val) {
-	return CAPIGetValue<uint32_t, LogicalTypeId::UINTEGER>(val);
-}
-duckdb_value duckdb_create_uint64(uint64_t input) {
-	return CAPICreateValue(input);
-}
-uint64_t duckdb_get_uint64(duckdb_value val) {
-	return CAPIGetValue<uint64_t, LogicalTypeId::UBIGINT>(val);
-}
-duckdb_value duckdb_create_int64(int64_t input) {
-	return CAPICreateValue(input);
-}
-int64_t duckdb_get_int64(duckdb_value val) {
-	return CAPIGetValue<int64_t, LogicalTypeId::BIGINT>(val);
-}
-duckdb_value duckdb_create_hugeint(duckdb_hugeint input) {
-	return WrapValue(new duckdb::Value(duckdb::Value::HUGEINT(duckdb::hugeint_t(input.upper, input.lower))));
-}
-duckdb_hugeint duckdb_get_hugeint(duckdb_value val) {
-	auto res = CAPIGetValue<duckdb::hugeint_t, LogicalTypeId::HUGEINT>(val);
-	return {res.lower, res.upper};
-}
-duckdb_value duckdb_create_uhugeint(duckdb_uhugeint input) {
-	return WrapValue(new duckdb::Value(duckdb::Value::UHUGEINT(duckdb::uhugeint_t(input.upper, input.lower))));
-}
-duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val) {
-	auto res = CAPIGetValue<duckdb::uhugeint_t, LogicalTypeId::UHUGEINT>(val);
-	return {res.lower, res.upper};
-}
-duckdb_value duckdb_create_varint(duckdb_varint input) {
-	return WrapValue(new duckdb::Value(
-	    duckdb::Value::VARINT(duckdb::Varint::FromByteArray(input.data, input.size, input.is_negative))));
-}
-duckdb_varint duckdb_get_varint(duckdb_value val) {
-	auto v = UnwrapValue(val).DefaultCastAs(duckdb::LogicalType::VARINT);
-	auto &str = duckdb::StringValue::Get(v);
-	duckdb::vector<uint8_t> byte_array;
-	bool is_negative;
-	duckdb::Varint::GetByteArray(byte_array, is_negative, duckdb::string_t(str));
-	auto size = byte_array.size();
-	auto data = reinterpret_cast<uint8_t *>(malloc(size));
-	memcpy(data, byte_array.data(), size);
-	return {data, size, is_negative};
-}
-duckdb_value duckdb_create_decimal(duckdb_decimal input) {
-	duckdb::hugeint_t hugeint(input.value.upper, input.value.lower);
-	int64_t int64;
-	if (duckdb::Hugeint::TryCast<int64_t>(hugeint, int64)) {
-		// The int64 DECIMAL value constructor will select the appropriate physical type based on width.
-		return WrapValue(new duckdb::Value(duckdb::Value::DECIMAL(int64, input.width, input.scale)));
-	} else {
-		// The hugeint DECIMAL value constructor always uses a physical hugeint, and requires width >= MAX_WIDTH_INT64.
-		return WrapValue(new duckdb::Value(duckdb::Value::DECIMAL(hugeint, input.width, input.scale)));
-	}
-}
-duckdb_decimal duckdb_get_decimal(duckdb_value val) {
-	auto &v = UnwrapValue(val);
-	auto &type = v.type();
-	if (type.id() != LogicalTypeId::DECIMAL) {
-		return {0, 0, {0, 0}};
-	}
-	auto width = duckdb::DecimalType::GetWidth(type);
-	auto scale = duckdb::DecimalType::GetScale(type);
-	duckdb::hugeint_t hugeint = duckdb::IntegralValue::Get(v);
-	return {width, scale, {hugeint.lower, hugeint.upper}};
-}
-duckdb_value duckdb_create_float(float input) {
-	return CAPICreateValue(input);
-}
-float duckdb_get_float(duckdb_value val) {
-	return CAPIGetValue<float, LogicalTypeId::FLOAT>(val);
-}
-duckdb_value duckdb_create_double(double input) {
-	return CAPICreateValue(input);
-}
-double duckdb_get_double(duckdb_value val) {
-	return CAPIGetValue<double, LogicalTypeId::DOUBLE>(val);
-}
-duckdb_value duckdb_create_date(duckdb_date input) {
-	return CAPICreateValue(duckdb::date_t(input.days));
-}
-duckdb_date duckdb_get_date(duckdb_value val) {
-	return {CAPIGetValue<duckdb::date_t, LogicalTypeId::DATE>(val).days};
-}
-duckdb_value duckdb_create_time(duckdb_time input) {
-	return CAPICreateValue(duckdb::dtime_t(input.micros));
-}
-duckdb_time duckdb_get_time(duckdb_value val) {
-	return {CAPIGetValue<duckdb::dtime_t, LogicalTypeId::TIME>(val).micros};
-}
-duckdb_value duckdb_create_time_tz_value(duckdb_time_tz input) {
-	return CAPICreateValue(duckdb::dtime_tz_t(input.bits));
-}
-duckdb_time_tz duckdb_get_time_tz(duckdb_value val) {
-	return {CAPIGetValue<duckdb::dtime_tz_t, LogicalTypeId::TIME_TZ>(val).bits};
-}
-
-duckdb_value duckdb_create_timestamp(duckdb_timestamp input) {
-	duckdb::timestamp_t ts(input.micros);
-	return CAPICreateValue(ts);
-}
-
-duckdb_timestamp duckdb_get_timestamp(duckdb_value val) {
-	if (!val) {
-		return {0};
-	}
-	return {CAPIGetValue<duckdb::timestamp_t, LogicalTypeId::TIMESTAMP>(val).value};
-}
-
-duckdb_value duckdb_create_timestamp_tz(duckdb_timestamp input) {
-	duckdb::timestamp_tz_t ts(input.micros);
-	return CAPICreateValue(ts);
-}
-
-duckdb_timestamp duckdb_get_timestamp_tz(duckdb_value val) {
-	if (!val) {
-		return {0};
-	}
-	return {CAPIGetValue<duckdb::timestamp_tz_t, LogicalTypeId::TIMESTAMP_TZ>(val).value};
-}
-
-duckdb_value duckdb_create_timestamp_s(duckdb_timestamp_s input) {
-	duckdb::timestamp_sec_t ts(input.seconds);
-	return CAPICreateValue(ts);
-}
-
-duckdb_timestamp_s duckdb_get_timestamp_s(duckdb_value val) {
-	if (!val) {
-		return {0};
-	}
-	return {CAPIGetValue<duckdb::timestamp_sec_t, LogicalTypeId::TIMESTAMP_SEC>(val).value};
-}
-
-duckdb_value duckdb_create_timestamp_ms(duckdb_timestamp_ms input) {
-	duckdb::timestamp_ms_t ts(input.millis);
-	return CAPICreateValue(ts);
-}
-
-duckdb_timestamp_ms duckdb_get_timestamp_ms(duckdb_value val) {
-	if (!val) {
-		return {0};
-	}
-	return {CAPIGetValue<duckdb::timestamp_ms_t, LogicalTypeId::TIMESTAMP_MS>(val).value};
-}
-
-duckdb_value duckdb_create_timestamp_ns(duckdb_timestamp_ns input) {
-	duckdb::timestamp_ns_t ts(input.nanos);
-	return CAPICreateValue(ts);
-}
-
-duckdb_timestamp_ns duckdb_get_timestamp_ns(duckdb_value val) {
-	if (!val) {
-		return {0};
-	}
-	return {CAPIGetValue<duckdb::timestamp_ns_t, LogicalTypeId::TIMESTAMP_NS>(val).value};
-}
-
-duckdb_value duckdb_create_interval(duckdb_interval input) {
-	return WrapValue(new duckdb::Value(duckdb::Value::INTERVAL(input.months, input.days, input.micros)));
-}
-duckdb_interval duckdb_get_interval(duckdb_value val) {
-	auto interval = CAPIGetValue<duckdb::interval_t, LogicalTypeId::INTERVAL>(val);
-	return {interval.months, interval.days, interval.micros};
-}
-duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length) {
-	return WrapValue(new duckdb::Value(duckdb::Value::BLOB((const uint8_t *)data, length)));
-}
-duckdb_blob duckdb_get_blob(duckdb_value val) {
-	auto res = UnwrapValue(val).DefaultCastAs(duckdb::LogicalType::BLOB);
-	auto &str = duckdb::StringValue::Get(res);
-
-	auto result = reinterpret_cast<void *>(malloc(sizeof(char) * str.size()));
-	memcpy(result, str.c_str(), str.size());
-	return {result, str.size()};
-}
-duckdb_value duckdb_create_bit(duckdb_bit input) {
-	return WrapValue(new duckdb::Value(duckdb::Value::BIT(input.data, input.size)));
-}
-duckdb_bit duckdb_get_bit(duckdb_value val) {
-	auto v = UnwrapValue(val).DefaultCastAs(duckdb::LogicalType::BIT);
-	auto &str = duckdb::StringValue::Get(v);
-	auto size = str.size();
-	auto data = reinterpret_cast<uint8_t *>(malloc(size));
-	memcpy(data, str.c_str(), size);
-	return {data, size};
-}
-duckdb_value duckdb_create_uuid(duckdb_uhugeint input) {
-	// uhugeint_t has a constexpr ctor with upper first
-	return WrapValue(new duckdb::Value(duckdb::Value::UUID(duckdb::UUID::FromUHugeint({input.upper, input.lower}))));
-}
-duckdb_uhugeint duckdb_get_uuid(duckdb_value val) {
-	auto hugeint = CAPIGetValue<duckdb::hugeint_t, LogicalTypeId::UUID>(val);
-	auto uhugeint = duckdb::UUID::ToUHugeint(hugeint);
-	// duckdb_uhugeint has no constexpr ctor; struct is lower first
-	return {uhugeint.lower, uhugeint.upper};
-}
-
-duckdb_logical_type duckdb_get_value_type(duckdb_value val) {
-	auto &type = UnwrapValue(val).type();
-	return (duckdb_logical_type)(&type);
-}
-
-char *duckdb_get_varchar(duckdb_value value) {
-	auto val = reinterpret_cast<duckdb::Value *>(value);
-	auto str_val = val->DefaultCastAs(duckdb::LogicalType::VARCHAR);
-	auto &str = duckdb::StringValue::Get(str_val);
-
-	auto result = reinterpret_cast<char *>(malloc(sizeof(char) * (str.size() + 1)));
-	memcpy(result, str.c_str(), str.size());
-	result[str.size()] = '\0';
-	return result;
-}
-duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values) {
-	if (!type || !values) {
-		return nullptr;
-	}
-	const auto &logical_type = UnwrapType(type);
-	if (logical_type.id() != duckdb::LogicalTypeId::STRUCT) {
-		return nullptr;
-	}
-	if (duckdb::TypeVisitor::Contains(logical_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(logical_type, duckdb::LogicalTypeId::ANY)) {
-		return nullptr;
-	}
-
-	auto count = duckdb::StructType::GetChildCount(logical_type);
-	duckdb::vector<duckdb::Value> unwrapped_values;
-	for (idx_t i = 0; i < count; i++) {
-		auto value = values[i];
-		if (!value) {
-			return nullptr;
-		}
-		unwrapped_values.emplace_back(UnwrapValue(value));
-	}
-	duckdb::Value *struct_value = new duckdb::Value;
-	try {
-		*struct_value = duckdb::Value::STRUCT(logical_type, std::move(unwrapped_values));
-	} catch (...) {
-		delete struct_value;
-		return nullptr;
-	}
-	return WrapValue(struct_value);
-}
-
-duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count) {
-	if (!type || !values) {
-		return nullptr;
-	}
-	auto &logical_type = UnwrapType(type);
-	duckdb::vector<duckdb::Value> unwrapped_values;
-	if (duckdb::TypeVisitor::Contains(logical_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(logical_type, duckdb::LogicalTypeId::ANY)) {
-		return nullptr;
-	}
-
-	for (idx_t i = 0; i < value_count; i++) {
-		auto value = values[i];
-		if (!value) {
-			return nullptr;
-		}
-		unwrapped_values.push_back(UnwrapValue(value));
-	}
-	duckdb::Value *list_value = new duckdb::Value;
-	try {
-		*list_value = duckdb::Value::LIST(logical_type, std::move(unwrapped_values));
-	} catch (...) {
-		delete list_value;
-		return nullptr;
-	}
-	return WrapValue(list_value);
-}
-
-duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count) {
-	if (!type || !values) {
-		return nullptr;
-	}
-	if (value_count >= duckdb::ArrayType::MAX_ARRAY_SIZE) {
-		return nullptr;
-	}
-	auto &logical_type = UnwrapType(type);
-	if (duckdb::TypeVisitor::Contains(logical_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(logical_type, duckdb::LogicalTypeId::ANY)) {
-		return nullptr;
-	}
-	duckdb::vector<duckdb::Value> unwrapped_values;
-
-	for (idx_t i = 0; i < value_count; i++) {
-		auto value = values[i];
-		if (!value) {
-			return nullptr;
-		}
-		unwrapped_values.push_back(UnwrapValue(value));
-	}
-	duckdb::Value *array_value = new duckdb::Value;
-	try {
-		*array_value = duckdb::Value::ARRAY(logical_type, std::move(unwrapped_values));
-	} catch (...) {
-		delete array_value;
-		return nullptr;
-	}
-	return WrapValue(array_value);
-}
-
-idx_t duckdb_get_map_size(duckdb_value value) {
-	if (!value) {
-		return 0;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::MAP || val.IsNull()) {
-		return 0;
-	}
-
-	auto &children = duckdb::MapValue::GetChildren(val);
-	return children.size();
-}
-
-duckdb_value duckdb_get_map_key(duckdb_value value, idx_t index) {
-	if (!value) {
-		return nullptr;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::MAP || val.IsNull()) {
-		return nullptr;
-	}
-
-	auto &children = duckdb::MapValue::GetChildren(val);
-	if (index >= children.size()) {
-		return nullptr;
-	}
-
-	auto &child = children[index];
-	auto &child_struct = duckdb::StructValue::GetChildren(child);
-	return WrapValue(new duckdb::Value(child_struct[0]));
-}
-
-duckdb_value duckdb_get_map_value(duckdb_value value, idx_t index) {
-	if (!value) {
-		return nullptr;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::MAP || val.IsNull()) {
-		return nullptr;
-	}
-
-	auto &children = duckdb::MapValue::GetChildren(val);
-	if (index >= children.size()) {
-		return nullptr;
-	}
-
-	auto &child = children[index];
-	auto &child_struct = duckdb::StructValue::GetChildren(child);
-	return WrapValue(new duckdb::Value(child_struct[1]));
-}
-
-bool duckdb_is_null_value(duckdb_value value) {
-	if (!value) {
-		return false;
-	}
-	return UnwrapValue(value).IsNull();
-}
-
-duckdb_value duckdb_create_null_value() {
-	return WrapValue(new duckdb::Value());
-}
-
-idx_t duckdb_get_list_size(duckdb_value value) {
-	if (!value) {
-		return 0;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::LIST || val.IsNull()) {
-		return 0;
-	}
-
-	auto &children = duckdb::ListValue::GetChildren(val);
-	return children.size();
-}
-
-duckdb_value duckdb_get_list_child(duckdb_value value, idx_t index) {
-	if (!value) {
-		return nullptr;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::LIST || val.IsNull()) {
-		return nullptr;
-	}
-
-	auto &children = duckdb::ListValue::GetChildren(val);
-	if (index >= children.size()) {
-		return nullptr;
-	}
-
-	return WrapValue(new duckdb::Value(children[index]));
-}
-
-duckdb_value duckdb_create_enum_value(duckdb_logical_type type, uint64_t value) {
-	if (!type) {
-		return nullptr;
-	}
-
-	auto &logical_type = UnwrapType(type);
-	if (logical_type.id() != LogicalTypeId::ENUM) {
-		return nullptr;
-	}
-
-	if (value >= duckdb::EnumType::GetSize(logical_type)) {
-		return nullptr;
-	}
-
-	return WrapValue(new duckdb::Value(duckdb::Value::ENUM(value, logical_type)));
-}
-
-uint64_t duckdb_get_enum_value(duckdb_value value) {
-	if (!value) {
-		return 0;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::ENUM || val.IsNull()) {
-		return 0;
-	}
-
-	return val.GetValue<uint64_t>();
-}
-
-duckdb_value duckdb_get_struct_child(duckdb_value value, idx_t index) {
-	if (!value) {
-		return nullptr;
-	}
-
-	auto val = UnwrapValue(value);
-	if (val.type().id() != LogicalTypeId::STRUCT || val.IsNull()) {
-		return nullptr;
-	}
-
-	auto &children = duckdb::StructValue::GetChildren(val);
-	if (index >= children.size()) {
-		return nullptr;
-	}
-
-	return WrapValue(new duckdb::Value(children[index]));
-}
diff --git a/src/duckdb/src/main/capi/helper-c.cpp b/src/duckdb/src/main/capi/helper-c.cpp
deleted file mode 100644
index 710996537..000000000
--- a/src/duckdb/src/main/capi/helper-c.cpp
+++ /dev/null
@@ -1,316 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-
-namespace duckdb {
-
-LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
-	switch (c_type) {
-	case DUCKDB_TYPE_INVALID:
-		return LogicalTypeId::INVALID;
-	case DUCKDB_TYPE_BOOLEAN:
-		return LogicalTypeId::BOOLEAN;
-	case DUCKDB_TYPE_TINYINT:
-		return LogicalTypeId::TINYINT;
-	case DUCKDB_TYPE_SMALLINT:
-		return LogicalTypeId::SMALLINT;
-	case DUCKDB_TYPE_INTEGER:
-		return LogicalTypeId::INTEGER;
-	case DUCKDB_TYPE_BIGINT:
-		return LogicalTypeId::BIGINT;
-	case DUCKDB_TYPE_UTINYINT:
-		return LogicalTypeId::UTINYINT;
-	case DUCKDB_TYPE_USMALLINT:
-		return LogicalTypeId::USMALLINT;
-	case DUCKDB_TYPE_UINTEGER:
-		return LogicalTypeId::UINTEGER;
-	case DUCKDB_TYPE_UBIGINT:
-		return LogicalTypeId::UBIGINT;
-	case DUCKDB_TYPE_FLOAT:
-		return LogicalTypeId::FLOAT;
-	case DUCKDB_TYPE_DOUBLE:
-		return LogicalTypeId::DOUBLE;
-	case DUCKDB_TYPE_TIMESTAMP:
-		return LogicalTypeId::TIMESTAMP;
-	case DUCKDB_TYPE_DATE:
-		return LogicalTypeId::DATE;
-	case DUCKDB_TYPE_TIME:
-		return LogicalTypeId::TIME;
-	case DUCKDB_TYPE_INTERVAL:
-		return LogicalTypeId::INTERVAL;
-	case DUCKDB_TYPE_HUGEINT:
-		return LogicalTypeId::HUGEINT;
-	case DUCKDB_TYPE_UHUGEINT:
-		return LogicalTypeId::UHUGEINT;
-	case DUCKDB_TYPE_VARCHAR:
-		return LogicalTypeId::VARCHAR;
-	case DUCKDB_TYPE_BLOB:
-		return LogicalTypeId::BLOB;
-	case DUCKDB_TYPE_DECIMAL:
-		return LogicalTypeId::DECIMAL;
-	case DUCKDB_TYPE_TIMESTAMP_S:
-		return LogicalTypeId::TIMESTAMP_SEC;
-	case DUCKDB_TYPE_TIMESTAMP_MS:
-		return LogicalTypeId::TIMESTAMP_MS;
-	case DUCKDB_TYPE_TIMESTAMP_NS:
-		return LogicalTypeId::TIMESTAMP_NS;
-	case DUCKDB_TYPE_ENUM:
-		return LogicalTypeId::ENUM;
-	case DUCKDB_TYPE_LIST:
-		return LogicalTypeId::LIST;
-	case DUCKDB_TYPE_STRUCT:
-		return LogicalTypeId::STRUCT;
-	case DUCKDB_TYPE_MAP:
-		return LogicalTypeId::MAP;
-	case DUCKDB_TYPE_ARRAY:
-		return LogicalTypeId::ARRAY;
-	case DUCKDB_TYPE_UUID:
-		return LogicalTypeId::UUID;
-	case DUCKDB_TYPE_UNION:
-		return LogicalTypeId::UNION;
-	case DUCKDB_TYPE_BIT:
-		return LogicalTypeId::BIT;
-	case DUCKDB_TYPE_TIME_TZ:
-		return LogicalTypeId::TIME_TZ;
-	case DUCKDB_TYPE_TIMESTAMP_TZ:
-		return LogicalTypeId::TIMESTAMP_TZ;
-	case DUCKDB_TYPE_ANY:
-		return LogicalTypeId::ANY;
-	case DUCKDB_TYPE_SQLNULL:
-		return LogicalTypeId::SQLNULL;
-	default: // LCOV_EXCL_START
-		D_ASSERT(0);
-		return LogicalTypeId::INVALID;
-	} // LCOV_EXCL_STOP
-}
-
-duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
-	switch (sql_type.id()) {
-	case LogicalTypeId::INVALID:
-		return DUCKDB_TYPE_INVALID;
-	case LogicalTypeId::BOOLEAN:
-		return DUCKDB_TYPE_BOOLEAN;
-	case LogicalTypeId::TINYINT:
-		return DUCKDB_TYPE_TINYINT;
-	case LogicalTypeId::SMALLINT:
-		return DUCKDB_TYPE_SMALLINT;
-	case LogicalTypeId::INTEGER:
-		return DUCKDB_TYPE_INTEGER;
-	case LogicalTypeId::BIGINT:
-		return DUCKDB_TYPE_BIGINT;
-	case LogicalTypeId::UTINYINT:
-		return DUCKDB_TYPE_UTINYINT;
-	case LogicalTypeId::USMALLINT:
-		return DUCKDB_TYPE_USMALLINT;
-	case LogicalTypeId::UINTEGER:
-		return DUCKDB_TYPE_UINTEGER;
-	case LogicalTypeId::UBIGINT:
-		return DUCKDB_TYPE_UBIGINT;
-	case LogicalTypeId::HUGEINT:
-		return DUCKDB_TYPE_HUGEINT;
-	case LogicalTypeId::UHUGEINT:
-		return DUCKDB_TYPE_UHUGEINT;
-	case LogicalTypeId::FLOAT:
-		return DUCKDB_TYPE_FLOAT;
-	case LogicalTypeId::DOUBLE:
-		return DUCKDB_TYPE_DOUBLE;
-	case LogicalTypeId::TIMESTAMP:
-		return DUCKDB_TYPE_TIMESTAMP;
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return DUCKDB_TYPE_TIMESTAMP_TZ;
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return DUCKDB_TYPE_TIMESTAMP_S;
-	case LogicalTypeId::TIMESTAMP_MS:
-		return DUCKDB_TYPE_TIMESTAMP_MS;
-	case LogicalTypeId::TIMESTAMP_NS:
-		return DUCKDB_TYPE_TIMESTAMP_NS;
-	case LogicalTypeId::DATE:
-		return DUCKDB_TYPE_DATE;
-	case LogicalTypeId::TIME:
-		return DUCKDB_TYPE_TIME;
-	case LogicalTypeId::TIME_TZ:
-		return DUCKDB_TYPE_TIME_TZ;
-	case LogicalTypeId::VARCHAR:
-		return DUCKDB_TYPE_VARCHAR;
-	case LogicalTypeId::BLOB:
-		return DUCKDB_TYPE_BLOB;
-	case LogicalTypeId::BIT:
-		return DUCKDB_TYPE_BIT;
-	case LogicalTypeId::VARINT:
-		return DUCKDB_TYPE_VARINT;
-	case LogicalTypeId::INTERVAL:
-		return DUCKDB_TYPE_INTERVAL;
-	case LogicalTypeId::DECIMAL:
-		return DUCKDB_TYPE_DECIMAL;
-	case LogicalTypeId::ENUM:
-		return DUCKDB_TYPE_ENUM;
-	case LogicalTypeId::LIST:
-		return DUCKDB_TYPE_LIST;
-	case LogicalTypeId::STRUCT:
-		return DUCKDB_TYPE_STRUCT;
-	case LogicalTypeId::MAP:
-		return DUCKDB_TYPE_MAP;
-	case LogicalTypeId::UNION:
-		return DUCKDB_TYPE_UNION;
-	case LogicalTypeId::UUID:
-		return DUCKDB_TYPE_UUID;
-	case LogicalTypeId::ARRAY:
-		return DUCKDB_TYPE_ARRAY;
-	case LogicalTypeId::ANY:
-		return DUCKDB_TYPE_ANY;
-	case LogicalTypeId::SQLNULL:
-		return DUCKDB_TYPE_SQLNULL;
-	default: // LCOV_EXCL_START
-		D_ASSERT(0);
-		return DUCKDB_TYPE_INVALID;
-	} // LCOV_EXCL_STOP
-}
-
-idx_t GetCTypeSize(duckdb_type type) {
-	switch (type) {
-	case DUCKDB_TYPE_BOOLEAN:
-		return sizeof(bool);
-	case DUCKDB_TYPE_TINYINT:
-		return sizeof(int8_t);
-	case DUCKDB_TYPE_SMALLINT:
-		return sizeof(int16_t);
-	case DUCKDB_TYPE_INTEGER:
-		return sizeof(int32_t);
-	case DUCKDB_TYPE_BIGINT:
-		return sizeof(int64_t);
-	case DUCKDB_TYPE_UTINYINT:
-		return sizeof(uint8_t);
-	case DUCKDB_TYPE_USMALLINT:
-		return sizeof(uint16_t);
-	case DUCKDB_TYPE_UINTEGER:
-		return sizeof(uint32_t);
-	case DUCKDB_TYPE_UBIGINT:
-		return sizeof(uint64_t);
-	case DUCKDB_TYPE_UHUGEINT:
-	case DUCKDB_TYPE_HUGEINT:
-	case DUCKDB_TYPE_UUID:
-		return sizeof(duckdb_hugeint);
-	case DUCKDB_TYPE_FLOAT:
-		return sizeof(float);
-	case DUCKDB_TYPE_DOUBLE:
-		return sizeof(double);
-	case DUCKDB_TYPE_DATE:
-		return sizeof(duckdb_date);
-	case DUCKDB_TYPE_TIME:
-		return sizeof(duckdb_time);
-	case DUCKDB_TYPE_TIMESTAMP:
-	case DUCKDB_TYPE_TIMESTAMP_TZ:
-	case DUCKDB_TYPE_TIMESTAMP_S:
-	case DUCKDB_TYPE_TIMESTAMP_MS:
-	case DUCKDB_TYPE_TIMESTAMP_NS:
-		return sizeof(duckdb_timestamp);
-	case DUCKDB_TYPE_VARCHAR:
-		return sizeof(const char *);
-	case DUCKDB_TYPE_BLOB:
-		return sizeof(duckdb_blob);
-	case DUCKDB_TYPE_INTERVAL:
-		return sizeof(duckdb_interval);
-	case DUCKDB_TYPE_DECIMAL:
-		return sizeof(duckdb_hugeint);
-	default: // LCOV_EXCL_START
-		// Unsupported nested or complex type. Internally, we set the null mask to NULL.
-		// This is a deprecated code path. Use the Vector Interface for nested and complex types.
-		return 0;
-	} // LCOV_EXCL_STOP
-}
-
-duckdb_statement_type StatementTypeToC(duckdb::StatementType statement_type) {
-	switch (statement_type) {
-	case duckdb::StatementType::SELECT_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_SELECT;
-	case duckdb::StatementType::INVALID_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_INVALID;
-	case duckdb::StatementType::INSERT_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_INSERT;
-	case duckdb::StatementType::UPDATE_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_UPDATE;
-	case duckdb::StatementType::EXPLAIN_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_EXPLAIN;
-	case duckdb::StatementType::DELETE_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_DELETE;
-	case duckdb::StatementType::PREPARE_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_PREPARE;
-	case duckdb::StatementType::CREATE_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_CREATE;
-	case duckdb::StatementType::EXECUTE_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_EXECUTE;
-	case duckdb::StatementType::ALTER_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_ALTER;
-	case duckdb::StatementType::TRANSACTION_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_TRANSACTION;
-	case duckdb::StatementType::COPY_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_COPY;
-	case duckdb::StatementType::ANALYZE_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_ANALYZE;
-	case duckdb::StatementType::VARIABLE_SET_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_VARIABLE_SET;
-	case duckdb::StatementType::CREATE_FUNC_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_CREATE_FUNC;
-	case duckdb::StatementType::DROP_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_DROP;
-	case duckdb::StatementType::EXPORT_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_EXPORT;
-	case duckdb::StatementType::PRAGMA_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_PRAGMA;
-	case duckdb::StatementType::VACUUM_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_VACUUM;
-	case duckdb::StatementType::CALL_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_CALL;
-	case duckdb::StatementType::SET_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_SET;
-	case duckdb::StatementType::LOAD_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_LOAD;
-	case duckdb::StatementType::RELATION_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_RELATION;
-	case duckdb::StatementType::EXTENSION_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_EXTENSION;
-	case duckdb::StatementType::LOGICAL_PLAN_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN;
-	case duckdb::StatementType::ATTACH_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_ATTACH;
-	case duckdb::StatementType::DETACH_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_DETACH;
-	case duckdb::StatementType::MULTI_STATEMENT:
-		return DUCKDB_STATEMENT_TYPE_MULTI;
-	default:
-		return DUCKDB_STATEMENT_TYPE_INVALID;
-	}
-}
-
-} // namespace duckdb
-
-void *duckdb_malloc(size_t size) {
-	return malloc(size);
-}
-
-void duckdb_free(void *ptr) {
-	free(ptr);
-}
-
-idx_t duckdb_vector_size() {
-	return STANDARD_VECTOR_SIZE;
-}
-
-bool duckdb_string_is_inlined(duckdb_string_t string_p) {
-	static_assert(sizeof(duckdb_string_t) == sizeof(duckdb::string_t),
-	              "duckdb_string_t should have the same memory layout as duckdb::string_t");
-	auto &string = *reinterpret_cast<duckdb::string_t *>(&string_p);
-	return string.IsInlined();
-}
-
-uint32_t duckdb_string_t_length(duckdb_string_t string_p) {
-	static_assert(sizeof(duckdb_string_t) == sizeof(duckdb::string_t),
-	              "duckdb_string_t should have the same memory layout as duckdb::string_t");
-	auto &string = *reinterpret_cast<duckdb::string_t *>(&string_p);
-	return static_cast<uint32_t>(string.GetSize());
-}
-
-const char *duckdb_string_t_data(duckdb_string_t *string_p) {
-	static_assert(sizeof(duckdb_string_t) == sizeof(duckdb::string_t),
-	              "duckdb_string_t should have the same memory layout as duckdb::string_t");
-	auto &string = *reinterpret_cast<duckdb::string_t *>(string_p);
-	return string.GetData();
-}
diff --git a/src/duckdb/src/main/capi/hugeint-c.cpp b/src/duckdb/src/main/capi/hugeint-c.cpp
deleted file mode 100644
index 5ac7120f1..000000000
--- a/src/duckdb/src/main/capi/hugeint-c.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/types/uhugeint.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-#include "duckdb/main/capi/cast/utils.hpp"
-#include "duckdb/main/capi/cast/to_decimal.hpp"
-
-using duckdb::Hugeint;
-using duckdb::hugeint_t;
-using duckdb::Uhugeint;
-using duckdb::uhugeint_t;
-using duckdb::Value;
-
-double duckdb_hugeint_to_double(duckdb_hugeint val) {
-	hugeint_t internal;
-	internal.lower = val.lower;
-	internal.upper = val.upper;
-	return Hugeint::Cast<double>(internal);
-}
-
-double duckdb_uhugeint_to_double(duckdb_uhugeint val) {
-	uhugeint_t internal;
-	internal.lower = val.lower;
-	internal.upper = val.upper;
-	return Uhugeint::Cast<double>(internal);
-}
-
-static duckdb_decimal to_decimal_cast(double val, uint8_t width, uint8_t scale) {
-	if (width > duckdb::Decimal::MAX_WIDTH_INT64) {
-		return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<hugeint_t>>(val, width, scale);
-	}
-	if (width > duckdb::Decimal::MAX_WIDTH_INT32) {
-		return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<int64_t>>(val, width, scale);
-	}
-	if (width > duckdb::Decimal::MAX_WIDTH_INT16) {
-		return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<int32_t>>(val, width, scale);
-	}
-	return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<int16_t>>(val, width, scale);
-}
-
-duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale) {
-	if (scale > width || width > duckdb::Decimal::MAX_WIDTH_INT128) {
-		return duckdb::FetchDefaultValue::Operation<duckdb_decimal>();
-	}
-	return to_decimal_cast(val, width, scale);
-}
-
-duckdb_hugeint duckdb_double_to_hugeint(double val) {
-	hugeint_t internal_result;
-	if (!Value::DoubleIsFinite(val) || !Hugeint::TryConvert<double>(val, internal_result)) {
-		internal_result.lower = 0;
-		internal_result.upper = 0;
-	}
-
-	duckdb_hugeint result;
-	result.lower = internal_result.lower;
-	result.upper = internal_result.upper;
-	return result;
-}
-
-duckdb_uhugeint duckdb_double_to_uhugeint(double val) {
-	uhugeint_t internal_result;
-	if (!Value::DoubleIsFinite(val) || !Uhugeint::TryConvert<double>(val, internal_result)) {
-		internal_result.lower = 0;
-		internal_result.upper = 0;
-	}
-
-	duckdb_uhugeint result;
-	result.lower = internal_result.lower;
-	result.upper = internal_result.upper;
-	return result;
-}
-
-double duckdb_decimal_to_double(duckdb_decimal val) {
-	double result;
-	hugeint_t value;
-	value.lower = val.value.lower;
-	value.upper = val.value.upper;
-	duckdb::CastParameters parameters;
-	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, parameters, val.width, val.scale);
-	return result;
-}
diff --git a/src/duckdb/src/main/capi/logical_types-c.cpp b/src/duckdb/src/main/capi/logical_types-c.cpp
deleted file mode 100644
index 6837c5276..000000000
--- a/src/duckdb/src/main/capi/logical_types-c.cpp
+++ /dev/null
@@ -1,387 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-struct CCustomType {
-	unique_ptr<LogicalType> base_type;
-	string name;
-};
-
-} // namespace duckdb
-
-static bool AssertLogicalTypeId(duckdb_logical_type type, duckdb::LogicalTypeId type_id) {
-	if (!type) {
-		return false;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (logical_type.id() != type_id) {
-		return false;
-	}
-	return true;
-}
-
-static bool AssertInternalType(duckdb_logical_type type, duckdb::PhysicalType physical_type) {
-	if (!type) {
-		return false;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (logical_type.InternalType() != physical_type) {
-		return false;
-	}
-	return true;
-}
-
-duckdb_logical_type duckdb_create_logical_type(duckdb_type type) {
-	if (type == DUCKDB_TYPE_DECIMAL || type == DUCKDB_TYPE_ENUM || type == DUCKDB_TYPE_LIST ||
-	    type == DUCKDB_TYPE_STRUCT || type == DUCKDB_TYPE_MAP || type == DUCKDB_TYPE_ARRAY ||
-	    type == DUCKDB_TYPE_UNION) {
-		type = DUCKDB_TYPE_INVALID;
-	}
-
-	auto cpp_type = duckdb::ConvertCTypeToCPP(type);
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(cpp_type));
-}
-
-duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
-	if (!type) {
-		return nullptr;
-	}
-	duckdb::LogicalType *logical_type = new duckdb::LogicalType;
-	*logical_type = duckdb::LogicalType::LIST(*reinterpret_cast<duckdb::LogicalType *>(type));
-	return reinterpret_cast<duckdb_logical_type>(logical_type);
-}
-
-duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size) {
-	if (!type) {
-		return nullptr;
-	}
-	if (array_size >= duckdb::ArrayType::MAX_ARRAY_SIZE) {
-		return nullptr;
-	}
-	duckdb::LogicalType *ltype = new duckdb::LogicalType;
-	*ltype = duckdb::LogicalType::ARRAY(*reinterpret_cast<duckdb::LogicalType *>(type), array_size);
-	return reinterpret_cast<duckdb_logical_type>(ltype);
-}
-
-duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types_p, const char **member_names,
-                                             idx_t member_count) {
-	if (!member_types_p || !member_names) {
-		return nullptr;
-	}
-	duckdb::LogicalType **member_types = reinterpret_cast<duckdb::LogicalType **>(member_types_p);
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	duckdb::child_list_t<duckdb::LogicalType> members;
-
-	for (idx_t i = 0; i < member_count; i++) {
-		members.push_back(make_pair(member_names[i], *member_types[i]));
-	}
-	*mtype = duckdb::LogicalType::UNION(members);
-	return reinterpret_cast<duckdb_logical_type>(mtype);
-}
-
-duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types_p, const char **member_names,
-                                              idx_t member_count) {
-	if (!member_types_p || !member_names) {
-		return nullptr;
-	}
-	duckdb::LogicalType **member_types = (duckdb::LogicalType **)member_types_p;
-	for (idx_t i = 0; i < member_count; i++) {
-		if (!member_names[i] || !member_types[i]) {
-			return nullptr;
-		}
-	}
-
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	duckdb::child_list_t<duckdb::LogicalType> members;
-
-	for (idx_t i = 0; i < member_count; i++) {
-		members.push_back(make_pair(member_names[i], *member_types[i]));
-	}
-	*mtype = duckdb::LogicalType::STRUCT(members);
-	return reinterpret_cast<duckdb_logical_type>(mtype);
-}
-
-duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count) {
-	if (!member_names) {
-		return nullptr;
-	}
-	duckdb::Vector enum_vector(duckdb::LogicalType::VARCHAR, member_count);
-	auto enum_vector_ptr = duckdb::FlatVector::GetData<duckdb::string_t>(enum_vector);
-
-	for (idx_t i = 0; i < member_count; i++) {
-		if (!member_names[i]) {
-			return nullptr;
-		}
-		enum_vector_ptr[i] = duckdb::StringVector::AddStringOrBlob(enum_vector, member_names[i]);
-	}
-
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	*mtype = duckdb::LogicalType::ENUM(enum_vector, member_count);
-	return reinterpret_cast<duckdb_logical_type>(mtype);
-}
-
-duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
-	if (!key_type || !value_type) {
-		return nullptr;
-	}
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	*mtype = duckdb::LogicalType::MAP(*reinterpret_cast<duckdb::LogicalType *>(key_type),
-	                                  *reinterpret_cast<duckdb::LogicalType *>(value_type));
-	return reinterpret_cast<duckdb_logical_type>(mtype);
-}
-
-duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale) {
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::LogicalType::DECIMAL(width, scale)));
-}
-
-duckdb_type duckdb_get_type_id(duckdb_logical_type type) {
-	if (!type) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	return duckdb::ConvertCPPTypeToC(*logical_type);
-}
-
-void duckdb_destroy_logical_type(duckdb_logical_type *type) {
-	if (type && *type) {
-		auto logical_type = reinterpret_cast<duckdb::LogicalType *>(*type);
-		delete logical_type;
-		*type = nullptr;
-	}
-}
-
-uint8_t duckdb_decimal_width(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::DECIMAL)) {
-		return 0;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return duckdb::DecimalType::GetWidth(logical_type);
-}
-
-uint8_t duckdb_decimal_scale(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::DECIMAL)) {
-		return 0;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return duckdb::DecimalType::GetScale(logical_type);
-}
-
-duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::DECIMAL)) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	switch (logical_type.InternalType()) {
-	case duckdb::PhysicalType::INT16:
-		return DUCKDB_TYPE_SMALLINT;
-	case duckdb::PhysicalType::INT32:
-		return DUCKDB_TYPE_INTEGER;
-	case duckdb::PhysicalType::INT64:
-		return DUCKDB_TYPE_BIGINT;
-	case duckdb::PhysicalType::INT128:
-		return DUCKDB_TYPE_HUGEINT;
-	default:
-		return DUCKDB_TYPE_INVALID;
-	}
-}
-
-duckdb_type duckdb_enum_internal_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ENUM)) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	switch (logical_type.InternalType()) {
-	case duckdb::PhysicalType::UINT8:
-		return DUCKDB_TYPE_UTINYINT;
-	case duckdb::PhysicalType::UINT16:
-		return DUCKDB_TYPE_USMALLINT;
-	case duckdb::PhysicalType::UINT32:
-		return DUCKDB_TYPE_UINTEGER;
-	default:
-		return DUCKDB_TYPE_INVALID;
-	}
-}
-
-uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ENUM)) {
-		return 0;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return duckdb::NumericCast<uint32_t>(duckdb::EnumType::GetSize(logical_type));
-}
-
-char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ENUM)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	auto &vector = duckdb::EnumType::GetValuesInsertOrder(logical_type);
-	auto value = vector.GetValue(index);
-	return strdup(duckdb::StringValue::Get(value).c_str());
-}
-
-duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::LIST) &&
-	    !AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (logical_type.id() != duckdb::LogicalTypeId::LIST && logical_type.id() != duckdb::LogicalTypeId::MAP) {
-		return nullptr;
-	}
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::ListType::GetChildType(logical_type)));
-}
-
-duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ARRAY)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (logical_type.id() != duckdb::LogicalTypeId::ARRAY) {
-		return nullptr;
-	}
-	return reinterpret_cast<duckdb_logical_type>(
-	    new duckdb::LogicalType(duckdb::ArrayType::GetChildType(logical_type)));
-}
-
-idx_t duckdb_array_type_array_size(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ARRAY)) {
-		return 0;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (logical_type.id() != duckdb::LogicalTypeId::ARRAY) {
-		return 0;
-	}
-	return duckdb::ArrayType::GetSize(logical_type);
-}
-
-duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
-		return nullptr;
-	}
-	auto &mtype = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
-		return nullptr;
-	}
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::MapType::KeyType(mtype)));
-}
-
-duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
-		return nullptr;
-	}
-	auto &mtype = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
-		return nullptr;
-	}
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::MapType::ValueType(mtype)));
-}
-
-idx_t duckdb_struct_type_child_count(duckdb_logical_type type) {
-	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
-		return 0;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return duckdb::StructType::GetChildCount(logical_type);
-}
-
-idx_t duckdb_union_type_member_count(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::UNION)) {
-		return 0;
-	}
-	idx_t member_count = duckdb_struct_type_child_count(type);
-	if (member_count != 0) {
-		member_count--;
-	}
-	return member_count;
-}
-
-char *duckdb_union_type_member_name(duckdb_logical_type type, idx_t index) {
-	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
-		return nullptr;
-	}
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::UNION)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return strdup(duckdb::UnionType::GetMemberName(logical_type, index).c_str());
-}
-
-duckdb_logical_type duckdb_union_type_member_type(duckdb_logical_type type, idx_t index) {
-	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
-		return nullptr;
-	}
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::UNION)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return reinterpret_cast<duckdb_logical_type>(
-	    new duckdb::LogicalType(duckdb::UnionType::GetMemberType(logical_type, index)));
-}
-
-char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index) {
-	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return strdup(duckdb::StructType::GetChildName(logical_type, index).c_str());
-}
-
-char *duckdb_logical_type_get_alias(duckdb_logical_type type) {
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return logical_type.HasAlias() ? strdup(logical_type.GetAlias().c_str()) : nullptr;
-}
-
-void duckdb_logical_type_set_alias(duckdb_logical_type type, const char *alias) {
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	logical_type.SetAlias(alias);
-}
-
-duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index) {
-	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
-		return nullptr;
-	}
-	auto &logical_type = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	if (logical_type.InternalType() != duckdb::PhysicalType::STRUCT) {
-		return nullptr;
-	}
-	return reinterpret_cast<duckdb_logical_type>(
-	    new duckdb::LogicalType(duckdb::StructType::GetChildType(logical_type, index)));
-}
-
-duckdb_state duckdb_register_logical_type(duckdb_connection connection, duckdb_logical_type type,
-                                          duckdb_create_type_info info) {
-	if (!connection || !type) {
-		return DuckDBError;
-	}
-
-	// Unused for now
-	(void)info;
-
-	const auto &base_type = *reinterpret_cast<duckdb::LogicalType *>(type);
-	if (!base_type.HasAlias()) {
-		return DuckDBError;
-	}
-
-	if (duckdb::TypeVisitor::Contains(base_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(base_type, duckdb::LogicalTypeId::ANY)) {
-		return DuckDBError;
-	}
-
-	try {
-		const auto con = reinterpret_cast<duckdb::Connection *>(connection);
-		con->context->RunFunctionInTransaction([&]() {
-			auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
-			duckdb::CreateTypeInfo info(base_type.GetAlias(), base_type);
-			info.temporary = true;
-			info.internal = true;
-			catalog.CreateType(*con->context, info);
-		});
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
diff --git a/src/duckdb/src/main/capi/pending-c.cpp b/src/duckdb/src/main/capi/pending-c.cpp
deleted file mode 100644
index 1d4fa4dcb..000000000
--- a/src/duckdb/src/main/capi/pending-c.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/pending_query_result.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-
-using duckdb::case_insensitive_map_t;
-using duckdb::make_uniq;
-using duckdb::optional_ptr;
-using duckdb::PendingExecutionResult;
-using duckdb::PendingQueryResult;
-using duckdb::PendingStatementWrapper;
-using duckdb::PreparedStatementWrapper;
-using duckdb::Value;
-
-duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared_statement,
-                                              duckdb_pending_result *out_result, bool allow_streaming) {
-	if (!prepared_statement || !out_result) {
-		return DuckDBError;
-	}
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	auto result = new PendingStatementWrapper();
-	result->allow_streaming = allow_streaming;
-
-	try {
-		result->statement = wrapper->statement->PendingQuery(wrapper->values, allow_streaming);
-	} catch (std::exception &ex) {
-		result->statement = make_uniq<PendingQueryResult>(duckdb::ErrorData(ex));
-	}
-	duckdb_state return_value = !result->statement->HasError() ? DuckDBSuccess : DuckDBError;
-	*out_result = reinterpret_cast<duckdb_pending_result>(result);
-
-	return return_value;
-}
-
-duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
-	return duckdb_pending_prepared_internal(prepared_statement, out_result, false);
-}
-
-duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
-                                               duckdb_pending_result *out_result) {
-	return duckdb_pending_prepared_internal(prepared_statement, out_result, true);
-}
-
-void duckdb_destroy_pending(duckdb_pending_result *pending_result) {
-	if (!pending_result || !*pending_result) {
-		return;
-	}
-	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(*pending_result);
-	if (wrapper->statement) {
-		wrapper->statement->Close();
-	}
-	delete wrapper;
-	*pending_result = nullptr;
-}
-
-const char *duckdb_pending_error(duckdb_pending_result pending_result) {
-	if (!pending_result) {
-		return nullptr;
-	}
-	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
-	if (!wrapper->statement) {
-		return nullptr;
-	}
-	return wrapper->statement->GetError().c_str();
-}
-
-duckdb_pending_state duckdb_pending_execute_check_state(duckdb_pending_result pending_result) {
-	if (!pending_result) {
-		return DUCKDB_PENDING_ERROR;
-	}
-	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
-	if (!wrapper->statement) {
-		return DUCKDB_PENDING_ERROR;
-	}
-	if (wrapper->statement->HasError()) {
-		return DUCKDB_PENDING_ERROR;
-	}
-	PendingExecutionResult return_value;
-	try {
-		return_value = wrapper->statement->CheckPulse();
-	} catch (std::exception &ex) {
-		wrapper->statement->SetError(duckdb::ErrorData(ex));
-		return DUCKDB_PENDING_ERROR;
-	}
-	switch (return_value) {
-	case PendingExecutionResult::BLOCKED:
-	case PendingExecutionResult::RESULT_READY:
-		return DUCKDB_PENDING_RESULT_READY;
-	case PendingExecutionResult::NO_TASKS_AVAILABLE:
-		return DUCKDB_PENDING_NO_TASKS_AVAILABLE;
-	case PendingExecutionResult::RESULT_NOT_READY:
-		return DUCKDB_PENDING_RESULT_NOT_READY;
-	default:
-		return DUCKDB_PENDING_ERROR;
-	}
-}
-
-duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_result) {
-	if (!pending_result) {
-		return DUCKDB_PENDING_ERROR;
-	}
-	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
-	if (!wrapper->statement) {
-		return DUCKDB_PENDING_ERROR;
-	}
-	if (wrapper->statement->HasError()) {
-		return DUCKDB_PENDING_ERROR;
-	}
-	PendingExecutionResult return_value;
-	try {
-		return_value = wrapper->statement->ExecuteTask();
-	} catch (std::exception &ex) {
-		wrapper->statement->SetError(duckdb::ErrorData(ex));
-		return DUCKDB_PENDING_ERROR;
-	}
-	switch (return_value) {
-	case PendingExecutionResult::EXECUTION_FINISHED:
-	case PendingExecutionResult::RESULT_READY:
-		return DUCKDB_PENDING_RESULT_READY;
-	case PendingExecutionResult::BLOCKED:
-	case PendingExecutionResult::NO_TASKS_AVAILABLE:
-		return DUCKDB_PENDING_NO_TASKS_AVAILABLE;
-	case PendingExecutionResult::RESULT_NOT_READY:
-		return DUCKDB_PENDING_RESULT_NOT_READY;
-	default:
-		return DUCKDB_PENDING_ERROR;
-	}
-}
-
-bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state) {
-	switch (pending_state) {
-	case DUCKDB_PENDING_RESULT_READY:
-		return PendingQueryResult::IsResultReady(PendingExecutionResult::RESULT_READY);
-	case DUCKDB_PENDING_NO_TASKS_AVAILABLE:
-		return PendingQueryResult::IsResultReady(PendingExecutionResult::NO_TASKS_AVAILABLE);
-	case DUCKDB_PENDING_RESULT_NOT_READY:
-		return PendingQueryResult::IsResultReady(PendingExecutionResult::RESULT_NOT_READY);
-	case DUCKDB_PENDING_ERROR:
-		return PendingQueryResult::IsResultReady(PendingExecutionResult::EXECUTION_ERROR);
-	default:
-		return PendingQueryResult::IsResultReady(PendingExecutionResult::EXECUTION_ERROR);
-	}
-}
-
-duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result) {
-	if (!pending_result || !out_result) {
-		return DuckDBError;
-	}
-	memset(out_result, 0, sizeof(duckdb_result));
-	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
-	if (!wrapper->statement) {
-		return DuckDBError;
-	}
-
-	duckdb::unique_ptr<duckdb::QueryResult> result;
-	try {
-		result = wrapper->statement->Execute();
-	} catch (std::exception &ex) {
-		duckdb::ErrorData error(ex);
-		result = duckdb::make_uniq<duckdb::MaterializedQueryResult>(std::move(error));
-	}
-
-	wrapper->statement.reset();
-	return DuckDBTranslateResult(std::move(result), out_result);
-}
diff --git a/src/duckdb/src/main/capi/prepared-c.cpp b/src/duckdb/src/main/capi/prepared-c.cpp
deleted file mode 100644
index d033083d0..000000000
--- a/src/duckdb/src/main/capi/prepared-c.cpp
+++ /dev/null
@@ -1,408 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-using duckdb::case_insensitive_map_t;
-using duckdb::Connection;
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::ErrorData;
-using duckdb::ExtractStatementsWrapper;
-using duckdb::hugeint_t;
-using duckdb::LogicalType;
-using duckdb::MaterializedQueryResult;
-using duckdb::optional_ptr;
-using duckdb::PreparedStatementWrapper;
-using duckdb::QueryResultType;
-using duckdb::StringUtil;
-using duckdb::timestamp_t;
-using duckdb::uhugeint_t;
-using duckdb::Value;
-
-idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
-                                duckdb_extracted_statements *out_extracted_statements) {
-	if (!connection || !query || !out_extracted_statements) {
-		return 0;
-	}
-	auto wrapper = new ExtractStatementsWrapper();
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	try {
-		wrapper->statements = conn->ExtractStatements(query);
-	} catch (const std::exception &ex) {
-		ErrorData error(ex);
-		wrapper->error = error.Message();
-	}
-
-	*out_extracted_statements = (duckdb_extracted_statements)wrapper;
-	return wrapper->statements.size();
-}
-
-duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection,
-                                                duckdb_extracted_statements extracted_statements, idx_t index,
-                                                duckdb_prepared_statement *out_prepared_statement) {
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	auto source_wrapper = (ExtractStatementsWrapper *)extracted_statements;
-
-	if (!connection || !out_prepared_statement || index >= source_wrapper->statements.size()) {
-		return DuckDBError;
-	}
-	auto wrapper = new PreparedStatementWrapper();
-	wrapper->statement = conn->Prepare(std::move(source_wrapper->statements[index]));
-
-	*out_prepared_statement = (duckdb_prepared_statement)wrapper;
-	return wrapper->statement->HasError() ? DuckDBError : DuckDBSuccess;
-}
-
-const char *duckdb_extract_statements_error(duckdb_extracted_statements extracted_statements) {
-	auto wrapper = (ExtractStatementsWrapper *)extracted_statements;
-	if (!wrapper || wrapper->error.empty()) {
-		return nullptr;
-	}
-	return wrapper->error.c_str();
-}
-
-duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
-                            duckdb_prepared_statement *out_prepared_statement) {
-	if (!connection || !query || !out_prepared_statement) {
-		return DuckDBError;
-	}
-	auto wrapper = new PreparedStatementWrapper();
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	wrapper->statement = conn->Prepare(query);
-	*out_prepared_statement = reinterpret_cast<duckdb_prepared_statement>(wrapper);
-	return !wrapper->statement->HasError() ? DuckDBSuccess : DuckDBError;
-}
-
-const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || !wrapper->statement->HasError()) {
-		return nullptr;
-	}
-	return wrapper->statement->error.Message().c_str();
-}
-
-idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return 0;
-	}
-	return wrapper->statement->named_param_map.size();
-}
-
-static duckdb::string duckdb_parameter_name_internal(duckdb_prepared_statement prepared_statement, idx_t index) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return duckdb::string();
-	}
-	if (index > wrapper->statement->named_param_map.size()) {
-		return duckdb::string();
-	}
-	for (auto &item : wrapper->statement->named_param_map) {
-		auto &identifier = item.first;
-		auto &param_idx = item.second;
-		if (param_idx == index) {
-			// Found the matching parameter
-			return identifier;
-		}
-	}
-	// No parameter was found with this index
-	return duckdb::string();
-}
-
-const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index) {
-	auto identifier = duckdb_parameter_name_internal(prepared_statement, index);
-	if (identifier == duckdb::string()) {
-		return NULL;
-	}
-	return strdup(identifier.c_str());
-}
-
-duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	auto logical_type = duckdb_param_logical_type(prepared_statement, param_idx);
-	if (!logical_type) {
-		return DUCKDB_TYPE_INVALID;
-	}
-
-	auto type = duckdb_get_type_id(logical_type);
-
-	duckdb_destroy_logical_type(&logical_type);
-
-	return type;
-}
-
-duckdb_logical_type duckdb_param_logical_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return nullptr;
-	}
-
-	auto identifier = duckdb_parameter_name_internal(prepared_statement, param_idx);
-	if (identifier == duckdb::string()) {
-		return nullptr;
-	}
-
-	LogicalType param_type;
-
-	if (wrapper->statement->data->TryGetType(identifier, param_type)) {
-		return reinterpret_cast<duckdb_logical_type>(new LogicalType(param_type));
-	}
-	// The value_map is gone after executing the prepared statement
-	// See if this is the case and we still have a value registered for it
-	auto it = wrapper->values.find(identifier);
-	if (it != wrapper->values.end()) {
-		return reinterpret_cast<duckdb_logical_type>(new LogicalType(it->second.return_type));
-	}
-	return nullptr;
-}
-
-duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return DuckDBError;
-	}
-	wrapper->values.clear();
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val) {
-	auto value = reinterpret_cast<Value *>(val);
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return DuckDBError;
-	}
-	if (param_idx <= 0 || param_idx > wrapper->statement->named_param_map.size()) {
-		wrapper->statement->error =
-		    duckdb::InvalidInputException("Can not bind to parameter number %d, statement only has %d parameter(s)",
-		                                  param_idx, wrapper->statement->named_param_map.size());
-		return DuckDBError;
-	}
-	auto identifier = duckdb_parameter_name_internal(prepared_statement, param_idx);
-	wrapper->values[identifier] = duckdb::BoundParameterData(*value);
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
-                                         const char *name_p) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return DuckDBError;
-	}
-	if (!name_p || !param_idx_out) {
-		return DuckDBError;
-	}
-	auto name = std::string(name_p);
-	for (auto &pair : wrapper->statement->named_param_map) {
-		if (duckdb::StringUtil::CIEquals(pair.first, name)) {
-			*param_idx_out = pair.second;
-			return DuckDBSuccess;
-		}
-	}
-	return DuckDBError;
-}
-
-duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val) {
-	auto value = Value::BOOLEAN(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val) {
-	auto value = Value::TINYINT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val) {
-	auto value = Value::SMALLINT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val) {
-	auto value = Value::INTEGER(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val) {
-	auto value = Value::BIGINT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-static hugeint_t duckdb_internal_hugeint(duckdb_hugeint val) {
-	hugeint_t internal;
-	internal.lower = val.lower;
-	internal.upper = val.upper;
-	return internal;
-}
-
-static uhugeint_t duckdb_internal_uhugeint(duckdb_uhugeint val) {
-	uhugeint_t internal;
-	internal.lower = val.lower;
-	internal.upper = val.upper;
-	return internal;
-}
-
-duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val) {
-	auto value = Value::HUGEINT(duckdb_internal_hugeint(val));
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_uhugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_uhugeint val) {
-	auto value = Value::UHUGEINT(duckdb_internal_uhugeint(val));
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val) {
-	auto value = Value::UTINYINT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val) {
-	auto value = Value::USMALLINT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val) {
-	auto value = Value::UINTEGER(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val) {
-	auto value = Value::UBIGINT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val) {
-	auto value = Value::FLOAT(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val) {
-	auto value = Value::DOUBLE(val);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val) {
-	auto value = Value::DATE(date_t(val.days));
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val) {
-	auto value = Value::TIME(dtime_t(val.micros));
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                   duckdb_timestamp val) {
-	auto value = Value::TIMESTAMP(timestamp_t(val.micros));
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_timestamp_tz(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                      duckdb_timestamp val) {
-	auto value = Value::TIMESTAMPTZ(duckdb::timestamp_tz_t(val.micros));
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_interval val) {
-	auto value = Value::INTERVAL(val.months, val.days, val.micros);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val) {
-	try {
-		auto value = Value(val);
-		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-	} catch (...) {
-		return DuckDBError;
-	}
-}
-
-duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val,
-                                        idx_t length) {
-	try {
-		auto value = Value(std::string(val, length));
-		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-	} catch (...) {
-		return DuckDBError;
-	}
-}
-
-duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_decimal val) {
-	auto hugeint_val = duckdb_internal_hugeint(val.value);
-	if (val.width > duckdb::Decimal::MAX_WIDTH_INT64) {
-		auto value = Value::DECIMAL(hugeint_val, val.width, val.scale);
-		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-	}
-	auto value = hugeint_val.lower;
-	auto duck_val = Value::DECIMAL((int64_t)value, val.width, val.scale);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&duck_val);
-}
-
-duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
-                              idx_t length) {
-	auto value = Value::BLOB(duckdb::const_data_ptr_cast(data), length);
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	auto value = Value();
-	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
-}
-
-duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return DuckDBError;
-	}
-
-	duckdb::unique_ptr<duckdb::QueryResult> result;
-	try {
-		result = wrapper->statement->Execute(wrapper->values, false);
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBTranslateResult(std::move(result), out_result);
-}
-
-duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,
-                                               duckdb_result *out_result) {
-	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
-		return DuckDBError;
-	}
-
-	auto result = wrapper->statement->Execute(wrapper->values, true);
-	return DuckDBTranslateResult(std::move(result), out_result);
-}
-
-duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement) {
-	if (!statement) {
-		return DUCKDB_STATEMENT_TYPE_INVALID;
-	}
-	auto stmt = reinterpret_cast<PreparedStatementWrapper *>(statement);
-
-	return StatementTypeToC(stmt->statement->GetStatementType());
-}
-
-template <class T>
-void duckdb_destroy(void **wrapper) {
-	if (!wrapper) {
-		return;
-	}
-
-	auto casted = (T *)*wrapper;
-	if (casted) {
-		delete casted;
-	}
-	*wrapper = nullptr;
-}
-
-void duckdb_destroy_extracted(duckdb_extracted_statements *extracted_statements) {
-	duckdb_destroy<ExtractStatementsWrapper>(reinterpret_cast<void **>(extracted_statements));
-}
-
-void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement) {
-	duckdb_destroy<PreparedStatementWrapper>(reinterpret_cast<void **>(prepared_statement));
-}
diff --git a/src/duckdb/src/main/capi/profiling_info-c.cpp b/src/duckdb/src/main/capi/profiling_info-c.cpp
deleted file mode 100644
index 4936aed4f..000000000
--- a/src/duckdb/src/main/capi/profiling_info-c.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-
-using duckdb::Connection;
-using duckdb::DuckDB;
-using duckdb::EnumUtil;
-using duckdb::MetricsType;
-using duckdb::optional_ptr;
-using duckdb::ProfilingNode;
-
-duckdb_profiling_info duckdb_get_profiling_info(duckdb_connection connection) {
-	if (!connection) {
-		return nullptr;
-	}
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-	optional_ptr<ProfilingNode> profiling_info;
-	try {
-		profiling_info = conn->GetProfilingTree();
-	} catch (std::exception &ex) {
-		return nullptr;
-	}
-
-	ProfilingNode *profiling_info_ptr = profiling_info.get();
-	return reinterpret_cast<duckdb_profiling_info>(profiling_info_ptr);
-}
-
-duckdb_value duckdb_profiling_info_get_value(duckdb_profiling_info info, const char *key) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &node = *reinterpret_cast<duckdb::ProfilingNode *>(info);
-	auto &profiling_info = node.GetProfilingInfo();
-	auto key_enum = EnumUtil::FromString<MetricsType>(duckdb::StringUtil::Upper(key));
-	if (!profiling_info.Enabled(profiling_info.settings, key_enum)) {
-		return nullptr;
-	}
-
-	auto str = profiling_info.GetMetricAsString(key_enum);
-	return duckdb_create_varchar_length(str.c_str(), strlen(str.c_str()));
-}
-
-duckdb_value duckdb_profiling_info_get_metrics(duckdb_profiling_info info) {
-	if (!info) {
-		return nullptr;
-	}
-
-	auto &node = *reinterpret_cast<duckdb::ProfilingNode *>(info);
-	auto &profiling_info = node.GetProfilingInfo();
-
-	duckdb::unordered_map<duckdb::string, duckdb::string> metrics_map;
-	for (const auto &metric : profiling_info.metrics) {
-		auto key = EnumUtil::ToString(metric.first);
-		if (!profiling_info.Enabled(profiling_info.settings, metric.first)) {
-			continue;
-		}
-
-		if (key == EnumUtil::ToString(MetricsType::OPERATOR_TYPE)) {
-			auto type = duckdb::PhysicalOperatorType(metric.second.GetValue<uint8_t>());
-			metrics_map[key] = EnumUtil::ToString(type);
-		} else {
-			metrics_map[key] = metric.second.ToString();
-		}
-	}
-
-	auto map = duckdb::Value::MAP(metrics_map);
-	return reinterpret_cast<duckdb_value>(new duckdb::Value(map));
-}
-
-idx_t duckdb_profiling_info_get_child_count(duckdb_profiling_info info) {
-	if (!info) {
-		return 0;
-	}
-	auto &node = *reinterpret_cast<duckdb::ProfilingNode *>(info);
-	return node.GetChildCount();
-}
-
-duckdb_profiling_info duckdb_profiling_info_get_child(duckdb_profiling_info info, idx_t index) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &node = *reinterpret_cast<duckdb::ProfilingNode *>(info);
-	if (index >= node.GetChildCount()) {
-		return nullptr;
-	}
-
-	ProfilingNode *profiling_info_ptr = node.GetChild(index).get();
-	return reinterpret_cast<duckdb_profiling_info>(profiling_info_ptr);
-}
diff --git a/src/duckdb/src/main/capi/replacement_scan-c.cpp b/src/duckdb/src/main/capi/replacement_scan-c.cpp
deleted file mode 100644
index 5f23a3169..000000000
--- a/src/duckdb/src/main/capi/replacement_scan-c.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-namespace duckdb {
-
-struct CAPIReplacementScanData : public ReplacementScanData {
-	~CAPIReplacementScanData() {
-		if (delete_callback) {
-			delete_callback(extra_data);
-		}
-	}
-
-	duckdb_replacement_callback_t callback;
-	void *extra_data;
-	duckdb_delete_callback_t delete_callback;
-};
-
-struct CAPIReplacementScanInfo {
-	CAPIReplacementScanInfo(optional_ptr<CAPIReplacementScanData> data) : data(data) {
-	}
-
-	optional_ptr<CAPIReplacementScanData> data;
-	string function_name;
-	vector<Value> parameters;
-	string error;
-};
-
-unique_ptr<TableRef> duckdb_capi_replacement_callback(ClientContext &context, ReplacementScanInput &input,
-                                                      optional_ptr<ReplacementScanData> data) {
-	auto &table_name = input.table_name;
-	auto &scan_data = data->Cast<CAPIReplacementScanData>();
-
-	CAPIReplacementScanInfo info(&scan_data);
-	scan_data.callback((duckdb_replacement_scan_info)&info, table_name.c_str(), scan_data.extra_data);
-	if (!info.error.empty()) {
-		throw BinderException("Error in replacement scan: %s\n", info.error);
-	}
-	if (info.function_name.empty()) {
-		// no function provided: bail-out
-		return nullptr;
-	}
-	auto table_function = make_uniq<TableFunctionRef>();
-	vector<unique_ptr<ParsedExpression>> children;
-	for (auto &param : info.parameters) {
-		children.push_back(make_uniq<ConstantExpression>(std::move(param)));
-	}
-	table_function->function = make_uniq<FunctionExpression>(info.function_name, std::move(children));
-	return std::move(table_function);
-}
-
-} // namespace duckdb
-
-void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback_t replacement, void *extra_data,
-                                 duckdb_delete_callback_t delete_callback) {
-	if (!db || !replacement) {
-		return;
-	}
-	auto wrapper = reinterpret_cast<duckdb::DatabaseWrapper *>(db);
-	auto scan_info = duckdb::make_uniq<duckdb::CAPIReplacementScanData>();
-	scan_info->callback = replacement;
-	scan_info->extra_data = extra_data;
-	scan_info->delete_callback = delete_callback;
-
-	auto &config = duckdb::DBConfig::GetConfig(*wrapper->database->instance);
-	config.replacement_scans.push_back(
-	    duckdb::ReplacementScan(duckdb::duckdb_capi_replacement_callback, std::move(scan_info)));
-}
-
-void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info_p, const char *function_name) {
-	if (!info_p || !function_name) {
-		return;
-	}
-	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
-	info->function_name = function_name;
-}
-
-void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info_p, duckdb_value parameter) {
-	if (!info_p || !parameter) {
-		return;
-	}
-	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
-	auto val = reinterpret_cast<duckdb::Value *>(parameter);
-	info->parameters.push_back(*val);
-}
-
-void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info info_p, const char *error) {
-	if (!info_p || !error) {
-		return;
-	}
-	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
-	info->error = error;
-}
diff --git a/src/duckdb/src/main/capi/result-c.cpp b/src/duckdb/src/main/capi/result-c.cpp
deleted file mode 100644
index cc5c6e471..000000000
--- a/src/duckdb/src/main/capi/result-c.cpp
+++ /dev/null
@@ -1,696 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/allocator.hpp"
-
-namespace duckdb {
-
-struct CBaseConverter {
-	template <class DST>
-	static void NullConvert(DST &target) {
-	}
-};
-struct CStandardConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		return input;
-	}
-};
-
-struct CStringConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		auto result = char_ptr_cast(duckdb_malloc(input.GetSize() + 1));
-		assert(result);
-		memcpy((void *)result, input.GetData(), input.GetSize());
-		auto write_arr = char_ptr_cast(result);
-		write_arr[input.GetSize()] = '\0';
-		return result;
-	}
-
-	template <class DST>
-	static void NullConvert(DST &target) {
-		target = nullptr;
-	}
-};
-
-struct CBlobConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		duckdb_blob result;
-		result.data = char_ptr_cast(duckdb_malloc(input.GetSize()));
-		result.size = input.GetSize();
-		assert(result.data);
-		memcpy(result.data, input.GetData(), input.GetSize());
-		return result;
-	}
-
-	template <class DST>
-	static void NullConvert(DST &target) {
-		target.data = nullptr;
-		target.size = 0;
-	}
-};
-
-struct CTimestampMsConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		if (!Timestamp::IsFinite(input)) {
-			return input;
-		}
-		return Timestamp::FromEpochMs(input.value);
-	}
-};
-
-struct CTimestampNsConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		if (!Timestamp::IsFinite(input)) {
-			return input;
-		}
-		return Timestamp::FromEpochNanoSeconds(input.value);
-	}
-};
-
-struct CTimestampSecConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		if (!Timestamp::IsFinite(input)) {
-			return input;
-		}
-		return Timestamp::FromEpochSeconds(input.value);
-	}
-};
-
-struct CHugeintConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		duckdb_hugeint result;
-		result.lower = input.lower;
-		result.upper = input.upper;
-		return result;
-	}
-};
-
-struct CUhugeintConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		duckdb_uhugeint result;
-		result.lower = input.lower;
-		result.upper = input.upper;
-		return result;
-	}
-};
-
-struct CIntervalConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		duckdb_interval result;
-		result.days = input.days;
-		result.months = input.months;
-		result.micros = input.micros;
-		return result;
-	}
-};
-
-template <class T>
-struct CDecimalConverter : public CBaseConverter {
-	template <class SRC, class DST>
-	static DST Convert(SRC input) {
-		duckdb_hugeint result;
-		result.lower = static_cast<uint64_t>(input);
-		result.upper = 0;
-		return result;
-	}
-};
-
-template <class SRC, class DST = SRC, class OP = CStandardConverter>
-void WriteData(duckdb_column *column, ColumnDataCollection &source, const vector<column_t> &column_ids) {
-	idx_t row = 0;
-	auto target = (DST *)column->deprecated_data;
-	for (auto &input : source.Chunks(column_ids)) {
-		auto source = FlatVector::GetData<SRC>(input.data[0]);
-		auto &mask = FlatVector::Validity(input.data[0]);
-
-		for (idx_t k = 0; k < input.size(); k++, row++) {
-			if (!mask.RowIsValid(k)) {
-				OP::template NullConvert<DST>(target[row]);
-			} else {
-				target[row] = OP::template Convert<SRC, DST>(source[k]);
-			}
-		}
-	}
-}
-
-duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result, duckdb_column *column, idx_t col) {
-	D_ASSERT(!result.HasError());
-	auto &collection = result.Collection();
-	idx_t row_count = collection.Count();
-	column->deprecated_nullmask = (bool *)duckdb_malloc(sizeof(bool) * collection.Count());
-
-	auto type_size = GetCTypeSize(column->deprecated_type);
-	if (type_size == 0) {
-		for (idx_t row_id = 0; row_id < row_count; row_id++) {
-			column->deprecated_nullmask[row_id] = false;
-		}
-		// Unsupported type, e.g., a LIST. By returning DuckDBSuccess here,
-		// we allow filling other columns, and return NULL for all unsupported types.
-		return DuckDBSuccess;
-	}
-
-	column->deprecated_data = duckdb_malloc(type_size * row_count);
-	if (!column->deprecated_nullmask || !column->deprecated_data) { // LCOV_EXCL_START
-		// malloc failure
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-
-	vector<column_t> column_ids {col};
-	// first convert the nullmask
-	{
-		idx_t row = 0;
-		for (auto &input : collection.Chunks(column_ids)) {
-			for (idx_t k = 0; k < input.size(); k++) {
-				column->deprecated_nullmask[row++] = FlatVector::IsNull(input.data[0], k);
-			}
-		}
-	}
-	// then write the data
-	switch (result.types[col].id()) {
-	case LogicalTypeId::BOOLEAN:
-		WriteData<bool>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::TINYINT:
-		WriteData<int8_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::SMALLINT:
-		WriteData<int16_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::INTEGER:
-		WriteData<int32_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::BIGINT:
-		WriteData<int64_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::UTINYINT:
-		WriteData<uint8_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::USMALLINT:
-		WriteData<uint16_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::UINTEGER:
-		WriteData<uint32_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::UBIGINT:
-		WriteData<uint64_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::FLOAT:
-		WriteData<float>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::DOUBLE:
-		WriteData<double>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::DATE:
-		WriteData<date_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::TIME:
-		WriteData<dtime_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::TIME_TZ:
-		WriteData<dtime_tz_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		WriteData<timestamp_t>(column, collection, column_ids);
-		break;
-	case LogicalTypeId::VARCHAR: {
-		WriteData<string_t, const char *, CStringConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::BLOB: {
-		WriteData<string_t, duckdb_blob, CBlobConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_NS: {
-		WriteData<timestamp_t, timestamp_t, CTimestampNsConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_MS: {
-		WriteData<timestamp_t, timestamp_t, CTimestampMsConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		WriteData<timestamp_t, timestamp_t, CTimestampSecConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::HUGEINT: {
-		WriteData<hugeint_t, duckdb_hugeint, CHugeintConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::UHUGEINT: {
-		WriteData<uhugeint_t, duckdb_uhugeint, CUhugeintConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::INTERVAL: {
-		WriteData<interval_t, duckdb_interval, CIntervalConverter>(column, collection, column_ids);
-		break;
-	}
-	case LogicalTypeId::DECIMAL: {
-		// get data
-		switch (result.types[col].InternalType()) {
-		case PhysicalType::INT16: {
-			WriteData<int16_t, duckdb_hugeint, CDecimalConverter<int16_t>>(column, collection, column_ids);
-			break;
-		}
-		case PhysicalType::INT32: {
-			WriteData<int32_t, duckdb_hugeint, CDecimalConverter<int32_t>>(column, collection, column_ids);
-			break;
-		}
-		case PhysicalType::INT64: {
-			WriteData<int64_t, duckdb_hugeint, CDecimalConverter<int64_t>>(column, collection, column_ids);
-			break;
-		}
-		case PhysicalType::INT128: {
-			WriteData<hugeint_t, duckdb_hugeint, CHugeintConverter>(column, collection, column_ids);
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported physical type for Decimal" +
-			                         TypeIdToString(result.types[col].InternalType()));
-		}
-		break;
-	}
-	default: // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-duckdb_state DuckDBTranslateResult(unique_ptr<QueryResult> result_p, duckdb_result *out) {
-	auto &result = *result_p;
-	D_ASSERT(result_p);
-	if (!out) {
-		// no result to write to, only return the status
-		return !result.HasError() ? DuckDBSuccess : DuckDBError;
-	}
-
-	memset(out, 0, sizeof(duckdb_result));
-
-	// initialize the result_data object
-	auto result_data = new DuckDBResultData();
-	result_data->result = std::move(result_p);
-	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_NONE;
-	out->internal_data = result_data;
-
-	if (result.HasError()) {
-		// write the error message
-		out->deprecated_error_message = (char *)result.GetError().c_str(); // NOLINT
-		return DuckDBError;
-	}
-	// copy the data
-	// first write the metadata
-	out->deprecated_column_count = result.ColumnCount();
-	out->deprecated_rows_changed = 0;
-	return DuckDBSuccess;
-}
-
-bool DeprecatedMaterializeResult(duckdb_result *result) {
-	if (!result) {
-		return false;
-	}
-	auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
-	if (result_data->result->HasError()) {
-		return false;
-	}
-	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		// already materialized into deprecated result format
-		return true;
-	}
-	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED) {
-		// already used as a new result set
-		return false;
-	}
-	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING) {
-		// already used as a streaming result
-		return false;
-	}
-	// materialize as deprecated result set
-	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED;
-	auto column_count = result_data->result->ColumnCount();
-	result->deprecated_columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * column_count);
-	if (!result->deprecated_columns) { // LCOV_EXCL_START
-		// malloc failure
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-
-	if (result_data->result->type == QueryResultType::STREAM_RESULT) {
-		// if we are dealing with a stream result, convert it to a materialized result first
-		auto &stream_result = (StreamQueryResult &)*result_data->result;
-		result_data->result = stream_result.Materialize();
-	}
-	D_ASSERT(result_data->result->type == QueryResultType::MATERIALIZED_RESULT);
-	auto &materialized = reinterpret_cast<MaterializedQueryResult &>(*result_data->result);
-
-	// convert the result to a materialized result
-	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
-	memset(result->deprecated_columns, 0, sizeof(duckdb_column) * column_count);
-	for (idx_t i = 0; i < column_count; i++) {
-		result->deprecated_columns[i].deprecated_type = ConvertCPPTypeToC(result_data->result->types[i]);
-		result->deprecated_columns[i].deprecated_name = (char *)result_data->result->names[i].c_str(); // NOLINT
-	}
-
-	result->deprecated_row_count = materialized.RowCount();
-	if (result->deprecated_row_count > 0 && materialized.properties.return_type == StatementReturnType::CHANGED_ROWS) {
-		// update total changes
-		auto row_changes = materialized.GetValue(0, 0);
-		if (!row_changes.IsNull() && row_changes.DefaultTryCastAs(LogicalType::BIGINT)) {
-			result->deprecated_rows_changed = NumericCast<idx_t>(row_changes.GetValue<int64_t>());
-		}
-	}
-
-	// Now write the data and skip any unsupported columns.
-	for (idx_t col = 0; col < column_count; col++) {
-		auto state = deprecated_duckdb_translate_column(materialized, &result->deprecated_columns[col], col);
-		if (state != DuckDBSuccess) {
-			return false;
-		}
-	}
-	return true;
-}
-
-duckdb_error_type CAPIErrorType(ExceptionType type) {
-	switch (type) {
-	case ExceptionType::INVALID:
-		return DUCKDB_ERROR_INVALID;
-	case ExceptionType::OUT_OF_RANGE:
-		return DUCKDB_ERROR_OUT_OF_RANGE;
-	case ExceptionType::CONVERSION:
-		return DUCKDB_ERROR_CONVERSION;
-	case ExceptionType::UNKNOWN_TYPE:
-		return DUCKDB_ERROR_UNKNOWN_TYPE;
-	case ExceptionType::DECIMAL:
-		return DUCKDB_ERROR_DECIMAL;
-	case ExceptionType::MISMATCH_TYPE:
-		return DUCKDB_ERROR_MISMATCH_TYPE;
-	case ExceptionType::DIVIDE_BY_ZERO:
-		return DUCKDB_ERROR_DIVIDE_BY_ZERO;
-	case ExceptionType::OBJECT_SIZE:
-		return DUCKDB_ERROR_OBJECT_SIZE;
-	case ExceptionType::INVALID_TYPE:
-		return DUCKDB_ERROR_INVALID_TYPE;
-	case ExceptionType::SERIALIZATION:
-		return DUCKDB_ERROR_SERIALIZATION;
-	case ExceptionType::TRANSACTION:
-		return DUCKDB_ERROR_TRANSACTION;
-	case ExceptionType::NOT_IMPLEMENTED:
-		return DUCKDB_ERROR_NOT_IMPLEMENTED;
-	case ExceptionType::EXPRESSION:
-		return DUCKDB_ERROR_EXPRESSION;
-	case ExceptionType::CATALOG:
-		return DUCKDB_ERROR_CATALOG;
-	case ExceptionType::PARSER:
-		return DUCKDB_ERROR_PARSER;
-	case ExceptionType::PLANNER:
-		return DUCKDB_ERROR_PLANNER;
-	case ExceptionType::SCHEDULER:
-		return DUCKDB_ERROR_SCHEDULER;
-	case ExceptionType::EXECUTOR:
-		return DUCKDB_ERROR_EXECUTOR;
-	case ExceptionType::CONSTRAINT:
-		return DUCKDB_ERROR_CONSTRAINT;
-	case ExceptionType::INDEX:
-		return DUCKDB_ERROR_INDEX;
-	case ExceptionType::STAT:
-		return DUCKDB_ERROR_STAT;
-	case ExceptionType::CONNECTION:
-		return DUCKDB_ERROR_CONNECTION;
-	case ExceptionType::SYNTAX:
-		return DUCKDB_ERROR_SYNTAX;
-	case ExceptionType::SETTINGS:
-		return DUCKDB_ERROR_SETTINGS;
-	case ExceptionType::BINDER:
-		return DUCKDB_ERROR_BINDER;
-	case ExceptionType::NETWORK:
-		return DUCKDB_ERROR_NETWORK;
-	case ExceptionType::OPTIMIZER:
-		return DUCKDB_ERROR_OPTIMIZER;
-	case ExceptionType::NULL_POINTER:
-		return DUCKDB_ERROR_NULL_POINTER;
-	case ExceptionType::IO:
-		return DUCKDB_ERROR_IO;
-	case ExceptionType::INTERRUPT:
-		return DUCKDB_ERROR_INTERRUPT;
-	case ExceptionType::FATAL:
-		return DUCKDB_ERROR_FATAL;
-	case ExceptionType::INTERNAL:
-		return DUCKDB_ERROR_INTERNAL;
-	case ExceptionType::INVALID_INPUT:
-		return DUCKDB_ERROR_INVALID_INPUT;
-	case ExceptionType::OUT_OF_MEMORY:
-		return DUCKDB_ERROR_OUT_OF_MEMORY;
-	case ExceptionType::PERMISSION:
-		return DUCKDB_ERROR_PERMISSION;
-	case ExceptionType::PARAMETER_NOT_RESOLVED:
-		return DUCKDB_ERROR_PARAMETER_NOT_RESOLVED;
-	case ExceptionType::PARAMETER_NOT_ALLOWED:
-		return DUCKDB_ERROR_PARAMETER_NOT_ALLOWED;
-	case ExceptionType::DEPENDENCY:
-		return DUCKDB_ERROR_DEPENDENCY;
-	case ExceptionType::HTTP:
-		return DUCKDB_ERROR_HTTP;
-	case ExceptionType::MISSING_EXTENSION:
-		return DUCKDB_ERROR_MISSING_EXTENSION;
-	case ExceptionType::AUTOLOAD:
-		return DUCKDB_ERROR_AUTOLOAD;
-	case ExceptionType::SEQUENCE:
-		return DUCKDB_ERROR_SEQUENCE;
-	case ExceptionType::INVALID_CONFIGURATION:
-		return DUCKDB_INVALID_CONFIGURATION;
-	}
-	return DUCKDB_ERROR_INVALID;
-}
-
-} // namespace duckdb
-
-static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
-	if (column.deprecated_data) {
-		if (column.deprecated_type == DUCKDB_TYPE_VARCHAR) {
-			// varchar, delete individual strings
-			auto data = reinterpret_cast<char **>(column.deprecated_data);
-			for (idx_t i = 0; i < count; i++) {
-				if (data[i]) {
-					duckdb_free(data[i]);
-				}
-			}
-		} else if (column.deprecated_type == DUCKDB_TYPE_BLOB) {
-			// blob, delete individual blobs
-			auto data = reinterpret_cast<duckdb_blob *>(column.deprecated_data);
-			for (idx_t i = 0; i < count; i++) {
-				if (data[i].data) {
-					duckdb_free((void *)data[i].data);
-				}
-			}
-		}
-		duckdb_free(column.deprecated_data);
-	}
-	if (column.deprecated_nullmask) {
-		duckdb_free(column.deprecated_nullmask);
-	}
-}
-
-void duckdb_destroy_result(duckdb_result *result) {
-	if (result->deprecated_columns) {
-		for (idx_t i = 0; i < result->deprecated_column_count; i++) {
-			DuckdbDestroyColumn(result->deprecated_columns[i], result->deprecated_row_count);
-		}
-		duckdb_free(result->deprecated_columns);
-	}
-	if (result->internal_data) {
-		auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
-		delete result_data;
-	}
-	memset(result, 0, sizeof(duckdb_result));
-}
-
-const char *duckdb_column_name(duckdb_result *result, idx_t col) {
-	if (!result || col >= duckdb_column_count(result)) {
-		return nullptr;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	return result_data.result->names[col].c_str();
-}
-
-duckdb_type duckdb_column_type(duckdb_result *result, idx_t col) {
-	if (!result || col >= duckdb_column_count(result)) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	return duckdb::ConvertCPPTypeToC(result_data.result->types[col]);
-}
-
-duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col) {
-	if (!result || col >= duckdb_column_count(result)) {
-		return nullptr;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(result_data.result->types[col]));
-}
-
-idx_t duckdb_column_count(duckdb_result *result) {
-	if (!result) {
-		return 0;
-	}
-	if (result->internal_data == NULL) {
-		return 0;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	return result_data.result->ColumnCount();
-}
-
-idx_t duckdb_row_count(duckdb_result *result) {
-	if (!result) {
-		return 0;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	if (result_data.result->type == duckdb::QueryResultType::STREAM_RESULT) {
-		// We can't know the row count beforehand
-		return 0;
-	}
-	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
-	return materialized.RowCount();
-}
-
-idx_t duckdb_rows_changed(duckdb_result *result) {
-	if (!result) {
-		return 0;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		// not a materialized result
-		return result->deprecated_rows_changed;
-	}
-	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
-	if (materialized.properties.return_type != duckdb::StatementReturnType::CHANGED_ROWS) {
-		// we can only use this function for CHANGED_ROWS result types
-		return 0;
-	}
-	if (materialized.RowCount() != 1 || materialized.ColumnCount() != 1) {
-		// CHANGED_ROWS should return exactly one row
-		return 0;
-	}
-	return materialized.GetValue(0, 0).GetValue<uint64_t>();
-}
-
-void *duckdb_column_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->deprecated_column_count) {
-		return nullptr;
-	}
-	if (!duckdb::DeprecatedMaterializeResult(result)) {
-		return nullptr;
-	}
-	return result->deprecated_columns[col].deprecated_data;
-}
-
-bool *duckdb_nullmask_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->deprecated_column_count) {
-		return nullptr;
-	}
-	if (!duckdb::DeprecatedMaterializeResult(result)) {
-		return nullptr;
-	}
-	return result->deprecated_columns[col].deprecated_nullmask;
-}
-
-const char *duckdb_result_error(duckdb_result *result) {
-	if (!result || !result->internal_data) {
-		return nullptr;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	return !result_data.result->HasError() ? nullptr : result_data.result->GetError().c_str();
-}
-
-duckdb_error_type duckdb_result_error_type(duckdb_result *result) {
-	if (!result || !result->internal_data) {
-		return DUCKDB_ERROR_INVALID;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
-	if (!result_data.result->HasError()) {
-		return DUCKDB_ERROR_INVALID;
-	}
-	return duckdb::CAPIErrorType(result_data.result->GetErrorType());
-}
-
-idx_t duckdb_result_chunk_count(duckdb_result result) {
-	if (!result.internal_data) {
-		return 0;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
-	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		return 0;
-	}
-	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
-		// Can't know beforehand how many chunks are returned.
-		return 0;
-	}
-	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
-	return materialized.Collection().ChunkCount();
-}
-
-duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx) {
-	if (!result.internal_data) {
-		return nullptr;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
-	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		return nullptr;
-	}
-	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
-		// This API is only supported for materialized query results
-		return nullptr;
-	}
-	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
-	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
-	auto &collection = materialized.Collection();
-	if (chunk_idx >= collection.ChunkCount()) {
-		return nullptr;
-	}
-	auto chunk = duckdb::make_uniq<duckdb::DataChunk>();
-	chunk->Initialize(duckdb::Allocator::DefaultAllocator(), collection.Types());
-	collection.FetchChunk(chunk_idx, *chunk);
-	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
-}
-
-bool duckdb_result_is_streaming(duckdb_result result) {
-	if (!result.internal_data) {
-		return false;
-	}
-	if (duckdb_result_error(&result) != nullptr) {
-		return false;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
-	return result_data.result->type == duckdb::QueryResultType::STREAM_RESULT;
-}
-
-duckdb_result_type duckdb_result_return_type(duckdb_result result) {
-	if (!result.internal_data || duckdb_result_error(&result) != nullptr) {
-		return DUCKDB_RESULT_TYPE_INVALID;
-	}
-	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
-	switch (result_data.result->properties.return_type) {
-	case duckdb::StatementReturnType::CHANGED_ROWS:
-		return DUCKDB_RESULT_TYPE_CHANGED_ROWS;
-	case duckdb::StatementReturnType::NOTHING:
-		return DUCKDB_RESULT_TYPE_NOTHING;
-	case duckdb::StatementReturnType::QUERY_RESULT:
-		return DUCKDB_RESULT_TYPE_QUERY_RESULT;
-	default:
-		return DUCKDB_RESULT_TYPE_INVALID;
-	}
-}
-
-duckdb_statement_type duckdb_result_statement_type(duckdb_result result) {
-	if (!result.internal_data || duckdb_result_error(&result) != nullptr) {
-		return DUCKDB_STATEMENT_TYPE_INVALID;
-	}
-	auto &pres = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
-
-	return StatementTypeToC(pres.result->statement_type);
-}
diff --git a/src/duckdb/src/main/capi/scalar_function-c.cpp b/src/duckdb/src/main/capi/scalar_function-c.cpp
deleted file mode 100644
index 3060ab839..000000000
--- a/src/duckdb/src/main/capi/scalar_function-c.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-struct CScalarFunctionInfo : public ScalarFunctionInfo {
-	~CScalarFunctionInfo() override {
-		if (extra_info && delete_callback) {
-			delete_callback(extra_info);
-		}
-		extra_info = nullptr;
-		delete_callback = nullptr;
-	}
-
-	duckdb_scalar_function_t function = nullptr;
-	duckdb_function_info extra_info = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-};
-
-struct CScalarExecuteInfo {
-	explicit CScalarExecuteInfo(CScalarFunctionInfo &info) : info(info) {
-	}
-
-	CScalarFunctionInfo &info;
-	bool success = true;
-	string error;
-};
-
-struct CScalarFunctionBindData : public FunctionData {
-	explicit CScalarFunctionBindData(CScalarFunctionInfo &info) : info(info) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<CScalarFunctionBindData>(info);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<CScalarFunctionBindData>();
-		return info.extra_info == other.info.extra_info && info.function == other.info.function;
-	}
-
-	CScalarFunctionInfo &info;
-};
-
-duckdb::ScalarFunction &GetCScalarFunction(duckdb_scalar_function function) {
-	return *reinterpret_cast<duckdb::ScalarFunction *>(function);
-}
-
-duckdb::ScalarFunctionSet &GetCScalarFunctionSet(duckdb_scalar_function_set set) {
-	return *reinterpret_cast<duckdb::ScalarFunctionSet *>(set);
-}
-
-unique_ptr<FunctionData> BindCAPIScalarFunction(ClientContext &, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	auto &info = bound_function.function_info->Cast<CScalarFunctionInfo>();
-	return make_uniq<CScalarFunctionBindData>(info);
-}
-
-void CAPIScalarFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &function = state.expr.Cast<BoundFunctionExpression>();
-	auto &bind_info = function.bind_info;
-	auto &c_bind_info = bind_info->Cast<CScalarFunctionBindData>();
-
-	auto all_const = input.AllConstant();
-	input.Flatten();
-	auto c_input = reinterpret_cast<duckdb_data_chunk>(&input);
-	auto c_result = reinterpret_cast<duckdb_vector>(&result);
-
-	CScalarExecuteInfo exec_info(c_bind_info.info);
-	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
-	c_bind_info.info.function(c_function_info, c_input, c_result);
-	if (!exec_info.success) {
-		throw InvalidInputException(exec_info.error);
-	}
-	if (all_const && (input.size() == 1 || function.function.stability != FunctionStability::VOLATILE)) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-} // namespace duckdb
-
-using duckdb::GetCScalarFunction;
-using duckdb::GetCScalarFunctionSet;
-
-duckdb_scalar_function duckdb_create_scalar_function() {
-	auto function = new duckdb::ScalarFunction("", {}, duckdb::LogicalType::INVALID, duckdb::CAPIScalarFunction,
-	                                           duckdb::BindCAPIScalarFunction);
-	function->function_info = duckdb::make_shared_ptr<duckdb::CScalarFunctionInfo>();
-	return reinterpret_cast<duckdb_scalar_function>(function);
-}
-
-void duckdb_destroy_scalar_function(duckdb_scalar_function *function) {
-	if (function && *function) {
-		auto scalar_function = reinterpret_cast<duckdb::ScalarFunction *>(*function);
-		delete scalar_function;
-		*function = nullptr;
-	}
-}
-
-void duckdb_scalar_function_set_name(duckdb_scalar_function function, const char *name) {
-	if (!function || !name) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	scalar_function.name = name;
-}
-
-void duckdb_scalar_function_set_varargs(duckdb_scalar_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	scalar_function.varargs = *logical_type;
-}
-
-void duckdb_scalar_function_set_special_handling(duckdb_scalar_function function) {
-	if (!function) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	scalar_function.null_handling = duckdb::FunctionNullHandling::SPECIAL_HANDLING;
-}
-
-void duckdb_scalar_function_set_volatile(duckdb_scalar_function function) {
-	if (!function) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	scalar_function.stability = duckdb::FunctionStability::VOLATILE;
-}
-
-void duckdb_scalar_function_add_parameter(duckdb_scalar_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	scalar_function.arguments.push_back(*logical_type);
-}
-
-void duckdb_scalar_function_set_return_type(duckdb_scalar_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	scalar_function.return_type = *logical_type;
-}
-
-duckdb::CScalarExecuteInfo &GetCScalarExecInfo(duckdb_function_info info) {
-	D_ASSERT(info);
-	return *reinterpret_cast<duckdb::CScalarExecuteInfo *>(info);
-}
-
-void *duckdb_scalar_function_get_extra_info(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &scalar_function = GetCScalarExecInfo(info);
-	return scalar_function.info.extra_info;
-}
-
-void duckdb_scalar_function_set_error(duckdb_function_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto &scalar_function = GetCScalarExecInfo(info);
-	scalar_function.error = error;
-	scalar_function.success = false;
-}
-
-void duckdb_scalar_function_set_extra_info(duckdb_scalar_function function, void *extra_info,
-                                           duckdb_delete_callback_t destroy) {
-	if (!function || !extra_info) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	auto &info = scalar_function.function_info->Cast<duckdb::CScalarFunctionInfo>();
-	info.extra_info = reinterpret_cast<duckdb_function_info>(extra_info);
-	info.delete_callback = destroy;
-}
-
-void duckdb_scalar_function_set_function(duckdb_scalar_function function, duckdb_scalar_function_t execute_func) {
-	if (!function || !execute_func) {
-		return;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	auto &info = scalar_function.function_info->Cast<duckdb::CScalarFunctionInfo>();
-	info.function = execute_func;
-}
-
-duckdb_state duckdb_register_scalar_function(duckdb_connection connection, duckdb_scalar_function function) {
-	if (!connection || !function) {
-		return DuckDBError;
-	}
-	auto &scalar_function = GetCScalarFunction(function);
-	duckdb::ScalarFunctionSet set(scalar_function.name);
-	set.AddFunction(scalar_function);
-	return duckdb_register_scalar_function_set(connection, reinterpret_cast<duckdb_scalar_function_set>(&set));
-}
-
-duckdb_scalar_function_set duckdb_create_scalar_function_set(const char *name) {
-	if (!name || !*name) {
-		return nullptr;
-	}
-	auto function = new duckdb::ScalarFunctionSet(name);
-	return reinterpret_cast<duckdb_scalar_function_set>(function);
-}
-
-void duckdb_destroy_scalar_function_set(duckdb_scalar_function_set *set) {
-	if (set && *set) {
-		auto scalar_function_set = reinterpret_cast<duckdb::ScalarFunctionSet *>(*set);
-		delete scalar_function_set;
-		*set = nullptr;
-	}
-}
-
-duckdb_state duckdb_add_scalar_function_to_set(duckdb_scalar_function_set set, duckdb_scalar_function function) {
-	if (!set || !function) {
-		return DuckDBError;
-	}
-	auto &scalar_function_set = GetCScalarFunctionSet(set);
-	auto &scalar_function = GetCScalarFunction(function);
-	scalar_function_set.AddFunction(scalar_function);
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_register_scalar_function_set(duckdb_connection connection, duckdb_scalar_function_set set) {
-	if (!connection || !set) {
-		return DuckDBError;
-	}
-	auto &scalar_function_set = GetCScalarFunctionSet(set);
-	for (idx_t idx = 0; idx < scalar_function_set.Size(); idx++) {
-		auto &scalar_function = scalar_function_set.GetFunctionReferenceByOffset(idx);
-		auto &info = scalar_function.function_info->Cast<duckdb::CScalarFunctionInfo>();
-
-		if (scalar_function.name.empty() || !info.function) {
-			return DuckDBError;
-		}
-		if (duckdb::TypeVisitor::Contains(scalar_function.return_type, duckdb::LogicalTypeId::INVALID) ||
-		    duckdb::TypeVisitor::Contains(scalar_function.return_type, duckdb::LogicalTypeId::ANY)) {
-			return DuckDBError;
-		}
-		for (const auto &argument : scalar_function.arguments) {
-			if (duckdb::TypeVisitor::Contains(argument, duckdb::LogicalTypeId::INVALID)) {
-				return DuckDBError;
-			}
-		}
-	}
-
-	try {
-		auto con = reinterpret_cast<duckdb::Connection *>(connection);
-		con->context->RunFunctionInTransaction([&]() {
-			auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
-			duckdb::CreateScalarFunctionInfo sf_info(scalar_function_set);
-			catalog.CreateFunction(*con->context, sf_info);
-		});
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
diff --git a/src/duckdb/src/main/capi/stream-c.cpp b/src/duckdb/src/main/capi/stream-c.cpp
deleted file mode 100644
index 5b950599f..000000000
--- a/src/duckdb/src/main/capi/stream-c.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/allocator.hpp"
-
-duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result) {
-	if (!result.internal_data) {
-		return nullptr;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
-	if (result_data.result->type != duckdb::QueryResultType::STREAM_RESULT) {
-		// We can only fetch from a StreamQueryResult
-		return nullptr;
-	}
-	return duckdb_fetch_chunk(result);
-}
-
-duckdb_data_chunk duckdb_fetch_chunk(duckdb_result result) {
-	if (!result.internal_data) {
-		return nullptr;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
-	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		return nullptr;
-	}
-	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING;
-	auto &result_instance = (duckdb::QueryResult &)*result_data.result;
-	// FetchRaw ? Do we care about flattening them?
-	try {
-		auto chunk = result_instance.Fetch();
-		return reinterpret_cast<duckdb_data_chunk>(chunk.release());
-	} catch (std::exception &e) {
-		return nullptr;
-	}
-}
diff --git a/src/duckdb/src/main/capi/table_description-c.cpp b/src/duckdb/src/main/capi/table_description-c.cpp
deleted file mode 100644
index 26624bbfc..000000000
--- a/src/duckdb/src/main/capi/table_description-c.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/string_util.hpp"
-
-using duckdb::Connection;
-using duckdb::ErrorData;
-using duckdb::TableDescription;
-using duckdb::TableDescriptionWrapper;
-
-duckdb_state duckdb_table_description_create(duckdb_connection connection, const char *schema, const char *table,
-                                             duckdb_table_description *out) {
-	return duckdb_table_description_create_ext(connection, INVALID_CATALOG, schema, table, out);
-}
-
-duckdb_state duckdb_table_description_create_ext(duckdb_connection connection, const char *catalog, const char *schema,
-                                                 const char *table, duckdb_table_description *out) {
-	Connection *conn = reinterpret_cast<Connection *>(connection);
-
-	if (!out) {
-		return DuckDBError;
-	}
-	auto wrapper = new TableDescriptionWrapper();
-	*out = reinterpret_cast<duckdb_table_description>(wrapper);
-
-	if (!connection || !table) {
-		return DuckDBError;
-	}
-	if (catalog == nullptr) {
-		catalog = INVALID_CATALOG;
-	}
-	if (schema == nullptr) {
-		schema = DEFAULT_SCHEMA;
-	}
-
-	try {
-		wrapper->description = conn->TableInfo(catalog, schema, table);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		wrapper->error = error.RawMessage();
-		return DuckDBError;
-	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown Connection::TableInfo error";
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	if (!wrapper->description) {
-		wrapper->error = "No table with that schema+name could be located";
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-void duckdb_table_description_destroy(duckdb_table_description *table) {
-	if (!table || !*table) {
-		return;
-	}
-	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(*table);
-	delete wrapper;
-	*table = nullptr;
-}
-
-const char *duckdb_table_description_error(duckdb_table_description table) {
-	if (!table) {
-		return nullptr;
-	}
-	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(table);
-	if (wrapper->error.empty()) {
-		return nullptr;
-	}
-	return wrapper->error.c_str();
-}
-
-duckdb_state GetTableDescription(TableDescriptionWrapper *wrapper, idx_t index) {
-	if (!wrapper) {
-		return DuckDBError;
-	}
-	auto &table = wrapper->description;
-	if (index >= table->columns.size()) {
-		wrapper->error = duckdb::StringUtil::Format("Column index %d is out of range, table only has %d columns", index,
-		                                            table->columns.size());
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_column_has_default(duckdb_table_description table_description, idx_t index, bool *out) {
-	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(table_description);
-	if (GetTableDescription(wrapper, index) == DuckDBError) {
-		return DuckDBError;
-	}
-	if (!out) {
-		wrapper->error = "Please provide a valid (non-null) 'out' variable";
-		return DuckDBError;
-	}
-
-	auto &table = wrapper->description;
-	auto &column = table->columns[index];
-	*out = column.HasDefaultValue();
-	return DuckDBSuccess;
-}
-
-char *duckdb_table_description_get_column_name(duckdb_table_description table_description, idx_t index) {
-	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(table_description);
-	if (GetTableDescription(wrapper, index) == DuckDBError) {
-		return nullptr;
-	}
-
-	auto &table = wrapper->description;
-	auto &column = table->columns[index];
-
-	auto name = column.GetName();
-	auto result = reinterpret_cast<char *>(malloc(sizeof(char) * (name.size() + 1)));
-	memcpy(result, name.c_str(), name.size());
-	result[name.size()] = '\0';
-
-	return result;
-}
diff --git a/src/duckdb/src/main/capi/table_function-c.cpp b/src/duckdb/src/main/capi/table_function-c.cpp
deleted file mode 100644
index 078ae7c25..000000000
--- a/src/duckdb/src/main/capi/table_function-c.cpp
+++ /dev/null
@@ -1,552 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/storage/statistics/node_statistics.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Structures
-//===--------------------------------------------------------------------===//
-struct CTableFunctionInfo : public TableFunctionInfo {
-	~CTableFunctionInfo() override {
-		if (extra_info && delete_callback) {
-			delete_callback(extra_info);
-		}
-		extra_info = nullptr;
-		delete_callback = nullptr;
-	}
-
-	duckdb_table_function_bind_t bind = nullptr;
-	duckdb_table_function_init_t init = nullptr;
-	duckdb_table_function_init_t local_init = nullptr;
-	duckdb_table_function_t function = nullptr;
-	void *extra_info = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-};
-
-struct CTableBindData : public TableFunctionData {
-	explicit CTableBindData(CTableFunctionInfo &info) : info(info) {
-	}
-	~CTableBindData() override {
-		if (bind_data && delete_callback) {
-			delete_callback(bind_data);
-		}
-		bind_data = nullptr;
-		delete_callback = nullptr;
-	}
-
-	CTableFunctionInfo &info;
-	void *bind_data = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-	unique_ptr<NodeStatistics> stats;
-};
-
-struct CTableInternalBindInfo {
-	CTableInternalBindInfo(ClientContext &context, TableFunctionBindInput &input, vector<LogicalType> &return_types,
-	                       vector<string> &names, CTableBindData &bind_data, CTableFunctionInfo &function_info)
-	    : context(context), input(input), return_types(return_types), names(names), bind_data(bind_data),
-	      function_info(function_info), success(true) {
-	}
-
-	ClientContext &context;
-	TableFunctionBindInput &input;
-	vector<LogicalType> &return_types;
-	vector<string> &names;
-	CTableBindData &bind_data;
-	CTableFunctionInfo &function_info;
-	bool success;
-	string error;
-};
-
-struct CTableInitData {
-	~CTableInitData() {
-		if (init_data && delete_callback) {
-			delete_callback(init_data);
-		}
-		init_data = nullptr;
-		delete_callback = nullptr;
-	}
-
-	void *init_data = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-	idx_t max_threads = 1;
-};
-
-struct CTableGlobalInitData : public GlobalTableFunctionState {
-	CTableInitData init_data;
-
-	idx_t MaxThreads() const override {
-		return init_data.max_threads;
-	}
-};
-
-struct CTableLocalInitData : public LocalTableFunctionState {
-	CTableInitData init_data;
-};
-
-struct CTableInternalInitInfo {
-	CTableInternalInitInfo(const CTableBindData &bind_data, CTableInitData &init_data,
-	                       const vector<column_t> &column_ids, optional_ptr<TableFilterSet> filters)
-	    : bind_data(bind_data), init_data(init_data), column_ids(column_ids), filters(filters), success(true) {
-	}
-
-	const CTableBindData &bind_data;
-	CTableInitData &init_data;
-	const vector<column_t> &column_ids;
-	optional_ptr<TableFilterSet> filters;
-	bool success;
-	string error;
-};
-
-struct CTableInternalFunctionInfo {
-	CTableInternalFunctionInfo(const CTableBindData &bind_data, CTableInitData &init_data, CTableInitData &local_data)
-	    : bind_data(bind_data), init_data(init_data), local_data(local_data), success(true) {
-	}
-
-	const CTableBindData &bind_data;
-	CTableInitData &init_data;
-	CTableInitData &local_data;
-	bool success;
-	string error;
-};
-
-//===--------------------------------------------------------------------===//
-// Helper Functions
-//===--------------------------------------------------------------------===//
-duckdb::TableFunction &GetCTableFunction(duckdb_table_function function) {
-	return *reinterpret_cast<duckdb::TableFunction *>(function);
-}
-
-duckdb::CTableInternalBindInfo &GetCBindInfo(duckdb_bind_info info) {
-	D_ASSERT(info);
-	return *reinterpret_cast<duckdb::CTableInternalBindInfo *>(info);
-}
-
-duckdb_bind_info ToCBindInfo(duckdb::CTableInternalBindInfo &info) {
-	return reinterpret_cast<duckdb_bind_info>(&info);
-}
-
-duckdb::CTableInternalInitInfo &GetCInitInfo(duckdb_init_info info) {
-	D_ASSERT(info);
-	return *reinterpret_cast<duckdb::CTableInternalInitInfo *>(info);
-}
-
-duckdb_init_info ToCInitInfo(duckdb::CTableInternalInitInfo &info) {
-	return reinterpret_cast<duckdb_init_info>(&info);
-}
-
-duckdb::CTableInternalFunctionInfo &GetCFunctionInfo(duckdb_function_info info) {
-	D_ASSERT(info);
-	return *reinterpret_cast<duckdb::CTableInternalFunctionInfo *>(info);
-}
-
-duckdb_function_info ToCFunctionInfo(duckdb::CTableInternalFunctionInfo &info) {
-	return reinterpret_cast<duckdb_function_info>(&info);
-}
-
-//===--------------------------------------------------------------------===//
-// Table Callbacks
-//===--------------------------------------------------------------------===//
-unique_ptr<FunctionData> CTableFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                            vector<LogicalType> &return_types, vector<string> &names) {
-	auto &info = input.info->Cast<CTableFunctionInfo>();
-	D_ASSERT(info.bind && info.function && info.init);
-	auto result = make_uniq<CTableBindData>(info);
-	CTableInternalBindInfo bind_info(context, input, return_types, names, *result, info);
-	info.bind(ToCBindInfo(bind_info));
-	if (!bind_info.success) {
-		throw BinderException(bind_info.error);
-	}
-
-	return std::move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context, TableFunctionInitInput &data_p) {
-	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
-	auto result = make_uniq<CTableGlobalInitData>();
-
-	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info.init(ToCInitInfo(init_info));
-	if (!init_info.success) {
-		throw InvalidInputException(init_info.error);
-	}
-	return std::move(result);
-}
-
-unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &context, TableFunctionInitInput &data_p,
-                                                            GlobalTableFunctionState *gstate) {
-	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
-	auto result = make_uniq<CTableLocalInitData>();
-	if (!bind_data.info.local_init) {
-		return std::move(result);
-	}
-
-	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info.local_init(ToCInitInfo(init_info));
-	if (!init_info.success) {
-		throw InvalidInputException(init_info.error);
-	}
-	return std::move(result);
-}
-
-unique_ptr<NodeStatistics> CTableFunctionCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = bind_data_p->Cast<CTableBindData>();
-	if (!bind_data.stats) {
-		return nullptr;
-	}
-	return make_uniq<NodeStatistics>(*bind_data.stats);
-}
-
-void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
-	auto &global_data = data_p.global_state->Cast<CTableGlobalInitData>();
-	auto &local_data = data_p.local_state->Cast<CTableLocalInitData>();
-	CTableInternalFunctionInfo function_info(bind_data, global_data.init_data, local_data.init_data);
-	bind_data.info.function(ToCFunctionInfo(function_info), reinterpret_cast<duckdb_data_chunk>(&output));
-	if (!function_info.success) {
-		throw InvalidInputException(function_info.error);
-	}
-}
-
-} // namespace duckdb
-
-//===--------------------------------------------------------------------===//
-// Table Function
-//===--------------------------------------------------------------------===//
-using duckdb::GetCTableFunction;
-
-duckdb_table_function duckdb_create_table_function() {
-	auto function = new duckdb::TableFunction("", {}, duckdb::CTableFunction, duckdb::CTableFunctionBind,
-	                                          duckdb::CTableFunctionInit, duckdb::CTableFunctionLocalInit);
-	function->function_info = duckdb::make_shared_ptr<duckdb::CTableFunctionInfo>();
-	function->cardinality = duckdb::CTableFunctionCardinality;
-	return reinterpret_cast<duckdb_table_function>(function);
-}
-
-void duckdb_destroy_table_function(duckdb_table_function *function) {
-	if (function && *function) {
-		auto tf = reinterpret_cast<duckdb::TableFunction *>(*function);
-		delete tf;
-		*function = nullptr;
-	}
-}
-
-void duckdb_table_function_set_name(duckdb_table_function function, const char *name) {
-	if (!function || !name) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	tf.name = name;
-}
-
-void duckdb_table_function_add_parameter(duckdb_table_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	tf.arguments.push_back(*logical_type);
-}
-
-void duckdb_table_function_add_named_parameter(duckdb_table_function function, const char *name,
-                                               duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	tf.named_parameters.insert({name, *logical_type});
-}
-
-void duckdb_table_function_set_extra_info(duckdb_table_function function, void *extra_info,
-                                          duckdb_delete_callback_t destroy) {
-	if (!function) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
-	info.extra_info = extra_info;
-	info.delete_callback = destroy;
-}
-
-void duckdb_table_function_set_bind(duckdb_table_function function, duckdb_table_function_bind_t bind) {
-	if (!function || !bind) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
-	info.bind = bind;
-}
-
-void duckdb_table_function_set_init(duckdb_table_function function, duckdb_table_function_init_t init) {
-	if (!function || !init) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
-	info.init = init;
-}
-
-void duckdb_table_function_set_local_init(duckdb_table_function function, duckdb_table_function_init_t init) {
-	if (!function || !init) {
-		return;
-	}
-	auto &tf = GetCTableFunction(function);
-	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
-	info.local_init = init;
-}
-
-void duckdb_table_function_set_function(duckdb_table_function table_function, duckdb_table_function_t function) {
-	if (!table_function || !function) {
-		return;
-	}
-	auto &tf = GetCTableFunction(table_function);
-	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
-	info.function = function;
-}
-
-void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown) {
-	if (!table_function) {
-		return;
-	}
-	auto &tf = GetCTableFunction(table_function);
-	tf.projection_pushdown = pushdown;
-}
-
-duckdb_state duckdb_register_table_function(duckdb_connection connection, duckdb_table_function function) {
-	if (!connection || !function) {
-		return DuckDBError;
-	}
-	auto con = reinterpret_cast<duckdb::Connection *>(connection);
-	auto &tf = GetCTableFunction(function);
-	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
-
-	if (tf.name.empty() || !info.bind || !info.init || !info.function) {
-		return DuckDBError;
-	}
-	for (auto it = tf.named_parameters.begin(); it != tf.named_parameters.end(); it++) {
-		if (duckdb::TypeVisitor::Contains(it->second, duckdb::LogicalTypeId::INVALID)) {
-			return DuckDBError;
-		}
-	}
-	for (const auto &argument : tf.arguments) {
-		if (duckdb::TypeVisitor::Contains(argument, duckdb::LogicalTypeId::INVALID)) {
-			return DuckDBError;
-		}
-	}
-
-	try {
-		con->context->RunFunctionInTransaction([&]() {
-			auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
-			duckdb::CreateTableFunctionInfo tf_info(tf);
-			catalog.CreateTableFunction(*con->context, tf_info);
-		});
-	} catch (...) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-//===--------------------------------------------------------------------===//
-// Bind Interface
-//===--------------------------------------------------------------------===//
-using duckdb::GetCBindInfo;
-
-void *duckdb_bind_get_extra_info(duckdb_bind_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	return bind_info.function_info.extra_info;
-}
-
-void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type) {
-	if (!info || !name || !type) {
-		return;
-	}
-	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	if (duckdb::TypeVisitor::Contains(*logical_type, duckdb::LogicalTypeId::INVALID) ||
-	    duckdb::TypeVisitor::Contains(*logical_type, duckdb::LogicalTypeId::ANY)) {
-		return;
-	}
-
-	auto &bind_info = GetCBindInfo(info);
-	bind_info.names.push_back(name);
-	bind_info.return_types.push_back(*logical_type);
-}
-
-idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info) {
-	if (!info) {
-		return 0;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	return bind_info.input.inputs.size();
-}
-
-duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index) {
-	if (!info || index >= duckdb_bind_get_parameter_count(info)) {
-		return nullptr;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	return reinterpret_cast<duckdb_value>(new duckdb::Value(bind_info.input.inputs[index]));
-}
-
-duckdb_value duckdb_bind_get_named_parameter(duckdb_bind_info info, const char *name) {
-	if (!info || !name) {
-		return nullptr;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	auto t = bind_info.input.named_parameters.find(name);
-	if (t == bind_info.input.named_parameters.end()) {
-		return nullptr;
-	} else {
-		return reinterpret_cast<duckdb_value>(new duckdb::Value(t->second));
-	}
-}
-
-void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy) {
-	if (!info) {
-		return;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	bind_info.bind_data.bind_data = bind_data;
-	bind_info.bind_data.delete_callback = destroy;
-}
-
-void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact) {
-	if (!info) {
-		return;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	if (is_exact) {
-		bind_info.bind_data.stats = duckdb::make_uniq<duckdb::NodeStatistics>(cardinality);
-	} else {
-		bind_info.bind_data.stats = duckdb::make_uniq<duckdb::NodeStatistics>(cardinality, cardinality);
-	}
-}
-
-void duckdb_bind_set_error(duckdb_bind_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto &bind_info = GetCBindInfo(info);
-	bind_info.error = error;
-	bind_info.success = false;
-}
-
-//===--------------------------------------------------------------------===//
-// Init Interface
-//===--------------------------------------------------------------------===//
-using duckdb::GetCInitInfo;
-
-void *duckdb_init_get_extra_info(duckdb_init_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto init_info = reinterpret_cast<duckdb::CTableInternalInitInfo *>(info);
-	return init_info->bind_data.info.extra_info;
-}
-
-void *duckdb_init_get_bind_data(duckdb_init_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &init_info = GetCInitInfo(info);
-	return init_info.bind_data.bind_data;
-}
-
-void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy) {
-	if (!info) {
-		return;
-	}
-	auto &init_info = GetCInitInfo(info);
-	init_info.init_data.init_data = init_data;
-	init_info.init_data.delete_callback = destroy;
-}
-
-void duckdb_init_set_error(duckdb_init_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto &init_info = GetCInitInfo(info);
-	init_info.error = error;
-	init_info.success = false;
-}
-
-idx_t duckdb_init_get_column_count(duckdb_init_info info) {
-	if (!info) {
-		return 0;
-	}
-	auto &init_info = GetCInitInfo(info);
-	return init_info.column_ids.size();
-}
-
-idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index) {
-	if (!info) {
-		return 0;
-	}
-	auto &init_info = GetCInitInfo(info);
-	if (column_index >= init_info.column_ids.size()) {
-		return 0;
-	}
-	return init_info.column_ids[column_index];
-}
-
-void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads) {
-	if (!info) {
-		return;
-	}
-	auto &init_info = GetCInitInfo(info);
-	init_info.init_data.max_threads = max_threads;
-}
-
-//===--------------------------------------------------------------------===//
-// Function Interface
-//===--------------------------------------------------------------------===//
-using duckdb::GetCFunctionInfo;
-
-void *duckdb_function_get_extra_info(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &function_info = GetCFunctionInfo(info);
-	return function_info.bind_data.info.extra_info;
-}
-
-void *duckdb_function_get_bind_data(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &function_info = GetCFunctionInfo(info);
-	return function_info.bind_data.bind_data;
-}
-
-void *duckdb_function_get_init_data(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &function_info = GetCFunctionInfo(info);
-	return function_info.init_data.init_data;
-}
-
-void *duckdb_function_get_local_init_data(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto &function_info = GetCFunctionInfo(info);
-	return function_info.local_data.init_data;
-}
-
-void duckdb_function_set_error(duckdb_function_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto &function_info = GetCFunctionInfo(info);
-	function_info.error = error;
-	function_info.success = false;
-}
diff --git a/src/duckdb/src/main/capi/threading-c.cpp b/src/duckdb/src/main/capi/threading-c.cpp
deleted file mode 100644
index 575f22c3c..000000000
--- a/src/duckdb/src/main/capi/threading-c.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-
-using duckdb::DatabaseWrapper;
-
-struct CAPITaskState {
-	explicit CAPITaskState(duckdb::DatabaseInstance &db)
-	    : db(db), marker(duckdb::make_uniq<duckdb::atomic<bool>>(true)), execute_count(0) {
-	}
-
-	duckdb::DatabaseInstance &db;
-	duckdb::unique_ptr<duckdb::atomic<bool>> marker;
-	duckdb::atomic<idx_t> execute_count;
-};
-
-void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks) {
-	if (!database) {
-		return;
-	}
-	auto wrapper = reinterpret_cast<DatabaseWrapper *>(database);
-	auto &scheduler = duckdb::TaskScheduler::GetScheduler(*wrapper->database->instance);
-	scheduler.ExecuteTasks(max_tasks);
-}
-
-duckdb_task_state duckdb_create_task_state(duckdb_database database) {
-	if (!database) {
-		return nullptr;
-	}
-	auto wrapper = reinterpret_cast<DatabaseWrapper *>(database);
-	auto state = new CAPITaskState(*wrapper->database->instance);
-	return state;
-}
-
-void duckdb_execute_tasks_state(duckdb_task_state state_p) {
-	if (!state_p) {
-		return;
-	}
-	auto state = (CAPITaskState *)state_p;
-	auto &scheduler = duckdb::TaskScheduler::GetScheduler(state->db);
-	state->execute_count++;
-	scheduler.ExecuteForever(state->marker.get());
-}
-
-idx_t duckdb_execute_n_tasks_state(duckdb_task_state state_p, idx_t max_tasks) {
-	if (!state_p) {
-		return 0;
-	}
-	auto state = (CAPITaskState *)state_p;
-	auto &scheduler = duckdb::TaskScheduler::GetScheduler(state->db);
-	return scheduler.ExecuteTasks(state->marker.get(), max_tasks);
-}
-
-void duckdb_finish_execution(duckdb_task_state state_p) {
-	if (!state_p) {
-		return;
-	}
-	auto state = (CAPITaskState *)state_p;
-	*state->marker = false;
-	if (state->execute_count > 0) {
-		// signal to the threads to wake up
-		auto &scheduler = duckdb::TaskScheduler::GetScheduler(state->db);
-		scheduler.Signal(state->execute_count);
-	}
-}
-
-bool duckdb_task_state_is_finished(duckdb_task_state state_p) {
-	if (!state_p) {
-		return false;
-	}
-	auto state = (CAPITaskState *)state_p;
-	return !(*state->marker);
-}
-
-void duckdb_destroy_task_state(duckdb_task_state state_p) {
-	if (!state_p) {
-		return;
-	}
-	auto state = (CAPITaskState *)state_p;
-	delete state;
-}
-
-bool duckdb_execution_is_finished(duckdb_connection con) {
-	if (!con) {
-		return false;
-	}
-	duckdb::Connection *conn = (duckdb::Connection *)con;
-	return conn->context->ExecutionIsFinished();
-}
diff --git a/src/duckdb/src/main/capi/value-c.cpp b/src/duckdb/src/main/capi/value-c.cpp
deleted file mode 100644
index c5cb16f55..000000000
--- a/src/duckdb/src/main/capi/value-c.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/uhugeint.hpp"
-
-#include "duckdb/main/capi/cast/generic.hpp"
-
-#include <cstring>
-
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::FetchDefaultValue;
-using duckdb::GetInternalCValue;
-using duckdb::hugeint_t;
-using duckdb::interval_t;
-using duckdb::StringCast;
-using duckdb::timestamp_t;
-using duckdb::ToCStringCastWrapper;
-using duckdb::uhugeint_t;
-using duckdb::UnsafeFetch;
-
-bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<bool>(result, col, row);
-}
-
-int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int8_t>(result, col, row);
-}
-
-int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int16_t>(result, col, row);
-}
-
-int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int32_t>(result, col, row);
-}
-
-int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int64_t>(result, col, row);
-}
-
-static bool ResultIsDecimal(duckdb_result *result, idx_t col) {
-	if (!result) {
-		return false;
-	}
-	if (!result->internal_data) {
-		return false;
-	}
-	auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
-	auto &query_result = result_data->result;
-	auto &source_type = query_result->types[col];
-	return source_type.id() == duckdb::LogicalTypeId::DECIMAL;
-}
-
-duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanFetchValue(result, col, row) || !ResultIsDecimal(result, col)) {
-		return FetchDefaultValue::Operation<duckdb_decimal>();
-	}
-
-	return GetInternalCValue<duckdb_decimal>(result, col, row);
-}
-
-duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_hugeint result_value;
-	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
-	result_value.lower = internal_value.lower;
-	result_value.upper = internal_value.upper;
-	return result_value;
-}
-
-duckdb_uhugeint duckdb_value_uhugeint(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_uhugeint result_value;
-	auto internal_value = GetInternalCValue<uhugeint_t>(result, col, row);
-	result_value.lower = internal_value.lower;
-	result_value.upper = internal_value.upper;
-	return result_value;
-}
-
-uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint8_t>(result, col, row);
-}
-
-uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint16_t>(result, col, row);
-}
-
-uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint32_t>(result, col, row);
-}
-
-uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint64_t>(result, col, row);
-}
-
-float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<float>(result, col, row);
-}
-
-double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<double>(result, col, row);
-}
-
-duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_date result_value;
-	result_value.days = GetInternalCValue<date_t>(result, col, row).days;
-	return result_value;
-}
-
-duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_time result_value;
-	result_value.micros = GetInternalCValue<dtime_t>(result, col, row).micros;
-	return result_value;
-}
-
-duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_timestamp result_value;
-	result_value.micros = GetInternalCValue<timestamp_t>(result, col, row).value;
-	return result_value;
-}
-
-duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_interval result_value;
-	auto ival = GetInternalCValue<interval_t>(result, col, row);
-	result_value.months = ival.months;
-	result_value.days = ival.days;
-	result_value.micros = ival.micros;
-	return result_value;
-}
-
-char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row) {
-	return duckdb_value_string(result, col, row).data;
-}
-
-duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<duckdb_string, ToCStringCastWrapper<StringCast>>(result, col, row);
-}
-
-char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row) {
-	return duckdb_value_string_internal(result, col, row).data;
-}
-
-duckdb_string duckdb_value_string_internal(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanFetchValue(result, col, row)) {
-		return FetchDefaultValue::Operation<duckdb_string>();
-	}
-	if (duckdb_column_type(result, col) != DUCKDB_TYPE_VARCHAR) {
-		return FetchDefaultValue::Operation<duckdb_string>();
-	}
-	// FIXME: this obviously does not work when there are null bytes in the string
-	// we need to remove the deprecated C result materialization to get that to work correctly
-	// since the deprecated C result materialization stores strings as null-terminated
-	duckdb_string res;
-	res.data = UnsafeFetch<char *>(result, col, row);
-	res.size = strlen(res.data);
-	return res;
-}
-
-duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
-	if (CanFetchValue(result, col, row) && result->deprecated_columns[col].deprecated_type == DUCKDB_TYPE_BLOB) {
-		auto internal_result = UnsafeFetch<duckdb_blob>(result, col, row);
-
-		duckdb_blob result_blob;
-		result_blob.data = malloc(internal_result.size);
-		result_blob.size = internal_result.size;
-		memcpy(result_blob.data, internal_result.data, internal_result.size);
-		return result_blob;
-	}
-	return FetchDefaultValue::Operation<duckdb_blob>();
-}
-
-bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanUseDeprecatedFetch(result, col, row)) {
-		return false;
-	}
-	return result->deprecated_columns[col].deprecated_nullmask[row];
-}
diff --git a/src/duckdb/src/main/chunk_scan_state.cpp b/src/duckdb/src/main/chunk_scan_state.cpp
deleted file mode 100644
index aab054c99..000000000
--- a/src/duckdb/src/main/chunk_scan_state.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/main/chunk_scan_state.hpp"
-
-namespace duckdb {
-
-ChunkScanState::ChunkScanState() {
-}
-
-ChunkScanState::~ChunkScanState() {
-}
-
-idx_t ChunkScanState::CurrentOffset() const {
-	return offset;
-}
-
-void ChunkScanState::IncreaseOffset(idx_t increment, bool unsafe) {
-	D_ASSERT(unsafe || increment <= RemainingInChunk());
-	offset += increment;
-}
-
-bool ChunkScanState::ChunkIsEmpty() const {
-	return !current_chunk || current_chunk->size() == 0;
-}
-
-bool ChunkScanState::Finished() const {
-	return finished;
-}
-
-bool ChunkScanState::ScanStarted() const {
-	return !ChunkIsEmpty();
-}
-
-DataChunk &ChunkScanState::CurrentChunk() {
-	// Scan must already be started
-	D_ASSERT(current_chunk);
-	return *current_chunk;
-}
-
-idx_t ChunkScanState::RemainingInChunk() const {
-	if (ChunkIsEmpty()) {
-		return 0;
-	}
-	D_ASSERT(current_chunk);
-	D_ASSERT(offset <= current_chunk->size());
-	return current_chunk->size() - offset;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/chunk_scan_state/batched_data_collection.cpp b/src/duckdb/src/main/chunk_scan_state/batched_data_collection.cpp
deleted file mode 100644
index 7d2bc36cf..000000000
--- a/src/duckdb/src/main/chunk_scan_state/batched_data_collection.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/main/chunk_scan_state/batched_data_collection.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-BatchCollectionChunkScanState::BatchCollectionChunkScanState(BatchedDataCollection &collection,
-                                                             BatchedChunkIteratorRange &range, ClientContext &context)
-    : ChunkScanState(), collection(collection) {
-	collection.InitializeScan(state, range);
-	current_chunk = make_uniq<DataChunk>();
-	auto &allocator = BufferManager::GetBufferManager(context).GetBufferAllocator();
-	current_chunk->Initialize(allocator, collection.Types());
-}
-
-BatchCollectionChunkScanState::~BatchCollectionChunkScanState() {
-}
-
-void BatchCollectionChunkScanState::InternalLoad(ErrorData &error) {
-	if (state.range.begin == state.range.end) {
-		// Signal empty chunk to break out of the loop
-		current_chunk->SetCardinality(0);
-		return;
-	}
-	offset = 0;
-	current_chunk->Reset();
-	collection.Scan(state, *current_chunk);
-	return;
-}
-
-bool BatchCollectionChunkScanState::HasError() const {
-	return false;
-}
-
-ErrorData &BatchCollectionChunkScanState::GetError() {
-	throw NotImplementedException("BatchDataCollections don't have an internal error object");
-}
-
-const vector<LogicalType> &BatchCollectionChunkScanState::Types() const {
-	return collection.Types();
-}
-
-const vector<string> &BatchCollectionChunkScanState::Names() const {
-	throw NotImplementedException("BatchDataCollections don't have names");
-}
-
-bool BatchCollectionChunkScanState::LoadNextChunk(ErrorData &error) {
-	if (finished) {
-		return false;
-	}
-	InternalLoad(error);
-	if (ChunkIsEmpty()) {
-		finished = true;
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/chunk_scan_state/query_result.cpp b/src/duckdb/src/main/chunk_scan_state/query_result.cpp
deleted file mode 100644
index 1c533f8c2..000000000
--- a/src/duckdb/src/main/chunk_scan_state/query_result.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/main/chunk_scan_state/query_result.hpp"
-
-namespace duckdb {
-
-QueryResultChunkScanState::QueryResultChunkScanState(QueryResult &result) : ChunkScanState(), result(result) {
-}
-
-QueryResultChunkScanState::~QueryResultChunkScanState() {
-}
-
-bool QueryResultChunkScanState::InternalLoad(ErrorData &error) {
-	D_ASSERT(!finished);
-	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = result.Cast<StreamQueryResult>();
-		if (!stream_result.IsOpen()) {
-			return true;
-		}
-	}
-	return result.TryFetch(current_chunk, error);
-}
-
-bool QueryResultChunkScanState::HasError() const {
-	return result.HasError();
-}
-
-ErrorData &QueryResultChunkScanState::GetError() {
-	D_ASSERT(result.HasError());
-	return result.GetErrorObject();
-}
-
-const vector<LogicalType> &QueryResultChunkScanState::Types() const {
-	return result.types;
-}
-
-const vector<string> &QueryResultChunkScanState::Names() const {
-	return result.names;
-}
-
-bool QueryResultChunkScanState::LoadNextChunk(ErrorData &error) {
-	if (finished) {
-		return !finished;
-	}
-	auto load_result = InternalLoad(error);
-	if (!load_result) {
-		finished = true;
-	}
-	offset = 0;
-	return !finished;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/client_config.cpp b/src/duckdb/src/main/client_config.cpp
deleted file mode 100644
index c3350a6be..000000000
--- a/src/duckdb/src/main/client_config.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/main/client_config.hpp"
-
-#include "duckdb/common/file_system.hpp"
-
-namespace duckdb {
-
-void ClientConfig::SetDefaultStreamingBufferSize() {
-	auto memory = FileSystem::GetAvailableMemory();
-	auto default_size = ClientConfig().streaming_buffer_size;
-	if (!memory.IsValid()) {
-		streaming_buffer_size = default_size;
-		return;
-	}
-	streaming_buffer_size = MinValue(memory.GetIndex(), default_size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/client_context.cpp b/src/duckdb/src/main/client_context.cpp
deleted file mode 100644
index 53234bdb9..000000000
--- a/src/duckdb/src/main/client_context.cpp
+++ /dev/null
@@ -1,1364 +0,0 @@
-#include "duckdb/main/client_context.hpp"
-
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/column_binding_resolver.hpp"
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/main/appender.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context_file_opener.hpp"
-#include "duckdb/main/client_context_state.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/main/query_result.hpp"
-#include "duckdb/main/relation.hpp"
-#include "duckdb/main/stream_query_result.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/parser/statement/execute_statement.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/parser/statement/prepare_statement.hpp"
-#include "duckdb/parser/statement/relation_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/planner/operator/logical_execute.hpp"
-#include "duckdb/planner/planner.hpp"
-#include "duckdb/planner/pragma_handler.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_context.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-
-namespace duckdb {
-
-struct ActiveQueryContext {
-public:
-	//! The query that is currently being executed
-	string query;
-	//! Prepared statement data
-	shared_ptr<PreparedStatementData> prepared;
-	//! The query executor
-	unique_ptr<Executor> executor;
-	//! The progress bar
-	unique_ptr<ProgressBar> progress_bar;
-
-public:
-	void SetOpenResult(BaseQueryResult &result) {
-		open_result = &result;
-	}
-	bool IsOpenResult(BaseQueryResult &result) {
-		return open_result == &result;
-	}
-	bool HasOpenResult() const {
-		return open_result != nullptr;
-	}
-
-private:
-	//! The currently open result
-	BaseQueryResult *open_result = nullptr;
-};
-
-#ifdef DEBUG
-struct DebugClientContextState : public ClientContextState {
-	~DebugClientContextState() override {
-		if (Exception::UncaughtException()) {
-			return;
-		}
-		D_ASSERT(!active_transaction);
-		D_ASSERT(!active_query);
-	}
-
-	bool active_transaction = false;
-	bool active_query = false;
-
-	void QueryBegin(ClientContext &context) override {
-		if (active_query) {
-			throw InternalException("DebugClientContextState::QueryBegin called when a query is already active");
-		}
-		active_query = true;
-	}
-	void QueryEnd(ClientContext &context) override {
-		if (!active_query) {
-			throw InternalException("DebugClientContextState::QueryEnd called when no query is active");
-		}
-		active_query = false;
-	}
-	void TransactionBegin(MetaTransaction &transaction, ClientContext &context) override {
-		if (active_transaction) {
-			throw InternalException(
-			    "DebugClientContextState::TransactionBegin called when a transaction is already active");
-		}
-		active_transaction = true;
-	}
-	void TransactionCommit(MetaTransaction &transaction, ClientContext &context) override {
-		if (!active_transaction) {
-			throw InternalException("DebugClientContextState::TransactionCommit called when no transaction is active");
-		}
-		active_transaction = false;
-	}
-	void TransactionRollback(MetaTransaction &transaction, ClientContext &context) override {
-		if (!active_transaction) {
-			throw InternalException(
-			    "DebugClientContextState::TransactionRollback called when no transaction is active");
-		}
-		active_transaction = false;
-	}
-#ifdef DUCKDB_DEBUG_REBIND
-	RebindQueryInfo OnPlanningError(ClientContext &context, SQLStatement &statement, ErrorData &error) override {
-		return RebindQueryInfo::ATTEMPT_TO_REBIND;
-	}
-	RebindQueryInfo OnFinalizePrepare(ClientContext &context, PreparedStatementData &prepared,
-	                                  PreparedStatementMode mode) override {
-		if (mode == PreparedStatementMode::PREPARE_AND_EXECUTE) {
-			return RebindQueryInfo::ATTEMPT_TO_REBIND;
-		}
-		return RebindQueryInfo::DO_NOT_REBIND;
-	}
-	RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementCallbackInfo &info,
-	                                  RebindQueryInfo current_rebind) override {
-		return RebindQueryInfo::ATTEMPT_TO_REBIND;
-	}
-#endif
-};
-#endif
-
-ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : db(std::move(database)), interrupted(false), client_data(make_uniq<ClientData>(*this)), transaction(*this) {
-	registered_state = make_uniq<RegisteredStateManager>();
-#ifdef DEBUG
-	registered_state->GetOrCreate<DebugClientContextState>("debug_client_context_state");
-#endif
-}
-
-ClientContext::~ClientContext() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	// destroy the client context and rollback if there is an active transaction
-	// but only if we are not destroying this client context as part of an exception stack unwind
-	Destroy();
-}
-
-unique_ptr<ClientContextLock> ClientContext::LockContext() {
-	return make_uniq<ClientContextLock>(context_lock);
-}
-
-void ClientContext::Destroy() {
-	auto lock = LockContext();
-	if (transaction.HasActiveTransaction()) {
-		transaction.ResetActiveQuery();
-		if (!transaction.IsAutoCommit()) {
-			transaction.Rollback(nullptr);
-		}
-	}
-	CleanupInternal(*lock);
-}
-
-void ClientContext::ProcessError(ErrorData &error, const string &query) const {
-	error.FinalizeError();
-	if (config.errors_as_json) {
-		error.ConvertErrorToJSON();
-	} else {
-		error.AddErrorLocation(query);
-	}
-}
-
-template <class T>
-unique_ptr<T> ClientContext::ErrorResult(ErrorData error, const string &query) {
-	ProcessError(error, query);
-	return make_uniq<T>(std::move(error));
-}
-
-void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &query) {
-	// check if we are on AutoCommit. In this case we should start a transaction
-	D_ASSERT(!active_query);
-	auto &db_inst = DatabaseInstance::GetDatabase(*this);
-	if (ValidChecker::IsInvalidated(db_inst)) {
-		throw ErrorManager::InvalidatedDatabase(*this, ValidChecker::InvalidatedMessage(db_inst));
-	}
-	active_query = make_uniq<ActiveQueryContext>();
-	if (transaction.IsAutoCommit()) {
-		transaction.BeginTransaction();
-	}
-
-	transaction.SetActiveQuery(db->GetDatabaseManager().GetNewQueryNumber());
-	LogQueryInternal(lock, query);
-	active_query->query = query;
-
-	query_progress.Initialize();
-	// Notify any registered state of query begin
-	for (auto &state : registered_state->States()) {
-		state->QueryBegin(*this);
-	}
-}
-
-ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction,
-                                          optional_ptr<ErrorData> previous_error) {
-	client_data->profiler->EndQuery();
-
-	if (active_query->executor) {
-		active_query->executor->CancelTasks();
-	}
-	active_query->progress_bar.reset();
-
-	D_ASSERT(active_query.get());
-	active_query.reset();
-	query_progress.Initialize();
-	ErrorData error;
-	try {
-		if (transaction.HasActiveTransaction()) {
-			transaction.ResetActiveQuery();
-			if (transaction.IsAutoCommit()) {
-				if (success) {
-					transaction.Commit();
-				} else {
-					transaction.Rollback(previous_error);
-				}
-			} else if (invalidate_transaction) {
-				D_ASSERT(!success);
-				ValidChecker::Invalidate(ActiveTransaction(), "Failed to commit");
-			}
-		}
-	} catch (std::exception &ex) {
-		error = ErrorData(ex);
-		if (Exception::InvalidatesDatabase(error.Type()) || error.Type() == ExceptionType::INTERNAL) {
-			auto &db_inst = DatabaseInstance::GetDatabase(*this);
-			ValidChecker::Invalidate(db_inst, error.RawMessage());
-		}
-	} catch (...) { // LCOV_EXCL_START
-		error = ErrorData("Unhandled exception!");
-	} // LCOV_EXCL_STOP
-
-	// Notify any registered state of query end
-	for (auto const &s : registered_state->States()) {
-		if (error.HasError()) {
-			s->QueryEnd(*this, &error);
-		} else {
-			s->QueryEnd(*this, previous_error);
-		}
-	}
-
-	return error;
-}
-
-void ClientContext::CleanupInternal(ClientContextLock &lock, BaseQueryResult *result, bool invalidate_transaction) {
-	if (!active_query) {
-		// no query currently active
-		return;
-	}
-	if (active_query->executor) {
-		active_query->executor->CancelTasks();
-	}
-	active_query->progress_bar.reset();
-
-	// Relaunch the threads if a SET THREADS command was issued
-	auto &scheduler = TaskScheduler::GetScheduler(*this);
-	scheduler.RelaunchThreads();
-
-	optional_ptr<ErrorData> passed_error = nullptr;
-	if (result && result->HasError()) {
-		passed_error = result->GetErrorObject();
-	}
-	auto error = EndQueryInternal(lock, result ? !result->HasError() : false, invalidate_transaction, passed_error);
-	if (result && !result->HasError()) {
-		// if an error occurred while committing report it in the result
-		result->SetError(error);
-	}
-	D_ASSERT(!active_query);
-}
-
-Executor &ClientContext::GetExecutor() {
-	D_ASSERT(active_query);
-	D_ASSERT(active_query->executor);
-	return *active_query->executor;
-}
-
-const string &ClientContext::GetCurrentQuery() {
-	D_ASSERT(active_query);
-	return active_query->query;
-}
-
-unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lock, PendingQueryResult &pending) {
-	D_ASSERT(active_query);
-	D_ASSERT(active_query->IsOpenResult(pending));
-	D_ASSERT(active_query->prepared);
-	auto &executor = GetExecutor();
-	auto &prepared = *active_query->prepared;
-	bool create_stream_result = prepared.properties.allow_stream_result && pending.allow_stream_result;
-	unique_ptr<QueryResult> result;
-	D_ASSERT(executor.HasResultCollector());
-	// we have a result collector - fetch the result directly from the result collector
-	result = executor.GetResult();
-	if (!create_stream_result) {
-		CleanupInternal(lock, result.get(), false);
-	} else {
-		active_query->SetOpenResult(*result);
-	}
-	return result;
-}
-
-static bool IsExplainAnalyze(SQLStatement *statement) {
-	if (!statement) {
-		return false;
-	}
-	if (statement->type != StatementType::EXPLAIN_STATEMENT) {
-		return false;
-	}
-	auto &explain = statement->Cast<ExplainStatement>();
-	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
-}
-
-shared_ptr<PreparedStatementData>
-ClientContext::CreatePreparedStatementInternal(ClientContextLock &lock, const string &query,
-                                               unique_ptr<SQLStatement> statement,
-                                               optional_ptr<case_insensitive_map_t<BoundParameterData>> values) {
-	StatementType statement_type = statement->type;
-	auto result = make_shared_ptr<PreparedStatementData>(statement_type);
-
-	auto &profiler = QueryProfiler::Get(*this);
-	profiler.StartQuery(query, IsExplainAnalyze(statement.get()), true);
-	profiler.StartPhase(MetricsType::PLANNER);
-	Planner planner(*this);
-	if (values) {
-		auto &parameter_values = *values;
-		for (auto &value : parameter_values) {
-			planner.parameter_data.emplace(value.first, BoundParameterData(value.second));
-		}
-	}
-
-	planner.CreatePlan(std::move(statement));
-	D_ASSERT(planner.plan || !planner.properties.bound_all_parameters);
-	profiler.EndPhase();
-
-	auto plan = std::move(planner.plan);
-	// extract the result column names from the plan
-	result->properties = planner.properties;
-	result->names = planner.names;
-	result->types = planner.types;
-	result->value_map = std::move(planner.value_map);
-	if (!planner.properties.bound_all_parameters) {
-		return result;
-	}
-#ifdef DEBUG
-	plan->Verify(*this);
-#endif
-	if (config.enable_optimizer && plan->RequireOptimizer()) {
-		profiler.StartPhase(MetricsType::ALL_OPTIMIZERS);
-		Optimizer optimizer(*planner.binder, *this);
-		plan = optimizer.Optimize(std::move(plan));
-		D_ASSERT(plan);
-		profiler.EndPhase();
-
-#ifdef DEBUG
-		plan->Verify(*this);
-#endif
-	}
-
-	profiler.StartPhase(MetricsType::PHYSICAL_PLANNER);
-	// now convert logical query plan into a physical query plan
-	PhysicalPlanGenerator physical_planner(*this);
-	auto physical_plan = physical_planner.CreatePlan(std::move(plan));
-	profiler.EndPhase();
-
-#ifdef DEBUG
-	D_ASSERT(!physical_plan->ToString().empty());
-#endif
-	result->plan = std::move(physical_plan);
-	return result;
-}
-
-shared_ptr<PreparedStatementData>
-ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-                                       optional_ptr<case_insensitive_map_t<BoundParameterData>> values,
-                                       PreparedStatementMode mode) {
-	// check if any client context state could request a rebind
-	bool can_request_rebind = false;
-	for (auto &state : registered_state->States()) {
-		if (state->CanRequestRebind()) {
-			can_request_rebind = true;
-		}
-	}
-	if (can_request_rebind) {
-		bool rebind = false;
-		// if any registered state can request a rebind we do the binding on a copy first
-		shared_ptr<PreparedStatementData> result;
-		try {
-			result = CreatePreparedStatementInternal(lock, query, statement->Copy(), values);
-		} catch (std::exception &ex) {
-			ErrorData error(ex);
-			// check if any registered client context state wants to try a rebind
-			for (auto &state : registered_state->States()) {
-				auto info = state->OnPlanningError(*this, *statement, error);
-				if (info == RebindQueryInfo::ATTEMPT_TO_REBIND) {
-					rebind = true;
-				}
-			}
-			if (!rebind) {
-				throw;
-			}
-		}
-		if (result) {
-			D_ASSERT(!rebind);
-			for (auto &state : registered_state->States()) {
-				auto info = state->OnFinalizePrepare(*this, *result, mode);
-				if (info == RebindQueryInfo::ATTEMPT_TO_REBIND) {
-					rebind = true;
-				}
-			}
-		}
-		if (!rebind) {
-			return result;
-		}
-		// an extension wants to do a rebind - do it once
-	}
-
-	return CreatePreparedStatementInternal(lock, query, std::move(statement), values);
-}
-
-QueryProgress ClientContext::GetQueryProgress() {
-	return query_progress;
-}
-
-void BindPreparedStatementParameters(PreparedStatementData &statement, const PendingQueryParameters &parameters) {
-	case_insensitive_map_t<BoundParameterData> owned_values;
-	if (parameters.parameters) {
-		auto &params = *parameters.parameters;
-		for (auto &val : params) {
-			owned_values.emplace(val);
-		}
-	}
-	statement.Bind(std::move(owned_values));
-}
-
-void ClientContext::RebindPreparedStatement(ClientContextLock &lock, const string &query,
-                                            shared_ptr<PreparedStatementData> &prepared,
-                                            const PendingQueryParameters &parameters) {
-	if (!prepared->unbound_statement) {
-		throw InternalException("ClientContext::RebindPreparedStatement called but PreparedStatementData did not have "
-		                        "an unbound statement so rebinding cannot be done");
-	}
-	// catalog was modified: rebind the statement before execution
-	auto new_prepared =
-	    CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters);
-	D_ASSERT(new_prepared->properties.bound_all_parameters);
-	new_prepared->properties.parameter_count = prepared->properties.parameter_count;
-	prepared = std::move(new_prepared);
-	prepared->properties.bound_all_parameters = false;
-}
-
-void ClientContext::CheckIfPreparedStatementIsExecutable(PreparedStatementData &statement) {
-	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
-		throw ErrorManager::InvalidatedTransaction(*this);
-	}
-	auto &meta_transaction = MetaTransaction::Get(*this);
-	auto &manager = DatabaseManager::Get(*this);
-	for (auto &it : statement.properties.modified_databases) {
-		auto &modified_database = it.first;
-		auto entry = manager.GetDatabase(*this, modified_database);
-		if (!entry) {
-			throw InternalException("Database \"%s\" not found", modified_database);
-		}
-		if (entry->IsReadOnly()) {
-			throw InvalidInputException(StringUtil::Format(
-			    "Cannot execute statement of type \"%s\" on database \"%s\" which is attached in read-only mode!",
-			    StatementTypeToString(statement.statement_type), modified_database));
-		}
-		meta_transaction.ModifyDatabase(*entry);
-	}
-}
-
-unique_ptr<PendingQueryResult>
-ClientContext::PendingPreparedStatementInternal(ClientContextLock &lock, shared_ptr<PreparedStatementData> statement_p,
-                                                const PendingQueryParameters &parameters) {
-	D_ASSERT(active_query);
-	auto &statement = *statement_p;
-
-	BindPreparedStatementParameters(statement, parameters);
-
-	active_query->executor = make_uniq<Executor>(*this);
-	auto &executor = *active_query->executor;
-	if (config.enable_progress_bar) {
-		progress_bar_display_create_func_t display_create_func = nullptr;
-		if (config.print_progress_bar) {
-			// If a custom display is set, use that, otherwise just use the default
-			display_create_func =
-			    config.display_create_func ? config.display_create_func : ProgressBar::DefaultProgressBarDisplay;
-		}
-		active_query->progress_bar =
-		    make_uniq<ProgressBar>(executor, NumericCast<idx_t>(config.wait_time), display_create_func);
-		active_query->progress_bar->Start();
-		query_progress.Restart();
-	}
-	auto stream_result = parameters.allow_stream_result && statement.properties.allow_stream_result;
-
-	get_result_collector_t get_method = PhysicalResultCollector::GetResultCollector;
-	auto &client_config = ClientConfig::GetConfig(*this);
-	if (!stream_result && client_config.result_collector) {
-		get_method = client_config.result_collector;
-	}
-	statement.is_streaming = stream_result;
-	auto collector = get_method(*this, statement);
-	D_ASSERT(collector->type == PhysicalOperatorType::RESULT_COLLECTOR);
-	executor.Initialize(std::move(collector));
-
-	auto types = executor.GetTypes();
-	D_ASSERT(types == statement.types);
-	D_ASSERT(!active_query->HasOpenResult());
-
-	auto pending_result =
-	    make_uniq<PendingQueryResult>(shared_from_this(), *statement_p, std::move(types), stream_result);
-	active_query->prepared = std::move(statement_p);
-	active_query->SetOpenResult(*pending_result);
-	return pending_result;
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock, const string &query,
-                                                                       shared_ptr<PreparedStatementData> prepared,
-                                                                       const PendingQueryParameters &parameters) {
-	CheckIfPreparedStatementIsExecutable(*prepared);
-
-	RebindQueryInfo rebind = RebindQueryInfo::DO_NOT_REBIND;
-	if (prepared->RequireRebind(*this, parameters.parameters)) {
-		rebind = RebindQueryInfo::ATTEMPT_TO_REBIND;
-	}
-
-	for (auto &state : registered_state->States()) {
-		PreparedStatementCallbackInfo info(*prepared, parameters);
-		auto new_rebind = state->OnExecutePrepared(*this, info, rebind);
-		if (new_rebind == RebindQueryInfo::ATTEMPT_TO_REBIND) {
-			rebind = RebindQueryInfo::ATTEMPT_TO_REBIND;
-		}
-	}
-	if (rebind == RebindQueryInfo::ATTEMPT_TO_REBIND) {
-		RebindPreparedStatement(lock, query, prepared, parameters);
-		CheckIfPreparedStatementIsExecutable(*prepared); // rerun this too as modified_databases might have changed
-	}
-	return PendingPreparedStatementInternal(lock, prepared, parameters);
-}
-
-void ClientContext::WaitForTask(ClientContextLock &lock, BaseQueryResult &result) {
-	active_query->executor->WaitForTask();
-}
-
-PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &lock, BaseQueryResult &result,
-                                                          bool dry_run) {
-	D_ASSERT(active_query);
-	D_ASSERT(active_query->IsOpenResult(result));
-	bool invalidate_transaction = true;
-	try {
-		auto query_result = active_query->executor->ExecuteTask(dry_run);
-		if (active_query->progress_bar) {
-			auto is_finished = PendingQueryResult::IsResultReady(query_result);
-			active_query->progress_bar->Update(is_finished);
-			query_progress = active_query->progress_bar->GetDetailedQueryProgress();
-		}
-		return query_result;
-	} catch (std::exception &ex) {
-		auto error = ErrorData(ex);
-		if (error.Type() == ExceptionType::INTERRUPT) {
-			auto &executor = *active_query->executor;
-			if (!executor.HasError()) {
-				// Interrupted by the user
-				result.SetError(ex);
-				invalidate_transaction = true;
-			} else {
-				// Interrupted by an exception caused in a worker thread
-				error = executor.GetError();
-				invalidate_transaction = Exception::InvalidatesTransaction(error.Type());
-				result.SetError(error);
-			}
-		} else if (!Exception::InvalidatesTransaction(error.Type())) {
-			invalidate_transaction = false;
-		} else if (Exception::InvalidatesDatabase(error.Type()) || error.Type() == ExceptionType::INTERNAL) {
-			// fatal exceptions invalidate the entire database
-			auto &db_instance = DatabaseInstance::GetDatabase(*this);
-			ValidChecker::Invalidate(db_instance, error.RawMessage());
-		}
-		ProcessError(error, active_query->query);
-		result.SetError(std::move(error));
-	} catch (...) { // LCOV_EXCL_START
-		result.SetError(ErrorData("Unhandled exception in ExecuteTaskInternal"));
-	} // LCOV_EXCL_STOP
-	EndQueryInternal(lock, false, invalidate_transaction, result.GetErrorObject());
-	return PendingExecutionResult::EXECUTION_ERROR;
-}
-
-void ClientContext::InitialCleanup(ClientContextLock &lock) {
-	//! Cleanup any open results and reset the interrupted flag
-	CleanupInternal(lock);
-	interrupted = false;
-}
-
-vector<unique_ptr<SQLStatement>> ClientContext::ParseStatements(const string &query) {
-	auto lock = LockContext();
-	return ParseStatementsInternal(*lock, query);
-}
-
-vector<unique_ptr<SQLStatement>> ClientContext::ParseStatementsInternal(ClientContextLock &lock, const string &query) {
-	Parser parser(GetParserOptions());
-	parser.ParseQuery(query);
-
-	PragmaHandler handler(*this);
-	handler.HandlePragmaStatements(lock, parser.statements);
-
-	return std::move(parser.statements);
-}
-
-void ClientContext::HandlePragmaStatements(vector<unique_ptr<SQLStatement>> &statements) {
-	auto lock = LockContext();
-
-	PragmaHandler handler(*this);
-	handler.HandlePragmaStatements(*lock, statements);
-}
-
-unique_ptr<LogicalOperator> ClientContext::ExtractPlan(const string &query) {
-	auto lock = LockContext();
-
-	auto statements = ParseStatementsInternal(*lock, query);
-	if (statements.size() != 1) {
-		throw InvalidInputException("ExtractPlan can only prepare a single statement");
-	}
-
-	unique_ptr<LogicalOperator> plan;
-	RunFunctionInTransactionInternal(*lock, [&]() {
-		Planner planner(*this);
-		planner.CreatePlan(std::move(statements[0]));
-		D_ASSERT(planner.plan);
-
-		plan = std::move(planner.plan);
-
-		if (config.enable_optimizer) {
-			Optimizer optimizer(*planner.binder, *this);
-			plan = optimizer.Optimize(std::move(plan));
-		}
-
-		ColumnBindingResolver resolver;
-		resolver.Verify(*plan);
-		resolver.VisitOperator(*plan);
-
-		plan->ResolveOperatorTypes();
-	});
-	return plan;
-}
-
-unique_ptr<PreparedStatement> ClientContext::PrepareInternal(ClientContextLock &lock,
-                                                             unique_ptr<SQLStatement> statement) {
-	auto named_param_map = statement->named_param_map;
-	auto statement_query = statement->query;
-	shared_ptr<PreparedStatementData> prepared_data;
-	auto unbound_statement = statement->Copy();
-	RunFunctionInTransactionInternal(
-	    lock, [&]() { prepared_data = CreatePreparedStatement(lock, statement_query, std::move(statement)); }, false);
-	prepared_data->unbound_statement = std::move(unbound_statement);
-	return make_uniq<PreparedStatement>(shared_from_this(), std::move(prepared_data), std::move(statement_query),
-	                                    std::move(named_param_map));
-}
-
-unique_ptr<PreparedStatement> ClientContext::Prepare(unique_ptr<SQLStatement> statement) {
-	auto lock = LockContext();
-	// prepare the query
-	auto query = statement->query;
-	try {
-		InitialCleanup(*lock);
-		return PrepareInternal(*lock, std::move(statement));
-	} catch (std::exception &ex) {
-		return ErrorResult<PreparedStatement>(ErrorData(ex), query);
-	}
-}
-
-unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
-	auto lock = LockContext();
-	// prepare the query
-	try {
-		InitialCleanup(*lock);
-
-		// first parse the query
-		auto statements = ParseStatementsInternal(*lock, query);
-		if (statements.empty()) {
-			throw InvalidInputException("No statement to prepare!");
-		}
-		if (statements.size() > 1) {
-			throw InvalidInputException("Cannot prepare multiple statements at once!");
-		}
-		return PrepareInternal(*lock, std::move(statements[0]));
-	} catch (std::exception &ex) {
-		return ErrorResult<PreparedStatement>(ErrorData(ex), query);
-	}
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
-                                                                           shared_ptr<PreparedStatementData> &prepared,
-                                                                           const PendingQueryParameters &parameters) {
-	try {
-		InitialCleanup(lock);
-	} catch (std::exception &ex) {
-		return ErrorResult<PendingQueryResult>(ErrorData(ex), query);
-	}
-	return PendingStatementOrPreparedStatementInternal(lock, query, nullptr, prepared, parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
-                                                           shared_ptr<PreparedStatementData> &prepared,
-                                                           const PendingQueryParameters &parameters) {
-	auto lock = LockContext();
-	return PendingQueryPreparedInternal(*lock, query, prepared, parameters);
-}
-
-unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               const PendingQueryParameters &parameters) {
-	auto lock = LockContext();
-	auto pending = PendingQueryPreparedInternal(*lock, query, prepared, parameters);
-	if (pending->HasError()) {
-		return ErrorResult<MaterializedQueryResult>(pending->GetErrorObject());
-	}
-	return pending->ExecuteInternal(*lock);
-}
-
-unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               case_insensitive_map_t<BoundParameterData> &values,
-                                               bool allow_stream_result) {
-	PendingQueryParameters parameters;
-	parameters.parameters = &values;
-	parameters.allow_stream_result = allow_stream_result;
-	return Execute(query, prepared, parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientContextLock &lock, const string &query,
-                                                                       unique_ptr<SQLStatement> statement,
-                                                                       const PendingQueryParameters &parameters) {
-	// prepare the query for execution
-	if (parameters.parameters) {
-		PreparedStatement::VerifyParameters(*parameters.parameters, statement->named_param_map);
-	}
-
-	auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters,
-	                                        PreparedStatementMode::PREPARE_AND_EXECUTE);
-
-	idx_t parameter_count = !parameters.parameters ? 0 : parameters.parameters->size();
-	if (prepared->properties.parameter_count > 0 && parameter_count == 0) {
-		string error_message = StringUtil::Format("Expected %lld parameters, but none were supplied",
-		                                          prepared->properties.parameter_count);
-		return ErrorResult<PendingQueryResult>(InvalidInputException(error_message), query);
-	}
-	if (!prepared->properties.bound_all_parameters) {
-		return ErrorResult<PendingQueryResult>(InvalidInputException("Not all parameters were bound"), query);
-	}
-	// execute the prepared statement
-	CheckIfPreparedStatementIsExecutable(*prepared);
-	return PendingPreparedStatementInternal(lock, std::move(prepared), parameters);
-}
-
-unique_ptr<QueryResult>
-ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-                                    bool allow_stream_result,
-                                    optional_ptr<case_insensitive_map_t<BoundParameterData>> params, bool verify) {
-	PendingQueryParameters parameters;
-	parameters.allow_stream_result = allow_stream_result;
-	parameters.parameters = params;
-	auto pending = PendingQueryInternal(lock, std::move(statement), parameters, verify);
-	if (pending->HasError()) {
-		return ErrorResult<MaterializedQueryResult>(pending->GetErrorObject());
-	}
-	return ExecutePendingQueryInternal(lock, *pending);
-}
-
-bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult &result) {
-	if (!active_query) {
-		return false;
-	}
-	return active_query->IsOpenResult(result);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatementInternal(
-    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-	if (statement && statement->type != StatementType::LOGICAL_PLAN_STATEMENT) {
-		statement = statement->Copy();
-	}
-#endif
-	// check if we are on AutoCommit. In this case we should start a transaction.
-	if (statement && config.AnyVerification()) {
-		// query verification is enabled
-		// create a copy of the statement, and use the copy
-		// this way we verify that the copy correctly copies all properties
-		auto copied_statement = statement->Copy();
-		switch (statement->type) {
-		case StatementType::SELECT_STATEMENT: {
-			// in case this is a select query, we verify the original statement
-			ErrorData error;
-			try {
-				error = VerifyQuery(lock, query, std::move(statement), parameters.parameters);
-			} catch (std::exception &ex) {
-				error = ErrorData(ex);
-			}
-			if (error.HasError()) {
-				// error in verifying query
-				return ErrorResult<PendingQueryResult>(std::move(error), query);
-			}
-			statement = std::move(copied_statement);
-			break;
-		}
-		default: {
-#ifndef DUCKDB_ALTERNATIVE_VERIFY
-			bool reparse_statement = true;
-#else
-			bool reparse_statement = false;
-#endif
-			statement = std::move(copied_statement);
-			if (statement->type == StatementType::RELATION_STATEMENT) {
-				reparse_statement = false;
-			}
-			if (reparse_statement) {
-				try {
-					Parser parser(GetParserOptions());
-					ErrorData error;
-					parser.ParseQuery(statement->ToString());
-					statement = std::move(parser.statements[0]);
-				} catch (const NotImplementedException &) {
-					// ToString was not implemented, just use the copied statement
-				}
-			}
-			break;
-		}
-		}
-	}
-	return PendingStatementOrPreparedStatement(lock, query, std::move(statement), prepared, parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatement(
-    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
-	unique_ptr<PendingQueryResult> pending;
-
-	try {
-		BeginQueryInternal(lock, query);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		if (Exception::InvalidatesDatabase(error.Type())) {
-			// fatal exceptions invalidate the entire database
-			auto &db_instance = DatabaseInstance::GetDatabase(*this);
-			ValidChecker::Invalidate(db_instance, error.RawMessage());
-		}
-		return ErrorResult<PendingQueryResult>(std::move(error), query);
-	}
-	// start the profiler
-	auto &profiler = QueryProfiler::Get(*this);
-	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
-
-	bool invalidate_query = true;
-	try {
-		if (statement) {
-			pending = PendingStatementInternal(lock, query, std::move(statement), parameters);
-		} else {
-			pending = PendingPreparedStatement(lock, query, prepared, parameters);
-		}
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		if (!Exception::InvalidatesTransaction(error.Type())) {
-			// standard exceptions do not invalidate the current transaction
-			invalidate_query = false;
-		} else if (Exception::InvalidatesDatabase(error.Type())) {
-			// fatal exceptions invalidate the entire database
-			if (!config.query_verification_enabled) {
-				auto &db_instance = DatabaseInstance::GetDatabase(*this);
-				ValidChecker::Invalidate(db_instance, error.RawMessage());
-			}
-		}
-		// other types of exceptions do invalidate the current transaction
-		pending = ErrorResult<PendingQueryResult>(std::move(error), query);
-	}
-	if (pending->HasError()) {
-		// query failed: abort now
-		EndQueryInternal(lock, false, invalidate_query, pending->GetErrorObject());
-		return pending;
-	}
-	D_ASSERT(active_query->IsOpenResult(*pending));
-	return pending;
-}
-
-void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
-	if (!client_data->log_query_writer) {
-#ifdef DUCKDB_FORCE_QUERY_LOG
-		try {
-			string log_path(DUCKDB_FORCE_QUERY_LOG);
-			client_data->log_query_writer =
-			    make_uniq<BufferedFileWriter>(FileSystem::GetFileSystem(*this), log_path,
-			                                  BufferedFileWriter::DEFAULT_OPEN_FLAGS, client_data->file_opener.get());
-		} catch (...) {
-			return;
-		}
-#else
-		return;
-#endif
-	}
-	// log query path is set: log the query
-	client_data->log_query_writer->WriteData(const_data_ptr_cast(query.c_str()), query.size());
-	client_data->log_query_writer->WriteData(const_data_ptr_cast("\n"), 1);
-	client_data->log_query_writer->Flush();
-	client_data->log_query_writer->Sync();
-}
-
-unique_ptr<QueryResult> ClientContext::Query(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	auto pending_query = PendingQuery(std::move(statement), allow_stream_result);
-	if (pending_query->HasError()) {
-		return ErrorResult<MaterializedQueryResult>(pending_query->GetErrorObject());
-	}
-	return pending_query->Execute();
-}
-
-unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_stream_result) {
-	auto lock = LockContext();
-
-	ErrorData error;
-	vector<unique_ptr<SQLStatement>> statements;
-	if (!ParseStatements(*lock, query, statements, error)) {
-		return ErrorResult<MaterializedQueryResult>(std::move(error), query);
-	}
-	if (statements.empty()) {
-		// no statements, return empty successful result
-		StatementProperties properties;
-		vector<string> names;
-		auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator());
-		return make_uniq<MaterializedQueryResult>(StatementType::INVALID_STATEMENT, properties, std::move(names),
-		                                          std::move(collection), GetClientProperties());
-	}
-
-	unique_ptr<QueryResult> result;
-	optional_ptr<QueryResult> last_result;
-	bool last_had_result = false;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		auto &statement = statements[i];
-		bool is_last_statement = i + 1 == statements.size();
-		PendingQueryParameters parameters;
-		parameters.allow_stream_result = allow_stream_result && is_last_statement;
-		auto pending_query = PendingQueryInternal(*lock, std::move(statement), parameters);
-		auto has_result = pending_query->properties.return_type == StatementReturnType::QUERY_RESULT;
-		unique_ptr<QueryResult> current_result;
-		if (pending_query->HasError()) {
-			current_result = ErrorResult<MaterializedQueryResult>(pending_query->GetErrorObject());
-		} else {
-			current_result = ExecutePendingQueryInternal(*lock, *pending_query);
-		}
-		// now append the result to the list of results
-		if (!last_result || !last_had_result) {
-			// first result of the query
-			result = std::move(current_result);
-			last_result = result.get();
-			last_had_result = has_result;
-		} else {
-			// later results; attach to the result chain
-			// but only if there is a result
-			if (!has_result) {
-				continue;
-			}
-			last_result->next = std::move(current_result);
-			last_result = last_result->next.get();
-		}
-		D_ASSERT(last_result);
-		if (last_result->HasError()) {
-			// Reset the interrupted flag, this was set by the task that found the error
-			// Next statements should not be bothered by that interruption
-			interrupted = false;
-			break;
-		}
-	}
-	return result;
-}
-
-bool ClientContext::ParseStatements(ClientContextLock &lock, const string &query,
-                                    vector<unique_ptr<SQLStatement>> &result, ErrorData &error) {
-	try {
-		InitialCleanup(lock);
-		// parse the query and transform it into a set of statements
-		result = ParseStatementsInternal(lock, query);
-		return true;
-	} catch (std::exception &ex) {
-		error = ErrorData(ex);
-		return false;
-	}
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query, bool allow_stream_result) {
-	case_insensitive_map_t<BoundParameterData> empty_param_list;
-	return PendingQuery(query, empty_param_list, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStatement> statement,
-                                                           bool allow_stream_result) {
-	case_insensitive_map_t<BoundParameterData> empty_param_list;
-	return PendingQuery(std::move(statement), empty_param_list, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
-                                                           case_insensitive_map_t<BoundParameterData> &values,
-                                                           bool allow_stream_result) {
-	auto lock = LockContext();
-	try {
-		InitialCleanup(*lock);
-
-		auto statements = ParseStatementsInternal(*lock, query);
-		if (statements.empty()) {
-			throw InvalidInputException("No statement to prepare!");
-		}
-		if (statements.size() > 1) {
-			throw InvalidInputException("Cannot prepare multiple statements at once!");
-		}
-
-		PendingQueryParameters params;
-		params.allow_stream_result = allow_stream_result;
-		params.parameters = values;
-
-		return PendingQueryInternal(*lock, std::move(statements[0]), params, true);
-	} catch (std::exception &ex) {
-		return make_uniq<PendingQueryResult>(ErrorData(ex));
-	}
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStatement> statement,
-                                                           case_insensitive_map_t<BoundParameterData> &values,
-                                                           bool allow_stream_result) {
-	auto lock = LockContext();
-	auto query = statement->query;
-	try {
-		InitialCleanup(*lock);
-
-		PendingQueryParameters params;
-		params.allow_stream_result = allow_stream_result;
-		params.parameters = values;
-
-		return PendingQueryInternal(*lock, std::move(statement), params, true);
-	} catch (std::exception &ex) {
-		return make_uniq<PendingQueryResult>(ErrorData(ex));
-	}
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
-                                                                   unique_ptr<SQLStatement> statement,
-                                                                   const PendingQueryParameters &parameters,
-                                                                   bool verify) {
-	auto query = statement->query;
-	shared_ptr<PreparedStatementData> prepared;
-	if (verify) {
-		return PendingStatementOrPreparedStatementInternal(lock, query, std::move(statement), prepared, parameters);
-	} else {
-		return PendingStatementOrPreparedStatement(lock, query, std::move(statement), prepared, parameters);
-	}
-}
-
-unique_ptr<QueryResult> ClientContext::ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query) {
-	return query.ExecuteInternal(lock);
-}
-
-void ClientContext::Interrupt() {
-	interrupted = true;
-}
-
-void ClientContext::CancelTransaction() {
-	auto lock = LockContext();
-	InitialCleanup(*lock);
-}
-
-void ClientContext::EnableProfiling() {
-	auto lock = LockContext();
-	auto &client_config = ClientConfig::GetConfig(*this);
-	client_config.enable_profiler = true;
-	client_config.emit_profiler_output = true;
-}
-
-void ClientContext::DisableProfiling() {
-	auto lock = LockContext();
-	auto &client_config = ClientConfig::GetConfig(*this);
-	client_config.enable_profiler = false;
-}
-
-void ClientContext::RegisterFunction(CreateFunctionInfo &info) {
-	RunFunctionInTransaction([&]() {
-		auto existing_function = Catalog::GetEntry<ScalarFunctionCatalogEntry>(*this, INVALID_CATALOG, info.schema,
-		                                                                       info.name, OnEntryNotFound::RETURN_NULL);
-		if (existing_function) {
-			auto &new_info = info.Cast<CreateScalarFunctionInfo>();
-			if (new_info.functions.MergeFunctionSet(existing_function->functions)) {
-				// function info was updated from catalog entry, rewrite is needed
-				info.on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
-			}
-		}
-		// create function
-		auto &catalog = Catalog::GetSystemCatalog(*this);
-		catalog.CreateFunction(*this, info);
-	});
-}
-
-void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, const std::function<void(void)> &fun,
-                                                     bool requires_valid_transaction) {
-	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
-	    ValidChecker::IsInvalidated(ActiveTransaction())) {
-		throw TransactionException(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
-	}
-	// check if we are on AutoCommit. In this case we should start a transaction
-	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
-	if (require_new_transaction) {
-		D_ASSERT(!active_query);
-		transaction.BeginTransaction();
-	}
-	try {
-		fun();
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		bool invalidates_transaction = true;
-		if (!Exception::InvalidatesTransaction(error.Type())) {
-			// standard exceptions don't invalidate the transaction
-			invalidates_transaction = false;
-		} else if (Exception::InvalidatesDatabase(error.Type())) {
-			auto &db_instance = DatabaseInstance::GetDatabase(*this);
-			ValidChecker::Invalidate(db_instance, error.RawMessage());
-		}
-		if (require_new_transaction) {
-			transaction.Rollback(error);
-		} else if (invalidates_transaction) {
-			ValidChecker::Invalidate(ActiveTransaction(), error.RawMessage());
-		}
-		throw;
-	}
-	if (require_new_transaction) {
-		transaction.Commit();
-	}
-}
-
-void ClientContext::RunFunctionInTransaction(const std::function<void(void)> &fun, bool requires_valid_transaction) {
-	auto lock = LockContext();
-	RunFunctionInTransactionInternal(*lock, fun, requires_valid_transaction);
-}
-
-unique_ptr<TableDescription> ClientContext::TableInfo(const string &database_name, const string &schema_name,
-                                                      const string &table_name) {
-	unique_ptr<TableDescription> result;
-	RunFunctionInTransaction([&]() {
-		// Obtain the table from the catalog.
-		auto table = Catalog::GetEntry<TableCatalogEntry>(*this, database_name, schema_name, table_name,
-		                                                  OnEntryNotFound::RETURN_NULL);
-		if (!table) {
-			return;
-		}
-		// Create the table description.
-		result = make_uniq<TableDescription>(database_name, schema_name, table_name);
-		auto &catalog = Catalog::GetCatalog(*this, database_name);
-		result->readonly = catalog.GetAttached().IsReadOnly();
-		for (auto &column : table->GetColumns().Logical()) {
-			result->columns.emplace_back(column.Copy());
-		}
-	});
-	return result;
-}
-
-unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name, const string &table_name) {
-	return TableInfo(INVALID_CATALOG, schema_name, table_name);
-}
-
-void ClientContext::Append(TableDescription &description, ColumnDataCollection &collection,
-                           optional_ptr<const vector<LogicalIndex>> column_ids) {
-
-	RunFunctionInTransaction([&]() {
-		auto &table_entry =
-		    Catalog::GetEntry<TableCatalogEntry>(*this, description.database, description.schema, description.table);
-		// verify that the table columns and types match up
-		if (description.PhysicalColumnCount() != table_entry.GetColumns().PhysicalColumnCount()) {
-			throw InvalidInputException("Failed to append: table entry has different number of columns!");
-		}
-		idx_t table_entry_col_idx = 0;
-		for (idx_t i = 0; i < description.columns.size(); i++) {
-			auto &column = description.columns[i];
-			if (column.Generated()) {
-				continue;
-			}
-			if (column.Type() != table_entry.GetColumns().GetColumn(PhysicalIndex(table_entry_col_idx)).Type()) {
-				throw InvalidInputException("Failed to append: table entry has different number of columns!");
-			}
-			table_entry_col_idx++;
-		}
-		auto binder = Binder::CreateBinder(*this);
-		auto bound_constraints = binder->BindConstraints(table_entry);
-		MetaTransaction::Get(*this).ModifyDatabase(table_entry.ParentCatalog().GetAttached());
-		table_entry.GetStorage().LocalAppend(table_entry, *this, collection, bound_constraints, column_ids);
-	});
-}
-
-void ClientContext::InternalTryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns) {
-	// bind the expressions
-	auto binder = Binder::CreateBinder(*this);
-	auto result = relation.Bind(*binder);
-	D_ASSERT(result.names.size() == result.types.size());
-
-	result_columns.reserve(result_columns.size() + result.names.size());
-	for (idx_t i = 0; i < result.names.size(); i++) {
-		result_columns.emplace_back(result.names[i], result.types[i]);
-	}
-}
-
-void ClientContext::TryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns) {
-#ifdef DEBUG
-	D_ASSERT(!relation.GetAlias().empty());
-	D_ASSERT(!relation.ToString().empty());
-#endif
-	RunFunctionInTransaction([&]() { InternalTryBindRelation(relation, result_columns); });
-}
-
-unordered_set<string> ClientContext::GetTableNames(const string &query) {
-	auto lock = LockContext();
-
-	auto statements = ParseStatementsInternal(*lock, query);
-	if (statements.size() != 1) {
-		throw InvalidInputException("Expected a single statement");
-	}
-
-	unordered_set<string> result;
-	RunFunctionInTransactionInternal(*lock, [&]() {
-		// bind the expressions
-		auto binder = Binder::CreateBinder(*this);
-		binder->SetBindingMode(BindingMode::EXTRACT_NAMES);
-		binder->Bind(*statements[0]);
-		result = binder->GetTableNames();
-	});
-	return result;
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
-                                                                   const shared_ptr<Relation> &relation,
-                                                                   bool allow_stream_result) {
-	InitialCleanup(lock);
-
-	string query;
-	if (config.query_verification_enabled) {
-		// run the ToString method of any relation we run, mostly to ensure it doesn't crash
-		relation->ToString();
-		relation->GetAlias();
-		if (relation->IsReadOnly()) {
-			// verify read only statements by running a select statement
-			auto select = make_uniq<SelectStatement>();
-			select->node = relation->GetQueryNode();
-			RunStatementInternal(lock, query, std::move(select), false, nullptr);
-		}
-	}
-
-	auto relation_stmt = make_uniq<RelationStatement>(relation);
-	PendingQueryParameters parameters;
-	parameters.allow_stream_result = allow_stream_result;
-	return PendingQueryInternal(lock, std::move(relation_stmt), parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const shared_ptr<Relation> &relation,
-                                                           bool allow_stream_result) {
-	auto lock = LockContext();
-	return PendingQueryInternal(*lock, relation, allow_stream_result);
-}
-
-unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relation) {
-	auto lock = LockContext();
-	auto &expected_columns = relation->Columns();
-	auto pending = PendingQueryInternal(*lock, relation, false);
-	if (!pending->success) {
-		return ErrorResult<MaterializedQueryResult>(pending->GetErrorObject());
-	}
-
-	unique_ptr<QueryResult> result;
-	result = ExecutePendingQueryInternal(*lock, *pending);
-	if (result->HasError()) {
-		return result;
-	}
-	// verify that the result types and result names of the query match the expected result types/names
-	if (result->types.size() == expected_columns.size()) {
-		bool mismatch = false;
-		for (idx_t i = 0; i < result->types.size(); i++) {
-			if (result->types[i] != expected_columns[i].Type() || result->names[i] != expected_columns[i].Name()) {
-				mismatch = true;
-				break;
-			}
-		}
-		if (!mismatch) {
-			// all is as expected: return the result
-			return result;
-		}
-	}
-	// result mismatch
-	string err_str = "Result mismatch in query!\nExpected the following columns: [";
-	for (idx_t i = 0; i < expected_columns.size(); i++) {
-		if (i > 0) {
-			err_str += ", ";
-		}
-		err_str += expected_columns[i].Name() + " " + expected_columns[i].Type().ToString();
-	}
-	err_str += "]\nBut result contained the following: ";
-	for (idx_t i = 0; i < result->types.size(); i++) {
-		err_str += i == 0 ? "[" : ", ";
-		err_str += result->names[i] + " " + result->types[i].ToString();
-	}
-	err_str += "]";
-	return ErrorResult<MaterializedQueryResult>(ErrorData(err_str));
-}
-
-SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) const {
-	// first check the built-in settings
-	auto &db_config = DBConfig::GetConfig(*this);
-	auto option = db_config.GetOptionByName(key);
-	if (option) {
-		result = option->get_setting(*this);
-		return SettingLookupResult(SettingScope::LOCAL);
-	}
-
-	// check the client session values
-	const auto &session_config_map = config.set_variables;
-
-	auto session_value = session_config_map.find(key);
-	bool found_session_value = session_value != session_config_map.end();
-	if (found_session_value) {
-		result = session_value->second;
-		return SettingLookupResult(SettingScope::LOCAL);
-	}
-	// finally check the global session values
-	return db->TryGetCurrentSetting(key, result);
-}
-
-ParserOptions ClientContext::GetParserOptions() const {
-	auto &client_config = ClientConfig::GetConfig(*this);
-	ParserOptions options;
-	options.preserve_identifier_case = client_config.preserve_identifier_case;
-	options.integer_division = client_config.integer_division;
-	options.max_expression_depth = client_config.max_expression_depth;
-	options.extensions = &DBConfig::GetConfig(*this).parser_extensions;
-	return options;
-}
-
-ClientProperties ClientContext::GetClientProperties() const {
-	string timezone = "UTC";
-	Value result;
-
-	if (TryGetCurrentSetting("TimeZone", result)) {
-		timezone = result.ToString();
-	}
-	return {timezone, db->config.options.arrow_offset_size, db->config.options.arrow_use_list_view,
-	        db->config.options.produce_arrow_string_views, db->config.options.arrow_lossless_conversion};
-}
-
-bool ClientContext::ExecutionIsFinished() {
-	if (!active_query || !active_query->executor) {
-		return false;
-	}
-	return active_query->executor->ExecutionIsFinished();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/client_context_file_opener.cpp b/src/duckdb/src/main/client_context_file_opener.cpp
deleted file mode 100644
index 5c7387b86..000000000
--- a/src/duckdb/src/main/client_context_file_opener.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/main/client_context_file_opener.hpp"
-#include "duckdb/catalog/catalog_transaction.hpp"
-
-#include "duckdb/main/database.hpp"
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result) {
-	return context.TryGetCurrentSetting(key, result);
-}
-
-// LCOV_EXCL_START
-SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) {
-	return context.TryGetCurrentSetting(key, result);
-}
-
-optional_ptr<DatabaseInstance> ClientContextFileOpener::TryGetDatabase() {
-	return context.db.get();
-}
-
-unique_ptr<CatalogTransaction> FileOpener::TryGetCatalogTransaction(optional_ptr<FileOpener> opener) {
-	if (!opener) {
-		return nullptr;
-	}
-	auto context = opener->TryGetClientContext();
-	if (context) {
-		return make_uniq<CatalogTransaction>(CatalogTransaction::GetSystemCatalogTransaction(*context));
-	}
-
-	auto db = opener->TryGetDatabase();
-	if (db) {
-		return make_uniq<CatalogTransaction>(CatalogTransaction::GetSystemTransaction(*db));
-	}
-	return nullptr;
-}
-
-optional_ptr<ClientContext> FileOpener::TryGetClientContext(optional_ptr<FileOpener> opener) {
-	if (!opener) {
-		return nullptr;
-	}
-	return opener->TryGetClientContext();
-}
-
-optional_ptr<DatabaseInstance> FileOpener::TryGetDatabase(optional_ptr<FileOpener> opener) {
-	if (!opener) {
-		return nullptr;
-	}
-	return opener->TryGetDatabase();
-}
-
-optional_ptr<SecretManager> FileOpener::TryGetSecretManager(optional_ptr<FileOpener> opener) {
-	if (!opener) {
-		return nullptr;
-	}
-
-	auto db = opener->TryGetDatabase();
-	if (!db) {
-		return nullptr;
-	}
-
-	return &db->GetSecretManager();
-}
-
-SettingLookupResult FileOpener::TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key,
-                                                     Value &result) {
-	if (!opener) {
-		return SettingLookupResult();
-	}
-	return opener->TryGetCurrentSetting(key, result);
-}
-
-SettingLookupResult FileOpener::TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key, Value &result,
-                                                     FileOpenerInfo &info) {
-	if (!opener) {
-		return SettingLookupResult();
-	}
-	return opener->TryGetCurrentSetting(key, result, info);
-}
-
-SettingLookupResult FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) {
-	return this->TryGetCurrentSetting(key, result);
-}
-// LCOV_EXCL_STOP
-} // namespace duckdb
diff --git a/src/duckdb/src/main/client_context_wrapper.cpp b/src/duckdb/src/main/client_context_wrapper.cpp
deleted file mode 100644
index 74783c79d..000000000
--- a/src/duckdb/src/main/client_context_wrapper.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/main/client_context_wrapper.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-ClientContextWrapper::ClientContextWrapper(const shared_ptr<ClientContext> &context) : client_context(context) {
-}
-
-shared_ptr<ClientContext> ClientContextWrapper::TryGetContext() {
-	auto actual_context = client_context.lock();
-	return actual_context;
-}
-
-shared_ptr<ClientContext> ClientContextWrapper::GetContext() {
-	auto actual_context = TryGetContext();
-	if (!actual_context) {
-		throw ConnectionException("Connection has already been closed");
-	}
-	return actual_context;
-}
-
-void ClientContextWrapper::TryBindRelation(Relation &relation, vector<ColumnDefinition> &columns) {
-	GetContext()->TryBindRelation(relation, columns);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/client_data.cpp b/src/duckdb/src/main/client_data.cpp
deleted file mode 100644
index fb07894c4..000000000
--- a/src/duckdb/src/main/client_data.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/main/client_data.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/common/opener_file_system.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/logging/http_logger.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_context_file_opener.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/query_profiler.hpp"
-
-namespace duckdb {
-
-class ClientFileSystem : public OpenerFileSystem {
-public:
-	explicit ClientFileSystem(ClientContext &context_p) : context(context_p) {
-	}
-
-	FileSystem &GetFileSystem() const override {
-		auto &config = DBConfig::GetConfig(context);
-		return *config.file_system;
-	}
-
-	optional_ptr<FileOpener> GetOpener() const override {
-		return ClientData::Get(context).file_opener.get();
-	}
-
-private:
-	ClientContext &context;
-};
-
-ClientData::ClientData(ClientContext &context) : catalog_search_path(make_uniq<CatalogSearchPath>(context)) {
-	auto &db = DatabaseInstance::GetDatabase(context);
-	profiler = make_shared_ptr<QueryProfiler>(context);
-	http_logger = make_shared_ptr<HTTPLogger>(context);
-	temporary_objects = make_shared_ptr<AttachedDatabase>(db, AttachedDatabaseType::TEMP_DATABASE);
-	temporary_objects->oid = DatabaseManager::Get(db).NextOid();
-	random_engine = make_uniq<RandomEngine>();
-	file_opener = make_uniq<ClientContextFileOpener>(context);
-	client_file_system = make_uniq<ClientFileSystem>(context);
-	temporary_objects->Initialize();
-}
-
-ClientData::~ClientData() {
-}
-
-ClientData &ClientData::Get(ClientContext &context) {
-	return *context.client_data;
-}
-
-const ClientData &ClientData::Get(const ClientContext &context) {
-	return *context.client_data;
-}
-
-RandomEngine &RandomEngine::Get(ClientContext &context) {
-	return *ClientData::Get(context).random_engine;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/client_verify.cpp b/src/duckdb/src/main/client_verify.cpp
deleted file mode 100644
index d3fb4f380..000000000
--- a/src/duckdb/src/main/client_verify.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/verification/statement_verifier.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/common/box_renderer.hpp"
-
-namespace duckdb {
-
-static void ThrowIfExceptionIsInternal(StatementVerifier &verifier) {
-	if (!verifier.materialized_result) {
-		return;
-	}
-	auto &result = *verifier.materialized_result;
-	if (!result.HasError()) {
-		return;
-	}
-	auto &error = result.GetErrorObject();
-	if (error.Type() == ExceptionType::INTERNAL) {
-		error.Throw();
-	}
-}
-
-ErrorData ClientContext::VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-                                     optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	D_ASSERT(statement->type == StatementType::SELECT_STATEMENT);
-	// Aggressive query verification
-
-#ifdef DUCKDB_RUN_SLOW_VERIFIERS
-	bool run_slow_verifiers = true;
-#else
-	bool run_slow_verifiers = false;
-#endif
-
-	// The purpose of this function is to test correctness of otherwise hard to test features:
-	// Copy() of statements and expressions
-	// Serialize()/Deserialize() of expressions
-	// Hash() of expressions
-	// Equality() of statements and expressions
-	// ToString() of statements and expressions
-	// Correctness of plans both with and without optimizers
-
-	const auto &stmt = *statement;
-	vector<unique_ptr<StatementVerifier>> statement_verifiers;
-	unique_ptr<StatementVerifier> prepared_statement_verifier;
-
-	// Base Statement verifiers: these are the verifiers we enable for regular builds
-	if (config.query_verification_enabled) {
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::COPIED, stmt, parameters));
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED, stmt, parameters));
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::UNOPTIMIZED, stmt, parameters));
-
-		// FIXME: Prepared parameter verifier is broken for queries with parameters
-		if (!parameters || parameters->empty()) {
-			prepared_statement_verifier = StatementVerifier::Create(VerificationType::PREPARED, stmt, parameters);
-		}
-	}
-
-	// This verifier is enabled explicitly OR by enabling run_slow_verifiers
-	if (config.verify_fetch_row || (run_slow_verifiers && config.query_verification_enabled)) {
-		statement_verifiers.emplace_back(
-		    StatementVerifier::Create(VerificationType::FETCH_ROW_AS_SCAN, stmt, parameters));
-	}
-
-	// For the DEBUG_ASYNC build we enable this extra verifier
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	if (config.query_verification_enabled) {
-		statement_verifiers.emplace_back(
-		    StatementVerifier::Create(VerificationType::NO_OPERATOR_CACHING, stmt, parameters));
-	}
-#endif
-
-	// Verify external always needs to be explicitly enabled and is never part of default verifier set
-	if (config.verify_external) {
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::EXTERNAL, stmt, parameters));
-	}
-
-	auto original = make_uniq<StatementVerifier>(std::move(statement), parameters);
-	for (auto &verifier : statement_verifiers) {
-		original->CheckExpressions(*verifier);
-	}
-	original->CheckExpressions();
-
-	// See below
-	auto statement_copy_for_explain = stmt.Copy();
-
-	// Save settings
-	bool optimizer_enabled = config.enable_optimizer;
-	bool profiling_is_enabled = config.enable_profiler;
-	bool force_external = config.force_external;
-
-	// Disable profiling if it is enabled
-	if (profiling_is_enabled) {
-		config.enable_profiler = false;
-	}
-
-	// Execute the original statement
-	bool any_failed = original->Run(*this, query,
-	                                [&](const string &q, unique_ptr<SQLStatement> s,
-	                                    optional_ptr<case_insensitive_map_t<BoundParameterData>> params) {
-		                                return RunStatementInternal(lock, q, std::move(s), false, params, false);
-	                                });
-	if (!any_failed) {
-		statement_verifiers.emplace_back(
-		    StatementVerifier::Create(VerificationType::PARSED, *statement_copy_for_explain, parameters));
-	}
-	// Execute the verifiers
-	for (auto &verifier : statement_verifiers) {
-		bool failed = verifier->Run(*this, query,
-		                            [&](const string &q, unique_ptr<SQLStatement> s,
-		                                optional_ptr<case_insensitive_map_t<BoundParameterData>> params) {
-			                            return RunStatementInternal(lock, q, std::move(s), false, params, false);
-		                            });
-		any_failed = any_failed || failed;
-	}
-
-	if (!any_failed && prepared_statement_verifier) {
-		// If none failed, we execute the prepared statement verifier
-		bool failed = prepared_statement_verifier->Run(
-		    *this, query,
-		    [&](const string &q, unique_ptr<SQLStatement> s,
-		        optional_ptr<case_insensitive_map_t<BoundParameterData>> params) {
-			    return RunStatementInternal(lock, q, std::move(s), false, params, false);
-		    });
-		if (!failed) {
-			// PreparedStatementVerifier fails if it runs into a ParameterNotAllowedException, which is OK
-			statement_verifiers.push_back(std::move(prepared_statement_verifier));
-		} else {
-			// If it does fail, let's make sure it's not an internal exception
-			ThrowIfExceptionIsInternal(*prepared_statement_verifier);
-		}
-	} else {
-		if (ValidChecker::IsInvalidated(*db)) {
-			return original->materialized_result->GetErrorObject();
-		}
-		if (transaction.HasActiveTransaction() && ValidChecker::IsInvalidated(ActiveTransaction())) {
-			return original->materialized_result->GetErrorObject();
-		}
-	}
-
-	// Restore config setting
-	config.enable_optimizer = optimizer_enabled;
-	config.force_external = force_external;
-
-	// Check explain, only if q does not already contain EXPLAIN
-	if (original->materialized_result->success) {
-		auto explain_q = "EXPLAIN " + query;
-		auto original_named_param_map = statement_copy_for_explain->named_param_map;
-		auto explain_stmt = make_uniq<ExplainStatement>(std::move(statement_copy_for_explain));
-		explain_stmt->named_param_map = original_named_param_map;
-		try {
-			RunStatementInternal(lock, explain_q, std::move(explain_stmt), false, parameters, false);
-		} catch (std::exception &ex) { // LCOV_EXCL_START
-			ErrorData error(ex);
-			interrupted = false;
-			return ErrorData("EXPLAIN failed but query did not (" + error.RawMessage() + ")");
-		} // LCOV_EXCL_STOP
-
-#ifdef DUCKDB_VERIFY_BOX_RENDERER
-		// this is pretty slow, so disabled by default
-		// test the box renderer on the result
-		// we mostly care that this does not crash
-		RandomEngine random;
-		BoxRendererConfig config;
-		// test with a random width
-		config.max_width = random.NextRandomInteger() % 500;
-		BoxRenderer renderer(config);
-		renderer.ToString(*this, original->materialized_result->names, original->materialized_result->Collection());
-#endif
-	}
-
-	// Restore profiler setting
-	if (profiling_is_enabled) {
-		config.enable_profiler = true;
-	}
-
-	// Now compare the results
-	// The results of all runs should be identical
-	for (auto &verifier : statement_verifiers) {
-		auto result = original->CompareResults(*verifier);
-		if (!result.empty()) {
-			return ErrorData(result);
-		}
-	}
-
-	return ErrorData();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/config.cpp b/src/duckdb/src/main/config.cpp
deleted file mode 100644
index 2c604cec3..000000000
--- a/src/duckdb/src/main/config.cpp
+++ /dev/null
@@ -1,782 +0,0 @@
-#include "duckdb/main/config.hpp"
-
-#include "duckdb/common/cgroups.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/settings.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-
-#ifndef DUCKDB_NO_THREADS
-#include "duckdb/common/thread.hpp"
-#endif
-
-#include <cinttypes>
-#include <cstdio>
-
-namespace duckdb {
-
-#ifdef DEBUG
-bool DBConfigOptions::debug_print_bindings = false;
-#endif
-
-#define DUCKDB_GLOBAL(_PARAM)                                                                                          \
-	{                                                                                                                  \
-		_PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::ResetGlobal,         \
-		    nullptr, _PARAM::GetSetting                                                                                \
-	}
-#define DUCKDB_GLOBAL_ALIAS(_ALIAS, _PARAM)                                                                            \
-	{                                                                                                                  \
-		_ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::ResetGlobal, nullptr,      \
-		    _PARAM::GetSetting                                                                                         \
-	}
-
-#define DUCKDB_LOCAL(_PARAM)                                                                                           \
-	{                                                                                                                  \
-		_PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, nullptr, _PARAM::ResetLocal,  \
-		    _PARAM::GetSetting                                                                                         \
-	}
-#define DUCKDB_LOCAL_ALIAS(_ALIAS, _PARAM)                                                                             \
-	{                                                                                                                  \
-		_ALIAS, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, nullptr, _PARAM::ResetLocal,        \
-		    _PARAM::GetSetting                                                                                         \
-	}
-
-#define DUCKDB_GLOBAL_LOCAL(_PARAM)                                                                                    \
-	{                                                                                                                  \
-		_PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal,                     \
-		    _PARAM::ResetGlobal, _PARAM::ResetLocal, _PARAM::GetSetting                                                \
-	}
-#define DUCKDB_GLOBAL_LOCAL_ALIAS(_ALIAS, _PARAM)                                                                      \
-	{                                                                                                                  \
-		_ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, _PARAM::ResetGlobal,      \
-		    _PARAM::ResetLocal, _PARAM::GetSetting                                                                     \
-	}
-#define FINAL_SETTING                                                                                                  \
-	{ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }
-
-static const ConfigurationOption internal_options[] = {
-    DUCKDB_GLOBAL(AccessModeSetting),
-    DUCKDB_GLOBAL(AllocatorBackgroundThreadsSetting),
-    DUCKDB_GLOBAL(AllocatorBulkDeallocationFlushThresholdSetting),
-    DUCKDB_GLOBAL(AllocatorFlushThresholdSetting),
-    DUCKDB_GLOBAL(AllowCommunityExtensionsSetting),
-    DUCKDB_GLOBAL(AllowExtensionsMetadataMismatchSetting),
-    DUCKDB_GLOBAL(AllowPersistentSecretsSetting),
-    DUCKDB_GLOBAL(AllowUnredactedSecretsSetting),
-    DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting),
-    DUCKDB_GLOBAL(AllowedDirectoriesSetting),
-    DUCKDB_GLOBAL(AllowedPathsSetting),
-    DUCKDB_GLOBAL(ArrowLargeBufferSizeSetting),
-    DUCKDB_GLOBAL(ArrowLosslessConversionSetting),
-    DUCKDB_GLOBAL(ArrowOutputListViewSetting),
-    DUCKDB_GLOBAL(AutoinstallExtensionRepositorySetting),
-    DUCKDB_GLOBAL(AutoinstallKnownExtensionsSetting),
-    DUCKDB_GLOBAL(AutoloadKnownExtensionsSetting),
-    DUCKDB_GLOBAL(CatalogErrorMaxSchemasSetting),
-    DUCKDB_GLOBAL(CheckpointThresholdSetting),
-    DUCKDB_GLOBAL_ALIAS("wal_autocheckpoint", CheckpointThresholdSetting),
-    DUCKDB_GLOBAL(CustomExtensionRepositorySetting),
-    DUCKDB_LOCAL(CustomProfilingSettingsSetting),
-    DUCKDB_GLOBAL(CustomUserAgentSetting),
-    DUCKDB_LOCAL(DebugAsofIejoinSetting),
-    DUCKDB_GLOBAL(DebugCheckpointAbortSetting),
-    DUCKDB_LOCAL(DebugForceExternalSetting),
-    DUCKDB_LOCAL(DebugForceNoCrossProductSetting),
-    DUCKDB_GLOBAL(DebugSkipCheckpointOnCommitSetting),
-    DUCKDB_GLOBAL(DebugWindowModeSetting),
-    DUCKDB_GLOBAL(DefaultBlockSizeSetting),
-    DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
-    DUCKDB_GLOBAL(DefaultNullOrderSetting),
-    DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
-    DUCKDB_GLOBAL(DefaultOrderSetting),
-    DUCKDB_GLOBAL(DefaultSecretStorageSetting),
-    DUCKDB_GLOBAL(DisabledFilesystemsSetting),
-    DUCKDB_GLOBAL(DisabledOptimizersSetting),
-    DUCKDB_GLOBAL(DuckDBAPISetting),
-    DUCKDB_LOCAL(DynamicOrFilterThresholdSetting),
-    DUCKDB_GLOBAL(EnableExternalAccessSetting),
-    DUCKDB_GLOBAL(EnableFSSTVectorsSetting),
-    DUCKDB_LOCAL(EnableHTTPLoggingSetting),
-    DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting),
-    DUCKDB_GLOBAL(EnableMacroDependenciesSetting),
-    DUCKDB_GLOBAL(EnableObjectCacheSetting),
-    DUCKDB_LOCAL(EnableProfilingSetting),
-    DUCKDB_LOCAL(EnableProgressBarSetting),
-    DUCKDB_LOCAL(EnableProgressBarPrintSetting),
-    DUCKDB_GLOBAL(EnableViewDependenciesSetting),
-    DUCKDB_LOCAL(ErrorsAsJSONSetting),
-    DUCKDB_LOCAL(ExplainOutputSetting),
-    DUCKDB_GLOBAL(ExtensionDirectorySetting),
-    DUCKDB_GLOBAL(ExternalThreadsSetting),
-    DUCKDB_LOCAL(FileSearchPathSetting),
-    DUCKDB_GLOBAL(ForceBitpackingModeSetting),
-    DUCKDB_GLOBAL(ForceCompressionSetting),
-    DUCKDB_LOCAL(HomeDirectorySetting),
-    DUCKDB_LOCAL(HTTPLoggingOutputSetting),
-    DUCKDB_GLOBAL(HTTPProxySetting),
-    DUCKDB_GLOBAL(HTTPProxyPasswordSetting),
-    DUCKDB_GLOBAL(HTTPProxyUsernameSetting),
-    DUCKDB_LOCAL(IEEEFloatingPointOpsSetting),
-    DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
-    DUCKDB_GLOBAL(IndexScanMaxCountSetting),
-    DUCKDB_GLOBAL(IndexScanPercentageSetting),
-    DUCKDB_LOCAL(IntegerDivisionSetting),
-    DUCKDB_GLOBAL(LockConfigurationSetting),
-    DUCKDB_LOCAL(LogQueryPathSetting),
-    DUCKDB_LOCAL(MaxExpressionDepthSetting),
-    DUCKDB_GLOBAL(MaxMemorySetting),
-    DUCKDB_GLOBAL_ALIAS("memory_limit", MaxMemorySetting),
-    DUCKDB_GLOBAL(MaxTempDirectorySizeSetting),
-    DUCKDB_GLOBAL(MaxVacuumTasksSetting),
-    DUCKDB_LOCAL(MergeJoinThresholdSetting),
-    DUCKDB_LOCAL(NestedLoopJoinThresholdSetting),
-    DUCKDB_GLOBAL(OldImplicitCastingSetting),
-    DUCKDB_LOCAL(OrderByNonIntegerLiteralSetting),
-    DUCKDB_LOCAL(OrderedAggregateThresholdSetting),
-    DUCKDB_LOCAL(PartitionedWriteFlushThresholdSetting),
-    DUCKDB_LOCAL(PartitionedWriteMaxOpenFilesSetting),
-    DUCKDB_GLOBAL(PasswordSetting),
-    DUCKDB_LOCAL(PerfectHtThresholdSetting),
-    DUCKDB_LOCAL(PivotFilterThresholdSetting),
-    DUCKDB_LOCAL(PivotLimitSetting),
-    DUCKDB_LOCAL(PreferRangeJoinsSetting),
-    DUCKDB_LOCAL(PreserveIdentifierCaseSetting),
-    DUCKDB_GLOBAL(PreserveInsertionOrderSetting),
-    DUCKDB_GLOBAL(ProduceArrowStringViewSetting),
-    DUCKDB_LOCAL(ProfileOutputSetting),
-    DUCKDB_LOCAL_ALIAS("profiling_output", ProfileOutputSetting),
-    DUCKDB_LOCAL(ProfilingModeSetting),
-    DUCKDB_LOCAL(ProgressBarTimeSetting),
-    DUCKDB_LOCAL(ScalarSubqueryErrorOnMultipleRowsSetting),
-    DUCKDB_LOCAL(SchemaSetting),
-    DUCKDB_LOCAL(SearchPathSetting),
-    DUCKDB_GLOBAL(SecretDirectorySetting),
-    DUCKDB_GLOBAL(StorageCompatibilityVersionSetting),
-    DUCKDB_LOCAL(StreamingBufferSizeSetting),
-    DUCKDB_GLOBAL(TempDirectorySetting),
-    DUCKDB_GLOBAL(ThreadsSetting),
-    DUCKDB_GLOBAL_ALIAS("worker_threads", ThreadsSetting),
-    DUCKDB_GLOBAL(UsernameSetting),
-    DUCKDB_GLOBAL_ALIAS("user", UsernameSetting),
-    DUCKDB_GLOBAL(ZstdMinStringLengthSetting),
-    FINAL_SETTING};
-
-vector<ConfigurationOption> DBConfig::GetOptions() {
-	vector<ConfigurationOption> options;
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		options.push_back(internal_options[index]);
-	}
-	return options;
-}
-
-idx_t DBConfig::GetOptionCount() {
-	idx_t count = 0;
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		count++;
-	}
-	return count;
-}
-
-vector<std::string> DBConfig::GetOptionNames() {
-	vector<string> names;
-	for (idx_t i = 0, option_count = DBConfig::GetOptionCount(); i < option_count; i++) {
-		names.emplace_back(DBConfig::GetOptionByIndex(i)->name);
-	}
-	return names;
-}
-
-optional_ptr<const ConfigurationOption> DBConfig::GetOptionByIndex(idx_t target_index) {
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		if (index == target_index) {
-			return internal_options + index;
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<const ConfigurationOption> DBConfig::GetOptionByName(const string &name) {
-	auto lname = StringUtil::Lower(name);
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		D_ASSERT(StringUtil::Lower(internal_options[index].name) == string(internal_options[index].name));
-		if (internal_options[index].name == lname) {
-			return internal_options + index;
-		}
-	}
-	return nullptr;
-}
-
-void DBConfig::SetOption(const ConfigurationOption &option, const Value &value) {
-	SetOption(nullptr, option, value);
-}
-
-void DBConfig::SetOptionByName(const string &name, const Value &value) {
-	if (is_user_config) {
-		// for user config we just set the option in the `user_options`
-		options.user_options[name] = value;
-	}
-	auto option = DBConfig::GetOptionByName(name);
-	if (option) {
-		SetOption(*option, value);
-		return;
-	}
-
-	auto param = extension_parameters.find(name);
-	if (param != extension_parameters.end()) {
-		Value target_value = value.DefaultCastAs(param->second.type);
-		SetOption(name, std::move(target_value));
-	} else {
-		options.unrecognized_options[name] = value;
-	}
-}
-
-void DBConfig::SetOptionsByName(const case_insensitive_map_t<Value> &values) {
-	for (auto &kv : values) {
-		auto &name = kv.first;
-		auto &value = kv.second;
-		SetOptionByName(name, value);
-	}
-}
-
-void DBConfig::SetOption(DatabaseInstance *db, const ConfigurationOption &option, const Value &value) {
-	lock_guard<mutex> l(config_lock);
-	if (!option.set_global) {
-		throw InvalidInputException("Could not set option \"%s\" as a global option", option.name);
-	}
-	D_ASSERT(option.reset_global);
-	Value input = value.DefaultCastAs(ParseLogicalType(option.parameter_type));
-	option.set_global(db, *this, input);
-}
-
-void DBConfig::ResetOption(DatabaseInstance *db, const ConfigurationOption &option) {
-	lock_guard<mutex> l(config_lock);
-	if (!option.reset_global) {
-		throw InternalException("Could not reset option \"%s\" as a global option", option.name);
-	}
-	D_ASSERT(option.set_global);
-	option.reset_global(db, *this);
-}
-
-void DBConfig::SetOption(const string &name, Value value) {
-	lock_guard<mutex> l(config_lock);
-	options.set_variables[name] = std::move(value);
-}
-
-void DBConfig::ResetOption(const string &name) {
-	lock_guard<mutex> l(config_lock);
-	auto extension_option = extension_parameters.find(name);
-	D_ASSERT(extension_option != extension_parameters.end());
-	auto &default_value = extension_option->second.default_value;
-	if (!default_value.IsNull()) {
-		// Default is not NULL, override the setting
-		options.set_variables[name] = default_value;
-	} else {
-		// Otherwise just remove it from the 'set_variables' map
-		options.set_variables.erase(name);
-	}
-}
-
-LogicalType DBConfig::ParseLogicalType(const string &type) {
-	if (StringUtil::EndsWith(type, "[]")) {
-		// list - recurse
-		auto child_type = ParseLogicalType(type.substr(0, type.size() - 2));
-		return LogicalType::LIST(child_type);
-	}
-
-	if (StringUtil::EndsWith(type, "]")) {
-		// array - recurse
-		auto bracket_open_idx = type.rfind('[');
-		if (bracket_open_idx == DConstants::INVALID_INDEX || bracket_open_idx == 0) {
-			throw InternalException("Ill formatted type: '%s'", type);
-		}
-		idx_t array_size = 0;
-		for (auto length_idx = bracket_open_idx + 1; length_idx < type.size() - 1; length_idx++) {
-			if (!isdigit(type[length_idx])) {
-				throw InternalException("Ill formatted array type: '%s'", type);
-			}
-			array_size = array_size * 10 + static_cast<idx_t>(type[length_idx] - '0');
-		}
-		if (array_size == 0 || array_size > ArrayType::MAX_ARRAY_SIZE) {
-			throw InternalException("Invalid array size: '%s'", type);
-		}
-		auto child_type = ParseLogicalType(type.substr(0, bracket_open_idx));
-		return LogicalType::ARRAY(child_type, array_size);
-	}
-
-	if (StringUtil::StartsWith(type, "MAP(") && StringUtil::EndsWith(type, ")")) {
-		// map - recurse
-		string map_args = type.substr(4, type.size() - 5);
-		vector<string> map_args_vect = StringUtil::SplitWithParentheses(map_args);
-		if (map_args_vect.size() != 2) {
-			throw InternalException("Ill formatted map type: '%s'", type);
-		}
-		StringUtil::Trim(map_args_vect[0]);
-		StringUtil::Trim(map_args_vect[1]);
-		auto key_type = ParseLogicalType(map_args_vect[0]);
-		auto value_type = ParseLogicalType(map_args_vect[1]);
-		return LogicalType::MAP(key_type, value_type);
-	}
-
-	if (StringUtil::StartsWith(type, "UNION(") && StringUtil::EndsWith(type, ")")) {
-		// union - recurse
-		string union_members_str = type.substr(6, type.size() - 7);
-		vector<string> union_members_vect = StringUtil::SplitWithParentheses(union_members_str);
-		child_list_t<LogicalType> union_members;
-		for (idx_t member_idx = 0; member_idx < union_members_vect.size(); member_idx++) {
-			StringUtil::Trim(union_members_vect[member_idx]);
-			vector<string> union_member_parts = StringUtil::SplitWithParentheses(union_members_vect[member_idx], ' ');
-			if (union_member_parts.size() != 2) {
-				throw InternalException("Ill formatted union type: %s", type);
-			}
-			StringUtil::Trim(union_member_parts[0]);
-			StringUtil::Trim(union_member_parts[1]);
-			auto value_type = ParseLogicalType(union_member_parts[1]);
-			union_members.emplace_back(make_pair(union_member_parts[0], value_type));
-		}
-		if (union_members.empty() || union_members.size() > UnionType::MAX_UNION_MEMBERS) {
-			throw InternalException("Invalid number of union members: '%s'", type);
-		}
-		return LogicalType::UNION(union_members);
-	}
-
-	if (StringUtil::StartsWith(type, "STRUCT(") && StringUtil::EndsWith(type, ")")) {
-		// struct - recurse
-		string struct_members_str = type.substr(7, type.size() - 8);
-		vector<string> struct_members_vect = StringUtil::SplitWithParentheses(struct_members_str);
-		child_list_t<LogicalType> struct_members;
-		for (idx_t member_idx = 0; member_idx < struct_members_vect.size(); member_idx++) {
-			StringUtil::Trim(struct_members_vect[member_idx]);
-			vector<string> struct_member_parts = StringUtil::SplitWithParentheses(struct_members_vect[member_idx], ' ');
-			if (struct_member_parts.size() != 2) {
-				throw InternalException("Ill formatted struct type: %s", type);
-			}
-			StringUtil::Trim(struct_member_parts[0]);
-			StringUtil::Trim(struct_member_parts[1]);
-			auto value_type = ParseLogicalType(struct_member_parts[1]);
-			struct_members.emplace_back(make_pair(struct_member_parts[0], value_type));
-		}
-		return LogicalType::STRUCT(struct_members);
-	}
-
-	LogicalType type_id = StringUtil::CIEquals(type, "ANY") ? LogicalType::ANY : TransformStringToLogicalTypeId(type);
-	if (type_id == LogicalTypeId::USER) {
-		throw InternalException("Error while generating extension function overloads - unrecognized logical type %s",
-		                        type);
-	}
-	return type_id;
-}
-
-void DBConfig::AddExtensionOption(const string &name, string description, LogicalType parameter,
-                                  const Value &default_value, set_option_callback_t function) {
-	extension_parameters.insert(
-	    make_pair(name, ExtensionOption(std::move(description), std::move(parameter), function, default_value)));
-	if (!default_value.IsNull()) {
-		// Default value is set, insert it into the 'set_variables' list
-		options.set_variables[name] = default_value;
-	}
-}
-
-bool DBConfig::IsInMemoryDatabase(const char *database_path) {
-	if (!database_path) {
-		// Entirely empty
-		return true;
-	}
-	if (strlen(database_path) == 0) {
-		// '' empty string
-		return true;
-	}
-	if (strcmp(database_path, ":memory:") == 0) {
-		return true;
-	}
-	return false;
-}
-
-CastFunctionSet &DBConfig::GetCastFunctions() {
-	return *cast_functions;
-}
-
-CollationBinding &DBConfig::GetCollationBinding() {
-	return *collation_bindings;
-}
-
-IndexTypeSet &DBConfig::GetIndexTypes() {
-	return *index_types;
-}
-
-void DBConfig::SetDefaultMaxMemory() {
-	auto memory = GetSystemAvailableMemory(*file_system);
-	if (memory == DBConfigOptions().maximum_memory) {
-		// If GetSystemAvailableMemory returned the default, use it as is
-		options.maximum_memory = memory;
-	} else {
-		// Otherwise, use 80% of the available memory
-		options.maximum_memory = memory * 8 / 10;
-	}
-}
-
-void DBConfig::SetDefaultTempDirectory() {
-	if (!options.use_temporary_directory) {
-		options.temporary_directory = string();
-	} else if (DBConfig::IsInMemoryDatabase(options.database_path.c_str())) {
-		options.temporary_directory = ".tmp";
-	} else {
-		options.temporary_directory = options.database_path + ".tmp";
-	}
-}
-
-void DBConfig::CheckLock(const string &name) {
-	if (!options.lock_configuration) {
-		// not locked
-		return;
-	}
-	case_insensitive_set_t allowed_settings {"schema", "search_path"};
-	if (allowed_settings.find(name) != allowed_settings.end()) {
-		// we are always allowed to change these settings
-		return;
-	}
-	// not allowed!
-	throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked", name);
-}
-
-idx_t DBConfig::GetSystemMaxThreads(FileSystem &fs) {
-#ifdef DUCKDB_NO_THREADS
-	return 1;
-#else
-	idx_t physical_cores = std::thread::hardware_concurrency();
-#ifdef __linux__
-	if (const char *slurm_cpus = getenv("SLURM_CPUS_ON_NODE")) {
-		idx_t slurm_threads;
-		if (TryCast::Operation<string_t, idx_t>(string_t(slurm_cpus), slurm_threads)) {
-			return MaxValue<idx_t>(slurm_threads, 1);
-		}
-	}
-	return MaxValue<idx_t>(CGroups::GetCPULimit(fs, physical_cores), 1);
-#else
-	return physical_cores;
-#endif
-#endif
-}
-
-idx_t DBConfig::GetSystemAvailableMemory(FileSystem &fs) {
-#ifdef __linux__
-	// Check SLURM environment variables first
-	const char *slurm_mem_per_node = getenv("SLURM_MEM_PER_NODE");
-	const char *slurm_mem_per_cpu = getenv("SLURM_MEM_PER_CPU");
-
-	if (slurm_mem_per_node) {
-		auto limit = ParseMemoryLimitSlurm(slurm_mem_per_node);
-		if (limit.IsValid()) {
-			return limit.GetIndex();
-		}
-	} else if (slurm_mem_per_cpu) {
-		auto mem_per_cpu = ParseMemoryLimitSlurm(slurm_mem_per_cpu);
-		if (mem_per_cpu.IsValid()) {
-			idx_t num_threads = GetSystemMaxThreads(fs);
-			return mem_per_cpu.GetIndex() * num_threads;
-		}
-	}
-
-	// Check cgroup memory limit
-	auto cgroup_memory_limit = CGroups::GetMemoryLimit(fs);
-	if (cgroup_memory_limit.IsValid()) {
-		return cgroup_memory_limit.GetIndex();
-	}
-#endif
-
-	// System memory detection
-	auto memory = FileSystem::GetAvailableMemory();
-	if (!memory.IsValid()) {
-		return DBConfigOptions().maximum_memory;
-	}
-	return memory.GetIndex();
-}
-
-idx_t DBConfig::ParseMemoryLimit(const string &arg) {
-	if (arg[0] == '-' || arg == "null" || arg == "none") {
-		// infinite
-		return NumericLimits<idx_t>::Maximum();
-	}
-	// split based on the number/non-number
-	idx_t idx = 0;
-	while (StringUtil::CharacterIsSpace(arg[idx])) {
-		idx++;
-	}
-	idx_t num_start = idx;
-	while ((arg[idx] >= '0' && arg[idx] <= '9') || arg[idx] == '.' || arg[idx] == 'e' || arg[idx] == 'E' ||
-	       arg[idx] == '-') {
-		idx++;
-	}
-	if (idx == num_start) {
-		throw ParserException("Memory limit must have a number (e.g. SET memory_limit=1GB");
-	}
-	string number = arg.substr(num_start, idx - num_start);
-
-	// try to parse the number
-	double limit = Cast::Operation<string_t, double>(string_t(number));
-
-	// now parse the memory limit unit (e.g. bytes, gb, etc)
-	while (StringUtil::CharacterIsSpace(arg[idx])) {
-		idx++;
-	}
-	idx_t start = idx;
-	while (idx < arg.size() && !StringUtil::CharacterIsSpace(arg[idx])) {
-		idx++;
-	}
-	if (limit < 0) {
-		// limit < 0, set limit to infinite
-		return (idx_t)-1;
-	}
-	string unit = StringUtil::Lower(arg.substr(start, idx - start));
-	idx_t multiplier;
-	if (unit == "byte" || unit == "bytes" || unit == "b") {
-		multiplier = 1;
-	} else if (unit == "kilobyte" || unit == "kilobytes" || unit == "kb" || unit == "k") {
-		multiplier = 1000LL;
-	} else if (unit == "megabyte" || unit == "megabytes" || unit == "mb" || unit == "m") {
-		multiplier = 1000LL * 1000LL;
-	} else if (unit == "gigabyte" || unit == "gigabytes" || unit == "gb" || unit == "g") {
-		multiplier = 1000LL * 1000LL * 1000LL;
-	} else if (unit == "terabyte" || unit == "terabytes" || unit == "tb" || unit == "t") {
-		multiplier = 1000LL * 1000LL * 1000LL * 1000LL;
-	} else if (unit == "kib") {
-		multiplier = 1024LL;
-	} else if (unit == "mib") {
-		multiplier = 1024LL * 1024LL;
-	} else if (unit == "gib") {
-		multiplier = 1024LL * 1024LL * 1024LL;
-	} else if (unit == "tib") {
-		multiplier = 1024LL * 1024LL * 1024LL * 1024LL;
-	} else {
-		throw ParserException("Unknown unit for memory_limit: '%s' (expected: KB, MB, GB, TB for 1000^i units or KiB, "
-		                      "MiB, GiB, TiB for 1024^i units)",
-		                      unit);
-	}
-	return LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
-}
-
-optional_idx DBConfig::ParseMemoryLimitSlurm(const string &arg) {
-	if (arg.empty()) {
-		return optional_idx();
-	}
-
-	string number_str = arg;
-	idx_t multiplier = 1000LL * 1000LL; // Default to MB if no unit specified
-
-	// Check for SLURM-style suffixes
-	if (arg.back() == 'K' || arg.back() == 'k') {
-		number_str = arg.substr(0, arg.size() - 1);
-		multiplier = 1000LL;
-	} else if (arg.back() == 'M' || arg.back() == 'm') {
-		number_str = arg.substr(0, arg.size() - 1);
-		multiplier = 1000LL * 1000LL;
-	} else if (arg.back() == 'G' || arg.back() == 'g') {
-		number_str = arg.substr(0, arg.size() - 1);
-		multiplier = 1000LL * 1000LL * 1000LL;
-	} else if (arg.back() == 'T' || arg.back() == 't') {
-		number_str = arg.substr(0, arg.size() - 1);
-		multiplier = 1000LL * 1000LL * 1000LL * 1000LL;
-	}
-
-	// Parse the number
-	double limit;
-	if (!TryCast::Operation<string_t, double>(string_t(number_str), limit)) {
-		return optional_idx();
-	}
-
-	if (limit < 0) {
-		return static_cast<idx_t>(NumericLimits<int64_t>::Maximum());
-	}
-	idx_t actual_limit = LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
-	if (actual_limit == NumericLimits<idx_t>::Maximum()) {
-		return static_cast<idx_t>(NumericLimits<int64_t>::Maximum());
-	}
-	return actual_limit;
-}
-
-// Right now we only really care about access mode when comparing DBConfigs
-bool DBConfigOptions::operator==(const DBConfigOptions &other) const {
-	return other.access_mode == access_mode && other.user_options == user_options;
-}
-
-bool DBConfig::operator==(const DBConfig &other) {
-	return other.options == options;
-}
-
-bool DBConfig::operator!=(const DBConfig &other) {
-	return !(other.options == options);
-}
-
-OrderType DBConfig::ResolveOrder(OrderType order_type) const {
-	if (order_type != OrderType::ORDER_DEFAULT) {
-		return order_type;
-	}
-	return options.default_order_type;
-}
-
-OrderByNullType DBConfig::ResolveNullOrder(OrderType order_type, OrderByNullType null_type) const {
-	if (null_type != OrderByNullType::ORDER_DEFAULT) {
-		return null_type;
-	}
-	switch (options.default_null_order) {
-	case DefaultOrderByNullType::NULLS_FIRST:
-		return OrderByNullType::NULLS_FIRST;
-	case DefaultOrderByNullType::NULLS_LAST:
-		return OrderByNullType::NULLS_LAST;
-	case DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC:
-		return order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_FIRST : OrderByNullType::NULLS_LAST;
-	case DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC:
-		return order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_LAST : OrderByNullType::NULLS_FIRST;
-	default:
-		throw InternalException("Unknown null order setting");
-	}
-}
-
-const string DBConfig::UserAgent() const {
-	auto user_agent = GetDefaultUserAgent();
-
-	if (!options.duckdb_api.empty()) {
-		user_agent += " " + options.duckdb_api;
-	}
-
-	if (!options.custom_user_agent.empty()) {
-		user_agent += " " + options.custom_user_agent;
-	}
-	return user_agent;
-}
-
-string DBConfig::SanitizeAllowedPath(const string &path) const {
-	auto path_sep = file_system->PathSeparator(path);
-	if (path_sep != "/") {
-		// allowed_directories/allowed_path always uses forward slashes regardless of the OS
-		return StringUtil::Replace(path, path_sep, "/");
-	}
-	return path;
-}
-
-void DBConfig::AddAllowedDirectory(const string &path) {
-	auto allowed_directory = SanitizeAllowedPath(path);
-	if (allowed_directory.empty()) {
-		throw InvalidInputException("Cannot provide an empty string for allowed_directory");
-	}
-	// ensure the directory ends with a path separator
-	if (!StringUtil::EndsWith(allowed_directory, "/")) {
-		allowed_directory += "/";
-	}
-	options.allowed_directories.insert(allowed_directory);
-}
-
-void DBConfig::AddAllowedPath(const string &path) {
-	auto allowed_path = SanitizeAllowedPath(path);
-	options.allowed_paths.insert(allowed_path);
-}
-
-bool DBConfig::CanAccessFile(const string &input_path, FileType type) {
-	if (options.enable_external_access) {
-		// all external access is allowed
-		return true;
-	}
-	string path = SanitizeAllowedPath(input_path);
-	if (options.allowed_paths.count(path) > 0) {
-		// path is explicitly allowed
-		return true;
-	}
-	if (options.allowed_directories.empty()) {
-		// no prefix directories specified
-		return false;
-	}
-	if (type == FileType::FILE_TYPE_DIR) {
-		// make sure directories end with a /
-		if (!StringUtil::EndsWith(path, "/")) {
-			path += "/";
-		}
-	}
-	auto start_bound = options.allowed_directories.lower_bound(path);
-	if (start_bound != options.allowed_directories.begin()) {
-		--start_bound;
-	}
-	auto end_bound = options.allowed_directories.upper_bound(path);
-
-	string prefix;
-	for (auto it = start_bound; it != end_bound; ++it) {
-		if (StringUtil::StartsWith(path, *it)) {
-			prefix = *it;
-			break;
-		}
-	}
-	if (prefix.empty()) {
-		// no common prefix found - path is not inside an allowed directory
-		return false;
-	}
-	D_ASSERT(StringUtil::EndsWith(prefix, "/"));
-	// path is inside an allowed directory - HOWEVER, we could still exit the allowed directory using ".."
-	// we check if we ever exit the allowed directory using ".." by looking at the path fragments
-	idx_t directory_level = 0;
-	idx_t current_pos = prefix.size();
-	for (; current_pos < path.size(); current_pos++) {
-		idx_t dir_begin = current_pos;
-		// find either the end of the path or the directory separator
-		for (; path[current_pos] != '/' && current_pos < path.size(); current_pos++) {
-		}
-		idx_t path_length = current_pos - dir_begin;
-		if (path_length == 2 && path[dir_begin] == '.' && path[dir_begin + 1] == '.') {
-			// go up a directory
-			if (directory_level == 0) {
-				// we cannot go up past the prefix
-				return false;
-			}
-			--directory_level;
-		} else if (path_length > 0) {
-			directory_level++;
-		}
-	}
-	return true;
-}
-
-SerializationCompatibility SerializationCompatibility::FromString(const string &input) {
-	if (input.empty()) {
-		throw InvalidInputException("Version string can not be empty");
-	}
-
-	auto serialization_version = GetSerializationVersion(input.c_str());
-	if (!serialization_version.IsValid()) {
-		auto candidates = GetSerializationCandidates();
-		throw InvalidInputException("The version string '%s' is not a valid DuckDB version, valid options are: %s",
-		                            input, StringUtil::Join(candidates, ", "));
-	}
-	SerializationCompatibility result;
-	result.duckdb_version = input;
-	result.serialization_version = serialization_version.GetIndex();
-	result.manually_set = true;
-	return result;
-}
-
-SerializationCompatibility SerializationCompatibility::Default() {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-	auto res = FromString("latest");
-	res.manually_set = false;
-	return res;
-#else
-#ifdef DUCKDB_LATEST_STORAGE
-	auto res = FromString("latest");
-	res.manually_set = false;
-	return res;
-#else
-	auto res = FromString("v0.10.2");
-	res.manually_set = false;
-	return res;
-#endif
-#endif
-}
-
-SerializationCompatibility SerializationCompatibility::Latest() {
-	auto res = FromString("latest");
-	res.manually_set = false;
-	return res;
-}
-
-bool SerializationCompatibility::Compare(idx_t property_version) const {
-	return property_version <= serialization_version;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/connection.cpp b/src/duckdb/src/main/connection.cpp
deleted file mode 100644
index 10dddcd4f..000000000
--- a/src/duckdb/src/main/connection.cpp
+++ /dev/null
@@ -1,369 +0,0 @@
-#include "duckdb/main/connection.hpp"
-
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/main/appender.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/main/relation/query_relation.hpp"
-#include "duckdb/main/relation/read_csv_relation.hpp"
-#include "duckdb/main/relation/table_function_relation.hpp"
-#include "duckdb/main/relation/table_relation.hpp"
-#include "duckdb/main/relation/value_relation.hpp"
-#include "duckdb/main/relation/view_relation.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-Connection::Connection(DatabaseInstance &database)
-    : context(make_shared_ptr<ClientContext>(database.shared_from_this())), warning_cb(nullptr) {
-	ConnectionManager::Get(database).AddConnection(*context);
-#ifdef DEBUG
-	EnableProfiling();
-	context->config.emit_profiler_output = false;
-#endif
-}
-
-Connection::Connection(DuckDB &database) : Connection(*database.instance) {
-	warning_cb = nullptr;
-}
-
-Connection::Connection(Connection &&other) noexcept {
-	std::swap(context, other.context);
-	std::swap(warning_cb, other.warning_cb);
-}
-
-Connection &Connection::operator=(Connection &&other) noexcept {
-	std::swap(context, other.context);
-	std::swap(warning_cb, other.warning_cb);
-	return *this;
-}
-
-Connection::~Connection() {
-	if (!context) {
-		return;
-	}
-	ConnectionManager::Get(*context->db).RemoveConnection(*context);
-}
-
-string Connection::GetProfilingInformation(ProfilerPrintFormat format) {
-	auto &profiler = QueryProfiler::Get(*context);
-	return profiler.ToString(format);
-}
-
-optional_ptr<ProfilingNode> Connection::GetProfilingTree() {
-	auto &client_config = ClientConfig::GetConfig(*context);
-	auto enable_profiler = client_config.enable_profiler;
-
-	if (!enable_profiler) {
-		throw Exception(ExceptionType::SETTINGS, "Profiling is not enabled for this connection");
-	}
-	auto &profiler = QueryProfiler::Get(*context);
-	return profiler.GetRoot();
-}
-
-void Connection::Interrupt() {
-	context->Interrupt();
-}
-
-void Connection::EnableProfiling() {
-	context->EnableProfiling();
-}
-
-void Connection::DisableProfiling() {
-	context->DisableProfiling();
-}
-
-void Connection::EnableQueryVerification() {
-	ClientConfig::GetConfig(*context).query_verification_enabled = true;
-}
-
-void Connection::DisableQueryVerification() {
-	ClientConfig::GetConfig(*context).query_verification_enabled = false;
-}
-
-void Connection::ForceParallelism() {
-	ClientConfig::GetConfig(*context).verify_parallelism = true;
-}
-
-unique_ptr<QueryResult> Connection::SendQuery(const string &query) {
-	return context->Query(query, true);
-}
-
-unique_ptr<MaterializedQueryResult> Connection::Query(const string &query) {
-	auto result = context->Query(query, false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
-}
-
-DUCKDB_API string Connection::GetSubstrait(const string &query) {
-	vector<Value> params;
-	params.emplace_back(query);
-	auto result = TableFunction("get_substrait", params)->Execute();
-	auto protobuf = result->FetchRaw()->GetValue(0, 0);
-	return protobuf.GetValueUnsafe<string_t>().GetString();
-}
-
-DUCKDB_API unique_ptr<QueryResult> Connection::FromSubstrait(const string &proto) {
-	vector<Value> params;
-	params.emplace_back(Value::BLOB_RAW(proto));
-	return TableFunction("from_substrait", params)->Execute();
-}
-
-DUCKDB_API string Connection::GetSubstraitJSON(const string &query) {
-	vector<Value> params;
-	params.emplace_back(query);
-	auto result = TableFunction("get_substrait_json", params)->Execute();
-	auto protobuf = result->FetchRaw()->GetValue(0, 0);
-	return protobuf.GetValueUnsafe<string_t>().GetString();
-}
-
-DUCKDB_API unique_ptr<QueryResult> Connection::FromSubstraitJSON(const string &json) {
-	vector<Value> params;
-	params.emplace_back(json);
-	return TableFunction("from_substrait_json", params)->Execute();
-}
-
-unique_ptr<MaterializedQueryResult> Connection::Query(unique_ptr<SQLStatement> statement) {
-	auto result = context->Query(std::move(statement), false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query, bool allow_stream_result) {
-	return context->PendingQuery(query, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	return context->PendingQuery(std::move(statement), allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query,
-                                                        case_insensitive_map_t<BoundParameterData> &named_values,
-                                                        bool allow_stream_result) {
-	return context->PendingQuery(query, named_values, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement,
-                                                        case_insensitive_map_t<BoundParameterData> &named_values,
-                                                        bool allow_stream_result) {
-	return context->PendingQuery(std::move(statement), named_values, allow_stream_result);
-}
-
-static case_insensitive_map_t<BoundParameterData> ConvertParamListToMap(vector<Value> &param_list) {
-	case_insensitive_map_t<BoundParameterData> named_values;
-	for (idx_t i = 0; i < param_list.size(); i++) {
-		auto &val = param_list[i];
-		named_values[std::to_string(i + 1)] = BoundParameterData(val);
-	}
-	return named_values;
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query, vector<Value> &values,
-                                                        bool allow_stream_result) {
-	auto named_params = ConvertParamListToMap(values);
-	return context->PendingQuery(query, named_params, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement, vector<Value> &values,
-                                                        bool allow_stream_result) {
-	auto named_params = ConvertParamListToMap(values);
-	return context->PendingQuery(std::move(statement), named_params, allow_stream_result);
-}
-
-unique_ptr<PreparedStatement> Connection::Prepare(const string &query) {
-	return context->Prepare(query);
-}
-
-unique_ptr<PreparedStatement> Connection::Prepare(unique_ptr<SQLStatement> statement) {
-	return context->Prepare(std::move(statement));
-}
-
-unique_ptr<QueryResult> Connection::QueryParamsRecursive(const string &query, vector<Value> &values) {
-	auto named_params = ConvertParamListToMap(values);
-	auto pending = PendingQuery(query, named_params, false);
-	if (pending->HasError()) {
-		return make_uniq<MaterializedQueryResult>(pending->GetErrorObject());
-	}
-	return pending->Execute();
-}
-
-unique_ptr<TableDescription> Connection::TableInfo(const string &database_name, const string &schema_name,
-                                                   const string &table_name) {
-	return context->TableInfo(database_name, schema_name, table_name);
-}
-
-unique_ptr<TableDescription> Connection::TableInfo(const string &schema_name, const string &table_name) {
-	return TableInfo(INVALID_CATALOG, schema_name, table_name);
-}
-
-unique_ptr<TableDescription> Connection::TableInfo(const string &table_name) {
-	return TableInfo(INVALID_CATALOG, DEFAULT_SCHEMA, table_name);
-}
-
-vector<unique_ptr<SQLStatement>> Connection::ExtractStatements(const string &query) {
-	return context->ParseStatements(query);
-}
-
-unique_ptr<LogicalOperator> Connection::ExtractPlan(const string &query) {
-	return context->ExtractPlan(query);
-}
-
-void Connection::Append(TableDescription &description, DataChunk &chunk) {
-	if (chunk.size() == 0) {
-		return;
-	}
-	ColumnDataCollection collection(Allocator::Get(*context), chunk.GetTypes());
-	collection.Append(chunk);
-	Append(description, collection);
-}
-
-void Connection::Append(TableDescription &description, ColumnDataCollection &collection) {
-	context->Append(description, collection);
-}
-
-shared_ptr<Relation> Connection::Table(const string &table_name) {
-	return Table(DEFAULT_SCHEMA, table_name);
-}
-
-shared_ptr<Relation> Connection::Table(const string &schema_name, const string &table_name) {
-	auto table_info = TableInfo(INVALID_CATALOG, schema_name, table_name);
-	if (!table_info) {
-		throw CatalogException("Table '%s' does not exist!", table_name);
-	}
-	return make_shared_ptr<TableRelation>(context, std::move(table_info));
-}
-
-shared_ptr<Relation> Connection::View(const string &tname) {
-	return View(DEFAULT_SCHEMA, tname);
-}
-
-shared_ptr<Relation> Connection::View(const string &schema_name, const string &table_name) {
-	return make_shared_ptr<ViewRelation>(context, schema_name, table_name);
-}
-
-shared_ptr<Relation> Connection::TableFunction(const string &fname) {
-	vector<Value> values;
-	named_parameter_map_t named_parameters;
-	return TableFunction(fname, values, named_parameters);
-}
-
-shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
-                                               const named_parameter_map_t &named_parameters) {
-	return make_shared_ptr<TableFunctionRelation>(context, fname, values, named_parameters);
-}
-
-shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values) {
-	return make_shared_ptr<TableFunctionRelation>(context, fname, values);
-}
-
-shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
-	vector<string> column_names;
-	return Values(values, column_names);
-}
-
-shared_ptr<Relation> Connection::Values(vector<vector<unique_ptr<ParsedExpression>>> &&expressions) {
-	vector<string> column_names;
-	return make_shared_ptr<ValueRelation>(context, std::move(expressions), column_names);
-}
-
-shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values, const vector<string> &column_names,
-                                        const string &alias) {
-	return make_shared_ptr<ValueRelation>(context, values, column_names, alias);
-}
-
-shared_ptr<Relation> Connection::Values(const string &values) {
-	vector<string> column_names;
-	return Values(values, column_names);
-}
-
-shared_ptr<Relation> Connection::Values(const string &values, const vector<string> &column_names, const string &alias) {
-	return make_shared_ptr<ValueRelation>(context, values, column_names, alias);
-}
-
-shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
-	named_parameter_map_t options;
-	return ReadCSV(csv_file, std::move(options));
-}
-
-shared_ptr<Relation> Connection::ReadCSV(const vector<string> &csv_input, named_parameter_map_t &&options) {
-	return make_shared_ptr<ReadCSVRelation>(context, csv_input, std::move(options));
-}
-
-shared_ptr<Relation> Connection::ReadCSV(const string &csv_input, named_parameter_map_t &&options) {
-	vector<string> csv_files = {csv_input};
-	return ReadCSV(csv_files, std::move(options));
-}
-
-shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<string> &columns) {
-	// parse columns
-	named_parameter_map_t options;
-	child_list_t<Value> column_list;
-	for (auto &column : columns) {
-		auto col_list = Parser::ParseColumnList(column, context->GetParserOptions());
-		if (col_list.LogicalColumnCount() != 1) {
-			throw ParserException("Expected a single column definition");
-		}
-		auto &col_def = col_list.GetColumnMutable(LogicalIndex(0));
-		column_list.push_back({col_def.GetName(), col_def.GetType().ToString()});
-	}
-	vector<string> files {csv_file};
-	return make_shared_ptr<ReadCSVRelation>(context, files, std::move(options));
-}
-
-shared_ptr<Relation> Connection::ReadParquet(const string &parquet_file, bool binary_as_string) {
-	vector<Value> params;
-	params.emplace_back(parquet_file);
-	named_parameter_map_t named_parameters({{"binary_as_string", Value::BOOLEAN(binary_as_string)}});
-	return TableFunction("parquet_scan", params, named_parameters)->Alias(parquet_file);
-}
-
-unordered_set<string> Connection::GetTableNames(const string &query) {
-	return context->GetTableNames(query);
-}
-
-shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const string &alias, const string &error) {
-	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), alias);
-}
-
-shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias,
-                                                   const string &query_p) {
-	return make_shared_ptr<QueryRelation>(context, std::move(select_stmt), alias, query_p);
-}
-
-void Connection::BeginTransaction() {
-	auto result = Query("BEGIN TRANSACTION");
-	if (result->HasError()) {
-		result->ThrowError();
-	}
-}
-
-void Connection::Commit() {
-	auto result = Query("COMMIT");
-	if (result->HasError()) {
-		result->ThrowError();
-	}
-}
-
-void Connection::Rollback() {
-	auto result = Query("ROLLBACK");
-	if (result->HasError()) {
-		result->ThrowError();
-	}
-}
-
-void Connection::SetAutoCommit(bool auto_commit) {
-	context->transaction.SetAutoCommit(auto_commit);
-}
-
-bool Connection::IsAutoCommit() {
-	return context->transaction.IsAutoCommit();
-}
-bool Connection::HasActiveTransaction() {
-	return context->transaction.HasActiveTransaction();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/connection_manager.cpp b/src/duckdb/src/main/connection_manager.cpp
deleted file mode 100644
index c0b53c6f4..000000000
--- a/src/duckdb/src/main/connection_manager.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/planner/extension_callback.hpp"
-
-namespace duckdb {
-
-ConnectionManager::ConnectionManager() {
-}
-
-void ConnectionManager::AddConnection(ClientContext &context) {
-	lock_guard<mutex> lock(connections_lock);
-	for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) {
-		callback->OnConnectionOpened(context);
-	}
-	connections[context] = weak_ptr<ClientContext>(context.shared_from_this());
-}
-
-void ConnectionManager::RemoveConnection(ClientContext &context) {
-	lock_guard<mutex> lock(connections_lock);
-	for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) {
-		callback->OnConnectionClosed(context);
-	}
-	connections.erase(context);
-}
-
-idx_t ConnectionManager::GetConnectionCount() const {
-	lock_guard<mutex> lock(connections_lock);
-	return connections.size();
-}
-
-vector<shared_ptr<ClientContext>> ConnectionManager::GetConnectionList() {
-	lock_guard<mutex> lock(connections_lock);
-	vector<shared_ptr<ClientContext>> result;
-	for (auto &it : connections) {
-		auto connection = it.second.lock();
-		if (!connection) {
-			connections.erase(it.first);
-			continue;
-		} else {
-			result.push_back(std::move(connection));
-		}
-	}
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/database.cpp b/src/duckdb/src/main/database.cpp
deleted file mode 100644
index 3bd387f84..000000000
--- a/src/duckdb/src/main/database.cpp
+++ /dev/null
@@ -1,529 +0,0 @@
-#include "duckdb/main/database.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/virtual_file_system.hpp"
-#include "duckdb/execution/index/index_type_set.hpp"
-#include "duckdb/execution/operator/helper/physical_set.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/database_file_opener.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/database_path_and_type.hpp"
-#include "duckdb/main/db_instance_cache.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/planner/collation_binding.hpp"
-#include "duckdb/planner/extension_callback.hpp"
-#include "duckdb/storage/object_cache.hpp"
-#include "duckdb/storage/standard_buffer_manager.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/main/capi/extension_api.hpp"
-#include "duckdb/storage/compression/empty_validity.hpp"
-
-#ifndef DUCKDB_NO_THREADS
-#include "duckdb/common/thread.hpp"
-#endif
-
-namespace duckdb {
-
-DBConfig::DBConfig() {
-	compression_functions = make_uniq<CompressionFunctionSet>();
-	encoding_functions = make_uniq<EncodingFunctionSet>();
-	encoding_functions->Initialize(*this);
-	cast_functions = make_uniq<CastFunctionSet>(*this);
-	collation_bindings = make_uniq<CollationBinding>();
-	index_types = make_uniq<IndexTypeSet>();
-	error_manager = make_uniq<ErrorManager>();
-	secret_manager = make_uniq<SecretManager>();
-}
-
-DBConfig::DBConfig(bool read_only) : DBConfig::DBConfig() {
-	if (read_only) {
-		options.access_mode = AccessMode::READ_ONLY;
-	}
-}
-
-DBConfig::DBConfig(const case_insensitive_map_t<Value> &config_dict, bool read_only) : DBConfig::DBConfig(read_only) {
-	SetOptionsByName(config_dict);
-}
-
-DBConfig::~DBConfig() {
-}
-
-DatabaseInstance::DatabaseInstance() {
-	config.is_user_config = false;
-	create_api_v1 = nullptr;
-}
-
-DatabaseInstance::~DatabaseInstance() {
-	// destroy all attached databases
-	GetDatabaseManager().ResetDatabases(scheduler);
-	// destroy child elements
-	connection_manager.reset();
-	object_cache.reset();
-	scheduler.reset();
-	db_manager.reset();
-	buffer_manager.reset();
-	// flush allocations and disable the background thread
-	if (Allocator::SupportsFlush()) {
-		Allocator::FlushAll();
-	}
-	Allocator::SetBackgroundThreads(false);
-	// after all destruction is complete clear the cache entry
-	db_cache_entry.reset();
-}
-
-BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
-	return db.GetBufferManager();
-}
-
-const BufferManager &BufferManager::GetBufferManager(const DatabaseInstance &db) {
-	return db.GetBufferManager();
-}
-
-BufferManager &BufferManager::GetBufferManager(AttachedDatabase &db) {
-	return BufferManager::GetBufferManager(db.GetDatabase());
-}
-
-DatabaseInstance &DatabaseInstance::GetDatabase(ClientContext &context) {
-	return *context.db;
-}
-
-const DatabaseInstance &DatabaseInstance::GetDatabase(const ClientContext &context) {
-	return *context.db;
-}
-
-void DatabaseInstance::SetDatabaseCacheEntry(shared_ptr<DatabaseCacheEntry> entry) {
-	db_cache_entry = std::move(entry);
-}
-
-DatabaseManager &DatabaseInstance::GetDatabaseManager() {
-	if (!db_manager) {
-		throw InternalException("Missing DB manager");
-	}
-	return *db_manager;
-}
-
-Catalog &Catalog::GetSystemCatalog(DatabaseInstance &db) {
-	return db.GetDatabaseManager().GetSystemCatalog();
-}
-
-Catalog &Catalog::GetCatalog(AttachedDatabase &db) {
-	return db.GetCatalog();
-}
-
-FileSystem &FileSystem::GetFileSystem(DatabaseInstance &db) {
-	return db.GetFileSystem();
-}
-
-FileSystem &FileSystem::Get(AttachedDatabase &db) {
-	return FileSystem::GetFileSystem(db.GetDatabase());
-}
-
-DBConfig &DBConfig::GetConfig(DatabaseInstance &db) {
-	return db.config;
-}
-
-ClientConfig &ClientConfig::GetConfig(ClientContext &context) {
-	return context.config;
-}
-
-DBConfig &DBConfig::Get(AttachedDatabase &db) {
-	return DBConfig::GetConfig(db.GetDatabase());
-}
-
-const DBConfig &DBConfig::GetConfig(const DatabaseInstance &db) {
-	return db.config;
-}
-
-const ClientConfig &ClientConfig::GetConfig(const ClientContext &context) {
-	return context.config;
-}
-
-TransactionManager &TransactionManager::Get(AttachedDatabase &db) {
-	return db.GetTransactionManager();
-}
-
-ConnectionManager &ConnectionManager::Get(DatabaseInstance &db) {
-	return db.GetConnectionManager();
-}
-
-ConnectionManager &ConnectionManager::Get(ClientContext &context) {
-	return ConnectionManager::Get(DatabaseInstance::GetDatabase(context));
-}
-
-unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(ClientContext &context, const AttachInfo &info,
-                                                                      const AttachOptions &options) {
-	unique_ptr<AttachedDatabase> attached_database;
-	auto &catalog = Catalog::GetSystemCatalog(*this);
-
-	if (!options.db_type.empty()) {
-		// Find the storage extension for this database file.
-		auto extension_name = ExtensionHelper::ApplyExtensionAlias(options.db_type);
-		auto entry = config.storage_extensions.find(extension_name);
-		if (entry == config.storage_extensions.end()) {
-			throw BinderException("Unrecognized storage type \"%s\"", options.db_type);
-		}
-
-		if (entry->second->attach != nullptr && entry->second->create_transaction_manager != nullptr) {
-			// Use the storage extension to create the initial database.
-			attached_database =
-			    make_uniq<AttachedDatabase>(*this, catalog, *entry->second, context, info.name, info, options);
-			return attached_database;
-		}
-
-		attached_database = make_uniq<AttachedDatabase>(*this, catalog, info.name, info.path, options);
-		return attached_database;
-	}
-
-	// An empty db_type defaults to a duckdb database file.
-	attached_database = make_uniq<AttachedDatabase>(*this, catalog, info.name, info.path, options);
-	return attached_database;
-}
-
-void DatabaseInstance::CreateMainDatabase() {
-	AttachInfo info;
-	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path, GetFileSystem());
-	info.path = config.options.database_path;
-
-	optional_ptr<AttachedDatabase> initial_database;
-	{
-		Connection con(*this);
-		con.BeginTransaction();
-		AttachOptions options(config.options);
-		initial_database = db_manager->AttachDatabase(*con.context, info, options);
-		con.Commit();
-	}
-
-	initial_database->SetInitialDatabase();
-	initial_database->Initialize();
-}
-
-static void ThrowExtensionSetUnrecognizedOptions(const case_insensitive_map_t<Value> &unrecognized_options) {
-	D_ASSERT(!unrecognized_options.empty());
-
-	vector<string> options;
-	for (auto &kv : unrecognized_options) {
-		options.push_back(kv.first);
-	}
-	auto concatenated = StringUtil::Join(options, ", ");
-	throw InvalidInputException("The following options were not recognized: " + concatenated);
-}
-
-void DatabaseInstance::LoadExtensionSettings() {
-	auto &unrecognized_options = config.options.unrecognized_options;
-
-	if (config.options.autoload_known_extensions) {
-		if (unrecognized_options.empty()) {
-			// Nothing to do
-			return;
-		}
-
-		Connection con(*this);
-		con.BeginTransaction();
-
-		vector<string> extension_options;
-		for (auto &option : unrecognized_options) {
-			auto &name = option.first;
-			auto &value = option.second;
-
-			auto extension_name = ExtensionHelper::FindExtensionInEntries(name, EXTENSION_SETTINGS);
-			if (extension_name.empty()) {
-				continue;
-			}
-			if (!ExtensionHelper::TryAutoLoadExtension(*this, extension_name)) {
-				throw InvalidInputException(
-				    "To set the %s setting, the %s extension needs to be loaded. But it could not be autoloaded.", name,
-				    extension_name);
-			}
-			auto it = config.extension_parameters.find(name);
-			if (it == config.extension_parameters.end()) {
-				throw InternalException("Extension %s did not provide the '%s' config setting", extension_name, name);
-			}
-			auto &context = *con.context;
-			PhysicalSet::SetExtensionVariable(context, it->second, name, SetScope::GLOBAL, value);
-			extension_options.push_back(name);
-		}
-
-		for (auto &option : extension_options) {
-			unrecognized_options.erase(option);
-		}
-		con.Commit();
-	}
-	if (!unrecognized_options.empty()) {
-		ThrowExtensionSetUnrecognizedOptions(unrecognized_options);
-	}
-}
-
-static duckdb_ext_api_v1 CreateAPIv1Wrapper() {
-	return CreateAPIv1();
-}
-
-void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_config) {
-	DBConfig default_config;
-	DBConfig *config_ptr = &default_config;
-	if (user_config) {
-		config_ptr = user_config;
-	}
-
-	Configure(*config_ptr, database_path);
-
-	create_api_v1 = CreateAPIv1Wrapper;
-
-	db_file_system = make_uniq<DatabaseFileSystem>(*this);
-	db_manager = make_uniq<DatabaseManager>(*this);
-	if (config.buffer_manager) {
-		buffer_manager = config.buffer_manager;
-	} else {
-		buffer_manager = make_uniq<StandardBufferManager>(*this, config.options.temporary_directory);
-	}
-	scheduler = make_uniq<TaskScheduler>(*this);
-	object_cache = make_uniq<ObjectCache>();
-	connection_manager = make_uniq<ConnectionManager>();
-
-	// initialize the secret manager
-	config.secret_manager->Initialize(*this);
-
-	// resolve the type of teh database we are opening
-	auto &fs = FileSystem::GetFileSystem(*this);
-	DBPathAndType::ResolveDatabaseType(fs, config.options.database_path, config.options.database_type);
-
-	// initialize the system catalog
-	db_manager->InitializeSystemCatalog();
-
-	if (!config.options.database_type.empty()) {
-		// if we are opening an extension database - load the extension
-		if (!config.file_system) {
-			throw InternalException("No file system!?");
-		}
-		ExtensionHelper::LoadExternalExtension(*this, *config.file_system, config.options.database_type);
-	}
-
-	LoadExtensionSettings();
-
-	if (!db_manager->HasDefaultDatabase()) {
-		CreateMainDatabase();
-	}
-
-	// only increase thread count after storage init because we get races on catalog otherwise
-	scheduler->SetThreads(config.options.maximum_threads, config.options.external_threads);
-	scheduler->RelaunchThreads();
-}
-
-DuckDB::DuckDB(const char *path, DBConfig *new_config) : instance(make_shared_ptr<DatabaseInstance>()) {
-	instance->Initialize(path, new_config);
-	if (instance->config.options.load_extensions) {
-		ExtensionHelper::LoadAllExtensions(*this);
-	}
-}
-
-DuckDB::DuckDB(const string &path, DBConfig *config) : DuckDB(path.c_str(), config) {
-}
-
-DuckDB::DuckDB(DatabaseInstance &instance_p) : instance(instance_p.shared_from_this()) {
-}
-
-DuckDB::~DuckDB() {
-}
-
-SecretManager &DatabaseInstance::GetSecretManager() {
-	return *config.secret_manager;
-}
-
-BufferManager &DatabaseInstance::GetBufferManager() {
-	return *buffer_manager;
-}
-
-const BufferManager &DatabaseInstance::GetBufferManager() const {
-	return *buffer_manager;
-}
-
-BufferPool &DatabaseInstance::GetBufferPool() const {
-	return *config.buffer_pool;
-}
-
-DatabaseManager &DatabaseManager::Get(DatabaseInstance &db) {
-	return db.GetDatabaseManager();
-}
-
-DatabaseManager &DatabaseManager::Get(ClientContext &db) {
-	return DatabaseManager::Get(*db.db);
-}
-
-TaskScheduler &DatabaseInstance::GetScheduler() {
-	return *scheduler;
-}
-
-ObjectCache &DatabaseInstance::GetObjectCache() {
-	return *object_cache;
-}
-
-FileSystem &DatabaseInstance::GetFileSystem() {
-	return *db_file_system;
-}
-
-ConnectionManager &DatabaseInstance::GetConnectionManager() {
-	return *connection_manager;
-}
-
-FileSystem &DuckDB::GetFileSystem() {
-	return instance->GetFileSystem();
-}
-
-Allocator &Allocator::Get(ClientContext &context) {
-	return Allocator::Get(*context.db);
-}
-
-Allocator &Allocator::Get(DatabaseInstance &db) {
-	return *db.config.allocator;
-}
-
-Allocator &Allocator::Get(AttachedDatabase &db) {
-	return Allocator::Get(db.GetDatabase());
-}
-
-void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path) {
-	config.options = new_config.options;
-
-	if (config.options.duckdb_api.empty()) {
-		config.SetOptionByName("duckdb_api", "cpp");
-	}
-
-	if (database_path) {
-		config.options.database_path = database_path;
-	} else {
-		config.options.database_path.clear();
-	}
-
-	if (new_config.options.temporary_directory.empty()) {
-		config.SetDefaultTempDirectory();
-	}
-
-	if (config.options.access_mode == AccessMode::UNDEFINED) {
-		config.options.access_mode = AccessMode::READ_WRITE;
-	}
-	config.extension_parameters = new_config.extension_parameters;
-	if (new_config.file_system) {
-		config.file_system = std::move(new_config.file_system);
-	} else {
-		config.file_system = make_uniq<VirtualFileSystem>();
-	}
-	if (database_path && !config.options.enable_external_access) {
-		config.AddAllowedPath(database_path);
-		config.AddAllowedPath(database_path + string(".wal"));
-		if (!config.options.temporary_directory.empty()) {
-			config.AddAllowedDirectory(config.options.temporary_directory);
-		}
-	}
-	if (new_config.secret_manager) {
-		config.secret_manager = std::move(new_config.secret_manager);
-	}
-	if (config.options.maximum_memory == DConstants::INVALID_INDEX) {
-		config.SetDefaultMaxMemory();
-	}
-	if (new_config.options.maximum_threads == DConstants::INVALID_INDEX) {
-		config.options.maximum_threads = config.GetSystemMaxThreads(*config.file_system);
-	}
-	config.allocator = std::move(new_config.allocator);
-	if (!config.allocator) {
-		config.allocator = make_uniq<Allocator>();
-	}
-	config.replacement_scans = std::move(new_config.replacement_scans);
-	config.parser_extensions = std::move(new_config.parser_extensions);
-	config.error_manager = std::move(new_config.error_manager);
-	if (!config.error_manager) {
-		config.error_manager = make_uniq<ErrorManager>();
-	}
-	if (!config.default_allocator) {
-		config.default_allocator = Allocator::DefaultAllocatorReference();
-	}
-	if (new_config.buffer_pool) {
-		config.buffer_pool = std::move(new_config.buffer_pool);
-	} else {
-		config.buffer_pool = make_shared_ptr<BufferPool>(config.options.maximum_memory,
-		                                                 config.options.buffer_manager_track_eviction_timestamps,
-		                                                 config.options.allocator_bulk_deallocation_flush_threshold);
-	}
-}
-
-DBConfig &DBConfig::GetConfig(ClientContext &context) {
-	return context.db->config;
-}
-
-const DBConfig &DBConfig::GetConfig(const ClientContext &context) {
-	return context.db->config;
-}
-
-idx_t DatabaseInstance::NumberOfThreads() {
-	return NumericCast<idx_t>(scheduler->NumberOfThreads());
-}
-
-const unordered_map<string, ExtensionInfo> &DatabaseInstance::GetExtensions() {
-	return loaded_extensions_info;
-}
-
-void DatabaseInstance::AddExtensionInfo(const string &name, const ExtensionLoadedInfo &info) {
-	loaded_extensions_info[name].load_info = make_uniq<ExtensionLoadedInfo>(info);
-}
-
-idx_t DuckDB::NumberOfThreads() {
-	return instance->NumberOfThreads();
-}
-
-bool DatabaseInstance::ExtensionIsLoaded(const std::string &name) {
-	auto extension_name = ExtensionHelper::GetExtensionName(name);
-	auto it = loaded_extensions_info.find(extension_name);
-	return it != loaded_extensions_info.end() && it->second.is_loaded;
-}
-
-bool DuckDB::ExtensionIsLoaded(const std::string &name) {
-	return instance->ExtensionIsLoaded(name);
-}
-
-void DatabaseInstance::SetExtensionLoaded(const string &name, ExtensionInstallInfo &install_info) {
-	auto extension_name = ExtensionHelper::GetExtensionName(name);
-	loaded_extensions_info[extension_name].is_loaded = true;
-	loaded_extensions_info[extension_name].install_info = make_uniq<ExtensionInstallInfo>(install_info);
-
-	auto &callbacks = DBConfig::GetConfig(*this).extension_callbacks;
-	for (auto &callback : callbacks) {
-		callback->OnExtensionLoaded(*this, name);
-	}
-}
-
-SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) const {
-	// check the session values
-	auto &db_config = DBConfig::GetConfig(*this);
-	const auto &global_config_map = db_config.options.set_variables;
-
-	auto global_value = global_config_map.find(key);
-	bool found_global_value = global_value != global_config_map.end();
-	if (!found_global_value) {
-		return SettingLookupResult();
-	}
-	result = global_value->second;
-	return SettingLookupResult(SettingScope::GLOBAL);
-}
-
-ValidChecker &DatabaseInstance::GetValidChecker() {
-	return db_validity;
-}
-
-const duckdb_ext_api_v1 DatabaseInstance::GetExtensionAPIV1() {
-	D_ASSERT(create_api_v1);
-	return create_api_v1();
-}
-
-ValidChecker &ValidChecker::Get(DatabaseInstance &db) {
-	return db.GetValidChecker();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/database_manager.cpp b/src/duckdb/src/main/database_manager.cpp
deleted file mode 100644
index b20394027..000000000
--- a/src/duckdb/src/main/database_manager.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-#include "duckdb/main/database_manager.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_path_and_type.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-
-namespace duckdb {
-
-DatabaseManager::DatabaseManager(DatabaseInstance &db) : next_oid(0), current_query_number(1) {
-	system = make_uniq<AttachedDatabase>(db);
-	databases = make_uniq<CatalogSet>(system->GetCatalog());
-}
-
-DatabaseManager::~DatabaseManager() {
-}
-
-DatabaseManager &DatabaseManager::Get(AttachedDatabase &db) {
-	return DatabaseManager::Get(db.GetDatabase());
-}
-
-void DatabaseManager::InitializeSystemCatalog() {
-	// The SYSTEM_DATABASE has no persistent storage.
-	system->Initialize();
-}
-
-optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &context, const string &name) {
-	if (StringUtil::Lower(name) == TEMP_CATALOG) {
-		return context.client_data->temporary_objects.get();
-	}
-	return reinterpret_cast<AttachedDatabase *>(databases->GetEntry(context, name).get());
-}
-
-optional_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, const AttachInfo &info,
-                                                               const AttachOptions &options) {
-	if (AttachedDatabase::NameIsReserved(info.name)) {
-		throw BinderException("Attached database name \"%s\" cannot be used because it is a reserved name", info.name);
-	}
-	// now create the attached database
-	auto &db = DatabaseInstance::GetDatabase(context);
-	auto attached_db = db.CreateAttachedDatabase(context, info, options);
-
-	if (options.db_type.empty()) {
-		InsertDatabasePath(context, info.path, attached_db->name);
-	}
-
-	const auto name = attached_db->GetName();
-	attached_db->oid = NextOid();
-	LogicalDependencyList dependencies;
-	if (default_database.empty()) {
-		default_database = name;
-	}
-
-	// and add it to the databases catalog set
-	if (!databases->CreateEntry(context, name, std::move(attached_db), dependencies)) {
-		throw BinderException("Failed to attach database: database with name \"%s\" already exists", name);
-	}
-
-	return GetDatabase(context, name);
-}
-
-void DatabaseManager::DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found) {
-	if (GetDefaultDatabase(context) == name) {
-		throw BinderException("Cannot detach database \"%s\" because it is the default database. Select a different "
-		                      "database using `USE` to allow detaching this database",
-		                      name);
-	}
-
-	if (!databases->DropEntry(context, name, false, true)) {
-		if (if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
-			throw BinderException("Failed to detach database with name \"%s\": database not found", name);
-		}
-	}
-}
-
-optional_ptr<AttachedDatabase> DatabaseManager::GetDatabaseFromPath(ClientContext &context, const string &path) {
-	auto database_list = GetDatabases(context);
-	for (auto &db_ref : database_list) {
-		auto &db = db_ref.get();
-		if (db.IsSystem()) {
-			continue;
-		}
-		auto &catalog = Catalog::GetCatalog(db);
-		if (catalog.InMemory()) {
-			continue;
-		}
-		auto db_path = catalog.GetDBPath();
-		if (StringUtil::CIEquals(path, db_path)) {
-			return &db;
-		}
-	}
-	return nullptr;
-}
-
-void DatabaseManager::CheckPathConflict(ClientContext &context, const string &path) {
-	// ensure that we did not already attach a database with the same path
-	bool path_exists;
-	{
-		lock_guard<mutex> path_lock(db_paths_lock);
-		path_exists = db_paths.find(path) != db_paths.end();
-	}
-	if (path_exists) {
-		// check that the database is actually still attached
-		auto entry = GetDatabaseFromPath(context, path);
-		if (entry) {
-			throw BinderException("Unique file handle conflict: Database \"%s\" is already attached with path \"%s\", ",
-			                      entry->name, path);
-		}
-	}
-}
-
-void DatabaseManager::InsertDatabasePath(ClientContext &context, const string &path, const string &name) {
-	if (path.empty() || path == IN_MEMORY_PATH) {
-		return;
-	}
-
-	CheckPathConflict(context, path);
-	lock_guard<mutex> path_lock(db_paths_lock);
-	db_paths.insert(path);
-}
-
-void DatabaseManager::EraseDatabasePath(const string &path) {
-	if (path.empty() || path == IN_MEMORY_PATH) {
-		return;
-	}
-	lock_guard<mutex> path_lock(db_paths_lock);
-	auto path_it = db_paths.find(path);
-	if (path_it != db_paths.end()) {
-		db_paths.erase(path_it);
-	}
-}
-
-vector<string> DatabaseManager::GetAttachedDatabasePaths() {
-	lock_guard<mutex> path_lock(db_paths_lock);
-	vector<string> paths;
-	for (auto &path : db_paths) {
-		paths.push_back(path);
-	}
-	return paths;
-}
-
-void DatabaseManager::GetDatabaseType(ClientContext &context, AttachInfo &info, const DBConfig &config,
-                                      AttachOptions &options) {
-
-	// Test if the database is a DuckDB database file.
-	if (StringUtil::CIEquals(options.db_type, "DUCKDB")) {
-		options.db_type = "";
-		return;
-	}
-
-	// Try to extract the database type from the path.
-	if (options.db_type.empty()) {
-		CheckPathConflict(context, info.path);
-
-		auto &fs = FileSystem::GetFileSystem(context);
-		DBPathAndType::CheckMagicBytes(fs, info.path, options.db_type);
-	}
-
-	// If we are loading a database type from an extension, then we need to check if that extension is loaded.
-	if (!options.db_type.empty()) {
-		if (!Catalog::TryAutoLoad(context, options.db_type)) {
-			// FIXME: Here it might be preferable to use an AutoLoadOrThrow kind of function
-			// so that either there will be success or a message to throw, and load will be
-			// attempted only once respecting the auto-loading options
-			ExtensionHelper::LoadExternalExtension(context, options.db_type);
-		}
-		return;
-	}
-}
-
-const string &DatabaseManager::GetDefaultDatabase(ClientContext &context) {
-	auto &config = ClientData::Get(context);
-	auto &default_entry = config.catalog_search_path->GetDefault();
-	if (IsInvalidCatalog(default_entry.catalog)) {
-		auto &result = DatabaseManager::Get(context).default_database;
-		if (result.empty()) {
-			throw InternalException("Calling DatabaseManager::GetDefaultDatabase with no default database set");
-		}
-		return result;
-	}
-	return default_entry.catalog;
-}
-
-// LCOV_EXCL_START
-void DatabaseManager::SetDefaultDatabase(ClientContext &context, const string &new_value) {
-	auto db_entry = GetDatabase(context, new_value);
-
-	if (!db_entry) {
-		throw InternalException("Database \"%s\" not found", new_value);
-	} else if (db_entry->IsTemporary()) {
-		throw InternalException("Cannot set the default database to a temporary database");
-	} else if (db_entry->IsSystem()) {
-		throw InternalException("Cannot set the default database to a system database");
-	}
-
-	default_database = new_value;
-}
-// LCOV_EXCL_STOP
-
-vector<reference<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext &context) {
-	vector<reference<AttachedDatabase>> result;
-	databases->Scan(context, [&](CatalogEntry &entry) { result.push_back(entry.Cast<AttachedDatabase>()); });
-	result.push_back(*system);
-	result.push_back(*context.client_data->temporary_objects);
-	return result;
-}
-
-void DatabaseManager::ResetDatabases(unique_ptr<TaskScheduler> &scheduler) {
-	vector<reference<AttachedDatabase>> result;
-	databases->Scan([&](CatalogEntry &entry) { result.push_back(entry.Cast<AttachedDatabase>()); });
-	for (auto &database : result) {
-		database.get().Close();
-	}
-	scheduler.reset();
-	databases.reset();
-}
-
-Catalog &DatabaseManager::GetSystemCatalog() {
-	D_ASSERT(system);
-	return system->GetCatalog();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/database_path_and_type.cpp b/src/duckdb/src/main/database_path_and_type.cpp
deleted file mode 100644
index a231b4e27..000000000
--- a/src/duckdb/src/main/database_path_and_type.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/main/database_path_and_type.hpp"
-
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/storage/magic_bytes.hpp"
-
-namespace duckdb {
-
-void DBPathAndType::ExtractExtensionPrefix(string &path, string &db_type) {
-	auto extension = ExtensionHelper::ExtractExtensionPrefixFromPath(path);
-	if (!extension.empty()) {
-		// path is prefixed with an extension - remove the first occurence of it
-		path = path.substr(extension.length() + 1);
-		db_type = ExtensionHelper::ApplyExtensionAlias(extension);
-	}
-}
-
-void DBPathAndType::CheckMagicBytes(FileSystem &fs, string &path, string &db_type) {
-	// if there isn't - check the magic bytes of the file (if any)
-	auto file_type = MagicBytes::CheckMagicBytes(fs, path);
-	if (file_type == DataFileType::SQLITE_FILE) {
-		db_type = "sqlite";
-	} else {
-		db_type = "";
-	}
-}
-
-void DBPathAndType::ResolveDatabaseType(FileSystem &fs, string &path, string &db_type) {
-	if (!db_type.empty()) {
-		// database type specified explicitly - no need to check
-		return;
-	}
-	// check for an extension prefix
-	ExtractExtensionPrefix(path, db_type);
-	if (!db_type.empty()) {
-		// extension prefix was provided (e.g. sqlite:/path/to/file.db) - we are done
-		return;
-	}
-	// check database type by reading the magic bytes of a file
-	DBPathAndType::CheckMagicBytes(fs, path, db_type);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/db_instance_cache.cpp b/src/duckdb/src/main/db_instance_cache.cpp
deleted file mode 100644
index 062765b04..000000000
--- a/src/duckdb/src/main/db_instance_cache.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include "duckdb/main/db_instance_cache.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-namespace duckdb {
-
-DatabaseCacheEntry::DatabaseCacheEntry(const shared_ptr<DuckDB> &database_p) : database(database_p) {
-}
-
-DatabaseCacheEntry::~DatabaseCacheEntry() {
-}
-
-string GetDBAbsolutePath(const string &database_p, FileSystem &fs) {
-	auto database = FileSystem::ExpandPath(database_p, nullptr);
-	if (database.empty()) {
-		return IN_MEMORY_PATH;
-	}
-	if (database.rfind(IN_MEMORY_PATH, 0) == 0) {
-		// this is a memory db, just return it.
-		return database;
-	}
-	if (!ExtensionHelper::ExtractExtensionPrefixFromPath(database).empty()) {
-		// this database path is handled by a replacement open and is not a file path
-		return database;
-	}
-	if (fs.IsPathAbsolute(database)) {
-		return fs.NormalizeAbsolutePath(database);
-	}
-	return fs.NormalizeAbsolutePath(fs.JoinPath(FileSystem::GetWorkingDirectory(), database));
-}
-
-shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {
-	auto local_fs = FileSystem::CreateLocal();
-	auto abs_database_path = GetDBAbsolutePath(database, *local_fs);
-	auto entry = db_instances.find(abs_database_path);
-	if (entry == db_instances.end()) {
-		// path does not exist in the list yet - no cache entry
-		return nullptr;
-	}
-	auto cache_entry = entry->second.lock();
-	if (!cache_entry) {
-		// cache entry does not exist anymore - clean it up
-		db_instances.erase(entry);
-		return nullptr;
-	}
-	// cache entry exists - check if the actual database still exists
-	auto db_instance = cache_entry->database.lock();
-	if (!db_instance) {
-		// if the database does not exist, but the cache entry still exists, the database is being shut down
-		// we need to wait until the database is fully shut down to safely proceed
-		// we do this here using a busy spin
-		while (cache_entry) {
-			// clear our cache entry
-			cache_entry.reset();
-			// try to lock it again
-			cache_entry = entry->second.lock();
-		}
-		// the cache entry has now been deleted - clear it from the set of database instances and return
-		db_instances.erase(entry);
-		return nullptr;
-	}
-	// the database instance exists - check that the config matches
-	if (db_instance->instance->config != config) {
-		throw duckdb::ConnectionException(
-		    "Can't open a connection to same database file with a different configuration "
-		    "than existing connections");
-	}
-	return db_instance;
-}
-
-shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DBConfig &config) {
-	lock_guard<mutex> l(cache_lock);
-	return GetInstanceInternal(database, config);
-}
-
-shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &database, DBConfig &config,
-                                                           bool cache_instance,
-                                                           const std::function<void(DuckDB &)> &on_create) {
-	string abs_database_path;
-	if (config.file_system) {
-		abs_database_path = GetDBAbsolutePath(database, *config.file_system);
-	} else {
-		auto tmp_fs = FileSystem::CreateLocal();
-		abs_database_path = GetDBAbsolutePath(database, *tmp_fs);
-	}
-	if (db_instances.find(abs_database_path) != db_instances.end()) {
-		throw duckdb::Exception(ExceptionType::CONNECTION,
-		                        "Instance with path: " + abs_database_path + " already exists.");
-	}
-	// Creates new instance
-	string instance_path = abs_database_path;
-	if (abs_database_path.rfind(IN_MEMORY_PATH, 0) == 0) {
-		instance_path = IN_MEMORY_PATH;
-	}
-	auto db_instance = make_shared_ptr<DuckDB>(instance_path, &config);
-	if (on_create) {
-		on_create(*db_instance);
-	}
-	if (cache_instance) {
-		// create the cache entry and attach it to the database
-		auto cache_entry = make_shared_ptr<DatabaseCacheEntry>(db_instance);
-		db_instance->instance->SetDatabaseCacheEntry(cache_entry);
-
-		// cache the entry in the db_instances map
-		db_instances[abs_database_path] = cache_entry;
-	}
-	return db_instance;
-}
-
-shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBConfig &config, bool cache_instance,
-                                                   const std::function<void(DuckDB &)> &on_create) {
-	lock_guard<mutex> l(cache_lock);
-	return CreateInstanceInternal(database, config, cache_instance, on_create);
-}
-
-shared_ptr<DuckDB> DBInstanceCache::GetOrCreateInstance(const string &database, DBConfig &config_dict,
-                                                        bool cache_instance,
-                                                        const std::function<void(DuckDB &)> &on_create) {
-	lock_guard<mutex> l(cache_lock);
-	if (cache_instance) {
-		auto instance = GetInstanceInternal(database, config_dict);
-		if (instance) {
-			return instance;
-		}
-	}
-	return CreateInstanceInternal(database, config_dict, cache_instance, on_create);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/error_manager.cpp b/src/duckdb/src/main/error_manager.cpp
deleted file mode 100644
index 4ec024c13..000000000
--- a/src/duckdb/src/main/error_manager.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/main/config.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/common/exception/list.hpp"
-
-namespace duckdb {
-
-struct DefaultError {
-	ErrorType type;
-	const char *error;
-};
-
-static const DefaultError internal_errors[] = {
-    {ErrorType::UNSIGNED_EXTENSION,
-     "Extension \"%s\" could not be loaded because its signature is either missing or invalid and unsigned extensions "
-     "are disabled by configuration (allow_unsigned_extensions)"},
-    {ErrorType::INVALIDATED_TRANSACTION, "Current transaction is aborted (please ROLLBACK)"},
-    {ErrorType::INVALIDATED_DATABASE, "Failed: database has been invalidated because of a previous fatal error. The "
-                                      "database must be restarted prior to being used again.\nOriginal error: \"%s\""},
-    {ErrorType::INVALID, nullptr}};
-
-string ErrorManager::FormatExceptionRecursive(ErrorType error_type, vector<ExceptionFormatValue> &values) {
-	if (error_type >= ErrorType::ERROR_COUNT) {
-		throw InternalException("Invalid error type passed to ErrorManager::FormatError");
-	}
-	auto entry = custom_errors.find(error_type);
-	string error;
-	if (entry == custom_errors.end()) {
-		// error was not overwritten
-		error = internal_errors[int(error_type)].error;
-	} else {
-		// error was overwritten
-		error = entry->second;
-	}
-	return ExceptionFormatValue::Format(error, values);
-}
-
-InvalidInputException ErrorManager::InvalidUnicodeError(const string &input, const string &context) {
-	UnicodeInvalidReason reason;
-	size_t pos;
-	auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(input.c_str()), input.size(), &reason, &pos);
-	if (unicode != UnicodeType::INVALID) {
-		return InvalidInputException("Invalid unicode error thrown but no invalid unicode detected in " + context);
-	}
-	string base_message;
-	switch (reason) {
-	case UnicodeInvalidReason::BYTE_MISMATCH:
-		base_message = "Invalid unicode (byte sequence mismatch)";
-		break;
-	case UnicodeInvalidReason::INVALID_UNICODE:
-		base_message = "Invalid unicode";
-		break;
-	default:
-		break;
-	}
-	return InvalidInputException(base_message + " detected in " + context);
-}
-
-FatalException ErrorManager::InvalidatedDatabase(ClientContext &context, const string &invalidated_msg) {
-	return FatalException(ErrorManager::FormatException(context, ErrorType::INVALIDATED_DATABASE, invalidated_msg));
-}
-
-TransactionException ErrorManager::InvalidatedTransaction(ClientContext &context) {
-	return TransactionException(ErrorManager::FormatException(context, ErrorType::INVALIDATED_TRANSACTION));
-}
-
-void ErrorManager::AddCustomError(ErrorType type, string new_error) {
-	custom_errors.insert(make_pair(type, std::move(new_error)));
-}
-
-ErrorManager &ErrorManager::Get(ClientContext &context) {
-	return *DBConfig::GetConfig(context).error_manager;
-}
-
-ErrorManager &ErrorManager::Get(DatabaseInstance &context) {
-	return *DBConfig::GetConfig(context).error_manager;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension.cpp b/src/duckdb/src/main/extension.cpp
deleted file mode 100644
index c13971b0c..000000000
--- a/src/duckdb/src/main/extension.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "duckdb/main/extension.hpp"
-
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/capi/extension_api.hpp"
-#include "duckdb/main/extension_helper.hpp"
-
-namespace duckdb {
-
-Extension::~Extension() {
-}
-
-static string PrettyPrintString(const string &s) {
-	string res = "";
-	for (auto c : s) {
-		if (StringUtil::CharacterIsAlpha(c) || StringUtil::CharacterIsDigit(c) || c == '_' || c == '-' || c == ' ' ||
-		    c == '.') {
-			res += c;
-		} else {
-			auto value = UnsafeNumericCast<uint8_t>(c);
-			res += "\\x";
-			uint8_t first = value / 16;
-			if (first < 10) {
-				res.push_back((char)('0' + first));
-			} else {
-				res.push_back((char)('a' + first - 10));
-			}
-			uint8_t second = value % 16;
-			if (second < 10) {
-				res.push_back((char)('0' + second));
-			} else {
-				res.push_back((char)('a' + second - 10));
-			}
-		}
-	}
-	return res;
-}
-
-string ParsedExtensionMetaData::GetInvalidMetadataError() {
-	const string engine_platform = string(DuckDB::Platform());
-
-	if (!AppearsValid()) {
-		return "The file is not a DuckDB extension. The metadata at the end of the file is invalid";
-	}
-
-	string result;
-
-	// CPP or C_STRUCT_UNSTABLE ABI versioning needs to match the DuckDB version exactly
-	if (abi_type == ExtensionABIType::CPP || abi_type == ExtensionABIType::C_STRUCT_UNSTABLE) {
-		const string engine_version = string(ExtensionHelper::GetVersionDirectoryName());
-
-		if (engine_version != duckdb_version) {
-			result += StringUtil::Format("The file was built for DuckDB version '%s', but we can only load extensions "
-			                             "built for DuckDB version '%s'.",
-			                             PrettyPrintString(duckdb_version), engine_version);
-		}
-		// C_STRUCT ABI versioning works when current duckdb version >= required version
-	} else if (abi_type == ExtensionABIType::C_STRUCT) {
-
-		if (!VersioningUtils::IsSupportedCAPIVersion(duckdb_capi_version)) {
-			result += StringUtil::Format("The file was built for DuckDB version '%s', but we can only load extensions "
-			                             "built for DuckDB C API 'v%lld.%lld.%lld' and lower.",
-			                             duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR,
-			                             DUCKDB_EXTENSION_API_VERSION_MINOR, DUCKDB_EXTENSION_API_VERSION_PATCH);
-		}
-	} else {
-		throw InternalException("Unknown ABI type for extension: " + extension_abi_metadata);
-	}
-
-	if (engine_platform != platform) {
-		if (!result.empty()) {
-			result += " Also, t";
-		} else {
-			result += "T";
-		}
-		result += StringUtil::Format(
-		    "he file was built for the platform '%s', but we can only load extensions built for platform '%s'.",
-		    PrettyPrintString(platform), engine_platform);
-	}
-
-	return result;
-}
-
-bool VersioningUtils::IsSupportedCAPIVersion(string &capi_version_string) {
-	idx_t major, minor, patch;
-	if (!ParseSemver(capi_version_string, major, minor, patch)) {
-		return false;
-	}
-
-	return IsSupportedCAPIVersion(major, minor, patch);
-}
-
-bool VersioningUtils::IsSupportedCAPIVersion(idx_t major, idx_t minor, idx_t patch) {
-	if (major != DUCKDB_EXTENSION_API_VERSION_MAJOR) {
-		return false;
-	}
-	if (minor > DUCKDB_EXTENSION_API_VERSION_MINOR) {
-		return false;
-	}
-	if (minor < DUCKDB_EXTENSION_API_VERSION_MINOR) {
-		return true;
-	}
-	if (patch > DUCKDB_EXTENSION_API_VERSION_PATCH) {
-		return false;
-	}
-	return true;
-}
-
-bool VersioningUtils::ParseSemver(string &semver, idx_t &major_out, idx_t &minor_out, idx_t &patch_out) {
-	if (!StringUtil::StartsWith(semver, "v")) {
-		return false;
-	}
-
-	auto without_v = semver.substr(1);
-
-	auto split = StringUtil::Split(without_v, '.');
-
-	if (split.size() != 3) {
-		return false;
-	}
-
-	idx_t major, minor, patch;
-	bool succeeded = true;
-
-	succeeded &= TryCast::Operation<string_t, idx_t>(split[0], major);
-	succeeded &= TryCast::Operation<string_t, idx_t>(split[1], minor);
-	succeeded &= TryCast::Operation<string_t, idx_t>(split[2], patch);
-
-	if (!succeeded) {
-		return false;
-	}
-
-	major_out = major;
-	minor_out = minor;
-	patch_out = patch;
-
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension/extension_alias.cpp b/src/duckdb/src/main/extension/extension_alias.cpp
deleted file mode 100644
index 81d3c1e1b..000000000
--- a/src/duckdb/src/main/extension/extension_alias.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/main/extension_helper.hpp"
-
-namespace duckdb {
-
-static const ExtensionAlias internal_aliases[] = {{"http", "httpfs"}, // httpfs
-                                                  {"https", "httpfs"},
-                                                  {"md", "motherduck"},       // motherduck
-                                                  {"mysql", "mysql_scanner"}, // mysql
-                                                  {"s3", "httpfs"},
-                                                  {"postgres", "postgres_scanner"}, // postgres
-                                                  {"sqlite", "sqlite_scanner"},     // sqlite
-                                                  {"sqlite3", "sqlite_scanner"},
-                                                  {nullptr, nullptr}};
-
-idx_t ExtensionHelper::ExtensionAliasCount() {
-	idx_t index;
-	for (index = 0; internal_aliases[index].alias != nullptr; index++) {
-	}
-	return index;
-}
-
-ExtensionAlias ExtensionHelper::GetExtensionAlias(idx_t index) {
-	D_ASSERT(index < ExtensionAliasCount());
-	return internal_aliases[index];
-}
-
-string ExtensionHelper::ApplyExtensionAlias(const string &extension_name) {
-	auto lname = StringUtil::Lower(extension_name);
-	for (idx_t index = 0; internal_aliases[index].alias; index++) {
-		if (lname == internal_aliases[index].alias) {
-			return internal_aliases[index].extension;
-		}
-	}
-	return lname;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension/extension_helper.cpp b/src/duckdb/src/main/extension/extension_helper.cpp
deleted file mode 100644
index 2eb5e419b..000000000
--- a/src/duckdb/src/main/extension/extension_helper.cpp
+++ /dev/null
@@ -1,993 +0,0 @@
-#include "duckdb/main/extension_helper.hpp"
-
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/windows.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/extension.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-
-// Note that c++ preprocessor doesn't have a nice way to clean this up so we need to set the defines we use to false
-// explicitly when they are undefined
-#ifndef DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED
-#define DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_ICU_LINKED
-#define DUCKDB_EXTENSION_ICU_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_EXCEL_LINKED
-#define DUCKDB_EXTENSION_EXCEL_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_PARQUET_LINKED
-#define DUCKDB_EXTENSION_PARQUET_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_TPCH_LINKED
-#define DUCKDB_EXTENSION_TPCH_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_TPCDS_LINKED
-#define DUCKDB_EXTENSION_TPCDS_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_HTTPFS_LINKED
-#define DUCKDB_EXTENSION_HTTPFS_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_JSON_LINKED
-#define DUCKDB_EXTENSION_JSON_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_JEMALLOC_LINKED
-#define DUCKDB_EXTENSION_JEMALLOC_LINKED false
-#endif
-
-#ifndef DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED
-#define DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED false
-#endif
-
-// Load the generated header file containing our list of extension headers
-#if defined(GENERATED_EXTENSION_HEADERS) && GENERATED_EXTENSION_HEADERS && !defined(DUCKDB_AMALGAMATION)
-#include "duckdb/main/extension/generated_extension_loader.hpp"
-#else
-// TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that
-//		 these can be removed
-#if DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED
-#include "core_functions_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_ICU_LINKED
-#include "icu_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_PARQUET_LINKED
-#include "parquet_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_TPCH_LINKED
-#include "tpch_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_TPCDS_LINKED
-#include "tpcds_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_JSON_LINKED
-#include "json_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_JEMALLOC_LINKED
-#include "jemalloc_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED
-#include "autocomplete_extension.hpp"
-#endif
-
-#endif
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Default Extensions
-//===--------------------------------------------------------------------===//
-static const DefaultExtension internal_extensions[] = {
-    {"core_functions", "Core function library", DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED},
-    {"icu", "Adds support for time zones and collations using the ICU library", DUCKDB_EXTENSION_ICU_LINKED},
-    {"excel", "Adds support for Excel-like format strings", DUCKDB_EXTENSION_EXCEL_LINKED},
-    {"parquet", "Adds support for reading and writing parquet files", DUCKDB_EXTENSION_PARQUET_LINKED},
-    {"tpch", "Adds TPC-H data generation and query support", DUCKDB_EXTENSION_TPCH_LINKED},
-    {"tpcds", "Adds TPC-DS data generation and query support", DUCKDB_EXTENSION_TPCDS_LINKED},
-    {"httpfs", "Adds support for reading and writing files over a HTTP(S) connection", DUCKDB_EXTENSION_HTTPFS_LINKED},
-    {"json", "Adds support for JSON operations", DUCKDB_EXTENSION_JSON_LINKED},
-    {"jemalloc", "Overwrites system allocator with JEMalloc", DUCKDB_EXTENSION_JEMALLOC_LINKED},
-    {"autocomplete", "Adds support for autocomplete in the shell", DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED},
-    {"motherduck", "Enables motherduck integration with the system", false},
-    {"mysql_scanner", "Adds support for connecting to a MySQL database", false},
-    {"sqlite_scanner", "Adds support for reading and writing SQLite database files", false},
-    {"postgres_scanner", "Adds support for connecting to a Postgres database", false},
-    {"inet", "Adds support for IP-related data types and functions", false},
-    {"spatial", "Geospatial extension that adds support for working with spatial data and functions", false},
-    {"substrait", "Adds support for the Substrait integration", false},
-    {"aws", "Provides features that depend on the AWS SDK", false},
-    {"arrow", "A zero-copy data integration between Apache Arrow and DuckDB", false},
-    {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false},
-    {"iceberg", "Adds support for Apache Iceberg", false},
-    {"vss", "Adds indexing support to accelerate Vector Similarity Search", false},
-    {"delta", "Adds support for Delta Lake", false},
-    {"fts", "Adds support for Full-Text Search Indexes", false},
-    {nullptr, nullptr, false}};
-
-idx_t ExtensionHelper::DefaultExtensionCount() {
-	idx_t index;
-	for (index = 0; internal_extensions[index].name != nullptr; index++) {
-	}
-	return index;
-}
-
-DefaultExtension ExtensionHelper::GetDefaultExtension(idx_t index) {
-	D_ASSERT(index < DefaultExtensionCount());
-	return internal_extensions[index];
-}
-
-//===--------------------------------------------------------------------===//
-// Allow Auto-Install Extensions
-//===--------------------------------------------------------------------===//
-static const char *const auto_install[] = {"motherduck", "postgres_scanner", "mysql_scanner", "sqlite_scanner",
-                                           nullptr};
-
-// TODO: unify with new autoload mechanism
-bool ExtensionHelper::AllowAutoInstall(const string &extension) {
-	auto lcase = StringUtil::Lower(extension);
-	for (idx_t i = 0; auto_install[i]; i++) {
-		if (lcase == auto_install[i]) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool ExtensionHelper::CanAutoloadExtension(const string &ext_name) {
-#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
-	return false;
-#endif
-
-	if (ext_name.empty()) {
-		return false;
-	}
-	for (const auto &ext : AUTOLOADABLE_EXTENSIONS) {
-		if (ext_name == ext) {
-			return true;
-		}
-	}
-	return false;
-}
-
-string ExtensionHelper::AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error,
-                                                          const string &extension_name) {
-
-	return AddExtensionInstallHintToErrorMsg(DatabaseInstance::GetDatabase(context), base_error, extension_name);
-}
-string ExtensionHelper::AddExtensionInstallHintToErrorMsg(DatabaseInstance &db, const string &base_error,
-                                                          const string &extension_name) {
-	string install_hint;
-
-	auto &config = db.config;
-
-	if (!ExtensionHelper::CanAutoloadExtension(extension_name)) {
-		install_hint = "Please try installing and loading the " + extension_name + " extension:\nINSTALL " +
-		               extension_name + ";\nLOAD " + extension_name + ";\n\n";
-	} else if (!config.options.autoload_known_extensions) {
-		install_hint =
-		    "Please try installing and loading the " + extension_name + " extension by running:\nINSTALL " +
-		    extension_name + ";\nLOAD " + extension_name +
-		    ";\n\nAlternatively, consider enabling auto-install "
-		    "and auto-load by running:\nSET autoinstall_known_extensions=1;\nSET autoload_known_extensions=1;";
-	} else if (!config.options.autoinstall_known_extensions) {
-		install_hint =
-		    "Please try installing the " + extension_name + " extension by running:\nINSTALL " + extension_name +
-		    ";\n\nAlternatively, consider enabling autoinstall by running:\nSET autoinstall_known_extensions=1;";
-	}
-
-	if (!install_hint.empty()) {
-		return base_error + "\n\n" + install_hint;
-	}
-
-	return base_error;
-}
-
-bool ExtensionHelper::TryAutoLoadExtension(ClientContext &context, const string &extension_name) noexcept {
-	if (context.db->ExtensionIsLoaded(extension_name)) {
-		return true;
-	}
-	auto &dbconfig = DBConfig::GetConfig(context);
-	try {
-		if (dbconfig.options.autoinstall_known_extensions) {
-			auto &config = DBConfig::GetConfig(context);
-			auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(
-			    StringValue::Get(config.GetSetting<AutoinstallExtensionRepositorySetting>(context)));
-			ExtensionInstallOptions options;
-			options.repository = autoinstall_repo;
-			ExtensionHelper::InstallExtension(context, extension_name, options);
-		}
-		ExtensionHelper::LoadExternalExtension(context, extension_name);
-		return true;
-	} catch (...) {
-		return false;
-	}
-}
-
-bool ExtensionHelper::TryAutoLoadExtension(DatabaseInstance &instance, const string &extension_name) noexcept {
-	if (instance.ExtensionIsLoaded(extension_name)) {
-		return true;
-	}
-	auto &dbconfig = DBConfig::GetConfig(instance);
-	try {
-		auto &fs = FileSystem::GetFileSystem(instance);
-		if (dbconfig.options.autoinstall_known_extensions) {
-			auto autoinstall_repo =
-			    ExtensionRepository::GetRepositoryByUrl(dbconfig.options.autoinstall_extension_repo);
-			ExtensionInstallOptions options;
-			options.repository = autoinstall_repo;
-			ExtensionHelper::InstallExtension(instance, fs, extension_name, options);
-		}
-		ExtensionHelper::LoadExternalExtension(instance, fs, extension_name);
-		return true;
-	} catch (...) {
-		return false;
-	}
-}
-
-static ExtensionUpdateResult UpdateExtensionInternal(ClientContext &context, DatabaseInstance &db, FileSystem &fs,
-                                                     const string &full_extension_path, const string &extension_name) {
-	ExtensionUpdateResult result;
-	result.extension_name = extension_name;
-
-	auto &config = DBConfig::GetConfig(db);
-
-	if (!fs.FileExists(full_extension_path)) {
-		result.tag = ExtensionUpdateResultTag::NOT_INSTALLED;
-		return result;
-	}
-
-	// Extension exists, check for .info file
-	const string info_file_path = full_extension_path + ".info";
-	if (!fs.FileExists(info_file_path)) {
-		result.tag = ExtensionUpdateResultTag::MISSING_INSTALL_INFO;
-		return result;
-	}
-
-	// Parse the version of the extension before updating
-	auto ext_binary_handle = fs.OpenFile(full_extension_path, FileOpenFlags::FILE_FLAGS_READ);
-	auto parsed_metadata = ExtensionHelper::ParseExtensionMetaData(*ext_binary_handle);
-	if (!parsed_metadata.AppearsValid() && !config.options.allow_extensions_metadata_mismatch) {
-		throw IOException(
-		    "Failed to update extension: '%s', the metadata of the extension appears invalid! To resolve this, either "
-		    "reinstall the extension using 'FORCE INSTALL %s', manually remove the file '%s', or enable '"
-		    "SET allow_extensions_metadata_mismatch=true'",
-		    extension_name, extension_name, full_extension_path);
-	}
-
-	result.prev_version = parsed_metadata.AppearsValid() ? parsed_metadata.extension_version : "";
-
-	auto extension_install_info = ExtensionInstallInfo::TryReadInfoFile(fs, info_file_path, extension_name);
-
-	// Early out: no info file found
-	if (extension_install_info->mode == ExtensionInstallMode::UNKNOWN) {
-		result.tag = ExtensionUpdateResultTag::MISSING_INSTALL_INFO;
-		return result;
-	}
-
-	// Early out: we can only update extensions from repositories
-	if (extension_install_info->mode != ExtensionInstallMode::REPOSITORY) {
-		result.tag = ExtensionUpdateResultTag::NOT_A_REPOSITORY;
-		result.installed_version = result.prev_version;
-		return result;
-	}
-
-	auto repository_from_info = ExtensionRepository::GetRepositoryByUrl(extension_install_info->repository_url);
-	result.repository = repository_from_info.ToReadableString();
-
-	// Force install the full url found in this file, enabling etags to ensure efficient updating
-	ExtensionInstallOptions options;
-	options.repository = repository_from_info;
-	options.force_install = true;
-	options.use_etags = true;
-
-	unique_ptr<ExtensionInstallInfo> install_result;
-	try {
-		install_result = ExtensionHelper::InstallExtension(context, extension_name, options);
-	} catch (std::exception &e) {
-		ErrorData error(e);
-		error.Throw("Extension updating failed when trying to install '" + extension_name + "', original error: ");
-	}
-
-	result.installed_version = install_result->version;
-
-	if (result.installed_version.empty()) {
-		result.tag = ExtensionUpdateResultTag::REDOWNLOADED;
-	} else if (result.installed_version != result.prev_version) {
-		result.tag = ExtensionUpdateResultTag::UPDATED;
-	} else {
-		result.tag = ExtensionUpdateResultTag::NO_UPDATE_AVAILABLE;
-	}
-
-	return result;
-}
-
-vector<ExtensionUpdateResult> ExtensionHelper::UpdateExtensions(ClientContext &context) {
-	auto &fs = FileSystem::GetFileSystem(context);
-
-	vector<ExtensionUpdateResult> result;
-	DatabaseInstance &db = DatabaseInstance::GetDatabase(context);
-
-#ifndef WASM_LOADABLE_EXTENSIONS
-	case_insensitive_set_t seen_extensions;
-
-	// scan the install directory for installed extensions
-	auto ext_directory = ExtensionHelper::ExtensionDirectory(db, fs);
-	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
-		if (!StringUtil::EndsWith(path, ".duckdb_extension")) {
-			return;
-		}
-
-		auto extension_file_name = StringUtil::GetFileName(path);
-		auto extension_name = StringUtil::Split(extension_file_name, ".")[0];
-
-		seen_extensions.insert(extension_name);
-
-		result.push_back(UpdateExtensionInternal(context, db, fs, fs.JoinPath(ext_directory, path), extension_name));
-	});
-#endif
-
-	return result;
-}
-
-ExtensionUpdateResult ExtensionHelper::UpdateExtension(ClientContext &context, const string &extension_name) {
-	auto &fs = FileSystem::GetFileSystem(context);
-	DatabaseInstance &db = DatabaseInstance::GetDatabase(context);
-	auto ext_directory = ExtensionHelper::ExtensionDirectory(db, fs);
-
-	auto full_extension_path = fs.JoinPath(ext_directory, extension_name + ".duckdb_extension");
-
-	auto update_result = UpdateExtensionInternal(context, db, fs, full_extension_path, extension_name);
-
-	if (update_result.tag == ExtensionUpdateResultTag::NOT_INSTALLED) {
-		throw InvalidInputException("Failed to update the extension '%s', the extension is not installed!",
-		                            extension_name);
-	} else if (update_result.tag == ExtensionUpdateResultTag::UNKNOWN) {
-		throw InternalException("Failed to update extension '%s', an unknown error occurred", extension_name);
-	}
-	return update_result;
-}
-
-void ExtensionHelper::AutoLoadExtension(ClientContext &context, const string &extension_name) {
-	return ExtensionHelper::AutoLoadExtension(*context.db, extension_name);
-}
-
-void ExtensionHelper::AutoLoadExtension(DatabaseInstance &db, const string &extension_name) {
-	if (db.ExtensionIsLoaded(extension_name)) {
-		// Avoid downloading again
-		return;
-	}
-	auto &dbconfig = DBConfig::GetConfig(db);
-	try {
-		auto fs = FileSystem::CreateLocal();
-#ifndef DUCKDB_WASM
-		if (dbconfig.options.autoinstall_known_extensions) {
-			//! Get the autoloading repository
-			auto repository = ExtensionRepository::GetRepositoryByUrl(dbconfig.options.autoinstall_extension_repo);
-			ExtensionInstallOptions options;
-			options.repository = repository;
-			ExtensionHelper::InstallExtension(db, *fs, extension_name, options);
-		}
-#endif
-		ExtensionHelper::LoadExternalExtension(db, *fs, extension_name);
-	} catch (std::exception &e) {
-		ErrorData error(e);
-		throw AutoloadException(extension_name, error.RawMessage());
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Load Statically Compiled Extension
-//===--------------------------------------------------------------------===//
-void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
-	// The in-tree extensions that we check. Non-cmake builds are currently limited to these for static linking
-	// TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that
-	//		 these can be removed
-	vector<string> extensions {"parquet", "icu",  "tpch",     "tpcds",        "httpfs",        "json",
-	                           "excel",   "inet", "jemalloc", "autocomplete", "core_functions"};
-	for (auto &ext : extensions) {
-		LoadExtensionInternal(db, ext, true);
-	}
-
-#if defined(GENERATED_EXTENSION_HEADERS) && GENERATED_EXTENSION_HEADERS
-	for (const auto &ext : LinkedExtensions()) {
-		LoadExtensionInternal(db, ext, true);
-	}
-#endif
-}
-
-ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
-	return LoadExtensionInternal(db, extension, false);
-}
-
-ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std::string &extension,
-                                                           bool initial_load) {
-#ifdef DUCKDB_TEST_REMOTE_INSTALL
-	if (!initial_load && StringUtil::Contains(DUCKDB_TEST_REMOTE_INSTALL, extension)) {
-		Connection con(db);
-		auto result = con.Query("INSTALL " + extension);
-		if (result->HasError()) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		result = con.Query("LOAD " + extension);
-		if (result->HasError()) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		return ExtensionLoadResult::LOADED_EXTENSION;
-	}
-#endif
-
-#ifdef DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE
-	// Note: weird comma's are on purpose to do easy string contains on a list of extension names
-	if (!initial_load && StringUtil::Contains(DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE, "," + extension + ",")) {
-		Connection con(db);
-		auto result = con.Query((string) "LOAD '" + DUCKDB_EXTENSIONS_BUILD_PATH + "/" + extension + "/" + extension +
-		                        ".duckdb_extension'");
-		if (result->HasError()) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		return ExtensionLoadResult::LOADED_EXTENSION;
-	}
-#endif
-
-	// This is the main extension loading mechanism that loads the extension that are statically linked.
-#if defined(GENERATED_EXTENSION_HEADERS) && GENERATED_EXTENSION_HEADERS
-	if (TryLoadLinkedExtension(db, extension)) {
-		return ExtensionLoadResult::LOADED_EXTENSION;
-	} else {
-		return ExtensionLoadResult::NOT_LOADED;
-	}
-#endif
-
-	// This is the fallback to the "old" extension loading mechanism for non-cmake builds
-	// TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds
-	if (extension == "parquet") {
-#if DUCKDB_EXTENSION_PARQUET_LINKED
-		db.LoadStaticExtension<ParquetExtension>();
-#else
-		// parquet extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "icu") {
-#if DUCKDB_EXTENSION_ICU_LINKED
-		db.LoadStaticExtension<IcuExtension>();
-#else
-		// icu extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "tpch") {
-#if DUCKDB_EXTENSION_TPCH_LINKED
-		db.LoadStaticExtension<TpchExtension>();
-#else
-		// icu extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "tpcds") {
-#if DUCKDB_EXTENSION_TPCDS_LINKED
-		db.LoadStaticExtension<TpcdsExtension>();
-#else
-		// icu extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "httpfs") {
-#if DUCKDB_EXTENSION_HTTPFS_LINKED
-		db.LoadStaticExtension<HttpfsExtension>();
-#else
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "json") {
-#if DUCKDB_EXTENSION_JSON_LINKED
-		db.LoadStaticExtension<JsonExtension>();
-#else
-		// json extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "excel") {
-#if DUCKDB_EXTENSION_EXCEL_LINKED
-		db.LoadStaticExtension<ExcelExtension>();
-#else
-		// excel extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "jemalloc") {
-#if DUCKDB_EXTENSION_JEMALLOC_LINKED
-		db.LoadStaticExtension<JemallocExtension>();
-#else
-		// jemalloc extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "autocomplete") {
-#if DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED
-		db.LoadStaticExtension<AutocompleteExtension>();
-#else
-		// autocomplete extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "inet") {
-#if DUCKDB_EXTENSION_INET_LINKED
-		db.LoadStaticExtension<InetExtension>();
-#else
-		// inet extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "core_functions") {
-#if DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED
-		db.LoadStaticExtension<CoreFunctionsExtension>();
-#else
-		// core_functions extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	}
-
-	return ExtensionLoadResult::LOADED_EXTENSION;
-}
-
-static const char *const public_keys[] = {
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6aZuHUa1cLR9YDDYaEfi
-UDbWY8m2t7b71S+k1ZkXfHqu+5drAxm+dIDzdOHOKZSIdwnJbT3sSqwFoG6PlXF3
-g3dsJjax5qESIhbVvf98nyipwNINxoyHCkcCIPkX17QP2xpnT7V59+CqcfDJXLqB
-ymjqoFSlaH8dUCHybM4OXlWnAtVHW/nmw0khF8CetcWn4LxaTUHptByaBz8CasSs
-gWpXgSfaHc3R9eArsYhtsVFGyL/DEWgkEHWolxY3Llenhgm/zOf3s7PsAMe7EJX4
-qlSgiXE6OVBXnqd85z4k20lCw/LAOe5hoTMmRWXIj74MudWe2U91J6GrrGEZa7zT
-7QIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAq8Gg1S/LI6ApMAYsFc9m
-PrkFIY+nc0LXSpxm77twU8D5M0Xkz/Av4f88DQmj1OE3164bEtR7sl7xDPZojFHj
-YYyucJxEI97l5OU1d3Pc1BdKXL4+mnW5FlUGj218u8qD+G1hrkySXQkrUzIjPPNw
-o6knF3G/xqQF+KI+tc7ajnTni8CAlnUSxfnstycqbVS86m238PLASVPK9/SmIRgO
-XCEV+ZNMlerq8EwsW4cJPHH0oNVMcaG+QT4z79roW1rbJghn9ubAVdQU6VLUAikI
-b8keUyY+D0XdY9DpDBeiorb1qPYt8BPLOAQrIUAw1CgpMM9KFp9TNvW47KcG4bcB
-dQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyYATA9KOQ0Azf97QAPfY
-Jc/WeZyE4E1qlRgKWKqNtYSXZqk5At0V7w2ntAWtYSpczFrVepCJ0oPMDpZTigEr
-NgOgfo5LEhPx5XmtCf62xY/xL3kgtfz9Mm5TBkuQy4KwY4z1npGr4NYYDXtF7kkf
-LQE+FnD8Yr4E0wHBib7ey7aeeKWmwqvUjzDqG+TzaqwzO/RCUsSctqSS0t1oo2hv
-4q1ofanUXsV8MXk/ujtgxu7WkVvfiSpK1zRazgeZjcrQFO9qL/pla0vBUxa1U8He
-GMLnL0oRfcMg7yKrbIMrvlEl2ZmiR9im44dXJWfY42quObwr1PuEkEoCMcMisSWl
-jwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4RvbWx3zLblDHH/lGUF5
-Q512MT+v3YPriuibROMllv8WiCLAMeJ0QXbVaIzBOeHDeLx8yvoZZN+TENKxtT6u
-IfMMneUzxHBqy0AQNfIsSsOnG5nqoeE/AwbS6VqCdH1aLfoCoPffacHYa0XvTcsi
-aVlZfr+UzJS+ty8pRmFVi1UKSOADDdK8XfIovJl/zMP2TxYX2Y3fnjeLtl8Sqs2e
-P+eHDoy7Wi4EPTyY7tNTCfxwKNHn1HQ5yrv5dgvMxFWIWXGz24yikFvtwLGHe8uJ
-Wi+fBX+0PF0diZ6pIthZ149VU8qCqYAXjgpxZ0EZdrsiF6Ewz0cfg20SYApFcmW4
-pwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyhd5AfwrUohG3O4DE0K9
-O3FmgB7zE4aDnkL8UUfGCh5kdP8q7ewMjekY+c6LwWOmpdJpSwqhfV1q5ZU1l6rk
-3hlt03LO3sgs28kcfOVH15hqfxts6Sg5KcRjxStE50ORmXGwXDcS9vqkJ60J1EHA
-lcZqbCRSO73ZPLhdepfd0/C6tM0L7Ge6cAE62/MTmYNGv8fDzwQr/kYIJMdoS8Zp
-thRpctFZJtPs3b0fffZA/TCLVKMvEVgTWs48751qKid7N/Lm/iEGx/tOf4o23Nec
-Pz1IQaGLP+UOLVQbqQBHJWNOqigm7kWhDgs3N4YagWgxPEQ0WVLtFji/ZjlKZc7h
-dwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnFDg3LhyV6BVE2Z3zQvN
-6urrKvPhygTa5+wIPGwYTzJ8DfGALqlsX3VOXMvcJTca6SbuwwkoXHuSU5wQxfcs
-bt4jTXD3NIoRwQPl+D9IbgIMuX0ACl27rJmr/f9zkY7qui4k1X82pQkxBe+/qJ4r
-TBwVNONVx1fekTMnSCEhwg5yU3TNbkObu0qlQeJfuMWLDQbW/8v/qfr/Nz0JqHDN
-yYKfKvFMlORxyJYiOyeOsbzNGEhkGQGOmKhRUhS35kD+oA0jqwPwMCM9O4kFg/L8
-iZbpBBX2By1K3msejWMRAewTOyPas6YMQOYq9BMmWQqzVtG5xcaSJwN/YnMpJyqb
-sQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1z0RU8vGrfEkrscEoZKA
-GiOcGh2EMcKwjQpl4nKuR9H4o/dg+CZregVSHg7MP2f8mhLZZyoFev49oWOV4Rmi
-qs99UNxm7DyKW1fF1ovowsUW5lsDoKYLvpuzHo0s4laiV4AnIYP7tHGLdzsnK2Os
-Cp5dSuMwKHPZ9N25hXxFB/dRrAdIiXHvbSqr4N29XzfQloQpL3bGHLKY6guFHluH
-X5dJ9eirVakWWou7BR2rnD0k9vER6oRdVnJ6YKb5uhWEOQ3NmV961oyr+uiDTcep
-qqtGHWuFhENixtiWGjFJJcACwqxEAW3bz9lyrfnPDsHSW/rlQVDIAkik+fOp+R7L
-kQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxwO27e1vnbNcpiDg7Wwx
-K/w5aEGukXotu3529ieq+O39H0+Bak4vIbzGhDUh3/ElmxaFMAs4PYrWe/hc2WFD
-H4JCOoFIn4y9gQeE855DGGFgeIVd1BnSs5S+5wUEMxLNyHdHSmINN6FsoZ535iUg
-KdYjRh1iZevezg7ln8o/O36uthu925ehFBXSy6jLJgQlwmq0KxZJE0OAZhuDBM60
-MtIunNa/e5y+Gw3GknFwtRLmn/nEckZx1nEtepYvvUa7UGy+8KuGuhOerCZTutbG
-k8liCVgGenRve8unA2LrBbpL+AUf3CrZU/uAxxTqWmw6Z/S6TeW5ozeeyOCh8ii6
-TwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsGIFOfIQ4RI5qu4klOxf
-ge6eXwBMAkuTXyhyIIJDtE8CurnwQvUXVlt+Kf0SfuIFW6MY5ErcWE/vMFbc81IR
-9wByOAAV2CTyiLGZT63uE8pN6FSHd6yGYCLjXd3P3cnP3Qj5pBncpLuAUDfHG4wP
-bs9jIADw3HysD+eCNja8p7ZC7CzWxTcO7HsEu9deAAU19YywdpagXvQ0pJ9zV5qU
-jrHxBygl31t6TmmX+3d+azjGu9Hu36E+5wcSOOhuwAFXDejb40Ixv53ItJ3fZzzH
-PF2nj9sQvQ8c5ptjyOvQCBRdqkEWXIVHClxqWb+o59pDIh1G0UGcmiDN7K9Gz5HA
-ZQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt9uUnlW/CoUXT68yaZh9
-SeXHzGRCPNEI98Tara+dgYxDX1z7nfOh8o15liT0QsAzx34EewZOxcKCNiV/dZX5
-z4clCkD8uUbZut6IVx8Eu+7Qcd5jZthRc6hQrN9Ltv7ZQEh7KGXOHa53kT2K01ws
-4jbVmd/7Nx7y0Yyqhja01pIu/CUaTkODfQxBXwriLdIzp7y/iJeF/TLqCwZWHKQx
-QOZnsPEveB1F00Va9MeAtTlXFUJ/TQXquqTjeLj4HuIRtbyuNgWoc0JyF+mcafAl
-bnrNEBIfxZhAT81aUCIAzRJp6AqfdeZxnZ/WwohtZQZLXAxFQPTWCcP+Z9M7OIQL
-WwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA56NhfACkeCyZM07l2wmd
-iTp24E2tLLKU3iByKlIRWRAvXsOejRMJTHTNHWa3cQ7uLP++Tf2St7ksNsyPMNZy
-9QRTLNCYr9rN9loLwdb2sMWxFBwwzCaAOTahGI7GJQy30UB7FEND0X/5U2rZvQij
-Q6K+O4aa+K9M5qyOHNMmXywmTnAgWKNaNxQHPRtD2+dSj60T6zXdtIuCrPfcNGg5
-gj07qWGEXX83V/L7nSqCiIVYg/wqds1x52Yjk1nhXYNBTqlnhmOd8LynGxz/sXC7
-h2Q9XsHjXIChW4FHyLIOl6b4zPMBSxzCigYm3QZJWfAkZv5PBRtnq7vhYOLHzLQj
-CwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmfPLe0IWGYC0MZC6YiM3
-QGfhT6zSKB0I2DW44nlBlWUcF+32jW2bFJtgE76qGGKFeU4kJBWYr99ufHoAodNg
-M1Ehl/JfQ5KmbC1WIqnFTrgbmqJde79jeCvCpbFLuqnzidwO1PbXDbfRFQcgWaXT
-mDVLNNVmLxA0GkCv+kydE2gtcOD9BDceg7F/56TDvclyI5QqAnjE2XIRMPZlXQP4
-oF2kgz4Cn7LxLHYmkU2sS9NYLzHoyUqFplWlxkQjA4eQ0neutV1Ydmc1IX8W7R38
-A7nFtaT8iI8w6Vkv7ijYN6xf5cVBPKZ3Dv7AdwPet86JD5mf5v+r7iwg5xl3r77Z
-iwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoB1kWsX8YmCcFOD9ilBY
-xK076HmUAN026uJ8JpmU9Hz+QT1FNXOsnj1h2G6U6btYVIdHUTHy/BvAumrDKqRz
-qcEAzCuhxUjPjss54a/Zqu6nQcoIPHuG/Er39oZHIVkPR1WCvWj8wmyYv6T//dPH
-unO6tW29sXXxS+J1Gah6vpbtJw1pI/liah1DZzb13KWPDI6ZzviTNnW4S05r6js/
-30He+Yud6aywrdaP/7G90qcrteEFcjFy4Xf+5vG960oKoGoDplwX5poay1oCP9tb
-g8AC8VSRAGi3oviTeSWZcrLXS8AtJhGvF48cXQj2q+8YeVKVDpH6fPQxJ9Sh9aeU
-awIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4NTMAIYIlCMID00ufy/I
-AZXc8pocDx9N1Q5x5/cL3aIpLmx02AKo9BvTJaJuHiTjlwYhPtlhIrHV4HUVTkOX
-sISp8B8v9i2I1RIvCTAcvy3gcH6rdRWZ0cdTUiMEqnnxBX9zdzl8oMzZcyauv19D
-BeqJvzflIT96b8g8K3mvgJHs9a1j9f0gN8FuTA0c52DouKnrh8UwH7mlrumYerJw
-6goJGQuK1HEOt6bcQuvogkbgJWOoEYwjNrPwQvIcP4wyrgSnOHg1yXOFE84oVynJ
-czQEOz9ke42I3h8wrnQxilEYBVo2uX8MenqTyfGnE32lPRt3Wv1iEVQls8Cxiuy2
-CQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3bUtfp66OtRyvIF/oucn
-id8mo7gvbNEH04QMLO3Ok43dlWgWI3hekJAqOYc0mvoI5anqr98h8FI7aCYZm/bY
-vpz0I1aXBaEPh3aWh8f/w9HME7ykBvmhMe3J+VFGWWL4eswfRl//GCtnSMBzDFhM
-SaQOTvADWHkC0njeI5yXjf/lNm6fMACP1cnhuvCtnx7VP/DAtvUk9usDKG56MJnZ
-UoVM3HHjbJeRwxCdlSWe12ilCdwMRKSDY92Hk38/zBLenH04C3HRQLjBGewACUmx
-uvNInehZ4kSYFGa+7UxBxFtzJhlKzGR73qUjpWzZivCe1K0WfRVP5IWsKNCCESJ/
-nQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyV2dE/CRUAUE8ybq/DoS
-Lc7QlYXh04K+McbhN724TbHahLTuDk5mR5TAunA8Nea4euRzknKdMFAz1eh9gyy3
-5x4UfXQW1fIZqNo6WNrGxYJgWAXU+pov+OvxsMQWzqS4jrTHDHbblCCLKp1akwJk
-aFNyqgjAL373PcqXC+XAn8vHx4xHFoFP5lq4lLcJCOW5ee9v9El3w0USLwS+t1cF
-RY3kuV6Njlr4zsRH9iM6/zaSuCALYWJ/JrPEurSJXzFZnWsvn6aQdeNeAn08+z0F
-k2NwaauEo0xmLqzqTRGzjHqKKmeefN3/+M/FN2FrApDlxWQfhD2Y3USdAiN547Nj
-1wIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvm2+kTrEQWZXuxhWzBdl
-PCbQGqbrukbeS6JKSlQLJDC8ayZIxFxatqg1Q8UPyv89MVRsHOGlG1OqFaOEtPjQ
-Oo6j/moFwB4GPyJhJHOGpCKa4CLB5clhfDCLJw6ty7PcDU3T6yW4X4Qc5k4LRRWy
-yzC8lVHfBdarN+1iEe0ALMOGoeiJjVn6i/AFxktRwgd8njqv/oWQyfjJZXkNMsb6
-7ZDxNVAUrp/WXpE4Kq694bB9xa/pWsqv7FjQJUgTnEzvbN+qXnVPtA7dHcOYYJ8Z
-SbrJUfHrf8TS5B54AiopFpWG+hIbjqqdigqabBqFpmjiRDZgDy4zJJj52xJZMnrp
-rwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwEAcVmY3589O02pLA22f
-MlarLyJUgy0BeJDG5AUsi17ct8sHZzRiv9zKQVCBk1CtZY//jyqnrM7iCBLWsyby
-TiTOtGYHHApaLnNjjtaHdQ6zplhbc3g2XLy+4ab8GNKG3zc8iXpsQM6r+JO5n9pm
-V9vollz9dkFxS9l+1P17lZdIgCh9O3EIFJv5QCd5c9l2ezHAan2OhkWhiDtldnH/
-MfRXbz7X5sqlwWLa/jhPtvY45x7dZaCHGqNzbupQZs0vHnAVdDu3vAWDmT/3sXHG
-vmGxswKA9tPU0prSvQWLz4LUCnGi/cC5R+fiu+fovFM/BwvaGtqBFIF/1oWVq7bZ
-4wIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA25qGwNO1+qHygC8mjm8L
-3I66mV/IzslgBDHC91mE8YcI5Fq0sdrtsbUhK3z89wIN/zOhbHX0NEiXm2GxUnsI
-vb5tDZXAh7AbTnXTMVbxO/e/8sPLUiObGjDvjVzyzrxOeG87yK/oIiilwk9wTsIb
-wMn2Grj4ht9gVKx3oGHYV7STNdWBlzSaJj4Ou7+5M1InjPDRFZG1K31D2d3IHByX
-lmcRPZtPFTa5C1uVJw00fI4F4uEFlPclZQlR5yA0G9v+0uDgLcjIUB4eqwMthUWc
-dHhlmrPp04LI19eksWHCtG30RzmUaxDiIC7J2Ut0zHDqUe7aXn8tOVI7dE9tTKQD
-KQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7EC2bx7aRnf3TcRg5gmw
-QOKNCUheCelK8hoXLMsKSJqmufyJ+IHUejpXGOpvyYRbACiJ5GiNcww20MVpTBU7
-YESWB2QSU2eEJJXMq84qsZSO8WGmAuKpUckI+hNHKQYJBEDOougV6/vVVEm5c5bc
-SLWQo0+/ciQ21Zwz5SwimX8ep1YpqYirO04gcyGZzAfGboXRvdUwA+1bZvuUXdKC
-4zsCw2QALlcVpzPwjB5mqA/3a+SPgdLAiLOwWXFDRMnQw44UjsnPJFoXgEZiUpZm
-EMS5gLv50CzQqJXK9mNzPuYXNUIc4Pw4ssVWe0OfN3Od90gl5uFUwk/G9lWSYnBN
-3wIDAQAB
------END PUBLIC KEY-----
-)", nullptr};
-
-static const char *const community_public_keys[] = {
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtXl28loGwAH3ZGQXXgJQ
-3omhIEiUb3z9Petjl+jmdtEQnMNUFEZiXkfJB02UFWBL1OoKKnjiGhcr5oGiIZKR
-CoaL6SfmWe//7o8STM44stE0exzZcv8W4tWwjrzSWQnwh2JgSnHN64xoDQjdvG3X
-9uQ1xXMXghWOKqEpgArpJQkHoPW3CD5sCS2NLFrBG6KgX0W+GTV5HaKhTMr2754F
-l260drcBJZhLFCeesze2DXtQC+R9D25Zwn2ehHHd2Fd1M10ZL/iKN8NeerB4Jnph
-w6E3orA0DusDLDLtpJUHhmpLoU/1eYQFQOpGw2ce5I88Tkx7SKnCRy1UiE7BA82W
-YQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvTgQ+mJs8vG/TQTJ6sV+
-tACTZTbmp8NkgTuwEyHZSNhX6W8FYwAqPzbePo7wudsUdBWV8j+kUYaBiqeiPUp0
-7neO/3oTUQkMJLq9FeIXfoYkS3+/5CIuvsfas6PJP9U2ge6MV1Ndgbd7a12cmX8V
-4eNwQRDv/H4zgL7YI2ZZSG1loxgMffZrpflNB87t/f0QYdmnwphMC5RqxiCkDZPA
-a5/5KbmD6kjLh8RRRw3lAZbPQe5r7o2Xqqwg9gc6rQ/WFBB1Oj+Q5Bggqznl6dCB
-JcLOA7rhYatv/mvt1h6ogQwQ9FGRM3PifV9boZxOQGBAkMD6ngpd5kVoOxdygC7v
-twIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7KvnA+Ixj4ZCLR+aXSFz
-ICGbQdVrZ/hhjImDQcWgWY+z/bEbybslDvy5KEPrxTNxKZ0VfFFAVEUj2cw8B5KI
-naK8U2VIpdD6LpEJvkOuWKg3bym4COhyAcRNqKKu/GPzS90wICJ2aaayF1mVoCIL
-dsp2ZShSIVRJa55gVvfRN1ZEkqBnZryKNt/h3DNqqq2Sn3n3HIZ8H9oEO+L+2Efe
-kyET7o9OHy6QZXhf4SJ8QlQAwxxe/L4bln8CBlBHKrUNNqxpjhC37EnY2jpuu3a9
-EZcNFj8R4qIJx7hcltntZyKrEIXqc6I6x4oZ4qhZj3RQ5Lr+pJ++idoc1LmBS3k5
-yQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7SF+5RZ9jXyruBkhxhk2
-BSWPbohevxxv++7Uw0HXC/3Xw4jzii0tYaJ6O8QWXyggEAkvmONblAN1rfiz+h5M
-oJUQwHjTTZ8BmKUmWrNayVokUXLu4IpCAHk4uSXfx4U/AINnNfWW7z8mUJf6nGsM
-XePuKPBRUsw+JmTWOXEIVrkc/66B+gpgi+DwRFLUPh96D8XRAhp7QbHE9UMD3HpA
-mPMX7ICVsVS+NGdCHNsdWfH4noaESjgmMdApKekgeeo8Zu1pvQ3y8iew1xOQVBoR
-V+PCGWAJYB7ulqBBkRz+NhPLWw7wRA4yLNcZVlZuDFxH9EoavWdfIyYYUn4efSz9
-tQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAszmZ6Slv/oJvFpOLtSMx
-58AKMia9y+qcVfw77/Alb3b+Qi5L2uy6nHfJElT7RIeeXhJ8mFglZ70MecTfj0jl
-5WhW+yMg6jmPCJL2JMt/oeC4iY4Cf/3C9RHU4IO13VN4dnVQ5S+SEEmSbXnno9Pe
-06yyVgZeJ0REJMV1JZj9gOPc/wbeLHsx4UC5qsu32Ammy6J7tS+k7JvRc9CPOEpe
-IhWoZmpONydcI6IRfyH2xl4uLY3hWDrRei0I2zGH45G2hPNeTtRh27t+SzXO7h9j
-y072CgHytRgQBiH711i8fe4bHMmtVPhPjFrbuzbJSgE7SyikrWIHMDsnPz443bdR
-cQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAleywAb7xZKYTFE08gGA9
-ffTeYPRcECl/J060fUziIiFu0NHTOZO+a4BH2X+E1WjjNNQkbn00g+op4nqg3/U+
-UaKuXNjWY2Rvd8s91fUD0YOdRpPmsTm2QqhgmYYzO8Oh3YXBNRpXaqALbjL9Nahw
-YEAsI3o5yenZGUIEk3JaZFHsAZPL5wGgDVpZgmVUHJ0EO8N5LQh01aHxnP5+ey2z
-L5h6IdWLubb07wEBk5bnmIvdhd6dIBzUql27BAqvxKJbW0/okjrhIgcIANDCavfV
-L8UP7MCGnfozK7VIl5DG85gCQVAD8+lGUDzOuhzZjl7XKpkFAIWaS8pl4AJbJuG8
-nwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxiKgcR7Kb1CGTNczbuX+
-S7OFpnVLDD5XGVKvYWxL+2By2QRFPWtMs8c24omLIgZ/CWBFPraMiNKS4+V9ar2C
-wJhToJnAOKyayA0Gw2wNZx1mgHAZ/5mT+ImfkmZu2HPwtzJmJDQlESD4p40BWBNa
-ZpWFGPMKn4GqvOOSGevC/r9inXm6NaPkM+B/piVDEgiJ7g/kpoqImmNb/c2/3XG5
-3kbDIHdbd2m3A3jWCjNGSANKsR5C0/rZtvsA8tjDlNWIuKmkU3C2nfj3UduU4dNP
-Cisod/pDY8ov0U9sdkM9XZsTXjtbAIGLzMshmOv4ajRFUueGnsZW0GRqp9DSnKmj
-2QIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuh334hUmJcdDJUSmeXqE
-GUfGnASD2QrnuoS+gsXgW5BQW8YMDFASvADQhoDUdcwZMlAF+p+CxKCX/gBp40nC
-5eyPXv1e0K6PFcCdHtJq8MhGYAr1sy+7cOpzv0r9whobYUykGoHjdwZeu3VbA3uz
-go80oYQlwY+v4zZFafCz3cXw8u7n/9PlddgeqHuIPsNZLocICuBUxwg5rHTzycg2
-Pa68CRselONGN12V0/wlOg+NZpKCym58CM9SS/0v4YZ6LnmINo8gdRYnGE2zhvey
-pHR8IJ8WSJXbl8NwyIY1AmtT/Z0dbAclfD8Wt/w5KA/sttnQzrB7fPsLRyLP1Alq
-iQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvWuRMEbez/Ud2o/0KA04
-K9u3HePWud9rEqMsPv2HlclH3k+cezoUJzVre0lopv3R4aG3LDoFETrgGgUVrfPG
-z3Zh7vyk0kb4IGkv+kLQu/cWQXyNzigxV+WQnpIWQ28vrP45y5f+GhwwgzFaDAQR
-u1o1HH1FEnP7SSzHVvisNTecY95+F5AOvtOOUg4VlegXdUeGZHEza/0D9V8gODPL
-DzbOJDDiqX8ahhRnIZyGEg6y7QqftZFz7j0siCHTXXYJBOcPjD4TqTUNpGvBox44
-wgLlLcDsZ/n2Ck4doLXxVz9F80VKOriHSk+qIwseykKVzWQDQTOMOsjCmQsDvram
-RwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyJmGd1GuBv/WD80IcVyr
-dZcmuYe/7azLuV1wsgtH4gsUx+ifUwLZUhLFGOTAPFitbFYPPdhQKncO+BcbvOIo
-9FGKj9jGVpMU6C+0JQfi+koESevtO1tYzG8c2dMOGNUO0Hlj2Hezm3tZY4nAbo1J
-DYqQSY7qvOYZPFvOS/zL+q2vMx93w9jDHJK4iU02ovAqK9xCWfTp4W7rtbDeTgiX
-W/75rMG8DWI1ZHA2JXAOFPsiOHa0/yyvCvUIWvRuNHqTTN5NFiJRIcbTCKKbNwNM
-xcNkBQCx4xwOqD9TkDbHpBOC/pfW7j3ygJdYRjFFqm10+KwPACYo/f0n4n4DI8Zz
-twIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmxbunsK+2pL8Cva9F8E
-9o/dQ35TuIqcgpl9/oIc++x+6G5/8UT5mgGCQTITJRIAPnHsZ9XEnMxTAuSCDkYG
-CA3JMl1MT7Zxu8TQJBPiXxOaAE1UmA13JuQ2Uu0v7T6TucQxR9KMvcdCxOZ5cBU4
-uyJObnZVy/WjM2vWcWDUaYGfMss3eYxcDpavspBANdtSZfv11+8/VC+gEGBOe+oW
-zDR+BlQx//MAzwSP5HVQcmLHsT073IvkoUWJUxSCCwlLe60ylpY16BLT6dB0RU8B
-sxFcIwmYg0kq19EEPPvZLvRKjG/TJRm1MFzOE5LP2VxLGdMltWYEVsBZHTcWU7HR
-8wIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAlo7eDZOpCptanajUtDK3
-q8Q/ykxmDDw6lVSiLBm54zwMxaqfM+tV/xqalvIVv3BrucRkCs6H+R0bpd7XhbE5
-a7ZFSrWCBf1V6y/NZrEn4qcRbk/WsG4UFqu7CG4r+EgQ4nmoIH/A5+e8FUcur3Y8
-2ie9Foi1CUpZojWYZJeHKbb2yYn4MFHszEb5w9HVxY+i9jR1B8Rvn6OEK3OYDrtA
-KnPXp4OiDx6CviYEmipX815PPj7Sv8KKL96JqGWjC4kYw6ALgV/GxiX++tv6rh2O
-paW9MBv1y+5oZ8ls5S2T/LXbxDpjUEKC9guSSWmsPHRMxOumXsw0H43grC3Ce8Ui
-CwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ACgf0kJeQgDh+vHj2aj
-K/6FQ794MknLxlwTARGlktoVwZgW/qc6vMZsILRUP1gb/gPXdpSTqqad/GLG4f5R
-1Ji1It6BniJOPWu1YyTz0C/BXzTGWbwPnIaawbpQE8n4A+tjGGvAoauPtzr0bWfV
-XOXPfIW9XB51dcaVTZgHN55Y8Yd/Pcu9/lqXqXyE23tDLXR/QgGpwK9VxTSbRmuC
-WspwqWY6L3MIw+3HIXERTM1uNhc9oHxMOCRbJmUghG0wCWB0ed3Xhbnl9mHlX+l1
-rfCJAP4lVWKFjkKBNUejaf+WHxASMjrQubgHLZ2fpf3Ra8TfI3rgPABsAqEIFw3T
-QwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt635/P50bMbEDTapjAQz
-ARTb3y8jMHxVruX0tJU1tycmkX3J8tBALmc6TkSHNTJcQmR8L8Sj3h76l/vuL373
-HFSGZ4xghBQqR1lUd2kVomoh+rzEte+0rHWm0JMhjmTQBx+AkDCOw4z3vi5AxWx0
-4EbYpQm2akVGKXQrQPyds0UirmdLACCH6WM6exgAXr75DB4PUpG85oI9Q+5ee1Km
-+4atVJ4FNa6ZnjWccrlMYT0W7a0Y7feJPAPvfizrs2MG9/ijyBX34eCWA5dtUSIm
-2uqI6DxITZlLTvXVDSKQGlq5TEGMvRULWTatqWy4g+tOZ8rSbRuj32pcBnXlwuVu
-7QIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwqO3yWSLKqz1uQ54iFd/
-VcQzgT6chLVuhktt7EFvi3tKaQqz2h2KPkDR+MssRV/BZ/41GNlR6r6p5CaPVDDe
-Cuj5IcxrIFZIOBMBi1YZ/bknF9edJacINxNfGK/lXBNEAdUvxcOxX8WeP69uvl2l
-SKyO3yAdx6HOyL9if95bYQD19HYPZzbfccPX1aD4pjnej6uMfd7yZErH7i8y0oj4
-eSKSe1CisjFlR9NzRGO42jU9rtqnAFH9sK5wU9xKQ7bQwlz7yKBF2RuuQweMpXb6
-lSObI7ZqYN+7jkf9F5hKRx4kX3+MMBeYmFOy1aYZ08u6sdJ2ua/hFNSDRg7e/UCe
-AwIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAkJihnfMECaa6YCg6avam
-cb8Sy1GshJ7c7+EW6C4vnspSSvEi04AEBB29pnEF9+VO6VSUHLxunVCpbmKFaLH+
-5fDLnc/wCkjPQww49da9MEScCmVGjROlmog65cxQbv4lfxyw55sFV3s/5CPcGlVc
-1gojHRABrx4YocpeYies04mEVoOYg1DBG4Uf+aFd5+hm3ZtBa4mqTK2iQa4ILkHa
-a0/Us1drRuDjjI4zSbgRzy9x0JVDvqDdLubHyaEf7d7SdrKzodhydG84qpsPFxIj
-LK7Bu5v7P4ZTJmxMG3PBM2kB//hlYVR4vO4VEu66mQIM6km+vT9cwxz77qIJhLn3
-ywIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA9NbP7ijUxZh4j0NVF6yO
-IZ0rzROwl4pP4HGeN+Woyi9+qpdE874WlVoquGEpsshF4Ojzbu2BtXuihb783awa
-GLx66MYPeID1FjTKmuCJ2aluOP+DkVo6K1EoqVJXyeIxZzVSqhSIuAdb/vmPlgLz
-Fzdk3FgNNOERuGV363DRGz1YxZVnJeSs76g+/9ddhMk8cqIRup5S4YgTOSr0vKem
-1E6lyE8IbLoq9J7w5Ur8VjzE2cI+eLKGFqr46Q8pf0pJq72gd+Z3mH5D2LmvEtAR
-9jAQXVlLfHauQR2M0K6mqDy9GxL19OU4tGO+GY86VvDTU+wZppAZRz9AKoL1fwfI
-BQIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjrI16GdC2zJriLbyzcre
-AqvckBSTMd4bdGaodUBNBTBVbITsOw/k7D62y2hSZHt2nHOyEVkJINJHADrpNZuY
-ybS4ssEXxD8+NnjATqQxDMuSz8lUj/Jnf49uzLh84fep3DTksDcQX6Nvio5q8Xbh
-HRgvl5I+tPfLtme0oW9cVuVja2i5lHB3SzYCW9Kk/V4/d2WiceYf91a1Nae6m7QV
-5bmbYoHmsxT8refTQq+5lAhzVXYU9QRgiKdbE8sSmkV+YiZEtGijefUXgmOxx3I9
-B3y03796WBS/RHpSzdMNJw/xPWJcSEMqaUdSYr0DuPCnrn7ojFeF/EFC47CBq5DU
-swIDAQAB
------END PUBLIC KEY-----
-)",
-    R"(
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjS1+My6OhQCCD1DgrzKu
-db4Fvc3aqqEhQyjqMLnalp0uoGFpSLoPsZiPGloTE8FSs1ZBFKQ8h2SsGwSdhRKF
-xIqoOnS0B/ORjGJxTj7Q2YWjzkCZUD4Ul2AxIbv3TmZM2LeyHJL3A71tSuck8EQY
-PE2aj1tLzXsSfRaByy5xwXiU6UpnwCY1xb8tK8QxavRCo5T9Si9tNsolStoNVXV0
-k9EbTcRNnxCvab/oqjvgyRuSmIES00v8jZOGQZQUpw02RN6yCBeX2i8GPsGjj/T9
-6Gu1Z3G4zUjLlJxl8vjo8KIDaQ8NVWT0j7gx9Knvb5tWnAORI1aJA8AHQvaoOT1W
-1wIDAQAB
------END PUBLIC KEY-----
-)", nullptr};
-
-const vector<string> ExtensionHelper::GetPublicKeys(bool allow_community_extensions) {
-	vector<string> keys;
-	for (idx_t i = 0; public_keys[i]; i++) {
-		keys.emplace_back(public_keys[i]);
-	}
-	if (allow_community_extensions) {
-		for (idx_t i = 0; community_public_keys[i]; i++) {
-			keys.emplace_back(community_public_keys[i]);
-		}
-	}
-	return keys;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension/extension_install.cpp b/src/duckdb/src/main/extension/extension_install.cpp
deleted file mode 100644
index 5675bb9ac..000000000
--- a/src/duckdb/src/main/extension/extension_install.cpp
+++ /dev/null
@@ -1,622 +0,0 @@
-#include "duckdb/common/exception/http_exception.hpp"
-#include "duckdb/common/gzip_file_system.hpp"
-#include "duckdb/common/http_util.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/logging/http_logger.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-#include "duckdb/main/secret/secret.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-
-#ifndef DISABLE_DUCKDB_REMOTE_INSTALL
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-#include "httplib.hpp"
-#ifndef DUCKDB_NO_THREADS
-#include <chrono>
-#include <thread>
-#endif
-#endif
-#endif
-#include "duckdb/common/windows_undefs.hpp"
-
-#include <fstream>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Install Extension
-//===--------------------------------------------------------------------===//
-const string ExtensionHelper::NormalizeVersionTag(const string &version_tag) {
-	if (!version_tag.empty() && version_tag[0] != 'v') {
-		return "v" + version_tag;
-	}
-	return version_tag;
-}
-
-bool ExtensionHelper::IsRelease(const string &version_tag) {
-	return !StringUtil::Contains(version_tag, "-dev");
-}
-
-const string ExtensionHelper::GetVersionDirectoryName() {
-#ifdef DUCKDB_WASM_VERSION
-	return DUCKDB_QUOTE_DEFINE(DUCKDB_WASM_VERSION);
-#endif
-	if (IsRelease(DuckDB::LibraryVersion())) {
-		return NormalizeVersionTag(DuckDB::LibraryVersion());
-	} else {
-		return DuckDB::SourceID();
-	}
-}
-
-const vector<string> ExtensionHelper::PathComponents() {
-	return vector<string> {GetVersionDirectoryName(), DuckDB::Platform()};
-}
-
-duckdb::string ExtensionHelper::DefaultExtensionFolder(FileSystem &fs) {
-	string home_directory = fs.GetHomeDirectory();
-	// exception if the home directory does not exist, don't create whatever we think is home
-	if (!fs.DirectoryExists(home_directory)) {
-		throw IOException("Can't find the home directory at '%s'\nSpecify a home directory using the SET "
-		                  "home_directory='/path/to/dir' option.",
-		                  home_directory);
-	}
-	string res = home_directory;
-	res = fs.JoinPath(res, ".duckdb");
-	res = fs.JoinPath(res, "extensions");
-	return res;
-}
-
-string ExtensionHelper::GetExtensionDirectoryPath(ClientContext &context) {
-	auto &db = DatabaseInstance::GetDatabase(context);
-	auto &fs = FileSystem::GetFileSystem(context);
-	return GetExtensionDirectoryPath(db, fs);
-}
-
-string ExtensionHelper::GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs) {
-	string extension_directory;
-	auto &config = db.config;
-	if (!config.options.extension_directory.empty()) { // create the extension directory if not present
-		extension_directory = config.options.extension_directory;
-		// TODO this should probably live in the FileSystem
-		// convert random separators to platform-canonic
-	} else { // otherwise default to home
-		extension_directory = DefaultExtensionFolder(fs);
-	}
-
-	extension_directory = fs.ConvertSeparators(extension_directory);
-	// expand ~ in extension directory
-	extension_directory = fs.ExpandPath(extension_directory);
-	return extension_directory;
-}
-
-string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs) {
-#ifdef WASM_LOADABLE_EXTENSIONS
-	throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm");
-#endif
-	string extension_directory = GetExtensionDirectoryPath(db, fs);
-	{
-		if (!fs.DirectoryExists(extension_directory)) {
-			auto sep = fs.PathSeparator(extension_directory);
-			auto splits = StringUtil::Split(extension_directory, sep);
-			D_ASSERT(!splits.empty());
-			string extension_directory_prefix;
-			if (StringUtil::StartsWith(extension_directory, sep)) {
-				extension_directory_prefix = sep; // this is swallowed by Split otherwise
-			}
-			for (auto &split : splits) {
-				extension_directory_prefix = extension_directory_prefix + split + sep;
-				if (!fs.DirectoryExists(extension_directory_prefix)) {
-					fs.CreateDirectory(extension_directory_prefix);
-				}
-			}
-		}
-	}
-	D_ASSERT(fs.DirectoryExists(extension_directory));
-
-	auto path_components = PathComponents();
-	for (auto &path_ele : path_components) {
-		extension_directory = fs.JoinPath(extension_directory, path_ele);
-		if (!fs.DirectoryExists(extension_directory)) {
-			fs.CreateDirectory(extension_directory);
-		}
-	}
-	return extension_directory;
-}
-
-string ExtensionHelper::ExtensionDirectory(ClientContext &context) {
-	auto &db = DatabaseInstance::GetDatabase(context);
-	auto &fs = FileSystem::GetFileSystem(context);
-	return ExtensionDirectory(db, fs);
-}
-
-bool ExtensionHelper::CreateSuggestions(const string &extension_name, string &message) {
-	auto lowercase_extension_name = StringUtil::Lower(extension_name);
-	vector<string> candidates;
-	for (idx_t ext_count = ExtensionHelper::DefaultExtensionCount(), i = 0; i < ext_count; i++) {
-		candidates.emplace_back(ExtensionHelper::GetDefaultExtension(i).name);
-	}
-	for (idx_t ext_count = ExtensionHelper::ExtensionAliasCount(), i = 0; i < ext_count; i++) {
-		candidates.emplace_back(ExtensionHelper::GetExtensionAlias(i).alias);
-	}
-	auto closest_extensions = StringUtil::TopNJaroWinkler(candidates, lowercase_extension_name);
-	message = StringUtil::CandidatesMessage(closest_extensions, "Candidate extensions");
-	for (auto &closest : closest_extensions) {
-		if (closest == lowercase_extension_name) {
-			message = "Extension \"" + extension_name + "\" is an existing extension.\n";
-			return true;
-		}
-	}
-	return false;
-}
-
-unique_ptr<ExtensionInstallInfo> ExtensionHelper::InstallExtension(DatabaseInstance &db, FileSystem &fs,
-                                                                   const string &extension,
-                                                                   ExtensionInstallOptions &options) {
-#ifdef WASM_LOADABLE_EXTENSIONS
-	// Install is currently a no-op
-	return nullptr;
-#endif
-	string local_path = ExtensionDirectory(db, fs);
-	return InstallExtensionInternal(db, fs, local_path, extension, options);
-}
-
-unique_ptr<ExtensionInstallInfo> ExtensionHelper::InstallExtension(ClientContext &context, const string &extension,
-                                                                   ExtensionInstallOptions &options) {
-#ifdef WASM_LOADABLE_EXTENSIONS
-	// Install is currently a no-op
-	return nullptr;
-#endif
-	auto &db = DatabaseInstance::GetDatabase(context);
-	auto &fs = FileSystem::GetFileSystem(context);
-	string local_path = ExtensionDirectory(context);
-	optional_ptr<HTTPLogger> http_logger =
-	    ClientConfig::GetConfig(context).enable_http_logging ? context.client_data->http_logger.get() : nullptr;
-	return InstallExtensionInternal(db, fs, local_path, extension, options, http_logger, context);
-}
-
-unsafe_unique_array<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
-	auto source_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
-	file_size = source_file->GetFileSize();
-	auto in_buffer = make_unsafe_uniq_array<data_t>(file_size);
-	source_file->Read(in_buffer.get(), file_size);
-	source_file->Close();
-	return in_buffer;
-}
-
-static void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, idx_t data_size) {
-	auto target_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_APPEND |
-	                                         FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
-	target_file->Write(data, data_size);
-	target_file->Close();
-	target_file.reset();
-}
-
-static void WriteExtensionMetadataFileToDisk(FileSystem &fs, const string &path, ExtensionInstallInfo &metadata) {
-	auto file_writer = BufferedFileWriter(fs, path);
-	BinarySerializer::Serialize(metadata, file_writer);
-	file_writer.Sync();
-}
-
-string ExtensionHelper::ExtensionUrlTemplate(optional_ptr<const DatabaseInstance> db,
-                                             const ExtensionRepository &repository, const string &version) {
-	string versioned_path;
-	if (!version.empty()) {
-		versioned_path = "/${NAME}/" + version + "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension";
-	} else {
-		versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension";
-	}
-#ifdef WASM_LOADABLE_EXTENSIONS
-	string default_endpoint = DEFAULT_REPOSITORY;
-	versioned_path = versioned_path + ".wasm";
-#else
-	string default_endpoint = ExtensionRepository::DEFAULT_REPOSITORY_URL;
-	versioned_path = versioned_path + CompressionExtensionFromType(FileCompressionType::GZIP);
-#endif
-	string url_template = repository.path + versioned_path;
-	return url_template;
-}
-
-string ExtensionHelper::ExtensionFinalizeUrlTemplate(const string &url_template, const string &extension_name) {
-	auto url = StringUtil::Replace(url_template, "${REVISION}", GetVersionDirectoryName());
-	url = StringUtil::Replace(url, "${PLATFORM}", DuckDB::Platform());
-	url = StringUtil::Replace(url, "${NAME}", extension_name);
-	return url;
-}
-
-static void CheckExtensionMetadataOnInstall(DatabaseInstance &db, void *in_buffer, idx_t file_size,
-                                            ExtensionInstallInfo &info, const string &extension_name) {
-	if (file_size < ParsedExtensionMetaData::FOOTER_SIZE) {
-		throw IOException("Failed to install '%s', file too small to be a valid DuckDB extension!", extension_name);
-	}
-
-	auto parsed_metadata = ExtensionHelper::ParseExtensionMetaData(static_cast<char *>(in_buffer) +
-	                                                               (file_size - ParsedExtensionMetaData::FOOTER_SIZE));
-
-	auto metadata_mismatch_error = parsed_metadata.GetInvalidMetadataError();
-
-	if (!metadata_mismatch_error.empty() && !db.config.options.allow_extensions_metadata_mismatch) {
-		throw IOException("Failed to install '%s'\n%s", extension_name, metadata_mismatch_error);
-	}
-
-	info.version = parsed_metadata.extension_version;
-}
-
-// Note: since this method is not atomic, this can fail in different ways, that should all be handled properly by
-// DuckDB:
-//   1. Crash after extension removal: extension is now uninstalled, metadata file still present
-//   2. Crash after metadata removal: extension is now uninstalled, extension dir is clean
-//   3. Crash after extension move: extension is now uninstalled, new metadata file present
-static void WriteExtensionFiles(FileSystem &fs, const string &temp_path, const string &local_extension_path,
-                                void *in_buffer, idx_t file_size, ExtensionInstallInfo &info) {
-	// Write extension to tmp file
-	WriteExtensionFileToDisk(fs, temp_path, in_buffer, file_size);
-
-	// Write metadata to tmp file
-	auto metadata_tmp_path = temp_path + ".info";
-	auto metadata_file_path = local_extension_path + ".info";
-	WriteExtensionMetadataFileToDisk(fs, metadata_tmp_path, info);
-
-	// First remove the local extension we are about to replace
-	if (fs.FileExists(local_extension_path)) {
-		fs.RemoveFile(local_extension_path);
-	}
-
-	// Then remove the old metadata file
-	if (fs.FileExists(metadata_file_path)) {
-		fs.RemoveFile(metadata_file_path);
-	}
-
-	fs.MoveFile(metadata_tmp_path, metadata_file_path);
-	fs.MoveFile(temp_path, local_extension_path);
-}
-
-// Install an extension using a filesystem
-static unique_ptr<ExtensionInstallInfo> DirectInstallExtension(DatabaseInstance &db, FileSystem &fs, const string &path,
-                                                               const string &temp_path, const string &extension_name,
-                                                               const string &local_extension_path,
-                                                               ExtensionInstallOptions &options,
-                                                               optional_ptr<ClientContext> context) {
-	string extension;
-	string file;
-	if (fs.IsRemoteFile(path, extension)) {
-		file = path;
-		// Try autoloading httpfs for loading extensions over https
-		if (context) {
-			auto &db = DatabaseInstance::GetDatabase(*context);
-			if (extension == "httpfs" && !db.ExtensionIsLoaded("httpfs") &&
-			    db.config.options.autoload_known_extensions) {
-				ExtensionHelper::AutoLoadExtension(*context, "httpfs");
-			}
-		}
-	} else {
-		file = fs.ConvertSeparators(path);
-	}
-
-	// Check if file exists
-	bool exists = fs.FileExists(file);
-
-	// Recheck without .gz
-	if (!exists && StringUtil::EndsWith(file, CompressionExtensionFromType(FileCompressionType::GZIP))) {
-		file = file.substr(0, file.size() - 3);
-		exists = fs.FileExists(file);
-	}
-
-	// Throw error on failure
-	if (!exists) {
-		if (!fs.IsRemoteFile(file)) {
-			throw IOException("Failed to copy local extension \"%s\" at PATH \"%s\"\n", extension_name, file);
-		}
-		if (StringUtil::StartsWith(file, "https://")) {
-			throw IOException("Failed to install remote extension \"%s\" from url \"%s\"", extension_name, file);
-		}
-	}
-
-	idx_t file_size;
-	auto in_buffer = ReadExtensionFileFromDisk(fs, file, file_size);
-
-	ExtensionInstallInfo info;
-
-	string decompressed_data;
-	void *extension_decompressed;
-	idx_t extension_decompressed_size;
-
-	if (GZipFileSystem::CheckIsZip(const_char_ptr_cast(in_buffer.get()), file_size)) {
-		decompressed_data = GZipFileSystem::UncompressGZIPString(const_char_ptr_cast(in_buffer.get()), file_size);
-		extension_decompressed = (void *)decompressed_data.data();
-		extension_decompressed_size = decompressed_data.size();
-	} else {
-		extension_decompressed = (void *)in_buffer.get();
-		extension_decompressed_size = file_size;
-	}
-
-	CheckExtensionMetadataOnInstall(db, extension_decompressed, extension_decompressed_size, info, extension_name);
-
-	if (!options.repository) {
-		info.mode = ExtensionInstallMode::CUSTOM_PATH;
-		info.full_path = file;
-	} else {
-		info.mode = ExtensionInstallMode::REPOSITORY;
-		info.full_path = file;
-		info.repository_url = options.repository->path;
-	}
-
-	WriteExtensionFiles(fs, temp_path, local_extension_path, extension_decompressed, extension_decompressed_size, info);
-
-	return make_uniq<ExtensionInstallInfo>(info);
-}
-
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-static unique_ptr<ExtensionInstallInfo> InstallFromHttpUrl(DatabaseInstance &db, const string &url,
-                                                           const string &extension_name, const string &temp_path,
-                                                           const string &local_extension_path,
-                                                           ExtensionInstallOptions &options,
-                                                           optional_ptr<HTTPLogger> http_logger) {
-	string no_http = StringUtil::Replace(url, "http://", "");
-
-	idx_t next = no_http.find('/', 0);
-	if (next == string::npos) {
-		throw IOException("No slash in URL template");
-	}
-
-	// Push the substring [last, next) on to splits
-	auto hostname_without_http = no_http.substr(0, next);
-	auto url_local_part = no_http.substr(next);
-
-	unique_ptr<ExtensionInstallInfo> install_info;
-	{
-		auto fs = FileSystem::CreateLocal();
-		if (fs->FileExists(local_extension_path + ".info")) {
-			try {
-				install_info =
-				    ExtensionInstallInfo::TryReadInfoFile(*fs, local_extension_path + ".info", extension_name);
-			} catch (...) {
-				if (!options.force_install) {
-					// We are going to rewrite the file anyhow, so this is fine
-					throw;
-				}
-			}
-		}
-	}
-
-	auto url_base = "http://" + hostname_without_http;
-	// FIXME: the retry logic should be unified with the retry logic in the httpfs client
-	static constexpr idx_t MAX_RETRY_COUNT = 3;
-	static constexpr uint64_t RETRY_WAIT_MS = 100;
-	static constexpr double RETRY_BACKOFF = 4;
-	idx_t retry_count = 0;
-	duckdb_httplib::Result res;
-	while (true) {
-		duckdb_httplib::Client cli(url_base.c_str());
-		if (!db.config.options.http_proxy.empty()) {
-			idx_t port;
-			string host;
-			HTTPUtil::ParseHTTPProxyHost(db.config.options.http_proxy, host, port);
-			cli.set_proxy(host, NumericCast<int>(port));
-		}
-
-		if (!db.config.options.http_proxy_username.empty() || !db.config.options.http_proxy_password.empty()) {
-			cli.set_proxy_basic_auth(db.config.options.http_proxy_username, db.config.options.http_proxy_password);
-		}
-
-		if (http_logger) {
-			cli.set_logger(http_logger->GetLogger<duckdb_httplib::Request, duckdb_httplib::Response>());
-		}
-
-		duckdb_httplib::Headers headers = {
-		    {"User-Agent", StringUtil::Format("%s %s", db.config.UserAgent(), DuckDB::SourceID())}};
-
-		if (options.use_etags && install_info && !install_info->etag.empty()) {
-			headers.insert({"If-None-Match", StringUtil::Format("%s", install_info->etag)});
-		}
-
-		res = cli.Get(url_local_part.c_str(), headers);
-		if (install_info && res && res->status == 304) {
-			return install_info;
-		}
-
-		if (res && res->status == 200) {
-			// success!
-			break;
-		}
-		// failure - check if we should retry
-		bool should_retry = false;
-		if (res.error() == duckdb_httplib::Error::Success) {
-			switch (res->status) {
-			case 408: // Request Timeout
-			case 418: // Server is pretending to be a teapot
-			case 429: // Rate limiter hit
-			case 500: // Server has error
-			case 503: // Server has error
-			case 504: // Server has error
-				should_retry = true;
-				break;
-			default:
-				break;
-			}
-		} else {
-			// always retry on duckdb_httplib::Error::Error
-			should_retry = true;
-		}
-		retry_count++;
-		if (!should_retry || retry_count >= MAX_RETRY_COUNT) {
-			// if we should not retry or exceeded the number of retries - bubble up the error
-			string message;
-			auto exact_match = ExtensionHelper::CreateSuggestions(extension_name, message);
-			if (exact_match && !ExtensionHelper::IsRelease(DuckDB::LibraryVersion())) {
-				message += "\nAre you using a development build? In this case, extensions might not (yet) be uploaded.";
-			}
-			if (res.error() == duckdb_httplib::Error::Success) {
-				throw HTTPException(res.value(), "Failed to download extension \"%s\" at URL \"%s%s\" (HTTP %n)\n%s",
-				                    extension_name, url_base, url_local_part, res->status, message);
-			} else {
-				throw IOException("Failed to download extension \"%s\" at URL \"%s%s\"\n%s (ERROR %s)", extension_name,
-				                  url_base, url_local_part, message, to_string(res.error()));
-			}
-		}
-#ifndef DUCKDB_NO_THREADS
-		// retry
-		// sleep first
-		uint64_t sleep_amount = static_cast<uint64_t>(static_cast<double>(RETRY_WAIT_MS) *
-		                                              pow(RETRY_BACKOFF, static_cast<double>(retry_count) - 1));
-		std::this_thread::sleep_for(std::chrono::milliseconds(sleep_amount));
-#endif
-	}
-	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
-
-	ExtensionInstallInfo info;
-	CheckExtensionMetadataOnInstall(db, (void *)decompressed_body.data(), decompressed_body.size(), info,
-	                                extension_name);
-	if (res->has_header("ETag")) {
-		info.etag = res->get_header_value("ETag");
-	}
-
-	if (options.repository) {
-		info.mode = ExtensionInstallMode::REPOSITORY;
-		info.full_path = url;
-		info.repository_url = options.repository->path;
-	} else {
-		info.mode = ExtensionInstallMode::CUSTOM_PATH;
-		info.full_path = url;
-	}
-
-	auto fs = FileSystem::CreateLocal();
-	WriteExtensionFiles(*fs, temp_path, local_extension_path, (void *)decompressed_body.data(),
-	                    decompressed_body.size(), info);
-
-	return make_uniq<ExtensionInstallInfo>(info);
-}
-
-// Install an extension using a hand-rolled http request
-static unique_ptr<ExtensionInstallInfo>
-InstallFromRepository(DatabaseInstance &db, FileSystem &fs, const string &url, const string &extension_name,
-                      const string &temp_path, const string &local_extension_path, ExtensionInstallOptions &options,
-                      optional_ptr<HTTPLogger> http_logger, optional_ptr<ClientContext> context) {
-	string url_template = ExtensionHelper::ExtensionUrlTemplate(db, *options.repository, options.version);
-	string generated_url = ExtensionHelper::ExtensionFinalizeUrlTemplate(url_template, extension_name);
-
-	// Special handling for http repository: avoid using regular filesystem (note: the filesystem is not used here)
-	if (StringUtil::StartsWith(options.repository->path, "http://")) {
-		return InstallFromHttpUrl(db, generated_url, extension_name, temp_path, local_extension_path, options,
-		                          http_logger);
-	}
-
-	// Default case, let the FileSystem figure it out
-	return DirectInstallExtension(db, fs, generated_url, temp_path, extension_name, local_extension_path, options,
-	                              context);
-}
-
-static bool IsHTTP(const string &path) {
-	return StringUtil::StartsWith(path, "http://") || !StringUtil::StartsWith(path, "https://");
-}
-
-static void ThrowErrorOnMismatchingExtensionOrigin(FileSystem &fs, const string &local_extension_path,
-                                                   const string &extension_name, const string &extension,
-                                                   optional_ptr<ExtensionRepository> repository) {
-	auto install_info = ExtensionInstallInfo::TryReadInfoFile(fs, local_extension_path + ".info", extension_name);
-
-	string format_string = "Installing extension '%s' failed. The extension is already installed "
-	                       "but the origin is different.\n"
-	                       "Currently installed extension is from %s '%s', while the extension to be "
-	                       "installed is from %s '%s'.\n"
-	                       "To solve this rerun this command with `FORCE INSTALL`";
-	string repo = "repository";
-	string custom_path = "custom_path";
-
-	if (install_info) {
-		if (install_info->mode == ExtensionInstallMode::REPOSITORY && repository &&
-		    install_info->repository_url != repository->path) {
-			throw InvalidInputException(format_string, extension_name, repo, install_info->repository_url, repo,
-			                            repository->path);
-		}
-		if (install_info->mode == ExtensionInstallMode::REPOSITORY && ExtensionHelper::IsFullPath(extension)) {
-			throw InvalidInputException(format_string, extension_name, repo, install_info->repository_url, custom_path,
-			                            extension);
-		}
-	}
-}
-#endif // DUCKDB_DISABLE_EXTENSION_LOAD
-
-unique_ptr<ExtensionInstallInfo>
-ExtensionHelper::InstallExtensionInternal(DatabaseInstance &db, FileSystem &fs, const string &local_path,
-                                          const string &extension, ExtensionInstallOptions &options,
-                                          optional_ptr<HTTPLogger> http_logger, optional_ptr<ClientContext> context) {
-#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
-	throw PermissionException("Installing external extensions is disabled through a compile time flag");
-#else
-	if (!db.config.options.enable_external_access) {
-		throw PermissionException("Installing extensions is disabled through configuration");
-	}
-
-	auto extension_name = ApplyExtensionAlias(fs.ExtractBaseName(extension));
-	string local_extension_path = fs.JoinPath(local_path, extension_name + ".duckdb_extension");
-	string temp_path = local_extension_path + ".tmp-" + UUID::ToString(UUID::GenerateRandomUUID());
-
-	if (fs.FileExists(local_extension_path) && !options.force_install) {
-		// File exists: throw error if origin mismatches
-		if (options.throw_on_origin_mismatch && !db.config.options.allow_extensions_metadata_mismatch &&
-		    fs.FileExists(local_extension_path + ".info")) {
-			ThrowErrorOnMismatchingExtensionOrigin(fs, local_extension_path, extension_name, extension,
-			                                       options.repository);
-		}
-
-		// File exists, but that's okay, install is now a NOP
-		return nullptr;
-	}
-
-	if (fs.FileExists(temp_path)) {
-		fs.RemoveFile(temp_path);
-	}
-
-	if (ExtensionHelper::IsFullPath(extension) && options.repository) {
-		throw InvalidInputException("Cannot pass both a repository and a full path url");
-	}
-
-	// Resolve default repository if there is none set
-	ExtensionRepository resolved_repository;
-	if (!ExtensionHelper::IsFullPath(extension) && !options.repository) {
-		resolved_repository = ExtensionRepository::GetDefaultRepository(db.config);
-		options.repository = resolved_repository;
-	}
-
-	// Install extension from local, direct url
-	if (ExtensionHelper::IsFullPath(extension) && !IsHTTP(extension)) {
-		LocalFileSystem local_fs;
-		return DirectInstallExtension(db, local_fs, extension, temp_path, extension, local_extension_path, options,
-		                              context);
-	}
-
-	// Install extension from local url based on a repository (Note that this will install it as a local file)
-	if (options.repository && !IsHTTP(options.repository->path)) {
-		LocalFileSystem local_fs;
-		return InstallFromRepository(db, fs, extension, extension_name, temp_path, local_extension_path, options,
-		                             http_logger, context);
-	}
-
-#ifdef DISABLE_DUCKDB_REMOTE_INSTALL
-	throw BinderException("Remote extension installation is disabled through configuration");
-#else
-
-	// Full path direct installation
-	if (IsFullPath(extension)) {
-		if (StringUtil::StartsWith(extension, "http://")) {
-			// HTTP takes separate path to avoid dependency on httpfs extension
-			return InstallFromHttpUrl(db, extension, extension_name, temp_path, local_extension_path, options,
-			                          http_logger);
-		}
-
-		// Direct installation from local or remote path
-		return DirectInstallExtension(db, fs, extension, temp_path, extension, local_extension_path, options, context);
-	}
-
-	// Repository installation
-	return InstallFromRepository(db, fs, extension, extension_name, temp_path, local_extension_path, options,
-	                             http_logger, context);
-#endif
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension/extension_load.cpp b/src/duckdb/src/main/extension/extension_load.cpp
deleted file mode 100644
index 23101f722..000000000
--- a/src/duckdb/src/main/extension/extension_load.cpp
+++ /dev/null
@@ -1,624 +0,0 @@
-#include "duckdb.h"
-#include "duckdb/common/dl.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/virtual_file_system.hpp"
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/main/capi/extension_api.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "mbedtls_wrapper.hpp"
-
-#ifndef DUCKDB_NO_THREADS
-#include <thread>
-#endif // DUCKDB_NO_THREADS
-
-#ifdef WASM_LOADABLE_EXTENSIONS
-#include <emscripten.h>
-#endif
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Extension C API
-//===--------------------------------------------------------------------===//
-
-//! State that is kept during the load phase of a C API extension
-struct DuckDBExtensionLoadState {
-	explicit DuckDBExtensionLoadState(DatabaseInstance &db_p, ExtensionInitResult &init_result_p)
-	    : db(db_p), init_result(init_result_p), database_data(nullptr) {
-	}
-
-	//! Create a DuckDBExtensionLoadState reference from a C API opaque pointer
-	static DuckDBExtensionLoadState &Get(duckdb_extension_info info) {
-		D_ASSERT(info);
-		return *reinterpret_cast<duckdb::DuckDBExtensionLoadState *>(info);
-	}
-
-	//! Convert to an opaque C API pointer
-	duckdb_extension_info ToCStruct() {
-		return reinterpret_cast<duckdb_extension_info>(this);
-	}
-
-	//! Ref to the database being loaded
-	DatabaseInstance &db;
-
-	//! The init result from initializing the extension
-	ExtensionInitResult &init_result;
-
-	//! This is the duckdb_database struct that will be passed to the extension during initialization. Note that the
-	//! extension does not need to free it.
-	unique_ptr<DatabaseWrapper> database_data;
-
-	//! The function pointer struct passed to the extension. The extension is expected to copy this struct during
-	//! initialization
-	duckdb_ext_api_v1 api_struct;
-
-	//! Error handling
-	bool has_error = false;
-	//! The stored error from the loading process
-	ErrorData error_data;
-};
-
-//! Contains the callbacks that are passed to CAPI extensions to allow initialization
-struct ExtensionAccess {
-	//! Create the struct of function pointers to pass to the extension for initialization
-	static duckdb_extension_access CreateAccessStruct() {
-		return {SetError, GetDatabase, GetAPI};
-	}
-
-	//! Called by the extension to indicate failure to initialize the extension
-	static void SetError(duckdb_extension_info info, const char *error) {
-		auto &load_state = DuckDBExtensionLoadState::Get(info);
-
-		if (error) {
-			load_state.has_error = true;
-			load_state.error_data = ErrorData(error);
-		} else {
-			load_state.has_error = true;
-			load_state.error_data = ErrorData(
-			    ExceptionType::UNKNOWN_TYPE,
-			    "Extension has indicated an error occured during initialization, but did not set an error message.");
-		}
-	}
-
-	//! Called by the extension get a pointer to the database that is loading it
-	static duckdb_database *GetDatabase(duckdb_extension_info info) {
-		auto &load_state = DuckDBExtensionLoadState::Get(info);
-
-		try {
-			// Create the duckdb_database
-			load_state.database_data = make_uniq<DatabaseWrapper>();
-			load_state.database_data->database = make_shared_ptr<DuckDB>(load_state.db);
-			return reinterpret_cast<duckdb_database *>(load_state.database_data.get());
-		} catch (std::exception &ex) {
-			load_state.error_data = ErrorData(ex);
-			return nullptr;
-		} catch (...) {
-			load_state.error_data =
-			    ErrorData(ExceptionType::UNKNOWN_TYPE, "Unknown error in GetDatabase when trying to load extension!");
-			return nullptr;
-		}
-	}
-
-	//! Called by the extension get a pointer the correctly versioned extension C API struct.
-	static const void *GetAPI(duckdb_extension_info info, const char *version) {
-		string version_string = version;
-		auto &load_state = DuckDBExtensionLoadState::Get(info);
-
-		if (load_state.init_result.abi_type == ExtensionABIType::C_STRUCT) {
-			idx_t major, minor, patch;
-			auto parsed = VersioningUtils::ParseSemver(version_string, major, minor, patch);
-
-			if (!parsed || !VersioningUtils::IsSupportedCAPIVersion(major, minor, patch)) {
-				load_state.has_error = true;
-				load_state.error_data = ErrorData(
-				    ExceptionType::UNKNOWN_TYPE,
-				    "Unsupported C CAPI version detected during extension initialization: " + string(version));
-				return nullptr;
-			}
-		} else if (load_state.init_result.abi_type == ExtensionABIType::C_STRUCT_UNSTABLE) {
-			// NOTE: we currently don't check anything here: the version of extensions of ABI type C_STRUCT_UNSTABLE is
-			// ignored because C_STRUCT_UNSTABLE extensions are tied 1:1 to duckdb verions meaning they will always
-			// receive the whole function pointer struct
-		} else {
-			load_state.has_error = true;
-			load_state.error_data =
-			    ErrorData(ExceptionType::UNKNOWN_TYPE,
-			              StringUtil::Format("Unknown ABI Type '%s' found when loading extension '%s'",
-			                                 load_state.init_result.abi_type, load_state.init_result.filename));
-			return nullptr;
-		}
-
-		load_state.api_struct = load_state.db.GetExtensionAPIV1();
-		return &load_state.api_struct;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Load External Extension
-//===--------------------------------------------------------------------===//
-#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-// The C++ init function
-typedef void (*ext_init_fun_t)(DatabaseInstance &);
-// The C init function
-typedef bool (*ext_init_c_api_fun_t)(duckdb_extension_info info, duckdb_extension_access *access);
-typedef const char *(*ext_version_fun_t)(void);
-typedef bool (*ext_is_storage_t)(void);
-
-template <class T>
-static T LoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
-	auto function = dlsym(dll, function_name.c_str());
-	if (!function) {
-		throw IOException("File \"%s\" did not contain function \"%s\": %s", filename, function_name, GetDLError());
-	}
-	return (T)function;
-}
-#endif
-
-template <class T>
-static T TryLoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
-	auto function = dlsym(dll, function_name.c_str());
-	if (!function) {
-		return nullptr;
-	}
-	return (T)function;
-}
-
-static void ComputeSHA256String(const string &to_hash, string *res) {
-	// Invoke MbedTls function to actually compute sha256
-	*res = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(to_hash);
-}
-
-static void ComputeSHA256FileSegment(FileHandle *handle, const idx_t start, const idx_t end, string *res) {
-	idx_t iter = start;
-	const idx_t segment_size = 1024ULL * 8ULL;
-
-	duckdb_mbedtls::MbedTlsWrapper::SHA256State state;
-
-	string to_hash;
-	while (iter < end) {
-		idx_t len = std::min(end - iter, segment_size);
-		to_hash.resize(len);
-		handle->Read((void *)to_hash.data(), len, iter);
-
-		state.AddString(to_hash);
-
-		iter += segment_size;
-	}
-
-	*res = state.Finalize();
-}
-
-static string FilterZeroAtEnd(string s) {
-	while (!s.empty() && s.back() == '\0') {
-		s.pop_back();
-	}
-	return s;
-}
-
-ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(const char *metadata) noexcept {
-	ParsedExtensionMetaData result;
-
-	vector<string> metadata_field;
-	for (idx_t i = 0; i < 8; i++) {
-		string field = string(metadata + i * 32, 32);
-		metadata_field.emplace_back(field);
-	}
-
-	std::reverse(metadata_field.begin(), metadata_field.end());
-
-	// Fetch the magic value and early out if this is invalid: the rest will just be bogus
-	result.magic_value = FilterZeroAtEnd(metadata_field[0]);
-	if (!result.AppearsValid()) {
-		return result;
-	}
-
-	result.platform = FilterZeroAtEnd(metadata_field[1]);
-
-	result.extension_version = FilterZeroAtEnd(metadata_field[3]);
-
-	auto extension_abi_metadata = FilterZeroAtEnd(metadata_field[4]);
-
-	if (extension_abi_metadata == "C_STRUCT") {
-		result.abi_type = ExtensionABIType::C_STRUCT;
-		result.duckdb_capi_version = FilterZeroAtEnd(metadata_field[2]);
-	} else if (extension_abi_metadata == "C_STRUCT_UNSTABLE") {
-		result.abi_type = ExtensionABIType::C_STRUCT_UNSTABLE;
-		result.duckdb_version = FilterZeroAtEnd(metadata_field[2]);
-	} else if (extension_abi_metadata == "CPP" || extension_abi_metadata.empty()) {
-		result.abi_type = ExtensionABIType::CPP;
-		result.duckdb_version = FilterZeroAtEnd(metadata_field[2]);
-	} else {
-		result.abi_type = ExtensionABIType::UNKNOWN;
-		result.duckdb_version = "unknown";
-		result.extension_abi_metadata = extension_abi_metadata;
-	}
-
-	result.signature = string(metadata, ParsedExtensionMetaData::FOOTER_SIZE - ParsedExtensionMetaData::SIGNATURE_SIZE);
-	return result;
-}
-
-ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(FileHandle &handle) {
-	const string engine_version = string(ExtensionHelper::GetVersionDirectoryName());
-	const string engine_platform = string(DuckDB::Platform());
-
-	string metadata_segment;
-	metadata_segment.resize(ParsedExtensionMetaData::FOOTER_SIZE);
-
-	if (handle.GetFileSize() < ParsedExtensionMetaData::FOOTER_SIZE) {
-		throw InvalidInputException(
-		    "File '%s' is not a DuckDB extension. Valid DuckDB extensions must be at least %llu bytes", handle.path,
-		    ParsedExtensionMetaData::FOOTER_SIZE);
-	}
-
-	handle.Read((void *)metadata_segment.data(), metadata_segment.size(),
-	            handle.GetFileSize() - ParsedExtensionMetaData::FOOTER_SIZE);
-
-	return ParseExtensionMetaData(metadata_segment.data());
-}
-
-bool ExtensionHelper::CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata,
-                                              const bool allow_community_extensions) {
-	auto signature_offset = handle.GetFileSize() - ParsedExtensionMetaData::SIGNATURE_SIZE;
-
-	const idx_t maxLenChunks = 1024ULL * 1024ULL;
-	const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks;
-	vector<string> hash_chunks(numChunks);
-	vector<idx_t> splits(numChunks + 1);
-
-	for (idx_t i = 0; i < numChunks; i++) {
-		splits[i] = maxLenChunks * i;
-	}
-	splits.back() = signature_offset;
-
-#ifndef DUCKDB_NO_THREADS
-	vector<std::thread> threads;
-	threads.reserve(numChunks);
-	for (idx_t i = 0; i < numChunks; i++) {
-		threads.emplace_back(ComputeSHA256FileSegment, &handle, splits[i], splits[i + 1], &hash_chunks[i]);
-	}
-
-	for (auto &thread : threads) {
-		thread.join();
-	}
-#else
-	for (idx_t i = 0; i < numChunks; i++) {
-		ComputeSHA256FileSegment(&handle, splits[i], splits[i + 1], &hash_chunks[i]);
-	}
-#endif // DUCKDB_NO_THREADS
-
-	string hash_concatenation;
-	hash_concatenation.reserve(32 * numChunks); // 256 bits -> 32 bytes per chunk
-
-	for (auto &hash_chunk : hash_chunks) {
-		hash_concatenation += hash_chunk;
-	}
-
-	string two_level_hash;
-	ComputeSHA256String(hash_concatenation, &two_level_hash);
-
-	// TODO maybe we should do a stream read / hash update here
-	handle.Read((void *)parsed_metadata.signature.data(), parsed_metadata.signature.size(), signature_offset);
-
-	for (auto &key : ExtensionHelper::GetPublicKeys(allow_community_extensions)) {
-		if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, parsed_metadata.signature, two_level_hash)) {
-			return true;
-			break;
-		}
-	}
-
-	return false;
-}
-
-bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension,
-                                     ExtensionInitResult &result, string &error) {
-#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
-	throw PermissionException("Loading external extensions is disabled through a compile time flag");
-#else
-	if (!db.config.options.enable_external_access) {
-		throw PermissionException("Loading external extensions is disabled through configuration");
-	}
-	auto filename = fs.ConvertSeparators(extension);
-
-	bool direct_load;
-
-	// shorthand case
-	if (!ExtensionHelper::IsFullPath(extension)) {
-		direct_load = false;
-		string extension_name = ApplyExtensionAlias(extension);
-#ifdef WASM_LOADABLE_EXTENSIONS
-		string url_template = ExtensionUrlTemplate(&config, "");
-		string url = ExtensionFinalizeUrlTemplate(url_template, extension_name);
-
-		char *str = (char *)EM_ASM_PTR(
-		    {
-			    var jsString = ((typeof runtime == 'object') && runtime && (typeof runtime.whereToLoad == 'function') &&
-			                    runtime.whereToLoad)
-			                       ? runtime.whereToLoad(UTF8ToString($0))
-			                       : (UTF8ToString($1));
-			    var lengthBytes = lengthBytesUTF8(jsString) + 1;
-			    // 'jsString.length' would return the length of the string as UTF-16
-			    // units, but Emscripten C strings operate as UTF-8.
-			    var stringOnWasmHeap = _malloc(lengthBytes);
-			    stringToUTF8(jsString, stringOnWasmHeap, lengthBytes);
-			    return stringOnWasmHeap;
-		    },
-		    filename.c_str(), url.c_str());
-		string address(str);
-		free(str);
-
-		filename = address;
-#else
-
-		string local_path = !db.config.options.extension_directory.empty()
-		                        ? db.config.options.extension_directory
-		                        : ExtensionHelper::DefaultExtensionFolder(fs);
-
-		// convert random separators to platform-canonic
-		local_path = fs.ConvertSeparators(local_path);
-		// expand ~ in extension directory
-		local_path = fs.ExpandPath(local_path);
-		auto path_components = PathComponents();
-		for (auto &path_ele : path_components) {
-			local_path = fs.JoinPath(local_path, path_ele);
-		}
-		filename = fs.JoinPath(local_path, extension_name + ".duckdb_extension");
-#endif
-	} else {
-		direct_load = true;
-		filename = fs.ExpandPath(filename);
-	}
-	if (!fs.FileExists(filename)) {
-		string message;
-		bool exact_match = ExtensionHelper::CreateSuggestions(extension, message);
-		if (exact_match) {
-			message += "\nInstall it first using \"INSTALL " + extension + "\".";
-		}
-		error = StringUtil::Format("Extension \"%s\" not found.\n%s", filename, message);
-		return false;
-	}
-
-	auto handle = fs.OpenFile(filename, FileFlags::FILE_FLAGS_READ);
-
-	// Parse the extension metadata from the extension binary
-	auto parsed_metadata = ParseExtensionMetaData(*handle);
-
-	auto metadata_mismatch_error = parsed_metadata.GetInvalidMetadataError();
-
-	if (!metadata_mismatch_error.empty()) {
-		metadata_mismatch_error = StringUtil::Format("Failed to load '%s', %s", extension, metadata_mismatch_error);
-	}
-
-	if (!db.config.options.allow_unsigned_extensions) {
-		bool signature_valid;
-		if (parsed_metadata.AppearsValid()) {
-			signature_valid =
-			    CheckExtensionSignature(*handle, parsed_metadata, db.config.options.allow_community_extensions);
-		} else {
-			signature_valid = false;
-		}
-
-		if (!signature_valid) {
-			throw IOException(db.config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename) +
-			                  metadata_mismatch_error);
-		}
-
-		if (!metadata_mismatch_error.empty()) {
-			// Signed extensions perform the full check
-			throw InvalidInputException(metadata_mismatch_error);
-		}
-	} else if (!db.config.options.allow_extensions_metadata_mismatch) {
-		if (!metadata_mismatch_error.empty()) {
-			// Unsigned extensions AND configuration allowing n, loading allowed, mainly for
-			// debugging purposes
-			throw InvalidInputException(metadata_mismatch_error);
-		}
-	}
-
-	auto filebase = fs.ExtractBaseName(filename);
-
-#ifdef WASM_LOADABLE_EXTENSIONS
-	EM_ASM(
-	    {
-		    // Next few lines should argubly in separate JavaScript-land function call
-		    // TODO: move them out / have them configurable
-		    const xhr = new XMLHttpRequest();
-		    xhr.open("GET", UTF8ToString($0), false);
-		    xhr.responseType = "arraybuffer";
-		    xhr.send(null);
-		    var uInt8Array = xhr.response;
-		    WebAssembly.validate(uInt8Array);
-		    console.log('Loading extension ', UTF8ToString($1));
-
-		    // Here we add the uInt8Array to Emscripten's filesystem, for it to be found by dlopen
-		    FS.writeFile(UTF8ToString($1), new Uint8Array(uInt8Array));
-	    },
-	    filename.c_str(), filebase.c_str());
-	auto dopen_from = filebase;
-#else
-	auto dopen_from = filename;
-#endif
-
-	auto lib_hdl = dlopen(dopen_from.c_str(), RTLD_NOW | RTLD_LOCAL);
-	if (!lib_hdl) {
-		throw IOException("Extension \"%s\" could not be loaded: %s", filename, GetDLError());
-	}
-
-	auto lowercase_extension_name = StringUtil::Lower(filebase);
-
-	// Initialize the ExtensionInitResult
-	result.filebase = lowercase_extension_name;
-	result.filename = filename;
-	result.lib_hdl = lib_hdl;
-	result.abi_type = parsed_metadata.abi_type;
-
-	if (!direct_load) {
-		auto info_file_name = filename + ".info";
-
-		result.install_info = ExtensionInstallInfo::TryReadInfoFile(fs, info_file_name, lowercase_extension_name);
-
-		if (result.install_info->mode == ExtensionInstallMode::UNKNOWN) {
-			// The info file was missing, we just set the version, since we have it from the parsed footer
-			result.install_info->version = parsed_metadata.extension_version;
-		}
-
-		if (result.install_info->version != parsed_metadata.extension_version) {
-			throw IOException("Metadata mismatch detected when loading extension '%s'\nPlease try reinstalling the "
-			                  "extension using `FORCE INSTALL '%s'`",
-			                  filename, extension);
-		}
-	} else {
-		result.install_info = make_uniq<ExtensionInstallInfo>();
-		result.install_info->mode = ExtensionInstallMode::NOT_INSTALLED;
-		result.install_info->full_path = filename;
-		result.install_info->version = parsed_metadata.extension_version;
-	}
-
-	return true;
-#endif
-}
-
-ExtensionInitResult ExtensionHelper::InitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension) {
-	string error;
-	ExtensionInitResult result;
-	if (!TryInitialLoad(db, fs, extension, result, error)) {
-		if (!ExtensionHelper::AllowAutoInstall(extension)) {
-			throw IOException(error);
-		}
-		// the extension load failed - try installing the extension
-		ExtensionInstallOptions options;
-		ExtensionHelper::InstallExtension(db, fs, extension, options);
-		// try loading again
-		if (!TryInitialLoad(db, fs, extension, result, error)) {
-			throw IOException(error);
-		}
-	}
-	return result;
-}
-
-bool ExtensionHelper::IsFullPath(const string &extension) {
-	return StringUtil::Contains(extension, ".") || StringUtil::Contains(extension, "/") ||
-	       StringUtil::Contains(extension, "\\");
-}
-
-string ExtensionHelper::GetExtensionName(const string &original_name) {
-	auto extension = StringUtil::Lower(original_name);
-	if (!IsFullPath(extension)) {
-		return ExtensionHelper::ApplyExtensionAlias(extension);
-	}
-	auto splits = StringUtil::Split(StringUtil::Replace(extension, "\\", "/"), '/');
-	if (splits.empty()) {
-		return ExtensionHelper::ApplyExtensionAlias(extension);
-	}
-	splits = StringUtil::Split(splits.back(), '.');
-	if (splits.empty()) {
-		return ExtensionHelper::ApplyExtensionAlias(extension);
-	}
-	return ExtensionHelper::ApplyExtensionAlias(splits.front());
-}
-
-void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension) {
-	if (db.ExtensionIsLoaded(extension)) {
-		return;
-	}
-#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
-	throw PermissionException("Loading external extensions is disabled through a compile time flag");
-#else
-	auto extension_init_result = InitialLoad(db, fs, extension);
-
-	// C++ ABI
-	if (extension_init_result.abi_type == ExtensionABIType::CPP) {
-		auto init_fun_name = extension_init_result.filebase + "_init";
-		ext_init_fun_t init_fun = TryLoadFunctionFromDLL<ext_init_fun_t>(extension_init_result.lib_hdl, init_fun_name,
-		                                                                 extension_init_result.filename);
-		if (!init_fun) {
-			throw IOException("Extension '%s' did not contain the expected entrypoint function '%s'", extension,
-			                  init_fun_name);
-		}
-
-		try {
-			(*init_fun)(db);
-		} catch (std::exception &e) {
-			ErrorData error(e);
-			throw InvalidInputException("Initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"",
-			                            init_fun_name, extension_init_result.filename, error.RawMessage());
-		}
-
-		D_ASSERT(extension_init_result.install_info);
-
-		db.SetExtensionLoaded(extension, *extension_init_result.install_info);
-		return;
-	}
-
-	// C ABI
-	if (extension_init_result.abi_type == ExtensionABIType::C_STRUCT ||
-	    extension_init_result.abi_type == ExtensionABIType::C_STRUCT_UNSTABLE) {
-		auto init_fun_name = extension_init_result.filebase + "_init_c_api";
-		ext_init_c_api_fun_t init_fun_capi = TryLoadFunctionFromDLL<ext_init_c_api_fun_t>(
-		    extension_init_result.lib_hdl, init_fun_name, extension_init_result.filename);
-
-		if (!init_fun_capi) {
-			throw IOException("File \"%s\" did not contain function \"%s\": %s", extension_init_result.filename,
-			                  init_fun_name, GetDLError());
-		}
-		// Create the load state
-		DuckDBExtensionLoadState load_state(db, extension_init_result);
-
-		auto access = ExtensionAccess::CreateAccessStruct();
-		auto result = (*init_fun_capi)(load_state.ToCStruct(), &access);
-
-		// Throw any error that the extension might have encountered
-		if (load_state.has_error) {
-			load_state.error_data.Throw("An error was thrown during initialization of the extension '" + extension +
-			                            "': ");
-		}
-
-		// Extensions are expected to either set an error or return true indicating successful initialization
-		if (result == false) {
-			throw FatalException(
-			    "Extension '%s' failed to initialize but did not return an error. This indicates an "
-			    "error in the extension: C API extensions should return a boolean `true` to indicate succesful "
-			    "initialization. "
-			    "This means that the Extension may be partially initialized resulting in an inconsistent state of "
-			    "DuckDB.",
-			    extension);
-		}
-
-		D_ASSERT(extension_init_result.install_info);
-
-		db.SetExtensionLoaded(extension, *extension_init_result.install_info);
-		return;
-	}
-
-	throw IOException("Unknown ABI type '%s' for extension '%s'", extension_init_result.abi_type, extension);
-#endif
-}
-
-void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string &extension) {
-	LoadExternalExtension(DatabaseInstance::GetDatabase(context), FileSystem::GetFileSystem(context), extension);
-}
-
-string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {
-	auto first_colon = path.find(':');
-	if (first_colon == string::npos || first_colon < 2) { // needs to be at least two characters because windows c: ...
-		return "";
-	}
-	auto extension = path.substr(0, first_colon);
-
-	if (path.substr(first_colon, 3) == "://") {
-		// these are not extensions
-		return "";
-	}
-
-	D_ASSERT(extension.size() > 1);
-	// needs to be alphanumeric
-	for (auto &ch : extension) {
-		if (!isalnum(ch) && ch != '_') {
-			return "";
-		}
-	}
-	return extension;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension/extension_util.cpp b/src/duckdb/src/main/extension/extension_util.cpp
deleted file mode 100644
index 65e099d7e..000000000
--- a/src/duckdb/src/main/extension/extension_util.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#include "duckdb/main/extension_util.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/main/database.hpp"
-
-namespace duckdb {
-
-void ExtensionUtil::RegisterExtension(DatabaseInstance &db, const string &name,
-                                      const ExtensionLoadedInfo &description) {
-
-	db.AddExtensionInfo(name, description);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction function) {
-	ScalarFunctionSet set(function.name);
-	set.AddFunction(std::move(function));
-	RegisterFunction(db, std::move(set));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunctionSet set) {
-	CreateScalarFunctionInfo info(std::move(set));
-	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
-	RegisterFunction(db, std::move(info));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateScalarFunctionInfo info) {
-	D_ASSERT(!info.functions.name.empty());
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreateFunction(data, info);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunction function) {
-	AggregateFunctionSet set(function.name);
-	set.AddFunction(std::move(function));
-	RegisterFunction(db, std::move(set));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunctionSet set) {
-	CreateAggregateFunctionInfo info(std::move(set));
-	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
-	RegisterFunction(db, std::move(info));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateAggregateFunctionInfo info) {
-	D_ASSERT(!info.functions.name.empty());
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreateFunction(data, info);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateSecretFunction function) {
-	D_ASSERT(!function.secret_type.empty());
-	auto &config = DBConfig::GetConfig(db);
-	config.secret_manager->RegisterSecretFunction(std::move(function), OnCreateConflict::ERROR_ON_CONFLICT);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction function) {
-	TableFunctionSet set(function.name);
-	set.AddFunction(std::move(function));
-	RegisterFunction(db, std::move(set));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunctionSet function) {
-	D_ASSERT(!function.name.empty());
-	CreateTableFunctionInfo info(std::move(function));
-	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
-	RegisterFunction(db, std::move(info));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateTableFunctionInfo info) {
-	D_ASSERT(!info.functions.name.empty());
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreateFunction(data, info);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunction function) {
-	D_ASSERT(!function.name.empty());
-	PragmaFunctionSet set(function.name);
-	set.AddFunction(std::move(function));
-	RegisterFunction(db, std::move(set));
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function) {
-	D_ASSERT(!function.name.empty());
-	auto function_name = function.name;
-	CreatePragmaFunctionInfo info(std::move(function_name), std::move(function));
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreatePragmaFunction(data, info);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CopyFunction function) {
-	CreateCopyFunctionInfo info(std::move(function));
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreateCopyFunction(data, info);
-}
-
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info) {
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreateFunction(data, info);
-}
-
-void ExtensionUtil::RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info) {
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	system_catalog.CreateCollation(data, info);
-
-	// Also register as a function for serialisation
-	CreateScalarFunctionInfo finfo(info.function);
-	finfo.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	system_catalog.CreateFunction(data, finfo);
-}
-
-void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, ScalarFunction function) {
-	auto &scalar_function = ExtensionUtil::GetFunction(db, function.name);
-	scalar_function.functions.AddFunction(std::move(function));
-}
-
-void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet functions) { // NOLINT
-	D_ASSERT(!functions.name.empty());
-	auto &scalar_function = ExtensionUtil::GetFunction(db, functions.name);
-	for (auto &function : functions.functions) {
-		function.name = functions.name;
-		scalar_function.functions.AddFunction(std::move(function));
-	}
-}
-
-void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, TableFunctionSet functions) { // NOLINT
-	auto &table_function = ExtensionUtil::GetTableFunction(db, functions.name);
-	for (auto &function : functions.functions) {
-		function.name = functions.name;
-		table_function.functions.AddFunction(std::move(function));
-	}
-}
-
-optional_ptr<CatalogEntry> TryGetEntry(DatabaseInstance &db, const string &name, CatalogType type) {
-	D_ASSERT(!name.empty());
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
-	return schema.GetEntry(data, type, name);
-}
-
-optional_ptr<CatalogEntry> ExtensionUtil::TryGetFunction(DatabaseInstance &db, const string &name) {
-	return TryGetEntry(db, name, CatalogType::SCALAR_FUNCTION_ENTRY);
-}
-
-ScalarFunctionCatalogEntry &ExtensionUtil::GetFunction(DatabaseInstance &db, const string &name) {
-	auto catalog_entry = TryGetFunction(db, name);
-	if (!catalog_entry) {
-		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetFunction", name);
-	}
-	return catalog_entry->Cast<ScalarFunctionCatalogEntry>();
-}
-
-optional_ptr<CatalogEntry> ExtensionUtil::TryGetTableFunction(DatabaseInstance &db, const string &name) {
-	return TryGetEntry(db, name, CatalogType::TABLE_FUNCTION_ENTRY);
-}
-
-TableFunctionCatalogEntry &ExtensionUtil::GetTableFunction(DatabaseInstance &db, const string &name) {
-	auto catalog_entry = TryGetTableFunction(db, name);
-	if (!catalog_entry) {
-		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetTableFunction", name);
-	}
-	return catalog_entry->Cast<TableFunctionCatalogEntry>();
-}
-
-void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
-                                 bind_logical_type_function_t bind_modifiers) {
-	D_ASSERT(!type_name.empty());
-	CreateTypeInfo info(std::move(type_name), std::move(type), bind_modifiers);
-	info.temporary = true;
-	info.internal = true;
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	system_catalog.CreateType(data, info);
-}
-
-void ExtensionUtil::RegisterSecretType(DatabaseInstance &db, SecretType secret_type) {
-	auto &config = DBConfig::GetConfig(db);
-	config.secret_manager->RegisterSecretType(secret_type);
-}
-
-void ExtensionUtil::RegisterCastFunction(DatabaseInstance &db, const LogicalType &source, const LogicalType &target,
-                                         BoundCastInfo function, int64_t implicit_cast_cost) {
-	auto &config = DBConfig::GetConfig(db);
-	auto &casts = config.GetCastFunctions();
-	casts.RegisterCastFunction(source, target, std::move(function), implicit_cast_cost);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/extension_install_info.cpp b/src/duckdb/src/main/extension_install_info.cpp
deleted file mode 100644
index 8c9e69e00..000000000
--- a/src/duckdb/src/main/extension_install_info.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/main/extension_install_info.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-
-namespace duckdb {
-
-string ExtensionRepository::GetRepository(const string &repository_url) {
-	auto resolved_repository = TryConvertUrlToKnownRepository(repository_url);
-	if (resolved_repository.empty()) {
-		return repository_url;
-	}
-	return resolved_repository;
-}
-
-string ExtensionRepository::TryGetRepositoryUrl(const string &repository) {
-	if (repository == "core") {
-		return CORE_REPOSITORY_URL;
-	} else if (repository == "core_nightly") {
-		return CORE_NIGHTLY_REPOSITORY_URL;
-	} else if (repository == "community") {
-		return COMMUNITY_REPOSITORY_URL;
-	} else if (repository == "local_build_debug") {
-		return BUILD_DEBUG_REPOSITORY_PATH;
-	} else if (repository == "local_build_release") {
-		return BUILD_RELEASE_REPOSITORY_PATH;
-	}
-	return "";
-}
-
-string ExtensionRepository::TryConvertUrlToKnownRepository(const string &url) {
-	if (url == CORE_REPOSITORY_URL) {
-		return "core";
-	} else if (url == CORE_NIGHTLY_REPOSITORY_URL) {
-		return "core_nightly";
-	} else if (url == COMMUNITY_REPOSITORY_URL) {
-		return "community";
-	} else if (url == BUILD_DEBUG_REPOSITORY_PATH) {
-		return "local_build_debug";
-	} else if (url == BUILD_RELEASE_REPOSITORY_PATH) {
-		return "local_build_release";
-	}
-	return "";
-}
-
-ExtensionRepository ExtensionRepository::GetDefaultRepository(optional_ptr<DBConfig> config) {
-	if (config && !config->options.custom_extension_repo.empty()) {
-		return ExtensionRepository("", config->options.custom_extension_repo);
-	}
-
-	return GetCoreRepository();
-}
-ExtensionRepository ExtensionRepository::GetDefaultRepository(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return GetDefaultRepository(config);
-}
-
-ExtensionRepository ExtensionRepository::GetCoreRepository() {
-	return {"core", CORE_REPOSITORY_URL};
-}
-
-ExtensionRepository ExtensionRepository::GetRepositoryByUrl(const string &url) {
-	if (url.empty()) {
-		return GetCoreRepository();
-	}
-
-	auto repo_name = TryConvertUrlToKnownRepository(url);
-	return {repo_name, url};
-}
-
-ExtensionRepository::ExtensionRepository() : name("core"), path(CORE_REPOSITORY_URL) {
-}
-ExtensionRepository::ExtensionRepository(const string &name_p, const string &path_p) : name(name_p), path(path_p) {
-}
-
-string ExtensionRepository::ToReadableString() {
-	if (!name.empty()) {
-		return name;
-	}
-	return path;
-}
-
-unique_ptr<ExtensionInstallInfo> ExtensionInstallInfo::TryReadInfoFile(FileSystem &fs,
-                                                                       const std::string &info_file_path,
-                                                                       const std::string &extension_name) {
-	unique_ptr<ExtensionInstallInfo> result;
-
-	string hint = StringUtil::Format("Try reinstalling the extension using 'FORCE INSTALL %s;'", extension_name);
-
-	// Return empty info if the file is missing (TODO: throw error here in the future?)
-	if (!fs.FileExists(info_file_path)) {
-		return make_uniq<ExtensionInstallInfo>();
-	}
-
-	BufferedFileReader file_reader(fs, info_file_path.c_str());
-	if (!file_reader.Finished()) {
-		try {
-			result = BinaryDeserializer::Deserialize<ExtensionInstallInfo>(file_reader);
-		} catch (std::exception &ex) {
-			ErrorData error(ex);
-			throw IOException(
-			    "Failed to read info file for '%s' extension: '%s'.\nA serialization error occurred: '%s'\n%s",
-			    extension_name, info_file_path, error.RawMessage(), hint);
-		}
-	}
-
-	if (!result) {
-		throw IOException("Failed to read info file for '%s' extension: '%s'.\nThe file appears to be empty!\n%s",
-		                  extension_name, info_file_path, hint);
-	}
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/materialized_query_result.cpp b/src/duckdb/src/main/materialized_query_result.cpp
deleted file mode 100644
index d319d5686..000000000
--- a/src/duckdb/src/main/materialized_query_result.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/box_renderer.hpp"
-
-namespace duckdb {
-
-MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
-                                                 vector<string> names_p, unique_ptr<ColumnDataCollection> collection_p,
-                                                 ClientProperties client_properties)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, std::move(properties), collection_p->Types(),
-                  std::move(names_p), std::move(client_properties)),
-      collection(std::move(collection_p)), scan_initialized(false) {
-}
-
-MaterializedQueryResult::MaterializedQueryResult(ErrorData error)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, std::move(error)), scan_initialized(false) {
-}
-
-string MaterializedQueryResult::ToString() {
-	string result;
-	if (success) {
-		result = HeaderToString();
-		result += "[ Rows: " + to_string(collection->Count()) + "]\n";
-		auto &coll = Collection();
-		for (auto &row : coll.Rows()) {
-			for (idx_t col_idx = 0; col_idx < coll.ColumnCount(); col_idx++) {
-				if (col_idx > 0) {
-					result += "\t";
-				}
-				auto val = row.GetValue(col_idx);
-				result += val.IsNull() ? "NULL" : StringUtil::Replace(val.ToString(), string("\0", 1), "\\0");
-			}
-			result += "\n";
-		}
-		result += "\n";
-	} else {
-		result = GetError() + "\n";
-	}
-	return result;
-}
-
-string MaterializedQueryResult::ToBox(ClientContext &context, const BoxRendererConfig &config) {
-	if (!success) {
-		return GetError() + "\n";
-	}
-	if (!collection) {
-		return "Internal error - result was successful but there was no collection";
-	}
-	BoxRenderer renderer(config);
-	return renderer.ToString(context, names, Collection());
-}
-
-Value MaterializedQueryResult::GetValue(idx_t column, idx_t index) {
-	if (!row_collection) {
-		row_collection = make_uniq<ColumnDataRowCollection>(collection->GetRows());
-	}
-	return row_collection->GetValue(column, index);
-}
-
-idx_t MaterializedQueryResult::RowCount() const {
-	return collection ? collection->Count() : 0;
-}
-
-ColumnDataCollection &MaterializedQueryResult::Collection() {
-	if (HasError()) {
-		throw InvalidInputException("Attempting to get collection from an unsuccessful query result\n: Error %s",
-		                            GetError());
-	}
-	if (!collection) {
-		throw InternalException("Missing collection from materialized query result");
-	}
-	return *collection;
-}
-
-unique_ptr<ColumnDataCollection> MaterializedQueryResult::TakeCollection() {
-	if (HasError()) {
-		throw InvalidInputException("Attempting to get collection from an unsuccessful query result\n: Error %s",
-		                            GetError());
-	}
-	if (!collection) {
-		throw InternalException("Missing collection from materialized query result");
-	}
-	return std::move(collection);
-}
-
-unique_ptr<DataChunk> MaterializedQueryResult::Fetch() {
-	return FetchRaw();
-}
-
-unique_ptr<DataChunk> MaterializedQueryResult::FetchRaw() {
-	if (HasError()) {
-		throw InvalidInputException("Attempting to fetch from an unsuccessful query result\nError: %s", GetError());
-	}
-	auto result = make_uniq<DataChunk>();
-	collection->InitializeScanChunk(*result);
-	if (!scan_initialized) {
-		// we disallow zero copy so the chunk is independently usable even after the result is destroyed
-		collection->InitializeScan(scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY);
-		scan_initialized = true;
-	}
-	collection->Scan(scan_state, *result);
-	if (result->size() == 0) {
-		return nullptr;
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/pending_query_result.cpp b/src/duckdb/src/main/pending_query_result.cpp
deleted file mode 100644
index 8c4d615c2..000000000
--- a/src/duckdb/src/main/pending_query_result.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "duckdb/main/pending_query_result.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-
-namespace duckdb {
-
-PendingQueryResult::PendingQueryResult(shared_ptr<ClientContext> context_p, PreparedStatementData &statement,
-                                       vector<LogicalType> types_p, bool allow_stream_result)
-    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, statement.properties,
-                      std::move(types_p), statement.names),
-      context(std::move(context_p)), allow_stream_result(allow_stream_result) {
-}
-
-PendingQueryResult::PendingQueryResult(ErrorData error)
-    : BaseQueryResult(QueryResultType::PENDING_RESULT, std::move(error)) {
-}
-
-PendingQueryResult::~PendingQueryResult() {
-}
-
-unique_ptr<ClientContextLock> PendingQueryResult::LockContext() {
-	if (!context) {
-		if (HasError()) {
-			throw InvalidInputException(
-			    "Attempting to execute an unsuccessful or closed pending query result\nError: %s", GetError());
-		}
-		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result");
-	}
-	return context->LockContext();
-}
-
-void PendingQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
-	bool invalidated = HasError() || !context;
-	if (!invalidated) {
-		invalidated = !context->IsActiveResult(lock, *this);
-	}
-	if (invalidated) {
-		if (HasError()) {
-			throw InvalidInputException(
-			    "Attempting to execute an unsuccessful or closed pending query result\nError: %s", GetError());
-		}
-		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result");
-	}
-}
-
-void PendingQueryResult::WaitForTask() {
-	auto lock = LockContext();
-	context->WaitForTask(*lock, *this);
-}
-
-PendingExecutionResult PendingQueryResult::ExecuteTask() {
-	auto lock = LockContext();
-	return ExecuteTaskInternal(*lock);
-}
-
-PendingExecutionResult PendingQueryResult::CheckPulse() {
-	auto lock = LockContext();
-	CheckExecutableInternal(*lock);
-	return context->ExecuteTaskInternal(*lock, *this, true);
-}
-
-bool PendingQueryResult::AllowStreamResult() const {
-	return allow_stream_result;
-}
-
-PendingExecutionResult PendingQueryResult::ExecuteTaskInternal(ClientContextLock &lock) {
-	CheckExecutableInternal(lock);
-	return context->ExecuteTaskInternal(lock, *this, false);
-}
-
-unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &lock) {
-	CheckExecutableInternal(lock);
-
-	PendingExecutionResult execution_result;
-	while (!IsResultReady(execution_result = ExecuteTaskInternal(lock))) {
-		if (execution_result == PendingExecutionResult::BLOCKED) {
-			CheckExecutableInternal(lock);
-			context->WaitForTask(lock, *this);
-		}
-	}
-	if (HasError()) {
-		if (allow_stream_result) {
-			return make_uniq<StreamQueryResult>(error);
-		} else {
-			return make_uniq<MaterializedQueryResult>(error);
-		}
-	}
-	auto result = context->FetchResultInternal(lock, *this);
-	Close();
-	return result;
-}
-
-unique_ptr<QueryResult> PendingQueryResult::Execute() {
-	auto lock = LockContext();
-	return ExecuteInternal(*lock);
-}
-
-void PendingQueryResult::Close() {
-	context.reset();
-}
-
-bool PendingQueryResult::IsResultReady(PendingExecutionResult result) {
-	return (IsExecutionFinished(result) || result == PendingExecutionResult::RESULT_READY);
-}
-
-bool PendingQueryResult::IsExecutionFinished(PendingExecutionResult result) {
-	return (result == PendingExecutionResult::EXECUTION_FINISHED || result == PendingExecutionResult::EXECUTION_ERROR);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/prepared_statement.cpp b/src/duckdb/src/main/prepared_statement.cpp
deleted file mode 100644
index 34d12cadc..000000000
--- a/src/duckdb/src/main/prepared_statement.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#include "duckdb/main/prepared_statement.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-
-namespace duckdb {
-
-PreparedStatement::PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data_p,
-                                     string query, case_insensitive_map_t<idx_t> named_param_map_p)
-    : context(std::move(context)), data(std::move(data_p)), query(std::move(query)), success(true),
-      named_param_map(std::move(named_param_map_p)) {
-	D_ASSERT(data || !success);
-}
-
-PreparedStatement::PreparedStatement(ErrorData error) : context(nullptr), success(false), error(std::move(error)) {
-}
-
-PreparedStatement::~PreparedStatement() {
-}
-
-const string &PreparedStatement::GetError() {
-	D_ASSERT(HasError());
-	return error.Message();
-}
-
-ErrorData &PreparedStatement::GetErrorObject() {
-	return error;
-}
-
-bool PreparedStatement::HasError() const {
-	return !success;
-}
-
-idx_t PreparedStatement::ColumnCount() {
-	D_ASSERT(data);
-	return data->types.size();
-}
-
-StatementType PreparedStatement::GetStatementType() {
-	D_ASSERT(data);
-	return data->statement_type;
-}
-
-StatementProperties PreparedStatement::GetStatementProperties() {
-	D_ASSERT(data);
-	return data->properties;
-}
-
-const vector<LogicalType> &PreparedStatement::GetTypes() {
-	D_ASSERT(data);
-	return data->types;
-}
-
-const vector<string> &PreparedStatement::GetNames() {
-	D_ASSERT(data);
-	return data->names;
-}
-
-case_insensitive_map_t<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
-	D_ASSERT(data);
-	case_insensitive_map_t<LogicalType> expected_types(data->value_map.size());
-	for (auto &it : data->value_map) {
-		auto &identifier = it.first;
-		D_ASSERT(data->value_map.count(identifier));
-		D_ASSERT(it.second);
-		expected_types[identifier] = it.second->GetValue().type();
-	}
-	return expected_types;
-}
-
-unique_ptr<QueryResult> PreparedStatement::Execute(case_insensitive_map_t<BoundParameterData> &named_values,
-                                                   bool allow_stream_result) {
-	auto pending = PendingQuery(named_values, allow_stream_result);
-	if (pending->HasError()) {
-		return make_uniq<MaterializedQueryResult>(pending->GetErrorObject());
-	}
-	return pending->Execute();
-}
-
-unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
-	auto pending = PendingQuery(values, allow_stream_result);
-	if (pending->HasError()) {
-		return make_uniq<MaterializedQueryResult>(pending->GetErrorObject());
-	}
-	return pending->Execute();
-}
-
-unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values, bool allow_stream_result) {
-	case_insensitive_map_t<BoundParameterData> named_values;
-	for (idx_t i = 0; i < values.size(); i++) {
-		auto &val = values[i];
-		named_values[std::to_string(i + 1)] = BoundParameterData(val);
-	}
-	return PendingQuery(named_values, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(case_insensitive_map_t<BoundParameterData> &named_values,
-                                                               bool allow_stream_result) {
-	if (!success) {
-		auto exception = InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
-		return make_uniq<PendingQueryResult>(ErrorData(exception));
-	}
-	PendingQueryParameters parameters;
-	parameters.parameters = &named_values;
-
-	try {
-		VerifyParameters(named_values, named_param_map);
-	} catch (const std::exception &ex) {
-		return make_uniq<PendingQueryResult>(ErrorData(ex));
-	}
-
-	D_ASSERT(data);
-	parameters.allow_stream_result = allow_stream_result && data->properties.allow_stream_result;
-	auto result = context->PendingQuery(query, data, parameters);
-	// The result should not contain any reference to the 'vector<Value> parameters.parameters'
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/prepared_statement_data.cpp b/src/duckdb/src/main/prepared_statement_data.cpp
deleted file mode 100644
index c4cec4c55..000000000
--- a/src/duckdb/src/main/prepared_statement_data.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/transaction/transaction.hpp"
-
-namespace duckdb {
-
-PreparedStatementData::PreparedStatementData(StatementType type) : statement_type(type) {
-}
-
-PreparedStatementData::~PreparedStatementData() {
-}
-
-void PreparedStatementData::CheckParameterCount(idx_t parameter_count) {
-	const auto required = properties.parameter_count;
-	if (parameter_count != required) {
-		throw BinderException("Parameter/argument count mismatch for prepared statement. Expected %llu, got %llu",
-		                      required, parameter_count);
-	}
-}
-
-bool CheckCatalogIdentity(ClientContext &context, const string &catalog_name,
-                          const StatementProperties::CatalogIdentity catalog_identity) {
-	// some catalogs don't support catalog version, we can't check identity in that case
-	if (!catalog_identity.catalog_version.IsValid()) {
-		return false;
-	}
-	auto database = DatabaseManager::Get(context).GetDatabase(context, catalog_name);
-	if (!database) {
-		throw BinderException("Prepared statement requires database %s but it was not attached", catalog_name);
-	}
-	Transaction::Get(context, *database);
-	auto current_catalog_oid = database->GetCatalog().GetOid();
-	auto current_catalog_version = database->GetCatalog().GetCatalogVersion(context);
-
-	return StatementProperties::CatalogIdentity {current_catalog_oid, current_catalog_version} == catalog_identity;
-}
-
-bool PreparedStatementData::RequireRebind(ClientContext &context,
-                                          optional_ptr<case_insensitive_map_t<BoundParameterData>> values) {
-	idx_t count = values ? values->size() : 0;
-	CheckParameterCount(count);
-	if (!unbound_statement) {
-		throw InternalException("Prepared statement without unbound statement");
-	}
-	if (properties.always_require_rebind) {
-		// this statement must always be re-bound
-		return true;
-	}
-	if (!properties.bound_all_parameters) {
-		// parameters not yet bound: query always requires a rebind
-		return true;
-	}
-	for (auto &it : value_map) {
-		auto &identifier = it.first;
-		auto lookup = values->find(identifier);
-		if (lookup == values->end()) {
-			break;
-		}
-		if (lookup->second.GetValue().type() != it.second->return_type) {
-			return true;
-		}
-	}
-	// Check the catalog versions to ensure all catalog entries we rely on are current
-	for (auto &it : properties.read_databases) {
-		if (!CheckCatalogIdentity(context, it.first, it.second)) {
-			return true;
-		}
-	}
-	for (auto &it : properties.modified_databases) {
-		if (!CheckCatalogIdentity(context, it.first, it.second)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void PreparedStatementData::Bind(case_insensitive_map_t<BoundParameterData> values) {
-	// set parameters
-	D_ASSERT(!unbound_statement || unbound_statement->named_param_map.size() == properties.parameter_count);
-	CheckParameterCount(values.size());
-
-	// bind the required values
-	for (auto &it : value_map) {
-		const string &identifier = it.first;
-		auto lookup = values.find(identifier);
-		if (lookup == values.end()) {
-			throw BinderException("Could not find parameter with identifier %s", identifier);
-		}
-		D_ASSERT(it.second);
-		auto value = lookup->second.GetValue();
-		if (!value.DefaultTryCastAs(it.second->return_type)) {
-			throw BinderException(
-			    "Type mismatch for binding parameter with identifier %s, expected type %s but got type %s", identifier,
-			    it.second->return_type.ToString().c_str(), value.type().ToString().c_str());
-		}
-		it.second->SetValue(std::move(value));
-	}
-}
-
-bool PreparedStatementData::TryGetType(const string &identifier, LogicalType &result) {
-	auto it = value_map.find(identifier);
-	if (it == value_map.end()) {
-		return false;
-	}
-	if (it->second->return_type.id() != LogicalTypeId::INVALID) {
-		result = it->second->return_type;
-	} else {
-		result = it->second->GetValue().type();
-	}
-	return true;
-}
-
-LogicalType PreparedStatementData::GetType(const string &identifier) {
-	LogicalType result;
-	if (!TryGetType(identifier, result)) {
-		throw BinderException("Could not find parameter identified with: %s", identifier);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/profiling_info.cpp b/src/duckdb/src/main/profiling_info.cpp
deleted file mode 100644
index 4ce68b76d..000000000
--- a/src/duckdb/src/main/profiling_info.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-#include "duckdb/main/profiling_info.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/main/query_profiler.hpp"
-
-#include "yyjson.hpp"
-
-using namespace duckdb_yyjson; // NOLINT
-
-namespace duckdb {
-
-ProfilingInfo::ProfilingInfo(const profiler_settings_t &n_settings, const idx_t depth) : settings(n_settings) {
-	// Expand.
-	if (depth == 0) {
-		settings.insert(MetricsType::QUERY_NAME);
-	} else {
-		settings.insert(MetricsType::OPERATOR_NAME);
-		settings.insert(MetricsType::OPERATOR_TYPE);
-	}
-	for (const auto &metric : settings) {
-		Expand(expanded_settings, metric);
-	}
-
-	// Reduce.
-	if (depth == 0) {
-		auto op_metrics = DefaultOperatorSettings();
-		for (const auto metric : op_metrics) {
-			settings.erase(metric);
-		}
-	} else {
-		auto root_metrics = DefaultRootSettings();
-		for (const auto metric : root_metrics) {
-			settings.erase(metric);
-		}
-	}
-	ResetMetrics();
-}
-
-profiler_settings_t ProfilingInfo::DefaultSettings() {
-	return {MetricsType::QUERY_NAME,
-	        MetricsType::BLOCKED_THREAD_TIME,
-	        MetricsType::CPU_TIME,
-	        MetricsType::EXTRA_INFO,
-	        MetricsType::CUMULATIVE_CARDINALITY,
-	        MetricsType::OPERATOR_NAME,
-	        MetricsType::OPERATOR_TYPE,
-	        MetricsType::OPERATOR_CARDINALITY,
-	        MetricsType::CUMULATIVE_ROWS_SCANNED,
-	        MetricsType::OPERATOR_ROWS_SCANNED,
-	        MetricsType::OPERATOR_TIMING,
-	        MetricsType::RESULT_SET_SIZE,
-	        MetricsType::LATENCY,
-	        MetricsType::ROWS_RETURNED};
-}
-
-profiler_settings_t ProfilingInfo::DefaultRootSettings() {
-	return {MetricsType::QUERY_NAME, MetricsType::BLOCKED_THREAD_TIME, MetricsType::LATENCY,
-	        MetricsType::ROWS_RETURNED};
-}
-
-profiler_settings_t ProfilingInfo::DefaultOperatorSettings() {
-	return {MetricsType::OPERATOR_CARDINALITY, MetricsType::OPERATOR_ROWS_SCANNED, MetricsType::OPERATOR_TIMING,
-	        MetricsType::OPERATOR_NAME, MetricsType::OPERATOR_TYPE};
-}
-
-void ProfilingInfo::ResetMetrics() {
-	metrics.clear();
-	for (auto &metric : expanded_settings) {
-		if (MetricsUtils::IsOptimizerMetric(metric) || MetricsUtils::IsPhaseTimingMetric(metric)) {
-			metrics[metric] = Value::CreateValue(0.0);
-			continue;
-		}
-
-		switch (metric) {
-		case MetricsType::QUERY_NAME:
-			metrics[metric] = Value::CreateValue("");
-			break;
-		case MetricsType::LATENCY:
-		case MetricsType::BLOCKED_THREAD_TIME:
-		case MetricsType::CPU_TIME:
-		case MetricsType::OPERATOR_TIMING:
-			metrics[metric] = Value::CreateValue(0.0);
-			break;
-		case MetricsType::OPERATOR_NAME:
-			metrics[metric] = Value::CreateValue("");
-			break;
-		case MetricsType::OPERATOR_TYPE:
-			metrics[metric] = Value::CreateValue<uint8_t>(0);
-			break;
-		case MetricsType::ROWS_RETURNED:
-		case MetricsType::RESULT_SET_SIZE:
-		case MetricsType::CUMULATIVE_CARDINALITY:
-		case MetricsType::OPERATOR_CARDINALITY:
-		case MetricsType::CUMULATIVE_ROWS_SCANNED:
-		case MetricsType::OPERATOR_ROWS_SCANNED:
-			metrics[metric] = Value::CreateValue<uint64_t>(0);
-			break;
-		case MetricsType::EXTRA_INFO:
-			break;
-		default:
-			throw Exception(ExceptionType::INTERNAL, "MetricsType" + EnumUtil::ToString(metric) + "not implemented");
-		}
-	}
-}
-
-bool ProfilingInfo::Enabled(const profiler_settings_t &settings, const MetricsType metric) {
-	if (settings.find(metric) != settings.end()) {
-		return true;
-	}
-	return false;
-}
-
-void ProfilingInfo::Expand(profiler_settings_t &settings, const MetricsType metric) {
-	settings.insert(metric);
-
-	switch (metric) {
-	case MetricsType::CPU_TIME:
-		settings.insert(MetricsType::OPERATOR_TIMING);
-		return;
-	case MetricsType::CUMULATIVE_CARDINALITY:
-		settings.insert(MetricsType::OPERATOR_CARDINALITY);
-		return;
-	case MetricsType::CUMULATIVE_ROWS_SCANNED:
-		settings.insert(MetricsType::OPERATOR_ROWS_SCANNED);
-		return;
-	case MetricsType::CUMULATIVE_OPTIMIZER_TIMING:
-	case MetricsType::ALL_OPTIMIZERS: {
-		auto optimizer_metrics = MetricsUtils::GetOptimizerMetrics();
-		for (const auto optimizer_metric : optimizer_metrics) {
-			settings.insert(optimizer_metric);
-		}
-		return;
-	}
-	default:
-		return;
-	}
-}
-
-string ProfilingInfo::GetMetricAsString(const MetricsType metric) const {
-	if (!Enabled(settings, metric)) {
-		throw InternalException("Metric %s not enabled", EnumUtil::ToString(metric));
-	}
-
-	if (metric == MetricsType::EXTRA_INFO) {
-		string result;
-		for (auto &it : extra_info) {
-			if (!result.empty()) {
-				result += ", ";
-			}
-			result += StringUtil::Format("%s: %s", it.first, it.second);
-		}
-		return "\"" + result + "\"";
-	}
-
-	// The metric cannot be NULL and must be initialized.
-	D_ASSERT(!metrics.at(metric).IsNull());
-	if (metric == MetricsType::OPERATOR_TYPE) {
-		auto type = PhysicalOperatorType(metrics.at(metric).GetValue<uint8_t>());
-		return EnumUtil::ToString(type);
-	}
-	return metrics.at(metric).ToString();
-}
-
-void ProfilingInfo::WriteMetricsToJSON(yyjson_mut_doc *doc, yyjson_mut_val *dest) {
-	for (auto &metric : settings) {
-		auto metric_str = StringUtil::Lower(EnumUtil::ToString(metric));
-		auto key_val = yyjson_mut_strcpy(doc, metric_str.c_str());
-		auto key_ptr = yyjson_mut_get_str(key_val);
-
-		if (metric == MetricsType::EXTRA_INFO) {
-			auto extra_info_obj = yyjson_mut_obj(doc);
-
-			for (auto &it : extra_info) {
-				auto &key = it.first;
-				auto &value = it.second;
-				auto splits = StringUtil::Split(value, "\n");
-				if (splits.size() > 1) {
-					auto list_items = yyjson_mut_arr(doc);
-					for (auto &split : splits) {
-						yyjson_mut_arr_add_strcpy(doc, list_items, split.c_str());
-					}
-					yyjson_mut_obj_add_val(doc, extra_info_obj, key.c_str(), list_items);
-				} else {
-					yyjson_mut_obj_add_strcpy(doc, extra_info_obj, key.c_str(), value.c_str());
-				}
-			}
-			yyjson_mut_obj_add_val(doc, dest, key_ptr, extra_info_obj);
-			continue;
-		}
-
-		// The metric cannot be NULL, and should have been 0 initialized.
-		D_ASSERT(!metrics[metric].IsNull());
-
-		if (MetricsUtils::IsOptimizerMetric(metric) || MetricsUtils::IsPhaseTimingMetric(metric)) {
-			yyjson_mut_obj_add_real(doc, dest, key_ptr, metrics[metric].GetValue<double>());
-			continue;
-		}
-
-		switch (metric) {
-		case MetricsType::QUERY_NAME:
-		case MetricsType::OPERATOR_NAME:
-			yyjson_mut_obj_add_strcpy(doc, dest, key_ptr, metrics[metric].GetValue<string>().c_str());
-			break;
-		case MetricsType::LATENCY:
-		case MetricsType::BLOCKED_THREAD_TIME:
-		case MetricsType::CPU_TIME:
-		case MetricsType::OPERATOR_TIMING: {
-			yyjson_mut_obj_add_real(doc, dest, key_ptr, metrics[metric].GetValue<double>());
-			break;
-		}
-		case MetricsType::OPERATOR_TYPE: {
-			yyjson_mut_obj_add_strcpy(doc, dest, key_ptr, GetMetricAsString(metric).c_str());
-			break;
-		}
-		case MetricsType::ROWS_RETURNED:
-		case MetricsType::RESULT_SET_SIZE:
-		case MetricsType::CUMULATIVE_CARDINALITY:
-		case MetricsType::OPERATOR_CARDINALITY:
-		case MetricsType::CUMULATIVE_ROWS_SCANNED:
-		case MetricsType::OPERATOR_ROWS_SCANNED: {
-			yyjson_mut_obj_add_uint(doc, dest, key_ptr, metrics[metric].GetValue<uint64_t>());
-			break;
-		}
-		default:
-			throw NotImplementedException("MetricsType %s not implemented", EnumUtil::ToString(metric));
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/query_profiler.cpp b/src/duckdb/src/main/query_profiler.cpp
deleted file mode 100644
index 03889af52..000000000
--- a/src/duckdb/src/main/query_profiler.cpp
+++ /dev/null
@@ -1,873 +0,0 @@
-#include "duckdb/main/query_profiler.hpp"
-
-#include "duckdb/common/fstream.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/tree_renderer/text_tree_renderer.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/helper/physical_execute.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "yyjson.hpp"
-
-#include <algorithm>
-#include <utility>
-
-using namespace duckdb_yyjson; // NOLINT
-
-namespace duckdb {
-
-QueryProfiler::QueryProfiler(ClientContext &context_p)
-    : context(context_p), running(false), query_requires_profiling(false), is_explain_analyze(false) {
-}
-
-bool QueryProfiler::IsEnabled() const {
-	return is_explain_analyze || ClientConfig::GetConfig(context).enable_profiler;
-}
-
-bool QueryProfiler::IsDetailedEnabled() const {
-	return !is_explain_analyze && ClientConfig::GetConfig(context).enable_detailed_profiling;
-}
-
-ProfilerPrintFormat QueryProfiler::GetPrintFormat(ExplainFormat format) const {
-	auto print_format = ClientConfig::GetConfig(context).profiler_print_format;
-	if (format == ExplainFormat::DEFAULT) {
-		return print_format;
-	}
-	switch (format) {
-	case ExplainFormat::TEXT:
-		return ProfilerPrintFormat::QUERY_TREE;
-	case ExplainFormat::JSON:
-		return ProfilerPrintFormat::JSON;
-	case ExplainFormat::HTML:
-		return ProfilerPrintFormat::HTML;
-	case ExplainFormat::GRAPHVIZ:
-		return ProfilerPrintFormat::GRAPHVIZ;
-	default:
-		throw NotImplementedException("No mapping from ExplainFormat::%s to ProfilerPrintFormat",
-		                              EnumUtil::ToString(format));
-	}
-}
-
-ExplainFormat QueryProfiler::GetExplainFormat(ProfilerPrintFormat format) const {
-	switch (format) {
-	case ProfilerPrintFormat::QUERY_TREE:
-	case ProfilerPrintFormat::QUERY_TREE_OPTIMIZER:
-		return ExplainFormat::TEXT;
-	case ProfilerPrintFormat::JSON:
-		return ExplainFormat::JSON;
-	case ProfilerPrintFormat::HTML:
-		return ExplainFormat::HTML;
-	case ProfilerPrintFormat::GRAPHVIZ:
-		return ExplainFormat::GRAPHVIZ;
-	case ProfilerPrintFormat::NO_OUTPUT:
-		throw InternalException("Should not attempt to get ExplainFormat for ProfilerPrintFormat::NO_OUTPUT");
-	default:
-		throw NotImplementedException("No mapping from ProfilePrintFormat::%s to ExplainFormat",
-		                              EnumUtil::ToString(format));
-	}
-}
-
-bool QueryProfiler::PrintOptimizerOutput() const {
-	return GetPrintFormat() == ProfilerPrintFormat::QUERY_TREE_OPTIMIZER || IsDetailedEnabled();
-}
-
-string QueryProfiler::GetSaveLocation() const {
-	return is_explain_analyze ? string() : ClientConfig::GetConfig(context).profiler_save_location;
-}
-
-QueryProfiler &QueryProfiler::Get(ClientContext &context) {
-	return *ClientData::Get(context).profiler;
-}
-
-void QueryProfiler::StartQuery(string query, bool is_explain_analyze_p, bool start_at_optimizer) {
-	lock_guard<std::mutex> guard(lock);
-	if (is_explain_analyze_p) {
-		StartExplainAnalyze();
-	}
-	if (!IsEnabled()) {
-		return;
-	}
-	if (start_at_optimizer && !PrintOptimizerOutput()) {
-		// This is the StartQuery call before the optimizer, but we don't have to print optimizer output
-		return;
-	}
-	if (running) {
-		// Called while already running: this should only happen when we print optimizer output
-		D_ASSERT(PrintOptimizerOutput());
-		return;
-	}
-
-	running = true;
-	query_info.query_name = std::move(query);
-	tree_map.clear();
-	root = nullptr;
-	phase_timings.clear();
-	phase_stack.clear();
-	main_query.Start();
-}
-
-bool QueryProfiler::OperatorRequiresProfiling(PhysicalOperatorType op_type) {
-	switch (op_type) {
-	case PhysicalOperatorType::ORDER_BY:
-	case PhysicalOperatorType::RESERVOIR_SAMPLE:
-	case PhysicalOperatorType::STREAMING_SAMPLE:
-	case PhysicalOperatorType::LIMIT:
-	case PhysicalOperatorType::LIMIT_PERCENT:
-	case PhysicalOperatorType::STREAMING_LIMIT:
-	case PhysicalOperatorType::TOP_N:
-	case PhysicalOperatorType::WINDOW:
-	case PhysicalOperatorType::UNNEST:
-	case PhysicalOperatorType::UNGROUPED_AGGREGATE:
-	case PhysicalOperatorType::HASH_GROUP_BY:
-	case PhysicalOperatorType::FILTER:
-	case PhysicalOperatorType::PROJECTION:
-	case PhysicalOperatorType::COPY_TO_FILE:
-	case PhysicalOperatorType::TABLE_SCAN:
-	case PhysicalOperatorType::CHUNK_SCAN:
-	case PhysicalOperatorType::DELIM_SCAN:
-	case PhysicalOperatorType::EXPRESSION_SCAN:
-	case PhysicalOperatorType::BLOCKWISE_NL_JOIN:
-	case PhysicalOperatorType::NESTED_LOOP_JOIN:
-	case PhysicalOperatorType::HASH_JOIN:
-	case PhysicalOperatorType::CROSS_PRODUCT:
-	case PhysicalOperatorType::PIECEWISE_MERGE_JOIN:
-	case PhysicalOperatorType::IE_JOIN:
-	case PhysicalOperatorType::LEFT_DELIM_JOIN:
-	case PhysicalOperatorType::RIGHT_DELIM_JOIN:
-	case PhysicalOperatorType::UNION:
-	case PhysicalOperatorType::RECURSIVE_CTE:
-	case PhysicalOperatorType::EMPTY_RESULT:
-	case PhysicalOperatorType::EXTENSION:
-		return true;
-	default:
-		return false;
-	}
-}
-
-void QueryProfiler::Finalize(ProfilingNode &node) {
-	for (idx_t i = 0; i < node.GetChildCount(); i++) {
-		auto child = node.GetChild(i);
-		Finalize(*child);
-
-		auto &info = node.GetProfilingInfo();
-		auto type = PhysicalOperatorType(info.GetMetricValue<uint8_t>(MetricsType::OPERATOR_TYPE));
-		if (type == PhysicalOperatorType::UNION &&
-		    info.Enabled(info.expanded_settings, MetricsType::OPERATOR_CARDINALITY)) {
-
-			auto &child_info = child->GetProfilingInfo();
-			auto value = child_info.metrics[MetricsType::OPERATOR_CARDINALITY].GetValue<idx_t>();
-			info.AddToMetric(MetricsType::OPERATOR_CARDINALITY, value);
-		}
-	}
-}
-
-void QueryProfiler::StartExplainAnalyze() {
-	is_explain_analyze = true;
-}
-
-template <class METRIC_TYPE>
-static void GetCumulativeMetric(ProfilingNode &node, MetricsType cumulative_metric, MetricsType child_metric) {
-	auto &info = node.GetProfilingInfo();
-	info.metrics[cumulative_metric] = info.metrics[child_metric];
-
-	for (idx_t i = 0; i < node.GetChildCount(); i++) {
-		auto child = node.GetChild(i);
-		GetCumulativeMetric<METRIC_TYPE>(*child, cumulative_metric, child_metric);
-		auto value = child->GetProfilingInfo().metrics[cumulative_metric].GetValue<METRIC_TYPE>();
-		info.AddToMetric(cumulative_metric, value);
-	}
-}
-
-Value GetCumulativeOptimizers(ProfilingNode &node) {
-	auto &metrics = node.GetProfilingInfo().metrics;
-	double count = 0;
-	for (auto &metric : metrics) {
-		if (MetricsUtils::IsOptimizerMetric(metric.first)) {
-			count += metric.second.GetValue<double>();
-		}
-	}
-	return Value::CreateValue(count);
-}
-
-void QueryProfiler::EndQuery() {
-	unique_lock<std::mutex> guard(lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-
-	main_query.End();
-	if (root) {
-		auto &info = root->GetProfilingInfo();
-		if (info.Enabled(info.expanded_settings, MetricsType::OPERATOR_CARDINALITY)) {
-			Finalize(*root->GetChild(0));
-		}
-	}
-	running = false;
-
-	bool emit_output = false;
-
-	// Print or output the query profiling after query termination.
-	// EXPLAIN ANALYZE output is not written by the profiler.
-	if (IsEnabled() && !is_explain_analyze) {
-		if (root) {
-			auto &info = root->GetProfilingInfo();
-			info = ProfilingInfo(ClientConfig::GetConfig(context).profiler_settings);
-			auto &child_info = root->children[0]->GetProfilingInfo();
-			info.metrics[MetricsType::QUERY_NAME] = query_info.query_name;
-
-			auto &settings = info.expanded_settings;
-			if (info.Enabled(settings, MetricsType::BLOCKED_THREAD_TIME)) {
-				info.metrics[MetricsType::BLOCKED_THREAD_TIME] = query_info.blocked_thread_time;
-			}
-			if (info.Enabled(settings, MetricsType::LATENCY)) {
-				info.metrics[MetricsType::LATENCY] = main_query.Elapsed();
-			}
-			if (info.Enabled(settings, MetricsType::ROWS_RETURNED)) {
-				info.metrics[MetricsType::ROWS_RETURNED] = child_info.metrics[MetricsType::OPERATOR_CARDINALITY];
-			}
-			if (info.Enabled(settings, MetricsType::CPU_TIME)) {
-				GetCumulativeMetric<double>(*root, MetricsType::CPU_TIME, MetricsType::OPERATOR_TIMING);
-			}
-			if (info.Enabled(settings, MetricsType::CUMULATIVE_CARDINALITY)) {
-				GetCumulativeMetric<idx_t>(*root, MetricsType::CUMULATIVE_CARDINALITY,
-				                           MetricsType::OPERATOR_CARDINALITY);
-			}
-			if (info.Enabled(settings, MetricsType::CUMULATIVE_ROWS_SCANNED)) {
-				GetCumulativeMetric<idx_t>(*root, MetricsType::CUMULATIVE_ROWS_SCANNED,
-				                           MetricsType::OPERATOR_ROWS_SCANNED);
-			}
-			if (info.Enabled(settings, MetricsType::RESULT_SET_SIZE)) {
-				info.metrics[MetricsType::RESULT_SET_SIZE] = child_info.metrics[MetricsType::RESULT_SET_SIZE];
-			}
-
-			MoveOptimizerPhasesToRoot();
-			if (info.Enabled(settings, MetricsType::CUMULATIVE_OPTIMIZER_TIMING)) {
-				info.metrics.at(MetricsType::CUMULATIVE_OPTIMIZER_TIMING) = GetCumulativeOptimizers(*root);
-			}
-		}
-
-		if (ClientConfig::GetConfig(context).emit_profiler_output) {
-			emit_output = true;
-		}
-	}
-
-	is_explain_analyze = false;
-
-	guard.unlock();
-
-	if (emit_output) {
-		string tree = ToString();
-		auto save_location = GetSaveLocation();
-
-		if (save_location.empty()) {
-			Printer::Print(tree);
-			Printer::Print("\n");
-		} else {
-			WriteToFile(save_location.c_str(), tree);
-		}
-	}
-}
-
-string QueryProfiler::ToString(ExplainFormat explain_format) const {
-	return ToString(GetPrintFormat(explain_format));
-}
-
-string QueryProfiler::ToString(ProfilerPrintFormat format) const {
-	if (!IsEnabled()) {
-		return RenderDisabledMessage(format);
-	}
-	switch (format) {
-	case ProfilerPrintFormat::QUERY_TREE:
-	case ProfilerPrintFormat::QUERY_TREE_OPTIMIZER:
-		return QueryTreeToString();
-	case ProfilerPrintFormat::JSON:
-		return ToJSON();
-	case ProfilerPrintFormat::NO_OUTPUT:
-		return "";
-	case ProfilerPrintFormat::HTML:
-	case ProfilerPrintFormat::GRAPHVIZ: {
-		lock_guard<std::mutex> guard(lock);
-		// checking the tree to ensure the query is really empty
-		// the query string is empty when a logical plan is deserialized
-		if (query_info.query_name.empty() && !root) {
-			return "";
-		}
-		auto renderer = TreeRenderer::CreateRenderer(GetExplainFormat(format));
-		std::stringstream str;
-		auto &info = root->GetProfilingInfo();
-		if (info.Enabled(info.expanded_settings, MetricsType::OPERATOR_TIMING)) {
-			info.metrics[MetricsType::OPERATOR_TIMING] = main_query.Elapsed();
-		}
-		renderer->Render(*root, str);
-		return str.str();
-	}
-	default:
-		throw InternalException("Unknown ProfilerPrintFormat \"%s\"", EnumUtil::ToString(format));
-	}
-}
-
-void QueryProfiler::StartPhase(MetricsType phase_metric) {
-	lock_guard<std::mutex> guard(lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-
-	// start a new phase
-	phase_stack.push_back(phase_metric);
-	// restart the timer
-	phase_profiler.Start();
-}
-
-void QueryProfiler::EndPhase() {
-	lock_guard<std::mutex> guard(lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-	D_ASSERT(!phase_stack.empty());
-
-	// end the timer
-	phase_profiler.End();
-	// add the timing to all currently active phases
-	for (auto &phase : phase_stack) {
-		phase_timings[phase] += phase_profiler.Elapsed();
-	}
-	// now remove the last added phase
-	phase_stack.pop_back();
-
-	if (!phase_stack.empty()) {
-		phase_profiler.Start();
-	}
-}
-
-OperatorProfiler::OperatorProfiler(ClientContext &context) : context(context) {
-	enabled = QueryProfiler::Get(context).IsEnabled();
-	auto &context_metrics = ClientConfig::GetConfig(context).profiler_settings;
-
-	// Expand.
-	for (const auto metric : context_metrics) {
-		settings.insert(metric);
-		ProfilingInfo::Expand(settings, metric);
-	}
-
-	// Reduce.
-	auto root_metrics = ProfilingInfo::DefaultRootSettings();
-	for (const auto metric : root_metrics) {
-		settings.erase(metric);
-	}
-}
-
-void OperatorProfiler::StartOperator(optional_ptr<const PhysicalOperator> phys_op) {
-	if (!enabled) {
-		return;
-	}
-	if (active_operator) {
-		throw InternalException("OperatorProfiler: Attempting to call StartOperator while another operator is active");
-	}
-	active_operator = phys_op;
-
-	if (!settings.empty()) {
-		if (ProfilingInfo::Enabled(settings, MetricsType::EXTRA_INFO)) {
-			auto &info = GetOperatorInfo(*active_operator);
-			auto params = active_operator->ParamsToString();
-			info.extra_info = params;
-		}
-
-		// Start the timing of the current operator.
-		if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_TIMING)) {
-			op.Start();
-		}
-	}
-}
-
-void OperatorProfiler::EndOperator(optional_ptr<DataChunk> chunk) {
-	if (!enabled) {
-		return;
-	}
-	if (!active_operator) {
-		throw InternalException("OperatorProfiler: Attempting to call EndOperator while another operator is active");
-	}
-
-	if (!settings.empty()) {
-		auto &info = GetOperatorInfo(*active_operator);
-		if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_TIMING)) {
-			op.End();
-			info.AddTime(op.Elapsed());
-		}
-		if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_CARDINALITY) && chunk) {
-			info.AddReturnedElements(chunk->size());
-		}
-		if (ProfilingInfo::Enabled(settings, MetricsType::RESULT_SET_SIZE) && chunk) {
-			auto result_set_size = chunk->GetAllocationSize();
-			info.AddResultSetSize(result_set_size);
-		}
-	}
-	active_operator = nullptr;
-}
-
-OperatorInformation &OperatorProfiler::GetOperatorInfo(const PhysicalOperator &phys_op) {
-	auto entry = operator_infos.find(phys_op);
-	if (entry != operator_infos.end()) {
-		return entry->second;
-	}
-
-	// Add a new entry.
-	operator_infos[phys_op] = OperatorInformation();
-	return operator_infos[phys_op];
-}
-
-void OperatorProfiler::Flush(const PhysicalOperator &phys_op) {
-	auto entry = operator_infos.find(phys_op);
-	if (entry == operator_infos.end()) {
-		return;
-	}
-
-	auto &info = operator_infos.find(phys_op)->second;
-	info.name = phys_op.GetName();
-}
-
-void QueryProfiler::Flush(OperatorProfiler &profiler) {
-	lock_guard<std::mutex> guard(lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-	for (auto &node : profiler.operator_infos) {
-		auto &op = node.first.get();
-		auto entry = tree_map.find(op);
-		D_ASSERT(entry != tree_map.end());
-
-		auto &tree_node = entry->second.get();
-		auto &info = tree_node.GetProfilingInfo();
-
-		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::OPERATOR_TIMING)) {
-			info.AddToMetric<double>(MetricsType::OPERATOR_TIMING, node.second.time);
-		}
-		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::OPERATOR_CARDINALITY)) {
-			info.AddToMetric<idx_t>(MetricsType::OPERATOR_CARDINALITY, node.second.elements_returned);
-		}
-		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::OPERATOR_ROWS_SCANNED)) {
-			if (op.type == PhysicalOperatorType::TABLE_SCAN) {
-				auto &scan_op = op.Cast<PhysicalTableScan>();
-				auto &bind_data = scan_op.bind_data;
-
-				if (bind_data && scan_op.function.cardinality) {
-					auto cardinality = scan_op.function.cardinality(context, &(*bind_data));
-					if (cardinality && cardinality->has_estimated_cardinality) {
-						info.AddToMetric<idx_t>(MetricsType::OPERATOR_ROWS_SCANNED, cardinality->estimated_cardinality);
-					}
-				}
-			}
-		}
-		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::RESULT_SET_SIZE)) {
-			info.AddToMetric<idx_t>(MetricsType::RESULT_SET_SIZE, node.second.result_set_size);
-		}
-		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::EXTRA_INFO)) {
-			info.extra_info = node.second.extra_info;
-		}
-	}
-	profiler.operator_infos.clear();
-}
-
-void QueryProfiler::SetInfo(const double &blocked_thread_time) {
-	lock_guard<std::mutex> guard(lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-
-	auto &info = root->GetProfilingInfo();
-	auto metric_enabled = info.Enabled(info.expanded_settings, MetricsType::BLOCKED_THREAD_TIME);
-	if (!metric_enabled) {
-		return;
-	}
-	query_info.blocked_thread_time = blocked_thread_time;
-}
-
-string QueryProfiler::DrawPadded(const string &str, idx_t width) {
-	if (str.size() > width) {
-		return str.substr(0, width);
-	} else {
-		width -= str.size();
-		auto half_spaces = width / 2;
-		auto extra_left_space = NumericCast<idx_t>(width % 2 != 0 ? 1 : 0);
-		return string(half_spaces + extra_left_space, ' ') + str + string(half_spaces, ' ');
-	}
-}
-
-static string RenderTitleCase(string str) {
-	str = StringUtil::Lower(str);
-	str[0] = NumericCast<char>(toupper(str[0]));
-	for (idx_t i = 0; i < str.size(); i++) {
-		if (str[i] == '_') {
-			str[i] = ' ';
-			if (i + 1 < str.size()) {
-				str[i + 1] = NumericCast<char>(toupper(str[i + 1]));
-			}
-		}
-	}
-	return str;
-}
-
-static string RenderTiming(double timing) {
-	string timing_s;
-	if (timing >= 1) {
-		timing_s = StringUtil::Format("%.2f", timing);
-	} else if (timing >= 0.1) {
-		timing_s = StringUtil::Format("%.3f", timing);
-	} else {
-		timing_s = StringUtil::Format("%.4f", timing);
-	}
-	return timing_s + "s";
-}
-
-string QueryProfiler::QueryTreeToString() const {
-	std::stringstream str;
-	QueryTreeToStream(str);
-	return str.str();
-}
-
-void RenderPhaseTimings(std::ostream &ss, const pair<string, double> &head, map<string, double> &timings, idx_t width) {
-	ss << "┌────────────────────────────────────────────────┐\n";
-	ss << "│" + QueryProfiler::DrawPadded(RenderTitleCase(head.first) + ": " + RenderTiming(head.second), width - 2) +
-	          "│\n";
-	ss << "│┌──────────────────────────────────────────────┐│\n";
-
-	for (const auto &entry : timings) {
-		ss << "││" +
-		          QueryProfiler::DrawPadded(RenderTitleCase(entry.first) + ": " + RenderTiming(entry.second),
-		                                    width - 4) +
-		          "││\n";
-	}
-	ss << "│└──────────────────────────────────────────────┘│\n";
-	ss << "└────────────────────────────────────────────────┘\n";
-}
-
-void PrintPhaseTimingsToStream(std::ostream &ss, const ProfilingInfo &info, idx_t width) {
-	map<string, double> optimizer_timings;
-	map<string, double> planner_timings;
-	map<string, double> physical_planner_timings;
-
-	pair<string, double> optimizer_head;
-	pair<string, double> planner_head;
-	pair<string, double> physical_planner_head;
-
-	for (const auto &entry : info.metrics) {
-		if (MetricsUtils::IsOptimizerMetric(entry.first)) {
-			optimizer_timings[EnumUtil::ToString(entry.first).substr(10)] = entry.second.GetValue<double>();
-		} else if (MetricsUtils::IsPhaseTimingMetric(entry.first)) {
-			switch (entry.first) {
-			case MetricsType::CUMULATIVE_OPTIMIZER_TIMING:
-				continue;
-			case MetricsType::ALL_OPTIMIZERS:
-				optimizer_head = {"Optimizer", entry.second.GetValue<double>()};
-				break;
-			case MetricsType::PHYSICAL_PLANNER:
-				physical_planner_head = {"Physical Planner", entry.second.GetValue<double>()};
-				break;
-			case MetricsType::PLANNER:
-				planner_head = {"Planner", entry.second.GetValue<double>()};
-				break;
-			default:
-				break;
-			}
-
-			auto metric = EnumUtil::ToString(entry.first);
-			if (StringUtil::StartsWith(metric, "PHYSICAL_PLANNER") && entry.first != MetricsType::PHYSICAL_PLANNER) {
-				physical_planner_timings[metric.substr(17)] = entry.second.GetValue<double>();
-			} else if (StringUtil::StartsWith(metric, "PLANNER") && entry.first != MetricsType::PLANNER) {
-				planner_timings[metric.substr(8)] = entry.second.GetValue<double>();
-			}
-		}
-	}
-
-	RenderPhaseTimings(ss, optimizer_head, optimizer_timings, width);
-	RenderPhaseTimings(ss, physical_planner_head, physical_planner_timings, width);
-	RenderPhaseTimings(ss, planner_head, planner_timings, width);
-}
-
-void QueryProfiler::QueryTreeToStream(std::ostream &ss) const {
-	lock_guard<std::mutex> guard(lock);
-	ss << "┌─────────────────────────────────────┐\n";
-	ss << "│┌───────────────────────────────────┐│\n";
-	ss << "││    Query Profiling Information    ││\n";
-	ss << "│└───────────────────────────────────┘│\n";
-	ss << "└─────────────────────────────────────┘\n";
-	ss << StringUtil::Replace(query_info.query_name, "\n", " ") + "\n";
-
-	// checking the tree to ensure the query is really empty
-	// the query string is empty when a logical plan is deserialized
-	if (query_info.query_name.empty() && !root) {
-		return;
-	}
-
-	for (auto &state : context.registered_state->States()) {
-		state->WriteProfilingInformation(ss);
-	}
-
-	constexpr idx_t TOTAL_BOX_WIDTH = 50;
-	ss << "┌────────────────────────────────────────────────┐\n";
-	ss << "│┌──────────────────────────────────────────────┐│\n";
-	string total_time = "Total Time: " + RenderTiming(main_query.Elapsed());
-	ss << "││" + DrawPadded(total_time, TOTAL_BOX_WIDTH - 4) + "││\n";
-	ss << "│└──────────────────────────────────────────────┘│\n";
-	ss << "└────────────────────────────────────────────────┘\n";
-	// render the main operator tree
-	if (root) {
-		// print phase timings
-		if (PrintOptimizerOutput()) {
-			PrintPhaseTimingsToStream(ss, root->GetProfilingInfo(), TOTAL_BOX_WIDTH);
-		}
-		Render(*root, ss);
-	}
-}
-
-InsertionOrderPreservingMap<string> QueryProfiler::JSONSanitize(const InsertionOrderPreservingMap<string> &input) {
-	InsertionOrderPreservingMap<string> result;
-	for (auto &it : input) {
-		auto key = it.first;
-		if (StringUtil::StartsWith(key, "__")) {
-			key = StringUtil::Replace(key, "__", "");
-			key = StringUtil::Replace(key, "_", " ");
-			key = StringUtil::Title(key);
-		}
-		result[key] = it.second;
-	}
-	return result;
-}
-
-string QueryProfiler::JSONSanitize(const std::string &text) {
-	string result;
-	result.reserve(text.size());
-	for (char i : text) {
-		switch (i) {
-		case '\b':
-			result += "\\b";
-			break;
-		case '\f':
-			result += "\\f";
-			break;
-		case '\n':
-			result += "\\n";
-			break;
-		case '\r':
-			result += "\\r";
-			break;
-		case '\t':
-			result += "\\t";
-			break;
-		case '"':
-			result += "\\\"";
-			break;
-		case '\\':
-			result += "\\\\";
-			break;
-		default:
-			result += i;
-			break;
-		}
-	}
-	return result;
-}
-
-static yyjson_mut_val *ToJSONRecursive(yyjson_mut_doc *doc, ProfilingNode &node) {
-	auto result_obj = yyjson_mut_obj(doc);
-	auto &profiling_info = node.GetProfilingInfo();
-	profiling_info.extra_info = QueryProfiler::JSONSanitize(profiling_info.extra_info);
-	profiling_info.WriteMetricsToJSON(doc, result_obj);
-
-	auto children_list = yyjson_mut_arr(doc);
-	for (idx_t i = 0; i < node.GetChildCount(); i++) {
-		auto child = ToJSONRecursive(doc, *node.GetChild(i));
-		yyjson_mut_arr_add_val(children_list, child);
-	}
-	yyjson_mut_obj_add_val(doc, result_obj, "children", children_list);
-	return result_obj;
-}
-
-static string StringifyAndFree(yyjson_mut_doc *doc, yyjson_mut_val *object) {
-	auto data = yyjson_mut_val_write_opts(object, YYJSON_WRITE_ALLOW_INF_AND_NAN | YYJSON_WRITE_PRETTY, nullptr,
-	                                      nullptr, nullptr);
-	if (!data) {
-		yyjson_mut_doc_free(doc);
-		throw InternalException("The plan could not be rendered as JSON, yyjson failed");
-	}
-	auto result = string(data);
-	free(data);
-	yyjson_mut_doc_free(doc);
-	return result;
-}
-
-string QueryProfiler::ToJSON() const {
-	lock_guard<std::mutex> guard(lock);
-	auto doc = yyjson_mut_doc_new(nullptr);
-	auto result_obj = yyjson_mut_obj(doc);
-	yyjson_mut_doc_set_root(doc, result_obj);
-
-	if (query_info.query_name.empty() && !root) {
-		yyjson_mut_obj_add_str(doc, result_obj, "result", "empty");
-		return StringifyAndFree(doc, result_obj);
-	}
-	if (!root) {
-		yyjson_mut_obj_add_str(doc, result_obj, "result", "error");
-		return StringifyAndFree(doc, result_obj);
-	}
-
-	auto &settings = root->GetProfilingInfo();
-
-	settings.WriteMetricsToJSON(doc, result_obj);
-
-	// recursively print the physical operator tree
-	auto children_list = yyjson_mut_arr(doc);
-	yyjson_mut_obj_add_val(doc, result_obj, "children", children_list);
-	auto child = ToJSONRecursive(doc, *root->GetChild(0));
-	yyjson_mut_arr_add_val(children_list, child);
-	return StringifyAndFree(doc, result_obj);
-}
-
-void QueryProfiler::WriteToFile(const char *path, string &info) const {
-	ofstream out(path);
-	out << info;
-	out.close();
-	// throw an IO exception if it fails to write the file
-	if (out.fail()) {
-		throw IOException(strerror(errno));
-	}
-}
-
-profiler_settings_t EraseQueryRootSettings(profiler_settings_t settings) {
-	profiler_settings_t phase_timing_settings_to_erase;
-
-	for (auto &setting : settings) {
-		if (MetricsUtils::IsOptimizerMetric(setting) || MetricsUtils::IsPhaseTimingMetric(setting) ||
-		    setting == MetricsType::BLOCKED_THREAD_TIME) {
-			phase_timing_settings_to_erase.insert(setting);
-		}
-	}
-
-	for (auto &setting : phase_timing_settings_to_erase) {
-		settings.erase(setting);
-	}
-
-	return settings;
-}
-
-unique_ptr<ProfilingNode> QueryProfiler::CreateTree(const PhysicalOperator &root_p, const profiler_settings_t &settings,
-                                                    const idx_t depth) {
-	if (OperatorRequiresProfiling(root_p.type)) {
-		query_requires_profiling = true;
-	}
-
-	unique_ptr<ProfilingNode> node = make_uniq<ProfilingNode>();
-	auto &info = node->GetProfilingInfo();
-	info = ProfilingInfo(settings, depth);
-	auto child_settings = settings;
-	if (depth == 0) {
-		child_settings = EraseQueryRootSettings(child_settings);
-	}
-	node->depth = depth;
-
-	if (depth != 0) {
-		info.metrics[MetricsType::OPERATOR_NAME] = root_p.GetName();
-		info.AddToMetric<uint8_t>(MetricsType::OPERATOR_TYPE, static_cast<uint8_t>(root_p.type));
-	}
-	if (info.Enabled(info.settings, MetricsType::EXTRA_INFO)) {
-		info.extra_info = root_p.ParamsToString();
-	}
-
-	tree_map.insert(make_pair(reference<const PhysicalOperator>(root_p), reference<ProfilingNode>(*node)));
-	auto children = root_p.GetChildren();
-	for (auto &child : children) {
-		auto child_node = CreateTree(child.get(), child_settings, depth + 1);
-		node->AddChild(std::move(child_node));
-	}
-	return node;
-}
-
-string QueryProfiler::RenderDisabledMessage(ProfilerPrintFormat format) const {
-	switch (format) {
-	case ProfilerPrintFormat::NO_OUTPUT:
-		return "";
-	case ProfilerPrintFormat::QUERY_TREE:
-	case ProfilerPrintFormat::QUERY_TREE_OPTIMIZER:
-		return "Query profiling is disabled. Use 'PRAGMA enable_profiling;' to enable profiling!";
-	case ProfilerPrintFormat::HTML:
-		return R"(
-				<!DOCTYPE html>
-                <html lang="en"><head/><body>
-                  Query profiling is disabled. Use 'PRAGMA enable_profiling;' to enable profiling!
-                </body></html>
-			)";
-	case ProfilerPrintFormat::GRAPHVIZ:
-		return R"(
-				digraph G {
-				    node [shape=box, style=rounded, fontname="Courier New", fontsize=10];
-				    node_0_0 [label="Query profiling is disabled. Use 'PRAGMA enable_profiling;' to enable profiling!"];
-				}
-			)";
-	case ProfilerPrintFormat::JSON: {
-		auto doc = yyjson_mut_doc_new(nullptr);
-		auto result_obj = yyjson_mut_obj(doc);
-		yyjson_mut_doc_set_root(doc, result_obj);
-
-		yyjson_mut_obj_add_str(doc, result_obj, "result", "disabled");
-		return StringifyAndFree(doc, result_obj);
-	}
-	default:
-		throw InternalException("Unknown ProfilerPrintFormat \"%s\"", EnumUtil::ToString(format));
-	}
-}
-
-void QueryProfiler::Initialize(const PhysicalOperator &root_op) {
-	lock_guard<std::mutex> guard(lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-	query_requires_profiling = false;
-	ClientConfig &config = ClientConfig::GetConfig(context);
-	root = CreateTree(root_op, config.profiler_settings, 0);
-	if (!query_requires_profiling) {
-		// query does not require profiling: disable profiling for this query
-		this->running = false;
-		tree_map.clear();
-		root = nullptr;
-		phase_timings.clear();
-		phase_stack.clear();
-	}
-}
-
-void QueryProfiler::Render(const ProfilingNode &node, std::ostream &ss) const {
-	TextTreeRenderer renderer;
-	if (IsDetailedEnabled()) {
-		renderer.EnableDetailed();
-	} else {
-		renderer.EnableStandard();
-	}
-	renderer.Render(node, ss);
-}
-
-void QueryProfiler::Print() {
-	Printer::Print(QueryTreeToString());
-}
-
-void QueryProfiler::MoveOptimizerPhasesToRoot() {
-	auto &root_info = root->GetProfilingInfo();
-	auto &root_metrics = root_info.metrics;
-
-	for (auto &entry : phase_timings) {
-		auto &phase = entry.first;
-		auto &timing = entry.second;
-		if (root_info.Enabled(root_info.expanded_settings, phase)) {
-			root_metrics[phase] = Value::CreateValue(timing);
-		}
-	}
-}
-
-void QueryProfiler::Propagate(QueryProfiler &) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/query_result.cpp b/src/duckdb/src/main/query_result.cpp
deleted file mode 100644
index d058e4966..000000000
--- a/src/duckdb/src/main/query_result.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-#include "duckdb/main/query_result.hpp"
-
-#include "duckdb/common/box_renderer.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/main/client_context.hpp"
-namespace duckdb {
-
-BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties_p,
-                                 vector<LogicalType> types_p, vector<string> names_p)
-    : type(type), statement_type(statement_type), properties(std::move(properties_p)), types(std::move(types_p)),
-      names(std::move(names_p)), success(true) {
-	D_ASSERT(types.size() == names.size());
-}
-
-BaseQueryResult::BaseQueryResult(QueryResultType type, ErrorData error)
-    : type(type), success(false), error(std::move(error)) {
-	// Assert that the error object is initialized
-	D_ASSERT(this->error.HasError());
-}
-
-BaseQueryResult::~BaseQueryResult() {
-}
-
-void BaseQueryResult::ThrowError(const string &prepended_message) const {
-	D_ASSERT(HasError());
-	error.Throw(prepended_message);
-}
-
-void BaseQueryResult::SetError(ErrorData error) {
-	success = !error.HasError();
-	this->error = std::move(error);
-}
-
-bool BaseQueryResult::HasError() const {
-	D_ASSERT(error.HasError() == !success);
-	return !success;
-}
-
-const ExceptionType &BaseQueryResult::GetErrorType() const {
-	return error.Type();
-}
-
-const std::string &BaseQueryResult::GetError() {
-	D_ASSERT(HasError());
-	return error.Message();
-}
-
-ErrorData &BaseQueryResult::GetErrorObject() {
-	return error;
-}
-
-idx_t BaseQueryResult::ColumnCount() {
-	return types.size();
-}
-
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-                         vector<LogicalType> types_p, vector<string> names_p, ClientProperties client_properties_p)
-    : BaseQueryResult(type, statement_type, std::move(properties), std::move(types_p), std::move(names_p)),
-      client_properties(std::move(client_properties_p)) {
-}
-
-QueryResult::QueryResult(QueryResultType type, ErrorData error)
-    : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR, false, false, false) {
-}
-
-QueryResult::~QueryResult() {
-}
-
-void QueryResult::DeduplicateColumns(vector<string> &names) {
-	unordered_map<string, idx_t> name_map;
-	for (auto &column_name : names) {
-		// put it all lower_case
-		auto low_column_name = StringUtil::Lower(column_name);
-		if (name_map.find(low_column_name) == name_map.end()) {
-			// Name does not exist yet
-			name_map[low_column_name]++;
-		} else {
-			// Name already exists, we add _x where x is the repetition number
-			string new_column_name = column_name + "_" + std::to_string(name_map[low_column_name]);
-			auto new_column_name_low = StringUtil::Lower(new_column_name);
-			while (name_map.find(new_column_name_low) != name_map.end()) {
-				// This name is already here due to a previous definition
-				name_map[low_column_name]++;
-				new_column_name = column_name + "_" + std::to_string(name_map[low_column_name]);
-				new_column_name_low = StringUtil::Lower(new_column_name);
-			}
-			column_name = new_column_name;
-			name_map[new_column_name_low]++;
-		}
-	}
-}
-
-const string &QueryResult::ColumnName(idx_t index) const {
-	D_ASSERT(index < names.size());
-	return names[index];
-}
-
-string QueryResult::ToBox(ClientContext &context, const BoxRendererConfig &config) {
-	return ToString();
-}
-
-unique_ptr<DataChunk> QueryResult::Fetch() {
-	auto chunk = FetchRaw();
-	if (!chunk) {
-		return nullptr;
-	}
-	chunk->Flatten();
-	return chunk;
-}
-
-bool QueryResult::Equals(QueryResult &other) { // LCOV_EXCL_START
-	// first compare the success state of the results
-	if (success != other.success) {
-		return false;
-	}
-	if (!success) {
-		return error == other.error;
-	}
-	// compare names
-	if (names != other.names) {
-		return false;
-	}
-	// compare types
-	if (types != other.types) {
-		return false;
-	}
-	// now compare the actual values
-	// fetch chunks
-	unique_ptr<DataChunk> lchunk, rchunk;
-	idx_t lindex = 0, rindex = 0;
-	while (true) {
-		if (!lchunk || lindex == lchunk->size()) {
-			lchunk = Fetch();
-			lindex = 0;
-		}
-		if (!rchunk || rindex == rchunk->size()) {
-			rchunk = other.Fetch();
-			rindex = 0;
-		}
-		if (!lchunk && !rchunk) {
-			return true;
-		}
-		if (!lchunk || !rchunk) {
-			return false;
-		}
-		if (lchunk->size() == 0 && rchunk->size() == 0) {
-			return true;
-		}
-		D_ASSERT(lchunk->ColumnCount() == rchunk->ColumnCount());
-		for (; lindex < lchunk->size() && rindex < rchunk->size(); lindex++, rindex++) {
-			for (idx_t col = 0; col < rchunk->ColumnCount(); col++) {
-				auto lvalue = lchunk->GetValue(col, lindex);
-				auto rvalue = rchunk->GetValue(col, rindex);
-				if (lvalue.IsNull() && rvalue.IsNull()) {
-					continue;
-				}
-				if (lvalue.IsNull() != rvalue.IsNull()) {
-					return false;
-				}
-				if (lvalue != rvalue) {
-					return false;
-				}
-			}
-		}
-	}
-} // LCOV_EXCL_STOP
-
-void QueryResult::Print() {
-	Printer::Print(ToString());
-}
-
-string QueryResult::HeaderToString() {
-	string result;
-	for (auto &name : names) {
-		result += name + "\t";
-	}
-	result += "\n";
-	for (auto &type : types) {
-		result += type.ToString() + "\t";
-	}
-	result += "\n";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation.cpp b/src/duckdb/src/main/relation.cpp
deleted file mode 100644
index 9154822f9..000000000
--- a/src/duckdb/src/main/relation.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-#include "duckdb/main/relation.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/main/relation/aggregate_relation.hpp"
-#include "duckdb/main/relation/cross_product_relation.hpp"
-#include "duckdb/main/relation/distinct_relation.hpp"
-#include "duckdb/main/relation/explain_relation.hpp"
-#include "duckdb/main/relation/filter_relation.hpp"
-#include "duckdb/main/relation/insert_relation.hpp"
-#include "duckdb/main/relation/limit_relation.hpp"
-#include "duckdb/main/relation/order_relation.hpp"
-#include "duckdb/main/relation/projection_relation.hpp"
-#include "duckdb/main/relation/setop_relation.hpp"
-#include "duckdb/main/relation/subquery_relation.hpp"
-#include "duckdb/main/relation/table_function_relation.hpp"
-#include "duckdb/main/relation/create_table_relation.hpp"
-#include "duckdb/main/relation/create_view_relation.hpp"
-#include "duckdb/main/relation/write_csv_relation.hpp"
-#include "duckdb/main/relation/write_parquet_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/main/relation/join_relation.hpp"
-#include "duckdb/main/relation/value_relation.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-
-namespace duckdb {
-
-shared_ptr<Relation> Relation::Project(const string &select_list) {
-	return Project(select_list, vector<string>());
-}
-
-shared_ptr<Relation> Relation::Project(const string &expression, const string &alias) {
-	return Project(expression, vector<string>({alias}));
-}
-
-shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
-	auto expressions = Parser::ParseExpressionList(select_list, context->GetContext()->GetParserOptions());
-	return make_shared_ptr<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
-}
-
-shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
-	vector<string> aliases;
-	return Project(expressions, aliases);
-}
-
-shared_ptr<Relation> Relation::Project(vector<unique_ptr<ParsedExpression>> expressions,
-                                       const vector<string> &aliases) {
-	return make_shared_ptr<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
-}
-
-static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(const ClientContext &context,
-                                                                       const vector<string> &expressions) {
-	if (expressions.empty()) {
-		throw ParserException("Zero expressions provided");
-	}
-	vector<unique_ptr<ParsedExpression>> result_list;
-	for (auto &expr : expressions) {
-		auto expression_list = Parser::ParseExpressionList(expr, context.GetParserOptions());
-		if (expression_list.size() != 1) {
-			throw ParserException("Expected a single expression in the expression list");
-		}
-		result_list.push_back(std::move(expression_list[0]));
-	}
-	return result_list;
-}
-
-shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
-	auto result_list = StringListToExpressionList(*context->GetContext(), expressions);
-	return make_shared_ptr<ProjectionRelation>(shared_from_this(), std::move(result_list), aliases);
-}
-
-shared_ptr<Relation> Relation::Filter(const string &expression) {
-	auto expression_list = Parser::ParseExpressionList(expression, context->GetContext()->GetParserOptions());
-	if (expression_list.size() != 1) {
-		throw ParserException("Expected a single expression as filter condition");
-	}
-	return Filter(std::move(expression_list[0]));
-}
-
-shared_ptr<Relation> Relation::Filter(unique_ptr<ParsedExpression> expression) {
-	return make_shared_ptr<FilterRelation>(shared_from_this(), std::move(expression));
-}
-
-shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
-	// if there are multiple expressions, we AND them together
-	auto expression_list = StringListToExpressionList(*context->GetContext(), expressions);
-	D_ASSERT(!expression_list.empty());
-
-	auto expr = std::move(expression_list[0]);
-	for (idx_t i = 1; i < expression_list.size(); i++) {
-		expr = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
-		                                        std::move(expression_list[i]));
-	}
-	return make_shared_ptr<FilterRelation>(shared_from_this(), std::move(expr));
-}
-
-shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
-	return make_shared_ptr<LimitRelation>(shared_from_this(), limit, offset);
-}
-
-shared_ptr<Relation> Relation::Order(const string &expression) {
-	auto order_list = Parser::ParseOrderList(expression, context->GetContext()->GetParserOptions());
-	return Order(std::move(order_list));
-}
-
-shared_ptr<Relation> Relation::Order(vector<OrderByNode> order_list) {
-	return make_shared_ptr<OrderRelation>(shared_from_this(), std::move(order_list));
-}
-
-shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
-	if (expressions.empty()) {
-		throw ParserException("Zero ORDER BY expressions provided");
-	}
-	vector<OrderByNode> order_list;
-	for (auto &expression : expressions) {
-		auto inner_list = Parser::ParseOrderList(expression, context->GetContext()->GetParserOptions());
-		if (inner_list.size() != 1) {
-			throw ParserException("Expected a single ORDER BY expression in the expression list");
-		}
-		order_list.push_back(std::move(inner_list[0]));
-	}
-	return Order(std::move(order_list));
-}
-
-shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type,
-                                    JoinRefType ref_type) {
-	auto expression_list = Parser::ParseExpressionList(condition, context->GetContext()->GetParserOptions());
-	D_ASSERT(!expression_list.empty());
-	return Join(other, std::move(expression_list), type, ref_type);
-}
-
-shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other,
-                                    vector<unique_ptr<ParsedExpression>> expression_list, JoinType type,
-                                    JoinRefType ref_type) {
-	if (expression_list.size() > 1 || expression_list[0]->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		// multiple columns or single column ref: the condition is a USING list
-		vector<string> using_columns;
-		for (auto &expr : expression_list) {
-			if (expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
-				throw ParserException("Expected a single expression as join condition");
-			}
-			auto &colref = expr->Cast<ColumnRefExpression>();
-			if (colref.IsQualified()) {
-				throw ParserException("Expected unqualified column for column in USING clause");
-			}
-			using_columns.push_back(colref.column_names[0]);
-		}
-		return make_shared_ptr<JoinRelation>(shared_from_this(), other, std::move(using_columns), type, ref_type);
-	} else {
-		// single expression that is not a column reference: use the expression as a join condition
-		return make_shared_ptr<JoinRelation>(shared_from_this(), other, std::move(expression_list[0]), type, ref_type);
-	}
-}
-
-shared_ptr<Relation> Relation::CrossProduct(const shared_ptr<Relation> &other, JoinRefType join_ref_type) {
-	return make_shared_ptr<CrossProductRelation>(shared_from_this(), other, join_ref_type);
-}
-
-shared_ptr<Relation> Relation::Union(const shared_ptr<Relation> &other) {
-	return make_shared_ptr<SetOpRelation>(shared_from_this(), other, SetOperationType::UNION, true);
-}
-
-shared_ptr<Relation> Relation::Except(const shared_ptr<Relation> &other) {
-	return make_shared_ptr<SetOpRelation>(shared_from_this(), other, SetOperationType::EXCEPT, true);
-}
-
-shared_ptr<Relation> Relation::Intersect(const shared_ptr<Relation> &other) {
-	return make_shared_ptr<SetOpRelation>(shared_from_this(), other, SetOperationType::INTERSECT, true);
-}
-
-shared_ptr<Relation> Relation::Distinct() {
-	return make_shared_ptr<DistinctRelation>(shared_from_this());
-}
-
-shared_ptr<Relation> Relation::Alias(const string &alias) {
-	return make_shared_ptr<SubqueryRelation>(shared_from_this(), alias);
-}
-
-shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context->GetContext()->GetParserOptions());
-	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expression_list));
-}
-
-shared_ptr<Relation> Relation::Aggregate(vector<unique_ptr<ParsedExpression>> expressions) {
-	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expressions));
-}
-
-shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context->GetContext()->GetParserOptions());
-	auto groups = Parser::ParseGroupByList(group_list, context->GetContext()->GetParserOptions());
-	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expression_list), std::move(groups));
-}
-
-shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
-	auto aggregate_list = StringListToExpressionList(*context->GetContext(), aggregates);
-	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(aggregate_list));
-}
-
-shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringUtil::Join(aggregates, ", ");
-	auto group_list = StringUtil::Join(groups, ", ");
-	return this->Aggregate(aggregate_list, group_list);
-}
-
-shared_ptr<Relation> Relation::Aggregate(vector<unique_ptr<ParsedExpression>> expressions, const string &group_list) {
-	auto groups = Parser::ParseGroupByList(group_list, context->GetContext()->GetParserOptions());
-	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expressions), std::move(groups));
-}
-
-string Relation::GetAlias() {
-	return alias;
-}
-
-unique_ptr<TableRef> Relation::GetTableRef() {
-	auto select = make_uniq<SelectStatement>();
-	select->node = GetQueryNode();
-	return make_uniq<SubqueryRef>(std::move(select), GetAlias());
-}
-
-unique_ptr<QueryResult> Relation::Execute() {
-	return context->GetContext()->Execute(shared_from_this());
-}
-
-unique_ptr<QueryResult> Relation::ExecuteOrThrow() {
-	auto res = Execute();
-	D_ASSERT(res);
-	if (res->HasError()) {
-		res->ThrowError();
-	}
-	return res;
-}
-
-BoundStatement Relation::Bind(Binder &binder) {
-	SelectStatement stmt;
-	stmt.node = GetQueryNode();
-	return binder.Bind(stmt.Cast<SQLStatement>());
-}
-
-shared_ptr<Relation> Relation::InsertRel(const string &schema_name, const string &table_name) {
-	return make_shared_ptr<InsertRelation>(shared_from_this(), schema_name, table_name);
-}
-
-void Relation::Insert(const string &table_name) {
-	Insert(INVALID_SCHEMA, table_name);
-}
-
-void Relation::Insert(const string &schema_name, const string &table_name) {
-	auto insert = InsertRel(schema_name, table_name);
-	auto res = insert->Execute();
-	if (res->HasError()) {
-		const string prepended_message = "Failed to insert into table '" + table_name + "': ";
-		res->ThrowError(prepended_message);
-	}
-}
-
-void Relation::Insert(const vector<vector<Value>> &values) {
-	vector<string> column_names;
-	auto rel = make_shared_ptr<ValueRelation>(context->GetContext(), values, std::move(column_names), "values");
-	rel->Insert(GetAlias());
-}
-
-void Relation::Insert(vector<vector<unique_ptr<ParsedExpression>>> &&expressions) {
-	vector<string> column_names;
-	auto rel = make_shared_ptr<ValueRelation>(context->GetContext(), std::move(expressions), std::move(column_names),
-	                                          "values");
-	rel->Insert(GetAlias());
-}
-
-shared_ptr<Relation> Relation::CreateRel(const string &schema_name, const string &table_name, bool temporary,
-                                         OnCreateConflict on_conflict) {
-	return make_shared_ptr<CreateTableRelation>(shared_from_this(), schema_name, table_name, temporary, on_conflict);
-}
-
-void Relation::Create(const string &table_name, bool temporary, OnCreateConflict on_conflict) {
-	Create(INVALID_SCHEMA, table_name, temporary, on_conflict);
-}
-
-void Relation::Create(const string &schema_name, const string &table_name, bool temporary,
-                      OnCreateConflict on_conflict) {
-	auto create = CreateRel(schema_name, table_name, temporary, on_conflict);
-	auto res = create->Execute();
-	if (res->HasError()) {
-		const string prepended_message = "Failed to create table '" + table_name + "': ";
-		res->ThrowError(prepended_message);
-	}
-}
-
-shared_ptr<Relation> Relation::WriteCSVRel(const string &csv_file, case_insensitive_map_t<vector<Value>> options) {
-	return make_shared_ptr<duckdb::WriteCSVRelation>(shared_from_this(), csv_file, std::move(options));
-}
-
-void Relation::WriteCSV(const string &csv_file, case_insensitive_map_t<vector<Value>> options) {
-	auto write_csv = WriteCSVRel(csv_file, std::move(options));
-	auto res = write_csv->Execute();
-	if (res->HasError()) {
-		const string prepended_message = "Failed to write '" + csv_file + "': ";
-		res->ThrowError(prepended_message);
-	}
-}
-
-shared_ptr<Relation> Relation::WriteParquetRel(const string &parquet_file,
-                                               case_insensitive_map_t<vector<Value>> options) {
-	auto write_parquet =
-	    make_shared_ptr<duckdb::WriteParquetRelation>(shared_from_this(), parquet_file, std::move(options));
-	return std::move(write_parquet);
-}
-
-void Relation::WriteParquet(const string &parquet_file, case_insensitive_map_t<vector<Value>> options) {
-	auto write_parquet = WriteParquetRel(parquet_file, std::move(options));
-	auto res = write_parquet->Execute();
-	if (res->HasError()) {
-		const string prepended_message = "Failed to write '" + parquet_file + "': ";
-		res->ThrowError(prepended_message);
-	}
-}
-
-shared_ptr<Relation> Relation::CreateView(const string &name, bool replace, bool temporary) {
-	return CreateView(INVALID_SCHEMA, name, replace, temporary);
-}
-
-shared_ptr<Relation> Relation::CreateView(const string &schema_name, const string &name, bool replace, bool temporary) {
-	auto view = make_shared_ptr<CreateViewRelation>(shared_from_this(), schema_name, name, replace, temporary);
-	auto res = view->Execute();
-	if (res->HasError()) {
-		const string prepended_message = "Failed to create view '" + name + "': ";
-		res->ThrowError(prepended_message);
-	}
-	return shared_from_this();
-}
-
-unique_ptr<QueryResult> Relation::Query(const string &sql) const {
-	return context->GetContext()->Query(sql, false);
-}
-
-unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
-    bool replace = true;
-    bool temp = IsReadOnly();
-	CreateView(name, replace, temp);
-	return Query(sql);
-}
-
-unique_ptr<QueryResult> Relation::Explain(ExplainType type, ExplainFormat format) {
-	auto explain = make_shared_ptr<ExplainRelation>(shared_from_this(), type, format);
-	return explain->Execute();
-}
-
-void Relation::TryBindRelation(vector<ColumnDefinition> &columns) {
-	context->TryBindRelation(*this, columns);
-}
-
-void Relation::Update(const string &update, const string &condition) {
-	throw InvalidInputException("UPDATE can only be used on base tables!");
-}
-
-void Relation::Update(vector<string>, // NOLINT: unused variable / copied on every invocation ...
-                      vector<unique_ptr<ParsedExpression>> &&update, // NOLINT: unused variable
-                      unique_ptr<ParsedExpression> condition) {      // NOLINT: unused variable
-	(void)std::move(update);
-	(void)std::move(condition);
-	throw InvalidInputException("UPDATE can only be used on base tables!");
-}
-
-void Relation::Delete(const string &condition) {
-	throw InvalidInputException("DELETE can only be used on base tables!");
-}
-
-shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
-                                             const named_parameter_map_t &named_parameters) {
-	return make_shared_ptr<TableFunctionRelation>(context->GetContext(), fname, values, named_parameters,
-	                                              shared_from_this());
-}
-
-shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values) {
-	return make_shared_ptr<TableFunctionRelation>(context->GetContext(), fname, values, shared_from_this());
-}
-
-string Relation::ToString() {
-	string str;
-	str += "---------------------\n";
-	str += "--- Relation Tree ---\n";
-	str += "---------------------\n";
-	str += ToString(0);
-	str += "\n\n";
-	str += "---------------------\n";
-	str += "-- Result Columns  --\n";
-	str += "---------------------\n";
-	auto &cols = Columns();
-	for (idx_t i = 0; i < cols.size(); i++) {
-		str += "- " + cols[i].Name() + " (" + cols[i].Type().ToString() + ")\n";
-	}
-	return str;
-}
-
-// LCOV_EXCL_START
-unique_ptr<QueryNode> Relation::GetQueryNode() {
-	throw InternalException("Cannot create a query node from this node type");
-}
-
-void Relation::Head(idx_t limit) {
-	auto limit_node = Limit(NumericCast<int64_t>(limit));
-	limit_node->Execute()->Print();
-}
-// LCOV_EXCL_STOP
-
-void Relation::Print() {
-	Printer::Print(ToString());
-}
-
-string Relation::RenderWhitespace(idx_t depth) {
-	return string(depth * 2, ' ');
-}
-
-void Relation::AddExternalDependency(shared_ptr<ExternalDependency> dependency) {
-	external_dependencies.push_back(std::move(dependency));
-}
-
-vector<shared_ptr<ExternalDependency>> Relation::GetAllDependencies() {
-	vector<shared_ptr<ExternalDependency>> all_dependencies;
-	Relation *cur = this;
-	while (cur) {
-		for (auto &dep : cur->external_dependencies) {
-			all_dependencies.push_back(dep);
-		}
-		cur = cur->ChildRelation();
-	}
-	return all_dependencies;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/aggregate_relation.cpp b/src/duckdb/src/main/relation/aggregate_relation.cpp
deleted file mode 100644
index daf663e3b..000000000
--- a/src/duckdb/src/main/relation/aggregate_relation.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include "duckdb/main/relation/aggregate_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-
-namespace duckdb {
-
-AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
-                                     vector<unique_ptr<ParsedExpression>> parsed_expressions)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      child(std::move(child_p)) {
-	// bind the expressions
-	TryBindRelation(columns);
-}
-
-AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
-                                     vector<unique_ptr<ParsedExpression>> parsed_expressions, GroupByNode groups_p)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      groups(std::move(groups_p)), child(std::move(child_p)) {
-	// bind the expressions
-	Relation::TryBindRelation(columns);
-}
-
-AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
-                                     vector<unique_ptr<ParsedExpression>> parsed_expressions,
-                                     vector<unique_ptr<ParsedExpression>> groups_p)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      child(std::move(child_p)) {
-	if (!groups_p.empty()) {
-		// explicit groups provided: use standard handling
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < groups_p.size(); i++) {
-			groups.group_expressions.push_back(std::move(groups_p[i]));
-			grouping_set.insert(i);
-		}
-		groups.grouping_sets.push_back(std::move(grouping_set));
-	}
-	// bind the expressions
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
-	auto child_ptr = child.get();
-	while (child_ptr->InheritsColumnBindings()) {
-		child_ptr = child_ptr->ChildRelation();
-	}
-	unique_ptr<QueryNode> result;
-	if (child_ptr->type == RelationType::JOIN_RELATION) {
-		// child node is a join: push projection into the child query node
-		result = child->GetQueryNode();
-	} else {
-		// child node is not a join: create a new select node and push the child as a table reference
-		auto select = make_uniq<SelectNode>();
-		select->from_table = child->GetTableRef();
-		result = std::move(select);
-	}
-	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = result->Cast<SelectNode>();
-	if (!groups.group_expressions.empty()) {
-		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;
-		select_node.groups = groups.Copy();
-	} else {
-		// no groups provided: automatically figure out groups (if any)
-		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;
-	}
-	select_node.select_list.clear();
-	for (auto &expr : expressions) {
-		select_node.select_list.push_back(expr->Copy());
-	}
-	return result;
-}
-
-string AggregateRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &AggregateRelation::Columns() {
-	return columns;
-}
-
-string AggregateRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Aggregate [";
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i != 0) {
-			str += ", ";
-		}
-		str += expressions[i]->ToString();
-	}
-	str += "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/create_table_relation.cpp b/src/duckdb/src/main/relation/create_table_relation.cpp
deleted file mode 100644
index 2492f244b..000000000
--- a/src/duckdb/src/main/relation/create_table_relation.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/main/relation/create_table_relation.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name,
-                                         bool temporary_p, OnCreateConflict on_conflict)
-    : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(std::move(child_p)),
-      schema_name(std::move(schema_name)), table_name(std::move(table_name)), temporary(temporary_p),
-      on_conflict(on_conflict) {
-	TryBindRelation(columns);
-}
-
-BoundStatement CreateTableRelation::Bind(Binder &binder) {
-	auto select = make_uniq<SelectStatement>();
-	select->node = child->GetQueryNode();
-
-	CreateStatement stmt;
-	auto info = make_uniq<CreateTableInfo>();
-	info->schema = schema_name;
-	info->table = table_name;
-	info->query = std::move(select);
-	info->on_conflict = on_conflict;
-	info->temporary = temporary;
-	stmt.info = std::move(info);
-	return binder.Bind(stmt.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &CreateTableRelation::Columns() {
-	return columns;
-}
-
-string CreateTableRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Create Table\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/create_view_relation.cpp b/src/duckdb/src/main/relation/create_view_relation.cpp
deleted file mode 100644
index c00deef38..000000000
--- a/src/duckdb/src/main/relation/create_view_relation.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/main/relation/create_view_relation.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view_name_p, bool replace_p,
-                                       bool temporary_p)
-    : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(std::move(child_p)),
-      view_name(std::move(view_name_p)), replace(replace_p), temporary(temporary_p) {
-	TryBindRelation(columns);
-}
-
-CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string schema_name_p, string view_name_p,
-                                       bool replace_p, bool temporary_p)
-    : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(std::move(child_p)),
-      schema_name(std::move(schema_name_p)), view_name(std::move(view_name_p)), replace(replace_p),
-      temporary(temporary_p) {
-	TryBindRelation(columns);
-}
-
-BoundStatement CreateViewRelation::Bind(Binder &binder) {
-	auto select = make_uniq<SelectStatement>();
-	select->node = child->GetQueryNode();
-
-	CreateStatement stmt;
-	auto info = make_uniq<CreateViewInfo>();
-	info->query = std::move(select);
-	info->view_name = view_name;
-	info->temporary = temporary;
-	info->schema = schema_name;
-	info->on_conflict = replace ? OnCreateConflict::REPLACE_ON_CONFLICT : OnCreateConflict::ERROR_ON_CONFLICT;
-	stmt.info = std::move(info);
-	return binder.Bind(stmt.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &CreateViewRelation::Columns() {
-	return columns;
-}
-
-string CreateViewRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Create View\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/cross_product_relation.cpp b/src/duckdb/src/main/relation/cross_product_relation.cpp
deleted file mode 100644
index e0645fae1..000000000
--- a/src/duckdb/src/main/relation/cross_product_relation.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/main/relation/cross_product_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-
-namespace duckdb {
-
-CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
-                                           JoinRefType ref_type)
-    : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(std::move(left_p)),
-      right(std::move(right_p)), ref_type(ref_type) {
-	if (left->context->GetContext() != right->context->GetContext()) {
-		throw InvalidInputException("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_uniq<JoinRef>(ref_type);
-	cross_product_ref->left = left->GetTableRef();
-	cross_product_ref->right = right->GetTableRef();
-	return std::move(cross_product_ref);
-}
-
-const vector<ColumnDefinition> &CrossProductRelation::Columns() {
-	return this->columns;
-}
-
-string CrossProductRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	str = "Cross Product";
-	return str + "\n" + left->ToString(depth + 1) + right->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/delete_relation.cpp b/src/duckdb/src/main/relation/delete_relation.cpp
deleted file mode 100644
index bbc0d58ef..000000000
--- a/src/duckdb/src/main/relation/delete_relation.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/main/relation/delete_relation.hpp"
-#include "duckdb/parser/statement/delete_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-
-namespace duckdb {
-
-DeleteRelation::DeleteRelation(shared_ptr<ClientContextWrapper> &context, unique_ptr<ParsedExpression> condition_p,
-                               string schema_name_p, string table_name_p)
-    : Relation(context, RelationType::DELETE_RELATION), condition(std::move(condition_p)),
-      schema_name(std::move(schema_name_p)), table_name(std::move(table_name_p)) {
-	TryBindRelation(columns);
-}
-
-BoundStatement DeleteRelation::Bind(Binder &binder) {
-	auto basetable = make_uniq<BaseTableRef>();
-	basetable->schema_name = schema_name;
-	basetable->table_name = table_name;
-
-	DeleteStatement stmt;
-	stmt.condition = condition ? condition->Copy() : nullptr;
-	stmt.table = std::move(basetable);
-	return binder.Bind(stmt.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &DeleteRelation::Columns() {
-	return columns;
-}
-
-string DeleteRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "DELETE FROM " + table_name;
-	if (condition) {
-		str += " WHERE " + condition->ToString();
-	}
-	return str;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/delim_get_relation.cpp b/src/duckdb/src/main/relation/delim_get_relation.cpp
deleted file mode 100644
index 3f1b9cbc8..000000000
--- a/src/duckdb/src/main/relation/delim_get_relation.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "duckdb/main/relation/delim_get_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/delimgetref.hpp"
-
-namespace duckdb {
-
-DelimGetRelation::DelimGetRelation(const shared_ptr<ClientContext> &context, vector<LogicalType> chunk_types_p)
-    : Relation(context, RelationType::DELIM_GET_RELATION), chunk_types(std::move(chunk_types_p)) {
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> DelimGetRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> DelimGetRelation::GetTableRef() {
-	auto delim_get_ref = make_uniq<DelimGetRef>(chunk_types);
-	return std::move(delim_get_ref);
-}
-
-const vector<ColumnDefinition> &DelimGetRelation::Columns() {
-	return this->columns;
-}
-
-string DelimGetRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	str += "Delimiter Get [";
-	for (idx_t i = 0; i < chunk_types.size(); i++) {
-		str += chunk_types[i].ToString();
-		if (i + 1 < chunk_types.size()) {
-			str += ", ";
-		}
-	}
-	str += "]";
-
-	return str;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/distinct_relation.cpp b/src/duckdb/src/main/relation/distinct_relation.cpp
deleted file mode 100644
index 16bb53822..000000000
--- a/src/duckdb/src/main/relation/distinct_relation.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/main/relation/distinct_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-DistinctRelation::DistinctRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::DISTINCT_RELATION), child(std::move(child_p)) {
-	D_ASSERT(child.get() != this);
-	vector<ColumnDefinition> dummy_columns;
-	TryBindRelation(dummy_columns);
-}
-
-unique_ptr<QueryNode> DistinctRelation::GetQueryNode() {
-	auto child_node = child->GetQueryNode();
-	child_node->AddDistinct();
-	return child_node;
-}
-
-string DistinctRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &DistinctRelation::Columns() {
-	return child->Columns();
-}
-
-string DistinctRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Distinct\n";
-	return str + child->ToString(depth + 1);
-	;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/explain_relation.cpp b/src/duckdb/src/main/relation/explain_relation.cpp
deleted file mode 100644
index f91e1d29f..000000000
--- a/src/duckdb/src/main/relation/explain_relation.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/main/relation/explain_relation.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type, ExplainFormat format)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type),
-      format(format) {
-	TryBindRelation(columns);
-}
-
-BoundStatement ExplainRelation::Bind(Binder &binder) {
-	auto select = make_uniq<SelectStatement>();
-	select->node = child->GetQueryNode();
-	ExplainStatement explain(std::move(select), type, format);
-	return binder.Bind(explain.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &ExplainRelation::Columns() {
-	return columns;
-}
-
-string ExplainRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Explain\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/filter_relation.cpp b/src/duckdb/src/main/relation/filter_relation.cpp
deleted file mode 100644
index 738e83577..000000000
--- a/src/duckdb/src/main/relation/filter_relation.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/main/relation/filter_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-
-namespace duckdb {
-
-FilterRelation::FilterRelation(shared_ptr<Relation> child_p, unique_ptr<ParsedExpression> condition_p)
-    : Relation(child_p->context, RelationType::FILTER_RELATION), condition(std::move(condition_p)),
-      child(std::move(child_p)) {
-	D_ASSERT(child.get() != this);
-	vector<ColumnDefinition> dummy_columns;
-	TryBindRelation(dummy_columns);
-}
-
-unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
-	auto child_ptr = child.get();
-	while (child_ptr->InheritsColumnBindings()) {
-		child_ptr = child_ptr->ChildRelation();
-	}
-	if (child_ptr->type == RelationType::JOIN_RELATION) {
-		// child node is a join: push filter into WHERE clause of select node
-		auto child_node = child->GetQueryNode();
-		D_ASSERT(child_node->type == QueryNodeType::SELECT_NODE);
-		auto &select_node = child_node->Cast<SelectNode>();
-		if (!select_node.where_clause) {
-			select_node.where_clause = condition->Copy();
-		} else {
-			select_node.where_clause = make_uniq<ConjunctionExpression>(
-			    ExpressionType::CONJUNCTION_AND, std::move(select_node.where_clause), condition->Copy());
-		}
-		return child_node;
-	} else {
-		auto result = make_uniq<SelectNode>();
-		result->select_list.push_back(make_uniq<StarExpression>());
-		result->from_table = child->GetTableRef();
-		result->where_clause = condition->Copy();
-		return std::move(result);
-	}
-}
-
-string FilterRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &FilterRelation::Columns() {
-	return child->Columns();
-}
-
-string FilterRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Filter [" + condition->ToString() + "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/insert_relation.cpp b/src/duckdb/src/main/relation/insert_relation.cpp
deleted file mode 100644
index 9728570a0..000000000
--- a/src/duckdb/src/main/relation/insert_relation.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/main/relation/insert_relation.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
-    : Relation(child_p->context, RelationType::INSERT_RELATION), child(std::move(child_p)),
-      schema_name(std::move(schema_name)), table_name(std::move(table_name)) {
-	TryBindRelation(columns);
-}
-
-BoundStatement InsertRelation::Bind(Binder &binder) {
-	InsertStatement stmt;
-	auto select = make_uniq<SelectStatement>();
-	select->node = child->GetQueryNode();
-
-	stmt.schema = schema_name;
-	stmt.table = table_name;
-	stmt.select_statement = std::move(select);
-	return binder.Bind(stmt.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &InsertRelation::Columns() {
-	return columns;
-}
-
-string InsertRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Insert\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/join_relation.cpp b/src/duckdb/src/main/relation/join_relation.cpp
deleted file mode 100644
index b3701ea39..000000000
--- a/src/duckdb/src/main/relation/join_relation.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "duckdb/main/relation/join_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/main/client_context_wrapper.hpp"
-
-namespace duckdb {
-
-JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
-                           unique_ptr<ParsedExpression> condition_p, JoinType type, JoinRefType join_ref_type)
-    : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
-      condition(std::move(condition_p)), join_type(type), join_ref_type(join_ref_type) {
-	if (left->context->GetContext() != right->context->GetContext()) {
-		throw InvalidInputException("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	TryBindRelation(columns);
-}
-
-JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, vector<string> using_columns_p,
-                           JoinType type, JoinRefType join_ref_type)
-    : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
-      using_columns(std::move(using_columns_p)), join_type(type), join_ref_type(join_ref_type) {
-	if (left->context->GetContext() != right->context->GetContext()) {
-		throw InvalidInputException("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> JoinRelation::GetTableRef() {
-	auto join_ref = make_uniq<JoinRef>(join_ref_type);
-	join_ref->left = left->GetTableRef();
-	join_ref->right = right->GetTableRef();
-	if (condition) {
-		join_ref->condition = condition->Copy();
-	}
-	join_ref->using_columns = using_columns;
-	join_ref->type = join_type;
-	join_ref->delim_flipped = delim_flipped;
-	for (auto &col : duplicate_eliminated_columns) {
-		join_ref->duplicate_eliminated_columns.emplace_back(col->Copy());
-	}
-	return std::move(join_ref);
-}
-
-const vector<ColumnDefinition> &JoinRelation::Columns() {
-	return this->columns;
-}
-
-string JoinRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	str += "Join " + EnumUtil::ToString(join_ref_type) + " " + EnumUtil::ToString(join_type);
-	if (condition) {
-		str += " " + condition->GetName();
-	}
-
-	return str + "\n" + left->ToString(depth + 1) + "\n" + right->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/limit_relation.cpp b/src/duckdb/src/main/relation/limit_relation.cpp
deleted file mode 100644
index c3a87b0e1..000000000
--- a/src/duckdb/src/main/relation/limit_relation.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/main/relation/limit_relation.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-LimitRelation::LimitRelation(shared_ptr<Relation> child_p, int64_t limit, int64_t offset)
-    : Relation(child_p->context, RelationType::LIMIT_RELATION), limit(limit), offset(offset),
-      child(std::move(child_p)) {
-	D_ASSERT(child.get() != this);
-}
-
-unique_ptr<QueryNode> LimitRelation::GetQueryNode() {
-	auto child_node = child->GetQueryNode();
-	auto limit_node = make_uniq<LimitModifier>();
-	if (limit >= 0) {
-		limit_node->limit = make_uniq<ConstantExpression>(Value::BIGINT(limit));
-	}
-	if (offset > 0) {
-		limit_node->offset = make_uniq<ConstantExpression>(Value::BIGINT(offset));
-	}
-
-	child_node->modifiers.push_back(std::move(limit_node));
-	return child_node;
-}
-
-string LimitRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &LimitRelation::Columns() {
-	return child->Columns();
-}
-
-string LimitRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Limit " + to_string(limit);
-	if (offset > 0) {
-		str += " Offset " + to_string(offset);
-	}
-	str += "\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/materialized_relation.cpp b/src/duckdb/src/main/relation/materialized_relation.cpp
deleted file mode 100644
index 8e17168f0..000000000
--- a/src/duckdb/src/main/relation/materialized_relation.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/main/relation/materialized_relation.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/bound_statement.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-#include "duckdb/parser/tableref/column_data_ref.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-MaterializedRelation::MaterializedRelation(const shared_ptr<ClientContext> &context,
-                                           unique_ptr<ColumnDataCollection> &&collection_p, vector<string> names,
-                                           string alias_p)
-    : Relation(context, RelationType::MATERIALIZED_RELATION), alias(std::move(alias_p)),
-      collection(std::move(collection_p)) {
-	// create constant expressions for the values
-	auto types = collection->Types();
-	D_ASSERT(types.size() == names.size());
-
-	QueryResult::DeduplicateColumns(names);
-	for (idx_t i = 0; i < types.size(); i++) {
-		auto &type = types[i];
-		auto &name = names[i];
-		auto column_definition = ColumnDefinition(name, type);
-		columns.push_back(std::move(column_definition));
-	}
-}
-
-unique_ptr<QueryNode> MaterializedRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> MaterializedRelation::GetTableRef() {
-	auto table_ref = make_uniq<ColumnDataRef>(collection);
-	for (auto &col : columns) {
-		table_ref->expected_names.push_back(col.Name());
-	}
-	table_ref->alias = GetAlias();
-	return std::move(table_ref);
-}
-
-string MaterializedRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &MaterializedRelation::Columns() {
-	return columns;
-}
-
-string MaterializedRelation::ToString(idx_t depth) {
-	return collection->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/order_relation.cpp b/src/duckdb/src/main/relation/order_relation.cpp
deleted file mode 100644
index ac97d1c52..000000000
--- a/src/duckdb/src/main/relation/order_relation.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/main/relation/order_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-
-namespace duckdb {
-
-OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> orders)
-    : Relation(child_p->context, RelationType::ORDER_RELATION), orders(std::move(orders)), child(std::move(child_p)) {
-	D_ASSERT(child.get() != this);
-	// bind the expressions
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
-	auto select = make_uniq<SelectNode>();
-	select->from_table = child->GetTableRef();
-	select->select_list.push_back(make_uniq<StarExpression>());
-	auto order_node = make_uniq<OrderModifier>();
-	for (idx_t i = 0; i < orders.size(); i++) {
-		order_node->orders.emplace_back(orders[i].type, orders[i].null_order, orders[i].expression->Copy());
-	}
-	select->modifiers.push_back(std::move(order_node));
-	return std::move(select);
-}
-
-string OrderRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &OrderRelation::Columns() {
-	return columns;
-}
-
-string OrderRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Order [";
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (i != 0) {
-			str += ", ";
-		}
-		str += orders[i].expression->ToString() + (orders[i].type == OrderType::ASCENDING ? " ASC" : " DESC");
-	}
-	str += "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/projection_relation.cpp b/src/duckdb/src/main/relation/projection_relation.cpp
deleted file mode 100644
index 0577ce73d..000000000
--- a/src/duckdb/src/main/relation/projection_relation.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "duckdb/main/relation/projection_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-
-namespace duckdb {
-
-ProjectionRelation::ProjectionRelation(shared_ptr<Relation> child_p,
-                                       vector<unique_ptr<ParsedExpression>> parsed_expressions, vector<string> aliases)
-    : Relation(child_p->context, RelationType::PROJECTION_RELATION), expressions(std::move(parsed_expressions)),
-      child(std::move(child_p)) {
-	if (!aliases.empty()) {
-		if (aliases.size() != expressions.size()) {
-			throw ParserException("Aliases list length must match expression list length!");
-		}
-		for (idx_t i = 0; i < aliases.size(); i++) {
-			expressions[i]->SetAlias(aliases[i]);
-		}
-	}
-	// bind the expressions
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
-	auto child_ptr = child.get();
-	while (child_ptr->InheritsColumnBindings()) {
-		child_ptr = child_ptr->ChildRelation();
-	}
-	unique_ptr<QueryNode> result;
-	if (child_ptr->type == RelationType::JOIN_RELATION) {
-		// child node is a join: push projection into the child query node
-		result = child->GetQueryNode();
-	} else {
-		// child node is not a join: create a new select node and push the child as a table reference
-		auto select = make_uniq<SelectNode>();
-		select->from_table = child->GetTableRef();
-		result = std::move(select);
-	}
-	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = result->Cast<SelectNode>();
-	select_node.aggregate_handling = AggregateHandling::NO_AGGREGATES_ALLOWED;
-	select_node.select_list.clear();
-	for (auto &expr : expressions) {
-		select_node.select_list.push_back(expr->Copy());
-	}
-	return result;
-}
-
-string ProjectionRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &ProjectionRelation::Columns() {
-	return columns;
-}
-
-string ProjectionRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Projection [";
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i != 0) {
-			str += ", ";
-		}
-		str += expressions[i]->ToString() + " as " + expressions[i]->GetAlias();
-	}
-	str += "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/query_relation.cpp b/src/duckdb/src/main/relation/query_relation.cpp
deleted file mode 100644
index bc0bfd4e5..000000000
--- a/src/duckdb/src/main/relation/query_relation.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "duckdb/main/relation/query_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/planner/bound_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/common_table_expression_info.hpp"
-
-namespace duckdb {
-
-QueryRelation::QueryRelation(const shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt_p,
-                             string alias_p, const string &query_p)
-    : Relation(context, RelationType::QUERY_RELATION), select_stmt(std::move(select_stmt_p)), query(query_p),
-      alias(std::move(alias_p)) {
-	if (query.empty()) {
-		query = select_stmt->ToString();
-	}
-	TryBindRelation(columns);
-}
-
-QueryRelation::~QueryRelation() {
-}
-
-unique_ptr<SelectStatement> QueryRelation::ParseStatement(ClientContext &context, const string &query,
-                                                          const string &error) {
-	Parser parser(context.GetParserOptions());
-	parser.ParseQuery(query);
-	if (parser.statements.size() != 1) {
-		throw ParserException(error);
-	}
-	if (parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException(error);
-	}
-	return unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
-}
-
-unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
-	return unique_ptr_cast<SQLStatement, SelectStatement>(select_stmt->Copy());
-}
-
-unique_ptr<QueryNode> QueryRelation::GetQueryNode() {
-	auto select = GetSelectStatement();
-	return std::move(select->node);
-}
-
-unique_ptr<TableRef> QueryRelation::GetTableRef() {
-	auto subquery_ref = make_uniq<SubqueryRef>(GetSelectStatement(), GetAlias());
-	return std::move(subquery_ref);
-}
-
-BoundStatement QueryRelation::Bind(Binder &binder) {
-	auto saved_binding_mode = binder.GetBindingMode();
-	binder.SetBindingMode(BindingMode::EXTRACT_REPLACEMENT_SCANS);
-	bool first_bind = columns.empty();
-	auto result = Relation::Bind(binder);
-	auto &replacements = binder.GetReplacementScans();
-	if (first_bind) {
-		auto &query_node = *select_stmt->node;
-		auto &cte_map = query_node.cte_map;
-		for (auto &kv : replacements) {
-			auto &name = kv.first;
-			auto &tableref = kv.second;
-
-			if (!tableref->external_dependency) {
-				// Only push a CTE for objects that are out of our control (i.e Python)
-				// This makes sure replacement scans for files (parquet/csv/json etc) are not transformed into a CTE
-				continue;
-			}
-
-			auto select = make_uniq<SelectStatement>();
-			auto select_node = make_uniq<SelectNode>();
-			select_node->select_list.push_back(make_uniq<StarExpression>());
-			select_node->from_table = std::move(tableref);
-			select->node = std::move(select_node);
-
-			auto cte_info = make_uniq<CommonTableExpressionInfo>();
-			cte_info->query = std::move(select);
-
-			cte_map.map[name] = std::move(cte_info);
-		}
-	}
-	replacements.clear();
-	binder.SetBindingMode(saved_binding_mode);
-	return result;
-}
-
-string QueryRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &QueryRelation::Columns() {
-	return columns;
-}
-
-string QueryRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Subquery";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/read_csv_relation.cpp b/src/duckdb/src/main/relation/read_csv_relation.cpp
deleted file mode 100644
index 4720a8e52..000000000
--- a/src/duckdb/src/main/relation/read_csv_relation.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-#include "duckdb/main/relation/read_csv_relation.hpp"
-
-#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-namespace duckdb {
-
-void ReadCSVRelation::InitializeAlias(const vector<string> &input) {
-	D_ASSERT(!input.empty());
-	const auto &csv_file = input[0];
-	alias = StringUtil::Split(csv_file, ".")[0];
-}
-
-ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const vector<string> &input,
-                                 named_parameter_map_t &&options, string alias_p)
-    : TableFunctionRelation(context, "read_csv_auto", {MultiFileReader::CreateValueFromFileList(input)}, nullptr,
-                            false),
-      alias(std::move(alias_p)) {
-
-	InitializeAlias(input);
-
-	auto file_list = MultiFileReader::CreateValueFromFileList(input);
-
-	auto multi_file_reader = MultiFileReader::CreateDefault("ReadCSVRelation");
-	vector<string> files;
-	context->RunFunctionInTransaction(
-	    [&]() { files = multi_file_reader->CreateFileList(*context, file_list)->GetAllFiles(); });
-	D_ASSERT(!files.empty());
-
-	auto &file_name = files[0];
-	CSVReaderOptions csv_options;
-	csv_options.file_path = file_name;
-	vector<string> empty;
-	csv_options.FromNamedParameters(options, *context);
-
-	// Run the auto-detect, populating the options with the detected settings
-
-	if (csv_options.file_options.union_by_name) {
-		SimpleMultiFileList multi_file_list(files);
-		vector<LogicalType> types;
-		vector<string> names;
-		auto result = make_uniq<ReadCSVData>();
-
-		multi_file_reader->BindUnionReader<CSVFileScan>(*context, types, names, multi_file_list, *result, csv_options);
-		if (result->union_readers.size() > 1) {
-			for (idx_t i = 0; i < result->union_readers.size(); i++) {
-				result->column_info.emplace_back(result->union_readers[i]->names, result->union_readers[i]->types);
-			}
-		}
-		if (!csv_options.sql_types_per_column.empty()) {
-			const auto exception = CSVError::ColumnTypesError(csv_options.sql_types_per_column, names);
-			if (!exception.error_message.empty()) {
-				throw BinderException(exception.error_message);
-			}
-			for (idx_t i = 0; i < names.size(); i++) {
-				auto it = csv_options.sql_types_per_column.find(names[i]);
-				if (it != csv_options.sql_types_per_column.end()) {
-					types[i] = csv_options.sql_type_list[it->second];
-				}
-			}
-		}
-		D_ASSERT(names.size() == types.size());
-		for (idx_t i = 0; i < names.size(); i++) {
-			columns.emplace_back(names[i], types[i]);
-		}
-	} else {
-		if (csv_options.auto_detect) {
-			shared_ptr<CSVBufferManager> buffer_manager;
-			context->RunFunctionInTransaction([&]() {
-				buffer_manager = make_shared_ptr<CSVBufferManager>(*context, csv_options, files[0], 0);
-				CSVSniffer sniffer(csv_options, buffer_manager, CSVStateMachineCache::Get(*context));
-				auto sniffer_result = sniffer.SniffCSV();
-				auto &types = sniffer_result.return_types;
-				auto &names = sniffer_result.names;
-				for (idx_t i = 0; i < types.size(); i++) {
-					columns.emplace_back(names[i], types[i]);
-				}
-			});
-		} else {
-			for (idx_t i = 0; i < csv_options.sql_type_list.size(); i++) {
-				D_ASSERT(csv_options.name_list.size() == csv_options.sql_type_list.size());
-				columns.emplace_back(csv_options.name_list[i], csv_options.sql_type_list[i]);
-			}
-		}
-		// After sniffing we can consider these set, so they are exported as named parameters
-		// FIXME: This is horribly hacky, should be refactored at some point
-		csv_options.dialect_options.state_machine_options.escape.ChangeSetByUserTrue();
-		csv_options.dialect_options.state_machine_options.delimiter.ChangeSetByUserTrue();
-		csv_options.dialect_options.state_machine_options.quote.ChangeSetByUserTrue();
-		csv_options.dialect_options.header.ChangeSetByUserTrue();
-		csv_options.dialect_options.skip_rows.ChangeSetByUserTrue();
-	}
-
-	// Capture the options potentially set/altered by the auto-detection phase
-	csv_options.ToNamedParameters(options);
-
-	// No need to auto-detect again
-	options["auto_detect"] = Value::BOOLEAN(false);
-	SetNamedParameters(std::move(options));
-
-	child_list_t<Value> column_names;
-	for (idx_t i = 0; i < columns.size(); i++) {
-		column_names.push_back(make_pair(columns[i].Name(), Value(columns[i].Type().ToString())));
-	}
-
-	if (!csv_options.file_options.union_by_name) {
-		AddNamedParameter("columns", Value::STRUCT(std::move(column_names)));
-	}
-	RemoveNamedParameterIfExists("names");
-	RemoveNamedParameterIfExists("types");
-	RemoveNamedParameterIfExists("dtypes");
-}
-
-string ReadCSVRelation::GetAlias() {
-	return alias;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/read_json_relation.cpp b/src/duckdb/src/main/relation/read_json_relation.cpp
deleted file mode 100644
index 6d80369d3..000000000
--- a/src/duckdb/src/main/relation/read_json_relation.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "duckdb/main/relation/read_json_relation.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-
-namespace duckdb {
-
-void ReadJSONRelation::InitializeAlias(const vector<string> &input) {
-	D_ASSERT(!input.empty());
-	const auto &first_file = input[0];
-	alias = StringUtil::Split(first_file, ".")[0];
-}
-
-ReadJSONRelation::ReadJSONRelation(const shared_ptr<ClientContext> &context, vector<string> &input,
-                                   named_parameter_map_t options, bool auto_detect, string alias_p)
-    : TableFunctionRelation(context, auto_detect ? "read_json_auto" : "read_json",
-                            {MultiFileReader::CreateValueFromFileList(input)}, std::move(options)),
-      alias(std::move(alias_p)) {
-
-	InitializeAlias(input);
-}
-
-ReadJSONRelation::ReadJSONRelation(const shared_ptr<ClientContext> &context, string json_file_p,
-                                   named_parameter_map_t options, bool auto_detect, string alias_p)
-    : TableFunctionRelation(context, auto_detect ? "read_json_auto" : "read_json", {Value(json_file_p)},
-                            std::move(options)),
-      json_file(std::move(json_file_p)), alias(std::move(alias_p)) {
-
-	if (alias.empty()) {
-		alias = StringUtil::Split(json_file, ".")[0];
-	}
-}
-
-ReadJSONRelation::~ReadJSONRelation() {
-}
-
-string ReadJSONRelation::GetAlias() {
-	return alias;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/setop_relation.cpp b/src/duckdb/src/main/relation/setop_relation.cpp
deleted file mode 100644
index a0253df37..000000000
--- a/src/duckdb/src/main/relation/setop_relation.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "duckdb/main/relation/setop_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-
-namespace duckdb {
-
-SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, SetOperationType setop_type_p,
-                             bool setop_all)
-    : Relation(left_p->context, RelationType::SET_OPERATION_RELATION), left(std::move(left_p)),
-      right(std::move(right_p)), setop_type(setop_type_p), setop_all(setop_all) {
-	if (left->context->GetContext() != right->context->GetContext()) {
-		throw InvalidInputException("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
-	auto result = make_uniq<SetOperationNode>();
-	if (!setop_all) {
-		result->modifiers.push_back(make_uniq<DistinctModifier>());
-	}
-	result->left = left->GetQueryNode();
-	result->right = right->GetQueryNode();
-	result->setop_type = setop_type;
-	result->setop_all = setop_all;
-	return std::move(result);
-}
-
-string SetOpRelation::GetAlias() {
-	return left->GetAlias();
-}
-
-const vector<ColumnDefinition> &SetOpRelation::Columns() {
-	return this->columns;
-}
-
-string SetOpRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	switch (setop_type) {
-	case SetOperationType::UNION:
-		str += "Union";
-		break;
-	case SetOperationType::EXCEPT:
-		str += "Except";
-		break;
-	case SetOperationType::INTERSECT:
-		str += "Intersect";
-		break;
-	default:
-		throw InternalException("Unknown setop type");
-	}
-	return str + "\n" + left->ToString(depth + 1) + right->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/subquery_relation.cpp b/src/duckdb/src/main/relation/subquery_relation.cpp
deleted file mode 100644
index 2e83ed124..000000000
--- a/src/duckdb/src/main/relation/subquery_relation.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/main/relation/subquery_relation.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-SubqueryRelation::SubqueryRelation(shared_ptr<Relation> child_p, const string &alias_p)
-    : Relation(child_p->context, RelationType::SUBQUERY_RELATION, alias_p), child(std::move(child_p)) {
-	D_ASSERT(child.get() != this);
-	vector<ColumnDefinition> dummy_columns;
-	Relation::TryBindRelation(dummy_columns);
-}
-
-unique_ptr<QueryNode> SubqueryRelation::GetQueryNode() {
-	return child->GetQueryNode();
-}
-
-const vector<ColumnDefinition> &SubqueryRelation::Columns() {
-	return child->Columns();
-}
-
-string SubqueryRelation::ToString(idx_t depth) {
-	return child->ToString(depth);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/table_function_relation.cpp b/src/duckdb/src/main/relation/table_function_relation.cpp
deleted file mode 100644
index 5111752e2..000000000
--- a/src/duckdb/src/main/relation/table_function_relation.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "duckdb/main/relation/table_function_relation.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/common/shared_ptr.hpp"
-
-namespace duckdb {
-
-void TableFunctionRelation::AddNamedParameter(const string &name, Value argument) {
-	named_parameters[name] = std::move(argument);
-}
-
-void TableFunctionRelation::RemoveNamedParameterIfExists(const string &name) {
-	if (named_parameters.find(name) != named_parameters.end()) {
-		named_parameters.erase(name);
-	}
-}
-
-void TableFunctionRelation::SetNamedParameters(named_parameter_map_t &&options) {
-	D_ASSERT(named_parameters.empty());
-	named_parameters = std::move(options);
-}
-
-TableFunctionRelation::TableFunctionRelation(const shared_ptr<ClientContext> &context, string name_p,
-                                             vector<Value> parameters_p, named_parameter_map_t named_parameters,
-                                             shared_ptr<Relation> input_relation_p, bool auto_init)
-    : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(std::move(name_p)),
-      parameters(std::move(parameters_p)), named_parameters(std::move(named_parameters)),
-      input_relation(std::move(input_relation_p)), auto_initialize(auto_init) {
-	InitializeColumns();
-}
-
-TableFunctionRelation::TableFunctionRelation(const shared_ptr<RelationContextWrapper> &context, string name_p,
-                                             vector<Value> parameters_p, named_parameter_map_t named_parameters,
-                                             shared_ptr<Relation> input_relation_p, bool auto_init)
-    : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(std::move(name_p)),
-      parameters(std::move(parameters_p)), named_parameters(std::move(named_parameters)),
-      input_relation(std::move(input_relation_p)), auto_initialize(auto_init) {
-	InitializeColumns();
-}
-
-TableFunctionRelation::TableFunctionRelation(const shared_ptr<ClientContext> &context, string name_p,
-                                             vector<Value> parameters_p, shared_ptr<Relation> input_relation_p,
-                                             bool auto_init)
-    : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(std::move(name_p)),
-      parameters(std::move(parameters_p)), input_relation(std::move(input_relation_p)), auto_initialize(auto_init) {
-	InitializeColumns();
-}
-
-void TableFunctionRelation::InitializeColumns() {
-	if (!auto_initialize) {
-		return;
-	}
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> TableFunctionRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> TableFunctionRelation::GetTableRef() {
-	vector<unique_ptr<ParsedExpression>> children;
-	if (input_relation) { // input relation becomes first parameter if present, always
-		auto subquery = make_uniq<SubqueryExpression>();
-		subquery->subquery = make_uniq<SelectStatement>();
-		subquery->subquery->node = input_relation->GetQueryNode();
-		subquery->subquery_type = SubqueryType::SCALAR;
-		children.push_back(std::move(subquery));
-	}
-	for (auto &parameter : parameters) {
-		children.push_back(make_uniq<ConstantExpression>(parameter));
-	}
-
-	for (auto &parameter : named_parameters) {
-		// Hackity-hack some comparisons with column refs
-		// This is all but pretty, basically the named parameter is the column, the table is empty because that's what
-		// the function binder likes
-		auto column_ref = make_uniq<ColumnRefExpression>(parameter.first);
-		auto constant_value = make_uniq<ConstantExpression>(parameter.second);
-		auto comparison = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(column_ref),
-		                                                  std::move(constant_value));
-		children.push_back(std::move(comparison));
-	}
-
-	auto table_function = make_uniq<TableFunctionRef>();
-	auto function = make_uniq<FunctionExpression>(name, std::move(children));
-	table_function->function = std::move(function);
-	return std::move(table_function);
-}
-
-string TableFunctionRelation::GetAlias() {
-	return name;
-}
-
-const vector<ColumnDefinition> &TableFunctionRelation::Columns() {
-	return columns;
-}
-
-string TableFunctionRelation::ToString(idx_t depth) {
-	string function_call = name + "(";
-	for (idx_t i = 0; i < parameters.size(); i++) {
-		if (i > 0) {
-			function_call += ", ";
-		}
-		function_call += parameters[i].ToString();
-	}
-	function_call += ")";
-	return RenderWhitespace(depth) + function_call;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/table_relation.cpp b/src/duckdb/src/main/relation/table_relation.cpp
deleted file mode 100644
index 1b790a698..000000000
--- a/src/duckdb/src/main/relation/table_relation.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/main/relation/table_relation.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/main/relation/delete_relation.hpp"
-#include "duckdb/main/relation/update_relation.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-TableRelation::TableRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description)
-    : Relation(context, RelationType::TABLE_RELATION), description(std::move(description)) {
-}
-
-TableRelation::TableRelation(const shared_ptr<RelationContextWrapper> &context,
-                             unique_ptr<TableDescription> description)
-    : Relation(context, RelationType::TABLE_RELATION), description(std::move(description)) {
-}
-
-unique_ptr<QueryNode> TableRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> TableRelation::GetTableRef() {
-	auto table_ref = make_uniq<BaseTableRef>();
-	table_ref->schema_name = description->schema;
-	table_ref->table_name = description->table;
-	return std::move(table_ref);
-}
-
-string TableRelation::GetAlias() {
-	return description->table;
-}
-
-const vector<ColumnDefinition> &TableRelation::Columns() {
-	return description->columns;
-}
-
-string TableRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Scan Table [" + description->table + "]";
-}
-
-static unique_ptr<ParsedExpression> ParseCondition(ClientContext &context, const string &condition) {
-	if (!condition.empty()) {
-		auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
-		if (expression_list.size() != 1) {
-			throw ParserException("Expected a single expression as filter condition");
-		}
-		return std::move(expression_list[0]);
-	} else {
-		return nullptr;
-	}
-}
-
-void TableRelation::Update(vector<string> names, vector<unique_ptr<ParsedExpression>> &&update,
-                           unique_ptr<ParsedExpression> condition) {
-	vector<string> update_columns = std::move(names);
-	vector<unique_ptr<ParsedExpression>> expressions = std::move(update);
-
-	auto update_relation =
-	    make_shared_ptr<UpdateRelation>(context, std::move(condition), description->schema, description->table,
-	                                    std::move(update_columns), std::move(expressions));
-	update_relation->Execute();
-}
-
-void TableRelation::Update(const string &update_list, const string &condition) {
-	vector<string> update_columns;
-	vector<unique_ptr<ParsedExpression>> expressions;
-	auto cond = ParseCondition(*context->GetContext(), condition);
-	Parser::ParseUpdateList(update_list, update_columns, expressions, context->GetContext()->GetParserOptions());
-	auto update = make_shared_ptr<UpdateRelation>(context, std::move(cond), description->schema, description->table,
-	                                              std::move(update_columns), std::move(expressions));
-	update->Execute();
-}
-
-void TableRelation::Delete(const string &condition) {
-	auto cond = ParseCondition(*context->GetContext(), condition);
-	auto del = make_shared_ptr<DeleteRelation>(context, std::move(cond), description->schema, description->table);
-	del->Execute();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/update_relation.cpp b/src/duckdb/src/main/relation/update_relation.cpp
deleted file mode 100644
index 6dd34dfc5..000000000
--- a/src/duckdb/src/main/relation/update_relation.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/main/relation/update_relation.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-
-namespace duckdb {
-
-UpdateRelation::UpdateRelation(shared_ptr<ClientContextWrapper> &context, unique_ptr<ParsedExpression> condition_p,
-                               string schema_name_p, string table_name_p, vector<string> update_columns_p,
-                               vector<unique_ptr<ParsedExpression>> expressions_p)
-    : Relation(context, RelationType::UPDATE_RELATION), condition(std::move(condition_p)),
-      schema_name(std::move(schema_name_p)), table_name(std::move(table_name_p)),
-      update_columns(std::move(update_columns_p)), expressions(std::move(expressions_p)) {
-	D_ASSERT(update_columns.size() == expressions.size());
-	TryBindRelation(columns);
-}
-
-BoundStatement UpdateRelation::Bind(Binder &binder) {
-	auto basetable = make_uniq<BaseTableRef>();
-	basetable->schema_name = schema_name;
-	basetable->table_name = table_name;
-
-	UpdateStatement stmt;
-	stmt.set_info = make_uniq<UpdateSetInfo>();
-
-	stmt.set_info->condition = condition ? condition->Copy() : nullptr;
-	stmt.table = std::move(basetable);
-	stmt.set_info->columns = update_columns;
-	for (auto &expr : expressions) {
-		stmt.set_info->expressions.push_back(expr->Copy());
-	}
-	return binder.Bind(stmt.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &UpdateRelation::Columns() {
-	return columns;
-}
-
-string UpdateRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "UPDATE " + table_name + " SET\n";
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		str += update_columns[i] + " = " + expressions[i]->ToString() + "\n";
-	}
-	if (condition) {
-		str += "WHERE " + condition->ToString() + "\n";
-	}
-	return str;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/value_relation.cpp b/src/duckdb/src/main/relation/value_relation.cpp
deleted file mode 100644
index bd9adf991..000000000
--- a/src/duckdb/src/main/relation/value_relation.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "duckdb/main/relation/value_relation.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parser.hpp"
-
-namespace duckdb {
-
-ValueRelation::ValueRelation(const shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
-                             vector<string> names_p, string alias_p)
-    : Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) {
-	// create constant expressions for the values
-	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
-		auto &list = values[row_idx];
-		vector<unique_ptr<ParsedExpression>> expressions;
-		for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-			expressions.push_back(make_uniq<ConstantExpression>(list[col_idx]));
-		}
-		this->expressions.push_back(std::move(expressions));
-	}
-	QueryResult::DeduplicateColumns(names);
-	TryBindRelation(columns);
-}
-
-ValueRelation::ValueRelation(const shared_ptr<ClientContext> &context,
-                             vector<vector<unique_ptr<ParsedExpression>>> &&expressions_p, vector<string> names_p,
-                             string alias_p)
-    : ValueRelation(make_shared_ptr<RelationContextWrapper>(context), std::move(expressions_p), std::move(names_p),
-                    std::move(alias_p)) {
-}
-
-ValueRelation::ValueRelation(const shared_ptr<ClientContext> &context, const string &values_list,
-                             vector<string> names_p, string alias_p)
-    : Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) {
-	this->expressions = Parser::ParseValuesList(values_list, context->GetParserOptions());
-	QueryResult::DeduplicateColumns(names);
-	TryBindRelation(columns);
-}
-
-ValueRelation::ValueRelation(const shared_ptr<RelationContextWrapper> &context, const vector<vector<Value>> &values,
-                             vector<string> names_p, string alias_p)
-    : Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) {
-	// create constant expressions for the values
-	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
-		auto &list = values[row_idx];
-		vector<unique_ptr<ParsedExpression>> expressions;
-		for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-			expressions.push_back(make_uniq<ConstantExpression>(list[col_idx]));
-		}
-		this->expressions.push_back(std::move(expressions));
-	}
-	QueryResult::DeduplicateColumns(names);
-	TryBindRelation(columns);
-}
-
-ValueRelation::ValueRelation(const shared_ptr<RelationContextWrapper> &context,
-                             vector<vector<unique_ptr<ParsedExpression>>> &&expressions_p, vector<string> names_p,
-                             string alias_p)
-    : Relation(context, RelationType::VALUE_LIST_RELATION), alias(std::move(alias_p)) {
-	D_ASSERT(!expressions_p.empty());
-	if (names_p.empty()) {
-		auto &first_list = expressions_p[0];
-		for (auto &expr : first_list) {
-			names_p.push_back(expr->GetName());
-		}
-	}
-	names = std::move(names_p);
-	expressions = std::move(expressions_p);
-	QueryResult::DeduplicateColumns(names);
-	TryBindRelation(columns);
-}
-
-unique_ptr<QueryNode> ValueRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> ValueRelation::GetTableRef() {
-	auto table_ref = make_uniq<ExpressionListRef>();
-	// set the expected types/names
-	if (columns.empty()) {
-		// no columns yet: only set up names
-		for (idx_t i = 0; i < names.size(); i++) {
-			table_ref->expected_names.push_back(names[i]);
-		}
-	} else {
-		for (idx_t i = 0; i < columns.size(); i++) {
-			table_ref->expected_names.push_back(columns[i].Name());
-			table_ref->expected_types.push_back(columns[i].Type());
-			D_ASSERT(names.size() == 0 || columns[i].Name() == names[i]);
-		}
-	}
-	// copy the expressions
-	for (auto &expr_list : expressions) {
-		vector<unique_ptr<ParsedExpression>> copied_list;
-		copied_list.reserve(expr_list.size());
-		for (auto &expr : expr_list) {
-			copied_list.push_back(expr->Copy());
-		}
-		table_ref->values.push_back(std::move(copied_list));
-	}
-	table_ref->alias = GetAlias();
-	return std::move(table_ref);
-}
-
-string ValueRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &ValueRelation::Columns() {
-	return columns;
-}
-
-string ValueRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Values ";
-	for (idx_t row_idx = 0; row_idx < expressions.size(); row_idx++) {
-		auto &list = expressions[row_idx];
-		str += row_idx > 0 ? ", (" : "(";
-		for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-			str += col_idx > 0 ? ", " : "";
-			str += list[col_idx]->ToString();
-		}
-		str += ")";
-	}
-	str += "\n";
-	return str;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/view_relation.cpp b/src/duckdb/src/main/relation/view_relation.cpp
deleted file mode 100644
index 16c1bdc37..000000000
--- a/src/duckdb/src/main/relation/view_relation.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/main/relation/view_relation.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parser.hpp"
-
-namespace duckdb {
-
-ViewRelation::ViewRelation(const shared_ptr<ClientContext> &context, string schema_name_p, string view_name_p)
-    : Relation(context, RelationType::VIEW_RELATION), schema_name(std::move(schema_name_p)),
-      view_name(std::move(view_name_p)) {
-	TryBindRelation(columns);
-}
-
-ViewRelation::ViewRelation(const shared_ptr<RelationContextWrapper> &context, string schema_name_p, string view_name_p)
-    : Relation(context, RelationType::VIEW_RELATION), schema_name(std::move(schema_name_p)),
-      view_name(std::move(view_name_p)) {
-	TryBindRelation(columns);
-}
-
-ViewRelation::ViewRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableRef> ref, const string &view_name)
-    : Relation(context, RelationType::VIEW_RELATION), view_name(view_name), premade_tableref(std::move(ref)) {
-	TryBindRelation(columns);
-	premade_tableref->alias = view_name;
-}
-
-unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
-	auto result = make_uniq<SelectNode>();
-	result->select_list.push_back(make_uniq<StarExpression>());
-	result->from_table = GetTableRef();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> ViewRelation::GetTableRef() {
-	if (premade_tableref) {
-		return premade_tableref->Copy();
-	}
-	auto table_ref = make_uniq<BaseTableRef>();
-	table_ref->schema_name = schema_name;
-	table_ref->table_name = view_name;
-	return std::move(table_ref);
-}
-
-string ViewRelation::GetAlias() {
-	D_ASSERT(!view_name.empty());
-	return view_name;
-}
-
-const vector<ColumnDefinition> &ViewRelation::Columns() {
-	return columns;
-}
-
-string ViewRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "View [" + view_name + "]";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/write_csv_relation.cpp b/src/duckdb/src/main/relation/write_csv_relation.cpp
deleted file mode 100644
index 4795c7a51..000000000
--- a/src/duckdb/src/main/relation/write_csv_relation.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/main/relation/write_csv_relation.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-WriteCSVRelation::WriteCSVRelation(shared_ptr<Relation> child_p, string csv_file_p,
-                                   case_insensitive_map_t<vector<Value>> options_p)
-    : Relation(child_p->context, RelationType::WRITE_CSV_RELATION), child(std::move(child_p)),
-      csv_file(std::move(csv_file_p)), options(std::move(options_p)) {
-	TryBindRelation(columns);
-}
-
-BoundStatement WriteCSVRelation::Bind(Binder &binder) {
-	CopyStatement copy;
-	auto info = make_uniq<CopyInfo>();
-	info->select_statement = child->GetQueryNode();
-	info->is_from = false;
-	info->file_path = csv_file;
-	info->format = "csv";
-	info->options = options;
-	copy.info = std::move(info);
-	return binder.Bind(copy.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &WriteCSVRelation::Columns() {
-	return columns;
-}
-
-string WriteCSVRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Write To CSV [" + csv_file + "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/relation/write_parquet_relation.cpp b/src/duckdb/src/main/relation/write_parquet_relation.cpp
deleted file mode 100644
index d6e403618..000000000
--- a/src/duckdb/src/main/relation/write_parquet_relation.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/main/relation/write_parquet_relation.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-WriteParquetRelation::WriteParquetRelation(shared_ptr<Relation> child_p, string parquet_file_p,
-                                           case_insensitive_map_t<vector<Value>> options_p)
-    : Relation(child_p->context, RelationType::WRITE_PARQUET_RELATION), child(std::move(child_p)),
-      parquet_file(std::move(parquet_file_p)), options(std::move(options_p)) {
-	TryBindRelation(columns);
-}
-
-BoundStatement WriteParquetRelation::Bind(Binder &binder) {
-	CopyStatement copy;
-	auto info = make_uniq<CopyInfo>();
-	info->select_statement = child->GetQueryNode();
-	info->is_from = false;
-	info->file_path = parquet_file;
-	info->format = "parquet";
-	info->options = options;
-	copy.info = std::move(info);
-	return binder.Bind(copy.Cast<SQLStatement>());
-}
-
-const vector<ColumnDefinition> &WriteParquetRelation::Columns() {
-	return columns;
-}
-
-string WriteParquetRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Write To Parquet [" + parquet_file + "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/secret/default_secrets.cpp b/src/duckdb/src/main/secret/default_secrets.cpp
deleted file mode 100644
index 2dd9fbc85..000000000
--- a/src/duckdb/src/main/secret/default_secrets.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "duckdb/main/secret/default_secrets.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-
-namespace duckdb {
-
-vector<SecretType> CreateHTTPSecretFunctions::GetDefaultSecretTypes() {
-	vector<SecretType> result;
-
-	// HTTP secret
-	SecretType secret_type;
-	secret_type.name = "http";
-	secret_type.deserializer = KeyValueSecret::Deserialize<KeyValueSecret>;
-	secret_type.default_provider = "config";
-	result.push_back(std::move(secret_type));
-
-	return result;
-}
-
-//! Get the default secret functions
-vector<CreateSecretFunction> CreateHTTPSecretFunctions::GetDefaultSecretFunctions() {
-	vector<CreateSecretFunction> result;
-
-	// HTTP secret CONFIG provider
-	CreateSecretFunction http_config_fun;
-	http_config_fun.secret_type = "http";
-	http_config_fun.provider = "config";
-	http_config_fun.function = CreateHTTPSecretFromConfig;
-
-	http_config_fun.named_parameters["http_proxy"] = LogicalType::VARCHAR;
-	http_config_fun.named_parameters["http_proxy_password"] = LogicalType::VARCHAR;
-	http_config_fun.named_parameters["http_proxy_username"] = LogicalType::VARCHAR;
-
-	http_config_fun.named_parameters["extra_http_headers"] =
-	    LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	http_config_fun.named_parameters["bearer_token"] = LogicalType::VARCHAR;
-	result.push_back(std::move(http_config_fun));
-
-	// HTTP secret ENV provider
-	CreateSecretFunction http_env_fun;
-	http_env_fun.secret_type = "http";
-	http_env_fun.provider = "env";
-	http_env_fun.function = CreateHTTPSecretFromEnv;
-
-	http_env_fun.named_parameters["http_proxy"] = LogicalType::VARCHAR;
-	http_env_fun.named_parameters["http_proxy_password"] = LogicalType::VARCHAR;
-	http_env_fun.named_parameters["http_proxy_username"] = LogicalType::VARCHAR;
-
-	http_env_fun.named_parameters["extra_http_headers"] = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	http_env_fun.named_parameters["bearer_token"] = LogicalType::VARCHAR;
-	result.push_back(std::move(http_env_fun));
-
-	return result;
-}
-
-static const char *TryGetEnv(const char *name) {
-	const char *res = std::getenv(name);
-	if (res) {
-		return res;
-	}
-	return std::getenv(StringUtil::Upper(name).c_str());
-}
-
-unique_ptr<BaseSecret> CreateHTTPSecretFunctions::CreateHTTPSecretFromEnv(ClientContext &context,
-                                                                          CreateSecretInput &input) {
-	auto secret = make_uniq<KeyValueSecret>(input.scope, input.type, input.provider, input.name);
-
-	auto http_proxy = TryGetEnv("http_proxy");
-	if (http_proxy) {
-		secret->secret_map["http_proxy"] = Value(http_proxy);
-	}
-	auto http_proxy_password = TryGetEnv("http_proxy_password");
-	if (http_proxy_password) {
-		secret->secret_map["http_proxy_password"] = Value(http_proxy_password);
-	}
-	auto http_proxy_username = TryGetEnv("http_proxy_username");
-	if (http_proxy_username) {
-		secret->secret_map["http_proxy_username"] = Value(http_proxy_username);
-	}
-
-	// Allow overwrites
-	secret->TrySetValue("http_proxy", input);
-	secret->TrySetValue("http_proxy_password", input);
-	secret->TrySetValue("http_proxy_username", input);
-
-	secret->TrySetValue("extra_http_headers", input);
-	secret->TrySetValue("bearer_token", input);
-
-	return std::move(secret);
-}
-
-unique_ptr<BaseSecret> CreateHTTPSecretFunctions::CreateHTTPSecretFromConfig(ClientContext &context,
-                                                                             CreateSecretInput &input) {
-	auto secret = make_uniq<KeyValueSecret>(input.scope, input.type, input.provider, input.name);
-
-	secret->TrySetValue("http_proxy", input);
-	secret->TrySetValue("http_proxy_password", input);
-	secret->TrySetValue("http_proxy_username", input);
-
-	secret->TrySetValue("extra_http_headers", input);
-	secret->TrySetValue("bearer_token", input);
-
-	//! Set redact keys
-	secret->redact_keys = {"http_proxy_password"};
-
-	return std::move(secret);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/secret/secret.cpp b/src/duckdb/src/main/secret/secret.cpp
deleted file mode 100644
index 9a39b7176..000000000
--- a/src/duckdb/src/main/secret/secret.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-#include "duckdb/main/secret/secret.hpp"
-
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/file_opener.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-
-namespace duckdb {
-
-int64_t BaseSecret::MatchScore(const string &path) const {
-	int64_t longest_match = NumericLimits<int64_t>::Minimum();
-
-	if (prefix_paths.empty()) {
-		longest_match = 0;
-	}
-
-	for (const auto &prefix : prefix_paths) {
-		// Handle empty scope which matches all at lowest possible score
-		if (prefix.empty()) {
-			longest_match = 0;
-			continue;
-		}
-		if (StringUtil::StartsWith(path, prefix)) {
-			longest_match = MaxValue<int64_t>(NumericCast<int64_t>(prefix.length()), longest_match);
-		}
-	}
-	return longest_match;
-}
-
-void BaseSecret::SerializeBaseSecret(Serializer &serializer) const {
-	serializer.WriteProperty(100, "type", type);
-	serializer.WriteProperty(101, "provider", provider);
-	serializer.WriteProperty(102, "name", name);
-	serializer.WriteList(103, "scope", prefix_paths.size(),
-	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(prefix_paths[i]); });
-}
-
-string BaseSecret::ToString(SecretDisplayType display_type) const {
-	return "";
-}
-
-void BaseSecret::Serialize(Serializer &serializer) const {
-	throw InternalException("Attempted to serialize secret without serialize");
-}
-
-string KeyValueSecret::ToString(SecretDisplayType mode) const {
-	string result;
-
-	result += "name=" + name + ";";
-	result += "type=" + type + ";";
-	result += "provider=" + provider + ";";
-	result += string("serializable=") + (serializable ? "true" : "false") + ";";
-	result += "scope=";
-	for (const auto &scope_it : prefix_paths) {
-		result += scope_it + ",";
-	}
-	result = result.substr(0, result.size() - 1);
-	result += ";";
-	for (auto it = secret_map.begin(); it != secret_map.end(); it++) {
-		result.append(it->first);
-		result.append("=");
-		if (mode == SecretDisplayType::REDACTED && redact_keys.find(it->first) != redact_keys.end()) {
-			result.append("redacted");
-		} else {
-			result.append(it->second.ToString());
-		}
-		if (it != --secret_map.end()) {
-			result.append(";");
-		}
-	}
-
-	return result;
-}
-
-// FIXME: use serialization scripts
-void KeyValueSecret::Serialize(Serializer &serializer) const {
-	BaseSecret::SerializeBaseSecret(serializer);
-
-	vector<Value> map_values;
-	for (auto it = secret_map.begin(); it != secret_map.end(); it++) {
-		child_list_t<Value> map_struct;
-		map_struct.push_back(make_pair("key", Value(it->first)));
-		map_struct.push_back(make_pair("value", Value(it->second)));
-		map_values.push_back(Value::STRUCT(map_struct));
-	}
-
-	// Warning: the secret map is serialized into a single MAP value with type ANY
-	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::ANY);
-	auto map = Value::MAP(ListType::GetChildType(map_type), map_values);
-	serializer.WriteProperty(201, "secret_map", map);
-
-	vector<Value> redact_key_values;
-	for (auto it = redact_keys.begin(); it != redact_keys.end(); it++) {
-		redact_key_values.push_back(*it);
-	}
-	auto list = Value::LIST(LogicalType::VARCHAR, redact_key_values);
-	serializer.WriteProperty(202, "redact_keys", list);
-}
-
-Value KeyValueSecret::TryGetValue(const string &key, bool error_on_missing) const {
-	auto lookup = secret_map.find(key);
-	if (lookup == secret_map.end()) {
-		if (error_on_missing) {
-			throw InternalException("Failed to fetch key '%s' from secret '%s' of type '%s'", key, name, type);
-		}
-		return Value();
-	}
-
-	return lookup->second;
-}
-
-KeyValueSecretReader::KeyValueSecretReader(DatabaseInstance &db_p, const char **secret_types, idx_t secret_types_len,
-                                           string path_p) {
-	db = db_p;
-	path = std::move(path_p);
-	Initialize(secret_types, secret_types_len);
-}
-
-KeyValueSecretReader::KeyValueSecretReader(DatabaseInstance &db_p, const char *secret_type, string path)
-    : KeyValueSecretReader(db_p, &secret_type, 1, std::move(path)) {
-}
-
-KeyValueSecretReader::KeyValueSecretReader(ClientContext &context_p, const char **secret_types, idx_t secret_types_len,
-                                           string path_p) {
-	context = context_p;
-	path = std::move(path_p);
-	Initialize(secret_types, secret_types_len);
-}
-KeyValueSecretReader::KeyValueSecretReader(ClientContext &context_p, const char *secret_type, string path)
-    : KeyValueSecretReader(context_p, &secret_type, 1, std::move(path)) {
-}
-
-KeyValueSecretReader::KeyValueSecretReader(FileOpener &opener_p, optional_ptr<FileOpenerInfo> info,
-                                           const char *secret_type)
-    : KeyValueSecretReader(opener_p, info, &secret_type, 1) {
-}
-
-void KeyValueSecretReader::Initialize(const char **secret_types, idx_t secret_types_len) {
-	if (!db) {
-		// TODO does this even work?
-		return;
-	}
-
-	auto &secret_manager = db->GetSecretManager();
-	auto transaction = context ? CatalogTransaction::GetSystemCatalogTransaction(*context)
-	                           : CatalogTransaction::GetSystemTransaction(*db);
-
-	SecretMatch secret_match;
-	for (idx_t i = 0; i < secret_types_len; i++) {
-		auto &secret_type = secret_types[i];
-		secret_match = secret_manager.LookupSecret(transaction, path, secret_type);
-		if (secret_match.HasMatch()) {
-			break;
-		}
-	}
-
-	if (secret_match.HasMatch()) {
-		secret = dynamic_cast<const KeyValueSecret &>(secret_match.GetSecret());
-		secret_entry = std::move(secret_match.secret_entry);
-	}
-}
-
-KeyValueSecretReader::KeyValueSecretReader(FileOpener &opener_p, optional_ptr<FileOpenerInfo> info,
-                                           const char **secret_types, idx_t secret_types_len) {
-	db = opener_p.TryGetDatabase();
-	context = opener_p.TryGetClientContext();
-
-	if (info) {
-		path = info->file_path;
-	}
-
-	Initialize(secret_types, secret_types_len);
-}
-
-KeyValueSecretReader::~KeyValueSecretReader() {
-}
-
-SettingLookupResult KeyValueSecretReader::TryGetSecretKey(const string &secret_key, Value &result) {
-	if (secret && secret->TryGetValue(secret_key, result)) {
-		return SettingLookupResult(SettingScope::SECRET);
-	}
-	return SettingLookupResult();
-}
-
-SettingLookupResult KeyValueSecretReader::TryGetSecretKeyOrSetting(const string &secret_key, const string &setting_name,
-                                                                   Value &result) {
-	if (secret && secret->TryGetValue(secret_key, result)) {
-		return SettingLookupResult(SettingScope::SECRET);
-	}
-	if (context) {
-		auto res = context->TryGetCurrentSetting(setting_name, result);
-		if (res) {
-			return res;
-		}
-	}
-	if (db) {
-		db->TryGetCurrentSetting(setting_name, result);
-	}
-	return SettingLookupResult();
-}
-
-Value KeyValueSecretReader::GetSecretKey(const string &secret_key) {
-	Value result;
-	if (TryGetSecretKey(secret_key, result)) {
-		return result;
-	}
-	ThrowNotFoundError(secret_key);
-}
-
-Value KeyValueSecretReader::GetSecretKeyOrSetting(const string &secret_key, const string &setting_name) {
-	Value result;
-	if (TryGetSecretKeyOrSetting(secret_key, setting_name, result)) {
-		return result;
-	}
-	ThrowNotFoundError(secret_key, setting_name);
-}
-
-void KeyValueSecretReader::ThrowNotFoundError(const string &secret_key) {
-	string base_message = "Failed to fetch required secret key '%s' from secret";
-
-	if (!secret) {
-		string secret_scope = path;
-		string secret_scope_hint_message = secret_scope.empty() ? "." : " for '" + secret_scope + "'.";
-		throw InvalidConfigurationException(base_message + ", because no secret was found%s", secret_key,
-		                                    secret_scope_hint_message);
-	}
-
-	throw InvalidConfigurationException(base_message + " '%s'.", secret_key, secret->GetName());
-}
-
-void KeyValueSecretReader::ThrowNotFoundError(const string &secret_key, const string &setting_name) {
-	string base_message = "Failed to fetch a parameter from either the secret key '%s' or the setting '%s'";
-
-	if (!secret) {
-		string secret_scope = path;
-		string secret_scope_hint_message = secret_scope.empty() ? "." : " for '" + secret_scope + "'.";
-		throw InvalidConfigurationException(base_message + ": no secret was found%s", secret_key, setting_name,
-		                                    secret_scope_hint_message);
-	}
-
-	throw InvalidConfigurationException(base_message +
-	                                        ": secret '%s' did not contain the key, also the setting was not found.",
-	                                    secret_key, setting_name, secret->GetName());
-}
-
-bool CreateSecretFunctionSet::ProviderExists(const string &provider_name) {
-	return functions.find(provider_name) != functions.end();
-}
-
-void CreateSecretFunctionSet::AddFunction(CreateSecretFunction &function, OnCreateConflict on_conflict) {
-	if (ProviderExists(function.provider)) {
-		if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			throw InternalException(
-			    "Attempted to override a Create Secret Function with OnCreateConflict::ERROR_ON_CONFLICT for: '%s'",
-			    function.provider);
-		} else if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-			functions[function.provider] = function;
-		} else if (on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
-			throw NotImplementedException("ALTER_ON_CONFLICT not implemented for CreateSecretFunctionSet");
-		}
-	} else {
-		functions[function.provider] = function;
-	}
-}
-
-CreateSecretFunction &CreateSecretFunctionSet::GetFunction(const string &provider) {
-	const auto &lookup = functions.find(provider);
-
-	if (lookup == functions.end()) {
-		throw InternalException("Could not find Create Secret Function with provider %s");
-	}
-
-	return lookup->second;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/secret/secret_manager.cpp b/src/duckdb/src/main/secret/secret_manager.cpp
deleted file mode 100644
index 191cf1f56..000000000
--- a/src/duckdb/src/main/secret/secret_manager.cpp
+++ /dev/null
@@ -1,730 +0,0 @@
-#include "duckdb/main/secret/secret_manager.hpp"
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/secret/secret_storage.hpp"
-#include "duckdb/main/secret/default_secrets.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/planner/operator/logical_create_secret.hpp"
-
-namespace duckdb {
-
-SecretCatalogEntry::SecretCatalogEntry(unique_ptr<SecretEntry> secret_p, Catalog &catalog)
-    : InCatalogEntry(CatalogType::SECRET_ENTRY, catalog, secret_p->secret->GetName()), secret(std::move(secret_p)) {
-	internal = true;
-}
-
-SecretCatalogEntry::SecretCatalogEntry(unique_ptr<const BaseSecret> secret_p, Catalog &catalog)
-    : InCatalogEntry(CatalogType::SECRET_ENTRY, catalog, secret_p->GetName()) {
-	internal = true;
-	secret = make_uniq<SecretEntry>(std::move(secret_p));
-}
-
-const BaseSecret &SecretMatch::GetSecret() const {
-	return *secret_entry->secret;
-}
-
-constexpr const char *SecretManager::TEMPORARY_STORAGE_NAME;
-constexpr const char *SecretManager::LOCAL_FILE_STORAGE_NAME;
-
-void SecretManager::Initialize(DatabaseInstance &db) {
-	lock_guard<mutex> lck(manager_lock);
-
-	// Construct default path
-	LocalFileSystem fs;
-	config.default_secret_path = fs.GetHomeDirectory();
-	vector<string> path_components = {".duckdb", "stored_secrets"};
-	for (auto &path_ele : path_components) {
-		config.default_secret_path = fs.JoinPath(config.default_secret_path, path_ele);
-	}
-	config.secret_path = config.default_secret_path;
-
-	// Set the defaults for persistent storage
-	config.default_persistent_storage = LOCAL_FILE_STORAGE_NAME;
-
-	// Store the current db for enabling autoloading
-	this->db = &db;
-
-	// Register default types
-	for (auto &type : CreateHTTPSecretFunctions::GetDefaultSecretTypes()) {
-		RegisterSecretTypeInternal(type);
-	}
-
-	// Register default functions
-	for (auto &function : CreateHTTPSecretFunctions::GetDefaultSecretFunctions()) {
-		RegisterSecretFunctionInternal(function, OnCreateConflict::ERROR_ON_CONFLICT);
-	}
-}
-
-void SecretManager::LoadSecretStorage(unique_ptr<SecretStorage> storage) {
-	lock_guard<mutex> lck(manager_lock);
-	return LoadSecretStorageInternal(std::move(storage));
-}
-
-void SecretManager::LoadSecretStorageInternal(unique_ptr<SecretStorage> storage) {
-	if (secret_storages.find(storage->GetName()) != secret_storages.end()) {
-		throw InternalException("Secret Storage with name '%s' already registered!", storage->GetName());
-	}
-
-	// Check for tie-break offset collisions to ensure we can always tie-break cleanly
-	for (const auto &storage_ptr : secret_storages) {
-		if (storage_ptr.second->tie_break_offset == storage->tie_break_offset) {
-			throw InternalException("Failed to load secret storage '%s', tie break score collides with '%s'",
-			                        storage->GetName(), storage_ptr.second->GetName());
-		}
-	}
-
-	secret_storages[storage->GetName()] = std::move(storage);
-}
-
-// FIXME: use serialization scripts?
-unique_ptr<BaseSecret> SecretManager::DeserializeSecret(Deserializer &deserializer, const string &secret_path) {
-	auto type = deserializer.ReadProperty<string>(100, "type");
-	auto provider = deserializer.ReadProperty<string>(101, "provider");
-	auto name = deserializer.ReadProperty<string>(102, "name");
-	vector<string> scope;
-	deserializer.ReadList(103, "scope",
-	                      [&](Deserializer::List &list, idx_t i) { scope.push_back(list.ReadElement<string>()); });
-	auto serialization_type =
-	    deserializer.ReadPropertyWithExplicitDefault(104, "serialization_type", SecretSerializationType::CUSTOM);
-
-	switch (serialization_type) {
-	// This allows us to skip looking up the secret type for deserialization altogether
-	case SecretSerializationType::KEY_VALUE_SECRET:
-		return KeyValueSecret::Deserialize<KeyValueSecret>(deserializer, {scope, type, provider, name});
-	// Continues below: we need to do a type lookup to find the secret deserialize method
-	case SecretSerializationType::CUSTOM:
-		break;
-	default:
-		throw IOException("Unrecognized secret serialization type found in secret '%s': %s", secret_path,
-		                  EnumUtil::ToString(serialization_type));
-	}
-
-	SecretType deserialized_type;
-	if (!TryLookupTypeInternal(type, deserialized_type)) {
-		ThrowTypeNotFoundError(type, secret_path);
-	}
-
-	if (!deserialized_type.deserializer) {
-		throw InternalException(
-		    "Attempted to deserialize secret type '%s' which does not have a deserialization method", type);
-	}
-
-	return deserialized_type.deserializer(deserializer, {scope, type, provider, name});
-}
-
-void SecretManager::RegisterSecretType(SecretType &type) {
-	lock_guard<mutex> lck(manager_lock);
-	RegisterSecretTypeInternal(type);
-}
-
-void SecretManager::RegisterSecretFunction(CreateSecretFunction function, OnCreateConflict on_conflict) {
-	unique_lock<mutex> lck(manager_lock);
-	RegisterSecretFunctionInternal(std::move(function), on_conflict);
-}
-
-unique_ptr<SecretEntry> SecretManager::RegisterSecret(CatalogTransaction transaction,
-                                                      unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
-                                                      SecretPersistType persist_type, const string &storage) {
-	InitializeSecrets(transaction);
-	return RegisterSecretInternal(transaction, std::move(secret), on_conflict, persist_type, storage);
-}
-
-unique_ptr<SecretEntry> SecretManager::RegisterSecretInternal(CatalogTransaction transaction,
-                                                              unique_ptr<const BaseSecret> secret,
-                                                              OnCreateConflict on_conflict,
-                                                              SecretPersistType persist_type, const string &storage) {
-	//! Ensure we only create secrets for known types;
-	LookupTypeInternal(secret->GetType());
-
-	//! Handle default for persist type
-	if (persist_type == SecretPersistType::DEFAULT) {
-		if (storage.empty()) {
-			persist_type = config.default_persist_type;
-		} else if (storage == TEMPORARY_STORAGE_NAME) {
-			persist_type = SecretPersistType::TEMPORARY;
-		} else {
-			persist_type = SecretPersistType::PERSISTENT;
-		}
-	}
-
-	//! Resolve storage
-	string resolved_storage;
-	if (storage.empty()) {
-		resolved_storage =
-		    persist_type == SecretPersistType::PERSISTENT ? config.default_persistent_storage : TEMPORARY_STORAGE_NAME;
-	} else {
-		resolved_storage = storage;
-	}
-
-	//! Lookup which backend to store the secret in
-	auto backend = GetSecretStorage(resolved_storage);
-	if (!backend) {
-		if (!config.allow_persistent_secrets &&
-		    (persist_type == SecretPersistType::PERSISTENT || storage == LOCAL_FILE_STORAGE_NAME)) {
-			throw InvalidInputException("Persistent secrets are disabled. Restart DuckDB and enable persistent secrets "
-			                            "through 'SET allow_persistent_secrets=true'");
-		}
-		throw InvalidInputException("Secret storage '%s' not found!", resolved_storage);
-	}
-
-	// Validation on both allow_persistent_secrets and storage backend's own persist type
-	if (persist_type == SecretPersistType::PERSISTENT) {
-		if (backend->persistent) {
-			if (!config.allow_persistent_secrets) {
-				throw InvalidInputException(
-				    "Persistent secrets are currently disabled. To enable them, restart duckdb and "
-				    "run 'SET allow_persistent_secrets=true'");
-			}
-		} else { // backend is temp
-			throw InvalidInputException("Cannot create persistent secrets in a temporary secret storage!");
-		}
-	} else { // SecretPersistType::TEMPORARY
-		if (backend->persistent) {
-			throw InvalidInputException("Cannot create temporary secrets in a persistent secret storage!");
-		}
-	}
-	return backend->StoreSecret(std::move(secret), on_conflict, &transaction);
-}
-
-optional_ptr<CreateSecretFunction> SecretManager::LookupFunctionInternal(const string &type, const string &provider) {
-	unique_lock<mutex> lck(manager_lock);
-	auto lookup = secret_functions.find(type);
-
-	if (lookup != secret_functions.end()) {
-		if (lookup->second.ProviderExists(provider)) {
-			return &lookup->second.GetFunction(provider);
-		}
-	}
-
-	// Try autoloading
-	lck.unlock();
-	AutoloadExtensionForFunction(type, provider);
-	lck.lock();
-
-	lookup = secret_functions.find(type);
-
-	if (lookup != secret_functions.end()) {
-		if (lookup->second.ProviderExists(provider)) {
-			return &lookup->second.GetFunction(provider);
-		}
-	}
-
-	return nullptr;
-}
-
-unique_ptr<SecretEntry> SecretManager::CreateSecret(ClientContext &context, const CreateSecretInfo &info) {
-	// Note that a context is required for CreateSecret, as the CreateSecretFunction expects one
-	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
-	InitializeSecrets(transaction);
-
-	// Make a copy to set the provider to default if necessary
-	CreateSecretInput function_input {info.type, info.provider, info.storage_type, info.name, info.scope, info.options};
-	if (function_input.provider.empty()) {
-		auto secret_type = LookupTypeInternal(function_input.type);
-		function_input.provider = secret_type.default_provider;
-	}
-
-	// Lookup function
-	auto function_lookup = LookupFunctionInternal(function_input.type, function_input.provider);
-	if (!function_lookup) {
-		ThrowProviderNotFoundError(info.type, info.provider);
-	}
-
-	// Call the function
-	auto secret = function_lookup->function(context, function_input);
-
-	if (!secret) {
-		throw InternalException("CreateSecretFunction for type: '%s' and provider: '%s' did not return a secret!",
-		                        info.type, info.provider);
-	}
-
-	// Register the secret at the secret_manager
-	return RegisterSecretInternal(transaction, std::move(secret), info.on_conflict, info.persist_type,
-	                              info.storage_type);
-}
-
-BoundStatement SecretManager::BindCreateSecret(CatalogTransaction transaction, CreateSecretInfo &info) {
-	InitializeSecrets(transaction);
-
-	auto type = info.type;
-	auto provider = info.provider;
-	bool default_provider = false;
-
-	if (provider.empty()) {
-		default_provider = true;
-		auto secret_type = LookupTypeInternal(type);
-		provider = secret_type.default_provider;
-	}
-
-	string default_string = default_provider ? "default " : "";
-
-	auto function = LookupFunctionInternal(type, provider);
-
-	if (!function) {
-		ThrowProviderNotFoundError(info.type, info.provider, default_provider);
-	}
-
-	auto bound_info = info;
-	bound_info.options.clear();
-
-	// We cast the passed parameters
-	for (const auto &param : info.options) {
-		auto matched_param = function->named_parameters.find(param.first);
-		if (matched_param == function->named_parameters.end()) {
-			throw BinderException("Unknown parameter '%s' for secret type '%s' with %sprovider '%s'", param.first, type,
-			                      default_string, provider);
-		}
-
-		// Cast the provided value to the expected type
-		string error_msg;
-		Value cast_value;
-		if (!param.second.DefaultTryCastAs(matched_param->second, cast_value, &error_msg)) {
-			throw BinderException("Failed to cast option '%s' to type '%s': '%s'", matched_param->first,
-			                      matched_param->second.ToString(), error_msg);
-		}
-
-		bound_info.options[matched_param->first] = {cast_value};
-	}
-
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_uniq<LogicalCreateSecret>(std::move(bound_info));
-	return result;
-}
-
-SecretMatch SecretManager::LookupSecret(CatalogTransaction transaction, const string &path, const string &type) {
-	InitializeSecrets(transaction);
-
-	int64_t best_match_score = NumericLimits<int64_t>::Minimum();
-	unique_ptr<SecretEntry> best_match = nullptr;
-
-	for (const auto &storage_ref : GetSecretStorages()) {
-		if (!storage_ref.get().IncludeInLookups()) {
-			continue;
-		}
-		auto match = storage_ref.get().LookupSecret(path, StringUtil::Lower(type), &transaction);
-		if (match.HasMatch() && match.score > best_match_score) {
-			best_match = std::move(match.secret_entry);
-			best_match_score = match.score;
-		}
-	}
-
-	if (best_match) {
-		return SecretMatch(*best_match, best_match_score);
-	}
-
-	return SecretMatch();
-}
-
-unique_ptr<SecretEntry> SecretManager::GetSecretByName(CatalogTransaction transaction, const string &name,
-                                                       const string &storage) {
-	InitializeSecrets(transaction);
-
-	unique_ptr<SecretEntry> result = nullptr;
-	bool found = false;
-
-	if (!storage.empty()) {
-		auto storage_lookup = GetSecretStorage(storage);
-
-		if (!storage_lookup) {
-			throw InvalidInputException("Unknown secret storage found: '%s'", storage);
-		}
-
-		return storage_lookup->GetSecretByName(name, &transaction);
-	}
-
-	for (const auto &storage_ref : GetSecretStorages()) {
-		auto lookup = storage_ref.get().GetSecretByName(name, &transaction);
-		if (lookup) {
-			if (found) {
-				throw InternalException(
-				    "Ambiguity detected for secret name '%s', secret occurs in multiple storage backends.", name);
-			}
-
-			result = std::move(lookup);
-			found = true;
-		}
-	}
-
-	return result;
-}
-
-void SecretManager::DropSecretByName(CatalogTransaction transaction, const string &name,
-                                     OnEntryNotFound on_entry_not_found, SecretPersistType persist_type,
-                                     const string &storage) {
-	InitializeSecrets(transaction);
-
-	vector<reference<SecretStorage>> matches;
-
-	// storage to drop from was specified directly
-	if (!storage.empty()) {
-		auto storage_lookup = GetSecretStorage(storage);
-		if (!storage_lookup) {
-			throw InvalidInputException("Unknown storage type found for drop secret: '%s'", storage);
-		}
-		matches.push_back(*storage_lookup.get());
-	} else {
-		for (const auto &storage_ref : GetSecretStorages()) {
-			if (persist_type == SecretPersistType::PERSISTENT && !storage_ref.get().Persistent()) {
-				continue;
-			}
-			if (persist_type == SecretPersistType::TEMPORARY && storage_ref.get().Persistent()) {
-				continue;
-			}
-
-			auto lookup = storage_ref.get().GetSecretByName(name, &transaction);
-			if (lookup) {
-				matches.push_back(storage_ref.get());
-			}
-		}
-	}
-
-	if (matches.size() > 1) {
-		string list_of_matches;
-		for (const auto &match : matches) {
-			list_of_matches += match.get().GetName() + ",";
-		}
-		list_of_matches.pop_back(); // trailing comma
-
-		throw InvalidInputException(
-		    "Ambiguity found for secret name '%s', secret occurs in multiple storages: [%s] Please specify which "
-		    "secret to drop using: 'DROP <PERSISTENT|TEMPORARY> SECRET [FROM <storage>]'.",
-		    name, list_of_matches);
-	}
-
-	if (matches.empty()) {
-		if (on_entry_not_found == OnEntryNotFound::THROW_EXCEPTION) {
-			string storage_str;
-			if (!storage.empty()) {
-				storage_str = " for storage '" + storage + "'";
-			}
-			throw InvalidInputException("Failed to remove non-existent secret with name '%s'%s", name, storage_str);
-		}
-		// Do nothing on OnEntryNotFound::RETURN_NULL...
-	} else {
-		matches[0].get().DropSecretByName(name, on_entry_not_found, &transaction);
-	}
-}
-
-SecretType SecretManager::LookupType(const string &type) {
-	return LookupTypeInternal(type);
-}
-
-void SecretManager::RegisterSecretTypeInternal(SecretType &type) {
-	auto lookup = secret_types.find(type.name);
-	if (lookup != secret_types.end()) {
-		throw InternalException("Attempted to register an already registered secret type: '%s'", type.name);
-	}
-	secret_types[type.name] = type;
-}
-
-bool SecretManager::TryLookupTypeInternal(const string &type, SecretType &type_out) {
-	unique_lock<mutex> lck(manager_lock);
-	auto lookup = secret_types.find(type);
-	if (lookup != secret_types.end()) {
-		type_out = lookup->second;
-		return true;
-	}
-
-	// Try autoloading
-	lck.unlock();
-	AutoloadExtensionForType(type);
-	lck.lock();
-
-	lookup = secret_types.find(type);
-	if (lookup != secret_types.end()) {
-		type_out = lookup->second;
-		return true;
-	}
-
-	return false;
-}
-
-SecretType SecretManager::LookupTypeInternal(const string &type) {
-	SecretType return_value;
-	if (!TryLookupTypeInternal(type, return_value)) {
-		ThrowTypeNotFoundError(type);
-	}
-	return return_value;
-}
-
-void SecretManager::RegisterSecretFunctionInternal(CreateSecretFunction function, OnCreateConflict on_conflict) {
-	auto lookup = secret_functions.find(function.secret_type);
-	if (lookup != secret_functions.end()) {
-		lookup->second.AddFunction(function, on_conflict);
-		return;
-	}
-	CreateSecretFunctionSet new_set(function.secret_type);
-	new_set.AddFunction(function, OnCreateConflict::ERROR_ON_CONFLICT);
-	secret_functions.insert({function.secret_type, new_set});
-}
-
-vector<SecretEntry> SecretManager::AllSecrets(CatalogTransaction transaction) {
-	InitializeSecrets(transaction);
-
-	vector<SecretEntry> result;
-
-	// Add results from all backends to the result set
-	for (const auto &backend : secret_storages) {
-		auto backend_result = backend.second->AllSecrets(&transaction);
-		for (const auto &it : backend_result) {
-			result.push_back(it);
-		}
-	}
-
-	return result;
-}
-
-void SecretManager::ThrowOnSettingChangeIfInitialized() {
-	if (initialized) {
-		throw InvalidInputException(
-		    "Changing Secret Manager settings after the secret manager is used is not allowed!");
-	}
-}
-
-void SecretManager::SetEnablePersistentSecrets(bool enabled) {
-	ThrowOnSettingChangeIfInitialized();
-	config.allow_persistent_secrets = enabled;
-}
-
-void SecretManager::ResetEnablePersistentSecrets() {
-	ThrowOnSettingChangeIfInitialized();
-	config.allow_persistent_secrets = SecretManagerConfig::DEFAULT_ALLOW_PERSISTENT_SECRETS;
-}
-
-bool SecretManager::PersistentSecretsEnabled() {
-	return config.allow_persistent_secrets;
-}
-
-void SecretManager::SetDefaultStorage(const string &storage) {
-	config.default_persistent_storage = storage;
-}
-
-void SecretManager::ResetDefaultStorage() {
-	config.default_persistent_storage = SecretManager::LOCAL_FILE_STORAGE_NAME;
-}
-
-string SecretManager::DefaultStorage() {
-	return config.default_persistent_storage;
-}
-
-void SecretManager::SetPersistentSecretPath(const string &path) {
-	ThrowOnSettingChangeIfInitialized();
-	config.secret_path = path;
-}
-
-void SecretManager::ResetPersistentSecretPath() {
-	ThrowOnSettingChangeIfInitialized();
-	config.secret_path = config.default_secret_path;
-}
-
-string SecretManager::PersistentSecretPath() {
-	return config.secret_path;
-}
-
-void SecretManager::InitializeSecrets(CatalogTransaction transaction) {
-	if (!initialized) {
-		lock_guard<mutex> lck(manager_lock);
-		if (initialized) {
-			// some sneaky other thread beat us to it
-			return;
-		}
-
-		// load the tmp storage
-		LoadSecretStorageInternal(make_uniq<TemporarySecretStorage>(TEMPORARY_STORAGE_NAME, *transaction.db));
-
-		if (config.allow_persistent_secrets) {
-			// load the persistent storage if enabled
-			LoadSecretStorageInternal(
-			    make_uniq<LocalFileSecretStorage>(*this, *transaction.db, LOCAL_FILE_STORAGE_NAME, config.secret_path));
-		}
-
-		initialized = true;
-	}
-}
-
-void SecretManager::AutoloadExtensionForType(const string &type) {
-	ExtensionHelper::TryAutoloadFromEntry(*db, StringUtil::Lower(type), EXTENSION_SECRET_TYPES);
-}
-
-void SecretManager::ThrowTypeNotFoundError(const string &type, const string &secret_path) {
-	auto entry = ExtensionHelper::FindExtensionInEntries(StringUtil::Lower(type), EXTENSION_SECRET_TYPES);
-	string error_message;
-
-	if (!entry.empty() && db) {
-		error_message = "Secret type '" + type + "' does not exist, but it exists in the " + entry + " extension.";
-		error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(*db, error_message, entry);
-
-		if (!secret_path.empty()) {
-			error_message += "\n\nAlternatively, ";
-		}
-	} else {
-		error_message = StringUtil::Format("Secret type '%s' not found", type);
-
-		if (!secret_path.empty()) {
-			error_message += ", ";
-		}
-	}
-
-	if (!secret_path.empty()) {
-		error_message += StringUtil::Format("try removing the secret at path '%s'.", secret_path);
-	}
-
-	throw InvalidInputException(error_message);
-}
-
-void SecretManager::AutoloadExtensionForFunction(const string &type, const string &provider) {
-	ExtensionHelper::TryAutoloadFromEntry(*db, StringUtil::Lower(type) + "/" + StringUtil::Lower(provider),
-	                                      EXTENSION_SECRET_PROVIDERS);
-}
-
-void SecretManager::ThrowProviderNotFoundError(const string &type, const string &provider, bool was_default) {
-	auto entry = ExtensionHelper::FindExtensionInEntries(StringUtil::Lower(type) + "/" + StringUtil::Lower(provider),
-	                                                     EXTENSION_SECRET_PROVIDERS);
-	if (!entry.empty() && db) {
-		string error_message = was_default ? "Default secret provider" : "Secret provider";
-		error_message +=
-		    " '" + provider + "' for type '" + type + "' does not exist, but it exists in the " + entry + " extension.";
-		error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(*db, error_message, entry);
-
-		throw InvalidInputException(error_message);
-	}
-	throw InvalidInputException("Secret provider '%s' not found for type '%s'", provider, type);
-}
-
-optional_ptr<SecretStorage> SecretManager::GetSecretStorage(const string &name) {
-	lock_guard<mutex> lock(manager_lock);
-
-	auto lookup = secret_storages.find(name);
-	if (lookup != secret_storages.end()) {
-		return lookup->second.get();
-	}
-
-	return nullptr;
-}
-
-vector<reference<SecretStorage>> SecretManager::GetSecretStorages() {
-	lock_guard<mutex> lock(manager_lock);
-
-	vector<reference<SecretStorage>> result;
-
-	for (const auto &storage : secret_storages) {
-		result.push_back(*storage.second);
-	}
-
-	return result;
-}
-
-DefaultSecretGenerator::DefaultSecretGenerator(Catalog &catalog, SecretManager &secret_manager,
-                                               case_insensitive_set_t &persistent_secrets)
-    : DefaultGenerator(catalog), secret_manager(secret_manager), persistent_secrets(persistent_secrets) {
-}
-
-unique_ptr<CatalogEntry> DefaultSecretGenerator::CreateDefaultEntryInternal(const string &entry_name) {
-	auto secret_lu = persistent_secrets.find(entry_name);
-	if (secret_lu == persistent_secrets.end()) {
-		return nullptr;
-	}
-
-	LocalFileSystem fs;
-
-	string base_secret_path = secret_manager.PersistentSecretPath();
-	string secret_path = fs.JoinPath(base_secret_path, entry_name + ".duckdb_secret");
-
-	// Note each file should contain 1 secret
-	try {
-		auto file_reader = BufferedFileReader(fs, secret_path.c_str());
-
-		if (!LocalFileSystem::IsPrivateFile(secret_path, nullptr)) {
-			throw IOException(
-			    "The secret file '%s' has incorrect permissions! Please set correct permissions or remove file",
-			    secret_path);
-		}
-
-		if (!file_reader.Finished()) {
-			BinaryDeserializer deserializer(file_reader);
-
-			deserializer.Begin();
-			auto deserialized_secret = secret_manager.DeserializeSecret(deserializer, secret_path);
-			deserializer.End();
-
-			auto entry = make_uniq<SecretCatalogEntry>(std::move(deserialized_secret), catalog);
-			entry->secret->storage_mode = SecretManager::LOCAL_FILE_STORAGE_NAME;
-			entry->secret->persist_type = SecretPersistType::PERSISTENT;
-
-			// Finally: we remove the default entry from the persistent_secrets, otherwise we aren't able to drop it
-			// later
-			persistent_secrets.erase(secret_lu);
-
-			return std::move(entry);
-		}
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		switch (error.Type()) {
-		case ExceptionType::SERIALIZATION:
-			throw SerializationException(
-			    "Failed to deserialize the persistent secret file: '%s'. The file maybe be "
-			    "corrupt, please remove the file, restart and try again. (error message: '%s')",
-			    secret_path, error.RawMessage());
-		case ExceptionType::IO:
-			throw IOException(
-			    "Failed to open the persistent secret file: '%s'. Some other process may have removed it, "
-			    "please restart and try again. (error message: '%s')",
-			    secret_path, error.RawMessage());
-		default:
-			throw;
-		}
-	}
-
-	throw SerializationException("Failed to deserialize secret '%s' from '%s': file appears empty! Please remove the "
-	                             "file, restart and try again",
-	                             entry_name, secret_path);
-}
-
-unique_ptr<CatalogEntry> DefaultSecretGenerator::CreateDefaultEntry(CatalogTransaction transaction,
-                                                                    const string &entry_name) {
-	return CreateDefaultEntryInternal(entry_name);
-}
-
-unique_ptr<CatalogEntry> DefaultSecretGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	return CreateDefaultEntryInternal(entry_name);
-}
-
-vector<string> DefaultSecretGenerator::GetDefaultEntries() {
-	vector<string> ret;
-
-	for (const auto &res : persistent_secrets) {
-		ret.push_back(res);
-	}
-
-	return ret;
-}
-
-SecretManager &SecretManager::Get(ClientContext &context) {
-	return *DBConfig::GetConfig(context).secret_manager;
-}
-SecretManager &SecretManager::Get(DatabaseInstance &db) {
-	return *DBConfig::GetConfig(db).secret_manager;
-}
-
-void SecretManager::DropSecretByName(ClientContext &context, const string &name, OnEntryNotFound on_entry_not_found,
-                                     SecretPersistType persist_type, const string &storage) {
-	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
-	return DropSecretByName(transaction, name, on_entry_not_found, persist_type, storage);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/secret/secret_storage.cpp b/src/duckdb/src/main/secret/secret_storage.cpp
deleted file mode 100644
index 0b543f8b3..000000000
--- a/src/duckdb/src/main/secret/secret_storage.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/common/types/uuid.hpp"
-#include "duckdb/function/function_set.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/secret/secret_storage.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-
-namespace duckdb {
-
-SecretMatch SecretStorage::SelectBestMatch(SecretEntry &secret_entry, const string &path, int64_t offset,
-                                           SecretMatch &current_best) {
-	// Get secret match score
-	auto match_score = secret_entry.secret->MatchScore(path);
-
-	// On no match
-	if (match_score == NumericLimits<int64_t>::Minimum()) {
-		return current_best;
-	}
-
-	// The number of characters that match, where 0 means matching the catchall of "*"
-	D_ASSERT(match_score >= 0);
-
-	// Apply storage tie-break offset
-	match_score = 100 * match_score - offset;
-
-	// Choose the best matching score, tie-breaking on secret name when necessary
-	if (match_score > current_best.score) {
-		return SecretMatch(secret_entry, match_score);
-	} else if (match_score == current_best.score &&
-	           secret_entry.secret->GetName() < current_best.GetSecret().GetName()) {
-		return SecretMatch(secret_entry, match_score);
-	} else {
-		return current_best;
-	}
-}
-
-unique_ptr<SecretEntry> CatalogSetSecretStorage::StoreSecret(unique_ptr<const BaseSecret> secret,
-                                                             OnCreateConflict on_conflict,
-                                                             optional_ptr<CatalogTransaction> transaction) {
-	if (secrets->GetEntry(GetTransactionOrDefault(transaction), secret->GetName())) {
-		if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			string persist_string = persistent ? "Persistent" : "Temporary";
-			string storage_string = persistent ? " in secret storage '" + storage_name + "'" : "";
-			throw InvalidInputException("%s secret with name '%s' already exists%s!", persist_string, secret->GetName(),
-			                            storage_string);
-		} else if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-			return nullptr;
-		} else if (on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
-			throw InternalException("unknown OnCreateConflict found while registering secret");
-		} else if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-			secrets->DropEntry(GetTransactionOrDefault(transaction), secret->GetName(), true, true);
-		}
-	}
-
-	// Call write function
-	WriteSecret(*secret, on_conflict);
-
-	auto secret_name = secret->GetName();
-	auto secret_entry = make_uniq<SecretCatalogEntry>(std::move(secret), Catalog::GetSystemCatalog(db));
-	secret_entry->temporary = !persistent;
-	secret_entry->secret->storage_mode = storage_name;
-	secret_entry->secret->persist_type = persistent ? SecretPersistType::PERSISTENT : SecretPersistType::TEMPORARY;
-	LogicalDependencyList l;
-	secrets->CreateEntry(GetTransactionOrDefault(transaction), secret_name, std::move(secret_entry), l);
-
-	auto secret_catalog_entry =
-	    &secrets->GetEntry(GetTransactionOrDefault(transaction), secret_name)->Cast<SecretCatalogEntry>();
-	return make_uniq<SecretEntry>(*secret_catalog_entry->secret);
-}
-
-vector<SecretEntry> CatalogSetSecretStorage::AllSecrets(optional_ptr<CatalogTransaction> transaction) {
-	vector<SecretEntry> ret_value;
-	const std::function<void(CatalogEntry &)> callback = [&](CatalogEntry &entry) {
-		auto &cast_entry = entry.Cast<SecretCatalogEntry>();
-		ret_value.push_back(*cast_entry.secret);
-	};
-	secrets->Scan(GetTransactionOrDefault(transaction), callback);
-	return ret_value;
-}
-
-void CatalogSetSecretStorage::DropSecretByName(const string &name, OnEntryNotFound on_entry_not_found,
-                                               optional_ptr<CatalogTransaction> transaction) {
-	auto entry = secrets->GetEntry(GetTransactionOrDefault(transaction), name);
-	if (!entry && on_entry_not_found == OnEntryNotFound::THROW_EXCEPTION) {
-		string persist_string = persistent ? "persistent" : "temporary";
-		string storage_string = persistent ? " in secret storage '" + storage_name + "'" : "";
-		throw InvalidInputException("Failed to remove non-existent %s secret '%s'%s", persist_string, name,
-		                            storage_string);
-	}
-
-	secrets->DropEntry(GetTransactionOrDefault(transaction), name, true, true);
-	RemoveSecret(name, on_entry_not_found);
-}
-
-SecretMatch CatalogSetSecretStorage::LookupSecret(const string &path, const string &type,
-                                                  optional_ptr<CatalogTransaction> transaction) {
-	auto best_match = SecretMatch();
-
-	const std::function<void(CatalogEntry &)> callback = [&](CatalogEntry &entry) {
-		auto &cast_entry = entry.Cast<SecretCatalogEntry>();
-		if (StringUtil::CIEquals(cast_entry.secret->secret->GetType(), type)) {
-			best_match = SelectBestMatch(*cast_entry.secret, path, tie_break_offset, best_match);
-		}
-	};
-	secrets->Scan(GetTransactionOrDefault(transaction), callback);
-
-	if (best_match.HasMatch()) {
-		return best_match;
-	}
-
-	return SecretMatch();
-}
-
-unique_ptr<SecretEntry> CatalogSetSecretStorage::GetSecretByName(const string &name,
-                                                                 optional_ptr<CatalogTransaction> transaction) {
-	auto res = secrets->GetEntry(GetTransactionOrDefault(transaction), name);
-
-	if (res) {
-		auto &cast_entry = res->Cast<SecretCatalogEntry>();
-		return make_uniq<SecretEntry>(*cast_entry.secret);
-	}
-
-	return nullptr;
-}
-
-LocalFileSecretStorage::LocalFileSecretStorage(SecretManager &manager, DatabaseInstance &db_p, const string &name_p,
-                                               const string &secret_path_p)
-    : CatalogSetSecretStorage(db_p, name_p, LOCAL_FILE_STORAGE_OFFSET),
-      secret_path(FileSystem::ExpandPath(secret_path_p, nullptr)) {
-	persistent = true;
-
-	// Check existence of persistent secret dir
-	LocalFileSystem fs;
-	if (fs.DirectoryExists(secret_path)) {
-		fs.ListFiles(secret_path, [&](const string &fname, bool is_dir) {
-			string full_path = fs.JoinPath(secret_path, fname);
-
-			if (StringUtil::EndsWith(full_path, ".duckdb_secret")) {
-				string secret_name = fname.substr(0, fname.size() - 14); // size of file ext
-				persistent_secrets.insert(secret_name);
-			}
-		});
-	}
-
-	auto &catalog = Catalog::GetSystemCatalog(db);
-	secrets = make_uniq<CatalogSet>(Catalog::GetSystemCatalog(db),
-	                                make_uniq<DefaultSecretGenerator>(catalog, manager, persistent_secrets));
-}
-
-void CatalogSetSecretStorage::WriteSecret(const BaseSecret &secret, OnCreateConflict on_conflict) {
-	// By default, this writes nothing
-}
-void CatalogSetSecretStorage::RemoveSecret(const string &name, OnEntryNotFound on_entry_not_found) {
-	// By default, this writes nothing
-}
-
-CatalogTransaction CatalogSetSecretStorage::GetTransactionOrDefault(optional_ptr<CatalogTransaction> transaction) {
-	if (transaction) {
-		return *transaction;
-	}
-	return CatalogTransaction::GetSystemTransaction(db);
-}
-
-static void WriteSecretFileToDisk(FileSystem &fs, const string &path, const BaseSecret &secret) {
-	auto open_flags = FileFlags::FILE_FLAGS_WRITE;
-	// Ensure we are writing to a private file with 600 permission
-	open_flags |= FileFlags::FILE_FLAGS_PRIVATE;
-	// Ensure we overwrite anything that may have been placed there since our delete above
-	open_flags |= FileFlags::FILE_FLAGS_FILE_CREATE_NEW;
-
-	auto file_writer = BufferedFileWriter(fs, path, open_flags);
-
-	auto serializer = BinarySerializer(file_writer);
-	serializer.Begin();
-	secret.Serialize(serializer);
-	serializer.End();
-
-	file_writer.Flush();
-}
-
-void LocalFileSecretStorage::WriteSecret(const BaseSecret &secret, OnCreateConflict on_conflict) {
-	LocalFileSystem fs;
-
-	// We may need to create the secret dir here if the directory was not present during LocalFileSecretStorage
-	// construction
-	if (!fs.DirectoryExists(secret_path)) {
-		// TODO: recursive directory creation should probably live in filesystem
-		auto sep = fs.PathSeparator(secret_path);
-		auto splits = StringUtil::Split(secret_path, sep);
-		D_ASSERT(!splits.empty());
-		string extension_directory_prefix;
-		if (StringUtil::StartsWith(secret_path, sep)) {
-			extension_directory_prefix = sep; // this is swallowed by Split otherwise
-		}
-		try {
-			for (auto &split : splits) {
-				extension_directory_prefix = extension_directory_prefix + split + sep;
-				if (!fs.DirectoryExists(extension_directory_prefix)) {
-					fs.CreateDirectory(extension_directory_prefix);
-				}
-			}
-		} catch (std::exception &ex) {
-			ErrorData error(ex);
-			if (error.Type() == ExceptionType::IO) {
-				throw IOException("Failed to initialize persistent storage directory. (original error: '%s')",
-				                  error.RawMessage());
-			}
-			throw;
-		}
-	}
-
-	string file_path = fs.JoinPath(secret_path, secret.GetName() + ".duckdb_secret");
-	string temp_path = file_path + ".tmp-" + UUID::ToString(UUID::GenerateRandomUUID());
-
-	// If persistent file already exists remove
-	if (fs.FileExists(file_path)) {
-		fs.RemoveFile(file_path);
-	}
-	// If temporary file already exists remove
-	if (fs.FileExists(temp_path)) {
-		fs.RemoveFile(temp_path);
-	}
-
-	WriteSecretFileToDisk(fs, temp_path, secret);
-
-	fs.MoveFile(temp_path, file_path);
-}
-
-void LocalFileSecretStorage::RemoveSecret(const string &secret, OnEntryNotFound on_entry_not_found) {
-	LocalFileSystem fs;
-	string file = fs.JoinPath(secret_path, secret + ".duckdb_secret");
-	persistent_secrets.erase(secret);
-	try {
-		fs.RemoveFile(file);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		if (error.Type() == ExceptionType::IO) {
-			throw IOException("Failed to remove secret file '%s', the file may have been removed by another duckdb "
-			                  "instance. (original error: '%s')",
-			                  file, error.RawMessage());
-		}
-		throw;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/settings/autogenerated_settings.cpp b/src/duckdb/src/main/settings/autogenerated_settings.cpp
deleted file mode 100644
index 6a7106963..000000000
--- a/src/duckdb/src/main/settings/autogenerated_settings.cpp
+++ /dev/null
@@ -1,1085 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-// This code is autogenerated from 'scripts/settings_scripts/update_settings_src_code.py'.
-// Please do not make any changes directly here, as they will be overwritten.
-// If you need to implement a custom function for a new setting, enable the
-// 'custom_implementation' in 'src/common/settings.json' for this setting.
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/main/settings.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-//===----------------------------------------------------------------------===//
-// Access Mode
-//===----------------------------------------------------------------------===//
-void AccessModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	auto str_input = StringUtil::Upper(input.GetValue<string>());
-	config.options.access_mode = EnumUtil::FromString<AccessMode>(str_input);
-}
-
-void AccessModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.access_mode = DBConfig().options.access_mode;
-}
-
-Value AccessModeSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::Lower(EnumUtil::ToString(config.options.access_mode)));
-}
-
-//===----------------------------------------------------------------------===//
-// Allocator Background Threads
-//===----------------------------------------------------------------------===//
-void AllocatorBackgroundThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.allocator_background_threads = input.GetValue<bool>();
-}
-
-void AllocatorBackgroundThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!OnGlobalReset(db, config)) {
-		return;
-	}
-	config.options.allocator_background_threads = DBConfig().options.allocator_background_threads;
-}
-
-Value AllocatorBackgroundThreadsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.allocator_background_threads);
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Community Extensions
-//===----------------------------------------------------------------------===//
-void AllowCommunityExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.allow_community_extensions = input.GetValue<bool>();
-}
-
-void AllowCommunityExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!OnGlobalReset(db, config)) {
-		return;
-	}
-	config.options.allow_community_extensions = DBConfig().options.allow_community_extensions;
-}
-
-Value AllowCommunityExtensionsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.allow_community_extensions);
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Extensions Metadata Mismatch
-//===----------------------------------------------------------------------===//
-void AllowExtensionsMetadataMismatchSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.allow_extensions_metadata_mismatch = input.GetValue<bool>();
-}
-
-void AllowExtensionsMetadataMismatchSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.allow_extensions_metadata_mismatch = DBConfig().options.allow_extensions_metadata_mismatch;
-}
-
-Value AllowExtensionsMetadataMismatchSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.allow_extensions_metadata_mismatch);
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Unredacted Secrets
-//===----------------------------------------------------------------------===//
-void AllowUnredactedSecretsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.allow_unredacted_secrets = input.GetValue<bool>();
-}
-
-void AllowUnredactedSecretsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!OnGlobalReset(db, config)) {
-		return;
-	}
-	config.options.allow_unredacted_secrets = DBConfig().options.allow_unredacted_secrets;
-}
-
-Value AllowUnredactedSecretsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.allow_unredacted_secrets);
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Unsigned Extensions
-//===----------------------------------------------------------------------===//
-void AllowUnsignedExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.allow_unsigned_extensions = input.GetValue<bool>();
-}
-
-void AllowUnsignedExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!OnGlobalReset(db, config)) {
-		return;
-	}
-	config.options.allow_unsigned_extensions = DBConfig().options.allow_unsigned_extensions;
-}
-
-Value AllowUnsignedExtensionsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.allow_unsigned_extensions);
-}
-
-//===----------------------------------------------------------------------===//
-// Arrow Large Buffer Size
-//===----------------------------------------------------------------------===//
-void ArrowLargeBufferSizeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.arrow_offset_size = DBConfig().options.arrow_offset_size;
-}
-
-//===----------------------------------------------------------------------===//
-// Arrow Lossless Conversion
-//===----------------------------------------------------------------------===//
-void ArrowLosslessConversionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.arrow_lossless_conversion = input.GetValue<bool>();
-}
-
-void ArrowLosslessConversionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.arrow_lossless_conversion = DBConfig().options.arrow_lossless_conversion;
-}
-
-Value ArrowLosslessConversionSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.arrow_lossless_conversion);
-}
-
-//===----------------------------------------------------------------------===//
-// Arrow Output List View
-//===----------------------------------------------------------------------===//
-void ArrowOutputListViewSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.arrow_use_list_view = input.GetValue<bool>();
-}
-
-void ArrowOutputListViewSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.arrow_use_list_view = DBConfig().options.arrow_use_list_view;
-}
-
-Value ArrowOutputListViewSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.arrow_use_list_view);
-}
-
-//===----------------------------------------------------------------------===//
-// Autoinstall Extension Repository
-//===----------------------------------------------------------------------===//
-void AutoinstallExtensionRepositorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.autoinstall_extension_repo = input.GetValue<string>();
-}
-
-void AutoinstallExtensionRepositorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.autoinstall_extension_repo = DBConfig().options.autoinstall_extension_repo;
-}
-
-Value AutoinstallExtensionRepositorySetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.autoinstall_extension_repo);
-}
-
-//===----------------------------------------------------------------------===//
-// Autoinstall Known Extensions
-//===----------------------------------------------------------------------===//
-void AutoinstallKnownExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.autoinstall_known_extensions = input.GetValue<bool>();
-}
-
-void AutoinstallKnownExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.autoinstall_known_extensions = DBConfig().options.autoinstall_known_extensions;
-}
-
-Value AutoinstallKnownExtensionsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.autoinstall_known_extensions);
-}
-
-//===----------------------------------------------------------------------===//
-// Autoload Known Extensions
-//===----------------------------------------------------------------------===//
-void AutoloadKnownExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.autoload_known_extensions = input.GetValue<bool>();
-}
-
-void AutoloadKnownExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.autoload_known_extensions = DBConfig().options.autoload_known_extensions;
-}
-
-Value AutoloadKnownExtensionsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.autoload_known_extensions);
-}
-
-//===----------------------------------------------------------------------===//
-// Catalog Error Max Schemas
-//===----------------------------------------------------------------------===//
-void CatalogErrorMaxSchemasSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.catalog_error_max_schemas = input.GetValue<idx_t>();
-}
-
-void CatalogErrorMaxSchemasSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.catalog_error_max_schemas = DBConfig().options.catalog_error_max_schemas;
-}
-
-Value CatalogErrorMaxSchemasSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::UBIGINT(config.options.catalog_error_max_schemas);
-}
-
-//===----------------------------------------------------------------------===//
-// Checkpoint Threshold
-//===----------------------------------------------------------------------===//
-void CheckpointThresholdSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.checkpoint_wal_size = DBConfig().options.checkpoint_wal_size;
-}
-
-//===----------------------------------------------------------------------===//
-// Custom Extension Repository
-//===----------------------------------------------------------------------===//
-void CustomExtensionRepositorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.custom_extension_repo = input.GetValue<string>();
-}
-
-void CustomExtensionRepositorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.custom_extension_repo = DBConfig().options.custom_extension_repo;
-}
-
-Value CustomExtensionRepositorySetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.custom_extension_repo);
-}
-
-//===----------------------------------------------------------------------===//
-// Custom User Agent
-//===----------------------------------------------------------------------===//
-Value CustomUserAgentSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.custom_user_agent);
-}
-
-//===----------------------------------------------------------------------===//
-// Debug Asof Iejoin
-//===----------------------------------------------------------------------===//
-void DebugAsofIejoinSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.force_asof_iejoin = input.GetValue<bool>();
-}
-
-void DebugAsofIejoinSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).force_asof_iejoin = ClientConfig().force_asof_iejoin;
-}
-
-Value DebugAsofIejoinSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.force_asof_iejoin);
-}
-
-//===----------------------------------------------------------------------===//
-// Debug Checkpoint Abort
-//===----------------------------------------------------------------------===//
-void DebugCheckpointAbortSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto str_input = StringUtil::Upper(input.GetValue<string>());
-	config.options.checkpoint_abort = EnumUtil::FromString<CheckpointAbort>(str_input);
-}
-
-void DebugCheckpointAbortSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.checkpoint_abort = DBConfig().options.checkpoint_abort;
-}
-
-Value DebugCheckpointAbortSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::Lower(EnumUtil::ToString(config.options.checkpoint_abort)));
-}
-
-//===----------------------------------------------------------------------===//
-// Debug Force External
-//===----------------------------------------------------------------------===//
-void DebugForceExternalSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.force_external = input.GetValue<bool>();
-}
-
-void DebugForceExternalSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).force_external = ClientConfig().force_external;
-}
-
-Value DebugForceExternalSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.force_external);
-}
-
-//===----------------------------------------------------------------------===//
-// Debug Force No Cross Product
-//===----------------------------------------------------------------------===//
-void DebugForceNoCrossProductSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.force_no_cross_product = input.GetValue<bool>();
-}
-
-void DebugForceNoCrossProductSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).force_no_cross_product = ClientConfig().force_no_cross_product;
-}
-
-Value DebugForceNoCrossProductSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.force_no_cross_product);
-}
-
-//===----------------------------------------------------------------------===//
-// Debug Skip Checkpoint On Commit
-//===----------------------------------------------------------------------===//
-void DebugSkipCheckpointOnCommitSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.debug_skip_checkpoint_on_commit = input.GetValue<bool>();
-}
-
-void DebugSkipCheckpointOnCommitSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.debug_skip_checkpoint_on_commit = DBConfig().options.debug_skip_checkpoint_on_commit;
-}
-
-Value DebugSkipCheckpointOnCommitSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.debug_skip_checkpoint_on_commit);
-}
-
-//===----------------------------------------------------------------------===//
-// Debug Window Mode
-//===----------------------------------------------------------------------===//
-void DebugWindowModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto str_input = StringUtil::Upper(input.GetValue<string>());
-	config.options.window_mode = EnumUtil::FromString<WindowAggregationMode>(str_input);
-}
-
-void DebugWindowModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.window_mode = DBConfig().options.window_mode;
-}
-
-Value DebugWindowModeSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::Lower(EnumUtil::ToString(config.options.window_mode)));
-}
-
-//===----------------------------------------------------------------------===//
-// Default Null Order
-//===----------------------------------------------------------------------===//
-void DefaultNullOrderSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.default_null_order = DBConfig().options.default_null_order;
-}
-
-Value DefaultNullOrderSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::Lower(EnumUtil::ToString(config.options.default_null_order)));
-}
-
-//===----------------------------------------------------------------------===//
-// Default Order
-//===----------------------------------------------------------------------===//
-void DefaultOrderSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.default_order_type = DBConfig().options.default_order_type;
-}
-
-//===----------------------------------------------------------------------===//
-// Dynamic Or Filter Threshold
-//===----------------------------------------------------------------------===//
-void DynamicOrFilterThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.dynamic_or_filter_threshold = input.GetValue<idx_t>();
-}
-
-void DynamicOrFilterThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).dynamic_or_filter_threshold = ClientConfig().dynamic_or_filter_threshold;
-}
-
-Value DynamicOrFilterThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.dynamic_or_filter_threshold);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable External Access
-//===----------------------------------------------------------------------===//
-void EnableExternalAccessSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.enable_external_access = input.GetValue<bool>();
-}
-
-void EnableExternalAccessSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!OnGlobalReset(db, config)) {
-		return;
-	}
-	config.options.enable_external_access = DBConfig().options.enable_external_access;
-}
-
-Value EnableExternalAccessSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.enable_external_access);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable F S S T Vectors
-//===----------------------------------------------------------------------===//
-void EnableFSSTVectorsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.enable_fsst_vectors = input.GetValue<bool>();
-}
-
-void EnableFSSTVectorsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.enable_fsst_vectors = DBConfig().options.enable_fsst_vectors;
-}
-
-Value EnableFSSTVectorsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.enable_fsst_vectors);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable H T T P Logging
-//===----------------------------------------------------------------------===//
-void EnableHTTPLoggingSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_http_logging = input.GetValue<bool>();
-}
-
-void EnableHTTPLoggingSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).enable_http_logging = ClientConfig().enable_http_logging;
-}
-
-Value EnableHTTPLoggingSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.enable_http_logging);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable H T T P Metadata Cache
-//===----------------------------------------------------------------------===//
-void EnableHTTPMetadataCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.http_metadata_cache_enable = input.GetValue<bool>();
-}
-
-void EnableHTTPMetadataCacheSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.http_metadata_cache_enable = DBConfig().options.http_metadata_cache_enable;
-}
-
-Value EnableHTTPMetadataCacheSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.http_metadata_cache_enable);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable Macro Dependencies
-//===----------------------------------------------------------------------===//
-void EnableMacroDependenciesSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.enable_macro_dependencies = input.GetValue<bool>();
-}
-
-void EnableMacroDependenciesSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.enable_macro_dependencies = DBConfig().options.enable_macro_dependencies;
-}
-
-Value EnableMacroDependenciesSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.enable_macro_dependencies);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable Progress Bar
-//===----------------------------------------------------------------------===//
-void EnableProgressBarSetting::SetLocal(ClientContext &context, const Value &input) {
-	if (!OnLocalSet(context, input)) {
-		return;
-	}
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_progress_bar = input.GetValue<bool>();
-}
-
-void EnableProgressBarSetting::ResetLocal(ClientContext &context) {
-	if (!OnLocalReset(context)) {
-		return;
-	}
-	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
-}
-
-Value EnableProgressBarSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.enable_progress_bar);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable View Dependencies
-//===----------------------------------------------------------------------===//
-void EnableViewDependenciesSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.enable_view_dependencies = input.GetValue<bool>();
-}
-
-void EnableViewDependenciesSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.enable_view_dependencies = DBConfig().options.enable_view_dependencies;
-}
-
-Value EnableViewDependenciesSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.enable_view_dependencies);
-}
-
-//===----------------------------------------------------------------------===//
-// Errors As J S O N
-//===----------------------------------------------------------------------===//
-void ErrorsAsJSONSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.errors_as_json = input.GetValue<bool>();
-}
-
-void ErrorsAsJSONSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).errors_as_json = ClientConfig().errors_as_json;
-}
-
-Value ErrorsAsJSONSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.errors_as_json);
-}
-
-//===----------------------------------------------------------------------===//
-// Explain Output
-//===----------------------------------------------------------------------===//
-void ExplainOutputSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	auto str_input = StringUtil::Upper(input.GetValue<string>());
-	config.explain_output_type = EnumUtil::FromString<ExplainOutputType>(str_input);
-}
-
-void ExplainOutputSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).explain_output_type = ClientConfig().explain_output_type;
-}
-
-Value ExplainOutputSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(StringUtil::Lower(EnumUtil::ToString(config.explain_output_type)));
-}
-
-//===----------------------------------------------------------------------===//
-// Extension Directory
-//===----------------------------------------------------------------------===//
-void ExtensionDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.extension_directory = input.GetValue<string>();
-}
-
-void ExtensionDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.extension_directory = DBConfig().options.extension_directory;
-}
-
-Value ExtensionDirectorySetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.extension_directory);
-}
-
-//===----------------------------------------------------------------------===//
-// External Threads
-//===----------------------------------------------------------------------===//
-void ExternalThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.external_threads = input.GetValue<idx_t>();
-}
-
-void ExternalThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!OnGlobalReset(db, config)) {
-		return;
-	}
-	config.options.external_threads = DBConfig().options.external_threads;
-}
-
-Value ExternalThreadsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::UBIGINT(config.options.external_threads);
-}
-
-//===----------------------------------------------------------------------===//
-// Home Directory
-//===----------------------------------------------------------------------===//
-void HomeDirectorySetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).home_directory = ClientConfig().home_directory;
-}
-
-Value HomeDirectorySetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(config.home_directory);
-}
-
-//===----------------------------------------------------------------------===//
-// H T T P Logging Output
-//===----------------------------------------------------------------------===//
-void HTTPLoggingOutputSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.http_logging_output = input.GetValue<string>();
-}
-
-void HTTPLoggingOutputSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).http_logging_output = ClientConfig().http_logging_output;
-}
-
-Value HTTPLoggingOutputSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(config.http_logging_output);
-}
-
-//===----------------------------------------------------------------------===//
-// H T T P Proxy
-//===----------------------------------------------------------------------===//
-void HTTPProxySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.http_proxy = input.GetValue<string>();
-}
-
-void HTTPProxySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.http_proxy = DBConfig().options.http_proxy;
-}
-
-Value HTTPProxySetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.http_proxy);
-}
-
-//===----------------------------------------------------------------------===//
-// H T T P Proxy Password
-//===----------------------------------------------------------------------===//
-void HTTPProxyPasswordSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.http_proxy_password = input.GetValue<string>();
-}
-
-void HTTPProxyPasswordSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.http_proxy_password = DBConfig().options.http_proxy_password;
-}
-
-Value HTTPProxyPasswordSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.http_proxy_password);
-}
-
-//===----------------------------------------------------------------------===//
-// H T T P Proxy Username
-//===----------------------------------------------------------------------===//
-void HTTPProxyUsernameSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.http_proxy_username = input.GetValue<string>();
-}
-
-void HTTPProxyUsernameSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.http_proxy_username = DBConfig().options.http_proxy_username;
-}
-
-Value HTTPProxyUsernameSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.http_proxy_username);
-}
-
-//===----------------------------------------------------------------------===//
-// I E E E Floating Point Ops
-//===----------------------------------------------------------------------===//
-void IEEEFloatingPointOpsSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.ieee_floating_point_ops = input.GetValue<bool>();
-}
-
-void IEEEFloatingPointOpsSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).ieee_floating_point_ops = ClientConfig().ieee_floating_point_ops;
-}
-
-Value IEEEFloatingPointOpsSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.ieee_floating_point_ops);
-}
-
-//===----------------------------------------------------------------------===//
-// Immediate Transaction Mode
-//===----------------------------------------------------------------------===//
-void ImmediateTransactionModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.immediate_transaction_mode = input.GetValue<bool>();
-}
-
-void ImmediateTransactionModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.immediate_transaction_mode = DBConfig().options.immediate_transaction_mode;
-}
-
-Value ImmediateTransactionModeSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.immediate_transaction_mode);
-}
-
-//===----------------------------------------------------------------------===//
-// Index Scan Max Count
-//===----------------------------------------------------------------------===//
-void IndexScanMaxCountSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.index_scan_max_count = input.GetValue<idx_t>();
-}
-
-void IndexScanMaxCountSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.index_scan_max_count = DBConfig().options.index_scan_max_count;
-}
-
-Value IndexScanMaxCountSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::UBIGINT(config.options.index_scan_max_count);
-}
-
-//===----------------------------------------------------------------------===//
-// Index Scan Percentage
-//===----------------------------------------------------------------------===//
-void IndexScanPercentageSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!OnGlobalSet(db, config, input)) {
-		return;
-	}
-	config.options.index_scan_percentage = input.GetValue<double>();
-}
-
-void IndexScanPercentageSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.index_scan_percentage = DBConfig().options.index_scan_percentage;
-}
-
-Value IndexScanPercentageSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::DOUBLE(config.options.index_scan_percentage);
-}
-
-//===----------------------------------------------------------------------===//
-// Integer Division
-//===----------------------------------------------------------------------===//
-void IntegerDivisionSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.integer_division = input.GetValue<bool>();
-}
-
-void IntegerDivisionSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).integer_division = ClientConfig().integer_division;
-}
-
-Value IntegerDivisionSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.integer_division);
-}
-
-//===----------------------------------------------------------------------===//
-// Lock Configuration
-//===----------------------------------------------------------------------===//
-void LockConfigurationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.lock_configuration = input.GetValue<bool>();
-}
-
-void LockConfigurationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.lock_configuration = DBConfig().options.lock_configuration;
-}
-
-Value LockConfigurationSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.lock_configuration);
-}
-
-//===----------------------------------------------------------------------===//
-// Max Expression Depth
-//===----------------------------------------------------------------------===//
-void MaxExpressionDepthSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.max_expression_depth = input.GetValue<idx_t>();
-}
-
-void MaxExpressionDepthSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).max_expression_depth = ClientConfig().max_expression_depth;
-}
-
-Value MaxExpressionDepthSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.max_expression_depth);
-}
-
-//===----------------------------------------------------------------------===//
-// Max Vacuum Tasks
-//===----------------------------------------------------------------------===//
-void MaxVacuumTasksSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.max_vacuum_tasks = input.GetValue<idx_t>();
-}
-
-void MaxVacuumTasksSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.max_vacuum_tasks = DBConfig().options.max_vacuum_tasks;
-}
-
-Value MaxVacuumTasksSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::UBIGINT(config.options.max_vacuum_tasks);
-}
-
-//===----------------------------------------------------------------------===//
-// Merge Join Threshold
-//===----------------------------------------------------------------------===//
-void MergeJoinThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.merge_join_threshold = input.GetValue<idx_t>();
-}
-
-void MergeJoinThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).merge_join_threshold = ClientConfig().merge_join_threshold;
-}
-
-Value MergeJoinThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.merge_join_threshold);
-}
-
-//===----------------------------------------------------------------------===//
-// Nested Loop Join Threshold
-//===----------------------------------------------------------------------===//
-void NestedLoopJoinThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.nested_loop_join_threshold = input.GetValue<idx_t>();
-}
-
-void NestedLoopJoinThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).nested_loop_join_threshold = ClientConfig().nested_loop_join_threshold;
-}
-
-Value NestedLoopJoinThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.nested_loop_join_threshold);
-}
-
-//===----------------------------------------------------------------------===//
-// Old Implicit Casting
-//===----------------------------------------------------------------------===//
-void OldImplicitCastingSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.old_implicit_casting = input.GetValue<bool>();
-}
-
-void OldImplicitCastingSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.old_implicit_casting = DBConfig().options.old_implicit_casting;
-}
-
-Value OldImplicitCastingSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.old_implicit_casting);
-}
-
-//===----------------------------------------------------------------------===//
-// Order By Non Integer Literal
-//===----------------------------------------------------------------------===//
-void OrderByNonIntegerLiteralSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.order_by_non_integer_literal = input.GetValue<bool>();
-}
-
-void OrderByNonIntegerLiteralSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).order_by_non_integer_literal = ClientConfig().order_by_non_integer_literal;
-}
-
-Value OrderByNonIntegerLiteralSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.order_by_non_integer_literal);
-}
-
-//===----------------------------------------------------------------------===//
-// Ordered Aggregate Threshold
-//===----------------------------------------------------------------------===//
-void OrderedAggregateThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	if (!OnLocalSet(context, input)) {
-		return;
-	}
-	auto &config = ClientConfig::GetConfig(context);
-	config.ordered_aggregate_threshold = input.GetValue<idx_t>();
-}
-
-void OrderedAggregateThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).ordered_aggregate_threshold = ClientConfig().ordered_aggregate_threshold;
-}
-
-Value OrderedAggregateThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.ordered_aggregate_threshold);
-}
-
-//===----------------------------------------------------------------------===//
-// Partitioned Write Flush Threshold
-//===----------------------------------------------------------------------===//
-void PartitionedWriteFlushThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.partitioned_write_flush_threshold = input.GetValue<idx_t>();
-}
-
-void PartitionedWriteFlushThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).partitioned_write_flush_threshold =
-	    ClientConfig().partitioned_write_flush_threshold;
-}
-
-Value PartitionedWriteFlushThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.partitioned_write_flush_threshold);
-}
-
-//===----------------------------------------------------------------------===//
-// Partitioned Write Max Open Files
-//===----------------------------------------------------------------------===//
-void PartitionedWriteMaxOpenFilesSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.partitioned_write_max_open_files = input.GetValue<idx_t>();
-}
-
-void PartitionedWriteMaxOpenFilesSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).partitioned_write_max_open_files = ClientConfig().partitioned_write_max_open_files;
-}
-
-Value PartitionedWriteMaxOpenFilesSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.partitioned_write_max_open_files);
-}
-
-//===----------------------------------------------------------------------===//
-// Perfect Ht Threshold
-//===----------------------------------------------------------------------===//
-void PerfectHtThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).perfect_ht_threshold = ClientConfig().perfect_ht_threshold;
-}
-
-//===----------------------------------------------------------------------===//
-// Pivot Filter Threshold
-//===----------------------------------------------------------------------===//
-void PivotFilterThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.pivot_filter_threshold = input.GetValue<idx_t>();
-}
-
-void PivotFilterThresholdSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).pivot_filter_threshold = ClientConfig().pivot_filter_threshold;
-}
-
-Value PivotFilterThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.pivot_filter_threshold);
-}
-
-//===----------------------------------------------------------------------===//
-// Pivot Limit
-//===----------------------------------------------------------------------===//
-void PivotLimitSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.pivot_limit = input.GetValue<idx_t>();
-}
-
-void PivotLimitSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).pivot_limit = ClientConfig().pivot_limit;
-}
-
-Value PivotLimitSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::UBIGINT(config.pivot_limit);
-}
-
-//===----------------------------------------------------------------------===//
-// Prefer Range Joins
-//===----------------------------------------------------------------------===//
-void PreferRangeJoinsSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.prefer_range_joins = input.GetValue<bool>();
-}
-
-void PreferRangeJoinsSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).prefer_range_joins = ClientConfig().prefer_range_joins;
-}
-
-Value PreferRangeJoinsSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.prefer_range_joins);
-}
-
-//===----------------------------------------------------------------------===//
-// Preserve Identifier Case
-//===----------------------------------------------------------------------===//
-void PreserveIdentifierCaseSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.preserve_identifier_case = input.GetValue<bool>();
-}
-
-void PreserveIdentifierCaseSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).preserve_identifier_case = ClientConfig().preserve_identifier_case;
-}
-
-Value PreserveIdentifierCaseSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.preserve_identifier_case);
-}
-
-//===----------------------------------------------------------------------===//
-// Preserve Insertion Order
-//===----------------------------------------------------------------------===//
-void PreserveInsertionOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.preserve_insertion_order = input.GetValue<bool>();
-}
-
-void PreserveInsertionOrderSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.preserve_insertion_order = DBConfig().options.preserve_insertion_order;
-}
-
-Value PreserveInsertionOrderSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.preserve_insertion_order);
-}
-
-//===----------------------------------------------------------------------===//
-// Produce Arrow String View
-//===----------------------------------------------------------------------===//
-void ProduceArrowStringViewSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.produce_arrow_string_views = input.GetValue<bool>();
-}
-
-void ProduceArrowStringViewSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.produce_arrow_string_views = DBConfig().options.produce_arrow_string_views;
-}
-
-Value ProduceArrowStringViewSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.options.produce_arrow_string_views);
-}
-
-//===----------------------------------------------------------------------===//
-// Scalar Subquery Error On Multiple Rows
-//===----------------------------------------------------------------------===//
-void ScalarSubqueryErrorOnMultipleRowsSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.scalar_subquery_error_on_multiple_rows = input.GetValue<bool>();
-}
-
-void ScalarSubqueryErrorOnMultipleRowsSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).scalar_subquery_error_on_multiple_rows =
-	    ClientConfig().scalar_subquery_error_on_multiple_rows;
-}
-
-Value ScalarSubqueryErrorOnMultipleRowsSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.scalar_subquery_error_on_multiple_rows);
-}
-
-//===----------------------------------------------------------------------===//
-// Zstd Min String Length
-//===----------------------------------------------------------------------===//
-void ZstdMinStringLengthSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.zstd_min_string_length = input.GetValue<idx_t>();
-}
-
-void ZstdMinStringLengthSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.zstd_min_string_length = DBConfig().options.zstd_min_string_length;
-}
-
-Value ZstdMinStringLengthSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::UBIGINT(config.options.zstd_min_string_length);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/settings/custom_settings.cpp b/src/duckdb/src/main/settings/custom_settings.cpp
deleted file mode 100644
index 57e961a22..000000000
--- a/src/duckdb/src/main/settings/custom_settings.cpp
+++ /dev/null
@@ -1,1237 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-// This file will not be overwritten. To implement a custom function for
-// a new setting, enable 'custom_implementation' in 'src/common/settings.json'
-// for this setting. The 'update_settings_definitions.py' may include new
-// setting methods' signatures that need to be implemented in this file. You
-// can check the functions declaration in 'settings.hpp' and what is
-// autogenerated in 'autogenerated_settings.cpp'.
-//
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/main/settings.hpp"
-
-#include "duckdb/common/enums/access_mode.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-
-namespace duckdb {
-
-const string GetDefaultUserAgent() {
-	return StringUtil::Format("duckdb/%s(%s)", DuckDB::LibraryVersion(), DuckDB::Platform());
-}
-
-//===----------------------------------------------------------------------===//
-// Access Mode
-//===----------------------------------------------------------------------===//
-bool AccessModeSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (db) {
-		throw InvalidInputException("Cannot change access_mode setting while database is running - it must be set when "
-		                            "opening or attaching the database");
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Allocator Background Threads
-//===----------------------------------------------------------------------===//
-bool AllocatorBackgroundThreadsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetAllocatorBackgroundThreads(input.GetValue<bool>());
-	}
-	return true;
-}
-
-bool AllocatorBackgroundThreadsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) {
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetAllocatorBackgroundThreads(DBConfig().options.allocator_background_threads);
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Allocator Bulk Deallocation Flush Threshold
-//===----------------------------------------------------------------------===//
-void AllocatorBulkDeallocationFlushThresholdSetting::SetGlobal(DatabaseInstance *db, DBConfig &config,
-                                                               const Value &input) {
-	config.options.allocator_bulk_deallocation_flush_threshold = DBConfig::ParseMemoryLimit(input.ToString());
-	if (db) {
-		BufferManager::GetBufferManager(*db).GetBufferPool().SetAllocatorBulkDeallocationFlushThreshold(
-		    config.options.allocator_bulk_deallocation_flush_threshold);
-	}
-}
-
-void AllocatorBulkDeallocationFlushThresholdSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.allocator_bulk_deallocation_flush_threshold =
-	    DBConfig().options.allocator_bulk_deallocation_flush_threshold;
-	if (db) {
-		BufferManager::GetBufferManager(*db).GetBufferPool().SetAllocatorBulkDeallocationFlushThreshold(
-		    config.options.allocator_bulk_deallocation_flush_threshold);
-	}
-}
-
-Value AllocatorBulkDeallocationFlushThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.options.allocator_bulk_deallocation_flush_threshold));
-}
-
-//===----------------------------------------------------------------------===//
-// Allocator Flush Threshold
-//===----------------------------------------------------------------------===//
-void AllocatorFlushThresholdSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.allocator_flush_threshold = DBConfig::ParseMemoryLimit(input.ToString());
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetAllocatorFlushTreshold(config.options.allocator_flush_threshold);
-	}
-}
-
-void AllocatorFlushThresholdSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.allocator_flush_threshold = DBConfig().options.allocator_flush_threshold;
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetAllocatorFlushTreshold(config.options.allocator_flush_threshold);
-	}
-}
-
-Value AllocatorFlushThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.options.allocator_flush_threshold));
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Community Extensions
-//===----------------------------------------------------------------------===//
-bool AllowCommunityExtensionsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (db && !config.options.allow_community_extensions) {
-		auto new_value = input.GetValue<bool>();
-		if (new_value) {
-			throw InvalidInputException("Cannot upgrade allow_community_extensions setting while database is running");
-		}
-		return false;
-	}
-	return true;
-}
-
-bool AllowCommunityExtensionsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) {
-	if (db && !config.options.allow_community_extensions) {
-		if (DBConfig().options.allow_community_extensions) {
-			throw InvalidInputException("Cannot upgrade allow_community_extensions setting while database is running");
-		}
-		return false;
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Persistent Secrets
-//===----------------------------------------------------------------------===//
-void AllowPersistentSecretsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto value = input.DefaultCastAs(LogicalType::BOOLEAN);
-	config.secret_manager->SetEnablePersistentSecrets(value.GetValue<bool>());
-}
-
-void AllowPersistentSecretsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.secret_manager->ResetEnablePersistentSecrets();
-}
-
-Value AllowPersistentSecretsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.secret_manager->PersistentSecretsEnabled());
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Unredacted Secrets
-//===----------------------------------------------------------------------===//
-bool AllowUnredactedSecretsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (db && input.GetValue<bool>()) {
-		throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running");
-	}
-	return true;
-}
-
-bool AllowUnredactedSecretsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) {
-	if (db) {
-		throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running");
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Allow Unsigned Extensions
-//===----------------------------------------------------------------------===//
-bool AllowUnsignedExtensionsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (db && input.GetValue<bool>()) {
-		throw InvalidInputException("Cannot change allow_unsigned_extensions setting while database is running");
-	}
-	return true;
-}
-
-bool AllowUnsignedExtensionsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) {
-	if (db) {
-		throw InvalidInputException("Cannot change allow_unsigned_extensions setting while database is running");
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Allowed Directories
-//===----------------------------------------------------------------------===//
-void AllowedDirectoriesSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!config.options.enable_external_access) {
-		throw InvalidInputException("Cannot change allowed_directories when enable_external_access is disabled");
-	}
-	config.options.allowed_directories.clear();
-	auto &list = ListValue::GetChildren(input);
-	for (auto &val : list) {
-		config.AddAllowedDirectory(val.GetValue<string>());
-	}
-}
-
-void AllowedDirectoriesSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!config.options.enable_external_access) {
-		throw InvalidInputException("Cannot change allowed_directories when enable_external_access is disabled");
-	}
-	config.options.allowed_directories = DBConfig().options.allowed_directories;
-}
-
-Value AllowedDirectoriesSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	vector<Value> allowed_directories;
-	for (auto &dir : config.options.allowed_directories) {
-		allowed_directories.emplace_back(dir);
-	}
-	return Value::LIST(LogicalType::VARCHAR, std::move(allowed_directories));
-}
-
-//===----------------------------------------------------------------------===//
-// Allowed Paths
-//===----------------------------------------------------------------------===//void
-void AllowedPathsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!config.options.enable_external_access) {
-		throw InvalidInputException("Cannot change allowed_paths when enable_external_access is disabled");
-	}
-	config.options.allowed_paths.clear();
-	auto &list = ListValue::GetChildren(input);
-	for (auto &val : list) {
-		config.AddAllowedPath(val.GetValue<string>());
-	}
-}
-
-void AllowedPathsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!config.options.enable_external_access) {
-		throw InvalidInputException("Cannot change allowed_paths when enable_external_access is disabled");
-	}
-	config.options.allowed_paths = DBConfig().options.allowed_paths;
-}
-
-Value AllowedPathsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	vector<Value> allowed_paths;
-	for (auto &dir : config.options.allowed_paths) {
-		allowed_paths.emplace_back(dir);
-	}
-	return Value::LIST(LogicalType::VARCHAR, std::move(allowed_paths));
-}
-
-//===----------------------------------------------------------------------===//
-// Arrow Large Buffer Size
-//===----------------------------------------------------------------------===//
-void ArrowLargeBufferSizeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto export_large_buffers_arrow = input.GetValue<bool>();
-	config.options.arrow_offset_size = export_large_buffers_arrow ? ArrowOffsetSize::LARGE : ArrowOffsetSize::REGULAR;
-}
-
-Value ArrowLargeBufferSizeSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	bool export_large_buffers_arrow = config.options.arrow_offset_size == ArrowOffsetSize::LARGE;
-	return Value::BOOLEAN(export_large_buffers_arrow);
-}
-
-//===----------------------------------------------------------------------===//
-// Checkpoint Threshold
-//===----------------------------------------------------------------------===//
-void CheckpointThresholdSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	idx_t new_limit = DBConfig::ParseMemoryLimit(input.ToString());
-	config.options.checkpoint_wal_size = new_limit;
-}
-
-Value CheckpointThresholdSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.options.checkpoint_wal_size));
-}
-
-//===----------------------------------------------------------------------===//
-// Custom Profiling Settings
-//===----------------------------------------------------------------------===//
-bool IsEnabledOptimizer(MetricsType metric, const set<OptimizerType> &disabled_optimizers) {
-	auto matching_optimizer_type = MetricsUtils::GetOptimizerTypeByMetric(metric);
-	if (matching_optimizer_type != OptimizerType::INVALID &&
-	    disabled_optimizers.find(matching_optimizer_type) == disabled_optimizers.end()) {
-		return true;
-	}
-	return false;
-}
-
-static profiler_settings_t FillTreeNodeSettings(unordered_map<string, string> &json,
-                                                const set<OptimizerType> &disabled_optimizers) {
-	profiler_settings_t metrics;
-
-	string invalid_settings;
-	for (auto &entry : json) {
-		MetricsType setting;
-		try {
-			setting = EnumUtil::FromString<MetricsType>(StringUtil::Upper(entry.first));
-		} catch (std::exception &ex) {
-			if (!invalid_settings.empty()) {
-				invalid_settings += ", ";
-			}
-			invalid_settings += entry.first;
-			continue;
-		}
-		if (StringUtil::Lower(entry.second) == "true" &&
-		    (!MetricsUtils::IsOptimizerMetric(setting) || IsEnabledOptimizer(setting, disabled_optimizers))) {
-			metrics.insert(setting);
-		}
-	}
-
-	if (!invalid_settings.empty()) {
-		throw IOException("Invalid custom profiler settings: \"%s\"", invalid_settings);
-	}
-	return metrics;
-}
-
-void AddOptimizerMetrics(profiler_settings_t &settings, const set<OptimizerType> &disabled_optimizers) {
-	if (settings.find(MetricsType::ALL_OPTIMIZERS) != settings.end()) {
-		auto optimizer_metrics = MetricsUtils::GetOptimizerMetrics();
-		for (auto &metric : optimizer_metrics) {
-			if (IsEnabledOptimizer(metric, disabled_optimizers)) {
-				settings.insert(metric);
-			}
-		}
-	}
-}
-
-void CustomProfilingSettingsSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-
-	// parse the file content
-	unordered_map<string, string> json;
-	try {
-		json = StringUtil::ParseJSONMap(input.ToString());
-	} catch (std::exception &ex) {
-		throw IOException("Could not parse the custom profiler settings file due to incorrect JSON: \"%s\".  Make sure "
-		                  "all the keys and values start with a quote. ",
-		                  input.ToString());
-	}
-
-	config.enable_profiler = true;
-	auto &db_config = DBConfig::GetConfig(context);
-	auto &disabled_optimizers = db_config.options.disabled_optimizers;
-
-	auto settings = FillTreeNodeSettings(json, disabled_optimizers);
-	AddOptimizerMetrics(settings, disabled_optimizers);
-	config.profiler_settings = settings;
-}
-
-void CustomProfilingSettingsSetting::ResetLocal(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_profiler = ClientConfig().enable_profiler;
-	config.profiler_settings = ProfilingInfo::DefaultSettings();
-}
-
-Value CustomProfilingSettingsSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-
-	string profiling_settings_str;
-	for (auto &entry : config.profiler_settings) {
-		if (!profiling_settings_str.empty()) {
-			profiling_settings_str += ", ";
-		}
-		profiling_settings_str += StringUtil::Format("\"%s\": \"true\"", EnumUtil::ToString(entry));
-	}
-	return Value(StringUtil::Format("{%s}", profiling_settings_str));
-}
-
-//===----------------------------------------------------------------------===//
-// Custom User Agent
-//===----------------------------------------------------------------------===//
-void CustomUserAgentSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto new_value = input.GetValue<string>();
-	if (db) {
-		throw InvalidInputException("Cannot change custom_user_agent setting while database is running");
-	}
-	config.options.custom_user_agent =
-	    config.options.custom_user_agent.empty() ? new_value : config.options.custom_user_agent + " " + new_value;
-}
-
-void CustomUserAgentSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (db) {
-		throw InvalidInputException("Cannot change custom_user_agent setting while database is running");
-	}
-	config.options.custom_user_agent = DBConfig().options.custom_user_agent;
-}
-
-//===----------------------------------------------------------------------===//
-// Default Block Size
-//===----------------------------------------------------------------------===//
-void DefaultBlockSizeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto block_alloc_size = input.GetValue<uint64_t>();
-	Storage::VerifyBlockAllocSize(block_alloc_size);
-	config.options.default_block_alloc_size = block_alloc_size;
-}
-
-void DefaultBlockSizeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.default_block_alloc_size = DBConfig().options.default_block_alloc_size;
-}
-
-Value DefaultBlockSizeSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::UBIGINT(config.options.default_block_alloc_size);
-}
-
-//===----------------------------------------------------------------------===//
-// Default Collation
-//===----------------------------------------------------------------------===//
-void DefaultCollationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	config.options.collation = parameter;
-}
-
-void DefaultCollationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.collation = DBConfig().options.collation;
-}
-
-void DefaultCollationSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	// bind the collation to verify that it exists
-	ExpressionBinder::TestCollation(context, parameter);
-	auto &config = DBConfig::GetConfig(context);
-	config.options.collation = parameter;
-}
-
-void DefaultCollationSetting::ResetLocal(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	config.options.collation = DBConfig().options.collation;
-}
-
-Value DefaultCollationSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.collation);
-}
-
-//===----------------------------------------------------------------------===//
-// Default Null Order
-//===----------------------------------------------------------------------===//
-void DefaultNullOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-
-	if (parameter == "nulls_first" || parameter == "nulls first" || parameter == "null first" || parameter == "first") {
-		config.options.default_null_order = DefaultOrderByNullType::NULLS_FIRST;
-	} else if (parameter == "nulls_last" || parameter == "nulls last" || parameter == "null last" ||
-	           parameter == "last") {
-		config.options.default_null_order = DefaultOrderByNullType::NULLS_LAST;
-	} else if (parameter == "nulls_first_on_asc_last_on_desc" || parameter == "sqlite" || parameter == "mysql") {
-		config.options.default_null_order = DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC;
-	} else if (parameter == "nulls_last_on_asc_first_on_desc" || parameter == "postgres") {
-		config.options.default_null_order = DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC;
-	} else {
-		throw ParserException("Unrecognized parameter for option NULL_ORDER \"%s\", expected either NULLS FIRST, NULLS "
-		                      "LAST, SQLite, MySQL or Postgres",
-		                      parameter);
-	}
-}
-
-//===----------------------------------------------------------------------===//
-// Default Order
-//===----------------------------------------------------------------------===//
-void DefaultOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	if (parameter == "ascending" || parameter == "asc") {
-		config.options.default_order_type = OrderType::ASCENDING;
-	} else if (parameter == "descending" || parameter == "desc") {
-		config.options.default_order_type = OrderType::DESCENDING;
-	} else {
-		throw InvalidInputException("Unrecognized parameter for option DEFAULT_ORDER \"%s\". Expected ASC or DESC.",
-		                            parameter);
-	}
-}
-
-Value DefaultOrderSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	switch (config.options.default_order_type) {
-	case OrderType::ASCENDING:
-		return "asc";
-	case OrderType::DESCENDING:
-		return "desc";
-	default:
-		throw InternalException("Unknown order type setting");
-	}
-}
-
-//===----------------------------------------------------------------------===//
-// Default Secret Storage
-//===----------------------------------------------------------------------===//
-void DefaultSecretStorageSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.secret_manager->SetDefaultStorage(input.ToString());
-}
-
-void DefaultSecretStorageSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.secret_manager->ResetDefaultStorage();
-}
-
-Value DefaultSecretStorageSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return config.secret_manager->DefaultStorage();
-}
-
-//===----------------------------------------------------------------------===//
-// Disabled Filesystems
-//===----------------------------------------------------------------------===//
-void DisabledFilesystemsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!db) {
-		throw InternalException("disabled_filesystems can only be set in an active database");
-	}
-	auto &fs = FileSystem::GetFileSystem(*db);
-	auto list = StringUtil::Split(input.ToString(), ",");
-	fs.SetDisabledFileSystems(list);
-}
-
-void DisabledFilesystemsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!db) {
-		throw InternalException("disabled_filesystems can only be set in an active database");
-	}
-	auto &fs = FileSystem::GetFileSystem(*db);
-	fs.SetDisabledFileSystems(vector<string>());
-}
-
-Value DisabledFilesystemsSetting::GetSetting(const ClientContext &context) {
-	return Value("");
-}
-
-//===----------------------------------------------------------------------===//
-// Disabled Optimizers
-//===----------------------------------------------------------------------===//
-void DisabledOptimizersSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto list = StringUtil::Split(input.ToString(), ",");
-	set<OptimizerType> disabled_optimizers;
-	for (auto &entry : list) {
-		auto param = StringUtil::Lower(entry);
-		StringUtil::Trim(param);
-		if (param.empty()) {
-			continue;
-		}
-		disabled_optimizers.insert(OptimizerTypeFromString(param));
-	}
-	config.options.disabled_optimizers = std::move(disabled_optimizers);
-}
-
-void DisabledOptimizersSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.disabled_optimizers = DBConfig().options.disabled_optimizers;
-}
-
-Value DisabledOptimizersSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	string result;
-	for (auto &optimizer : config.options.disabled_optimizers) {
-		if (!result.empty()) {
-			result += ",";
-		}
-		result += OptimizerTypeToString(optimizer);
-	}
-	return Value(result);
-}
-
-//===----------------------------------------------------------------------===//
-// Duckdb Api
-//===----------------------------------------------------------------------===//
-void DuckDBAPISetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto new_value = input.GetValue<string>();
-	if (db) {
-		throw InvalidInputException("Cannot change duckdb_api setting while database is running");
-	}
-	config.options.duckdb_api = new_value;
-}
-
-void DuckDBAPISetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (db) {
-		throw InvalidInputException("Cannot change duckdb_api setting while database is running");
-	}
-	config.options.duckdb_api = GetDefaultUserAgent();
-}
-
-Value DuckDBAPISetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.options.duckdb_api);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable External Access
-//===----------------------------------------------------------------------===//
-bool EnableExternalAccessSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!db) {
-		return true;
-	}
-	if (input.GetValue<bool>()) {
-		throw InvalidInputException("Cannot change enable_external_access setting while database is running");
-	}
-	if (db && config.options.enable_external_access) {
-		// we are turning off external access - add any already attached databases to the list of accepted paths
-		auto &db_manager = DatabaseManager::Get(*db);
-		auto attached_paths = db_manager.GetAttachedDatabasePaths();
-		for (auto &path : attached_paths) {
-			config.AddAllowedPath(path);
-			config.AddAllowedPath(path + ".wal");
-		}
-	}
-	if (config.options.use_temporary_directory && !config.options.temporary_directory.empty()) {
-		// if temp directory is enabled we can also write there
-		config.AddAllowedDirectory(config.options.temporary_directory);
-	}
-	return true;
-}
-
-bool EnableExternalAccessSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) {
-	if (db) {
-		throw InvalidInputException("Cannot change enable_external_access setting while database is running");
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Enable Object Cache
-//===----------------------------------------------------------------------===//
-void EnableObjectCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-}
-
-void EnableObjectCacheSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-}
-
-Value EnableObjectCacheSetting::GetSetting(const ClientContext &context) {
-	return Value();
-}
-
-//===----------------------------------------------------------------------===//
-// Enable Profiling
-//===----------------------------------------------------------------------===//
-void EnableProfilingSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_profiler = true;
-	config.emit_profiler_output = true;
-	config.profiler_settings = ClientConfig().profiler_settings;
-
-	if (parameter == "json") {
-		config.profiler_print_format = ProfilerPrintFormat::JSON;
-	} else if (parameter == "query_tree") {
-		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
-	} else if (parameter == "query_tree_optimizer") {
-		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE_OPTIMIZER;
-
-		// add optimizer settings to the profiler settings
-		auto optimizer_settings = MetricsUtils::GetOptimizerMetrics();
-		for (auto &setting : optimizer_settings) {
-			config.profiler_settings.insert(setting);
-		}
-
-		// add the phase timing settings to the profiler settings
-		auto phase_timing_settings = MetricsUtils::GetPhaseTimingMetrics();
-		for (auto &setting : phase_timing_settings) {
-			config.profiler_settings.insert(setting);
-		}
-	} else if (parameter == "no_output") {
-		config.profiler_print_format = ProfilerPrintFormat::NO_OUTPUT;
-		config.emit_profiler_output = false;
-	} else if (parameter == "html") {
-		config.profiler_print_format = ProfilerPrintFormat::HTML;
-	} else if (parameter == "graphviz") {
-		config.profiler_print_format = ProfilerPrintFormat::GRAPHVIZ;
-	} else {
-		throw ParserException(
-		    "Unrecognized print format %s, supported formats: [json, query_tree, query_tree_optimizer, no_output]",
-		    parameter);
-	}
-}
-
-void EnableProfilingSetting::ResetLocal(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.profiler_print_format = ClientConfig().profiler_print_format;
-	config.enable_profiler = ClientConfig().enable_profiler;
-	config.emit_profiler_output = ClientConfig().emit_profiler_output;
-	config.profiler_settings = ClientConfig().profiler_settings;
-}
-
-Value EnableProfilingSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (!config.enable_profiler) {
-		return Value();
-	}
-	switch (config.profiler_print_format) {
-	case ProfilerPrintFormat::JSON:
-		return Value("json");
-	case ProfilerPrintFormat::QUERY_TREE:
-		return Value("query_tree");
-	case ProfilerPrintFormat::QUERY_TREE_OPTIMIZER:
-		return Value("query_tree_optimizer");
-	case ProfilerPrintFormat::NO_OUTPUT:
-		return Value("no_output");
-	case ProfilerPrintFormat::HTML:
-		return Value("html");
-	case ProfilerPrintFormat::GRAPHVIZ:
-		return Value("graphviz");
-	default:
-		throw InternalException("Unsupported profiler print format");
-	}
-}
-
-//===----------------------------------------------------------------------===//
-// Enable Progress Bar Print
-//===----------------------------------------------------------------------===//
-void EnableProgressBarPrintSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	ProgressBar::SystemOverrideCheck(config);
-	config.print_progress_bar = input.GetValue<bool>();
-}
-
-void EnableProgressBarPrintSetting::ResetLocal(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	ProgressBar::SystemOverrideCheck(config);
-	config.print_progress_bar = ClientConfig().print_progress_bar;
-}
-
-Value EnableProgressBarPrintSetting::GetSetting(const ClientContext &context) {
-	return Value::BOOLEAN(ClientConfig::GetConfig(context).print_progress_bar);
-}
-
-//===----------------------------------------------------------------------===//
-// Enable Progress Bar
-//===----------------------------------------------------------------------===//
-bool EnableProgressBarSetting::OnLocalSet(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	ProgressBar::SystemOverrideCheck(config);
-	return true;
-}
-
-bool EnableProgressBarSetting::OnLocalReset(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	ProgressBar::SystemOverrideCheck(config);
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// External Threads
-//===----------------------------------------------------------------------===//
-bool ExternalThreadsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto new_val = input.GetValue<int64_t>();
-	if (new_val < 0) {
-		throw SyntaxException("Must have a non-negative number of external threads!");
-	}
-	auto new_external_threads = NumericCast<idx_t>(new_val);
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetThreads(config.options.maximum_threads, new_external_threads);
-	}
-	return true;
-}
-
-bool ExternalThreadsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) {
-	idx_t new_external_threads = DBConfig().options.external_threads;
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetThreads(config.options.maximum_threads, new_external_threads);
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// File Search Path
-//===----------------------------------------------------------------------===//
-void FileSearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	auto &client_data = ClientData::Get(context);
-	client_data.file_search_path = parameter;
-}
-
-void FileSearchPathSetting::ResetLocal(ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	client_data.file_search_path.clear();
-}
-
-Value FileSearchPathSetting::GetSetting(const ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return Value(client_data.file_search_path);
-}
-
-//===----------------------------------------------------------------------===//
-// Force Bitpacking Mode
-//===----------------------------------------------------------------------===//
-void ForceBitpackingModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto mode_str = StringUtil::Lower(input.ToString());
-	auto mode = BitpackingModeFromString(mode_str);
-	if (mode == BitpackingMode::INVALID) {
-		throw ParserException("Unrecognized option for force_bitpacking_mode, expected none, constant, constant_delta, "
-		                      "delta_for, or for");
-	}
-	config.options.force_bitpacking_mode = mode;
-}
-
-void ForceBitpackingModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.force_bitpacking_mode = DBConfig().options.force_bitpacking_mode;
-}
-
-Value ForceBitpackingModeSetting::GetSetting(const ClientContext &context) {
-	return Value(BitpackingModeToString(context.db->config.options.force_bitpacking_mode));
-}
-
-//===----------------------------------------------------------------------===//
-// Force Compression
-//===----------------------------------------------------------------------===//
-void ForceCompressionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto compression = StringUtil::Lower(input.ToString());
-	if (compression == "none" || compression == "auto") {
-		config.options.force_compression = CompressionType::COMPRESSION_AUTO;
-	} else {
-		auto compression_type = CompressionTypeFromString(compression);
-		if (CompressionTypeIsDeprecated(compression_type)) {
-			throw ParserException("Attempted to force a deprecated compression type (%s)",
-			                      CompressionTypeToString(compression_type));
-		}
-		if (compression_type == CompressionType::COMPRESSION_AUTO) {
-			auto compression_types = StringUtil::Join(ListCompressionTypes(), ", ");
-			throw ParserException("Unrecognized option for PRAGMA force_compression, expected %s", compression_types);
-		}
-		config.options.force_compression = compression_type;
-	}
-}
-
-void ForceCompressionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.force_compression = DBConfig().options.force_compression;
-}
-
-Value ForceCompressionSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(*context.db);
-	return CompressionTypeToString(config.options.force_compression);
-}
-
-//===----------------------------------------------------------------------===//
-// Home Directory
-//===----------------------------------------------------------------------===//
-void HomeDirectorySetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (!input.IsNull() && FileSystem::GetFileSystem(context).IsRemoteFile(input.ToString())) {
-		throw InvalidInputException("Cannot set the home directory to a remote path");
-	}
-	config.home_directory = input.IsNull() ? string() : input.ToString();
-}
-
-//===----------------------------------------------------------------------===//
-// Index Scan Percentage
-//===----------------------------------------------------------------------===//
-bool IndexScanPercentageSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto index_scan_percentage = input.GetValue<double>();
-	if (index_scan_percentage < 0 || index_scan_percentage > 1.0) {
-		throw InvalidInputException("the index scan percentage must be within [0, 1]");
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Log Query Path
-//===----------------------------------------------------------------------===//
-void LogQueryPathSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &client_data = ClientData::Get(context);
-	auto path = input.ToString();
-	if (path.empty()) {
-		// empty path: clean up query writer
-		client_data.log_query_writer = nullptr;
-	} else {
-		client_data.log_query_writer = make_uniq<BufferedFileWriter>(FileSystem::GetFileSystem(context), path,
-		                                                             BufferedFileWriter::DEFAULT_OPEN_FLAGS);
-	}
-}
-
-void LogQueryPathSetting::ResetLocal(ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	// TODO: verify that this does the right thing
-	client_data.log_query_writer = std::move(ClientData(context).log_query_writer);
-}
-
-Value LogQueryPathSetting::GetSetting(const ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value();
-}
-
-//===----------------------------------------------------------------------===//
-// Max Memory
-//===----------------------------------------------------------------------===//
-void MaxMemorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.maximum_memory = DBConfig::ParseMemoryLimit(input.ToString());
-	if (db) {
-		BufferManager::GetBufferManager(*db).SetMemoryLimit(config.options.maximum_memory);
-	}
-}
-
-void MaxMemorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.SetDefaultMaxMemory();
-}
-
-Value MaxMemorySetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.options.maximum_memory));
-}
-
-//===----------------------------------------------------------------------===//
-// Max Temp Directory Size
-//===----------------------------------------------------------------------===//
-void MaxTempDirectorySizeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (input == "90% of available disk space") {
-		ResetGlobal(db, config);
-		return;
-	}
-	auto maximum_swap_space = DBConfig::ParseMemoryLimit(input.ToString());
-	if (maximum_swap_space == DConstants::INVALID_INDEX) {
-		// We use INVALID_INDEX to indicate that the value is not set by the user
-		// use one lower to indicate 'unlimited'
-		maximum_swap_space--;
-	}
-	if (!db) {
-		config.options.maximum_swap_space = maximum_swap_space;
-		return;
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(*db);
-	buffer_manager.SetSwapLimit(maximum_swap_space);
-	config.options.maximum_swap_space = maximum_swap_space;
-}
-
-void MaxTempDirectorySizeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.maximum_swap_space = DConstants::INVALID_INDEX;
-	if (!db) {
-		return;
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(*db);
-	buffer_manager.SetSwapLimit();
-}
-
-Value MaxTempDirectorySizeSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	if (config.options.maximum_swap_space != DConstants::INVALID_INDEX) {
-		// Explicitly set by the user
-		return Value(StringUtil::BytesToHumanReadableString(config.options.maximum_swap_space));
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	// Database is initialized, use the setting from the temporary directory
-	auto max_swap = buffer_manager.GetMaxSwap();
-	if (max_swap.IsValid()) {
-		return Value(StringUtil::BytesToHumanReadableString(max_swap.GetIndex()));
-	} else {
-		// The temp directory has not been used yet
-		return Value("90% of available disk space");
-	}
-}
-
-//===----------------------------------------------------------------------===//
-// Ordered Aggregate Threshold
-//===----------------------------------------------------------------------===//
-bool OrderedAggregateThresholdSetting::OnLocalSet(ClientContext &context, const Value &input) {
-	const auto param = input.GetValue<uint64_t>();
-	if (param <= 0) {
-		throw ParserException("Invalid option for PRAGMA ordered_aggregate_threshold, value must be positive");
-	}
-	return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Password
-//===----------------------------------------------------------------------===//
-void PasswordSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	// nop
-}
-
-void PasswordSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	// nop
-}
-
-Value PasswordSetting::GetSetting(const ClientContext &context) {
-	return Value();
-}
-
-//===----------------------------------------------------------------------===//
-// Perfect Ht Threshold
-//===----------------------------------------------------------------------===//
-void PerfectHtThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto bits = input.GetValue<int64_t>();
-	if (bits < 0 || bits > 32) {
-		throw ParserException("Perfect HT threshold out of range: should be within range 0 - 32");
-	}
-	ClientConfig::GetConfig(context).perfect_ht_threshold = NumericCast<idx_t>(bits);
-}
-
-Value PerfectHtThresholdSetting::GetSetting(const ClientContext &context) {
-	return Value::BIGINT(NumericCast<int64_t>(ClientConfig::GetConfig(context).perfect_ht_threshold));
-}
-
-//===----------------------------------------------------------------------===//
-// Profile Output
-//===----------------------------------------------------------------------===//
-void ProfileOutputSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	auto parameter = input.ToString();
-	config.profiler_save_location = parameter;
-}
-
-void ProfileOutputSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).profiler_save_location = ClientConfig().profiler_save_location;
-}
-
-Value ProfileOutputSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(config.profiler_save_location);
-}
-
-//===----------------------------------------------------------------------===//
-// Profiling Mode
-//===----------------------------------------------------------------------===//
-void ProfilingModeSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	auto &config = ClientConfig::GetConfig(context);
-	if (parameter == "standard") {
-		config.enable_profiler = true;
-		config.enable_detailed_profiling = false;
-	} else if (parameter == "detailed") {
-		config.enable_profiler = true;
-		config.enable_detailed_profiling = true;
-
-		// add optimizer settings to the profiler settings
-		auto optimizer_settings = MetricsUtils::GetOptimizerMetrics();
-		for (auto &setting : optimizer_settings) {
-			config.profiler_settings.insert(setting);
-		}
-
-		// add the phase timing settings to the profiler settings
-		auto phase_timing_settings = MetricsUtils::GetPhaseTimingMetrics();
-		for (auto &setting : phase_timing_settings) {
-			config.profiler_settings.insert(setting);
-		}
-	} else {
-		throw ParserException("Unrecognized profiling mode \"%s\", supported formats: [standard, detailed]", parameter);
-	}
-}
-
-void ProfilingModeSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).enable_profiler = ClientConfig().enable_profiler;
-	ClientConfig::GetConfig(context).enable_detailed_profiling = ClientConfig().enable_detailed_profiling;
-	ClientConfig::GetConfig(context).emit_profiler_output = ClientConfig().emit_profiler_output;
-	ClientConfig::GetConfig(context).profiler_settings = ClientConfig().profiler_settings;
-}
-
-Value ProfilingModeSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (!config.enable_profiler) {
-		return Value();
-	}
-	return Value(config.enable_detailed_profiling ? "detailed" : "standard");
-}
-
-//===----------------------------------------------------------------------===//
-// Progress Bar Time
-//===----------------------------------------------------------------------===//
-void ProgressBarTimeSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	ProgressBar::SystemOverrideCheck(config);
-	config.wait_time = input.GetValue<int32_t>();
-	config.enable_progress_bar = true;
-}
-
-void ProgressBarTimeSetting::ResetLocal(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	ProgressBar::SystemOverrideCheck(config);
-	config.wait_time = ClientConfig().wait_time;
-	config.enable_progress_bar = ClientConfig().enable_progress_bar;
-}
-
-Value ProgressBarTimeSetting::GetSetting(const ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).wait_time);
-}
-
-//===----------------------------------------------------------------------===//
-// Schema
-//===----------------------------------------------------------------------===//
-void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(CatalogSearchEntry::Parse(parameter), CatalogSetPathType::SET_SCHEMA);
-}
-
-void SchemaSetting::ResetLocal(ClientContext &context) {
-	// FIXME: catalog_search_path is controlled by both SchemaSetting and SearchPathSetting
-	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Reset();
-}
-
-Value SchemaSetting::GetSetting(const ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return client_data.catalog_search_path->GetDefault().schema;
-}
-
-//===----------------------------------------------------------------------===//
-// Search Path
-//===----------------------------------------------------------------------===//
-void SearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(CatalogSearchEntry::ParseList(parameter), CatalogSetPathType::SET_SCHEMAS);
-}
-
-void SearchPathSetting::ResetLocal(ClientContext &context) {
-	// FIXME: catalog_search_path is controlled by both SchemaSetting and SearchPathSetting
-	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Reset();
-}
-
-Value SearchPathSetting::GetSetting(const ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	auto &set_paths = client_data.catalog_search_path->GetSetPaths();
-	return Value(CatalogSearchEntry::ListToString(set_paths));
-}
-
-//===----------------------------------------------------------------------===//
-// Secret Directory
-//===----------------------------------------------------------------------===//
-void SecretDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.secret_manager->SetPersistentSecretPath(input.ToString());
-}
-
-void SecretDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.secret_manager->ResetPersistentSecretPath();
-}
-
-Value SecretDirectorySetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return config.secret_manager->PersistentSecretPath();
-}
-
-//===----------------------------------------------------------------------===//
-// Storage Compatibility Version
-//===----------------------------------------------------------------------===//
-void StorageCompatibilityVersionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto version_string = input.GetValue<string>();
-	auto serialization_compatibility = SerializationCompatibility::FromString(version_string);
-	config.options.serialization_compatibility = serialization_compatibility;
-}
-
-void StorageCompatibilityVersionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.serialization_compatibility = DBConfig().options.serialization_compatibility;
-}
-
-Value StorageCompatibilityVersionSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-
-	auto &version_name = config.options.serialization_compatibility.duckdb_version;
-	return Value(version_name);
-}
-
-//===----------------------------------------------------------------------===//
-// Streaming Buffer Size
-//===----------------------------------------------------------------------===//
-void StreamingBufferSizeSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.streaming_buffer_size = DBConfig::ParseMemoryLimit(input.ToString());
-}
-
-void StreamingBufferSizeSetting::ResetLocal(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.SetDefaultStreamingBufferSize();
-}
-
-Value StreamingBufferSizeSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.streaming_buffer_size));
-}
-
-//===----------------------------------------------------------------------===//
-// Temp Directory
-//===----------------------------------------------------------------------===//
-void TempDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!config.options.enable_external_access) {
-		throw PermissionException("Modifying the temp_directory has been disabled by configuration");
-	}
-	config.options.temporary_directory = input.IsNull() ? "" : input.ToString();
-	config.options.use_temporary_directory = !config.options.temporary_directory.empty();
-	if (db) {
-		auto &buffer_manager = BufferManager::GetBufferManager(*db);
-		buffer_manager.SetTemporaryDirectory(config.options.temporary_directory);
-	}
-}
-
-void TempDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!config.options.enable_external_access) {
-		throw PermissionException("Modifying the temp_directory has been disabled by configuration");
-	}
-	config.SetDefaultTempDirectory();
-	config.options.use_temporary_directory = DBConfig().options.use_temporary_directory;
-	if (db) {
-		auto &buffer_manager = BufferManager::GetBufferManager(*db);
-		buffer_manager.SetTemporaryDirectory(config.options.temporary_directory);
-	}
-}
-
-Value TempDirectorySetting::GetSetting(const ClientContext &context) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	return Value(buffer_manager.GetTemporaryDirectory());
-}
-
-//===----------------------------------------------------------------------===//
-// Threads
-//===----------------------------------------------------------------------===//
-void ThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto new_val = input.GetValue<int64_t>();
-	if (new_val < 1) {
-		throw SyntaxException("Must have at least 1 thread!");
-	}
-	auto new_maximum_threads = NumericCast<idx_t>(new_val);
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, config.options.external_threads);
-	}
-	config.options.maximum_threads = new_maximum_threads;
-}
-
-void ThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	idx_t new_maximum_threads = config.GetSystemMaxThreads(*config.file_system);
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, config.options.external_threads);
-	}
-	config.options.maximum_threads = new_maximum_threads;
-}
-
-Value ThreadsSetting::GetSetting(const ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(NumericCast<int64_t>(config.options.maximum_threads));
-}
-
-//===----------------------------------------------------------------------===//
-// Username
-//===----------------------------------------------------------------------===//
-void UsernameSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	// nop
-}
-
-void UsernameSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	// nop
-}
-
-Value UsernameSetting::GetSetting(const ClientContext &context) {
-	return Value();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/stream_query_result.cpp b/src/duckdb/src/main/stream_query_result.cpp
deleted file mode 100644
index 9e4b06caa..000000000
--- a/src/duckdb/src/main/stream_query_result.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#include "duckdb/main/stream_query_result.hpp"
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/materialized_query_result.hpp"
-#include "duckdb/common/box_renderer.hpp"
-#include "duckdb/main/database.hpp"
-
-namespace duckdb {
-
-StreamQueryResult::StreamQueryResult(StatementType statement_type, StatementProperties properties,
-                                     vector<LogicalType> types, vector<string> names,
-                                     ClientProperties client_properties, shared_ptr<BufferedData> data)
-    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, std::move(properties), std::move(types),
-                  std::move(names), std::move(client_properties)),
-      buffered_data(std::move(data)) {
-	context = buffered_data->GetContext();
-}
-
-StreamQueryResult::StreamQueryResult(ErrorData error) : QueryResult(QueryResultType::STREAM_RESULT, std::move(error)) {
-}
-
-StreamQueryResult::~StreamQueryResult() {
-}
-
-string StreamQueryResult::ToString() {
-	string result;
-	if (success) {
-		result = HeaderToString();
-		result += "[[STREAM RESULT]]";
-	} else {
-		result = GetError() + "\n";
-	}
-	return result;
-}
-
-unique_ptr<ClientContextLock> StreamQueryResult::LockContext() {
-	if (!context) {
-		string error_str = "Attempting to execute an unsuccessful or closed pending query result";
-		if (HasError()) {
-			error_str += StringUtil::Format("\nError: %s", GetError());
-		}
-		throw InvalidInputException(error_str);
-	}
-	return context->LockContext();
-}
-
-StreamExecutionResult StreamQueryResult::ExecuteTaskInternal(ClientContextLock &lock) {
-	return buffered_data->ExecuteTaskInternal(*this, lock);
-}
-
-StreamExecutionResult StreamQueryResult::ExecuteTask() {
-	auto lock = LockContext();
-	return ExecuteTaskInternal(*lock);
-}
-
-void StreamQueryResult::WaitForTask() {
-	auto lock = LockContext();
-	buffered_data->UnblockSinks();
-	context->WaitForTask(*lock, *this);
-}
-
-static bool ExecutionErrorOccurred(StreamExecutionResult result) {
-	if (result == StreamExecutionResult::EXECUTION_CANCELLED) {
-		return true;
-	}
-	if (result == StreamExecutionResult::EXECUTION_ERROR) {
-		return true;
-	}
-	return false;
-}
-
-unique_ptr<DataChunk> StreamQueryResult::FetchInternal(ClientContextLock &lock) {
-	bool invalidate_query = true;
-	unique_ptr<DataChunk> chunk;
-	try {
-		// fetch the chunk and return it
-		auto stream_execution_result = buffered_data->ReplenishBuffer(*this, lock);
-		if (ExecutionErrorOccurred(stream_execution_result)) {
-			return chunk;
-		}
-		chunk = buffered_data->Scan();
-		if (!chunk || chunk->ColumnCount() == 0 || chunk->size() == 0) {
-			context->CleanupInternal(lock, this);
-			chunk = nullptr;
-		}
-		return chunk;
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		if (!Exception::InvalidatesTransaction(error.Type())) {
-			// standard exceptions do not invalidate the current transaction
-			invalidate_query = false;
-		} else if (Exception::InvalidatesDatabase(error.Type())) {
-			// fatal exceptions invalidate the entire database
-			auto &config = context->config;
-			if (!config.query_verification_enabled) {
-				auto &db_instance = DatabaseInstance::GetDatabase(*context);
-				ValidChecker::Invalidate(db_instance, error.RawMessage());
-			}
-		}
-		context->ProcessError(error, context->GetCurrentQuery());
-		SetError(std::move(error));
-	} catch (...) { // LCOV_EXCL_START
-		SetError(ErrorData("Unhandled exception in FetchInternal"));
-	} // LCOV_EXCL_STOP
-	context->CleanupInternal(lock, this, invalidate_query);
-	return nullptr;
-}
-
-unique_ptr<DataChunk> StreamQueryResult::FetchRaw() {
-	unique_ptr<DataChunk> chunk;
-	{
-		auto lock = LockContext();
-		CheckExecutableInternal(*lock);
-		chunk = FetchInternal(*lock);
-	}
-	if (!chunk || chunk->ColumnCount() == 0 || chunk->size() == 0) {
-		Close();
-		return nullptr;
-	}
-	return chunk;
-}
-
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-static unique_ptr<DataChunk> AlternativeFetch(StreamQueryResult &stream_result) {
-	// We first use StreamQueryResult::ExecuteTask until IsChunkReady becomes true
-	// then call Fetch
-	StreamExecutionResult execution_result;
-	while (!StreamQueryResult::IsChunkReady(execution_result = stream_result.ExecuteTask())) {
-		if (execution_result == StreamExecutionResult::BLOCKED) {
-			stream_result.WaitForTask();
-		}
-	}
-	if (execution_result == StreamExecutionResult::EXECUTION_CANCELLED) {
-		throw InvalidInputException("The execution of the query was cancelled before it could finish, likely "
-		                            "caused by executing a different query");
-	}
-	if (execution_result == StreamExecutionResult::EXECUTION_ERROR) {
-		stream_result.ThrowError();
-	}
-	return stream_result.Fetch();
-}
-#endif
-
-unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
-	if (HasError() || !context) {
-		return make_uniq<MaterializedQueryResult>(GetErrorObject());
-	}
-	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
-
-	ColumnDataAppendState append_state;
-	collection->InitializeAppend(append_state);
-	while (true) {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-		auto chunk = AlternativeFetch(*this);
-#else
-		auto chunk = Fetch();
-#endif
-		if (!chunk || chunk->size() == 0) {
-			break;
-		}
-		collection->Append(append_state, *chunk);
-	}
-	auto result =
-	    make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(collection), client_properties);
-	if (HasError()) {
-		return make_uniq<MaterializedQueryResult>(GetErrorObject());
-	}
-	return result;
-}
-
-bool StreamQueryResult::IsOpenInternal(ClientContextLock &lock) {
-	bool invalidated = !success || !context;
-	if (!invalidated) {
-		invalidated = !context->IsActiveResult(lock, *this);
-	}
-	return !invalidated;
-}
-
-void StreamQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
-	if (!IsOpenInternal(lock)) {
-		string error_str = "Attempting to execute an unsuccessful or closed pending query result";
-		if (HasError()) {
-			error_str += StringUtil::Format("\nError: %s", GetError());
-		}
-		throw InvalidInputException(error_str);
-	}
-}
-
-bool StreamQueryResult::IsOpen() {
-	if (!success || !context) {
-		return false;
-	}
-	auto lock = LockContext();
-	return IsOpenInternal(*lock);
-}
-
-void StreamQueryResult::Close() {
-	buffered_data->Close();
-	context.reset();
-}
-
-bool StreamQueryResult::IsChunkReady(StreamExecutionResult result) {
-	if (result == StreamExecutionResult::CHUNK_READY) {
-		// A chunk is ready to be fetched with Fetch()
-		return true;
-	}
-	if (result == StreamExecutionResult::EXECUTION_CANCELLED) {
-		// Another query execution was started that cancelled this one
-		return true;
-	}
-	if (result == StreamExecutionResult::EXECUTION_ERROR) {
-		// An error was encountered while executing the final pipeline
-		return true;
-	}
-	if (result == StreamExecutionResult::EXECUTION_FINISHED) {
-		// The final pipeline completed successfully
-		return true;
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/main/valid_checker.cpp b/src/duckdb/src/main/valid_checker.cpp
deleted file mode 100644
index a4373ef0e..000000000
--- a/src/duckdb/src/main/valid_checker.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/main/valid_checker.hpp"
-
-namespace duckdb {
-
-ValidChecker::ValidChecker() : is_invalidated(false) {
-}
-
-void ValidChecker::Invalidate(string error) {
-	lock_guard<mutex> l(invalidate_lock);
-	this->is_invalidated = true;
-	this->invalidated_msg = std::move(error);
-}
-
-bool ValidChecker::IsInvalidated() {
-	return this->is_invalidated;
-}
-
-string ValidChecker::InvalidatedMessage() {
-	lock_guard<mutex> l(invalidate_lock);
-	return invalidated_msg;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp b/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp
deleted file mode 100644
index 384760594..000000000
--- a/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp
+++ /dev/null
@@ -1,271 +0,0 @@
-#include "duckdb/optimizer/build_probe_side_optimizer.hpp"
-
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/type_visitor.hpp"
-#include "duckdb/common/types/row/tuple_data_layout.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-namespace duckdb {
-
-static void GetRowidBindings(LogicalOperator &op, vector<ColumnBinding> &bindings) {
-	if (op.type == LogicalOperatorType::LOGICAL_GET) {
-		auto &get = op.Cast<LogicalGet>();
-		auto get_bindings = get.GetColumnBindings();
-		auto &column_ids = get.GetColumnIds();
-		bool has_row_id = false;
-		for (auto &col_id : column_ids) {
-			if (col_id.IsRowIdColumn()) {
-				has_row_id = true;
-				break;
-			}
-		}
-		if (has_row_id) {
-			for (auto &binding : get_bindings) {
-				bindings.push_back(binding);
-			}
-		}
-	}
-	for (auto &child : op.children) {
-		GetRowidBindings(*child, bindings);
-	}
-}
-
-BuildProbeSideOptimizer::BuildProbeSideOptimizer(ClientContext &context, LogicalOperator &op) : context(context) {
-	vector<ColumnBinding> updating_columns, current_op_bindings;
-	auto bindings = op.GetColumnBindings();
-	vector<ColumnBinding> row_id_bindings;
-	// If any column bindings are a row_id, there is a good chance the statement is an insert/delete/update statement.
-	// As an initialization step, we travers the plan and find which bindings are row_id bindings.
-	// When we eventually do our build side probe side optimizations, if we get to a join where the left and right
-	// cardinalities are the same, we prefer to have the child with the rowid bindings in the probe side.
-	GetRowidBindings(op, preferred_on_probe_side);
-	op.ResolveOperatorTypes();
-}
-
-static void FlipChildren(LogicalOperator &op) {
-	std::swap(op.children[0], op.children[1]);
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		join.join_type = InverseJoinType(join.join_type);
-		for (auto &cond : join.conditions) {
-			std::swap(cond.left, cond.right);
-			cond.comparison = FlipComparisonExpression(cond.comparison);
-		}
-		std::swap(join.left_projection_map, join.right_projection_map);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &join = op.Cast<LogicalAnyJoin>();
-		join.join_type = InverseJoinType(join.join_type);
-		std::swap(join.left_projection_map, join.right_projection_map);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-		// don't need to do anything here
-		return;
-	}
-	default:
-		throw InternalException("Flipping children, but children were not flipped");
-	}
-}
-
-static inline idx_t ComputeOverlappingBindings(const vector<ColumnBinding> &haystack,
-                                               const vector<ColumnBinding> &needles) {
-	idx_t result = 0;
-	for (auto &needle : needles) {
-		if (std::find(haystack.begin(), haystack.end(), needle) != haystack.end()) {
-			result++;
-		}
-	}
-	return result;
-}
-
-BuildSize BuildProbeSideOptimizer::GetBuildSizes(const LogicalOperator &op, const idx_t lhs_cardinality,
-                                                 const idx_t rhs_cardinality) {
-	BuildSize ret;
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
-		ret.left_side = GetBuildSize(op.children[0]->types, lhs_cardinality);
-		ret.right_side = GetBuildSize(op.children[1]->types, rhs_cardinality);
-		return ret;
-	}
-	default:
-		break;
-	}
-	return ret;
-}
-
-double BuildProbeSideOptimizer::GetBuildSize(vector<LogicalType> types, const idx_t cardinality) {
-	// Row width in the hash table
-	types.push_back(LogicalType::HASH);
-	auto tuple_layout = TupleDataLayout();
-	tuple_layout.Initialize(types);
-	auto row_width = tuple_layout.GetRowWidth();
-
-	for (const auto &type : types) {
-		TypeVisitor::VisitReplace(type, [&](const LogicalType &visited_type) {
-			// Penalty for variable-size types (we don't have statistics here yet)
-			switch (visited_type.InternalType()) {
-			case PhysicalType::VARCHAR:
-				row_width += 8;
-				break;
-			case PhysicalType::LIST:
-			case PhysicalType::ARRAY:
-				row_width += 32;
-				break;
-			default:
-				break;
-			}
-
-			// Penalty for number of (recursive) columns
-			row_width += COLUMN_COUNT_PENALTY;
-
-			return visited_type;
-		});
-	}
-
-	// There is also a cost of NextPowerOfTwo(count * 2) * sizeof(data_ptr_t) per tuple in the hash table
-	// This is a not a smooth cost function, so instead we do the average, which is ~3 * sizeof(data_ptr_t)
-	row_width += 3 * sizeof(data_ptr_t);
-
-	return static_cast<double>(row_width * cardinality);
-}
-
-idx_t BuildProbeSideOptimizer::ChildHasJoins(LogicalOperator &op) {
-	if (op.children.empty()) {
-		return 0;
-	} else if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	           op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN ||
-	           op.type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-		return 1 + ChildHasJoins(*op.children[0]) + ChildHasJoins(*op.children[1]);
-	}
-	return ChildHasJoins(*op.children[0]);
-}
-
-void BuildProbeSideOptimizer::TryFlipJoinChildren(LogicalOperator &op) const {
-	auto &left_child = *op.children[0];
-	auto &right_child = *op.children[1];
-	const auto lhs_cardinality = left_child.has_estimated_cardinality ? left_child.estimated_cardinality
-	                                                                  : left_child.EstimateCardinality(context);
-	const auto rhs_cardinality = right_child.has_estimated_cardinality ? right_child.estimated_cardinality
-	                                                                   : right_child.EstimateCardinality(context);
-
-	auto build_sizes = GetBuildSizes(op, lhs_cardinality, rhs_cardinality);
-	auto &left_side_build_cost = build_sizes.left_side;
-	auto &right_side_build_cost = build_sizes.right_side;
-
-	bool swap = false;
-
-	idx_t left_child_joins = ChildHasJoins(*op.children[0]);
-	idx_t right_child_joins = ChildHasJoins(*op.children[1]);
-	// if the right child is a table scan, and the left child has joins, we should prefer the left child
-	// to be the build side. Since the tuples of the left side will already have been built on/be in flight,
-	// it will be faster to build on them again.
-	if (right_child_joins == 0 && left_child_joins > 0) {
-		right_side_build_cost *= (1 + PREFER_RIGHT_DEEP_PENALTY);
-	}
-
-	// RHS is build side.
-	// if right_side metric is larger than left_side metric, then right_side is more costly to build on
-	// than the lhs. So we swap
-	if (right_side_build_cost > left_side_build_cost) {
-		swap = true;
-	}
-
-	// swap for preferred on probe side
-	if (rhs_cardinality == lhs_cardinality && !preferred_on_probe_side.empty()) {
-		// inspect final bindings, we prefer them on the probe side
-		auto bindings_left = left_child.GetColumnBindings();
-		auto bindings_right = right_child.GetColumnBindings();
-		auto bindings_in_left = ComputeOverlappingBindings(bindings_left, preferred_on_probe_side);
-		auto bindings_in_right = ComputeOverlappingBindings(bindings_right, preferred_on_probe_side);
-		// (if the sides are planning to be swapped AND
-		// if more projected bindings are in the left (meaning right/build side after the swap)
-		// then swap them back. The projected bindings stay in the left/probe side.)
-		// OR
-		// (if the sides are planning not to be swapped AND
-		// if more projected bindings are in the right (meaning right/build)
-		// then swap them. The projected bindings are swapped to the left/probe side.)
-		if ((swap && bindings_in_left > bindings_in_right) || (!swap && bindings_in_right > bindings_in_left)) {
-			swap = !swap;
-		}
-	}
-
-	if (swap) {
-		FlipChildren(op);
-	}
-}
-
-void BuildProbeSideOptimizer::VisitOperator(LogicalOperator &op) {
-	// then the currentoperator
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		if (HasInverseJoinType(join.join_type)) {
-			FlipChildren(join);
-			join.delim_flipped = true;
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		switch (join.join_type) {
-		case JoinType::SEMI:
-		case JoinType::ANTI: {
-			// if the conditions have no equality, do not flip the children.
-			// There is no physical join operator (yet) that can do an inequality right_semi/anti join.
-			idx_t has_range = 0;
-			if (op.type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
-			    (op.Cast<LogicalComparisonJoin>().HasEquality(has_range) && !context.config.prefer_range_joins)) {
-				TryFlipJoinChildren(join);
-			}
-			break;
-		}
-		default:
-			if (HasInverseJoinType(join.join_type)) {
-				TryFlipJoinChildren(op);
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &join = op.Cast<LogicalJoin>();
-		// We do not yet support the RIGHT_SEMI or RIGHT_ANTI join types for these, so don't try to flip
-		switch (join.join_type) {
-		case JoinType::SEMI:
-		case JoinType::ANTI:
-			break; // RIGHT_SEMI/RIGHT_ANTI not supported yet for ANY/ASOF
-		default:
-			// We cannot flip projection maps are set (YET), but not flipping is worse than just clearing them
-			// They will be set in the 2nd round of ColumnLifetimeAnalyzer
-			join.left_projection_map.clear();
-			join.right_projection_map.clear();
-			TryFlipJoinChildren(op);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-		TryFlipJoinChildren(op);
-		break;
-	}
-	default:
-		break;
-	}
-
-	VisitOperatorChildren(op);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/column_binding_replacer.cpp b/src/duckdb/src/optimizer/column_binding_replacer.cpp
deleted file mode 100644
index f5652ad2a..000000000
--- a/src/duckdb/src/optimizer/column_binding_replacer.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-
-namespace duckdb {
-
-ReplacementBinding::ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding)
-    : old_binding(old_binding), new_binding(new_binding), replace_type(false) {
-}
-
-ReplacementBinding::ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding, LogicalType new_type)
-    : old_binding(old_binding), new_binding(new_binding), replace_type(true), new_type(std::move(new_type)) {
-}
-
-ColumnBindingReplacer::ColumnBindingReplacer() {
-}
-
-void ColumnBindingReplacer::VisitOperator(LogicalOperator &op) {
-	if (stop_operator && stop_operator.get() == &op) {
-		return;
-	}
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-}
-
-void ColumnBindingReplacer::VisitExpression(unique_ptr<Expression> *expression) {
-	auto &expr = *expression;
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-		auto &bound_column_ref = expr->Cast<BoundColumnRefExpression>();
-		for (const auto &replace_binding : replacement_bindings) {
-			if (bound_column_ref.binding == replace_binding.old_binding) {
-				bound_column_ref.binding = replace_binding.new_binding;
-				if (replace_binding.replace_type) {
-					bound_column_ref.return_type = replace_binding.new_type;
-				}
-			}
-		}
-	}
-
-	VisitExpressionChildren(**expression);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp b/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp
deleted file mode 100644
index efb3e684d..000000000
--- a/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-#include "duckdb/optimizer/column_lifetime_analyzer.hpp"
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/optimizer/topn_optimizer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-namespace duckdb {
-
-void ColumnLifetimeAnalyzer::ExtractUnusedColumnBindings(const vector<ColumnBinding> &bindings,
-                                                         column_binding_set_t &unused_bindings) {
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (column_references.find(bindings[i]) == column_references.end()) {
-			unused_bindings.insert(bindings[i]);
-		}
-	}
-}
-
-void ColumnLifetimeAnalyzer::GenerateProjectionMap(vector<ColumnBinding> bindings,
-                                                   column_binding_set_t &unused_bindings,
-                                                   vector<idx_t> &projection_map) {
-	projection_map.clear();
-	if (unused_bindings.empty()) {
-		return;
-	}
-	// now iterate over the result bindings of the child
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		// if this binding does not belong to the unused bindings, add it to the projection map
-		if (unused_bindings.find(bindings[i]) == unused_bindings.end()) {
-			projection_map.push_back(i);
-		}
-	}
-	if (projection_map.size() == bindings.size()) {
-		projection_map.clear();
-	}
-}
-
-void ColumnLifetimeAnalyzer::StandardVisitOperator(LogicalOperator &op) {
-	VisitOperatorExpressions(op);
-	VisitOperatorChildren(op);
-}
-
-void ExtractColumnBindings(Expression &expr, vector<ColumnBinding> &bindings) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_ref = expr.Cast<BoundColumnRefExpression>();
-		bindings.push_back(bound_ref.binding);
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractColumnBindings(child, bindings); });
-}
-
-void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
-	Verify(op);
-	if (TopN::CanOptimize(op) && op.children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) {
-		// Let's not mess with this, TopN is more important than projection maps
-		// TopN does not support a projection map like Order does
-		VisitOperatorExpressions(op);                        // Visit LIMIT
-		VisitOperatorExpressions(*op.children[0]);           // Visit ORDER
-		StandardVisitOperator(*op.children[0]->children[0]); // Recurse into child of ORDER
-		return;
-	}
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		// FIXME: groups that are not referenced can be removed from projection
-		// recurse into the children of the aggregate
-		ColumnLifetimeAnalyzer analyzer(optimizer, root);
-		analyzer.StandardVisitOperator(op);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &comp_join = op.Cast<LogicalComparisonJoin>();
-		if (everything_referenced) {
-			break;
-		}
-
-		// FIXME: for now, we only push into the projection map for equality (hash) joins
-		idx_t has_range = 0;
-		if (!comp_join.HasEquality(has_range) || optimizer.context.config.prefer_range_joins) {
-			return;
-		}
-
-		column_binding_set_t lhs_unused;
-		column_binding_set_t rhs_unused;
-		ExtractUnusedColumnBindings(op.children[0]->GetColumnBindings(), lhs_unused);
-		ExtractUnusedColumnBindings(op.children[1]->GetColumnBindings(), rhs_unused);
-
-		StandardVisitOperator(op);
-
-		// then generate the projection map
-		if (op.type != LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			// FIXME: left_projection_map in ASOF join
-			GenerateProjectionMap(op.children[0]->GetColumnBindings(), lhs_unused, comp_join.left_projection_map);
-		}
-		GenerateProjectionMap(op.children[1]->GetColumnBindings(), rhs_unused, comp_join.right_projection_map);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE: {
-		// for set operations/materialized CTEs we don't remove anything, just recursively visit the children
-		// FIXME: for UNION we can remove unreferenced columns as long as everything_referenced is false (i.e. we
-		// encounter a UNION node that is not preceded by a DISTINCT)
-		ColumnLifetimeAnalyzer analyzer(optimizer, root, true);
-		analyzer.StandardVisitOperator(op);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		// then recurse into the children of this projection
-		ColumnLifetimeAnalyzer analyzer(optimizer, root);
-		analyzer.StandardVisitOperator(op);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		auto &order = op.Cast<LogicalOrder>();
-		if (everything_referenced) {
-			break;
-		}
-
-		column_binding_set_t unused_bindings;
-		ExtractUnusedColumnBindings(op.children[0]->GetColumnBindings(), unused_bindings);
-
-		StandardVisitOperator(op);
-
-		GenerateProjectionMap(op.children[0]->GetColumnBindings(), unused_bindings, order.projection_map);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		// distinct, all projected columns are used for the DISTINCT computation
-		// mark all columns as used and continue to the children
-		// FIXME: DISTINCT with expression list does not implicitly reference everything
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = op.Cast<LogicalFilter>();
-		if (everything_referenced) {
-			break;
-		}
-
-		// filter, figure out which columns are not needed after the filter
-		column_binding_set_t unused_bindings;
-		ExtractUnusedColumnBindings(op.children[0]->GetColumnBindings(), unused_bindings);
-
-		StandardVisitOperator(op);
-
-		// then generate the projection map
-		GenerateProjectionMap(op.children[0]->GetColumnBindings(), unused_bindings, filter.projection_map);
-
-		return;
-	}
-	default:
-		break;
-	}
-	StandardVisitOperator(op);
-}
-
-void ColumnLifetimeAnalyzer::Verify(LogicalOperator &op) {
-#ifdef DEBUG
-	if (everything_referenced) {
-		return;
-	}
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		AddVerificationProjection(op.children[0]);
-		if (op.Cast<LogicalComparisonJoin>().join_type != JoinType::MARK) { // Can't mess up the mark_index
-			AddVerificationProjection(op.children[1]);
-		}
-		break;
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-	case LogicalOperatorType::LOGICAL_FILTER:
-		AddVerificationProjection(op.children[0]);
-		break;
-	default:
-		break;
-	}
-#endif
-}
-
-void ColumnLifetimeAnalyzer::AddVerificationProjection(unique_ptr<LogicalOperator> &child) {
-	child->ResolveOperatorTypes();
-	const auto child_types = child->types;
-	const auto child_bindings = child->GetColumnBindings();
-	const auto column_count = child_bindings.size();
-
-	// If our child has columns [i, j], we will generate a projection like so [NULL, j, NULL, i, NULL]
-	const auto projection_column_count = column_count * 2 + 1;
-	vector<unique_ptr<Expression>> expressions;
-	expressions.reserve(projection_column_count);
-
-	// First fill with all NULLs
-	for (idx_t col_idx = 0; col_idx < projection_column_count; col_idx++) {
-		expressions.emplace_back(make_uniq<BoundConstantExpression>(Value(LogicalType::UTINYINT)));
-	}
-
-	// Now place the "real" columns in their respective positions, while keeping track of which column becomes which
-	const auto table_index = optimizer.binder.GenerateTableIndex();
-	ColumnBindingReplacer replacer;
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-		const auto &old_binding = child_bindings[col_idx];
-		const auto new_col_idx = projection_column_count - 2 - col_idx * 2;
-		expressions[new_col_idx] = make_uniq<BoundColumnRefExpression>(child_types[col_idx], old_binding);
-		replacer.replacement_bindings.emplace_back(old_binding, ColumnBinding(table_index, new_col_idx));
-	}
-
-	// Create a projection and swap the operators accordingly
-	auto projection = make_uniq<LogicalProjection>(table_index, std::move(expressions));
-	projection->children.emplace_back(std::move(child));
-	child = std::move(projection);
-
-	// Replace references to the old binding (higher up in the plan) with references to the new binding
-	replacer.stop_operator = child.get();
-	replacer.VisitOperator(root);
-
-	// Add new bindings to column_references, else they are considered "unused"
-	for (const auto &replacement_binding : replacer.replacement_bindings) {
-		if (column_references.find(replacement_binding.old_binding) != column_references.end()) {
-			column_references.insert(replacement_binding.new_binding);
-		}
-	}
-}
-
-unique_ptr<Expression> ColumnLifetimeAnalyzer::VisitReplace(BoundColumnRefExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	column_references.insert(expr.binding);
-	return nullptr;
-}
-
-unique_ptr<Expression> ColumnLifetimeAnalyzer::VisitReplace(BoundReferenceExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	// BoundReferenceExpression should not be used here yet, they only belong in the physical plan
-	throw InternalException("BoundReferenceExpression should not be used here yet!");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp b/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp
deleted file mode 100644
index 991c12d83..000000000
--- a/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "duckdb/optimizer/common_aggregate_optimizer.hpp"
-
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-
-namespace duckdb {
-
-void CommonAggregateOptimizer::StandardVisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	if (!aggregate_map.empty()) {
-		VisitOperatorExpressions(op);
-	}
-}
-
-void CommonAggregateOptimizer::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		CommonAggregateOptimizer common_aggregate;
-		common_aggregate.StandardVisitOperator(op);
-		return;
-	}
-	default:
-		break;
-	}
-
-	StandardVisitOperator(op);
-	if (op.type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY) {
-		ExtractCommonAggregates(op.Cast<LogicalAggregate>());
-	}
-}
-
-unique_ptr<Expression> CommonAggregateOptimizer::VisitReplace(BoundColumnRefExpression &expr,
-                                                              unique_ptr<Expression> *expr_ptr) {
-	// check if this column ref points to an aggregate that was remapped; if it does we remap it
-	auto entry = aggregate_map.find(expr.binding);
-	if (entry != aggregate_map.end()) {
-		expr.binding = entry->second;
-	}
-	return nullptr;
-}
-
-void CommonAggregateOptimizer::ExtractCommonAggregates(LogicalAggregate &aggr) {
-	expression_map_t<idx_t> aggregate_remap;
-	idx_t total_erased = 0;
-	for (idx_t i = 0; i < aggr.expressions.size(); i++) {
-		idx_t original_index = i + total_erased;
-		auto entry = aggregate_remap.find(*aggr.expressions[i]);
-		if (entry == aggregate_remap.end()) {
-			// aggregate does not exist yet: add it to the map
-			aggregate_remap[*aggr.expressions[i]] = i;
-			if (i != original_index) {
-				// this aggregate is not erased, however an aggregate BEFORE it has been erased
-				// so we need to remap this aggregate
-				ColumnBinding original_binding(aggr.aggregate_index, original_index);
-				ColumnBinding new_binding(aggr.aggregate_index, i);
-				aggregate_map[original_binding] = new_binding;
-			}
-		} else {
-			// aggregate already exists! we can remove this entry
-			total_erased++;
-			aggr.expressions.erase_at(i);
-			i--;
-			// we need to remap any references to this aggregate so they point to the other aggregate
-			ColumnBinding original_binding(aggr.aggregate_index, original_index);
-			ColumnBinding new_binding(aggr.aggregate_index, entry->second);
-			aggregate_map[original_binding] = new_binding;
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/compressed_materialization.cpp b/src/duckdb/src/optimizer/compressed_materialization.cpp
deleted file mode 100644
index 5e6c30760..000000000
--- a/src/duckdb/src/optimizer/compressed_materialization.cpp
+++ /dev/null
@@ -1,485 +0,0 @@
-#include "duckdb/optimizer/compressed_materialization.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/compressed_materialization_utils.hpp"
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/optimizer/topn_optimizer.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-namespace duckdb {
-
-CMChildInfo::CMChildInfo(LogicalOperator &op, const column_binding_set_t &referenced_bindings)
-    : bindings_before(op.GetColumnBindings()), types(op.types), can_compress(bindings_before.size(), true) {
-	for (const auto &binding : referenced_bindings) {
-		for (idx_t binding_idx = 0; binding_idx < bindings_before.size(); binding_idx++) {
-			if (binding == bindings_before[binding_idx]) {
-				can_compress[binding_idx] = false;
-			}
-		}
-	}
-}
-
-CMBindingInfo::CMBindingInfo(ColumnBinding binding_p, const LogicalType &type_p)
-    : binding(binding_p), type(type_p), needs_decompression(false) {
-}
-
-CompressedMaterializationInfo::CompressedMaterializationInfo(LogicalOperator &op, vector<idx_t> &&child_idxs_p,
-                                                             const column_binding_set_t &referenced_bindings)
-    : child_idxs(std::move(child_idxs_p)) {
-	child_info.reserve(child_idxs.size());
-	for (const auto &child_idx : child_idxs) {
-		child_info.emplace_back(*op.children[child_idx], referenced_bindings);
-	}
-}
-
-CompressExpression::CompressExpression(unique_ptr<Expression> expression_p, unique_ptr<BaseStatistics> stats_p)
-    : expression(std::move(expression_p)), stats(std::move(stats_p)) {
-}
-
-CompressedMaterialization::CompressedMaterialization(Optimizer &optimizer_p, LogicalOperator &root_p,
-                                                     statistics_map_t &statistics_map_p)
-    : optimizer(optimizer_p), context(optimizer.context), root(&root_p), statistics_map(statistics_map_p) {
-}
-
-void CompressedMaterialization::GetReferencedBindings(const Expression &expression,
-                                                      column_binding_set_t &referenced_bindings) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		const auto &col_ref = expression.Cast<BoundColumnRefExpression>();
-		referenced_bindings.insert(col_ref.binding);
-	} else {
-		ExpressionIterator::EnumerateChildren(
-		    expression, [&](const Expression &child) { GetReferencedBindings(child, referenced_bindings); });
-	}
-}
-
-void CompressedMaterialization::UpdateBindingInfo(CompressedMaterializationInfo &info, const ColumnBinding &binding,
-                                                  bool needs_decompression) {
-	auto &binding_map = info.binding_map;
-	auto binding_it = binding_map.find(binding);
-	if (binding_it == binding_map.end()) {
-		return;
-	}
-
-	auto &binding_info = binding_it->second;
-	binding_info.needs_decompression = needs_decompression;
-	auto stats_it = statistics_map.find(binding);
-	if (stats_it != statistics_map.end()) {
-		binding_info.stats = statistics_map[binding]->ToUnique();
-	}
-}
-
-void CompressedMaterialization::Compress(unique_ptr<LogicalOperator> &op) {
-	if (TopN::CanOptimize(*op)) { // Let's not mess with the TopN optimizer
-		return;
-	}
-
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		break;
-	default:
-		return;
-	}
-
-	root->ResolveOperatorTypes();
-
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		CompressAggregate(op);
-		break;
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		CompressComparisonJoin(op);
-		break;
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		CompressDistinct(op);
-		break;
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		CompressOrder(op);
-		break;
-	default:
-		break;
-	}
-}
-
-void CompressedMaterialization::CreateProjections(unique_ptr<LogicalOperator> &op,
-                                                  CompressedMaterializationInfo &info) {
-	auto &materializing_op = *op;
-
-	bool compressed_anything = false;
-	for (idx_t i = 0; i < info.child_idxs.size(); i++) {
-		auto &child_info = info.child_info[i];
-		vector<unique_ptr<CompressExpression>> compress_exprs;
-		if (TryCompressChild(info, child_info, compress_exprs)) {
-			// We can compress: Create a projection on top of the child operator
-			const auto child_idx = info.child_idxs[i];
-			CreateCompressProjection(materializing_op.children[child_idx], std::move(compress_exprs), info, child_info);
-			compressed_anything = true;
-		}
-	}
-
-	if (compressed_anything) {
-		CreateDecompressProjection(op, info);
-	}
-}
-
-bool CompressedMaterialization::TryCompressChild(CompressedMaterializationInfo &info, const CMChildInfo &child_info,
-                                                 vector<unique_ptr<CompressExpression>> &compress_exprs) {
-	// Try to compress each of the column bindings of the child
-	bool compressed_anything = false;
-	for (idx_t child_i = 0; child_i < child_info.bindings_before.size(); child_i++) {
-		const auto child_binding = child_info.bindings_before[child_i];
-		const auto &child_type = child_info.types[child_i];
-		const auto &can_compress = child_info.can_compress[child_i];
-		auto compress_expr = GetCompressExpression(child_binding, child_type, can_compress);
-		bool compressed = false;
-		if (compress_expr) { // We compressed, mark the outgoing binding in need of decompression
-			compress_exprs.emplace_back(std::move(compress_expr));
-			compressed = true;
-		} else { // We did not compress, just push a colref
-			auto colref_expr = make_uniq<BoundColumnRefExpression>(child_type, child_binding);
-			auto it = statistics_map.find(colref_expr->binding);
-			unique_ptr<BaseStatistics> colref_stats = it != statistics_map.end() ? it->second->ToUnique() : nullptr;
-			compress_exprs.emplace_back(make_uniq<CompressExpression>(std::move(colref_expr), std::move(colref_stats)));
-		}
-		UpdateBindingInfo(info, child_binding, compressed);
-		compressed_anything = compressed_anything || compressed;
-	}
-	if (!compressed_anything) {
-		// If we compressed anything non-generically, we still need to decompress
-		for (const auto &entry : info.binding_map) {
-			compressed_anything = compressed_anything || entry.second.needs_decompression;
-		}
-	}
-	return compressed_anything;
-}
-
-void CompressedMaterialization::CreateCompressProjection(unique_ptr<LogicalOperator> &child_op,
-                                                         vector<unique_ptr<CompressExpression>> compress_exprs,
-                                                         CompressedMaterializationInfo &info, CMChildInfo &child_info) {
-	// Replace child op with a projection
-	vector<unique_ptr<Expression>> projections;
-	projections.reserve(compress_exprs.size());
-	for (auto &compress_expr : compress_exprs) {
-		projections.emplace_back(std::move(compress_expr->expression));
-	}
-	const auto table_index = optimizer.binder.GenerateTableIndex();
-	auto compress_projection = make_uniq<LogicalProjection>(table_index, std::move(projections));
-	if (child_op->has_estimated_cardinality) {
-		compress_projection->SetEstimatedCardinality(child_op->estimated_cardinality);
-	}
-	compress_projection->ResolveOperatorTypes();
-
-	compress_projection->children.emplace_back(std::move(child_op));
-	child_op = std::move(compress_projection);
-
-	// Get the new bindings and types
-	child_info.bindings_after = child_op->GetColumnBindings();
-	const auto &new_types = child_op->types;
-
-	// Initialize a ColumnBindingReplacer with the new bindings and types
-	ColumnBindingReplacer replacer;
-	auto &replacement_bindings = replacer.replacement_bindings;
-	for (idx_t col_idx = 0; col_idx < child_info.bindings_before.size(); col_idx++) {
-		const auto &old_binding = child_info.bindings_before[col_idx];
-		const auto &new_binding = child_info.bindings_after[col_idx];
-		const auto &new_type = new_types[col_idx];
-		replacement_bindings.emplace_back(old_binding, new_binding, new_type);
-
-		// Remove the old binding from the statistics map
-		statistics_map.erase(old_binding);
-	}
-
-	// Make sure we stop at the compress operator when replacing bindings
-	replacer.stop_operator = child_op.get();
-
-	// Make the plan consistent again
-	replacer.VisitOperator(*root);
-
-	// Replace in/out exprs in the binding map too
-	auto &binding_map = info.binding_map;
-	for (auto &replacement_binding : replacement_bindings) {
-		auto it = binding_map.find(replacement_binding.old_binding);
-		if (it == binding_map.end()) {
-			continue;
-		}
-		auto &binding_info = it->second;
-		if (binding_info.binding == replacement_binding.old_binding) {
-			binding_info.binding = replacement_binding.new_binding;
-		}
-
-		if (it->first == replacement_binding.old_binding) {
-			auto binding_info_local = std::move(binding_info);
-			binding_map.erase(it);
-			binding_map.emplace(replacement_binding.new_binding, std::move(binding_info_local));
-		}
-	}
-
-	// Add projection stats to statistics map
-	for (idx_t col_idx = 0; col_idx < child_info.bindings_after.size(); col_idx++) {
-		const auto &binding = child_info.bindings_after[col_idx];
-		auto &stats = compress_exprs[col_idx]->stats;
-		statistics_map.emplace(binding, std::move(stats));
-	}
-}
-
-void CompressedMaterialization::CreateDecompressProjection(unique_ptr<LogicalOperator> &op,
-                                                           CompressedMaterializationInfo &info) {
-	const auto bindings = op->GetColumnBindings();
-	op->ResolveOperatorTypes();
-	const auto &types = op->types;
-
-	// Create decompress expressions for everything we compressed
-	auto &binding_map = info.binding_map;
-	vector<unique_ptr<Expression>> decompress_exprs;
-	vector<optional_ptr<BaseStatistics>> statistics;
-	for (idx_t col_idx = 0; col_idx < bindings.size(); col_idx++) {
-		const auto &binding = bindings[col_idx];
-		auto decompress_expr = make_uniq_base<Expression, BoundColumnRefExpression>(types[col_idx], binding);
-		optional_ptr<BaseStatistics> stats;
-		for (auto &entry : binding_map) {
-			auto &binding_info = entry.second;
-			if (binding_info.binding != binding) {
-				continue;
-			}
-			stats = binding_info.stats.get();
-			if (binding_info.needs_decompression) {
-				decompress_expr = GetDecompressExpression(std::move(decompress_expr), binding_info.type, *stats);
-			}
-		}
-		statistics.push_back(stats);
-		decompress_exprs.emplace_back(std::move(decompress_expr));
-	}
-
-	// Replace op with a projection
-	const auto table_index = optimizer.binder.GenerateTableIndex();
-	auto decompress_projection = make_uniq<LogicalProjection>(table_index, std::move(decompress_exprs));
-	if (op->has_estimated_cardinality) {
-		decompress_projection->SetEstimatedCardinality(op->estimated_cardinality);
-	}
-
-	decompress_projection->children.emplace_back(std::move(op));
-	op = std::move(decompress_projection);
-
-	// Check if we're placing a projection on top of the root
-	if (RefersToSameObject(*op->children[0], *root)) {
-		root = op;
-		return;
-	}
-
-	// Get the new bindings and types
-	auto new_bindings = op->GetColumnBindings();
-	op->ResolveOperatorTypes();
-	auto &new_types = op->types;
-
-	// Initialize a ColumnBindingReplacer with the new bindings and types
-	ColumnBindingReplacer replacer;
-	auto &replacement_bindings = replacer.replacement_bindings;
-	for (idx_t col_idx = 0; col_idx < bindings.size(); col_idx++) {
-		const auto &old_binding = bindings[col_idx];
-		const auto &new_binding = new_bindings[col_idx];
-		const auto &new_type = new_types[col_idx];
-		replacement_bindings.emplace_back(old_binding, new_binding, new_type);
-
-		if (statistics[col_idx]) {
-			statistics_map[new_binding] = statistics[col_idx]->ToUnique();
-		}
-	}
-
-	// Make sure we skip the decompress operator when replacing bindings
-	replacer.stop_operator = op.get();
-
-	// Make the plan consistent again
-	replacer.VisitOperator(*root);
-}
-
-unique_ptr<CompressExpression> CompressedMaterialization::GetCompressExpression(const ColumnBinding &binding,
-                                                                                const LogicalType &type,
-                                                                                const bool &can_compress) {
-	auto it = statistics_map.find(binding);
-	if (can_compress && it != statistics_map.end() && it->second) {
-		auto input = make_uniq<BoundColumnRefExpression>(type, binding);
-		const auto &stats = *it->second;
-		return GetCompressExpression(std::move(input), stats);
-	}
-	return nullptr;
-}
-
-unique_ptr<CompressExpression> CompressedMaterialization::GetCompressExpression(unique_ptr<Expression> input,
-                                                                                const BaseStatistics &stats) {
-	const auto &type = input->return_type;
-	if (type != stats.GetType()) { // LCOV_EXCL_START
-		return nullptr;
-	} // LCOV_EXCL_STOP
-	if (type.IsIntegral()) {
-		return GetIntegralCompress(std::move(input), stats);
-	} else if (type.id() == LogicalTypeId::VARCHAR) {
-		return GetStringCompress(std::move(input), stats);
-	}
-	return nullptr;
-}
-
-static Value GetIntegralRangeValue(ClientContext &context, const LogicalType &type, const BaseStatistics &stats) {
-	auto min = NumericStats::Min(stats);
-	auto max = NumericStats::Max(stats);
-
-	vector<unique_ptr<Expression>> arguments;
-	arguments.emplace_back(make_uniq<BoundConstantExpression>(max));
-	arguments.emplace_back(make_uniq<BoundConstantExpression>(min));
-	BoundFunctionExpression sub(type, SubtractFunction::GetFunction(type, type), std::move(arguments), nullptr);
-
-	Value result;
-	if (ExpressionExecutor::TryEvaluateScalar(context, sub, result)) {
-		return result;
-	} else {
-		// Couldn't evaluate: Return max hugeint as range so GetIntegralCompress will return nullptr
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Maximum());
-	}
-}
-
-unique_ptr<CompressExpression> CompressedMaterialization::GetIntegralCompress(unique_ptr<Expression> input,
-                                                                              const BaseStatistics &stats) {
-	const auto &type = input->return_type;
-	if (GetTypeIdSize(type.InternalType()) == 1 || !NumericStats::HasMinMax(stats)) {
-		return nullptr;
-	}
-
-	// Get range and cast to UBIGINT (might fail for HUGEINT, in which case we just return)
-	Value range_value = GetIntegralRangeValue(context, type, stats);
-	if (!range_value.DefaultTryCastAs(LogicalType::UBIGINT)) {
-		return nullptr;
-	}
-
-	// Get the smallest type that the range can fit into
-	const auto range = UBigIntValue::Get(range_value);
-	LogicalType cast_type;
-	if (range <= NumericLimits<uint8_t>().Maximum()) {
-		cast_type = LogicalType::UTINYINT;
-	} else if (range <= NumericLimits<uint16_t>().Maximum()) {
-		cast_type = LogicalType::USMALLINT;
-	} else if (range <= NumericLimits<uint32_t>().Maximum()) {
-		cast_type = LogicalType::UINTEGER;
-	} else {
-		D_ASSERT(range <= NumericLimits<uint64_t>().Maximum());
-		cast_type = LogicalType::UBIGINT;
-	}
-
-	// Check if type that fits the range is smaller than the input type
-	if (GetTypeIdSize(cast_type.InternalType()) == GetTypeIdSize(type.InternalType())) {
-		return nullptr;
-	}
-	D_ASSERT(GetTypeIdSize(cast_type.InternalType()) < GetTypeIdSize(type.InternalType()));
-
-	// Compressing will yield a benefit
-	auto compress_function = CMIntegralCompressFun::GetFunction(type, cast_type);
-	vector<unique_ptr<Expression>> arguments;
-	arguments.emplace_back(std::move(input));
-	arguments.emplace_back(make_uniq<BoundConstantExpression>(NumericStats::Min(stats)));
-	auto compress_expr =
-	    make_uniq<BoundFunctionExpression>(cast_type, compress_function, std::move(arguments), nullptr);
-
-	auto compress_stats = BaseStatistics::CreateEmpty(cast_type);
-	compress_stats.CopyBase(stats);
-	NumericStats::SetMin(compress_stats, Value(0).DefaultCastAs(cast_type));
-	NumericStats::SetMax(compress_stats, range_value.DefaultCastAs(cast_type));
-
-	return make_uniq<CompressExpression>(std::move(compress_expr), compress_stats.ToUnique());
-}
-
-unique_ptr<CompressExpression> CompressedMaterialization::GetStringCompress(unique_ptr<Expression> input,
-                                                                            const BaseStatistics &stats) {
-	if (!StringStats::HasMaxStringLength(stats)) {
-		return nullptr;
-	}
-
-	const auto max_string_length = StringStats::MaxStringLength(stats);
-	LogicalType cast_type = LogicalType::INVALID;
-	for (const auto &compressed_type : CMUtils::StringTypes()) {
-		if (max_string_length < GetTypeIdSize(compressed_type.InternalType())) {
-			cast_type = compressed_type;
-			break;
-		}
-	}
-	if (cast_type == LogicalType::INVALID) {
-		return nullptr;
-	}
-
-	auto compress_stats = BaseStatistics::CreateEmpty(cast_type);
-	compress_stats.CopyBase(stats);
-	if (cast_type.id() == LogicalTypeId::USMALLINT) {
-		auto min_string = StringStats::Min(stats);
-		auto max_string = StringStats::Max(stats);
-
-		uint8_t min_numeric = 0;
-		if (max_string_length != 0 && !min_string.empty()) {
-			min_numeric = *reinterpret_cast<const uint8_t *>(min_string.c_str());
-		}
-		uint8_t max_numeric = 0;
-		if (max_string_length != 0 && !max_string.empty()) {
-			max_numeric = *reinterpret_cast<const uint8_t *>(max_string.c_str());
-		}
-
-		Value min_val = Value::USMALLINT(min_numeric);
-		Value max_val = Value::USMALLINT(max_numeric + 1);
-		if (max_numeric < NumericLimits<uint8_t>::Maximum()) {
-			cast_type = LogicalType::UTINYINT;
-			compress_stats = BaseStatistics::CreateEmpty(cast_type);
-			compress_stats.CopyBase(stats);
-			min_val = Value::UTINYINT(min_numeric);
-			max_val = Value::UTINYINT(max_numeric + 1);
-		}
-
-		NumericStats::SetMin(compress_stats, min_val);
-		NumericStats::SetMax(compress_stats, max_val);
-	}
-
-	auto compress_function = CMStringCompressFun::GetFunction(cast_type);
-	vector<unique_ptr<Expression>> arguments;
-	arguments.emplace_back(std::move(input));
-	auto compress_expr =
-	    make_uniq<BoundFunctionExpression>(cast_type, compress_function, std::move(arguments), nullptr);
-	return make_uniq<CompressExpression>(std::move(compress_expr), compress_stats.ToUnique());
-}
-
-unique_ptr<Expression> CompressedMaterialization::GetDecompressExpression(unique_ptr<Expression> input,
-                                                                          const LogicalType &result_type,
-                                                                          const BaseStatistics &stats) {
-	const auto &type = result_type;
-	if (TypeIsIntegral(type.InternalType())) {
-		return GetIntegralDecompress(std::move(input), result_type, stats);
-	} else if (type.id() == LogicalTypeId::VARCHAR) {
-		return GetStringDecompress(std::move(input), result_type, stats);
-	} else {
-		throw InternalException("Type other than integral/string marked for decompression!");
-	}
-}
-
-unique_ptr<Expression> CompressedMaterialization::GetIntegralDecompress(unique_ptr<Expression> input,
-                                                                        const LogicalType &result_type,
-                                                                        const BaseStatistics &stats) {
-	D_ASSERT(NumericStats::HasMinMax(stats));
-	auto decompress_function = CMIntegralDecompressFun::GetFunction(input->return_type, result_type);
-	vector<unique_ptr<Expression>> arguments;
-	arguments.emplace_back(std::move(input));
-	arguments.emplace_back(make_uniq<BoundConstantExpression>(NumericStats::Min(stats)));
-	return make_uniq<BoundFunctionExpression>(result_type, decompress_function, std::move(arguments), nullptr);
-}
-
-unique_ptr<Expression> CompressedMaterialization::GetStringDecompress(unique_ptr<Expression> input,
-                                                                      const LogicalType &result_type,
-                                                                      const BaseStatistics &stats) {
-	D_ASSERT(StringStats::HasMaxStringLength(stats));
-	auto decompress_function = CMStringDecompressFun::GetFunction(input->return_type);
-	vector<unique_ptr<Expression>> arguments;
-	arguments.emplace_back(std::move(input));
-	return make_uniq<BoundFunctionExpression>(result_type, decompress_function, std::move(arguments), nullptr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/compressed_materialization/compress_aggregate.cpp b/src/duckdb/src/optimizer/compressed_materialization/compress_aggregate.cpp
deleted file mode 100644
index ae4a7e8f1..000000000
--- a/src/duckdb/src/optimizer/compressed_materialization/compress_aggregate.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "duckdb/optimizer/compressed_materialization.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-
-namespace duckdb {
-
-void CompressedMaterialization::CompressAggregate(unique_ptr<LogicalOperator> &op) {
-	auto &aggregate = op->Cast<LogicalAggregate>();
-	if (aggregate.grouping_sets.size() > 1) {
-		return; // FIXME: we should be able to compress here but for some reason the NULL statistics ain't right
-	}
-	auto &groups = aggregate.groups;
-	column_binding_set_t group_binding_set;
-	for (const auto &group : groups) {
-		if (group->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			continue;
-		}
-		auto &colref = group->Cast<BoundColumnRefExpression>();
-		if (group_binding_set.find(colref.binding) != group_binding_set.end()) {
-			return; // Duplicate group - don't compress
-		}
-		group_binding_set.insert(colref.binding);
-	}
-	auto &group_stats = aggregate.group_stats;
-
-	// No need to compress if there are no groups/stats
-	if (groups.empty() || group_stats.empty()) {
-		return;
-	}
-	D_ASSERT(groups.size() == group_stats.size());
-
-	// Find all bindings referenced by non-colref expressions in the groups
-	// These are excluded from compression by projection
-	// But we can try to compress the expression directly
-	column_binding_set_t referenced_bindings;
-	vector<ColumnBinding> group_bindings(groups.size(), ColumnBinding());
-	vector<bool> needs_decompression(groups.size(), false);
-	vector<unique_ptr<BaseStatistics>> stored_group_stats;
-	stored_group_stats.resize(groups.size());
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		auto &group_expr = *groups[group_idx];
-		if (group_expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			auto &colref = group_expr.Cast<BoundColumnRefExpression>();
-			group_bindings[group_idx] = colref.binding;
-			continue; // Will be compressed generically
-		}
-
-		// Mark the bindings referenced by the non-colref expression so they won't be modified
-		GetReferencedBindings(group_expr, referenced_bindings);
-
-		// The non-colref expression won't be compressed generically, so try to compress it here
-		if (!group_stats[group_idx]) {
-			continue; // Can't compress without stats
-		}
-
-		// Try to compress, if successful, replace the expression
-		auto compress_expr = GetCompressExpression(group_expr.Copy(), *group_stats[group_idx]);
-		if (compress_expr) {
-			needs_decompression[group_idx] = true;
-			stored_group_stats[group_idx] = std::move(group_stats[group_idx]);
-			groups[group_idx] = std::move(compress_expr->expression);
-			group_stats[group_idx] = std::move(compress_expr->stats);
-		}
-	}
-
-	// Anything referenced in the aggregate functions is also excluded
-	for (idx_t expr_idx = 0; expr_idx < aggregate.expressions.size(); expr_idx++) {
-		const auto &expr = *aggregate.expressions[expr_idx];
-		D_ASSERT(expr.GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
-		const auto &aggr_expr = expr.Cast<BoundAggregateExpression>();
-		for (const auto &child : aggr_expr.children) {
-			GetReferencedBindings(*child, referenced_bindings);
-		}
-		if (aggr_expr.filter) {
-			GetReferencedBindings(*aggr_expr.filter, referenced_bindings);
-		}
-		if (aggr_expr.order_bys) {
-			for (const auto &order : aggr_expr.order_bys->orders) {
-				const auto &order_expr = *order.expression;
-				if (order_expr.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-					GetReferencedBindings(order_expr, referenced_bindings);
-				}
-			}
-		}
-	}
-
-	// Create info for compression
-	CompressedMaterializationInfo info(*op, {0}, referenced_bindings);
-
-	// Create binding mapping
-	const auto bindings_out = aggregate.GetColumnBindings();
-	const auto &types = aggregate.types;
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		// Aggregate changes bindings as it has a table idx
-		CMBindingInfo binding_info(bindings_out[group_idx], types[group_idx]);
-		binding_info.needs_decompression = needs_decompression[group_idx];
-		if (needs_decompression[group_idx]) {
-			// Compressed non-generically
-			auto entry = info.binding_map.emplace(bindings_out[group_idx], std::move(binding_info));
-			entry.first->second.stats = std::move(stored_group_stats[group_idx]);
-		} else if (group_bindings[group_idx] != ColumnBinding()) {
-			info.binding_map.emplace(group_bindings[group_idx], std::move(binding_info));
-		}
-	}
-
-	// Now try to compress
-	CreateProjections(op, info);
-
-	// Update aggregate statistics
-	UpdateAggregateStats(op);
-}
-
-void CompressedMaterialization::UpdateAggregateStats(unique_ptr<LogicalOperator> &op) {
-	if (op->type != LogicalOperatorType::LOGICAL_PROJECTION) {
-		return;
-	}
-
-	// Update aggregate group stats if compressed
-	auto &compressed_aggregate = op->children[0]->Cast<LogicalAggregate>();
-	auto &groups = compressed_aggregate.groups;
-	auto &group_stats = compressed_aggregate.group_stats;
-
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		auto &group_expr = *groups[group_idx];
-		if (group_expr.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			continue;
-		}
-		auto &colref = group_expr.Cast<BoundColumnRefExpression>();
-		if (!group_stats[group_idx]) {
-			continue;
-		}
-		if (colref.return_type == group_stats[group_idx]->GetType()) {
-			continue;
-		}
-		auto it = statistics_map.find(colref.binding);
-		if (it != statistics_map.end() && it->second) {
-			group_stats[group_idx] = it->second->ToUnique();
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/compressed_materialization/compress_comparison_join.cpp b/src/duckdb/src/optimizer/compressed_materialization/compress_comparison_join.cpp
deleted file mode 100644
index 5b150bea6..000000000
--- a/src/duckdb/src/optimizer/compressed_materialization/compress_comparison_join.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-#include "duckdb/optimizer/compressed_materialization.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-static void PopulateBindingMap(CompressedMaterializationInfo &info, const vector<ColumnBinding> &bindings_out,
-                               const vector<LogicalType> &types, LogicalOperator &op_in) {
-	const auto bindings_in = op_in.GetColumnBindings();
-	for (const auto &binding : bindings_in) {
-		// Joins do not change bindings, input binding is output binding
-		for (idx_t col_idx_out = 0; col_idx_out < bindings_out.size(); col_idx_out++) {
-			const auto &binding_out = bindings_out[col_idx_out];
-			if (binding_out == binding) {
-				// This one is projected out, add it to map
-				info.binding_map.emplace(binding, CMBindingInfo(binding_out, types[col_idx_out]));
-			}
-		}
-	}
-}
-
-void CompressedMaterialization::CompressComparisonJoin(unique_ptr<LogicalOperator> &op) {
-	auto &join = op->Cast<LogicalComparisonJoin>();
-	if (join.join_type == JoinType::MARK) {
-		// Tricky to get bindings right. RHS binding stays the same even though it changes type. Skip for now
-		return;
-	}
-
-	auto &left_child = *join.children[0];
-	auto &right_child = *join.children[1];
-
-#ifndef DEBUG
-	// In debug mode, we always apply compressed materialization to joins regardless of cardinalities,
-	// so that it is well-tested. In release mode, we require build cardinality > JOIN_BUILD_CARDINALITY_THRESHOLD,
-	// and we require join_cardinality / build_cardinality < JOIN_CARDINALITY_RATIO_THRESHOLD,
-	// so that we don't end up doing many more decompressions than compressions and hurting performance
-	const auto build_cardinality = right_child.has_estimated_cardinality ? right_child.estimated_cardinality
-	                                                                     : right_child.EstimateCardinality(context);
-	const auto join_cardinality =
-	    join.has_estimated_cardinality ? join.estimated_cardinality : join.EstimateCardinality(context);
-	const double ratio = static_cast<double>(join_cardinality) / static_cast<double>(build_cardinality);
-	if (build_cardinality < JOIN_BUILD_CARDINALITY_THRESHOLD || ratio > JOIN_CARDINALITY_RATIO_THRESHOLD) {
-		return;
-	}
-#endif
-
-	// Find all bindings referenced by non-colref expressions in the conditions
-	// These are excluded from compression by projection
-	// But we can try to compress the expression directly
-	column_binding_set_t probe_compress_bindings;
-	column_binding_set_t referenced_bindings;
-	for (const auto &condition : join.conditions) {
-		if (join.conditions.size() == 1 && join.type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			// We only try to compress the join condition cols if there's one join condition
-			// Else it gets messy with the stats if one column shows up in multiple conditions
-			if (condition.left->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
-			    condition.right->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-				// Both are bound column refs, see if both can be compressed generically to the same type
-				auto &lhs_colref = condition.left->Cast<BoundColumnRefExpression>();
-				auto &rhs_colref = condition.right->Cast<BoundColumnRefExpression>();
-				auto lhs_it = statistics_map.find(lhs_colref.binding);
-				auto rhs_it = statistics_map.find(rhs_colref.binding);
-				if (lhs_it != statistics_map.end() && rhs_it != statistics_map.end() && lhs_it->second &&
-				    rhs_it->second) {
-					// For joins we need to compress both using the same statistics, otherwise comparisons don't work
-					auto merged_stats = lhs_it->second->Copy();
-					merged_stats.Merge(*rhs_it->second);
-
-					// If one can be compressed, both can (same stats)
-					auto compress_expr = GetCompressExpression(condition.left->Copy(), merged_stats);
-					if (compress_expr) {
-						D_ASSERT(GetCompressExpression(condition.right->Copy(), merged_stats));
-						// This will be compressed generically, but we have to merge the stats
-						lhs_it->second->Merge(merged_stats);
-						rhs_it->second->Merge(merged_stats);
-						probe_compress_bindings.insert(lhs_colref.binding);
-						continue;
-					}
-				}
-			}
-		}
-		GetReferencedBindings(*condition.left, referenced_bindings);
-		GetReferencedBindings(*condition.right, referenced_bindings);
-	}
-
-	if (join.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		for (auto &dec : join.duplicate_eliminated_columns) {
-			GetReferencedBindings(*dec, referenced_bindings);
-		}
-	}
-
-	// We mark the probe-side bindings that do not show up in the join condition as "referenced"
-	// We don't want to compress these because they are streamed
-	const auto probe_bindings = left_child.GetColumnBindings();
-	for (auto &binding : probe_bindings) {
-		if (probe_compress_bindings.find(binding) == probe_compress_bindings.end()) {
-			referenced_bindings.insert(binding);
-		}
-	}
-
-	// Create info for compression
-	CompressedMaterializationInfo info(*op, {0, 1}, referenced_bindings);
-
-	const auto bindings_out = join.GetColumnBindings();
-	const auto &types = join.types;
-	PopulateBindingMap(info, bindings_out, types, left_child);
-	PopulateBindingMap(info, bindings_out, types, right_child);
-
-	// Now try to compress
-	CreateProjections(op, info);
-
-	// Update join statistics
-	UpdateComparisonJoinStats(op);
-}
-
-void CompressedMaterialization::UpdateComparisonJoinStats(unique_ptr<LogicalOperator> &op) {
-	if (op->type != LogicalOperatorType::LOGICAL_PROJECTION) {
-		return;
-	}
-
-	// Update join stats if compressed
-	auto &compressed_join = op->children[0]->Cast<LogicalComparisonJoin>();
-	if (compressed_join.join_stats.empty()) {
-		return; // Nothing to update
-	}
-
-	for (idx_t condition_idx = 0; condition_idx < compressed_join.conditions.size(); condition_idx++) {
-		auto &condition = compressed_join.conditions[condition_idx];
-		if (condition.left->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF ||
-		    condition.right->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			continue; // We definitely didn't compress these, nothing changed
-		}
-		if (condition_idx * 2 >= compressed_join.join_stats.size()) {
-			break;
-		}
-
-		auto &lhs_colref = condition.left->Cast<BoundColumnRefExpression>();
-		auto &rhs_colref = condition.right->Cast<BoundColumnRefExpression>();
-		auto &lhs_join_stats = compressed_join.join_stats[condition_idx * 2];
-		auto &rhs_join_stats = compressed_join.join_stats[condition_idx * 2 + 1];
-		auto lhs_it = statistics_map.find(lhs_colref.binding);
-		auto rhs_it = statistics_map.find(rhs_colref.binding);
-		if (lhs_it != statistics_map.end() && lhs_it->second) {
-			lhs_join_stats = lhs_it->second->ToUnique();
-		}
-		if (rhs_it != statistics_map.end() && rhs_it->second) {
-			rhs_join_stats = rhs_it->second->ToUnique();
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/compressed_materialization/compress_distinct.cpp b/src/duckdb/src/optimizer/compressed_materialization/compress_distinct.cpp
deleted file mode 100644
index e533bfaac..000000000
--- a/src/duckdb/src/optimizer/compressed_materialization/compress_distinct.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/optimizer/compressed_materialization.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-
-namespace duckdb {
-
-void CompressedMaterialization::CompressDistinct(unique_ptr<LogicalOperator> &op) {
-	auto &distinct = op->Cast<LogicalDistinct>();
-	auto &distinct_targets = distinct.distinct_targets;
-
-	column_binding_set_t referenced_bindings;
-	for (auto &target : distinct_targets) {
-		if (target->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) { // LCOV_EXCL_START
-			GetReferencedBindings(*target, referenced_bindings);
-		} // LCOV_EXCL_STOP
-	}
-
-	if (distinct.order_by) {
-		for (auto &order : distinct.order_by->orders) {
-			if (order.expression->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) { // LCOV_EXCL_START
-				GetReferencedBindings(*order.expression, referenced_bindings);
-			} // LCOV_EXCL_STOP
-		}
-	}
-
-	// Create info for compression
-	CompressedMaterializationInfo info(*op, {0}, referenced_bindings);
-
-	// Create binding mapping
-	const auto bindings = distinct.GetColumnBindings();
-	const auto &types = distinct.types;
-	D_ASSERT(bindings.size() == types.size());
-	for (idx_t col_idx = 0; col_idx < bindings.size(); col_idx++) {
-		// Distinct does not change bindings, input binding is output binding
-		info.binding_map.emplace(bindings[col_idx], CMBindingInfo(bindings[col_idx], types[col_idx]));
-	}
-
-	// Now try to compress
-	CreateProjections(op, info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/compressed_materialization/compress_order.cpp b/src/duckdb/src/optimizer/compressed_materialization/compress_order.cpp
deleted file mode 100644
index 2b098fda6..000000000
--- a/src/duckdb/src/optimizer/compressed_materialization/compress_order.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/optimizer/compressed_materialization.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-
-namespace duckdb {
-
-void CompressedMaterialization::CompressOrder(unique_ptr<LogicalOperator> &op) {
-	auto &order = op->Cast<LogicalOrder>();
-
-	// Find all bindings referenced by non-colref expressions in the order nodes
-	// These are excluded from compression by projection
-	// But we can try to compress the expression directly
-	column_binding_set_t referenced_bindings;
-	for (idx_t order_node_idx = 0; order_node_idx < order.orders.size(); order_node_idx++) {
-		auto &bound_order = order.orders[order_node_idx];
-		auto &order_expression = *bound_order.expression;
-		if (order_expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			continue; // Will be compressed generically
-		}
-
-		// Mark the bindings referenced by the non-colref expression so they won't be modified
-		GetReferencedBindings(order_expression, referenced_bindings);
-	}
-
-	// Create info for compression
-	CompressedMaterializationInfo info(*op, {0}, referenced_bindings);
-
-	// Create binding mapping
-	const auto bindings = order.GetColumnBindings();
-	const auto &types = order.types;
-	D_ASSERT(bindings.size() == types.size());
-	for (idx_t col_idx = 0; col_idx < bindings.size(); col_idx++) {
-		// Order does not change bindings, input binding is output binding
-		info.binding_map.emplace(bindings[col_idx], CMBindingInfo(bindings[col_idx], types[col_idx]));
-	}
-
-	// Now try to compress
-	CreateProjections(op, info);
-
-	// Update order statistics
-	UpdateOrderStats(op);
-}
-
-void CompressedMaterialization::UpdateOrderStats(unique_ptr<LogicalOperator> &op) {
-	if (op->type != LogicalOperatorType::LOGICAL_PROJECTION) {
-		return;
-	}
-
-	// Update order stats if compressed
-	auto &compressed_order = op->children[0]->Cast<LogicalOrder>();
-	for (idx_t order_node_idx = 0; order_node_idx < compressed_order.orders.size(); order_node_idx++) {
-		auto &bound_order = compressed_order.orders[order_node_idx];
-		auto &order_expression = *bound_order.expression;
-		if (order_expression.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			continue;
-		}
-		auto &colref = order_expression.Cast<BoundColumnRefExpression>();
-		auto it = statistics_map.find(colref.binding);
-		if (it != statistics_map.end() && it->second) {
-			bound_order.stats = it->second->ToUnique();
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/cse_optimizer.cpp b/src/duckdb/src/optimizer/cse_optimizer.cpp
deleted file mode 100644
index cde7aeb4c..000000000
--- a/src/duckdb/src/optimizer/cse_optimizer.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-#include "duckdb/optimizer/cse_optimizer.hpp"
-
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-//! The CSENode contains information about a common subexpression; how many times it occurs, and the column index in the
-//! underlying projection
-struct CSENode {
-	idx_t count;
-	optional_idx column_index;
-
-	CSENode() : count(1), column_index() {
-	}
-};
-
-//! The CSEReplacementState
-struct CSEReplacementState {
-	//! The projection index of the new projection
-	idx_t projection_index;
-	//! Map of expression -> CSENode
-	expression_map_t<CSENode> expression_count;
-	//! Map of column bindings to column indexes in the projection expression list
-	column_binding_map_t<idx_t> column_map;
-	//! The set of expressions of the resulting projection
-	vector<unique_ptr<Expression>> expressions;
-	//! Cached expressions that are kept around so the expression_map always contains valid expressions
-	vector<unique_ptr<Expression>> cached_expressions;
-};
-
-void CommonSubExpressionOptimizer::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		ExtractCommonSubExpresions(op);
-		break;
-	default:
-		break;
-	}
-	LogicalOperatorVisitor::VisitOperator(op);
-}
-
-void CommonSubExpressionOptimizer::CountExpressions(Expression &expr, CSEReplacementState &state) {
-	// we only consider expressions with children for CSE elimination
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_COLUMN_REF:
-	case ExpressionClass::BOUND_CONSTANT:
-	case ExpressionClass::BOUND_PARAMETER:
-	// skip conjunctions and case, since short-circuiting might be incorrectly disabled otherwise
-	case ExpressionClass::BOUND_CONJUNCTION:
-	case ExpressionClass::BOUND_CASE:
-		return;
-	default:
-		break;
-	}
-	if (expr.GetExpressionClass() != ExpressionClass::BOUND_AGGREGATE && !expr.IsVolatile()) {
-		// we can't move aggregates to a projection, so we only consider the children of the aggregate
-		auto node = state.expression_count.find(expr);
-		if (node == state.expression_count.end()) {
-			// first time we encounter this expression, insert this node with [count = 1]
-			state.expression_count[expr] = CSENode();
-		} else {
-			// we encountered this expression before, increment the occurrence count
-			node->second.count++;
-		}
-	}
-	// recursively count the children
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { CountExpressions(child, state); });
-}
-
-void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> &expr_ptr, CSEReplacementState &state) {
-	Expression &expr = *expr_ptr;
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-		auto &bound_column_ref = expr.Cast<BoundColumnRefExpression>();
-		// bound column ref, check if this one has already been recorded in the expression list
-		auto column_entry = state.column_map.find(bound_column_ref.binding);
-		if (column_entry == state.column_map.end()) {
-			// not there yet: push the expression
-			idx_t new_column_index = state.expressions.size();
-			state.column_map[bound_column_ref.binding] = new_column_index;
-			state.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    bound_column_ref.GetAlias(), bound_column_ref.return_type, bound_column_ref.binding));
-			bound_column_ref.binding = ColumnBinding(state.projection_index, new_column_index);
-		} else {
-			// else: just update the column binding!
-			bound_column_ref.binding = ColumnBinding(state.projection_index, column_entry->second);
-		}
-		return;
-	}
-	// check if this child is eligible for CSE elimination
-	bool can_cse = expr.GetExpressionClass() != ExpressionClass::BOUND_CONJUNCTION &&
-	               expr.GetExpressionClass() != ExpressionClass::BOUND_CASE;
-	if (can_cse && state.expression_count.find(expr) != state.expression_count.end()) {
-		auto &node = state.expression_count[expr];
-		if (node.count > 1) {
-			// this expression occurs more than once! push it into the projection
-			// check if it has already been pushed into the projection
-			auto alias = expr.GetAlias();
-			auto type = expr.return_type;
-			if (!node.column_index.IsValid()) {
-				// has not been pushed yet: push it
-				node.column_index = state.expressions.size();
-				state.expressions.push_back(std::move(expr_ptr));
-			} else {
-				state.cached_expressions.push_back(std::move(expr_ptr));
-			}
-			// replace the original expression with a bound column ref
-			expr_ptr = make_uniq<BoundColumnRefExpression>(
-			    alias, type, ColumnBinding(state.projection_index, node.column_index.GetIndex()));
-			return;
-		}
-	}
-	// this expression only occurs once, we can't perform CSE elimination
-	// look into the children to see if we can replace them
-	ExpressionIterator::EnumerateChildren(expr,
-	                                      [&](unique_ptr<Expression> &child) { PerformCSEReplacement(child, state); });
-}
-
-void CommonSubExpressionOptimizer::ExtractCommonSubExpresions(LogicalOperator &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	// first we count for each expression with children how many types it occurs
-	CSEReplacementState state;
-	LogicalOperatorVisitor::EnumerateExpressions(
-	    op, [&](unique_ptr<Expression> *child) { CountExpressions(**child, state); });
-	// check if there are any expressions to extract
-	bool perform_replacement = false;
-	for (auto &expr : state.expression_count) {
-		if (expr.second.count > 1) {
-			perform_replacement = true;
-			break;
-		}
-	}
-	if (!perform_replacement) {
-		// no CSEs to extract
-		return;
-	}
-	state.projection_index = binder.GenerateTableIndex();
-	// we found common subexpressions to extract
-	// now we iterate over all the expressions and perform the actual CSE elimination
-
-	LogicalOperatorVisitor::EnumerateExpressions(
-	    op, [&](unique_ptr<Expression> *child) { PerformCSEReplacement(*child, state); });
-	D_ASSERT(state.expressions.size() > 0);
-	// create a projection node as the child of this node
-	auto projection = make_uniq<LogicalProjection>(state.projection_index, std::move(state.expressions));
-	if (op.children[0]->has_estimated_cardinality) {
-		projection->SetEstimatedCardinality(op.children[0]->estimated_cardinality);
-	}
-	projection->children.push_back(std::move(op.children[0]));
-	op.children[0] = std::move(projection);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/cte_filter_pusher.cpp b/src/duckdb/src/optimizer/cte_filter_pusher.cpp
deleted file mode 100644
index b930cae00..000000000
--- a/src/duckdb/src/optimizer/cte_filter_pusher.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#include "duckdb/optimizer/cte_filter_pusher.hpp"
-
-#include "duckdb/optimizer/column_binding_replacer.hpp"
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/operator/logical_cteref.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_materialized_cte.hpp"
-
-namespace duckdb {
-
-CTEFilterPusher::MaterializedCTEInfo::MaterializedCTEInfo(LogicalOperator &materialized_cte_p)
-    : materialized_cte(materialized_cte_p), all_cte_refs_are_filtered(true) {
-}
-
-CTEFilterPusher::CTEFilterPusher(Optimizer &optimizer_p) : optimizer(optimizer_p) {
-}
-
-unique_ptr<LogicalOperator> CTEFilterPusher::Optimize(unique_ptr<LogicalOperator> op) {
-	FindCandidates(*op);
-	auto ctes = std::move(cte_info_map);
-
-	// Iterate once over all materialized CTEs
-	for (auto it = ctes.rbegin(); it != ctes.rend(); it++) {
-		if (!it->second->all_cte_refs_are_filtered) {
-			continue;
-		}
-
-		// The cte_info_map must be reconstructed each time.
-		// Changes to the plan otherwise break the non-unique_ptr references.
-		cte_info_map = InsertionOrderPreservingMap<unique_ptr<MaterializedCTEInfo>>();
-		FindCandidates(*op);
-
-		PushFilterIntoCTE(*cte_info_map[it->first]);
-	}
-	return op;
-}
-
-void CTEFilterPusher::FindCandidates(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
-		// We encountered a new CTE, add it to the map
-		auto key = to_string(op.Cast<LogicalMaterializedCTE>().table_index);
-		auto value = make_uniq<MaterializedCTEInfo>(op);
-
-		cte_info_map.insert(key, std::move(value));
-	} else if (op.type == LogicalOperatorType::LOGICAL_FILTER &&
-	           op.children[0]->type == LogicalOperatorType::LOGICAL_CTE_REF) {
-		// We encountered a filtered CTE ref, update the according CTE info
-		auto &cte_ref = op.children[0]->Cast<LogicalCTERef>();
-		auto it = cte_info_map.find(to_string(cte_ref.cte_index));
-		if (it != cte_info_map.end()) {
-			it->second->filters.push_back(op);
-		}
-		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_CTE_REF) {
-		// We encountered a CTE ref without a filter on top, so we can't do the optimization
-		auto &cte_ref = op.Cast<LogicalCTERef>();
-		auto it = cte_info_map.find(to_string(cte_ref.cte_index));
-		if (it != cte_info_map.end()) {
-			it->second->all_cte_refs_are_filtered = false;
-		}
-		return;
-	}
-	for (auto &child : op.children) {
-		FindCandidates(*child);
-	}
-}
-
-void CTEFilterPusher::PushFilterIntoCTE(MaterializedCTEInfo &info) {
-	D_ASSERT(info.materialized_cte.type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE);
-	if (info.filters.empty()) {
-		return;
-	}
-
-	// Create an OR expression with all the filters on all references of the CTE
-	unique_ptr<Expression> outer_expr;
-	for (auto &filter : info.filters) {
-		D_ASSERT(filter.get().type == LogicalOperatorType::LOGICAL_FILTER);
-
-		auto old_bindings = filter.get().children[0]->GetColumnBindings();
-		auto new_bindings = info.materialized_cte.children[0]->GetColumnBindings();
-		D_ASSERT(old_bindings.size() == new_bindings.size());
-
-		ColumnBindingReplacer replacer;
-		replacer.replacement_bindings.reserve(old_bindings.size());
-		for (idx_t i = 0; i < old_bindings.size(); i++) {
-			replacer.replacement_bindings.emplace_back(old_bindings[i], new_bindings[i]);
-		}
-
-		// We copy the filters and replace the CTE reference bindings with the bindings in the CTE definition
-		unique_ptr<Expression> inner_expr;
-		for (auto &filter_expr : filter.get().expressions) {
-			auto filter_expr_copy = filter_expr->Copy();
-			replacer.VisitExpression(&filter_expr_copy);
-			if (inner_expr) {
-				inner_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-				                                                   std::move(inner_expr), std::move(filter_expr_copy));
-			} else {
-				inner_expr = std::move(filter_expr_copy);
-			}
-		}
-
-		if (outer_expr) {
-			outer_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR, std::move(outer_expr),
-			                                                   std::move(inner_expr));
-		} else {
-			outer_expr = std::move(inner_expr);
-		}
-	}
-
-	// Add the filter on top of the CTE definition and push it down
-	auto new_cte = make_uniq_base<LogicalOperator, LogicalFilter>(std::move(outer_expr));
-	new_cte->children.push_back(std::move(info.materialized_cte.children[0]));
-	FilterPushdown pushdown(optimizer);
-	new_cte = pushdown.Rewrite(std::move(new_cte));
-	info.materialized_cte.children[0] = std::move(new_cte);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/deliminator.cpp b/src/duckdb/src/optimizer/deliminator.cpp
deleted file mode 100644
index 254a57026..000000000
--- a/src/duckdb/src/optimizer/deliminator.cpp
+++ /dev/null
@@ -1,413 +0,0 @@
-#include "duckdb/optimizer/deliminator.hpp"
-
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/table_filter.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct JoinWithDelimGet {
-	JoinWithDelimGet(unique_ptr<LogicalOperator> &join_p, idx_t depth_p) : join(join_p), depth(depth_p) {
-	}
-	reference<unique_ptr<LogicalOperator>> join;
-	idx_t depth;
-};
-
-struct DelimCandidate {
-public:
-	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalComparisonJoin &delim_join)
-	    : op(op), delim_join(delim_join), delim_get_count(0) {
-	}
-
-public:
-	unique_ptr<LogicalOperator> &op;
-	LogicalComparisonJoin &delim_join;
-	vector<JoinWithDelimGet> joins;
-	idx_t delim_get_count;
-};
-
-static bool IsEqualityJoinCondition(const JoinCondition &cond) {
-	switch (cond.comparison) {
-	case ExpressionType::COMPARE_EQUAL:
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return true;
-	default:
-		return false;
-	}
-}
-
-unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op) {
-	root = op;
-
-	vector<DelimCandidate> candidates;
-	FindCandidates(op, candidates);
-
-	if (candidates.empty()) {
-		return op;
-	}
-
-	for (auto &candidate : candidates) {
-		auto &delim_join = candidate.delim_join;
-
-		// Sort these so the deepest are first
-		std::sort(candidate.joins.begin(), candidate.joins.end(),
-		          [](const JoinWithDelimGet &lhs, const JoinWithDelimGet &rhs) { return lhs.depth > rhs.depth; });
-
-		bool all_removed = true;
-		if (!candidate.joins.empty() && HasSelection(delim_join)) {
-			// Keep the deepest join with DelimGet in these cases,
-			// as the selection can greatly reduce the cost of the RHS child of the DelimJoin
-			candidate.joins.erase(candidate.joins.begin());
-			all_removed = false;
-		}
-
-		bool all_equality_conditions = true;
-		for (auto &join : candidate.joins) {
-			all_removed = RemoveJoinWithDelimGet(delim_join, candidate.delim_get_count, join.join.get(),
-			                                     all_equality_conditions) &&
-			              all_removed;
-		}
-
-		// Change type if there are no more duplicate-eliminated columns
-		if (candidate.joins.size() == candidate.delim_get_count && all_removed) {
-			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
-			delim_join.duplicate_eliminated_columns.clear();
-		}
-
-		// Only DelimJoins are ever created as SINGLE joins,
-		// and we can switch from SINGLE to LEFT if the RHS is de-duplicated by an aggr
-		if (delim_join.join_type == JoinType::SINGLE) {
-			TrySwitchSingleToLeft(delim_join);
-		}
-	}
-
-	return op;
-}
-
-void Deliminator::FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates) {
-	for (auto &child : op->children) {
-		FindCandidates(child, candidates);
-	}
-
-	if (op->type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return;
-	}
-
-	candidates.emplace_back(op, op->Cast<LogicalComparisonJoin>());
-	auto &candidate = candidates.back();
-
-	// DelimGets are in the RHS
-	FindJoinWithDelimGet(op->children[1], candidate);
-}
-
-bool Deliminator::HasSelection(const LogicalOperator &op) {
-	// TODO once we implement selectivity estimation using samples we need to use that here
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_GET: {
-		auto &get = op.Cast<LogicalGet>();
-		for (const auto &filter : get.table_filters.filters) {
-			if (filter.second->filter_type != TableFilterType::IS_NOT_NULL) {
-				return true;
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return true;
-	default:
-		break;
-	}
-
-	for (auto &child : op.children) {
-		if (HasSelection(*child)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-static bool OperatorIsDelimGet(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		return true;
-	}
-	if (op.type == LogicalOperatorType::LOGICAL_FILTER &&
-	    op.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		return true;
-	}
-	return false;
-}
-
-void Deliminator::FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate, idx_t depth) {
-	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		FindJoinWithDelimGet(op->children[0], candidate, depth + 1);
-	} else if (op->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidate.delim_get_count++;
-	} else {
-		for (auto &child : op->children) {
-			FindJoinWithDelimGet(child, candidate, depth + 1);
-		}
-	}
-
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN &&
-	    (OperatorIsDelimGet(*op->children[0]) || OperatorIsDelimGet(*op->children[1]))) {
-		candidate.joins.emplace_back(op, depth);
-	}
-}
-
-static bool ChildJoinTypeCanBeDeliminated(JoinType &join_type) {
-	switch (join_type) {
-	case JoinType::INNER:
-	case JoinType::SEMI:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool Deliminator::RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
-                                         unique_ptr<LogicalOperator> &join, bool &all_equality_conditions) {
-	auto &comparison_join = join->Cast<LogicalComparisonJoin>();
-	if (!ChildJoinTypeCanBeDeliminated(comparison_join.join_type)) {
-		return false;
-	}
-
-	// Get the index (left or right) of the DelimGet side of the join
-	const idx_t delim_idx = OperatorIsDelimGet(*join->children[0]) ? 0 : 1;
-
-	// Get the filter (if any)
-	optional_ptr<LogicalFilter> filter;
-	vector<unique_ptr<Expression>> filter_expressions;
-	if (join->children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
-		filter = &join->children[delim_idx]->Cast<LogicalFilter>();
-		for (auto &expr : filter->expressions) {
-			filter_expressions.emplace_back(expr->Copy());
-		}
-	}
-
-	auto &delim_get = (filter ? filter->children[0] : join->children[delim_idx])->Cast<LogicalDelimGet>();
-	if (comparison_join.conditions.size() != delim_get.chunk_types.size()) {
-		return false; // Joining with DelimGet adds new information
-	}
-
-	// Check if joining with the DelimGet is redundant, and collect relevant column information
-	ColumnBindingReplacer replacer;
-	auto &replacement_bindings = replacer.replacement_bindings;
-	for (auto &cond : comparison_join.conditions) {
-		all_equality_conditions = all_equality_conditions && IsEqualityJoinCondition(cond);
-		auto &delim_side = delim_idx == 0 ? *cond.left : *cond.right;
-		auto &other_side = delim_idx == 0 ? *cond.right : *cond.left;
-		if (delim_side.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF ||
-		    other_side.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			return false;
-		}
-		auto &delim_colref = delim_side.Cast<BoundColumnRefExpression>();
-		auto &other_colref = other_side.Cast<BoundColumnRefExpression>();
-		replacement_bindings.emplace_back(delim_colref.binding, other_colref.binding);
-
-		if (cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			auto is_not_null_expr =
-			    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-			is_not_null_expr->children.push_back(other_side.Copy());
-			filter_expressions.push_back(std::move(is_not_null_expr));
-		}
-	}
-
-	if (!all_equality_conditions &&
-	    !RemoveInequalityJoinWithDelimGet(delim_join, delim_get_count, join, replacement_bindings)) {
-		return false;
-	}
-
-	unique_ptr<LogicalOperator> replacement_op = std::move(comparison_join.children[1 - delim_idx]);
-	if (!filter_expressions.empty()) { // Create filter if necessary
-		auto new_filter = make_uniq<LogicalFilter>();
-		new_filter->expressions = std::move(filter_expressions);
-		new_filter->children.emplace_back(std::move(replacement_op));
-		replacement_op = std::move(new_filter);
-	}
-
-	join = std::move(replacement_op);
-
-	// TODO: Maybe go from delim join instead to save work
-	replacer.VisitOperator(*root);
-	return true;
-}
-
-static bool InequalityDelimJoinCanBeEliminated(JoinType &join_type) {
-	return join_type == JoinType::ANTI || join_type == JoinType::MARK || join_type == JoinType::SEMI ||
-	       join_type == JoinType::SINGLE;
-}
-
-bool FindAndReplaceBindings(vector<ColumnBinding> &traced_bindings, const vector<unique_ptr<Expression>> &expressions,
-                            const vector<ColumnBinding> &current_bindings) {
-	for (auto &binding : traced_bindings) {
-		idx_t current_idx;
-		for (current_idx = 0; current_idx < expressions.size(); current_idx++) {
-			if (binding == current_bindings[current_idx]) {
-				break;
-			}
-		}
-
-		if (current_idx == expressions.size() ||
-		    expressions[current_idx]->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			return false; // Didn't find / can't deal with non-colref
-		}
-
-		auto &colref = expressions[current_idx]->Cast<BoundColumnRefExpression>();
-		binding = colref.binding;
-	}
-	return true;
-}
-
-bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
-                                                   unique_ptr<LogicalOperator> &join,
-                                                   const vector<ReplacementBinding> &replacement_bindings) {
-	auto &comparison_join = join->Cast<LogicalComparisonJoin>();
-	auto &delim_conditions = delim_join.conditions;
-	const auto &join_conditions = comparison_join.conditions;
-	if (delim_get_count != 1 || !InequalityDelimJoinCanBeEliminated(delim_join.join_type) ||
-	    delim_conditions.size() != join_conditions.size()) {
-		return false;
-	}
-
-	// TODO: we cannot perform the optimization here because our pure inequality joins don't implement
-	//  JoinType::SINGLE yet, and JoinType::MARK is a special case
-	if (delim_join.join_type == JoinType::SINGLE || delim_join.join_type == JoinType::MARK) {
-		bool has_one_equality = false;
-		for (auto &cond : join_conditions) {
-			has_one_equality = has_one_equality || IsEqualityJoinCondition(cond);
-		}
-		if (!has_one_equality) {
-			return false;
-		}
-	}
-
-	// We only support colref's
-	vector<ColumnBinding> traced_bindings;
-	for (const auto &cond : delim_conditions) {
-		if (cond.right->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			return false;
-		}
-		auto &colref = cond.right->Cast<BoundColumnRefExpression>();
-		traced_bindings.emplace_back(colref.binding);
-	}
-
-	// Now we trace down the bindings to the join (for now, we only trace it through a few operators)
-	reference<LogicalOperator> current_op = *delim_join.children[1];
-	while (&current_op.get() != join.get()) {
-		if (current_op.get().children.size() != 1) {
-			return false;
-		}
-
-		switch (current_op.get().type) {
-		case LogicalOperatorType::LOGICAL_PROJECTION:
-			FindAndReplaceBindings(traced_bindings, current_op.get().expressions, current_op.get().GetColumnBindings());
-			break;
-		case LogicalOperatorType::LOGICAL_FILTER:
-			break; // Doesn't change bindings
-		default:
-			return false;
-		}
-		current_op = *current_op.get().children[0];
-	}
-
-	// Get the index (left or right) of the DelimGet side of the join
-	const idx_t delim_idx = OperatorIsDelimGet(*join->children[0]) ? 0 : 1;
-
-	bool found_all = true;
-	for (idx_t cond_idx = 0; cond_idx < delim_conditions.size(); cond_idx++) {
-		auto &delim_condition = delim_conditions[cond_idx];
-		const auto &traced_binding = traced_bindings[cond_idx];
-
-		bool found = false;
-		for (auto &join_condition : join_conditions) {
-			auto &delim_side = delim_idx == 0 ? *join_condition.left : *join_condition.right;
-			auto &colref = delim_side.Cast<BoundColumnRefExpression>();
-			if (colref.binding == traced_binding) {
-				auto join_comparison = join_condition.comparison;
-				if (delim_condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-				    delim_condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-					// We need to compare NULL values
-					if (join_comparison == ExpressionType::COMPARE_EQUAL) {
-						join_comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-					} else if (join_comparison == ExpressionType::COMPARE_NOTEQUAL) {
-						join_comparison = ExpressionType::COMPARE_DISTINCT_FROM;
-					} else if (join_comparison != ExpressionType::COMPARE_DISTINCT_FROM &&
-					           join_comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-						// The optimization does not work here
-						found = false;
-						break;
-					}
-				}
-				delim_condition.comparison = FlipComparisonExpression(join_comparison);
-				found = true;
-				break;
-			}
-		}
-		found_all = found_all && found;
-	}
-
-	return found_all;
-}
-
-void Deliminator::TrySwitchSingleToLeft(LogicalComparisonJoin &delim_join) {
-	D_ASSERT(delim_join.join_type == JoinType::SINGLE);
-
-	// Collect RHS bindings
-	vector<ColumnBinding> join_bindings;
-	for (const auto &cond : delim_join.conditions) {
-		if (!IsEqualityJoinCondition(cond)) {
-			return;
-		}
-		if (cond.right->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			return;
-		}
-		auto &colref = cond.right->Cast<BoundColumnRefExpression>();
-		join_bindings.emplace_back(colref.binding);
-	}
-
-	// Now try to find an aggr in the RHS such that the join_column_bindings is a superset of the groups
-	reference<LogicalOperator> current_op = *delim_join.children[1];
-	while (current_op.get().type != LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY) {
-		if (current_op.get().children.size() != 1) {
-			return;
-		}
-
-		switch (current_op.get().type) {
-		case LogicalOperatorType::LOGICAL_PROJECTION:
-			FindAndReplaceBindings(join_bindings, current_op.get().expressions, current_op.get().GetColumnBindings());
-			break;
-		case LogicalOperatorType::LOGICAL_FILTER:
-			break; // Doesn't change bindings
-		default:
-			return;
-		}
-		current_op = *current_op.get().children[0];
-	}
-
-	D_ASSERT(current_op.get().type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY);
-	const auto &aggr = current_op.get().Cast<LogicalAggregate>();
-	if (!aggr.grouping_functions.empty()) {
-		return;
-	}
-
-	for (idx_t group_idx = 0; group_idx < aggr.groups.size(); group_idx++) {
-		if (std::find(join_bindings.begin(), join_bindings.end(), ColumnBinding(aggr.group_index, group_idx)) ==
-		    join_bindings.end()) {
-			return;
-		}
-	}
-
-	delim_join.join_type = JoinType::LEFT;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/empty_result_pullup.cpp b/src/duckdb/src/optimizer/empty_result_pullup.cpp
deleted file mode 100644
index 12b809634..000000000
--- a/src/duckdb/src/optimizer/empty_result_pullup.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "duckdb/optimizer/empty_result_pullup.hpp"
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> EmptyResultPullup::PullUpEmptyJoinChildren(unique_ptr<LogicalOperator> op) {
-	JoinType join_type = JoinType::INVALID;
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_EXCEPT);
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		join_type = op->Cast<LogicalComparisonJoin>().join_type;
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		join_type = op->Cast<LogicalAnyJoin>().join_type;
-		break;
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		join_type = JoinType::ANTI;
-		break;
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		join_type = JoinType::SEMI;
-		break;
-	default:
-		break;
-	}
-
-	switch (join_type) {
-	case JoinType::SEMI:
-	case JoinType::INNER: {
-		for (auto &child : op->children) {
-			if (child->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-				op = make_uniq<LogicalEmptyResult>(std::move(op));
-				break;
-			}
-		}
-		break;
-	}
-	// TODO: For ANTI joins, if the right child is empty, you can replace the whole join with
-	//  the left child
-	case JoinType::ANTI:
-	case JoinType::MARK:
-	case JoinType::SINGLE:
-	case JoinType::LEFT: {
-		if (op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-			op = make_uniq<LogicalEmptyResult>(std::move(op));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-	return op;
-}
-
-unique_ptr<LogicalOperator> EmptyResultPullup::Optimize(unique_ptr<LogicalOperator> op) {
-	for (idx_t i = 0; i < op->children.size(); i++) {
-		op->children[i] = Optimize(std::move(op->children[i]));
-	}
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-	case LogicalOperatorType::LOGICAL_FILTER:
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_WINDOW:
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-	case LogicalOperatorType::LOGICAL_GET:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_PIVOT:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-		for (auto &child : op->children) {
-			if (child->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-				op = make_uniq<LogicalEmptyResult>(std::move(op));
-				break;
-			}
-		}
-		return op;
-	}
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		op = PullUpEmptyJoinChildren(std::move(op));
-		break;
-	}
-	default:
-		break;
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/expression_heuristics.cpp b/src/duckdb/src/optimizer/expression_heuristics.cpp
deleted file mode 100644
index e6103b6d3..000000000
--- a/src/duckdb/src/optimizer/expression_heuristics.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-#include "duckdb/optimizer/expression_heuristics.hpp"
-
-#include "duckdb/planner/expression/list.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> ExpressionHeuristics::Rewrite(unique_ptr<LogicalOperator> op) {
-	VisitOperator(*op);
-	return op;
-}
-
-void ExpressionHeuristics::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_FILTER) {
-		// reorder all filter expressions
-		if (op.expressions.size() > 1) {
-			ReorderExpressions(op.expressions);
-		}
-	}
-
-	// traverse recursively through the operator tree
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-}
-
-unique_ptr<Expression> ExpressionHeuristics::VisitReplace(BoundConjunctionExpression &expr,
-                                                          unique_ptr<Expression> *expr_ptr) {
-	ReorderExpressions(expr.children);
-	return nullptr;
-}
-
-void ExpressionHeuristics::ReorderExpressions(vector<unique_ptr<Expression>> &expressions) {
-
-	struct ExpressionCosts {
-		unique_ptr<Expression> expr;
-		idx_t cost;
-
-		bool operator==(const ExpressionCosts &p) const {
-			return cost == p.cost;
-		}
-		bool operator<(const ExpressionCosts &p) const {
-			return cost < p.cost;
-		}
-	};
-
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (expressions[i]->CanThrow()) {
-			// do not allow reordering if an expression can throw
-			return;
-		}
-	}
-
-	vector<ExpressionCosts> expression_costs;
-	expression_costs.reserve(expressions.size());
-	// iterate expressions, get cost for each one
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		idx_t cost = Cost(*expressions[i]);
-		expression_costs.push_back({std::move(expressions[i]), cost});
-	}
-
-	// sort by cost and put back in place
-	sort(expression_costs.begin(), expression_costs.end());
-	for (idx_t i = 0; i < expression_costs.size(); i++) {
-		expressions[i] = std::move(expression_costs[i].expr);
-	}
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundBetweenExpression &expr) {
-	return Cost(*expr.input) + Cost(*expr.lower) + Cost(*expr.upper) + 10;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundCaseExpression &expr) {
-	// CASE WHEN check THEN result_if_true ELSE result_if_false END
-	idx_t case_cost = 0;
-	for (auto &case_check : expr.case_checks) {
-		case_cost += Cost(*case_check.then_expr);
-		case_cost += Cost(*case_check.when_expr);
-	}
-	case_cost += Cost(*expr.else_expr);
-	return case_cost;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundCastExpression &expr) {
-	// OPERATOR_CAST
-	// determine cast cost by comparing cast_expr.source_type and cast_expr_target_type
-	idx_t cast_cost = 0;
-	if (expr.return_type != expr.source_type()) {
-		// if cast from or to varchar
-		// TODO: we might want to add more cases
-		if (expr.return_type.id() == LogicalTypeId::VARCHAR || expr.source_type().id() == LogicalTypeId::VARCHAR ||
-		    expr.return_type.id() == LogicalTypeId::BLOB || expr.source_type().id() == LogicalTypeId::BLOB) {
-			cast_cost = 200;
-		} else {
-			cast_cost = 5;
-		}
-	}
-	return Cost(*expr.child) + cast_cost;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundComparisonExpression &expr) {
-	// COMPARE_EQUAL, COMPARE_NOTEQUAL, COMPARE_GREATERTHAN, COMPARE_GREATERTHANOREQUALTO, COMPARE_LESSTHAN,
-	// COMPARE_LESSTHANOREQUALTO
-	return Cost(*expr.left) + 5 + Cost(*expr.right);
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundConjunctionExpression &expr) {
-	// CONJUNCTION_AND, CONJUNCTION_OR
-	idx_t cost = 5;
-	for (auto &child : expr.children) {
-		cost += Cost(*child);
-	}
-	return cost;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundFunctionExpression &expr) {
-	idx_t cost_children = 0;
-	for (auto &child : expr.children) {
-		cost_children += Cost(*child);
-	}
-
-	auto cost_function = function_costs.find(expr.function.name);
-	if (cost_function != function_costs.end()) {
-		return cost_children + cost_function->second;
-	} else {
-		return cost_children + 1000;
-	}
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundOperatorExpression &expr, ExpressionType expr_type) {
-	idx_t sum = 0;
-	for (auto &child : expr.children) {
-		sum += Cost(*child);
-	}
-
-	// OPERATOR_IS_NULL, OPERATOR_IS_NOT_NULL
-	if (expr_type == ExpressionType::OPERATOR_IS_NULL || expr_type == ExpressionType::OPERATOR_IS_NOT_NULL) {
-		return sum + 5;
-	} else if (expr_type == ExpressionType::COMPARE_IN || expr_type == ExpressionType::COMPARE_NOT_IN) {
-		// COMPARE_IN, COMPARE_NOT_IN
-		return sum + (expr.children.size() - 1) * 100;
-	} else if (expr_type == ExpressionType::OPERATOR_NOT) {
-		// OPERATOR_NOT
-		return sum + 10; // TODO: evaluate via measured runtimes
-	} else {
-		return sum + 1000;
-	}
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(PhysicalType return_type, idx_t multiplier) {
-	// TODO: ajust values according to benchmark results
-	switch (return_type) {
-	case PhysicalType::VARCHAR:
-		return 5 * multiplier;
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return 2 * multiplier;
-	default:
-		return 1 * multiplier;
-	}
-}
-
-idx_t ExpressionHeuristics::Cost(Expression &expr) {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_CASE: {
-		auto &case_expr = expr.Cast<BoundCaseExpression>();
-		return ExpressionCost(case_expr);
-	}
-	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between_expr = expr.Cast<BoundBetweenExpression>();
-		return ExpressionCost(between_expr);
-	}
-	case ExpressionClass::BOUND_CAST: {
-		auto &cast_expr = expr.Cast<BoundCastExpression>();
-		return ExpressionCost(cast_expr);
-	}
-	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comp_expr = expr.Cast<BoundComparisonExpression>();
-		return ExpressionCost(comp_expr);
-	}
-	case ExpressionClass::BOUND_CONJUNCTION: {
-		auto &conj_expr = expr.Cast<BoundConjunctionExpression>();
-		return ExpressionCost(conj_expr);
-	}
-	case ExpressionClass::BOUND_FUNCTION: {
-		auto &func_expr = expr.Cast<BoundFunctionExpression>();
-		return ExpressionCost(func_expr);
-	}
-	case ExpressionClass::BOUND_OPERATOR: {
-		auto &op_expr = expr.Cast<BoundOperatorExpression>();
-		return ExpressionCost(op_expr, expr.GetExpressionType());
-	}
-	case ExpressionClass::BOUND_COLUMN_REF: {
-		auto &col_expr = expr.Cast<BoundColumnRefExpression>();
-		return ExpressionCost(col_expr.return_type.InternalType(), 8);
-	}
-	case ExpressionClass::BOUND_CONSTANT: {
-		auto &const_expr = expr.Cast<BoundConstantExpression>();
-		return ExpressionCost(const_expr.return_type.InternalType(), 1);
-	}
-	case ExpressionClass::BOUND_PARAMETER: {
-		auto &const_expr = expr.Cast<BoundParameterExpression>();
-		return ExpressionCost(const_expr.return_type.InternalType(), 1);
-	}
-	case ExpressionClass::BOUND_REF: {
-		auto &col_expr = expr.Cast<BoundColumnRefExpression>();
-		return ExpressionCost(col_expr.return_type.InternalType(), 8);
-	}
-	default: {
-		break;
-	}
-	}
-
-	// return a very high value if nothing matches
-	return 1000;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/expression_rewriter.cpp b/src/duckdb/src/optimizer/expression_rewriter.cpp
deleted file mode 100644
index a8ab28358..000000000
--- a/src/duckdb/src/optimizer/expression_rewriter.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "duckdb/optimizer/expression_rewriter.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/function/scalar/generic_common.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const vector<reference<Rule>> &rules,
-                                                      unique_ptr<Expression> expr, bool &changes_made, bool is_root) {
-	for (auto &rule : rules) {
-		vector<reference<Expression>> bindings;
-		if (rule.get().root->Match(*expr, bindings)) {
-			// the rule matches! try to apply it
-			bool rule_made_change = false;
-			auto result = rule.get().Apply(op, bindings, rule_made_change, is_root);
-			if (result) {
-				changes_made = true;
-				// the base node changed: the rule applied changes
-				// rerun on the new node
-				return ExpressionRewriter::ApplyRules(op, rules, std::move(result), changes_made);
-			} else if (rule_made_change) {
-				changes_made = true;
-				// the base node didn't change, but changes were made, rerun
-				return expr;
-			}
-			// else nothing changed, continue to the next rule
-			continue;
-		}
-	}
-	// no changes could be made to this node
-	// recursively run on the children of this node
-	ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-		child = ExpressionRewriter::ApplyRules(op, rules, std::move(child), changes_made);
-	});
-	return expr;
-}
-
-unique_ptr<Expression> ExpressionRewriter::ConstantOrNull(unique_ptr<Expression> child, Value value) {
-	vector<unique_ptr<Expression>> children;
-	children.push_back(make_uniq<BoundConstantExpression>(value));
-	children.push_back(std::move(child));
-	return ConstantOrNull(std::move(children), std::move(value));
-}
-
-unique_ptr<Expression> ExpressionRewriter::ConstantOrNull(vector<unique_ptr<Expression>> children, Value value) {
-	auto type = value.type();
-	auto func = ConstantOrNullFun::GetFunction();
-	func.arguments[0] = type;
-	func.return_type = type;
-	children.insert(children.begin(), make_uniq<BoundConstantExpression>(value));
-	return make_uniq<BoundFunctionExpression>(type, func, std::move(children), ConstantOrNull::Bind(std::move(value)));
-}
-
-void ExpressionRewriter::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	this->op = &op;
-
-	to_apply_rules.clear();
-	for (auto &rule : rules) {
-		to_apply_rules.push_back(*rule);
-	}
-
-	VisitOperatorExpressions(op);
-
-	// if it is a LogicalFilter, we split up filter conjunctions again
-	if (op.type == LogicalOperatorType::LOGICAL_FILTER) {
-		auto &filter = op.Cast<LogicalFilter>();
-		filter.SplitPredicates();
-	}
-}
-
-void ExpressionRewriter::VisitExpression(unique_ptr<Expression> *expression) {
-	bool changes_made;
-	do {
-		changes_made = false;
-		*expression = ExpressionRewriter::ApplyRules(*op, to_apply_rules, std::move(*expression), changes_made, true);
-	} while (changes_made);
-}
-
-ClientContext &Rule::GetContext() const {
-	return rewriter.context;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/filter_combiner.cpp b/src/duckdb/src/optimizer/filter_combiner.cpp
deleted file mode 100644
index a72354d7d..000000000
--- a/src/duckdb/src/optimizer/filter_combiner.cpp
+++ /dev/null
@@ -1,1410 +0,0 @@
-#include "duckdb/optimizer/filter_combiner.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/in_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/planner/filter/struct_filter.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-namespace duckdb {
-
-using ExpressionValueInformation = FilterCombiner::ExpressionValueInformation;
-
-ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left, ExpressionValueInformation &right);
-
-FilterCombiner::FilterCombiner(ClientContext &context) : context(context) {
-}
-
-FilterCombiner::FilterCombiner(Optimizer &optimizer) : FilterCombiner(optimizer.context) {
-}
-
-Expression &FilterCombiner::GetNode(Expression &expr) {
-	auto entry = stored_expressions.find(expr);
-	if (entry != stored_expressions.end()) {
-		// expression already exists: return a reference to the stored expression
-		return *entry->second;
-	}
-	// expression does not exist yet: create a copy and store it
-	auto copy = expr.Copy();
-	auto &copy_ref = *copy;
-	D_ASSERT(stored_expressions.find(copy_ref) == stored_expressions.end());
-	stored_expressions[copy_ref] = std::move(copy);
-	return copy_ref;
-}
-
-idx_t FilterCombiner::GetEquivalenceSet(Expression &expr) {
-	D_ASSERT(stored_expressions.find(expr) != stored_expressions.end());
-	D_ASSERT(stored_expressions.find(expr)->second.get() == &expr);
-	auto entry = equivalence_set_map.find(expr);
-	if (entry == equivalence_set_map.end()) {
-		idx_t index = set_index++;
-		equivalence_set_map[expr] = index;
-		equivalence_map[index].push_back(expr);
-		constant_values.insert(make_pair(index, vector<ExpressionValueInformation>()));
-		return index;
-	} else {
-		return entry->second;
-	}
-}
-
-FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInformation> &info_list,
-                                                   ExpressionValueInformation info) {
-	if (info.constant.IsNull()) {
-		return FilterResult::UNSATISFIABLE;
-	}
-	for (idx_t i = 0; i < info_list.size(); i++) {
-		auto comparison = CompareValueInformation(info_list[i], info);
-		switch (comparison) {
-		case ValueComparisonResult::PRUNE_LEFT:
-			// prune the entry from the info list
-			info_list.erase_at(i);
-			i--;
-			break;
-		case ValueComparisonResult::PRUNE_RIGHT:
-			// prune the current info
-			return FilterResult::SUCCESS;
-		case ValueComparisonResult::UNSATISFIABLE_CONDITION:
-			// combination of filters is unsatisfiable: prune the entire branch
-			return FilterResult::UNSATISFIABLE;
-		default:
-			// prune nothing, move to the next condition
-			break;
-		}
-	}
-	// finally add the entry to the list
-	info_list.push_back(info);
-	return FilterResult::SUCCESS;
-}
-
-FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
-	//	LookUpConjunctions(expr.get());
-	// try to push the filter into the combiner
-	auto result = AddFilter(*expr);
-	if (result == FilterResult::UNSUPPORTED) {
-		// unsupported filter, push into remaining filters
-		remaining_filters.push_back(std::move(expr));
-		return FilterResult::SUCCESS;
-	}
-	return result;
-}
-
-void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Expression> filter)> &callback) {
-	// first loop over the remaining filters
-	for (auto &filter : remaining_filters) {
-		callback(std::move(filter));
-	}
-	remaining_filters.clear();
-	// now loop over the equivalence sets
-	for (auto &entry : equivalence_map) {
-		auto equivalence_set = entry.first;
-		auto &entries = entry.second;
-		auto &constant_list = constant_values.find(equivalence_set)->second;
-		// for each entry generate an equality expression comparing to each other
-		for (idx_t i = 0; i < entries.size(); i++) {
-			for (idx_t k = i + 1; k < entries.size(); k++) {
-				auto comparison = make_uniq<BoundComparisonExpression>(
-				    ExpressionType::COMPARE_EQUAL, entries[i].get().Copy(), entries[k].get().Copy());
-				callback(std::move(comparison));
-			}
-			// for each entry also create a comparison with each constant
-			auto lower_index = optional_idx::Invalid();
-			auto upper_index = optional_idx::Invalid();
-			bool lower_inclusive = false;
-			bool upper_inclusive = false;
-			for (idx_t k = 0; k < constant_list.size(); k++) {
-				auto &info = constant_list[k];
-				if (info.comparison_type == ExpressionType::COMPARE_GREATERTHAN ||
-				    info.comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
-					lower_index = k;
-					lower_inclusive = info.comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-				} else if (info.comparison_type == ExpressionType::COMPARE_LESSTHAN ||
-				           info.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO) {
-					upper_index = k;
-					upper_inclusive = info.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO;
-				} else {
-					auto constant = make_uniq<BoundConstantExpression>(info.constant);
-					auto comparison = make_uniq<BoundComparisonExpression>(
-					    info.comparison_type, entries[i].get().Copy(), std::move(constant));
-					callback(std::move(comparison));
-				}
-			}
-			if (lower_index.IsValid() && upper_index.IsValid()) {
-				// found both lower and upper index, create a BETWEEN expression
-				auto lower_constant =
-				    make_uniq<BoundConstantExpression>(constant_list[lower_index.GetIndex()].constant);
-				auto upper_constant =
-				    make_uniq<BoundConstantExpression>(constant_list[upper_index.GetIndex()].constant);
-				auto between =
-				    make_uniq<BoundBetweenExpression>(entries[i].get().Copy(), std::move(lower_constant),
-				                                      std::move(upper_constant), lower_inclusive, upper_inclusive);
-				callback(std::move(between));
-			} else if (lower_index.IsValid()) {
-				// only lower index found, create simple comparison expression
-				auto constant = make_uniq<BoundConstantExpression>(constant_list[lower_index.GetIndex()].constant);
-				auto comparison =
-				    make_uniq<BoundComparisonExpression>(constant_list[lower_index.GetIndex()].comparison_type,
-				                                         entries[i].get().Copy(), std::move(constant));
-				callback(std::move(comparison));
-			} else if (upper_index.IsValid()) {
-				// only upper index found, create simple comparison expression
-				auto constant = make_uniq<BoundConstantExpression>(constant_list[upper_index.GetIndex()].constant);
-				auto comparison =
-				    make_uniq<BoundComparisonExpression>(constant_list[upper_index.GetIndex()].comparison_type,
-				                                         entries[i].get().Copy(), std::move(constant));
-				callback(std::move(comparison));
-			}
-		}
-	}
-	stored_expressions.clear();
-	equivalence_set_map.clear();
-	constant_values.clear();
-	equivalence_map.clear();
-}
-
-bool FilterCombiner::HasFilters() {
-	bool has_filters = false;
-	GenerateFilters([&](unique_ptr<Expression> child) { has_filters = true; });
-	return has_filters;
-}
-
-// unordered_map<idx_t, std::pair<Value *, Value *>> MergeAnd(unordered_map<idx_t, std::pair<Value *, Value *>> &f_1,
-//                                                            unordered_map<idx_t, std::pair<Value *, Value *>> &f_2) {
-// 	unordered_map<idx_t, std::pair<Value *, Value *>> result;
-// 	for (auto &f : f_1) {
-// 		auto it = f_2.find(f.first);
-// 		if (it == f_2.end()) {
-// 			result[f.first] = f.second;
-// 		} else {
-// 			Value *min = nullptr, *max = nullptr;
-// 			if (it->second.first && f.second.first) {
-// 				if (*f.second.first > *it->second.first) {
-// 					min = f.second.first;
-// 				} else {
-// 					min = it->second.first;
-// 				}
-
-// 			} else if (it->second.first) {
-// 				min = it->second.first;
-// 			} else if (f.second.first) {
-// 				min = f.second.first;
-// 			} else {
-// 				min = nullptr;
-// 			}
-// 			if (it->second.second && f.second.second) {
-// 				if (*f.second.second < *it->second.second) {
-// 					max = f.second.second;
-// 				} else {
-// 					max = it->second.second;
-// 				}
-// 			} else if (it->second.second) {
-// 				max = it->second.second;
-// 			} else if (f.second.second) {
-// 				max = f.second.second;
-// 			} else {
-// 				max = nullptr;
-// 			}
-// 			result[f.first] = {min, max};
-// 			f_2.erase(f.first);
-// 		}
-// 	}
-// 	for (auto &f : f_2) {
-// 		result[f.first] = f.second;
-// 	}
-// 	return result;
-// }
-
-// unordered_map<idx_t, std::pair<Value *, Value *>> MergeOr(unordered_map<idx_t, std::pair<Value *, Value *>> &f_1,
-//                                                           unordered_map<idx_t, std::pair<Value *, Value *>> &f_2) {
-// 	unordered_map<idx_t, std::pair<Value *, Value *>> result;
-// 	for (auto &f : f_1) {
-// 		auto it = f_2.find(f.first);
-// 		if (it != f_2.end()) {
-// 			Value *min = nullptr, *max = nullptr;
-// 			if (it->second.first && f.second.first) {
-// 				if (*f.second.first < *it->second.first) {
-// 					min = f.second.first;
-// 				} else {
-// 					min = it->second.first;
-// 				}
-// 			}
-// 			if (it->second.second && f.second.second) {
-// 				if (*f.second.second > *it->second.second) {
-// 					max = f.second.second;
-// 				} else {
-// 					max = it->second.second;
-// 				}
-// 			}
-// 			result[f.first] = {min, max};
-// 			f_2.erase(f.first);
-// 		}
-// 	}
-// 	return result;
-// }
-
-// unordered_map<idx_t, std::pair<Value *, Value *>>
-// FilterCombiner::FindZonemapChecks(vector<idx_t> &column_ids, unordered_set<idx_t> &not_constants, Expression *filter)
-// { 	unordered_map<idx_t, std::pair<Value *, Value *>> checks; 	switch (filter->type) { 	case
-// ExpressionType::CONJUNCTION_OR: {
-// 		//! For a filter to
-// 		auto &or_exp = filter->Cast<BoundConjunctionExpression>();
-// 		checks = FindZonemapChecks(column_ids, not_constants, or_exp.children[0].get());
-// 		for (size_t i = 1; i < or_exp.children.size(); ++i) {
-// 			auto child_check = FindZonemapChecks(column_ids, not_constants, or_exp.children[i].get());
-// 			checks = MergeOr(checks, child_check);
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::CONJUNCTION_AND: {
-// 		auto &and_exp = filter->Cast<BoundConjunctionExpression>();
-// 		checks = FindZonemapChecks(column_ids, not_constants, and_exp.children[0].get());
-// 		for (size_t i = 1; i < and_exp.children.size(); ++i) {
-// 			auto child_check = FindZonemapChecks(column_ids, not_constants, and_exp.children[i].get());
-// 			checks = MergeAnd(checks, child_check);
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_IN: {
-// 		auto &comp_in_exp = filter->Cast<BoundOperatorExpression>();
-// 		if (comp_in_exp.children[0]->type == ExpressionType::BOUND_COLUMN_REF) {
-// 			Value *min = nullptr, *max = nullptr;
-// 			auto &column_ref = comp_in_exp.children[0]->Cast<BoundColumnRefExpression>();
-// 			for (size_t i {1}; i < comp_in_exp.children.size(); i++) {
-// 				if (comp_in_exp.children[i]->type != ExpressionType::VALUE_CONSTANT) {
-// 					//! This indicates the column has a comparison that is not with a constant
-// 					not_constants.insert(column_ids[column_ref.binding.column_index]);
-// 					break;
-// 				} else {
-// 					auto &const_value_expr = comp_in_exp.children[i]->Cast<BoundConstantExpression>();
-// 					if (const_value_expr.value.IsNull()) {
-// 						return checks;
-// 					}
-// 					if (!min && !max) {
-// 						min = &const_value_expr.value;
-// 						max = min;
-// 					} else {
-// 						if (*min > const_value_expr.value) {
-// 							min = &const_value_expr.value;
-// 						}
-// 						if (*max < const_value_expr.value) {
-// 							max = &const_value_expr.value;
-// 						}
-// 					}
-// 				}
-// 			}
-// 			checks[column_ids[column_ref.binding.column_index]] = {min, max};
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_EQUAL: {
-// 		auto &comp_exp = filter->Cast<BoundComparisonExpression>();
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = comp_exp.left->Cast<BoundColumnRefExpression>();
-// 			auto &constant_value_expr = comp_exp.right->Cast<BoundConstantExpression>();
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value,
-// 			                                                       &constant_value_expr.value};
-// 		}
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = comp_exp.right->Cast<BoundColumnRefExpression>();
-// 			auto &constant_value_expr = comp_exp.left->Cast<BoundConstantExpression>();
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value,
-// 			                                                       &constant_value_expr.value};
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_LESSTHAN:
-// 	case ExpressionType::COMPARE_LESSTHANOREQUALTO: {
-// 		auto &comp_exp = filter->Cast<BoundComparisonExpression>();
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = comp_exp.left->Cast<BoundColumnRefExpression>();
-// 			auto &constant_value_expr = comp_exp.right->Cast<BoundConstantExpression>();
-// 			checks[column_ids[column_ref.binding.column_index]] = {nullptr, &constant_value_expr.value};
-// 		}
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = comp_exp.right->Cast<BoundColumnRefExpression>();
-// 			auto &constant_value_expr = comp_exp.left->Cast<BoundConstantExpression>();
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value, nullptr};
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-// 	case ExpressionType::COMPARE_GREATERTHAN: {
-// 		auto &comp_exp = filter->Cast<BoundComparisonExpression>();
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = comp_exp.left->Cast<BoundColumnRefExpression>();
-// 			auto &constant_value_expr = comp_exp.right->Cast<BoundConstantExpression>();
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value, nullptr};
-// 		}
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = comp_exp.right->Cast<BoundColumnRefExpression>();
-// 			auto &constant_value_expr = comp_exp.left->Cast<BoundConstantExpression>();
-// 			checks[column_ids[column_ref.binding.column_index]] = {nullptr, &constant_value_expr.value};
-// 		}
-// 		return checks;
-// 	}
-// 	default:
-// 		return checks;
-// 	}
-// }
-
-// vector<TableFilter> FilterCombiner::GenerateZonemapChecks(vector<idx_t> &column_ids,
-//                                                           vector<TableFilter> &pushed_filters) {
-// 	vector<TableFilter> zonemap_checks;
-// 	unordered_set<idx_t> not_constants;
-// 	//! We go through the remaining filters and capture their min max
-// 	if (remaining_filters.empty()) {
-// 		return zonemap_checks;
-// 	}
-
-// 	auto checks = FindZonemapChecks(column_ids, not_constants, remaining_filters[0].get());
-// 	for (size_t i = 1; i < remaining_filters.size(); ++i) {
-// 		auto child_check = FindZonemapChecks(column_ids, not_constants, remaining_filters[i].get());
-// 		checks = MergeAnd(checks, child_check);
-// 	}
-// 	//! We construct the equivalent filters
-// 	for (auto not_constant : not_constants) {
-// 		checks.erase(not_constant);
-// 	}
-// 	for (const auto &pushed_filter : pushed_filters) {
-// 		checks.erase(column_ids[pushed_filter.column_index]);
-// 	}
-// 	for (const auto &check : checks) {
-// 		if (check.second.first) {
-// 			zonemap_checks.emplace_back(check.second.first->Copy(), ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-// 			                            check.first);
-// 		}
-// 		if (check.second.second) {
-// 			zonemap_checks.emplace_back(check.second.second->Copy(), ExpressionType::COMPARE_LESSTHANOREQUALTO,
-// 			                            check.first);
-// 		}
-// 	}
-// 	return zonemap_checks;
-// }
-
-// Try to extract a column index from a bound column ref expression, or a column ref recursively nested
-// inside of a struct_extract call. If the expression is not a column ref (or nested column ref), return false.
-static bool TryGetBoundColumnIndex(const vector<ColumnIndex> &column_ids, const Expression &expr, ColumnIndex &result) {
-	switch (expr.GetExpressionType()) {
-	case ExpressionType::BOUND_COLUMN_REF: {
-		auto &ref = expr.Cast<BoundColumnRefExpression>();
-		result = column_ids[ref.binding.column_index];
-		return true;
-	}
-	case ExpressionType::BOUND_FUNCTION: {
-		auto &func = expr.Cast<BoundFunctionExpression>();
-		if (func.function.name == "struct_extract" || func.function.name == "struct_extract_at") {
-			auto &child_expr = func.children[0];
-			return TryGetBoundColumnIndex(column_ids, *child_expr, result);
-		}
-		return false;
-	}
-	default:
-		return false;
-	}
-}
-
-// Try to push down a filter into a expression by recursively wrapping any nested expressions in StructFilters.
-// If the expression is not a struct_extract, return the inner_filter unchanged.
-static unique_ptr<TableFilter> PushDownFilterIntoExpr(const Expression &expr, unique_ptr<TableFilter> inner_filter) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_FUNCTION) {
-		auto &func = expr.Cast<BoundFunctionExpression>();
-		auto &child_expr = func.children[0];
-		auto child_value = func.children[1]->Cast<BoundConstantExpression>().value;
-		if (func.function.name == "struct_extract") {
-			string child_name = child_value.GetValue<string>();
-			auto child_index = StructType::GetChildIndexUnsafe(func.children[0]->return_type, child_name);
-			inner_filter = make_uniq<StructFilter>(child_index, child_name, std::move(inner_filter));
-			return PushDownFilterIntoExpr(*child_expr, std::move(inner_filter));
-		} else if (func.function.name == "struct_extract_at") {
-			inner_filter = make_uniq<StructFilter>(child_value.GetValue<idx_t>() - 1, "", std::move(inner_filter));
-			return PushDownFilterIntoExpr(*child_expr, std::move(inner_filter));
-		}
-	}
-	return inner_filter;
-}
-
-bool FilterCombiner::ContainsNull(vector<Value> &in_list) {
-	for (idx_t i = 0; i < in_list.size(); i++) {
-		if (in_list[i].IsNull()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool FilterCombiner::IsDenseRange(vector<Value> &in_list) {
-	if (in_list.empty()) {
-		return true;
-	}
-	if (!in_list[0].type().IsIntegral()) {
-		return false;
-	}
-	// sort the input list
-	sort(in_list.begin(), in_list.end());
-
-	// check if the gap between each value is exactly one
-	hugeint_t prev_value = in_list[0].GetValue<hugeint_t>();
-	for (idx_t i = 1; i < in_list.size(); i++) {
-		hugeint_t current_value = in_list[i].GetValue<hugeint_t>();
-		hugeint_t diff;
-		if (!TrySubtractOperator::Operation(current_value, prev_value, diff)) {
-			// if subtract would overflow then it's certainly not 1
-			return false;
-		}
-		if (diff != 1) {
-			// gap is not 1 - this is not a dense range
-			return false;
-		}
-		prev_value = current_value;
-	}
-	// dense range
-	return true;
-}
-
-TableFilterSet FilterCombiner::GenerateTableScanFilters(const vector<ColumnIndex> &column_ids) {
-	TableFilterSet table_filters;
-	//! First, we figure the filters that have constant expressions that we can push down to the table scan
-	for (auto &constant_value : constant_values) {
-		if (!constant_value.second.empty()) {
-			auto filter_exp = equivalence_map.end();
-			if ((constant_value.second[0].comparison_type == ExpressionType::COMPARE_EQUAL ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_GREATERTHAN ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_LESSTHAN ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_NOTEQUAL) &&
-			    (TypeIsNumeric(constant_value.second[0].constant.type().InternalType()) ||
-			     constant_value.second[0].constant.type().InternalType() == PhysicalType::VARCHAR ||
-			     constant_value.second[0].constant.type().InternalType() == PhysicalType::BOOL)) {
-				//! Here we check if these filters are column references
-				filter_exp = equivalence_map.find(constant_value.first);
-
-				if (filter_exp->second.size() != 1) {
-					continue;
-				}
-
-				auto &expr = filter_exp->second[0];
-				auto equiv_set = filter_exp->first;
-
-				// Try to get the column index, either from bound column ref, or a column ref nested inside of a
-				// struct_extract call
-				ColumnIndex column_index;
-				if (!TryGetBoundColumnIndex(column_ids, expr, column_index)) {
-					continue;
-				}
-
-				auto &constant_list = constant_values.find(equiv_set)->second;
-				for (auto &constant_cmp : constant_list) {
-					auto constant_filter =
-					    make_uniq<ConstantFilter>(constant_cmp.comparison_type, constant_cmp.constant);
-					table_filters.PushFilter(column_index, PushDownFilterIntoExpr(expr, std::move(constant_filter)));
-				}
-				equivalence_map.erase(filter_exp);
-			}
-		}
-	}
-	//! Here we look for LIKE or IN filters
-	for (idx_t rem_fil_idx = 0; rem_fil_idx < remaining_filters.size(); rem_fil_idx++) {
-		auto &remaining_filter = remaining_filters[rem_fil_idx];
-		if (remaining_filter->GetExpressionClass() == ExpressionClass::BOUND_FUNCTION) {
-			auto &func = remaining_filter->Cast<BoundFunctionExpression>();
-			if (func.function.name == "prefix" &&
-			    func.children[0]->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF &&
-			    func.children[1]->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-				//! This is a like function.
-				auto &column_ref = func.children[0]->Cast<BoundColumnRefExpression>();
-				auto &constant_value_expr = func.children[1]->Cast<BoundConstantExpression>();
-				auto like_string = StringValue::Get(constant_value_expr.value);
-				if (like_string.empty()) {
-					continue;
-				}
-				auto &column_index = column_ids[column_ref.binding.column_index];
-				//! Here the like must be transformed to a BOUND COMPARISON geq le
-				auto lower_bound =
-				    make_uniq<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(like_string));
-				like_string[like_string.size() - 1]++;
-				auto upper_bound = make_uniq<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(like_string));
-				table_filters.PushFilter(column_index, std::move(lower_bound));
-				table_filters.PushFilter(column_index, std::move(upper_bound));
-			}
-			if (func.function.name == "~~" &&
-			    func.children[0]->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF &&
-			    func.children[1]->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-				//! This is a like function.
-				auto &column_ref = func.children[0]->Cast<BoundColumnRefExpression>();
-				auto &constant_value_expr = func.children[1]->Cast<BoundConstantExpression>();
-				auto &column_index = column_ids[column_ref.binding.column_index];
-				// constant value expr can sometimes be null. if so, push is not null filter, which will
-				// make the filter unsatisfiable and return no results.
-				if (constant_value_expr.value.IsNull()) {
-					auto is_not_null = make_uniq<IsNotNullFilter>();
-					table_filters.PushFilter(column_index, std::move(is_not_null));
-					continue;
-				}
-				auto &like_string = StringValue::Get(constant_value_expr.value);
-				if (like_string[0] == '%' || like_string[0] == '_') {
-					//! We have no prefix so nothing to pushdown
-					break;
-				}
-				string prefix;
-				bool equality = true;
-				for (char const &c : like_string) {
-					if (c == '%' || c == '_') {
-						equality = false;
-						break;
-					}
-					prefix += c;
-				}
-				if (equality) {
-					//! Here the like can be transformed to an equality query
-					auto equal_filter = make_uniq<ConstantFilter>(ExpressionType::COMPARE_EQUAL, Value(prefix));
-					table_filters.PushFilter(column_index, std::move(equal_filter));
-				} else {
-					//! Here the like must be transformed to a BOUND COMPARISON geq le
-					auto lower_bound =
-					    make_uniq<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(prefix));
-					prefix[prefix.size() - 1]++;
-					auto upper_bound = make_uniq<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(prefix));
-					table_filters.PushFilter(column_index, std::move(lower_bound));
-					table_filters.PushFilter(column_index, std::move(upper_bound));
-				}
-			}
-		} else if (remaining_filter->GetExpressionType() == ExpressionType::COMPARE_IN) {
-			auto &func = remaining_filter->Cast<BoundOperatorExpression>();
-			D_ASSERT(func.children.size() > 1);
-			if (func.children[0]->GetExpressionClass() != ExpressionClass::BOUND_COLUMN_REF) {
-				continue;
-			}
-			auto &column_ref = func.children[0]->Cast<BoundColumnRefExpression>();
-			auto &column_index = column_ids[column_ref.binding.column_index];
-			if (column_index.IsRowIdColumn()) {
-				break;
-			}
-			//! check if all children are const expr
-			bool children_constant = true;
-			for (size_t i {1}; i < func.children.size(); i++) {
-				if (func.children[i]->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
-					children_constant = false;
-					break;
-				}
-				auto &const_value_expr = func.children[i]->Cast<BoundConstantExpression>();
-				if (const_value_expr.value.IsNull()) {
-					// cannot simplify NULL values
-					children_constant = false;
-					break;
-				}
-			}
-			if (!children_constant) {
-				continue;
-			}
-			auto &fst_const_value_expr = func.children[1]->Cast<BoundConstantExpression>();
-			auto &type = fst_const_value_expr.value.type();
-
-			if ((type.IsNumeric() || type.id() == LogicalTypeId::VARCHAR || type.id() == LogicalTypeId::BOOLEAN) &&
-			    func.children.size() == 2) {
-				auto bound_eq_comparison =
-				    make_uniq<ConstantFilter>(ExpressionType::COMPARE_EQUAL, fst_const_value_expr.value);
-				table_filters.PushFilter(column_index, std::move(bound_eq_comparison));
-				remaining_filters.erase_at(rem_fil_idx--); // decrement to stay on the same idx next iteration
-				continue;
-			}
-
-			//! Check if values are consecutive, if yes transform them to >= <= (only for integers)
-			// e.g. if we have x IN (1, 2, 3, 4, 5) we transform this into x >= 1 AND x <= 5
-			vector<Value> in_list;
-			for (idx_t i = 1; i < func.children.size(); i++) {
-				auto &const_value_expr = func.children[i]->Cast<BoundConstantExpression>();
-				D_ASSERT(!const_value_expr.value.IsNull());
-				in_list.push_back(const_value_expr.value);
-			}
-			if (type.IsIntegral() && IsDenseRange(in_list)) {
-				// dense range! turn this into x >= min AND x <= max
-				// IsDenseRange sorts in_list, so the front element is the min and the back element is the max
-				auto lower_bound =
-				    make_uniq<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, std::move(in_list.front()));
-				auto upper_bound =
-				    make_uniq<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO, std::move(in_list.back()));
-				table_filters.PushFilter(column_index, std::move(lower_bound));
-				table_filters.PushFilter(column_index, std::move(upper_bound));
-
-				remaining_filters.erase_at(rem_fil_idx--); // decrement to stay on the same idx next iteration
-			} else {
-				// if this is not a dense range we can push a zone-map filter
-				auto optional_filter = make_uniq<OptionalFilter>();
-				auto in_filter = make_uniq<InFilter>(std::move(in_list));
-				optional_filter->child_filter = std::move(in_filter);
-				table_filters.PushFilter(column_index, std::move(optional_filter));
-			}
-		}
-	}
-
-	for (idx_t rem_fil_idx = 0; rem_fil_idx < remaining_filters.size(); rem_fil_idx++) {
-		auto &remaining_filter = remaining_filters[rem_fil_idx];
-		if (remaining_filter->GetExpressionClass() == ExpressionClass::BOUND_CONJUNCTION) {
-			auto &conj = remaining_filter->Cast<BoundConjunctionExpression>();
-			if (conj.GetExpressionType() == ExpressionType::CONJUNCTION_OR) {
-				optional_idx column_id;
-				auto optional_filter = make_uniq<OptionalFilter>();
-				auto conj_filter = make_uniq<ConjunctionOrFilter>();
-				for (auto &child : conj.children) {
-					if (child->GetExpressionClass() != ExpressionClass::BOUND_COMPARISON) {
-						column_id.SetInvalid();
-						break;
-					}
-					optional_ptr<BoundColumnRefExpression> column_ref;
-					optional_ptr<BoundConstantExpression> const_val;
-					auto &comp = child->Cast<BoundComparisonExpression>();
-					bool invert = false;
-					if (comp.left->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF &&
-					    comp.right->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
-						column_ref = comp.left->Cast<BoundColumnRefExpression>();
-						const_val = comp.right->Cast<BoundConstantExpression>();
-					} else if (comp.left->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT &&
-					           comp.right->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-						column_ref = comp.right->Cast<BoundColumnRefExpression>();
-						const_val = comp.left->Cast<BoundConstantExpression>();
-						invert = true;
-					} else {
-						// child of OR filter is not simple so we do not push the or filter down at all
-						column_id.SetInvalid();
-						break;
-					}
-
-					if (!column_id.IsValid()) {
-						auto &col_id = column_ids[column_ref->binding.column_index];
-						if (col_id.IsRowIdColumn()) {
-							break;
-						}
-						column_id = col_id.GetPrimaryIndex();
-					} else if (column_id.GetIndex() != column_ids[column_ref->binding.column_index].GetPrimaryIndex()) {
-						column_id.SetInvalid();
-						break;
-					}
-
-					if (const_val->value.type().IsTemporal()) {
-						column_id.SetInvalid();
-						break;
-					}
-					auto comparison_type =
-					    invert ? FlipComparisonExpression(comp.GetExpressionType()) : comp.GetExpressionType();
-					if (const_val->value.IsNull()) {
-						switch (comparison_type) {
-						case ExpressionType::COMPARE_DISTINCT_FROM: {
-							auto null_filter = make_uniq<IsNotNullFilter>();
-							conj_filter->child_filters.push_back(std::move(null_filter));
-							break;
-						}
-						case ExpressionType::COMPARE_NOT_DISTINCT_FROM: {
-							auto null_filter = make_uniq<IsNullFilter>();
-							conj_filter->child_filters.push_back(std::move(null_filter));
-							break;
-						}
-						// if any other comparison type (i.e EQUAL, NOT_EQUAL) do not push a table filter
-						default:
-							break;
-						}
-					} else {
-						auto const_filter = make_uniq<ConstantFilter>(comparison_type, const_val->value);
-						conj_filter->child_filters.push_back(std::move(const_filter));
-					}
-				}
-				if (column_id.IsValid()) {
-					optional_filter->child_filter = std::move(conj_filter);
-					table_filters.PushFilter(ColumnIndex(column_id.GetIndex()), std::move(optional_filter));
-				}
-			}
-		}
-	}
-
-	return table_filters;
-}
-
-static bool IsGreaterThan(ExpressionType type) {
-	return type == ExpressionType::COMPARE_GREATERTHAN || type == ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-}
-
-static bool IsLessThan(ExpressionType type) {
-	return type == ExpressionType::COMPARE_LESSTHAN || type == ExpressionType::COMPARE_LESSTHANOREQUALTO;
-}
-
-FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
-	auto &comparison = expr.Cast<BoundComparisonExpression>();
-	if (comparison.GetExpressionType() != ExpressionType::COMPARE_LESSTHAN &&
-	    comparison.GetExpressionType() != ExpressionType::COMPARE_LESSTHANOREQUALTO &&
-	    comparison.GetExpressionType() != ExpressionType::COMPARE_GREATERTHAN &&
-	    comparison.GetExpressionType() != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
-	    comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL &&
-	    comparison.GetExpressionType() != ExpressionType::COMPARE_NOTEQUAL) {
-		// only support [>, >=, <, <=, ==, !=] expressions
-		return FilterResult::UNSUPPORTED;
-	}
-	// check if one of the sides is a scalar value
-	bool left_is_scalar = comparison.left->IsFoldable();
-	bool right_is_scalar = comparison.right->IsFoldable();
-	if (left_is_scalar || right_is_scalar) {
-		// comparison with scalar
-		auto &node = GetNode(left_is_scalar ? *comparison.right : *comparison.left);
-		idx_t equivalence_set = GetEquivalenceSet(node);
-		auto &scalar = left_is_scalar ? comparison.left : comparison.right;
-		Value constant_value;
-		if (!ExpressionExecutor::TryEvaluateScalar(context, *scalar, constant_value)) {
-			return FilterResult::UNSUPPORTED;
-		}
-		if (constant_value.IsNull()) {
-			// comparisons with null are always null (i.e. will never result in rows)
-			return FilterResult::UNSATISFIABLE;
-		}
-
-		// create the ExpressionValueInformation
-		ExpressionValueInformation info;
-		info.comparison_type =
-		    left_is_scalar ? FlipComparisonExpression(comparison.GetExpressionType()) : comparison.GetExpressionType();
-		info.constant = constant_value;
-
-		// get the current bucket of constant values
-		D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-		auto &info_list = constant_values.find(equivalence_set)->second;
-		if (node.return_type != info.constant.type()) {
-			return FilterResult::UNSUPPORTED;
-		}
-		// check the existing constant comparisons to see if we can do any pruning
-		auto ret = AddConstantComparison(info_list, info);
-
-		auto &non_scalar = left_is_scalar ? *comparison.right : *comparison.left;
-		auto transitive_filter = FindTransitiveFilter(non_scalar);
-		if (transitive_filter != nullptr) {
-			// try to add transitive filters
-			if (AddTransitiveFilters(transitive_filter->Cast<BoundComparisonExpression>()) ==
-			    FilterResult::UNSUPPORTED) {
-				// in case of unsuccessful re-add filter into remaining ones
-				remaining_filters.push_back(std::move(transitive_filter));
-			}
-		}
-		return ret;
-	} else {
-		// comparison between two non-scalars
-		// only handle comparisons for now
-		if (expr.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
-			return FilterResult::UNSUPPORTED;
-		}
-		// get the LHS and RHS nodes
-		auto &left_node = GetNode(*comparison.left);
-		auto &right_node = GetNode(*comparison.right);
-		if (left_node.Equals(right_node)) {
-			return FilterResult::UNSUPPORTED;
-		}
-		// get the equivalence sets of the LHS and RHS
-		auto left_equivalence_set = GetEquivalenceSet(left_node);
-		auto right_equivalence_set = GetEquivalenceSet(right_node);
-		if (left_equivalence_set == right_equivalence_set) {
-			// this equality filter already exists, prune it
-			return FilterResult::SUCCESS;
-		}
-		// add the right bucket into the left bucket
-		D_ASSERT(equivalence_map.find(left_equivalence_set) != equivalence_map.end());
-		D_ASSERT(equivalence_map.find(right_equivalence_set) != equivalence_map.end());
-
-		auto &left_bucket = equivalence_map.find(left_equivalence_set)->second;
-		auto &right_bucket = equivalence_map.find(right_equivalence_set)->second;
-		for (auto &right_expr : right_bucket) {
-			// rewrite the equivalence set mapping for this node
-			equivalence_set_map[right_expr] = left_equivalence_set;
-			// add the node to the left bucket
-			left_bucket.push_back(right_expr);
-		}
-		// now add all constant values from the right bucket to the left bucket
-		D_ASSERT(constant_values.find(left_equivalence_set) != constant_values.end());
-		D_ASSERT(constant_values.find(right_equivalence_set) != constant_values.end());
-		auto &left_constant_bucket = constant_values.find(left_equivalence_set)->second;
-		auto &right_constant_bucket = constant_values.find(right_equivalence_set)->second;
-		for (auto &right_constant : right_constant_bucket) {
-			if (AddConstantComparison(left_constant_bucket, right_constant) == FilterResult::UNSATISFIABLE) {
-				return FilterResult::UNSATISFIABLE;
-			}
-		}
-	}
-	return FilterResult::SUCCESS;
-}
-
-FilterResult FilterCombiner::AddFilter(Expression &expr) {
-	if (expr.HasParameter()) {
-		return FilterResult::UNSUPPORTED;
-	}
-	if (expr.IsFoldable()) {
-		// scalar condition, evaluate it
-		Value result;
-		if (!ExpressionExecutor::TryEvaluateScalar(context, expr, result)) {
-			return FilterResult::UNSUPPORTED;
-		}
-		result = result.DefaultCastAs(LogicalType::BOOLEAN);
-		// check if the filter passes
-		if (result.IsNull() || !BooleanValue::Get(result)) {
-			// the filter does not pass the scalar test, create an empty result
-			return FilterResult::UNSATISFIABLE;
-		} else {
-			// the filter passes the scalar test, just remove the condition
-			return FilterResult::SUCCESS;
-		}
-	}
-	D_ASSERT(!expr.IsFoldable());
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_BETWEEN) {
-		auto &comparison = expr.Cast<BoundBetweenExpression>();
-		//! check if one of the sides is a scalar value
-		bool lower_is_scalar = comparison.lower->IsFoldable();
-		bool upper_is_scalar = comparison.upper->IsFoldable();
-		if (lower_is_scalar || upper_is_scalar) {
-			//! comparison with scalar - break apart
-			auto &node = GetNode(*comparison.input);
-			idx_t equivalence_set = GetEquivalenceSet(node);
-			auto result = FilterResult::UNSATISFIABLE;
-
-			if (lower_is_scalar) {
-				auto scalar = comparison.lower.get();
-				Value constant_value;
-				if (!ExpressionExecutor::TryEvaluateScalar(context, *scalar, constant_value)) {
-					return FilterResult::UNSUPPORTED;
-				}
-
-				// create the ExpressionValueInformation
-				ExpressionValueInformation info;
-				if (comparison.lower_inclusive) {
-					info.comparison_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-				} else {
-					info.comparison_type = ExpressionType::COMPARE_GREATERTHAN;
-				}
-				info.constant = constant_value;
-
-				// get the current bucket of constant values
-				D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-				auto &info_list = constant_values.find(equivalence_set)->second;
-				// check the existing constant comparisons to see if we can do any pruning
-				result = AddConstantComparison(info_list, info);
-			} else {
-				D_ASSERT(upper_is_scalar);
-				const auto type = comparison.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
-				                                             : ExpressionType::COMPARE_LESSTHAN;
-				auto left = comparison.lower->Copy();
-				auto right = comparison.input->Copy();
-				auto lower_comp = make_uniq<BoundComparisonExpression>(type, std::move(left), std::move(right));
-				result = AddBoundComparisonFilter(*lower_comp);
-			}
-
-			//	 Stop if we failed
-			if (result != FilterResult::SUCCESS) {
-				return result;
-			}
-
-			if (upper_is_scalar) {
-				auto scalar = comparison.upper.get();
-				Value constant_value;
-				if (!ExpressionExecutor::TryEvaluateScalar(context, *scalar, constant_value)) {
-					return FilterResult::UNSUPPORTED;
-				}
-
-				// create the ExpressionValueInformation
-				ExpressionValueInformation info;
-				if (comparison.upper_inclusive) {
-					info.comparison_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-				} else {
-					info.comparison_type = ExpressionType::COMPARE_LESSTHAN;
-				}
-				info.constant = constant_value;
-
-				// get the current bucket of constant values
-				D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-				// check the existing constant comparisons to see if we can do any pruning
-				result = AddConstantComparison(constant_values.find(equivalence_set)->second, info);
-			} else {
-				D_ASSERT(lower_is_scalar);
-				const auto type = comparison.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
-				                                             : ExpressionType::COMPARE_LESSTHAN;
-				auto left = comparison.input->Copy();
-				auto right = comparison.upper->Copy();
-				auto upper_comp = make_uniq<BoundComparisonExpression>(type, std::move(left), std::move(right));
-				result = AddBoundComparisonFilter(*upper_comp);
-			}
-
-			return result;
-		}
-	} else if (expr.GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-		return AddBoundComparisonFilter(expr);
-	}
-	// only comparisons supported for now
-	return FilterResult::UNSUPPORTED;
-}
-
-/*
- * Create and add new transitive filters from a two non-scalar filter such as j > i, j >= i, j < i, and j <= i
- * It's missing to create another method to add transitive filters from scalar filters, e.g, i > 10
- */
-FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &comparison, bool is_root) {
-	if (!IsGreaterThan(comparison.GetExpressionType()) && !IsLessThan(comparison.GetExpressionType())) {
-		return FilterResult::UNSUPPORTED;
-	}
-	// get the LHS and RHS nodes
-	auto &left_node = GetNode(*comparison.left);
-	reference<Expression> right_node = GetNode(*comparison.right);
-	// In case with filters like CAST(i) = j and i = 5 we replace the COLUMN_REF i with the constant 5
-	do {
-		if (right_node.get().GetExpressionType() != ExpressionType::OPERATOR_CAST) {
-			break;
-		}
-		auto &bound_cast_expr = right_node.get().Cast<BoundCastExpression>();
-		if (bound_cast_expr.child->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			break;
-		}
-		auto &col_ref = bound_cast_expr.child->Cast<BoundColumnRefExpression>();
-		for (auto &stored_exp : stored_expressions) {
-			reference<Expression> expr = stored_exp.first;
-			if (expr.get().GetExpressionType() == ExpressionType::OPERATOR_CAST) {
-				expr = *(right_node.get().Cast<BoundCastExpression>().child);
-			}
-			if (expr.get().GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-				continue;
-			}
-			auto &st_col_ref = expr.get().Cast<BoundColumnRefExpression>();
-			if (st_col_ref.binding != col_ref.binding) {
-				continue;
-			}
-			if (bound_cast_expr.return_type != stored_exp.second->return_type) {
-				continue;
-			}
-			bound_cast_expr.child = stored_exp.second->Copy();
-			right_node = GetNode(*bound_cast_expr.child);
-			break;
-		}
-	} while (false);
-
-	if (left_node.Equals(right_node)) {
-		return FilterResult::UNSUPPORTED;
-	}
-	// get the equivalence sets of the LHS and RHS
-	idx_t left_equivalence_set = GetEquivalenceSet(left_node);
-	idx_t right_equivalence_set = GetEquivalenceSet(right_node);
-	if (left_equivalence_set == right_equivalence_set) {
-		// this equality filter already exists, prune it
-		return FilterResult::SUCCESS;
-	}
-
-	vector<ExpressionValueInformation> &left_constants = constant_values.find(left_equivalence_set)->second;
-	vector<ExpressionValueInformation> &right_constants = constant_values.find(right_equivalence_set)->second;
-	bool is_successful = false;
-	bool is_inserted = false;
-	// read every constant filters already inserted for the right scalar variable
-	// and see if we can create new transitive filters, e.g., there is already a filter i > 10,
-	// suppose that we have now the j >= i, then we can infer a new filter j > 10
-	for (const auto &right_constant : right_constants) {
-		ExpressionValueInformation info;
-		info.constant = right_constant.constant;
-		// there is already an equality filter, e.g., i = 10
-		if (right_constant.comparison_type == ExpressionType::COMPARE_EQUAL) {
-			// create filter j [>, >=, <, <=] 10
-			// suppose the new comparison is j >= i and we have already a filter i = 10,
-			// then we create a new filter j >= 10
-			// and the filter j >= i can be pruned by not adding it into the remaining filters
-			info.comparison_type = comparison.GetExpressionType();
-		} else if ((comparison.GetExpressionType() == ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
-		            IsGreaterThan(right_constant.comparison_type)) ||
-		           (comparison.GetExpressionType() == ExpressionType::COMPARE_LESSTHANOREQUALTO &&
-		            IsLessThan(right_constant.comparison_type))) {
-			// filters (j >= i AND i [>, >=] 10) OR (j <= i AND i [<, <=] 10)
-			// create filter j [>, >=] 10 and add the filter j [>=, <=] i into the remaining filters
-			info.comparison_type = right_constant.comparison_type; // create filter j [>, >=, <, <=] 10
-			if (!is_inserted) {
-				// Add the filter j >= i in the remaing filters
-				auto filter = make_uniq<BoundComparisonExpression>(comparison.GetExpressionType(),
-				                                                   comparison.left->Copy(), comparison.right->Copy());
-				remaining_filters.push_back(std::move(filter));
-				is_inserted = true;
-			}
-		} else if ((comparison.GetExpressionType() == ExpressionType::COMPARE_GREATERTHAN &&
-		            IsGreaterThan(right_constant.comparison_type)) ||
-		           (comparison.GetExpressionType() == ExpressionType::COMPARE_LESSTHAN &&
-		            IsLessThan(right_constant.comparison_type))) {
-			// filters (j > i AND i [>, >=] 10) OR j < i AND i [<, <=] 10
-			// create filter j [>, <] 10 and add the filter j [>, <] i into the remaining filters
-			// the comparisons j > i and j < i are more restrictive
-			info.comparison_type = comparison.GetExpressionType();
-			if (!is_inserted) {
-				// Add the filter j [>, <] i
-				auto filter = make_uniq<BoundComparisonExpression>(comparison.GetExpressionType(),
-				                                                   comparison.left->Copy(), comparison.right->Copy());
-				remaining_filters.push_back(std::move(filter));
-				is_inserted = true;
-			}
-		} else {
-			// we cannot add a new filter
-			continue;
-		}
-		// Add the new filer into the left set
-		if (AddConstantComparison(left_constants, info) == FilterResult::UNSATISFIABLE) {
-			return FilterResult::UNSATISFIABLE;
-		}
-		is_successful = true;
-	}
-	if (is_successful) {
-		if (is_root) {
-			// now check for remaining transitive filters from the left column
-			auto transitive_filter = FindTransitiveFilter(*comparison.left);
-			if (transitive_filter != nullptr) {
-				// try to add transitive filters
-				auto &transitive_cast = transitive_filter->Cast<BoundComparisonExpression>();
-				if (AddTransitiveFilters(transitive_cast, false) == FilterResult::UNSUPPORTED) {
-					// in case of unsuccessful re-add filter into remaining ones
-					remaining_filters.push_back(std::move(transitive_filter));
-				}
-			}
-		}
-		return FilterResult::SUCCESS;
-	}
-
-	return FilterResult::UNSUPPORTED;
-}
-
-/*
- * Find a transitive filter already inserted into the remaining filters
- * Check for a match between the right column of bound comparisons and the expression,
- * then removes the bound comparison from the remaining filters and returns it
- */
-unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression &expr) {
-	// We only check for bound column ref
-	if (expr.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-		return nullptr;
-	}
-	for (idx_t i = 0; i < remaining_filters.size(); i++) {
-		if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-			auto &comparison = remaining_filters[i]->Cast<BoundComparisonExpression>();
-			if (expr.Equals(*comparison.right) && comparison.GetExpressionType() != ExpressionType::COMPARE_NOTEQUAL) {
-				auto filter = std::move(remaining_filters[i]);
-				remaining_filters.erase_at(i);
-				return filter;
-			}
-		}
-	}
-	return nullptr;
-}
-
-ValueComparisonResult InvertValueComparisonResult(ValueComparisonResult result) {
-	if (result == ValueComparisonResult::PRUNE_RIGHT) {
-		return ValueComparisonResult::PRUNE_LEFT;
-	}
-	if (result == ValueComparisonResult::PRUNE_LEFT) {
-		return ValueComparisonResult::PRUNE_RIGHT;
-	}
-	return result;
-}
-
-ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left, ExpressionValueInformation &right) {
-	if (left.comparison_type == ExpressionType::COMPARE_EQUAL) {
-		// left is COMPARE_EQUAL, we can either
-		// (1) prune the right side or
-		// (2) return UNSATISFIABLE
-		bool prune_right_side = false;
-		switch (right.comparison_type) {
-		case ExpressionType::COMPARE_LESSTHAN:
-			prune_right_side = left.constant < right.constant;
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			prune_right_side = left.constant <= right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			prune_right_side = left.constant > right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			prune_right_side = left.constant >= right.constant;
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-			prune_right_side = left.constant != right.constant;
-			break;
-		default:
-			D_ASSERT(right.comparison_type == ExpressionType::COMPARE_EQUAL);
-			prune_right_side = left.constant == right.constant;
-			break;
-		}
-		if (prune_right_side) {
-			return ValueComparisonResult::PRUNE_RIGHT;
-		} else {
-			return ValueComparisonResult::UNSATISFIABLE_CONDITION;
-		}
-	} else if (right.comparison_type == ExpressionType::COMPARE_EQUAL) {
-		// right is COMPARE_EQUAL
-		return InvertValueComparisonResult(CompareValueInformation(right, left));
-	} else if (left.comparison_type == ExpressionType::COMPARE_NOTEQUAL) {
-		// left is COMPARE_NOTEQUAL, we can either
-		// (1) prune the left side or
-		// (2) not prune anything
-		bool prune_left_side = false;
-		switch (right.comparison_type) {
-		case ExpressionType::COMPARE_LESSTHAN:
-			prune_left_side = left.constant >= right.constant;
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			prune_left_side = left.constant > right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			prune_left_side = left.constant <= right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			prune_left_side = left.constant < right.constant;
-			break;
-		default:
-			D_ASSERT(right.comparison_type == ExpressionType::COMPARE_NOTEQUAL);
-			prune_left_side = left.constant == right.constant;
-			break;
-		}
-		if (prune_left_side) {
-			return ValueComparisonResult::PRUNE_LEFT;
-		} else {
-			return ValueComparisonResult::PRUNE_NOTHING;
-		}
-	} else if (right.comparison_type == ExpressionType::COMPARE_NOTEQUAL) {
-		return InvertValueComparisonResult(CompareValueInformation(right, left));
-	} else if (IsGreaterThan(left.comparison_type) && IsGreaterThan(right.comparison_type)) {
-		// both comparisons are [>], we can either
-		// (1) prune the left side or
-		// (2) prune the right side
-		if (left.constant > right.constant) {
-			// left constant is more selective, prune right
-			return ValueComparisonResult::PRUNE_RIGHT;
-		} else if (left.constant < right.constant) {
-			// right constant is more selective, prune left
-			return ValueComparisonResult::PRUNE_LEFT;
-		} else {
-			// constants are equivalent
-			// however we can still have the scenario where one is [>=] and the other is [>]
-			// we want to prune the [>=] because [>] is more selective
-			// if left is [>=] we prune the left, else we prune the right
-			if (left.comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
-				return ValueComparisonResult::PRUNE_LEFT;
-			} else {
-				return ValueComparisonResult::PRUNE_RIGHT;
-			}
-		}
-	} else if (IsLessThan(left.comparison_type) && IsLessThan(right.comparison_type)) {
-		// both comparisons are [<], we can either
-		// (1) prune the left side or
-		// (2) prune the right side
-		if (left.constant < right.constant) {
-			// left constant is more selective, prune right
-			return ValueComparisonResult::PRUNE_RIGHT;
-		} else if (left.constant > right.constant) {
-			// right constant is more selective, prune left
-			return ValueComparisonResult::PRUNE_LEFT;
-		} else {
-			// constants are equivalent
-			// however we can still have the scenario where one is [<=] and the other is [<]
-			// we want to prune the [<=] because [<] is more selective
-			// if left is [<=] we prune the left, else we prune the right
-			if (left.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO) {
-				return ValueComparisonResult::PRUNE_LEFT;
-			} else {
-				return ValueComparisonResult::PRUNE_RIGHT;
-			}
-		}
-	} else if (IsLessThan(left.comparison_type)) {
-		D_ASSERT(IsGreaterThan(right.comparison_type));
-		// left is [<] and right is [>], in this case we can either
-		// (1) prune nothing or
-		// (2) return UNSATISFIABLE
-		// the SMALLER THAN constant has to be greater than the BIGGER THAN constant
-		if (left.constant >= right.constant) {
-			return ValueComparisonResult::PRUNE_NOTHING;
-		} else {
-			return ValueComparisonResult::UNSATISFIABLE_CONDITION;
-		}
-	} else {
-		// left is [>] and right is [<] or [!=]
-		D_ASSERT(IsLessThan(right.comparison_type) && IsGreaterThan(left.comparison_type));
-		return InvertValueComparisonResult(CompareValueInformation(right, left));
-	}
-}
-//
-// void FilterCombiner::LookUpConjunctions(Expression *expr) {
-//	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_OR) {
-//		auto root_or_expr = (BoundConjunctionExpression *)expr;
-//		for (const auto &entry : map_col_conjunctions) {
-//			for (const auto &conjs_to_push : entry.second) {
-//				if (conjs_to_push->root_or->Equals(root_or_expr)) {
-//					return;
-//				}
-//			}
-//		}
-//
-//		cur_root_or = root_or_expr;
-//		cur_conjunction = root_or_expr;
-//		cur_colref_to_push = nullptr;
-//		if (!BFSLookUpConjunctions(cur_root_or)) {
-//			if (cur_colref_to_push) {
-//				auto entry = map_col_conjunctions.find(cur_colref_to_push);
-//				auto &vec_conjs_to_push = entry->second;
-//				if (vec_conjs_to_push.size() == 1) {
-//					map_col_conjunctions.erase(entry);
-//					return;
-//				}
-//				vec_conjs_to_push.pop_back();
-//			}
-//		}
-//		return;
-//	}
-//
-//	// Verify if the expression has a column already pushed down by other OR expression
-//	VerifyOrsToPush(*expr);
-//}
-//
-// bool FilterCombiner::BFSLookUpConjunctions(BoundConjunctionExpression *conjunction) {
-//	vector<BoundConjunctionExpression *> conjunctions_to_visit;
-//
-//	for (auto &child : conjunction->children) {
-//		switch (child->GetExpressionClass()) {
-//		case ExpressionClass::BOUND_CONJUNCTION: {
-//			auto child_conjunction = (BoundConjunctionExpression *)child.get();
-//			conjunctions_to_visit.emplace_back(child_conjunction);
-//			break;
-//		}
-//		case ExpressionClass::BOUND_COMPARISON: {
-//			if (!UpdateConjunctionFilter((BoundComparisonExpression *)child.get())) {
-//				return false;
-//			}
-//			break;
-//		}
-//		default: {
-//			return false;
-//		}
-//		}
-//	}
-//
-//	for (auto child_conjunction : conjunctions_to_visit) {
-//		cur_conjunction = child_conjunction;
-//		// traverse child conjunction
-//		if (!BFSLookUpConjunctions(child_conjunction)) {
-//			return false;
-//		}
-//	}
-//	return true;
-//}
-//
-// void FilterCombiner::VerifyOrsToPush(Expression &expr) {
-//	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-//		auto colref = (BoundColumnRefExpression *)&expr;
-//		auto entry = map_col_conjunctions.find(colref);
-//		if (entry == map_col_conjunctions.end()) {
-//			return;
-//		}
-//		map_col_conjunctions.erase(entry);
-//	}
-//	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { VerifyOrsToPush(child); });
-//}
-//
-// bool FilterCombiner::UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr) {
-//	bool left_is_scalar = comparison_expr->left->IsFoldable();
-//	bool right_is_scalar = comparison_expr->right->IsFoldable();
-//
-//	Expression *non_scalar_expr;
-//	if (left_is_scalar || right_is_scalar) {
-//		// only support comparison with scalar
-//		non_scalar_expr = left_is_scalar ? comparison_expr->right.get() : comparison_expr->left.get();
-//
-//		if (non_scalar_expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-//			return UpdateFilterByColumn((BoundColumnRefExpression *)non_scalar_expr, comparison_expr);
-//		}
-//	}
-//
-//	return false;
-//}
-//
-// bool FilterCombiner::UpdateFilterByColumn(BoundColumnRefExpression *column_ref,
-//                                          BoundComparisonExpression *comparison_expr) {
-//	if (cur_colref_to_push == nullptr) {
-//		cur_colref_to_push = column_ref;
-//
-//		auto or_conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-//		or_conjunction->children.emplace_back(comparison_expr->Copy());
-//
-//		unique_ptr<ConjunctionsToPush> conjs_to_push = make_uniq<ConjunctionsToPush>();
-//		conjs_to_push->conjunctions.emplace_back(std::move(or_conjunction));
-//		conjs_to_push->root_or = cur_root_or;
-//
-//		auto &&vec_col_conjs = map_col_conjunctions[column_ref];
-//		vec_col_conjs.emplace_back(std::move(conjs_to_push));
-//		vec_colref_insertion_order.emplace_back(column_ref);
-//		return true;
-//	}
-//
-//	auto entry = map_col_conjunctions.find(cur_colref_to_push);
-//	D_ASSERT(entry != map_col_conjunctions.end());
-//	auto &conjunctions_to_push = entry->second.back();
-//
-//	if (!cur_colref_to_push->Equals(column_ref)) {
-//		// check for multiple colunms in the same root OR node
-//		if (cur_root_or == cur_conjunction) {
-//			return false;
-//		}
-//		// found an AND using a different column, we should stop the look up
-//		if (cur_conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-//			return false;
-//		}
-//
-//		// found a different column, AND conditions cannot be preserved anymore
-//		conjunctions_to_push->preserve_and = false;
-//		return true;
-//	}
-//
-//	auto &last_conjunction = conjunctions_to_push->conjunctions.back();
-//	if (cur_conjunction->GetExpressionType() == last_conjunction->GetExpressionType()) {
-//		last_conjunction->children.emplace_back(comparison_expr->Copy());
-//	} else {
-//		auto new_conjunction = make_uniq<BoundConjunctionExpression>(cur_conjunction->GetExpressionType());
-//		new_conjunction->children.emplace_back(comparison_expr->Copy());
-//		conjunctions_to_push->conjunctions.emplace_back(std::move(new_conjunction));
-//	}
-//	return true;
-//}
-//
-// void FilterCombiner::GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids) {
-//	for (const auto colref : vec_colref_insertion_order) {
-//		auto column_index = column_ids[colref->binding.column_index];
-//		if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-//			break;
-//		}
-//
-//		for (const auto &conjunctions_to_push : map_col_conjunctions[colref]) {
-//			// root OR filter to push into the TableFilter
-//			auto root_or_filter = make_uniq<ConjunctionOrFilter>();
-//			// variable to hold the last conjuntion filter pointer
-//			// the next filter will be added into it, i.e., we create a chain of conjunction filters
-//			ConjunctionFilter *last_conj_filter = root_or_filter.get();
-//
-//			for (auto &conjunction : conjunctions_to_push->conjunctions) {
-//				if (conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND &&
-//				    conjunctions_to_push->preserve_and) {
-//					GenerateConjunctionFilter<ConjunctionAndFilter>(conjunction.get(), last_conj_filter);
-//				} else {
-//					GenerateConjunctionFilter<ConjunctionOrFilter>(conjunction.get(), last_conj_filter);
-//				}
-//			}
-//			table_filter.PushFilter(column_index, std::move(root_or_filter));
-//		}
-//	}
-//	map_col_conjunctions.clear();
-//	vec_colref_insertion_order.clear();
-//}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/filter_pullup.cpp b/src/duckdb/src/optimizer/filter_pullup.cpp
deleted file mode 100644
index 219611387..000000000
--- a/src/duckdb/src/optimizer/filter_pullup.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "duckdb/optimizer/filter_pullup.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op) {
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return PullupFilter(std::move(op));
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PullupProjection(std::move(op));
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PullupCrossProduct(std::move(op));
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		return PullupJoin(std::move(op));
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		return PullupSetOperation(std::move(op));
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		// we can just pull directly through these operations without any rewriting
-		op->children[0] = Rewrite(std::move(op->children[0]));
-		return op;
-	}
-	default:
-		return FinishPullup(std::move(op));
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = op->Cast<LogicalJoin>();
-
-	switch (join.join_type) {
-	case JoinType::INNER:
-		if (op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			//	We can only move filters through the left side of AsOf joins.
-			return PullupFromLeft(std::move(op));
-		} else {
-			return PullupInnerJoin(std::move(op));
-		}
-	case JoinType::LEFT:
-	case JoinType::ANTI:
-	case JoinType::SEMI: {
-		return PullupFromLeft(std::move(op));
-	}
-	default:
-		// unsupported join type: call children pull up
-		return FinishPullup(std::move(op));
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupInnerJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->Cast<LogicalJoin>().join_type == JoinType::INNER);
-	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return op;
-	}
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN);
-
-	// Get the filters from both sides of the join
-	op = PullupBothSide(std::move(op));
-	vector<unique_ptr<Expression>> expressions;
-	if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
-		expressions = std::move(op->expressions);
-		op = std::move(op->children[0]);
-	} else if (!can_pullup) {
-		return op; // No filters from below, and we can't pullup, stop.
-	}
-
-	// Also extract the filters of the joins
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &comp_join = op->Cast<LogicalComparisonJoin>();
-		for (auto &cond : comp_join.conditions) {
-			expressions.push_back(
-			    make_uniq<BoundComparisonExpression>(cond.comparison, std::move(cond.left), std::move(cond.right)));
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &any_join = op->Cast<LogicalAnyJoin>();
-		expressions.push_back(std::move(any_join.condition));
-		break;
-	}
-	default:
-		throw NotImplementedException("PullupInnerJoin for LogicalOperatorType::%s", EnumUtil::ToString(op->type));
-	}
-
-	// Convert to cross product
-	op = make_uniq<LogicalCrossProduct>(std::move(op->children[0]), std::move(op->children[1]));
-	if (can_pullup) {
-		for (auto &expr : expressions) {
-			filters_expr_pullup.push_back(std::move(expr));
-		}
-	} else {
-		op = GeneratePullupFilter(std::move(op), expressions);
-	}
-	return op;
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupCrossProduct(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT);
-	return PullupBothSide(std::move(op));
-}
-
-unique_ptr<LogicalOperator> FilterPullup::GeneratePullupFilter(unique_ptr<LogicalOperator> child,
-                                                               vector<unique_ptr<Expression>> &expressions) {
-	unique_ptr<LogicalFilter> filter = make_uniq<LogicalFilter>();
-	for (idx_t i = 0; i < expressions.size(); ++i) {
-		filter->expressions.push_back(std::move(expressions[i]));
-	}
-	expressions.clear();
-	filter->children.push_back(std::move(child));
-	return std::move(filter);
-}
-
-unique_ptr<LogicalOperator> FilterPullup::FinishPullup(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (idx_t i = 0; i < op->children.size(); i++) {
-		FilterPullup pullup;
-		op->children[i] = pullup.Rewrite(std::move(op->children[i]));
-	}
-	// now pull up any existing filters
-	if (filters_expr_pullup.empty()) {
-		// no filters to pull up
-		return op;
-	}
-	return GeneratePullupFilter(std::move(op), filters_expr_pullup);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/filter_pushdown.cpp b/src/duckdb/src/optimizer/filter_pushdown.cpp
deleted file mode 100644
index c7962b714..000000000
--- a/src/duckdb/src/optimizer/filter_pushdown.cpp
+++ /dev/null
@@ -1,238 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/filter_combiner.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-void FilterPushdown::CheckMarkToSemi(LogicalOperator &op, unordered_set<idx_t> &table_bindings) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		if (join.join_type != JoinType::MARK) {
-			break;
-		}
-		// if the projected table bindings include the mark join index,
-		if (table_bindings.find(join.mark_index) != table_bindings.end()) {
-			join.convert_mark_to_semi = false;
-		}
-		break;
-	}
-	// you need to store table.column index.
-	// if you get to a projection, you need to change the table_bindings passed so they reflect the
-	// table index of the original expression they originated from.
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		// when we encounter a projection, replace the table_bindings with
-		// the tables in the projection
-		auto &proj = op.Cast<LogicalProjection>();
-		auto proj_bindings = proj.GetColumnBindings();
-		unordered_set<idx_t> new_table_bindings;
-		for (auto &binding : proj_bindings) {
-			auto col_index = binding.column_index;
-			auto &expr = proj.expressions.at(col_index);
-			vector<ColumnBinding> bindings_to_keep;
-			ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) {
-				if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-					auto &col_ref = child.Cast<BoundColumnRefExpression>();
-					bindings_to_keep.push_back(col_ref.binding);
-				}
-			});
-			for (auto &expr_binding : bindings_to_keep) {
-				new_table_bindings.insert(expr_binding.table_index);
-			}
-			table_bindings = new_table_bindings;
-		}
-		break;
-	}
-	default:
-		break;
-	}
-
-	// recurse into the children to find mark joins and project their indexes.
-	for (auto &child : op.children) {
-		CheckMarkToSemi(*child, table_bindings);
-	}
-}
-
-FilterPushdown::FilterPushdown(Optimizer &optimizer, bool convert_mark_joins)
-    : optimizer(optimizer), combiner(optimizer.context), convert_mark_joins(convert_mark_joins) {
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(!combiner.HasFilters());
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return PushdownAggregate(std::move(op));
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return PushdownFilter(std::move(op));
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PushdownCrossProduct(std::move(op));
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PushdownJoin(std::move(op));
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PushdownProjection(std::move(op));
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_UNION:
-		return PushdownSetOperation(std::move(op));
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		return PushdownDistinct(std::move(op));
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		// we can just push directly through these operations without any rewriting
-		op->children[0] = Rewrite(std::move(op->children[0]));
-		return op;
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE: {
-		// we can't push filters into the materialized CTE (LHS), but we do want to recurse into it
-		FilterPushdown pushdown(optimizer, convert_mark_joins);
-		op->children[0] = pushdown.Rewrite(std::move(op->children[0]));
-		// we can push filters into the rest of the query plan (RHS)
-		op->children[1] = Rewrite(std::move(op->children[1]));
-		return op;
-	}
-	case LogicalOperatorType::LOGICAL_GET:
-		return PushdownGet(std::move(op));
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		return PushdownLimit(std::move(op));
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		return PushdownWindow(std::move(op));
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		return PushdownUnnest(std::move(op));
-	default:
-		return FinishPushdown(std::move(op));
-	}
-}
-
-ClientContext &FilterPushdown::GetContext() {
-	return optimizer.GetContext();
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = op->Cast<LogicalJoin>();
-	if (join.HasProjectionMap()) {
-		// cannot push down further otherwise the projection maps won't be preserved
-		return FinishPushdown(std::move(op));
-	}
-
-	unordered_set<idx_t> left_bindings, right_bindings;
-	LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
-	LogicalJoin::GetTableReferences(*op->children[1], right_bindings);
-
-	switch (join.join_type) {
-	case JoinType::INNER:
-		//	AsOf joins can't push anything into the RHS, so treat it as a left join
-		if (op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			return PushdownLeftJoin(std::move(op), left_bindings, right_bindings);
-		}
-		return PushdownInnerJoin(std::move(op), left_bindings, right_bindings);
-	case JoinType::LEFT:
-		return PushdownLeftJoin(std::move(op), left_bindings, right_bindings);
-	case JoinType::MARK:
-		return PushdownMarkJoin(std::move(op), left_bindings, right_bindings);
-	case JoinType::SINGLE:
-		return PushdownSingleJoin(std::move(op), left_bindings, right_bindings);
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-		return PushdownSemiAntiJoin(std::move(op));
-	default:
-		// unsupported join type: stop pushing down
-		return FinishPushdown(std::move(op));
-	}
-}
-void FilterPushdown::PushFilters() {
-	for (auto &f : filters) {
-		auto result = combiner.AddFilter(std::move(f->filter));
-		D_ASSERT(result != FilterResult::UNSUPPORTED);
-		(void)result;
-	}
-	filters.clear();
-}
-
-FilterResult FilterPushdown::AddFilter(unique_ptr<Expression> expr) {
-	PushFilters();
-	// split up the filters by AND predicate
-	vector<unique_ptr<Expression>> expressions;
-	expressions.push_back(std::move(expr));
-	LogicalFilter::SplitPredicates(expressions);
-	// push the filters into the combiner
-	for (auto &child_expr : expressions) {
-		if (combiner.AddFilter(std::move(child_expr)) == FilterResult::UNSATISFIABLE) {
-			return FilterResult::UNSATISFIABLE;
-		}
-	}
-	return FilterResult::SUCCESS;
-}
-
-void FilterPushdown::GenerateFilters() {
-	if (!filters.empty()) {
-		D_ASSERT(!combiner.HasFilters());
-		return;
-	}
-	combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
-		auto f = make_uniq<Filter>();
-		f->filter = std::move(filter);
-		f->ExtractBindings();
-		filters.push_back(std::move(f));
-	});
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::AddLogicalFilter(unique_ptr<LogicalOperator> op,
-                                                             vector<unique_ptr<Expression>> expressions) {
-	if (expressions.empty()) {
-		// No left expressions, so needn't to add an extra filter operator.
-		return op;
-	}
-	auto filter = make_uniq<LogicalFilter>();
-	if (op->has_estimated_cardinality) {
-		// set the filter's estimated cardinality as the child op's.
-		// if the filter is created during the filter pushdown optimization, the estimated cardinality will be later
-		// overridden during the join order optimization to a more accurate one.
-		// if the filter is created during the statistics propagation, the estimated cardinality won't be set unless set
-		// here. assuming the filters introduced during the statistics propagation have little effect in reducing the
-		// cardinality, we adopt the the cardinality of the child. this could be improved by MinMax info from the
-		// statistics propagation
-		filter->SetEstimatedCardinality(op->estimated_cardinality);
-	}
-	filter->expressions = std::move(expressions);
-	filter->children.push_back(std::move(op));
-	return std::move(filter);
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushFinalFilters(unique_ptr<LogicalOperator> op) {
-	vector<unique_ptr<Expression>> expressions;
-	for (auto &f : filters) {
-		expressions.push_back(std::move(f->filter));
-	}
-
-	return AddLogicalFilter(std::move(op), std::move(expressions));
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (auto &child : op->children) {
-		FilterPushdown pushdown(optimizer, convert_mark_joins);
-		child = pushdown.Rewrite(std::move(child));
-	}
-	// now push any existing filters
-	return PushFinalFilters(std::move(op));
-}
-
-void FilterPushdown::Filter::ExtractBindings() {
-	bindings.clear();
-	LogicalJoin::GetExpressionBindings(*filter, bindings);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/in_clause_rewriter.cpp b/src/duckdb/src/optimizer/in_clause_rewriter.cpp
deleted file mode 100644
index 62f34c1a9..000000000
--- a/src/duckdb/src/optimizer/in_clause_rewriter.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include "duckdb/optimizer/in_clause_rewriter.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> InClauseRewriter::Rewrite(unique_ptr<LogicalOperator> op) {
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		current_op = op.get();
-		root = std::move(op->children[0]);
-		VisitOperatorExpressions(*op);
-		op->children[0] = std::move(root);
-		break;
-	}
-	default:
-		break;
-	}
-
-	for (auto &child : op->children) {
-		child = Rewrite(std::move(child));
-	}
-	return op;
-}
-
-unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr) {
-	if (expr.GetExpressionType() != ExpressionType::COMPARE_IN &&
-	    expr.GetExpressionType() != ExpressionType::COMPARE_NOT_IN) {
-		return nullptr;
-	}
-	D_ASSERT(root);
-	auto in_type = expr.children[0]->return_type;
-	bool is_regular_in = expr.GetExpressionType() == ExpressionType::COMPARE_IN;
-	bool all_scalar = true;
-	// IN clause with many children: try to generate a mark join that replaces this IN expression
-	// we can only do this if the expressions in the expression list are scalar
-	for (idx_t i = 1; i < expr.children.size(); i++) {
-		if (!expr.children[i]->IsFoldable()) {
-			// non-scalar expression
-			all_scalar = false;
-		}
-	}
-	if (expr.children.size() == 2) {
-		// only one child
-		// IN: turn into X = 1
-		// NOT IN: turn into X <> 1
-		return make_uniq<BoundComparisonExpression>(is_regular_in ? ExpressionType::COMPARE_EQUAL
-		                                                          : ExpressionType::COMPARE_NOTEQUAL,
-		                                            std::move(expr.children[0]), std::move(expr.children[1]));
-	}
-	if (expr.children.size() < 6 || !all_scalar) {
-		// low amount of children or not all scalar
-		// IN: turn into (X = 1 OR X = 2 OR X = 3...)
-		// NOT IN: turn into (X <> 1 AND X <> 2 AND X <> 3 ...)
-		auto conjunction = make_uniq<BoundConjunctionExpression>(is_regular_in ? ExpressionType::CONJUNCTION_OR
-		                                                                       : ExpressionType::CONJUNCTION_AND);
-		for (idx_t i = 1; i < expr.children.size(); i++) {
-			conjunction->children.push_back(make_uniq<BoundComparisonExpression>(
-			    is_regular_in ? ExpressionType::COMPARE_EQUAL : ExpressionType::COMPARE_NOTEQUAL,
-			    expr.children[0]->Copy(), std::move(expr.children[i])));
-		}
-		return std::move(conjunction);
-	}
-	// IN clause with many constant children
-	// generate a mark join that replaces this IN expression
-	// first generate a ColumnDataCollection from the set of expressions
-	vector<LogicalType> types = {in_type};
-	auto collection = make_uniq<ColumnDataCollection>(context, types);
-	ColumnDataAppendState append_state;
-	collection->InitializeAppend(append_state);
-
-	DataChunk chunk;
-	chunk.Initialize(context, types);
-	for (idx_t i = 1; i < expr.children.size(); i++) {
-		// resolve this expression to a constant
-		Value value;
-		if (!ExpressionExecutor::TryEvaluateScalar(context, *expr.children[i], value)) {
-			// error while evaluating scalar
-			return nullptr;
-		}
-		idx_t index = chunk.size();
-		chunk.SetCardinality(chunk.size() + 1);
-		chunk.SetValue(0, index, value);
-		if (chunk.size() == STANDARD_VECTOR_SIZE || i + 1 == expr.children.size()) {
-			// chunk full: append to chunk collection
-			collection->Append(append_state, chunk);
-			chunk.Reset();
-		}
-	}
-	// now generate a ChunkGet that scans this collection
-	auto chunk_index = optimizer.binder.GenerateTableIndex();
-	auto chunk_scan = make_uniq<LogicalColumnDataGet>(chunk_index, types, std::move(collection));
-
-	// then we generate the MARK join with the chunk scan on the RHS
-	auto join = make_uniq<LogicalComparisonJoin>(JoinType::MARK);
-	join->mark_index = chunk_index;
-	join->AddChild(std::move(root));
-	join->AddChild(std::move(chunk_scan));
-	// create the JOIN condition
-	JoinCondition cond;
-	cond.left = std::move(expr.children[0]);
-
-	cond.right = make_uniq<BoundColumnRefExpression>(in_type, ColumnBinding(chunk_index, 0));
-	cond.comparison = ExpressionType::COMPARE_EQUAL;
-	join->conditions.push_back(std::move(cond));
-	root = std::move(join);
-
-	if (current_op->type == LogicalOperatorType::LOGICAL_FILTER) {
-		// project out the mark index again
-		auto &filter = current_op->Cast<LogicalFilter>();
-		if (filter.projection_map.empty()) {
-			auto child_bindings = root->GetColumnBindings();
-			for (idx_t i = 0; i < child_bindings.size(); i++) {
-				if (child_bindings[i].table_index != chunk_index) {
-					filter.projection_map.push_back(i);
-				}
-			}
-		}
-	}
-
-	// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
-	unique_ptr<Expression> result =
-	    make_uniq<BoundColumnRefExpression>("IN (...)", LogicalType::BOOLEAN, ColumnBinding(chunk_index, 0));
-	if (!is_regular_in) {
-		// NOT IN: invert
-		auto invert = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
-		invert->children.push_back(std::move(result));
-		result = std::move(invert);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_filter_pushdown_optimizer.cpp b/src/duckdb/src/optimizer/join_filter_pushdown_optimizer.cpp
deleted file mode 100644
index 6187d3f8d..000000000
--- a/src/duckdb/src/optimizer/join_filter_pushdown_optimizer.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-#include "duckdb/optimizer/join_filter_pushdown_optimizer.hpp"
-
-#include "duckdb/execution/operator/join/join_filter_pushdown.hpp"
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/operator/logical_unnest.hpp"
-
-namespace duckdb {
-
-JoinFilterPushdownOptimizer::JoinFilterPushdownOptimizer(Optimizer &optimizer) : optimizer(optimizer) {
-}
-
-bool PushdownJoinFilterExpression(Expression &expr, JoinFilterPushdownColumn &filter) {
-	if (expr.GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-		// not a simple column ref - bail-out
-		return false;
-	}
-	// column-ref - pass through the new column binding
-	auto &colref = expr.Cast<BoundColumnRefExpression>();
-	filter.probe_column_index = colref.binding;
-	return true;
-}
-
-void JoinFilterPushdownOptimizer::GetPushdownFilterTargets(LogicalOperator &op,
-                                                           vector<JoinFilterPushdownColumn> columns,
-                                                           vector<PushdownFilterTarget> &targets) {
-	auto &probe_child = op;
-	switch (probe_child.type) {
-	case LogicalOperatorType::LOGICAL_LIMIT:
-	case LogicalOperatorType::LOGICAL_FILTER:
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-	case LogicalOperatorType::LOGICAL_TOP_N:
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		// does not affect probe side - recurse into left child
-		// FIXME: we can probably recurse into more operators here (e.g. window, unnest)
-		GetPushdownFilterTargets(*probe_child.children[0], std::move(columns), targets);
-		break;
-	case LogicalOperatorType::LOGICAL_UNNEST: {
-		auto &unnest = probe_child.Cast<LogicalUnnest>();
-		// check if the filters apply to the unnest index
-		for (auto &filter : columns) {
-			if (filter.probe_column_index.table_index == unnest.unnest_index) {
-				// the filter applies to the unnest index - bail out
-				return;
-			}
-		}
-		GetPushdownFilterTargets(*probe_child.children[0], std::move(columns), targets);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_UNION: {
-		auto &setop = probe_child.Cast<LogicalSetOperation>();
-		// union
-		// check if the filters apply to this table index
-		for (auto &filter : columns) {
-			if (filter.probe_column_index.table_index != setop.table_index) {
-				// the filter does not apply to the union - bail-out
-				return;
-			}
-		}
-		for (auto &child : probe_child.children) {
-			// rewrite the filters for each of the children of the union
-			vector<JoinFilterPushdownColumn> child_columns;
-			auto child_bindings = child->GetColumnBindings();
-			child_columns.reserve(columns.size());
-			for (auto &child_column : columns) {
-				JoinFilterPushdownColumn new_col;
-				new_col.probe_column_index = child_bindings[child_column.probe_column_index.column_index];
-				child_columns.push_back(new_col);
-			}
-			// then recurse into the child
-			GetPushdownFilterTargets(*child, std::move(child_columns), targets);
-
-			// for EXCEPT we can only recurse into the first (left) child
-			if (probe_child.type == LogicalOperatorType::LOGICAL_EXCEPT) {
-				break;
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_GET: {
-		// found LogicalGet
-		auto &get = probe_child.Cast<LogicalGet>();
-		if (!get.function.filter_pushdown) {
-			// filter pushdown is not supported - no need to consider this node
-			return;
-		}
-		for (auto &filter : columns) {
-			if (filter.probe_column_index.table_index != get.table_index) {
-				// the filter does not apply to the probe side here - bail-out
-				return;
-			}
-		}
-		targets.emplace_back(get, std::move(columns));
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		// projection - check if we all of the expressions are only column references
-		auto &proj = probe_child.Cast<LogicalProjection>();
-		for (auto &filter : columns) {
-			if (filter.probe_column_index.table_index != proj.table_index) {
-				// index does not belong to this projection - bail-out
-				return;
-			}
-			auto &expr = *proj.expressions[filter.probe_column_index.column_index];
-			if (!PushdownJoinFilterExpression(expr, filter)) {
-				// cannot push through this expression - bail-out
-				return;
-			}
-		}
-		GetPushdownFilterTargets(*probe_child.children[0], std::move(columns), targets);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		// we can push filters through aggregates IF they all point to groups
-		auto &aggr = probe_child.Cast<LogicalAggregate>();
-		for (auto &filter : columns) {
-			if (filter.probe_column_index.table_index != aggr.group_index) {
-				// index does not refer to a group - bail-out
-				return;
-			}
-			auto &expr = *aggr.groups[filter.probe_column_index.column_index];
-			if (!PushdownJoinFilterExpression(expr, filter)) {
-				// cannot push through this expression - bail-out
-				return;
-			}
-		}
-		GetPushdownFilterTargets(*probe_child.children[0], std::move(columns), targets);
-		break;
-	}
-	default:
-		// unsupported child type
-		break;
-	}
-}
-
-void JoinFilterPushdownOptimizer::GenerateJoinFilters(LogicalComparisonJoin &join) {
-	switch (join.join_type) {
-	case JoinType::MARK:
-	case JoinType::SINGLE:
-	case JoinType::LEFT:
-	case JoinType::OUTER:
-	case JoinType::ANTI:
-	case JoinType::RIGHT_ANTI:
-	case JoinType::RIGHT_SEMI:
-		// cannot generate join filters for these join types
-		// mark/single - cannot change cardinality of probe side
-		// left/outer always need to include every row from probe side
-		// FIXME: anti/right_anti - we could do this, but need to invert the join conditions
-		return;
-	default:
-		break;
-	}
-	// re-order conditions here - otherwise this will happen later on and invalidate the indexes we generate
-	PhysicalComparisonJoin::ReorderConditions(join.conditions);
-	auto pushdown_info = make_uniq<JoinFilterPushdownInfo>();
-
-	vector<JoinFilterPushdownColumn> pushdown_columns;
-	for (idx_t cond_idx = 0; cond_idx < join.conditions.size(); cond_idx++) {
-		auto &cond = join.conditions[cond_idx];
-		if (cond.comparison != ExpressionType::COMPARE_EQUAL) {
-			// only equality supported for now
-			continue;
-		}
-		if (cond.left->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			// only bound column ref supported for now
-			continue;
-		}
-		if (cond.left->return_type.IsNested()) {
-			// nested columns are not supported for pushdown
-			continue;
-		}
-		if (cond.left->return_type.id() == LogicalTypeId::INTERVAL) {
-			// interval is not supported for pushdown
-			continue;
-		}
-		JoinFilterPushdownColumn pushdown_col;
-		auto &colref = cond.left->Cast<BoundColumnRefExpression>();
-		pushdown_col.probe_column_index = colref.binding;
-		pushdown_columns.push_back(pushdown_col);
-
-		pushdown_info->join_condition.push_back(cond_idx);
-	}
-	if (pushdown_columns.empty()) {
-		// could not generate any filters - bail-out
-		return;
-	}
-	// recurse the query tree to find the LogicalGets in which we can push the filter info
-	vector<PushdownFilterTarget> pushdown_filter_targets;
-	GetPushdownFilterTargets(*join.children[0], pushdown_columns, pushdown_filter_targets);
-	for (auto &target : pushdown_filter_targets) {
-		auto &get = target.get;
-		// pushdown info can be applied to this LogicalGet - push the dynamic table filter set
-		if (!get.dynamic_filters) {
-			get.dynamic_filters = make_shared_ptr<DynamicTableFilterSet>();
-		}
-
-		JoinFilterPushdownFilter get_filter;
-		get_filter.dynamic_filters = get.dynamic_filters;
-		get_filter.columns = std::move(target.columns);
-		pushdown_info->probe_info.push_back(std::move(get_filter));
-	}
-
-	// Even if we cannot find any table sources in which we can push down filters,
-	// we still initialize the aggregate states so that we have the possibility of doing a perfect hash join
-	const auto compute_aggregates_anyway = join.join_type == JoinType::INNER && join.conditions.size() == 1 &&
-	                                       pushdown_info->join_condition.size() == 1 &&
-	                                       TypeIsIntegral(join.conditions[0].right->return_type.InternalType());
-	if (pushdown_info->probe_info.empty() && !compute_aggregates_anyway) {
-		// no table sources found in which we can push down filters
-		return;
-	}
-
-	// set up the min/max aggregates for each of the filters
-	vector<AggregateFunction> aggr_functions;
-	aggr_functions.push_back(MinFunction::GetFunction());
-	aggr_functions.push_back(MaxFunction::GetFunction());
-	for (auto &join_condition : pushdown_info->join_condition) {
-		for (auto &aggr : aggr_functions) {
-			FunctionBinder function_binder(optimizer.GetContext());
-			vector<unique_ptr<Expression>> aggr_children;
-			aggr_children.push_back(join.conditions[join_condition].right->Copy());
-			auto aggr_expr = function_binder.BindAggregateFunction(aggr, std::move(aggr_children), nullptr,
-			                                                       AggregateType::NON_DISTINCT);
-			if (aggr_expr->children.size() != 1) {
-				// min/max with collation - not supported
-				return;
-			}
-			pushdown_info->min_max_aggregates.push_back(std::move(aggr_expr));
-		}
-	}
-	// set up the filter pushdown in the join itself
-	join.filter_pushdown = std::move(pushdown_info);
-}
-
-void JoinFilterPushdownOptimizer::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		// comparison join - try to generate join filters (if possible)
-		GenerateJoinFilters(op.Cast<LogicalComparisonJoin>());
-	}
-	LogicalOperatorVisitor::VisitOperator(op);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp b/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp
deleted file mode 100644
index 4b5e22ada..000000000
--- a/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp
+++ /dev/null
@@ -1,497 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/query_graph_manager.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-namespace duckdb {
-
-// The filter was made on top of a logical sample or other projection,
-// but no specific columns are referenced. See issue 4978 number 4.
-bool CardinalityEstimator::EmptyFilter(FilterInfo &filter_info) {
-	if (!filter_info.left_set && !filter_info.right_set) {
-		return true;
-	}
-	return false;
-}
-
-void CardinalityEstimator::AddRelationTdom(FilterInfo &filter_info) {
-	D_ASSERT(filter_info.set.get().count >= 1);
-	for (const RelationsToTDom &r2tdom : relations_to_tdoms) {
-		auto &i_set = r2tdom.equivalent_relations;
-		if (i_set.find(filter_info.left_binding) != i_set.end()) {
-			// found an equivalent filter
-			return;
-		}
-	}
-
-	auto key = ColumnBinding(filter_info.left_binding.table_index, filter_info.left_binding.column_index);
-	RelationsToTDom new_r2tdom(column_binding_set_t({key}));
-
-	relations_to_tdoms.emplace_back(new_r2tdom);
-}
-
-bool CardinalityEstimator::SingleColumnFilter(duckdb::FilterInfo &filter_info) {
-	if (filter_info.left_set && filter_info.right_set && filter_info.set.get().count > 1) {
-		// Both set and are from different relations
-		return false;
-	}
-	if (EmptyFilter(filter_info)) {
-		return false;
-	}
-	if (filter_info.join_type == JoinType::SEMI || filter_info.join_type == JoinType::ANTI) {
-		return false;
-	}
-	return true;
-}
-
-vector<idx_t> CardinalityEstimator::DetermineMatchingEquivalentSets(optional_ptr<FilterInfo> filter_info) {
-	vector<idx_t> matching_equivalent_sets;
-	idx_t equivalent_relation_index = 0;
-
-	for (const RelationsToTDom &r2tdom : relations_to_tdoms) {
-		auto &i_set = r2tdom.equivalent_relations;
-		if (i_set.find(filter_info->left_binding) != i_set.end()) {
-			matching_equivalent_sets.push_back(equivalent_relation_index);
-		} else if (i_set.find(filter_info->right_binding) != i_set.end()) {
-			// don't add both left and right to the matching_equivalent_sets
-			// since both left and right get added to that index anyway.
-			matching_equivalent_sets.push_back(equivalent_relation_index);
-		}
-		equivalent_relation_index++;
-	}
-	return matching_equivalent_sets;
-}
-
-void CardinalityEstimator::AddToEquivalenceSets(optional_ptr<FilterInfo> filter_info,
-                                                vector<idx_t> matching_equivalent_sets) {
-	D_ASSERT(matching_equivalent_sets.size() <= 2);
-	if (matching_equivalent_sets.size() > 1) {
-		// an equivalence relation is connecting two sets of equivalence relations
-		// so push all relations from the second set into the first. Later we will delete
-		// the second set.
-		for (ColumnBinding i : relations_to_tdoms.at(matching_equivalent_sets[1]).equivalent_relations) {
-			relations_to_tdoms.at(matching_equivalent_sets[0]).equivalent_relations.insert(i);
-		}
-		for (auto &column_name : relations_to_tdoms.at(matching_equivalent_sets[1]).column_names) {
-			relations_to_tdoms.at(matching_equivalent_sets[0]).column_names.push_back(column_name);
-		}
-		relations_to_tdoms.at(matching_equivalent_sets[1]).equivalent_relations.clear();
-		relations_to_tdoms.at(matching_equivalent_sets[1]).column_names.clear();
-		relations_to_tdoms.at(matching_equivalent_sets[0]).filters.push_back(filter_info);
-		// add all values of one set to the other, delete the empty one
-	} else if (matching_equivalent_sets.size() == 1) {
-		auto &tdom_i = relations_to_tdoms.at(matching_equivalent_sets.at(0));
-		tdom_i.equivalent_relations.insert(filter_info->left_binding);
-		tdom_i.equivalent_relations.insert(filter_info->right_binding);
-		tdom_i.filters.push_back(filter_info);
-	} else if (matching_equivalent_sets.empty()) {
-		column_binding_set_t tmp;
-		tmp.insert(filter_info->left_binding);
-		tmp.insert(filter_info->right_binding);
-		relations_to_tdoms.emplace_back(tmp);
-		relations_to_tdoms.back().filters.push_back(filter_info);
-	}
-}
-
-void CardinalityEstimator::InitEquivalentRelations(const vector<unique_ptr<FilterInfo>> &filter_infos) {
-	// For each filter, we fill keep track of the index of the equivalent relation set
-	// the left and right relation needs to be added to.
-	for (auto &filter : filter_infos) {
-		if (SingleColumnFilter(*filter)) {
-			// Filter on one relation, (i.e. string or range filter on a column).
-			// Grab the first relation and add it to  the equivalence_relations
-			AddRelationTdom(*filter);
-			continue;
-		} else if (EmptyFilter(*filter)) {
-			continue;
-		}
-		D_ASSERT(filter->left_set->count >= 1);
-		D_ASSERT(filter->right_set->count >= 1);
-
-		auto matching_equivalent_sets = DetermineMatchingEquivalentSets(filter.get());
-		AddToEquivalenceSets(filter.get(), matching_equivalent_sets);
-	}
-	RemoveEmptyTotalDomains();
-}
-
-void CardinalityEstimator::RemoveEmptyTotalDomains() {
-	auto remove_start = std::remove_if(relations_to_tdoms.begin(), relations_to_tdoms.end(),
-	                                   [](RelationsToTDom &r_2_tdom) { return r_2_tdom.equivalent_relations.empty(); });
-	relations_to_tdoms.erase(remove_start, relations_to_tdoms.end());
-}
-
-double CardinalityEstimator::GetNumerator(JoinRelationSet &set) {
-	double numerator = 1;
-	for (idx_t i = 0; i < set.count; i++) {
-		auto &single_node_set = set_manager.GetJoinRelation(set.relations[i]);
-		auto card_helper = relation_set_2_cardinality[single_node_set.ToString()];
-		numerator *= card_helper.cardinality_before_filters == 0 ? 1 : card_helper.cardinality_before_filters;
-	}
-	return numerator;
-}
-
-bool EdgeConnects(FilterInfoWithTotalDomains &edge, Subgraph2Denominator &subgraph) {
-	if (edge.filter_info->left_set) {
-		if (JoinRelationSet::IsSubset(*subgraph.relations, *edge.filter_info->left_set)) {
-			// cool
-			return true;
-		}
-	}
-	if (edge.filter_info->right_set) {
-		if (JoinRelationSet::IsSubset(*subgraph.relations, *edge.filter_info->right_set)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-vector<FilterInfoWithTotalDomains> GetEdges(vector<RelationsToTDom> &relations_to_tdom,
-                                            JoinRelationSet &requested_set) {
-	vector<FilterInfoWithTotalDomains> res;
-	for (auto &relation_2_tdom : relations_to_tdom) {
-		for (auto &filter : relation_2_tdom.filters) {
-			if (JoinRelationSet::IsSubset(requested_set, filter->set)) {
-				FilterInfoWithTotalDomains new_edge(filter, relation_2_tdom);
-				res.push_back(new_edge);
-			}
-		}
-	}
-	return res;
-}
-
-vector<idx_t> SubgraphsConnectedByEdge(FilterInfoWithTotalDomains &edge, vector<Subgraph2Denominator> &subgraphs) {
-	vector<idx_t> res;
-	if (subgraphs.empty()) {
-		return res;
-	} else {
-		// check the combinations of subgraphs and see if the edge connects two of them,
-		// if so, return the indexes of the two subgraphs within the vector
-		for (idx_t outer = 0; outer != subgraphs.size(); outer++) {
-			// check if the edge connects two subgraphs.
-			for (idx_t inner = outer + 1; inner != subgraphs.size(); inner++) {
-				if (EdgeConnects(edge, subgraphs.at(outer)) && EdgeConnects(edge, subgraphs.at(inner))) {
-					// order is important because we will delete the inner subgraph later
-					res.push_back(outer);
-					res.push_back(inner);
-					return res;
-				}
-			}
-			// if the edge does not connect two subgraphs, see if the edge connects with just outer
-			// merge subgraph.at(outer) with the RelationSet(s) that edge connects
-			if (EdgeConnects(edge, subgraphs.at(outer))) {
-				res.push_back(outer);
-				return res;
-			}
-		}
-	}
-	// this edge connects only the relations it connects. Return an empty result so a new subgraph is created.
-	return res;
-}
-
-JoinRelationSet &CardinalityEstimator::UpdateNumeratorRelations(Subgraph2Denominator left, Subgraph2Denominator right,
-                                                                FilterInfoWithTotalDomains &filter) {
-	switch (filter.filter_info->join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI: {
-		if (JoinRelationSet::IsSubset(*left.relations, *filter.filter_info->left_set) &&
-		    JoinRelationSet::IsSubset(*right.relations, *filter.filter_info->right_set)) {
-			return *left.numerator_relations;
-		}
-		return *right.numerator_relations;
-	}
-	default:
-		// cross product or inner join
-		return set_manager.Union(*left.numerator_relations, *right.numerator_relations);
-	}
-}
-
-double CardinalityEstimator::CalculateUpdatedDenom(Subgraph2Denominator left, Subgraph2Denominator right,
-                                                   FilterInfoWithTotalDomains &filter) {
-	double new_denom = left.denom * right.denom;
-	switch (filter.filter_info->join_type) {
-	case JoinType::INNER: {
-		bool set = false;
-		ExpressionType comparison_type = ExpressionType::COMPARE_EQUAL;
-		ExpressionIterator::EnumerateExpression(filter.filter_info->filter, [&](Expression &expr) {
-			if (expr.GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-				comparison_type = expr.GetExpressionType();
-				set = true;
-				return;
-			}
-		});
-		if (!set) {
-			new_denom *=
-			    filter.has_tdom_hll ? static_cast<double>(filter.tdom_hll) : static_cast<double>(filter.tdom_no_hll);
-			// no comparison is taking place, so the denominator is just the product of the left and right
-			return new_denom;
-		}
-		// extra_ratio helps represents how many tuples will be filtered out if the comparison evaluates to
-		// false. set to 1 to assume cross product.
-		double extra_ratio = 1;
-		switch (comparison_type) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-			// extra ration stays 1
-			extra_ratio = filter.has_tdom_hll ? (double)filter.tdom_hll : (double)filter.tdom_no_hll;
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHAN:
-			// start with the selectivity of equality
-			extra_ratio = filter.has_tdom_hll ? (double)filter.tdom_hll : (double)filter.tdom_no_hll;
-			// now assume every tuple will match 2.5 times (on average)
-			extra_ratio *= static_cast<double>(1) / CardinalityEstimator::DEFAULT_LT_GT_MULTIPLIER;
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			// basically assume cross product.
-			extra_ratio = 1;
-			break;
-		default:
-			break;
-		}
-		new_denom *= extra_ratio;
-		return new_denom;
-	}
-	case JoinType::SEMI:
-	case JoinType::ANTI: {
-		if (JoinRelationSet::IsSubset(*left.relations, *filter.filter_info->left_set) &&
-		    JoinRelationSet::IsSubset(*right.relations, *filter.filter_info->right_set)) {
-			new_denom = left.denom * CardinalityEstimator::DEFAULT_SEMI_ANTI_SELECTIVITY;
-			return new_denom;
-		}
-		new_denom = right.denom * CardinalityEstimator::DEFAULT_SEMI_ANTI_SELECTIVITY;
-		return new_denom;
-	}
-	default:
-		// cross product
-		return new_denom;
-	}
-}
-
-DenomInfo CardinalityEstimator::GetDenominator(JoinRelationSet &set) {
-	vector<Subgraph2Denominator> subgraphs;
-
-	// Finding the denominator is tricky. You need to go through the tdoms in decreasing order
-	// Then loop through all filters in the equivalence set of the tdom to see if both the
-	// left and right relations are in the new set, if so you can use that filter.
-	// You must also make sure that the filters all relations in the given set, so we use subgraphs
-	// that should eventually merge into one connected graph that joins all the relations
-	// TODO: Implement a method to cache subgraphs so you don't have to build them up every
-	// time the cardinality of a new set is requested
-
-	// relations_to_tdoms has already been sorted by largest to smallest total domain
-	// then we look through the filters for the relations_to_tdoms,
-	// and we start to choose the filters that join relations in the set.
-
-	// edges are guaranteed to be in order of largest tdom to smallest tdom.
-	unordered_set<idx_t> unused_edge_tdoms;
-	auto edges = GetEdges(relations_to_tdoms, set);
-	for (auto &edge : edges) {
-		if (subgraphs.size() == 1 && subgraphs.at(0).relations->ToString() == set.ToString()) {
-			// the first subgraph has connected all the desired relations, just skip the rest of the edges
-			if (edge.has_tdom_hll) {
-				unused_edge_tdoms.insert(edge.tdom_hll);
-			}
-			continue;
-		}
-
-		auto subgraph_connections = SubgraphsConnectedByEdge(edge, subgraphs);
-		if (subgraph_connections.empty()) {
-			// create a subgraph out of left and right, then merge right into left and add left to subgraphs.
-			// this helps cover a case where there are no subgraphs yet, and the only join filter is a SEMI JOIN
-			auto left_subgraph = Subgraph2Denominator();
-			auto right_subgraph = Subgraph2Denominator();
-			left_subgraph.relations = edge.filter_info->left_set;
-			left_subgraph.numerator_relations = edge.filter_info->left_set;
-			right_subgraph.relations = edge.filter_info->right_set;
-			right_subgraph.numerator_relations = edge.filter_info->right_set;
-			left_subgraph.numerator_relations = &UpdateNumeratorRelations(left_subgraph, right_subgraph, edge);
-			left_subgraph.relations = edge.filter_info->set.get();
-			left_subgraph.denom = CalculateUpdatedDenom(left_subgraph, right_subgraph, edge);
-			subgraphs.push_back(left_subgraph);
-		} else if (subgraph_connections.size() == 1) {
-			auto left_subgraph = &subgraphs.at(subgraph_connections.at(0));
-			auto right_subgraph = Subgraph2Denominator();
-			right_subgraph.relations = edge.filter_info->right_set;
-			right_subgraph.numerator_relations = edge.filter_info->right_set;
-			if (JoinRelationSet::IsSubset(*left_subgraph->relations, *right_subgraph.relations)) {
-				right_subgraph.relations = edge.filter_info->left_set;
-				right_subgraph.numerator_relations = edge.filter_info->left_set;
-			}
-
-			if (JoinRelationSet::IsSubset(*left_subgraph->relations, *edge.filter_info->left_set) &&
-			    JoinRelationSet::IsSubset(*left_subgraph->relations, *edge.filter_info->right_set)) {
-				// here we have an edge that connects the same subgraph to the same subgraph. Just continue. no need to
-				// update the denom
-				continue;
-			}
-			left_subgraph->numerator_relations = &UpdateNumeratorRelations(*left_subgraph, right_subgraph, edge);
-			left_subgraph->relations = &set_manager.Union(*left_subgraph->relations, *right_subgraph.relations);
-			left_subgraph->denom = CalculateUpdatedDenom(*left_subgraph, right_subgraph, edge);
-		} else if (subgraph_connections.size() == 2) {
-			// The two subgraphs in the subgraph_connections can be merged by this edge.
-			D_ASSERT(subgraph_connections.at(0) < subgraph_connections.at(1));
-			auto subgraph_to_merge_into = &subgraphs.at(subgraph_connections.at(0));
-			auto subgraph_to_delete = &subgraphs.at(subgraph_connections.at(1));
-			subgraph_to_merge_into->relations =
-			    &set_manager.Union(*subgraph_to_merge_into->relations, *subgraph_to_delete->relations);
-			subgraph_to_merge_into->numerator_relations =
-			    &UpdateNumeratorRelations(*subgraph_to_merge_into, *subgraph_to_delete, edge);
-			subgraph_to_merge_into->denom = CalculateUpdatedDenom(*subgraph_to_merge_into, *subgraph_to_delete, edge);
-			subgraph_to_delete->relations = nullptr;
-			auto remove_start = std::remove_if(subgraphs.begin(), subgraphs.end(),
-			                                   [](Subgraph2Denominator &s) { return !s.relations; });
-			subgraphs.erase(remove_start, subgraphs.end());
-		}
-	}
-
-	// Slight penalty to cardinality for unused edges
-	auto denom_multiplier = 1.0 + static_cast<double>(unused_edge_tdoms.size());
-
-	// It's possible cross-products were added and are not present in the filters in the relation_2_tdom
-	// structures. When that's the case, merge all remaining subgraphs.
-	if (subgraphs.size() > 1) {
-		auto final_subgraph = subgraphs.at(0);
-		for (auto merge_with = subgraphs.begin() + 1; merge_with != subgraphs.end(); merge_with++) {
-			D_ASSERT(final_subgraph.relations && merge_with->relations);
-			final_subgraph.relations = &set_manager.Union(*final_subgraph.relations, *merge_with->relations);
-			D_ASSERT(final_subgraph.numerator_relations && merge_with->numerator_relations);
-			final_subgraph.numerator_relations =
-			    &set_manager.Union(*final_subgraph.numerator_relations, *merge_with->numerator_relations);
-			final_subgraph.denom *= merge_with->denom;
-		}
-	}
-	// can happen if a table has cardinality 0, a tdom is set to 0, or if a cross product is used.
-	if (subgraphs.empty() || subgraphs.at(0).denom == 0) {
-		// denominator is 1 and numerators are a cross product of cardinalities.
-		return DenomInfo(set, 1, 1);
-	}
-	return DenomInfo(*subgraphs.at(0).numerator_relations, 1, subgraphs.at(0).denom * denom_multiplier);
-}
-
-template <>
-double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) {
-
-	if (relation_set_2_cardinality.find(new_set.ToString()) != relation_set_2_cardinality.end()) {
-		return relation_set_2_cardinality[new_set.ToString()].cardinality_before_filters;
-	}
-
-	// can happen if a table has cardinality 0, or a tdom is set to 0
-	auto denom = GetDenominator(new_set);
-	auto numerator = GetNumerator(denom.numerator_relations);
-
-	double result = numerator / denom.denominator;
-	auto new_entry = CardinalityHelper(result);
-	relation_set_2_cardinality[new_set.ToString()] = new_entry;
-	return result;
-}
-
-template <>
-idx_t CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) {
-	auto cardinality_as_double = EstimateCardinalityWithSet<double>(new_set);
-	auto max = NumericLimits<idx_t>::Maximum();
-	if (cardinality_as_double >= (double)max) {
-		return max;
-	}
-	return (idx_t)cardinality_as_double;
-}
-
-bool SortTdoms(const RelationsToTDom &a, const RelationsToTDom &b) {
-	if (a.has_tdom_hll && b.has_tdom_hll) {
-		return a.tdom_hll > b.tdom_hll;
-	}
-	if (a.has_tdom_hll) {
-		return a.tdom_hll > b.tdom_no_hll;
-	}
-	if (b.has_tdom_hll) {
-		return a.tdom_no_hll > b.tdom_hll;
-	}
-	return a.tdom_no_hll > b.tdom_no_hll;
-}
-
-void CardinalityEstimator::InitCardinalityEstimatorProps(optional_ptr<JoinRelationSet> set, RelationStats &stats) {
-	// Get the join relation set
-	D_ASSERT(stats.stats_initialized);
-	auto relation_cardinality = stats.cardinality;
-
-	auto card_helper = CardinalityHelper((double)relation_cardinality);
-	relation_set_2_cardinality[set->ToString()] = card_helper;
-
-	UpdateTotalDomains(set, stats);
-
-	// sort relations from greatest tdom to lowest tdom.
-	std::sort(relations_to_tdoms.begin(), relations_to_tdoms.end(), SortTdoms);
-}
-
-void CardinalityEstimator::UpdateTotalDomains(optional_ptr<JoinRelationSet> set, RelationStats &stats) {
-	D_ASSERT(set->count == 1);
-	auto relation_id = set->relations[0];
-	//! Initialize the distinct count for all columns used in joins with the current relation.
-	//	D_ASSERT(stats.column_distinct_count.size() >= 1);
-
-	for (idx_t i = 0; i < stats.column_distinct_count.size(); i++) {
-		//! for every column used in a filter in the relation, get the distinct count via HLL, or assume it to be
-		//! the cardinality
-		// Update the relation_to_tdom set with the estimated distinct count (or tdom) calculated above
-		auto key = ColumnBinding(relation_id, i);
-		for (auto &relation_to_tdom : relations_to_tdoms) {
-			column_binding_set_t i_set = relation_to_tdom.equivalent_relations;
-			if (i_set.find(key) == i_set.end()) {
-				continue;
-			}
-			auto distinct_count = stats.column_distinct_count.at(i);
-			if (distinct_count.from_hll && relation_to_tdom.has_tdom_hll) {
-				relation_to_tdom.tdom_hll = MaxValue(relation_to_tdom.tdom_hll, distinct_count.distinct_count);
-			} else if (distinct_count.from_hll && !relation_to_tdom.has_tdom_hll) {
-				relation_to_tdom.has_tdom_hll = true;
-				relation_to_tdom.tdom_hll = distinct_count.distinct_count;
-			} else {
-				relation_to_tdom.tdom_no_hll = MinValue(distinct_count.distinct_count, relation_to_tdom.tdom_no_hll);
-			}
-			break;
-		}
-	}
-}
-
-// LCOV_EXCL_START
-
-void CardinalityEstimator::AddRelationNamesToTdoms(vector<RelationStats> &stats) {
-#ifdef DEBUG
-	for (auto &total_domain : relations_to_tdoms) {
-		for (auto &binding : total_domain.equivalent_relations) {
-			D_ASSERT(binding.table_index < stats.size());
-			string column_name;
-			if (binding.column_index < stats[binding.table_index].column_names.size()) {
-				column_name = stats[binding.table_index].column_names[binding.column_index];
-			} else {
-				column_name = "[unknown]";
-			}
-			total_domain.column_names.push_back(column_name);
-		}
-	}
-#endif
-}
-
-void CardinalityEstimator::PrintRelationToTdomInfo() {
-	for (auto &total_domain : relations_to_tdoms) {
-		string domain = "Following columns have the same distinct count: ";
-		for (auto &column_name : total_domain.column_names) {
-			domain += column_name + ", ";
-		}
-		bool have_hll = total_domain.has_tdom_hll;
-		domain += "\n TOTAL DOMAIN = " + to_string(have_hll ? total_domain.tdom_hll : total_domain.tdom_no_hll);
-		Printer::Print(domain);
-	}
-}
-
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/cost_model.cpp b/src/duckdb/src/optimizer/join_order/cost_model.cpp
deleted file mode 100644
index bfe64412f..000000000
--- a/src/duckdb/src/optimizer/join_order/cost_model.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
-#include "duckdb/optimizer/join_order/cost_model.hpp"
-
-namespace duckdb {
-
-CostModel::CostModel(QueryGraphManager &query_graph_manager)
-    : query_graph_manager(query_graph_manager), cardinality_estimator() {
-}
-
-double CostModel::ComputeCost(DPJoinNode &left, DPJoinNode &right) {
-	auto &combination = query_graph_manager.set_manager.Union(left.set, right.set);
-	auto join_card = cardinality_estimator.EstimateCardinalityWithSet<double>(combination);
-	auto join_cost = join_card;
-	return join_cost + left.cost + right.cost;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/join_node.cpp b/src/duckdb/src/optimizer/join_order/join_node.cpp
deleted file mode 100644
index 031f56ce2..000000000
--- a/src/duckdb/src/optimizer/join_order/join_node.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/optimizer/join_order/join_node.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/operator/list.hpp"
-
-namespace duckdb {
-
-DPJoinNode::DPJoinNode(JoinRelationSet &set) : set(set), info(nullptr), is_leaf(true), left_set(set), right_set(set) {
-}
-
-DPJoinNode::DPJoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinRelationSet &left,
-                       JoinRelationSet &right, double cost)
-    : set(set), info(info), is_leaf(false), left_set(left), right_set(right), cost(cost) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp b/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp
deleted file mode 100644
index e49798ac4..000000000
--- a/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
-
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/optimizer/join_order/cost_model.hpp"
-#include "duckdb/optimizer/join_order/plan_enumerator.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/operator/list.hpp"
-
-namespace duckdb {
-
-JoinOrderOptimizer::JoinOrderOptimizer(ClientContext &context) : context(context), query_graph_manager(context) {
-}
-
-JoinOrderOptimizer JoinOrderOptimizer::CreateChildOptimizer() {
-	JoinOrderOptimizer child_optimizer(context);
-	child_optimizer.materialized_cte_stats = materialized_cte_stats;
-	child_optimizer.delim_scan_stats = delim_scan_stats;
-	return child_optimizer;
-}
-
-unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOperator> plan,
-                                                         optional_ptr<RelationStats> stats) {
-
-	// make sure query graph manager has not extracted a relation graph already
-	LogicalOperator *op = plan.get();
-
-	// extract the relations that go into the hyper graph.
-	// We optimize the children of any non-reorderable operations we come across.
-	bool reorderable = query_graph_manager.Build(*this, *op);
-
-	// get relation_stats here since the reconstruction process will move all relations.
-	auto relation_stats = query_graph_manager.relation_manager.GetRelationStats();
-	unique_ptr<LogicalOperator> new_logical_plan = nullptr;
-
-	if (reorderable) {
-		// query graph now has filters and relations
-		auto cost_model = CostModel(query_graph_manager);
-
-		// Initialize a plan enumerator.
-		auto plan_enumerator =
-		    PlanEnumerator(query_graph_manager, cost_model, query_graph_manager.GetQueryGraphEdges());
-
-		// Initialize the leaf/single node plans
-		plan_enumerator.InitLeafPlans();
-		plan_enumerator.SolveJoinOrder();
-		// now reconstruct a logical plan from the query graph plan
-		query_graph_manager.plans = &plan_enumerator.GetPlans();
-
-		new_logical_plan = query_graph_manager.Reconstruct(std::move(plan));
-	} else {
-		new_logical_plan = std::move(plan);
-		if (relation_stats.size() == 1) {
-			new_logical_plan->estimated_cardinality = relation_stats.at(0).cardinality;
-			new_logical_plan->has_estimated_cardinality = true;
-		}
-	}
-
-	// Propagate up a stats object from the top of the new_logical_plan if stats exist.
-	if (stats) {
-		auto cardinality = new_logical_plan->EstimateCardinality(context);
-		auto bindings = new_logical_plan->GetColumnBindings();
-		auto new_stats = RelationStatisticsHelper::CombineStatsOfReorderableOperator(bindings, relation_stats);
-		new_stats.cardinality = cardinality;
-		RelationStatisticsHelper::CopyRelationStats(*stats, new_stats);
-	} else {
-		// starts recursively setting cardinality
-		new_logical_plan->EstimateCardinality(context);
-	}
-
-	if (new_logical_plan->type == LogicalOperatorType::LOGICAL_EXPLAIN) {
-		new_logical_plan->SetEstimatedCardinality(3);
-	}
-
-	return new_logical_plan;
-}
-
-void JoinOrderOptimizer::AddMaterializedCTEStats(idx_t index, RelationStats &&stats) {
-	materialized_cte_stats.emplace(index, std::move(stats));
-}
-
-RelationStats JoinOrderOptimizer::GetMaterializedCTEStats(idx_t index) {
-	auto it = materialized_cte_stats.find(index);
-	if (it == materialized_cte_stats.end()) {
-		throw InternalException("Unable to find materialized CTE stats with index %llu", index);
-	}
-	return it->second;
-}
-
-void JoinOrderOptimizer::AddDelimScanStats(RelationStats &stats) {
-	delim_scan_stats = &stats;
-}
-
-RelationStats JoinOrderOptimizer::GetDelimScanStats() {
-	if (!delim_scan_stats) {
-		throw InternalException("Unable to find delim scan stats!");
-	}
-	return *delim_scan_stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/join_relation_set.cpp b/src/duckdb/src/optimizer/join_order/join_relation_set.cpp
deleted file mode 100644
index aa5767427..000000000
--- a/src/duckdb/src/optimizer/join_order/join_relation_set.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-using JoinRelationTreeNode = JoinRelationSetManager::JoinRelationTreeNode;
-
-// LCOV_EXCL_START
-string JoinRelationSet::ToString() const {
-	string result = "[";
-	result += StringUtil::Join(relations, count, ", ", [](const idx_t &relation) { return to_string(relation); });
-	result += "]";
-	return result;
-}
-// LCOV_EXCL_STOP
-
-//! Returns true if sub is a subset of super
-bool JoinRelationSet::IsSubset(JoinRelationSet &super, JoinRelationSet &sub) {
-	D_ASSERT(sub.count > 0);
-	if (sub.count > super.count) {
-		return false;
-	}
-	idx_t j = 0;
-	for (idx_t i = 0; i < super.count; i++) {
-		if (sub.relations[j] == super.relations[i]) {
-			j++;
-			if (j == sub.count) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unsafe_unique_array<idx_t> relations, idx_t count) {
-	// now look it up in the tree
-	reference<JoinRelationTreeNode> info(root);
-	for (idx_t i = 0; i < count; i++) {
-		auto entry = info.get().children.find(relations[i]);
-		if (entry == info.get().children.end()) {
-			// node not found, create it
-			auto insert_it = info.get().children.insert(make_pair(relations[i], make_uniq<JoinRelationTreeNode>()));
-			entry = insert_it.first;
-		}
-		// move to the next node
-		info = *entry->second;
-	}
-	// now check if the JoinRelationSet has already been created
-	if (!info.get().relation) {
-		// if it hasn't we need to create it
-		info.get().relation = make_uniq<JoinRelationSet>(std::move(relations), count);
-	}
-	return *info.get().relation;
-}
-
-//! Create or get a JoinRelationSet from a single node with the given index
-JoinRelationSet &JoinRelationSetManager::GetJoinRelation(idx_t index) {
-	// create a sorted vector of the relations
-	auto relations = make_unsafe_uniq_array<idx_t>(1);
-	relations[0] = index;
-	idx_t count = 1;
-	return GetJoinRelation(std::move(relations), count);
-}
-
-JoinRelationSet &JoinRelationSetManager::GetJoinRelation(const unordered_set<idx_t> &bindings) {
-	// create a sorted vector of the relations
-	unsafe_unique_array<idx_t> relations = bindings.empty() ? nullptr : make_unsafe_uniq_array<idx_t>(bindings.size());
-	idx_t count = 0;
-	for (auto &entry : bindings) {
-		relations[count++] = entry;
-	}
-	std::sort(relations.get(), relations.get() + count);
-	return GetJoinRelation(std::move(relations), count);
-}
-
-JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelationSet &right) {
-	auto relations = make_unsafe_uniq_array<idx_t>(left.count + right.count);
-	idx_t count = 0;
-	// move through the left and right relations, eliminating duplicates
-	idx_t i = 0, j = 0;
-	while (true) {
-		if (i == left.count) {
-			// exhausted left relation, add remaining of right relation
-			for (; j < right.count; j++) {
-				relations[count++] = right.relations[j];
-			}
-			break;
-		} else if (j == right.count) {
-			// exhausted right relation, add remaining of left
-			for (; i < left.count; i++) {
-				relations[count++] = left.relations[i];
-			}
-			break;
-		} else if (left.relations[i] < right.relations[j]) {
-			// left is smaller, progress left and add it to the set
-			relations[count++] = left.relations[i];
-			i++;
-		} else if (left.relations[i] > right.relations[j]) {
-			// right is smaller, progress right and add it to the set
-			relations[count++] = right.relations[j];
-			j++;
-		} else {
-			D_ASSERT(left.relations[i] == right.relations[j]);
-			relations[count++] = left.relations[i];
-			i++;
-			j++;
-		}
-	}
-	return GetJoinRelation(std::move(relations), count);
-}
-
-// JoinRelationSet *JoinRelationSetManager::Difference(JoinRelationSet *left, JoinRelationSet *right) {
-// 	auto relations = unsafe_unique_array<idx_t>(new idx_t[left->count]);
-// 	idx_t count = 0;
-// 	// move through the left and right relations
-// 	idx_t i = 0, j = 0;
-// 	while (true) {
-// 		if (i == left->count) {
-// 			// exhausted left relation, we are done
-// 			break;
-// 		} else if (j == right->count) {
-// 			// exhausted right relation, add remaining of left
-// 			for (; i < left->count; i++) {
-// 				relations[count++] = left->relations[i];
-// 			}
-// 			break;
-// 		} else if (left->relations[i] == right->relations[j]) {
-// 			// equivalent, add nothing
-// 			i++;
-// 			j++;
-// 		} else if (left->relations[i] < right->relations[j]) {
-// 			// left is smaller, progress left and add it to the set
-// 			relations[count++] = left->relations[i];
-// 			i++;
-// 		} else {
-// 			// right is smaller, progress right
-// 			j++;
-// 		}
-// 	}
-// 	return GetJoinRelation(std::move(relations), count);
-// }
-
-static string JoinRelationTreeNodeToString(const JoinRelationTreeNode *node) {
-	string result = "";
-	if (node->relation) {
-		result += node->relation.get()->ToString() + "\n";
-	}
-	for (auto &child : node->children) {
-		result += JoinRelationTreeNodeToString(child.second.get());
-	}
-	return result;
-}
-
-string JoinRelationSetManager::ToString() const {
-	return JoinRelationTreeNodeToString(&root);
-}
-
-void JoinRelationSetManager::Print() {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp b/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp
deleted file mode 100644
index 04b396b97..000000000
--- a/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp
+++ /dev/null
@@ -1,504 +0,0 @@
-#include "duckdb/optimizer/join_order/plan_enumerator.hpp"
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/optimizer/join_order/query_graph_manager.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-static vector<unordered_set<idx_t>> AddSuperSets(const vector<unordered_set<idx_t>> &current,
-                                                 const vector<idx_t> &all_neighbors) {
-	vector<unordered_set<idx_t>> ret;
-
-	for (const auto &neighbor_set : current) {
-		auto max_val = std::max_element(neighbor_set.begin(), neighbor_set.end());
-		for (const auto &neighbor : all_neighbors) {
-			if (*max_val >= neighbor) {
-				continue;
-			}
-			if (neighbor_set.count(neighbor) == 0) {
-				unordered_set<idx_t> new_set;
-				for (auto &n : neighbor_set) {
-					new_set.insert(n);
-				}
-				new_set.insert(neighbor);
-				ret.push_back(new_set);
-			}
-		}
-	}
-
-	return ret;
-}
-
-//! Update the exclusion set with all entries in the subgraph
-static void UpdateExclusionSet(optional_ptr<JoinRelationSet> node, unordered_set<idx_t> &exclusion_set) {
-	for (idx_t i = 0; i < node->count; i++) {
-		exclusion_set.insert(node->relations[i]);
-	}
-}
-
-// works by first creating all sets with cardinality 1
-// then iterates over each previously created group of subsets and will only add a neighbor if the neighbor
-// is greater than all relations in the set.
-static vector<unordered_set<idx_t>> GetAllNeighborSets(vector<idx_t> neighbors) {
-	vector<unordered_set<idx_t>> ret;
-	sort(neighbors.begin(), neighbors.end());
-	vector<unordered_set<idx_t>> added;
-	for (auto &neighbor : neighbors) {
-		added.push_back(unordered_set<idx_t>({neighbor}));
-		ret.push_back(unordered_set<idx_t>({neighbor}));
-	}
-	do {
-		added = AddSuperSets(added, neighbors);
-		for (auto &d : added) {
-			ret.push_back(d);
-		}
-	} while (!added.empty());
-#if DEBUG
-	// drive by test to make sure we have an accurate amount of
-	// subsets, and that each neighbor is in a correct amount
-	// of those subsets.
-	D_ASSERT(ret.size() == std::pow(2, neighbors.size()) - 1);
-	for (auto &n : neighbors) {
-		idx_t count = 0;
-		for (auto &set : ret) {
-			if (set.count(n) >= 1) {
-				count += 1;
-			}
-		}
-		D_ASSERT(count == std::pow(2, neighbors.size() - 1));
-	}
-#endif
-	return ret;
-}
-
-void PlanEnumerator::GenerateCrossProducts() {
-	// generate a set of cross products to combine the currently available plans into a full join plan
-	// we create edges between every relation with a high cost
-	for (idx_t i = 0; i < query_graph_manager.relation_manager.NumRelations(); i++) {
-		auto &left = query_graph_manager.set_manager.GetJoinRelation(i);
-		for (idx_t j = 0; j < query_graph_manager.relation_manager.NumRelations(); j++) {
-			auto cross_product_allowed = query_graph_manager.relation_manager.CrossProductWithRelationAllowed(i) &&
-			                             query_graph_manager.relation_manager.CrossProductWithRelationAllowed(j);
-			if (i != j && cross_product_allowed) {
-				auto &right = query_graph_manager.set_manager.GetJoinRelation(j);
-				query_graph_manager.CreateQueryGraphCrossProduct(left, right);
-			}
-		}
-	}
-	// Now that the query graph has new edges, we need to re-initialize our query graph.
-	// TODO: do we need to initialize our qyery graph again?
-	// query_graph = query_graph_manager.GetQueryGraph();
-}
-
-const reference_map_t<JoinRelationSet, unique_ptr<DPJoinNode>> &PlanEnumerator::GetPlans() const {
-	return plans;
-}
-
-//! Create a new JoinTree node by joining together two previous JoinTree nodes
-unique_ptr<DPJoinNode> PlanEnumerator::CreateJoinTree(JoinRelationSet &set,
-                                                      const vector<reference<NeighborInfo>> &possible_connections,
-                                                      DPJoinNode &left, DPJoinNode &right) {
-
-	// FIXME: should consider different join algorithms, should we pick a join algorithm here as well? (probably)
-	optional_ptr<NeighborInfo> best_connection = possible_connections.back().get();
-	// cross products are technically still connections, but the filter expression is a null_ptr
-	bool found_non_cross_product_connection = false;
-	for (auto &connection : possible_connections) {
-		for (auto &filter : connection.get().filters) {
-			if (filter->join_type != JoinType::INVALID) {
-				best_connection = connection.get();
-				found_non_cross_product_connection = true;
-				break;
-			}
-		}
-		if (found_non_cross_product_connection) {
-			break;
-		}
-	}
-	auto join_type = JoinType::INVALID;
-	for (auto &filter_binding : best_connection->filters) {
-		if (!filter_binding->left_set || !filter_binding->right_set) {
-			continue;
-		}
-
-		join_type = filter_binding->join_type;
-		// prefer joining on semi and anti joins as they have a higher chance of being more
-		// selective
-		if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-			break;
-		}
-	}
-	// need the filter info from the Neighborhood info.
-	auto cost = cost_model.ComputeCost(left, right);
-	auto result = make_uniq<DPJoinNode>(set, best_connection, left.set, right.set, cost);
-	result->cardinality = cost_model.cardinality_estimator.EstimateCardinalityWithSet<idx_t>(set);
-	return result;
-}
-
-DPJoinNode &PlanEnumerator::EmitPair(JoinRelationSet &left, JoinRelationSet &right,
-                                     const vector<reference<NeighborInfo>> &info) {
-	// get the left and right join plans
-	auto left_plan = plans.find(left);
-	auto right_plan = plans.find(right);
-	if (left_plan == plans.end() || right_plan == plans.end()) {
-		throw InternalException("No left or right plan: internal error in join order optimizer");
-	}
-	auto &new_set = query_graph_manager.set_manager.Union(left, right);
-	// create the join tree based on combining the two plans
-	auto new_plan = CreateJoinTree(new_set, info, *left_plan->second, *right_plan->second);
-	// check if this plan is the optimal plan we found for this set of relations
-	auto entry = plans.find(new_set);
-	auto new_cost = new_plan->cost;
-	double old_cost = NumericLimits<double>::Maximum();
-	if (entry != plans.end()) {
-		old_cost = entry->second->cost;
-	}
-	if (entry == plans.end() || new_cost < old_cost) {
-		// the new plan costs less than the old plan. Update our DP table.
-		plans[new_set] = std::move(new_plan);
-		return *plans[new_set];
-	}
-	// Create join node from the plan currently in the DP table.
-	return *entry->second;
-}
-
-bool PlanEnumerator::TryEmitPair(JoinRelationSet &left, JoinRelationSet &right,
-                                 const vector<reference<NeighborInfo>> &info) {
-	pairs++;
-	// If a full plan is created, it's possible a node in the plan gets updated. When this happens, make sure you keep
-	// emitting pairs until you emit another final plan. Another final plan is guaranteed to be produced because of
-	// our symmetry guarantees.
-	if (pairs >= 10000) {
-		// when the amount of pairs gets too large we exit the dynamic programming and resort to a greedy algorithm
-		// FIXME: simple heuristic currently
-		// at 10K pairs stop searching exactly and switch to heuristic
-		return false;
-	}
-	EmitPair(left, right, info);
-	return true;
-}
-
-bool PlanEnumerator::EmitCSG(JoinRelationSet &node) {
-	if (node.count == query_graph_manager.relation_manager.NumRelations()) {
-		return true;
-	}
-	// create the exclusion set as everything inside the subgraph AND anything with members BELOW it
-	unordered_set<idx_t> exclusion_set;
-	for (idx_t i = 0; i < node.relations[0]; i++) {
-		exclusion_set.insert(i);
-	}
-	UpdateExclusionSet(&node, exclusion_set);
-	// find the neighbors given this exclusion set
-	auto neighbors = query_graph.GetNeighbors(node, exclusion_set);
-	if (neighbors.empty()) {
-		return true;
-	}
-
-	//! Neighbors should be reversed when iterating over them.
-	std::sort(neighbors.begin(), neighbors.end(), std::greater<idx_t>());
-	for (idx_t i = 0; i < neighbors.size() - 1; i++) {
-		D_ASSERT(neighbors[i] > neighbors[i + 1]);
-	}
-
-	// Dphyp paper missing this.
-	// Because we are traversing in reverse order, we need to add neighbors whose number is smaller than the current
-	// node to exclusion_set
-	// This avoids duplicated enumeration
-	unordered_set<idx_t> new_exclusion_set = exclusion_set;
-	for (idx_t i = 0; i < neighbors.size(); ++i) {
-		D_ASSERT(new_exclusion_set.find(neighbors[i]) == new_exclusion_set.end());
-		new_exclusion_set.insert(neighbors[i]);
-	}
-
-	for (auto neighbor : neighbors) {
-		// since the GetNeighbors only returns the smallest element in a list, the entry might not be connected to
-		// (only!) this neighbor,  hence we have to do a connectedness check before we can emit it
-		auto &neighbor_relation = query_graph_manager.set_manager.GetJoinRelation(neighbor);
-		auto connections = query_graph.GetConnections(node, neighbor_relation);
-		if (!connections.empty()) {
-			if (!TryEmitPair(node, neighbor_relation, connections)) {
-				return false;
-			}
-		}
-
-		if (!EnumerateCmpRecursive(node, neighbor_relation, new_exclusion_set)) {
-			return false;
-		}
-
-		new_exclusion_set.erase(neighbor);
-	}
-	return true;
-}
-
-bool PlanEnumerator::EnumerateCmpRecursive(JoinRelationSet &left, JoinRelationSet &right,
-                                           unordered_set<idx_t> &exclusion_set) {
-	// get the neighbors of the second relation under the exclusion set
-	auto neighbors = query_graph.GetNeighbors(right, exclusion_set);
-	if (neighbors.empty()) {
-		return true;
-	}
-
-	auto all_subset = GetAllNeighborSets(neighbors);
-	vector<reference<JoinRelationSet>> union_sets;
-	union_sets.reserve(all_subset.size());
-	for (const auto &rel_set : all_subset) {
-		auto &neighbor = query_graph_manager.set_manager.GetJoinRelation(rel_set);
-		// emit the combinations of this node and its neighbors
-		auto &combined_set = query_graph_manager.set_manager.Union(right, neighbor);
-		// If combined_set.count == right.count, This means we found a neighbor that has been present before
-		// This means we didn't set exclusion_set correctly.
-		D_ASSERT(combined_set.count > right.count);
-		if (plans.find(combined_set) != plans.end()) {
-			auto connections = query_graph.GetConnections(left, combined_set);
-			if (!connections.empty()) {
-				if (!TryEmitPair(left, combined_set, connections)) {
-					return false;
-				}
-			}
-		}
-		union_sets.push_back(combined_set);
-	}
-
-	unordered_set<idx_t> new_exclusion_set = exclusion_set;
-	for (const auto &neighbor : neighbors) {
-		new_exclusion_set.insert(neighbor);
-	}
-
-	// recursively enumerate the sets
-	for (idx_t i = 0; i < union_sets.size(); i++) {
-		// updated the set of excluded entries with this neighbor
-		if (!EnumerateCmpRecursive(left, union_sets[i], new_exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool PlanEnumerator::EnumerateCSGRecursive(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) {
-	// find neighbors of S under the exclusion set
-	auto neighbors = query_graph.GetNeighbors(node, exclusion_set);
-	if (neighbors.empty()) {
-		return true;
-	}
-
-	auto all_subset = GetAllNeighborSets(neighbors);
-	vector<reference<JoinRelationSet>> union_sets;
-	union_sets.reserve(all_subset.size());
-	for (const auto &rel_set : all_subset) {
-		auto &neighbor = query_graph_manager.set_manager.GetJoinRelation(rel_set);
-		// emit the combinations of this node and its neighbors
-		auto &new_set = query_graph_manager.set_manager.Union(node, neighbor);
-		D_ASSERT(new_set.count > node.count);
-		if (plans.find(new_set) != plans.end()) {
-			if (!EmitCSG(new_set)) {
-				return false;
-			}
-		}
-		union_sets.push_back(new_set);
-	}
-
-	unordered_set<idx_t> new_exclusion_set = exclusion_set;
-	for (const auto &neighbor : neighbors) {
-		new_exclusion_set.insert(neighbor);
-	}
-
-	// recursively enumerate the sets
-	for (idx_t i = 0; i < union_sets.size(); i++) {
-		// updated the set of excluded entries with this neighbor
-		if (!EnumerateCSGRecursive(union_sets[i], new_exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool PlanEnumerator::SolveJoinOrderExactly() {
-	// now we perform the actual dynamic programming to compute the final result
-	// we enumerate over all the possible pairs in the neighborhood
-	for (idx_t i = query_graph_manager.relation_manager.NumRelations(); i > 0; i--) {
-		// for every node in the set, we consider it as the start node once
-		auto &start_node = query_graph_manager.set_manager.GetJoinRelation(i - 1);
-		// emit the start node
-		if (!EmitCSG(start_node)) {
-			return false;
-		}
-		// initialize the set of exclusion_set as all the nodes with a number below this
-		unordered_set<idx_t> exclusion_set;
-		for (idx_t j = 0; j < i; j++) {
-			exclusion_set.insert(j);
-		}
-		// then we recursively search for neighbors that do not belong to the banned entries
-		if (!EnumerateCSGRecursive(start_node, exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void PlanEnumerator::SolveJoinOrderApproximately() {
-	// at this point, we exited the dynamic programming but did not compute the final join order because it took too
-	// long instead, we use a greedy heuristic to obtain a join ordering now we use Greedy Operator Ordering to
-	// construct the result tree first we start out with all the base relations (the to-be-joined relations)
-	vector<reference<JoinRelationSet>> join_relations; // T in the paper
-	for (idx_t i = 0; i < query_graph_manager.relation_manager.NumRelations(); i++) {
-		join_relations.push_back(query_graph_manager.set_manager.GetJoinRelation(i));
-	}
-	while (join_relations.size() > 1) {
-		// now in every step of the algorithm, we greedily pick the join between the to-be-joined relations that has the
-		// smallest cost. This is O(r^2) per step, and every step will reduce the total amount of relations to-be-joined
-		// by 1, so the total cost is O(r^3) in the amount of relations
-		// long is needed to prevent clang-tidy complaints. (idx_t) cannot be added to an iterator position because it
-		// is unsigned.
-		idx_t best_left = 0, best_right = 0;
-		optional_ptr<DPJoinNode> best_connection;
-		for (idx_t i = 0; i < join_relations.size(); i++) {
-			auto left = join_relations[i];
-			for (idx_t j = i + 1; j < join_relations.size(); j++) {
-				auto right = join_relations[j];
-				// check if we can connect these two relations
-				auto connection = query_graph.GetConnections(left, right);
-				if (!connection.empty()) {
-					// we can check the cost of this connection
-					auto node = EmitPair(left, right, connection);
-
-					// update the DP tree in case a plan created by the DP algorithm uses the node
-					// that was potentially just updated by EmitPair. You will get a use-after-free
-					// error if future plans rely on the old node that was just replaced.
-					// if node in FullPath, then updateDP tree.
-
-					if (!best_connection || node.cost < best_connection->cost) {
-						// best pair found so far
-						best_connection = &EmitPair(left, right, connection);
-						best_left = i;
-						best_right = j;
-					}
-				}
-			}
-		}
-		if (!best_connection) {
-			// could not find a connection, but we were not done with finding a completed plan
-			// we have to add a cross product; we add it between the two smallest relations
-			optional_ptr<DPJoinNode> smallest_plans[2];
-			size_t smallest_index[2];
-			D_ASSERT(join_relations.size() >= 2);
-
-			// first just add the first two join relations. It doesn't matter the cost as the JOO
-			// will swap them on estimated cardinality anyway.
-			for (idx_t i = 0; i < 2; i++) {
-				optional_ptr<DPJoinNode> current_plan = plans[join_relations[i]];
-				smallest_plans[i] = current_plan;
-				smallest_index[i] = i;
-			}
-
-			// if there are any other join relations that don't have connections
-			// add them if they have lower estimated cardinality.
-			for (idx_t i = 2; i < join_relations.size(); i++) {
-				// get the plan for this relation
-				optional_ptr<DPJoinNode> current_plan = plans[join_relations[i]];
-				// check if the cardinality is smaller than the smallest two found so far
-				for (idx_t j = 0; j < 2; j++) {
-					if (!smallest_plans[j] || smallest_plans[j]->cost > current_plan->cost) {
-						smallest_plans[j] = current_plan;
-						smallest_index[j] = i;
-						break;
-					}
-				}
-			}
-			if (!smallest_plans[0] || !smallest_plans[1]) {
-				throw InternalException("Internal error in join order optimizer");
-			}
-			D_ASSERT(smallest_plans[0] && smallest_plans[1]);
-			D_ASSERT(smallest_index[0] != smallest_index[1]);
-			auto &left = smallest_plans[0]->set;
-			auto &right = smallest_plans[1]->set;
-			// create a cross product edge (i.e. edge with empty filter) between these two sets in the query graph
-			query_graph_manager.CreateQueryGraphCrossProduct(left, right);
-			// now emit the pair and continue with the algorithm
-			auto connections = query_graph.GetConnections(left, right);
-			D_ASSERT(!connections.empty());
-
-			best_connection = &EmitPair(left, right, connections);
-			best_left = smallest_index[0];
-			best_right = smallest_index[1];
-
-			// the code below assumes best_right > best_left
-			if (best_left > best_right) {
-				std::swap(best_left, best_right);
-			}
-		}
-		// now update the to-be-checked pairs
-		// remove left and right, and add the combination
-
-		// important to erase the biggest element first
-		// if we erase the smallest element first the index of the biggest element changes
-		auto &new_set = query_graph_manager.set_manager.Union(join_relations.at(best_left).get(),
-		                                                      join_relations.at(best_right).get());
-		D_ASSERT(best_right > best_left);
-		join_relations.erase(join_relations.begin() + (int64_t)best_right);
-		join_relations.erase(join_relations.begin() + (int64_t)best_left);
-		join_relations.push_back(new_set);
-	}
-}
-
-void PlanEnumerator::InitLeafPlans() {
-	// First we initialize each of the single-node plans with themselves and with their cardinalities these are the leaf
-	// nodes of the join tree NOTE: we can just use pointers to JoinRelationSet* here because the GetJoinRelation
-	// function ensures that a unique combination of relations will have a unique JoinRelationSet object.
-	// first initialize equivalent relations based on the filters
-	auto relation_stats = query_graph_manager.relation_manager.GetRelationStats();
-
-	cost_model.cardinality_estimator.InitEquivalentRelations(query_graph_manager.GetFilterBindings());
-	cost_model.cardinality_estimator.AddRelationNamesToTdoms(relation_stats);
-
-	// then update the total domains based on the cardinalities of each relation.
-	for (idx_t i = 0; i < relation_stats.size(); i++) {
-		auto stats = relation_stats.at(i);
-		auto &relation_set = query_graph_manager.set_manager.GetJoinRelation(i);
-		auto join_node = make_uniq<DPJoinNode>(relation_set);
-		join_node->cost = 0;
-		join_node->cardinality = stats.cardinality;
-		D_ASSERT(join_node->set.count == 1);
-		plans[relation_set] = std::move(join_node);
-		cost_model.cardinality_estimator.InitCardinalityEstimatorProps(&relation_set, stats);
-	}
-}
-
-// the plan enumeration is a straight implementation of the paper "Dynamic Programming Strikes Back" by Guido
-// Moerkotte and Thomas Neumannn, see that paper for additional info/documentation bonus slides:
-// https://db.in.tum.de/teaching/ws1415/queryopt/chapter3.pdf?lang=de
-void PlanEnumerator::SolveJoinOrder() {
-	bool force_no_cross_product = query_graph_manager.context.config.force_no_cross_product;
-	// first try to solve the join order exactly
-	if (query_graph_manager.relation_manager.NumRelations() >= THRESHOLD_TO_SWAP_TO_APPROXIMATE) {
-		SolveJoinOrderApproximately();
-	} else if (!SolveJoinOrderExactly()) {
-		// otherwise, if that times out we resort to a greedy algorithm
-		SolveJoinOrderApproximately();
-	}
-
-	// now the optimal join path should have been found
-	// get it from the node
-	unordered_set<idx_t> bindings;
-	for (idx_t i = 0; i < query_graph_manager.relation_manager.NumRelations(); i++) {
-		bindings.insert(i);
-	}
-	auto &total_relation = query_graph_manager.set_manager.GetJoinRelation(bindings);
-	auto final_plan = plans.find(total_relation);
-	if (final_plan == plans.end()) {
-		// could not find the final plan
-		// this should only happen in case the sets are actually disjunct
-		// in this case we need to generate cross product to connect the disjoint sets
-		if (force_no_cross_product) {
-			throw InvalidInputException(
-			    "Query requires a cross-product, but 'force_no_cross_product' PRAGMA is enabled");
-		}
-		GenerateCrossProducts();
-		//! solve the join order again, returning the final plan
-		return SolveJoinOrder();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/query_graph.cpp b/src/duckdb/src/optimizer/join_order/query_graph.cpp
deleted file mode 100644
index beb9e1521..000000000
--- a/src/duckdb/src/optimizer/join_order/query_graph.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "duckdb/optimizer/join_order/query_graph.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/assert.hpp"
-
-namespace duckdb {
-
-using QueryEdge = QueryGraphEdges::QueryEdge;
-
-// LCOV_EXCL_START
-static string QueryEdgeToString(const QueryEdge *info, vector<idx_t> prefix) {
-	string result = "";
-	string source = "[";
-	for (idx_t i = 0; i < prefix.size(); i++) {
-		source += to_string(prefix[i]) + (i < prefix.size() - 1 ? ", " : "");
-	}
-	source += "]";
-	for (auto &entry : info->neighbors) {
-		result += StringUtil::Format("%s -> %s\n", source.c_str(), entry->neighbor->ToString().c_str());
-	}
-	for (auto &entry : info->children) {
-		vector<idx_t> new_prefix = prefix;
-		new_prefix.push_back(entry.first);
-		result += QueryEdgeToString(entry.second.get(), new_prefix);
-	}
-	return result;
-}
-
-string QueryGraphEdges::ToString() const {
-	return QueryEdgeToString(&root, {});
-}
-
-void QueryGraphEdges::Print() {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-optional_ptr<QueryEdge> QueryGraphEdges::GetQueryEdge(JoinRelationSet &left) {
-	D_ASSERT(left.count > 0);
-	// find the EdgeInfo corresponding to the left set
-	optional_ptr<QueryEdge> info(&root);
-	for (idx_t i = 0; i < left.count; i++) {
-		auto entry = info.get()->children.find(left.relations[i]);
-		if (entry == info.get()->children.end()) {
-			// node not found, create it
-			auto insert_it = info.get()->children.insert(make_pair(left.relations[i], make_uniq<QueryEdge>()));
-			entry = insert_it.first;
-		}
-		// move to the next node
-		info = entry->second;
-	}
-	return info;
-}
-
-void QueryGraphEdges::CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> filter_info) {
-	D_ASSERT(left.count > 0 && right.count > 0);
-	// find the EdgeInfo corresponding to the left set
-	auto info = GetQueryEdge(left);
-	// now insert the edge to the right relation, if it does not exist
-	for (idx_t i = 0; i < info->neighbors.size(); i++) {
-		if (info->neighbors[i]->neighbor == &right) {
-			if (filter_info) {
-				// neighbor already exists just add the filter, if we have any
-				info->neighbors[i]->filters.push_back(filter_info);
-			}
-			return;
-		}
-	}
-	// neighbor does not exist, create it
-	auto n = make_uniq<NeighborInfo>(&right);
-	// if the edge represents a cross product, filter_info is null. The easiest way then to determine
-	// if an edge is for a cross product is if the filters are empty
-	if (info && filter_info) {
-		n->filters.push_back(filter_info);
-	}
-	info->neighbors.push_back(std::move(n));
-}
-
-void QueryGraphEdges::EnumerateNeighborsDFS(JoinRelationSet &node, reference<QueryEdge> info, idx_t index,
-                                            const std::function<bool(NeighborInfo &)> &callback) const {
-
-	for (auto &neighbor : info.get().neighbors) {
-		if (callback(*neighbor)) {
-			return;
-		}
-	}
-
-	for (idx_t node_index = index; node_index < node.count; ++node_index) {
-		auto iter = info.get().children.find(node.relations[node_index]);
-		if (iter != info.get().children.end()) {
-			reference<QueryEdge> new_info = *iter->second;
-			EnumerateNeighborsDFS(node, new_info, node_index + 1, callback);
-		}
-	}
-}
-
-void QueryGraphEdges::EnumerateNeighbors(JoinRelationSet &node,
-                                         const std::function<bool(NeighborInfo &)> &callback) const {
-	for (idx_t j = 0; j < node.count; j++) {
-		auto iter = root.children.find(node.relations[j]);
-		if (iter != root.children.end()) {
-			reference<QueryEdge> new_info = *iter->second;
-			EnumerateNeighborsDFS(node, new_info, j + 1, callback);
-		}
-	}
-}
-
-//! Returns true if a JoinRelationSet is banned by the list of exclusion_set, false otherwise
-static bool JoinRelationSetIsExcluded(optional_ptr<JoinRelationSet> node, unordered_set<idx_t> &exclusion_set) {
-	return exclusion_set.find(node->relations[0]) != exclusion_set.end();
-}
-
-const vector<idx_t> QueryGraphEdges::GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) const {
-	unordered_set<idx_t> result;
-	EnumerateNeighbors(node, [&](NeighborInfo &info) -> bool {
-		if (!JoinRelationSetIsExcluded(info.neighbor, exclusion_set)) {
-			// add the smallest node of the neighbor to the set
-			result.insert(info.neighbor->relations[0]);
-		}
-		return false;
-	});
-	vector<idx_t> neighbors;
-	neighbors.insert(neighbors.end(), result.begin(), result.end());
-	return neighbors;
-}
-
-const vector<reference<NeighborInfo>> QueryGraphEdges::GetConnections(JoinRelationSet &node,
-                                                                      JoinRelationSet &other) const {
-	vector<reference<NeighborInfo>> connections;
-	EnumerateNeighbors(node, [&](NeighborInfo &info) -> bool {
-		if (JoinRelationSet::IsSubset(other, *info.neighbor)) {
-			connections.push_back(info);
-		}
-		return false;
-	});
-	return connections;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp b/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp
deleted file mode 100644
index 6850508a6..000000000
--- a/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp
+++ /dev/null
@@ -1,415 +0,0 @@
-#include "duckdb/optimizer/join_order/query_graph_manager.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/optimizer/join_order/join_relation.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator/list.hpp"
-
-namespace duckdb {
-
-//! Returns true if A and B are disjoint, false otherwise
-template <class T>
-static bool Disjoint(const unordered_set<T> &a, const unordered_set<T> &b) {
-	return std::all_of(a.begin(), a.end(), [&b](typename std::unordered_set<T>::const_reference entry) {
-		return b.find(entry) == b.end();
-	});
-}
-
-bool QueryGraphManager::Build(JoinOrderOptimizer &optimizer, LogicalOperator &op) {
-	// have the relation manager extract the join relations and create a reference list of all the
-	// filter operators.
-	auto can_reorder = relation_manager.ExtractJoinRelations(optimizer, op, filter_operators);
-	auto num_relations = relation_manager.NumRelations();
-	if (num_relations <= 1 || !can_reorder) {
-		// nothing to optimize/reorder
-		return false;
-	}
-	// extract the edges of the hypergraph, creating a list of filters and their associated bindings.
-	filters_and_bindings = relation_manager.ExtractEdges(op, filter_operators, set_manager);
-	// Create the query_graph hyper edges
-	CreateHyperGraphEdges();
-	return true;
-}
-
-void QueryGraphManager::GetColumnBinding(Expression &expression, ColumnBinding &binding) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		// Here you have a filter on a single column in a table. Return a binding for the column
-		// being filtered on so the filter estimator knows what HLL count to pull
-		auto &colref = expression.Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.depth == 0);
-		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
-		// map the base table index to the relation index used by the JoinOrderOptimizer
-		D_ASSERT(relation_manager.relation_mapping.find(colref.binding.table_index) !=
-		         relation_manager.relation_mapping.end());
-		binding =
-		    ColumnBinding(relation_manager.relation_mapping[colref.binding.table_index], colref.binding.column_index);
-	}
-	// TODO: handle inequality filters with functions.
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &expr) { GetColumnBinding(expr, binding); });
-}
-
-const vector<unique_ptr<FilterInfo>> &QueryGraphManager::GetFilterBindings() const {
-	return filters_and_bindings;
-}
-
-void FilterInfo::SetLeftSet(optional_ptr<JoinRelationSet> left_set_new) {
-	left_set = left_set_new;
-}
-
-void FilterInfo::SetRightSet(optional_ptr<JoinRelationSet> right_set_new) {
-	right_set = right_set_new;
-}
-
-static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node, unique_ptr<Expression> expr) {
-	// push an expression into a filter
-	// first check if we have any filter to push it into
-	if (node->type != LogicalOperatorType::LOGICAL_FILTER) {
-		// we don't, we need to create one
-		auto filter = make_uniq<LogicalFilter>();
-		filter->children.push_back(std::move(node));
-		node = std::move(filter);
-	}
-	// push the filter into the LogicalFilter
-	D_ASSERT(node->type == LogicalOperatorType::LOGICAL_FILTER);
-	auto &filter = node->Cast<LogicalFilter>();
-	filter.expressions.push_back(std::move(expr));
-	return node;
-}
-
-void QueryGraphManager::CreateHyperGraphEdges() {
-	// create potential edges from the comparisons
-	for (auto &filter_info : filters_and_bindings) {
-		auto &filter = filter_info->filter;
-		// now check if it can be used as a join predicate
-		if (filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-			auto &comparison = filter->Cast<BoundComparisonExpression>();
-			// extract the bindings that are required for the left and right side of the comparison
-			unordered_set<idx_t> left_bindings, right_bindings;
-			relation_manager.ExtractBindings(*comparison.left, left_bindings);
-			relation_manager.ExtractBindings(*comparison.right, right_bindings);
-			GetColumnBinding(*comparison.left, filter_info->left_binding);
-			GetColumnBinding(*comparison.right, filter_info->right_binding);
-			if (!left_bindings.empty() && !right_bindings.empty()) {
-				// both the left and the right side have bindings
-				// first create the relation sets, if they do not exist
-				if (!filter_info->left_set) {
-					filter_info->left_set = &set_manager.GetJoinRelation(left_bindings);
-				}
-				if (!filter_info->right_set) {
-					filter_info->right_set = &set_manager.GetJoinRelation(right_bindings);
-				}
-				// we can only create a meaningful edge if the sets are not exactly the same
-				if (filter_info->left_set != filter_info->right_set) {
-					// check if the sets are disjoint
-					if (Disjoint(left_bindings, right_bindings)) {
-						// they are disjoint, we only need to create one set of edges in the join graph
-						query_graph.CreateEdge(*filter_info->left_set, *filter_info->right_set, filter_info);
-						query_graph.CreateEdge(*filter_info->right_set, *filter_info->left_set, filter_info);
-					}
-				}
-			}
-		} else if (filter->GetExpressionClass() == ExpressionClass::BOUND_CONJUNCTION) {
-			auto &conjunction = filter->Cast<BoundConjunctionExpression>();
-			if (conjunction.GetExpressionType() == ExpressionType::CONJUNCTION_OR ||
-			    filter_info->join_type == JoinType::INNER || filter_info->join_type == JoinType::INVALID) {
-				// Currently we do not interpret Conjunction expressions as INNER joins
-				// for hyper graph edges. These are most likely OR conjunctions, and
-				// will be pushed down into a join later in the optimizer.
-				// Conjunction filters are mostly to help plan semi and anti joins at the moment.
-				continue;
-			}
-			unordered_set<idx_t> left_bindings, right_bindings;
-			D_ASSERT(filter_info->left_set);
-			D_ASSERT(filter_info->right_set);
-			D_ASSERT(filter_info->join_type == JoinType::SEMI || filter_info->join_type == JoinType::ANTI);
-			for (auto &child_comp : conjunction.children) {
-				if (child_comp->GetExpressionClass() != ExpressionClass::BOUND_COMPARISON) {
-					continue;
-				}
-				auto &comparison = child_comp->Cast<BoundComparisonExpression>();
-				// extract the bindings that are required for the left and right side of the comparison
-				relation_manager.ExtractBindings(*comparison.left, left_bindings);
-				relation_manager.ExtractBindings(*comparison.right, right_bindings);
-				if (filter_info->left_binding.table_index == DConstants::INVALID_INDEX &&
-				    filter_info->left_binding.column_index == DConstants::INVALID_INDEX) {
-					GetColumnBinding(*comparison.left, filter_info->left_binding);
-				}
-				if (filter_info->right_binding.table_index == DConstants::INVALID_INDEX &&
-				    filter_info->right_binding.column_index == DConstants::INVALID_INDEX) {
-					GetColumnBinding(*comparison.right, filter_info->right_binding);
-				}
-			}
-			if (!left_bindings.empty() && !right_bindings.empty()) {
-				// we can only create a meaningful edge if the sets are not exactly the same
-				if (filter_info->left_set != filter_info->right_set) {
-					// check if the sets are disjoint
-					if (Disjoint(left_bindings, right_bindings)) {
-						// they are disjoint, we only need to create one set of edges in the join graph
-						query_graph.CreateEdge(*filter_info->left_set, *filter_info->right_set, filter_info);
-						query_graph.CreateEdge(*filter_info->right_set, *filter_info->left_set, filter_info);
-					}
-				}
-			}
-		}
-	}
-}
-
-static unique_ptr<LogicalOperator> ExtractJoinRelation(unique_ptr<SingleJoinRelation> &rel) {
-	auto &children = rel->parent->children;
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (children[i].get() == &rel->op) {
-			// found it! take ownership o/**/f it from the parent
-			auto result = std::move(children[i]);
-			children.erase_at(i);
-			return result;
-		}
-	}
-	throw InternalException("Could not find relation in parent node (?)");
-}
-
-unique_ptr<LogicalOperator> QueryGraphManager::Reconstruct(unique_ptr<LogicalOperator> plan) {
-	// now we have to rewrite the plan
-	bool root_is_join = plan->children.size() > 1;
-
-	unordered_set<idx_t> bindings;
-	for (idx_t i = 0; i < relation_manager.NumRelations(); i++) {
-		bindings.insert(i);
-	}
-	auto &total_relation = set_manager.GetJoinRelation(bindings);
-
-	// first we will extract all relations from the main plan
-	vector<unique_ptr<LogicalOperator>> extracted_relations;
-	extracted_relations.reserve(relation_manager.NumRelations());
-	for (auto &relation : relation_manager.GetRelations()) {
-		extracted_relations.push_back(ExtractJoinRelation(relation));
-	}
-
-	// now we generate the actual joins
-	auto join_tree = GenerateJoins(extracted_relations, total_relation);
-
-	// perform the final pushdown of remaining filters
-	for (auto &filter : filters_and_bindings) {
-		// check if the filter has already been extracted
-		if (filter->filter) {
-			// if not we need to push it
-			join_tree.op = PushFilter(std::move(join_tree.op), std::move(filter->filter));
-		}
-	}
-
-	// find the first join in the relation to know where to place this node
-	if (root_is_join) {
-		// first node is the join, return it immediately
-		return std::move(join_tree.op);
-	}
-	D_ASSERT(plan->children.size() == 1);
-	// have to move up through the relations
-	auto op = plan.get();
-	auto parent = plan.get();
-	while (op->type != LogicalOperatorType::LOGICAL_CROSS_PRODUCT &&
-	       op->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN &&
-	       op->type != LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-		D_ASSERT(op->children.size() == 1);
-		parent = op;
-		op = op->children[0].get();
-	}
-	// have to replace at this node
-	parent->children[0] = std::move(join_tree.op);
-	return plan;
-}
-
-static JoinCondition MaybeInvertConditions(unique_ptr<Expression> condition, bool invert) {
-	auto &comparison = condition->Cast<BoundComparisonExpression>();
-	JoinCondition cond;
-	cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
-	cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
-	cond.comparison = condition->GetExpressionType();
-	if (invert) {
-		// reverse comparison expression if we reverse the order of the children
-		cond.comparison = FlipComparisonExpression(cond.comparison);
-	}
-	return cond;
-}
-
-GenerateJoinRelation QueryGraphManager::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations,
-                                                      JoinRelationSet &set) {
-	optional_ptr<JoinRelationSet> left_node;
-	optional_ptr<JoinRelationSet> right_node;
-	optional_ptr<JoinRelationSet> result_relation;
-	unique_ptr<LogicalOperator> result_operator;
-
-	auto dp_entry = plans->find(set);
-	if (dp_entry == plans->end()) {
-		throw InternalException("Join Order Optimizer Error: No full plan was created");
-	}
-	auto &node = dp_entry->second;
-	if (!dp_entry->second->is_leaf) {
-
-		// generate the left and right children
-		auto left = GenerateJoins(extracted_relations, node->left_set);
-		auto right = GenerateJoins(extracted_relations, node->right_set);
-		if (dp_entry->second->info->filters.empty()) {
-			// no filters, create a cross product
-			auto cardinality = left.op->estimated_cardinality * right.op->estimated_cardinality;
-			result_operator = LogicalCrossProduct::Create(std::move(left.op), std::move(right.op));
-			result_operator->SetEstimatedCardinality(cardinality);
-		} else {
-			// we have filters, create a join node
-			auto chosen_filter = node->info->filters.at(0);
-			for (idx_t i = 0; i < node->info->filters.size(); i++) {
-				if (node->info->filters.at(i)->join_type == JoinType::INNER) {
-					chosen_filter = node->info->filters.at(i);
-					break;
-				}
-			}
-
-			auto join = make_uniq<LogicalComparisonJoin>(chosen_filter->join_type);
-			// Here we optimize build side probe side. Our build side is the right side
-			// So the right plans should have lower cardinalities.
-			join->children.push_back(std::move(left.op));
-			join->children.push_back(std::move(right.op));
-
-			// set the join conditions from the join node
-			for (auto &filter_ref : node->info->filters) {
-				auto f = filter_ref.get();
-				// extract the filter from the operator it originally belonged to
-				D_ASSERT(filters_and_bindings[f->filter_index]->filter);
-				auto &filter_and_binding = filters_and_bindings.at(f->filter_index);
-				auto condition = std::move(filter_and_binding->filter);
-				// now create the actual join condition
-				D_ASSERT((JoinRelationSet::IsSubset(*left.set, *f->left_set) &&
-				          JoinRelationSet::IsSubset(*right.set, *f->right_set)) ||
-				         (JoinRelationSet::IsSubset(*left.set, *f->right_set) &&
-				          JoinRelationSet::IsSubset(*right.set, *f->left_set)));
-
-				bool invert = !JoinRelationSet::IsSubset(*left.set, *f->left_set);
-				// If the left and right set are inverted AND it is a semi or anti join
-				// swap left and right children back.
-				if (invert && (f->join_type == JoinType::SEMI || f->join_type == JoinType::ANTI)) {
-					std::swap(left, right);
-					invert = false;
-				}
-
-				if (condition->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-					auto cond = MaybeInvertConditions(std::move(condition), invert);
-					join->conditions.push_back(std::move(cond));
-				} else if (condition->GetExpressionClass() == ExpressionClass::BOUND_CONJUNCTION) {
-					auto &conjunction = condition->Cast<BoundConjunctionExpression>();
-					for (auto &child : conjunction.children) {
-						D_ASSERT(child->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-						auto cond = MaybeInvertConditions(std::move(child), invert);
-						join->conditions.push_back(std::move(cond));
-					}
-				}
-			}
-			D_ASSERT(!join->conditions.empty());
-			result_operator = std::move(join);
-		}
-		left_node = left.set;
-		right_node = right.set;
-		result_relation = &set_manager.Union(*left.set, *right.set);
-	} else {
-		// base node, get the entry from the list of extracted relations
-		D_ASSERT(node->set.count == 1);
-		D_ASSERT(extracted_relations[node->set.relations[0]]);
-		result_relation = &node->set;
-		result_operator = std::move(extracted_relations[result_relation->relations[0]]);
-	}
-	// TODO: this is where estimated properties start coming into play.
-	//  when creating the result operator, we should ask the cost model and cardinality estimator what
-	//  the cost and cardinality are
-	//	result_operator->estimated_props = node.estimated_props->Copy();
-	result_operator->estimated_cardinality = node->cardinality;
-	result_operator->has_estimated_cardinality = true;
-	// check if we should do a pushdown on this node
-	// basically, any remaining filter that is a subset of the current relation will no longer be used in joins
-	// hence we should push it here
-	for (auto &filter_info : filters_and_bindings) {
-		// check if the filter has already been extracted
-		auto &info = *filter_info;
-		if (filters_and_bindings[info.filter_index]->filter) {
-			// now check if the filter is a subset of the current relation
-			// note that infos with an empty relation set are a special case and we do not push them down
-			if (info.set.get().count > 0 && JoinRelationSet::IsSubset(*result_relation, info.set)) {
-				auto &filter_and_binding = filters_and_bindings[info.filter_index];
-				auto filter = std::move(filter_and_binding->filter);
-				// if it is, we can push the filter
-				// we can push it either into a join or as a filter
-				// check if we are in a join or in a base table
-				if (!left_node || !info.left_set) {
-					// base table or non-comparison expression, push it as a filter
-					result_operator = PushFilter(std::move(result_operator), std::move(filter));
-					continue;
-				}
-				// the node below us is a join or cross product and the expression is a comparison
-				// check if the nodes can be split up into left/right
-				bool found_subset = false;
-				bool invert = false;
-				if (JoinRelationSet::IsSubset(*left_node, *info.left_set) &&
-				    JoinRelationSet::IsSubset(*right_node, *info.right_set)) {
-					found_subset = true;
-				} else if (JoinRelationSet::IsSubset(*right_node, *info.left_set) &&
-				           JoinRelationSet::IsSubset(*left_node, *info.right_set)) {
-					invert = true;
-					found_subset = true;
-				}
-				if (!found_subset) {
-					// could not be split up into left/right
-					result_operator = PushFilter(std::move(result_operator), std::move(filter));
-					continue;
-				}
-				// create the join condition
-				JoinCondition cond;
-				D_ASSERT(filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				auto &comparison = filter->Cast<BoundComparisonExpression>();
-				// we need to figure out which side is which by looking at the relations available to us
-				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
-				cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
-				cond.comparison = comparison.GetExpressionType();
-				if (invert) {
-					// reverse comparison expression if we reverse the order of the children
-					cond.comparison = FlipComparisonExpression(comparison.GetExpressionType());
-				}
-				// now find the join to push it into
-				auto node = result_operator.get();
-				if (node->type == LogicalOperatorType::LOGICAL_FILTER) {
-					node = node->children[0].get();
-				}
-				if (node->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-					// turn into comparison join
-					auto comp_join = make_uniq<LogicalComparisonJoin>(JoinType::INNER);
-					comp_join->children.push_back(std::move(node->children[0]));
-					comp_join->children.push_back(std::move(node->children[1]));
-					comp_join->conditions.push_back(std::move(cond));
-					if (node == result_operator.get()) {
-						result_operator = std::move(comp_join);
-					} else {
-						D_ASSERT(result_operator->type == LogicalOperatorType::LOGICAL_FILTER);
-						result_operator->children[0] = std::move(comp_join);
-					}
-				} else {
-					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-					         node->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
-					auto &comp_join = node->Cast<LogicalComparisonJoin>();
-					comp_join.conditions.push_back(std::move(cond));
-				}
-			}
-		}
-	}
-	auto result = GenerateJoinRelation(result_relation, std::move(result_operator));
-	return result;
-}
-
-const QueryGraphEdges &QueryGraphManager::GetQueryGraphEdges() const {
-	return query_graph;
-}
-
-void QueryGraphManager::CreateQueryGraphCrossProduct(JoinRelationSet &left, JoinRelationSet &right) {
-	query_graph.CreateEdge(left, right, nullptr);
-	query_graph.CreateEdge(right, left, nullptr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/relation_manager.cpp b/src/duckdb/src/optimizer/join_order/relation_manager.cpp
deleted file mode 100644
index d4f7032d6..000000000
--- a/src/duckdb/src/optimizer/join_order/relation_manager.cpp
+++ /dev/null
@@ -1,618 +0,0 @@
-#include "duckdb/optimizer/join_order/relation_manager.hpp"
-
-#include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
-#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/list.hpp"
-
-namespace duckdb {
-
-const vector<RelationStats> RelationManager::GetRelationStats() {
-	vector<RelationStats> ret;
-	for (idx_t i = 0; i < relations.size(); i++) {
-		ret.push_back(relations[i]->stats);
-	}
-	return ret;
-}
-
-vector<unique_ptr<SingleJoinRelation>> RelationManager::GetRelations() {
-	return std::move(relations);
-}
-
-idx_t RelationManager::NumRelations() {
-	return relations.size();
-}
-
-void RelationManager::AddAggregateOrWindowRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent,
-                                                   const RelationStats &stats, LogicalOperatorType op_type) {
-	auto relation = make_uniq<SingleJoinRelation>(op, parent, stats);
-	auto relation_id = relations.size();
-
-	auto op_bindings = op.GetColumnBindings();
-	for (auto &binding : op_bindings) {
-		if (relation_mapping.find(binding.table_index) == relation_mapping.end()) {
-			relation_mapping[binding.table_index] = relation_id;
-		}
-	}
-	relations.push_back(std::move(relation));
-	op.estimated_cardinality = stats.cardinality;
-	op.has_estimated_cardinality = true;
-}
-
-void RelationManager::AddRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent,
-                                  const RelationStats &stats) {
-
-	// if parent is null, then this is a root relation
-	// if parent is not null, it should have multiple children
-	D_ASSERT(!parent || parent->children.size() >= 2);
-	auto relation = make_uniq<SingleJoinRelation>(op, parent, stats);
-	auto relation_id = relations.size();
-
-	auto table_indexes = op.GetTableIndex();
-	if (table_indexes.empty()) {
-		// relation represents a non-reorderable relation, most likely a join relation
-		// Get the tables referenced in the non-reorderable relation and add them to the relation mapping
-		// This should all table references, even if there are nested non-reorderable joins.
-		unordered_set<idx_t> table_references;
-		LogicalJoin::GetTableReferences(op, table_references);
-		D_ASSERT(table_references.size() > 0);
-		for (auto &reference : table_references) {
-			D_ASSERT(relation_mapping.find(reference) == relation_mapping.end());
-			relation_mapping[reference] = relation_id;
-		}
-	} else if (op.type == LogicalOperatorType::LOGICAL_UNNEST) {
-		// logical unnest has a logical_unnest index, but other bindings can refer to
-		// columns that are not unnested.
-		auto bindings = op.GetColumnBindings();
-		for (auto &binding : bindings) {
-			relation_mapping[binding.table_index] = relation_id;
-		}
-	} else {
-		// Relations should never return more than 1 table index
-		D_ASSERT(table_indexes.size() == 1);
-		idx_t table_index = table_indexes.at(0);
-		D_ASSERT(relation_mapping.find(table_index) == relation_mapping.end());
-		relation_mapping[table_index] = relation_id;
-	}
-	relations.push_back(std::move(relation));
-	op.estimated_cardinality = stats.cardinality;
-	op.has_estimated_cardinality = true;
-}
-
-bool RelationManager::CrossProductWithRelationAllowed(idx_t relation_id) {
-	return no_cross_product_relations.find(relation_id) == no_cross_product_relations.end();
-}
-
-static bool OperatorNeedsRelation(LogicalOperatorType op_type) {
-	switch (op_type) {
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-	case LogicalOperatorType::LOGICAL_GET:
-	case LogicalOperatorType::LOGICAL_UNNEST:
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-	case LogicalOperatorType::LOGICAL_WINDOW:
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-static bool OperatorIsNonReorderable(LogicalOperatorType op_type) {
-	switch (op_type) {
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool ExpressionContainsColumnRef(Expression &expression) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		// Here you have a filter on a single column in a table. Return a binding for the column
-		// being filtered on so the filter estimator knows what HLL count to pull
-#ifdef DEBUG
-		auto &colref = expression.Cast<BoundColumnRefExpression>();
-		(void)colref.depth;
-		D_ASSERT(colref.depth == 0);
-		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
-#endif
-		// map the base table index to the relation index used by the JoinOrderOptimizer
-		return true;
-	}
-	// TODO: handle inequality filters with functions.
-	auto children_ret = false;
-	ExpressionIterator::EnumerateChildren(expression,
-	                                      [&](Expression &expr) { children_ret = ExpressionContainsColumnRef(expr); });
-	return children_ret;
-}
-
-static bool JoinIsReorderable(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-		return true;
-	} else if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		switch (join.join_type) {
-		case JoinType::INNER:
-		case JoinType::SEMI:
-		case JoinType::ANTI:
-			for (auto &cond : join.conditions) {
-				if (ExpressionContainsColumnRef(*cond.left) && ExpressionContainsColumnRef(*cond.right)) {
-					return true;
-				}
-			}
-			return false;
-		default:
-			return false;
-		}
-	}
-	return false;
-}
-
-static bool HasNonReorderableChild(LogicalOperator &op) {
-	LogicalOperator *tmp = &op;
-	while (tmp->children.size() == 1) {
-		if (OperatorNeedsRelation(tmp->type) || OperatorIsNonReorderable(tmp->type)) {
-			return true;
-		}
-		tmp = tmp->children[0].get();
-		if (tmp->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-			if (!JoinIsReorderable(*tmp)) {
-				return true;
-			}
-		}
-	}
-	return tmp->children.empty();
-}
-
-static void ModifyStatsIfLimit(optional_ptr<LogicalOperator> limit_op, RelationStats &stats) {
-	if (!limit_op) {
-		return;
-	}
-	auto &limit = limit_op->Cast<LogicalLimit>();
-	if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-		stats.cardinality = MinValue(limit.limit_val.GetConstantValue(), stats.cardinality);
-	}
-}
-
-bool RelationManager::ExtractJoinRelations(JoinOrderOptimizer &optimizer, LogicalOperator &input_op,
-                                           vector<reference<LogicalOperator>> &filter_operators,
-                                           optional_ptr<LogicalOperator> parent) {
-	optional_ptr<LogicalOperator> op = &input_op;
-	vector<reference<LogicalOperator>> datasource_filters;
-	optional_ptr<LogicalOperator> limit_op = nullptr;
-	// pass through single child operators
-	while (op->children.size() == 1 && !OperatorNeedsRelation(op->type)) {
-		if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
-			if (HasNonReorderableChild(*op)) {
-				datasource_filters.push_back(*op);
-			}
-			filter_operators.push_back(*op);
-		}
-		if (op->type == LogicalOperatorType::LOGICAL_LIMIT) {
-			limit_op = op;
-		}
-		op = op->children[0].get();
-	}
-	bool non_reorderable_operation = false;
-	if (OperatorIsNonReorderable(op->type)) {
-		// set operation, optimize separately in children
-		non_reorderable_operation = true;
-	}
-
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		if (JoinIsReorderable(*op)) {
-			// extract join conditions from inner join
-			filter_operators.push_back(*op);
-		} else {
-			non_reorderable_operation = true;
-		}
-	}
-	if (non_reorderable_operation) {
-		// we encountered a non-reordable operation (setop or non-inner join)
-		// we do not reorder non-inner joins yet, however we do want to expand the potential join graph around them
-		// non-inner joins are also tricky because we can't freely make conditions through them
-		// e.g. suppose we have (left LEFT OUTER JOIN right WHERE right IS NOT NULL), the join can generate
-		// new NULL values in the right side, so pushing this condition through the join leads to incorrect results
-		// for this reason, we just start a new JoinOptimizer pass in each of the children of the join
-		// stats.cardinality will be initiated to highest cardinality of the children.
-		vector<RelationStats> children_stats;
-		for (auto &child : op->children) {
-			auto stats = RelationStats();
-			auto child_optimizer = optimizer.CreateChildOptimizer();
-			child = child_optimizer.Optimize(std::move(child), &stats);
-			children_stats.push_back(stats);
-		}
-
-		auto combined_stats = RelationStatisticsHelper::CombineStatsOfNonReorderableOperator(*op, children_stats);
-		op->SetEstimatedCardinality(combined_stats.cardinality);
-		if (!datasource_filters.empty()) {
-			combined_stats.cardinality = (idx_t)MaxValue(
-			    double(combined_stats.cardinality) * RelationStatisticsHelper::DEFAULT_SELECTIVITY, (double)1);
-		}
-		AddRelation(input_op, parent, combined_stats);
-		return true;
-	}
-
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		// optimize children
-		RelationStats child_stats;
-		auto child_optimizer = optimizer.CreateChildOptimizer();
-		op->children[0] = child_optimizer.Optimize(std::move(op->children[0]), &child_stats);
-		auto &aggr = op->Cast<LogicalAggregate>();
-		auto operator_stats = RelationStatisticsHelper::ExtractAggregationStats(aggr, child_stats);
-		// the extracted cardinality should be set for aggregate
-		aggr.SetEstimatedCardinality(operator_stats.cardinality);
-		if (!datasource_filters.empty()) {
-			operator_stats.cardinality = LossyNumericCast<idx_t>(static_cast<double>(operator_stats.cardinality) *
-			                                                     RelationStatisticsHelper::DEFAULT_SELECTIVITY);
-		}
-		ModifyStatsIfLimit(limit_op.get(), child_stats);
-		AddAggregateOrWindowRelation(input_op, parent, operator_stats, op->type);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_WINDOW: {
-		// optimize children
-		RelationStats child_stats;
-		auto child_optimizer = optimizer.CreateChildOptimizer();
-		op->children[0] = child_optimizer.Optimize(std::move(op->children[0]), &child_stats);
-		auto &window = op->Cast<LogicalWindow>();
-		auto operator_stats = RelationStatisticsHelper::ExtractWindowStats(window, child_stats);
-		// the extracted cardinality should be set for window
-		window.SetEstimatedCardinality(operator_stats.cardinality);
-		if (!datasource_filters.empty()) {
-			operator_stats.cardinality = LossyNumericCast<idx_t>(static_cast<double>(operator_stats.cardinality) *
-			                                                     RelationStatisticsHelper::DEFAULT_SELECTIVITY);
-		}
-		ModifyStatsIfLimit(limit_op.get(), child_stats);
-		AddAggregateOrWindowRelation(input_op, parent, operator_stats, op->type);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_UNNEST: {
-		// optimize children of unnest
-		RelationStats child_stats;
-		auto child_optimizer = optimizer.CreateChildOptimizer();
-		op->children[0] = child_optimizer.Optimize(std::move(op->children[0]), &child_stats);
-		// the extracted cardinality should be set for window
-		if (!datasource_filters.empty()) {
-			child_stats.cardinality = LossyNumericCast<idx_t>(static_cast<double>(child_stats.cardinality) *
-			                                                  RelationStatisticsHelper::DEFAULT_SELECTIVITY);
-		}
-		ModifyStatsIfLimit(limit_op.get(), child_stats);
-		AddRelation(input_op, parent, child_stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = op->Cast<LogicalComparisonJoin>();
-		// Adding relations of the left side to the current join order optimizer
-		bool can_reorder_left = ExtractJoinRelations(optimizer, *op->children[0], filter_operators, op);
-		bool can_reorder_right = true;
-		// For semi & anti joins, you only reorder relations in the left side of the join.
-		// We do not want to reorder a relation A into the right side because then all column bindings A from A will be
-		// lost after the semi or anti join
-
-		// We cannot reorder a relation B out of the right side because any filter/join in the right side
-		// between a relation B and another RHS relation will be invalid. The semi join will remove
-		// all right column bindings,
-
-		// So we treat the right side of left join as its own relation so no relations
-		// are pushed into the right side, or taken out of the right side.
-		if (join.join_type == JoinType::SEMI || join.join_type == JoinType::ANTI) {
-			RelationStats child_stats;
-			// optimize the child and copy the stats
-			auto child_optimizer = optimizer.CreateChildOptimizer();
-			op->children[1] = child_optimizer.Optimize(std::move(op->children[1]), &child_stats);
-			AddRelation(*op->children[1], op, child_stats);
-			// remember that if a cross product needs to be forced, it cannot be forced
-			// across the children of a semi or anti join
-			no_cross_product_relations.insert(relations.size() - 1);
-			auto right_child_bindings = op->children[1]->GetColumnBindings();
-			for (auto &bindings : right_child_bindings) {
-				relation_mapping[bindings.table_index] = relations.size() - 1;
-			}
-		} else {
-			can_reorder_right = ExtractJoinRelations(optimizer, *op->children[1], filter_operators, op);
-		}
-		return can_reorder_left && can_reorder_right;
-	}
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-		bool can_reorder_left = ExtractJoinRelations(optimizer, *op->children[0], filter_operators, op);
-		bool can_reorder_right = ExtractJoinRelations(optimizer, *op->children[1], filter_operators, op);
-		return can_reorder_left && can_reorder_right;
-	}
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN: {
-		auto &dummy_scan = op->Cast<LogicalDummyScan>();
-		auto stats = RelationStatisticsHelper::ExtractDummyScanStats(dummy_scan, context);
-		AddRelation(input_op, parent, stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
-		// base table scan, add to set of relations.
-		// create empty stats for dummy scan or logical expression get
-		auto &expression_get = op->Cast<LogicalExpressionGet>();
-		auto stats = RelationStatisticsHelper::ExtractExpressionGetStats(expression_get, context);
-		AddRelation(input_op, parent, stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_GET: {
-		// TODO: Get stats from a logical GET
-		auto &get = op->Cast<LogicalGet>();
-		auto stats = RelationStatisticsHelper::ExtractGetStats(get, context);
-		// if there is another logical filter that could not be pushed down into the
-		// table scan, apply another selectivity.
-		get.SetEstimatedCardinality(stats.cardinality);
-		if (!datasource_filters.empty()) {
-			stats.cardinality =
-			    (idx_t)MaxValue(double(stats.cardinality) * RelationStatisticsHelper::DEFAULT_SELECTIVITY, (double)1);
-		}
-		ModifyStatsIfLimit(limit_op.get(), stats);
-		AddRelation(input_op, parent, stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		RelationStats child_stats;
-		// optimize the child and copy the stats
-		auto child_optimizer = optimizer.CreateChildOptimizer();
-		op->children[0] = child_optimizer.Optimize(std::move(op->children[0]), &child_stats);
-		auto &proj = op->Cast<LogicalProjection>();
-		// Projection can create columns so we need to add them here
-		auto proj_stats = RelationStatisticsHelper::ExtractProjectionStats(proj, child_stats);
-		proj.SetEstimatedCardinality(proj_stats.cardinality);
-		ModifyStatsIfLimit(limit_op.get(), proj_stats);
-		AddRelation(input_op, parent, proj_stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT: {
-		// optimize the child and copy the stats
-		auto &empty_result = op->Cast<LogicalEmptyResult>();
-		// Projection can create columns so we need to add them here
-		auto stats = RelationStatisticsHelper::ExtractEmptyResultStats(empty_result);
-		empty_result.SetEstimatedCardinality(stats.cardinality);
-		AddRelation(input_op, parent, stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: {
-		RelationStats lhs_stats;
-		// optimize the lhs child and copy the stats
-		auto lhs_optimizer = optimizer.CreateChildOptimizer();
-		op->children[0] = lhs_optimizer.Optimize(std::move(op->children[0]), &lhs_stats);
-		// optimize the rhs child
-		auto rhs_optimizer = optimizer.CreateChildOptimizer();
-		auto table_index = op->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE
-		                       ? op->Cast<LogicalMaterializedCTE>().table_index
-		                       : op->Cast<LogicalRecursiveCTE>().table_index;
-		rhs_optimizer.AddMaterializedCTEStats(table_index, std::move(lhs_stats));
-		op->children[1] = rhs_optimizer.Optimize(std::move(op->children[1]));
-		return false;
-	}
-	case LogicalOperatorType::LOGICAL_CTE_REF: {
-		auto &cte_ref = op->Cast<LogicalCTERef>();
-		if (cte_ref.materialized_cte != CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-			return false;
-		}
-		auto cte_stats = optimizer.GetMaterializedCTEStats(cte_ref.cte_index);
-		cte_ref.SetEstimatedCardinality(cte_stats.cardinality);
-		AddRelation(input_op, parent, cte_stats);
-		return true;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
-		auto &delim_join = op->Cast<LogicalComparisonJoin>();
-
-		// optimize LHS (duplicate-eliminated) child
-		RelationStats lhs_stats;
-		auto lhs_optimizer = optimizer.CreateChildOptimizer();
-		op->children[0] = lhs_optimizer.Optimize(std::move(op->children[0]), &lhs_stats);
-
-		// create dummy aggregation for the duplicate elimination
-		auto dummy_aggr = make_uniq<LogicalAggregate>(DConstants::INVALID_INDEX - 1, DConstants::INVALID_INDEX,
-		                                              vector<unique_ptr<Expression>>());
-		for (auto &delim_col : delim_join.duplicate_eliminated_columns) {
-			dummy_aggr->groups.push_back(delim_col->Copy());
-		}
-		auto lhs_delim_stats = RelationStatisticsHelper::ExtractAggregationStats(*dummy_aggr, lhs_stats);
-
-		// optimize the other child, which will now have access to the stats
-		RelationStats rhs_stats;
-		auto rhs_optimizer = optimizer.CreateChildOptimizer();
-		rhs_optimizer.AddDelimScanStats(lhs_delim_stats);
-		op->children[1] = rhs_optimizer.Optimize(std::move(op->children[1]), rhs_stats);
-
-		return false;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_GET: {
-		// Used to not be possible to reorder these. We added reordering (without stats) before,
-		// but ran into terrible join orders (see internal issue #596), so we removed it again
-		// We now have proper statistics for DelimGets, and get an even better query plan for #596
-		auto delim_scan_stats = optimizer.GetDelimScanStats();
-		op->SetEstimatedCardinality(delim_scan_stats.cardinality);
-		AddAggregateOrWindowRelation(input_op, parent, delim_scan_stats, op->type);
-		return true;
-	}
-	default:
-		return false;
-	}
-}
-
-bool RelationManager::ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expression.Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.depth == 0);
-		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
-		// map the base table index to the relation index used by the JoinOrderOptimizer
-		if (expression.GetAlias() == "SUBQUERY" &&
-		    relation_mapping.find(colref.binding.table_index) == relation_mapping.end()) {
-			// most likely a BoundSubqueryExpression that was created from an uncorrelated subquery
-			// Here we return true and don't fill the bindings, the expression can be reordered.
-			// A filter will be created using this expression, and pushed back on top of the parent
-			// operator during plan reconstruction
-			return true;
-		}
-		if (relation_mapping.find(colref.binding.table_index) != relation_mapping.end()) {
-			bindings.insert(relation_mapping[colref.binding.table_index]);
-		}
-	}
-	if (expression.GetExpressionType() == ExpressionType::BOUND_REF) {
-		// bound expression
-		bindings.clear();
-		return false;
-	}
-	D_ASSERT(expression.GetExpressionType() != ExpressionType::SUBQUERY);
-	bool can_reorder = true;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &expr) {
-		if (!ExtractBindings(expr, bindings)) {
-			can_reorder = false;
-			return;
-		}
-	});
-	return can_reorder;
-}
-
-vector<unique_ptr<FilterInfo>> RelationManager::ExtractEdges(LogicalOperator &op,
-                                                             vector<reference<LogicalOperator>> &filter_operators,
-                                                             JoinRelationSetManager &set_manager) {
-	// now that we know we are going to perform join ordering we actually extract the filters, eliminating duplicate
-	// filters in the process
-	vector<unique_ptr<FilterInfo>> filters_and_bindings;
-	expression_set_t filter_set;
-	for (auto &filter_op : filter_operators) {
-		auto &f_op = filter_op.get();
-		if (f_op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-		    f_op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			auto &join = f_op.Cast<LogicalComparisonJoin>();
-			D_ASSERT(join.expressions.empty());
-			if (join.join_type == JoinType::SEMI || join.join_type == JoinType::ANTI) {
-
-				auto conjunction_expression = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-				// create a conjunction expression for the semi join.
-				// It's possible multiple LHS relations have a condition in
-				// this semi join. Suppose we have ((A ⨝ B) ⋉ C). (example in test_4950.test)
-				// If the semi join condition has A.x = C.y AND B.x = C.z then we need to prevent a reordering
-				// that looks like ((A ⋉ C) ⨝ B)), since all columns from C will be lost after it joins with A,
-				// and the condition B.x = C.z will no longer be possible.
-				// if we make a conjunction expressions and populate the left set and right set with all
-				// the relations from the conditions in the conjunction expression, we can prevent invalid
-				// reordering.
-				for (auto &cond : join.conditions) {
-					auto comparison = make_uniq<BoundComparisonExpression>(cond.comparison, std::move(cond.left),
-					                                                       std::move(cond.right));
-					conjunction_expression->children.push_back(std::move(comparison));
-				}
-
-				// create the filter info so all required LHS relations are present when reconstructing the
-				// join
-				optional_ptr<JoinRelationSet> left_set;
-				optional_ptr<JoinRelationSet> right_set;
-				optional_ptr<JoinRelationSet> full_set;
-				// here we create a left_set that unions all relations from the left side of
-				// every expression and a right_set that unions all relations frmo the right side of a
-				// every expression (although this should always be 1).
-				for (auto &bound_expr : conjunction_expression->children) {
-					D_ASSERT(bound_expr->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-					auto &comp = bound_expr->Cast<BoundComparisonExpression>();
-					unordered_set<idx_t> right_bindings, left_bindings;
-					ExtractBindings(*comp.right, right_bindings);
-					ExtractBindings(*comp.left, left_bindings);
-
-					if (!left_set) {
-						left_set = set_manager.GetJoinRelation(left_bindings);
-					} else {
-						left_set = set_manager.Union(set_manager.GetJoinRelation(left_bindings), *left_set);
-					}
-					if (!right_set) {
-						right_set = set_manager.GetJoinRelation(right_bindings);
-					} else {
-						right_set = set_manager.Union(set_manager.GetJoinRelation(right_bindings), *right_set);
-					}
-				}
-				full_set = set_manager.Union(*left_set, *right_set);
-				D_ASSERT(left_set && left_set->count > 0);
-				D_ASSERT(right_set && right_set->count == 1);
-				D_ASSERT(full_set && full_set->count > 0);
-
-				// now we push the conjunction expressions
-				// In QueryGraphManager::GenerateJoins we extract each condition again and create a standalone join
-				// condition.
-				auto filter_info = make_uniq<FilterInfo>(std::move(conjunction_expression), *full_set,
-				                                         filters_and_bindings.size(), join.join_type);
-				filter_info->SetLeftSet(left_set);
-				filter_info->SetRightSet(right_set);
-
-				filters_and_bindings.push_back(std::move(filter_info));
-			} else {
-				// can extract every inner join condition individually.
-				for (auto &cond : join.conditions) {
-					auto comparison = make_uniq<BoundComparisonExpression>(cond.comparison, std::move(cond.left),
-					                                                       std::move(cond.right));
-					if (filter_set.find(*comparison) == filter_set.end()) {
-						filter_set.insert(*comparison);
-						unordered_set<idx_t> bindings;
-						ExtractBindings(*comparison, bindings);
-						auto &set = set_manager.GetJoinRelation(bindings);
-						auto filter_info = make_uniq<FilterInfo>(std::move(comparison), set,
-						                                         filters_and_bindings.size(), join.join_type);
-						filters_and_bindings.push_back(std::move(filter_info));
-					}
-				}
-			}
-			join.conditions.clear();
-		} else {
-			vector<unique_ptr<Expression>> leftover_expressions;
-			for (auto &expression : f_op.expressions) {
-				if (filter_set.find(*expression) == filter_set.end()) {
-					filter_set.insert(*expression);
-					unordered_set<idx_t> bindings;
-					ExtractBindings(*expression, bindings);
-					if (bindings.empty()) {
-						// the filter is on a column that is not in our relational map. (example: limit_rownum)
-						// in this case we do not create a FilterInfo for it. (duckdb-internal/#1493)s
-						leftover_expressions.push_back(std::move(expression));
-						continue;
-					}
-					auto &set = set_manager.GetJoinRelation(bindings);
-					auto filter_info = make_uniq<FilterInfo>(std::move(expression), set, filters_and_bindings.size());
-					filters_and_bindings.push_back(std::move(filter_info));
-				}
-			}
-			f_op.expressions = std::move(leftover_expressions);
-		}
-	}
-
-	return filters_and_bindings;
-}
-
-// LCOV_EXCL_START
-
-void RelationManager::PrintRelationStats() {
-#ifdef DEBUG
-	string to_print;
-	for (idx_t i = 0; i < relations.size(); i++) {
-		auto &relation = relations.at(i);
-		auto &stats = relation->stats;
-		D_ASSERT(stats.column_names.size() == stats.column_distinct_count.size());
-		for (idx_t i = 0; i < stats.column_names.size(); i++) {
-			to_print = stats.column_names.at(i) + " has estimated distinct count " +
-			           to_string(stats.column_distinct_count.at(i).distinct_count);
-			Printer::Print(to_print);
-		}
-		to_print = stats.table_name + " has estimated cardinality " + to_string(stats.cardinality);
-		to_print += " and relation id " + to_string(i) + "\n";
-		Printer::Print(to_print);
-	}
-#endif
-}
-
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp b/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp
deleted file mode 100644
index 6340d9c02..000000000
--- a/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp
+++ /dev/null
@@ -1,444 +0,0 @@
-#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-
-namespace duckdb {
-
-static ExpressionBinding GetChildColumnBinding(Expression &expr) {
-	auto ret = ExpressionBinding();
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_FUNCTION: {
-		// TODO: Other expression classes that can have 0 children?
-		auto &func = expr.Cast<BoundFunctionExpression>();
-		// no children some sort of gen_random_uuid() or equivalent.
-		if (func.children.empty()) {
-			ret.found_expression = true;
-			ret.expression_is_constant = true;
-			return ret;
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_COLUMN_REF: {
-		ret.found_expression = true;
-		auto &new_col_ref = expr.Cast<BoundColumnRefExpression>();
-		ret.child_binding = ColumnBinding(new_col_ref.binding.table_index, new_col_ref.binding.column_index);
-		return ret;
-	}
-	case ExpressionClass::BOUND_LAMBDA_REF:
-	case ExpressionClass::BOUND_CONSTANT:
-	case ExpressionClass::BOUND_DEFAULT:
-	case ExpressionClass::BOUND_PARAMETER:
-	case ExpressionClass::BOUND_REF:
-		ret.found_expression = true;
-		ret.expression_is_constant = true;
-		return ret;
-	default:
-		break;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &child) {
-		auto recursive_result = GetChildColumnBinding(*child);
-		if (recursive_result.found_expression) {
-			ret = recursive_result;
-		}
-	});
-	// we didn't find a Bound Column Ref
-	return ret;
-}
-
-RelationStats RelationStatisticsHelper::ExtractGetStats(LogicalGet &get, ClientContext &context) {
-	auto return_stats = RelationStats();
-
-	auto base_table_cardinality = get.EstimateCardinality(context);
-	auto cardinality_after_filters = base_table_cardinality;
-	unique_ptr<BaseStatistics> column_statistics;
-
-	auto catalog_table = get.GetTable();
-	auto name = string("some table");
-	if (catalog_table) {
-		name = catalog_table->name;
-		return_stats.table_name = name;
-	}
-
-	// if we can get the catalog table, then our column statistics will be accurate
-	// parquet readers etc. will still return statistics, but they initialize distinct column
-	// counts to 0.
-	// TODO: fix this, some file formats can encode distinct counts, we don't want to rely on
-	//  getting a catalog table to know that we can use statistics.
-	bool have_catalog_table_statistics = false;
-	if (get.GetTable()) {
-		have_catalog_table_statistics = true;
-	}
-
-	// first push back basic distinct counts for each column (if we have them).
-	auto &column_ids = get.GetColumnIds();
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column_id = column_ids[i].GetPrimaryIndex();
-		bool have_distinct_count_stats = false;
-		if (get.function.statistics) {
-			column_statistics = get.function.statistics(context, get.bind_data.get(), column_id);
-			if (column_statistics && have_catalog_table_statistics) {
-				auto distinct_count = MaxValue<idx_t>(1, column_statistics->GetDistinctCount());
-				auto column_distinct_count = DistinctCount({distinct_count, true});
-				return_stats.column_distinct_count.push_back(column_distinct_count);
-				return_stats.column_names.push_back(name + "." + get.names.at(column_id));
-				have_distinct_count_stats = true;
-			}
-		}
-		if (!have_distinct_count_stats) {
-			// currently treating the cardinality as the distinct count.
-			// the cardinality estimator will update these distinct counts based
-			// on the extra columns that are joined on.
-			auto column_distinct_count = DistinctCount({cardinality_after_filters, false});
-			return_stats.column_distinct_count.push_back(column_distinct_count);
-			auto column_name = string("column");
-			if (column_id < get.names.size()) {
-				column_name = get.names.at(column_id);
-			}
-			return_stats.column_names.push_back(get.GetName() + "." + column_name);
-		}
-	}
-
-	if (!get.table_filters.filters.empty()) {
-		column_statistics = nullptr;
-		bool has_non_optional_filters = false;
-		for (auto &it : get.table_filters.filters) {
-			if (get.bind_data && get.function.statistics) {
-				column_statistics = get.function.statistics(context, get.bind_data.get(), it.first);
-			}
-
-			if (column_statistics) {
-				idx_t cardinality_with_filter =
-				    InspectTableFilter(base_table_cardinality, it.first, *it.second, *column_statistics);
-				cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_filter);
-			}
-
-			if (it.second->filter_type != TableFilterType::OPTIONAL_FILTER) {
-				has_non_optional_filters = true;
-			}
-		}
-		// if the above code didn't find an equality filter (i.e country_code = "[us]")
-		// and there are other table filters (i.e cost > 50), use default selectivity.
-		bool has_equality_filter = (cardinality_after_filters != base_table_cardinality);
-		if (!has_equality_filter && has_non_optional_filters) {
-			cardinality_after_filters = MaxValue<idx_t>(
-			    LossyNumericCast<idx_t>(double(base_table_cardinality) * RelationStatisticsHelper::DEFAULT_SELECTIVITY),
-			    1U);
-		}
-		if (base_table_cardinality == 0) {
-			cardinality_after_filters = 0;
-		}
-	}
-	return_stats.cardinality = cardinality_after_filters;
-	// update the estimated cardinality of the get as well.
-	// This is not updated during plan reconstruction.
-	get.estimated_cardinality = cardinality_after_filters;
-	get.has_estimated_cardinality = true;
-	D_ASSERT(base_table_cardinality >= cardinality_after_filters);
-	return_stats.stats_initialized = true;
-	return return_stats;
-}
-
-RelationStats RelationStatisticsHelper::ExtractDelimGetStats(LogicalDelimGet &delim_get, ClientContext &context) {
-	RelationStats stats;
-	stats.table_name = delim_get.GetName();
-	idx_t card = delim_get.EstimateCardinality(context);
-	stats.cardinality = card;
-	stats.stats_initialized = true;
-	for (auto &binding : delim_get.GetColumnBindings()) {
-		stats.column_distinct_count.push_back(DistinctCount({1, false}));
-		stats.column_names.push_back("column" + to_string(binding.column_index));
-	}
-	return stats;
-}
-
-RelationStats RelationStatisticsHelper::ExtractProjectionStats(LogicalProjection &proj, RelationStats &child_stats) {
-	auto proj_stats = RelationStats();
-	proj_stats.cardinality = child_stats.cardinality;
-	proj_stats.table_name = proj.GetName();
-	for (auto &expr : proj.expressions) {
-		proj_stats.column_names.push_back(expr->GetName());
-		auto res = GetChildColumnBinding(*expr);
-		D_ASSERT(res.found_expression);
-		if (res.expression_is_constant) {
-			proj_stats.column_distinct_count.push_back(DistinctCount({1, true}));
-		} else {
-			auto column_index = res.child_binding.column_index;
-			if (column_index >= child_stats.column_distinct_count.size() && expr->ToString() == "count_star()") {
-				// only one value for a count star
-				proj_stats.column_distinct_count.push_back(DistinctCount({1, true}));
-			} else {
-				// TODO: add this back in
-				//	D_ASSERT(column_index < stats.column_distinct_count.size());
-				if (column_index < child_stats.column_distinct_count.size()) {
-					proj_stats.column_distinct_count.push_back(child_stats.column_distinct_count.at(column_index));
-				} else {
-					proj_stats.column_distinct_count.push_back(DistinctCount({proj_stats.cardinality, false}));
-				}
-			}
-		}
-	}
-	proj_stats.stats_initialized = true;
-	return proj_stats;
-}
-
-RelationStats RelationStatisticsHelper::ExtractDummyScanStats(LogicalDummyScan &dummy_scan, ClientContext &context) {
-	auto stats = RelationStats();
-	idx_t card = dummy_scan.EstimateCardinality(context);
-	stats.cardinality = card;
-	for (idx_t i = 0; i < dummy_scan.GetColumnBindings().size(); i++) {
-		stats.column_distinct_count.push_back(DistinctCount({card, false}));
-		stats.column_names.push_back("dummy_scan_column");
-	}
-	stats.stats_initialized = true;
-	stats.table_name = "dummy scan";
-	return stats;
-}
-
-void RelationStatisticsHelper::CopyRelationStats(RelationStats &to, const RelationStats &from) {
-	to.column_distinct_count = from.column_distinct_count;
-	to.column_names = from.column_names;
-	to.cardinality = from.cardinality;
-	to.table_name = from.table_name;
-	to.stats_initialized = from.stats_initialized;
-}
-
-RelationStats RelationStatisticsHelper::CombineStatsOfReorderableOperator(vector<ColumnBinding> &bindings,
-                                                                          vector<RelationStats> relation_stats) {
-	RelationStats stats;
-	idx_t max_card = 0;
-	for (auto &child_stats : relation_stats) {
-		for (idx_t i = 0; i < child_stats.column_distinct_count.size(); i++) {
-			stats.column_distinct_count.push_back(child_stats.column_distinct_count.at(i));
-			stats.column_names.push_back(child_stats.column_names.at(i));
-		}
-		stats.table_name += "joined with " + child_stats.table_name;
-		max_card = MaxValue(max_card, child_stats.cardinality);
-	}
-	stats.stats_initialized = true;
-	stats.cardinality = max_card;
-	return stats;
-}
-
-RelationStats RelationStatisticsHelper::CombineStatsOfNonReorderableOperator(LogicalOperator &op,
-                                                                             vector<RelationStats> child_stats) {
-	D_ASSERT(child_stats.size() == 2);
-	RelationStats ret;
-	idx_t child_1_card = child_stats[0].stats_initialized ? child_stats[0].cardinality : 0;
-	idx_t child_2_card = child_stats[1].stats_initialized ? child_stats[1].cardinality : 0;
-	ret.cardinality = MaxValue(child_1_card, child_2_card);
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		switch (join.join_type) {
-		case JoinType::RIGHT_ANTI:
-		case JoinType::RIGHT_SEMI:
-			ret.cardinality = child_2_card;
-			break;
-		case JoinType::ANTI:
-		case JoinType::SEMI:
-		case JoinType::SINGLE:
-		case JoinType::MARK:
-			ret.cardinality = child_1_card;
-			break;
-		default:
-			break;
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_UNION: {
-		auto &setop = op.Cast<LogicalSetOperation>();
-		if (setop.setop_all) {
-			// setop returns all records
-			ret.cardinality = child_1_card + child_2_card;
-		} else {
-			ret.cardinality = MaxValue(child_1_card, child_2_card);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_INTERSECT: {
-		ret.cardinality = MinValue(child_1_card, child_2_card);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_EXCEPT: {
-		ret.cardinality = child_1_card;
-		break;
-	}
-	default:
-		break;
-	}
-
-	ret.stats_initialized = true;
-	ret.filter_strength = 1;
-	ret.table_name = child_stats[0].table_name + " joined with " + child_stats[1].table_name;
-	for (auto &stats : child_stats) {
-		// MARK joins are nonreorderable. They won't return initialized stats
-		// continue in this case.
-		if (!stats.stats_initialized) {
-			continue;
-		}
-		for (auto &distinct_count : stats.column_distinct_count) {
-			ret.column_distinct_count.push_back(distinct_count);
-		}
-		for (auto &column_name : stats.column_names) {
-			ret.column_names.push_back(column_name);
-		}
-	}
-	return ret;
-}
-
-RelationStats RelationStatisticsHelper::ExtractExpressionGetStats(LogicalExpressionGet &expression_get,
-                                                                  ClientContext &context) {
-	auto stats = RelationStats();
-	idx_t card = expression_get.EstimateCardinality(context);
-	stats.cardinality = card;
-	for (idx_t i = 0; i < expression_get.GetColumnBindings().size(); i++) {
-		stats.column_distinct_count.push_back(DistinctCount({card, false}));
-		stats.column_names.push_back("expression_get_column");
-	}
-	stats.stats_initialized = true;
-	stats.table_name = "expression_get";
-	return stats;
-}
-
-RelationStats RelationStatisticsHelper::ExtractWindowStats(LogicalWindow &window, RelationStats &child_stats) {
-	RelationStats stats;
-	stats.cardinality = child_stats.cardinality;
-	stats.column_distinct_count = child_stats.column_distinct_count;
-	stats.column_names = child_stats.column_names;
-	stats.stats_initialized = true;
-	auto num_child_columns = window.GetColumnBindings().size();
-
-	for (idx_t column_index = child_stats.column_distinct_count.size(); column_index < num_child_columns;
-	     column_index++) {
-		stats.column_distinct_count.push_back(DistinctCount({child_stats.cardinality, false}));
-		stats.column_names.push_back("window");
-	}
-	return stats;
-}
-
-RelationStats RelationStatisticsHelper::ExtractAggregationStats(LogicalAggregate &aggr, RelationStats &child_stats) {
-	RelationStats stats;
-	// TODO: look at child distinct count to better estimate cardinality.
-	stats.cardinality = child_stats.cardinality;
-	stats.column_distinct_count = child_stats.column_distinct_count;
-	double new_card = -1;
-	for (auto &g_set : aggr.grouping_sets) {
-		for (auto &ind : g_set) {
-			if (aggr.groups[ind]->GetExpressionClass() != ExpressionClass::BOUND_COLUMN_REF) {
-				continue;
-			}
-			auto bound_col = &aggr.groups[ind]->Cast<BoundColumnRefExpression>();
-			auto col_index = bound_col->binding.column_index;
-			if (col_index >= child_stats.column_distinct_count.size()) {
-				// it is possible the column index of the grouping_set is not in the child stats.
-				// this can happen when delim joins are present, since delim scans are not currently
-				// reorderable. Meaning they don't add a relation or column_ids that could potentially
-				// be grouped by. Hopefully this can be fixed with duckdb-internal#606
-				continue;
-			}
-			double distinct_count = double(child_stats.column_distinct_count[col_index].distinct_count);
-			if (new_card < distinct_count) {
-				new_card = distinct_count;
-			}
-		}
-	}
-	if (new_card < 0 || new_card >= double(child_stats.cardinality)) {
-		// We have no good statistics on distinct count.
-		// most likely we are running on parquet files. Therefore we divide by 2.
-		new_card = (double)child_stats.cardinality / 2;
-	}
-	// an ungrouped aggregate has 1 row
-	stats.cardinality = aggr.groups.empty() ? 1 : LossyNumericCast<idx_t>(new_card);
-	stats.column_names = child_stats.column_names;
-	stats.stats_initialized = true;
-	auto num_child_columns = aggr.GetColumnBindings().size();
-
-	for (idx_t column_index = child_stats.column_distinct_count.size(); column_index < num_child_columns;
-	     column_index++) {
-		stats.column_distinct_count.push_back(DistinctCount({child_stats.cardinality, false}));
-		stats.column_names.push_back("aggregate");
-	}
-	return stats;
-}
-
-RelationStats RelationStatisticsHelper::ExtractEmptyResultStats(LogicalEmptyResult &empty) {
-	RelationStats stats;
-	for (idx_t i = 0; i < empty.GetColumnBindings().size(); i++) {
-		stats.column_distinct_count.push_back(DistinctCount({0, false}));
-		stats.column_names.push_back("empty_result_column");
-	}
-	stats.stats_initialized = true;
-	return stats;
-}
-
-idx_t RelationStatisticsHelper::InspectTableFilter(idx_t cardinality, idx_t column_index, TableFilter &filter,
-                                                   BaseStatistics &base_stats) {
-	auto cardinality_after_filters = cardinality;
-	switch (filter.filter_type) {
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &and_filter = filter.Cast<ConjunctionAndFilter>();
-		for (auto &child_filter : and_filter.child_filters) {
-			cardinality_after_filters = MinValue(
-			    cardinality_after_filters, InspectTableFilter(cardinality, column_index, *child_filter, base_stats));
-		}
-		return cardinality_after_filters;
-	}
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &comparison_filter = filter.Cast<ConstantFilter>();
-		if (comparison_filter.comparison_type != ExpressionType::COMPARE_EQUAL) {
-			return cardinality_after_filters;
-		}
-		auto column_count = base_stats.GetDistinctCount();
-		// column_count = 0 when there is no column count (i.e parquet scans)
-		if (column_count > 0) {
-			// we want the ceil of cardinality/column_count. We also want to avoid compiler errors
-			cardinality_after_filters = (cardinality + column_count - 1) / column_count;
-		}
-		return cardinality_after_filters;
-	}
-	default:
-		return cardinality_after_filters;
-	}
-}
-
-// TODO: Currently only simple AND filters are pushed into table scans.
-//  When OR filters are pushed this function can be added
-// idx_t RelationStatisticsHelper::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter
-// &filter,
-//                                                     BaseStatistics &base_stats) {
-//	auto has_equality_filter = false;
-//	auto cardinality_after_filters = cardinality;
-//	for (auto &child_filter : filter.child_filters) {
-//		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
-//			continue;
-//		}
-//		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
-//		if (comparison_filter.comparison_type == ExpressionType::COMPARE_EQUAL) {
-//			auto column_count = base_stats.GetDistinctCount();
-//			auto increment = MaxValue<idx_t>(((cardinality + column_count - 1) / column_count), 1);
-//			if (has_equality_filter) {
-//				cardinality_after_filters += increment;
-//			} else {
-//				cardinality_after_filters = increment;
-//			}
-//			has_equality_filter = true;
-//		}
-//		if (child_filter->filter_type == TableFilterType::CONJUNCTION_AND) {
-//			auto &and_filter = child_filter->Cast<ConjunctionAndFilter>();
-//			cardinality_after_filters = RelationStatisticsHelper::InspectConjunctionAND(
-//			    cardinality_after_filters, column_index, and_filter, base_stats);
-//			continue;
-//		}
-//	}
-//	D_ASSERT(cardinality_after_filters > 0);
-//	return cardinality_after_filters;
-//}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/limit_pushdown.cpp b/src/duckdb/src/optimizer/limit_pushdown.cpp
deleted file mode 100644
index e47f00939..000000000
--- a/src/duckdb/src/optimizer/limit_pushdown.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/optimizer/limit_pushdown.hpp"
-
-#include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-namespace duckdb {
-
-bool LimitPushdown::CanOptimize(duckdb::LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_LIMIT &&
-	    op.children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		auto &limit = op.Cast<LogicalLimit>();
-
-		if (limit.offset_val.Type() == LimitNodeType::EXPRESSION_PERCENTAGE ||
-		    limit.offset_val.Type() == LimitNodeType::EXPRESSION_VALUE) {
-			// Offset cannot be an expression
-			return false;
-		}
-
-		if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE && limit.limit_val.GetConstantValue() < 8192) {
-			// Push down only when limit value is smaller than 8192.
-			// when physical_limit is introduced, it will end a parallel pipeline
-			// restrict the limit value to be small so that remaining operations run fast without parallelization.
-			return true;
-		}
-	}
-	return false;
-}
-
-unique_ptr<LogicalOperator> LimitPushdown::Optimize(unique_ptr<LogicalOperator> op) {
-	if (CanOptimize(*op)) {
-		auto projection = std::move(op->children[0]);
-		op->children[0] = std::move(projection->children[0]);
-		projection->SetEstimatedCardinality(op->estimated_cardinality);
-		projection->children[0] = std::move(op);
-		swap(projection, op);
-	}
-	for (auto &child : op->children) {
-		child = Optimize(std::move(child));
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/matcher/expression_matcher.cpp b/src/duckdb/src/optimizer/matcher/expression_matcher.cpp
deleted file mode 100644
index 499daa599..000000000
--- a/src/duckdb/src/optimizer/matcher/expression_matcher.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-
-#include "duckdb/planner/expression/list.hpp"
-
-namespace duckdb {
-
-bool ExpressionMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
-	if (type && !type->Match(expr.return_type)) {
-		return false;
-	}
-	if (expr_type && !expr_type->Match(expr.GetExpressionType())) {
-		return false;
-	}
-	if (expr_class != ExpressionClass::INVALID && expr_class != expr.GetExpressionClass()) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-bool ExpressionEqualityMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
-	if (!expr.Equals(expression)) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-bool CaseExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	return true;
-}
-
-bool ComparisonExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto &expr = expr_p.Cast<BoundComparisonExpression>();
-	vector<reference<Expression>> expressions;
-	expressions.push_back(*expr.left);
-	expressions.push_back(*expr.right);
-	return SetMatcher::Match(matchers, expressions, bindings, policy);
-}
-
-bool CastExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	if (!matcher) {
-		return true;
-	}
-	auto &expr = expr_p.Cast<BoundCastExpression>();
-	return matcher->Match(*expr.child, bindings);
-}
-
-bool InClauseExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto &expr = expr_p.Cast<BoundOperatorExpression>();
-	if (expr.GetExpressionType() != ExpressionType::COMPARE_IN ||
-	    expr.GetExpressionType() == ExpressionType::COMPARE_NOT_IN) {
-		return false;
-	}
-	return SetMatcher::Match(matchers, expr.children, bindings, policy);
-}
-
-bool ConjunctionExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto &expr = expr_p.Cast<BoundConjunctionExpression>();
-	if (!SetMatcher::Match(matchers, expr.children, bindings, policy)) {
-		return false;
-	}
-	return true;
-}
-
-bool FunctionExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto &expr = expr_p.Cast<BoundFunctionExpression>();
-	if (!FunctionMatcher::Match(function, expr.function.name)) {
-		return false;
-	}
-	if (!SetMatcher::Match(matchers, expr.children, bindings, policy)) {
-		return false;
-	}
-	return true;
-}
-
-bool AggregateExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto &expr = expr_p.Cast<BoundAggregateExpression>();
-	if (!FunctionMatcher::Match(function, expr.function.name)) {
-		return false;
-	}
-	// we should create matchers for these in the future
-	if (expr.filter || expr.order_bys || expr.aggr_type != AggregateType::NON_DISTINCT) {
-		return false;
-	}
-	if (!SetMatcher::Match(matchers, expr.children, bindings, policy)) {
-		return false;
-	}
-	return true;
-}
-
-bool FoldableConstantMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
-	// we match on ANY expression that is a scalar expression
-	if (!expr.IsFoldable()) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-bool StableExpressionMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
-	// we match on ANY expression that is a stable expression
-	if (expr.IsVolatile()) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/optimizer.cpp b/src/duckdb/src/optimizer/optimizer.cpp
deleted file mode 100644
index d5c466211..000000000
--- a/src/duckdb/src/optimizer/optimizer.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-#include "duckdb/optimizer/optimizer.hpp"
-
-#include "duckdb/execution/column_binding_resolver.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/optimizer/build_probe_side_optimizer.hpp"
-#include "duckdb/optimizer/column_lifetime_analyzer.hpp"
-#include "duckdb/optimizer/common_aggregate_optimizer.hpp"
-#include "duckdb/optimizer/cse_optimizer.hpp"
-#include "duckdb/optimizer/cte_filter_pusher.hpp"
-#include "duckdb/optimizer/deliminator.hpp"
-#include "duckdb/optimizer/empty_result_pullup.hpp"
-#include "duckdb/optimizer/expression_heuristics.hpp"
-#include "duckdb/optimizer/filter_pullup.hpp"
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/in_clause_rewriter.hpp"
-#include "duckdb/optimizer/join_filter_pushdown_optimizer.hpp"
-#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
-#include "duckdb/optimizer/limit_pushdown.hpp"
-#include "duckdb/optimizer/regex_range_filter.hpp"
-#include "duckdb/optimizer/remove_duplicate_groups.hpp"
-#include "duckdb/optimizer/remove_unused_columns.hpp"
-#include "duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp"
-#include "duckdb/optimizer/rule/equal_or_null_simplification.hpp"
-#include "duckdb/optimizer/rule/in_clause_simplification.hpp"
-#include "duckdb/optimizer/rule/join_dependent_filter.hpp"
-#include "duckdb/optimizer/rule/list.hpp"
-#include "duckdb/optimizer/sampling_pushdown.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/optimizer/sum_rewriter.hpp"
-#include "duckdb/optimizer/topn_optimizer.hpp"
-#include "duckdb/optimizer/unnest_rewriter.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/planner.hpp"
-
-namespace duckdb {
-
-Optimizer::Optimizer(Binder &binder, ClientContext &context) : context(context), binder(binder), rewriter(context) {
-	rewriter.rules.push_back(make_uniq<ConstantFoldingRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<DistributivityRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<ArithmeticSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<CaseSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<ConjunctionSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<DatePartSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<ComparisonSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<InClauseSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<EqualOrNullSimplification>(rewriter));
-	rewriter.rules.push_back(make_uniq<MoveConstantsRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<LikeOptimizationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<OrderedAggregateOptimizer>(rewriter));
-	rewriter.rules.push_back(make_uniq<DistinctAggregateOptimizer>(rewriter));
-	rewriter.rules.push_back(make_uniq<DistinctWindowedOptimizer>(rewriter));
-	rewriter.rules.push_back(make_uniq<RegexOptimizationRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<EmptyNeedleRemovalRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<EnumComparisonRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<JoinDependentFilterRule>(rewriter));
-	rewriter.rules.push_back(make_uniq<TimeStampComparison>(context, rewriter));
-
-#ifdef DEBUG
-	for (auto &rule : rewriter.rules) {
-		// root not defined in rule
-		D_ASSERT(rule->root);
-	}
-#endif
-}
-
-ClientContext &Optimizer::GetContext() {
-	return context;
-}
-
-bool Optimizer::OptimizerDisabled(OptimizerType type) {
-	return OptimizerDisabled(context, type);
-}
-
-bool Optimizer::OptimizerDisabled(ClientContext &context_p, OptimizerType type) {
-	auto &config = DBConfig::GetConfig(context_p);
-	return config.options.disabled_optimizers.find(type) != config.options.disabled_optimizers.end();
-}
-
-void Optimizer::RunOptimizer(OptimizerType type, const std::function<void()> &callback) {
-	if (OptimizerDisabled(type)) {
-		// optimizer is marked as disabled: skip
-		return;
-	}
-	auto &profiler = QueryProfiler::Get(context);
-	profiler.StartPhase(MetricsUtils::GetOptimizerMetricByType(type));
-	callback();
-	profiler.EndPhase();
-	if (plan) {
-		Verify(*plan);
-	}
-}
-
-void Optimizer::Verify(LogicalOperator &op) {
-	ColumnBindingResolver::Verify(op);
-}
-
-void Optimizer::RunBuiltInOptimizers() {
-	switch (plan->type) {
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-	case LogicalOperatorType::LOGICAL_SET:
-	case LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS:
-	case LogicalOperatorType::LOGICAL_CREATE_SECRET:
-	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		// skip optimizing simple & often-occurring plans unaffected by rewrites
-		if (plan->children.empty()) {
-			return;
-		}
-		break;
-	default:
-		break;
-	}
-	// first we perform expression rewrites using the ExpressionRewriter
-	// this does not change the logical plan structure, but only simplifies the expression trees
-	RunOptimizer(OptimizerType::EXPRESSION_REWRITER, [&]() { rewriter.VisitOperator(*plan); });
-
-	// transform ORDER BY + LIMIT to TopN
-	RunOptimizer(OptimizerType::SUM_REWRITER, [&]() {
-		SumRewriterOptimizer optimizer(*this);
-		optimizer.Optimize(plan);
-	});
-
-	// perform filter pullup
-	RunOptimizer(OptimizerType::FILTER_PULLUP, [&]() {
-		FilterPullup filter_pullup;
-		plan = filter_pullup.Rewrite(std::move(plan));
-	});
-
-	// perform filter pushdown
-	RunOptimizer(OptimizerType::FILTER_PUSHDOWN, [&]() {
-		FilterPushdown filter_pushdown(*this);
-		unordered_set<idx_t> top_bindings;
-		filter_pushdown.CheckMarkToSemi(*plan, top_bindings);
-		plan = filter_pushdown.Rewrite(std::move(plan));
-	});
-
-	// derive and push filters into materialized CTEs
-	RunOptimizer(OptimizerType::CTE_FILTER_PUSHER, [&]() {
-		CTEFilterPusher cte_filter_pusher(*this);
-		plan = cte_filter_pusher.Optimize(std::move(plan));
-	});
-
-	RunOptimizer(OptimizerType::REGEX_RANGE, [&]() {
-		RegexRangeFilter regex_opt;
-		plan = regex_opt.Rewrite(std::move(plan));
-	});
-
-	RunOptimizer(OptimizerType::IN_CLAUSE, [&]() {
-		InClauseRewriter ic_rewriter(context, *this);
-		plan = ic_rewriter.Rewrite(std::move(plan));
-	});
-
-	// removes any redundant DelimGets/DelimJoins
-	RunOptimizer(OptimizerType::DELIMINATOR, [&]() {
-		Deliminator deliminator;
-		plan = deliminator.Optimize(std::move(plan));
-	});
-
-	// Pulls up empty results
-	RunOptimizer(OptimizerType::EMPTY_RESULT_PULLUP, [&]() {
-		EmptyResultPullup empty_result_pullup;
-		plan = empty_result_pullup.Optimize(std::move(plan));
-	});
-
-	// then we perform the join ordering optimization
-	// this also rewrites cross products + filters into joins and performs filter pushdowns
-	RunOptimizer(OptimizerType::JOIN_ORDER, [&]() {
-		JoinOrderOptimizer optimizer(context);
-		plan = optimizer.Optimize(std::move(plan));
-	});
-
-	// rewrites UNNESTs in DelimJoins by moving them to the projection
-	RunOptimizer(OptimizerType::UNNEST_REWRITER, [&]() {
-		UnnestRewriter unnest_rewriter;
-		plan = unnest_rewriter.Optimize(std::move(plan));
-	});
-
-	// removes unused columns
-	RunOptimizer(OptimizerType::UNUSED_COLUMNS, [&]() {
-		RemoveUnusedColumns unused(binder, context, true);
-		unused.VisitOperator(*plan);
-	});
-
-	// Remove duplicate groups from aggregates
-	RunOptimizer(OptimizerType::DUPLICATE_GROUPS, [&]() {
-		RemoveDuplicateGroups remove;
-		remove.VisitOperator(*plan);
-	});
-
-	// then we extract common subexpressions inside the different operators
-	RunOptimizer(OptimizerType::COMMON_SUBEXPRESSIONS, [&]() {
-		CommonSubExpressionOptimizer cse_optimizer(binder);
-		cse_optimizer.VisitOperator(*plan);
-	});
-
-	// creates projection maps so unused columns are projected out early
-	RunOptimizer(OptimizerType::COLUMN_LIFETIME, [&]() {
-		ColumnLifetimeAnalyzer column_lifetime(*this, *plan, true);
-		column_lifetime.VisitOperator(*plan);
-	});
-
-	// Once we know the column lifetime, we have more information regarding
-	// what relations should be the build side/probe side.
-	RunOptimizer(OptimizerType::BUILD_SIDE_PROBE_SIDE, [&]() {
-		BuildProbeSideOptimizer build_probe_side_optimizer(context, *plan);
-		build_probe_side_optimizer.VisitOperator(*plan);
-	});
-
-	// pushes LIMIT below PROJECTION
-	RunOptimizer(OptimizerType::LIMIT_PUSHDOWN, [&]() {
-		LimitPushdown limit_pushdown;
-		plan = limit_pushdown.Optimize(std::move(plan));
-	});
-
-	// perform sampling pushdown
-	RunOptimizer(OptimizerType::SAMPLING_PUSHDOWN, [&]() {
-		SamplingPushdown sampling_pushdown;
-		plan = sampling_pushdown.Optimize(std::move(plan));
-	});
-
-	// transform ORDER BY + LIMIT to TopN
-	RunOptimizer(OptimizerType::TOP_N, [&]() {
-		TopN topn;
-		plan = topn.Optimize(std::move(plan));
-	});
-
-	// perform statistics propagation
-	column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map;
-	RunOptimizer(OptimizerType::STATISTICS_PROPAGATION, [&]() {
-		StatisticsPropagator propagator(*this, *plan);
-		propagator.PropagateStatistics(plan);
-		statistics_map = propagator.GetStatisticsMap();
-	});
-
-	// remove duplicate aggregates
-	RunOptimizer(OptimizerType::COMMON_AGGREGATE, [&]() {
-		CommonAggregateOptimizer common_aggregate;
-		common_aggregate.VisitOperator(*plan);
-	});
-
-	// creates projection maps so unused columns are projected out early
-	RunOptimizer(OptimizerType::COLUMN_LIFETIME, [&]() {
-		ColumnLifetimeAnalyzer column_lifetime(*this, *plan, true);
-		column_lifetime.VisitOperator(*plan);
-	});
-
-	// apply simple expression heuristics to get an initial reordering
-	RunOptimizer(OptimizerType::REORDER_FILTER, [&]() {
-		ExpressionHeuristics expression_heuristics(*this);
-		plan = expression_heuristics.Rewrite(std::move(plan));
-	});
-
-	// perform join filter pushdown after the dust has settled
-	RunOptimizer(OptimizerType::JOIN_FILTER_PUSHDOWN, [&]() {
-		JoinFilterPushdownOptimizer join_filter_pushdown(*this);
-		join_filter_pushdown.VisitOperator(*plan);
-	});
-}
-
-unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan_p) {
-	Verify(*plan_p);
-
-	this->plan = std::move(plan_p);
-
-	RunBuiltInOptimizers();
-
-	for (auto &optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) {
-		RunOptimizer(OptimizerType::EXTENSION, [&]() {
-			OptimizerExtensionInput input {GetContext(), *this, optimizer_extension.optimizer_info.get()};
-			optimizer_extension.optimize_function(input, plan);
-		});
-	}
-
-	Planner::VerifyPlan(context, plan);
-
-	return std::move(plan);
-}
-
-unique_ptr<Expression> Optimizer::BindScalarFunction(const string &name, unique_ptr<Expression> c1) {
-	vector<unique_ptr<Expression>> children;
-	children.push_back(std::move(c1));
-	return BindScalarFunction(name, std::move(children));
-}
-
-unique_ptr<Expression> Optimizer::BindScalarFunction(const string &name, unique_ptr<Expression> c1,
-                                                     unique_ptr<Expression> c2) {
-	vector<unique_ptr<Expression>> children;
-	children.push_back(std::move(c1));
-	children.push_back(std::move(c2));
-	return BindScalarFunction(name, std::move(children));
-}
-
-unique_ptr<Expression> Optimizer::BindScalarFunction(const string &name, vector<unique_ptr<Expression>> children) {
-	FunctionBinder binder(context);
-	ErrorData error;
-	auto expr = binder.BindScalarFunction(DEFAULT_SCHEMA, name, std::move(children), error);
-	if (error.HasError()) {
-		throw InternalException("Optimizer exception - failed to bind function %s: %s", name, error.Message());
-	}
-	return expr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pullup/pullup_both_side.cpp b/src/duckdb/src/optimizer/pullup/pullup_both_side.cpp
deleted file mode 100644
index 04bbb3f1b..000000000
--- a/src/duckdb/src/optimizer/pullup/pullup_both_side.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "duckdb/optimizer/filter_pullup.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::PullupBothSide(unique_ptr<LogicalOperator> op) {
-	FilterPullup left_pullup(true, can_add_column);
-	FilterPullup right_pullup(true, can_add_column);
-	op->children[0] = left_pullup.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pullup.Rewrite(std::move(op->children[1]));
-	D_ASSERT(left_pullup.can_add_column == can_add_column);
-	D_ASSERT(right_pullup.can_add_column == can_add_column);
-
-	// merging filter expressions
-	for (idx_t i = 0; i < right_pullup.filters_expr_pullup.size(); ++i) {
-		left_pullup.filters_expr_pullup.push_back(std::move(right_pullup.filters_expr_pullup[i]));
-	}
-
-	if (!left_pullup.filters_expr_pullup.empty()) {
-		return GeneratePullupFilter(std::move(op), left_pullup.filters_expr_pullup);
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pullup/pullup_filter.cpp b/src/duckdb/src/optimizer/pullup/pullup_filter.cpp
deleted file mode 100644
index 95fd7f7bb..000000000
--- a/src/duckdb/src/optimizer/pullup/pullup_filter.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/optimizer/filter_pullup.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::PullupFilter(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
-
-	auto &filter = op->Cast<LogicalFilter>();
-	if (can_pullup && !filter.HasProjectionMap()) {
-		unique_ptr<LogicalOperator> child = std::move(op->children[0]);
-		child = Rewrite(std::move(child));
-		// moving filter's expressions
-		for (idx_t i = 0; i < op->expressions.size(); ++i) {
-			filters_expr_pullup.push_back(std::move(op->expressions[i]));
-		}
-		return child;
-	}
-	op->children[0] = Rewrite(std::move(op->children[0]));
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pullup/pullup_from_left.cpp b/src/duckdb/src/optimizer/pullup/pullup_from_left.cpp
deleted file mode 100644
index c2014de7d..000000000
--- a/src/duckdb/src/optimizer/pullup/pullup_from_left.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/optimizer/filter_pullup.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::PullupFromLeft(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_EXCEPT || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-
-	FilterPullup left_pullup(true, can_add_column);
-	FilterPullup right_pullup(false, can_add_column);
-
-	op->children[0] = left_pullup.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pullup.Rewrite(std::move(op->children[1]));
-
-	// check only for filters from the LHS
-	if (!left_pullup.filters_expr_pullup.empty() && right_pullup.filters_expr_pullup.empty()) {
-		return GeneratePullupFilter(std::move(op), left_pullup.filters_expr_pullup);
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pullup/pullup_projection.cpp b/src/duckdb/src/optimizer/pullup/pullup_projection.cpp
deleted file mode 100644
index 0149fbcf2..000000000
--- a/src/duckdb/src/optimizer/pullup/pullup_projection.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "duckdb/optimizer/filter_pullup.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-
-namespace duckdb {
-
-static void RevertFilterPullup(LogicalProjection &proj, vector<unique_ptr<Expression>> &expressions) {
-	unique_ptr<LogicalFilter> filter = make_uniq<LogicalFilter>();
-	for (idx_t i = 0; i < expressions.size(); ++i) {
-		filter->expressions.push_back(std::move(expressions[i]));
-	}
-	expressions.clear();
-	filter->children.push_back(std::move(proj.children[0]));
-	proj.children[0] = std::move(filter);
-}
-
-static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expressions, Expression &expr,
-                                     idx_t proj_table_idx) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		bool found_proj_col = false;
-		BoundColumnRefExpression &colref = expr.Cast<BoundColumnRefExpression>();
-		// find the corresponding column index in the projection expressions
-		for (idx_t proj_idx = 0; proj_idx < proj_expressions.size(); proj_idx++) {
-			auto &proj_expr = *proj_expressions[proj_idx];
-			if (proj_expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-				if (colref.Equals(proj_expr)) {
-					colref.binding.table_index = proj_table_idx;
-					colref.binding.column_index = proj_idx;
-					found_proj_col = true;
-					break;
-				}
-			}
-		}
-		if (!found_proj_col) {
-			// Project a new column
-			auto new_colref = colref.Copy();
-			colref.binding.table_index = proj_table_idx;
-			colref.binding.column_index = proj_expressions.size();
-			proj_expressions.push_back(std::move(new_colref));
-		}
-	}
-	ExpressionIterator::EnumerateChildren(
-	    expr, [&](Expression &child) { return ReplaceExpressionBinding(proj_expressions, child, proj_table_idx); });
-}
-
-void FilterPullup::ProjectSetOperation(LogicalProjection &proj) {
-	vector<unique_ptr<Expression>> copy_proj_expressions;
-	// copying the project expressions, it's useful whether we should revert the filter pullup
-	for (idx_t i = 0; i < proj.expressions.size(); ++i) {
-		copy_proj_expressions.push_back(proj.expressions[i]->Copy());
-	}
-
-	// Replace filter expression bindings, when need we add new columns into the copied projection expression
-	vector<unique_ptr<Expression>> changed_filter_expressions;
-	for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-		auto copy_filter_expr = filters_expr_pullup[i]->Copy();
-		ReplaceExpressionBinding(copy_proj_expressions, (Expression &)*copy_filter_expr, proj.table_index);
-		changed_filter_expressions.push_back(std::move(copy_filter_expr));
-	}
-
-	/// Case new columns were added into the projection
-	// we must skip filter pullup because adding new columns to these operators will change the result
-	if (copy_proj_expressions.size() > proj.expressions.size()) {
-		RevertFilterPullup(proj, filters_expr_pullup);
-		return;
-	}
-
-	// now we must replace the filter bindings
-	D_ASSERT(filters_expr_pullup.size() == changed_filter_expressions.size());
-	for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-		filters_expr_pullup[i] = std::move(changed_filter_expressions[i]);
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupProjection(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	op->children[0] = Rewrite(std::move(op->children[0]));
-	if (!filters_expr_pullup.empty()) {
-		auto &proj = op->Cast<LogicalProjection>();
-		// INTERSECT, EXCEPT, and DISTINCT
-		if (!can_add_column) {
-			// special treatment for operators that cannot add columns, e.g., INTERSECT, EXCEPT, and DISTINCT
-			ProjectSetOperation(proj);
-			return op;
-		}
-
-		for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-			auto &expr = (Expression &)*filters_expr_pullup[i];
-			ReplaceExpressionBinding(proj.expressions, expr, proj.table_index);
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pullup/pullup_set_operation.cpp b/src/duckdb/src/optimizer/pullup/pullup_set_operation.cpp
deleted file mode 100644
index 00f642ca0..000000000
--- a/src/duckdb/src/optimizer/pullup/pullup_set_operation.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/optimizer/filter_pullup.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-
-namespace duckdb {
-
-static void ReplaceFilterTableIndex(Expression &expr, LogicalSetOperation &setop) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr.Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.depth == 0);
-
-		colref.binding.table_index = setop.table_index;
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ReplaceFilterTableIndex(child, setop); });
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupSetOperation(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_INTERSECT || op->type == LogicalOperatorType::LOGICAL_EXCEPT);
-	can_add_column = false;
-	can_pullup = true;
-	if (op->type == LogicalOperatorType::LOGICAL_INTERSECT) {
-		op = PullupBothSide(std::move(op));
-	} else {
-		// EXCEPT only pull ups from LHS
-		op = PullupFromLeft(std::move(op));
-	}
-	if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
-		auto &filter = op->Cast<LogicalFilter>();
-		auto &setop = filter.children[0]->Cast<LogicalSetOperation>();
-		for (idx_t i = 0; i < filter.expressions.size(); ++i) {
-			ReplaceFilterTableIndex(*filter.expressions[i], setop);
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp
deleted file mode 100644
index eb5f803b6..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, unique_ptr<Expression> expr) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr->Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.binding.table_index == proj.group_index);
-		D_ASSERT(colref.binding.column_index < proj.groups.size());
-		D_ASSERT(colref.depth == 0);
-		// replace the binding with a copy to the expression at the referenced index
-		return proj.groups[colref.binding.column_index]->Copy();
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceGroupBindings(proj, std::move(child)); });
-	return expr;
-}
-
-void FilterPushdown::ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindings) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr.Cast<BoundColumnRefExpression>();
-		bindings.push_back(colref.binding);
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractFilterBindings(child, bindings); });
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY);
-	auto &aggr = op->Cast<LogicalAggregate>();
-
-	// pushdown into AGGREGATE and GROUP BY
-	// we cannot push expressions that refer to the aggregate
-	FilterPushdown child_pushdown(optimizer, convert_mark_joins);
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto &f = *filters[i];
-		if (f.bindings.find(aggr.aggregate_index) != f.bindings.end()) {
-			// filter on aggregate: cannot pushdown
-			continue;
-		}
-		if (f.bindings.find(aggr.groupings_index) != f.bindings.end()) {
-			// filter on GROUPINGS function: cannot pushdown
-			continue;
-		}
-		// no aggregate! we are filtering on a group
-		// we can only push this down if the filter is in all grouping sets
-		if (aggr.grouping_sets.empty()) {
-			// empty grouping set - we cannot pushdown the filter
-			continue;
-		}
-
-		vector<ColumnBinding> bindings;
-		ExtractFilterBindings(*f.filter, bindings);
-		if (bindings.empty()) {
-			// we can never push down empty grouping sets
-			continue;
-		}
-
-		bool can_pushdown_filter = true;
-		for (auto &grp : aggr.grouping_sets) {
-			// check for each of the grouping sets if they contain all groups
-			for (auto &binding : bindings) {
-				if (grp.find(binding.column_index) == grp.end()) {
-					can_pushdown_filter = false;
-					break;
-				}
-			}
-			if (!can_pushdown_filter) {
-				break;
-			}
-		}
-		if (!can_pushdown_filter) {
-			continue;
-		}
-		// no aggregate! we can push this down
-		// rewrite any group bindings within the filter
-		f.filter = ReplaceGroupBindings(aggr, std::move(f.filter));
-		// add the filter to the child node
-		if (child_pushdown.AddFilter(std::move(f.filter)) == FilterResult::UNSATISFIABLE) {
-			// filter statically evaluates to false, strip tree
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		}
-		// erase the filter from here
-		filters.erase_at(i);
-		i--;
-	}
-	child_pushdown.GenerateFilters();
-
-	op->children[0] = child_pushdown.Rewrite(std::move(op->children[0]));
-	return FinishPushdown(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp
deleted file mode 100644
index 40ff4dc3c..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->children.size() > 1);
-	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
-	vector<unique_ptr<Expression>> join_expressions;
-	auto join_ref_type = JoinRefType::REGULAR;
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		break;
-	default:
-		throw InternalException("Unsupported join type for cross product push down");
-	}
-	unordered_set<idx_t> left_bindings, right_bindings;
-	if (!filters.empty()) {
-		// check to see into which side we should push the filters
-		// first get the LHS and RHS bindings
-		LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
-		LogicalJoin::GetTableReferences(*op->children[1], right_bindings);
-		// now check the set of filters
-		for (auto &f : filters) {
-			auto side = JoinSide::GetJoinSide(f->bindings, left_bindings, right_bindings);
-			if (side == JoinSide::LEFT) {
-				// bindings match left side: push into left
-				left_pushdown.filters.push_back(std::move(f));
-			} else if (side == JoinSide::RIGHT) {
-				right_pushdown.filters.push_back(std::move(f));
-			} else {
-				D_ASSERT(side == JoinSide::BOTH || side == JoinSide::NONE);
-				// bindings match both: turn into join condition
-				join_expressions.push_back(std::move(f->filter));
-			}
-		}
-	}
-
-	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-
-	if (!join_expressions.empty()) {
-		// join conditions found: turn into inner join
-		// extract join conditions
-		vector<JoinCondition> conditions;
-		vector<unique_ptr<Expression>> arbitrary_expressions;
-		const auto join_type = JoinType::INNER;
-		LogicalComparisonJoin::ExtractJoinConditions(GetContext(), join_type, join_ref_type, op->children[0],
-		                                             op->children[1], left_bindings, right_bindings, join_expressions,
-		                                             conditions, arbitrary_expressions);
-		// create the join from the join conditions
-		auto new_op = LogicalComparisonJoin::CreateJoin(GetContext(), join_type, join_ref_type,
-		                                                std::move(op->children[0]), std::move(op->children[1]),
-		                                                std::move(conditions), std::move(arbitrary_expressions));
-
-		// possible cases are: AnyJoin, ComparisonJoin, or Filter + ComparisonJoin
-		if (op->has_estimated_cardinality) {
-			// set the estimated cardinality of the new operator
-			new_op->SetEstimatedCardinality(op->estimated_cardinality);
-			if (new_op->type == LogicalOperatorType::LOGICAL_FILTER) {
-				// if the new operators are Filter + ComparisonJoin, also set the estimated cardinality for the join
-				D_ASSERT(new_op->children[0]->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-				new_op->children[0]->SetEstimatedCardinality(op->estimated_cardinality);
-			}
-		}
-		return new_op;
-	} else {
-		// no join conditions found: keep as cross product
-		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT);
-		return op;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_distinct.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_distinct.cpp
deleted file mode 100644
index 030d18190..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_distinct.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownDistinct(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_DISTINCT);
-	auto &distinct = op->Cast<LogicalDistinct>();
-	if (!distinct.order_by) {
-		// regular DISTINCT - can just push down
-		op->children[0] = Rewrite(std::move(op->children[0]));
-		return op;
-	}
-	// no pushdown through DISTINCT ON (yet?)
-	return FinishPushdown(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_filter.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_filter.cpp
deleted file mode 100644
index fdf6fbe6e..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_filter.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownFilter(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
-	auto &filter = op->Cast<LogicalFilter>();
-	if (filter.HasProjectionMap()) {
-		return FinishPushdown(std::move(op));
-	}
-	// filter: gather the filters and remove the filter from the set of operations
-	for (auto &expression : filter.expressions) {
-		if (AddFilter(std::move(expression)) == FilterResult::UNSATISFIABLE) {
-			// filter statically evaluates to false, strip tree
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		}
-	}
-	GenerateFilters();
-	return Rewrite(std::move(filter.children[0]));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp
deleted file mode 100644
index afc2f4b36..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-
-namespace duckdb {
-unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = op->Cast<LogicalGet>();
-
-	if (get.function.pushdown_complex_filter || get.function.filter_pushdown) {
-		// this scan supports some form of filter push-down
-		// check if there are any parameters
-		// if there are, invalidate them to force a re-bind on execution
-		for (auto &filter : filters) {
-			if (filter->filter->HasParameter()) {
-				// there is a parameter in the filters! invalidate it
-				BoundParameterExpression::InvalidateRecursive(*filter->filter);
-			}
-		}
-	}
-	if (get.function.pushdown_complex_filter) {
-		// for the remaining filters, check if we can push any of them into the scan as well
-		vector<unique_ptr<Expression>> expressions;
-		expressions.reserve(filters.size());
-		for (auto &filter : filters) {
-			expressions.push_back(std::move(filter->filter));
-		}
-		filters.clear();
-
-		get.function.pushdown_complex_filter(optimizer.context, get, get.bind_data.get(), expressions);
-
-		if (expressions.empty()) {
-			return op;
-		}
-		// re-generate the filters
-		for (auto &expr : expressions) {
-			auto f = make_uniq<Filter>();
-			f->filter = std::move(expr);
-			f->ExtractBindings();
-			filters.push_back(std::move(f));
-		}
-	}
-
-	if (!get.table_filters.filters.empty() || !get.function.filter_pushdown) {
-		// the table function does not support filter pushdown: push a LogicalFilter on top
-		return FinishPushdown(std::move(op));
-	}
-	PushFilters();
-
-	//! We generate the table filters that will be executed during the table scan
-	//! Right now this only executes simple AND filters
-	get.table_filters = combiner.GenerateTableScanFilters(get.GetColumnIds());
-
-	GenerateFilters();
-
-	//! Now we try to pushdown the remaining filters to perform zonemap checking
-	return FinishPushdown(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp
deleted file mode 100644
index 8370f4ca9..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<LogicalOperator> op,
-                                                              unordered_set<idx_t> &left_bindings,
-                                                              unordered_set<idx_t> &right_bindings) {
-	auto &join = op->Cast<LogicalJoin>();
-	D_ASSERT(join.join_type == JoinType::INNER);
-	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return FinishPushdown(std::move(op));
-	}
-	// inner join: gather all the conditions of the inner join and add to the filter list
-	if (op->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
-		auto &any_join = join.Cast<LogicalAnyJoin>();
-		// any join: only one filter to add
-		if (AddFilter(std::move(any_join.condition)) == FilterResult::UNSATISFIABLE) {
-			// filter statically evaluates to false, strip tree
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		}
-	} else {
-		// comparison join
-		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-		auto &comp_join = join.Cast<LogicalComparisonJoin>();
-		// turn the conditions into filters
-		for (auto &i : comp_join.conditions) {
-			auto condition = JoinCondition::CreateExpression(std::move(i));
-			if (AddFilter(std::move(condition)) == FilterResult::UNSATISFIABLE) {
-				// filter statically evaluates to false, strip tree
-				return make_uniq<LogicalEmptyResult>(std::move(op));
-			}
-		}
-	}
-	GenerateFilters();
-
-	// turn the inner join into a cross product
-	auto cross_product = make_uniq<LogicalCrossProduct>(std::move(op->children[0]), std::move(op->children[1]));
-
-	// preserve the estimated cardinality of the operator
-	if (op->has_estimated_cardinality) {
-		cross_product->SetEstimatedCardinality(op->estimated_cardinality);
-	}
-
-	// then push down cross product
-	return PushdownCrossProduct(std::move(cross_product));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp
deleted file mode 100644
index 814adadc0..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-static unique_ptr<Expression> ReplaceColRefWithNull(unique_ptr<Expression> expr, unordered_set<idx_t> &right_bindings) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-		if (right_bindings.find(bound_colref.binding.table_index) != right_bindings.end()) {
-			// bound colref belongs to RHS
-			// replace it with a constant NULL
-			return make_uniq<BoundConstantExpression>(Value(expr->return_type));
-		}
-		return expr;
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceColRefWithNull(std::move(child), right_bindings); });
-	return expr;
-}
-
-static bool FilterRemovesNull(ClientContext &context, ExpressionRewriter &rewriter, Expression *expr,
-                              unordered_set<idx_t> &right_bindings) {
-	// make a copy of the expression
-	auto copy = expr->Copy();
-	// replace all BoundColumnRef expressions from the RHS with NULL constants in the copied expression
-	copy = ReplaceColRefWithNull(std::move(copy), right_bindings);
-
-	// attempt to flatten the expression by running the expression rewriter on it
-	auto filter = make_uniq<LogicalFilter>();
-	filter->expressions.push_back(std::move(copy));
-	rewriter.VisitOperator(*filter);
-
-	// check if all expressions are foldable
-	for (idx_t i = 0; i < filter->expressions.size(); i++) {
-		if (!filter->expressions[i]->IsFoldable()) {
-			return false;
-		}
-		// we flattened the result into a scalar, check if it is FALSE or NULL
-		auto val =
-		    ExpressionExecutor::EvaluateScalar(context, *filter->expressions[i]).DefaultCastAs(LogicalType::BOOLEAN);
-		// if the result of the expression with all expressions replaced with NULL is "NULL" or "false"
-		// then any extra entries generated by the LEFT OUTER JOIN will be filtered out!
-		// hence the LEFT OUTER JOIN is equivalent to an inner join
-		if (val.IsNull() || !BooleanValue::Get(val)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalOperator> op,
-                                                             unordered_set<idx_t> &left_bindings,
-                                                             unordered_set<idx_t> &right_bindings) {
-	auto &join = op->Cast<LogicalJoin>();
-	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return FinishPushdown(std::move(op));
-	}
-	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
-	// for a comparison join we create a FilterCombiner that checks if we can push conditions on LHS join conditions
-	// into the RHS of the join
-	FilterCombiner filter_combiner(optimizer);
-	const auto isComparison = (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	                           op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
-	if (isComparison) {
-		// add all comparison conditions
-		auto &comparison_join = op->Cast<LogicalComparisonJoin>();
-		for (auto &cond : comparison_join.conditions) {
-			filter_combiner.AddFilter(
-			    make_uniq<BoundComparisonExpression>(cond.comparison, cond.left->Copy(), cond.right->Copy()));
-		}
-	}
-	// now check the set of filters
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
-		if (side == JoinSide::LEFT) {
-			// bindings match left side
-			// we can push the filter into the left side
-			if (isComparison) {
-				// we MIGHT be able to push it down the RHS as well, but only if it is a comparison that matches the
-				// join predicates we use the FilterCombiner to figure this out add the expression to the FilterCombiner
-				filter_combiner.AddFilter(filters[i]->filter->Copy());
-			}
-			left_pushdown.filters.push_back(std::move(filters[i]));
-			// erase the filter from the list of filters
-			filters.erase_at(i);
-			i--;
-		} else if (op->type != LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			// bindings match right side or both sides: we cannot directly push it into the right
-			// however, if the filter removes rows with null values from the RHS we can turn the left outer join
-			// in an inner join, and then push down as we would push down an inner join
-			// Edit: This is only possible if the bindings match BOTH sides, so the filter can be pushed down to both
-			// children. If the filter can only be applied to the right side, and the filter filters
-			// all tuples, then the inner join cannot be converted.
-			if (FilterRemovesNull(optimizer.context, optimizer.rewriter, filters[i]->filter.get(), right_bindings)) {
-				// the filter removes NULL values, turn it into an inner join
-				join.join_type = JoinType::INNER;
-				// now we can do more pushdown
-				// move all filters we added to the left_pushdown back into the filter list
-				for (auto &left_filter : left_pushdown.filters) {
-					filters.push_back(std::move(left_filter));
-				}
-				// now push down the inner join
-				return PushdownInnerJoin(std::move(op), left_bindings, right_bindings);
-			}
-		}
-	}
-	// finally we check the FilterCombiner to see if there are any predicates we can push into the RHS
-	// we only added (1) predicates that have JoinSide::BOTH from the conditions, and
-	// (2) predicates that have JoinSide::LEFT from the filters
-	// we check now if this combination generated any new filters that are only on JoinSide::RIGHT
-	// this happens if, e.g. a join condition is (i=a) and there is a filter (i=500), we can then push the filter
-	// (a=500) into the RHS
-	filter_combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
-		if (JoinSide::GetJoinSide(*filter, left_bindings, right_bindings) == JoinSide::RIGHT) {
-			right_pushdown.AddFilter(std::move(filter));
-		}
-	});
-	right_pushdown.GenerateFilters();
-	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return PushFinalFilters(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_limit.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_limit.cpp
deleted file mode 100644
index 10487bbdc..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_limit.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownLimit(unique_ptr<LogicalOperator> op) {
-	auto &limit = op->Cast<LogicalLimit>();
-
-	if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE && limit.limit_val.GetConstantValue() == 0) {
-		return make_uniq<LogicalEmptyResult>(std::move(op));
-	}
-
-	return FinishPushdown(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp
deleted file mode 100644
index 8958bb88a..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalOperator> op,
-                                                             unordered_set<idx_t> &left_bindings,
-                                                             unordered_set<idx_t> &right_bindings) {
-	auto op_bindings = op->GetColumnBindings();
-	auto &join = op->Cast<LogicalJoin>();
-	auto &comp_join = op->Cast<LogicalComparisonJoin>();
-	D_ASSERT(join.join_type == JoinType::MARK);
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN || op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
-
-	right_bindings.insert(comp_join.mark_index);
-	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
-#ifdef DEBUG
-	bool simplified_mark_join = false;
-#endif
-	// now check the set of filters
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
-		if (side == JoinSide::LEFT) {
-			// bindings match left side: push into left
-			left_pushdown.filters.push_back(std::move(filters[i]));
-			// erase the filter from the list of filters
-			filters.erase_at(i);
-			i--;
-		} else if (side == JoinSide::RIGHT) {
-#ifdef DEBUG
-			D_ASSERT(!simplified_mark_join);
-#endif
-			// this filter references the marker
-			// we can turn this into a SEMI join if the filter is on only the marker
-			if (filters[i]->filter->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF && convert_mark_joins &&
-			    comp_join.convert_mark_to_semi) {
-				// filter just references the marker: turn into semi join
-#ifdef DEBUG
-				simplified_mark_join = true;
-#endif
-				join.join_type = JoinType::SEMI;
-				filters.erase_at(i);
-				i--;
-				continue;
-			}
-			// if the filter is on NOT(marker) AND the join conditions are all set to "null_values_are_equal" we can
-			// turn this into an ANTI join if all join conditions have null_values_are_equal=true, then the result of
-			// the MARK join is always TRUE or FALSE, and never NULL this happens in the case of a correlated EXISTS
-			// clause
-			if (filters[i]->filter->GetExpressionType() == ExpressionType::OPERATOR_NOT) {
-				auto &op_expr = filters[i]->filter->Cast<BoundOperatorExpression>();
-				if (op_expr.children[0]->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-					// the filter is NOT(marker), check the join conditions
-					bool all_null_values_are_equal = true;
-					for (auto &cond : comp_join.conditions) {
-						if (cond.comparison != ExpressionType::COMPARE_DISTINCT_FROM &&
-						    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-							all_null_values_are_equal = false;
-							break;
-						}
-					}
-					if (all_null_values_are_equal && convert_mark_joins && comp_join.convert_mark_to_semi) {
-#ifdef DEBUG
-						simplified_mark_join = true;
-#endif
-						// all null values are equal, convert to ANTI join
-						join.join_type = JoinType::ANTI;
-						filters.erase_at(i);
-						i--;
-						continue;
-					}
-				}
-			}
-		}
-	}
-	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return PushFinalFilters(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_projection.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_projection.cpp
deleted file mode 100644
index b10b60ae4..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_projection.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-static bool IsVolatile(LogicalProjection &proj, const unique_ptr<Expression> &expr) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr->Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.binding.table_index == proj.table_index);
-		D_ASSERT(colref.binding.column_index < proj.expressions.size());
-		D_ASSERT(colref.depth == 0);
-		if (proj.expressions[colref.binding.column_index]->IsVolatile()) {
-			return true;
-		}
-		return false;
-	}
-	bool is_volatile = false;
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { is_volatile |= IsVolatile(proj, child); });
-	return is_volatile;
-}
-
-static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj, unique_ptr<Expression> expr) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr->Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.binding.table_index == proj.table_index);
-		D_ASSERT(colref.binding.column_index < proj.expressions.size());
-		D_ASSERT(colref.depth == 0);
-		// replace the binding with a copy to the expression at the referenced index
-		return proj.expressions[colref.binding.column_index]->Copy();
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceProjectionBindings(proj, std::move(child)); });
-	return expr;
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	auto &proj = op->Cast<LogicalProjection>();
-	// push filter through logical projection
-	// all the BoundColumnRefExpressions in the filter should refer to the LogicalProjection
-	// we can rewrite them by replacing those references with the expression of the LogicalProjection node
-	FilterPushdown child_pushdown(optimizer, convert_mark_joins);
-	// There are some expressions can not be pushed down. We should keep them
-	// and add an extra filter operator.
-	vector<unique_ptr<Expression>> remain_expressions;
-	for (auto &filter : filters) {
-		auto &f = *filter;
-		D_ASSERT(f.bindings.size() <= 1);
-		bool is_volatile = IsVolatile(proj, f.filter);
-		if (is_volatile || f.filter->CanThrow()) {
-			// We can't push down related expressions if the column in the
-			// expression is generated by the functions which have side effects
-			remain_expressions.push_back(std::move(f.filter));
-		} else {
-			// rewrite the bindings within this subquery
-			f.filter = ReplaceProjectionBindings(proj, std::move(f.filter));
-			// add the filter to the child pushdown
-			if (child_pushdown.AddFilter(std::move(f.filter)) == FilterResult::UNSATISFIABLE) {
-				// filter statically evaluates to false, strip tree
-				return make_uniq<LogicalEmptyResult>(std::move(op));
-			}
-		}
-	}
-	child_pushdown.GenerateFilters();
-	// now push into children
-	op->children[0] = child_pushdown.Rewrite(std::move(op->children[0]));
-	if (op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		// child returns an empty result: generate an empty result here too
-		return make_uniq<LogicalEmptyResult>(std::move(op));
-	}
-	return AddLogicalFilter(std::move(op), std::move(remain_expressions));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_semi_anti_join.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_semi_anti_join.cpp
deleted file mode 100644
index 7d240e3f6..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_semi_anti_join.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownSemiAntiJoin(unique_ptr<LogicalOperator> op) {
-	auto &join = op->Cast<LogicalJoin>();
-	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return FinishPushdown(std::move(op));
-	}
-
-	// push all current filters down the left side
-	op->children[0] = Rewrite(std::move(op->children[0]));
-	FilterPushdown right_pushdown(optimizer, convert_mark_joins);
-	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-
-	bool left_empty = op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-	bool right_empty = op->children[1]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-	if (left_empty && right_empty) {
-		// both empty: return empty result
-		return make_uniq<LogicalEmptyResult>(std::move(op));
-	}
-	// TODO: if semi/anti join is created from a intersect/except statement, then we can
-	//  push filters down into both children.
-	// filter pushdown happens before join order optimization, so right_anti and right_semi are not possible yet here
-	if (left_empty) {
-		// left child is empty result
-		switch (join.join_type) {
-		case JoinType::ANTI:
-		case JoinType::SEMI:
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		default:
-			break;
-		}
-	} else if (right_empty) {
-		// right child is empty result
-		switch (join.join_type) {
-		case JoinType::ANTI:
-			// just return the left child.
-			return std::move(op->children[0]);
-		case JoinType::SEMI:
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		default:
-			break;
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_set_operation.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_set_operation.cpp
deleted file mode 100644
index 64f9fe18a..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_set_operation.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-static void ReplaceSetOpBindings(vector<ColumnBinding> &bindings, Filter &filter, Expression &expr,
-                                 LogicalSetOperation &setop) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr.Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.binding.table_index == setop.table_index);
-		D_ASSERT(colref.depth == 0);
-
-		// rewrite the binding by looking into the bound_tables list of the subquery
-		colref.binding = bindings[colref.binding.column_index];
-		filter.bindings.insert(colref.binding.table_index);
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(
-	    expr, [&](Expression &child) { ReplaceSetOpBindings(bindings, filter, child, setop); });
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_UNION || op->type == LogicalOperatorType::LOGICAL_EXCEPT ||
-	         op->type == LogicalOperatorType::LOGICAL_INTERSECT);
-	auto &setop = op->Cast<LogicalSetOperation>();
-
-	D_ASSERT(op->children.size() == 2);
-	auto left_bindings = op->children[0]->GetColumnBindings();
-	auto right_bindings = op->children[1]->GetColumnBindings();
-	if (left_bindings.size() != right_bindings.size()) {
-		throw InternalException("Filter pushdown - set operation LHS and RHS have incompatible counts");
-	}
-
-	// pushdown into set operation, we can duplicate the condition and pushdown the expressions into both sides
-	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
-	for (idx_t i = 0; i < filters.size(); i++) {
-		// first create a copy of the filter
-		auto right_filter = make_uniq<Filter>();
-		right_filter->filter = filters[i]->filter->Copy();
-
-		// in the original filter, rewrite references to the result of the union into references to the left_index
-		ReplaceSetOpBindings(left_bindings, *filters[i], *filters[i]->filter, setop);
-		// in the copied filter, rewrite references to the result of the union into references to the right_index
-		ReplaceSetOpBindings(right_bindings, *right_filter, *right_filter->filter, setop);
-
-		// extract bindings again
-		filters[i]->ExtractBindings();
-		right_filter->ExtractBindings();
-
-		// move the filters into the child pushdown nodes
-		left_pushdown.filters.push_back(std::move(filters[i]));
-		right_pushdown.filters.push_back(std::move(right_filter));
-	}
-
-	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-
-	bool left_empty = op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-	bool right_empty = op->children[1]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-	if (left_empty && right_empty) {
-		// both empty: return empty result
-		return make_uniq<LogicalEmptyResult>(std::move(op));
-	}
-	if (left_empty && setop.setop_all) {
-		// left child is empty result
-		switch (op->type) {
-		case LogicalOperatorType::LOGICAL_UNION:
-			if (op->children[1]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-				// union with empty left side: return right child
-				auto &projection = op->children[1]->Cast<LogicalProjection>();
-				projection.table_index = setop.table_index;
-				return std::move(op->children[1]);
-			}
-			break;
-		case LogicalOperatorType::LOGICAL_EXCEPT:
-			// except: if left child is empty, return empty result
-		case LogicalOperatorType::LOGICAL_INTERSECT:
-			// intersect: if any child is empty, return empty result itself
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		default:
-			throw InternalException("Unsupported set operation");
-		}
-	} else if (right_empty && setop.setop_all) {
-		// right child is empty result
-		switch (op->type) {
-		case LogicalOperatorType::LOGICAL_UNION:
-		case LogicalOperatorType::LOGICAL_EXCEPT:
-			if (op->children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-				// union or except with empty right child: return left child
-				auto &projection = op->children[0]->Cast<LogicalProjection>();
-				projection.table_index = setop.table_index;
-				return std::move(op->children[0]);
-			}
-			break;
-		case LogicalOperatorType::LOGICAL_INTERSECT:
-			// intersect: if any child is empty, return empty result itself
-			return make_uniq<LogicalEmptyResult>(std::move(op));
-		default:
-			throw InternalException("Unsupported set operation");
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp
deleted file mode 100644
index f205c6069..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<LogicalOperator> op,
-                                                               unordered_set<idx_t> &left_bindings,
-                                                               unordered_set<idx_t> &right_bindings) {
-	D_ASSERT(op->Cast<LogicalJoin>().join_type == JoinType::SINGLE);
-	FilterPushdown left_pushdown(optimizer, convert_mark_joins), right_pushdown(optimizer, convert_mark_joins);
-	// now check the set of filters
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
-		if (side == JoinSide::LEFT) {
-			// bindings match left side: push into left
-			left_pushdown.filters.push_back(std::move(filters[i]));
-			// erase the filter from the list of filters
-			filters.erase_at(i);
-			i--;
-		}
-	}
-	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return PushFinalFilters(std::move(op));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_unnest.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_unnest.cpp
deleted file mode 100644
index 9bdeb2567..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_unnest.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_unnest.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownUnnest(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = op->Cast<LogicalUnnest>();
-	// push filter through logical projection
-	// all the BoundColumnRefExpressions in the filter should refer to the LogicalProjection
-	// we can rewrite them by replacing those references with the expression of the LogicalProjection node
-	FilterPushdown child_pushdown(optimizer, convert_mark_joins);
-	// There are some expressions can not be pushed down. We should keep them
-	// and add an extra filter operator.
-	vector<unique_ptr<Expression>> remain_expressions;
-	for (auto &filter : filters) {
-		auto &f = *filter;
-		auto can_push = true;
-		for (auto &binding : f.bindings) {
-			if (binding == unnest.unnest_index) {
-				can_push = false;
-				break;
-			}
-		}
-		// if the expression index table index is the unnest index, then the filter is on the
-		// unnest, and it should not be pushed down.
-		if (!can_push) {
-			// We can't push down related expressions if the column in the
-			// expression is generated by the functions which have side effects
-			remain_expressions.push_back(std::move(f.filter));
-		} else {
-			// add the filter to the child pushdown
-			if (child_pushdown.AddFilter(std::move(f.filter)) == FilterResult::UNSATISFIABLE) {
-				// filter statically evaluates to false, strip tree
-				return make_uniq<LogicalEmptyResult>(std::move(op));
-			}
-		}
-	}
-	child_pushdown.GenerateFilters();
-	// now push into children
-	op->children[0] = child_pushdown.Rewrite(std::move(op->children[0]));
-	if (op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		// child returns an empty result: generate an empty result here too
-		return make_uniq<LogicalEmptyResult>(std::move(op));
-	}
-	return AddLogicalFilter(std::move(op), std::move(remain_expressions));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_window.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_window.cpp
deleted file mode 100644
index a193b1e93..000000000
--- a/src/duckdb/src/optimizer/pushdown/pushdown_window.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-bool CanPushdownFilter(vector<column_binding_set_t> window_exprs_partition_bindings,
-                       const vector<ColumnBinding> &bindings) {
-	auto filter_on_all_partitions = true;
-	for (auto &partition_binding_set : window_exprs_partition_bindings) {
-		auto filter_on_binding_set = true;
-		for (auto &binding : bindings) {
-			if (partition_binding_set.find(binding) == partition_binding_set.end()) {
-				filter_on_binding_set = false;
-				break;
-			}
-		}
-		filter_on_all_partitions = filter_on_all_partitions && filter_on_binding_set;
-		if (!filter_on_all_partitions) {
-			break;
-		}
-	}
-	return filter_on_all_partitions;
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownWindow(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_WINDOW);
-	auto &window = op->Cast<LogicalWindow>();
-	FilterPushdown pushdown(optimizer, convert_mark_joins);
-
-	// 1. Loop throguh the expressions, find the window expressions and investigate the partitions
-	// if a filter applies to a partition in each window expression then you can push the filter
-	// into the children.
-	vector<column_binding_set_t> window_exprs_partition_bindings;
-	for (auto &expr : window.expressions) {
-		if (expr->GetExpressionClass() != ExpressionClass::BOUND_WINDOW) {
-			continue;
-		}
-		auto &window_expr = expr->Cast<BoundWindowExpression>();
-		auto &partitions = window_expr.partitions;
-		if (partitions.empty()) {
-			// If any window expression does not have partitions, we cannot push any filters.
-			// all window expressions need to be partitioned by the same column
-			// in order to push down the window.
-			return FinishPushdown(std::move(op));
-		}
-		column_binding_set_t partition_bindings;
-		// 2. Get the binding information of the partitions of the window expression
-		for (auto &partition_expr : partitions) {
-			switch (partition_expr->GetExpressionType()) {
-			// TODO: Add expressions for function expressions like FLOOR, CEIL etc.
-			case ExpressionType::BOUND_COLUMN_REF: {
-				auto &partition_col = partition_expr->Cast<BoundColumnRefExpression>();
-				partition_bindings.insert(partition_col.binding);
-				break;
-			}
-			default:
-				break;
-			}
-		}
-		window_exprs_partition_bindings.push_back(partition_bindings);
-	}
-
-	if (window_exprs_partition_bindings.empty()) {
-		return FinishPushdown(std::move(op));
-	}
-
-	vector<unique_ptr<Filter>> leftover_filters;
-	// Loop through the filters. If a filter is on a partition in every window expression
-	// it can be pushed down.
-	for (idx_t i = 0; i < filters.size(); i++) {
-		// the filter must be on all partition bindings
-		vector<ColumnBinding> bindings;
-		ExtractFilterBindings(*filters.at(i)->filter, bindings);
-		if (CanPushdownFilter(window_exprs_partition_bindings, bindings)) {
-			pushdown.filters.push_back(std::move(filters.at(i)));
-		} else {
-			leftover_filters.push_back(std::move(filters.at(i)));
-		}
-	}
-	op->children[0] = pushdown.Rewrite(std::move(op->children[0]));
-	filters = std::move(leftover_filters);
-	return FinishPushdown(std::move(op));
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/regex_range_filter.cpp b/src/duckdb/src/optimizer/regex_range_filter.cpp
deleted file mode 100644
index fd9f98fe6..000000000
--- a/src/duckdb/src/optimizer/regex_range_filter.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "duckdb/optimizer/regex_range_filter.hpp"
-
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-
-#include "duckdb/function/scalar/string_functions.hpp"
-
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-
-#include "duckdb/function/scalar/regexp.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator> op) {
-
-	for (idx_t child_idx = 0; child_idx < op->children.size(); child_idx++) {
-		op->children[child_idx] = Rewrite(std::move(op->children[child_idx]));
-	}
-
-	if (op->type != LogicalOperatorType::LOGICAL_FILTER) {
-		return op;
-	}
-
-	auto new_filter = make_uniq<LogicalFilter>();
-
-	for (auto &expr : op->expressions) {
-		if (expr->GetExpressionType() == ExpressionType::BOUND_FUNCTION) {
-			auto &func = expr->Cast<BoundFunctionExpression>();
-			if (func.function.name != "regexp_full_match" || func.children.size() != 2) {
-				continue;
-			}
-			auto &info = func.bind_info->Cast<RegexpMatchesBindData>();
-			if (!info.range_success) {
-				continue;
-			}
-			auto filter_left = make_uniq<BoundComparisonExpression>(
-			    ExpressionType::COMPARE_GREATERTHANOREQUALTO, func.children[0]->Copy(),
-			    make_uniq<BoundConstantExpression>(Value::BLOB_RAW(info.range_min)));
-			auto filter_right = make_uniq<BoundComparisonExpression>(
-			    ExpressionType::COMPARE_LESSTHANOREQUALTO, func.children[0]->Copy(),
-			    make_uniq<BoundConstantExpression>(Value::BLOB_RAW(info.range_max)));
-			auto filter_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-			                                                         std::move(filter_left), std::move(filter_right));
-
-			new_filter->expressions.push_back(std::move(filter_expr));
-		}
-	}
-
-	if (!new_filter->expressions.empty()) {
-		new_filter->children = std::move(op->children);
-		op->children.clear();
-		op->children.push_back(std::move(new_filter));
-	}
-
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/remove_duplicate_groups.cpp b/src/duckdb/src/optimizer/remove_duplicate_groups.cpp
deleted file mode 100644
index dd09c2f3d..000000000
--- a/src/duckdb/src/optimizer/remove_duplicate_groups.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include "duckdb/optimizer/remove_duplicate_groups.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-
-namespace duckdb {
-
-void RemoveDuplicateGroups::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		VisitAggregate(op.Cast<LogicalAggregate>());
-		break;
-	default:
-		break;
-	}
-	LogicalOperatorVisitor::VisitOperatorExpressions(op);
-	LogicalOperatorVisitor::VisitOperatorChildren(op);
-}
-
-void RemoveDuplicateGroups::VisitAggregate(LogicalAggregate &aggr) {
-	if (!aggr.grouping_functions.empty()) {
-		return;
-	}
-
-	auto &groups = aggr.groups;
-
-	column_binding_map_t<idx_t> duplicate_map;
-	vector<pair<idx_t, idx_t>> duplicates;
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		const auto &group = groups[group_idx];
-		if (group->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-			continue;
-		}
-		const auto &colref = group->Cast<BoundColumnRefExpression>();
-		const auto &binding = colref.binding;
-		const auto it = duplicate_map.find(binding);
-		if (it == duplicate_map.end()) {
-			duplicate_map.emplace(binding, group_idx);
-		} else {
-			duplicates.emplace_back(it->second, group_idx);
-		}
-	}
-
-	if (duplicates.empty()) {
-		return;
-	}
-
-	// Sort duplicates by max duplicate group idx, because we want to remove groups from the back
-	sort(duplicates.begin(), duplicates.end(),
-	     [](const pair<idx_t, idx_t> &lhs, const pair<idx_t, idx_t> &rhs) { return lhs.second > rhs.second; });
-
-	// Now we want to remove the duplicates, but this alters the column bindings coming out of the aggregate,
-	// so we keep track of how they shift and do another round of column binding replacements
-	column_binding_map_t<ColumnBinding> group_binding_map;
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		group_binding_map.emplace(ColumnBinding(aggr.group_index, group_idx),
-		                          ColumnBinding(aggr.group_index, group_idx));
-	}
-
-	for (idx_t duplicate_idx = 0; duplicate_idx < duplicates.size(); duplicate_idx++) {
-		const auto &duplicate = duplicates[duplicate_idx];
-		const auto &remaining_idx = duplicate.first;
-		const auto &removed_idx = duplicate.second;
-
-		// Store expression and remove it from groups
-		stored_expressions.emplace_back(std::move(groups[removed_idx]));
-		groups.erase_at(removed_idx);
-
-		// This optimizer should run before statistics propagation, so this should be empty
-		// If it runs after, then group_stats should be updated too
-		D_ASSERT(aggr.group_stats.empty());
-
-		// Remove from grouping sets too
-		for (auto &grouping_set : aggr.grouping_sets) {
-			// Replace removed group with duplicate remaining group
-			if (grouping_set.erase(removed_idx) != 0) {
-				grouping_set.insert(remaining_idx);
-			}
-
-			// Indices shifted: Reinsert groups in the set with group_idx - 1
-			vector<idx_t> group_indices_to_reinsert;
-			for (auto &entry : grouping_set) {
-				if (entry > removed_idx) {
-					group_indices_to_reinsert.emplace_back(entry);
-				}
-			}
-			for (const auto group_idx : group_indices_to_reinsert) {
-				grouping_set.erase(group_idx);
-			}
-			for (const auto group_idx : group_indices_to_reinsert) {
-				grouping_set.insert(group_idx - 1);
-			}
-		}
-
-		// Update mapping
-		auto it = group_binding_map.find(ColumnBinding(aggr.group_index, removed_idx));
-		D_ASSERT(it != group_binding_map.end());
-		it->second.column_index = remaining_idx;
-
-		for (auto &map_entry : group_binding_map) {
-			auto &new_binding = map_entry.second;
-			if (new_binding.column_index > removed_idx) {
-				new_binding.column_index--;
-			}
-		}
-	}
-
-	// Replace all references to the old group binding with the new group binding
-	for (const auto &map_entry : group_binding_map) {
-		auto it = column_references.find(map_entry.first);
-		if (it != column_references.end()) {
-			for (auto expr : it->second) {
-				expr.get().binding = map_entry.second;
-			}
-		}
-	}
-}
-
-unique_ptr<Expression> RemoveDuplicateGroups::VisitReplace(BoundColumnRefExpression &expr,
-                                                           unique_ptr<Expression> *expr_ptr) {
-	// add a column reference
-	column_references[expr.binding].push_back(expr);
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/remove_unused_columns.cpp b/src/duckdb/src/optimizer/remove_unused_columns.cpp
deleted file mode 100644
index 3a867bdf2..000000000
--- a/src/duckdb/src/optimizer/remove_unused_columns.cpp
+++ /dev/null
@@ -1,484 +0,0 @@
-#include "duckdb/optimizer/remove_unused_columns.hpp"
-
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include "duckdb/function/scalar/struct_utils.hpp"
-
-namespace duckdb {
-
-void RemoveUnusedColumns::ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding) {
-	auto colrefs = column_references.find(current_binding);
-	if (colrefs != column_references.end()) {
-		for (auto &colref_p : colrefs->second.bindings) {
-			auto &colref = colref_p.get();
-			D_ASSERT(colref.binding == current_binding);
-			colref.binding = new_binding;
-		}
-	}
-}
-
-template <class T>
-void RemoveUnusedColumns::ClearUnusedExpressions(vector<T> &list, idx_t table_idx, bool replace) {
-	idx_t offset = 0;
-	for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-		auto current_binding = ColumnBinding(table_idx, col_idx + offset);
-		auto entry = column_references.find(current_binding);
-		if (entry == column_references.end()) {
-			// this entry is not referred to, erase it from the set of expressions
-			list.erase_at(col_idx);
-			offset++;
-			col_idx--;
-		} else if (offset > 0 && replace) {
-			// column is used but the ColumnBinding has changed because of removed columns
-			ReplaceBinding(current_binding, ColumnBinding(table_idx, col_idx));
-		}
-	}
-}
-
-void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		// aggregate
-		if (!everything_referenced) {
-			// FIXME: groups that are not referenced need to stay -> but they don't need to be scanned and output!
-			auto &aggr = op.Cast<LogicalAggregate>();
-			ClearUnusedExpressions(aggr.expressions, aggr.aggregate_index);
-			if (aggr.expressions.empty() && aggr.groups.empty()) {
-				// removed all expressions from the aggregate: push a COUNT(*)
-				auto count_star_fun = CountStarFun::GetFunction();
-				FunctionBinder function_binder(context);
-				aggr.expressions.push_back(
-				    function_binder.BindAggregateFunction(count_star_fun, {}, nullptr, AggregateType::NON_DISTINCT));
-			}
-		}
-
-		// then recurse into the children of the aggregate
-		RemoveUnusedColumns remove(binder, context);
-		remove.VisitOperatorExpressions(op);
-		remove.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (!everything_referenced) {
-			auto &comp_join = op.Cast<LogicalComparisonJoin>();
-
-			if (comp_join.join_type != JoinType::INNER) {
-				break;
-			}
-			// for inner joins with equality predicates in the form of (X=Y)
-			// we can replace any references to the RHS (Y) to references to the LHS (X)
-			// this reduces the amount of columns we need to extract from the join hash table
-			for (auto &cond : comp_join.conditions) {
-				if (cond.comparison == ExpressionType::COMPARE_EQUAL) {
-					if (cond.left->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF &&
-					    cond.right->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-						// comparison join between two bound column refs
-						// we can replace any reference to the RHS (build-side) with a reference to the LHS (probe-side)
-						auto &lhs_col = cond.left->Cast<BoundColumnRefExpression>();
-						auto &rhs_col = cond.right->Cast<BoundColumnRefExpression>();
-						// if there are any columns that refer to the RHS,
-						auto colrefs = column_references.find(rhs_col.binding);
-						if (colrefs != column_references.end()) {
-							for (auto &entry : colrefs->second.bindings) {
-								auto &colref = entry.get();
-								colref.binding = lhs_col.binding;
-								AddBinding(colref);
-							}
-							column_references.erase(rhs_col.binding);
-						}
-					}
-				}
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		break;
-	case LogicalOperatorType::LOGICAL_UNION: {
-		auto &setop = op.Cast<LogicalSetOperation>();
-		if (setop.setop_all && !everything_referenced) {
-			// for UNION we can remove unreferenced columns if union all is used
-			// it's possible not all columns are referenced, but unreferenced columns in the union can
-			// still have an affect on the result of the union
-			vector<idx_t> entries;
-			for (idx_t i = 0; i < setop.column_count; i++) {
-				entries.push_back(i);
-			}
-			ClearUnusedExpressions(entries, setop.table_index);
-			if (entries.size() < setop.column_count) {
-				if (entries.empty()) {
-					// no columns referenced: this happens in the case of a COUNT(*)
-					// extract the first column
-					entries.push_back(0);
-				}
-				// columns were cleared
-				setop.column_count = entries.size();
-
-				for (idx_t child_idx = 0; child_idx < op.children.size(); child_idx++) {
-					RemoveUnusedColumns remove(binder, context, true);
-					auto &child = op.children[child_idx];
-
-					// we push a projection under this child that references the required columns of the union
-					child->ResolveOperatorTypes();
-					auto bindings = child->GetColumnBindings();
-					vector<unique_ptr<Expression>> expressions;
-					expressions.reserve(entries.size());
-					for (auto &column_idx : entries) {
-						expressions.push_back(
-						    make_uniq<BoundColumnRefExpression>(child->types[column_idx], bindings[column_idx]));
-					}
-					auto new_projection =
-					    make_uniq<LogicalProjection>(binder.GenerateTableIndex(), std::move(expressions));
-					if (child->has_estimated_cardinality) {
-						new_projection->SetEstimatedCardinality(child->estimated_cardinality);
-					}
-					new_projection->children.push_back(std::move(child));
-					op.children[child_idx] = std::move(new_projection);
-
-					remove.VisitOperator(*op.children[child_idx]);
-				}
-				return;
-			}
-		}
-		for (auto &child : op.children) {
-			RemoveUnusedColumns remove(binder, context, true);
-			remove.VisitOperator(*child);
-		}
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT: {
-		// for INTERSECT/EXCEPT operations we can't remove anything, just recursively visit the children
-		for (auto &child : op.children) {
-			RemoveUnusedColumns remove(binder, context, true);
-			remove.VisitOperator(*child);
-		}
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		if (!everything_referenced) {
-			auto &proj = op.Cast<LogicalProjection>();
-			ClearUnusedExpressions(proj.expressions, proj.table_index);
-
-			if (proj.expressions.empty()) {
-				// nothing references the projected expressions
-				// this happens in the case of e.g. EXISTS(SELECT * FROM ...)
-				// in this case we only need to project a single constant
-				proj.expressions.push_back(make_uniq<BoundConstantExpression>(Value::INTEGER(42)));
-			}
-		}
-		// then recurse into the children of this projection
-		RemoveUnusedColumns remove(binder, context);
-		remove.VisitOperatorExpressions(op);
-		remove.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_INSERT:
-	case LogicalOperatorType::LOGICAL_UPDATE:
-	case LogicalOperatorType::LOGICAL_DELETE: {
-		//! When RETURNING is used, a PROJECTION is the top level operator for INSERTS, UPDATES, and DELETES
-		//! We still need to project all values from these operators so the projection
-		//! on top of them can select from only the table values being inserted.
-		//! TODO: Push down the projections from the returning statement
-		//! TODO: Be careful because you might be adding expressions when a user returns *
-		RemoveUnusedColumns remove(binder, context, true);
-		remove.VisitOperatorExpressions(op);
-		remove.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_GET:
-		LogicalOperatorVisitor::VisitOperatorExpressions(op);
-		if (!everything_referenced) {
-			auto &get = op.Cast<LogicalGet>();
-			if (!get.function.projection_pushdown) {
-				return;
-			}
-
-			auto final_column_ids = get.GetColumnIds();
-
-			// Create "selection vector" of all column ids
-			vector<idx_t> proj_sel;
-			for (idx_t col_idx = 0; col_idx < final_column_ids.size(); col_idx++) {
-				proj_sel.push_back(col_idx);
-			}
-			// Create a copy that we can use to match ids later
-			auto col_sel = proj_sel;
-			// Clear unused ids, exclude filter columns that are projected out immediately
-			ClearUnusedExpressions(proj_sel, get.table_index, false);
-
-			vector<unique_ptr<Expression>> filter_expressions;
-			// for every table filter, push a column binding into the column references map to prevent the column from
-			// being projected out
-			for (auto &filter : get.table_filters.filters) {
-				optional_idx index;
-				for (idx_t i = 0; i < final_column_ids.size(); i++) {
-					if (final_column_ids[i].GetPrimaryIndex() == filter.first) {
-						index = i;
-						break;
-					}
-				}
-				if (!index.IsValid()) {
-					throw InternalException("Could not find column index for table filter");
-				}
-
-				auto column_type =
-				    filter.first == COLUMN_IDENTIFIER_ROW_ID ? LogicalType::ROW_TYPE : get.returned_types[filter.first];
-
-				ColumnBinding filter_binding(get.table_index, index.GetIndex());
-				auto column_ref = make_uniq<BoundColumnRefExpression>(std::move(column_type), filter_binding);
-				auto filter_expr = filter.second->ToExpression(*column_ref);
-				VisitExpression(&filter_expr);
-				filter_expressions.push_back(std::move(filter_expr));
-			}
-
-			// Clear unused ids, include filter columns that are projected out immediately
-			ClearUnusedExpressions(col_sel, get.table_index);
-
-			// Now set the column ids in the LogicalGet using the "selection vector"
-			vector<ColumnIndex> column_ids;
-			column_ids.reserve(col_sel.size());
-			for (auto col_sel_idx : col_sel) {
-				auto entry = column_references.find(ColumnBinding(get.table_index, col_sel_idx));
-				if (entry == column_references.end()) {
-					throw InternalException("RemoveUnusedColumns - could not find referenced column");
-				}
-				if (final_column_ids[col_sel_idx].HasChildren()) {
-					throw InternalException("RemoveUnusedColumns - LogicalGet::column_ids already has children");
-				}
-				ColumnIndex new_index(final_column_ids[col_sel_idx].GetPrimaryIndex(), entry->second.child_columns);
-				column_ids.emplace_back(new_index);
-			}
-			if (column_ids.empty()) {
-				// this generally means we are only interested in whether or not anything exists in the table (e.g.
-				// EXISTS(SELECT * FROM tbl)) in this case, we just scan the row identifier column as it means we do not
-				// need to read any of the columns
-				column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
-			}
-			get.SetColumnIds(std::move(column_ids));
-
-			if (get.function.filter_prune) {
-				// Now set the projection cols by matching the "selection vector" that excludes filter columns
-				// with the "selection vector" that includes filter columns
-				idx_t col_idx = 0;
-				for (auto proj_sel_idx : proj_sel) {
-					for (; col_idx < col_sel.size(); col_idx++) {
-						if (proj_sel_idx == col_sel[col_idx]) {
-							get.projection_ids.push_back(col_idx);
-							break;
-						}
-					}
-				}
-			}
-		}
-		return;
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		auto &distinct = op.Cast<LogicalDistinct>();
-		if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
-			// distinct type references columns that need to be distinct on, so no
-			// need to implicity reference everything.
-			break;
-		}
-		// distinct, all projected columns are used for the DISTINCT computation
-		// mark all columns as used and continue to the children
-		// FIXME: DISTINCT with expression list does not implicitly reference everything
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: {
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE: {
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_CTE_REF: {
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_PIVOT: {
-		everything_referenced = true;
-		break;
-	}
-	default:
-		break;
-	}
-	LogicalOperatorVisitor::VisitOperatorExpressions(op);
-	LogicalOperatorVisitor::VisitOperatorChildren(op);
-
-	if (op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN ||
-	    op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		auto &comp_join = op.Cast<LogicalComparisonJoin>();
-		// after removing duplicate columns we may have duplicate join conditions (if the join graph is cyclical)
-		vector<JoinCondition> unique_conditions;
-		for (auto &cond : comp_join.conditions) {
-			bool found = false;
-			for (auto &unique_cond : unique_conditions) {
-				if (cond.comparison == unique_cond.comparison && cond.left->Equals(*unique_cond.left) &&
-				    cond.right->Equals(*unique_cond.right)) {
-					found = true;
-					break;
-				}
-			}
-			if (!found) {
-				unique_conditions.push_back(std::move(cond));
-			}
-		}
-		comp_join.conditions = std::move(unique_conditions);
-	}
-}
-
-bool RemoveUnusedColumns::HandleStructExtractRecursive(Expression &expr, optional_ptr<BoundColumnRefExpression> &colref,
-                                                       vector<idx_t> &indexes) {
-	if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
-		return false;
-	}
-	auto &function = expr.Cast<BoundFunctionExpression>();
-	if (function.function.name != "struct_extract_at" && function.function.name != "struct_extract" &&
-	    function.function.name != "array_extract") {
-		return false;
-	}
-	if (!function.bind_info) {
-		return false;
-	}
-	if (function.children[0]->return_type.id() != LogicalTypeId::STRUCT) {
-		return false;
-	}
-	auto &bind_data = function.bind_info->Cast<StructExtractBindData>();
-	indexes.push_back(bind_data.index);
-	// struct extract, check if left child is a bound column ref
-	if (function.children[0]->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-		// column reference - check if it is a struct
-		auto &ref = function.children[0]->Cast<BoundColumnRefExpression>();
-		if (ref.return_type.id() != LogicalTypeId::STRUCT) {
-			return false;
-		}
-		colref = &ref;
-		return true;
-	}
-	// not a column reference - try to handle this recursively
-	if (!HandleStructExtractRecursive(*function.children[0], colref, indexes)) {
-		return false;
-	}
-	return true;
-}
-
-bool RemoveUnusedColumns::HandleStructExtract(Expression &expr) {
-	optional_ptr<BoundColumnRefExpression> colref;
-	vector<idx_t> indexes;
-	if (!HandleStructExtractRecursive(expr, colref, indexes)) {
-		return false;
-	}
-	D_ASSERT(!indexes.empty());
-	// construct the ColumnIndex
-	ColumnIndex index = ColumnIndex(indexes[0]);
-	for (idx_t i = 1; i < indexes.size(); i++) {
-		ColumnIndex new_index(indexes[i]);
-		new_index.AddChildIndex(std::move(index));
-		index = std::move(new_index);
-	}
-	AddBinding(*colref, std::move(index));
-	return true;
-}
-
-void MergeChildColumns(vector<ColumnIndex> &current_child_columns, ColumnIndex &new_child_column) {
-	if (current_child_columns.empty()) {
-		// there's already a reference to the full column - we can't extract only a subfield
-		// skip struct projection pushdown
-		return;
-	}
-	// if we are already extract sub-fields, add it (if it is not there yet)
-	for (auto &binding : current_child_columns) {
-		if (binding.GetPrimaryIndex() != new_child_column.GetPrimaryIndex()) {
-			continue;
-		}
-		// found a match: sub-field is already projected
-		// check if we have child columns
-		auto &nested_child_columns = binding.GetChildIndexesMutable();
-		if (!new_child_column.HasChildren()) {
-			// new child is a reference to a full column - clear any existing bindings (if any)
-			nested_child_columns.clear();
-		} else {
-			// new child has a sub-reference - merge recursively
-			D_ASSERT(new_child_column.ChildIndexCount() == 1);
-			MergeChildColumns(nested_child_columns, new_child_column.GetChildIndex(0));
-		}
-		return;
-	}
-	// this child column is not projected yet - add it in
-	current_child_columns.push_back(std::move(new_child_column));
-}
-
-void RemoveUnusedColumns::AddBinding(BoundColumnRefExpression &col, ColumnIndex child_column) {
-	auto entry = column_references.find(col.binding);
-	if (entry == column_references.end()) {
-		// column not referenced yet - add a binding to it entirely
-		ReferencedColumn column;
-		column.bindings.push_back(col);
-		column.child_columns.push_back(std::move(child_column));
-		column_references.insert(make_pair(col.binding, std::move(column)));
-	} else {
-		// column reference already exists - check add the binding
-		auto &column = entry->second;
-		column.bindings.push_back(col);
-
-		MergeChildColumns(column.child_columns, child_column);
-	}
-}
-
-void RemoveUnusedColumns::AddBinding(BoundColumnRefExpression &col) {
-	auto entry = column_references.find(col.binding);
-	if (entry == column_references.end()) {
-		// column not referenced yet - add a binding to it entirely
-		column_references[col.binding].bindings.push_back(col);
-	} else {
-		// column reference already exists - add the binding and clear any sub-references
-		auto &column = entry->second;
-		column.bindings.push_back(col);
-		column.child_columns.clear();
-	}
-}
-
-void RemoveUnusedColumns::VisitExpression(unique_ptr<Expression> *expression) {
-	auto &expr = **expression;
-	if (HandleStructExtract(expr)) {
-		// already handled
-		return;
-	}
-	// recurse
-	LogicalOperatorVisitor::VisitExpression(expression);
-}
-
-unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundColumnRefExpression &expr,
-                                                         unique_ptr<Expression> *expr_ptr) {
-	// add a reference to the entire column
-	AddBinding(expr);
-	return nullptr;
-}
-
-unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundReferenceExpression &expr,
-                                                         unique_ptr<Expression> *expr_ptr) {
-	// BoundReferenceExpression should not be used here yet, they only belong in the physical plan
-	throw InternalException("BoundReferenceExpression should not be used here yet!");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp b/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp
deleted file mode 100644
index 367731fec..000000000
--- a/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "duckdb/optimizer/rule/arithmetic_simplification.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on an OperatorExpression that has a ConstantExpression as child
-	auto op = make_uniq<FunctionExpressionMatcher>();
-	op->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-	op->matchers.push_back(make_uniq<ExpressionMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	// we only match on simple arithmetic expressions (+, -, *, /)
-	op->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*", "//"});
-	// and only with numeric results
-	op->type = make_uniq<IntegerTypeMatcher>();
-	op->matchers[0]->type = make_uniq<IntegerTypeMatcher>();
-	op->matchers[1]->type = make_uniq<IntegerTypeMatcher>();
-	root = std::move(op);
-}
-
-unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                           bool &changes_made, bool is_root) {
-	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
-	auto &constant = bindings[1].get().Cast<BoundConstantExpression>();
-	idx_t constant_child = root.children[0].get() == &constant ? 0 : 1;
-	D_ASSERT(root.children.size() == 2);
-	(void)root;
-	// any arithmetic operator involving NULL is always NULL
-	if (constant.value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(root.return_type));
-	}
-	auto &func_name = root.function.name;
-	if (func_name == "+") {
-		if (constant.value == 0) {
-			// addition with 0
-			// we can remove the entire operator and replace it with the non-constant child
-			return std::move(root.children[1 - constant_child]);
-		}
-	} else if (func_name == "-") {
-		if (constant_child == 1 && constant.value == 0) {
-			// subtraction by 0
-			// we can remove the entire operator and replace it with the non-constant child
-			return std::move(root.children[1 - constant_child]);
-		}
-	} else if (func_name == "*") {
-		if (constant.value == 1) {
-			// multiply with 1, replace with non-constant child
-			return std::move(root.children[1 - constant_child]);
-		} else if (constant.value == 0) {
-			// multiply by zero: replace with constant or null
-			return ExpressionRewriter::ConstantOrNull(std::move(root.children[1 - constant_child]),
-			                                          Value::Numeric(root.return_type, 0));
-		}
-	} else if (func_name == "//") {
-		if (constant_child == 1) {
-			if (constant.value == 1) {
-				// divide by 1, replace with non-constant child
-				return std::move(root.children[1 - constant_child]);
-			} else if (constant.value == 0) {
-				// divide by 0, replace with NULL
-				return make_uniq<BoundConstantExpression>(Value(root.return_type));
-			}
-		}
-	} else {
-		throw InternalException("Unrecognized function name in ArithmeticSimplificationRule");
-	}
-	return nullptr;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/case_simplification.cpp b/src/duckdb/src/optimizer/rule/case_simplification.cpp
deleted file mode 100644
index 2dbbecef5..000000000
--- a/src/duckdb/src/optimizer/rule/case_simplification.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/optimizer/rule/case_simplification.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-
-namespace duckdb {
-
-CaseSimplificationRule::CaseSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a CaseExpression that has a ConstantExpression as a check
-	auto op = make_uniq<CaseExpressionMatcher>();
-	root = std::move(op);
-}
-
-unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                     bool &changes_made, bool is_root) {
-	auto &root = bindings[0].get().Cast<BoundCaseExpression>();
-	for (idx_t i = 0; i < root.case_checks.size(); i++) {
-		auto &case_check = root.case_checks[i];
-		if (case_check.when_expr->IsFoldable()) {
-			// the WHEN check is a foldable expression
-			// use an ExpressionExecutor to execute the expression
-			auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), *case_check.when_expr);
-
-			// fold based on the constant condition
-			auto condition = constant_value.DefaultCastAs(LogicalType::BOOLEAN);
-			if (condition.IsNull() || !BooleanValue::Get(condition)) {
-				// the condition is always false: remove this case check
-				root.case_checks.erase_at(i);
-				i--;
-			} else {
-				// the condition is always true
-				// move the THEN clause to the ELSE of the case
-				root.else_expr = std::move(case_check.then_expr);
-				// remove this case check and any case checks after this one
-				root.case_checks.erase(root.case_checks.begin() + NumericCast<int64_t>(i), root.case_checks.end());
-				break;
-			}
-		}
-	}
-	if (root.case_checks.empty()) {
-		// no case checks left: return the ELSE expression
-		return std::move(root.else_expr);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/comparison_simplification.cpp b/src/duckdb/src/optimizer/rule/comparison_simplification.cpp
deleted file mode 100644
index 1e377528d..000000000
--- a/src/duckdb/src/optimizer/rule/comparison_simplification.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/optimizer/rule/comparison_simplification.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-
-namespace duckdb {
-
-ComparisonSimplificationRule::ComparisonSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a ComparisonExpression that has a ConstantExpression as a check
-	auto op = make_uniq<ComparisonExpressionMatcher>();
-	op->matchers.push_back(make_uniq<FoldableConstantMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	root = std::move(op);
-}
-
-unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                           bool &changes_made, bool is_root) {
-
-	auto &expr = bindings[0].get().Cast<BoundComparisonExpression>();
-	auto &constant_expr = bindings[1].get();
-	bool column_ref_left = expr.left.get() != &constant_expr;
-	auto column_ref_expr = !column_ref_left ? expr.right.get() : expr.left.get();
-	// the constant_expr is a scalar expression that we have to fold
-	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr.IsFoldable());
-	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
-		return nullptr;
-	}
-	if (constant_value.IsNull() && !(expr.GetExpressionType() == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-	                                 expr.GetExpressionType() == ExpressionType::COMPARE_DISTINCT_FROM)) {
-		// comparison with constant NULL, return NULL
-		return make_uniq<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
-	}
-	if (column_ref_expr->GetExpressionClass() == ExpressionClass::BOUND_CAST) {
-		//! Here we check if we can apply the expression on the constant side
-		//! We can do this if the cast itself is invertible and casting the constant is
-		//! invertible in practice.
-		auto &cast_expression = column_ref_expr->Cast<BoundCastExpression>();
-		auto target_type = cast_expression.source_type();
-		if (!BoundCastExpression::CastIsInvertible(target_type, cast_expression.return_type)) {
-			return nullptr;
-		}
-
-		// Can we cast the constant at all?
-		string error_message;
-		Value cast_constant;
-		auto new_constant =
-		    constant_value.TryCastAs(rewriter.context, target_type, cast_constant, &error_message, true);
-		if (!new_constant) {
-			return nullptr;
-		}
-
-		// Is the constant cast invertible?
-		if (!cast_constant.IsNull() &&
-		    !BoundCastExpression::CastIsInvertible(cast_expression.return_type, target_type)) {
-			// Is it actually invertible?
-			Value uncast_constant;
-			if (!cast_constant.TryCastAs(rewriter.context, constant_value.type(), uncast_constant, &error_message,
-			                             true) ||
-			    uncast_constant != constant_value) {
-				return nullptr;
-			}
-		}
-
-		//! We can cast, now we change our column_ref_expression from an operator cast to a column reference
-		auto child_expression = std::move(cast_expression.child);
-		auto new_constant_expr = make_uniq<BoundConstantExpression>(cast_constant);
-		if (column_ref_left) {
-			expr.left = std::move(child_expression);
-			expr.right = std::move(new_constant_expr);
-		} else {
-			expr.left = std::move(new_constant_expr);
-			expr.right = std::move(child_expression);
-		}
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp b/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp
deleted file mode 100644
index f1d5838d0..000000000
--- a/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-
-#include "duckdb/optimizer/rule/conjunction_simplification.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-ConjunctionSimplificationRule::ConjunctionSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a ComparisonExpression that has a ConstantExpression as a check
-	auto op = make_uniq<ConjunctionExpressionMatcher>();
-	op->matchers.push_back(make_uniq<FoldableConstantMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	root = std::move(op);
-}
-
-unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConjunctionExpression &conj,
-                                                                       const Expression &expr) {
-	for (idx_t i = 0; i < conj.children.size(); i++) {
-		if (conj.children[i].get() == &expr) {
-			// erase the expression
-			conj.children.erase_at(i);
-			break;
-		}
-	}
-	if (conj.children.size() == 1) {
-		// one expression remaining: simply return that expression and erase the conjunction
-		return std::move(conj.children[0]);
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
-                                                            vector<reference<Expression>> &bindings, bool &changes_made,
-                                                            bool is_root) {
-	auto &conjunction = bindings[0].get().Cast<BoundConjunctionExpression>();
-	auto &constant_expr = bindings[1].get();
-	// the constant_expr is a scalar expression that we have to fold
-	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr.IsFoldable());
-	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
-		return nullptr;
-	}
-	constant_value = constant_value.DefaultCastAs(LogicalType::BOOLEAN);
-	if (constant_value.IsNull()) {
-		// we can't simplify conjunctions with a constant NULL
-		return nullptr;
-	}
-	if (conjunction.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		if (!BooleanValue::Get(constant_value)) {
-			// FALSE in AND, result of expression is false
-			return make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
-		} else {
-			// TRUE in AND, remove the expression from the set
-			return RemoveExpression(conjunction, constant_expr);
-		}
-	} else {
-		D_ASSERT(conjunction.GetExpressionType() == ExpressionType::CONJUNCTION_OR);
-		if (!BooleanValue::Get(constant_value)) {
-			// FALSE in OR, remove the expression from the set
-			return RemoveExpression(conjunction, constant_expr);
-		} else {
-			// TRUE in OR, result of expression is true
-			return make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/constant_folding.cpp b/src/duckdb/src/optimizer/rule/constant_folding.cpp
deleted file mode 100644
index 6dba91d2a..000000000
--- a/src/duckdb/src/optimizer/rule/constant_folding.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-
-#include "duckdb/optimizer/rule/constant_folding.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-//! The ConstantFoldingExpressionMatcher matches on any scalar expression (i.e. Expression::IsFoldable is true)
-class ConstantFoldingExpressionMatcher : public FoldableConstantMatcher {
-public:
-	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override {
-		// we also do not match on ConstantExpressions, because we cannot fold those any further
-		if (expr.GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-			return false;
-		}
-		return FoldableConstantMatcher::Match(expr, bindings);
-	}
-};
-
-ConstantFoldingRule::ConstantFoldingRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto op = make_uniq<ConstantFoldingExpressionMatcher>();
-	root = std::move(op);
-}
-
-unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                  bool &changes_made, bool is_root) {
-	auto &root = bindings[0].get();
-	// the root is a scalar expression that we have to fold
-	D_ASSERT(root.IsFoldable() && root.GetExpressionType() != ExpressionType::VALUE_CONSTANT);
-
-	// use an ExpressionExecutor to execute the expression
-	Value result_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), root, result_value)) {
-		return nullptr;
-	}
-	D_ASSERT(result_value.type().InternalType() == root.return_type.InternalType());
-	// now get the value from the result vector and insert it back into the plan as a constant expression
-	return make_uniq<BoundConstantExpression>(result_value);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/date_part_simplification.cpp b/src/duckdb/src/optimizer/rule/date_part_simplification.cpp
deleted file mode 100644
index 6737e576c..000000000
--- a/src/duckdb/src/optimizer/rule/date_part_simplification.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "duckdb/optimizer/rule/date_part_simplification.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/common/enums/date_part_specifier.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/function/function_binder.hpp"
-
-namespace duckdb {
-
-DatePartSimplificationRule::DatePartSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto func = make_uniq<FunctionExpressionMatcher>();
-	func->function = make_uniq<SpecificFunctionMatcher>("date_part");
-	func->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-	func->matchers.push_back(make_uniq<ExpressionMatcher>());
-	func->policy = SetMatcher::Policy::ORDERED;
-	root = std::move(func);
-}
-
-unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                         bool &changes_made, bool is_root) {
-	auto &date_part = bindings[0].get().Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[1].get().Cast<BoundConstantExpression>();
-	auto &constant = constant_expr.value;
-
-	if (constant.IsNull()) {
-		// NULL specifier: return constant NULL
-		return make_uniq<BoundConstantExpression>(Value(date_part.return_type));
-	}
-	// otherwise check the specifier
-	auto specifier = GetDatePartSpecifier(StringValue::Get(constant));
-	string new_function_name;
-	switch (specifier) {
-	case DatePartSpecifier::YEAR:
-		new_function_name = "year";
-		break;
-	case DatePartSpecifier::MONTH:
-		new_function_name = "month";
-		break;
-	case DatePartSpecifier::DAY:
-		new_function_name = "day";
-		break;
-	case DatePartSpecifier::DECADE:
-		new_function_name = "decade";
-		break;
-	case DatePartSpecifier::CENTURY:
-		new_function_name = "century";
-		break;
-	case DatePartSpecifier::MILLENNIUM:
-		new_function_name = "millennium";
-		break;
-	case DatePartSpecifier::QUARTER:
-		new_function_name = "quarter";
-		break;
-	case DatePartSpecifier::WEEK:
-		new_function_name = "week";
-		break;
-	case DatePartSpecifier::YEARWEEK:
-		new_function_name = "yearweek";
-		break;
-	case DatePartSpecifier::DOW:
-		new_function_name = "dayofweek";
-		break;
-	case DatePartSpecifier::ISODOW:
-		new_function_name = "isodow";
-		break;
-	case DatePartSpecifier::DOY:
-		new_function_name = "dayofyear";
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		new_function_name = "microsecond";
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		new_function_name = "millisecond";
-		break;
-	case DatePartSpecifier::SECOND:
-		new_function_name = "second";
-		break;
-	case DatePartSpecifier::MINUTE:
-		new_function_name = "minute";
-		break;
-	case DatePartSpecifier::HOUR:
-		new_function_name = "hour";
-		break;
-	default:
-		return nullptr;
-	}
-	// found a replacement function: bind it
-	vector<unique_ptr<Expression>> children;
-	children.push_back(std::move(date_part.children[1]));
-
-	ErrorData error;
-	FunctionBinder binder(rewriter.context);
-	auto function = binder.BindScalarFunction(DEFAULT_SCHEMA, new_function_name, std::move(children), error, false);
-	if (!function) {
-		error.Throw();
-	}
-	return function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/distinct_aggregate_optimizer.cpp b/src/duckdb/src/optimizer/rule/distinct_aggregate_optimizer.cpp
deleted file mode 100644
index 7eeae1d34..000000000
--- a/src/duckdb/src/optimizer/rule/distinct_aggregate_optimizer.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/optimizer/rule/distinct_aggregate_optimizer.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-
-namespace duckdb {
-
-DistinctAggregateOptimizer::DistinctAggregateOptimizer(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	root = make_uniq<ExpressionMatcher>();
-	root->expr_class = ExpressionClass::BOUND_AGGREGATE;
-}
-
-unique_ptr<Expression> DistinctAggregateOptimizer::Apply(ClientContext &context, BoundAggregateExpression &aggr,
-                                                         bool &changes_made) {
-	if (!aggr.IsDistinct()) {
-		// no DISTINCT defined
-		return nullptr;
-	}
-	if (aggr.function.distinct_dependent == AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT) {
-		// not a distinct-sensitive aggregate but we have an DISTINCT modifier - remove it
-		aggr.aggr_type = AggregateType::NON_DISTINCT;
-		changes_made = true;
-		return nullptr;
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> DistinctAggregateOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                         bool &changes_made, bool is_root) {
-	auto &aggr = bindings[0].get().Cast<BoundAggregateExpression>();
-	return Apply(rewriter.context, aggr, changes_made);
-}
-
-DistinctWindowedOptimizer::DistinctWindowedOptimizer(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	root = make_uniq<ExpressionMatcher>();
-	root->expr_class = ExpressionClass::BOUND_WINDOW;
-}
-
-unique_ptr<Expression> DistinctWindowedOptimizer::Apply(ClientContext &context, BoundWindowExpression &wexpr,
-                                                        bool &changes_made) {
-	if (!wexpr.distinct) {
-		// no DISTINCT defined
-		return nullptr;
-	}
-	if (!wexpr.aggregate) {
-		// not an aggregate
-		return nullptr;
-	}
-	if (wexpr.aggregate->distinct_dependent == AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT) {
-		// not a distinct-sensitive aggregate but we have an DISTINCT modifier - remove it
-		wexpr.distinct = false;
-		changes_made = true;
-		return nullptr;
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> DistinctWindowedOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                        bool &changes_made, bool is_root) {
-	auto &wexpr = bindings[0].get().Cast<BoundWindowExpression>();
-	return Apply(rewriter.context, wexpr, changes_made);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/distributivity.cpp b/src/duckdb/src/optimizer/rule/distributivity.cpp
deleted file mode 100644
index b1b18617c..000000000
--- a/src/duckdb/src/optimizer/rule/distributivity.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/optimizer/rule/distributivity.hpp"
-
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-
-namespace duckdb {
-
-DistributivityRule::DistributivityRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// we match on an OR expression within a LogicalFilter node
-	root = make_uniq<ExpressionMatcher>();
-	root->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::CONJUNCTION_OR);
-}
-
-void DistributivityRule::AddExpressionSet(Expression &expr, expression_set_t &set) {
-	if (expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		auto &and_expr = expr.Cast<BoundConjunctionExpression>();
-		for (auto &child : and_expr.children) {
-			set.insert(*child);
-		}
-	} else {
-		set.insert(expr);
-	}
-}
-
-unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExpression &conj, idx_t idx,
-                                                             Expression &expr) {
-	auto &child = conj.children[idx];
-	unique_ptr<Expression> result;
-	if (child->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		// AND, remove expression from the list
-		auto &and_expr = child->Cast<BoundConjunctionExpression>();
-		for (idx_t i = 0; i < and_expr.children.size(); i++) {
-			if (and_expr.children[i]->Equals(expr)) {
-				result = std::move(and_expr.children[i]);
-				and_expr.children.erase_at(i);
-				break;
-			}
-		}
-		if (and_expr.children.size() == 1) {
-			conj.children[idx] = std::move(and_expr.children[0]);
-		}
-	} else {
-		// not an AND node! remove the entire expression
-		// this happens in the case of e.g. (X AND B) OR X
-		D_ASSERT(child->Equals(expr));
-		result = std::move(child);
-		conj.children[idx] = nullptr;
-	}
-	D_ASSERT(result);
-	return result;
-}
-
-unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                 bool &changes_made, bool is_root) {
-	auto &initial_or = bindings[0].get().Cast<BoundConjunctionExpression>();
-
-	// we want to find expressions that occur in each of the children of the OR
-	// i.e. (X AND A) OR (X AND B) => X occurs in all branches
-	// first, for the initial child, we create an expression set of which expressions occur
-	// this is our initial candidate set (in the example: [X, A])
-	expression_set_t candidate_set;
-	AddExpressionSet(*initial_or.children[0], candidate_set);
-	// now for each of the remaining children, we create a set again and intersect them
-	// in our example: the second set would be [X, B]
-	// the intersection would leave [X]
-	for (idx_t i = 1; i < initial_or.children.size(); i++) {
-		expression_set_t next_set;
-		AddExpressionSet(*initial_or.children[i], next_set);
-		expression_set_t intersect_result;
-		for (auto &expr : candidate_set) {
-			if (next_set.find(expr) != next_set.end()) {
-				intersect_result.insert(expr);
-			}
-		}
-		candidate_set = intersect_result;
-	}
-	if (candidate_set.empty()) {
-		// nothing found: abort
-		return nullptr;
-	}
-	// now for each of the remaining expressions in the candidate set we know that it is contained in all branches of
-	// the OR
-	auto new_root = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-	for (auto &expr : candidate_set) {
-		D_ASSERT(initial_or.children.size() > 0);
-
-		// extract the expression from the first child of the OR
-		auto result = ExtractExpression(initial_or, 0, expr.get());
-		// now for the subsequent expressions, simply remove the expression
-		for (idx_t i = 1; i < initial_or.children.size(); i++) {
-			ExtractExpression(initial_or, i, *result);
-		}
-		// now we add the expression to the new root
-		new_root->children.push_back(std::move(result));
-	}
-
-	// check if we completely erased one of the children of the OR
-	// this happens if we have an OR in the form of "X OR (X AND A)"
-	// the left child will be completely empty, as it only contains common expressions
-	// in this case, any other children are not useful:
-	// X OR (X AND A) is the same as "X"
-	// since (1) only tuples that do not qualify "X" will not pass this predicate
-	//   and (2) all tuples that qualify "X" will pass this predicate
-	for (idx_t i = 0; i < initial_or.children.size(); i++) {
-		if (!initial_or.children[i]) {
-			if (new_root->children.size() <= 1) {
-				return std::move(new_root->children[0]);
-			} else {
-				return std::move(new_root);
-			}
-		}
-	}
-	// finally we need to add the remaining expressions in the OR to the new root
-	if (initial_or.children.size() == 1) {
-		// one child: skip the OR entirely and only add the single child
-		new_root->children.push_back(std::move(initial_or.children[0]));
-	} else if (initial_or.children.size() > 1) {
-		// multiple children still remain: push them into a new OR and add that to the new root
-		auto new_or = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-		for (auto &child : initial_or.children) {
-			new_or->children.push_back(std::move(child));
-		}
-		new_root->children.push_back(std::move(new_or));
-	}
-	// finally return the new root
-	if (new_root->children.size() == 1) {
-		return std::move(new_root->children[0]);
-	}
-	return std::move(new_root);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/empty_needle_removal.cpp b/src/duckdb/src/optimizer/rule/empty_needle_removal.cpp
deleted file mode 100644
index 1b6275092..000000000
--- a/src/duckdb/src/optimizer/rule/empty_needle_removal.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-
-#include "duckdb/optimizer/rule/empty_needle_removal.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-
-namespace duckdb {
-
-EmptyNeedleRemovalRule::EmptyNeedleRemovalRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a FunctionExpression that has a foldable ConstantExpression
-	auto func = make_uniq<FunctionExpressionMatcher>();
-	func->matchers.push_back(make_uniq<ExpressionMatcher>());
-	func->matchers.push_back(make_uniq<ExpressionMatcher>());
-	func->policy = SetMatcher::Policy::SOME;
-
-	unordered_set<string> functions = {"prefix", "contains", "suffix"};
-	func->function = make_uniq<ManyFunctionMatcher>(functions);
-	root = std::move(func);
-}
-
-unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                     bool &changes_made, bool is_root) {
-	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
-	D_ASSERT(root.children.size() == 2);
-	auto &prefix_expr = bindings[2].get();
-
-	// the constant_expr is a scalar expression that we have to fold
-	if (!prefix_expr.IsFoldable()) {
-		return nullptr;
-	}
-	D_ASSERT(root.return_type.id() == LogicalTypeId::BOOLEAN);
-
-	auto prefix_value = ExpressionExecutor::EvaluateScalar(GetContext(), prefix_expr);
-
-	if (prefix_value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
-	}
-
-	D_ASSERT(prefix_value.type() == prefix_expr.return_type);
-	if (prefix_value.type().InternalType() != PhysicalType::VARCHAR) {
-		return nullptr;
-	}
-	auto &needle_string = StringValue::Get(prefix_value);
-
-	// PREFIX('xyz', '') is TRUE
-	// PREFIX(NULL, '') is NULL
-	// so rewrite PREFIX(x, '') to TRUE_OR_NULL(x)
-	if (needle_string.empty()) {
-		return ExpressionRewriter::ConstantOrNull(std::move(root.children[0]), Value::BOOLEAN(true));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/enum_comparison.cpp b/src/duckdb/src/optimizer/rule/enum_comparison.cpp
deleted file mode 100644
index 5dfcfaf30..000000000
--- a/src/duckdb/src/optimizer/rule/enum_comparison.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-
-#include "duckdb/optimizer/rule/enum_comparison.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/optimizer/matcher/type_matcher_id.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/common/types.hpp"
-
-namespace duckdb {
-
-EnumComparisonRule::EnumComparisonRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a ComparisonExpression that is an Equality and has a VARCHAR and ENUM as its children
-	auto op = make_uniq<ComparisonExpressionMatcher>();
-	// Enum requires expression to be root
-	op->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::COMPARE_EQUAL);
-	for (idx_t i = 0; i < 2; i++) {
-		auto child = make_uniq<CastExpressionMatcher>();
-		child->type = make_uniq<TypeMatcherId>(LogicalTypeId::VARCHAR);
-		child->matcher = make_uniq<ExpressionMatcher>();
-		child->matcher->type = make_uniq<TypeMatcherId>(LogicalTypeId::ENUM);
-		op->matchers.push_back(std::move(child));
-	}
-	root = std::move(op);
-}
-
-bool AreMatchesPossible(LogicalType &left, LogicalType &right) {
-	LogicalType *small_enum, *big_enum;
-	if (EnumType::GetSize(left) < EnumType::GetSize(right)) {
-		small_enum = &left;
-		big_enum = &right;
-	} else {
-		small_enum = &right;
-		big_enum = &left;
-	}
-	auto &string_vec = EnumType::GetValuesInsertOrder(*small_enum);
-	auto string_vec_ptr = FlatVector::GetData<string_t>(string_vec);
-	auto size = EnumType::GetSize(*small_enum);
-	for (idx_t i = 0; i < size; i++) {
-		auto key = string_vec_ptr[i].GetString();
-		if (EnumType::GetPos(*big_enum, key) != -1) {
-			return true;
-		}
-	}
-	return false;
-}
-unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                 bool &changes_made, bool is_root) {
-
-	auto &root = bindings[0].get().Cast<BoundComparisonExpression>();
-	auto &left_child = bindings[1].get().Cast<BoundCastExpression>();
-	auto &right_child = bindings[3].get().Cast<BoundCastExpression>();
-
-	if (!AreMatchesPossible(left_child.child->return_type, right_child.child->return_type)) {
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(root.left));
-		children.push_back(std::move(root.right));
-		return ExpressionRewriter::ConstantOrNull(std::move(children), Value::BOOLEAN(false));
-	}
-
-	if (!is_root || op.type != LogicalOperatorType::LOGICAL_FILTER) {
-		return nullptr;
-	}
-
-	auto cast_left_to_right =
-	    BoundCastExpression::AddDefaultCastToType(std::move(left_child.child), right_child.child->return_type, true);
-	return make_uniq<BoundComparisonExpression>(root.GetExpressionType(), std::move(cast_left_to_right),
-	                                            std::move(right_child.child));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/equal_or_null_simplification.cpp b/src/duckdb/src/optimizer/rule/equal_or_null_simplification.cpp
deleted file mode 100644
index c3053b382..000000000
--- a/src/duckdb/src/optimizer/rule/equal_or_null_simplification.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "duckdb/optimizer/rule/equal_or_null_simplification.hpp"
-
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-
-namespace duckdb {
-
-EqualOrNullSimplification::EqualOrNullSimplification(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on OR conjunction
-	auto op = make_uniq<ConjunctionExpressionMatcher>();
-	op->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::CONJUNCTION_OR);
-	op->policy = SetMatcher::Policy::SOME;
-
-	// equi comparison on one side
-	auto equal_child = make_uniq<ComparisonExpressionMatcher>();
-	equal_child->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::COMPARE_EQUAL);
-	equal_child->policy = SetMatcher::Policy::SOME;
-	op->matchers.push_back(std::move(equal_child));
-
-	// AND conjunction on the other
-	auto and_child = make_uniq<ConjunctionExpressionMatcher>();
-	and_child->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::CONJUNCTION_AND);
-	and_child->policy = SetMatcher::Policy::SOME;
-
-	// IS NULL tests inside AND
-	auto isnull_child = make_uniq<ExpressionMatcher>();
-	isnull_child->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::OPERATOR_IS_NULL);
-	// I could try to use std::make_uniq for a copy, but it's available from C++14 only
-	auto isnull_child2 = make_uniq<ExpressionMatcher>();
-	isnull_child2->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::OPERATOR_IS_NULL);
-	and_child->matchers.push_back(std::move(isnull_child));
-	and_child->matchers.push_back(std::move(isnull_child2));
-
-	op->matchers.push_back(std::move(and_child));
-	root = std::move(op);
-}
-
-// a=b OR (a IS NULL AND b IS NULL) to a IS NOT DISTINCT FROM b
-static unique_ptr<Expression> TryRewriteEqualOrIsNull(Expression &equal_expr, Expression &and_expr) {
-	if (equal_expr.GetExpressionType() != ExpressionType::COMPARE_EQUAL ||
-	    and_expr.GetExpressionType() != ExpressionType::CONJUNCTION_AND) {
-		return nullptr;
-	}
-
-	auto &equal_cast = equal_expr.Cast<BoundComparisonExpression>();
-	auto &and_cast = and_expr.Cast<BoundConjunctionExpression>();
-
-	if (and_cast.children.size() != 2) {
-		return nullptr;
-	}
-
-	// Make sure on the AND conjunction the relevant conditions appear
-	auto &a_exp = *equal_cast.left;
-	auto &b_exp = *equal_cast.right;
-	bool a_is_null_found = false;
-	bool b_is_null_found = false;
-
-	for (const auto &item : and_cast.children) {
-		auto &next_exp = *item;
-
-		if (next_exp.GetExpressionType() == ExpressionType::OPERATOR_IS_NULL) {
-			auto &next_exp_cast = next_exp.Cast<BoundOperatorExpression>();
-			auto &child = *next_exp_cast.children[0];
-
-			// Test for equality on both 'a' and 'b' expressions
-			if (Expression::Equals(child, a_exp)) {
-				a_is_null_found = true;
-			} else if (Expression::Equals(child, b_exp)) {
-				b_is_null_found = true;
-			} else {
-				return nullptr;
-			}
-		} else {
-			return nullptr;
-		}
-	}
-	if (a_is_null_found && b_is_null_found) {
-		return make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-		                                            std::move(equal_cast.left), std::move(equal_cast.right));
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                        bool &changes_made, bool is_root) {
-	const Expression &or_exp = bindings[0].get();
-
-	if (or_exp.GetExpressionType() != ExpressionType::CONJUNCTION_OR) {
-		return nullptr;
-	}
-
-	const auto &or_exp_cast = or_exp.Cast<BoundConjunctionExpression>();
-
-	if (or_exp_cast.children.size() != 2) {
-		return nullptr;
-	}
-
-	auto &left_exp = *or_exp_cast.children[0];
-	auto &right_exp = *or_exp_cast.children[1];
-	// Test for: a=b OR (a IS NULL AND b IS NULL)
-	auto first_try = TryRewriteEqualOrIsNull(left_exp, right_exp);
-	if (first_try) {
-		return first_try;
-	}
-	// Test for: (a IS NULL AND b IS NULL) OR a=b
-	return TryRewriteEqualOrIsNull(right_exp, left_exp);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/in_clause_simplification_rule.cpp b/src/duckdb/src/optimizer/rule/in_clause_simplification_rule.cpp
deleted file mode 100644
index d54d98cc9..000000000
--- a/src/duckdb/src/optimizer/rule/in_clause_simplification_rule.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/optimizer/rule/in_clause_simplification.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-
-namespace duckdb {
-
-InClauseSimplificationRule::InClauseSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on InClauseExpression that has a ConstantExpression as a check
-	auto op = make_uniq<InClauseExpressionMatcher>();
-	op->policy = SetMatcher::Policy::SOME;
-	root = std::move(op);
-}
-
-unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                         bool &changes_made, bool is_root) {
-	auto &expr = bindings[0].get().Cast<BoundOperatorExpression>();
-	if (expr.children[0]->GetExpressionClass() != ExpressionClass::BOUND_CAST) {
-		return nullptr;
-	}
-	auto &cast_expression = expr.children[0]->Cast<BoundCastExpression>();
-	if (cast_expression.child->GetExpressionClass() != ExpressionClass::BOUND_COLUMN_REF) {
-		return nullptr;
-	}
-	//! The goal here is to remove the cast from the probe expression
-	//! and apply a cast to the constant expressions. We can only do this
-	//! if the semantics do not change, which only happens when BOTH casts
-	//! are invertible.
-	auto target_type = cast_expression.source_type();
-	if (!BoundCastExpression::CastIsInvertible(target_type, cast_expression.return_type)) {
-		return nullptr;
-	}
-	vector<unique_ptr<BoundConstantExpression>> cast_list;
-	//! First check if we can cast all children
-	for (size_t i = 1; i < expr.children.size(); i++) {
-		if (expr.children[i]->GetExpressionClass() != ExpressionClass::BOUND_CONSTANT) {
-			return nullptr;
-		}
-		D_ASSERT(expr.children[i]->IsFoldable());
-		auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), *expr.children[i]);
-		if (!BoundCastExpression::CastIsInvertible(constant_value.type(), target_type)) {
-			return nullptr;
-		}
-		auto new_constant = constant_value.DefaultTryCastAs(target_type);
-		if (!new_constant) {
-			return nullptr;
-		} else {
-			auto new_constant_expr = make_uniq<BoundConstantExpression>(constant_value);
-			cast_list.push_back(std::move(new_constant_expr));
-		}
-	}
-	//! We can cast, so we move the new constant
-	for (size_t i = 1; i < expr.children.size(); i++) {
-		expr.children[i] = std::move(cast_list[i - 1]);
-
-		//		expr->children[i] = std::move(new_constant_expr);
-	}
-	//! We can cast the full list, so we move the column
-	expr.children[0] = std::move(cast_expression.child);
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/join_dependent_filter.cpp b/src/duckdb/src/optimizer/rule/join_dependent_filter.cpp
deleted file mode 100644
index 339bc46bb..000000000
--- a/src/duckdb/src/optimizer/rule/join_dependent_filter.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/optimizer/rule/join_dependent_filter.hpp"
-
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-
-namespace duckdb {
-
-JoinDependentFilterRule::JoinDependentFilterRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// Match on a ConjunctionExpression that has at least two ConjunctionExpressions as children
-	auto op = make_uniq<ConjunctionExpressionMatcher>();
-	op->matchers.push_back(make_uniq<ConjunctionExpressionMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	root = std::move(op);
-}
-
-static inline void GetTableIndices(const Expression &expression, unordered_set<idx_t> &table_idxs) {
-	ExpressionIterator::EnumerateChildren(expression, [&](const Expression &child) {
-		if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-			auto &colref = child.Cast<BoundColumnRefExpression>();
-			table_idxs.insert(colref.binding.table_index);
-		} else {
-			GetTableIndices(child, table_idxs);
-		}
-	});
-}
-
-static inline bool ExpressionReferencesMultipleTables(const Expression &binding) {
-	unordered_set<idx_t> table_idxs;
-	GetTableIndices(binding, table_idxs);
-	return table_idxs.size() > 1;
-}
-
-static inline void ExtractConjunctedExpressions(Expression &expression,
-                                                unordered_map<idx_t, unique_ptr<Expression>> &expressions) {
-	if (expression.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		auto &conjunction = expression.Cast<BoundConjunctionExpression>();
-		for (auto &child : conjunction.children) {
-			ExtractConjunctedExpressions(*child, expressions);
-		}
-	} else if (!expression.IsVolatile()) {
-		unordered_set<idx_t> table_idxs;
-		GetTableIndices(expression, table_idxs);
-		if (table_idxs.size() != 1) {
-			return; // Needs to reference exactly one table
-		}
-
-		// If there was already an expression, AND it together
-		auto &table_expressions = expressions[*table_idxs.begin()];
-		table_expressions = table_expressions
-		                        ? make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-		                                                                std::move(table_expressions), expression.Copy())
-		                        : expression.Copy();
-	}
-}
-
-unique_ptr<Expression> JoinDependentFilterRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                      bool &changes_made, bool is_root) {
-	// Only applies to top-level FILTER expressions
-	if ((op.type != LogicalOperatorType::LOGICAL_FILTER && op.type != LogicalOperatorType::LOGICAL_ANY_JOIN) ||
-	    !is_root) {
-		return nullptr;
-	}
-
-	// The expression must be an OR
-	auto &conjunction = bindings[0].get().Cast<BoundConjunctionExpression>();
-	if (conjunction.GetExpressionType() != ExpressionType::CONJUNCTION_OR) {
-		return nullptr;
-	}
-
-	// Must have at least one join-dependent AND expression
-	auto &children = conjunction.children;
-	bool eligible = false;
-	for (const auto &child : children) {
-		if (child->GetExpressionClass() == ExpressionClass::BOUND_CONJUNCTION &&
-		    child->GetExpressionType() == ExpressionType::CONJUNCTION_AND &&
-		    ExpressionReferencesMultipleTables(*child)) {
-			eligible = true;
-			break;
-		}
-	}
-	if (!eligible) {
-		return nullptr;
-	}
-
-	// Extract all comparison expressions between column references and constants that are AND'ed together
-	auto conjuncted_expressions = make_uniq_array<unordered_map<idx_t, unique_ptr<Expression>>>(children.size());
-	for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
-		conjuncted_expressions[child_idx] = unordered_map<idx_t, unique_ptr<Expression>>();
-		ExtractConjunctedExpressions(*children[child_idx], conjuncted_expressions[child_idx]);
-	}
-
-	auto derived_filter = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-	for (auto &entry : conjuncted_expressions[0]) {
-		auto derived_entry_filter = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-		derived_entry_filter->children.push_back(entry.second->Copy());
-
-		bool found = true;
-		for (idx_t conj_idx = 1; conj_idx < children.size(); conj_idx++) {
-			auto &other_entry = conjuncted_expressions[conj_idx];
-			auto other_it = other_entry.find(entry.first);
-			if (other_it == other_entry.end()) {
-				found = false;
-				break; // Expression does not appear in every conjuncted expression, cannot derive any restriction
-			}
-			derived_entry_filter->children.push_back(other_it->second->Copy());
-		}
-
-		if (!found) {
-			continue; // Expression must show up in every entry
-		}
-
-		derived_filter->children.push_back(std::move(derived_entry_filter));
-	}
-
-	if (derived_filter->children.empty()) {
-		return nullptr; // Could not derive filters that can be pushed down
-	}
-
-	// Add the derived expression to the original expression with an AND
-	auto result = make_uniq_base<Expression, BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-	auto &result_conjunction = result->Cast<BoundConjunctionExpression>();
-	result_conjunction.children.push_back(conjunction.Copy());
-
-	if (derived_filter->children.size() == 1) {
-		result_conjunction.children.push_back(std::move(derived_filter->children[0]));
-	} else {
-		result_conjunction.children.push_back(std::move(derived_filter));
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/like_optimizations.cpp b/src/duckdb/src/optimizer/rule/like_optimizations.cpp
deleted file mode 100644
index a8398c99f..000000000
--- a/src/duckdb/src/optimizer/rule/like_optimizations.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-#include "duckdb/optimizer/rule/like_optimizations.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-
-namespace duckdb {
-
-LikeOptimizationRule::LikeOptimizationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a FunctionExpression that has a foldable ConstantExpression
-	auto func = make_uniq<FunctionExpressionMatcher>();
-	func->matchers.push_back(make_uniq<ExpressionMatcher>());
-	func->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-	func->policy = SetMatcher::Policy::ORDERED;
-	// we match on LIKE ("~~") and NOT LIKE ("!~~")
-	func->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"!~~", "~~"});
-	root = std::move(func);
-}
-
-static bool PatternIsConstant(const string &pattern) {
-	for (idx_t i = 0; i < pattern.size(); i++) {
-		if (pattern[i] == '%' || pattern[i] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-static bool PatternIsPrefix(const string &pattern) {
-	idx_t i;
-	for (i = pattern.size(); i > 0; i--) {
-		if (pattern[i - 1] != '%') {
-			break;
-		}
-	}
-	if (i == pattern.size()) {
-		// no trailing %
-		// cannot be a prefix
-		return false;
-	}
-	// continue to look in the string
-	// if there is a % or _ in the string (besides at the very end) this is not a prefix match
-	for (; i > 0; i--) {
-		if (pattern[i - 1] == '%' || pattern[i - 1] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-static bool PatternIsSuffix(const string &pattern) {
-	idx_t i;
-	for (i = 0; i < pattern.size(); i++) {
-		if (pattern[i] != '%') {
-			break;
-		}
-	}
-	if (i == 0) {
-		// no leading %
-		// cannot be a suffix
-		return false;
-	}
-	// continue to look in the string
-	// if there is a % or _ in the string (besides at the beginning) this is not a suffix match
-	for (; i < pattern.size(); i++) {
-		if (pattern[i] == '%' || pattern[i] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-static bool PatternIsContains(const string &pattern) {
-	idx_t start;
-	idx_t end;
-	for (start = 0; start < pattern.size(); start++) {
-		if (pattern[start] != '%') {
-			break;
-		}
-	}
-	for (end = pattern.size(); end > 0; end--) {
-		if (pattern[end - 1] != '%') {
-			break;
-		}
-	}
-	if (start == 0 || end == pattern.size()) {
-		// contains requires both a leading AND a trailing %
-		return false;
-	}
-	// check if there are any other special characters in the string
-	// if there is a % or _ in the string (besides at the beginning/end) this is not a contains match
-	for (idx_t i = start; i < end; i++) {
-		if (pattern[i] == '%' || pattern[i] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                   bool &changes_made, bool is_root) {
-	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[2].get().Cast<BoundConstantExpression>();
-	D_ASSERT(root.children.size() == 2);
-
-	if (constant_expr.value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(root.return_type));
-	}
-
-	// the constant_expr is a scalar expression that we have to fold
-	if (!constant_expr.IsFoldable()) {
-		return nullptr;
-	}
-
-	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), constant_expr);
-	D_ASSERT(constant_value.type() == constant_expr.return_type);
-	auto &patt_str = StringValue::Get(constant_value);
-
-	bool is_not_like = root.function.name == "!~~";
-	if (PatternIsConstant(patt_str)) {
-		// Pattern is constant
-		return make_uniq<BoundComparisonExpression>(is_not_like ? ExpressionType::COMPARE_NOTEQUAL
-		                                                        : ExpressionType::COMPARE_EQUAL,
-		                                            std::move(root.children[0]), std::move(root.children[1]));
-	} else if (PatternIsPrefix(patt_str)) {
-		// Prefix LIKE pattern : [^%_]*[%]+, ignoring underscore
-		return ApplyRule(root, PrefixFun::GetFunction(), patt_str, is_not_like);
-	} else if (PatternIsSuffix(patt_str)) {
-		// Suffix LIKE pattern: [%]+[^%_]*, ignoring underscore
-		return ApplyRule(root, SuffixFun::GetFunction(), patt_str, is_not_like);
-	} else if (PatternIsContains(patt_str)) {
-		// Contains LIKE pattern: [%]+[^%_]*[%]+, ignoring underscore
-		return ApplyRule(root, GetStringContains(), patt_str, is_not_like);
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> LikeOptimizationRule::ApplyRule(BoundFunctionExpression &expr, ScalarFunction function,
-                                                       string pattern, bool is_not_like) {
-	// replace LIKE by an optimized function
-	unique_ptr<Expression> result;
-	auto new_function =
-	    make_uniq<BoundFunctionExpression>(expr.return_type, std::move(function), std::move(expr.children), nullptr);
-
-	// removing "%" from the pattern
-	pattern.erase(std::remove(pattern.begin(), pattern.end(), '%'), pattern.end());
-
-	new_function->children[1] = make_uniq<BoundConstantExpression>(Value(std::move(pattern)));
-
-	result = std::move(new_function);
-	if (is_not_like) {
-		auto negation = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
-		negation->children.push_back(std::move(result));
-		result = std::move(negation);
-	}
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/move_constants.cpp b/src/duckdb/src/optimizer/rule/move_constants.cpp
deleted file mode 100644
index b2be74a02..000000000
--- a/src/duckdb/src/optimizer/rule/move_constants.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-#include "duckdb/optimizer/rule/move_constants.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-
-namespace duckdb {
-
-MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto op = make_uniq<ComparisonExpressionMatcher>();
-	op->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-	op->policy = SetMatcher::Policy::UNORDERED;
-
-	auto arithmetic = make_uniq<FunctionExpressionMatcher>();
-	// we handle multiplication, addition and subtraction because those are "easy"
-	// integer division makes the division case difficult
-	// e.g. [x / 2 = 3] means [x = 6 OR x = 7] because of truncation -> no clean rewrite rules
-	arithmetic->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*"});
-	// we match only on integral numeric types
-	arithmetic->type = make_uniq<IntegerTypeMatcher>();
-	auto child_constant_matcher = make_uniq<ConstantExpressionMatcher>();
-	auto child_expression_matcher = make_uniq<ExpressionMatcher>();
-	child_constant_matcher->type = make_uniq<IntegerTypeMatcher>();
-	child_expression_matcher->type = make_uniq<IntegerTypeMatcher>();
-	arithmetic->matchers.push_back(std::move(child_constant_matcher));
-	arithmetic->matchers.push_back(std::move(child_expression_matcher));
-	arithmetic->policy = SetMatcher::Policy::SOME;
-	op->matchers.push_back(std::move(arithmetic));
-	root = std::move(op);
-}
-
-unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                bool &changes_made, bool is_root) {
-	auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
-	auto &outer_constant = bindings[1].get().Cast<BoundConstantExpression>();
-	auto &arithmetic = bindings[2].get().Cast<BoundFunctionExpression>();
-	auto &inner_constant = bindings[3].get().Cast<BoundConstantExpression>();
-	D_ASSERT(arithmetic.return_type.IsIntegral());
-	D_ASSERT(arithmetic.children[0]->return_type.IsIntegral());
-	if (inner_constant.value.IsNull() || outer_constant.value.IsNull()) {
-		if (comparison.GetExpressionType() == ExpressionType::COMPARE_DISTINCT_FROM ||
-		    comparison.GetExpressionType() == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			return nullptr;
-		}
-		return make_uniq<BoundConstantExpression>(Value(comparison.return_type));
-	}
-	auto &constant_type = outer_constant.return_type;
-	hugeint_t outer_value = IntegralValue::Get(outer_constant.value);
-	hugeint_t inner_value = IntegralValue::Get(inner_constant.value);
-
-	idx_t arithmetic_child_index = arithmetic.children[0].get() == &inner_constant ? 1 : 0;
-	auto &op_type = arithmetic.function.name;
-	if (op_type == "+") {
-		// [x + 1 COMP 10] OR [1 + x COMP 10]
-		// order does not matter in addition:
-		// simply change right side to 10-1 (outer_constant - inner_constant)
-		if (!Hugeint::TrySubtractInPlace(outer_value, inner_value)) {
-			return nullptr;
-		}
-		auto result_value = Value::HUGEINT(outer_value);
-		if (!result_value.DefaultTryCastAs(constant_type)) {
-			if (comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
-				return nullptr;
-			}
-			// if the cast is not possible then the comparison is not possible
-			// for example, if we have x + 5 = 3, where x is an unsigned number, we will get x = -2
-			// since this is not possible we can remove the entire branch here
-			return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
-			                                          Value::BOOLEAN(false));
-		}
-		outer_constant.value = std::move(result_value);
-	} else if (op_type == "-") {
-		// [x - 1 COMP 10] O R [1 - x COMP 10]
-		// order matters in subtraction:
-		if (arithmetic_child_index == 0) {
-			// [x - 1 COMP 10]
-			// change right side to 10+1 (outer_constant + inner_constant)
-			if (!Hugeint::TryAddInPlace(outer_value, inner_value)) {
-				return nullptr;
-			}
-			auto result_value = Value::HUGEINT(outer_value);
-			if (!result_value.DefaultTryCastAs(constant_type)) {
-				// if the cast is not possible then an equality comparison is not possible
-				if (comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
-					return nullptr;
-				}
-				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
-				                                          Value::BOOLEAN(false));
-			}
-			outer_constant.value = std::move(result_value);
-		} else {
-			// [1 - x COMP 10]
-			// change right side to 1-10=-9
-			if (!Hugeint::TrySubtractInPlace(inner_value, outer_value)) {
-				return nullptr;
-			}
-			auto result_value = Value::HUGEINT(inner_value);
-			if (!result_value.DefaultTryCastAs(constant_type)) {
-				// if the cast is not possible then an equality comparison is not possible
-				if (comparison.GetExpressionType() != ExpressionType::COMPARE_EQUAL) {
-					return nullptr;
-				}
-				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
-				                                          Value::BOOLEAN(false));
-			}
-			outer_constant.value = std::move(result_value);
-			// in this case, we should also flip the comparison
-			// e.g. if we have [4 - x < 2] then we should have [x > 2]
-			comparison.SetExpressionTypeUnsafe(FlipComparisonExpression(comparison.GetExpressionType()));
-		}
-	} else {
-		D_ASSERT(op_type == "*");
-		// [x * 2 COMP 10] OR [2 * x COMP 10]
-		// order does not matter in multiplication:
-		// change right side to 10/2 (outer_constant / inner_constant)
-		// but ONLY if outer_constant is cleanly divisible by the inner_constant
-		if (inner_value == 0) {
-			// x * 0, the result is either 0 or NULL
-			// we let the arithmetic_simplification rule take care of simplifying this first
-			return nullptr;
-		}
-		// check out of range for HUGEINT or not cleanly divisible
-		// HUGEINT is not cleanly divisible when outer_value == minimum and inner value == -1. (modulo overflow)
-		if ((outer_value == NumericLimits<hugeint_t>::Minimum() && inner_value == -1) ||
-		    outer_value % inner_value != 0) {
-			bool is_equality = comparison.GetExpressionType() == ExpressionType::COMPARE_EQUAL;
-			bool is_inequality = comparison.GetExpressionType() == ExpressionType::COMPARE_NOTEQUAL;
-			if (is_equality || is_inequality) {
-				// we know the values are not equal
-				// the result will be either FALSE or NULL (if COMPARE_EQUAL)
-				// or TRUE or NULL (if COMPARE_NOTEQUAL)
-				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
-				                                          Value::BOOLEAN(is_inequality));
-			} else {
-				// not cleanly divisible and we are doing > >= < <=, skip the simplification for now
-				return nullptr;
-			}
-		}
-		if (inner_value < 0) {
-			// multiply by negative value, need to flip expression
-			comparison.SetExpressionTypeUnsafe(FlipComparisonExpression(comparison.GetExpressionType()));
-		}
-		// else divide the RHS by the LHS
-		// we need to do a range check on the cast even though we do a division
-		// because e.g. -128 / -1 = 128, which is out of range
-		auto result_value = Value::HUGEINT(outer_value / inner_value);
-		if (!result_value.DefaultTryCastAs(constant_type)) {
-			return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
-			                                          Value::BOOLEAN(false));
-		}
-		outer_constant.value = std::move(result_value);
-	}
-	// replace left side with x
-	// first extract x from the arithmetic expression
-	auto arithmetic_child = std::move(arithmetic.children[arithmetic_child_index]);
-	// then place in the comparison
-	if (comparison.left.get() == &outer_constant) {
-		comparison.right = std::move(arithmetic_child);
-	} else {
-		comparison.left = std::move(arithmetic_child);
-	}
-	changes_made = true;
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/ordered_aggregate_optimizer.cpp b/src/duckdb/src/optimizer/rule/ordered_aggregate_optimizer.cpp
deleted file mode 100644
index 93c9c8016..000000000
--- a/src/duckdb/src/optimizer/rule/ordered_aggregate_optimizer.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"
-
-namespace duckdb {
-
-OrderedAggregateOptimizer::OrderedAggregateOptimizer(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// we match on an OR expression within a LogicalFilter node
-	root = make_uniq<ExpressionMatcher>();
-	root->expr_class = ExpressionClass::BOUND_AGGREGATE;
-}
-
-unique_ptr<Expression> OrderedAggregateOptimizer::Apply(ClientContext &context, BoundAggregateExpression &aggr,
-                                                        vector<unique_ptr<Expression>> &groups, bool &changes_made) {
-	if (!aggr.order_bys) {
-		// no ORDER BYs defined
-		return nullptr;
-	}
-	if (aggr.function.order_dependent == AggregateOrderDependent::NOT_ORDER_DEPENDENT) {
-		// not an order dependent aggregate but we have an ORDER BY clause - remove it
-		aggr.order_bys.reset();
-		changes_made = true;
-		return nullptr;
-	}
-
-	// Remove unnecessary ORDER BY clauses and return if nothing remains
-	if (aggr.order_bys->Simplify(groups)) {
-		aggr.order_bys.reset();
-		changes_made = true;
-		return nullptr;
-	}
-
-	//	Rewrite first/last/arbitrary/any_value to use arg_xxx[_null] and create_sort_key
-	const auto &aggr_name = aggr.function.name;
-	string arg_xxx_name;
-	if (aggr_name == "last") {
-		arg_xxx_name = "arg_max_null";
-	} else if (aggr_name == "first" || aggr_name == "arbitrary") {
-		arg_xxx_name = "arg_min_null";
-	} else if (aggr_name == "any_value") {
-		arg_xxx_name = "arg_min";
-	} else {
-		return nullptr;
-	}
-
-	FunctionBinder binder(context);
-	vector<unique_ptr<Expression>> sort_children;
-	for (auto &order : aggr.order_bys->orders) {
-		sort_children.emplace_back(std::move(order.expression));
-
-		string modifier;
-		modifier += (order.type == OrderType::ASCENDING) ? "ASC" : "DESC";
-		modifier += " NULLS";
-		modifier += (order.null_order == OrderByNullType::NULLS_FIRST) ? " FIRST" : " LAST";
-		sort_children.emplace_back(make_uniq<BoundConstantExpression>(Value(modifier)));
-	}
-	aggr.order_bys.reset();
-
-	ErrorData error;
-	auto sort_key = binder.BindScalarFunction(DEFAULT_SCHEMA, "create_sort_key", std::move(sort_children), error);
-	if (!sort_key) {
-		error.Throw();
-	}
-
-	auto &children = aggr.children;
-	children.emplace_back(std::move(sort_key));
-
-	//  Look up the arg_xxx_name function in the catalog
-	QueryErrorContext error_context;
-	auto &func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, SYSTEM_CATALOG, DEFAULT_SCHEMA, arg_xxx_name,
-	                                                              error_context);
-	D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-
-	// bind the aggregate
-	vector<LogicalType> types;
-	for (const auto &child : children) {
-		types.emplace_back(child->return_type);
-	}
-	auto best_function = binder.BindFunction(func.name, func.functions, types, error);
-	if (!best_function.IsValid()) {
-		error.Throw();
-	}
-	// found a matching function!
-	auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
-	return binder.BindAggregateFunction(bound_function, std::move(children), std::move(aggr.filter),
-	                                    aggr.IsDistinct() ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
-}
-
-unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                        bool &changes_made, bool is_root) {
-	auto &aggr = bindings[0].get().Cast<BoundAggregateExpression>();
-	return Apply(rewriter.context, aggr, op.Cast<LogicalAggregate>().groups, changes_made);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/regex_optimizations.cpp b/src/duckdb/src/optimizer/rule/regex_optimizations.cpp
deleted file mode 100644
index 24786867b..000000000
--- a/src/duckdb/src/optimizer/rule/regex_optimizations.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-#include "duckdb/optimizer/rule/regex_optimizations.hpp"
-
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/function/scalar/string_common.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/regexp.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include "re2/re2.h"
-#include "re2/regexp.h"
-
-namespace duckdb {
-
-RegexOptimizationRule::RegexOptimizationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto func = make_uniq<FunctionExpressionMatcher>();
-	func->function = make_uniq<SpecificFunctionMatcher>("regexp_matches");
-	func->policy = SetMatcher::Policy::SOME_ORDERED;
-	func->matchers.push_back(make_uniq<ExpressionMatcher>());
-	func->matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-
-	root = std::move(func);
-}
-
-struct LikeString {
-	bool exists = true;
-	bool escaped = false;
-	string like_string = "";
-};
-
-static void AddCharacter(char chr, LikeString &ret, bool contains) {
-	// if we are not converting into a contains, and the string has LIKE special characters
-	// then don't return a possible LIKE match
-	// same if the character is a control character
-	if (iscntrl(static_cast<unsigned char>(chr)) || (!contains && (chr == '%' || chr == '_'))) {
-		ret.exists = false;
-		return;
-	}
-	auto run_as_str {chr};
-	ret.like_string += run_as_str;
-}
-
-static void AddCodepoint(int32_t codepoint, LikeString &ret, bool contains) {
-	int sz = 0;
-	char utf8_str[4];
-	if (!Utf8Proc::CodepointToUtf8(codepoint, sz, utf8_str)) {
-		// invalid codepoint
-		ret.exists = false;
-		return;
-	}
-	for (idx_t i = 0; i < idx_t(sz); i++) {
-		AddCharacter(utf8_str[i], ret, contains);
-	}
-}
-
-static LikeString GetLikeStringEscaped(duckdb_re2::Regexp *regexp, bool contains = false) {
-	D_ASSERT(regexp->op() == duckdb_re2::kRegexpLiteralString || regexp->op() == duckdb_re2::kRegexpLiteral);
-	LikeString ret;
-
-	if (regexp->parse_flags() & duckdb_re2::Regexp::FoldCase ||
-	    !(regexp->parse_flags() & duckdb_re2::Regexp::OneLine)) {
-		// parse flags can turn on and off within a regex match, return no optimization
-		// For now, we just don't optimize if these every turn on.
-		// TODO: logic to attempt the optimization, then if the parse flags change, then abort
-		ret.exists = false;
-		return ret;
-	}
-
-	// case insensitivity may be on now, but it can also turn off.
-	if (regexp->op() == duckdb_re2::kRegexpLiteralString) {
-		auto nrunes = (idx_t)regexp->nrunes();
-		auto runes = regexp->runes();
-		for (idx_t i = 0; i < nrunes; i++) {
-			AddCodepoint(runes[i], ret, contains);
-			if (!ret.exists) {
-				return ret;
-			}
-		}
-	} else {
-		auto rune = regexp->rune();
-		AddCodepoint(rune, ret, contains);
-	}
-	D_ASSERT(ret.like_string.size() >= 1 || !ret.exists);
-	return ret;
-}
-
-static LikeString LikeMatchFromRegex(duckdb_re2::RE2 &pattern) {
-	LikeString ret = LikeString();
-	auto num_subs = pattern.Regexp()->nsub();
-	auto subs = pattern.Regexp()->sub();
-	auto cur_sub_index = 0;
-	while (cur_sub_index < num_subs) {
-		switch (subs[cur_sub_index]->op()) {
-		case duckdb_re2::kRegexpAnyChar:
-			if (cur_sub_index == 0) {
-				ret.like_string += "%";
-			}
-			ret.like_string += "_";
-			if (cur_sub_index + 1 == num_subs) {
-				ret.like_string += "%";
-			}
-			break;
-		case duckdb_re2::kRegexpStar:
-			// .* is a Star operator is a anyChar operator as a child.
-			// any other child operator would represent a pattern LIKE cannot match.
-			if (subs[cur_sub_index]->nsub() == 1 && subs[cur_sub_index]->sub()[0]->op() == duckdb_re2::kRegexpAnyChar) {
-				ret.like_string += "%";
-				break;
-			}
-			ret.exists = false;
-			return ret;
-		case duckdb_re2::kRegexpLiteralString:
-		case duckdb_re2::kRegexpLiteral: {
-			// if this is the only matching op, we should have directly called
-			// GetEscapedLikeString
-			D_ASSERT(!(cur_sub_index == 0 && cur_sub_index + 1 == num_subs));
-			if (cur_sub_index == 0) {
-				ret.like_string += "%";
-			}
-			// if the kRegexpLiteral or kRegexpLiteralString is the only op to match
-			// the string can directly be converted into a contains
-			LikeString escaped_like_string = GetLikeStringEscaped(subs[cur_sub_index], false);
-			if (!escaped_like_string.exists) {
-				return escaped_like_string;
-			}
-			ret.like_string += escaped_like_string.like_string;
-			ret.escaped = escaped_like_string.escaped;
-			if (cur_sub_index + 1 == num_subs) {
-				ret.like_string += "%";
-			}
-			break;
-		}
-		case duckdb_re2::kRegexpEndText:
-		case duckdb_re2::kRegexpEmptyMatch:
-		case duckdb_re2::kRegexpBeginText: {
-			break;
-		}
-		default:
-			// some other regexp op that doesn't have an equivalent to a like string
-			// return false;
-			ret.exists = false;
-			return ret;
-		}
-		cur_sub_index += 1;
-	}
-	return ret;
-}
-
-unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                    bool &changes_made, bool is_root) {
-	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[2].get().Cast<BoundConstantExpression>();
-	D_ASSERT(root.children.size() == 2 || root.children.size() == 3);
-	auto regexp_bind_data = root.bind_info.get()->Cast<RegexpMatchesBindData>();
-
-	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), constant_expr);
-	D_ASSERT(constant_value.type() == constant_expr.return_type);
-
-	duckdb_re2::RE2::Options parsed_options = regexp_bind_data.options;
-
-	if (constant_expr.value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(root.return_type));
-	}
-	auto patt_str = StringValue::Get(constant_value);
-
-	// the constant_expr is a scalar expression that we have to fold
-	if (!constant_expr.IsFoldable()) {
-		return nullptr;
-	};
-
-	duckdb_re2::RE2 pattern(patt_str, parsed_options);
-	if (!pattern.ok()) {
-		return nullptr; // this should fail somewhere else
-	}
-
-	LikeString like_string;
-	// check for a like string. If we can convert it to a like string, the like string
-	// optimizer will further optimize suffix and prefix things.
-	if (pattern.Regexp()->op() == duckdb_re2::kRegexpLiteralString ||
-	    pattern.Regexp()->op() == duckdb_re2::kRegexpLiteral) {
-		// convert to contains.
-		LikeString escaped_like_string = GetLikeStringEscaped(pattern.Regexp(), true);
-		if (!escaped_like_string.exists) {
-			return nullptr;
-		}
-		auto parameter = make_uniq<BoundConstantExpression>(Value(std::move(escaped_like_string.like_string)));
-		auto contains = make_uniq<BoundFunctionExpression>(root.return_type, GetStringContains(),
-		                                                   std::move(root.children), nullptr);
-		contains->children[1] = std::move(parameter);
-
-		return std::move(contains);
-	} else if (pattern.Regexp()->op() == duckdb_re2::kRegexpConcat) {
-		like_string = LikeMatchFromRegex(pattern);
-	} else {
-		like_string.exists = false;
-	}
-
-	if (!like_string.exists) {
-		return nullptr;
-	}
-
-	// if regexp had options, remove them so the new Like Expression can be matched for other optimizers.
-	if (root.children.size() == 3) {
-		root.children.pop_back();
-		D_ASSERT(root.children.size() == 2);
-	}
-
-	auto like_expression =
-	    make_uniq<BoundFunctionExpression>(root.return_type, LikeFun::GetFunction(), std::move(root.children), nullptr);
-	auto parameter = make_uniq<BoundConstantExpression>(Value(std::move(like_string.like_string)));
-	like_expression->children[1] = std::move(parameter);
-	return std::move(like_expression);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp b/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp
deleted file mode 100644
index ee144e695..000000000
--- a/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-
-#include "duckdb/optimizer/rule/timestamp_comparison.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/optimizer/matcher/type_matcher_id.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/operator/add.hpp"
-
-namespace duckdb {
-
-TimeStampComparison::TimeStampComparison(ClientContext &context, ExpressionRewriter &rewriter)
-    : Rule(rewriter), context(context) {
-	// match on a ComparisonExpression that is an Equality and has a VARCHAR and ENUM as its children
-	auto op = make_uniq<ComparisonExpressionMatcher>();
-	op->policy = SetMatcher::Policy::UNORDERED;
-	// Enum requires expression to be root
-	op->expr_type = make_uniq<SpecificExpressionTypeMatcher>(ExpressionType::COMPARE_EQUAL);
-
-	// one side is timestamp cast to date
-	auto left = make_uniq<CastExpressionMatcher>();
-	left->type = make_uniq<TypeMatcherId>(LogicalTypeId::DATE);
-	left->matcher = make_uniq<ExpressionMatcher>();
-	left->matcher->expr_class = ExpressionClass::BOUND_COLUMN_REF;
-	left->matcher->type = make_uniq<TypeMatcherId>(LogicalTypeId::TIMESTAMP);
-	op->matchers.push_back(std::move(left));
-
-	// other side is varchar to date?
-	auto right = make_uniq<CastExpressionMatcher>();
-	right->type = make_uniq<TypeMatcherId>(LogicalTypeId::DATE);
-	right->matcher = make_uniq<FoldableConstantMatcher>();
-	right->matcher->expr_class = ExpressionClass::BOUND_CONSTANT;
-	right->matcher->type = make_uniq<TypeMatcherId>(LogicalTypeId::VARCHAR);
-	op->matchers.push_back(std::move(right));
-
-	root = std::move(op);
-}
-
-static void ExpressionIsConstant(Expression &expr, bool &is_constant) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		is_constant = false;
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExpressionIsConstant(child, is_constant); });
-}
-
-unique_ptr<Expression> TimeStampComparison::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
-                                                  bool &changes_made, bool is_root) {
-	auto cast_constant = bindings[3].get().Copy();
-	auto cast_columnref = bindings[2].get().Copy();
-	auto is_constant = true;
-	ExpressionIsConstant(*cast_constant, is_constant);
-	if (!is_constant) {
-		// means the matchers are flipped, so we need to flip our bindings
-		// for some reason an extra binding is added in this case.
-		cast_constant = bindings[4].get().Copy();
-		cast_columnref = bindings[3].get().Copy();
-	}
-	auto new_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-
-	Value result;
-	if (ExpressionExecutor::TryEvaluateScalar(context, *cast_constant, result)) {
-		D_ASSERT(result.type() == LogicalType::DATE);
-		auto original_val = result.GetValue<duckdb::date_t>();
-		auto no_seconds = dtime_t(0);
-
-		// original date as timestamp with no seconds
-		auto original_val_ts = Value::TIMESTAMP(original_val, no_seconds);
-		auto original_val_for_comparison = make_uniq<BoundConstantExpression>(original_val_ts);
-
-		// add one day and validate the new date
-		// code is inspired by AddOperator::Operation(date_t left, int32_t right). The function wasn't used directly
-		// since it throws errors that I cannot catch here.
-
-		auto date_t_copy = result.GetValue<duckdb::date_t>();
-		date_t date_t_result;
-		// attempt to add 1 day
-		if (!TryAddOperator::Operation<date_t, int32_t, date_t>(date_t_copy, 1, date_t_result)) {
-			// don't rewrite the expression and let the expression executor handle the invalid date
-			return nullptr;
-		}
-
-		auto result_as_val = Value::DATE(date_t_result);
-		auto original_val_plus_on_date_ts = Value::TIMESTAMP(result_as_val.GetValue<timestamp_t>());
-
-		auto val_for_comparison = make_uniq<BoundConstantExpression>(original_val_plus_on_date_ts);
-
-		auto left_copy = cast_columnref->Copy();
-		auto right_copy = cast_columnref->Copy();
-		auto lt_eq_expr = make_uniq_base<Expression, BoundComparisonExpression>(
-		    ExpressionType::COMPARE_LESSTHAN, std::move(right_copy), std::move(val_for_comparison));
-		auto gt_eq_expr = make_uniq_base<Expression, BoundComparisonExpression>(
-		    ExpressionType::COMPARE_GREATERTHANOREQUALTO, std::move(left_copy), std::move(original_val_for_comparison));
-		new_expr->children.push_back(std::move(gt_eq_expr));
-		new_expr->children.push_back(std::move(lt_eq_expr));
-		return std::move(new_expr);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/sampling_pushdown.cpp b/src/duckdb/src/optimizer/sampling_pushdown.cpp
deleted file mode 100644
index ca805e64e..000000000
--- a/src/duckdb/src/optimizer/sampling_pushdown.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "duckdb/optimizer/sampling_pushdown.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/common/types/value.hpp"
-namespace duckdb {
-
-unique_ptr<LogicalOperator> SamplingPushdown::Optimize(unique_ptr<LogicalOperator> op) {
-	if (op->type == LogicalOperatorType::LOGICAL_SAMPLE &&
-	    op->Cast<LogicalSample>().sample_options->method == SampleMethod::SYSTEM_SAMPLE &&
-	    op->Cast<LogicalSample>().sample_options->is_percentage && !op->children.empty() &&
-	    op->children[0]->type == LogicalOperatorType::LOGICAL_GET &&
-	    op->children[0]->Cast<LogicalGet>().function.sampling_pushdown && op->children[0]->children.empty()) {
-		auto &get = op->children[0]->Cast<LogicalGet>();
-		// set sampling option
-		get.extra_info.sample_options = std::move(op->Cast<LogicalSample>().sample_options);
-		op = std::move(op->children[0]);
-	}
-	for (auto &child : op->children) {
-		child = Optimize(std::move(child));
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_aggregate.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_aggregate.cpp
deleted file mode 100644
index d0e24dac6..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_aggregate.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundAggregateExpression &aggr,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	vector<BaseStatistics> stats;
-	stats.reserve(aggr.children.size());
-	for (auto &child : aggr.children) {
-		auto stat = PropagateExpression(child);
-		if (!stat) {
-			stats.push_back(BaseStatistics::CreateUnknown(child->return_type));
-		} else {
-			stats.push_back(stat->Copy());
-		}
-	}
-	if (!aggr.function.statistics) {
-		return nullptr;
-	}
-	AggregateStatisticsInput input(aggr.bind_info.get(), stats, node_stats.get());
-	return aggr.function.statistics(context, aggr, input);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_between.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_between.cpp
deleted file mode 100644
index b7953332a..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_between.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundBetweenExpression &between,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	// propagate in all the children
-	auto input_stats = PropagateExpression(between.input);
-	auto lower_stats = PropagateExpression(between.lower);
-	auto upper_stats = PropagateExpression(between.upper);
-	if (!input_stats) {
-		return nullptr;
-	}
-	auto lower_comparison = between.LowerComparisonType();
-	auto upper_comparison = between.UpperComparisonType();
-	// propagate the comparisons
-	auto lower_prune = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	auto upper_prune = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	if (lower_stats) {
-		lower_prune = PropagateComparison(*input_stats, *lower_stats, lower_comparison);
-	}
-	if (upper_stats) {
-		upper_prune = PropagateComparison(*input_stats, *upper_stats, upper_comparison);
-	}
-	if (lower_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE &&
-	    upper_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// both filters are always true: replace the between expression with a constant true
-		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-	} else if (lower_prune == FilterPropagateResult::FILTER_ALWAYS_FALSE ||
-	           upper_prune == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-		// either one of the filters is always false: replace the between expression with a constant false
-		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
-	} else if (lower_prune == FilterPropagateResult::FILTER_FALSE_OR_NULL ||
-	           upper_prune == FilterPropagateResult::FILTER_FALSE_OR_NULL) {
-		// either one of the filters is false or null: replace with a constant or null (false)
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(between.input));
-		children.push_back(std::move(between.lower));
-		children.push_back(std::move(between.upper));
-		expr_ptr = ExpressionRewriter::ConstantOrNull(std::move(children), Value::BOOLEAN(false));
-	} else if (lower_prune == FilterPropagateResult::FILTER_TRUE_OR_NULL &&
-	           upper_prune == FilterPropagateResult::FILTER_TRUE_OR_NULL) {
-		// both filters are true or null: replace with a true or null
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(between.input));
-		children.push_back(std::move(between.lower));
-		children.push_back(std::move(between.upper));
-		expr_ptr = ExpressionRewriter::ConstantOrNull(std::move(children), Value::BOOLEAN(true));
-	} else if (lower_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// lower filter is always true: replace with upper comparison
-		expr_ptr =
-		    make_uniq<BoundComparisonExpression>(upper_comparison, std::move(between.input), std::move(between.upper));
-	} else if (upper_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// upper filter is always true: replace with lower comparison
-		expr_ptr =
-		    make_uniq<BoundComparisonExpression>(lower_comparison, std::move(between.input), std::move(between.lower));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_case.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_case.cpp
deleted file mode 100644
index d74a05755..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_case.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCaseExpression &bound_case,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	// propagate in all the children
-	auto result_stats = PropagateExpression(bound_case.else_expr);
-	for (auto &case_check : bound_case.case_checks) {
-		PropagateExpression(case_check.when_expr);
-		auto then_stats = PropagateExpression(case_check.then_expr);
-		if (!then_stats) {
-			result_stats.reset();
-		} else if (result_stats) {
-			result_stats->Merge(*then_stats);
-		}
-	}
-	return result_stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp
deleted file mode 100644
index b5fcc8ced..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<BaseStatistics> StatisticsOperationsNumericNumericCast(const BaseStatistics &input,
-                                                                         const LogicalType &target) {
-	if (!NumericStats::HasMinMax(input)) {
-		return nullptr;
-	}
-	Value min = NumericStats::Min(input);
-	Value max = NumericStats::Max(input);
-	if (!min.DefaultTryCastAs(target) || !max.DefaultTryCastAs(target)) {
-		// overflow in cast: bailout
-		return nullptr;
-	}
-	auto result = NumericStats::CreateEmpty(target);
-	result.CopyBase(input);
-	NumericStats::SetMin(result, min);
-	NumericStats::SetMax(result, max);
-	return result.ToUnique();
-}
-
-static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatistics &input, const LogicalType &target) {
-	//	Downcasting timestamps to times is not a truncation operation
-	switch (target.id()) {
-	case LogicalTypeId::TIME: {
-		switch (input.GetType().id()) {
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return nullptr;
-		default:
-			break;
-		}
-		break;
-	}
-	// FIXME: perform actual stats propagation for these casts
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		const bool to_timestamp = target.id() == LogicalTypeId::TIMESTAMP;
-		const bool to_timestamp_tz = target.id() == LogicalTypeId::TIMESTAMP_TZ;
-		//  Casting to timestamp[_tz] (us) from a different unit can not re-use stats
-		switch (input.GetType().id()) {
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-			return nullptr;
-		case LogicalTypeId::TIMESTAMP: {
-			if (to_timestamp_tz) {
-				// Both use INT64 physical type, but should not be treated equal
-				return nullptr;
-			}
-			break;
-		}
-		case LogicalTypeId::TIMESTAMP_TZ: {
-			if (to_timestamp) {
-				// Both use INT64 physical type, but should not be treated equal
-				return nullptr;
-			}
-			break;
-		}
-		default:
-			break;
-		}
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_NS: {
-		// Same as above ^
-		switch (input.GetType().id()) {
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_TZ:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-			return nullptr;
-		default:
-			break;
-		}
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_MS: {
-		// Same as above ^
-		switch (input.GetType().id()) {
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_TZ:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-			return nullptr;
-		default:
-			break;
-		}
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		// Same as above ^
-		switch (input.GetType().id()) {
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_TZ:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_MS:
-			return nullptr;
-		default:
-			break;
-		}
-		break;
-	}
-	default:
-		break;
-	}
-
-	switch (target.InternalType()) {
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return StatisticsOperationsNumericNumericCast(input, target);
-	default:
-		return nullptr;
-	}
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCastExpression &cast,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	auto child_stats = PropagateExpression(cast.child);
-	if (!child_stats) {
-		return nullptr;
-	}
-	unique_ptr<BaseStatistics> result_stats;
-	switch (cast.child->return_type.InternalType()) {
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		result_stats = StatisticsNumericCastSwitch(*child_stats, cast.return_type);
-		break;
-	default:
-		return nullptr;
-	}
-	if (cast.try_cast && result_stats) {
-		result_stats->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-	}
-	return result_stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_columnref.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_columnref.cpp
deleted file mode 100644
index 94ed2b0ab..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_columnref.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundColumnRefExpression &colref,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	auto stats = statistics_map.find(colref.binding);
-	if (stats == statistics_map.end()) {
-		return nullptr;
-	}
-	return stats->second->ToUnique();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_comparison.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_comparison.cpp
deleted file mode 100644
index bc1e116d6..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_comparison.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-
-namespace duckdb {
-
-FilterPropagateResult StatisticsPropagator::PropagateComparison(BaseStatistics &lstats, BaseStatistics &rstats,
-                                                                ExpressionType comparison) {
-	// only handle numerics for now
-	switch (lstats.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::UINT128:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		break;
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	if (!NumericStats::HasMinMax(lstats) || !NumericStats::HasMinMax(rstats)) {
-		// no stats available: nothing to prune
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	// the result of the propagation depend on whether or not either side has null values
-	// if there are null values present, we cannot say whether or not
-	bool has_null = lstats.CanHaveNull() || rstats.CanHaveNull();
-	switch (comparison) {
-	case ExpressionType::COMPARE_EQUAL:
-		// l = r, if l.min > r.max or r.min > l.max equality is not possible
-		if (NumericStats::Min(lstats) > NumericStats::Max(rstats) ||
-		    NumericStats::Min(rstats) > NumericStats::Max(lstats)) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		} else {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-	case ExpressionType::COMPARE_GREATERTHAN:
-		// l > r
-		if (NumericStats::Min(lstats) > NumericStats::Max(rstats)) {
-			// if l.min > r.max, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if r.min is bigger or equal to l.max, the filter is always false
-		if (NumericStats::Min(rstats) >= NumericStats::Max(lstats)) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// l >= r
-		if (NumericStats::Min(lstats) >= NumericStats::Max(rstats)) {
-			// if l.min >= r.max, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if r.min > l.max, the filter is always false
-		if (NumericStats::Min(rstats) > NumericStats::Max(lstats)) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_LESSTHAN:
-		// l < r
-		if (NumericStats::Max(lstats) < NumericStats::Min(rstats)) {
-			// if l.max < r.min, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if l.min >= rstats.max, the filter is always false
-		if (NumericStats::Min(lstats) >= NumericStats::Max(rstats)) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// l <= r
-		if (NumericStats::Max(lstats) <= NumericStats::Min(rstats)) {
-			// if l.max <= r.min, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if l.min > rstats.max, the filter is always false
-		if (NumericStats::Min(lstats) > NumericStats::Max(rstats)) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundComparisonExpression &expr,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	auto left_stats = PropagateExpression(expr.left);
-	auto right_stats = PropagateExpression(expr.right);
-	if (!left_stats || !right_stats) {
-		return nullptr;
-	}
-	// propagate the statistics of the comparison operator
-	auto propagate_result = PropagateComparison(*left_stats, *right_stats, expr.GetExpressionType());
-	switch (propagate_result) {
-	case FilterPropagateResult::FILTER_ALWAYS_TRUE:
-		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-		return PropagateExpression(expr_ptr);
-	case FilterPropagateResult::FILTER_ALWAYS_FALSE:
-		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
-		return PropagateExpression(expr_ptr);
-	case FilterPropagateResult::FILTER_TRUE_OR_NULL: {
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(expr.left));
-		children.push_back(std::move(expr.right));
-		expr_ptr = ExpressionRewriter::ConstantOrNull(std::move(children), Value::BOOLEAN(true));
-		return nullptr;
-	}
-	case FilterPropagateResult::FILTER_FALSE_OR_NULL: {
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(expr.left));
-		children.push_back(std::move(expr.right));
-		expr_ptr = ExpressionRewriter::ConstantOrNull(std::move(children), Value::BOOLEAN(false));
-		return nullptr;
-	}
-	default:
-		// FIXME: we can propagate nulls here, i.e. this expression will have nulls only if left and right has nulls
-		return nullptr;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_conjunction.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_conjunction.cpp
deleted file mode 100644
index 31e415f19..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_conjunction.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConjunctionExpression &expr,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	auto is_and = expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND;
-	for (idx_t expr_idx = 0; expr_idx < expr.children.size(); expr_idx++) {
-		auto &child = expr.children[expr_idx];
-		auto stats = PropagateExpression(child);
-		if (!child->IsFoldable()) {
-			continue;
-		}
-		// we have a constant in a conjunction
-		// we (1) either prune the child
-		// or (2) replace the entire conjunction with a constant
-		auto constant = ExpressionExecutor::EvaluateScalar(context, *child);
-		if (constant.IsNull()) {
-			continue;
-		}
-		auto b = BooleanValue::Get(constant);
-		bool prune_child = false;
-		bool constant_value = true;
-		if (b) {
-			// true
-			if (is_and) {
-				// true in and: prune child
-				prune_child = true;
-			} else {
-				// true in OR: replace with TRUE
-				constant_value = true;
-			}
-		} else {
-			// false
-			if (is_and) {
-				// false in AND: replace with FALSE
-				constant_value = false;
-			} else {
-				// false in OR: prune child
-				prune_child = true;
-			}
-		}
-		if (prune_child) {
-			expr.children.erase_at(expr_idx);
-			expr_idx--;
-			continue;
-		}
-		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(constant_value));
-		return PropagateExpression(expr_ptr);
-	}
-	if (expr.children.empty()) {
-		// if there are no children left, replace the conjunction with TRUE (for AND) or FALSE (for OR)
-		expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(is_and));
-		return PropagateExpression(expr_ptr);
-	} else if (expr.children.size() == 1) {
-		// if there is one child left, replace the conjunction with that one child
-		expr_ptr = std::move(expr.children[0]);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_constant.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_constant.cpp
deleted file mode 100644
index a87328107..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_constant.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/storage/statistics/list_stats.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value &input) {
-	return BaseStatistics::FromConstant(input).ToUnique();
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConstantExpression &constant,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	return StatisticsFromValue(constant.value);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_function.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_function.cpp
deleted file mode 100644
index 2a0263450..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_function.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundFunctionExpression &func,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	vector<BaseStatistics> stats;
-	stats.reserve(func.children.size());
-	for (idx_t i = 0; i < func.children.size(); i++) {
-		auto stat = PropagateExpression(func.children[i]);
-		if (!stat) {
-			stats.push_back(BaseStatistics::CreateUnknown(func.children[i]->return_type));
-		} else {
-			stats.push_back(stat->Copy());
-		}
-	}
-	if (!func.function.statistics) {
-		return nullptr;
-	}
-	FunctionStatisticsInput input(func, func.bind_info.get(), stats, &expr_ptr);
-	return func.function.statistics(context, input);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_operator.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_operator.cpp
deleted file mode 100644
index 234459478..000000000
--- a/src/duckdb/src/optimizer/statistics/expression/propagate_operator.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundOperatorExpression &expr,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	bool all_have_stats = true;
-	vector<unique_ptr<BaseStatistics>> child_stats;
-	child_stats.reserve(expr.children.size());
-	for (auto &child : expr.children) {
-		auto stats = PropagateExpression(child);
-		if (!stats) {
-			all_have_stats = false;
-		}
-		child_stats.push_back(std::move(stats));
-	}
-	if (!all_have_stats) {
-		return nullptr;
-	}
-	switch (expr.GetExpressionType()) {
-	case ExpressionType::OPERATOR_COALESCE:
-		// COALESCE, merge stats of all children
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			D_ASSERT(child_stats[i]);
-			if (!child_stats[i]->CanHaveNoNull()) {
-				// this child is always NULL, we can remove it from the coalesce
-				// UNLESS there is only one node remaining
-				if (expr.children.size() > 1) {
-					expr.children.erase_at(i);
-					child_stats.erase_at(i);
-					i--;
-				}
-			} else if (!child_stats[i]->CanHaveNull()) {
-				// coalesce child cannot have NULL entries
-				// this is the last coalesce node that influences the result
-				// we can erase any children after this node
-				if (i + 1 < expr.children.size()) {
-					expr.children.erase(expr.children.begin() + NumericCast<int64_t>(i + 1), expr.children.end());
-					child_stats.erase(child_stats.begin() + NumericCast<int64_t>(i + 1), child_stats.end());
-				}
-				break;
-			}
-		}
-		D_ASSERT(!expr.children.empty());
-		D_ASSERT(expr.children.size() == child_stats.size());
-		if (expr.children.size() == 1) {
-			// coalesce of one entry: simply return that entry
-			expr_ptr = std::move(expr.children[0]);
-		} else {
-			// coalesce of multiple entries
-			// merge the stats
-			for (idx_t i = 1; i < expr.children.size(); i++) {
-				child_stats[0]->Merge(*child_stats[i]);
-			}
-		}
-		return std::move(child_stats[0]);
-	case ExpressionType::OPERATOR_IS_NULL:
-		if (!child_stats[0]->CanHaveNull()) {
-			// child has no null values: x IS NULL will always be false
-			expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
-			return PropagateExpression(expr_ptr);
-		}
-		if (!child_stats[0]->CanHaveNoNull()) {
-			// child has no valid values: x IS NULL will always be true
-			expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-			return PropagateExpression(expr_ptr);
-		}
-		return nullptr;
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		if (!child_stats[0]->CanHaveNull()) {
-			// child has no null values: x IS NOT NULL will always be true
-			expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));
-			return PropagateExpression(expr_ptr);
-		}
-		if (!child_stats[0]->CanHaveNoNull()) {
-			// child has no valid values: x IS NOT NULL will always be false
-			expr_ptr = make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
-			return PropagateExpression(expr_ptr);
-		}
-		return nullptr;
-	default:
-		return nullptr;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_aggregate.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_aggregate.cpp
deleted file mode 100644
index 811d01c94..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_aggregate.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-void StatisticsPropagator::TryExecuteAggregates(LogicalAggregate &aggr, unique_ptr<LogicalOperator> &node_ptr) {
-	if (!aggr.groups.empty()) {
-		// not possible with groups
-		return;
-	}
-	if (aggr.children[0]->type != LogicalOperatorType::LOGICAL_GET) {
-		// child must be a LOGICAL_GET
-		// FIXME: we could do this with projections as well
-		return;
-	}
-	auto &get = aggr.children[0]->Cast<LogicalGet>();
-	if (!get.function.get_partition_stats) {
-		// GET does not support getting the partition stats
-		return;
-	}
-	if (!get.table_filters.filters.empty()) {
-		// we cannot do this if the GET has filters
-		return;
-	}
-	// check if all aggregates are COUNT(*)
-	for (auto &aggr_ref : aggr.expressions) {
-		if (aggr_ref->GetExpressionClass() != ExpressionClass::BOUND_AGGREGATE) {
-			// not an aggregate
-			return;
-		}
-		auto &aggr_expr = aggr_ref->Cast<BoundAggregateExpression>();
-		if (aggr_expr.function.name != "count_star") {
-			// aggregate is not count star - bail
-			return;
-		}
-		if (aggr_expr.filter) {
-			// aggregate has a filter - bail
-			return;
-		}
-	}
-	// we can do the rewrite! get the stats
-	GetPartitionStatsInput input(get.function, get.bind_data.get());
-	auto partition_stats = get.function.get_partition_stats(context, input);
-	idx_t count = 0;
-	for (auto &stats : partition_stats) {
-		if (stats.count_type == CountType::COUNT_APPROXIMATE) {
-			// we cannot get an exact count
-			return;
-		}
-		count += stats.count;
-	}
-	// we got an exact count - replace the entire aggregate with a scan of the result
-	vector<LogicalType> types;
-	vector<unique_ptr<Expression>> count_results;
-	for (idx_t aggregate_index = 0; aggregate_index < aggr.expressions.size(); ++aggregate_index) {
-		auto count_result = make_uniq<BoundConstantExpression>(Value::BIGINT(NumericCast<int64_t>(count)));
-		count_result->SetAlias(aggr.expressions[aggregate_index]->GetName());
-		count_results.push_back(std::move(count_result));
-
-		types.push_back(LogicalType::BIGINT);
-	}
-
-	vector<vector<unique_ptr<Expression>>> expressions;
-	expressions.push_back(std::move(count_results));
-	auto expression_get =
-	    make_uniq<LogicalExpressionGet>(aggr.aggregate_index, std::move(types), std::move(expressions));
-	expression_get->children.push_back(make_uniq<LogicalDummyScan>(aggr.group_index));
-	node_ptr = std::move(expression_get);
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggregate &aggr,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate statistics in the child node
-	node_stats = PropagateStatistics(aggr.children[0]);
-
-	// handle the groups: simply propagate statistics and assign the stats to the group binding
-	aggr.group_stats.resize(aggr.groups.size());
-	for (idx_t group_idx = 0; group_idx < aggr.groups.size(); group_idx++) {
-		auto stats = PropagateExpression(aggr.groups[group_idx]);
-		aggr.group_stats[group_idx] = stats ? stats->ToUnique() : nullptr;
-		if (!stats) {
-			continue;
-		}
-		if (aggr.grouping_sets.size() > 1) {
-			// aggregates with multiple grouping sets can introduce NULL values to certain groups
-			// FIXME: actually figure out WHICH groups can have null values introduced
-			stats->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-			continue;
-		}
-		ColumnBinding group_binding(aggr.group_index, group_idx);
-		statistics_map[group_binding] = std::move(stats);
-	}
-	// propagate statistics in the aggregates
-	for (idx_t aggregate_idx = 0; aggregate_idx < aggr.expressions.size(); aggregate_idx++) {
-		auto stats = PropagateExpression(aggr.expressions[aggregate_idx]);
-		if (!stats) {
-			continue;
-		}
-		ColumnBinding aggregate_binding(aggr.aggregate_index, aggregate_idx);
-		statistics_map[aggregate_binding] = std::move(stats);
-	}
-
-	// after we propagate statistics - try to directly execute aggregates using statistics
-	TryExecuteAggregates(aggr, node_ptr);
-
-	// the max cardinality of an aggregate is the max cardinality of the input (i.e. when every row is a unique group)
-	return std::move(node_stats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_cross_product.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_cross_product.cpp
deleted file mode 100644
index 5e9b7529f..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_cross_product.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalCrossProduct &cp,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate statistics in the child node
-	auto left_stats = PropagateStatistics(cp.children[0]);
-	auto right_stats = PropagateStatistics(cp.children[1]);
-	if (!left_stats || !right_stats) {
-		return nullptr;
-	}
-	MultiplyCardinalities(left_stats, *right_stats);
-	return left_stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp
deleted file mode 100644
index 1c555be4e..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/generic_common.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-static bool IsCompareDistinct(ExpressionType type) {
-	return type == ExpressionType::COMPARE_DISTINCT_FROM || type == ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-}
-
-bool StatisticsPropagator::ExpressionIsConstant(Expression &expr, const Value &val) {
-	Value expr_value;
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
-		expr_value = expr.Cast<BoundConstantExpression>().value;
-	} else if (expr.IsFoldable()) {
-		if (!ExpressionExecutor::TryEvaluateScalar(context, expr, expr_value)) {
-			return false;
-		}
-	} else {
-		return false;
-	}
-	D_ASSERT(expr_value.type() == val.type());
-	return Value::NotDistinctFrom(expr_value, val);
-}
-
-bool StatisticsPropagator::ExpressionIsConstantOrNull(Expression &expr, const Value &val) {
-	if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
-		return false;
-	}
-	auto &bound_function = expr.Cast<BoundFunctionExpression>();
-	return ConstantOrNull::IsConstantOrNull(bound_function, val);
-}
-
-void StatisticsPropagator::SetStatisticsNotNull(ColumnBinding binding) {
-	auto entry = statistics_map.find(binding);
-	if (entry == statistics_map.end()) {
-		return;
-	}
-	entry->second->Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &stats, ExpressionType comparison_type,
-                                                  const Value &constant) {
-	// regular comparisons removes all null values
-	if (!IsCompareDistinct(comparison_type)) {
-		stats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-	}
-	if (!stats.GetType().IsNumeric()) {
-		// don't handle non-numeric columns here (yet)
-		return;
-	}
-	if (!NumericStats::HasMinMax(stats)) {
-		// no stats available: skip this
-		return;
-	}
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// X < constant OR X <= constant
-		// max becomes the constant
-		NumericStats::SetMax(stats, constant);
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// X > constant OR X >= constant
-		// min becomes the constant
-		NumericStats::SetMin(stats, constant);
-		break;
-	case ExpressionType::COMPARE_EQUAL:
-		// X = constant
-		// both min and max become the constant
-		NumericStats::SetMin(stats, constant);
-		NumericStats::SetMax(stats, constant);
-		break;
-	default:
-		break;
-	}
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &lstats, BaseStatistics &rstats,
-                                                  ExpressionType comparison_type) {
-	// regular comparisons removes all null values
-	if (!IsCompareDistinct(comparison_type)) {
-		lstats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-		rstats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-	}
-	D_ASSERT(lstats.GetType() == rstats.GetType());
-	if (!lstats.GetType().IsNumeric()) {
-		// don't handle non-numeric columns here (yet)
-		return;
-	}
-	if (!NumericStats::HasMinMax(lstats) || !NumericStats::HasMinMax(rstats)) {
-		// no stats available: skip this
-		return;
-	}
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// LEFT < RIGHT OR LEFT <= RIGHT
-		// we know that every value of left is smaller (or equal to) every value in right
-		// i.e. if we have left = [-50, 250] and right = [-100, 100]
-
-		// we know that left.max is AT MOST equal to right.max
-		// because any value in left that is BIGGER than right.max will not pass the filter
-		if (NumericStats::Max(lstats) > NumericStats::Max(rstats)) {
-			NumericStats::SetMax(lstats, NumericStats::Max(rstats));
-		}
-
-		// we also know that right.min is AT MOST equal to left.min
-		// because any value in right that is SMALLER than left.min will not pass the filter
-		if (NumericStats::Min(rstats) < NumericStats::Min(lstats)) {
-			NumericStats::SetMin(rstats, NumericStats::Min(lstats));
-		}
-		// so in our example, the bounds get updated as follows:
-		// left: [-50, 100], right: [-50, 100]
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// LEFT > RIGHT OR LEFT >= RIGHT
-		// we know that every value of left is bigger (or equal to) every value in right
-		// this is essentially the inverse of the less than (or equal to) scenario
-		if (NumericStats::Max(rstats) > NumericStats::Max(lstats)) {
-			NumericStats::SetMax(rstats, NumericStats::Max(lstats));
-		}
-		if (NumericStats::Min(lstats) < NumericStats::Min(rstats)) {
-			NumericStats::SetMin(lstats, NumericStats::Min(rstats));
-		}
-		break;
-	case ExpressionType::COMPARE_EQUAL:
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		// LEFT = RIGHT
-		// only the tightest bounds pass
-		// so if we have e.g. left = [-50, 250] and right = [-100, 100]
-		// the tighest bounds are [-50, 100]
-		// select the highest min
-		if (NumericStats::Min(lstats) > NumericStats::Min(rstats)) {
-			NumericStats::SetMin(rstats, NumericStats::Min(lstats));
-		} else {
-			NumericStats::SetMin(lstats, NumericStats::Min(rstats));
-		}
-		// select the lowest max
-		if (NumericStats::Max(lstats) < NumericStats::Max(rstats)) {
-			NumericStats::SetMax(rstats, NumericStats::Max(lstats));
-		} else {
-			NumericStats::SetMax(lstats, NumericStats::Max(rstats));
-		}
-		break;
-	default:
-		break;
-	}
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &right, ExpressionType comparison_type) {
-	// first check if either side is a bound column ref
-	// any column ref involved in a comparison will not be null after the comparison
-	bool compare_distinct = IsCompareDistinct(comparison_type);
-	if (!compare_distinct && left.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		SetStatisticsNotNull((left.Cast<BoundColumnRefExpression>()).binding);
-	}
-	if (!compare_distinct && right.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		SetStatisticsNotNull((right.Cast<BoundColumnRefExpression>()).binding);
-	}
-	// check if this is a comparison between a constant and a column ref
-	optional_ptr<BoundConstantExpression> constant;
-	optional_ptr<BoundColumnRefExpression> columnref;
-	if (left.GetExpressionType() == ExpressionType::VALUE_CONSTANT &&
-	    right.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		constant = &left.Cast<BoundConstantExpression>();
-		columnref = &right.Cast<BoundColumnRefExpression>();
-		comparison_type = FlipComparisonExpression(comparison_type);
-	} else if (left.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
-	           right.GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-		columnref = &left.Cast<BoundColumnRefExpression>();
-		constant = &right.Cast<BoundConstantExpression>();
-	} else if (left.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
-	           right.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		// comparison between two column refs
-		auto &left_column_ref = left.Cast<BoundColumnRefExpression>();
-		auto &right_column_ref = right.Cast<BoundColumnRefExpression>();
-		auto lentry = statistics_map.find(left_column_ref.binding);
-		auto rentry = statistics_map.find(right_column_ref.binding);
-		if (lentry == statistics_map.end() || rentry == statistics_map.end()) {
-			return;
-		}
-		UpdateFilterStatistics(*lentry->second, *rentry->second, comparison_type);
-	} else {
-		// unsupported filter
-		return;
-	}
-	if (constant && columnref) {
-		// comparison between columnref
-		auto entry = statistics_map.find(columnref->binding);
-		if (entry == statistics_map.end()) {
-			return;
-		}
-		UpdateFilterStatistics(*entry->second, comparison_type, constant->value);
-	}
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(Expression &condition) {
-	// in filters, we check for constant comparisons with bound columns
-	// if we find a comparison in the form of e.g. "i=3", we can update our statistics for that column
-	switch (condition.GetExpressionClass()) {
-	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between = condition.Cast<BoundBetweenExpression>();
-		UpdateFilterStatistics(*between.input, *between.lower, between.LowerComparisonType());
-		UpdateFilterStatistics(*between.input, *between.upper, between.UpperComparisonType());
-		break;
-	}
-	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comparison = condition.Cast<BoundComparisonExpression>();
-		UpdateFilterStatistics(*comparison.left, *comparison.right, comparison.GetExpressionType());
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilter &filter,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(filter.children[0]);
-	if (filter.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		ReplaceWithEmptyResult(node_ptr);
-		return make_uniq<NodeStatistics>(0U, 0U);
-	}
-
-	// then propagate to each of the expressions
-	for (idx_t i = 0; i < filter.expressions.size(); i++) {
-		auto &condition = filter.expressions[i];
-		PropagateExpression(condition);
-
-		if (ExpressionIsConstant(*condition, Value::BOOLEAN(true))) {
-			// filter is always true; it is useless to execute it
-			// erase this condition
-			filter.expressions.erase_at(i);
-			i--;
-			if (filter.expressions.empty()) {
-				// if there is a projection map, we should keep the filter
-				// the physical planner will eventually skip the filter, but will keep
-				// the correct columns.
-				if (filter.projection_map.empty()) {
-					node_ptr = std::move(filter.children[0]);
-				}
-				break;
-			}
-		} else if (ExpressionIsConstant(*condition, Value::BOOLEAN(false)) ||
-		           ExpressionIsConstantOrNull(*condition, Value::BOOLEAN(false))) {
-			// filter is always false or null; this entire filter should be replaced by an empty result block
-			ReplaceWithEmptyResult(node_ptr);
-			return make_uniq<NodeStatistics>(0U, 0U);
-		} else {
-			// cannot prune this filter: propagate statistics from the filter
-			UpdateFilterStatistics(*condition);
-		}
-	}
-	// the max cardinality of a filter is the cardinality of the input (i.e. no tuples get filtered)
-	return std::move(node_stats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp
deleted file mode 100644
index dc2390db5..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/table_filter.hpp"
-
-namespace duckdb {
-
-FilterPropagateResult StatisticsPropagator::PropagateTableFilter(BaseStatistics &stats, TableFilter &filter) {
-	return filter.CheckStatistics(stats);
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter) {
-	// FIXME: update stats...
-	switch (filter.filter_type) {
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
-		for (auto &child_filter : conjunction_and.child_filters) {
-			UpdateFilterStatistics(input, *child_filter);
-		}
-		break;
-	}
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = filter.Cast<ConstantFilter>();
-		UpdateFilterStatistics(input, constant_filter.comparison_type, constant_filter.constant);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet &get,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	if (get.function.cardinality) {
-		node_stats = get.function.cardinality(context, get.bind_data.get());
-	}
-	if (!get.function.statistics) {
-		// no column statistics to get
-		return std::move(node_stats);
-	}
-	auto &column_ids = get.GetColumnIds();
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto stats = get.function.statistics(context, get.bind_data.get(), column_ids[i].GetPrimaryIndex());
-		if (stats) {
-			ColumnBinding binding(get.table_index, i);
-			statistics_map.insert(make_pair(binding, std::move(stats)));
-		}
-	}
-	// push table filters into the statistics
-	vector<idx_t> column_indexes;
-	column_indexes.reserve(get.table_filters.filters.size());
-	for (auto &kv : get.table_filters.filters) {
-		column_indexes.push_back(kv.first);
-	}
-
-	for (auto &table_filter_column : column_indexes) {
-		idx_t column_index;
-		for (column_index = 0; column_index < column_ids.size(); column_index++) {
-			if (column_ids[column_index].GetPrimaryIndex() == table_filter_column) {
-				break;
-			}
-		}
-		D_ASSERT(column_index < column_ids.size());
-		D_ASSERT(column_ids[column_index].GetPrimaryIndex() == table_filter_column);
-
-		// find the stats
-		ColumnBinding stats_binding(get.table_index, column_index);
-		auto entry = statistics_map.find(stats_binding);
-		if (entry == statistics_map.end()) {
-			// no stats for this entry
-			continue;
-		}
-		auto &stats = *entry->second;
-
-		// fetch the table filter
-		D_ASSERT(get.table_filters.filters.count(table_filter_column) > 0);
-		auto &filter = get.table_filters.filters[table_filter_column];
-		auto propagate_result = PropagateTableFilter(stats, *filter);
-		switch (propagate_result) {
-		case FilterPropagateResult::FILTER_ALWAYS_TRUE:
-			// filter is always true; it is useless to execute it
-			// erase this condition
-			get.table_filters.filters.erase(table_filter_column);
-			break;
-		case FilterPropagateResult::FILTER_FALSE_OR_NULL:
-		case FilterPropagateResult::FILTER_ALWAYS_FALSE:
-			// filter is always false; this entire filter should be replaced by an empty result block
-			ReplaceWithEmptyResult(node_ptr);
-			return make_uniq<NodeStatistics>(0U, 0U);
-		default:
-			// general case: filter can be true or false, update this columns' statistics
-			UpdateFilterStatistics(stats, *filter);
-			break;
-		}
-	}
-	return std::move(node_stats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp
deleted file mode 100644
index 1787a7f26..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp
+++ /dev/null
@@ -1,369 +0,0 @@
-#include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/optimizer/filter_pushdown.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_positional_join.hpp"
-
-namespace duckdb {
-
-void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, unique_ptr<LogicalOperator> &node_ptr) {
-	for (idx_t i = 0; i < join.conditions.size(); i++) {
-		auto &condition = join.conditions[i];
-		const auto stats_left = PropagateExpression(condition.left);
-		const auto stats_right = PropagateExpression(condition.right);
-		if (stats_left && stats_right) {
-			if ((condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-			     condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) &&
-			    stats_left->CanHaveNull() && stats_right->CanHaveNull()) {
-				// null values are equal in this join, and both sides can have null values
-				// nothing to do here
-				continue;
-			}
-			auto prune_result = PropagateComparison(*stats_left, *stats_right, condition.comparison);
-			// Add stats to logical_join for perfect hash join
-			join.join_stats.push_back(stats_left->ToUnique());
-			join.join_stats.push_back(stats_right->ToUnique());
-			switch (prune_result) {
-			case FilterPropagateResult::FILTER_FALSE_OR_NULL:
-			case FilterPropagateResult::FILTER_ALWAYS_FALSE:
-				// filter is always false or null, none of the join conditions matter
-				switch (join.join_type) {
-				case JoinType::RIGHT_SEMI:
-				case JoinType::SEMI:
-				case JoinType::INNER:
-					// semi or inner join on false; entire node can be pruned
-					ReplaceWithEmptyResult(node_ptr);
-					return;
-				case JoinType::RIGHT_ANTI:
-				case JoinType::ANTI: {
-					if (join.join_type == JoinType::RIGHT_ANTI) {
-						std::swap(join.children[0], join.children[1]);
-					}
-					// If the filter is always false or Null, just return the left child.
-					node_ptr = std::move(join.children[0]);
-					return;
-				}
-				case JoinType::LEFT:
-					// anti/left outer join: replace right side with empty node
-					ReplaceWithEmptyResult(join.children[1]);
-					return;
-				case JoinType::RIGHT:
-					// right outer join: replace left side with empty node
-					ReplaceWithEmptyResult(join.children[0]);
-					return;
-				default:
-					// other join types: can't do much meaningful with this information
-					// full outer join requires both sides anyway; we can skip the execution of the actual join, but eh
-					// mark/single join requires knowing if the rhs has null values or not
-					break;
-				}
-				break;
-			case FilterPropagateResult::FILTER_ALWAYS_TRUE:
-				// filter is always true
-				// If this is the inequality for an AsOf join,
-				// then we must leave it in because it also flags
-				// the semantics of restricting to a single match
-				// so we can't replace it with an equi-join on the remaining conditions.
-				if (join.type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-					switch (condition.comparison) {
-					case ExpressionType::COMPARE_GREATERTHAN:
-					case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-					case ExpressionType::COMPARE_LESSTHAN:
-					case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-						continue;
-					default:
-						break;
-					}
-				}
-				if (join.conditions.size() > 1) {
-					// there are multiple conditions: erase this condition
-					join.conditions.erase_at(i);
-					// remove the corresponding statistics
-					join.join_stats.clear();
-					i--;
-					continue;
-				} else {
-					// this is the only condition and it is always true: all conditions are true
-					switch (join.join_type) {
-					case JoinType::RIGHT_SEMI:
-					case JoinType::SEMI: {
-						if (join.join_type == JoinType::RIGHT_SEMI) {
-							std::swap(join.children[0], join.children[1]);
-						}
-						// when the right child has no data, return an empty set
-						// cannot just return the left child because if the right child has no cardinality
-						// then the whole result should be empty.
-						// TODO: write better CE logic for limits so that we can just look at
-						//  join.children[1].estimated_cardinality.
-						auto limit = make_uniq<LogicalLimit>(BoundLimitNode::ConstantValue(1), BoundLimitNode());
-						limit->SetEstimatedCardinality(1);
-						limit->AddChild(std::move(join.children[1]));
-						auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit));
-						node_ptr = std::move(cross_product);
-						return;
-					}
-					case JoinType::INNER: {
-						// inner, replace with cross product
-						auto cross_product =
-						    LogicalCrossProduct::Create(std::move(join.children[0]), std::move(join.children[1]));
-						node_ptr = std::move(cross_product);
-						return;
-					}
-					case JoinType::ANTI:
-					case JoinType::RIGHT_ANTI: {
-						ReplaceWithEmptyResult(node_ptr);
-						return;
-					}
-					default:
-						// we don't handle mark/single join here yet
-						break;
-					}
-				}
-				break;
-			default:
-				break;
-			}
-		}
-		// after we have propagated, we can update the statistics on both sides
-		// note that it is fine to do this now, even if the same column is used again later
-		// e.g. if we have i=j AND i=k, and the stats for j and k are disjoint, we know there are no results
-		// so if we have e.g. i: [0, 100], j: [0, 25], k: [75, 100]
-		// we can set i: [0, 25] after the first comparison, and statically determine that the second comparison is fals
-
-		// note that we can't update statistics the same for all join types
-		// mark and single joins don't filter any tuples -> so there is no propagation possible
-		// anti joins have inverse statistics propagation
-		// (i.e. if we have an anti join on i: [0, 100] and j: [0, 25], the resulting stats are i:[25,100])
-		// for now we don't handle anti joins
-		if (condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			// skip update when null values are equal (for now?)
-			continue;
-		}
-		switch (join.join_type) {
-		case JoinType::INNER:
-		case JoinType::SEMI: {
-			UpdateFilterStatistics(*condition.left, *condition.right, condition.comparison);
-			auto updated_stats_left = PropagateExpression(condition.left);
-			auto updated_stats_right = PropagateExpression(condition.right);
-
-			// Try to push lhs stats down rhs and vice versa
-			if (stats_left && stats_right && updated_stats_left && updated_stats_right &&
-			    condition.left->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF &&
-			    condition.right->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-				CreateFilterFromJoinStats(join.children[0], condition.left, *stats_left, *updated_stats_left);
-				CreateFilterFromJoinStats(join.children[1], condition.right, *stats_right, *updated_stats_right);
-			}
-
-			// Update join_stats when is already part of the join
-			if (join.join_stats.size() == 2) {
-				join.join_stats[0] = std::move(updated_stats_left);
-				join.join_stats[1] = std::move(updated_stats_right);
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-}
-
-void StatisticsPropagator::PropagateStatistics(LogicalAnyJoin &join, unique_ptr<LogicalOperator> &node_ptr) {
-	// propagate the expression into the join condition
-	PropagateExpression(join.condition);
-}
-
-void StatisticsPropagator::MultiplyCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats) {
-	if (!stats->has_estimated_cardinality || !new_stats.has_estimated_cardinality || !stats->has_max_cardinality ||
-	    !new_stats.has_max_cardinality) {
-		stats = nullptr;
-		return;
-	}
-	stats->estimated_cardinality = MaxValue<idx_t>(stats->estimated_cardinality, new_stats.estimated_cardinality);
-	auto new_max = Hugeint::Multiply(NumericCast<int64_t>(stats->max_cardinality),
-	                                 NumericCast<int64_t>(new_stats.max_cardinality));
-	if (new_max < NumericLimits<int64_t>::Maximum()) {
-		int64_t result;
-		if (!Hugeint::TryCast<int64_t>(new_max, result)) {
-			throw InternalException("Overflow in cast in statistics propagation");
-		}
-		D_ASSERT(result >= 0);
-		stats->max_cardinality = idx_t(result);
-	} else {
-		stats = nullptr;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin &join,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate through the children of the join
-	node_stats = PropagateStatistics(join.children[0]);
-	for (idx_t child_idx = 1; child_idx < join.children.size(); child_idx++) {
-		auto child_stats = PropagateStatistics(join.children[child_idx]);
-		if (!child_stats) {
-			node_stats = nullptr;
-		} else if (node_stats) {
-			MultiplyCardinalities(node_stats, *child_stats);
-		}
-	}
-
-	auto join_type = join.join_type;
-	// depending on the join type, we might need to alter the statistics
-	// LEFT, FULL, RIGHT OUTER and SINGLE joins can introduce null values
-	// this requires us to alter the statistics after this point in the query plan
-	bool adds_null_on_left = IsRightOuterJoin(join_type);
-	bool adds_null_on_right = IsLeftOuterJoin(join_type) || join_type == JoinType::SINGLE;
-
-	vector<ColumnBinding> left_bindings, right_bindings;
-	if (adds_null_on_left) {
-		left_bindings = join.children[0]->GetColumnBindings();
-	}
-	if (adds_null_on_right) {
-		right_bindings = join.children[1]->GetColumnBindings();
-	}
-
-	// then propagate into the join conditions
-	switch (join.type) {
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		PropagateStatistics(join.Cast<LogicalComparisonJoin>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		PropagateStatistics(join.Cast<LogicalAnyJoin>(), node_ptr);
-		break;
-	default:
-		break;
-	}
-
-	if (adds_null_on_right) {
-		// left or full outer join: set IsNull() to true for all rhs statistics
-		for (auto &binding : right_bindings) {
-			auto stats = statistics_map.find(binding);
-			if (stats != statistics_map.end()) {
-				stats->second->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-			}
-		}
-	}
-	if (adds_null_on_left) {
-		// right or full outer join: set IsNull() to true for all lhs statistics
-		for (auto &binding : left_bindings) {
-			auto stats = statistics_map.find(binding);
-			if (stats != statistics_map.end()) {
-				stats->second->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-			}
-		}
-	}
-	return std::move(node_stats);
-}
-
-static void MaxCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats) {
-	if (!stats->has_estimated_cardinality || !new_stats.has_estimated_cardinality || !stats->has_max_cardinality ||
-	    !new_stats.has_max_cardinality) {
-		stats = nullptr;
-		return;
-	}
-	stats->estimated_cardinality = MaxValue<idx_t>(stats->estimated_cardinality, new_stats.estimated_cardinality);
-	stats->max_cardinality = MaxValue<idx_t>(stats->max_cardinality, new_stats.max_cardinality);
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalPositionalJoin &join,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	D_ASSERT(join.type == LogicalOperatorType::LOGICAL_POSITIONAL_JOIN);
-
-	// first propagate through the children of the join
-	node_stats = PropagateStatistics(join.children[0]);
-	for (idx_t child_idx = 1; child_idx < join.children.size(); child_idx++) {
-		auto child_stats = PropagateStatistics(join.children[child_idx]);
-		if (!child_stats) {
-			node_stats = nullptr;
-		} else if (node_stats) {
-			if (!node_stats->has_estimated_cardinality || !child_stats->has_estimated_cardinality ||
-			    !node_stats->has_max_cardinality || !child_stats->has_max_cardinality) {
-				node_stats = nullptr;
-			} else {
-				MaxCardinalities(node_stats, *child_stats);
-			}
-		}
-	}
-
-	// No conditions.
-
-	// Positional Joins are always FULL OUTER
-
-	// set IsNull() to true for all lhs statistics
-	auto left_bindings = join.children[0]->GetColumnBindings();
-	for (auto &binding : left_bindings) {
-		auto stats = statistics_map.find(binding);
-		if (stats != statistics_map.end()) {
-			stats->second->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-		}
-	}
-
-	// set IsNull() to true for all rhs statistics
-	auto right_bindings = join.children[1]->GetColumnBindings();
-	for (auto &binding : right_bindings) {
-		auto stats = statistics_map.find(binding);
-		if (stats != statistics_map.end()) {
-			stats->second->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-		}
-	}
-
-	return std::move(node_stats);
-}
-
-void StatisticsPropagator::CreateFilterFromJoinStats(unique_ptr<LogicalOperator> &child, unique_ptr<Expression> &expr,
-                                                     const BaseStatistics &stats_before,
-                                                     const BaseStatistics &stats_after) {
-	// Only do this for integral colref's that have stats
-	if (expr->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF || !expr->return_type.IsIntegral() ||
-	    !NumericStats::HasMinMax(stats_before) || !NumericStats::HasMinMax(stats_after)) {
-		return;
-	}
-
-	// Retrieve min/max
-	auto min_before = NumericStats::Min(stats_before);
-	auto max_before = NumericStats::Max(stats_before);
-	auto min_after = NumericStats::Min(stats_after);
-	auto max_after = NumericStats::Max(stats_after);
-
-	vector<unique_ptr<Expression>> filter_exprs;
-	if (min_after > min_before) {
-		filter_exprs.emplace_back(
-		    make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, expr->Copy(),
-		                                         make_uniq<BoundConstantExpression>(std::move(min_after))));
-	}
-	if (max_after < max_before) {
-		filter_exprs.emplace_back(
-		    make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO, expr->Copy(),
-		                                         make_uniq<BoundConstantExpression>(std::move(max_after))));
-	}
-
-	if (filter_exprs.empty()) {
-		return;
-	}
-
-	auto filter = make_uniq<LogicalFilter>();
-	filter->children.emplace_back(std::move(child));
-	child = std::move(filter);
-
-	for (auto &filter_expr : filter_exprs) {
-		child->expressions.emplace_back(std::move(filter_expr));
-	}
-
-	// not allowed to let filter pushdown change mark joins to semi joins.
-	// semi joins are potentially slower AND the conversion can ruin column binding information
-	FilterPushdown filter_pushdown(optimizer, false);
-	child = filter_pushdown.Rewrite(std::move(child));
-	PropagateExpression(expr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_limit.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_limit.cpp
deleted file mode 100644
index 8dd710ac3..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_limit.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalLimit &limit,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// propagate statistics in the child node
-	PropagateStatistics(limit.children[0]);
-	// return the node stats, with as expected cardinality the amount specified in the limit
-	if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-		auto constant_limit = limit.limit_val.GetConstantValue();
-		return make_uniq<NodeStatistics>(constant_limit, constant_limit);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_order.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_order.cpp
deleted file mode 100644
index d9de1607a..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_order.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOrder &order,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(order.children[0]);
-
-	// then propagate to each of the order expressions
-	for (auto &bound_order : order.orders) {
-		bound_order.stats = PropagateExpression(bound_order.expression);
-	}
-	return std::move(node_stats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_projection.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_projection.cpp
deleted file mode 100644
index d867343d8..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_projection.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalProjection &proj,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(proj.children[0]);
-	if (proj.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		ReplaceWithEmptyResult(node_ptr);
-		return std::move(node_stats);
-	}
-	// then propagate to each of the expressions
-	for (idx_t i = 0; i < proj.expressions.size(); i++) {
-		auto stats = PropagateExpression(proj.expressions[i]);
-		if (stats) {
-			ColumnBinding binding(proj.table_index, i);
-			statistics_map.insert(make_pair(binding, std::move(stats)));
-		}
-	}
-	return std::move(node_stats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_set_operation.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_set_operation.cpp
deleted file mode 100644
index 4c8c33ccd..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_set_operation.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-
-namespace duckdb {
-
-void StatisticsPropagator::AddCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats) {
-	if (!stats->has_estimated_cardinality || !new_stats.has_estimated_cardinality || !stats->has_max_cardinality ||
-	    !new_stats.has_max_cardinality) {
-		stats = nullptr;
-		return;
-	}
-	stats->estimated_cardinality += new_stats.estimated_cardinality;
-	auto new_max =
-	    Hugeint::Add(NumericCast<int64_t>(stats->max_cardinality), NumericCast<int64_t>(new_stats.max_cardinality));
-	if (new_max < NumericLimits<int64_t>::Maximum()) {
-		int64_t result;
-		if (!Hugeint::TryCast<int64_t>(new_max, result)) {
-			throw InternalException("Overflow in cast in statistics propagation");
-		}
-		D_ASSERT(result >= 0);
-		stats->max_cardinality = idx_t(result);
-	} else {
-		stats = nullptr;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalSetOperation &setop,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate statistics in the child nodes
-	auto left_stats = PropagateStatistics(setop.children[0]);
-	auto right_stats = PropagateStatistics(setop.children[1]);
-
-	// now fetch the column bindings on both sides
-	auto left_bindings = setop.children[0]->GetColumnBindings();
-	auto right_bindings = setop.children[1]->GetColumnBindings();
-
-	D_ASSERT(left_bindings.size() == right_bindings.size());
-	D_ASSERT(left_bindings.size() == setop.column_count);
-	for (idx_t i = 0; i < setop.column_count; i++) {
-		// for each column binding, we fetch the statistics from both the lhs and the rhs
-		auto left_entry = statistics_map.find(left_bindings[i]);
-		auto right_entry = statistics_map.find(right_bindings[i]);
-		if (left_entry == statistics_map.end() || right_entry == statistics_map.end()) {
-			// no statistics on one of the sides: can't propagate stats
-			continue;
-		}
-		unique_ptr<BaseStatistics> new_stats;
-		switch (setop.type) {
-		case LogicalOperatorType::LOGICAL_UNION:
-			// union: merge the stats of the LHS and RHS together
-			new_stats = left_entry->second->ToUnique();
-			new_stats->Merge(*right_entry->second);
-			break;
-		case LogicalOperatorType::LOGICAL_EXCEPT:
-			// except: use the stats of the LHS
-			new_stats = left_entry->second->ToUnique();
-			break;
-		case LogicalOperatorType::LOGICAL_INTERSECT:
-			// intersect: intersect the two stats
-			// FIXME: for now we just use the stats of the LHS, as this is correct
-			// however, the stats can be further refined to the minimal subset of the LHS and RHS
-			new_stats = left_entry->second->ToUnique();
-			break;
-		default:
-			throw InternalException("Unsupported setop type");
-		}
-		ColumnBinding binding(setop.table_index, i);
-		statistics_map[binding] = std::move(new_stats);
-	}
-	if (!left_stats || !right_stats) {
-		return nullptr;
-	}
-	if (setop.type == LogicalOperatorType::LOGICAL_UNION) {
-		AddCardinalities(left_stats, *right_stats);
-	}
-	return left_stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_window.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_window.cpp
deleted file mode 100644
index 3f3d91731..000000000
--- a/src/duckdb/src/optimizer/statistics/operator/propagate_window.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalWindow &window,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(window.children[0]);
-
-	// then propagate to each of the order expressions
-	for (auto &window_expr : window.expressions) {
-		auto &over_expr = window_expr->Cast<BoundWindowExpression>();
-		for (auto &expr : over_expr.partitions) {
-			over_expr.partitions_stats.push_back(PropagateExpression(expr));
-		}
-		for (auto &bound_order : over_expr.orders) {
-			bound_order.stats = PropagateExpression(bound_order.expression);
-		}
-
-		if (over_expr.start_expr) {
-			over_expr.expr_stats.push_back(PropagateExpression(over_expr.start_expr));
-		} else {
-			over_expr.expr_stats.push_back(nullptr);
-		}
-
-		if (over_expr.end_expr) {
-			over_expr.expr_stats.push_back(PropagateExpression(over_expr.end_expr));
-		} else {
-			over_expr.expr_stats.push_back(nullptr);
-		}
-
-		if (over_expr.offset_expr) {
-			over_expr.expr_stats.push_back(PropagateExpression(over_expr.offset_expr));
-		} else {
-			over_expr.expr_stats.push_back(nullptr);
-		}
-
-		if (over_expr.default_expr) {
-			over_expr.expr_stats.push_back(PropagateExpression(over_expr.default_expr));
-		} else {
-			over_expr.expr_stats.push_back(nullptr);
-		}
-		for (auto &bound_order : over_expr.arg_orders) {
-			bound_order.stats = PropagateExpression(bound_order.expression);
-		}
-	}
-	return std::move(node_stats);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/statistics_propagator.cpp b/src/duckdb/src/optimizer/statistics_propagator.cpp
deleted file mode 100644
index d3b1b1fe3..000000000
--- a/src/duckdb/src/optimizer/statistics_propagator.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/optimizer/statistics_propagator.hpp"
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/optimizer/compressed_materialization.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/planner/operator/logical_positional_join.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-
-namespace duckdb {
-
-StatisticsPropagator::StatisticsPropagator(Optimizer &optimizer_p, LogicalOperator &root_p)
-    : optimizer(optimizer_p), context(optimizer.context), root(&root_p) {
-	root->ResolveOperatorTypes();
-}
-
-void StatisticsPropagator::ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node) {
-	node = make_uniq<LogicalEmptyResult>(std::move(node));
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateChildren(LogicalOperator &node,
-                                                                   unique_ptr<LogicalOperator> &node_ptr) {
-	for (idx_t child_idx = 0; child_idx < node.children.size(); child_idx++) {
-		PropagateStatistics(node.children[child_idx]);
-	}
-	return nullptr;
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOperator &node,
-                                                                     unique_ptr<LogicalOperator> &node_ptr) {
-	unique_ptr<NodeStatistics> result;
-	switch (node.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		result = PropagateStatistics(node.Cast<LogicalAggregate>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		result = PropagateStatistics(node.Cast<LogicalCrossProduct>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_FILTER:
-		result = PropagateStatistics(node.Cast<LogicalFilter>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_GET:
-		result = PropagateStatistics(node.Cast<LogicalGet>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		result = PropagateStatistics(node.Cast<LogicalProjection>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		result = PropagateStatistics(node.Cast<LogicalJoin>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		result = PropagateStatistics(node.Cast<LogicalPositionalJoin>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		result = PropagateStatistics(node.Cast<LogicalSetOperation>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		result = PropagateStatistics(node.Cast<LogicalOrder>(), node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		result = PropagateStatistics(node.Cast<LogicalWindow>(), node_ptr);
-		break;
-	default:
-		result = PropagateChildren(node, node_ptr);
-	}
-
-	if (!optimizer.OptimizerDisabled(OptimizerType::COMPRESSED_MATERIALIZATION)) {
-		// compress data based on statistics for materializing operators
-		CompressedMaterialization compressed_materialization(optimizer, *root, statistics_map);
-		compressed_materialization.Compress(node_ptr);
-	}
-
-	return result;
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(unique_ptr<LogicalOperator> &node_ptr) {
-	return PropagateStatistics(*node_ptr, node_ptr);
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(Expression &expr,
-                                                                     unique_ptr<Expression> &expr_ptr) {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_AGGREGATE:
-		return PropagateExpression(expr.Cast<BoundAggregateExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_BETWEEN:
-		return PropagateExpression(expr.Cast<BoundBetweenExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_CASE:
-		return PropagateExpression(expr.Cast<BoundCaseExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return PropagateExpression(expr.Cast<BoundConjunctionExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_FUNCTION:
-		return PropagateExpression(expr.Cast<BoundFunctionExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_CAST:
-		return PropagateExpression(expr.Cast<BoundCastExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_COMPARISON:
-		return PropagateExpression(expr.Cast<BoundComparisonExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_CONSTANT:
-		return PropagateExpression(expr.Cast<BoundConstantExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_COLUMN_REF:
-		return PropagateExpression(expr.Cast<BoundColumnRefExpression>(), expr_ptr);
-	case ExpressionClass::BOUND_OPERATOR:
-		return PropagateExpression(expr.Cast<BoundOperatorExpression>(), expr_ptr);
-	default:
-		break;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &child) { PropagateExpression(child); });
-	return nullptr;
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(unique_ptr<Expression> &expr) {
-	auto stats = PropagateExpression(*expr, expr);
-	if (ClientConfig::GetConfig(context).query_verification_enabled && stats) {
-		expr->verification_stats = stats->ToUnique();
-	}
-	return stats;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/sum_rewriter.cpp b/src/duckdb/src/optimizer/sum_rewriter.cpp
deleted file mode 100644
index 587144110..000000000
--- a/src/duckdb/src/optimizer/sum_rewriter.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-#include "duckdb/optimizer/sum_rewriter.hpp"
-
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-
-namespace duckdb {
-
-unique_ptr<SetTypesMatcher> GetSmallIntegerTypesMatcher() {
-	vector<LogicalType> types {LogicalTypeId::TINYINT,  LogicalTypeId::SMALLINT, LogicalTypeId::INTEGER,
-	                           LogicalTypeId::BIGINT,   LogicalTypeId::UTINYINT, LogicalTypeId::USMALLINT,
-	                           LogicalTypeId::UINTEGER, LogicalTypeId::UBIGINT};
-	return make_uniq<SetTypesMatcher>(std::move(types));
-}
-
-SumRewriterOptimizer::SumRewriterOptimizer(Optimizer &optimizer) : optimizer(optimizer) {
-	// set up an expression matcher that detects SUM(x + C) or SUM(C + x)
-	auto op = make_uniq<AggregateExpressionMatcher>();
-	op->function = make_uniq<SpecificFunctionMatcher>("sum");
-	op->policy = SetMatcher::Policy::UNORDERED;
-
-	auto arithmetic = make_uniq<FunctionExpressionMatcher>();
-	// handle X + C where
-	arithmetic->function = make_uniq<SpecificFunctionMatcher>("+");
-	// we match only on integral numeric types
-	arithmetic->type = make_uniq<IntegerTypeMatcher>();
-	auto child_constant_matcher = make_uniq<ConstantExpressionMatcher>();
-	auto child_expression_matcher = make_uniq<StableExpressionMatcher>();
-	child_constant_matcher->type = GetSmallIntegerTypesMatcher();
-	child_expression_matcher->type = GetSmallIntegerTypesMatcher();
-	arithmetic->matchers.push_back(std::move(child_constant_matcher));
-	arithmetic->matchers.push_back(std::move(child_expression_matcher));
-	arithmetic->policy = SetMatcher::Policy::SOME;
-	op->matchers.push_back(std::move(arithmetic));
-
-	sum_matcher = std::move(op);
-}
-
-SumRewriterOptimizer::~SumRewriterOptimizer() {
-}
-
-void SumRewriterOptimizer::Optimize(unique_ptr<LogicalOperator> &op) {
-	if (op->type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY) {
-		RewriteSums(op);
-	}
-	VisitOperator(*op);
-}
-
-void SumRewriterOptimizer::StandardVisitOperator(LogicalOperator &op) {
-	for (auto &child : op.children) {
-		Optimize(child);
-	}
-	if (!aggregate_map.empty()) {
-		VisitOperatorExpressions(op);
-	}
-}
-
-void SumRewriterOptimizer::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		SumRewriterOptimizer sum_rewriter(optimizer);
-		sum_rewriter.StandardVisitOperator(op);
-		return;
-	}
-	default:
-		break;
-	}
-
-	StandardVisitOperator(op);
-}
-
-unique_ptr<Expression> SumRewriterOptimizer::VisitReplace(BoundColumnRefExpression &expr,
-                                                          unique_ptr<Expression> *expr_ptr) {
-	// check if this column ref points to an aggregate that was remapped; if it does we remap it
-	auto entry = aggregate_map.find(expr.binding);
-	if (entry != aggregate_map.end()) {
-		expr.binding = entry->second;
-	}
-	return nullptr;
-}
-
-void SumRewriterOptimizer::RewriteSums(unique_ptr<LogicalOperator> &op) {
-	auto &aggr = op->Cast<LogicalAggregate>();
-	if (!aggr.groups.empty()) {
-		return;
-	}
-
-	unordered_set<idx_t> rewrote_map;
-	vector<unique_ptr<Expression>> constants;
-	idx_t aggr_count = aggr.expressions.size();
-	for (idx_t i = 0; i < aggr_count; ++i) {
-		auto &expr = aggr.expressions[i];
-		vector<reference<Expression>> bindings;
-		if (!sum_matcher->Match(*expr, bindings)) {
-			continue;
-		}
-		// found SUM(x + C)
-		auto &sum = bindings[0].get().Cast<BoundAggregateExpression>();
-		auto &addition = bindings[1].get().Cast<BoundFunctionExpression>();
-		idx_t const_idx = addition.children[0]->GetExpressionType() == ExpressionType::VALUE_CONSTANT ? 0 : 1;
-		auto const_expr = std::move(addition.children[const_idx]);
-		auto main_expr = std::move(addition.children[1 - const_idx]);
-
-		// turn this into SUM(x)
-		sum.children[0] = main_expr->Copy();
-
-		// push a new aggregate - COUNT(x)
-		FunctionBinder function_binder(optimizer.context);
-
-		auto count_fun = CountFunctionBase::GetFunction();
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(main_expr));
-		auto count_aggr =
-		    function_binder.BindAggregateFunction(count_fun, std::move(children), nullptr, AggregateType::NON_DISTINCT);
-		aggr.expressions.push_back(std::move(count_aggr));
-		constants.push_back(std::move(const_expr));
-		rewrote_map.insert(i);
-	}
-	if (rewrote_map.empty()) {
-		return;
-	}
-	vector<unique_ptr<Expression>> projection_expressions;
-	// we rewrote aggregates - we need to push a projection in which we re-compute the original result
-	idx_t rewritten_index = 0;
-	auto proj_index = optimizer.binder.GenerateTableIndex();
-	for (idx_t i = 0; i < aggr_count; i++) {
-		ColumnBinding aggregate_binding(aggr.aggregate_index, i);
-		aggregate_map[aggregate_binding] = ColumnBinding(proj_index, i);
-		auto &aggr_type = aggr.expressions[i]->return_type;
-		auto aggr_ref = make_uniq<BoundColumnRefExpression>(aggr_type, aggregate_binding);
-		if (rewrote_map.find(i) == rewrote_map.end()) {
-			// not rewritten - just push a reference
-			projection_expressions.push_back(std::move(aggr_ref));
-			continue;
-		}
-		// rewritten - need to compute the final result
-		idx_t count_idx = aggr_count + rewritten_index;
-		ColumnBinding count_binding(aggr.aggregate_index, count_idx);
-		auto count_ref = make_uniq<BoundColumnRefExpression>(aggr.expressions[count_idx]->return_type, count_binding);
-
-		// cast the count to the sum type
-		auto cast_count = BoundCastExpression::AddCastToType(optimizer.context, std::move(count_ref), aggr_type);
-		auto const_expr =
-		    BoundCastExpression::AddCastToType(optimizer.context, std::move(constants[rewritten_index]), aggr_type);
-
-		// bind the multiplication
-		auto multiply = optimizer.BindScalarFunction("*", std::move(cast_count), std::move(const_expr));
-
-		// add it to the sum
-		auto final_result = optimizer.BindScalarFunction("+", std::move(aggr_ref), std::move(multiply));
-		projection_expressions.push_back(std::move(final_result));
-
-		rewritten_index++;
-	}
-
-	// push the projection to replace the aggregate
-	auto proj = make_uniq<LogicalProjection>(proj_index, std::move(projection_expressions));
-	proj->children.push_back(std::move(op));
-	op = std::move(proj);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/topn_optimizer.cpp b/src/duckdb/src/optimizer/topn_optimizer.cpp
deleted file mode 100644
index 0bfd81190..000000000
--- a/src/duckdb/src/optimizer/topn_optimizer.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#include "duckdb/optimizer/topn_optimizer.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/planner/operator/logical_top_n.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/dynamic_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/execution/operator/join/join_filter_pushdown.hpp"
-#include "duckdb/optimizer/join_filter_pushdown_optimizer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-
-namespace duckdb {
-
-bool TopN::CanOptimize(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_LIMIT) {
-		auto &limit = op.Cast<LogicalLimit>();
-
-		if (limit.limit_val.Type() != LimitNodeType::CONSTANT_VALUE) {
-			// we need LIMIT to be present AND be a constant value for us to be able to use Top-N
-			return false;
-		}
-		if (limit.offset_val.Type() == LimitNodeType::EXPRESSION_VALUE) {
-			// we need offset to be either not set (i.e. limit without offset) OR have offset be
-			return false;
-		}
-
-		auto child_op = op.children[0].get();
-
-		while (child_op->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-			D_ASSERT(!child_op->children.empty());
-			child_op = child_op->children[0].get();
-		}
-
-		return child_op->type == LogicalOperatorType::LOGICAL_ORDER_BY;
-	}
-	return false;
-}
-
-void TopN::PushdownDynamicFilters(LogicalTopN &op) {
-	// pushdown dynamic filters through the Top-N operator
-	if (op.orders[0].null_order == OrderByNullType::NULLS_FIRST) {
-		// FIXME: not supported for NULLS FIRST quite yet
-		// we can support NULLS FIRST by doing (x IS NULL) OR [boundary value]
-		return;
-	}
-	auto &type = op.orders[0].expression->return_type;
-	if (!TypeIsIntegral(type.InternalType()) && type.id() != LogicalTypeId::VARCHAR) {
-		// only supported for integral types currently
-		return;
-	}
-	if (op.orders[0].expression->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-		// we can only pushdown on ORDER BY [col] currently
-		return;
-	}
-	auto &colref = op.orders[0].expression->Cast<BoundColumnRefExpression>();
-	vector<JoinFilterPushdownColumn> columns;
-	JoinFilterPushdownColumn column;
-	column.probe_column_index = colref.binding;
-	columns.emplace_back(column);
-	vector<PushdownFilterTarget> pushdown_targets;
-	JoinFilterPushdownOptimizer::GetPushdownFilterTargets(*op.children[0], std::move(columns), pushdown_targets);
-	if (pushdown_targets.empty()) {
-		// no pushdown targets
-		return;
-	}
-	// found pushdown targets! generate dynamic filters
-	ExpressionType comparison_type;
-	if (op.orders[0].type == OrderType::ASCENDING) {
-		// for ascending order, we want the lowest N elements, so we filter on C <= [boundary]
-		// if we only have a single order clause, we can filter on C < boundary
-		comparison_type =
-		    op.orders.size() == 1 ? ExpressionType::COMPARE_LESSTHAN : ExpressionType::COMPARE_LESSTHANOREQUALTO;
-	} else {
-		// for descending order, we want the highest N elements, so we filter on C >= [boundary]
-		// if we only have a single order clause, we can filter on C > boundary
-		comparison_type =
-		    op.orders.size() == 1 ? ExpressionType::COMPARE_GREATERTHAN : ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-	}
-	Value minimum_value = type.InternalType() == PhysicalType::VARCHAR ? Value("") : Value::MinimumValue(type);
-	auto base_filter = make_uniq<ConstantFilter>(comparison_type, std::move(minimum_value));
-	auto filter_data = make_shared_ptr<DynamicFilterData>();
-	filter_data->filter = std::move(base_filter);
-
-	// put the filter into the Top-N clause
-	op.dynamic_filter = filter_data;
-
-	for (auto &target : pushdown_targets) {
-		auto &get = target.get;
-		D_ASSERT(target.columns.size() == 1);
-		auto col_idx = target.columns[0].probe_column_index.column_index;
-
-		// create the actual dynamic filter
-		auto dynamic_filter = make_uniq<DynamicFilter>(filter_data);
-		auto optional_filter = make_uniq<OptionalFilter>(std::move(dynamic_filter));
-
-		// push the filter into the table scan
-		auto &column_index = get.GetColumnIds()[col_idx];
-		get.table_filters.PushFilter(column_index, std::move(optional_filter));
-	}
-}
-
-unique_ptr<LogicalOperator> TopN::Optimize(unique_ptr<LogicalOperator> op) {
-	if (CanOptimize(*op)) {
-
-		vector<unique_ptr<LogicalOperator>> projections;
-
-		// traverse operator tree and collect all projection nodes until we reach
-		// the order by operator
-
-		auto child = std::move(op->children[0]);
-		// collect all projections until we get to the order by
-		while (child->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-			D_ASSERT(!child->children.empty());
-			auto tmp = std::move(child->children[0]);
-			projections.push_back(std::move(child));
-			child = std::move(tmp);
-		}
-		D_ASSERT(child->type == LogicalOperatorType::LOGICAL_ORDER_BY);
-		auto &order_by = child->Cast<LogicalOrder>();
-
-		// Move order by operator into children of limit operator
-		op->children[0] = std::move(child);
-
-		auto &limit = op->Cast<LogicalLimit>();
-		auto limit_val = limit.limit_val.GetConstantValue();
-		idx_t offset_val = 0;
-		if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-			offset_val = limit.offset_val.GetConstantValue();
-		}
-		auto topn = make_uniq<LogicalTopN>(std::move(order_by.orders), limit_val, offset_val);
-		topn->AddChild(std::move(order_by.children[0]));
-		auto cardinality = limit_val;
-		if (topn->children[0]->has_estimated_cardinality && topn->children[0]->estimated_cardinality < limit_val) {
-			cardinality = topn->children[0]->estimated_cardinality;
-		}
-		PushdownDynamicFilters(*topn);
-		topn->SetEstimatedCardinality(cardinality);
-		op = std::move(topn);
-
-		// reconstruct all projection nodes above limit operator
-		while (!projections.empty()) {
-			auto node = std::move(projections.back());
-			node->children[0] = std::move(op);
-			op = std::move(node);
-			projections.pop_back();
-		}
-	}
-
-	for (auto &child : op->children) {
-		child = Optimize(std::move(child));
-	}
-	return op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/optimizer/unnest_rewriter.cpp b/src/duckdb/src/optimizer/unnest_rewriter.cpp
deleted file mode 100644
index 4c4207e2a..000000000
--- a/src/duckdb/src/optimizer/unnest_rewriter.cpp
+++ /dev/null
@@ -1,334 +0,0 @@
-#include "duckdb/optimizer/unnest_rewriter.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_unnest.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-
-namespace duckdb {
-
-void UnnestRewriterPlanUpdater::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-}
-
-void UnnestRewriterPlanUpdater::VisitExpression(unique_ptr<Expression> *expression) {
-	auto &expr = *expression;
-
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-		auto &bound_column_ref = expr->Cast<BoundColumnRefExpression>();
-		for (idx_t i = 0; i < replace_bindings.size(); i++) {
-			if (bound_column_ref.binding == replace_bindings[i].old_binding) {
-				bound_column_ref.binding = replace_bindings[i].new_binding;
-				break;
-			}
-		}
-	}
-
-	VisitExpressionChildren(**expression);
-}
-
-unique_ptr<LogicalOperator> UnnestRewriter::Optimize(unique_ptr<LogicalOperator> op) {
-
-	UnnestRewriterPlanUpdater updater;
-	vector<reference<unique_ptr<LogicalOperator>>> candidates;
-	FindCandidates(op, candidates);
-
-	// rewrite the plan and update the bindings
-	for (auto &candidate : candidates) {
-
-		// rearrange the logical operators
-		if (RewriteCandidate(candidate)) {
-			updater.overwritten_tbl_idx = overwritten_tbl_idx;
-			// update the bindings of the BOUND_UNNEST expression
-			UpdateBoundUnnestBindings(updater, candidate);
-			// update the sequence of LOGICAL_PROJECTION(s)
-			UpdateRHSBindings(op, candidate, updater);
-			// reset
-			delim_columns.clear();
-			lhs_bindings.clear();
-		}
-	}
-
-	return op;
-}
-
-void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> &op,
-                                    vector<reference<unique_ptr<LogicalOperator>>> &candidates) {
-	// search children before adding, so that we add candidates bottom-up
-	for (auto &child : op->children) {
-		FindCandidates(child, candidates);
-	}
-
-	// search for operator that has a LOGICAL_DELIM_JOIN as its child
-	if (op->children.size() != 1) {
-		return;
-	}
-	if (op->children[0]->type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return;
-	}
-
-	// found a delim join
-	auto &delim_join = op->children[0]->Cast<LogicalComparisonJoin>();
-	// only support INNER delim joins
-	if (delim_join.join_type != JoinType::INNER) {
-		return;
-	}
-	// INNER delim join must have exactly one condition
-	if (delim_join.conditions.size() != 1) {
-		return;
-	}
-
-	// LHS child is a window
-	idx_t delim_idx = delim_join.delim_flipped ? 1 : 0;
-	idx_t other_idx = 1 - delim_idx;
-	if (delim_join.children[delim_idx]->type != LogicalOperatorType::LOGICAL_WINDOW) {
-		return;
-	}
-
-	// RHS child must be projection(s) followed by an UNNEST
-	auto curr_op = &delim_join.children[other_idx];
-	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		if (curr_op->get()->children.size() != 1) {
-			break;
-		}
-		curr_op = &curr_op->get()->children[0];
-	}
-
-	if (curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST &&
-	    curr_op->get()->children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op);
-	}
-}
-
-bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> &candidate) {
-
-	auto &topmost_op = *candidate;
-	if (topmost_op.type != LogicalOperatorType::LOGICAL_PROJECTION &&
-	    topmost_op.type != LogicalOperatorType::LOGICAL_WINDOW &&
-	    topmost_op.type != LogicalOperatorType::LOGICAL_FILTER &&
-	    topmost_op.type != LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY &&
-	    topmost_op.type != LogicalOperatorType::LOGICAL_UNNEST) {
-		return false;
-	}
-
-	// get the LOGICAL_DELIM_JOIN, which is a child of the candidate
-	D_ASSERT(topmost_op.children.size() == 1);
-	auto &delim_join = topmost_op.children[0]->Cast<LogicalComparisonJoin>();
-	D_ASSERT(delim_join.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	GetDelimColumns(delim_join);
-
-	// LHS of the LOGICAL_DELIM_JOIN is a LOGICAL_WINDOW that contains a LOGICAL_PROJECTION/LOGICAL_CROSS_JOIN
-	// this lhs_proj later becomes the child of the UNNEST
-
-	idx_t delim_idx = delim_join.delim_flipped ? 1 : 0;
-	idx_t other_idx = 1 - delim_idx;
-	auto &window = *delim_join.children[delim_idx];
-	auto &lhs_op = window.children[0];
-	GetLHSExpressions(*lhs_op);
-
-	// find the LOGICAL_UNNEST
-	// and get the path down to the LOGICAL_UNNEST
-	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
-	auto curr_op = &delim_join.children[other_idx];
-	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		path_to_unnest.push_back(curr_op);
-		curr_op = &curr_op->get()->children[0];
-	}
-
-	// store the table index of the child of the LOGICAL_UNNEST
-	// then update the plan by making the lhs_proj the child of the LOGICAL_UNNEST
-	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
-	D_ASSERT(unnest.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET);
-	overwritten_tbl_idx = unnest.children[0]->Cast<LogicalDelimGet>().table_index;
-
-	D_ASSERT(!unnest.children.empty());
-	auto &delim_get = unnest.children[0]->Cast<LogicalDelimGet>();
-	D_ASSERT(delim_get.chunk_types.size() > 1);
-	distinct_unnest_count = delim_get.chunk_types.size();
-	unnest.children[0] = std::move(lhs_op);
-
-	// replace the LOGICAL_DELIM_JOIN with its RHS child operator
-	topmost_op.children[0] = std::move(*path_to_unnest.front());
-	return true;
-}
-
-void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> &plan, unique_ptr<LogicalOperator> &candidate,
-                                       UnnestRewriterPlanUpdater &updater) {
-
-	auto &topmost_op = *candidate;
-	idx_t shift = lhs_bindings.size();
-
-	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
-	auto curr_op = &topmost_op.children[0];
-	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-
-		path_to_unnest.push_back(curr_op);
-		D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
-		auto &proj = curr_op->get()->Cast<LogicalProjection>();
-
-		// pop the unnest columns and the delim index
-		D_ASSERT(proj.expressions.size() > distinct_unnest_count);
-		for (idx_t i = 0; i < distinct_unnest_count; i++) {
-			proj.expressions.pop_back();
-		}
-
-		// store all shifted current bindings
-		idx_t tbl_idx = proj.table_index;
-		for (idx_t i = 0; i < proj.expressions.size(); i++) {
-			ReplaceBinding replace_binding(ColumnBinding(tbl_idx, i), ColumnBinding(tbl_idx, i + shift));
-			updater.replace_bindings.push_back(replace_binding);
-		}
-
-		curr_op = &curr_op->get()->children[0];
-	}
-
-	// update all bindings by shifting them
-	updater.VisitOperator(*plan);
-	updater.replace_bindings.clear();
-
-	// update all bindings coming from the LHS to RHS bindings
-	D_ASSERT(topmost_op.children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	auto &top_proj = topmost_op.children[0]->Cast<LogicalProjection>();
-	for (idx_t i = 0; i < lhs_bindings.size(); i++) {
-		ReplaceBinding replace_binding(lhs_bindings[i].binding, ColumnBinding(top_proj.table_index, i));
-		updater.replace_bindings.push_back(replace_binding);
-	}
-
-	// temporarily remove the BOUND_UNNESTs and the child of the LOGICAL_UNNEST from the plan
-	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
-	vector<unique_ptr<Expression>> temp_bound_unnests;
-	for (auto &temp_bound_unnest : unnest.expressions) {
-		temp_bound_unnests.push_back(std::move(temp_bound_unnest));
-	}
-	D_ASSERT(unnest.children.size() == 1);
-	auto temp_unnest_child = std::move(unnest.children[0]);
-	unnest.expressions.clear();
-	unnest.children.clear();
-	// update the bindings of the plan
-	updater.VisitOperator(*plan);
-	updater.replace_bindings.clear();
-	// add the children again
-	for (auto &temp_bound_unnest : temp_bound_unnests) {
-		unnest.expressions.push_back(std::move(temp_bound_unnest));
-	}
-	unnest.children.push_back(std::move(temp_unnest_child));
-
-	// add the LHS expressions to each LOGICAL_PROJECTION
-	for (idx_t i = path_to_unnest.size(); i > 0; i--) {
-
-		D_ASSERT(path_to_unnest[i - 1]->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
-		auto &proj = path_to_unnest[i - 1]->get()->Cast<LogicalProjection>();
-
-		// temporarily store the existing expressions
-		vector<unique_ptr<Expression>> existing_expressions;
-		for (idx_t expr_idx = 0; expr_idx < proj.expressions.size(); expr_idx++) {
-			existing_expressions.push_back(std::move(proj.expressions[expr_idx]));
-		}
-
-		proj.expressions.clear();
-
-		// add the new expressions
-		for (idx_t expr_idx = 0; expr_idx < lhs_bindings.size(); expr_idx++) {
-			auto new_expr = make_uniq<BoundColumnRefExpression>(
-			    lhs_bindings[expr_idx].alias, lhs_bindings[expr_idx].type, lhs_bindings[expr_idx].binding);
-			proj.expressions.push_back(std::move(new_expr));
-
-			// update the table index
-			lhs_bindings[expr_idx].binding.table_index = proj.table_index;
-			lhs_bindings[expr_idx].binding.column_index = expr_idx;
-		}
-
-		// add the existing expressions again
-		for (idx_t expr_idx = 0; expr_idx < existing_expressions.size(); expr_idx++) {
-			proj.expressions.push_back(std::move(existing_expressions[expr_idx]));
-		}
-	}
-}
-
-void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater,
-                                               unique_ptr<LogicalOperator> &candidate) {
-
-	auto &topmost_op = *candidate;
-
-	// traverse LOGICAL_PROJECTION(s)
-	auto curr_op = &topmost_op.children[0];
-	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		curr_op = &curr_op->get()->children[0];
-	}
-
-	// found the LOGICAL_UNNEST
-	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
-
-	D_ASSERT(unnest.children.size() == 1);
-	auto unnest_cols = unnest.children[0]->GetColumnBindings();
-
-	for (idx_t i = 0; i < delim_columns.size(); i++) {
-		auto delim_binding = delim_columns[i];
-
-		auto unnest_it = unnest_cols.begin();
-		while (unnest_it != unnest_cols.end()) {
-			auto unnest_binding = *unnest_it;
-
-			if (delim_binding.table_index == unnest_binding.table_index) {
-				unnest_binding.table_index = overwritten_tbl_idx;
-				unnest_binding.column_index = i;
-				updater.replace_bindings.emplace_back(unnest_binding, delim_binding);
-				unnest_cols.erase(unnest_it);
-				break;
-			}
-			unnest_it++;
-		}
-	}
-
-	// update bindings
-	for (auto &unnest_expr : unnest.expressions) {
-		updater.VisitExpression(&unnest_expr);
-	}
-	updater.replace_bindings.clear();
-}
-
-void UnnestRewriter::GetDelimColumns(LogicalOperator &op) {
-
-	D_ASSERT(op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &delim_join = op.Cast<LogicalComparisonJoin>();
-	for (idx_t i = 0; i < delim_join.duplicate_eliminated_columns.size(); i++) {
-		auto &expr = *delim_join.duplicate_eliminated_columns[i];
-		D_ASSERT(expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF);
-		auto &bound_colref_expr = expr.Cast<BoundColumnRefExpression>();
-		delim_columns.push_back(bound_colref_expr.binding);
-	}
-}
-
-void UnnestRewriter::GetLHSExpressions(LogicalOperator &op) {
-
-	op.ResolveOperatorTypes();
-	auto col_bindings = op.GetColumnBindings();
-	D_ASSERT(op.types.size() == col_bindings.size());
-
-	bool set_alias = false;
-	// we can easily extract the alias for LOGICAL_PROJECTION(s)
-	if (op.type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		auto &proj = op.Cast<LogicalProjection>();
-		if (proj.expressions.size() == op.types.size()) {
-			set_alias = true;
-		}
-	}
-
-	for (idx_t i = 0; i < op.types.size(); i++) {
-		lhs_bindings.emplace_back(col_bindings[i], op.types[i]);
-		if (set_alias) {
-			auto &proj = op.Cast<LogicalProjection>();
-			lhs_bindings.back().alias = proj.expressions[i]->GetAlias();
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/base_pipeline_event.cpp b/src/duckdb/src/parallel/base_pipeline_event.cpp
deleted file mode 100644
index 347f114f5..000000000
--- a/src/duckdb/src/parallel/base_pipeline_event.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "duckdb/parallel/base_pipeline_event.hpp"
-
-namespace duckdb {
-
-BasePipelineEvent::BasePipelineEvent(shared_ptr<Pipeline> pipeline_p)
-    : Event(pipeline_p->executor), pipeline(std::move(pipeline_p)) {
-}
-
-BasePipelineEvent::BasePipelineEvent(Pipeline &pipeline_p)
-    : Event(pipeline_p.executor), pipeline(pipeline_p.shared_from_this()) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/event.cpp b/src/duckdb/src/parallel/event.cpp
deleted file mode 100644
index 0ecfddea5..000000000
--- a/src/duckdb/src/parallel/event.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "duckdb/parallel/event.hpp"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/execution/executor.hpp"
-
-namespace duckdb {
-
-Event::Event(Executor &executor_p)
-    : executor(executor_p), finished_tasks(0), total_tasks(0), finished_dependencies(0), total_dependencies(0),
-      finished(false) {
-}
-
-void Event::CompleteDependency() {
-	idx_t current_finished = ++finished_dependencies;
-	D_ASSERT(current_finished <= total_dependencies);
-	if (current_finished == total_dependencies) {
-		// all dependencies have been completed: schedule the event
-		D_ASSERT(total_tasks == 0);
-		Schedule();
-		if (total_tasks == 0) {
-			Finish();
-		}
-	}
-}
-
-void Event::Finish() {
-	D_ASSERT(!finished);
-	FinishEvent();
-	finished = true;
-	// finished processing the pipeline, now we can schedule pipelines that depend on this pipeline
-	for (auto &parent_entry : parents) {
-		auto parent = parent_entry.lock();
-		if (!parent) { // LCOV_EXCL_START
-			continue;
-		} // LCOV_EXCL_STOP
-		// mark a dependency as completed for each of the parents
-		parent->CompleteDependency();
-	}
-	FinalizeFinish();
-}
-
-void Event::AddDependency(Event &event) {
-	total_dependencies++;
-	event.parents.push_back(weak_ptr<Event>(shared_from_this()));
-#ifdef DEBUG
-	event.parents_raw.push_back(*this);
-#endif
-}
-
-const vector<reference<Event>> &Event::GetParentsVerification() const {
-	D_ASSERT(parents.size() == parents_raw.size());
-	return parents_raw;
-}
-
-void Event::FinishTask() {
-	D_ASSERT(finished_tasks.load() < total_tasks.load());
-	idx_t current_tasks = total_tasks;
-	idx_t current_finished = ++finished_tasks;
-	D_ASSERT(current_finished <= current_tasks);
-	if (current_finished == current_tasks) {
-		Finish();
-	}
-}
-
-void Event::InsertEvent(shared_ptr<Event> replacement_event) {
-	replacement_event->parents = std::move(parents);
-#ifdef DEBUG
-	replacement_event->parents_raw = std::move(parents_raw);
-#endif
-	replacement_event->AddDependency(*this);
-	executor.AddEvent(std::move(replacement_event));
-}
-
-void Event::SetTasks(vector<shared_ptr<Task>> tasks) {
-	auto &ts = TaskScheduler::GetScheduler(executor.context);
-	D_ASSERT(total_tasks == 0);
-	D_ASSERT(!tasks.empty());
-	this->total_tasks = tasks.size();
-	for (auto &task : tasks) {
-		ts.ScheduleTask(executor.GetToken(), std::move(task));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/executor.cpp b/src/duckdb/src/parallel/executor.cpp
deleted file mode 100644
index 487a9c3d0..000000000
--- a/src/duckdb/src/parallel/executor.cpp
+++ /dev/null
@@ -1,723 +0,0 @@
-#include "duckdb/execution/executor.hpp"
-
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-#include "duckdb/execution/operator/set/physical_cte.hpp"
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/parallel/meta_pipeline.hpp"
-#include "duckdb/parallel/pipeline_complete_event.hpp"
-#include "duckdb/parallel/pipeline_event.hpp"
-#include "duckdb/parallel/pipeline_executor.hpp"
-#include "duckdb/parallel/pipeline_finish_event.hpp"
-#include "duckdb/parallel/pipeline_initialize_event.hpp"
-#include "duckdb/parallel/pipeline_prepare_finish_event.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-#include <algorithm>
-#include <chrono>
-
-namespace duckdb {
-
-Executor::Executor(ClientContext &context) : context(context), executor_tasks(0), blocked_thread_time(0) {
-}
-
-Executor::~Executor() {
-	D_ASSERT(Exception::UncaughtException() || executor_tasks == 0);
-}
-
-Executor &Executor::Get(ClientContext &context) {
-	return context.GetExecutor();
-}
-
-void Executor::AddEvent(shared_ptr<Event> event) {
-	lock_guard<mutex> elock(executor_lock);
-	if (cancelled) {
-		return;
-	}
-	events.push_back(std::move(event));
-}
-
-struct PipelineEventStack {
-	PipelineEventStack(Event &pipeline_initialize_event, Event &pipeline_event, Event &pipeline_prepare_finish_event,
-	                   Event &pipeline_finish_event, Event &pipeline_complete_event)
-	    : pipeline_initialize_event(pipeline_initialize_event), pipeline_event(pipeline_event),
-	      pipeline_prepare_finish_event(pipeline_prepare_finish_event), pipeline_finish_event(pipeline_finish_event),
-	      pipeline_complete_event(pipeline_complete_event) {
-	}
-
-	Event &pipeline_initialize_event;
-	Event &pipeline_event;
-	Event &pipeline_prepare_finish_event;
-	Event &pipeline_finish_event;
-	Event &pipeline_complete_event;
-};
-
-using event_map_t = reference_map_t<Pipeline, PipelineEventStack>;
-
-struct ScheduleEventData {
-	ScheduleEventData(const vector<shared_ptr<MetaPipeline>> &meta_pipelines, vector<shared_ptr<Event>> &events,
-	                  bool initial_schedule)
-	    : meta_pipelines(meta_pipelines), events(events), initial_schedule(initial_schedule) {
-	}
-
-	const vector<shared_ptr<MetaPipeline>> &meta_pipelines;
-	vector<shared_ptr<Event>> &events;
-	bool initial_schedule;
-	event_map_t event_map;
-};
-
-void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, ScheduleEventData &event_data) {
-	D_ASSERT(meta_pipeline);
-	auto &events = event_data.events;
-	auto &event_map = event_data.event_map;
-
-	// create events/stack for the base pipeline
-	auto base_pipeline = meta_pipeline->GetBasePipeline();
-	auto base_initialize_event = make_shared_ptr<PipelineInitializeEvent>(base_pipeline);
-	auto base_event = make_shared_ptr<PipelineEvent>(base_pipeline);
-	auto base_prepare_finish_event = make_shared_ptr<PipelinePrepareFinishEvent>(base_pipeline);
-	auto base_finish_event = make_shared_ptr<PipelineFinishEvent>(base_pipeline);
-	auto base_complete_event =
-	    make_shared_ptr<PipelineCompleteEvent>(base_pipeline->executor, event_data.initial_schedule);
-	PipelineEventStack base_stack(*base_initialize_event, *base_event, *base_prepare_finish_event, *base_finish_event,
-	                              *base_complete_event);
-	events.push_back(std::move(base_initialize_event));
-	events.push_back(std::move(base_event));
-	events.push_back(std::move(base_prepare_finish_event));
-	events.push_back(std::move(base_finish_event));
-	events.push_back(std::move(base_complete_event));
-
-	// dependencies: initialize -> event -> prepare finish -> finish -> complete
-	base_stack.pipeline_event.AddDependency(base_stack.pipeline_initialize_event);
-	base_stack.pipeline_prepare_finish_event.AddDependency(base_stack.pipeline_event);
-	base_stack.pipeline_finish_event.AddDependency(base_stack.pipeline_prepare_finish_event);
-	base_stack.pipeline_complete_event.AddDependency(base_stack.pipeline_finish_event);
-
-	// create an event and stack for all pipelines in the MetaPipeline
-	vector<shared_ptr<Pipeline>> pipelines;
-	meta_pipeline->GetPipelines(pipelines, false);
-	for (idx_t i = 1; i < pipelines.size(); i++) { // loop starts at 1 because 0 is the base pipeline
-		auto &pipeline = pipelines[i];
-		D_ASSERT(pipeline);
-
-		// create events/stack for this pipeline
-		auto pipeline_event = make_shared_ptr<PipelineEvent>(pipeline);
-
-		auto finish_group = meta_pipeline->GetFinishGroup(*pipeline);
-		if (finish_group) {
-			// this pipeline is part of a finish group
-			const auto group_entry = event_map.find(*finish_group.get());
-			D_ASSERT(group_entry != event_map.end());
-			auto &group_stack = group_entry->second;
-			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
-			                                  group_stack.pipeline_prepare_finish_event,
-			                                  group_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
-
-			// dependencies: base_finish -> pipeline_event -> group_prepare_finish
-			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_finish_event);
-			group_stack.pipeline_prepare_finish_event.AddDependency(pipeline_stack.pipeline_event);
-
-			// add pipeline stack to event map
-			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
-		} else if (meta_pipeline->HasFinishEvent(*pipeline)) {
-			// this pipeline has its own finish event (despite going into the same sink - Finalize twice!)
-			auto pipeline_prepare_finish_event = make_shared_ptr<PipelinePrepareFinishEvent>(pipeline);
-			auto pipeline_finish_event = make_shared_ptr<PipelineFinishEvent>(pipeline);
-			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
-			                                  *pipeline_prepare_finish_event, *pipeline_finish_event,
-			                                  base_stack.pipeline_complete_event);
-			events.push_back(std::move(pipeline_prepare_finish_event));
-			events.push_back(std::move(pipeline_finish_event));
-
-			// dependencies:
-			// base_finish -> pipeline_event -> pipeline_prepare_finish -> pipeline_finish -> base_complete
-			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_finish_event);
-			pipeline_stack.pipeline_prepare_finish_event.AddDependency(pipeline_stack.pipeline_event);
-			pipeline_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_prepare_finish_event);
-			base_stack.pipeline_complete_event.AddDependency(pipeline_stack.pipeline_finish_event);
-
-			// add pipeline stack to event map
-			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
-		} else {
-			// no additional finish event
-			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
-			                                  base_stack.pipeline_prepare_finish_event,
-			                                  base_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
-
-			// dependencies: base_initialize -> pipeline_event -> base_prepare_finish
-			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_initialize_event);
-			base_stack.pipeline_prepare_finish_event.AddDependency(pipeline_stack.pipeline_event);
-
-			// add pipeline stack to event map
-			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
-		}
-		events.push_back(std::move(pipeline_event));
-	}
-
-	// add base stack to the event data too
-	event_map.insert(make_pair(reference<Pipeline>(*base_pipeline), base_stack));
-
-	for (auto &pipeline : pipelines) {
-		auto source = pipeline->GetSource();
-		if (source->type == PhysicalOperatorType::TABLE_SCAN) {
-			auto &table_function = source->Cast<PhysicalTableScan>();
-			if (table_function.function.global_initialization == TableFunctionInitialization::INITIALIZE_ON_SCHEDULE) {
-				// certain functions have to be eagerly initialized during scheduling
-				// if that is the case - initialize the function here
-				pipeline->ResetSource(true);
-			}
-		}
-	}
-}
-
-void Executor::ScheduleEventsInternal(ScheduleEventData &event_data) {
-	auto &events = event_data.events;
-	D_ASSERT(events.empty());
-
-	// create all the required pipeline events
-	for (auto &meta_pipeline : event_data.meta_pipelines) {
-		SchedulePipeline(meta_pipeline, event_data);
-	}
-
-	// set up the dependencies for complete event
-	auto &event_map = event_data.event_map;
-	for (auto &entry : event_map) {
-		auto &pipeline = entry.first.get();
-		for (auto &dependency : pipeline.dependencies) {
-			auto dep = dependency.lock();
-			D_ASSERT(dep);
-			auto event_map_entry = event_map.find(*dep);
-			if (event_map_entry == event_map.end()) {
-				continue;
-			}
-			D_ASSERT(event_map_entry != event_map.end());
-			auto &dep_entry = event_map_entry->second;
-			entry.second.pipeline_event.AddDependency(dep_entry.pipeline_complete_event);
-		}
-	}
-
-	// set the dependencies for pipeline event
-	for (auto &meta_pipeline : event_data.meta_pipelines) {
-		for (auto &entry : meta_pipeline->GetDependencies()) {
-			auto &pipeline = entry.first.get();
-			auto root_entry = event_map.find(pipeline);
-			D_ASSERT(root_entry != event_map.end());
-			auto &pipeline_stack = root_entry->second;
-			for (auto &dependency : entry.second) {
-				auto event_entry = event_map.find(dependency);
-				D_ASSERT(event_entry != event_map.end());
-				auto &dependency_stack = event_entry->second;
-				pipeline_stack.pipeline_event.AddDependency(dependency_stack.pipeline_event);
-			}
-		}
-	}
-
-	// these dependencies make it so that things happen in this order:
-	// 1. all join build child pipelines run until Combine
-	// 2. all join build child pipeline PrepareFinalize
-	// 3. all join build child pipelines Finalize
-	// operators communicate their memory usage through the TemporaryMemoryManger (TMM) in PrepareFinalize
-	// then, when the child pipelines Finalize, all required memory is known, and TMM can make an informed decision
-	for (auto &meta_pipeline : event_data.meta_pipelines) {
-		vector<shared_ptr<MetaPipeline>> children;
-		meta_pipeline->GetMetaPipelines(children, false, true);
-		for (auto &child1 : children) {
-			if (child1->Type() != MetaPipelineType::JOIN_BUILD) {
-				continue; // We only want to do this for join builds
-			}
-			auto &child1_base = *child1->GetBasePipeline();
-			auto child1_entry = event_map.find(child1_base);
-			D_ASSERT(child1_entry != event_map.end());
-
-			for (auto &child2 : children) {
-				if (child2->Type() != MetaPipelineType::JOIN_BUILD || RefersToSameObject(*child1, *child2)) {
-					continue; // We don't want to depend on itself
-				}
-				if (!RefersToSameObject(*child1->GetParent(), *child2->GetParent())) {
-					continue; // Different parents, skip
-				}
-
-				auto &child2_base = *child2->GetBasePipeline();
-				auto child2_entry = event_map.find(child2_base);
-				D_ASSERT(child2_entry != event_map.end());
-
-				// all children PrepareFinalize must wait until all Combine
-				child1_entry->second.pipeline_prepare_finish_event.AddDependency(child2_entry->second.pipeline_event);
-				// all children Finalize must wait until all PrepareFinalize
-				child1_entry->second.pipeline_finish_event.AddDependency(
-				    child2_entry->second.pipeline_prepare_finish_event);
-			}
-		}
-	}
-
-	// verify that we have no cyclic dependencies
-	VerifyScheduledEvents(event_data);
-
-	// schedule the pipelines that do not have dependencies
-	for (auto &event : events) {
-		if (!event->HasDependencies()) {
-			event->Schedule();
-		}
-	}
-}
-
-void Executor::ScheduleEvents(const vector<shared_ptr<MetaPipeline>> &meta_pipelines) {
-	ScheduleEventData event_data(meta_pipelines, events, true);
-	ScheduleEventsInternal(event_data);
-}
-
-void Executor::VerifyScheduledEvents(const ScheduleEventData &event_data) {
-#ifdef DEBUG
-	const idx_t count = event_data.events.size();
-	vector<reference<Event>> vertices;
-	vertices.reserve(count);
-	for (const auto &event : event_data.events) {
-		vertices.push_back(*event);
-	}
-	vector<bool> visited(count, false);
-	vector<bool> recursion_stack(count, false);
-	for (idx_t i = 0; i < count; i++) {
-		VerifyScheduledEventsInternal(i, vertices, visited, recursion_stack);
-	}
-#endif
-}
-
-void Executor::VerifyScheduledEventsInternal(const idx_t vertex, const vector<reference<Event>> &vertices,
-                                             vector<bool> &visited, vector<bool> &recursion_stack) {
-	D_ASSERT(!recursion_stack[vertex]); // this vertex is in the recursion stack: circular dependency!
-	if (visited[vertex]) {
-		return; // early out: we already visited this vertex
-	}
-
-	auto &parents = vertices[vertex].get().GetParentsVerification();
-	if (parents.empty()) {
-		return; // early out: outgoing edges
-	}
-
-	// create a vector the indices of the adjacent events
-	vector<idx_t> adjacent;
-	const idx_t count = vertices.size();
-	for (auto parent : parents) {
-		idx_t i;
-		for (i = 0; i < count; i++) {
-			if (RefersToSameObject(vertices[i], parent)) {
-				adjacent.push_back(i);
-				break;
-			}
-		}
-		D_ASSERT(i != count); // dependency must be in there somewhere
-	}
-
-	// mark vertex as visited and add to recursion stack
-	visited[vertex] = true;
-	recursion_stack[vertex] = true;
-
-	// recurse into adjacent vertices
-	for (const auto &i : adjacent) {
-		VerifyScheduledEventsInternal(i, vertices, visited, recursion_stack);
-	}
-
-	// remove vertex from recursion stack
-	recursion_stack[vertex] = false;
-}
-
-void Executor::AddRecursiveCTE(PhysicalOperator &rec_cte) {
-	recursive_ctes.push_back(rec_cte);
-}
-
-void Executor::ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines_p,
-                                   vector<shared_ptr<Event>> &events_p) {
-	ScheduleEventData event_data(pipelines_p, events_p, false);
-	ScheduleEventsInternal(event_data);
-}
-
-bool Executor::NextExecutor() {
-	if (root_pipeline_idx >= root_pipelines.size()) {
-		return false;
-	}
-	root_pipelines[root_pipeline_idx]->Reset();
-	root_executor = make_uniq<PipelineExecutor>(context, *root_pipelines[root_pipeline_idx]);
-	root_pipeline_idx++;
-	return true;
-}
-
-void Executor::VerifyPipeline(Pipeline &pipeline) {
-	D_ASSERT(!pipeline.ToString().empty());
-	auto operators = pipeline.GetOperators();
-	for (auto &other_pipeline : pipelines) {
-		auto other_operators = other_pipeline->GetOperators();
-		for (idx_t op_idx = 0; op_idx < operators.size(); op_idx++) {
-			for (idx_t other_idx = 0; other_idx < other_operators.size(); other_idx++) {
-				auto &left = operators[op_idx].get();
-				auto &right = other_operators[other_idx].get();
-				if (left.Equals(right)) {
-					D_ASSERT(right.Equals(left));
-				} else {
-					D_ASSERT(!right.Equals(left));
-				}
-			}
-		}
-	}
-}
-
-void Executor::VerifyPipelines() {
-#ifdef DEBUG
-	for (auto &pipeline : pipelines) {
-		VerifyPipeline(*pipeline);
-	}
-#endif
-}
-
-void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan_p) {
-	Reset();
-	owned_plan = std::move(physical_plan_p);
-	InitializeInternal(*owned_plan);
-}
-
-void Executor::Initialize(PhysicalOperator &plan) {
-	Reset();
-	InitializeInternal(plan);
-}
-
-void Executor::InitializeInternal(PhysicalOperator &plan) {
-
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-	{
-		lock_guard<mutex> elock(executor_lock);
-		physical_plan = &plan;
-
-		this->profiler = ClientData::Get(context).profiler;
-		profiler->Initialize(plan);
-		this->producer = scheduler.CreateProducer();
-
-		// build and ready the pipelines
-		PipelineBuildState state;
-		auto root_pipeline = make_shared_ptr<MetaPipeline>(*this, state, nullptr);
-		root_pipeline->Build(*physical_plan);
-		root_pipeline->Ready();
-
-		// ready recursive cte pipelines too
-		for (auto &rec_cte_ref : recursive_ctes) {
-			auto &rec_cte = rec_cte_ref.get().Cast<PhysicalRecursiveCTE>();
-			rec_cte.recursive_meta_pipeline->Ready();
-		}
-
-		// set root pipelines, i.e., all pipelines that end in the final sink
-		root_pipeline->GetPipelines(root_pipelines, false);
-		root_pipeline_idx = 0;
-
-		// collect all meta-pipelines from the root pipeline
-		vector<shared_ptr<MetaPipeline>> to_schedule;
-		root_pipeline->GetMetaPipelines(to_schedule, true, true);
-
-		// number of 'PipelineCompleteEvent's is equal to the number of meta pipelines, so we have to set it here
-		total_pipelines = to_schedule.size();
-
-		// collect all pipelines from the root pipelines (recursively) for the progress bar and verify them
-		root_pipeline->GetPipelines(pipelines, true);
-
-		// finally, verify and schedule
-		VerifyPipelines();
-		ScheduleEvents(to_schedule);
-	}
-}
-
-void Executor::CancelTasks() {
-	task.reset();
-
-	{
-		lock_guard<mutex> elock(executor_lock);
-		// mark the query as cancelled so tasks will early-out
-		cancelled = true;
-		// destroy all pipelines, events and states
-		for (auto &rec_cte_ref : recursive_ctes) {
-			auto &rec_cte = rec_cte_ref.get().Cast<PhysicalRecursiveCTE>();
-			rec_cte.recursive_meta_pipeline.reset();
-		}
-		pipelines.clear();
-		root_pipelines.clear();
-		to_be_rescheduled_tasks.clear();
-		events.clear();
-	}
-	// Take all pending tasks and execute them until they cancel
-	while (executor_tasks > 0) {
-		WorkOnTasks();
-	}
-}
-
-void Executor::WorkOnTasks() {
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-
-	shared_ptr<Task> task_from_producer;
-	while (scheduler.GetTaskFromProducer(*producer, task_from_producer)) {
-		auto res = task_from_producer->Execute(TaskExecutionMode::PROCESS_ALL);
-		if (res == TaskExecutionResult::TASK_BLOCKED) {
-			task_from_producer->Deschedule();
-		}
-		task_from_producer.reset();
-	}
-}
-
-void Executor::SignalTaskRescheduled(lock_guard<mutex> &) {
-	task_reschedule.notify_one();
-}
-
-void Executor::WaitForTask() {
-#ifndef DUCKDB_NO_THREADS
-	static constexpr std::chrono::milliseconds WAIT_TIME_MS = std::chrono::milliseconds(WAIT_TIME);
-	std::unique_lock<mutex> l(executor_lock);
-	if (to_be_rescheduled_tasks.empty()) {
-		return;
-	}
-	if (ResultCollectorIsBlocked()) {
-		// If the result collector is blocked, it won't get unblocked until the connection calls Fetch
-		return;
-	}
-
-	blocked_thread_time++;
-	task_reschedule.wait_for(l, WAIT_TIME_MS);
-#endif
-}
-
-void Executor::RescheduleTask(shared_ptr<Task> &task_p) {
-	// This function will spin lock until the task provided is added to the to_be_rescheduled_tasks
-	while (true) {
-		lock_guard<mutex> l(executor_lock);
-		if (cancelled) {
-			return;
-		}
-		auto entry = to_be_rescheduled_tasks.find(task_p.get());
-		if (entry != to_be_rescheduled_tasks.end()) {
-			auto &scheduler = TaskScheduler::GetScheduler(context);
-			to_be_rescheduled_tasks.erase(task_p.get());
-			scheduler.ScheduleTask(GetToken(), task_p);
-			SignalTaskRescheduled(l);
-			break;
-		}
-	}
-}
-
-bool Executor::ResultCollectorIsBlocked() {
-	if (!HasStreamingResultCollector()) {
-		return false;
-	}
-	if (completed_pipelines + 1 != total_pipelines) {
-		// The result collector is always in the last pipeline
-		return false;
-	}
-	if (to_be_rescheduled_tasks.empty()) {
-		return false;
-	}
-	for (auto &kv : to_be_rescheduled_tasks) {
-		auto &task = kv.second;
-		if (task->TaskBlockedOnResult()) {
-			// At least one of the blocked tasks is connected to a result collector
-			// This task could be the only task that could unblock the other non-result-collector tasks
-			// To prevent a scenario where we halt indefinitely, we return here so it can be unblocked by a call to
-			// Fetch
-			return true;
-		}
-	}
-	return false;
-}
-
-void Executor::AddToBeRescheduled(shared_ptr<Task> &task_p) {
-	lock_guard<mutex> l(executor_lock);
-	if (cancelled) {
-		return;
-	}
-	if (to_be_rescheduled_tasks.find(task_p.get()) != to_be_rescheduled_tasks.end()) {
-		return;
-	}
-	to_be_rescheduled_tasks[task_p.get()] = std::move(task_p);
-}
-
-bool Executor::ExecutionIsFinished() {
-	return completed_pipelines >= total_pipelines || HasError();
-}
-
-PendingExecutionResult Executor::ExecuteTask(bool dry_run) {
-	// Only executor should return NO_TASKS_AVAILABLE
-	D_ASSERT(execution_result != PendingExecutionResult::NO_TASKS_AVAILABLE);
-	if (execution_result != PendingExecutionResult::RESULT_NOT_READY && ExecutionIsFinished()) {
-		return execution_result;
-	}
-	// check if there are any incomplete pipelines
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-	if (completed_pipelines < total_pipelines) {
-		// there are! if we don't already have a task, fetch one
-		auto current_task = task.get();
-		if (dry_run) {
-			// Pretend we have no task, we don't want to execute anything
-			current_task = nullptr;
-		} else {
-			if (!task) {
-				scheduler.GetTaskFromProducer(*producer, task);
-			}
-			current_task = task.get();
-		}
-
-		if (!current_task && !HasError()) {
-			// there are no tasks to be scheduled and there are tasks blocked
-			lock_guard<mutex> l(executor_lock);
-			if (to_be_rescheduled_tasks.empty()) {
-				return PendingExecutionResult::NO_TASKS_AVAILABLE;
-			}
-			// At least one task is blocked
-			if (ResultCollectorIsBlocked()) {
-				return PendingExecutionResult::RESULT_READY;
-			}
-			return PendingExecutionResult::BLOCKED;
-		}
-
-		if (current_task) {
-			// if we have a task, partially process it
-			auto result = task->Execute(TaskExecutionMode::PROCESS_PARTIAL);
-			if (result == TaskExecutionResult::TASK_BLOCKED) {
-				task->Deschedule();
-				task.reset();
-			} else if (result == TaskExecutionResult::TASK_FINISHED) {
-				// if the task is finished, clean it up
-				task.reset();
-			}
-		}
-		if (!HasError()) {
-			// we (partially) processed a task and no exceptions were thrown
-			// give back control to the caller
-			return PendingExecutionResult::RESULT_NOT_READY;
-		}
-		execution_result = PendingExecutionResult::EXECUTION_ERROR;
-
-		// an exception has occurred executing one of the pipelines
-		// we need to cancel all tasks associated with this executor
-		CancelTasks();
-		ThrowException();
-	}
-	D_ASSERT(!task);
-
-	lock_guard<mutex> elock(executor_lock);
-	pipelines.clear();
-	NextExecutor();
-	if (HasError()) { // LCOV_EXCL_START
-		// an exception has occurred executing one of the pipelines
-		execution_result = PendingExecutionResult::EXECUTION_ERROR;
-		ThrowException();
-	} // LCOV_EXCL_STOP
-	execution_result = PendingExecutionResult::EXECUTION_FINISHED;
-	return execution_result;
-}
-
-void Executor::Reset() {
-	lock_guard<mutex> elock(executor_lock);
-	physical_plan = nullptr;
-	cancelled = false;
-	owned_plan.reset();
-	root_executor.reset();
-	root_pipelines.clear();
-	root_pipeline_idx = 0;
-	completed_pipelines = 0;
-	total_pipelines = 0;
-	error_manager.Reset();
-	pipelines.clear();
-	events.clear();
-	to_be_rescheduled_tasks.clear();
-	execution_result = PendingExecutionResult::RESULT_NOT_READY;
-}
-
-shared_ptr<Pipeline> Executor::CreateChildPipeline(Pipeline &current, PhysicalOperator &op) {
-	D_ASSERT(!current.operators.empty());
-	D_ASSERT(op.IsSource());
-	// found another operator that is a source, schedule a child pipeline
-	// 'op' is the source, and the sink is the same
-	auto child_pipeline = make_shared_ptr<Pipeline>(*this);
-	child_pipeline->sink = current.sink;
-	child_pipeline->source = &op;
-
-	// the child pipeline has the same operators up until 'op'
-	for (auto current_op : current.operators) {
-		if (&current_op.get() == &op) {
-			break;
-		}
-		child_pipeline->operators.push_back(current_op);
-	}
-
-	return child_pipeline;
-}
-
-vector<LogicalType> Executor::GetTypes() {
-	D_ASSERT(physical_plan);
-	return physical_plan->GetTypes();
-}
-
-void Executor::PushError(ErrorData exception) {
-	// push the exception onto the stack
-	error_manager.PushError(std::move(exception));
-	// interrupt execution of any other pipelines that belong to this executor
-	context.interrupted = true;
-}
-
-bool Executor::HasError() {
-	return error_manager.HasError();
-}
-
-ErrorData Executor::GetError() {
-	return error_manager.GetError();
-}
-
-void Executor::ThrowException() {
-	error_manager.ThrowException();
-}
-
-void Executor::Flush(ThreadContext &thread_context) {
-	static constexpr std::chrono::milliseconds WAIT_TIME_MS = std::chrono::milliseconds(WAIT_TIME);
-	auto global_profiler = profiler;
-	if (global_profiler) {
-		global_profiler->Flush(thread_context.profiler);
-
-		auto blocked_time = blocked_thread_time.load();
-		global_profiler->SetInfo(double(blocked_time * WAIT_TIME_MS.count()) / 1000);
-	}
-}
-
-idx_t Executor::GetPipelinesProgress(ProgressData &progress) { // LCOV_EXCL_START
-	lock_guard<mutex> elock(executor_lock);
-
-	progress.done = 0;
-	progress.total = 0;
-	idx_t count_invalid = 0;
-	for (auto &pipeline : pipelines) {
-		ProgressData p;
-		if (!pipeline->GetProgress(p)) {
-			count_invalid++;
-		} else {
-			progress.Add(p);
-		}
-	}
-	return count_invalid;
-} // LCOV_EXCL_STOP
-
-bool Executor::HasResultCollector() {
-	return physical_plan->type == PhysicalOperatorType::RESULT_COLLECTOR;
-}
-
-bool Executor::HasStreamingResultCollector() {
-	if (!HasResultCollector()) {
-		return false;
-	}
-	auto &result_collector = physical_plan->Cast<PhysicalResultCollector>();
-	return result_collector.IsStreaming();
-}
-
-unique_ptr<QueryResult> Executor::GetResult() {
-	D_ASSERT(HasResultCollector());
-	auto &result_collector = physical_plan->Cast<PhysicalResultCollector>();
-	D_ASSERT(result_collector.sink_state);
-	return result_collector.GetResult(*result_collector.sink_state);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/executor_task.cpp b/src/duckdb/src/parallel/executor_task.cpp
deleted file mode 100644
index ebd462f93..000000000
--- a/src/duckdb/src/parallel/executor_task.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/parallel/task.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/thread_context.hpp"
-
-namespace duckdb {
-
-ExecutorTask::ExecutorTask(Executor &executor_p, shared_ptr<Event> event_p)
-    : executor(executor_p), event(std::move(event_p)) {
-	executor.RegisterTask();
-}
-
-ExecutorTask::ExecutorTask(ClientContext &context, shared_ptr<Event> event_p, const PhysicalOperator &op_p)
-    : executor(Executor::Get(context)), event(std::move(event_p)), op(&op_p) {
-	thread_context = make_uniq<ThreadContext>(context);
-	executor.RegisterTask();
-}
-
-ExecutorTask::~ExecutorTask() {
-	if (thread_context) {
-		executor.Flush(*thread_context);
-	}
-	executor.UnregisterTask();
-}
-
-void ExecutorTask::Deschedule() {
-	auto this_ptr = shared_from_this();
-	executor.AddToBeRescheduled(this_ptr);
-}
-
-void ExecutorTask::Reschedule() {
-	auto this_ptr = shared_from_this();
-	executor.RescheduleTask(this_ptr);
-}
-
-TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
-	try {
-		if (thread_context) {
-			TaskExecutionResult result;
-			do {
-				thread_context->profiler.StartOperator(op);
-				// to allow continuous profiling, always execute in small steps
-				result = ExecuteTask(TaskExecutionMode::PROCESS_PARTIAL);
-				thread_context->profiler.EndOperator(nullptr);
-				executor.Flush(*thread_context);
-			} while (mode == TaskExecutionMode::PROCESS_ALL && result == TaskExecutionResult::TASK_NOT_FINISHED);
-			return result;
-		} else {
-			return ExecuteTask(mode);
-		}
-	} catch (std::exception &ex) {
-		executor.PushError(ErrorData(ex));
-	} catch (...) { // LCOV_EXCL_START
-		executor.PushError(ErrorData("Unknown exception in Finalize!"));
-	} // LCOV_EXCL_STOP
-	return TaskExecutionResult::TASK_ERROR;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/interrupt.cpp b/src/duckdb/src/parallel/interrupt.cpp
deleted file mode 100644
index 45948c41a..000000000
--- a/src/duckdb/src/parallel/interrupt.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/mutex.hpp"
-#include <condition_variable>
-
-namespace duckdb {
-
-InterruptState::InterruptState() : mode(InterruptMode::NO_INTERRUPTS) {
-}
-InterruptState::InterruptState(weak_ptr<Task> task) : mode(InterruptMode::TASK), current_task(std::move(task)) {
-}
-InterruptState::InterruptState(weak_ptr<InterruptDoneSignalState> signal_state_p)
-    : mode(InterruptMode::BLOCKING), signal_state(std::move(signal_state_p)) {
-}
-
-void InterruptState::Callback() const {
-	if (mode == InterruptMode::TASK) {
-		auto task = current_task.lock();
-
-		if (!task) {
-			return;
-		}
-
-		task->Reschedule();
-	} else if (mode == InterruptMode::BLOCKING) {
-		auto signal_state_l = signal_state.lock();
-
-		if (!signal_state_l) {
-			return;
-		}
-
-		// Signal the caller, who is currently blocked
-		signal_state_l->Signal();
-	} else {
-		throw InternalException("Callback made on InterruptState without valid interrupt mode specified");
-	}
-}
-
-void InterruptDoneSignalState::Signal() {
-	{
-		unique_lock<mutex> lck {lock};
-		done = true;
-	}
-	cv.notify_all();
-}
-
-void InterruptDoneSignalState::Await() {
-	std::unique_lock<std::mutex> lck(lock);
-	cv.wait(lck, [&]() { return done; });
-
-	// Reset after signal received
-	done = false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/meta_pipeline.cpp b/src/duckdb/src/parallel/meta_pipeline.cpp
deleted file mode 100644
index 0bd0a6f53..000000000
--- a/src/duckdb/src/parallel/meta_pipeline.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-#include "duckdb/parallel/meta_pipeline.hpp"
-
-#include "duckdb/execution/executor.hpp"
-
-namespace duckdb {
-
-MetaPipeline::MetaPipeline(Executor &executor_p, PipelineBuildState &state_p, optional_ptr<PhysicalOperator> sink_p,
-                           MetaPipelineType type_p)
-    : executor(executor_p), state(state_p), sink(sink_p), type(type_p), recursive_cte(false), next_batch_index(0) {
-	CreatePipeline();
-}
-
-Executor &MetaPipeline::GetExecutor() const {
-	return executor;
-}
-
-PipelineBuildState &MetaPipeline::GetState() const {
-	return state;
-}
-
-optional_ptr<PhysicalOperator> MetaPipeline::GetSink() const {
-	return sink;
-}
-
-optional_ptr<Pipeline> MetaPipeline::GetParent() const {
-	return parent;
-}
-
-shared_ptr<Pipeline> &MetaPipeline::GetBasePipeline() {
-	return pipelines[0];
-}
-
-void MetaPipeline::GetPipelines(vector<shared_ptr<Pipeline>> &result, bool recursive) {
-	result.insert(result.end(), pipelines.begin(), pipelines.end());
-	if (recursive) {
-		for (auto &child : children) {
-			child->GetPipelines(result, true);
-		}
-	}
-}
-
-void MetaPipeline::GetMetaPipelines(vector<shared_ptr<MetaPipeline>> &result, bool recursive, bool skip) {
-	if (!skip) {
-		result.push_back(shared_from_this());
-	}
-	for (auto &child : children) {
-		result.push_back(child);
-		if (recursive) {
-			child->GetMetaPipelines(result, true, true);
-		}
-	}
-}
-
-MetaPipeline &MetaPipeline::GetLastChild() {
-	if (children.empty()) {
-		return *this;
-	}
-	reference<const vector<shared_ptr<MetaPipeline>>> current_children = children;
-	while (!current_children.get().back()->children.empty()) {
-		current_children = current_children.get().back()->children;
-	}
-	return *current_children.get().back();
-}
-
-const reference_map_t<Pipeline, vector<reference<Pipeline>>> &MetaPipeline::GetDependencies() const {
-	return pipeline_dependencies;
-}
-
-MetaPipelineType MetaPipeline::Type() const {
-	return type;
-}
-
-bool MetaPipeline::HasRecursiveCTE() const {
-	return recursive_cte;
-}
-
-void MetaPipeline::SetRecursiveCTE() {
-	recursive_cte = true;
-}
-
-void MetaPipeline::AssignNextBatchIndex(Pipeline &pipeline) {
-	pipeline.base_batch_index = next_batch_index++ * PipelineBuildState::BATCH_INCREMENT;
-}
-
-void MetaPipeline::Build(PhysicalOperator &op) {
-	D_ASSERT(pipelines.size() == 1);
-	D_ASSERT(children.empty());
-	op.BuildPipelines(*pipelines.back(), *this);
-}
-
-void MetaPipeline::Ready() const {
-	for (auto &pipeline : pipelines) {
-		pipeline->Ready();
-	}
-	for (auto &child : children) {
-		child->Ready();
-	}
-}
-
-MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op, MetaPipelineType type) {
-	children.push_back(make_shared_ptr<MetaPipeline>(executor, state, &op, type));
-	auto &child_meta_pipeline = *children.back().get();
-	// store the parent
-	child_meta_pipeline.parent = &current;
-	// child MetaPipeline must finish completely before this MetaPipeline can start
-	current.AddDependency(child_meta_pipeline.GetBasePipeline());
-	// child meta pipeline is part of the recursive CTE too
-	child_meta_pipeline.recursive_cte = recursive_cte;
-	return child_meta_pipeline;
-}
-
-Pipeline &MetaPipeline::CreatePipeline() {
-	pipelines.emplace_back(make_shared_ptr<Pipeline>(executor));
-	state.SetPipelineSink(*pipelines.back(), sink, next_batch_index++);
-	return *pipelines.back();
-}
-
-vector<shared_ptr<Pipeline>> MetaPipeline::AddDependenciesFrom(Pipeline &dependant, const Pipeline &start,
-                                                               const bool including) {
-	// find 'start'
-	auto it = pipelines.begin();
-	for (; !RefersToSameObject(**it, start); it++) {
-	}
-
-	if (!including) {
-		it++;
-	}
-
-	// collect pipelines that were created from then
-	vector<shared_ptr<Pipeline>> created_pipelines;
-	for (; it != pipelines.end(); it++) {
-		if (RefersToSameObject(**it, dependant)) {
-			// cannot depend on itself
-			continue;
-		}
-		created_pipelines.push_back(*it);
-	}
-
-	// add them to the dependencies
-	auto &explicit_deps = pipeline_dependencies[dependant];
-	for (auto &created_pipeline : created_pipelines) {
-		explicit_deps.push_back(*created_pipeline);
-	}
-
-	return created_pipelines;
-}
-
-static bool PipelineExceedsThreadCount(Pipeline &pipeline, const idx_t thread_count) {
-#ifdef DEBUG
-	// we always add the dependency in debug mode so that this is well-tested
-	return true;
-#else
-	return pipeline.GetSource()->EstimatedThreadCount() > thread_count;
-#endif
-}
-
-void MetaPipeline::AddRecursiveDependencies(const vector<shared_ptr<Pipeline>> &new_dependencies,
-                                            const MetaPipeline &last_child) {
-	if (recursive_cte) {
-		return; // let's not burn our fingers on this for now
-	}
-
-	vector<shared_ptr<MetaPipeline>> child_meta_pipelines;
-	this->GetMetaPipelines(child_meta_pipelines, true, false);
-
-	// find the meta pipeline that has the same sink as 'pipeline'
-	auto it = child_meta_pipelines.begin();
-	for (; !RefersToSameObject(last_child, **it); it++) {
-	}
-	D_ASSERT(it != child_meta_pipelines.end());
-
-	// skip over it
-	it++;
-
-	// we try to limit the performance impact of these dependencies on smaller workloads,
-	// by only adding the dependencies if the source operator can likely keep all threads busy
-	const auto thread_count = NumericCast<idx_t>(TaskScheduler::GetScheduler(executor.context).NumberOfThreads());
-	for (; it != child_meta_pipelines.end(); it++) {
-		for (auto &pipeline : it->get()->pipelines) {
-			if (!PipelineExceedsThreadCount(*pipeline, thread_count)) {
-				continue;
-			}
-			auto &pipeline_deps = pipeline_dependencies[*pipeline];
-			for (auto &new_dependency : new_dependencies) {
-				if (!PipelineExceedsThreadCount(*new_dependency, thread_count)) {
-					continue;
-				}
-				pipeline_deps.push_back(*new_dependency);
-			}
-		}
-	}
-}
-
-void MetaPipeline::AddFinishEvent(Pipeline &pipeline) {
-	D_ASSERT(finish_pipelines.find(pipeline) == finish_pipelines.end());
-	finish_pipelines.insert(pipeline);
-
-	// add all pipelines that were added since 'pipeline' was added (including 'pipeline') to the finish group
-	auto it = pipelines.begin();
-	for (; !RefersToSameObject(**it, pipeline); it++) {
-	}
-	it++;
-	for (; it != pipelines.end(); it++) {
-		finish_map.emplace(**it, pipeline);
-	}
-}
-
-bool MetaPipeline::HasFinishEvent(Pipeline &pipeline) const {
-	return finish_pipelines.find(pipeline) != finish_pipelines.end();
-}
-
-optional_ptr<Pipeline> MetaPipeline::GetFinishGroup(Pipeline &pipeline) const {
-	auto it = finish_map.find(pipeline);
-	return it == finish_map.end() ? nullptr : &it->second;
-}
-
-Pipeline &MetaPipeline::CreateUnionPipeline(Pipeline &current, bool order_matters) {
-	// create the union pipeline (batch index 0, should be set correctly afterwards)
-	auto &union_pipeline = CreatePipeline();
-	state.SetPipelineOperators(union_pipeline, state.GetPipelineOperators(current));
-	state.SetPipelineSink(union_pipeline, sink, 0);
-
-	// 'union_pipeline' inherits ALL dependencies of 'current' (within this MetaPipeline, and across MetaPipelines)
-	union_pipeline.dependencies = current.dependencies;
-	auto it = pipeline_dependencies.find(current);
-	if (it != pipeline_dependencies.end()) {
-		pipeline_dependencies[union_pipeline] = it->second;
-	}
-
-	if (order_matters) {
-		// if we need to preserve order, or if the sink is not parallel, we set a dependency
-		pipeline_dependencies[union_pipeline].push_back(current);
-	}
-
-	return union_pipeline;
-}
-
-void MetaPipeline::CreateChildPipeline(Pipeline &current, PhysicalOperator &op, Pipeline &last_pipeline) {
-	// rule 2: 'current' must be fully built (down to the source) before creating the child pipeline
-	D_ASSERT(current.source);
-
-	// create the child pipeline (same batch index)
-	pipelines.emplace_back(state.CreateChildPipeline(executor, current, op));
-	auto &child_pipeline = *pipelines.back();
-	child_pipeline.base_batch_index = current.base_batch_index;
-
-	// child pipeline has a dependency (within this MetaPipeline on all pipelines that were scheduled
-	// between 'current' and now (including 'current') - set them up
-	pipeline_dependencies[child_pipeline].push_back(current);
-	AddDependenciesFrom(child_pipeline, last_pipeline, false);
-	D_ASSERT(pipeline_dependencies.find(child_pipeline) != pipeline_dependencies.end());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline.cpp b/src/duckdb/src/parallel/pipeline.cpp
deleted file mode 100644
index 4e15068fb..000000000
--- a/src/duckdb/src/parallel/pipeline.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-#include "duckdb/parallel/pipeline.hpp"
-
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/tree_renderer/text_tree_renderer.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parallel/pipeline_event.hpp"
-#include "duckdb/parallel/pipeline_executor.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-
-namespace duckdb {
-
-PipelineTask::PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-    : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) {
-}
-
-bool PipelineTask::TaskBlockedOnResult() const {
-	// If this returns true, it means the pipeline this task belongs to has a cached chunk
-	// that was the result of the Sink method returning BLOCKED
-	return pipeline_executor->RemainingSinkChunk();
-}
-
-const PipelineExecutor &PipelineTask::GetPipelineExecutor() const {
-	return *pipeline_executor;
-}
-
-TaskExecutionResult PipelineTask::ExecuteTask(TaskExecutionMode mode) {
-	if (!pipeline_executor) {
-		pipeline_executor = make_uniq<PipelineExecutor>(pipeline.GetClientContext(), pipeline);
-	}
-
-	pipeline_executor->SetTaskForInterrupts(shared_from_this());
-
-	if (mode == TaskExecutionMode::PROCESS_PARTIAL) {
-		auto res = pipeline_executor->Execute(PARTIAL_CHUNK_COUNT);
-
-		switch (res) {
-		case PipelineExecuteResult::NOT_FINISHED:
-			return TaskExecutionResult::TASK_NOT_FINISHED;
-		case PipelineExecuteResult::INTERRUPTED:
-			return TaskExecutionResult::TASK_BLOCKED;
-		case PipelineExecuteResult::FINISHED:
-			break;
-		}
-	} else {
-		auto res = pipeline_executor->Execute();
-		switch (res) {
-		case PipelineExecuteResult::NOT_FINISHED:
-			throw InternalException("Execute without limit should not return NOT_FINISHED");
-		case PipelineExecuteResult::INTERRUPTED:
-			return TaskExecutionResult::TASK_BLOCKED;
-		case PipelineExecuteResult::FINISHED:
-			break;
-		}
-	}
-
-	event->FinishTask();
-	pipeline_executor.reset();
-	return TaskExecutionResult::TASK_FINISHED;
-}
-
-Pipeline::Pipeline(Executor &executor_p)
-    : executor(executor_p), ready(false), initialized(false), source(nullptr), sink(nullptr) {
-}
-
-ClientContext &Pipeline::GetClientContext() {
-	return executor.context;
-}
-
-bool Pipeline::GetProgress(ProgressData &progress) {
-	D_ASSERT(source);
-	idx_t source_cardinality = MinValue<idx_t>(source->estimated_cardinality, 1ULL << 48ULL);
-	if (source_cardinality < 1) {
-		source_cardinality = 1;
-	}
-	if (!initialized) {
-		progress.done = 0;
-		progress.total = double(source_cardinality);
-		return true;
-	}
-	auto &client = executor.context;
-
-	progress = source->GetProgress(client, *source_state);
-	progress.Normalize(double(source_cardinality));
-	progress = sink->GetSinkProgress(client, *sink->sink_state, progress);
-	return progress.IsValid();
-}
-
-void Pipeline::ScheduleSequentialTask(shared_ptr<Event> &event) {
-	vector<shared_ptr<Task>> tasks;
-	tasks.push_back(make_uniq<PipelineTask>(*this, event));
-	event->SetTasks(std::move(tasks));
-}
-
-bool Pipeline::ScheduleParallel(shared_ptr<Event> &event) {
-	// check if the sink, source and all intermediate operators support parallelism
-	if (!sink->ParallelSink()) {
-		return false;
-	}
-	if (!source->ParallelSource()) {
-		return false;
-	}
-	for (auto &op_ref : operators) {
-		auto &op = op_ref.get();
-		if (!op.ParallelOperator()) {
-			return false;
-		}
-	}
-	auto partition_info = sink->RequiredPartitionInfo();
-	if (partition_info.batch_index) {
-		if (!source->SupportsPartitioning(OperatorPartitionInfo::BatchIndex())) {
-			throw InternalException(
-			    "Attempting to schedule a pipeline where the sink requires batch index but source does not support it");
-		}
-	}
-	auto max_threads = source_state->MaxThreads();
-	auto &scheduler = TaskScheduler::GetScheduler(executor.context);
-	auto active_threads = NumericCast<idx_t>(scheduler.NumberOfThreads());
-	if (max_threads > active_threads) {
-		max_threads = active_threads;
-	}
-	if (sink && sink->sink_state) {
-		max_threads = sink->sink_state->MaxThreads(max_threads);
-	}
-	if (max_threads > active_threads) {
-		max_threads = active_threads;
-	}
-	return LaunchScanTasks(event, max_threads);
-}
-
-bool Pipeline::IsOrderDependent() const {
-	auto &config = DBConfig::GetConfig(executor.context);
-	if (source) {
-		auto source_order = source->SourceOrder();
-		if (source_order == OrderPreservationType::FIXED_ORDER) {
-			return true;
-		}
-		if (source_order == OrderPreservationType::NO_ORDER) {
-			return false;
-		}
-	}
-	for (auto &op_ref : operators) {
-		auto &op = op_ref.get();
-		if (op.OperatorOrder() == OrderPreservationType::NO_ORDER) {
-			return false;
-		}
-		if (op.OperatorOrder() == OrderPreservationType::FIXED_ORDER) {
-			return true;
-		}
-	}
-	if (!config.options.preserve_insertion_order) {
-		return false;
-	}
-	if (sink && sink->SinkOrderDependent()) {
-		return true;
-	}
-	return false;
-}
-
-void Pipeline::Schedule(shared_ptr<Event> &event) {
-	D_ASSERT(ready);
-	D_ASSERT(sink);
-	Reset();
-	if (!ScheduleParallel(event)) {
-		// could not parallelize this pipeline: push a sequential task instead
-		ScheduleSequentialTask(event);
-	}
-}
-
-bool Pipeline::LaunchScanTasks(shared_ptr<Event> &event, idx_t max_threads) {
-	// split the scan up into parts and schedule the parts
-	if (max_threads <= 1) {
-		// too small to parallelize
-		return false;
-	}
-
-	// launch a task for every thread
-	vector<shared_ptr<Task>> tasks;
-	for (idx_t i = 0; i < max_threads; i++) {
-		tasks.push_back(make_uniq<PipelineTask>(*this, event));
-	}
-	event->SetTasks(std::move(tasks));
-	return true;
-}
-
-void Pipeline::ResetSink() {
-	if (sink) {
-		if (!sink->IsSink()) {
-			throw InternalException("Sink of pipeline does not have IsSink set");
-		}
-		lock_guard<mutex> guard(sink->lock);
-		if (!sink->sink_state) {
-			sink->sink_state = sink->GetGlobalSinkState(GetClientContext());
-		}
-	}
-}
-
-void Pipeline::PrepareFinalize() {
-	if (sink) {
-		if (!sink->IsSink()) {
-			throw InternalException("Sink of pipeline does not have IsSink set");
-		}
-		lock_guard<mutex> guard(sink->lock);
-		if (!sink->sink_state) {
-			throw InternalException("Sink of pipeline does not have sink state");
-		}
-		sink->PrepareFinalize(GetClientContext(), *sink->sink_state);
-	}
-}
-
-void Pipeline::Reset() {
-	ResetSink();
-	for (auto &op_ref : operators) {
-		auto &op = op_ref.get();
-		lock_guard<mutex> guard(op.lock);
-		if (!op.op_state) {
-			op.op_state = op.GetGlobalOperatorState(GetClientContext());
-		}
-	}
-	ResetSource(false);
-	// we no longer reset source here because this function is no longer guaranteed to be called by the main thread
-	// source reset needs to be called by the main thread because resetting a source may call into clients like R
-	initialized = true;
-}
-
-void Pipeline::ResetSource(bool force) {
-	if (source && !source->IsSource()) {
-		throw InternalException("Source of pipeline does not have IsSource set");
-	}
-	if (force || !source_state) {
-		source_state = source->GetGlobalSourceState(GetClientContext());
-	}
-}
-
-void Pipeline::Ready() {
-	if (ready) {
-		return;
-	}
-	ready = true;
-	std::reverse(operators.begin(), operators.end());
-}
-
-void Pipeline::AddDependency(shared_ptr<Pipeline> &pipeline) {
-	D_ASSERT(pipeline);
-	dependencies.push_back(weak_ptr<Pipeline>(pipeline));
-	pipeline->parents.push_back(weak_ptr<Pipeline>(shared_from_this()));
-}
-
-string Pipeline::ToString() const {
-	TextTreeRenderer renderer;
-	return renderer.ToString(*this);
-}
-
-void Pipeline::Print() const {
-	Printer::Print(ToString());
-}
-
-void Pipeline::PrintDependencies() const {
-	for (auto &dep : dependencies) {
-		shared_ptr<Pipeline>(dep)->Print();
-	}
-}
-
-vector<reference<PhysicalOperator>> Pipeline::GetOperators() {
-	vector<reference<PhysicalOperator>> result;
-	D_ASSERT(source);
-	result.push_back(*source);
-	for (auto &op : operators) {
-		result.push_back(op.get());
-	}
-	if (sink) {
-		result.push_back(*sink);
-	}
-	return result;
-}
-
-vector<const_reference<PhysicalOperator>> Pipeline::GetOperators() const {
-	vector<const_reference<PhysicalOperator>> result;
-	D_ASSERT(source);
-	result.push_back(*source);
-	for (auto &op : operators) {
-		result.push_back(op.get());
-	}
-	if (sink) {
-		result.push_back(*sink);
-	}
-	return result;
-}
-
-void Pipeline::ClearSource() {
-	source_state.reset();
-	batch_indexes.clear();
-}
-
-idx_t Pipeline::RegisterNewBatchIndex() {
-	lock_guard<mutex> l(batch_lock);
-	idx_t minimum = batch_indexes.empty() ? base_batch_index : *batch_indexes.begin();
-	batch_indexes.insert(minimum);
-	return minimum;
-}
-
-idx_t Pipeline::UpdateBatchIndex(idx_t old_index, idx_t new_index) {
-	lock_guard<mutex> l(batch_lock);
-	if (new_index < *batch_indexes.begin()) {
-		throw InternalException("Processing batch index %llu, but previous min batch index was %llu", new_index,
-		                        *batch_indexes.begin());
-	}
-	auto entry = batch_indexes.find(old_index);
-	if (entry == batch_indexes.end()) {
-		throw InternalException("Batch index %llu was not found in set of active batch indexes", old_index);
-	}
-	batch_indexes.erase(entry);
-	batch_indexes.insert(new_index);
-	return *batch_indexes.begin();
-}
-//===--------------------------------------------------------------------===//
-// Pipeline Build State
-//===--------------------------------------------------------------------===//
-void PipelineBuildState::SetPipelineSource(Pipeline &pipeline, PhysicalOperator &op) {
-	pipeline.source = &op;
-}
-
-void PipelineBuildState::SetPipelineSink(Pipeline &pipeline, optional_ptr<PhysicalOperator> op,
-                                         idx_t sink_pipeline_count) {
-	pipeline.sink = op;
-	// set the base batch index of this pipeline based on how many other pipelines have this node as their sink
-	pipeline.base_batch_index = BATCH_INCREMENT * sink_pipeline_count;
-}
-
-void PipelineBuildState::AddPipelineOperator(Pipeline &pipeline, PhysicalOperator &op) {
-	pipeline.operators.push_back(op);
-}
-
-optional_ptr<PhysicalOperator> PipelineBuildState::GetPipelineSource(Pipeline &pipeline) {
-	return pipeline.source;
-}
-
-optional_ptr<PhysicalOperator> PipelineBuildState::GetPipelineSink(Pipeline &pipeline) {
-	return pipeline.sink;
-}
-
-void PipelineBuildState::SetPipelineOperators(Pipeline &pipeline, vector<reference<PhysicalOperator>> operators) {
-	pipeline.operators = std::move(operators);
-}
-
-shared_ptr<Pipeline> PipelineBuildState::CreateChildPipeline(Executor &executor, Pipeline &pipeline,
-                                                             PhysicalOperator &op) {
-	return executor.CreateChildPipeline(pipeline, op);
-}
-
-vector<reference<PhysicalOperator>> PipelineBuildState::GetPipelineOperators(Pipeline &pipeline) {
-	return pipeline.operators;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline_complete_event.cpp b/src/duckdb/src/parallel/pipeline_complete_event.cpp
deleted file mode 100644
index 85e5ac63b..000000000
--- a/src/duckdb/src/parallel/pipeline_complete_event.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parallel/pipeline_complete_event.hpp"
-#include "duckdb/execution/executor.hpp"
-
-namespace duckdb {
-
-PipelineCompleteEvent::PipelineCompleteEvent(Executor &executor, bool complete_pipeline_p)
-    : Event(executor), complete_pipeline(complete_pipeline_p) {
-}
-
-void PipelineCompleteEvent::Schedule() {
-}
-
-void PipelineCompleteEvent::FinalizeFinish() {
-	if (complete_pipeline) {
-		executor.CompletePipeline();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline_event.cpp b/src/duckdb/src/parallel/pipeline_event.cpp
deleted file mode 100644
index aaa84a3a2..000000000
--- a/src/duckdb/src/parallel/pipeline_event.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/parallel/pipeline_event.hpp"
-#include "duckdb/execution/executor.hpp"
-
-namespace duckdb {
-
-PipelineEvent::PipelineEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(std::move(pipeline_p)) {
-}
-
-void PipelineEvent::Schedule() {
-	auto event = shared_from_this();
-	auto &executor = pipeline->executor;
-	try {
-		pipeline->Schedule(event);
-		D_ASSERT(total_tasks > 0);
-	} catch (std::exception &ex) {
-		executor.PushError(ErrorData(ex));
-	} catch (...) { // LCOV_EXCL_START
-		executor.PushError(ErrorData("Unknown exception in Finalize!"));
-	} // LCOV_EXCL_STOP
-}
-
-void PipelineEvent::FinishEvent() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline_executor.cpp b/src/duckdb/src/parallel/pipeline_executor.cpp
deleted file mode 100644
index 4b32c99d9..000000000
--- a/src/duckdb/src/parallel/pipeline_executor.cpp
+++ /dev/null
@@ -1,558 +0,0 @@
-#include "duckdb/parallel/pipeline_executor.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/main/client_context.hpp"
-
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-#include <chrono>
-#include <thread>
-#endif
-
-namespace duckdb {
-
-PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_p)
-    : pipeline(pipeline_p), thread(context_p), context(context_p, thread, &pipeline_p) {
-	D_ASSERT(pipeline.source_state);
-	if (pipeline.sink) {
-		local_sink_state = pipeline.sink->GetLocalSinkState(context);
-		required_partition_info = pipeline.sink->RequiredPartitionInfo();
-		if (required_partition_info.AnyRequired()) {
-			D_ASSERT(pipeline.source->SupportsPartitioning(OperatorPartitionInfo::BatchIndex()));
-			auto &partition_info = local_sink_state->partition_info;
-			D_ASSERT(!partition_info.batch_index.IsValid());
-			// batch index is not set yet - initialize before fetching anything
-			partition_info.batch_index = pipeline.RegisterNewBatchIndex();
-			partition_info.min_batch_index = partition_info.batch_index;
-		}
-	}
-	local_source_state = pipeline.source->GetLocalSourceState(context, *pipeline.source_state);
-
-	intermediate_chunks.reserve(pipeline.operators.size());
-	intermediate_states.reserve(pipeline.operators.size());
-	for (idx_t i = 0; i < pipeline.operators.size(); i++) {
-		auto &prev_operator = i == 0 ? *pipeline.source : pipeline.operators[i - 1].get();
-		auto &current_operator = pipeline.operators[i].get();
-
-		auto chunk = make_uniq<DataChunk>();
-		chunk->Initialize(Allocator::Get(context.client), prev_operator.GetTypes());
-		intermediate_chunks.push_back(std::move(chunk));
-
-		auto op_state = current_operator.GetOperatorState(context);
-		intermediate_states.push_back(std::move(op_state));
-
-		if (current_operator.IsSink() && current_operator.sink_state->state == SinkFinalizeType::NO_OUTPUT_POSSIBLE) {
-			// one of the operators has already figured out no output is possible
-			// we can skip executing the pipeline
-			FinishProcessing();
-		}
-	}
-	InitializeChunk(final_chunk);
-}
-
-bool PipelineExecutor::TryFlushCachingOperators(ExecutionBudget &chunk_budget) {
-	if (!started_flushing) {
-		// Remainder of this method assumes any in process operators are from flushing
-		D_ASSERT(in_process_operators.empty());
-		started_flushing = true;
-		flushing_idx = IsFinished() ? idx_t(finished_processing_idx) : 0;
-	}
-
-	// For each operator that supports FinalExecute,
-	// extract every chunk from it and push it through the rest of the pipeline
-	// before moving onto the next operators' FinalExecute
-	while (flushing_idx < pipeline.operators.size()) {
-		if (!pipeline.operators[flushing_idx].get().RequiresFinalExecute()) {
-			flushing_idx++;
-			continue;
-		}
-
-		// This slightly awkward way of increasing the flushing idx is to make the code re-entrant: We need to call this
-		// method again in the case of a Sink returning BLOCKED.
-		if (!should_flush_current_idx && in_process_operators.empty()) {
-			should_flush_current_idx = true;
-			flushing_idx++;
-			continue;
-		}
-
-		auto &curr_chunk =
-		    flushing_idx + 1 >= intermediate_chunks.size() ? final_chunk : *intermediate_chunks[flushing_idx + 1];
-		auto &current_operator = pipeline.operators[flushing_idx].get();
-
-		OperatorFinalizeResultType finalize_result;
-
-		if (in_process_operators.empty()) {
-			curr_chunk.Reset();
-			StartOperator(current_operator);
-			finalize_result = current_operator.FinalExecute(context, curr_chunk, *current_operator.op_state,
-			                                                *intermediate_states[flushing_idx]);
-			EndOperator(current_operator, &curr_chunk);
-		} else {
-			// Reset flag and reflush the last chunk we were flushing.
-			finalize_result = OperatorFinalizeResultType::HAVE_MORE_OUTPUT;
-		}
-
-		auto push_result = ExecutePushInternal(curr_chunk, chunk_budget, flushing_idx + 1);
-
-		if (finalize_result == OperatorFinalizeResultType::HAVE_MORE_OUTPUT) {
-			should_flush_current_idx = true;
-		} else {
-			should_flush_current_idx = false;
-		}
-
-		switch (push_result) {
-		case OperatorResultType::BLOCKED: {
-			remaining_sink_chunk = true;
-			return false;
-		}
-		case OperatorResultType::HAVE_MORE_OUTPUT: {
-			D_ASSERT(chunk_budget.IsDepleted());
-			// The chunk budget was used up, pushing the chunk through the pipeline created more chunks
-			// we need to continue this the next time Execute is called.
-			return false;
-		}
-		case OperatorResultType::NEED_MORE_INPUT:
-			continue;
-		case OperatorResultType::FINISHED:
-			break;
-		default:
-			throw InternalException("Unexpected OperatorResultType (%s) in TryFlushCachingOperators",
-			                        EnumUtil::ToString(push_result));
-		}
-		break;
-	}
-	return true;
-}
-
-SinkNextBatchType PipelineExecutor::NextBatch(DataChunk &source_chunk) {
-	D_ASSERT(required_partition_info.AnyRequired());
-	auto max_batch_index = pipeline.base_batch_index + PipelineBuildState::BATCH_INCREMENT - 1;
-	// by default set it to the maximum valid batch index value for the current pipeline
-	OperatorPartitionData next_data(max_batch_index);
-	if (source_chunk.size() > 0) {
-		// if we retrieved data - initialize the next batch index
-		auto partition_data = pipeline.source->GetPartitionData(context, source_chunk, *pipeline.source_state,
-		                                                        *local_source_state, required_partition_info);
-		auto batch_index = partition_data.batch_index;
-		// we start with the base_batch_index as a valid starting value. Make sure that next batch is called below
-		next_data = std::move(partition_data);
-		next_data.batch_index = pipeline.base_batch_index + batch_index + 1;
-		if (next_data.batch_index >= max_batch_index) {
-			throw InternalException("Pipeline batch index - invalid batch index %llu returned by source operator",
-			                        batch_index);
-		}
-	}
-	auto &partition_info = local_sink_state->partition_info;
-	if (next_data.batch_index == partition_info.batch_index.GetIndex()) {
-		// no changes, return
-		return SinkNextBatchType::READY;
-	}
-	// batch index has changed - update it
-	if (partition_info.batch_index.GetIndex() > next_data.batch_index) {
-		throw InternalException(
-		    "Pipeline batch index - gotten lower batch index %llu (down from previous batch index of %llu)",
-		    next_data.batch_index, partition_info.batch_index.GetIndex());
-	}
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	if (debug_blocked_next_batch_count < debug_blocked_target_count) {
-		debug_blocked_next_batch_count++;
-
-		auto &callback_state = interrupt_state;
-		std::thread rewake_thread([callback_state] {
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-			callback_state.Callback();
-		});
-		rewake_thread.detach();
-
-		return SinkNextBatchType::BLOCKED;
-	}
-#endif
-	auto current_batch = partition_info.batch_index.GetIndex();
-	partition_info.batch_index = next_data.batch_index;
-	partition_info.partition_data = std::move(next_data.partition_data);
-	OperatorSinkNextBatchInput next_batch_input {*pipeline.sink->sink_state, *local_sink_state, interrupt_state};
-	// call NextBatch before updating min_batch_index to provide the opportunity to flush the previous batch
-	auto next_batch_result = pipeline.sink->NextBatch(context, next_batch_input);
-
-	if (next_batch_result == SinkNextBatchType::BLOCKED) {
-		partition_info.batch_index = current_batch; // set batch_index back to what it was before
-		return SinkNextBatchType::BLOCKED;
-	}
-
-	partition_info.min_batch_index = pipeline.UpdateBatchIndex(current_batch, next_data.batch_index);
-
-	return SinkNextBatchType::READY;
-}
-
-PipelineExecuteResult PipelineExecutor::Execute(idx_t max_chunks) {
-	D_ASSERT(pipeline.sink);
-	auto &source_chunk = pipeline.operators.empty() ? final_chunk : *intermediate_chunks[0];
-	ExecutionBudget chunk_budget(max_chunks);
-	do {
-		if (context.client.interrupted) {
-			throw InterruptException();
-		}
-
-		OperatorResultType result;
-		if (exhausted_source && done_flushing && !remaining_sink_chunk && !next_batch_blocked &&
-		    in_process_operators.empty()) {
-			break;
-		} else if (remaining_sink_chunk) {
-			// The pipeline was interrupted by the Sink. We should retry sinking the final chunk.
-			result = ExecutePushInternal(final_chunk, chunk_budget);
-			D_ASSERT(result != OperatorResultType::HAVE_MORE_OUTPUT);
-			remaining_sink_chunk = false;
-		} else if (!in_process_operators.empty() && !started_flushing) {
-			// Operator(s) in the pipeline have returned `HAVE_MORE_OUTPUT` in the last Execute call
-			// the operators have to be called with the same input chunk to produce the rest of the output
-			D_ASSERT(source_chunk.size() > 0);
-			result = ExecutePushInternal(source_chunk, chunk_budget);
-		} else if (exhausted_source && !next_batch_blocked && !done_flushing) {
-			// The source was exhausted, try flushing all operators
-			auto flush_completed = TryFlushCachingOperators(chunk_budget);
-			if (flush_completed) {
-				done_flushing = true;
-				break;
-			} else {
-				if (remaining_sink_chunk) {
-					return PipelineExecuteResult::INTERRUPTED;
-				} else {
-					D_ASSERT(chunk_budget.IsDepleted());
-					return PipelineExecuteResult::NOT_FINISHED;
-				}
-			}
-		} else if (!exhausted_source || next_batch_blocked) {
-			SourceResultType source_result;
-			if (!next_batch_blocked) {
-				// "Regular" path: fetch a chunk from the source and push it through the pipeline
-				source_chunk.Reset();
-				source_result = FetchFromSource(source_chunk);
-				if (source_result == SourceResultType::BLOCKED) {
-					return PipelineExecuteResult::INTERRUPTED;
-				}
-				if (source_result == SourceResultType::FINISHED) {
-					exhausted_source = true;
-				}
-			}
-
-			if (required_partition_info.AnyRequired()) {
-				auto next_batch_result = NextBatch(source_chunk);
-				next_batch_blocked = next_batch_result == SinkNextBatchType::BLOCKED;
-				if (next_batch_blocked) {
-					return PipelineExecuteResult::INTERRUPTED;
-				}
-			}
-
-			if (exhausted_source && source_chunk.size() == 0) {
-				// To ensure that we're not early-terminating the pipeline
-				continue;
-			}
-
-			result = ExecutePushInternal(source_chunk, chunk_budget);
-		} else {
-			throw InternalException("Unexpected state reached in pipeline executor");
-		}
-
-		// SINK INTERRUPT
-		if (result == OperatorResultType::BLOCKED) {
-			remaining_sink_chunk = true;
-			return PipelineExecuteResult::INTERRUPTED;
-		}
-
-		if (result == OperatorResultType::FINISHED) {
-			break;
-		}
-	} while (chunk_budget.Next());
-
-	if ((!exhausted_source || !done_flushing) && !IsFinished()) {
-		return PipelineExecuteResult::NOT_FINISHED;
-	}
-
-	return PushFinalize();
-}
-
-bool PipelineExecutor::RemainingSinkChunk() const {
-	return remaining_sink_chunk;
-}
-
-PipelineExecuteResult PipelineExecutor::Execute() {
-	return Execute(NumericLimits<idx_t>::Maximum());
-}
-
-void PipelineExecutor::FinishProcessing(int32_t operator_idx) {
-	finished_processing_idx = operator_idx < 0 ? NumericLimits<int32_t>::Maximum() : operator_idx;
-	in_process_operators = stack<idx_t>();
-
-	if (pipeline.GetSource()) {
-		auto guard = pipeline.source_state->Lock();
-		pipeline.source_state->PreventBlocking(guard);
-		pipeline.source_state->UnblockTasks(guard);
-	}
-	if (pipeline.GetSink()) {
-		auto guard = pipeline.GetSink()->sink_state->Lock();
-		pipeline.GetSink()->sink_state->PreventBlocking(guard);
-		pipeline.GetSink()->sink_state->UnblockTasks(guard);
-	}
-}
-
-bool PipelineExecutor::IsFinished() {
-	return finished_processing_idx >= 0;
-}
-
-OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, ExecutionBudget &chunk_budget,
-                                                         idx_t initial_idx) {
-	D_ASSERT(pipeline.sink);
-	if (input.size() == 0) { // LCOV_EXCL_START
-		return OperatorResultType::NEED_MORE_INPUT;
-	} // LCOV_EXCL_STOP
-
-	// this loop will continuously push the input chunk through the pipeline as long as:
-	// - the OperatorResultType for the Execute is HAVE_MORE_OUTPUT
-	// - the Sink doesn't block
-	// - the ExecutionBudget has not been depleted
-	OperatorResultType result = OperatorResultType::HAVE_MORE_OUTPUT;
-	do {
-		// Note: if input is the final_chunk, we don't do any executing, the chunk just needs to be sinked
-		if (&input != &final_chunk) {
-			final_chunk.Reset();
-			// Execute and put the result into 'final_chunk'
-			result = Execute(input, final_chunk, initial_idx);
-			if (result == OperatorResultType::FINISHED) {
-				return OperatorResultType::FINISHED;
-			}
-		} else {
-			result = OperatorResultType::NEED_MORE_INPUT;
-		}
-		auto &sink_chunk = final_chunk;
-		if (sink_chunk.size() > 0) {
-			StartOperator(*pipeline.sink);
-			D_ASSERT(pipeline.sink);
-			D_ASSERT(pipeline.sink->sink_state);
-			OperatorSinkInput sink_input {*pipeline.sink->sink_state, *local_sink_state, interrupt_state};
-
-			auto sink_result = Sink(sink_chunk, sink_input);
-
-			EndOperator(*pipeline.sink, nullptr);
-
-			if (sink_result == SinkResultType::BLOCKED) {
-				return OperatorResultType::BLOCKED;
-			} else if (sink_result == SinkResultType::FINISHED) {
-				FinishProcessing();
-				return OperatorResultType::FINISHED;
-			}
-		}
-		if (result == OperatorResultType::NEED_MORE_INPUT) {
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-	} while (chunk_budget.Next());
-	return result;
-}
-
-PipelineExecuteResult PipelineExecutor::PushFinalize() {
-	if (finalized) {
-		throw InternalException("Calling PushFinalize on a pipeline that has been finalized already");
-	}
-
-	D_ASSERT(local_sink_state);
-
-	// Run the combine for the sink
-	OperatorSinkCombineInput combine_input {*pipeline.sink->sink_state, *local_sink_state, interrupt_state};
-
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	if (debug_blocked_combine_count < debug_blocked_target_count) {
-		debug_blocked_combine_count++;
-
-		auto &callback_state = combine_input.interrupt_state;
-		std::thread rewake_thread([callback_state] {
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-			callback_state.Callback();
-		});
-		rewake_thread.detach();
-
-		return PipelineExecuteResult::INTERRUPTED;
-	}
-#endif
-	auto result = pipeline.sink->Combine(context, combine_input);
-
-	if (result == SinkCombineResultType::BLOCKED) {
-		return PipelineExecuteResult::INTERRUPTED;
-	}
-
-	finalized = true;
-	// flush all query profiler info
-	for (idx_t i = 0; i < intermediate_states.size(); i++) {
-		intermediate_states[i]->Finalize(pipeline.operators[i].get(), context);
-	}
-	pipeline.executor.Flush(thread);
-	local_sink_state.reset();
-
-	return PipelineExecuteResult::FINISHED;
-}
-
-void PipelineExecutor::GoToSource(idx_t &current_idx, idx_t initial_idx) {
-	// we go back to the first operator (the source)
-	current_idx = initial_idx;
-	if (!in_process_operators.empty()) {
-		// ... UNLESS there is an in process operator
-		// if there is an in-process operator, we start executing at the latest one
-		// for example, if we have a join operator that has tuples left, we first need to emit those tuples
-		current_idx = in_process_operators.top();
-		in_process_operators.pop();
-	}
-	D_ASSERT(current_idx >= initial_idx);
-}
-
-OperatorResultType PipelineExecutor::Execute(DataChunk &input, DataChunk &result, idx_t initial_idx) {
-	if (input.size() == 0) { // LCOV_EXCL_START
-		return OperatorResultType::NEED_MORE_INPUT;
-	} // LCOV_EXCL_STOP
-	D_ASSERT(!pipeline.operators.empty());
-
-	idx_t current_idx;
-	GoToSource(current_idx, initial_idx);
-	if (current_idx == initial_idx) {
-		current_idx++;
-	}
-	if (current_idx > pipeline.operators.size()) {
-		result.Reference(input);
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	while (true) {
-		if (context.client.interrupted) {
-			throw InterruptException();
-		}
-		// now figure out where to put the chunk
-		// if current_idx is the last possible index (>= operators.size()) we write to the result
-		// otherwise we write to an intermediate chunk
-		auto current_intermediate = current_idx;
-		auto &current_chunk =
-		    current_intermediate >= intermediate_chunks.size() ? result : *intermediate_chunks[current_intermediate];
-		current_chunk.Reset();
-		if (current_idx == initial_idx) {
-			// we went back to the source: we need more input
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			auto &prev_chunk =
-			    current_intermediate == initial_idx + 1 ? input : *intermediate_chunks[current_intermediate - 1];
-			auto operator_idx = current_idx - 1;
-			auto &current_operator = pipeline.operators[operator_idx].get();
-
-			// if current_idx > source_idx, we pass the previous operators' output through the Execute of the current
-			// operator
-			StartOperator(current_operator);
-			auto result = current_operator.Execute(context, prev_chunk, current_chunk, *current_operator.op_state,
-			                                       *intermediate_states[current_intermediate - 1]);
-			EndOperator(current_operator, &current_chunk);
-			if (result == OperatorResultType::HAVE_MORE_OUTPUT) {
-				// more data remains in this operator
-				// push in-process marker
-				in_process_operators.push(current_idx);
-			} else if (result == OperatorResultType::FINISHED) {
-				D_ASSERT(current_chunk.size() == 0);
-				FinishProcessing(NumericCast<int32_t>(current_idx));
-				return OperatorResultType::FINISHED;
-			}
-			current_chunk.Verify();
-		}
-
-		if (current_chunk.size() == 0) {
-			// no output from this operator!
-			if (current_idx == initial_idx) {
-				// if we got no output from the scan, we are done
-				break;
-			} else {
-				// if we got no output from an intermediate op
-				// we go back and try to pull data from the source again
-				GoToSource(current_idx, initial_idx);
-				continue;
-			}
-		} else {
-			// we got output! continue to the next operator
-			current_idx++;
-			if (current_idx > pipeline.operators.size()) {
-				// if we got output and are at the last operator, we are finished executing for this output chunk
-				// return the data and push it into the chunk
-				break;
-			}
-		}
-	}
-	return in_process_operators.empty() ? OperatorResultType::NEED_MORE_INPUT : OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-void PipelineExecutor::SetTaskForInterrupts(weak_ptr<Task> current_task) {
-	interrupt_state = InterruptState(std::move(current_task));
-}
-
-SourceResultType PipelineExecutor::GetData(DataChunk &chunk, OperatorSourceInput &input) {
-	//! Testing feature to enable async source on every operator
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	if (debug_blocked_source_count < debug_blocked_target_count) {
-		debug_blocked_source_count++;
-
-		auto &callback_state = input.interrupt_state;
-		std::thread rewake_thread([callback_state] {
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-			callback_state.Callback();
-		});
-		rewake_thread.detach();
-
-		return SourceResultType::BLOCKED;
-	}
-#endif
-
-	return pipeline.source->GetData(context, chunk, input);
-}
-
-SinkResultType PipelineExecutor::Sink(DataChunk &chunk, OperatorSinkInput &input) {
-	//! Testing feature to enable async sink on every operator
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	if (debug_blocked_sink_count < debug_blocked_target_count) {
-		debug_blocked_sink_count++;
-
-		auto &callback_state = input.interrupt_state;
-		std::thread rewake_thread([callback_state] {
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-			callback_state.Callback();
-		});
-		rewake_thread.detach();
-
-		return SinkResultType::BLOCKED;
-	}
-#endif
-	return pipeline.sink->Sink(context, chunk, input);
-}
-
-SourceResultType PipelineExecutor::FetchFromSource(DataChunk &result) {
-	StartOperator(*pipeline.source);
-
-	OperatorSourceInput source_input = {*pipeline.source_state, *local_source_state, interrupt_state};
-	auto res = GetData(result, source_input);
-
-	// Ensures Sinks only return empty results when Blocking or Finished
-	D_ASSERT(res != SourceResultType::BLOCKED || result.size() == 0);
-
-	EndOperator(*pipeline.source, &result);
-
-	return res;
-}
-
-void PipelineExecutor::InitializeChunk(DataChunk &chunk) {
-	auto &last_op = pipeline.operators.empty() ? *pipeline.source : pipeline.operators.back().get();
-	chunk.Initialize(Allocator::DefaultAllocator(), last_op.GetTypes());
-}
-
-void PipelineExecutor::StartOperator(PhysicalOperator &op) {
-	if (context.client.interrupted) {
-		throw InterruptException();
-	}
-	context.thread.profiler.StartOperator(&op);
-}
-
-void PipelineExecutor::EndOperator(PhysicalOperator &op, optional_ptr<DataChunk> chunk) {
-	context.thread.profiler.EndOperator(chunk);
-
-	if (chunk) {
-		chunk->Verify();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline_finish_event.cpp b/src/duckdb/src/parallel/pipeline_finish_event.cpp
deleted file mode 100644
index b933e7ead..000000000
--- a/src/duckdb/src/parallel/pipeline_finish_event.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "duckdb/parallel/pipeline_finish_event.hpp"
-#include "duckdb/execution/executor.hpp"
-#include "duckdb/parallel/interrupt.hpp"
-#include "duckdb/parallel/executor_task.hpp"
-
-namespace duckdb {
-
-//! The PipelineFinishTask calls Finalize on the sink. Note that this is a single-threaded operation, but is executed
-//! in a task to allow the Finalize call to block (e.g. for async I/O)
-class PipelineFinishTask : public ExecutorTask {
-public:
-	explicit PipelineFinishTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) {
-	}
-
-	Pipeline &pipeline;
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		auto sink = pipeline.GetSink();
-		InterruptState interrupt_state(shared_from_this());
-		OperatorSinkFinalizeInput finalize_input {*sink->sink_state, interrupt_state};
-
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-		if (debug_blocked_count < debug_blocked_target_count) {
-			debug_blocked_count++;
-
-			auto &callback_state = interrupt_state;
-			std::thread rewake_thread([callback_state] {
-				std::this_thread::sleep_for(std::chrono::milliseconds(1));
-				callback_state.Callback();
-			});
-			rewake_thread.detach();
-
-			return TaskExecutionResult::TASK_BLOCKED;
-		}
-#endif
-		auto sink_state = sink->Finalize(pipeline, *event, executor.context, finalize_input);
-
-		if (sink_state == SinkFinalizeType::BLOCKED) {
-			return TaskExecutionResult::TASK_BLOCKED;
-		}
-
-		sink->sink_state->state = sink_state;
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
-	//! Debugging state: number of times blocked
-	int debug_blocked_count = 0;
-	//! Number of times the Finalize will block before actually returning data
-	int debug_blocked_target_count = 1;
-#endif
-};
-
-PipelineFinishEvent::PipelineFinishEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(std::move(pipeline_p)) {
-}
-
-void PipelineFinishEvent::Schedule() {
-	vector<shared_ptr<Task>> tasks;
-	tasks.push_back(make_uniq<PipelineFinishTask>(*pipeline, shared_from_this()));
-	SetTasks(std::move(tasks));
-}
-
-void PipelineFinishEvent::FinishEvent() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline_initialize_event.cpp b/src/duckdb/src/parallel/pipeline_initialize_event.cpp
deleted file mode 100644
index 2d9e460d5..000000000
--- a/src/duckdb/src/parallel/pipeline_initialize_event.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/parallel/pipeline_initialize_event.hpp"
-
-#include "duckdb/execution/executor.hpp"
-
-namespace duckdb {
-
-PipelineInitializeEvent::PipelineInitializeEvent(shared_ptr<Pipeline> pipeline_p)
-    : BasePipelineEvent(std::move(pipeline_p)) {
-}
-
-class PipelineInitializeTask : public ExecutorTask {
-public:
-	explicit PipelineInitializeTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) {
-	}
-
-	Pipeline &pipeline;
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		pipeline.ResetSink();
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-};
-
-void PipelineInitializeEvent::Schedule() {
-	// needs to spawn a task to get the chain of tasks for the query plan going
-	vector<shared_ptr<Task>> tasks;
-	tasks.push_back(make_uniq<PipelineInitializeTask>(*pipeline, shared_from_this()));
-	SetTasks(std::move(tasks));
-}
-
-void PipelineInitializeEvent::FinishEvent() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/pipeline_prepare_finish_event.cpp b/src/duckdb/src/parallel/pipeline_prepare_finish_event.cpp
deleted file mode 100644
index 2cca2d11e..000000000
--- a/src/duckdb/src/parallel/pipeline_prepare_finish_event.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/parallel/pipeline_prepare_finish_event.hpp"
-
-namespace duckdb {
-
-PipelinePrepareFinishEvent::PipelinePrepareFinishEvent(shared_ptr<Pipeline> pipeline_p)
-    : BasePipelineEvent(std::move(pipeline_p)) {
-}
-
-class PipelinePreFinishTask : public ExecutorTask {
-public:
-	explicit PipelinePreFinishTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor, std::move(event_p)), pipeline(pipeline_p) {
-	}
-
-	Pipeline &pipeline;
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		pipeline.PrepareFinalize();
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-};
-
-void PipelinePrepareFinishEvent::Schedule() {
-	vector<shared_ptr<Task>> tasks;
-	tasks.push_back(make_uniq<PipelinePreFinishTask>(*pipeline, shared_from_this()));
-	SetTasks(std::move(tasks));
-}
-
-void PipelinePrepareFinishEvent::FinishEvent() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/task_executor.cpp b/src/duckdb/src/parallel/task_executor.cpp
deleted file mode 100644
index eef4d28ab..000000000
--- a/src/duckdb/src/parallel/task_executor.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/parallel/task_executor.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-
-namespace duckdb {
-
-TaskExecutor::TaskExecutor(TaskScheduler &scheduler)
-    : scheduler(scheduler), token(scheduler.CreateProducer()), completed_tasks(0), total_tasks(0) {
-}
-
-TaskExecutor::TaskExecutor(ClientContext &context) : TaskExecutor(TaskScheduler::GetScheduler(context)) {
-}
-
-TaskExecutor::~TaskExecutor() {
-}
-
-void TaskExecutor::PushError(ErrorData error) {
-	error_manager.PushError(std::move(error));
-}
-
-bool TaskExecutor::HasError() {
-	return error_manager.HasError();
-}
-
-void TaskExecutor::ThrowError() {
-	error_manager.ThrowException();
-}
-
-void TaskExecutor::ScheduleTask(unique_ptr<Task> task) {
-	++total_tasks;
-	scheduler.ScheduleTask(*token, std::move(task));
-}
-void TaskExecutor::FinishTask() {
-	++completed_tasks;
-}
-
-void TaskExecutor::WorkOnTasks() {
-	// repeatedly execute tasks until we are finished
-	shared_ptr<Task> task_from_producer;
-	while (scheduler.GetTaskFromProducer(*token, task_from_producer)) {
-		auto res = task_from_producer->Execute(TaskExecutionMode::PROCESS_ALL);
-		(void)res;
-		D_ASSERT(res != TaskExecutionResult::TASK_BLOCKED);
-		task_from_producer.reset();
-	}
-	// wait for all active tasks to finish
-	while (completed_tasks != total_tasks) {
-	}
-
-	// check if we ran into any errors while checkpointing
-	if (HasError()) {
-		// throw the error
-		ThrowError();
-	}
-}
-
-bool TaskExecutor::GetTask(shared_ptr<Task> &task) {
-	return scheduler.GetTaskFromProducer(*token, task);
-}
-
-BaseExecutorTask::BaseExecutorTask(TaskExecutor &executor) : executor(executor) {
-}
-
-TaskExecutionResult BaseExecutorTask::Execute(TaskExecutionMode mode) {
-	(void)mode;
-	D_ASSERT(mode == TaskExecutionMode::PROCESS_ALL);
-	if (executor.HasError()) {
-		// another task encountered an error - bailout
-		executor.FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-	try {
-		ExecuteTask();
-		executor.FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	} catch (std::exception &ex) {
-		executor.PushError(ErrorData(ex));
-	} catch (...) { // LCOV_EXCL_START
-		executor.PushError(ErrorData("Unknown exception during Checkpoint!"));
-	} // LCOV_EXCL_STOP
-	executor.FinishTask();
-	return TaskExecutionResult::TASK_ERROR;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/task_scheduler.cpp b/src/duckdb/src/parallel/task_scheduler.cpp
deleted file mode 100644
index fd6671a3e..000000000
--- a/src/duckdb/src/parallel/task_scheduler.cpp
+++ /dev/null
@@ -1,418 +0,0 @@
-#include "duckdb/parallel/task_scheduler.hpp"
-
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-
-#ifndef DUCKDB_NO_THREADS
-#include "concurrentqueue.h"
-#include "duckdb/common/thread.hpp"
-#include "lightweightsemaphore.h"
-
-#include <thread>
-#else
-#include <queue>
-#endif
-
-#if defined(_WIN32)
-#include <windows.h>
-#elif defined(__GNUC__)
-#include <sched.h>
-#include <unistd.h>
-#endif
-
-namespace duckdb {
-
-struct SchedulerThread {
-#ifndef DUCKDB_NO_THREADS
-	explicit SchedulerThread(unique_ptr<thread> thread_p) : internal_thread(std::move(thread_p)) {
-	}
-
-	unique_ptr<thread> internal_thread;
-#endif
-};
-
-#ifndef DUCKDB_NO_THREADS
-typedef duckdb_moodycamel::ConcurrentQueue<shared_ptr<Task>> concurrent_queue_t;
-typedef duckdb_moodycamel::LightweightSemaphore lightweight_semaphore_t;
-
-struct ConcurrentQueue {
-	concurrent_queue_t q;
-	lightweight_semaphore_t semaphore;
-
-	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
-	bool DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task);
-};
-
-struct QueueProducerToken {
-	explicit QueueProducerToken(ConcurrentQueue &queue) : queue_token(queue.q) {
-	}
-
-	duckdb_moodycamel::ProducerToken queue_token;
-};
-
-void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
-	lock_guard<mutex> producer_lock(token.producer_lock);
-	if (q.enqueue(token.token->queue_token, std::move(task))) {
-		semaphore.signal();
-	} else {
-		throw InternalException("Could not schedule task!");
-	}
-}
-
-bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
-	lock_guard<mutex> producer_lock(token.producer_lock);
-	return q.try_dequeue_from_producer(token.token->queue_token, task);
-}
-
-#else
-struct ConcurrentQueue {
-	reference_map_t<QueueProducerToken, std::queue<shared_ptr<Task>>> q;
-	mutex qlock;
-
-	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
-	bool DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task);
-};
-
-void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
-	lock_guard<mutex> lock(qlock);
-	q[std::ref(*token.token)].push(std::move(task));
-}
-
-bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
-	lock_guard<mutex> lock(qlock);
-	D_ASSERT(!q.empty());
-
-	const auto it = q.find(std::ref(*token.token));
-	if (it == q.end() || it->second.empty()) {
-		return false;
-	}
-
-	task = std::move(it->second.front());
-	it->second.pop();
-
-	return true;
-}
-
-struct QueueProducerToken {
-	explicit QueueProducerToken(ConcurrentQueue &queue) : queue(&queue) {
-	}
-
-	~QueueProducerToken() {
-		lock_guard<mutex> lock(queue->qlock);
-		queue->q.erase(*this);
-	}
-
-private:
-	ConcurrentQueue *queue;
-};
-#endif
-
-ProducerToken::ProducerToken(TaskScheduler &scheduler, unique_ptr<QueueProducerToken> token)
-    : scheduler(scheduler), token(std::move(token)) {
-}
-
-ProducerToken::~ProducerToken() {
-}
-
-TaskScheduler::TaskScheduler(DatabaseInstance &db)
-    : db(db), queue(make_uniq<ConcurrentQueue>()),
-      allocator_flush_threshold(db.config.options.allocator_flush_threshold),
-      allocator_background_threads(db.config.options.allocator_background_threads), requested_thread_count(0),
-      current_thread_count(1) {
-	SetAllocatorBackgroundThreads(db.config.options.allocator_background_threads);
-}
-
-TaskScheduler::~TaskScheduler() {
-#ifndef DUCKDB_NO_THREADS
-	try {
-		RelaunchThreadsInternal(0);
-	} catch (...) {
-		// nothing we can do in the destructor if this fails
-	}
-#endif
-}
-
-TaskScheduler &TaskScheduler::GetScheduler(ClientContext &context) {
-	return TaskScheduler::GetScheduler(DatabaseInstance::GetDatabase(context));
-}
-
-TaskScheduler &TaskScheduler::GetScheduler(DatabaseInstance &db) {
-	return db.GetScheduler();
-}
-
-unique_ptr<ProducerToken> TaskScheduler::CreateProducer() {
-	auto token = make_uniq<QueueProducerToken>(*queue);
-	return make_uniq<ProducerToken>(*this, std::move(token));
-}
-
-void TaskScheduler::ScheduleTask(ProducerToken &token, shared_ptr<Task> task) {
-	// Enqueue a task for the given producer token and signal any sleeping threads
-	queue->Enqueue(token, std::move(task));
-}
-
-bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
-	return queue->DequeueFromProducer(token, task);
-}
-
-void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
-#ifndef DUCKDB_NO_THREADS
-	static constexpr const int64_t INITIAL_FLUSH_WAIT = 500000; // initial wait time of 0.5s (in mus) before flushing
-
-	shared_ptr<Task> task;
-	// loop until the marker is set to false
-	while (*marker) {
-		if (!Allocator::SupportsFlush()) {
-			// allocator can't flush, just start an untimed wait
-			queue->semaphore.wait();
-		} else if (!queue->semaphore.wait(INITIAL_FLUSH_WAIT)) {
-			// allocator can flush, we flush this threads outstanding allocations after it was idle for 0.5s
-			Allocator::ThreadFlush(allocator_background_threads, allocator_flush_threshold,
-			                       NumericCast<idx_t>(requested_thread_count.load()));
-			auto decay_delay = Allocator::DecayDelay();
-			if (!decay_delay.IsValid()) {
-				// no decay delay specified - just wait
-				queue->semaphore.wait();
-			} else {
-				if (!queue->semaphore.wait(UnsafeNumericCast<int64_t>(decay_delay.GetIndex()) * 1000000 -
-				                           INITIAL_FLUSH_WAIT)) {
-					// in total, the thread was idle for the entire decay delay (note: seconds converted to mus)
-					// mark it as idle and start an untimed wait
-					Allocator::ThreadIdle();
-					queue->semaphore.wait();
-				}
-			}
-		}
-		if (queue->q.try_dequeue(task)) {
-			auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
-
-			switch (execute_result) {
-			case TaskExecutionResult::TASK_FINISHED:
-			case TaskExecutionResult::TASK_ERROR:
-				task.reset();
-				break;
-			case TaskExecutionResult::TASK_NOT_FINISHED:
-				throw InternalException("Task should not return TASK_NOT_FINISHED in PROCESS_ALL mode");
-			case TaskExecutionResult::TASK_BLOCKED:
-				task->Deschedule();
-				task.reset();
-				break;
-			}
-		}
-	}
-	// this thread will exit, flush all of its outstanding allocations
-	if (Allocator::SupportsFlush()) {
-		Allocator::ThreadFlush(allocator_background_threads, 0, NumericCast<idx_t>(requested_thread_count.load()));
-		Allocator::ThreadIdle();
-	}
-#else
-	throw NotImplementedException("DuckDB was compiled without threads! Background thread loop is not allowed.");
-#endif
-}
-
-idx_t TaskScheduler::ExecuteTasks(atomic<bool> *marker, idx_t max_tasks) {
-#ifndef DUCKDB_NO_THREADS
-	idx_t completed_tasks = 0;
-	// loop until the marker is set to false
-	while (*marker && completed_tasks < max_tasks) {
-		shared_ptr<Task> task;
-		if (!queue->q.try_dequeue(task)) {
-			return completed_tasks;
-		}
-		auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
-
-		switch (execute_result) {
-		case TaskExecutionResult::TASK_FINISHED:
-		case TaskExecutionResult::TASK_ERROR:
-			task.reset();
-			completed_tasks++;
-			break;
-		case TaskExecutionResult::TASK_NOT_FINISHED:
-			throw InternalException("Task should not return TASK_NOT_FINISHED in PROCESS_ALL mode");
-		case TaskExecutionResult::TASK_BLOCKED:
-			task->Deschedule();
-			task.reset();
-			break;
-		}
-	}
-	return completed_tasks;
-#else
-	throw NotImplementedException("DuckDB was compiled without threads! Background thread loop is not allowed.");
-#endif
-}
-
-void TaskScheduler::ExecuteTasks(idx_t max_tasks) {
-#ifndef DUCKDB_NO_THREADS
-	shared_ptr<Task> task;
-	for (idx_t i = 0; i < max_tasks; i++) {
-		queue->semaphore.wait(TASK_TIMEOUT_USECS);
-		if (!queue->q.try_dequeue(task)) {
-			return;
-		}
-		try {
-			auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
-			switch (execute_result) {
-			case TaskExecutionResult::TASK_FINISHED:
-			case TaskExecutionResult::TASK_ERROR:
-				task.reset();
-				break;
-			case TaskExecutionResult::TASK_NOT_FINISHED:
-				throw InternalException("Task should not return TASK_NOT_FINISHED in PROCESS_ALL mode");
-			case TaskExecutionResult::TASK_BLOCKED:
-				task->Deschedule();
-				task.reset();
-				break;
-			}
-		} catch (...) {
-			return;
-		}
-	}
-#else
-	throw NotImplementedException("DuckDB was compiled without threads! Background thread loop is not allowed.");
-#endif
-}
-
-#ifndef DUCKDB_NO_THREADS
-static void ThreadExecuteTasks(TaskScheduler *scheduler, atomic<bool> *marker) {
-	scheduler->ExecuteForever(marker);
-}
-#endif
-
-int32_t TaskScheduler::NumberOfThreads() {
-	return current_thread_count.load();
-}
-
-void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) {
-	if (total_threads == 0) {
-		throw SyntaxException("Number of threads must be positive!");
-	}
-#ifndef DUCKDB_NO_THREADS
-	if (total_threads < external_threads) {
-		throw SyntaxException("Number of threads can't be smaller than number of external threads!");
-	}
-#else
-	if (total_threads != external_threads) {
-		throw NotImplementedException(
-		    "DuckDB was compiled without threads! Setting total_threads != external_threads is not allowed.");
-	}
-#endif
-	requested_thread_count = NumericCast<int32_t>(total_threads - external_threads);
-}
-
-void TaskScheduler::SetAllocatorFlushTreshold(idx_t threshold) {
-	allocator_flush_threshold = threshold;
-}
-
-void TaskScheduler::SetAllocatorBackgroundThreads(bool enable) {
-	allocator_background_threads = enable;
-	Allocator::SetBackgroundThreads(enable);
-}
-
-void TaskScheduler::Signal(idx_t n) {
-#ifndef DUCKDB_NO_THREADS
-	typedef std::make_signed<std::size_t>::type ssize_t;
-	queue->semaphore.signal(NumericCast<ssize_t>(n));
-#endif
-}
-
-void TaskScheduler::YieldThread() {
-#ifndef DUCKDB_NO_THREADS
-	std::this_thread::yield();
-#endif
-}
-
-idx_t TaskScheduler::GetEstimatedCPUId() {
-#if defined(EMSCRIPTEN)
-	// FIXME: Wasm + multithreads can likely be implemented as
-	//   return return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
-	return 0;
-#else
-	// this code comes from jemalloc
-#if defined(_WIN32)
-	return (idx_t)GetCurrentProcessorNumber();
-#elif defined(_GNU_SOURCE)
-	auto cpu = sched_getcpu();
-	if (cpu < 0) {
-#ifndef DUCKDB_NO_THREADS
-		// fallback to thread id
-		return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
-#else
-
-		return 0;
-#endif
-	}
-	return (idx_t)cpu;
-#elif defined(__aarch64__) && defined(__APPLE__)
-	/* Other oses most likely use tpidr_el0 instead */
-	uintptr_t c;
-	asm volatile("mrs %x0, tpidrro_el0" : "=r"(c)::"memory");
-	return (idx_t)(c & (1 << 3) - 1);
-#else
-#ifndef DUCKDB_NO_THREADS
-	// fallback to thread id
-	return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
-#else
-	return 0;
-#endif
-#endif
-#endif
-}
-
-void TaskScheduler::RelaunchThreads() {
-	lock_guard<mutex> t(thread_lock);
-	auto n = requested_thread_count.load();
-	RelaunchThreadsInternal(n);
-}
-
-void TaskScheduler::RelaunchThreadsInternal(int32_t n) {
-#ifndef DUCKDB_NO_THREADS
-	auto &config = DBConfig::GetConfig(db);
-	auto new_thread_count = NumericCast<idx_t>(n);
-	if (threads.size() == new_thread_count) {
-		current_thread_count = NumericCast<int32_t>(threads.size() + config.options.external_threads);
-		return;
-	}
-	if (threads.size() > new_thread_count) {
-		// we are reducing the number of threads: clear all threads first
-		for (idx_t i = 0; i < threads.size(); i++) {
-			*markers[i] = false;
-		}
-		Signal(threads.size());
-		// now join the threads to ensure they are fully stopped before erasing them
-		for (idx_t i = 0; i < threads.size(); i++) {
-			threads[i]->internal_thread->join();
-		}
-		// erase the threads/markers
-		threads.clear();
-		markers.clear();
-	}
-	if (threads.size() < new_thread_count) {
-		// we are increasing the number of threads: launch them and run tasks on them
-		idx_t create_new_threads = new_thread_count - threads.size();
-		for (idx_t i = 0; i < create_new_threads; i++) {
-			// launch a thread and assign it a cancellation marker
-			auto marker = unique_ptr<atomic<bool>>(new atomic<bool>(true));
-			unique_ptr<thread> worker_thread;
-			try {
-				worker_thread = make_uniq<thread>(ThreadExecuteTasks, this, marker.get());
-			} catch (std::exception &ex) {
-				// thread constructor failed - this can happen when the system has too many threads allocated
-				// in this case we cannot allocate more threads - stop launching them
-				break;
-			}
-			auto thread_wrapper = make_uniq<SchedulerThread>(std::move(worker_thread));
-
-			threads.push_back(std::move(thread_wrapper));
-			markers.push_back(std::move(marker));
-		}
-	}
-	current_thread_count = NumericCast<int32_t>(threads.size() + config.options.external_threads);
-	if (Allocator::SupportsFlush()) {
-		Allocator::FlushAll();
-	}
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parallel/thread_context.cpp b/src/duckdb/src/parallel/thread_context.cpp
deleted file mode 100644
index 2eb15a3c3..000000000
--- a/src/duckdb/src/parallel/thread_context.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/execution/execution_context.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-ThreadContext::ThreadContext(ClientContext &context) : profiler(context) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/base_expression.cpp b/src/duckdb/src/parser/base_expression.cpp
deleted file mode 100644
index 92fa254a8..000000000
--- a/src/duckdb/src/parser/base_expression.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "duckdb/parser/base_expression.hpp"
-
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/printer.hpp"
-
-namespace duckdb {
-
-void BaseExpression::Print() const {
-	Printer::Print(ToString());
-}
-
-string BaseExpression::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return ToString();
-	}
-#endif
-	return !alias.empty() ? alias : ToString();
-}
-
-bool BaseExpression::Equals(const BaseExpression &other) const {
-	if (expression_class != other.expression_class || type != other.type) {
-		return false;
-	}
-	return true;
-}
-
-void BaseExpression::Verify() const {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/column_definition.cpp b/src/duckdb/src/parser/column_definition.cpp
deleted file mode 100644
index 4718c40c1..000000000
--- a/src/duckdb/src/parser/column_definition.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-
-namespace duckdb {
-
-ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p)
-    : name(std::move(name_p)), type(std::move(type_p)) {
-}
-
-ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p, unique_ptr<ParsedExpression> expression,
-                                   TableColumnType category)
-    : name(std::move(name_p)), type(std::move(type_p)), category(category), expression(std::move(expression)) {
-}
-
-ColumnDefinition ColumnDefinition::Copy() const {
-	ColumnDefinition copy(name, type);
-	copy.oid = oid;
-	copy.storage_oid = storage_oid;
-	copy.expression = expression ? expression->Copy() : nullptr;
-	copy.compression_type = compression_type;
-	copy.category = category;
-	copy.comment = comment;
-	copy.tags = tags;
-	return copy;
-}
-
-const ParsedExpression &ColumnDefinition::DefaultValue() const {
-	if (!HasDefaultValue()) {
-		if (Generated()) {
-			throw InternalException("Calling DefaultValue() on a generated column");
-		}
-		throw InternalException("DefaultValue() called on a column without a default value");
-	}
-	return *expression;
-}
-
-bool ColumnDefinition::HasDefaultValue() const {
-	if (Generated()) {
-		return false;
-	}
-	return expression != nullptr;
-}
-
-void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
-	if (Generated()) {
-		throw InternalException("Calling SetDefaultValue() on a generated column");
-	}
-	this->expression = std::move(default_value);
-}
-
-const LogicalType &ColumnDefinition::Type() const {
-	return type;
-}
-
-LogicalType &ColumnDefinition::TypeMutable() {
-	return type;
-}
-
-void ColumnDefinition::SetType(const LogicalType &type) {
-	this->type = type;
-}
-
-const string &ColumnDefinition::Name() const {
-	return name;
-}
-void ColumnDefinition::SetName(const string &name) {
-	this->name = name;
-}
-
-const Value &ColumnDefinition::Comment() const {
-	return comment;
-}
-
-void ColumnDefinition::SetComment(const Value &comment) {
-	this->comment = comment;
-}
-
-const duckdb::CompressionType &ColumnDefinition::CompressionType() const {
-	return compression_type;
-}
-
-void ColumnDefinition::SetCompressionType(duckdb::CompressionType compression_type) {
-	this->compression_type = compression_type;
-}
-
-const storage_t &ColumnDefinition::StorageOid() const {
-	return storage_oid;
-}
-
-LogicalIndex ColumnDefinition::Logical() const {
-	return LogicalIndex(oid);
-}
-
-PhysicalIndex ColumnDefinition::Physical() const {
-	return PhysicalIndex(storage_oid);
-}
-
-void ColumnDefinition::SetStorageOid(storage_t storage_oid) {
-	this->storage_oid = storage_oid;
-}
-
-const column_t &ColumnDefinition::Oid() const {
-	return oid;
-}
-
-void ColumnDefinition::SetOid(column_t oid) {
-	this->oid = oid;
-}
-
-const TableColumnType &ColumnDefinition::Category() const {
-	return category;
-}
-
-bool ColumnDefinition::Generated() const {
-	return category == TableColumnType::GENERATED;
-}
-
-//===--------------------------------------------------------------------===//
-// Generated Columns (VIRTUAL)
-//===--------------------------------------------------------------------===//
-
-static void VerifyColumnRefs(ParsedExpression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &column_ref = expr.Cast<ColumnRefExpression>();
-		if (column_ref.IsQualified()) {
-			throw ParserException(
-			    "Qualified (tbl.name) column references are not allowed inside of generated column expressions");
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { VerifyColumnRefs((ParsedExpression &)child); });
-}
-
-static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &dependencies) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto columnref = expr.Cast<ColumnRefExpression>();
-		auto &name = columnref.GetColumnName();
-		dependencies.push_back(name);
-	}
-	ParsedExpressionIterator::EnumerateChildren(expr, [&](const ParsedExpression &child) {
-		if (expr.GetExpressionType() == ExpressionType::LAMBDA) {
-			throw NotImplementedException("Lambda functions are currently not supported in generated columns.");
-		}
-		InnerGetListOfDependencies((ParsedExpression &)child, dependencies);
-	});
-}
-
-void ColumnDefinition::GetListOfDependencies(vector<string> &dependencies) const {
-	D_ASSERT(Generated());
-	InnerGetListOfDependencies(*expression, dependencies);
-}
-
-string ColumnDefinition::GetName() const {
-	return name;
-}
-
-LogicalType ColumnDefinition::GetType() const {
-	return type;
-}
-
-void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> new_expr) {
-	category = TableColumnType::GENERATED;
-
-	if (new_expr->HasSubquery()) {
-		throw ParserException("Expression of generated column \"%s\" contains a subquery, which isn't allowed", name);
-	}
-
-	VerifyColumnRefs(*new_expr);
-	if (type.id() == LogicalTypeId::ANY) {
-		expression = std::move(new_expr);
-		return;
-	}
-	// Always wrap the expression in a cast, that way we can always update the cast when we change the type
-	// Except if the type is LogicalType::ANY (no type specified)
-	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(new_expr));
-}
-
-void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
-	D_ASSERT(Generated());
-	// First time the type is set, add a cast around the expression
-	D_ASSERT(this->type.id() == LogicalTypeId::ANY);
-	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
-	// Every generated expression should be wrapped in a cast on creation
-	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
-	// auto &cast_expr = generated_expression->Cast<CastExpression>();
-	// auto base_expr = std::move(cast_expr.child);
-	// generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(base_expr));
-}
-
-const ParsedExpression &ColumnDefinition::GeneratedExpression() const {
-	D_ASSERT(Generated());
-	return *expression;
-}
-
-ParsedExpression &ColumnDefinition::GeneratedExpressionMutable() {
-	D_ASSERT(Generated());
-	return *expression;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/column_list.cpp b/src/duckdb/src/parser/column_list.cpp
deleted file mode 100644
index f0b29f483..000000000
--- a/src/duckdb/src/parser/column_list.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/exception/catalog_exception.hpp"
-
-namespace duckdb {
-
-ColumnList::ColumnList(bool allow_duplicate_names) : allow_duplicate_names(allow_duplicate_names) {
-}
-
-ColumnList::ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names)
-    : allow_duplicate_names(allow_duplicate_names) {
-	for (auto &col : columns) {
-		AddColumn(std::move(col));
-	}
-}
-
-void ColumnList::AddColumn(ColumnDefinition column) {
-	auto oid = columns.size();
-	if (!column.Generated()) {
-		column.SetStorageOid(physical_columns.size());
-		physical_columns.push_back(oid);
-	} else {
-		column.SetStorageOid(DConstants::INVALID_INDEX);
-	}
-	column.SetOid(columns.size());
-	AddToNameMap(column);
-	columns.push_back(std::move(column));
-}
-
-void ColumnList::Finalize() {
-	// add the "rowid" alias, if there is no rowid column specified in the table
-	if (name_map.find("rowid") == name_map.end()) {
-		name_map["rowid"] = COLUMN_IDENTIFIER_ROW_ID;
-	}
-}
-
-void ColumnList::AddToNameMap(ColumnDefinition &col) {
-	if (allow_duplicate_names) {
-		idx_t index = 1;
-		string base_name = col.Name();
-		while (name_map.find(col.Name()) != name_map.end()) {
-			col.SetName(base_name + "_" + to_string(index++));
-		}
-	} else {
-		if (name_map.find(col.Name()) != name_map.end()) {
-			throw CatalogException("Column with name %s already exists!", col.Name());
-		}
-	}
-	name_map[col.Name()] = col.Oid();
-}
-
-ColumnDefinition &ColumnList::GetColumnMutable(LogicalIndex logical) {
-	if (logical.index >= columns.size()) {
-		throw InternalException("Logical column index %lld out of range", logical.index);
-	}
-	return columns[logical.index];
-}
-
-ColumnDefinition &ColumnList::GetColumnMutable(PhysicalIndex physical) {
-	if (physical.index >= physical_columns.size()) {
-		throw InternalException("Physical column index %lld out of range", physical.index);
-	}
-	auto logical_index = physical_columns[physical.index];
-	D_ASSERT(logical_index < columns.size());
-	return columns[logical_index];
-}
-
-ColumnDefinition &ColumnList::GetColumnMutable(const string &name) {
-	auto entry = name_map.find(name);
-	if (entry == name_map.end()) {
-		throw InternalException("Column with name \"%s\" does not exist", name);
-	}
-	auto logical_index = entry->second;
-	D_ASSERT(logical_index < columns.size());
-	return columns[logical_index];
-}
-
-const ColumnDefinition &ColumnList::GetColumn(LogicalIndex logical) const {
-	if (logical.index >= columns.size()) {
-		throw InternalException("Logical column index %lld out of range", logical.index);
-	}
-	return columns[logical.index];
-}
-
-const ColumnDefinition &ColumnList::GetColumn(PhysicalIndex physical) const {
-	if (physical.index >= physical_columns.size()) {
-		throw InternalException("Physical column index %lld out of range", physical.index);
-	}
-	auto logical_index = physical_columns[physical.index];
-	D_ASSERT(logical_index < columns.size());
-	return columns[logical_index];
-}
-
-const ColumnDefinition &ColumnList::GetColumn(const string &name) const {
-	auto entry = name_map.find(name);
-	if (entry == name_map.end()) {
-		throw InternalException("Column with name \"%s\" does not exist", name);
-	}
-	auto logical_index = entry->second;
-	D_ASSERT(logical_index < columns.size());
-	return columns[logical_index];
-}
-
-vector<string> ColumnList::GetColumnNames() const {
-	vector<string> names;
-	names.reserve(columns.size());
-	for (auto &column : columns) {
-		names.push_back(column.Name());
-	}
-	return names;
-}
-
-vector<LogicalType> ColumnList::GetColumnTypes() const {
-	vector<LogicalType> types;
-	types.reserve(columns.size());
-	for (auto &column : columns) {
-		types.push_back(column.Type());
-	}
-	return types;
-}
-
-bool ColumnList::ColumnExists(const string &name) const {
-	auto entry = name_map.find(name);
-	return entry != name_map.end();
-}
-
-PhysicalIndex ColumnList::LogicalToPhysical(LogicalIndex logical) const {
-	auto &column = GetColumn(logical);
-	if (column.Generated()) {
-		throw InternalException("Column at position %d is not a physical column", logical.index);
-	}
-	return column.Physical();
-}
-
-LogicalIndex ColumnList::PhysicalToLogical(PhysicalIndex index) const {
-	auto &column = GetColumn(index);
-	return column.Logical();
-}
-
-LogicalIndex ColumnList::GetColumnIndex(string &column_name) const {
-	auto entry = name_map.find(column_name);
-	if (entry == name_map.end()) {
-		return LogicalIndex(DConstants::INVALID_INDEX);
-	}
-	if (entry->second == COLUMN_IDENTIFIER_ROW_ID) {
-		column_name = "rowid";
-		return LogicalIndex(COLUMN_IDENTIFIER_ROW_ID);
-	}
-	column_name = columns[entry->second].Name();
-	return LogicalIndex(entry->second);
-}
-
-ColumnList ColumnList::Copy() const {
-	ColumnList result(allow_duplicate_names);
-	for (auto &col : columns) {
-		result.AddColumn(col.Copy());
-	}
-	return result;
-}
-
-ColumnList::ColumnListIterator ColumnList::Logical() const {
-	return ColumnListIterator(*this, false);
-}
-
-ColumnList::ColumnListIterator ColumnList::Physical() const {
-	return ColumnListIterator(*this, true);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/constraint.cpp b/src/duckdb/src/parser/constraint.cpp
deleted file mode 100644
index c06a5c800..000000000
--- a/src/duckdb/src/parser/constraint.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/parser/constraint.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-
-namespace duckdb {
-
-Constraint::Constraint(ConstraintType type) : type(type) {
-}
-
-Constraint::~Constraint() {
-}
-
-void Constraint::Print() const {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/constraints/check_constraint.cpp b/src/duckdb/src/parser/constraints/check_constraint.cpp
deleted file mode 100644
index 9e6c27bd3..000000000
--- a/src/duckdb/src/parser/constraints/check_constraint.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/parser/constraints/check_constraint.hpp"
-
-namespace duckdb {
-
-CheckConstraint::CheckConstraint(unique_ptr<ParsedExpression> expression)
-    : Constraint(ConstraintType::CHECK), expression(std::move(expression)) {
-}
-
-string CheckConstraint::ToString() const {
-	return "CHECK(" + expression->ToString() + ")";
-}
-
-unique_ptr<Constraint> CheckConstraint::Copy() const {
-	return make_uniq<CheckConstraint>(expression->Copy());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp b/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp
deleted file mode 100644
index db76fd516..000000000
--- a/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-ForeignKeyConstraint::ForeignKeyConstraint() : Constraint(ConstraintType::FOREIGN_KEY) {
-}
-
-ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
-    : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)),
-      info(std::move(info)) {
-}
-
-string ForeignKeyConstraint::ToString() const {
-	if (info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-		string base = "FOREIGN KEY (";
-
-		for (idx_t i = 0; i < fk_columns.size(); i++) {
-			if (i > 0) {
-				base += ", ";
-			}
-			base += KeywordHelper::WriteOptionallyQuoted(fk_columns[i]);
-		}
-		base += ") REFERENCES ";
-		if (!info.schema.empty()) {
-			base += info.schema;
-			base += ".";
-		}
-		base += info.table;
-		if (!pk_columns.empty()) {
-			base += "(";
-
-			for (idx_t i = 0; i < pk_columns.size(); i++) {
-				if (i > 0) {
-					base += ", ";
-				}
-				base += KeywordHelper::WriteOptionallyQuoted(pk_columns[i]);
-			}
-			base += ")";
-		}
-
-		return base;
-	}
-
-	return "";
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Copy() const {
-	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, info);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/constraints/not_null_constraint.cpp b/src/duckdb/src/parser/constraints/not_null_constraint.cpp
deleted file mode 100644
index fb406e5a7..000000000
--- a/src/duckdb/src/parser/constraints/not_null_constraint.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-
-namespace duckdb {
-
-NotNullConstraint::NotNullConstraint(LogicalIndex index) : Constraint(ConstraintType::NOT_NULL), index(index) {
-}
-
-NotNullConstraint::~NotNullConstraint() {
-}
-
-string NotNullConstraint::ToString() const {
-	return "NOT NULL";
-}
-
-unique_ptr<Constraint> NotNullConstraint::Copy() const {
-	return make_uniq<NotNullConstraint>(index);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/constraints/unique_constraint.cpp b/src/duckdb/src/parser/constraints/unique_constraint.cpp
deleted file mode 100644
index 51c4631b3..000000000
--- a/src/duckdb/src/parser/constraints/unique_constraint.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-UniqueConstraint::UniqueConstraint() : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX) {
-}
-
-UniqueConstraint::UniqueConstraint(const LogicalIndex index, const bool is_primary_key)
-    : Constraint(ConstraintType::UNIQUE), index(index), is_primary_key(is_primary_key) {
-}
-
-UniqueConstraint::UniqueConstraint(vector<string> columns, const bool is_primary_key)
-    : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX), columns(std::move(columns)),
-      is_primary_key(is_primary_key) {
-}
-
-string UniqueConstraint::ToString() const {
-	string base = is_primary_key ? "PRIMARY KEY(" : "UNIQUE(";
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i > 0) {
-			base += ", ";
-		}
-		base += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-	}
-	return base + ")";
-}
-
-unique_ptr<Constraint> UniqueConstraint::Copy() const {
-	if (!HasIndex()) {
-		return make_uniq<UniqueConstraint>(columns, is_primary_key);
-	}
-
-	auto result = make_uniq<UniqueConstraint>(index, is_primary_key);
-	if (!columns.empty()) {
-		result->columns.push_back(columns[0]);
-	}
-	return std::move(result);
-}
-
-bool UniqueConstraint::IsPrimaryKey() const {
-	return is_primary_key;
-}
-
-bool UniqueConstraint::HasIndex() const {
-	return index.index != DConstants::INVALID_INDEX;
-}
-
-LogicalIndex UniqueConstraint::GetIndex() const {
-	if (!HasIndex()) {
-		throw InternalException("UniqueConstraint::GetIndex called on a unique constraint without an index");
-	}
-	return index;
-}
-
-void UniqueConstraint::SetIndex(const LogicalIndex new_index) {
-	D_ASSERT(new_index.index != DConstants::INVALID_INDEX);
-	index = new_index;
-}
-
-const vector<string> &UniqueConstraint::GetColumnNames() const {
-	D_ASSERT(!columns.empty());
-	return columns;
-}
-
-vector<string> &UniqueConstraint::GetColumnNamesMutable() {
-	D_ASSERT(!columns.empty());
-	return columns;
-}
-
-vector<LogicalIndex> UniqueConstraint::GetLogicalIndexes(const ColumnList &column_list) const {
-	if (HasIndex()) {
-		return {GetIndex()};
-	}
-
-	vector<LogicalIndex> indexes;
-	for (auto &col_name : GetColumnNames()) {
-		D_ASSERT(column_list.ColumnExists(col_name));
-		auto &col = column_list.GetColumn(col_name);
-		D_ASSERT(!col.Generated());
-		indexes.push_back(col.Logical());
-	}
-	return indexes;
-}
-
-string UniqueConstraint::GetName(const string &table_name) const {
-	auto type = IsPrimaryKey() ? IndexConstraintType::PRIMARY : IndexConstraintType::UNIQUE;
-	auto type_name = EnumUtil::ToString(type);
-
-	string name;
-	for (const auto &column_name : GetColumnNames()) {
-		name += "_" + column_name;
-	}
-	return type_name + "_" + table_name + name;
-}
-
-void UniqueConstraint::SetColumnName(const string &column_name) {
-	if (!columns.empty()) {
-		return;
-	}
-	columns.push_back(column_name);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/between_expression.cpp b/src/duckdb/src/parser/expression/between_expression.cpp
deleted file mode 100644
index 414e5048b..000000000
--- a/src/duckdb/src/parser/expression/between_expression.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/parser/expression/between_expression.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-BetweenExpression::BetweenExpression(unique_ptr<ParsedExpression> input_p, unique_ptr<ParsedExpression> lower_p,
-                                     unique_ptr<ParsedExpression> upper_p)
-    : ParsedExpression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BETWEEN), input(std::move(input_p)),
-      lower(std::move(lower_p)), upper(std::move(upper_p)) {
-}
-
-BetweenExpression::BetweenExpression() : BetweenExpression(nullptr, nullptr, nullptr) {
-}
-
-string BetweenExpression::ToString() const {
-	return ToString<BetweenExpression, ParsedExpression>(*this);
-}
-
-bool BetweenExpression::Equal(const BetweenExpression &a, const BetweenExpression &b) {
-	if (!a.input->Equals(*b.input)) {
-		return false;
-	}
-	if (!a.lower->Equals(*b.lower)) {
-		return false;
-	}
-	if (!a.upper->Equals(*b.upper)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> BetweenExpression::Copy() const {
-	auto copy = make_uniq<BetweenExpression>(input->Copy(), lower->Copy(), upper->Copy());
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/case_expression.cpp b/src/duckdb/src/parser/expression/case_expression.cpp
deleted file mode 100644
index fd76081ac..000000000
--- a/src/duckdb/src/parser/expression/case_expression.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/parser/expression/case_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
-}
-
-string CaseExpression::ToString() const {
-	return ToString<CaseExpression, ParsedExpression>(*this);
-}
-
-bool CaseExpression::Equal(const CaseExpression &a, const CaseExpression &b) {
-	if (a.case_checks.size() != b.case_checks.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.case_checks.size(); i++) {
-		if (!a.case_checks[i].when_expr->Equals(*b.case_checks[i].when_expr)) {
-			return false;
-		}
-		if (!a.case_checks[i].then_expr->Equals(*b.case_checks[i].then_expr)) {
-			return false;
-		}
-	}
-	if (!a.else_expr->Equals(*b.else_expr)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> CaseExpression::Copy() const {
-	auto copy = make_uniq<CaseExpression>();
-	copy->CopyProperties(*this);
-	for (auto &check : case_checks) {
-		CaseCheck new_check;
-		new_check.when_expr = check.when_expr->Copy();
-		new_check.then_expr = check.then_expr->Copy();
-		copy->case_checks.push_back(std::move(new_check));
-	}
-	copy->else_expr = else_expr->Copy();
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/cast_expression.cpp b/src/duckdb/src/parser/expression/cast_expression.cpp
deleted file mode 100644
index 758cc29ce..000000000
--- a/src/duckdb/src/parser/expression/cast_expression.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/parser/expression/cast_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-CastExpression::CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast_p)
-    : ParsedExpression(ExpressionType::OPERATOR_CAST, ExpressionClass::CAST), cast_type(std::move(target)),
-      try_cast(try_cast_p) {
-	D_ASSERT(child);
-	this->child = std::move(child);
-}
-
-CastExpression::CastExpression() : ParsedExpression(ExpressionType::OPERATOR_CAST, ExpressionClass::CAST) {
-}
-
-string CastExpression::ToString() const {
-	return ToString<CastExpression, ParsedExpression>(*this);
-}
-
-bool CastExpression::Equal(const CastExpression &a, const CastExpression &b) {
-	if (!a.child->Equals(*b.child)) {
-		return false;
-	}
-	if (a.cast_type != b.cast_type) {
-		return false;
-	}
-	if (a.try_cast != b.try_cast) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> CastExpression::Copy() const {
-	auto copy = make_uniq<CastExpression>(cast_type, child->Copy(), try_cast);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/collate_expression.cpp b/src/duckdb/src/parser/expression/collate_expression.cpp
deleted file mode 100644
index 70b754f9c..000000000
--- a/src/duckdb/src/parser/expression/collate_expression.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/parser/expression/collate_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpression> child)
-    : ParsedExpression(ExpressionType::COLLATE, ExpressionClass::COLLATE), collation(std::move(collation_p)) {
-	D_ASSERT(child);
-	this->child = std::move(child);
-}
-
-CollateExpression::CollateExpression() : ParsedExpression(ExpressionType::COLLATE, ExpressionClass::COLLATE) {
-}
-
-string CollateExpression::ToString() const {
-	return StringUtil::Format("%s COLLATE %s", child->ToString(), SQLIdentifier(collation));
-}
-
-bool CollateExpression::Equal(const CollateExpression &a, const CollateExpression &b) {
-	if (!a.child->Equals(*b.child)) {
-		return false;
-	}
-	if (a.collation != b.collation) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> CollateExpression::Copy() const {
-	auto copy = make_uniq<CollateExpression>(collation, child->Copy());
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/columnref_expression.cpp b/src/duckdb/src/parser/expression/columnref_expression.cpp
deleted file mode 100644
index c1eb6e9cd..000000000
--- a/src/duckdb/src/parser/expression/columnref_expression.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "duckdb/parser/expression/columnref_expression.hpp"
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/planner/binding_alias.hpp"
-
-namespace duckdb {
-
-ColumnRefExpression::ColumnRefExpression() : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF) {
-}
-
-ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
-    : ColumnRefExpression(table_name.empty() ? vector<string> {std::move(column_name)}
-                                             : vector<string> {std::move(table_name), std::move(column_name)}) {
-}
-
-ColumnRefExpression::ColumnRefExpression(string column_name, const BindingAlias &alias)
-    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF) {
-	if (alias.IsSet()) {
-		if (!alias.GetCatalog().empty()) {
-			column_names.push_back(alias.GetCatalog());
-		}
-		if (!alias.GetSchema().empty()) {
-			column_names.push_back(alias.GetSchema());
-		}
-		column_names.push_back(alias.GetAlias());
-	}
-	column_names.push_back(std::move(column_name));
-}
-
-ColumnRefExpression::ColumnRefExpression(string column_name)
-    : ColumnRefExpression(vector<string> {std::move(column_name)}) {
-}
-
-ColumnRefExpression::ColumnRefExpression(vector<string> column_names_p)
-    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF),
-      column_names(std::move(column_names_p)) {
-#ifdef DEBUG
-	for (auto &col_name : column_names) {
-		D_ASSERT(!col_name.empty());
-	}
-#endif
-}
-
-bool ColumnRefExpression::IsQualified() const {
-	return column_names.size() > 1;
-}
-
-const string &ColumnRefExpression::GetColumnName() const {
-	D_ASSERT(column_names.size() <= 4);
-	return column_names.back();
-}
-
-const string &ColumnRefExpression::GetTableName() const {
-	D_ASSERT(column_names.size() >= 2 && column_names.size() <= 4);
-	if (column_names.size() == 4) {
-		return column_names[2];
-	}
-	if (column_names.size() == 3) {
-		return column_names[1];
-	}
-	return column_names[0];
-}
-
-string ColumnRefExpression::GetName() const {
-	return !alias.empty() ? alias : column_names.back();
-}
-
-string ColumnRefExpression::ToString() const {
-	string result;
-	for (idx_t i = 0; i < column_names.size(); i++) {
-		if (i > 0) {
-			result += ".";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(column_names[i]);
-	}
-	return result;
-}
-
-bool ColumnRefExpression::Equal(const ColumnRefExpression &a, const ColumnRefExpression &b) {
-	if (a.column_names.size() != b.column_names.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.column_names.size(); i++) {
-		if (!StringUtil::CIEquals(a.column_names[i], b.column_names[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-hash_t ColumnRefExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	for (auto &column_name : column_names) {
-		result = CombineHash(result, StringUtil::CIHash(column_name));
-	}
-	return result;
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
-	auto copy = make_uniq<ColumnRefExpression>(column_names);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/comparison_expression.cpp b/src/duckdb/src/parser/expression/comparison_expression.cpp
deleted file mode 100644
index d0649b35a..000000000
--- a/src/duckdb/src/parser/expression/comparison_expression.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/parser/expression/comparison_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-ComparisonExpression::ComparisonExpression(ExpressionType type) : ParsedExpression(type, ExpressionClass::COMPARISON) {
-}
-
-ComparisonExpression::ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-                                           unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::COMPARISON), left(std::move(left)), right(std::move(right)) {
-}
-
-string ComparisonExpression::ToString() const {
-	return ToString<ComparisonExpression, ParsedExpression>(*this);
-}
-
-bool ComparisonExpression::Equal(const ComparisonExpression &a, const ComparisonExpression &b) {
-	if (!a.left->Equals(*b.left)) {
-		return false;
-	}
-	if (!a.right->Equals(*b.right)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::Copy() const {
-	auto copy = make_uniq<ComparisonExpression>(type, left->Copy(), right->Copy());
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/conjunction_expression.cpp b/src/duckdb/src/parser/expression/conjunction_expression.cpp
deleted file mode 100644
index a11759b8f..000000000
--- a/src/duckdb/src/parser/expression/conjunction_expression.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression_util.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-ConjunctionExpression::ConjunctionExpression(ExpressionType type)
-    : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-}
-
-ConjunctionExpression::ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children)
-    : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-	for (auto &child : children) {
-		AddExpression(std::move(child));
-	}
-}
-
-ConjunctionExpression::ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-                                             unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-	AddExpression(std::move(left));
-	AddExpression(std::move(right));
-}
-
-void ConjunctionExpression::AddExpression(unique_ptr<ParsedExpression> expr) {
-	if (expr->GetExpressionType() == type) {
-		// expr is a conjunction of the same type: merge the expression lists together
-		auto &other = expr->Cast<ConjunctionExpression>();
-		for (auto &child : other.children) {
-			children.push_back(std::move(child));
-		}
-	} else {
-		children.push_back(std::move(expr));
-	}
-}
-
-string ConjunctionExpression::ToString() const {
-	return ToString<ConjunctionExpression, ParsedExpression>(*this);
-}
-
-bool ConjunctionExpression::Equal(const ConjunctionExpression &a, const ConjunctionExpression &b) {
-	return ExpressionUtil::SetEquals(a.children, b.children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {
-	vector<unique_ptr<ParsedExpression>> copy_children;
-	copy_children.reserve(children.size());
-	for (auto &expr : children) {
-		copy_children.push_back(expr->Copy());
-	}
-
-	auto copy = make_uniq<ConjunctionExpression>(type, std::move(copy_children));
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/constant_expression.cpp b/src/duckdb/src/parser/expression/constant_expression.cpp
deleted file mode 100644
index 437687b14..000000000
--- a/src/duckdb/src/parser/expression/constant_expression.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-ConstantExpression::ConstantExpression() : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT) {
-}
-
-ConstantExpression::ConstantExpression(Value val)
-    : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT), value(std::move(val)) {
-}
-
-string ConstantExpression::ToString() const {
-	return value.ToSQLString();
-}
-
-bool ConstantExpression::Equal(const ConstantExpression &a, const ConstantExpression &b) {
-	return a.value.type() == b.value.type() && !ValueOperations::DistinctFrom(a.value, b.value);
-}
-
-hash_t ConstantExpression::Hash() const {
-	return value.Hash();
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::Copy() const {
-	auto copy = make_uniq<ConstantExpression>(value);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/default_expression.cpp b/src/duckdb/src/parser/expression/default_expression.cpp
deleted file mode 100644
index 7618fd21b..000000000
--- a/src/duckdb/src/parser/expression/default_expression.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/parser/expression/default_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-DefaultExpression::DefaultExpression() : ParsedExpression(ExpressionType::VALUE_DEFAULT, ExpressionClass::DEFAULT) {
-}
-
-string DefaultExpression::ToString() const {
-	return "DEFAULT";
-}
-
-unique_ptr<ParsedExpression> DefaultExpression::Copy() const {
-	auto copy = make_uniq<DefaultExpression>();
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/function_expression.cpp b/src/duckdb/src/parser/expression/function_expression.cpp
deleted file mode 100644
index a38b3024e..000000000
--- a/src/duckdb/src/parser/expression/function_expression.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "duckdb/parser/expression/function_expression.hpp"
-
-#include <utility>
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hash.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-FunctionExpression::FunctionExpression() : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION) {
-}
-
-FunctionExpression::FunctionExpression(string catalog, string schema, const string &function_name,
-                                       vector<unique_ptr<ParsedExpression>> children_p,
-                                       unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys_p,
-                                       bool distinct, bool is_operator, bool export_state_p)
-    : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION), catalog(std::move(catalog)),
-      schema(std::move(schema)), function_name(StringUtil::Lower(function_name)), is_operator(is_operator),
-      children(std::move(children_p)), distinct(distinct), filter(std::move(filter)), order_bys(std::move(order_bys_p)),
-      export_state(export_state_p) {
-	D_ASSERT(!function_name.empty());
-	if (!order_bys) {
-		order_bys = make_uniq<OrderModifier>();
-	}
-}
-
-FunctionExpression::FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children_p,
-                                       unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys,
-                                       bool distinct, bool is_operator, bool export_state_p)
-    : FunctionExpression(INVALID_CATALOG, INVALID_SCHEMA, function_name, std::move(children_p), std::move(filter),
-                         std::move(order_bys), distinct, is_operator, export_state_p) {
-}
-
-string FunctionExpression::ToString() const {
-	return ToString<FunctionExpression, ParsedExpression>(*this, catalog, schema, function_name, is_operator, distinct,
-	                                                      filter.get(), order_bys.get(), export_state, true);
-}
-
-bool FunctionExpression::Equal(const FunctionExpression &a, const FunctionExpression &b) {
-	if (a.catalog != b.catalog || a.schema != b.schema || a.function_name != b.function_name ||
-	    b.distinct != a.distinct) {
-		return false;
-	}
-	if (b.children.size() != a.children.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.children.size(); i++) {
-		if (!a.children[i]->Equals(*b.children[i])) {
-			return false;
-		}
-	}
-	if (!ParsedExpression::Equals(a.filter, b.filter)) {
-		return false;
-	}
-	if (!OrderModifier::Equals(a.order_bys, b.order_bys)) {
-		return false;
-	}
-	if (a.export_state != b.export_state) {
-		return false;
-	}
-	return true;
-}
-
-hash_t FunctionExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	result = CombineHash(result, duckdb::Hash<const char *>(schema.c_str()));
-	result = CombineHash(result, duckdb::Hash<const char *>(function_name.c_str()));
-	result = CombineHash(result, duckdb::Hash<bool>(distinct));
-	result = CombineHash(result, duckdb::Hash<bool>(export_state));
-	return result;
-}
-
-unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
-	vector<unique_ptr<ParsedExpression>> copy_children;
-	unique_ptr<ParsedExpression> filter_copy;
-	copy_children.reserve(children.size());
-	for (auto &child : children) {
-		copy_children.push_back(child->Copy());
-	}
-	if (filter) {
-		filter_copy = filter->Copy();
-	}
-	auto order_copy = order_bys ? unique_ptr_cast<ResultModifier, OrderModifier>(order_bys->Copy()) : nullptr;
-	auto copy =
-	    make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(copy_children), std::move(filter_copy),
-	                                  std::move(order_copy), distinct, is_operator, export_state);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-void FunctionExpression::Verify() const {
-	D_ASSERT(!function_name.empty());
-}
-
-bool FunctionExpression::IsLambdaFunction() const {
-	// Ignore the ->> operator (JSON extension).
-	if (function_name == "->>") {
-		return false;
-	}
-	// Check the children for lambda expressions.
-	for (auto &child : children) {
-		if (child->GetExpressionClass() == ExpressionClass::LAMBDA) {
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/lambda_expression.cpp b/src/duckdb/src/parser/expression/lambda_expression.cpp
deleted file mode 100644
index bdf32e6c0..000000000
--- a/src/duckdb/src/parser/expression/lambda_expression.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "duckdb/parser/expression/lambda_expression.hpp"
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-LambdaExpression::LambdaExpression() : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA) {
-}
-
-LambdaExpression::LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr)
-    : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA), lhs(std::move(lhs)), expr(std::move(expr)) {
-}
-
-vector<reference<ParsedExpression>> LambdaExpression::ExtractColumnRefExpressions(string &error_message) {
-
-	// we return an error message because we can't throw a binder exception here,
-	// since we can't distinguish between a lambda function and the JSON operator yet
-	vector<reference<ParsedExpression>> column_refs;
-
-	if (lhs->GetExpressionClass() == ExpressionClass::COLUMN_REF) {
-		// single column reference
-		column_refs.emplace_back(*lhs);
-		return column_refs;
-	}
-
-	if (lhs->GetExpressionClass() == ExpressionClass::FUNCTION) {
-		// list of column references
-		auto &func_expr = lhs->Cast<FunctionExpression>();
-		if (func_expr.function_name != "row") {
-			error_message = InvalidParametersErrorMessage();
-			return column_refs;
-		}
-
-		for (auto &child : func_expr.children) {
-			if (child->GetExpressionClass() != ExpressionClass::COLUMN_REF) {
-				error_message = InvalidParametersErrorMessage();
-				return column_refs;
-			}
-			column_refs.emplace_back(*child);
-		}
-	}
-
-	if (column_refs.empty()) {
-		error_message = InvalidParametersErrorMessage();
-	}
-	return column_refs;
-}
-
-string LambdaExpression::InvalidParametersErrorMessage() {
-	return "Invalid lambda parameters! Parameters must be unqualified comma-separated names like x or (x, y).";
-}
-
-bool LambdaExpression::IsLambdaParameter(const vector<unordered_set<string>> &lambda_params,
-                                         const string &parameter_name) {
-	for (const auto &level : lambda_params) {
-		if (level.find(parameter_name) != level.end()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-string LambdaExpression::ToString() const {
-	return "(" + lhs->ToString() + " -> " + expr->ToString() + ")";
-}
-
-bool LambdaExpression::Equal(const LambdaExpression &a, const LambdaExpression &b) {
-	return a.lhs->Equals(*b.lhs) && a.expr->Equals(*b.expr);
-}
-
-hash_t LambdaExpression::Hash() const {
-	hash_t result = lhs->Hash();
-	ParsedExpression::Hash();
-	result = CombineHash(result, expr->Hash());
-	return result;
-}
-
-unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
-	auto copy = make_uniq<LambdaExpression>(lhs->Copy(), expr->Copy());
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/lambdaref_expression.cpp b/src/duckdb/src/parser/expression/lambdaref_expression.cpp
deleted file mode 100644
index fed844fea..000000000
--- a/src/duckdb/src/parser/expression/lambdaref_expression.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/parser/expression/lambdaref_expression.hpp"
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/planner/table_binding.hpp"
-
-namespace duckdb {
-
-LambdaRefExpression::LambdaRefExpression(idx_t lambda_idx, string column_name_p)
-    : ParsedExpression(ExpressionType::LAMBDA_REF, ExpressionClass::LAMBDA_REF), lambda_idx(lambda_idx),
-      column_name(std::move(column_name_p)) {
-	alias = column_name;
-}
-
-bool LambdaRefExpression::IsScalar() const {
-	throw InternalException("lambda reference expressions are transient, IsScalar should never be called");
-}
-
-string LambdaRefExpression::GetName() const {
-	return column_name;
-}
-
-string LambdaRefExpression::ToString() const {
-	throw InternalException("lambda reference expressions are transient, ToString should never be called");
-}
-
-hash_t LambdaRefExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	result = CombineHash(result, lambda_idx);
-	result = CombineHash(result, StringUtil::CIHash(column_name));
-	return result;
-}
-
-unique_ptr<ParsedExpression> LambdaRefExpression::Copy() const {
-	throw InternalException("lambda reference expressions are transient, Copy should never be called");
-}
-
-unique_ptr<ParsedExpression>
-LambdaRefExpression::FindMatchingBinding(optional_ptr<vector<DummyBinding>> &lambda_bindings,
-                                         const string &column_name) {
-
-	// if this is a lambda parameter, then we temporarily add a BoundLambdaRef,
-	// which we capture and remove later
-
-	// inner lambda parameters have precedence over outer lambda parameters, and
-	// lambda parameters have precedence over macros and columns
-
-	if (lambda_bindings) {
-		for (idx_t i = lambda_bindings->size(); i > 0; i--) {
-			if ((*lambda_bindings)[i - 1].HasMatchingBinding(column_name)) {
-				D_ASSERT((*lambda_bindings)[i - 1].alias.IsSet());
-				return make_uniq<LambdaRefExpression>(i - 1, column_name);
-			}
-		}
-	}
-
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/operator_expression.cpp b/src/duckdb/src/parser/expression/operator_expression.cpp
deleted file mode 100644
index 79d90f674..000000000
--- a/src/duckdb/src/parser/expression/operator_expression.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "duckdb/parser/expression/operator_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-OperatorExpression::OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-                                       unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::OPERATOR) {
-	if (left) {
-		children.push_back(std::move(left));
-	}
-	if (right) {
-		children.push_back(std::move(right));
-	}
-}
-
-OperatorExpression::OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children)
-    : ParsedExpression(type, ExpressionClass::OPERATOR), children(std::move(children)) {
-}
-
-string OperatorExpression::ToString() const {
-	return ToString<OperatorExpression, ParsedExpression>(*this);
-}
-
-bool OperatorExpression::Equal(const OperatorExpression &a, const OperatorExpression &b) {
-	if (a.children.size() != b.children.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.children.size(); i++) {
-		if (!a.children[i]->Equals(*b.children[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
-	auto copy = make_uniq<OperatorExpression>(type);
-	copy->CopyProperties(*this);
-	for (auto &it : children) {
-		copy->children.push_back(it->Copy());
-	}
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/parameter_expression.cpp b/src/duckdb/src/parser/expression/parameter_expression.cpp
deleted file mode 100644
index 034c4eaef..000000000
--- a/src/duckdb/src/parser/expression/parameter_expression.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/parser/expression/parameter_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/to_string.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-ParameterExpression::ParameterExpression()
-    : ParsedExpression(ExpressionType::VALUE_PARAMETER, ExpressionClass::PARAMETER) {
-}
-
-string ParameterExpression::ToString() const {
-	return "$" + identifier;
-}
-
-unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
-	auto copy = make_uniq<ParameterExpression>();
-	copy->identifier = identifier;
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-bool ParameterExpression::Equal(const ParameterExpression &a, const ParameterExpression &b) {
-	return StringUtil::CIEquals(a.identifier, b.identifier);
-}
-
-hash_t ParameterExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	return CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/positional_reference_expression.cpp b/src/duckdb/src/parser/expression/positional_reference_expression.cpp
deleted file mode 100644
index e73bbeddf..000000000
--- a/src/duckdb/src/parser/expression/positional_reference_expression.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/to_string.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-PositionalReferenceExpression::PositionalReferenceExpression()
-    : ParsedExpression(ExpressionType::POSITIONAL_REFERENCE, ExpressionClass::POSITIONAL_REFERENCE) {
-}
-
-PositionalReferenceExpression::PositionalReferenceExpression(idx_t index)
-    : ParsedExpression(ExpressionType::POSITIONAL_REFERENCE, ExpressionClass::POSITIONAL_REFERENCE), index(index) {
-}
-
-string PositionalReferenceExpression::ToString() const {
-	return "#" + to_string(index);
-}
-
-bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression &a,
-                                          const PositionalReferenceExpression &b) {
-	return a.index == b.index;
-}
-
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Copy() const {
-	auto copy = make_uniq<PositionalReferenceExpression>(index);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-hash_t PositionalReferenceExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	return CombineHash(duckdb::Hash(index), result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/star_expression.cpp b/src/duckdb/src/parser/expression/star_expression.cpp
deleted file mode 100644
index 22279f121..000000000
--- a/src/duckdb/src/parser/expression/star_expression.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include "duckdb/parser/expression/star_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-StarExpression::StarExpression(string relation_name_p)
-    : ParsedExpression(ExpressionType::STAR, ExpressionClass::STAR), relation_name(std::move(relation_name_p)) {
-}
-
-string StarExpression::ToString() const {
-	string result;
-	if (unpacked) {
-		D_ASSERT(columns);
-		result += "*";
-	}
-	if (expr) {
-		D_ASSERT(columns);
-		result += "COLUMNS(" + expr->ToString() + ")";
-		return result;
-	}
-	if (columns) {
-		result += "COLUMNS(";
-	}
-	result += relation_name.empty() ? "*" : relation_name + ".*";
-	if (!exclude_list.empty()) {
-		result += " EXCLUDE (";
-		bool first_entry = true;
-		for (auto &entry : exclude_list) {
-			if (!first_entry) {
-				result += ", ";
-			}
-			result += entry.ToString();
-			first_entry = false;
-		}
-		result += ")";
-	}
-	if (!replace_list.empty()) {
-		result += " REPLACE (";
-		bool first_entry = true;
-		for (auto &entry : replace_list) {
-			if (!first_entry) {
-				result += ", ";
-			}
-			result += entry.second->ToString();
-			result += " AS ";
-			result += KeywordHelper::WriteOptionallyQuoted(entry.first);
-			first_entry = false;
-		}
-		result += ")";
-	}
-	if (!rename_list.empty()) {
-		result += " RENAME (";
-		bool first_entry = true;
-		for (auto &entry : rename_list) {
-			if (!first_entry) {
-				result += ", ";
-			}
-			result += entry.first.ToString();
-			result += " AS ";
-			result += KeywordHelper::WriteOptionallyQuoted(entry.second);
-			first_entry = false;
-		}
-		result += ")";
-	}
-	if (columns) {
-		result += ")";
-	}
-	return result;
-}
-
-bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
-	if (a.relation_name != b.relation_name || a.exclude_list != b.exclude_list || a.rename_list != b.rename_list) {
-		return false;
-	}
-	if (a.columns != b.columns) {
-		return false;
-	}
-	if (a.unpacked != b.unpacked) {
-		return false;
-	}
-	if (a.replace_list.size() != b.replace_list.size()) {
-		return false;
-	}
-	for (auto &entry : a.replace_list) {
-		auto other_entry = b.replace_list.find(entry.first);
-		if (other_entry == b.replace_list.end()) {
-			return false;
-		}
-		if (!entry.second->Equals(*other_entry->second)) {
-			return false;
-		}
-	}
-	if (!ParsedExpression::Equals(a.expr, b.expr)) {
-		return false;
-	}
-	return true;
-}
-
-bool StarExpression::IsStar(const ParsedExpression &a) {
-	if (a.GetExpressionClass() != ExpressionClass::STAR) {
-		return false;
-	}
-	auto &star = a.Cast<StarExpression>();
-	return star.columns == false;
-}
-
-bool StarExpression::IsColumns(const ParsedExpression &a) {
-	if (a.GetExpressionClass() != ExpressionClass::STAR) {
-		return false;
-	}
-	auto &star = a.Cast<StarExpression>();
-	return star.columns == true && star.unpacked == false;
-}
-
-bool StarExpression::IsColumnsUnpacked(const ParsedExpression &a) {
-	if (a.GetExpressionClass() != ExpressionClass::STAR) {
-		return false;
-	}
-	auto &star = a.Cast<StarExpression>();
-	return star.columns == true && star.unpacked == true;
-}
-
-unique_ptr<ParsedExpression> StarExpression::Copy() const {
-	auto copy = make_uniq<StarExpression>(relation_name);
-	copy->exclude_list = exclude_list;
-	for (auto &entry : replace_list) {
-		copy->replace_list[entry.first] = entry.second->Copy();
-	}
-	copy->rename_list = rename_list;
-	copy->columns = columns;
-	copy->expr = expr ? expr->Copy() : nullptr;
-	copy->CopyProperties(*this);
-	copy->unpacked = unpacked;
-	return std::move(copy);
-}
-
-StarExpression::StarExpression(const case_insensitive_set_t &exclude_list_p, qualified_column_set_t qualified_set)
-    : ParsedExpression(ExpressionType::STAR, ExpressionClass::STAR), exclude_list(std::move(qualified_set)) {
-	for (auto &entry : exclude_list_p) {
-		exclude_list.insert(QualifiedColumnName(entry));
-	}
-}
-
-case_insensitive_set_t StarExpression::SerializedExcludeList() const {
-	// we serialize non-qualified elements in a separate list of only column names for backwards compatibility
-	case_insensitive_set_t result;
-	for (auto &entry : exclude_list) {
-		if (!entry.IsQualified()) {
-			result.insert(entry.column);
-		}
-	}
-	return result;
-}
-
-qualified_column_set_t StarExpression::SerializedQualifiedExcludeList() const {
-	// we serialize only qualified elements in the qualified list for backwards compatibility
-	qualified_column_set_t result;
-	for (auto &entry : exclude_list) {
-		if (entry.IsQualified()) {
-			result.insert(entry);
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/subquery_expression.cpp b/src/duckdb/src/parser/expression/subquery_expression.cpp
deleted file mode 100644
index 2cc1e4548..000000000
--- a/src/duckdb/src/parser/expression/subquery_expression.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/parser/expression/subquery_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-
-SubqueryExpression::SubqueryExpression()
-    : ParsedExpression(ExpressionType::SUBQUERY, ExpressionClass::SUBQUERY), subquery_type(SubqueryType::INVALID),
-      comparison_type(ExpressionType::INVALID) {
-}
-
-string SubqueryExpression::ToString() const {
-	switch (subquery_type) {
-	case SubqueryType::ANY:
-		return "(" + child->ToString() + " " + ExpressionTypeToOperator(comparison_type) + " ANY(" +
-		       subquery->ToString() + "))";
-	case SubqueryType::EXISTS:
-		return "EXISTS(" + subquery->ToString() + ")";
-	case SubqueryType::NOT_EXISTS:
-		return "NOT EXISTS(" + subquery->ToString() + ")";
-	case SubqueryType::SCALAR:
-		return "(" + subquery->ToString() + ")";
-	default:
-		throw InternalException("Unrecognized type for subquery");
-	}
-}
-
-bool SubqueryExpression::Equal(const SubqueryExpression &a, const SubqueryExpression &b) {
-	if (!a.subquery || !b.subquery) {
-		return false;
-	}
-	if (!ParsedExpression::Equals(a.child, b.child)) {
-		return false;
-	}
-	return a.comparison_type == b.comparison_type && a.subquery_type == b.subquery_type &&
-	       a.subquery->Equals(*b.subquery);
-}
-
-unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
-	auto copy = make_uniq<SubqueryExpression>();
-	copy->CopyProperties(*this);
-	copy->subquery = unique_ptr_cast<SQLStatement, SelectStatement>(subquery->Copy());
-	copy->subquery_type = subquery_type;
-	copy->child = child ? child->Copy() : nullptr;
-	copy->comparison_type = comparison_type;
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression/window_expression.cpp b/src/duckdb/src/parser/expression/window_expression.cpp
deleted file mode 100644
index 666bfbd3f..000000000
--- a/src/duckdb/src/parser/expression/window_expression.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include "duckdb/parser/expression/window_expression.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-WindowExpression::WindowExpression(ExpressionType type) : ParsedExpression(type, ExpressionClass::WINDOW) {
-}
-
-WindowExpression::WindowExpression(ExpressionType type, string catalog_name, string schema, const string &function_name)
-    : ParsedExpression(type, ExpressionClass::WINDOW), catalog(std::move(catalog_name)), schema(std::move(schema)),
-      function_name(StringUtil::Lower(function_name)), ignore_nulls(false), distinct(false) {
-	switch (type) {
-	case ExpressionType::WINDOW_AGGREGATE:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_NTH_VALUE:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_CUME_DIST:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-	case ExpressionType::WINDOW_NTILE:
-		break;
-	default:
-		throw NotImplementedException("Window aggregate type %s not supported", ExpressionTypeToString(type).c_str());
-	}
-}
-
-ExpressionType WindowExpression::WindowToExpressionType(string &fun_name) {
-	if (fun_name == "rank") {
-		return ExpressionType::WINDOW_RANK;
-	} else if (fun_name == "rank_dense" || fun_name == "dense_rank") {
-		return ExpressionType::WINDOW_RANK_DENSE;
-	} else if (fun_name == "percent_rank") {
-		return ExpressionType::WINDOW_PERCENT_RANK;
-	} else if (fun_name == "row_number") {
-		return ExpressionType::WINDOW_ROW_NUMBER;
-	} else if (fun_name == "first_value" || fun_name == "first") {
-		return ExpressionType::WINDOW_FIRST_VALUE;
-	} else if (fun_name == "last_value" || fun_name == "last") {
-		return ExpressionType::WINDOW_LAST_VALUE;
-	} else if (fun_name == "nth_value") {
-		return ExpressionType::WINDOW_NTH_VALUE;
-	} else if (fun_name == "cume_dist") {
-		return ExpressionType::WINDOW_CUME_DIST;
-	} else if (fun_name == "lead") {
-		return ExpressionType::WINDOW_LEAD;
-	} else if (fun_name == "lag") {
-		return ExpressionType::WINDOW_LAG;
-	} else if (fun_name == "ntile") {
-		return ExpressionType::WINDOW_NTILE;
-	}
-	return ExpressionType::WINDOW_AGGREGATE;
-}
-
-string WindowExpression::ToString() const {
-	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
-}
-
-bool WindowExpression::Equal(const WindowExpression &a, const WindowExpression &b) {
-	// check if the child expressions are equivalent
-	if (a.ignore_nulls != b.ignore_nulls) {
-		return false;
-	}
-	if (a.distinct != b.distinct) {
-		return false;
-	}
-	if (!ParsedExpression::ListEquals(a.children, b.children)) {
-		return false;
-	}
-	if (a.start != b.start || a.end != b.end) {
-		return false;
-	}
-	if (a.exclude_clause != b.exclude_clause) {
-		return false;
-	}
-	// check if the framing expressions are equivalent
-	if (!ParsedExpression::Equals(a.start_expr, b.start_expr) || !ParsedExpression::Equals(a.end_expr, b.end_expr) ||
-	    !ParsedExpression::Equals(a.offset_expr, b.offset_expr) ||
-	    !ParsedExpression::Equals(a.default_expr, b.default_expr)) {
-		return false;
-	}
-
-	// check if the argument orderings are equivalent
-	if (a.arg_orders.size() != b.arg_orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.arg_orders.size(); i++) {
-		if (a.arg_orders[i].type != b.arg_orders[i].type) {
-			return false;
-		}
-		if (a.arg_orders[i].null_order != b.arg_orders[i].null_order) {
-			return false;
-		}
-		if (!a.arg_orders[i].expression->Equals(*b.arg_orders[i].expression)) {
-			return false;
-		}
-	}
-
-	// check if the partitions are equivalent
-	if (!ParsedExpression::ListEquals(a.partitions, b.partitions)) {
-		return false;
-	}
-	// check if the orderings are equivalent
-	if (a.orders.size() != b.orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.orders.size(); i++) {
-		if (a.orders[i].type != b.orders[i].type) {
-			return false;
-		}
-		if (a.orders[i].null_order != b.orders[i].null_order) {
-			return false;
-		}
-		if (!a.orders[i].expression->Equals(*b.orders[i].expression)) {
-			return false;
-		}
-	}
-	// check if the filter clauses are equivalent
-	if (!ParsedExpression::Equals(a.filter_expr, b.filter_expr)) {
-		return false;
-	}
-
-	return true;
-}
-
-unique_ptr<ParsedExpression> WindowExpression::Copy() const {
-	auto new_window = make_uniq<WindowExpression>(type, catalog, schema, function_name);
-	new_window->CopyProperties(*this);
-
-	for (auto &child : children) {
-		new_window->children.push_back(child->Copy());
-	}
-
-	for (auto &e : partitions) {
-		new_window->partitions.push_back(e->Copy());
-	}
-
-	for (auto &o : orders) {
-		new_window->orders.emplace_back(o.type, o.null_order, o.expression->Copy());
-	}
-
-	for (auto &o : arg_orders) {
-		new_window->arg_orders.emplace_back(o.type, o.null_order, o.expression->Copy());
-	}
-
-	new_window->filter_expr = filter_expr ? filter_expr->Copy() : nullptr;
-
-	new_window->start = start;
-	new_window->end = end;
-	new_window->exclude_clause = exclude_clause;
-	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
-	new_window->end_expr = end_expr ? end_expr->Copy() : nullptr;
-	new_window->offset_expr = offset_expr ? offset_expr->Copy() : nullptr;
-	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
-	new_window->ignore_nulls = ignore_nulls;
-	new_window->distinct = distinct;
-
-	return std::move(new_window);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/expression_util.cpp b/src/duckdb/src/parser/expression_util.cpp
deleted file mode 100644
index 76ffddc59..000000000
--- a/src/duckdb/src/parser/expression_util.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#include "duckdb/parser/expression_util.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/expression_map.hpp"
-
-namespace duckdb {
-
-template <class T>
-bool ExpressionUtil::ExpressionListEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
-	if (a.size() != b.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.size(); i++) {
-		if (!(*a[i] == *b[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-template <class T, class EXPRESSION_MAP>
-bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
-	if (a.size() != b.size()) {
-		return false;
-	}
-	// we create a map of expression -> count for the left side
-	// we keep the count because the same expression can occur multiple times (e.g. "1 AND 1" is legal)
-	// in this case we track the following value: map["Constant(1)"] = 2
-	EXPRESSION_MAP map;
-	for (idx_t i = 0; i < a.size(); i++) {
-		map[*a[i]]++;
-	}
-	// now on the right side we reduce the counts again
-	// if the conjunctions are identical, all the counts will be 0 after the
-	for (auto &expr : b) {
-		auto entry = map.find(*expr);
-		// first we check if we can find the expression in the map at all
-		if (entry == map.end()) {
-			return false;
-		}
-		// if we found it we check the count; if the count is already 0 we return false
-		// this happens if e.g. the left side contains "1 AND X", and the right side contains "1 AND 1"
-		// "1" is contained in the map, however, the right side contains the expression twice
-		// hence we know the children are not identical in this case because the LHS and RHS have a different count for
-		// the Constant(1) expression
-		if (entry->second == 0) {
-			return false;
-		}
-		entry->second--;
-	}
-	return true;
-}
-
-bool ExpressionUtil::ListEquals(const vector<unique_ptr<ParsedExpression>> &a,
-                                const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionListEquals<ParsedExpression>(a, b);
-}
-
-bool ExpressionUtil::ListEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionListEquals<Expression>(a, b);
-}
-
-bool ExpressionUtil::SetEquals(const vector<unique_ptr<ParsedExpression>> &a,
-                               const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionSetEquals<ParsedExpression, parsed_expression_map_t<idx_t>>(a, b);
-}
-
-bool ExpressionUtil::SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionSetEquals<Expression, expression_map_t<idx_t>>(a, b);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/keyword_helper.cpp b/src/duckdb/src/parser/keyword_helper.cpp
deleted file mode 100644
index 80cea773b..000000000
--- a/src/duckdb/src/parser/keyword_helper.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-bool KeywordHelper::IsKeyword(const string &text) {
-	return Parser::IsKeyword(text) != KeywordCategory::KEYWORD_NONE;
-}
-
-KeywordCategory KeywordHelper::KeywordCategoryType(const string &text) {
-	return Parser::IsKeyword(text);
-}
-
-bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps) {
-	for (size_t i = 0; i < text.size(); i++) {
-		if (i > 0 && (text[i] >= '0' && text[i] <= '9')) {
-			continue;
-		}
-		if (text[i] >= 'a' && text[i] <= 'z') {
-			continue;
-		}
-		if (allow_caps) {
-			if (text[i] >= 'A' && text[i] <= 'Z') {
-				continue;
-			}
-		}
-		if (text[i] == '_') {
-			continue;
-		}
-		return true;
-	}
-	return IsKeyword(text);
-}
-
-string KeywordHelper::EscapeQuotes(const string &text, char quote) {
-	return StringUtil::Replace(text, string(1, quote), string(2, quote));
-}
-
-string KeywordHelper::WriteQuoted(const string &text, char quote) {
-	// 1. Escapes all occurences of 'quote' by doubling them (escape in SQL)
-	// 2. Adds quotes around the string
-	return string(1, quote) + EscapeQuotes(text, quote) + string(1, quote);
-}
-
-string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote, bool allow_caps) {
-	if (!RequiresQuotes(text, allow_caps)) {
-		return text;
-	}
-	return WriteQuoted(text, quote);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/alter_info.cpp b/src/duckdb/src/parser/parsed_data/alter_info.cpp
deleted file mode 100644
index 2f90d0abf..000000000
--- a/src/duckdb/src/parser/parsed_data/alter_info.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-
-#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-
-namespace duckdb {
-
-AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
-    : ParseInfo(TYPE), type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)),
-      schema(std::move(schema_p)), name(std::move(name_p)), allow_internal(false) {
-}
-
-AlterInfo::AlterInfo(AlterType type) : ParseInfo(TYPE), type(type) {
-}
-
-AlterInfo::~AlterInfo() {
-}
-
-AlterEntryData AlterInfo::GetAlterEntryData() const {
-	AlterEntryData data;
-	data.catalog = catalog;
-	data.schema = schema;
-	data.name = name;
-	data.if_not_found = if_not_found;
-	return data;
-}
-
-bool AlterInfo::IsAddPrimaryKey() const {
-	if (type != AlterType::ALTER_TABLE) {
-		return false;
-	}
-
-	auto &table_info = Cast<AlterTableInfo>();
-	if (table_info.alter_table_type != AlterTableType::ADD_CONSTRAINT) {
-		return false;
-	}
-
-	auto &constraint_info = table_info.Cast<AddConstraintInfo>();
-	if (constraint_info.constraint->type != ConstraintType::UNIQUE) {
-		return false;
-	}
-
-	auto &unique_info = constraint_info.constraint->Cast<UniqueConstraint>();
-	if (!unique_info.IsPrimaryKey()) {
-		return false;
-	}
-
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp b/src/duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp
deleted file mode 100644
index 3de4fc52a..000000000
--- a/src/duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/constraint.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// AlterScalarFunctionInfo
-//===--------------------------------------------------------------------===//
-AlterScalarFunctionInfo::AlterScalarFunctionInfo(AlterScalarFunctionType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_SCALAR_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_not_found),
-      alter_scalar_function_type(type) {
-}
-AlterScalarFunctionInfo::~AlterScalarFunctionInfo() {
-}
-
-CatalogType AlterScalarFunctionInfo::GetCatalogType() const {
-	return CatalogType::SCALAR_FUNCTION_ENTRY;
-}
-
-//===--------------------------------------------------------------------===//
-// AddScalarFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-AddScalarFunctionOverloadInfo::AddScalarFunctionOverloadInfo(AlterEntryData data,
-                                                             unique_ptr<CreateScalarFunctionInfo> new_overloads_p)
-    : AlterScalarFunctionInfo(AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS, std::move(data)),
-      new_overloads(std::move(new_overloads_p)) {
-	this->allow_internal = true;
-}
-
-AddScalarFunctionOverloadInfo::~AddScalarFunctionOverloadInfo() {
-}
-
-unique_ptr<AlterInfo> AddScalarFunctionOverloadInfo::Copy() const {
-	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(
-	    GetAlterEntryData(), unique_ptr_cast<CreateInfo, CreateScalarFunctionInfo>(new_overloads->Copy()));
-}
-
-string AddScalarFunctionOverloadInfo::ToString() const {
-	throw NotImplementedException("NOT PARSABLE CURRENTLY");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/alter_table_function_info.cpp b/src/duckdb/src/parser/parsed_data/alter_table_function_info.cpp
deleted file mode 100644
index e7ce608c8..000000000
--- a/src/duckdb/src/parser/parsed_data/alter_table_function_info.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
-
-#include "duckdb/parser/constraint.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// AlterTableFunctionInfo
-//===--------------------------------------------------------------------===//
-AlterTableFunctionInfo::AlterTableFunctionInfo(AlterTableFunctionType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_TABLE_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_not_found),
-      alter_table_function_type(type) {
-}
-AlterTableFunctionInfo::~AlterTableFunctionInfo() {
-}
-
-CatalogType AlterTableFunctionInfo::GetCatalogType() const {
-	return CatalogType::TABLE_FUNCTION_ENTRY;
-}
-
-//===--------------------------------------------------------------------===//
-// AddTableFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-AddTableFunctionOverloadInfo::AddTableFunctionOverloadInfo(AlterEntryData data, TableFunctionSet new_overloads_p)
-    : AlterTableFunctionInfo(AlterTableFunctionType::ADD_FUNCTION_OVERLOADS, std::move(data)),
-      new_overloads(std::move(new_overloads_p)) {
-	this->allow_internal = true;
-}
-
-AddTableFunctionOverloadInfo::~AddTableFunctionOverloadInfo() {
-}
-
-unique_ptr<AlterInfo> AddTableFunctionOverloadInfo::Copy() const {
-	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
-}
-
-string AddTableFunctionOverloadInfo::ToString() const {
-	throw NotImplementedException("NOT PARSABLE");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/alter_table_info.cpp b/src/duckdb/src/parser/parsed_data/alter_table_info.cpp
deleted file mode 100644
index ddf7db07d..000000000
--- a/src/duckdb/src/parser/parsed_data/alter_table_info.cpp
+++ /dev/null
@@ -1,476 +0,0 @@
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-
-#include "duckdb/parser/constraint.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// ChangeOwnershipInfo
-//===--------------------------------------------------------------------===//
-ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog_p, string entry_schema_p,
-                                         string entry_name_p, string owner_schema_p, string owner_name_p,
-                                         OnEntryNotFound if_not_found)
-    : AlterInfo(AlterType::CHANGE_OWNERSHIP, std::move(entry_catalog_p), std::move(entry_schema_p),
-                std::move(entry_name_p), if_not_found),
-      entry_catalog_type(entry_catalog_type), owner_schema(std::move(owner_schema_p)),
-      owner_name(std::move(owner_name_p)) {
-}
-
-ChangeOwnershipInfo::ChangeOwnershipInfo() : AlterInfo(AlterType::CHANGE_OWNERSHIP) {
-}
-
-CatalogType ChangeOwnershipInfo::GetCatalogType() const {
-	return entry_catalog_type;
-}
-
-unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
-	return make_uniq_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, catalog, schema, name, owner_schema,
-	                                                      owner_name, if_not_found);
-}
-
-string ChangeOwnershipInfo::ToString() const {
-	string result = "";
-
-	result += "ALTER ";
-	result += TypeToString(entry_catalog_type);
-	result += " ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += "IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " OWNED BY ";
-	result += QualifierToString(catalog, owner_schema, owner_name);
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// SetCommentInfo
-//===--------------------------------------------------------------------===//
-SetCommentInfo::SetCommentInfo(CatalogType entry_catalog_type, string entry_catalog_p, string entry_schema_p,
-                               string entry_name_p, Value new_comment_value_p, OnEntryNotFound if_not_found)
-    : AlterInfo(AlterType::SET_COMMENT, std::move(entry_catalog_p), std::move(entry_schema_p), std::move(entry_name_p),
-                if_not_found),
-      entry_catalog_type(entry_catalog_type), comment_value(std::move(new_comment_value_p)) {
-}
-
-CatalogType SetCommentInfo::GetCatalogType() const {
-	return entry_catalog_type;
-}
-
-unique_ptr<AlterInfo> SetCommentInfo::Copy() const {
-	return make_uniq_base<AlterInfo, SetCommentInfo>(entry_catalog_type, catalog, schema, name, comment_value,
-	                                                 if_not_found);
-}
-
-string SetCommentInfo::ToString() const {
-	string result = "";
-
-	result += "COMMENT ON ";
-	result += ParseInfo::TypeToString(entry_catalog_type);
-	result += " ";
-	result += QualifierToString(catalog, schema, name);
-	result += " IS ";
-	result += comment_value.ToSQLString();
-
-	result += ";";
-	return result;
-}
-
-SetCommentInfo::SetCommentInfo() : AlterInfo(AlterType::SET_COMMENT) {
-}
-
-//===--------------------------------------------------------------------===//
-// AlterTableInfo
-//===--------------------------------------------------------------------===//
-AlterTableInfo::AlterTableInfo(AlterTableType type) : AlterInfo(AlterType::ALTER_TABLE), alter_table_type(type) {
-}
-
-AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_not_found),
-      alter_table_type(type) {
-}
-AlterTableInfo::~AlterTableInfo() {
-}
-
-CatalogType AlterTableInfo::GetCatalogType() const {
-	return CatalogType::TABLE_ENTRY;
-}
-//===--------------------------------------------------------------------===//
-// RenameColumnInfo
-//===--------------------------------------------------------------------===//
-RenameColumnInfo::RenameColumnInfo(AlterEntryData data, string old_name_p, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_COLUMN, std::move(data)), old_name(std::move(old_name_p)),
-      new_name(std::move(new_name_p)) {
-}
-
-RenameColumnInfo::RenameColumnInfo() : AlterTableInfo(AlterTableType::RENAME_COLUMN) {
-}
-
-RenameColumnInfo::~RenameColumnInfo() {
-}
-
-unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
-	return make_uniq_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
-}
-
-string RenameColumnInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " RENAME COLUMN ";
-	result += KeywordHelper::WriteOptionallyQuoted(old_name);
-	result += " TO ";
-	result += KeywordHelper::WriteOptionallyQuoted(new_name);
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// RenameTableInfo
-//===--------------------------------------------------------------------===//
-RenameTableInfo::RenameTableInfo() : AlterTableInfo(AlterTableType::RENAME_TABLE) {
-}
-
-RenameTableInfo::RenameTableInfo(AlterEntryData data, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_TABLE, std::move(data)), new_table_name(std::move(new_name_p)) {
-}
-
-RenameTableInfo::~RenameTableInfo() {
-}
-
-unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
-	return make_uniq_base<AlterInfo, RenameTableInfo>(GetAlterEntryData(), new_table_name);
-}
-
-string RenameTableInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " RENAME TO ";
-	result += KeywordHelper::WriteOptionallyQuoted(new_table_name);
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// AddColumnInfo
-//===--------------------------------------------------------------------===//
-AddColumnInfo::AddColumnInfo(ColumnDefinition new_column_p)
-    : AlterTableInfo(AlterTableType::ADD_COLUMN), new_column(std::move(new_column_p)) {
-}
-
-AddColumnInfo::AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists)
-    : AlterTableInfo(AlterTableType::ADD_COLUMN, std::move(data)), new_column(std::move(new_column)),
-      if_column_not_exists(if_column_not_exists) {
-}
-
-AddColumnInfo::~AddColumnInfo() {
-}
-
-unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
-	return make_uniq_base<AlterInfo, AddColumnInfo>(GetAlterEntryData(), new_column.Copy(), if_column_not_exists);
-}
-
-string AddColumnInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " ADD COLUMN";
-	if (if_column_not_exists) {
-		result += " IF NOT EXISTS";
-	}
-	throw NotImplementedException("COLUMN SERIALIZATION");
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// RemoveColumnInfo
-//===--------------------------------------------------------------------===//
-RemoveColumnInfo::RemoveColumnInfo() : AlterTableInfo(AlterTableType::REMOVE_COLUMN) {
-}
-
-RemoveColumnInfo::RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade)
-    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, std::move(data)), removed_column(std::move(removed_column)),
-      if_column_exists(if_column_exists), cascade(cascade) {
-}
-RemoveColumnInfo::~RemoveColumnInfo() {
-}
-
-unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
-	return make_uniq_base<AlterInfo, RemoveColumnInfo>(GetAlterEntryData(), removed_column, if_column_exists, cascade);
-}
-
-string RemoveColumnInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " DROP COLUMN ";
-	if (if_column_exists) {
-		result += "IF EXISTS ";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(removed_column);
-	if (cascade) {
-		result += " CASCADE";
-	}
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// ChangeColumnTypeInfo
-//===--------------------------------------------------------------------===//
-ChangeColumnTypeInfo::ChangeColumnTypeInfo() : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE) {
-}
-
-ChangeColumnTypeInfo::ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
-                                           unique_ptr<ParsedExpression> expression)
-    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, std::move(data)), column_name(std::move(column_name)),
-      target_type(std::move(target_type)), expression(std::move(expression)) {
-}
-ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
-}
-
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
-	return make_uniq_base<AlterInfo, ChangeColumnTypeInfo>(GetAlterEntryData(), column_name, target_type,
-	                                                       expression->Copy());
-}
-
-string ChangeColumnTypeInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " ALTER COLUMN ";
-	result += KeywordHelper::WriteOptionallyQuoted(column_name);
-	result += " TYPE ";
-	if (target_type.IsValid()) {
-		result += target_type.ToString();
-	}
-	auto extra_type_info = target_type.AuxInfo();
-	if (extra_type_info && extra_type_info->type == ExtraTypeInfoType::STRING_TYPE_INFO) {
-		auto &string_info = extra_type_info->Cast<StringTypeInfo>();
-		if (!string_info.collation.empty()) {
-			result += " COLLATE " + string_info.collation;
-		}
-	}
-	if (expression) {
-		result += " USING ";
-		result += expression->ToString();
-	}
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// SetDefaultInfo
-//===--------------------------------------------------------------------===//
-SetDefaultInfo::SetDefaultInfo() : AlterTableInfo(AlterTableType::SET_DEFAULT) {
-}
-
-SetDefaultInfo::SetDefaultInfo(AlterEntryData data, string column_name_p, unique_ptr<ParsedExpression> new_default)
-    : AlterTableInfo(AlterTableType::SET_DEFAULT, std::move(data)), column_name(std::move(column_name_p)),
-      expression(std::move(new_default)) {
-}
-SetDefaultInfo::~SetDefaultInfo() {
-}
-
-unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
-	return make_uniq_base<AlterInfo, SetDefaultInfo>(GetAlterEntryData(), column_name,
-	                                                 expression ? expression->Copy() : nullptr);
-}
-
-string SetDefaultInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " ALTER COLUMN ";
-	result += KeywordHelper::WriteOptionallyQuoted(column_name);
-	if (expression) {
-		result += " SET DEFAULT ";
-		result += expression->ToString();
-	} else {
-		result += " DROP DEFAULT";
-	}
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// SetNotNullInfo
-//===--------------------------------------------------------------------===//
-SetNotNullInfo::SetNotNullInfo() : AlterTableInfo(AlterTableType::SET_NOT_NULL) {
-}
-
-SetNotNullInfo::SetNotNullInfo(AlterEntryData data, string column_name_p)
-    : AlterTableInfo(AlterTableType::SET_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
-}
-SetNotNullInfo::~SetNotNullInfo() {
-}
-
-unique_ptr<AlterInfo> SetNotNullInfo::Copy() const {
-	return make_uniq_base<AlterInfo, SetNotNullInfo>(GetAlterEntryData(), column_name);
-}
-
-string SetNotNullInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " ALTER COLUMN ";
-	result += KeywordHelper::WriteOptionallyQuoted(column_name);
-	result += " SET NOT NULL";
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// DropNotNullInfo
-//===--------------------------------------------------------------------===//
-DropNotNullInfo::DropNotNullInfo() : AlterTableInfo(AlterTableType::DROP_NOT_NULL) {
-}
-
-DropNotNullInfo::DropNotNullInfo(AlterEntryData data, string column_name_p)
-    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
-}
-DropNotNullInfo::~DropNotNullInfo() {
-}
-
-unique_ptr<AlterInfo> DropNotNullInfo::Copy() const {
-	return make_uniq_base<AlterInfo, DropNotNullInfo>(GetAlterEntryData(), column_name);
-}
-
-string DropNotNullInfo::ToString() const {
-	string result = "";
-	result += "ALTER TABLE ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " ALTER COLUMN ";
-	result += KeywordHelper::WriteOptionallyQuoted(column_name);
-	result += " DROP NOT NULL";
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// AlterForeignKeyInfo
-//===--------------------------------------------------------------------===//
-AlterForeignKeyInfo::AlterForeignKeyInfo() : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT) {
-}
-
-AlterForeignKeyInfo::AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns,
-                                         vector<string> fk_columns, vector<PhysicalIndex> pk_keys,
-                                         vector<PhysicalIndex> fk_keys, AlterForeignKeyType type_p)
-    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, std::move(data)), fk_table(std::move(fk_table)),
-      pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)), pk_keys(std::move(pk_keys)),
-      fk_keys(std::move(fk_keys)), type(type_p) {
-}
-AlterForeignKeyInfo::~AlterForeignKeyInfo() {
-}
-
-unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
-	return make_uniq_base<AlterInfo, AlterForeignKeyInfo>(GetAlterEntryData(), fk_table, pk_columns, fk_columns,
-	                                                      pk_keys, fk_keys, type);
-}
-
-string AlterForeignKeyInfo::ToString() const {
-	throw NotImplementedException("NOT PARSABLE CURRENTLY");
-}
-
-//===--------------------------------------------------------------------===//
-// Alter View
-//===--------------------------------------------------------------------===//
-AlterViewInfo::AlterViewInfo(AlterViewType type) : AlterInfo(AlterType::ALTER_VIEW), alter_view_type(type) {
-}
-
-AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_not_found),
-      alter_view_type(type) {
-}
-AlterViewInfo::~AlterViewInfo() {
-}
-
-CatalogType AlterViewInfo::GetCatalogType() const {
-	return CatalogType::VIEW_ENTRY;
-}
-
-//===--------------------------------------------------------------------===//
-// RenameViewInfo
-//===--------------------------------------------------------------------===//
-RenameViewInfo::RenameViewInfo() : AlterViewInfo(AlterViewType::RENAME_VIEW) {
-}
-RenameViewInfo::RenameViewInfo(AlterEntryData data, string new_name_p)
-    : AlterViewInfo(AlterViewType::RENAME_VIEW, std::move(data)), new_view_name(std::move(new_name_p)) {
-}
-RenameViewInfo::~RenameViewInfo() {
-}
-
-unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
-	return make_uniq_base<AlterInfo, RenameViewInfo>(GetAlterEntryData(), new_view_name);
-}
-
-string RenameViewInfo::ToString() const {
-	string result = "";
-	result += "ALTER VIEW ";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += QualifierToString(catalog, schema, name);
-	result += " RENAME TO ";
-	result += KeywordHelper::WriteOptionallyQuoted(new_view_name);
-	result += ";";
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// AddConstraintInfo
-//===--------------------------------------------------------------------===//
-AddConstraintInfo::AddConstraintInfo() : AlterTableInfo(AlterTableType::ADD_CONSTRAINT) {
-}
-
-AddConstraintInfo::AddConstraintInfo(AlterEntryData data, unique_ptr<Constraint> constraint_p)
-    : AlterTableInfo(AlterTableType::ADD_CONSTRAINT, std::move(data)), constraint(std::move(constraint_p)) {
-}
-
-AddConstraintInfo::~AddConstraintInfo() {
-}
-
-unique_ptr<AlterInfo> AddConstraintInfo::Copy() const {
-	return make_uniq_base<AlterInfo, AddConstraintInfo>(GetAlterEntryData(), constraint->Copy());
-}
-
-string AddConstraintInfo::ToString() const {
-	string result = "ALTER TABLE ";
-	result += QualifierToString(catalog, schema, name);
-	result += " ADD ";
-	result += constraint->ToString();
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/attach_info.cpp b/src/duckdb/src/parser/parsed_data/attach_info.cpp
deleted file mode 100644
index 3ad50d8bb..000000000
--- a/src/duckdb/src/parser/parsed_data/attach_info.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-#include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-StorageOptions AttachInfo::GetStorageOptions() const {
-	StorageOptions storage_options;
-	for (auto &entry : options) {
-		if (entry.first == "block_size") {
-			// Extract the block allocation size. This is NOT the actual memory available on a block (block_size),
-			// even though the corresponding option we expose to the user is called "block_size".
-			storage_options.block_alloc_size = entry.second.GetValue<uint64_t>();
-		} else if (entry.first == "row_group_size") {
-			storage_options.row_group_size = entry.second.GetValue<uint64_t>();
-		}
-	}
-	return storage_options;
-}
-
-unique_ptr<AttachInfo> AttachInfo::Copy() const {
-	auto result = make_uniq<AttachInfo>();
-	result->name = name;
-	result->path = path;
-	result->options = options;
-	result->on_conflict = on_conflict;
-	return result;
-}
-
-string AttachInfo::ToString() const {
-	string result = "";
-	result += "ATTACH";
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		result += " IF NOT EXISTS";
-	}
-	result += " DATABASE";
-	result += StringUtil::Format(" '%s'", path);
-	if (!name.empty()) {
-		result += " AS " + KeywordHelper::WriteOptionallyQuoted(name);
-	}
-	if (!options.empty()) {
-		vector<string> stringified;
-		for (auto &opt : options) {
-			stringified.push_back(StringUtil::Format("%s %s", opt.first, opt.second.ToSQLString()));
-		}
-		result += " (" + StringUtil::Join(stringified, ", ") + ")";
-	}
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/comment_on_column_info.cpp b/src/duckdb/src/parser/parsed_data/comment_on_column_info.cpp
deleted file mode 100644
index 4bc332482..000000000
--- a/src/duckdb/src/parser/parsed_data/comment_on_column_info.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry_retriever.hpp"
-
-namespace duckdb {
-
-SetColumnCommentInfo::SetColumnCommentInfo()
-    : AlterInfo(AlterType::SET_COLUMN_COMMENT, INVALID_CATALOG, INVALID_SCHEMA, "", OnEntryNotFound::THROW_EXCEPTION),
-      catalog_entry_type(CatalogType::INVALID), column_name(""), comment_value(Value()) {
-}
-
-SetColumnCommentInfo::SetColumnCommentInfo(string catalog, string schema, string name, string column_name,
-                                           Value comment_value, OnEntryNotFound if_not_found)
-    : AlterInfo(AlterType::SET_COLUMN_COMMENT, std::move(catalog), std::move(schema), std::move(name), if_not_found),
-      catalog_entry_type(CatalogType::INVALID), column_name(std::move(column_name)),
-      comment_value(std::move(comment_value)) {
-}
-
-unique_ptr<AlterInfo> SetColumnCommentInfo::Copy() const {
-	auto result = make_uniq<SetColumnCommentInfo>(catalog, schema, name, column_name, comment_value, if_not_found);
-	result->type = type;
-	return std::move(result);
-}
-
-string SetColumnCommentInfo::ToString() const {
-	string result = "";
-
-	D_ASSERT(catalog_entry_type == CatalogType::INVALID);
-	result += "COMMENT ON COLUMN ";
-	result += QualifierToString(catalog, schema, name);
-	result += " IS ";
-	result += comment_value.ToSQLString();
-	result += ";";
-	return result;
-}
-
-optional_ptr<CatalogEntry> SetColumnCommentInfo::TryResolveCatalogEntry(CatalogEntryRetriever &retriever) {
-	auto entry = retriever.GetEntry(CatalogType::TABLE_ENTRY, catalog, schema, name, if_not_found);
-
-	if (entry) {
-		catalog_entry_type = entry->type;
-		return entry;
-	}
-
-	return nullptr;
-}
-
-// Note: this is a bit of a weird one: the exact type is not yet known: it can be either a view or a column this needs
-//       to be resolved at bind time. If type is invalid here, the CommentOnColumnInfo was not properly resolved first
-CatalogType SetColumnCommentInfo::GetCatalogType() const {
-	if (catalog_entry_type == CatalogType::INVALID) {
-		throw InternalException("Attempted to access unresolved ");
-	}
-	return catalog_entry_type;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/copy_info.cpp b/src/duckdb/src/parser/parsed_data/copy_info.cpp
deleted file mode 100644
index c46263a7f..000000000
--- a/src/duckdb/src/parser/parsed_data/copy_info.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-unique_ptr<CopyInfo> CopyInfo::Copy() const {
-	auto result = make_uniq<CopyInfo>();
-	result->catalog = catalog;
-	result->schema = schema;
-	result->table = table;
-	result->select_list = select_list;
-	result->file_path = file_path;
-	result->is_from = is_from;
-	result->format = format;
-	result->options = options;
-	if (select_statement) {
-		result->select_statement = select_statement->Copy();
-	}
-	return result;
-}
-
-string CopyInfo::CopyOptionsToString(const string &format, const case_insensitive_map_t<vector<Value>> &options) {
-	if (format.empty() && options.empty()) {
-		return string();
-	}
-	string result;
-
-	result += " (";
-	vector<string> stringified;
-	if (!format.empty()) {
-		stringified.push_back(StringUtil::Format(" FORMAT %s", format));
-	}
-	for (auto &opt : options) {
-		auto &name = opt.first;
-		auto &values = opt.second;
-
-		auto option = name + " ";
-		if (values.empty()) {
-			// Options like HEADER don't need an explicit value
-			// just providing the name already sets it to true
-			stringified.push_back(option);
-		} else if (values.size() == 1) {
-			stringified.push_back(option + values[0].ToSQLString());
-		} else {
-			vector<string> sub_values;
-			for (auto &val : values) {
-				sub_values.push_back(val.ToSQLString());
-			}
-			stringified.push_back(option + "( " + StringUtil::Join(sub_values, ", ") + " )");
-		}
-	}
-	result += StringUtil::Join(stringified, ", ");
-	result += " )";
-	return result;
-}
-
-string CopyInfo::TablePartToString() const {
-	string result;
-
-	D_ASSERT(!table.empty());
-	result += QualifierToString(catalog, schema, table);
-
-	// (c1, c2, ..)
-	if (!select_list.empty()) {
-		vector<string> options;
-		for (auto &option : select_list) {
-			options.push_back(KeywordHelper::WriteOptionallyQuoted(option));
-		}
-		result += " (";
-		result += StringUtil::Join(options, ", ");
-		result += " )";
-	}
-	return result;
-}
-
-string CopyInfo::ToString() const {
-	string result = "";
-	result += "COPY ";
-	if (is_from) {
-		D_ASSERT(!select_statement);
-		result += TablePartToString();
-		result += " FROM";
-		result += StringUtil::Format(" %s", SQLString(file_path));
-		result += CopyOptionsToString(format, options);
-	} else {
-		if (select_statement) {
-			// COPY (select-node) TO ...
-			result += "(" + select_statement->ToString() + ")";
-		} else {
-			result += TablePartToString();
-		}
-		result += " TO ";
-		result += StringUtil::Format("%s", SQLString(file_path));
-		result += CopyOptionsToString(format, options);
-	}
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_aggregate_function_info.cpp b/src/duckdb/src/parser/parsed_data/create_aggregate_function_info.cpp
deleted file mode 100644
index 4e7476b88..000000000
--- a/src/duckdb/src/parser/parsed_data/create_aggregate_function_info.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-
-namespace duckdb {
-
-CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunction function)
-    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-	name = function.name;
-	functions.AddFunction(std::move(function));
-	internal = true;
-}
-
-CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunctionSet set)
-    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(std::move(set)) {
-	name = functions.name;
-	for (auto &func : functions.functions) {
-		func.name = functions.name;
-	}
-	internal = true;
-}
-
-unique_ptr<CreateInfo> CreateAggregateFunctionInfo::Copy() const {
-	auto result = make_uniq<CreateAggregateFunctionInfo>(functions);
-	CopyFunctionProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_collation_info.cpp b/src/duckdb/src/parser/parsed_data/create_collation_info.cpp
deleted file mode 100644
index 9ae2e6102..000000000
--- a/src/duckdb/src/parser/parsed_data/create_collation_info.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-
-namespace duckdb {
-
-CreateCollationInfo::CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p,
-                                         bool not_required_for_equality_p)
-    : CreateInfo(CatalogType::COLLATION_ENTRY), function(std::move(function_p)), combinable(combinable_p),
-      not_required_for_equality(not_required_for_equality_p) {
-	this->name = std::move(name_p);
-	internal = true;
-}
-
-unique_ptr<CreateInfo> CreateCollationInfo::Copy() const {
-	auto result = make_uniq<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
-	CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_copy_function_info.cpp b/src/duckdb/src/parser/parsed_data/create_copy_function_info.cpp
deleted file mode 100644
index 333f27520..000000000
--- a/src/duckdb/src/parser/parsed_data/create_copy_function_info.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-
-namespace duckdb {
-
-CreateCopyFunctionInfo::CreateCopyFunctionInfo(CopyFunction function_p)
-    : CreateInfo(CatalogType::COPY_FUNCTION_ENTRY), function(std::move(function_p)) {
-	this->name = function.name;
-	internal = true;
-}
-
-unique_ptr<CreateInfo> CreateCopyFunctionInfo::Copy() const {
-	auto result = make_uniq<CreateCopyFunctionInfo>(function);
-	CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_function_info.cpp b/src/duckdb/src/parser/parsed_data/create_function_info.cpp
deleted file mode 100644
index 2c3dde835..000000000
--- a/src/duckdb/src/parser/parsed_data/create_function_info.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/parser/parsed_data/create_function_info.hpp"
-
-namespace duckdb {
-
-CreateFunctionInfo::CreateFunctionInfo(CatalogType type, string schema) : CreateInfo(type, std::move(schema)) {
-	D_ASSERT(type == CatalogType::SCALAR_FUNCTION_ENTRY || type == CatalogType::AGGREGATE_FUNCTION_ENTRY ||
-	         type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY ||
-	         type == CatalogType::MACRO_ENTRY || type == CatalogType::TABLE_MACRO_ENTRY);
-}
-
-void CreateFunctionInfo::CopyFunctionProperties(CreateFunctionInfo &other) const {
-	CopyProperties(other);
-	other.name = name;
-	other.descriptions = descriptions;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_index_info.cpp b/src/duckdb/src/parser/parsed_data/create_index_info.cpp
deleted file mode 100644
index 1d062a702..000000000
--- a/src/duckdb/src/parser/parsed_data/create_index_info.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-namespace duckdb {
-
-CreateIndexInfo::CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY, INVALID_SCHEMA) {
-}
-
-CreateIndexInfo::CreateIndexInfo(const duckdb::CreateIndexInfo &info)
-    : CreateInfo(CatalogType::INDEX_ENTRY, info.schema), table(info.table), index_name(info.index_name),
-      options(info.options), index_type(info.index_type), constraint_type(info.constraint_type),
-      column_ids(info.column_ids), scan_types(info.scan_types), names(info.names) {
-}
-
-static void RemoveTableQualificationRecursive(unique_ptr<ParsedExpression> &expr, const string &table_name) {
-	if (expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
-		ParsedExpressionIterator::EnumerateChildren(*expr, [&table_name](unique_ptr<ParsedExpression> &child) {
-			RemoveTableQualificationRecursive(child, table_name);
-		});
-		return;
-	}
-
-	auto &col_ref = expr->Cast<ColumnRefExpression>();
-	auto &col_names = col_ref.column_names;
-	if (col_ref.IsQualified() && col_ref.GetTableName() == table_name) {
-		col_names.erase(col_names.begin());
-	}
-}
-
-vector<string> CreateIndexInfo::ExpressionsToList() const {
-	vector<string> list;
-
-	for (idx_t i = 0; i < parsed_expressions.size(); i++) {
-		auto &expr = parsed_expressions[i];
-		auto copy = expr->Copy();
-
-		// Column reference expressions are qualified with the table name.
-		// We need to remove them to reproduce the original query.
-		RemoveTableQualificationRecursive(copy, table);
-		bool add_parenthesis = true;
-		if (copy->GetExpressionType() == ExpressionType::COLUMN_REF) {
-			auto &column_ref = copy->Cast<ColumnRefExpression>();
-			if (!column_ref.IsQualified()) {
-				// Only not qualified references like (col1, col2) don't need parenthesis.
-				add_parenthesis = false;
-			}
-		}
-
-		if (add_parenthesis) {
-			list.push_back(StringUtil::Format("(%s)", copy->ToString()));
-		} else {
-			list.push_back(StringUtil::Format("%s", copy->ToString()));
-		}
-	}
-	return list;
-}
-
-string CreateIndexInfo::ExpressionsToString() const {
-	auto list = ExpressionsToList();
-	return StringUtil::Join(list, ", ");
-}
-
-string CreateIndexInfo::ToString() const {
-	string result;
-
-	result += "CREATE";
-	D_ASSERT(constraint_type == IndexConstraintType::UNIQUE || constraint_type == IndexConstraintType::NONE);
-	if (constraint_type == IndexConstraintType::UNIQUE) {
-		result += " UNIQUE";
-	}
-	result += " INDEX ";
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		result += "IF NOT EXISTS ";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(index_name);
-	result += " ON ";
-	result += QualifierToString(temporary ? "" : catalog, schema, table);
-	if (index_type != "ART") {
-		result += " USING ";
-		result += KeywordHelper::WriteOptionallyQuoted(index_type);
-		result += " ";
-	}
-	result += "(";
-	result += ExpressionsToString();
-	result += ")";
-	if (!options.empty()) {
-		result += " WITH (";
-		idx_t i = 0;
-		for (auto &opt : options) {
-			result += StringUtil::Format("%s = %s", opt.first, opt.second.ToString());
-			if (i > 0) {
-				result += ", ";
-			}
-			i++;
-		}
-		result += " )";
-	}
-	result += ";";
-	return result;
-}
-
-unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
-	auto result = make_uniq<CreateIndexInfo>(*this);
-	CopyProperties(*result);
-
-	for (auto &expr : expressions) {
-		result->expressions.push_back(expr->Copy());
-	}
-	for (auto &expr : parsed_expressions) {
-		result->parsed_expressions.push_back(expr->Copy());
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_info.cpp b/src/duckdb/src/parser/parsed_data/create_info.cpp
deleted file mode 100644
index 92777cd7f..000000000
--- a/src/duckdb/src/parser/parsed_data/create_info.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "duckdb/parser/parsed_data/create_info.hpp"
-
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-
-namespace duckdb {
-
-void CreateInfo::CopyProperties(CreateInfo &other) const {
-	other.type = type;
-	other.catalog = catalog;
-	other.schema = schema;
-	other.on_conflict = on_conflict;
-	other.temporary = temporary;
-	other.internal = internal;
-	other.sql = sql;
-	other.dependencies = dependencies;
-	other.comment = comment;
-	other.tags = tags;
-}
-
-unique_ptr<AlterInfo> CreateInfo::GetAlterInfo() const {
-	throw NotImplementedException("GetAlterInfo not implemented for this type");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_macro_info.cpp b/src/duckdb/src/parser/parsed_data/create_macro_info.cpp
deleted file mode 100644
index 0891b32dc..000000000
--- a/src/duckdb/src/parser/parsed_data/create_macro_info.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-CreateMacroInfo::CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
-}
-
-CreateMacroInfo::CreateMacroInfo(CatalogType type, unique_ptr<MacroFunction> function,
-                                 vector<unique_ptr<MacroFunction>> extra_functions)
-    : CreateFunctionInfo(type, INVALID_SCHEMA) {
-	macros.push_back(std::move(function));
-	for (auto &macro : extra_functions) {
-		macros.push_back(std::move(macro));
-	}
-}
-
-string CreateMacroInfo::ToString() const {
-	string result;
-	for (auto &function : macros) {
-		if (!result.empty()) {
-			result += ", ";
-		}
-		result += function->ToSQL();
-	}
-	// prefix with CREATE MACRO
-	string prefix = "CREATE MACRO ";
-	if (!catalog.empty()) {
-		prefix += KeywordHelper::WriteOptionallyQuoted(catalog);
-		prefix += ".";
-	}
-	if (!schema.empty()) {
-		prefix += KeywordHelper::WriteOptionallyQuoted(schema);
-		prefix += ".";
-	}
-	prefix += KeywordHelper::WriteOptionallyQuoted(name);
-	result = prefix + " " + result + ";";
-	return result;
-}
-
-unique_ptr<CreateInfo> CreateMacroInfo::Copy() const {
-	auto result = make_uniq<CreateMacroInfo>(type);
-	for (auto &macro : macros) {
-		result->macros.push_back(macro->Copy());
-	}
-	result->name = name;
-	CopyFunctionProperties(*result);
-	return std::move(result);
-}
-
-vector<unique_ptr<MacroFunction>> CreateMacroInfo::GetAllButFirstFunction() const {
-	vector<unique_ptr<MacroFunction>> result;
-	for (idx_t i = 1; i < macros.size(); i++) {
-		result.push_back(macros[i]->Copy());
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_pragma_function_info.cpp b/src/duckdb/src/parser/parsed_data/create_pragma_function_info.cpp
deleted file mode 100644
index 7e38ee885..000000000
--- a/src/duckdb/src/parser/parsed_data/create_pragma_function_info.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-
-namespace duckdb {
-
-CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(PragmaFunction function)
-    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(function.name) {
-	name = function.name;
-	functions.AddFunction(std::move(function));
-	internal = true;
-}
-CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions_p)
-    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(std::move(functions_p)) {
-	this->name = std::move(name);
-	internal = true;
-}
-
-unique_ptr<CreateInfo> CreatePragmaFunctionInfo::Copy() const {
-	auto result = make_uniq<CreatePragmaFunctionInfo>(functions.name, functions);
-	CopyFunctionProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_scalar_function_info.cpp b/src/duckdb/src/parser/parsed_data/create_scalar_function_info.cpp
deleted file mode 100644
index 51598a72e..000000000
--- a/src/duckdb/src/parser/parsed_data/create_scalar_function_info.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
-
-namespace duckdb {
-
-CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunction function)
-    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(function.name) {
-	name = function.name;
-	functions.AddFunction(std::move(function));
-	internal = true;
-}
-CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunctionSet set)
-    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(std::move(set)) {
-	name = functions.name;
-	for (auto &func : functions.functions) {
-		func.name = functions.name;
-	}
-	internal = true;
-}
-
-unique_ptr<CreateInfo> CreateScalarFunctionInfo::Copy() const {
-	ScalarFunctionSet set(name);
-	set.functions = functions.functions;
-	auto result = make_uniq<CreateScalarFunctionInfo>(std::move(set));
-	CopyFunctionProperties(*result);
-	return std::move(result);
-}
-
-unique_ptr<AlterInfo> CreateScalarFunctionInfo::GetAlterInfo() const {
-	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(
-	    AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL),
-	    unique_ptr_cast<CreateInfo, CreateScalarFunctionInfo>(Copy()));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_schema_info.cpp b/src/duckdb/src/parser/parsed_data/create_schema_info.cpp
deleted file mode 100644
index e7c7f3f8b..000000000
--- a/src/duckdb/src/parser/parsed_data/create_schema_info.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-CreateSchemaInfo::CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
-}
-
-unique_ptr<CreateInfo> CreateSchemaInfo::Copy() const {
-	auto result = make_uniq<CreateSchemaInfo>();
-	CopyProperties(*result);
-	return std::move(result);
-}
-
-string CreateSchemaInfo::ToString() const {
-	string ret = "";
-	string qualified = QualifierToString(temporary ? "" : catalog, "", schema);
-
-	switch (on_conflict) {
-	case OnCreateConflict::ALTER_ON_CONFLICT: {
-		ret += "CREATE SCHEMA " + qualified + " ON CONFLICT INSERT OR REPLACE;";
-		break;
-	}
-	case OnCreateConflict::IGNORE_ON_CONFLICT: {
-		ret += "CREATE SCHEMA IF NOT EXISTS " + qualified + ";";
-		break;
-	}
-	case OnCreateConflict::REPLACE_ON_CONFLICT: {
-		ret += "CREATE OR REPLACE SCHEMA " + qualified + ";";
-		break;
-	}
-	case OnCreateConflict::ERROR_ON_CONFLICT: {
-		ret += "CREATE SCHEMA " + qualified + ";";
-		break;
-	}
-	}
-	return ret;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_secret_info.cpp b/src/duckdb/src/parser/parsed_data/create_secret_info.cpp
deleted file mode 100644
index 55f8bd020..000000000
--- a/src/duckdb/src/parser/parsed_data/create_secret_info.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-
-#include "duckdb/parser/parsed_data/create_info.hpp"
-
-namespace duckdb {
-
-CreateSecretInfo::CreateSecretInfo(OnCreateConflict on_conflict, SecretPersistType persist_type)
-    : CreateInfo(CatalogType::SECRET_ENTRY), on_conflict(on_conflict), persist_type(persist_type), options() {
-}
-
-unique_ptr<CreateInfo> CreateSecretInfo::Copy() const {
-	auto result = make_uniq<CreateSecretInfo>(on_conflict, persist_type);
-	result->type = type;
-	result->storage_type = storage_type;
-	result->provider = provider;
-	result->name = name;
-	result->scope = scope;
-	result->options = options;
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp b/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp
deleted file mode 100644
index ba5d83b3d..000000000
--- a/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-CreateSequenceInfo::CreateSequenceInfo()
-    : CreateInfo(CatalogType::SEQUENCE_ENTRY, INVALID_SCHEMA), name(string()), usage_count(0), increment(1),
-      min_value(1), max_value(NumericLimits<int64_t>::Maximum()), start_value(1), cycle(false) {
-}
-
-unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
-	auto result = make_uniq<CreateSequenceInfo>();
-	CopyProperties(*result);
-	result->name = name;
-	result->schema = schema;
-	result->usage_count = usage_count;
-	result->increment = increment;
-	result->min_value = min_value;
-	result->max_value = max_value;
-	result->start_value = start_value;
-	result->cycle = cycle;
-	return std::move(result);
-}
-
-string CreateSequenceInfo::ToString() const {
-	std::stringstream ss;
-	ss << "CREATE";
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		ss << " OR REPLACE";
-	}
-	if (temporary) {
-		ss << " TEMPORARY";
-	}
-	ss << " SEQUENCE ";
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		ss << " IF NOT EXISTS ";
-	}
-	ss << QualifierToString(temporary ? "" : catalog, schema, name);
-	ss << " INCREMENT BY " << increment;
-	ss << " MINVALUE " << min_value;
-	ss << " MAXVALUE " << max_value;
-	ss << " START " << start_value;
-	ss << " " << (cycle ? "CYCLE" : "NO CYCLE") << ";";
-	return ss.str();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_table_function_info.cpp b/src/duckdb/src/parser/parsed_data/create_table_function_info.cpp
deleted file mode 100644
index 3e774fba9..000000000
--- a/src/duckdb/src/parser/parsed_data/create_table_function_info.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
-
-namespace duckdb {
-
-CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunction function)
-    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(function.name) {
-	name = function.name;
-	functions.AddFunction(std::move(function));
-	internal = true;
-}
-CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunctionSet set)
-    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(std::move(set)) {
-	name = functions.name;
-	for (auto &func : functions.functions) {
-		func.name = functions.name;
-	}
-	internal = true;
-}
-
-unique_ptr<CreateInfo> CreateTableFunctionInfo::Copy() const {
-	TableFunctionSet set(name);
-	set.functions = functions.functions;
-	auto result = make_uniq<CreateTableFunctionInfo>(std::move(set));
-	CopyFunctionProperties(*result);
-	return std::move(result);
-}
-
-unique_ptr<AlterInfo> CreateTableFunctionInfo::GetAlterInfo() const {
-	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(
-	    AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL), functions);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_table_info.cpp b/src/duckdb/src/parser/parsed_data/create_table_info.cpp
deleted file mode 100644
index 0568a8fd1..000000000
--- a/src/duckdb/src/parser/parsed_data/create_table_info.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-CreateTableInfo::CreateTableInfo() : CreateInfo(CatalogType::TABLE_ENTRY, INVALID_SCHEMA) {
-}
-
-CreateTableInfo::CreateTableInfo(string catalog_p, string schema_p, string name_p)
-    : CreateInfo(CatalogType::TABLE_ENTRY, std::move(schema_p), std::move(catalog_p)), table(std::move(name_p)) {
-}
-
-CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
-    : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
-}
-
-unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
-	auto result = make_uniq<CreateTableInfo>(catalog, schema, table);
-	CopyProperties(*result);
-	result->columns = columns.Copy();
-	for (auto &constraint : constraints) {
-		result->constraints.push_back(constraint->Copy());
-	}
-	if (query) {
-		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-	}
-	return std::move(result);
-}
-
-string CreateTableInfo::ToString() const {
-	string ret = "";
-
-	ret += "CREATE";
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		ret += " OR REPLACE";
-	}
-	if (temporary) {
-		ret += " TEMP";
-	}
-	ret += " TABLE ";
-
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		ret += " IF NOT EXISTS ";
-	}
-	ret += QualifierToString(temporary ? "" : catalog, schema, table);
-
-	if (query != nullptr) {
-		ret += TableCatalogEntry::ColumnNamesToSQL(columns);
-		ret += " AS " + query->ToString();
-	} else {
-		ret += TableCatalogEntry::ColumnsToSQL(columns, constraints) + ";";
-	}
-	return ret;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_type_info.cpp b/src/duckdb/src/parser/parsed_data/create_type_info.cpp
deleted file mode 100644
index 1ce0327c3..000000000
--- a/src/duckdb/src/parser/parsed_data/create_type_info.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-
-namespace duckdb {
-
-CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY), bind_function(nullptr) {
-}
-CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p, bind_logical_type_function_t bind_function_p)
-    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)),
-      bind_function(bind_function_p) {
-}
-
-unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
-	auto result = make_uniq<CreateTypeInfo>();
-	CopyProperties(*result);
-	result->name = name;
-	result->type = type;
-	if (query) {
-		result->query = query->Copy();
-	}
-	result->bind_function = bind_function;
-	return std::move(result);
-}
-
-string CreateTypeInfo::ToString() const {
-	string result = "";
-	result += "CREATE";
-	if (temporary) {
-		// These are created by PIVOT
-		throw NotImplementedException("CREATE TEMPORARY TYPE can't be parsed currently");
-	}
-	result += " TYPE ";
-	result += QualifierToString(temporary ? "" : catalog, schema, name);
-	if (type.id() == LogicalTypeId::ENUM) {
-		auto &values_insert_order = EnumType::GetValuesInsertOrder(type);
-		idx_t size = EnumType::GetSize(type);
-
-		result += " AS ENUM ( ";
-		for (idx_t i = 0; i < size; i++) {
-			result += "'" + values_insert_order.GetValue(i).ToString() + "'";
-			if (i != size - 1) {
-				result += ", ";
-			}
-		}
-		result += " );";
-	} else if (type.id() == LogicalTypeId::INVALID) {
-		// CREATE TYPE mood AS ENUM (SELECT 'happy')
-		D_ASSERT(query);
-		result += " AS ENUM (" + query->ToString() + ")";
-	} else if (type.id() == LogicalTypeId::USER) {
-		result += " AS ";
-		auto extra_info = type.AuxInfo();
-		D_ASSERT(extra_info);
-		D_ASSERT(extra_info->type == ExtraTypeInfoType::USER_TYPE_INFO);
-		auto &user_info = extra_info->Cast<UserTypeInfo>();
-		result += QualifierToString(user_info.catalog, user_info.schema, user_info.user_type_name);
-	} else {
-		result += " AS ";
-		result += type.ToString();
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/create_view_info.cpp b/src/duckdb/src/parser/parsed_data/create_view_info.cpp
deleted file mode 100644
index ee8a71c5d..000000000
--- a/src/duckdb/src/parser/parsed_data/create_view_info.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-
-namespace duckdb {
-
-CreateViewInfo::CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
-}
-CreateViewInfo::CreateViewInfo(string catalog_p, string schema_p, string view_name_p)
-    : CreateInfo(CatalogType::VIEW_ENTRY, std::move(schema_p), std::move(catalog_p)),
-      view_name(std::move(view_name_p)) {
-}
-
-CreateViewInfo::CreateViewInfo(SchemaCatalogEntry &schema, string view_name)
-    : CreateViewInfo(schema.catalog.GetName(), schema.name, std::move(view_name)) {
-}
-
-string CreateViewInfo::ToString() const {
-	string result;
-
-	result += "CREATE";
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		result += " OR REPLACE";
-	}
-	if (temporary) {
-		result += " TEMPORARY";
-	}
-	result += " VIEW ";
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		result += " IF NOT EXISTS ";
-	}
-	result += QualifierToString(temporary ? "" : catalog, schema, view_name);
-	if (!aliases.empty()) {
-		result += " (";
-		result += StringUtil::Join(aliases, aliases.size(), ", ",
-		                           [](const string &name) { return KeywordHelper::WriteOptionallyQuoted(name); });
-		result += ")";
-	}
-	result += " AS ";
-	result += query->ToString();
-	result += ";";
-	return result;
-}
-
-unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
-	auto result = make_uniq<CreateViewInfo>(catalog, schema, view_name);
-	CopyProperties(*result);
-	result->aliases = aliases;
-	result->types = types;
-	result->column_comments = column_comments;
-	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-	return std::move(result);
-}
-
-unique_ptr<SelectStatement> CreateViewInfo::ParseSelect(const string &sql) {
-	Parser parser;
-	parser.ParseQuery(sql);
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw BinderException(
-		    "Failed to create view from SQL string - \"%s\" - statement did not contain a single SELECT statement",
-		    sql);
-	}
-	D_ASSERT(parser.statements.size() == 1 && parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-	return unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
-}
-
-unique_ptr<CreateViewInfo> CreateViewInfo::FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info) {
-	D_ASSERT(info);
-	D_ASSERT(!info->view_name.empty());
-	D_ASSERT(!info->sql.empty());
-	D_ASSERT(!info->query);
-
-	info->query = ParseSelect(info->sql);
-
-	auto binder = Binder::CreateBinder(context);
-	binder->BindCreateViewInfo(*info);
-
-	return info;
-}
-
-unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context, const string &sql) {
-	D_ASSERT(!sql.empty());
-
-	// parse the SQL statement
-	Parser parser;
-	parser.ParseQuery(sql);
-
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
-		throw BinderException(
-		    "Failed to create view from SQL string - \"%s\" - statement did not contain a single CREATE VIEW statement",
-		    sql);
-	}
-	auto &create_statement = parser.statements[0]->Cast<CreateStatement>();
-	if (create_statement.info->type != CatalogType::VIEW_ENTRY) {
-		throw BinderException(
-		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE VIEW statement", sql);
-	}
-
-	auto result = unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(create_statement.info));
-
-	auto binder = Binder::CreateBinder(context);
-	binder->BindCreateViewInfo(*result);
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/detach_info.cpp b/src/duckdb/src/parser/parsed_data/detach_info.cpp
deleted file mode 100644
index 623023157..000000000
--- a/src/duckdb/src/parser/parsed_data/detach_info.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/parser/parsed_data/detach_info.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-DetachInfo::DetachInfo() : ParseInfo(TYPE) {
-}
-
-unique_ptr<DetachInfo> DetachInfo::Copy() const {
-	auto result = make_uniq<DetachInfo>();
-	result->name = name;
-	result->if_not_found = if_not_found;
-	return result;
-}
-
-string DetachInfo::ToString() const {
-	string result = "";
-	result += "DETACH DATABASE";
-	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
-	}
-	result += " " + KeywordHelper::WriteOptionallyQuoted(name);
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/drop_info.cpp b/src/duckdb/src/parser/parsed_data/drop_info.cpp
deleted file mode 100644
index c5db57ddc..000000000
--- a/src/duckdb/src/parser/parsed_data/drop_info.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/parser/parsed_data/extra_drop_info.hpp"
-
-namespace duckdb {
-
-DropInfo::DropInfo() : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
-}
-
-DropInfo::DropInfo(const DropInfo &info)
-    : ParseInfo(info.info_type), type(info.type), catalog(info.catalog), schema(info.schema), name(info.name),
-      if_not_found(info.if_not_found), cascade(info.cascade), allow_drop_internal(info.allow_drop_internal),
-      extra_drop_info(info.extra_drop_info ? info.extra_drop_info->Copy() : nullptr) {
-}
-
-unique_ptr<DropInfo> DropInfo::Copy() const {
-	return make_uniq<DropInfo>(*this);
-}
-
-string DropInfo::ToString() const {
-	string result = "";
-	if (type == CatalogType::PREPARED_STATEMENT) {
-		result += "DEALLOCATE PREPARE ";
-		result += KeywordHelper::WriteOptionallyQuoted(name);
-	} else {
-		result += "DROP";
-		result += " " + ParseInfo::TypeToString(type);
-		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-			result += " IF EXISTS";
-		}
-		result += " ";
-		result += QualifierToString(catalog, schema, name);
-		if (cascade) {
-			result += " CASCADE";
-		}
-	}
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/exported_table_data.cpp b/src/duckdb/src/parser/parsed_data/exported_table_data.cpp
deleted file mode 100644
index d3573bc0a..000000000
--- a/src/duckdb/src/parser/parsed_data/exported_table_data.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-ExportedTableInfo::ExportedTableInfo(TableCatalogEntry &entry, ExportedTableData table_data_p,
-                                     vector<string> &not_null_columns_p)
-    : entry(entry), table_data(std::move(table_data_p)) {
-	table_data.not_null_columns = not_null_columns_p;
-}
-
-ExportedTableInfo::ExportedTableInfo(ClientContext &context, ExportedTableData table_data_p)
-    : entry(GetEntry(context, table_data_p)), table_data(std::move(table_data_p)) {
-}
-
-TableCatalogEntry &ExportedTableInfo::GetEntry(ClientContext &context, const ExportedTableData &table_data) {
-	return Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, table_data.database_name, table_data.schema_name,
-	                         table_data.table_name)
-	    .Cast<TableCatalogEntry>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/extra_drop_info.cpp b/src/duckdb/src/parser/parsed_data/extra_drop_info.cpp
deleted file mode 100644
index 9b51841d0..000000000
--- a/src/duckdb/src/parser/parsed_data/extra_drop_info.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/parser/parsed_data/extra_drop_info.hpp"
-
-namespace duckdb {
-
-ExtraDropSecretInfo::ExtraDropSecretInfo() : ExtraDropInfo(ExtraDropInfoType::SECRET_INFO) {
-}
-
-ExtraDropSecretInfo::ExtraDropSecretInfo(const ExtraDropSecretInfo &info)
-    : ExtraDropInfo(ExtraDropInfoType::SECRET_INFO) {
-	persist_mode = info.persist_mode;
-	secret_storage = info.secret_storage;
-}
-
-unique_ptr<ExtraDropInfo> ExtraDropSecretInfo::Copy() const {
-	return std::move(make_uniq<ExtraDropSecretInfo>(*this));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/load_info.cpp b/src/duckdb/src/parser/parsed_data/load_info.cpp
deleted file mode 100644
index ea1fae141..000000000
--- a/src/duckdb/src/parser/parsed_data/load_info.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/parser/parsed_data/load_info.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-unique_ptr<LoadInfo> LoadInfo::Copy() const {
-	auto result = make_uniq<LoadInfo>();
-	result->filename = filename;
-	result->repository = repository;
-	result->load_type = load_type;
-	result->repo_is_alias = repo_is_alias;
-	result->version = version;
-	return result;
-}
-
-static string LoadInfoToString(LoadType load_type) {
-	switch (load_type) {
-	case LoadType::LOAD:
-		return "LOAD";
-	case LoadType::INSTALL:
-		return "INSTALL";
-	case LoadType::FORCE_INSTALL:
-		return "FORCE INSTALL";
-	default:
-		throw InternalException("ToString for LoadType with type: %s not implemented", EnumUtil::ToString(load_type));
-	}
-}
-
-string LoadInfo::ToString() const {
-	string result = "";
-	result += LoadInfoToString(load_type);
-	result += StringUtil::Format(" '%s'", filename);
-	if (!repository.empty()) {
-		if (repo_is_alias) {
-			result += " FROM " + KeywordHelper::WriteOptionallyQuoted(repository);
-		} else {
-			result += " FROM " + KeywordHelper::WriteQuoted(repository);
-		}
-	}
-
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/parse_info.cpp b/src/duckdb/src/parser/parsed_data/parse_info.cpp
deleted file mode 100644
index 63f7c67cc..000000000
--- a/src/duckdb/src/parser/parsed_data/parse_info.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/common/enums/catalog_type.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-string ParseInfo::TypeToString(CatalogType type) {
-	switch (type) {
-	case CatalogType::TABLE_ENTRY:
-		return "TABLE";
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		return "FUNCTION";
-	case CatalogType::INDEX_ENTRY:
-		return "INDEX";
-	case CatalogType::SCHEMA_ENTRY:
-		return "SCHEMA";
-	case CatalogType::TYPE_ENTRY:
-		return "TYPE";
-	case CatalogType::VIEW_ENTRY:
-		return "VIEW";
-	case CatalogType::SEQUENCE_ENTRY:
-		return "SEQUENCE";
-	case CatalogType::MACRO_ENTRY:
-		return "MACRO";
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return "MACRO TABLE";
-	case CatalogType::SECRET_ENTRY:
-		return "SECRET";
-	default:
-		throw InternalException("ParseInfo::TypeToString for CatalogType with type: %s not implemented",
-		                        EnumUtil::ToString(type));
-	}
-}
-
-string ParseInfo::QualifierToString(const string &catalog, const string &schema, const string &name) {
-	string result;
-	if (!catalog.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
-		if (!schema.empty()) {
-			result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-		}
-	} else if (!schema.empty() && schema != DEFAULT_SCHEMA) {
-		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(name);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/pragma_info.cpp b/src/duckdb/src/parser/parsed_data/pragma_info.cpp
deleted file mode 100644
index 3052c4415..000000000
--- a/src/duckdb/src/parser/parsed_data/pragma_info.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-
-namespace duckdb {
-
-unique_ptr<PragmaInfo> PragmaInfo::Copy() const {
-	auto result = make_uniq<PragmaInfo>();
-	result->name = name;
-	for (auto &param : parameters) {
-		result->parameters.push_back(param->Copy());
-	}
-	for (auto &entry : named_parameters) {
-		result->named_parameters.insert(make_pair(entry.first, entry.second->Copy()));
-	}
-	return result;
-}
-
-string PragmaInfo::ToString() const {
-	string result = "";
-	result += "PRAGMA";
-	// FIXME: Can pragma's live in different catalog/schemas ?
-	result += " " + KeywordHelper::WriteOptionallyQuoted(name);
-	if (!parameters.empty()) {
-		vector<string> stringified;
-		for (auto &param : parameters) {
-			stringified.push_back(param->ToString());
-		}
-		result += "(" + StringUtil::Join(stringified, ", ") + ")";
-	}
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/sample_options.cpp b/src/duckdb/src/parser/parsed_data/sample_options.cpp
deleted file mode 100644
index 54be9d1cb..000000000
--- a/src/duckdb/src/parser/parsed_data/sample_options.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-// **DEPRECATED**: Use EnumUtil directly instead.
-string SampleMethodToString(SampleMethod method) {
-	return EnumUtil::ToString(method);
-}
-
-SampleOptions::SampleOptions(int64_t seed_) {
-	repeatable = false;
-	if (seed_ >= 0) {
-		seed = static_cast<idx_t>(seed_);
-	}
-	sample_size = 0;
-	is_percentage = false;
-	method = SampleMethod::INVALID;
-}
-
-unique_ptr<SampleOptions> SampleOptions::Copy() {
-	auto result = make_uniq<SampleOptions>();
-	result->sample_size = sample_size;
-	result->is_percentage = is_percentage;
-	result->method = method;
-	result->seed = seed;
-	result->repeatable = repeatable;
-	return result;
-}
-
-void SampleOptions::SetSeed(idx_t new_seed) {
-	seed = new_seed;
-}
-
-bool SampleOptions::Equals(SampleOptions *a, SampleOptions *b) {
-	if (a == b) {
-		return true;
-	}
-	if (!a || !b) {
-		return false;
-	}
-	// if only one is valid, they are not equal
-	if (a->seed.IsValid() != b->seed.IsValid()) {
-		return false;
-	}
-	// if both are invalid, then they are technically the same
-	if (!a->seed.IsValid() && !b->seed.IsValid()) {
-		return true;
-	}
-	if (a->sample_size != b->sample_size || a->is_percentage != b->is_percentage || a->method != b->method ||
-	    a->seed.GetIndex() != b->seed.GetIndex()) {
-		return false;
-	}
-	return true;
-}
-
-int64_t SampleOptions::GetSeed() const {
-	if (seed.IsValid()) {
-		return static_cast<int64_t>(seed.GetIndex());
-	}
-	return -1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/transaction_info.cpp b/src/duckdb/src/parser/parsed_data/transaction_info.cpp
deleted file mode 100644
index af102e6e3..000000000
--- a/src/duckdb/src/parser/parsed_data/transaction_info.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/parser/parsed_data/transaction_info.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-TransactionInfo::TransactionInfo() : ParseInfo(TYPE) {
-}
-
-TransactionInfo::TransactionInfo(TransactionType type)
-    : ParseInfo(TYPE), type(type), modifier(TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER) {
-}
-
-string TransactionInfo::ToString() const {
-	string result = "";
-	switch (type) {
-	case TransactionType::BEGIN_TRANSACTION:
-		result += "BEGIN";
-		break;
-	case TransactionType::COMMIT:
-		result += "COMMIT";
-		break;
-	case TransactionType::ROLLBACK:
-		result += "ROLLBACK";
-		break;
-	default: {
-		throw InternalException("ToString for TransactionStatement with type: %s not implemented",
-		                        EnumUtil::ToString(type));
-	}
-	}
-	switch (modifier) {
-	case TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER:
-		break;
-	case TransactionModifierType::TRANSACTION_READ_ONLY:
-		result += " READ ONLY";
-		break;
-	case TransactionModifierType::TRANSACTION_READ_WRITE:
-		result += " READ WRITE";
-		break;
-	default:
-		throw InternalException("ToString for TransactionStatement with modifier type: %s not implemented",
-		                        EnumUtil::ToString(modifier));
-	}
-	result += ";";
-	return result;
-}
-
-unique_ptr<TransactionInfo> TransactionInfo::Copy() const {
-	auto result = make_uniq<TransactionInfo>(type);
-	result->modifier = modifier;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_data/vacuum_info.cpp b/src/duckdb/src/parser/parsed_data/vacuum_info.cpp
deleted file mode 100644
index 7fff15e83..000000000
--- a/src/duckdb/src/parser/parsed_data/vacuum_info.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-VacuumInfo::VacuumInfo(VacuumOptions options) : ParseInfo(TYPE), options(options), has_table(false) {
-}
-
-unique_ptr<VacuumInfo> VacuumInfo::Copy() {
-	auto result = make_uniq<VacuumInfo>(options);
-	result->has_table = has_table;
-	if (has_table) {
-		result->ref = ref->Copy();
-	}
-	result->columns = columns;
-	return result;
-}
-
-string VacuumInfo::ToString() const {
-	string result = "";
-	result += "VACUUM";
-	if (options.analyze) {
-		result += " ANALYZE";
-	}
-	if (ref) {
-		result += " " + ref->ToString();
-		if (!columns.empty()) {
-			vector<string> names;
-			for (auto &column : columns) {
-				names.push_back(KeywordHelper::WriteOptionallyQuoted(column));
-			}
-			result += "(" + StringUtil::Join(names, ", ") + ")";
-		}
-	}
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_expression.cpp b/src/duckdb/src/parser/parsed_expression.cpp
deleted file mode 100644
index 1ba33bfd8..000000000
--- a/src/duckdb/src/parser/parsed_expression.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "duckdb/main/client_context.hpp"
-
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/parser/expression/list.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/expression_util.hpp"
-
-namespace duckdb {
-
-bool ParsedExpression::IsAggregate() const {
-	bool is_aggregate = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { is_aggregate |= child.IsAggregate(); });
-	return is_aggregate;
-}
-
-bool ParsedExpression::IsWindow() const {
-	bool is_window = false;
-	ParsedExpressionIterator::EnumerateChildren(*this,
-	                                            [&](const ParsedExpression &child) { is_window |= child.IsWindow(); });
-	return is_window;
-}
-
-bool ParsedExpression::IsScalar() const {
-	bool is_scalar = true;
-	ParsedExpressionIterator::EnumerateChildren(*this, [&](const ParsedExpression &child) {
-		if (!child.IsScalar()) {
-			is_scalar = false;
-		}
-	});
-	return is_scalar;
-}
-
-bool ParsedExpression::HasParameter() const {
-	bool has_parameter = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { has_parameter |= child.HasParameter(); });
-	return has_parameter;
-}
-
-bool ParsedExpression::HasSubquery() const {
-	bool has_subquery = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { has_subquery |= child.HasSubquery(); });
-	return has_subquery;
-}
-
-bool ParsedExpression::Equals(const BaseExpression &other) const {
-	if (!BaseExpression::Equals(other)) {
-		return false;
-	}
-	switch (expression_class) {
-	case ExpressionClass::BETWEEN:
-		return BetweenExpression::Equal(Cast<BetweenExpression>(), other.Cast<BetweenExpression>());
-	case ExpressionClass::CASE:
-		return CaseExpression::Equal(Cast<CaseExpression>(), other.Cast<CaseExpression>());
-	case ExpressionClass::CAST:
-		return CastExpression::Equal(Cast<CastExpression>(), other.Cast<CastExpression>());
-	case ExpressionClass::COLLATE:
-		return CollateExpression::Equal(Cast<CollateExpression>(), other.Cast<CollateExpression>());
-	case ExpressionClass::COLUMN_REF:
-		return ColumnRefExpression::Equal(Cast<ColumnRefExpression>(), other.Cast<ColumnRefExpression>());
-	case ExpressionClass::COMPARISON:
-		return ComparisonExpression::Equal(Cast<ComparisonExpression>(), other.Cast<ComparisonExpression>());
-	case ExpressionClass::CONJUNCTION:
-		return ConjunctionExpression::Equal(Cast<ConjunctionExpression>(), other.Cast<ConjunctionExpression>());
-	case ExpressionClass::CONSTANT:
-		return ConstantExpression::Equal(Cast<ConstantExpression>(), other.Cast<ConstantExpression>());
-	case ExpressionClass::DEFAULT:
-		return true;
-	case ExpressionClass::FUNCTION:
-		return FunctionExpression::Equal(Cast<FunctionExpression>(), other.Cast<FunctionExpression>());
-	case ExpressionClass::LAMBDA:
-		return LambdaExpression::Equal(Cast<LambdaExpression>(), other.Cast<LambdaExpression>());
-	case ExpressionClass::OPERATOR:
-		return OperatorExpression::Equal(Cast<OperatorExpression>(), other.Cast<OperatorExpression>());
-	case ExpressionClass::PARAMETER:
-		return ParameterExpression::Equal(Cast<ParameterExpression>(), other.Cast<ParameterExpression>());
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return PositionalReferenceExpression::Equal(Cast<PositionalReferenceExpression>(),
-		                                            other.Cast<PositionalReferenceExpression>());
-	case ExpressionClass::STAR:
-		return StarExpression::Equal(Cast<StarExpression>(), other.Cast<StarExpression>());
-	case ExpressionClass::SUBQUERY:
-		return SubqueryExpression::Equal(Cast<SubqueryExpression>(), other.Cast<SubqueryExpression>());
-	case ExpressionClass::WINDOW:
-		return WindowExpression::Equal(Cast<WindowExpression>(), other.Cast<WindowExpression>());
-	default:
-		throw SerializationException("Unsupported type for expression comparison!");
-	}
-}
-
-hash_t ParsedExpression::Hash() const {
-	hash_t hash = duckdb::Hash<uint32_t>(static_cast<uint32_t>(type));
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { hash = CombineHash(child.Hash(), hash); });
-	return hash;
-}
-
-bool ParsedExpression::Equals(const unique_ptr<ParsedExpression> &left, const unique_ptr<ParsedExpression> &right) {
-	if (left.get() == right.get()) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return left->Equals(*right);
-}
-
-bool ParsedExpression::ListEquals(const vector<unique_ptr<ParsedExpression>> &left,
-                                  const vector<unique_ptr<ParsedExpression>> &right) {
-	return ExpressionUtil::ListEquals(left, right);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parsed_expression_iterator.cpp b/src/duckdb/src/parser/parsed_expression_iterator.cpp
deleted file mode 100644
index ca1df3a6b..000000000
--- a/src/duckdb/src/parser/parsed_expression_iterator.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-#include "duckdb/parser/expression/list.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-#include "duckdb/parser/tableref/list.hpp"
-
-namespace duckdb {
-
-void ParsedExpressionIterator::EnumerateChildren(const ParsedExpression &expression,
-                                                 const std::function<void(const ParsedExpression &child)> &callback) {
-	EnumerateChildren((ParsedExpression &)expression, [&](unique_ptr<ParsedExpression> &child) {
-		D_ASSERT(child);
-		callback(*child);
-	});
-}
-
-void ParsedExpressionIterator::EnumerateChildren(ParsedExpression &expr,
-                                                 const std::function<void(ParsedExpression &child)> &callback) {
-	EnumerateChildren(expr, [&](unique_ptr<ParsedExpression> &child) {
-		D_ASSERT(child);
-		callback(*child);
-	});
-}
-
-void ParsedExpressionIterator::EnumerateChildren(
-    ParsedExpression &expr, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BETWEEN: {
-		auto &cast_expr = expr.Cast<BetweenExpression>();
-		callback(cast_expr.input);
-		callback(cast_expr.lower);
-		callback(cast_expr.upper);
-		break;
-	}
-	case ExpressionClass::CASE: {
-		auto &case_expr = expr.Cast<CaseExpression>();
-		for (auto &check : case_expr.case_checks) {
-			callback(check.when_expr);
-			callback(check.then_expr);
-		}
-		callback(case_expr.else_expr);
-		break;
-	}
-	case ExpressionClass::CAST: {
-		auto &cast_expr = expr.Cast<CastExpression>();
-		callback(cast_expr.child);
-		break;
-	}
-	case ExpressionClass::COLLATE: {
-		auto &cast_expr = expr.Cast<CollateExpression>();
-		callback(cast_expr.child);
-		break;
-	}
-	case ExpressionClass::COMPARISON: {
-		auto &comp_expr = expr.Cast<ComparisonExpression>();
-		callback(comp_expr.left);
-		callback(comp_expr.right);
-		break;
-	}
-	case ExpressionClass::CONJUNCTION: {
-		auto &conj_expr = expr.Cast<ConjunctionExpression>();
-		for (auto &child : conj_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-
-	case ExpressionClass::FUNCTION: {
-		auto &func_expr = expr.Cast<FunctionExpression>();
-		for (auto &child : func_expr.children) {
-			callback(child);
-		}
-		if (func_expr.filter) {
-			callback(func_expr.filter);
-		}
-		if (func_expr.order_bys) {
-			for (auto &order : func_expr.order_bys->orders) {
-				callback(order.expression);
-			}
-		}
-		break;
-	}
-	case ExpressionClass::LAMBDA: {
-		auto &lambda_expr = expr.Cast<LambdaExpression>();
-		callback(lambda_expr.lhs);
-		callback(lambda_expr.expr);
-		break;
-	}
-	case ExpressionClass::OPERATOR: {
-		auto &op_expr = expr.Cast<OperatorExpression>();
-		for (auto &child : op_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::STAR: {
-		auto &star_expr = expr.Cast<StarExpression>();
-		if (star_expr.expr) {
-			callback(star_expr.expr);
-		}
-		for (auto &item : star_expr.replace_list) {
-			callback(item.second);
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		auto &subquery_expr = expr.Cast<SubqueryExpression>();
-		if (subquery_expr.child) {
-			callback(subquery_expr.child);
-		}
-		break;
-	}
-	case ExpressionClass::WINDOW: {
-		auto &window_expr = expr.Cast<WindowExpression>();
-		for (auto &partition : window_expr.partitions) {
-			callback(partition);
-		}
-		for (auto &order : window_expr.orders) {
-			callback(order.expression);
-		}
-		for (auto &child : window_expr.children) {
-			callback(child);
-		}
-		if (window_expr.filter_expr) {
-			callback(window_expr.filter_expr);
-		}
-		if (window_expr.start_expr) {
-			callback(window_expr.start_expr);
-		}
-		if (window_expr.end_expr) {
-			callback(window_expr.end_expr);
-		}
-		if (window_expr.offset_expr) {
-			callback(window_expr.offset_expr);
-		}
-		if (window_expr.default_expr) {
-			callback(window_expr.default_expr);
-		}
-		for (auto &order : window_expr.arg_orders) {
-			callback(order.expression);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_EXPRESSION:
-	case ExpressionClass::COLUMN_REF:
-	case ExpressionClass::LAMBDA_REF:
-	case ExpressionClass::CONSTANT:
-	case ExpressionClass::DEFAULT:
-	case ExpressionClass::PARAMETER:
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		// these node types have no children
-		break;
-	default:
-		// called on non ParsedExpression type!
-		throw NotImplementedException("Unimplemented expression class");
-	}
-}
-
-void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
-    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
-
-	for (auto &modifier : node.modifiers) {
-		switch (modifier->type) {
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit_modifier = modifier->Cast<LimitModifier>();
-			if (limit_modifier.limit) {
-				callback(limit_modifier.limit);
-			}
-			if (limit_modifier.offset) {
-				callback(limit_modifier.offset);
-			}
-		} break;
-
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit_modifier = modifier->Cast<LimitPercentModifier>();
-			if (limit_modifier.limit) {
-				callback(limit_modifier.limit);
-			}
-			if (limit_modifier.offset) {
-				callback(limit_modifier.offset);
-			}
-		} break;
-
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order_modifier = modifier->Cast<OrderModifier>();
-			for (auto &order : order_modifier.orders) {
-				callback(order.expression);
-			}
-		} break;
-
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct_modifier = modifier->Cast<DistinctModifier>();
-			for (auto &target : distinct_modifier.distinct_on_targets) {
-				callback(target);
-			}
-		} break;
-
-		// do nothing
-		default:
-			break;
-		}
-	}
-}
-
-void ParsedExpressionIterator::EnumerateTableRefChildren(
-    TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
-    const std::function<void(TableRef &ref)> &ref_callback) {
-	switch (ref.type) {
-	case TableReferenceType::EXPRESSION_LIST: {
-		auto &el_ref = ref.Cast<ExpressionListRef>();
-		for (idx_t i = 0; i < el_ref.values.size(); i++) {
-			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
-				expr_callback(el_ref.values[i][j]);
-			}
-		}
-		break;
-	}
-	case TableReferenceType::JOIN: {
-		auto &j_ref = ref.Cast<JoinRef>();
-		EnumerateTableRefChildren(*j_ref.left, expr_callback, ref_callback);
-		EnumerateTableRefChildren(*j_ref.right, expr_callback, ref_callback);
-		if (j_ref.condition) {
-			expr_callback(j_ref.condition);
-		}
-		break;
-	}
-	case TableReferenceType::PIVOT: {
-		auto &p_ref = ref.Cast<PivotRef>();
-		EnumerateTableRefChildren(*p_ref.source, expr_callback, ref_callback);
-		for (auto &aggr : p_ref.aggregates) {
-			expr_callback(aggr);
-		}
-		break;
-	}
-	case TableReferenceType::SUBQUERY: {
-		auto &sq_ref = ref.Cast<SubqueryRef>();
-		EnumerateQueryNodeChildren(*sq_ref.subquery->node, expr_callback, ref_callback);
-		break;
-	}
-	case TableReferenceType::TABLE_FUNCTION: {
-		auto &tf_ref = ref.Cast<TableFunctionRef>();
-		expr_callback(tf_ref.function);
-		break;
-	}
-	case TableReferenceType::BASE_TABLE:
-	case TableReferenceType::EMPTY_FROM:
-	case TableReferenceType::SHOW_REF:
-	case TableReferenceType::COLUMN_DATA:
-	case TableReferenceType::DELIM_GET:
-		// these TableRefs do not need to be unfolded
-		break;
-	case TableReferenceType::INVALID:
-	case TableReferenceType::CTE:
-		throw NotImplementedException("TableRef type not implemented for traversal");
-	}
-	ref_callback(ref);
-}
-
-void ParsedExpressionIterator::EnumerateQueryNodeChildren(
-    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
-    const std::function<void(TableRef &ref)> &ref_callback) {
-	switch (node.type) {
-	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &rcte_node = node.Cast<RecursiveCTENode>();
-		EnumerateQueryNodeChildren(*rcte_node.left, expr_callback, ref_callback);
-		EnumerateQueryNodeChildren(*rcte_node.right, expr_callback, ref_callback);
-		break;
-	}
-	case QueryNodeType::CTE_NODE: {
-		auto &cte_node = node.Cast<CTENode>();
-		EnumerateQueryNodeChildren(*cte_node.query, expr_callback, ref_callback);
-		EnumerateQueryNodeChildren(*cte_node.child, expr_callback, ref_callback);
-		break;
-	}
-	case QueryNodeType::SELECT_NODE: {
-		auto &sel_node = node.Cast<SelectNode>();
-		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
-			expr_callback(sel_node.select_list[i]);
-		}
-		for (idx_t i = 0; i < sel_node.groups.group_expressions.size(); i++) {
-			expr_callback(sel_node.groups.group_expressions[i]);
-		}
-		if (sel_node.where_clause) {
-			expr_callback(sel_node.where_clause);
-		}
-		if (sel_node.having) {
-			expr_callback(sel_node.having);
-		}
-		if (sel_node.qualify) {
-			expr_callback(sel_node.qualify);
-		}
-
-		EnumerateTableRefChildren(*sel_node.from_table.get(), expr_callback, ref_callback);
-		break;
-	}
-	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &setop_node = node.Cast<SetOperationNode>();
-		EnumerateQueryNodeChildren(*setop_node.left, expr_callback, ref_callback);
-		EnumerateQueryNodeChildren(*setop_node.right, expr_callback, ref_callback);
-		break;
-	}
-	default:
-		throw NotImplementedException("QueryNode type not implemented for traversal");
-	}
-
-	if (!node.modifiers.empty()) {
-		EnumerateQueryNodeModifiers(node, expr_callback);
-	}
-
-	for (auto &kv : node.cte_map.map) {
-		EnumerateQueryNodeChildren(*kv.second->query->node, expr_callback, ref_callback);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/parser.cpp b/src/duckdb/src/parser/parser.cpp
deleted file mode 100644
index 77ad899f1..000000000
--- a/src/duckdb/src/parser/parser.cpp
+++ /dev/null
@@ -1,612 +0,0 @@
-#include "duckdb/parser/parser.hpp"
-
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/group_by_node.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/parser_extension.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/statement/extension_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "parser/parser.hpp"
-#include "postgres_parser.hpp"
-
-namespace duckdb {
-
-Parser::Parser(ParserOptions options_p) : options(options_p) {
-}
-
-struct UnicodeSpace {
-	UnicodeSpace(idx_t pos, idx_t bytes) : pos(pos), bytes(bytes) {
-	}
-
-	idx_t pos;
-	idx_t bytes;
-};
-
-static bool ReplaceUnicodeSpaces(const string &query, string &new_query, vector<UnicodeSpace> &unicode_spaces) {
-	if (unicode_spaces.empty()) {
-		// no unicode spaces found
-		return false;
-	}
-	idx_t prev = 0;
-	for (auto &usp : unicode_spaces) {
-		new_query += query.substr(prev, usp.pos - prev);
-		new_query += " ";
-		prev = usp.pos + usp.bytes;
-	}
-	new_query += query.substr(prev, query.size() - prev);
-	return true;
-}
-
-static bool IsValidDollarQuotedStringTagFirstChar(const unsigned char &c) {
-	// the first character can be between A-Z, a-z, or \200 - \377
-	return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c >= 0x80;
-}
-
-static bool IsValidDollarQuotedStringTagSubsequentChar(const unsigned char &c) {
-	// subsequent characters can also be between 0-9
-	return IsValidDollarQuotedStringTagFirstChar(c) || (c >= '0' && c <= '9');
-}
-
-// This function strips unicode space characters from the query and replaces them with regular spaces
-// It returns true if any unicode space characters were found and stripped
-// See here for a list of unicode space characters - https://jkorpela.fi/chars/spaces.html
-bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) {
-	const idx_t NBSP_LEN = 2;
-	const idx_t USP_LEN = 3;
-	idx_t pos = 0;
-	unsigned char quote;
-	string_t dollar_quote_tag;
-	vector<UnicodeSpace> unicode_spaces;
-	auto query = const_uchar_ptr_cast(query_str.c_str());
-	auto qsize = query_str.size();
-
-regular:
-	for (; pos + 2 < qsize; pos++) {
-		if (query[pos] == 0xC2) {
-			if (query[pos + 1] == 0xA0) {
-				// U+00A0 - C2A0
-				unicode_spaces.emplace_back(pos, NBSP_LEN);
-			}
-		}
-		if (query[pos] == 0xE2) {
-			if (query[pos + 1] == 0x80) {
-				if (query[pos + 2] >= 0x80 && query[pos + 2] <= 0x8B) {
-					// U+2000 to U+200B
-					// E28080 - E2808B
-					unicode_spaces.emplace_back(pos, USP_LEN);
-				} else if (query[pos + 2] == 0xAF) {
-					// U+202F - E280AF
-					unicode_spaces.emplace_back(pos, USP_LEN);
-				}
-			} else if (query[pos + 1] == 0x81) {
-				if (query[pos + 2] == 0x9F) {
-					// U+205F - E2819f
-					unicode_spaces.emplace_back(pos, USP_LEN);
-				} else if (query[pos + 2] == 0xA0) {
-					// U+2060 - E281A0
-					unicode_spaces.emplace_back(pos, USP_LEN);
-				}
-			}
-		} else if (query[pos] == 0xE3) {
-			if (query[pos + 1] == 0x80 && query[pos + 2] == 0x80) {
-				// U+3000 - E38080
-				unicode_spaces.emplace_back(pos, USP_LEN);
-			}
-		} else if (query[pos] == 0xEF) {
-			if (query[pos + 1] == 0xBB && query[pos + 2] == 0xBF) {
-				// U+FEFF - EFBBBF
-				unicode_spaces.emplace_back(pos, USP_LEN);
-			}
-		} else if (query[pos] == '"' || query[pos] == '\'') {
-			quote = query[pos];
-			pos++;
-			goto in_quotes;
-		} else if (query[pos] == '$' &&
-		           (query[pos + 1] == '$' || IsValidDollarQuotedStringTagFirstChar(query[pos + 1]))) {
-			// (optionally tagged) dollar-quoted string
-			auto start = &query[++pos];
-			for (; pos + 2 < qsize; pos++) {
-				if (query[pos] == '$') {
-					// end of tag
-					dollar_quote_tag =
-					    string_t(const_char_ptr_cast(start), NumericCast<uint32_t, int64_t>(&query[pos] - start));
-					goto in_dollar_quotes;
-				}
-
-				if (!IsValidDollarQuotedStringTagSubsequentChar(query[pos])) {
-					// invalid char in dollar-quoted string, continue as normal
-					goto regular;
-				}
-			}
-			goto end;
-		} else if (query[pos] == '-' && query[pos + 1] == '-') {
-			goto in_comment;
-		}
-	}
-	goto end;
-in_quotes:
-	for (; pos + 1 < qsize; pos++) {
-		if (query[pos] == quote) {
-			if (query[pos + 1] == quote) {
-				// escaped quote
-				pos++;
-				continue;
-			}
-			pos++;
-			goto regular;
-		}
-	}
-	goto end;
-in_dollar_quotes:
-	for (; pos + 2 < qsize; pos++) {
-		if (query[pos] == '$' &&
-		    qsize - (pos + 1) >= dollar_quote_tag.GetSize() + 1 && // found '$' and enough space left
-		    query[pos + dollar_quote_tag.GetSize() + 1] == '$' &&  // ending '$' at the right spot
-		    memcmp(&query[pos + 1], dollar_quote_tag.GetData(), dollar_quote_tag.GetSize()) == 0) { // tags match
-			pos += dollar_quote_tag.GetSize() + 1;
-			goto regular;
-		}
-	}
-	goto end;
-in_comment:
-	for (; pos < qsize; pos++) {
-		if (query[pos] == '\n' || query[pos] == '\r') {
-			goto regular;
-		}
-	}
-	goto end;
-end:
-	return ReplaceUnicodeSpaces(query_str, new_query, unicode_spaces);
-}
-
-vector<string> SplitQueryStringIntoStatements(const string &query) {
-	// Break sql string down into sql statements using the tokenizer
-	vector<string> query_statements;
-	auto tokens = Parser::Tokenize(query);
-	idx_t next_statement_start = 0;
-	for (idx_t i = 1; i < tokens.size(); ++i) {
-		auto &t_prev = tokens[i - 1];
-		auto &t = tokens[i];
-		if (t_prev.type == SimplifiedTokenType::SIMPLIFIED_TOKEN_OPERATOR) {
-			// LCOV_EXCL_START
-			for (idx_t c = t_prev.start; c <= t.start; ++c) {
-				if (query.c_str()[c] == ';') {
-					query_statements.emplace_back(query.substr(next_statement_start, t.start - next_statement_start));
-					next_statement_start = tokens[i].start;
-				}
-			}
-			// LCOV_EXCL_STOP
-		}
-	}
-	query_statements.emplace_back(query.substr(next_statement_start, query.size() - next_statement_start));
-	return query_statements;
-}
-
-void Parser::ParseQuery(const string &query) {
-	Transformer transformer(options);
-	string parser_error;
-	optional_idx parser_error_location;
-	{
-		// check if there are any unicode spaces in the string
-		string new_query;
-		if (StripUnicodeSpaces(query, new_query)) {
-			// there are - strip the unicode spaces and re-run the query
-			ParseQuery(new_query);
-			return;
-		}
-	}
-	{
-		PostgresParser::SetPreserveIdentifierCase(options.preserve_identifier_case);
-		bool parsing_succeed = false;
-		// Creating a new scope to prevent multiple PostgresParser destructors being called
-		// which led to some memory issues
-		{
-			PostgresParser parser;
-			parser.Parse(query);
-			if (parser.success) {
-				if (!parser.parse_tree) {
-					// empty statement
-					return;
-				}
-
-				// if it succeeded, we transform the Postgres parse tree into a list of
-				// SQLStatements
-				transformer.TransformParseTree(parser.parse_tree, statements);
-				parsing_succeed = true;
-			} else {
-				parser_error = parser.error_message;
-				if (parser.error_location > 0) {
-					parser_error_location = NumericCast<idx_t>(parser.error_location - 1);
-				}
-			}
-		}
-		// If DuckDB fails to parse the entire sql string, break the string down into individual statements
-		// using ';' as the delimiter so that parser extensions can parse the statement
-		if (parsing_succeed) {
-			// no-op
-			// return here would require refactoring into another function. o.w. will just no-op in order to run wrap up
-			// code at the end of this function
-		} else if (!options.extensions || options.extensions->empty()) {
-			throw ParserException::SyntaxError(query, parser_error, parser_error_location);
-		} else {
-			// split sql string into statements and re-parse using extension
-			auto query_statements = SplitQueryStringIntoStatements(query);
-			idx_t stmt_loc = 0;
-			for (auto const &query_statement : query_statements) {
-				ErrorData another_parser_error;
-				// Creating a new scope to allow extensions to use PostgresParser, which is not reentrant
-				{
-					PostgresParser another_parser;
-					another_parser.Parse(query_statement);
-					// LCOV_EXCL_START
-					// first see if DuckDB can parse this individual query statement
-					if (another_parser.success) {
-						if (!another_parser.parse_tree) {
-							// empty statement
-							continue;
-						}
-						transformer.TransformParseTree(another_parser.parse_tree, statements);
-						// important to set in the case of a mixture of DDB and parser ext statements
-						statements.back()->stmt_length = query_statement.size() - 1;
-						statements.back()->stmt_location = stmt_loc;
-						stmt_loc += query_statement.size();
-						continue;
-					} else {
-						another_parser_error = ErrorData(another_parser.error_message);
-						if (another_parser.error_location > 0) {
-							another_parser_error.AddQueryLocation(
-							    NumericCast<idx_t>(another_parser.error_location - 1));
-						}
-					}
-				} // LCOV_EXCL_STOP
-				// LCOV_EXCL_START
-				// let extensions parse the statement which DuckDB failed to parse
-				bool parsed_single_statement = false;
-				for (auto &ext : *options.extensions) {
-					D_ASSERT(!parsed_single_statement);
-					D_ASSERT(ext.parse_function);
-					auto result = ext.parse_function(ext.parser_info.get(), query_statement);
-					if (result.type == ParserExtensionResultType::PARSE_SUCCESSFUL) {
-						auto statement = make_uniq<ExtensionStatement>(ext, std::move(result.parse_data));
-						statement->stmt_length = query_statement.size() - 1;
-						statement->stmt_location = stmt_loc;
-						stmt_loc += query_statement.size();
-						statements.push_back(std::move(statement));
-						parsed_single_statement = true;
-						break;
-					} else if (result.type == ParserExtensionResultType::DISPLAY_EXTENSION_ERROR) {
-						throw ParserException::SyntaxError(query, result.error, result.error_location);
-					} else {
-						// We move to the next one!
-					}
-				}
-				if (!parsed_single_statement) {
-					throw ParserException::SyntaxError(query, parser_error, parser_error_location);
-				} // LCOV_EXCL_STOP
-			}
-		}
-	}
-	if (!statements.empty()) {
-		auto &last_statement = statements.back();
-		last_statement->stmt_length = query.size() - last_statement->stmt_location;
-		for (auto &statement : statements) {
-			statement->query = query;
-			if (statement->type == StatementType::CREATE_STATEMENT) {
-				auto &create = statement->Cast<CreateStatement>();
-				create.info->sql = query.substr(statement->stmt_location, statement->stmt_length);
-			}
-		}
-	}
-}
-
-vector<SimplifiedToken> Parser::Tokenize(const string &query) {
-	auto pg_tokens = PostgresParser::Tokenize(query);
-	vector<SimplifiedToken> result;
-	result.reserve(pg_tokens.size());
-	for (auto &pg_token : pg_tokens) {
-		SimplifiedToken token;
-		switch (pg_token.type) {
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_IDENTIFIER:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_NUMERIC_CONSTANT:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_NUMERIC_CONSTANT;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_STRING_CONSTANT:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_STRING_CONSTANT;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_OPERATOR:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_OPERATOR;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_KEYWORD:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_KEYWORD;
-			break;
-		// comments are not supported by our tokenizer right now
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_COMMENT: // LCOV_EXCL_START
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_COMMENT;
-			break;
-		default:
-			throw InternalException("Unrecognized token category");
-		} // LCOV_EXCL_STOP
-		token.start = NumericCast<idx_t>(pg_token.start);
-		result.push_back(token);
-	}
-	return result;
-}
-
-vector<SimplifiedToken> Parser::TokenizeError(const string &error_msg) {
-	idx_t error_start = 0;
-	idx_t error_end = error_msg.size();
-
-	vector<SimplifiedToken> tokens;
-	// find "XXX Error:" - this marks the start of the error message
-	auto error = StringUtil::Find(error_msg, "Error: ");
-	if (error.IsValid()) {
-		SimplifiedToken token;
-		token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR;
-		token.start = 0;
-		tokens.push_back(token);
-
-		token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER;
-		token.start = error.GetIndex() + 6;
-		tokens.push_back(token);
-
-		error_start = error.GetIndex() + 7;
-	}
-
-	// find "LINE (number)" - this marks the end of the message
-	auto line_pos = StringUtil::Find(error_msg, "\nLINE ");
-	if (line_pos.IsValid()) {
-		// tokenize between
-		error_end = line_pos.GetIndex();
-	}
-
-	// now iterate over the
-	bool in_quotes = false;
-	char quote_char = '\0';
-	for (idx_t i = error_start; i < error_end; i++) {
-		if (in_quotes) {
-			// in a quote - look for the quote character
-			if (error_msg[i] == quote_char) {
-				SimplifiedToken token;
-				token.start = i;
-				token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER;
-				tokens.push_back(token);
-				in_quotes = false;
-			}
-			if (StringUtil::CharacterIsNewline(error_msg[i])) {
-				// found a newline in a quote, abort the quoted state entirely
-				tokens.pop_back();
-				in_quotes = false;
-			}
-		} else if (error_msg[i] == '"' || error_msg[i] == '\'') {
-			// not quoted and found a quote - enter the quoted state
-			SimplifiedToken token;
-			token.start = i;
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_STRING_CONSTANT;
-			token.start++;
-			tokens.push_back(token);
-			quote_char = error_msg[i];
-			in_quotes = true;
-		}
-	}
-	if (in_quotes) {
-		// unterminated quotes at the end of the error - pop back the quoted state
-		tokens.pop_back();
-	}
-	if (line_pos.IsValid()) {
-		SimplifiedToken token;
-		token.start = line_pos.GetIndex() + 1;
-		token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_COMMENT;
-		tokens.push_back(token);
-
-		// tokenize the LINE part
-		idx_t query_start;
-		for (query_start = line_pos.GetIndex() + 6; query_start < error_msg.size(); query_start++) {
-			if (error_msg[query_start] != ':' && !StringUtil::CharacterIsDigit(error_msg[query_start])) {
-				break;
-			}
-		}
-		if (query_start < error_msg.size()) {
-			token.start = query_start;
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER;
-			tokens.push_back(token);
-
-			idx_t query_end;
-			for (query_end = query_start; query_end < error_msg.size(); query_end++) {
-				if (error_msg[query_end] == '\n') {
-					break;
-				}
-			}
-			// after LINE XXX: comes a caret - look for it
-			idx_t caret_position = error_msg.size();
-			bool place_caret = false;
-			idx_t caret_start = query_end + 1;
-			if (caret_start < error_msg.size()) {
-				for (idx_t i = caret_start; i < error_msg.size(); i++) {
-					if (error_msg[i] == '^') {
-						// found the caret
-						// to get the caret position in the query we need to
-						caret_position = i - caret_start - ((query_start - line_pos.GetIndex()) - 1);
-						place_caret = true;
-						break;
-					}
-				}
-			}
-			// tokenize the actual query
-			string query = error_msg.substr(query_start, query_end - query_start);
-			auto query_tokens = Tokenize(query);
-			for (auto &query_token : query_tokens) {
-				if (place_caret) {
-					if (query_token.start >= caret_position) {
-						// we need to place the caret here
-						query_token.start = query_start + caret_position;
-						query_token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR;
-						tokens.push_back(query_token);
-
-						place_caret = false;
-						continue;
-					}
-				}
-				query_token.start += query_start;
-				tokens.push_back(query_token);
-			}
-			// FIXME: find the caret position and highlight/bold the identifier it points to
-			if (query_end < error_msg.size()) {
-				token.start = query_end;
-				token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR;
-				tokens.push_back(token);
-			}
-		}
-	}
-	return tokens;
-}
-
-KeywordCategory ToKeywordCategory(duckdb_libpgquery::PGKeywordCategory type) {
-	switch (type) {
-	case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_RESERVED:
-		return KeywordCategory::KEYWORD_RESERVED;
-	case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_UNRESERVED:
-		return KeywordCategory::KEYWORD_UNRESERVED;
-	case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_TYPE_FUNC:
-		return KeywordCategory::KEYWORD_TYPE_FUNC;
-	case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_COL_NAME:
-		return KeywordCategory::KEYWORD_COL_NAME;
-	case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_NONE:
-		return KeywordCategory::KEYWORD_NONE;
-	default:
-		throw InternalException("Unrecognized keyword category");
-	}
-}
-
-KeywordCategory Parser::IsKeyword(const string &text) {
-	return ToKeywordCategory(PostgresParser::IsKeyword(text));
-}
-
-vector<ParserKeyword> Parser::KeywordList() {
-	auto keywords = PostgresParser::KeywordList();
-	vector<ParserKeyword> result;
-	for (auto &kw : keywords) {
-		ParserKeyword res;
-		res.name = kw.text;
-		res.category = ToKeywordCategory(kw.category);
-		result.push_back(res);
-	}
-	return result;
-}
-
-vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list, ParserOptions options) {
-	// construct a mock query prefixed with SELECT
-	string mock_query = "SELECT " + select_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = parser.statements[0]->Cast<SelectStatement>();
-	if (select.node->type != QueryNodeType::SELECT_NODE) {
-		throw ParserException("Expected a single SELECT node");
-	}
-	auto &select_node = select.node->Cast<SelectNode>();
-	return std::move(select_node.select_list);
-}
-
-GroupByNode Parser::ParseGroupByList(const string &group_by, ParserOptions options) {
-	// construct a mock SELECT query with our group_by expressions
-	string mock_query = StringUtil::Format("SELECT 42 GROUP BY %s", group_by);
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the result
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = parser.statements[0]->Cast<SelectStatement>();
-	D_ASSERT(select.node->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = select.node->Cast<SelectNode>();
-	return std::move(select_node.groups);
-}
-
-vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOptions options) {
-	// construct a mock query
-	string mock_query = "SELECT * FROM tbl ORDER BY " + select_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = parser.statements[0]->Cast<SelectStatement>();
-	D_ASSERT(select.node->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = select.node->Cast<SelectNode>();
-	if (select_node.modifiers.empty() || select_node.modifiers[0]->type != ResultModifierType::ORDER_MODIFIER ||
-	    select_node.modifiers.size() != 1) {
-		throw ParserException("Expected a single ORDER clause");
-	}
-	auto &order = select_node.modifiers[0]->Cast<OrderModifier>();
-	return std::move(order.orders);
-}
-
-void Parser::ParseUpdateList(const string &update_list, vector<string> &update_columns,
-                             vector<unique_ptr<ParsedExpression>> &expressions, ParserOptions options) {
-	// construct a mock query
-	string mock_query = "UPDATE tbl SET " + update_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::UPDATE_STATEMENT) {
-		throw ParserException("Expected a single UPDATE statement");
-	}
-	auto &update = parser.statements[0]->Cast<UpdateStatement>();
-	update_columns = std::move(update.set_info->columns);
-	expressions = std::move(update.set_info->expressions);
-}
-
-vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const string &value_list, ParserOptions options) {
-	// construct a mock query
-	string mock_query = "VALUES " + value_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = parser.statements[0]->Cast<SelectStatement>();
-	if (select.node->type != QueryNodeType::SELECT_NODE) {
-		throw ParserException("Expected a single SELECT node");
-	}
-	auto &select_node = select.node->Cast<SelectNode>();
-	if (!select_node.from_table || select_node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
-		throw ParserException("Expected a single VALUES statement");
-	}
-	auto &values_list = select_node.from_table->Cast<ExpressionListRef>();
-	return std::move(values_list.values);
-}
-
-ColumnList Parser::ParseColumnList(const string &column_list, ParserOptions options) {
-	string mock_query = "CREATE TABLE tbl (" + column_list + ")";
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
-		throw ParserException("Expected a single CREATE statement");
-	}
-	auto &create = parser.statements[0]->Cast<CreateStatement>();
-	if (create.info->type != CatalogType::TABLE_ENTRY) {
-		throw InternalException("Expected a single CREATE TABLE statement");
-	}
-	auto &info = create.info->Cast<CreateTableInfo>();
-	return std::move(info.columns);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/qualified_name.cpp b/src/duckdb/src/parser/qualified_name.cpp
deleted file mode 100644
index c4567edea..000000000
--- a/src/duckdb/src/parser/qualified_name.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-
-namespace duckdb {
-
-string QualifiedName::ToString() const {
-	return ParseInfo::QualifierToString(catalog, schema, name);
-}
-
-QualifiedName QualifiedName::Parse(const string &input) {
-	string catalog;
-	string schema;
-	string name;
-	idx_t idx = 0;
-	vector<string> entries;
-	string entry;
-normal:
-	//! quote
-	for (; idx < input.size(); idx++) {
-		if (input[idx] == '"') {
-			idx++;
-			goto quoted;
-		} else if (input[idx] == '.') {
-			goto separator;
-		}
-		entry += input[idx];
-	}
-	goto end;
-separator:
-	entries.push_back(entry);
-	entry = "";
-	idx++;
-	goto normal;
-quoted:
-	//! look for another quote
-	for (; idx < input.size(); idx++) {
-		if (input[idx] == '"') {
-			//! unquote
-			idx++;
-			goto normal;
-		}
-		entry += input[idx];
-	}
-	throw ParserException("Unterminated quote in qualified name!");
-end:
-	if (entries.empty()) {
-		catalog = INVALID_CATALOG;
-		schema = INVALID_SCHEMA;
-		name = entry;
-	} else if (entries.size() == 1) {
-		catalog = INVALID_CATALOG;
-		schema = entries[0];
-		name = entry;
-	} else if (entries.size() == 2) {
-		catalog = entries[0];
-		schema = entries[1];
-		name = entry;
-	} else {
-		throw ParserException("Expected catalog.entry, schema.entry or entry: too many entries found");
-	}
-	return QualifiedName {catalog, schema, name};
-}
-
-QualifiedColumnName::QualifiedColumnName() {
-}
-QualifiedColumnName::QualifiedColumnName(string column_p) : column(std::move(column_p)) {
-}
-QualifiedColumnName::QualifiedColumnName(string table_p, string column_p)
-    : table(std::move(table_p)), column(std::move(column_p)) {
-}
-QualifiedColumnName::QualifiedColumnName(const BindingAlias &alias, string column_p)
-    : catalog(alias.GetCatalog()), schema(alias.GetSchema()), table(alias.GetAlias()), column(std::move(column_p)) {
-}
-
-string QualifiedColumnName::ToString() const {
-	string result;
-	if (!catalog.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
-	}
-	if (!schema.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-	}
-	if (!table.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(table) + ".";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(column);
-	return result;
-}
-
-bool QualifiedColumnName::IsQualified() const {
-	return !catalog.empty() || !schema.empty() || !table.empty();
-}
-
-bool QualifiedColumnName::operator==(const QualifiedColumnName &rhs) const {
-	return StringUtil::CIEquals(catalog, rhs.catalog) && StringUtil::CIEquals(schema, rhs.schema) &&
-	       StringUtil::CIEquals(table, rhs.table) && StringUtil::CIEquals(column, rhs.column);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/query_error_context.cpp b/src/duckdb/src/parser/query_error_context.cpp
deleted file mode 100644
index f8545714e..000000000
--- a/src/duckdb/src/parser/query_error_context.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-string QueryErrorContext::Format(const string &query, const string &error_message, optional_idx error_loc,
-                                 bool add_line_indicator) {
-	static constexpr idx_t MAX_LINE_RENDER_WIDTH = 120;
-	if (!error_loc.IsValid()) {
-		// no location in query provided
-		return error_message;
-	}
-	idx_t error_location = error_loc.GetIndex();
-	if (error_location >= query.size()) {
-		// out of bounds
-		return error_message;
-	}
-	// count the line numbers until the error location
-	// and set the start position as the first character of that line
-	idx_t start_pos = 0;
-	idx_t line_number = 1;
-	for (idx_t i = 0; i < error_location; i++) {
-		bool is_newline = false;
-		switch (query[i]) {
-		case '\r':
-			if (i + 1 >= error_location || query[i + 1] != '\n') {
-				// not \r\n
-				is_newline = true;
-			}
-			break;
-		case '\n':
-			is_newline = true;
-			break;
-		default:
-			break;
-		}
-		if (is_newline) {
-			line_number++;
-			start_pos = i + 1;
-		}
-	}
-	// now find either the next newline token after the query, or find the end of string
-	// this is the initial end position
-	idx_t end_pos = query.size();
-	for (idx_t i = error_location; i < query.size(); i++) {
-		if (StringUtil::CharacterIsNewline(query[i])) {
-			end_pos = i;
-			break;
-		}
-	}
-	// now start scanning from the start pos
-	// we want to figure out the start and end pos of what we are going to render
-	// we want to render at most 80 characters in total, with the error_location located in the middle
-	const char *buf = query.c_str() + start_pos;
-	idx_t len = end_pos - start_pos;
-	vector<idx_t> render_widths;
-	vector<idx_t> positions;
-	vector<idx_t> natural_break;
-	if (Utf8Proc::IsValid(buf, len)) {
-		// for unicode awareness, we traverse the graphemes of the current line and keep track of their render widths
-		// and of their position in the string
-		for (idx_t cpos = 0; cpos < len;) {
-			auto char_render_width = Utf8Proc::RenderWidth(buf, len, cpos);
-			positions.push_back(cpos);
-			render_widths.push_back(char_render_width);
-			natural_break.push_back(StringUtil::CharacterIsOperator(buf[cpos]) ||
-			                        StringUtil::CharacterIsSpace(buf[cpos]));
-			cpos = Utf8Proc::NextGraphemeCluster(buf, len, cpos);
-		}
-	} else { // LCOV_EXCL_START
-		// invalid utf-8, we can't do much at this point
-		// we just assume every character is a character, and every character has a render width of 1
-		for (idx_t cpos = 0; cpos < len; cpos++) {
-			positions.push_back(cpos);
-			render_widths.push_back(1);
-			natural_break.push_back(StringUtil::CharacterIsOperator(buf[cpos]) ||
-			                        StringUtil::CharacterIsSpace(buf[cpos]));
-		}
-	} // LCOV_EXCL_STOP
-	// now we want to find the (unicode aware) start and end position
-	idx_t epos = 0;
-	// start by finding the error location inside the array
-	for (idx_t i = 0; i < positions.size(); i++) {
-		if (positions[i] >= (error_location - start_pos)) {
-			epos = i;
-			break;
-		}
-	}
-	bool truncate_beginning = false;
-	bool truncate_end = false;
-	idx_t spos = 0;
-	// now we iterate backwards from the error location
-	// we show max 60 render width before the error location
-	idx_t error_line_start = start_pos;
-	idx_t current_render_width = 0;
-	for (idx_t i = epos; i > 0; i--) {
-		current_render_width += render_widths[i];
-		if (current_render_width >= MAX_LINE_RENDER_WIDTH / 2) {
-			// we're exceeding the render width - truncate the beginning
-			// try to break at a "nice" point (i.e. a space, bracket, etc)
-			// try to find a natural break that is within 4 bytes of here
-			idx_t start_scan = i > 4 ? i - 4 : 0;
-			idx_t end_scan = MinValue<idx_t>(i + 4, epos);
-			for (idx_t k = start_scan; k < end_scan; k++) {
-				if (natural_break[k]) {
-					i = k;
-					break;
-				}
-			}
-			truncate_beginning = true;
-			start_pos += positions[i];
-			spos = i;
-			break;
-		}
-	}
-	// now do the same, but going forward
-	current_render_width = 0;
-	for (idx_t i = epos; i < positions.size(); i++) {
-		current_render_width += render_widths[i];
-		if (current_render_width >= MAX_LINE_RENDER_WIDTH / 2) {
-			// we're exceeding the render width - truncate the end
-			// try to break at a "nice" point (i.e. a space, bracket, etc)
-			// try to find a natural break that is within 4 bytes of here
-			idx_t start_scan = i > epos + 4 ? i - 4 : epos;
-			idx_t end_scan = MinValue<idx_t>(i + 4, positions.size());
-			for (idx_t k = start_scan; k < end_scan; k++) {
-				if (natural_break[k]) {
-					i = k;
-					break;
-				}
-			}
-			truncate_end = true;
-			end_pos = error_line_start + positions[i];
-			break;
-		}
-	}
-	string line_indicator;
-	if (add_line_indicator) {
-		line_indicator = "LINE " + to_string(line_number) + ": ";
-	}
-	string begin_trunc = truncate_beginning ? "..." : "";
-	string end_trunc = truncate_end ? "..." : "";
-
-	// get the render width of the error indicator (i.e. how many spaces we need to insert before the ^)
-	idx_t error_render_width = 0;
-	for (idx_t i = spos; i < epos; i++) {
-		error_render_width += render_widths[i];
-	}
-	error_render_width += line_indicator.size() + begin_trunc.size();
-
-	// now first print the error message plus the current line (or a subset of the line)
-	string result = error_message;
-	result += "\n\n" + line_indicator + begin_trunc + query.substr(start_pos, end_pos - start_pos) + end_trunc;
-	// print an arrow pointing at the error location
-	result += "\n" + string(error_render_width, ' ') + "^";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/query_node.cpp b/src/duckdb/src/parser/query_node.cpp
deleted file mode 100644
index 7b084c5c8..000000000
--- a/src/duckdb/src/parser/query_node.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#include "duckdb/parser/query_node.hpp"
-
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-CommonTableExpressionMap::CommonTableExpressionMap() {
-}
-
-CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
-	CommonTableExpressionMap res;
-	for (auto &kv : this->map) {
-		auto kv_info = make_uniq<CommonTableExpressionInfo>();
-		for (auto &al : kv.second->aliases) {
-			kv_info->aliases.push_back(al);
-		}
-		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
-		kv_info->materialized = kv.second->materialized;
-		res.map[kv.first] = std::move(kv_info);
-	}
-
-	return res;
-}
-
-string CommonTableExpressionMap::ToString() const {
-	if (map.empty()) {
-		return string();
-	}
-	// check if there are any recursive CTEs
-	bool has_recursive = false;
-	for (auto &kv : map) {
-		if (kv.second->query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
-			has_recursive = true;
-			break;
-		}
-	}
-	string result = "WITH ";
-	if (has_recursive) {
-		result += "RECURSIVE ";
-	}
-	bool first_cte = true;
-
-	for (auto &kv : map) {
-		if (!first_cte) {
-			result += ", ";
-		}
-		auto &cte = *kv.second;
-		result += KeywordHelper::WriteOptionallyQuoted(kv.first);
-		if (!cte.aliases.empty()) {
-			result += " (";
-			for (idx_t k = 0; k < cte.aliases.size(); k++) {
-				if (k > 0) {
-					result += ", ";
-				}
-				result += KeywordHelper::WriteOptionallyQuoted(cte.aliases[k]);
-			}
-			result += ")";
-		}
-		if (kv.second->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-			result += " AS MATERIALIZED (";
-		} else if (kv.second->materialized == CTEMaterialize::CTE_MATERIALIZE_NEVER) {
-			result += " AS NOT MATERIALIZED (";
-		} else {
-			result += " AS (";
-		}
-		result += cte.query->ToString();
-		result += ")";
-		first_cte = false;
-	}
-	return result;
-}
-
-string QueryNode::ResultModifiersToString() const {
-	string result;
-	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
-		auto &modifier = *modifiers[modifier_idx];
-		if (modifier.type == ResultModifierType::ORDER_MODIFIER) {
-			auto &order_modifier = modifier.Cast<OrderModifier>();
-			result += " ORDER BY ";
-			for (idx_t k = 0; k < order_modifier.orders.size(); k++) {
-				if (k > 0) {
-					result += ", ";
-				}
-				result += order_modifier.orders[k].ToString();
-			}
-		} else if (modifier.type == ResultModifierType::LIMIT_MODIFIER) {
-			auto &limit_modifier = modifier.Cast<LimitModifier>();
-			if (limit_modifier.limit) {
-				result += " LIMIT " + limit_modifier.limit->ToString();
-			}
-			if (limit_modifier.offset) {
-				result += " OFFSET " + limit_modifier.offset->ToString();
-			}
-		} else if (modifier.type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-			auto &limit_p_modifier = modifier.Cast<LimitPercentModifier>();
-			if (limit_p_modifier.limit) {
-				result += " LIMIT (" + limit_p_modifier.limit->ToString() + ") %";
-			}
-			if (limit_p_modifier.offset) {
-				result += " OFFSET " + limit_p_modifier.offset->ToString();
-			}
-		}
-	}
-	return result;
-}
-
-bool QueryNode::Equals(const QueryNode *other) const {
-	if (!other) {
-		return false;
-	}
-	if (this == other) {
-		return true;
-	}
-	if (other->type != this->type) {
-		return false;
-	}
-
-	if (modifiers.size() != other->modifiers.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < modifiers.size(); i++) {
-		if (!modifiers[i]->Equals(*other->modifiers[i])) {
-			return false;
-		}
-	}
-	// WITH clauses (CTEs)
-	if (cte_map.map.size() != other->cte_map.map.size()) {
-		return false;
-	}
-
-	for (auto &entry : cte_map.map) {
-		auto other_entry = other->cte_map.map.find(entry.first);
-		if (other_entry == other->cte_map.map.end()) {
-			return false;
-		}
-
-		if (entry.second->aliases != other->cte_map.map.at(entry.first)->aliases) {
-			return false;
-		}
-		if (!entry.second->query->Equals(*other->cte_map.map.at(entry.first)->query)) {
-			return false;
-		}
-	}
-	return other->type == type;
-}
-
-void QueryNode::CopyProperties(QueryNode &other) const {
-	for (auto &modifier : modifiers) {
-		other.modifiers.push_back(modifier->Copy());
-	}
-	for (auto &kv : cte_map.map) {
-		auto kv_info = make_uniq<CommonTableExpressionInfo>();
-		for (auto &al : kv.second->aliases) {
-			kv_info->aliases.push_back(al);
-		}
-		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
-		kv_info->materialized = kv.second->materialized;
-		other.cte_map.map[kv.first] = std::move(kv_info);
-	}
-}
-
-void QueryNode::AddDistinct() {
-	// check if we already have a DISTINCT modifier
-	for (idx_t modifier_idx = modifiers.size(); modifier_idx > 0; modifier_idx--) {
-		auto &modifier = *modifiers[modifier_idx - 1];
-		if (modifier.type == ResultModifierType::DISTINCT_MODIFIER) {
-			auto &distinct_modifier = modifier.Cast<DistinctModifier>();
-			if (distinct_modifier.distinct_on_targets.empty()) {
-				// we have a DISTINCT without an ON clause - this distinct does not need to be added
-				return;
-			}
-		} else if (modifier.type == ResultModifierType::LIMIT_MODIFIER ||
-		           modifier.type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-			// we encountered a LIMIT or LIMIT PERCENT - these change the result of DISTINCT, so we do need to push a
-			// DISTINCT relation
-			break;
-		}
-	}
-	modifiers.push_back(make_uniq<DistinctModifier>());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/query_node/cte_node.cpp b/src/duckdb/src/parser/query_node/cte_node.cpp
deleted file mode 100644
index 4504c9857..000000000
--- a/src/duckdb/src/parser/query_node/cte_node.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string CTENode::ToString() const {
-	string result;
-	result += child->ToString();
-	return result;
-}
-
-bool CTENode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto &other = other_p->Cast<CTENode>();
-
-	if (!query->Equals(other.query.get())) {
-		return false;
-	}
-	if (!child->Equals(other.child.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> CTENode::Copy() const {
-	auto result = make_uniq<CTENode>();
-	result->ctename = ctename;
-	result->query = query->Copy();
-	result->child = child->Copy();
-	result->aliases = aliases;
-	this->CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/query_node/recursive_cte_node.cpp b/src/duckdb/src/parser/query_node/recursive_cte_node.cpp
deleted file mode 100644
index 120547e6c..000000000
--- a/src/duckdb/src/parser/query_node/recursive_cte_node.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string RecursiveCTENode::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "(" + left->ToString() + ")";
-	result += " UNION ";
-	if (union_all) {
-		result += " ALL ";
-	}
-	result += "(" + right->ToString() + ")";
-	return result;
-}
-
-bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto &other = other_p->Cast<RecursiveCTENode>();
-
-	if (other.union_all != union_all) {
-		return false;
-	}
-	if (!left->Equals(other.left.get())) {
-		return false;
-	}
-	if (!right->Equals(other.right.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
-	auto result = make_uniq<RecursiveCTENode>();
-	result->ctename = ctename;
-	result->union_all = union_all;
-	result->left = left->Copy();
-	result->right = right->Copy();
-	result->aliases = aliases;
-	this->CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/query_node/select_node.cpp b/src/duckdb/src/parser/query_node/select_node.cpp
deleted file mode 100644
index 3c3e4537c..000000000
--- a/src/duckdb/src/parser/query_node/select_node.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression_util.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-SelectNode::SelectNode()
-    : QueryNode(QueryNodeType::SELECT_NODE), aggregate_handling(AggregateHandling::STANDARD_HANDLING) {
-}
-
-string SelectNode::ToString() const {
-	if (from_table && from_table->type == TableReferenceType::SHOW_REF) {
-		D_ASSERT(select_list.size() == 1);
-		return from_table->ToString();
-	}
-	string result;
-	result = cte_map.ToString();
-	result += "SELECT ";
-
-	// search for a distinct modifier
-	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
-		if (modifiers[modifier_idx]->type == ResultModifierType::DISTINCT_MODIFIER) {
-			auto &distinct_modifier = modifiers[modifier_idx]->Cast<DistinctModifier>();
-			result += "DISTINCT ";
-			if (!distinct_modifier.distinct_on_targets.empty()) {
-				result += "ON (";
-				for (idx_t k = 0; k < distinct_modifier.distinct_on_targets.size(); k++) {
-					if (k > 0) {
-						result += ", ";
-					}
-					result += distinct_modifier.distinct_on_targets[k]->ToString();
-				}
-				result += ") ";
-			}
-		}
-	}
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += select_list[i]->ToString();
-		if (!select_list[i]->GetAlias().empty()) {
-			result += StringUtil::Format(" AS %s", SQLIdentifier(select_list[i]->GetAlias()));
-		}
-	}
-	if (from_table && from_table->type != TableReferenceType::EMPTY_FROM) {
-		result += " FROM " + from_table->ToString();
-	}
-	if (where_clause) {
-		result += " WHERE " + where_clause->ToString();
-	}
-	if (!groups.grouping_sets.empty()) {
-		result += " GROUP BY ";
-		// if we are dealing with multiple grouping sets, we have to add a few additional brackets
-		bool grouping_sets = groups.grouping_sets.size() > 1;
-		if (grouping_sets) {
-			result += "GROUPING SETS (";
-		}
-		for (idx_t i = 0; i < groups.grouping_sets.size(); i++) {
-			auto &grouping_set = groups.grouping_sets[i];
-			if (i > 0) {
-				result += ",";
-			}
-			if (grouping_set.empty()) {
-				result += "()";
-				continue;
-			}
-			if (grouping_sets) {
-				result += "(";
-			}
-			bool first = true;
-			for (auto &grp : grouping_set) {
-				if (!first) {
-					result += ", ";
-				}
-				result += groups.group_expressions[grp]->ToString();
-				first = false;
-			}
-			if (grouping_sets) {
-				result += ")";
-			}
-		}
-		if (grouping_sets) {
-			result += ")";
-		}
-	} else if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-		result += " GROUP BY ALL";
-	}
-	if (having) {
-		result += " HAVING " + having->ToString();
-	}
-	if (qualify) {
-		result += " QUALIFY " + qualify->ToString();
-	}
-	if (sample) {
-		result += " USING SAMPLE ";
-		result += sample->sample_size.ToString();
-		if (sample->is_percentage) {
-			result += "%";
-		}
-		result += " (" + EnumUtil::ToString(sample->method);
-		if (sample->seed.IsValid()) {
-			result += ", " + std::to_string(sample->seed.GetIndex());
-		}
-		result += ")";
-	}
-	return result + ResultModifiersToString();
-}
-
-bool SelectNode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto &other = other_p->Cast<SelectNode>();
-
-	// SELECT
-	if (!ExpressionUtil::ListEquals(select_list, other.select_list)) {
-		return false;
-	}
-	// FROM
-	if (!TableRef::Equals(from_table, other.from_table)) {
-		return false;
-	}
-	// WHERE
-	if (!ParsedExpression::Equals(where_clause, other.where_clause)) {
-		return false;
-	}
-	// GROUP BY
-	if (!ParsedExpression::ListEquals(groups.group_expressions, other.groups.group_expressions)) {
-		return false;
-	}
-	if (groups.grouping_sets != other.groups.grouping_sets) {
-		return false;
-	}
-	if (!SampleOptions::Equals(sample.get(), other.sample.get())) {
-		return false;
-	}
-	// HAVING
-	if (!ParsedExpression::Equals(having, other.having)) {
-		return false;
-	}
-	// QUALIFY
-	if (!ParsedExpression::Equals(qualify, other.qualify)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> SelectNode::Copy() const {
-	auto result = make_uniq<SelectNode>();
-	for (auto &child : select_list) {
-		result->select_list.push_back(child->Copy());
-	}
-	result->from_table = from_table ? from_table->Copy() : nullptr;
-	result->where_clause = where_clause ? where_clause->Copy() : nullptr;
-	// groups
-	for (auto &group : groups.group_expressions) {
-		result->groups.group_expressions.push_back(group->Copy());
-	}
-	result->groups.grouping_sets = groups.grouping_sets;
-	result->aggregate_handling = aggregate_handling;
-	result->having = having ? having->Copy() : nullptr;
-	result->qualify = qualify ? qualify->Copy() : nullptr;
-	result->sample = sample ? sample->Copy() : nullptr;
-	this->CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/query_node/set_operation_node.cpp b/src/duckdb/src/parser/query_node/set_operation_node.cpp
deleted file mode 100644
index 5b444cf60..000000000
--- a/src/duckdb/src/parser/query_node/set_operation_node.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string SetOperationNode::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "(" + left->ToString() + ") ";
-
-	switch (setop_type) {
-	case SetOperationType::UNION:
-		result += setop_all ? "UNION ALL" : "UNION";
-		break;
-	case SetOperationType::UNION_BY_NAME:
-		result += setop_all ? "UNION ALL BY NAME" : "UNION BY NAME";
-		break;
-	case SetOperationType::EXCEPT:
-		result += setop_all ? "EXCEPT ALL" : "EXCEPT";
-		break;
-	case SetOperationType::INTERSECT:
-		result += setop_all ? "INTERSECT ALL" : "INTERSECT";
-		break;
-	default:
-		throw InternalException("Unsupported set operation type");
-	}
-	result += " (" + right->ToString() + ")";
-	return result + ResultModifiersToString();
-}
-
-bool SetOperationNode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto &other = other_p->Cast<SetOperationNode>();
-	if (setop_type != other.setop_type) {
-		return false;
-	}
-	if (setop_all != other.setop_all) {
-		return false;
-	}
-	if (!left->Equals(other.left.get())) {
-		return false;
-	}
-	if (!right->Equals(other.right.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> SetOperationNode::Copy() const {
-	auto result = make_uniq<SetOperationNode>();
-	result->setop_type = setop_type;
-	result->setop_all = setop_all;
-	result->left = left->Copy();
-	result->right = right->Copy();
-	this->CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/result_modifier.cpp b/src/duckdb/src/parser/result_modifier.cpp
deleted file mode 100644
index eae317e4c..000000000
--- a/src/duckdb/src/parser/result_modifier.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/parser/expression_util.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-bool ResultModifier::Equals(const ResultModifier &other) const {
-	return type == other.type;
-}
-
-bool LimitModifier::Equals(const ResultModifier &other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<LimitModifier>();
-	if (!ParsedExpression::Equals(limit, other.limit)) {
-		return false;
-	}
-	if (!ParsedExpression::Equals(offset, other.offset)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> LimitModifier::Copy() const {
-	auto copy = make_uniq<LimitModifier>();
-	if (limit) {
-		copy->limit = limit->Copy();
-	}
-	if (offset) {
-		copy->offset = offset->Copy();
-	}
-	return std::move(copy);
-}
-
-bool DistinctModifier::Equals(const ResultModifier &other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<DistinctModifier>();
-	if (!ExpressionUtil::ListEquals(distinct_on_targets, other.distinct_on_targets)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> DistinctModifier::Copy() const {
-	auto copy = make_uniq<DistinctModifier>();
-	for (auto &expr : distinct_on_targets) {
-		copy->distinct_on_targets.push_back(expr->Copy());
-	}
-	return std::move(copy);
-}
-
-bool OrderModifier::Equals(const ResultModifier &other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<OrderModifier>();
-	if (orders.size() != other.orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (orders[i].type != other.orders[i].type) {
-			return false;
-		}
-		if (!BaseExpression::Equals(*orders[i].expression, *other.orders[i].expression)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool OrderModifier::Equals(const unique_ptr<OrderModifier> &left, const unique_ptr<OrderModifier> &right) {
-	if (left.get() == right.get()) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return left->Equals(*right);
-}
-
-unique_ptr<ResultModifier> OrderModifier::Copy() const {
-	auto copy = make_uniq<OrderModifier>();
-	for (auto &order : orders) {
-		copy->orders.emplace_back(order.type, order.null_order, order.expression->Copy());
-	}
-	return std::move(copy);
-}
-
-string OrderByNode::ToString() const {
-	auto str = expression->ToString();
-	switch (type) {
-	case OrderType::ASCENDING:
-		str += " ASC";
-		break;
-	case OrderType::DESCENDING:
-		str += " DESC";
-		break;
-	default:
-		break;
-	}
-
-	switch (null_order) {
-	case OrderByNullType::NULLS_FIRST:
-		str += " NULLS FIRST";
-		break;
-	case OrderByNullType::NULLS_LAST:
-		str += " NULLS LAST";
-		break;
-	default:
-		break;
-	}
-	return str;
-}
-
-bool LimitPercentModifier::Equals(const ResultModifier &other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<LimitPercentModifier>();
-	if (!ParsedExpression::Equals(limit, other.limit)) {
-		return false;
-	}
-	if (!ParsedExpression::Equals(offset, other.offset)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> LimitPercentModifier::Copy() const {
-	auto copy = make_uniq<LimitPercentModifier>();
-	if (limit) {
-		copy->limit = limit->Copy();
-	}
-	if (offset) {
-		copy->offset = offset->Copy();
-	}
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/alter_statement.cpp b/src/duckdb/src/parser/statement/alter_statement.cpp
deleted file mode 100644
index e964783ca..000000000
--- a/src/duckdb/src/parser/statement/alter_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/alter_statement.hpp"
-
-namespace duckdb {
-
-AlterStatement::AlterStatement() : SQLStatement(StatementType::ALTER_STATEMENT) {
-}
-
-AlterStatement::AlterStatement(const AlterStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> AlterStatement::Copy() const {
-	return unique_ptr<AlterStatement>(new AlterStatement(*this));
-}
-
-string AlterStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/attach_statement.cpp b/src/duckdb/src/parser/statement/attach_statement.cpp
deleted file mode 100644
index 12958a22b..000000000
--- a/src/duckdb/src/parser/statement/attach_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/attach_statement.hpp"
-
-namespace duckdb {
-
-AttachStatement::AttachStatement() : SQLStatement(StatementType::ATTACH_STATEMENT) {
-}
-
-AttachStatement::AttachStatement(const AttachStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> AttachStatement::Copy() const {
-	return unique_ptr<AttachStatement>(new AttachStatement(*this));
-}
-
-string AttachStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/call_statement.cpp b/src/duckdb/src/parser/statement/call_statement.cpp
deleted file mode 100644
index 646765afa..000000000
--- a/src/duckdb/src/parser/statement/call_statement.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/parser/statement/call_statement.hpp"
-
-namespace duckdb {
-
-CallStatement::CallStatement() : SQLStatement(StatementType::CALL_STATEMENT) {
-}
-
-CallStatement::CallStatement(const CallStatement &other) : SQLStatement(other), function(other.function->Copy()) {
-}
-
-unique_ptr<SQLStatement> CallStatement::Copy() const {
-	return unique_ptr<CallStatement>(new CallStatement(*this));
-}
-
-string CallStatement::ToString() const {
-	string result = "";
-	result += "CALL";
-	result += " " + function->ToString();
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/copy_database_statement.cpp b/src/duckdb/src/parser/statement/copy_database_statement.cpp
deleted file mode 100644
index 06ee39186..000000000
--- a/src/duckdb/src/parser/statement/copy_database_statement.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/parser/statement/copy_database_statement.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-
-namespace duckdb {
-
-CopyDatabaseStatement::CopyDatabaseStatement(string from_database_p, string to_database_p, CopyDatabaseType copy_type)
-    : SQLStatement(StatementType::COPY_DATABASE_STATEMENT), from_database(std::move(from_database_p)),
-      to_database(std::move(to_database_p)), copy_type(copy_type) {
-}
-
-CopyDatabaseStatement::CopyDatabaseStatement(const CopyDatabaseStatement &other)
-    : SQLStatement(other), from_database(other.from_database), to_database(other.to_database),
-      copy_type(other.copy_type) {
-}
-
-unique_ptr<SQLStatement> CopyDatabaseStatement::Copy() const {
-	return unique_ptr<CopyDatabaseStatement>(new CopyDatabaseStatement(*this));
-}
-
-string CopyDatabaseStatement::ToString() const {
-	string result;
-	result = "COPY FROM DATABASE ";
-	result += KeywordHelper::WriteOptionallyQuoted(from_database);
-	result += " TO ";
-	result += KeywordHelper::WriteOptionallyQuoted(to_database);
-	result += " (";
-	switch (copy_type) {
-	case CopyDatabaseType::COPY_DATA:
-		result += "DATA";
-		break;
-	case CopyDatabaseType::COPY_SCHEMA:
-		result += "SCHEMA";
-		break;
-	default:
-		throw InternalException("Unsupported CopyDatabaseType");
-	}
-	result += ")";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/copy_statement.cpp b/src/duckdb/src/parser/statement/copy_statement.cpp
deleted file mode 100644
index 5a77447bd..000000000
--- a/src/duckdb/src/parser/statement/copy_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/copy_statement.hpp"
-
-namespace duckdb {
-
-CopyStatement::CopyStatement() : SQLStatement(StatementType::COPY_STATEMENT), info(make_uniq<CopyInfo>()) {
-}
-
-CopyStatement::CopyStatement(const CopyStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-string CopyStatement::ToString() const {
-	return info->ToString();
-}
-
-unique_ptr<SQLStatement> CopyStatement::Copy() const {
-	return unique_ptr<CopyStatement>(new CopyStatement(*this));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/create_statement.cpp b/src/duckdb/src/parser/statement/create_statement.cpp
deleted file mode 100644
index fbc86c874..000000000
--- a/src/duckdb/src/parser/statement/create_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/create_statement.hpp"
-
-namespace duckdb {
-
-CreateStatement::CreateStatement() : SQLStatement(StatementType::CREATE_STATEMENT) {
-}
-
-CreateStatement::CreateStatement(const CreateStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> CreateStatement::Copy() const {
-	return unique_ptr<CreateStatement>(new CreateStatement(*this));
-}
-
-string CreateStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/delete_statement.cpp b/src/duckdb/src/parser/statement/delete_statement.cpp
deleted file mode 100644
index 0c3293e29..000000000
--- a/src/duckdb/src/parser/statement/delete_statement.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "duckdb/parser/statement/delete_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-
-namespace duckdb {
-
-DeleteStatement::DeleteStatement() : SQLStatement(StatementType::DELETE_STATEMENT) {
-}
-
-DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(other), table(other.table->Copy()) {
-	if (other.condition) {
-		condition = other.condition->Copy();
-	}
-	for (const auto &using_clause : other.using_clauses) {
-		using_clauses.push_back(using_clause->Copy());
-	}
-	for (auto &expr : other.returning_list) {
-		returning_list.emplace_back(expr->Copy());
-	}
-	cte_map = other.cte_map.Copy();
-}
-
-string DeleteStatement::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "DELETE FROM ";
-	result += table->ToString();
-	if (!using_clauses.empty()) {
-		result += " USING ";
-		for (idx_t i = 0; i < using_clauses.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += using_clauses[i]->ToString();
-		}
-	}
-	if (condition) {
-		result += " WHERE " + condition->ToString();
-	}
-
-	if (!returning_list.empty()) {
-		result += " RETURNING ";
-		for (idx_t i = 0; i < returning_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			auto column = returning_list[i]->ToString();
-			if (!returning_list[i]->GetAlias().empty()) {
-				column +=
-				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
-			}
-			result += column;
-		}
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> DeleteStatement::Copy() const {
-	return unique_ptr<DeleteStatement>(new DeleteStatement(*this));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/detach_statement.cpp b/src/duckdb/src/parser/statement/detach_statement.cpp
deleted file mode 100644
index 0239e9403..000000000
--- a/src/duckdb/src/parser/statement/detach_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/detach_statement.hpp"
-
-namespace duckdb {
-
-DetachStatement::DetachStatement() : SQLStatement(StatementType::DETACH_STATEMENT) {
-}
-
-DetachStatement::DetachStatement(const DetachStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> DetachStatement::Copy() const {
-	return unique_ptr<DetachStatement>(new DetachStatement(*this));
-}
-
-string DetachStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/drop_statement.cpp b/src/duckdb/src/parser/statement/drop_statement.cpp
deleted file mode 100644
index b1ad8fd69..000000000
--- a/src/duckdb/src/parser/statement/drop_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/drop_statement.hpp"
-
-namespace duckdb {
-
-DropStatement::DropStatement() : SQLStatement(StatementType::DROP_STATEMENT), info(make_uniq<DropInfo>()) {
-}
-
-DropStatement::DropStatement(const DropStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> DropStatement::Copy() const {
-	return unique_ptr<DropStatement>(new DropStatement(*this));
-}
-
-string DropStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/execute_statement.cpp b/src/duckdb/src/parser/statement/execute_statement.cpp
deleted file mode 100644
index b052b71b9..000000000
--- a/src/duckdb/src/parser/statement/execute_statement.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "duckdb/parser/statement/execute_statement.hpp"
-
-namespace duckdb {
-
-ExecuteStatement::ExecuteStatement() : SQLStatement(StatementType::EXECUTE_STATEMENT) {
-}
-
-ExecuteStatement::ExecuteStatement(const ExecuteStatement &other) : SQLStatement(other), name(other.name) {
-	for (const auto &item : other.named_values) {
-		named_values.emplace(std::make_pair(item.first, item.second->Copy()));
-	}
-}
-
-unique_ptr<SQLStatement> ExecuteStatement::Copy() const {
-	return unique_ptr<ExecuteStatement>(new ExecuteStatement(*this));
-}
-
-string ExecuteStatement::ToString() const {
-	string result = "";
-	result += "EXECUTE";
-	result += " " + name;
-	if (!named_values.empty()) {
-		vector<string> stringified;
-		for (auto &val : named_values) {
-			stringified.push_back(StringUtil::Format("\"%s\" := %s", val.first, val.second->ToString()));
-		}
-		result += "(" + StringUtil::Join(stringified, ", ") + ")";
-	}
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/explain_statement.cpp b/src/duckdb/src/parser/statement/explain_statement.cpp
deleted file mode 100644
index 55c72b2b6..000000000
--- a/src/duckdb/src/parser/statement/explain_statement.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-ExplainStatement::ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type,
-                                   ExplainFormat explain_format)
-    : SQLStatement(StatementType::EXPLAIN_STATEMENT), stmt(std::move(stmt)), explain_type(explain_type),
-      explain_format(explain_format) {
-}
-
-ExplainStatement::ExplainStatement(const ExplainStatement &other)
-    : SQLStatement(other), stmt(other.stmt->Copy()), explain_type(other.explain_type),
-      explain_format(other.explain_format) {
-}
-
-unique_ptr<SQLStatement> ExplainStatement::Copy() const {
-	return unique_ptr<ExplainStatement>(new ExplainStatement(*this));
-}
-
-string ExplainStatement::OptionsToString() const {
-	string options;
-	if (explain_type == ExplainType::EXPLAIN_ANALYZE) {
-		options += "(";
-		options += "ANALYZE";
-	}
-	if (explain_format != ExplainFormat::DEFAULT) {
-		if (options.empty()) {
-			options += "(";
-		} else {
-			options += ", ";
-		}
-		options += StringUtil::Format("FORMAT %s", EnumUtil::ToString(explain_format));
-	}
-	if (!options.empty()) {
-		options += ")";
-	}
-	return options;
-}
-
-string ExplainStatement::ToString() const {
-	string result = "EXPLAIN";
-	auto options = OptionsToString();
-	if (!options.empty()) {
-		result += " " + options;
-	}
-	result += " " + stmt->ToString();
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/export_statement.cpp b/src/duckdb/src/parser/statement/export_statement.cpp
deleted file mode 100644
index 2b2e0c831..000000000
--- a/src/duckdb/src/parser/statement/export_statement.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/parser/statement/export_statement.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/query_node.hpp"
-
-namespace duckdb {
-
-ExportStatement::ExportStatement(unique_ptr<CopyInfo> info)
-    : SQLStatement(StatementType::EXPORT_STATEMENT), info(std::move(info)) {
-}
-
-ExportStatement::ExportStatement(const ExportStatement &other)
-    : SQLStatement(other), info(other.info->Copy()), database(other.database) {
-}
-
-unique_ptr<SQLStatement> ExportStatement::Copy() const {
-	return unique_ptr<ExportStatement>(new ExportStatement(*this));
-}
-
-string ExportStatement::ToString() const {
-	string result = "";
-	result += "EXPORT DATABASE";
-	if (!database.empty()) {
-		result += " " + database + " TO";
-	}
-	auto &path = info->file_path;
-	D_ASSERT(info->is_from == false);
-	auto &options = info->options;
-	auto &format = info->format;
-	result += StringUtil::Format(" '%s'", path);
-	result += CopyInfo::CopyOptionsToString(format, options);
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/extension_statement.cpp b/src/duckdb/src/parser/statement/extension_statement.cpp
deleted file mode 100644
index ac0e66f55..000000000
--- a/src/duckdb/src/parser/statement/extension_statement.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/parser/statement/extension_statement.hpp"
-
-namespace duckdb {
-
-ExtensionStatement::ExtensionStatement(ParserExtension extension_p, unique_ptr<ParserExtensionParseData> parse_data_p)
-    : SQLStatement(StatementType::EXTENSION_STATEMENT), extension(std::move(extension_p)),
-      parse_data(std::move(parse_data_p)) {
-}
-
-unique_ptr<SQLStatement> ExtensionStatement::Copy() const {
-	return make_uniq<ExtensionStatement>(extension, parse_data->Copy());
-}
-
-string ExtensionStatement::ToString() const {
-	return parse_data->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/insert_statement.cpp b/src/duckdb/src/parser/statement/insert_statement.cpp
deleted file mode 100644
index f59a2ef3a..000000000
--- a/src/duckdb/src/parser/statement/insert_statement.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-
-namespace duckdb {
-
-OnConflictInfo::OnConflictInfo() : action_type(OnConflictAction::THROW) {
-}
-
-OnConflictInfo::OnConflictInfo(const OnConflictInfo &other)
-    : action_type(other.action_type), indexed_columns(other.indexed_columns) {
-	if (other.set_info) {
-		set_info = other.set_info->Copy();
-	}
-	if (other.condition) {
-		condition = other.condition->Copy();
-	}
-}
-
-unique_ptr<OnConflictInfo> OnConflictInfo::Copy() const {
-	return unique_ptr<OnConflictInfo>(new OnConflictInfo(*this));
-}
-
-InsertStatement::InsertStatement()
-    : SQLStatement(StatementType::INSERT_STATEMENT), schema(DEFAULT_SCHEMA), catalog(INVALID_CATALOG) {
-}
-
-InsertStatement::InsertStatement(const InsertStatement &other)
-    : SQLStatement(other), select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(
-                               other.select_statement ? other.select_statement->Copy() : nullptr)),
-      columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog),
-      default_values(other.default_values), column_order(other.column_order) {
-	cte_map = other.cte_map.Copy();
-	for (auto &expr : other.returning_list) {
-		returning_list.emplace_back(expr->Copy());
-	}
-	if (other.table_ref) {
-		table_ref = other.table_ref->Copy();
-	}
-	if (other.on_conflict_info) {
-		on_conflict_info = other.on_conflict_info->Copy();
-	}
-}
-
-string InsertStatement::OnConflictActionToString(OnConflictAction action) {
-	switch (action) {
-	case OnConflictAction::NOTHING:
-		return "DO NOTHING";
-	case OnConflictAction::REPLACE:
-	case OnConflictAction::UPDATE:
-		return "DO UPDATE";
-	case OnConflictAction::THROW:
-		// Explicitly left empty, for ToString purposes
-		return "";
-	default: {
-		throw NotImplementedException("type not implemented for OnConflictActionType");
-	}
-	}
-}
-
-string InsertStatement::ToString() const {
-	bool or_replace_shorthand_set = false;
-	string result;
-
-	result = cte_map.ToString();
-	result += "INSERT";
-	if (on_conflict_info && on_conflict_info->action_type == OnConflictAction::REPLACE) {
-		or_replace_shorthand_set = true;
-		result += " OR REPLACE";
-	}
-	result += " INTO ";
-	if (!catalog.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
-	}
-	if (!schema.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(table);
-	// Write the (optional) alias of the insert target
-	if (table_ref && !table_ref->alias.empty()) {
-		result += StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(table_ref->alias));
-	}
-	if (column_order == InsertColumnOrder::INSERT_BY_NAME) {
-		result += " BY NAME";
-	}
-	if (!columns.empty()) {
-		result += " (";
-		for (idx_t i = 0; i < columns.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-		}
-		result += " )";
-	}
-	result += " ";
-	auto values_list = GetValuesList();
-	if (values_list) {
-		D_ASSERT(!default_values);
-		auto saved_alias = values_list->alias;
-		values_list->alias = string();
-		result += values_list->ToString();
-		values_list->alias = saved_alias;
-	} else if (select_statement) {
-		D_ASSERT(!default_values);
-		result += select_statement->ToString();
-	} else {
-		D_ASSERT(default_values);
-		result += "DEFAULT VALUES";
-	}
-	if (!or_replace_shorthand_set && on_conflict_info) {
-		auto &conflict_info = *on_conflict_info;
-		result += " ON CONFLICT ";
-		// (optional) conflict target
-		if (!conflict_info.indexed_columns.empty()) {
-			result += "(";
-			auto &columns = conflict_info.indexed_columns;
-			for (auto it = columns.begin(); it != columns.end();) {
-				result += StringUtil::Lower(*it);
-				if (++it != columns.end()) {
-					result += ", ";
-				}
-			}
-			result += " )";
-		}
-
-		// (optional) where clause
-		if (conflict_info.condition) {
-			result += " WHERE " + conflict_info.condition->ToString();
-		}
-		result += " " + OnConflictActionToString(conflict_info.action_type);
-		if (conflict_info.set_info) {
-			D_ASSERT(conflict_info.action_type == OnConflictAction::UPDATE);
-			result += " SET ";
-			auto &set_info = *conflict_info.set_info;
-			D_ASSERT(set_info.columns.size() == set_info.expressions.size());
-			// SET <column_name> = <expression>
-			for (idx_t i = 0; i < set_info.columns.size(); i++) {
-				auto &column = set_info.columns[i];
-				auto &expr = set_info.expressions[i];
-				if (i) {
-					result += ", ";
-				}
-				result += StringUtil::Lower(column) + " = " + expr->ToString();
-			}
-			// (optional) where clause
-			if (set_info.condition) {
-				result += " WHERE " + set_info.condition->ToString();
-			}
-		}
-	}
-	if (!returning_list.empty()) {
-		result += " RETURNING ";
-		for (idx_t i = 0; i < returning_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			auto column = returning_list[i]->ToString();
-			if (!returning_list[i]->GetAlias().empty()) {
-				column +=
-				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
-			}
-			result += column;
-		}
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> InsertStatement::Copy() const {
-	return unique_ptr<InsertStatement>(new InsertStatement(*this));
-}
-
-optional_ptr<ExpressionListRef> InsertStatement::GetValuesList() const {
-	if (!select_statement) {
-		return nullptr;
-	}
-	if (select_statement->node->type != QueryNodeType::SELECT_NODE) {
-		return nullptr;
-	}
-	auto &node = select_statement->node->Cast<SelectNode>();
-	if (node.where_clause || node.qualify || node.having) {
-		return nullptr;
-	}
-	if (!node.cte_map.map.empty()) {
-		return nullptr;
-	}
-	if (!node.groups.grouping_sets.empty()) {
-		return nullptr;
-	}
-	if (node.aggregate_handling != AggregateHandling::STANDARD_HANDLING) {
-		return nullptr;
-	}
-	if (node.select_list.size() != 1 || node.select_list[0]->GetExpressionType() != ExpressionType::STAR) {
-		return nullptr;
-	}
-	if (!node.from_table || node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
-		return nullptr;
-	}
-	return &node.from_table->Cast<ExpressionListRef>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/load_statement.cpp b/src/duckdb/src/parser/statement/load_statement.cpp
deleted file mode 100644
index 8ab6e37ad..000000000
--- a/src/duckdb/src/parser/statement/load_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/load_statement.hpp"
-
-namespace duckdb {
-
-LoadStatement::LoadStatement() : SQLStatement(StatementType::LOAD_STATEMENT) {
-}
-
-LoadStatement::LoadStatement(const LoadStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> LoadStatement::Copy() const {
-	return unique_ptr<LoadStatement>(new LoadStatement(*this));
-}
-
-string LoadStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/multi_statement.cpp b/src/duckdb/src/parser/statement/multi_statement.cpp
deleted file mode 100644
index 2821084cd..000000000
--- a/src/duckdb/src/parser/statement/multi_statement.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/parser/statement/multi_statement.hpp"
-
-namespace duckdb {
-
-MultiStatement::MultiStatement() : SQLStatement(StatementType::MULTI_STATEMENT) {
-}
-
-MultiStatement::MultiStatement(const MultiStatement &other) : SQLStatement(other) {
-	for (auto &stmt : other.statements) {
-		statements.push_back(stmt->Copy());
-	}
-}
-
-unique_ptr<SQLStatement> MultiStatement::Copy() const {
-	return unique_ptr<MultiStatement>(new MultiStatement(*this));
-}
-
-string MultiStatement::ToString() const {
-	vector<string> stringified;
-	for (auto &stmt : statements) {
-		stringified.push_back(stmt->ToString());
-	}
-	return StringUtil::Join(stringified, ";") + ";";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/pragma_statement.cpp b/src/duckdb/src/parser/statement/pragma_statement.cpp
deleted file mode 100644
index b15034568..000000000
--- a/src/duckdb/src/parser/statement/pragma_statement.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/statement/pragma_statement.hpp"
-
-namespace duckdb {
-
-PragmaStatement::PragmaStatement() : SQLStatement(StatementType::PRAGMA_STATEMENT), info(make_uniq<PragmaInfo>()) {
-}
-
-PragmaStatement::PragmaStatement(const PragmaStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> PragmaStatement::Copy() const {
-	return unique_ptr<PragmaStatement>(new PragmaStatement(*this));
-}
-
-string PragmaStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/prepare_statement.cpp b/src/duckdb/src/parser/statement/prepare_statement.cpp
deleted file mode 100644
index 69c8ba9e7..000000000
--- a/src/duckdb/src/parser/statement/prepare_statement.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/parser/statement/prepare_statement.hpp"
-
-namespace duckdb {
-
-PrepareStatement::PrepareStatement() : SQLStatement(StatementType::PREPARE_STATEMENT), statement(nullptr), name("") {
-}
-
-PrepareStatement::PrepareStatement(const PrepareStatement &other)
-    : SQLStatement(other), statement(other.statement->Copy()), name(other.name) {
-}
-
-unique_ptr<SQLStatement> PrepareStatement::Copy() const {
-	return unique_ptr<PrepareStatement>(new PrepareStatement(*this));
-}
-
-string PrepareStatement::ToString() const {
-	string result = "";
-	result += "PREPARE";
-	result += " ";
-	result += name;
-	result += " ";
-	result += "AS";
-	result += " ";
-	result += statement->ToString();
-	// NOTE: We expect SQLStatement->ToString() to always end in a ';' ^
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/relation_statement.cpp b/src/duckdb/src/parser/statement/relation_statement.cpp
deleted file mode 100644
index 9b3801495..000000000
--- a/src/duckdb/src/parser/statement/relation_statement.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/parser/statement/relation_statement.hpp"
-#include "duckdb/main/relation/query_relation.hpp"
-
-namespace duckdb {
-
-RelationStatement::RelationStatement(shared_ptr<Relation> relation_p)
-    : SQLStatement(StatementType::RELATION_STATEMENT), relation(std::move(relation_p)) {
-	if (relation->type == RelationType::QUERY_RELATION) {
-		auto &query_relation = relation->Cast<QueryRelation>();
-		query = query_relation.query;
-	}
-}
-
-unique_ptr<SQLStatement> RelationStatement::Copy() const {
-	return unique_ptr<RelationStatement>(new RelationStatement(*this));
-}
-
-string RelationStatement::ToString() const {
-	return relation->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/select_statement.cpp b/src/duckdb/src/parser/statement/select_statement.cpp
deleted file mode 100644
index 1c686c675..000000000
--- a/src/duckdb/src/parser/statement/select_statement.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/parser/statement/select_statement.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-SelectStatement::SelectStatement(const SelectStatement &other) : SQLStatement(other), node(other.node->Copy()) {
-}
-
-unique_ptr<SQLStatement> SelectStatement::Copy() const {
-	return unique_ptr<SelectStatement>(new SelectStatement(*this));
-}
-
-bool SelectStatement::Equals(const SQLStatement &other_p) const {
-	if (type != other_p.type) {
-		return false;
-	}
-	auto &other = other_p.Cast<SelectStatement>();
-	return node->Equals(other.node.get());
-}
-
-string SelectStatement::ToString() const {
-	return node->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/set_statement.cpp b/src/duckdb/src/parser/statement/set_statement.cpp
deleted file mode 100644
index c0cd75a52..000000000
--- a/src/duckdb/src/parser/statement/set_statement.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "duckdb/parser/statement/set_statement.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-SetStatement::SetStatement(string name_p, SetScope scope_p, SetType type_p)
-    : SQLStatement(StatementType::SET_STATEMENT), name(std::move(name_p)), scope(scope_p), set_type(type_p) {
-}
-
-// Set Variable
-
-SetVariableStatement::SetVariableStatement(string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p)
-    : SetStatement(std::move(name_p), scope_p, SetType::SET), value(std::move(value_p)) {
-}
-
-SetVariableStatement::SetVariableStatement(const SetVariableStatement &other)
-    : SetVariableStatement(other.name, other.value->Copy(), other.scope) {
-}
-
-unique_ptr<SQLStatement> SetVariableStatement::Copy() const {
-	return unique_ptr<SetVariableStatement>(new SetVariableStatement(*this));
-}
-
-static string ScopeToString(SetScope scope) {
-	switch (scope) {
-	case SetScope::AUTOMATIC:
-		return "";
-	case SetScope::LOCAL:
-		return "LOCAL";
-	case SetScope::SESSION:
-		return "SESSION";
-	case SetScope::GLOBAL:
-		return "GLOBAL";
-	case SetScope::VARIABLE:
-		return "VARIABLE";
-	default:
-		throw InternalException("ToString not implemented for SetScope of type: %s", EnumUtil::ToString(scope));
-	}
-}
-
-string SetVariableStatement::ToString() const {
-	return StringUtil::Format("SET %s %s TO %s;", ScopeToString(scope), name, value->ToString());
-}
-
-// Reset Variable
-
-ResetVariableStatement::ResetVariableStatement(std::string name_p, SetScope scope_p)
-    : SetStatement(std::move(name_p), scope_p, SetType::RESET) {
-}
-
-unique_ptr<SQLStatement> ResetVariableStatement::Copy() const {
-	return unique_ptr<ResetVariableStatement>(new ResetVariableStatement(*this));
-}
-
-string ResetVariableStatement::ToString() const {
-	string result = "";
-	result += "RESET";
-	result += " " + ScopeToString(scope);
-	result += " " + name;
-	result += ";";
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/transaction_statement.cpp b/src/duckdb/src/parser/statement/transaction_statement.cpp
deleted file mode 100644
index f1098536b..000000000
--- a/src/duckdb/src/parser/statement/transaction_statement.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/parser/statement/transaction_statement.hpp"
-
-namespace duckdb {
-
-TransactionStatement::TransactionStatement(unique_ptr<TransactionInfo> info)
-    : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(std::move(info)) {
-}
-
-TransactionStatement::TransactionStatement(const TransactionStatement &other)
-    : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> TransactionStatement::Copy() const {
-	return unique_ptr<TransactionStatement>(new TransactionStatement(*this));
-}
-
-string TransactionStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/update_extensions_statement.cpp b/src/duckdb/src/parser/statement/update_extensions_statement.cpp
deleted file mode 100644
index 73fea01d6..000000000
--- a/src/duckdb/src/parser/statement/update_extensions_statement.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/parser/statement/update_extensions_statement.hpp"
-
-namespace duckdb {
-
-UpdateExtensionsStatement::UpdateExtensionsStatement() : SQLStatement(StatementType::UPDATE_EXTENSIONS_STATEMENT) {
-}
-
-UpdateExtensionsStatement::UpdateExtensionsStatement(const UpdateExtensionsStatement &other)
-    : SQLStatement(other), info(other.info->Copy()) {
-}
-
-string UpdateExtensionsStatement::ToString() const {
-	string result;
-	result += "UPDATE EXTENSIONS";
-
-	if (!info->extensions_to_update.empty()) {
-		result += "(";
-		for (idx_t i = 0; i < info->extensions_to_update.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += info->extensions_to_update[i];
-		}
-		result += ")";
-	}
-
-	return result;
-}
-
-unique_ptr<SQLStatement> UpdateExtensionsStatement::Copy() const {
-	return unique_ptr<UpdateExtensionsStatement>(new UpdateExtensionsStatement(*this));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/update_statement.cpp b/src/duckdb/src/parser/statement/update_statement.cpp
deleted file mode 100644
index cabd1d36e..000000000
--- a/src/duckdb/src/parser/statement/update_statement.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-
-namespace duckdb {
-
-UpdateSetInfo::UpdateSetInfo() {
-}
-
-UpdateSetInfo::UpdateSetInfo(const UpdateSetInfo &other) : columns(other.columns) {
-	if (other.condition) {
-		condition = other.condition->Copy();
-	}
-	for (auto &expr : other.expressions) {
-		expressions.emplace_back(expr->Copy());
-	}
-}
-
-unique_ptr<UpdateSetInfo> UpdateSetInfo::Copy() const {
-	return unique_ptr<UpdateSetInfo>(new UpdateSetInfo(*this));
-}
-
-UpdateStatement::UpdateStatement() : SQLStatement(StatementType::UPDATE_STATEMENT) {
-}
-
-UpdateStatement::UpdateStatement(const UpdateStatement &other)
-    : SQLStatement(other), table(other.table->Copy()), set_info(other.set_info->Copy()) {
-	if (other.from_table) {
-		from_table = other.from_table->Copy();
-	}
-	for (auto &expr : other.returning_list) {
-		returning_list.emplace_back(expr->Copy());
-	}
-	cte_map = other.cte_map.Copy();
-}
-
-string UpdateStatement::ToString() const {
-	D_ASSERT(set_info);
-	auto &condition = set_info->condition;
-	auto &columns = set_info->columns;
-	auto &expressions = set_info->expressions;
-
-	string result;
-	result = cte_map.ToString();
-	result += "UPDATE ";
-	result += table->ToString();
-	result += " SET ";
-	D_ASSERT(columns.size() == expressions.size());
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-		result += " = ";
-		result += expressions[i]->ToString();
-	}
-	if (from_table) {
-		result += " FROM " + from_table->ToString();
-	}
-	if (condition) {
-		result += " WHERE " + condition->ToString();
-	}
-	if (!returning_list.empty()) {
-		result += " RETURNING ";
-		for (idx_t i = 0; i < returning_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			auto column = returning_list[i]->ToString();
-			if (!returning_list[i]->GetAlias().empty()) {
-				column +=
-				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
-			}
-			result += column;
-		}
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> UpdateStatement::Copy() const {
-	return unique_ptr<UpdateStatement>(new UpdateStatement(*this));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/statement/vacuum_statement.cpp b/src/duckdb/src/parser/statement/vacuum_statement.cpp
deleted file mode 100644
index e78f422b8..000000000
--- a/src/duckdb/src/parser/statement/vacuum_statement.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/parser/statement/vacuum_statement.hpp"
-
-namespace duckdb {
-
-VacuumStatement::VacuumStatement(const VacuumOptions &options)
-    : SQLStatement(StatementType::VACUUM_STATEMENT), info(make_uniq<VacuumInfo>(options)) {
-}
-
-VacuumStatement::VacuumStatement(const VacuumStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> VacuumStatement::Copy() const {
-	return unique_ptr<VacuumStatement>(new VacuumStatement(*this));
-}
-
-string VacuumStatement::ToString() const {
-	return info->ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref.cpp b/src/duckdb/src/parser/tableref.cpp
deleted file mode 100644
index 9ce290237..000000000
--- a/src/duckdb/src/parser/tableref.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "duckdb/parser/tableref.hpp"
-
-#include "duckdb/common/printer.hpp"
-#include "duckdb/parser/tableref/list.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-string TableRef::BaseToString(string result) const {
-	vector<string> column_name_alias;
-	return BaseToString(std::move(result), column_name_alias);
-}
-
-string TableRef::BaseToString(string result, const vector<string> &column_name_alias) const {
-	if (!alias.empty()) {
-		result += StringUtil::Format(" AS %s", SQLIdentifier(alias));
-	}
-	if (!column_name_alias.empty()) {
-		D_ASSERT(!alias.empty());
-		result += "(";
-		for (idx_t i = 0; i < column_name_alias.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += KeywordHelper::WriteOptionallyQuoted(column_name_alias[i]);
-		}
-		result += ")";
-	}
-	if (sample) {
-		result += " TABLESAMPLE " + EnumUtil::ToString(sample->method);
-		result += "(" + sample->sample_size.ToString() + " " + string(sample->is_percentage ? "PERCENT" : "ROWS") + ")";
-		if (sample->seed.IsValid()) {
-			result += "REPEATABLE (" + to_string(sample->seed.GetIndex()) + ")";
-		}
-	}
-
-	return result;
-}
-
-bool TableRef::Equals(const TableRef &other) const {
-	return type == other.type && alias == other.alias && SampleOptions::Equals(sample.get(), other.sample.get());
-}
-
-void TableRef::CopyProperties(TableRef &target) const {
-	D_ASSERT(type == target.type);
-	target.alias = alias;
-	target.query_location = query_location;
-	target.sample = sample ? sample->Copy() : nullptr;
-	target.external_dependency = external_dependency;
-}
-
-void TableRef::Print() {
-	Printer::Print(ToString());
-}
-
-bool TableRef::Equals(const unique_ptr<TableRef> &left, const unique_ptr<TableRef> &right) {
-	if (left.get() == right.get()) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return left->Equals(*right);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/basetableref.cpp b/src/duckdb/src/parser/tableref/basetableref.cpp
deleted file mode 100644
index a39c07ec7..000000000
--- a/src/duckdb/src/parser/tableref/basetableref.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "duckdb/parser/tableref/basetableref.hpp"
-
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string BaseTableRef::ToString() const {
-	string result;
-	result += catalog_name.empty() ? "" : (KeywordHelper::WriteOptionallyQuoted(catalog_name) + ".");
-	result += schema_name.empty() ? "" : (KeywordHelper::WriteOptionallyQuoted(schema_name) + ".");
-	result += KeywordHelper::WriteOptionallyQuoted(table_name);
-	return BaseToString(result, column_name_alias);
-}
-
-bool BaseTableRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BaseTableRef>();
-	return other.catalog_name == catalog_name && other.schema_name == schema_name && other.table_name == table_name &&
-	       column_name_alias == other.column_name_alias;
-}
-
-unique_ptr<TableRef> BaseTableRef::Copy() {
-	auto copy = make_uniq<BaseTableRef>();
-
-	copy->catalog_name = catalog_name;
-	copy->schema_name = schema_name;
-	copy->table_name = table_name;
-	copy->column_name_alias = column_name_alias;
-	CopyProperties(*copy);
-
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/column_data_ref.cpp b/src/duckdb/src/parser/tableref/column_data_ref.cpp
deleted file mode 100644
index dec10e1c2..000000000
--- a/src/duckdb/src/parser/tableref/column_data_ref.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "duckdb/parser/tableref/column_data_ref.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string ColumnDataRef::ToString() const {
-	auto result = collection->ToString();
-	return BaseToString(result, expected_names);
-}
-
-bool ColumnDataRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<ColumnDataRef>();
-	auto expected_types = collection->Types();
-	auto other_expected_types = other.collection->Types();
-	if (expected_types.size() != other_expected_types.size()) {
-		return false;
-	}
-	if (expected_names.size() != other.expected_names.size()) {
-		return false;
-	}
-	D_ASSERT(expected_types.size() == expected_names.size());
-	for (idx_t i = 0; i < expected_types.size(); i++) {
-		auto &this_type = expected_types[i];
-		auto &other_type = other_expected_types[i];
-
-		auto &this_name = expected_names[i];
-		auto &other_name = other.expected_names[i];
-
-		if (this_type != other_type) {
-			return false;
-		}
-		if (!StringUtil::CIEquals(this_name, other_name)) {
-			return false;
-		}
-	}
-	string unused;
-	if (!ColumnDataCollection::ResultEquals(*collection, *other.collection, unused, true)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<TableRef> ColumnDataRef::Copy() {
-	auto result = make_uniq<ColumnDataRef>(collection, expected_names);
-	CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/delimgetref.cpp b/src/duckdb/src/parser/tableref/delimgetref.cpp
deleted file mode 100644
index 71910ff3b..000000000
--- a/src/duckdb/src/parser/tableref/delimgetref.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "duckdb/parser/tableref/delimgetref.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-
-string DelimGetRef::ToString() const {
-	return "";
-}
-
-bool DelimGetRef::Equals(const TableRef &other) const {
-	return TableRef::Equals(other);
-}
-
-unique_ptr<TableRef> DelimGetRef::Copy() {
-	return make_uniq<DelimGetRef>(types);
-}
-
-void DelimGetRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WriteProperty<vector<LogicalType>>(105, "chunk_types", types);
-}
-
-unique_ptr<TableRef> DelimGetRef::Deserialize(Deserializer &deserializer) {
-	vector<LogicalType> types = deserializer.ReadProperty<vector<LogicalType>>(105, "chunk_types");
-	auto result = duckdb::unique_ptr<DelimGetRef>(new DelimGetRef(types));
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/emptytableref.cpp b/src/duckdb/src/parser/tableref/emptytableref.cpp
deleted file mode 100644
index 0107aac9c..000000000
--- a/src/duckdb/src/parser/tableref/emptytableref.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/parser/tableref/emptytableref.hpp"
-
-namespace duckdb {
-
-string EmptyTableRef::ToString() const {
-	return "";
-}
-
-bool EmptyTableRef::Equals(const TableRef &other) const {
-	return TableRef::Equals(other);
-}
-
-unique_ptr<TableRef> EmptyTableRef::Copy() {
-	return make_uniq<EmptyTableRef>();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/expressionlistref.cpp b/src/duckdb/src/parser/tableref/expressionlistref.cpp
deleted file mode 100644
index c14483a1b..000000000
--- a/src/duckdb/src/parser/tableref/expressionlistref.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string ExpressionListRef::ToString() const {
-	D_ASSERT(!values.empty());
-	string result = "(VALUES ";
-	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
-		if (row_idx > 0) {
-			result += ", ";
-		}
-		auto &row = values[row_idx];
-		result += "(";
-		for (idx_t col_idx = 0; col_idx < row.size(); col_idx++) {
-			if (col_idx > 0) {
-				result += ", ";
-			}
-			result += row[col_idx]->ToString();
-		}
-		result += ")";
-	}
-	result += ")";
-	return BaseToString(result, expected_names);
-}
-
-bool ExpressionListRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<ExpressionListRef>();
-	if (values.size() != other.values.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < values.size(); i++) {
-		if (values[i].size() != other.values[i].size()) {
-			return false;
-		}
-		for (idx_t j = 0; j < values[i].size(); j++) {
-			if (!values[i][j]->Equals(*other.values[i][j])) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-unique_ptr<TableRef> ExpressionListRef::Copy() {
-	// value list
-	auto result = make_uniq<ExpressionListRef>();
-	for (auto &val_list : values) {
-		vector<unique_ptr<ParsedExpression>> new_val_list;
-		new_val_list.reserve(val_list.size());
-		for (auto &val : val_list) {
-			new_val_list.push_back(val->Copy());
-		}
-		result->values.push_back(std::move(new_val_list));
-	}
-	result->expected_names = expected_names;
-	result->expected_types = expected_types;
-	CopyProperties(*result);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/joinref.cpp b/src/duckdb/src/parser/tableref/joinref.cpp
deleted file mode 100644
index a7477a3f5..000000000
--- a/src/duckdb/src/parser/tableref/joinref.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "duckdb/parser/tableref/joinref.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string JoinRef::ToString() const {
-	string result;
-	result = left->ToString() + " ";
-	switch (ref_type) {
-	case JoinRefType::REGULAR:
-		result += EnumUtil::ToString(type) + " JOIN ";
-		break;
-	case JoinRefType::NATURAL:
-		result += "NATURAL ";
-		result += EnumUtil::ToString(type) + " JOIN ";
-		break;
-	case JoinRefType::ASOF:
-		result += "ASOF ";
-		result += EnumUtil::ToString(type) + " JOIN ";
-		break;
-	case JoinRefType::CROSS:
-		result += ", ";
-		break;
-	case JoinRefType::POSITIONAL:
-		result += "POSITIONAL JOIN ";
-		break;
-	case JoinRefType::DEPENDENT:
-		result += "DEPENDENT JOIN ";
-		break;
-	}
-	result += right->ToString();
-	if (condition) {
-		D_ASSERT(using_columns.empty());
-		result += " ON (";
-		result += condition->ToString();
-		result += ")";
-	} else if (!using_columns.empty()) {
-		result += " USING (";
-		for (idx_t i = 0; i < using_columns.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += using_columns[i];
-		}
-		result += ")";
-	}
-	return result;
-}
-
-bool JoinRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<JoinRef>();
-	if (using_columns.size() != other.using_columns.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < using_columns.size(); i++) {
-		if (using_columns[i] != other.using_columns[i]) {
-			return false;
-		}
-	}
-	return left->Equals(*other.left) && right->Equals(*other.right) &&
-	       ParsedExpression::Equals(condition, other.condition) && type == other.type;
-}
-
-unique_ptr<TableRef> JoinRef::Copy() {
-	auto copy = make_uniq<JoinRef>(ref_type);
-	copy->left = left->Copy();
-	copy->right = right->Copy();
-	if (condition) {
-		copy->condition = condition->Copy();
-	}
-	copy->type = type;
-	copy->ref_type = ref_type;
-	copy->alias = alias;
-	copy->using_columns = using_columns;
-	copy->delim_flipped = delim_flipped;
-	for (auto &col : duplicate_eliminated_columns) {
-		copy->duplicate_eliminated_columns.emplace_back(col->Copy());
-	}
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/pivotref.cpp b/src/duckdb/src/parser/tableref/pivotref.cpp
deleted file mode 100644
index ffeef36f4..000000000
--- a/src/duckdb/src/parser/tableref/pivotref.cpp
+++ /dev/null
@@ -1,252 +0,0 @@
-#include "duckdb/parser/tableref/pivotref.hpp"
-
-#include "duckdb/common/limits.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// PivotColumn
-//===--------------------------------------------------------------------===//
-string PivotColumn::ToString() const {
-	string result;
-	if (!unpivot_names.empty()) {
-		D_ASSERT(pivot_expressions.empty());
-		// unpivot
-		if (unpivot_names.size() == 1) {
-			result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[0]);
-		} else {
-			result += "(";
-			for (idx_t n = 0; n < unpivot_names.size(); n++) {
-				if (n > 0) {
-					result += ", ";
-				}
-				result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[n]);
-			}
-			result += ")";
-		}
-	} else if (!pivot_expressions.empty()) {
-		// pivot
-		result += "(";
-		for (idx_t n = 0; n < pivot_expressions.size(); n++) {
-			if (n > 0) {
-				result += ", ";
-			}
-			result += pivot_expressions[n]->ToString();
-		}
-		result += ")";
-	}
-	result += " IN ";
-	if (pivot_enum.empty()) {
-		result += "(";
-		for (idx_t e = 0; e < entries.size(); e++) {
-			auto &entry = entries[e];
-			if (e > 0) {
-				result += ", ";
-			}
-			if (entry.expr) {
-				D_ASSERT(entry.values.empty());
-				result += entry.expr->ToString();
-			} else if (entry.values.size() == 1) {
-				result += entry.values[0].ToSQLString();
-			} else {
-				result += "(";
-				for (idx_t v = 0; v < entry.values.size(); v++) {
-					if (v > 0) {
-						result += ", ";
-					}
-					result += entry.values[v].ToSQLString();
-				}
-				result += ")";
-			}
-			if (!entry.alias.empty()) {
-				result += " AS " + KeywordHelper::WriteOptionallyQuoted(entry.alias);
-			}
-		}
-		result += ")";
-	} else {
-		result += KeywordHelper::WriteOptionallyQuoted(pivot_enum);
-	}
-	return result;
-}
-
-bool PivotColumnEntry::Equals(const PivotColumnEntry &other) const {
-	if (alias != other.alias) {
-		return false;
-	}
-	if (values.size() != other.values.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < values.size(); i++) {
-		if (!Value::NotDistinctFrom(values[i], other.values[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool PivotColumn::Equals(const PivotColumn &other) const {
-	if (!ExpressionUtil::ListEquals(pivot_expressions, other.pivot_expressions)) {
-		return false;
-	}
-	if (other.unpivot_names != unpivot_names) {
-		return false;
-	}
-	if (other.pivot_enum != pivot_enum) {
-		return false;
-	}
-	if (other.entries.size() != entries.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < entries.size(); i++) {
-		if (!entries[i].Equals(other.entries[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-PivotColumn PivotColumn::Copy() const {
-	PivotColumn result;
-	for (auto &expr : pivot_expressions) {
-		result.pivot_expressions.push_back(expr->Copy());
-	}
-	result.unpivot_names = unpivot_names;
-	for (auto &entry : entries) {
-		result.entries.push_back(entry.Copy());
-	}
-	result.pivot_enum = pivot_enum;
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// PivotColumnEntry
-//===--------------------------------------------------------------------===//
-PivotColumnEntry PivotColumnEntry::Copy() const {
-	PivotColumnEntry result;
-	result.values = values;
-	result.expr = expr ? expr->Copy() : nullptr;
-	result.alias = alias;
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// PivotRef
-//===--------------------------------------------------------------------===//
-string PivotRef::ToString() const {
-	string result;
-	result = source->ToString();
-	if (!aggregates.empty()) {
-		// pivot
-		result += " PIVOT (";
-		for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-			if (aggr_idx > 0) {
-				result += ", ";
-			}
-			result += aggregates[aggr_idx]->ToString();
-			if (!aggregates[aggr_idx]->GetAlias().empty()) {
-				result += " AS " + KeywordHelper::WriteOptionallyQuoted(aggregates[aggr_idx]->GetAlias());
-			}
-		}
-	} else {
-		// unpivot
-		result += " UNPIVOT ";
-		if (include_nulls) {
-			result += "INCLUDE NULLS ";
-		}
-		result += "(";
-		if (unpivot_names.size() == 1) {
-			result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[0]);
-		} else {
-			result += "(";
-			for (idx_t n = 0; n < unpivot_names.size(); n++) {
-				if (n > 0) {
-					result += ", ";
-				}
-				result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[n]);
-			}
-			result += ")";
-		}
-	}
-	result += " FOR";
-	for (auto &pivot : pivots) {
-		result += " ";
-		result += pivot.ToString();
-	}
-	if (!groups.empty()) {
-		result += " GROUP BY ";
-		for (idx_t i = 0; i < groups.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += groups[i];
-		}
-	}
-	result += ")";
-	if (!alias.empty()) {
-		result += " AS " + KeywordHelper::WriteOptionallyQuoted(alias);
-		if (!column_name_alias.empty()) {
-			result += "(";
-			for (idx_t i = 0; i < column_name_alias.size(); i++) {
-				if (i > 0) {
-					result += ", ";
-				}
-				result += KeywordHelper::WriteOptionallyQuoted(column_name_alias[i]);
-			}
-			result += ")";
-		}
-	}
-	return result;
-}
-
-bool PivotRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<PivotRef>();
-	if (!source->Equals(*other.source)) {
-		return false;
-	}
-	if (!ParsedExpression::ListEquals(aggregates, other.aggregates)) {
-		return false;
-	}
-	if (pivots.size() != other.pivots.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < pivots.size(); i++) {
-		if (!pivots[i].Equals(other.pivots[i])) {
-			return false;
-		}
-	}
-	if (unpivot_names != other.unpivot_names) {
-		return false;
-	}
-	if (alias != other.alias) {
-		return false;
-	}
-	if (groups != other.groups) {
-		return false;
-	}
-	if (include_nulls != other.include_nulls) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<TableRef> PivotRef::Copy() {
-	auto copy = make_uniq<PivotRef>();
-	copy->source = source->Copy();
-	for (auto &aggr : aggregates) {
-		copy->aggregates.push_back(aggr->Copy());
-	}
-	copy->unpivot_names = unpivot_names;
-	for (auto &entry : pivots) {
-		copy->pivots.push_back(entry.Copy());
-	}
-	copy->groups = groups;
-	copy->column_name_alias = column_name_alias;
-	copy->include_nulls = include_nulls;
-	copy->alias = alias;
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/showref.cpp b/src/duckdb/src/parser/tableref/showref.cpp
deleted file mode 100644
index 950defb31..000000000
--- a/src/duckdb/src/parser/tableref/showref.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "duckdb/parser/tableref/showref.hpp"
-
-namespace duckdb {
-
-ShowRef::ShowRef() : TableRef(TableReferenceType::SHOW_REF), show_type(ShowType::DESCRIBE) {
-}
-
-string ShowRef::ToString() const {
-	string result;
-	if (show_type == ShowType::SUMMARY) {
-		result += "SUMMARIZE ";
-	} else {
-		result += "DESCRIBE ";
-	}
-	if (query) {
-		result += "(";
-		result += query->ToString();
-		result += ")";
-	} else if (table_name != "__show_tables_expanded") {
-		result += table_name;
-	}
-	return result;
-}
-
-bool ShowRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<ShowRef>();
-	if (other.query.get() != query.get()) {
-		if (!other.query->Equals(query.get())) {
-			return false;
-		}
-	}
-	return table_name == other.table_name && show_type == other.show_type;
-}
-
-unique_ptr<TableRef> ShowRef::Copy() {
-	auto copy = make_uniq<ShowRef>();
-
-	copy->table_name = table_name;
-	copy->query = query ? query->Copy() : nullptr;
-	copy->show_type = show_type;
-	CopyProperties(*copy);
-
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/subqueryref.cpp b/src/duckdb/src/parser/tableref/subqueryref.cpp
deleted file mode 100644
index 2d3214bdc..000000000
--- a/src/duckdb/src/parser/tableref/subqueryref.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/parser/tableref/subqueryref.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-string SubqueryRef::ToString() const {
-	string result = "(" + subquery->ToString() + ")";
-	return BaseToString(result, column_name_alias);
-}
-
-SubqueryRef::SubqueryRef() : TableRef(TableReferenceType::SUBQUERY) {
-}
-
-SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
-    : TableRef(TableReferenceType::SUBQUERY), subquery(std::move(subquery_p)) {
-	this->alias = std::move(alias_p);
-}
-
-bool SubqueryRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<SubqueryRef>();
-	return subquery->Equals(*other.subquery);
-}
-
-unique_ptr<TableRef> SubqueryRef::Copy() {
-	auto copy = make_uniq<SubqueryRef>(unique_ptr_cast<SQLStatement, SelectStatement>(subquery->Copy()), alias);
-	copy->column_name_alias = column_name_alias;
-	CopyProperties(*copy);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/tableref/table_function.cpp b/src/duckdb/src/parser/tableref/table_function.cpp
deleted file mode 100644
index 29a6da9bc..000000000
--- a/src/duckdb/src/parser/tableref/table_function.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-TableFunctionRef::TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
-}
-
-string TableFunctionRef::ToString() const {
-	return BaseToString(function->ToString(), column_name_alias);
-}
-
-bool TableFunctionRef::Equals(const TableRef &other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<TableFunctionRef>();
-	return function->Equals(*other.function);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Copy() {
-	auto copy = make_uniq<TableFunctionRef>();
-
-	copy->function = function->Copy();
-	copy->column_name_alias = column_name_alias;
-	CopyProperties(*copy);
-
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp b/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp
deleted file mode 100644
index 8439fc863..000000000
--- a/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar &input, ForeignKeyInfo &fk_info) {
-	if (input.catalogname) {
-		throw ParserException("FOREIGN KEY constraints cannot be defined cross-database");
-	}
-	fk_info.schema = input.schemaname ? input.schemaname : "";
-	fk_info.table = input.relname;
-}
-
-static bool ForeignKeyActionSupported(char action) {
-	switch (action) {
-	case PG_FKCONSTR_ACTION_NOACTION:
-	case PG_FKCONSTR_ACTION_RESTRICT:
-		return true;
-	case PG_FKCONSTR_ACTION_CASCADE:
-	case PG_FKCONSTR_ACTION_SETDEFAULT:
-	case PG_FKCONSTR_ACTION_SETNULL:
-		return false;
-	default:
-		D_ASSERT(false);
-	}
-	return false;
-}
-
-static unique_ptr<ForeignKeyConstraint>
-TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint &constraint,
-                              optional_ptr<const string> override_fk_column = nullptr) {
-	if (!ForeignKeyActionSupported(constraint.fk_upd_action) || !ForeignKeyActionSupported(constraint.fk_del_action)) {
-		throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT");
-	}
-
-	ForeignKeyInfo fk_info;
-	fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-	ParseSchemaTableNameFK(*constraint.pktable, fk_info);
-
-	vector<string> pk_columns;
-	vector<string> fk_columns;
-
-	if (override_fk_column) {
-		D_ASSERT(!constraint.fk_attrs);
-		fk_columns.emplace_back(*override_fk_column);
-
-	} else if (constraint.fk_attrs) {
-		for (auto kc = constraint.fk_attrs->head; kc; kc = kc->next) {
-			auto value = Transformer::PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
-			fk_columns.emplace_back(value->val.str);
-		}
-	}
-
-	if (constraint.pk_attrs) {
-		for (auto kc = constraint.pk_attrs->head; kc; kc = kc->next) {
-			auto value = Transformer::PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
-			pk_columns.emplace_back(value->val.str);
-		}
-	}
-	if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-		throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-	}
-	if (fk_columns.empty()) {
-		throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
-	}
-	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-}
-
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGConstraint &constraint) {
-	switch (constraint.contype) {
-	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
-	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
-		bool is_primary_key = constraint.contype == duckdb_libpgquery::PG_CONSTR_PRIMARY;
-		if (!constraint.keys) {
-			throw ParserException("UNIQUE USING INDEX is not supported");
-		}
-		vector<string> columns;
-		for (auto kc = constraint.keys->head; kc; kc = kc->next) {
-			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
-			columns.emplace_back(value->val.str);
-		}
-		return make_uniq<UniqueConstraint>(columns, is_primary_key);
-	}
-	case duckdb_libpgquery::PG_CONSTR_CHECK: {
-		auto expression = TransformExpression(constraint.raw_expr);
-		if (expression->HasSubquery()) {
-			throw ParserException("subqueries prohibited in CHECK constraints");
-		}
-		return make_uniq<CheckConstraint>(TransformExpression(constraint.raw_expr));
-	}
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
-		return TransformForeignKeyConstraint(constraint);
-	default:
-		throw NotImplementedException("Constraint type not handled yet!");
-	}
-}
-
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGConstraint &constraint,
-                                                        ColumnDefinition &column, idx_t index) {
-	switch (constraint.contype) {
-	case duckdb_libpgquery::PG_CONSTR_NOTNULL:
-		return make_uniq<NotNullConstraint>(LogicalIndex(index));
-	case duckdb_libpgquery::PG_CONSTR_CHECK:
-		return TransformConstraint(constraint);
-	case duckdb_libpgquery::PG_CONSTR_PRIMARY:
-		return make_uniq<UniqueConstraint>(LogicalIndex(index), true);
-	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
-		return make_uniq<UniqueConstraint>(LogicalIndex(index), false);
-	case duckdb_libpgquery::PG_CONSTR_NULL:
-		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_GENERATED_VIRTUAL: {
-		if (column.HasDefaultValue()) {
-			throw InvalidInputException("\"%s\" has a DEFAULT value set, it can not become a GENERATED column",
-			                            column.Name());
-		}
-		column.SetGeneratedExpression(TransformExpression(constraint.raw_expr));
-		return nullptr;
-	}
-	case duckdb_libpgquery::PG_CONSTR_GENERATED_STORED:
-		throw InvalidInputException("Can not create a STORED generated column!");
-	case duckdb_libpgquery::PG_CONSTR_DEFAULT:
-		column.SetDefaultValue(TransformExpression(constraint.raw_expr));
-		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_COMPRESSION:
-		column.SetCompressionType(CompressionTypeFromString(constraint.compression_name));
-		if (column.CompressionType() == CompressionType::COMPRESSION_AUTO) {
-			throw ParserException("Unrecognized option for column compression, expected none, uncompressed, rle, "
-			                      "dictionary, pfor, bitpacking or fsst");
-		}
-		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
-		return TransformForeignKeyConstraint(constraint, &column.Name());
-	default:
-		throw NotImplementedException("Constraint not implemented!");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_array_access.cpp b/src/duckdb/src/parser/transform/expression/transform_array_access.cpp
deleted file mode 100644
index 447688c61..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_array_access.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection &indirection_node) {
-
-	// Transform the source expression.
-	unique_ptr<ParsedExpression> result;
-	result = TransformExpression(indirection_node.arg);
-
-	// Iterate the indices.
-	// For more complex expressions like (foo).field_name[42] a single indirection
-	// node can contain multiple indices.
-	idx_t list_size = 0;
-	for (auto node = indirection_node.indirection->head; node != nullptr; node = node->next) {
-		auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-
-		switch (target->type) {
-		case duckdb_libpgquery::T_PGAIndices: {
-			// Index access.
-			auto indices = PGCast<duckdb_libpgquery::PGAIndices>(*target.get());
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(std::move(result));
-
-			if (indices.is_slice) {
-				// If either the lower or upper bound is not specified, we use an empty constant LIST,
-				// which we handle in the execution.
-				auto constant_list = make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
-
-				auto lower = indices.lidx ? TransformExpression(indices.lidx) : constant_list->Copy();
-				children.push_back(std::move(lower));
-				auto upper = indices.uidx ? TransformExpression(indices.uidx) : constant_list->Copy();
-				children.push_back(std::move(upper));
-
-				if (indices.step) {
-					children.push_back(TransformExpression(indices.step));
-				}
-				result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_SLICE, std::move(children));
-				break;
-			}
-
-			// Array access.
-			D_ASSERT(!indices.lidx && indices.uidx);
-			children.push_back(TransformExpression(indices.uidx));
-			result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_EXTRACT, std::move(children));
-			break;
-		}
-		case duckdb_libpgquery::T_PGString: {
-			auto value = PGCast<duckdb_libpgquery::PGValue>(*target.get());
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(std::move(result));
-			children.push_back(TransformValue(value));
-			result = make_uniq<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
-			break;
-		}
-		case duckdb_libpgquery::T_PGFuncCall: {
-			auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*target.get());
-			auto function = TransformFuncCall(func);
-			if (function->GetExpressionType() != ExpressionType::FUNCTION) {
-				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
-			}
-			auto &function_expr = function->Cast<FunctionExpression>();
-			function_expr.children.insert(function_expr.children.begin(), std::move(result));
-			result = std::move(function);
-			break;
-		}
-		default:
-			throw NotImplementedException("Unimplemented subscript type");
-		}
-
-		list_size++;
-		StackCheck(list_size);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp b/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp
deleted file mode 100644
index 76078f5e2..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::PGBoolExpr &root) {
-	unique_ptr<ParsedExpression> result;
-	for (auto node = root.args->head; node != nullptr; node = node->next) {
-		auto next = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value));
-
-		switch (root.boolop) {
-		case duckdb_libpgquery::PG_AND_EXPR: {
-			if (!result) {
-				result = std::move(next);
-			} else {
-				result = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(result),
-				                                          std::move(next));
-			}
-			break;
-		}
-		case duckdb_libpgquery::PG_OR_EXPR: {
-			if (!result) {
-				result = std::move(next);
-			} else {
-				result = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_OR, std::move(result),
-				                                          std::move(next));
-			}
-			break;
-		}
-		case duckdb_libpgquery::PG_NOT_EXPR: {
-			if (next->GetExpressionType() == ExpressionType::COMPARE_IN) {
-				// convert COMPARE_IN to COMPARE_NOT_IN
-				next->SetExpressionTypeUnsafe(ExpressionType::COMPARE_NOT_IN);
-				result = std::move(next);
-			} else if (next->GetExpressionType() >= ExpressionType::COMPARE_EQUAL &&
-			           next->GetExpressionType() <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
-				// NOT on a comparison: we can negate the comparison
-				// e.g. NOT(x > y) is equivalent to x <= y
-				next->SetExpressionTypeUnsafe(NegateComparisonExpression(next->GetExpressionType()));
-				result = std::move(next);
-			} else {
-				result = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(next));
-			}
-			break;
-		}
-		}
-	}
-	SetQueryLocation(*result, root.location);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_boolean_test.cpp b/src/duckdb/src/parser/transform/expression/transform_boolean_test.cpp
deleted file mode 100644
index 8a7e23419..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_boolean_test.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-
-namespace duckdb {
-
-static unique_ptr<ParsedExpression> TransformBooleanTestInternal(unique_ptr<ParsedExpression> argument,
-                                                                 ExpressionType comparison_type, bool comparison_value,
-                                                                 int query_location) {
-	auto bool_value = make_uniq<ConstantExpression>(Value::BOOLEAN(comparison_value));
-	Transformer::SetQueryLocation(*bool_value, query_location);
-	// we cast the argument to bool to remove ambiguity wrt function binding on the comparison
-	auto cast_argument = make_uniq<CastExpression>(LogicalType::BOOLEAN, std::move(argument));
-
-	auto result = make_uniq<ComparisonExpression>(comparison_type, std::move(cast_argument), std::move(bool_value));
-	Transformer::SetQueryLocation(*result, query_location);
-	return std::move(result);
-}
-
-static unique_ptr<ParsedExpression> TransformBooleanTestIsNull(unique_ptr<ParsedExpression> argument,
-                                                               ExpressionType operator_type, int query_location) {
-	auto result = make_uniq<OperatorExpression>(operator_type, std::move(argument));
-	Transformer::SetQueryLocation(*result, query_location);
-	return std::move(result);
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformBooleanTest(duckdb_libpgquery::PGBooleanTest &node) {
-	auto argument = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(node.arg));
-
-	switch (node.booltesttype) {
-	case duckdb_libpgquery::PGBoolTestType::PG_IS_TRUE:
-		return TransformBooleanTestInternal(std::move(argument), ExpressionType::COMPARE_NOT_DISTINCT_FROM, true,
-		                                    node.location);
-	case duckdb_libpgquery::PGBoolTestType::IS_NOT_TRUE:
-		return TransformBooleanTestInternal(std::move(argument), ExpressionType::COMPARE_DISTINCT_FROM, true,
-		                                    node.location);
-	case duckdb_libpgquery::PGBoolTestType::IS_FALSE:
-		return TransformBooleanTestInternal(std::move(argument), ExpressionType::COMPARE_NOT_DISTINCT_FROM, false,
-		                                    node.location);
-	case duckdb_libpgquery::PGBoolTestType::IS_NOT_FALSE:
-		return TransformBooleanTestInternal(std::move(argument), ExpressionType::COMPARE_DISTINCT_FROM, false,
-		                                    node.location);
-	case duckdb_libpgquery::PGBoolTestType::IS_UNKNOWN: // IS NULL
-		return TransformBooleanTestIsNull(std::move(argument), ExpressionType::OPERATOR_IS_NULL, node.location);
-	case duckdb_libpgquery::PGBoolTestType::IS_NOT_UNKNOWN: // IS NOT NULL
-		return TransformBooleanTestIsNull(std::move(argument), ExpressionType::OPERATOR_IS_NOT_NULL, node.location);
-	default:
-		throw NotImplementedException("Unknown boolean test type %d", node.booltesttype);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_case.cpp b/src/duckdb/src/parser/transform/expression/transform_case.cpp
deleted file mode 100644
index 73eeb3189..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_case.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCaseExpr &root) {
-	auto case_node = make_uniq<CaseExpression>();
-	auto root_arg = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
-	for (auto cell = root.args->head; cell != nullptr; cell = cell->next) {
-		CaseCheck case_check;
-
-		auto w = PGPointerCast<duckdb_libpgquery::PGCaseWhen>(cell->data.ptr_value);
-		auto test_raw = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(w->expr));
-		unique_ptr<ParsedExpression> test;
-		if (root_arg) {
-			case_check.when_expr =
-			    make_uniq<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, root_arg->Copy(), std::move(test_raw));
-		} else {
-			case_check.when_expr = std::move(test_raw);
-		}
-		case_check.then_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(w->result));
-		case_node->case_checks.push_back(std::move(case_check));
-	}
-
-	if (root.defresult) {
-		case_node->else_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.defresult));
-	} else {
-		case_node->else_expr = make_uniq<ConstantExpression>(Value(LogicalType::SQLNULL));
-	}
-	SetQueryLocation(*case_node, root.location);
-	return std::move(case_node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_cast.cpp b/src/duckdb/src/parser/transform/expression/transform_cast.cpp
deleted file mode 100644
index a4b1dde59..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_cast.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/common/limits.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/blob.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast &root) {
-	// get the type to cast to
-	auto type_name = root.typeName;
-	LogicalType target_type = TransformTypeName(*type_name);
-
-	// check for a constant BLOB value, then return ConstantExpression with BLOB
-	if (!root.tryCast && target_type == LogicalType::BLOB && root.arg->type == duckdb_libpgquery::T_PGAConst) {
-		auto c = PGPointerCast<duckdb_libpgquery::PGAConst>(root.arg);
-		if (c->val.type == duckdb_libpgquery::T_PGString) {
-			CastParameters parameters;
-			if (root.location >= 0) {
-				parameters.query_location = NumericCast<idx_t>(root.location);
-			}
-			auto blob_data = Blob::ToBlob(string(c->val.val.str), parameters);
-			return make_uniq<ConstantExpression>(Value::BLOB_RAW(blob_data));
-		}
-	}
-	// transform the expression node
-	auto expression = TransformExpression(root.arg);
-	bool try_cast = root.tryCast;
-
-	// now create a cast operation
-	auto result = make_uniq<CastExpression>(target_type, std::move(expression), try_cast);
-	SetQueryLocation(*result, root.location);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_coalesce.cpp b/src/duckdb/src/parser/transform/expression/transform_coalesce.cpp
deleted file mode 100644
index bc42a2b22..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_coalesce.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-// COALESCE(a,b,c) returns the first argument that is NOT NULL, so
-// rewrite into CASE(a IS NOT NULL, a, CASE(b IS NOT NULL, b, c))
-unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::PGAExpr &root) {
-	auto coalesce_args = PGPointerCast<duckdb_libpgquery::PGList>(root.lexpr);
-	D_ASSERT(coalesce_args->length > 0); // parser ensures this already
-
-	auto coalesce_op = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-	for (auto cell = coalesce_args->head; cell; cell = cell->next) {
-		// get the value of the COALESCE
-		auto value_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(cell->data.ptr_value));
-		coalesce_op->children.push_back(std::move(value_expr));
-	}
-	return std::move(coalesce_op);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_columnref.cpp b/src/duckdb/src/parser/transform/expression/transform_columnref.cpp
deleted file mode 100644
index a232219fa..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_columnref.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-QualifiedColumnName TransformQualifiedColumnName(duckdb_libpgquery::PGList &list) {
-	QualifiedColumnName result;
-	switch (list.length) {
-	case 1:
-		result.column = const_char_ptr_cast(list.head->data.ptr_value);
-		break;
-	case 2:
-		result.table = const_char_ptr_cast(list.head->data.ptr_value);
-		result.column = const_char_ptr_cast(list.head->next->data.ptr_value);
-		break;
-	case 3:
-		result.schema = const_char_ptr_cast(list.head->data.ptr_value);
-		result.table = const_char_ptr_cast(list.head->next->data.ptr_value);
-		result.column = const_char_ptr_cast(list.head->next->next->data.ptr_value);
-		break;
-	case 4:
-		result.catalog = const_char_ptr_cast(list.head->data.ptr_value);
-		result.schema = const_char_ptr_cast(list.head->next->data.ptr_value);
-		result.table = const_char_ptr_cast(list.head->next->next->data.ptr_value);
-		result.column = const_char_ptr_cast(list.head->next->next->next->data.ptr_value);
-		break;
-	default:
-		throw ParserException("Qualified column name must have between 1 and 4 elements");
-	}
-	return result;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGAStar &star) {
-	auto result = make_uniq<StarExpression>(star.relation ? star.relation : string());
-	if (star.except_list) {
-		for (auto head = star.except_list->head; head; head = head->next) {
-			auto exclude_column_list = PGPointerCast<duckdb_libpgquery::PGList>(head->data.ptr_value);
-			auto exclude_column = TransformQualifiedColumnName(*exclude_column_list);
-			// qualified - add to exclude list
-			if (result->exclude_list.find(exclude_column) != result->exclude_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in EXCLUDE list", exclude_column.ToString());
-			}
-			result->exclude_list.insert(std::move(exclude_column));
-		}
-	}
-	if (star.replace_list) {
-		for (auto head = star.replace_list->head; head; head = head->next) {
-			auto list = PGPointerCast<duckdb_libpgquery::PGList>(head->data.ptr_value);
-			D_ASSERT(list->length == 2);
-			auto replace_expression =
-			    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(list->head->data.ptr_value));
-			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(list->tail->data.ptr_value);
-			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
-			string replace_entry = value->val.str;
-			if (result->replace_list.find(replace_entry) != result->replace_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in REPLACE list", replace_entry);
-			}
-			if (result->exclude_list.find(QualifiedColumnName(replace_entry)) != result->exclude_list.end()) {
-				throw ParserException("Column \"%s\" cannot occur in both EXCLUDE and REPLACE list", replace_entry);
-			}
-			result->replace_list.insert(make_pair(std::move(replace_entry), std::move(replace_expression)));
-		}
-	}
-	if (star.rename_list) {
-		for (auto head = star.rename_list->head; head; head = head->next) {
-			auto list = PGPointerCast<duckdb_libpgquery::PGList>(head->data.ptr_value);
-			D_ASSERT(list->length == 2);
-			auto rename_column_list = PGPointerCast<duckdb_libpgquery::PGList>(list->head->data.ptr_value);
-			auto rename_column = TransformQualifiedColumnName(*rename_column_list);
-			string new_name = char_ptr_cast(list->tail->data.ptr_value);
-			if (result->rename_list.find(rename_column) != result->rename_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in EXCLUDE list", rename_column.ToString());
-			}
-			if (result->exclude_list.find(rename_column) != result->exclude_list.end()) {
-				throw ParserException("Column \"%s\" cannot occur in both EXCLUDE and RENAME list",
-				                      rename_column.ToString());
-			}
-			if (result->replace_list.find(rename_column.column) != result->replace_list.end()) {
-				throw ParserException("Column \"%s\" cannot occur in both REPLACE and RENAME list",
-				                      rename_column.ToString());
-			}
-			result->rename_list.insert(make_pair(std::move(rename_column), std::move(new_name)));
-		}
-	}
-	if (star.expr) {
-		D_ASSERT(star.columns);
-		D_ASSERT(result->relation_name.empty());
-		D_ASSERT(result->exclude_list.empty());
-		D_ASSERT(result->replace_list.empty());
-		result->expr = TransformExpression(star.expr);
-		if (StarExpression::IsStar(*result->expr)) {
-			auto &child_star = result->expr->Cast<StarExpression>();
-			result->relation_name = child_star.relation_name;
-			result->exclude_list = std::move(child_star.exclude_list);
-			result->replace_list = std::move(child_star.replace_list);
-			result->expr.reset();
-		} else if (result->expr->GetExpressionType() == ExpressionType::LAMBDA) {
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(make_uniq<StarExpression>());
-			children.push_back(std::move(result->expr));
-			auto list_filter = make_uniq<FunctionExpression>("list_filter", std::move(children));
-			result->expr = std::move(list_filter);
-		}
-	}
-	result->columns = star.columns;
-	result->unpacked = star.unpacked;
-	SetQueryLocation(*result, star.location);
-	return std::move(result);
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::PGColumnRef &root) {
-	auto fields = root.fields;
-	auto head_node = PGPointerCast<duckdb_libpgquery::PGNode>(fields->head->data.ptr_value);
-	switch (head_node->type) {
-	case duckdb_libpgquery::T_PGString: {
-		if (fields->length < 1) {
-			throw InternalException("Unexpected field length");
-		}
-		vector<string> column_names;
-		for (auto node = fields->head; node; node = node->next) {
-			column_names.emplace_back(PGPointerCast<duckdb_libpgquery::PGValue>(node->data.ptr_value)->val.str);
-		}
-		auto colref = make_uniq<ColumnRefExpression>(std::move(column_names));
-		SetQueryLocation(*colref, root.location);
-		return std::move(colref);
-	}
-	case duckdb_libpgquery::T_PGAStar: {
-		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(*head_node));
-	}
-	default:
-		throw NotImplementedException("ColumnRef not implemented!");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_constant.cpp b/src/duckdb/src/parser/transform/expression/transform_constant.cpp
deleted file mode 100644
index 88fd295ff..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_constant.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PGValue val) {
-	switch (val.type) {
-	case duckdb_libpgquery::T_PGInteger:
-		D_ASSERT(val.val.ival <= NumericLimits<int32_t>::Maximum());
-		return make_uniq<ConstantExpression>(Value::INTEGER((int32_t)val.val.ival));
-	case duckdb_libpgquery::T_PGBitString: // FIXME: this should actually convert to BLOB
-	case duckdb_libpgquery::T_PGString:
-		return make_uniq<ConstantExpression>(Value(string(val.val.str)));
-	case duckdb_libpgquery::T_PGFloat: {
-		string_t str_val(val.val.str);
-		bool try_cast_as_integer = true;
-		bool try_cast_as_decimal = true;
-		optional_idx decimal_position = optional_idx::Invalid();
-		idx_t num_underscores = 0;
-		idx_t num_integer_underscores = 0;
-		for (idx_t i = 0; i < str_val.GetSize(); i++) {
-			if (val.val.str[i] == '.') {
-				// decimal point: cast as either decimal or double
-				try_cast_as_integer = false;
-				decimal_position = i;
-			}
-			if (val.val.str[i] == 'e' || val.val.str[i] == 'E') {
-				// found exponent, cast as double
-				try_cast_as_integer = false;
-				try_cast_as_decimal = false;
-			}
-			if (val.val.str[i] == '_') {
-				num_underscores++;
-				if (!decimal_position.IsValid()) {
-					num_integer_underscores++;
-				}
-			}
-		}
-		if (try_cast_as_integer) {
-			int64_t bigint_value;
-			// try to cast as bigint first
-			if (TryCast::Operation<string_t, int64_t>(str_val, bigint_value)) {
-				// successfully cast to bigint: bigint value
-				return make_uniq<ConstantExpression>(Value::BIGINT(bigint_value));
-			}
-			hugeint_t hugeint_value;
-			// if that is not successful; try to cast as hugeint
-			if (TryCast::Operation<string_t, hugeint_t>(str_val, hugeint_value)) {
-				// successfully cast to bigint: bigint value
-				return make_uniq<ConstantExpression>(Value::HUGEINT(hugeint_value));
-			}
-			uhugeint_t uhugeint_value;
-			// if that is not successful; try to cast as uhugeint
-			if (TryCast::Operation<string_t, uhugeint_t>(str_val, uhugeint_value)) {
-				// successfully cast to bigint: bigint value
-				return make_uniq<ConstantExpression>(Value::UHUGEINT(uhugeint_value));
-			}
-		}
-		idx_t decimal_offset = val.val.str[0] == '-' ? 3 : 2;
-		if (try_cast_as_decimal && decimal_position.IsValid() &&
-		    str_val.GetSize() - num_underscores < Decimal::MAX_WIDTH_DECIMAL + decimal_offset) {
-			// figure out the width/scale based on the decimal position
-			auto width = NumericCast<uint8_t>(str_val.GetSize() - 1 - num_underscores);
-			auto scale = NumericCast<uint8_t>(width - decimal_position.GetIndex() + num_integer_underscores);
-			if (val.val.str[0] == '-') {
-				width--;
-			}
-			if (width <= Decimal::MAX_WIDTH_DECIMAL) {
-				// we can cast the value as a decimal
-				Value val = Value(str_val);
-				val = val.DefaultCastAs(LogicalType::DECIMAL(width, scale));
-				return make_uniq<ConstantExpression>(std::move(val));
-			}
-		}
-		// if there is a decimal or the value is too big to cast as either hugeint or bigint
-		double dbl_value = Cast::Operation<string_t, double>(str_val);
-		return make_uniq<ConstantExpression>(Value::DOUBLE(dbl_value));
-	}
-	case duckdb_libpgquery::T_PGNull:
-		return make_uniq<ConstantExpression>(Value(LogicalType::SQLNULL));
-	default:
-		throw NotImplementedException("Value not implemented!");
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst &c) {
-	auto constant = TransformValue(c.val);
-	SetQueryLocation(*constant, c.location);
-	return std::move(constant);
-}
-
-bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) {
-	// We have to construct it like this because we don't have the ClientContext for binding/executing the expr here
-	switch (expr.GetExpressionType()) {
-	case ExpressionType::FUNCTION: {
-		auto &function = expr.Cast<FunctionExpression>();
-		if (function.function_name == "struct_pack") {
-			unordered_set<string> unique_names;
-			child_list_t<Value> values;
-			values.reserve(function.children.size());
-			for (const auto &child : function.children) {
-				if (!unique_names.insert(child->GetAlias()).second) {
-					throw BinderException("Duplicate struct entry name \"%s\"", child->GetAlias());
-				}
-				Value child_value;
-				if (!ConstructConstantFromExpression(*child, child_value)) {
-					return false;
-				}
-				values.emplace_back(child->GetAlias(), std::move(child_value));
-			}
-			value = Value::STRUCT(std::move(values));
-			return true;
-		} else if (function.function_name == "list_value") {
-			vector<Value> values;
-			values.reserve(function.children.size());
-			for (const auto &child : function.children) {
-				Value child_value;
-				if (!ConstructConstantFromExpression(*child, child_value)) {
-					return false;
-				}
-				values.emplace_back(std::move(child_value));
-			}
-
-			// figure out child type
-			LogicalType child_type(LogicalTypeId::SQLNULL);
-			for (auto &child_value : values) {
-				child_type = LogicalType::ForceMaxLogicalType(child_type, child_value.type());
-			}
-
-			// finally create the list
-			value = Value::LIST(child_type, values);
-			return true;
-		} else if (function.function_name == "map") {
-			Value keys;
-			if (!ConstructConstantFromExpression(*function.children[0], keys)) {
-				return false;
-			}
-
-			Value values;
-			if (!ConstructConstantFromExpression(*function.children[1], values)) {
-				return false;
-			}
-
-			vector<Value> keys_unpacked = ListValue::GetChildren(keys);
-			vector<Value> values_unpacked = ListValue::GetChildren(values);
-
-			value = Value::MAP(ListType::GetChildType(keys.type()), ListType::GetChildType(values.type()),
-			                   keys_unpacked, values_unpacked);
-			return true;
-		} else {
-			return false;
-		}
-	}
-	case ExpressionType::VALUE_CONSTANT: {
-		auto &constant = expr.Cast<ConstantExpression>();
-		value = constant.value;
-		return true;
-	}
-	case ExpressionType::OPERATOR_CAST: {
-		auto &cast = expr.Cast<CastExpression>();
-		Value dummy_value;
-		if (!ConstructConstantFromExpression(*cast.child, dummy_value)) {
-			return false;
-		}
-
-		string error_message;
-		if (!dummy_value.DefaultTryCastAs(cast.cast_type, value, &error_message)) {
-			throw ConversionException("Unable to cast %s to %s", dummy_value.ToString(),
-			                          EnumUtil::ToString(cast.cast_type.id()));
-		}
-		return true;
-	}
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_expression.cpp b/src/duckdb/src/parser/transform/expression/transform_expression.cpp
deleted file mode 100644
index 1f64c8ed4..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_expression.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression/default_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::PGResTarget &root) {
-	auto expr = TransformExpression(root.val);
-	if (!expr) {
-		return nullptr;
-	}
-	if (root.name) {
-		expr->SetAlias(root.name);
-	}
-	return expr;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr &root) {
-
-	auto expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
-	if (root.name) {
-		expr->SetAlias(root.name);
-	}
-	return expr;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery::PGNode &node) {
-
-	auto stack_checker = StackCheck();
-
-	switch (node.type) {
-	case duckdb_libpgquery::T_PGColumnRef:
-		return TransformColumnRef(PGCast<duckdb_libpgquery::PGColumnRef>(node));
-	case duckdb_libpgquery::T_PGAConst:
-		return TransformConstant(PGCast<duckdb_libpgquery::PGAConst>(node));
-	case duckdb_libpgquery::T_PGAExpr:
-		return TransformAExpr(PGCast<duckdb_libpgquery::PGAExpr>(node));
-	case duckdb_libpgquery::T_PGFuncCall:
-		return TransformFuncCall(PGCast<duckdb_libpgquery::PGFuncCall>(node));
-	case duckdb_libpgquery::T_PGBoolExpr:
-		return TransformBoolExpr(PGCast<duckdb_libpgquery::PGBoolExpr>(node));
-	case duckdb_libpgquery::T_PGTypeCast:
-		return TransformTypeCast(PGCast<duckdb_libpgquery::PGTypeCast>(node));
-	case duckdb_libpgquery::T_PGCaseExpr:
-		return TransformCase(PGCast<duckdb_libpgquery::PGCaseExpr>(node));
-	case duckdb_libpgquery::T_PGSubLink:
-		return TransformSubquery(PGCast<duckdb_libpgquery::PGSubLink>(node));
-	case duckdb_libpgquery::T_PGCoalesceExpr:
-		return TransformCoalesce(PGCast<duckdb_libpgquery::PGAExpr>(node));
-	case duckdb_libpgquery::T_PGNullTest:
-		return TransformNullTest(PGCast<duckdb_libpgquery::PGNullTest>(node));
-	case duckdb_libpgquery::T_PGResTarget:
-		return TransformResTarget(PGCast<duckdb_libpgquery::PGResTarget>(node));
-	case duckdb_libpgquery::T_PGParamRef:
-		return TransformParamRef(PGCast<duckdb_libpgquery::PGParamRef>(node));
-	case duckdb_libpgquery::T_PGNamedArgExpr:
-		return TransformNamedArg(PGCast<duckdb_libpgquery::PGNamedArgExpr>(node));
-	case duckdb_libpgquery::T_PGSQLValueFunction:
-		return TransformSQLValueFunction(PGCast<duckdb_libpgquery::PGSQLValueFunction>(node));
-	case duckdb_libpgquery::T_PGSetToDefault:
-		return make_uniq<DefaultExpression>();
-	case duckdb_libpgquery::T_PGCollateClause:
-		return TransformCollateExpr(PGCast<duckdb_libpgquery::PGCollateClause>(node));
-	case duckdb_libpgquery::T_PGIntervalConstant:
-		return TransformInterval(PGCast<duckdb_libpgquery::PGIntervalConstant>(node));
-	case duckdb_libpgquery::T_PGLambdaFunction:
-		return TransformLambda(PGCast<duckdb_libpgquery::PGLambdaFunction>(node));
-	case duckdb_libpgquery::T_PGAIndirection:
-		return TransformArrayAccess(PGCast<duckdb_libpgquery::PGAIndirection>(node));
-	case duckdb_libpgquery::T_PGPositionalReference:
-		return TransformPositionalReference(PGCast<duckdb_libpgquery::PGPositionalReference>(node));
-	case duckdb_libpgquery::T_PGGroupingFunc:
-		return TransformGroupingFunction(PGCast<duckdb_libpgquery::PGGroupingFunc>(node));
-	case duckdb_libpgquery::T_PGAStar:
-		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(node));
-	case duckdb_libpgquery::T_PGBooleanTest:
-		return TransformBooleanTest(PGCast<duckdb_libpgquery::PGBooleanTest>(node));
-	case duckdb_libpgquery::T_PGMultiAssignRef:
-		return TransformMultiAssignRef(PGCast<duckdb_libpgquery::PGMultiAssignRef>(node));
-
-	default:
-		throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node.type), (int)node.type);
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformExpression(optional_ptr<duckdb_libpgquery::PGNode> node) {
-	if (!node) {
-		return nullptr;
-	}
-	return TransformExpression(*node);
-}
-
-void Transformer::TransformExpressionList(duckdb_libpgquery::PGList &list,
-                                          vector<unique_ptr<ParsedExpression>> &result) {
-	for (auto node = list.head; node != nullptr; node = node->next) {
-		auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-
-		auto expr = TransformExpression(*target);
-		result.push_back(std::move(expr));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_function.cpp b/src/duckdb/src/parser/transform/expression/transform_function.cpp
deleted file mode 100644
index e410b7049..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_function.cpp
+++ /dev/null
@@ -1,388 +0,0 @@
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr,
-                                     const char *window_name) {
-	// next: partitioning/ordering expressions
-	if (window_spec.partitionClause) {
-		if (window_name && !expr.partitions.empty()) {
-			throw ParserException("Cannot override PARTITION BY clause of window \"%s\"", window_name);
-		}
-		TransformExpressionList(*window_spec.partitionClause, expr.partitions);
-	}
-	if (window_spec.orderClause) {
-		if (window_name && !expr.orders.empty()) {
-			throw ParserException("Cannot override ORDER BY clause of window \"%s\"", window_name);
-		}
-		TransformOrderBy(window_spec.orderClause, expr.orders);
-		for (auto &order : expr.orders) {
-			if (order.expression->GetExpressionType() == ExpressionType::STAR) {
-				throw ParserException("Cannot ORDER BY ALL in a window expression");
-			}
-		}
-	}
-}
-
-void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr) {
-	// finally: specifics of bounds
-	expr.start_expr = TransformExpression(window_spec.startOffset);
-	expr.end_expr = TransformExpression(window_spec.endOffset);
-
-	if ((window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) ||
-	    (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)) {
-		throw InternalException(
-		    "Window frames starting with unbounded following or ending in unbounded preceding make no sense");
-	}
-
-	if (window_spec.frameOptions & FRAMEOPTION_GROUPS) {
-		throw ParserException("GROUPS mode for window functions is not implemented yet");
-	}
-	const bool rangeMode = (window_spec.frameOptions & FRAMEOPTION_RANGE) != 0;
-	if (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
-		expr.start = WindowBoundary::UNBOUNDED_PRECEDING;
-	} else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING) {
-		expr.start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) {
-		expr.start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
-	} else if (window_spec.frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
-		expr.start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
-	}
-
-	if (window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
-		expr.end = WindowBoundary::UNBOUNDED_FOLLOWING;
-	} else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING) {
-		expr.end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING) {
-		expr.end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
-	} else if (window_spec.frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
-		expr.end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
-	}
-
-	D_ASSERT(expr.start != WindowBoundary::INVALID && expr.end != WindowBoundary::INVALID);
-	if (((window_spec.frameOptions & (FRAMEOPTION_START_OFFSET_PRECEDING | FRAMEOPTION_START_OFFSET_FOLLOWING)) &&
-	     !expr.start_expr) ||
-	    ((window_spec.frameOptions & (FRAMEOPTION_END_OFFSET_PRECEDING | FRAMEOPTION_END_OFFSET_FOLLOWING)) &&
-	     !expr.end_expr)) {
-		throw InternalException("Failed to transform window boundary expression");
-	}
-
-	if (window_spec.frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW) {
-		expr.exclude_clause = WindowExcludeMode::CURRENT_ROW;
-	} else if (window_spec.frameOptions & FRAMEOPTION_EXCLUDE_GROUP) {
-		expr.exclude_clause = WindowExcludeMode::GROUP;
-	} else if (window_spec.frameOptions & FRAMEOPTION_EXCLUDE_TIES) {
-		expr.exclude_clause = WindowExcludeMode::TIES;
-	} else {
-		expr.exclude_clause = WindowExcludeMode::NO_OTHER;
-	}
-}
-
-bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {
-	if (expr.GetExpressionClass() != ExpressionClass::STAR) {
-		return false;
-	}
-	auto &star = expr.Cast<StarExpression>();
-	if (!star.columns && star.exclude_list.empty() && star.replace_list.empty()) {
-		return true;
-	}
-	return false;
-}
-
-bool Transformer::InWindowDefinition() {
-	if (in_window_definition) {
-		return true;
-	}
-	if (parent) {
-		return parent->InWindowDefinition();
-	}
-	return false;
-}
-
-static bool IsOrderableWindowFunction(ExpressionType type) {
-	switch (type) {
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_NTH_VALUE:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_NTILE:
-	case ExpressionType::WINDOW_CUME_DIST:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-	case ExpressionType::WINDOW_AGGREGATE:
-		return true;
-	case ExpressionType::WINDOW_RANK_DENSE:
-		return false;
-	default:
-		throw InternalException("Unknown orderable window type %s", ExpressionTypeToString(type).c_str());
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall &root) {
-	auto name = root.funcname;
-	string catalog, schema, function_name;
-	if (name->length == 3) {
-		// catalog + schema + name
-		catalog = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->data.ptr_value)->val.str;
-		schema = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->next->data.ptr_value)->val.str;
-		function_name = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->next->next->data.ptr_value)->val.str;
-	} else if (name->length == 2) {
-		// schema + name
-		catalog = INVALID_CATALOG;
-		schema = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->data.ptr_value)->val.str;
-		function_name = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->next->data.ptr_value)->val.str;
-	} else if (name->length == 1) {
-		// unqualified name
-		catalog = INVALID_CATALOG;
-		schema = INVALID_SCHEMA;
-		function_name = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->data.ptr_value)->val.str;
-	} else {
-		throw ParserException("TransformFuncCall - Expected 1, 2 or 3 qualifications");
-	}
-
-	//  transform children
-	vector<unique_ptr<ParsedExpression>> children;
-	if (root.args) {
-		TransformExpressionList(*root.args, children);
-	}
-	if (children.size() == 1 && ExpressionIsEmptyStar(*children[0]) && !root.agg_distinct && !root.agg_order) {
-		// COUNT(*) gets translated into COUNT()
-		children.clear();
-	}
-
-	auto lowercase_name = StringUtil::Lower(function_name);
-	if (root.over) {
-		if (InWindowDefinition()) {
-			throw ParserException("window functions are not allowed in window definitions");
-		}
-
-		const auto win_fun_type = WindowExpression::WindowToExpressionType(lowercase_name);
-		if (win_fun_type == ExpressionType::INVALID) {
-			throw InternalException("Unknown/unsupported window function");
-		}
-
-		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root.agg_distinct) {
-			throw ParserException("DISTINCT is not implemented for non-aggregate window functions!");
-		}
-
-		if (root.agg_order && !IsOrderableWindowFunction(win_fun_type)) {
-			throw ParserException("ORDER BY is not supported for the window function \"%s\"", lowercase_name.c_str());
-		}
-
-		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root.agg_filter) {
-			throw ParserException("FILTER is not implemented for non-aggregate window functions!");
-		}
-		if (root.export_state) {
-			throw ParserException("EXPORT_STATE is not supported for window functions!");
-		}
-
-		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE &&
-		    root.agg_ignore_nulls != duckdb_libpgquery::PG_DEFAULT_NULLS) {
-			throw ParserException("RESPECT/IGNORE NULLS is not supported for windowed aggregates");
-		}
-
-		auto expr = make_uniq<WindowExpression>(win_fun_type, std::move(catalog), std::move(schema), lowercase_name);
-		expr->ignore_nulls = (root.agg_ignore_nulls == duckdb_libpgquery::PG_IGNORE_NULLS);
-		expr->distinct = root.agg_distinct;
-
-		if (root.agg_filter) {
-			auto filter_expr = TransformExpression(root.agg_filter);
-			expr->filter_expr = std::move(filter_expr);
-		}
-
-		if (root.agg_order) {
-			auto order_bys = make_uniq<OrderModifier>();
-			TransformOrderBy(root.agg_order, order_bys->orders);
-			expr->arg_orders = std::move(order_bys->orders);
-		}
-
-		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE) {
-			expr->children = std::move(children);
-		} else {
-			if (!children.empty()) {
-				expr->children.push_back(std::move(children[0]));
-			}
-			if (win_fun_type == ExpressionType::WINDOW_LEAD || win_fun_type == ExpressionType::WINDOW_LAG) {
-				if (children.size() > 1) {
-					expr->offset_expr = std::move(children[1]);
-				}
-				if (children.size() > 2) {
-					expr->default_expr = std::move(children[2]);
-				}
-				if (children.size() > 3) {
-					throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-				}
-			} else if (win_fun_type == ExpressionType::WINDOW_NTH_VALUE) {
-				if (children.size() > 1) {
-					expr->children.push_back(std::move(children[1]));
-				}
-				if (children.size() > 2) {
-					throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-				}
-			} else {
-				if (children.size() > 1) {
-					throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-				}
-			}
-		}
-		auto window_spec = PGPointerCast<duckdb_libpgquery::PGWindowDef>(root.over);
-		if (window_spec->name) {
-			auto it = window_clauses.find(string(window_spec->name));
-			if (it == window_clauses.end()) {
-				throw ParserException("window \"%s\" does not exist", window_spec->name);
-			}
-			window_spec = it->second;
-			D_ASSERT(window_spec);
-		}
-		auto window_ref = window_spec;
-		auto window_name = window_ref->refname;
-		if (window_ref->refname) {
-			auto it = window_clauses.find(string(window_spec->refname));
-			if (it == window_clauses.end()) {
-				throw ParserException("window \"%s\" does not exist", window_spec->refname);
-			}
-			window_ref = it->second;
-			D_ASSERT(window_ref);
-			if (window_ref->startOffset || window_ref->endOffset || window_ref->frameOptions != FRAMEOPTION_DEFAULTS) {
-				throw ParserException("cannot copy window \"%s\" because it has a frame clause", window_spec->refname);
-			}
-		}
-		in_window_definition = true;
-		TransformWindowDef(*window_ref, *expr);
-		if (window_ref != window_spec) {
-			TransformWindowDef(*window_spec, *expr, window_name);
-		}
-		TransformWindowFrame(*window_spec, *expr);
-		in_window_definition = false;
-		SetQueryLocation(*expr, root.location);
-		return std::move(expr);
-	}
-
-	if (root.agg_ignore_nulls != duckdb_libpgquery::PG_DEFAULT_NULLS) {
-		throw ParserException("RESPECT/IGNORE NULLS is not supported for non-window functions");
-	}
-
-	unique_ptr<ParsedExpression> filter_expr;
-	if (root.agg_filter) {
-		filter_expr = TransformExpression(root.agg_filter);
-	}
-
-	auto order_bys = make_uniq<OrderModifier>();
-	TransformOrderBy(root.agg_order, order_bys->orders);
-
-	// Ordered aggregates can be either WITHIN GROUP or after the function arguments
-	if (root.agg_within_group) {
-		//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
-		//  Since we implement "ordered aggregates" without sorting,
-		//  we map all the ones we support to the corresponding aggregate function.
-		if (order_bys->orders.size() != 1) {
-			throw ParserException("Cannot use multiple ORDER BY clauses with WITHIN GROUP");
-		}
-		if (lowercase_name == "percentile_cont") {
-			if (children.size() != 1) {
-				throw ParserException("Wrong number of arguments for PERCENTILE_CONT");
-			}
-			lowercase_name = "quantile_cont";
-		} else if (lowercase_name == "percentile_disc") {
-			if (children.size() != 1) {
-				throw ParserException("Wrong number of arguments for PERCENTILE_DISC");
-			}
-			lowercase_name = "quantile_disc";
-		} else if (lowercase_name == "mode") {
-			if (!children.empty()) {
-				throw ParserException("Wrong number of arguments for MODE");
-			}
-			lowercase_name = "mode";
-		} else {
-			throw ParserException("Unknown ordered aggregate \"%s\".", function_name);
-		}
-	}
-
-	// star gets eaten in the parser
-	if (lowercase_name == "count" && children.empty()) {
-		lowercase_name = "count_star";
-	}
-
-	if (lowercase_name == "if") {
-		if (children.size() != 3) {
-			throw ParserException("Wrong number of arguments to IF.");
-		}
-		auto expr = make_uniq<CaseExpression>();
-		CaseCheck check;
-		check.when_expr = std::move(children[0]);
-		check.then_expr = std::move(children[1]);
-		expr->case_checks.push_back(std::move(check));
-		expr->else_expr = std::move(children[2]);
-		return std::move(expr);
-	} else if (lowercase_name == "construct_array") {
-		auto construct_array = make_uniq<OperatorExpression>(ExpressionType::ARRAY_CONSTRUCTOR);
-		construct_array->children = std::move(children);
-		return std::move(construct_array);
-	} else if (lowercase_name == "__internal_position_operator") {
-		if (children.size() != 2) {
-			throw ParserException("Wrong number of arguments to __internal_position_operator.");
-		}
-		// swap arguments for POSITION(x IN y)
-		std::swap(children[0], children[1]);
-		lowercase_name = "position";
-	} else if (lowercase_name == "ifnull") {
-		if (children.size() != 2) {
-			throw ParserException("Wrong number of arguments to IFNULL.");
-		}
-
-		//  Two-argument COALESCE
-		auto coalesce_op = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-		coalesce_op->children.push_back(std::move(children[0]));
-		coalesce_op->children.push_back(std::move(children[1]));
-		return std::move(coalesce_op);
-	} else if (lowercase_name == "list" && order_bys->orders.size() == 1) {
-		// list(expr ORDER BY expr <sense> <nulls>) => list_sort(list(expr), <sense>, <nulls>)
-		if (children.size() != 1) {
-			throw ParserException("Wrong number of arguments to LIST.");
-		}
-		auto arg_expr = children[0].get();
-		auto &order_by = order_bys->orders[0];
-		if (arg_expr->Equals(*order_by.expression)) {
-			auto sense = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.type));
-			auto nulls = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.null_order));
-			order_bys = nullptr;
-			auto unordered = make_uniq<FunctionExpression>(catalog, schema, lowercase_name.c_str(), std::move(children),
-			                                               std::move(filter_expr), std::move(order_bys),
-			                                               root.agg_distinct, false, root.export_state);
-			lowercase_name = "list_sort";
-			order_bys.reset();   // NOLINT
-			filter_expr.reset(); // NOLINT
-			children.clear();    // NOLINT
-			root.agg_distinct = false;
-			children.emplace_back(std::move(unordered));
-			children.emplace_back(std::move(sense));
-			children.emplace_back(std::move(nulls));
-		}
-	}
-
-	auto function = make_uniq<FunctionExpression>(std::move(catalog), std::move(schema), lowercase_name.c_str(),
-	                                              std::move(children), std::move(filter_expr), std::move(order_bys),
-	                                              root.agg_distinct, false, root.export_state);
-	SetQueryLocation(*function, root.location);
-
-	return std::move(function);
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction &node) {
-	throw InternalException("SQL value functions should not be emitted by the parser");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_grouping_function.cpp b/src/duckdb/src/parser/transform/expression/transform_grouping_function.cpp
deleted file mode 100644
index a3300cb80..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_grouping_function.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc &grouping) {
-	auto op = make_uniq<OperatorExpression>(ExpressionType::GROUPING_FUNCTION);
-	for (auto node = grouping.args->head; node; node = node->next) {
-		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-		op->children.push_back(TransformExpression(n));
-	}
-	SetQueryLocation(*op, grouping.location);
-	return std::move(op);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_interval.cpp b/src/duckdb/src/parser/transform/expression/transform_interval.cpp
deleted file mode 100644
index 421ebde93..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_interval.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::PGIntervalConstant &node) {
-	// handle post-fix notation of INTERVAL
-
-	// three scenarios
-	// interval (expr) year
-	// interval 'string' year
-	// interval int year
-	unique_ptr<ParsedExpression> expr;
-	switch (node.val_type) {
-	case duckdb_libpgquery::T_PGAExpr:
-		expr = TransformExpression(node.eval);
-		break;
-	case duckdb_libpgquery::T_PGString:
-		expr = make_uniq<ConstantExpression>(Value(node.sval));
-		break;
-	case duckdb_libpgquery::T_PGInteger:
-		expr = make_uniq<ConstantExpression>(Value(node.ival));
-		break;
-	default:
-		throw InternalException("Unsupported interval transformation");
-	}
-
-	if (!node.typmods) {
-		return make_uniq<CastExpression>(LogicalType::INTERVAL, std::move(expr));
-	}
-
-	int32_t mask = NumericCast<int32_t>(
-	    PGPointerCast<duckdb_libpgquery::PGAConst>(node.typmods->head->data.ptr_value)->val.val.ival);
-	// these seemingly random constants are from libpg_query/include/utils/datetime.hpp
-	// they are copied here to avoid having to include this header
-	// the bitshift is from the function INTERVAL_MASK in the parser
-	constexpr int32_t MONTH_MASK = 1 << 1;
-	constexpr int32_t YEAR_MASK = 1 << 2;
-	constexpr int32_t DAY_MASK = 1 << 3;
-	constexpr int32_t HOUR_MASK = 1 << 10;
-	constexpr int32_t MINUTE_MASK = 1 << 11;
-	constexpr int32_t SECOND_MASK = 1 << 12;
-	constexpr int32_t MILLISECOND_MASK = 1 << 13;
-	constexpr int32_t MICROSECOND_MASK = 1 << 14;
-	constexpr int32_t WEEK_MASK = 1 << 24;
-	constexpr int32_t DECADE_MASK = 1 << 25;
-	constexpr int32_t CENTURY_MASK = 1 << 26;
-	constexpr int32_t MILLENNIUM_MASK = 1 << 27;
-	constexpr int32_t QUARTER_MASK = 1 << 29;
-
-	// we need to check certain combinations
-	// because certain interval masks (e.g. INTERVAL '10' HOURS TO DAYS) set multiple bits
-	// for now we don't support all of the combined ones
-	// (we might add support if someone complains about it)
-
-	string fname;
-	LogicalType parse_type = LogicalType::DOUBLE;
-	LogicalType target_type;
-	if (mask & YEAR_MASK && mask & MONTH_MASK) {
-		// DAY TO HOUR
-		throw ParserException("YEAR TO MONTH is not supported");
-	} else if (mask & DAY_MASK && mask & HOUR_MASK) {
-		// DAY TO HOUR
-		throw ParserException("DAY TO HOUR is not supported");
-	} else if (mask & DAY_MASK && mask & MINUTE_MASK) {
-		// DAY TO MINUTE
-		throw ParserException("DAY TO MINUTE is not supported");
-	} else if (mask & DAY_MASK && mask & SECOND_MASK) {
-		// DAY TO SECOND
-		throw ParserException("DAY TO SECOND is not supported");
-	} else if (mask & HOUR_MASK && mask & MINUTE_MASK) {
-		// DAY TO SECOND
-		throw ParserException("HOUR TO MINUTE is not supported");
-	} else if (mask & HOUR_MASK && mask & SECOND_MASK) {
-		// DAY TO SECOND
-		throw ParserException("HOUR TO SECOND is not supported");
-	} else if (mask & MINUTE_MASK && mask & SECOND_MASK) {
-		// DAY TO SECOND
-		throw ParserException("MINUTE TO SECOND is not supported");
-	} else if (mask & YEAR_MASK) {
-		// YEAR
-		fname = "to_years";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & MONTH_MASK) {
-		// MONTH
-		fname = "to_months";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & DAY_MASK) {
-		// DAY
-		fname = "to_days";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & HOUR_MASK) {
-		// HOUR
-		fname = "to_hours";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & MINUTE_MASK) {
-		// MINUTE
-		fname = "to_minutes";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & SECOND_MASK) {
-		// SECOND
-		fname = "to_seconds";
-		target_type = LogicalType::DOUBLE;
-	} else if (mask & MILLISECOND_MASK) {
-		// MILLISECOND
-		fname = "to_milliseconds";
-		target_type = LogicalType::DOUBLE;
-	} else if (mask & MICROSECOND_MASK) {
-		// MICROSECOND
-		fname = "to_microseconds";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & WEEK_MASK) {
-		// WEEK
-		fname = "to_weeks";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & QUARTER_MASK) {
-		// QUARTER
-		fname = "to_quarters";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & DECADE_MASK) {
-		// DECADE
-		fname = "to_decades";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & CENTURY_MASK) {
-		// CENTURY
-		fname = "to_centuries";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & MILLENNIUM_MASK) {
-		// MILLENNIUM
-		fname = "to_millennia";
-		target_type = LogicalType::INTEGER;
-	} else {
-		throw InternalException("Unsupported interval post-fix");
-	}
-	// first push a cast to the parse type
-	expr = make_uniq<CastExpression>(parse_type, std::move(expr));
-
-	// next, truncate it if the target type doesn't match the parse type
-	if (target_type != parse_type) {
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(std::move(expr));
-		expr = make_uniq<FunctionExpression>("trunc", std::move(children));
-		expr = make_uniq<CastExpression>(target_type, std::move(expr));
-	}
-	// now push the operation
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(std::move(expr));
-	return make_uniq<FunctionExpression>(fname, std::move(children));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_is_null.cpp b/src/duckdb/src/parser/transform/expression/transform_is_null.cpp
deleted file mode 100644
index c588438b0..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_is_null.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::PGNullTest &root) {
-	auto arg = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
-	if (root.argisrow) {
-		throw NotImplementedException("IS NULL argisrow");
-	}
-	ExpressionType expr_type = (root.nulltesttype == duckdb_libpgquery::PG_IS_NULL)
-	                               ? ExpressionType::OPERATOR_IS_NULL
-	                               : ExpressionType::OPERATOR_IS_NOT_NULL;
-
-	auto result = make_uniq<OperatorExpression>(expr_type, std::move(arg));
-	SetQueryLocation(*result, root.location);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_lambda.cpp b/src/duckdb/src/parser/transform/expression/transform_lambda.cpp
deleted file mode 100644
index 00011ad33..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_lambda.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction &node) {
-	D_ASSERT(node.lhs);
-	D_ASSERT(node.rhs);
-
-	auto lhs = TransformExpression(node.lhs);
-	auto rhs = TransformExpression(node.rhs);
-	D_ASSERT(lhs);
-	D_ASSERT(rhs);
-	auto result = make_uniq<LambdaExpression>(std::move(lhs), std::move(rhs));
-	SetQueryLocation(*result, node.location);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_multi_assign_reference.cpp b/src/duckdb/src/parser/transform/expression/transform_multi_assign_reference.cpp
deleted file mode 100644
index 28dc623f3..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_multi_assign_reference.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformMultiAssignRef(duckdb_libpgquery::PGMultiAssignRef &root) {
-
-	// Early-out, if the root is not a function call.
-	if (root.source->type != duckdb_libpgquery::T_PGFuncCall) {
-		return TransformExpression(root.source);
-	}
-
-	auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*root.source);
-
-	// Only allow ROW function.
-	auto function = PGPointerCast<duckdb_libpgquery::PGValue>(func.funcname->tail->data.ptr_value);
-	char const *function_name = function->val.str;
-	if (!function_name || !StringUtil::CIEquals(function_name, "row")) {
-		return TransformExpression(root.source);
-	}
-
-	// Too many columns, e.g., (x, y) != (1, 2, 3).
-	int64_t value_count = func.args ? func.args->length : 0;
-	if (int64_t(root.ncolumns) < value_count || !func.args) {
-		throw ParserException("Could not perform assignment, expected %d values, got %d", root.ncolumns, value_count);
-	}
-
-	// Get the expression corresponding with the current column.
-	int64_t idx = 1;
-	auto list = func.args->head;
-	while (list && idx < int64_t(root.colno)) {
-		list = list->next;
-		++idx;
-	}
-
-	// Not enough columns, e.g., (x, y, z) != (1, 2).
-	if (!list) {
-		throw ParserException("Could not perform assignment, expected %d values, got %d", root.ncolumns,
-		                      func.args->length);
-	}
-
-	auto node = PGPointerCast<duckdb_libpgquery::PGNode>(list->data.ptr_value);
-	return TransformExpression(node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_operator.cpp b/src/duckdb/src/parser/transform/expression/transform_operator.cpp
deleted file mode 100644
index 46a2d6c09..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_operator.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-#include "duckdb/parser/expression/between_expression.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/parser/parser_options.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(std::move(child));
-
-	// built-in operator function
-	auto result = make_uniq<FunctionExpression>(op, std::move(children));
-	result->is_operator = true;
-	return std::move(result);
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
-                                                                  unique_ptr<ParsedExpression> right) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-
-	if (options.integer_division && op == "/") {
-		op = "//";
-	}
-	if (op == "~" || op == "!~") {
-		// rewrite 'asdf' SIMILAR TO '.*sd.*' into regexp_full_match('asdf', '.*sd.*')
-		bool invert_similar = op == "!~";
-
-		auto result = make_uniq<FunctionExpression>("regexp_full_match", std::move(children));
-		if (invert_similar) {
-			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(result));
-		} else {
-			return std::move(result);
-		}
-	} else {
-		auto target_type = OperatorToExpressionType(op);
-		if (target_type != ExpressionType::INVALID) {
-			// built-in comparison operator
-			return make_uniq<ComparisonExpression>(target_type, std::move(children[0]), std::move(children[1]));
-		}
-		// not a special operator: convert to a function expression
-		auto result = make_uniq<FunctionExpression>(std::move(op), std::move(children));
-		result->is_operator = true;
-		return std::move(result);
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformInExpression(const string &name, duckdb_libpgquery::PGAExpr &root) {
-	auto left_expr = TransformExpression(root.lexpr);
-	ExpressionType operator_type;
-	// this looks very odd, but seems to be the way to find out its NOT IN
-	if (name == "<>") {
-		// NOT IN
-		operator_type = ExpressionType::COMPARE_NOT_IN;
-	} else {
-		// IN
-		operator_type = ExpressionType::COMPARE_IN;
-	}
-
-	if (root.rexpr->type == duckdb_libpgquery::T_PGList) {
-		auto result = make_uniq<OperatorExpression>(operator_type, std::move(left_expr));
-		TransformExpressionList(*PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr), result->children);
-		return std::move(result);
-	}
-	auto expr = TransformExpression(*root.rexpr);
-
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(std::move(expr));
-	children.push_back(std::move(left_expr));
-	auto result = make_uniq_base<ParsedExpression, FunctionExpression>("contains", std::move(children));
-	if (operator_type == ExpressionType::COMPARE_NOT_IN) {
-		result = make_uniq_base<ParsedExpression, OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(result));
-	}
-	return result;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr &root) {
-	auto name = string(PGPointerCast<duckdb_libpgquery::PGValue>(root.name->head->data.ptr_value)->val.str);
-
-	switch (root.kind) {
-	case duckdb_libpgquery::PG_AEXPR_OP_ALL:
-	case duckdb_libpgquery::PG_AEXPR_OP_ANY: {
-		// left=ANY(right)
-		// we turn this into left=ANY((SELECT UNNEST(right)))
-		auto left_expr = TransformExpression(root.lexpr);
-		auto right_expr = TransformExpression(root.rexpr);
-
-		auto subquery_expr = make_uniq<SubqueryExpression>();
-		auto select_statement = make_uniq<SelectStatement>();
-		auto select_node = make_uniq<SelectNode>();
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(std::move(right_expr));
-
-		select_node->select_list.push_back(make_uniq<FunctionExpression>("UNNEST", std::move(children)));
-		select_node->from_table = make_uniq<EmptyTableRef>();
-		select_statement->node = std::move(select_node);
-		subquery_expr->subquery = std::move(select_statement);
-		subquery_expr->subquery_type = SubqueryType::ANY;
-		subquery_expr->child = std::move(left_expr);
-		subquery_expr->comparison_type = OperatorToExpressionType(name);
-		SetQueryLocation(*subquery_expr, root.location);
-		if (subquery_expr->comparison_type == ExpressionType::INVALID) {
-			throw ParserException("Unsupported comparison \"%s\" for ANY/ALL subquery", name);
-		}
-
-		if (root.kind == duckdb_libpgquery::PG_AEXPR_OP_ALL) {
-			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
-			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
-			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
-			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
-		}
-		return std::move(subquery_expr);
-	}
-	case duckdb_libpgquery::PG_AEXPR_IN: {
-		return TransformInExpression(name, root);
-	}
-	// rewrite NULLIF(a, b) into CASE WHEN a=b THEN NULL ELSE a END
-	case duckdb_libpgquery::PG_AEXPR_NULLIF: {
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(TransformExpression(root.lexpr));
-		children.push_back(TransformExpression(root.rexpr));
-		return make_uniq<FunctionExpression>("nullif", std::move(children));
-	}
-	// rewrite (NOT) X BETWEEN A AND B into (NOT) AND(GREATERTHANOREQUALTO(X,
-	// A), LESSTHANOREQUALTO(X, B))
-	case duckdb_libpgquery::PG_AEXPR_BETWEEN:
-	case duckdb_libpgquery::PG_AEXPR_NOT_BETWEEN: {
-		auto between_args = PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr);
-		if (between_args->length != 2 || !between_args->head->data.ptr_value || !between_args->tail->data.ptr_value) {
-			throw InternalException("(NOT) BETWEEN needs two args");
-		}
-
-		auto input = TransformExpression(root.lexpr);
-		auto between_left =
-		    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(between_args->head->data.ptr_value));
-		auto between_right =
-		    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(between_args->tail->data.ptr_value));
-
-		auto compare_between =
-		    make_uniq<BetweenExpression>(std::move(input), std::move(between_left), std::move(between_right));
-		if (root.kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
-			return std::move(compare_between);
-		} else {
-			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(compare_between));
-		}
-	}
-	// rewrite SIMILAR TO into regexp_full_match('asdf', '.*sd.*')
-	case duckdb_libpgquery::PG_AEXPR_SIMILAR: {
-		auto left_expr = TransformExpression(root.lexpr);
-		auto right_expr = TransformExpression(root.rexpr);
-
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(std::move(left_expr));
-
-		auto &similar_func = right_expr->Cast<FunctionExpression>();
-		D_ASSERT(similar_func.function_name == "similar_escape");
-		D_ASSERT(similar_func.children.size() == 2);
-		if (similar_func.children[1]->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
-			throw NotImplementedException("Custom escape in SIMILAR TO");
-		}
-		auto &constant = similar_func.children[1]->Cast<ConstantExpression>();
-		if (!constant.value.IsNull()) {
-			throw NotImplementedException("Custom escape in SIMILAR TO");
-		}
-		// take the child of the similar_func
-		children.push_back(std::move(similar_func.children[0]));
-
-		// this looks very odd, but seems to be the way to find out its NOT IN
-		bool invert_similar = false;
-		if (name == "!~") {
-			// NOT SIMILAR TO
-			invert_similar = true;
-		}
-		const auto regex_function = "regexp_full_match";
-		auto result = make_uniq<FunctionExpression>(regex_function, std::move(children));
-
-		if (invert_similar) {
-			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(result));
-		} else {
-			return std::move(result);
-		}
-	}
-	case duckdb_libpgquery::PG_AEXPR_NOT_DISTINCT: {
-		auto left_expr = TransformExpression(root.lexpr);
-		auto right_expr = TransformExpression(root.rexpr);
-		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, std::move(left_expr),
-		                                       std::move(right_expr));
-	}
-	case duckdb_libpgquery::PG_AEXPR_DISTINCT: {
-		auto left_expr = TransformExpression(root.lexpr);
-		auto right_expr = TransformExpression(root.rexpr);
-		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_DISTINCT_FROM, std::move(left_expr),
-		                                       std::move(right_expr));
-	}
-
-	default:
-		break;
-	}
-	auto left_expr = TransformExpression(root.lexpr);
-	auto right_expr = TransformExpression(root.rexpr);
-
-	if (!left_expr) {
-		// prefix operator
-		return TransformUnaryOperator(name, std::move(right_expr));
-	} else if (!right_expr) {
-		// postfix operator, only ! is currently supported
-		return TransformUnaryOperator(name + "__postfix", std::move(left_expr));
-	} else {
-		return TransformBinaryOperator(std::move(name), std::move(left_expr), std::move(right_expr));
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr &root) {
-	auto result = TransformAExprInternal(root);
-	if (result) {
-		SetQueryLocation(*result, root.location);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_param_ref.cpp b/src/duckdb/src/parser/transform/expression/transform_param_ref.cpp
deleted file mode 100644
index 2d4ba5155..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_param_ref.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/algorithm.hpp"
-
-namespace duckdb {
-
-namespace {
-
-struct PreparedParam {
-	PreparedParamType type;
-	string identifier;
-};
-
-} // namespace
-
-static PreparedParam GetParameterIdentifier(duckdb_libpgquery::PGParamRef &node) {
-	PreparedParam param;
-	if (node.name) {
-		param.type = PreparedParamType::NAMED;
-		param.identifier = node.name;
-		return param;
-	}
-	if (node.number < 0) {
-		throw ParserException("Parameter numbers cannot be negative");
-	}
-	param.identifier = StringUtil::Format("%d", node.number);
-	param.type = node.number == 0 ? PreparedParamType::AUTO_INCREMENT : PreparedParamType::POSITIONAL;
-	return param;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
-	auto expr = make_uniq<ParameterExpression>();
-
-	auto param = GetParameterIdentifier(node);
-	idx_t known_param_index = DConstants::INVALID_INDEX;
-	// This is a named parameter, try to find an entry for it
-	GetParam(param.identifier, known_param_index, param.type);
-
-	if (known_param_index == DConstants::INVALID_INDEX) {
-		// We have not seen this parameter before
-		if (node.number != 0) {
-			// Preserve the parameter number
-			known_param_index = NumericCast<idx_t>(node.number);
-		} else {
-			known_param_index = ParamCount() + 1;
-			if (!node.name) {
-				param.identifier = StringUtil::Format("%d", known_param_index);
-			}
-		}
-
-		if (!named_param_map.count(param.identifier)) {
-			// Add it to the named parameter map so we can find it next time it's referenced
-			SetParam(param.identifier, known_param_index, param.type);
-		}
-	}
-
-	expr->identifier = param.identifier;
-	idx_t new_param_count = MaxValue<idx_t>(ParamCount(), known_param_index);
-	SetParamCount(new_param_count);
-	return std::move(expr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_positional_reference.cpp b/src/duckdb/src/parser/transform/expression/transform_positional_reference.cpp
deleted file mode 100644
index 8d672948d..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_positional_reference.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference &node) {
-	if (node.position <= 0) {
-		throw ParserException("Positional reference node needs to be >= 1");
-	}
-	auto result = make_uniq<PositionalReferenceExpression>(NumericCast<idx_t>(node.position));
-	SetQueryLocation(*result, node.location);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/expression/transform_subquery.cpp b/src/duckdb/src/parser/transform/expression/transform_subquery.cpp
deleted file mode 100644
index 6f6d74207..000000000
--- a/src/duckdb/src/parser/transform/expression/transform_subquery.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/parser/expression/list.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-namespace duckdb {
-
-void RemoveOrderQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
-	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &col_ref = expr->Cast<ColumnRefExpression>();
-		auto &col_names = col_ref.column_names;
-		if (col_names.size() > 1) {
-			col_names = vector<string> {col_names.back()};
-		}
-	} else {
-		ParsedExpressionIterator::EnumerateChildren(
-		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveOrderQualificationRecursive(child); });
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink &root) {
-	auto subquery_expr = make_uniq<SubqueryExpression>();
-
-	subquery_expr->subquery = TransformSelectStmt(*root.subselect);
-	SetQueryLocation(*subquery_expr, root.location);
-	D_ASSERT(subquery_expr->subquery);
-	D_ASSERT(!subquery_expr->subquery->node->GetSelectList().empty());
-
-	switch (root.subLinkType) {
-	case duckdb_libpgquery::PG_EXISTS_SUBLINK: {
-		subquery_expr->subquery_type = SubqueryType::EXISTS;
-		break;
-	}
-	case duckdb_libpgquery::PG_ANY_SUBLINK:
-	case duckdb_libpgquery::PG_ALL_SUBLINK: {
-		// comparison with ANY() or ALL()
-		subquery_expr->subquery_type = SubqueryType::ANY;
-		subquery_expr->child = TransformExpression(root.testexpr);
-		// get the operator name
-		if (!root.operName) {
-			// simple IN
-			subquery_expr->comparison_type = ExpressionType::COMPARE_EQUAL;
-		} else {
-			auto operator_name =
-			    string((PGPointerCast<duckdb_libpgquery::PGValue>(root.operName->head->data.ptr_value))->val.str);
-			subquery_expr->comparison_type = OperatorToExpressionType(operator_name);
-		}
-		if (subquery_expr->comparison_type != ExpressionType::COMPARE_EQUAL &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_NOTEQUAL &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_GREATERTHAN &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHAN &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHANOREQUALTO) {
-			throw ParserException("ANY and ALL operators require one of =,<>,>,<,>=,<= comparisons!");
-		}
-		if (root.subLinkType == duckdb_libpgquery::PG_ALL_SUBLINK) {
-			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
-			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
-			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
-			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
-		}
-		break;
-	}
-	case duckdb_libpgquery::PG_EXPR_SUBLINK: {
-		// return a single scalar value from the subquery
-		// no child expression to compare to
-		subquery_expr->subquery_type = SubqueryType::SCALAR;
-		break;
-	}
-	case duckdb_libpgquery::PG_ARRAY_SUBLINK: {
-		// ARRAY expression
-		// wrap subquery into
-		// "SELECT CASE WHEN ARRAY_AGG(col) IS NULL THEN [] ELSE ARRAY_AGG(col) END FROM (...) tbl"
-		auto select_node = make_uniq<SelectNode>();
-
-		unique_ptr<ParsedExpression> array_agg_child;
-		optional_ptr<SelectNode> sub_select;
-		if (subquery_expr->subquery->node->type == QueryNodeType::SELECT_NODE) {
-			// easy case - subquery is a SELECT
-			sub_select = subquery_expr->subquery->node->Cast<SelectNode>();
-			if (sub_select->select_list.size() != 1) {
-				throw BinderException(*subquery_expr, "Subquery returns %zu columns - expected 1",
-				                      sub_select->select_list.size());
-			}
-			array_agg_child = make_uniq<PositionalReferenceExpression>(1ULL);
-		} else {
-			// subquery is not a SELECT but a UNION or CTE
-			// we can still support this but it is more challenging since we can't push columns for the ORDER BY
-			auto columns_star = make_uniq<StarExpression>();
-			columns_star->columns = true;
-			array_agg_child = std::move(columns_star);
-		}
-
-		// ARRAY_AGG(COLUMNS(*))
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(std::move(array_agg_child));
-		auto aggr = make_uniq<FunctionExpression>("array_agg", std::move(children));
-		// push ORDER BY modifiers into the array_agg
-		for (auto &modifier : subquery_expr->subquery->node->modifiers) {
-			if (modifier->type == ResultModifierType::ORDER_MODIFIER) {
-				aggr->order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(modifier->Copy());
-				break;
-			}
-		}
-		// transform constants (e.g. ORDER BY 1) into positional references (ORDER BY #1)
-		if (aggr->order_bys) {
-			for (auto &order : aggr->order_bys->orders) {
-				if (order.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-					auto &constant_expr = order.expression->Cast<ConstantExpression>();
-					Value bigint_value;
-					string error;
-					if (constant_expr.value.DefaultTryCastAs(LogicalType::BIGINT, bigint_value, &error)) {
-						int64_t order_index = BigIntValue::Get(bigint_value);
-						idx_t positional_index = order_index < 0 ? NumericLimits<idx_t>::Maximum() : idx_t(order_index);
-						order.expression = make_uniq<PositionalReferenceExpression>(positional_index);
-					}
-				} else if (sub_select) {
-					// if we have a SELECT we can push the ORDER BY clause into the SELECT list and reference it
-					sub_select->select_list.push_back(std::move(order.expression));
-					order.expression = make_uniq<PositionalReferenceExpression>(sub_select->select_list.size() - 1);
-				} else {
-					// otherwise we remove order qualifications
-					RemoveOrderQualificationRecursive(order.expression);
-				}
-			}
-		}
-		// ARRAY_AGG(COLUMNS(*)) IS NULL
-		auto agg_is_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NULL, aggr->Copy());
-		// empty list
-		vector<unique_ptr<ParsedExpression>> list_children;
-		auto empty_list = make_uniq<FunctionExpression>("list_value", std::move(list_children));
-		// CASE
-		auto case_expr = make_uniq<CaseExpression>();
-		CaseCheck check;
-		check.when_expr = std::move(agg_is_null);
-		check.then_expr = std::move(empty_list);
-		case_expr->case_checks.push_back(std::move(check));
-		case_expr->else_expr = std::move(aggr);
-
-		select_node->select_list.push_back(std::move(case_expr));
-
-		// FROM (...) tbl
-		auto child_subquery = make_uniq<SubqueryRef>(std::move(subquery_expr->subquery));
-		select_node->from_table = std::move(child_subquery);
-
-		auto new_subquery = make_uniq<SelectStatement>();
-		new_subquery->node = std::move(select_node);
-		subquery_expr->subquery = std::move(new_subquery);
-
-		subquery_expr->subquery_type = SubqueryType::SCALAR;
-		break;
-	}
-	default:
-		throw NotImplementedException("Subquery of type %d not implemented\n", (int)root.subLinkType);
-	}
-	return std::move(subquery_expr);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp b/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp
deleted file mode 100644
index ed9e2e37f..000000000
--- a/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp
+++ /dev/null
@@ -1,828 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { // LCOV_EXCL_START
-	switch (type) {
-	case duckdb_libpgquery::T_PGInvalid:
-		return "T_Invalid";
-	case duckdb_libpgquery::T_PGIndexInfo:
-		return "T_IndexInfo";
-	case duckdb_libpgquery::T_PGExprContext:
-		return "T_ExprContext";
-	case duckdb_libpgquery::T_PGProjectionInfo:
-		return "T_ProjectionInfo";
-	case duckdb_libpgquery::T_PGJunkFilter:
-		return "T_JunkFilter";
-	case duckdb_libpgquery::T_PGResultRelInfo:
-		return "T_ResultRelInfo";
-	case duckdb_libpgquery::T_PGEState:
-		return "T_EState";
-	case duckdb_libpgquery::T_PGTupleTableSlot:
-		return "T_TupleTableSlot";
-	case duckdb_libpgquery::T_PGPlan:
-		return "T_Plan";
-	case duckdb_libpgquery::T_PGResult:
-		return "T_Result";
-	case duckdb_libpgquery::T_PGProjectSet:
-		return "T_ProjectSet";
-	case duckdb_libpgquery::T_PGModifyTable:
-		return "T_ModifyTable";
-	case duckdb_libpgquery::T_PGAppend:
-		return "T_Append";
-	case duckdb_libpgquery::T_PGMergeAppend:
-		return "T_MergeAppend";
-	case duckdb_libpgquery::T_PGRecursiveUnion:
-		return "T_RecursiveUnion";
-	case duckdb_libpgquery::T_PGBitmapAnd:
-		return "T_BitmapAnd";
-	case duckdb_libpgquery::T_PGBitmapOr:
-		return "T_BitmapOr";
-	case duckdb_libpgquery::T_PGScan:
-		return "T_Scan";
-	case duckdb_libpgquery::T_PGSeqScan:
-		return "T_SeqScan";
-	case duckdb_libpgquery::T_PGSampleScan:
-		return "T_SampleScan";
-	case duckdb_libpgquery::T_PGIndexScan:
-		return "T_IndexScan";
-	case duckdb_libpgquery::T_PGIndexOnlyScan:
-		return "T_IndexOnlyScan";
-	case duckdb_libpgquery::T_PGBitmapIndexScan:
-		return "T_BitmapIndexScan";
-	case duckdb_libpgquery::T_PGBitmapHeapScan:
-		return "T_BitmapHeapScan";
-	case duckdb_libpgquery::T_PGTidScan:
-		return "T_TidScan";
-	case duckdb_libpgquery::T_PGSubqueryScan:
-		return "T_SubqueryScan";
-	case duckdb_libpgquery::T_PGFunctionScan:
-		return "T_FunctionScan";
-	case duckdb_libpgquery::T_PGValuesScan:
-		return "T_ValuesScan";
-	case duckdb_libpgquery::T_PGTableFuncScan:
-		return "T_TableFuncScan";
-	case duckdb_libpgquery::T_PGCteScan:
-		return "T_CteScan";
-	case duckdb_libpgquery::T_PGNamedTuplestoreScan:
-		return "T_NamedTuplestoreScan";
-	case duckdb_libpgquery::T_PGWorkTableScan:
-		return "T_WorkTableScan";
-	case duckdb_libpgquery::T_PGForeignScan:
-		return "T_ForeignScan";
-	case duckdb_libpgquery::T_PGCustomScan:
-		return "T_CustomScan";
-	case duckdb_libpgquery::T_PGJoin:
-		return "T_Join";
-	case duckdb_libpgquery::T_PGNestLoop:
-		return "T_NestLoop";
-	case duckdb_libpgquery::T_PGMergeJoin:
-		return "T_MergeJoin";
-	case duckdb_libpgquery::T_PGHashJoin:
-		return "T_HashJoin";
-	case duckdb_libpgquery::T_PGMaterial:
-		return "T_Material";
-	case duckdb_libpgquery::T_PGSort:
-		return "T_Sort";
-	case duckdb_libpgquery::T_PGGroup:
-		return "T_Group";
-	case duckdb_libpgquery::T_PGAgg:
-		return "T_Agg";
-	case duckdb_libpgquery::T_PGWindowAgg:
-		return "T_WindowAgg";
-	case duckdb_libpgquery::T_PGUnique:
-		return "T_Unique";
-	case duckdb_libpgquery::T_PGGather:
-		return "T_Gather";
-	case duckdb_libpgquery::T_PGGatherMerge:
-		return "T_GatherMerge";
-	case duckdb_libpgquery::T_PGHash:
-		return "T_Hash";
-	case duckdb_libpgquery::T_PGSetOp:
-		return "T_SetOp";
-	case duckdb_libpgquery::T_PGLockRows:
-		return "T_LockRows";
-	case duckdb_libpgquery::T_PGLimit:
-		return "T_Limit";
-	case duckdb_libpgquery::T_PGNestLoopParam:
-		return "T_NestLoopParam";
-	case duckdb_libpgquery::T_PGPlanRowMark:
-		return "T_PlanRowMark";
-	case duckdb_libpgquery::T_PGPlanInvalItem:
-		return "T_PlanInvalItem";
-	case duckdb_libpgquery::T_PGPlanState:
-		return "T_PlanState";
-	case duckdb_libpgquery::T_PGResultState:
-		return "T_ResultState";
-	case duckdb_libpgquery::T_PGProjectSetState:
-		return "T_ProjectSetState";
-	case duckdb_libpgquery::T_PGModifyTableState:
-		return "T_ModifyTableState";
-	case duckdb_libpgquery::T_PGAppendState:
-		return "T_AppendState";
-	case duckdb_libpgquery::T_PGMergeAppendState:
-		return "T_MergeAppendState";
-	case duckdb_libpgquery::T_PGRecursiveUnionState:
-		return "T_RecursiveUnionState";
-	case duckdb_libpgquery::T_PGBitmapAndState:
-		return "T_BitmapAndState";
-	case duckdb_libpgquery::T_PGBitmapOrState:
-		return "T_BitmapOrState";
-	case duckdb_libpgquery::T_PGScanState:
-		return "T_ScanState";
-	case duckdb_libpgquery::T_PGSeqScanState:
-		return "T_SeqScanState";
-	case duckdb_libpgquery::T_PGSampleScanState:
-		return "T_SampleScanState";
-	case duckdb_libpgquery::T_PGIndexScanState:
-		return "T_IndexScanState";
-	case duckdb_libpgquery::T_PGIndexOnlyScanState:
-		return "T_IndexOnlyScanState";
-	case duckdb_libpgquery::T_PGBitmapIndexScanState:
-		return "T_BitmapIndexScanState";
-	case duckdb_libpgquery::T_PGBitmapHeapScanState:
-		return "T_BitmapHeapScanState";
-	case duckdb_libpgquery::T_PGTidScanState:
-		return "T_TidScanState";
-	case duckdb_libpgquery::T_PGSubqueryScanState:
-		return "T_SubqueryScanState";
-	case duckdb_libpgquery::T_PGFunctionScanState:
-		return "T_FunctionScanState";
-	case duckdb_libpgquery::T_PGTableFuncScanState:
-		return "T_TableFuncScanState";
-	case duckdb_libpgquery::T_PGValuesScanState:
-		return "T_ValuesScanState";
-	case duckdb_libpgquery::T_PGCteScanState:
-		return "T_CteScanState";
-	case duckdb_libpgquery::T_PGNamedTuplestoreScanState:
-		return "T_NamedTuplestoreScanState";
-	case duckdb_libpgquery::T_PGWorkTableScanState:
-		return "T_WorkTableScanState";
-	case duckdb_libpgquery::T_PGForeignScanState:
-		return "T_ForeignScanState";
-	case duckdb_libpgquery::T_PGCustomScanState:
-		return "T_CustomScanState";
-	case duckdb_libpgquery::T_PGJoinState:
-		return "T_JoinState";
-	case duckdb_libpgquery::T_PGNestLoopState:
-		return "T_NestLoopState";
-	case duckdb_libpgquery::T_PGMergeJoinState:
-		return "T_MergeJoinState";
-	case duckdb_libpgquery::T_PGHashJoinState:
-		return "T_HashJoinState";
-	case duckdb_libpgquery::T_PGMaterialState:
-		return "T_MaterialState";
-	case duckdb_libpgquery::T_PGSortState:
-		return "T_SortState";
-	case duckdb_libpgquery::T_PGGroupState:
-		return "T_GroupState";
-	case duckdb_libpgquery::T_PGAggState:
-		return "T_AggState";
-	case duckdb_libpgquery::T_PGWindowAggState:
-		return "T_WindowAggState";
-	case duckdb_libpgquery::T_PGUniqueState:
-		return "T_UniqueState";
-	case duckdb_libpgquery::T_PGGatherState:
-		return "T_GatherState";
-	case duckdb_libpgquery::T_PGGatherMergeState:
-		return "T_GatherMergeState";
-	case duckdb_libpgquery::T_PGHashState:
-		return "T_HashState";
-	case duckdb_libpgquery::T_PGSetOpState:
-		return "T_SetOpState";
-	case duckdb_libpgquery::T_PGLockRowsState:
-		return "T_LockRowsState";
-	case duckdb_libpgquery::T_PGLimitState:
-		return "T_LimitState";
-	case duckdb_libpgquery::T_PGAlias:
-		return "T_Alias";
-	case duckdb_libpgquery::T_PGRangeVar:
-		return "T_RangeVar";
-	case duckdb_libpgquery::T_PGTableFunc:
-		return "T_TableFunc";
-	case duckdb_libpgquery::T_PGExpr:
-		return "T_Expr";
-	case duckdb_libpgquery::T_PGVar:
-		return "T_Var";
-	case duckdb_libpgquery::T_PGConst:
-		return "T_Const";
-	case duckdb_libpgquery::T_PGParam:
-		return "T_Param";
-	case duckdb_libpgquery::T_PGAggref:
-		return "T_Aggref";
-	case duckdb_libpgquery::T_PGGroupingFunc:
-		return "T_GroupingFunc";
-	case duckdb_libpgquery::T_PGWindowFunc:
-		return "T_WindowFunc";
-	case duckdb_libpgquery::T_PGArrayRef:
-		return "T_ArrayRef";
-	case duckdb_libpgquery::T_PGFuncExpr:
-		return "T_FuncExpr";
-	case duckdb_libpgquery::T_PGNamedArgExpr:
-		return "T_NamedArgExpr";
-	case duckdb_libpgquery::T_PGOpExpr:
-		return "T_OpExpr";
-	case duckdb_libpgquery::T_PGDistinctExpr:
-		return "T_DistinctExpr";
-	case duckdb_libpgquery::T_PGNullIfExpr:
-		return "T_NullIfExpr";
-	case duckdb_libpgquery::T_PGScalarArrayOpExpr:
-		return "T_ScalarArrayOpExpr";
-	case duckdb_libpgquery::T_PGBoolExpr:
-		return "T_BoolExpr";
-	case duckdb_libpgquery::T_PGSubLink:
-		return "T_SubLink";
-	case duckdb_libpgquery::T_PGSubPlan:
-		return "T_SubPlan";
-	case duckdb_libpgquery::T_PGAlternativeSubPlan:
-		return "T_AlternativeSubPlan";
-	case duckdb_libpgquery::T_PGFieldSelect:
-		return "T_FieldSelect";
-	case duckdb_libpgquery::T_PGFieldStore:
-		return "T_FieldStore";
-	case duckdb_libpgquery::T_PGRelabelType:
-		return "T_RelabelType";
-	case duckdb_libpgquery::T_PGCoerceViaIO:
-		return "T_CoerceViaIO";
-	case duckdb_libpgquery::T_PGArrayCoerceExpr:
-		return "T_ArrayCoerceExpr";
-	case duckdb_libpgquery::T_PGConvertRowtypeExpr:
-		return "T_ConvertRowtypeExpr";
-	case duckdb_libpgquery::T_PGCollateExpr:
-		return "T_CollateExpr";
-	case duckdb_libpgquery::T_PGCaseExpr:
-		return "T_CaseExpr";
-	case duckdb_libpgquery::T_PGCaseWhen:
-		return "T_CaseWhen";
-	case duckdb_libpgquery::T_PGCaseTestExpr:
-		return "T_CaseTestExpr";
-	case duckdb_libpgquery::T_PGArrayExpr:
-		return "T_ArrayExpr";
-	case duckdb_libpgquery::T_PGRowExpr:
-		return "T_RowExpr";
-	case duckdb_libpgquery::T_PGRowCompareExpr:
-		return "T_RowCompareExpr";
-	case duckdb_libpgquery::T_PGCoalesceExpr:
-		return "T_CoalesceExpr";
-	case duckdb_libpgquery::T_PGMinMaxExpr:
-		return "T_MinMaxExpr";
-	case duckdb_libpgquery::T_PGSQLValueFunction:
-		return "T_SQLValueFunction";
-	case duckdb_libpgquery::T_PGXmlExpr:
-		return "T_XmlExpr";
-	case duckdb_libpgquery::T_PGNullTest:
-		return "T_NullTest";
-	case duckdb_libpgquery::T_PGBooleanTest:
-		return "T_BooleanTest";
-	case duckdb_libpgquery::T_PGCoerceToDomain:
-		return "T_CoerceToDomain";
-	case duckdb_libpgquery::T_PGCoerceToDomainValue:
-		return "T_CoerceToDomainValue";
-	case duckdb_libpgquery::T_PGSetToDefault:
-		return "T_SetToDefault";
-	case duckdb_libpgquery::T_PGCurrentOfExpr:
-		return "T_CurrentOfExpr";
-	case duckdb_libpgquery::T_PGNextValueExpr:
-		return "T_NextValueExpr";
-	case duckdb_libpgquery::T_PGInferenceElem:
-		return "T_InferenceElem";
-	case duckdb_libpgquery::T_PGTargetEntry:
-		return "T_TargetEntry";
-	case duckdb_libpgquery::T_PGRangeTblRef:
-		return "T_RangeTblRef";
-	case duckdb_libpgquery::T_PGJoinExpr:
-		return "T_JoinExpr";
-	case duckdb_libpgquery::T_PGFromExpr:
-		return "T_FromExpr";
-	case duckdb_libpgquery::T_PGOnConflictExpr:
-		return "T_OnConflictExpr";
-	case duckdb_libpgquery::T_PGIntoClause:
-		return "T_IntoClause";
-	case duckdb_libpgquery::T_PGExprState:
-		return "T_ExprState";
-	case duckdb_libpgquery::T_PGAggrefExprState:
-		return "T_AggrefExprState";
-	case duckdb_libpgquery::T_PGWindowFuncExprState:
-		return "T_WindowFuncExprState";
-	case duckdb_libpgquery::T_PGSetExprState:
-		return "T_SetExprState";
-	case duckdb_libpgquery::T_PGSubPlanState:
-		return "T_SubPlanState";
-	case duckdb_libpgquery::T_PGAlternativeSubPlanState:
-		return "T_AlternativeSubPlanState";
-	case duckdb_libpgquery::T_PGDomainConstraintState:
-		return "T_DomainConstraintState";
-	case duckdb_libpgquery::T_PGPlannerInfo:
-		return "T_PlannerInfo";
-	case duckdb_libpgquery::T_PGPlannerGlobal:
-		return "T_PlannerGlobal";
-	case duckdb_libpgquery::T_PGRelOptInfo:
-		return "T_RelOptInfo";
-	case duckdb_libpgquery::T_PGIndexOptInfo:
-		return "T_IndexOptInfo";
-	case duckdb_libpgquery::T_PGForeignKeyOptInfo:
-		return "T_ForeignKeyOptInfo";
-	case duckdb_libpgquery::T_PGParamPathInfo:
-		return "T_ParamPathInfo";
-	case duckdb_libpgquery::T_PGPath:
-		return "T_Path";
-	case duckdb_libpgquery::T_PGIndexPath:
-		return "T_IndexPath";
-	case duckdb_libpgquery::T_PGBitmapHeapPath:
-		return "T_BitmapHeapPath";
-	case duckdb_libpgquery::T_PGBitmapAndPath:
-		return "T_BitmapAndPath";
-	case duckdb_libpgquery::T_PGBitmapOrPath:
-		return "T_BitmapOrPath";
-	case duckdb_libpgquery::T_PGTidPath:
-		return "T_TidPath";
-	case duckdb_libpgquery::T_PGSubqueryScanPath:
-		return "T_SubqueryScanPath";
-	case duckdb_libpgquery::T_PGForeignPath:
-		return "T_ForeignPath";
-	case duckdb_libpgquery::T_PGCustomPath:
-		return "T_CustomPath";
-	case duckdb_libpgquery::T_PGNestPath:
-		return "T_NestPath";
-	case duckdb_libpgquery::T_PGMergePath:
-		return "T_MergePath";
-	case duckdb_libpgquery::T_PGHashPath:
-		return "T_HashPath";
-	case duckdb_libpgquery::T_PGAppendPath:
-		return "T_AppendPath";
-	case duckdb_libpgquery::T_PGMergeAppendPath:
-		return "T_MergeAppendPath";
-	case duckdb_libpgquery::T_PGResultPath:
-		return "T_ResultPath";
-	case duckdb_libpgquery::T_PGMaterialPath:
-		return "T_MaterialPath";
-	case duckdb_libpgquery::T_PGUniquePath:
-		return "T_UniquePath";
-	case duckdb_libpgquery::T_PGGatherPath:
-		return "T_GatherPath";
-	case duckdb_libpgquery::T_PGGatherMergePath:
-		return "T_GatherMergePath";
-	case duckdb_libpgquery::T_PGProjectionPath:
-		return "T_ProjectionPath";
-	case duckdb_libpgquery::T_PGProjectSetPath:
-		return "T_ProjectSetPath";
-	case duckdb_libpgquery::T_PGSortPath:
-		return "T_SortPath";
-	case duckdb_libpgquery::T_PGGroupPath:
-		return "T_GroupPath";
-	case duckdb_libpgquery::T_PGUpperUniquePath:
-		return "T_UpperUniquePath";
-	case duckdb_libpgquery::T_PGAggPath:
-		return "T_AggPath";
-	case duckdb_libpgquery::T_PGGroupingSetsPath:
-		return "T_GroupingSetsPath";
-	case duckdb_libpgquery::T_PGMinMaxAggPath:
-		return "T_MinMaxAggPath";
-	case duckdb_libpgquery::T_PGWindowAggPath:
-		return "T_WindowAggPath";
-	case duckdb_libpgquery::T_PGSetOpPath:
-		return "T_SetOpPath";
-	case duckdb_libpgquery::T_PGRecursiveUnionPath:
-		return "T_RecursiveUnionPath";
-	case duckdb_libpgquery::T_PGLockRowsPath:
-		return "T_LockRowsPath";
-	case duckdb_libpgquery::T_PGModifyTablePath:
-		return "T_ModifyTablePath";
-	case duckdb_libpgquery::T_PGLimitPath:
-		return "T_LimitPath";
-	case duckdb_libpgquery::T_PGEquivalenceClass:
-		return "T_EquivalenceClass";
-	case duckdb_libpgquery::T_PGEquivalenceMember:
-		return "T_EquivalenceMember";
-	case duckdb_libpgquery::T_PGPathKey:
-		return "T_PathKey";
-	case duckdb_libpgquery::T_PGPathTarget:
-		return "T_PathTarget";
-	case duckdb_libpgquery::T_PGRestrictInfo:
-		return "T_RestrictInfo";
-	case duckdb_libpgquery::T_PGPlaceHolderVar:
-		return "T_PlaceHolderVar";
-	case duckdb_libpgquery::T_PGSpecialJoinInfo:
-		return "T_SpecialJoinInfo";
-	case duckdb_libpgquery::T_PGAppendRelInfo:
-		return "T_AppendRelInfo";
-	case duckdb_libpgquery::T_PGPartitionedChildRelInfo:
-		return "T_PartitionedChildRelInfo";
-	case duckdb_libpgquery::T_PGPlaceHolderInfo:
-		return "T_PlaceHolderInfo";
-	case duckdb_libpgquery::T_PGMinMaxAggInfo:
-		return "T_MinMaxAggInfo";
-	case duckdb_libpgquery::T_PGPlannerParamItem:
-		return "T_PlannerParamItem";
-	case duckdb_libpgquery::T_PGRollupData:
-		return "T_RollupData";
-	case duckdb_libpgquery::T_PGGroupingSetData:
-		return "T_GroupingSetData";
-	case duckdb_libpgquery::T_PGStatisticExtInfo:
-		return "T_StatisticExtInfo";
-	case duckdb_libpgquery::T_PGMemoryContext:
-		return "T_MemoryContext";
-	case duckdb_libpgquery::T_PGAllocSetContext:
-		return "T_AllocSetContext";
-	case duckdb_libpgquery::T_PGSlabContext:
-		return "T_SlabContext";
-	case duckdb_libpgquery::T_PGValue:
-		return "T_Value";
-	case duckdb_libpgquery::T_PGInteger:
-		return "T_Integer";
-	case duckdb_libpgquery::T_PGFloat:
-		return "T_Float";
-	case duckdb_libpgquery::T_PGString:
-		return "T_String";
-	case duckdb_libpgquery::T_PGBitString:
-		return "T_BitString";
-	case duckdb_libpgquery::T_PGNull:
-		return "T_Null";
-	case duckdb_libpgquery::T_PGList:
-		return "T_List";
-	case duckdb_libpgquery::T_PGIntList:
-		return "T_IntList";
-	case duckdb_libpgquery::T_PGOidList:
-		return "T_OidList";
-	case duckdb_libpgquery::T_PGExtensibleNode:
-		return "T_ExtensibleNode";
-	case duckdb_libpgquery::T_PGRawStmt:
-		return "T_RawStmt";
-	case duckdb_libpgquery::T_PGQuery:
-		return "T_Query";
-	case duckdb_libpgquery::T_PGPlannedStmt:
-		return "T_PlannedStmt";
-	case duckdb_libpgquery::T_PGInsertStmt:
-		return "T_InsertStmt";
-	case duckdb_libpgquery::T_PGDeleteStmt:
-		return "T_DeleteStmt";
-	case duckdb_libpgquery::T_PGUpdateStmt:
-		return "T_UpdateStmt";
-	case duckdb_libpgquery::T_PGUpdateExtensionsStmt:
-		return "T_UpdateExtensionsStmt";
-	case duckdb_libpgquery::T_PGSelectStmt:
-		return "T_SelectStmt";
-	case duckdb_libpgquery::T_PGAlterTableStmt:
-		return "T_AlterTableStmt";
-	case duckdb_libpgquery::T_PGAlterTableCmd:
-		return "T_AlterTableCmd";
-	case duckdb_libpgquery::T_PGAlterDomainStmt:
-		return "T_AlterDomainStmt";
-	case duckdb_libpgquery::T_PGSetOperationStmt:
-		return "T_SetOperationStmt";
-	case duckdb_libpgquery::T_PGGrantStmt:
-		return "T_GrantStmt";
-	case duckdb_libpgquery::T_PGGrantRoleStmt:
-		return "T_GrantRoleStmt";
-	case duckdb_libpgquery::T_PGAlterDefaultPrivilegesStmt:
-		return "T_AlterDefaultPrivilegesStmt";
-	case duckdb_libpgquery::T_PGClosePortalStmt:
-		return "T_ClosePortalStmt";
-	case duckdb_libpgquery::T_PGClusterStmt:
-		return "T_ClusterStmt";
-	case duckdb_libpgquery::T_PGCommentOnStmt:
-		return "T_CommentOnStmt";
-	case duckdb_libpgquery::T_PGCopyStmt:
-		return "T_CopyStmt";
-	case duckdb_libpgquery::T_PGCreateStmt:
-		return "T_CreateStmt";
-	case duckdb_libpgquery::T_PGDefineStmt:
-		return "T_DefineStmt";
-	case duckdb_libpgquery::T_PGDropStmt:
-		return "T_DropStmt";
-	case duckdb_libpgquery::T_PGTruncateStmt:
-		return "T_TruncateStmt";
-	case duckdb_libpgquery::T_PGCommentStmt:
-		return "T_CommentStmt";
-	case duckdb_libpgquery::T_PGFetchStmt:
-		return "T_FetchStmt";
-	case duckdb_libpgquery::T_PGIndexStmt:
-		return "T_IndexStmt";
-	case duckdb_libpgquery::T_PGCreateFunctionStmt:
-		return "T_CreateFunctionStmt";
-	case duckdb_libpgquery::T_PGAlterFunctionStmt:
-		return "T_AlterFunctionStmt";
-	case duckdb_libpgquery::T_PGDoStmt:
-		return "T_DoStmt";
-	case duckdb_libpgquery::T_PGRenameStmt:
-		return "T_RenameStmt";
-	case duckdb_libpgquery::T_PGRuleStmt:
-		return "T_RuleStmt";
-	case duckdb_libpgquery::T_PGNotifyStmt:
-		return "T_NotifyStmt";
-	case duckdb_libpgquery::T_PGListenStmt:
-		return "T_ListenStmt";
-	case duckdb_libpgquery::T_PGUnlistenStmt:
-		return "T_UnlistenStmt";
-	case duckdb_libpgquery::T_PGTransactionStmt:
-		return "T_TransactionStmt";
-	case duckdb_libpgquery::T_PGViewStmt:
-		return "T_ViewStmt";
-	case duckdb_libpgquery::T_PGLoadStmt:
-		return "T_LoadStmt";
-	case duckdb_libpgquery::T_PGCreateDomainStmt:
-		return "T_CreateDomainStmt";
-	case duckdb_libpgquery::T_PGCreatedbStmt:
-		return "T_CreatedbStmt";
-	case duckdb_libpgquery::T_PGDropdbStmt:
-		return "T_DropdbStmt";
-	case duckdb_libpgquery::T_PGVacuumStmt:
-		return "T_VacuumStmt";
-	case duckdb_libpgquery::T_PGExplainStmt:
-		return "T_ExplainStmt";
-	case duckdb_libpgquery::T_PGCreateTableAsStmt:
-		return "T_CreateTableAsStmt";
-	case duckdb_libpgquery::T_PGCreateSeqStmt:
-		return "T_CreateSeqStmt";
-	case duckdb_libpgquery::T_PGAlterSeqStmt:
-		return "T_AlterSeqStmt";
-	case duckdb_libpgquery::T_PGVariableSetStmt:
-		return "T_VariableSetStmt";
-	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return "T_VariableShowStmt";
-	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return "T_VariableShowSelectStmt";
-	case duckdb_libpgquery::T_PGDiscardStmt:
-		return "T_DiscardStmt";
-	case duckdb_libpgquery::T_PGCreateTrigStmt:
-		return "T_CreateTrigStmt";
-	case duckdb_libpgquery::T_PGCreatePLangStmt:
-		return "T_CreatePLangStmt";
-	case duckdb_libpgquery::T_PGCreateRoleStmt:
-		return "T_CreateRoleStmt";
-	case duckdb_libpgquery::T_PGAlterRoleStmt:
-		return "T_AlterRoleStmt";
-	case duckdb_libpgquery::T_PGDropRoleStmt:
-		return "T_DropRoleStmt";
-	case duckdb_libpgquery::T_PGLockStmt:
-		return "T_LockStmt";
-	case duckdb_libpgquery::T_PGConstraintsSetStmt:
-		return "T_ConstraintsSetStmt";
-	case duckdb_libpgquery::T_PGReindexStmt:
-		return "T_ReindexStmt";
-	case duckdb_libpgquery::T_PGCheckPointStmt:
-		return "T_CheckPointStmt";
-	case duckdb_libpgquery::T_PGCreateSchemaStmt:
-		return "T_CreateSchemaStmt";
-	case duckdb_libpgquery::T_PGAlterDatabaseStmt:
-		return "T_AlterDatabaseStmt";
-	case duckdb_libpgquery::T_PGAlterDatabaseSetStmt:
-		return "T_AlterDatabaseSetStmt";
-	case duckdb_libpgquery::T_PGAlterRoleSetStmt:
-		return "T_AlterRoleSetStmt";
-	case duckdb_libpgquery::T_PGCreateConversionStmt:
-		return "T_CreateConversionStmt";
-	case duckdb_libpgquery::T_PGCreateCastStmt:
-		return "T_CreateCastStmt";
-	case duckdb_libpgquery::T_PGCreateOpClassStmt:
-		return "T_CreateOpClassStmt";
-	case duckdb_libpgquery::T_PGCreateOpFamilyStmt:
-		return "T_CreateOpFamilyStmt";
-	case duckdb_libpgquery::T_PGAlterOpFamilyStmt:
-		return "T_AlterOpFamilyStmt";
-	case duckdb_libpgquery::T_PGPrepareStmt:
-		return "T_PrepareStmt";
-	case duckdb_libpgquery::T_PGExecuteStmt:
-		return "T_ExecuteStmt";
-	case duckdb_libpgquery::T_PGCallStmt:
-		return "T_CallStmt";
-	case duckdb_libpgquery::T_PGDeallocateStmt:
-		return "T_DeallocateStmt";
-	case duckdb_libpgquery::T_PGDeclareCursorStmt:
-		return "T_DeclareCursorStmt";
-	case duckdb_libpgquery::T_PGCreateTableSpaceStmt:
-		return "T_CreateTableSpaceStmt";
-	case duckdb_libpgquery::T_PGDropTableSpaceStmt:
-		return "T_DropTableSpaceStmt";
-	case duckdb_libpgquery::T_PGAlterObjectDependsStmt:
-		return "T_AlterObjectDependsStmt";
-	case duckdb_libpgquery::T_PGAlterObjectSchemaStmt:
-		return "T_AlterObjectSchemaStmt";
-	case duckdb_libpgquery::T_PGAlterOwnerStmt:
-		return "T_AlterOwnerStmt";
-	case duckdb_libpgquery::T_PGAlterOperatorStmt:
-		return "T_AlterOperatorStmt";
-	case duckdb_libpgquery::T_PGDropOwnedStmt:
-		return "T_DropOwnedStmt";
-	case duckdb_libpgquery::T_PGReassignOwnedStmt:
-		return "T_ReassignOwnedStmt";
-	case duckdb_libpgquery::T_PGCompositeTypeStmt:
-		return "T_CompositeTypeStmt";
-	case duckdb_libpgquery::T_PGCreateTypeStmt:
-		return "T_CreateTypeStmt";
-	case duckdb_libpgquery::T_PGCreateRangeStmt:
-		return "T_CreateRangeStmt";
-	case duckdb_libpgquery::T_PGAlterEnumStmt:
-		return "T_AlterEnumStmt";
-	case duckdb_libpgquery::T_PGAlterTSDictionaryStmt:
-		return "T_AlterTSDictionaryStmt";
-	case duckdb_libpgquery::T_PGAlterTSConfigurationStmt:
-		return "T_AlterTSConfigurationStmt";
-	case duckdb_libpgquery::T_PGCreateFdwStmt:
-		return "T_CreateFdwStmt";
-	case duckdb_libpgquery::T_PGAlterFdwStmt:
-		return "T_AlterFdwStmt";
-	case duckdb_libpgquery::T_PGCreateForeignServerStmt:
-		return "T_CreateForeignServerStmt";
-	case duckdb_libpgquery::T_PGAlterForeignServerStmt:
-		return "T_AlterForeignServerStmt";
-	case duckdb_libpgquery::T_PGCreateUserMappingStmt:
-		return "T_CreateUserMappingStmt";
-	case duckdb_libpgquery::T_PGAlterUserMappingStmt:
-		return "T_AlterUserMappingStmt";
-	case duckdb_libpgquery::T_PGDropUserMappingStmt:
-		return "T_DropUserMappingStmt";
-	case duckdb_libpgquery::T_PGAlterTableSpaceOptionsStmt:
-		return "T_AlterTableSpaceOptionsStmt";
-	case duckdb_libpgquery::T_PGAlterTableMoveAllStmt:
-		return "T_AlterTableMoveAllStmt";
-	case duckdb_libpgquery::T_PGSecLabelStmt:
-		return "T_SecLabelStmt";
-	case duckdb_libpgquery::T_PGCreateForeignTableStmt:
-		return "T_CreateForeignTableStmt";
-	case duckdb_libpgquery::T_PGImportForeignSchemaStmt:
-		return "T_ImportForeignSchemaStmt";
-	case duckdb_libpgquery::T_PGCreateExtensionStmt:
-		return "T_CreateExtensionStmt";
-	case duckdb_libpgquery::T_PGAlterExtensionStmt:
-		return "T_AlterExtensionStmt";
-	case duckdb_libpgquery::T_PGAlterExtensionContentsStmt:
-		return "T_AlterExtensionContentsStmt";
-	case duckdb_libpgquery::T_PGCreateEventTrigStmt:
-		return "T_CreateEventTrigStmt";
-	case duckdb_libpgquery::T_PGAlterEventTrigStmt:
-		return "T_AlterEventTrigStmt";
-	case duckdb_libpgquery::T_PGRefreshMatViewStmt:
-		return "T_RefreshMatViewStmt";
-	case duckdb_libpgquery::T_PGReplicaIdentityStmt:
-		return "T_ReplicaIdentityStmt";
-	case duckdb_libpgquery::T_PGAlterSystemStmt:
-		return "T_AlterSystemStmt";
-	case duckdb_libpgquery::T_PGCreatePolicyStmt:
-		return "T_CreatePolicyStmt";
-	case duckdb_libpgquery::T_PGAlterPolicyStmt:
-		return "T_AlterPolicyStmt";
-	case duckdb_libpgquery::T_PGCreateTransformStmt:
-		return "T_CreateTransformStmt";
-	case duckdb_libpgquery::T_PGCreateAmStmt:
-		return "T_CreateAmStmt";
-	case duckdb_libpgquery::T_PGCreatePublicationStmt:
-		return "T_CreatePublicationStmt";
-	case duckdb_libpgquery::T_PGAlterPublicationStmt:
-		return "T_AlterPublicationStmt";
-	case duckdb_libpgquery::T_PGCreateSubscriptionStmt:
-		return "T_CreateSubscriptionStmt";
-	case duckdb_libpgquery::T_PGAlterSubscriptionStmt:
-		return "T_AlterSubscriptionStmt";
-	case duckdb_libpgquery::T_PGDropSubscriptionStmt:
-		return "T_DropSubscriptionStmt";
-	case duckdb_libpgquery::T_PGCreateStatsStmt:
-		return "T_CreateStatsStmt";
-	case duckdb_libpgquery::T_PGAlterCollationStmt:
-		return "T_AlterCollationStmt";
-	case duckdb_libpgquery::T_PGAExpr:
-		return "TAExpr";
-	case duckdb_libpgquery::T_PGColumnRef:
-		return "T_ColumnRef";
-	case duckdb_libpgquery::T_PGParamRef:
-		return "T_ParamRef";
-	case duckdb_libpgquery::T_PGAConst:
-		return "TAConst";
-	case duckdb_libpgquery::T_PGFuncCall:
-		return "T_FuncCall";
-	case duckdb_libpgquery::T_PGAStar:
-		return "TAStar";
-	case duckdb_libpgquery::T_PGAIndices:
-		return "TAIndices";
-	case duckdb_libpgquery::T_PGAIndirection:
-		return "TAIndirection";
-	case duckdb_libpgquery::T_PGAArrayExpr:
-		return "TAArrayExpr";
-	case duckdb_libpgquery::T_PGResTarget:
-		return "T_ResTarget";
-	case duckdb_libpgquery::T_PGMultiAssignRef:
-		return "T_MultiAssignRef";
-	case duckdb_libpgquery::T_PGTypeCast:
-		return "T_TypeCast";
-	case duckdb_libpgquery::T_PGCollateClause:
-		return "T_CollateClause";
-	case duckdb_libpgquery::T_PGSortBy:
-		return "T_SortBy";
-	case duckdb_libpgquery::T_PGWindowDef:
-		return "T_WindowDef";
-	case duckdb_libpgquery::T_PGRangeSubselect:
-		return "T_RangeSubselect";
-	case duckdb_libpgquery::T_PGRangeFunction:
-		return "T_RangeFunction";
-	case duckdb_libpgquery::T_PGRangeTableSample:
-		return "T_RangeTableSample";
-	case duckdb_libpgquery::T_PGRangeTableFunc:
-		return "T_RangeTableFunc";
-	case duckdb_libpgquery::T_PGRangeTableFuncCol:
-		return "T_RangeTableFuncCol";
-	case duckdb_libpgquery::T_PGTypeName:
-		return "T_TypeName";
-	case duckdb_libpgquery::T_PGColumnDef:
-		return "T_ColumnDef";
-	case duckdb_libpgquery::T_PGIndexElem:
-		return "T_IndexElem";
-	case duckdb_libpgquery::T_PGConstraint:
-		return "T_Constraint";
-	case duckdb_libpgquery::T_PGDefElem:
-		return "T_DefElem";
-	case duckdb_libpgquery::T_PGRangeTblEntry:
-		return "T_RangeTblEntry";
-	case duckdb_libpgquery::T_PGRangeTblFunction:
-		return "T_RangeTblFunction";
-	case duckdb_libpgquery::T_PGTableSampleClause:
-		return "T_TableSampleClause";
-	case duckdb_libpgquery::T_PGWithCheckOption:
-		return "T_WithCheckOption";
-	case duckdb_libpgquery::T_PGSortGroupClause:
-		return "T_SortGroupClause";
-	case duckdb_libpgquery::T_PGGroupingSet:
-		return "T_GroupingSet";
-	case duckdb_libpgquery::T_PGWindowClause:
-		return "T_WindowClause";
-	case duckdb_libpgquery::T_PGObjectWithArgs:
-		return "T_ObjectWithArgs";
-	case duckdb_libpgquery::T_PGAccessPriv:
-		return "T_AccessPriv";
-	case duckdb_libpgquery::T_PGCreateOpClassItem:
-		return "T_CreateOpClassItem";
-	case duckdb_libpgquery::T_PGTableLikeClause:
-		return "T_TableLikeClause";
-	case duckdb_libpgquery::T_PGFunctionParameter:
-		return "T_FunctionParameter";
-	case duckdb_libpgquery::T_PGLockingClause:
-		return "T_LockingClause";
-	case duckdb_libpgquery::T_PGRowMarkClause:
-		return "T_RowMarkClause";
-	case duckdb_libpgquery::T_PGXmlSerialize:
-		return "T_XmlSerialize";
-	case duckdb_libpgquery::T_PGWithClause:
-		return "T_WithClause";
-	case duckdb_libpgquery::T_PGInferClause:
-		return "T_InferClause";
-	case duckdb_libpgquery::T_PGOnConflictClause:
-		return "T_OnConflictClause";
-	case duckdb_libpgquery::T_PGCommonTableExpr:
-		return "T_CommonTableExpr";
-	case duckdb_libpgquery::T_PGRoleSpec:
-		return "T_RoleSpec";
-	case duckdb_libpgquery::T_PGTriggerTransition:
-		return "T_TriggerTransition";
-	case duckdb_libpgquery::T_PGPartitionElem:
-		return "T_PartitionElem";
-	case duckdb_libpgquery::T_PGPartitionSpec:
-		return "T_PartitionSpec";
-	case duckdb_libpgquery::T_PGPartitionBoundSpec:
-		return "T_PartitionBoundSpec";
-	case duckdb_libpgquery::T_PGPartitionRangeDatum:
-		return "T_PartitionRangeDatum";
-	case duckdb_libpgquery::T_PGPartitionCmd:
-		return "T_PartitionCmd";
-	case duckdb_libpgquery::T_PGIdentifySystemCmd:
-		return "T_IdentifySystemCmd";
-	case duckdb_libpgquery::T_PGBaseBackupCmd:
-		return "T_BaseBackupCmd";
-	case duckdb_libpgquery::T_PGCreateReplicationSlotCmd:
-		return "T_CreateReplicationSlotCmd";
-	case duckdb_libpgquery::T_PGDropReplicationSlotCmd:
-		return "T_DropReplicationSlotCmd";
-	case duckdb_libpgquery::T_PGStartReplicationCmd:
-		return "T_StartReplicationCmd";
-	case duckdb_libpgquery::T_PGTimeLineHistoryCmd:
-		return "T_TimeLineHistoryCmd";
-	case duckdb_libpgquery::T_PGSQLCmd:
-		return "T_SQLCmd";
-	case duckdb_libpgquery::T_PGTriggerData:
-		return "T_TriggerData";
-	case duckdb_libpgquery::T_PGEventTriggerData:
-		return "T_EventTriggerData";
-	case duckdb_libpgquery::T_PGReturnSetInfo:
-		return "T_ReturnSetInfo";
-	case duckdb_libpgquery::T_PGWindowObjectData:
-		return "T_WindowObjectData";
-	case duckdb_libpgquery::T_PGTIDBitmap:
-		return "T_TIDBitmap";
-	case duckdb_libpgquery::T_PGInlineCodeBlock:
-		return "T_InlineCodeBlock";
-	case duckdb_libpgquery::T_PGFdwRoutine:
-		return "T_FdwRoutine";
-	case duckdb_libpgquery::T_PGIndexAmRoutine:
-		return "T_IndexAmRoutine";
-	case duckdb_libpgquery::T_PGTsmRoutine:
-		return "T_TsmRoutine";
-	case duckdb_libpgquery::T_PGForeignKeyCacheInfo:
-		return "T_ForeignKeyCacheInfo";
-	case duckdb_libpgquery::T_PGAttachStmt:
-		return "T_PGAttachStmt";
-	case duckdb_libpgquery::T_PGUseStmt:
-		return "T_PGUseStmt";
-	default:
-		return "(UNKNOWN)";
-	}
-} // LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/transform_alias.cpp b/src/duckdb/src/parser/transform/helpers/transform_alias.cpp
deleted file mode 100644
index 5f0ef56e9..000000000
--- a/src/duckdb/src/parser/transform/helpers/transform_alias.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-vector<string> Transformer::TransformStringList(duckdb_libpgquery::PGList *list) {
-	vector<string> result;
-	if (!list) {
-		return result;
-	}
-	for (auto node = list->head; node != nullptr; node = node->next) {
-		auto value = PGPointerCast<duckdb_libpgquery::PGValue>(node->data.ptr_value);
-		result.emplace_back(value->val.str);
-	}
-	return result;
-}
-
-string Transformer::TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias) {
-	if (!root) {
-		return "";
-	}
-	column_name_alias = TransformStringList(root->colnames);
-	return root->aliasname;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/transform_cte.cpp b/src/duckdb/src/parser/transform/helpers/transform_cte.cpp
deleted file mode 100644
index a344d730e..000000000
--- a/src/duckdb/src/parser/transform/helpers/transform_cte.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "duckdb/common/enums/set_operation_type.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Copy() {
-	auto result = make_uniq<CommonTableExpressionInfo>();
-	result->aliases = aliases;
-	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-	result->materialized = materialized;
-	return result;
-}
-
-void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
-	for (auto &cte_entry : stored_cte_map) {
-		for (auto &entry : cte_entry->map) {
-			auto found_entry = cte_map.map.find(entry.first);
-			if (found_entry != cte_map.map.end()) {
-				// entry already present - use top-most entry
-				continue;
-			}
-			cte_map.map[entry.first] = entry.second->Copy();
-		}
-	}
-	if (parent) {
-		parent->ExtractCTEsRecursive(cte_map);
-	}
-}
-
-void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map) {
-	stored_cte_map.push_back(&cte_map);
-
-	// TODO: might need to update in case of future lawsuit
-	D_ASSERT(de_with_clause.ctes);
-	for (auto cte_ele = de_with_clause.ctes->head; cte_ele != nullptr; cte_ele = cte_ele->next) {
-		auto info = make_uniq<CommonTableExpressionInfo>();
-
-		auto &cte = *PGPointerCast<duckdb_libpgquery::PGCommonTableExpr>(cte_ele->data.ptr_value);
-		if (cte.aliascolnames) {
-			for (auto node = cte.aliascolnames->head; node != nullptr; node = node->next) {
-				auto value = PGPointerCast<duckdb_libpgquery::PGValue>(node->data.ptr_value);
-				info->aliases.emplace_back(value->val.str);
-			}
-		}
-		// lets throw some errors on unsupported features early
-		if (cte.ctecolnames) {
-			throw NotImplementedException("Column name setting not supported in CTEs");
-		}
-		if (cte.ctecoltypes) {
-			throw NotImplementedException("Column type setting not supported in CTEs");
-		}
-		if (cte.ctecoltypmods) {
-			throw NotImplementedException("Column type modification not supported in CTEs");
-		}
-		if (cte.ctecolcollations) {
-			throw NotImplementedException("CTE collations not supported");
-		}
-		// we need a query
-		if (!cte.ctequery || cte.ctequery->type != duckdb_libpgquery::T_PGSelectStmt) {
-			throw NotImplementedException("A CTE needs a SELECT");
-		}
-
-		// CTE transformation can either result in inlining for non recursive CTEs, or in recursive CTE bindings
-		// otherwise.
-		if (cte.cterecursive || de_with_clause.recursive) {
-			info->query = TransformRecursiveCTE(cte, *info);
-		} else {
-			Transformer cte_transformer(*this);
-			info->query = cte_transformer.TransformSelectStmt(*cte.ctequery);
-		}
-		D_ASSERT(info->query);
-		auto cte_name = string(cte.ctename);
-
-		auto it = cte_map.map.find(cte_name);
-		if (it != cte_map.map.end()) {
-			// can't have two CTEs with same name
-			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
-		}
-
-		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeDefault) {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
-#else
-			info->materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
-#endif
-		} else if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeAlways) {
-			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
-		} else if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeNever) {
-			info->materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
-		}
-
-		cte_map.map[cte_name] = std::move(info);
-	}
-}
-
-unique_ptr<SelectStatement> Transformer::TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr &cte,
-                                                               CommonTableExpressionInfo &info) {
-	auto &stmt = *PGPointerCast<duckdb_libpgquery::PGSelectStmt>(cte.ctequery);
-
-	unique_ptr<SelectStatement> select;
-	switch (stmt.op) {
-	case duckdb_libpgquery::PG_SETOP_UNION: {
-		select = make_uniq<SelectStatement>();
-		select->node = make_uniq_base<QueryNode, RecursiveCTENode>();
-		auto &result = select->node->Cast<RecursiveCTENode>();
-		result.ctename = string(cte.ctename);
-		result.union_all = stmt.all;
-		if (stmt.withClause) {
-			auto with_clause = PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause);
-			TransformCTE(*with_clause, result.cte_map);
-		}
-		result.left = TransformSelectNode(*stmt.larg);
-		result.right = TransformSelectNode(*stmt.rarg);
-		result.aliases = info.aliases;
-		break;
-	}
-	case duckdb_libpgquery::PG_SETOP_EXCEPT:
-	case duckdb_libpgquery::PG_SETOP_INTERSECT:
-	default: {
-		// This CTE is not recursive. Fallback to regular query transformation.
-		auto node = TransformSelectNode(*cte.ctequery);
-		auto result = make_uniq<SelectStatement>();
-		result->node = std::move(node);
-		return result;
-	}
-	}
-
-	if (stmt.limitCount || stmt.limitOffset) {
-		throw ParserException("LIMIT or OFFSET in a recursive query is not allowed");
-	}
-	if (stmt.sortClause) {
-		throw ParserException("ORDER BY in a recursive query is not allowed");
-	}
-	return select;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp b/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp
deleted file mode 100644
index 2a8a95c94..000000000
--- a/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-namespace duckdb {
-
-static void CheckGroupingSetMax(idx_t count) {
-	static constexpr const idx_t MAX_GROUPING_SETS = 65535;
-	if (count > MAX_GROUPING_SETS) {
-		throw ParserException("Maximum grouping set count of %d exceeded", MAX_GROUPING_SETS);
-	}
-}
-
-static void CheckGroupingSetCubes(idx_t current_count, idx_t cube_count) {
-	idx_t combinations = 1;
-	for (idx_t i = 0; i < cube_count; i++) {
-		combinations *= 2;
-		CheckGroupingSetMax(current_count + combinations);
-	}
-}
-
-struct GroupingExpressionMap {
-	parsed_expression_map_t<idx_t> map;
-};
-
-static GroupingSet VectorToGroupingSet(vector<idx_t> &indexes) {
-	GroupingSet result;
-	for (idx_t i = 0; i < indexes.size(); i++) {
-		result.insert(indexes[i]);
-	}
-	return result;
-}
-
-static void MergeGroupingSet(GroupingSet &result, GroupingSet &other) {
-	CheckGroupingSetMax(result.size() + other.size());
-	result.insert(other.begin(), other.end());
-}
-
-void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression, GroupingExpressionMap &map,
-                                       GroupByNode &result, vector<idx_t> &result_set) {
-	if (expression->GetExpressionType() == ExpressionType::FUNCTION) {
-		auto &func = expression->Cast<FunctionExpression>();
-		if (func.function_name == "row") {
-			for (auto &child : func.children) {
-				AddGroupByExpression(std::move(child), map, result, result_set);
-			}
-			return;
-		}
-	}
-	auto entry = map.map.find(*expression);
-	idx_t result_idx;
-	if (entry == map.map.end()) {
-		result_idx = result.group_expressions.size();
-		map.map[*expression] = result_idx;
-		result.group_expressions.push_back(std::move(expression));
-	} else {
-		result_idx = entry->second;
-	}
-	result_set.push_back(result_idx);
-}
-
-static void AddCubeSets(const GroupingSet &current_set, vector<GroupingSet> &result_set,
-                        vector<GroupingSet> &result_sets, idx_t start_idx = 0) {
-	CheckGroupingSetMax(result_sets.size());
-	result_sets.push_back(current_set);
-	for (idx_t k = start_idx; k < result_set.size(); k++) {
-		auto child_set = current_set;
-		MergeGroupingSet(child_set, result_set[k]);
-		AddCubeSets(child_set, result_set, result_sets, k + 1);
-	}
-}
-
-void Transformer::TransformGroupByExpression(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map,
-                                             GroupByNode &result, vector<idx_t> &indexes) {
-	auto expression = TransformExpression(n);
-	AddGroupByExpression(std::move(expression), map, result, indexes);
-}
-
-// If one GROUPING SETS clause is nested inside another,
-// the effect is the same as if all the elements of the inner clause had been written directly in the outer clause.
-void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map, SelectNode &result,
-                                       vector<GroupingSet> &result_sets) {
-	if (n.type == duckdb_libpgquery::T_PGGroupingSet) {
-		auto &grouping_set = PGCast<duckdb_libpgquery::PGGroupingSet>(n);
-		switch (grouping_set.kind) {
-		case duckdb_libpgquery::GROUPING_SET_EMPTY:
-			result_sets.emplace_back();
-			break;
-		case duckdb_libpgquery::GROUPING_SET_ALL: {
-			result.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;
-			break;
-		}
-		case duckdb_libpgquery::GROUPING_SET_SETS: {
-			for (auto node = grouping_set.content->head; node; node = node->next) {
-				auto pg_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-				TransformGroupByNode(*pg_node, map, result, result_sets);
-			}
-			break;
-		}
-		case duckdb_libpgquery::GROUPING_SET_ROLLUP: {
-			vector<GroupingSet> rollup_sets;
-			for (auto node = grouping_set.content->head; node; node = node->next) {
-				auto pg_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-				vector<idx_t> rollup_set;
-				TransformGroupByExpression(*pg_node, map, result.groups, rollup_set);
-				rollup_sets.push_back(VectorToGroupingSet(rollup_set));
-			}
-			// generate the subsets of the rollup set and add them to the grouping sets
-			GroupingSet current_set;
-			result_sets.push_back(current_set);
-			for (idx_t i = 0; i < rollup_sets.size(); i++) {
-				MergeGroupingSet(current_set, rollup_sets[i]);
-				result_sets.push_back(current_set);
-			}
-			break;
-		}
-		case duckdb_libpgquery::GROUPING_SET_CUBE: {
-			vector<GroupingSet> cube_sets;
-			for (auto node = grouping_set.content->head; node; node = node->next) {
-				auto pg_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-				vector<idx_t> cube_set;
-				TransformGroupByExpression(*pg_node, map, result.groups, cube_set);
-				cube_sets.push_back(VectorToGroupingSet(cube_set));
-			}
-			// generate the subsets of the rollup set and add them to the grouping sets
-			CheckGroupingSetCubes(result_sets.size(), cube_sets.size());
-
-			GroupingSet current_set;
-			AddCubeSets(current_set, cube_sets, result_sets, 0);
-			break;
-		}
-		default:
-			throw InternalException("Unsupported GROUPING SET type %d", grouping_set.kind);
-		}
-	} else {
-		vector<idx_t> indexes;
-		TransformGroupByExpression(n, map, result.groups, indexes);
-		result_sets.push_back(VectorToGroupingSet(indexes));
-	}
-}
-
-// If multiple grouping items are specified in a single GROUP BY clause,
-// then the final list of grouping sets is the cross product of the individual items.
-bool Transformer::TransformGroupBy(optional_ptr<duckdb_libpgquery::PGList> group, SelectNode &select_node) {
-	if (!group) {
-		return false;
-	}
-	auto &result = select_node.groups;
-	GroupingExpressionMap map;
-	for (auto node = group->head; node != nullptr; node = node->next) {
-		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-		vector<GroupingSet> result_sets;
-		TransformGroupByNode(*n, map, select_node, result_sets);
-		CheckGroupingSetMax(result_sets.size());
-		if (result.grouping_sets.empty()) {
-			// no grouping sets yet: use the current set of grouping sets
-			result.grouping_sets = std::move(result_sets);
-		} else {
-			// compute the cross product
-			vector<GroupingSet> new_sets;
-			idx_t grouping_set_count = result.grouping_sets.size() * result_sets.size();
-			CheckGroupingSetMax(grouping_set_count);
-			new_sets.reserve(grouping_set_count);
-			for (idx_t current_idx = 0; current_idx < result.grouping_sets.size(); current_idx++) {
-				auto &current_set = result.grouping_sets[current_idx];
-				for (idx_t new_idx = 0; new_idx < result_sets.size(); new_idx++) {
-					auto &new_set = result_sets[new_idx];
-					GroupingSet set;
-					set.insert(current_set.begin(), current_set.end());
-					set.insert(new_set.begin(), new_set.end());
-					new_sets.push_back(std::move(set));
-				}
-			}
-			result.grouping_sets = std::move(new_sets);
-		}
-	}
-	if (result.group_expressions.size() == 1 && result.grouping_sets.size() == 1 &&
-	    ExpressionIsEmptyStar(*result.group_expressions[0])) {
-		// GROUP BY *
-		result.group_expressions.clear();
-		result.grouping_sets.clear();
-		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/transform_orderby.cpp b/src/duckdb/src/parser/transform/helpers/transform_orderby.cpp
deleted file mode 100644
index 0feec0ead..000000000
--- a/src/duckdb/src/parser/transform/helpers/transform_orderby.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result) {
-	if (!order) {
-		return false;
-	}
-
-	for (auto node = order->head; node != nullptr; node = node->next) {
-		auto temp_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-		if (temp_node->type != duckdb_libpgquery::T_PGSortBy) {
-			throw NotImplementedException("ORDER BY list member type %d\n", temp_node->type);
-		}
-
-		OrderType type;
-		OrderByNullType null_order;
-		auto sort = PGCast<duckdb_libpgquery::PGSortBy>(*temp_node.get());
-		auto target = sort.node;
-
-		if (sort.sortby_dir == duckdb_libpgquery::PG_SORTBY_DEFAULT) {
-			type = OrderType::ORDER_DEFAULT;
-		} else if (sort.sortby_dir == duckdb_libpgquery::PG_SORTBY_ASC) {
-			type = OrderType::ASCENDING;
-		} else if (sort.sortby_dir == duckdb_libpgquery::PG_SORTBY_DESC) {
-			type = OrderType::DESCENDING;
-		} else {
-			throw NotImplementedException("Unimplemented order by type");
-		}
-
-		if (sort.sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_DEFAULT) {
-			null_order = OrderByNullType::ORDER_DEFAULT;
-		} else if (sort.sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_FIRST) {
-			null_order = OrderByNullType::NULLS_FIRST;
-		} else if (sort.sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_LAST) {
-			null_order = OrderByNullType::NULLS_LAST;
-		} else {
-			throw NotImplementedException("Unimplemented order by type");
-		}
-
-		auto order_expression = TransformExpression(target);
-		result.emplace_back(type, null_order, std::move(order_expression));
-	}
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/transform_sample.cpp b/src/duckdb/src/parser/transform/helpers/transform_sample.cpp
deleted file mode 100644
index bd1cc75a2..000000000
--- a/src/duckdb/src/parser/transform/helpers/transform_sample.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-static SampleMethod GetSampleMethod(const string &method) {
-	auto lmethod = StringUtil::Lower(method);
-	if (lmethod == "system") {
-		return SampleMethod::SYSTEM_SAMPLE;
-	} else if (lmethod == "bernoulli") {
-		return SampleMethod::BERNOULLI_SAMPLE;
-	} else if (lmethod == "reservoir") {
-		return SampleMethod::RESERVOIR_SAMPLE;
-	} else {
-		throw ParserException("Unrecognized sampling method %s, expected system, bernoulli or reservoir", method);
-	}
-}
-
-unique_ptr<SampleOptions> Transformer::TransformSampleOptions(optional_ptr<duckdb_libpgquery::PGNode> options) {
-	if (!options) {
-		return nullptr;
-	}
-	auto result = make_uniq<SampleOptions>();
-	auto &sample_options = PGCast<duckdb_libpgquery::PGSampleOptions>(*options);
-	auto &sample_size = *PGPointerCast<duckdb_libpgquery::PGSampleSize>(sample_options.sample_size);
-	auto sample_expression = TransformExpression(sample_size.sample_size);
-	if (sample_expression->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
-		throw ParserException(sample_expression->GetQueryLocation(),
-		                      "Only constants are supported in sample clause currently");
-	}
-	auto &const_expr = sample_expression->Cast<ConstantExpression>();
-	auto &sample_value = const_expr.value;
-	result->is_percentage = sample_size.is_percentage;
-	if (sample_size.is_percentage) {
-		// sample size is given in sample_size: use system sampling
-		auto percentage = sample_value.GetValue<double>();
-		if (percentage < 0 || percentage > 100) {
-			throw ParserException("Sample sample_size %llf out of range, must be between 0 and 100", percentage);
-		}
-		result->sample_size = Value::DOUBLE(percentage);
-		result->method = SampleMethod::SYSTEM_SAMPLE;
-	} else {
-		// sample size is given in rows: use reservoir sampling
-		auto rows = sample_value.GetValue<int64_t>();
-		if (rows < 0) {
-			throw ParserException("Sample rows %lld out of range, must be bigger than or equal to 0", rows);
-		}
-		result->sample_size = Value::BIGINT(rows);
-		result->method = SampleMethod::RESERVOIR_SAMPLE;
-	}
-	if (sample_options.method) {
-		result->method = GetSampleMethod(sample_options.method);
-	}
-	if (sample_options.has_seed && sample_options.seed >= 0) {
-		result->seed = static_cast<idx_t>(sample_options.seed);
-		result->repeatable = true;
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/helpers/transform_typename.cpp b/src/duckdb/src/parser/transform/helpers/transform_typename.cpp
deleted file mode 100644
index a7beb3ba2..000000000
--- a/src/duckdb/src/parser/transform/helpers/transform_typename.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-struct SizeModifiers {
-	int64_t width = 0;
-	int64_t scale = 0;
-	// How many modifiers were found
-	idx_t count = 0;
-};
-
-static SizeModifiers GetSizeModifiers(duckdb_libpgquery::PGTypeName &type_name, LogicalTypeId base_type) {
-
-	SizeModifiers result;
-
-	if (base_type == LogicalTypeId::DECIMAL) {
-		// Defaults for DECIMAL
-		result.width = 18;
-		result.scale = 3;
-	}
-
-	if (type_name.typmods) {
-		for (auto node = type_name.typmods->head; node; node = node->next) {
-			auto &const_val = *Transformer::PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
-			if (const_val.type != duckdb_libpgquery::T_PGAConst ||
-			    const_val.val.type != duckdb_libpgquery::T_PGInteger) {
-				throw ParserException("Expected an integer constant as type modifier");
-			}
-			if (const_val.val.val.ival < 0) {
-				throw ParserException("Negative modifier not supported");
-			}
-			if (result.count == 0) {
-				result.width = const_val.val.val.ival;
-				if (base_type == LogicalTypeId::BIT && const_val.location != -1) {
-					result.width = 0;
-				}
-			} else if (result.count == 1) {
-				result.scale = const_val.val.val.ival;
-			} else {
-				throw ParserException("A maximum of two modifiers is supported");
-			}
-			result.count++;
-		}
-	}
-	return result;
-}
-
-vector<Value> Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName &type_name) {
-	vector<Value> type_mods;
-	if (type_name.typmods) {
-		for (auto node = type_name.typmods->head; node; node = node->next) {
-			if (type_mods.size() > 9) {
-				const auto &name =
-				    *PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
-				throw ParserException("'%s': a maximum of 9 type modifiers is allowed", name);
-			}
-			const auto &const_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
-			if (const_val.type != duckdb_libpgquery::T_PGAConst) {
-				throw ParserException("Expected a constant as type modifier");
-			}
-			const auto const_expr = TransformValue(const_val.val);
-			type_mods.push_back(std::move(const_expr->value));
-		}
-	}
-	return type_mods;
-}
-
-LogicalType Transformer::TransformTypeNameInternal(duckdb_libpgquery::PGTypeName &type_name) {
-	if (type_name.names->length > 1) {
-		// qualified typename
-		vector<string> names;
-		for (auto cell = type_name.names->head; cell; cell = cell->next) {
-			names.push_back(PGPointerCast<duckdb_libpgquery::PGValue>(cell->data.ptr_value)->val.str);
-		}
-		vector<Value> type_mods = TransformTypeModifiers(type_name);
-		switch (type_name.names->length) {
-		case 2: {
-			return LogicalType::USER(INVALID_CATALOG, std::move(names[0]), std::move(names[1]), std::move(type_mods));
-		}
-		case 3: {
-			return LogicalType::USER(std::move(names[0]), std::move(names[1]), std::move(names[2]),
-			                         std::move(type_mods));
-		}
-		default:
-			throw ParserException(
-			    "Too many qualifications for type name - expected [catalog.schema.name] or [schema.name]");
-		}
-	}
-
-	auto name = PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
-	// transform it to the SQL type
-	LogicalTypeId base_type = TransformStringToLogicalTypeId(name);
-
-	if (base_type == LogicalTypeId::LIST) {
-		throw ParserException("LIST is not valid as a stand-alone type");
-	}
-	if (base_type == LogicalTypeId::ENUM) {
-		if (!type_name.typmods || type_name.typmods->length == 0) {
-			throw ParserException("Enum needs a set of entries");
-		}
-		Vector enum_vector(LogicalType::VARCHAR, NumericCast<idx_t>(type_name.typmods->length));
-		auto string_data = FlatVector::GetData<string_t>(enum_vector);
-		idx_t pos = 0;
-		for (auto node = type_name.typmods->head; node; node = node->next) {
-			auto constant_value = PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
-			if (constant_value->type != duckdb_libpgquery::T_PGAConst ||
-			    constant_value->val.type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("Enum type requires a set of strings as type modifiers");
-			}
-			string_data[pos++] = StringVector::AddString(enum_vector, constant_value->val.val.str);
-		}
-		return LogicalType::ENUM(enum_vector, NumericCast<idx_t>(type_name.typmods->length));
-	}
-	if (base_type == LogicalTypeId::STRUCT) {
-		if (!type_name.typmods || type_name.typmods->length == 0) {
-			throw ParserException("Struct needs a name and entries");
-		}
-		child_list_t<LogicalType> children;
-		case_insensitive_set_t name_collision_set;
-
-		for (auto node = type_name.typmods->head; node; node = node->next) {
-			auto &type_val = *PGPointerCast<duckdb_libpgquery::PGList>(node->data.ptr_value);
-			if (type_val.length != 2) {
-				throw ParserException("Struct entry needs an entry name and a type name");
-			}
-
-			auto entry_name_node = PGPointerCast<duckdb_libpgquery::PGValue>(type_val.head->data.ptr_value);
-			D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString);
-			auto entry_type_node = PGPointerCast<duckdb_libpgquery::PGTypeName>(type_val.tail->data.ptr_value);
-			D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName);
-
-			auto entry_name = string(entry_name_node->val.str);
-			D_ASSERT(!entry_name.empty());
-
-			if (name_collision_set.find(entry_name) != name_collision_set.end()) {
-				throw ParserException("Duplicate struct entry name \"%s\"", entry_name);
-			}
-			name_collision_set.insert(entry_name);
-			auto entry_type = TransformTypeName(*entry_type_node);
-
-			children.push_back(make_pair(entry_name, entry_type));
-		}
-		D_ASSERT(!children.empty());
-		return LogicalType::STRUCT(children);
-	}
-	if (base_type == LogicalTypeId::MAP) {
-		if (!type_name.typmods || type_name.typmods->length != 2) {
-			throw ParserException("Map type needs exactly two entries, key and value type");
-		}
-		auto key_type =
-		    TransformTypeName(*PGPointerCast<duckdb_libpgquery::PGTypeName>(type_name.typmods->head->data.ptr_value));
-		auto value_type =
-		    TransformTypeName(*PGPointerCast<duckdb_libpgquery::PGTypeName>(type_name.typmods->tail->data.ptr_value));
-
-		return LogicalType::MAP(std::move(key_type), std::move(value_type));
-	}
-	if (base_type == LogicalTypeId::UNION) {
-		if (!type_name.typmods || type_name.typmods->length == 0) {
-			throw ParserException("Union type needs at least one member");
-		}
-		if (type_name.typmods->length > (int)UnionType::MAX_UNION_MEMBERS) {
-			throw ParserException("Union types can have at most %d members", UnionType::MAX_UNION_MEMBERS);
-		}
-
-		child_list_t<LogicalType> children;
-		case_insensitive_set_t name_collision_set;
-
-		for (auto node = type_name.typmods->head; node; node = node->next) {
-			auto &type_val = *PGPointerCast<duckdb_libpgquery::PGList>(node->data.ptr_value);
-			if (type_val.length != 2) {
-				throw ParserException("Union type member needs a tag name and a type name");
-			}
-
-			auto entry_name_node = PGPointerCast<duckdb_libpgquery::PGValue>(type_val.head->data.ptr_value);
-			D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString);
-			auto entry_type_node = PGPointerCast<duckdb_libpgquery::PGTypeName>(type_val.tail->data.ptr_value);
-			D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName);
-
-			auto entry_name = string(entry_name_node->val.str);
-			D_ASSERT(!entry_name.empty());
-
-			if (name_collision_set.find(entry_name) != name_collision_set.end()) {
-				throw ParserException("Duplicate union type tag name \"%s\"", entry_name);
-			}
-
-			name_collision_set.insert(entry_name);
-
-			auto entry_type = TransformTypeName(*entry_type_node);
-			children.push_back(make_pair(entry_name, entry_type));
-		}
-		D_ASSERT(!children.empty());
-		return LogicalType::UNION(std::move(children));
-	}
-	if (base_type == LogicalTypeId::USER) {
-		string user_type_name {name};
-		vector<Value> type_mods = TransformTypeModifiers(type_name);
-		return LogicalType::USER(user_type_name, type_mods);
-	}
-
-	SizeModifiers modifiers = GetSizeModifiers(type_name, base_type);
-	switch (base_type) {
-	case LogicalTypeId::VARCHAR:
-		if (modifiers.count > 1) {
-			throw ParserException("VARCHAR only supports a single modifier");
-		}
-		// FIXME: create CHECK constraint based on varchar width
-		modifiers.width = 0;
-		return LogicalType::VARCHAR;
-	case LogicalTypeId::DECIMAL:
-		if (modifiers.count > 2) {
-			throw ParserException("DECIMAL only supports a maximum of two modifiers");
-		}
-		if (modifiers.count == 1) {
-			// only width is provided: set scale to 0
-			modifiers.scale = 0;
-		}
-		if (modifiers.width <= 0 || modifiers.width > Decimal::MAX_WIDTH_DECIMAL) {
-			throw ParserException("Width must be between 1 and %d!", (int)Decimal::MAX_WIDTH_DECIMAL);
-		}
-		if (modifiers.scale > modifiers.width) {
-			throw ParserException("Scale cannot be bigger than width");
-		}
-		return LogicalType::DECIMAL(NumericCast<uint8_t>(modifiers.width), NumericCast<uint8_t>(modifiers.scale));
-	case LogicalTypeId::INTERVAL:
-		if (modifiers.count > 1) {
-			throw ParserException("INTERVAL only supports a single modifier");
-		}
-		modifiers.width = 0;
-		return LogicalType::INTERVAL;
-	case LogicalTypeId::BIT:
-		if (!modifiers.width && type_name.typmods) {
-			throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
-		}
-		return LogicalType(base_type);
-	case LogicalTypeId::TIMESTAMP:
-		if (modifiers.count == 0) {
-			return LogicalType::TIMESTAMP;
-		}
-		if (modifiers.count > 1) {
-			throw ParserException("TIMESTAMP only supports a single modifier");
-		}
-		if (modifiers.width > 10) {
-			throw ParserException("TIMESTAMP only supports until nano-second precision (9)");
-		}
-		if (modifiers.width == 0) {
-			return LogicalType::TIMESTAMP_S;
-		}
-		if (modifiers.width <= 3) {
-			return LogicalType::TIMESTAMP_MS;
-		}
-		if (modifiers.width <= 6) {
-			return LogicalType::TIMESTAMP;
-		}
-		return LogicalType::TIMESTAMP_NS;
-	default:
-		if (modifiers.count > 0) {
-			throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
-		}
-		return LogicalType(base_type);
-	}
-}
-
-LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) {
-	if (type_name.type != duckdb_libpgquery::T_PGTypeName) {
-		throw ParserException("Expected a type");
-	}
-	auto stack_checker = StackCheck();
-	auto result_type = TransformTypeNameInternal(type_name);
-	if (type_name.arrayBounds) {
-		// array bounds: turn the type into a list
-		idx_t extra_stack = 0;
-		for (auto cell = type_name.arrayBounds->head; cell != nullptr; cell = cell->next) {
-			StackCheck(extra_stack++);
-			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(cell->data.ptr_value);
-			if (val->type != duckdb_libpgquery::T_PGInteger) {
-				throw ParserException("Expected integer value as array bound");
-			}
-			auto array_size = val->val.ival;
-			if (array_size < 0) {
-				// -1 if bounds are empty
-				result_type = LogicalType::LIST(result_type);
-			} else if (array_size == 0) {
-				// Empty arrays are not supported
-				throw ParserException("Arrays must have a size of at least 1");
-			} else if (array_size > static_cast<int64_t>(ArrayType::MAX_ARRAY_SIZE)) {
-				throw ParserException("Arrays must have a size of at most %d", ArrayType::MAX_ARRAY_SIZE);
-			} else {
-				result_type = LogicalType::ARRAY(result_type, NumericCast<idx_t>(array_size));
-			}
-		}
-	}
-	return result_type;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_alter_sequence.cpp b/src/duckdb/src/parser/transform/statement/transform_alter_sequence.cpp
deleted file mode 100644
index b80c5a927..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_alter_sequence.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "duckdb/common/enum_class_hash.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery::PGAlterSeqStmt &stmt) {
-	auto result = make_uniq<AlterStatement>();
-
-	auto qname = TransformQualifiedName(*stmt.sequence);
-	auto sequence_catalog = qname.catalog;
-	auto sequence_schema = qname.schema;
-	auto sequence_name = qname.name;
-
-	if (!stmt.options) {
-		throw InternalException("Expected an argument for ALTER SEQUENCE.");
-	}
-
-	unordered_set<SequenceInfo, EnumClassHash> used;
-	duckdb_libpgquery::PGListCell *cell;
-	for_each_cell(cell, stmt.options->head) {
-		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-		string opt_name = string(def_elem->defname);
-
-		if (opt_name == "owned_by") {
-			if (used.find(SequenceInfo::SEQ_OWN) != used.end()) {
-				throw ParserException("Owned by value should be passed as most once");
-			}
-			used.insert(SequenceInfo::SEQ_OWN);
-
-			auto val = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
-			if (!val) {
-				throw InternalException("Expected an argument for option %s", opt_name);
-			}
-			D_ASSERT(val);
-			if (val->type != duckdb_libpgquery::T_PGList) {
-				throw InternalException("Expected a string argument for option %s", opt_name);
-			}
-			auto opt_values = vector<string>();
-
-			for (auto c = val->head; c != nullptr; c = lnext(c)) {
-				auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
-				opt_values.emplace_back(target->name);
-			}
-			D_ASSERT(!opt_values.empty());
-			string owner_schema = INVALID_SCHEMA;
-			string owner_name;
-			if (opt_values.size() == 2) {
-				owner_schema = opt_values[0];
-				owner_name = opt_values[1];
-			} else if (opt_values.size() == 1) {
-				owner_schema = DEFAULT_SCHEMA;
-				owner_name = opt_values[0];
-			} else {
-				throw InternalException("Wrong argument for %s. Expected either <schema>.<name> or <name>", opt_name);
-			}
-			auto info = make_uniq<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_catalog, sequence_schema,
-			                                           sequence_name, owner_schema, owner_name,
-			                                           TransformOnEntryNotFound(stmt.missing_ok));
-			result->info = std::move(info);
-		} else {
-			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
-		}
-	}
-	result->info->if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
-	return result;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp b/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp
deleted file mode 100644
index 2537daaec..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-OnEntryNotFound Transformer::TransformOnEntryNotFound(bool missing_ok) {
-	return missing_ok ? OnEntryNotFound::RETURN_NULL : OnEntryNotFound::THROW_EXCEPTION;
-}
-
-unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGAlterTableStmt &stmt) {
-
-	D_ASSERT(stmt.relation);
-	if (stmt.cmds->length != 1) {
-		throw ParserException("Only one ALTER command per statement is supported");
-	}
-
-	auto result = make_uniq<AlterStatement>();
-	auto qualified_name = TransformQualifiedName(*stmt.relation);
-
-	// Check the ALTER type.
-	for (auto c = stmt.cmds->head; c != nullptr; c = c->next) {
-
-		auto command = PGPointerCast<duckdb_libpgquery::PGAlterTableCmd>(c->data.ptr_value);
-		AlterEntryData data(qualified_name.catalog, qualified_name.schema, qualified_name.name,
-		                    TransformOnEntryNotFound(stmt.missing_ok));
-
-		switch (command->subtype) {
-		case duckdb_libpgquery::PG_AT_AddColumn: {
-			auto column_def = PGPointerCast<duckdb_libpgquery::PGColumnDef>(command->def);
-			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
-				throw ParserException("Adding columns is only supported for tables");
-			}
-			if (column_def->category == duckdb_libpgquery::COL_GENERATED) {
-				throw ParserException("Adding generated columns after table creation is not supported yet");
-			}
-
-			auto column_entry = TransformColumnDefinition(*column_def);
-			if (column_def->constraints) {
-				for (auto cell = column_def->constraints->head; cell != nullptr; cell = cell->next) {
-					auto pg_constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(cell->data.ptr_value);
-					auto constraint = TransformConstraint(*pg_constraint, column_entry, 0);
-					if (!constraint) {
-						continue;
-					}
-					throw ParserException("Adding columns with constraints not yet supported");
-				}
-			}
-			result->info = make_uniq<AddColumnInfo>(std::move(data), std::move(column_entry), command->missing_ok);
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_DropColumn: {
-			auto cascade = command->behavior == duckdb_libpgquery::PG_DROP_CASCADE;
-			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
-				throw ParserException("Dropping columns is only supported for tables");
-			}
-			result->info = make_uniq<RemoveColumnInfo>(std::move(data), command->name, command->missing_ok, cascade);
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_ColumnDefault: {
-			auto expr = TransformExpression(command->def);
-			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
-				throw ParserException("Alter column's default is only supported for tables");
-			}
-			result->info = make_uniq<SetDefaultInfo>(std::move(data), command->name, std::move(expr));
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_AlterColumnType: {
-			auto column_def = PGPointerCast<duckdb_libpgquery::PGColumnDef>(command->def);
-			auto column_entry = TransformColumnDefinition(*column_def);
-
-			unique_ptr<ParsedExpression> expr;
-			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
-				throw ParserException("Alter column's type is only supported for tables");
-			}
-
-			if (column_entry.GetType() == LogicalType::UNKNOWN && !column_def->raw_default) {
-				throw ParserException("Omitting the type is only possible in combination with USING");
-			}
-
-			if (column_def->raw_default) {
-				expr = TransformExpression(column_def->raw_default);
-			} else {
-				auto col_ref = make_uniq<ColumnRefExpression>(command->name);
-				expr = make_uniq<CastExpression>(column_entry.Type(), std::move(col_ref));
-			}
-			result->info =
-			    make_uniq<ChangeColumnTypeInfo>(std::move(data), command->name, column_entry.Type(), std::move(expr));
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_SetNotNull: {
-			result->info = make_uniq<SetNotNullInfo>(std::move(data), command->name);
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_DropNotNull: {
-			result->info = make_uniq<DropNotNullInfo>(std::move(data), command->name);
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_AddConstraint: {
-			auto pg_constraint = PGCast<duckdb_libpgquery::PGConstraint>(*command->def);
-			if (pg_constraint.contype != duckdb_libpgquery::PGConstrType::PG_CONSTR_PRIMARY) {
-				throw NotImplementedException("No support for that ALTER TABLE option yet!");
-			}
-
-			auto constraint = TransformConstraint(pg_constraint);
-			result->info = make_uniq<AddConstraintInfo>(std::move(data), std::move(constraint));
-			break;
-		}
-		default:
-			throw NotImplementedException("No support for that ALTER TABLE option yet!");
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_attach.cpp b/src/duckdb/src/parser/transform/statement/transform_attach.cpp
deleted file mode 100644
index 8c7632f74..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_attach.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/statement/attach_statement.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-unique_ptr<AttachStatement> Transformer::TransformAttach(duckdb_libpgquery::PGAttachStmt &stmt) {
-	auto result = make_uniq<AttachStatement>();
-	auto info = make_uniq<AttachInfo>();
-	info->name = stmt.name ? stmt.name : string();
-	info->path = stmt.path;
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-
-	if (stmt.options) {
-		duckdb_libpgquery::PGListCell *cell;
-		for_each_cell(cell, stmt.options->head) {
-			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-			Value val;
-			if (def_elem->arg) {
-				val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
-			} else {
-				val = Value::BOOLEAN(true);
-			}
-			info->options[StringUtil::Lower(def_elem->defname)] = std::move(val);
-		}
-	}
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_call.cpp b/src/duckdb/src/parser/transform/statement/transform_call.cpp
deleted file mode 100644
index 54d1a4f34..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_call.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "duckdb/parser/statement/call_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<CallStatement> Transformer::TransformCall(duckdb_libpgquery::PGCallStmt &stmt) {
-	auto result = make_uniq<CallStatement>();
-	result->function = TransformFuncCall(*PGPointerCast<duckdb_libpgquery::PGFuncCall>(stmt.func));
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_checkpoint.cpp b/src/duckdb/src/parser/transform/statement/transform_checkpoint.cpp
deleted file mode 100644
index 6f8fded60..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_checkpoint.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/statement/call_statement.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformCheckpoint(duckdb_libpgquery::PGCheckPointStmt &stmt) {
-	vector<unique_ptr<ParsedExpression>> children;
-	// transform into "CALL checkpoint()" or "CALL force_checkpoint()"
-	auto checkpoint_name = stmt.force ? "force_checkpoint" : "checkpoint";
-	auto result = make_uniq<CallStatement>();
-	auto function = make_uniq<FunctionExpression>(checkpoint_name, std::move(children));
-	function->catalog = SYSTEM_CATALOG;
-	function->schema = DEFAULT_SCHEMA;
-	if (stmt.name) {
-		function->children.push_back(make_uniq<ConstantExpression>(Value(stmt.name)));
-	}
-	result->function = std::move(function);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp b/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp
deleted file mode 100644
index 6ab5d9e68..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<AlterStatement> Transformer::TransformCommentOn(duckdb_libpgquery::PGCommentOnStmt &stmt) {
-	QualifiedName qualified_name;
-	string column_name;
-
-	if (stmt.object_type != duckdb_libpgquery::PG_OBJECT_COLUMN) {
-		qualified_name = TransformQualifiedName(*stmt.name);
-	} else {
-		auto transformed_expr = TransformExpression(stmt.column_expr);
-
-		if (transformed_expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
-			throw ParserException("Unexpected expression found, expected column reference to comment on (e.g. "
-			                      "'schema.table.column'), found '%s'",
-			                      transformed_expr->ToString());
-		}
-
-		auto colref_expr = transformed_expr->Cast<ColumnRefExpression>();
-
-		if (colref_expr.column_names.size() > 4) {
-			throw ParserException("Invalid column reference: '%s', too many dots", colref_expr.ToString());
-		}
-		if (colref_expr.column_names.size() < 2) {
-			throw ParserException("Invalid column reference: '%s', please specify a table", colref_expr.ToString());
-		}
-
-		column_name = colref_expr.GetColumnName();
-		qualified_name.name = colref_expr.column_names.size() > 1 ? colref_expr.GetTableName() : "";
-
-		if (colref_expr.column_names.size() == 4) {
-			qualified_name.catalog = colref_expr.column_names[0];
-			qualified_name.schema = colref_expr.column_names[1];
-		} else if (colref_expr.column_names.size() == 3) {
-			qualified_name.schema = colref_expr.column_names[0];
-		}
-	}
-
-	auto res = make_uniq<AlterStatement>();
-	unique_ptr<AlterInfo> info;
-
-	auto expr = TransformExpression(stmt.value);
-	if (expr->GetExpressionClass() != ExpressionClass::CONSTANT) {
-		throw NotImplementedException("Can only use constants as comments");
-	}
-	auto comment_value = expr->Cast<ConstantExpression>().value;
-
-	CatalogType type = CatalogType::INVALID;
-
-	// Regular CatalogTypes
-	switch (stmt.object_type) {
-	case duckdb_libpgquery::PG_OBJECT_TABLE:
-		type = CatalogType::TABLE_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_INDEX:
-		type = CatalogType::INDEX_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_VIEW:
-		type = CatalogType::VIEW_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_FUNCTION:
-		type = CatalogType::MACRO_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TABLE_MACRO:
-		type = CatalogType::TABLE_MACRO_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_SEQUENCE:
-		type = CatalogType::SEQUENCE_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TYPE:
-		type = CatalogType::TYPE_ENTRY;
-		break;
-	default:
-		break;
-	}
-
-	if (type != CatalogType::INVALID) {
-		info = make_uniq<SetCommentInfo>(type, qualified_name.catalog, qualified_name.schema, qualified_name.name,
-		                                 comment_value, OnEntryNotFound::THROW_EXCEPTION);
-	} else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_COLUMN) {
-		info = make_uniq<SetColumnCommentInfo>(qualified_name.catalog, qualified_name.schema, qualified_name.name,
-		                                       column_name, comment_value, OnEntryNotFound::THROW_EXCEPTION);
-	} else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_DATABASE) {
-		throw NotImplementedException("Adding comments to databases is not implemented");
-	} else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_SCHEMA) {
-		throw NotImplementedException("Adding comments to schemas is not implemented");
-	}
-
-	if (info) {
-		res->info = std::move(info);
-		return res;
-	}
-
-	throw NotImplementedException("Can not comment on this type");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_copy.cpp b/src/duckdb/src/parser/transform/statement/transform_copy.cpp
deleted file mode 100644
index 7c199ac5b..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_copy.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/function/replacement_scan.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-void Transformer::ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
-                                              duckdb_libpgquery::PGNode *arg) {
-	// otherwise
-	if (result_options.find(name) != result_options.end()) {
-		throw ParserException("Unexpected duplicate option \"%s\"", name);
-	}
-	if (!arg) {
-		result_options[name] = vector<Value>();
-		return;
-	}
-	switch (arg->type) {
-	case duckdb_libpgquery::T_PGList: {
-		auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(arg);
-		for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
-			result_options[name].push_back(Value(target->name));
-		}
-		break;
-	}
-	case duckdb_libpgquery::T_PGAStar:
-		result_options[name].push_back(Value("*"));
-		break;
-	case duckdb_libpgquery::T_PGFuncCall: {
-		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(arg);
-		auto func_expr = TransformFuncCall(*func_call);
-
-		Value value;
-		if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
-			throw ParserException("Unsupported expression in option list: %s", func_expr->ToString());
-		}
-		result_options[name].push_back(std::move(value));
-		break;
-	}
-	default: {
-		auto val = PGPointerCast<duckdb_libpgquery::PGValue>(arg);
-		result_options[name].push_back(TransformValue(*val)->value);
-		break;
-	}
-	}
-}
-
-void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpgquery::PGList> options) {
-	if (!options) {
-		return;
-	}
-
-	duckdb_libpgquery::PGListCell *cell;
-	// iterate over each option
-	for_each_cell(cell, options->head) {
-		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-		if (StringUtil::Lower(def_elem->defname) == "format") {
-			// format specifier: interpret this option
-			auto format_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (!format_val || format_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet'");
-			}
-			info.format = StringUtil::Lower(format_val->val.str);
-			continue;
-		}
-
-		// The rest ends up in the options
-		string name = def_elem->defname;
-		ParseGenericOptionListEntry(info.options, name, def_elem->arg);
-	}
-}
-
-unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGCopyStmt &stmt) {
-	auto result = make_uniq<CopyStatement>();
-	auto &info = *result->info;
-
-	// get file_path and is_from
-	info.is_from = stmt.is_from;
-	if (!stmt.filename) {
-		// stdin/stdout
-		info.file_path = info.is_from ? "/dev/stdin" : "/dev/stdout";
-	} else {
-		// copy to a file
-		info.file_path = stmt.filename;
-	}
-
-	if (ReplacementScan::CanReplace(info.file_path, {"parquet"})) {
-		info.format = "parquet";
-	} else if (ReplacementScan::CanReplace(info.file_path, {"json", "jsonl", "ndjson"})) {
-		info.format = "json";
-	} else {
-		info.format = "csv";
-	}
-
-	// get select_list
-	if (stmt.attlist) {
-		for (auto n = stmt.attlist->head; n != nullptr; n = n->next) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(n->data.ptr_value);
-			if (target->name) {
-				info.select_list.emplace_back(target->name);
-			}
-		}
-	}
-
-	if (stmt.relation) {
-		auto ref = TransformRangeVar(*stmt.relation);
-		auto &table = ref->Cast<BaseTableRef>();
-		info.table = table.table_name;
-		info.schema = table.schema_name;
-		info.catalog = table.catalog_name;
-	} else {
-		info.select_statement = TransformSelectNode(*stmt.query);
-	}
-
-	// handle the different options of the COPY statement
-	TransformCopyOptions(info, stmt.options);
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_copy_database.cpp b/src/duckdb/src/parser/transform/statement/transform_copy_database.cpp
deleted file mode 100644
index 6d8dd0d11..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_copy_database.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/parser/statement/copy_database_statement.hpp"
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformCopyDatabase(duckdb_libpgquery::PGCopyDatabaseStmt &stmt) {
-	if (stmt.copy_database_flag) {
-		// copy a specific subset of the database
-		CopyDatabaseType type;
-		if (StringUtil::Equals(stmt.copy_database_flag, "schema")) {
-			type = CopyDatabaseType::COPY_SCHEMA;
-		} else if (StringUtil::Equals(stmt.copy_database_flag, "data")) {
-			type = CopyDatabaseType::COPY_DATA;
-		} else {
-			throw NotImplementedException("Unsupported flag for COPY DATABASE");
-		}
-		return make_uniq<CopyDatabaseStatement>(stmt.from_database, stmt.to_database, type);
-	} else {
-		auto result = make_uniq<PragmaStatement>();
-		result->info->name = "copy_database";
-		result->info->parameters.emplace_back(make_uniq<ConstantExpression>(Value(stmt.from_database)));
-		result->info->parameters.emplace_back(make_uniq<ConstantExpression>(Value(stmt.to_database)));
-		return std::move(result);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_function.cpp b/src/duckdb/src/parser/transform/statement/transform_create_function.cpp
deleted file mode 100644
index 6fdb68aab..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_function.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "duckdb/function/scalar_macro_function.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<MacroFunction> Transformer::TransformMacroFunction(duckdb_libpgquery::PGFunctionDefinition &def) {
-	unique_ptr<MacroFunction> macro_func;
-	if (def.function) {
-		auto expression = TransformExpression(def.function);
-		macro_func = make_uniq<ScalarMacroFunction>(std::move(expression));
-	} else if (def.query) {
-		auto query_node = TransformSelectNode(*def.query);
-		macro_func = make_uniq<TableMacroFunction>(std::move(query_node));
-	}
-
-	if (!def.params) {
-		return macro_func;
-	}
-	vector<unique_ptr<ParsedExpression>> parameters;
-	TransformExpressionList(*def.params, parameters);
-	for (auto &param : parameters) {
-		Value const_param;
-		if (ConstructConstantFromExpression(*param, const_param)) {
-			// parameters with default value (must have an alias)
-			if (param->GetAlias().empty()) {
-				throw ParserException("Invalid parameter: '%s'", param->ToString());
-			}
-			if (macro_func->default_parameters.find(param->GetAlias()) != macro_func->default_parameters.end()) {
-				throw ParserException("Duplicate default parameter: '%s'", param->GetAlias());
-			}
-			auto constructed_constant = make_uniq<ConstantExpression>(std::move(const_param));
-			constructed_constant->SetAlias(param->GetAlias());
-			macro_func->default_parameters[param->GetAlias()] = std::move(constructed_constant);
-		} else if (param->GetExpressionClass() == ExpressionClass::COLUMN_REF) {
-			// positional parameters
-			if (!macro_func->default_parameters.empty()) {
-				throw ParserException("Positional parameters cannot come after parameters with a default value!");
-			}
-			macro_func->parameters.push_back(std::move(param));
-		} else {
-			throw ParserException("Invalid parameter: '%s'", param->ToString());
-		}
-	}
-	return macro_func;
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgquery::PGCreateFunctionStmt &stmt) {
-	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGCreateFunctionStmt);
-	D_ASSERT(stmt.functions);
-
-	auto result = make_uniq<CreateStatement>();
-	auto qname = TransformQualifiedName(*stmt.name);
-
-	vector<unique_ptr<MacroFunction>> macros;
-	for (auto c = stmt.functions->head; c != nullptr; c = lnext(c)) {
-		auto &function_def = *PGPointerCast<duckdb_libpgquery::PGFunctionDefinition>(c->data.ptr_value);
-		macros.push_back(TransformMacroFunction(function_def));
-	}
-	PivotEntryCheck("macro");
-
-	auto catalog_type =
-	    macros[0]->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY;
-	auto info = make_uniq<CreateMacroInfo>(catalog_type);
-	info->catalog = qname.catalog;
-	info->schema = qname.schema;
-	info->name = qname.name;
-
-	// temporary macro
-	switch (stmt.name->relpersistence) {
-	case duckdb_libpgquery::PG_RELPERSISTENCE_TEMP:
-		info->temporary = true;
-		break;
-	case duckdb_libpgquery::PG_RELPERSISTENCE_UNLOGGED:
-		throw ParserException("Unlogged flag not supported for macros: '%s'", qname.name);
-	case duckdb_libpgquery::RELPERSISTENCE_PERMANENT:
-		info->temporary = false;
-		break;
-	default:
-		throw ParserException("Unsupported persistence flag for table '%s'", qname.name);
-	}
-
-	// what to do on conflict
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-	info->macros = std::move(macros);
-
-	result->info = std::move(info);
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_index.cpp b/src/duckdb/src/parser/transform/statement/transform_create_index.cpp
deleted file mode 100644
index 3b13d53ce..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_index.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-vector<unique_ptr<ParsedExpression>> Transformer::TransformIndexParameters(duckdb_libpgquery::PGList &list,
-                                                                           const string &relation_name) {
-	vector<unique_ptr<ParsedExpression>> expressions;
-	for (auto cell = list.head; cell != nullptr; cell = cell->next) {
-		auto index_element = PGPointerCast<duckdb_libpgquery::PGIndexElem>(cell->data.ptr_value);
-		if (index_element->collation) {
-			throw NotImplementedException("Index with collation not supported yet!");
-		}
-		if (index_element->opclass) {
-			throw NotImplementedException("Index with opclass not supported yet!");
-		}
-
-		if (index_element->name) {
-			// create a column reference expression
-			expressions.push_back(make_uniq<ColumnRefExpression>(index_element->name, relation_name));
-		} else {
-			// parse the index expression
-			D_ASSERT(index_element->expr);
-			expressions.push_back(TransformExpression(index_element->expr));
-		}
-	}
-	return expressions;
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery::PGIndexStmt &stmt) {
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateIndexInfo>();
-	if (stmt.unique) {
-		info->constraint_type = IndexConstraintType::UNIQUE;
-	} else {
-		info->constraint_type = IndexConstraintType::NONE;
-	}
-
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
-
-	info->index_type = StringUtil::Upper(string(stmt.accessMethod));
-
-	if (stmt.relation->schemaname) {
-		info->schema = stmt.relation->schemaname;
-	}
-	if (stmt.relation->catalogname) {
-		info->catalog = stmt.relation->catalogname;
-	}
-	info->table = stmt.relation->relname;
-	if (stmt.idxname) {
-		info->index_name = stmt.idxname;
-	} else {
-		throw NotImplementedException("Please provide an index name, e.g., CREATE INDEX my_name ...");
-	}
-
-	// Parse the options list
-	if (stmt.options) {
-		duckdb_libpgquery::PGListCell *cell;
-		for_each_cell(cell, stmt.options->head) {
-			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-			Value val;
-			if (def_elem->arg) {
-				val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
-			} else {
-				val = Value::BOOLEAN(true);
-			}
-			info->options[StringUtil::Lower(def_elem->defname)] = std::move(val);
-		}
-	}
-
-	for (auto &expr : info->expressions) {
-		info->parsed_expressions.emplace_back(expr->Copy());
-	}
-	if (stmt.whereClause) {
-		throw NotImplementedException("Creating partial indexes is not supported currently");
-	}
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_schema.cpp b/src/duckdb/src/parser/transform/statement/transform_create_schema.cpp
deleted file mode 100644
index 0dc343abf..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_schema.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateSchema(duckdb_libpgquery::PGCreateSchemaStmt &stmt) {
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateSchemaInfo>();
-
-	D_ASSERT(stmt.schemaname);
-	info->catalog = stmt.catalogname ? stmt.catalogname : INVALID_CATALOG;
-	info->schema = stmt.schemaname;
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-
-	if (stmt.schemaElts) {
-		// schema elements
-		for (auto cell = stmt.schemaElts->head; cell != nullptr; cell = cell->next) {
-			auto node = PGPointerCast<duckdb_libpgquery::PGNode>(cell->data.ptr_value);
-			switch (node->type) {
-			case duckdb_libpgquery::T_PGCreateStmt:
-			case duckdb_libpgquery::T_PGViewStmt:
-			default:
-				throw NotImplementedException("Schema element not supported yet!");
-			}
-		}
-	}
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_sequence.cpp b/src/duckdb/src/parser/transform/statement/transform_create_sequence.cpp
deleted file mode 100644
index 50e3c3f4d..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_sequence.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/enum_class_hash.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgquery::PGCreateSeqStmt &stmt) {
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateSequenceInfo>();
-
-	auto qname = TransformQualifiedName(*stmt.sequence);
-	info->catalog = qname.catalog;
-	info->schema = qname.schema;
-	info->name = qname.name;
-
-	if (stmt.options) {
-		int64_t default_start_value = info->start_value;
-		bool has_start_value = false;
-		unordered_set<SequenceInfo, EnumClassHash> used;
-		duckdb_libpgquery::PGListCell *cell = nullptr;
-		for_each_cell(cell, stmt.options->head) {
-			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-			string opt_name = string(def_elem->defname);
-			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			bool nodef = def_elem->defaction == duckdb_libpgquery::PG_DEFELEM_UNSPEC && !val; // e.g. NO MINVALUE
-			int64_t opt_value = 0;
-
-			if (val) {
-				if (val->type == duckdb_libpgquery::T_PGInteger) {
-					opt_value = val->val.ival;
-				} else if (val->type == duckdb_libpgquery::T_PGFloat) {
-					if (!TryCast::Operation<string_t, int64_t>(string_t(val->val.str), opt_value, true)) {
-						throw ParserException("Expected an integer argument for option %s", opt_name);
-					}
-				} else {
-					throw ParserException("Expected an integer argument for option %s", opt_name);
-				}
-			}
-			if (opt_name == "increment") {
-				if (used.find(SequenceInfo::SEQ_INC) != used.end()) {
-					throw ParserException("Increment value should be passed as most once");
-				}
-				used.insert(SequenceInfo::SEQ_INC);
-				if (nodef) {
-					continue;
-				}
-
-				info->increment = opt_value;
-				if (info->increment == 0) {
-					throw ParserException("Increment must not be zero");
-				}
-				if (info->increment < 0) {
-					default_start_value = info->max_value = -1;
-					info->min_value = NumericLimits<int64_t>::Minimum();
-				} else {
-					default_start_value = info->min_value = 1;
-					info->max_value = NumericLimits<int64_t>::Maximum();
-				}
-			} else if (opt_name == "minvalue") {
-				if (used.find(SequenceInfo::SEQ_MIN) != used.end()) {
-					throw ParserException("Minvalue should be passed as most once");
-				}
-				used.insert(SequenceInfo::SEQ_MIN);
-				if (nodef) {
-					continue;
-				}
-
-				info->min_value = opt_value;
-				if (info->increment > 0) {
-					default_start_value = info->min_value;
-				}
-			} else if (opt_name == "maxvalue") {
-				if (used.find(SequenceInfo::SEQ_MAX) != used.end()) {
-					throw ParserException("Maxvalue should be passed as most once");
-				}
-				used.insert(SequenceInfo::SEQ_MAX);
-				if (nodef) {
-					continue;
-				}
-
-				info->max_value = opt_value;
-				if (info->increment < 0) {
-					default_start_value = info->max_value;
-				}
-			} else if (opt_name == "start") {
-				if (used.find(SequenceInfo::SEQ_START) != used.end()) {
-					throw ParserException("Start value should be passed as most once");
-				}
-				used.insert(SequenceInfo::SEQ_START);
-				if (nodef) {
-					continue;
-				}
-				has_start_value = true;
-				info->start_value = opt_value;
-			} else if (opt_name == "cycle") {
-				if (used.find(SequenceInfo::SEQ_CYCLE) != used.end()) {
-					throw ParserException("Cycle value should be passed as most once");
-				}
-				used.insert(SequenceInfo::SEQ_CYCLE);
-				if (nodef) {
-					continue;
-				}
-
-				info->cycle = opt_value > 0;
-			} else {
-				throw ParserException("Unrecognized option \"%s\" for CREATE SEQUENCE", opt_name);
-			}
-		}
-		if (!has_start_value) {
-			info->start_value = default_start_value;
-		}
-	}
-	info->temporary = !stmt.sequence->relpersistence;
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-	if (info->max_value <= info->min_value) {
-		throw ParserException("MINVALUE (%lld) must be less than MAXVALUE (%lld)", info->min_value, info->max_value);
-	}
-	if (info->start_value < info->min_value) {
-		throw ParserException("START value (%lld) cannot be less than MINVALUE (%lld)", info->start_value,
-		                      info->min_value);
-	}
-	if (info->start_value > info->max_value) {
-		throw ParserException("START value (%lld) cannot be greater than MAXVALUE (%lld)", info->start_value,
-		                      info->max_value);
-	}
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_table.cpp b/src/duckdb/src/parser/transform/statement/transform_create_table.cpp
deleted file mode 100644
index 412a73cd3..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_table.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/parser/constraint.hpp"
-#include "duckdb/parser/expression/collate_expression.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-string Transformer::TransformCollation(optional_ptr<duckdb_libpgquery::PGCollateClause> collate) {
-	if (!collate) {
-		return string();
-	}
-	string collation;
-	for (auto c = collate->collname->head; c != nullptr; c = lnext(c)) {
-		auto pgvalue = PGPointerCast<duckdb_libpgquery::PGValue>(c->data.ptr_value);
-		if (pgvalue->type != duckdb_libpgquery::T_PGString) {
-			throw ParserException("Expected a string as collation type!");
-		}
-		auto collation_argument = string(pgvalue->val.str);
-		if (collation.empty()) {
-			collation = collation_argument;
-		} else {
-			collation += "." + collation_argument;
-		}
-	}
-	return collation;
-}
-
-OnCreateConflict Transformer::TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict) {
-	switch (conflict) {
-	case duckdb_libpgquery::PG_ERROR_ON_CONFLICT:
-		return OnCreateConflict::ERROR_ON_CONFLICT;
-	case duckdb_libpgquery::PG_IGNORE_ON_CONFLICT:
-		return OnCreateConflict::IGNORE_ON_CONFLICT;
-	case duckdb_libpgquery::PG_REPLACE_ON_CONFLICT:
-		return OnCreateConflict::REPLACE_ON_CONFLICT;
-	default:
-		throw InternalException("Unrecognized OnConflict type");
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformCollateExpr(duckdb_libpgquery::PGCollateClause &collate) {
-	auto child = TransformExpression(collate.arg);
-	auto collation = TransformCollation(&collate);
-	return make_uniq<CollateExpression>(collation, std::move(child));
-}
-
-ColumnDefinition Transformer::TransformColumnDefinition(duckdb_libpgquery::PGColumnDef &cdef) {
-	string name;
-	if (cdef.colname) {
-		name = cdef.colname;
-	}
-
-	auto optional_type = cdef.category == duckdb_libpgquery::COL_GENERATED;
-	LogicalType target_type;
-	if (optional_type && !cdef.typeName) {
-		target_type = LogicalType::ANY;
-	} else if (!cdef.typeName) {
-		// ALTER TABLE tbl ALTER TYPE USING ...
-		target_type = LogicalType::UNKNOWN;
-	} else {
-		target_type = TransformTypeName(*cdef.typeName);
-	}
-
-	if (cdef.collClause) {
-		if (cdef.category == duckdb_libpgquery::COL_GENERATED) {
-			throw ParserException("Collations are not supported on generated columns");
-		}
-		if (target_type.id() != LogicalTypeId::VARCHAR) {
-			throw ParserException("Only VARCHAR columns can have collations!");
-		}
-		target_type = LogicalType::VARCHAR_COLLATION(TransformCollation(cdef.collClause));
-	}
-
-	return ColumnDefinition(name, target_type);
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateTable(duckdb_libpgquery::PGCreateStmt &stmt) {
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateTableInfo>();
-
-	if (stmt.inhRelations) {
-		throw NotImplementedException("inherited relations not implemented");
-	}
-	D_ASSERT(stmt.relation);
-
-	info->catalog = INVALID_CATALOG;
-	auto qname = TransformQualifiedName(*stmt.relation);
-	info->catalog = qname.catalog;
-	info->schema = qname.schema;
-	info->table = qname.name;
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-	info->temporary =
-	    stmt.relation->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
-
-	if (info->temporary && stmt.oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_PRESERVE_ROWS &&
-	    stmt.oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_NOOP) {
-		throw NotImplementedException("Only ON COMMIT PRESERVE ROWS is supported");
-	}
-	if (!stmt.tableElts) {
-		throw ParserException("Table must have at least one column!");
-	}
-
-	idx_t column_count = 0;
-	for (auto c = stmt.tableElts->head; c != nullptr; c = lnext(c)) {
-		auto node = PGPointerCast<duckdb_libpgquery::PGNode>(c->data.ptr_value);
-		switch (node->type) {
-		case duckdb_libpgquery::T_PGColumnDef: {
-			auto pg_col_def = PGPointerCast<duckdb_libpgquery::PGColumnDef>(c->data.ptr_value);
-			auto col_def = TransformColumnDefinition(*pg_col_def);
-
-			if (pg_col_def->constraints) {
-				for (auto cell = pg_col_def->constraints->head; cell != nullptr; cell = cell->next) {
-					auto pg_constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(cell->data.ptr_value);
-					auto constraint = TransformConstraint(*pg_constraint, col_def, info->columns.LogicalColumnCount());
-					if (constraint) {
-						info->constraints.push_back(std::move(constraint));
-					}
-				}
-			}
-
-			info->columns.AddColumn(std::move(col_def));
-			column_count++;
-			break;
-		}
-		case duckdb_libpgquery::T_PGConstraint: {
-			auto pg_constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(c->data.ptr_value);
-			info->constraints.push_back(TransformConstraint(*pg_constraint));
-			break;
-		}
-		default:
-			throw NotImplementedException("ColumnDef type not handled yet");
-		}
-	}
-
-	if (!column_count) {
-		throw ParserException("Table must have at least one column!");
-	}
-
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp b/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp
deleted file mode 100644
index 3770194a7..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateTableAs(duckdb_libpgquery::PGCreateTableAsStmt &stmt) {
-	if (stmt.relkind == duckdb_libpgquery::PG_OBJECT_MATVIEW) {
-		throw NotImplementedException("Materialized view not implemented");
-	}
-	if (stmt.is_select_into || stmt.into->options) {
-		throw NotImplementedException("Unimplemented features for CREATE TABLE as");
-	}
-	if (stmt.query->type != duckdb_libpgquery::T_PGSelectStmt) {
-		throw ParserException("CREATE TABLE AS requires a SELECT clause");
-	}
-
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateTableInfo>();
-	auto qname = TransformQualifiedName(*stmt.into->rel);
-	auto query = TransformSelectStmt(*stmt.query, false);
-
-	if (stmt.into->colNames) {
-		auto cols = TransformStringList(stmt.into->colNames);
-		for (idx_t i = 0; i < cols.size(); i++) {
-			// We really don't know the type of the columns during parsing, so we just use UNKNOWN
-			info->columns.AddColumn(ColumnDefinition(cols[i], LogicalType::UNKNOWN));
-		}
-	}
-	info->catalog = qname.catalog;
-	info->schema = qname.schema;
-	info->table = qname.name;
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-	info->temporary =
-	    stmt.into->rel->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
-	info->query = std::move(query);
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_type.cpp b/src/duckdb/src/parser/transform/statement/transform_create_type.cpp
deleted file mode 100644
index 3b6753b6b..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_type.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-Vector Transformer::PGListToVector(optional_ptr<duckdb_libpgquery::PGList> column_list, idx_t &size) {
-	if (!column_list) {
-		Vector result(LogicalType::VARCHAR);
-		return result;
-	}
-	// First we discover the size of this list
-	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		size++;
-	}
-
-	Vector result(LogicalType::VARCHAR, size);
-	auto result_ptr = FlatVector::GetData<string_t>(result);
-
-	size = 0;
-	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		auto &type_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(c->data.ptr_value);
-		auto &entry_value_node = type_val.val;
-		if (entry_value_node.type != duckdb_libpgquery::T_PGString) {
-			throw ParserException("Expected a string constant as value");
-		}
-
-		auto entry_value = string(entry_value_node.val.str);
-		D_ASSERT(!entry_value.empty());
-		result_ptr[size++] = StringVector::AddStringOrBlob(result, entry_value);
-	}
-	return result;
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::PGCreateTypeStmt &stmt) {
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateTypeInfo>();
-
-	auto qualified_name = TransformQualifiedName(*stmt.typeName);
-	info->catalog = qualified_name.catalog;
-	info->schema = qualified_name.schema;
-	info->name = qualified_name.name;
-
-	switch (stmt.kind) {
-	case duckdb_libpgquery::PG_NEWTYPE_ENUM: {
-		info->internal = false;
-		if (stmt.query) {
-			// CREATE TYPE mood AS ENUM (SELECT ...)
-			D_ASSERT(stmt.vals == nullptr);
-			auto query = TransformSelectStmt(*stmt.query, false);
-			info->query = std::move(query);
-			info->type = LogicalType::INVALID;
-		} else {
-			D_ASSERT(stmt.query == nullptr);
-			idx_t size = 0;
-			auto ordered_array = PGListToVector(stmt.vals, size);
-			info->type = LogicalType::ENUM(ordered_array, size);
-		}
-	} break;
-
-	case duckdb_libpgquery::PG_NEWTYPE_ALIAS: {
-		LogicalType target_type = TransformTypeName(*stmt.ofType);
-		info->type = target_type;
-	} break;
-
-	default:
-		throw InternalException("Unknown kind of new type");
-	}
-	result->info = std::move(info);
-	return result;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_create_view.cpp b/src/duckdb/src/parser/transform/statement/transform_create_view.cpp
deleted file mode 100644
index 24a26c022..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_create_view.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::PGViewStmt &stmt) {
-	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGViewStmt);
-	D_ASSERT(stmt.view);
-
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateViewInfo>();
-
-	auto qname = TransformQualifiedName(*stmt.view);
-	info->catalog = qname.catalog;
-	info->schema = qname.schema;
-	info->view_name = qname.name;
-	info->temporary = !stmt.view->relpersistence;
-	if (info->temporary && IsInvalidCatalog(info->catalog)) {
-		info->catalog = TEMP_CATALOG;
-	}
-	info->on_conflict = TransformOnConflict(stmt.onconflict);
-
-	info->query = TransformSelectStmt(*stmt.query, false);
-
-	PivotEntryCheck("view");
-
-	if (stmt.aliases && stmt.aliases->length > 0) {
-		for (auto c = stmt.aliases->head; c != nullptr; c = lnext(c)) {
-			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(c->data.ptr_value);
-			switch (val->type) {
-			case duckdb_libpgquery::T_PGString: {
-				info->aliases.emplace_back(val->val.str);
-				break;
-			}
-			default:
-				throw NotImplementedException("View projection type");
-			}
-		}
-		if (info->aliases.empty()) {
-			throw ParserException("Need at least one column name in CREATE VIEW projection list");
-		}
-	}
-
-	if (stmt.options && stmt.options->length > 0) {
-		throw NotImplementedException("VIEW options");
-	}
-
-	if (stmt.withCheckOption != duckdb_libpgquery::PGViewCheckOption::PG_NO_CHECK_OPTION) {
-		throw NotImplementedException("VIEW CHECK options");
-	}
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_delete.cpp b/src/duckdb/src/parser/transform/statement/transform_delete.cpp
deleted file mode 100644
index 1a185968a..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_delete.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/parser/statement/delete_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGDeleteStmt &stmt) {
-	auto result = make_uniq<DeleteStatement>();
-	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
-	}
-
-	result->condition = TransformExpression(stmt.whereClause);
-	result->table = TransformRangeVar(*stmt.relation);
-	if (result->table->type != TableReferenceType::BASE_TABLE) {
-		throw InvalidInputException("Can only delete from base tables!");
-	}
-	if (stmt.usingClause) {
-		for (auto n = stmt.usingClause->head; n != nullptr; n = n->next) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(n->data.ptr_value);
-			auto using_entry = TransformTableRefNode(*target);
-			result->using_clauses.push_back(std::move(using_entry));
-		}
-	}
-
-	if (stmt.returningList) {
-		TransformExpressionList(*stmt.returningList, result->returning_list);
-	}
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_detach.cpp b/src/duckdb/src/parser/transform/statement/transform_detach.cpp
deleted file mode 100644
index 8a3e00bdf..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_detach.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/statement/detach_statement.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGDetachStmt &stmt) {
-	auto result = make_uniq<DetachStatement>();
-	auto info = make_uniq<DetachInfo>();
-	info->name = stmt.db_name;
-	info->if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
-
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_drop.cpp b/src/duckdb/src/parser/transform/statement/transform_drop.cpp
deleted file mode 100644
index 13ebcaa8e..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_drop.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGDropStmt &stmt) {
-	auto result = make_uniq<DropStatement>();
-	auto &info = *result->info.get();
-	if (stmt.objects->length != 1) {
-		throw NotImplementedException("Can only drop one object at a time");
-	}
-	switch (stmt.removeType) {
-	case duckdb_libpgquery::PG_OBJECT_TABLE:
-		info.type = CatalogType::TABLE_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_SCHEMA:
-		info.type = CatalogType::SCHEMA_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_INDEX:
-		info.type = CatalogType::INDEX_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_VIEW:
-		info.type = CatalogType::VIEW_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_SEQUENCE:
-		info.type = CatalogType::SEQUENCE_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_FUNCTION:
-		info.type = CatalogType::MACRO_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TABLE_MACRO:
-		info.type = CatalogType::TABLE_MACRO_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TYPE:
-		info.type = CatalogType::TYPE_ENTRY;
-		break;
-	default:
-		throw NotImplementedException("Cannot drop this type yet");
-	}
-
-	switch (stmt.removeType) {
-	case duckdb_libpgquery::PG_OBJECT_SCHEMA: {
-		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects->head->data.ptr_value);
-		if (view_list->length == 2) {
-			info.catalog = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
-			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->data.ptr_value)->val.str;
-		} else if (view_list->length == 1) {
-			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
-		} else {
-			throw ParserException("Expected \"catalog.schema\" or \"schema\"");
-		}
-		break;
-	}
-	default: {
-		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects->head->data.ptr_value);
-		if (view_list->length == 3) {
-			info.catalog = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
-			info.schema = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->data.ptr_value)->val.str;
-			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->next->data.ptr_value)->val.str;
-		} else if (view_list->length == 2) {
-			info.schema = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
-			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->data.ptr_value)->val.str;
-		} else if (view_list->length == 1) {
-			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
-		} else {
-			throw ParserException("Expected \"catalog.schema.name\", \"schema.name\"or \"name\"");
-		}
-		break;
-	}
-	}
-	info.cascade = stmt.behavior == duckdb_libpgquery::PGDropBehavior::PG_DROP_CASCADE;
-	info.if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
-	return std::move(result);
-}
-
-unique_ptr<DropStatement> Transformer::TransformDropSecret(duckdb_libpgquery::PGDropSecretStmt &stmt) {
-	auto result = make_uniq<DropStatement>();
-	auto info = make_uniq<DropInfo>();
-	auto extra_info = make_uniq<ExtraDropSecretInfo>();
-
-	info->type = CatalogType::SECRET_ENTRY;
-	info->name = stmt.secret_name;
-	info->if_not_found = stmt.missing_ok ? OnEntryNotFound::RETURN_NULL : OnEntryNotFound::THROW_EXCEPTION;
-
-	extra_info->persist_mode = EnumUtil::FromString<SecretPersistType>(StringUtil::Upper(stmt.persist_type));
-	extra_info->secret_storage = stmt.secret_storage;
-
-	if (extra_info->persist_mode == SecretPersistType::TEMPORARY) {
-		if (!extra_info->secret_storage.empty()) {
-			throw ParserException("Can not combine TEMPORARY with specifying a storage for drop secret");
-		}
-	}
-
-	info->extra_drop_info = std::move(extra_info);
-	result->info = std::move(info);
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_explain.cpp b/src/duckdb/src/parser/transform/statement/transform_explain.cpp
deleted file mode 100644
index 1909e1599..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_explain.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-ExplainFormat ParseFormat(const Value &val) {
-	if (val.type().id() != LogicalTypeId::VARCHAR) {
-		throw InvalidInputException("Expected a string as argument to FORMAT");
-	}
-	auto format_val = val.GetValue<string>();
-	case_insensitive_map_t<ExplainFormat> format_mapping {
-	    {"default", ExplainFormat::DEFAULT}, {"text", ExplainFormat::TEXT},         {"json", ExplainFormat::JSON},
-	    {"html", ExplainFormat::HTML},       {"graphviz", ExplainFormat::GRAPHVIZ},
-	};
-	auto it = format_mapping.find(format_val);
-	if (it != format_mapping.end()) {
-		return it->second;
-	}
-	vector<string> options_list;
-	for (auto &it : format_mapping) {
-		options_list.push_back(it.first);
-	}
-	auto allowed_options = StringUtil::Join(options_list, ", ");
-	throw InvalidInputException("\"%s\" is not a valid FORMAT argument, valid options are: %s", format_val,
-	                            allowed_options);
-}
-
-unique_ptr<ExplainStatement> Transformer::TransformExplain(duckdb_libpgquery::PGExplainStmt &stmt) {
-	auto explain_type = ExplainType::EXPLAIN_STANDARD;
-	auto explain_format = ExplainFormat::DEFAULT;
-	bool format_is_set = false;
-	if (stmt.options) {
-		for (auto n = stmt.options->head; n; n = n->next) {
-			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(n->data.ptr_value);
-			auto def_name = def_elem->defname;
-			auto elem = StringUtil::Lower(def_name);
-			if (elem == "analyze") {
-				explain_type = ExplainType::EXPLAIN_ANALYZE;
-			} else if (elem == "format") {
-				if (def_elem->arg) {
-					if (format_is_set) {
-						throw InvalidInputException("FORMAT can not be provided more than once");
-					}
-					auto val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
-					format_is_set = true;
-					explain_format = ParseFormat(val);
-				}
-			} else {
-				throw NotImplementedException("Unimplemented explain type: %s", elem);
-			}
-		}
-	}
-	return make_uniq<ExplainStatement>(TransformStatement(*stmt.query), explain_type, explain_format);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_export.cpp b/src/duckdb/src/parser/transform/statement/transform_export.cpp
deleted file mode 100644
index 24c819da6..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_export.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/parser/statement/export_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<ExportStatement> Transformer::TransformExport(duckdb_libpgquery::PGExportStmt &stmt) {
-	auto info = make_uniq<CopyInfo>();
-	info->file_path = stmt.filename;
-	info->format = "csv";
-	info->is_from = false;
-	// handle export options
-	TransformCopyOptions(*info, stmt.options);
-
-	auto result = make_uniq<ExportStatement>(std::move(info));
-	if (stmt.database) {
-		result->database = stmt.database;
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_import.cpp b/src/duckdb/src/parser/transform/statement/transform_import.cpp
deleted file mode 100644
index 48077e291..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_import.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<PragmaStatement> Transformer::TransformImport(duckdb_libpgquery::PGImportStmt &stmt) {
-	auto result = make_uniq<PragmaStatement>();
-	result->info->name = "import_database";
-	result->info->parameters.emplace_back(make_uniq<ConstantExpression>(Value(stmt.filename)));
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_insert.cpp b/src/duckdb/src/parser/transform/statement/transform_insert.cpp
deleted file mode 100644
index 57c895cf7..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_insert.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList *list) {
-	auto result = make_uniq<ExpressionListRef>();
-	for (auto value_list = list->head; value_list != nullptr; value_list = value_list->next) {
-		auto target = PGPointerCast<duckdb_libpgquery::PGList>(value_list->data.ptr_value);
-
-		vector<unique_ptr<ParsedExpression>> insert_values;
-		TransformExpressionList(*target, insert_values);
-		if (!result->values.empty()) {
-			if (result->values[0].size() != insert_values.size()) {
-				throw ParserException("VALUES lists must all be the same length");
-			}
-		}
-		result->values.push_back(std::move(insert_values));
-	}
-	result->alias = "valueslist";
-	return std::move(result);
-}
-
-unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt) {
-	auto result = make_uniq<InsertStatement>();
-	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
-	}
-
-	// first check if there are any columns specified
-	if (stmt.cols) {
-		for (auto c = stmt.cols->head; c != nullptr; c = lnext(c)) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
-			result->columns.emplace_back(target->name);
-		}
-	}
-
-	// Grab and transform the returning columns from the parser.
-	if (stmt.returningList) {
-		TransformExpressionList(*stmt.returningList, result->returning_list);
-	}
-	if (stmt.selectStmt) {
-		result->select_statement = TransformSelectStmt(*stmt.selectStmt, false);
-	} else {
-		result->default_values = true;
-	}
-
-	auto qname = TransformQualifiedName(*stmt.relation);
-	result->table = qname.name;
-	result->schema = qname.schema;
-
-	if (stmt.onConflictClause) {
-		if (stmt.onConflictAlias != duckdb_libpgquery::PG_ONCONFLICT_ALIAS_NONE) {
-			// OR REPLACE | OR IGNORE are shorthands for the ON CONFLICT clause
-			throw ParserException("You can not provide both OR REPLACE|IGNORE and an ON CONFLICT clause, please remove "
-			                      "the first if you want to have more granual control");
-		}
-		result->on_conflict_info = TransformOnConflictClause(stmt.onConflictClause, result->schema);
-		result->table_ref = TransformRangeVar(*stmt.relation);
-	}
-	if (stmt.onConflictAlias != duckdb_libpgquery::PG_ONCONFLICT_ALIAS_NONE) {
-		D_ASSERT(!stmt.onConflictClause);
-		result->on_conflict_info = DummyOnConflictClause(stmt.onConflictAlias, result->schema);
-		result->table_ref = TransformRangeVar(*stmt.relation);
-	}
-	switch (stmt.insert_column_order) {
-	case duckdb_libpgquery::PG_INSERT_BY_POSITION:
-		result->column_order = InsertColumnOrder::INSERT_BY_POSITION;
-		break;
-	case duckdb_libpgquery::PG_INSERT_BY_NAME:
-		result->column_order = InsertColumnOrder::INSERT_BY_NAME;
-		break;
-	default:
-		throw InternalException("Unrecognized insert column order in TransformInsert");
-	}
-	result->catalog = qname.catalog;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_load.cpp b/src/duckdb/src/parser/transform/statement/transform_load.cpp
deleted file mode 100644
index 50ef37837..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_load.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "duckdb/parser/statement/load_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<LoadStatement> Transformer::TransformLoad(duckdb_libpgquery::PGLoadStmt &stmt) {
-	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGLoadStmt);
-
-	auto load_stmt = make_uniq<LoadStatement>();
-	auto load_info = make_uniq<LoadInfo>();
-	load_info->filename = stmt.filename ? string(stmt.filename) : "";
-	load_info->repository = stmt.repository ? string(stmt.repository) : "";
-	load_info->repo_is_alias = stmt.repo_is_alias;
-	load_info->version = stmt.version ? string(stmt.version) : "";
-	switch (stmt.load_type) {
-	case duckdb_libpgquery::PG_LOAD_TYPE_LOAD:
-		load_info->load_type = LoadType::LOAD;
-		break;
-	case duckdb_libpgquery::PG_LOAD_TYPE_INSTALL:
-		load_info->load_type = LoadType::INSTALL;
-		break;
-	case duckdb_libpgquery::PG_LOAD_TYPE_FORCE_INSTALL:
-		load_info->load_type = LoadType::FORCE_INSTALL;
-		break;
-	}
-	load_stmt->info = std::move(load_info);
-	return load_stmt;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp b/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp
deleted file mode 100644
index 94bafd72f..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/multi_statement.hpp"
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/common/types/uuid.hpp"
-
-namespace duckdb {
-
-void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column,
-                                unique_ptr<QueryNode> subquery, bool has_parameters) {
-	if (parent) {
-		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column), std::move(subquery),
-		                      has_parameters);
-		return;
-	}
-	auto result = make_uniq<CreatePivotEntry>();
-	result->enum_name = std::move(enum_name);
-	result->base = std::move(base);
-	result->column = std::move(column);
-	result->subquery = std::move(subquery);
-	result->has_parameters = has_parameters;
-
-	pivot_entries.push_back(std::move(result));
-}
-
-bool Transformer::HasPivotEntries() {
-	return !GetPivotEntries().empty();
-}
-
-idx_t Transformer::PivotEntryCount() {
-	return GetPivotEntries().size();
-}
-
-vector<unique_ptr<Transformer::CreatePivotEntry>> &Transformer::GetPivotEntries() {
-	if (parent) {
-		return parent->GetPivotEntries();
-	}
-	return pivot_entries;
-}
-
-void Transformer::PivotEntryCheck(const string &type) {
-	auto &entries = GetPivotEntries();
-	if (!entries.empty()) {
-		throw ParserException(
-		    "PIVOT statements with pivot elements extracted from the data cannot be used in %ss.\nIn order to use "
-		    "PIVOT in a %s the PIVOT values must be manually specified, e.g.:\nPIVOT ... ON %s IN (val1, val2, ...)",
-		    type, type, entries[0]->column->ToString());
-	}
-}
-unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry) {
-	auto result = make_uniq<CreateStatement>();
-	auto info = make_uniq<CreateTypeInfo>();
-
-	info->temporary = true;
-	info->internal = false;
-	info->catalog = INVALID_CATALOG;
-	info->schema = INVALID_SCHEMA;
-	info->name = std::move(entry->enum_name);
-	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
-
-	// generate the query that will result in the enum creation
-	unique_ptr<QueryNode> subselect;
-	if (!entry->subquery) {
-		auto select_node = std::move(entry->base);
-		auto columnref = entry->column->Copy();
-		auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
-		select_node->select_list.push_back(std::move(cast));
-
-		auto is_not_null =
-		    make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
-		select_node->where_clause = std::move(is_not_null);
-
-		// order by the column
-		select_node->modifiers.push_back(make_uniq<DistinctModifier>());
-		auto modifier = make_uniq<OrderModifier>();
-		modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
-		                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
-		select_node->modifiers.push_back(std::move(modifier));
-		subselect = std::move(select_node);
-	} else {
-		subselect = std::move(entry->subquery);
-	}
-
-	auto select = make_uniq<SelectStatement>();
-	select->node = TransformMaterializedCTE(std::move(subselect));
-	info->query = std::move(select);
-	info->type = LogicalType::INVALID;
-
-	result->info = std::move(info);
-	return std::move(result);
-}
-
-// unique_ptr<SQLStatement> GenerateDropEnumStmt(string enum_name) {
-//	auto result = make_uniq<DropStatement>();
-//	result->info->if_exists = true;
-//	result->info->schema = INVALID_SCHEMA;
-//	result->info->catalog = INVALID_CATALOG;
-//	result->info->name = std::move(enum_name);
-//	result->info->type = CatalogType::TYPE_ENTRY;
-//	return std::move(result);
-//}
-
-unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStatement> statement) {
-	auto result = make_uniq<MultiStatement>();
-	for (auto &pivot : pivot_entries) {
-		if (pivot->has_parameters) {
-			throw ParserException(
-			    "PIVOT statements with pivot elements extracted from the data cannot have parameters in their source.\n"
-			    "In order to use parameters the PIVOT values must be manually specified, e.g.:\n"
-			    "PIVOT ... ON %s IN (val1, val2, ...)",
-			    pivot->column->ToString());
-		}
-		result->statements.push_back(GenerateCreateEnumStmt(std::move(pivot)));
-	}
-	result->statements.push_back(std::move(statement));
-	// FIXME: drop the types again!?
-	//	for(auto &pivot : pivot_entries) {
-	//		result->statements.push_back(GenerateDropEnumStmt(std::move(pivot->enum_name)));
-	//	}
-	return std::move(result);
-}
-
-unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt &select) {
-	auto pivot = select.pivot;
-	auto current_param_count = ParamCount();
-	auto source = TransformTableRefNode(*pivot->source);
-	auto next_param_count = ParamCount();
-	bool has_parameters = next_param_count > current_param_count;
-
-	auto select_node = make_uniq<SelectNode>();
-	// handle the CTEs
-	if (select.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(select.withClause), select_node->cte_map);
-	}
-	if (!pivot->columns) {
-		// no pivot columns - not actually a pivot
-		select_node->from_table = std::move(source);
-		if (pivot->groups) {
-			auto groups = TransformStringList(pivot->groups);
-			GroupingSet set;
-			for (idx_t gr = 0; gr < groups.size(); gr++) {
-				auto &group = groups[gr];
-				auto colref = make_uniq<ColumnRefExpression>(group);
-				select_node->select_list.push_back(colref->Copy());
-				select_node->groups.group_expressions.push_back(std::move(colref));
-				set.insert(gr);
-			}
-			select_node->groups.grouping_sets.push_back(std::move(set));
-		}
-		if (pivot->aggrs) {
-			TransformExpressionList(*pivot->aggrs, select_node->select_list);
-		}
-		// transform order by/limit modifiers
-		TransformModifiers(select, *select_node);
-		return std::move(select_node);
-	}
-
-	// generate CREATE TYPE statements for each of the columns that do not have an IN list
-	bool is_pivot = !pivot->unpivots;
-	auto columns = TransformPivotList(*pivot->columns, is_pivot);
-	for (idx_t c = 0; c < columns.size(); c++) {
-		auto &col = columns[c];
-		if (!col.pivot_enum.empty() || !col.entries.empty()) {
-			continue;
-		}
-		if (col.pivot_expressions.size() != 1) {
-			throw InternalException("PIVOT statement with multiple names in pivot entry!?");
-		}
-		auto enum_name = "__pivot_enum_" + UUID::ToString(UUID::GenerateRandomUUID());
-
-		auto new_select = make_uniq<SelectNode>();
-		ExtractCTEsRecursive(new_select->cte_map);
-		new_select->from_table = source->Copy();
-		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy(), std::move(col.subquery),
-		              has_parameters);
-		col.pivot_enum = enum_name;
-	}
-
-	// generate the actual query, including the pivot
-	select_node->select_list.push_back(make_uniq<StarExpression>());
-
-	auto pivot_ref = make_uniq<PivotRef>();
-	pivot_ref->source = std::move(source);
-	if (pivot->unpivots) {
-		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
-	} else {
-		if (pivot->aggrs) {
-			TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
-		} else {
-			// pivot but no aggregates specified - push a count star
-			vector<unique_ptr<ParsedExpression>> children;
-			auto function = make_uniq<FunctionExpression>("count_star", std::move(children));
-			pivot_ref->aggregates.push_back(std::move(function));
-		}
-	}
-	if (pivot->groups) {
-		pivot_ref->groups = TransformStringList(pivot->groups);
-	}
-	pivot_ref->pivots = std::move(columns);
-	SetQueryLocation(*pivot_ref, pivot->location);
-	select_node->from_table = std::move(pivot_ref);
-	// transform order by/limit modifiers
-	TransformModifiers(select, *select_node);
-
-	return std::move(select_node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_pragma.cpp b/src/duckdb/src/parser/transform/statement/transform_pragma.cpp
deleted file mode 100644
index c0ff7b8cb..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_pragma.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/statement/set_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragmaStmt &stmt) {
-	auto result = make_uniq<PragmaStatement>();
-	auto &info = *result->info;
-
-	info.name = stmt.name;
-	// parse the arguments, if any
-	if (stmt.args) {
-		for (auto cell = stmt.args->head; cell != nullptr; cell = cell->next) {
-			auto node = PGPointerCast<duckdb_libpgquery::PGNode>(cell->data.ptr_value);
-			auto expr = TransformExpression(node);
-
-			if (expr->GetExpressionType() == ExpressionType::COMPARE_EQUAL) {
-				auto &comp = expr->Cast<ComparisonExpression>();
-				if (comp.left->GetExpressionType() != ExpressionType::COLUMN_REF) {
-					throw ParserException("Named parameter requires a column reference on the LHS");
-				}
-				auto &columnref = comp.left->Cast<ColumnRefExpression>();
-				info.named_parameters.insert(make_pair(columnref.GetName(), std::move(comp.right)));
-			} else if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-				auto &colref = expr->Cast<ColumnRefExpression>();
-				if (!colref.IsQualified()) {
-					info.parameters.emplace_back(make_uniq<ConstantExpression>(Value(colref.GetColumnName())));
-				} else {
-					info.parameters.emplace_back(make_uniq<ConstantExpression>(Value(expr->ToString())));
-				}
-			} else {
-				info.parameters.emplace_back(std::move(expr));
-			}
-		}
-	}
-	// now parse the pragma type
-	switch (stmt.kind) {
-	case duckdb_libpgquery::PG_PRAGMA_TYPE_NOTHING: {
-		if (!info.parameters.empty() || !info.named_parameters.empty()) {
-			throw InternalException("PRAGMA statement that is not a call or assignment cannot contain parameters");
-		}
-		break;
-	case duckdb_libpgquery::PG_PRAGMA_TYPE_ASSIGNMENT:
-		if (info.parameters.size() != 1) {
-			throw ParserException("PRAGMA statement with assignment should contain exactly one parameter");
-		}
-		if (!info.named_parameters.empty()) {
-			throw InternalException("PRAGMA statement with assignment cannot have named parameters");
-		}
-		// SQLite does not distinguish between:
-		// "PRAGMA table_info='integers'"
-		// "PRAGMA table_info('integers')"
-		// for compatibility, any pragmas that match the SQLite ones are parsed as calls
-		case_insensitive_set_t sqlite_compat_pragmas {"table_info"};
-		if (sqlite_compat_pragmas.find(info.name) != sqlite_compat_pragmas.end()) {
-			break;
-		}
-		auto set_statement =
-		    make_uniq<SetVariableStatement>(info.name, std::move(info.parameters[0]), SetScope::AUTOMATIC);
-		return std::move(set_statement);
-	}
-	case duckdb_libpgquery::PG_PRAGMA_TYPE_CALL:
-		break;
-	default:
-		throw InternalException("Unknown pragma type");
-	}
-
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_prepare.cpp b/src/duckdb/src/parser/transform/statement/transform_prepare.cpp
deleted file mode 100644
index 9c1fc9ba2..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_prepare.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/parser/statement/execute_statement.hpp"
-#include "duckdb/parser/statement/prepare_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PGPrepareStmt &stmt) {
-	if (stmt.argtypes && stmt.argtypes->length > 0) {
-		throw NotImplementedException("Prepared statement argument types are not supported, use CAST");
-	}
-
-	auto result = make_uniq<PrepareStatement>();
-	result->name = string(stmt.name);
-	result->statement = TransformStatement(*stmt.query);
-	ClearParameters();
-
-	return result;
-}
-
-static string NotAcceptedExpressionException() {
-	return "Only scalar parameters, named parameters or NULL supported for EXECUTE";
-}
-
-unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PGExecuteStmt &stmt) {
-	auto result = make_uniq<ExecuteStatement>();
-	result->name = string(stmt.name);
-
-	vector<unique_ptr<ParsedExpression>> intermediate_values;
-	if (stmt.params) {
-		TransformExpressionList(*stmt.params, intermediate_values);
-	}
-
-	idx_t param_idx = 0;
-	for (idx_t i = 0; i < intermediate_values.size(); i++) {
-		auto &expr = intermediate_values[i];
-		if (!expr->IsScalar()) {
-			throw InvalidInputException(NotAcceptedExpressionException());
-		}
-		if (!expr->GetAlias().empty() && param_idx != 0) {
-			// Found unnamed parameters mixed with named parameters
-			throw NotImplementedException("Mixing named parameters and positional parameters is not supported yet");
-		}
-		auto param_name = expr->GetAlias();
-		if (expr->GetAlias().empty()) {
-			param_name = std::to_string(param_idx + 1);
-			if (param_idx != i) {
-				throw NotImplementedException("Mixing named parameters and positional parameters is not supported yet");
-			}
-			param_idx++;
-		}
-		expr->ClearAlias();
-		result->named_values[param_name] = std::move(expr);
-	}
-	intermediate_values.clear();
-	return result;
-}
-
-unique_ptr<DropStatement> Transformer::TransformDeallocate(duckdb_libpgquery::PGDeallocateStmt &stmt) {
-	if (!stmt.name) {
-		throw ParserException("DEALLOCATE requires a name");
-	}
-
-	auto result = make_uniq<DropStatement>();
-	result->info->type = CatalogType::PREPARED_STATEMENT;
-	result->info->name = string(stmt.name);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_rename.cpp b/src/duckdb/src/parser/transform/statement/transform_rename.cpp
deleted file mode 100644
index 25b72d85a..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_rename.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGRenameStmt &stmt) {
-	if (!stmt.relation) {
-		throw NotImplementedException("Altering schemas is not yet supported");
-	}
-
-	unique_ptr<AlterInfo> info;
-
-	AlterEntryData data;
-	data.if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
-	data.catalog = stmt.relation->catalogname ? stmt.relation->catalogname : INVALID_CATALOG;
-	data.schema = stmt.relation->schemaname ? stmt.relation->schemaname : INVALID_SCHEMA;
-	if (stmt.relation->relname) {
-		data.name = stmt.relation->relname;
-	}
-	// first we check the type of ALTER
-	switch (stmt.renameType) {
-	case duckdb_libpgquery::PG_OBJECT_COLUMN: {
-		// change column name
-
-		// get the old name and the new name
-		string old_name = stmt.subname;
-		string new_name = stmt.newname;
-		info = make_uniq<RenameColumnInfo>(std::move(data), old_name, new_name);
-		break;
-	}
-	case duckdb_libpgquery::PG_OBJECT_TABLE: {
-		// change table name
-		string new_name = stmt.newname;
-		info = make_uniq<RenameTableInfo>(std::move(data), new_name);
-		break;
-	}
-	case duckdb_libpgquery::PG_OBJECT_VIEW: {
-		// change view name
-		string new_name = stmt.newname;
-		info = make_uniq<RenameViewInfo>(std::move(data), new_name);
-		break;
-	}
-	case duckdb_libpgquery::PG_OBJECT_DATABASE:
-	default:
-		throw NotImplementedException("Schema element not supported yet!");
-	}
-	D_ASSERT(info);
-
-	auto result = make_uniq<AlterStatement>();
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_secret.cpp b/src/duckdb/src/parser/transform/statement/transform_secret.cpp
deleted file mode 100644
index f9f13b088..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_secret.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-void Transformer::TransformCreateSecretOptions(CreateSecretInfo &info,
-                                               optional_ptr<duckdb_libpgquery::PGList> options) {
-	if (!options) {
-		return;
-	}
-
-	duckdb_libpgquery::PGListCell *cell;
-	// iterate over each option
-	for_each_cell(cell, options->head) {
-		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-		auto lower_name = StringUtil::Lower(def_elem->defname);
-		if (lower_name == "scope") {
-			// format specifier: interpret this option
-			auto scope_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (!scope_val) {
-				throw ParserException("Unsupported parameter type for SCOPE");
-			} else if (scope_val->type == duckdb_libpgquery::T_PGString) {
-				info.scope.push_back(scope_val->val.str);
-				continue;
-			} else if (scope_val->type != duckdb_libpgquery::T_PGList) {
-				throw ParserException("%s has to be a string, or a list of strings", lower_name);
-			}
-
-			auto list = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
-			for (auto scope_cell = list->head; scope_cell != nullptr; scope_cell = lnext(scope_cell)) {
-				auto scope_val_entry = PGPointerCast<duckdb_libpgquery::PGValue>(scope_cell->data.ptr_value);
-				info.scope.push_back(scope_val_entry->val.str);
-			}
-			continue;
-		} else if (lower_name == "type") {
-			auto type_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (type_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("%s has to be a string", lower_name);
-			}
-			info.type = StringUtil::Lower(type_val->val.str);
-			continue;
-		} else if (lower_name == "provider") {
-			auto provider_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (provider_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("%s has to be a string", lower_name);
-			}
-			info.provider = StringUtil::Lower(provider_val->val.str);
-			continue;
-		}
-
-		// All the other options end up in the generic
-		case_insensitive_map_t<vector<Value>> vector_options;
-		ParseGenericOptionListEntry(vector_options, lower_name, def_elem->arg);
-
-		for (const auto &entry : vector_options) {
-			if (entry.second.size() != 1) {
-				throw ParserException("Invalid parameter passed to option '%s'", entry.first);
-			}
-
-			if (info.options.find(entry.first) != info.options.end()) {
-				throw BinderException("Duplicate query param found while parsing create secret: '%s'", entry.first);
-			}
-
-			info.options[entry.first] = entry.second.at(0);
-		}
-	}
-}
-
-unique_ptr<CreateStatement> Transformer::TransformSecret(duckdb_libpgquery::PGCreateSecretStmt &stmt) {
-	auto result = make_uniq<CreateStatement>();
-
-	auto create_secret_info =
-	    make_uniq<CreateSecretInfo>(TransformOnConflict(stmt.onconflict),
-	                                EnumUtil::FromString<SecretPersistType>(StringUtil::Upper(stmt.persist_type)));
-
-	if (stmt.secret_name) {
-		create_secret_info->name = StringUtil::Lower(stmt.secret_name);
-	}
-
-	if (stmt.secret_storage) {
-		create_secret_info->storage_type = StringUtil::Lower(stmt.secret_storage);
-	}
-
-	if (stmt.options) {
-		TransformCreateSecretOptions(*create_secret_info, stmt.options);
-	}
-
-	if (create_secret_info->type.empty()) {
-		throw ParserException("Failed to create secret - secret must have a type defined");
-	}
-	if (create_secret_info->name.empty()) {
-		create_secret_info->name = "__default_" + create_secret_info->type;
-	}
-
-	result->info = std::move(create_secret_info);
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_select.cpp b/src/duckdb/src/parser/transform/statement/transform_select.cpp
deleted file mode 100644
index 2e5135ef6..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_select.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGNode &node, bool is_select) {
-	switch (node.type) {
-	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return TransformShowSelect(PGCast<duckdb_libpgquery::PGVariableShowSelectStmt>(node));
-	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return TransformShow(PGCast<duckdb_libpgquery::PGVariableShowStmt>(node));
-	default:
-		return TransformSelectNodeInternal(PGCast<duckdb_libpgquery::PGSelectStmt>(node), is_select);
-	}
-}
-
-unique_ptr<QueryNode> Transformer::TransformSelectNodeInternal(duckdb_libpgquery::PGSelectStmt &select,
-                                                               bool is_select) {
-	// Both Insert/Create Table As uses this.
-	if (is_select) {
-		if (select.intoClause) {
-			throw ParserException("SELECT INTO not supported!");
-		}
-		if (select.lockingClause) {
-			throw ParserException("SELECT locking clause is not supported!");
-		}
-	}
-	unique_ptr<QueryNode> stmt = nullptr;
-	if (select.pivot) {
-		stmt = TransformPivotStatement(select);
-	} else {
-		stmt = TransformSelectInternal(select);
-	}
-	return TransformMaterializedCTE(std::move(stmt));
-}
-
-unique_ptr<SelectStatement> Transformer::TransformSelectStmt(duckdb_libpgquery::PGSelectStmt &select, bool is_select) {
-	auto result = make_uniq<SelectStatement>();
-	result->node = TransformSelectNodeInternal(select, is_select);
-	return result;
-}
-
-unique_ptr<SelectStatement> Transformer::TransformSelectStmt(duckdb_libpgquery::PGNode &node, bool is_select) {
-	auto select_node = TransformSelectNode(node, is_select);
-	auto select_statement = make_uniq<SelectStatement>();
-	select_statement->node = std::move(select_node);
-	return select_statement;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_select_node.cpp b/src/duckdb/src/parser/transform/statement/transform_select_node.cpp
deleted file mode 100644
index ab206fdb8..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_select_node.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-
-namespace duckdb {
-
-void Transformer::TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node) {
-	// transform the common properties
-	// both the set operations and the regular select can have an ORDER BY/LIMIT attached to them
-	vector<OrderByNode> orders;
-	TransformOrderBy(stmt.sortClause, orders);
-	if (!orders.empty()) {
-		auto order_modifier = make_uniq<OrderModifier>();
-		order_modifier->orders = std::move(orders);
-		node.modifiers.push_back(std::move(order_modifier));
-	}
-
-	if (stmt.limitCount || stmt.limitOffset) {
-		if (stmt.limitCount && stmt.limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
-			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
-			auto expr_node = PGPointerCast<duckdb_libpgquery::PGLimitPercent>(stmt.limitCount)->limit_percent;
-			limit_percent_modifier->limit = TransformExpression(expr_node);
-			if (stmt.limitOffset) {
-				limit_percent_modifier->offset = TransformExpression(stmt.limitOffset);
-			}
-			node.modifiers.push_back(std::move(limit_percent_modifier));
-		} else {
-			auto limit_modifier = make_uniq<LimitModifier>();
-			if (stmt.limitCount) {
-				limit_modifier->limit = TransformExpression(stmt.limitCount);
-			}
-			if (stmt.limitOffset) {
-				limit_modifier->offset = TransformExpression(stmt.limitOffset);
-			}
-			node.modifiers.push_back(std::move(limit_modifier));
-		}
-	}
-}
-
-unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PGSelectStmt &stmt) {
-	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGSelectStmt);
-	auto stack_checker = StackCheck();
-
-	unique_ptr<QueryNode> node;
-
-	switch (stmt.op) {
-	case duckdb_libpgquery::PG_SETOP_NONE: {
-		node = make_uniq<SelectNode>();
-		auto &result = node->Cast<SelectNode>();
-		if (stmt.withClause) {
-			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
-		}
-		if (stmt.windowClause) {
-			for (auto window_ele = stmt.windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
-				auto window_def = PGPointerCast<duckdb_libpgquery::PGWindowDef>(window_ele->data.ptr_value);
-				D_ASSERT(window_def);
-				D_ASSERT(window_def->name);
-				string window_name(window_def->name);
-				auto it = window_clauses.find(window_name);
-				if (it != window_clauses.end()) {
-					throw ParserException("window \"%s\" is already defined", window_name);
-				}
-				window_clauses[window_name] = window_def.get();
-			}
-		}
-
-		// checks distinct clause
-		if (stmt.distinctClause != nullptr) {
-			auto modifier = make_uniq<DistinctModifier>();
-			// checks distinct on clause
-			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(stmt.distinctClause->head->data.ptr_value);
-			if (target) {
-				//  add the columns defined in the ON clause to the select list
-				TransformExpressionList(*stmt.distinctClause, modifier->distinct_on_targets);
-			}
-			result.modifiers.push_back(std::move(modifier));
-		}
-
-		// do this early so the value lists also have a `FROM`
-		if (stmt.valuesLists) {
-			// VALUES list, create an ExpressionList
-			D_ASSERT(!stmt.fromClause);
-			result.from_table = TransformValuesList(stmt.valuesLists);
-			result.select_list.push_back(make_uniq<StarExpression>());
-		} else {
-			if (!stmt.targetList) {
-				throw ParserException("SELECT clause without selection list");
-			}
-			// transform in the specified order to ensure positional parameters are correctly set
-			if (stmt.from_first) {
-				result.from_table = TransformFrom(stmt.fromClause);
-				TransformExpressionList(*stmt.targetList, result.select_list);
-			} else {
-				TransformExpressionList(*stmt.targetList, result.select_list);
-				result.from_table = TransformFrom(stmt.fromClause);
-			}
-		}
-
-		// where
-		result.where_clause = TransformExpression(stmt.whereClause);
-		// group by
-		TransformGroupBy(stmt.groupClause, result);
-		// having
-		result.having = TransformExpression(stmt.havingClause);
-		// qualify
-		result.qualify = TransformExpression(stmt.qualifyClause);
-		// sample
-		result.sample = TransformSampleOptions(stmt.sampleOptions);
-		break;
-	}
-	case duckdb_libpgquery::PG_SETOP_UNION:
-	case duckdb_libpgquery::PG_SETOP_EXCEPT:
-	case duckdb_libpgquery::PG_SETOP_INTERSECT:
-	case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME: {
-		node = make_uniq<SetOperationNode>();
-		auto &result = node->Cast<SetOperationNode>();
-		if (stmt.withClause) {
-			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
-		}
-		result.left = TransformSelectNode(*stmt.larg);
-		result.right = TransformSelectNode(*stmt.rarg);
-		if (!result.left || !result.right) {
-			throw InternalException("Failed to transform setop children.");
-		}
-
-		result.setop_all = stmt.all;
-		switch (stmt.op) {
-		case duckdb_libpgquery::PG_SETOP_UNION:
-			result.setop_type = SetOperationType::UNION;
-			break;
-		case duckdb_libpgquery::PG_SETOP_EXCEPT:
-			result.setop_type = SetOperationType::EXCEPT;
-			break;
-		case duckdb_libpgquery::PG_SETOP_INTERSECT:
-			result.setop_type = SetOperationType::INTERSECT;
-			break;
-		case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME:
-			result.setop_type = SetOperationType::UNION_BY_NAME;
-			break;
-		default:
-			throw InternalException("Unexpected setop type");
-		}
-		if (stmt.sampleOptions) {
-			throw ParserException("SAMPLE clause is only allowed in regular SELECT statements");
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Statement type %d not implemented!", stmt.op);
-	}
-
-	TransformModifiers(stmt, *node);
-
-	return node;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_set.cpp b/src/duckdb/src/parser/transform/statement/transform_set.cpp
deleted file mode 100644
index 6df82aec3..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_set.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "duckdb/parser/statement/set_statement.hpp"
-
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-
-namespace duckdb {
-
-namespace {
-
-SetScope ToSetScope(duckdb_libpgquery::VariableSetScope pg_scope) {
-	switch (pg_scope) {
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL:
-		return SetScope::LOCAL;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_SESSION:
-		return SetScope::SESSION;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_GLOBAL:
-		return SetScope::GLOBAL;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_VARIABLE:
-		return SetScope::VARIABLE;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_DEFAULT:
-		return SetScope::AUTOMATIC;
-	default:
-		throw InternalException("Unexpected pg_scope: %d", pg_scope);
-	}
-}
-
-SetType ToSetType(duckdb_libpgquery::VariableSetKind pg_kind) {
-	switch (pg_kind) {
-	case duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE:
-		return SetType::SET;
-	case duckdb_libpgquery::VariableSetKind::VAR_RESET:
-		return SetType::RESET;
-	default:
-		throw NotImplementedException("Can only SET or RESET a variable");
-	}
-}
-
-} // namespace
-
-unique_ptr<SetStatement> Transformer::TransformSetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt) {
-	if (stmt.scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
-		throw NotImplementedException("SET LOCAL is not implemented.");
-	}
-
-	string name(stmt.name);
-	D_ASSERT(!name.empty()); // parser protect us!
-	if (stmt.args->length != 1) {
-		throw ParserException("SET needs a single scalar value parameter");
-	}
-	auto scope = ToSetScope(stmt.scope);
-	D_ASSERT(stmt.args->head && stmt.args->head->data.ptr_value);
-	auto const_val = PGPointerCast<duckdb_libpgquery::PGNode>(stmt.args->head->data.ptr_value);
-	auto expr = TransformExpression(const_val);
-	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr->Cast<ColumnRefExpression>();
-		Value val;
-		if (!colref.IsQualified()) {
-			val = Value(colref.GetColumnName());
-		} else {
-			val = Value(expr->ToString());
-		}
-		expr = make_uniq<ConstantExpression>(std::move(val));
-	}
-	if (expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-		// set to default = reset
-		return make_uniq<ResetVariableStatement>(std::move(name), scope);
-	}
-	return make_uniq<SetVariableStatement>(std::move(name), std::move(expr), scope);
-}
-
-unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt) {
-	D_ASSERT(stmt.kind == duckdb_libpgquery::VariableSetKind::VAR_RESET);
-
-	if (stmt.scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
-		throw NotImplementedException("RESET LOCAL is not implemented.");
-	}
-
-	string name(stmt.name);
-	D_ASSERT(!name.empty()); // parser protect us!
-
-	return make_uniq<ResetVariableStatement>(name, ToSetScope(stmt.scope));
-}
-
-unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGVariableSetStmt &stmt) {
-	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGVariableSetStmt);
-
-	SetType set_type = ToSetType(stmt.kind);
-	switch (set_type) {
-	case SetType::SET:
-		return TransformSetVariable(stmt);
-	case SetType::RESET:
-		return TransformResetVariable(stmt);
-	default:
-		throw InternalException("Type not implemented for SetType");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_show.cpp b/src/duckdb/src/parser/transform/statement/transform_show.cpp
deleted file mode 100644
index 648dbb9b7..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_show.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/tableref/showref.hpp"
-
-namespace duckdb {
-
-unique_ptr<QueryNode> Transformer::TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt) {
-	// create the query that holds the show statement
-	auto select_node = make_uniq<SelectNode>();
-	select_node->select_list.push_back(make_uniq<StarExpression>());
-	auto showref = make_uniq<ShowRef>();
-	if (stmt.set) {
-		// describing a set (e.g. SHOW ALL TABLES) - push it in the table name
-		showref->table_name = stmt.set;
-	} else if (!stmt.relation->schemaname) {
-		// describing an unqualified relation - check if this is a "special" relation
-		string table_name = StringUtil::Lower(stmt.relation->relname);
-		if (table_name == "databases" || table_name == "tables" || table_name == "variables") {
-			showref->table_name = "\"" + std::move(table_name) + "\"";
-		}
-	}
-	if (showref->table_name.empty()) {
-		// describing a single relation
-		// wrap the relation in a "SELECT * FROM [table_name]" query
-		auto show_select_node = make_uniq<SelectNode>();
-		show_select_node->select_list.push_back(make_uniq<StarExpression>());
-		auto tableref = TransformRangeVar(*stmt.relation);
-		show_select_node->from_table = std::move(tableref);
-		showref->query = std::move(show_select_node);
-	}
-
-	showref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
-	select_node->from_table = std::move(showref);
-	return std::move(select_node);
-}
-
-unique_ptr<SelectStatement> Transformer::TransformShowStmt(duckdb_libpgquery::PGVariableShowStmt &stmt) {
-	auto result = make_uniq<SelectStatement>();
-	result->node = TransformShow(stmt);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_show_select.cpp b/src/duckdb/src/parser/transform/statement/transform_show_select.cpp
deleted file mode 100644
index bd6f52a87..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_show_select.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "duckdb/parser/sql_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/showref.hpp"
-
-namespace duckdb {
-
-unique_ptr<QueryNode> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
-	// we capture the select statement of SHOW
-	auto select_node = make_uniq<SelectNode>();
-	select_node->select_list.push_back(make_uniq<StarExpression>());
-
-	auto show_ref = make_uniq<ShowRef>();
-	show_ref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
-	show_ref->query = TransformSelectNode(*stmt.stmt);
-	select_node->from_table = std::move(show_ref);
-	return std::move(select_node);
-}
-
-unique_ptr<SelectStatement> Transformer::TransformShowSelectStmt(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
-	auto result = make_uniq<SelectStatement>();
-	result->node = TransformShowSelect(stmt);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_transaction.cpp b/src/duckdb/src/parser/transform/statement/transform_transaction.cpp
deleted file mode 100644
index ba4c04527..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_transaction.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/parser/statement/transaction_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-TransactionType TransformTransactionType(duckdb_libpgquery::PGTransactionStmtKind kind) {
-	switch (kind) {
-	case duckdb_libpgquery::PG_TRANS_STMT_BEGIN:
-	case duckdb_libpgquery::PG_TRANS_STMT_START:
-		return TransactionType::BEGIN_TRANSACTION;
-	case duckdb_libpgquery::PG_TRANS_STMT_COMMIT:
-		return TransactionType::COMMIT;
-	case duckdb_libpgquery::PG_TRANS_STMT_ROLLBACK:
-		return TransactionType::ROLLBACK;
-	default:
-		throw NotImplementedException("Transaction type %d not implemented yet", kind);
-	}
-}
-
-TransactionModifierType TransformTransactionModifier(duckdb_libpgquery::PGTransactionStmtType type) {
-	switch (type) {
-	case duckdb_libpgquery::PG_TRANS_TYPE_DEFAULT:
-		return TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER;
-	case duckdb_libpgquery::PG_TRANS_TYPE_READ_ONLY:
-		return TransactionModifierType::TRANSACTION_READ_ONLY;
-	case duckdb_libpgquery::PG_TRANS_TYPE_READ_WRITE:
-		return TransactionModifierType::TRANSACTION_READ_WRITE;
-	default:
-		throw NotImplementedException("Transaction modifier %d not implemented yet", type);
-	}
-}
-
-unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt) {
-	//	stmt.transaction_type
-	auto type = TransformTransactionType(stmt.kind);
-	auto info = make_uniq<TransactionInfo>(type);
-	info->modifier = TransformTransactionModifier(stmt.transaction_type);
-	return make_uniq<TransactionStatement>(std::move(info));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_update.cpp b/src/duckdb/src/parser/transform/statement/transform_update.cpp
deleted file mode 100644
index 9f5951d02..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_update.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/parser/statement/update_extensions_statement.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery::PGList *target_list,
-                                                              duckdb_libpgquery::PGNode *where_clause) {
-	auto result = make_uniq<UpdateSetInfo>();
-	auto root = target_list;
-
-	for (auto cell = root->head; cell != nullptr; cell = cell->next) {
-		auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(cell->data.ptr_value);
-		result->columns.emplace_back(target->name);
-		result->expressions.push_back(TransformExpression(target->val));
-	}
-
-	result->condition = TransformExpression(where_clause);
-	return result;
-}
-
-unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt) {
-	auto result = make_uniq<UpdateStatement>();
-	if (stmt.withClause) {
-		auto with_clause = PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause);
-		TransformCTE(*with_clause, result->cte_map);
-	}
-
-	result->table = TransformRangeVar(*stmt.relation);
-	if (stmt.fromClause) {
-		result->from_table = TransformFrom(stmt.fromClause);
-	}
-	result->set_info = TransformUpdateSetInfo(stmt.targetList, stmt.whereClause);
-
-	// Grab and transform the returning columns from the parser.
-	if (stmt.returningList) {
-		TransformExpressionList(*stmt.returningList, result->returning_list);
-	}
-	return result;
-}
-
-unique_ptr<UpdateExtensionsStatement>
-Transformer::TransformUpdateExtensions(duckdb_libpgquery::PGUpdateExtensionsStmt &stmt) {
-	auto result = make_uniq<UpdateExtensionsStatement>();
-	auto info = make_uniq<UpdateExtensionsInfo>();
-
-	if (stmt.extensions) {
-		auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.extensions);
-		for (auto c = column_list->head; c != nullptr; c = c->next) {
-			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(c->data.ptr_value);
-			info->extensions_to_update.emplace_back(value->val.str);
-		}
-	}
-
-	result->info = std::move(info);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_upsert.cpp b/src/duckdb/src/parser/transform/statement/transform_upsert.cpp
deleted file mode 100644
index aa0130f3c..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_upsert.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-OnConflictAction TransformOnConflictAction(duckdb_libpgquery::PGOnConflictClause *on_conflict) {
-	if (!on_conflict) {
-		return OnConflictAction::THROW;
-	}
-	switch (on_conflict->action) {
-	case duckdb_libpgquery::PG_ONCONFLICT_NONE:
-		return OnConflictAction::THROW;
-	case duckdb_libpgquery::PG_ONCONFLICT_NOTHING:
-		return OnConflictAction::NOTHING;
-	case duckdb_libpgquery::PG_ONCONFLICT_UPDATE:
-		return OnConflictAction::UPDATE;
-	default:
-		throw InternalException("Type not implemented for OnConflictAction");
-	}
-}
-
-vector<string> Transformer::TransformConflictTarget(duckdb_libpgquery::PGList &list) {
-	vector<string> columns;
-	for (auto cell = list.head; cell != nullptr; cell = cell->next) {
-		auto index_element = PGPointerCast<duckdb_libpgquery::PGIndexElem>(cell->data.ptr_value);
-		if (index_element->collation) {
-			throw NotImplementedException("Index with collation not supported yet!");
-		}
-		if (index_element->opclass) {
-			throw NotImplementedException("Index with opclass not supported yet!");
-		}
-		if (!index_element->name) {
-			throw NotImplementedException("Non-column index element not supported yet!");
-		}
-		if (index_element->nulls_ordering) {
-			throw NotImplementedException("Index with null_ordering not supported yet!");
-		}
-		if (index_element->ordering) {
-			throw NotImplementedException("Index with ordering not supported yet!");
-		}
-		columns.emplace_back(index_element->name);
-	}
-	return columns;
-}
-
-unique_ptr<OnConflictInfo> Transformer::DummyOnConflictClause(duckdb_libpgquery::PGOnConflictActionAlias type,
-                                                              const string &relname) {
-	switch (type) {
-	case duckdb_libpgquery::PGOnConflictActionAlias::PG_ONCONFLICT_ALIAS_REPLACE: {
-		// This can not be fully resolved yet until the bind stage
-		auto result = make_uniq<OnConflictInfo>();
-		result->action_type = OnConflictAction::REPLACE;
-		return result;
-	}
-	case duckdb_libpgquery::PGOnConflictActionAlias::PG_ONCONFLICT_ALIAS_IGNORE: {
-		// We can just fully replace this with DO NOTHING, and be done with it
-		auto result = make_uniq<OnConflictInfo>();
-		result->action_type = OnConflictAction::NOTHING;
-		return result;
-	}
-	default: {
-		throw InternalException("Type not implemented for PGOnConflictActionAlias");
-	}
-	}
-}
-
-unique_ptr<OnConflictInfo> Transformer::TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node,
-                                                                  const string &) {
-
-	auto stmt = PGPointerCast<duckdb_libpgquery::PGOnConflictClause>(node);
-	D_ASSERT(stmt);
-
-	auto result = make_uniq<OnConflictInfo>();
-	result->action_type = TransformOnConflictAction(stmt.get());
-
-	if (stmt->infer) {
-		// A filter for the ON CONFLICT ... is specified.
-		if (!stmt->infer->indexElems) {
-			throw NotImplementedException("ON CONSTRAINT conflict target is not supported yet");
-		}
-		result->indexed_columns = TransformConflictTarget(*stmt->infer->indexElems);
-		if (stmt->infer->whereClause) {
-			result->condition = TransformExpression(stmt->infer->whereClause);
-		}
-	}
-
-	if (result->action_type == OnConflictAction::UPDATE) {
-		result->set_info = TransformUpdateSetInfo(stmt->targetList, stmt->whereClause);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_use.cpp b/src/duckdb/src/parser/transform/statement/transform_use.cpp
deleted file mode 100644
index 4bb8a2b86..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_use.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/statement/set_statement.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<SetStatement> Transformer::TransformUse(duckdb_libpgquery::PGUseStmt &stmt) {
-	auto qualified_name = TransformQualifiedName(*stmt.name);
-	if (!IsInvalidCatalog(qualified_name.catalog)) {
-		throw ParserException("Expected \"USE database\" or \"USE database.schema\"");
-	}
-	string name;
-	if (IsInvalidSchema(qualified_name.schema)) {
-		name = KeywordHelper::WriteOptionallyQuoted(qualified_name.name, '"');
-	} else {
-		name = KeywordHelper::WriteOptionallyQuoted(qualified_name.schema, '"') + "." +
-		       KeywordHelper::WriteOptionallyQuoted(qualified_name.name, '"');
-	}
-	auto name_expr = make_uniq<ConstantExpression>(Value(name));
-	return make_uniq<SetVariableStatement>("schema", std::move(name_expr), SetScope::AUTOMATIC);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/statement/transform_vacuum.cpp b/src/duckdb/src/parser/transform/statement/transform_vacuum.cpp
deleted file mode 100644
index e18dedad1..000000000
--- a/src/duckdb/src/parser/transform/statement/transform_vacuum.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/parser/statement/vacuum_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-VacuumOptions ParseOptions(const int32_t options) {
-	VacuumOptions result;
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_VACUUM) {
-		result.vacuum = true;
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_ANALYZE) {
-		result.analyze = true;
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_VERBOSE) {
-		throw NotImplementedException("Verbose vacuum option");
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_FREEZE) {
-		throw NotImplementedException("Freeze vacuum option");
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_FULL) {
-		throw NotImplementedException("Full vacuum option");
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_NOWAIT) {
-		throw NotImplementedException("No Wait vacuum option");
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_SKIPTOAST) {
-		throw NotImplementedException("Skip Toast vacuum option");
-	}
-	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_DISABLE_PAGE_SKIPPING) {
-		throw NotImplementedException("Disable Page Skipping vacuum option");
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGVacuumStmt &stmt) {
-	auto result = make_uniq<VacuumStatement>(ParseOptions(stmt.options));
-
-	if (stmt.relation) {
-		result->info->ref = TransformRangeVar(*stmt.relation);
-		result->info->has_table = true;
-	}
-
-	if (stmt.va_cols) {
-		D_ASSERT(result->info->has_table);
-		for (auto col_node = stmt.va_cols->head; col_node != nullptr; col_node = col_node->next) {
-			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(col_node->data.ptr_value);
-			result->info->columns.emplace_back(value->val.str);
-		}
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp b/src/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp
deleted file mode 100644
index d0e64a452..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVar &root) {
-	auto result = make_uniq<BaseTableRef>();
-
-	result->alias = TransformAlias(root.alias, result->column_name_alias);
-	if (root.relname) {
-		result->table_name = root.relname;
-	}
-	if (root.catalogname) {
-		result->catalog_name = root.catalogname;
-	}
-	if (root.schemaname) {
-		result->schema_name = root.schemaname;
-	}
-	if (root.sample) {
-		result->sample = TransformSampleOptions(root.sample);
-	}
-	SetQueryLocation(*result, root.location);
-	return std::move(result);
-}
-
-QualifiedName Transformer::TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root) {
-	QualifiedName qname;
-	if (root.catalogname) {
-		qname.catalog = root.catalogname;
-	} else {
-		qname.catalog = INVALID_CATALOG;
-	}
-	if (root.schemaname) {
-		qname.schema = root.schemaname;
-	} else {
-		qname.schema = INVALID_SCHEMA;
-	}
-	if (root.relname) {
-		qname.name = root.relname;
-	} else {
-		qname.name = string();
-	}
-	return qname;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_from.cpp b/src/duckdb/src/parser/transform/tableref/transform_from.cpp
deleted file mode 100644
index 84ec8ea51..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_from.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformFrom(optional_ptr<duckdb_libpgquery::PGList> root) {
-	if (!root) {
-		return make_uniq<EmptyTableRef>();
-	}
-
-	if (root->length > 1) {
-		// Cross Product
-		auto result = make_uniq<JoinRef>(JoinRefType::CROSS);
-		JoinRef *cur_root = result.get();
-		idx_t list_size = 0;
-		for (auto node = root->head; node != nullptr; node = node->next) {
-			auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-			unique_ptr<TableRef> next = TransformTableRefNode(*n);
-			if (!cur_root->left) {
-				cur_root->left = std::move(next);
-			} else if (!cur_root->right) {
-				cur_root->right = std::move(next);
-			} else {
-				auto old_res = std::move(result);
-				result = make_uniq<JoinRef>(JoinRefType::CROSS);
-				result->left = std::move(old_res);
-				result->right = std::move(next);
-				cur_root = result.get();
-			}
-			list_size++;
-			StackCheck(list_size);
-		}
-		return std::move(result);
-	}
-
-	auto n = PGPointerCast<duckdb_libpgquery::PGNode>(root->head->data.ptr_value);
-	return TransformTableRefNode(*n);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_join.cpp b/src/duckdb/src/parser/transform/tableref/transform_join.cpp
deleted file mode 100644
index 5aa6637ea..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_join.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &root) {
-	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-	switch (root.jointype) {
-	case duckdb_libpgquery::PG_JOIN_INNER: {
-		result->type = JoinType::INNER;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_LEFT: {
-		result->type = JoinType::LEFT;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_FULL: {
-		result->type = JoinType::OUTER;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_RIGHT: {
-		result->type = JoinType::RIGHT;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_SEMI: {
-		result->type = JoinType::SEMI;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_ANTI: {
-		result->type = JoinType::ANTI;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_POSITION: {
-		result->ref_type = JoinRefType::POSITIONAL;
-		break;
-	}
-	default:
-		throw NotImplementedException("Join type %d not supported\n", root.jointype);
-	}
-
-	// Check the type of the left and right argument before transforming.
-	result->left = TransformTableRefNode(*root.larg);
-	result->right = TransformTableRefNode(*root.rarg);
-
-	switch (root.joinreftype) {
-	case duckdb_libpgquery::PG_JOIN_NATURAL:
-		result->ref_type = JoinRefType::NATURAL;
-		break;
-	case duckdb_libpgquery::PG_JOIN_ASOF:
-		result->ref_type = JoinRefType::ASOF;
-		break;
-	default:
-		break;
-	}
-
-	SetQueryLocation(*result, root.location);
-	if (root.usingClause && root.usingClause->length > 0) {
-		// usingClause is a list of strings.
-		for (auto node = root.usingClause->head; node != nullptr; node = node->next) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-			D_ASSERT(target->type == duckdb_libpgquery::T_PGString);
-			auto value = PGCast<duckdb_libpgquery::PGValue>(*target.get());
-			result->using_columns.push_back(string(value.val.str));
-		}
-		return std::move(result);
-	}
-
-	// Check if this is a cross product.
-	if (!root.quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) {
-		result->ref_type = JoinRefType::CROSS;
-	}
-	result->condition = TransformExpression(root.quals);
-
-	if (root.alias) {
-		// This is a join with an alias, so we wrap it in a subquery.
-		auto select_node = make_uniq<SelectNode>();
-		select_node->select_list.push_back(make_uniq<StarExpression>());
-		select_node->from_table = std::move(result);
-
-		auto select = make_uniq<SelectStatement>();
-		select->node = std::move(select_node);
-
-		auto subquery = make_uniq<SubqueryRef>(std::move(select));
-		SetQueryLocation(*subquery, root.location);
-
-		// Apply the alias to the subquery.
-		subquery->alias = TransformAlias(root.alias, subquery->column_name_alias);
-		return std::move(subquery);
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp
deleted file mode 100644
index d042d881d..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-namespace duckdb {
-
-bool Transformer::TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry) {
-	switch (expr->GetExpressionType()) {
-	case ExpressionType::COLUMN_REF: {
-		auto &colref = expr->Cast<ColumnRefExpression>();
-		if (colref.IsQualified()) {
-			throw ParserException(expr->GetQueryLocation(), "PIVOT IN list cannot contain qualified column references");
-		}
-		entry.values.emplace_back(colref.GetColumnName());
-		return true;
-	}
-	case ExpressionType::FUNCTION: {
-		auto &function = expr->Cast<FunctionExpression>();
-		if (function.function_name != "row") {
-			return false;
-		}
-		for (auto &child : function.children) {
-			if (!TransformPivotInList(child, entry, false)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default: {
-		Value val;
-		if (!Transformer::ConstructConstantFromExpression(*expr, val)) {
-			return false;
-		}
-		entry.values.push_back(std::move(val));
-		return true;
-	}
-	}
-}
-
-PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot) {
-	PivotColumn col;
-	if (pivot.pivot_columns) {
-		TransformExpressionList(*pivot.pivot_columns, col.pivot_expressions);
-		for (auto &expr : col.pivot_expressions) {
-			if (expr->IsScalar()) {
-				throw ParserException(expr->GetQueryLocation(), "Cannot pivot on constant value \"%s\"",
-				                      expr->ToString());
-			}
-			if (expr->HasSubquery()) {
-				throw ParserException(expr->GetQueryLocation(), "Cannot pivot on subquery \"%s\"", expr->ToString());
-			}
-		}
-	} else if (pivot.unpivot_columns) {
-		col.unpivot_names = TransformStringList(pivot.unpivot_columns);
-	} else {
-		throw InternalException("Either pivot_columns or unpivot_columns must be defined");
-	}
-	if (pivot.pivot_value) {
-		for (auto node = pivot.pivot_value->head; node != nullptr; node = node->next) {
-			auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-			auto expr = TransformExpression(n);
-			PivotColumnEntry entry;
-			entry.alias = expr->GetAlias();
-			auto transformed = TransformPivotInList(expr, entry);
-			if (!transformed) {
-				// could not transform into list of constant values
-				if (is_pivot) {
-					// for pivot - throw an exception
-					throw ParserException(expr->GetQueryLocation(),
-					                      "PIVOT IN list must contain columns or lists of columns");
-				} else {
-					// for unpivot - we can forward the expression immediately
-					entry.values.clear();
-					entry.expr = std::move(expr);
-				}
-			}
-			col.entries.push_back(std::move(entry));
-		}
-	}
-	if (pivot.subquery) {
-		col.subquery = TransformSelectNode(*pivot.subquery);
-	}
-	if (pivot.pivot_enum) {
-		col.pivot_enum = pivot.pivot_enum;
-	}
-	return col;
-}
-
-vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot) {
-	vector<PivotColumn> result;
-	for (auto node = list.head; node != nullptr; node = node->next) {
-		auto pivot = PGPointerCast<duckdb_libpgquery::PGPivot>(node->data.ptr_value);
-		result.push_back(TransformPivotColumn(*pivot, is_pivot));
-	}
-	return result;
-}
-
-unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr &root) {
-	auto result = make_uniq<PivotRef>();
-	result->source = TransformTableRefNode(*root.source);
-	if (root.aggrs) {
-		TransformExpressionList(*root.aggrs, result->aggregates);
-	}
-	if (root.unpivots) {
-		result->unpivot_names = TransformStringList(root.unpivots);
-	}
-	auto is_pivot = result->unpivot_names.empty();
-	result->pivots = TransformPivotList(*root.pivots, is_pivot);
-	if (!is_pivot && result->pivots.size() > 1) {
-		throw ParserException("UNPIVOT requires a single pivot element");
-	}
-	if (root.groups) {
-		result->groups = TransformStringList(root.groups);
-	}
-	for (auto &pivot : result->pivots) {
-		if (!is_pivot) {
-			// unpivot
-			if (pivot.unpivot_names.size() != 1) {
-				throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause");
-			}
-			D_ASSERT(pivot.pivot_expressions.empty());
-		} else {
-			// pivot
-			auto expected_size = pivot.pivot_expressions.size();
-			D_ASSERT(pivot.unpivot_names.empty());
-			for (auto &entry : pivot.entries) {
-				if (entry.expr) {
-					throw ParserException("PIVOT IN list must contain columns or lists of columns - expressions are "
-					                      "only supported for UNPIVOT");
-				}
-				if (entry.values.size() != expected_size) {
-					throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
-					                      expected_size, entry.values.size());
-				}
-			}
-		}
-	}
-	result->include_nulls = root.include_nulls;
-	result->alias = TransformAlias(root.alias, result->column_name_alias);
-	SetQueryLocation(*result, root.location);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp b/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp
deleted file mode 100644
index 58c61811c..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect &root) {
-	Transformer subquery_transformer(*this);
-	auto subquery = subquery_transformer.TransformSelectStmt(*root.subquery);
-	if (!subquery) {
-		return nullptr;
-	}
-	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	result->alias = TransformAlias(root.alias, result->column_name_alias);
-	if (root.sample) {
-		result->sample = TransformSampleOptions(root.sample);
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_table_function.cpp b/src/duckdb/src/parser/transform/tableref/transform_table_function.cpp
deleted file mode 100644
index 43dccc743..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_table_function.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRangeFunction &root) {
-	if (root.ordinality) {
-		throw NotImplementedException("WITH ORDINALITY not implemented");
-	}
-	if (root.is_rowsfrom) {
-		throw NotImplementedException("ROWS FROM() not implemented");
-	}
-	if (root.functions->length != 1) {
-		throw NotImplementedException("Need exactly one function");
-	}
-	auto function_sublist = PGPointerCast<duckdb_libpgquery::PGList>(root.functions->head->data.ptr_value);
-	D_ASSERT(function_sublist->length == 2);
-	auto call_tree = PGPointerCast<duckdb_libpgquery::PGNode>(function_sublist->head->data.ptr_value);
-	auto coldef = function_sublist->head->next->data.ptr_value;
-
-	if (coldef) {
-		throw NotImplementedException("Explicit column definition not supported yet");
-	}
-	// transform the function call
-	auto result = make_uniq<TableFunctionRef>();
-	switch (call_tree->type) {
-	case duckdb_libpgquery::T_PGFuncCall: {
-		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(call_tree.get());
-		result->function = TransformFuncCall(*func_call);
-		SetQueryLocation(*result, func_call->location);
-		break;
-	}
-	case duckdb_libpgquery::T_PGSQLValueFunction:
-		result->function =
-		    TransformSQLValueFunction(*PGPointerCast<duckdb_libpgquery::PGSQLValueFunction>(call_tree.get()));
-		break;
-	default:
-		throw ParserException("Not a function call or value function");
-	}
-	result->alias = TransformAlias(root.alias, result->column_name_alias);
-	if (root.sample) {
-		result->sample = TransformSampleOptions(root.sample);
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transform/tableref/transform_tableref.cpp b/src/duckdb/src/parser/transform/tableref/transform_tableref.cpp
deleted file mode 100644
index ee4de7007..000000000
--- a/src/duckdb/src/parser/transform/tableref/transform_tableref.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/tableref.hpp"
-#include "duckdb/parser/transformer.hpp"
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNode &n) {
-	auto stack_checker = StackCheck();
-
-	switch (n.type) {
-	case duckdb_libpgquery::T_PGRangeVar:
-		return TransformRangeVar(PGCast<duckdb_libpgquery::PGRangeVar>(n));
-	case duckdb_libpgquery::T_PGJoinExpr:
-		return TransformJoin(PGCast<duckdb_libpgquery::PGJoinExpr>(n));
-	case duckdb_libpgquery::T_PGRangeSubselect:
-		return TransformRangeSubselect(PGCast<duckdb_libpgquery::PGRangeSubselect>(n));
-	case duckdb_libpgquery::T_PGRangeFunction:
-		return TransformRangeFunction(PGCast<duckdb_libpgquery::PGRangeFunction>(n));
-	case duckdb_libpgquery::T_PGPivotExpr:
-		return TransformPivot(PGCast<duckdb_libpgquery::PGPivotExpr>(n));
-	default:
-		throw NotImplementedException("From Type %d not supported", n.type);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/parser/transformer.cpp b/src/duckdb/src/parser/transformer.cpp
deleted file mode 100644
index c3b27dbc4..000000000
--- a/src/duckdb/src/parser/transformer.cpp
+++ /dev/null
@@ -1,272 +0,0 @@
-#include "duckdb/parser/transformer.hpp"
-
-#include "duckdb/parser/expression/list.hpp"
-#include "duckdb/parser/statement/list.hpp"
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/parser/parser_options.hpp"
-
-namespace duckdb {
-
-Transformer::Transformer(ParserOptions &options)
-    : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
-}
-
-Transformer::Transformer(Transformer &parent)
-    : parent(&parent), options(parent.options), stack_depth(DConstants::INVALID_INDEX) {
-}
-
-Transformer::~Transformer() {
-}
-
-void Transformer::Clear() {
-	ClearParameters();
-	pivot_entries.clear();
-}
-
-bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
-	InitializeStackCheck();
-	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
-		Clear();
-		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(entry->data.ptr_value);
-		auto stmt = TransformStatement(*n);
-		D_ASSERT(stmt);
-		if (HasPivotEntries()) {
-			stmt = CreatePivotStatement(std::move(stmt));
-		}
-		statements.push_back(std::move(stmt));
-	}
-	return true;
-}
-
-void Transformer::InitializeStackCheck() {
-	stack_depth = 0;
-}
-
-StackChecker<Transformer> Transformer::StackCheck(idx_t extra_stack) {
-	auto &root = RootTransformer();
-	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
-	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
-		throw ParserException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
-		                      "increase the maximum expression depth.",
-		                      options.max_expression_depth);
-	}
-	return StackChecker<Transformer>(root, extra_stack);
-}
-
-unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {
-	auto result = TransformStatementInternal(stmt);
-	if (!named_param_map.empty()) {
-		// Avoid overriding a previous move with nothing
-		result->named_param_map = named_param_map;
-	}
-	return result;
-}
-
-Transformer &Transformer::RootTransformer() {
-	reference<Transformer> node = *this;
-	while (node.get().parent) {
-		node = *node.get().parent;
-	}
-	return node.get();
-}
-
-const Transformer &Transformer::RootTransformer() const {
-	reference<const Transformer> node = *this;
-	while (node.get().parent) {
-		node = *node.get().parent;
-	}
-	return node.get();
-}
-
-idx_t Transformer::ParamCount() const {
-	auto &root = RootTransformer();
-	return root.prepared_statement_parameter_index;
-}
-
-void Transformer::SetParamCount(idx_t new_count) {
-	auto &root = RootTransformer();
-	root.prepared_statement_parameter_index = new_count;
-}
-
-void Transformer::ClearParameters() {
-	auto &root = RootTransformer();
-	root.prepared_statement_parameter_index = 0;
-	root.named_param_map.clear();
-}
-
-static void ParamTypeCheck(PreparedParamType last_type, PreparedParamType new_type) {
-	// Mixing positional/auto-increment and named parameters is not supported
-	if (last_type == PreparedParamType::INVALID) {
-		return;
-	}
-	if (last_type == PreparedParamType::NAMED) {
-		if (new_type != PreparedParamType::NAMED) {
-			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
-		}
-	}
-	if (last_type != PreparedParamType::NAMED) {
-		if (new_type == PreparedParamType::NAMED) {
-			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
-		}
-	}
-}
-
-void Transformer::SetParam(const string &identifier, idx_t index, PreparedParamType type) {
-	auto &root = RootTransformer();
-	ParamTypeCheck(root.last_param_type, type);
-	root.last_param_type = type;
-	D_ASSERT(!root.named_param_map.count(identifier));
-	root.named_param_map[identifier] = index;
-}
-
-bool Transformer::GetParam(const string &identifier, idx_t &index, PreparedParamType type) {
-	auto &root = RootTransformer();
-	ParamTypeCheck(root.last_param_type, type);
-	auto entry = root.named_param_map.find(identifier);
-	if (entry == root.named_param_map.end()) {
-		return false;
-	}
-	index = entry->second;
-	return true;
-}
-
-unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode &stmt) {
-	switch (stmt.type) {
-	case duckdb_libpgquery::T_PGRawStmt: {
-		auto &raw_stmt = PGCast<duckdb_libpgquery::PGRawStmt>(stmt);
-		auto result = TransformStatement(*raw_stmt.stmt);
-		if (result) {
-			result->stmt_location = NumericCast<idx_t>(raw_stmt.stmt_location);
-			result->stmt_length = NumericCast<idx_t>(raw_stmt.stmt_len);
-		}
-		return result;
-	}
-	case duckdb_libpgquery::T_PGSelectStmt:
-		return TransformSelectStmt(PGCast<duckdb_libpgquery::PGSelectStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateStmt:
-		return TransformCreateTable(PGCast<duckdb_libpgquery::PGCreateStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateSchemaStmt:
-		return TransformCreateSchema(PGCast<duckdb_libpgquery::PGCreateSchemaStmt>(stmt));
-	case duckdb_libpgquery::T_PGViewStmt:
-		return TransformCreateView(PGCast<duckdb_libpgquery::PGViewStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateSeqStmt:
-		return TransformCreateSequence(PGCast<duckdb_libpgquery::PGCreateSeqStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateFunctionStmt:
-		return TransformCreateFunction(PGCast<duckdb_libpgquery::PGCreateFunctionStmt>(stmt));
-	case duckdb_libpgquery::T_PGDropStmt:
-		return TransformDrop(PGCast<duckdb_libpgquery::PGDropStmt>(stmt));
-	case duckdb_libpgquery::T_PGInsertStmt:
-		return TransformInsert(PGCast<duckdb_libpgquery::PGInsertStmt>(stmt));
-	case duckdb_libpgquery::T_PGCopyStmt:
-		return TransformCopy(PGCast<duckdb_libpgquery::PGCopyStmt>(stmt));
-	case duckdb_libpgquery::T_PGTransactionStmt:
-		return TransformTransaction(PGCast<duckdb_libpgquery::PGTransactionStmt>(stmt));
-	case duckdb_libpgquery::T_PGDeleteStmt:
-		return TransformDelete(PGCast<duckdb_libpgquery::PGDeleteStmt>(stmt));
-	case duckdb_libpgquery::T_PGUpdateStmt:
-		return TransformUpdate(PGCast<duckdb_libpgquery::PGUpdateStmt>(stmt));
-	case duckdb_libpgquery::T_PGUpdateExtensionsStmt:
-		return TransformUpdateExtensions(PGCast<duckdb_libpgquery::PGUpdateExtensionsStmt>(stmt));
-	case duckdb_libpgquery::T_PGIndexStmt:
-		return TransformCreateIndex(PGCast<duckdb_libpgquery::PGIndexStmt>(stmt));
-	case duckdb_libpgquery::T_PGAlterTableStmt:
-		return TransformAlter(PGCast<duckdb_libpgquery::PGAlterTableStmt>(stmt));
-	case duckdb_libpgquery::T_PGRenameStmt:
-		return TransformRename(PGCast<duckdb_libpgquery::PGRenameStmt>(stmt));
-	case duckdb_libpgquery::T_PGPrepareStmt:
-		return TransformPrepare(PGCast<duckdb_libpgquery::PGPrepareStmt>(stmt));
-	case duckdb_libpgquery::T_PGExecuteStmt:
-		return TransformExecute(PGCast<duckdb_libpgquery::PGExecuteStmt>(stmt));
-	case duckdb_libpgquery::T_PGDeallocateStmt:
-		return TransformDeallocate(PGCast<duckdb_libpgquery::PGDeallocateStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateTableAsStmt:
-		return TransformCreateTableAs(PGCast<duckdb_libpgquery::PGCreateTableAsStmt>(stmt));
-	case duckdb_libpgquery::T_PGPragmaStmt:
-		return TransformPragma(PGCast<duckdb_libpgquery::PGPragmaStmt>(stmt));
-	case duckdb_libpgquery::T_PGExportStmt:
-		return TransformExport(PGCast<duckdb_libpgquery::PGExportStmt>(stmt));
-	case duckdb_libpgquery::T_PGImportStmt:
-		return TransformImport(PGCast<duckdb_libpgquery::PGImportStmt>(stmt));
-	case duckdb_libpgquery::T_PGExplainStmt:
-		return TransformExplain(PGCast<duckdb_libpgquery::PGExplainStmt>(stmt));
-	case duckdb_libpgquery::T_PGVacuumStmt:
-		return TransformVacuum(PGCast<duckdb_libpgquery::PGVacuumStmt>(stmt));
-	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return TransformShowStmt(PGCast<duckdb_libpgquery::PGVariableShowStmt>(stmt));
-	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return TransformShowSelectStmt(PGCast<duckdb_libpgquery::PGVariableShowSelectStmt>(stmt));
-	case duckdb_libpgquery::T_PGCallStmt:
-		return TransformCall(PGCast<duckdb_libpgquery::PGCallStmt>(stmt));
-	case duckdb_libpgquery::T_PGVariableSetStmt:
-		return TransformSet(PGCast<duckdb_libpgquery::PGVariableSetStmt>(stmt));
-	case duckdb_libpgquery::T_PGCheckPointStmt:
-		return TransformCheckpoint(PGCast<duckdb_libpgquery::PGCheckPointStmt>(stmt));
-	case duckdb_libpgquery::T_PGLoadStmt:
-		return TransformLoad(PGCast<duckdb_libpgquery::PGLoadStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateTypeStmt:
-		return TransformCreateType(PGCast<duckdb_libpgquery::PGCreateTypeStmt>(stmt));
-	case duckdb_libpgquery::T_PGAlterSeqStmt:
-		return TransformAlterSequence(PGCast<duckdb_libpgquery::PGAlterSeqStmt>(stmt));
-	case duckdb_libpgquery::T_PGAttachStmt:
-		return TransformAttach(PGCast<duckdb_libpgquery::PGAttachStmt>(stmt));
-	case duckdb_libpgquery::T_PGDetachStmt:
-		return TransformDetach(PGCast<duckdb_libpgquery::PGDetachStmt>(stmt));
-	case duckdb_libpgquery::T_PGUseStmt:
-		return TransformUse(PGCast<duckdb_libpgquery::PGUseStmt>(stmt));
-	case duckdb_libpgquery::T_PGCopyDatabaseStmt:
-		return TransformCopyDatabase(PGCast<duckdb_libpgquery::PGCopyDatabaseStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateSecretStmt:
-		return TransformSecret(PGCast<duckdb_libpgquery::PGCreateSecretStmt>(stmt));
-	case duckdb_libpgquery::T_PGDropSecretStmt:
-		return TransformDropSecret(PGCast<duckdb_libpgquery::PGDropSecretStmt>(stmt));
-	case duckdb_libpgquery::T_PGCommentOnStmt:
-		return TransformCommentOn(PGCast<duckdb_libpgquery::PGCommentOnStmt>(stmt));
-	default:
-		throw NotImplementedException(NodetypeToString(stmt.type));
-	}
-}
-
-unique_ptr<QueryNode> Transformer::TransformMaterializedCTE(unique_ptr<QueryNode> root) {
-	// Extract materialized CTEs from cte_map
-	vector<unique_ptr<CTENode>> materialized_ctes;
-
-	for (auto &cte : root->cte_map.map) {
-		auto &cte_entry = cte.second;
-		if (cte_entry->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-			auto mat_cte = make_uniq<CTENode>();
-			mat_cte->ctename = cte.first;
-			mat_cte->query = cte_entry->query->node->Copy();
-			mat_cte->aliases = cte_entry->aliases;
-			materialized_ctes.push_back(std::move(mat_cte));
-		}
-	}
-
-	while (!materialized_ctes.empty()) {
-		unique_ptr<CTENode> node_result;
-		node_result = std::move(materialized_ctes.back());
-		node_result->cte_map = root->cte_map.Copy();
-		node_result->child = std::move(root);
-		root = std::move(node_result);
-		materialized_ctes.pop_back();
-	}
-
-	return root;
-}
-
-void Transformer::SetQueryLocation(ParsedExpression &expr, int query_location) {
-	if (query_location < 0) {
-		return;
-	}
-	expr.SetQueryLocation(optional_idx(static_cast<idx_t>(query_location)));
-}
-
-void Transformer::SetQueryLocation(TableRef &ref, int query_location) {
-	if (query_location < 0) {
-		return;
-	}
-	ref.query_location = optional_idx(static_cast<idx_t>(query_location));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/bind_context.cpp b/src/duckdb/src/planner/bind_context.cpp
deleted file mode 100644
index d135ed2ae..000000000
--- a/src/duckdb/src/planner/bind_context.cpp
+++ /dev/null
@@ -1,738 +0,0 @@
-#include "duckdb/planner/bind_context.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-BindContext::BindContext(Binder &binder) : binder(binder) {
-}
-
-string MinimumUniqueAlias(const BindingAlias &alias, const BindingAlias &other) {
-	if (!StringUtil::CIEquals(alias.GetAlias(), other.GetAlias())) {
-		return alias.GetAlias();
-	}
-	if (!StringUtil::CIEquals(alias.GetSchema(), other.GetSchema())) {
-		return alias.GetSchema() + "." + alias.GetAlias();
-	}
-	return alias.ToString();
-}
-
-optional_ptr<Binding> BindContext::GetMatchingBinding(const string &column_name) {
-	optional_ptr<Binding> result;
-	for (auto &binding_ptr : bindings_list) {
-		auto &binding = *binding_ptr;
-		auto is_using_binding = GetUsingBinding(column_name, binding.alias);
-		if (is_using_binding) {
-			continue;
-		}
-		if (binding.HasMatchingBinding(column_name)) {
-			if (result || is_using_binding) {
-				throw BinderException("Ambiguous reference to column name \"%s\" (use: \"%s.%s\" "
-				                      "or \"%s.%s\")",
-				                      column_name, MinimumUniqueAlias(result->alias, binding.alias), column_name,
-				                      MinimumUniqueAlias(binding.alias, result->alias), column_name);
-			}
-			result = &binding;
-		}
-	}
-	return result;
-}
-
-vector<string> BindContext::GetSimilarBindings(const string &column_name) {
-	vector<pair<string, double>> scores;
-	for (auto &binding_ptr : bindings_list) {
-		auto binding = *binding_ptr;
-		for (auto &name : binding.names) {
-			double distance = StringUtil::SimilarityRating(name, column_name);
-			// check if we need to qualify the column
-			auto matching_bindings = GetMatchingBindings(name);
-			if (matching_bindings.size() > 1) {
-				scores.emplace_back(binding.GetAlias() + "." + name, distance);
-			} else {
-				scores.emplace_back(name, distance);
-			}
-		}
-	}
-	return StringUtil::TopNStrings(scores);
-}
-
-void BindContext::AddUsingBinding(const string &column_name, UsingColumnSet &set) {
-	using_columns[column_name].insert(set);
-}
-
-void BindContext::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
-	using_column_sets.push_back(std::move(set));
-}
-
-optional_ptr<UsingColumnSet> BindContext::GetUsingBinding(const string &column_name) {
-	auto entry = using_columns.find(column_name);
-	if (entry == using_columns.end()) {
-		return nullptr;
-	}
-	auto &using_bindings = entry->second;
-	if (using_bindings.size() > 1) {
-		string error = "Ambiguous column reference: column \"" + column_name + "\" can refer to either:\n";
-		for (auto &using_set_ref : using_bindings) {
-			auto &using_set = using_set_ref.get();
-			string result_bindings;
-			for (auto &binding : using_set.bindings) {
-				if (result_bindings.empty()) {
-					result_bindings = "[";
-				} else {
-					result_bindings += ", ";
-				}
-				result_bindings += binding.GetAlias();
-				result_bindings += ".";
-				result_bindings += GetActualColumnName(binding, column_name);
-			}
-			error += result_bindings + "]";
-		}
-		throw BinderException(error);
-	}
-	for (auto &using_set : using_bindings) {
-		return &using_set.get();
-	}
-	throw InternalException("Using binding found but no entries");
-}
-
-optional_ptr<UsingColumnSet> BindContext::GetUsingBinding(const string &column_name, const BindingAlias &binding) {
-	if (!binding.IsSet()) {
-		throw InternalException("GetUsingBinding: expected non-empty binding_name");
-	}
-	auto entry = using_columns.find(column_name);
-	if (entry == using_columns.end()) {
-		return nullptr;
-	}
-	auto &using_bindings = entry->second;
-	for (auto &using_set_ref : using_bindings) {
-		auto &using_set = using_set_ref.get();
-		auto &bindings = using_set.bindings;
-		for (auto &using_binding : bindings) {
-			if (using_binding == binding) {
-				return &using_set;
-			}
-		}
-	}
-	return nullptr;
-}
-
-void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet &set) {
-	auto entry = using_columns.find(column_name);
-	if (entry == using_columns.end()) {
-		throw InternalException("Attempting to remove using binding that is not there");
-	}
-	auto &bindings = entry->second;
-	if (bindings.find(set) != bindings.end()) {
-		bindings.erase(set);
-	}
-	if (bindings.empty()) {
-		using_columns.erase(column_name);
-	}
-}
-
-void BindContext::TransferUsingBinding(BindContext &current_context, optional_ptr<UsingColumnSet> current_set,
-                                       UsingColumnSet &new_set, const string &using_column) {
-	AddUsingBinding(using_column, new_set);
-	if (current_set) {
-		current_context.RemoveUsingBinding(using_column, *current_set);
-	}
-}
-
-string BindContext::GetActualColumnName(Binding &binding, const string &column_name) {
-	column_t binding_index;
-	if (!binding.TryGetBindingIndex(column_name, binding_index)) { // LCOV_EXCL_START
-		throw InternalException("Binding with name \"%s\" does not have a column named \"%s\"", binding.GetAlias(),
-		                        column_name);
-	} // LCOV_EXCL_STOP
-	return binding.names[binding_index];
-}
-
-string BindContext::GetActualColumnName(const BindingAlias &binding_alias, const string &column_name) {
-	ErrorData error;
-	auto binding = GetBinding(binding_alias, error);
-	if (!binding) {
-		throw InternalException("No binding with name \"%s\": %s", binding_alias.GetAlias(), error.RawMessage());
-	}
-	return GetActualColumnName(*binding, column_name);
-}
-
-vector<reference<Binding>> BindContext::GetMatchingBindings(const string &column_name) {
-	vector<reference<Binding>> result;
-	for (auto &binding_ptr : bindings_list) {
-		auto &binding = *binding_ptr;
-		if (binding.HasMatchingBinding(column_name)) {
-			result.push_back(binding);
-		}
-	}
-	return result;
-}
-
-unique_ptr<ParsedExpression> BindContext::ExpandGeneratedColumn(TableBinding &table_binding,
-                                                                const string &column_name) {
-	auto result = table_binding.ExpandGeneratedColumn(column_name);
-	result->SetAlias(column_name);
-	return result;
-}
-
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const BindingAlias &table_alias,
-                                                                const string &column_name, ColumnBindType bind_type) {
-	return CreateColumnReference(table_alias.GetCatalog(), table_alias.GetSchema(), table_alias.GetAlias(), column_name,
-	                             bind_type);
-}
-
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &table_name, const string &column_name,
-                                                                ColumnBindType bind_type) {
-	string schema_name;
-	return CreateColumnReference(schema_name, table_name, column_name, bind_type);
-}
-
-static bool ColumnIsGenerated(Binding &binding, column_t index) {
-	if (binding.binding_type != BindingType::TABLE) {
-		return false;
-	}
-	auto &table_binding = binding.Cast<TableBinding>();
-	auto catalog_entry = table_binding.GetStandardEntry();
-	if (!catalog_entry) {
-		return false;
-	}
-	if (index == COLUMN_IDENTIFIER_ROW_ID) {
-		return false;
-	}
-	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto &table_entry = catalog_entry->Cast<TableCatalogEntry>();
-	return table_entry.GetColumn(LogicalIndex(index)).Generated();
-}
-
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &catalog_name, const string &schema_name,
-                                                                const string &table_name, const string &column_name,
-                                                                ColumnBindType bind_type) {
-	ErrorData error;
-	vector<string> names;
-	if (!catalog_name.empty()) {
-		names.push_back(catalog_name);
-	}
-	if (!schema_name.empty()) {
-		names.push_back(schema_name);
-	}
-	names.push_back(table_name);
-	names.push_back(column_name);
-
-	BindingAlias alias(catalog_name, schema_name, table_name);
-	auto result = make_uniq<ColumnRefExpression>(std::move(names));
-	auto binding = GetBinding(alias, column_name, error);
-	if (!binding) {
-		return std::move(result);
-	}
-	auto column_index = binding->GetBindingIndex(column_name);
-	if (bind_type == ColumnBindType::EXPAND_GENERATED_COLUMNS && ColumnIsGenerated(*binding, column_index)) {
-		return ExpandGeneratedColumn(binding->Cast<TableBinding>(), column_name);
-	} else if (column_index < binding->names.size() && binding->names[column_index] != column_name) {
-		// because of case insensitivity in the binder we rename the column to the original name
-		// as it appears in the binding itself
-		result->SetAlias(binding->names[column_index]);
-	}
-	return std::move(result);
-}
-
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &schema_name, const string &table_name,
-                                                                const string &column_name, ColumnBindType bind_type) {
-	string catalog_name;
-	return CreateColumnReference(catalog_name, schema_name, table_name, column_name, bind_type);
-}
-
-optional_ptr<Binding> BindContext::GetCTEBinding(const string &ctename) {
-	auto match = cte_bindings.find(ctename);
-	if (match == cte_bindings.end()) {
-		return nullptr;
-	}
-	return match->second.get();
-}
-
-vector<reference<Binding>> BindContext::GetBindings(const BindingAlias &alias, ErrorData &out_error) {
-	if (!alias.IsSet()) {
-		throw InternalException("BindingAlias is not set");
-	}
-	vector<reference<Binding>> matching_bindings;
-	for (auto &binding : bindings_list) {
-		if (binding->alias.Matches(alias)) {
-			matching_bindings.push_back(*binding);
-		}
-	}
-	if (matching_bindings.empty()) {
-		// alias not found in this BindContext
-		vector<string> candidates;
-		for (auto &binding : bindings_list) {
-			candidates.push_back(binding->alias.GetAlias());
-		}
-		string candidate_str = StringUtil::CandidatesMessage(StringUtil::TopNJaroWinkler(candidates, alias.GetAlias()),
-		                                                     "Candidate tables");
-		out_error = ErrorData(ExceptionType::BINDER, StringUtil::Format("Referenced table \"%s\" not found!%s",
-		                                                                alias.GetAlias(), candidate_str));
-	}
-	return matching_bindings;
-}
-
-string BindContext::AmbiguityException(const BindingAlias &alias, const vector<reference<Binding>> &bindings) {
-	D_ASSERT(bindings.size() > 1);
-	// found multiple matching aliases
-	string result = "(use: ";
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (i > 0) {
-			if (i + 1 == bindings.size()) {
-				result += " or ";
-			} else {
-				result += ", ";
-			}
-		}
-		// find the minimum alias that uniquely describes this table reference
-		auto &current_alias = bindings[i].get().alias;
-		string minimum_alias;
-		bool duplicate_alias = false;
-		for (idx_t k = 0; k < bindings.size(); k++) {
-			if (k == i) {
-				continue;
-			}
-			auto &other_alias = bindings[k].get().alias;
-			if (current_alias == other_alias) {
-				duplicate_alias = true;
-			}
-			string new_minimum_alias = MinimumUniqueAlias(current_alias, other_alias);
-			if (new_minimum_alias.size() > minimum_alias.size()) {
-				minimum_alias = std::move(new_minimum_alias);
-			}
-		}
-		if (duplicate_alias) {
-			result = "(duplicate alias \"" + alias.ToString() +
-			         "\", explicitly alias one of the tables using \"AS my_alias\"";
-		} else {
-			result += minimum_alias;
-		}
-	}
-	result += ")";
-	return result;
-}
-
-optional_ptr<Binding> BindContext::GetBinding(const BindingAlias &alias, const string &column_name,
-                                              ErrorData &out_error) {
-	auto matching_bindings = GetBindings(alias, out_error);
-	if (matching_bindings.empty()) {
-		// no bindings found
-		return nullptr;
-	}
-
-	optional_ptr<Binding> result;
-	// find the binding that this column name belongs to
-	for (auto &binding_ref : matching_bindings) {
-		auto &binding = binding_ref.get();
-		if (!binding.HasMatchingBinding(column_name)) {
-			continue;
-		}
-		if (result) {
-			// we found multiple bindings that this column name belongs to - ambiguity
-			string helper_message = AmbiguityException(alias, matching_bindings);
-			throw BinderException("Ambiguous reference to table \"%s\" %s", alias.ToString(), helper_message);
-		} else {
-			result = &binding;
-		}
-	}
-	if (!result) {
-		// found the table binding - but could not find the column
-		out_error = matching_bindings[0].get().ColumnNotFoundError(column_name);
-	}
-	return result;
-}
-
-optional_ptr<Binding> BindContext::GetBinding(const BindingAlias &alias, ErrorData &out_error) {
-	auto matching_bindings = GetBindings(alias, out_error);
-	if (matching_bindings.empty()) {
-		return nullptr;
-	}
-	if (matching_bindings.size() > 1) {
-		string helper_message = AmbiguityException(alias, matching_bindings);
-		throw BinderException("Ambiguous reference to table \"%s\" %s", alias.ToString(), helper_message);
-	}
-	// found a single matching alias
-	return &matching_bindings[0].get();
-}
-
-optional_ptr<Binding> BindContext::GetBinding(const string &name, ErrorData &out_error) {
-	return GetBinding(BindingAlias(name), out_error);
-}
-
-BindingAlias GetBindingAlias(ColumnRefExpression &colref) {
-	if (colref.column_names.size() <= 1 || colref.column_names.size() > 4) {
-		throw InternalException("Cannot get binding alias from column ref unless it has 2..4 entries");
-	}
-	if (colref.column_names.size() >= 4) {
-		return BindingAlias(colref.column_names[0], colref.column_names[1], colref.column_names[2]);
-	}
-	if (colref.column_names.size() == 3) {
-		return BindingAlias(colref.column_names[0], colref.column_names[1]);
-	}
-	return BindingAlias(colref.column_names[0]);
-}
-
-BindResult BindContext::BindColumn(ColumnRefExpression &colref, idx_t depth) {
-	if (!colref.IsQualified()) {
-		throw InternalException("Could not bind alias \"%s\"!", colref.GetColumnName());
-	}
-
-	ErrorData error;
-	BindingAlias alias;
-	auto binding = GetBinding(GetBindingAlias(colref), colref.GetColumnName(), error);
-	if (!binding) {
-		return BindResult(std::move(error));
-	}
-	return binding->Bind(colref, depth);
-}
-
-string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name) {
-	idx_t total_columns = 0;
-	idx_t current_position = ref.index - 1;
-	for (auto &entry : bindings_list) {
-		auto &binding = *entry;
-		idx_t entry_column_count = binding.names.size();
-		if (ref.index == 0) {
-			// this is a row id
-			table_name = binding.alias.GetAlias();
-			column_name = "rowid";
-			return string();
-		}
-		if (current_position < entry_column_count) {
-			table_name = binding.alias.GetAlias();
-			column_name = binding.names[current_position];
-			return string();
-		} else {
-			total_columns += entry_column_count;
-			current_position -= entry_column_count;
-		}
-	}
-	return StringUtil::Format("Positional reference %d out of range (total %d columns)", ref.index, total_columns);
-}
-
-unique_ptr<ColumnRefExpression> BindContext::PositionToColumn(PositionalReferenceExpression &ref) {
-	string table_name, column_name;
-
-	string error = BindColumn(ref, table_name, column_name);
-	if (!error.empty()) {
-		throw BinderException(error);
-	}
-	return make_uniq<ColumnRefExpression>(column_name, table_name);
-}
-
-struct ExclusionListInfo {
-	explicit ExclusionListInfo(vector<unique_ptr<ParsedExpression>> &new_select_list)
-	    : new_select_list(new_select_list) {
-	}
-
-	vector<unique_ptr<ParsedExpression>> &new_select_list;
-	case_insensitive_set_t excluded_columns;
-	qualified_column_set_t excluded_qualified_columns;
-};
-
-bool CheckExclusionList(StarExpression &expr, const QualifiedColumnName &qualified_name, ExclusionListInfo &info) {
-	if (expr.exclude_list.find(qualified_name) != expr.exclude_list.end()) {
-		info.excluded_qualified_columns.insert(qualified_name);
-		return true;
-	}
-	auto entry = expr.replace_list.find(qualified_name.column);
-	if (entry != expr.replace_list.end()) {
-		auto new_entry = entry->second->Copy();
-		new_entry->SetAlias(entry->first);
-		info.excluded_columns.insert(entry->first);
-		info.new_select_list.push_back(std::move(new_entry));
-		return true;
-	}
-	return false;
-}
-
-void HandleRename(StarExpression &expr, const QualifiedColumnName &qualified_name, ParsedExpression &new_expr) {
-	auto rename_entry = expr.rename_list.find(qualified_name);
-	if (rename_entry != expr.rename_list.end()) {
-		new_expr.SetAlias(rename_entry->second);
-	}
-}
-
-void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
-                                               vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	if (bindings_list.empty()) {
-		throw BinderException("* expression without FROM clause!");
-	}
-	ExclusionListInfo exclusion_info(new_select_list);
-	if (expr.relation_name.empty()) {
-		// SELECT * case
-		// bind all expressions of each table in-order
-		reference_set_t<UsingColumnSet> handled_using_columns;
-		for (auto &entry : bindings_list) {
-			auto &binding = *entry;
-			for (auto &column_name : binding.names) {
-				QualifiedColumnName qualified_column(binding.alias, column_name);
-				if (CheckExclusionList(expr, qualified_column, exclusion_info)) {
-					continue;
-				}
-				// check if this column is a USING column
-				auto using_binding_ptr = GetUsingBinding(column_name, binding.alias);
-				if (using_binding_ptr) {
-					auto &using_binding = *using_binding_ptr;
-					// it is!
-					// check if we have already emitted the using column
-					if (handled_using_columns.find(using_binding) != handled_using_columns.end()) {
-						// we have! bail out
-						continue;
-					}
-					// we have not! output the using column
-					if (!using_binding.primary_binding.IsSet()) {
-						// no primary binding: output a coalesce
-						auto coalesce = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-						for (auto &child_binding : using_binding.bindings) {
-							coalesce->children.push_back(make_uniq<ColumnRefExpression>(column_name, child_binding));
-						}
-						coalesce->SetAlias(column_name);
-						HandleRename(expr, qualified_column, *coalesce);
-						new_select_list.push_back(std::move(coalesce));
-					} else {
-						// primary binding: output the qualified column ref
-						auto new_expr = make_uniq<ColumnRefExpression>(column_name, using_binding.primary_binding);
-						HandleRename(expr, qualified_column, *new_expr);
-						new_select_list.push_back(std::move(new_expr));
-					}
-					handled_using_columns.insert(using_binding);
-					continue;
-				}
-				auto new_expr =
-				    CreateColumnReference(binding.alias, column_name, ColumnBindType::DO_NOT_EXPAND_GENERATED_COLUMNS);
-				HandleRename(expr, qualified_column, *new_expr);
-				new_select_list.push_back(std::move(new_expr));
-			}
-		}
-	} else {
-		// SELECT tbl.* case
-		// SELECT struct.* case
-		ErrorData error;
-		auto binding = GetBinding(expr.relation_name, error);
-		bool is_struct_ref = false;
-		if (!binding) {
-			binding = GetMatchingBinding(expr.relation_name);
-			if (!binding) {
-				error.Throw();
-			}
-			is_struct_ref = true;
-		}
-
-		if (is_struct_ref) {
-			auto col_idx = binding->GetBindingIndex(expr.relation_name);
-			auto col_type = binding->types[col_idx];
-			if (col_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException(StringUtil::Format(
-				    "Cannot extract field from expression \"%s\" because it is not a struct", expr.ToString()));
-			}
-			auto &struct_children = StructType::GetChildTypes(col_type);
-			vector<string> column_names(3);
-			column_names[0] = binding->alias.GetAlias();
-			column_names[1] = expr.relation_name;
-			for (auto &child : struct_children) {
-				QualifiedColumnName qualified_name(child.first);
-				if (CheckExclusionList(expr, qualified_name, exclusion_info)) {
-					continue;
-				}
-				column_names[2] = child.first;
-				auto new_expr = make_uniq<ColumnRefExpression>(column_names);
-				HandleRename(expr, qualified_name, *new_expr);
-				new_select_list.push_back(std::move(new_expr));
-			}
-		} else {
-			for (auto &column_name : binding->names) {
-				QualifiedColumnName qualified_name(binding->alias, column_name);
-				if (CheckExclusionList(expr, qualified_name, exclusion_info)) {
-					continue;
-				}
-				auto new_expr =
-				    CreateColumnReference(binding->alias, column_name, ColumnBindType::DO_NOT_EXPAND_GENERATED_COLUMNS);
-				HandleRename(expr, qualified_name, *new_expr);
-				new_select_list.push_back(std::move(new_expr));
-			}
-		}
-	}
-	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		expr.exclude_list.clear();
-		expr.replace_list.clear();
-	}
-	for (auto &excluded : expr.exclude_list) {
-		if (exclusion_info.excluded_qualified_columns.find(excluded) ==
-		    exclusion_info.excluded_qualified_columns.end()) {
-			throw BinderException("Column \"%s\" in EXCLUDE list not found in %s", excluded.ToString(),
-			                      expr.relation_name.empty() ? "FROM clause" : expr.relation_name.c_str());
-		}
-	}
-	for (auto &entry : expr.replace_list) {
-		if (exclusion_info.excluded_columns.find(entry.first) == exclusion_info.excluded_columns.end()) {
-			throw BinderException("Column \"%s\" in REPLACE list not found in %s", entry.first,
-			                      expr.relation_name.empty() ? "FROM clause" : expr.relation_name.c_str());
-		}
-	}
-}
-
-void BindContext::GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types) {
-	for (auto &binding_entry : bindings_list) {
-		auto &binding = *binding_entry;
-		D_ASSERT(binding.names.size() == binding.types.size());
-		for (idx_t i = 0; i < binding.names.size(); i++) {
-			result_names.push_back(binding.names[i]);
-			result_types.push_back(binding.types[i]);
-		}
-	}
-}
-
-void BindContext::AddBinding(unique_ptr<Binding> binding) {
-	bindings_list.push_back(std::move(binding));
-}
-
-void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
-                               const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
-                               StandardEntry &entry, bool add_row_id) {
-	AddBinding(make_uniq<TableBinding>(alias, types, names, bound_column_ids, &entry, index, add_row_id));
-}
-
-void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
-                               const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
-                               const string &table_name) {
-	AddBinding(make_uniq<TableBinding>(alias.empty() ? table_name : alias, types, names, bound_column_ids, nullptr,
-	                                   index, true));
-}
-
-void BindContext::AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
-                                   const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
-                                   optional_ptr<StandardEntry> entry) {
-	AddBinding(make_uniq<TableBinding>(alias, types, names, bound_column_ids, entry, index));
-}
-
-static string AddColumnNameToBinding(const string &base_name, case_insensitive_set_t &current_names) {
-	idx_t index = 1;
-	string name = base_name;
-	while (current_names.find(name) != current_names.end()) {
-		name = base_name + "_" + std::to_string(index++);
-	}
-	current_names.insert(name);
-	return name;
-}
-
-vector<string> BindContext::AliasColumnNames(const string &table_name, const vector<string> &names,
-                                             const vector<string> &column_aliases) {
-	vector<string> result;
-	if (column_aliases.size() > names.size()) {
-		throw BinderException("table \"%s\" has %lld columns available but %lld columns specified", table_name,
-		                      names.size(), column_aliases.size());
-	}
-	case_insensitive_set_t current_names;
-	// use any provided column aliases first
-	for (idx_t i = 0; i < column_aliases.size(); i++) {
-		result.push_back(AddColumnNameToBinding(column_aliases[i], current_names));
-	}
-	// if not enough aliases were provided, use the default names for remaining columns
-	for (idx_t i = column_aliases.size(); i < names.size(); i++) {
-		result.push_back(AddColumnNameToBinding(names[i], current_names));
-	}
-	return result;
-}
-
-void BindContext::AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery) {
-	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddGenericBinding(index, alias, names, subquery.types);
-}
-
-void BindContext::AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
-                                  const vector<LogicalType> &types, StandardEntry &entry) {
-	AddBinding(make_uniq<EntryBinding>(alias, types, names, index, entry));
-}
-
-void BindContext::AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery,
-                          ViewCatalogEntry &view) {
-	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddEntryBinding(index, alias, names, subquery.types, view.Cast<StandardEntry>());
-}
-
-void BindContext::AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery) {
-	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddGenericBinding(index, alias, names, subquery.types);
-}
-
-void BindContext::AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
-                                    const vector<LogicalType> &types) {
-	AddBinding(make_uniq<Binding>(BindingType::BASE, BindingAlias(alias), types, names, index));
-}
-
-void BindContext::AddCTEBinding(idx_t index, const string &alias, const vector<string> &names,
-                                const vector<LogicalType> &types) {
-	auto binding = make_shared_ptr<Binding>(BindingType::BASE, BindingAlias(alias), types, names, index);
-
-	if (cte_bindings.find(alias) != cte_bindings.end()) {
-		throw BinderException("Duplicate CTE binding \"%s\" in query!", alias);
-	}
-	cte_bindings[alias] = std::move(binding);
-	cte_references[alias] = make_shared_ptr<idx_t>(0);
-}
-
-void BindContext::AddContext(BindContext other) {
-	for (auto &binding : other.bindings_list) {
-		AddBinding(std::move(binding));
-	}
-	for (auto &entry : other.using_columns) {
-		for (auto &alias : entry.second) {
-			using_columns[entry.first].insert(alias);
-		}
-	}
-}
-
-vector<BindingAlias> BindContext::GetBindingAliases() {
-	vector<BindingAlias> result;
-	for (auto &binding : bindings_list) {
-		result.push_back(BindingAlias(binding->alias));
-	}
-	return result;
-}
-
-void BindContext::RemoveContext(const vector<BindingAlias> &aliases) {
-	for (auto &alias : aliases) {
-		// remove the binding from any USING columns
-		vector<string> removed_using_columns;
-		for (auto &using_sets : using_columns) {
-			for (auto &using_set_ref : using_sets.second) {
-				auto &using_set = using_set_ref.get();
-				auto it = std::remove_if(using_set.bindings.begin(), using_set.bindings.end(),
-				                         [&](const BindingAlias &using_alias) { return using_alias == alias; });
-				using_set.bindings.erase(it, using_set.bindings.end());
-				if (using_set.bindings.empty() || using_set.primary_binding == alias) {
-					// if the using column is no longer referred to - remove it entirely
-					removed_using_columns.push_back(using_sets.first);
-				}
-			}
-		}
-		for (auto &removed_col : removed_using_columns) {
-			using_columns.erase(removed_col);
-		}
-
-		// remove the binding from the list of bindings
-		auto it = std::remove_if(bindings_list.begin(), bindings_list.end(),
-		                         [&](unique_ptr<Binding> &x) { return x->alias == alias; });
-		bindings_list.erase(it, bindings_list.end());
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder.cpp b/src/duckdb/src/planner/binder.cpp
deleted file mode 100644
index 7333ac393..000000000
--- a/src/duckdb/src/planner/binder.cpp
+++ /dev/null
@@ -1,733 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/query_node/list.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/list.hpp"
-#include "duckdb/parser/tableref/list.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression_binder/returning_binder.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/planner/query_node/list.hpp"
-#include "duckdb/planner/tableref/list.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-Binder &Binder::GetRootBinder() {
-	reference<Binder> root = *this;
-	while (root.get().parent) {
-		root = *root.get().parent;
-	}
-	return root.get();
-}
-
-idx_t Binder::GetBinderDepth() const {
-	const_reference<Binder> root = *this;
-	idx_t depth = 1;
-	while (root.get().parent) {
-		depth++;
-		root = *root.get().parent;
-	}
-	return depth;
-}
-
-shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, optional_ptr<Binder> parent, BinderType binder_type) {
-	auto depth = parent ? parent->GetBinderDepth() : 0;
-	if (depth > context.config.max_expression_depth) {
-		throw BinderException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
-		                      "increase the maximum expression depth.",
-		                      context.config.max_expression_depth);
-	}
-	return shared_ptr<Binder>(new Binder(context, parent ? parent->shared_from_this() : nullptr, binder_type));
-}
-
-Binder::Binder(ClientContext &context, shared_ptr<Binder> parent_p, BinderType binder_type)
-    : context(context), bind_context(*this), parent(std::move(parent_p)), bound_tables(0), binder_type(binder_type),
-      entry_retriever(context) {
-	if (parent) {
-		entry_retriever.Inherit(parent->entry_retriever);
-
-		// We have to inherit macro and lambda parameter bindings and from the parent binder, if there is a parent.
-		macro_binding = parent->macro_binding;
-		lambda_bindings = parent->lambda_bindings;
-
-		if (binder_type == BinderType::REGULAR_BINDER) {
-			// We have to inherit CTE bindings from the parent bind_context, if there is a parent.
-			bind_context.SetCTEBindings(parent->bind_context.GetCTEBindings());
-			bind_context.cte_references = parent->bind_context.cte_references;
-			parameters = parent->parameters;
-		}
-	}
-}
-
-unique_ptr<BoundCTENode> Binder::BindMaterializedCTE(CommonTableExpressionMap &cte_map) {
-	// Extract materialized CTEs from cte_map
-	vector<unique_ptr<CTENode>> materialized_ctes;
-	for (auto &cte : cte_map.map) {
-		auto &cte_entry = cte.second;
-		if (cte_entry->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-			auto mat_cte = make_uniq<CTENode>();
-			mat_cte->ctename = cte.first;
-			mat_cte->query = cte_entry->query->node->Copy();
-			mat_cte->aliases = cte_entry->aliases;
-			materialized_ctes.push_back(std::move(mat_cte));
-		}
-	}
-
-	if (materialized_ctes.empty()) {
-		return nullptr;
-	}
-
-	unique_ptr<CTENode> cte_root = nullptr;
-	while (!materialized_ctes.empty()) {
-		unique_ptr<CTENode> node_result;
-		node_result = std::move(materialized_ctes.back());
-		node_result->cte_map = cte_map.Copy();
-		if (cte_root) {
-			node_result->child = std::move(cte_root);
-		} else {
-			node_result->child = nullptr;
-		}
-		cte_root = std::move(node_result);
-		materialized_ctes.pop_back();
-	}
-
-	AddCTEMap(cte_map);
-	auto bound_cte = BindCTE(cte_root->Cast<CTENode>());
-
-	return bound_cte;
-}
-
-template <class T>
-BoundStatement Binder::BindWithCTE(T &statement) {
-	BoundStatement bound_statement;
-	auto bound_cte = BindMaterializedCTE(statement.template Cast<T>().cte_map);
-	if (bound_cte) {
-		reference<BoundCTENode> tail_ref = *bound_cte;
-
-		while (tail_ref.get().child && tail_ref.get().child->type == QueryNodeType::CTE_NODE) {
-			tail_ref = tail_ref.get().child->Cast<BoundCTENode>();
-		}
-
-		auto &tail = tail_ref.get();
-		bound_statement = tail.child_binder->Bind(statement.template Cast<T>());
-
-		tail.types = bound_statement.types;
-		tail.names = bound_statement.names;
-
-		for (auto &c : tail.query_binder->correlated_columns) {
-			tail.child_binder->AddCorrelatedColumn(c);
-		}
-		MoveCorrelatedExpressions(*tail.child_binder);
-
-		auto plan = std::move(bound_statement.plan);
-		bound_statement.plan = CreatePlan(*bound_cte, std::move(plan));
-	} else {
-		bound_statement = Bind(statement.template Cast<T>());
-	}
-	return bound_statement;
-}
-
-BoundStatement Binder::Bind(SQLStatement &statement) {
-	root_statement = &statement;
-	switch (statement.type) {
-	case StatementType::SELECT_STATEMENT:
-		return Bind(statement.Cast<SelectStatement>());
-	case StatementType::INSERT_STATEMENT:
-		return BindWithCTE(statement.Cast<InsertStatement>());
-	case StatementType::COPY_STATEMENT:
-		return Bind(statement.Cast<CopyStatement>(), CopyToType::COPY_TO_FILE);
-	case StatementType::DELETE_STATEMENT:
-		return BindWithCTE(statement.Cast<DeleteStatement>());
-	case StatementType::UPDATE_STATEMENT:
-		return BindWithCTE(statement.Cast<UpdateStatement>());
-	case StatementType::RELATION_STATEMENT:
-		return Bind(statement.Cast<RelationStatement>());
-	case StatementType::CREATE_STATEMENT:
-		return Bind(statement.Cast<CreateStatement>());
-	case StatementType::DROP_STATEMENT:
-		return Bind(statement.Cast<DropStatement>());
-	case StatementType::ALTER_STATEMENT:
-		return Bind(statement.Cast<AlterStatement>());
-	case StatementType::TRANSACTION_STATEMENT:
-		return Bind(statement.Cast<TransactionStatement>());
-	case StatementType::PRAGMA_STATEMENT:
-		return Bind(statement.Cast<PragmaStatement>());
-	case StatementType::EXPLAIN_STATEMENT:
-		return Bind(statement.Cast<ExplainStatement>());
-	case StatementType::VACUUM_STATEMENT:
-		return Bind(statement.Cast<VacuumStatement>());
-	case StatementType::CALL_STATEMENT:
-		return Bind(statement.Cast<CallStatement>());
-	case StatementType::EXPORT_STATEMENT:
-		return Bind(statement.Cast<ExportStatement>());
-	case StatementType::SET_STATEMENT:
-		return Bind(statement.Cast<SetStatement>());
-	case StatementType::LOAD_STATEMENT:
-		return Bind(statement.Cast<LoadStatement>());
-	case StatementType::EXTENSION_STATEMENT:
-		return Bind(statement.Cast<ExtensionStatement>());
-	case StatementType::PREPARE_STATEMENT:
-		return Bind(statement.Cast<PrepareStatement>());
-	case StatementType::EXECUTE_STATEMENT:
-		return Bind(statement.Cast<ExecuteStatement>());
-	case StatementType::LOGICAL_PLAN_STATEMENT:
-		return Bind(statement.Cast<LogicalPlanStatement>());
-	case StatementType::ATTACH_STATEMENT:
-		return Bind(statement.Cast<AttachStatement>());
-	case StatementType::DETACH_STATEMENT:
-		return Bind(statement.Cast<DetachStatement>());
-	case StatementType::COPY_DATABASE_STATEMENT:
-		return Bind(statement.Cast<CopyDatabaseStatement>());
-	case StatementType::UPDATE_EXTENSIONS_STATEMENT:
-		return Bind(statement.Cast<UpdateExtensionsStatement>());
-	default: // LCOV_EXCL_START
-		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
-		                              StatementTypeToString(statement.type));
-	} // LCOV_EXCL_STOP
-}
-
-void Binder::AddCTEMap(CommonTableExpressionMap &cte_map) {
-	for (auto &cte_it : cte_map.map) {
-		AddCTE(cte_it.first, *cte_it.second);
-	}
-}
-
-static void GetTableRefCountsNode(case_insensitive_map_t<idx_t> &cte_ref_counts, QueryNode &node);
-
-static void GetTableRefCountsExpr(case_insensitive_map_t<idx_t> &cte_ref_counts, ParsedExpression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::SUBQUERY) {
-		auto &subquery = expr.Cast<SubqueryExpression>();
-		GetTableRefCountsNode(cte_ref_counts, *subquery.subquery->node);
-	} else {
-		ParsedExpressionIterator::EnumerateChildren(
-		    expr, [&](ParsedExpression &expr) { GetTableRefCountsExpr(cte_ref_counts, expr); });
-	}
-}
-
-static void GetTableRefCountsNode(case_insensitive_map_t<idx_t> &cte_ref_counts, QueryNode &node) {
-	ParsedExpressionIterator::EnumerateQueryNodeChildren(
-	    node, [&](unique_ptr<ParsedExpression> &child) { GetTableRefCountsExpr(cte_ref_counts, *child); },
-	    [&](TableRef &ref) {
-		    if (ref.type != TableReferenceType::BASE_TABLE) {
-			    return;
-		    }
-		    auto cte_ref_counts_it = cte_ref_counts.find(ref.Cast<BaseTableRef>().table_name);
-		    if (cte_ref_counts_it != cte_ref_counts.end()) {
-			    cte_ref_counts_it->second++;
-		    }
-	    });
-}
-
-static bool ParsedExpressionIsAggregate(Binder &binder, const ParsedExpression &expr) {
-	if (expr.GetExpressionClass() == ExpressionClass::FUNCTION) {
-		auto &function = expr.Cast<FunctionExpression>();
-		QueryErrorContext error_context;
-		auto entry = binder.GetCatalogEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, function.catalog, function.schema,
-		                                    function.function_name, OnEntryNotFound::RETURN_NULL, error_context);
-		if (entry && entry->type == CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-			return true;
-		}
-	}
-	bool is_aggregate = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { is_aggregate |= ParsedExpressionIsAggregate(binder, child); });
-	return is_aggregate;
-}
-
-bool Binder::OptimizeCTEs(QueryNode &node) {
-	D_ASSERT(context.config.enable_optimizer);
-
-	// only applies to nodes that have at least one CTE
-	auto &cte_map = node.cte_map.map;
-	if (cte_map.empty()) {
-		return false;
-	}
-
-	// initialize counts with the CTE names
-	case_insensitive_map_t<idx_t> cte_ref_counts;
-	for (auto &cte : cte_map) {
-		cte_ref_counts[cte.first];
-	}
-
-	// count the references of each CTE
-	GetTableRefCountsNode(cte_ref_counts, node);
-
-	// determine for each CTE whether it should be materialized
-	bool result = false;
-	for (auto &cte : cte_map) {
-		if (cte.second->materialized != CTEMaterialize::CTE_MATERIALIZE_DEFAULT) {
-			continue; // only triggers when nothing is specified
-		}
-		if (bind_context.GetCTEBinding(cte.first)) {
-			continue; // there's a CTE in the bind context with an overlapping name, we can't also materialize this
-		}
-
-		auto cte_ref_counts_it = cte_ref_counts.find(cte.first);
-		D_ASSERT(cte_ref_counts_it != cte_ref_counts.end());
-
-		// only applies to CTEs that are referenced more than once
-		if (cte_ref_counts_it->second <= 1) {
-			continue;
-		}
-
-		// if the cte is a SELECT node
-		if (cte.second->query->node->type != QueryNodeType::SELECT_NODE) {
-			continue;
-		}
-
-		// we materialize if the CTE ends in an aggregation
-		auto &cte_node = cte.second->query->node->Cast<SelectNode>();
-		bool materialize = !cte_node.groups.group_expressions.empty() || !cte_node.groups.grouping_sets.empty();
-		// or has a distinct modifier
-		for (auto &modifier : cte_node.modifiers) {
-			if (materialize) {
-				break;
-			}
-			if (modifier->type == ResultModifierType::DISTINCT_MODIFIER) {
-				materialize = true;
-			}
-		}
-		for (auto &sel : cte_node.select_list) {
-			if (materialize) {
-				break;
-			}
-			materialize |= ParsedExpressionIsAggregate(*this, *sel);
-		}
-
-		if (materialize) {
-			cte.second->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
-			result = true;
-		}
-	}
-	return result;
-}
-
-unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
-	// first we visit the set of CTEs and add them to the bind context
-	AddCTEMap(node.cte_map);
-	// now we bind the node
-	unique_ptr<BoundQueryNode> result;
-	switch (node.type) {
-	case QueryNodeType::SELECT_NODE:
-		result = BindNode(node.Cast<SelectNode>());
-		break;
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = BindNode(node.Cast<RecursiveCTENode>());
-		break;
-	case QueryNodeType::CTE_NODE:
-		result = BindNode(node.Cast<CTENode>());
-		break;
-	default:
-		D_ASSERT(node.type == QueryNodeType::SET_OPERATION_NODE);
-		result = BindNode(node.Cast<SetOperationNode>());
-		break;
-	}
-	return result;
-}
-
-BoundStatement Binder::Bind(QueryNode &node) {
-	BoundStatement result;
-	if (node.type != QueryNodeType::CTE_NODE && // Issue #13850 - Don't auto-materialize if users materialize (for now)
-	    !Optimizer::OptimizerDisabled(context, OptimizerType::MATERIALIZED_CTE) && context.config.enable_optimizer &&
-	    OptimizeCTEs(node)) {
-		switch (node.type) {
-		case QueryNodeType::SELECT_NODE:
-			result = BindWithCTE(node.Cast<SelectNode>());
-			break;
-		case QueryNodeType::RECURSIVE_CTE_NODE:
-			result = BindWithCTE(node.Cast<RecursiveCTENode>());
-			break;
-		case QueryNodeType::CTE_NODE:
-			result = BindWithCTE(node.Cast<CTENode>());
-			break;
-		default:
-			D_ASSERT(node.type == QueryNodeType::SET_OPERATION_NODE);
-			result = BindWithCTE(node.Cast<SetOperationNode>());
-			break;
-		}
-	} else {
-		auto bound_node = BindNode(node);
-
-		result.names = bound_node->names;
-		result.types = bound_node->types;
-
-		// and plan it
-		result.plan = CreatePlan(*bound_node);
-	}
-	return result;
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundQueryNode &node) {
-	switch (node.type) {
-	case QueryNodeType::SELECT_NODE:
-		return CreatePlan(node.Cast<BoundSelectNode>());
-	case QueryNodeType::SET_OPERATION_NODE:
-		return CreatePlan(node.Cast<BoundSetOperationNode>());
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		return CreatePlan(node.Cast<BoundRecursiveCTENode>());
-	case QueryNodeType::CTE_NODE:
-		return CreatePlan(node.Cast<BoundCTENode>());
-	default:
-		throw InternalException("Unsupported bound query node type");
-	}
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
-	unique_ptr<BoundTableRef> result;
-	switch (ref.type) {
-	case TableReferenceType::BASE_TABLE:
-		result = Bind(ref.Cast<BaseTableRef>());
-		break;
-	case TableReferenceType::JOIN:
-		result = Bind(ref.Cast<JoinRef>());
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = Bind(ref.Cast<SubqueryRef>());
-		break;
-	case TableReferenceType::EMPTY_FROM:
-		result = Bind(ref.Cast<EmptyTableRef>());
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = Bind(ref.Cast<TableFunctionRef>());
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = Bind(ref.Cast<ExpressionListRef>());
-		break;
-	case TableReferenceType::COLUMN_DATA:
-		result = Bind(ref.Cast<ColumnDataRef>());
-		break;
-	case TableReferenceType::PIVOT:
-		result = Bind(ref.Cast<PivotRef>());
-		break;
-	case TableReferenceType::SHOW_REF:
-		result = Bind(ref.Cast<ShowRef>());
-		break;
-	case TableReferenceType::DELIM_GET:
-		result = Bind(ref.Cast<DelimGetRef>());
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-	default:
-		throw InternalException("Unknown table ref type (%s)", EnumUtil::ToString(ref.type));
-	}
-	result->sample = std::move(ref.sample);
-	return result;
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
-	unique_ptr<LogicalOperator> root;
-	switch (ref.type) {
-	case TableReferenceType::BASE_TABLE:
-		root = CreatePlan(ref.Cast<BoundBaseTableRef>());
-		break;
-	case TableReferenceType::SUBQUERY:
-		root = CreatePlan(ref.Cast<BoundSubqueryRef>());
-		break;
-	case TableReferenceType::JOIN:
-		root = CreatePlan(ref.Cast<BoundJoinRef>());
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		root = CreatePlan(ref.Cast<BoundTableFunction>());
-		break;
-	case TableReferenceType::EMPTY_FROM:
-		root = CreatePlan(ref.Cast<BoundEmptyTableRef>());
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		root = CreatePlan(ref.Cast<BoundExpressionListRef>());
-		break;
-	case TableReferenceType::COLUMN_DATA:
-		root = CreatePlan(ref.Cast<BoundColumnDataRef>());
-		break;
-	case TableReferenceType::CTE:
-		root = CreatePlan(ref.Cast<BoundCTERef>());
-		break;
-	case TableReferenceType::PIVOT:
-		root = CreatePlan(ref.Cast<BoundPivotRef>());
-		break;
-	case TableReferenceType::DELIM_GET:
-		root = CreatePlan(ref.Cast<BoundDelimGetRef>());
-		break;
-	case TableReferenceType::INVALID:
-	default:
-		throw InternalException("Unsupported bound table ref type (%s)", EnumUtil::ToString(ref.type));
-	}
-	// plan the sample clause
-	if (ref.sample) {
-		root = make_uniq<LogicalSample>(std::move(ref.sample), std::move(root));
-	}
-	return root;
-}
-
-void Binder::AddCTE(const string &name, CommonTableExpressionInfo &info) {
-	D_ASSERT(!name.empty());
-	auto entry = CTE_bindings.find(name);
-	if (entry != CTE_bindings.end()) {
-		throw InternalException("Duplicate CTE \"%s\" in query!", name);
-	}
-	CTE_bindings.insert(make_pair(name, reference<CommonTableExpressionInfo>(info)));
-}
-
-vector<reference<CommonTableExpressionInfo>> Binder::FindCTE(const string &name, bool skip) {
-	auto entry = CTE_bindings.find(name);
-	vector<reference<CommonTableExpressionInfo>> ctes;
-	if (entry != CTE_bindings.end()) {
-		if (!skip || entry->second.get().query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
-			ctes.push_back(entry->second);
-		}
-	}
-	if (parent && binder_type == BinderType::REGULAR_BINDER) {
-		auto parent_ctes = parent->FindCTE(name, name == alias);
-		ctes.insert(ctes.end(), parent_ctes.begin(), parent_ctes.end());
-	}
-	return ctes;
-}
-
-bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo &cte) {
-	if (bound_ctes.find(cte) != bound_ctes.end()) {
-		return true;
-	}
-	if (parent && binder_type == BinderType::REGULAR_BINDER) {
-		return parent->CTEIsAlreadyBound(cte);
-	}
-	return false;
-}
-
-void Binder::AddBoundView(ViewCatalogEntry &view) {
-	// check if the view is already bound
-	auto current = this;
-	while (current) {
-		if (current->bound_views.find(view) != current->bound_views.end()) {
-			throw BinderException("infinite recursion detected: attempting to recursively bind view \"%s\"", view.name);
-		}
-		current = current->parent.get();
-	}
-	bound_views.insert(view);
-}
-
-idx_t Binder::GenerateTableIndex() {
-	auto &root_binder = GetRootBinder();
-	return root_binder.bound_tables++;
-}
-
-StatementProperties &Binder::GetStatementProperties() {
-	auto &root_binder = GetRootBinder();
-	return root_binder.prop;
-}
-
-void Binder::PushExpressionBinder(ExpressionBinder &binder) {
-	GetActiveBinders().push_back(binder);
-}
-
-void Binder::PopExpressionBinder() {
-	D_ASSERT(HasActiveBinder());
-	GetActiveBinders().pop_back();
-}
-
-void Binder::SetActiveBinder(ExpressionBinder &binder) {
-	D_ASSERT(HasActiveBinder());
-	GetActiveBinders().back() = binder;
-}
-
-ExpressionBinder &Binder::GetActiveBinder() {
-	return GetActiveBinders().back();
-}
-
-bool Binder::HasActiveBinder() {
-	return !GetActiveBinders().empty();
-}
-
-vector<reference<ExpressionBinder>> &Binder::GetActiveBinders() {
-	reference<Binder> root = *this;
-	while (root.get().parent && root.get().binder_type == BinderType::REGULAR_BINDER) {
-		root = *root.get().parent;
-	}
-	auto &root_binder = root.get();
-	return root_binder.active_binders;
-}
-
-void Binder::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
-	auto &root_binder = GetRootBinder();
-	root_binder.bind_context.AddUsingBindingSet(std::move(set));
-}
-
-void Binder::MoveCorrelatedExpressions(Binder &other) {
-	MergeCorrelatedColumns(other.correlated_columns);
-	other.correlated_columns.clear();
-}
-
-void Binder::MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other) {
-	for (idx_t i = 0; i < other.size(); i++) {
-		AddCorrelatedColumn(other[i]);
-	}
-}
-
-void Binder::AddCorrelatedColumn(const CorrelatedColumnInfo &info) {
-	// we only add correlated columns to the list if they are not already there
-	if (std::find(correlated_columns.begin(), correlated_columns.end(), info) == correlated_columns.end()) {
-		correlated_columns.push_back(info);
-	}
-}
-
-optional_ptr<Binding> Binder::GetMatchingBinding(const string &table_name, const string &column_name,
-                                                 ErrorData &error) {
-	string empty_schema;
-	return GetMatchingBinding(empty_schema, table_name, column_name, error);
-}
-
-optional_ptr<Binding> Binder::GetMatchingBinding(const string &schema_name, const string &table_name,
-                                                 const string &column_name, ErrorData &error) {
-	string empty_catalog;
-	return GetMatchingBinding(empty_catalog, schema_name, table_name, column_name, error);
-}
-
-optional_ptr<Binding> Binder::GetMatchingBinding(const string &catalog_name, const string &schema_name,
-                                                 const string &table_name, const string &column_name,
-                                                 ErrorData &error) {
-	optional_ptr<Binding> binding;
-	D_ASSERT(!lambda_bindings);
-	if (macro_binding && table_name == macro_binding->GetAlias()) {
-		binding = optional_ptr<Binding>(macro_binding.get());
-	} else {
-		BindingAlias alias(catalog_name, schema_name, table_name);
-		binding = bind_context.GetBinding(alias, column_name, error);
-	}
-	return binding;
-}
-
-void Binder::SetBindingMode(BindingMode mode) {
-	auto &root_binder = GetRootBinder();
-	root_binder.mode = mode;
-}
-
-BindingMode Binder::GetBindingMode() {
-	auto &root_binder = GetRootBinder();
-	return root_binder.mode;
-}
-
-void Binder::SetCanContainNulls(bool can_contain_nulls_p) {
-	can_contain_nulls = can_contain_nulls_p;
-}
-
-void Binder::SetAlwaysRequireRebind() {
-	auto &properties = GetStatementProperties();
-	properties.always_require_rebind = true;
-}
-
-void Binder::AddTableName(string table_name) {
-	auto &root_binder = GetRootBinder();
-	root_binder.table_names.insert(std::move(table_name));
-}
-
-void Binder::AddReplacementScan(const string &table_name, unique_ptr<TableRef> replacement) {
-	auto &root_binder = GetRootBinder();
-	auto it = root_binder.replacement_scans.find(table_name);
-	replacement->column_name_alias.clear();
-	replacement->alias.clear();
-	if (it == root_binder.replacement_scans.end()) {
-		root_binder.replacement_scans[table_name] = std::move(replacement);
-	} else {
-		// A replacement scan by this name was previously registered, we can just use it
-	}
-}
-
-const unordered_set<string> &Binder::GetTableNames() {
-	auto &root_binder = GetRootBinder();
-	return root_binder.table_names;
-}
-
-case_insensitive_map_t<unique_ptr<TableRef>> &Binder::GetReplacementScans() {
-	auto &root_binder = GetRootBinder();
-	return root_binder.replacement_scans;
-}
-
-// FIXME: this is extremely naive
-void VerifyNotExcluded(ParsedExpression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &column_ref = expr.Cast<ColumnRefExpression>();
-		if (!column_ref.IsQualified()) {
-			return;
-		}
-		auto &table_name = column_ref.GetTableName();
-		if (table_name == "excluded") {
-			throw NotImplementedException("'excluded' qualified columns are not supported in the RETURNING clause yet");
-		}
-		return;
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { VerifyNotExcluded((ParsedExpression &)child); });
-}
-
-BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry &table,
-                                     const string &alias, idx_t update_table_index,
-                                     unique_ptr<LogicalOperator> child_operator, BoundStatement result) {
-
-	vector<LogicalType> types;
-	vector<std::string> names;
-
-	auto binder = Binder::CreateBinder(context);
-
-	vector<ColumnIndex> bound_columns;
-	idx_t column_count = 0;
-	for (auto &col : table.GetColumns().Logical()) {
-		names.push_back(col.Name());
-		types.push_back(col.Type());
-		if (!col.Generated()) {
-			bound_columns.emplace_back(column_count);
-		}
-		column_count++;
-	}
-
-	binder->bind_context.AddBaseTable(update_table_index, alias, names, types, bound_columns, table, false);
-	ReturningBinder returning_binder(*binder, context);
-
-	vector<unique_ptr<Expression>> projection_expressions;
-	LogicalType result_type;
-	vector<unique_ptr<ParsedExpression>> new_returning_list;
-	binder->ExpandStarExpressions(returning_list, new_returning_list);
-	for (auto &returning_expr : new_returning_list) {
-		VerifyNotExcluded(*returning_expr);
-		auto expr = returning_binder.Bind(returning_expr, &result_type);
-		result.names.push_back(expr->GetName());
-		result.types.push_back(result_type);
-		projection_expressions.push_back(std::move(expr));
-	}
-	if (new_returning_list.empty()) {
-		throw BinderException("RETURNING list is empty!");
-	}
-	auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(projection_expressions));
-	projection->AddChild(std::move(child_operator));
-	D_ASSERT(result.types.size() == result.names.size());
-	result.plan = std::move(projection);
-	// If an insert/delete/update statement returns data, there are sometimes issues with streaming results
-	// where the data modification doesn't take place until the streamed result is exhausted. Once a row is
-	// returned, it should be guaranteed that the row has been inserted.
-	// see https://github.com/duckdb/duckdb/issues/8310
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-optional_ptr<CatalogEntry> Binder::GetCatalogEntry(CatalogType type, const string &catalog, const string &schema,
-                                                   const string &name, OnEntryNotFound on_entry_not_found,
-                                                   QueryErrorContext &error_context) {
-	return entry_retriever.GetEntry(type, catalog, schema, name, on_entry_not_found, error_context);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp
deleted file mode 100644
index beba67f83..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp
+++ /dev/null
@@ -1,321 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/function/scalar/generic_common.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/expression_binder/base_select_binder.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-static bool IsFunctionallyDependent(const unique_ptr<Expression> &expr, const vector<unique_ptr<Expression>> &deps) {
-	//	Volatile expressions can't depend on anything else
-	if (expr->IsVolatile()) {
-		return false;
-	}
-	//	Constant expressions are always FD
-	if (expr->IsFoldable()) {
-		return true;
-	}
-	// If the expression matches ANY of the dependencies, then it is FD on them
-	for (const auto &dep : deps) {
-		// We don't need to check volatility of the dependencies because we checked it for the expression.
-		if (expr->Equals(*dep)) {
-			return true;
-		}
-	}
-
-	// The expression doesn't match any dependency, so check ALL children.
-	bool has_children = false;
-	bool are_dependent = true;
-	ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-		has_children = true;
-		are_dependent &= IsFunctionallyDependent(child, deps);
-	});
-	return has_children && are_dependent;
-}
-
-static Value NegatePercentileValue(const Value &v, const bool desc) {
-	if (v.IsNull()) {
-		return v;
-	}
-
-	const auto frac = v.GetValue<double>();
-	if (frac < 0 || frac > 1) {
-		throw BinderException("PERCENTILEs can only take parameters in the range [0, 1]");
-	}
-
-	if (!desc) {
-		return v;
-	}
-
-	const auto &type = v.type();
-	switch (type.id()) {
-	case LogicalTypeId::DECIMAL: {
-		// Negate DECIMALs as DECIMAL.
-		const auto integral = IntegralValue::Get(v);
-		const auto width = DecimalType::GetWidth(type);
-		const auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(Cast::Operation<hugeint_t, int16_t>(-integral), width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(Cast::Operation<hugeint_t, int32_t>(-integral), width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(Cast::Operation<hugeint_t, int64_t>(-integral), width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(-integral, width, scale);
-		default:
-			throw InternalException("Unknown DECIMAL type");
-		}
-	}
-	default:
-		// Everything else can just be a DOUBLE
-		return Value::DOUBLE(-v.GetValue<double>());
-	}
-}
-
-static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedExpression> &fractions, bool desc) {
-	D_ASSERT(fractions.get());
-	D_ASSERT(fractions->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = BoundExpression::GetExpression(*fractions);
-
-	if (!bound->IsFoldable()) {
-		return;
-	}
-
-	Value value = ExpressionExecutor::EvaluateScalar(context, *bound);
-	if (value.type().id() == LogicalTypeId::LIST) {
-		vector<Value> values;
-		for (const auto &element_val : ListValue::GetChildren(value)) {
-			values.push_back(NegatePercentileValue(element_val, desc));
-		}
-		if (values.empty()) {
-			throw BinderException("Empty list in percentile not allowed");
-		}
-		bound = make_uniq<BoundConstantExpression>(Value::LIST(values));
-	} else {
-		bound = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
-	}
-}
-
-BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry &func, idx_t depth) {
-	// first bind the child of the aggregate expression (if any)
-	this->bound_aggregate = true;
-	unique_ptr<Expression> bound_filter;
-	AggregateBinder aggregate_binder(binder, context);
-	ErrorData error;
-
-	// Now we bind the filter (if any)
-	if (aggr.filter) {
-		aggregate_binder.BindChild(aggr.filter, 0, error);
-	}
-
-	// Handle ordered-set aggregates by moving the single ORDER BY expression to the front of the children.
-	//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
-	// We also have to handle ORDER BY in the argument list, so note how many arguments we should have
-	// and only inject the ordering expression if there are too few.
-	idx_t ordered_set_agg = 0;
-	bool negate_fractions = false;
-	if (aggr.order_bys && aggr.order_bys->orders.size() == 1) {
-		const auto &func_name = aggr.function_name;
-		if (func_name == "mode") {
-			ordered_set_agg = 1;
-		} else if (func_name == "quantile_cont" || func_name == "quantile_disc") {
-			ordered_set_agg = 2;
-
-			auto &config = DBConfig::GetConfig(context);
-			const auto &order = aggr.order_bys->orders[0];
-			const auto sense =
-			    (order.type == OrderType::ORDER_DEFAULT) ? config.options.default_order_type : order.type;
-			negate_fractions = (sense == OrderType::DESCENDING);
-		}
-	}
-
-	for (idx_t i = 0; i < aggr.children.size(); ++i) {
-		auto &child = aggr.children[i];
-		aggregate_binder.BindChild(child, 0, error);
-		// We have to negate the fractions for PERCENTILE_XXXX DESC
-		if (!error.HasError() && ordered_set_agg && i == aggr.children.size() - 1) {
-			NegatePercentileFractions(context, child, negate_fractions);
-		}
-	}
-
-	// Bind the ORDER BYs, if any
-	if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
-		for (auto &order : aggr.order_bys->orders) {
-			if (order.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-				auto &const_expr = order.expression->Cast<ConstantExpression>();
-				if (!const_expr.value.type().IsIntegral()) {
-					auto &config = ClientConfig::GetConfig(context);
-					if (!config.order_by_non_integer_literal) {
-						throw BinderException(
-						    *order.expression,
-						    "ORDER BY non-integer literal has no effect.\n* SET order_by_non_integer_literal=true to "
-						    "allow this behavior.\n\nPerhaps you misplaced ORDER BY; ORDER BY must appear "
-						    "after all regular arguments of the aggregate.");
-					}
-				}
-			}
-			aggregate_binder.BindChild(order.expression, 0, error);
-		}
-	}
-
-	if (error.HasError()) {
-		// failed to bind child
-		if (aggregate_binder.HasBoundColumns()) {
-			for (idx_t i = 0; i < aggr.children.size(); i++) {
-				// however, we bound columns!
-				// that means this aggregation belongs to this node
-				// check if we have to resolve any errors by binding with parent binders
-				auto result = aggregate_binder.BindCorrelatedColumns(aggr.children[i], error);
-				// if there is still an error after this, we could not successfully bind the aggregate
-				if (result.HasError()) {
-					result.error.Throw();
-				}
-				auto &bound_expr = BoundExpression::GetExpression(*aggr.children[i]);
-				ExtractCorrelatedExpressions(binder, *bound_expr);
-			}
-			if (aggr.filter) {
-				auto result = aggregate_binder.BindCorrelatedColumns(aggr.filter, error);
-				// if there is still an error after this, we could not successfully bind the aggregate
-				if (result.HasError()) {
-					result.error.Throw();
-				}
-				auto &bound_expr = BoundExpression::GetExpression(*aggr.filter);
-				ExtractCorrelatedExpressions(binder, *bound_expr);
-			}
-			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
-				for (auto &order : aggr.order_bys->orders) {
-					auto result = aggregate_binder.BindCorrelatedColumns(order.expression, error);
-					if (result.HasError()) {
-						result.error.Throw();
-					}
-					auto &bound_expr = BoundExpression::GetExpression(*order.expression);
-					ExtractCorrelatedExpressions(binder, *bound_expr);
-				}
-			}
-		} else {
-			// we didn't bind columns, try again in children
-			return BindResult(std::move(error));
-		}
-	} else if (depth > 0 && !aggregate_binder.HasBoundColumns()) {
-		return BindResult("Aggregate with only constant parameters has to be bound in the root subquery");
-	}
-
-	if (aggr.filter) {
-		auto &child = BoundExpression::GetExpression(*aggr.filter);
-		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN);
-	}
-
-	// all children bound successfully
-	// extract the children and types
-	vector<LogicalType> types;
-	vector<LogicalType> arguments;
-	vector<unique_ptr<Expression>> children;
-
-	if (ordered_set_agg) {
-		const bool order_sensitive = (aggr.function_name == "mode");
-		// Inject missing ordering arguments
-		if (aggr.children.size() < ordered_set_agg) {
-			for (auto &order : aggr.order_bys->orders) {
-				auto &child = BoundExpression::GetExpression(*order.expression);
-				types.push_back(child->return_type);
-				arguments.push_back(child->return_type);
-				if (order_sensitive) {
-					children.push_back(child->Copy());
-				} else {
-					children.push_back(std::move(child));
-				}
-			}
-		}
-		if (!order_sensitive) {
-			aggr.order_bys->orders.clear();
-		}
-	}
-
-	for (idx_t i = 0; i < aggr.children.size(); i++) {
-		auto &child = BoundExpression::GetExpression(*aggr.children[i]);
-		types.push_back(child->return_type);
-		arguments.push_back(child->return_type);
-		children.push_back(std::move(child));
-	}
-
-	// bind the aggregate
-	FunctionBinder function_binder(binder);
-	auto best_function = function_binder.BindFunction(func.name, func.functions, types, error);
-	if (!best_function.IsValid()) {
-		error.AddQueryLocation(aggr);
-		error.Throw();
-	}
-	// found a matching function!
-	auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
-
-	// Bind any sort columns, unless the aggregate is order-insensitive
-	unique_ptr<BoundOrderModifier> order_bys;
-	if (!aggr.order_bys->orders.empty()) {
-		order_bys = make_uniq<BoundOrderModifier>();
-		auto &config = DBConfig::GetConfig(context);
-		for (auto &order : aggr.order_bys->orders) {
-			auto &order_expr = BoundExpression::GetExpression(*order.expression);
-			PushCollation(context, order_expr, order_expr->return_type);
-			const auto sense = config.ResolveOrder(order.type);
-			const auto null_order = config.ResolveNullOrder(sense, order.null_order);
-			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr));
-		}
-	}
-
-	// If the aggregate is DISTINCT then the ORDER BYs need to be functional dependencies of the arguments.
-	if (aggr.distinct && order_bys) {
-		bool in_args = true;
-		for (const auto &order_by : order_bys->orders) {
-			in_args &= IsFunctionallyDependent(order_by.expression, children);
-		}
-
-		if (!in_args) {
-			throw BinderException("In a DISTINCT aggregate, ORDER BY expressions must appear in the argument list");
-		}
-	}
-
-	auto aggregate =
-	    function_binder.BindAggregateFunction(bound_function, std::move(children), std::move(bound_filter),
-	                                          aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
-	if (aggr.export_state) {
-		aggregate = ExportAggregateFunction::Bind(std::move(aggregate));
-	}
-	aggregate->order_bys = std::move(order_bys);
-
-	// check for all the aggregates if this aggregate already exists
-	idx_t aggr_index;
-	auto entry = node.aggregate_map.find(*aggregate);
-	if (entry == node.aggregate_map.end()) {
-		// new aggregate: insert into aggregate list
-		aggr_index = node.aggregates.size();
-		node.aggregate_map[*aggregate] = aggr_index;
-		node.aggregates.push_back(std::move(aggregate));
-	} else {
-		// duplicate aggregate: simplify refer to this aggregate
-		aggr_index = entry->second;
-	}
-
-	// now create a column reference referring to the aggregate
-	auto colref = make_uniq<BoundColumnRefExpression>(
-	    aggr.GetAlias().empty() ? node.aggregates[aggr_index]->ToString() : aggr.GetAlias(),
-	    node.aggregates[aggr_index]->return_type, ColumnBinding(node.aggregate_index, aggr_index), depth);
-	// move the aggregate expression into the set of bound aggregates
-	return BindResult(std::move(colref));
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_between_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_between_expression.cpp
deleted file mode 100644
index 09c92dd48..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_between_expression.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "duckdb/parser/expression/between_expression.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	ErrorData error;
-	BindChild(expr.input, depth, error);
-	BindChild(expr.lower, depth, error);
-	BindChild(expr.upper, depth, error);
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-	// the children have been successfully resolved
-	auto &input = BoundExpression::GetExpression(*expr.input);
-	auto &lower = BoundExpression::GetExpression(*expr.lower);
-	auto &upper = BoundExpression::GetExpression(*expr.upper);
-
-	auto input_sql_type = ExpressionBinder::GetExpressionReturnType(*input);
-	auto lower_sql_type = ExpressionBinder::GetExpressionReturnType(*lower);
-	auto upper_sql_type = ExpressionBinder::GetExpressionReturnType(*upper);
-
-	// cast the input types to the same type
-	// now obtain the result type of the input types
-	LogicalType input_type;
-	if (!BoundComparisonExpression::TryBindComparison(context, input_sql_type, lower_sql_type, input_type,
-	                                                  expr.GetExpressionType())) {
-
-		throw BinderException(expr,
-		                      "Cannot mix values of type %s and %s in BETWEEN clause - an explicit cast is required",
-		                      input_sql_type.ToString(), lower_sql_type.ToString());
-	}
-	if (!BoundComparisonExpression::TryBindComparison(context, input_type, upper_sql_type, input_type,
-	                                                  expr.GetExpressionType())) {
-		throw BinderException(expr,
-		                      "Cannot mix values of type %s and %s in BETWEEN clause - an explicit cast is required",
-		                      input_type.ToString(), upper_sql_type.ToString());
-	}
-	// add casts (if necessary)
-	input = BoundCastExpression::AddCastToType(context, std::move(input), input_type);
-	lower = BoundCastExpression::AddCastToType(context, std::move(lower), input_type);
-	upper = BoundCastExpression::AddCastToType(context, std::move(upper), input_type);
-	// handle collation
-	PushCollation(context, input, input_type);
-	PushCollation(context, lower, input_type);
-	PushCollation(context, upper, input_type);
-
-	if (!input->IsVolatile() && !input->HasParameter() && !input->HasSubquery()) {
-		// the expression does not have side effects and can be copied: create two comparisons
-		// the reason we do this is that individual comparisons are easier to handle in optimizers
-		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer
-		auto left_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-		                                                         input->Copy(), std::move(lower));
-		auto right_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-		                                                          std::move(input), std::move(upper));
-		return BindResult(make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-		                                                        std::move(left_compare), std::move(right_compare)));
-	} else {
-		// expression has side effects: we cannot duplicate it
-		// create a bound_between directly
-		return BindResult(
-		    make_uniq<BoundBetweenExpression>(std::move(input), std::move(lower), std::move(upper), true, true));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_case_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_case_expression.cpp
deleted file mode 100644
index a96a2e2bb..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_case_expression.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(CaseExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	ErrorData error;
-	for (auto &check : expr.case_checks) {
-		BindChild(check.when_expr, depth, error);
-		BindChild(check.then_expr, depth, error);
-	}
-	BindChild(expr.else_expr, depth, error);
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-	// the children have been successfully resolved
-	// figure out the result type of the CASE expression
-	auto &else_expr = BoundExpression::GetExpression(*expr.else_expr);
-	auto return_type = ExpressionBinder::GetExpressionReturnType(*else_expr);
-	for (auto &check : expr.case_checks) {
-		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
-		auto then_type = ExpressionBinder::GetExpressionReturnType(*then_expr);
-		if (!LogicalType::TryGetMaxLogicalType(context, return_type, then_type, return_type)) {
-			throw BinderException(
-			    expr, "Cannot mix values of type %s and %s in CASE expression - an explicit cast is required",
-			    return_type.ToString(), then_type.ToString());
-		}
-	}
-
-	// bind all the individual components of the CASE statement
-	auto result = make_uniq<BoundCaseExpression>(return_type);
-	for (auto &check : expr.case_checks) {
-		auto &when_expr = BoundExpression::GetExpression(*check.when_expr);
-		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
-		BoundCaseCheck result_check;
-		result_check.when_expr =
-		    BoundCastExpression::AddCastToType(context, std::move(when_expr), LogicalType::BOOLEAN);
-		result_check.then_expr = BoundCastExpression::AddCastToType(context, std::move(then_expr), return_type);
-		result->case_checks.push_back(std::move(result_check));
-	}
-	result->else_expr = BoundCastExpression::AddCastToType(context, std::move(else_expr), return_type);
-	return BindResult(std::move(result));
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_cast_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_cast_expression.cpp
deleted file mode 100644
index 79d9047e1..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_cast_expression.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
-	// first try to bind the child of the cast expression
-	auto error = Bind(expr.child, depth);
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-	// FIXME: We can also implement 'hello'::schema.custom_type; and pass by the schema down here.
-	// Right now just considering its DEFAULT_SCHEMA always
-	binder.BindLogicalType(expr.cast_type);
-	// the children have been successfully resolved
-	auto &child = BoundExpression::GetExpression(*expr.child);
-	if (expr.try_cast) {
-		if (ExpressionBinder::GetExpressionReturnType(*child) == expr.cast_type) {
-			// no cast required: type matches
-			return BindResult(std::move(child));
-		}
-		child = BoundCastExpression::AddCastToType(context, std::move(child), expr.cast_type, true);
-	} else {
-		// otherwise add a cast to the target type
-		child = BoundCastExpression::AddCastToType(context, std::move(child), expr.cast_type);
-	}
-	return BindResult(std::move(child));
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp
deleted file mode 100644
index 0bcb8d213..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/parser/expression/collate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth) {
-	// first try to bind the child of the cast expression
-	auto error = Bind(expr.child, depth);
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-	auto &child = BoundExpression::GetExpression(*expr.child);
-	if (child->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (child->return_type.id() != LogicalTypeId::VARCHAR) {
-		throw BinderException("collations are only supported for type varchar");
-	}
-	// Validate the collation, but don't use it
-	auto collation_test = make_uniq_base<Expression, BoundConstantExpression>(Value(child->return_type));
-	auto collation_type = LogicalType::VARCHAR_COLLATION(expr.collation);
-	PushCollation(context, collation_test, collation_type);
-	child->return_type = collation_type;
-	return BindResult(std::move(child));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp
deleted file mode 100644
index 1c9bc238b..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp
+++ /dev/null
@@ -1,496 +0,0 @@
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-
-namespace duckdb {
-
-string GetSQLValueFunctionName(const string &column_name) {
-	auto lcase = StringUtil::Lower(column_name);
-	if (lcase == "current_catalog") {
-		return "current_catalog";
-	} else if (lcase == "current_date") {
-		return "current_date";
-	} else if (lcase == "current_schema") {
-		return "current_schema";
-	} else if (lcase == "current_role") {
-		return "current_role";
-	} else if (lcase == "current_time") {
-		return "get_current_time";
-	} else if (lcase == "current_timestamp") {
-		return "get_current_timestamp";
-	} else if (lcase == "current_user") {
-		return "current_user";
-	} else if (lcase == "localtime") {
-		return "current_localtime";
-	} else if (lcase == "localtimestamp") {
-		return "current_localtimestamp";
-	} else if (lcase == "session_user") {
-		return "session_user";
-	} else if (lcase == "user") {
-		return "user";
-	}
-	return string();
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::GetSQLValueFunction(const string &column_name) {
-	auto value_function = GetSQLValueFunctionName(column_name);
-	if (value_function.empty()) {
-		return nullptr;
-	}
-
-	vector<unique_ptr<ParsedExpression>> children;
-	return make_uniq<FunctionExpression>(value_function, std::move(children));
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &column_name, ErrorData &error) {
-	auto using_binding = binder.bind_context.GetUsingBinding(column_name);
-	if (using_binding) {
-		// we are referencing a USING column
-		// check if we can refer to one of the base columns directly
-		unique_ptr<Expression> expression;
-		if (using_binding->primary_binding.IsSet()) {
-			// we can! just assign the table name and re-bind
-			return binder.bind_context.CreateColumnReference(using_binding->primary_binding, column_name);
-		} else {
-			// we cannot! we need to bind this as COALESCE between all the relevant columns
-			auto coalesce = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-			coalesce->children.reserve(using_binding->bindings.size());
-			for (auto &entry : using_binding->bindings) {
-				coalesce->children.push_back(make_uniq<ColumnRefExpression>(column_name, entry));
-			}
-			return std::move(coalesce);
-		}
-	}
-
-	// try binding as a lambda parameter
-	auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, column_name);
-	if (lambda_ref) {
-		return lambda_ref;
-	}
-
-	// find a table binding that contains this column name
-	auto table_binding = binder.bind_context.GetMatchingBinding(column_name);
-
-	// throw an error if a macro parameter name conflicts with a column name
-	auto is_macro_column = false;
-	if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(column_name)) {
-		is_macro_column = true;
-		if (table_binding) {
-			throw BinderException("Conflicting column names for column " + column_name + "!");
-		}
-	}
-
-	// bind as a macro column
-	if (is_macro_column) {
-		return binder.bind_context.CreateColumnReference(binder.macro_binding->alias, column_name);
-	}
-
-	// bind as a regular column
-	if (table_binding) {
-		return binder.bind_context.CreateColumnReference(table_binding->alias, column_name);
-	}
-
-	// it's not, find candidates and error
-	auto similar_bindings = binder.bind_context.GetSimilarBindings(column_name);
-	error = ErrorData(BinderException::ColumnNotFound(column_name, similar_bindings));
-	return nullptr;
-}
-
-void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr,
-                                          vector<unordered_set<string>> &lambda_params,
-                                          const bool within_function_expression) {
-
-	bool next_within_function_expression = false;
-	switch (expr->GetExpressionType()) {
-	case ExpressionType::COLUMN_REF: {
-		auto &col_ref = expr->Cast<ColumnRefExpression>();
-
-		// don't qualify lambda parameters
-		if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) {
-			return;
-		}
-
-		ErrorData error;
-		auto new_expr = QualifyColumnName(col_ref, error);
-
-		if (new_expr) {
-			if (!expr->GetAlias().empty()) {
-				// Pre-existing aliases are added to the qualified column reference
-				new_expr->SetAlias(expr->GetAlias());
-			} else if (within_function_expression) {
-				// Qualifying the column reference may add an alias, but this needs to be removed within function
-				// expressions, because the alias here means a named parameter instead of a positional parameter
-				new_expr->ClearAlias();
-			}
-
-			// replace the expression with the qualified column reference
-			new_expr->SetQueryLocation(col_ref.GetQueryLocation());
-			expr = std::move(new_expr);
-		}
-		return;
-	}
-	case ExpressionType::POSITIONAL_REFERENCE: {
-		auto &ref = expr->Cast<PositionalReferenceExpression>();
-		if (ref.GetAlias().empty()) {
-			string table_name, column_name;
-			auto error = binder.bind_context.BindColumn(ref, table_name, column_name);
-			if (error.empty()) {
-				ref.SetAlias(column_name);
-			}
-		}
-		break;
-	}
-	case ExpressionType::FUNCTION: {
-		// Special-handling for lambdas, which are inside function expressions.
-		auto &function = expr->Cast<FunctionExpression>();
-		if (function.IsLambdaFunction()) {
-			return QualifyColumnNamesInLambda(function, lambda_params);
-		}
-
-		next_within_function_expression = true;
-		break;
-	}
-	default: // fall through
-		break;
-	}
-
-	// recurse on the child expressions
-	ParsedExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<ParsedExpression> &child) {
-		QualifyColumnNames(child, lambda_params, next_within_function_expression);
-	});
-}
-
-void ExpressionBinder::QualifyColumnNamesInLambda(FunctionExpression &function,
-                                                  vector<unordered_set<string>> &lambda_params) {
-
-	for (auto &child : function.children) {
-		if (child->GetExpressionClass() != ExpressionClass::LAMBDA) {
-			// not a lambda expression
-			QualifyColumnNames(child, lambda_params, true);
-			continue;
-		}
-
-		// special-handling for LHS lambda parameters
-		// we do not qualify them, and we add them to the lambda_params vector
-		auto &lambda_expr = child->Cast<LambdaExpression>();
-		string error_message;
-		auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message);
-
-		if (!error_message.empty()) {
-			// possibly a JSON function, qualify both LHS and RHS
-			QualifyColumnNames(lambda_expr.lhs, lambda_params, true);
-			QualifyColumnNames(lambda_expr.expr, lambda_params, true);
-			continue;
-		}
-
-		// push this level
-		lambda_params.emplace_back();
-
-		// push the lambda parameter names
-		for (const auto &column_ref_expr : column_ref_expressions) {
-			const auto &column_ref = column_ref_expr.get().Cast<ColumnRefExpression>();
-			lambda_params.back().emplace(column_ref.GetName());
-		}
-
-		// only qualify in RHS
-		QualifyColumnNames(lambda_expr.expr, lambda_params, true);
-
-		// pop this level
-		lambda_params.pop_back();
-	}
-}
-
-void ExpressionBinder::QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr) {
-	WhereBinder where_binder(binder, binder.context);
-	vector<unordered_set<string>> lambda_params;
-	where_binder.QualifyColumnNames(expr, lambda_params);
-}
-
-void ExpressionBinder::QualifyColumnNames(ExpressionBinder &expression_binder, unique_ptr<ParsedExpression> &expr) {
-	vector<unordered_set<string>> lambda_params;
-	expression_binder.QualifyColumnNames(expr, lambda_params);
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<ParsedExpression> base,
-                                                                   const string &field_name) {
-
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(std::move(base));
-	children.push_back(make_uniq_base<ParsedExpression, ConstantExpression>(Value(field_name)));
-	auto extract_fun = make_uniq<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
-	return std::move(extract_fun);
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpression &col_ref) {
-	if (col_ref.column_names.size() > 3) {
-		return nullptr;
-	}
-	D_ASSERT(!col_ref.column_names.empty());
-
-	// get a matching binding
-	ErrorData error;
-	optional_ptr<Binding> binding;
-	switch (col_ref.column_names.size()) {
-	case 1: {
-		// single entry - this must be the table name
-		BindingAlias alias(col_ref.column_names[0]);
-		binding = binder.bind_context.GetBinding(alias, error);
-		break;
-	}
-	case 2: {
-		// two entries - this can either be "catalog.table" or "schema.table" - try both
-		BindingAlias alias(col_ref.column_names[0], col_ref.column_names[1]);
-		binding = binder.bind_context.GetBinding(alias, error);
-		if (!binding) {
-			alias = BindingAlias(col_ref.column_names[0], INVALID_SCHEMA, col_ref.column_names[1]);
-			binding = binder.bind_context.GetBinding(alias, error);
-		}
-		break;
-	}
-	case 3: {
-		// three entries - this must be "catalog.schema.table"
-		BindingAlias alias(col_ref.column_names[0], col_ref.column_names[1], col_ref.column_names[2]);
-		binding = binder.bind_context.GetBinding(alias, error);
-		break;
-	}
-	default:
-		throw InternalException("Expected 1, 2 or 3 column names for CreateStructPack");
-	}
-	if (!binding) {
-		return nullptr;
-	}
-
-	// We found the table, now create the struct_pack expression
-	vector<unique_ptr<ParsedExpression>> child_expressions;
-	child_expressions.reserve(binding->names.size());
-	for (const auto &column_name : binding->names) {
-		child_expressions.push_back(binder.bind_context.CreateColumnReference(
-		    binding->alias, column_name, ColumnBindType::DO_NOT_EXPAND_GENERATED_COLUMNS));
-	}
-	return make_uniq<FunctionExpression>("struct_pack", std::move(child_expressions));
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnNameWithManyDotsInternal(ColumnRefExpression &col_ref,
-                                                                                     ErrorData &error,
-                                                                                     idx_t &struct_extract_start) {
-	// two or more dots (i.e. "part1.part2.part3.part4...")
-	// -> part1 is a catalog, part2 is a schema, part3 is a table, part4 is a column name, part 5 and beyond are
-	// struct fields
-	// -> part1 is a catalog, part2 is a table, part3 is a column name, part4 and beyond are struct fields
-	// -> part1 is a schema, part2 is a table, part3 is a column name, part4 and beyond are struct fields
-	// -> part1 is a table, part2 is a column name, part3 and beyond are struct fields
-	// -> part1 is a column, part2 and beyond are struct fields
-
-	// we always prefer the most top-level view
-	// i.e. in case of multiple resolution options, we resolve in order:
-	// -> 1. resolve "part1" as a catalog
-	// -> 2. resolve "part1" as a schema
-	// -> 3. resolve "part1" as a table
-	// -> 4. resolve "part1" as a column
-
-	// first check if part1 is a catalog
-	optional_ptr<Binding> binding;
-	if (col_ref.column_names.size() > 3) {
-		binding = binder.GetMatchingBinding(col_ref.column_names[0], col_ref.column_names[1], col_ref.column_names[2],
-		                                    col_ref.column_names[3], error);
-		if (binding) {
-			// part1 is a catalog - the column reference is "catalog.schema.table.column"
-			struct_extract_start = 4;
-			return binder.bind_context.CreateColumnReference(binding->alias, col_ref.column_names[3]);
-		}
-	}
-	binding = binder.GetMatchingBinding(col_ref.column_names[0], INVALID_SCHEMA, col_ref.column_names[1],
-	                                    col_ref.column_names[2], error);
-	if (binding) {
-		// part1 is a catalog - the column reference is "catalog.table.column"
-		struct_extract_start = 3;
-		return binder.bind_context.CreateColumnReference(binding->alias, col_ref.column_names[2]);
-	}
-	binding =
-	    binder.GetMatchingBinding(col_ref.column_names[0], col_ref.column_names[1], col_ref.column_names[2], error);
-	if (binding) {
-		// part1 is a schema - the column reference is "schema.table.column"
-		// any additional fields are turned into struct_extract calls
-		struct_extract_start = 3;
-		return binder.bind_context.CreateColumnReference(binding->alias, col_ref.column_names[2]);
-	}
-	binding = binder.GetMatchingBinding(col_ref.column_names[0], col_ref.column_names[1], error);
-	if (binding) {
-		// part1 is a table
-		// the column reference is "table.column"
-		// any additional fields are turned into struct_extract calls
-		struct_extract_start = 2;
-		return binder.bind_context.CreateColumnReference(binding->alias, col_ref.column_names[1]);
-	}
-	// part1 could be a column
-	ErrorData col_error;
-	auto result_expr = QualifyColumnName(col_ref.column_names[0], col_error);
-	if (result_expr) {
-		// it is! add the struct extract calls
-		struct_extract_start = 1;
-		return result_expr;
-	}
-	return CreateStructPack(col_ref);
-}
-unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnNameWithManyDots(ColumnRefExpression &col_ref,
-                                                                             ErrorData &error) {
-	idx_t struct_extract_start = col_ref.column_names.size();
-	auto result_expr = QualifyColumnNameWithManyDotsInternal(col_ref, error, struct_extract_start);
-	if (!result_expr) {
-		return nullptr;
-	}
-
-	// create a struct extract with all remaining column names
-	for (idx_t i = struct_extract_start; i < col_ref.column_names.size(); i++) {
-		result_expr = CreateStructExtract(std::move(result_expr), col_ref.column_names[i]);
-	}
-
-	return result_expr;
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error) {
-
-	// try binding as a lambda parameter
-	if (!col_ref.IsQualified()) {
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
-		if (lambda_ref) {
-			return lambda_ref;
-		}
-	}
-
-	idx_t column_parts = col_ref.column_names.size();
-
-	// column names can have an arbitrary amount of dots
-	// here is how the resolution works:
-	if (column_parts == 1) {
-		// no dots (i.e. "part1")
-		// -> part1 refers to a column
-		// check if we can qualify the column name with the table name
-		auto qualified_col_ref = QualifyColumnName(col_ref.GetColumnName(), error);
-		if (qualified_col_ref) {
-			// we could: return it
-			return qualified_col_ref;
-		}
-		// we could not! Try creating an implicit struct_pack
-		return CreateStructPack(col_ref);
-	}
-
-	if (column_parts == 2) {
-		// one dot (i.e. "part1.part2")
-		// EITHER:
-		// -> part1 is a table, part2 is a column
-		// -> part1 is a column, part2 is a property of that column (i.e. struct_extract)
-
-		// first check if part1 is a table, and part2 is a standard column name
-		auto binding = binder.GetMatchingBinding(col_ref.column_names[0], col_ref.column_names[1], error);
-		if (binding) {
-			// it is! return the column reference directly
-			return binder.bind_context.CreateColumnReference(binding->alias, col_ref.GetColumnName());
-		}
-
-		// otherwise check if we can turn this into a struct extract
-		ErrorData other_error;
-		auto qualified_col_ref = QualifyColumnName(col_ref.column_names[0], other_error);
-		if (qualified_col_ref) {
-			// we could: create a struct extract
-			return CreateStructExtract(std::move(qualified_col_ref), col_ref.column_names[1]);
-		}
-		// we could not! Try creating an implicit struct_pack
-		return CreateStructPack(col_ref);
-	}
-
-	// three or more dots
-	return QualifyColumnNameWithManyDots(col_ref, error);
-}
-
-BindResult ExpressionBinder::BindExpression(LambdaRefExpression &lambda_ref, idx_t depth) {
-	D_ASSERT(lambda_bindings && lambda_ref.lambda_idx < lambda_bindings->size());
-	return (*lambda_bindings)[lambda_ref.lambda_idx].Bind(lambda_ref, depth);
-}
-
-BindResult ExpressionBinder::BindExpression(ColumnRefExpression &col_ref_p, idx_t depth, bool root_expression) {
-	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
-	}
-
-	ErrorData error;
-	auto expr = QualifyColumnName(col_ref_p, error);
-	if (!expr) {
-		if (!col_ref_p.IsQualified()) {
-			// column was not found
-			// first try to bind it as an alias
-			BindResult alias_result;
-			auto found_alias = TryBindAlias(col_ref_p, root_expression, alias_result);
-			if (found_alias) {
-				return alias_result;
-			}
-
-			// column was not found - check if it is a SQL value function
-			auto value_function = GetSQLValueFunction(col_ref_p.GetColumnName());
-			if (value_function) {
-				return BindExpression(value_function, depth);
-			}
-		}
-		error.AddQueryLocation(col_ref_p);
-		return BindResult(std::move(error));
-	}
-
-	expr->SetQueryLocation(col_ref_p.GetQueryLocation());
-
-	// the above QualifyColumName returns a generated expression for a generated
-	// column, and struct_extract for a struct, or a lambda reference expression,
-	// all of them are not column reference expressions, so we return here
-	if (expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
-		auto alias = expr->GetAlias();
-		auto result = BindExpression(expr, depth);
-		if (result.expression) {
-			result.expression->SetAlias(std::move(alias));
-		}
-		return result;
-	}
-
-	// the above QualifyColumnName returned an individual column reference
-	// expression, which we resolve to either a base table or a subquery expression,
-	// and if it was a macro parameter, then we let macro_binding bind it to the argument
-	BindResult result;
-	auto &col_ref = expr->Cast<ColumnRefExpression>();
-	D_ASSERT(col_ref.IsQualified());
-	auto &table_name = col_ref.GetTableName();
-
-	if (binder.macro_binding && table_name == binder.macro_binding->GetAlias()) {
-		result = binder.macro_binding->Bind(col_ref, depth);
-	} else {
-		result = binder.bind_context.BindColumn(col_ref, depth);
-	}
-
-	if (result.HasError()) {
-		result.error.AddQueryLocation(col_ref_p);
-		return result;
-	}
-
-	// we bound the column reference
-	BoundColumnReferenceInfo ref;
-	ref.name = col_ref.column_names.back();
-	ref.query_location = col_ref.GetQueryLocation();
-	bound_columns.push_back(std::move(ref));
-	return result;
-}
-
-bool ExpressionBinder::QualifyColumnAlias(const ColumnRefExpression &col_ref) {
-	// only the BaseSelectBinder will have a valid column alias map,
-	// otherwise we return false
-	return false;
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp
deleted file mode 100644
index cd490f433..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-
-#include "duckdb/function/scalar/string_functions.hpp"
-
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/planner/collation_binding.hpp"
-
-namespace duckdb {
-
-bool ExpressionBinder::PushCollation(ClientContext &context, unique_ptr<Expression> &source,
-                                     const LogicalType &sql_type, CollationType type) {
-	auto &collation_binding = CollationBinding::Get(context);
-	return collation_binding.PushCollation(context, source, sql_type, type);
-}
-
-void ExpressionBinder::TestCollation(ClientContext &context, const string &collation) {
-	auto expr = make_uniq_base<Expression, BoundConstantExpression>(Value(""));
-	PushCollation(context, expr, LogicalType::VARCHAR_COLLATION(collation));
-}
-
-static bool SwitchVarcharComparison(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::INTERVAL:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::INTEGER_LITERAL:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool BoundComparisonExpression::TryBindComparison(ClientContext &context, const LogicalType &left_type,
-                                                  const LogicalType &right_type, LogicalType &result_type,
-                                                  ExpressionType comparison_type) {
-	LogicalType res;
-	bool is_equality;
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-	case ExpressionType::COMPARE_NOTEQUAL:
-	case ExpressionType::COMPARE_IN:
-	case ExpressionType::COMPARE_NOT_IN:
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		is_equality = true;
-		break;
-	default:
-		is_equality = false;
-		break;
-	}
-	if (is_equality) {
-		res = LogicalType::ForceMaxLogicalType(left_type, right_type);
-	} else {
-		if (!LogicalType::TryGetMaxLogicalType(context, left_type, right_type, res)) {
-			return false;
-		}
-	}
-	switch (res.id()) {
-	case LogicalTypeId::DECIMAL: {
-		// result is a decimal: we need the maximum width and the maximum scale over width
-		vector<LogicalType> argument_types = {left_type, right_type};
-		uint8_t max_width = 0, max_scale = 0, max_width_over_scale = 0;
-		for (idx_t i = 0; i < argument_types.size(); i++) {
-			uint8_t width, scale;
-			auto can_convert = argument_types[i].GetDecimalProperties(width, scale);
-			if (!can_convert) {
-				result_type = res;
-				return true;
-			}
-			max_width = MaxValue<uint8_t>(width, max_width);
-			max_scale = MaxValue<uint8_t>(scale, max_scale);
-			max_width_over_scale = MaxValue<uint8_t>(width - scale, max_width_over_scale);
-		}
-		max_width = MaxValue<uint8_t>(max_scale + max_width_over_scale, max_width);
-		if (max_width > Decimal::MAX_WIDTH_DECIMAL) {
-			// target width does not fit in decimal: truncate the scale (if possible) to try and make it fit
-			max_width = Decimal::MAX_WIDTH_DECIMAL;
-		}
-		res = LogicalType::DECIMAL(max_width, max_scale);
-		break;
-	}
-	case LogicalTypeId::VARCHAR:
-		// for comparison with strings, we prefer to bind to the numeric types
-		if (left_type.id() != LogicalTypeId::VARCHAR && SwitchVarcharComparison(left_type)) {
-			res = LogicalType::NormalizeType(left_type);
-		} else if (right_type.id() != LogicalTypeId::VARCHAR && SwitchVarcharComparison(right_type)) {
-			res = LogicalType::NormalizeType(right_type);
-		} else {
-			// else: check if collations are compatible
-			auto left_collation = StringType::GetCollation(left_type);
-			auto right_collation = StringType::GetCollation(right_type);
-			if (!left_collation.empty() && !right_collation.empty() && left_collation != right_collation) {
-				throw BinderException("Cannot combine types with different collation!");
-			}
-		}
-		break;
-	default:
-		break;
-	}
-	result_type = res;
-	return true;
-}
-
-LogicalType BoundComparisonExpression::BindComparison(ClientContext &context, const LogicalType &left_type,
-                                                      const LogicalType &right_type, ExpressionType comparison_type) {
-	LogicalType result_type;
-	if (!BoundComparisonExpression::TryBindComparison(context, left_type, right_type, result_type, comparison_type)) {
-		throw BinderException("Cannot mix values of type %s and %s - an explicit cast is required",
-		                      left_type.ToString(), right_type.ToString());
-	}
-	return result_type;
-}
-
-LogicalType ExpressionBinder::GetExpressionReturnType(const Expression &expr) {
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
-		if (expr.return_type == LogicalTypeId::VARCHAR && StringType::GetCollation(expr.return_type).empty()) {
-			return LogicalTypeId::STRING_LITERAL;
-		}
-		if (expr.return_type.IsIntegral()) {
-			auto &constant = expr.Cast<BoundConstantExpression>();
-			if (!constant.value.IsNull()) {
-				return LogicalType::INTEGER_LITERAL(constant.value);
-			}
-		}
-	}
-	return expr.return_type;
-}
-
-BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	ErrorData error;
-	BindChild(expr.left, depth, error);
-	BindChild(expr.right, depth, error);
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-
-	// the children have been successfully resolved
-	auto &left = BoundExpression::GetExpression(*expr.left);
-	auto &right = BoundExpression::GetExpression(*expr.right);
-	auto left_sql_type = ExpressionBinder::GetExpressionReturnType(*left);
-	auto right_sql_type = ExpressionBinder::GetExpressionReturnType(*right);
-	// cast the input types to the same type
-	// now obtain the result type of the input types
-	LogicalType input_type;
-	if (!BoundComparisonExpression::TryBindComparison(context, left_sql_type, right_sql_type, input_type,
-	                                                  expr.GetExpressionType())) {
-		return BindResult(BinderException(expr,
-		                                  "Cannot compare values of type %s and type %s - an explicit cast is required",
-		                                  left_sql_type.ToString(), right_sql_type.ToString()));
-	}
-	// add casts (if necessary)
-	left = BoundCastExpression::AddCastToType(context, std::move(left), input_type,
-	                                          input_type.id() == LogicalTypeId::ENUM);
-	right = BoundCastExpression::AddCastToType(context, std::move(right), input_type,
-	                                           input_type.id() == LogicalTypeId::ENUM);
-
-	PushCollation(context, left, input_type);
-	PushCollation(context, right, input_type);
-
-	// now create the bound comparison expression
-	return BindResult(
-	    make_uniq<BoundComparisonExpression>(expr.GetExpressionType(), std::move(left), std::move(right)));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_conjunction_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_conjunction_expression.cpp
deleted file mode 100644
index b93cb5a2d..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_conjunction_expression.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(ConjunctionExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	ErrorData error;
-	for (idx_t i = 0; i < expr.children.size(); i++) {
-		BindChild(expr.children[i], depth, error);
-	}
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-	// the children have been successfully resolved
-	// cast the input types to boolean (if necessary)
-	// and construct the bound conjunction expression
-	auto result = make_uniq<BoundConjunctionExpression>(expr.GetExpressionType());
-	for (auto &child_expr : expr.children) {
-		auto &child = BoundExpression::GetExpression(*child_expr);
-		result->children.push_back(BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN));
-	}
-	// now create the bound conjunction expression
-	return BindResult(std::move(result));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_constant_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_constant_expression.cpp
deleted file mode 100644
index 1222cf46b..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_constant_expression.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(ConstantExpression &expr, idx_t depth) {
-	return BindResult(make_uniq<BoundConstantExpression>(expr.value));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp
deleted file mode 100644
index b2a44072c..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_lambda_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::TryBindLambdaOrJson(FunctionExpression &function, idx_t depth, CatalogEntry &func) {
-
-	auto lambda_bind_result = BindLambdaFunction(function, func.Cast<ScalarFunctionCatalogEntry>(), depth);
-	if (!lambda_bind_result.HasError()) {
-		return lambda_bind_result;
-	}
-
-	auto json_bind_result = BindFunction(function, func.Cast<ScalarFunctionCatalogEntry>(), depth);
-	if (!json_bind_result.HasError()) {
-		return json_bind_result;
-	}
-
-	return BindResult("failed to bind function, either: " + lambda_bind_result.error.RawMessage() +
-	                  "\n"
-	                  " or: " +
-	                  json_bind_result.error.RawMessage());
-}
-
-BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t depth,
-                                            unique_ptr<ParsedExpression> &expr_ptr) {
-	// lookup the function in the catalog
-	QueryErrorContext error_context(function.GetQueryLocation());
-	binder.BindSchemaOrCatalog(function.catalog, function.schema);
-	auto func = GetCatalogEntry(CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
-	                            function.function_name, OnEntryNotFound::RETURN_NULL, error_context);
-	if (!func) {
-		// function was not found - check if we this is a table function
-		auto table_func = GetCatalogEntry(CatalogType::TABLE_FUNCTION_ENTRY, function.catalog, function.schema,
-		                                  function.function_name, OnEntryNotFound::RETURN_NULL, error_context);
-		if (table_func) {
-			throw BinderException(function,
-			                      "Function \"%s\" is a table function but it was used as a scalar function. This "
-			                      "function has to be called in a FROM clause (similar to a table).",
-			                      function.function_name);
-		}
-		// not a table function - check if the schema is set
-		if (!function.schema.empty()) {
-			// the schema is set - check if we can turn this the schema into a column ref
-			ErrorData error;
-			unique_ptr<ColumnRefExpression> colref;
-			if (function.catalog.empty()) {
-				colref = make_uniq<ColumnRefExpression>(function.schema);
-			} else {
-				colref = make_uniq<ColumnRefExpression>(function.schema, function.catalog);
-			}
-			auto new_colref = QualifyColumnName(*colref, error);
-			bool is_col = !error.HasError();
-			bool is_col_alias = QualifyColumnAlias(*colref);
-
-			if (is_col || is_col_alias) {
-				// we can! transform this into a function call on the column
-				// i.e. "x.lower()" becomes "lower(x)"
-				function.children.insert(function.children.begin(), std::move(colref));
-				function.catalog = INVALID_CATALOG;
-				function.schema = INVALID_SCHEMA;
-			}
-		}
-		// rebind the function
-		func = GetCatalogEntry(CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
-		                       function.function_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
-	}
-
-	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&
-	    (function.distinct || function.filter || !function.order_bys->orders.empty())) {
-		throw InvalidInputException("Function \"%s\" is a %s. \"DISTINCT\", \"FILTER\", and \"ORDER BY\" are only "
-		                            "applicable to aggregate functions.",
-		                            function.function_name, CatalogTypeToString(func->type));
-	}
-
-	switch (func->type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY: {
-		if (function.IsLambdaFunction()) {
-			return TryBindLambdaOrJson(function, depth, *func);
-		}
-		return BindFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
-	}
-	case CatalogType::MACRO_ENTRY:
-		// macro function
-		return BindMacro(function, func->Cast<ScalarMacroCatalogEntry>(), depth, expr_ptr);
-	default:
-		// aggregate function
-		return BindAggregate(function, func->Cast<AggregateFunctionCatalogEntry>(), depth);
-	}
-}
-
-BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFunctionCatalogEntry &func, idx_t depth) {
-	// bind the children of the function expression
-	ErrorData error;
-
-	// bind of each child
-	for (idx_t i = 0; i < function.children.size(); i++) {
-		BindChild(function.children[i], depth, error);
-	}
-
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
-	}
-
-	// all children bound successfully
-	// extract the children and types
-	vector<unique_ptr<Expression>> children;
-	for (idx_t i = 0; i < function.children.size(); i++) {
-		auto &child = BoundExpression::GetExpression(*function.children[i]);
-		children.push_back(std::move(child));
-	}
-
-	FunctionBinder function_binder(binder);
-	auto result = function_binder.BindScalarFunction(func, std::move(children), error, function.is_operator, &binder);
-	if (!result) {
-		error.AddQueryLocation(function);
-		error.Throw();
-	}
-	if (result->GetExpressionType() == ExpressionType::BOUND_FUNCTION) {
-		auto &bound_function = result->Cast<BoundFunctionExpression>();
-		if (bound_function.function.stability == FunctionStability::CONSISTENT_WITHIN_QUERY) {
-			binder.SetAlwaysRequireRebind();
-		}
-	}
-	return BindResult(std::move(result));
-}
-
-BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, ScalarFunctionCatalogEntry &func,
-                                                idx_t depth) {
-
-	// scalar functions with lambdas can never be overloaded
-	if (func.functions.functions.size() != 1) {
-		return BindResult("This scalar function does not support lambdas!");
-	}
-
-	// get the callback function for the lambda parameter types
-	auto &scalar_function = func.functions.functions.front();
-	auto &bind_lambda_function = scalar_function.bind_lambda;
-	if (!bind_lambda_function) {
-		return BindResult("This scalar function does not support lambdas!");
-	}
-
-	if (function.children.size() != 2) {
-		return BindResult("Invalid number of function arguments!");
-	}
-	D_ASSERT(function.children[1]->GetExpressionClass() == ExpressionClass::LAMBDA);
-
-	// bind the list parameter
-	ErrorData error;
-	BindChild(function.children[0], depth, error);
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-
-	// get the logical type of the children of the list
-	auto &list_child = BoundExpression::GetExpression(*function.children[0]);
-	if (list_child->return_type.id() != LogicalTypeId::LIST && list_child->return_type.id() != LogicalTypeId::ARRAY &&
-	    list_child->return_type.id() != LogicalTypeId::SQLNULL &&
-	    list_child->return_type.id() != LogicalTypeId::UNKNOWN) {
-		return BindResult("Invalid LIST argument during lambda function binding!");
-	}
-
-	LogicalType list_child_type = list_child->return_type.id();
-	if (list_child->return_type.id() != LogicalTypeId::SQLNULL &&
-	    list_child->return_type.id() != LogicalTypeId::UNKNOWN) {
-
-		if (list_child->return_type.id() == LogicalTypeId::ARRAY) {
-			list_child_type = ArrayType::GetChildType(list_child->return_type);
-		} else {
-			list_child_type = ListType::GetChildType(list_child->return_type);
-		}
-	}
-
-	// bind the lambda parameter
-	auto &lambda_expr = function.children[1]->Cast<LambdaExpression>();
-	BindResult bind_lambda_result = BindExpression(lambda_expr, depth, list_child_type, &bind_lambda_function);
-
-	if (bind_lambda_result.HasError()) {
-		return BindResult(bind_lambda_result.error);
-	}
-
-	// successfully bound: replace the node with a BoundExpression
-	auto alias = function.children[1]->GetAlias();
-	bind_lambda_result.expression->SetAlias(alias);
-	if (!alias.empty()) {
-		bind_lambda_result.expression->SetAlias(alias);
-	}
-	function.children[1] = make_uniq<BoundExpression>(std::move(bind_lambda_result.expression));
-
-	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
-	}
-
-	// all children bound successfully
-	// extract the children and types
-	vector<unique_ptr<Expression>> children;
-	for (idx_t i = 0; i < function.children.size(); i++) {
-		auto &child = BoundExpression::GetExpression(*function.children[i]);
-		children.push_back(std::move(child));
-	}
-
-	// capture the (lambda) columns
-	auto &bound_lambda_expr = children.back()->Cast<BoundLambdaExpression>();
-	CaptureLambdaColumns(bound_lambda_expr, bound_lambda_expr.lambda_expr, &bind_lambda_function, list_child_type);
-
-	FunctionBinder function_binder(binder);
-	unique_ptr<Expression> result =
-	    function_binder.BindScalarFunction(func, std::move(children), error, function.is_operator, &binder);
-	if (!result) {
-		error.AddQueryLocation(function);
-		error.Throw();
-	}
-
-	auto &bound_function_expr = result->Cast<BoundFunctionExpression>();
-	D_ASSERT(bound_function_expr.children.size() == 2);
-
-	// remove the lambda expression from the children
-	auto lambda = std::move(bound_function_expr.children.back());
-	bound_function_expr.children.pop_back();
-	auto &bound_lambda = lambda->Cast<BoundLambdaExpression>();
-
-	// push back (in reverse order) any nested lambda parameters so that we can later use them in the lambda
-	// expression (rhs). This happens after we bound the lambda expression of this depth. So it is relevant for
-	// correctly binding lambdas one level 'out'. Therefore, the current parameter count does not matter here.
-	idx_t offset = 0;
-	if (lambda_bindings) {
-		for (idx_t i = lambda_bindings->size(); i > 0; i--) {
-
-			auto &binding = (*lambda_bindings)[i - 1];
-			D_ASSERT(binding.names.size() == binding.types.size());
-
-			for (idx_t column_idx = binding.names.size(); column_idx > 0; column_idx--) {
-				auto bound_lambda_param = make_uniq<BoundReferenceExpression>(binding.names[column_idx - 1],
-				                                                              binding.types[column_idx - 1], offset);
-				offset++;
-				bound_function_expr.children.push_back(std::move(bound_lambda_param));
-			}
-		}
-	}
-
-	// push back the captures into the children vector
-	for (auto &capture : bound_lambda.captures) {
-		bound_function_expr.children.push_back(std::move(capture));
-	}
-
-	return BindResult(std::move(result));
-}
-
-BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function,
-                                           idx_t depth) {
-	return BindUnsupportedExpression(expr, depth, UnsupportedAggregateMessage());
-}
-
-BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression) {
-	return BindUnsupportedExpression(expr, depth, UnsupportedUnnestMessage());
-}
-
-void ExpressionBinder::ThrowIfUnnestInLambda(const ColumnBinding &column_binding) {
-}
-
-string ExpressionBinder::UnsupportedAggregateMessage() {
-	return "Aggregate functions are not supported here";
-}
-
-string ExpressionBinder::UnsupportedUnnestMessage() {
-	return "UNNEST not supported here";
-}
-
-optional_ptr<CatalogEntry> ExpressionBinder::GetCatalogEntry(CatalogType type, const string &catalog,
-                                                             const string &schema, const string &name,
-                                                             OnEntryNotFound on_entry_not_found,
-                                                             QueryErrorContext &error_context) {
-	return binder.GetCatalogEntry(type, catalog, schema, name, on_entry_not_found, error_context);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_lambda.cpp b/src/duckdb/src/planner/binder/expression/bind_lambda.cpp
deleted file mode 100644
index acc68ed0b..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_lambda.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-#include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/bind_context.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
-#include "duckdb/planner/expression/bound_lambda_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-
-namespace duckdb {
-
-idx_t GetLambdaParamCount(const vector<DummyBinding> &lambda_bindings) {
-	idx_t count = 0;
-	for (auto &binding : lambda_bindings) {
-		count += binding.names.size();
-	}
-	return count;
-}
-
-idx_t GetLambdaParamIndex(const vector<DummyBinding> &lambda_bindings, const BoundLambdaExpression &bound_lambda_expr,
-                          const BoundLambdaRefExpression &bound_lambda_ref_expr) {
-	D_ASSERT(bound_lambda_ref_expr.lambda_idx < lambda_bindings.size());
-	idx_t offset = 0;
-	// count the remaining lambda parameters BEFORE the current lambda parameter,
-	// as these will be in front of the current lambda parameter in the input chunk
-	for (idx_t i = bound_lambda_ref_expr.lambda_idx + 1; i < lambda_bindings.size(); i++) {
-		offset += lambda_bindings[i].names.size();
-	}
-	offset +=
-	    lambda_bindings[bound_lambda_ref_expr.lambda_idx].names.size() - bound_lambda_ref_expr.binding.column_index - 1;
-	offset += bound_lambda_expr.parameter_count;
-	return offset;
-}
-
-void ExtractParameter(ParsedExpression &expr, vector<string> &column_names, vector<string> &column_aliases) {
-
-	auto &column_ref = expr.Cast<ColumnRefExpression>();
-	if (column_ref.IsQualified()) {
-		throw BinderException(LambdaExpression::InvalidParametersErrorMessage());
-	}
-
-	column_names.push_back(column_ref.GetName());
-	column_aliases.push_back(column_ref.ToString());
-}
-
-void ExtractParameters(LambdaExpression &expr, vector<string> &column_names, vector<string> &column_aliases) {
-
-	// extract the lambda parameters, which are a single column
-	// reference, or a list of column references (ROW function)
-	string error_message;
-	auto column_refs = expr.ExtractColumnRefExpressions(error_message);
-	if (!error_message.empty()) {
-		throw BinderException(error_message);
-	}
-
-	for (const auto &column_ref : column_refs) {
-		ExtractParameter(column_ref.get(), column_names, column_aliases);
-	}
-	D_ASSERT(!column_names.empty());
-}
-
-BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth, const LogicalType &list_child_type,
-                                            optional_ptr<bind_lambda_function_t> bind_lambda_function) {
-
-	// This is not a lambda expression, but the JSON arrow operator.
-	if (!bind_lambda_function) {
-		OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(expr.lhs), std::move(expr.expr));
-		auto bind_result = BindExpression(arrow_expr, depth);
-
-		// The arrow_expr now contains bound nodes. We move these into the original expression.
-		if (bind_result.HasError()) {
-			D_ASSERT(arrow_expr.children.size() == 2);
-			expr.lhs = std::move(arrow_expr.children[0]);
-			expr.expr = std::move(arrow_expr.children[1]);
-		}
-		return bind_result;
-	}
-
-	// extract and verify lambda parameters to create dummy columns
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	vector<string> column_aliases;
-	ExtractParameters(expr, column_names, column_aliases);
-	for (idx_t i = 0; i < column_names.size(); i++) {
-		column_types.push_back((*bind_lambda_function)(i, list_child_type));
-	}
-
-	// base table alias
-	auto table_alias = StringUtil::Join(column_aliases, ", ");
-	if (column_aliases.size() > 1) {
-		table_alias = "(" + table_alias + ")";
-	}
-
-	// create a lambda binding and push it to the lambda bindings vector
-	vector<DummyBinding> local_bindings;
-	if (!lambda_bindings) {
-		lambda_bindings = &local_bindings;
-	}
-	DummyBinding new_lambda_binding(column_types, column_names, table_alias);
-	lambda_bindings->push_back(new_lambda_binding);
-
-	auto result = BindExpression(expr.expr, depth, false);
-	lambda_bindings->pop_back();
-
-	// successfully bound a subtree of nested lambdas, set this to nullptr in case other parts of the
-	// query also contain lambdas
-	if (lambda_bindings->empty()) {
-		lambda_bindings = nullptr;
-	}
-
-	if (result.HasError()) {
-		result.error.Throw();
-	}
-
-	return BindResult(make_uniq<BoundLambdaExpression>(ExpressionType::LAMBDA, LogicalType::LAMBDA,
-	                                                   std::move(result.expression), column_names.size()));
-}
-
-void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &original,
-                                                     unique_ptr<Expression> &replacement,
-                                                     BoundLambdaExpression &bound_lambda_expr,
-                                                     const optional_ptr<bind_lambda_function_t> bind_lambda_function,
-                                                     const LogicalType &list_child_type) {
-
-	// check if the original expression is a lambda parameter
-	if (original->GetExpressionClass() == ExpressionClass::BOUND_LAMBDA_REF) {
-
-		auto &bound_lambda_ref = original->Cast<BoundLambdaRefExpression>();
-		auto alias = bound_lambda_ref.GetAlias();
-
-		// refers to a lambda parameter outside the current lambda function
-		// so the lambda parameter will be inside the lambda_bindings
-		if (lambda_bindings && bound_lambda_ref.lambda_idx != lambda_bindings->size()) {
-
-			auto &binding = (*lambda_bindings)[bound_lambda_ref.lambda_idx];
-			D_ASSERT(binding.names.size() == binding.types.size());
-
-			// find the matching dummy column in the lambda binding
-			for (idx_t column_idx = 0; column_idx < binding.names.size(); column_idx++) {
-				if (column_idx == bound_lambda_ref.binding.column_index) {
-
-					// now create the replacement
-					auto index = GetLambdaParamIndex(*lambda_bindings, bound_lambda_expr, bound_lambda_ref);
-					replacement = make_uniq<BoundReferenceExpression>(binding.names[column_idx],
-					                                                  binding.types[column_idx], index);
-					return;
-				}
-			}
-
-			// error resolving the lambda index
-			throw InternalException("Failed to bind lambda parameter internally");
-		}
-
-		// refers to a lambda parameter inside the current lambda function
-		auto logical_type = (*bind_lambda_function)(bound_lambda_ref.binding.column_index, list_child_type);
-		auto index = bound_lambda_expr.parameter_count - bound_lambda_ref.binding.column_index - 1;
-		replacement = make_uniq<BoundReferenceExpression>(alias, logical_type, index);
-		return;
-	}
-
-	// this is not a lambda parameter, get the capture offset
-	idx_t offset = 0;
-	if (lambda_bindings) {
-		offset += GetLambdaParamCount(*lambda_bindings);
-	}
-	offset += bound_lambda_expr.parameter_count;
-	offset += bound_lambda_expr.captures.size();
-
-	replacement = make_uniq<BoundReferenceExpression>(original->GetAlias(), original->return_type, offset);
-	bound_lambda_expr.captures.push_back(std::move(original));
-}
-
-void ExpressionBinder::CaptureLambdaColumns(BoundLambdaExpression &bound_lambda_expr, unique_ptr<Expression> &expr,
-                                            const optional_ptr<bind_lambda_function_t> bind_lambda_function,
-                                            const LogicalType &list_child_type) {
-
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
-		throw BinderException("subqueries in lambda expressions are not supported");
-	}
-
-	// these are bound depth-first
-	D_ASSERT(expr->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA);
-
-	// we do not need to replace anything, as these will be constant in the lambda expression
-	// when executed by the expression executor
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
-		return;
-	}
-
-	// these expression classes do not have children, transform them
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF ||
-	    expr->GetExpressionClass() == ExpressionClass::BOUND_PARAMETER ||
-	    expr->GetExpressionClass() == ExpressionClass::BOUND_LAMBDA_REF) {
-
-		if (expr->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
-			// Search for UNNEST.
-			auto &column_binding = expr->Cast<BoundColumnRefExpression>().binding;
-			ThrowIfUnnestInLambda(column_binding);
-		}
-
-		// move the expr because we are going to replace it
-		auto original = std::move(expr);
-		unique_ptr<Expression> replacement;
-
-		TransformCapturedLambdaColumn(original, replacement, bound_lambda_expr, bind_lambda_function, list_child_type);
-
-		// replace the expression
-		expr = std::move(replacement);
-
-	} else {
-		// recursively enumerate the children of the expression
-		ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-			CaptureLambdaColumns(bound_lambda_expr, child, bind_lambda_function, list_child_type);
-		});
-	}
-
-	expr->Verify();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp
deleted file mode 100644
index c6c12a985..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/function/scalar_macro_function.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &function,
-                                                      vector<unordered_set<string>> &lambda_params) {
-
-	for (auto &child : function.children) {
-		if (child->GetExpressionClass() != ExpressionClass::LAMBDA) {
-			ReplaceMacroParameters(child, lambda_params);
-			continue;
-		}
-
-		// Special-handling for LHS lambda parameters.
-		// We do not replace them, and we add them to the lambda_params vector.
-		auto &lambda_expr = child->Cast<LambdaExpression>();
-		string error_message;
-		auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message);
-
-		if (!error_message.empty()) {
-			// Possibly a JSON function, replace both LHS and RHS.
-			ReplaceMacroParameters(lambda_expr.lhs, lambda_params);
-			ReplaceMacroParameters(lambda_expr.expr, lambda_params);
-			continue;
-		}
-
-		// Push the lambda parameter names of this level.
-		lambda_params.emplace_back();
-		for (const auto &column_ref_expr : column_ref_expressions) {
-			const auto &column_ref = column_ref_expr.get().Cast<ColumnRefExpression>();
-			lambda_params.back().emplace(column_ref.GetName());
-		}
-
-		// Only replace in the RHS of the expression.
-		ReplaceMacroParameters(lambda_expr.expr, lambda_params);
-
-		lambda_params.pop_back();
-	}
-}
-
-void ExpressionBinder::ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr,
-                                              vector<unordered_set<string>> &lambda_params) {
-
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF: {
-		// If the expression is a column reference, we replace it with its argument.
-		auto &col_ref = expr->Cast<ColumnRefExpression>();
-		if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) {
-			return;
-		}
-
-		bool bind_macro_parameter = false;
-		if (col_ref.IsQualified()) {
-			if (col_ref.GetTableName().find(DummyBinding::DUMMY_NAME) != string::npos) {
-				bind_macro_parameter = true;
-			}
-		} else {
-			bind_macro_parameter = macro_binding->HasMatchingBinding(col_ref.GetColumnName());
-		}
-
-		if (bind_macro_parameter) {
-			D_ASSERT(macro_binding->HasMatchingBinding(col_ref.GetColumnName()));
-			expr = macro_binding->ParamToArg(col_ref);
-		}
-		return;
-	}
-	case ExpressionClass::FUNCTION: {
-		// Special-handling for lambdas, which are inside function expressions.
-		auto &function = expr->Cast<FunctionExpression>();
-		if (function.IsLambdaFunction()) {
-			return ReplaceMacroParametersInLambda(function, lambda_params);
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
-		ParsedExpressionIterator::EnumerateQueryNodeChildren(
-		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParameters(child, lambda_params); });
-		break;
-	}
-	default:
-		break;
-	}
-
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParameters(child, lambda_params); });
-}
-
-void ExpressionBinder::UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func,
-                                             unique_ptr<ParsedExpression> &expr) {
-	// validate the arguments and separate positional and default arguments
-	vector<unique_ptr<ParsedExpression>> positionals;
-	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
-
-	auto bind_result =
-	    MacroFunction::BindMacroFunction(macro_func.macros, macro_func.name, function, positionals, defaults);
-	if (!bind_result.error.empty()) {
-		throw BinderException(*expr, bind_result.error);
-	}
-	auto &macro_def = macro_func.macros[bind_result.function_idx.GetIndex()]->Cast<ScalarMacroFunction>();
-
-	// create a MacroBinding to bind this macro's parameters to its arguments
-	vector<LogicalType> types;
-	vector<string> names;
-	// positional parameters
-	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		types.emplace_back(LogicalTypeId::UNKNOWN);
-		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
-		names.push_back(param.GetColumnName());
-	}
-	// default parameters
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		types.emplace_back(LogicalTypeId::UNKNOWN);
-		names.push_back(it->first);
-		// now push the defaults into the positionals
-		positionals.push_back(std::move(defaults[it->first]));
-	}
-	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func.name);
-	new_macro_binding->arguments = &positionals;
-	macro_binding = new_macro_binding.get();
-
-	// replace current expression with stored macro expression
-	// special case: If this is a window function, then we need to return a window expression
-	if (expr->GetExpressionClass() == ExpressionClass::WINDOW) {
-		//	Only allowed if the expression is a function
-		if (macro_def.expression->GetExpressionType() != ExpressionType::FUNCTION) {
-			throw BinderException("Window function macros must be functions");
-		}
-		auto macro_copy = macro_def.expression->Copy();
-		auto &macro_expr = macro_copy->Cast<FunctionExpression>();
-		// Transfer the macro function attributes
-		auto &window_expr = expr->Cast<WindowExpression>();
-		window_expr.catalog = macro_expr.catalog;
-		window_expr.schema = macro_expr.schema;
-		window_expr.function_name = macro_expr.function_name;
-		window_expr.children = std::move(macro_expr.children);
-		window_expr.distinct = macro_expr.distinct;
-		window_expr.filter_expr = std::move(macro_expr.filter);
-		// TODO: transfer order_bys when window functions support them
-	} else {
-		expr = macro_def.expression->Copy();
-	}
-
-	// qualify only the macro parameters with a new empty binder that only knows the macro binding
-	auto dummy_binder = Binder::CreateBinder(context);
-	dummy_binder->macro_binding = new_macro_binding.get();
-	ExpressionBinder::QualifyColumnNames(*dummy_binder, expr);
-
-	// now replace the parameters
-	vector<unordered_set<string>> lambda_params;
-	ReplaceMacroParameters(expr, lambda_params);
-}
-
-BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func, idx_t depth,
-                                       unique_ptr<ParsedExpression> &expr) {
-	auto stack_checker = StackCheck(*expr, 3);
-
-	// unfold the macro expression
-	UnfoldMacroExpression(function, macro_func, expr);
-
-	// bind the unfolded macro
-	return BindExpression(expr, depth);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp
deleted file mode 100644
index 9326c8849..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-LogicalType ExpressionBinder::ResolveNotType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
-	// NOT expression, cast child to BOOLEAN
-	D_ASSERT(children.size() == 1);
-	children[0] = BoundCastExpression::AddCastToType(context, std::move(children[0]), LogicalType::BOOLEAN);
-	return LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-LogicalType ExpressionBinder::ResolveCoalesceType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
-	if (children.empty()) {
-		throw InternalException("IN requires at least a single child node");
-	}
-	// get the maximum type from the children
-	LogicalType max_type = ExpressionBinder::GetExpressionReturnType(*children[0]);
-	bool is_in_operator = (op.GetExpressionType() == ExpressionType::COMPARE_IN ||
-	                       op.GetExpressionType() == ExpressionType::COMPARE_NOT_IN);
-	for (idx_t i = 1; i < children.size(); i++) {
-		auto child_return = ExpressionBinder::GetExpressionReturnType(*children[i]);
-		if (is_in_operator) {
-			// If it's IN/NOT_IN operator, adjust DECIMAL and VARCHAR returned type.
-			if (!BoundComparisonExpression::TryBindComparison(context, max_type, child_return, max_type,
-			                                                  op.GetExpressionType())) {
-				throw BinderException(op,
-				                      "Cannot mix values of type %s and %s in %s clause - an explicit cast is required",
-				                      max_type.ToString(), child_return.ToString(),
-				                      op.GetExpressionType() == ExpressionType::COMPARE_IN ? "IN" : "NOT IN");
-			}
-		} else {
-			// If it's COALESCE operator, don't do extra adjustment.
-			if (!LogicalType::TryGetMaxLogicalType(context, max_type, child_return, max_type)) {
-				throw BinderException(
-				    op, "Cannot mix values of type %s and %s in COALESCE operator - an explicit cast is required",
-				    max_type.ToString(), child_return.ToString());
-			}
-		}
-	}
-
-	// cast all children to the same type
-	for (auto &child : children) {
-		child = BoundCastExpression::AddCastToType(context, std::move(child), max_type);
-		if (is_in_operator) {
-			// If it's IN/NOT_IN operator, push collation functions.
-			ExpressionBinder::PushCollation(context, child, max_type);
-		}
-	}
-	return max_type;
-}
-
-LogicalType ExpressionBinder::ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
-	switch (op.GetExpressionType()) {
-	case ExpressionType::OPERATOR_IS_NULL:
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		// IS (NOT) NULL always returns a boolean, and does not cast its children
-		if (!children[0]->return_type.IsValid()) {
-			throw ParameterNotResolvedException();
-		}
-		return LogicalType::BOOLEAN;
-	case ExpressionType::COMPARE_IN:
-	case ExpressionType::COMPARE_NOT_IN:
-		ResolveCoalesceType(op, children);
-		// (NOT) IN always returns a boolean
-		return LogicalType::BOOLEAN;
-	case ExpressionType::OPERATOR_COALESCE: {
-		return ResolveCoalesceType(op, children);
-	}
-	case ExpressionType::OPERATOR_NOT:
-		return ResolveNotType(op, children);
-	default:
-		throw InternalException("Unrecognized expression type for ResolveOperatorType");
-	}
-}
-
-BindResult ExpressionBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
-	return BindResult("GROUPING function is not supported here");
-}
-
-BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth) {
-	if (op.GetExpressionType() == ExpressionType::GROUPING_FUNCTION) {
-		return BindGroupingFunction(op, depth);
-	}
-
-	// Bind the children of the operator expression. We already create bound expressions.
-	// Only those children that trigger an error are not yet bound.
-	ErrorData error;
-	for (idx_t i = 0; i < op.children.size(); i++) {
-		BindChild(op.children[i], depth, error);
-	}
-	if (error.HasError()) {
-		return BindResult(std::move(error));
-	}
-
-	// all children bound successfully
-	string function_name;
-	switch (op.GetExpressionType()) {
-	case ExpressionType::ARRAY_EXTRACT: {
-		D_ASSERT(op.children[0]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-		auto &b_exp = BoundExpression::GetExpression(*op.children[0]);
-		const auto &b_exp_type = b_exp->return_type;
-		if (b_exp_type.id() == LogicalTypeId::MAP) {
-			function_name = "map_extract";
-		} else if (b_exp_type.IsJSONType() && op.children.size() == 2) {
-			function_name = "json_extract";
-			// Make sure we only extract array elements, not fields, by adding the $[] syntax
-			auto &i_exp = BoundExpression::GetExpression(*op.children[1]);
-			if (i_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
-				auto &const_exp = i_exp->Cast<BoundConstantExpression>();
-				if (!const_exp.value.IsNull()) {
-					const_exp.value = StringUtil::Format("$[%s]", const_exp.value.ToString());
-					const_exp.return_type = LogicalType::VARCHAR;
-				}
-			}
-		} else {
-			function_name = "array_extract";
-		}
-		break;
-	}
-	case ExpressionType::ARRAY_SLICE:
-		function_name = "array_slice";
-		break;
-	case ExpressionType::STRUCT_EXTRACT: {
-		D_ASSERT(op.children.size() == 2);
-		D_ASSERT(op.children[0]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-		D_ASSERT(op.children[1]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-		auto &extract_exp = BoundExpression::GetExpression(*op.children[0]);
-		if (extract_exp->HasParameter() || extract_exp->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-		auto &name_exp = BoundExpression::GetExpression(*op.children[1]);
-		const auto &extract_expr_type = extract_exp->return_type;
-		if (extract_expr_type.id() != LogicalTypeId::STRUCT && extract_expr_type.id() != LogicalTypeId::UNION &&
-		    extract_expr_type.id() != LogicalTypeId::MAP && extract_expr_type.id() != LogicalTypeId::SQLNULL &&
-		    !extract_expr_type.IsJSONType()) {
-			return BindResult(StringUtil::Format(
-			    "Cannot extract field %s from expression \"%s\" because it is not a struct, union, map, or json",
-			    name_exp->ToString(), extract_exp->ToString()));
-		}
-		if (extract_expr_type.id() == LogicalTypeId::UNION) {
-			function_name = "union_extract";
-		} else if (extract_expr_type.id() == LogicalTypeId::MAP) {
-			function_name = "map_extract";
-		} else if (extract_expr_type.IsJSONType()) {
-			function_name = "json_extract";
-			// Make sure we only extract fields, not array elements, by adding $. syntax
-			if (name_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
-				auto &const_exp = name_exp->Cast<BoundConstantExpression>();
-				if (!const_exp.value.IsNull()) {
-					const_exp.value = StringUtil::Format("$.\"%s\"", const_exp.value.ToString());
-					const_exp.return_type = LogicalType::VARCHAR;
-				}
-			}
-		} else {
-			function_name = "struct_extract";
-		}
-		break;
-	}
-	case ExpressionType::ARRAY_CONSTRUCTOR:
-		function_name = "list_value";
-		break;
-	case ExpressionType::ARROW:
-		function_name = "json_extract";
-		break;
-	default:
-		break;
-	}
-	if (!function_name.empty()) {
-		auto function = make_uniq_base<ParsedExpression, FunctionExpression>(function_name, std::move(op.children));
-		return BindExpression(function, depth, false);
-	}
-
-	vector<unique_ptr<Expression>> children;
-	for (idx_t i = 0; i < op.children.size(); i++) {
-		D_ASSERT(op.children[i]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-		children.push_back(std::move(BoundExpression::GetExpression(*op.children[i])));
-	}
-	// now resolve the types
-	LogicalType result_type = ResolveOperatorType(op, children);
-	if (op.GetExpressionType() == ExpressionType::OPERATOR_COALESCE) {
-		if (children.empty()) {
-			throw BinderException("COALESCE needs at least one child");
-		}
-		if (children.size() == 1) {
-			return BindResult(std::move(children[0]));
-		}
-	}
-
-	auto result = make_uniq<BoundOperatorExpression>(op.GetExpressionType(), result_type);
-	for (auto &child : children) {
-		result->children.push_back(std::move(child));
-	}
-	return BindResult(std::move(result));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_parameter_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_parameter_expression.cpp
deleted file mode 100644
index 109c0ecbd..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_parameter_expression.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
-	if (!binder.parameters) {
-		throw BinderException("Unexpected prepared parameter. This type of statement can't be prepared!");
-	}
-	auto parameter_id = expr.identifier;
-
-	D_ASSERT(binder.parameters);
-	// Check if a parameter value has already been supplied
-	auto &parameter_data = binder.parameters->GetParameterData();
-	auto param_data_it = parameter_data.find(parameter_id);
-	if (param_data_it != parameter_data.end()) {
-		// it has! emit a constant directly
-		auto &data = param_data_it->second;
-		auto return_type = binder.parameters->GetReturnType(parameter_id);
-		bool is_literal =
-		    return_type.id() == LogicalTypeId::INTEGER_LITERAL || return_type.id() == LogicalTypeId::STRING_LITERAL;
-		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
-		constant->SetAlias(expr.GetAlias());
-		if (is_literal) {
-			return BindResult(std::move(constant));
-		}
-		auto cast = BoundCastExpression::AddCastToType(context, std::move(constant), return_type);
-		return BindResult(std::move(cast));
-	}
-
-	auto bound_parameter = binder.parameters->BindParameterExpression(expr);
-	return BindResult(std::move(bound_parameter));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_positional_reference_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_positional_reference_expression.cpp
deleted file mode 100644
index fbb27206c..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_positional_reference_expression.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth,
-                                                     bool root_expression) {
-	auto &ref = expr->Cast<PositionalReferenceExpression>();
-	if (depth != 0) {
-		throw InternalException("Positional reference expression could not be bound");
-	}
-	// replace the positional reference with a column
-	auto column = binder.bind_context.PositionToColumn(ref);
-	expr = std::move(column);
-	return BindExpression(expr, depth, root_expression);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_star_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_star_expression.cpp
deleted file mode 100644
index 179fad7da..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_star_expression.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/planner/expression_binder/table_function_binder.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/regexp.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-namespace duckdb {
-
-string GetColumnsStringValue(ParsedExpression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		return colref.GetColumnName();
-	} else {
-		return expr.ToString();
-	}
-}
-
-bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpression **star, bool is_root,
-                                bool in_columns) {
-	bool has_star = false;
-	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
-		auto &current_star = expr->Cast<StarExpression>();
-		if (StarExpression::IsStar(*expr)) {
-			if (is_root) {
-				D_ASSERT(!in_columns);
-				// At the root level
-				*star = &current_star;
-				return true;
-			}
-
-			if (!in_columns) {
-				// '*' can only appear inside COLUMNS or at the root level
-				throw BinderException(
-				    "STAR expression is only allowed as the root element of an expression. Use COLUMNS(*) instead.");
-			}
-
-			if (!current_star.replace_list.empty()) {
-				// '*' inside COLUMNS can not have a REPLACE list
-				throw BinderException(
-				    "STAR expression with REPLACE list is only allowed as the root element of COLUMNS");
-			}
-			if (!current_star.rename_list.empty()) {
-				// '*' inside COLUMNS can not have a REPLACE list
-				throw BinderException(
-				    "STAR expression with RENAME list is only allowed as the root element of COLUMNS");
-			}
-
-			// '*' expression inside a COLUMNS - convert to a constant list of strings (column names)
-			vector<unique_ptr<ParsedExpression>> star_list;
-			bind_context.GenerateAllColumnExpressions(current_star, star_list);
-
-			vector<Value> values;
-			values.reserve(star_list.size());
-			for (auto &element : star_list) {
-				values.emplace_back(GetColumnsStringValue(*element));
-			}
-			D_ASSERT(!values.empty());
-			expr = make_uniq<ConstantExpression>(Value::LIST(LogicalType::VARCHAR, values));
-			return true;
-		}
-		if (in_columns) {
-			throw BinderException("COLUMNS expression is not allowed inside another COLUMNS expression");
-		}
-		in_columns = true;
-
-		if (*star) {
-			// we can have multiple
-			if (!(*star)->Equals(current_star)) {
-				throw BinderException(*expr,
-				                      "Multiple different STAR/COLUMNS in the same expression are not supported");
-			}
-			return true;
-		}
-		*star = &current_star;
-		has_star = true;
-	}
-	ParsedExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<ParsedExpression> &child_expr) {
-		if (FindStarExpression(child_expr, star, false, in_columns)) {
-			has_star = true;
-		}
-	});
-	return has_star;
-}
-
-void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement) {
-	D_ASSERT(expr);
-	if (StarExpression::IsColumns(*expr) || StarExpression::IsStar(*expr)) {
-		D_ASSERT(replacement);
-		auto alias = expr->GetAlias();
-		expr = replacement->Copy();
-		if (!alias.empty()) {
-			expr->SetAlias(std::move(alias));
-		}
-		return;
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceStarExpression(child_expr, replacement); });
-}
-
-static string ReplaceColumnsAlias(const string &alias, const string &column_name, optional_ptr<duckdb_re2::RE2> regex) {
-	string result;
-	result.reserve(alias.size());
-	for (idx_t c = 0; c < alias.size(); c++) {
-		if (alias[c] == '\\') {
-			c++;
-			if (c >= alias.size()) {
-				throw BinderException("Unterminated backslash in COLUMNS(*) \"%s\" alias. Backslashes must either be "
-				                      "escaped or followed by a number",
-				                      alias);
-			}
-			if (alias[c] == '\\') {
-				result += "\\";
-				continue;
-			}
-			if (alias[c] < '0' || alias[c] > '9') {
-				throw BinderException("Invalid backslash code in COLUMNS(*) \"%s\" alias. Backslashes must either be "
-				                      "escaped or followed by a number",
-				                      alias);
-			}
-			if (alias[c] == '0') {
-				result += column_name;
-			} else if (!regex) {
-				throw BinderException(
-				    "Only the backslash escape code \\0 can be used when no regex is supplied to COLUMNS(*)");
-			} else {
-				string extracted;
-				RE2::Extract(column_name, *regex, "\\" + alias.substr(c, 1), &extracted);
-				result += extracted;
-			}
-		} else {
-			result += alias[c];
-		}
-	}
-	return result;
-}
-
-void TryTransformStarLike(unique_ptr<ParsedExpression> &root) {
-	// detect "* LIKE [literal]" and similar expressions
-	if (root->GetExpressionClass() != ExpressionClass::FUNCTION) {
-		return;
-	}
-	auto &function = root->Cast<FunctionExpression>();
-	if (function.children.size() != 2) {
-		return;
-	}
-	auto &left = function.children[0];
-	// expression must have a star on the LHS, and a literal on the RHS
-	if (left->GetExpressionClass() != ExpressionClass::STAR) {
-		return;
-	}
-	auto &star = left->Cast<StarExpression>();
-	if (star.columns) {
-		// COLUMNS(*) has different semantics
-		return;
-	}
-	unordered_set<string> supported_ops {"~~", "!~~", "~~~", "!~~~", "~~*", "!~~*", "regexp_full_match"};
-	if (supported_ops.count(function.function_name) == 0) {
-		// unsupported op for * expression
-		throw BinderException(*root, "Function \"%s\" cannot be applied to a star expression", function.function_name);
-	}
-	auto &right = function.children[1];
-	if (right->GetExpressionClass() != ExpressionClass::CONSTANT) {
-		throw BinderException(*root, "Pattern applied to a star expression must be a constant");
-	}
-	if (!star.rename_list.empty()) {
-		throw BinderException(*root, "Rename list cannot be combined with a filtering operation");
-	}
-	if (!star.replace_list.empty()) {
-		throw BinderException(*root, "Replace list cannot be combined with a filtering operation");
-	}
-	auto original_alias = root->GetAlias();
-	auto star_expr = std::move(left);
-	unique_ptr<ParsedExpression> child_expr;
-	if (function.function_name == "regexp_full_match" && star.exclude_list.empty()) {
-		// * SIMILAR TO '[regex]' is equivalent to COLUMNS('[regex]') so we can just move the expression directly
-		child_expr = std::move(right);
-	} else {
-		// for other expressions -> generate a columns expression
-		// "* LIKE '%literal%'
-		// -> COLUMNS(list_filter(*, x -> x LIKE '%literal%'))
-		auto lhs = make_uniq<ColumnRefExpression>("__lambda_col");
-		function.children[0] = lhs->Copy();
-
-		auto lambda = make_uniq<LambdaExpression>(std::move(lhs), std::move(root));
-		vector<unique_ptr<ParsedExpression>> filter_children;
-		filter_children.push_back(std::move(star_expr));
-		filter_children.push_back(std::move(lambda));
-		auto list_filter = make_uniq<FunctionExpression>("list_filter", std::move(filter_children));
-		child_expr = std::move(list_filter);
-	}
-
-	auto columns_expr = make_uniq<StarExpression>();
-	columns_expr->columns = true;
-	columns_expr->expr = std::move(child_expr);
-	columns_expr->SetAlias(std::move(original_alias));
-	root = std::move(columns_expr);
-}
-
-optional_ptr<ParsedExpression> Binder::GetResolvedColumnExpression(ParsedExpression &root_expr) {
-	optional_ptr<ParsedExpression> expr = &root_expr;
-	while (expr) {
-		if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-			break;
-		}
-		if (expr->GetExpressionType() == ExpressionType::OPERATOR_COALESCE) {
-			expr = expr->Cast<OperatorExpression>().children[0].get();
-		} else {
-			// unknown expression
-			return nullptr;
-		}
-	}
-	return expr;
-}
-
-void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
-                                  vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	TryTransformStarLike(expr);
-
-	StarExpression *star = nullptr;
-	if (!FindStarExpression(expr, &star, true, false)) {
-		// no star expression: add it as-is
-		D_ASSERT(!star);
-		new_select_list.push_back(std::move(expr));
-		return;
-	}
-	D_ASSERT(star);
-	vector<unique_ptr<ParsedExpression>> star_list;
-	// we have star expressions! expand the list of star expressions
-	bind_context.GenerateAllColumnExpressions(*star, star_list);
-
-	unique_ptr<duckdb_re2::RE2> regex;
-	if (star->expr) {
-		// COLUMNS with an expression
-		// two options:
-		// VARCHAR parameter <- this is a regular expression
-		// LIST of VARCHAR parameters <- this is a set of columns
-		TableFunctionBinder binder(*this, context);
-		auto child = star->expr->Copy();
-		auto result = binder.Bind(child);
-		if (!result->IsFoldable()) {
-			// cannot resolve parameters here
-			if (star->expr->HasParameter()) {
-				throw ParameterNotResolvedException();
-			} else {
-				throw BinderException("Unsupported expression in COLUMNS");
-			}
-		}
-		auto val = ExpressionExecutor::EvaluateScalar(context, *result);
-		if (val.type().id() == LogicalTypeId::VARCHAR) {
-			// regex
-			if (val.IsNull()) {
-				throw BinderException("COLUMNS does not support NULL as regex argument");
-			}
-			auto &regex_str = StringValue::Get(val);
-			regex = make_uniq<duckdb_re2::RE2>(regex_str);
-			if (!regex->error().empty()) {
-				auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex->error());
-				throw BinderException(*star, err);
-			}
-			vector<unique_ptr<ParsedExpression>> new_list;
-			for (idx_t i = 0; i < star_list.size(); i++) {
-				auto child_expr = GetResolvedColumnExpression(*star_list[i]);
-				if (!child_expr) {
-					continue;
-				}
-				auto &colref = child_expr->Cast<ColumnRefExpression>();
-				if (!RE2::PartialMatch(colref.GetColumnName(), *regex)) {
-					continue;
-				}
-				new_list.push_back(std::move(star_list[i]));
-			}
-			if (new_list.empty()) {
-				auto err = StringUtil::Format("No matching columns found that match regex \"%s\"", regex_str);
-				throw BinderException(*star, err);
-			}
-			star_list = std::move(new_list);
-		} else if (val.type().id() == LogicalTypeId::LIST &&
-		           ListType::GetChildType(val.type()).id() == LogicalTypeId::VARCHAR) {
-			// list of varchar columns
-			if (val.IsNull() || ListValue::GetChildren(val).empty()) {
-				auto err =
-				    StringUtil::Format("Star expression \"%s\" resulted in an empty set of columns", star->ToString());
-				throw BinderException(*star, err);
-			}
-			auto &children = ListValue::GetChildren(val);
-			vector<unique_ptr<ParsedExpression>> new_list;
-			// scan the list for all selected columns and construct a lookup table
-			case_insensitive_map_t<bool> selected_set;
-			for (auto &child : children) {
-				if (child.IsNull()) {
-					throw BinderException(*star, "Columns expression does not support NULL input parameters");
-				}
-				selected_set.insert(make_pair(StringValue::Get(child), false));
-			}
-			// now check the list of all possible expressions and select which ones make it in
-			for (auto &expr : star_list) {
-				auto str = GetColumnsStringValue(*expr);
-				auto entry = selected_set.find(str);
-				if (entry != selected_set.end()) {
-					new_list.push_back(std::move(expr));
-					entry->second = true;
-				}
-			}
-			// check if all expressions found a match
-			for (auto &entry : selected_set) {
-				if (!entry.second) {
-					throw BinderException("Column \"%s\" was selected but was not found in the FROM clause",
-					                      entry.first);
-				}
-			}
-			star_list = std::move(new_list);
-		} else {
-			throw BinderException(
-			    *star, "COLUMNS expects either a VARCHAR argument (regex) or a LIST of VARCHAR (list of columns)");
-		}
-	}
-
-	// now perform the replacement
-	if (StarExpression::IsColumnsUnpacked(*star)) {
-		if (StarExpression::IsColumnsUnpacked(*expr)) {
-			throw BinderException("*COLUMNS not allowed at the root level, use COLUMNS instead");
-		}
-		ReplaceUnpackedStarExpression(expr, star_list);
-		new_select_list.push_back(std::move(expr));
-		return;
-	}
-	for (idx_t i = 0; i < star_list.size(); i++) {
-		auto new_expr = expr->Copy();
-		ReplaceStarExpression(new_expr, star_list[i]);
-		if (StarExpression::IsColumns(*star)) {
-			auto expr = GetResolvedColumnExpression(*star_list[i]);
-			if (expr) {
-				auto &colref = expr->Cast<ColumnRefExpression>();
-				if (new_expr->GetAlias().empty()) {
-					new_expr->SetAlias(colref.GetColumnName());
-				} else {
-					new_expr->SetAlias(ReplaceColumnsAlias(new_expr->GetAlias(), colref.GetColumnName(), regex.get()));
-				}
-			}
-		}
-		new_select_list.push_back(std::move(new_expr));
-	}
-}
-
-void Binder::ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
-                                   vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	for (auto &select_element : select_list) {
-		ExpandStarExpression(std::move(select_element), new_select_list);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp
deleted file mode 100644
index 45dc31a33..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-class BoundSubqueryNode : public QueryNode {
-public:
-	static constexpr const QueryNodeType TYPE = QueryNodeType::BOUND_SUBQUERY_NODE;
-
-public:
-	BoundSubqueryNode(shared_ptr<Binder> subquery_binder, unique_ptr<BoundQueryNode> bound_node,
-	                  unique_ptr<SelectStatement> subquery)
-	    : QueryNode(QueryNodeType::BOUND_SUBQUERY_NODE), subquery_binder(std::move(subquery_binder)),
-	      bound_node(std::move(bound_node)), subquery(std::move(subquery)) {
-	}
-
-	shared_ptr<Binder> subquery_binder;
-	unique_ptr<BoundQueryNode> bound_node;
-	unique_ptr<SelectStatement> subquery;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		throw InternalException("Cannot get select list of bound subquery node");
-	}
-
-	string ToString() const override {
-		throw InternalException("Cannot ToString bound subquery node");
-	}
-	unique_ptr<QueryNode> Copy() const override {
-		throw InternalException("Cannot copy bound subquery node");
-	}
-
-	void Serialize(Serializer &serializer) const override {
-		throw InternalException("Cannot serialize bound subquery node");
-	}
-};
-
-bool TypeIsUnnamedStruct(const LogicalType &type) {
-	if (type.id() != LogicalTypeId::STRUCT) {
-		return false;
-	}
-	return StructType::IsUnnamed(type);
-}
-
-void ExtractSubqueryChildren(unique_ptr<Expression> &child, vector<unique_ptr<Expression>> &result,
-                             const vector<LogicalType> &types) {
-	// two scenarios
-	// Single Expression (standard):
-	// x IN (...)
-	// Multi-Expression/Struct:
-	// (a, b) IN (SELECT ...)
-	// the latter has an unnamed struct on the LHS that is created by a "ROW" expression
-	auto &return_type = child->return_type;
-	if (!TypeIsUnnamedStruct(return_type)) {
-		// child is not an unnamed struct
-		return;
-	}
-	if (child->GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
-		// not a function
-		return;
-	}
-	auto &function = child->Cast<BoundFunctionExpression>();
-	if (function.function.name != "row") {
-		// not "ROW"
-		return;
-	}
-	// we found (a, b, ...) - we can extract all children of this function
-	// note that we don't always want to do this
-	if (types.size() == 1 && TypeIsUnnamedStruct(types[0]) && function.children.size() != types.size()) {
-		// old case: we have an unnamed struct INSIDE the subquery as well
-		// i.e. (a, b) IN (SELECT (a, b) ...)
-		// unnesting the struct is guaranteed to throw an error - match the structs against each-other instead
-		return;
-	}
-	for (auto &row_child : function.children) {
-		result.push_back(std::move(row_child));
-	}
-}
-
-BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {
-	if (expr.subquery->node->type != QueryNodeType::BOUND_SUBQUERY_NODE) {
-		// first bind the actual subquery in a new binder
-		auto subquery_binder = Binder::CreateBinder(context, &binder);
-		subquery_binder->can_contain_nulls = true;
-		auto bound_node = subquery_binder->BindNode(*expr.subquery->node);
-		// check the correlated columns of the subquery for correlated columns with depth > 1
-		for (idx_t i = 0; i < subquery_binder->correlated_columns.size(); i++) {
-			CorrelatedColumnInfo corr = subquery_binder->correlated_columns[i];
-			if (corr.depth > 1) {
-				// depth > 1, the column references the query ABOVE the current one
-				// add to the set of correlated columns for THIS query
-				corr.depth -= 1;
-				binder.AddCorrelatedColumn(corr);
-			}
-		}
-		auto prior_subquery = std::move(expr.subquery);
-		expr.subquery = make_uniq<SelectStatement>();
-		expr.subquery->node =
-		    make_uniq<BoundSubqueryNode>(std::move(subquery_binder), std::move(bound_node), std::move(prior_subquery));
-	}
-	// now bind the child node of the subquery
-	if (expr.child) {
-		// first bind the children of the subquery, if any
-		auto error = Bind(expr.child, depth);
-		if (error.HasError()) {
-			return BindResult(std::move(error));
-		}
-	}
-	auto &bound_subquery = expr.subquery->node->Cast<BoundSubqueryNode>();
-	vector<unique_ptr<Expression>> child_expressions;
-	if (expr.subquery_type != SubqueryType::EXISTS) {
-		idx_t expected_columns = 1;
-		if (expr.child) {
-			auto &child = BoundExpression::GetExpression(*expr.child);
-			ExtractSubqueryChildren(child, child_expressions, bound_subquery.bound_node->types);
-			if (child_expressions.empty()) {
-				child_expressions.push_back(std::move(child));
-			}
-			expected_columns = child_expressions.size();
-		}
-		if (bound_subquery.bound_node->types.size() != expected_columns) {
-			throw BinderException(expr, "Subquery returns %zu columns - expected %d",
-			                      bound_subquery.bound_node->types.size(), expected_columns);
-		}
-	}
-	// both binding the child and binding the subquery was successful
-	D_ASSERT(expr.subquery->node->type == QueryNodeType::BOUND_SUBQUERY_NODE);
-	auto subquery_binder = std::move(bound_subquery.subquery_binder);
-	auto bound_node = std::move(bound_subquery.bound_node);
-	LogicalType return_type =
-	    expr.subquery_type == SubqueryType::SCALAR ? bound_node->types[0] : LogicalType(LogicalTypeId::BOOLEAN);
-	if (return_type.id() == LogicalTypeId::UNKNOWN) {
-		return_type = LogicalType::SQLNULL;
-	}
-
-	auto result = make_uniq<BoundSubqueryExpression>(return_type);
-	if (expr.subquery_type == SubqueryType::ANY) {
-		// ANY comparison
-		// cast child and subquery child to equivalent types
-		for (idx_t child_idx = 0; child_idx < child_expressions.size(); child_idx++) {
-			auto &child = child_expressions[child_idx];
-			auto child_type = ExpressionBinder::GetExpressionReturnType(*child);
-			auto &subquery_type = bound_node->types[child_idx];
-			LogicalType compare_type;
-			if (!LogicalType::TryGetMaxLogicalType(context, child_type, subquery_type, compare_type)) {
-				throw BinderException(
-				    expr, "Cannot compare values of type %s and %s in IN/ANY/ALL clause - an explicit cast is required",
-				    child_type.ToString(), subquery_type);
-			}
-			child = BoundCastExpression::AddCastToType(context, std::move(child), compare_type);
-			result->child_types.push_back(subquery_type);
-			result->child_target = compare_type;
-			result->children.push_back(std::move(child));
-		}
-	}
-	result->binder = std::move(subquery_binder);
-	result->subquery = std::move(bound_node);
-	result->subquery_type = expr.subquery_type;
-	result->comparison_type = expr.comparison_type;
-
-	return BindResult(std::move(result));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_unnest_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_unnest_expression.cpp
deleted file mode 100644
index ba9c0715b..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_unnest_expression.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_expanded_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-unique_ptr<Expression> CreateBoundStructExtract(ClientContext &context, unique_ptr<Expression> expr, string key) {
-	vector<unique_ptr<Expression>> arguments;
-	arguments.push_back(std::move(expr));
-	arguments.push_back(make_uniq<BoundConstantExpression>(Value(key)));
-	auto extract_function = GetKeyExtractFunction();
-	auto bind_info = extract_function.bind(context, extract_function, arguments);
-	auto return_type = extract_function.return_type;
-	auto result = make_uniq<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
-	                                                 std::move(bind_info));
-	result->SetAlias(std::move(key));
-	return std::move(result);
-}
-
-unique_ptr<Expression> CreateBoundStructExtractIndex(ClientContext &context, unique_ptr<Expression> expr, idx_t key) {
-	vector<unique_ptr<Expression>> arguments;
-	arguments.push_back(std::move(expr));
-	arguments.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(int64_t(key))));
-	auto extract_function = GetIndexExtractFunction();
-	auto bind_info = extract_function.bind(context, extract_function, arguments);
-	auto return_type = extract_function.return_type;
-	auto result = make_uniq<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
-	                                                 std::move(bind_info));
-	result->SetAlias("element" + to_string(key));
-	return std::move(result);
-}
-
-void SelectBinder::ThrowIfUnnestInLambda(const ColumnBinding &column_binding) {
-	// Extract the unnests and check if any match the column index.
-	for (auto &node_pair : node.unnests) {
-		auto &unnest_node = node_pair.second;
-
-		if (unnest_node.index == column_binding.table_index) {
-			if (column_binding.column_index < unnest_node.expressions.size()) {
-				throw BinderException("UNNEST in lambda expressions is not supported");
-			}
-		}
-	}
-}
-
-BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, bool root_expression) {
-	// bind the children of the function expression
-	if (depth > 0) {
-		return BindResult(BinderException(function, "UNNEST() for correlated expressions is not supported yet"));
-	}
-
-	ErrorData error;
-	if (function.children.empty()) {
-		return BindResult(BinderException(function, "UNNEST() requires a single argument"));
-	}
-	if (inside_window) {
-		return BindResult(BinderException(function, UnsupportedUnnestMessage()));
-	}
-
-	if (function.distinct || function.filter || !function.order_bys->orders.empty()) {
-		throw InvalidInputException("\"DISTINCT\", \"FILTER\", and \"ORDER BY\" are not "
-		                            "applicable to \"UNNEST\"");
-	}
-
-	idx_t max_depth = 1;
-	if (function.children.size() != 1) {
-		bool has_parameter = false;
-		bool supported_argument = false;
-		for (idx_t i = 1; i < function.children.size(); i++) {
-			if (has_parameter) {
-				return BindResult(BinderException(function, "UNNEST() only supports a single additional argument"));
-			}
-			if (function.children[i]->HasParameter()) {
-				throw ParameterNotAllowedException("Parameter not allowed in unnest parameter");
-			}
-			if (!function.children[i]->IsScalar()) {
-				break;
-			}
-			auto alias = StringUtil::Lower(function.children[i]->GetAlias());
-			BindChild(function.children[i], depth, error);
-			if (error.HasError()) {
-				return BindResult(std::move(error));
-			}
-			auto &const_child = BoundExpression::GetExpression(*function.children[i]);
-			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child, true);
-			if (alias == "recursive") {
-				auto recursive = value.GetValue<bool>();
-				if (recursive) {
-					max_depth = NumericLimits<idx_t>::Maximum();
-				}
-			} else if (alias == "max_depth") {
-				max_depth = value.GetValue<uint32_t>();
-				if (max_depth == 0) {
-					throw BinderException("UNNEST cannot have a max depth of 0");
-				}
-			} else if (!alias.empty()) {
-				throw BinderException("Unsupported parameter \"%s\" for unnest", alias);
-			} else {
-				break;
-			}
-			has_parameter = true;
-			supported_argument = true;
-		}
-		if (!supported_argument) {
-			return BindResult(BinderException(function, "UNNEST - unsupported extra argument, unnest only supports "
-			                                            "recursive := [true/false] or max_depth := #"));
-		}
-	}
-	unnest_level++;
-	BindChild(function.children[0], depth, error);
-	if (error.HasError()) {
-		// failed to bind
-		// try to bind correlated columns manually
-		auto result = BindCorrelatedColumns(function.children[0], error);
-		if (result.HasError()) {
-			return BindResult(result.error);
-		}
-		auto &bound_expr = BoundExpression::GetExpression(*function.children[0]);
-		ExtractCorrelatedExpressions(binder, *bound_expr);
-	}
-	auto &child = BoundExpression::GetExpression(*function.children[0]);
-	auto &child_type = child->return_type;
-	unnest_level--;
-
-	if (unnest_level > 0) {
-		throw BinderException(
-		    function,
-		    "Nested UNNEST calls are not supported - use UNNEST(x, recursive := true) to unnest multiple levels");
-	}
-
-	switch (child_type.id()) {
-	case LogicalTypeId::UNKNOWN:
-		throw ParameterNotResolvedException();
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::SQLNULL:
-		break;
-	default:
-		return BindResult(BinderException(function, "UNNEST() can only be applied to lists, structs and NULL"));
-	}
-
-	idx_t list_unnests;
-	idx_t struct_unnests = 0;
-
-	auto unnest_expr = std::move(child);
-	if (child_type.id() == LogicalTypeId::SQLNULL) {
-		list_unnests = 1;
-	} else {
-		// perform all LIST unnests
-		auto type = child_type;
-		list_unnests = 0;
-		while (type.id() == LogicalTypeId::LIST) {
-			type = ListType::GetChildType(type);
-			list_unnests++;
-			if (list_unnests >= max_depth) {
-				break;
-			}
-		}
-		// unnest structs
-		if (type.id() == LogicalTypeId::STRUCT) {
-			struct_unnests = max_depth - list_unnests;
-		}
-	}
-	if (struct_unnests > 0 && !root_expression) {
-		child = std::move(unnest_expr);
-		return BindResult(BinderException(
-		    function, "UNNEST() on a struct column can only be applied as the root element of a SELECT expression"));
-	}
-	// perform all LIST unnests
-	auto return_type = child_type;
-	for (idx_t current_depth = 0; current_depth < list_unnests; current_depth++) {
-		if (return_type.id() == LogicalTypeId::LIST) {
-			return_type = ListType::GetChildType(return_type);
-		}
-		auto result = make_uniq<BoundUnnestExpression>(return_type);
-		result->child = std::move(unnest_expr);
-		auto alias = function.GetAlias().empty() ? result->ToString() : function.GetAlias();
-
-		auto current_level = unnest_level + list_unnests - current_depth - 1;
-		auto entry = node.unnests.find(current_level);
-		idx_t unnest_table_index;
-		idx_t unnest_column_index;
-		if (entry == node.unnests.end()) {
-			BoundUnnestNode unnest_node;
-			unnest_node.index = binder.GenerateTableIndex();
-			unnest_node.expressions.push_back(std::move(result));
-			unnest_table_index = unnest_node.index;
-			unnest_column_index = 0;
-			node.unnests.insert(make_pair(current_level, std::move(unnest_node)));
-		} else {
-			unnest_table_index = entry->second.index;
-			unnest_column_index = entry->second.expressions.size();
-			entry->second.expressions.push_back(std::move(result));
-		}
-		// now create a column reference referring to the unnest
-		unnest_expr = make_uniq<BoundColumnRefExpression>(
-		    std::move(alias), return_type, ColumnBinding(unnest_table_index, unnest_column_index), depth);
-	}
-	// now perform struct unnests, if any
-	if (struct_unnests > 0) {
-		vector<unique_ptr<Expression>> struct_expressions;
-		struct_expressions.push_back(std::move(unnest_expr));
-
-		for (idx_t i = 0; i < struct_unnests; i++) {
-			vector<unique_ptr<Expression>> new_expressions;
-			// check if there are any structs left
-			bool has_structs = false;
-			for (auto &expr : struct_expressions) {
-				if (expr->return_type.id() == LogicalTypeId::STRUCT) {
-					// struct! push a struct_extract
-					auto &child_types = StructType::GetChildTypes(expr->return_type);
-					if (StructType::IsUnnamed(expr->return_type)) {
-						for (idx_t child_index = 0; child_index < child_types.size(); child_index++) {
-							new_expressions.push_back(
-							    CreateBoundStructExtractIndex(context, expr->Copy(), child_index + 1));
-						}
-					} else {
-						for (auto &entry : child_types) {
-							new_expressions.push_back(CreateBoundStructExtract(context, expr->Copy(), entry.first));
-						}
-					}
-					has_structs = true;
-				} else {
-					// not a struct - push as-is
-					new_expressions.push_back(std::move(expr));
-				}
-			}
-			struct_expressions = std::move(new_expressions);
-			if (!has_structs) {
-				break;
-			}
-		}
-		unnest_expr = make_uniq<BoundExpandedExpression>(std::move(struct_expressions));
-	}
-	return BindResult(std::move(unnest_expr));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_unpacked_star_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_unpacked_star_expression.cpp
deleted file mode 100644
index 24e708129..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_unpacked_star_expression.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-namespace duckdb {
-
-using expression_list_t = vector<unique_ptr<ParsedExpression>>;
-
-static void AddChild(unique_ptr<ParsedExpression> &child, expression_list_t &new_children,
-                     expression_list_t &replacements) {
-	if (!StarExpression::IsColumnsUnpacked(*child)) {
-		// Just add the child directly
-		new_children.push_back(std::move(child));
-		return;
-	}
-	// Replace the child with the replacement expression(s)
-	for (auto &replacement : replacements) {
-		new_children.push_back(replacement->Copy());
-	}
-}
-
-static void ReplaceInFunction(unique_ptr<ParsedExpression> &expr, expression_list_t &star_list) {
-	auto &function_expr = expr->Cast<FunctionExpression>();
-
-	// Replace children
-	expression_list_t new_children;
-	for (auto &child : function_expr.children) {
-		AddChild(child, new_children, star_list);
-	}
-	function_expr.children = std::move(new_children);
-
-	// Replace ORDER_BY
-	if (function_expr.order_bys) {
-		expression_list_t new_orders;
-		for (auto &order : function_expr.order_bys->orders) {
-			AddChild(order.expression, new_orders, star_list);
-		}
-		if (new_orders.size() != function_expr.order_bys->orders.size()) {
-			throw NotImplementedException("*COLUMNS(...) is not supported in the order expression");
-		}
-		for (idx_t i = 0; i < new_orders.size(); i++) {
-			auto &new_order = new_orders[i];
-			function_expr.order_bys->orders[i].expression = std::move(new_order);
-		}
-	}
-}
-
-static void ReplaceInOperator(unique_ptr<ParsedExpression> &expr, expression_list_t &star_list) {
-	auto &operator_expr = expr->Cast<OperatorExpression>();
-
-	// Replace children
-	expression_list_t new_children;
-	for (auto &child : operator_expr.children) {
-		AddChild(child, new_children, star_list);
-	}
-	operator_expr.children = std::move(new_children);
-}
-
-void Binder::ReplaceUnpackedStarExpression(unique_ptr<ParsedExpression> &expr, expression_list_t &star_list) {
-	D_ASSERT(expr);
-	auto expression_class = expr->GetExpressionClass();
-	// Replace *COLUMNS(...) in the supported places
-	switch (expression_class) {
-	case ExpressionClass::STAR: {
-		if (!StarExpression::IsColumnsUnpacked(*expr)) {
-			break;
-		}
-		// Deal with any *COLUMNS that was not replaced
-		throw BinderException("*COLUMNS() can not be used in this place");
-	}
-	case ExpressionClass::FUNCTION: {
-		ReplaceInFunction(expr, star_list);
-		break;
-	}
-	case ExpressionClass::OPERATOR: {
-		ReplaceInOperator(expr, star_list);
-		break;
-	}
-	default: {
-		break;
-	}
-	}
-
-	// Visit the children of this expression, collecting the unpacked expressions
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceUnpackedStarExpression(child_expr, star_list); });
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp
deleted file mode 100644
index 72a6c4be2..000000000
--- a/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp
+++ /dev/null
@@ -1,393 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/function/scalar_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-static LogicalType ResolveWindowExpressionType(ExpressionType window_type, const vector<LogicalType> &child_types) {
-
-	idx_t param_count;
-	switch (window_type) {
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_CUME_DIST:
-		param_count = 0;
-		break;
-	case ExpressionType::WINDOW_NTILE:
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-		param_count = 1;
-		break;
-	case ExpressionType::WINDOW_NTH_VALUE:
-		param_count = 2;
-		break;
-	default:
-		throw InternalException("Unrecognized window expression type " + ExpressionTypeToString(window_type));
-	}
-	if (child_types.size() != param_count) {
-		throw BinderException("%s needs %d parameter%s, got %d", ExpressionTypeToString(window_type), param_count,
-		                      param_count == 1 ? "" : "s", child_types.size());
-	}
-	switch (window_type) {
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_CUME_DIST:
-		return LogicalType(LogicalTypeId::DOUBLE);
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_NTILE:
-		return LogicalType::BIGINT;
-	case ExpressionType::WINDOW_NTH_VALUE:
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-		return child_types[0];
-	default:
-		throw InternalException("Unrecognized window expression type " + ExpressionTypeToString(window_type));
-	}
-}
-
-static unique_ptr<Expression> GetExpression(unique_ptr<ParsedExpression> &expr) {
-	if (!expr) {
-		return nullptr;
-	}
-	D_ASSERT(expr.get());
-	D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-	return std::move(BoundExpression::GetExpression(*expr));
-}
-
-static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression> &expr, const LogicalType &type) {
-	if (!expr) {
-		return nullptr;
-	}
-	D_ASSERT(expr.get());
-	D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-
-	auto &bound = BoundExpression::GetExpression(*expr);
-	bound = BoundCastExpression::AddDefaultCastToType(std::move(bound), type);
-
-	return std::move(bound);
-}
-
-static bool IsRangeType(const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-	case PhysicalType::INTERVAL:
-		return true;
-	default:
-		return false;
-	}
-}
-
-static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr<ParsedExpression> &expr,
-                                       unique_ptr<ParsedExpression> &order_expr) {
-
-	vector<unique_ptr<Expression>> children;
-
-	D_ASSERT(order_expr.get());
-	D_ASSERT(order_expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound_order = BoundExpression::GetExpression(*order_expr);
-	children.emplace_back(bound_order->Copy());
-
-	D_ASSERT(expr.get());
-	D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = BoundExpression::GetExpression(*expr);
-	QueryErrorContext error_context(bound->GetQueryLocation());
-	if (bound->return_type == LogicalType::SQLNULL) {
-		throw BinderException(error_context, "Window RANGE expressions cannot be NULL");
-	}
-	children.emplace_back(std::move(bound));
-
-	ErrorData error;
-	FunctionBinder function_binder(context);
-	auto function = function_binder.BindScalarFunction(DEFAULT_SCHEMA, name, std::move(children), error, true);
-	if (!function) {
-		error.Throw();
-	}
-	// +/- can be applied to non-scalar types,
-	// so we can't rely on function binding to catch all problems.
-	if (!IsRangeType(function->return_type)) {
-		throw BinderException(error_context, "Invalid type for Window RANGE expression");
-	}
-	bound = std::move(function);
-	return bound->return_type;
-}
-
-BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
-	QueryErrorContext error_context(window.GetQueryLocation());
-	//	Check for macros pretending to be aggregates
-	auto entry = GetCatalogEntry(CatalogType::SCALAR_FUNCTION_ENTRY, window.catalog, window.schema,
-	                             window.function_name, OnEntryNotFound::RETURN_NULL, error_context);
-	if (window.GetExpressionType() == ExpressionType::WINDOW_AGGREGATE && entry &&
-	    entry->type == CatalogType::MACRO_ENTRY) {
-		auto macro = make_uniq<FunctionExpression>(window.catalog, window.schema, window.function_name,
-		                                           std::move(window.children), std::move(window.filter_expr), nullptr,
-		                                           window.distinct);
-		auto macro_expr = window.Copy();
-		return BindMacro(*macro, entry->Cast<ScalarMacroCatalogEntry>(), depth, macro_expr);
-	}
-
-	auto name = window.alias;
-
-	if (inside_window) {
-		throw BinderException(error_context, "window function calls cannot be nested");
-	}
-	if (depth > 0) {
-		throw BinderException(error_context, "correlated columns in window functions not supported");
-	}
-
-	// If we have range expressions, then only one order by clause is allowed.
-	const auto is_range =
-	    (window.start == WindowBoundary::EXPR_PRECEDING_RANGE || window.start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
-	     window.end == WindowBoundary::EXPR_PRECEDING_RANGE || window.end == WindowBoundary::EXPR_FOLLOWING_RANGE);
-	if (is_range && window.orders.size() != 1) {
-		throw BinderException(error_context, "RANGE frames must have only one ORDER BY expression");
-	}
-	// bind inside the children of the window function
-	// we set the inside_window flag to true to prevent binding nested window functions
-	inside_window = true;
-	ErrorData error;
-	for (auto &child : window.children) {
-		BindChild(child, depth, error);
-	}
-	for (auto &child : window.partitions) {
-		BindChild(child, depth, error);
-	}
-	for (auto &order : window.orders) {
-		BindChild(order.expression, depth, error);
-
-		//	If the frame is a RANGE frame and the type is a time,
-		//	then we have to convert the time to a timestamp to avoid wrapping.
-		if (!is_range || error.HasError()) {
-			continue;
-		}
-		auto &order_expr = order.expression;
-		auto &bound_order = BoundExpression::GetExpression(*order_expr);
-		const auto type_id = bound_order->return_type.id();
-		if (type_id == LogicalTypeId::TIME || type_id == LogicalTypeId::TIME_TZ) {
-			//	Convert to time + epoch and rebind
-			unique_ptr<ParsedExpression> epoch = make_uniq<ConstantExpression>(Value::DATE(date_t::epoch()));
-			BindChild(epoch, depth, error);
-			BindRangeExpression(context, "+", order.expression, epoch);
-		}
-	}
-	BindChild(window.filter_expr, depth, error);
-	BindChild(window.start_expr, depth, error);
-	BindChild(window.end_expr, depth, error);
-	BindChild(window.offset_expr, depth, error);
-	BindChild(window.default_expr, depth, error);
-
-	for (auto &order : window.arg_orders) {
-		BindChild(order.expression, depth, error);
-	}
-
-	inside_window = false;
-	if (error.HasError()) {
-		// failed to bind children of window function
-		return BindResult(std::move(error));
-	}
-
-	//	Restore any collation expressions
-	for (auto &order : window.arg_orders) {
-		auto &order_expr = order.expression;
-		auto &bound_order = BoundExpression::GetExpression(*order_expr);
-		ExpressionBinder::PushCollation(context, bound_order, bound_order->return_type);
-	}
-	for (auto &part_expr : window.partitions) {
-		auto &bound_partition = BoundExpression::GetExpression(*part_expr);
-		ExpressionBinder::PushCollation(context, bound_partition, bound_partition->return_type);
-	}
-	for (auto &order : window.orders) {
-		auto &order_expr = order.expression;
-		auto &bound_order = BoundExpression::GetExpression(*order_expr);
-		ExpressionBinder::PushCollation(context, bound_order, bound_order->return_type);
-	}
-	// successfully bound all children: create bound window function
-	vector<LogicalType> types;
-	vector<unique_ptr<Expression>> children;
-	for (auto &child : window.children) {
-		D_ASSERT(child.get());
-		D_ASSERT(child->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound = BoundExpression::GetExpression(*child);
-		// Add casts for positional arguments
-		const auto argno = children.size();
-		switch (window.GetExpressionType()) {
-		case ExpressionType::WINDOW_NTILE:
-			// ntile(bigint)
-			if (argno == 0) {
-				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
-			}
-			break;
-		case ExpressionType::WINDOW_NTH_VALUE:
-			// nth_value(<expr>, index)
-			if (argno == 1) {
-				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
-			}
-			break;
-		default:
-			break;
-		}
-		types.push_back(bound->return_type);
-		children.push_back(std::move(bound));
-	}
-	//  Determine the function type.
-	LogicalType sql_type;
-	unique_ptr<AggregateFunction> aggregate;
-	unique_ptr<FunctionData> bind_info;
-	if (window.GetExpressionType() == ExpressionType::WINDOW_AGGREGATE) {
-		//  Look up the aggregate function in the catalog
-		if (!entry || entry->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-			//	Not an aggregate: Look it up to generate error
-			Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
-			                                                 window.function_name, error_context);
-		}
-		auto &func = entry->Cast<AggregateFunctionCatalogEntry>();
-		D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-
-		// bind the aggregate
-		ErrorData error_aggr;
-		FunctionBinder function_binder(context);
-		auto best_function = function_binder.BindFunction(func.name, func.functions, types, error_aggr);
-		if (!best_function.IsValid()) {
-			error_aggr.AddQueryLocation(window);
-			error_aggr.Throw();
-		}
-
-		// found a matching function! bind it as an aggregate
-		auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
-		auto window_bound_aggregate = function_binder.BindAggregateFunction(bound_function, std::move(children));
-		// create the aggregate
-		aggregate = make_uniq<AggregateFunction>(window_bound_aggregate->function);
-		bind_info = std::move(window_bound_aggregate->bind_info);
-		children = std::move(window_bound_aggregate->children);
-		sql_type = window_bound_aggregate->return_type;
-
-	} else {
-		// fetch the child of the non-aggregate window function (if any)
-		sql_type = ResolveWindowExpressionType(window.GetExpressionType(), types);
-	}
-	auto result = make_uniq<BoundWindowExpression>(window.GetExpressionType(), sql_type, std::move(aggregate),
-	                                               std::move(bind_info));
-	result->children = std::move(children);
-	for (auto &child : window.partitions) {
-		result->partitions.push_back(GetExpression(child));
-	}
-	result->ignore_nulls = window.ignore_nulls;
-	result->distinct = window.distinct;
-
-	// Convert RANGE boundary expressions to ORDER +/- expressions.
-	// Note that PRECEEDING and FOLLOWING refer to the sequential order in the frame,
-	// not the natural ordering of the type. This means that the offset arithmetic must be reversed
-	// for ORDER BY DESC.
-	auto &config = DBConfig::GetConfig(context);
-	auto range_sense = OrderType::INVALID;
-	LogicalType start_type = LogicalType::BIGINT;
-	if (window.start == WindowBoundary::EXPR_PRECEDING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
-		const auto range_name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
-		start_type = BindRangeExpression(context, range_name, window.start_expr, window.orders[0].expression);
-
-	} else if (window.start == WindowBoundary::EXPR_FOLLOWING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
-		const auto range_name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
-		start_type = BindRangeExpression(context, range_name, window.start_expr, window.orders[0].expression);
-	}
-
-	LogicalType end_type = LogicalType::BIGINT;
-	if (window.end == WindowBoundary::EXPR_PRECEDING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
-		const auto range_name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
-		end_type = BindRangeExpression(context, range_name, window.end_expr, window.orders[0].expression);
-
-	} else if (window.end == WindowBoundary::EXPR_FOLLOWING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
-		const auto range_name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
-		end_type = BindRangeExpression(context, range_name, window.end_expr, window.orders[0].expression);
-	}
-
-	// Cast ORDER and boundary expressions to the same type
-	if (range_sense != OrderType::INVALID) {
-		D_ASSERT(window.orders.size() == 1);
-
-		auto &order_expr = window.orders[0].expression;
-		D_ASSERT(order_expr.get());
-		D_ASSERT(order_expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound_order = BoundExpression::GetExpression(*order_expr);
-		auto order_type = bound_order->return_type;
-		if (window.start_expr) {
-			order_type = LogicalType::MaxLogicalType(context, order_type, start_type);
-		}
-		if (window.end_expr) {
-			order_type = LogicalType::MaxLogicalType(context, order_type, end_type);
-		}
-
-		// Cast all three to match
-		bound_order = BoundCastExpression::AddCastToType(context, std::move(bound_order), order_type);
-		start_type = end_type = order_type;
-	}
-
-	for (auto &order : window.orders) {
-		auto type = config.ResolveOrder(order.type);
-		auto null_order = config.ResolveNullOrder(type, order.null_order);
-		auto expression = GetExpression(order.expression);
-		result->orders.emplace_back(type, null_order, std::move(expression));
-	}
-
-	// Argument orders are just like arguments, not frames
-	for (auto &order : window.arg_orders) {
-		auto type = config.ResolveOrder(order.type);
-		auto null_order = config.ResolveNullOrder(type, order.null_order);
-		auto expression = GetExpression(order.expression);
-		result->arg_orders.emplace_back(type, null_order, std::move(expression));
-	}
-
-	result->filter_expr = CastWindowExpression(window.filter_expr, LogicalType::BOOLEAN);
-	result->start_expr = CastWindowExpression(window.start_expr, start_type);
-	result->end_expr = CastWindowExpression(window.end_expr, end_type);
-	result->offset_expr = CastWindowExpression(window.offset_expr, LogicalType::BIGINT);
-	result->default_expr = CastWindowExpression(window.default_expr, result->return_type);
-	result->start = window.start;
-	result->end = window.end;
-	result->exclude_clause = window.exclude_clause;
-
-	// create a BoundColumnRef that references this entry
-	auto colref = make_uniq<BoundColumnRefExpression>(std::move(name), result->return_type,
-	                                                  ColumnBinding(node.window_index, node.windows.size()), depth);
-	// move the WINDOW expression into the set of bound windows
-	node.windows.push_back(std::move(result));
-	return BindResult(std::move(colref));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/bind_cte_node.cpp b/src/duckdb/src/planner/binder/query_node/bind_cte_node.cpp
deleted file mode 100644
index cd61b03e8..000000000
--- a/src/duckdb/src/planner/binder/query_node/bind_cte_node.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/query_node/bound_cte_node.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundQueryNode> Binder::BindNode(CTENode &statement) {
-	// first recursively visit the materialized CTE operations
-	// the left side is visited first and is added to the BindContext of the right side
-	D_ASSERT(statement.query);
-
-	return BindCTE(statement);
-}
-
-unique_ptr<BoundCTENode> Binder::BindCTE(CTENode &statement) {
-	auto result = make_uniq<BoundCTENode>();
-
-	// first recursively visit the materialized CTE operations
-	// the left side is visited first and is added to the BindContext of the right side
-	D_ASSERT(statement.query);
-
-	result->ctename = statement.ctename;
-	result->setop_index = GenerateTableIndex();
-
-	result->query_binder = Binder::CreateBinder(context, this);
-	result->query = result->query_binder->BindNode(*statement.query);
-
-	// the result types of the CTE are the types of the LHS
-	result->types = result->query->types;
-	// names are picked from the LHS, unless aliases are explicitly specified
-	result->names = result->query->names;
-	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
-		result->names[i] = statement.aliases[i];
-	}
-
-	// Rename columns if duplicate names are detected
-	idx_t index = 1;
-	vector<string> names;
-	for (auto &n : result->names) {
-		string name = n;
-		while (find(names.begin(), names.end(), name) != names.end()) {
-			name = n + "_" + std::to_string(index++);
-		}
-		names.push_back(name);
-	}
-
-	// This allows the right side to reference the CTE
-	bind_context.AddGenericBinding(result->setop_index, statement.ctename, names, result->types);
-
-	result->child_binder = Binder::CreateBinder(context, this);
-
-	// Add bindings of left side to temporary CTE bindings context
-	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, names, result->types);
-
-	if (statement.child) {
-		// Move all modifiers to the child node.
-		for (auto &modifier : statement.modifiers) {
-			statement.child->modifiers.push_back(std::move(modifier));
-		}
-
-		statement.modifiers.clear();
-
-		result->child = result->child_binder->BindNode(*statement.child);
-		for (auto &c : result->query_binder->correlated_columns) {
-			result->child_binder->AddCorrelatedColumn(c);
-		}
-
-		// the result types of the CTE are the types of the LHS
-		result->types = result->child->types;
-		result->names = result->child->names;
-
-		MoveCorrelatedExpressions(*result->child_binder);
-	}
-
-	MoveCorrelatedExpressions(*result->query_binder);
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/bind_recursive_cte_node.cpp b/src/duckdb/src/planner/binder/query_node/bind_recursive_cte_node.cpp
deleted file mode 100644
index 1c5e34261..000000000
--- a/src/duckdb/src/planner/binder/query_node/bind_recursive_cte_node.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/query_node/bound_recursive_cte_node.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundQueryNode> Binder::BindNode(RecursiveCTENode &statement) {
-	auto result = make_uniq<BoundRecursiveCTENode>();
-
-	// first recursively visit the recursive CTE operations
-	// the left side is visited first and is added to the BindContext of the right side
-	D_ASSERT(statement.left);
-	D_ASSERT(statement.right);
-
-	result->ctename = statement.ctename;
-	result->union_all = statement.union_all;
-	result->setop_index = GenerateTableIndex();
-
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->left = result->left_binder->BindNode(*statement.left);
-
-	// the result types of the CTE are the types of the LHS
-	result->types = result->left->types;
-	// names are picked from the LHS, unless aliases are explicitly specified
-	result->names = result->left->names;
-	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
-		result->names[i] = statement.aliases[i];
-	}
-
-	// This allows the right side to reference the CTE recursively
-	bind_context.AddGenericBinding(result->setop_index, statement.ctename, result->names, result->types);
-
-	result->right_binder = Binder::CreateBinder(context, this);
-
-	// Add bindings of left side to temporary CTE bindings context
-	result->right_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
-	                                                 result->types);
-	result->right = result->right_binder->BindNode(*statement.right);
-	for (auto &c : result->left_binder->correlated_columns) {
-		result->right_binder->AddCorrelatedColumn(c);
-	}
-
-	// move the correlated expressions from the child binders to this binder
-	MoveCorrelatedExpressions(*result->left_binder);
-	MoveCorrelatedExpressions(*result->right_binder);
-
-	// now both sides have been bound we can resolve types
-	if (result->left->types.size() != result->right->types.size()) {
-		throw BinderException("Set operations can only apply to expressions with the "
-		                      "same number of result columns");
-	}
-
-	if (!statement.modifiers.empty()) {
-		throw NotImplementedException("FIXME: bind modifiers in recursive CTE");
-	}
-
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp b/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp
deleted file mode 100644
index 126ae001f..000000000
--- a/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp
+++ /dev/null
@@ -1,684 +0,0 @@
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_expanded_expression.hpp"
-#include "duckdb/planner/expression_binder/column_alias_binder.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/planner/expression_binder/group_binder.hpp"
-#include "duckdb/planner/expression_binder/having_binder.hpp"
-#include "duckdb/planner/expression_binder/order_binder.hpp"
-#include "duckdb/planner/expression_binder/qualify_binder.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr) {
-	// we treat the distinct list as an ORDER BY
-	auto bound_expr = order_binder.Bind(std::move(expr));
-	if (!bound_expr) {
-		// DISTINCT ON non-integer constant
-		// remove the expression from the DISTINCT ON list
-		return nullptr;
-	}
-	D_ASSERT(bound_expr->GetExpressionType() == ExpressionType::VALUE_CONSTANT);
-	return bound_expr;
-}
-
-BoundLimitNode Binder::BindLimitValue(OrderBinder &order_binder, unique_ptr<ParsedExpression> limit_val,
-                                      bool is_percentage, bool is_offset) {
-	auto new_binder = Binder::CreateBinder(context, this);
-	ExpressionBinder expr_binder(*new_binder, context);
-	auto target_type = is_percentage ? LogicalType::DOUBLE : LogicalType::BIGINT;
-	expr_binder.target_type = target_type;
-	auto original_limit = limit_val->Copy();
-	auto expr = expr_binder.Bind(limit_val);
-	if (expr->HasSubquery()) {
-		if (!order_binder.HasExtraList()) {
-			throw BinderException("Subquery in LIMIT/OFFSET not supported in set operation");
-		}
-		auto bound_limit = order_binder.CreateExtraReference(std::move(original_limit));
-		if (is_percentage) {
-			return BoundLimitNode::ExpressionPercentage(std::move(bound_limit));
-		} else {
-			return BoundLimitNode::ExpressionValue(std::move(bound_limit));
-		}
-	}
-	if (expr->IsFoldable()) {
-		//! this is a constant
-		auto val = ExpressionExecutor::EvaluateScalar(context, *expr).CastAs(context, target_type);
-		if (is_percentage) {
-			D_ASSERT(!is_offset);
-			double percentage_val;
-			if (val.IsNull()) {
-				percentage_val = 100.0;
-			} else {
-				percentage_val = val.GetValue<double>();
-			}
-			if (Value::IsNan(percentage_val) || percentage_val < 0 || percentage_val > 100) {
-				throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%");
-			}
-			return BoundLimitNode::ConstantPercentage(percentage_val);
-		} else {
-			int64_t constant_val;
-			if (val.IsNull()) {
-				constant_val = is_offset ? 0 : NumericLimits<int64_t>::Maximum();
-			} else {
-				constant_val = val.GetValue<int64_t>();
-			}
-			if (constant_val < 0) {
-				throw BinderException(expr->GetQueryLocation(), "LIMIT/OFFSET cannot be negative");
-			}
-			return BoundLimitNode::ConstantValue(constant_val);
-		}
-	}
-	if (!new_binder->correlated_columns.empty()) {
-		throw BinderException("Correlated columns not supported in LIMIT/OFFSET");
-	}
-	// move any correlated columns to this binder
-	MoveCorrelatedExpressions(*new_binder);
-	if (is_percentage) {
-		return BoundLimitNode::ExpressionPercentage(std::move(expr));
-	} else {
-		return BoundLimitNode::ExpressionValue(std::move(expr));
-	}
-}
-
-duckdb::unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) {
-	auto result = make_uniq<BoundLimitModifier>();
-	if (limit_mod.limit) {
-		result->limit_val = BindLimitValue(order_binder, std::move(limit_mod.limit), false, false);
-	}
-	if (limit_mod.offset) {
-		result->offset_val = BindLimitValue(order_binder, std::move(limit_mod.offset), false, true);
-	}
-	return std::move(result);
-}
-
-unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) {
-	auto result = make_uniq<BoundLimitModifier>();
-	if (limit_mod.limit) {
-		result->limit_val = BindLimitValue(order_binder, std::move(limit_mod.limit), true, false);
-	}
-	if (limit_mod.offset) {
-		result->offset_val = BindLimitValue(order_binder, std::move(limit_mod.offset), false, true);
-	}
-	return std::move(result);
-}
-
-void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result) {
-	for (auto &mod : statement.modifiers) {
-		unique_ptr<BoundResultModifier> bound_modifier;
-		switch (mod->type) {
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = mod->Cast<DistinctModifier>();
-			auto bound_distinct = make_uniq<BoundDistinctModifier>();
-			bound_distinct->distinct_type =
-			    distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON;
-			if (distinct.distinct_on_targets.empty()) {
-				for (idx_t i = 0; i < result.names.size(); i++) {
-					distinct.distinct_on_targets.push_back(
-					    make_uniq<ConstantExpression>(Value::INTEGER(UnsafeNumericCast<int32_t>(1 + i))));
-				}
-			}
-			order_binder.SetQueryComponent("DISTINCT ON");
-			for (auto &distinct_on_target : distinct.distinct_on_targets) {
-				auto expr = BindOrderExpression(order_binder, std::move(distinct_on_target));
-				if (!expr) {
-					continue;
-				}
-				bound_distinct->target_distincts.push_back(std::move(expr));
-			}
-			order_binder.SetQueryComponent();
-
-			bound_modifier = std::move(bound_distinct);
-			break;
-		}
-		case ResultModifierType::ORDER_MODIFIER: {
-
-			auto &order = mod->Cast<OrderModifier>();
-			auto bound_order = make_uniq<BoundOrderModifier>();
-			auto &config = DBConfig::GetConfig(context);
-			D_ASSERT(!order.orders.empty());
-			auto &order_binders = order_binder.GetBinders();
-			if (order.orders.size() == 1 && order.orders[0].expression->GetExpressionType() == ExpressionType::STAR) {
-				auto &star = order.orders[0].expression->Cast<StarExpression>();
-				if (star.exclude_list.empty() && star.replace_list.empty() && !star.expr) {
-					// ORDER BY ALL
-					// replace the order list with the all elements in the SELECT list
-					auto order_type = config.ResolveOrder(order.orders[0].type);
-					auto null_order = config.ResolveNullOrder(order_type, order.orders[0].null_order);
-					auto constant_expr = make_uniq<BoundConstantExpression>(Value("ALL"));
-					bound_order->orders.emplace_back(order_type, null_order, std::move(constant_expr));
-					bound_modifier = std::move(bound_order);
-					break;
-				}
-			}
-#if 0
-			// When this verification is enabled, replace ORDER BY x, y with ORDER BY create_sort_key(x, y)
-			// note that we don't enable this during actual verification since it doesn't always work
-			// e.g. it breaks EXPLAIN output on queries
-			bool can_replace = true;
-			for (auto &order_node : order.orders) {
-				if (order_node.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-					// we cannot replace the sort key when we order by literals (e.g. ORDER BY 1, 2`
-					can_replace = false;
-					break;
-				}
-			}
-			if (!order_binder.HasExtraList()) {
-				// we can only do the replacement when we can order by elements that are not in the selection list
-				can_replace = false;
-			}
-			if (can_replace) {
-				vector<unique_ptr<ParsedExpression>> sort_key_parameters;
-				for (auto &order_node : order.orders) {
-					sort_key_parameters.push_back(std::move(order_node.expression));
-					auto type = config.ResolveOrder(order_node.type);
-					auto null_order = config.ResolveNullOrder(type, order_node.null_order);
-					string sort_param = EnumUtil::ToString(type) + " " + EnumUtil::ToString(null_order);
-					sort_key_parameters.push_back(make_uniq<ConstantExpression>(Value(sort_param)));
-				}
-				order.orders.clear();
-				auto create_sort_key = make_uniq<FunctionExpression>("create_sort_key", std::move(sort_key_parameters));
-				order.orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(create_sort_key));
-			}
-#endif
-			for (auto &order_node : order.orders) {
-				vector<unique_ptr<ParsedExpression>> order_list;
-				order_binders[0].get().ExpandStarExpression(std::move(order_node.expression), order_list);
-
-				auto type = config.ResolveOrder(order_node.type);
-				auto null_order = config.ResolveNullOrder(type, order_node.null_order);
-				for (auto &order_expr : order_list) {
-					auto bound_expr = BindOrderExpression(order_binder, std::move(order_expr));
-					if (!bound_expr) {
-						continue;
-					}
-					bound_order->orders.emplace_back(type, null_order, std::move(bound_expr));
-				}
-			}
-			if (!bound_order->orders.empty()) {
-				bound_modifier = std::move(bound_order);
-			}
-			break;
-		}
-		case ResultModifierType::LIMIT_MODIFIER:
-			bound_modifier = BindLimit(order_binder, mod->Cast<LimitModifier>());
-			break;
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-			bound_modifier = BindLimitPercent(order_binder, mod->Cast<LimitPercentModifier>());
-			break;
-		default:
-			throw InternalException("Unsupported result modifier");
-		}
-		if (bound_modifier) {
-			result.modifiers.push_back(std::move(bound_modifier));
-		}
-	}
-}
-
-unique_ptr<Expression> CreateOrderExpression(unique_ptr<Expression> expr, const vector<string> &names,
-                                             const vector<LogicalType> &sql_types, idx_t table_index, idx_t index) {
-	if (index >= sql_types.size()) {
-		throw BinderException(*expr, "ORDER term out of range - should be between 1 and %lld", sql_types.size());
-	}
-	auto result =
-	    make_uniq<BoundColumnRefExpression>(expr->GetAlias(), sql_types[index], ColumnBinding(table_index, index));
-	if (result->GetAlias().empty() && index < names.size()) {
-		result->SetAlias(names[index]);
-	}
-	return std::move(result);
-}
-
-unique_ptr<Expression> FinalizeBindOrderExpression(unique_ptr<Expression> expr, idx_t table_index,
-                                                   const vector<string> &names, const vector<LogicalType> &sql_types,
-                                                   const SelectBindState &bind_state) {
-	auto &constant = expr->Cast<BoundConstantExpression>();
-	switch (constant.value.type().id()) {
-	case LogicalTypeId::UBIGINT: {
-		// index
-		auto index = UBigIntValue::Get(constant.value);
-		return CreateOrderExpression(std::move(expr), names, sql_types, table_index, bind_state.GetFinalIndex(index));
-	}
-	case LogicalTypeId::VARCHAR: {
-		// ORDER BY ALL
-		return nullptr;
-	}
-	case LogicalTypeId::STRUCT: {
-		// collation
-		auto &struct_values = StructValue::GetChildren(constant.value);
-		if (struct_values.size() > 2) {
-			throw InternalException("Expected one or two children: index and optional collation");
-		}
-		auto index = UBigIntValue::Get(struct_values[0]);
-		string collation;
-		if (struct_values.size() == 2) {
-			collation = StringValue::Get(struct_values[1]);
-		}
-		auto result = CreateOrderExpression(std::move(expr), names, sql_types, table_index, index);
-		if (!collation.empty()) {
-			if (sql_types[index].id() != LogicalTypeId::VARCHAR) {
-				throw BinderException(*result, "COLLATE can only be applied to varchar columns");
-			}
-			result->return_type = LogicalType::VARCHAR_COLLATION(std::move(collation));
-		}
-		return result;
-	}
-	default:
-		throw InternalException("Unknown type in FinalizeBindOrderExpression");
-	}
-}
-
-static void AssignReturnType(unique_ptr<Expression> &expr, idx_t table_index, const vector<string> &names,
-                             const vector<LogicalType> &sql_types, const SelectBindState &bind_state) {
-	if (!expr) {
-		return;
-	}
-	if (expr->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-		expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
-	}
-	if (expr->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
-		return;
-	}
-	auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-	bound_colref.return_type = sql_types[bound_colref.binding.column_index];
-}
-
-void Binder::BindModifiers(BoundQueryNode &result, idx_t table_index, const vector<string> &names,
-                           const vector<LogicalType> &sql_types, const SelectBindState &bind_state) {
-	for (auto &bound_mod : result.modifiers) {
-		switch (bound_mod->type) {
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = bound_mod->Cast<BoundDistinctModifier>();
-			// set types of distinct targets
-			for (auto &expr : distinct.target_distincts) {
-				expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
-				if (!expr) {
-					throw InternalException("DISTINCT ON ORDER BY ALL not supported");
-				}
-			}
-			for (auto &expr : distinct.target_distincts) {
-				ExpressionBinder::PushCollation(context, expr, expr->return_type);
-			}
-			break;
-		}
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit = bound_mod->Cast<BoundLimitModifier>();
-			AssignReturnType(limit.limit_val.GetExpression(), table_index, names, sql_types, bind_state);
-			AssignReturnType(limit.offset_val.GetExpression(), table_index, names, sql_types, bind_state);
-			break;
-		}
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = bound_mod->Cast<BoundOrderModifier>();
-			bool order_by_all = false;
-			for (auto &order_node : order.orders) {
-				auto &expr = order_node.expression;
-				expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
-				if (!expr) {
-					order_by_all = true;
-				}
-			}
-			if (order_by_all) {
-				D_ASSERT(order.orders.size() == 1);
-				auto order_type = order.orders[0].type;
-				auto null_order = order.orders[0].null_order;
-				order.orders.clear();
-				for (idx_t i = 0; i < sql_types.size(); i++) {
-					auto expr = make_uniq<BoundColumnRefExpression>(sql_types[i], ColumnBinding(table_index, i));
-					if (i < names.size()) {
-						expr->SetAlias(names[i]);
-					}
-					order.orders.emplace_back(order_type, null_order, std::move(expr));
-				}
-			}
-			for (auto &order_node : order.orders) {
-				auto &expr = order_node.expression;
-				ExpressionBinder::PushCollation(context, order_node.expression, expr->return_type);
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-}
-
-unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
-	D_ASSERT(statement.from_table);
-
-	// first bind the FROM table statement
-	auto from = std::move(statement.from_table);
-	auto from_table = Bind(*from);
-	return BindSelectNode(statement, std::move(from_table));
-}
-
-void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
-	// expand any expressions in the upper AND recursively
-	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		auto &conj = expr->Cast<ConjunctionExpression>();
-		for (auto &child : conj.children) {
-			BindWhereStarExpression(child);
-		}
-		return;
-	}
-	if (expr->GetExpressionType() == ExpressionType::STAR) {
-		auto &star = expr->Cast<StarExpression>();
-		if (!star.columns) {
-			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
-		}
-	}
-	// expand the stars for this expression
-	vector<unique_ptr<ParsedExpression>> new_conditions;
-	ExpandStarExpression(std::move(expr), new_conditions);
-	if (new_conditions.empty()) {
-		throw ParserException("COLUMNS expansion resulted in empty set of columns");
-	}
-
-	// set up an AND conjunction between the expanded conditions
-	expr = std::move(new_conditions[0]);
-	for (idx_t i = 1; i < new_conditions.size(); i++) {
-		auto and_conj = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
-		                                                 std::move(new_conditions[i]));
-		expr = std::move(and_conj);
-	}
-}
-
-unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table) {
-	D_ASSERT(from_table);
-	D_ASSERT(!statement.from_table);
-	auto result = make_uniq<BoundSelectNode>();
-	result->projection_index = GenerateTableIndex();
-	result->group_index = GenerateTableIndex();
-	result->aggregate_index = GenerateTableIndex();
-	result->groupings_index = GenerateTableIndex();
-	result->window_index = GenerateTableIndex();
-	result->prune_index = GenerateTableIndex();
-
-	result->from_table = std::move(from_table);
-	// bind the sample clause
-	if (statement.sample) {
-		result->sample_options = std::move(statement.sample);
-	}
-
-	// visit the select list and expand any "*" statements
-	vector<unique_ptr<ParsedExpression>> new_select_list;
-	ExpandStarExpressions(statement.select_list, new_select_list);
-
-	if (new_select_list.empty()) {
-		throw BinderException("SELECT list is empty after resolving * expressions!");
-	}
-	statement.select_list = std::move(new_select_list);
-
-	auto &bind_state = result->bind_state;
-	for (idx_t i = 0; i < statement.select_list.size(); i++) {
-		auto &expr = statement.select_list[i];
-		result->names.push_back(expr->GetName());
-		ExpressionBinder::QualifyColumnNames(*this, expr);
-		if (!expr->GetAlias().empty()) {
-			bind_state.alias_map[expr->GetAlias()] = i;
-			result->names[i] = expr->GetAlias();
-		}
-		bind_state.projection_map[*expr] = i;
-		bind_state.original_expressions.push_back(expr->Copy());
-	}
-	result->column_count = statement.select_list.size();
-
-	// first visit the WHERE clause
-	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
-	if (statement.where_clause) {
-		// bind any star expressions in the WHERE clause
-		BindWhereStarExpression(statement.where_clause);
-
-		ColumnAliasBinder alias_binder(bind_state);
-		WhereBinder where_binder(*this, context, &alias_binder);
-		unique_ptr<ParsedExpression> condition = std::move(statement.where_clause);
-		result->where_clause = where_binder.Bind(condition);
-	}
-
-	// now bind all the result modifiers; including DISTINCT and ORDER BY targets
-	OrderBinder order_binder({*this}, statement, bind_state);
-	PrepareModifiers(order_binder, statement, *result);
-
-	vector<unique_ptr<ParsedExpression>> unbound_groups;
-	BoundGroupInformation info;
-	auto &group_expressions = statement.groups.group_expressions;
-	if (!group_expressions.empty()) {
-		// the statement has a GROUP BY clause, bind it
-		unbound_groups.resize(group_expressions.size());
-		GroupBinder group_binder(*this, context, statement, result->group_index, bind_state, info.alias_map);
-		for (idx_t i = 0; i < group_expressions.size(); i++) {
-
-			// we keep a copy of the unbound expression;
-			// we keep the unbound copy around to check for group references in the SELECT and HAVING clause
-			// the reason we want the unbound copy is because we want to figure out whether an expression
-			// is a group reference BEFORE binding in the SELECT/HAVING binder
-			group_binder.unbound_expression = group_expressions[i]->Copy();
-			group_binder.bind_index = i;
-
-			// bind the groups
-			LogicalType group_type;
-			auto bound_expr = group_binder.Bind(group_expressions[i], &group_type);
-			D_ASSERT(bound_expr->return_type.id() != LogicalTypeId::INVALID);
-
-			// find out whether the expression contains a subquery, it can't be copied if so
-			auto &bound_expr_ref = *bound_expr;
-			bool contains_subquery = bound_expr_ref.HasSubquery();
-
-			// push a potential collation, if necessary
-			bool requires_collation = ExpressionBinder::PushCollation(context, bound_expr, group_type);
-			if (!contains_subquery && requires_collation) {
-				// if there is a collation on a group x, we should group by the collated expr,
-				// but also push a first(x) aggregate in case x is selected (uncollated)
-				info.collated_groups[i] = result->aggregates.size();
-
-				auto first_fun = FirstFunctionGetter::GetFunction(bound_expr_ref.return_type);
-				vector<unique_ptr<Expression>> first_children;
-				// FIXME: would be better to just refer to this expression, but for now we copy
-				first_children.push_back(bound_expr_ref.Copy());
-
-				FunctionBinder function_binder(*this);
-				auto function = function_binder.BindAggregateFunction(first_fun, std::move(first_children));
-				function->SetAlias("__collated_group");
-				result->aggregates.push_back(std::move(function));
-			}
-			result->groups.group_expressions.push_back(std::move(bound_expr));
-
-			// in the unbound expression we DO bind the table names of any ColumnRefs
-			// we do this to make sure that "table.a" and "a" are treated the same
-			// if we wouldn't do this then (SELECT test.a FROM test GROUP BY a) would not work because "test.a" <> "a"
-			// hence we convert "a" -> "test.a" in the unbound expression
-			unbound_groups[i] = std::move(group_binder.unbound_expression);
-			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
-			info.map[*unbound_groups[i]] = i;
-		}
-	}
-	result->groups.grouping_sets = std::move(statement.groups.grouping_sets);
-
-	// bind the HAVING clause, if any
-	if (statement.having) {
-		HavingBinder having_binder(*this, context, *result, info, statement.aggregate_handling);
-		ExpressionBinder::QualifyColumnNames(having_binder, statement.having);
-		result->having = having_binder.Bind(statement.having);
-	}
-
-	// bind the QUALIFY clause, if any
-	vector<BoundColumnReferenceInfo> bound_qualify_columns;
-	if (statement.qualify) {
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-			throw BinderException("Combining QUALIFY with GROUP BY ALL is not supported yet");
-		}
-		QualifyBinder qualify_binder(*this, context, *result, info);
-		ExpressionBinder::QualifyColumnNames(*this, statement.qualify);
-		result->qualify = qualify_binder.Bind(statement.qualify);
-		if (qualify_binder.HasBoundColumns()) {
-			if (qualify_binder.BoundAggregates()) {
-				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
-			}
-			bound_qualify_columns = qualify_binder.GetBoundColumns();
-		}
-	}
-
-	// after that, we bind to the SELECT list
-	SelectBinder select_binder(*this, context, *result, info);
-
-	// if we expand select-list expressions, e.g., via UNNEST, then we need to possibly
-	// adjust the column index of the already bound ORDER BY modifiers, and not only set their types
-	vector<idx_t> group_by_all_indexes;
-	vector<string> new_names;
-	vector<LogicalType> internal_sql_types;
-
-	for (idx_t i = 0; i < statement.select_list.size(); i++) {
-		bool is_window = statement.select_list[i]->IsWindow();
-		idx_t unnest_count = result->unnests.size();
-		LogicalType result_type;
-		auto expr = select_binder.Bind(statement.select_list[i], &result_type, true);
-		bool is_original_column = i < result->column_count;
-		bool can_group_by_all =
-		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
-		result->bound_column_count++;
-
-		if (expr->GetExpressionType() == ExpressionType::BOUND_EXPANDED) {
-			if (!is_original_column) {
-				throw BinderException("UNNEST of struct cannot be used in ORDER BY/DISTINCT ON clause");
-			}
-			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-				throw BinderException("UNNEST of struct cannot be combined with GROUP BY ALL");
-			}
-
-			auto &expanded = expr->Cast<BoundExpandedExpression>();
-			auto &struct_expressions = expanded.expanded_expressions;
-			D_ASSERT(!struct_expressions.empty());
-
-			for (auto &struct_expr : struct_expressions) {
-				new_names.push_back(struct_expr->GetName());
-				result->types.push_back(struct_expr->return_type);
-				internal_sql_types.push_back(struct_expr->return_type);
-				result->select_list.push_back(std::move(struct_expr));
-			}
-			bind_state.AddExpandedColumn(struct_expressions.size());
-			continue;
-		}
-
-		if (expr->IsVolatile()) {
-			bind_state.SetExpressionIsVolatile(i);
-		}
-		if (expr->HasSubquery()) {
-			bind_state.SetExpressionHasSubquery(i);
-		}
-		bind_state.AddRegularColumn();
-
-		if (can_group_by_all && select_binder.HasBoundColumns()) {
-			if (select_binder.BoundAggregates()) {
-				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
-			}
-			if (is_window) {
-				throw BinderException("Cannot group on a window clause");
-			}
-			if (result->unnests.size() > unnest_count) {
-				throw BinderException("Cannot group on an UNNEST or UNLIST clause");
-			}
-			// we are forcing aggregates, and the node has columns bound
-			// this entry becomes a group
-			group_by_all_indexes.push_back(i);
-		}
-
-		result->select_list.push_back(std::move(expr));
-		if (is_original_column) {
-			new_names.push_back(std::move(result->names[i]));
-			result->types.push_back(result_type);
-		}
-		internal_sql_types.push_back(result_type);
-
-		if (can_group_by_all) {
-			select_binder.ResetBindings();
-		}
-	}
-
-	// push the GROUP BY ALL expressions into the group set
-
-	for (auto &group_by_all_index : group_by_all_indexes) {
-		auto &expr = result->select_list[group_by_all_index];
-		auto group_ref = make_uniq<BoundColumnRefExpression>(
-		    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
-		result->groups.group_expressions.push_back(std::move(expr));
-		expr = std::move(group_ref);
-	}
-	set<idx_t> group_by_all_indexes_set;
-	if (!group_by_all_indexes.empty()) {
-		idx_t num_set_indexes = result->groups.group_expressions.size();
-		for (idx_t i = 0; i < num_set_indexes; i++) {
-			group_by_all_indexes_set.insert(i);
-		}
-		D_ASSERT(result->groups.grouping_sets.empty());
-		result->groups.grouping_sets.push_back(group_by_all_indexes_set);
-	}
-	result->column_count = new_names.size();
-	result->names = std::move(new_names);
-	result->need_prune = result->select_list.size() > result->column_count;
-
-	// in the normal select binder, we bind columns as if there is no aggregation
-	// i.e. in the query [SELECT i, SUM(i) FROM integers;] the "i" will be bound as a normal column
-	// since we have an aggregation, we need to either (1) throw an error, or (2) wrap the column in a FIRST() aggregate
-	// we choose the former one [CONTROVERSIAL: this is the PostgreSQL behavior]
-	if (!result->groups.group_expressions.empty() || !result->aggregates.empty() || statement.having ||
-	    !result->groups.grouping_sets.empty()) {
-		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
-			throw BinderException("Aggregates cannot be present in a Project relation!");
-		} else {
-			vector<BoundColumnReferenceInfo> bound_columns;
-			if (select_binder.HasBoundColumns()) {
-				bound_columns = select_binder.GetBoundColumns();
-			}
-			for (auto &bound_qualify_col : bound_qualify_columns) {
-				bound_columns.push_back(bound_qualify_col);
-			}
-			if (!bound_columns.empty()) {
-				string error;
-				error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
-				if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-					error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
-					         "GROUP BY this entry explicitly.";
-					throw BinderException(bound_columns[0].query_location, error, bound_columns[0].name);
-				} else {
-					error +=
-					    "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
-					    "is not important.";
-					throw BinderException(bound_columns[0].query_location, error, bound_columns[0].name,
-					                      bound_columns[0].name, bound_columns[0].name);
-				}
-			}
-		}
-	}
-
-	// QUALIFY clause requires at least one window function to be specified in at least one of the SELECT column list or
-	// the filter predicate of the QUALIFY clause
-	if (statement.qualify && result->windows.empty()) {
-		throw BinderException("at least one window function must appear in the SELECT column or QUALIFY clause");
-	}
-
-	// now that the SELECT list is bound, we set the types of DISTINCT/ORDER BY expressions
-	BindModifiers(*result, result->projection_index, result->names, internal_sql_types, bind_state);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp b/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp
deleted file mode 100644
index 82d6c754b..000000000
--- a/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/query_node/set_operation_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_binder/order_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/query_node/bound_set_operation_node.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-static void GatherAliases(BoundQueryNode &node, SelectBindState &bind_state, const vector<idx_t> &reorder_idx) {
-	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
-		// setop, recurse
-		auto &setop = node.Cast<BoundSetOperationNode>();
-
-		// create new reorder index
-		if (setop.setop_type == SetOperationType::UNION_BY_NAME) {
-			vector<idx_t> new_left_reorder_idx(setop.left_reorder_idx.size());
-			vector<idx_t> new_right_reorder_idx(setop.right_reorder_idx.size());
-			for (idx_t i = 0; i < setop.left_reorder_idx.size(); ++i) {
-				new_left_reorder_idx[i] = reorder_idx[setop.left_reorder_idx[i]];
-			}
-
-			for (idx_t i = 0; i < setop.right_reorder_idx.size(); ++i) {
-				new_right_reorder_idx[i] = reorder_idx[setop.right_reorder_idx[i]];
-			}
-
-			// use new reorder index
-			GatherAliases(*setop.left, bind_state, new_left_reorder_idx);
-			GatherAliases(*setop.right, bind_state, new_right_reorder_idx);
-			return;
-		}
-
-		GatherAliases(*setop.left, bind_state, reorder_idx);
-		GatherAliases(*setop.right, bind_state, reorder_idx);
-	} else {
-		// query node
-		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
-		auto &select = node.Cast<BoundSelectNode>();
-		// fill the alias lists with the names
-		for (idx_t i = 0; i < select.names.size(); i++) {
-			auto &name = select.names[i];
-			// first check if the alias is already in there
-			auto entry = bind_state.alias_map.find(name);
-
-			idx_t index = reorder_idx[i];
-
-			if (entry == bind_state.alias_map.end()) {
-				// the alias is not in there yet, just assign it
-				bind_state.alias_map[name] = index;
-			}
-		}
-		// check if the expression matches one of the expressions in the original expression liset
-		for (idx_t i = 0; i < select.bind_state.original_expressions.size(); i++) {
-			auto &expr = select.bind_state.original_expressions[i];
-			idx_t index = reorder_idx[i];
-			// now check if the node is already in the set of expressions
-			auto expr_entry = bind_state.projection_map.find(*expr);
-			if (expr_entry != bind_state.projection_map.end()) {
-				// the node is in there
-				// repeat the same as with the alias: if there is an ambiguity we insert "-1"
-				if (expr_entry->second != index) {
-					bind_state.projection_map[*expr] = DConstants::INVALID_INDEX;
-				}
-			} else {
-				// not in there yet, just place it in there
-				bind_state.projection_map[*expr] = index;
-			}
-		}
-	}
-}
-
-static void BuildUnionByNameInfo(ClientContext &context, BoundSetOperationNode &result, bool can_contain_nulls) {
-	D_ASSERT(result.setop_type == SetOperationType::UNION_BY_NAME);
-	case_insensitive_map_t<idx_t> left_names_map;
-	case_insensitive_map_t<idx_t> right_names_map;
-
-	auto &left_node = *result.left;
-	auto &right_node = *result.right;
-
-	// Build a name_map to use to check if a name exists
-	// We throw a binder exception if two same name in the SELECT list
-	for (idx_t i = 0; i < left_node.names.size(); ++i) {
-		if (left_names_map.find(left_node.names[i]) != left_names_map.end()) {
-			throw BinderException("UNION (ALL) BY NAME operation doesn't support duplicate names in the SELECT list - "
-			                      "the name \"%s\" occurs multiple times in the left-hand side",
-			                      left_node.names[i]);
-		}
-		left_names_map[left_node.names[i]] = i;
-	}
-
-	for (idx_t i = 0; i < right_node.names.size(); ++i) {
-		if (right_names_map.find(right_node.names[i]) != right_names_map.end()) {
-			throw BinderException("UNION (ALL) BY NAME operation doesn't support duplicate names in the SELECT list - "
-			                      "the name \"%s\" occurs multiple times in the right-hand side",
-			                      right_node.names[i]);
-		}
-		if (left_names_map.find(right_node.names[i]) == left_names_map.end()) {
-			result.names.push_back(right_node.names[i]);
-		}
-		right_names_map[right_node.names[i]] = i;
-	}
-
-	idx_t new_size = result.names.size();
-	bool need_reorder = false;
-	vector<idx_t> left_reorder_idx(left_node.names.size());
-	vector<idx_t> right_reorder_idx(right_node.names.size());
-
-	// Construct return type and reorder_idxs
-	// reorder_idxs is used to gather correct alias_map
-	// and expression_map in GatherAlias(...)
-	for (idx_t i = 0; i < new_size; ++i) {
-		auto left_index = left_names_map.find(result.names[i]);
-		auto right_index = right_names_map.find(result.names[i]);
-		bool left_exist = left_index != left_names_map.end();
-		bool right_exist = right_index != right_names_map.end();
-		LogicalType result_type;
-		if (left_exist && right_exist) {
-			result_type = LogicalType::ForceMaxLogicalType(left_node.types[left_index->second],
-			                                               right_node.types[right_index->second]);
-			if (left_index->second != i || right_index->second != i) {
-				need_reorder = true;
-			}
-			left_reorder_idx[left_index->second] = i;
-			right_reorder_idx[right_index->second] = i;
-		} else if (left_exist) {
-			result_type = left_node.types[left_index->second];
-			need_reorder = true;
-			left_reorder_idx[left_index->second] = i;
-		} else {
-			D_ASSERT(right_exist);
-			result_type = right_node.types[right_index->second];
-			need_reorder = true;
-			right_reorder_idx[right_index->second] = i;
-		}
-
-		if (!can_contain_nulls) {
-			if (ExpressionBinder::ContainsNullType(result_type)) {
-				result_type = ExpressionBinder::ExchangeNullType(result_type);
-			}
-		}
-
-		result.types.push_back(result_type);
-	}
-
-	result.left_reorder_idx = std::move(left_reorder_idx);
-	result.right_reorder_idx = std::move(right_reorder_idx);
-
-	// If reorder is required, collect reorder expressions for push projection
-	// into the two child nodes of union node
-	if (need_reorder) {
-		for (idx_t i = 0; i < new_size; ++i) {
-			auto left_index = left_names_map.find(result.names[i]);
-			auto right_index = right_names_map.find(result.names[i]);
-			bool left_exist = left_index != left_names_map.end();
-			bool right_exist = right_index != right_names_map.end();
-			unique_ptr<Expression> left_reorder_expr;
-			unique_ptr<Expression> right_reorder_expr;
-			if (left_exist && right_exist) {
-				left_reorder_expr = make_uniq<BoundColumnRefExpression>(
-				    left_node.types[left_index->second], ColumnBinding(left_node.GetRootIndex(), left_index->second));
-				right_reorder_expr =
-				    make_uniq<BoundColumnRefExpression>(right_node.types[right_index->second],
-				                                        ColumnBinding(right_node.GetRootIndex(), right_index->second));
-			} else if (left_exist) {
-				left_reorder_expr = make_uniq<BoundColumnRefExpression>(
-				    left_node.types[left_index->second], ColumnBinding(left_node.GetRootIndex(), left_index->second));
-				// create null value here
-				right_reorder_expr = make_uniq<BoundConstantExpression>(Value(result.types[i]));
-			} else {
-				D_ASSERT(right_exist);
-				left_reorder_expr = make_uniq<BoundConstantExpression>(Value(result.types[i]));
-				right_reorder_expr =
-				    make_uniq<BoundColumnRefExpression>(right_node.types[right_index->second],
-				                                        ColumnBinding(right_node.GetRootIndex(), right_index->second));
-			}
-			result.left_reorder_exprs.push_back(std::move(left_reorder_expr));
-			result.right_reorder_exprs.push_back(std::move(right_reorder_expr));
-		}
-	}
-}
-
-static void GatherSetOpBinders(BoundQueryNode &node, Binder &binder, vector<reference<Binder>> &binders) {
-	if (node.type != QueryNodeType::SET_OPERATION_NODE) {
-		binders.push_back(binder);
-		return;
-	}
-	auto &setop_node = node.Cast<BoundSetOperationNode>();
-	GatherSetOpBinders(*setop_node.left, *setop_node.left_binder, binders);
-	GatherSetOpBinders(*setop_node.right, *setop_node.right_binder, binders);
-}
-
-unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
-	auto result = make_uniq<BoundSetOperationNode>();
-	result->setop_type = statement.setop_type;
-	result->setop_all = statement.setop_all;
-
-	// first recursively visit the set operations
-	// both the left and right sides have an independent BindContext and Binder
-	D_ASSERT(statement.left);
-	D_ASSERT(statement.right);
-
-	result->setop_index = GenerateTableIndex();
-
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->left_binder->can_contain_nulls = true;
-	result->left = result->left_binder->BindNode(*statement.left);
-	result->right_binder = Binder::CreateBinder(context, this);
-	result->right_binder->can_contain_nulls = true;
-	result->right = result->right_binder->BindNode(*statement.right);
-
-	result->names = result->left->names;
-
-	// move the correlated expressions from the child binders to this binder
-	MoveCorrelatedExpressions(*result->left_binder);
-	MoveCorrelatedExpressions(*result->right_binder);
-
-	// now both sides have been bound we can resolve types
-	if (result->setop_type != SetOperationType::UNION_BY_NAME &&
-	    result->left->types.size() != result->right->types.size()) {
-		throw BinderException("Set operations can only apply to expressions with the "
-		                      "same number of result columns");
-	}
-
-	if (result->setop_type == SetOperationType::UNION_BY_NAME) {
-		BuildUnionByNameInfo(context, *result, can_contain_nulls);
-	} else {
-		// figure out the types of the setop result by picking the max of both
-		for (idx_t i = 0; i < result->left->types.size(); i++) {
-			auto result_type = LogicalType::ForceMaxLogicalType(result->left->types[i], result->right->types[i]);
-			if (!can_contain_nulls) {
-				if (ExpressionBinder::ContainsNullType(result_type)) {
-					result_type = ExpressionBinder::ExchangeNullType(result_type);
-				}
-			}
-			result->types.push_back(result_type);
-		}
-	}
-
-	SelectBindState bind_state;
-	if (!statement.modifiers.empty()) {
-		// handle the ORDER BY/DISTINCT clauses
-
-		// we recursively visit the children of this node to extract aliases and expressions that can be referenced
-		// in the ORDER BY
-
-		if (result->setop_type == SetOperationType::UNION_BY_NAME) {
-			GatherAliases(*result->left, bind_state, result->left_reorder_idx);
-			GatherAliases(*result->right, bind_state, result->right_reorder_idx);
-		} else {
-			vector<idx_t> reorder_idx;
-			for (idx_t i = 0; i < result->names.size(); i++) {
-				reorder_idx.push_back(i);
-			}
-			GatherAliases(*result, bind_state, reorder_idx);
-		}
-		// now we perform the actual resolution of the ORDER BY/DISTINCT expressions
-		vector<reference<Binder>> binders;
-		GatherSetOpBinders(*result->left, *result->left_binder, binders);
-		GatherSetOpBinders(*result->right, *result->right_binder, binders);
-		OrderBinder order_binder(binders, bind_state);
-		PrepareModifiers(order_binder, statement, *result);
-	}
-
-	// finally bind the types of the ORDER/DISTINCT clause expressions
-	BindModifiers(*result, result->setop_index, result->names, result->types, bind_state);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp b/src/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp
deleted file mode 100644
index 0f90c1155..000000000
--- a/src/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-
-namespace duckdb {
-
-unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func,
-                                             idx_t depth) {
-	// validate the arguments and separate positional and default arguments
-	vector<unique_ptr<ParsedExpression>> positionals;
-	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
-	auto bind_result =
-	    MacroFunction::BindMacroFunction(macro_func.macros, macro_func.name, function, positionals, defaults);
-	if (!bind_result.error.empty()) {
-		// cannot use error below as binder rnot in scope
-		// return BindResult(binder. FormatError(*expr->get(), error));
-		throw BinderException(function, bind_result.error);
-	}
-	auto &macro_def = macro_func.macros[bind_result.function_idx.GetIndex()]->Cast<TableMacroFunction>();
-	auto node = macro_def.query_node->Copy();
-
-	// create a MacroBinding to bind this macro's parameters to its arguments
-	vector<LogicalType> types;
-	vector<string> names;
-	// positional parameters
-	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		types.emplace_back(LogicalTypeId::UNKNOWN);
-		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
-		names.push_back(param.GetColumnName());
-	}
-	// default parameters
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		types.emplace_back(LogicalTypeId::UNKNOWN);
-		names.push_back(it->first);
-		// now push the defaults into the positionals
-		positionals.push_back(std::move(defaults[it->first]));
-	}
-	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func.name);
-	new_macro_binding->arguments = &positionals;
-
-	// We need an ExpressionBinder so that we can call ExpressionBinder::ReplaceMacroParametersRecursive()
-	auto eb = ExpressionBinder(*this, this->context);
-
-	eb.macro_binding = new_macro_binding.get();
-	vector<unordered_set<string>> lambda_params;
-	ParsedExpressionIterator::EnumerateQueryNodeChildren(
-	    *node, [&](unique_ptr<ParsedExpression> &child) { eb.ReplaceMacroParameters(child, lambda_params); });
-
-	return node;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/plan_cte_node.cpp b/src/duckdb/src/planner/binder/query_node/plan_cte_node.cpp
deleted file mode 100644
index 057ee60fc..000000000
--- a/src/duckdb/src/planner/binder/query_node/plan_cte_node.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/operator/logical_materialized_cte.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/query_node/bound_cte_node.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
-	// Generate the logical plan for the cte_query and child.
-	auto cte_query = CreatePlan(*node.query);
-	auto cte_child = CreatePlan(*node.child);
-
-	auto root = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
-	                                              std::move(cte_query), std::move(cte_child));
-
-	// check if there are any unplanned subqueries left in either child
-	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.child_binder->has_unplanned_dependent_joins ||
-	                                node.query_binder->has_unplanned_dependent_joins;
-
-	return VisitQueryNode(node, std::move(root));
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node, unique_ptr<LogicalOperator> base) {
-	// Generate the logical plan for the cte_query and child.
-	auto cte_query = CreatePlan(*node.query);
-	unique_ptr<LogicalOperator> root;
-	if (node.child && node.child->type == QueryNodeType::CTE_NODE) {
-		root = CreatePlan(node.child->Cast<BoundCTENode>(), std::move(base));
-	} else if (node.child) {
-		root = CreatePlan(*node.child);
-	} else {
-		root = std::move(base);
-	}
-
-	// Only keep the materialized CTE, if it is used
-	if (node.child_binder->bind_context.cte_references[node.ctename] &&
-	    *node.child_binder->bind_context.cte_references[node.ctename] > 0) {
-
-		// Push the CTE through single-child operators so query modifiers appear ABOVE the CTE (internal issue #2652)
-		// Otherwise, we may have a LIMIT on top of the CTE, and an ORDER BY in the query, and we can't make a TopN
-		reference<unique_ptr<LogicalOperator>> cte_child = root;
-		while (cte_child.get()->children.size() == 1 && cte_child.get()->type != LogicalOperatorType::LOGICAL_CTE_REF) {
-			cte_child = cte_child.get()->children[0];
-		}
-		cte_child.get() = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
-		                                                    std::move(cte_query), std::move(cte_child.get()));
-
-		// check if there are any unplanned subqueries left in either child
-		has_unplanned_dependent_joins = has_unplanned_dependent_joins ||
-		                                node.child_binder->has_unplanned_dependent_joins ||
-		                                node.query_binder->has_unplanned_dependent_joins;
-	}
-	return VisitQueryNode(node, std::move(root));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/plan_query_node.cpp b/src/duckdb/src/planner/binder/query_node/plan_query_node.cpp
deleted file mode 100644
index c448f2f11..000000000
--- a/src/duckdb/src/planner/binder/query_node/plan_query_node.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root) {
-	D_ASSERT(root);
-	for (auto &mod : node.modifiers) {
-		switch (mod->type) {
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &bound = mod->Cast<BoundDistinctModifier>();
-			if (bound.target_distincts.empty()) {
-				break;
-			}
-			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts), bound.distinct_type);
-			distinct->AddChild(std::move(root));
-			root = std::move(distinct);
-			break;
-		}
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &bound = mod->Cast<BoundOrderModifier>();
-			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
-				auto &distinct = root->Cast<LogicalDistinct>();
-				if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
-					auto order_by = make_uniq<BoundOrderModifier>();
-					for (auto &order_node : bound.orders) {
-						order_by->orders.push_back(order_node.Copy());
-					}
-					distinct.order_by = std::move(order_by);
-				}
-			}
-			auto order = make_uniq<LogicalOrder>(std::move(bound.orders));
-			order->AddChild(std::move(root));
-			root = std::move(order);
-			break;
-		}
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &bound = mod->Cast<BoundLimitModifier>();
-			auto limit = make_uniq<LogicalLimit>(std::move(bound.limit_val), std::move(bound.offset_val));
-			limit->AddChild(std::move(root));
-			root = std::move(limit);
-			break;
-		}
-		default:
-			throw BinderException("Unimplemented modifier type!");
-		}
-	}
-	return root;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/plan_recursive_cte_node.cpp b/src/duckdb/src/planner/binder/query_node/plan_recursive_cte_node.cpp
deleted file mode 100644
index 7f2eafefd..000000000
--- a/src/duckdb/src/planner/binder/query_node/plan_recursive_cte_node.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_recursive_cte.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/query_node/bound_recursive_cte_node.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
-	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->is_outside_flattened = is_outside_flattened;
-	node.right_binder->is_outside_flattened = is_outside_flattened;
-
-	auto left_node = node.left_binder->CreatePlan(*node.left);
-	auto right_node = node.right_binder->CreatePlan(*node.right);
-
-	// check if there are any unplanned subqueries left in either child
-	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.left_binder->has_unplanned_dependent_joins ||
-	                                node.right_binder->has_unplanned_dependent_joins;
-
-	// for both the left and right sides, cast them to the same types
-	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
-	right_node = CastLogicalOperatorToTypes(node.right->types, node.types, std::move(right_node));
-
-	if (!node.right_binder->bind_context.cte_references[node.ctename] ||
-	    *node.right_binder->bind_context.cte_references[node.ctename] == 0) {
-		auto root = make_uniq<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
-		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION, true);
-		return VisitQueryNode(node, std::move(root));
-	}
-	auto root = make_uniq<LogicalRecursiveCTE>(node.ctename, node.setop_index, node.types.size(), node.union_all,
-	                                           std::move(left_node), std::move(right_node));
-
-	return VisitQueryNode(node, std::move(root));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/plan_select_node.cpp b/src/duckdb/src/planner/binder/query_node/plan_select_node.cpp
deleted file mode 100644
index 46e5d2e12..000000000
--- a/src/duckdb/src/planner/binder/query_node/plan_select_node.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root) {
-	PlanSubqueries(condition, root);
-	auto filter = make_uniq<LogicalFilter>(std::move(condition));
-	filter->AddChild(std::move(root));
-	return std::move(filter);
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
-	unique_ptr<LogicalOperator> root;
-	D_ASSERT(statement.from_table);
-	root = CreatePlan(*statement.from_table);
-	D_ASSERT(root);
-
-	// plan the sample clause
-	if (statement.sample_options) {
-		root = make_uniq<LogicalSample>(std::move(statement.sample_options), std::move(root));
-	}
-
-	if (statement.where_clause) {
-		root = PlanFilter(std::move(statement.where_clause), std::move(root));
-	}
-
-	if (!statement.aggregates.empty() || !statement.groups.group_expressions.empty()) {
-		if (!statement.groups.group_expressions.empty()) {
-			// visit the groups
-			for (auto &group : statement.groups.group_expressions) {
-				PlanSubqueries(group, root);
-			}
-		}
-		// now visit all aggregate expressions
-		for (auto &expr : statement.aggregates) {
-			PlanSubqueries(expr, root);
-		}
-		// finally create the aggregate node with the group_index and aggregate_index as obtained from the binder
-		auto aggregate = make_uniq<LogicalAggregate>(statement.group_index, statement.aggregate_index,
-		                                             std::move(statement.aggregates));
-		aggregate->groups = std::move(statement.groups.group_expressions);
-		aggregate->groupings_index = statement.groupings_index;
-		aggregate->grouping_sets = std::move(statement.groups.grouping_sets);
-		aggregate->grouping_functions = std::move(statement.grouping_functions);
-
-		aggregate->AddChild(std::move(root));
-		root = std::move(aggregate);
-	} else if (!statement.groups.grouping_sets.empty()) {
-		// edge case: we have grouping sets but no groups or aggregates
-		// this can only happen if we have e.g. select 1 from tbl group by ();
-		// just output a dummy scan
-		root = make_uniq_base<LogicalOperator, LogicalDummyScan>(statement.group_index);
-	}
-
-	if (statement.having) {
-		PlanSubqueries(statement.having, root);
-		auto having = make_uniq<LogicalFilter>(std::move(statement.having));
-
-		having->AddChild(std::move(root));
-		root = std::move(having);
-	}
-
-	if (!statement.windows.empty()) {
-		auto win = make_uniq<LogicalWindow>(statement.window_index);
-		win->expressions = std::move(statement.windows);
-		// visit the window expressions
-		for (auto &expr : win->expressions) {
-			PlanSubqueries(expr, root);
-		}
-		D_ASSERT(!win->expressions.empty());
-		win->AddChild(std::move(root));
-		root = std::move(win);
-	}
-
-	if (statement.qualify) {
-		PlanSubqueries(statement.qualify, root);
-		auto qualify = make_uniq<LogicalFilter>(std::move(statement.qualify));
-
-		qualify->AddChild(std::move(root));
-		root = std::move(qualify);
-	}
-
-	for (idx_t i = statement.unnests.size(); i > 0; i--) {
-		auto unnest_level = i - 1;
-		auto entry = statement.unnests.find(unnest_level);
-		if (entry == statement.unnests.end()) {
-			throw InternalException("unnests specified at level %d but none were found", unnest_level);
-		}
-		auto &unnest_node = entry->second;
-		auto unnest = make_uniq<LogicalUnnest>(unnest_node.index);
-		unnest->expressions = std::move(unnest_node.expressions);
-		// visit the unnest expressions
-		for (auto &expr : unnest->expressions) {
-			PlanSubqueries(expr, root);
-		}
-		D_ASSERT(!unnest->expressions.empty());
-		unnest->AddChild(std::move(root));
-		root = std::move(unnest);
-	}
-
-	for (auto &expr : statement.select_list) {
-		PlanSubqueries(expr, root);
-	}
-
-	auto proj = make_uniq<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
-	auto &projection = *proj;
-	proj->AddChild(std::move(root));
-	root = std::move(proj);
-
-	// finish the plan by handling the elements of the QueryNode
-	root = VisitQueryNode(statement, std::move(root));
-
-	// add a prune node if necessary
-	if (statement.need_prune) {
-		D_ASSERT(root);
-		vector<unique_ptr<Expression>> prune_expressions;
-		for (idx_t i = 0; i < statement.column_count; i++) {
-			prune_expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    projection.expressions[i]->return_type, ColumnBinding(statement.projection_index, i)));
-		}
-		auto prune = make_uniq<LogicalProjection>(statement.prune_index, std::move(prune_expressions));
-		prune->AddChild(std::move(root));
-		root = std::move(prune);
-	}
-	return root;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/plan_setop.cpp b/src/duckdb/src/planner/binder/query_node/plan_setop.cpp
deleted file mode 100644
index ba929bcd8..000000000
--- a/src/duckdb/src/planner/binder/query_node/plan_setop.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/planner/query_node/bound_set_operation_node.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-
-namespace duckdb {
-
-// Optionally push a PROJECTION operator
-unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalType> &source_types,
-                                                               vector<LogicalType> &target_types,
-                                                               unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op);
-	// first check if we even need to cast
-	D_ASSERT(source_types.size() == target_types.size());
-	if (source_types == target_types) {
-		// source and target types are equal: don't need to cast
-		return op;
-	}
-	// otherwise add casts
-	auto node = op.get();
-	if (node->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		// "node" is a projection; we can just do the casts in there
-		D_ASSERT(node->expressions.size() == source_types.size());
-		if (node->children.size() == 1 && node->children[0]->type == LogicalOperatorType::LOGICAL_GET) {
-			// If this projection only has one child and that child is a logical get we can try to pushdown types
-			auto &logical_get = node->children[0]->Cast<LogicalGet>();
-			auto &column_ids = logical_get.GetColumnIds();
-			if (logical_get.function.type_pushdown) {
-				unordered_map<idx_t, LogicalType> new_column_types;
-				bool do_pushdown = true;
-				for (idx_t i = 0; i < op->expressions.size(); i++) {
-					if (op->expressions[i]->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-						auto &col_ref = op->expressions[i]->Cast<BoundColumnRefExpression>();
-						auto column_id = column_ids[col_ref.binding.column_index].GetPrimaryIndex();
-						if (new_column_types.find(column_id) != new_column_types.end()) {
-							// Only one reference per column is accepted
-							do_pushdown = false;
-							break;
-						}
-						new_column_types[column_id] = target_types[i];
-					} else {
-						do_pushdown = false;
-						break;
-					}
-				}
-				if (do_pushdown) {
-					logical_get.function.type_pushdown(context, logical_get.bind_data, new_column_types);
-					// We also have to modify the types to the logical_get.returned_types
-					for (auto &type : new_column_types) {
-						logical_get.returned_types[type.first] = type.second;
-					}
-					return std::move(op->children[0]);
-				}
-			}
-		}
-		// add the casts to the selection list
-		for (idx_t i = 0; i < target_types.size(); i++) {
-			if (source_types[i] != target_types[i]) {
-				// differing types, have to add a cast
-				string cur_alias = node->expressions[i]->GetAlias();
-				node->expressions[i] =
-				    BoundCastExpression::AddCastToType(context, std::move(node->expressions[i]), target_types[i]);
-				node->expressions[i]->SetAlias(cur_alias);
-			}
-		}
-		return op;
-	} else {
-		// found a non-projection operator
-		// push a new projection containing the casts
-
-		// fetch the set of column bindings
-		auto setop_columns = op->GetColumnBindings();
-		D_ASSERT(setop_columns.size() == source_types.size());
-
-		// now generate the expression list
-		vector<unique_ptr<Expression>> select_list;
-		for (idx_t i = 0; i < target_types.size(); i++) {
-			unique_ptr<Expression> result = make_uniq<BoundColumnRefExpression>(source_types[i], setop_columns[i]);
-			if (source_types[i] != target_types[i]) {
-				// add a cast only if the source and target types are not equivalent
-				result = BoundCastExpression::AddCastToType(context, std::move(result), target_types[i]);
-			}
-			select_list.push_back(std::move(result));
-		}
-		auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
-		projection->children.push_back(std::move(op));
-		return std::move(projection);
-	}
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
-	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->is_outside_flattened = is_outside_flattened;
-	node.right_binder->is_outside_flattened = is_outside_flattened;
-
-	auto left_node = node.left_binder->CreatePlan(*node.left);
-	auto right_node = node.right_binder->CreatePlan(*node.right);
-
-	// Add a new projection to child node
-	D_ASSERT(node.left_reorder_exprs.size() == node.right_reorder_exprs.size());
-	if (!node.left_reorder_exprs.empty()) {
-		D_ASSERT(node.setop_type == SetOperationType::UNION_BY_NAME);
-		vector<LogicalType> left_types;
-		vector<LogicalType> right_types;
-		// We are going to add a new projection operator, so collect the type
-		// of reorder exprs in order to call CastLogicalOperatorToTypes()
-		for (idx_t i = 0; i < node.left_reorder_exprs.size(); ++i) {
-			left_types.push_back(node.left_reorder_exprs[i]->return_type);
-			right_types.push_back(node.right_reorder_exprs[i]->return_type);
-		}
-
-		auto left_projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(node.left_reorder_exprs));
-		left_projection->children.push_back(std::move(left_node));
-		left_node = std::move(left_projection);
-
-		auto right_projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(node.right_reorder_exprs));
-		right_projection->children.push_back(std::move(right_node));
-		right_node = std::move(right_projection);
-
-		left_node = CastLogicalOperatorToTypes(left_types, node.types, std::move(left_node));
-		right_node = CastLogicalOperatorToTypes(right_types, node.types, std::move(right_node));
-	} else {
-		left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
-		right_node = CastLogicalOperatorToTypes(node.right->types, node.types, std::move(right_node));
-	}
-
-	// check if there are any unplanned subqueries left in either child
-	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.left_binder->has_unplanned_dependent_joins ||
-	                                node.right_binder->has_unplanned_dependent_joins;
-
-	// create actual logical ops for setops
-	LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_INVALID;
-	switch (node.setop_type) {
-	case SetOperationType::UNION:
-	case SetOperationType::UNION_BY_NAME:
-		logical_type = LogicalOperatorType::LOGICAL_UNION;
-		break;
-	case SetOperationType::EXCEPT:
-		logical_type = LogicalOperatorType::LOGICAL_EXCEPT;
-		break;
-	case SetOperationType::INTERSECT:
-		logical_type = LogicalOperatorType::LOGICAL_INTERSECT;
-		break;
-	default:
-		D_ASSERT(false);
-		break;
-	}
-
-	auto root = make_uniq<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
-	                                           std::move(right_node), logical_type, node.setop_all);
-
-	return VisitQueryNode(node, std::move(root));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp b/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp
deleted file mode 100644
index 1e1c06c1e..000000000
--- a/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp
+++ /dev/null
@@ -1,525 +0,0 @@
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/planner/operator/logical_window.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/planner/subquery/flatten_dependent_join.hpp"
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
-#include "duckdb/planner/subquery/recursive_dependent_join_planner.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-
-namespace duckdb {
-
-static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubqueryExpression &expr,
-                                                       unique_ptr<LogicalOperator> &root,
-                                                       unique_ptr<LogicalOperator> plan) {
-	D_ASSERT(!expr.IsCorrelated());
-	switch (expr.subquery_type) {
-	case SubqueryType::EXISTS: {
-		// uncorrelated EXISTS
-		// we only care about existence, hence we push a LIMIT 1 operator
-		auto limit = make_uniq<LogicalLimit>(BoundLimitNode::ConstantValue(1), BoundLimitNode());
-		limit->AddChild(std::move(plan));
-		plan = std::move(limit);
-
-		// now we push a COUNT(*) aggregate onto the limit, this will be either 0 or 1 (EXISTS or NOT EXISTS)
-		auto count_star_fun = CountStarFun::GetFunction();
-
-		FunctionBinder function_binder(binder);
-		auto count_star =
-		    function_binder.BindAggregateFunction(count_star_fun, {}, nullptr, AggregateType::NON_DISTINCT);
-		auto idx_type = count_star->return_type;
-		vector<unique_ptr<Expression>> aggregate_list;
-		aggregate_list.push_back(std::move(count_star));
-		auto aggregate_index = binder.GenerateTableIndex();
-		auto aggregate =
-		    make_uniq<LogicalAggregate>(binder.GenerateTableIndex(), aggregate_index, std::move(aggregate_list));
-		aggregate->AddChild(std::move(plan));
-		plan = std::move(aggregate);
-
-		// now we push a projection with a comparison to 1
-		auto left_child = make_uniq<BoundColumnRefExpression>(idx_type, ColumnBinding(aggregate_index, 0));
-		auto right_child = make_uniq<BoundConstantExpression>(Value::Numeric(idx_type, 1));
-		auto comparison = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left_child),
-		                                                       std::move(right_child));
-
-		vector<unique_ptr<Expression>> projection_list;
-		projection_list.push_back(std::move(comparison));
-		auto projection_index = binder.GenerateTableIndex();
-		auto projection = make_uniq<LogicalProjection>(projection_index, std::move(projection_list));
-		projection->AddChild(std::move(plan));
-		plan = std::move(projection);
-
-		// we add it to the main query by adding a cross product
-		// FIXME: should use something else besides cross product as we always add only one scalar constant
-		root = LogicalCrossProduct::Create(std::move(root), std::move(plan));
-
-		// we replace the original subquery with a ColumnRefExpression referring to the result of the projection (either
-		// TRUE or FALSE)
-		return make_uniq<BoundColumnRefExpression>(expr.GetName(), LogicalType::BOOLEAN,
-		                                           ColumnBinding(projection_index, 0));
-	}
-	case SubqueryType::SCALAR: {
-		// uncorrelated scalar, we want to return the first entry
-		// figure out the table index of the bound table of the entry which we want to return
-		auto bindings = plan->GetColumnBindings();
-		D_ASSERT(bindings.size() == 1);
-		idx_t table_idx = bindings[0].table_index;
-
-		auto &config = ClientConfig::GetConfig(binder.context);
-		bool error_on_multiple_rows = config.scalar_subquery_error_on_multiple_rows;
-
-		// we push an aggregate that returns the FIRST element
-		vector<unique_ptr<Expression>> expressions;
-		auto bound = make_uniq<BoundColumnRefExpression>(expr.return_type, ColumnBinding(table_idx, 0));
-		vector<unique_ptr<Expression>> first_children;
-		first_children.push_back(std::move(bound));
-
-		FunctionBinder function_binder(binder);
-		auto first_agg =
-		    function_binder.BindAggregateFunction(FirstFunctionGetter::GetFunction(expr.return_type),
-		                                          std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
-
-		expressions.push_back(std::move(first_agg));
-		if (error_on_multiple_rows) {
-			vector<unique_ptr<Expression>> count_children;
-			auto count_agg = function_binder.BindAggregateFunction(
-			    CountStarFun::GetFunction(), std::move(count_children), nullptr, AggregateType::NON_DISTINCT);
-			expressions.push_back(std::move(count_agg));
-		}
-		auto aggr_index = binder.GenerateTableIndex();
-
-		auto aggr = make_uniq<LogicalAggregate>(binder.GenerateTableIndex(), aggr_index, std::move(expressions));
-		aggr->AddChild(std::move(plan));
-		plan = std::move(aggr);
-
-		if (error_on_multiple_rows) {
-			// CASE WHEN count > 1 THEN error('Scalar subquery can only return a single row') ELSE first_agg END
-			idx_t proj_index = binder.GenerateTableIndex();
-
-			auto first_ref =
-			    make_uniq<BoundColumnRefExpression>(plan->expressions[0]->return_type, ColumnBinding(aggr_index, 0));
-			auto count_ref =
-			    make_uniq<BoundColumnRefExpression>(plan->expressions[1]->return_type, ColumnBinding(aggr_index, 1));
-
-			auto constant_one = make_uniq<BoundConstantExpression>(Value::BIGINT(1));
-			auto count_check = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHAN,
-			                                                        std::move(count_ref), std::move(constant_one));
-
-			vector<unique_ptr<Expression>> error_children;
-			error_children.push_back(make_uniq<BoundConstantExpression>(
-			    Value("More than one row returned by a subquery used as an expression - scalar subqueries can only "
-			          "return a single row.\n\nUse \"SET scalar_subquery_error_on_multiple_rows=false\" to revert to "
-			          "previous behavior of returning a random row.")));
-			auto error_expr = function_binder.BindScalarFunction(ErrorFun::GetFunction(), std::move(error_children));
-			error_expr->return_type = first_ref->return_type;
-			auto case_expr =
-			    make_uniq<BoundCaseExpression>(std::move(count_check), std::move(error_expr), std::move(first_ref));
-
-			vector<unique_ptr<Expression>> proj_expressions;
-			proj_expressions.push_back(std::move(case_expr));
-
-			auto proj = make_uniq<LogicalProjection>(proj_index, std::move(proj_expressions));
-			proj->AddChild(std::move(plan));
-			plan = std::move(proj);
-
-			aggr_index = proj_index;
-		}
-
-		// in the uncorrelated case, we add the value to the main query through a cross product
-		// FIXME: should use something else besides cross product as we always add only one scalar constant and cross
-		// product is not optimized for this.
-		D_ASSERT(root);
-		root = LogicalCrossProduct::Create(std::move(root), std::move(plan));
-
-		// we replace the original subquery with a BoundColumnRefExpression referring to the first result of the
-		// aggregation
-		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(aggr_index, 0));
-	}
-	default: {
-		D_ASSERT(expr.subquery_type == SubqueryType::ANY);
-		// we generate a MARK join that results in either (TRUE, FALSE or NULL)
-		// subquery has NULL values -> result is (TRUE or NULL)
-		// subquery has no NULL values -> result is (TRUE, FALSE or NULL [if input is NULL])
-		// fetch the column bindings
-		auto plan_columns = plan->GetColumnBindings();
-
-		// then we generate the MARK join with the subquery
-		idx_t mark_index = binder.GenerateTableIndex();
-		auto join = make_uniq<LogicalComparisonJoin>(JoinType::MARK);
-		join->mark_index = mark_index;
-		join->AddChild(std::move(root));
-		join->AddChild(std::move(plan));
-		// create the JOIN condition
-		for (idx_t child_idx = 0; child_idx < expr.children.size(); child_idx++) {
-			JoinCondition cond;
-			cond.left = std::move(expr.children[child_idx]);
-			auto &child_type = expr.child_types[child_idx];
-			cond.right = BoundCastExpression::AddDefaultCastToType(
-			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), expr.child_target);
-			cond.comparison = expr.comparison_type;
-			join->conditions.push_back(std::move(cond));
-		}
-		root = std::move(join);
-
-		// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
-		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
-	}
-	}
-}
-
-static unique_ptr<LogicalComparisonJoin>
-CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_columns, JoinType join_type,
-                              unique_ptr<LogicalOperator> original_plan, bool perform_delim) {
-	auto delim_join = make_uniq<LogicalComparisonJoin>(join_type, LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	if (!perform_delim) {
-		// if we are not performing a delim join, we push a row_number() OVER() window operator on the LHS
-		// and perform all duplicate elimination on that row number instead
-		D_ASSERT(correlated_columns[0].type.id() == LogicalTypeId::BIGINT);
-		auto window = make_uniq<LogicalWindow>(correlated_columns[0].binding.table_index);
-		auto row_number =
-		    make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT, nullptr, nullptr);
-		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
-		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
-		row_number->SetAlias("delim_index");
-		window->expressions.push_back(std::move(row_number));
-		window->AddChild(std::move(original_plan));
-		original_plan = std::move(window);
-	}
-	delim_join->AddChild(std::move(original_plan));
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		auto &col = correlated_columns[i];
-		delim_join->duplicate_eliminated_columns.push_back(make_uniq<BoundColumnRefExpression>(col.type, col.binding));
-		delim_join->mark_types.push_back(col.type);
-	}
-	return delim_join;
-}
-
-static void CreateDelimJoinConditions(LogicalComparisonJoin &delim_join,
-                                      const vector<CorrelatedColumnInfo> &correlated_columns,
-                                      vector<ColumnBinding> bindings, idx_t base_offset, bool perform_delim) {
-	auto col_count = perform_delim ? correlated_columns.size() : 1;
-	for (idx_t i = 0; i < col_count; i++) {
-		auto &col = correlated_columns[i];
-		auto binding_idx = base_offset + i;
-		if (binding_idx >= bindings.size()) {
-			throw InternalException("Delim join - binding index out of range");
-		}
-		JoinCondition cond;
-		cond.left = make_uniq<BoundColumnRefExpression>(col.name, col.type, col.binding);
-		cond.right = make_uniq<BoundColumnRefExpression>(col.name, col.type, bindings[binding_idx]);
-		cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-		delim_join.conditions.push_back(std::move(cond));
-	}
-}
-
-static bool PerformDelimOnType(const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::LIST) {
-		return false;
-	}
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		for (auto &entry : StructType::GetChildTypes(type)) {
-			if (!PerformDelimOnType(entry.second)) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnInfo> &correlated_columns) {
-	if (!ClientConfig::GetConfig(binder.context).enable_optimizer) {
-		// if optimizations are disabled we always do a delim join
-		return true;
-	}
-	bool perform_delim = true;
-	for (auto &col : correlated_columns) {
-		if (!PerformDelimOnType(col.type)) {
-			perform_delim = false;
-			break;
-		}
-	}
-	if (perform_delim) {
-		return true;
-	}
-	auto binding = ColumnBinding(binder.GenerateTableIndex(), 0);
-	auto type = LogicalType::BIGINT;
-	auto name = "delim_index";
-	CorrelatedColumnInfo info(binding, type, name, 0);
-	correlated_columns.insert(correlated_columns.begin(), std::move(info));
-	return false;
-}
-
-static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubqueryExpression &expr,
-                                                     unique_ptr<LogicalOperator> &root,
-                                                     unique_ptr<LogicalOperator> plan) {
-	auto &correlated_columns = expr.binder->correlated_columns;
-	// FIXME: there should be a way of disabling decorrelation for ANY queries as well, but not for now...
-	bool perform_delim =
-	    expr.subquery_type == SubqueryType::ANY ? true : PerformDuplicateElimination(binder, correlated_columns);
-	D_ASSERT(expr.IsCorrelated());
-	// correlated subquery
-	// for a more in-depth explanation of this code, read the paper "Unnesting Arbitrary Subqueries"
-	// we handle three types of correlated subqueries: Scalar, EXISTS and ANY
-	// all three cases are very similar with some minor changes (mainly the type of join performed at the end)
-	switch (expr.subquery_type) {
-	case SubqueryType::SCALAR: {
-		// correlated SCALAR query
-		// first push a DUPLICATE ELIMINATED join
-		// a duplicate eliminated join creates a duplicate eliminated copy of the LHS
-		// and pushes it into any DUPLICATE_ELIMINATED SCAN operators on the RHS
-
-		// in the SCALAR case, we create a SINGLE join (because we are only interested in obtaining the value)
-		// NULL values are equal in this join because we join on the correlated columns ONLY
-		// and e.g. in the query: SELECT (SELECT 42 FROM integers WHERE i1.i IS NULL LIMIT 1) FROM integers i1;
-		// the input value NULL will generate the value 42, and we need to join NULL on the LHS with NULL on the RHS
-		// the left side is the original plan
-		// this is the side that will be duplicate eliminated and pushed into the RHS
-		auto delim_join =
-		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::SINGLE, std::move(root), perform_delim);
-
-		// the right side initially is a DEPENDENT join between the duplicate eliminated scan and the subquery
-		// HOWEVER: we do not explicitly create the dependent join
-		// instead, we eliminate the dependent join by pushing it down into the right side of the plan
-		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim);
-
-		// first we check which logical operators have correlated expressions in the first place
-		flatten.DetectCorrelatedExpressions(*plan);
-		// now we push the dependent join down
-		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
-
-		// now the dependent join is fully eliminated
-		// we only need to create the join conditions between the LHS and the RHS
-		// fetch the set of columns
-		auto plan_columns = dependent_join->GetColumnBindings();
-
-		// now create the join conditions
-		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		delim_join->AddChild(std::move(dependent_join));
-		root = std::move(delim_join);
-		// finally push the BoundColumnRefExpression referring to the data element returned by the join
-		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, plan_columns[flatten.data_offset]);
-	}
-	case SubqueryType::EXISTS: {
-		// correlated EXISTS query
-		// this query is similar to the correlated SCALAR query, except we use a MARK join here
-		idx_t mark_index = binder.GenerateTableIndex();
-		auto delim_join =
-		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, std::move(root), perform_delim);
-		delim_join->mark_index = mark_index;
-		// RHS
-		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim, true);
-		flatten.DetectCorrelatedExpressions(*plan);
-		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
-
-		// fetch the set of columns
-		auto plan_columns = dependent_join->GetColumnBindings();
-
-		// now we create the join conditions between the dependent join and the original table
-		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		delim_join->AddChild(std::move(dependent_join));
-		root = std::move(delim_join);
-		// finally push the BoundColumnRefExpression referring to the marker
-		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
-	}
-	default: {
-		D_ASSERT(expr.subquery_type == SubqueryType::ANY);
-		// correlated ANY query
-		// this query is similar to the correlated SCALAR query
-		// however, in this case we push a correlated MARK join
-		// note that in this join null values are NOT equal for ALL columns, but ONLY for the correlated columns
-		// the correlated mark join handles this case by itself
-		// as the MARK join has one extra join condition (the original condition, of the ANY expression, e.g.
-		// [i=ANY(...)])
-		idx_t mark_index = binder.GenerateTableIndex();
-		auto delim_join =
-		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, std::move(root), perform_delim);
-		delim_join->mark_index = mark_index;
-		// RHS
-		FlattenDependentJoins flatten(binder, correlated_columns, true, true);
-		flatten.DetectCorrelatedExpressions(*plan);
-		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
-
-		// fetch the columns
-		auto plan_columns = dependent_join->GetColumnBindings();
-
-		// now we create the join conditions between the dependent join and the original table
-		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		if (expr.children.size() > 1) {
-			// FIXME: the code to generate the plan here is actually correct
-			// the problem is in the hash join - specifically PhysicalHashJoin::InitializeHashTable
-			// this contains code that is hard-coded for a single comparison
-			// -> (delim_types.size() + 1 == conditions.size())
-			// this needs to be generalized to get this to work
-			throw NotImplementedException("Correlated IN/ANY/ALL with multiple columns not yet supported");
-		}
-		// add the actual condition based on the ANY/ALL predicate
-		for (idx_t child_idx = 0; child_idx < expr.children.size(); child_idx++) {
-			JoinCondition compare_cond;
-			compare_cond.left = std::move(expr.children[child_idx]);
-			auto &child_type = expr.child_types[child_idx];
-			compare_cond.right = BoundCastExpression::AddDefaultCastToType(
-			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), expr.child_target);
-			compare_cond.comparison = expr.comparison_type;
-			delim_join->conditions.push_back(std::move(compare_cond));
-		}
-
-		delim_join->AddChild(std::move(dependent_join));
-		root = std::move(delim_join);
-		// finally push the BoundColumnRefExpression referring to the marker
-		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
-	}
-	}
-}
-
-void RecursiveDependentJoinPlanner::VisitOperator(LogicalOperator &op) {
-	if (!op.children.empty()) {
-		// Collect all recursive CTEs during recursive descend
-		if (op.type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
-			auto &rec_cte = op.Cast<LogicalRecursiveCTE>();
-			binder.recursive_ctes[rec_cte.table_index] = &op;
-		}
-		root = std::move(op.children[0]);
-		D_ASSERT(root);
-		if (root->type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
-			// Found a dependent join, flatten it
-			auto &new_root = root->Cast<LogicalDependentJoin>();
-			root = binder.PlanLateralJoin(std::move(new_root.children[0]), std::move(new_root.children[1]),
-			                              new_root.correlated_columns, new_root.join_type,
-			                              std::move(new_root.join_condition));
-		}
-		VisitOperatorExpressions(op);
-		op.children[0] = std::move(root);
-		for (idx_t i = 0; i < op.children.size(); i++) {
-			D_ASSERT(op.children[i]);
-			VisitOperator(*op.children[i]);
-		}
-	}
-}
-
-unique_ptr<Expression> RecursiveDependentJoinPlanner::VisitReplace(BoundSubqueryExpression &expr,
-                                                                   unique_ptr<Expression> *expr_ptr) {
-	return binder.PlanSubquery(expr, root);
-}
-
-unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root) {
-	D_ASSERT(root);
-	// first we translate the QueryNode of the subquery into a logical plan
-	// note that we do not plan nested subqueries yet
-	auto sub_binder = Binder::CreateBinder(context, this);
-	sub_binder->is_outside_flattened = false;
-	auto subquery_root = sub_binder->CreatePlan(*expr.subquery);
-	D_ASSERT(subquery_root);
-
-	// now we actually flatten the subquery
-	auto plan = std::move(subquery_root);
-
-	unique_ptr<Expression> result_expression;
-	if (!expr.IsCorrelated()) {
-		result_expression = PlanUncorrelatedSubquery(*this, expr, root, std::move(plan));
-	} else {
-		result_expression = PlanCorrelatedSubquery(*this, expr, root, std::move(plan));
-	}
-	// finally, we recursively plan the nested subqueries (if there are any)
-	if (sub_binder->has_unplanned_dependent_joins) {
-		RecursiveDependentJoinPlanner plan(*this);
-		plan.VisitOperator(*root);
-	}
-	return result_expression;
-}
-
-void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<LogicalOperator> &root) {
-	if (!expr_ptr) {
-		return;
-	}
-	auto &expr = *expr_ptr;
-	// first visit the children of the node, if any
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
-
-	// check if this is a subquery node
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
-		auto &subquery = expr.Cast<BoundSubqueryExpression>();
-		// subquery node! plan it
-		if (!is_outside_flattened) {
-			// detected a nested correlated subquery
-			// we don't plan it yet here, we are currently planning a subquery
-			// nested subqueries will only be planned AFTER the current subquery has been flattened entirely
-			has_unplanned_dependent_joins = true;
-			return;
-		}
-		expr_ptr = PlanSubquery(subquery, root);
-	}
-}
-
-unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-                                                    vector<CorrelatedColumnInfo> &correlated, JoinType join_type,
-                                                    unique_ptr<Expression> condition) {
-	// scan the right operator for correlated columns
-	// correlated LATERAL JOIN
-	vector<JoinCondition> conditions;
-	vector<unique_ptr<Expression>> arbitrary_expressions;
-	if (condition) {
-		if (condition->HasSubquery()) {
-			throw BinderException(*condition, "Subqueries are not supported in LATERAL join conditions");
-		}
-		// extract join conditions, if there are any
-		LogicalComparisonJoin::ExtractJoinConditions(context, join_type, JoinRefType::REGULAR, left, right,
-		                                             std::move(condition), conditions, arbitrary_expressions);
-	}
-
-	auto perform_delim = PerformDuplicateElimination(*this, correlated);
-	auto delim_join = CreateDuplicateEliminatedJoin(correlated, join_type, std::move(left), perform_delim);
-
-	FlattenDependentJoins flatten(*this, correlated, perform_delim);
-
-	// first we check which logical operators have correlated expressions in the first place
-	flatten.DetectCorrelatedExpressions(*right, true);
-	// now we push the dependent join down
-	auto dependent_join = flatten.PushDownDependentJoin(std::move(right), join_type != JoinType::INNER);
-
-	// now the dependent join is fully eliminated
-	// we only need to create the join conditions between the LHS and the RHS
-	// fetch the set of columns
-	auto plan_columns = dependent_join->GetColumnBindings();
-
-	// in case of a materialized CTE, the output is defined by the second children operator
-	if (dependent_join->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
-		plan_columns = dependent_join->children[1]->GetColumnBindings();
-	}
-
-	// now create the join conditions
-	// start off with the conditions that were passed in (if any)
-	D_ASSERT(delim_join->conditions.empty());
-	delim_join->conditions = std::move(conditions);
-	// then add the delim join conditions
-	CreateDelimJoinConditions(*delim_join, correlated, plan_columns, flatten.delim_offset, perform_delim);
-	delim_join->AddChild(std::move(dependent_join));
-
-	// check if there are any arbitrary expressions left
-	if (!arbitrary_expressions.empty()) {
-		// we can only evaluate scalar arbitrary expressions for inner joins
-		if (join_type != JoinType::INNER) {
-			throw BinderException(
-			    "Join condition for non-inner LATERAL JOIN must be a comparison between the left and right side");
-		}
-		auto filter = make_uniq<LogicalFilter>();
-		filter->expressions = std::move(arbitrary_expressions);
-		filter->AddChild(std::move(delim_join));
-		return std::move(filter);
-	}
-	return std::move(delim_join);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_attach.cpp b/src/duckdb/src/planner/binder/statement/bind_attach.cpp
deleted file mode 100644
index 480324161..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_attach.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/attach_statement.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/tableref/bound_table_function.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(AttachStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ATTACH, std::move(stmt.info));
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_call.cpp b/src/duckdb/src/planner/binder/statement/bind_call.cpp
deleted file mode 100644
index ba96927e8..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_call.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/parser/statement/call_statement.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/tableref/bound_table_function.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(CallStatement &stmt) {
-	SelectStatement select_statement;
-	auto select_node = make_uniq<SelectNode>();
-	auto table_function = make_uniq<TableFunctionRef>();
-	table_function->function = std::move(stmt.function);
-	select_node->select_list.push_back(make_uniq<StarExpression>());
-	select_node->from_table = std::move(table_function);
-	select_statement.node = std::move(select_node);
-
-	auto result = Bind(select_statement);
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_copy.cpp b/src/duckdb/src/planner/binder/statement/bind_copy.cpp
deleted file mode 100644
index ce2f93ad8..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_copy.cpp
+++ /dev/null
@@ -1,359 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/bind_helpers.hpp"
-#include "duckdb/common/filename_pattern.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_copy_to_file.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_insert.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-static bool GetBooleanArg(ClientContext &context, const vector<Value> &arg) {
-	return arg.empty() || arg[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
-}
-
-BoundStatement Binder::BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type) {
-	// lookup the format in the catalog
-	auto &copy_function =
-	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (copy_function.function.plan) {
-		// plan rewrite COPY TO
-		return copy_function.function.plan(*this, stmt);
-	}
-
-	auto &copy_info = *stmt.info;
-	// bind the select statement
-	auto node_copy = copy_info.select_statement->Copy();
-	auto select_node = Bind(*node_copy);
-
-	if (!copy_function.function.copy_to_bind) {
-		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
-	}
-
-	bool use_tmp_file = true;
-	CopyOverwriteMode overwrite_mode = CopyOverwriteMode::COPY_ERROR_ON_CONFLICT;
-	FilenamePattern filename_pattern;
-	bool user_set_use_tmp_file = false;
-	bool per_thread_output = false;
-	optional_idx file_size_bytes;
-	vector<idx_t> partition_cols;
-	bool seen_overwrite_mode = false;
-	bool seen_filepattern = false;
-	bool write_partition_columns = false;
-	CopyFunctionReturnType return_type = CopyFunctionReturnType::CHANGED_ROWS;
-
-	CopyFunctionBindInput bind_input(*stmt.info);
-
-	bind_input.file_extension = copy_function.function.extension;
-
-	auto original_options = stmt.info->options;
-	stmt.info->options.clear();
-	for (auto &option : original_options) {
-		auto loption = StringUtil::Lower(option.first);
-		if (loption == "use_tmp_file") {
-			use_tmp_file = GetBooleanArg(context, option.second);
-			user_set_use_tmp_file = true;
-		} else if (loption == "overwrite_or_ignore" || loption == "overwrite" || loption == "append") {
-			if (seen_overwrite_mode) {
-				throw BinderException("Can only set one of OVERWRITE_OR_IGNORE, OVERWRITE or APPEND");
-			}
-			seen_overwrite_mode = true;
-
-			auto boolean = GetBooleanArg(context, option.second);
-			if (boolean) {
-				if (loption == "overwrite_or_ignore") {
-					overwrite_mode = CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE;
-				} else if (loption == "overwrite") {
-					overwrite_mode = CopyOverwriteMode::COPY_OVERWRITE;
-				} else if (loption == "append") {
-					if (!seen_filepattern) {
-						filename_pattern.SetFilenamePattern("{uuid}");
-					}
-					overwrite_mode = CopyOverwriteMode::COPY_APPEND;
-				}
-			}
-		} else if (loption == "filename_pattern") {
-			if (option.second.empty()) {
-				throw IOException("FILENAME_PATTERN cannot be empty");
-			}
-			filename_pattern.SetFilenamePattern(
-			    option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue<string>());
-			seen_filepattern = true;
-		} else if (loption == "file_extension") {
-			if (option.second.empty()) {
-				throw IOException("FILE_EXTENSION cannot be empty");
-			}
-			bind_input.file_extension = option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue<string>();
-		} else if (loption == "per_thread_output") {
-			per_thread_output = GetBooleanArg(context, option.second);
-		} else if (loption == "file_size_bytes") {
-			if (option.second.empty()) {
-				throw BinderException("FILE_SIZE_BYTES cannot be empty");
-			}
-			if (!copy_function.function.rotate_files) {
-				throw NotImplementedException("FILE_SIZE_BYTES not implemented for FORMAT \"%s\"", stmt.info->format);
-			}
-			if (option.second[0].GetTypeMutable().id() == LogicalTypeId::VARCHAR) {
-				file_size_bytes = DBConfig::ParseMemoryLimit(option.second[0].ToString());
-			} else {
-				file_size_bytes = option.second[0].GetValue<uint64_t>();
-			}
-		} else if (loption == "partition_by") {
-			auto converted = ConvertVectorToValue(std::move(option.second));
-			partition_cols = ParseColumnsOrdered(converted, select_node.names, loption);
-		} else if (loption == "return_files") {
-			if (GetBooleanArg(context, option.second)) {
-				return_type = CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST;
-			}
-		} else if (loption == "write_partition_columns") {
-			write_partition_columns = GetBooleanArg(context, option.second);
-		} else {
-			stmt.info->options[option.first] = option.second;
-		}
-	}
-	if (overwrite_mode == CopyOverwriteMode::COPY_APPEND && !filename_pattern.HasUUID()) {
-		throw BinderException("APPEND mode requires a {uuid} label in filename_pattern");
-	}
-	if (user_set_use_tmp_file && per_thread_output) {
-		throw NotImplementedException("Can't combine USE_TMP_FILE and PER_THREAD_OUTPUT for COPY");
-	}
-	if (user_set_use_tmp_file && file_size_bytes.IsValid()) {
-		throw NotImplementedException("Can't combine USE_TMP_FILE and FILE_SIZE_BYTES for COPY");
-	}
-	if (user_set_use_tmp_file && !partition_cols.empty()) {
-		throw NotImplementedException("Can't combine USE_TMP_FILE and PARTITION_BY for COPY");
-	}
-	if (per_thread_output && !partition_cols.empty()) {
-		throw NotImplementedException("Can't combine PER_THREAD_OUTPUT and PARTITION_BY for COPY");
-	}
-	if (file_size_bytes.IsValid() && !partition_cols.empty()) {
-		throw NotImplementedException("Can't combine FILE_SIZE_BYTES and PARTITION_BY for COPY");
-	}
-	if (!write_partition_columns) {
-		if (partition_cols.size() == select_node.names.size()) {
-			throw NotImplementedException("No column to write as all columns are specified as partition columns. "
-			                              "WRITE_PARTITION_COLUMNS option can be used to write partition columns.");
-		}
-	}
-	bool is_remote_file = FileSystem::IsRemoteFile(stmt.info->file_path);
-	if (is_remote_file) {
-		use_tmp_file = false;
-	} else {
-		auto &fs = FileSystem::GetFileSystem(context);
-		bool is_file_and_exists = fs.FileExists(stmt.info->file_path);
-		bool is_stdout = stmt.info->file_path == "/dev/stdout";
-		if (!user_set_use_tmp_file) {
-			use_tmp_file = is_file_and_exists && !per_thread_output && partition_cols.empty() && !is_stdout;
-		}
-	}
-
-	// Allow the copy function to intercept the select list and types and push a new projection on top of the plan
-	if (copy_function.function.copy_to_select) {
-		auto bindings = select_node.plan->GetColumnBindings();
-
-		CopyToSelectInput input = {context, stmt.info->options, {}, copy_to_type};
-		input.select_list.reserve(bindings.size());
-
-		// Create column references for the select list
-		for (idx_t i = 0; i < bindings.size(); i++) {
-			auto &binding = bindings[i];
-			auto &name = select_node.names[i];
-			auto &type = select_node.types[i];
-			input.select_list.push_back(make_uniq<BoundColumnRefExpression>(name, type, binding));
-		}
-
-		auto new_select_list = copy_function.function.copy_to_select(input);
-		if (!new_select_list.empty()) {
-
-			// We have a new select list, create a projection on top of the current plan
-			auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(new_select_list));
-			projection->children.push_back(std::move(select_node.plan));
-			projection->ResolveOperatorTypes();
-
-			// Update the names and types of the select node
-			select_node.names.clear();
-			select_node.types.clear();
-			for (auto &expr : projection->expressions) {
-				select_node.names.push_back(expr->GetName());
-				select_node.types.push_back(expr->return_type);
-			}
-			select_node.plan = std::move(projection);
-		}
-	}
-
-	auto unique_column_names = select_node.names;
-	QueryResult::DeduplicateColumns(unique_column_names);
-	auto file_path = stmt.info->file_path;
-
-	auto names_to_write =
-	    LogicalCopyToFile::GetNamesWithoutPartitions(unique_column_names, partition_cols, write_partition_columns);
-	auto types_to_write =
-	    LogicalCopyToFile::GetTypesWithoutPartitions(select_node.types, partition_cols, write_partition_columns);
-	auto function_data = copy_function.function.copy_to_bind(context, bind_input, names_to_write, types_to_write);
-
-	const auto rotate =
-	    copy_function.function.rotate_files && copy_function.function.rotate_files(*function_data, file_size_bytes);
-	if (rotate) {
-		if (!copy_function.function.rotate_next_file) {
-			throw InternalException("rotate_next_file not implemented for \"%s\"", copy_function.function.extension);
-		}
-		if (user_set_use_tmp_file) {
-			throw NotImplementedException(
-			    "Can't combine USE_TMP_FILE and file rotation (e.g., ROW_GROUPS_PER_FILE) for COPY");
-		}
-		if (!partition_cols.empty()) {
-			throw NotImplementedException(
-			    "Can't combine file rotation (e.g., ROW_GROUPS_PER_FILE) and PARTITION_BY for COPY");
-		}
-	}
-
-	// now create the copy information
-	auto copy = make_uniq<LogicalCopyToFile>(copy_function.function, std::move(function_data), std::move(stmt.info));
-	copy->file_path = file_path;
-	copy->use_tmp_file = use_tmp_file;
-	copy->overwrite_mode = overwrite_mode;
-	copy->filename_pattern = filename_pattern;
-	copy->file_extension = bind_input.file_extension;
-	copy->per_thread_output = per_thread_output;
-	if (file_size_bytes.IsValid()) {
-		copy->file_size_bytes = file_size_bytes;
-	}
-	copy->rotate = rotate;
-	copy->partition_output = !partition_cols.empty();
-	copy->write_partition_columns = write_partition_columns;
-	copy->partition_columns = std::move(partition_cols);
-	copy->return_type = return_type;
-
-	copy->names = unique_column_names;
-	copy->expected_types = select_node.types;
-
-	copy->AddChild(std::move(select_node.plan));
-
-	auto &properties = GetStatementProperties();
-	switch (copy->return_type) {
-	case CopyFunctionReturnType::CHANGED_ROWS:
-		properties.return_type = StatementReturnType::CHANGED_ROWS;
-		break;
-	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST:
-		properties.return_type = StatementReturnType::QUERY_RESULT;
-		break;
-	default:
-		throw NotImplementedException("Unknown CopyFunctionReturnType");
-	}
-
-	BoundStatement result;
-	result.names = GetCopyFunctionReturnNames(copy->return_type);
-	result.types = GetCopyFunctionReturnLogicalTypes(copy->return_type);
-	result.plan = std::move(copy);
-
-	return result;
-}
-
-BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BIGINT};
-	result.names = {"Count"};
-
-	if (stmt.info->table.empty()) {
-		throw ParserException("COPY FROM requires a table name to be specified");
-	}
-	// COPY FROM a file
-	// generate an insert statement for the to-be-inserted table
-	InsertStatement insert;
-	insert.table = stmt.info->table;
-	insert.schema = stmt.info->schema;
-	insert.catalog = stmt.info->catalog;
-	insert.columns = stmt.info->select_list;
-
-	// bind the insert statement to the base table
-	auto insert_statement = Bind(insert);
-	D_ASSERT(insert_statement.plan->type == LogicalOperatorType::LOGICAL_INSERT);
-
-	auto &bound_insert = insert_statement.plan->Cast<LogicalInsert>();
-
-	// lookup the format in the catalog
-	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto &copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function.function.copy_from_bind) {
-		throw NotImplementedException("COPY FROM is not supported for FORMAT \"%s\"", stmt.info->format);
-	}
-	// lookup the table to copy into
-	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-	auto &table =
-	    Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
-	vector<string> expected_names;
-	if (!bound_insert.column_index_map.empty()) {
-		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table.GetColumns().Physical()) {
-			auto i = col.Physical();
-			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
-				expected_names[bound_insert.column_index_map[i]] = col.Name();
-			}
-		}
-	} else {
-		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table.GetColumns().Physical()) {
-			expected_names.push_back(col.Name());
-		}
-	}
-
-	auto function_data =
-	    copy_function.function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
-	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function.function.copy_from_function,
-	                                 std::move(function_data), bound_insert.expected_types, expected_names);
-	for (idx_t i = 0; i < bound_insert.expected_types.size(); i++) {
-		get->AddColumnId(i);
-	}
-	insert_statement.plan->children.push_back(std::move(get));
-	result.plan = std::move(insert_statement.plan);
-	return result;
-}
-
-BoundStatement Binder::Bind(CopyStatement &stmt, CopyToType copy_to_type) {
-	if (!stmt.info->is_from && !stmt.info->select_statement) {
-		// copy table into file without a query
-		// generate SELECT * FROM table;
-		auto ref = make_uniq<BaseTableRef>();
-		ref->catalog_name = stmt.info->catalog;
-		ref->schema_name = stmt.info->schema;
-		ref->table_name = stmt.info->table;
-
-		auto statement = make_uniq<SelectNode>();
-		statement->from_table = std::move(ref);
-		if (!stmt.info->select_list.empty()) {
-			for (auto &name : stmt.info->select_list) {
-				statement->select_list.push_back(make_uniq<ColumnRefExpression>(name));
-			}
-		} else {
-			statement->select_list.push_back(make_uniq<StarExpression>());
-		}
-		stmt.info->select_statement = std::move(statement);
-	}
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::CHANGED_ROWS;
-	if (stmt.info->is_from) {
-		return BindCopyFrom(stmt);
-	} else {
-		return BindCopyTo(stmt, copy_to_type);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_copy_database.cpp b/src/duckdb/src/planner/binder/statement/bind_copy_database.cpp
deleted file mode 100644
index f05445e90..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_copy_database.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/parser/statement/copy_database_statement.hpp"
-#include "duckdb/catalog/catalog_entry/list.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/planner/operator/logical_copy_database.hpp"
-#include "duckdb/execution/operator/persistent/physical_export.hpp"
-#include "duckdb/planner/operator/logical_create_table.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(Catalog &from_database, const string &target_database_name) {
-
-	catalog_entry_vector_t catalog_entries;
-	catalog_entries = PhysicalExport::GetNaiveExportOrder(context, from_database);
-
-	auto info = make_uniq<CopyDatabaseInfo>(target_database_name);
-	for (auto &entry : catalog_entries) {
-		auto create_info = entry.get().GetInfo();
-		create_info->catalog = target_database_name;
-		auto on_conflict = create_info->type == CatalogType::SCHEMA_ENTRY ? OnCreateConflict::IGNORE_ON_CONFLICT
-		                                                                  : OnCreateConflict::ERROR_ON_CONFLICT;
-		// Update all the dependencies of the entry to point to the newly created entries on the target database
-		LogicalDependencyList altered_dependencies;
-		for (auto &dep : create_info->dependencies.Set()) {
-			auto altered_dep = dep;
-			altered_dep.catalog = target_database_name;
-			altered_dependencies.AddDependency(altered_dep);
-		}
-		create_info->dependencies = altered_dependencies;
-		create_info->on_conflict = on_conflict;
-		info->entries.push_back(std::move(create_info));
-	}
-
-	// FIXME: copy indexes
-	return make_uniq<LogicalCopyDatabase>(std::move(info));
-}
-
-unique_ptr<LogicalOperator> Binder::BindCopyDatabaseData(Catalog &source_catalog, const string &target_database_name) {
-	auto source_schemas = source_catalog.GetSchemas(context);
-
-	// We can just use ExtractEntries here because the order doesn't matter
-	ExportEntries entries;
-	PhysicalExport::ExtractEntries(context, source_schemas, entries);
-
-	vector<unique_ptr<LogicalOperator>> insert_nodes;
-	for (auto &table_ref : entries.tables) {
-		auto &table = table_ref.get().Cast<TableCatalogEntry>();
-		// generate the insert statement
-		InsertStatement insert_stmt;
-		insert_stmt.catalog = target_database_name;
-		insert_stmt.schema = table.ParentSchema().name;
-		insert_stmt.table = table.name;
-
-		auto from_tbl = make_uniq<BaseTableRef>();
-		from_tbl->catalog_name = source_catalog.GetName();
-		from_tbl->schema_name = table.ParentSchema().name;
-		from_tbl->table_name = table.name;
-
-		auto select_node = make_uniq<SelectNode>();
-		auto &select_list = select_node->select_list;
-		for (auto &col : table.GetColumns().Physical()) {
-			select_list.push_back(make_uniq<ColumnRefExpression>(col.Name(), table.name));
-		}
-
-		select_node->from_table = std::move(from_tbl);
-
-		auto select_stmt = make_uniq<SelectStatement>();
-		select_stmt->node = std::move(select_node);
-
-		insert_stmt.select_statement = std::move(select_stmt);
-		auto bound_insert = Bind(insert_stmt);
-		auto insert_plan = std::move(bound_insert.plan);
-		insert_nodes.push_back(std::move(insert_plan));
-	}
-	unique_ptr<LogicalOperator> result;
-	if (insert_nodes.empty()) {
-		vector<LogicalType> result_types;
-		result_types.push_back(LogicalType::BIGINT);
-		vector<unique_ptr<Expression>> expression_list;
-		expression_list.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(0)));
-		vector<vector<unique_ptr<Expression>>> expressions;
-		expressions.push_back(std::move(expression_list));
-		result = make_uniq<LogicalExpressionGet>(GenerateTableIndex(), std::move(result_types), std::move(expressions));
-		result->children.push_back(make_uniq<LogicalDummyScan>(GenerateTableIndex()));
-	} else {
-		// use UNION ALL to combine the individual copy statements into a single node
-		result = UnionOperators(std::move(insert_nodes));
-	}
-	return result;
-}
-
-BoundStatement Binder::Bind(CopyDatabaseStatement &stmt) {
-	BoundStatement result;
-
-	unique_ptr<LogicalOperator> plan;
-	auto &source_catalog = Catalog::GetCatalog(context, stmt.from_database);
-	auto &target_catalog = Catalog::GetCatalog(context, stmt.to_database);
-	if (&source_catalog == &target_catalog) {
-		throw BinderException("Cannot copy from \"%s\" to \"%s\" - FROM and TO databases are the same",
-		                      stmt.from_database, stmt.to_database);
-	}
-	if (stmt.copy_type == CopyDatabaseType::COPY_SCHEMA) {
-		result.types = {LogicalType::BOOLEAN};
-		result.names = {"Success"};
-
-		plan = BindCopyDatabaseSchema(source_catalog, target_catalog.GetName());
-	} else {
-		result.types = {LogicalType::BIGINT};
-		result.names = {"Count"};
-
-		plan = BindCopyDatabaseData(source_catalog, target_catalog.GetName());
-	}
-
-	result.plan = std::move(plan);
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	properties.RegisterDBModify(target_catalog, context);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp
deleted file mode 100644
index 49c2f37b7..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_create.cpp
+++ /dev/null
@@ -1,532 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/function/scalar_macro_function.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/secret/secret_manager.hpp"
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_binder/index_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
-#include "duckdb/planner/operator/logical_create.hpp"
-#include "duckdb/planner/operator/logical_create_table.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-#include "duckdb/common/extension_type_info.hpp"
-
-namespace duckdb {
-
-void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema) {
-	if (catalog.empty() && !schema.empty()) {
-		// schema is specified - but catalog is not
-		// try searching for the catalog instead
-		auto &db_manager = DatabaseManager::Get(context);
-		auto database = db_manager.GetDatabase(context, schema);
-		if (database) {
-			// we have a database with this name
-			// check if there is a schema
-			auto &search_path = *context.client_data->catalog_search_path;
-			auto catalog_names = search_path.GetCatalogsForSchema(schema);
-			if (catalog_names.empty()) {
-				catalog_names.push_back(DatabaseManager::GetDefaultDatabase(context));
-			}
-			for (auto &catalog_name : catalog_names) {
-				auto &catalog = Catalog::GetCatalog(context, catalog_name);
-				if (catalog.CheckAmbiguousCatalogOrSchema(context, schema)) {
-					throw BinderException(
-					    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
-					    schema, catalog_name, schema);
-				}
-			}
-			catalog = schema;
-			schema = string();
-		}
-	}
-}
-
-void Binder::BindSchemaOrCatalog(string &catalog, string &schema) {
-	BindSchemaOrCatalog(context, catalog, schema);
-}
-
-const string Binder::BindCatalog(string &catalog) {
-	auto &db_manager = DatabaseManager::Get(context);
-	optional_ptr<AttachedDatabase> database = db_manager.GetDatabase(context, catalog);
-	if (database) {
-		return db_manager.GetDatabase(context, catalog).get()->GetName();
-	} else {
-		return db_manager.GetDefaultDatabase(context);
-	}
-}
-
-SchemaCatalogEntry &Binder::BindSchema(CreateInfo &info) {
-	BindSchemaOrCatalog(info.catalog, info.schema);
-	if (IsInvalidCatalog(info.catalog) && info.temporary) {
-		info.catalog = TEMP_CATALOG;
-	}
-	auto &search_path = ClientData::Get(context).catalog_search_path;
-	if (IsInvalidCatalog(info.catalog) && IsInvalidSchema(info.schema)) {
-		auto &default_entry = search_path->GetDefault();
-		info.catalog = default_entry.catalog;
-		info.schema = default_entry.schema;
-	} else if (IsInvalidSchema(info.schema)) {
-		info.schema = search_path->GetDefaultSchema(info.catalog);
-	} else if (IsInvalidCatalog(info.catalog)) {
-		info.catalog = search_path->GetDefaultCatalog(info.schema);
-	}
-	if (IsInvalidCatalog(info.catalog)) {
-		info.catalog = DatabaseManager::GetDefaultDatabase(context);
-	}
-	if (!info.temporary) {
-		// non-temporary create: not read only
-		if (info.catalog == TEMP_CATALOG) {
-			throw ParserException("Only TEMPORARY table names can use the \"%s\" catalog", TEMP_CATALOG);
-		}
-	} else {
-		if (info.catalog != TEMP_CATALOG) {
-			throw ParserException("TEMPORARY table names can *only* use the \"%s\" catalog", TEMP_CATALOG);
-		}
-	}
-	// fetch the schema in which we want to create the object
-	auto &schema_obj = Catalog::GetSchema(context, info.catalog, info.schema);
-	D_ASSERT(schema_obj.type == CatalogType::SCHEMA_ENTRY);
-	info.schema = schema_obj.name;
-	if (!info.temporary) {
-		auto &properties = GetStatementProperties();
-		properties.RegisterDBModify(schema_obj.catalog, context);
-	}
-	return schema_obj;
-}
-
-SchemaCatalogEntry &Binder::BindCreateSchema(CreateInfo &info) {
-	auto &schema = BindSchema(info);
-	if (schema.catalog.IsSystemCatalog()) {
-		throw BinderException("Cannot create entry in system catalog");
-	}
-	return schema;
-}
-
-void Binder::SetCatalogLookupCallback(catalog_entry_callback_t callback) {
-	entry_retriever.SetCallback(std::move(callback));
-}
-
-void Binder::BindCreateViewInfo(CreateViewInfo &base) {
-	// bind the view as if it were a query so we can catch errors
-	// note that we bind the original, and replace the original with a copy
-	auto view_binder = Binder::CreateBinder(context);
-	auto &dependencies = base.dependencies;
-	auto &catalog = Catalog::GetCatalog(context, base.catalog);
-
-	auto &db_config = DBConfig::GetConfig(context);
-	bool should_create_dependencies = db_config.GetSetting<EnableViewDependenciesSetting>(context);
-	if (should_create_dependencies) {
-		view_binder->SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) {
-			if (&catalog != &entry.ParentCatalog()) {
-				// Don't register dependencies between catalogs
-				return;
-			}
-			dependencies.AddDependency(entry);
-		});
-	}
-	view_binder->can_contain_nulls = true;
-
-	auto copy = base.query->Copy();
-	auto query_node = view_binder->Bind(*base.query);
-	base.query = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(copy));
-	if (base.aliases.size() > query_node.names.size()) {
-		throw BinderException("More VIEW aliases than columns in query result");
-	}
-	base.types = query_node.types;
-	base.names = query_node.names;
-}
-
-SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
-	auto &base = info.Cast<CreateMacroInfo>();
-
-	auto &dependencies = base.dependencies;
-	auto &catalog = Catalog::GetCatalog(context, info.catalog);
-	auto &db_config = DBConfig::GetConfig(context);
-	// try to bind each of the included functions
-	unordered_set<idx_t> positional_parameters;
-	for (auto &function : base.macros) {
-		auto &scalar_function = function->Cast<ScalarMacroFunction>();
-		if (scalar_function.expression->HasParameter()) {
-			throw BinderException("Parameter expressions within macro's are not supported!");
-		}
-		vector<LogicalType> dummy_types;
-		vector<string> dummy_names;
-		auto parameter_count = function->parameters.size();
-		if (positional_parameters.find(parameter_count) != positional_parameters.end()) {
-			throw BinderException(
-			    "Ambiguity in macro overloads - macro \"%s\" has multiple definitions with %llu parameters", base.name,
-			    parameter_count);
-		}
-		positional_parameters.insert(parameter_count);
-
-		// positional parameters
-		for (auto &param_expr : function->parameters) {
-			auto param = param_expr->Cast<ColumnRefExpression>();
-			if (param.IsQualified()) {
-				throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString());
-			}
-			dummy_types.emplace_back(LogicalType::UNKNOWN);
-			dummy_names.push_back(param.GetColumnName());
-		}
-		// default parameters
-		for (auto &entry : function->default_parameters) {
-			auto &val = entry.second->Cast<ConstantExpression>();
-			dummy_types.push_back(val.value.type());
-			dummy_names.push_back(entry.first);
-		}
-		auto this_macro_binding = make_uniq<DummyBinding>(dummy_types, dummy_names, base.name);
-		macro_binding = this_macro_binding.get();
-
-		// create a copy of the expression because we do not want to alter the original
-		auto expression = scalar_function.expression->Copy();
-		ExpressionBinder::QualifyColumnNames(*this, expression);
-
-		// bind it to verify the function was defined correctly
-		BoundSelectNode sel_node;
-		BoundGroupInformation group_info;
-		SelectBinder binder(*this, context, sel_node, group_info);
-		bool should_create_dependencies = db_config.GetSetting<EnableMacroDependenciesSetting>(context);
-
-		if (should_create_dependencies) {
-			binder.SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) {
-				if (&catalog != &entry.ParentCatalog()) {
-					// Don't register any cross-catalog dependencies
-					return;
-				}
-				// Register any catalog entry required to bind the macro function
-				dependencies.AddDependency(entry);
-			});
-		}
-		ErrorData error;
-		try {
-			error = binder.Bind(expression, 0, false);
-			if (error.HasError()) {
-				error.Throw();
-			}
-		} catch (const std::exception &ex) {
-			error = ErrorData(ex);
-		}
-		// if we cannot resolve parameters we postpone binding until the macro function is used
-		if (error.HasError() && error.Type() != ExceptionType::PARAMETER_NOT_RESOLVED) {
-			error.Throw();
-		}
-	}
-
-	return BindCreateSchema(info);
-}
-
-static bool IsValidUserType(optional_ptr<CatalogEntry> entry) {
-	if (!entry) {
-		return false;
-	}
-	return entry->Cast<TypeCatalogEntry>().user_type.id() != LogicalTypeId::INVALID;
-}
-
-void Binder::BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog, const string &schema) {
-	if (type.id() != LogicalTypeId::USER) {
-		// Recursive types, make sure to bind any nested user types recursively
-		auto alias = type.GetAlias();
-		auto ext_info = type.HasExtensionInfo() ? make_uniq<ExtensionTypeInfo>(*type.GetExtensionInfo()) : nullptr;
-
-		switch (type.id()) {
-		case LogicalTypeId::LIST: {
-			auto child_type = ListType::GetChildType(type);
-			BindLogicalType(child_type, catalog, schema);
-			type = LogicalType::LIST(child_type);
-		} break;
-		case LogicalTypeId::MAP: {
-			auto key_type = MapType::KeyType(type);
-			BindLogicalType(key_type, catalog, schema);
-			auto value_type = MapType::ValueType(type);
-			BindLogicalType(value_type, catalog, schema);
-			type = LogicalType::MAP(key_type, value_type);
-		} break;
-		case LogicalTypeId::ARRAY: {
-			auto child_type = ArrayType::GetChildType(type);
-			auto array_size = ArrayType::GetSize(type);
-			BindLogicalType(child_type, catalog, schema);
-			type = LogicalType::ARRAY(child_type, array_size);
-		} break;
-		case LogicalTypeId::STRUCT: {
-			auto child_types = StructType::GetChildTypes(type);
-			for (auto &child_type : child_types) {
-				BindLogicalType(child_type.second, catalog, schema);
-			}
-			type = LogicalType::STRUCT(child_types);
-		} break;
-		case LogicalTypeId::UNION: {
-			auto member_types = UnionType::CopyMemberTypes(type);
-			for (auto &member_type : member_types) {
-				BindLogicalType(member_type.second, catalog, schema);
-			}
-			type = LogicalType::UNION(member_types);
-		} break;
-		default:
-			break;
-		}
-
-		// Set the alias and extension info back
-		type.SetAlias(alias);
-		type.SetExtensionInfo(std::move(ext_info));
-
-		return;
-	}
-
-	// User type, bind the user type
-	auto user_type_name = UserType::GetTypeName(type);
-	auto user_type_schema = UserType::GetSchema(type);
-	auto user_type_mods = UserType::GetTypeModifiers(type);
-
-	bind_logical_type_function_t user_bind_modifiers_func = nullptr;
-
-	if (catalog) {
-		// The search order is:
-		// 1) In the explicitly set schema (my_schema.my_type)
-		// 2) In the same schema as the table
-		// 3) In the same catalog
-		// 4) System catalog
-
-		optional_ptr<CatalogEntry> entry = nullptr;
-		if (!user_type_schema.empty()) {
-			entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, user_type_schema, user_type_name,
-			                                 OnEntryNotFound::RETURN_NULL);
-		}
-		if (!IsValidUserType(entry)) {
-			entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, schema, user_type_name,
-			                                 OnEntryNotFound::RETURN_NULL);
-		}
-		if (!IsValidUserType(entry)) {
-			entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, INVALID_SCHEMA, user_type_name,
-			                                 OnEntryNotFound::RETURN_NULL);
-		}
-		if (!IsValidUserType(entry)) {
-			entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, INVALID_CATALOG, INVALID_SCHEMA, user_type_name,
-			                                 OnEntryNotFound::THROW_EXCEPTION);
-		}
-		auto &type_entry = entry->Cast<TypeCatalogEntry>();
-		type = type_entry.user_type;
-		user_bind_modifiers_func = type_entry.bind_function;
-	} else {
-		string type_catalog = UserType::GetCatalog(type);
-		string type_schema = UserType::GetSchema(type);
-
-		BindSchemaOrCatalog(context, type_catalog, type_schema);
-		auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, type_catalog, type_schema, user_type_name);
-		auto &type_entry = entry->Cast<TypeCatalogEntry>();
-		type = type_entry.user_type;
-		user_bind_modifiers_func = type_entry.bind_function;
-	}
-
-	// Now we bind the inner user type
-	BindLogicalType(type, catalog, schema);
-
-	// Apply the type modifiers (if any)
-	if (user_bind_modifiers_func) {
-		// If an explicit bind_modifiers function was provided, use that to construct the type
-
-		BindLogicalTypeInput input {context, type, user_type_mods};
-		type = user_bind_modifiers_func(input);
-	} else {
-		if (!user_type_mods.empty()) {
-			throw BinderException("Type '%s' does not take any type modifiers", user_type_name);
-		}
-	}
-}
-
-unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateStatement &stmt,
-                                                         TableCatalogEntry &table, unique_ptr<LogicalOperator> plan) {
-	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
-	auto create_index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(stmt.info));
-	IndexBinder index_binder(binder, binder.context);
-	return index_binder.BindCreateIndex(binder.context, std::move(create_index_info), table, std::move(plan), nullptr);
-}
-
-BoundStatement Binder::Bind(CreateStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-
-	auto catalog_type = stmt.info->type;
-	auto &properties = GetStatementProperties();
-	switch (catalog_type) {
-	case CatalogType::SCHEMA_ENTRY: {
-		auto &base = stmt.info->Cast<CreateInfo>();
-		auto catalog = BindCatalog(base.catalog);
-		properties.RegisterDBModify(Catalog::GetCatalog(context, catalog), context);
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, std::move(stmt.info));
-		break;
-	}
-	case CatalogType::VIEW_ENTRY: {
-		auto &base = stmt.info->Cast<CreateViewInfo>();
-		// bind the schema
-		auto &schema = BindCreateSchema(*stmt.info);
-		BindCreateViewInfo(base);
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, std::move(stmt.info), &schema);
-		break;
-	}
-	case CatalogType::SEQUENCE_ENTRY: {
-		auto &schema = BindCreateSchema(*stmt.info);
-		result.plan =
-		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, std::move(stmt.info), &schema);
-		break;
-	}
-	case CatalogType::TABLE_MACRO_ENTRY: {
-		auto &schema = BindCreateSchema(*stmt.info);
-		result.plan =
-		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
-		break;
-	}
-	case CatalogType::MACRO_ENTRY: {
-		auto &schema = BindCreateFunctionInfo(*stmt.info);
-		auto logical_create =
-		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
-		result.plan = std::move(logical_create);
-		break;
-	}
-	case CatalogType::INDEX_ENTRY: {
-		auto &create_index_info = stmt.info->Cast<CreateIndexInfo>();
-
-		// Plan the table scan.
-		TableDescription table_description(create_index_info.catalog, create_index_info.schema,
-		                                   create_index_info.table);
-		auto table_ref = make_uniq<BaseTableRef>(table_description);
-		auto bound_table = Bind(*table_ref);
-		if (bound_table->type != TableReferenceType::BASE_TABLE) {
-			throw BinderException("can only create an index on a base table");
-		}
-
-		auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
-		auto &table = table_binding.table;
-		if (table.temporary) {
-			stmt.info->temporary = true;
-		}
-		properties.RegisterDBModify(table.catalog, context);
-
-		// create a plan over the bound table
-		auto plan = CreatePlan(*bound_table);
-		if (plan->type != LogicalOperatorType::LOGICAL_GET) {
-			throw BinderException("Cannot create index on a view!");
-		}
-
-		result.plan = table.catalog.BindCreateIndex(*this, stmt, table, std::move(plan));
-		break;
-	}
-	case CatalogType::TABLE_ENTRY: {
-		auto bound_info = BindCreateTableInfo(std::move(stmt.info));
-		auto root = std::move(bound_info->query);
-
-		// create the logical operator
-		auto &schema = bound_info->schema;
-		auto create_table = make_uniq<LogicalCreateTable>(schema, std::move(bound_info));
-		if (root) {
-			// CREATE TABLE AS
-			properties.return_type = StatementReturnType::CHANGED_ROWS;
-			create_table->children.push_back(std::move(root));
-		}
-		result.plan = std::move(create_table);
-		break;
-	}
-	case CatalogType::TYPE_ENTRY: {
-		auto &schema = BindCreateSchema(*stmt.info);
-		auto &create_type_info = stmt.info->Cast<CreateTypeInfo>();
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
-
-		auto &catalog = Catalog::GetCatalog(context, create_type_info.catalog);
-		auto &dependencies = create_type_info.dependencies;
-		auto dependency_callback = [&dependencies, &catalog](CatalogEntry &entry) {
-			if (&catalog != &entry.ParentCatalog()) {
-				// Don't register any cross-catalog dependencies
-				return;
-			}
-			dependencies.AddDependency(entry);
-		};
-		if (create_type_info.query) {
-			// CREATE TYPE mood AS ENUM (SELECT 'happy')
-			auto query_obj = Bind(*create_type_info.query);
-			auto query = std::move(query_obj.plan);
-			create_type_info.query.reset();
-
-			auto &sql_types = query_obj.types;
-			if (sql_types.size() != 1) {
-				// add cast expression?
-				throw BinderException("The query must return a single column");
-			}
-			if (sql_types[0].id() != LogicalType::VARCHAR) {
-				// push a projection casting to varchar
-				vector<unique_ptr<Expression>> select_list;
-				auto ref = make_uniq<BoundColumnRefExpression>(sql_types[0], query->GetColumnBindings()[0]);
-				auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(ref), LogicalType::VARCHAR);
-				select_list.push_back(std::move(cast_expr));
-				auto proj = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
-				proj->AddChild(std::move(query));
-				query = std::move(proj);
-			}
-
-			result.plan->AddChild(std::move(query));
-		} else if (create_type_info.type.id() == LogicalTypeId::USER) {
-			SetCatalogLookupCallback(dependency_callback);
-			// two cases:
-			// 1: create a type with a non-existent type as source, Binder::BindLogicalType(...) will throw exception.
-			// 2: create a type alias with a custom type.
-			// eg. CREATE TYPE a AS INT; CREATE TYPE b AS a;
-			// We set b to be an alias for the underlying type of a
-			auto type_entry_p = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, schema.catalog.GetName(), schema.name,
-			                                             UserType::GetTypeName(create_type_info.type));
-			D_ASSERT(type_entry_p);
-			auto &type_entry = type_entry_p->Cast<TypeCatalogEntry>();
-			create_type_info.type = type_entry.user_type;
-		} else {
-			SetCatalogLookupCallback(dependency_callback);
-			// This is done so that if the type contains a USER type,
-			// we register this dependency
-			auto preserved_type = create_type_info.type;
-			BindLogicalType(create_type_info.type);
-			create_type_info.type = preserved_type;
-		}
-		break;
-	}
-	case CatalogType::SECRET_ENTRY: {
-		CatalogTransaction transaction = CatalogTransaction(Catalog::GetSystemCatalog(context), context);
-		properties.return_type = StatementReturnType::QUERY_RESULT;
-		return SecretManager::Get(context).BindCreateSecret(transaction, stmt.info->Cast<CreateSecretInfo>());
-	}
-	default:
-		throw InternalException("Unrecognized type!");
-	}
-	properties.return_type = StatementReturnType::NOTHING;
-	properties.allow_stream_result = false;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_create_table.cpp b/src/duckdb/src/planner/binder/statement/bind_create_table.cpp
deleted file mode 100644
index 80d50d074..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_create_table.cpp
+++ /dev/null
@@ -1,649 +0,0 @@
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/constraints/list.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_binder/check_binder.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/parser/expression/list.hpp"
-#include "duckdb/common/index_map.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/expression_binder/index_binder.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-namespace duckdb {
-
-static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
-	auto &base = info.base->Cast<CreateTableInfo>();
-	for (auto &col : base.columns.Logical()) {
-		if (!col.Generated()) {
-			continue;
-		}
-		info.column_dependency_manager.AddGeneratedColumn(col, base.columns);
-	}
-}
-
-vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(ClientContext &context,
-                                                            const vector<unique_ptr<Constraint>> &constraints,
-                                                            const string &table_name, const ColumnList &columns) {
-	auto binder = Binder::CreateBinder(context);
-	return binder->BindConstraints(constraints, table_name, columns);
-}
-
-vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const TableCatalogEntry &table) {
-	return BindConstraints(table.GetConstraints(), table.name, table.GetColumns());
-}
-
-vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const vector<unique_ptr<Constraint>> &constraints,
-                                                            const string &table_name, const ColumnList &columns) {
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	for (const auto &constr : constraints) {
-		bound_constraints.push_back(BindConstraint(*constr, table_name, columns));
-	}
-	return bound_constraints;
-}
-
-vector<unique_ptr<BoundConstraint>> Binder::BindNewConstraints(vector<unique_ptr<Constraint>> &constraints,
-                                                               const string &table_name, const ColumnList &columns) {
-	auto bound_constraints = BindConstraints(constraints, table_name, columns);
-
-	// Handle PK and NOT NULL constraints.
-	bool has_primary_key = false;
-	physical_index_set_t not_null_columns;
-	vector<PhysicalIndex> primary_keys;
-
-	for (const auto &bound_constr : bound_constraints) {
-		switch (bound_constr->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null = bound_constr->Cast<BoundNotNullConstraint>();
-			not_null_columns.insert(not_null.index);
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			const auto &unique = bound_constr->Cast<BoundUniqueConstraint>();
-			if (unique.is_primary_key) {
-				if (has_primary_key) {
-					throw ParserException("table \"%s\" has more than one primary key", table_name);
-				}
-				has_primary_key = true;
-				primary_keys = unique.keys;
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	if (has_primary_key) {
-		// Create a PK constraint, and a NOT NULL constraint for each indexed column.
-		for (auto &column_index : primary_keys) {
-			if (not_null_columns.count(column_index) != 0) {
-				continue;
-			}
-
-			auto logical_index = columns.PhysicalToLogical(column_index);
-			constraints.push_back(make_uniq<NotNullConstraint>(logical_index));
-			bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(column_index));
-		}
-	}
-
-	return bound_constraints;
-}
-
-unique_ptr<BoundConstraint> BindCheckConstraint(Binder &binder, Constraint &constraint, const string &table,
-                                                const ColumnList &columns) {
-	auto bound_constraint = make_uniq<BoundCheckConstraint>();
-	auto &bound_check = bound_constraint->Cast<BoundCheckConstraint>();
-
-	// Bind the CHECK expression.
-	CheckBinder check_binder(binder, binder.context, table, columns, bound_check.bound_columns);
-	auto &check = constraint.Cast<CheckConstraint>();
-
-	// Create a copy of the unbound expression because binding can invalidate it.
-	auto unbound_expression = check.expression->Copy();
-
-	// Bind the constraint and reset the original expression.
-	bound_check.expression = check_binder.Bind(check.expression);
-	check.expression = std::move(unbound_expression);
-	return std::move(bound_constraint);
-}
-
-unique_ptr<BoundConstraint> Binder::BindUniqueConstraint(Constraint &constraint, const string &table,
-                                                         const ColumnList &columns) {
-	auto &unique = constraint.Cast<UniqueConstraint>();
-
-	// Resolve the columns.
-	vector<PhysicalIndex> indexes;
-	physical_index_set_t index_set;
-
-	// HasIndex refers to a column index, not an index(-structure).
-	// If set, then the UNIQUE constraint is defined on a single column.
-	if (unique.HasIndex()) {
-		auto &col = columns.GetColumn(unique.GetIndex());
-		unique.SetColumnName(col.Name());
-		indexes.push_back(col.Physical());
-		index_set.insert(col.Physical());
-		return make_uniq<BoundUniqueConstraint>(std::move(indexes), std::move(index_set), unique.IsPrimaryKey());
-	}
-
-	// The UNIQUE constraint is defined on a list of columns.
-	for (auto &col_name : unique.GetColumnNames()) {
-		if (!columns.ColumnExists(col_name)) {
-			throw CatalogException("table \"%s\" does not have a column named \"%s\"", table, col_name);
-		}
-		auto &col = columns.GetColumn(col_name);
-		if (col.Generated()) {
-			throw BinderException("cannot create a PRIMARY KEY on a generated column: %s", col.GetName());
-		}
-
-		auto physical_index = col.Physical();
-		if (index_set.find(physical_index) != index_set.end()) {
-			throw ParserException("column \"%s\" appears twice in primary key constraint", col_name);
-		}
-		indexes.push_back(physical_index);
-		index_set.insert(physical_index);
-	}
-
-	return make_uniq<BoundUniqueConstraint>(std::move(indexes), std::move(index_set), unique.IsPrimaryKey());
-}
-
-unique_ptr<BoundConstraint> BindForeignKey(Constraint &constraint) {
-	auto &fk = constraint.Cast<ForeignKeyConstraint>();
-	D_ASSERT((fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE && !fk.info.pk_keys.empty()) ||
-	         (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && !fk.info.pk_keys.empty()) ||
-	         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
-
-	physical_index_set_t pk_key_set;
-	for (auto &pk_key : fk.info.pk_keys) {
-		if (pk_key_set.find(pk_key) != pk_key_set.end()) {
-			throw ParserException("duplicate primary key referenced in FOREIGN KEY constraint");
-		}
-		pk_key_set.insert(pk_key);
-	}
-
-	physical_index_set_t fk_key_set;
-	for (auto &fk_key : fk.info.fk_keys) {
-		if (fk_key_set.find(fk_key) != fk_key_set.end()) {
-			throw ParserException("duplicate key specified in FOREIGN KEY constraint");
-		}
-		fk_key_set.insert(fk_key);
-	}
-
-	return make_uniq<BoundForeignKeyConstraint>(fk.info, std::move(pk_key_set), std::move(fk_key_set));
-}
-
-unique_ptr<BoundConstraint> Binder::BindConstraint(Constraint &constraint, const string &table,
-                                                   const ColumnList &columns) {
-	switch (constraint.type) {
-	case ConstraintType::CHECK: {
-		return BindCheckConstraint(*this, constraint, table, columns);
-	}
-	case ConstraintType::NOT_NULL: {
-		auto &not_null = constraint.Cast<NotNullConstraint>();
-		auto &col = columns.GetColumn(not_null.index);
-		return make_uniq<BoundNotNullConstraint>(col.Physical());
-	}
-	case ConstraintType::UNIQUE: {
-		return BindUniqueConstraint(constraint, table, columns);
-	}
-	case ConstraintType::FOREIGN_KEY: {
-		return BindForeignKey(constraint);
-	}
-	default:
-		throw NotImplementedException("unrecognized constraint type in bind");
-	}
-}
-
-void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
-	auto &base = info.base->Cast<CreateTableInfo>();
-
-	vector<string> names;
-	vector<LogicalType> types;
-
-	D_ASSERT(base.type == CatalogType::TABLE_ENTRY);
-	for (auto &col : base.columns.Logical()) {
-		names.push_back(col.Name());
-		types.push_back(col.Type());
-	}
-	auto table_index = GenerateTableIndex();
-
-	// Create a new binder because we dont need (or want) these bindings in this scope
-	auto binder = Binder::CreateBinder(context);
-	binder->SetCatalogLookupCallback(entry_retriever.GetCallback());
-	binder->bind_context.AddGenericBinding(table_index, base.table, names, types);
-	auto expr_binder = ExpressionBinder(*binder, context);
-	ErrorData ignore;
-	auto table_binding = binder->bind_context.GetBinding(base.table, ignore);
-	D_ASSERT(table_binding && !ignore.HasError());
-
-	auto bind_order = info.column_dependency_manager.GetBindOrder(base.columns);
-	logical_index_set_t bound_indices;
-
-	while (!bind_order.empty()) {
-		auto i = bind_order.top();
-		bind_order.pop();
-		auto &col = base.columns.GetColumnMutable(i);
-
-		//! Already bound this previously
-		//! This can not be optimized out of the GetBindOrder function
-		//! These occurrences happen because we need to make sure that ALL dependencies of a column are resolved before
-		//! it gets resolved
-		if (bound_indices.count(i)) {
-			continue;
-		}
-		D_ASSERT(col.Generated());
-		auto expression = col.GeneratedExpression().Copy();
-
-		auto bound_expression = expr_binder.Bind(expression);
-		D_ASSERT(bound_expression);
-		if (bound_expression->HasSubquery()) {
-			throw BinderException("Failed to bind generated column '%s' because the expression contains a subquery",
-			                      col.Name());
-		}
-		if (col.Type().id() == LogicalTypeId::ANY) {
-			// Do this before changing the type, so we know it's the first time the type is set
-			col.ChangeGeneratedExpressionType(bound_expression->return_type);
-			col.SetType(bound_expression->return_type);
-
-			// Update the type in the binding, for future expansions
-			table_binding->types[i.index] = col.Type();
-		}
-		bound_indices.insert(i);
-	}
-}
-
-void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults,
-                               const string &catalog_name, const string &schema_p) {
-	string schema_name = schema_p;
-	if (schema_p.empty()) {
-		schema_name = DEFAULT_SCHEMA;
-	}
-
-	// FIXME: We might want to save the existing search path of the binder
-	vector<CatalogSearchEntry> defaults_search_path;
-	defaults_search_path.emplace_back(catalog_name, schema_name);
-	if (schema_name != DEFAULT_SCHEMA) {
-		defaults_search_path.emplace_back(catalog_name, DEFAULT_SCHEMA);
-	}
-	entry_retriever.SetSearchPath(std::move(defaults_search_path));
-
-	for (auto &column : columns.Physical()) {
-		unique_ptr<Expression> bound_default;
-		if (column.HasDefaultValue()) {
-			// we bind a copy of the DEFAULT value because binding is destructive
-			// and we want to keep the original expression around for serialization
-			auto default_copy = column.DefaultValue().Copy();
-			if (default_copy->HasParameter()) {
-				throw BinderException("DEFAULT values cannot contain parameters");
-			}
-			ConstantBinder default_binder(*this, context, "DEFAULT value");
-			default_binder.target_type = column.Type();
-			bound_default = default_binder.Bind(default_copy);
-		} else {
-			// no default value specified: push a default value of constant null
-			bound_default = make_uniq<BoundConstantExpression>(Value(column.Type()));
-		}
-		bound_defaults.push_back(std::move(bound_default));
-	}
-}
-
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema) {
-	vector<unique_ptr<Expression>> bound_defaults;
-	return BindCreateTableInfo(std::move(info), schema, bound_defaults);
-}
-
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableCheckpoint(unique_ptr<CreateInfo> info,
-                                                                   SchemaCatalogEntry &schema) {
-	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
-	CreateColumnDependencyManager(*result);
-	return result;
-}
-
-void ExpressionContainsGeneratedColumn(const ParsedExpression &expr, const unordered_set<string> &gcols,
-                                       bool &contains_gcol) {
-	if (contains_gcol) {
-		return;
-	}
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &column_ref = expr.Cast<ColumnRefExpression>();
-		auto &name = column_ref.GetColumnName();
-		if (gcols.count(name)) {
-			contains_gcol = true;
-			return;
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { ExpressionContainsGeneratedColumn(child, gcols, contains_gcol); });
-}
-
-static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info) {
-	unordered_set<string> generated_columns;
-	for (auto &col : table_info.columns.Logical()) {
-		if (!col.Generated()) {
-			continue;
-		}
-		generated_columns.insert(col.Name());
-	}
-	if (generated_columns.empty()) {
-		return false;
-	}
-
-	for (auto &constr : table_info.constraints) {
-		switch (constr->type) {
-		case ConstraintType::CHECK: {
-			auto &constraint = constr->Cast<CheckConstraint>();
-			auto &expr = constraint.expression;
-			bool contains_generated_column = false;
-			ExpressionContainsGeneratedColumn(*expr, generated_columns, contains_generated_column);
-			if (contains_generated_column) {
-				return true;
-			}
-			break;
-		}
-		case ConstraintType::NOT_NULL: {
-			auto &constraint = constr->Cast<NotNullConstraint>();
-			if (table_info.columns.GetColumn(constraint.index).Generated()) {
-				return true;
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto &constraint = constr->Cast<UniqueConstraint>();
-			if (!constraint.HasIndex()) {
-				for (auto &col : constraint.GetColumnNames()) {
-					if (generated_columns.count(col)) {
-						return true;
-					}
-				}
-			} else {
-				if (table_info.columns.GetColumn(constraint.GetIndex()).Generated()) {
-					return true;
-				}
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			// If it contained a generated column, an exception would have been thrown inside AddDataTableIndex earlier
-			break;
-		}
-		default: {
-			throw NotImplementedException("ConstraintType not implemented");
-		}
-		}
-	}
-	return false;
-}
-
-static void FindForeignKeyIndexes(const ColumnList &columns, const vector<string> &names,
-                                  vector<PhysicalIndex> &indexes) {
-	D_ASSERT(indexes.empty());
-	D_ASSERT(!names.empty());
-	for (auto &name : names) {
-		if (!columns.ColumnExists(name)) {
-			throw BinderException("column \"%s\" named in key does not exist", name);
-		}
-		auto &column = columns.GetColumn(name);
-		if (column.Generated()) {
-			throw BinderException("Failed to create foreign key: referenced column \"%s\" is a generated column",
-			                      column.Name());
-		}
-		indexes.push_back(column.Physical());
-	}
-}
-
-static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints,
-                                          ForeignKeyConstraint &fk) {
-	// find the matching primary key constraint
-	bool found_constraint = false;
-	// if no columns are defined, we will automatically try to bind to the primary key
-	bool find_primary_key = fk.pk_columns.empty();
-	for (auto &constr : constraints) {
-		if (constr->type != ConstraintType::UNIQUE) {
-			continue;
-		}
-		auto &unique = constr->Cast<UniqueConstraint>();
-		if (find_primary_key && !unique.IsPrimaryKey()) {
-			continue;
-		}
-		found_constraint = true;
-
-		vector<string> pk_names;
-		if (unique.HasIndex()) {
-			pk_names.push_back(columns.GetColumn(LogicalIndex(unique.GetIndex())).Name());
-		} else {
-			pk_names = unique.GetColumnNames();
-		}
-		if (find_primary_key) {
-			// found matching primary key
-			if (pk_names.size() != fk.fk_columns.size()) {
-				auto pk_name_str = StringUtil::Join(pk_names, ",");
-				auto fk_name_str = StringUtil::Join(fk.fk_columns, ",");
-				throw BinderException(
-				    "Failed to create foreign key: number of referencing (%s) and referenced columns (%s) differ",
-				    fk_name_str, pk_name_str);
-			}
-			fk.pk_columns = pk_names;
-			return;
-		}
-		if (pk_names.size() != fk.fk_columns.size()) {
-			// the number of referencing and referenced columns for foreign keys must be the same
-			continue;
-		}
-		bool equals = true;
-		for (idx_t i = 0; i < fk.pk_columns.size(); i++) {
-			if (!StringUtil::CIEquals(fk.pk_columns[i], pk_names[i])) {
-				equals = false;
-				break;
-			}
-		}
-		if (!equals) {
-			continue;
-		}
-		// found match
-		return;
-	}
-	// no match found! examine why
-	if (!found_constraint) {
-		// no unique constraint or primary key
-		string search_term = find_primary_key ? "primary key" : "primary key or unique constraint";
-		throw BinderException("Failed to create foreign key: there is no %s for referenced table \"%s\"", search_term,
-		                      fk.info.table);
-	}
-	// check if all the columns exist
-	for (auto &name : fk.pk_columns) {
-		bool found = columns.ColumnExists(name);
-		if (!found) {
-			throw BinderException(
-			    "Failed to create foreign key: referenced table \"%s\" does not have a column named \"%s\"",
-			    fk.info.table, name);
-		}
-	}
-	auto fk_names = StringUtil::Join(fk.pk_columns, ",");
-	throw BinderException("Failed to create foreign key: referenced table \"%s\" does not have a primary key or unique "
-	                      "constraint on the columns %s",
-	                      fk.info.table, fk_names);
-}
-
-static void CheckForeignKeyTypes(const ColumnList &pk_columns, const ColumnList &fk_columns, ForeignKeyConstraint &fk) {
-	D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size());
-	for (idx_t c_idx = 0; c_idx < fk.info.pk_keys.size(); c_idx++) {
-		auto &pk_col = pk_columns.GetColumn(fk.info.pk_keys[c_idx]);
-		auto &fk_col = fk_columns.GetColumn(fk.info.fk_keys[c_idx]);
-		if (pk_col.Type() != fk_col.Type()) {
-			throw BinderException("Failed to create foreign key: incompatible types between column \"%s\" (\"%s\") and "
-			                      "column \"%s\" (\"%s\")",
-			                      pk_col.Name(), pk_col.Type().ToString(), fk_col.Name(), fk_col.Type().ToString());
-		}
-	}
-}
-
-static void BindCreateTableConstraints(CreateTableInfo &create_info, CatalogEntryRetriever &entry_retriever,
-                                       SchemaCatalogEntry &schema) {
-	// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
-	reference_set_t<SchemaCatalogEntry> fk_schemas;
-	for (idx_t i = 0; i < create_info.constraints.size(); i++) {
-		auto &cond = create_info.constraints[i];
-		if (cond->type != ConstraintType::FOREIGN_KEY) {
-			continue;
-		}
-		auto &fk = cond->Cast<ForeignKeyConstraint>();
-		if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-			continue;
-		}
-		if (!fk.info.pk_keys.empty() && !fk.info.fk_keys.empty()) {
-			return;
-		}
-		D_ASSERT(fk.info.pk_keys.empty());
-		D_ASSERT(fk.info.fk_keys.empty());
-		FindForeignKeyIndexes(create_info.columns, fk.fk_columns, fk.info.fk_keys);
-
-		// Resolve the self-reference.
-		if (StringUtil::CIEquals(create_info.table, fk.info.table)) {
-			fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
-			FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk);
-			FindForeignKeyIndexes(create_info.columns, fk.pk_columns, fk.info.pk_keys);
-			CheckForeignKeyTypes(create_info.columns, create_info.columns, fk);
-			continue;
-		}
-
-		// Resolve the table reference.
-		auto table_entry =
-		    entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, INVALID_CATALOG, fk.info.schema, fk.info.table);
-		if (table_entry->type == CatalogType::VIEW_ENTRY) {
-			throw BinderException("cannot reference a VIEW with a FOREIGN KEY");
-		}
-
-		auto &pk_table_entry_ptr = table_entry->Cast<TableCatalogEntry>();
-		if (&pk_table_entry_ptr.schema != &schema) {
-			throw BinderException("Creating foreign keys across different schemas or catalogs is not supported");
-		}
-		FindMatchingPrimaryKeyColumns(pk_table_entry_ptr.GetColumns(), pk_table_entry_ptr.GetConstraints(), fk);
-		FindForeignKeyIndexes(pk_table_entry_ptr.GetColumns(), fk.pk_columns, fk.info.pk_keys);
-		CheckForeignKeyTypes(pk_table_entry_ptr.GetColumns(), create_info.columns, fk);
-		auto &storage = pk_table_entry_ptr.GetStorage();
-
-		if (!storage.HasForeignKeyIndex(fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE)) {
-			auto fk_column_names = StringUtil::Join(fk.pk_columns, ",");
-			throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint "
-			                      "present on these columns",
-			                      pk_table_entry_ptr.name, fk_column_names);
-		}
-
-		D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size());
-		D_ASSERT(fk.info.pk_keys.size() == fk.pk_columns.size());
-		D_ASSERT(fk.info.fk_keys.size() == fk.fk_columns.size());
-	}
-}
-
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema,
-                                                             vector<unique_ptr<Expression>> &bound_defaults) {
-	auto &base = info->Cast<CreateTableInfo>();
-	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
-	auto &dependencies = result->dependencies;
-
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	if (base.query) {
-		// construct the result object
-		auto query_obj = Bind(*base.query);
-		base.query.reset();
-		result->query = std::move(query_obj.plan);
-
-		// construct the set of columns based on the names and types of the query
-		auto &names = query_obj.names;
-		auto &sql_types = query_obj.types;
-		// e.g. create table (col1 ,col2) as QUERY
-		// col1 and col2 are the target_col_names
-		auto target_col_names = base.columns.GetColumnNames();
-		// TODO check  types and target_col_names are mismatch in size
-		D_ASSERT(names.size() == sql_types.size());
-		base.columns.SetAllowDuplicates(true);
-		if (!target_col_names.empty()) {
-			if (target_col_names.size() > sql_types.size()) {
-				throw BinderException("Target table has more colum names than query result.");
-			} else if (target_col_names.size() < sql_types.size()) {
-				// filled the target_col_names with the name of query names
-				for (idx_t i = target_col_names.size(); i < sql_types.size(); i++) {
-					target_col_names.push_back(names[i]);
-				}
-			}
-			ColumnList new_colums;
-			for (idx_t i = 0; i < target_col_names.size(); i++) {
-				new_colums.AddColumn(ColumnDefinition(target_col_names[i], sql_types[i]));
-			}
-			base.columns = std::move(new_colums);
-		} else {
-			for (idx_t i = 0; i < names.size(); i++) {
-				base.columns.AddColumn(ColumnDefinition(names[i], sql_types[i]));
-			}
-		}
-		// bind collations to detect any unsupported collation errors
-		for (idx_t i = 0; i < base.columns.PhysicalColumnCount(); i++) {
-			auto &column = base.columns.GetColumnMutable(PhysicalIndex(i));
-			if (column.Type().id() == LogicalTypeId::VARCHAR) {
-				ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
-			}
-			BindLogicalType(column.TypeMutable(), &result->schema.catalog, result->schema.name);
-		}
-	} else {
-		SetCatalogLookupCallback([&dependencies, &schema](CatalogEntry &entry) {
-			if (&schema.ParentCatalog() != &entry.ParentCatalog()) {
-				// Don't register dependencies between catalogs
-				return;
-			}
-			dependencies.AddDependency(entry);
-		});
-		CreateColumnDependencyManager(*result);
-		// bind the generated column expressions
-		BindGeneratedColumns(*result);
-		// bind any constraints
-
-		// bind collations to detect any unsupported collation errors
-		for (idx_t i = 0; i < base.columns.PhysicalColumnCount(); i++) {
-			auto &column = base.columns.GetColumnMutable(PhysicalIndex(i));
-			if (column.Type().id() == LogicalTypeId::VARCHAR) {
-				ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
-			}
-			BindLogicalType(column.TypeMutable(), &result->schema.catalog, result->schema.name);
-		}
-		BindCreateTableConstraints(base, entry_retriever, schema);
-
-		if (AnyConstraintReferencesGeneratedColumn(base)) {
-			throw BinderException("Constraints on generated columns are not supported yet");
-		}
-		bound_constraints = BindNewConstraints(base.constraints, base.table, base.columns);
-		// bind the default values
-		auto &catalog_name = schema.ParentCatalog().GetName();
-		auto &schema_name = schema.name;
-		BindDefaultValues(base.columns, bound_defaults, catalog_name, schema_name);
-	}
-
-	if (base.columns.PhysicalColumnCount() == 0) {
-		throw BinderException("Creating a table without physical (non-generated) columns is not supported");
-	}
-
-	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	return result;
-}
-
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
-	auto &base = info->Cast<CreateTableInfo>();
-	auto &schema = BindCreateSchema(base);
-	return BindCreateTableInfo(std::move(info), schema);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_delete.cpp b/src/duckdb/src/planner/binder/statement/bind_delete.cpp
deleted file mode 100644
index 822f487ed..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_delete.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "duckdb/parser/statement/delete_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/expression_binder/returning_binder.hpp"
-#include "duckdb/planner/operator/logical_delete.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(DeleteStatement &stmt) {
-	BoundStatement result;
-
-	// visit the table reference
-	auto bound_table = Bind(*stmt.table);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw BinderException("Can only delete from base table!");
-	}
-	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
-	auto &table = table_binding.table;
-
-	auto root = CreatePlan(*bound_table);
-	auto &get = root->Cast<LogicalGet>();
-	D_ASSERT(root->type == LogicalOperatorType::LOGICAL_GET);
-
-	if (!table.temporary) {
-		// delete from persistent table: not read only!
-		auto &properties = GetStatementProperties();
-		properties.RegisterDBModify(table.catalog, context);
-	}
-
-	// Add CTEs as bindable
-	AddCTEMap(stmt.cte_map);
-
-	// plan any tables from the various using clauses
-	if (!stmt.using_clauses.empty()) {
-		unique_ptr<LogicalOperator> child_operator;
-		for (auto &using_clause : stmt.using_clauses) {
-			// bind the using clause
-			auto using_binder = Binder::CreateBinder(context, this);
-			auto bound_node = using_binder->Bind(*using_clause);
-			auto op = CreatePlan(*bound_node);
-			if (child_operator) {
-				// already bound a child: create a cross product to unify the two
-				child_operator = LogicalCrossProduct::Create(std::move(child_operator), std::move(op));
-			} else {
-				child_operator = std::move(op);
-			}
-			bind_context.AddContext(std::move(using_binder->bind_context));
-		}
-		if (child_operator) {
-			root = LogicalCrossProduct::Create(std::move(root), std::move(child_operator));
-		}
-	}
-
-	// project any additional columns required for the condition
-	unique_ptr<Expression> condition;
-	if (stmt.condition) {
-		WhereBinder binder(*this, context);
-		condition = binder.Bind(stmt.condition);
-
-		PlanSubqueries(condition, root);
-		auto filter = make_uniq<LogicalFilter>(std::move(condition));
-		filter->AddChild(std::move(root));
-		root = std::move(filter);
-	}
-	// create the delete node
-	auto del = make_uniq<LogicalDelete>(table, GenerateTableIndex());
-	del->bound_constraints = BindConstraints(table);
-	del->AddChild(std::move(root));
-
-	// set up the delete expression
-	auto &column_ids = get.GetColumnIds();
-	del->expressions.push_back(
-	    make_uniq<BoundColumnRefExpression>(table.GetRowIdType(), ColumnBinding(get.table_index, column_ids.size())));
-	get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID);
-
-	if (!stmt.returning_list.empty()) {
-		del->return_chunk = true;
-
-		auto update_table_index = GenerateTableIndex();
-		del->table_index = update_table_index;
-
-		unique_ptr<LogicalOperator> del_as_logicaloperator = std::move(del);
-		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
-		                     std::move(del_as_logicaloperator), std::move(result));
-	}
-	result.plan = std::move(del);
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::CHANGED_ROWS;
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_detach.cpp b/src/duckdb/src/planner/binder/statement/bind_detach.cpp
deleted file mode 100644
index 98db58055..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_detach.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/parser/statement/detach_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(DetachStatement &stmt) {
-	BoundStatement result;
-
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_drop.cpp b/src/duckdb/src/planner/binder/statement/bind_drop.cpp
deleted file mode 100644
index e17287bed..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_drop.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(DropStatement &stmt) {
-	BoundStatement result;
-
-	auto &properties = GetStatementProperties();
-	switch (stmt.info->type) {
-	case CatalogType::PREPARED_STATEMENT:
-		// dropping prepared statements is always possible
-		// it also does not require a valid transaction
-		properties.requires_valid_transaction = false;
-		break;
-	case CatalogType::SCHEMA_ENTRY: {
-		// dropping a schema is never read-only because there are no temporary schemas
-		auto &catalog = Catalog::GetCatalog(context, stmt.info->catalog);
-		properties.RegisterDBModify(catalog, context);
-		break;
-	}
-	case CatalogType::VIEW_ENTRY:
-	case CatalogType::SEQUENCE_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-	case CatalogType::INDEX_ENTRY:
-	case CatalogType::TABLE_ENTRY:
-	case CatalogType::TYPE_ENTRY: {
-		BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-		auto catalog = Catalog::GetCatalogEntry(context, stmt.info->catalog);
-		if (catalog) {
-			// mark catalog as accessed
-			properties.RegisterDBRead(*catalog, context);
-		}
-		auto entry = Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema, stmt.info->name,
-		                               stmt.info->if_not_found);
-		if (!entry) {
-			break;
-		}
-		if (entry->internal) {
-			throw CatalogException("Cannot drop internal catalog entry \"%s\"!", entry->name);
-		}
-		stmt.info->catalog = entry->ParentCatalog().GetName();
-		if (!entry->temporary) {
-			// we can only drop temporary schema entries in read-only mode
-			properties.RegisterDBModify(entry->ParentCatalog(), context);
-		}
-		stmt.info->schema = entry->ParentSchema().name;
-		break;
-	}
-	case CatalogType::SECRET_ENTRY: {
-		//! Secrets are stored in the secret manager; they can always be dropped
-		properties.requires_valid_transaction = false;
-		break;
-	}
-	default:
-		throw BinderException("Unknown catalog type for drop statement: '%s'", CatalogTypeToString(stmt.info->type));
-	}
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, std::move(stmt.info));
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_execute.cpp b/src/duckdb/src/planner/binder/statement/bind_execute.cpp
deleted file mode 100644
index 3e3af4d6a..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_execute.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/execute_statement.hpp"
-#include "duckdb/planner/planner.hpp"
-#include "duckdb/planner/operator/logical_execute.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ExecuteStatement &stmt) {
-	auto parameter_count = stmt.named_param_map.size();
-
-	// bind the prepared statement
-	auto &client_data = ClientData::Get(context);
-
-	auto entry = client_data.prepared_statements.find(stmt.name);
-	if (entry == client_data.prepared_statements.end()) {
-		throw BinderException("Prepared statement \"%s\" does not exist", stmt.name);
-	}
-
-	// check if we need to rebind the prepared statement
-	// this happens if the catalog changes, since in this case e.g. tables we relied on may have been deleted
-	auto prepared = entry->second;
-	auto &named_param_map = prepared->unbound_statement->named_param_map;
-
-	PreparedStatement::VerifyParameters(stmt.named_values, named_param_map);
-
-	auto &mapped_named_values = stmt.named_values;
-	// bind any supplied parameters
-	case_insensitive_map_t<BoundParameterData> bind_values;
-	auto constant_binder = Binder::CreateBinder(context);
-	constant_binder->SetCanContainNulls(true);
-	for (auto &pair : mapped_named_values) {
-		bool is_literal = pair.second->GetExpressionType() == ExpressionType::VALUE_CONSTANT;
-
-		ConstantBinder cbinder(*constant_binder, context, "EXECUTE statement");
-		auto bound_expr = cbinder.Bind(pair.second);
-		BoundParameterData parameter_data;
-		if (is_literal) {
-			auto &constant = bound_expr->Cast<BoundConstantExpression>();
-			LogicalType return_type;
-			if (constant.return_type == LogicalTypeId::VARCHAR &&
-			    StringType::GetCollation(constant.return_type).empty()) {
-				return_type = LogicalTypeId::STRING_LITERAL;
-			} else if (constant.return_type.IsIntegral()) {
-				return_type = LogicalType::INTEGER_LITERAL(constant.value);
-			} else {
-				return_type = constant.value.type();
-			}
-			parameter_data = BoundParameterData(std::move(constant.value), std::move(return_type));
-		} else {
-			auto value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
-			parameter_data = BoundParameterData(std::move(value));
-		}
-		bind_values[pair.first] = std::move(parameter_data);
-	}
-	unique_ptr<LogicalOperator> rebound_plan;
-
-	if (prepared->RequireRebind(context, &bind_values)) {
-		// catalog was modified or statement does not have clear types: rebind the statement before running the execute
-		Planner prepared_planner(context);
-		prepared_planner.parameter_data = bind_values;
-		prepared = prepared_planner.PrepareSQLStatement(entry->second->unbound_statement->Copy());
-		rebound_plan = std::move(prepared_planner.plan);
-		D_ASSERT(prepared->properties.bound_all_parameters);
-		this->bound_tables = prepared_planner.binder->bound_tables;
-	}
-	// copy the properties of the prepared statement into the planner
-	auto &properties = GetStatementProperties();
-	properties = prepared->properties;
-	properties.parameter_count = parameter_count;
-
-	BoundStatement result;
-	result.names = prepared->names;
-	result.types = prepared->types;
-
-	prepared->Bind(std::move(bind_values));
-	if (rebound_plan) {
-		auto execute_plan = make_uniq<LogicalExecute>(std::move(prepared));
-		execute_plan->children.push_back(std::move(rebound_plan));
-		result.plan = std::move(execute_plan);
-	} else {
-		result.plan = make_uniq<LogicalExecute>(std::move(prepared));
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_explain.cpp b/src/duckdb/src/planner/binder/statement/bind_explain.cpp
deleted file mode 100644
index b223cf06f..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_explain.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/explain_statement.hpp"
-#include "duckdb/planner/operator/logical_explain.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ExplainStatement &stmt) {
-	BoundStatement result;
-
-	// bind the underlying statement
-	auto plan = Bind(*stmt.stmt);
-	// get the unoptimized logical plan, and create the explain statement
-	auto logical_plan_unopt = plan.plan->ToString(stmt.explain_format);
-	auto explain = make_uniq<LogicalExplain>(std::move(plan.plan), stmt.explain_type, stmt.explain_format);
-	explain->logical_plan_unopt = logical_plan_unopt;
-
-	result.plan = std::move(explain);
-	result.names = {"explain_key", "explain_value"};
-	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
-
-	auto &properties = GetStatementProperties();
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_export.cpp b/src/duckdb/src/planner/binder/statement/bind_export.cpp
deleted file mode 100644
index 68b5b80d2..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_export.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/parser/statement/export_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_export.hpp"
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
-#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-//! Sanitizes a string to have only low case chars and underscores
-string SanitizeExportIdentifier(const string &str) {
-	// Copy the original string to result
-	string result(str);
-
-	for (idx_t i = 0; i < str.length(); ++i) {
-		auto c = str[i];
-		if (c >= 'a' && c <= 'z') {
-			// If it is lower case just continue
-			continue;
-		}
-
-		if (c >= 'A' && c <= 'Z') {
-			// To lowercase
-			result[i] = NumericCast<char>(tolower(c));
-		} else {
-			// Substitute to underscore
-			result[i] = '_';
-		}
-	}
-
-	return result;
-}
-
-bool ReferencedTableIsOrdered(string &referenced_table, catalog_entry_vector_t &ordered) {
-	for (auto &entry : ordered) {
-		auto &table_entry = entry.get().Cast<TableCatalogEntry>();
-		if (StringUtil::CIEquals(table_entry.name, referenced_table)) {
-			// The referenced table is already ordered
-			return true;
-		}
-	}
-	return false;
-}
-
-void ScanForeignKeyTable(catalog_entry_vector_t &ordered, catalog_entry_vector_t &unordered,
-                         bool move_primary_keys_only) {
-	catalog_entry_vector_t remaining;
-
-	for (auto &entry : unordered) {
-		auto &table_entry = entry.get().Cast<TableCatalogEntry>();
-		bool move_to_ordered = true;
-		auto &constraints = table_entry.GetConstraints();
-
-		for (auto &cond : constraints) {
-			if (cond->type != ConstraintType::FOREIGN_KEY) {
-				continue;
-			}
-			auto &fk = cond->Cast<ForeignKeyConstraint>();
-			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				continue;
-			}
-
-			if (move_primary_keys_only) {
-				// This table references a table, don't move it yet
-				move_to_ordered = false;
-				break;
-			} else if (!ReferencedTableIsOrdered(fk.info.table, ordered)) {
-				// The table that it references isn't ordered yet
-				move_to_ordered = false;
-				break;
-			}
-		}
-
-		if (move_to_ordered) {
-			ordered.push_back(table_entry);
-		} else {
-			remaining.push_back(table_entry);
-		}
-	}
-	unordered = remaining;
-}
-
-void ReorderTableEntries(catalog_entry_vector_t &tables) {
-	catalog_entry_vector_t ordered;
-	catalog_entry_vector_t unordered = tables;
-	// First only move the tables that don't have any dependencies
-	ScanForeignKeyTable(ordered, unordered, true);
-	while (!unordered.empty()) {
-		// Now we will start moving tables that have foreign key constraints
-		// if the tables they reference are already moved
-		ScanForeignKeyTable(ordered, unordered, false);
-	}
-	tables = ordered;
-}
-
-string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const string &extension) {
-	auto name = SanitizeExportIdentifier(table.name);
-	if (table.schema.name == DEFAULT_SCHEMA) {
-		return StringUtil::Format("%s%s.%s", name, id_suffix, extension);
-	}
-	auto schema = SanitizeExportIdentifier(table.schema.name);
-	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
-}
-
-static unique_ptr<QueryNode> CreateSelectStatement(CopyStatement &stmt, child_list_t<LogicalType> &select_list) {
-	auto ref = make_uniq<BaseTableRef>();
-	ref->catalog_name = stmt.info->catalog;
-	ref->schema_name = stmt.info->schema;
-	ref->table_name = stmt.info->table;
-
-	auto statement = make_uniq<SelectNode>();
-	statement->from_table = std::move(ref);
-
-	vector<unique_ptr<ParsedExpression>> expressions;
-	for (auto &col : select_list) {
-		auto expression = make_uniq_base<ParsedExpression, ColumnRefExpression>(col.first);
-		expressions.push_back(std::move(expression));
-	}
-
-	statement->select_list = std::move(expressions);
-	return std::move(statement);
-}
-
-unique_ptr<LogicalOperator> Binder::UnionOperators(vector<unique_ptr<LogicalOperator>> nodes) {
-	if (nodes.empty()) {
-		return nullptr;
-	}
-	while (nodes.size() > 1) {
-		vector<unique_ptr<LogicalOperator>> new_nodes;
-		for (idx_t i = 0; i < nodes.size(); i += 2) {
-			if (i + 1 == nodes.size()) {
-				new_nodes.push_back(std::move(nodes[i]));
-			} else {
-				auto copy_union = make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1U, std::move(nodes[i]),
-				                                                 std::move(nodes[i + 1]),
-				                                                 LogicalOperatorType::LOGICAL_UNION, true, false);
-				new_nodes.push_back(std::move(copy_union));
-			}
-		}
-		nodes = std::move(new_nodes);
-	}
-	return std::move(nodes[0]);
-}
-
-BoundStatement Binder::Bind(ExportStatement &stmt) {
-	// COPY TO a file
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	// lookup the format in the catalog
-	auto &copy_function =
-	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function.function.copy_to_bind && !copy_function.function.plan) {
-		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
-	}
-
-	// gather a list of all the tables
-	string catalog = stmt.database.empty() ? INVALID_CATALOG : stmt.database;
-	catalog_entry_vector_t tables;
-	auto schemas = Catalog::GetSchemas(context, catalog);
-	for (auto &schema : schemas) {
-		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.type == CatalogType::TABLE_ENTRY) {
-				tables.push_back(entry.Cast<TableCatalogEntry>());
-			}
-		});
-	}
-
-	// reorder tables because of foreign key constraint
-	ReorderTableEntries(tables);
-
-	// now generate the COPY statements for each of the tables
-	auto &fs = FileSystem::GetFileSystem(context);
-
-	auto exported_tables = make_uniq<BoundExportData>();
-
-	unordered_set<string> table_name_index;
-	vector<unique_ptr<LogicalOperator>> export_nodes;
-	for (auto &t : tables) {
-		auto &table = t.get().Cast<TableCatalogEntry>();
-		auto info = make_uniq<CopyInfo>();
-		// we copy the options supplied to the EXPORT
-		info->format = stmt.info->format;
-		info->options = stmt.info->options;
-		// set up the file name for the COPY TO
-
-		idx_t id = 0;
-		while (true) {
-			string id_suffix = id == 0 ? string() : "_" + to_string(id);
-			auto name = CreateFileName(id_suffix, table, copy_function.function.extension);
-			auto directory = stmt.info->file_path;
-			auto full_path = fs.JoinPath(directory, name);
-			info->file_path = full_path;
-			auto insert_result = table_name_index.insert(info->file_path);
-			if (insert_result.second) {
-				// this name was not yet taken: take it
-				break;
-			}
-			id++;
-		}
-		info->is_from = false;
-		info->catalog = catalog;
-		info->schema = table.schema.name;
-		info->table = table.name;
-
-		// We can not export generated columns
-		child_list_t<LogicalType> select_list;
-		// Let's verify if any on these columns have not null constraints
-		vector<string> not_null_columns;
-		for (auto &constaint : table.GetConstraints()) {
-			if (constaint->type == ConstraintType::NOT_NULL) {
-				auto &not_null_constraint = constaint->Cast<NotNullConstraint>();
-				not_null_columns.push_back(table.GetColumn(not_null_constraint.index).GetName());
-			}
-		}
-		for (auto &col : table.GetColumns().Physical()) {
-			select_list.push_back(std::make_pair(col.Name(), col.Type()));
-		}
-
-		ExportedTableData exported_data;
-		exported_data.database_name = catalog;
-		exported_data.table_name = info->table;
-		exported_data.schema_name = info->schema;
-
-		exported_data.file_path = info->file_path;
-
-		ExportedTableInfo table_info(table, std::move(exported_data), not_null_columns);
-		exported_tables->data.push_back(table_info);
-		id++;
-
-		// generate the copy statement and bind it
-		CopyStatement copy_stmt;
-		copy_stmt.info = std::move(info);
-		copy_stmt.info->select_statement = CreateSelectStatement(copy_stmt, select_list);
-
-		auto copy_binder = Binder::CreateBinder(context, this);
-		auto bound_statement = copy_binder->Bind(copy_stmt, CopyToType::EXPORT_DATABASE);
-
-		auto plan = std::move(bound_statement.plan);
-
-		export_nodes.push_back(std::move(plan));
-	}
-	auto child_operator = UnionOperators(std::move(export_nodes));
-
-	// try to create the directory, if it doesn't exist yet
-	// a bit hacky to do it here, but we need to create the directory BEFORE the copy statements run
-	if (!fs.DirectoryExists(stmt.info->file_path)) {
-		fs.CreateDirectory(stmt.info->file_path);
-	}
-
-	stmt.info->catalog = catalog;
-	// create the export node
-	auto export_node =
-	    make_uniq<LogicalExport>(copy_function.function, std::move(stmt.info), std::move(exported_tables));
-
-	if (child_operator) {
-		export_node->children.push_back(std::move(child_operator));
-	}
-
-	result.plan = std::move(export_node);
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_extension.cpp b/src/duckdb/src/planner/binder/statement/bind_extension.cpp
deleted file mode 100644
index b4fc0e86b..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_extension.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/extension_statement.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ExtensionStatement &stmt) {
-	BoundStatement result;
-
-	// perform the planning of the function
-	D_ASSERT(stmt.extension.plan_function);
-	auto parse_result =
-	    stmt.extension.plan_function(stmt.extension.parser_info.get(), context, std::move(stmt.parse_data));
-
-	auto &properties = GetStatementProperties();
-	properties.modified_databases = parse_result.modified_databases;
-	properties.requires_valid_transaction = parse_result.requires_valid_transaction;
-	properties.return_type = parse_result.return_type;
-
-	// create the plan as a scan of the given table function
-	result.plan = BindTableFunction(parse_result.function, std::move(parse_result.parameters));
-	D_ASSERT(result.plan->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = result.plan->Cast<LogicalGet>();
-	result.names = get.names;
-	result.types = get.returned_types;
-	get.ClearColumnIds();
-	for (idx_t i = 0; i < get.returned_types.size(); i++) {
-		get.AddColumnId(i);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_insert.cpp b/src/duckdb/src/planner/binder/statement/bind_insert.cpp
deleted file mode 100644
index d4af5ab44..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_insert.cpp
+++ /dev/null
@@ -1,641 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/insert_binder.hpp"
-#include "duckdb/planner/operator/logical_insert.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/expression_binder/update_binder.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/tableref/bound_dummytableref.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-
-namespace duckdb {
-
-static void CheckInsertColumnCountMismatch(idx_t expected_columns, idx_t result_columns, bool columns_provided,
-                                           const char *tname) {
-	if (result_columns != expected_columns) {
-		string msg = StringUtil::Format(!columns_provided ? "table %s has %lld columns but %lld values were supplied"
-		                                                  : "Column name/value mismatch for insert on %s: "
-		                                                    "expected %lld columns but %lld values were supplied",
-		                                tname, expected_columns, result_columns);
-		throw BinderException(msg);
-	}
-}
-
-unique_ptr<ParsedExpression> ExpandDefaultExpression(const ColumnDefinition &column) {
-	if (column.HasDefaultValue()) {
-		return column.DefaultValue().Copy();
-	} else {
-		return make_uniq<ConstantExpression>(Value(column.Type()));
-	}
-}
-
-void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDefinition &column) {
-	D_ASSERT(expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT);
-	expr = ExpandDefaultExpression(column);
-}
-
-void ExpressionBinder::DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name,
-                                                  vector<unordered_set<string>> &lambda_params) {
-
-	for (auto &child : function.children) {
-		if (child->GetExpressionClass() != ExpressionClass::LAMBDA) {
-			DoUpdateSetQualify(child, table_name, lambda_params);
-			continue;
-		}
-
-		// Special-handling for LHS lambda parameters.
-		// We do not qualify them, and we add them to the lambda_params vector.
-		auto &lambda_expr = child->Cast<LambdaExpression>();
-		string error_message;
-		auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message);
-
-		if (!error_message.empty()) {
-			// Possibly a JSON function, qualify both LHS and RHS.
-			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr<ParsedExpression> &child) {
-				DoUpdateSetQualify(child, table_name, lambda_params);
-			});
-			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
-				DoUpdateSetQualify(child, table_name, lambda_params);
-			});
-			continue;
-		}
-
-		// Push the lambda parameter names of this level.
-		lambda_params.emplace_back();
-		for (const auto &column_ref_expr : column_ref_expressions) {
-			const auto &column_ref = column_ref_expr.get().Cast<ColumnRefExpression>();
-			lambda_params.back().emplace(column_ref.GetName());
-		}
-
-		// Only qualify in the RHS of the expression.
-		ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
-			DoUpdateSetQualify(child, table_name, lambda_params);
-		});
-
-		lambda_params.pop_back();
-	}
-}
-
-void ExpressionBinder::DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
-                                          vector<unordered_set<string>> &lambda_params) {
-
-	// We avoid ambiguity with EXCLUDED columns by qualifying all column references.
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF: {
-		auto &col_ref = expr->Cast<ColumnRefExpression>();
-		if (col_ref.IsQualified()) {
-			return;
-		}
-
-		// Don't qualify lambda parameters.
-		if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) {
-			return;
-		}
-
-		// Qualify the column reference.
-		expr = make_uniq<ColumnRefExpression>(col_ref.GetColumnName(), table_name);
-		return;
-	}
-	case ExpressionClass::FUNCTION: {
-		// Special-handling for lambdas, which are inside function expressions.
-		auto &function = expr->Cast<FunctionExpression>();
-		if (function.IsLambdaFunction()) {
-			return DoUpdateSetQualifyInLambda(function, table_name, lambda_params);
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		throw BinderException("DO UPDATE SET clause cannot contain a subquery");
-	}
-	default:
-		break;
-	}
-
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { DoUpdateSetQualify(child, table_name, lambda_params); });
-}
-
-// Replace binding.table_index with 'dest' if it's 'source'
-void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_columnref = expr.Cast<BoundColumnRefExpression>();
-		if (bound_columnref.binding.table_index == source) {
-			bound_columnref.binding.table_index = dest;
-		}
-	}
-	ExpressionIterator::EnumerateChildren(
-	    expr, [&](unique_ptr<Expression> &child) { ReplaceColumnBindings(*child, source, dest); });
-}
-
-void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert &insert, UpdateSetInfo &set_info,
-                                        TableCatalogEntry &table, TableStorageInfo &storage_info) {
-	D_ASSERT(insert.children.size() == 1);
-
-	vector<column_t> logical_column_ids;
-	vector<string> column_names;
-	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
-
-	for (idx_t i = 0; i < set_info.columns.size(); i++) {
-		auto &colname = set_info.columns[i];
-		auto &expr = set_info.expressions[i];
-		if (!table.ColumnExists(colname)) {
-			throw BinderException("Referenced update column %s not found in table!", colname);
-		}
-		auto &column = table.GetColumn(colname);
-		if (column.Generated()) {
-			throw BinderException("Cant update column \"%s\" because it is a generated column!", column.Name());
-		}
-		if (std::find(insert.set_columns.begin(), insert.set_columns.end(), column.Physical()) !=
-		    insert.set_columns.end()) {
-			throw BinderException("Multiple assignments to same column \"%s\"", colname);
-		}
-
-		if (!column.Type().SupportsRegularUpdate()) {
-			insert.update_is_del_and_insert = true;
-		}
-
-		insert.set_columns.push_back(column.Physical());
-		logical_column_ids.push_back(column.Oid());
-		insert.set_types.push_back(column.Type());
-		column_names.push_back(colname);
-		if (expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-			expr = ExpandDefaultExpression(column);
-		}
-
-		// Qualify and bind the ON CONFLICT DO UPDATE SET expression.
-		UpdateBinder update_binder(*this, context);
-		update_binder.target_type = column.Type();
-
-		// Avoid ambiguity between existing table columns and EXCLUDED columns.
-		vector<unordered_set<string>> lambda_params;
-		update_binder.DoUpdateSetQualify(expr, table_alias, lambda_params);
-
-		auto bound_expr = update_binder.Bind(expr);
-		D_ASSERT(bound_expr);
-		insert.expressions.push_back(std::move(bound_expr));
-	}
-
-	// Figure out which columns are indexed on
-	unordered_set<column_t> indexed_columns;
-	for (auto &index : storage_info.index_info) {
-		for (auto &column_id : index.column_set) {
-			indexed_columns.insert(column_id);
-		}
-	}
-
-	// If any column targeted by a SET expression has an index, then
-	// we need to rewrite this to an DELETE + INSERT.
-	for (idx_t i = 0; i < logical_column_ids.size(); i++) {
-		auto &column = logical_column_ids[i];
-		if (indexed_columns.count(column)) {
-			insert.update_is_del_and_insert = true;
-			break;
-		}
-	}
-}
-
-unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, InsertStatement &insert,
-                                                  TableStorageInfo &storage_info) {
-	auto set_info = make_uniq<UpdateSetInfo>();
-
-	auto &columns = set_info->columns;
-	// Figure out which columns are indexed on
-
-	unordered_set<column_t> indexed_columns;
-	for (auto &index : storage_info.index_info) {
-		for (auto &column_id : index.column_set) {
-			indexed_columns.insert(column_id);
-		}
-	}
-
-	auto &column_list = table.GetColumns();
-	if (insert.columns.empty()) {
-		for (auto &column : column_list.Physical()) {
-			auto &name = column.Name();
-			// FIXME: can these column names be aliased somehow?
-			if (indexed_columns.count(column.Oid())) {
-				continue;
-			}
-			columns.push_back(name);
-		}
-	} else {
-		// a list of columns was explicitly supplied, only update those
-		for (auto &name : insert.columns) {
-			auto &column = column_list.GetColumn(name);
-			if (indexed_columns.count(column.Oid())) {
-				continue;
-			}
-			columns.push_back(name);
-		}
-	}
-
-	// Create 'excluded' qualified column references of these columns
-	for (auto &column : columns) {
-		set_info->expressions.push_back(make_uniq<ColumnRefExpression>(column, "excluded"));
-	}
-
-	return set_info;
-}
-
-vector<column_t> GetColumnsToFetch(const TableBinding &binding) {
-	auto &bound_columns = binding.GetBoundColumnIds();
-	vector<column_t> result;
-	for (auto &col : bound_columns) {
-		result.push_back(col.GetPrimaryIndex());
-	}
-	return result;
-}
-
-void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt) {
-	if (!stmt.on_conflict_info) {
-		insert.action_type = OnConflictAction::THROW;
-		return;
-	}
-	D_ASSERT(stmt.table_ref->type == TableReferenceType::BASE_TABLE);
-
-	// visit the table reference
-	auto bound_table = Bind(*stmt.table_ref);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw BinderException("Can only update base table!");
-	}
-
-	auto &table_ref = stmt.table_ref->Cast<BaseTableRef>();
-	const string &table_alias = !table_ref.alias.empty() ? table_ref.alias : table_ref.table_name;
-
-	auto &on_conflict = *stmt.on_conflict_info;
-	D_ASSERT(on_conflict.action_type != OnConflictAction::THROW);
-	insert.action_type = on_conflict.action_type;
-
-	// obtain the table storage info
-	auto storage_info = table.GetStorageInfo(context);
-
-	auto &columns = table.GetColumns();
-	if (!on_conflict.indexed_columns.empty()) {
-		// Bind the ON CONFLICT (<columns>)
-
-		// create a mapping of (list index) -> (column index)
-		case_insensitive_map_t<idx_t> specified_columns;
-		for (idx_t i = 0; i < on_conflict.indexed_columns.size(); i++) {
-			specified_columns[on_conflict.indexed_columns[i]] = i;
-			auto column_index = table.GetColumnIndex(on_conflict.indexed_columns[i]);
-			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
-				throw BinderException("Cannot specify ROWID as ON CONFLICT target");
-			}
-			auto &col = columns.GetColumn(column_index);
-			if (col.Generated()) {
-				throw BinderException("Cannot specify a generated column as ON CONFLICT target");
-			}
-		}
-		for (auto &col : columns.Physical()) {
-			auto entry = specified_columns.find(col.Name());
-			if (entry != specified_columns.end()) {
-				// column was specified, set to the index
-				insert.on_conflict_filter.insert(col.Physical().index);
-			}
-		}
-		bool index_references_columns = false;
-		for (auto &index : storage_info.index_info) {
-			if (!index.is_unique) {
-				continue;
-			}
-			bool index_matches = insert.on_conflict_filter == index.column_set;
-			if (index_matches) {
-				index_references_columns = true;
-				break;
-			}
-		}
-		if (!index_references_columns) {
-			// Same as before, this is essentially a no-op, turning this into a DO THROW instead
-			// But since this makes no logical sense, it's probably better to throw an error
-			throw BinderException("The specified columns as conflict target are not referenced by a UNIQUE/PRIMARY KEY "
-			                      "CONSTRAINT or INDEX");
-		}
-	} else {
-		// When omitting the conflict target, the ON CONFLICT applies to every UNIQUE/PRIMARY KEY on the table
-
-		// We check if there are any constraints on the table, if there aren't we throw an error.
-		idx_t found_matching_indexes = 0;
-		for (auto &index : storage_info.index_info) {
-			if (!index.is_unique) {
-				continue;
-			}
-			auto &indexed_columns = index.column_set;
-			bool matches = false;
-			for (auto &column : table.GetColumns().Physical()) {
-				if (indexed_columns.count(column.Physical().index)) {
-					matches = true;
-					break;
-				}
-			}
-			found_matching_indexes += matches;
-		}
-
-		if (!found_matching_indexes) {
-			throw BinderException(
-			    "There are no UNIQUE/PRIMARY KEY Indexes that refer to this table, ON CONFLICT is a no-op");
-		} else if (found_matching_indexes != 1) {
-			if (insert.action_type != OnConflictAction::NOTHING) {
-				// When no conflict target is provided, and the action type is UPDATE,
-				// we only allow the operation when only a single Index exists
-				throw BinderException("Conflict target has to be provided for a DO UPDATE operation when the table has "
-				                      "multiple UNIQUE/PRIMARY KEY constraints");
-			}
-		}
-	}
-
-	// add the 'excluded' dummy table binding
-	AddTableName("excluded");
-	// add a bind context entry for it
-	auto excluded_index = GenerateTableIndex();
-	insert.excluded_table_index = excluded_index;
-	vector<string> table_column_names;
-	vector<LogicalType> table_column_types;
-	for (auto &col : columns.Physical()) {
-		table_column_names.push_back(col.Name());
-		table_column_types.push_back(col.Type());
-	}
-	bind_context.AddGenericBinding(excluded_index, "excluded", table_column_names, table_column_types);
-
-	if (on_conflict.condition) {
-		WhereBinder where_binder(*this, context);
-
-		// Avoid ambiguity between existing table columns and EXCLUDED columns.
-		vector<unordered_set<string>> lambda_params;
-		where_binder.DoUpdateSetQualify(on_conflict.condition, table_alias, lambda_params);
-
-		// Bind the ON CONFLICT ... WHERE clause.
-		auto condition = where_binder.Bind(on_conflict.condition);
-		insert.on_conflict_condition = std::move(condition);
-	}
-
-	optional_idx projection_index;
-	reference<vector<unique_ptr<LogicalOperator>>> insert_child_operators = insert.children;
-	while (!projection_index.IsValid()) {
-		if (insert_child_operators.get().empty()) {
-			// No further children to visit
-			break;
-		}
-		auto &current_child = insert_child_operators.get()[0];
-		auto table_indices = current_child->GetTableIndex();
-		if (table_indices.empty()) {
-			// This operator does not have a table index to refer to, we have to visit its children
-			insert_child_operators = current_child->children;
-			continue;
-		}
-		projection_index = table_indices[0];
-	}
-	if (!projection_index.IsValid()) {
-		throw InternalException("Could not locate a table_index from the children of the insert");
-	}
-
-	ErrorData unused;
-	auto original_binding = bind_context.GetBinding(table_alias, unused);
-	D_ASSERT(original_binding && !unused.HasError());
-
-	auto table_index = original_binding->index;
-
-	// Replace any column bindings to refer to the projection table_index, rather than the source table
-	if (insert.on_conflict_condition) {
-		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index.GetIndex());
-	}
-
-	if (insert.action_type == OnConflictAction::REPLACE) {
-		D_ASSERT(on_conflict.set_info == nullptr);
-		on_conflict.set_info = CreateSetInfoForReplace(table, stmt, storage_info);
-		insert.action_type = OnConflictAction::UPDATE;
-	}
-	if (on_conflict.set_info && on_conflict.set_info->columns.empty()) {
-		// if we are doing INSERT OR REPLACE on a table with no columns outside of the primary key column
-		// convert to INSERT OR IGNORE
-		insert.action_type = OnConflictAction::NOTHING;
-	}
-	if (insert.action_type == OnConflictAction::NOTHING) {
-		if (!insert.on_conflict_condition) {
-			return;
-		}
-		// Get the column_ids we need to fetch later on from the conflicting tuples
-		// of the original table, to execute the expressions
-		D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-		auto &table_binding = original_binding->Cast<TableBinding>();
-		insert.columns_to_fetch = GetColumnsToFetch(table_binding);
-		return;
-	}
-
-	D_ASSERT(on_conflict.set_info);
-	auto &set_info = *on_conflict.set_info;
-	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
-
-	if (set_info.condition) {
-		WhereBinder where_binder(*this, context);
-
-		// Avoid ambiguity between existing table columns and EXCLUDED columns.
-		vector<unordered_set<string>> lambda_params;
-		where_binder.DoUpdateSetQualify(set_info.condition, table_alias, lambda_params);
-
-		// Bind the SET ... WHERE clause.
-		auto condition = where_binder.Bind(set_info.condition);
-		insert.do_update_condition = std::move(condition);
-	}
-
-	BindDoUpdateSetExpressions(table_alias, insert, set_info, table, storage_info);
-
-	// Get the column_ids we need to fetch later on from the conflicting tuples
-	// of the original table, to execute the expressions
-	D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-	auto &table_binding = original_binding->Cast<TableBinding>();
-	insert.columns_to_fetch = GetColumnsToFetch(table_binding);
-
-	// Replace the column bindings to refer to the child operator
-	for (auto &expr : insert.expressions) {
-		// Change the non-excluded column references to refer to the projection index
-		ReplaceColumnBindings(*expr, table_index, projection_index.GetIndex());
-	}
-	// Do the same for the (optional) DO UPDATE condition
-	if (insert.do_update_condition) {
-		ReplaceColumnBindings(*insert.do_update_condition, table_index, projection_index.GetIndex());
-	}
-}
-
-BoundStatement Binder::Bind(InsertStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-
-	BindSchemaOrCatalog(stmt.catalog, stmt.schema);
-	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
-	if (!table.temporary) {
-		// inserting into a non-temporary table: alters underlying database
-		auto &properties = GetStatementProperties();
-		properties.RegisterDBModify(table.catalog, context);
-	}
-
-	auto insert = make_uniq<LogicalInsert>(table, GenerateTableIndex());
-	// Add CTEs as bindable
-	AddCTEMap(stmt.cte_map);
-
-	auto values_list = stmt.GetValuesList();
-
-	// bind the root select node (if any)
-	BoundStatement root_select;
-	if (stmt.column_order == InsertColumnOrder::INSERT_BY_NAME) {
-		if (values_list) {
-			throw BinderException("INSERT BY NAME can only be used when inserting from a SELECT statement");
-		}
-		if (stmt.default_values) {
-			throw BinderException("INSERT BY NAME cannot be combined with with DEFAULT VALUES");
-		}
-		if (!stmt.columns.empty()) {
-			throw BinderException("INSERT BY NAME cannot be combined with an explicit column list");
-		}
-		D_ASSERT(stmt.select_statement);
-		// INSERT BY NAME - generate the columns from the names of the SELECT statement
-		auto select_binder = Binder::CreateBinder(context, this);
-		root_select = select_binder->Bind(*stmt.select_statement);
-		MoveCorrelatedExpressions(*select_binder);
-
-		stmt.columns = root_select.names;
-	}
-
-	vector<LogicalIndex> named_column_map;
-	if (!stmt.columns.empty() || stmt.default_values) {
-		// insertion statement specifies column list
-
-		// create a mapping of (list index) -> (column index)
-		case_insensitive_map_t<idx_t> column_name_map;
-		for (idx_t i = 0; i < stmt.columns.size(); i++) {
-			auto entry = column_name_map.insert(make_pair(stmt.columns[i], i));
-			if (!entry.second) {
-				throw BinderException("Duplicate column name \"%s\" in INSERT", stmt.columns[i]);
-			}
-			auto column_index = table.GetColumnIndex(stmt.columns[i]);
-			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
-				throw BinderException("Cannot explicitly insert values into rowid column");
-			}
-			auto &col = table.GetColumn(column_index);
-			if (col.Generated()) {
-				throw BinderException("Cannot insert into a generated column");
-			}
-			insert->expected_types.push_back(col.Type());
-			named_column_map.push_back(column_index);
-		}
-		for (auto &col : table.GetColumns().Physical()) {
-			auto entry = column_name_map.find(col.Name());
-			if (entry == column_name_map.end()) {
-				// column not specified, set index to DConstants::INVALID_INDEX
-				insert->column_index_map.push_back(DConstants::INVALID_INDEX);
-			} else {
-				// column was specified, set to the index
-				insert->column_index_map.push_back(entry->second);
-			}
-		}
-	} else {
-		// insert by position and no columns specified - insertion into all columns of the table
-		// intentionally don't populate 'column_index_map' as an indication of this
-		for (auto &col : table.GetColumns().Physical()) {
-			named_column_map.push_back(col.Logical());
-			insert->expected_types.push_back(col.Type());
-		}
-	}
-
-	// bind the default values
-	auto &catalog_name = table.ParentCatalog().GetName();
-	auto &schema_name = table.ParentSchema().name;
-	BindDefaultValues(table.GetColumns(), insert->bound_defaults, catalog_name, schema_name);
-	insert->bound_constraints = BindConstraints(table);
-	if (!stmt.select_statement && !stmt.default_values) {
-		result.plan = std::move(insert);
-		return result;
-	}
-	// Exclude the generated columns from this amount
-	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
-
-	// special case: check if we are inserting from a VALUES statement
-	if (values_list) {
-		auto &expr_list = values_list->Cast<ExpressionListRef>();
-		expr_list.expected_types.resize(expected_columns);
-		expr_list.expected_names.resize(expected_columns);
-
-		D_ASSERT(!expr_list.values.empty());
-		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
-		                               table.name.c_str());
-
-		// VALUES list!
-		for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
-			D_ASSERT(named_column_map.size() >= col_idx);
-			auto &table_col_idx = named_column_map[col_idx];
-
-			// set the expected types as the types for the INSERT statement
-			auto &column = table.GetColumn(table_col_idx);
-			expr_list.expected_types[col_idx] = column.Type();
-			expr_list.expected_names[col_idx] = column.Name();
-
-			// now replace any DEFAULT values with the corresponding default expression
-			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
-				if (expr_list.values[list_idx][col_idx]->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-					// DEFAULT value! replace the entry
-					ReplaceDefaultExpression(expr_list.values[list_idx][col_idx], column);
-				}
-			}
-		}
-	}
-
-	// parse select statement and add to logical plan
-	unique_ptr<LogicalOperator> root;
-	if (stmt.select_statement) {
-		if (stmt.column_order == InsertColumnOrder::INSERT_BY_POSITION) {
-			auto select_binder = Binder::CreateBinder(context, this);
-			root_select = select_binder->Bind(*stmt.select_statement);
-			MoveCorrelatedExpressions(*select_binder);
-		}
-		// inserting from a select - check if the column count matches
-		CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-		                               table.name.c_str());
-
-		root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
-	} else {
-		root = make_uniq<LogicalDummyScan>(GenerateTableIndex());
-	}
-	insert->AddChild(std::move(root));
-
-	BindOnConflictClause(*insert, table, stmt);
-
-	if (!stmt.returning_list.empty()) {
-		insert->return_chunk = true;
-		result.types.clear();
-		result.names.clear();
-		auto insert_table_index = GenerateTableIndex();
-		insert->table_index = insert_table_index;
-		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
-
-		return BindReturning(std::move(stmt.returning_list), table, stmt.table_ref ? stmt.table_ref->alias : string(),
-		                     insert_table_index, std::move(index_as_logicaloperator), std::move(result));
-	}
-
-	D_ASSERT(result.types.size() == result.names.size());
-	result.plan = std::move(insert);
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::CHANGED_ROWS;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_load.cpp b/src/duckdb/src/planner/binder/statement/bind_load.cpp
deleted file mode 100644
index 53d8f5792..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_load.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/parser/statement/load_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-#include <algorithm>
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(LoadStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	// Ensure the repository exists if it's an alias
-	if (!stmt.info->repository.empty() && stmt.info->repo_is_alias) {
-		auto repository_url = ExtensionRepository::TryGetRepositoryUrl(stmt.info->repository);
-		if (repository_url.empty()) {
-			throw BinderException("'%s' is not a known repository name. Are you trying to query from a repository by "
-			                      "path? Use single quotes: `FROM '%s'`",
-			                      stmt.info->repository, stmt.info->repository);
-		}
-	}
-
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, std::move(stmt.info));
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_logical_plan.cpp b/src/duckdb/src/planner/binder/statement/bind_logical_plan.cpp
deleted file mode 100644
index 5b187c8e3..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_logical_plan.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/parser/statement/logical_plan_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include <algorithm>
-
-namespace duckdb {
-
-idx_t GetMaxTableIndex(LogicalOperator &op) {
-	idx_t result = 0;
-	for (auto &child : op.children) {
-		auto max_child_index = GetMaxTableIndex(*child);
-		result = MaxValue<idx_t>(result, max_child_index);
-	}
-	auto indexes = op.GetTableIndex();
-	for (auto &index : indexes) {
-		result = MaxValue<idx_t>(result, index);
-	}
-	return result;
-}
-
-BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
-	BoundStatement result;
-	result.types = stmt.plan->types;
-	for (idx_t i = 0; i < result.types.size(); i++) {
-		result.names.push_back(StringUtil::Format("col%d", i));
-	}
-	result.plan = std::move(stmt.plan);
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = true;
-	properties.return_type = StatementReturnType::QUERY_RESULT; // TODO could also be something else
-
-	if (parent) {
-		throw InternalException("LogicalPlanStatement should be bound in root binder");
-	}
-	bound_tables = GetMaxTableIndex(*result.plan) + 1;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_pragma.cpp b/src/duckdb/src/planner/binder/statement/bind_pragma.cpp
deleted file mode 100644
index 3955cf897..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_pragma.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/planner/operator/logical_pragma.hpp"
-#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundPragmaInfo> Binder::BindPragma(PragmaInfo &info, QueryErrorContext error_context) {
-	vector<Value> params;
-	named_parameter_map_t named_parameters;
-
-	// resolve the parameters
-	ConstantBinder pragma_binder(*this, context, "PRAGMA value");
-	for (auto &param : info.parameters) {
-		auto bound_value = pragma_binder.Bind(param);
-		auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
-		params.push_back(std::move(value));
-	}
-
-	for (auto &entry : info.named_parameters) {
-		auto bound_value = pragma_binder.Bind(entry.second);
-		auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
-		named_parameters.insert(make_pair(entry.first, std::move(value)));
-	}
-
-	// bind the pragma function
-	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
-	FunctionBinder function_binder(*this);
-	ErrorData error;
-	auto bound_idx = function_binder.BindFunction(entry.name, entry.functions, params, error);
-	if (!bound_idx.IsValid()) {
-		D_ASSERT(error.HasError());
-		error.AddQueryLocation(error_context);
-		error.Throw();
-	}
-	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx.GetIndex());
-	// bind and check named params
-	BindNamedParameters(bound_function.named_parameters, named_parameters, error_context, bound_function.name);
-	return make_uniq<BoundPragmaInfo>(std::move(bound_function), std::move(params), std::move(named_parameters));
-}
-
-BoundStatement Binder::Bind(PragmaStatement &stmt) {
-	// bind the pragma function
-	QueryErrorContext error_context(stmt.stmt_location);
-	auto bound_info = BindPragma(*stmt.info, error_context);
-	if (!bound_info->function.function) {
-		throw BinderException("PRAGMA function does not have a function specified");
-	}
-
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_uniq<LogicalPragma>(std::move(bound_info));
-
-	auto &properties = GetStatementProperties();
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_prepare.cpp b/src/duckdb/src/planner/binder/statement/bind_prepare.cpp
deleted file mode 100644
index 74062e413..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_prepare.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/prepare_statement.hpp"
-#include "duckdb/planner/planner.hpp"
-#include "duckdb/planner/operator/logical_prepare.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(PrepareStatement &stmt) {
-	Planner prepared_planner(context);
-	auto prepared_data = prepared_planner.PrepareSQLStatement(std::move(stmt.statement));
-	this->bound_tables = prepared_planner.binder->bound_tables;
-
-	auto prepare = make_uniq<LogicalPrepare>(stmt.name, std::move(prepared_data), std::move(prepared_planner.plan));
-	// we can always prepare, even if the transaction has been invalidated
-	// this is required because most clients ALWAYS invoke prepared statements
-	auto &properties = GetStatementProperties();
-	properties.requires_valid_transaction = false;
-	properties.allow_stream_result = false;
-	properties.bound_all_parameters = true;
-	properties.parameter_count = 0;
-	properties.return_type = StatementReturnType::NOTHING;
-
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = std::move(prepare);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_relation.cpp b/src/duckdb/src/planner/binder/statement/bind_relation.cpp
deleted file mode 100644
index 1e0565a1a..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_relation.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/relation_statement.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(RelationStatement &stmt) {
-	return stmt.relation->Bind(*this);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_select.cpp b/src/duckdb/src/planner/binder/statement/bind_select.cpp
deleted file mode 100644
index ee68d0e25..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_select.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(SelectStatement &stmt) {
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = true;
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return Bind(*stmt.node);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_set.cpp b/src/duckdb/src/planner/binder/statement/bind_set.cpp
deleted file mode 100644
index 8bb8618f8..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_set.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "duckdb/parser/statement/set_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_set.hpp"
-#include "duckdb/planner/operator/logical_reset.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(SetVariableStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	// evaluate the scalar value
-	Value value;
-	unique_ptr<LogicalOperator> op;
-	if (stmt.scope != SetScope::VARIABLE) {
-		ConstantBinder default_binder(*this, context, "SET value");
-		auto bound_value = default_binder.Bind(stmt.value);
-		if (bound_value->HasParameter()) {
-			throw NotImplementedException("SET statements cannot have parameters");
-		}
-		value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
-	} else {
-		auto select_node = make_uniq<SelectNode>();
-		select_node->select_list.push_back(std::move(stmt.value));
-		select_node->from_table = make_uniq<EmptyTableRef>();
-		auto bound_select = Bind(*select_node);
-		if (bound_select.types.size() > 1) {
-			throw BinderException("SET variable expected a single input");
-		}
-		op = std::move(bound_select.plan);
-	}
-	result.plan = make_uniq<LogicalSet>(stmt.name, std::move(value), stmt.scope);
-	if (op) {
-		result.plan->children.push_back(std::move(op));
-	}
-	auto &properties = GetStatementProperties();
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-BoundStatement Binder::Bind(ResetVariableStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	result.plan = make_uniq<LogicalReset>(stmt.name, stmt.scope);
-
-	auto &properties = GetStatementProperties();
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-BoundStatement Binder::Bind(SetStatement &stmt) {
-	switch (stmt.set_type) {
-	case SetType::SET: {
-		auto &set_stmt = stmt.Cast<SetVariableStatement>();
-		return Bind(set_stmt);
-	}
-	case SetType::RESET: {
-		auto &set_stmt = stmt.Cast<ResetVariableStatement>();
-		return Bind(set_stmt);
-	}
-	default:
-		throw NotImplementedException("Type not implemented for SetType");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_simple.cpp b/src/duckdb/src/planner/binder/statement/bind_simple.cpp
deleted file mode 100644
index d4d862843..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_simple.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/statement/transaction_statement.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-#include "duckdb/planner/expression_binder/index_binder.hpp"
-#include "duckdb/planner/operator/logical_create_index.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> DuckCatalog::BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry,
-                                                           unique_ptr<LogicalOperator> plan,
-                                                           unique_ptr<CreateIndexInfo> create_info,
-                                                           unique_ptr<AlterTableInfo> alter_info) {
-	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
-	IndexBinder index_binder(binder, binder.context);
-	return index_binder.BindCreateIndex(binder.context, std::move(create_info), table_entry, std::move(plan),
-	                                    std::move(alter_info));
-}
-
-BoundStatement Binder::BindAlterAddIndex(BoundStatement &result, CatalogEntry &entry,
-                                         unique_ptr<AlterInfo> alter_info) {
-	auto &table_info = alter_info->Cast<AlterTableInfo>();
-	auto &constraint_info = table_info.Cast<AddConstraintInfo>();
-	auto &table = entry.Cast<TableCatalogEntry>();
-	auto &column_list = table.GetColumns();
-
-	auto bound_constraint = BindUniqueConstraint(*constraint_info.constraint, table_info.name, column_list);
-	auto &bound_unique = bound_constraint->Cast<BoundUniqueConstraint>();
-
-	// Create the CreateIndexInfo.
-	auto create_index_info = make_uniq<CreateIndexInfo>();
-	create_index_info->table = table_info.name;
-	create_index_info->index_type = ART::TYPE_NAME;
-	create_index_info->constraint_type = IndexConstraintType::PRIMARY;
-
-	for (const auto &physical_index : bound_unique.keys) {
-		auto &col = column_list.GetColumn(physical_index);
-		unique_ptr<ParsedExpression> parsed = make_uniq<ColumnRefExpression>(col.GetName(), table_info.name);
-		create_index_info->expressions.push_back(parsed->Copy());
-		create_index_info->parsed_expressions.push_back(parsed->Copy());
-	}
-
-	auto unique_constraint = constraint_info.constraint->Cast<UniqueConstraint>();
-	auto index_name = unique_constraint.GetName(table_info.name);
-	create_index_info->index_name = index_name;
-	D_ASSERT(!create_index_info->index_name.empty());
-
-	// Plan the table scan.
-	TableDescription table_description(table_info.catalog, table_info.schema, table_info.name);
-	auto table_ref = make_uniq<BaseTableRef>(table_description);
-	auto bound_table = Bind(*table_ref);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw BinderException("can only add an index to a base table");
-	}
-	auto plan = CreatePlan(*bound_table);
-	auto &get = plan->Cast<LogicalGet>();
-	get.names = column_list.GetColumnNames();
-
-	auto alter_table_info = unique_ptr_cast<AlterInfo, AlterTableInfo>(std::move(alter_info));
-	result.plan = table.catalog.BindAlterAddIndex(*this, table, std::move(plan), std::move(create_index_info),
-	                                              std::move(alter_table_info));
-	return std::move(result);
-}
-
-BoundStatement Binder::Bind(AlterStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-
-	optional_ptr<CatalogEntry> entry;
-	if (stmt.info->type == AlterType::SET_COLUMN_COMMENT) {
-		// Extra step for column comments: They can alter a table or a view, and we resolve that here.
-		auto &info = stmt.info->Cast<SetColumnCommentInfo>();
-		entry = info.TryResolveCatalogEntry(entry_retriever);
-
-	} else {
-		// For any other ALTER, we retrieve the catalog entry directly.
-		entry = entry_retriever.GetEntry(stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
-		                                 stmt.info->name, stmt.info->if_not_found);
-	}
-
-	auto &properties = GetStatementProperties();
-	properties.return_type = StatementReturnType::NOTHING;
-	if (!entry) {
-		result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
-		return result;
-	}
-
-	D_ASSERT(!entry->deleted);
-	auto &catalog = entry->ParentCatalog();
-	if (catalog.IsSystemCatalog()) {
-		throw BinderException("Can not comment on System Catalog entries");
-	}
-	if (!entry->temporary) {
-		// We can only alter temporary tables and views in read-only mode.
-		properties.RegisterDBModify(catalog, context);
-	}
-	stmt.info->catalog = catalog.GetName();
-	stmt.info->schema = entry->ParentSchema().name;
-
-	if (!stmt.info->IsAddPrimaryKey()) {
-		result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
-		return result;
-	}
-
-	return BindAlterAddIndex(result, *entry, std::move(stmt.info));
-}
-
-BoundStatement Binder::Bind(TransactionStatement &stmt) {
-	auto &properties = GetStatementProperties();
-
-	// Transaction statements do not require a valid transaction.
-	properties.requires_valid_transaction = stmt.info->type == TransactionType::BEGIN_TRANSACTION;
-
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, std::move(stmt.info));
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_summarize.cpp b/src/duckdb/src/planner/binder/statement/bind_summarize.cpp
deleted file mode 100644
index b5c87e1ad..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_summarize.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/tableref/showref.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-
-namespace duckdb {
-
-static unique_ptr<ParsedExpression> SummarizeWrapUnnest(vector<unique_ptr<ParsedExpression>> &children,
-                                                        const string &alias) {
-	auto list_function = make_uniq<FunctionExpression>("list_value", std::move(children));
-	vector<unique_ptr<ParsedExpression>> unnest_children;
-	unnest_children.push_back(std::move(list_function));
-	auto unnest_function = make_uniq<FunctionExpression>("unnest", std::move(unnest_children));
-	unnest_function->SetAlias(alias);
-	return std::move(unnest_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_uniq<ColumnRefExpression>(std::move(column_name)));
-	auto aggregate_function = make_uniq<FunctionExpression>(aggregate, std::move(children));
-	auto cast_function = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
-	return std::move(cast_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name,
-                                                             const Value &modifier) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_uniq<ColumnRefExpression>(std::move(column_name)));
-	children.push_back(make_uniq<ConstantExpression>(modifier));
-	auto aggregate_function = make_uniq<FunctionExpression>(aggregate, std::move(children));
-	auto cast_function = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
-	return std::move(cast_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateCountStar() {
-	vector<unique_ptr<ParsedExpression>> children;
-	auto aggregate_function = make_uniq<FunctionExpression>("count_star", std::move(children));
-	return std::move(aggregate_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateBinaryFunction(const string &op, unique_ptr<ParsedExpression> left,
-                                                                  unique_ptr<ParsedExpression> right) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-	auto binary_function = make_uniq<FunctionExpression>(op, std::move(children));
-	return std::move(binary_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateNullPercentage(string column_name) {
-	auto count_star = make_uniq<CastExpression>(LogicalType::DOUBLE, SummarizeCreateCountStar());
-	auto count =
-	    make_uniq<CastExpression>(LogicalType::DOUBLE, SummarizeCreateAggregate("count", std::move(column_name)));
-	auto null_percentage = SummarizeCreateBinaryFunction("/", std::move(count), std::move(count_star));
-	auto negate_x =
-	    SummarizeCreateBinaryFunction("-", make_uniq<ConstantExpression>(Value::DOUBLE(1)), std::move(null_percentage));
-	auto percentage_x =
-	    SummarizeCreateBinaryFunction("*", std::move(negate_x), make_uniq<ConstantExpression>(Value::DOUBLE(100)));
-
-	auto comp_expr = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_GREATERTHAN, SummarizeCreateCountStar(),
-	                                                 make_uniq<ConstantExpression>(Value::BIGINT(0)));
-	auto case_expr = make_uniq<CaseExpression>();
-	CaseCheck check;
-	check.when_expr = std::move(comp_expr);
-	check.then_expr = std::move(percentage_x);
-	case_expr->case_checks.push_back(std::move(check));
-	case_expr->else_expr = make_uniq<ConstantExpression>(Value());
-
-	return make_uniq<CastExpression>(LogicalType::DECIMAL(9, 2), std::move(case_expr));
-}
-
-unique_ptr<BoundTableRef> Binder::BindSummarize(ShowRef &ref) {
-	unique_ptr<QueryNode> query;
-	if (ref.query) {
-		query = std::move(ref.query);
-	} else {
-		auto table_name = QualifiedName::Parse(ref.table_name);
-		auto node = make_uniq<SelectNode>();
-		node->select_list.push_back(make_uniq<StarExpression>());
-		auto basetableref = make_uniq<BaseTableRef>();
-		basetableref->catalog_name = table_name.catalog;
-		basetableref->schema_name = table_name.schema;
-		basetableref->table_name = table_name.name;
-		node->from_table = std::move(basetableref);
-		query = std::move(node);
-	}
-	auto query_copy = query->Copy();
-
-	// we bind the plan once in a child-node to figure out the column names and column types
-	auto child_binder = Binder::CreateBinder(context, this);
-	auto plan = child_binder->Bind(*query);
-	D_ASSERT(plan.types.size() == plan.names.size());
-	vector<unique_ptr<ParsedExpression>> name_children;
-	vector<unique_ptr<ParsedExpression>> type_children;
-	vector<unique_ptr<ParsedExpression>> min_children;
-	vector<unique_ptr<ParsedExpression>> max_children;
-	vector<unique_ptr<ParsedExpression>> unique_children;
-	vector<unique_ptr<ParsedExpression>> avg_children;
-	vector<unique_ptr<ParsedExpression>> std_children;
-	vector<unique_ptr<ParsedExpression>> q25_children;
-	vector<unique_ptr<ParsedExpression>> q50_children;
-	vector<unique_ptr<ParsedExpression>> q75_children;
-	vector<unique_ptr<ParsedExpression>> count_children;
-	vector<unique_ptr<ParsedExpression>> null_percentage_children;
-	auto select = make_uniq<SelectStatement>();
-	select->node = std::move(query_copy);
-	for (idx_t i = 0; i < plan.names.size(); i++) {
-		name_children.push_back(make_uniq<ConstantExpression>(Value(plan.names[i])));
-		type_children.push_back(make_uniq<ConstantExpression>(Value(plan.types[i].ToString())));
-		min_children.push_back(SummarizeCreateAggregate("min", plan.names[i]));
-		max_children.push_back(SummarizeCreateAggregate("max", plan.names[i]));
-		unique_children.push_back(make_uniq<CastExpression>(
-		    LogicalType::BIGINT, SummarizeCreateAggregate("approx_count_distinct", plan.names[i])));
-		if (plan.types[i].IsNumeric()) {
-			avg_children.push_back(SummarizeCreateAggregate("avg", plan.names[i]));
-			std_children.push_back(SummarizeCreateAggregate("stddev", plan.names[i]));
-		} else {
-			avg_children.push_back(make_uniq<ConstantExpression>(Value()));
-			std_children.push_back(make_uniq<ConstantExpression>(Value()));
-		}
-		if (plan.types[i].IsNumeric() || plan.types[i].IsTemporal()) {
-			q25_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.25)));
-			q50_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.50)));
-			q75_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.75)));
-		} else {
-			q25_children.push_back(make_uniq<ConstantExpression>(Value()));
-			q50_children.push_back(make_uniq<ConstantExpression>(Value()));
-			q75_children.push_back(make_uniq<ConstantExpression>(Value()));
-		}
-		count_children.push_back(SummarizeCreateCountStar());
-		null_percentage_children.push_back(SummarizeCreateNullPercentage(plan.names[i]));
-	}
-	auto subquery_ref = make_uniq<SubqueryRef>(std::move(select), "summarize_tbl");
-	subquery_ref->column_name_alias = plan.names;
-
-	auto select_node = make_uniq<SelectNode>();
-	select_node->select_list.push_back(SummarizeWrapUnnest(name_children, "column_name"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(type_children, "column_type"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(min_children, "min"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(max_children, "max"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(unique_children, "approx_unique"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(avg_children, "avg"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(std_children, "std"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(q25_children, "q25"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(q50_children, "q50"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(q75_children, "q75"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(count_children, "count"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(null_percentage_children, "null_percentage"));
-	select_node->from_table = std::move(subquery_ref);
-
-	auto select_stmt = make_uniq<SelectStatement>();
-	select_stmt->node = std::move(select_node);
-	auto subquery = make_uniq<SubqueryRef>(std::move(select_stmt));
-	return Bind(*subquery);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_update.cpp b/src/duckdb/src/planner/binder/statement/bind_update.cpp
deleted file mode 100644
index 75dd39074..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_update.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/planner/expression_binder/update_binder.hpp"
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/storage/data_table.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-// This creates a LogicalProjection and moves 'root' into it as a child
-// unless there are no expressions to project, in which case it just returns 'root'
-unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
-                                                  UpdateSetInfo &set_info, TableCatalogEntry &table,
-                                                  vector<PhysicalIndex> &columns) {
-	auto proj_index = GenerateTableIndex();
-
-	vector<unique_ptr<Expression>> projection_expressions;
-	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
-	for (idx_t i = 0; i < set_info.columns.size(); i++) {
-		auto &colname = set_info.columns[i];
-		auto &expr = set_info.expressions[i];
-		if (!table.ColumnExists(colname)) {
-			throw BinderException("Referenced update column %s not found in table!", colname);
-		}
-		auto &column = table.GetColumn(colname);
-		if (column.Generated()) {
-			throw BinderException("Cant update column \"%s\" because it is a generated column!", column.Name());
-		}
-		if (std::find(columns.begin(), columns.end(), column.Physical()) != columns.end()) {
-			throw BinderException("Multiple assignments to same column \"%s\"", colname);
-		}
-		columns.push_back(column.Physical());
-		if (expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-			op.expressions.push_back(make_uniq<BoundDefaultExpression>(column.Type()));
-		} else {
-			UpdateBinder binder(*this, context);
-			binder.target_type = column.Type();
-			auto bound_expr = binder.Bind(expr);
-			PlanSubqueries(bound_expr, root);
-
-			op.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
-			projection_expressions.push_back(std::move(bound_expr));
-		}
-	}
-	if (op.type != LogicalOperatorType::LOGICAL_UPDATE && projection_expressions.empty()) {
-		return root;
-	}
-	// now create the projection
-	auto proj = make_uniq<LogicalProjection>(proj_index, std::move(projection_expressions));
-	proj->AddChild(std::move(root));
-	return unique_ptr_cast<LogicalProjection, LogicalOperator>(std::move(proj));
-}
-
-BoundStatement Binder::Bind(UpdateStatement &stmt) {
-	BoundStatement result;
-	unique_ptr<LogicalOperator> root;
-
-	// visit the table reference
-	auto bound_table = Bind(*stmt.table);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw BinderException("Can only update base table!");
-	}
-	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
-	auto &table = table_binding.table;
-
-	// Add CTEs as bindable
-	AddCTEMap(stmt.cte_map);
-
-	optional_ptr<LogicalGet> get;
-	if (stmt.from_table) {
-		auto from_binder = Binder::CreateBinder(context, this);
-		BoundJoinRef bound_crossproduct(JoinRefType::CROSS);
-		bound_crossproduct.left = std::move(bound_table);
-		bound_crossproduct.right = from_binder->Bind(*stmt.from_table);
-		root = CreatePlan(bound_crossproduct);
-		get = &root->children[0]->Cast<LogicalGet>();
-		bind_context.AddContext(std::move(from_binder->bind_context));
-	} else {
-		root = CreatePlan(*bound_table);
-		get = &root->Cast<LogicalGet>();
-	}
-
-	if (!table.temporary) {
-		// update of persistent table: not read only!
-		auto &properties = GetStatementProperties();
-		properties.RegisterDBModify(table.catalog, context);
-	}
-	auto update = make_uniq<LogicalUpdate>(table);
-
-	// set return_chunk boolean early because it needs uses update_is_del_and_insert logic
-	if (!stmt.returning_list.empty()) {
-		update->return_chunk = true;
-	}
-	// bind the default values
-	auto &catalog_name = table.ParentCatalog().GetName();
-	auto &schema_name = table.ParentSchema().name;
-	BindDefaultValues(table.GetColumns(), update->bound_defaults, catalog_name, schema_name);
-	update->bound_constraints = BindConstraints(table);
-
-	// project any additional columns required for the condition/expressions
-	if (stmt.set_info->condition) {
-		WhereBinder binder(*this, context);
-		auto condition = binder.Bind(stmt.set_info->condition);
-
-		PlanSubqueries(condition, root);
-		auto filter = make_uniq<LogicalFilter>(std::move(condition));
-		filter->AddChild(std::move(root));
-		root = std::move(filter);
-	}
-
-	D_ASSERT(stmt.set_info);
-	D_ASSERT(stmt.set_info->columns.size() == stmt.set_info->expressions.size());
-
-	auto proj_tmp = BindUpdateSet(*update, std::move(root), *stmt.set_info, table, update->columns);
-	D_ASSERT(proj_tmp->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
-
-	// bind any extra columns necessary for CHECK constraints or indexes
-	table.BindUpdateConstraints(*this, *get, *proj, *update, context);
-
-	// finally add the row id column to the projection list
-	auto &column_ids = get->GetColumnIds();
-	proj->expressions.push_back(
-	    make_uniq<BoundColumnRefExpression>(table.GetRowIdType(), ColumnBinding(get->table_index, column_ids.size())));
-	get->AddColumnId(COLUMN_IDENTIFIER_ROW_ID);
-
-	// set the projection as child of the update node and finalize the result
-	update->AddChild(std::move(proj));
-
-	auto update_table_index = GenerateTableIndex();
-	update->table_index = update_table_index;
-	if (!stmt.returning_list.empty()) {
-		unique_ptr<LogicalOperator> update_as_logicaloperator = std::move(update);
-
-		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
-		                     std::move(update_as_logicaloperator), std::move(result));
-	}
-
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	result.plan = std::move(update);
-
-	auto &properties = GetStatementProperties();
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::CHANGED_ROWS;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_update_extensions.cpp b/src/duckdb/src/planner/binder/statement/bind_update_extensions.cpp
deleted file mode 100644
index e355adc78..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_update_extensions.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "duckdb/parser/statement/load_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/update_extensions_statement.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include <algorithm>
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(UpdateExtensionsStatement &stmt) {
-	BoundStatement result;
-
-	result.names.emplace_back("extension_name");
-	result.types.emplace_back(LogicalType::VARCHAR);
-	result.names.emplace_back("repository");
-	result.types.emplace_back(LogicalType::VARCHAR);
-	result.names.emplace_back("update_result");
-	result.types.emplace_back(LogicalType::VARCHAR);
-	result.names.emplace_back("previous_version");
-	result.types.emplace_back(LogicalType::VARCHAR);
-	result.names.emplace_back("current_version");
-	result.types.emplace_back(LogicalType::VARCHAR);
-
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS, std::move(stmt.info));
-
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp b/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp
deleted file mode 100644
index 93e70fe5b..000000000
--- a/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/statement/vacuum_statement.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_vacuum.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-namespace duckdb {
-
-void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator> &root) {
-	auto &info = vacuum.GetInfo();
-	if (!info.has_table) {
-		return;
-	}
-
-	D_ASSERT(vacuum.column_id_map.empty());
-	auto bound_table = Bind(*info.ref);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw InvalidInputException("can only vacuum or analyze base tables");
-	}
-	auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
-	auto &table = ref->table;
-	vacuum.SetTable(table);
-
-	vector<unique_ptr<Expression>> select_list;
-	auto &columns = info.columns;
-	if (columns.empty()) {
-		// Empty means ALL columns should be vacuumed/analyzed
-		for (auto &col : table.GetColumns().Physical()) {
-			columns.push_back(col.GetName());
-		}
-	}
-
-	case_insensitive_set_t column_name_set;
-	vector<string> non_generated_column_names;
-	for (auto &col_name : columns) {
-		if (column_name_set.count(col_name) > 0) {
-			throw BinderException("cannot vacuum or analyze the same column twice, i.e., there is a duplicate entry in "
-			                      "the list of column names");
-		}
-		column_name_set.insert(col_name);
-		if (!table.ColumnExists(col_name)) {
-			throw BinderException("Column with name \"%s\" does not exist", col_name);
-		}
-		auto &col = table.GetColumn(col_name);
-		// ignore generated column
-		if (col.Generated()) {
-			throw BinderException(
-			    "cannot vacuum or analyze generated column \"%s\" - specify non-generated columns to vacuum or analyze",
-			    col.GetName());
-		}
-		non_generated_column_names.push_back(col_name);
-		ColumnRefExpression colref(col_name, table.name);
-		auto result = bind_context.BindColumn(colref, 0);
-		if (result.HasError()) {
-			result.error.Throw();
-		}
-		select_list.push_back(std::move(result.expression));
-	}
-	info.columns = std::move(non_generated_column_names);
-
-	auto table_scan = CreatePlan(*ref);
-	D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
-
-	auto &get = table_scan->Cast<LogicalGet>();
-
-	auto &column_ids = get.GetColumnIds();
-	D_ASSERT(select_list.size() == column_ids.size());
-	D_ASSERT(info.columns.size() == column_ids.size());
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		vacuum.column_id_map[i] = table.GetColumns().LogicalToPhysical(column_ids[i].ToLogical()).index;
-	}
-
-	auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
-	projection->children.push_back(std::move(table_scan));
-
-	root = std::move(projection);
-}
-
-BoundStatement Binder::Bind(VacuumStatement &stmt) {
-	BoundStatement result;
-
-	unique_ptr<LogicalOperator> root;
-
-	auto vacuum = make_uniq<LogicalVacuum>(std::move(stmt.info));
-	BindVacuumTable(*vacuum, root);
-	if (root) {
-		vacuum->children.push_back(std::move(root));
-	}
-
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = std::move(vacuum);
-
-	auto &properties = GetStatementProperties();
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp b/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp
deleted file mode 100644
index f2566cf71..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp
+++ /dev/null
@@ -1,324 +0,0 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/extension_helper.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/tableref/bound_cteref.hpp"
-#include "duckdb/planner/tableref/bound_dummytableref.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-#include "duckdb/catalog/catalog_search_path.hpp"
-
-namespace duckdb {
-
-static bool TryLoadExtensionForReplacementScan(ClientContext &context, const string &table_name) {
-	auto lower_name = StringUtil::Lower(table_name);
-	auto &dbconfig = DBConfig::GetConfig(context);
-
-	if (!dbconfig.options.autoload_known_extensions) {
-		return false;
-	}
-
-	for (const auto &entry : EXTENSION_FILE_POSTFIXES) {
-		if (StringUtil::EndsWith(lower_name, entry.name)) {
-			ExtensionHelper::AutoLoadExtension(context, entry.extension);
-			return true;
-		}
-	}
-
-	for (const auto &entry : EXTENSION_FILE_CONTAINS) {
-		if (StringUtil::Contains(lower_name, entry.name)) {
-			ExtensionHelper::AutoLoadExtension(context, entry.extension);
-			return true;
-		}
-	}
-
-	return false;
-}
-
-unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context, BaseTableRef &ref) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!context.config.use_replacement_scans) {
-		return nullptr;
-	}
-	for (auto &scan : config.replacement_scans) {
-		ReplacementScanInput input(ref.catalog_name, ref.schema_name, ref.table_name);
-		auto replacement_function = scan.function(context, input, scan.data.get());
-		if (!replacement_function) {
-			continue;
-		}
-		if (!ref.alias.empty()) {
-			// user-provided alias overrides the default alias
-			replacement_function->alias = ref.alias;
-		} else if (replacement_function->alias.empty()) {
-			// if the replacement scan itself did not provide an alias we use the table name
-			replacement_function->alias = ref.table_name;
-		}
-		if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
-			auto &table_function = replacement_function->Cast<TableFunctionRef>();
-			table_function.column_name_alias = ref.column_name_alias;
-		} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
-			auto &subquery = replacement_function->Cast<SubqueryRef>();
-			subquery.column_name_alias = ref.column_name_alias;
-		} else {
-			throw InternalException("Replacement scan should return either a table function or a subquery");
-		}
-		if (GetBindingMode() == BindingMode::EXTRACT_REPLACEMENT_SCANS) {
-			AddReplacementScan(ref.table_name, replacement_function->Copy());
-		}
-		return Bind(*replacement_function);
-	}
-	return nullptr;
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
-	QueryErrorContext error_context(ref.query_location);
-	// CTEs and views are also referred to using BaseTableRefs, hence need to distinguish here
-	// check if the table name refers to a CTE
-
-	// CTE name should never be qualified (i.e. schema_name should be empty)
-	vector<reference<CommonTableExpressionInfo>> found_ctes;
-	if (ref.schema_name.empty()) {
-		found_ctes = FindCTE(ref.table_name, ref.table_name == alias);
-	}
-
-	if (!found_ctes.empty()) {
-		// Check if there is a CTE binding in the BindContext
-		bool circular_cte = false;
-		for (auto found_cte : found_ctes) {
-			auto &cte = found_cte.get();
-			auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
-			if (ctebinding && (cte.query->node->type == QueryNodeType::RECURSIVE_CTE_NODE ||
-			                   cte.materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS)) {
-				// There is a CTE binding in the BindContext.
-				// This can only be the case if there is a recursive CTE,
-				// or a materialized CTE present.
-				auto index = GenerateTableIndex();
-				auto materialized = cte.materialized;
-				if (materialized == CTEMaterialize::CTE_MATERIALIZE_DEFAULT) {
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-					materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
-#else
-					materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
-#endif
-				}
-				auto result = make_uniq<BoundCTERef>(index, ctebinding->index, materialized);
-				auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
-				auto names = BindContext::AliasColumnNames(alias, ctebinding->names, ref.column_name_alias);
-
-				bind_context.AddGenericBinding(index, alias, names, ctebinding->types);
-				// Update references to CTE
-				auto cteref = bind_context.cte_references[ref.table_name];
-				(*cteref)++;
-
-				result->types = ctebinding->types;
-				result->bound_columns = std::move(names);
-				return std::move(result);
-			} else {
-				if (CTEIsAlreadyBound(cte)) {
-					// remember error state
-					circular_cte = true;
-					// retry with next candidate CTE
-					continue;
-				}
-
-				// If we have found a materialized CTE, but no corresponding CTE binding,
-				// something is wrong.
-				if (cte.materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-					throw BinderException(
-					    "There is a WITH item named \"%s\", but it cannot be referenced from this part of the query.",
-					    ref.table_name);
-				}
-
-				// Move CTE to subquery and bind recursively
-				SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte.query->Copy()));
-				subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-				subquery.column_name_alias = cte.aliases;
-				for (idx_t i = 0; i < ref.column_name_alias.size(); i++) {
-					if (i < subquery.column_name_alias.size()) {
-						subquery.column_name_alias[i] = ref.column_name_alias[i];
-					} else {
-						subquery.column_name_alias.push_back(ref.column_name_alias[i]);
-					}
-				}
-				return Bind(subquery, &found_cte.get());
-			}
-		}
-		if (circular_cte) {
-			auto replacement_scan_bind_result = BindWithReplacementScan(context, ref);
-			if (replacement_scan_bind_result) {
-				return replacement_scan_bind_result;
-			}
-
-			throw BinderException(
-			    "Circular reference to CTE \"%s\", There are two possible solutions. \n1. use WITH RECURSIVE to "
-			    "use recursive CTEs. \n2. If "
-			    "you want to use the TABLE name \"%s\" the same as the CTE name, please explicitly add "
-			    "\"SCHEMA\" before table name. You can try \"main.%s\" (main is the duckdb default schema)",
-			    ref.table_name, ref.table_name, ref.table_name);
-		}
-	}
-	// not a CTE
-	// extract a table or view from the catalog
-	BindSchemaOrCatalog(ref.catalog_name, ref.schema_name);
-	auto table_or_view = entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
-	                                              ref.table_name, OnEntryNotFound::RETURN_NULL, error_context);
-	// we still didn't find the table
-	if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		if (!table_or_view || table_or_view->type == CatalogType::TABLE_ENTRY) {
-			// if we are in EXTRACT_NAMES, we create a dummy table ref
-			AddTableName(ref.table_name);
-
-			// add a bind context entry
-			auto table_index = GenerateTableIndex();
-			auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
-			vector<LogicalType> types {LogicalType::INTEGER};
-			vector<string> names {"__dummy_col" + to_string(table_index)};
-			bind_context.AddGenericBinding(table_index, alias, names, types);
-			return make_uniq_base<BoundTableRef, BoundEmptyTableRef>(table_index);
-		}
-	}
-	if (!table_or_view) {
-		// table could not be found: try to bind a replacement scan
-		// Try replacement scan bind
-		auto replacement_scan_bind_result = BindWithReplacementScan(context, ref);
-		if (replacement_scan_bind_result) {
-			return replacement_scan_bind_result;
-		}
-
-		// Try autoloading an extension, then retry the replacement scan bind
-		auto full_path = ReplacementScan::GetFullPath(ref.catalog_name, ref.schema_name, ref.table_name);
-		auto extension_loaded = TryLoadExtensionForReplacementScan(context, full_path);
-		if (extension_loaded) {
-			replacement_scan_bind_result = BindWithReplacementScan(context, ref);
-			if (replacement_scan_bind_result) {
-				return replacement_scan_bind_result;
-			}
-		}
-		auto &config = DBConfig::GetConfig(context);
-		if (context.config.use_replacement_scans && config.options.enable_external_access &&
-		    ExtensionHelper::IsFullPath(full_path)) {
-			auto &fs = FileSystem::GetFileSystem(context);
-			if (fs.FileExists(full_path)) {
-				throw BinderException(
-				    "No extension found that is capable of reading the file \"%s\"\n* If this file is a supported file "
-				    "format you can explicitly use the reader functions, such as read_csv, read_json or read_parquet",
-				    full_path);
-			}
-		}
-
-		// could not find an alternative: bind again to get the error
-		(void)entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, ref.table_name,
-		                               OnEntryNotFound::THROW_EXCEPTION, error_context);
-		throw InternalException("Catalog::GetEntry should have thrown an exception above");
-	}
-
-	switch (table_or_view->type) {
-	case CatalogType::TABLE_ENTRY: {
-		// base table: create the BoundBaseTableRef node
-		auto table_index = GenerateTableIndex();
-		auto &table = table_or_view->Cast<TableCatalogEntry>();
-
-		auto &properties = GetStatementProperties();
-		properties.RegisterDBRead(table.ParentCatalog(), context);
-
-		unique_ptr<FunctionData> bind_data;
-		auto scan_function = table.GetScanFunction(context, bind_data);
-		// TODO: bundle the type and name vector in a struct (e.g PackedColumnMetadata)
-		vector<LogicalType> table_types;
-		vector<string> table_names;
-		vector<TableColumnType> table_categories;
-
-		vector<LogicalType> return_types;
-		vector<string> return_names;
-		for (auto &col : table.GetColumns().Logical()) {
-			table_types.push_back(col.Type());
-			table_names.push_back(col.Name());
-			return_types.push_back(col.Type());
-			return_names.push_back(col.Name());
-		}
-		table_names = BindContext::AliasColumnNames(ref.table_name, table_names, ref.column_name_alias);
-
-		auto logical_get =
-		    make_uniq<LogicalGet>(table_index, scan_function, std::move(bind_data), std::move(return_types),
-		                          std::move(return_names), table.GetRowIdType());
-		auto table_entry = logical_get->GetTable();
-		auto &col_ids = logical_get->GetMutableColumnIds();
-		if (!table_entry) {
-			bind_context.AddBaseTable(table_index, ref.alias, table_names, table_types, col_ids, ref.table_name);
-		} else {
-			bind_context.AddBaseTable(table_index, ref.alias, table_names, table_types, col_ids, *table_entry);
-		}
-		return make_uniq_base<BoundTableRef, BoundBaseTableRef>(table, std::move(logical_get));
-	}
-	case CatalogType::VIEW_ENTRY: {
-		// the node is a view: get the query that the view represents
-		auto &view_catalog_entry = table_or_view->Cast<ViewCatalogEntry>();
-		// We need to use a new binder for the view that doesn't reference any CTEs
-		// defined for this binder so there are no collisions between the CTEs defined
-		// for the view and for the current query
-		auto view_binder = Binder::CreateBinder(context, this, BinderType::VIEW_BINDER);
-		view_binder->can_contain_nulls = true;
-		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(view_catalog_entry.query->Copy()));
-		subquery.alias = ref.alias;
-		// construct view names by first (1) taking the view aliases, (2) adding the view names, then (3) applying
-		// subquery aliases
-		vector<string> view_names = view_catalog_entry.aliases;
-		for (idx_t n = view_names.size(); n < view_catalog_entry.names.size(); n++) {
-			view_names.push_back(view_catalog_entry.names[n]);
-		}
-		subquery.column_name_alias = BindContext::AliasColumnNames(ref.table_name, view_names, ref.column_name_alias);
-
-		// when binding a view, we always look into the catalog/schema where the view is stored first
-		vector<CatalogSearchEntry> view_search_path;
-		auto &catalog_name = view_catalog_entry.ParentCatalog().GetName();
-		auto &schema_name = view_catalog_entry.ParentSchema().name;
-		view_search_path.emplace_back(catalog_name, schema_name);
-		if (schema_name != DEFAULT_SCHEMA) {
-			view_search_path.emplace_back(view_catalog_entry.ParentCatalog().GetName(), DEFAULT_SCHEMA);
-		}
-		view_binder->entry_retriever.SetSearchPath(std::move(view_search_path));
-		// bind the child subquery
-		view_binder->AddBoundView(view_catalog_entry);
-		auto bound_child = view_binder->Bind(subquery);
-		if (!view_binder->correlated_columns.empty()) {
-			throw BinderException("Contents of view were altered - view bound correlated columns");
-		}
-
-		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
-		// verify that the types and names match up with the expected types and names
-		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
-		if (GetBindingMode() != BindingMode::EXTRACT_NAMES) {
-			if (bound_subquery.subquery->types != view_catalog_entry.types) {
-				auto actual_types = StringUtil::ToString(bound_subquery.subquery->types, ", ");
-				auto expected_types = StringUtil::ToString(view_catalog_entry.types, ", ");
-				throw BinderException(
-				    "Contents of view were altered: types don't match! Expected [%s], but found [%s] instead",
-				    expected_types, actual_types);
-			}
-			if (bound_subquery.subquery->names.size() == view_catalog_entry.names.size() &&
-			    bound_subquery.subquery->names != view_catalog_entry.names) {
-				auto actual_names = StringUtil::Join(bound_subquery.subquery->names, ", ");
-				auto expected_names = StringUtil::Join(view_catalog_entry.names, ", ");
-				throw BinderException(
-				    "Contents of view were altered: names don't match! Expected [%s], but found [%s] instead",
-				    expected_names, actual_names);
-			}
-		}
-		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,
-		                     *bound_subquery.subquery, view_catalog_entry);
-		return bound_child;
-	}
-	default:
-		throw InternalException("Catalog entry type");
-	}
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_column_data_ref.cpp b/src/duckdb/src/planner/binder/tableref/bind_column_data_ref.cpp
deleted file mode 100644
index e5587e8b0..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_column_data_ref.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/tableref/column_data_ref.hpp"
-#include "duckdb/planner/tableref/bound_column_data_ref.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(ColumnDataRef &ref) {
-	auto &collection = *ref.collection;
-	auto types = collection.Types();
-	auto result = make_uniq<BoundColumnDataRef>(collection);
-	result->bind_index = GenerateTableIndex();
-	bind_context.AddGenericBinding(result->bind_index, ref.alias, ref.expected_names, types);
-	return unique_ptr_cast<BoundColumnDataRef, BoundTableRef>(std::move(result));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_delimgetref.cpp b/src/duckdb/src/planner/binder/tableref/bind_delimgetref.cpp
deleted file mode 100644
index f280404f9..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_delimgetref.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/parser/tableref/delimgetref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_delimgetref.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(DelimGetRef &ref) {
-	// Have to add bindings
-	idx_t tbl_idx = GenerateTableIndex();
-	string internal_name = "__internal_delim_get_ref_" + std::to_string(tbl_idx);
-	bind_context.AddGenericBinding(tbl_idx, internal_name, ref.internal_aliases, ref.types);
-
-	return make_uniq<BoundDelimGetRef>(tbl_idx, ref.types);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_emptytableref.cpp b/src/duckdb/src/planner/binder/tableref/bind_emptytableref.cpp
deleted file mode 100644
index fe0e96f3d..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_emptytableref.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_dummytableref.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(EmptyTableRef &ref) {
-	return make_uniq<BoundEmptyTableRef>(GenerateTableIndex());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_expressionlistref.cpp b/src/duckdb/src/planner/binder/tableref/bind_expressionlistref.cpp
deleted file mode 100644
index 7176fb682..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_expressionlistref.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_expressionlistref.hpp"
-#include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "duckdb/planner/expression_binder/insert_binder.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
-	auto result = make_uniq<BoundExpressionListRef>();
-	result->types = expr.expected_types;
-	result->names = expr.expected_names;
-	auto prev_can_contain_nulls = this->can_contain_nulls;
-	// bind value list
-	InsertBinder binder(*this, context);
-	binder.target_type = LogicalType(LogicalTypeId::INVALID);
-	for (idx_t list_idx = 0; list_idx < expr.values.size(); list_idx++) {
-		auto &expression_list = expr.values[list_idx];
-		if (result->names.empty()) {
-			// no names provided, generate them
-			for (idx_t val_idx = 0; val_idx < expression_list.size(); val_idx++) {
-				result->names.push_back("col" + to_string(val_idx));
-			}
-		}
-
-		this->can_contain_nulls = true;
-		vector<unique_ptr<Expression>> list;
-		for (idx_t val_idx = 0; val_idx < expression_list.size(); val_idx++) {
-			if (!result->types.empty()) {
-				D_ASSERT(result->types.size() == expression_list.size());
-				binder.target_type = result->types[val_idx];
-			}
-			auto bound_expr = binder.Bind(expression_list[val_idx]);
-			list.push_back(std::move(bound_expr));
-		}
-		result->values.push_back(std::move(list));
-		this->can_contain_nulls = prev_can_contain_nulls;
-	}
-	if (result->types.empty() && !expr.values.empty()) {
-		// there are no types specified
-		// we have to figure out the result types
-		// for each column, we iterate over all of the expressions and select the max logical type
-		// we initialize all types to SQLNULL
-		result->types.resize(expr.values[0].size(), LogicalType::SQLNULL);
-		// now loop over the lists and select the max logical type
-		for (idx_t list_idx = 0; list_idx < result->values.size(); list_idx++) {
-			auto &list = result->values[list_idx];
-			for (idx_t val_idx = 0; val_idx < list.size(); val_idx++) {
-				auto &current_type = result->types[val_idx];
-				auto next_type = ExpressionBinder::GetExpressionReturnType(*list[val_idx]);
-				result->types[val_idx] = LogicalType::MaxLogicalType(context, current_type, next_type);
-			}
-		}
-		for (auto &type : result->types) {
-			type = LogicalType::NormalizeType(type);
-		}
-		// finally do another loop over the expressions and add casts where required
-		for (idx_t list_idx = 0; list_idx < result->values.size(); list_idx++) {
-			auto &list = result->values[list_idx];
-			for (idx_t val_idx = 0; val_idx < list.size(); val_idx++) {
-				list[val_idx] =
-				    BoundCastExpression::AddCastToType(context, std::move(list[val_idx]), result->types[val_idx]);
-			}
-		}
-	}
-	result->bind_index = GenerateTableIndex();
-	bind_context.AddGenericBinding(result->bind_index, expr.alias, result->names, result->types);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp b/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp
deleted file mode 100644
index 257e275be..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-#include "duckdb/parser/tableref/joinref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/planner/expression_binder/lateral_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &context, const BindingAlias &alias,
-                                               const string &column_name) {
-	auto expr = make_uniq_base<ParsedExpression, ColumnRefExpression>(column_name, alias);
-	ExpressionBinder expr_binder(binder, context);
-	auto result = expr_binder.Bind(expr);
-	return make_uniq<BoundExpression>(std::move(result));
-}
-
-static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder &left_binder, Binder &right_binder,
-                                                 const BindingAlias &left_alias, const BindingAlias &right_alias,
-                                                 const string &column_name, ExpressionType type) {
-	ExpressionBinder expr_binder(left_binder, context);
-	auto left = BindColumn(left_binder, context, left_alias, column_name);
-	auto right = BindColumn(right_binder, context, right_alias, column_name);
-	return make_uniq<ComparisonExpression>(type, std::move(left), std::move(right));
-}
-
-bool Binder::TryFindBinding(const string &using_column, const string &join_side, BindingAlias &result) {
-	// for each using column, get the matching binding
-	auto bindings = bind_context.GetMatchingBindings(using_column);
-	if (bindings.empty()) {
-		return false;
-	}
-	// find the join binding
-	for (auto &binding : bindings) {
-		if (result.IsSet()) {
-			string error = "Column name \"";
-			error += using_column;
-			error += "\" is ambiguous: it exists more than once on ";
-			error += join_side;
-			error += " side of join.\nCandidates:";
-			for (auto &binding_ref : bindings) {
-				auto &other_binding = binding_ref.get();
-				error += "\n\t";
-				error += other_binding.GetAlias();
-				error += ".";
-				error += bind_context.GetActualColumnName(other_binding, using_column);
-			}
-			throw BinderException(error);
-		} else {
-			result = binding.get().alias;
-		}
-	}
-	return true;
-}
-
-BindingAlias Binder::FindBinding(const string &using_column, const string &join_side) {
-	BindingAlias result;
-	if (!TryFindBinding(using_column, join_side, result)) {
-		throw BinderException("Column \"%s\" does not exist on %s side of join!", using_column, join_side);
-	}
-	return result;
-}
-
-static void AddUsingBindings(UsingColumnSet &set, optional_ptr<UsingColumnSet> input_set,
-                             const BindingAlias &input_binding) {
-	if (input_set) {
-		for (auto &entry : input_set->bindings) {
-			set.bindings.push_back(entry);
-		}
-	} else {
-		set.bindings.push_back(input_binding);
-	}
-}
-
-static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const BindingAlias &left_binding,
-                              const BindingAlias &right_binding) {
-	switch (join_type) {
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-		set.primary_binding = left_binding;
-		break;
-	case JoinType::RIGHT:
-	case JoinType::RIGHT_SEMI:
-	case JoinType::RIGHT_ANTI:
-		set.primary_binding = right_binding;
-		break;
-	default:
-		break;
-	}
-}
-
-BindingAlias Binder::RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
-                                          const string &using_column, const string &join_side) {
-	BindingAlias binding;
-	if (!current_set) {
-		binding = current_binder.FindBinding(using_column, join_side);
-	} else {
-		binding = current_set->primary_binding;
-	}
-	return binding;
-}
-
-static vector<string> RemoveDuplicateUsingColumns(const vector<string> &using_columns) {
-	vector<string> result;
-	case_insensitive_set_t handled_columns;
-	for (auto &using_column : using_columns) {
-		if (handled_columns.find(using_column) == handled_columns.end()) {
-			handled_columns.insert(using_column);
-			result.push_back(using_column);
-		}
-	}
-	return result;
-}
-
-unique_ptr<BoundTableRef> Binder::BindJoin(Binder &parent_binder, TableRef &ref) {
-	unnamed_subquery_index = parent_binder.unnamed_subquery_index;
-	auto result = Bind(ref);
-	parent_binder.unnamed_subquery_index = unnamed_subquery_index;
-	return result;
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
-	auto result = make_uniq<BoundJoinRef>(ref.ref_type);
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->right_binder = Binder::CreateBinder(context, this);
-	auto &left_binder = *result->left_binder;
-	auto &right_binder = *result->right_binder;
-
-	result->type = ref.type;
-	result->left = left_binder.BindJoin(*this, *ref.left);
-	result->delim_flipped = ref.delim_flipped;
-
-	{
-		LateralBinder binder(left_binder, context);
-		result->right = right_binder.BindJoin(*this, *ref.right);
-		if (!ref.duplicate_eliminated_columns.empty()) {
-			if (ref.delim_flipped) {
-				// We gotta use the expression binder of the right side
-				ExpressionBinder expr_binder(right_binder, context);
-				for (auto &col : ref.duplicate_eliminated_columns) {
-					result->duplicate_eliminated_columns.emplace_back(expr_binder.Bind(col));
-				}
-			} else {
-				// We use the left side
-				ExpressionBinder expr_binder(left_binder, context);
-				for (auto &col : ref.duplicate_eliminated_columns) {
-					result->duplicate_eliminated_columns.emplace_back(expr_binder.Bind(col));
-				}
-			}
-		}
-		bool is_lateral = false;
-		// Store the correlated columns in the right binder in bound ref for planning of LATERALs
-		// Ignore the correlated columns in the left binder, flattening handles those correlations
-		result->correlated_columns = right_binder.correlated_columns;
-		// Find correlations for the current join
-		for (auto &cor_col : result->correlated_columns) {
-			if (cor_col.depth == 1) {
-				// Depth 1 indicates columns binding from the left indicating a lateral join
-				is_lateral = true;
-				break;
-			}
-		}
-		result->lateral = is_lateral;
-		if (result->lateral) {
-			// lateral join: can only be an INNER or LEFT join
-			if (ref.type != JoinType::INNER && ref.type != JoinType::LEFT) {
-				throw BinderException("The combining JOIN type must be INNER or LEFT for a LATERAL reference");
-			}
-		}
-	}
-
-	vector<unique_ptr<ParsedExpression>> extra_conditions;
-	vector<string> extra_using_columns;
-	switch (ref.ref_type) {
-	case JoinRefType::NATURAL: {
-		// natural join, figure out which column names are present in both sides of the join
-		// first bind the left hand side and get a list of all the tables and column names
-		case_insensitive_set_t lhs_columns;
-		auto &lhs_binding_list = left_binder.bind_context.GetBindingsList();
-		for (auto &binding : lhs_binding_list) {
-			for (auto &column_name : binding->names) {
-				lhs_columns.insert(column_name);
-			}
-		}
-		// now bind the rhs
-		for (auto &column_name : lhs_columns) {
-			auto right_using_binding = right_binder.bind_context.GetUsingBinding(column_name);
-
-			BindingAlias right_binding;
-			// loop over the set of lhs columns, and figure out if there is a table in the rhs with the same name
-			if (!right_using_binding) {
-				if (!right_binder.TryFindBinding(column_name, "right", right_binding)) {
-					// no match found for this column on the rhs: skip
-					continue;
-				}
-			}
-			extra_using_columns.push_back(column_name);
-		}
-		if (extra_using_columns.empty()) {
-			// no matching bindings found in natural join: throw an exception
-			string error_msg = "No columns found to join on in NATURAL JOIN.\n";
-			error_msg += "Use CROSS JOIN if you intended for this to be a cross-product.";
-			// gather all left/right candidates
-			string left_candidates, right_candidates;
-			auto &rhs_binding_list = right_binder.bind_context.GetBindingsList();
-			for (auto &binding_ref : lhs_binding_list) {
-				auto &binding = *binding_ref;
-				for (auto &column_name : binding.names) {
-					if (!left_candidates.empty()) {
-						left_candidates += ", ";
-					}
-					left_candidates += binding.GetAlias() + "." + column_name;
-				}
-			}
-			for (auto &binding_ref : rhs_binding_list) {
-				auto &binding = *binding_ref;
-				for (auto &column_name : binding.names) {
-					if (!right_candidates.empty()) {
-						right_candidates += ", ";
-					}
-					right_candidates += binding.GetAlias() + "." + column_name;
-				}
-			}
-			error_msg += "\n   Left candidates: " + left_candidates;
-			error_msg += "\n   Right candidates: " + right_candidates;
-			throw BinderException(ref, error_msg);
-		}
-		break;
-	}
-	case JoinRefType::REGULAR:
-	case JoinRefType::ASOF:
-		if (!ref.using_columns.empty()) {
-			// USING columns
-			D_ASSERT(!result->condition);
-			extra_using_columns = ref.using_columns;
-		}
-		break;
-
-	case JoinRefType::CROSS:
-	case JoinRefType::POSITIONAL:
-	case JoinRefType::DEPENDENT:
-		break;
-	}
-	extra_using_columns = RemoveDuplicateUsingColumns(extra_using_columns);
-
-	if (!extra_using_columns.empty()) {
-		vector<optional_ptr<UsingColumnSet>> left_using_bindings;
-		vector<optional_ptr<UsingColumnSet>> right_using_bindings;
-		for (idx_t i = 0; i < extra_using_columns.size(); i++) {
-			auto &using_column = extra_using_columns[i];
-			// we check if there is ALREADY a using column of the same name in the left and right set
-			// this can happen if we chain USING clauses
-			// e.g. x JOIN y USING (c) JOIN z USING (c)
-			auto left_using_binding = left_binder.bind_context.GetUsingBinding(using_column);
-			auto right_using_binding = right_binder.bind_context.GetUsingBinding(using_column);
-			if (!left_using_binding) {
-				left_binder.bind_context.GetMatchingBinding(using_column);
-			}
-			if (!right_using_binding) {
-				right_binder.bind_context.GetMatchingBinding(using_column);
-			}
-			left_using_bindings.push_back(left_using_binding);
-			right_using_bindings.push_back(right_using_binding);
-		}
-
-		for (idx_t i = 0; i < extra_using_columns.size(); i++) {
-			auto &using_column = extra_using_columns[i];
-			BindingAlias left_binding;
-			BindingAlias right_binding;
-
-			auto set = make_uniq<UsingColumnSet>();
-			auto &left_using_binding = left_using_bindings[i];
-			auto &right_using_binding = right_using_bindings[i];
-			left_binding = RetrieveUsingBinding(left_binder, left_using_binding, using_column, "left");
-			right_binding = RetrieveUsingBinding(right_binder, right_using_binding, using_column, "right");
-
-			// Last column of ASOF JOIN ... USING is >=
-			const auto type = (ref.ref_type == JoinRefType::ASOF && i == extra_using_columns.size() - 1)
-			                      ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
-			                      : ExpressionType::COMPARE_EQUAL;
-
-			extra_conditions.push_back(
-			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column, type));
-
-			AddUsingBindings(*set, left_using_binding, left_binding);
-			AddUsingBindings(*set, right_using_binding, right_binding);
-			SetPrimaryBinding(*set, ref.type, left_binding, right_binding);
-			bind_context.TransferUsingBinding(left_binder.bind_context, left_using_binding, *set, using_column);
-			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, *set, using_column);
-			AddUsingBindingSet(std::move(set));
-		}
-	}
-
-	auto right_bindings = right_binder.bind_context.GetBindingAliases();
-	auto left_bindings = left_binder.bind_context.GetBindingAliases();
-
-	bind_context.AddContext(std::move(left_binder.bind_context));
-	bind_context.AddContext(std::move(right_binder.bind_context));
-
-	// Update the correlated columns for the parent binder
-	// For the left binder, depth >= 1 indicates correlations from the parent binder
-	for (const auto &col : left_binder.correlated_columns) {
-		if (col.depth >= 1) {
-			AddCorrelatedColumn(col);
-		}
-	}
-	// For the right binder, depth > 1 indicates correlations from the parent binder
-	// (depth = 1 indicates correlations from the left side of the join)
-	for (auto col : right_binder.correlated_columns) {
-		if (col.depth > 1) {
-			// Decrement the depth to account for the effect of the lateral binder
-			col.depth--;
-			AddCorrelatedColumn(col);
-		}
-	}
-
-	for (auto &condition : extra_conditions) {
-		if (ref.condition) {
-			ref.condition = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(ref.condition),
-			                                                 std::move(condition));
-		} else {
-			ref.condition = std::move(condition);
-		}
-	}
-	if (ref.condition) {
-		WhereBinder binder(*this, context);
-		result->condition = binder.Bind(ref.condition);
-	}
-
-	if (result->type == JoinType::SEMI || result->type == JoinType::ANTI || result->type == JoinType::MARK) {
-		bind_context.RemoveContext(right_bindings);
-		if (result->type == JoinType::MARK) {
-			auto mark_join_idx = GenerateTableIndex();
-			string mark_join_alias = "__internal_mark_join_ref" + to_string(mark_join_idx);
-			bind_context.AddGenericBinding(mark_join_idx, mark_join_alias, {"__mark_index_column"},
-			                               {LogicalType::BOOLEAN});
-			result->mark_index = mark_join_idx;
-		}
-	}
-	if (result->type == JoinType::RIGHT_SEMI || result->type == JoinType::RIGHT_ANTI) {
-		bind_context.RemoveContext(left_bindings);
-	}
-
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_named_parameters.cpp b/src/duckdb/src/planner/binder/tableref/bind_named_parameters.cpp
deleted file mode 100644
index e2a6537d1..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_named_parameters.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-void Binder::BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
-                                 QueryErrorContext &error_context, string &func_name) {
-	for (auto &kv : values) {
-		auto entry = types.find(kv.first);
-		if (entry == types.end()) {
-			// create a list of named parameters for the error
-			string named_params;
-			for (auto &kv : types) {
-				named_params += "    ";
-				named_params += kv.first;
-				named_params += " ";
-				named_params += kv.second.ToString();
-				named_params += "\n";
-			}
-			string error_msg;
-			if (named_params.empty()) {
-				error_msg = "Function does not accept any named parameters.";
-			} else {
-				error_msg = "Candidates:\n" + named_params;
-			}
-			throw BinderException(error_context, "Invalid named parameter \"%s\" for function %s\n%s", kv.first,
-			                      func_name, error_msg);
-		}
-		if (entry->second.id() != LogicalTypeId::ANY) {
-			kv.second = kv.second.DefaultCastAs(entry->second);
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp b/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp
deleted file mode 100644
index 3899ecdd6..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp
+++ /dev/null
@@ -1,760 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/common/types/value_map.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-#include "duckdb/planner/tableref/bound_pivotref.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/main/query_result.hpp"
-
-namespace duckdb {
-
-static void ConstructPivots(PivotRef &ref, vector<PivotValueElement> &pivot_values, idx_t pivot_idx = 0,
-                            const PivotValueElement &current_value = PivotValueElement()) {
-	auto &pivot = ref.pivots[pivot_idx];
-	bool last_pivot = pivot_idx + 1 == ref.pivots.size();
-	for (auto &entry : pivot.entries) {
-		PivotValueElement new_value = current_value;
-		string name = entry.alias;
-		D_ASSERT(entry.values.size() == pivot.pivot_expressions.size());
-		for (idx_t v = 0; v < entry.values.size(); v++) {
-			auto &value = entry.values[v];
-			new_value.values.push_back(value);
-			if (entry.alias.empty()) {
-				if (name.empty()) {
-					name = value.ToString();
-				} else {
-					name += "_" + value.ToString();
-				}
-			}
-		}
-		if (!current_value.name.empty()) {
-			new_value.name = current_value.name + "_" + name;
-		} else {
-			new_value.name = std::move(name);
-		}
-		if (last_pivot) {
-			pivot_values.push_back(std::move(new_value));
-		} else {
-			// need to recurse
-			ConstructPivots(ref, pivot_values, pivot_idx + 1, new_value);
-		}
-	}
-}
-
-static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set_t &handled_columns) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &child_colref = expr.Cast<ColumnRefExpression>();
-		if (child_colref.IsQualified()) {
-			throw BinderException("PIVOT expression cannot contain qualified columns");
-		}
-		handled_columns.insert(child_colref.GetColumnName());
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](ParsedExpression &child) { ExtractPivotExpressions(child, handled_columns); });
-}
-
-void ExtractPivotAggregateExpression(ClientContext &context, ParsedExpression &expr,
-                                     vector<reference<FunctionExpression>> &aggregates) {
-	if (expr.GetExpressionType() == ExpressionType::FUNCTION) {
-		auto &aggr_function = expr.Cast<FunctionExpression>();
-
-		// check if this is an aggregate to ensure it is an aggregate and not a scalar function
-		auto &entry = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, aggr_function.catalog,
-		                                aggr_function.schema, aggr_function.function_name);
-		if (entry.type == CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-			// aggregate
-			aggregates.push_back(aggr_function);
-			return;
-		}
-	}
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		throw BinderException(expr, "Columns can only be referenced within the aggregate of a PIVOT expression");
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](ParsedExpression &child) { ExtractPivotAggregateExpression(context, child, aggregates); });
-}
-
-static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns,
-                                                       const case_insensitive_set_t &handled_columns) {
-	auto subquery = make_uniq<SelectNode>();
-	subquery->from_table = std::move(ref.source);
-	if (ref.groups.empty()) {
-		// if rows are not specified any columns that are not pivoted/aggregated on are added to the GROUP BY clause
-		for (auto &entry : all_columns) {
-			auto column_entry = Binder::GetResolvedColumnExpression(*entry);
-			if (!column_entry) {
-				throw InternalException("Unexpected child of pivot source - not a ColumnRef");
-			}
-			auto &columnref = column_entry->Cast<ColumnRefExpression>();
-			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
-				// not handled - add to grouping set
-				subquery->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-				    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery->select_list.size() + 1))));
-				subquery->select_list.push_back(make_uniq<ColumnRefExpression>(columnref.GetColumnName()));
-			}
-		}
-	} else {
-		// if rows are specified only the columns mentioned in rows are added as groups
-		for (auto &row : ref.groups) {
-			subquery->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-			    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery->select_list.size() + 1))));
-			subquery->select_list.push_back(make_uniq<ColumnRefExpression>(row));
-		}
-	}
-	return subquery;
-}
-
-static unique_ptr<SelectNode> PivotFilteredAggregate(ClientContext &context, PivotRef &ref,
-                                                     vector<unique_ptr<ParsedExpression>> all_columns,
-                                                     const case_insensitive_set_t &handled_columns,
-                                                     vector<PivotValueElement> pivot_values) {
-	auto subquery = ConstructInitialGrouping(ref, std::move(all_columns), handled_columns);
-
-	// push the filtered aggregates
-	for (auto &pivot_value : pivot_values) {
-		unique_ptr<ParsedExpression> filter;
-		idx_t pivot_value_idx = 0;
-		for (auto &pivot_column : ref.pivots) {
-			for (auto &pivot_expr : pivot_column.pivot_expressions) {
-				auto column_ref = make_uniq<CastExpression>(LogicalType::VARCHAR, pivot_expr->Copy());
-				auto constant_value = make_uniq<ConstantExpression>(
-				    pivot_value.values[pivot_value_idx++].DefaultCastAs(LogicalType::VARCHAR));
-				auto comp_expr = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-				                                                 std::move(column_ref), std::move(constant_value));
-				if (filter) {
-					filter = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(filter),
-					                                          std::move(comp_expr));
-				} else {
-					filter = std::move(comp_expr);
-				}
-			}
-		}
-		for (auto &aggregate : ref.aggregates) {
-			auto copied_aggr = aggregate->Copy();
-
-			vector<reference<FunctionExpression>> aggregates;
-			ExtractPivotAggregateExpression(context, *copied_aggr, aggregates);
-			D_ASSERT(aggregates.size() == 1);
-
-			auto &aggr = aggregates[0].get().Cast<FunctionExpression>();
-			aggr.filter = filter->Copy();
-			auto &aggr_name = aggregate->GetAlias();
-			auto name = pivot_value.name;
-			if (ref.aggregates.size() > 1 || !aggr_name.empty()) {
-				// if there are multiple aggregates specified we add the name of the aggregate as well
-				name += "_" + (aggr_name.empty() ? aggregate->GetName() : aggr_name);
-			}
-			copied_aggr->SetAlias(name);
-			subquery->select_list.push_back(std::move(copied_aggr));
-		}
-	}
-	return subquery;
-}
-
-struct PivotBindState {
-	vector<string> internal_group_names;
-	vector<string> group_names;
-	vector<string> aggregate_names;
-	vector<string> internal_aggregate_names;
-};
-
-static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state, PivotRef &ref,
-                                                    vector<unique_ptr<ParsedExpression>> all_columns,
-                                                    const case_insensitive_set_t &handled_columns) {
-	auto subquery_stage1 = ConstructInitialGrouping(ref, std::move(all_columns), handled_columns);
-
-	idx_t group_count = 0;
-	for (auto &expr : subquery_stage1->select_list) {
-		bind_state.group_names.push_back(expr->GetName());
-		if (expr->GetAlias().empty()) {
-			expr->SetAlias("__internal_pivot_group" + std::to_string(++group_count));
-		}
-		bind_state.internal_group_names.push_back(expr->GetAlias());
-	}
-	// group by all of the pivot values
-	idx_t pivot_count = 0;
-	for (auto &pivot_column : ref.pivots) {
-		for (auto &pivot_expr : pivot_column.pivot_expressions) {
-			if (pivot_expr->GetAlias().empty()) {
-				pivot_expr->SetAlias("__internal_pivot_ref" + std::to_string(++pivot_count));
-			}
-			auto pivot_alias = pivot_expr->GetAlias();
-			subquery_stage1->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-			    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery_stage1->select_list.size() + 1))));
-			subquery_stage1->select_list.push_back(std::move(pivot_expr));
-			pivot_expr = make_uniq<ColumnRefExpression>(std::move(pivot_alias));
-		}
-	}
-	idx_t aggregate_count = 0;
-	// finally add the aggregates
-	for (auto &aggregate : ref.aggregates) {
-		auto aggregate_alias = "__internal_pivot_aggregate" + std::to_string(++aggregate_count);
-		bind_state.aggregate_names.push_back(aggregate->GetAlias());
-		bind_state.internal_aggregate_names.push_back(aggregate_alias);
-		aggregate->SetAlias(std::move(aggregate_alias));
-		subquery_stage1->select_list.push_back(std::move(aggregate));
-	}
-	return subquery_stage1;
-}
-
-unique_ptr<ParsedExpression> ConstructPivotExpression(unique_ptr<ParsedExpression> pivot_expr) {
-	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(pivot_expr));
-	vector<unique_ptr<ParsedExpression>> coalesce_children;
-	coalesce_children.push_back(std::move(cast));
-	coalesce_children.push_back(make_uniq<ConstantExpression>(Value("NULL")));
-	auto coalesce = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE, std::move(coalesce_children));
-	return std::move(coalesce);
-}
-
-static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, PivotRef &ref,
-                                                 unique_ptr<SelectNode> subquery_stage1) {
-	auto subquery_stage2 = make_uniq<SelectNode>();
-	// wrap the subquery of stage 1
-	auto subquery_select = make_uniq<SelectStatement>();
-	subquery_select->node = std::move(subquery_stage1);
-	auto subquery_ref = make_uniq<SubqueryRef>(std::move(subquery_select));
-
-	// add all of the groups
-	for (idx_t gr = 0; gr < bind_state.internal_group_names.size(); gr++) {
-		subquery_stage2->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-		    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery_stage2->select_list.size() + 1))));
-		auto group_reference = make_uniq<ColumnRefExpression>(bind_state.internal_group_names[gr]);
-		group_reference->SetAlias(bind_state.internal_group_names[gr]);
-		subquery_stage2->select_list.push_back(std::move(group_reference));
-	}
-
-	// construct the list aggregates
-	for (idx_t aggr = 0; aggr < bind_state.internal_aggregate_names.size(); aggr++) {
-		auto colref = make_uniq<ColumnRefExpression>(bind_state.internal_aggregate_names[aggr]);
-		vector<unique_ptr<ParsedExpression>> list_children;
-		list_children.push_back(std::move(colref));
-		auto aggregate = make_uniq<FunctionExpression>("list", std::move(list_children));
-		aggregate->SetAlias(bind_state.internal_aggregate_names[aggr]);
-		subquery_stage2->select_list.push_back(std::move(aggregate));
-	}
-	// construct the pivot list
-	auto pivot_name = "__internal_pivot_name";
-	unique_ptr<ParsedExpression> expr;
-	for (auto &pivot : ref.pivots) {
-		for (auto &pivot_expr : pivot.pivot_expressions) {
-			// coalesce(pivot::VARCHAR, 'NULL')
-			auto coalesce = ConstructPivotExpression(std::move(pivot_expr));
-			if (!expr) {
-				expr = std::move(coalesce);
-			} else {
-				// string concat
-				vector<unique_ptr<ParsedExpression>> concat_children;
-				concat_children.push_back(std::move(expr));
-				concat_children.push_back(make_uniq<ConstantExpression>(Value("_")));
-				concat_children.push_back(std::move(coalesce));
-				auto concat = make_uniq<FunctionExpression>("concat", std::move(concat_children));
-				expr = std::move(concat);
-			}
-		}
-	}
-	// list(coalesce)
-	vector<unique_ptr<ParsedExpression>> list_children;
-	list_children.push_back(std::move(expr));
-	auto aggregate = make_uniq<FunctionExpression>("list", std::move(list_children));
-
-	aggregate->SetAlias(pivot_name);
-	subquery_stage2->select_list.push_back(std::move(aggregate));
-
-	subquery_stage2->from_table = std::move(subquery_ref);
-	return subquery_stage2;
-}
-
-static unique_ptr<SelectNode> PivotFinalOperator(PivotBindState &bind_state, PivotRef &ref,
-                                                 unique_ptr<SelectNode> subquery,
-                                                 vector<PivotValueElement> pivot_values) {
-	auto final_pivot_operator = make_uniq<SelectNode>();
-	// wrap the subquery of stage 1
-	auto subquery_select = make_uniq<SelectStatement>();
-	subquery_select->node = std::move(subquery);
-	auto subquery_ref = make_uniq<SubqueryRef>(std::move(subquery_select));
-
-	auto bound_pivot = make_uniq<PivotRef>();
-	bound_pivot->bound_pivot_values = std::move(pivot_values);
-	bound_pivot->bound_group_names = std::move(bind_state.group_names);
-	bound_pivot->bound_aggregate_names = std::move(bind_state.aggregate_names);
-	bound_pivot->source = std::move(subquery_ref);
-
-	final_pivot_operator->select_list.push_back(make_uniq<StarExpression>());
-	final_pivot_operator->from_table = std::move(bound_pivot);
-	return final_pivot_operator;
-}
-
-void ExtractPivotAggregates(BoundTableRef &node, vector<unique_ptr<Expression>> &aggregates) {
-	if (node.type != TableReferenceType::SUBQUERY) {
-		throw InternalException("Pivot - Expected a subquery");
-	}
-	auto &subq = node.Cast<BoundSubqueryRef>();
-	if (subq.subquery->type != QueryNodeType::SELECT_NODE) {
-		throw InternalException("Pivot - Expected a select node");
-	}
-	auto &select = subq.subquery->Cast<BoundSelectNode>();
-	if (select.from_table->type != TableReferenceType::SUBQUERY) {
-		throw InternalException("Pivot - Expected another subquery");
-	}
-	auto &subq2 = select.from_table->Cast<BoundSubqueryRef>();
-	if (subq2.subquery->type != QueryNodeType::SELECT_NODE) {
-		throw InternalException("Pivot - Expected another select node");
-	}
-	auto &select2 = subq2.subquery->Cast<BoundSelectNode>();
-	for (auto &aggr : select2.aggregates) {
-		if (aggr->GetAlias() == "__collated_group") {
-			continue;
-		}
-		aggregates.push_back(aggr->Copy());
-	}
-}
-
-unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
-	// bind the child table in a child binder
-	auto result = make_uniq<BoundPivotRef>();
-	result->bind_index = GenerateTableIndex();
-	result->child_binder = Binder::CreateBinder(context, this);
-	result->child = result->child_binder->Bind(*ref.source);
-
-	auto &aggregates = result->bound_pivot.aggregates;
-	ExtractPivotAggregates(*result->child, aggregates);
-	if (aggregates.size() != ref.bound_aggregate_names.size()) {
-		throw InternalException("Pivot aggregate count mismatch (expected %llu, found %llu)",
-		                        ref.bound_aggregate_names.size(), aggregates.size());
-	}
-
-	vector<string> child_names;
-	vector<LogicalType> child_types;
-	result->child_binder->bind_context.GetTypesAndNames(child_names, child_types);
-
-	vector<string> names;
-	vector<LogicalType> types;
-	// emit the groups
-	for (idx_t i = 0; i < ref.bound_group_names.size(); i++) {
-		names.push_back(ref.bound_group_names[i]);
-		types.push_back(child_types[i]);
-	}
-	// emit the pivot columns
-	for (auto &pivot_value : ref.bound_pivot_values) {
-		for (idx_t aggr_idx = 0; aggr_idx < ref.bound_aggregate_names.size(); aggr_idx++) {
-			auto &aggr = aggregates[aggr_idx];
-			auto &aggr_name = ref.bound_aggregate_names[aggr_idx];
-			auto name = pivot_value.name;
-			if (aggregates.size() > 1 || !aggr_name.empty()) {
-				// if there are multiple aggregates specified we add the name of the aggregate as well
-				name += "_" + (aggr_name.empty() ? aggr->GetName() : aggr_name);
-			}
-			string pivot_str;
-			for (auto &value : pivot_value.values) {
-				auto str = value.ToString();
-				if (pivot_str.empty()) {
-					pivot_str = std::move(str);
-				} else {
-					pivot_str += "_" + str;
-				}
-			}
-			result->bound_pivot.pivot_values.push_back(std::move(pivot_str));
-			names.push_back(std::move(name));
-			types.push_back(aggr->return_type);
-		}
-	}
-	result->bound_pivot.group_count = ref.bound_group_names.size();
-	result->bound_pivot.types = types;
-	auto subquery_alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
-	QueryResult::DeduplicateColumns(names);
-	bind_context.AddGenericBinding(result->bind_index, subquery_alias, names, types);
-
-	MoveCorrelatedExpressions(*result->child_binder);
-	return std::move(result);
-}
-
-unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns) {
-	// keep track of the columns by which we pivot/aggregate
-	// any columns which are not pivoted/aggregated on are added to the GROUP BY clause
-	case_insensitive_set_t handled_columns;
-
-	vector<reference<FunctionExpression>> pivot_aggregates;
-	// parse the aggregate, and extract the referenced columns from the aggregate
-	for (auto &aggr : ref.aggregates) {
-		if (aggr->HasSubquery()) {
-			throw BinderException(*aggr, "Pivot expression cannot contain subqueries");
-		}
-		if (aggr->IsWindow()) {
-			throw BinderException(*aggr, "Pivot expression cannot contain window functions");
-		}
-		idx_t aggregate_count = pivot_aggregates.size();
-		ExtractPivotAggregateExpression(context, *aggr, pivot_aggregates);
-		if (pivot_aggregates.size() != aggregate_count + 1) {
-			string error_str = pivot_aggregates.size() == aggregate_count
-			                       ? "but no aggregates were found"
-			                       : "but " + to_string(pivot_aggregates.size() - aggregate_count) + " were found";
-			throw BinderException(*aggr, "Pivot expression must contain exactly one aggregate, %s", error_str);
-		}
-	}
-	for (auto &aggr : pivot_aggregates) {
-		ExtractPivotExpressions(aggr.get(), handled_columns);
-	}
-
-	// first add all pivots to the set of handled columns, and check for duplicates
-	idx_t total_pivots = 1;
-	for (auto &pivot : ref.pivots) {
-		if (!pivot.pivot_enum.empty()) {
-			auto &type_entry =
-			    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, INVALID_SCHEMA, pivot.pivot_enum);
-			auto type = type_entry.user_type;
-			if (type.id() != LogicalTypeId::ENUM) {
-				throw BinderException(ref, "Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
-				                      pivot.pivot_enum, type.ToString());
-			}
-			if (!type.IsComplete()) {
-				throw BinderException("ENUM type is incomplete");
-			}
-			auto enum_size = EnumType::GetSize(type);
-			for (idx_t i = 0; i < enum_size; i++) {
-				auto enum_value = EnumType::GetValue(Value::ENUM(i, type));
-				PivotColumnEntry entry;
-				entry.values.emplace_back(enum_value);
-				entry.alias = std::move(enum_value);
-				pivot.entries.push_back(std::move(entry));
-			}
-		}
-		total_pivots *= pivot.entries.size();
-		// add the pivoted column to the columns that have been handled
-		for (auto &pivot_name : pivot.pivot_expressions) {
-			ExtractPivotExpressions(*pivot_name, handled_columns);
-		}
-		value_set_t pivots;
-		for (auto &entry : pivot.entries) {
-			D_ASSERT(!entry.expr);
-			Value val;
-			if (entry.values.size() == 1) {
-				val = entry.values[0];
-			} else {
-				val = Value::LIST(LogicalType::VARCHAR, entry.values);
-			}
-			if (pivots.find(val) != pivots.end()) {
-				throw BinderException(ref, "The value \"%s\" was specified multiple times in the IN clause",
-				                      val.ToString());
-			}
-			if (entry.values.size() != pivot.pivot_expressions.size()) {
-				throw BinderException(ref, "PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
-				                      pivot.pivot_expressions.size(), entry.values.size());
-			}
-			pivots.insert(val);
-		}
-	}
-	auto &client_config = ClientConfig::GetConfig(context);
-	auto pivot_limit = client_config.pivot_limit;
-	if (total_pivots >= pivot_limit) {
-		throw BinderException(ref, "Pivot column limit of %llu exceeded. Use SET pivot_limit=X to increase the limit.",
-		                      client_config.pivot_limit);
-	}
-
-	// construct the required pivot values recursively
-	vector<PivotValueElement> pivot_values;
-	ConstructPivots(ref, pivot_values);
-
-	unique_ptr<SelectNode> pivot_node;
-	// pivots have three components
-	// - the pivots (i.e. future column names)
-	// - the groups (i.e. the future row names
-	// - the aggregates (i.e. the values of the pivot columns)
-
-	// we have two ways of executing a pivot statement
-	// (1) the straightforward manner of filtered aggregates SUM(..) FILTER (pivot_value=X)
-	// (2) computing the aggregates once, then using LIST to group the aggregates together with the PIVOT operator
-	// -> filtered aggregates are faster when there are FEW pivot values
-	// -> LIST is faster when there are MANY pivot values
-	// we switch dynamically based on the number of pivots to compute
-	if (pivot_values.size() <= client_config.pivot_filter_threshold) {
-		// use a set of filtered aggregates
-		pivot_node =
-		    PivotFilteredAggregate(context, ref, std::move(all_columns), handled_columns, std::move(pivot_values));
-	} else {
-		// executing a pivot statement happens in three stages
-		// 1) execute the query "SELECT {groups}, {pivots}, {aggregates} FROM {from_clause} GROUP BY {groups}, {pivots}
-		// this computes all values that are required in the final result, but not yet in the correct orientation
-		// 2) execute the query "SELECT {groups}, LIST({pivots}), LIST({aggregates}) FROM [Q1] GROUP BY {groups}
-		// this pushes all pivots and aggregates that belong to a specific group together in an aligned manner
-		// 3) push a PIVOT operator, that performs the actual pivoting of the values into the different columns
-
-		PivotBindState bind_state;
-		// Pivot Stage 1
-		// SELECT {groups}, {pivots}, {aggregates} FROM {from_clause} GROUP BY {groups}, {pivots}
-		auto subquery_stage1 = PivotInitialAggregate(bind_state, ref, std::move(all_columns), handled_columns);
-
-		// Pivot stage 2
-		// SELECT {groups}, LIST({pivots}), LIST({aggregates}) FROM [Q1] GROUP BY {groups}
-		auto subquery_stage2 = PivotListAggregate(bind_state, ref, std::move(subquery_stage1));
-
-		// Pivot stage 3
-		// construct the final pivot operator
-		pivot_node = PivotFinalOperator(bind_state, ref, std::move(subquery_stage2), std::move(pivot_values));
-	}
-	return pivot_node;
-}
-
-struct UnpivotEntry {
-	string alias;
-	vector<string> column_names;
-	vector<unique_ptr<ParsedExpression>> expressions;
-};
-
-void Binder::ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry,
-                                   vector<UnpivotEntry> &unpivot_entries) {
-	if (!entry.expr) {
-		// pivot entry without an expression - generate one
-		UnpivotEntry unpivot_entry;
-		unpivot_entry.alias = entry.alias;
-		for (auto &val : entry.values) {
-			auto column_name = val.ToString();
-			if (column_name.empty()) {
-				throw BinderException("UNPIVOT - empty column name not supported");
-			}
-			unpivot_entry.expressions.push_back(make_uniq<ColumnRefExpression>(column_name));
-		}
-		unpivot_entries.push_back(std::move(unpivot_entry));
-		return;
-	}
-	D_ASSERT(entry.values.empty());
-	// expand star expressions (if any)
-	vector<unique_ptr<ParsedExpression>> star_columns;
-	child_binder.ExpandStarExpression(std::move(entry.expr), star_columns);
-
-	for (auto &expr : star_columns) {
-		// create one pivot entry per result column
-		UnpivotEntry unpivot_entry;
-		if (!expr->GetAlias().empty()) {
-			unpivot_entry.alias = expr->GetAlias();
-		}
-		unpivot_entry.expressions.push_back(std::move(expr));
-		unpivot_entries.push_back(std::move(unpivot_entry));
-	}
-}
-
-void Binder::ExtractUnpivotColumnName(ParsedExpression &expr, vector<string> &result) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		result.push_back(colref.GetColumnName());
-		return;
-	}
-	if (expr.GetExpressionType() == ExpressionType::SUBQUERY) {
-		throw BinderException(expr, "UNPIVOT list cannot contain subqueries");
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](ParsedExpression &child) { ExtractUnpivotColumnName(child, result); });
-}
-
-unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
-                                           vector<unique_ptr<ParsedExpression>> all_columns,
-                                           unique_ptr<ParsedExpression> &where_clause) {
-	D_ASSERT(ref.groups.empty());
-	D_ASSERT(ref.pivots.size() == 1);
-
-	auto select_node = make_uniq<SelectNode>();
-	select_node->from_table = std::move(ref.source);
-
-	// handle the pivot
-	auto &unpivot = ref.pivots[0];
-
-	// handle star expressions in any entries
-	vector<UnpivotEntry> unpivot_entries;
-	for (auto &entry : unpivot.entries) {
-		ExtractUnpivotEntries(child_binder, entry, unpivot_entries);
-	}
-	if (unpivot_entries.empty()) {
-		throw BinderException(ref, "UNPIVOT clause must unpivot on at least one column - zero were provided");
-	}
-
-	case_insensitive_set_t handled_columns;
-	case_insensitive_map_t<string> name_map;
-	for (auto &entry : unpivot_entries) {
-		for (auto &unpivot_expr : entry.expressions) {
-			vector<string> result;
-			ExtractUnpivotColumnName(*unpivot_expr, result);
-			if (result.empty()) {
-
-				throw BinderException(
-				    *unpivot_expr,
-				    "UNPIVOT clause must contain exactly one column - expression \"%s\" does not contain any",
-				    unpivot_expr->ToString());
-			}
-			if (result.size() > 1) {
-				throw BinderException(
-				    *unpivot_expr,
-				    "UNPIVOT clause must contain exactly one column - expression \"%s\" contains multiple (%s)",
-				    unpivot_expr->ToString(), StringUtil::Join(result, ", "));
-			}
-			handled_columns.insert(result[0]);
-			entry.column_names.push_back(std::move(result[0]));
-		}
-	}
-
-	for (auto &col_expr : all_columns) {
-		if (col_expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
-			throw InternalException("Unexpected child of pivot source - not a ColumnRef");
-		}
-		auto &columnref = col_expr->Cast<ColumnRefExpression>();
-		auto &column_name = columnref.GetColumnName();
-		auto entry = handled_columns.find(column_name);
-		if (entry == handled_columns.end()) {
-			// not handled - add to the set of regularly selected columns
-			select_node->select_list.push_back(std::move(col_expr));
-		} else {
-			name_map[column_name] = column_name;
-			handled_columns.erase(entry);
-		}
-	}
-	if (!handled_columns.empty()) {
-		for (auto &entry : handled_columns) {
-			throw BinderException(
-			    ref, "Column \"%s\" referenced in UNPIVOT but no matching entry was found in the table", entry);
-		}
-	}
-	vector<Value> unpivot_names;
-	for (auto &entry : unpivot_entries) {
-		string generated_name;
-		D_ASSERT(entry.expressions.size() == entry.column_names.size());
-		for (idx_t c = 0; c < entry.expressions.size(); c++) {
-			auto name_entry = name_map.find(entry.column_names[c]);
-			if (name_entry == name_map.end()) {
-				throw InternalException("Unpivot - could not find column name in name map");
-			}
-			if (!generated_name.empty()) {
-				generated_name += "_";
-			}
-			generated_name += name_entry->second;
-		}
-		unpivot_names.emplace_back(!entry.alias.empty() ? entry.alias : generated_name);
-	}
-	vector<vector<unique_ptr<ParsedExpression>>> unpivot_expressions;
-	for (idx_t v_idx = 1; v_idx < unpivot_entries.size(); v_idx++) {
-		if (unpivot_entries[v_idx].expressions.size() != unpivot_entries[0].expressions.size()) {
-			throw BinderException(
-			    ref,
-			    "UNPIVOT value count mismatch - entry has %llu values, but expected all entries to have %llu values",
-			    unpivot_entries[v_idx].expressions.size(), unpivot_entries[0].expressions.size());
-		}
-	}
-
-	for (idx_t v_idx = 0; v_idx < unpivot_entries[0].expressions.size(); v_idx++) {
-		vector<unique_ptr<ParsedExpression>> expressions;
-		expressions.reserve(unpivot_entries.size());
-		for (auto &entry : unpivot_entries) {
-			expressions.push_back(std::move(entry.expressions[v_idx]));
-		}
-		unpivot_expressions.push_back(std::move(expressions));
-	}
-
-	// construct the UNNEST expression for the set of names (constant)
-	auto unpivot_list = Value::LIST(LogicalType::VARCHAR, std::move(unpivot_names));
-	auto unpivot_name_expr = make_uniq<ConstantExpression>(std::move(unpivot_list));
-	vector<unique_ptr<ParsedExpression>> unnest_name_children;
-	unnest_name_children.push_back(std::move(unpivot_name_expr));
-	auto unnest_name_expr = make_uniq<FunctionExpression>("unnest", std::move(unnest_name_children));
-	unnest_name_expr->SetAlias(unpivot.unpivot_names[0]);
-	select_node->select_list.push_back(std::move(unnest_name_expr));
-
-	// construct the UNNEST expression for the set of unpivoted columns
-	if (ref.unpivot_names.size() != unpivot_expressions.size()) {
-		throw BinderException(ref, "UNPIVOT name count mismatch - got %d names but %d expressions",
-		                      ref.unpivot_names.size(), unpivot_expressions.size());
-	}
-	for (idx_t i = 0; i < unpivot_expressions.size(); i++) {
-		auto list_expr = make_uniq<FunctionExpression>("unpivot_list", std::move(unpivot_expressions[i]));
-		vector<unique_ptr<ParsedExpression>> unnest_val_children;
-		unnest_val_children.push_back(std::move(list_expr));
-		auto unnest_val_expr = make_uniq<FunctionExpression>("unnest", std::move(unnest_val_children));
-		auto unnest_name = i < ref.column_name_alias.size() ? ref.column_name_alias[i] : ref.unpivot_names[i];
-		unnest_val_expr->SetAlias(unnest_name);
-		select_node->select_list.push_back(std::move(unnest_val_expr));
-		if (!ref.include_nulls) {
-			// if we are running with EXCLUDE NULLS we need to add an IS NOT NULL filter
-			auto colref = make_uniq<ColumnRefExpression>(unnest_name);
-			auto filter = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(colref));
-			if (where_clause) {
-				where_clause = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-				                                                std::move(where_clause), std::move(filter));
-			} else {
-				where_clause = std::move(filter);
-			}
-		}
-	}
-	return select_node;
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(PivotRef &ref) {
-	if (!ref.source) {
-		throw InternalException("Pivot without a source!?");
-	}
-	if (!ref.bound_pivot_values.empty() || !ref.bound_group_names.empty() || !ref.bound_aggregate_names.empty()) {
-		// bound pivot
-		return BindBoundPivot(ref);
-	}
-
-	// bind the source of the pivot
-	// we need to do this to be able to expand star expressions
-	if (ref.source->type == TableReferenceType::SUBQUERY && ref.source->alias.empty()) {
-		ref.source->alias = "__internal_pivot_alias_" + to_string(GenerateTableIndex());
-	}
-	auto copied_source = ref.source->Copy();
-	auto star_binder = Binder::CreateBinder(context, this);
-	star_binder->Bind(*copied_source);
-
-	// figure out the set of column names that are in the source of the pivot
-	vector<unique_ptr<ParsedExpression>> all_columns;
-	star_binder->ExpandStarExpression(make_uniq<StarExpression>(), all_columns);
-
-	unique_ptr<SelectNode> select_node;
-	unique_ptr<ParsedExpression> where_clause;
-	if (!ref.aggregates.empty()) {
-		select_node = BindPivot(ref, std::move(all_columns));
-	} else {
-		select_node = BindUnpivot(*star_binder, ref, std::move(all_columns), where_clause);
-	}
-	// bind the generated select node
-	auto child_binder = Binder::CreateBinder(context, this);
-	auto bound_select_node = child_binder->BindNode(*select_node);
-	auto root_index = bound_select_node->GetRootIndex();
-	BoundQueryNode *bound_select_ptr = bound_select_node.get();
-
-	unique_ptr<BoundTableRef> result;
-	MoveCorrelatedExpressions(*child_binder);
-	result = make_uniq<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
-	auto subquery_alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
-	SubqueryRef subquery_ref(nullptr, subquery_alias);
-	subquery_ref.column_name_alias = std::move(ref.column_name_alias);
-	if (where_clause) {
-		// if a WHERE clause was provided - bind a subquery holding the WHERE clause
-		// we need to bind a new subquery here because the WHERE clause has to be applied AFTER the unnest
-		child_binder = Binder::CreateBinder(context, this);
-		child_binder->bind_context.AddSubquery(root_index, subquery_ref.alias, subquery_ref, *bound_select_ptr);
-		auto where_query = make_uniq<SelectNode>();
-		where_query->select_list.push_back(make_uniq<StarExpression>());
-		where_query->where_clause = std::move(where_clause);
-		bound_select_node = child_binder->BindSelectNode(*where_query, std::move(result));
-		bound_select_ptr = bound_select_node.get();
-		root_index = bound_select_node->GetRootIndex();
-		result = make_uniq<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
-	}
-	bind_context.AddSubquery(root_index, subquery_ref.alias, subquery_ref, *bound_select_ptr);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_showref.cpp b/src/duckdb/src/planner/binder/tableref/bind_showref.cpp
deleted file mode 100644
index d61b98f67..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_showref.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#include "duckdb/function/pragma/pragma_functions.hpp"
-#include "duckdb/function/table/system_functions.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/tableref/showref.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-#include "duckdb/planner/tableref/bound_table_function.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-namespace duckdb {
-
-struct BaseTableColumnInfo {
-	optional_ptr<TableCatalogEntry> table;
-	optional_ptr<const ColumnDefinition> column;
-};
-
-BaseTableColumnInfo FindBaseTableColumn(LogicalOperator &op, ColumnBinding binding) {
-	BaseTableColumnInfo result;
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_GET: {
-		auto &get = op.Cast<LogicalGet>();
-		if (get.table_index != binding.table_index) {
-			return result;
-		}
-		auto table = get.GetTable();
-		if (!table) {
-			break;
-		}
-		if (!get.projection_ids.empty()) {
-			throw InternalException("Projection ids should not exist here");
-		}
-		result.table = table;
-		auto base_column_id = get.GetColumnIds()[binding.column_index];
-		result.column = &table->GetColumn(LogicalIndex(base_column_id.GetPrimaryIndex()));
-		return result;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		auto &projection = op.Cast<LogicalProjection>();
-		if (binding.table_index != projection.table_index) {
-			break;
-		}
-		auto &expr = projection.expressions[binding.column_index];
-		if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			// if the projection at this index only has a column reference we can directly trace it to the base table
-			auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-			return FindBaseTableColumn(*projection.children[0], bound_colref.binding);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT:
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-	case LogicalOperatorType::LOGICAL_TOP_N:
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_FILTER:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_JOIN:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		// for any "pass-through" operators - search in children directly
-		for (auto &child : op.children) {
-			result = FindBaseTableColumn(*child, binding);
-			if (result.table) {
-				return result;
-			}
-		}
-		break;
-	default:
-		// unsupported operator
-		break;
-	}
-	return result;
-}
-
-BaseTableColumnInfo FindBaseTableColumn(LogicalOperator &op, idx_t column_index) {
-	auto bindings = op.GetColumnBindings();
-	return FindBaseTableColumn(op, bindings[column_index]);
-}
-
-unique_ptr<BoundTableRef> Binder::BindShowQuery(ShowRef &ref) {
-	// bind the child plan of the DESCRIBE statement
-	auto child_binder = Binder::CreateBinder(context, this);
-	auto plan = child_binder->Bind(*ref.query);
-
-	// construct a column data collection with the result
-	vector<string> return_names = {"column_name", "column_type", "null", "key", "default", "extra"};
-	vector<LogicalType> return_types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
-	                                    LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
-	DataChunk output;
-	output.Initialize(Allocator::Get(context), return_types);
-
-	auto collection = make_uniq<ColumnDataCollection>(context, return_types);
-	ColumnDataAppendState append_state;
-	collection->InitializeAppend(append_state);
-	for (idx_t column_idx = 0; column_idx < plan.types.size(); column_idx++) {
-		// check if we can trace the column to a base table so that we can figure out constraint information
-		auto result = FindBaseTableColumn(*plan.plan, column_idx);
-		if (result.table) {
-			// we can! emit the information from the base table directly
-			PragmaTableInfo::GetColumnInfo(*result.table, *result.column, output, output.size());
-		} else {
-			// we cannot - read the type/name from the plan instead
-			auto type = plan.types[column_idx];
-			auto &name = plan.names[column_idx];
-
-			// "name", TypeId::VARCHAR
-			output.SetValue(0, output.size(), Value(name));
-			// "type", TypeId::VARCHAR
-			output.SetValue(1, output.size(), Value(type.ToString()));
-			// "null", TypeId::VARCHAR
-			output.SetValue(2, output.size(), Value("YES"));
-			// "pk", TypeId::BOOL
-			output.SetValue(3, output.size(), Value());
-			// "dflt_value", TypeId::VARCHAR
-			output.SetValue(4, output.size(), Value());
-			// "extra", TypeId::VARCHAR
-			output.SetValue(5, output.size(), Value());
-		}
-
-		output.SetCardinality(output.size() + 1);
-		if (output.size() == STANDARD_VECTOR_SIZE) {
-			collection->Append(append_state, output);
-			output.Reset();
-		}
-	}
-	collection->Append(append_state, output);
-
-	auto show = make_uniq<LogicalColumnDataGet>(GenerateTableIndex(), return_types, std::move(collection));
-	bind_context.AddGenericBinding(show->table_index, "__show_select", return_names, return_types);
-	return make_uniq<BoundTableFunction>(std::move(show));
-}
-
-unique_ptr<BoundTableRef> Binder::BindShowTable(ShowRef &ref) {
-	auto lname = StringUtil::Lower(ref.table_name);
-
-	string sql;
-	if (lname == "\"databases\"") {
-		sql = PragmaShowDatabases();
-	} else if (lname == "\"tables\"") {
-		sql = PragmaShowTables();
-	} else if (lname == "\"variables\"") {
-		sql = PragmaShowVariables();
-	} else if (lname == "__show_tables_expanded") {
-		sql = PragmaShowTablesExpanded();
-	} else {
-		sql = PragmaShow(ref.table_name);
-	}
-	auto select = CreateViewInfo::ParseSelect(sql);
-	auto subquery = make_uniq<SubqueryRef>(std::move(select));
-	return Bind(*subquery);
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(ShowRef &ref) {
-	if (ref.show_type == ShowType::SUMMARY) {
-		return BindSummarize(ref);
-	}
-	if (ref.query) {
-		return BindShowQuery(ref);
-	} else {
-		return BindShowTable(ref);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp b/src/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp
deleted file mode 100644
index 5acbd06b5..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte) {
-	auto binder = Binder::CreateBinder(context, this);
-	binder->can_contain_nulls = true;
-	if (cte) {
-		binder->bound_ctes.insert(*cte);
-	}
-	auto subquery = binder->BindNode(*ref.subquery->node);
-	binder->alias = ref.alias.empty() ? "unnamed_subquery" : ref.alias;
-	idx_t bind_index = subquery->GetRootIndex();
-	string subquery_alias;
-	if (ref.alias.empty()) {
-		auto index = unnamed_subquery_index++;
-		subquery_alias = "unnamed_subquery";
-		;
-		if (index > 1) {
-			subquery_alias += to_string(index);
-		}
-	} else {
-		subquery_alias = ref.alias;
-	}
-	auto result = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(subquery));
-	bind_context.AddSubquery(bind_index, subquery_alias, ref, *result->subquery);
-	MoveCorrelatedExpressions(*result->binder);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp b/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp
deleted file mode 100644
index 3f4c249bd..000000000
--- a/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp
+++ /dev/null
@@ -1,374 +0,0 @@
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
-#include "duckdb/common/algorithm.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/tableref/emptytableref.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/table_function_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-#include "duckdb/planner/tableref/bound_table_function.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-
-namespace duckdb {
-
-enum class TableFunctionBindType { STANDARD_TABLE_FUNCTION, TABLE_IN_OUT_FUNCTION, TABLE_PARAMETER_FUNCTION };
-
-static TableFunctionBindType GetTableFunctionBindType(TableFunctionCatalogEntry &table_function,
-                                                      vector<unique_ptr<ParsedExpression>> &expressions) {
-	// first check if all expressions are scalar
-	// if they are we always bind as a standard table function
-	bool all_scalar = true;
-	for (auto &expr : expressions) {
-		if (!expr->IsScalar()) {
-			all_scalar = false;
-			break;
-		}
-	}
-	if (all_scalar) {
-		return TableFunctionBindType::STANDARD_TABLE_FUNCTION;
-	}
-	// if we have non-scalar parameters - we need to look at the function definition to decide how to bind
-	// if a function does not have an in_out_function defined, we need to bind as a standard table function regardless
-	bool has_in_out_function = false;
-	bool has_standard_table_function = false;
-	bool has_table_parameter = false;
-	for (idx_t function_idx = 0; function_idx < table_function.functions.Size(); function_idx++) {
-		const auto &function = table_function.functions.GetFunctionReferenceByOffset(function_idx);
-		for (auto &arg : function.arguments) {
-			if (arg.id() == LogicalTypeId::TABLE) {
-				has_table_parameter = true;
-			}
-		}
-		if (function.in_out_function) {
-			has_in_out_function = true;
-		} else if (function.function || function.bind_replace) {
-			has_standard_table_function = true;
-		} else {
-			throw InternalException("Function \"%s\" has neither in_out_function nor function defined",
-			                        table_function.name);
-		}
-	}
-	if (has_table_parameter) {
-		if (table_function.functions.Size() != 1) {
-			throw InternalException(
-			    "Function \"%s\" has a TABLE parameter, and multiple function overloads - this is not supported",
-			    table_function.name);
-		}
-		return TableFunctionBindType::TABLE_PARAMETER_FUNCTION;
-	}
-	if (has_in_out_function && has_standard_table_function) {
-		throw InternalException("Function \"%s\" is both an in_out_function and a table function", table_function.name);
-	}
-	return has_in_out_function ? TableFunctionBindType::TABLE_IN_OUT_FUNCTION
-	                           : TableFunctionBindType::STANDARD_TABLE_FUNCTION;
-}
-
-void Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-                                         unique_ptr<BoundSubqueryRef> &subquery) {
-	auto binder = Binder::CreateBinder(this->context, this);
-	unique_ptr<QueryNode> subquery_node;
-	// generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3]))
-	auto select_node = make_uniq<SelectNode>();
-	select_node->select_list = std::move(expressions);
-	select_node->from_table = make_uniq<EmptyTableRef>();
-	subquery_node = std::move(select_node);
-	binder->can_contain_nulls = true;
-	auto node = binder->BindNode(*subquery_node);
-	subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
-	MoveCorrelatedExpressions(*subquery->binder);
-}
-
-bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
-                                         vector<unique_ptr<ParsedExpression>> &expressions,
-                                         vector<LogicalType> &arguments, vector<Value> &parameters,
-                                         named_parameter_map_t &named_parameters,
-                                         unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error) {
-	auto bind_type = GetTableFunctionBindType(table_function, expressions);
-	if (bind_type == TableFunctionBindType::TABLE_IN_OUT_FUNCTION) {
-		// bind table in-out function
-		BindTableInTableOutFunction(expressions, subquery);
-		// fetch the arguments from the subquery
-		arguments = subquery->subquery->types;
-		return true;
-	}
-	bool seen_subquery = false;
-	for (auto &child : expressions) {
-		string parameter_name;
-
-		// hack to make named parameters work
-		if (child->GetExpressionType() == ExpressionType::COMPARE_EQUAL) {
-			// comparison, check if the LHS is a columnref
-			auto &comp = child->Cast<ComparisonExpression>();
-			if (comp.left->GetExpressionType() == ExpressionType::COLUMN_REF) {
-				auto &colref = comp.left->Cast<ColumnRefExpression>();
-				if (!colref.IsQualified()) {
-					parameter_name = colref.GetColumnName();
-					child = std::move(comp.right);
-				}
-			}
-		} else if (!child->GetAlias().empty()) {
-			// <name> => <expression> will set the alias of <expression> to <name>
-			parameter_name = child->GetAlias();
-		}
-		if (bind_type == TableFunctionBindType::TABLE_PARAMETER_FUNCTION &&
-		    child->GetExpressionType() == ExpressionType::SUBQUERY) {
-			D_ASSERT(table_function.functions.Size() == 1);
-			auto fun = table_function.functions.GetFunctionByOffset(0);
-			if (table_function.functions.Size() != 1 || fun.arguments.empty() ||
-			    fun.arguments[0].id() != LogicalTypeId::TABLE) {
-				throw BinderException(
-				    "Only table-in-out functions can have subquery parameters - %s only accepts constant parameters",
-				    fun.name);
-			}
-			if (seen_subquery) {
-				error = ErrorData("Table function can have at most one subquery parameter");
-				return false;
-			}
-			auto binder = Binder::CreateBinder(this->context, this);
-			binder->can_contain_nulls = true;
-			auto &se = child->Cast<SubqueryExpression>();
-			auto node = binder->BindNode(*se.subquery->node);
-			subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
-			MoveCorrelatedExpressions(*subquery->binder);
-			seen_subquery = true;
-			arguments.emplace_back(LogicalTypeId::TABLE);
-			parameters.emplace_back(Value());
-			continue;
-		}
-
-		TableFunctionBinder binder(*this, context, table_function.name);
-		LogicalType sql_type;
-		auto expr = binder.Bind(child, &sql_type);
-		if (expr->HasParameter()) {
-			throw ParameterNotResolvedException();
-		}
-		if (!expr->IsScalar()) {
-			// should have been eliminated before
-			throw InternalException("Table function requires a constant parameter");
-		}
-		auto constant = ExpressionExecutor::EvaluateScalar(context, *expr, true);
-		if (parameter_name.empty()) {
-			// unnamed parameter
-			if (!named_parameters.empty()) {
-				error = ErrorData("Unnamed parameters cannot come after named parameters");
-				return false;
-			}
-			arguments.emplace_back(constant.IsNull() ? LogicalType::SQLNULL : sql_type);
-			parameters.emplace_back(std::move(constant));
-		} else {
-			named_parameters[parameter_name] = std::move(constant);
-		}
-	}
-	return true;
-}
-
-static string GetAlias(const TableFunctionRef &ref) {
-	if (!ref.alias.empty()) {
-		return ref.alias;
-	}
-	if (ref.function && ref.function->GetExpressionType() == ExpressionType::FUNCTION) {
-		auto &function_expr = ref.function->Cast<FunctionExpression>();
-		return function_expr.function_name;
-	}
-	return string();
-}
-
-unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &table_function,
-                                                              const TableFunctionRef &ref, vector<Value> parameters,
-                                                              named_parameter_map_t named_parameters,
-                                                              vector<LogicalType> input_table_types,
-                                                              vector<string> input_table_names) {
-	auto function_name = GetAlias(ref);
-	auto &column_name_alias = ref.column_name_alias;
-
-	auto bind_index = GenerateTableIndex();
-	// perform the binding
-	unique_ptr<FunctionData> bind_data;
-	vector<LogicalType> return_types;
-	vector<string> return_names;
-	if (table_function.bind || table_function.bind_replace) {
-		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
-		                                  table_function.function_info.get(), this, table_function, ref);
-		if (table_function.bind_replace) {
-			auto new_plan = table_function.bind_replace(context, bind_input);
-			if (new_plan != nullptr) {
-				return CreatePlan(*Bind(*new_plan));
-			} else if (!table_function.bind) {
-				throw BinderException("Failed to bind \"%s\": nullptr returned from bind_replace without bind function",
-				                      table_function.name);
-			}
-		}
-		bind_data = table_function.bind(context, bind_input, return_types, return_names);
-	} else {
-		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
-		                            table_function.name);
-	}
-	if (return_types.size() != return_names.size()) {
-		throw InternalException("Failed to bind \"%s\": return_types/names must have same size", table_function.name);
-	}
-	if (return_types.empty()) {
-		throw InternalException("Failed to bind \"%s\": Table function must return at least one column",
-		                        table_function.name);
-	}
-	// overwrite the names with any supplied aliases
-	for (idx_t i = 0; i < column_name_alias.size() && i < return_names.size(); i++) {
-		return_names[i] = column_name_alias[i];
-	}
-	for (idx_t i = 0; i < return_names.size(); i++) {
-		if (return_names[i].empty()) {
-			return_names[i] = "C" + to_string(i);
-		}
-	}
-
-	auto get = make_uniq<LogicalGet>(bind_index, table_function, std::move(bind_data), return_types, return_names);
-	get->parameters = parameters;
-	get->named_parameters = named_parameters;
-	get->input_table_types = input_table_types;
-	get->input_table_names = input_table_names;
-	if (table_function.in_out_function && !table_function.projection_pushdown) {
-		for (idx_t i = 0; i < return_types.size(); i++) {
-			get->AddColumnId(i);
-		}
-	}
-	// now add the table function to the bind context so its columns can be bound
-	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->GetMutableColumnIds(),
-	                              get->GetTable().get());
-	return std::move(get);
-}
-
-unique_ptr<LogicalOperator> Binder::BindTableFunction(TableFunction &function, vector<Value> parameters) {
-	named_parameter_map_t named_parameters;
-	vector<LogicalType> input_table_types;
-	vector<string> input_table_names;
-
-	TableFunctionRef ref;
-	ref.alias = function.name;
-	D_ASSERT(!ref.alias.empty());
-	return BindTableFunctionInternal(function, ref, std::move(parameters), std::move(named_parameters),
-	                                 std::move(input_table_types), std::move(input_table_names));
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
-	QueryErrorContext error_context(ref.query_location);
-
-	D_ASSERT(ref.function->GetExpressionType() == ExpressionType::FUNCTION);
-	auto &fexpr = ref.function->Cast<FunctionExpression>();
-
-	string catalog = fexpr.catalog;
-	string schema = fexpr.schema;
-	Binder::BindSchemaOrCatalog(context, catalog, schema);
-
-	// fetch the function from the catalog
-	auto &func_catalog = *GetCatalogEntry(CatalogType::TABLE_FUNCTION_ENTRY, catalog, schema, fexpr.function_name,
-	                                      OnEntryNotFound::THROW_EXCEPTION, error_context);
-
-	if (func_catalog.type == CatalogType::TABLE_MACRO_ENTRY) {
-		auto &macro_func = func_catalog.Cast<TableMacroCatalogEntry>();
-		auto query_node = BindTableMacro(fexpr, macro_func, 0);
-		D_ASSERT(query_node);
-
-		auto binder = Binder::CreateBinder(context, this);
-		binder->can_contain_nulls = true;
-
-		binder->alias = ref.alias.empty() ? "unnamed_query" : ref.alias;
-		unique_ptr<BoundQueryNode> query;
-		try {
-			query = binder->BindNode(*query_node);
-		} catch (std::exception &ex) {
-			ErrorData error(ex);
-			error.AddQueryLocation(ref);
-			error.Throw();
-		}
-
-		idx_t bind_index = query->GetRootIndex();
-		// string alias;
-		string alias = (ref.alias.empty() ? "unnamed_query" + to_string(bind_index) : ref.alias);
-
-		auto result = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(query));
-		// remember ref here is TableFunctionRef and NOT base class
-		bind_context.AddSubquery(bind_index, alias, ref, *result->subquery);
-		MoveCorrelatedExpressions(*result->binder);
-		return std::move(result);
-	}
-	D_ASSERT(func_catalog.type == CatalogType::TABLE_FUNCTION_ENTRY);
-	auto &function = func_catalog.Cast<TableFunctionCatalogEntry>();
-
-	// evaluate the input parameters to the function
-	vector<LogicalType> arguments;
-	vector<Value> parameters;
-	named_parameter_map_t named_parameters;
-	unique_ptr<BoundSubqueryRef> subquery;
-	ErrorData error;
-	if (!BindTableFunctionParameters(function, fexpr.children, arguments, parameters, named_parameters, subquery,
-	                                 error)) {
-		error.AddQueryLocation(ref);
-		error.Throw();
-	}
-
-	// select the function based on the input parameters
-	FunctionBinder function_binder(*this);
-	auto best_function_idx = function_binder.BindFunction(function.name, function.functions, arguments, error);
-	if (!best_function_idx.IsValid()) {
-		error.AddQueryLocation(ref);
-		error.Throw();
-	}
-	auto table_function = function.functions.GetFunctionByOffset(best_function_idx.GetIndex());
-
-	// now check the named parameters
-	BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name);
-
-	vector<LogicalType> input_table_types;
-	vector<string> input_table_names;
-
-	if (subquery) {
-		input_table_types = subquery->subquery->types;
-		input_table_names = subquery->subquery->names;
-	} else if (table_function.in_out_function) {
-		for (auto &param : parameters) {
-			input_table_types.push_back(param.type());
-			input_table_names.push_back(string());
-		}
-	}
-	if (!parameters.empty()) {
-		// cast the parameters to the type of the function
-		for (idx_t i = 0; i < arguments.size(); i++) {
-			auto target_type =
-			    i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs;
-
-			if (target_type != LogicalType::ANY && target_type != LogicalType::POINTER &&
-			    target_type.id() != LogicalTypeId::LIST && target_type != LogicalType::TABLE) {
-				parameters[i] = parameters[i].CastAs(context, target_type);
-			}
-		}
-	} else if (subquery) {
-		for (idx_t i = 0; i < arguments.size(); i++) {
-			auto target_type =
-			    i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs;
-
-			if (target_type != LogicalType::ANY && target_type != LogicalType::POINTER &&
-			    target_type.id() != LogicalTypeId::LIST) {
-				input_table_types[i] = target_type;
-			}
-		}
-	}
-
-	auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters),
-	                                     std::move(input_table_types), std::move(input_table_names));
-	auto table_function_ref = make_uniq<BoundTableFunction>(std::move(get));
-	table_function_ref->subquery = std::move(subquery);
-	return std::move(table_function_ref);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_basetableref.cpp b/src/duckdb/src/planner/binder/tableref/plan_basetableref.cpp
deleted file mode 100644
index 085498fbb..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_basetableref.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundBaseTableRef &ref) {
-	return std::move(ref.get);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_column_data_ref.cpp b/src/duckdb/src/planner/binder/tableref/plan_column_data_ref.cpp
deleted file mode 100644
index 83e965b5e..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_column_data_ref.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_column_data_ref.hpp"
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundColumnDataRef &ref) {
-	auto types = ref.collection->Types();
-	// Create a (potentially owning) LogicalColumnDataGet
-	auto root = make_uniq_base<LogicalOperator, LogicalColumnDataGet>(ref.bind_index, std::move(types),
-	                                                                  std::move(ref.collection));
-	return root;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_cteref.cpp b/src/duckdb/src/planner/binder/tableref/plan_cteref.cpp
deleted file mode 100644
index 1f0fcb6b8..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_cteref.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_cteref.hpp"
-#include "duckdb/planner/tableref/bound_cteref.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTERef &ref) {
-	return make_uniq<LogicalCTERef>(ref.bind_index, ref.cte_index, ref.types, ref.bound_columns, ref.materialized_cte);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_delimgetref.cpp b/src/duckdb/src/planner/binder/tableref/plan_delimgetref.cpp
deleted file mode 100644
index b674b43df..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_delimgetref.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/operator/logical_delim_get.hpp"
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundDelimGetRef &ref) {
-	return make_uniq<LogicalDelimGet>(ref.bind_index, ref.column_types);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_dummytableref.cpp b/src/duckdb/src/planner/binder/tableref/plan_dummytableref.cpp
deleted file mode 100644
index f31fc929b..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_dummytableref.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/tableref/bound_dummytableref.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundEmptyTableRef &ref) {
-	return make_uniq<LogicalDummyScan>(ref.bind_index);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp b/src/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp
deleted file mode 100644
index ba6253bce..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_expressionlistref.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundExpressionListRef &ref) {
-	auto root = make_uniq_base<LogicalOperator, LogicalDummyScan>(GenerateTableIndex());
-	// values list, first plan any subqueries in the list
-	for (auto &expr_list : ref.values) {
-		for (auto &expr : expr_list) {
-			PlanSubqueries(expr, root);
-		}
-	}
-	// now create a LogicalExpressionGet from the set of expressions
-	// fetch the types
-	vector<LogicalType> types;
-	for (auto &expr : ref.values[0]) {
-		types.push_back(expr->return_type);
-	}
-	auto expr_get = make_uniq<LogicalExpressionGet>(ref.bind_index, types, std::move(ref.values));
-	expr_get->AddChild(std::move(root));
-	return std::move(expr_get);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp b/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp
deleted file mode 100644
index aa96ff857..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/expression_binder/lateral_binder.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_positional_join.hpp"
-#include "duckdb/planner/subquery/recursive_dependent_join_planner.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-
-namespace duckdb {
-
-//! Only use conditions that are valid for the join ref type
-static bool IsJoinTypeCondition(const JoinRefType ref_type, const ExpressionType expr_type) {
-	switch (ref_type) {
-	case JoinRefType::ASOF:
-		switch (expr_type) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_LESSTHAN:
-			return true;
-		default:
-			return false;
-		}
-	default:
-		return true;
-	}
-}
-
-//! Create a JoinCondition from a comparison
-static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &left_bindings,
-                                const unordered_set<idx_t> &right_bindings, vector<JoinCondition> &conditions) {
-	// comparison
-	auto &comparison = expr.Cast<BoundComparisonExpression>();
-	auto left_side = JoinSide::GetJoinSide(*comparison.left, left_bindings, right_bindings);
-	auto right_side = JoinSide::GetJoinSide(*comparison.right, left_bindings, right_bindings);
-	if (left_side != JoinSide::BOTH && right_side != JoinSide::BOTH) {
-		// join condition can be divided in a left/right side
-		JoinCondition condition;
-		condition.comparison = expr.GetExpressionType();
-		auto left = std::move(comparison.left);
-		auto right = std::move(comparison.right);
-		if (left_side == JoinSide::RIGHT) {
-			// left = right, right = left, flip the comparison symbol and reverse sides
-			swap(left, right);
-			condition.comparison = FlipComparisonExpression(expr.GetExpressionType());
-		}
-		condition.left = std::move(left);
-		condition.right = std::move(right);
-		conditions.push_back(std::move(condition));
-		return true;
-	}
-	return false;
-}
-
-void LogicalComparisonJoin::ExtractJoinConditions(
-    ClientContext &context, JoinType type, JoinRefType ref_type, unique_ptr<LogicalOperator> &left_child,
-    unique_ptr<LogicalOperator> &right_child, const unordered_set<idx_t> &left_bindings,
-    const unordered_set<idx_t> &right_bindings, vector<unique_ptr<Expression>> &expressions,
-    vector<JoinCondition> &conditions, vector<unique_ptr<Expression>> &arbitrary_expressions) {
-
-	for (auto &expr : expressions) {
-		auto total_side = JoinSide::GetJoinSide(*expr, left_bindings, right_bindings);
-		if (total_side != JoinSide::BOTH) {
-			// join condition does not reference both sides, add it as filter under the join
-			if ((type == JoinType::LEFT || ref_type == JoinRefType::ASOF) && total_side == JoinSide::RIGHT) {
-				// filter is on RHS and the join is a LEFT OUTER join, we can push it in the right child
-				if (right_child->type != LogicalOperatorType::LOGICAL_FILTER) {
-					// not a filter yet, push a new empty filter
-					auto filter = make_uniq<LogicalFilter>();
-					filter->AddChild(std::move(right_child));
-					right_child = std::move(filter);
-				}
-				// push the expression into the filter
-				auto &filter = right_child->Cast<LogicalFilter>();
-				filter.expressions.push_back(std::move(expr));
-				continue;
-			}
-			// if the join is a LEFT JOIN and the join expression constantly evaluates to TRUE,
-			// then we do not add it to the arbitrary expressions
-			if (type == JoinType::LEFT && expr->IsFoldable()) {
-				Value result;
-				ExpressionExecutor::TryEvaluateScalar(context, *expr, result);
-				if (!result.IsNull() && result == Value(true)) {
-					continue;
-				}
-			}
-		} else if (expr->GetExpressionType() == ExpressionType::COMPARE_EQUAL ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_NOTEQUAL ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_BOUNDARY_START ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_LESSTHAN ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_GREATERTHAN ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_LESSTHANOREQUALTO ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_BOUNDARY_START ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-		           expr->GetExpressionType() == ExpressionType::COMPARE_DISTINCT_FROM)
-
-		{
-			// comparison, check if we can create a comparison JoinCondition
-			if (IsJoinTypeCondition(ref_type, expr->GetExpressionType()) &&
-			    CreateJoinCondition(*expr, left_bindings, right_bindings, conditions)) {
-				// successfully created the join condition
-				continue;
-			}
-		}
-		arbitrary_expressions.push_back(std::move(expr));
-	}
-}
-
-void LogicalComparisonJoin::ExtractJoinConditions(ClientContext &context, JoinType type, JoinRefType ref_type,
-                                                  unique_ptr<LogicalOperator> &left_child,
-                                                  unique_ptr<LogicalOperator> &right_child,
-                                                  vector<unique_ptr<Expression>> &expressions,
-                                                  vector<JoinCondition> &conditions,
-                                                  vector<unique_ptr<Expression>> &arbitrary_expressions) {
-	unordered_set<idx_t> left_bindings, right_bindings;
-	LogicalJoin::GetTableReferences(*left_child, left_bindings);
-	LogicalJoin::GetTableReferences(*right_child, right_bindings);
-	return ExtractJoinConditions(context, type, ref_type, left_child, right_child, left_bindings, right_bindings,
-	                             expressions, conditions, arbitrary_expressions);
-}
-
-void LogicalComparisonJoin::ExtractJoinConditions(ClientContext &context, JoinType type, JoinRefType ref_type,
-                                                  unique_ptr<LogicalOperator> &left_child,
-                                                  unique_ptr<LogicalOperator> &right_child,
-                                                  unique_ptr<Expression> condition, vector<JoinCondition> &conditions,
-                                                  vector<unique_ptr<Expression>> &arbitrary_expressions) {
-	// split the expressions by the AND clause
-	vector<unique_ptr<Expression>> expressions;
-	expressions.push_back(std::move(condition));
-	LogicalFilter::SplitPredicates(expressions);
-	return ExtractJoinConditions(context, type, ref_type, left_child, right_child, expressions, conditions,
-	                             arbitrary_expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(ClientContext &context, JoinType type,
-                                                              JoinRefType reftype,
-                                                              unique_ptr<LogicalOperator> left_child,
-                                                              unique_ptr<LogicalOperator> right_child,
-                                                              vector<JoinCondition> conditions,
-                                                              vector<unique_ptr<Expression>> arbitrary_expressions) {
-	// Validate the conditions
-	bool need_to_consider_arbitrary_expressions = true;
-	switch (reftype) {
-	case JoinRefType::ASOF: {
-		need_to_consider_arbitrary_expressions = false;
-		auto asof_idx = conditions.size();
-		for (size_t c = 0; c < conditions.size(); ++c) {
-			auto &cond = conditions[c];
-			switch (cond.comparison) {
-			case ExpressionType::COMPARE_EQUAL:
-			case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-				break;
-			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			case ExpressionType::COMPARE_GREATERTHAN:
-			case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			case ExpressionType::COMPARE_LESSTHAN:
-				if (asof_idx < conditions.size()) {
-					throw BinderException("Multiple ASOF JOIN inequalities");
-				}
-				asof_idx = c;
-				break;
-			default:
-				throw BinderException("Invalid ASOF JOIN comparison");
-			}
-		}
-		if (asof_idx == conditions.size()) {
-			throw BinderException("Missing ASOF JOIN inequality");
-		}
-		break;
-	}
-	default:
-		break;
-	}
-
-	if (type == JoinType::INNER && reftype == JoinRefType::REGULAR) {
-		// for inner joins we can push arbitrary expressions as a filter
-		// here we prefer to create a comparison join if possible
-		// that way we can use the much faster hash join to process the main join
-		// rather than doing a nested loop join to handle arbitrary expressions
-
-		// for left and full outer joins we HAVE to process all join conditions
-		// because pushing a filter will lead to an incorrect result, as non-matching tuples cannot be filtered out
-		need_to_consider_arbitrary_expressions = false;
-	}
-	if ((need_to_consider_arbitrary_expressions && !arbitrary_expressions.empty()) || conditions.empty()) {
-		if (arbitrary_expressions.empty()) {
-			// all conditions were pushed down, add TRUE predicate
-			arbitrary_expressions.push_back(make_uniq<BoundConstantExpression>(Value::BOOLEAN(true)));
-		}
-		for (auto &condition : conditions) {
-			arbitrary_expressions.push_back(JoinCondition::CreateExpression(std::move(condition)));
-		}
-		// if we get here we could not create any JoinConditions
-		// turn this into an arbitrary expression join
-		auto any_join = make_uniq<LogicalAnyJoin>(type);
-		// create the condition
-		any_join->children.push_back(std::move(left_child));
-		any_join->children.push_back(std::move(right_child));
-		// AND all the arbitrary expressions together
-		// do the same with any remaining conditions
-		any_join->condition = std::move(arbitrary_expressions[0]);
-		for (idx_t i = 1; i < arbitrary_expressions.size(); i++) {
-			any_join->condition = make_uniq<BoundConjunctionExpression>(
-			    ExpressionType::CONJUNCTION_AND, std::move(any_join->condition), std::move(arbitrary_expressions[i]));
-		}
-		return std::move(any_join);
-	} else {
-		// we successfully converted expressions into JoinConditions
-		// create a LogicalComparisonJoin
-		auto logical_type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
-		if (reftype == JoinRefType::ASOF) {
-			logical_type = LogicalOperatorType::LOGICAL_ASOF_JOIN;
-		}
-		auto comp_join = make_uniq<LogicalComparisonJoin>(type, logical_type);
-		comp_join->conditions = std::move(conditions);
-		comp_join->children.push_back(std::move(left_child));
-		comp_join->children.push_back(std::move(right_child));
-		if (!arbitrary_expressions.empty()) {
-			// we have some arbitrary expressions as well
-			// add them to a filter
-			auto filter = make_uniq<LogicalFilter>();
-			for (auto &expr : arbitrary_expressions) {
-				filter->expressions.push_back(std::move(expr));
-			}
-			LogicalFilter::SplitPredicates(filter->expressions);
-			filter->children.push_back(std::move(comp_join));
-			return std::move(filter);
-		}
-		return std::move(comp_join);
-	}
-}
-
-static bool HasCorrelatedColumns(Expression &expression) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expression.Cast<BoundColumnRefExpression>();
-		if (colref.depth > 0) {
-			return true;
-		}
-	}
-	bool has_correlated_columns = false;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &child) {
-		if (HasCorrelatedColumns(child)) {
-			has_correlated_columns = true;
-		}
-	});
-	return has_correlated_columns;
-}
-
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(ClientContext &context, JoinType type,
-                                                              JoinRefType reftype,
-                                                              unique_ptr<LogicalOperator> left_child,
-                                                              unique_ptr<LogicalOperator> right_child,
-                                                              unique_ptr<Expression> condition) {
-	vector<JoinCondition> conditions;
-	vector<unique_ptr<Expression>> arbitrary_expressions;
-	LogicalComparisonJoin::ExtractJoinConditions(context, type, reftype, left_child, right_child, std::move(condition),
-	                                             conditions, arbitrary_expressions);
-	return LogicalComparisonJoin::CreateJoin(context, type, reftype, std::move(left_child), std::move(right_child),
-	                                         std::move(conditions), std::move(arbitrary_expressions));
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
-	auto old_is_outside_flattened = is_outside_flattened;
-	// Plan laterals from outermost to innermost
-	if (ref.lateral) {
-		// Set the flag to ensure that children do not flatten before the root
-		is_outside_flattened = false;
-	}
-	auto left = CreatePlan(*ref.left);
-	auto right = CreatePlan(*ref.right);
-	is_outside_flattened = old_is_outside_flattened;
-
-	// For joins, depth of the bindings will be one higher on the right because of the lateral binder
-	// If the current join does not have correlations between left and right, then the right bindings
-	// have depth 1 too high and can be reduced by 1 throughout
-	if (!ref.lateral && !ref.correlated_columns.empty()) {
-		LateralBinder::ReduceExpressionDepth(*right, ref.correlated_columns);
-	}
-
-	if (ref.type == JoinType::RIGHT && ref.ref_type != JoinRefType::ASOF &&
-	    ClientConfig::GetConfig(context).enable_optimizer &&
-	    !Optimizer::OptimizerDisabled(context, OptimizerType::BUILD_SIDE_PROBE_SIDE)) {
-		// we turn any right outer joins into left outer joins for optimization purposes
-		// they are the same but with sides flipped, so treating them the same simplifies life
-		ref.type = JoinType::LEFT;
-		std::swap(left, right);
-	}
-	if (ref.lateral) {
-		if (!is_outside_flattened) {
-			// If outer dependent joins is yet to be flattened, only plan the lateral
-			has_unplanned_dependent_joins = true;
-			return LogicalDependentJoin::Create(std::move(left), std::move(right), ref.correlated_columns, ref.type,
-			                                    std::move(ref.condition));
-		} else {
-			// All outer dependent joins have been planned and flattened, so plan and flatten lateral and recursively
-			// plan the children
-			auto new_plan = PlanLateralJoin(std::move(left), std::move(right), ref.correlated_columns, ref.type,
-			                                std::move(ref.condition));
-			if (has_unplanned_dependent_joins) {
-				RecursiveDependentJoinPlanner plan(*this);
-				plan.VisitOperator(*new_plan);
-			}
-			return new_plan;
-		}
-	}
-	switch (ref.ref_type) {
-	case JoinRefType::CROSS:
-		return LogicalCrossProduct::Create(std::move(left), std::move(right));
-	case JoinRefType::POSITIONAL:
-		return LogicalPositionalJoin::Create(std::move(left), std::move(right));
-	default:
-		break;
-	}
-	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition)) &&
-	    ref.ref_type == JoinRefType::REGULAR) {
-		// inner join, generate a cross product + filter
-		// this will be later turned into a proper join by the join order optimizer
-		auto root = LogicalCrossProduct::Create(std::move(left), std::move(right));
-
-		auto filter = make_uniq<LogicalFilter>(std::move(ref.condition));
-		// visit the expressions in the filter
-		for (auto &expression : filter->expressions) {
-			PlanSubqueries(expression, root);
-		}
-		filter->AddChild(std::move(root));
-		return std::move(filter);
-	}
-
-	// now create the join operator from the join condition
-	auto result = LogicalComparisonJoin::CreateJoin(context, ref.type, ref.ref_type, std::move(left), std::move(right),
-	                                                std::move(ref.condition));
-	optional_ptr<LogicalOperator> join;
-	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
-		join = result->children[0].get();
-	} else {
-		join = result.get();
-	}
-
-	if (ref.type == JoinType::MARK) {
-		join->Cast<LogicalJoin>().mark_index = ref.mark_index;
-	}
-	for (auto &child : join->children) {
-		if (child->type == LogicalOperatorType::LOGICAL_FILTER) {
-			auto &filter = child->Cast<LogicalFilter>();
-			for (auto &expr : filter.expressions) {
-				PlanSubqueries(expr, filter.children[0]);
-			}
-		}
-	}
-
-	// we visit the expressions depending on the type of join
-	switch (join->type) {
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		// comparison join
-		// in this join we visit the expressions on the LHS with the LHS as root node
-		// and the expressions on the RHS with the RHS as root node
-		auto &comp_join = join->Cast<LogicalComparisonJoin>();
-		for (idx_t i = 0; i < comp_join.conditions.size(); i++) {
-			PlanSubqueries(comp_join.conditions[i].left, comp_join.children[0]);
-			PlanSubqueries(comp_join.conditions[i].right, comp_join.children[1]);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &any_join = join->Cast<LogicalAnyJoin>();
-		// for the any join we just visit the condition
-		if (any_join.condition->HasSubquery()) {
-			throw NotImplementedException("Cannot perform non-inner join on subquery!");
-		}
-		break;
-	}
-	default:
-		break;
-	}
-	if (!ref.duplicate_eliminated_columns.empty()) {
-		auto &comp_join = join->Cast<LogicalComparisonJoin>();
-		comp_join.type = LogicalOperatorType::LOGICAL_DELIM_JOIN;
-		comp_join.delim_flipped = ref.delim_flipped;
-		for (auto &col : ref.duplicate_eliminated_columns) {
-			comp_join.duplicate_eliminated_columns.emplace_back(col->Copy());
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_pivotref.cpp b/src/duckdb/src/planner/binder/tableref/plan_pivotref.cpp
deleted file mode 100644
index 4d9482e5b..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_pivotref.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "duckdb/planner/tableref/bound_pivotref.hpp"
-#include "duckdb/planner/operator/logical_pivot.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundPivotRef &ref) {
-	auto subquery = ref.child_binder->CreatePlan(*ref.child);
-
-	auto result = make_uniq<LogicalPivot>(ref.bind_index, std::move(subquery), std::move(ref.bound_pivot));
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_subqueryref.cpp b/src/duckdb/src/planner/binder/tableref/plan_subqueryref.cpp
deleted file mode 100644
index 821654460..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_subqueryref.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSubqueryRef &ref) {
-	// generate the logical plan for the subquery
-	// this happens separately from the current LogicalPlan generation
-	ref.binder->is_outside_flattened = is_outside_flattened;
-	auto subquery = ref.binder->CreatePlan(*ref.subquery);
-	if (ref.binder->has_unplanned_dependent_joins) {
-		has_unplanned_dependent_joins = true;
-	}
-	return subquery;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binder/tableref/plan_table_function.cpp b/src/duckdb/src/planner/binder/tableref/plan_table_function.cpp
deleted file mode 100644
index 3be48aa6c..000000000
--- a/src/duckdb/src/planner/binder/tableref/plan_table_function.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/tableref/bound_table_function.hpp"
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
-	if (ref.subquery) {
-		auto child_node = CreatePlan(*ref.subquery);
-		ref.get->children.push_back(std::move(child_node));
-	}
-	return std::move(ref.get);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/binding_alias.cpp b/src/duckdb/src/planner/binding_alias.cpp
deleted file mode 100644
index 62f60dfa1..000000000
--- a/src/duckdb/src/planner/binding_alias.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "duckdb/planner/binding_alias.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
-
-namespace duckdb {
-
-BindingAlias::BindingAlias() {
-}
-
-BindingAlias::BindingAlias(string alias_p) : alias(std::move(alias_p)) {
-}
-
-BindingAlias::BindingAlias(string schema_p, string alias_p) : schema(std::move(schema_p)), alias(std::move(alias_p)) {
-}
-
-BindingAlias::BindingAlias(const StandardEntry &entry)
-    : catalog(entry.ParentCatalog().GetName()), schema(entry.schema.name), alias(entry.name) {
-}
-
-BindingAlias::BindingAlias(string catalog_p, string schema_p, string alias_p)
-    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), alias(std::move(alias_p)) {
-}
-
-bool BindingAlias::IsSet() const {
-	return !alias.empty();
-}
-
-const string &BindingAlias::GetAlias() const {
-	if (!IsSet()) {
-		throw InternalException("Calling BindingAlias::GetAlias on a non-set alias");
-	}
-	return alias;
-}
-
-string BindingAlias::ToString() const {
-	string result;
-	if (!catalog.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
-	}
-	if (!schema.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(alias);
-	return result;
-}
-
-bool BindingAlias::Matches(const BindingAlias &other) const {
-	// we match based on the specificity of the other entry
-	// i.e. "tbl" matches "catalog.schema.tbl"
-	// but "schema2.tbl" does not match "schema.tbl"
-	if (!other.catalog.empty()) {
-		if (!StringUtil::CIEquals(catalog, other.catalog)) {
-			return false;
-		}
-	}
-	if (!other.schema.empty()) {
-		if (!StringUtil::CIEquals(schema, other.schema)) {
-			return false;
-		}
-	}
-	return StringUtil::CIEquals(alias, other.alias);
-}
-
-bool BindingAlias::operator==(const BindingAlias &other) const {
-	return StringUtil::CIEquals(catalog, other.catalog) && StringUtil::CIEquals(schema, other.schema) &&
-	       StringUtil::CIEquals(alias, other.alias);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/bound_parameter_map.cpp b/src/duckdb/src/planner/bound_parameter_map.cpp
deleted file mode 100644
index 112a17934..000000000
--- a/src/duckdb/src/planner/bound_parameter_map.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "duckdb/planner/bound_parameter_map.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-
-namespace duckdb {
-
-BoundParameterMap::BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data)
-    : parameter_data(parameter_data) {
-}
-
-LogicalType BoundParameterMap::GetReturnType(const string &identifier) {
-	D_ASSERT(!identifier.empty());
-	auto it = parameter_data.find(identifier);
-	if (it == parameter_data.end()) {
-		return LogicalTypeId::UNKNOWN;
-	}
-	return it->second.return_type;
-}
-
-bound_parameter_map_t *BoundParameterMap::GetParametersPtr() {
-	return &parameters;
-}
-
-const bound_parameter_map_t &BoundParameterMap::GetParameters() {
-	return parameters;
-}
-
-const case_insensitive_map_t<BoundParameterData> &BoundParameterMap::GetParameterData() {
-	return parameter_data;
-}
-
-shared_ptr<BoundParameterData> BoundParameterMap::CreateOrGetData(const string &identifier) {
-	auto entry = parameters.find(identifier);
-	if (entry == parameters.end()) {
-		// no entry yet: create a new one
-		auto data = make_shared_ptr<BoundParameterData>();
-		data->return_type = GetReturnType(identifier);
-
-		CreateNewParameter(identifier, data);
-		return data;
-	}
-	return entry->second;
-}
-
-unique_ptr<BoundParameterExpression> BoundParameterMap::BindParameterExpression(ParameterExpression &expr) {
-
-	auto &identifier = expr.identifier;
-	D_ASSERT(!parameter_data.count(identifier));
-
-	// No value has been supplied yet,
-	// We return a shared pointer to an object that will get populated with a Value later
-	// When the BoundParameterExpression gets executed, this will be used to get the corresponding value
-	auto param_data = CreateOrGetData(identifier);
-	auto bound_expr = make_uniq<BoundParameterExpression>(identifier);
-
-	bound_expr->parameter_data = param_data;
-	bound_expr->SetAlias(expr.GetAlias());
-
-	auto param_type = param_data->return_type;
-	auto identifier_type = GetReturnType(identifier);
-
-	// we found a type for this bound parameter, but now we found another occurrence with the same identifier,
-	// a CAST around this consecutive occurrence might swallow the unknown type of this consecutive occurrence,
-	// then, if we do not rebind, we potentially have unknown data types during execution
-	if (identifier_type == LogicalType::UNKNOWN && param_type != LogicalType::UNKNOWN) {
-		rebind = true;
-	}
-
-	bound_expr->return_type = identifier_type;
-	return bound_expr;
-}
-
-void BoundParameterMap::CreateNewParameter(const string &id, const shared_ptr<BoundParameterData> &param_data) {
-	D_ASSERT(!parameters.count(id));
-	parameters.emplace(std::make_pair(id, param_data));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/bound_result_modifier.cpp b/src/duckdb/src/planner/bound_result_modifier.cpp
deleted file mode 100644
index 4f4706076..000000000
--- a/src/duckdb/src/planner/bound_result_modifier.cpp
+++ /dev/null
@@ -1,199 +0,0 @@
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/parser/expression_map.hpp"
-
-namespace duckdb {
-
-BoundResultModifier::BoundResultModifier(ResultModifierType type) : type(type) {
-}
-
-BoundResultModifier::~BoundResultModifier() {
-}
-
-BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression)
-    : type(type), null_order(null_order), expression(std::move(expression)) {
-}
-BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression,
-                                   unique_ptr<BaseStatistics> stats)
-    : type(type), null_order(null_order), expression(std::move(expression)), stats(std::move(stats)) {
-}
-
-BoundOrderByNode BoundOrderByNode::Copy() const {
-	if (stats) {
-		return BoundOrderByNode(type, null_order, expression->Copy(), stats->ToUnique());
-	} else {
-		return BoundOrderByNode(type, null_order, expression->Copy());
-	}
-}
-
-bool BoundOrderByNode::Equals(const BoundOrderByNode &other) const {
-	if (type != other.type || null_order != other.null_order) {
-		return false;
-	}
-	if (!expression->Equals(*other.expression)) {
-		return false;
-	}
-
-	return true;
-}
-
-string BoundOrderByNode::ToString() const {
-	auto str = expression->ToString();
-	switch (type) {
-	case OrderType::ASCENDING:
-		str += " ASC";
-		break;
-	case OrderType::DESCENDING:
-		str += " DESC";
-		break;
-	default:
-		break;
-	}
-
-	switch (null_order) {
-	case OrderByNullType::NULLS_FIRST:
-		str += " NULLS FIRST";
-		break;
-	case OrderByNullType::NULLS_LAST:
-		str += " NULLS LAST";
-		break;
-	default:
-		break;
-	}
-	return str;
-}
-
-unique_ptr<BoundOrderModifier> BoundOrderModifier::Copy() const {
-	auto result = make_uniq<BoundOrderModifier>();
-	for (auto &order : orders) {
-		result->orders.push_back(order.Copy());
-	}
-	return result;
-}
-
-bool BoundOrderModifier::Equals(const BoundOrderModifier &left, const BoundOrderModifier &right) {
-	if (left.orders.size() != right.orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < left.orders.size(); i++) {
-		if (!left.orders[i].Equals(right.orders[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool BoundOrderModifier::Equals(const unique_ptr<BoundOrderModifier> &left,
-                                const unique_ptr<BoundOrderModifier> &right) {
-	if (left.get() == right.get()) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return BoundOrderModifier::Equals(*left, *right);
-}
-
-bool BoundOrderModifier::Simplify(vector<BoundOrderByNode> &orders, const vector<unique_ptr<Expression>> &groups) {
-	// for each ORDER BY - check if it is actually necessary
-	// expressions that are in the groups do not need to be ORDERED BY
-	// `ORDER BY` on a group has no effect, because for each aggregate, the group is unique
-	// similarly, we only need to ORDER BY each aggregate once
-	expression_set_t seen_expressions;
-	for (auto &target : groups) {
-		seen_expressions.insert(*target);
-	}
-	vector<BoundOrderByNode> new_order_nodes;
-	for (auto &order_node : orders) {
-		if (seen_expressions.find(*order_node.expression) != seen_expressions.end()) {
-			// we do not need to order by this node
-			continue;
-		}
-		seen_expressions.insert(*order_node.expression);
-		new_order_nodes.push_back(std::move(order_node));
-	}
-	orders.swap(new_order_nodes);
-
-	return orders.empty(); // NOLINT
-}
-
-bool BoundOrderModifier::Simplify(const vector<unique_ptr<Expression>> &groups) {
-	return Simplify(orders, groups);
-}
-
-BoundLimitNode::BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage,
-                               unique_ptr<Expression> expression_p)
-    : type(type), constant_integer(constant_integer), constant_percentage(constant_percentage),
-      expression(std::move(expression_p)) {
-}
-
-BoundLimitNode::BoundLimitNode() : type(LimitNodeType::UNSET) {
-}
-
-BoundLimitNode::BoundLimitNode(int64_t constant_value)
-    : type(LimitNodeType::CONSTANT_VALUE), constant_integer(NumericCast<idx_t>(constant_value)) {
-}
-
-BoundLimitNode::BoundLimitNode(double percentage_value)
-    : type(LimitNodeType::CONSTANT_PERCENTAGE), constant_percentage(percentage_value) {
-}
-
-BoundLimitNode::BoundLimitNode(unique_ptr<Expression> expression_p, bool is_percentage)
-    : type(is_percentage ? LimitNodeType::EXPRESSION_PERCENTAGE : LimitNodeType::EXPRESSION_VALUE),
-      expression(std::move(expression_p)) {
-}
-
-BoundLimitNode BoundLimitNode::ConstantValue(int64_t value) {
-	return BoundLimitNode(value);
-}
-
-BoundLimitNode BoundLimitNode::ConstantPercentage(double percentage) {
-	return BoundLimitNode(percentage);
-}
-
-BoundLimitNode BoundLimitNode::ExpressionValue(unique_ptr<Expression> expression) {
-	return BoundLimitNode(std::move(expression), false);
-}
-
-BoundLimitNode BoundLimitNode::ExpressionPercentage(unique_ptr<Expression> expression) {
-	return BoundLimitNode(std::move(expression), true);
-}
-
-idx_t BoundLimitNode::GetConstantValue() const {
-	if (Type() != LimitNodeType::CONSTANT_VALUE) {
-		throw InternalException("BoundLimitNode::GetConstantValue called but limit is not a constant value");
-	}
-	return constant_integer;
-}
-
-double BoundLimitNode::GetConstantPercentage() const {
-	if (Type() != LimitNodeType::CONSTANT_PERCENTAGE) {
-		throw InternalException("BoundLimitNode::GetConstantPercentage called but limit is not a constant percentage");
-	}
-	return constant_percentage;
-}
-
-const Expression &BoundLimitNode::GetValueExpression() const {
-	if (Type() != LimitNodeType::EXPRESSION_VALUE) {
-		throw InternalException("BoundLimitNode::GetValueExpression called but limit is not an expression value");
-	}
-	return *expression;
-}
-
-const Expression &BoundLimitNode::GetPercentageExpression() const {
-	if (Type() != LimitNodeType::EXPRESSION_PERCENTAGE) {
-		throw InternalException(
-		    "BoundLimitNode::GetPercentageExpression called but limit is not an expression percentage");
-	}
-	return *expression;
-}
-
-BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
-}
-
-BoundOrderModifier::BoundOrderModifier() : BoundResultModifier(ResultModifierType::ORDER_MODIFIER) {
-}
-
-BoundDistinctModifier::BoundDistinctModifier() : BoundResultModifier(ResultModifierType::DISTINCT_MODIFIER) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/collation_binding.cpp b/src/duckdb/src/planner/collation_binding.cpp
deleted file mode 100644
index aabde7f55..000000000
--- a/src/duckdb/src/planner/collation_binding.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "duckdb/planner/collation_binding.hpp"
-#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/function/function_binder.hpp"
-
-namespace duckdb {
-
-bool PushVarcharCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
-                          CollationType type) {
-	if (sql_type.id() != LogicalTypeId::VARCHAR) {
-		// only VARCHAR columns require collation
-		return false;
-	}
-	// replace default collation with system collation
-	auto str_collation = StringType::GetCollation(sql_type);
-	string collation;
-	if (str_collation.empty()) {
-		collation = DBConfig::GetConfig(context).options.collation;
-	} else {
-		collation = str_collation;
-	}
-	collation = StringUtil::Lower(collation);
-	// bind the collation
-	if (collation.empty() || collation == "binary" || collation == "c" || collation == "posix") {
-		// no collation or binary collation: skip
-		return false;
-	}
-	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
-	vector<reference<CollateCatalogEntry>> entries;
-	unordered_set<string> collations;
-	for (auto &collation_argument : splits) {
-		if (collations.count(collation_argument)) {
-			// we already applied this collation
-			continue;
-		}
-		auto &collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
-		if (collation_entry.combinable) {
-			entries.insert(entries.begin(), collation_entry);
-		} else {
-			if (!entries.empty() && !entries.back().get().combinable) {
-				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back().get().name,
-				                      collation_entry.name);
-			}
-			entries.push_back(collation_entry);
-		}
-		collations.insert(collation_argument);
-	}
-	for (auto &entry : entries) {
-		auto &collation_entry = entry.get();
-		if (!collation_entry.combinable && type == CollationType::COMBINABLE_COLLATIONS) {
-			// not a combinable collation - ignore
-			return false;
-		}
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(source));
-
-		FunctionBinder function_binder(context);
-		auto function = function_binder.BindScalarFunction(collation_entry.function, std::move(children));
-		source = std::move(function);
-	}
-	return true;
-}
-
-bool PushTimeTZCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
-                         CollationType) {
-	if (sql_type.id() != LogicalTypeId::TIME_TZ) {
-		return false;
-	}
-
-	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto &function_entry =
-	    catalog.GetEntry<ScalarFunctionCatalogEntry>(context, DEFAULT_SCHEMA, "timetz_byte_comparable");
-	if (function_entry.functions.Size() != 1) {
-		throw InternalException("timetz_byte_comparable should only have a single overload");
-	}
-	auto &scalar_function = function_entry.functions.GetFunctionReferenceByOffset(0);
-	vector<unique_ptr<Expression>> children;
-	children.push_back(std::move(source));
-
-	FunctionBinder function_binder(context);
-	auto function = function_binder.BindScalarFunction(scalar_function, std::move(children));
-	source = std::move(function);
-	return true;
-}
-
-bool PushIntervalCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
-                           CollationType) {
-	if (sql_type.id() != LogicalTypeId::INTERVAL) {
-		return false;
-	}
-
-	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto &function_entry = catalog.GetEntry<ScalarFunctionCatalogEntry>(context, DEFAULT_SCHEMA, "normalized_interval");
-	if (function_entry.functions.Size() != 1) {
-		throw InternalException("normalized_interval should only have a single overload");
-	}
-	auto &scalar_function = function_entry.functions.GetFunctionReferenceByOffset(0);
-	vector<unique_ptr<Expression>> children;
-	children.push_back(std::move(source));
-
-	FunctionBinder function_binder(context);
-	auto function = function_binder.BindScalarFunction(scalar_function, std::move(children));
-	source = std::move(function);
-	return true;
-}
-
-// timetz_byte_comparable
-CollationBinding::CollationBinding() {
-	RegisterCollation(CollationCallback(PushVarcharCollation));
-	RegisterCollation(CollationCallback(PushTimeTZCollation));
-	RegisterCollation(CollationCallback(PushIntervalCollation));
-}
-
-void CollationBinding::RegisterCollation(CollationCallback callback) {
-	collations.push_back(callback);
-}
-
-bool CollationBinding::PushCollation(ClientContext &context, unique_ptr<Expression> &source,
-                                     const LogicalType &sql_type, CollationType type) const {
-	for (auto &collation : collations) {
-		if (collation.try_push_collation(context, source, sql_type, type)) {
-			// successfully pushed a collation
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression.cpp b/src/duckdb/src/planner/expression.cpp
deleted file mode 100644
index 3eb0118c1..000000000
--- a/src/duckdb/src/planner/expression.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include "duckdb/planner/expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/parser/expression_util.hpp"
-
-namespace duckdb {
-
-Expression::Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type)
-    : BaseExpression(type, expression_class), return_type(std::move(return_type)) {
-}
-
-Expression::~Expression() {
-}
-
-bool Expression::IsAggregate() const {
-	bool is_aggregate = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { is_aggregate |= child.IsAggregate(); });
-	return is_aggregate;
-}
-
-bool Expression::IsWindow() const {
-	bool is_window = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { is_window |= child.IsWindow(); });
-	return is_window;
-}
-
-bool Expression::IsScalar() const {
-	bool is_scalar = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.IsScalar()) {
-			is_scalar = false;
-		}
-	});
-	return is_scalar;
-}
-
-bool Expression::IsVolatile() const {
-	bool is_volatile = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (child.IsVolatile()) {
-			is_volatile = true;
-		}
-	});
-	return is_volatile;
-}
-
-bool Expression::IsConsistent() const {
-	bool is_consistent = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.IsConsistent()) {
-			is_consistent = false;
-		}
-	});
-	return is_consistent;
-}
-
-bool Expression::CanThrow() const {
-	bool can_throw = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { can_throw |= child.CanThrow(); });
-	return can_throw;
-}
-
-bool Expression::PropagatesNullValues() const {
-	if (type == ExpressionType::OPERATOR_IS_NULL || type == ExpressionType::OPERATOR_IS_NOT_NULL ||
-	    type == ExpressionType::COMPARE_NOT_DISTINCT_FROM || type == ExpressionType::COMPARE_DISTINCT_FROM ||
-	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND ||
-	    type == ExpressionType::OPERATOR_COALESCE) {
-		return false;
-	}
-	bool propagate_null_values = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.PropagatesNullValues()) {
-			propagate_null_values = false;
-		}
-	});
-	return propagate_null_values;
-}
-
-bool Expression::IsFoldable() const {
-	bool is_foldable = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.IsFoldable()) {
-			is_foldable = false;
-		}
-	});
-	return is_foldable;
-}
-
-bool Expression::HasParameter() const {
-	bool has_parameter = false;
-	ExpressionIterator::EnumerateChildren(*this,
-	                                      [&](const Expression &child) { has_parameter |= child.HasParameter(); });
-	return has_parameter;
-}
-
-bool Expression::HasSubquery() const {
-	bool has_subquery = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { has_subquery |= child.HasSubquery(); });
-	return has_subquery;
-}
-
-hash_t Expression::Hash() const {
-	hash_t hash = duckdb::Hash<uint32_t>(static_cast<uint32_t>(type));
-	hash = CombineHash(hash, return_type.Hash());
-	ExpressionIterator::EnumerateChildren(*this,
-	                                      [&](const Expression &child) { hash = CombineHash(child.Hash(), hash); });
-	return hash;
-}
-
-bool Expression::Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right) {
-	if (left.get() == right.get()) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return left->Equals(*right);
-}
-
-bool Expression::ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right) {
-	return ExpressionUtil::ListEquals(left, right);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp b/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp
deleted file mode 100644
index 68bc16b26..000000000
--- a/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/function/function_serialization.hpp"
-
-namespace duckdb {
-
-BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, vector<unique_ptr<Expression>> children,
-                                                   unique_ptr<Expression> filter, unique_ptr<FunctionData> bind_info,
-                                                   AggregateType aggr_type)
-    : Expression(ExpressionType::BOUND_AGGREGATE, ExpressionClass::BOUND_AGGREGATE, function.return_type),
-      function(std::move(function)), children(std::move(children)), bind_info(std::move(bind_info)),
-      aggr_type(aggr_type), filter(std::move(filter)) {
-	D_ASSERT(!this->function.name.empty());
-}
-
-string BoundAggregateExpression::ToString() const {
-	return FunctionExpression::ToString<BoundAggregateExpression, Expression, BoundOrderModifier>(
-	    *this, string(), string(), function.name, false, IsDistinct(), filter.get(), order_bys.get());
-}
-
-hash_t BoundAggregateExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	result = CombineHash(result, function.Hash());
-	result = CombineHash(result, duckdb::Hash(IsDistinct()));
-	return result;
-}
-
-bool BoundAggregateExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundAggregateExpression>();
-	if (other.aggr_type != aggr_type) {
-		return false;
-	}
-	if (other.function != function) {
-		return false;
-	}
-	if (children.size() != other.children.size()) {
-		return false;
-	}
-	if (!Expression::Equals(other.filter, filter)) {
-		return false;
-	}
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(*children[i], *other.children[i])) {
-			return false;
-		}
-	}
-	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {
-		return false;
-	}
-	if (!BoundOrderModifier::Equals(order_bys, other.order_bys)) {
-		return false;
-	}
-	return true;
-}
-
-bool BoundAggregateExpression::PropagatesNullValues() const {
-	return function.null_handling == FunctionNullHandling::SPECIAL_HANDLING ? false
-	                                                                        : Expression::PropagatesNullValues();
-}
-
-unique_ptr<Expression> BoundAggregateExpression::Copy() const {
-	vector<unique_ptr<Expression>> new_children;
-	new_children.reserve(children.size());
-	for (auto &child : children) {
-		new_children.push_back(child->Copy());
-	}
-	auto new_bind_info = bind_info ? bind_info->Copy() : nullptr;
-	auto new_filter = filter ? filter->Copy() : nullptr;
-	auto copy = make_uniq<BoundAggregateExpression>(function, std::move(new_children), std::move(new_filter),
-	                                                std::move(new_bind_info), aggr_type);
-	copy->CopyProperties(*this);
-	copy->order_bys = order_bys ? order_bys->Copy() : nullptr;
-	return std::move(copy);
-}
-
-void BoundAggregateExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty(200, "return_type", return_type);
-	serializer.WriteProperty(201, "children", children);
-	FunctionSerializer::Serialize(serializer, function, bind_info.get());
-	serializer.WriteProperty(203, "aggregate_type", aggr_type);
-	serializer.WritePropertyWithDefault(204, "filter", filter, unique_ptr<Expression>());
-	serializer.WritePropertyWithDefault(205, "order_bys", order_bys, unique_ptr<BoundOrderModifier>());
-}
-
-unique_ptr<Expression> BoundAggregateExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
-	auto entry = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, return_type);
-	auto aggregate_type = deserializer.ReadProperty<AggregateType>(203, "aggregate_type");
-	auto filter =
-	    deserializer.ReadPropertyWithExplicitDefault<unique_ptr<Expression>>(204, "filter", unique_ptr<Expression>());
-	auto result = make_uniq<BoundAggregateExpression>(std::move(entry.first), std::move(children), std::move(filter),
-	                                                  std::move(entry.second), aggregate_type);
-	if (result->return_type != return_type) {
-		// return type mismatch - push a cast
-		auto &context = deserializer.Get<ClientContext &>();
-		return BoundCastExpression::AddCastToType(context, std::move(result), return_type);
-	}
-	deserializer.ReadPropertyWithExplicitDefault(205, "order_bys", result->order_bys, unique_ptr<BoundOrderModifier>());
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_between_expression.cpp b/src/duckdb/src/planner/expression/bound_between_expression.cpp
deleted file mode 100644
index 0b8533560..000000000
--- a/src/duckdb/src/planner/expression/bound_between_expression.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/planner/expression/bound_between_expression.hpp"
-#include "duckdb/parser/expression/between_expression.hpp"
-
-namespace duckdb {
-
-BoundBetweenExpression::BoundBetweenExpression()
-    : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN) {
-}
-
-BoundBetweenExpression::BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower,
-                                               unique_ptr<Expression> upper, bool lower_inclusive, bool upper_inclusive)
-    : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN),
-      input(std::move(input)), lower(std::move(lower)), upper(std::move(upper)), lower_inclusive(lower_inclusive),
-      upper_inclusive(upper_inclusive) {
-}
-
-string BoundBetweenExpression::ToString() const {
-	return BetweenExpression::ToString<BoundBetweenExpression, Expression>(*this);
-}
-
-bool BoundBetweenExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundBetweenExpression>();
-	if (!Expression::Equals(*input, *other.input)) {
-		return false;
-	}
-	if (!Expression::Equals(*lower, *other.lower)) {
-		return false;
-	}
-	if (!Expression::Equals(*upper, *other.upper)) {
-		return false;
-	}
-	return lower_inclusive == other.lower_inclusive && upper_inclusive == other.upper_inclusive;
-}
-
-unique_ptr<Expression> BoundBetweenExpression::Copy() const {
-	auto copy = make_uniq<BoundBetweenExpression>(input->Copy(), lower->Copy(), upper->Copy(), lower_inclusive,
-	                                              upper_inclusive);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_case_expression.cpp b/src/duckdb/src/planner/expression/bound_case_expression.cpp
deleted file mode 100644
index f35705c15..000000000
--- a/src/duckdb/src/planner/expression/bound_case_expression.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-
-namespace duckdb {
-
-BoundCaseExpression::BoundCaseExpression(LogicalType type)
-    : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, std::move(type)) {
-}
-
-BoundCaseExpression::BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,
-                                         unique_ptr<Expression> else_expr_p)
-    : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, then_expr->return_type),
-      else_expr(std::move(else_expr_p)) {
-	BoundCaseCheck check;
-	check.when_expr = std::move(when_expr);
-	check.then_expr = std::move(then_expr);
-	case_checks.push_back(std::move(check));
-}
-
-string BoundCaseExpression::ToString() const {
-	return CaseExpression::ToString<BoundCaseExpression, Expression>(*this);
-}
-
-bool BoundCaseExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundCaseExpression>();
-	if (case_checks.size() != other.case_checks.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < case_checks.size(); i++) {
-		if (!Expression::Equals(*case_checks[i].when_expr, *other.case_checks[i].when_expr)) {
-			return false;
-		}
-		if (!Expression::Equals(*case_checks[i].then_expr, *other.case_checks[i].then_expr)) {
-			return false;
-		}
-	}
-	if (!Expression::Equals(*else_expr, *other.else_expr)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundCaseExpression::Copy() const {
-	auto new_case = make_uniq<BoundCaseExpression>(return_type);
-	for (auto &check : case_checks) {
-		BoundCaseCheck new_check;
-		new_check.when_expr = check.when_expr->Copy();
-		new_check.then_expr = check.then_expr->Copy();
-		new_case->case_checks.push_back(std::move(new_check));
-	}
-	new_case->else_expr = else_expr->Copy();
-
-	new_case->CopyProperties(*this);
-	return std::move(new_case);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_cast_expression.cpp b/src/duckdb/src/planner/expression/bound_cast_expression.cpp
deleted file mode 100644
index 4168bf3e5..000000000
--- a/src/duckdb/src/planner/expression/bound_cast_expression.cpp
+++ /dev/null
@@ -1,232 +0,0 @@
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/function/cast_rules.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
-	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
-	GetCastFunctionInput input(context);
-	return cast_functions.GetCastFunction(source, target, input);
-}
-
-BoundCastExpression::BoundCastExpression(unique_ptr<Expression> child_p, LogicalType target_type_p,
-                                         BoundCastInfo bound_cast_p, bool try_cast_p)
-    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
-      child(std::move(child_p)), try_cast(try_cast_p), bound_cast(std::move(bound_cast_p)) {
-}
-
-BoundCastExpression::BoundCastExpression(ClientContext &context, unique_ptr<Expression> child_p,
-                                         LogicalType target_type_p)
-    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
-      child(std::move(child_p)), try_cast(false),
-      bound_cast(BindCastFunction(context, child->return_type, return_type)) {
-}
-
-unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
-                                                 BoundCastInfo bound_cast, bool try_cast) {
-	if (ExpressionBinder::GetExpressionReturnType(*expr) == target_type) {
-		return expr;
-	}
-	auto &expr_type = expr->return_type;
-	if (target_type.id() == LogicalTypeId::LIST && expr_type.id() == LogicalTypeId::LIST) {
-		auto &target_list = ListType::GetChildType(target_type);
-		auto &expr_list = ListType::GetChildType(expr_type);
-		if (target_list.id() == LogicalTypeId::ANY || expr_list == target_list) {
-			return expr;
-		}
-	}
-	auto result = make_uniq<BoundCastExpression>(std::move(expr), target_type, std::move(bound_cast), try_cast);
-	result->SetQueryLocation(result->child->GetQueryLocation());
-	return std::move(result);
-}
-
-unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
-                                             CastFunctionSet &cast_functions, GetCastFunctionInput &get_input,
-                                             bool try_cast) {
-	D_ASSERT(expr);
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_PARAMETER) {
-		auto &parameter = expr->Cast<BoundParameterExpression>();
-		if (!target_type.IsValid()) {
-			// invalidate the parameter
-			parameter.parameter_data->return_type = LogicalType::INVALID;
-			parameter.return_type = target_type;
-			return expr;
-		}
-		if (parameter.parameter_data->return_type.id() == LogicalTypeId::INVALID) {
-			// we don't know the type of this parameter
-			parameter.return_type = target_type;
-			return expr;
-		}
-		if (parameter.parameter_data->return_type.id() == LogicalTypeId::UNKNOWN) {
-			// prepared statement parameter cast - but there is no type, convert the type
-			parameter.parameter_data->return_type = target_type;
-			parameter.return_type = target_type;
-			return expr;
-		}
-		// prepared statement parameter already has a type
-		if (parameter.parameter_data->return_type == target_type) {
-			// this type! we are done
-			parameter.return_type = parameter.parameter_data->return_type;
-			return expr;
-		}
-		// invalidate the type
-		parameter.parameter_data->return_type = LogicalType::INVALID;
-		parameter.return_type = target_type;
-		return expr;
-	} else if (expr->GetExpressionClass() == ExpressionClass::BOUND_DEFAULT) {
-		D_ASSERT(target_type.IsValid());
-		auto &def = expr->Cast<BoundDefaultExpression>();
-		def.return_type = target_type;
-	}
-	if (!target_type.IsValid()) {
-		return expr;
-	}
-
-	auto cast_function = cast_functions.GetCastFunction(expr->return_type, target_type, get_input);
-	return AddCastExpressionInternal(std::move(expr), target_type, std::move(cast_function), try_cast);
-}
-
-unique_ptr<Expression> BoundCastExpression::AddDefaultCastToType(unique_ptr<Expression> expr,
-                                                                 const LogicalType &target_type, bool try_cast) {
-	CastFunctionSet default_set;
-	GetCastFunctionInput get_input;
-	get_input.query_location = expr->GetQueryLocation();
-	return AddCastToTypeInternal(std::move(expr), target_type, default_set, get_input, try_cast);
-}
-
-unique_ptr<Expression> BoundCastExpression::AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
-                                                          const LogicalType &target_type, bool try_cast) {
-	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
-	GetCastFunctionInput get_input(context);
-	get_input.query_location = expr->GetQueryLocation();
-	return AddCastToTypeInternal(std::move(expr), target_type, cast_functions, get_input, try_cast);
-}
-
-unique_ptr<Expression> BoundCastExpression::AddArrayCastToList(ClientContext &context, unique_ptr<Expression> expr) {
-	if (expr->return_type.id() != LogicalTypeId::ARRAY) {
-		return expr;
-	}
-	auto &child_type = ArrayType::GetChildType(expr->return_type);
-	return BoundCastExpression::AddCastToType(context, std::move(expr), LogicalType::LIST(child_type));
-}
-
-bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type) {
-	D_ASSERT(source_type.IsValid() && target_type.IsValid());
-	if (source_type.id() == LogicalTypeId::BOOLEAN || target_type.id() == LogicalTypeId::BOOLEAN) {
-		return false;
-	}
-	if (source_type.id() == LogicalTypeId::FLOAT || target_type.id() == LogicalTypeId::FLOAT) {
-		return false;
-	}
-	if (source_type.id() == LogicalTypeId::DOUBLE || target_type.id() == LogicalTypeId::DOUBLE) {
-		return false;
-	}
-	if (source_type.id() == LogicalTypeId::DECIMAL || target_type.id() == LogicalTypeId::DECIMAL) {
-		uint8_t source_width, target_width;
-		uint8_t source_scale, target_scale;
-		// cast to or from decimal
-		// cast is only invertible if the cast is strictly widening
-		if (!source_type.GetDecimalProperties(source_width, source_scale)) {
-			return false;
-		}
-		if (!target_type.GetDecimalProperties(target_width, target_scale)) {
-			return false;
-		}
-		if (target_scale < source_scale) {
-			return false;
-		}
-		return true;
-	}
-	switch (source_type.id()) {
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-		switch (target_type.id()) {
-			// see types.hpp to see timestamp ranking
-		case LogicalTypeId::TIMESTAMP:
-			return source_type.id() <= LogicalTypeId::TIMESTAMP;
-		case LogicalTypeId::TIMESTAMP_SEC:
-			return source_type.id() <= LogicalTypeId::TIMESTAMP_SEC;
-		case LogicalTypeId::TIMESTAMP_MS:
-			return source_type.id() <= LogicalTypeId::TIMESTAMP_MS;
-		case LogicalTypeId::TIMESTAMP_NS:
-			return source_type.id() <= LogicalTypeId::TIMESTAMP_NS;
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIME_TZ:
-			return false;
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return source_type.id() == LogicalTypeId::TIMESTAMP_TZ;
-		default:
-			break;
-		}
-		break;
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BIT:
-	case LogicalTypeId::TIME_TZ:
-		return false;
-	default:
-		break;
-	}
-	if (target_type.id() == LogicalTypeId::VARCHAR) {
-		switch (source_type.id()) {
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIME_TZ:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return true;
-		default:
-			return false;
-		}
-	}
-	return true;
-}
-
-string BoundCastExpression::ToString() const {
-	return (try_cast ? "TRY_CAST(" : "CAST(") + child->GetName() + " AS " + return_type.ToString() + ")";
-}
-
-bool BoundCastExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundCastExpression>();
-	if (!Expression::Equals(*child, *other.child)) {
-		return false;
-	}
-	if (try_cast != other.try_cast) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundCastExpression::Copy() const {
-	auto copy = make_uniq<BoundCastExpression>(child->Copy(), return_type, bound_cast.Copy(), try_cast);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-bool BoundCastExpression::CanThrow() const {
-	const auto child_type = child->return_type;
-	if (return_type.id() != child_type.id() &&
-	    LogicalType::ForceMaxLogicalType(return_type, child_type) == child_type.id()) {
-		return true;
-	}
-	bool changes_type = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { changes_type |= child.CanThrow(); });
-	return changes_type;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_columnref_expression.cpp b/src/duckdb/src/planner/expression/bound_columnref_expression.cpp
deleted file mode 100644
index 1c7b15365..000000000
--- a/src/duckdb/src/planner/expression/bound_columnref_expression.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-BoundColumnRefExpression::BoundColumnRefExpression(string alias_p, LogicalType type, ColumnBinding binding, idx_t depth)
-    : Expression(ExpressionType::BOUND_COLUMN_REF, ExpressionClass::BOUND_COLUMN_REF, std::move(type)),
-      binding(binding), depth(depth) {
-	this->alias = std::move(alias_p);
-}
-
-BoundColumnRefExpression::BoundColumnRefExpression(LogicalType type, ColumnBinding binding, idx_t depth)
-    : BoundColumnRefExpression(string(), std::move(type), binding, depth) {
-}
-
-unique_ptr<Expression> BoundColumnRefExpression::Copy() const {
-	return make_uniq<BoundColumnRefExpression>(alias, return_type, binding, depth);
-}
-
-hash_t BoundColumnRefExpression::Hash() const {
-	auto result = Expression::Hash();
-	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.column_index));
-	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.table_index));
-	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
-}
-
-bool BoundColumnRefExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundColumnRefExpression>();
-	return other.binding == binding && other.depth == depth;
-}
-
-string BoundColumnRefExpression::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return binding.ToString();
-	}
-#endif
-	return Expression::GetName();
-}
-
-string BoundColumnRefExpression::ToString() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return binding.ToString();
-	}
-#endif
-	if (!alias.empty()) {
-		return alias;
-	}
-	return binding.ToString();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_comparison_expression.cpp b/src/duckdb/src/planner/expression/bound_comparison_expression.cpp
deleted file mode 100644
index a75a40894..000000000
--- a/src/duckdb/src/planner/expression/bound_comparison_expression.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-
-namespace duckdb {
-
-BoundComparisonExpression::BoundComparisonExpression(ExpressionType type, unique_ptr<Expression> left,
-                                                     unique_ptr<Expression> right)
-    : Expression(type, ExpressionClass::BOUND_COMPARISON, LogicalType::BOOLEAN), left(std::move(left)),
-      right(std::move(right)) {
-}
-
-string BoundComparisonExpression::ToString() const {
-	return ComparisonExpression::ToString<BoundComparisonExpression, Expression>(*this);
-}
-
-bool BoundComparisonExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundComparisonExpression>();
-	if (!Expression::Equals(*left, *other.left)) {
-		return false;
-	}
-	if (!Expression::Equals(*right, *other.right)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundComparisonExpression::Copy() const {
-	auto copy = make_uniq<BoundComparisonExpression>(type, left->Copy(), right->Copy());
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_conjunction_expression.cpp b/src/duckdb/src/planner/expression/bound_conjunction_expression.cpp
deleted file mode 100644
index 1ad649bfc..000000000
--- a/src/duckdb/src/planner/expression/bound_conjunction_expression.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
-#include "duckdb/parser/expression_util.hpp"
-
-namespace duckdb {
-
-BoundConjunctionExpression::BoundConjunctionExpression(ExpressionType type)
-    : Expression(type, ExpressionClass::BOUND_CONJUNCTION, LogicalType::BOOLEAN) {
-}
-
-BoundConjunctionExpression::BoundConjunctionExpression(ExpressionType type, unique_ptr<Expression> left,
-                                                       unique_ptr<Expression> right)
-    : BoundConjunctionExpression(type) {
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-}
-
-string BoundConjunctionExpression::ToString() const {
-	return ConjunctionExpression::ToString<BoundConjunctionExpression, Expression>(*this);
-}
-
-bool BoundConjunctionExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundConjunctionExpression>();
-	return ExpressionUtil::SetEquals(children, other.children);
-}
-
-bool BoundConjunctionExpression::PropagatesNullValues() const {
-	return false;
-}
-
-unique_ptr<Expression> BoundConjunctionExpression::Copy() const {
-	auto copy = make_uniq<BoundConjunctionExpression>(type);
-	for (auto &expr : children) {
-		copy->children.push_back(expr->Copy());
-	}
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_constant_expression.cpp b/src/duckdb/src/planner/expression/bound_constant_expression.cpp
deleted file mode 100644
index 27b1eccc7..000000000
--- a/src/duckdb/src/planner/expression/bound_constant_expression.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/value_operations/value_operations.hpp"
-
-namespace duckdb {
-
-BoundConstantExpression::BoundConstantExpression(Value value_p)
-    : Expression(ExpressionType::VALUE_CONSTANT, ExpressionClass::BOUND_CONSTANT, value_p.type()),
-      value(std::move(value_p)) {
-}
-
-string BoundConstantExpression::ToString() const {
-	return value.ToSQLString();
-}
-
-bool BoundConstantExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundConstantExpression>();
-	return value.type() == other.value.type() && !ValueOperations::DistinctFrom(value, other.value);
-}
-
-hash_t BoundConstantExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	return CombineHash(value.Hash(), result);
-}
-
-unique_ptr<Expression> BoundConstantExpression::Copy() const {
-	auto copy = make_uniq<BoundConstantExpression>(value);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_expanded_expression.cpp b/src/duckdb/src/planner/expression/bound_expanded_expression.cpp
deleted file mode 100644
index 9e730fe42..000000000
--- a/src/duckdb/src/planner/expression/bound_expanded_expression.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/planner/expression/bound_expanded_expression.hpp"
-
-namespace duckdb {
-
-BoundExpandedExpression::BoundExpandedExpression(vector<unique_ptr<Expression>> expanded_expressions_p)
-    : Expression(ExpressionType::BOUND_EXPANDED, ExpressionClass::BOUND_EXPANDED, LogicalType::INTEGER),
-      expanded_expressions(std::move(expanded_expressions_p)) {
-}
-
-string BoundExpandedExpression::ToString() const {
-	return "BOUND_EXPANDED";
-}
-
-bool BoundExpandedExpression::Equals(const BaseExpression &other_p) const {
-	return false;
-}
-
-unique_ptr<Expression> BoundExpandedExpression::Copy() const {
-	throw SerializationException("Cannot copy BoundExpandedExpression");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_expression.cpp b/src/duckdb/src/planner/expression/bound_expression.cpp
deleted file mode 100644
index b475c4f49..000000000
--- a/src/duckdb/src/planner/expression/bound_expression.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-BoundExpression::BoundExpression(unique_ptr<Expression> expr_p)
-    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr_p)) {
-	this->alias = expr->GetAlias();
-}
-
-unique_ptr<Expression> &BoundExpression::GetExpression(ParsedExpression &expr) {
-	auto &bound_expr = expr.Cast<BoundExpression>();
-	if (!bound_expr.expr) {
-		throw InternalException("BoundExpression::GetExpression called on empty bound expression");
-	}
-	return bound_expr.expr;
-}
-
-string BoundExpression::ToString() const {
-	if (!expr) {
-		throw InternalException("ToString(): BoundExpression does not have a child");
-	}
-	return expr->ToString();
-}
-
-bool BoundExpression::Equals(const BaseExpression &other) const {
-	return false;
-}
-hash_t BoundExpression::Hash() const {
-	return 0;
-}
-
-unique_ptr<ParsedExpression> BoundExpression::Copy() const {
-	throw SerializationException("Cannot copy bound expression");
-}
-
-void BoundExpression::Serialize(Serializer &serializer) const {
-	throw SerializationException("Cannot serialize bound expression");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_function_expression.cpp b/src/duckdb/src/planner/expression/bound_function_expression.cpp
deleted file mode 100644
index 1be272540..000000000
--- a/src/duckdb/src/planner/expression/bound_function_expression.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/function/function_serialization.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/function/lambda_functions.hpp"
-
-namespace duckdb {
-
-BoundFunctionExpression::BoundFunctionExpression(LogicalType return_type, ScalarFunction bound_function,
-                                                 vector<unique_ptr<Expression>> arguments,
-                                                 unique_ptr<FunctionData> bind_info, bool is_operator)
-    : Expression(ExpressionType::BOUND_FUNCTION, ExpressionClass::BOUND_FUNCTION, std::move(return_type)),
-      function(std::move(bound_function)), children(std::move(arguments)), bind_info(std::move(bind_info)),
-      is_operator(is_operator) {
-	D_ASSERT(!function.name.empty());
-}
-
-bool BoundFunctionExpression::IsVolatile() const {
-	return function.stability == FunctionStability::VOLATILE ? true : Expression::IsVolatile();
-}
-
-bool BoundFunctionExpression::IsConsistent() const {
-	return function.stability != FunctionStability::CONSISTENT ? false : Expression::IsConsistent();
-}
-
-bool BoundFunctionExpression::IsFoldable() const {
-	// functions with side effects cannot be folded: they have to be executed once for every row
-	if (function.bind_lambda) {
-		// This is a lambda function
-		D_ASSERT(bind_info);
-		auto &lambda_bind_data = bind_info->Cast<ListLambdaBindData>();
-		if (lambda_bind_data.lambda_expr) {
-			auto &expr = *lambda_bind_data.lambda_expr;
-			if (expr.IsVolatile()) {
-				return false;
-			}
-		}
-	}
-	return function.stability == FunctionStability::VOLATILE ? false : Expression::IsFoldable();
-}
-
-bool BoundFunctionExpression::CanThrow() const {
-	if (function.errors == FunctionErrors::CAN_THROW_RUNTIME_ERROR) {
-		return true;
-	}
-	return Expression::CanThrow();
-}
-
-string BoundFunctionExpression::ToString() const {
-	return FunctionExpression::ToString<BoundFunctionExpression, Expression>(*this, string(), string(), function.name,
-	                                                                         is_operator);
-}
-bool BoundFunctionExpression::PropagatesNullValues() const {
-	return function.null_handling == FunctionNullHandling::SPECIAL_HANDLING ? false
-	                                                                        : Expression::PropagatesNullValues();
-}
-
-hash_t BoundFunctionExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	return CombineHash(result, function.Hash());
-}
-
-bool BoundFunctionExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundFunctionExpression>();
-	if (other.function != function) {
-		return false;
-	}
-	if (!Expression::ListEquals(children, other.children)) {
-		return false;
-	}
-	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundFunctionExpression::Copy() const {
-	vector<unique_ptr<Expression>> new_children;
-	new_children.reserve(children.size());
-	for (auto &child : children) {
-		new_children.push_back(child->Copy());
-	}
-	unique_ptr<FunctionData> new_bind_info = bind_info ? bind_info->Copy() : nullptr;
-
-	auto copy = make_uniq<BoundFunctionExpression>(return_type, function, std::move(new_children),
-	                                               std::move(new_bind_info), is_operator);
-	copy->CopyProperties(*this);
-	return std::move(copy);
-}
-
-void BoundFunctionExpression::Verify() const {
-	D_ASSERT(!function.name.empty());
-}
-
-void BoundFunctionExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty(200, "return_type", return_type);
-	serializer.WriteProperty(201, "children", children);
-	FunctionSerializer::Serialize(serializer, function, bind_info.get());
-	serializer.WriteProperty(202, "is_operator", is_operator);
-}
-
-unique_ptr<Expression> BoundFunctionExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
-	auto entry = FunctionSerializer::Deserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
-	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children, return_type);
-	auto function_return_type = entry.first.return_type;
-	auto result = make_uniq<BoundFunctionExpression>(std::move(function_return_type), std::move(entry.first),
-	                                                 std::move(children), std::move(entry.second));
-	deserializer.ReadProperty(202, "is_operator", result->is_operator);
-	if (result->return_type != return_type) {
-		// return type mismatch - push a cast
-		auto &context = deserializer.Get<ClientContext &>();
-		return BoundCastExpression::AddCastToType(context, std::move(result), return_type);
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_lambda_expression.cpp b/src/duckdb/src/planner/expression/bound_lambda_expression.cpp
deleted file mode 100644
index 6b88b8f6e..000000000
--- a/src/duckdb/src/planner/expression/bound_lambda_expression.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/planner/expression/bound_lambda_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-BoundLambdaExpression::BoundLambdaExpression(ExpressionType type_p, LogicalType return_type_p,
-                                             unique_ptr<Expression> lambda_expr_p, idx_t parameter_count_p)
-    : Expression(type_p, ExpressionClass::BOUND_LAMBDA, std::move(return_type_p)),
-      lambda_expr(std::move(lambda_expr_p)), parameter_count(parameter_count_p) {
-}
-
-string BoundLambdaExpression::ToString() const {
-	return lambda_expr->ToString();
-}
-
-bool BoundLambdaExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundLambdaExpression>();
-	if (!Expression::Equals(*lambda_expr, *other.lambda_expr)) {
-		return false;
-	}
-	if (!Expression::ListEquals(captures, other.captures)) {
-		return false;
-	}
-	if (parameter_count != other.parameter_count) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundLambdaExpression::Copy() const {
-	auto copy = make_uniq<BoundLambdaExpression>(type, return_type, lambda_expr->Copy(), parameter_count);
-	for (auto &capture : captures) {
-		copy->captures.push_back(capture->Copy());
-	}
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp b/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp
deleted file mode 100644
index e1bc961bd..000000000
--- a/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-BoundLambdaRefExpression::BoundLambdaRefExpression(string alias_p, LogicalType type, ColumnBinding binding,
-                                                   idx_t lambda_idx, idx_t depth)
-    : Expression(ExpressionType::BOUND_LAMBDA_REF, ExpressionClass::BOUND_LAMBDA_REF, std::move(type)),
-      binding(binding), lambda_idx(lambda_idx), depth(depth) {
-	this->alias = std::move(alias_p);
-}
-
-BoundLambdaRefExpression::BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_idx,
-                                                   idx_t depth)
-    : BoundLambdaRefExpression(string(), std::move(type), binding, lambda_idx, depth) {
-}
-
-unique_ptr<Expression> BoundLambdaRefExpression::Copy() const {
-	return make_uniq<BoundLambdaRefExpression>(alias, return_type, binding, lambda_idx, depth);
-}
-
-hash_t BoundLambdaRefExpression::Hash() const {
-	auto result = Expression::Hash();
-	result = CombineHash(result, duckdb::Hash<uint64_t>(lambda_idx));
-	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.column_index));
-	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.table_index));
-	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
-}
-
-bool BoundLambdaRefExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundLambdaRefExpression>();
-	return other.binding == binding && other.lambda_idx == lambda_idx && other.depth == depth;
-}
-
-string BoundLambdaRefExpression::ToString() const {
-	if (!alias.empty()) {
-		return alias;
-	}
-	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "." + to_string(lambda_idx) +
-	       "]";
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_operator_expression.cpp b/src/duckdb/src/planner/expression/bound_operator_expression.cpp
deleted file mode 100644
index 0955ca5bf..000000000
--- a/src/duckdb/src/planner/expression/bound_operator_expression.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-
-namespace duckdb {
-
-BoundOperatorExpression::BoundOperatorExpression(ExpressionType type, LogicalType return_type)
-    : Expression(type, ExpressionClass::BOUND_OPERATOR, std::move(return_type)) {
-}
-
-string BoundOperatorExpression::ToString() const {
-	return OperatorExpression::ToString<BoundOperatorExpression, Expression>(*this);
-}
-
-bool BoundOperatorExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundOperatorExpression>();
-	if (!Expression::ListEquals(children, other.children)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundOperatorExpression::Copy() const {
-	auto copy = make_uniq<BoundOperatorExpression>(type, return_type);
-	copy->CopyProperties(*this);
-	for (auto &child : children) {
-		copy->children.push_back(child->Copy());
-	}
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_parameter_expression.cpp b/src/duckdb/src/planner/expression/bound_parameter_expression.cpp
deleted file mode 100644
index 82ceca2d4..000000000
--- a/src/duckdb/src/planner/expression/bound_parameter_expression.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-
-namespace duckdb {
-
-BoundParameterExpression::BoundParameterExpression(const string &identifier)
-    : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER,
-                 LogicalType(LogicalTypeId::UNKNOWN)),
-      identifier(identifier) {
-}
-
-BoundParameterExpression::BoundParameterExpression(bound_parameter_map_t &global_parameter_set, string identifier,
-                                                   LogicalType return_type,
-                                                   shared_ptr<BoundParameterData> parameter_data)
-    : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER, std::move(return_type)),
-      identifier(std::move(identifier)) {
-	// check if we have already deserialized a parameter with this number
-	auto entry = global_parameter_set.find(this->identifier);
-	if (entry == global_parameter_set.end()) {
-		// we have not - store the entry we deserialized from this parameter expression
-		global_parameter_set[this->identifier] = parameter_data;
-	} else {
-		// we have! use the previously deserialized entry
-		parameter_data = entry->second;
-	}
-	this->parameter_data = std::move(parameter_data);
-}
-
-void BoundParameterExpression::Invalidate(Expression &expr) {
-	if (expr.GetExpressionType() != ExpressionType::VALUE_PARAMETER) {
-		throw InternalException("BoundParameterExpression::Invalidate requires a parameter as input");
-	}
-	auto &bound_parameter = expr.Cast<BoundParameterExpression>();
-	bound_parameter.return_type = LogicalTypeId::SQLNULL;
-	bound_parameter.parameter_data->return_type = LogicalTypeId::INVALID;
-}
-
-void BoundParameterExpression::InvalidateRecursive(Expression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::VALUE_PARAMETER) {
-		Invalidate(expr);
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { InvalidateRecursive(child); });
-}
-
-bool BoundParameterExpression::IsScalar() const {
-	return true;
-}
-bool BoundParameterExpression::HasParameter() const {
-	return true;
-}
-bool BoundParameterExpression::IsFoldable() const {
-	return false;
-}
-
-string BoundParameterExpression::ToString() const {
-	return "$" + identifier;
-}
-
-bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundParameterExpression>();
-	return StringUtil::CIEquals(identifier, other.identifier);
-}
-
-hash_t BoundParameterExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	result = CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
-	return result;
-}
-
-unique_ptr<Expression> BoundParameterExpression::Copy() const {
-	auto result = make_uniq<BoundParameterExpression>(identifier);
-	result->parameter_data = parameter_data;
-	result->return_type = return_type;
-	result->CopyProperties(*this);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_reference_expression.cpp b/src/duckdb/src/planner/expression/bound_reference_expression.cpp
deleted file mode 100644
index fe3912402..000000000
--- a/src/duckdb/src/planner/expression/bound_reference_expression.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-BoundReferenceExpression::BoundReferenceExpression(string alias, LogicalType type, idx_t index)
-    : Expression(ExpressionType::BOUND_REF, ExpressionClass::BOUND_REF, std::move(type)), index(index) {
-	this->alias = std::move(alias);
-}
-BoundReferenceExpression::BoundReferenceExpression(LogicalType type, idx_t index)
-    : BoundReferenceExpression(string(), std::move(type), index) {
-}
-
-string BoundReferenceExpression::ToString() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return "#" + to_string(index);
-	}
-#endif
-	if (!alias.empty()) {
-		return alias;
-	}
-	return "#" + to_string(index);
-}
-
-bool BoundReferenceExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundReferenceExpression>();
-	return other.index == index;
-}
-
-hash_t BoundReferenceExpression::Hash() const {
-	return CombineHash(Expression::Hash(), duckdb::Hash<idx_t>(index));
-}
-
-unique_ptr<Expression> BoundReferenceExpression::Copy() const {
-	return make_uniq<BoundReferenceExpression>(alias, return_type, index);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_subquery_expression.cpp b/src/duckdb/src/planner/expression/bound_subquery_expression.cpp
deleted file mode 100644
index 95c08b98a..000000000
--- a/src/duckdb/src/planner/expression/bound_subquery_expression.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-BoundSubqueryExpression::BoundSubqueryExpression(LogicalType return_type)
-    : Expression(ExpressionType::SUBQUERY, ExpressionClass::BOUND_SUBQUERY, std::move(return_type)) {
-}
-
-string BoundSubqueryExpression::ToString() const {
-	return "SUBQUERY";
-}
-
-bool BoundSubqueryExpression::Equals(const BaseExpression &other_p) const {
-	// equality between bound subqueries not implemented currently
-	return false;
-}
-
-unique_ptr<Expression> BoundSubqueryExpression::Copy() const {
-	throw SerializationException("Cannot copy BoundSubqueryExpression");
-}
-
-bool BoundSubqueryExpression::PropagatesNullValues() const {
-	// TODO this can be optimized further by checking the actual subquery node
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_unnest_expression.cpp b/src/duckdb/src/planner/expression/bound_unnest_expression.cpp
deleted file mode 100644
index 16d83a503..000000000
--- a/src/duckdb/src/planner/expression/bound_unnest_expression.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-BoundUnnestExpression::BoundUnnestExpression(LogicalType return_type)
-    : Expression(ExpressionType::BOUND_UNNEST, ExpressionClass::BOUND_UNNEST, std::move(return_type)) {
-}
-
-bool BoundUnnestExpression::IsFoldable() const {
-	return false;
-}
-
-string BoundUnnestExpression::ToString() const {
-	return "UNNEST(" + child->ToString() + ")";
-}
-
-hash_t BoundUnnestExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	return CombineHash(result, duckdb::Hash("unnest"));
-}
-
-bool BoundUnnestExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundUnnestExpression>();
-	if (!Expression::Equals(*child, *other.child)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundUnnestExpression::Copy() const {
-	auto copy = make_uniq<BoundUnnestExpression>(return_type);
-	copy->child = child->Copy();
-	return std::move(copy);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression/bound_window_expression.cpp b/src/duckdb/src/planner/expression/bound_window_expression.cpp
deleted file mode 100644
index b189b8e6e..000000000
--- a/src/duckdb/src/planner/expression/bound_window_expression.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/function_serialization.hpp"
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-
-namespace duckdb {
-
-BoundWindowExpression::BoundWindowExpression(ExpressionType type, LogicalType return_type,
-                                             unique_ptr<AggregateFunction> aggregate,
-                                             unique_ptr<FunctionData> bind_info)
-    : Expression(type, ExpressionClass::BOUND_WINDOW, std::move(return_type)), aggregate(std::move(aggregate)),
-      bind_info(std::move(bind_info)), ignore_nulls(false), distinct(false) {
-}
-
-string BoundWindowExpression::ToString() const {
-	string function_name = aggregate.get() ? aggregate->name : ExpressionTypeToString(type);
-	return WindowExpression::ToString<BoundWindowExpression, Expression, BoundOrderByNode>(*this, string(),
-	                                                                                       function_name);
-}
-
-bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<BoundWindowExpression>();
-
-	if (ignore_nulls != other.ignore_nulls) {
-		return false;
-	}
-	if (distinct != other.distinct) {
-		return false;
-	}
-	if (start != other.start || end != other.end) {
-		return false;
-	}
-	if (exclude_clause != other.exclude_clause) {
-		return false;
-	}
-
-	// If there are aggregates, check they are equal
-	if (aggregate.get() != other.aggregate.get()) {
-		if (!aggregate || !other.aggregate || *aggregate != *other.aggregate) {
-			return false;
-		}
-	}
-	// If there's function data, check if they are equal
-	if (bind_info.get() != other.bind_info.get()) {
-		if (!bind_info || !other.bind_info || !bind_info->Equals(*other.bind_info)) {
-			return false;
-		}
-	}
-	// check if the child expressions are equivalent
-	if (!Expression::ListEquals(children, other.children)) {
-		return false;
-	}
-	if (!Expression::ListEquals(partitions, other.partitions)) {
-		return false;
-	}
-	// check if the filter expressions are equivalent
-	if (!Expression::Equals(filter_expr, other.filter_expr)) {
-		return false;
-	}
-
-	// check if the argument orderings are equivalent
-	if (arg_orders.size() != other.arg_orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < arg_orders.size(); i++) {
-		if (!arg_orders[i].Equals(other.arg_orders[i])) {
-			return false;
-		}
-	}
-
-	// check if the framing expressions are equivalent
-	if (!Expression::Equals(start_expr, other.start_expr) || !Expression::Equals(end_expr, other.end_expr) ||
-	    !Expression::Equals(offset_expr, other.offset_expr) || !Expression::Equals(default_expr, other.default_expr)) {
-		return false;
-	}
-
-	return KeysAreCompatible(other);
-}
-
-bool BoundWindowExpression::PartitionsAreEquivalent(const BoundWindowExpression &other) const {
-	// Partitions are not order sensitive.
-	if (partitions.size() != other.partitions.size()) {
-		return false;
-	}
-	// TODO: Should partitions be an expression_set_t?
-	expression_set_t others;
-	for (const auto &partition : other.partitions) {
-		others.insert(*partition);
-	}
-	for (const auto &partition : partitions) {
-		if (!others.count(*partition)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-idx_t BoundWindowExpression::GetSharedOrders(const vector<BoundOrderByNode> &lhs, const vector<BoundOrderByNode> &rhs) {
-	const auto overlap = MinValue<idx_t>(lhs.size(), rhs.size());
-
-	idx_t result = 0;
-	for (; result < overlap; ++result) {
-		if (!lhs.at(result).Equals(rhs.at(result))) {
-			return 0;
-		}
-	}
-
-	return result;
-}
-
-idx_t BoundWindowExpression::GetSharedOrders(const BoundWindowExpression &other) const {
-	return GetSharedOrders(orders, other.orders);
-}
-
-bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const {
-	if (!PartitionsAreEquivalent(other)) {
-		return false;
-	}
-	// check if the orderings are equivalent
-	if (orders.size() != other.orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (!orders[i].Equals(other.orders[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundWindowExpression::Copy() const {
-	auto new_window = make_uniq<BoundWindowExpression>(type, return_type, nullptr, nullptr);
-	new_window->CopyProperties(*this);
-
-	if (aggregate) {
-		new_window->aggregate = make_uniq<AggregateFunction>(*aggregate);
-	}
-	if (bind_info) {
-		new_window->bind_info = bind_info->Copy();
-	}
-	for (auto &child : children) {
-		new_window->children.push_back(child->Copy());
-	}
-	for (auto &e : partitions) {
-		new_window->partitions.push_back(e->Copy());
-	}
-	for (auto &ps : partitions_stats) {
-		if (ps) {
-			new_window->partitions_stats.push_back(ps->ToUnique());
-		} else {
-			new_window->partitions_stats.push_back(nullptr);
-		}
-	}
-	for (auto &o : orders) {
-		new_window->orders.emplace_back(o.type, o.null_order, o.expression->Copy());
-	}
-
-	for (auto &o : arg_orders) {
-		new_window->arg_orders.emplace_back(o.type, o.null_order, o.expression->Copy());
-	}
-
-	new_window->filter_expr = filter_expr ? filter_expr->Copy() : nullptr;
-
-	new_window->start = start;
-	new_window->end = end;
-	new_window->exclude_clause = exclude_clause;
-	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
-	new_window->end_expr = end_expr ? end_expr->Copy() : nullptr;
-	new_window->offset_expr = offset_expr ? offset_expr->Copy() : nullptr;
-	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
-	new_window->ignore_nulls = ignore_nulls;
-	new_window->distinct = distinct;
-
-	for (auto &es : expr_stats) {
-		if (es) {
-			new_window->expr_stats.push_back(es->ToUnique());
-		} else {
-			new_window->expr_stats.push_back(nullptr);
-		}
-	}
-	return std::move(new_window);
-}
-
-void BoundWindowExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty(200, "return_type", return_type);
-	serializer.WriteProperty(201, "children", children);
-	if (type == ExpressionType::WINDOW_AGGREGATE) {
-		D_ASSERT(aggregate);
-		FunctionSerializer::Serialize(serializer, *aggregate, bind_info.get());
-	}
-	serializer.WriteProperty(202, "partitions", partitions);
-	serializer.WriteProperty(203, "orders", orders);
-	serializer.WritePropertyWithDefault(204, "filters", filter_expr, unique_ptr<Expression>());
-	serializer.WriteProperty(205, "ignore_nulls", ignore_nulls);
-	serializer.WriteProperty(206, "start", start);
-	serializer.WriteProperty(207, "end", end);
-	serializer.WritePropertyWithDefault(208, "start_expr", start_expr, unique_ptr<Expression>());
-	serializer.WritePropertyWithDefault(209, "end_expr", end_expr, unique_ptr<Expression>());
-	serializer.WritePropertyWithDefault(210, "offset_expr", offset_expr, unique_ptr<Expression>());
-	serializer.WritePropertyWithDefault(211, "default_expr", default_expr, unique_ptr<Expression>());
-	serializer.WriteProperty(212, "exclude_clause", exclude_clause);
-	serializer.WriteProperty(213, "distinct", distinct);
-	serializer.WriteProperty(214, "arg_orders", arg_orders);
-}
-
-unique_ptr<Expression> BoundWindowExpression::Deserialize(Deserializer &deserializer) {
-	auto expression_type = deserializer.Get<ExpressionType>();
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
-	unique_ptr<AggregateFunction> aggregate;
-	unique_ptr<FunctionData> bind_info;
-	if (expression_type == ExpressionType::WINDOW_AGGREGATE) {
-		auto entry = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-		    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, return_type);
-		aggregate = make_uniq<AggregateFunction>(std::move(entry.first));
-		bind_info = std::move(entry.second);
-	}
-	auto result =
-	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
-	result->children = std::move(children);
-	deserializer.ReadProperty(202, "partitions", result->partitions);
-	deserializer.ReadProperty(203, "orders", result->orders);
-	deserializer.ReadPropertyWithExplicitDefault(204, "filters", result->filter_expr, unique_ptr<Expression>());
-	deserializer.ReadProperty(205, "ignore_nulls", result->ignore_nulls);
-	deserializer.ReadProperty(206, "start", result->start);
-	deserializer.ReadProperty(207, "end", result->end);
-	deserializer.ReadPropertyWithExplicitDefault(208, "start_expr", result->start_expr, unique_ptr<Expression>());
-	deserializer.ReadPropertyWithExplicitDefault(209, "end_expr", result->end_expr, unique_ptr<Expression>());
-	deserializer.ReadPropertyWithExplicitDefault(210, "offset_expr", result->offset_expr, unique_ptr<Expression>());
-	deserializer.ReadPropertyWithExplicitDefault(211, "default_expr", result->default_expr, unique_ptr<Expression>());
-	deserializer.ReadProperty(212, "exclude_clause", result->exclude_clause);
-	deserializer.ReadProperty(213, "distinct", result->distinct);
-	deserializer.ReadPropertyWithExplicitDefault(214, "arg_orders", result->arg_orders, vector<BoundOrderByNode>());
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder.cpp b/src/duckdb/src/planner/expression_binder.cpp
deleted file mode 100644
index d09f796b9..000000000
--- a/src/duckdb/src/planner/expression_binder.cpp
+++ /dev/null
@@ -1,401 +0,0 @@
-#include "duckdb/planner/expression_binder.hpp"
-
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/parser/expression/list.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/main/client_config.hpp"
-
-namespace duckdb {
-
-void ExpressionBinder::SetCatalogLookupCallback(catalog_entry_callback_t callback) {
-	binder.SetCatalogLookupCallback(std::move(callback));
-}
-
-ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
-    : binder(binder), context(context) {
-	InitializeStackCheck();
-	if (replace_binder) {
-		stored_binder = &binder.GetActiveBinder();
-		binder.SetActiveBinder(*this);
-	} else {
-		binder.PushExpressionBinder(*this);
-	}
-}
-
-ExpressionBinder::~ExpressionBinder() {
-	if (binder.HasActiveBinder()) {
-		if (stored_binder) {
-			binder.SetActiveBinder(*stored_binder);
-		} else {
-			binder.PopExpressionBinder();
-		}
-	}
-}
-
-void ExpressionBinder::InitializeStackCheck() {
-	static constexpr idx_t INITIAL_DEPTH = 5;
-	if (binder.HasActiveBinder()) {
-		stack_depth = binder.GetActiveBinder().stack_depth + INITIAL_DEPTH;
-	} else {
-		stack_depth = INITIAL_DEPTH;
-	}
-}
-
-StackChecker<ExpressionBinder> ExpressionBinder::StackCheck(const ParsedExpression &expr, idx_t extra_stack) {
-	D_ASSERT(stack_depth != DConstants::INVALID_INDEX);
-	auto &options = ClientConfig::GetConfig(context);
-	if (stack_depth + extra_stack >= options.max_expression_depth) {
-		throw BinderException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
-		                      "increase the maximum expression depth.",
-		                      options.max_expression_depth);
-	}
-	return StackChecker<ExpressionBinder>(*this, extra_stack);
-}
-
-BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
-	auto stack_checker = StackCheck(*expr);
-
-	auto &expr_ref = *expr;
-	switch (expr_ref.GetExpressionClass()) {
-	case ExpressionClass::BETWEEN:
-		return BindExpression(expr_ref.Cast<BetweenExpression>(), depth);
-	case ExpressionClass::CASE:
-		return BindExpression(expr_ref.Cast<CaseExpression>(), depth);
-	case ExpressionClass::CAST:
-		return BindExpression(expr_ref.Cast<CastExpression>(), depth);
-	case ExpressionClass::COLLATE:
-		return BindExpression(expr_ref.Cast<CollateExpression>(), depth);
-	case ExpressionClass::COLUMN_REF:
-		return BindExpression(expr_ref.Cast<ColumnRefExpression>(), depth, root_expression);
-	case ExpressionClass::LAMBDA_REF:
-		return BindExpression(expr_ref.Cast<LambdaRefExpression>(), depth);
-	case ExpressionClass::COMPARISON:
-		return BindExpression(expr_ref.Cast<ComparisonExpression>(), depth);
-	case ExpressionClass::CONJUNCTION:
-		return BindExpression(expr_ref.Cast<ConjunctionExpression>(), depth);
-	case ExpressionClass::CONSTANT:
-		return BindExpression(expr_ref.Cast<ConstantExpression>(), depth);
-	case ExpressionClass::FUNCTION: {
-		auto &function = expr_ref.Cast<FunctionExpression>();
-		if (IsUnnestFunction(function.function_name)) {
-			// special case, not in catalog
-			return BindUnnest(function, depth, root_expression);
-		}
-		// binding a function expression requires an extra parameter for macros
-		return BindExpression(function, depth, expr);
-	}
-	case ExpressionClass::LAMBDA:
-		return BindExpression(expr_ref.Cast<LambdaExpression>(), depth, LogicalTypeId::INVALID, nullptr);
-	case ExpressionClass::OPERATOR:
-		return BindExpression(expr_ref.Cast<OperatorExpression>(), depth);
-	case ExpressionClass::SUBQUERY:
-		return BindExpression(expr_ref.Cast<SubqueryExpression>(), depth);
-	case ExpressionClass::PARAMETER:
-		return BindExpression(expr_ref.Cast<ParameterExpression>(), depth);
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindPositionalReference(expr, depth, root_expression);
-	case ExpressionClass::STAR:
-		return BindResult(BinderException::Unsupported(expr_ref, "STAR expression is not supported here"));
-	default:
-		throw NotImplementedException("Unimplemented expression class");
-	}
-}
-
-static bool CombineMissingColumns(ErrorData &current, ErrorData new_error) {
-	auto &current_info = current.ExtraInfo();
-	auto &new_info = new_error.ExtraInfo();
-	auto current_entry = current_info.find("error_subtype");
-	auto new_entry = new_info.find("error_subtype");
-	if (current_entry == current_info.end() || new_entry == new_info.end()) {
-		// no subtype info in either expression
-		return false;
-	}
-	if (current_entry->second != "COLUMN_NOT_FOUND" || new_entry->second != "COLUMN_NOT_FOUND") {
-		// either info is not a `COLUMN_NOT_FOUND`
-		return false;
-	}
-	current_entry = current_info.find("name");
-	new_entry = new_info.find("name");
-	if (current_entry == current_info.end() || new_entry == new_info.end()) {
-		// no candidate info in either column
-		return false;
-	}
-	if (current_entry->second != new_entry->second) {
-		// error does not concern the same name/column
-		return false;
-	}
-	auto column_name = current_entry->second;
-	current_entry = current_info.find("candidates");
-	new_entry = new_info.find("candidates");
-	if (current_entry == current_info.end()) {
-		// no current candidates - use new candidates
-		current = std::move(new_error);
-		return true;
-	}
-	if (new_entry == new_info.end()) {
-		// no new candidates - use current candidates
-		return true;
-	}
-	// both errors have candidates - combine the candidates
-	auto current_candidates = StringUtil::Split(current_entry->second, ",");
-	auto new_candidates = StringUtil::Split(new_entry->second, ",");
-	current_candidates.insert(current_candidates.end(), new_candidates.begin(), new_candidates.end());
-
-	// run the similarity ranking on both sets of candidates
-	unordered_set<string> candidates;
-	vector<pair<string, double>> scores;
-	for (auto &candidate : current_candidates) {
-		// split by "." since the candidates might be in the form "table.column"
-		auto column_splits = StringUtil::Split(candidate, ".");
-		if (column_splits.empty()) {
-			continue;
-		}
-		auto &candidate_column = column_splits.back();
-		auto entry = candidates.find(candidate);
-		if (entry != candidates.end()) {
-			// already found
-			continue;
-		}
-		auto score = StringUtil::SimilarityRating(candidate_column, column_name);
-		candidates.insert(candidate);
-		scores.emplace_back(make_pair(std::move(candidate), score));
-	}
-	// get a new top-n
-	auto top_candidates = StringUtil::TopNStrings(scores);
-	// get query location
-	QueryErrorContext context;
-	current_entry = current_info.find("position");
-	new_entry = new_info.find("position");
-	uint64_t position;
-	if (current_entry != current_info.end() &&
-	    TryCast::Operation<string_t, uint64_t>(current_entry->second, position)) {
-		context = QueryErrorContext(position);
-	} else if (new_entry != new_info.end() && TryCast::Operation<string_t, uint64_t>(new_entry->second, position)) {
-		context = QueryErrorContext(position);
-	}
-	// generate a new (combined) error
-	current = BinderException::ColumnNotFound(column_name, top_candidates, context);
-	return true;
-}
-
-static void CombineErrors(ErrorData &current, ErrorData new_error) {
-	// try to combine missing column exceptions in order to pick the most relevant one
-	if (CombineMissingColumns(current, new_error)) {
-		// keep the old info
-		return;
-	}
-
-	// override the error with the new one
-	current = std::move(new_error);
-}
-
-BindResult ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr, ErrorData error_message) {
-	// try to bind in one of the outer queries, if the binding error occurred in a subquery
-	auto &active_binders = binder.GetActiveBinders();
-	// make a copy of the set of binders, so we can restore it later
-	auto binders = active_binders;
-	auto bind_error = std::move(error_message);
-	// we already failed with the current binder
-	active_binders.pop_back();
-	idx_t depth = 1;
-	while (!active_binders.empty()) {
-		auto &next_binder = active_binders.back().get();
-		ExpressionBinder::QualifyColumnNames(next_binder.binder, expr);
-		auto next_error = next_binder.Bind(expr, depth);
-		if (!next_error.HasError()) {
-			bind_error = std::move(next_error);
-			break;
-		}
-		CombineErrors(bind_error, std::move(next_error));
-		depth++;
-		active_binders.pop_back();
-	}
-	active_binders = binders;
-	return BindResult(bind_error);
-}
-
-void ExpressionBinder::BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, ErrorData &error) {
-	if (expr) {
-		ErrorData bind_error = Bind(expr, depth);
-		if (!error.HasError()) {
-			error = std::move(bind_error);
-		}
-	}
-}
-
-void ExpressionBinder::ExtractCorrelatedExpressions(Binder &binder, Expression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr.Cast<BoundColumnRefExpression>();
-		if (bound_colref.depth > 0) {
-			binder.AddCorrelatedColumn(CorrelatedColumnInfo(bound_colref));
-		}
-	}
-	ExpressionIterator::EnumerateChildren(expr,
-	                                      [&](Expression &child) { ExtractCorrelatedExpressions(binder, child); });
-}
-
-bool ExpressionBinder::ContainsType(const LogicalType &type, LogicalTypeId target) {
-	if (type.id() == target) {
-		return true;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT: {
-		auto child_count = StructType::GetChildCount(type);
-		for (idx_t i = 0; i < child_count; i++) {
-			if (ContainsType(StructType::GetChildType(type, i), target)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	case LogicalTypeId::UNION: {
-		auto member_count = UnionType::GetMemberCount(type);
-		for (idx_t i = 0; i < member_count; i++) {
-			if (ContainsType(UnionType::GetMemberType(type, i), target)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-		return ContainsType(ListType::GetChildType(type), target);
-	case LogicalTypeId::ARRAY:
-		return ContainsType(ArrayType::GetChildType(type), target);
-	default:
-		return false;
-	}
-}
-
-LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeId target, LogicalType new_type) {
-	if (type.id() == target) {
-		return new_type;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT: {
-		// we make a copy of the child types of the struct here
-		auto child_types = StructType::GetChildTypes(type);
-		for (auto &child_type : child_types) {
-			child_type.second = ExchangeType(child_type.second, target, new_type);
-		}
-		return LogicalType::STRUCT(child_types);
-	}
-	case LogicalTypeId::UNION: {
-		auto member_types = UnionType::CopyMemberTypes(type);
-		for (auto &member_type : member_types) {
-			member_type.second = ExchangeType(member_type.second, target, new_type);
-		}
-		return LogicalType::UNION(std::move(member_types));
-	}
-	case LogicalTypeId::LIST:
-		return LogicalType::LIST(ExchangeType(ListType::GetChildType(type), target, new_type));
-	case LogicalTypeId::MAP:
-		return LogicalType::MAP(ExchangeType(ListType::GetChildType(type), target, new_type));
-	case LogicalTypeId::ARRAY:
-		return LogicalType::ARRAY(ExchangeType(ArrayType::GetChildType(type), target, new_type),
-		                          ArrayType::GetSize(type));
-	default:
-		return type;
-	}
-}
-
-bool ExpressionBinder::ContainsNullType(const LogicalType &type) {
-	return ContainsType(type, LogicalTypeId::SQLNULL);
-}
-
-LogicalType ExpressionBinder::ExchangeNullType(const LogicalType &type) {
-	return ExchangeType(type, LogicalTypeId::SQLNULL, LogicalType::INTEGER);
-}
-
-unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, optional_ptr<LogicalType> result_type,
-                                              bool root_expression) {
-	// bind the main expression
-	auto error_msg = Bind(expr, 0, root_expression);
-	if (error_msg.HasError()) {
-		// Try binding the correlated column. If binding the correlated column
-		// has error messages, those should be propagated up. So for the test case
-		// having subquery failed to bind:14 the real error message should be something like
-		// aggregate with constant input must be bound to a root node.
-		auto result = BindCorrelatedColumns(expr, error_msg);
-		if (result.HasError()) {
-			CombineErrors(error_msg, std::move(result.error));
-			error_msg.Throw();
-		}
-		auto &bound_expr = expr->Cast<BoundExpression>();
-		ExtractCorrelatedExpressions(binder, *bound_expr.expr);
-	}
-	auto &bound_expr = expr->Cast<BoundExpression>();
-	unique_ptr<Expression> result = std::move(bound_expr.expr);
-	if (target_type.id() != LogicalTypeId::INVALID) {
-		// the binder has a specific target type: add a cast to that type
-		result = BoundCastExpression::AddCastToType(context, std::move(result), target_type);
-	} else {
-		if (!binder.can_contain_nulls) {
-			// SQL NULL type is only used internally in the binder
-			// cast to INTEGER if we encounter it outside of the binder
-			if (ContainsNullType(result->return_type)) {
-				auto exchanged_type = ExchangeNullType(result->return_type);
-				result = BoundCastExpression::AddCastToType(context, std::move(result), exchanged_type);
-			}
-		}
-		if (result->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw ParameterNotResolvedException();
-		}
-	}
-	if (result_type) {
-		*result_type = result->return_type;
-	}
-	return result;
-}
-
-ErrorData ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
-	// bind the node, but only if it has not been bound yet
-	auto query_location = expr->GetQueryLocation();
-	auto &expression = *expr;
-	auto alias = expression.GetAlias();
-	if (expression.GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION) {
-		// already bound, don't bind it again
-		return ErrorData();
-	}
-	// bind the expression
-	BindResult result = BindExpression(expr, depth, root_expression);
-	if (result.HasError()) {
-		return std::move(result.error);
-	}
-	// successfully bound: replace the node with a BoundExpression
-	result.expression->SetQueryLocation(query_location);
-	expr = make_uniq<BoundExpression>(std::move(result.expression));
-	auto &be = expr->Cast<BoundExpression>();
-	be.SetAlias(alias);
-	if (!alias.empty()) {
-		be.expr->SetAlias(alias);
-	}
-	return ErrorData();
-}
-
-BindResult ExpressionBinder::BindUnsupportedExpression(ParsedExpression &expr, idx_t depth, const string &message) {
-	// we always prefer to throw an error if it occurs in a child expression
-	// since that error might be more descriptive
-	// bind all children
-	ErrorData result;
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](unique_ptr<ParsedExpression> &child) { BindChild(child, depth, result); });
-	if (result.HasError()) {
-		return BindResult(std::move(result));
-	}
-	return BindResult(BinderException::Unsupported(expr, message));
-}
-
-bool ExpressionBinder::IsUnnestFunction(const string &function_name) {
-	return function_name == "unnest" || function_name == "unlist";
-}
-
-bool ExpressionBinder::TryBindAlias(ColumnRefExpression &colref, bool root_expression, BindResult &result) {
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/aggregate_binder.cpp b/src/duckdb/src/planner/expression_binder/aggregate_binder.cpp
deleted file mode 100644
index b02cbf970..000000000
--- a/src/duckdb/src/planner/expression_binder/aggregate_binder.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-AggregateBinder::AggregateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context, true) {
-}
-
-BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		throw BinderException::Unsupported(expr, "aggregate function calls cannot contain window function calls");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string AggregateBinder::UnsupportedAggregateMessage() {
-	return "aggregate function calls cannot be nested";
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/alter_binder.cpp b/src/duckdb/src/planner/expression_binder/alter_binder.cpp
deleted file mode 100644
index 797e37111..000000000
--- a/src/duckdb/src/planner/expression_binder/alter_binder.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "duckdb/planner/expression_binder/alter_binder.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/table_binding.hpp"
-
-namespace duckdb {
-
-AlterBinder::AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table,
-                         vector<LogicalIndex> &bound_columns, LogicalType target_type)
-    : ExpressionBinder(binder, context), table(table), bound_columns(bound_columns) {
-	this->target_type = std::move(target_type);
-}
-
-BindResult AlterBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) {
-	D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size());
-	auto &lambda_ref = expr.Cast<LambdaRefExpression>();
-	return (*lambda_bindings)[expr.lambda_idx].Bind(lambda_ref, depth);
-}
-
-BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		return BindResult(BinderException::Unsupported(expr, "window functions are not allowed in alter statement"));
-	case ExpressionClass::SUBQUERY:
-		return BindResult(BinderException::Unsupported(expr, "cannot use subquery in alter statement"));
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnReference(expr.Cast<ColumnRefExpression>(), depth);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string AlterBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in alter statement";
-}
-
-BindResult AlterBinder::BindColumnReference(ColumnRefExpression &col_ref, idx_t depth) {
-
-	// try binding as a lambda parameter
-	if (!col_ref.IsQualified()) {
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
-		if (lambda_ref) {
-			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
-		}
-	}
-
-	if (col_ref.column_names.size() > 1) {
-		return BindQualifiedColumnName(col_ref, table.name);
-	}
-
-	auto idx = table.GetColumnIndex(col_ref.column_names[0], true);
-	if (!idx.IsValid()) {
-		throw BinderException("Table does not contain column %s referenced in alter statement!",
-		                      col_ref.column_names[0]);
-	}
-	if (table.GetColumn(idx).Generated()) {
-		throw BinderException("Using generated columns in alter statement not supported");
-	}
-	bound_columns.push_back(idx);
-	return BindResult(make_uniq<BoundReferenceExpression>(table.GetColumn(idx).Type(), bound_columns.size() - 1));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/base_select_binder.cpp b/src/duckdb/src/planner/expression_binder/base_select_binder.cpp
deleted file mode 100644
index e0adf5398..000000000
--- a/src/duckdb/src/planner/expression_binder/base_select_binder.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "duckdb/planner/expression_binder/base_select_binder.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-
-namespace duckdb {
-
-BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node,
-                                   BoundGroupInformation &info)
-    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info) {
-}
-
-BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return BindGroup(expr, depth, group_index);
-	}
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	case ExpressionClass::DEFAULT:
-		return BindResult(BinderException::Unsupported(expr, "SELECT clause cannot contain DEFAULT clause"));
-	case ExpressionClass::WINDOW:
-		return BindWindow(expr.Cast<WindowExpression>(), depth);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth, root_expression);
-	}
-}
-
-idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr) {
-	// first check the group alias map, if expr is a ColumnRefExpression
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		if (!colref.IsQualified()) {
-			auto alias_entry = info.alias_map.find(colref.column_names[0]);
-			if (alias_entry != info.alias_map.end()) {
-				// found entry!
-				return alias_entry->second;
-			}
-		}
-	}
-	// no alias reference found
-	// check the list of group columns for a match
-	auto entry = info.map.find(expr);
-	if (entry != info.map.end()) {
-		return entry->second;
-	}
-#ifdef DEBUG
-	for (auto map_entry : info.map) {
-		D_ASSERT(!map_entry.first.get().Equals(expr));
-		D_ASSERT(!expr.Equals(map_entry.first.get()));
-	}
-#endif
-	return DConstants::INVALID_INDEX;
-}
-
-BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	return ExpressionBinder::BindExpression(expr_ptr, depth);
-}
-
-BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
-	if (op.children.empty()) {
-		throw InternalException("GROUPING requires at least one child");
-	}
-	if (node.groups.group_expressions.empty()) {
-		return BindResult(BinderException(op, "GROUPING statement cannot be used without groups"));
-	}
-	if (op.children.size() >= 64) {
-		return BindResult(BinderException(op, "GROUPING statement cannot have more than 64 groups"));
-	}
-	vector<idx_t> group_indexes;
-	group_indexes.reserve(op.children.size());
-	for (auto &child : op.children) {
-		ExpressionBinder::QualifyColumnNames(binder, child);
-		auto idx = TryBindGroup(*child);
-		if (idx == DConstants::INVALID_INDEX) {
-			return BindResult(BinderException(op, "GROUPING child \"%s\" must be a grouping column", child->GetName()));
-		}
-		group_indexes.push_back(idx);
-	}
-	auto col_idx = node.grouping_functions.size();
-	node.grouping_functions.push_back(std::move(group_indexes));
-	return BindResult(make_uniq<BoundColumnRefExpression>(op.GetName(), LogicalType::BIGINT,
-	                                                      ColumnBinding(node.groupings_index, col_idx), depth));
-}
-
-BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index) {
-	auto it = info.collated_groups.find(group_index);
-	if (it != info.collated_groups.end()) {
-		// This is an implicitly collated group, so we need to refer to the first() aggregate
-		const auto &aggr_index = it->second;
-		auto uncollated_first_expression =
-		    make_uniq<BoundColumnRefExpression>(expr.GetName(), node.aggregates[aggr_index]->return_type,
-		                                        ColumnBinding(node.aggregate_index, aggr_index), depth);
-
-		if (node.groups.grouping_sets.size() <= 1) {
-			// if there are no more than two grouping sets, you can return the uncollated first expression.
-			// "first" meaning the aggreagte function.
-			return BindResult(std::move(uncollated_first_expression));
-		}
-
-		// otherwise we insert a case statement to return NULL when the collated group expression is NULL
-		// otherwise you can return the "first" of the uncollated expression.
-		auto &group = node.groups.group_expressions[group_index];
-		auto collated_group_expression = make_uniq<BoundColumnRefExpression>(
-		    expr.GetName(), group->return_type, ColumnBinding(node.group_index, group_index), depth);
-
-		auto sql_null = make_uniq<BoundConstantExpression>(Value(LogicalType::VARCHAR));
-		auto when_expr = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
-		when_expr->children.push_back(std::move(collated_group_expression));
-		auto then_expr = make_uniq<BoundConstantExpression>(Value(LogicalType::VARCHAR));
-		auto else_expr = std::move(uncollated_first_expression);
-		auto case_expr =
-		    make_uniq<BoundCaseExpression>(std::move(when_expr), std::move(then_expr), std::move(else_expr));
-		return BindResult(std::move(case_expr));
-	} else {
-		auto &group = node.groups.group_expressions[group_index];
-		return BindResult(make_uniq<BoundColumnRefExpression>(expr.GetName(), group->return_type,
-		                                                      ColumnBinding(node.group_index, group_index), depth));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/check_binder.cpp b/src/duckdb/src/planner/expression_binder/check_binder.cpp
deleted file mode 100644
index c89c96ded..000000000
--- a/src/duckdb/src/planner/expression_binder/check_binder.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "duckdb/planner/expression_binder/check_binder.hpp"
-
-#include "duckdb/planner/table_binding.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-namespace duckdb {
-
-CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table_p, const ColumnList &columns,
-                         physical_index_set_t &bound_columns)
-    : ExpressionBinder(binder, context), table(std::move(table_p)), columns(columns), bound_columns(bound_columns) {
-	target_type = LogicalType::INTEGER;
-}
-
-BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		return BindResult("window functions are not allowed in check constraints");
-	case ExpressionClass::SUBQUERY:
-		return BindResult("cannot use subquery in check constraint");
-	case ExpressionClass::COLUMN_REF:
-		return BindCheckColumn(expr.Cast<ColumnRefExpression>());
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string CheckBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in check constraints";
-}
-
-BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref, const string &table_name) {
-	idx_t struct_start = 0;
-	if (colref.column_names[0] == table_name) {
-		struct_start++;
-	}
-	auto result = make_uniq_base<ParsedExpression, ColumnRefExpression>(colref.column_names.back());
-	for (idx_t i = struct_start; i + 1 < colref.column_names.size(); i++) {
-		result = CreateStructExtract(std::move(result), colref.column_names[i]);
-	}
-	return BindExpression(result, 0);
-}
-
-BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
-
-	if (!colref.IsQualified()) {
-		if (lambda_bindings) {
-			for (idx_t i = lambda_bindings->size(); i > 0; i--) {
-				if ((*lambda_bindings)[i - 1].HasMatchingBinding(colref.GetName())) {
-					// FIXME: support lambdas in CHECK constraints
-					// FIXME: like so: return (*lambda_bindings)[i - 1].Bind(colref, i, depth);
-					// FIXME: and move this to LambdaRefExpression::FindMatchingBinding
-					throw NotImplementedException("Lambda functions are currently not supported in CHECK constraints.");
-				}
-			}
-		}
-	}
-
-	if (colref.column_names.size() > 1) {
-		return BindQualifiedColumnName(colref, table);
-	}
-	if (!columns.ColumnExists(colref.column_names[0])) {
-		throw BinderException("Table does not contain column %s referenced in check constraint!",
-		                      colref.column_names[0]);
-	}
-	auto &col = columns.GetColumn(colref.column_names[0]);
-	if (col.Generated()) {
-		auto bound_expression = col.GeneratedExpression().Copy();
-		return BindExpression(bound_expression, 0, false);
-	}
-	bound_columns.insert(col.Physical());
-	D_ASSERT(col.StorageOid() != DConstants::INVALID_INDEX);
-	return BindResult(make_uniq<BoundReferenceExpression>(col.Type(), col.StorageOid()));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/column_alias_binder.cpp b/src/duckdb/src/planner/expression_binder/column_alias_binder.cpp
deleted file mode 100644
index c4477f9e3..000000000
--- a/src/duckdb/src/planner/expression_binder/column_alias_binder.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/planner/expression_binder/column_alias_binder.hpp"
-
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-
-namespace duckdb {
-
-ColumnAliasBinder::ColumnAliasBinder(SelectBindState &bind_state) : bind_state(bind_state), visited_select_indexes() {
-}
-
-bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, unique_ptr<ParsedExpression> &expr_ptr,
-                                  idx_t depth, bool root_expression, BindResult &result) {
-
-	D_ASSERT(expr_ptr->GetExpressionClass() == ExpressionClass::COLUMN_REF);
-	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
-
-	// Qualified columns cannot be aliases.
-	if (expr.IsQualified()) {
-		return false;
-	}
-
-	// We try to find the alias in the alias_map and return false, if no alias exists.
-	auto alias_entry = bind_state.alias_map.find(expr.column_names[0]);
-	if (alias_entry == bind_state.alias_map.end()) {
-		return false;
-	}
-
-	if (visited_select_indexes.find(alias_entry->second) != visited_select_indexes.end()) {
-		// self-referential alias cannot be resolved
-		return false;
-	}
-
-	// We found an alias, so we copy the alias expression into this expression.
-	auto original_expr = bind_state.BindAlias(alias_entry->second);
-	expr_ptr = std::move(original_expr);
-	visited_select_indexes.insert(alias_entry->second);
-
-	result = enclosing_binder.BindExpression(expr_ptr, depth, root_expression);
-	visited_select_indexes.erase(alias_entry->second);
-	return true;
-}
-
-bool ColumnAliasBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
-	if (!colref.IsQualified()) {
-		return bind_state.alias_map.find(colref.column_names[0]) != bind_state.alias_map.end();
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/constant_binder.cpp b/src/duckdb/src/planner/expression_binder/constant_binder.cpp
deleted file mode 100644
index 97a65ba31..000000000
--- a/src/duckdb/src/planner/expression_binder/constant_binder.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-
-namespace duckdb {
-
-ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string clause)
-    : ExpressionBinder(binder, context), clause(std::move(clause)) {
-}
-
-BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF: {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		if (!colref.IsQualified()) {
-			auto value_function = GetSQLValueFunction(colref.GetColumnName());
-			if (value_function) {
-				expr_ptr = std::move(value_function);
-				return BindExpression(expr_ptr, depth, root_expression);
-			}
-		}
-		return BindUnsupportedExpression(expr, depth, clause + " cannot contain column names");
-	}
-	case ExpressionClass::SUBQUERY:
-		throw BinderException(clause + " cannot contain subqueries");
-	case ExpressionClass::DEFAULT:
-		return BindUnsupportedExpression(expr, depth, clause + " cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindUnsupportedExpression(expr, depth, clause + " cannot contain window functions!");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string ConstantBinder::UnsupportedAggregateMessage() {
-	return clause + " cannot contain aggregates!";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/group_binder.cpp b/src/duckdb/src/planner/expression_binder/group_binder.cpp
deleted file mode 100644
index cdec41e15..000000000
--- a/src/duckdb/src/planner/expression_binder/group_binder.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "duckdb/planner/expression_binder/group_binder.hpp"
-
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-#include "duckdb/common/to_string.hpp"
-
-namespace duckdb {
-
-GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-                         SelectBindState &bind_state, case_insensitive_map_t<idx_t> &group_alias_map)
-    : ExpressionBinder(binder, context), node(node), bind_state(bind_state), group_alias_map(group_alias_map),
-      group_index(group_index) {
-}
-
-BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	if (root_expression && depth == 0) {
-		switch (expr.GetExpressionClass()) {
-		case ExpressionClass::COLUMN_REF:
-			return BindColumnRef(expr.Cast<ColumnRefExpression>());
-		case ExpressionClass::CONSTANT:
-			return BindConstant(expr.Cast<ConstantExpression>());
-		case ExpressionClass::PARAMETER:
-			throw ParameterNotAllowedException("Parameter not supported in GROUP BY clause");
-		default:
-			break;
-		}
-	}
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::DEFAULT:
-		return BindUnsupportedExpression(expr, depth, "GROUP BY clause cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindUnsupportedExpression(expr, depth, "GROUP BY clause cannot contain window functions!");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string GroupBinder::UnsupportedAggregateMessage() {
-	return "GROUP BY clause cannot contain aggregates!";
-}
-
-BindResult GroupBinder::BindSelectRef(idx_t entry) {
-	if (used_aliases.find(entry) != used_aliases.end()) {
-		// the alias has already been bound to before!
-		// this happens if we group on the same alias twice
-		// e.g. GROUP BY k, k or GROUP BY 1, 1
-		// in this case, we can just replace the grouping with a constant since the second grouping has no effect
-		// (the constant grouping will be optimized out later)
-		return BindResult(make_uniq<BoundConstantExpression>(Value::INTEGER(42)));
-	}
-	if (entry >= node.select_list.size()) {
-		throw BinderException("GROUP BY term out of range - should be between 1 and %d", (int)node.select_list.size());
-	}
-	// we replace the root expression, also replace the unbound expression
-	unbound_expression = node.select_list[entry]->Copy();
-	// move the expression that this refers to here and bind it
-	auto select_entry = std::move(node.select_list[entry]);
-	auto binding = Bind(select_entry, nullptr, false);
-	// now replace the original expression in the select list with a reference to this group
-	group_alias_map[to_string(entry)] = bind_index;
-	node.select_list[entry] = make_uniq<ColumnRefExpression>(to_string(entry));
-	// insert into the set of used aliases
-	used_aliases.insert(entry);
-	return BindResult(std::move(binding));
-}
-
-BindResult GroupBinder::BindConstant(ConstantExpression &constant) {
-	// constant as root expression
-	if (!constant.value.type().IsIntegral()) {
-		// non-integral expression, we just leave the constant here.
-		return ExpressionBinder::BindExpression(constant, 0);
-	}
-	// INTEGER constant: we use the integer as an index into the select list (e.g. GROUP BY 1)
-	auto index = (idx_t)constant.value.GetValue<int64_t>();
-	return BindSelectRef(index - 1);
-}
-
-bool GroupBinder::TryBindAlias(ColumnRefExpression &colref, bool root_expression, BindResult &result) {
-	// failed to bind the column and the node is the root expression with depth = 0
-	// check if refers to an alias in the select clause
-	auto &alias_name = colref.GetColumnName();
-	auto entry = bind_state.alias_map.find(alias_name);
-	if (entry == bind_state.alias_map.end()) {
-		// no matching alias found
-		return false;
-	}
-	if (!root_expression) {
-		result = BindResult(BinderException(
-		    colref,
-		    "Alias with name \"%s\" exists, but aliases cannot be used as part of an expression in the GROUP BY",
-		    alias_name));
-		return true;
-	}
-	result = BindResult(BindSelectRef(entry->second));
-	if (!result.HasError()) {
-		group_alias_map[alias_name] = bind_index;
-	}
-	return true;
-}
-
-BindResult GroupBinder::BindColumnRef(ColumnRefExpression &colref) {
-	// columns in GROUP BY clauses:
-	// FIRST refer to the original tables, and
-	// THEN if no match is found refer to aliases in the SELECT list
-	// THEN if no match is found, refer to outer queries
-
-	// first try to bind to the base columns (original tables)
-	return ExpressionBinder::BindExpression(colref, 0, true);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/having_binder.cpp b/src/duckdb/src/planner/expression_binder/having_binder.cpp
deleted file mode 100644
index 6f0c96a06..000000000
--- a/src/duckdb/src/planner/expression_binder/having_binder.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "duckdb/planner/expression_binder/having_binder.hpp"
-
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                           AggregateHandling aggregate_handling)
-    : BaseSelectBinder(binder, context, node, info), column_alias_binder(node.bind_state),
-      aggregate_handling(aggregate_handling) {
-	target_type = LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-BindResult HavingBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) {
-	D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size());
-	auto &lambda_ref = expr.Cast<LambdaRefExpression>();
-	return (*lambda_bindings)[expr.lambda_idx].Bind(lambda_ref, depth);
-}
-
-unique_ptr<ParsedExpression> HavingBinder::QualifyColumnName(ColumnRefExpression &colref, ErrorData &error) {
-	auto qualified_colref = ExpressionBinder::QualifyColumnName(colref, error);
-	if (!qualified_colref) {
-		return nullptr;
-	}
-
-	auto group_index = TryBindGroup(*qualified_colref);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return qualified_colref;
-	}
-	if (column_alias_binder.QualifyColumnAlias(colref)) {
-		return nullptr;
-	}
-	return qualified_colref;
-}
-
-BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-
-	// Keep the original column name to return a meaningful error message.
-	auto col_ref = expr_ptr->Cast<ColumnRefExpression>();
-	const auto &column_name = col_ref.GetColumnName();
-
-	// Try binding as a lambda parameter
-	if (!col_ref.IsQualified()) {
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
-		if (lambda_ref) {
-			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
-		}
-		// column was not found - check if it is a SQL value function
-		auto value_function = GetSQLValueFunction(col_ref.GetColumnName());
-		if (value_function) {
-			return BindExpression(value_function, depth);
-		}
-	}
-
-	// Bind the alias.
-	BindResult alias_result;
-	auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
-	if (found_alias) {
-		if (depth > 0) {
-			throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery", column_name);
-		}
-		return alias_result;
-	}
-
-	if (aggregate_handling != AggregateHandling::FORCE_AGGREGATES) {
-		return BindResult(StringUtil::Format(
-		    "column %s must appear in the GROUP BY clause or be used in an aggregate function", column_name));
-	}
-
-	if (depth > 0) {
-		throw BinderException("Having clause cannot reference column \"%s\" in correlated subquery and group by all",
-		                      column_name);
-	}
-
-	auto expr = duckdb::BaseSelectBinder::BindColumnRef(expr_ptr, depth, root_expression);
-	if (expr.HasError()) {
-		return expr;
-	}
-
-	// Return a GROUP BY column reference expression.
-	auto return_type = expr.expression->return_type;
-	auto column_binding = ColumnBinding(node.group_index, node.groups.group_expressions.size());
-	auto group_ref = make_uniq<BoundColumnRefExpression>(return_type, column_binding);
-	node.groups.group_expressions.push_back(std::move(expr.expression));
-	return BindResult(std::move(group_ref));
-}
-
-BindResult HavingBinder::BindWindow(WindowExpression &expr, idx_t depth) {
-	return BindResult(BinderException::Unsupported(expr, "HAVING clause cannot contain window functions!"));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/index_binder.cpp b/src/duckdb/src/planner/expression_binder/index_binder.cpp
deleted file mode 100644
index 950edb6e6..000000000
--- a/src/duckdb/src/planner/expression_binder/index_binder.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/planner/expression_binder/index_binder.hpp"
-
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/execution/index/unbound_index.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/planner/operator/logical_create_index.hpp"
-
-namespace duckdb {
-
-IndexBinder::IndexBinder(Binder &binder, ClientContext &context, optional_ptr<TableCatalogEntry> table,
-                         optional_ptr<CreateIndexInfo> info)
-    : ExpressionBinder(binder, context), table(table), info(info) {
-}
-
-unique_ptr<BoundIndex> IndexBinder::BindIndex(const UnboundIndex &unbound_index) {
-	auto &index_type_name = unbound_index.GetIndexType();
-	// Do we know the type of this index now?
-	auto index_type = context.db->config.GetIndexTypes().FindByName(index_type_name);
-	if (!index_type) {
-		throw MissingExtensionException("Cannot bind index '%s', unknown index type '%s'. You need to load the "
-		                                "extension that provides this index type before table '%s' can be modified.",
-		                                unbound_index.GetTableName(), index_type_name, unbound_index.GetTableName());
-	}
-
-	auto &create_info = unbound_index.GetCreateInfo();
-	auto &storage_info = unbound_index.GetStorageInfo();
-	auto &parsed_expressions = unbound_index.GetParsedExpressions();
-
-	// bind the parsed expressions to create unbound expressions
-	vector<unique_ptr<Expression>> unbound_expressions;
-	unbound_expressions.reserve(parsed_expressions.size());
-	for (auto &expr : parsed_expressions) {
-		auto copy = expr->Copy();
-		unbound_expressions.push_back(Bind(copy));
-	}
-
-	CreateIndexInput input(unbound_index.table_io_manager, unbound_index.db, create_info.constraint_type,
-	                       create_info.index_name, create_info.column_ids, unbound_expressions, storage_info,
-	                       create_info.options);
-
-	return index_type->create_instance(input);
-}
-
-void IndexBinder::InitCreateIndexInfo(LogicalGet &get, CreateIndexInfo &info, const string &schema) {
-	auto &column_ids = get.GetColumnIds();
-	for (auto &column_id : column_ids) {
-		if (column_id.IsRowIdColumn()) {
-			throw BinderException("cannot create an index on the rowid");
-		}
-		auto col_id = column_id.GetPrimaryIndex();
-		info.column_ids.push_back(col_id);
-		info.scan_types.push_back(get.returned_types[col_id]);
-	}
-
-	info.scan_types.emplace_back(LogicalType::ROW_TYPE);
-	info.names = get.names;
-	info.schema = schema;
-	get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID);
-}
-
-unique_ptr<LogicalOperator> IndexBinder::BindCreateIndex(ClientContext &context,
-                                                         unique_ptr<CreateIndexInfo> create_index_info,
-                                                         TableCatalogEntry &table_entry,
-                                                         unique_ptr<LogicalOperator> plan,
-                                                         unique_ptr<AlterTableInfo> alter_table_info) {
-	// Add the dependencies.
-	auto &dependencies = create_index_info->dependencies;
-	auto &catalog = Catalog::GetCatalog(context, create_index_info->catalog);
-	SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) {
-		if (&catalog != &entry.ParentCatalog()) {
-			return;
-		}
-		dependencies.AddDependency(entry);
-	});
-
-	// Bind the index expressions.
-	vector<unique_ptr<Expression>> expressions;
-	for (auto &expr : create_index_info->expressions) {
-		expressions.push_back(Bind(expr));
-	}
-
-	auto &get = plan->Cast<LogicalGet>();
-	InitCreateIndexInfo(get, *create_index_info, table_entry.schema.name);
-	auto &bind_data = get.bind_data->Cast<TableScanBindData>();
-	bind_data.is_create_index = true;
-
-	auto result = make_uniq<LogicalCreateIndex>(std::move(create_index_info), std::move(expressions), table_entry,
-	                                            std::move(alter_table_info));
-	result->children.push_back(std::move(plan));
-	return std::move(result);
-}
-
-BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		return BindResult(BinderException::Unsupported(expr, "window functions are not allowed in index expressions"));
-	case ExpressionClass::SUBQUERY:
-		return BindResult(BinderException::Unsupported(expr, "cannot use subquery in index expressions"));
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string IndexBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in index expressions";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/insert_binder.cpp b/src/duckdb/src/planner/expression_binder/insert_binder.cpp
deleted file mode 100644
index 6b7d74502..000000000
--- a/src/duckdb/src/planner/expression_binder/insert_binder.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/planner/expression_binder/insert_binder.hpp"
-
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-
-namespace duckdb {
-
-InsertBinder::InsertBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult InsertBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::DEFAULT:
-		return BindResult(BinderException::Unsupported(expr, "DEFAULT is not allowed here!"));
-	case ExpressionClass::WINDOW:
-		return BindResult(BinderException::Unsupported(expr, "INSERT statement cannot contain window functions!"));
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string InsertBinder::UnsupportedAggregateMessage() {
-	return "INSERT statement cannot contain aggregates!";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/lateral_binder.cpp b/src/duckdb/src/planner/expression_binder/lateral_binder.cpp
deleted file mode 100644
index 205b644e8..000000000
--- a/src/duckdb/src/planner/expression_binder/lateral_binder.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-#include "duckdb/planner/expression_binder/lateral_binder.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-
-namespace duckdb {
-
-LateralBinder::LateralBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-void LateralBinder::ExtractCorrelatedColumns(Expression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr.Cast<BoundColumnRefExpression>();
-		if (bound_colref.depth > 0) {
-			// add the correlated column info
-			CorrelatedColumnInfo info(bound_colref);
-			if (std::find(correlated_columns.begin(), correlated_columns.end(), info) == correlated_columns.end()) {
-				correlated_columns.push_back(std::move(info));
-			}
-		}
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractCorrelatedColumns(child); });
-}
-
-BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	if (depth == 0) {
-		throw InternalException("Lateral binder can only bind correlated columns");
-	}
-	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
-	if (result.HasError()) {
-		return result;
-	}
-	ExtractCorrelatedColumns(*result.expression);
-	return result;
-}
-
-BindResult LateralBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::DEFAULT:
-		return BindUnsupportedExpression(expr, depth, "LATERAL join cannot contain DEFAULT clause!");
-	case ExpressionClass::WINDOW:
-		return BindUnsupportedExpression(expr, depth, "LATERAL join cannot contain window functions!");
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string LateralBinder::UnsupportedAggregateMessage() {
-	return "LATERAL join cannot contain aggregates!";
-}
-
-static void ReduceColumnRefDepth(BoundColumnRefExpression &expr,
-                                 const vector<CorrelatedColumnInfo> &correlated_columns) {
-	// don't need to reduce this
-	if (expr.depth == 0) {
-		return;
-	}
-	for (auto &correlated : correlated_columns) {
-		if (correlated.binding == expr.binding) {
-			D_ASSERT(expr.depth > 1);
-			expr.depth--;
-			break;
-		}
-	}
-}
-
-static void ReduceColumnDepth(vector<CorrelatedColumnInfo> &columns,
-                              const vector<CorrelatedColumnInfo> &affected_columns) {
-	for (auto &s_correlated : columns) {
-		for (auto &affected : affected_columns) {
-			if (affected == s_correlated) {
-				s_correlated.depth--;
-				break;
-			}
-		}
-	}
-}
-
-class ExpressionDepthReducerRecursive : public BoundNodeVisitor {
-public:
-	explicit ExpressionDepthReducerRecursive(const vector<CorrelatedColumnInfo> &correlated)
-	    : correlated_columns(correlated) {
-	}
-
-	void VisitExpression(unique_ptr<Expression> &expression) override {
-		if (expression->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			ReduceColumnRefDepth(expression->Cast<BoundColumnRefExpression>(), correlated_columns);
-		} else if (expression->GetExpressionType() == ExpressionType::SUBQUERY) {
-			ReduceExpressionSubquery(expression->Cast<BoundSubqueryExpression>(), correlated_columns);
-		}
-		BoundNodeVisitor::VisitExpression(expression);
-	}
-
-	void VisitBoundTableRef(BoundTableRef &ref) override {
-		if (ref.type == TableReferenceType::JOIN) {
-			// rewrite correlated columns in child joins
-			auto &bound_join = ref.Cast<BoundJoinRef>();
-			ReduceColumnDepth(bound_join.correlated_columns, correlated_columns);
-		}
-		// visit the children of the table ref
-		BoundNodeVisitor::VisitBoundTableRef(ref);
-	}
-
-	static void ReduceExpressionSubquery(BoundSubqueryExpression &expr,
-	                                     const vector<CorrelatedColumnInfo> &correlated_columns) {
-		ReduceColumnDepth(expr.binder->correlated_columns, correlated_columns);
-		ExpressionDepthReducerRecursive recursive(correlated_columns);
-		recursive.VisitBoundQueryNode(*expr.subquery);
-	}
-
-private:
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-};
-
-class ExpressionDepthReducer : public LogicalOperatorVisitor {
-public:
-	explicit ExpressionDepthReducer(const vector<CorrelatedColumnInfo> &correlated) : correlated_columns(correlated) {
-	}
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		ReduceColumnRefDepth(expr, correlated_columns);
-		return nullptr;
-	}
-
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		ExpressionDepthReducerRecursive::ReduceExpressionSubquery(expr, correlated_columns);
-		return nullptr;
-	}
-
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-};
-
-void LateralBinder::ReduceExpressionDepth(LogicalOperator &op, const vector<CorrelatedColumnInfo> &correlated) {
-	ExpressionDepthReducer depth_reducer(correlated);
-	depth_reducer.VisitOperator(op);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/order_binder.cpp b/src/duckdb/src/planner/expression_binder/order_binder.cpp
deleted file mode 100644
index af78102b8..000000000
--- a/src/duckdb/src/planner/expression_binder/order_binder.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-#include "duckdb/planner/expression_binder/order_binder.hpp"
-
-#include "duckdb/parser/expression/collate_expression.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-#include "duckdb/main/client_config.hpp"
-#include "duckdb/common/pair.hpp"
-
-namespace duckdb {
-
-OrderBinder::OrderBinder(vector<reference<Binder>> binders, SelectBindState &bind_state)
-    : binders(std::move(binders)), extra_list(nullptr), bind_state(bind_state) {
-}
-OrderBinder::OrderBinder(vector<reference<Binder>> binders, SelectNode &node, SelectBindState &bind_state)
-    : binders(std::move(binders)), bind_state(bind_state) {
-	this->extra_list = &node.select_list;
-}
-
-unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &expr, const idx_t index) {
-	string alias;
-	if (extra_list && index < extra_list->size()) {
-		alias = extra_list->at(index)->ToString();
-	} else {
-		if (!expr.GetAlias().empty()) {
-			alias = expr.GetAlias();
-		}
-	}
-	auto result = make_uniq<BoundConstantExpression>(Value::UBIGINT(index));
-	result->SetAlias(std::move(alias));
-	result->SetQueryLocation(expr.GetQueryLocation());
-	return std::move(result);
-}
-
-unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpression> expr) {
-	if (!extra_list) {
-		throw InternalException("CreateExtraReference called without extra_list");
-	}
-	bind_state.projection_map[*expr] = extra_list->size();
-	auto result = CreateProjectionReference(*expr, extra_list->size());
-	extra_list->push_back(std::move(expr));
-	return result;
-}
-
-optional_idx OrderBinder::TryGetProjectionReference(ParsedExpression &expr) const {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::CONSTANT: {
-		auto &constant = expr.Cast<ConstantExpression>();
-		// ORDER BY a constant
-		if (!constant.value.type().IsIntegral()) {
-			// non-integral expression
-			// ORDER BY <constant> has no effect
-			// this is disabled by default (matching Postgres) - but we can control this with a setting
-			auto &config = ClientConfig::GetConfig(binders[0].get().context);
-			if (!config.order_by_non_integer_literal) {
-				throw BinderException(expr,
-				                      "%s non-integer literal has no effect.\n* SET "
-				                      "order_by_non_integer_literal=true to allow this behavior.",
-				                      query_component);
-			}
-			break;
-		}
-		// INTEGER constant: we use the integer as an index into the select list (e.g. ORDER BY 1)
-		auto order_value = constant.value.GetValue<int64_t>();
-		return static_cast<idx_t>(order_value <= 0 ? NumericLimits<int64_t>::Maximum() : order_value - 1);
-	}
-	case ExpressionClass::COLUMN_REF: {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		// if there is an explicit table name we can't bind to an alias
-		if (colref.IsQualified()) {
-			break;
-		}
-		// check the alias list
-		auto entry = bind_state.alias_map.find(colref.column_names[0]);
-		if (entry == bind_state.alias_map.end()) {
-			break;
-		}
-		// this is an alias - return the index
-		return entry->second;
-	}
-	case ExpressionClass::POSITIONAL_REFERENCE: {
-		auto &posref = expr.Cast<PositionalReferenceExpression>();
-		return posref.index - 1;
-	}
-	default:
-		break;
-	}
-	return optional_idx();
-}
-
-void OrderBinder::SetQueryComponent(string component) {
-	if (component.empty()) {
-		query_component = "ORDER BY";
-	} else {
-		query_component = std::move(component);
-	}
-}
-
-unique_ptr<Expression> OrderBinder::BindConstant(ParsedExpression &expr) {
-	auto index = TryGetProjectionReference(expr);
-	if (!index.IsValid()) {
-		return nullptr;
-	}
-	child_list_t<Value> values;
-	values.push_back(make_pair("index", Value::UBIGINT(index.GetIndex())));
-	auto result = make_uniq<BoundConstantExpression>(Value::STRUCT(std::move(values)));
-	result->SetAlias(expr.GetAlias());
-	result->SetQueryLocation(expr.GetQueryLocation());
-	return std::move(result);
-}
-
-unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
-	// in the ORDER BY clause we do not bind children
-	// we bind ONLY to the select list
-	// if there is no matching entry in the SELECT list already, we add the expression to the SELECT list and refer the
-	// new expression the new entry will then be bound later during the binding of the SELECT list we also don't do type
-	// resolution here: this only happens after the SELECT list has been bound
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::CONSTANT: {
-		// ORDER BY constant
-		// is the ORDER BY expression a constant integer? (e.g. ORDER BY 1)
-		return BindConstant(*expr);
-	}
-	case ExpressionClass::COLUMN_REF:
-	case ExpressionClass::POSITIONAL_REFERENCE: {
-		// COLUMN REF expression
-		// check if we can bind it to an alias in the select list
-		auto index = TryGetProjectionReference(*expr);
-		if (index.IsValid()) {
-			return CreateProjectionReference(*expr, index.GetIndex());
-		}
-		break;
-	}
-	case ExpressionClass::PARAMETER: {
-		throw ParameterNotAllowedException("Parameter not supported in %s clause", query_component);
-	}
-	case ExpressionClass::COLLATE: {
-		auto &collation = expr->Cast<CollateExpression>();
-		auto collation_index = TryGetProjectionReference(*collation.child);
-		if (collation_index.IsValid()) {
-			child_list_t<Value> values;
-			values.push_back(make_pair("index", Value::UBIGINT(collation_index.GetIndex())));
-			values.push_back(make_pair("collation", Value(std::move(collation.collation))));
-			return make_uniq<BoundConstantExpression>(Value::STRUCT(std::move(values)));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-	// general case
-	// first bind the table names of this entry
-	for (auto &binder : binders) {
-		ExpressionBinder::QualifyColumnNames(binder.get(), expr);
-	}
-	// first check if the ORDER BY clause already points to an entry in the projection list
-	auto entry = bind_state.projection_map.find(*expr);
-	if (entry != bind_state.projection_map.end()) {
-		if (entry->second == DConstants::INVALID_INDEX) {
-			throw BinderException("Ambiguous reference to column");
-		}
-		// there is a matching entry in the projection list
-		// just point to that entry
-		return CreateProjectionReference(*expr, entry->second);
-	}
-	if (!extra_list) {
-		// no extra list specified: we cannot push an extra ORDER BY clause
-		throw BinderException("Could not ORDER BY column \"%s\": add the expression/function to every SELECT, or move "
-		                      "the UNION into a FROM clause.",
-		                      expr->ToString());
-	}
-	// otherwise we need to push the ORDER BY entry into the select list
-	return CreateExtraReference(std::move(expr));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/qualify_binder.cpp b/src/duckdb/src/planner/expression_binder/qualify_binder.cpp
deleted file mode 100644
index 7b251a52d..000000000
--- a/src/duckdb/src/planner/expression_binder/qualify_binder.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/planner/expression_binder/qualify_binder.hpp"
-
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-
-namespace duckdb {
-
-QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info)
-    : BaseSelectBinder(binder, context, node, info), column_alias_binder(node.bind_state) {
-	target_type = LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto result = duckdb::BaseSelectBinder::BindColumnRef(expr_ptr, depth, root_expression);
-	if (!result.HasError()) {
-		return result;
-	}
-
-	// Keep the original column reference's string to return a meaningful error message.
-	auto expr_string = expr_ptr->Cast<ColumnRefExpression>().ToString();
-
-	// Try to bind as an alias.
-	BindResult alias_result;
-	auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
-	if (found_alias) {
-		return alias_result;
-	}
-
-	return BindResult(BinderException(
-	    *expr_ptr, "Referenced column %s not found in FROM clause and can't find in alias map.", expr_string));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/relation_binder.cpp b/src/duckdb/src/planner/expression_binder/relation_binder.cpp
deleted file mode 100644
index 10a0516cf..000000000
--- a/src/duckdb/src/planner/expression_binder/relation_binder.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/planner/expression_binder/relation_binder.hpp"
-
-namespace duckdb {
-
-RelationBinder::RelationBinder(Binder &binder, ClientContext &context, string op)
-    : ExpressionBinder(binder, context), op(std::move(op)) {
-}
-
-BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::AGGREGATE:
-		return BindResult(BinderException::Unsupported(expr, "aggregate functions are not allowed in " + op));
-	case ExpressionClass::DEFAULT:
-		return BindResult(BinderException::Unsupported(expr, op + " cannot contain DEFAULT clause"));
-	case ExpressionClass::SUBQUERY:
-		return BindResult(BinderException::Unsupported(expr, "subqueries are not allowed in " + op));
-	case ExpressionClass::WINDOW:
-		return BindResult(BinderException::Unsupported(expr, "window functions are not allowed in " + op));
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string RelationBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in " + op;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/returning_binder.cpp b/src/duckdb/src/planner/expression_binder/returning_binder.cpp
deleted file mode 100644
index 684bebc53..000000000
--- a/src/duckdb/src/planner/expression_binder/returning_binder.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/planner/expression_binder/returning_binder.hpp"
-
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-
-namespace duckdb {
-
-ReturningBinder::ReturningBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::SUBQUERY:
-		return BindResult(BinderException::Unsupported(expr, "SUBQUERY is not supported in returning statements"));
-	case ExpressionClass::BOUND_SUBQUERY:
-		return BindResult(
-		    BinderException::Unsupported(expr, "BOUND SUBQUERY is not supported in returning statements"));
-	case ExpressionClass::COLUMN_REF:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/select_bind_state.cpp b/src/duckdb/src/planner/expression_binder/select_bind_state.cpp
deleted file mode 100644
index dbdbcf0ff..000000000
--- a/src/duckdb/src/planner/expression_binder/select_bind_state.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> SelectBindState::BindAlias(idx_t index) {
-	if (volatile_expressions.find(index) != volatile_expressions.end()) {
-		throw BinderException("Alias \"%s\" referenced - but the expression has side "
-		                      "effects. This is not yet supported.",
-		                      original_expressions[index]->GetAlias());
-	}
-	referenced_aliases.insert(index);
-	return original_expressions[index]->Copy();
-}
-
-void SelectBindState::SetExpressionIsVolatile(idx_t index) {
-	// check if this expression has been referenced before
-	if (referenced_aliases.find(index) != referenced_aliases.end()) {
-		throw BinderException("Alias \"%s\" referenced - but the expression has side "
-		                      "effects. This is not yet supported.",
-		                      original_expressions[index]->GetAlias());
-	}
-	volatile_expressions.insert(index);
-}
-
-void SelectBindState::SetExpressionHasSubquery(idx_t index) {
-	subquery_expressions.insert(index);
-}
-
-bool SelectBindState::AliasHasSubquery(idx_t index) const {
-	return subquery_expressions.find(index) != subquery_expressions.end();
-}
-
-void SelectBindState::AddExpandedColumn(idx_t expand_count) {
-	if (expanded_column_indices.empty()) {
-		expanded_column_indices.push_back(0);
-	}
-	expanded_column_indices.push_back(expanded_column_indices.back() + expand_count);
-}
-
-void SelectBindState::AddRegularColumn() {
-	AddExpandedColumn(1);
-}
-
-idx_t SelectBindState::GetFinalIndex(idx_t index) const {
-	if (index >= expanded_column_indices.size()) {
-		return index;
-	}
-	return expanded_column_indices[index];
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/select_binder.cpp b/src/duckdb/src/planner/expression_binder/select_binder.cpp
deleted file mode 100644
index aab666a47..000000000
--- a/src/duckdb/src/planner/expression_binder/select_binder.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "duckdb/planner/expression_binder/select_binder.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-
-namespace duckdb {
-
-SelectBinder::SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info)
-    : BaseSelectBinder(binder, context, node, info) {
-}
-
-unique_ptr<ParsedExpression> SelectBinder::GetSQLValueFunction(const string &column_name) {
-	auto alias_entry = node.bind_state.alias_map.find(column_name);
-	if (alias_entry != node.bind_state.alias_map.end()) {
-		// don't replace SQL value functions if they are in the alias map
-		return nullptr;
-	}
-	return ExpressionBinder::GetSQLValueFunction(column_name);
-}
-
-BindResult SelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	// first try to bind the column reference regularly
-	auto result = BaseSelectBinder::BindColumnRef(expr_ptr, depth, root_expression);
-	if (!result.HasError()) {
-		return result;
-	}
-	// binding failed
-	// check in the alias map
-	auto &colref = (expr_ptr.get())->Cast<ColumnRefExpression>();
-	if (!colref.IsQualified()) {
-		auto &bind_state = node.bind_state;
-		auto alias_entry = node.bind_state.alias_map.find(colref.column_names[0]);
-		if (alias_entry != node.bind_state.alias_map.end()) {
-			// found entry!
-			auto index = alias_entry->second;
-			if (index >= node.bound_column_count) {
-				throw BinderException("Column \"%s\" referenced that exists in the SELECT clause - but this column "
-				                      "cannot be referenced before it is defined",
-				                      colref.column_names[0]);
-			}
-			if (bind_state.AliasHasSubquery(index)) {
-				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has a subquery."
-				                      " This is not yet supported.",
-				                      colref.column_names[0]);
-			}
-			auto copied_expression = node.bind_state.BindAlias(index);
-			result = BindExpression(copied_expression, depth, false);
-			return result;
-		}
-	}
-	// entry was not found in the alias map: return the original error
-	return result;
-}
-
-bool SelectBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
-	if (!colref.IsQualified()) {
-		return node.bind_state.alias_map.find(colref.column_names[0]) != node.bind_state.alias_map.end();
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/table_function_binder.cpp b/src/duckdb/src/planner/expression_binder/table_function_binder.cpp
deleted file mode 100644
index fca04a10b..000000000
--- a/src/duckdb/src/planner/expression_binder/table_function_binder.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "duckdb/planner/expression_binder/table_function_binder.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/table_binding.hpp"
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-TableFunctionBinder::TableFunctionBinder(Binder &binder, ClientContext &context, string table_function_name_p)
-    : ExpressionBinder(binder, context), table_function_name(std::move(table_function_name_p)) {
-}
-
-BindResult TableFunctionBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) {
-	D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size());
-	auto &lambda_ref = expr.Cast<LambdaRefExpression>();
-	return (*lambda_bindings)[expr.lambda_idx].Bind(lambda_ref, depth);
-}
-
-BindResult TableFunctionBinder::BindColumnReference(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-                                                    bool root_expression) {
-	// try binding as a lambda parameter
-	auto &col_ref = expr_ptr->Cast<ColumnRefExpression>();
-	if (!col_ref.IsQualified()) {
-		auto column_name = col_ref.GetName();
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, column_name);
-		if (lambda_ref) {
-			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
-		}
-		if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(column_name)) {
-			throw ParameterNotResolvedException();
-		}
-	}
-	auto query_location = col_ref.GetQueryLocation();
-	auto column_names = col_ref.column_names;
-	auto result_name = StringUtil::Join(column_names, ".");
-	if (!table_function_name.empty()) {
-		// check if this is a lateral join column/parameter
-		auto result = BindCorrelatedColumns(expr_ptr, ErrorData("error"));
-		if (!result.HasError()) {
-			// it is a lateral join parameter - this is not supported in this type of table function
-			throw BinderException(query_location,
-			                      "Table function \"%s\" does not support lateral join column parameters - cannot use "
-			                      "column \"%s\" in this context.\nThe function only supports literals as parameters.",
-			                      table_function_name, result_name);
-		}
-	}
-
-	auto value_function = ExpressionBinder::GetSQLValueFunction(column_names.back());
-	if (value_function) {
-		return BindExpression(value_function, depth, root_expression);
-	}
-
-	return BindResult(make_uniq<BoundConstantExpression>(Value(result_name)));
-}
-
-BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-                                               bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::LAMBDA_REF:
-		return BindLambdaReference(expr.Cast<LambdaRefExpression>(), depth);
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnReference(expr_ptr, depth, root_expression);
-	case ExpressionClass::SUBQUERY:
-		throw BinderException("Table function cannot contain subqueries");
-	case ExpressionClass::DEFAULT:
-		return BindResult("Table function cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindResult("Table function cannot contain window functions!");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string TableFunctionBinder::UnsupportedAggregateMessage() {
-	return "Table function cannot contain aggregates!";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/update_binder.cpp b/src/duckdb/src/planner/expression_binder/update_binder.cpp
deleted file mode 100644
index 5d69e94b3..000000000
--- a/src/duckdb/src/planner/expression_binder/update_binder.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/planner/expression_binder/update_binder.hpp"
-
-namespace duckdb {
-
-UpdateBinder::UpdateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult UpdateBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		return BindResult(BinderException::Unsupported(expr, "window functions are not allowed in UPDATE"));
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string UpdateBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in UPDATE";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_binder/where_binder.cpp b/src/duckdb/src/planner/expression_binder/where_binder.cpp
deleted file mode 100644
index 9b25c7930..000000000
--- a/src/duckdb/src/planner/expression_binder/where_binder.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/expression_binder/column_alias_binder.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-
-namespace duckdb {
-
-WhereBinder::WhereBinder(Binder &binder, ClientContext &context, optional_ptr<ColumnAliasBinder> column_alias_binder)
-    : ExpressionBinder(binder, context), column_alias_binder(column_alias_binder) {
-	target_type = LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-
-	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
-	if (!result.HasError() || !column_alias_binder) {
-		return result;
-	}
-
-	BindResult alias_result;
-	auto found_alias = column_alias_binder->BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
-	if (found_alias) {
-		return alias_result;
-	}
-
-	return result;
-}
-
-BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::DEFAULT:
-		return BindUnsupportedExpression(expr, depth, "WHERE clause cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindUnsupportedExpression(expr, depth, "WHERE clause cannot contain window functions!");
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string WhereBinder::UnsupportedAggregateMessage() {
-	return "WHERE clause cannot contain aggregates!";
-}
-
-bool WhereBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
-	if (column_alias_binder) {
-		return column_alias_binder->QualifyColumnAlias(colref);
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/expression_iterator.cpp b/src/duckdb/src/planner/expression_iterator.cpp
deleted file mode 100644
index af2afe826..000000000
--- a/src/duckdb/src/planner/expression_iterator.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-#include "duckdb/planner/expression_iterator.hpp"
-
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/query_node/bound_set_operation_node.hpp"
-#include "duckdb/planner/query_node/bound_recursive_cte_node.hpp"
-#include "duckdb/planner/query_node/bound_cte_node.hpp"
-#include "duckdb/planner/tableref/list.hpp"
-#include "duckdb/common/enum_util.hpp"
-
-namespace duckdb {
-
-void ExpressionIterator::EnumerateChildren(const Expression &expr,
-                                           const std::function<void(const Expression &child)> &callback) {
-	EnumerateChildren((Expression &)expr, [&](unique_ptr<Expression> &child) { callback(*child); });
-}
-
-void ExpressionIterator::EnumerateChildren(Expression &expr, const std::function<void(Expression &child)> &callback) {
-	EnumerateChildren(expr, [&](unique_ptr<Expression> &child) { callback(*child); });
-}
-
-void ExpressionIterator::EnumerateChildren(Expression &expr,
-                                           const std::function<void(unique_ptr<Expression> &child)> &callback) {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_AGGREGATE: {
-		auto &aggr_expr = expr.Cast<BoundAggregateExpression>();
-		for (auto &child : aggr_expr.children) {
-			callback(child);
-		}
-		if (aggr_expr.filter) {
-			callback(aggr_expr.filter);
-		}
-		if (aggr_expr.order_bys) {
-			for (auto &order : aggr_expr.order_bys->orders) {
-				callback(order.expression);
-			}
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between_expr = expr.Cast<BoundBetweenExpression>();
-		callback(between_expr.input);
-		callback(between_expr.lower);
-		callback(between_expr.upper);
-		break;
-	}
-	case ExpressionClass::BOUND_CASE: {
-		auto &case_expr = expr.Cast<BoundCaseExpression>();
-		for (auto &case_check : case_expr.case_checks) {
-			callback(case_check.when_expr);
-			callback(case_check.then_expr);
-		}
-		callback(case_expr.else_expr);
-		break;
-	}
-	case ExpressionClass::BOUND_CAST: {
-		auto &cast_expr = expr.Cast<BoundCastExpression>();
-		callback(cast_expr.child);
-		break;
-	}
-	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comp_expr = expr.Cast<BoundComparisonExpression>();
-		callback(comp_expr.left);
-		callback(comp_expr.right);
-		break;
-	}
-	case ExpressionClass::BOUND_CONJUNCTION: {
-		auto &conj_expr = expr.Cast<BoundConjunctionExpression>();
-		for (auto &child : conj_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_FUNCTION: {
-		auto &func_expr = expr.Cast<BoundFunctionExpression>();
-		for (auto &child : func_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_OPERATOR: {
-		auto &op_expr = expr.Cast<BoundOperatorExpression>();
-		for (auto &child : op_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_SUBQUERY: {
-		auto &subquery_expr = expr.Cast<BoundSubqueryExpression>();
-		for (auto &child : subquery_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_WINDOW: {
-		auto &window_expr = expr.Cast<BoundWindowExpression>();
-		for (auto &partition : window_expr.partitions) {
-			callback(partition);
-		}
-		for (auto &order : window_expr.orders) {
-			callback(order.expression);
-		}
-		for (auto &child : window_expr.children) {
-			callback(child);
-		}
-		if (window_expr.filter_expr) {
-			callback(window_expr.filter_expr);
-		}
-		if (window_expr.start_expr) {
-			callback(window_expr.start_expr);
-		}
-		if (window_expr.end_expr) {
-			callback(window_expr.end_expr);
-		}
-		if (window_expr.offset_expr) {
-			callback(window_expr.offset_expr);
-		}
-		if (window_expr.default_expr) {
-			callback(window_expr.default_expr);
-		}
-		for (auto &order : window_expr.arg_orders) {
-			callback(order.expression);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_UNNEST: {
-		auto &unnest_expr = expr.Cast<BoundUnnestExpression>();
-		callback(unnest_expr.child);
-		break;
-	}
-	case ExpressionClass::BOUND_COLUMN_REF:
-	case ExpressionClass::BOUND_LAMBDA_REF:
-	case ExpressionClass::BOUND_CONSTANT:
-	case ExpressionClass::BOUND_DEFAULT:
-	case ExpressionClass::BOUND_PARAMETER:
-	case ExpressionClass::BOUND_REF:
-		// these node types have no children
-		break;
-	default:
-		throw InternalException("ExpressionIterator used on unbound expression");
-	}
-}
-
-void ExpressionIterator::EnumerateExpression(unique_ptr<Expression> &expr,
-                                             const std::function<void(Expression &child)> &callback) {
-	if (!expr) {
-		return;
-	}
-	callback(*expr);
-	ExpressionIterator::EnumerateChildren(*expr,
-	                                      [&](unique_ptr<Expression> &child) { EnumerateExpression(child, callback); });
-}
-
-void BoundNodeVisitor::VisitExpression(unique_ptr<Expression> &expression) {
-	VisitExpressionChildren(*expression);
-}
-
-void BoundNodeVisitor::VisitExpressionChildren(Expression &expr) {
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { VisitExpression(expr); });
-}
-
-void BoundNodeVisitor::VisitBoundQueryNode(BoundQueryNode &node) {
-	switch (node.type) {
-	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &bound_setop = node.Cast<BoundSetOperationNode>();
-		VisitBoundQueryNode(*bound_setop.left);
-		VisitBoundQueryNode(*bound_setop.right);
-		break;
-	}
-	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &cte_node = node.Cast<BoundRecursiveCTENode>();
-		VisitBoundQueryNode(*cte_node.left);
-		VisitBoundQueryNode(*cte_node.right);
-		break;
-	}
-	case QueryNodeType::CTE_NODE: {
-		auto &cte_node = node.Cast<BoundCTENode>();
-		VisitBoundQueryNode(*cte_node.child);
-		VisitBoundQueryNode(*cte_node.query);
-		break;
-	}
-	case QueryNodeType::SELECT_NODE: {
-		auto &bound_select = node.Cast<BoundSelectNode>();
-		for (auto &expr : bound_select.select_list) {
-			VisitExpression(expr);
-		}
-		if (bound_select.where_clause) {
-			VisitExpression(bound_select.where_clause);
-		}
-		for (auto &expr : bound_select.groups.group_expressions) {
-			VisitExpression(expr);
-		}
-		if (bound_select.having) {
-			VisitExpression(bound_select.having);
-		}
-		for (auto &expr : bound_select.aggregates) {
-			VisitExpression(expr);
-		}
-		for (auto &entry : bound_select.unnests) {
-			for (auto &expr : entry.second.expressions) {
-				VisitExpression(expr);
-			}
-		}
-		for (auto &expr : bound_select.windows) {
-			VisitExpression(expr);
-		}
-		if (bound_select.from_table) {
-			VisitBoundTableRef(*bound_select.from_table);
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented query node in ExpressionIterator");
-	}
-	for (idx_t i = 0; i < node.modifiers.size(); i++) {
-		switch (node.modifiers[i]->type) {
-		case ResultModifierType::DISTINCT_MODIFIER:
-			for (auto &expr : node.modifiers[i]->Cast<BoundDistinctModifier>().target_distincts) {
-				VisitExpression(expr);
-			}
-			break;
-		case ResultModifierType::ORDER_MODIFIER:
-			for (auto &order : node.modifiers[i]->Cast<BoundOrderModifier>().orders) {
-				VisitExpression(order.expression);
-			}
-			break;
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit_expr = node.modifiers[i]->Cast<BoundLimitModifier>().limit_val.GetExpression();
-			auto &offset_expr = node.modifiers[i]->Cast<BoundLimitModifier>().offset_val.GetExpression();
-			if (limit_expr) {
-				VisitExpression(limit_expr);
-			}
-			if (offset_expr) {
-				VisitExpression(offset_expr);
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-}
-
-class LogicalBoundNodeVisitor : public LogicalOperatorVisitor {
-public:
-	explicit LogicalBoundNodeVisitor(BoundNodeVisitor &parent) : parent(parent) {
-	}
-
-	void VisitExpression(unique_ptr<Expression> *expression) override {
-		auto &expr = **expression;
-		parent.VisitExpression(*expression);
-		VisitExpressionChildren(expr);
-	}
-
-protected:
-	BoundNodeVisitor &parent;
-};
-
-void BoundNodeVisitor::VisitBoundTableRef(BoundTableRef &ref) {
-	switch (ref.type) {
-	case TableReferenceType::EXPRESSION_LIST: {
-		auto &bound_expr_list = ref.Cast<BoundExpressionListRef>();
-		for (auto &expr_list : bound_expr_list.values) {
-			for (auto &expr : expr_list) {
-				VisitExpression(expr);
-			}
-		}
-		break;
-	}
-	case TableReferenceType::JOIN: {
-		auto &bound_join = ref.Cast<BoundJoinRef>();
-		if (bound_join.condition) {
-			VisitExpression(bound_join.condition);
-		}
-		VisitBoundTableRef(*bound_join.left);
-		VisitBoundTableRef(*bound_join.right);
-		break;
-	}
-	case TableReferenceType::SUBQUERY: {
-		auto &bound_subquery = ref.Cast<BoundSubqueryRef>();
-		VisitBoundQueryNode(*bound_subquery.subquery);
-		break;
-	}
-	case TableReferenceType::TABLE_FUNCTION: {
-		auto &bound_table_function = ref.Cast<BoundTableFunction>();
-		LogicalBoundNodeVisitor node_visitor(*this);
-		if (bound_table_function.get) {
-			node_visitor.VisitOperator(*bound_table_function.get);
-		}
-		if (bound_table_function.subquery) {
-			VisitBoundTableRef(*bound_table_function.subquery);
-		}
-		break;
-	}
-	case TableReferenceType::EMPTY_FROM:
-	case TableReferenceType::BASE_TABLE:
-	case TableReferenceType::CTE:
-		break;
-	default:
-		throw NotImplementedException("Unimplemented table reference type (%s) in ExpressionIterator",
-		                              EnumUtil::ToString(ref.type));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/conjunction_filter.cpp b/src/duckdb/src/planner/filter/conjunction_filter.cpp
deleted file mode 100644
index abb53b4aa..000000000
--- a/src/duckdb/src/planner/filter/conjunction_filter.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-
-namespace duckdb {
-
-ConjunctionOrFilter::ConjunctionOrFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_OR) {
-}
-
-FilterPropagateResult ConjunctionOrFilter::CheckStatistics(BaseStatistics &stats) {
-	// the OR filter is true if ANY of the children is true
-	D_ASSERT(!child_filters.empty());
-	for (auto &filter : child_filters) {
-		auto prune_result = filter->CheckStatistics(stats);
-		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-	}
-	return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-}
-
-string ConjunctionOrFilter::ToString(const string &column_name) {
-	string result;
-	for (idx_t i = 0; i < child_filters.size(); i++) {
-		if (i > 0) {
-			result += " OR ";
-		}
-		result += child_filters[i]->ToString(column_name);
-	}
-	return result;
-}
-
-bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
-	if (!ConjunctionFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<ConjunctionOrFilter>();
-	if (other.child_filters.size() != child_filters.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < other.child_filters.size(); i++) {
-		if (!child_filters[i]->Equals(*other.child_filters[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<TableFilter> ConjunctionOrFilter::Copy() const {
-	auto result = make_uniq<ConjunctionOrFilter>();
-	for (auto &filter : child_filters) {
-		result->child_filters.push_back(filter->Copy());
-	}
-	return std::move(result);
-}
-
-unique_ptr<Expression> ConjunctionOrFilter::ToExpression(const Expression &column) const {
-	auto conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-	for (auto &filter : child_filters) {
-		conjunction->children.push_back(filter->ToExpression(column));
-	}
-	return std::move(conjunction);
-}
-
-ConjunctionAndFilter::ConjunctionAndFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_AND) {
-}
-
-FilterPropagateResult ConjunctionAndFilter::CheckStatistics(BaseStatistics &stats) {
-	// the AND filter is true if ALL of the children is true
-	D_ASSERT(!child_filters.empty());
-	auto result = FilterPropagateResult::FILTER_ALWAYS_TRUE;
-	for (auto &filter : child_filters) {
-		auto prune_result = filter->CheckStatistics(stats);
-		if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		} else if (prune_result != result) {
-			result = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-	}
-	return result;
-}
-
-string ConjunctionAndFilter::ToString(const string &column_name) {
-	string result;
-	for (idx_t i = 0; i < child_filters.size(); i++) {
-		if (i > 0) {
-			result += " AND ";
-		}
-		result += child_filters[i]->ToString(column_name);
-	}
-	return result;
-}
-
-bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
-	if (!ConjunctionFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<ConjunctionAndFilter>();
-	if (other.child_filters.size() != child_filters.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < other.child_filters.size(); i++) {
-		if (!child_filters[i]->Equals(*other.child_filters[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<TableFilter> ConjunctionAndFilter::Copy() const {
-	auto result = make_uniq<ConjunctionAndFilter>();
-	for (auto &filter : child_filters) {
-		result->child_filters.push_back(filter->Copy());
-	}
-	return std::move(result);
-}
-
-unique_ptr<Expression> ConjunctionAndFilter::ToExpression(const Expression &column) const {
-	auto conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-	for (auto &filter : child_filters) {
-		conjunction->children.push_back(filter->ToExpression(column));
-	}
-	return std::move(conjunction);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/constant_filter.cpp b/src/duckdb/src/planner/filter/constant_filter.cpp
deleted file mode 100644
index 9384cd204..000000000
--- a/src/duckdb/src/planner/filter/constant_filter.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-ConstantFilter::ConstantFilter(ExpressionType comparison_type_p, Value constant_p)
-    : TableFilter(TableFilterType::CONSTANT_COMPARISON), comparison_type(comparison_type_p),
-      constant(std::move(constant_p)) {
-	if (constant.IsNull()) {
-		throw InternalException("ConstantFilter constant cannot be NULL - use IsNullFilter instead");
-	}
-}
-
-FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
-	if (!stats.CanHaveNoNull()) {
-		// no non-null values are possible: always false
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	FilterPropagateResult result;
-	D_ASSERT(constant.type().id() == stats.GetType().id());
-	switch (constant.type().InternalType()) {
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::UINT128:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		result = NumericStats::CheckZonemap(stats, comparison_type, array_ptr<Value>(&constant, 1));
-		break;
-	case PhysicalType::VARCHAR:
-		result = StringStats::CheckZonemap(stats, comparison_type, array_ptr<Value>(&constant, 1));
-		break;
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	if (result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// the numeric filter is always true, but the column can have NULL values
-		// we can't prune the filter
-		if (stats.CanHaveNull()) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-	}
-	return result;
-}
-
-string ConstantFilter::ToString(const string &column_name) {
-	return column_name + ExpressionTypeToOperator(comparison_type) + constant.ToSQLString();
-}
-
-unique_ptr<Expression> ConstantFilter::ToExpression(const Expression &column) const {
-	auto bound_constant = make_uniq<BoundConstantExpression>(constant);
-	auto result = make_uniq<BoundComparisonExpression>(comparison_type, column.Copy(), std::move(bound_constant));
-	return std::move(result);
-}
-
-bool ConstantFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<ConstantFilter>();
-	return other.comparison_type == comparison_type && other.constant == constant;
-}
-
-unique_ptr<TableFilter> ConstantFilter::Copy() const {
-	return make_uniq<ConstantFilter>(comparison_type, constant);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/dynamic_filter.cpp b/src/duckdb/src/planner/filter/dynamic_filter.cpp
deleted file mode 100644
index 23de4bf42..000000000
--- a/src/duckdb/src/planner/filter/dynamic_filter.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "duckdb/planner/filter/dynamic_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-
-namespace duckdb {
-
-DynamicFilter::DynamicFilter() : TableFilter(TableFilterType::DYNAMIC_FILTER) {
-}
-
-DynamicFilter::DynamicFilter(shared_ptr<DynamicFilterData> filter_data_p)
-    : TableFilter(TableFilterType::DYNAMIC_FILTER), filter_data(std::move(filter_data_p)) {
-}
-
-FilterPropagateResult DynamicFilter::CheckStatistics(BaseStatistics &stats) {
-	if (!filter_data) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	lock_guard<mutex> l(filter_data->lock);
-	if (!filter_data->initialized) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	return filter_data->filter->CheckStatistics(stats);
-}
-
-string DynamicFilter::ToString(const string &column_name) {
-	if (filter_data) {
-		return "Dynamic Filter (" + column_name + ")";
-	} else {
-		return "Empty Dynamic Filter (" + column_name + ")";
-	}
-}
-
-unique_ptr<Expression> DynamicFilter::ToExpression(const Expression &column) const {
-	if (!filter_data || !filter_data->initialized) {
-		auto bound_constant = make_uniq<BoundConstantExpression>(Value(true));
-		return std::move(bound_constant);
-	}
-	lock_guard<mutex> l(filter_data->lock);
-	return filter_data->filter->ToExpression(column);
-}
-
-bool DynamicFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<DynamicFilter>();
-	return other.filter_data.get() == filter_data.get();
-}
-
-unique_ptr<TableFilter> DynamicFilter::Copy() const {
-	return make_uniq<DynamicFilter>(filter_data);
-}
-
-void DynamicFilterData::SetValue(Value val) {
-	if (val.IsNull()) {
-		return;
-	}
-	lock_guard<mutex> l(lock);
-	filter->Cast<ConstantFilter>().constant = std::move(val);
-	initialized = true;
-}
-
-void DynamicFilterData::Reset() {
-	lock_guard<mutex> l(lock);
-	initialized = false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/in_filter.cpp b/src/duckdb/src/planner/filter/in_filter.cpp
deleted file mode 100644
index b3eff6e23..000000000
--- a/src/duckdb/src/planner/filter/in_filter.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/planner/filter/in_filter.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-
-namespace duckdb {
-
-InFilter::InFilter(vector<Value> values_p) : InFilter(std::move(values_p), false) {
-}
-
-InFilter::InFilter(vector<Value> values_p, bool origin_is_hash_join)
-    : TableFilter(TableFilterType::IN_FILTER), values(std::move(values_p)), origin_is_hash_join(origin_is_hash_join) {
-	for (auto &val : values) {
-		if (val.IsNull()) {
-			throw InternalException("InFilter constant cannot be NULL - use IsNullFilter instead");
-		}
-	}
-	for (idx_t i = 1; i < values.size(); i++) {
-		if (values[0].type() != values[i].type()) {
-			throw InternalException("InFilter constants must all have the same type");
-		}
-	}
-	if (values.empty()) {
-		throw InternalException("InFilter constants cannot be empty");
-	}
-}
-
-FilterPropagateResult InFilter::CheckStatistics(BaseStatistics &stats) {
-	switch (values[0].type().InternalType()) {
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::UINT128:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return NumericStats::CheckZonemap(stats, ExpressionType::COMPARE_EQUAL,
-		                                  array_ptr<Value>(values.data(), values.size()));
-	case PhysicalType::VARCHAR:
-		return StringStats::CheckZonemap(stats, ExpressionType::COMPARE_EQUAL,
-		                                 array_ptr<Value>(values.data(), values.size()));
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-}
-
-string InFilter::ToString(const string &column_name) {
-	string in_list;
-	for (auto &val : values) {
-		if (!in_list.empty()) {
-			in_list += ", ";
-		}
-		in_list += val.ToSQLString();
-	}
-	return column_name + " IN (" + in_list + ")";
-}
-
-unique_ptr<Expression> InFilter::ToExpression(const Expression &column) const {
-	auto result = make_uniq<BoundOperatorExpression>(ExpressionType::COMPARE_IN, LogicalType::BOOLEAN);
-	result->children.push_back(column.Copy());
-	for (auto &val : values) {
-		result->children.push_back(make_uniq<BoundConstantExpression>(val));
-	}
-	return std::move(result);
-}
-
-bool InFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<InFilter>();
-	return other.values == values && other.origin_is_hash_join == origin_is_hash_join;
-}
-
-unique_ptr<TableFilter> InFilter::Copy() const {
-	return make_uniq<InFilter>(values, origin_is_hash_join);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/null_filter.cpp b/src/duckdb/src/planner/filter/null_filter.cpp
deleted file mode 100644
index 6848191e9..000000000
--- a/src/duckdb/src/planner/filter/null_filter.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-IsNullFilter::IsNullFilter() : TableFilter(TableFilterType::IS_NULL) {
-}
-
-FilterPropagateResult IsNullFilter::CheckStatistics(BaseStatistics &stats) {
-	if (!stats.CanHaveNull()) {
-		// no null values are possible: always false
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (!stats.CanHaveNoNull()) {
-		// no non-null values are possible: always true
-		return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-	}
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-string IsNullFilter::ToString(const string &column_name) {
-	return column_name + " IS NULL";
-}
-
-unique_ptr<TableFilter> IsNullFilter::Copy() const {
-	return make_uniq<IsNullFilter>();
-}
-
-unique_ptr<Expression> IsNullFilter::ToExpression(const Expression &column) const {
-	auto result = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
-	result->children.push_back(column.Copy());
-	return std::move(result);
-}
-
-IsNotNullFilter::IsNotNullFilter() : TableFilter(TableFilterType::IS_NOT_NULL) {
-}
-
-FilterPropagateResult IsNotNullFilter::CheckStatistics(BaseStatistics &stats) {
-	if (!stats.CanHaveNoNull()) {
-		// no non-null values are possible: always false
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (!stats.CanHaveNull()) {
-		// no null values are possible: always true
-		return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-	}
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-string IsNotNullFilter::ToString(const string &column_name) {
-	return column_name + " IS NOT NULL";
-}
-
-unique_ptr<TableFilter> IsNotNullFilter::Copy() const {
-	return make_uniq<IsNotNullFilter>();
-}
-
-unique_ptr<Expression> IsNotNullFilter::ToExpression(const Expression &column) const {
-	auto result = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-	result->children.push_back(column.Copy());
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/optional_filter.cpp b/src/duckdb/src/planner/filter/optional_filter.cpp
deleted file mode 100644
index 891e9014d..000000000
--- a/src/duckdb/src/planner/filter/optional_filter.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/planner/expression.hpp"
-
-namespace duckdb {
-
-OptionalFilter::OptionalFilter(unique_ptr<TableFilter> filter)
-    : TableFilter(TableFilterType::OPTIONAL_FILTER), child_filter(std::move(filter)) {
-}
-
-FilterPropagateResult OptionalFilter::CheckStatistics(BaseStatistics &stats) {
-	return child_filter->CheckStatistics(stats);
-}
-
-string OptionalFilter::ToString(const string &column_name) {
-	return string("optional: ") + child_filter->ToString(column_name);
-}
-
-unique_ptr<Expression> OptionalFilter::ToExpression(const Expression &column) const {
-	return child_filter->ToExpression(column);
-}
-
-unique_ptr<TableFilter> OptionalFilter::Copy() const {
-	auto copy = make_uniq<OptionalFilter>();
-	copy->child_filter = child_filter->Copy();
-	return duckdb::unique_ptr_cast<OptionalFilter, TableFilter>(std::move(copy));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/filter/struct_filter.cpp b/src/duckdb/src/planner/filter/struct_filter.cpp
deleted file mode 100644
index 91d3b323d..000000000
--- a/src/duckdb/src/planner/filter/struct_filter.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/planner/filter/struct_filter.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
-
-namespace duckdb {
-
-StructFilter::StructFilter(idx_t child_idx_p, string child_name_p, unique_ptr<TableFilter> child_filter_p)
-    : TableFilter(TableFilterType::STRUCT_EXTRACT), child_idx(child_idx_p), child_name(std::move(child_name_p)),
-      child_filter(std::move(child_filter_p)) {
-}
-
-FilterPropagateResult StructFilter::CheckStatistics(BaseStatistics &stats) {
-	D_ASSERT(stats.GetType().id() == LogicalTypeId::STRUCT);
-	// Check the child statistics
-	auto &child_stats = StructStats::GetChildStats(stats, child_idx);
-	return child_filter->CheckStatistics(child_stats);
-}
-
-string StructFilter::ToString(const string &column_name) {
-	if (!child_name.empty()) {
-		return child_filter->ToString(column_name + "." + child_name);
-	}
-	return child_filter->ToString("struct_extract_at(" + column_name + "," + std::to_string(child_idx + 1) + ")");
-}
-
-bool StructFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = other_p.Cast<StructFilter>();
-	if ((!child_name.empty()) && (!other.child_name.empty())) { // if both child_names are known, sanity check
-		D_ASSERT((other.child_idx == child_idx) == StringUtil::CIEquals(other.child_name, child_name));
-	}
-	return other.child_idx == child_idx && other.child_filter->Equals(*child_filter);
-}
-
-unique_ptr<TableFilter> StructFilter::Copy() const {
-	return make_uniq<StructFilter>(child_idx, child_name, child_filter->Copy());
-}
-
-unique_ptr<Expression> StructFilter::ToExpression(const Expression &column) const {
-	auto &child_type = StructType::GetChildType(column.return_type, child_idx);
-	vector<unique_ptr<Expression>> arguments;
-	arguments.push_back(column.Copy());
-	arguments.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(NumericCast<int64_t>(child_idx + 1))));
-	auto child = make_uniq<BoundFunctionExpression>(child_type, GetExtractAtFunction(), std::move(arguments),
-	                                                GetBindData(child_idx));
-	return child_filter->ToExpression(*child);
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/joinside.cpp b/src/duckdb/src/planner/joinside.cpp
deleted file mode 100644
index b4c571b91..000000000
--- a/src/duckdb/src/planner/joinside.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "duckdb/planner/joinside.hpp"
-
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-
-namespace duckdb {
-
-unique_ptr<Expression> JoinCondition::CreateExpression(JoinCondition cond) {
-	auto bound_comparison =
-	    make_uniq<BoundComparisonExpression>(cond.comparison, std::move(cond.left), std::move(cond.right));
-	return std::move(bound_comparison);
-}
-
-unique_ptr<Expression> JoinCondition::CreateExpression(vector<JoinCondition> conditions) {
-	unique_ptr<Expression> result;
-	for (auto &cond : conditions) {
-		auto expr = CreateExpression(std::move(cond));
-		if (!result) {
-			result = std::move(expr);
-		} else {
-			auto conj = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
-			                                                  std::move(result));
-			result = std::move(conj);
-		}
-	}
-	return result;
-}
-
-JoinSide JoinSide::CombineJoinSide(JoinSide left, JoinSide right) {
-	if (left == JoinSide::NONE) {
-		return right;
-	}
-	if (right == JoinSide::NONE) {
-		return left;
-	}
-	if (left != right) {
-		return JoinSide::BOTH;
-	}
-	return left;
-}
-
-JoinSide JoinSide::GetJoinSide(idx_t table_binding, const unordered_set<idx_t> &left_bindings,
-                               const unordered_set<idx_t> &right_bindings) {
-	if (left_bindings.find(table_binding) != left_bindings.end()) {
-		// column references table on left side
-		D_ASSERT(right_bindings.find(table_binding) == right_bindings.end());
-		return JoinSide::LEFT;
-	} else {
-		// column references table on right side
-		D_ASSERT(right_bindings.find(table_binding) != right_bindings.end());
-		return JoinSide::RIGHT;
-	}
-}
-
-JoinSide JoinSide::GetJoinSide(Expression &expression, const unordered_set<idx_t> &left_bindings,
-                               const unordered_set<idx_t> &right_bindings) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expression.Cast<BoundColumnRefExpression>();
-		if (colref.depth > 0) {
-			throw NotImplementedException("Non-inner join on correlated columns not supported");
-		}
-		return GetJoinSide(colref.binding.table_index, left_bindings, right_bindings);
-	}
-	D_ASSERT(expression.GetExpressionType() != ExpressionType::BOUND_REF);
-	if (expression.GetExpressionType() == ExpressionType::SUBQUERY) {
-		D_ASSERT(expression.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY);
-		auto &subquery = expression.Cast<BoundSubqueryExpression>();
-		JoinSide side = JoinSide::NONE;
-		for (auto &child : subquery.children) {
-			auto child_side = GetJoinSide(*child, left_bindings, right_bindings);
-			side = CombineJoinSide(side, child_side);
-		}
-		// correlated subquery, check the side of each of correlated columns in the subquery
-		for (auto &corr : subquery.binder->correlated_columns) {
-			if (corr.depth > 1) {
-				// correlated column has depth > 1
-				// it does not refer to any table in the current set of bindings
-				return JoinSide::BOTH;
-			}
-			auto correlated_side = GetJoinSide(corr.binding.table_index, left_bindings, right_bindings);
-			side = CombineJoinSide(side, correlated_side);
-		}
-		return side;
-	}
-	JoinSide join_side = JoinSide::NONE;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &child) {
-		auto child_side = GetJoinSide(child, left_bindings, right_bindings);
-		join_side = CombineJoinSide(child_side, join_side);
-	});
-	return join_side;
-}
-
-JoinSide JoinSide::GetJoinSide(const unordered_set<idx_t> &bindings, const unordered_set<idx_t> &left_bindings,
-                               const unordered_set<idx_t> &right_bindings) {
-	JoinSide side = JoinSide::NONE;
-	for (auto binding : bindings) {
-		side = CombineJoinSide(side, GetJoinSide(binding, left_bindings, right_bindings));
-	}
-	return side;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/logical_operator.cpp b/src/duckdb/src/planner/logical_operator.cpp
deleted file mode 100644
index c8e73a1fe..000000000
--- a/src/duckdb/src/planner/logical_operator.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-#include "duckdb/planner/logical_operator.hpp"
-
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/operator/logical_join.hpp"
-#include "duckdb/planner/operator/logical_order.hpp"
-
-namespace duckdb {
-
-LogicalOperator::LogicalOperator(LogicalOperatorType type)
-    : type(type), estimated_cardinality(0), has_estimated_cardinality(false) {
-}
-
-LogicalOperator::LogicalOperator(LogicalOperatorType type, vector<unique_ptr<Expression>> expressions)
-    : type(type), expressions(std::move(expressions)), estimated_cardinality(0), has_estimated_cardinality(false) {
-}
-
-LogicalOperator::~LogicalOperator() {
-}
-
-vector<ColumnBinding> LogicalOperator::GetColumnBindings() {
-	return {ColumnBinding(0, 0)};
-}
-
-void LogicalOperator::SetParamsEstimatedCardinality(InsertionOrderPreservingMap<string> &result) const {
-	if (has_estimated_cardinality) {
-		result[RenderTreeNode::ESTIMATED_CARDINALITY] = StringUtil::Format("%llu", estimated_cardinality);
-	}
-}
-
-void LogicalOperator::SetEstimatedCardinality(idx_t _estimated_cardinality) {
-	estimated_cardinality = _estimated_cardinality;
-	has_estimated_cardinality = true;
-}
-
-// LCOV_EXCL_START
-string LogicalOperator::ColumnBindingsToString(const vector<ColumnBinding> &bindings) {
-	string result = "{";
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (i != 0) {
-			result += ", ";
-		}
-		result += bindings[i].ToString();
-	}
-	return result + "}";
-}
-
-void LogicalOperator::PrintColumnBindings() {
-	Printer::Print(ColumnBindingsToString(GetColumnBindings()));
-}
-// LCOV_EXCL_STOP
-
-string LogicalOperator::GetName() const {
-	return LogicalOperatorToString(type);
-}
-
-InsertionOrderPreservingMap<string> LogicalOperator::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string expressions_info;
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i > 0) {
-			expressions_info += "\n";
-		}
-		expressions_info += expressions[i]->GetName();
-	}
-	result["Expressions"] = expressions_info;
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-void LogicalOperator::ResolveOperatorTypes() {
-	types.clear();
-	// first resolve child types
-	for (auto &child : children) {
-		child->ResolveOperatorTypes();
-	}
-	// now resolve the types for this operator
-	ResolveTypes();
-	D_ASSERT(types.size() == GetColumnBindings().size());
-}
-
-vector<ColumnBinding> LogicalOperator::GenerateColumnBindings(idx_t table_idx, idx_t column_count) {
-	vector<ColumnBinding> result;
-	result.reserve(column_count);
-	for (idx_t i = 0; i < column_count; i++) {
-		result.emplace_back(table_idx, i);
-	}
-	return result;
-}
-
-vector<LogicalType> LogicalOperator::MapTypes(const vector<LogicalType> &types, const vector<idx_t> &projection_map) {
-	if (projection_map.empty()) {
-		return types;
-	} else {
-		vector<LogicalType> result_types;
-		result_types.reserve(projection_map.size());
-		for (auto index : projection_map) {
-			result_types.push_back(types[index]);
-		}
-		return result_types;
-	}
-}
-
-vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &bindings,
-                                                   const vector<idx_t> &projection_map) {
-	if (projection_map.empty()) {
-		return bindings;
-	} else {
-		vector<ColumnBinding> result_bindings;
-		result_bindings.reserve(projection_map.size());
-		for (auto index : projection_map) {
-			D_ASSERT(index < bindings.size());
-			result_bindings.push_back(bindings[index]);
-		}
-		return result_bindings;
-	}
-}
-
-string LogicalOperator::ToString(ExplainFormat format) const {
-	auto renderer = TreeRenderer::CreateRenderer(format);
-	stringstream ss;
-	auto tree = RenderTree::CreateRenderTree(*this);
-	renderer->ToStream(*tree, ss);
-	return ss.str();
-}
-
-void LogicalOperator::Verify(ClientContext &context) {
-#ifdef DEBUG
-	// verify expressions
-	for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
-		auto str = expressions[expr_idx]->ToString();
-		// verify that we can (correctly) copy this expression
-		auto copy = expressions[expr_idx]->Copy();
-		auto original_hash = expressions[expr_idx]->Hash();
-		auto copy_hash = copy->Hash();
-		// copy should be identical to original
-		D_ASSERT(expressions[expr_idx]->ToString() == copy->ToString());
-		D_ASSERT(original_hash == copy_hash);
-		D_ASSERT(Expression::Equals(expressions[expr_idx], copy));
-
-		for (idx_t other_idx = 0; other_idx < expr_idx; other_idx++) {
-			// comparison with other expressions
-			auto other_hash = expressions[other_idx]->Hash();
-			bool expr_equal = Expression::Equals(expressions[expr_idx], expressions[other_idx]);
-			if (original_hash != other_hash) {
-				// if the hashes are not equal the expressions should not be equal either
-				D_ASSERT(!expr_equal);
-			}
-		}
-		D_ASSERT(!str.empty());
-
-		// verify that serialization + deserialization round-trips correctly
-		if (expressions[expr_idx]->HasParameter()) {
-			continue;
-		}
-		MemoryStream stream;
-		// We are serializing a query plan
-		try {
-			BinarySerializer::Serialize(*expressions[expr_idx], stream);
-		} catch (NotImplementedException &ex) {
-			// ignore for now (FIXME)
-			continue;
-		}
-		// Rewind the stream
-		stream.Rewind();
-
-		bound_parameter_map_t parameters;
-		auto deserialized_expression = BinaryDeserializer::Deserialize<Expression>(stream, context, parameters);
-
-		// FIXME: expressions might not be equal yet because of statistics propagation
-		continue;
-		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));
-		D_ASSERT(expressions[expr_idx]->Hash() == deserialized_expression->Hash());
-	}
-	D_ASSERT(!ToString().empty());
-	for (auto &child : children) {
-		child->Verify(context);
-	}
-#endif
-}
-
-void LogicalOperator::AddChild(unique_ptr<LogicalOperator> child) {
-	D_ASSERT(child);
-	children.push_back(std::move(child));
-}
-
-idx_t LogicalOperator::EstimateCardinality(ClientContext &context) {
-	// simple estimator, just take the max of the children
-	if (has_estimated_cardinality) {
-		return estimated_cardinality;
-	}
-	idx_t max_cardinality = 0;
-	for (auto &child : children) {
-		max_cardinality = MaxValue(child->EstimateCardinality(context), max_cardinality);
-	}
-	has_estimated_cardinality = true;
-	estimated_cardinality = max_cardinality;
-	return estimated_cardinality;
-}
-
-void LogicalOperator::Print() {
-	Printer::Print(ToString());
-}
-
-vector<idx_t> LogicalOperator::GetTableIndex() const {
-	return vector<idx_t> {};
-}
-
-unique_ptr<LogicalOperator> LogicalOperator::Copy(ClientContext &context) const {
-	MemoryStream stream;
-	BinarySerializer serializer(stream);
-	try {
-		serializer.Begin();
-		this->Serialize(serializer);
-		serializer.End();
-	} catch (NotImplementedException &ex) {
-		ErrorData error(ex);
-		throw NotImplementedException("Logical Operator Copy requires the logical operator and all of its children to "
-		                              "be serializable: " +
-		                              error.RawMessage());
-	}
-	stream.Rewind();
-	bound_parameter_map_t parameters;
-	auto op_copy = BinaryDeserializer::Deserialize<LogicalOperator>(stream, context, parameters);
-	return op_copy;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/logical_operator_visitor.cpp b/src/duckdb/src/planner/logical_operator_visitor.cpp
deleted file mode 100644
index 7ebf3151e..000000000
--- a/src/duckdb/src/planner/logical_operator_visitor.cpp
+++ /dev/null
@@ -1,335 +0,0 @@
-#include "duckdb/planner/logical_operator_visitor.hpp"
-
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/operator/list.hpp"
-
-namespace duckdb {
-
-void LogicalOperatorVisitor::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-}
-
-void LogicalOperatorVisitor::VisitOperatorChildren(LogicalOperator &op) {
-	if (op.HasProjectionMap()) {
-		VisitOperatorWithProjectionMapChildren(op);
-	} else {
-		for (auto &child : op.children) {
-			VisitOperator(*child);
-		}
-	}
-}
-
-void LogicalOperatorVisitor::VisitOperatorWithProjectionMapChildren(LogicalOperator &op) {
-	D_ASSERT(op.HasProjectionMap());
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN: {
-		auto &join = op.Cast<LogicalJoin>();
-		VisitChildOfOperatorWithProjectionMap(*op.children[0], join.left_projection_map);
-		VisitChildOfOperatorWithProjectionMap(*op.children[1], join.right_projection_map);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		auto &order = op.Cast<LogicalOrder>();
-		VisitChildOfOperatorWithProjectionMap(*op.children[0], order.projection_map);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = op.Cast<LogicalFilter>();
-		VisitChildOfOperatorWithProjectionMap(*op.children[0], filter.projection_map);
-		break;
-	}
-	default:
-		throw NotImplementedException("VisitOperatorWithProjectionMapChildren for %s", EnumUtil::ToString(op.type));
-	}
-}
-
-void LogicalOperatorVisitor::VisitChildOfOperatorWithProjectionMap(LogicalOperator &child,
-                                                                   vector<idx_t> &projection_map) {
-	const auto child_bindings_before = child.GetColumnBindings();
-	VisitOperator(child);
-	if (projection_map.empty()) {
-		return; // Nothing to fix here
-	}
-	// Child binding order may have changed due to 'fun'.
-	const auto child_bindings_after = child.GetColumnBindings();
-	if (child_bindings_before == child_bindings_after) {
-		return; // Nothing changed
-	}
-	// The desired order is 'projection_map' applied to 'child_bindings_before'
-	// We create 'new_projection_map', which ensures this order even if 'child_bindings_after' is different
-	vector<idx_t> new_projection_map;
-	new_projection_map.reserve(projection_map.size());
-	for (const auto proj_idx_before : projection_map) {
-		auto &desired_binding = child_bindings_before[proj_idx_before];
-		idx_t proj_idx_after;
-		for (proj_idx_after = 0; proj_idx_after < child_bindings_after.size(); proj_idx_after++) {
-			if (child_bindings_after[proj_idx_after] == desired_binding) {
-				break;
-			}
-		}
-		if (proj_idx_after == child_bindings_after.size()) {
-			// VisitOperator has removed this binding, e.g., by replacing one binding with another
-			// Inside here we don't know how it has been replaced, and projection maps are positional: bail
-			new_projection_map.clear();
-			break;
-		}
-		new_projection_map.push_back(proj_idx_after);
-	}
-	projection_map = std::move(new_projection_map);
-}
-
-void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
-                                                  const std::function<void(unique_ptr<Expression> *child)> &callback) {
-
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
-		auto &get = op.Cast<LogicalExpressionGet>();
-		for (auto &expr_list : get.expressions) {
-			for (auto &expr : expr_list) {
-				callback(&expr);
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		auto &order = op.Cast<LogicalOrder>();
-		for (auto &node : order.orders) {
-			callback(&node.expression);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_TOP_N: {
-		auto &order = op.Cast<LogicalTopN>();
-		for (auto &node : order.orders) {
-			callback(&node.expression);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		auto &distinct = op.Cast<LogicalDistinct>();
-		for (auto &target : distinct.distinct_targets) {
-			callback(&target);
-		}
-		if (distinct.order_by) {
-			for (auto &order : distinct.order_by->orders) {
-				callback(&order.expression);
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_INSERT: {
-		auto &insert = op.Cast<LogicalInsert>();
-		if (insert.on_conflict_condition) {
-			callback(&insert.on_conflict_condition);
-		}
-		if (insert.do_update_condition) {
-			callback(&insert.do_update_condition);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		for (auto &expr : join.duplicate_eliminated_columns) {
-			callback(&expr);
-		}
-		for (auto &cond : join.conditions) {
-			callback(&cond.left);
-			callback(&cond.right);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &join = op.Cast<LogicalAnyJoin>();
-		callback(&join.condition);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT: {
-		auto &limit = op.Cast<LogicalLimit>();
-		if (limit.limit_val.GetExpression()) {
-			callback(&limit.limit_val.GetExpression());
-		}
-		if (limit.offset_val.GetExpression()) {
-			callback(&limit.offset_val.GetExpression());
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		auto &aggr = op.Cast<LogicalAggregate>();
-		for (auto &group : aggr.groups) {
-			callback(&group);
-		}
-		break;
-	}
-	default:
-		break;
-	}
-	for (auto &expression : op.expressions) {
-		callback(&expression);
-	}
-}
-
-void LogicalOperatorVisitor::VisitOperatorExpressions(LogicalOperator &op) {
-	LogicalOperatorVisitor::EnumerateExpressions(op, [&](unique_ptr<Expression> *child) { VisitExpression(child); });
-}
-
-void LogicalOperatorVisitor::VisitExpression(unique_ptr<Expression> *expression) {
-	auto &expr = **expression;
-	unique_ptr<Expression> result;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_AGGREGATE:
-		result = VisitReplace(expr.Cast<BoundAggregateExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_BETWEEN:
-		result = VisitReplace(expr.Cast<BoundBetweenExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_CASE:
-		result = VisitReplace(expr.Cast<BoundCaseExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_CAST:
-		result = VisitReplace(expr.Cast<BoundCastExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_COLUMN_REF:
-		result = VisitReplace(expr.Cast<BoundColumnRefExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_COMPARISON:
-		result = VisitReplace(expr.Cast<BoundComparisonExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_CONJUNCTION:
-		result = VisitReplace(expr.Cast<BoundConjunctionExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_CONSTANT:
-		result = VisitReplace(expr.Cast<BoundConstantExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_FUNCTION:
-		result = VisitReplace(expr.Cast<BoundFunctionExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_SUBQUERY:
-		result = VisitReplace(expr.Cast<BoundSubqueryExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_OPERATOR:
-		result = VisitReplace(expr.Cast<BoundOperatorExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_PARAMETER:
-		result = VisitReplace(expr.Cast<BoundParameterExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_REF:
-		result = VisitReplace(expr.Cast<BoundReferenceExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_DEFAULT:
-		result = VisitReplace(expr.Cast<BoundDefaultExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_WINDOW:
-		result = VisitReplace(expr.Cast<BoundWindowExpression>(), expression);
-		break;
-	case ExpressionClass::BOUND_UNNEST:
-		result = VisitReplace(expr.Cast<BoundUnnestExpression>(), expression);
-		break;
-	default:
-		throw InternalException("Unrecognized expression type in logical operator visitor");
-	}
-	if (result) {
-		*expression = std::move(result);
-	} else {
-		// visit the children of this node
-		VisitExpressionChildren(expr);
-	}
-}
-
-void LogicalOperatorVisitor::VisitExpressionChildren(Expression &expr) {
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { VisitExpression(&expr); });
-}
-
-// these are all default methods that can be overriden
-// we don't care about coverage here
-// LCOV_EXCL_START
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundAggregateExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundBetweenExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundCaseExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundCastExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundColumnRefExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundComparisonExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundConjunctionExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundConstantExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundDefaultExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundFunctionExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundOperatorExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundParameterExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundReferenceExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundSubqueryExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundWindowExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundUnnestExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_aggregate.cpp b/src/duckdb/src/planner/operator/logical_aggregate.cpp
deleted file mode 100644
index 3ee244c22..000000000
--- a/src/duckdb/src/planner/operator/logical_aggregate.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "duckdb/planner/operator/logical_aggregate.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-LogicalAggregate::LogicalAggregate(idx_t group_index, idx_t aggregate_index, vector<unique_ptr<Expression>> select_list)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY, std::move(select_list)),
-      group_index(group_index), aggregate_index(aggregate_index), groupings_index(DConstants::INVALID_INDEX) {
-}
-
-void LogicalAggregate::ResolveTypes() {
-	D_ASSERT(groupings_index != DConstants::INVALID_INDEX || grouping_functions.empty());
-	for (auto &expr : groups) {
-		types.push_back(expr->return_type);
-	}
-	// get the chunk types from the projection list
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-	for (idx_t i = 0; i < grouping_functions.size(); i++) {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-}
-
-vector<ColumnBinding> LogicalAggregate::GetColumnBindings() {
-	D_ASSERT(groupings_index != DConstants::INVALID_INDEX || grouping_functions.empty());
-	vector<ColumnBinding> result;
-	result.reserve(groups.size() + expressions.size() + grouping_functions.size());
-	for (idx_t i = 0; i < groups.size(); i++) {
-		result.emplace_back(group_index, i);
-	}
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		result.emplace_back(aggregate_index, i);
-	}
-	for (idx_t i = 0; i < grouping_functions.size(); i++) {
-		result.emplace_back(groupings_index, i);
-	}
-	return result;
-}
-
-InsertionOrderPreservingMap<string> LogicalAggregate::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string groups_info;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			groups_info += "\n";
-		}
-		groups_info += groups[i]->GetName();
-	}
-	result["Groups"] = groups_info;
-
-	string expressions_info;
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i > 0) {
-			expressions_info += "\n";
-		}
-		expressions_info += expressions[i]->GetName();
-	}
-	result["Expressions"] = expressions_info;
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-idx_t LogicalAggregate::EstimateCardinality(ClientContext &context) {
-	if (groups.empty()) {
-		// ungrouped aggregate
-		return 1;
-	}
-	return LogicalOperator::EstimateCardinality(context);
-}
-
-vector<idx_t> LogicalAggregate::GetTableIndex() const {
-	vector<idx_t> result {group_index, aggregate_index};
-	if (groupings_index != DConstants::INVALID_INDEX) {
-		result.push_back(groupings_index);
-	}
-	return result;
-}
-
-string LogicalAggregate::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() +
-		       StringUtil::Format(" #%llu, #%llu, #%llu", group_index, aggregate_index, groupings_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_any_join.cpp b/src/duckdb/src/planner/operator/logical_any_join.cpp
deleted file mode 100644
index 07587dad9..000000000
--- a/src/duckdb/src/planner/operator/logical_any_join.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/planner/operator/logical_any_join.hpp"
-
-namespace duckdb {
-
-LogicalAnyJoin::LogicalAnyJoin(JoinType type) : LogicalJoin(type, LogicalOperatorType::LOGICAL_ANY_JOIN) {
-}
-
-InsertionOrderPreservingMap<string> LogicalAnyJoin::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Condition"] = condition->ToString();
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_column_data_get.cpp b/src/duckdb/src/planner/operator/logical_column_data_get.cpp
deleted file mode 100644
index 28b0e76bd..000000000
--- a/src/duckdb/src/planner/operator/logical_column_data_get.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/planner/operator/logical_column_data_get.hpp"
-
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types,
-                                           unique_ptr<ColumnDataCollection> collection_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index),
-      collection(std::move(collection_p)) {
-	D_ASSERT(types.size() > 0);
-	chunk_types = std::move(types);
-}
-
-LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types, ColumnDataCollection &to_scan)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index), collection(to_scan) {
-	D_ASSERT(types.size() > 0);
-	chunk_types = std::move(types);
-}
-
-LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types,
-                                           optionally_owned_ptr<ColumnDataCollection> collection_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index),
-      collection(std::move(collection_p)) {
-	D_ASSERT(types.size() > 0);
-	chunk_types = std::move(types);
-}
-
-vector<ColumnBinding> LogicalColumnDataGet::GetColumnBindings() {
-	return GenerateColumnBindings(table_index, chunk_types.size());
-}
-
-vector<idx_t> LogicalColumnDataGet::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalColumnDataGet::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_comparison_join.cpp b/src/duckdb/src/planner/operator/logical_comparison_join.cpp
deleted file mode 100644
index 48efe6259..000000000
--- a/src/duckdb/src/planner/operator/logical_comparison_join.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/common/enum_util.hpp"
-namespace duckdb {
-
-LogicalComparisonJoin::LogicalComparisonJoin(JoinType join_type, LogicalOperatorType logical_type)
-    : LogicalJoin(join_type, logical_type) {
-}
-
-InsertionOrderPreservingMap<string> LogicalComparisonJoin::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Join Type"] = EnumUtil::ToChars(join_type);
-
-	string conditions_info;
-	for (idx_t i = 0; i < conditions.size(); i++) {
-		if (i > 0) {
-			conditions_info += "\n";
-		}
-		auto &condition = conditions[i];
-		auto expr =
-		    make_uniq<BoundComparisonExpression>(condition.comparison, condition.left->Copy(), condition.right->Copy());
-		conditions_info += expr->ToString();
-	}
-	result["Conditions"] = conditions_info;
-	SetParamsEstimatedCardinality(result);
-
-	return result;
-}
-
-bool LogicalComparisonJoin::HasEquality(idx_t &range_count) const {
-	for (size_t c = 0; c < conditions.size(); ++c) {
-		auto &cond = conditions[c];
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-			return true;
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			++range_count;
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			break;
-		default:
-			throw NotImplementedException("Unimplemented comparison join");
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_copy_database.cpp b/src/duckdb/src/planner/operator/logical_copy_database.cpp
deleted file mode 100644
index ce67fab74..000000000
--- a/src/duckdb/src/planner/operator/logical_copy_database.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/planner/operator/logical_copy_database.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-
-namespace duckdb {
-
-LogicalCopyDatabase::LogicalCopyDatabase(unique_ptr<CopyDatabaseInfo> info_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_DATABASE), info(std::move(info_p)) {
-}
-
-LogicalCopyDatabase::LogicalCopyDatabase(unique_ptr<ParseInfo> info_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_DATABASE),
-      info(unique_ptr_cast<ParseInfo, CopyDatabaseInfo>(std::move(info_p))) {
-}
-
-LogicalCopyDatabase::~LogicalCopyDatabase() {
-}
-
-void LogicalCopyDatabase::ResolveTypes() {
-	types.emplace_back(LogicalType::BOOLEAN);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_copy_to_file.cpp b/src/duckdb/src/planner/operator/logical_copy_to_file.cpp
deleted file mode 100644
index 1b4f88f65..000000000
--- a/src/duckdb/src/planner/operator/logical_copy_to_file.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-#include "duckdb/planner/operator/logical_copy_to_file.hpp"
-
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/function/copy_function.hpp"
-#include "duckdb/function/function_serialization.hpp"
-
-namespace duckdb {
-
-vector<LogicalType> LogicalCopyToFile::GetTypesWithoutPartitions(const vector<LogicalType> &col_types,
-                                                                 const vector<idx_t> &part_cols, bool write_part_cols) {
-	if (write_part_cols || part_cols.empty()) {
-		return col_types;
-	}
-	vector<LogicalType> types;
-	set<idx_t> part_col_set(part_cols.begin(), part_cols.end());
-	for (idx_t col_idx = 0; col_idx < col_types.size(); col_idx++) {
-		if (part_col_set.find(col_idx) == part_col_set.end()) {
-			types.push_back(col_types[col_idx]);
-		}
-	}
-	return types;
-}
-
-vector<string> LogicalCopyToFile::GetNamesWithoutPartitions(const vector<string> &col_names,
-                                                            const vector<column_t> &part_cols, bool write_part_cols) {
-	if (write_part_cols || part_cols.empty()) {
-		return col_names;
-	}
-	vector<string> names;
-	set<idx_t> part_col_set(part_cols.begin(), part_cols.end());
-	for (idx_t col_idx = 0; col_idx < col_names.size(); col_idx++) {
-		if (part_col_set.find(col_idx) == part_col_set.end()) {
-			names.push_back(col_names[col_idx]);
-		}
-	}
-	return names;
-}
-
-void LogicalCopyToFile::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty(200, "file_path", file_path);
-	serializer.WriteProperty(201, "use_tmp_file", use_tmp_file);
-	serializer.WriteProperty(202, "filename_pattern", filename_pattern);
-	serializer.WriteProperty(203, "overwrite_or_ignore", overwrite_mode);
-	serializer.WriteProperty(204, "per_thread_output", per_thread_output);
-	serializer.WriteProperty(205, "partition_output", partition_output);
-	serializer.WriteProperty(206, "partition_columns", partition_columns);
-	serializer.WriteProperty(207, "names", names);
-	serializer.WriteProperty(208, "expected_types", expected_types);
-	serializer.WriteProperty(209, "copy_info", copy_info);
-
-	// Serialize function
-	serializer.WriteProperty(210, "function_name", function.name);
-
-	bool has_serialize = function.serialize;
-	serializer.WriteProperty(211, "function_has_serialize", has_serialize);
-	if (has_serialize) {
-		D_ASSERT(function.deserialize); // if serialize is set, deserialize should be set as well
-		serializer.WriteObject(212, "function_data",
-		                       [&](Serializer &obj) { function.serialize(obj, *bind_data, function); });
-	}
-
-	serializer.WriteProperty(213, "file_extension", file_extension);
-	serializer.WriteProperty(214, "rotate", rotate);
-	serializer.WriteProperty(215, "return_type", return_type);
-	serializer.WritePropertyWithDefault(216, "write_partition_columns", write_partition_columns, true);
-}
-
-unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(Deserializer &deserializer) {
-	auto file_path = deserializer.ReadProperty<string>(200, "file_path");
-	auto use_tmp_file = deserializer.ReadProperty<bool>(201, "use_tmp_file");
-	auto filename_pattern = deserializer.ReadProperty<FilenamePattern>(202, "filename_pattern");
-	auto overwrite_mode = deserializer.ReadProperty<CopyOverwriteMode>(203, "overwrite_mode");
-	auto per_thread_output = deserializer.ReadProperty<bool>(204, "per_thread_output");
-	auto partition_output = deserializer.ReadProperty<bool>(205, "partition_output");
-	auto partition_columns = deserializer.ReadProperty<vector<idx_t>>(206, "partition_columns");
-	auto names = deserializer.ReadProperty<vector<string>>(207, "names");
-	auto expected_types = deserializer.ReadProperty<vector<LogicalType>>(208, "expected_types");
-	auto copy_info =
-	    unique_ptr_cast<ParseInfo, CopyInfo>(deserializer.ReadProperty<unique_ptr<ParseInfo>>(209, "copy_info"));
-
-	// Deserialize function
-	auto &context = deserializer.Get<ClientContext &>();
-	auto name = deserializer.ReadProperty<string>(210, "function_name");
-
-	auto &func_catalog_entry =
-	    Catalog::GetEntry(context, CatalogType::COPY_FUNCTION_ENTRY, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
-	if (func_catalog_entry.type != CatalogType::COPY_FUNCTION_ENTRY) {
-		throw InternalException("DeserializeFunction - cant find catalog entry for function %s", name);
-	}
-	auto &function_entry = func_catalog_entry.Cast<CopyFunctionCatalogEntry>();
-	auto function = function_entry.function;
-	// Deserialize function data
-	unique_ptr<FunctionData> bind_data;
-	auto has_serialize = deserializer.ReadProperty<bool>(211, "function_has_serialize");
-	if (has_serialize) {
-		// Just deserialize the bind data
-		deserializer.ReadObject(212, "function_data",
-		                        [&](Deserializer &obj) { bind_data = function.deserialize(obj, function); });
-	}
-
-	auto default_extension = function.extension;
-
-	auto file_extension =
-	    deserializer.ReadPropertyWithExplicitDefault<string>(213, "file_extension", std::move(default_extension));
-
-	auto rotate = deserializer.ReadPropertyWithExplicitDefault(214, "rotate", false);
-	auto return_type =
-	    deserializer.ReadPropertyWithExplicitDefault(215, "return_type", CopyFunctionReturnType::CHANGED_ROWS);
-	auto write_partition_columns = deserializer.ReadPropertyWithExplicitDefault(216, "write_partition_columns", true);
-
-	if (!has_serialize) {
-		// If not serialized, re-bind with the copy info
-		if (!function.copy_to_bind) {
-			throw InternalException("Copy function \"%s\" has neither bind nor (de)serialize", function.name);
-		}
-
-		CopyFunctionBindInput function_bind_input(*copy_info);
-		auto names_to_write = GetNamesWithoutPartitions(names, partition_columns, write_partition_columns);
-		auto types_to_write = GetTypesWithoutPartitions(expected_types, partition_columns, write_partition_columns);
-		bind_data = function.copy_to_bind(context, function_bind_input, names_to_write, types_to_write);
-	}
-
-	auto result = make_uniq<LogicalCopyToFile>(function, std::move(bind_data), std::move(copy_info));
-	result->file_path = file_path;
-	result->use_tmp_file = use_tmp_file;
-	result->filename_pattern = filename_pattern;
-	result->file_extension = file_extension;
-	result->overwrite_mode = overwrite_mode;
-	result->per_thread_output = per_thread_output;
-	result->partition_output = partition_output;
-	result->partition_columns = partition_columns;
-	result->names = names;
-	result->expected_types = expected_types;
-	result->rotate = rotate;
-	result->return_type = return_type;
-	result->write_partition_columns = write_partition_columns;
-
-	return std::move(result);
-}
-
-vector<ColumnBinding> LogicalCopyToFile::GetColumnBindings() {
-	switch (return_type) {
-	case CopyFunctionReturnType::CHANGED_ROWS:
-		return {ColumnBinding(0, 0)};
-	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST:
-		return {ColumnBinding(0, 0), ColumnBinding(0, 1)};
-	default:
-		throw NotImplementedException("Unknown CopyFunctionReturnType");
-	}
-}
-
-idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_create.cpp b/src/duckdb/src/planner/operator/logical_create.cpp
deleted file mode 100644
index ff4aeb981..000000000
--- a/src/duckdb/src/planner/operator/logical_create.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "duckdb/planner/operator/logical_create.hpp"
-
-namespace duckdb {
-
-LogicalCreate::LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info,
-                             optional_ptr<SchemaCatalogEntry> schema)
-    : LogicalOperator(type), schema(schema), info(std::move(info)) {
-}
-
-LogicalCreate::LogicalCreate(LogicalOperatorType type, ClientContext &context, unique_ptr<CreateInfo> info_p)
-    : LogicalOperator(type), info(std::move(info_p)) {
-	this->schema = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
-}
-
-idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-void LogicalCreate::ResolveTypes() {
-	types.emplace_back(LogicalType::BIGINT);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_create_index.cpp b/src/duckdb/src/planner/operator/logical_create_index.cpp
deleted file mode 100644
index e1bc0f0ee..000000000
--- a/src/duckdb/src/planner/operator/logical_create_index.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/planner/operator/logical_create_index.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/function/function_serialization.hpp"
-
-namespace duckdb {
-
-LogicalCreateIndex::LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
-                                       TableCatalogEntry &table_p, unique_ptr<AlterTableInfo> alter_table_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), info(std::move(info_p)), table(table_p),
-      alter_table_info(std::move(alter_table_info)) {
-
-	for (auto &expr : expressions_p) {
-		unbound_expressions.push_back(expr->Copy());
-	}
-	expressions = std::move(expressions_p);
-
-	if (info->column_ids.empty()) {
-		throw BinderException("CREATE INDEX does not refer to any columns in the base table!");
-	}
-}
-
-LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info_p,
-                                       vector<unique_ptr<Expression>> expressions_p,
-                                       unique_ptr<ParseInfo> alter_table_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX),
-      info(unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info_p))), table(BindTable(context, *info)),
-      alter_table_info(unique_ptr_cast<ParseInfo, AlterTableInfo>(std::move(alter_table_info))) {
-
-	for (auto &expr : expressions_p) {
-		unbound_expressions.push_back(expr->Copy());
-	}
-	expressions = std::move(expressions_p);
-}
-
-void LogicalCreateIndex::ResolveTypes() {
-	types.emplace_back(LogicalType::BIGINT);
-}
-
-TableCatalogEntry &LogicalCreateIndex::BindTable(ClientContext &context, CreateIndexInfo &info_p) {
-	auto &catalog = info_p.catalog;
-	auto &schema = info_p.schema;
-	auto &table_name = info_p.table;
-	return Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_create_table.cpp b/src/duckdb/src/planner/operator/logical_create_table.cpp
deleted file mode 100644
index 76b2cc91f..000000000
--- a/src/duckdb/src/planner/operator/logical_create_table.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/planner/operator/logical_create_table.hpp"
-
-#include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-LogicalCreateTable::LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
-}
-
-LogicalCreateTable::LogicalCreateTable(ClientContext &context, unique_ptr<CreateInfo> unbound_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE),
-      schema(Catalog::GetSchema(context, unbound_info->catalog, unbound_info->schema)) {
-	D_ASSERT(unbound_info->type == CatalogType::TABLE_ENTRY);
-	auto binder = Binder::CreateBinder(context);
-	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));
-}
-
-idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-void LogicalCreateTable::ResolveTypes() {
-	types.emplace_back(LogicalType::BIGINT);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_cross_product.cpp b/src/duckdb/src/planner/operator/logical_cross_product.cpp
deleted file mode 100644
index 263dcf494..000000000
--- a/src/duckdb/src/planner/operator/logical_cross_product.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_cross_product.hpp"
-
-namespace duckdb {
-
-LogicalCrossProduct::LogicalCrossProduct(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right)
-    : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_CROSS_PRODUCT, std::move(left), std::move(right)) {
-}
-
-unique_ptr<LogicalOperator> LogicalCrossProduct::Create(unique_ptr<LogicalOperator> left,
-                                                        unique_ptr<LogicalOperator> right) {
-	if (left->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
-		return right;
-	}
-	if (right->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
-		return left;
-	}
-	return make_uniq<LogicalCrossProduct>(std::move(left), std::move(right));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_cteref.cpp b/src/duckdb/src/planner/operator/logical_cteref.cpp
deleted file mode 100644
index e82b1448a..000000000
--- a/src/duckdb/src/planner/operator/logical_cteref.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/planner/operator/logical_cteref.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-InsertionOrderPreservingMap<string> LogicalCTERef::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["CTE Index"] = StringUtil::Format("%llu", cte_index);
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-vector<idx_t> LogicalCTERef::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalCTERef::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_delete.cpp b/src/duckdb/src/planner/operator/logical_delete.cpp
deleted file mode 100644
index d82c3bfd8..000000000
--- a/src/duckdb/src/planner/operator/logical_delete.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/planner/operator/logical_delete.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-
-namespace duckdb {
-
-LogicalDelete::LogicalDelete(TableCatalogEntry &table, idx_t table_index)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(table_index),
-      return_chunk(false) {
-}
-
-LogicalDelete::LogicalDelete(ClientContext &context, const unique_ptr<CreateInfo> &table_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE),
-      table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
-                                                 table_info->Cast<CreateTableInfo>().table)) {
-	auto binder = Binder::CreateBinder(context);
-	bound_constraints = binder->BindConstraints(table);
-}
-
-idx_t LogicalDelete::EstimateCardinality(ClientContext &context) {
-	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
-}
-
-vector<idx_t> LogicalDelete::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-vector<ColumnBinding> LogicalDelete::GetColumnBindings() {
-	if (return_chunk) {
-		return GenerateColumnBindings(table_index, table.GetTypes().size());
-	}
-	return {ColumnBinding(0, 0)};
-}
-
-void LogicalDelete::ResolveTypes() {
-	if (return_chunk) {
-		types = table.GetTypes();
-	} else {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-}
-
-string LogicalDelete::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_delim_get.cpp b/src/duckdb/src/planner/operator/logical_delim_get.cpp
deleted file mode 100644
index 3cd63f3a0..000000000
--- a/src/duckdb/src/planner/operator/logical_delim_get.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_delim_get.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<idx_t> LogicalDelimGet::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalDelimGet::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_dependent_join.cpp b/src/duckdb/src/planner/operator/logical_dependent_join.cpp
deleted file mode 100644
index 308aa15d1..000000000
--- a/src/duckdb/src/planner/operator/logical_dependent_join.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
-
-namespace duckdb {
-
-LogicalDependentJoin::LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-                                           vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
-                                           unique_ptr<Expression> condition)
-    : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_DEPENDENT_JOIN), join_condition(std::move(condition)),
-      correlated_columns(std::move(correlated_columns)) {
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-}
-
-unique_ptr<LogicalOperator> LogicalDependentJoin::Create(unique_ptr<LogicalOperator> left,
-                                                         unique_ptr<LogicalOperator> right,
-                                                         vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
-                                                         unique_ptr<Expression> condition) {
-	return make_uniq<LogicalDependentJoin>(std::move(left), std::move(right), std::move(correlated_columns), type,
-	                                       std::move(condition));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_distinct.cpp b/src/duckdb/src/planner/operator/logical_distinct.cpp
deleted file mode 100644
index f6983b5e8..000000000
--- a/src/duckdb/src/planner/operator/logical_distinct.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
-
-namespace duckdb {
-
-LogicalDistinct::LogicalDistinct(DistinctType distinct_type)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
-}
-LogicalDistinct::LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
-      distinct_targets(std::move(targets)) {
-}
-
-InsertionOrderPreservingMap<string> LogicalDistinct::ParamsToString() const {
-	auto result = LogicalOperator::ParamsToString();
-	if (!distinct_targets.empty()) {
-		result["Distinct Targets"] =
-		    StringUtil::Join(distinct_targets, distinct_targets.size(), "\n",
-		                     [](const unique_ptr<Expression> &child) { return child->GetName(); });
-	}
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-void LogicalDistinct::ResolveTypes() {
-	types = children[0]->types;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_dummy_scan.cpp b/src/duckdb/src/planner/operator/logical_dummy_scan.cpp
deleted file mode 100644
index 13219fba2..000000000
--- a/src/duckdb/src/planner/operator/logical_dummy_scan.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_dummy_scan.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<idx_t> LogicalDummyScan::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalDummyScan::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_empty_result.cpp b/src/duckdb/src/planner/operator/logical_empty_result.cpp
deleted file mode 100644
index 28b014ff2..000000000
--- a/src/duckdb/src/planner/operator/logical_empty_result.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-
-namespace duckdb {
-
-LogicalEmptyResult::LogicalEmptyResult(unique_ptr<LogicalOperator> op)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-
-	this->bindings = op->GetColumnBindings();
-
-	op->ResolveOperatorTypes();
-	this->return_types = op->types;
-}
-
-LogicalEmptyResult::LogicalEmptyResult() : LogicalOperator(LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_export.cpp b/src/duckdb/src/planner/operator/logical_export.cpp
deleted file mode 100644
index 046aff3e0..000000000
--- a/src/duckdb/src/planner/operator/logical_export.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "duckdb/planner/operator/logical_export.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-
-namespace duckdb {
-
-LogicalExport::LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info,
-                             unique_ptr<BoundExportData> exported_tables)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), copy_info(std::move(copy_info)),
-      function(std::move(function)), exported_tables(std::move(exported_tables)) {
-}
-
-LogicalExport::LogicalExport(ClientContext &context, unique_ptr<ParseInfo> copy_info_p,
-                             unique_ptr<ParseInfo> exported_tables_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT),
-      copy_info(unique_ptr_cast<ParseInfo, CopyInfo>(std::move(copy_info_p))),
-      function(GetCopyFunction(context, *copy_info)),
-      exported_tables(unique_ptr_cast<ParseInfo, BoundExportData>(std::move(exported_tables_p))) {
-}
-
-CopyFunction LogicalExport::GetCopyFunction(ClientContext &context, CopyInfo &info) {
-	auto &copy_entry =
-	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.format);
-	return copy_entry.function;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_expression_get.cpp b/src/duckdb/src/planner/operator/logical_expression_get.cpp
deleted file mode 100644
index 6f9fe0451..000000000
--- a/src/duckdb/src/planner/operator/logical_expression_get.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_expression_get.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<idx_t> LogicalExpressionGet::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalExpressionGet::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_extension_operator.cpp b/src/duckdb/src/planner/operator/logical_extension_operator.cpp
deleted file mode 100644
index 2e0cb6d15..000000000
--- a/src/duckdb/src/planner/operator/logical_extension_operator.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "duckdb/planner/operator/logical_extension_operator.hpp"
-#include "duckdb/execution/column_binding_resolver.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings) {
-	// general case
-	// first visit the children of this operator
-	for (auto &child : children) {
-		res.VisitOperator(*child);
-	}
-	// now visit the expressions of this operator to resolve any bound column references
-	for (auto &expression : expressions) {
-		res.VisitExpression(&expression);
-	}
-	// finally update the current set of bindings to the current set of column bindings
-	bindings = GetColumnBindings();
-}
-
-void LogicalExtensionOperator::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty(200, "extension_name", GetExtensionName());
-}
-
-unique_ptr<LogicalOperator> LogicalExtensionOperator::Deserialize(Deserializer &deserializer) {
-	auto &config = DBConfig::GetConfig(deserializer.Get<ClientContext &>());
-	auto extension_name = deserializer.ReadProperty<string>(200, "extension_name");
-	for (auto &extension : config.operator_extensions) {
-		if (extension->GetName() == extension_name) {
-			return extension->Deserialize(deserializer);
-		}
-	}
-	throw SerializationException("No deserialization method exists for extension: " + extension_name);
-}
-
-string LogicalExtensionOperator::GetExtensionName() const {
-	throw SerializationException("LogicalExtensionOperator::GetExtensionName not implemented which is required for "
-	                             "serializing extension operators");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_filter.cpp b/src/duckdb/src/planner/operator/logical_filter.cpp
deleted file mode 100644
index aa9b21642..000000000
--- a/src/duckdb/src/planner/operator/logical_filter.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "duckdb/planner/operator/logical_filter.hpp"
-#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
-
-namespace duckdb {
-
-LogicalFilter::LogicalFilter(unique_ptr<Expression> expression) : LogicalOperator(LogicalOperatorType::LOGICAL_FILTER) {
-	expressions.push_back(std::move(expression));
-	SplitPredicates(expressions);
-}
-
-LogicalFilter::LogicalFilter() : LogicalOperator(LogicalOperatorType::LOGICAL_FILTER) {
-}
-
-void LogicalFilter::ResolveTypes() {
-	types = MapTypes(children[0]->types, projection_map);
-}
-
-vector<ColumnBinding> LogicalFilter::GetColumnBindings() {
-	return MapBindings(children[0]->GetColumnBindings(), projection_map);
-}
-
-// Split the predicates separated by AND statements
-// These are the predicates that are safe to push down because all of them MUST
-// be true
-bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions) {
-	bool found_conjunction = false;
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (expressions[i]->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-			auto &conjunction = expressions[i]->Cast<BoundConjunctionExpression>();
-			found_conjunction = true;
-			// AND expression, append the other children
-			for (idx_t k = 1; k < conjunction.children.size(); k++) {
-				expressions.push_back(std::move(conjunction.children[k]));
-			}
-			// replace this expression with the first child of the conjunction
-			expressions[i] = std::move(conjunction.children[0]);
-			// we move back by one so the right child is checked again
-			// in case it is an AND expression as well
-			i--;
-		}
-	}
-	return found_conjunction;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_get.cpp b/src/duckdb/src/planner/operator/logical_get.cpp
deleted file mode 100644
index be7b5aa5d..000000000
--- a/src/duckdb/src/planner/operator/logical_get.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-#include "duckdb/planner/operator/logical_get.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/function/function_serialization.hpp"
-#include "duckdb/function/table/table_scan.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-
-namespace duckdb {
-
-LogicalGet::LogicalGet() : LogicalOperator(LogicalOperatorType::LOGICAL_GET) {
-}
-
-LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
-                       vector<LogicalType> returned_types, vector<string> returned_names, LogicalType rowid_type)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(std::move(function)),
-      bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)),
-      extra_info(), rowid_type(std::move(rowid_type)) {
-}
-
-optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
-	if (!function.get_bind_info) {
-		return nullptr;
-	}
-	return function.get_bind_info(bind_data.get()).table;
-}
-
-InsertionOrderPreservingMap<string> LogicalGet::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-
-	string filters_info;
-	bool first_item = true;
-	for (auto &kv : table_filters.filters) {
-		auto &column_index = kv.first;
-		auto &filter = kv.second;
-		if (column_index < names.size()) {
-			if (!first_item) {
-				filters_info += "\n";
-			}
-			first_item = false;
-			filters_info += filter->ToString(names[column_index]);
-		}
-	}
-	result["Filters"] = filters_info;
-
-	if (extra_info.sample_options) {
-		result["Sample Method"] = "System: " + extra_info.sample_options->sample_size.ToString() + "%";
-	}
-
-	if (!extra_info.file_filters.empty()) {
-		result["File Filters"] = extra_info.file_filters;
-		if (extra_info.filtered_files.IsValid() && extra_info.total_files.IsValid()) {
-			result["Scanning Files"] = StringUtil::Format("%llu/%llu", extra_info.filtered_files.GetIndex(),
-			                                              extra_info.total_files.GetIndex());
-		}
-	}
-
-	if (function.to_string) {
-		TableFunctionToStringInput input(function, bind_data.get());
-		auto to_string_result = function.to_string(input);
-		for (const auto &it : to_string_result) {
-			result[it.first] = it.second;
-		}
-	}
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-void LogicalGet::SetColumnIds(vector<ColumnIndex> &&column_ids) {
-	this->column_ids = std::move(column_ids);
-}
-
-void LogicalGet::AddColumnId(column_t column_id) {
-	column_ids.emplace_back(column_id);
-}
-
-void LogicalGet::ClearColumnIds() {
-	column_ids.clear();
-}
-
-const vector<ColumnIndex> &LogicalGet::GetColumnIds() const {
-	return column_ids;
-}
-
-vector<ColumnIndex> &LogicalGet::GetMutableColumnIds() {
-	return column_ids;
-}
-
-vector<ColumnBinding> LogicalGet::GetColumnBindings() {
-	if (column_ids.empty()) {
-		return {ColumnBinding(table_index, 0)};
-	}
-	vector<ColumnBinding> result;
-	if (projection_ids.empty()) {
-		for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
-			result.emplace_back(table_index, col_idx);
-		}
-	} else {
-		for (auto proj_id : projection_ids) {
-			result.emplace_back(table_index, proj_id);
-		}
-	}
-	if (!projected_input.empty()) {
-		if (children.size() != 1) {
-			throw InternalException("LogicalGet::project_input can only be set for table-in-out functions");
-		}
-		auto child_bindings = children[0]->GetColumnBindings();
-		for (auto entry : projected_input) {
-			D_ASSERT(entry < child_bindings.size());
-			result.emplace_back(child_bindings[entry]);
-		}
-	}
-	return result;
-}
-
-void LogicalGet::ResolveTypes() {
-	if (column_ids.empty()) {
-		column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
-	}
-	types.clear();
-	if (projection_ids.empty()) {
-		for (auto &index : column_ids) {
-			if (index.IsRowIdColumn()) {
-				types.emplace_back(LogicalType(rowid_type));
-			} else {
-				types.push_back(returned_types[index.GetPrimaryIndex()]);
-			}
-		}
-	} else {
-		for (auto &proj_index : projection_ids) {
-			auto &index = column_ids[proj_index];
-			if (index.IsRowIdColumn()) {
-				types.emplace_back(LogicalType(rowid_type));
-			} else {
-				types.push_back(returned_types[index.GetPrimaryIndex()]);
-			}
-		}
-	}
-	if (!projected_input.empty()) {
-		if (children.size() != 1) {
-			throw InternalException("LogicalGet::project_input can only be set for table-in-out functions");
-		}
-		for (auto entry : projected_input) {
-			D_ASSERT(entry < children[0]->types.size());
-			types.push_back(children[0]->types[entry]);
-		}
-	}
-}
-
-idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
-	// join order optimizer does better cardinality estimation.
-	if (has_estimated_cardinality) {
-		return estimated_cardinality;
-	}
-	if (function.cardinality) {
-		auto node_stats = function.cardinality(context, bind_data.get());
-		if (node_stats && node_stats->has_estimated_cardinality) {
-			return node_stats->estimated_cardinality;
-		}
-	}
-	if (!children.empty()) {
-		return children[0]->EstimateCardinality(context);
-	}
-	return 1;
-}
-
-void LogicalGet::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty(200, "table_index", table_index);
-	serializer.WriteProperty(201, "returned_types", returned_types);
-	serializer.WriteProperty(202, "names", names);
-	/* [Deleted] (vector<column_t>) "column_ids" */
-	serializer.WriteProperty(204, "projection_ids", projection_ids);
-	serializer.WriteProperty(205, "table_filters", table_filters);
-	FunctionSerializer::Serialize(serializer, function, bind_data.get());
-	if (!function.serialize) {
-		D_ASSERT(!function.serialize);
-		// no serialize method: serialize input values and named_parameters for rebinding purposes
-		serializer.WriteProperty(206, "parameters", parameters);
-		serializer.WriteProperty(207, "named_parameters", named_parameters);
-		serializer.WriteProperty(208, "input_table_types", input_table_types);
-		serializer.WriteProperty(209, "input_table_names", input_table_names);
-	}
-	serializer.WriteProperty(210, "projected_input", projected_input);
-	serializer.WritePropertyWithDefault(211, "column_indexes", column_ids);
-}
-
-unique_ptr<LogicalOperator> LogicalGet::Deserialize(Deserializer &deserializer) {
-	vector<column_t> legacy_column_ids;
-
-	auto result = unique_ptr<LogicalGet>(new LogicalGet());
-	deserializer.ReadProperty(200, "table_index", result->table_index);
-	deserializer.ReadProperty(201, "returned_types", result->returned_types);
-	deserializer.ReadProperty(202, "names", result->names);
-	deserializer.ReadPropertyWithDefault(203, "column_ids", legacy_column_ids);
-	deserializer.ReadProperty(204, "projection_ids", result->projection_ids);
-	deserializer.ReadProperty(205, "table_filters", result->table_filters);
-	auto entry = FunctionSerializer::DeserializeBase<TableFunction, TableFunctionCatalogEntry>(
-	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
-	result->function = entry.first;
-	auto &function = result->function;
-	auto has_serialize = entry.second;
-	unique_ptr<FunctionData> bind_data;
-	if (!has_serialize) {
-		deserializer.ReadProperty(206, "parameters", result->parameters);
-		deserializer.ReadProperty(207, "named_parameters", result->named_parameters);
-		deserializer.ReadProperty(208, "input_table_types", result->input_table_types);
-		deserializer.ReadProperty(209, "input_table_names", result->input_table_names);
-	} else {
-		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
-	}
-	deserializer.ReadProperty(210, "projected_input", result->projected_input);
-	deserializer.ReadPropertyWithDefault(211, "column_indexes", result->column_ids);
-	if (!legacy_column_ids.empty()) {
-		if (!result->column_ids.empty()) {
-			throw SerializationException(
-			    "LogicalGet::Deserialize - either column_ids or column_indexes should be set - not both");
-		}
-		for (auto &col_id : legacy_column_ids) {
-			result->column_ids.emplace_back(col_id);
-		}
-	}
-	if (!has_serialize) {
-		TableFunctionRef empty_ref;
-		TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
-		                             result->input_table_names, function.function_info.get(), nullptr, result->function,
-		                             empty_ref);
-
-		vector<LogicalType> bind_return_types;
-		vector<string> bind_names;
-		if (!function.bind) {
-			throw InternalException("Table function \"%s\" has neither bind nor (de)serialize", function.name);
-		}
-		bind_data = function.bind(deserializer.Get<ClientContext &>(), input, bind_return_types, bind_names);
-
-		for (auto &col_id : result->column_ids) {
-			if (col_id.IsRowIdColumn()) {
-				// rowid
-				continue;
-			}
-			auto idx = col_id.GetPrimaryIndex();
-			auto &ret_type = result->returned_types[idx];
-			auto &col_name = result->names[idx];
-			if (bind_return_types[idx] != ret_type) {
-				throw SerializationException("Table function deserialization failure in function \"%s\" - column with "
-				                             "name %s was serialized with type %s, but now has type %s",
-				                             function.name, col_name, ret_type, bind_return_types[idx]);
-			}
-		}
-		result->returned_types = std::move(bind_return_types);
-	}
-	result->bind_data = std::move(bind_data);
-	return std::move(result);
-}
-
-vector<idx_t> LogicalGet::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalGet::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return StringUtil::Upper(function.name) + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return StringUtil::Upper(function.name);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_insert.cpp b/src/duckdb/src/planner/operator/logical_insert.cpp
deleted file mode 100644
index 10f115697..000000000
--- a/src/duckdb/src/planner/operator/logical_insert.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/planner/operator/logical_insert.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-
-namespace duckdb {
-
-LogicalInsert::LogicalInsert(TableCatalogEntry &table, idx_t table_index)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT), table(table), table_index(table_index), return_chunk(false),
-      action_type(OnConflictAction::THROW), update_is_del_and_insert(false) {
-}
-
-LogicalInsert::LogicalInsert(ClientContext &context, const unique_ptr<CreateInfo> table_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT),
-      table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
-                                                 table_info->Cast<CreateTableInfo>().table)) {
-	auto binder = Binder::CreateBinder(context);
-	bound_constraints = binder->BindConstraints(table);
-}
-
-idx_t LogicalInsert::EstimateCardinality(ClientContext &context) {
-	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
-}
-
-vector<idx_t> LogicalInsert::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-vector<ColumnBinding> LogicalInsert::GetColumnBindings() {
-	if (return_chunk) {
-		return GenerateColumnBindings(table_index, table.GetTypes().size());
-	}
-	return {ColumnBinding(0, 0)};
-}
-
-void LogicalInsert::ResolveTypes() {
-	if (return_chunk) {
-		types = table.GetTypes();
-	} else {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-}
-
-string LogicalInsert::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_join.cpp b/src/duckdb/src/planner/operator/logical_join.cpp
deleted file mode 100644
index 9545e6602..000000000
--- a/src/duckdb/src/planner/operator/logical_join.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "duckdb/planner/operator/logical_join.hpp"
-
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-
-namespace duckdb {
-
-LogicalJoin::LogicalJoin(JoinType join_type, LogicalOperatorType logical_type)
-    : LogicalOperator(logical_type), join_type(join_type) {
-}
-
-vector<ColumnBinding> LogicalJoin::GetColumnBindings() {
-	auto left_bindings = MapBindings(children[0]->GetColumnBindings(), left_projection_map);
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		// for SEMI and ANTI join we only project the left hand side
-		return left_bindings;
-	}
-
-	if (join_type == JoinType::MARK) {
-		// for MARK join we project the left hand side plus the MARK column
-		left_bindings.emplace_back(mark_index, 0);
-		return left_bindings;
-	}
-	// for other join types we project both the LHS and the RHS
-	auto right_bindings = MapBindings(children[1]->GetColumnBindings(), right_projection_map);
-	if (join_type == JoinType::RIGHT_SEMI || join_type == JoinType::RIGHT_ANTI) {
-		return right_bindings;
-	}
-	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
-	return left_bindings;
-}
-
-void LogicalJoin::ResolveTypes() {
-	types = MapTypes(children[0]->types, left_projection_map);
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		// for SEMI and ANTI join we only project the left hand side
-		return;
-	}
-	if (join_type == JoinType::MARK) {
-		// for MARK join we project the left hand side, plus a BOOLEAN column indicating the MARK
-		types.emplace_back(LogicalType::BOOLEAN);
-		return;
-	}
-	// for any other join we project both sides
-	auto right_types = MapTypes(children[1]->types, right_projection_map);
-	if (join_type == JoinType::RIGHT_SEMI || join_type == JoinType::RIGHT_ANTI) {
-		types = right_types;
-		return;
-	}
-	types.insert(types.end(), right_types.begin(), right_types.end());
-}
-
-void LogicalJoin::GetTableReferences(LogicalOperator &op, unordered_set<idx_t> &bindings) {
-	auto column_bindings = op.GetColumnBindings();
-	for (auto binding : column_bindings) {
-		bindings.insert(binding.table_index);
-	}
-}
-
-void LogicalJoin::GetExpressionBindings(Expression &expr, unordered_set<idx_t> &bindings) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expr.Cast<BoundColumnRefExpression>();
-		D_ASSERT(colref.depth == 0);
-		bindings.insert(colref.binding.table_index);
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { GetExpressionBindings(child, bindings); });
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_limit.cpp b/src/duckdb/src/planner/operator/logical_limit.cpp
deleted file mode 100644
index 332da4ab5..000000000
--- a/src/duckdb/src/planner/operator/logical_limit.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/planner/operator/logical_limit.hpp"
-
-namespace duckdb {
-
-LogicalLimit::LogicalLimit(BoundLimitNode limit_val, BoundLimitNode offset_val)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(std::move(limit_val)),
-      offset_val(std::move(offset_val)) {
-}
-
-vector<ColumnBinding> LogicalLimit::GetColumnBindings() {
-	return children[0]->GetColumnBindings();
-}
-
-idx_t LogicalLimit::EstimateCardinality(ClientContext &context) {
-	auto child_cardinality = children[0]->EstimateCardinality(context);
-	switch (limit_val.Type()) {
-	case LimitNodeType::CONSTANT_VALUE:
-		if (limit_val.GetConstantValue() < child_cardinality) {
-			child_cardinality = limit_val.GetConstantValue();
-		}
-		break;
-	case LimitNodeType::CONSTANT_PERCENTAGE:
-		child_cardinality = idx_t(double(child_cardinality) * limit_val.GetConstantPercentage());
-		break;
-	default:
-		break;
-	}
-	return child_cardinality;
-}
-
-void LogicalLimit::ResolveTypes() {
-	types = children[0]->types;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_materialized_cte.cpp b/src/duckdb/src/planner/operator/logical_materialized_cte.cpp
deleted file mode 100644
index 043695bbd..000000000
--- a/src/duckdb/src/planner/operator/logical_materialized_cte.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/planner/operator/logical_materialized_cte.hpp"
-
-namespace duckdb {
-
-InsertionOrderPreservingMap<string> LogicalMaterializedCTE::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	result["Table Index"] = StringUtil::Format("%llu", table_index);
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-vector<idx_t> LogicalMaterializedCTE::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_order.cpp b/src/duckdb/src/planner/operator/logical_order.cpp
deleted file mode 100644
index bf904c3f3..000000000
--- a/src/duckdb/src/planner/operator/logical_order.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "duckdb/planner/operator/logical_order.hpp"
-
-namespace duckdb {
-
-LogicalOrder::LogicalOrder(vector<BoundOrderByNode> orders)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
-}
-
-vector<ColumnBinding> LogicalOrder::GetColumnBindings() {
-	auto child_bindings = children[0]->GetColumnBindings();
-	if (!HasProjectionMap()) {
-		return child_bindings;
-	}
-	return MapBindings(child_bindings, projection_map);
-}
-
-InsertionOrderPreservingMap<string> LogicalOrder::ParamsToString() const {
-	InsertionOrderPreservingMap<string> result;
-	string orders_info;
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (i > 0) {
-			orders_info += "\n";
-		}
-		orders_info += orders[i].expression->GetName();
-	}
-	result["__order_by__"] = orders_info;
-	SetParamsEstimatedCardinality(result);
-	return result;
-}
-
-void LogicalOrder::ResolveTypes() {
-	const auto child_types = children[0]->types;
-	if (!HasProjectionMap()) {
-		types = child_types;
-	} else {
-		types = MapTypes(child_types, projection_map);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_pivot.cpp b/src/duckdb/src/planner/operator/logical_pivot.cpp
deleted file mode 100644
index b5fbbd2e9..000000000
--- a/src/duckdb/src/planner/operator/logical_pivot.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "duckdb/planner/operator/logical_pivot.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-LogicalPivot::LogicalPivot() : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT) {
-}
-
-LogicalPivot::LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT), pivot_index(pivot_idx), bound_pivot(std::move(info_p)) {
-	D_ASSERT(plan);
-	children.push_back(std::move(plan));
-}
-
-vector<ColumnBinding> LogicalPivot::GetColumnBindings() {
-	vector<ColumnBinding> result;
-	for (idx_t i = 0; i < bound_pivot.types.size(); i++) {
-		result.emplace_back(pivot_index, i);
-	}
-	return result;
-}
-
-vector<idx_t> LogicalPivot::GetTableIndex() const {
-	return vector<idx_t> {pivot_index};
-}
-
-void LogicalPivot::ResolveTypes() {
-	this->types = bound_pivot.types;
-}
-
-string LogicalPivot::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", pivot_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_positional_join.cpp b/src/duckdb/src/planner/operator/logical_positional_join.cpp
deleted file mode 100644
index 754313ca5..000000000
--- a/src/duckdb/src/planner/operator/logical_positional_join.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/planner/operator/logical_positional_join.hpp"
-
-namespace duckdb {
-
-LogicalPositionalJoin::LogicalPositionalJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right)
-    : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_POSITIONAL_JOIN, std::move(left), std::move(right)) {
-	SetEstimatedCardinality(MaxValue(children[0]->estimated_cardinality, children[1]->estimated_cardinality));
-}
-
-unique_ptr<LogicalOperator> LogicalPositionalJoin::Create(unique_ptr<LogicalOperator> left,
-                                                          unique_ptr<LogicalOperator> right) {
-	if (left->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
-		return right;
-	}
-	if (right->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
-		return left;
-	}
-	return make_uniq<LogicalPositionalJoin>(std::move(left), std::move(right));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_pragma.cpp b/src/duckdb/src/planner/operator/logical_pragma.cpp
deleted file mode 100644
index e694c366a..000000000
--- a/src/duckdb/src/planner/operator/logical_pragma.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "duckdb/planner/operator/logical_pragma.hpp"
-
-namespace duckdb {
-
-idx_t LogicalPragma::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_prepare.cpp b/src/duckdb/src/planner/operator/logical_prepare.cpp
deleted file mode 100644
index d1f067a52..000000000
--- a/src/duckdb/src/planner/operator/logical_prepare.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "duckdb/planner/operator/logical_prepare.hpp"
-
-namespace duckdb {
-
-idx_t LogicalPrepare::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_projection.cpp b/src/duckdb/src/planner/operator/logical_projection.cpp
deleted file mode 100644
index 141773a6e..000000000
--- a/src/duckdb/src/planner/operator/logical_projection.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "duckdb/planner/operator/logical_projection.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-LogicalProjection::LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_PROJECTION, std::move(select_list)), table_index(table_index) {
-}
-
-vector<ColumnBinding> LogicalProjection::GetColumnBindings() {
-	return GenerateColumnBindings(table_index, expressions.size());
-}
-
-void LogicalProjection::ResolveTypes() {
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-}
-
-vector<idx_t> LogicalProjection::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalProjection::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_recursive_cte.cpp b/src/duckdb/src/planner/operator/logical_recursive_cte.cpp
deleted file mode 100644
index b6867c0c1..000000000
--- a/src/duckdb/src/planner/operator/logical_recursive_cte.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_recursive_cte.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalRecursiveCTE::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_reset.cpp b/src/duckdb/src/planner/operator/logical_reset.cpp
deleted file mode 100644
index 12d663f5e..000000000
--- a/src/duckdb/src/planner/operator/logical_reset.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "duckdb/planner/operator/logical_reset.hpp"
-
-namespace duckdb {
-
-idx_t LogicalReset::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_sample.cpp b/src/duckdb/src/planner/operator/logical_sample.cpp
deleted file mode 100644
index 59e14e6eb..000000000
--- a/src/duckdb/src/planner/operator/logical_sample.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/planner/operator/logical_sample.hpp"
-
-namespace duckdb {
-
-LogicalSample::LogicalSample() : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE) {
-}
-
-LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(std::move(sample_options_p)) {
-	children.push_back(std::move(child));
-}
-
-vector<ColumnBinding> LogicalSample::GetColumnBindings() {
-	return children[0]->GetColumnBindings();
-}
-
-idx_t LogicalSample::EstimateCardinality(ClientContext &context) {
-	auto child_cardinality = children[0]->EstimateCardinality(context);
-	if (sample_options->is_percentage) {
-		double sample_cardinality =
-		    double(child_cardinality) * (sample_options->sample_size.GetValue<double>() / 100.0);
-		if (sample_cardinality > double(child_cardinality)) {
-			return child_cardinality;
-		}
-		return idx_t(sample_cardinality);
-	} else {
-		auto sample_size = sample_options->sample_size.GetValue<uint64_t>();
-		if (sample_size < child_cardinality) {
-			return sample_size;
-		}
-	}
-	return child_cardinality;
-}
-
-void LogicalSample::ResolveTypes() {
-	types = children[0]->types;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_set.cpp b/src/duckdb/src/planner/operator/logical_set.cpp
deleted file mode 100644
index 0f17cac54..000000000
--- a/src/duckdb/src/planner/operator/logical_set.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "duckdb/planner/operator/logical_set.hpp"
-
-namespace duckdb {
-
-idx_t LogicalSet::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_set_operation.cpp b/src/duckdb/src/planner/operator/logical_set_operation.cpp
deleted file mode 100644
index 72da2e053..000000000
--- a/src/duckdb/src/planner/operator/logical_set_operation.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_set_operation.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<idx_t> LogicalSetOperation::GetTableIndex() const {
-	return vector<idx_t> {table_index};
-}
-
-string LogicalSetOperation::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_simple.cpp b/src/duckdb/src/planner/operator/logical_simple.cpp
deleted file mode 100644
index 45982c443..000000000
--- a/src/duckdb/src/planner/operator/logical_simple.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/planner/operator/logical_simple.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/parser/parsed_data/load_info.hpp"
-#include "duckdb/parser/parsed_data/transaction_info.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/parser/parsed_data/detach_info.hpp"
-
-namespace duckdb {
-
-idx_t LogicalSimple::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_top_n.cpp b/src/duckdb/src/planner/operator/logical_top_n.cpp
deleted file mode 100644
index 098fcf1bb..000000000
--- a/src/duckdb/src/planner/operator/logical_top_n.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/planner/operator/logical_top_n.hpp"
-
-namespace duckdb {
-
-LogicalTopN::LogicalTopN(vector<BoundOrderByNode> orders, idx_t limit, idx_t offset)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_TOP_N), orders(std::move(orders)), limit(limit), offset(offset) {
-}
-
-LogicalTopN::~LogicalTopN() {
-}
-
-idx_t LogicalTopN::EstimateCardinality(ClientContext &context) {
-	auto child_cardinality = LogicalOperator::EstimateCardinality(context);
-	if (child_cardinality < limit) {
-		return child_cardinality;
-	}
-	return limit;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_unconditional_join.cpp b/src/duckdb/src/planner/operator/logical_unconditional_join.cpp
deleted file mode 100644
index 3a14f5d81..000000000
--- a/src/duckdb/src/planner/operator/logical_unconditional_join.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/planner/operator/logical_unconditional_join.hpp"
-
-namespace duckdb {
-
-LogicalUnconditionalJoin::LogicalUnconditionalJoin(LogicalOperatorType logical_type, unique_ptr<LogicalOperator> left,
-                                                   unique_ptr<LogicalOperator> right)
-    : LogicalOperator(logical_type) {
-	D_ASSERT(left);
-	D_ASSERT(right);
-	children.push_back(std::move(left));
-	children.push_back(std::move(right));
-}
-
-vector<ColumnBinding> LogicalUnconditionalJoin::GetColumnBindings() {
-	auto left_bindings = children[0]->GetColumnBindings();
-	auto right_bindings = children[1]->GetColumnBindings();
-	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
-	return left_bindings;
-}
-
-void LogicalUnconditionalJoin::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	types.insert(types.end(), children[1]->types.begin(), children[1]->types.end());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_unnest.cpp b/src/duckdb/src/planner/operator/logical_unnest.cpp
deleted file mode 100644
index 7d0932cfa..000000000
--- a/src/duckdb/src/planner/operator/logical_unnest.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/planner/operator/logical_unnest.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<ColumnBinding> LogicalUnnest::GetColumnBindings() {
-	auto child_bindings = children[0]->GetColumnBindings();
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		child_bindings.emplace_back(unnest_index, i);
-	}
-	return child_bindings;
-}
-
-void LogicalUnnest::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-}
-
-vector<idx_t> LogicalUnnest::GetTableIndex() const {
-	return vector<idx_t> {unnest_index};
-}
-
-string LogicalUnnest::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", unnest_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_update.cpp b/src/duckdb/src/planner/operator/logical_update.cpp
deleted file mode 100644
index 386264478..000000000
--- a/src/duckdb/src/planner/operator/logical_update.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-LogicalUpdate::LogicalUpdate(TableCatalogEntry &table)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
-}
-
-LogicalUpdate::LogicalUpdate(ClientContext &context, const unique_ptr<CreateInfo> &table_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE),
-      table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
-                                                 table_info->Cast<CreateTableInfo>().table)) {
-	auto binder = Binder::CreateBinder(context);
-	bound_constraints = binder->BindConstraints(table);
-}
-
-idx_t LogicalUpdate::EstimateCardinality(ClientContext &context) {
-	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
-}
-
-vector<ColumnBinding> LogicalUpdate::GetColumnBindings() {
-	if (return_chunk) {
-		return GenerateColumnBindings(table_index, table.GetTypes().size());
-	}
-	return {ColumnBinding(0, 0)};
-}
-
-void LogicalUpdate::ResolveTypes() {
-	if (return_chunk) {
-		types = table.GetTypes();
-	} else {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-}
-
-string LogicalUpdate::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_vacuum.cpp b/src/duckdb/src/planner/operator/logical_vacuum.cpp
deleted file mode 100644
index 36352a0ea..000000000
--- a/src/duckdb/src/planner/operator/logical_vacuum.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "duckdb/planner/operator/logical_vacuum.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-
-namespace duckdb {
-
-LogicalVacuum::LogicalVacuum() : LogicalOperator(LogicalOperatorType::LOGICAL_VACUUM) {
-}
-
-LogicalVacuum::LogicalVacuum(unique_ptr<VacuumInfo> info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_VACUUM), info(std::move(info)) {
-}
-
-TableCatalogEntry &LogicalVacuum::GetTable() {
-	D_ASSERT(HasTable());
-	return *table;
-}
-bool LogicalVacuum::HasTable() const {
-	return table != nullptr;
-}
-
-void LogicalVacuum::SetTable(TableCatalogEntry &table_p) {
-	table = &table_p;
-}
-
-void LogicalVacuum::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-
-	serializer.WriteProperty(200, "info", info);
-	serializer.WriteProperty(201, "column_id_map", column_id_map);
-}
-
-unique_ptr<LogicalOperator> LogicalVacuum::Deserialize(Deserializer &deserializer) {
-	auto result = unique_ptr<LogicalVacuum>(new LogicalVacuum());
-
-	auto tmp_info = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(200, "info");
-	deserializer.ReadProperty(201, "column_id_map", result->column_id_map);
-
-	result->info = unique_ptr_cast<ParseInfo, VacuumInfo>(std::move(tmp_info));
-	auto &info = *result->info;
-	if (info.has_table) {
-		// deserialize the 'table'
-		auto &context = deserializer.Get<ClientContext &>();
-		auto binder = Binder::CreateBinder(context);
-		auto bound_table = binder->Bind(*info.ref);
-		if (bound_table->type != TableReferenceType::BASE_TABLE) {
-			throw InvalidInputException("can only vacuum or analyze base tables");
-		}
-		auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
-		auto &table = ref->table;
-		result->SetTable(table);
-		// FIXME: we should probably verify that the 'column_id_map' and 'columns' are the same on the bound table after
-		// deserialization?
-	}
-	return std::move(result);
-}
-
-idx_t LogicalVacuum::EstimateCardinality(ClientContext &context) {
-	return 1;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/operator/logical_window.cpp b/src/duckdb/src/planner/operator/logical_window.cpp
deleted file mode 100644
index 4d066f41b..000000000
--- a/src/duckdb/src/planner/operator/logical_window.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "duckdb/planner/operator/logical_window.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-vector<ColumnBinding> LogicalWindow::GetColumnBindings() {
-	auto child_bindings = children[0]->GetColumnBindings();
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		child_bindings.emplace_back(window_index, i);
-	}
-	return child_bindings;
-}
-
-void LogicalWindow::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-}
-
-vector<idx_t> LogicalWindow::GetTableIndex() const {
-	return vector<idx_t> {window_index};
-}
-
-string LogicalWindow::GetName() const {
-#ifdef DEBUG
-	if (DBConfigOptions::debug_print_bindings) {
-		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", window_index);
-	}
-#endif
-	return LogicalOperator::GetName();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/planner.cpp b/src/duckdb/src/planner/planner.cpp
deleted file mode 100644
index 99a5934ae..000000000
--- a/src/duckdb/src/planner/planner.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-#include "duckdb/planner/planner.hpp"
-
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/prepared_statement_data.hpp"
-#include "duckdb/main/query_profiler.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/execution/column_binding_resolver.hpp"
-#include "duckdb/main/attached_database.hpp"
-
-namespace duckdb {
-
-Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context)), context(context) {
-}
-
-static void CheckTreeDepth(const LogicalOperator &op, idx_t max_depth, idx_t depth = 0) {
-	if (depth >= max_depth) {
-		throw ParserException("Maximum tree depth of %lld exceeded in logical planner", max_depth);
-	}
-	for (auto &child : op.children) {
-		CheckTreeDepth(*child, max_depth, depth + 1);
-	}
-}
-
-void Planner::CreatePlan(SQLStatement &statement) {
-	auto &profiler = QueryProfiler::Get(context);
-	auto parameter_count = statement.named_param_map.size();
-
-	BoundParameterMap bound_parameters(parameter_data);
-
-	// first bind the tables and columns to the catalog
-	bool parameters_resolved = true;
-	try {
-		profiler.StartPhase(MetricsType::PLANNER_BINDING);
-		binder->parameters = &bound_parameters;
-		auto bound_statement = binder->Bind(statement);
-		profiler.EndPhase();
-
-		this->names = bound_statement.names;
-		this->types = bound_statement.types;
-		this->plan = std::move(bound_statement.plan);
-
-		auto max_tree_depth = ClientConfig::GetConfig(context).max_expression_depth;
-		CheckTreeDepth(*plan, max_tree_depth);
-	} catch (const std::exception &ex) {
-		ErrorData error(ex);
-		this->plan = nullptr;
-		if (error.Type() == ExceptionType::PARAMETER_NOT_RESOLVED) {
-			// parameter types could not be resolved
-			this->names = {"unknown"};
-			this->types = {LogicalTypeId::UNKNOWN};
-			parameters_resolved = false;
-		} else if (error.Type() != ExceptionType::INVALID) {
-			// different exception type - try operator_extensions
-			auto &config = DBConfig::GetConfig(context);
-			for (auto &extension_op : config.operator_extensions) {
-				auto bound_statement =
-				    extension_op->Bind(context, *this->binder, extension_op->operator_info.get(), statement);
-				if (bound_statement.plan != nullptr) {
-					this->names = bound_statement.names;
-					this->types = bound_statement.types;
-					this->plan = std::move(bound_statement.plan);
-					break;
-				}
-			}
-			if (!this->plan) {
-				throw;
-			}
-		} else {
-			throw;
-		}
-	}
-	this->properties = binder->GetStatementProperties();
-	this->properties.parameter_count = parameter_count;
-	properties.bound_all_parameters = !bound_parameters.rebind && parameters_resolved;
-
-	Planner::VerifyPlan(context, plan, bound_parameters.GetParametersPtr());
-
-	// set up a map of parameter number -> value entries
-	for (auto &kv : bound_parameters.GetParameters()) {
-		auto &identifier = kv.first;
-		auto &param = kv.second;
-		// check if the type of the parameter could be resolved
-		if (!param->return_type.IsValid()) {
-			properties.bound_all_parameters = false;
-			continue;
-		}
-		param->SetValue(Value(param->return_type));
-		value_map[identifier] = param;
-	}
-}
-
-shared_ptr<PreparedStatementData> Planner::PrepareSQLStatement(unique_ptr<SQLStatement> statement) {
-	auto copied_statement = statement->Copy();
-	// create a plan of the underlying statement
-	CreatePlan(std::move(statement));
-	// now create the logical prepare
-	auto prepared_data = make_shared_ptr<PreparedStatementData>(copied_statement->type);
-	prepared_data->unbound_statement = std::move(copied_statement);
-	prepared_data->names = names;
-	prepared_data->types = types;
-	prepared_data->value_map = std::move(value_map);
-	prepared_data->properties = properties;
-	return prepared_data;
-}
-
-void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
-	D_ASSERT(statement);
-	switch (statement->type) {
-	case StatementType::SELECT_STATEMENT:
-	case StatementType::INSERT_STATEMENT:
-	case StatementType::COPY_STATEMENT:
-	case StatementType::DELETE_STATEMENT:
-	case StatementType::UPDATE_STATEMENT:
-	case StatementType::CREATE_STATEMENT:
-	case StatementType::DROP_STATEMENT:
-	case StatementType::ALTER_STATEMENT:
-	case StatementType::TRANSACTION_STATEMENT:
-	case StatementType::EXPLAIN_STATEMENT:
-	case StatementType::VACUUM_STATEMENT:
-	case StatementType::RELATION_STATEMENT:
-	case StatementType::CALL_STATEMENT:
-	case StatementType::EXPORT_STATEMENT:
-	case StatementType::PRAGMA_STATEMENT:
-	case StatementType::SET_STATEMENT:
-	case StatementType::LOAD_STATEMENT:
-	case StatementType::EXTENSION_STATEMENT:
-	case StatementType::PREPARE_STATEMENT:
-	case StatementType::EXECUTE_STATEMENT:
-	case StatementType::LOGICAL_PLAN_STATEMENT:
-	case StatementType::ATTACH_STATEMENT:
-	case StatementType::DETACH_STATEMENT:
-	case StatementType::COPY_DATABASE_STATEMENT:
-	case StatementType::UPDATE_EXTENSIONS_STATEMENT:
-		CreatePlan(*statement);
-		break;
-	default:
-		throw NotImplementedException("Cannot plan statement of type %s!", StatementTypeToString(statement->type));
-	}
-}
-
-static bool OperatorSupportsSerialization(LogicalOperator &op) {
-	for (auto &child : op.children) {
-		if (!OperatorSupportsSerialization(*child)) {
-			return false;
-		}
-	}
-	return op.SupportSerialization();
-}
-
-void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op,
-                         optional_ptr<bound_parameter_map_t> map) {
-	auto &config = DBConfig::GetConfig(context);
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
-	{
-		auto &serialize_comp = config.options.serialization_compatibility;
-		auto latest_version = SerializationCompatibility::Latest();
-		if (serialize_comp.manually_set &&
-		    serialize_comp.serialization_version != latest_version.serialization_version) {
-			// Serialization should not be skipped, this test relies on the serialization to remove certain fields for
-			// compatibility with older versions. This might change behavior, not doing this might make this test fail.
-		} else {
-			// if alternate verification is enabled we run the original operator
-			return;
-		}
-	}
-#endif
-	if (!op || !ClientConfig::GetConfig(context).verify_serializer) {
-		return;
-	}
-	//! SELECT only for now
-	if (!OperatorSupportsSerialization(*op)) {
-		return;
-	}
-	// verify the column bindings of the plan
-	ColumnBindingResolver::Verify(*op);
-
-	// format (de)serialization of this operator
-	try {
-		MemoryStream stream;
-
-		SerializationOptions options;
-		if (config.options.serialization_compatibility.manually_set) {
-			// Override the default of 'latest' if this was manually set (for testing, mostly)
-			options.serialization_compatibility = config.options.serialization_compatibility;
-		} else {
-			options.serialization_compatibility = SerializationCompatibility::Latest();
-		}
-
-		BinarySerializer::Serialize(*op, stream, options);
-		stream.Rewind();
-		bound_parameter_map_t parameters;
-		auto new_plan = BinaryDeserializer::Deserialize<LogicalOperator>(stream, context, parameters);
-
-		if (map) {
-			*map = std::move(parameters);
-		}
-		op = std::move(new_plan);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		switch (error.Type()) {
-		case ExceptionType::NOT_IMPLEMENTED: // NOLINT: explicitly allowing these errors (for now)
-			break;                           // pass
-		default:
-			throw;
-		}
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/pragma_handler.cpp b/src/duckdb/src/planner/pragma_handler.cpp
deleted file mode 100644
index 7e0b8eab7..000000000
--- a/src/duckdb/src/planner/pragma_handler.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "duckdb/planner/pragma_handler.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/parser.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-#include "duckdb/parser/statement/multi_statement.hpp"
-#include "duckdb/parser/parsed_data/bound_pragma_info.hpp"
-#include "duckdb/function/function.hpp"
-
-#include "duckdb/main/client_context.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/function/function_binder.hpp"
-
-namespace duckdb {
-
-PragmaHandler::PragmaHandler(ClientContext &context) : context(context) {
-}
-
-void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements) {
-	vector<unique_ptr<SQLStatement>> new_statements;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		if (statements[i]->type == StatementType::MULTI_STATEMENT) {
-			auto &multi_statement = statements[i]->Cast<MultiStatement>();
-			for (auto &stmt : multi_statement.statements) {
-				statements.push_back(std::move(stmt));
-			}
-			continue;
-		}
-		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
-			// PRAGMA statement: check if we need to replace it by a new set of statements
-			PragmaHandler handler(context);
-			string new_query;
-			bool expanded = handler.HandlePragma(*statements[i], new_query);
-			if (expanded) {
-				// this PRAGMA statement gets replaced by a new query string
-				// push the new query string through the parser again and add it to the transformer
-				Parser parser(context.GetParserOptions());
-				parser.ParseQuery(new_query);
-				// insert the new statements and remove the old statement
-				for (idx_t j = 0; j < parser.statements.size(); j++) {
-					new_statements.push_back(std::move(parser.statements[j]));
-				}
-				continue;
-			}
-		}
-		new_statements.push_back(std::move(statements[i]));
-	}
-	statements = std::move(new_statements);
-}
-
-void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<unique_ptr<SQLStatement>> &statements) {
-	// first check if there are any pragma statements
-	bool found_pragma = false;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		if (statements[i]->type == StatementType::PRAGMA_STATEMENT ||
-		    statements[i]->type == StatementType::MULTI_STATEMENT) {
-			found_pragma = true;
-			break;
-		}
-	}
-	if (!found_pragma) {
-		// no pragmas: skip this step
-		return;
-	}
-	context.RunFunctionInTransactionInternal(lock, [&]() { HandlePragmaStatementsInternal(statements); });
-}
-
-bool PragmaHandler::HandlePragma(SQLStatement &statement, string &resulting_query) {
-	auto info = statement.Cast<PragmaStatement>().info->Copy();
-	QueryErrorContext error_context(statement.stmt_location);
-	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindPragma(*info, error_context);
-	if (bound_info->function.query) {
-		FunctionParameters parameters {bound_info->parameters, bound_info->named_parameters};
-		resulting_query = bound_info->function.query(context, parameters);
-		return true;
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp b/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp
deleted file mode 100644
index a297a7855..000000000
--- a/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp
+++ /dev/null
@@ -1,784 +0,0 @@
-#include "duckdb/planner/subquery/flatten_dependent_join.hpp"
-
-#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/aggregate/distributive_function_utils.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/list.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/planner/subquery/has_correlated_expressions.hpp"
-#include "duckdb/planner/subquery/rewrite_correlated_expressions.hpp"
-#include "duckdb/planner/subquery/rewrite_cte_scan.hpp"
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
-#include "duckdb/execution/column_binding_resolver.hpp"
-
-namespace duckdb {
-
-FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated,
-                                             bool perform_delim, bool any_join)
-    : binder(binder), delim_offset(DConstants::INVALID_INDEX), correlated_columns(correlated),
-      perform_delim(perform_delim), any_join(any_join) {
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		auto &col = correlated_columns[i];
-		correlated_map[col.binding] = i;
-		delim_types.push_back(col.type);
-	}
-}
-
-bool FlattenDependentJoins::DetectCorrelatedExpressions(LogicalOperator &op, bool lateral, idx_t lateral_depth) {
-
-	bool is_lateral_join = false;
-
-	// check if this entry has correlated expressions
-	if (op.type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
-		is_lateral_join = true;
-	}
-	HasCorrelatedExpressions visitor(correlated_columns, lateral, lateral_depth);
-	visitor.VisitOperator(op);
-	bool has_correlation = visitor.has_correlated_expressions;
-	int child_idx = 0;
-	// now visit the children of this entry and check if they have correlated expressions
-	for (auto &child : op.children) {
-		auto new_lateral_depth = lateral_depth;
-		if (is_lateral_join && child_idx == 1) {
-			new_lateral_depth = lateral_depth + 1;
-		}
-		// we OR the property with its children such that has_correlation is true if either
-		// (1) this node has a correlated expression or
-		// (2) one of its children has a correlated expression
-		if (DetectCorrelatedExpressions(*child, lateral, new_lateral_depth)) {
-			has_correlation = true;
-		}
-		child_idx++;
-	}
-	// set the entry in the map
-	has_correlated_expressions[op] = has_correlation;
-
-	// If we detect correlation in a materialized or recursive CTE, the entire right side of the operator
-	// needs to be marked as correlated. Otherwise, function PushDownDependentJoinInternal does not do the
-	// right thing.
-	if (op.type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE ||
-	    op.type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
-		if (has_correlation) {
-			MarkSubtreeCorrelated(*op.children[1].get());
-		}
-	}
-	return has_correlation;
-}
-
-bool FlattenDependentJoins::MarkSubtreeCorrelated(LogicalOperator &op) {
-	// Do not mark base table scans as correlated
-	auto entry = has_correlated_expressions.find(op);
-	D_ASSERT(entry != has_correlated_expressions.end());
-	bool has_correlation = entry->second;
-	for (auto &child : op.children) {
-		has_correlation |= MarkSubtreeCorrelated(*child.get());
-	}
-	if (op.type != LogicalOperatorType::LOGICAL_GET || op.children.size() == 1) {
-		if (op.type == LogicalOperatorType::LOGICAL_CTE_REF) {
-			has_correlated_expressions[op] = true;
-			return true;
-		} else {
-			has_correlated_expressions[op] = has_correlation;
-		}
-	}
-	return has_correlation;
-}
-
-unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoin(unique_ptr<LogicalOperator> plan,
-                                                                         bool propagate_null_values) {
-	auto result = PushDownDependentJoinInternal(std::move(plan), propagate_null_values, 0);
-	if (!replacement_map.empty()) {
-		// check if we have to replace any COUNT aggregates into "CASE WHEN X IS NULL THEN 0 ELSE COUNT END"
-		RewriteCountAggregates aggr(replacement_map);
-		aggr.VisitOperator(*result);
-	}
-	return result;
-}
-
-bool SubqueryDependentFilter(Expression &expr) {
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_CONJUNCTION &&
-	    expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		auto &bound_conjunction = expr.Cast<BoundConjunctionExpression>();
-		for (auto &child : bound_conjunction.children) {
-			if (SubqueryDependentFilter(*child)) {
-				return true;
-			}
-		}
-	}
-	if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
-		return true;
-	}
-	return false;
-}
-
-unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan,
-                                                                                 bool &parent_propagate_null_values,
-                                                                                 idx_t lateral_depth) {
-	// first check if the logical operator has correlated expressions
-	auto entry = has_correlated_expressions.find(*plan);
-	bool exit_projection = false;
-	unique_ptr<LogicalDelimGet> delim_scan;
-	D_ASSERT(entry != has_correlated_expressions.end());
-	if (!entry->second) {
-		// we reached a node without correlated expressions
-		// we can eliminate the dependent join now and create a simple cross product
-		// now create the duplicate eliminated scan for this node
-		if (plan->type == LogicalOperatorType::LOGICAL_CTE_REF) {
-			auto &op = plan->Cast<LogicalCTERef>();
-
-			auto rec_cte = binder.recursive_ctes.find(op.cte_index);
-			if (rec_cte != binder.recursive_ctes.end()) {
-				D_ASSERT(rec_cte->second->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
-				auto &rec_cte_op = rec_cte->second->Cast<LogicalRecursiveCTE>();
-				RewriteCTEScan cte_rewriter(op.cte_index, rec_cte_op.correlated_columns);
-				cte_rewriter.VisitOperator(*plan);
-			}
-		}
-
-		// create cross product with Delim Join
-		auto delim_index = binder.GenerateTableIndex();
-		base_binding = ColumnBinding(delim_index, 0);
-
-		auto left_columns = plan->GetColumnBindings().size();
-		delim_offset = left_columns;
-		data_offset = 0;
-		delim_scan = make_uniq<LogicalDelimGet>(delim_index, delim_types);
-		if (plan->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-			// we want to keep the logical projection for positionality.
-			exit_projection = true;
-		} else {
-			auto cross_product = LogicalCrossProduct::Create(std::move(plan), std::move(delim_scan));
-			return cross_product;
-		}
-	}
-	switch (plan->type) {
-	case LogicalOperatorType::LOGICAL_UNNEST:
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		// filter
-		// first we flatten the dependent join in the child of the filter
-		for (auto &expr : plan->expressions) {
-			any_join |= SubqueryDependentFilter(*expr);
-		}
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		// projection
-		// first we flatten the dependent join in the child of the projection
-		for (auto &expr : plan->expressions) {
-			parent_propagate_null_values &= expr->PropagatesNullValues();
-		}
-
-		// if the node has no correlated expressions,
-		// push the cross product with the delim get only below the projection.
-		// This will preserve positionality of the columns and prevent errors when reordering of
-		// delim gets is enabled.
-		if (exit_projection) {
-			auto cross_product = LogicalCrossProduct::Create(std::move(plan->children[0]), std::move(delim_scan));
-			plan->children[0] = std::move(cross_product);
-		} else {
-			plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]),
-			                                                  parent_propagate_null_values, lateral_depth);
-		}
-
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-		// now we add all the columns of the delim_scan to the projection list
-		auto &proj = plan->Cast<LogicalProjection>();
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			auto &col = correlated_columns[i];
-			auto colref = make_uniq<BoundColumnRefExpression>(
-			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			plan->expressions.push_back(std::move(colref));
-		}
-
-		base_binding.table_index = proj.table_index;
-		this->delim_offset = base_binding.column_index = plan->expressions.size() - correlated_columns.size();
-		this->data_offset = 0;
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		auto &aggr = plan->Cast<LogicalAggregate>();
-		// aggregate and group by
-		// first we flatten the dependent join in the child of the projection
-		for (auto &expr : plan->expressions) {
-			parent_propagate_null_values &= expr->PropagatesNullValues();
-		}
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-		// now we add all the columns of the delim_scan to the grouping operators AND the projection list
-		idx_t delim_table_index;
-		idx_t delim_column_offset;
-		idx_t delim_data_offset;
-		auto new_group_count = perform_delim ? correlated_columns.size() : 1;
-		for (idx_t i = 0; i < new_group_count; i++) {
-			auto &col = correlated_columns[i];
-			auto colref = make_uniq<BoundColumnRefExpression>(
-			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			for (auto &set : aggr.grouping_sets) {
-				set.insert(aggr.groups.size());
-			}
-			aggr.groups.push_back(std::move(colref));
-		}
-		if (!perform_delim) {
-			// if we are not performing the duplicate elimination, we have only added the row_id column to the grouping
-			// operators in this case, we push a FIRST aggregate for each of the remaining expressions
-			delim_table_index = aggr.aggregate_index;
-			delim_column_offset = aggr.expressions.size();
-			delim_data_offset = aggr.groups.size();
-			for (idx_t i = 0; i < correlated_columns.size(); i++) {
-				auto &col = correlated_columns[i];
-				auto first_aggregate = FirstFunctionGetter::GetFunction(col.type);
-				auto colref = make_uniq<BoundColumnRefExpression>(
-				    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-				vector<unique_ptr<Expression>> aggr_children;
-				aggr_children.push_back(std::move(colref));
-				auto first_fun =
-				    make_uniq<BoundAggregateExpression>(std::move(first_aggregate), std::move(aggr_children), nullptr,
-				                                        nullptr, AggregateType::NON_DISTINCT);
-				aggr.expressions.push_back(std::move(first_fun));
-			}
-		} else {
-			delim_table_index = aggr.group_index;
-			delim_column_offset = aggr.groups.size() - correlated_columns.size();
-			delim_data_offset = aggr.groups.size();
-		}
-		bool ungrouped_join = false;
-		if (aggr.grouping_sets.empty()) {
-			ungrouped_join = aggr.groups.size() == new_group_count;
-		} else {
-			for (auto &grouping_set : aggr.grouping_sets) {
-				if (grouping_set.size() == new_group_count) {
-					ungrouped_join = true;
-				}
-			}
-		}
-		if (ungrouped_join) {
-			// we have to perform an INNER or LEFT OUTER JOIN between the result of this aggregate and the delim scan
-			// this does not always have to be a LEFT OUTER JOIN, depending on whether aggr.expressions return
-			// NULL or a value
-			JoinType join_type = JoinType::INNER;
-			if (any_join || !parent_propagate_null_values) {
-				join_type = JoinType::LEFT;
-			}
-			for (auto &aggr_exp : aggr.expressions) {
-				auto &b_aggr_exp = aggr_exp->Cast<BoundAggregateExpression>();
-				if (!b_aggr_exp.PropagatesNullValues()) {
-					join_type = JoinType::LEFT;
-					break;
-				}
-			}
-			unique_ptr<LogicalComparisonJoin> join = make_uniq<LogicalComparisonJoin>(join_type);
-			auto left_index = binder.GenerateTableIndex();
-			delim_scan = make_uniq<LogicalDelimGet>(left_index, delim_types);
-			join->children.push_back(std::move(delim_scan));
-			join->children.push_back(std::move(plan));
-			for (idx_t i = 0; i < new_group_count; i++) {
-				auto &col = correlated_columns[i];
-				JoinCondition cond;
-				cond.left = make_uniq<BoundColumnRefExpression>(col.name, col.type, ColumnBinding(left_index, i));
-				cond.right = make_uniq<BoundColumnRefExpression>(
-				    correlated_columns[i].type, ColumnBinding(delim_table_index, delim_column_offset + i));
-				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-				join->conditions.push_back(std::move(cond));
-			}
-			// for any COUNT aggregate we replace references to the column with: CASE WHEN COUNT(*) IS NULL THEN 0
-			// ELSE COUNT(*) END
-			for (idx_t i = 0; i < aggr.expressions.size(); i++) {
-				D_ASSERT(aggr.expressions[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-				auto &bound = aggr.expressions[i]->Cast<BoundAggregateExpression>();
-				vector<LogicalType> arguments;
-				if (bound.function == CountFunctionBase::GetFunction() ||
-				    bound.function == CountStarFun::GetFunction()) {
-					// have to replace this ColumnBinding with the CASE expression
-					replacement_map[ColumnBinding(aggr.aggregate_index, i)] = i;
-				}
-			}
-			// now we update the delim_index
-			base_binding.table_index = left_index;
-			this->delim_offset = base_binding.column_index = 0;
-			this->data_offset = 0;
-			return std::move(join);
-		} else {
-			// update the delim_index
-			base_binding.table_index = delim_table_index;
-			this->delim_offset = base_binding.column_index = delim_column_offset;
-			this->data_offset = delim_data_offset;
-			return plan;
-		}
-	}
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-		// cross product
-		// push into both sides of the plan
-		bool left_has_correlation = has_correlated_expressions.find(*plan->children[0])->second;
-		bool right_has_correlation = has_correlated_expressions.find(*plan->children[1])->second;
-		if (!right_has_correlation) {
-			// only left has correlation: push into left
-			plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]),
-			                                                  parent_propagate_null_values, lateral_depth);
-			return plan;
-		}
-		if (!left_has_correlation) {
-			// only right has correlation: push into right
-			plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]),
-			                                                  parent_propagate_null_values, lateral_depth);
-			return plan;
-		}
-		// both sides have correlation
-		// turn into an inner join
-		auto join = make_uniq<LogicalComparisonJoin>(JoinType::INNER);
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-		auto left_binding = this->base_binding;
-		plan->children[1] =
-		    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values, lateral_depth);
-		// add the correlated columns to the join conditions
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			JoinCondition cond;
-			cond.left = make_uniq<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i));
-			cond.right = make_uniq<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-			join->conditions.push_back(std::move(cond));
-		}
-		join->children.push_back(std::move(plan->children[0]));
-		join->children.push_back(std::move(plan->children[1]));
-		return std::move(join);
-	}
-	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN: {
-		auto &dependent_join = plan->Cast<LogicalJoin>();
-		if (!((dependent_join.join_type == JoinType::INNER) || (dependent_join.join_type == JoinType::LEFT))) {
-			throw NotImplementedException("Dependent join can only be INNER or LEFT type");
-		}
-		D_ASSERT(plan->children.size() == 2);
-		// Push all the bindings down to the left side so the right side knows where to refer DELIM_GET from
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-
-		// Normal rewriter like in other joins
-		RewriteCorrelatedExpressions rewriter(this->base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-
-		// Recursive rewriter to visit right side of lateral join and update bindings from left
-		RewriteCorrelatedExpressions recursive_rewriter(this->base_binding, correlated_map, lateral_depth + 1, true);
-		recursive_rewriter.VisitOperator(*plan->children[1]);
-
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = plan->Cast<LogicalJoin>();
-		D_ASSERT(plan->children.size() == 2);
-		// check the correlated expressions in the children of the join
-		bool left_has_correlation = has_correlated_expressions.find(*plan->children[0])->second;
-		bool right_has_correlation = has_correlated_expressions.find(*plan->children[1])->second;
-
-		if (join.join_type == JoinType::INNER) {
-			// inner join
-			if (!right_has_correlation) {
-				// only left has correlation: push into left
-				plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]),
-				                                                  parent_propagate_null_values, lateral_depth);
-				// Remove the correlated columns coming from outside for current join node
-				return plan;
-			}
-			if (!left_has_correlation) {
-				// only right has correlation: push into right
-				plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]),
-				                                                  parent_propagate_null_values, lateral_depth);
-				// Remove the correlated columns coming from outside for current join node
-				return plan;
-			}
-		} else if (join.join_type == JoinType::LEFT) {
-			// left outer join
-			if (!right_has_correlation) {
-				// only left has correlation: push into left
-				plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]),
-				                                                  parent_propagate_null_values, lateral_depth);
-				// Remove the correlated columns coming from outside for current join node
-				return plan;
-			}
-		} else if (join.join_type == JoinType::RIGHT) {
-			// right outer join
-			if (!left_has_correlation) {
-				// only right has correlation: push into right
-				plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]),
-				                                                  parent_propagate_null_values, lateral_depth);
-				return plan;
-			}
-		} else if (join.join_type == JoinType::MARK) {
-			if (right_has_correlation) {
-				throw NotImplementedException("MARK join with correlation in RHS not supported");
-			}
-			// push the child into the LHS
-			plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]),
-			                                                  parent_propagate_null_values, lateral_depth);
-			// rewrite expressions in the join conditions
-			RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-			rewriter.VisitOperator(*plan);
-			return plan;
-		} else {
-			throw NotImplementedException("Unsupported join type for flattening correlated subquery");
-		}
-		// both sides have correlation
-		// push into both sides
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-		auto left_binding = this->base_binding;
-		plan->children[1] =
-		    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values, lateral_depth);
-		auto right_binding = this->base_binding;
-		// NOTE: for OUTER JOINS it matters what the BASE BINDING is after the join
-		// for the LEFT OUTER JOIN, we want the LEFT side to be the base binding after we push
-		// because the RIGHT binding might contain NULL values
-		if (join.join_type == JoinType::LEFT) {
-			this->base_binding = left_binding;
-		} else if (join.join_type == JoinType::RIGHT) {
-			this->base_binding = right_binding;
-			delim_offset += plan->children[0]->GetColumnBindings().size();
-		}
-		// add the correlated columns to the join conditions
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			auto left = make_uniq<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i));
-			auto right = make_uniq<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(right_binding.table_index, right_binding.column_index + i));
-
-			if (join.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-			    join.type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-				JoinCondition cond;
-				cond.left = std::move(left);
-				cond.right = std::move(right);
-				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-
-				auto &comparison_join = join.Cast<LogicalComparisonJoin>();
-				comparison_join.conditions.push_back(std::move(cond));
-			} else {
-				auto &logical_any_join = join.Cast<LogicalAnyJoin>();
-				auto comparison = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-				                                                       std::move(left), std::move(right));
-				auto conjunction = make_uniq<BoundConjunctionExpression>(
-				    ExpressionType::CONJUNCTION_AND, std::move(comparison), std::move(logical_any_join.condition));
-				logical_any_join.condition = std::move(conjunction);
-			}
-		}
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(right_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT: {
-		auto &limit = plan->Cast<LogicalLimit>();
-		switch (limit.limit_val.Type()) {
-		case LimitNodeType::CONSTANT_PERCENTAGE:
-		case LimitNodeType::EXPRESSION_PERCENTAGE:
-			// NOTE: limit percent could be supported in a manner similar to the LIMIT above
-			// but instead of filtering by an exact number of rows, the limit should be expressed as
-			// COUNT computed over the partition multiplied by the percentage
-			throw ParserException("Limit percent operator not supported in correlated subquery");
-		case LimitNodeType::EXPRESSION_VALUE:
-			throw ParserException("Non-constant limit not supported in correlated subquery");
-		default:
-			break;
-		}
-		switch (limit.offset_val.Type()) {
-		case LimitNodeType::EXPRESSION_VALUE:
-			throw ParserException("Non-constant offset not supported in correlated subquery");
-		case LimitNodeType::CONSTANT_PERCENTAGE:
-		case LimitNodeType::EXPRESSION_PERCENTAGE:
-			throw InternalException("Percentage offset in FlattenDependentJoin");
-		default:
-			break;
-		}
-		auto rownum_alias = "limit_rownum";
-		unique_ptr<LogicalOperator> child;
-		unique_ptr<LogicalOrder> order_by;
-
-		// check if the direct child of this LIMIT node is an ORDER BY node, if so, keep it separate
-		// this is done for an optimization to avoid having to compute the total order
-		if (plan->children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) {
-			order_by = unique_ptr_cast<LogicalOperator, LogicalOrder>(std::move(plan->children[0]));
-			child = PushDownDependentJoinInternal(std::move(order_by->children[0]), parent_propagate_null_values,
-			                                      lateral_depth);
-		} else {
-			child = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values,
-			                                      lateral_depth);
-		}
-		auto child_column_count = child->GetColumnBindings().size();
-		// we push a row_number() OVER (PARTITION BY [correlated columns])
-		auto window_index = binder.GenerateTableIndex();
-		auto window = make_uniq<LogicalWindow>(window_index);
-		auto row_number =
-		    make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT, nullptr, nullptr);
-		auto partition_count = perform_delim ? correlated_columns.size() : 1;
-		for (idx_t i = 0; i < partition_count; i++) {
-			auto &col = correlated_columns[i];
-			auto colref = make_uniq<BoundColumnRefExpression>(
-			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			row_number->partitions.push_back(std::move(colref));
-		}
-		if (order_by) {
-			// optimization: if there is an ORDER BY node followed by a LIMIT
-			// rather than computing the entire order, we push the ORDER BY expressions into the row_num computation
-			// this way, the order only needs to be computed per partition
-			row_number->orders = std::move(order_by->orders);
-		}
-		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
-		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
-		window->expressions.push_back(std::move(row_number));
-		window->children.push_back(std::move(child));
-
-		// add a filter based on the row_number
-		// the filter we add is "row_number > offset AND row_number <= offset + limit"
-		auto filter = make_uniq<LogicalFilter>();
-		unique_ptr<Expression> condition;
-		auto row_num_ref =
-		    make_uniq<BoundColumnRefExpression>(rownum_alias, LogicalType::BIGINT, ColumnBinding(window_index, 0));
-
-		if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-			auto upper_bound_limit = NumericLimits<int64_t>::Maximum();
-			auto limit_val = int64_t(limit.limit_val.GetConstantValue());
-			if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-				// both offset and limit specified - upper bound is offset + limit
-				auto offset_val = int64_t(limit.offset_val.GetConstantValue());
-				TryAddOperator::Operation(limit_val, offset_val, upper_bound_limit);
-			} else {
-				// no offset - upper bound is only the limit
-				upper_bound_limit = limit_val;
-			}
-			auto upper_bound = make_uniq<BoundConstantExpression>(Value::BIGINT(upper_bound_limit));
-			condition = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-			                                                 row_num_ref->Copy(), std::move(upper_bound));
-		}
-		// we only need to add "row_number >= offset + 1" if offset is bigger than 0
-		if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
-			auto offset_val = int64_t(limit.offset_val.GetConstantValue());
-			auto lower_bound = make_uniq<BoundConstantExpression>(Value::BIGINT(offset_val));
-			auto lower_comp = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHAN,
-			                                                       row_num_ref->Copy(), std::move(lower_bound));
-			if (condition) {
-				auto conj = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-				                                                  std::move(lower_comp), std::move(condition));
-				condition = std::move(conj);
-			} else {
-				condition = std::move(lower_comp);
-			}
-		}
-		filter->expressions.push_back(std::move(condition));
-		filter->children.push_back(std::move(window));
-		// we prune away the row_number after the filter clause using the projection map
-		for (idx_t i = 0; i < child_column_count; i++) {
-			filter->projection_map.push_back(i);
-		}
-		return std::move(filter);
-	}
-	case LogicalOperatorType::LOGICAL_WINDOW: {
-		auto &window = plan->Cast<LogicalWindow>();
-		// push into children
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-
-		// we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-
-		// add the correlated columns to the PARTITION BY clauses in the Window
-		for (auto &expr : window.expressions) {
-			D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto &w = expr->Cast<BoundWindowExpression>();
-			for (idx_t i = 0; i < correlated_columns.size(); i++) {
-				w.partitions.push_back(make_uniq<BoundColumnRefExpression>(
-				    correlated_columns[i].type,
-				    ColumnBinding(base_binding.table_index, base_binding.column_index + i)));
-			}
-		}
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_UNION: {
-		auto &setop = plan->Cast<LogicalSetOperation>();
-		// set operator, push into both children
-#ifdef DEBUG
-		plan->children[0]->ResolveOperatorTypes();
-		plan->children[1]->ResolveOperatorTypes();
-		D_ASSERT(plan->children[0]->types == plan->children[1]->types);
-#endif
-		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
-		plan->children[1] = PushDownDependentJoin(std::move(plan->children[1]));
-		for (idx_t i = 0; i < plan->children.size(); i++) {
-			if (plan->children[i]->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-				auto proj_index = binder.GenerateTableIndex();
-				auto bindings = plan->children[i]->GetColumnBindings();
-				plan->children[i]->ResolveOperatorTypes();
-				auto types = plan->children[i]->types;
-				vector<unique_ptr<Expression>> expressions;
-				expressions.reserve(bindings.size());
-				D_ASSERT(bindings.size() == types.size());
-
-				// No column binding replaceent is needed because the parent operator is
-				// a setop which will immediately assign new bindings.
-				for (idx_t col_idx = 0; col_idx < bindings.size(); col_idx++) {
-					expressions.push_back(make_uniq<BoundColumnRefExpression>(types[col_idx], bindings[col_idx]));
-				}
-				auto proj = make_uniq<LogicalProjection>(proj_index, std::move(expressions));
-				proj->children.push_back(std::move(plan->children[i]));
-				plan->children[i] = std::move(proj);
-			}
-		}
-
-		// here we need to check the children. If they have reorderable bindings, you need to plan a projection
-		// on top that will guarantee the order of the bindings.
-#ifdef DEBUG
-		D_ASSERT(plan->children[0]->GetColumnBindings().size() == plan->children[1]->GetColumnBindings().size());
-		plan->children[0]->ResolveOperatorTypes();
-		plan->children[1]->ResolveOperatorTypes();
-		D_ASSERT(plan->children[0]->types == plan->children[1]->types);
-#endif
-		// we have to refer to the setop index now
-		base_binding.table_index = setop.table_index;
-		base_binding.column_index = setop.column_count;
-		setop.column_count += correlated_columns.size();
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		auto &distinct = plan->Cast<LogicalDistinct>();
-		// push down into child
-		distinct.children[0] = PushDownDependentJoin(std::move(distinct.children[0]));
-		// add all correlated columns to the distinct targets
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			distinct.distinct_targets.push_back(make_uniq<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i)));
-		}
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
-		// expression get
-		// first we flatten the dependent join in the child
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-		// now we add all the correlated columns to each of the expressions of the expression scan
-		auto &expr_get = plan->Cast<LogicalExpressionGet>();
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			for (auto &expr_list : expr_get.expressions) {
-				auto colref = make_uniq<BoundColumnRefExpression>(
-				    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-				expr_list.push_back(std::move(colref));
-			}
-			expr_get.expr_types.push_back(correlated_columns[i].type);
-		}
-
-		base_binding.table_index = expr_get.table_index;
-		this->delim_offset = base_binding.column_index = expr_get.expr_types.size() - correlated_columns.size();
-		this->data_offset = 0;
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_PIVOT:
-		throw BinderException("PIVOT is not supported in correlated subqueries yet");
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
-		return plan;
-	case LogicalOperatorType::LOGICAL_GET: {
-		auto &get = plan->Cast<LogicalGet>();
-		if (get.children.size() != 1) {
-			throw InternalException("Flatten dependent joins - logical get encountered without children");
-		}
-		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			get.projected_input.push_back(this->delim_offset + i);
-		}
-		this->delim_offset = get.returned_types.size();
-		this->data_offset = 0;
-
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: {
-
-#ifdef DEBUG
-		plan->children[0]->ResolveOperatorTypes();
-		plan->children[1]->ResolveOperatorTypes();
-#endif
-		idx_t table_index = 0;
-		plan->children[0] =
-		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
-		if (plan->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
-			auto &setop = plan->Cast<LogicalRecursiveCTE>();
-			base_binding.table_index = setop.table_index;
-			base_binding.column_index = setop.column_count;
-			table_index = setop.table_index;
-			setop.correlated_columns = correlated_columns;
-		} else if (plan->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
-			auto &setop = plan->Cast<LogicalMaterializedCTE>();
-			base_binding.table_index = setop.table_index;
-			base_binding.column_index = setop.column_count;
-			table_index = setop.table_index;
-		}
-
-		RewriteCTEScan cte_rewriter(table_index, correlated_columns);
-		cte_rewriter.VisitOperator(*plan->children[1]);
-
-		parent_propagate_null_values = false;
-		plan->children[1] =
-		    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values, lateral_depth);
-		RewriteCorrelatedExpressions rewriter(this->base_binding, correlated_map, lateral_depth);
-		rewriter.VisitOperator(*plan);
-
-		RewriteCorrelatedExpressions recursive_rewriter(this->base_binding, correlated_map, lateral_depth, true);
-		recursive_rewriter.VisitOperator(*plan->children[0]);
-		recursive_rewriter.VisitOperator(*plan->children[1]);
-
-#ifdef DEBUG
-		plan->children[0]->ResolveOperatorTypes();
-		plan->children[1]->ResolveOperatorTypes();
-#endif
-		if (plan->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
-			// we have to refer to the recursive CTE index now
-			auto &setop = plan->Cast<LogicalRecursiveCTE>();
-			base_binding.table_index = setop.table_index;
-			base_binding.column_index = setop.column_count;
-			setop.column_count += correlated_columns.size();
-		}
-
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_CTE_REF: {
-		auto &cteref = plan->Cast<LogicalCTERef>();
-		// Read correlated columns from CTE_SCAN instead of from DELIM_SCAN
-		base_binding.table_index = cteref.table_index;
-		base_binding.column_index = cteref.chunk_types.size() - cteref.correlated_columns;
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
-		throw BinderException("Nested lateral joins or lateral joins in correlated subqueries are not (yet) supported");
-	}
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		throw BinderException("Sampling in correlated subqueries is not (yet) supported");
-	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		throw BinderException("Positional join in correlated subqueries is not (yet) supported");
-	default:
-		throw InternalException("Logical operator type \"%s\" for dependent join", LogicalOperatorToString(plan->type));
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/subquery/has_correlated_expressions.cpp b/src/duckdb/src/planner/subquery/has_correlated_expressions.cpp
deleted file mode 100644
index d53cb9849..000000000
--- a/src/duckdb/src/planner/subquery/has_correlated_expressions.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "duckdb/planner/subquery/has_correlated_expressions.hpp"
-
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-HasCorrelatedExpressions::HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated, bool lateral,
-                                                   idx_t lateral_depth)
-    : has_correlated_expressions(false), lateral(lateral), correlated_columns(correlated),
-      lateral_depth(lateral_depth) {
-}
-
-void HasCorrelatedExpressions::VisitOperator(LogicalOperator &op) {
-	VisitOperatorExpressions(op);
-}
-
-unique_ptr<Expression> HasCorrelatedExpressions::VisitReplace(BoundColumnRefExpression &expr,
-                                                              unique_ptr<Expression> *expr_ptr) {
-	// Indicates local correlations (all correlations within a child) for the root
-	if (expr.depth <= lateral_depth) {
-		return nullptr;
-	}
-
-	// Should never happen
-	if (expr.depth > 1 + lateral_depth) {
-		if (lateral) {
-			throw BinderException("Invalid lateral depth encountered for an expression");
-		}
-		throw InternalException("Expression with depth > 1 detected in non-lateral join");
-	}
-	// Note: This is added, since we only want to set has_correlated_expressions to true when the
-	// BoundSubqueryExpression has the same bindings as one of the correlated_columns from the left hand side
-	// (correlated_columns is the correlated_columns from left hand side)
-	bool found_match = false;
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		if (correlated_columns[i].binding == expr.binding) {
-			found_match = true;
-			break;
-		}
-	}
-	// correlated column reference
-	D_ASSERT(expr.depth == lateral_depth + 1);
-	has_correlated_expressions = found_match;
-	return nullptr;
-}
-
-unique_ptr<Expression> HasCorrelatedExpressions::VisitReplace(BoundSubqueryExpression &expr,
-                                                              unique_ptr<Expression> *expr_ptr) {
-	if (!expr.IsCorrelated()) {
-		return nullptr;
-	}
-	// check if the subquery contains any of the correlated expressions that we are concerned about in this node
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		if (std::find(expr.binder->correlated_columns.begin(), expr.binder->correlated_columns.end(),
-		              correlated_columns[i]) != expr.binder->correlated_columns.end()) {
-			has_correlated_expressions = true;
-			break;
-		}
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp b/src/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp
deleted file mode 100644
index 61c9c7ba2..000000000
--- a/src/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-#include "duckdb/planner/subquery/rewrite_correlated_expressions.hpp"
-
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
-
-namespace duckdb {
-
-RewriteCorrelatedExpressions::RewriteCorrelatedExpressions(ColumnBinding base_binding,
-                                                           column_binding_map_t<idx_t> &correlated_map,
-                                                           idx_t lateral_depth, bool recursive_rewrite)
-    : base_binding(base_binding), correlated_map(correlated_map), lateral_depth(lateral_depth),
-      recursive_rewrite(recursive_rewrite) {
-}
-
-void RewriteCorrelatedExpressions::VisitOperator(LogicalOperator &op) {
-	if (recursive_rewrite) {
-		// Update column bindings from left child of lateral to right child
-		if (op.type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
-			D_ASSERT(op.children.size() == 2);
-			VisitOperator(*op.children[0]);
-			lateral_depth++;
-			VisitOperator(*op.children[1]);
-			lateral_depth--;
-		} else {
-			VisitOperatorChildren(op);
-		}
-	}
-	// update the bindings in the correlated columns of the dependendent join
-	if (op.type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
-		auto &plan = op.Cast<LogicalDependentJoin>();
-		for (auto &corr : plan.correlated_columns) {
-			auto entry = correlated_map.find(corr.binding);
-			if (entry != correlated_map.end()) {
-				corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-			}
-		}
-	}
-	VisitOperatorExpressions(op);
-}
-
-unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundColumnRefExpression &expr,
-                                                                  unique_ptr<Expression> *expr_ptr) {
-	if (expr.depth <= lateral_depth) {
-		// Indicates local correlations not relevant for the current the rewrite
-		return nullptr;
-	}
-	// correlated column reference
-	// replace with the entry referring to the duplicate eliminated scan
-	// if this assertion occurs it generally means the bindings are inappropriate set in the binder or
-	// we either missed to account for lateral binder or over-counted for the lateral binder
-	D_ASSERT(expr.depth == 1 + lateral_depth);
-	auto entry = correlated_map.find(expr.binding);
-	D_ASSERT(entry != correlated_map.end());
-
-	expr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-	if (recursive_rewrite) {
-		D_ASSERT(expr.depth > 1);
-		expr.depth--;
-	} else {
-		expr.depth = 0;
-	}
-	return nullptr;
-}
-
-//! Helper class used to recursively rewrite correlated expressions within nested subqueries.
-class RewriteCorrelatedRecursive : public BoundNodeVisitor {
-public:
-	RewriteCorrelatedRecursive(ColumnBinding base_binding, column_binding_map_t<idx_t> &correlated_map);
-
-	void VisitBoundTableRef(BoundTableRef &ref) override;
-	void VisitExpression(unique_ptr<Expression> &expression) override;
-
-	void RewriteCorrelatedSubquery(Binder &binder, BoundQueryNode &subquery);
-
-	ColumnBinding base_binding;
-	column_binding_map_t<idx_t> &correlated_map;
-};
-
-unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundSubqueryExpression &expr,
-                                                                  unique_ptr<Expression> *expr_ptr) {
-	if (!expr.IsCorrelated()) {
-		return nullptr;
-	}
-	// subquery detected within this subquery
-	// recursively rewrite it using the RewriteCorrelatedRecursive class
-	RewriteCorrelatedRecursive rewrite(base_binding, correlated_map);
-	rewrite.RewriteCorrelatedSubquery(*expr.binder, *expr.subquery);
-	return nullptr;
-}
-
-RewriteCorrelatedRecursive::RewriteCorrelatedRecursive(ColumnBinding base_binding,
-                                                       column_binding_map_t<idx_t> &correlated_map)
-    : base_binding(base_binding), correlated_map(correlated_map) {
-}
-
-void RewriteCorrelatedRecursive::VisitBoundTableRef(BoundTableRef &ref) {
-	if (ref.type == TableReferenceType::JOIN) {
-		// rewrite correlated columns in child joins
-		auto &bound_join = ref.Cast<BoundJoinRef>();
-		for (auto &corr : bound_join.correlated_columns) {
-			auto entry = correlated_map.find(corr.binding);
-			if (entry != correlated_map.end()) {
-				corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-			}
-		}
-	} else if (ref.type == TableReferenceType::SUBQUERY) {
-		auto &subquery = ref.Cast<BoundSubqueryRef>();
-		RewriteCorrelatedSubquery(*subquery.binder, *subquery.subquery);
-		return;
-	}
-	// visit the children of the table ref
-	BoundNodeVisitor::VisitBoundTableRef(ref);
-}
-
-void RewriteCorrelatedRecursive::RewriteCorrelatedSubquery(Binder &binder, BoundQueryNode &subquery) {
-	// rewrite the binding in the correlated list of the subquery)
-	for (auto &corr : binder.correlated_columns) {
-		auto entry = correlated_map.find(corr.binding);
-		if (entry != correlated_map.end()) {
-			corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-		}
-	}
-	VisitBoundQueryNode(subquery);
-}
-
-void RewriteCorrelatedRecursive::VisitExpression(unique_ptr<Expression> &expression) {
-	if (expression->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		// bound column reference
-		auto &bound_colref = expression->Cast<BoundColumnRefExpression>();
-		if (bound_colref.depth == 0) {
-			// not a correlated column, ignore
-			return;
-		}
-		// correlated column
-		// check the correlated map
-		auto entry = correlated_map.find(bound_colref.binding);
-		if (entry != correlated_map.end()) {
-			// we found the column in the correlated map!
-			// update the binding and reduce the depth by 1
-			bound_colref.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-			bound_colref.depth--;
-		}
-	} else if (expression->GetExpressionType() == ExpressionType::SUBQUERY) {
-		// we encountered another subquery: rewrite recursively
-		auto &bound_subquery = expression->Cast<BoundSubqueryExpression>();
-		RewriteCorrelatedSubquery(*bound_subquery.binder, *bound_subquery.subquery);
-	}
-	// recurse into the children of this subquery
-	BoundNodeVisitor::VisitExpression(expression);
-}
-
-RewriteCountAggregates::RewriteCountAggregates(column_binding_map_t<idx_t> &replacement_map)
-    : replacement_map(replacement_map) {
-}
-
-unique_ptr<Expression> RewriteCountAggregates::VisitReplace(BoundColumnRefExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	auto entry = replacement_map.find(expr.binding);
-	if (entry != replacement_map.end()) {
-		// reference to a COUNT(*) aggregate
-		// replace this with CASE WHEN COUNT(*) IS NULL THEN 0 ELSE COUNT(*) END
-		auto is_null = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
-		is_null->children.push_back(expr.Copy());
-		auto check = std::move(is_null);
-		auto result_if_true = make_uniq<BoundConstantExpression>(Value::Numeric(expr.return_type, 0));
-		auto result_if_false = std::move(*expr_ptr);
-		return make_uniq<BoundCaseExpression>(std::move(check), std::move(result_if_true), std::move(result_if_false));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/subquery/rewrite_cte_scan.cpp b/src/duckdb/src/planner/subquery/rewrite_cte_scan.cpp
deleted file mode 100644
index 5ac0a59be..000000000
--- a/src/duckdb/src/planner/subquery/rewrite_cte_scan.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/planner/subquery/rewrite_cte_scan.hpp"
-
-#include "duckdb/planner/operator/list.hpp"
-
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/tableref/bound_joinref.hpp"
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
-
-namespace duckdb {
-
-RewriteCTEScan::RewriteCTEScan(idx_t table_index, const vector<CorrelatedColumnInfo> &correlated_columns)
-    : table_index(table_index), correlated_columns(correlated_columns) {
-}
-
-void RewriteCTEScan::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_CTE_REF) {
-		auto &cteref = op.Cast<LogicalCTERef>();
-
-		if (cteref.cte_index == table_index) {
-			for (auto &c : this->correlated_columns) {
-				cteref.chunk_types.push_back(c.type);
-				cteref.bound_columns.push_back(c.name);
-			}
-			cteref.correlated_columns += correlated_columns.size();
-		}
-	}
-	VisitOperatorChildren(op);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/table_binding.cpp b/src/duckdb/src/planner/table_binding.cpp
deleted file mode 100644
index 455834a4b..000000000
--- a/src/duckdb/src/planner/table_binding.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#include "duckdb/planner/table_binding.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/planner/bind_context.hpp"
-#include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-Binding::Binding(BindingType binding_type, BindingAlias alias_p, vector<LogicalType> coltypes, vector<string> colnames,
-                 idx_t index, LogicalType rowid_type)
-    : binding_type(binding_type), alias(std::move(alias_p)), index(index), types(std::move(coltypes)),
-      names(std::move(colnames)), rowid_type(std::move(rowid_type)) {
-	D_ASSERT(types.size() == names.size());
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto &name = names[i];
-		D_ASSERT(!name.empty());
-		if (name_map.find(name) != name_map.end()) {
-			throw BinderException("table \"%s\" has duplicate column name \"%s\"", alias.GetAlias(), name);
-		}
-		name_map[name] = i;
-	}
-}
-
-string Binding::GetAlias() const {
-	return alias.GetAlias();
-}
-
-bool Binding::TryGetBindingIndex(const string &column_name, column_t &result) {
-	auto entry = name_map.find(column_name);
-	if (entry == name_map.end()) {
-		return false;
-	}
-	auto column_info = entry->second;
-	result = column_info;
-	return true;
-}
-
-column_t Binding::GetBindingIndex(const string &column_name) {
-	column_t result;
-	if (!TryGetBindingIndex(column_name, result)) {
-		throw InternalException("Binding index for column \"%s\" not found", column_name);
-	}
-	return result;
-}
-
-bool Binding::HasMatchingBinding(const string &column_name) {
-	column_t result;
-	return TryGetBindingIndex(column_name, result);
-}
-
-ErrorData Binding::ColumnNotFoundError(const string &column_name) const {
-	return ErrorData(ExceptionType::BINDER, StringUtil::Format("Values list \"%s\" does not have a column named \"%s\"",
-	                                                           GetAlias(), column_name));
-}
-
-BindResult Binding::Bind(ColumnRefExpression &colref, idx_t depth) {
-	column_t column_index;
-	bool success = false;
-	success = TryGetBindingIndex(colref.GetColumnName(), column_index);
-	if (!success) {
-		return BindResult(ColumnNotFoundError(colref.GetColumnName()));
-	}
-	ColumnBinding binding;
-	binding.table_index = index;
-	binding.column_index = column_index;
-	LogicalType sql_type = types[column_index];
-	if (colref.GetAlias().empty()) {
-		colref.SetAlias(names[column_index]);
-	}
-	return BindResult(make_uniq<BoundColumnRefExpression>(colref.GetName(), sql_type, binding, depth));
-}
-
-optional_ptr<StandardEntry> Binding::GetStandardEntry() {
-	return nullptr;
-}
-
-BindingAlias Binding::GetAlias(const string &explicit_alias, const StandardEntry &entry) {
-	if (!explicit_alias.empty()) {
-		return BindingAlias(explicit_alias);
-	}
-	// no explicit alias provided - generate from entry
-	return BindingAlias(entry);
-}
-
-BindingAlias Binding::GetAlias(const string &explicit_alias, optional_ptr<StandardEntry> entry) {
-	if (!explicit_alias.empty()) {
-		return BindingAlias(explicit_alias);
-	}
-	if (!entry) {
-		throw InternalException("Binding::GetAlias called - but neither an alias nor an entry was provided");
-	}
-	// no explicit alias provided - generate from entry
-	return BindingAlias(*entry);
-}
-
-EntryBinding::EntryBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p, idx_t index,
-                           StandardEntry &entry)
-    : Binding(BindingType::CATALOG_ENTRY, GetAlias(alias, entry), std::move(types_p), std::move(names_p), index),
-      entry(entry) {
-}
-
-optional_ptr<StandardEntry> EntryBinding::GetStandardEntry() {
-	return &entry;
-}
-
-TableBinding::TableBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p,
-                           vector<ColumnIndex> &bound_column_ids, optional_ptr<StandardEntry> entry, idx_t index,
-                           bool add_row_id)
-    : Binding(BindingType::TABLE, GetAlias(alias, entry), std::move(types_p), std::move(names_p), index,
-              (add_row_id && entry) ? entry->Cast<TableCatalogEntry>().GetRowIdType() : LogicalType::ROW_TYPE),
-      bound_column_ids(bound_column_ids), entry(entry) {
-	if (add_row_id) {
-		if (name_map.find("rowid") == name_map.end()) {
-			name_map["rowid"] = COLUMN_IDENTIFIER_ROW_ID;
-		}
-	}
-}
-
-static void ReplaceAliases(ParsedExpression &expr, const ColumnList &list,
-                           const unordered_map<idx_t, string> &alias_map) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		D_ASSERT(!colref.IsQualified());
-		auto &col_names = colref.column_names;
-		D_ASSERT(col_names.size() == 1);
-		auto idx_entry = list.GetColumnIndex(col_names[0]);
-		auto &alias = alias_map.at(idx_entry.index);
-		col_names = {alias};
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](ParsedExpression &child) { ReplaceAliases(child, list, alias_map); });
-}
-
-static void BakeTableName(ParsedExpression &expr, const BindingAlias &binding_alias) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		D_ASSERT(!colref.IsQualified());
-		auto &col_names = colref.column_names;
-		col_names.insert(col_names.begin(), binding_alias.GetAlias());
-		if (!binding_alias.GetSchema().empty()) {
-			col_names.insert(col_names.begin(), binding_alias.GetSchema());
-		}
-		if (!binding_alias.GetCatalog().empty()) {
-			col_names.insert(col_names.begin(), binding_alias.GetCatalog());
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(expr,
-	                                            [&](ParsedExpression &child) { BakeTableName(child, binding_alias); });
-}
-
-unique_ptr<ParsedExpression> TableBinding::ExpandGeneratedColumn(const string &column_name) {
-	auto catalog_entry = GetStandardEntry();
-	D_ASSERT(catalog_entry); // Should only be called on a TableBinding
-
-	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto &table_entry = catalog_entry->Cast<TableCatalogEntry>();
-
-	// Get the index of the generated column
-	auto column_index = GetBindingIndex(column_name);
-	D_ASSERT(table_entry.GetColumn(LogicalIndex(column_index)).Generated());
-	// Get a copy of the generated column
-	auto expression = table_entry.GetColumn(LogicalIndex(column_index)).GeneratedExpression().Copy();
-	unordered_map<idx_t, string> alias_map;
-	for (auto &entry : name_map) {
-		alias_map[entry.second] = entry.first;
-	}
-	ReplaceAliases(*expression, table_entry.GetColumns(), alias_map);
-	BakeTableName(*expression, alias);
-	return (expression);
-}
-
-const vector<ColumnIndex> &TableBinding::GetBoundColumnIds() const {
-#ifdef DEBUG
-	unordered_set<idx_t> column_ids;
-	for (auto &col_id : bound_column_ids) {
-		idx_t id = col_id.IsRowIdColumn() ? DConstants::INVALID_INDEX : col_id.GetPrimaryIndex();
-		auto result = column_ids.insert(id);
-		// assert that all entries in the bound_column_ids are unique
-		D_ASSERT(result.second);
-		auto it = std::find_if(name_map.begin(), name_map.end(),
-		                       [&](const std::pair<const string, idx_t> &it) { return it.second == id; });
-		// assert that every id appears in the name_map
-		D_ASSERT(it != name_map.end());
-		// the order that they appear in is not guaranteed to be sequential
-	}
-#endif
-	return bound_column_ids;
-}
-
-ColumnBinding TableBinding::GetColumnBinding(column_t column_index) {
-	auto &column_ids = bound_column_ids;
-	ColumnBinding binding;
-
-	// Locate the column_id that matches the 'column_index'
-	binding.column_index = column_ids.size();
-	for (idx_t i = 0; i < column_ids.size(); ++i) {
-		auto &col_id = column_ids[i];
-		if (col_id.GetPrimaryIndex() == column_index) {
-			binding.column_index = i;
-			break;
-		}
-	}
-	// If it wasn't found, add it
-	if (binding.column_index == column_ids.size()) {
-		column_ids.emplace_back(column_index);
-	}
-
-	binding.table_index = index;
-	return binding;
-}
-
-BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
-	auto &column_name = colref.GetColumnName();
-	column_t column_index;
-	bool success = false;
-	success = TryGetBindingIndex(column_name, column_index);
-	if (!success) {
-		return BindResult(ColumnNotFoundError(column_name));
-	}
-	auto entry = GetStandardEntry();
-	if (entry && column_index != COLUMN_IDENTIFIER_ROW_ID) {
-		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
-		// Either there is no table, or the columns category has to be standard
-		auto &table_entry = entry->Cast<TableCatalogEntry>();
-		auto &column_entry = table_entry.GetColumn(LogicalIndex(column_index));
-		(void)table_entry;
-		(void)column_entry;
-		D_ASSERT(column_entry.Category() == TableColumnType::STANDARD);
-	}
-	// fetch the type of the column
-	LogicalType col_type;
-	if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-		col_type = LogicalType(rowid_type);
-	} else {
-		// normal column: fetch type from base column
-		col_type = types[column_index];
-		if (colref.GetAlias().empty()) {
-			colref.SetAlias(names[column_index]);
-		}
-	}
-	ColumnBinding binding = GetColumnBinding(column_index);
-	return BindResult(make_uniq<BoundColumnRefExpression>(colref.GetName(), col_type, binding, depth));
-}
-
-optional_ptr<StandardEntry> TableBinding::GetStandardEntry() {
-	return entry;
-}
-
-ErrorData TableBinding::ColumnNotFoundError(const string &column_name) const {
-	auto candidate_message = StringUtil::CandidatesErrorMessage(names, column_name, "Candidate bindings: ");
-	return ErrorData(ExceptionType::BINDER, StringUtil::Format("Table \"%s\" does not have a column named \"%s\"\n%s",
-	                                                           alias.GetAlias(), column_name, candidate_message));
-}
-
-DummyBinding::DummyBinding(vector<LogicalType> types, vector<string> names, string dummy_name)
-    : Binding(BindingType::DUMMY, BindingAlias(DummyBinding::DUMMY_NAME + dummy_name), std::move(types),
-              std::move(names), DConstants::INVALID_INDEX),
-      dummy_name(std::move(dummy_name)) {
-}
-
-BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
-	column_t column_index;
-	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
-		throw InternalException("Column %s not found in bindings", colref.GetColumnName());
-	}
-	ColumnBinding binding(index, column_index);
-
-	// we are binding a parameter to create the dummy binding, no arguments are supplied
-	return BindResult(make_uniq<BoundColumnRefExpression>(colref.GetName(), types[column_index], binding, depth));
-}
-
-BindResult DummyBinding::Bind(LambdaRefExpression &lambdaref, idx_t depth) {
-	column_t column_index;
-	if (!TryGetBindingIndex(lambdaref.GetName(), column_index)) {
-		throw InternalException("Column %s not found in bindings", lambdaref.GetName());
-	}
-	ColumnBinding binding(index, column_index);
-	return BindResult(make_uniq<BoundLambdaRefExpression>(lambdaref.GetName(), types[column_index], binding,
-	                                                      lambdaref.lambda_idx, depth));
-}
-
-unique_ptr<ParsedExpression> DummyBinding::ParamToArg(ColumnRefExpression &colref) {
-	column_t column_index;
-	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
-		throw InternalException("Column %s not found in macro", colref.GetColumnName());
-	}
-	auto arg = (*arguments)[column_index]->Copy();
-	arg->SetAlias(colref.GetAlias());
-	return arg;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/planner/table_filter.cpp b/src/duckdb/src/planner/table_filter.cpp
deleted file mode 100644
index f8544102d..000000000
--- a/src/duckdb/src/planner/table_filter.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "duckdb/planner/table_filter.hpp"
-
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
-
-namespace duckdb {
-
-void TableFilterSet::PushFilter(const ColumnIndex &col_idx, unique_ptr<TableFilter> filter) {
-	auto column_index = col_idx.GetPrimaryIndex();
-	auto entry = filters.find(column_index);
-	if (entry == filters.end()) {
-		// no filter yet: push the filter directly
-		filters[column_index] = std::move(filter);
-	} else {
-		// there is already a filter: AND it together
-		if (entry->second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &and_filter = entry->second->Cast<ConjunctionAndFilter>();
-			and_filter.child_filters.push_back(std::move(filter));
-		} else {
-			auto and_filter = make_uniq<ConjunctionAndFilter>();
-			and_filter->child_filters.push_back(std::move(entry->second));
-			and_filter->child_filters.push_back(std::move(filter));
-			filters[column_index] = std::move(and_filter);
-		}
-	}
-}
-
-string TableFilter::DebugToString() {
-	return ToString("c0");
-}
-
-void DynamicTableFilterSet::ClearFilters(const PhysicalOperator &op) {
-	lock_guard<mutex> l(lock);
-	filters.erase(op);
-}
-
-void DynamicTableFilterSet::PushFilter(const PhysicalOperator &op, idx_t column_index, unique_ptr<TableFilter> filter) {
-	lock_guard<mutex> l(lock);
-	auto entry = filters.find(op);
-	optional_ptr<TableFilterSet> filter_ptr;
-	if (entry == filters.end()) {
-		auto filter_set = make_uniq<TableFilterSet>();
-		filter_ptr = filter_set.get();
-		filters[op] = std::move(filter_set);
-	} else {
-		filter_ptr = entry->second.get();
-	}
-	filter_ptr->PushFilter(ColumnIndex(column_index), std::move(filter));
-}
-
-bool DynamicTableFilterSet::HasFilters() const {
-	lock_guard<mutex> l(lock);
-	return !filters.empty();
-}
-
-unique_ptr<TableFilterSet>
-DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan,
-                                            optional_ptr<TableFilterSet> existing_filters) const {
-	D_ASSERT(HasFilters());
-	auto result = make_uniq<TableFilterSet>();
-	if (existing_filters) {
-		for (auto &entry : existing_filters->filters) {
-			result->PushFilter(ColumnIndex(entry.first), entry.second->Copy());
-		}
-	}
-	for (auto &entry : filters) {
-		for (auto &filter : entry.second->filters) {
-			result->PushFilter(ColumnIndex(filter.first), filter.second->Copy());
-		}
-	}
-	if (result->filters.empty()) {
-		return nullptr;
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/arena_allocator.cpp b/src/duckdb/src/storage/arena_allocator.cpp
deleted file mode 100644
index 000444f75..000000000
--- a/src/duckdb/src/storage/arena_allocator.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-#include "duckdb/storage/arena_allocator.hpp"
-
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Arena Chunk
-//===--------------------------------------------------------------------===//
-ArenaChunk::ArenaChunk(Allocator &allocator, idx_t size) : current_position(0), maximum_size(size), prev(nullptr) {
-	D_ASSERT(size > 0);
-	data = allocator.Allocate(size);
-}
-ArenaChunk::~ArenaChunk() {
-	if (next) {
-		auto current_next = std::move(next);
-		while (current_next) {
-			current_next = std::move(current_next->next);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Allocator Wrapper
-//===--------------------------------------------------------------------===//
-struct ArenaAllocatorData : public PrivateAllocatorData {
-	explicit ArenaAllocatorData(ArenaAllocator &allocator) : allocator(allocator) {
-		free_type = AllocatorFreeType::DOES_NOT_REQUIRE_FREE;
-	}
-
-	ArenaAllocator &allocator;
-};
-
-static data_ptr_t ArenaAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
-	return allocator_data.allocator.Allocate(size);
-}
-
-static void ArenaAllocatorFree(PrivateAllocatorData *, data_ptr_t, idx_t) {
-	// nop
-}
-
-static data_ptr_t ArenaAllocateReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-                                          idx_t size) {
-	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
-	return allocator_data.allocator.Reallocate(pointer, old_size, size);
-}
-//===--------------------------------------------------------------------===//
-// Arena Allocator
-//===--------------------------------------------------------------------===//
-ArenaAllocator::ArenaAllocator(Allocator &allocator, idx_t initial_capacity)
-    : allocator(allocator), initial_capacity(initial_capacity),
-      arena_allocator(ArenaAllocatorAllocate, ArenaAllocatorFree, ArenaAllocateReallocate,
-                      make_uniq<ArenaAllocatorData>(*this)) {
-	head = nullptr;
-	tail = nullptr;
-}
-
-ArenaAllocator::~ArenaAllocator() {
-}
-
-data_ptr_t ArenaAllocator::Allocate(idx_t len) {
-	D_ASSERT(!head || head->current_position <= head->maximum_size);
-	if (!head || head->current_position + len > head->maximum_size) {
-		idx_t capacity;
-		// start off with either (1) initial capacity (if we have no block) or (2) capacity of the previous block
-		if (!head) {
-			capacity = initial_capacity;
-		} else {
-			capacity = head->maximum_size;
-		}
-		// capacity of the previous block can be bigger than the max capacity if we allocate len > max capacity
-		// for new blocks - try to set it back to the max capacity
-		if (capacity > ARENA_ALLOCATOR_MAX_CAPACITY) {
-			capacity = ARENA_ALLOCATOR_MAX_CAPACITY;
-		}
-		// if we are below the max capacity - double the size of the block
-		if (capacity < ARENA_ALLOCATOR_MAX_CAPACITY) {
-			capacity *= 2;
-		}
-		// we double the size until we can fit `len`
-		// this is generally only relevant if len is very large
-		while (capacity < len) {
-			capacity *= 2;
-		}
-		auto new_chunk = make_unsafe_uniq<ArenaChunk>(allocator, capacity);
-		if (head) {
-			head->prev = new_chunk.get();
-			new_chunk->next = std::move(head);
-		} else {
-			tail = new_chunk.get();
-		}
-		head = std::move(new_chunk);
-		allocated_size += capacity;
-	}
-	D_ASSERT(head->current_position + len <= head->maximum_size);
-	auto result = head->data.get() + head->current_position;
-	head->current_position += len;
-	return result;
-}
-
-data_ptr_t ArenaAllocator::Reallocate(data_ptr_t pointer, idx_t old_size, idx_t size) {
-	D_ASSERT(head);
-	if (old_size == size) {
-		// nothing to do
-		return pointer;
-	}
-
-	const auto head_ptr = head->data.get() + head->current_position - old_size;
-	int64_t current_position = NumericCast<int64_t>(head->current_position);
-	int64_t diff = NumericCast<int64_t>(size) - NumericCast<int64_t>(old_size);
-	if (pointer == head_ptr &&
-	    (size < old_size || current_position + diff <= NumericCast<int64_t>(head->maximum_size))) {
-		// passed pointer is the head pointer, and the diff fits on the current chunk
-		head->current_position = NumericCast<idx_t>(current_position + diff);
-		return pointer;
-	} else {
-		// allocate new memory
-		auto result = Allocate(size);
-		memcpy(result, pointer, old_size);
-		return result;
-	}
-}
-
-void ArenaAllocator::AlignNext() {
-	if (head && !ValueIsAligned<idx_t>(head->current_position)) {
-		// move the current position forward so that the next allocation is aligned
-		head->current_position = AlignValue<idx_t>(head->current_position);
-	}
-}
-
-data_ptr_t ArenaAllocator::AllocateAligned(idx_t size) {
-	AlignNext();
-	return Allocate(AlignValue<idx_t>(size));
-}
-
-data_ptr_t ArenaAllocator::ReallocateAligned(data_ptr_t pointer, idx_t old_size, idx_t size) {
-	AlignNext();
-	return Reallocate(pointer, old_size, AlignValue<idx_t>(size));
-}
-
-void ArenaAllocator::Reset() {
-	if (head) {
-		// destroy all chunks except the current one
-		if (head->next) {
-			auto current_next = std::move(head->next);
-			while (current_next) {
-				current_next = std::move(current_next->next);
-			}
-		}
-		tail = head.get();
-
-		// reset the head
-		head->current_position = 0;
-		head->prev = nullptr;
-	}
-	allocated_size = 0;
-}
-
-void ArenaAllocator::Destroy() {
-	head = nullptr;
-	tail = nullptr;
-	allocated_size = 0;
-}
-
-void ArenaAllocator::Move(ArenaAllocator &other) {
-	D_ASSERT(!other.head);
-	other.tail = tail;
-	other.head = std::move(head);
-	other.initial_capacity = initial_capacity;
-	other.allocated_size = allocated_size;
-	Destroy();
-}
-
-ArenaChunk *ArenaAllocator::GetHead() {
-	return head.get();
-}
-
-ArenaChunk *ArenaAllocator::GetTail() {
-	return tail;
-}
-
-bool ArenaAllocator::IsEmpty() const {
-	return head == nullptr;
-}
-
-idx_t ArenaAllocator::SizeInBytes() const {
-	idx_t total_size = 0;
-	if (!IsEmpty()) {
-		auto current = head.get();
-		while (current != nullptr) {
-			total_size += current->current_position;
-			current = current->next.get();
-		}
-	}
-	return total_size;
-}
-
-idx_t ArenaAllocator::AllocationSize() const {
-	D_ASSERT(head || allocated_size == 0);
-	return allocated_size;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/block.cpp b/src/duckdb/src/storage/block.cpp
deleted file mode 100644
index f97da28b8..000000000
--- a/src/duckdb/src/storage/block.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "duckdb/storage/block.hpp"
-
-#include "duckdb/common/assert.hpp"
-
-namespace duckdb {
-
-Block::Block(Allocator &allocator, const block_id_t id, const idx_t block_size)
-    : FileBuffer(allocator, FileBufferType::BLOCK, block_size), id(id) {
-}
-
-Block::Block(Allocator &allocator, block_id_t id, uint32_t internal_size)
-    : FileBuffer(allocator, FileBufferType::BLOCK, internal_size), id(id) {
-	D_ASSERT((AllocSize() & (Storage::SECTOR_SIZE - 1)) == 0);
-}
-
-Block::Block(FileBuffer &source, block_id_t id) : FileBuffer(source, FileBufferType::BLOCK), id(id) {
-	D_ASSERT((AllocSize() & (Storage::SECTOR_SIZE - 1)) == 0);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/buffer/block_handle.cpp b/src/duckdb/src/storage/buffer/block_handle.cpp
deleted file mode 100644
index 1d1c333b3..000000000
--- a/src/duckdb/src/storage/buffer/block_handle.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-#include "duckdb/storage/buffer/block_handle.hpp"
-
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, MemoryTag tag)
-    : block_manager(block_manager), readers(0), block_id(block_id_p), tag(tag), buffer_type(FileBufferType::BLOCK),
-      buffer(nullptr), eviction_seq_num(0), destroy_buffer_upon(DestroyBufferUpon::BLOCK),
-      memory_charge(tag, block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr),
-      eviction_queue_idx(DConstants::INVALID_INDEX) {
-	eviction_seq_num = 0;
-	state = BlockState::BLOCK_UNLOADED;
-	memory_usage = block_manager.GetBlockAllocSize();
-}
-
-BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, MemoryTag tag,
-                         unique_ptr<FileBuffer> buffer_p, DestroyBufferUpon destroy_buffer_upon_p, idx_t block_size,
-                         BufferPoolReservation &&reservation)
-    : block_manager(block_manager), readers(0), block_id(block_id_p), tag(tag), buffer_type(buffer_p->GetBufferType()),
-      eviction_seq_num(0), destroy_buffer_upon(destroy_buffer_upon_p),
-      memory_charge(tag, block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr),
-      eviction_queue_idx(DConstants::INVALID_INDEX) {
-	buffer = std::move(buffer_p);
-	state = BlockState::BLOCK_LOADED;
-	memory_usage = block_size;
-	memory_charge = std::move(reservation);
-}
-
-BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
-	// being destroyed, so any unswizzled pointers are just binary junk now.
-	unswizzled = nullptr;
-	D_ASSERT(!buffer || buffer->GetBufferType() == buffer_type);
-	if (buffer && buffer_type != FileBufferType::TINY_BUFFER) {
-		// we kill the latest version in the eviction queue
-		auto &buffer_manager = block_manager.buffer_manager;
-		buffer_manager.GetBufferPool().IncrementDeadNodes(*this);
-	}
-
-	// no references remain to this block: erase
-	if (buffer && state == BlockState::BLOCK_LOADED) {
-		D_ASSERT(memory_charge.size > 0);
-		// the block is still loaded in memory: erase it
-		buffer.reset();
-		memory_charge.Resize(0);
-	} else {
-		D_ASSERT(memory_charge.size == 0);
-	}
-
-	block_manager.UnregisterBlock(*this);
-}
-
-unique_ptr<Block> AllocateBlock(BlockManager &block_manager, unique_ptr<FileBuffer> reusable_buffer,
-                                block_id_t block_id) {
-	if (reusable_buffer) {
-		// re-usable buffer: re-use it
-		if (reusable_buffer->GetBufferType() == FileBufferType::BLOCK) {
-			// we can reuse the buffer entirely
-			auto &block = reinterpret_cast<Block &>(*reusable_buffer);
-			block.id = block_id;
-			return unique_ptr_cast<FileBuffer, Block>(std::move(reusable_buffer));
-		}
-		auto block = block_manager.CreateBlock(block_id, reusable_buffer.get());
-		reusable_buffer.reset();
-		return block;
-	} else {
-		// no re-usable buffer: allocate a new block
-		return block_manager.CreateBlock(block_id, nullptr);
-	}
-}
-
-void BlockHandle::ChangeMemoryUsage(BlockLock &l, int64_t delta) {
-	VerifyMutex(l);
-
-	D_ASSERT(delta < 0);
-	memory_usage += static_cast<idx_t>(delta);
-	memory_charge.Resize(memory_usage);
-}
-
-unique_ptr<FileBuffer> &BlockHandle::GetBuffer(BlockLock &l) {
-	VerifyMutex(l);
-	return buffer;
-}
-
-void BlockHandle::VerifyMutex(BlockLock &l) const {
-	D_ASSERT(l.owns_lock());
-	D_ASSERT(l.mutex() == &lock);
-}
-
-BufferPoolReservation &BlockHandle::GetMemoryCharge(BlockLock &l) {
-	VerifyMutex(l);
-	return memory_charge;
-}
-
-void BlockHandle::MergeMemoryReservation(BlockLock &l, BufferPoolReservation reservation) {
-	VerifyMutex(l);
-	memory_charge.Merge(std::move(reservation));
-}
-
-void BlockHandle::ResizeMemory(BlockLock &l, idx_t alloc_size) {
-	VerifyMutex(l);
-	memory_charge.Resize(alloc_size);
-}
-
-void BlockHandle::ResizeBuffer(BlockLock &l, idx_t block_size, int64_t memory_delta) {
-	VerifyMutex(l);
-
-	D_ASSERT(buffer);
-	// resize and adjust current memory
-	buffer->Resize(block_size);
-	memory_usage = NumericCast<idx_t>(NumericCast<int64_t>(memory_usage.load()) + memory_delta);
-	D_ASSERT(memory_usage == buffer->AllocSize());
-}
-
-BufferHandle BlockHandle::LoadFromBuffer(BlockLock &l, data_ptr_t data, unique_ptr<FileBuffer> reusable_buffer,
-                                         BufferPoolReservation reservation) {
-	VerifyMutex(l);
-
-	D_ASSERT(state != BlockState::BLOCK_LOADED);
-	D_ASSERT(readers == 0);
-	// copy over the data into the block from the file buffer
-	auto block = AllocateBlock(block_manager, std::move(reusable_buffer), block_id);
-	memcpy(block->InternalBuffer(), data, block->AllocSize());
-	buffer = std::move(block);
-	state = BlockState::BLOCK_LOADED;
-	readers = 1;
-	memory_charge = std::move(reservation);
-	return BufferHandle(shared_from_this(), buffer.get());
-}
-
-BufferHandle BlockHandle::Load(unique_ptr<FileBuffer> reusable_buffer) {
-	if (state == BlockState::BLOCK_LOADED) {
-		// already loaded
-		D_ASSERT(buffer);
-		++readers;
-		return BufferHandle(shared_from_this(), buffer.get());
-	}
-
-	if (block_id < MAXIMUM_BLOCK) {
-		auto block = AllocateBlock(block_manager, std::move(reusable_buffer), block_id);
-		block_manager.Read(*block);
-		buffer = std::move(block);
-	} else {
-		if (MustWriteToTemporaryFile()) {
-			buffer = block_manager.buffer_manager.ReadTemporaryBuffer(tag, *this, std::move(reusable_buffer));
-		} else {
-			return BufferHandle(); // Destroyed upon unpin/evict, so there is no temp buffer to read
-		}
-	}
-	state = BlockState::BLOCK_LOADED;
-	readers = 1;
-	return BufferHandle(shared_from_this(), buffer.get());
-}
-
-unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock(BlockLock &lock) {
-	VerifyMutex(lock);
-
-	if (state == BlockState::BLOCK_UNLOADED) {
-		// already unloaded: nothing to do
-		return nullptr;
-	}
-	D_ASSERT(!unswizzled);
-	D_ASSERT(CanUnload());
-
-	if (block_id >= MAXIMUM_BLOCK && MustWriteToTemporaryFile()) {
-		// temporary block that cannot be destroyed upon evict/unpin: write to temporary file
-		block_manager.buffer_manager.WriteTemporaryBuffer(tag, block_id, *buffer);
-	}
-	memory_charge.Resize(0);
-	state = BlockState::BLOCK_UNLOADED;
-	return std::move(buffer);
-}
-
-void BlockHandle::Unload(BlockLock &lock) {
-	auto block = UnloadAndTakeBlock(lock);
-	block.reset();
-}
-
-bool BlockHandle::CanUnload() const {
-	if (state == BlockState::BLOCK_UNLOADED) {
-		// already unloaded
-		return false;
-	}
-	if (readers > 0) {
-		// there are active readers
-		return false;
-	}
-	if (block_id >= MAXIMUM_BLOCK && MustWriteToTemporaryFile() &&
-	    !block_manager.buffer_manager.HasTemporaryDirectory()) {
-		// this block cannot be destroyed upon evict/unpin
-		// in order to unload this block we need to write it to a temporary buffer
-		// however, no temporary directory is specified!
-		// hence we cannot unload the block
-		return false;
-	}
-	return true;
-}
-
-void BlockHandle::ConvertToPersistent(BlockLock &l, BlockHandle &new_block, unique_ptr<FileBuffer> new_buffer) {
-	VerifyMutex(l);
-
-	// move the data from the old block into data for the new block
-	new_block.state = BlockState::BLOCK_LOADED;
-	new_block.buffer = std::move(new_buffer);
-	new_block.memory_usage = memory_usage.load();
-	new_block.memory_charge = std::move(memory_charge);
-
-	// clear out the buffer data from this block
-	buffer.reset();
-	state = BlockState::BLOCK_UNLOADED;
-	memory_usage = 0;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/buffer/block_manager.cpp b/src/duckdb/src/storage/buffer/block_manager.cpp
deleted file mode 100644
index 1ee4fb6da..000000000
--- a/src/duckdb/src/storage/buffer/block_manager.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-
-namespace duckdb {
-
-BlockManager::BlockManager(BufferManager &buffer_manager, const optional_idx block_alloc_size_p)
-    : buffer_manager(buffer_manager), metadata_manager(make_uniq<MetadataManager>(*this, buffer_manager)),
-      block_alloc_size(block_alloc_size_p) {
-}
-
-shared_ptr<BlockHandle> BlockManager::RegisterBlock(block_id_t block_id) {
-	lock_guard<mutex> lock(blocks_lock);
-	// check if the block already exists
-	auto entry = blocks.find(block_id);
-	if (entry != blocks.end()) {
-		// already exists: check if it hasn't expired yet
-		auto existing_ptr = entry->second.lock();
-		if (existing_ptr) {
-			//! it hasn't! return it
-			return existing_ptr;
-		}
-	}
-	// create a new block pointer for this block
-	auto result = make_shared_ptr<BlockHandle>(*this, block_id, MemoryTag::BASE_TABLE);
-	// register the block pointer in the set of blocks as a weak pointer
-	blocks[block_id] = weak_ptr<BlockHandle>(result);
-	return result;
-}
-
-shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block,
-                                                          BufferHandle old_handle) {
-	// register a block with the new block id
-	auto new_block = RegisterBlock(block_id);
-	D_ASSERT(new_block->GetState() == BlockState::BLOCK_UNLOADED);
-	D_ASSERT(new_block->Readers() == 0);
-
-	auto lock = old_block->GetLock();
-	D_ASSERT(old_block->GetState() == BlockState::BLOCK_LOADED);
-	D_ASSERT(old_block->GetBuffer(lock));
-	if (old_block->Readers() > 1) {
-		throw InternalException("BlockManager::ConvertToPersistent - cannot be called for block %d as old_block has "
-		                        "multiple readers active",
-		                        block_id);
-	}
-
-	// Temp buffers can be larger than the storage block size.
-	// But persistent buffers cannot.
-	D_ASSERT(old_block->GetBuffer(lock)->AllocSize() <= GetBlockAllocSize());
-
-	// convert the buffer to a block
-	auto converted_buffer = ConvertBlock(block_id, *old_block->GetBuffer(lock));
-
-	// persist the new block to disk
-	Write(*converted_buffer, block_id);
-
-	// now convert the actual block
-	old_block->ConvertToPersistent(lock, *new_block, std::move(converted_buffer));
-
-	// destroy the old buffer
-	lock.unlock();
-	old_handle.Destroy();
-	old_block.reset();
-
-	// potentially purge the queue
-	auto purge_queue = buffer_manager.GetBufferPool().AddToEvictionQueue(new_block);
-	if (purge_queue) {
-		buffer_manager.GetBufferPool().PurgeQueue(*new_block);
-	}
-	return new_block;
-}
-
-shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block) {
-	// pin the old block to ensure we have it loaded in memory
-	auto handle = buffer_manager.Pin(old_block);
-	return ConvertToPersistent(block_id, std::move(old_block), std::move(handle));
-}
-
-void BlockManager::UnregisterBlock(block_id_t id) {
-	D_ASSERT(id < MAXIMUM_BLOCK);
-	lock_guard<mutex> lock(blocks_lock);
-	// on-disk block: erase from list of blocks in manager
-	blocks.erase(id);
-}
-
-void BlockManager::UnregisterBlock(BlockHandle &block) {
-	auto id = block.BlockId();
-	if (id >= MAXIMUM_BLOCK) {
-		// in-memory buffer: buffer could have been offloaded to disk: remove the file
-		buffer_manager.DeleteTemporaryFile(block);
-	} else {
-		lock_guard<mutex> lock(blocks_lock);
-		// on-disk block: erase from list of blocks in manager
-		blocks.erase(id);
-	}
-}
-
-MetadataManager &BlockManager::GetMetadataManager() {
-	return *metadata_manager;
-}
-
-void BlockManager::Truncate() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/buffer/buffer_handle.cpp b/src/duckdb/src/storage/buffer/buffer_handle.cpp
deleted file mode 100644
index a0a5d20c9..000000000
--- a/src/duckdb/src/storage/buffer/buffer_handle.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-
-namespace duckdb {
-
-BufferHandle::BufferHandle() : handle(nullptr), node(nullptr) {
-}
-
-BufferHandle::BufferHandle(shared_ptr<BlockHandle> handle_p, optional_ptr<FileBuffer> node_p)
-    : handle(std::move(handle_p)), node(node_p) {
-}
-
-BufferHandle::BufferHandle(BufferHandle &&other) noexcept : node(nullptr) {
-	std::swap(node, other.node);
-	std::swap(handle, other.handle);
-}
-
-BufferHandle &BufferHandle::operator=(BufferHandle &&other) noexcept {
-	std::swap(node, other.node);
-	std::swap(handle, other.handle);
-	return *this;
-}
-
-BufferHandle::~BufferHandle() {
-	Destroy();
-}
-
-bool BufferHandle::IsValid() const {
-	return node != nullptr;
-}
-
-void BufferHandle::Destroy() {
-	if (!handle || !IsValid()) {
-		return;
-	}
-	handle->block_manager.buffer_manager.Unpin(handle);
-	handle.reset();
-	node = nullptr;
-}
-
-FileBuffer &BufferHandle::GetFileBuffer() {
-	D_ASSERT(node);
-	return *node;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/buffer/buffer_pool.cpp b/src/duckdb/src/storage/buffer/buffer_pool.cpp
deleted file mode 100644
index 867e88ec1..000000000
--- a/src/duckdb/src/storage/buffer/buffer_pool.cpp
+++ /dev/null
@@ -1,481 +0,0 @@
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/parallel/concurrentqueue.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/storage/temporary_memory_manager.hpp"
-
-namespace duckdb {
-
-BufferEvictionNode::BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t eviction_seq_num)
-    : handle(std::move(handle_p)), handle_sequence_number(eviction_seq_num) {
-	D_ASSERT(!handle.expired());
-}
-
-bool BufferEvictionNode::CanUnload(BlockHandle &handle_p) {
-	if (handle_sequence_number != handle_p.EvictionSequenceNumber()) {
-		// handle was used in between
-		return false;
-	}
-	return handle_p.CanUnload();
-}
-
-shared_ptr<BlockHandle> BufferEvictionNode::TryGetBlockHandle() {
-	auto handle_p = handle.lock();
-	if (!handle_p) {
-		// BlockHandle has been destroyed
-		return nullptr;
-	}
-	if (!CanUnload(*handle_p)) {
-		// handle was used in between
-		return nullptr;
-	}
-	// this is the latest node in the queue with this handle
-	return handle_p;
-}
-
-typedef duckdb_moodycamel::ConcurrentQueue<BufferEvictionNode> eviction_queue_t;
-
-struct EvictionQueue {
-public:
-	explicit EvictionQueue(const FileBufferType file_buffer_type_p)
-	    : file_buffer_type(file_buffer_type_p), evict_queue_insertions(0), total_dead_nodes(0) {
-	}
-
-public:
-	//! Add a buffer handle to the eviction queue. Returns true, if the queue is
-	//! ready to be purged, and false otherwise.
-	bool AddToEvictionQueue(BufferEvictionNode &&node);
-	//! Tries to dequeue an element from the eviction queue, but only after acquiring the purge queue lock.
-	bool TryDequeueWithLock(BufferEvictionNode &node);
-	//! Garbage collect dead nodes in the eviction queue.
-	void Purge();
-	template <typename FN>
-	void IterateUnloadableBlocks(FN fn);
-
-	//! Increment the dead node counter in the purge queue.
-	inline void IncrementDeadNodes() {
-		total_dead_nodes++;
-	}
-	//! Decrement the dead node counter in the purge queue.
-	inline void DecrementDeadNodes() {
-		total_dead_nodes--;
-	}
-
-private:
-	//! Bulk purge dead nodes from the eviction queue. Then, enqueue those that are still alive.
-	void PurgeIteration(const idx_t purge_size);
-
-public:
-	//! The type of the buffers in this queue
-	const FileBufferType file_buffer_type;
-	//! The concurrent queue
-	eviction_queue_t q;
-
-private:
-	//! We trigger a purge of the eviction queue every INSERT_INTERVAL insertions
-	constexpr static idx_t INSERT_INTERVAL = 4096;
-	//! We multiply the base purge size by this value.
-	constexpr static idx_t PURGE_SIZE_MULTIPLIER = 2;
-	//! We multiply the purge size by this value to determine early-outs. This is the minimum queue size.
-	//! We never purge below this point.
-	constexpr static idx_t EARLY_OUT_MULTIPLIER = 4;
-	//! We multiply the approximate alive nodes by this value to test whether our total dead nodes
-	//! exceed their allowed ratio. Must be greater than 1.
-	constexpr static idx_t ALIVE_NODE_MULTIPLIER = 4;
-
-private:
-	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
-	atomic<idx_t> evict_queue_insertions;
-	//! Total dead nodes in the eviction queue. There are two scenarios in which a node dies: (1) we destroy its block
-	//! handle, or (2) we insert a newer version into the eviction queue.
-	atomic<idx_t> total_dead_nodes;
-
-	//! Locked, if a queue purge is currently active or we're trying to forcefully evict a node.
-	//! Only lets a single thread enter the purge phase.
-	mutex purge_lock;
-	//! A pre-allocated vector of eviction nodes. We reuse this to keep the allocation overhead of purges small.
-	vector<BufferEvictionNode> purge_nodes;
-};
-
-bool EvictionQueue::AddToEvictionQueue(BufferEvictionNode &&node) {
-	q.enqueue(std::move(node));
-	return ++evict_queue_insertions % INSERT_INTERVAL == 0;
-}
-
-bool EvictionQueue::TryDequeueWithLock(BufferEvictionNode &node) {
-	lock_guard<mutex> lock(purge_lock);
-	return q.try_dequeue(node);
-}
-
-void EvictionQueue::Purge() {
-	// only one thread purges the queue, all other threads early-out
-	if (!purge_lock.try_lock()) {
-		return;
-	}
-	lock_guard<mutex> lock {purge_lock, std::adopt_lock};
-
-	// we purge INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER nodes
-	idx_t purge_size = INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER;
-
-	// get an estimate of the queue size as-of now
-	idx_t approx_q_size = q.size_approx();
-
-	// early-out, if the queue is not big enough to justify purging
-	// - we want to keep the LRU characteristic alive
-	if (approx_q_size < purge_size * EARLY_OUT_MULTIPLIER) {
-		return;
-	}
-
-	// There are two types of situations.
-
-	// For most scenarios, purging INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER nodes is enough.
-	// Purging more nodes than we insert also counters oscillation for scenarios where most nodes are dead.
-	// If we always purge slightly more, we trigger a purge less often, as we purge below the trigger.
-
-	// However, if the pressure on the queue becomes too contested, we need to purge more aggressively,
-	// i.e., we actively seek a specific number of dead nodes to purge. We use the total number of existing dead nodes.
-	// We detect this situation by observing the queue's ratio between alive vs. dead nodes. If the ratio of alive vs.
-	// dead nodes grows faster than we can purge, we keep purging until we hit one of the following conditions.
-
-	// 2.1. We're back at an approximate queue size less than purge_size * EARLY_OUT_MULTIPLIER.
-	// 2.2. We're back at a ratio of 1*alive_node:ALIVE_NODE_MULTIPLIER*dead_nodes.
-	// 2.3. We've purged the entire queue: max_purges is zero. This is a worst-case scenario,
-	// guaranteeing that we always exit the loop.
-
-	idx_t max_purges = approx_q_size / purge_size;
-	while (max_purges != 0) {
-		PurgeIteration(purge_size);
-
-		// update relevant sizes and potentially early-out
-		approx_q_size = q.size_approx();
-
-		// early-out according to (2.1)
-		if (approx_q_size < purge_size * EARLY_OUT_MULTIPLIER) {
-			break;
-		}
-
-		idx_t approx_dead_nodes = total_dead_nodes;
-		approx_dead_nodes = approx_dead_nodes > approx_q_size ? approx_q_size : approx_dead_nodes;
-		idx_t approx_alive_nodes = approx_q_size - approx_dead_nodes;
-
-		// early-out according to (2.2)
-		if (approx_alive_nodes * (ALIVE_NODE_MULTIPLIER - 1) > approx_dead_nodes) {
-			break;
-		}
-
-		max_purges--;
-	}
-}
-
-void EvictionQueue::PurgeIteration(const idx_t purge_size) {
-	// if this purge is significantly smaller or bigger than the previous purge, then
-	// we need to resize the purge_nodes vector. Note that this barely happens, as we
-	// purge queue_insertions * PURGE_SIZE_MULTIPLIER nodes
-	idx_t previous_purge_size = purge_nodes.size();
-	if (purge_size < previous_purge_size / 2 || purge_size > previous_purge_size) {
-		purge_nodes.resize(purge_size);
-	}
-
-	// bulk purge
-	idx_t actually_dequeued = q.try_dequeue_bulk(purge_nodes.begin(), purge_size);
-
-	// retrieve all alive nodes that have been wrongly dequeued
-	idx_t alive_nodes = 0;
-	for (idx_t i = 0; i < actually_dequeued; i++) {
-		auto &node = purge_nodes[i];
-		auto handle = node.TryGetBlockHandle();
-		if (handle) {
-			q.enqueue(std::move(node));
-			alive_nodes++;
-		}
-	}
-
-	total_dead_nodes -= actually_dequeued - alive_nodes;
-}
-
-BufferPool::BufferPool(idx_t maximum_memory, bool track_eviction_timestamps,
-                       idx_t allocator_bulk_deallocation_flush_threshold)
-    : eviction_queue_sizes({BLOCK_QUEUE_SIZE, MANAGED_BUFFER_QUEUE_SIZE, TINY_BUFFER_QUEUE_SIZE}),
-      maximum_memory(maximum_memory),
-      allocator_bulk_deallocation_flush_threshold(allocator_bulk_deallocation_flush_threshold),
-      track_eviction_timestamps(track_eviction_timestamps),
-      temporary_memory_manager(make_uniq<TemporaryMemoryManager>()) {
-	for (uint8_t type_idx = 0; type_idx < FILE_BUFFER_TYPE_COUNT; type_idx++) {
-		const auto type = static_cast<FileBufferType>(type_idx + 1);
-		const auto &type_queue_size = eviction_queue_sizes[type_idx];
-		for (idx_t queue_idx = 0; queue_idx < type_queue_size; queue_idx++) {
-			queues.push_back(make_uniq<EvictionQueue>(type));
-		}
-	}
-}
-BufferPool::~BufferPool() {
-}
-
-bool BufferPool::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
-	auto &queue = GetEvictionQueueForBlockHandle(*handle);
-
-	// The block handle is locked during this operation (Unpin),
-	// or the block handle is still a local variable (ConvertToPersistent)
-	D_ASSERT(handle->Readers() == 0);
-	auto ts = handle->NextEvictionSequenceNumber();
-	if (track_eviction_timestamps) {
-		handle->SetLRUTimestamp(
-		    std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now())
-		        .time_since_epoch()
-		        .count());
-	}
-
-	if (ts != 1) {
-		// we add a newer version, i.e., we kill exactly one previous version
-		queue.IncrementDeadNodes();
-	}
-
-	// Get the eviction queue for the block and add it
-	return queue.AddToEvictionQueue(BufferEvictionNode(weak_ptr<BlockHandle>(handle), ts));
-}
-
-EvictionQueue &BufferPool::GetEvictionQueueForBlockHandle(const BlockHandle &handle) {
-	const auto &handle_buffer_type = handle.GetBufferType();
-
-	// Get offset into eviction queues for this FileBufferType
-	idx_t queue_index = 0;
-	for (uint8_t type_idx = 0; type_idx < FILE_BUFFER_TYPE_COUNT; type_idx++) {
-		const auto queue_buffer_type = static_cast<FileBufferType>(type_idx + 1);
-		if (handle_buffer_type == queue_buffer_type) {
-			break;
-		}
-		const auto &type_queue_size = eviction_queue_sizes[type_idx];
-		queue_index += type_queue_size;
-	}
-
-	const auto &queue_size = eviction_queue_sizes[static_cast<uint8_t>(handle_buffer_type) - 1];
-	// Adjust if eviction_queue_idx is set (idx == 0 -> add at back, idx >= queue_size -> add at front)
-	auto eviction_queue_idx = handle.GetEvictionQueueIndex();
-	if (eviction_queue_idx < queue_size) {
-		queue_index += queue_size - eviction_queue_idx - 1;
-	}
-
-	D_ASSERT(queues[queue_index]->file_buffer_type == handle_buffer_type);
-	return *queues[queue_index];
-}
-
-void BufferPool::IncrementDeadNodes(const BlockHandle &handle) {
-	GetEvictionQueueForBlockHandle(handle).IncrementDeadNodes();
-}
-
-void BufferPool::UpdateUsedMemory(MemoryTag tag, int64_t size) {
-	memory_usage.UpdateUsedMemory(tag, size);
-}
-
-idx_t BufferPool::GetUsedMemory() const {
-	return memory_usage.GetUsedMemory(MemoryUsageCaches::FLUSH);
-}
-
-idx_t BufferPool::GetMaxMemory() const {
-	return maximum_memory;
-}
-
-idx_t BufferPool::GetQueryMaxMemory() const {
-	return GetMaxMemory();
-}
-
-TemporaryMemoryManager &BufferPool::GetTemporaryMemoryManager() {
-	return *temporary_memory_manager;
-}
-
-BufferPool::EvictionResult BufferPool::EvictBlocks(MemoryTag tag, idx_t extra_memory, idx_t memory_limit,
-                                                   unique_ptr<FileBuffer> *buffer) {
-	for (auto &queue : queues) {
-		auto block_result = EvictBlocksInternal(*queue, tag, extra_memory, memory_limit, buffer);
-		if (block_result.success || RefersToSameObject(*queue, *queues.back())) {
-			return block_result; // Return upon success or upon last queue
-		}
-	}
-	// This can never happen since we always return when i == 1. Exception to silence compiler warning
-	throw InternalException("Exited BufferPool::EvictBlocksInternal without obtaining BufferPool::EvictionResult");
-}
-
-BufferPool::EvictionResult BufferPool::EvictBlocksInternal(EvictionQueue &queue, MemoryTag tag, idx_t extra_memory,
-                                                           idx_t memory_limit, unique_ptr<FileBuffer> *buffer) {
-	TempBufferPoolReservation r(tag, *this, extra_memory);
-	bool found = false;
-
-	if (memory_usage.GetUsedMemory(MemoryUsageCaches::NO_FLUSH) <= memory_limit) {
-		if (Allocator::SupportsFlush() && extra_memory > allocator_bulk_deallocation_flush_threshold) {
-			Allocator::FlushAll();
-		}
-		return {true, std::move(r)};
-	}
-
-	queue.IterateUnloadableBlocks([&](BufferEvictionNode &, const shared_ptr<BlockHandle> &handle, BlockLock &lock) {
-		// hooray, we can unload the block
-		if (buffer && handle->GetBuffer(lock)->AllocSize() == extra_memory) {
-			// we can re-use the memory directly
-			*buffer = handle->UnloadAndTakeBlock(lock);
-			found = true;
-			return false;
-		}
-
-		// release the memory and mark the block as unloaded
-		handle->Unload(lock);
-
-		if (memory_usage.GetUsedMemory(MemoryUsageCaches::NO_FLUSH) <= memory_limit) {
-			found = true;
-			return false;
-		}
-
-		// Continue iteration
-		return true;
-	});
-
-	if (!found) {
-		r.Resize(0);
-	} else if (Allocator::SupportsFlush() && extra_memory > allocator_bulk_deallocation_flush_threshold) {
-		Allocator::FlushAll();
-	}
-
-	return {found, std::move(r)};
-}
-
-idx_t BufferPool::PurgeAgedBlocks(uint32_t max_age_sec) {
-	int64_t now = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now())
-	                  .time_since_epoch()
-	                  .count();
-	int64_t limit = now - (static_cast<int64_t>(max_age_sec) * 1000);
-	idx_t purged_bytes = 0;
-	for (auto &queue : queues) {
-		purged_bytes += PurgeAgedBlocksInternal(*queue, max_age_sec, now, limit);
-	}
-	return purged_bytes;
-}
-
-idx_t BufferPool::PurgeAgedBlocksInternal(EvictionQueue &queue, uint32_t max_age_sec, int64_t now, int64_t limit) {
-	idx_t purged_bytes = 0;
-	queue.IterateUnloadableBlocks(
-	    [&](BufferEvictionNode &node, const shared_ptr<BlockHandle> &handle, BlockLock &lock) {
-		    // We will unload this block regardless. But stop the iteration immediately afterward if this
-		    // block is younger than the age threshold.
-		    auto lru_timestamp_msec = handle->GetLRUTimestamp();
-		    bool is_fresh = lru_timestamp_msec >= limit && lru_timestamp_msec <= now;
-		    purged_bytes += handle->GetMemoryUsage();
-		    handle->Unload(lock);
-		    // Return false to stop iterating if the current block is_fresh
-		    return !is_fresh;
-	    });
-	return purged_bytes;
-}
-
-template <typename FN>
-void EvictionQueue::IterateUnloadableBlocks(FN fn) {
-	for (;;) {
-		// get a block to unpin from the queue
-		BufferEvictionNode node;
-		if (!q.try_dequeue(node)) {
-			// we could not dequeue any eviction node, so we try one more time,
-			// but more aggressively
-			if (!TryDequeueWithLock(node)) {
-				return;
-			}
-		}
-
-		// get a reference to the underlying block pointer
-		auto handle = node.TryGetBlockHandle();
-		if (!handle) {
-			DecrementDeadNodes();
-			continue;
-		}
-
-		// we might be able to free this block: grab the mutex and check if we can free it
-		auto lock = handle->GetLock();
-		if (!node.CanUnload(*handle)) {
-			// something changed in the mean-time, bail out
-			DecrementDeadNodes();
-			continue;
-		}
-
-		if (!fn(node, handle, lock)) {
-			break;
-		}
-	}
-}
-
-void BufferPool::PurgeQueue(const BlockHandle &block) {
-	GetEvictionQueueForBlockHandle(block).Purge();
-}
-
-void BufferPool::SetLimit(idx_t limit, const char *exception_postscript) {
-	lock_guard<mutex> l_lock(limit_lock);
-	// try to evict until the limit is reached
-	if (!EvictBlocks(MemoryTag::EXTENSION, 0, limit).success) {
-		throw OutOfMemoryException(
-		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
-		    exception_postscript);
-	}
-	idx_t old_limit = maximum_memory;
-	// set the global maximum memory to the new limit if successful
-	maximum_memory = limit;
-	// evict again
-	if (!EvictBlocks(MemoryTag::EXTENSION, 0, limit).success) {
-		// failed: go back to old limit
-		maximum_memory = old_limit;
-		throw OutOfMemoryException(
-		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
-		    exception_postscript);
-	}
-	if (Allocator::SupportsFlush()) {
-		Allocator::FlushAll();
-	}
-}
-
-void BufferPool::SetAllocatorBulkDeallocationFlushThreshold(idx_t threshold) {
-	allocator_bulk_deallocation_flush_threshold = threshold;
-}
-
-idx_t BufferPool::GetAllocatorBulkDeallocationFlushThreshold() {
-	return allocator_bulk_deallocation_flush_threshold;
-}
-
-BufferPool::MemoryUsage::MemoryUsage() {
-	for (auto &v : memory_usage) {
-		v = 0;
-	}
-	for (auto &cache : memory_usage_caches) {
-		for (auto &v : cache) {
-			v = 0;
-		}
-	}
-}
-
-void BufferPool::MemoryUsage::UpdateUsedMemory(MemoryTag tag, int64_t size) {
-	auto tag_idx = (idx_t)tag;
-	if ((idx_t)AbsValue(size) < MEMORY_USAGE_CACHE_THRESHOLD) {
-		// update cache and update global counter when cache exceeds threshold
-		// Get corresponding cache slot based on current CPU core index
-		// Two threads may access the same cache simultaneously,
-		// ensuring correctness through atomic operations
-		auto cache_idx = (idx_t)TaskScheduler::GetEstimatedCPUId() % MEMORY_USAGE_CACHE_COUNT;
-		auto &cache = memory_usage_caches[cache_idx];
-		auto new_tag_size = cache[tag_idx].fetch_add(size, std::memory_order_relaxed) + size;
-		if ((idx_t)AbsValue(new_tag_size) >= MEMORY_USAGE_CACHE_THRESHOLD) {
-			// cached tag memory usage exceeds threshold
-			auto tag_size = cache[tag_idx].exchange(0, std::memory_order_relaxed);
-			memory_usage[tag_idx].fetch_add(tag_size, std::memory_order_relaxed);
-		}
-		auto new_total_size = cache[TOTAL_MEMORY_USAGE_INDEX].fetch_add(size, std::memory_order_relaxed) + size;
-		if ((idx_t)AbsValue(new_total_size) >= MEMORY_USAGE_CACHE_THRESHOLD) {
-			// cached total memory usage exceeds threshold
-			auto total_size = cache[TOTAL_MEMORY_USAGE_INDEX].exchange(0, std::memory_order_relaxed);
-			memory_usage[TOTAL_MEMORY_USAGE_INDEX].fetch_add(total_size, std::memory_order_relaxed);
-		}
-	} else {
-		// update global counter
-		memory_usage[tag_idx].fetch_add(size, std::memory_order_relaxed);
-		memory_usage[TOTAL_MEMORY_USAGE_INDEX].fetch_add(size, std::memory_order_relaxed);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp b/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp
deleted file mode 100644
index 783a98079..000000000
--- a/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-
-namespace duckdb {
-
-BufferPoolReservation::BufferPoolReservation(MemoryTag tag, BufferPool &pool) : tag(tag), pool(pool) {
-}
-
-BufferPoolReservation::BufferPoolReservation(BufferPoolReservation &&src) noexcept : tag(src.tag), pool(src.pool) {
-	size = src.size;
-	src.size = 0;
-}
-
-BufferPoolReservation &BufferPoolReservation::operator=(BufferPoolReservation &&src) noexcept {
-	tag = src.tag;
-	size = src.size;
-	src.size = 0;
-	return *this;
-}
-
-BufferPoolReservation::~BufferPoolReservation() {
-	D_ASSERT(size == 0);
-}
-
-void BufferPoolReservation::Resize(idx_t new_size) {
-	auto delta = UnsafeNumericCast<int64_t>(new_size) - UnsafeNumericCast<int64_t>(size);
-	pool.UpdateUsedMemory(tag, delta);
-	size = new_size;
-}
-
-void BufferPoolReservation::Merge(BufferPoolReservation src) {
-	size += src.size;
-	src.size = 0;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/buffer_manager.cpp b/src/duckdb/src/storage/buffer_manager.cpp
deleted file mode 100644
index 1ff33caa4..000000000
--- a/src/duckdb/src/storage/buffer_manager.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/standard_buffer_manager.hpp"
-
-namespace duckdb {
-
-shared_ptr<BlockHandle> BufferManager::RegisterTransientMemory(const idx_t size, const idx_t block_size) {
-	throw NotImplementedException("This type of BufferManager can not create 'transient-memory' blocks");
-}
-
-shared_ptr<BlockHandle> BufferManager::RegisterSmallMemory(const idx_t size) {
-	return RegisterSmallMemory(MemoryTag::BASE_TABLE, size);
-}
-
-shared_ptr<BlockHandle> BufferManager::RegisterSmallMemory(MemoryTag tag, const idx_t size) {
-	throw NotImplementedException("This type of BufferManager can not create 'small-memory' blocks");
-}
-
-Allocator &BufferManager::GetBufferAllocator() {
-	throw NotImplementedException("This type of BufferManager does not have an Allocator");
-}
-
-void BufferManager::ReserveMemory(idx_t size) {
-	throw NotImplementedException("This type of BufferManager can not reserve memory");
-}
-void BufferManager::FreeReservedMemory(idx_t size) {
-	throw NotImplementedException("This type of BufferManager can not free reserved memory");
-}
-
-void BufferManager::SetMemoryLimit(idx_t limit) {
-	throw NotImplementedException("This type of BufferManager can not set a memory limit");
-}
-
-void BufferManager::SetSwapLimit(optional_idx limit) {
-	throw NotImplementedException("This type of BufferManager can not set a swap limit");
-}
-
-vector<TemporaryFileInformation> BufferManager::GetTemporaryFiles() {
-	throw InternalException("This type of BufferManager does not allow temporary files");
-}
-
-const string &BufferManager::GetTemporaryDirectory() const {
-	throw InternalException("This type of BufferManager does not allow a temporary directory");
-}
-
-BufferPool &BufferManager::GetBufferPool() const {
-	throw InternalException("This type of BufferManager does not have a buffer pool");
-}
-
-TemporaryMemoryManager &BufferManager::GetTemporaryMemoryManager() {
-	throw NotImplementedException("This type of BufferManager does not have a TemporaryMemoryManager");
-}
-
-void BufferManager::SetTemporaryDirectory(const string &new_dir) {
-	throw NotImplementedException("This type of BufferManager can not set a temporary directory");
-}
-
-bool BufferManager::HasTemporaryDirectory() const {
-	return false;
-}
-
-//! Returns the maximum available memory for a given query
-idx_t BufferManager::GetQueryMaxMemory() const {
-	return GetBufferPool().GetQueryMaxMemory();
-}
-
-unique_ptr<FileBuffer> BufferManager::ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&,
-                                                             FileBufferType type) {
-	throw NotImplementedException("This type of BufferManager can not construct managed buffers");
-}
-
-// Protected methods
-
-void BufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
-	throw NotImplementedException("This type of BufferManager does not support 'AddToEvictionQueue");
-}
-
-void BufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) {
-	throw NotImplementedException("This type of BufferManager does not support 'WriteTemporaryBuffer");
-}
-
-unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(MemoryTag tag, BlockHandle &block,
-                                                          unique_ptr<FileBuffer> buffer) {
-	throw NotImplementedException("This type of BufferManager does not support 'ReadTemporaryBuffer");
-}
-
-void BufferManager::DeleteTemporaryFile(BlockHandle &block) {
-	throw NotImplementedException("This type of BufferManager does not support 'DeleteTemporaryFile");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/checkpoint/row_group_writer.cpp b/src/duckdb/src/storage/checkpoint/row_group_writer.cpp
deleted file mode 100644
index 14be12778..000000000
--- a/src/duckdb/src/storage/checkpoint/row_group_writer.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-
-namespace duckdb {
-
-CompressionType RowGroupWriter::GetColumnCompressionType(idx_t i) {
-	return table.GetColumn(LogicalIndex(i)).CompressionType();
-}
-
-SingleFileRowGroupWriter::SingleFileRowGroupWriter(TableCatalogEntry &table, PartialBlockManager &partial_block_manager,
-                                                   TableDataWriter &writer, MetadataWriter &table_data_writer)
-    : RowGroupWriter(table, partial_block_manager), writer(writer), table_data_writer(table_data_writer) {
-}
-
-CheckpointType SingleFileRowGroupWriter::GetCheckpointType() const {
-	return writer.GetCheckpointType();
-}
-
-MetadataWriter &SingleFileRowGroupWriter::GetPayloadWriter() {
-	return table_data_writer;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/checkpoint/table_data_reader.cpp b/src/duckdb/src/storage/checkpoint/table_data_reader.cpp
deleted file mode 100644
index 5f76227f3..000000000
--- a/src/duckdb/src/storage/checkpoint/table_data_reader.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/storage/checkpoint/table_data_reader.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-
-#include "duckdb/main/database.hpp"
-
-namespace duckdb {
-
-TableDataReader::TableDataReader(MetadataReader &reader, BoundCreateTableInfo &info) : reader(reader), info(info) {
-	info.data = make_uniq<PersistentTableData>(info.Base().columns.LogicalColumnCount());
-}
-
-void TableDataReader::ReadTableData() {
-	auto &columns = info.Base().columns;
-	D_ASSERT(!columns.empty());
-
-	// We stored the table statistics as a unit in FinalizeTable.
-	BinaryDeserializer stats_deserializer(reader);
-	stats_deserializer.Begin();
-	info.data->table_stats.Deserialize(stats_deserializer, columns);
-	stats_deserializer.End();
-
-	// Deserialize the row group pointers (lazily, just set the count and the pointer to them for now)
-	info.data->row_group_count = reader.Read<uint64_t>();
-	info.data->block_pointer = reader.GetMetaBlockPointer();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/checkpoint/table_data_writer.cpp b/src/duckdb/src/storage/checkpoint/table_data_writer.cpp
deleted file mode 100644
index 5a134c3c6..000000000
--- a/src/duckdb/src/storage/checkpoint/table_data_writer.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/table_statistics.hpp"
-
-namespace duckdb {
-
-TableDataWriter::TableDataWriter(TableCatalogEntry &table_p) : table(table_p.Cast<DuckTableEntry>()) {
-	D_ASSERT(table_p.IsDuckTable());
-}
-
-TableDataWriter::~TableDataWriter() {
-}
-
-void TableDataWriter::WriteTableData(Serializer &metadata_serializer) {
-	// start scanning the table and append the data to the uncompressed segments
-	table.GetStorage().Checkpoint(*this, metadata_serializer);
-}
-
-CompressionType TableDataWriter::GetColumnCompressionType(idx_t i) {
-	return table.GetColumn(LogicalIndex(i)).CompressionType();
-}
-
-void TableDataWriter::AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> writer) {
-	row_group_pointers.push_back(std::move(row_group_pointer));
-}
-
-TaskScheduler &TableDataWriter::GetScheduler() {
-	return TaskScheduler::GetScheduler(GetDatabase());
-}
-
-DatabaseInstance &TableDataWriter::GetDatabase() {
-	return table.ParentCatalog().GetDatabase();
-}
-
-SingleFileTableDataWriter::SingleFileTableDataWriter(SingleFileCheckpointWriter &checkpoint_manager,
-                                                     TableCatalogEntry &table, MetadataWriter &table_data_writer)
-    : TableDataWriter(table), checkpoint_manager(checkpoint_manager), table_data_writer(table_data_writer) {
-}
-
-unique_ptr<RowGroupWriter> SingleFileTableDataWriter::GetRowGroupWriter(RowGroup &row_group) {
-	return make_uniq<SingleFileRowGroupWriter>(table, checkpoint_manager.partial_block_manager, *this,
-	                                           table_data_writer);
-}
-
-CheckpointType SingleFileTableDataWriter::GetCheckpointType() const {
-	return checkpoint_manager.GetCheckpointType();
-}
-
-void SingleFileTableDataWriter::FinalizeTable(const TableStatistics &global_stats, DataTableInfo *info,
-                                              Serializer &serializer) {
-
-	// store the current position in the metadata writer
-	// this is where the row groups for this table start
-	auto pointer = table_data_writer.GetMetaBlockPointer();
-
-	// Serialize statistics as a single unit
-	BinarySerializer stats_serializer(table_data_writer);
-	stats_serializer.Begin();
-	global_stats.Serialize(stats_serializer);
-	stats_serializer.End();
-
-	// now start writing the row group pointers to disk
-	table_data_writer.Write<uint64_t>(row_group_pointers.size());
-	idx_t total_rows = 0;
-	for (auto &row_group_pointer : row_group_pointers) {
-		auto row_group_count = row_group_pointer.row_start + row_group_pointer.tuple_count;
-		if (row_group_count > total_rows) {
-			total_rows = row_group_count;
-		}
-
-		// Each RowGroup is its own unit
-		BinarySerializer row_group_serializer(table_data_writer);
-		row_group_serializer.Begin();
-		RowGroup::Serialize(row_group_pointer, row_group_serializer);
-		row_group_serializer.End();
-	}
-
-	// Now begin the metadata as a unit
-	// Pointer to the table itself goes to the metadata stream.
-	serializer.WriteProperty(101, "table_pointer", pointer);
-	serializer.WriteProperty(102, "total_rows", total_rows);
-
-	auto db_options = checkpoint_manager.db.GetDatabase().config.options;
-	auto v1_0_0_storage = db_options.serialization_compatibility.serialization_version < 3;
-	case_insensitive_map_t<Value> options;
-	if (!v1_0_0_storage) {
-		options.emplace("v1_0_0_storage", v1_0_0_storage);
-	}
-	auto index_storage_infos = info->GetIndexes().GetStorageInfos(options);
-
-#ifdef DUCKDB_BLOCK_VERIFICATION
-	for (auto &entry : index_storage_infos) {
-		for (auto &allocator : entry.allocator_infos) {
-			for (auto &block : allocator.block_pointers) {
-				checkpoint_manager.verify_block_usage_count[block.block_id]++;
-			}
-		}
-	}
-#endif
-
-	// write empty block pointers for forwards compatibility
-	vector<BlockPointer> compat_block_pointers;
-	serializer.WriteProperty(103, "index_pointers", compat_block_pointers);
-	serializer.WritePropertyWithDefault(104, "index_storage_infos", index_storage_infos);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp b/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp
deleted file mode 100644
index c58be3102..000000000
--- a/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/partial_block_manager.hpp"
-
-namespace duckdb {
-
-WriteOverflowStringsToDisk::WriteOverflowStringsToDisk(PartialBlockManager &partial_block_manager)
-    : partial_block_manager(partial_block_manager), block_id(INVALID_BLOCK), offset(0) {
-}
-
-WriteOverflowStringsToDisk::~WriteOverflowStringsToDisk() {
-	// verify that the overflow writer has been flushed
-	D_ASSERT(Exception::UncaughtException() || offset == 0);
-}
-
-shared_ptr<BlockHandle> UncompressedStringSegmentState::GetHandle(BlockManager &manager, block_id_t block_id) {
-	lock_guard<mutex> lock(block_lock);
-	auto entry = handles.find(block_id);
-	if (entry != handles.end()) {
-		return entry->second;
-	}
-	auto result = manager.RegisterBlock(block_id);
-	handles.insert(make_pair(block_id, result));
-	return result;
-}
-
-void UncompressedStringSegmentState::RegisterBlock(BlockManager &manager, block_id_t block_id) {
-	lock_guard<mutex> lock(block_lock);
-	auto entry = handles.find(block_id);
-	if (entry != handles.end()) {
-		throw InternalException("UncompressedStringSegmentState::RegisterBlock - block id %llu already exists",
-		                        block_id);
-	}
-	auto result = manager.RegisterBlock(block_id);
-	handles.insert(make_pair(block_id, std::move(result)));
-	on_disk_blocks.push_back(block_id);
-}
-
-void WriteOverflowStringsToDisk::WriteString(UncompressedStringSegmentState &state, string_t string,
-                                             block_id_t &result_block, int32_t &result_offset) {
-	auto &block_manager = partial_block_manager.GetBlockManager();
-	auto &buffer_manager = block_manager.buffer_manager;
-	if (!handle.IsValid()) {
-		handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, block_manager.GetBlockSize());
-	}
-	// first write the length of the string
-	if (block_id == INVALID_BLOCK || offset + 2 * sizeof(uint32_t) >= GetStringSpace()) {
-		AllocateNewBlock(state, block_manager.GetFreeBlockId());
-	}
-	result_block = block_id;
-	result_offset = UnsafeNumericCast<int32_t>(offset);
-
-	// write the length field
-	auto data_ptr = handle.Ptr();
-	auto string_length = string.GetSize();
-	Store<uint32_t>(UnsafeNumericCast<uint32_t>(string_length), data_ptr + offset);
-	offset += sizeof(uint32_t);
-
-	// now write the remainder of the string
-	auto strptr = string.GetData();
-	auto remaining = UnsafeNumericCast<uint32_t>(string_length);
-	while (remaining > 0) {
-		uint32_t to_write = MinValue<uint32_t>(remaining, UnsafeNumericCast<uint32_t>(GetStringSpace() - offset));
-		if (to_write > 0) {
-			memcpy(data_ptr + offset, strptr, to_write);
-
-			remaining -= to_write;
-			offset += to_write;
-			strptr += to_write;
-		}
-		if (remaining > 0) {
-			D_ASSERT(offset == GetStringSpace());
-			// there is still remaining stuff to write
-			// now write the current block to disk and allocate a new block
-			AllocateNewBlock(state, block_manager.GetFreeBlockId());
-		}
-	}
-}
-
-void WriteOverflowStringsToDisk::Flush() {
-	if (block_id != INVALID_BLOCK && offset > 0) {
-		// zero-initialize the empty part of the overflow string buffer (if any)
-		if (offset < GetStringSpace()) {
-			memset(handle.Ptr() + offset, 0, GetStringSpace() - offset);
-		}
-		// write to disk
-		auto &block_manager = partial_block_manager.GetBlockManager();
-		block_manager.Write(handle.GetFileBuffer(), block_id);
-
-		auto lock = partial_block_manager.GetLock();
-		partial_block_manager.AddWrittenBlock(block_id);
-	}
-	block_id = INVALID_BLOCK;
-	offset = 0;
-}
-
-void WriteOverflowStringsToDisk::AllocateNewBlock(UncompressedStringSegmentState &state, block_id_t new_block_id) {
-	if (block_id != INVALID_BLOCK) {
-		// there is an old block, write it first
-		// write the new block id at the end of the previous block
-		Store<block_id_t>(new_block_id, handle.Ptr() + GetStringSpace());
-		Flush();
-	}
-	offset = 0;
-	block_id = new_block_id;
-	auto &block_manager = partial_block_manager.GetBlockManager();
-	state.RegisterBlock(block_manager, new_block_id);
-}
-
-idx_t WriteOverflowStringsToDisk::GetStringSpace() const {
-	auto &block_manager = partial_block_manager.GetBlockManager();
-	return block_manager.GetBlockSize() - sizeof(block_id_t);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/checkpoint_manager.cpp b/src/duckdb/src/storage/checkpoint_manager.cpp
deleted file mode 100644
index f28bdc454..000000000
--- a/src/duckdb/src/storage/checkpoint_manager.cpp
+++ /dev/null
@@ -1,604 +0,0 @@
-#include "duckdb/storage/checkpoint_manager.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/unbound_index.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/connection.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/checkpoint/table_data_reader.hpp"
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-
-namespace duckdb {
-
-void ReorderTableEntries(catalog_entry_vector_t &tables);
-
-SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager,
-                                                       CheckpointType checkpoint_type)
-    : CheckpointWriter(db), partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT),
-      checkpoint_type(checkpoint_type) {
-}
-
-BlockManager &SingleFileCheckpointWriter::GetBlockManager() {
-	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
-	return *storage_manager.block_manager;
-}
-
-MetadataWriter &SingleFileCheckpointWriter::GetMetadataWriter() {
-	return *metadata_writer;
-}
-
-MetadataManager &SingleFileCheckpointWriter::GetMetadataManager() {
-	return GetBlockManager().GetMetadataManager();
-}
-
-unique_ptr<TableDataWriter> SingleFileCheckpointWriter::GetTableDataWriter(TableCatalogEntry &table) {
-	return make_uniq<SingleFileTableDataWriter>(*this, table, *table_metadata_writer);
-}
-
-static catalog_entry_vector_t GetCatalogEntries(vector<reference<SchemaCatalogEntry>> &schemas) {
-	catalog_entry_vector_t entries;
-	for (auto &schema_p : schemas) {
-		auto &schema = schema_p.get();
-		entries.push_back(schema);
-		schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			entries.push_back(entry);
-		});
-
-		schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			entries.push_back(entry);
-		});
-
-		catalog_entry_vector_t tables;
-		vector<reference<ViewCatalogEntry>> views;
-		schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			if (entry.type == CatalogType::TABLE_ENTRY) {
-				tables.push_back(entry.Cast<TableCatalogEntry>());
-			} else if (entry.type == CatalogType::VIEW_ENTRY) {
-				views.push_back(entry.Cast<ViewCatalogEntry>());
-			} else {
-				throw NotImplementedException("Catalog type for entries");
-			}
-		});
-		// Reorder tables because of foreign key constraint
-		ReorderTableEntries(tables);
-		for (auto &table : tables) {
-			entries.push_back(table.get());
-		}
-		for (auto &view : views) {
-			entries.push_back(view.get());
-		}
-
-		schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			if (entry.type == CatalogType::MACRO_ENTRY) {
-				entries.push_back(entry);
-			}
-		});
-
-		schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
-			if (entry.internal) {
-				return;
-			}
-			if (entry.type == CatalogType::TABLE_MACRO_ENTRY) {
-				entries.push_back(entry);
-			}
-		});
-
-		schema.Scan(CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) {
-			D_ASSERT(!entry.internal);
-			entries.push_back(entry);
-		});
-	}
-	return entries;
-}
-
-void SingleFileCheckpointWriter::CreateCheckpoint() {
-	auto &config = DBConfig::Get(db);
-	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
-	if (storage_manager.InMemory()) {
-		return;
-	}
-	// assert that the checkpoint manager hasn't been used before
-	D_ASSERT(!metadata_writer);
-
-	auto &block_manager = GetBlockManager();
-	auto &metadata_manager = GetMetadataManager();
-
-	//! Set up the writers for the checkpoints
-	metadata_writer = make_uniq<MetadataWriter>(metadata_manager);
-	table_metadata_writer = make_uniq<MetadataWriter>(metadata_manager);
-
-	// get the id of the first meta block
-	auto meta_block = metadata_writer->GetMetaBlockPointer();
-
-	vector<reference<SchemaCatalogEntry>> schemas;
-	// we scan the set of committed schemas
-	auto &catalog = Catalog::GetCatalog(db).Cast<DuckCatalog>();
-	catalog.ScanSchemas([&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
-
-	catalog_entry_vector_t catalog_entries;
-	D_ASSERT(catalog.IsDuckCatalog());
-
-	auto &dependency_manager = *catalog.GetDependencyManager();
-	catalog_entries = GetCatalogEntries(schemas);
-	dependency_manager.ReorderEntries(catalog_entries);
-
-	// write the actual data into the database
-
-	// Create a serializer to write the checkpoint data
-	// The serialized format is roughly:
-	/*
-	    {
-	        schemas: [
-	            {
-	                schema: <schema_info>,
-	                custom_types: [ { type: <type_info> }, ... ],
-	                sequences: [ { sequence: <sequence_info> }, ... ],
-	                tables: [ { table: <table_info> }, ... ],
-	                views: [ { view: <view_info> }, ... ],
-	                macros: [ { macro: <macro_info> }, ... ],
-	                table_macros: [ { table_macro: <table_macro_info> }, ... ],
-	                indexes: [ { index: <index_info>, root_offset <block_ptr> }, ... ]
-	            }
-	        ]
-	    }
-	 */
-	SerializationOptions serialization_options;
-
-	serialization_options.serialization_compatibility = config.options.serialization_compatibility;
-
-	BinarySerializer serializer(*metadata_writer, serialization_options);
-	serializer.Begin();
-	serializer.WriteList(100, "catalog_entries", catalog_entries.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = catalog_entries[i];
-		list.WriteObject([&](Serializer &obj) { WriteEntry(entry.get(), obj); });
-	});
-	serializer.End();
-
-	metadata_writer->Flush();
-	table_metadata_writer->Flush();
-
-	// write a checkpoint flag to the WAL
-	// this protects against the rare event that the database crashes AFTER writing the file, but BEFORE truncating the
-	// WAL we write an entry CHECKPOINT "meta_block_id" into the WAL upon loading, if we see there is an entry
-	// CHECKPOINT "meta_block_id", and the id MATCHES the head idin the file we know that the database was successfully
-	// checkpointed, so we know that we should avoid replaying the WAL to avoid duplicating data
-	bool wal_is_empty = storage_manager.GetWALSize() == 0;
-	if (!wal_is_empty) {
-		auto wal = storage_manager.GetWAL();
-		wal->WriteCheckpoint(meta_block);
-		wal->Flush();
-	}
-
-	if (config.options.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER) {
-		throw FatalException("Checkpoint aborted before header write because of PRAGMA checkpoint_abort flag");
-	}
-
-	// finally write the updated header
-	DatabaseHeader header;
-	header.meta_block = meta_block.block_pointer;
-	header.block_alloc_size = block_manager.GetBlockAllocSize();
-	header.vector_size = STANDARD_VECTOR_SIZE;
-	block_manager.WriteHeader(header);
-
-#ifdef DUCKDB_BLOCK_VERIFICATION
-	// extend verify_block_usage_count
-	auto metadata_info = storage_manager.GetMetadataInfo();
-	for (auto &info : metadata_info) {
-		verify_block_usage_count[info.block_id]++;
-	}
-	for (auto &entry_ref : catalog_entries) {
-		auto &entry = entry_ref.get();
-		if (entry.type == CatalogType::TABLE_ENTRY) {
-			auto &table = entry.Cast<DuckTableEntry>();
-			auto &storage = table.GetStorage();
-			auto segment_info = storage.GetColumnSegmentInfo();
-			for (auto &segment : segment_info) {
-				verify_block_usage_count[segment.block_id]++;
-				if (StringUtil::Contains(segment.segment_info, "Overflow String Block Ids: ")) {
-					auto overflow_blocks = StringUtil::Replace(segment.segment_info, "Overflow String Block Ids: ", "");
-					auto splits = StringUtil::Split(overflow_blocks, ", ");
-					for (auto &split : splits) {
-						auto overflow_block_id = std::stoll(split);
-						verify_block_usage_count[overflow_block_id]++;
-					}
-				}
-			}
-		}
-	}
-	block_manager.VerifyBlocks(verify_block_usage_count);
-#endif
-
-	if (config.options.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE) {
-		throw FatalException("Checkpoint aborted before truncate because of PRAGMA checkpoint_abort flag");
-	}
-
-	// truncate the file
-	block_manager.Truncate();
-
-	// truncate the WAL
-	if (!wal_is_empty) {
-		storage_manager.ResetWAL();
-	}
-}
-
-void CheckpointReader::LoadCheckpoint(CatalogTransaction transaction, MetadataReader &reader) {
-	BinaryDeserializer deserializer(reader);
-	deserializer.Begin();
-	deserializer.ReadList(100, "catalog_entries", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadEntry(transaction, obj); });
-	});
-	deserializer.End();
-}
-
-MetadataManager &SingleFileCheckpointReader::GetMetadataManager() {
-	return storage.block_manager->GetMetadataManager();
-}
-
-void SingleFileCheckpointReader::LoadFromStorage() {
-	auto &block_manager = *storage.block_manager;
-	auto &metadata_manager = GetMetadataManager();
-	MetaBlockPointer meta_block(block_manager.GetMetaBlock(), 0);
-	if (!meta_block.IsValid()) {
-		// storage is empty
-		return;
-	}
-
-	if (block_manager.IsRemote()) {
-		auto metadata_blocks = metadata_manager.GetBlocks();
-		auto &buffer_manager = BufferManager::GetBufferManager(storage.GetDatabase());
-		buffer_manager.Prefetch(metadata_blocks);
-	}
-
-	// create the MetadataReader to read from the storage
-	MetadataReader reader(metadata_manager, meta_block);
-	auto transaction = CatalogTransaction::GetSystemTransaction(catalog.GetDatabase());
-	LoadCheckpoint(transaction, reader);
-}
-
-void CheckpointWriter::WriteEntry(CatalogEntry &entry, Serializer &serializer) {
-	serializer.WriteProperty(99, "catalog_type", entry.type);
-
-	switch (entry.type) {
-	case CatalogType::SCHEMA_ENTRY: {
-		auto &schema = entry.Cast<SchemaCatalogEntry>();
-		WriteSchema(schema, serializer);
-		break;
-	}
-	case CatalogType::TYPE_ENTRY: {
-		auto &custom_type = entry.Cast<TypeCatalogEntry>();
-		WriteType(custom_type, serializer);
-		break;
-	}
-	case CatalogType::SEQUENCE_ENTRY: {
-		auto &seq = entry.Cast<SequenceCatalogEntry>();
-		WriteSequence(seq, serializer);
-		break;
-	}
-	case CatalogType::TABLE_ENTRY: {
-		auto &table = entry.Cast<TableCatalogEntry>();
-		WriteTable(table, serializer);
-		break;
-	}
-	case CatalogType::VIEW_ENTRY: {
-		auto &view = entry.Cast<ViewCatalogEntry>();
-		WriteView(view, serializer);
-		break;
-	}
-	case CatalogType::MACRO_ENTRY: {
-		auto &macro = entry.Cast<ScalarMacroCatalogEntry>();
-		WriteMacro(macro, serializer);
-		break;
-	}
-	case CatalogType::TABLE_MACRO_ENTRY: {
-		auto &macro = entry.Cast<TableMacroCatalogEntry>();
-		WriteTableMacro(macro, serializer);
-		break;
-	}
-	case CatalogType::INDEX_ENTRY: {
-		auto &index = entry.Cast<IndexCatalogEntry>();
-		WriteIndex(index, serializer);
-		break;
-	}
-	default:
-		throw InternalException("Unrecognized catalog type in CheckpointWriter::WriteEntry");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Schema
-//===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer) {
-	// write the schema data
-	serializer.WriteProperty(100, "schema", &schema);
-}
-
-void CheckpointReader::ReadEntry(CatalogTransaction transaction, Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<CatalogType>(99, "type");
-
-	switch (type) {
-	case CatalogType::SCHEMA_ENTRY: {
-		ReadSchema(transaction, deserializer);
-		break;
-	}
-	case CatalogType::TYPE_ENTRY: {
-		ReadType(transaction, deserializer);
-		break;
-	}
-	case CatalogType::SEQUENCE_ENTRY: {
-		ReadSequence(transaction, deserializer);
-		break;
-	}
-	case CatalogType::TABLE_ENTRY: {
-		ReadTable(transaction, deserializer);
-		break;
-	}
-	case CatalogType::VIEW_ENTRY: {
-		ReadView(transaction, deserializer);
-		break;
-	}
-	case CatalogType::MACRO_ENTRY: {
-		ReadMacro(transaction, deserializer);
-		break;
-	}
-	case CatalogType::TABLE_MACRO_ENTRY: {
-		ReadTableMacro(transaction, deserializer);
-		break;
-	}
-	case CatalogType::INDEX_ENTRY: {
-		ReadIndex(transaction, deserializer);
-		break;
-	}
-	default:
-		throw InternalException("Unrecognized catalog type in CheckpointWriter::WriteEntry");
-	}
-}
-
-void CheckpointReader::ReadSchema(CatalogTransaction transaction, Deserializer &deserializer) {
-	// Read the schema and create it in the catalog
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "schema");
-	auto &schema_info = info->Cast<CreateSchemaInfo>();
-
-	// we set create conflict to IGNORE_ON_CONFLICT, so that we can ignore a failure when recreating the main schema
-	schema_info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateSchema(transaction, schema_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Views
-//===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteView(ViewCatalogEntry &view, Serializer &serializer) {
-	serializer.WriteProperty(100, "view", &view);
-}
-
-void CheckpointReader::ReadView(CatalogTransaction transaction, Deserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "view");
-	auto &view_info = info->Cast<CreateViewInfo>();
-	catalog.CreateView(transaction, view_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Sequences
-//===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteSequence(SequenceCatalogEntry &seq, Serializer &serializer) {
-	serializer.WriteProperty(100, "sequence", &seq);
-}
-
-void CheckpointReader::ReadSequence(CatalogTransaction transaction, Deserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "sequence");
-	auto &sequence_info = info->Cast<CreateSequenceInfo>();
-	catalog.CreateSequence(transaction, sequence_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Indexes
-//===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteIndex(IndexCatalogEntry &index_catalog_entry, Serializer &serializer) {
-	// The index data is written as part of WriteTableData
-	// Here, we serialize the index catalog entry
-
-	// we need to keep the tag "index", even though it is slightly misleading
-	serializer.WriteProperty(100, "index", &index_catalog_entry);
-}
-
-void CheckpointReader::ReadIndex(CatalogTransaction transaction, Deserializer &deserializer) {
-	// we need to keep the tag "index", even though it is slightly misleading.
-	auto create_info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "index");
-	auto &info = create_info->Cast<CreateIndexInfo>();
-
-	// also, we have to read the root_block_pointer, which will not be valid for newer storage versions.
-	// This leads to different code paths in this function.
-	auto root_block_pointer =
-	    deserializer.ReadPropertyWithExplicitDefault<BlockPointer>(101, "root_block_pointer", BlockPointer());
-
-	// create the index in the catalog
-
-	// look for the table in the catalog
-	auto &schema = catalog.GetSchema(transaction, create_info->schema);
-	auto catalog_table = schema.GetEntry(transaction, CatalogType::TABLE_ENTRY, info.table);
-	if (!catalog_table) {
-		// See internal issue 3663.
-		throw IOException("corrupt database file - index entry without table entry");
-	}
-	auto &table = catalog_table->Cast<DuckTableEntry>();
-
-	// we also need to make sure the index type is loaded
-	// backwards compatibility:
-	// if the index type is not specified, we default to ART
-	if (info.index_type.empty()) {
-		info.index_type = ART::TYPE_NAME;
-	}
-
-	// now we can look for the index in the catalog and assign the table info
-	auto &index = schema.CreateIndex(transaction, info, table)->Cast<DuckIndexEntry>();
-	auto &data_table = table.GetStorage();
-	auto &table_info = data_table.GetDataTableInfo();
-
-	IndexStorageInfo index_storage_info;
-	if (root_block_pointer.IsValid()) {
-		// Read older duckdb files.
-		index_storage_info.name = index.name;
-		index_storage_info.root_block_ptr = root_block_pointer;
-
-	} else {
-		// Read the matching index storage info.
-		for (auto const &elem : table_info->GetIndexStorageInfo()) {
-			if (elem.name == index.name) {
-				index_storage_info = elem;
-				break;
-			}
-		}
-	}
-
-	D_ASSERT(index_storage_info.IsValid());
-	D_ASSERT(!index_storage_info.name.empty());
-
-	// Create an unbound index and add it to the table.
-	auto unbound_index = make_uniq<UnboundIndex>(std::move(create_info), index_storage_info,
-	                                             TableIOManager::Get(data_table), data_table.db);
-	table_info->GetIndexes().AddIndex(std::move(unbound_index));
-}
-
-//===--------------------------------------------------------------------===//
-// Custom Types
-//===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteType(TypeCatalogEntry &type, Serializer &serializer) {
-	serializer.WriteProperty(100, "type", &type);
-}
-
-void CheckpointReader::ReadType(CatalogTransaction transaction, Deserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "type");
-	auto &type_info = info->Cast<CreateTypeInfo>();
-	catalog.CreateType(transaction, type_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Macro's
-//===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteMacro(ScalarMacroCatalogEntry &macro, Serializer &serializer) {
-	serializer.WriteProperty(100, "macro", &macro);
-}
-
-void CheckpointReader::ReadMacro(CatalogTransaction transaction, Deserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "macro");
-	auto &macro_info = info->Cast<CreateMacroInfo>();
-	catalog.CreateFunction(transaction, macro_info);
-}
-
-void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro, Serializer &serializer) {
-	serializer.WriteProperty(100, "table_macro", &macro);
-}
-
-void CheckpointReader::ReadTableMacro(CatalogTransaction transaction, Deserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "table_macro");
-	auto &macro_info = info->Cast<CreateMacroInfo>();
-	catalog.CreateFunction(transaction, macro_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Table Metadata
-//===--------------------------------------------------------------------===//
-void SingleFileCheckpointWriter::WriteTable(TableCatalogEntry &table, Serializer &serializer) {
-	// Write the table metadata
-	serializer.WriteProperty(100, "table", &table);
-
-	// Write the table data
-	auto table_lock = table.GetStorage().GetCheckpointLock();
-	if (auto writer = GetTableDataWriter(table)) {
-		writer->WriteTableData(serializer);
-	}
-	// flush any partial blocks BEFORE releasing the table lock
-	// flushing partial blocks updates where data lives and is not thread-safe
-	partial_block_manager.FlushPartialBlocks();
-}
-
-void CheckpointReader::ReadTable(CatalogTransaction transaction, Deserializer &deserializer) {
-	// deserialize the table meta data
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "table");
-	auto &schema = catalog.GetSchema(transaction, info->schema);
-	auto bound_info = Binder::BindCreateTableCheckpoint(std::move(info), schema);
-
-	for (auto &dep : bound_info->Base().dependencies.Set()) {
-		bound_info->dependencies.AddDependency(dep);
-	}
-
-	// now read the actual table data and place it into the CreateTableInfo
-	ReadTableData(transaction, deserializer, *bound_info);
-
-	// finally create the table in the catalog
-	catalog.CreateTable(transaction, *bound_info);
-}
-
-void CheckpointReader::ReadTableData(CatalogTransaction transaction, Deserializer &deserializer,
-                                     BoundCreateTableInfo &bound_info) {
-
-	// written in "SingleFileTableDataWriter::FinalizeTable"
-	auto table_pointer = deserializer.ReadProperty<MetaBlockPointer>(101, "table_pointer");
-	auto total_rows = deserializer.ReadProperty<idx_t>(102, "total_rows");
-
-	// Cover reading old storage files.
-	auto index_pointers = deserializer.ReadPropertyWithExplicitDefault<vector<BlockPointer>>(103, "index_pointers", {});
-	// Cover reading new storage files.
-	auto index_storage_infos =
-	    deserializer.ReadPropertyWithExplicitDefault<vector<IndexStorageInfo>>(104, "index_storage_infos", {});
-
-	if (!index_storage_infos.empty()) {
-		bound_info.indexes = index_storage_infos;
-
-	} else {
-		// This is an old duckdb file containing index pointers and deprecated storage.
-		for (idx_t i = 0; i < index_pointers.size(); i++) {
-			// Deprecated storage is always true for old duckdb files.
-			IndexStorageInfo index_storage_info;
-			index_storage_info.root_block_ptr = index_pointers[i];
-			bound_info.indexes.push_back(index_storage_info);
-		}
-	}
-
-	// FIXME: icky downcast to get the underlying MetadataReader
-	auto &binary_deserializer = dynamic_cast<BinaryDeserializer &>(deserializer);
-	auto &reader = dynamic_cast<MetadataReader &>(binary_deserializer.GetStream());
-
-	MetadataReader table_data_reader(reader.GetMetadataManager(), table_pointer);
-	TableDataReader data_reader(table_data_reader, bound_info);
-	data_reader.ReadTableData();
-
-	bound_info.data->total_rows = total_rows;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/alp/alp.cpp b/src/duckdb/src/storage/compression/alp/alp.cpp
deleted file mode 100644
index 284dd45aa..000000000
--- a/src/duckdb/src/storage/compression/alp/alp.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/alp/alp_analyze.hpp"
-#include "duckdb/storage/compression/alp/alp_compress.hpp"
-#include "duckdb/storage/compression/alp/alp_fetch.hpp"
-#include "duckdb/storage/compression/alp/alp_scan.hpp"
-
-namespace duckdb {
-
-template <class T>
-CompressionFunction GetAlpFunction(PhysicalType data_type) {
-	throw NotImplementedException("GetAlpFunction not implemented for the given datatype");
-}
-
-template <>
-CompressionFunction GetAlpFunction<float>(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_ALP, data_type, AlpInitAnalyze<float>, AlpAnalyze<float>,
-	                           AlpFinalAnalyze<float>, AlpInitCompression<float>, AlpCompress<float>,
-	                           AlpFinalizeCompress<float>, AlpInitScan<float>, AlpScan<float>, AlpScanPartial<float>,
-	                           AlpFetchRow<float>, AlpSkip<float>);
-}
-
-template <>
-CompressionFunction GetAlpFunction<double>(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_ALP, data_type, AlpInitAnalyze<double>, AlpAnalyze<double>,
-	                           AlpFinalAnalyze<double>, AlpInitCompression<double>, AlpCompress<double>,
-	                           AlpFinalizeCompress<double>, AlpInitScan<double>, AlpScan<double>,
-	                           AlpScanPartial<double>, AlpFetchRow<double>, AlpSkip<double>);
-}
-
-CompressionFunction AlpCompressionFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::FLOAT:
-		return GetAlpFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetAlpFunction<double>(type);
-	default:
-		throw InternalException("Unsupported type for Alp");
-	}
-}
-
-bool AlpCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/alp/alp_constants.cpp b/src/duckdb/src/storage/compression/alp/alp_constants.cpp
deleted file mode 100644
index 694b5e61a..000000000
--- a/src/duckdb/src/storage/compression/alp/alp_constants.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "duckdb/storage/compression/alp/alp_constants.hpp"
-
-namespace duckdb {
-
-constexpr int64_t AlpConstants::FACT_ARR[];
-
-constexpr float AlpTypedConstants<float>::EXP_ARR[];
-constexpr float AlpTypedConstants<float>::FRAC_ARR[];
-
-constexpr double AlpTypedConstants<double>::EXP_ARR[];
-constexpr double AlpTypedConstants<double>::FRAC_ARR[];
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/alprd.cpp b/src/duckdb/src/storage/compression/alprd.cpp
deleted file mode 100644
index 9b48c45e4..000000000
--- a/src/duckdb/src/storage/compression/alprd.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/common/limits.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/alprd/alprd_analyze.hpp"
-#include "duckdb/storage/compression/alprd/alprd_compress.hpp"
-#include "duckdb/storage/compression/alprd/alprd_fetch.hpp"
-#include "duckdb/storage/compression/alprd/alprd_scan.hpp"
-
-namespace duckdb {
-
-template <class T>
-CompressionFunction GetAlpRDFunction(PhysicalType data_type) {
-	throw NotImplementedException("GetAlpFunction not implemented for the given datatype");
-}
-
-template <>
-CompressionFunction GetAlpRDFunction<float>(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_ALPRD, data_type, AlpRDInitAnalyze<float>,
-	                           AlpRDAnalyze<float>, AlpRDFinalAnalyze<float>, AlpRDInitCompression<float>,
-	                           AlpRDCompress<float>, AlpRDFinalizeCompress<float>, AlpRDInitScan<float>,
-	                           AlpRDScan<float>, AlpRDScanPartial<float>, AlpRDFetchRow<float>, AlpRDSkip<float>);
-}
-
-template <>
-CompressionFunction GetAlpRDFunction<double>(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_ALPRD, data_type, AlpRDInitAnalyze<double>,
-	                           AlpRDAnalyze<double>, AlpRDFinalAnalyze<double>, AlpRDInitCompression<double>,
-	                           AlpRDCompress<double>, AlpRDFinalizeCompress<double>, AlpRDInitScan<double>,
-	                           AlpRDScan<double>, AlpRDScanPartial<double>, AlpRDFetchRow<double>, AlpRDSkip<double>);
-}
-
-CompressionFunction AlpRDCompressionFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::FLOAT:
-		return GetAlpRDFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetAlpRDFunction<double>(type);
-	default:
-		throw InternalException("Unsupported type for Alp");
-	}
-}
-
-bool AlpRDCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/bitpacking.cpp b/src/duckdb/src/storage/compression/bitpacking.cpp
deleted file mode 100644
index af2e35c2d..000000000
--- a/src/duckdb/src/storage/compression/bitpacking.cpp
+++ /dev/null
@@ -1,1014 +0,0 @@
-#include "duckdb/common/bitpacking.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/compression/bitpacking.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-static constexpr const idx_t BITPACKING_METADATA_GROUP_SIZE = STANDARD_VECTOR_SIZE > 512 ? STANDARD_VECTOR_SIZE : 2048;
-
-BitpackingMode BitpackingModeFromString(const string &str) {
-	auto mode = StringUtil::Lower(str);
-	if (mode == "auto" || mode == "none") {
-		return BitpackingMode::AUTO;
-	} else if (mode == "constant") {
-		return BitpackingMode::CONSTANT;
-	} else if (mode == "constant_delta") {
-		return BitpackingMode::CONSTANT_DELTA;
-	} else if (mode == "delta_for") {
-		return BitpackingMode::DELTA_FOR;
-	} else if (mode == "for") {
-		return BitpackingMode::FOR;
-	} else {
-		return BitpackingMode::INVALID;
-	}
-}
-
-string BitpackingModeToString(const BitpackingMode &mode) {
-	switch (mode) {
-	case BitpackingMode::AUTO:
-		return "auto";
-	case BitpackingMode::CONSTANT:
-		return "constant";
-	case BitpackingMode::CONSTANT_DELTA:
-		return "constant_delta";
-	case BitpackingMode::DELTA_FOR:
-		return "delta_for";
-	case BitpackingMode::FOR:
-		return "for";
-	default:
-		throw NotImplementedException("Unknown bitpacking mode: " + to_string((uint8_t)mode) + "\n");
-	}
-}
-
-typedef struct {
-	BitpackingMode mode;
-	uint32_t offset;
-} bitpacking_metadata_t;
-
-typedef uint32_t bitpacking_metadata_encoded_t;
-
-static bitpacking_metadata_encoded_t EncodeMeta(bitpacking_metadata_t metadata) {
-	D_ASSERT(metadata.offset <= 0x00FFFFFF); // max uint24_t
-	bitpacking_metadata_encoded_t encoded_value = metadata.offset;
-	encoded_value |= UnsafeNumericCast<bitpacking_metadata_encoded_t>((uint8_t)metadata.mode << 24);
-	return encoded_value;
-}
-static bitpacking_metadata_t DecodeMeta(bitpacking_metadata_encoded_t *metadata_encoded) {
-	bitpacking_metadata_t metadata;
-	metadata.mode = Load<BitpackingMode>(data_ptr_cast(metadata_encoded) + 3);
-	metadata.offset = *metadata_encoded & 0x00FFFFFF;
-	return metadata;
-}
-
-struct EmptyBitpackingWriter {
-	template <class T>
-	static void WriteConstant(T constant, idx_t count, void *data_ptr, bool all_invalid) {
-	}
-	template <class T, class T_S = typename MakeSigned<T>::type>
-	static void WriteConstantDelta(T_S constant, T frame_of_reference, idx_t count, T *values, bool *validity,
-	                               void *data_ptr) {
-	}
-	template <class T, class T_S = typename MakeSigned<T>::type>
-	static void WriteDeltaFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference,
-	                          T_S delta_offset, T *original_values, idx_t count, void *data_ptr) {
-	}
-	template <class T>
-	static void WriteFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference, idx_t count,
-	                     void *data_ptr) {
-	}
-};
-
-template <class T, class T_S = typename MakeSigned<T>::type>
-struct BitpackingState {
-public:
-	BitpackingState() : compression_buffer_idx(0), total_size(0), data_ptr(nullptr) {
-		compression_buffer_internal[0] = T(0);
-		compression_buffer = &compression_buffer_internal[1];
-		Reset();
-	}
-
-	// Extra val for delta encoding
-	T compression_buffer_internal[BITPACKING_METADATA_GROUP_SIZE + 1];
-	T *compression_buffer;
-	T_S delta_buffer[BITPACKING_METADATA_GROUP_SIZE];
-	bool compression_buffer_validity[BITPACKING_METADATA_GROUP_SIZE];
-	idx_t compression_buffer_idx;
-	idx_t total_size;
-
-	// Used to pass CompressionState ptr through the Bitpacking writer
-	void *data_ptr;
-
-	// Stats on current compression buffer
-	T minimum;
-	T maximum;
-	T min_max_diff;
-	T_S minimum_delta;
-	T_S maximum_delta;
-	T_S min_max_delta_diff;
-	T_S delta_offset;
-	bool all_valid;
-	bool all_invalid;
-
-	bool can_do_delta;
-	bool can_do_for;
-
-	// Used to force a specific mode, useful in testing
-	BitpackingMode mode = BitpackingMode::AUTO;
-
-public:
-	void Reset() {
-		minimum = NumericLimits<T>::Maximum();
-		minimum_delta = NumericLimits<T_S>::Maximum();
-		maximum = NumericLimits<T>::Minimum();
-		maximum_delta = NumericLimits<T_S>::Minimum();
-		delta_offset = 0;
-		all_valid = true;
-		all_invalid = true;
-		can_do_delta = false;
-		can_do_for = false;
-		compression_buffer_idx = 0;
-		min_max_diff = 0;
-		min_max_delta_diff = 0;
-	}
-
-	void CalculateFORStats() {
-		can_do_for = TrySubtractOperator::Operation(maximum, minimum, min_max_diff);
-	}
-
-	void CalculateDeltaStats() {
-		// TODO: currently we dont support delta compression of values above NumericLimits<T_S>::Maximum(),
-		// 		 we could support this with some clever substract trickery?
-		if (maximum > static_cast<T>(NumericLimits<T_S>::Maximum())) {
-			return;
-		}
-
-		// Don't delta encoding 1 value makes no sense
-		if (compression_buffer_idx < 2) {
-			return;
-		}
-
-		// TODO: handle NULLS here?
-		// Currently we cannot handle nulls because we would need an additional step of patching for this.
-		// we could for example copy the last value on a null insert. This would help a bit, but not be optimal for
-		// large deltas since theres suddenly a zero then. Ideally we would insert a value that leads to a delta within
-		// the current domain of deltas however we dont know that domain here yet
-		if (!all_valid) {
-			return;
-		}
-
-		// Note: since we dont allow any values over NumericLimits<T_S>::Maximum(), all subtractions for unsigned types
-		// are guaranteed not to overflow
-		bool can_do_all = true;
-		if (NumericLimits<T>::IsSigned()) {
-			T_S bogus;
-			can_do_all = TrySubtractOperator::Operation(static_cast<T_S>(minimum), static_cast<T_S>(maximum), bogus) &&
-			             TrySubtractOperator::Operation(static_cast<T_S>(maximum), static_cast<T_S>(minimum), bogus);
-		}
-
-		// Calculate delta's
-		// compression_buffer pointer points one element ahead of the internal buffer making the use of signed index
-		// integer (-1) possible
-		D_ASSERT(compression_buffer_idx <= NumericLimits<int64_t>::Maximum());
-		if (can_do_all) {
-			for (int64_t i = 0; i < static_cast<int64_t>(compression_buffer_idx); i++) {
-				delta_buffer[i] = static_cast<T_S>(compression_buffer[i]) - static_cast<T_S>(compression_buffer[i - 1]);
-			}
-		} else {
-			for (int64_t i = 0; i < static_cast<int64_t>(compression_buffer_idx); i++) {
-				auto success =
-				    TrySubtractOperator::Operation(static_cast<T_S>(compression_buffer[i]),
-				                                   static_cast<T_S>(compression_buffer[i - 1]), delta_buffer[i]);
-				if (!success) {
-					return;
-				}
-			}
-		}
-
-		can_do_delta = true;
-
-		for (idx_t i = 1; i < compression_buffer_idx; i++) {
-			maximum_delta = MaxValue<T_S>(maximum_delta, delta_buffer[i]);
-			minimum_delta = MinValue<T_S>(minimum_delta, delta_buffer[i]);
-		}
-
-		// Since we can set the first value arbitrarily, we want to pick one from the current domain, note that
-		// we will store the original first value - this offset as the  delta_offset to be able to decode this again.
-		delta_buffer[0] = minimum_delta;
-
-		can_do_delta = can_do_delta && TrySubtractOperator::Operation(maximum_delta, minimum_delta, min_max_delta_diff);
-		can_do_delta = can_do_delta && TrySubtractOperator::Operation(static_cast<T_S>(compression_buffer[0]),
-		                                                              minimum_delta, delta_offset);
-	}
-
-	template <class T_INNER>
-	void SubtractFrameOfReference(T_INNER *buffer, T_INNER frame_of_reference) {
-		static_assert(NumericLimits<T_INNER>::IsIntegral(), "Integral type required.");
-
-		using T_U = typename MakeUnsigned<T_INNER>::type;
-
-		for (idx_t i = 0; i < compression_buffer_idx; i++) {
-			reinterpret_cast<T_U *>(buffer)[i] -= static_cast<T_U>(frame_of_reference);
-		}
-	}
-
-	template <class OP>
-	bool Flush() {
-		if (compression_buffer_idx == 0) {
-			return true;
-		}
-
-		if ((all_invalid || maximum == minimum) && (mode == BitpackingMode::AUTO || mode == BitpackingMode::CONSTANT)) {
-			OP::WriteConstant(maximum, compression_buffer_idx, data_ptr, all_invalid);
-			total_size += sizeof(T) + sizeof(bitpacking_metadata_encoded_t);
-			return true;
-		}
-
-		CalculateFORStats();
-		CalculateDeltaStats();
-
-		if (can_do_delta) {
-			if (maximum_delta == minimum_delta && mode != BitpackingMode::FOR && mode != BitpackingMode::DELTA_FOR) {
-				// FOR needs to be T (considering hugeint is bigger than idx_t)
-				T frame_of_reference = compression_buffer[0];
-
-				OP::WriteConstantDelta(maximum_delta, static_cast<T>(frame_of_reference), compression_buffer_idx,
-				                       compression_buffer, compression_buffer_validity, data_ptr);
-				total_size += sizeof(T) + sizeof(T) + sizeof(bitpacking_metadata_encoded_t);
-				return true;
-			}
-
-			// Check if delta has benefit
-			auto delta_required_bitwidth =
-			    BitpackingPrimitives::MinimumBitWidth<T, false>(static_cast<T>(min_max_delta_diff));
-			auto regular_required_bitwidth = BitpackingPrimitives::MinimumBitWidth(min_max_diff);
-
-			if (delta_required_bitwidth < regular_required_bitwidth && mode != BitpackingMode::FOR) {
-				SubtractFrameOfReference(delta_buffer, minimum_delta);
-
-				OP::WriteDeltaFor(reinterpret_cast<T *>(delta_buffer), compression_buffer_validity,
-				                  delta_required_bitwidth, static_cast<T>(minimum_delta), delta_offset,
-				                  compression_buffer, compression_buffer_idx, data_ptr);
-
-				// FOR (frame of reference).
-				total_size += sizeof(T);
-				// Aligned bitpacking width.
-				total_size += AlignValue(sizeof(bitpacking_width_t));
-				// Delta offset.
-				total_size += sizeof(T);
-				// Compressed data size.
-				total_size += BitpackingPrimitives::GetRequiredSize(compression_buffer_idx, delta_required_bitwidth);
-
-				return true;
-			}
-		}
-
-		if (can_do_for) {
-			auto width = BitpackingPrimitives::MinimumBitWidth<T, false>(min_max_diff);
-			SubtractFrameOfReference(compression_buffer, minimum);
-			OP::WriteFor(compression_buffer, compression_buffer_validity, width, minimum, compression_buffer_idx,
-			             data_ptr);
-
-			total_size += BitpackingPrimitives::GetRequiredSize(compression_buffer_idx, width);
-			total_size += sizeof(T); // FOR value
-			total_size += AlignValue(sizeof(bitpacking_width_t));
-
-			return true;
-		}
-
-		return false;
-	}
-
-	template <class OP = EmptyBitpackingWriter>
-	bool Update(T value, bool is_valid) {
-		compression_buffer_validity[compression_buffer_idx] = is_valid;
-		all_valid = all_valid && is_valid;
-		all_invalid = all_invalid && !is_valid;
-
-		if (is_valid) {
-			compression_buffer[compression_buffer_idx] = value;
-			minimum = MinValue<T>(minimum, value);
-			maximum = MaxValue<T>(maximum, value);
-		}
-
-		compression_buffer_idx++;
-
-		if (compression_buffer_idx == BITPACKING_METADATA_GROUP_SIZE) {
-			bool success = Flush<OP>();
-			Reset();
-			return success;
-		}
-		return true;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-template <class T>
-struct BitpackingAnalyzeState : public AnalyzeState {
-	explicit BitpackingAnalyzeState(const CompressionInfo &info) : AnalyzeState(info) {};
-	BitpackingState<T> state;
-};
-
-template <class T>
-unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	auto &config = DBConfig::GetConfig(col_data.GetDatabase());
-
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	auto state = make_uniq<BitpackingAnalyzeState<T>>(info);
-	state->state.mode = config.options.force_bitpacking_mode;
-
-	return std::move(state);
-}
-
-template <class T>
-bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = state.Cast<BitpackingAnalyzeState<T>>();
-
-	// We use BITPACKING_METADATA_GROUP_SIZE tuples, which can exceed the block size.
-	// In that case, we disable bitpacking.
-	// we are conservative here by multiplying by 2
-	auto type_size = GetTypeIdSize(input.GetType().InternalType());
-	if (type_size * BITPACKING_METADATA_GROUP_SIZE * 2 > state.info.GetBlockSize()) {
-		return false;
-	}
-
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-
-	auto data = UnifiedVectorFormat::GetData<T>(vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (!analyze_state.state.template Update<EmptyBitpackingWriter>(data[idx], vdata.validity.RowIsValid(idx))) {
-			return false;
-		}
-	}
-	return true;
-}
-
-template <class T>
-idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
-	auto &bitpacking_state = state.Cast<BitpackingAnalyzeState<T>>();
-	auto flush_result = bitpacking_state.state.template Flush<EmptyBitpackingWriter>();
-	if (!flush_result) {
-		return DConstants::INVALID_INDEX;
-	}
-	return bitpacking_state.state.total_size;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-template <class T, bool WRITE_STATISTICS, class T_S = typename MakeSigned<T>::type>
-struct BitpackingCompressState : public CompressionState {
-public:
-	explicit BitpackingCompressState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info)
-	    : CompressionState(info), checkpoint_data(checkpoint_data),
-	      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING)) {
-		CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-
-		state.data_ptr = reinterpret_cast<void *>(this);
-
-		auto &config = DBConfig::GetConfig(checkpoint_data.GetDatabase());
-		state.mode = config.options.force_bitpacking_mode;
-	}
-
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	// Ptr to next free spot in segment;
-	data_ptr_t data_ptr;
-	// Ptr to next free spot for storing bitwidths and frame-of-references (growing downwards).
-	data_ptr_t metadata_ptr;
-
-	BitpackingState<T> state;
-
-public:
-	struct BitpackingWriter {
-		static void WriteConstant(T constant, idx_t count, void *data_ptr, bool all_invalid) {
-			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
-
-			ReserveSpace(state, sizeof(T));
-			WriteMetaData(state, BitpackingMode::CONSTANT);
-			WriteData(state->data_ptr, constant);
-
-			UpdateStats(state, count);
-		}
-
-		static void WriteConstantDelta(T_S constant, T frame_of_reference, idx_t count, T *values, bool *validity,
-		                               void *data_ptr) {
-			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
-
-			ReserveSpace(state, 2 * sizeof(T));
-			WriteMetaData(state, BitpackingMode::CONSTANT_DELTA);
-			WriteData(state->data_ptr, frame_of_reference);
-			WriteData(state->data_ptr, constant);
-
-			UpdateStats(state, count);
-		}
-		static void WriteDeltaFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference,
-		                          T_S delta_offset, T *original_values, idx_t count, void *data_ptr) {
-			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
-
-			auto bp_size = BitpackingPrimitives::GetRequiredSize(count, width);
-			ReserveSpace(state, bp_size + 3 * sizeof(T));
-
-			WriteMetaData(state, BitpackingMode::DELTA_FOR);
-			WriteData(state->data_ptr, frame_of_reference);
-			WriteData(state->data_ptr, static_cast<T>(width));
-			WriteData(state->data_ptr, delta_offset);
-
-			BitpackingPrimitives::PackBuffer<T, false>(state->data_ptr, values, count, width);
-			state->data_ptr += bp_size;
-
-			UpdateStats(state, count);
-		}
-
-		static void WriteFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference, idx_t count,
-		                     void *data_ptr) {
-			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
-
-			auto bp_size = BitpackingPrimitives::GetRequiredSize(count, width);
-			ReserveSpace(state, bp_size + 2 * sizeof(T));
-
-			WriteMetaData(state, BitpackingMode::FOR);
-			WriteData(state->data_ptr, frame_of_reference);
-			WriteData(state->data_ptr, (T)width);
-
-			BitpackingPrimitives::PackBuffer<T, false>(state->data_ptr, values, count, width);
-			state->data_ptr += bp_size;
-
-			UpdateStats(state, count);
-		}
-
-		template <class T_OUT>
-		static void WriteData(data_ptr_t &ptr, T_OUT val) {
-			*reinterpret_cast<T_OUT *>(ptr) = val;
-			ptr += sizeof(T_OUT);
-		}
-
-		static void WriteMetaData(BitpackingCompressState<T, WRITE_STATISTICS> *state, BitpackingMode mode) {
-			bitpacking_metadata_t metadata {mode, (uint32_t)(state->data_ptr - state->handle.Ptr())};
-			state->metadata_ptr -= sizeof(bitpacking_metadata_encoded_t);
-			Store<bitpacking_metadata_encoded_t>(EncodeMeta(metadata), state->metadata_ptr);
-		}
-
-		static void ReserveSpace(BitpackingCompressState<T, WRITE_STATISTICS> *state, idx_t data_bytes) {
-			idx_t meta_bytes = sizeof(bitpacking_metadata_encoded_t);
-			state->FlushAndCreateSegmentIfFull(data_bytes, meta_bytes);
-			D_ASSERT(state->CanStore(data_bytes, meta_bytes));
-		}
-
-		static void UpdateStats(BitpackingCompressState<T, WRITE_STATISTICS> *state, idx_t count) {
-			state->current_segment->count += count;
-
-			if (WRITE_STATISTICS && !state->state.all_invalid) {
-				state->current_segment->stats.statistics.template UpdateNumericStats<T>(state->state.maximum);
-				state->current_segment->stats.statistics.template UpdateNumericStats<T>(state->state.minimum);
-			}
-		}
-	};
-
-	bool CanStore(idx_t data_bytes, idx_t meta_bytes) {
-		auto required_data_bytes = AlignValue<idx_t>(UnsafeNumericCast<idx_t>((data_ptr + data_bytes) - data_ptr));
-		auto required_meta_bytes = info.GetBlockSize() - UnsafeNumericCast<idx_t>(metadata_ptr - data_ptr) + meta_bytes;
-
-		return required_data_bytes + required_meta_bytes <=
-		       info.GetBlockSize() - BitpackingPrimitives::BITPACKING_HEADER_SIZE;
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start,
-		                                                                info.GetBlockSize(), info.GetBlockSize());
-		current_segment = std::move(compressed_segment);
-
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
-		handle = buffer_manager.Pin(current_segment->block);
-
-		data_ptr = handle.Ptr() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
-		metadata_ptr = handle.Ptr() + info.GetBlockSize();
-	}
-
-	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = UnifiedVectorFormat::GetData<T>(vdata);
-
-		for (idx_t i = 0; i < count; i++) {
-			idx_t idx = vdata.sel->get_index(i);
-			state.template Update<BitpackingCompressState<T, WRITE_STATISTICS, T_S>::BitpackingWriter>(
-			    data[idx], vdata.validity.RowIsValid(idx));
-		}
-	}
-
-	void FlushAndCreateSegmentIfFull(idx_t required_data_bytes, idx_t required_meta_bytes) {
-		if (!CanStore(required_data_bytes, required_meta_bytes)) {
-			idx_t row_start = current_segment->start + current_segment->count;
-			FlushSegment();
-			CreateEmptySegment(row_start);
-		}
-	}
-
-	void FlushSegment() {
-		auto &state = checkpoint_data.GetCheckpointState();
-		auto base_ptr = handle.Ptr();
-
-		// Compact the segment by moving the metadata next to the data.
-
-		idx_t unaligned_offset = NumericCast<idx_t>(data_ptr - base_ptr);
-		idx_t metadata_offset = AlignValue(unaligned_offset);
-		idx_t metadata_size = NumericCast<idx_t>(base_ptr + info.GetBlockSize() - metadata_ptr);
-		idx_t total_segment_size = metadata_offset + metadata_size;
-
-		// Asserting things are still sane here
-		if (!CanStore(0, 0)) {
-			throw InternalException("Error in bitpacking size calculation");
-		}
-
-		if (unaligned_offset != metadata_offset) {
-			// zero initialize any padding bits
-			memset(base_ptr + unaligned_offset, 0, metadata_offset - unaligned_offset);
-		}
-		memmove(base_ptr + metadata_offset, metadata_ptr, metadata_size);
-
-		// Store the offset of the metadata of the first group (which is at the highest address).
-		Store<idx_t>(metadata_offset + metadata_size, base_ptr);
-
-		state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size);
-	}
-
-	void Finalize() {
-		state.template Flush<BitpackingCompressState<T, WRITE_STATISTICS, T_S>::BitpackingWriter>();
-		FlushSegment();
-		current_segment.reset();
-	}
-};
-
-template <class T, bool WRITE_STATISTICS>
-unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                       unique_ptr<AnalyzeState> state) {
-	return make_uniq<BitpackingCompressState<T, WRITE_STATISTICS>>(checkpoint_data, state->info);
-}
-
-template <class T, bool WRITE_STATISTICS>
-void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = state_p.Cast<BitpackingCompressState<T, WRITE_STATISTICS>>();
-	UnifiedVectorFormat vdata;
-	scan_vector.ToUnifiedFormat(count, vdata);
-	state.Append(vdata, count);
-}
-
-template <class T, bool WRITE_STATISTICS>
-void BitpackingFinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<BitpackingCompressState<T, WRITE_STATISTICS>>();
-	state.Finalize();
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-template <class T>
-static void ApplyFrameOfReference(T *dst, T frame_of_reference, idx_t size) {
-	using T_U = typename MakeUnsigned<T>::type;
-	if (!frame_of_reference) {
-		return;
-	}
-
-	for (idx_t i = 0; i < size; i++) {
-		reinterpret_cast<T_U *>(dst)[i] += static_cast<T_U>(frame_of_reference);
-	}
-}
-
-// Based on https://github.com/lemire/FastPFor (Apache License 2.0)
-template <class T>
-static T DeltaDecode(T *data, T previous_value, const size_t size) {
-	D_ASSERT(size >= 1);
-
-	data[0] += previous_value;
-
-	const size_t UnrollQty = 4;
-	const size_t sz0 = (size / UnrollQty) * UnrollQty; // equal to 0, if size < UnrollQty
-	size_t i = 1;
-	if (sz0 >= UnrollQty) {
-		T a = data[0];
-		for (; i < sz0 - UnrollQty; i += UnrollQty) {
-			a = data[i] += a;
-			a = data[i + 1] += a;
-			a = data[i + 2] += a;
-			a = data[i + 3] += a;
-		}
-	}
-	for (; i != size; ++i) {
-		data[i] += data[i - 1];
-	}
-
-	return data[size - 1];
-}
-
-template <class T, class T_S = typename MakeSigned<T>::type>
-struct BitpackingScanState : public SegmentScanState {
-public:
-	explicit BitpackingScanState(ColumnSegment &segment) : current_segment(segment) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		handle = buffer_manager.Pin(segment.block);
-		auto data_ptr = handle.Ptr();
-
-		// load offset to bitpacking widths pointer
-		auto bitpacking_metadata_offset = Load<idx_t>(data_ptr + segment.GetBlockOffset());
-		bitpacking_metadata_ptr =
-		    data_ptr + segment.GetBlockOffset() + bitpacking_metadata_offset - sizeof(bitpacking_metadata_encoded_t);
-
-		// load the first group
-		LoadNextGroup();
-	}
-
-	BufferHandle handle;
-	ColumnSegment &current_segment;
-
-	T decompression_buffer[BITPACKING_METADATA_GROUP_SIZE];
-
-	bitpacking_metadata_t current_group;
-	bitpacking_width_t current_width;
-	T current_frame_of_reference;
-	T current_constant;
-	T current_delta_offset;
-
-	idx_t current_group_offset = 0;
-	data_ptr_t current_group_ptr;
-	data_ptr_t bitpacking_metadata_ptr;
-
-public:
-	//! Loads the metadata for the current metadata group. This will set bitpacking_metadata_ptr to the next group.
-	//! It also loads any metadata at the start of a compressed buffer (e.g. the width, for, or constant value)
-	//! depending on the bitpacking mode of that group.
-	void LoadNextGroup() {
-		D_ASSERT(bitpacking_metadata_ptr > handle.Ptr() &&
-		         bitpacking_metadata_ptr < handle.Ptr() + current_segment.GetBlockManager().GetBlockSize());
-		current_group_offset = 0;
-		current_group = DecodeMeta(reinterpret_cast<bitpacking_metadata_encoded_t *>(bitpacking_metadata_ptr));
-
-		bitpacking_metadata_ptr -= sizeof(bitpacking_metadata_encoded_t);
-		current_group_ptr = GetPtr(current_group);
-
-		// Read first value
-		switch (current_group.mode) {
-		case BitpackingMode::CONSTANT:
-			current_constant = *reinterpret_cast<T *>(current_group_ptr);
-			current_group_ptr += sizeof(T);
-			break;
-		case BitpackingMode::FOR:
-		case BitpackingMode::CONSTANT_DELTA:
-		case BitpackingMode::DELTA_FOR:
-			current_frame_of_reference = *reinterpret_cast<T *>(current_group_ptr);
-			current_group_ptr += sizeof(T);
-			break;
-		default:
-			throw InternalException("Invalid bitpacking mode");
-		}
-
-		// Read second value
-		switch (current_group.mode) {
-		case BitpackingMode::CONSTANT_DELTA:
-			current_constant = *reinterpret_cast<T *>(current_group_ptr);
-			current_group_ptr += sizeof(T);
-			break;
-		case BitpackingMode::FOR:
-		case BitpackingMode::DELTA_FOR:
-			current_width = (bitpacking_width_t)(*reinterpret_cast<T *>(current_group_ptr));
-			current_group_ptr += MaxValue(sizeof(T), sizeof(bitpacking_width_t));
-			break;
-		case BitpackingMode::CONSTANT:
-			break;
-		default:
-			throw InternalException("Invalid bitpacking mode");
-		}
-
-		// Read third value
-		if (current_group.mode == BitpackingMode::DELTA_FOR) {
-			current_delta_offset = *reinterpret_cast<T *>(current_group_ptr);
-			current_group_ptr += sizeof(T);
-		}
-	}
-
-	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		bool skip_sign_extend = true;
-
-		idx_t skipped = 0;
-		idx_t initial_group_offset = current_group_offset;
-
-		// This skips straight to the correct metadata group
-		idx_t meta_groups_to_skip = (skip_count + current_group_offset) / BITPACKING_METADATA_GROUP_SIZE;
-		if (meta_groups_to_skip) {
-
-			// bitpacking_metadata_ptr points to the next metadata: this means we need to advance the pointer by n-1
-			bitpacking_metadata_ptr -= (meta_groups_to_skip - 1) * sizeof(bitpacking_metadata_encoded_t);
-			LoadNextGroup();
-			// The first (partial) group we skipped
-			skipped += BITPACKING_METADATA_GROUP_SIZE - initial_group_offset;
-			// The remaining groups that were skipped
-			skipped += (meta_groups_to_skip - 1) * BITPACKING_METADATA_GROUP_SIZE;
-		}
-
-		// Assert we can are in the correct metadata group
-		idx_t remaining_to_skip = skip_count - skipped;
-		D_ASSERT(current_group_offset + remaining_to_skip < BITPACKING_METADATA_GROUP_SIZE);
-
-		if (current_group.mode == BitpackingMode::CONSTANT || current_group.mode == BitpackingMode::CONSTANT_DELTA ||
-		    current_group.mode == BitpackingMode::FOR) {
-			// Skipping within a constant or constant delta is done by increasing the current_group_offset
-			skipped += remaining_to_skip;
-			current_group_offset += remaining_to_skip;
-		} else {
-			// For DELTA we actually need to decompress from the current_group_offset up until the row we want to skip
-			// to this is because we need that delta to be able to continue scanning from here
-			D_ASSERT(current_group.mode == BitpackingMode::DELTA_FOR);
-
-			while (skipped < skip_count) {
-				// Calculate compression group offset and pointer
-				idx_t offset_in_compression_group =
-				    current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-				data_ptr_t current_position_ptr = current_group_ptr + current_group_offset * current_width / 8;
-				data_ptr_t decompression_group_start_pointer =
-				    current_position_ptr - offset_in_compression_group * current_width / 8;
-
-				idx_t skipping_this_algorithm_group =
-				    MinValue(remaining_to_skip,
-				             BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - offset_in_compression_group);
-
-				BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(decompression_buffer),
-				                                     decompression_group_start_pointer, current_width,
-				                                     skip_sign_extend);
-
-				T *decompression_ptr = decompression_buffer + offset_in_compression_group;
-				ApplyFrameOfReference<T_S>(reinterpret_cast<T_S *>(decompression_ptr),
-				                           static_cast<T_S>(current_frame_of_reference), skipping_this_algorithm_group);
-				DeltaDecode<T_S>(reinterpret_cast<T_S *>(decompression_ptr), static_cast<T_S>(current_delta_offset),
-				                 skipping_this_algorithm_group);
-				current_delta_offset = decompression_ptr[skipping_this_algorithm_group - 1];
-
-				skipped += skipping_this_algorithm_group;
-				current_group_offset += skipping_this_algorithm_group;
-				remaining_to_skip -= skipping_this_algorithm_group;
-			}
-		}
-
-		D_ASSERT(skipped == skip_count);
-	}
-
-	data_ptr_t GetPtr(bitpacking_metadata_t group) {
-		return handle.Ptr() + current_segment.GetBlockOffset() + group.offset;
-	}
-};
-
-template <class T>
-unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<BitpackingScanState<T>>(segment);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T, class T_S = typename MakeSigned<T>::type, class T_U = typename MakeUnsigned<T>::type>
-void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                           idx_t result_offset) {
-	auto &scan_state = state.scan_state->Cast<BitpackingScanState<T>>();
-
-	T *result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	//! Because FOR offsets all our values to be 0 or above, we can always skip sign extension here
-	bool skip_sign_extend = true;
-
-	idx_t scanned = 0;
-	while (scanned < scan_count) {
-		D_ASSERT(scan_state.current_group_offset <= BITPACKING_METADATA_GROUP_SIZE);
-
-		// Exhausted this metadata group, move pointers to next group and load metadata for next group.
-		if (scan_state.current_group_offset == BITPACKING_METADATA_GROUP_SIZE) {
-			scan_state.LoadNextGroup();
-		}
-
-		idx_t offset_in_compression_group =
-		    scan_state.current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-		if (scan_state.current_group.mode == BitpackingMode::CONSTANT) {
-			idx_t remaining = scan_count - scanned;
-			idx_t to_scan = MinValue(remaining, BITPACKING_METADATA_GROUP_SIZE - scan_state.current_group_offset);
-			T *begin = result_data + result_offset + scanned;
-			T *end = begin + remaining;
-			std::fill(begin, end, scan_state.current_constant);
-			scanned += to_scan;
-			scan_state.current_group_offset += to_scan;
-			continue;
-		}
-		if (scan_state.current_group.mode == BitpackingMode::CONSTANT_DELTA) {
-			idx_t remaining = scan_count - scanned;
-			idx_t to_scan = MinValue(remaining, BITPACKING_METADATA_GROUP_SIZE - scan_state.current_group_offset);
-			T *target_ptr = result_data + result_offset + scanned;
-
-			for (idx_t i = 0; i < to_scan; i++) {
-				idx_t multiplier = scan_state.current_group_offset + i;
-				// intended static casts to unsigned and back for defined wrapping of integers
-				target_ptr[i] = static_cast<T>((static_cast<T_U>(scan_state.current_constant) * multiplier) +
-				                               static_cast<T_U>(scan_state.current_frame_of_reference));
-			}
-
-			scanned += to_scan;
-			scan_state.current_group_offset += to_scan;
-			continue;
-		}
-		D_ASSERT(scan_state.current_group.mode == BitpackingMode::FOR ||
-		         scan_state.current_group.mode == BitpackingMode::DELTA_FOR);
-
-		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_group_ptr + scan_state.current_group_offset * 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
-			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(current_result_ptr), decompression_group_start_pointer,
-			                                     scan_state.current_width, skip_sign_extend);
-		} else {
-			// Decompress compression algorithm to buffer
-			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(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));
-		}
-
-		if (scan_state.current_group.mode == BitpackingMode::DELTA_FOR) {
-			ApplyFrameOfReference<T_S>(reinterpret_cast<T_S *>(current_result_ptr),
-			                           static_cast<T_S>(scan_state.current_frame_of_reference), to_scan);
-			DeltaDecode<T_S>(reinterpret_cast<T_S *>(current_result_ptr),
-			                 static_cast<T_S>(scan_state.current_delta_offset), to_scan);
-			scan_state.current_delta_offset = current_result_ptr[to_scan - 1];
-		} else {
-			ApplyFrameOfReference<T>(current_result_ptr, scan_state.current_frame_of_reference, to_scan);
-		}
-
-		scanned += to_scan;
-		scan_state.current_group_offset += 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, NumericCast<idx_t>(row_id));
-
-	D_ASSERT(scan_state.current_group_offset < BITPACKING_METADATA_GROUP_SIZE);
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	T *result_data = FlatVector::GetData<T>(result);
-	T *current_result_ptr = result_data + result_idx;
-
-	idx_t offset_in_compression_group =
-	    scan_state.current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-	data_ptr_t decompression_group_start_pointer =
-	    scan_state.current_group_ptr +
-	    (scan_state.current_group_offset - offset_in_compression_group) * scan_state.current_width / 8;
-
-	//! Because FOR offsets all our values to be 0 or above, we can always skip sign extension here
-	bool skip_sign_extend = true;
-
-	if (scan_state.current_group.mode == BitpackingMode::CONSTANT) {
-		*current_result_ptr = scan_state.current_constant;
-		return;
-	}
-
-	if (scan_state.current_group.mode == BitpackingMode::CONSTANT_DELTA) {
-		T multiplier;
-		auto cast = TryCast::Operation<idx_t, T>(scan_state.current_group_offset, multiplier);
-		(void)cast;
-		D_ASSERT(cast);
-#ifdef DEBUG
-		// overflow check
-		T result;
-		bool multiply = TryMultiplyOperator::Operation(multiplier, scan_state.current_constant, result);
-		bool add = TryAddOperator::Operation(result, scan_state.current_frame_of_reference, result);
-		D_ASSERT(multiply && add);
-#endif
-		*current_result_ptr = (multiplier * scan_state.current_constant) + scan_state.current_frame_of_reference;
-		return;
-	}
-
-	D_ASSERT(scan_state.current_group.mode == BitpackingMode::FOR ||
-	         scan_state.current_group.mode == BitpackingMode::DELTA_FOR);
-
-	BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(scan_state.decompression_buffer),
-	                                     decompression_group_start_pointer, scan_state.current_width, skip_sign_extend);
-
-	*current_result_ptr = scan_state.decompression_buffer[offset_in_compression_group];
-	*current_result_ptr += scan_state.current_frame_of_reference;
-
-	if (scan_state.current_group.mode == BitpackingMode::DELTA_FOR) {
-		*current_result_ptr += scan_state.current_delta_offset;
-	}
-}
-
-template <class T>
-void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = static_cast<BitpackingScanState<T> &>(*state.scan_state);
-	scan_state.Skip(segment, skip_count);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-template <class T, bool WRITE_STATISTICS = true>
-CompressionFunction GetBitpackingFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_BITPACKING, data_type, BitpackingInitAnalyze<T>,
-	                           BitpackingAnalyze<T>, BitpackingFinalAnalyze<T>,
-	                           BitpackingInitCompression<T, WRITE_STATISTICS>, BitpackingCompress<T, WRITE_STATISTICS>,
-	                           BitpackingFinalizeCompress<T, WRITE_STATISTICS>, BitpackingInitScan<T>,
-	                           BitpackingScan<T>, BitpackingScanPartial<T>, BitpackingFetchRow<T>, BitpackingSkip<T>);
-}
-
-CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	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::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);
-	case PhysicalType::INT128:
-		return GetBitpackingFunction<hugeint_t>(type);
-	case PhysicalType::UINT128:
-		return GetBitpackingFunction<uhugeint_t>(type);
-	case PhysicalType::LIST:
-		return GetBitpackingFunction<uint64_t, false>(type);
-	default:
-		throw InternalException("Unsupported type for Bitpacking");
-	}
-}
-
-bool BitpackingFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_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:
-	case PhysicalType::LIST:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT128:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp b/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp
deleted file mode 100644
index 3c84c6ec6..000000000
--- a/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-#include "duckdb/common/bitpacking.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Unpacking
-//===--------------------------------------------------------------------===//
-
-static void UnpackSingle(const uint32_t *__restrict &in, uhugeint_t *__restrict out, uint16_t delta, uint16_t shr) {
-	if (delta + shr < 32) {
-		*out = ((static_cast<uhugeint_t>(in[0])) >> shr) % (uhugeint_t(1) << delta);
-	}
-
-	else if (delta + shr >= 32 && delta + shr < 64) {
-		*out = static_cast<uhugeint_t>(in[0]) >> shr;
-		++in;
-
-		if (delta + shr > 32) {
-			const uint16_t NEXT_SHR = shr + delta - 32;
-			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (32 - shr);
-		}
-	}
-
-	else if (delta + shr >= 64 && delta + shr < 96) {
-		*out = static_cast<uhugeint_t>(in[0]) >> shr;
-		*out |= static_cast<uhugeint_t>(in[1]) << (32 - shr);
-		in += 2;
-
-		if (delta + shr > 64) {
-			const uint16_t NEXT_SHR = delta + shr - 64;
-			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (64 - shr);
-		}
-	}
-
-	else if (delta + shr >= 96 && delta + shr < 128) {
-		*out = static_cast<uhugeint_t>(in[0]) >> shr;
-		*out |= static_cast<uhugeint_t>(in[1]) << (32 - shr);
-		*out |= static_cast<uhugeint_t>(in[2]) << (64 - shr);
-		in += 3;
-
-		if (delta + shr > 96) {
-			const uint16_t NEXT_SHR = delta + shr - 96;
-			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (96 - shr);
-		}
-	}
-
-	else if (delta + shr >= 128) {
-		*out = static_cast<uhugeint_t>(in[0]) >> shr;
-		*out |= static_cast<uhugeint_t>(in[1]) << (32 - shr);
-		*out |= static_cast<uhugeint_t>(in[2]) << (64 - shr);
-		*out |= static_cast<uhugeint_t>(in[3]) << (96 - shr);
-		in += 4;
-
-		if (delta + shr > 128) {
-			const uint16_t NEXT_SHR = delta + shr - 128;
-			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (128 - shr);
-		}
-	}
-}
-
-static void UnpackLast(const uint32_t *__restrict &in, uhugeint_t *__restrict out, uint16_t delta) {
-	const uint8_t LAST_IDX = 31;
-	const uint16_t SHIFT = (delta * 31) % 32;
-	out[LAST_IDX] = in[0] >> SHIFT;
-	if (delta > 32) {
-		out[LAST_IDX] |= static_cast<uhugeint_t>(in[1]) << (32 - SHIFT);
-	}
-	if (delta > 64) {
-		out[LAST_IDX] |= static_cast<uhugeint_t>(in[2]) << (64 - SHIFT);
-	}
-	if (delta > 96) {
-		out[LAST_IDX] |= static_cast<uhugeint_t>(in[3]) << (96 - SHIFT);
-	}
-}
-
-// Unpacks for specific deltas
-static void UnpackDelta0(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		out[i] = 0;
-	}
-}
-
-static void UnpackDelta32(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
-	for (uint8_t k = 0; k < 32; ++k) {
-		out[k] = static_cast<uhugeint_t>(in[k]);
-	}
-}
-
-static void UnpackDelta64(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		const uint8_t OFFSET = i * 2;
-		out[i] = in[OFFSET];
-		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 1]) << 32;
-	}
-}
-
-static void UnpackDelta96(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		const uint8_t OFFSET = i * 3;
-		out[i] = in[OFFSET];
-		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 1]) << 32;
-		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 2]) << 64;
-	}
-}
-
-static void UnpackDelta128(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		const uint8_t OFFSET = i * 4;
-		out[i] = in[OFFSET];
-		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 1]) << 32;
-		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 2]) << 64;
-		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 3]) << 96;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Packing
-//===--------------------------------------------------------------------===//
-
-static void PackSingle(const uhugeint_t in, uint32_t *__restrict &out, uint16_t delta, uint16_t shl, uhugeint_t mask) {
-	if (delta + shl < 32) {
-
-		if (shl == 0) {
-			out[0] = static_cast<uint32_t>(in & mask);
-		} else {
-			out[0] |= static_cast<uint32_t>((in & mask) << shl);
-		}
-
-	} else if (delta + shl >= 32 && delta + shl < 64) {
-
-		if (shl == 0) {
-			out[0] = static_cast<uint32_t>(in & mask);
-		} else {
-			out[0] |= static_cast<uint32_t>((in & mask) << shl);
-		}
-		++out;
-
-		if (delta + shl > 32) {
-			*out = static_cast<uint32_t>((in & mask) >> (32 - shl));
-		}
-	}
-
-	else if (delta + shl >= 64 && delta + shl < 96) {
-
-		if (shl == 0) {
-			out[0] = static_cast<uint32_t>(in & mask);
-		} else {
-			out[0] |= static_cast<uint32_t>(in << shl);
-		}
-
-		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
-		out += 2;
-
-		if (delta + shl > 64) {
-			*out = static_cast<uint32_t>((in & mask) >> (64 - shl));
-		}
-	}
-
-	else if (delta + shl >= 96 && delta + shl < 128) {
-		if (shl == 0) {
-			out[0] = static_cast<uint32_t>(in & mask);
-		} else {
-			out[0] |= static_cast<uint32_t>(in << shl);
-		}
-
-		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
-		out[2] = static_cast<uint32_t>((in & mask) >> (64 - shl));
-		out += 3;
-
-		if (delta + shl > 96) {
-			*out = static_cast<uint32_t>((in & mask) >> (96 - shl));
-		}
-	}
-
-	else if (delta + shl >= 128) {
-		// shl == 0 won't ever happen here considering a delta of 128 calls PackDelta128
-		out[0] |= static_cast<uint32_t>(in << shl);
-		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
-		out[2] = static_cast<uint32_t>((in & mask) >> (64 - shl));
-		out[3] = static_cast<uint32_t>((in & mask) >> (96 - shl));
-		out += 4;
-
-		if (delta + shl > 128) {
-			*out = static_cast<uint32_t>((in & mask) >> (128 - shl));
-		}
-	}
-}
-
-static void PackLast(const uhugeint_t *__restrict in, uint32_t *__restrict out, uint16_t delta) {
-	const uint8_t LAST_IDX = 31;
-	const uint16_t SHIFT = (delta * 31) % 32;
-	out[0] |= static_cast<uint32_t>(in[LAST_IDX] << SHIFT);
-	if (delta > 32) {
-		out[1] = static_cast<uint32_t>(in[LAST_IDX] >> (32 - SHIFT));
-	}
-	if (delta > 64) {
-		out[2] = static_cast<uint32_t>(in[LAST_IDX] >> (64 - SHIFT));
-	}
-	if (delta > 96) {
-		out[3] = static_cast<uint32_t>(in[LAST_IDX] >> (96 - SHIFT));
-	}
-}
-
-// Packs for specific deltas
-static void PackDelta32(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		out[i] = static_cast<uint32_t>(in[i]);
-	}
-}
-
-static void PackDelta64(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		const uint8_t OFFSET = 2 * i;
-		out[OFFSET] = static_cast<uint32_t>(in[i]);
-		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
-	}
-}
-
-static void PackDelta96(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		const uint8_t OFFSET = 3 * i;
-		out[OFFSET] = static_cast<uint32_t>(in[i]);
-		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
-		out[OFFSET + 2] = static_cast<uint32_t>(in[i] >> 64);
-	}
-}
-
-static void PackDelta128(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
-	for (uint8_t i = 0; i < 32; ++i) {
-		const uint8_t OFFSET = 4 * i;
-		out[OFFSET] = static_cast<uint32_t>(in[i]);
-		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
-		out[OFFSET + 2] = static_cast<uint32_t>(in[i] >> 64);
-		out[OFFSET + 3] = static_cast<uint32_t>(in[i] >> 96);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// HugeIntPacker
-//===--------------------------------------------------------------------===//
-
-void HugeIntPacker::Pack(const uhugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width) {
-	D_ASSERT(width <= 128);
-	switch (width) {
-	case 0:
-		break;
-	case 32:
-		PackDelta32(in, out);
-		break;
-	case 64:
-		PackDelta64(in, out);
-		break;
-	case 96:
-		PackDelta96(in, out);
-		break;
-	case 128:
-		PackDelta128(in, out);
-		break;
-	default:
-		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
-			PackSingle(in[oindex], out, width, (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE,
-			           (uhugeint_t(1) << width) - 1);
-		}
-		PackLast(in, out, width);
-	}
-}
-
-void HugeIntPacker::Unpack(const uint32_t *__restrict in, uhugeint_t *__restrict out, bitpacking_width_t width) {
-	D_ASSERT(width <= 128);
-	switch (width) {
-	case 0:
-		UnpackDelta0(in, out);
-		break;
-	case 32:
-		UnpackDelta32(in, out);
-		break;
-	case 64:
-		UnpackDelta64(in, out);
-		break;
-	case 96:
-		UnpackDelta96(in, out);
-		break;
-	case 128:
-		UnpackDelta128(in, out);
-		break;
-	default:
-		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
-			UnpackSingle(in, out + oindex, width,
-			             (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE);
-		}
-		UnpackLast(in, out, width);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/chimp/bit_reader.cpp b/src/duckdb/src/storage/compression/chimp/bit_reader.cpp
deleted file mode 100644
index ee24cb583..000000000
--- a/src/duckdb/src/storage/compression/chimp/bit_reader.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "duckdb/storage/compression/chimp/algorithm/bit_reader.hpp"
-
-namespace duckdb {
-
-constexpr uint8_t BitReader::REMAINDER_MASKS[];
-constexpr uint8_t BitReader::MASKS[];
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/chimp/chimp.cpp b/src/duckdb/src/storage/compression/chimp/chimp.cpp
deleted file mode 100644
index 088c6dbdc..000000000
--- a/src/duckdb/src/storage/compression/chimp/chimp.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/chimp/chimp_analyze.hpp"
-#include "duckdb/storage/compression/chimp/chimp_compress.hpp"
-#include "duckdb/storage/compression/chimp/chimp_fetch.hpp"
-#include "duckdb/storage/compression/chimp/chimp_scan.hpp"
-
-namespace duckdb {
-
-template <class T>
-CompressionFunction GetChimpFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_CHIMP, data_type, ChimpInitAnalyze<T>, ChimpAnalyze<T>,
-	                           ChimpFinalAnalyze<T>, ChimpInitCompression<T>, ChimpCompress<T>,
-	                           ChimpFinalizeCompress<T>, ChimpInitScan<T>, ChimpScan<T>, ChimpScanPartial<T>,
-	                           ChimpFetchRow<T>, ChimpSkip<T>);
-}
-
-CompressionFunction ChimpCompressionFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::FLOAT:
-		return GetChimpFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetChimpFunction<double>(type);
-	default:
-		throw InternalException("Unsupported type for Chimp");
-	}
-}
-
-bool ChimpCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/chimp/chimp_constants.cpp b/src/duckdb/src/storage/compression/chimp/chimp_constants.cpp
deleted file mode 100644
index 4577ba5fc..000000000
--- a/src/duckdb/src/storage/compression/chimp/chimp_constants.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
-
-namespace duckdb {
-
-constexpr uint8_t ChimpConstants::Compression::LEADING_ROUND[];
-constexpr uint8_t ChimpConstants::Compression::LEADING_REPRESENTATION[];
-
-constexpr uint8_t ChimpConstants::Decompression::LEADING_REPRESENTATION[];
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/chimp/flag_buffer.cpp b/src/duckdb/src/storage/compression/chimp/flag_buffer.cpp
deleted file mode 100644
index 06c84d835..000000000
--- a/src/duckdb/src/storage/compression/chimp/flag_buffer.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp"
-
-namespace duckdb {
-
-constexpr uint8_t FlagBufferConstants::MASKS[];
-constexpr uint8_t FlagBufferConstants::SHIFTS[];
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/chimp/leading_zero_buffer.cpp b/src/duckdb/src/storage/compression/chimp/leading_zero_buffer.cpp
deleted file mode 100644
index ac4d9e434..000000000
--- a/src/duckdb/src/storage/compression/chimp/leading_zero_buffer.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp"
-
-namespace duckdb {
-
-constexpr uint32_t LeadingZeroBufferConstants::MASKS[];
-constexpr uint8_t LeadingZeroBufferConstants::SHIFTS[];
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/dictionary/analyze.cpp b/src/duckdb/src/storage/compression/dictionary/analyze.cpp
deleted file mode 100644
index 3d12bc2e1..000000000
--- a/src/duckdb/src/storage/compression/dictionary/analyze.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "duckdb/storage/compression/dictionary/analyze.hpp"
-
-namespace duckdb {
-
-DictionaryAnalyzeState::DictionaryAnalyzeState(const CompressionInfo &info)
-    : DictionaryCompressionState(info), segment_count(0), current_tuple_count(0), current_unique_count(0),
-      current_dict_size(0), current_width(0), next_width(0) {
-}
-
-bool DictionaryAnalyzeState::LookupString(string_t str) {
-	return current_set.count(str);
-}
-
-void DictionaryAnalyzeState::AddNewString(string_t str) {
-	current_tuple_count++;
-	current_unique_count++;
-	current_dict_size += str.GetSize();
-	if (str.IsInlined()) {
-		current_set.insert(str);
-	} else {
-		current_set.insert(heap.AddBlob(str));
-	}
-	current_width = next_width;
-}
-
-void DictionaryAnalyzeState::AddLastLookup() {
-	current_tuple_count++;
-}
-
-void DictionaryAnalyzeState::AddNull() {
-	current_tuple_count++;
-}
-
-bool DictionaryAnalyzeState::CalculateSpaceRequirements(bool new_string, idx_t string_size) {
-	if (!new_string) {
-		return DictionaryCompression::HasEnoughSpace(current_tuple_count + 1, current_unique_count, current_dict_size,
-		                                             current_width, info.GetBlockSize());
-	}
-	next_width = BitpackingPrimitives::MinimumBitWidth(current_unique_count + 2); // 1 for null, one for new string
-	return DictionaryCompression::HasEnoughSpace(current_tuple_count + 1, current_unique_count + 1,
-	                                             current_dict_size + string_size, next_width, info.GetBlockSize());
-}
-
-void DictionaryAnalyzeState::Flush(bool final) {
-	segment_count++;
-	current_tuple_count = 0;
-	current_unique_count = 0;
-	current_dict_size = 0;
-	current_set.clear();
-}
-void DictionaryAnalyzeState::Verify() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/dictionary/common.cpp b/src/duckdb/src/storage/compression/dictionary/common.cpp
deleted file mode 100644
index 05be9aaed..000000000
--- a/src/duckdb/src/storage/compression/dictionary/common.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "duckdb/storage/compression/dictionary/common.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Helper Functions
-//===--------------------------------------------------------------------===//
-bool DictionaryCompression::HasEnoughSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-                                           bitpacking_width_t packing_width, const idx_t block_size) {
-	return RequiredSpace(current_count, index_count, dict_size, packing_width) <= block_size;
-}
-
-idx_t DictionaryCompression::RequiredSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-                                           bitpacking_width_t packing_width) {
-	idx_t base_space = DICTIONARY_HEADER_SIZE + dict_size;
-	idx_t string_number_space = BitpackingPrimitives::GetRequiredSize(current_count, packing_width);
-	idx_t index_space = index_count * sizeof(uint32_t);
-
-	idx_t used_space = base_space + index_space + string_number_space;
-
-	return used_space;
-}
-
-StringDictionaryContainer DictionaryCompression::GetDictionary(ColumnSegment &segment, BufferHandle &handle) {
-	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(handle.Ptr() + segment.GetBlockOffset());
-	StringDictionaryContainer container;
-	container.size = Load<uint32_t>(data_ptr_cast(&header_ptr->dict_size));
-	container.end = Load<uint32_t>(data_ptr_cast(&header_ptr->dict_end));
-	return container;
-}
-
-void DictionaryCompression::SetDictionary(ColumnSegment &segment, BufferHandle &handle,
-                                          StringDictionaryContainer container) {
-	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(handle.Ptr() + segment.GetBlockOffset());
-	Store<uint32_t>(container.size, data_ptr_cast(&header_ptr->dict_size));
-	Store<uint32_t>(container.end, data_ptr_cast(&header_ptr->dict_end));
-}
-
-DictionaryCompressionState::DictionaryCompressionState(const CompressionInfo &info) : CompressionState(info) {
-}
-DictionaryCompressionState::~DictionaryCompressionState() {
-}
-
-bool DictionaryCompressionState::UpdateState(Vector &scan_vector, idx_t count) {
-	UnifiedVectorFormat vdata;
-	scan_vector.ToUnifiedFormat(count, vdata);
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-	Verify();
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		idx_t string_size = 0;
-		bool new_string = false;
-		auto row_is_valid = vdata.validity.RowIsValid(idx);
-
-		if (row_is_valid) {
-			string_size = data[idx].GetSize();
-			if (string_size >= StringUncompressed::GetStringBlockLimit(info.GetBlockSize())) {
-				// Big strings not implemented for dictionary compression
-				return false;
-			}
-			new_string = !LookupString(data[idx]);
-		}
-
-		bool fits = CalculateSpaceRequirements(new_string, string_size);
-		if (!fits) {
-			Flush();
-			new_string = true;
-
-			fits = CalculateSpaceRequirements(new_string, string_size);
-			if (!fits) {
-				throw InternalException("Dictionary compression could not write to new segment");
-			}
-		}
-
-		if (!row_is_valid) {
-			AddNull();
-		} else if (new_string) {
-			AddNewString(data[idx]);
-		} else {
-			AddLastLookup();
-		}
-
-		Verify();
-	}
-
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/dictionary/compression.cpp b/src/duckdb/src/storage/compression/dictionary/compression.cpp
deleted file mode 100644
index 64a3db402..000000000
--- a/src/duckdb/src/storage/compression/dictionary/compression.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-#include "duckdb/storage/compression/dictionary/compression.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-
-namespace duckdb {
-
-DictionaryCompressionCompressState::DictionaryCompressionCompressState(ColumnDataCheckpointData &checkpoint_data_p,
-                                                                       const CompressionInfo &info)
-    : DictionaryCompressionState(info), checkpoint_data(checkpoint_data_p),
-      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_DICTIONARY)) {
-	CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-}
-
-void DictionaryCompressionCompressState::CreateEmptySegment(idx_t row_start) {
-	auto &db = checkpoint_data.GetDatabase();
-	auto &type = checkpoint_data.GetType();
-
-	auto compressed_segment =
-	    ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize());
-	current_segment = std::move(compressed_segment);
-
-	// Reset the buffers and the string map.
-	current_string_map.clear();
-	index_buffer.clear();
-
-	// Reserve index 0 for null strings.
-	index_buffer.push_back(0);
-	selection_buffer.clear();
-
-	current_width = 0;
-	next_width = 0;
-
-	// Reset the pointers into the current segment.
-	auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase());
-	current_handle = buffer_manager.Pin(current_segment->block);
-	current_dictionary = DictionaryCompression::GetDictionary(*current_segment, current_handle);
-	current_end_ptr = current_handle.Ptr() + current_dictionary.end;
-}
-
-void DictionaryCompressionCompressState::Verify() {
-	current_dictionary.Verify(info.GetBlockSize());
-	D_ASSERT(current_segment->count == selection_buffer.size());
-	D_ASSERT(DictionaryCompression::HasEnoughSpace(current_segment->count.load(), index_buffer.size(),
-	                                               current_dictionary.size, current_width, info.GetBlockSize()));
-	D_ASSERT(current_dictionary.end == info.GetBlockSize());
-	D_ASSERT(index_buffer.size() == current_string_map.size() + 1); // +1 is for null value
-}
-
-bool DictionaryCompressionCompressState::LookupString(string_t str) {
-	auto search = current_string_map.find(str);
-	auto has_result = search != current_string_map.end();
-
-	if (has_result) {
-		latest_lookup_result = search->second;
-	}
-	return has_result;
-}
-
-void DictionaryCompressionCompressState::AddNewString(string_t str) {
-	UncompressedStringStorage::UpdateStringStats(current_segment->stats, str);
-
-	// Copy string to dict
-	current_dictionary.size += str.GetSize();
-	auto dict_pos = current_end_ptr - current_dictionary.size;
-	memcpy(dict_pos, str.GetData(), str.GetSize());
-	current_dictionary.Verify(info.GetBlockSize());
-	D_ASSERT(current_dictionary.end == info.GetBlockSize());
-
-	// Update buffers and map
-	index_buffer.push_back(current_dictionary.size);
-	selection_buffer.push_back(UnsafeNumericCast<uint32_t>(index_buffer.size() - 1));
-	if (str.IsInlined()) {
-		current_string_map.insert({str, index_buffer.size() - 1});
-	} else {
-		string_t dictionary_string((const char *)dict_pos, UnsafeNumericCast<uint32_t>(str.GetSize())); // NOLINT
-		D_ASSERT(!dictionary_string.IsInlined());
-		current_string_map.insert({dictionary_string, index_buffer.size() - 1});
-	}
-	DictionaryCompression::SetDictionary(*current_segment, current_handle, current_dictionary);
-
-	current_width = next_width;
-	current_segment->count++;
-}
-
-void DictionaryCompressionCompressState::AddNull() {
-	selection_buffer.push_back(0);
-	current_segment->count++;
-}
-
-void DictionaryCompressionCompressState::AddLastLookup() {
-	selection_buffer.push_back(latest_lookup_result);
-	current_segment->count++;
-}
-
-bool DictionaryCompressionCompressState::CalculateSpaceRequirements(bool new_string, idx_t string_size) {
-	if (!new_string) {
-		return DictionaryCompression::HasEnoughSpace(current_segment->count.load() + 1, index_buffer.size(),
-		                                             current_dictionary.size, current_width, info.GetBlockSize());
-	}
-	next_width = BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1 + new_string);
-	return DictionaryCompression::HasEnoughSpace(current_segment->count.load() + 1, index_buffer.size() + 1,
-	                                             current_dictionary.size + string_size, next_width,
-	                                             info.GetBlockSize());
-}
-
-void DictionaryCompressionCompressState::Flush(bool final) {
-	auto next_start = current_segment->start + current_segment->count;
-
-	auto segment_size = Finalize();
-	auto &state = checkpoint_data.GetCheckpointState();
-	state.FlushSegment(std::move(current_segment), std::move(current_handle), segment_size);
-
-	if (!final) {
-		CreateEmptySegment(next_start);
-	}
-}
-
-idx_t DictionaryCompressionCompressState::Finalize() {
-	auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase());
-	auto handle = buffer_manager.Pin(current_segment->block);
-	D_ASSERT(current_dictionary.end == info.GetBlockSize());
-
-	// calculate sizes
-	auto compressed_selection_buffer_size =
-	    BitpackingPrimitives::GetRequiredSize(current_segment->count, current_width);
-	auto index_buffer_size = index_buffer.size() * sizeof(uint32_t);
-	auto total_size = DictionaryCompression::DICTIONARY_HEADER_SIZE + compressed_selection_buffer_size +
-	                  index_buffer_size + current_dictionary.size;
-
-	// calculate ptr and offsets
-	auto base_ptr = handle.Ptr();
-	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(base_ptr);
-	auto compressed_selection_buffer_offset = DictionaryCompression::DICTIONARY_HEADER_SIZE;
-	auto index_buffer_offset = compressed_selection_buffer_offset + compressed_selection_buffer_size;
-
-	// Write compressed selection buffer
-	BitpackingPrimitives::PackBuffer<sel_t, false>(base_ptr + compressed_selection_buffer_offset,
-	                                               (sel_t *)(selection_buffer.data()), current_segment->count,
-	                                               current_width);
-
-	// Write the index buffer
-	memcpy(base_ptr + index_buffer_offset, index_buffer.data(), index_buffer_size);
-
-	// Store sizes and offsets in segment header
-	Store<uint32_t>(NumericCast<uint32_t>(index_buffer_offset), data_ptr_cast(&header_ptr->index_buffer_offset));
-	Store<uint32_t>(NumericCast<uint32_t>(index_buffer.size()), data_ptr_cast(&header_ptr->index_buffer_count));
-	Store<uint32_t>((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width));
-
-	D_ASSERT(current_width == BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1));
-	D_ASSERT(DictionaryCompression::HasEnoughSpace(current_segment->count, index_buffer.size(), current_dictionary.size,
-	                                               current_width, info.GetBlockSize()));
-	D_ASSERT((uint64_t)*max_element(std::begin(selection_buffer), std::end(selection_buffer)) ==
-	         index_buffer.size() - 1);
-
-	// Early-out, if the block is sufficiently full.
-	if (total_size >= info.GetCompactionFlushLimit()) {
-		return info.GetBlockSize();
-	}
-
-	// Sufficient space: calculate how much space we can save.
-	auto move_amount = info.GetBlockSize() - total_size;
-
-	// Move the dictionary to align it with the offsets.
-	auto new_dictionary_offset = index_buffer_offset + index_buffer_size;
-	memmove(base_ptr + new_dictionary_offset, base_ptr + current_dictionary.end - current_dictionary.size,
-	        current_dictionary.size);
-	current_dictionary.end -= move_amount;
-	D_ASSERT(current_dictionary.end == total_size);
-
-	// Write the new dictionary with the updated "end".
-	DictionaryCompression::SetDictionary(*current_segment, handle, current_dictionary);
-	return total_size;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/dictionary/decompression.cpp b/src/duckdb/src/storage/compression/dictionary/decompression.cpp
deleted file mode 100644
index 4063e9224..000000000
--- a/src/duckdb/src/storage/compression/dictionary/decompression.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#include "duckdb/storage/compression/dictionary/decompression.hpp"
-
-namespace duckdb {
-
-uint16_t CompressedStringScanState::GetStringLength(sel_t index) {
-	if (index == 0) {
-		return 0;
-	} else {
-		return UnsafeNumericCast<uint16_t>(index_buffer_ptr[index] - index_buffer_ptr[index - 1]);
-	}
-}
-
-string_t CompressedStringScanState::FetchStringFromDict(int32_t dict_offset, uint16_t string_len) {
-	D_ASSERT(dict_offset >= 0 && dict_offset <= NumericCast<int32_t>(block_size));
-	if (dict_offset == 0) {
-		return string_t(nullptr, 0);
-	}
-
-	// normal string: read string from this block
-	auto dict_end = baseptr + dict.end;
-	auto dict_pos = dict_end - dict_offset;
-
-	auto str_ptr = char_ptr_cast(dict_pos);
-	return string_t(str_ptr, string_len);
-}
-
-void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initialize_dictionary) {
-	baseptr = handle->Ptr() + segment.GetBlockOffset();
-
-	// Load header values
-	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(baseptr);
-	auto index_buffer_offset = Load<uint32_t>(data_ptr_cast(&header_ptr->index_buffer_offset));
-	index_buffer_count = Load<uint32_t>(data_ptr_cast(&header_ptr->index_buffer_count));
-	current_width = (bitpacking_width_t)(Load<uint32_t>(data_ptr_cast(&header_ptr->bitpacking_width)));
-	if (segment.GetBlockOffset() + index_buffer_offset + sizeof(uint32_t) * index_buffer_count >
-	    segment.GetBlockManager().GetBlockSize()) {
-		throw IOException(
-		    "Failed to scan dictionary string - index was out of range. Database file appears to be corrupted.");
-	}
-	index_buffer_ptr = reinterpret_cast<uint32_t *>(baseptr + index_buffer_offset);
-	base_data = data_ptr_cast(baseptr + DictionaryCompression::DICTIONARY_HEADER_SIZE);
-
-	block_size = segment.GetBlockManager().GetBlockSize();
-
-	dict = DictionaryCompression::GetDictionary(segment, *handle);
-
-	if (!initialize_dictionary) {
-		// Used by fetch, as fetch will never produce a DictionaryVector
-		return;
-	}
-
-	dictionary = make_buffer<Vector>(segment.type, index_buffer_count);
-	dictionary_size = index_buffer_count;
-	auto dict_child_data = FlatVector::GetData<string_t>(*(dictionary));
-	auto &validity = FlatVector::Validity(*dictionary);
-	D_ASSERT(index_buffer_count >= 1);
-	validity.SetInvalid(0);
-	for (uint32_t i = 0; i < index_buffer_count; i++) {
-		// NOTE: the passing of dict_child_vector, will not be used, its for big strings
-		uint16_t str_len = GetStringLength(i);
-		dict_child_data[i] = FetchStringFromDict(UnsafeNumericCast<int32_t>(index_buffer_ptr[i]), str_len);
-	}
-}
-
-void CompressedStringScanState::ScanToFlatVector(Vector &result, idx_t result_offset, idx_t start, idx_t scan_count) {
-	auto result_data = FlatVector::GetData<string_t>(result);
-	auto &validity = FlatVector::Validity(result);
-
-	// Handling non-bitpacking-group-aligned start values;
-	idx_t start_offset = start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-	// We will scan in blocks of BITPACKING_ALGORITHM_GROUP_SIZE, so we may scan some extra values.
-	idx_t decompress_count = BitpackingPrimitives::RoundUpToAlgorithmGroupSize(scan_count + start_offset);
-
-	// Create a decompression buffer of sufficient size if we don't already have one.
-	if (!sel_vec || sel_vec_size < decompress_count) {
-		sel_vec_size = decompress_count;
-		sel_vec = make_buffer<SelectionVector>(decompress_count);
-	}
-
-	data_ptr_t src = &base_data[((start - start_offset) * current_width) / 8];
-	sel_t *sel_vec_ptr = sel_vec->data();
-
-	BitpackingPrimitives::UnPackBuffer<sel_t>(data_ptr_cast(sel_vec_ptr), src, decompress_count, current_width);
-
-	for (idx_t i = 0; i < scan_count; i++) {
-		// Lookup dict offset in index buffer
-		auto string_number = sel_vec->get_index(i + start_offset);
-		if (string_number == 0) {
-			validity.SetInvalid(result_offset + i);
-		}
-		auto dict_offset = index_buffer_ptr[string_number];
-		auto str_len = GetStringLength(UnsafeNumericCast<sel_t>(string_number));
-		result_data[result_offset + i] = FetchStringFromDict(UnsafeNumericCast<int32_t>(dict_offset), str_len);
-	}
-}
-
-void CompressedStringScanState::ScanToDictionaryVector(ColumnSegment &segment, Vector &result, idx_t result_offset,
-                                                       idx_t start, idx_t scan_count) {
-	D_ASSERT(start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE == 0);
-	D_ASSERT(scan_count == STANDARD_VECTOR_SIZE);
-	D_ASSERT(result_offset == 0);
-
-	idx_t decompress_count = BitpackingPrimitives::RoundUpToAlgorithmGroupSize(scan_count);
-
-	// Create a selection vector of sufficient size if we don't already have one.
-	if (!sel_vec || sel_vec_size < decompress_count) {
-		sel_vec_size = decompress_count;
-		sel_vec = make_buffer<SelectionVector>(decompress_count);
-	}
-
-	// Scanning 2048 values, emitting a dict vector
-	data_ptr_t dst = data_ptr_cast(sel_vec->data());
-	data_ptr_t src = data_ptr_cast(&base_data[(start * current_width) / 8]);
-
-	BitpackingPrimitives::UnPackBuffer<sel_t>(dst, src, scan_count, current_width);
-
-	result.Dictionary(*(dictionary), dictionary_size, *sel_vec, scan_count);
-	DictionaryVector::SetDictionaryId(result, to_string(CastPointerToValue(&segment)));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/dictionary_compression.cpp b/src/duckdb/src/storage/compression/dictionary_compression.cpp
deleted file mode 100644
index 78915a374..000000000
--- a/src/duckdb/src/storage/compression/dictionary_compression.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-#include "duckdb/storage/compression/dictionary/analyze.hpp"
-#include "duckdb/storage/compression/dictionary/compression.hpp"
-#include "duckdb/storage/compression/dictionary/decompression.hpp"
-
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/string_map_set.hpp"
-#include "duckdb/common/types/vector_buffer.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-
-/*
-Data layout per segment:
-+------------------------------------------------------+
-|                  Header                              |
-|   +----------------------------------------------+   |
-|   |   dictionary_compression_header_t  header    |   |
-|   +----------------------------------------------+   |
-|                                                      |
-+------------------------------------------------------+
-|             Selection Buffer               |
-|   +------------------------------------+   |
-|   |   uint16_t index_buffer_idx[]      |   |
-|   +------------------------------------+   |
-|      tuple index -> index buffer idx       |
-|                                            |
-+--------------------------------------------+
-|               Index Buffer                 |
-|   +------------------------------------+   |
-|   |   uint16_t  dictionary_offset[]    |   |
-|   +------------------------------------+   |
-|  string_index -> offset in the dictionary  |
-|                                            |
-+--------------------------------------------+
-|                Dictionary                  |
-|   +------------------------------------+   |
-|   |   uint8_t *raw_string_data         |   |
-|   +------------------------------------+   |
-|      the string data without lengths       |
-|                                            |
-+--------------------------------------------+
-*/
-
-namespace duckdb {
-
-struct DictionaryCompressionStorage {
-	static unique_ptr<AnalyzeState> StringInitAnalyze(ColumnData &col_data, PhysicalType type);
-	static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count);
-	static idx_t StringFinalAnalyze(AnalyzeState &state_p);
-
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointData &checkpoint_data,
-	                                                    unique_ptr<AnalyzeState> state);
-	static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-
-	static unique_ptr<SegmentScanState> StringInitScan(ColumnSegment &segment);
-	template <bool ALLOW_DICT_VECTORS>
-	static void StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                              idx_t result_offset);
-	static void StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result);
-	static void StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                           idx_t result_idx);
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-unique_ptr<AnalyzeState> DictionaryCompressionStorage::StringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<DictionaryCompressionAnalyzeState>(info);
-}
-
-bool DictionaryCompressionStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<DictionaryCompressionAnalyzeState>();
-	return state.analyze_state->UpdateState(input, count);
-}
-
-idx_t DictionaryCompressionStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &analyze_state = state_p.Cast<DictionaryCompressionAnalyzeState>();
-	auto &state = *analyze_state.analyze_state;
-
-	auto width = BitpackingPrimitives::MinimumBitWidth(state.current_unique_count + 1);
-	auto req_space = DictionaryCompression::RequiredSpace(state.current_tuple_count, state.current_unique_count,
-	                                                      state.current_dict_size, width);
-
-	const auto total_space = state.segment_count * state.info.GetBlockSize() + req_space;
-	return LossyNumericCast<idx_t>(DictionaryCompression::MINIMUM_COMPRESSION_RATIO * float(total_space));
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-unique_ptr<CompressionState> DictionaryCompressionStorage::InitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                                           unique_ptr<AnalyzeState> state) {
-	return make_uniq<DictionaryCompressionCompressState>(checkpoint_data, state->info);
-}
-
-void DictionaryCompressionStorage::Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = state_p.Cast<DictionaryCompressionCompressState>();
-	state.UpdateState(scan_vector, count);
-}
-
-void DictionaryCompressionStorage::FinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<DictionaryCompressionCompressState>();
-	state.Flush(true);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-unique_ptr<SegmentScanState> DictionaryCompressionStorage::StringInitScan(ColumnSegment &segment) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto state = make_uniq<CompressedStringScanState>(buffer_manager.Pin(segment.block));
-	state->Initialize(segment, true);
-	return std::move(state);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <bool ALLOW_DICT_VECTORS>
-void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                                     Vector &result, idx_t result_offset) {
-	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = state.scan_state->Cast<CompressedStringScanState>();
-
-	auto start = segment.GetRelativeIndex(state.row_index);
-	if (!ALLOW_DICT_VECTORS || scan_count != STANDARD_VECTOR_SIZE ||
-	    start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE != 0) {
-		scan_state.ScanToFlatVector(result, result_offset, start, scan_count);
-	} else {
-		scan_state.ScanToDictionaryVector(segment, result, result_offset, start, scan_count);
-	}
-}
-
-void DictionaryCompressionStorage::StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                              Vector &result) {
-	StringScanPartial<true>(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void DictionaryCompressionStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
-                                                  Vector &result, idx_t result_idx) {
-	// fetch a single row from the string segment
-	CompressedStringScanState scan_state(state.GetOrInsertHandle(segment));
-	scan_state.Initialize(segment, false);
-	scan_state.ScanToFlatVector(result, result_idx, NumericCast<idx_t>(row_id), 1);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction DictionaryCompressionFun::GetFunction(PhysicalType data_type) {
-	auto res = CompressionFunction(
-	    CompressionType::COMPRESSION_DICTIONARY, data_type, DictionaryCompressionStorage ::StringInitAnalyze,
-	    DictionaryCompressionStorage::StringAnalyze, DictionaryCompressionStorage::StringFinalAnalyze,
-	    DictionaryCompressionStorage::InitCompression, DictionaryCompressionStorage::Compress,
-	    DictionaryCompressionStorage::FinalizeCompress, DictionaryCompressionStorage::StringInitScan,
-	    DictionaryCompressionStorage::StringScan, DictionaryCompressionStorage::StringScanPartial<false>,
-	    DictionaryCompressionStorage::StringFetchRow, UncompressedFunctions::EmptySkip,
-	    UncompressedStringStorage::StringInitSegment);
-	res.validity = CompressionValidity::NO_VALIDITY_REQUIRED;
-	return res;
-}
-
-bool DictionaryCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	return physical_type == PhysicalType::VARCHAR;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/empty_validity.cpp b/src/duckdb/src/storage/compression/empty_validity.cpp
deleted file mode 100644
index 0b6534153..000000000
--- a/src/duckdb/src/storage/compression/empty_validity.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/storage/compression/empty_validity.hpp"
-
-namespace duckdb {
-
-CompressionFunction EmptyValidityCompressionFun::GetFunction(PhysicalType type) {
-	return EmptyValidityCompression::CreateFunction();
-}
-
-bool EmptyValidityCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	D_ASSERT(physical_type == PhysicalType::BIT);
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp b/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp
deleted file mode 100644
index 3215f1b8f..000000000
--- a/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp
+++ /dev/null
@@ -1,313 +0,0 @@
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct FixedSizeAnalyzeState : public AnalyzeState {
-	explicit FixedSizeAnalyzeState(const CompressionInfo &info) : AnalyzeState(info), count(0) {
-	}
-
-	idx_t count;
-};
-
-unique_ptr<AnalyzeState> FixedSizeInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<FixedSizeAnalyzeState>(info);
-}
-
-bool FixedSizeAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<FixedSizeAnalyzeState>();
-	state.count += count;
-	return true;
-}
-
-template <class T>
-idx_t FixedSizeFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = state_p.template Cast<FixedSizeAnalyzeState>();
-	return sizeof(T) * state.count;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-struct UncompressedCompressState : public CompressionState {
-public:
-	UncompressedCompressState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info);
-
-public:
-	virtual void CreateEmptySegment(idx_t row_start);
-	void FlushSegment(idx_t segment_size);
-	void Finalize(idx_t segment_size);
-
-public:
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-	unique_ptr<ColumnSegment> current_segment;
-	ColumnAppendState append_state;
-};
-
-UncompressedCompressState::UncompressedCompressState(ColumnDataCheckpointData &checkpoint_data,
-                                                     const CompressionInfo &info)
-    : CompressionState(info), checkpoint_data(checkpoint_data),
-      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED)) {
-	UncompressedCompressState::CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-}
-
-void UncompressedCompressState::CreateEmptySegment(idx_t row_start) {
-	auto &db = checkpoint_data.GetDatabase();
-	auto &type = checkpoint_data.GetType();
-
-	auto compressed_segment =
-	    ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize());
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		auto &state = compressed_segment->GetSegmentState()->Cast<UncompressedStringSegmentState>();
-		state.overflow_writer =
-		    make_uniq<WriteOverflowStringsToDisk>(checkpoint_data.GetCheckpointState().GetPartialBlockManager());
-	}
-	current_segment = std::move(compressed_segment);
-	current_segment->InitializeAppend(append_state);
-}
-
-void UncompressedCompressState::FlushSegment(idx_t segment_size) {
-	auto &state = checkpoint_data.GetCheckpointState();
-	if (current_segment->type.InternalType() == PhysicalType::VARCHAR) {
-		auto &segment_state = current_segment->GetSegmentState()->Cast<UncompressedStringSegmentState>();
-		segment_state.overflow_writer->Flush();
-		segment_state.overflow_writer.reset();
-	}
-	append_state.child_appends.clear();
-	append_state.append_state.reset();
-	append_state.lock.reset();
-	state.FlushSegmentInternal(std::move(current_segment), segment_size);
-}
-
-void UncompressedCompressState::Finalize(idx_t segment_size) {
-	FlushSegment(segment_size);
-	current_segment.reset();
-}
-
-unique_ptr<CompressionState> UncompressedFunctions::InitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                                    unique_ptr<AnalyzeState> state) {
-	return make_uniq<UncompressedCompressState>(checkpoint_data, state->info);
-}
-
-void UncompressedFunctions::Compress(CompressionState &state_p, Vector &data, idx_t count) {
-	auto &state = state_p.Cast<UncompressedCompressState>();
-	UnifiedVectorFormat vdata;
-	data.ToUnifiedFormat(count, vdata);
-
-	idx_t offset = 0;
-	while (count > 0) {
-		idx_t appended = state.current_segment->Append(state.append_state, vdata, offset, count);
-		if (appended == count) {
-			// appended everything: finished
-			return;
-		}
-		auto next_start = state.current_segment->start + state.current_segment->count;
-		// the segment is full: flush it to disk
-		state.FlushSegment(state.current_segment->FinalizeAppend(state.append_state));
-
-		// now create a new segment and continue appending
-		state.CreateEmptySegment(next_start);
-		offset += appended;
-		count -= appended;
-	}
-}
-
-void UncompressedFunctions::FinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<UncompressedCompressState>();
-	state.Finalize(state.current_segment->FinalizeAppend(state.append_state));
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct FixedSizeScanState : public SegmentScanState {
-	BufferHandle handle;
-};
-
-unique_ptr<SegmentScanState> FixedSizeInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<FixedSizeScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	result->handle = buffer_manager.Pin(segment.block);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void FixedSizeScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                          idx_t result_offset) {
-	auto &scan_state = state.scan_state->Cast<FixedSizeScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto source_data = data + start * sizeof(T);
-
-	// copy the data from the base table
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	memcpy(FlatVector::GetData(result) + result_offset * sizeof(T), source_data, scan_count * sizeof(T));
-}
-
-template <class T>
-void FixedSizeScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &scan_state = state.scan_state->template Cast<FixedSizeScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto source_data = data + start * sizeof(T);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	FlatVector::SetData(result, source_data);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-template <class T>
-void FixedSizeFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                       idx_t result_idx) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-
-	// first fetch the data from the base table
-	auto data_ptr = handle.Ptr() + segment.GetBlockOffset() + NumericCast<idx_t>(row_id) * sizeof(T);
-
-	memcpy(FlatVector::GetData(result) + result_idx * sizeof(T), data_ptr, sizeof(T));
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-static unique_ptr<CompressionAppendState> FixedSizeInitAppend(ColumnSegment &segment) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	return make_uniq<CompressionAppendState>(std::move(handle));
-}
-
-struct StandardFixedSizeAppend {
-	template <class T>
-	static void Append(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, UnifiedVectorFormat &adata,
-	                   idx_t offset, idx_t count) {
-		auto sdata = UnifiedVectorFormat::GetData<T>(adata);
-		auto tdata = reinterpret_cast<T *>(target);
-		if (!adata.validity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto source_idx = adata.sel->get_index(offset + i);
-				auto target_idx = target_offset + i;
-				bool is_null = !adata.validity.RowIsValid(source_idx);
-				if (!is_null) {
-					stats.statistics.UpdateNumericStats<T>(sdata[source_idx]);
-					tdata[target_idx] = sdata[source_idx];
-				} else {
-					// we insert a NullValue<T> in the null gap for debuggability
-					// this value should never be used or read anywhere
-					tdata[target_idx] = NullValue<T>();
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto source_idx = adata.sel->get_index(offset + i);
-				auto target_idx = target_offset + i;
-				stats.statistics.UpdateNumericStats<T>(sdata[source_idx]);
-				tdata[target_idx] = sdata[source_idx];
-			}
-		}
-	}
-};
-
-struct ListFixedSizeAppend {
-	template <class T>
-	static void Append(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, UnifiedVectorFormat &adata,
-	                   idx_t offset, idx_t count) {
-		auto sdata = UnifiedVectorFormat::GetData<uint64_t>(adata);
-		auto tdata = reinterpret_cast<uint64_t *>(target);
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = adata.sel->get_index(offset + i);
-			auto target_idx = target_offset + i;
-			tdata[target_idx] = sdata[source_idx];
-		}
-	}
-};
-
-template <class T, class OP>
-idx_t FixedSizeAppend(CompressionAppendState &append_state, ColumnSegment &segment, SegmentStatistics &stats,
-                      UnifiedVectorFormat &data, idx_t offset, idx_t count) {
-	D_ASSERT(segment.GetBlockOffset() == 0);
-
-	auto target_ptr = append_state.handle.Ptr();
-	idx_t max_tuple_count = segment.SegmentSize() / sizeof(T);
-	idx_t copy_count = MinValue<idx_t>(count, max_tuple_count - segment.count);
-
-	OP::template Append<T>(stats, target_ptr, segment.count, data, offset, copy_count);
-	segment.count += copy_count;
-	return copy_count;
-}
-
-template <class T>
-idx_t FixedSizeFinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats) {
-	return segment.count * sizeof(T);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-template <class T, class APPENDER = StandardFixedSizeAppend>
-CompressionFunction FixedSizeGetFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, data_type, FixedSizeInitAnalyze,
-	                           FixedSizeAnalyze, FixedSizeFinalAnalyze<T>, UncompressedFunctions::InitCompression,
-	                           UncompressedFunctions::Compress, UncompressedFunctions::FinalizeCompress,
-	                           FixedSizeInitScan, FixedSizeScan<T>, FixedSizeScanPartial<T>, FixedSizeFetchRow<T>,
-	                           UncompressedFunctions::EmptySkip, nullptr, FixedSizeInitAppend,
-	                           FixedSizeAppend<T, APPENDER>, FixedSizeFinalizeAppend<T>);
-}
-
-CompressionFunction FixedSizeUncompressed::GetFunction(PhysicalType data_type) {
-	switch (data_type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return FixedSizeGetFunction<int8_t>(data_type);
-	case PhysicalType::INT16:
-		return FixedSizeGetFunction<int16_t>(data_type);
-	case PhysicalType::INT32:
-		return FixedSizeGetFunction<int32_t>(data_type);
-	case PhysicalType::INT64:
-		return FixedSizeGetFunction<int64_t>(data_type);
-	case PhysicalType::UINT8:
-		return FixedSizeGetFunction<uint8_t>(data_type);
-	case PhysicalType::UINT16:
-		return FixedSizeGetFunction<uint16_t>(data_type);
-	case PhysicalType::UINT32:
-		return FixedSizeGetFunction<uint32_t>(data_type);
-	case PhysicalType::UINT64:
-		return FixedSizeGetFunction<uint64_t>(data_type);
-	case PhysicalType::INT128:
-		return FixedSizeGetFunction<hugeint_t>(data_type);
-	case PhysicalType::UINT128:
-		return FixedSizeGetFunction<uhugeint_t>(data_type);
-	case PhysicalType::FLOAT:
-		return FixedSizeGetFunction<float>(data_type);
-	case PhysicalType::DOUBLE:
-		return FixedSizeGetFunction<double>(data_type);
-	case PhysicalType::INTERVAL:
-		return FixedSizeGetFunction<interval_t>(data_type);
-	case PhysicalType::LIST:
-		return FixedSizeGetFunction<uint64_t, ListFixedSizeAppend>(data_type);
-	default:
-		throw InternalException("Unsupported type for FixedSizeUncompressed::GetFunction");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/fsst.cpp b/src/duckdb/src/storage/compression/fsst.cpp
deleted file mode 100644
index bc5c52228..000000000
--- a/src/duckdb/src/storage/compression/fsst.cpp
+++ /dev/null
@@ -1,824 +0,0 @@
-#include "duckdb/common/fsst.hpp"
-
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp"
-#include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-
-#include "fsst.h"
-#include "miniz_wrapper.hpp"
-
-namespace duckdb {
-struct FSSTScanState;
-
-typedef struct {
-	uint32_t dict_size;
-	uint32_t dict_end;
-	uint32_t bitpacking_width;
-	uint32_t fsst_symbol_table_offset;
-} fsst_compression_header_t;
-
-// Counts and offsets used during scanning/fetching
-//                                         |               ColumnSegment to be scanned / fetched from				 |
-//                                         | untouched | bp align | unused d-values | to scan | bp align | untouched |
-typedef struct BPDeltaDecodeOffsets {
-	idx_t delta_decode_start_row;      //                         X
-	idx_t bitunpack_alignment_offset;  //			   <--------->
-	idx_t bitunpack_start_row;         //	           X
-	idx_t unused_delta_decoded_values; //						  <----------------->
-	idx_t scan_offset;                 //			   <---------------------------->
-	idx_t total_delta_decode_count;    //					      <-------------------------->
-	idx_t total_bitunpack_count;       //              <------------------------------------------------>
-} bp_delta_offsets_t;
-
-struct FSSTStorage {
-	static constexpr double MINIMUM_COMPRESSION_RATIO = 1.2;
-	static constexpr double ANALYSIS_SAMPLE_SIZE = 0.25;
-
-	static unique_ptr<AnalyzeState> StringInitAnalyze(ColumnData &col_data, PhysicalType type);
-	static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count);
-	static idx_t StringFinalAnalyze(AnalyzeState &state_p);
-
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointData &checkpoint_data,
-	                                                    unique_ptr<AnalyzeState> analyze_state_p);
-	static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-
-	static unique_ptr<SegmentScanState> StringInitScan(ColumnSegment &segment);
-	template <bool ALLOW_FSST_VECTORS = false>
-	static void StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                              idx_t result_offset);
-	static void StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result);
-	static void StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                           idx_t result_idx);
-	static void Select(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-	                   const SelectionVector &sel, idx_t sel_count);
-
-	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer container);
-	static StringDictionaryContainer GetDictionary(ColumnSegment &segment, BufferHandle &handle);
-
-	static char *FetchStringPointer(StringDictionaryContainer dict, data_ptr_t baseptr, int32_t dict_offset);
-	static bp_delta_offsets_t CalculateBpDeltaOffsets(int64_t last_known_row, idx_t start, idx_t scan_count);
-	static bool ParseFSSTSegmentHeader(data_ptr_t base_ptr, duckdb_fsst_decoder_t *decoder_out,
-	                                   bitpacking_width_t *width_out);
-	static bp_delta_offsets_t StartScan(FSSTScanState &scan_state, data_ptr_t base_data, idx_t start,
-	                                    idx_t vector_count);
-	static void EndScan(FSSTScanState &scan_state, bp_delta_offsets_t &offsets, idx_t start, idx_t scan_count);
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct FSSTAnalyzeState : public AnalyzeState {
-	explicit FSSTAnalyzeState(const CompressionInfo &info)
-	    : AnalyzeState(info), count(0), fsst_string_total_size(0), empty_strings(0) {
-	}
-
-	~FSSTAnalyzeState() override {
-		if (fsst_encoder) {
-			duckdb_fsst_destroy(fsst_encoder);
-		}
-	}
-
-	duckdb_fsst_encoder_t *fsst_encoder = nullptr;
-	idx_t count;
-
-	StringHeap fsst_string_heap;
-	vector<string_t> fsst_strings;
-	size_t fsst_string_total_size;
-
-	RandomEngine random_engine;
-	bool have_valid_row = false;
-
-	idx_t empty_strings;
-};
-
-unique_ptr<AnalyzeState> FSSTStorage::StringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<FSSTAnalyzeState>(info);
-}
-
-bool FSSTStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<FSSTAnalyzeState>();
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-
-	state.count += count;
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-
-	// Note that we ignore the sampling in case we have not found any valid strings yet, this solves the issue of
-	// not having seen any valid strings here leading to an empty fsst symbol table.
-	bool sample_selected = !state.have_valid_row || state.random_engine.NextRandom() < ANALYSIS_SAMPLE_SIZE;
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-
-		if (!vdata.validity.RowIsValid(idx)) {
-			continue;
-		}
-
-		// We need to check all strings for this, otherwise we run in to trouble during compression if we miss ones
-		auto string_size = data[idx].GetSize();
-		if (string_size >= StringUncompressed::GetStringBlockLimit(state.info.GetBlockSize())) {
-			return false;
-		}
-
-		if (!sample_selected) {
-			continue;
-		}
-
-		if (string_size > 0) {
-			state.have_valid_row = true;
-			if (data[idx].IsInlined()) {
-				state.fsst_strings.push_back(data[idx]);
-			} else {
-				state.fsst_strings.emplace_back(state.fsst_string_heap.AddBlob(data[idx]));
-			}
-			state.fsst_string_total_size += string_size;
-		} else {
-			state.empty_strings++;
-		}
-	}
-	return true;
-}
-
-idx_t FSSTStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = state_p.Cast<FSSTAnalyzeState>();
-
-	size_t compressed_dict_size = 0;
-	size_t max_compressed_string_length = 0;
-
-	auto string_count = state.fsst_strings.size();
-
-	if (!string_count) {
-		return DConstants::INVALID_INDEX;
-	}
-
-	size_t output_buffer_size = 7 + 2 * state.fsst_string_total_size; // size as specified in fsst.h
-
-	vector<size_t> fsst_string_sizes;
-	vector<unsigned char *> fsst_string_ptrs;
-	for (auto &str : state.fsst_strings) {
-		fsst_string_sizes.push_back(str.GetSize());
-		fsst_string_ptrs.push_back((unsigned char *)str.GetData()); // NOLINT
-	}
-
-	state.fsst_encoder = duckdb_fsst_create(string_count, &fsst_string_sizes[0], &fsst_string_ptrs[0], 0);
-
-	// TODO: do we really need to encode to get a size estimate?
-	auto compressed_ptrs = vector<unsigned char *>(string_count, nullptr);
-	auto compressed_sizes = vector<size_t>(string_count, 0);
-	unique_ptr<unsigned char[]> compressed_buffer(new unsigned char[output_buffer_size]);
-
-	auto res =
-	    duckdb_fsst_compress(state.fsst_encoder, string_count, &fsst_string_sizes[0], &fsst_string_ptrs[0],
-	                         output_buffer_size, compressed_buffer.get(), &compressed_sizes[0], &compressed_ptrs[0]);
-
-	if (string_count != res) {
-		throw std::runtime_error("FSST output buffer is too small unexpectedly");
-	}
-
-	// Sum and and Max compressed lengths
-	for (auto &size : compressed_sizes) {
-		compressed_dict_size += size;
-		max_compressed_string_length = MaxValue(max_compressed_string_length, size);
-	}
-	D_ASSERT(compressed_dict_size ==
-	         (uint64_t)(compressed_ptrs[res - 1] - compressed_ptrs[0]) + compressed_sizes[res - 1]);
-
-	auto minimum_width = BitpackingPrimitives::MinimumBitWidth(max_compressed_string_length);
-	auto bitpacked_offsets_size =
-	    BitpackingPrimitives::GetRequiredSize(string_count + state.empty_strings, minimum_width);
-
-	auto estimated_base_size = double(bitpacked_offsets_size + compressed_dict_size) * (1 / ANALYSIS_SAMPLE_SIZE);
-	auto num_blocks = estimated_base_size / double(state.info.GetBlockSize() - sizeof(duckdb_fsst_decoder_t));
-	auto symtable_size = num_blocks * sizeof(duckdb_fsst_decoder_t);
-	auto estimated_size = estimated_base_size + symtable_size;
-
-	return LossyNumericCast<idx_t>(estimated_size * MINIMUM_COMPRESSION_RATIO);
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-
-class FSSTCompressionState : public CompressionState {
-public:
-	FSSTCompressionState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info)
-	    : CompressionState(info), checkpoint_data(checkpoint_data),
-	      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_FSST)) {
-		CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-	}
-
-	~FSSTCompressionState() override {
-		if (fsst_encoder) {
-			duckdb_fsst_destroy(fsst_encoder);
-		}
-	}
-
-	void Reset() {
-		index_buffer.clear();
-		current_width = 0;
-		max_compressed_string_length = 0;
-		last_fitting_size = 0;
-
-		// Reset the pointers into the current segment
-		auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db);
-		current_handle = buffer_manager.Pin(current_segment->block);
-		current_dictionary = FSSTStorage::GetDictionary(*current_segment, current_handle);
-		current_end_ptr = current_handle.Ptr() + current_dictionary.end;
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start,
-		                                                                info.GetBlockSize(), info.GetBlockSize());
-		current_segment = std::move(compressed_segment);
-		Reset();
-	}
-
-	void UpdateState(string_t uncompressed_string, unsigned char *compressed_string, size_t compressed_string_len) {
-		if (!HasEnoughSpace(compressed_string_len)) {
-			Flush();
-			if (!HasEnoughSpace(compressed_string_len)) {
-				throw InternalException("FSST string compression failed due to insufficient space in empty block");
-			};
-		}
-
-		UncompressedStringStorage::UpdateStringStats(current_segment->stats, uncompressed_string);
-
-		// Write string into dictionary
-		current_dictionary.size += compressed_string_len;
-		auto dict_pos = current_end_ptr - current_dictionary.size;
-		memcpy(dict_pos, compressed_string, compressed_string_len);
-		current_dictionary.Verify(info.GetBlockSize());
-
-		// We just push the string length to effectively delta encode the strings
-		index_buffer.push_back(NumericCast<uint32_t>(compressed_string_len));
-
-		max_compressed_string_length = MaxValue(max_compressed_string_length, compressed_string_len);
-
-		current_width = BitpackingPrimitives::MinimumBitWidth(max_compressed_string_length);
-		current_segment->count++;
-	}
-
-	void AddNull() {
-		if (!HasEnoughSpace(0)) {
-			Flush();
-			if (!HasEnoughSpace(0)) {
-				throw InternalException("FSST string compression failed due to insufficient space in empty block");
-			};
-		}
-		index_buffer.push_back(0);
-		current_segment->count++;
-	}
-
-	void AddEmptyString() {
-		AddNull();
-		UncompressedStringStorage::UpdateStringStats(current_segment->stats, "");
-	}
-
-	size_t GetRequiredSize(size_t string_len) {
-		bitpacking_width_t required_minimum_width;
-		if (string_len > max_compressed_string_length) {
-			required_minimum_width = BitpackingPrimitives::MinimumBitWidth(string_len);
-		} else {
-			required_minimum_width = current_width;
-		}
-
-		size_t current_dict_size = current_dictionary.size;
-		idx_t current_string_count = index_buffer.size();
-
-		size_t dict_offsets_size =
-		    BitpackingPrimitives::GetRequiredSize(current_string_count + 1, required_minimum_width);
-
-		// TODO switch to a symbol table per RowGroup, saves a bit of space
-		return sizeof(fsst_compression_header_t) + current_dict_size + dict_offsets_size + string_len +
-		       fsst_serialized_symbol_table_size;
-	}
-
-	// Checks if there is enough space, if there is, sets last_fitting_size
-	bool HasEnoughSpace(size_t string_len) {
-		auto required_size = GetRequiredSize(string_len);
-
-		if (required_size <= info.GetBlockSize()) {
-			last_fitting_size = required_size;
-			return true;
-		}
-		return false;
-	}
-
-	void Flush(bool final = false) {
-		auto next_start = current_segment->start + current_segment->count;
-
-		auto segment_size = Finalize();
-		auto &state = checkpoint_data.GetCheckpointState();
-		state.FlushSegment(std::move(current_segment), std::move(current_handle), segment_size);
-
-		if (!final) {
-			CreateEmptySegment(next_start);
-		}
-	}
-
-	idx_t Finalize() {
-		auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db);
-		auto handle = buffer_manager.Pin(current_segment->block);
-		D_ASSERT(current_dictionary.end == info.GetBlockSize());
-
-		// calculate sizes
-		auto compressed_index_buffer_size =
-		    BitpackingPrimitives::GetRequiredSize(current_segment->count, current_width);
-		auto total_size = sizeof(fsst_compression_header_t) + compressed_index_buffer_size + current_dictionary.size +
-		                  fsst_serialized_symbol_table_size;
-
-		if (total_size != last_fitting_size) {
-			throw InternalException("FSST string compression failed due to incorrect size calculation");
-		}
-
-		// calculate ptr and offsets
-		auto base_ptr = handle.Ptr();
-		auto header_ptr = reinterpret_cast<fsst_compression_header_t *>(base_ptr);
-		auto compressed_index_buffer_offset = sizeof(fsst_compression_header_t);
-		auto symbol_table_offset = compressed_index_buffer_offset + compressed_index_buffer_size;
-
-		D_ASSERT(current_segment->count == index_buffer.size());
-		BitpackingPrimitives::PackBuffer<sel_t, false>(base_ptr + compressed_index_buffer_offset,
-		                                               reinterpret_cast<uint32_t *>(index_buffer.data()),
-		                                               current_segment->count, current_width);
-
-		// Write the fsst symbol table or nothing
-		if (fsst_encoder != nullptr) {
-			memcpy(base_ptr + symbol_table_offset, &fsst_serialized_symbol_table[0], fsst_serialized_symbol_table_size);
-		} else {
-			memset(base_ptr + symbol_table_offset, 0, fsst_serialized_symbol_table_size);
-		}
-
-		Store<uint32_t>(NumericCast<uint32_t>(symbol_table_offset),
-		                data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
-		Store<uint32_t>((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width));
-
-		if (total_size >= info.GetCompactionFlushLimit()) {
-			// the block is full enough, don't bother moving around the dictionary
-			return info.GetBlockSize();
-		}
-
-		// the block has space left: figure out how much space we can save
-		auto move_amount = info.GetBlockSize() - total_size;
-		// move the dictionary so it lines up exactly with the offsets
-		auto new_dictionary_offset = symbol_table_offset + fsst_serialized_symbol_table_size;
-		memmove(base_ptr + new_dictionary_offset, base_ptr + current_dictionary.end - current_dictionary.size,
-		        current_dictionary.size);
-		current_dictionary.end -= move_amount;
-		D_ASSERT(current_dictionary.end == total_size);
-		// write the new dictionary (with the updated "end")
-		FSSTStorage::SetDictionary(*current_segment, handle, current_dictionary);
-
-		return total_size;
-	}
-
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-
-	// State regarding current segment
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle current_handle;
-	StringDictionaryContainer current_dictionary;
-	data_ptr_t current_end_ptr;
-
-	// Buffers and map for current segment
-	vector<uint32_t> index_buffer;
-
-	size_t max_compressed_string_length;
-	bitpacking_width_t current_width;
-	idx_t last_fitting_size;
-
-	duckdb_fsst_encoder_t *fsst_encoder = nullptr;
-	unsigned char fsst_serialized_symbol_table[sizeof(duckdb_fsst_decoder_t)];
-	size_t fsst_serialized_symbol_table_size = sizeof(duckdb_fsst_decoder_t);
-};
-
-unique_ptr<CompressionState> FSSTStorage::InitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                          unique_ptr<AnalyzeState> analyze_state_p) {
-	auto &analyze_state = analyze_state_p->Cast<FSSTAnalyzeState>();
-	auto compression_state = make_uniq<FSSTCompressionState>(checkpoint_data, analyze_state.info);
-
-	if (analyze_state.fsst_encoder == nullptr) {
-		throw InternalException("No encoder found during FSST compression");
-	}
-
-	compression_state->fsst_encoder = analyze_state.fsst_encoder;
-	compression_state->fsst_serialized_symbol_table_size =
-	    duckdb_fsst_export(compression_state->fsst_encoder, &compression_state->fsst_serialized_symbol_table[0]);
-	analyze_state.fsst_encoder = nullptr;
-
-	return std::move(compression_state);
-}
-
-void FSSTStorage::Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = state_p.Cast<FSSTCompressionState>();
-
-	// Get vector data
-	UnifiedVectorFormat vdata;
-	scan_vector.ToUnifiedFormat(count, vdata);
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-
-	// Collect pointers to strings to compress
-	vector<size_t> sizes_in;
-	vector<unsigned char *> strings_in;
-	size_t total_size = 0;
-	idx_t total_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-
-		// Note: we treat nulls and empty strings the same
-		if (!vdata.validity.RowIsValid(idx) || data[idx].GetSize() == 0) {
-			continue;
-		}
-
-		total_count++;
-		total_size += data[idx].GetSize();
-		sizes_in.push_back(data[idx].GetSize());
-		strings_in.push_back((unsigned char *)data[idx].GetData()); // NOLINT
-	}
-
-	// Only Nulls or empty strings in this vector, nothing to compress
-	if (total_count == 0) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(idx)) {
-				state.AddNull();
-			} else if (data[idx].GetSize() == 0) {
-				state.AddEmptyString();
-			} else {
-				throw FatalException("FSST: no encoder found even though there are values to encode");
-			}
-		}
-		return;
-	}
-
-	// Compress buffers
-	size_t compress_buffer_size = MaxValue<size_t>(total_size * 2 + 7, 1);
-	vector<unsigned char *> strings_out(total_count, nullptr);
-	vector<size_t> sizes_out(total_count, 0);
-	vector<unsigned char> compress_buffer(compress_buffer_size, 0);
-
-	auto res = duckdb_fsst_compress(
-	    state.fsst_encoder,   /* IN: encoder obtained from duckdb_fsst_create(). */
-	    total_count,          /* IN: number of strings in batch to compress. */
-	    &sizes_in[0],         /* IN: byte-lengths of the inputs */
-	    &strings_in[0],       /* IN: input string start pointers. */
-	    compress_buffer_size, /* IN: byte-length of output buffer. */
-	    &compress_buffer[0],  /* OUT: memory buffer to put the compressed strings in (one after the other). */
-	    &sizes_out[0],        /* OUT: byte-lengths of the compressed strings. */
-	    &strings_out[0]       /* OUT: output string start pointers. Will all point into [output,output+size). */
-	);
-
-	if (res != total_count) {
-		throw FatalException("FSST compression failed to compress all strings");
-	}
-
-	// Push the compressed strings to the compression state one by one
-	idx_t compressed_idx = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(idx)) {
-			state.AddNull();
-		} else if (data[idx].GetSize() == 0) {
-			state.AddEmptyString();
-		} else {
-			state.UpdateState(data[idx], strings_out[compressed_idx], sizes_out[compressed_idx]);
-			compressed_idx++;
-		}
-	}
-}
-
-void FSSTStorage::FinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<FSSTCompressionState>();
-	state.Flush(true);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct FSSTScanState : public StringScanState {
-	explicit FSSTScanState(const idx_t string_block_limit) {
-		ResetStoredDelta();
-		decompress_buffer.resize(string_block_limit + 1);
-	}
-
-	buffer_ptr<void> duckdb_fsst_decoder;
-	vector<unsigned char> decompress_buffer;
-	bitpacking_width_t current_width;
-
-	// To speed up delta decoding we store the last index
-	uint32_t last_known_index;
-	int64_t last_known_row;
-
-	unsafe_unique_array<uint32_t> bitunpack_buffer;
-	idx_t bitunpack_buffer_capacity = 0;
-	unsafe_unique_array<uint32_t> delta_decode_buffer;
-	idx_t delta_decode_capacity = 0;
-
-	void StoreLastDelta(uint32_t value, int64_t row) {
-		last_known_index = value;
-		last_known_row = row;
-	}
-	void ResetStoredDelta() {
-		last_known_index = 0;
-		last_known_row = -1;
-	}
-	inline string_t DecompressString(StringDictionaryContainer dict, data_ptr_t baseptr,
-	                                 const bp_delta_offsets_t &offsets, idx_t index, Vector &result) {
-		uint32_t str_len = bitunpack_buffer[offsets.scan_offset + index];
-		auto str_ptr = FSSTStorage::FetchStringPointer(
-		    dict, baseptr,
-		    UnsafeNumericCast<int32_t>(delta_decode_buffer[index + offsets.unused_delta_decoded_values]));
-
-		if (str_len == 0) {
-			return string_t(nullptr, 0);
-		}
-		return FSSTPrimitives::DecompressValue(duckdb_fsst_decoder.get(), result, str_ptr, str_len, decompress_buffer);
-	}
-};
-
-unique_ptr<SegmentScanState> FSSTStorage::StringInitScan(ColumnSegment &segment) {
-	auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize());
-	auto state = make_uniq<FSSTScanState>(string_block_limit);
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	state->handle = buffer_manager.Pin(segment.block);
-	auto base_ptr = state->handle.Ptr() + segment.GetBlockOffset();
-
-	state->duckdb_fsst_decoder = make_buffer<duckdb_fsst_decoder_t>();
-	auto retval = ParseFSSTSegmentHeader(
-	    base_ptr, reinterpret_cast<duckdb_fsst_decoder_t *>(state->duckdb_fsst_decoder.get()), &state->current_width);
-	if (!retval) {
-		state->duckdb_fsst_decoder = nullptr;
-	}
-
-	return std::move(state);
-}
-
-void DeltaDecodeIndices(uint32_t *buffer_in, uint32_t *buffer_out, idx_t decode_count, uint32_t last_known_value) {
-	buffer_out[0] = buffer_in[0];
-	buffer_out[0] += last_known_value;
-	for (idx_t i = 1; i < decode_count; i++) {
-		buffer_out[i] = buffer_in[i] + buffer_out[i - 1];
-	}
-}
-
-void BitUnpackRange(data_ptr_t src_ptr, data_ptr_t dst_ptr, idx_t count, idx_t row, bitpacking_width_t width) {
-	auto bitunpack_src_ptr = &src_ptr[(row * width) / 8];
-	BitpackingPrimitives::UnPackBuffer<uint32_t>(dst_ptr, bitunpack_src_ptr, count, width);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-bp_delta_offsets_t FSSTStorage::StartScan(FSSTScanState &scan_state, data_ptr_t base_data, idx_t start,
-                                          idx_t scan_count) {
-	if (start == 0 || scan_state.last_known_row >= (int64_t)start) {
-		scan_state.ResetStoredDelta();
-	}
-
-	auto offsets = CalculateBpDeltaOffsets(scan_state.last_known_row, start, scan_count);
-
-	if (scan_state.bitunpack_buffer_capacity < offsets.total_bitunpack_count) {
-		scan_state.bitunpack_buffer = make_unsafe_uniq_array<uint32_t>(offsets.total_bitunpack_count);
-		scan_state.bitunpack_buffer_capacity = offsets.total_bitunpack_count;
-	}
-	BitUnpackRange(base_data, data_ptr_cast(scan_state.bitunpack_buffer.get()), offsets.total_bitunpack_count,
-	               offsets.bitunpack_start_row, scan_state.current_width);
-	if (scan_state.delta_decode_capacity < offsets.total_delta_decode_count) {
-		scan_state.delta_decode_buffer = make_unsafe_uniq_array<uint32_t>(offsets.total_delta_decode_count);
-		scan_state.delta_decode_capacity = offsets.total_delta_decode_count;
-	}
-	DeltaDecodeIndices(scan_state.bitunpack_buffer.get() + offsets.bitunpack_alignment_offset,
-	                   scan_state.delta_decode_buffer.get(), offsets.total_delta_decode_count,
-	                   scan_state.last_known_index);
-	return offsets;
-}
-
-void FSSTStorage::EndScan(FSSTScanState &scan_state, bp_delta_offsets_t &offsets, idx_t start, idx_t scan_count) {
-	scan_state.StoreLastDelta(scan_state.delta_decode_buffer[scan_count + offsets.unused_delta_decoded_values - 1],
-	                          UnsafeNumericCast<int64_t>(start + scan_count - 1));
-}
-
-template <bool ALLOW_FSST_VECTORS>
-void FSSTStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                                    idx_t result_offset) {
-
-	auto &scan_state = state.scan_state->Cast<FSSTScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	bool enable_fsst_vectors;
-	if (ALLOW_FSST_VECTORS) {
-		auto &config = DBConfig::GetConfig(segment.db);
-		enable_fsst_vectors = config.options.enable_fsst_vectors;
-	} else {
-		enable_fsst_vectors = false;
-	}
-
-	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, scan_state.handle);
-	auto base_data = data_ptr_cast(baseptr + sizeof(fsst_compression_header_t));
-	string_t *result_data;
-
-	if (scan_count == 0) {
-		return;
-	}
-
-	if (enable_fsst_vectors) {
-		D_ASSERT(result_offset == 0);
-		if (scan_state.duckdb_fsst_decoder) {
-			D_ASSERT(result_offset == 0 || result.GetVectorType() == VectorType::FSST_VECTOR);
-			result.SetVectorType(VectorType::FSST_VECTOR);
-			auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize());
-			FSSTVector::RegisterDecoder(result, scan_state.duckdb_fsst_decoder, string_block_limit);
-			result_data = FSSTVector::GetCompressedData<string_t>(result);
-		} else {
-			D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-			result_data = FlatVector::GetData<string_t>(result);
-		}
-	} else {
-		D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-		result_data = FlatVector::GetData<string_t>(result);
-	}
-
-	auto offsets = StartScan(scan_state, base_data, start, scan_count);
-	auto &bitunpack_buffer = scan_state.bitunpack_buffer;
-	auto &delta_decode_buffer = scan_state.delta_decode_buffer;
-	if (enable_fsst_vectors) {
-		// Lookup decompressed offsets in dict
-		for (idx_t i = 0; i < scan_count; i++) {
-			uint32_t string_length = bitunpack_buffer[i + offsets.scan_offset];
-			result_data[i] = UncompressedStringStorage::FetchStringFromDict(
-			    segment, dict, result, baseptr,
-			    UnsafeNumericCast<int32_t>(delta_decode_buffer[i + offsets.unused_delta_decoded_values]),
-			    string_length);
-			FSSTVector::SetCount(result, scan_count);
-		}
-	} else {
-		// Just decompress
-		for (idx_t i = 0; i < scan_count; i++) {
-			result_data[i + result_offset] = scan_state.DecompressString(dict, baseptr, offsets, i, result);
-		}
-	}
-	EndScan(scan_state, offsets, start, scan_count);
-}
-
-void FSSTStorage::StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	StringScanPartial<true>(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Select
-//===--------------------------------------------------------------------===//
-void FSSTStorage::Select(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-                         const SelectionVector &sel, idx_t sel_count) {
-	auto &scan_state = state.scan_state->Cast<FSSTScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, scan_state.handle);
-	auto base_data = data_ptr_cast(baseptr + sizeof(fsst_compression_header_t));
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	auto offsets = StartScan(scan_state, base_data, start, vector_count);
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < sel_count; i++) {
-		idx_t index = sel.get_index(i);
-		result_data[i] = scan_state.DecompressString(dict, baseptr, offsets, index, result);
-	}
-	EndScan(scan_state, offsets, start, vector_count);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void FSSTStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                                 idx_t result_idx) {
-
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	auto base_ptr = handle.Ptr() + segment.GetBlockOffset();
-	auto base_data = data_ptr_cast(base_ptr + sizeof(fsst_compression_header_t));
-	auto dict = GetDictionary(segment, handle);
-
-	duckdb_fsst_decoder_t decoder;
-	bitpacking_width_t width;
-	auto have_symbol_table = ParseFSSTSegmentHeader(base_ptr, &decoder, &width);
-
-	auto result_data = FlatVector::GetData<string_t>(result);
-	if (!have_symbol_table) {
-		// There is no FSST symtable. This is only the case for empty strings or NULLs. We emit an empty string.
-		result_data[result_idx] = string_t(nullptr, 0);
-		return;
-	}
-
-	// We basically just do a scan of 1 which is kinda expensive as we need to repeatedly delta decode until we
-	// reach the row we want, we could consider a more clever caching trick if this is slow
-	auto offsets = CalculateBpDeltaOffsets(-1, UnsafeNumericCast<idx_t>(row_id), 1);
-
-	auto bitunpack_buffer = unique_ptr<uint32_t[]>(new uint32_t[offsets.total_bitunpack_count]);
-	BitUnpackRange(base_data, data_ptr_cast(bitunpack_buffer.get()), offsets.total_bitunpack_count,
-	               offsets.bitunpack_start_row, width);
-	auto delta_decode_buffer = unique_ptr<uint32_t[]>(new uint32_t[offsets.total_delta_decode_count]);
-	DeltaDecodeIndices(bitunpack_buffer.get() + offsets.bitunpack_alignment_offset, delta_decode_buffer.get(),
-	                   offsets.total_delta_decode_count, 0);
-
-	uint32_t string_length = bitunpack_buffer[offsets.scan_offset];
-
-	string_t compressed_string = UncompressedStringStorage::FetchStringFromDict(
-	    segment, dict, result, base_ptr,
-	    UnsafeNumericCast<int32_t>(delta_decode_buffer[offsets.unused_delta_decoded_values]), string_length);
-
-	vector<unsigned char> uncompress_buffer;
-	auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize());
-	uncompress_buffer.resize(string_block_limit + 1);
-	result_data[result_idx] = FSSTPrimitives::DecompressValue((void *)&decoder, result, compressed_string.GetData(),
-	                                                          compressed_string.GetSize(), uncompress_buffer);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction FSSTFun::GetFunction(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::VARCHAR);
-	return CompressionFunction(CompressionType::COMPRESSION_FSST, data_type, FSSTStorage::StringInitAnalyze,
-	                           FSSTStorage::StringAnalyze, FSSTStorage::StringFinalAnalyze,
-	                           FSSTStorage::InitCompression, FSSTStorage::Compress, FSSTStorage::FinalizeCompress,
-	                           FSSTStorage::StringInitScan, FSSTStorage::StringScan,
-	                           FSSTStorage::StringScanPartial<false>, FSSTStorage::StringFetchRow,
-	                           UncompressedFunctions::EmptySkip, UncompressedStringStorage::StringInitSegment, nullptr,
-	                           nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, FSSTStorage::Select);
-}
-
-bool FSSTFun::TypeIsSupported(const PhysicalType physical_type) {
-	return physical_type == PhysicalType::VARCHAR;
-}
-
-//===--------------------------------------------------------------------===//
-// Helper Functions
-//===--------------------------------------------------------------------===//
-void FSSTStorage::SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer container) {
-	auto header_ptr = reinterpret_cast<fsst_compression_header_t *>(handle.Ptr() + segment.GetBlockOffset());
-	Store<uint32_t>(container.size, data_ptr_cast(&header_ptr->dict_size));
-	Store<uint32_t>(container.end, data_ptr_cast(&header_ptr->dict_end));
-}
-
-StringDictionaryContainer FSSTStorage::GetDictionary(ColumnSegment &segment, BufferHandle &handle) {
-	auto header_ptr = reinterpret_cast<fsst_compression_header_t *>(handle.Ptr() + segment.GetBlockOffset());
-	StringDictionaryContainer container;
-	container.size = Load<uint32_t>(data_ptr_cast(&header_ptr->dict_size));
-	container.end = Load<uint32_t>(data_ptr_cast(&header_ptr->dict_end));
-	return container;
-}
-
-char *FSSTStorage::FetchStringPointer(StringDictionaryContainer dict, data_ptr_t baseptr, int32_t dict_offset) {
-	if (dict_offset == 0) {
-		return nullptr;
-	}
-
-	auto dict_end = baseptr + dict.end;
-	auto dict_pos = dict_end - dict_offset;
-	return char_ptr_cast(dict_pos);
-}
-
-// Returns false if no symbol table was found. This means all strings are either empty or null
-bool FSSTStorage::ParseFSSTSegmentHeader(data_ptr_t base_ptr, duckdb_fsst_decoder_t *decoder_out,
-                                         bitpacking_width_t *width_out) {
-	auto header_ptr = reinterpret_cast<fsst_compression_header_t *>(base_ptr);
-	auto fsst_symbol_table_offset = Load<uint32_t>(data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
-	*width_out = (bitpacking_width_t)(Load<uint32_t>(data_ptr_cast(&header_ptr->bitpacking_width)));
-	return duckdb_fsst_import(decoder_out, base_ptr + fsst_symbol_table_offset);
-}
-
-// The calculation of offsets and counts while scanning or fetching is a bit tricky, for two reasons:
-// - bitunpacking needs to be aligned to BITPACKING_ALGORITHM_GROUP_SIZE
-// - delta decoding needs to decode from the last known value.
-bp_delta_offsets_t FSSTStorage::CalculateBpDeltaOffsets(int64_t last_known_row, idx_t start, idx_t scan_count) {
-	D_ASSERT((idx_t)(last_known_row + 1) <= start);
-	bp_delta_offsets_t result;
-
-	result.delta_decode_start_row = (idx_t)(last_known_row + 1);
-	result.bitunpack_alignment_offset =
-	    result.delta_decode_start_row % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-	result.bitunpack_start_row = result.delta_decode_start_row - result.bitunpack_alignment_offset;
-	result.unused_delta_decoded_values = start - result.delta_decode_start_row;
-	result.scan_offset = result.bitunpack_alignment_offset + result.unused_delta_decoded_values;
-	result.total_delta_decode_count = scan_count + result.unused_delta_decoded_values;
-	result.total_bitunpack_count =
-	    BitpackingPrimitives::RoundUpToAlgorithmGroupSize<idx_t>(scan_count + result.scan_offset);
-
-	D_ASSERT(result.total_delta_decode_count + result.bitunpack_alignment_offset <= result.total_bitunpack_count);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/numeric_constant.cpp b/src/duckdb/src/storage/compression/numeric_constant.cpp
deleted file mode 100644
index 097ab9068..000000000
--- a/src/duckdb/src/storage/compression/numeric_constant.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-unique_ptr<SegmentScanState> ConstantInitScan(ColumnSegment &segment) {
-	return nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan Partial
-//===--------------------------------------------------------------------===//
-void ConstantFillFunctionValidity(ColumnSegment &segment, Vector &result, idx_t start_idx, idx_t count) {
-	auto &stats = segment.stats.statistics;
-	if (stats.CanHaveNull()) {
-		auto &mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < count; i++) {
-			mask.SetInvalid(start_idx + i);
-		}
-	}
-}
-
-template <class T>
-void ConstantFillFunction(ColumnSegment &segment, Vector &result, idx_t start_idx, idx_t count) {
-	auto &nstats = segment.stats.statistics;
-
-	auto data = FlatVector::GetData<T>(result);
-	auto constant_value = NumericStats::GetMin<T>(nstats);
-	for (idx_t i = 0; i < count; i++) {
-		data[start_idx + i] = constant_value;
-	}
-}
-
-void ConstantScanPartialValidity(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                                 idx_t result_offset) {
-	ConstantFillFunctionValidity(segment, result, result_offset, scan_count);
-}
-
-template <class T>
-void ConstantScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                         idx_t result_offset) {
-	ConstantFillFunction<T>(segment, result, result_offset, scan_count);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void ConstantScanFunctionValidity(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &stats = segment.stats.statistics;
-	if (stats.CanHaveNull()) {
-		if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			result.Flatten(scan_count);
-			ConstantFillFunctionValidity(segment, result, 0, scan_count);
-		}
-	}
-}
-
-template <class T>
-void ConstantScanFunction(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &nstats = segment.stats.statistics;
-
-	auto data = FlatVector::GetData<T>(result);
-	data[0] = NumericStats::GetMin<T>(nstats);
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ConstantFetchRowValidity(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                              idx_t result_idx) {
-	ConstantFillFunctionValidity(segment, result, result_idx, 1);
-}
-
-template <class T>
-void ConstantFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	ConstantFillFunction<T>(segment, result, result_idx, 1);
-}
-
-//===--------------------------------------------------------------------===//
-// Select
-//===--------------------------------------------------------------------===//
-void ConstantSelectValidity(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-                            const SelectionVector &sel, idx_t sel_count) {
-	ConstantScanFunctionValidity(segment, state, vector_count, result);
-}
-
-template <class T>
-void ConstantSelect(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-                    const SelectionVector &sel, idx_t sel_count) {
-	ConstantScanFunction<T>(segment, state, vector_count, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Filter
-//===--------------------------------------------------------------------===//
-void FiltersNullValues(const TableFilter &filter, bool &filters_nulls, bool &filters_valid_values) {
-	filters_nulls = false;
-	filters_valid_values = false;
-
-	switch (filter.filter_type) {
-	case TableFilterType::OPTIONAL_FILTER:
-		break;
-	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction_or = filter.Cast<ConjunctionOrFilter>();
-		filters_nulls = true;
-		filters_valid_values = true;
-		for (auto &child_filter : conjunction_or.child_filters) {
-			bool child_filters_nulls, child_filters_valid_values;
-			FiltersNullValues(*child_filter, child_filters_nulls, child_filters_valid_values);
-			filters_nulls = filters_nulls && child_filters_nulls;
-			filters_valid_values = filters_valid_values && child_filters_valid_values;
-		}
-		break;
-	}
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
-		filters_nulls = false;
-		filters_valid_values = false;
-		for (auto &child_filter : conjunction_and.child_filters) {
-			bool child_filters_nulls, child_filters_valid_values;
-			FiltersNullValues(*child_filter, child_filters_nulls, child_filters_valid_values);
-			filters_nulls = filters_nulls || child_filters_nulls;
-			filters_valid_values = filters_valid_values || child_filters_valid_values;
-		}
-		break;
-	}
-	case TableFilterType::CONSTANT_COMPARISON:
-		filters_nulls = true;
-		break;
-	case TableFilterType::IS_NULL:
-		filters_valid_values = true;
-		break;
-	case TableFilterType::IS_NOT_NULL:
-		filters_nulls = true;
-		break;
-	default:
-		throw InternalException("FIXME: unsupported type for filter selection in validity select");
-	}
-}
-
-void ConstantFilterValidity(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-                            SelectionVector &sel, idx_t &sel_count, const TableFilter &filter) {
-	// check what effect the filter has on NULL values
-	bool filters_nulls, filters_valid_values;
-	FiltersNullValues(filter, filters_nulls, filters_valid_values);
-
-	auto &stats = segment.stats.statistics;
-	if (stats.CanHaveNull()) {
-		// all values are NULL
-		if (filters_nulls) {
-			// ... and the filter removes NULL values
-			sel_count = 0;
-			return;
-		}
-	} else {
-		// all values are valid
-		if (filters_valid_values) {
-			// ... and the filter removes valid values
-			sel_count = 0;
-			return;
-		}
-	}
-	ConstantScanFunctionValidity(segment, state, vector_count, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction ConstantGetFunctionValidity(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::BIT);
-	return CompressionFunction(CompressionType::COMPRESSION_CONSTANT, data_type, nullptr, nullptr, nullptr, nullptr,
-	                           nullptr, nullptr, ConstantInitScan, ConstantScanFunctionValidity,
-	                           ConstantScanPartialValidity, ConstantFetchRowValidity, UncompressedFunctions::EmptySkip,
-	                           nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                           ConstantSelectValidity, ConstantFilterValidity);
-}
-
-template <class T>
-CompressionFunction ConstantGetFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_CONSTANT, data_type, nullptr, nullptr, nullptr, nullptr,
-	                           nullptr, nullptr, ConstantInitScan, ConstantScanFunction<T>, ConstantScanPartial<T>,
-	                           ConstantFetchRow<T>, UncompressedFunctions::EmptySkip, nullptr, nullptr, nullptr,
-	                           nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, ConstantSelect<T>);
-}
-
-CompressionFunction ConstantFun::GetFunction(PhysicalType data_type) {
-	switch (data_type) {
-	case PhysicalType::BIT:
-		return ConstantGetFunctionValidity(data_type);
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return ConstantGetFunction<int8_t>(data_type);
-	case PhysicalType::INT16:
-		return ConstantGetFunction<int16_t>(data_type);
-	case PhysicalType::INT32:
-		return ConstantGetFunction<int32_t>(data_type);
-	case PhysicalType::INT64:
-		return ConstantGetFunction<int64_t>(data_type);
-	case PhysicalType::UINT8:
-		return ConstantGetFunction<uint8_t>(data_type);
-	case PhysicalType::UINT16:
-		return ConstantGetFunction<uint16_t>(data_type);
-	case PhysicalType::UINT32:
-		return ConstantGetFunction<uint32_t>(data_type);
-	case PhysicalType::UINT64:
-		return ConstantGetFunction<uint64_t>(data_type);
-	case PhysicalType::INT128:
-		return ConstantGetFunction<hugeint_t>(data_type);
-	case PhysicalType::UINT128:
-		return ConstantGetFunction<uhugeint_t>(data_type);
-	case PhysicalType::FLOAT:
-		return ConstantGetFunction<float>(data_type);
-	case PhysicalType::DOUBLE:
-		return ConstantGetFunction<double>(data_type);
-	default:
-		throw InternalException("Unsupported type for ConstantUncompressed::GetFunction");
-	}
-}
-
-bool ConstantFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::BIT:
-	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:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		throw InternalException("Unsupported type for constant function");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/patas.cpp b/src/duckdb/src/storage/compression/patas.cpp
deleted file mode 100644
index 1a7a6fd56..000000000
--- a/src/duckdb/src/storage/compression/patas.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/common/limits.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/compression/patas/patas_analyze.hpp"
-#include "duckdb/storage/compression/patas/patas_compress.hpp"
-#include "duckdb/storage/compression/patas/patas_fetch.hpp"
-#include "duckdb/storage/compression/patas/patas_scan.hpp"
-
-namespace duckdb {
-
-template <class T>
-CompressionFunction GetPatasFunction(PhysicalType data_type) {
-	throw NotImplementedException("GetPatasFunction not implemented for the given datatype");
-}
-
-template <>
-CompressionFunction GetPatasFunction<float>(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_PATAS, data_type, PatasInitAnalyze<float>,
-	                           PatasAnalyze<float>, PatasFinalAnalyze<float>, PatasInitCompression<float>,
-	                           PatasCompress<float>, PatasFinalizeCompress<float>, PatasInitScan<float>,
-	                           PatasScan<float>, PatasScanPartial<float>, PatasFetchRow<float>, PatasSkip<float>);
-}
-
-template <>
-CompressionFunction GetPatasFunction<double>(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_PATAS, data_type, PatasInitAnalyze<double>,
-	                           PatasAnalyze<double>, PatasFinalAnalyze<double>, PatasInitCompression<double>,
-	                           PatasCompress<double>, PatasFinalizeCompress<double>, PatasInitScan<double>,
-	                           PatasScan<double>, PatasScanPartial<double>, PatasFetchRow<double>, PatasSkip<double>);
-}
-
-CompressionFunction PatasCompressionFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::FLOAT:
-		return GetPatasFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetPatasFunction<double>(type);
-	default:
-		throw InternalException("Unsupported type for Patas");
-	}
-}
-
-bool PatasCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/rle.cpp b/src/duckdb/src/storage/compression/rle.cpp
deleted file mode 100644
index 0144ff829..000000000
--- a/src/duckdb/src/storage/compression/rle.cpp
+++ /dev/null
@@ -1,631 +0,0 @@
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-#include <functional>
-
-namespace duckdb {
-
-using rle_count_t = uint16_t;
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct EmptyRLEWriter {
-	template <class VALUE_TYPE>
-	static void Operation(VALUE_TYPE value, rle_count_t count, void *dataptr, bool is_null) {
-	}
-};
-
-template <class T>
-struct RLEState {
-	RLEState() : seen_count(0), last_value(NullValue<T>()), last_seen_count(0), dataptr(nullptr) {
-	}
-
-	idx_t seen_count;
-	T last_value;
-	rle_count_t last_seen_count;
-	void *dataptr;
-	bool all_null = true;
-
-public:
-	template <class OP>
-	void Flush() {
-		OP::template Operation<T>(last_value, last_seen_count, dataptr, all_null);
-	}
-
-	template <class OP = EmptyRLEWriter>
-	void Update(const T *data, ValidityMask &validity, idx_t idx) {
-		if (validity.RowIsValid(idx)) {
-			if (all_null) {
-				// no value seen yet
-				// assign the current value, and increment the seen_count
-				// note that we increment last_seen_count rather than setting it to 1
-				// this is intentional: this is the first VALID value we see
-				// but it might not be the first value in case of nulls!
-				last_value = data[idx];
-				seen_count++;
-				last_seen_count++;
-				all_null = false;
-			} else if (last_value == data[idx]) {
-				// the last value is identical to this value: increment the last_seen_count
-				last_seen_count++;
-			} else {
-				// the values are different
-				// issue the callback on the last value
-				// edge case: if a value has exactly 2^16 repeated values, we can end up here with last_seen_count = 0
-				if (last_seen_count > 0) {
-					Flush<OP>();
-					seen_count++;
-				}
-
-				// increment the seen_count and put the new value into the RLE slot
-				last_value = data[idx];
-				last_seen_count = 1;
-			}
-		} else {
-			// NULL value: we merely increment the last_seen_count
-			last_seen_count++;
-		}
-		if (last_seen_count == NumericLimits<rle_count_t>::Maximum()) {
-			// we have seen the same value so many times in a row we are at the limit of what fits in our count
-			// write away the value and move to the next value
-			Flush<OP>();
-			last_seen_count = 0;
-			seen_count++;
-		}
-	}
-};
-
-template <class T>
-struct RLEAnalyzeState : public AnalyzeState {
-	explicit RLEAnalyzeState(const CompressionInfo &info) : AnalyzeState(info) {
-	}
-
-	RLEState<T> state;
-};
-
-template <class T>
-unique_ptr<AnalyzeState> RLEInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<RLEAnalyzeState<T>>(info);
-}
-
-template <class T>
-bool RLEAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &rle_state = state.template Cast<RLEAnalyzeState<T>>();
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-
-	auto data = UnifiedVectorFormat::GetData<T>(vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		rle_state.state.Update(data, vdata.validity, idx);
-	}
-	return true;
-}
-
-template <class T>
-idx_t RLEFinalAnalyze(AnalyzeState &state) {
-	auto &rle_state = state.template Cast<RLEAnalyzeState<T>>();
-	return (sizeof(rle_count_t) + sizeof(T)) * rle_state.state.seen_count;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-struct RLEConstants {
-	static constexpr const idx_t RLE_HEADER_SIZE = sizeof(uint64_t);
-};
-
-template <class T, bool WRITE_STATISTICS>
-struct RLECompressState : public CompressionState {
-	struct RLEWriter {
-		template <class VALUE_TYPE>
-		static void Operation(VALUE_TYPE value, rle_count_t count, void *dataptr, bool is_null) {
-			auto state = reinterpret_cast<RLECompressState<T, WRITE_STATISTICS> *>(dataptr);
-			state->WriteValue(value, count, is_null);
-		}
-	};
-
-	idx_t MaxRLECount() {
-		auto entry_size = sizeof(T) + sizeof(rle_count_t);
-		return (info.GetBlockSize() - RLEConstants::RLE_HEADER_SIZE) / entry_size;
-	}
-
-	RLECompressState(ColumnDataCheckpointData &checkpoint_data_p, const CompressionInfo &info)
-	    : CompressionState(info), checkpoint_data(checkpoint_data_p),
-	      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_RLE)) {
-		CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-
-		state.dataptr = (void *)this;
-		max_rle_count = MaxRLECount();
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-
-		auto column_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(),
-		                                                            info.GetBlockSize());
-		current_segment = std::move(column_segment);
-
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
-		handle = buffer_manager.Pin(current_segment->block);
-	}
-
-	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = UnifiedVectorFormat::GetData<T>(vdata);
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = vdata.sel->get_index(i);
-			state.template Update<RLECompressState<T, WRITE_STATISTICS>::RLEWriter>(data, vdata.validity, idx);
-		}
-	}
-
-	void WriteValue(T value, rle_count_t count, bool is_null) {
-		// write the RLE entry
-		auto handle_ptr = handle.Ptr() + RLEConstants::RLE_HEADER_SIZE;
-		auto data_pointer = reinterpret_cast<T *>(handle_ptr);
-		auto index_pointer = reinterpret_cast<rle_count_t *>(handle_ptr + max_rle_count * sizeof(T));
-		data_pointer[entry_count] = value;
-		index_pointer[entry_count] = count;
-		entry_count++;
-
-		// update meta data
-		if (WRITE_STATISTICS && !is_null) {
-			current_segment->stats.statistics.UpdateNumericStats<T>(value);
-		}
-		current_segment->count += count;
-
-		if (entry_count == max_rle_count) {
-			// we have finished writing this segment: flush it and create a new segment
-			auto row_start = current_segment->start + current_segment->count;
-			FlushSegment();
-			CreateEmptySegment(row_start);
-			entry_count = 0;
-		}
-	}
-
-	void FlushSegment() {
-		// flush the segment
-		// we compact the segment by moving the counts so they are directly next to the values
-		idx_t counts_size = sizeof(rle_count_t) * entry_count;
-		idx_t original_rle_offset = RLEConstants::RLE_HEADER_SIZE + max_rle_count * sizeof(T);
-		idx_t minimal_rle_offset = AlignValue(RLEConstants::RLE_HEADER_SIZE + sizeof(T) * entry_count);
-		idx_t total_segment_size = minimal_rle_offset + counts_size;
-		auto data_ptr = handle.Ptr();
-		memmove(data_ptr + minimal_rle_offset, data_ptr + original_rle_offset, counts_size);
-		// store the final RLE offset within the segment
-		Store<uint64_t>(minimal_rle_offset, data_ptr);
-		handle.Destroy();
-
-		auto &state = checkpoint_data.GetCheckpointState();
-		state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size);
-	}
-
-	void Finalize() {
-		state.template Flush<RLECompressState<T, WRITE_STATISTICS>::RLEWriter>();
-
-		FlushSegment();
-		current_segment.reset();
-	}
-
-	ColumnDataCheckpointData &checkpoint_data;
-	CompressionFunction &function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	RLEState<T> state;
-	idx_t entry_count = 0;
-	idx_t max_rle_count;
-};
-
-template <class T, bool WRITE_STATISTICS>
-unique_ptr<CompressionState> RLEInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                unique_ptr<AnalyzeState> state) {
-	return make_uniq<RLECompressState<T, WRITE_STATISTICS>>(checkpoint_data, state->info);
-}
-
-template <class T, bool WRITE_STATISTICS>
-void RLECompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = state_p.Cast<RLECompressState<T, WRITE_STATISTICS>>();
-	UnifiedVectorFormat vdata;
-	scan_vector.ToUnifiedFormat(count, vdata);
-
-	state.Append(vdata, count);
-}
-
-template <class T, bool WRITE_STATISTICS>
-void RLEFinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<RLECompressState<T, WRITE_STATISTICS>>();
-	state.Finalize();
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-template <class T>
-struct RLEScanState : public SegmentScanState {
-	explicit RLEScanState(ColumnSegment &segment) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		handle = buffer_manager.Pin(segment.block);
-		entry_pos = 0;
-		position_in_entry = 0;
-		rle_count_offset = UnsafeNumericCast<uint32_t>(Load<uint64_t>(handle.Ptr() + segment.GetBlockOffset()));
-		D_ASSERT(rle_count_offset <= segment.GetBlockManager().GetBlockSize());
-	}
-
-	inline void SkipInternal(rle_count_t *index_pointer, idx_t skip_count) {
-		while (skip_count > 0) {
-			rle_count_t run_end = index_pointer[entry_pos];
-			idx_t skip_amount = MinValue<idx_t>(skip_count, run_end - position_in_entry);
-
-			skip_count -= skip_amount;
-			position_in_entry += skip_amount;
-			if (ExhaustedRun(index_pointer)) {
-				ForwardToNextRun();
-			}
-		}
-	}
-
-	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		auto data = handle.Ptr() + segment.GetBlockOffset();
-		auto index_pointer = reinterpret_cast<rle_count_t *>(data + rle_count_offset);
-		SkipInternal(index_pointer, skip_count);
-	}
-
-	inline void ForwardToNextRun() {
-		// handled all entries in this RLE value
-		// move to the next entry
-		entry_pos++;
-		position_in_entry = 0;
-	}
-
-	inline bool ExhaustedRun(rle_count_t *index_pointer) {
-		return position_in_entry >= index_pointer[entry_pos];
-	}
-
-	BufferHandle handle;
-	idx_t entry_pos;
-	idx_t position_in_entry;
-	uint32_t rle_count_offset;
-	//! If we are running a filter over the column - the runs that match the filter
-	unsafe_unique_array<bool> matching_runs;
-	idx_t matching_run_count = 0;
-};
-
-template <class T>
-unique_ptr<SegmentScanState> RLEInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<RLEScanState<T>>(segment);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void RLESkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = state.scan_state->Cast<RLEScanState<T>>();
-	scan_state.Skip(segment, skip_count);
-}
-
-template <bool ENTIRE_VECTOR>
-static bool CanEmitConstantVector(idx_t position, idx_t run_length, idx_t scan_count) {
-	if (!ENTIRE_VECTOR) {
-		return false;
-	}
-	if (scan_count != STANDARD_VECTOR_SIZE) {
-		// Only when we can fill an entire Vector can we emit a ConstantVector, because subsequent scans require the
-		// input Vector to be flat
-		return false;
-	}
-	D_ASSERT(position < run_length);
-	auto remaining_in_run = run_length - position;
-	// The amount of values left in this run are equal or greater than the amount of values we need to scan
-	return remaining_in_run >= scan_count;
-}
-
-template <class T>
-static void RLEScanConstant(RLEScanState<T> &scan_state, rle_count_t *index_pointer, T *data_pointer, idx_t scan_count,
-                            Vector &result) {
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	auto result_data = ConstantVector::GetData<T>(result);
-	result_data[0] = data_pointer[scan_state.entry_pos];
-	scan_state.position_in_entry += scan_count;
-	if (scan_state.ExhaustedRun(index_pointer)) {
-		scan_state.ForwardToNextRun();
-	}
-	return;
-}
-
-template <class T, bool ENTIRE_VECTOR>
-void RLEScanPartialInternal(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                            idx_t result_offset) {
-	auto &scan_state = state.scan_state->Cast<RLEScanState<T>>();
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
-	auto index_pointer = reinterpret_cast<rle_count_t *>(data + scan_state.rle_count_offset);
-
-	// If we are scanning an entire Vector and it contains only a single run
-	if (CanEmitConstantVector<ENTIRE_VECTOR>(scan_state.position_in_entry, index_pointer[scan_state.entry_pos],
-	                                         scan_count)) {
-		RLEScanConstant<T>(scan_state, index_pointer, data_pointer, scan_count, result);
-		return;
-	}
-
-	auto result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	idx_t result_end = result_offset + scan_count;
-	while (result_offset < result_end) {
-		rle_count_t run_end = index_pointer[scan_state.entry_pos];
-		idx_t run_count = run_end - scan_state.position_in_entry;
-		idx_t remaining_scan_count = result_end - result_offset;
-		T element = data_pointer[scan_state.entry_pos];
-		if (DUCKDB_UNLIKELY(run_count > remaining_scan_count)) {
-			for (idx_t i = 0; i < remaining_scan_count; i++) {
-				result_data[result_offset + i] = element;
-			}
-			scan_state.position_in_entry += remaining_scan_count;
-			break;
-		}
-
-		for (idx_t i = 0; i < run_count; i++) {
-			result_data[result_offset + i] = element;
-		}
-
-		result_offset += run_count;
-		scan_state.ForwardToNextRun();
-	}
-}
-
-template <class T>
-void RLEScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                    idx_t result_offset) {
-	return RLEScanPartialInternal<T, false>(segment, state, scan_count, result, result_offset);
-}
-
-template <class T>
-void RLEScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	RLEScanPartialInternal<T, true>(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Select
-//===--------------------------------------------------------------------===//
-template <class T>
-void RLESelect(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
-               const SelectionVector &sel, idx_t sel_count) {
-	auto &scan_state = state.scan_state->Cast<RLEScanState<T>>();
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
-	auto index_pointer = reinterpret_cast<rle_count_t *>(data + scan_state.rle_count_offset);
-
-	// If we are scanning an entire Vector and it contains only a single run we don't need to select at all
-	if (CanEmitConstantVector<true>(scan_state.position_in_entry, index_pointer[scan_state.entry_pos], vector_count)) {
-		RLEScanConstant<T>(scan_state, index_pointer, data_pointer, vector_count, result);
-		return;
-	}
-
-	auto result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	idx_t prev_idx = 0;
-	for (idx_t i = 0; i < sel_count; i++) {
-		auto next_idx = sel.get_index(i);
-		if (next_idx < prev_idx) {
-			throw InternalException("Error in RLESelect - selection vector indices are not ordered");
-		}
-		// skip forward to the next index
-		scan_state.SkipInternal(index_pointer, next_idx - prev_idx);
-		// read the element
-		result_data[i] = data_pointer[scan_state.entry_pos];
-		// move the next to the prev
-		prev_idx = next_idx;
-	}
-	// skip the tail
-	scan_state.SkipInternal(index_pointer, vector_count - prev_idx);
-}
-
-//===--------------------------------------------------------------------===//
-// Filter
-//===--------------------------------------------------------------------===//
-template <class T>
-void RLEFilter(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result, SelectionVector &sel,
-               idx_t &sel_count, const TableFilter &filter) {
-	auto &scan_state = state.scan_state->Cast<RLEScanState<T>>();
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
-	auto index_pointer = reinterpret_cast<rle_count_t *>(data + scan_state.rle_count_offset);
-
-	auto total_run_count = (scan_state.rle_count_offset - RLEConstants::RLE_HEADER_SIZE) / sizeof(T);
-	if (!scan_state.matching_runs) {
-		// we haven't applied the filter yet
-		// apply the filter to all RLE values at once
-
-		// initialize the filter set to all false (all runs are filtered out)
-		scan_state.matching_runs = make_unsafe_uniq_array<bool>(total_run_count);
-		memset(scan_state.matching_runs.get(), 0, sizeof(bool) * total_run_count);
-
-		// execute the filter over all runs at once
-		Vector run_vector(result.GetType(), data_ptr_cast(data_pointer));
-
-		UnifiedVectorFormat run_format;
-		run_vector.ToUnifiedFormat(total_run_count, run_format);
-
-		SelectionVector run_matches;
-		scan_state.matching_run_count = total_run_count;
-		ColumnSegment::FilterSelection(run_matches, run_vector, run_format, filter, total_run_count,
-		                               scan_state.matching_run_count);
-
-		// for any runs that pass the filter - set the matches to true
-		for (idx_t i = 0; i < scan_state.matching_run_count; i++) {
-			auto idx = run_matches.get_index(i);
-			scan_state.matching_runs[idx] = true;
-		}
-	}
-	if (scan_state.matching_run_count == 0) {
-		// early-out, no runs match the filter so the filter can never pass
-		sel_count = 0;
-		return;
-	}
-	// scan (the subset of) the matching runs AND set the output selection vector with the rows that match
-	auto result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	idx_t matching_count = 0;
-	SelectionVector matching_sel(sel_count);
-	if (!sel.IsSet()) {
-		// no selection vector yet - fast path
-		// this is essentially the normal scan, but we apply the filter and fill the selection vector
-		idx_t result_offset = 0;
-		idx_t result_end = sel_count;
-		while (result_offset < result_end) {
-			rle_count_t run_end = index_pointer[scan_state.entry_pos];
-			idx_t run_count = run_end - scan_state.position_in_entry;
-			idx_t remaining_scan_count = result_end - result_offset;
-			// the run is scanned - scan it
-			T element = data_pointer[scan_state.entry_pos];
-			if (DUCKDB_UNLIKELY(run_count > remaining_scan_count)) {
-				if (scan_state.matching_runs[scan_state.entry_pos]) {
-					for (idx_t i = 0; i < remaining_scan_count; i++) {
-						result_data[result_offset + i] = element;
-						matching_sel.set_index(matching_count++, result_offset + i);
-					}
-				}
-				scan_state.position_in_entry += remaining_scan_count;
-				break;
-			}
-
-			if (scan_state.matching_runs[scan_state.entry_pos]) {
-				for (idx_t i = 0; i < run_count; i++) {
-					result_data[result_offset + i] = element;
-					matching_sel.set_index(matching_count++, result_offset + i);
-				}
-			}
-
-			result_offset += run_count;
-			scan_state.ForwardToNextRun();
-		}
-	} else {
-		// we already have a selection applied - this is more complex since we need to merge it with our filter
-		// use a simpler (but slower) approach
-		idx_t prev_idx = 0;
-		for (idx_t i = 0; i < sel_count; i++) {
-			auto read_idx = sel.get_index(i);
-			if (read_idx < prev_idx) {
-				throw InternalException("Error in RLEFilter - selection vector indices are not ordered");
-			}
-			// skip forward to the next index
-			scan_state.SkipInternal(index_pointer, read_idx - prev_idx);
-			prev_idx = read_idx;
-			if (!scan_state.matching_runs[scan_state.entry_pos]) {
-				// this run is filtered out - we don't need to scan it
-				continue;
-			}
-			// the run is not filtered out - read the element
-			result_data[read_idx] = data_pointer[scan_state.entry_pos];
-			matching_sel.set_index(matching_count++, read_idx);
-		}
-		// skip the tail
-		scan_state.SkipInternal(index_pointer, vector_count - prev_idx);
-	}
-
-	// set up the filter result
-	if (matching_count != sel_count) {
-		sel.Initialize(matching_sel);
-		sel_count = matching_count;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-template <class T>
-void RLEFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	RLEScanState<T> scan_state(segment);
-	scan_state.Skip(segment, NumericCast<idx_t>(row_id));
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<T>(result);
-	result_data[result_idx] = data_pointer[scan_state.entry_pos];
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-template <class T, bool WRITE_STATISTICS = true>
-CompressionFunction GetRLEFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_RLE, data_type, RLEInitAnalyze<T>, RLEAnalyze<T>,
-	                           RLEFinalAnalyze<T>, RLEInitCompression<T, WRITE_STATISTICS>,
-	                           RLECompress<T, WRITE_STATISTICS>, RLEFinalizeCompress<T, WRITE_STATISTICS>,
-	                           RLEInitScan<T>, RLEScan<T>, RLEScanPartial<T>, RLEFetchRow<T>, RLESkip<T>, nullptr,
-	                           nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, RLESelect<T>,
-	                           RLEFilter<T>);
-}
-
-CompressionFunction RLEFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return GetRLEFunction<int8_t>(type);
-	case PhysicalType::INT16:
-		return GetRLEFunction<int16_t>(type);
-	case PhysicalType::INT32:
-		return GetRLEFunction<int32_t>(type);
-	case PhysicalType::INT64:
-		return GetRLEFunction<int64_t>(type);
-	case PhysicalType::INT128:
-		return GetRLEFunction<hugeint_t>(type);
-	case PhysicalType::UINT128:
-		return GetRLEFunction<uhugeint_t>(type);
-	case PhysicalType::UINT8:
-		return GetRLEFunction<uint8_t>(type);
-	case PhysicalType::UINT16:
-		return GetRLEFunction<uint16_t>(type);
-	case PhysicalType::UINT32:
-		return GetRLEFunction<uint32_t>(type);
-	case PhysicalType::UINT64:
-		return GetRLEFunction<uint64_t>(type);
-	case PhysicalType::FLOAT:
-		return GetRLEFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetRLEFunction<double>(type);
-	case PhysicalType::LIST:
-		return GetRLEFunction<uint64_t, false>(type);
-	default:
-		throw InternalException("Unsupported type for RLE");
-	}
-}
-
-bool RLEFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::UINT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-	case PhysicalType::LIST:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/roaring/analyze.cpp b/src/duckdb/src/storage/compression/roaring/analyze.cpp
deleted file mode 100644
index f5a49eb29..000000000
--- a/src/duckdb/src/storage/compression/roaring/analyze.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#include "duckdb/storage/compression/roaring/roaring.hpp"
-#include "duckdb/storage/compression/roaring/appender.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/bitpacking.hpp"
-
-namespace duckdb {
-
-namespace roaring {
-
-static unsafe_unique_array<BitmaskTableEntry> CreateBitmaskTable() {
-	unsafe_unique_array<BitmaskTableEntry> result;
-	result = make_unsafe_uniq_array_uninitialized<BitmaskTableEntry>(NumericLimits<uint8_t>::Maximum() + 1);
-
-	for (uint16_t val = 0; val < NumericLimits<uint8_t>::Maximum() + 1; val++) {
-		bool previous_bit;
-		auto &entry = result[val];
-		entry.valid_count = 0;
-		entry.run_count = 0;
-		for (uint8_t i = 0; i < 8; i++) {
-			const bool bit_set = val & (1 << i);
-			if (!i) {
-				entry.first_bit_set = bit_set;
-			} else if (i == 7) {
-				entry.last_bit_set = bit_set;
-			}
-			entry.valid_count += bit_set;
-
-			if (i && !bit_set && previous_bit == true) {
-				entry.run_count++;
-			}
-			previous_bit = bit_set;
-		}
-	}
-
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-RoaringAnalyzeState::RoaringAnalyzeState(const CompressionInfo &info)
-    : AnalyzeState(info), bitmask_table(CreateBitmaskTable()) {
-}
-
-void RoaringAnalyzeState::HandleByte(RoaringAnalyzeState &state, uint8_t array_index) {
-	auto bit_info = state.bitmask_table[static_cast<uint8_t>(array_index)];
-
-	state.run_count +=
-	    bit_info.run_count + (bit_info.first_bit_set == false && (!state.count || state.last_bit_set == true));
-	state.one_count += bit_info.valid_count;
-	D_ASSERT(bit_info.valid_count <= 8);
-	state.zero_count += 8 - bit_info.valid_count;
-	state.last_bit_set = bit_info.last_bit_set;
-	state.count += 8;
-}
-
-static inline void HandleBit(RoaringAnalyzeState &state, bool bit_set) {
-	if (!bit_set && (state.count == 0 || state.last_bit_set == true)) {
-		state.run_count++;
-	}
-	state.one_count += bit_set;
-	state.zero_count += !bit_set;
-	state.last_bit_set = bit_set;
-	state.count++;
-}
-
-void RoaringAnalyzeState::HandleRaggedByte(RoaringAnalyzeState &state, uint8_t array_index, idx_t relevant_bits) {
-	D_ASSERT(relevant_bits <= 8);
-	for (idx_t i = 0; i < relevant_bits; i++) {
-		const bool bit_set = array_index & (1 << i);
-		HandleBit(state, bit_set);
-	}
-}
-
-void RoaringAnalyzeState::HandleAllValid(RoaringAnalyzeState &state, idx_t amount) {
-	state.one_count += amount;
-	state.last_bit_set = true;
-	state.count += amount;
-}
-
-void RoaringAnalyzeState::HandleNoneValid(RoaringAnalyzeState &state, idx_t amount) {
-	if (!state.count || (state.last_bit_set != false)) {
-		state.run_count++;
-	}
-	state.zero_count += amount;
-	state.last_bit_set = false;
-	state.count += amount;
-}
-
-idx_t RoaringAnalyzeState::Count(RoaringAnalyzeState &state) {
-	return state.count;
-}
-
-void RoaringAnalyzeState::Flush(RoaringAnalyzeState &state) {
-	state.FlushContainer();
-}
-
-bool RoaringAnalyzeState::HasEnoughSpaceInSegment(idx_t required_space) {
-	D_ASSERT(space_used <= info.GetBlockSize());
-	idx_t remaining_space = info.GetBlockSize() - space_used;
-	if (required_space > remaining_space) {
-		return false;
-	}
-	return true;
-}
-
-void RoaringAnalyzeState::FlushSegment() {
-	if (!current_count) {
-		D_ASSERT(!space_used);
-		return;
-	}
-	metadata_collection.FlushSegment();
-	total_size += space_used;
-	space_used = 0;
-	current_count = 0;
-	segment_count++;
-}
-
-ContainerMetadata RoaringAnalyzeState::GetResult() {
-	return ContainerMetadata::CreateMetadata(count, zero_count, one_count, run_count);
-}
-
-void RoaringAnalyzeState::FlushContainer() {
-	if (!count) {
-		return;
-	}
-	auto metadata = GetResult();
-	idx_t runs_count = metadata_collection.GetRunContainerCount();
-	idx_t arrays_count = metadata_collection.GetArrayAndBitsetContainerCount();
-
-	if (metadata.IsRun()) {
-		runs_count++;
-	} else {
-		arrays_count++;
-	}
-
-	idx_t required_space = metadata_collection.GetMetadataSize(runs_count + arrays_count, runs_count, arrays_count);
-
-	required_space += metadata.GetDataSizeInBytes(count);
-	if (!HasEnoughSpaceInSegment(required_space)) {
-		FlushSegment();
-	}
-	container_metadata.push_back(metadata);
-	metadata_collection.AddMetadata(metadata);
-	space_used += required_space;
-	current_count += count;
-
-	// Reset the container analyze state
-	one_count = 0;
-	zero_count = 0;
-	run_count = 0;
-	last_bit_set = false;
-	count = 0;
-}
-
-void RoaringAnalyzeState::Analyze(Vector &input, idx_t count) {
-	auto &self = *this;
-
-	RoaringStateAppender<RoaringAnalyzeState>::AppendVector(self, input, count);
-	total_count += count;
-}
-
-} // namespace roaring
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/roaring/common.cpp b/src/duckdb/src/storage/compression/roaring/common.cpp
deleted file mode 100644
index e5dad7503..000000000
--- a/src/duckdb/src/storage/compression/roaring/common.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-#include "duckdb/storage/compression/roaring/roaring.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/bitpacking.hpp"
-
-/*
-Data layout per segment:
-
-                Offsets
-+--------------------------------------+
-|   +------------------------------+   |
-|   |   uint64_t metadata_offset   |   |
-|   +------------------------------+   |
-+--------------------------------------+
-
-                [Container Data]+
-+------------------------------------------------------+
-|              Uncompressed Array Container            |
-|   +----------------------------------------------+   |
-|   |   uint16_t values[]                          |   |
-|   +----------------------------------------------+   |
-|                                                      |
-|               Compressed Array Container             |
-|   +----------------------------------------------+   |
-|   |   uint8_t counts[COMPRESSED_SEGMENT_COUNT]   |   |
-|   |   uint8_t values[]                           |   |
-|   +----------------------------------------------+   |
-+------------------------------------------------------+
-|                    Bitset Container                  |
-|   +----------------------------------------------+   |
-|   |   uint32_t page_offset[]                     |   |
-|   |   uint64_t uncompressed_size[]               |   |
-|   |   uint64_t compressed_size[]                 |   |
-|   +----------------------------------------------+   |
-|                                                      |
-+------------------------------------------------------+
-|               Uncompressed Run Container             |
-|   +----------------------------------------------+   |
-|   |   (uint16_t, uint16_t) runs[]                |   |
-|   +----------------------------------------------+   |
-|                                                      |
-|                Compressed Run Container              |
-|   +----------------------------------------------+   |
-|   |   uint8_t counts[COMPRESSED_SEGMENT_COUNT]   |   |
-|   |   (uint8_t, uint8_t) runs[]                  |   |
-|   +----------------------------------------------+   |
-+------------------------------------------------------+
-
-              Container Metadata
-+--------------------------------------------+
-|             Container Types                |
-|   +------------------------------------+   |
-|   |   uint8_t:1 is_run                 |   |
-|   |   uint8_t:1 is_inverted            |   |
-|   +------------------------------------+   |
-|                                            |
-|            Run Container Sizes             |
-|   +------------------------------------+   |
-|   |   uint8_t:7 size                   |   |
-|   +------------------------------------+   |
-|                                            |
-|        Array/Bitset Container Sizes        |
-|   +------------------------------------+   |
-|   |   uint8_t:8 size                   |   |
-|   +------------------------------------+   |
-+--------------------------------------------+
-*/
-
-namespace duckdb {
-
-namespace roaring {
-
-// Set all the bits from start (inclusive) to end (exclusive) to 0
-void SetInvalidRange(ValidityMask &result, idx_t start, idx_t end) {
-	if (end <= start) {
-		throw InternalException("SetInvalidRange called with end (%d) <= start (%d)", end, start);
-	}
-	result.EnsureWritable();
-	auto result_data = (validity_t *)result.GetData();
-
-#ifdef DEBUG
-	ValidityMask copy_for_verification(result.Capacity());
-	copy_for_verification.EnsureWritable();
-	for (idx_t i = 0;
-	     i < AlignValue<idx_t, ValidityMask::BITS_PER_VALUE>(result.Capacity()) / ValidityMask::BITS_PER_VALUE; i++) {
-		copy_for_verification.GetData()[i] = result.GetData()[i];
-	}
-#endif
-	idx_t index = start;
-
-	if ((index % ValidityMask::BITS_PER_VALUE) != 0) {
-		// Adjust the high bits of the first entry
-
-		// +======================================+
-		// |xxxxxxxxxxxxxxxxxxxxxxxxx|            |
-		// +======================================+
-		//
-		// 'x': bits to set to 0 in the result
-
-		idx_t right_bits = index % ValidityMask::BITS_PER_VALUE;
-		idx_t bits_to_set = ValidityMask::BITS_PER_VALUE - right_bits;
-		idx_t left_bits = 0;
-		if (index + bits_to_set > end) {
-			// Limit the amount of bits to set
-			left_bits = (index + bits_to_set) - end;
-			bits_to_set = end - index;
-		}
-
-		// Prepare the mask
-		validity_t mask = ValidityUncompressed::LOWER_MASKS[right_bits];
-		if (left_bits) {
-			// Mask off the part that we don't want to touch (if the range doesn't fully cover the bits)
-			mask |= ValidityUncompressed::UPPER_MASKS[left_bits];
-		}
-
-		idx_t entry_idx = index / ValidityMask::BITS_PER_VALUE;
-		index += bits_to_set;
-		result_data[entry_idx] &= mask;
-	}
-
-	idx_t remaining_bits = end - index;
-	idx_t full_entries = remaining_bits / ValidityMask::BITS_PER_VALUE;
-	idx_t entry_idx = index / ValidityMask::BITS_PER_VALUE;
-	// Set all the entries that are fully covered by the range to 0
-	for (idx_t i = 0; i < full_entries; i++) {
-		result_data[entry_idx + i] = (validity_t)0;
-	}
-
-	if ((remaining_bits % ValidityMask::BITS_PER_VALUE) != 0) {
-		// The last entry touched by the range is only partially covered
-
-		// +======================================+
-		// |                         |xxxxxxxxxxxx|
-		// +======================================+
-		//
-		// 'x': bits to set to 0 in the result
-
-		idx_t bits_to_set = end % ValidityMask::BITS_PER_VALUE;
-		idx_t left_bits = ValidityMask::BITS_PER_VALUE - bits_to_set;
-		validity_t mask = ValidityUncompressed::UPPER_MASKS[left_bits];
-		idx_t entry_idx = end / ValidityMask::BITS_PER_VALUE;
-		result_data[entry_idx] &= mask;
-	}
-
-#ifdef DEBUG
-	D_ASSERT(end <= result.Capacity());
-	for (idx_t i = 0; i < result.Capacity(); i++) {
-		if (i >= start && i < end) {
-			D_ASSERT(!result.RowIsValidUnsafe(i));
-		} else {
-			// Ensure no others bits are touched by this method
-			D_ASSERT(copy_for_verification.RowIsValidUnsafe(i) == result.RowIsValidUnsafe(i));
-		}
-	}
-#endif
-}
-
-unique_ptr<AnalyzeState> RoaringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	auto state = make_uniq<RoaringAnalyzeState>(info);
-
-	return std::move(state);
-}
-
-bool RoaringAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = state.Cast<RoaringAnalyzeState>();
-	analyze_state.Analyze(input, count);
-	return true;
-}
-
-idx_t RoaringFinalAnalyze(AnalyzeState &state) {
-	auto &roaring_state = state.Cast<RoaringAnalyzeState>();
-	roaring_state.FlushContainer();
-	roaring_state.FlushSegment();
-
-	constexpr const double ROARING_COMPRESS_PENALTY = 2.0;
-	return LossyNumericCast<idx_t>((double)roaring_state.total_size * ROARING_COMPRESS_PENALTY);
-}
-
-unique_ptr<CompressionState> RoaringInitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                    unique_ptr<AnalyzeState> state) {
-	return make_uniq<RoaringCompressState>(checkpoint_data, std::move(state));
-}
-
-void RoaringCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = state_p.Cast<RoaringCompressState>();
-	state.Compress(scan_vector, count);
-}
-
-void RoaringFinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<RoaringCompressState>();
-	state.Finalize();
-}
-
-unique_ptr<SegmentScanState> RoaringInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<RoaringScanState>(segment);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void RoaringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                        idx_t result_offset) {
-	auto &scan_state = state.scan_state->Cast<RoaringScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	scan_state.ScanPartial(start, result, result_offset, scan_count);
-}
-
-void RoaringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	RoaringScanPartial(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void RoaringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	RoaringScanState scan_state(segment);
-
-	idx_t internal_offset;
-	idx_t container_idx = scan_state.GetContainerIndex(static_cast<idx_t>(row_id), internal_offset);
-	auto &container_state = scan_state.LoadContainer(container_idx, internal_offset);
-
-	scan_state.ScanInternal(container_state, 1, result, result_idx);
-}
-
-void RoaringSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	// NO OP
-	// We skip inside scan instead, if the container boundary gets crossed we can avoid a bunch of work anyways
-	return;
-}
-
-unique_ptr<CompressedSegmentState> RoaringInitSegment(ColumnSegment &segment, block_id_t block_id,
-                                                      optional_ptr<ColumnSegmentState> segment_state) {
-	// 'ValidityInitSegment' is used normally, which memsets the page to all bits set.
-	return nullptr;
-}
-
-} // namespace roaring
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction GetCompressionFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_ROARING, data_type, roaring::RoaringInitAnalyze,
-	                           roaring::RoaringAnalyze, roaring::RoaringFinalAnalyze, roaring::RoaringInitCompression,
-	                           roaring::RoaringCompress, roaring::RoaringFinalizeCompress, roaring::RoaringInitScan,
-	                           roaring::RoaringScan, roaring::RoaringScanPartial, roaring::RoaringFetchRow,
-	                           roaring::RoaringSkip, roaring::RoaringInitSegment);
-}
-
-CompressionFunction RoaringCompressionFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return GetCompressionFunction(type);
-	default:
-		throw InternalException("Unsupported type for Roaring");
-	}
-}
-
-bool RoaringCompressionFun::TypeIsSupported(const PhysicalType physical_type) {
-	switch (physical_type) {
-	case PhysicalType::BIT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/roaring/compress.cpp b/src/duckdb/src/storage/compression/roaring/compress.cpp
deleted file mode 100644
index 77463d9e2..000000000
--- a/src/duckdb/src/storage/compression/roaring/compress.cpp
+++ /dev/null
@@ -1,478 +0,0 @@
-#include "duckdb/storage/compression/roaring/roaring.hpp"
-#include "duckdb/storage/compression/roaring/appender.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/bitpacking.hpp"
-
-namespace duckdb {
-
-namespace roaring {
-
-ContainerCompressionState::ContainerCompressionState() {
-	Reset();
-}
-
-inline void AppendBitset(ContainerCompressionState &state, bool null, uint16_t amount) {
-	D_ASSERT(state.uncompressed);
-	if (null) {
-		ValidityMask mask(state.uncompressed, ROARING_CONTAINER_SIZE);
-		SetInvalidRange(mask, state.appended_count, state.appended_count + amount);
-	}
-}
-
-inline void AppendRun(ContainerCompressionState &state, bool null, uint16_t amount) {
-	// Adjust the run
-	auto run_idx = state.run_idx;
-	auto appended_count = state.appended_count;
-	if (!null && run_idx < MAX_RUN_IDX && appended_count && (null != state.last_is_null)) {
-		if (run_idx < COMPRESSED_RUN_THRESHOLD) {
-			auto &last_run = state.runs[run_idx];
-			// End the last run
-			last_run.length = (appended_count - last_run.start) - 1;
-		}
-		state.compressed_runs[(run_idx * 2) + 1] = static_cast<uint8_t>(appended_count & (COMPRESSED_SEGMENT_SIZE - 1));
-		state.run_counts[appended_count >> COMPRESSED_SEGMENT_SHIFT_AMOUNT]++;
-		state.run_idx++;
-	} else if (null && run_idx < MAX_RUN_IDX && (!appended_count || null != state.last_is_null)) {
-		if (run_idx < COMPRESSED_RUN_THRESHOLD) {
-			auto &current_run = state.runs[run_idx];
-			// Initialize a new run
-			current_run.start = appended_count;
-		}
-		state.compressed_runs[(run_idx * 2) + 0] = static_cast<uint8_t>(appended_count & (COMPRESSED_SEGMENT_SIZE - 1));
-		state.run_counts[appended_count >> COMPRESSED_SEGMENT_SHIFT_AMOUNT]++;
-	}
-}
-
-template <bool INVERTED>
-inline void AppendToArray(ContainerCompressionState &state, bool null, uint16_t amount) {
-	if (DUCKDB_LIKELY(INVERTED != null)) {
-		return;
-	}
-
-	auto current_array_idx = state.array_idx[null];
-	if (current_array_idx + amount > MAX_ARRAY_IDX) {
-		return;
-	}
-	auto appended_count = state.appended_count;
-	auto array_count = state.array_counts[null];
-	auto compressed_array = state.compressed_arrays[null];
-	uint16_t appended = 0;
-	while (appended < amount) {
-		uint16_t remaining = amount - appended;
-		uint8_t segment_offset = appended ? 0 : (appended_count + appended) & (COMPRESSED_SEGMENT_SIZE - 1);
-		uint8_t to_append =
-		    static_cast<uint8_t>(MinValue<uint16_t>(remaining, COMPRESSED_SEGMENT_SIZE - segment_offset));
-		for (uint8_t i = 0; i < to_append; i++) {
-			auto index = current_array_idx + appended + i;
-			compressed_array[index] = segment_offset + i;
-		}
-
-		idx_t segment_index = (appended_count + appended) / COMPRESSED_SEGMENT_SIZE;
-		array_count[segment_index] += to_append;
-		appended += to_append;
-	}
-
-	if (current_array_idx + amount < COMPRESSED_ARRAY_THRESHOLD) {
-		auto &array = state.arrays[null];
-		for (uint16_t i = 0; i < amount; i++) {
-			array[current_array_idx + i] = appended_count + i;
-		}
-	}
-	state.array_idx[null] += amount;
-}
-
-void ContainerCompressionState::Append(bool null, uint16_t amount) {
-	append_function(*this, null, amount);
-	last_is_null = null;
-	null_count += null * amount;
-	appended_count += amount;
-}
-
-void ContainerCompressionState::OverrideArray(data_ptr_t destination, bool nulls, idx_t count) {
-	if (nulls) {
-		append_function = AppendToArray<true>;
-	} else {
-		append_function = AppendToArray<false>;
-	}
-
-	if (count >= COMPRESSED_ARRAY_THRESHOLD) {
-		memset(destination, 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT);
-		array_counts[nulls] = reinterpret_cast<uint8_t *>(destination);
-		destination += sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT;
-		compressed_arrays[nulls] = reinterpret_cast<uint8_t *>(destination);
-	} else {
-		arrays[nulls] = reinterpret_cast<uint16_t *>(destination);
-	}
-}
-
-void ContainerCompressionState::OverrideRun(data_ptr_t destination, idx_t count) {
-	append_function = AppendRun;
-
-	if (count >= COMPRESSED_RUN_THRESHOLD) {
-		memset(destination, 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT);
-		run_counts = reinterpret_cast<uint8_t *>(destination);
-		destination += sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT;
-		compressed_runs = reinterpret_cast<uint8_t *>(destination);
-	} else {
-		runs = reinterpret_cast<RunContainerRLEPair *>(destination);
-	}
-}
-
-void ContainerCompressionState::OverrideUncompressed(data_ptr_t destination) {
-	append_function = AppendBitset;
-	uncompressed = reinterpret_cast<validity_t *>(destination);
-}
-
-void ContainerCompressionState::Finalize() {
-	D_ASSERT(!finalized);
-	if (appended_count && last_is_null && run_idx < MAX_RUN_IDX) {
-		if (run_idx < COMPRESSED_RUN_THRESHOLD) {
-			auto &last_run = runs[run_idx];
-			// End the last run
-			last_run.length = (appended_count - last_run.start);
-		}
-		compressed_runs[(run_idx * 2) + 1] = static_cast<uint8_t>(appended_count % COMPRESSED_SEGMENT_SIZE);
-		if (appended_count != ROARING_CONTAINER_SIZE) {
-			run_counts[appended_count >> COMPRESSED_SEGMENT_SHIFT_AMOUNT]++;
-		}
-		run_idx++;
-	}
-	finalized = true;
-}
-
-ContainerMetadata ContainerCompressionState::GetResult() {
-	if (uncompressed) {
-		return ContainerMetadata::BitsetContainer(appended_count);
-	}
-	D_ASSERT(finalized);
-	return ContainerMetadata::CreateMetadata(appended_count, array_idx[NULLS], array_idx[NON_NULLS], run_idx);
-}
-
-void ContainerCompressionState::Reset() {
-	length = 0;
-
-	appended_count = 0;
-	null_count = 0;
-	run_idx = 0;
-	array_idx[NON_NULLS] = 0;
-	array_idx[NULLS] = 0;
-	finalized = false;
-	last_is_null = false;
-
-	// Reset the arrays + runs
-	arrays[NULLS] = base_arrays[NULLS];
-	arrays[NON_NULLS] = base_arrays[NON_NULLS];
-	runs = base_runs;
-
-	compressed_arrays[NULLS] = base_compressed_arrays[NULLS];
-	compressed_arrays[NON_NULLS] = base_compressed_arrays[NON_NULLS];
-	compressed_runs = base_compressed_runs;
-
-	array_counts[NULLS] = base_array_counts[NULLS];
-	array_counts[NON_NULLS] = base_array_counts[NON_NULLS];
-	run_counts = base_run_counts;
-
-	memset(array_counts[NULLS], 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT);
-	memset(array_counts[NON_NULLS], 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT);
-	memset(run_counts, 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT);
-	uncompressed = nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-RoaringCompressState::RoaringCompressState(ColumnDataCheckpointData &checkpoint_data,
-                                           unique_ptr<AnalyzeState> analyze_state_p)
-    : CompressionState(analyze_state_p->info), owned_analyze_state(std::move(analyze_state_p)),
-      analyze_state(owned_analyze_state->Cast<RoaringAnalyzeState>()), container_state(),
-      container_metadata(analyze_state.container_metadata), checkpoint_data(checkpoint_data),
-      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ROARING)) {
-	CreateEmptySegment(checkpoint_data.GetRowGroup().start);
-	total_count = 0;
-	InitializeContainer();
-}
-
-idx_t RoaringCompressState::GetContainerIndex() {
-	idx_t index = total_count / ROARING_CONTAINER_SIZE;
-	return index;
-}
-
-idx_t RoaringCompressState::GetRemainingSpace() {
-	return static_cast<idx_t>(metadata_ptr - data_ptr);
-}
-
-bool RoaringCompressState::CanStore(idx_t container_size, const ContainerMetadata &metadata) {
-	idx_t required_space = 0;
-	if (metadata.IsUncompressed()) {
-		// Account for the alignment we might need for this container
-		required_space += (AlignValue<idx_t>(reinterpret_cast<idx_t>(data_ptr))) - reinterpret_cast<idx_t>(data_ptr);
-	}
-	required_space += metadata.GetDataSizeInBytes(container_size);
-
-	idx_t runs_count = metadata_collection.GetRunContainerCount();
-	idx_t arrays_count = metadata_collection.GetArrayAndBitsetContainerCount();
-#ifdef DEBUG
-	idx_t current_size = metadata_collection.GetMetadataSize(runs_count + arrays_count, runs_count, arrays_count);
-	(void)current_size;
-	D_ASSERT(required_space + current_size <= GetRemainingSpace());
-#endif
-	if (metadata.IsRun()) {
-		runs_count++;
-	} else {
-		arrays_count++;
-	}
-	idx_t metadata_size = metadata_collection.GetMetadataSize(runs_count + arrays_count, runs_count, arrays_count);
-	required_space += metadata_size;
-
-	if (required_space > GetRemainingSpace()) {
-		return false;
-	}
-	return true;
-}
-
-void RoaringCompressState::InitializeContainer() {
-	if (total_count == analyze_state.total_count) {
-		// No more containers left
-		return;
-	}
-	auto container_index = GetContainerIndex();
-	D_ASSERT(container_index < container_metadata.size());
-	auto metadata = container_metadata[container_index];
-
-	idx_t container_size = AlignValue<idx_t, ValidityMask::BITS_PER_VALUE>(
-	    MinValue<idx_t>(analyze_state.total_count - container_state.appended_count, ROARING_CONTAINER_SIZE));
-	if (!CanStore(container_size, metadata)) {
-		idx_t row_start = current_segment->start + current_segment->count;
-		FlushSegment();
-		CreateEmptySegment(row_start);
-	}
-
-	// Override the pointer to write directly into the block
-	if (metadata.IsUncompressed()) {
-		data_ptr = reinterpret_cast<data_ptr_t>(AlignValue<idx_t>(reinterpret_cast<idx_t>(data_ptr)));
-		FastMemset(data_ptr, ~0, sizeof(validity_t) * (container_size / ValidityMask::BITS_PER_VALUE));
-		container_state.OverrideUncompressed(data_ptr);
-	} else if (metadata.IsRun()) {
-		auto number_of_runs = metadata.NumberOfRuns();
-		container_state.OverrideRun(data_ptr, number_of_runs);
-	} else {
-		auto cardinality = metadata.Cardinality();
-		container_state.OverrideArray(data_ptr, metadata.IsInverted(), cardinality);
-	}
-	data_ptr += metadata.GetDataSizeInBytes(container_size);
-	metadata_collection.AddMetadata(metadata);
-}
-
-void RoaringCompressState::CreateEmptySegment(idx_t row_start) {
-	auto &db = checkpoint_data.GetDatabase();
-	auto &type = checkpoint_data.GetType();
-
-	auto compressed_segment =
-	    ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize());
-	current_segment = std::move(compressed_segment);
-
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	handle = buffer_manager.Pin(current_segment->block);
-	data_ptr = handle.Ptr();
-	data_ptr += sizeof(idx_t);
-	metadata_ptr = handle.Ptr() + info.GetBlockSize();
-}
-
-void RoaringCompressState::FlushSegment() {
-	auto &state = checkpoint_data.GetCheckpointState();
-	auto base_ptr = handle.Ptr();
-	// +======================================+
-	// |x|ddddddddddddddd||mmm|               |
-	// +======================================+
-
-	// x: metadata_offset (to the "right" of it)
-	// d: data of the containers
-	// m: metadata of the containers
-
-	// This is after 'x'
-	base_ptr += sizeof(idx_t);
-
-	// Size of the 'd' part
-	idx_t data_size = NumericCast<idx_t>(data_ptr - base_ptr);
-	data_size = AlignValue(data_size);
-
-	// Size of the 'm' part
-	idx_t metadata_size = metadata_collection.GetMetadataSizeForSegment();
-
-	if (current_segment->count.load() == 0) {
-		D_ASSERT(metadata_size == 0);
-		return;
-	}
-
-	idx_t serialized_metadata_size = metadata_collection.Serialize(data_ptr);
-	metadata_collection.FlushSegment();
-	(void)serialized_metadata_size;
-	D_ASSERT(metadata_size == serialized_metadata_size);
-	idx_t metadata_start = static_cast<idx_t>(data_ptr - base_ptr);
-	Store<idx_t>(metadata_start, handle.Ptr());
-	idx_t total_segment_size = sizeof(idx_t) + data_size + metadata_size;
-	state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size);
-}
-
-void RoaringCompressState::Finalize() {
-	FlushContainer();
-	FlushSegment();
-	current_segment.reset();
-}
-
-void RoaringCompressState::FlushContainer() {
-	if (container_state.length) {
-		container_state.Append(!container_state.last_bit_set, container_state.length);
-		container_state.length = 0;
-	}
-
-	if (!container_state.appended_count) {
-		return;
-	}
-	container_state.Finalize();
-#ifdef DEBUG
-	auto container_index = GetContainerIndex();
-	auto metadata = container_metadata[container_index];
-
-	idx_t container_size = container_state.appended_count;
-	if (!metadata.IsUncompressed()) {
-		unique_ptr<ContainerScanState> scan_state;
-		if (metadata.IsRun()) {
-			D_ASSERT(metadata.IsInverted());
-			auto number_of_runs = metadata.NumberOfRuns();
-			if (number_of_runs >= COMPRESSED_RUN_THRESHOLD) {
-				auto segments = container_state.run_counts;
-				auto data_ptr = container_state.compressed_runs;
-				scan_state = make_uniq<CompressedRunContainerScanState>(container_index, container_size, number_of_runs,
-				                                                        segments, data_ptr);
-			} else {
-				auto data_ptr = reinterpret_cast<data_ptr_t>(container_state.runs);
-				scan_state =
-				    make_uniq<RunContainerScanState>(container_index, container_size, number_of_runs, data_ptr);
-			}
-		} else {
-			auto cardinality = metadata.Cardinality();
-			if (cardinality >= COMPRESSED_ARRAY_THRESHOLD) {
-				if (metadata.IsInverted()) {
-					auto segments = reinterpret_cast<data_ptr_t>(container_state.array_counts[NULLS]);
-					auto data_ptr = reinterpret_cast<data_ptr_t>(container_state.compressed_arrays[NULLS]);
-					scan_state = make_uniq<CompressedArrayContainerScanState<NULLS>>(container_index, container_size,
-					                                                                 cardinality, segments, data_ptr);
-				} else {
-					auto segments = reinterpret_cast<data_ptr_t>(container_state.array_counts[NON_NULLS]);
-					auto data_ptr = reinterpret_cast<data_ptr_t>(container_state.compressed_arrays[NON_NULLS]);
-					scan_state = make_uniq<CompressedArrayContainerScanState<NON_NULLS>>(
-					    container_index, container_size, cardinality, segments, data_ptr);
-				}
-			} else {
-				if (metadata.IsInverted()) {
-					auto data_ptr = reinterpret_cast<data_ptr_t>(container_state.arrays[NULLS]);
-					scan_state = make_uniq<ArrayContainerScanState<NULLS>>(container_index, container_size, cardinality,
-					                                                       data_ptr);
-				} else {
-					auto data_ptr = reinterpret_cast<data_ptr_t>(container_state.arrays[NON_NULLS]);
-					scan_state = make_uniq<ArrayContainerScanState<NON_NULLS>>(container_index, container_size,
-					                                                           cardinality, data_ptr);
-				}
-			}
-		}
-		scan_state->Verify();
-	}
-
-#endif
-	total_count += container_state.appended_count;
-	bool has_nulls = container_state.null_count != 0;
-	bool has_non_nulls = container_state.null_count != container_state.appended_count;
-	if (has_nulls || container_state.uncompressed) {
-		current_segment->stats.statistics.SetHasNullFast();
-	}
-	if (has_non_nulls || container_state.uncompressed) {
-		current_segment->stats.statistics.SetHasNoNullFast();
-	}
-	current_segment->count += container_state.appended_count;
-	container_state.Reset();
-}
-
-void RoaringCompressState::NextContainer() {
-	FlushContainer();
-	InitializeContainer();
-}
-
-void RoaringCompressState::HandleByte(RoaringCompressState &state, uint8_t array_index) {
-	if (array_index == NumericLimits<uint8_t>::Maximum()) {
-		HandleAllValid(state, 8);
-	} else if (array_index == 0) {
-		HandleNoneValid(state, 8);
-	} else {
-		HandleRaggedByte(state, array_index, 8);
-	}
-}
-
-static inline void HandleBit(RoaringCompressState &state, bool bit_set) {
-	auto &container_state = state.container_state;
-	if (container_state.length && container_state.last_bit_set != bit_set) {
-		container_state.Append(!container_state.last_bit_set, container_state.length);
-		container_state.length = 0;
-	}
-	container_state.length += 1;
-	container_state.last_bit_set = bit_set;
-}
-
-void RoaringCompressState::HandleRaggedByte(RoaringCompressState &state, uint8_t array_index, idx_t relevant_bits) {
-	D_ASSERT(relevant_bits <= 8);
-	for (idx_t i = 0; i < relevant_bits; i++) {
-		const bool bit_set = array_index & (1 << i);
-		HandleBit(state, bit_set);
-	}
-}
-
-void RoaringCompressState::HandleAllValid(RoaringCompressState &state, idx_t amount) {
-	auto &container_state = state.container_state;
-	if (container_state.length && container_state.last_bit_set == false) {
-		container_state.Append(!container_state.last_bit_set, container_state.length);
-		container_state.length = 0;
-	}
-	container_state.length += amount;
-	container_state.last_bit_set = true;
-}
-
-void RoaringCompressState::HandleNoneValid(RoaringCompressState &state, idx_t amount) {
-	auto &container_state = state.container_state;
-	if (container_state.length && container_state.last_bit_set == true) {
-		container_state.Append(!container_state.last_bit_set, container_state.length);
-		container_state.length = 0;
-	}
-	container_state.length += amount;
-	container_state.last_bit_set = false;
-}
-
-idx_t RoaringCompressState::Count(RoaringCompressState &state) {
-	auto &container_state = state.container_state;
-	// How much is appended and waiting to be appended
-	return container_state.appended_count + container_state.length;
-}
-
-void RoaringCompressState::Flush(RoaringCompressState &state) {
-	state.NextContainer();
-}
-
-void RoaringCompressState::Compress(Vector &input, idx_t count) {
-	auto &self = *this;
-	RoaringStateAppender<RoaringCompressState>::AppendVector(self, input, count);
-}
-
-} // namespace roaring
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/roaring/metadata.cpp b/src/duckdb/src/storage/compression/roaring/metadata.cpp
deleted file mode 100644
index 9322f5a34..000000000
--- a/src/duckdb/src/storage/compression/roaring/metadata.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-#include "duckdb/storage/compression/roaring/roaring.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/bitpacking.hpp"
-
-namespace duckdb {
-
-namespace roaring {
-
-ContainerMetadata ContainerMetadata::CreateMetadata(uint16_t count, uint16_t array_null, uint16_t array_non_null,
-                                                    uint16_t runs) {
-	const bool can_use_null_array = array_null < MAX_ARRAY_IDX;
-	const bool can_use_non_null_array = array_non_null < MAX_ARRAY_IDX;
-
-	const bool can_use_run = runs < MAX_RUN_IDX;
-
-	const bool can_use_array = can_use_null_array || can_use_non_null_array;
-	if (!can_use_array && !can_use_run) {
-		// Can not efficiently encode at all, write it as bitset
-		return ContainerMetadata::BitsetContainer(count);
-	}
-	uint16_t null_array_cost = array_null < COMPRESSED_ARRAY_THRESHOLD
-	                               ? array_null * sizeof(uint16_t)
-	                               : COMPRESSED_SEGMENT_COUNT + (array_null * sizeof(uint8_t));
-	uint16_t non_null_array_cost = array_non_null < COMPRESSED_ARRAY_THRESHOLD
-	                                   ? array_non_null * sizeof(uint16_t)
-	                                   : COMPRESSED_SEGMENT_COUNT + (array_non_null * sizeof(uint8_t));
-
-	uint16_t lowest_array_cost = MinValue<uint16_t>(null_array_cost, non_null_array_cost);
-	uint16_t lowest_run_cost = runs < COMPRESSED_RUN_THRESHOLD ? runs * sizeof(uint32_t)
-	                                                           : COMPRESSED_SEGMENT_COUNT + (runs * sizeof(uint16_t));
-	uint16_t bitset_cost =
-	    (AlignValue<uint16_t, ValidityMask::BITS_PER_VALUE>(count) / ValidityMask::BITS_PER_VALUE) * sizeof(validity_t);
-	if (MinValue<uint16_t>(lowest_array_cost, lowest_run_cost) > bitset_cost) {
-		// The amount of values is too small, better off using bitset
-		// we can detect this at decompression because we know how many values are left
-		return ContainerMetadata::BitsetContainer(count);
-	}
-
-	if (lowest_array_cost <= lowest_run_cost) {
-		if (array_null <= array_non_null) {
-			return ContainerMetadata::ArrayContainer(array_null, NULLS);
-		} else {
-			return ContainerMetadata::ArrayContainer(array_non_null, NON_NULLS);
-		}
-	} else {
-		return ContainerMetadata::RunContainer(runs);
-	}
-}
-
-idx_t ContainerMetadata::GetDataSizeInBytes(idx_t container_size) const {
-	if (IsUncompressed()) {
-		return (container_size / ValidityMask::BITS_PER_VALUE) * sizeof(validity_t);
-	}
-	if (IsRun()) {
-		auto number_of_runs = NumberOfRuns();
-		if (number_of_runs >= COMPRESSED_RUN_THRESHOLD) {
-			return COMPRESSED_SEGMENT_COUNT + (sizeof(uint8_t) * number_of_runs * 2);
-		} else {
-			return sizeof(RunContainerRLEPair) * number_of_runs;
-		}
-	} else {
-		auto cardinality = Cardinality();
-		if (cardinality >= COMPRESSED_ARRAY_THRESHOLD) {
-			return COMPRESSED_SEGMENT_COUNT + (sizeof(uint8_t) * cardinality);
-		} else {
-			return sizeof(uint16_t) * cardinality;
-		}
-	}
-}
-
-ContainerMetadataCollection::ContainerMetadataCollection() {
-}
-
-void ContainerMetadataCollection::AddMetadata(ContainerMetadata metadata) {
-	if (metadata.IsRun()) {
-		AddRunContainer(metadata.NumberOfRuns(), metadata.IsInverted());
-	} else if (metadata.IsUncompressed()) {
-		AddBitsetContainer();
-	} else {
-		AddArrayContainer(metadata.Cardinality(), metadata.IsInverted());
-	}
-}
-
-idx_t ContainerMetadataCollection::GetMetadataSizeForSegment() const {
-	idx_t runs_count = GetRunContainerCount();
-	idx_t arrays_count = GetArrayAndBitsetContainerCount();
-	return GetMetadataSize(runs_count + arrays_count, runs_count, arrays_count);
-}
-
-idx_t ContainerMetadataCollection::GetMetadataSize(idx_t container_count, idx_t run_containers,
-                                                   idx_t array_containers) const {
-	idx_t types_size = BitpackingPrimitives::GetRequiredSize(container_count, CONTAINER_TYPE_BITWIDTH);
-	idx_t runs_size = BitpackingPrimitives::GetRequiredSize(run_containers, RUN_CONTAINER_SIZE_BITWIDTH);
-	idx_t arrays_size = sizeof(uint8_t) * array_containers;
-	return types_size + runs_size + arrays_size;
-}
-
-idx_t ContainerMetadataCollection::GetRunContainerCount() const {
-	return runs_in_segment;
-}
-idx_t ContainerMetadataCollection::GetArrayAndBitsetContainerCount() const {
-	return arrays_in_segment;
-}
-
-void ContainerMetadataCollection::FlushSegment() {
-	runs_in_segment = 0;
-	count_in_segment = 0;
-	arrays_in_segment = 0;
-}
-
-void ContainerMetadataCollection::Reset() {
-	FlushSegment();
-	container_type.clear();
-	number_of_runs.clear();
-	cardinality.clear();
-}
-
-// Write the metadata for the current segment
-idx_t ContainerMetadataCollection::Serialize(data_ptr_t dest) const {
-	// Element sizes (in bits) for written metadata
-	// +======================================+
-	// |mmmmmm|rrrrrr|aaaaaaa|                |
-	// +======================================+
-	//
-	// m: 2: (1: is_run, 1: is_inverted)
-	// r: 7: number_of_runs
-	// a: 8: cardinality
-
-	idx_t types_size = BitpackingPrimitives::GetRequiredSize(count_in_segment, CONTAINER_TYPE_BITWIDTH);
-	idx_t runs_size = BitpackingPrimitives::GetRequiredSize(runs_in_segment, RUN_CONTAINER_SIZE_BITWIDTH);
-	idx_t arrays_size = sizeof(uint8_t) * arrays_in_segment;
-
-	idx_t types_offset = container_type.size() - count_in_segment;
-	data_ptr_t types_data = (data_ptr_t)(container_type.data()); // NOLINT: c-style cast (for const)
-	BitpackingPrimitives::PackBuffer<uint8_t>(dest, types_data + types_offset, count_in_segment,
-	                                          CONTAINER_TYPE_BITWIDTH);
-	dest += types_size;
-
-	if (!number_of_runs.empty()) {
-		idx_t runs_offset = number_of_runs.size() - runs_in_segment;
-		data_ptr_t run_data = (data_ptr_t)(number_of_runs.data()); // NOLINT: c-style cast (for const)
-		BitpackingPrimitives::PackBuffer<uint8_t>(dest, run_data + runs_offset, runs_in_segment,
-		                                          RUN_CONTAINER_SIZE_BITWIDTH);
-		dest += runs_size;
-	}
-
-	if (!cardinality.empty()) {
-		idx_t arrays_offset = cardinality.size() - arrays_in_segment;
-		data_ptr_t arrays_data = (data_ptr_t)(cardinality.data()); // NOLINT: c-style cast (for const)
-		memcpy(dest, arrays_data + arrays_offset, sizeof(uint8_t) * arrays_in_segment);
-	}
-	return types_size + runs_size + arrays_size;
-}
-
-void ContainerMetadataCollection::Deserialize(data_ptr_t src, idx_t container_count) {
-	container_type.resize(AlignValue<idx_t, BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE>(container_count));
-	count_in_segment = container_count;
-
-	// Load the types of the containers
-	idx_t types_size = BitpackingPrimitives::GetRequiredSize(container_type.size(), 2);
-	BitpackingPrimitives::UnPackBuffer<uint8_t>(container_type.data(), src, container_count, 2, true);
-	src += types_size;
-
-	// Figure out how many are run containers
-	idx_t runs_count = 0;
-	for (idx_t i = 0; i < container_count; i++) {
-		auto type = container_type[i];
-		runs_count += ((type >> 1) & 1) == 1;
-	}
-	runs_in_segment = runs_count;
-	number_of_runs.resize(AlignValue<idx_t, BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE>(runs_count));
-	cardinality.resize(container_count - runs_count);
-
-	// Load the run containers
-	if (runs_count) {
-		idx_t runs_size = BitpackingPrimitives::GetRequiredSize(runs_count, RUN_CONTAINER_SIZE_BITWIDTH);
-		BitpackingPrimitives::UnPackBuffer<uint8_t>(number_of_runs.data(), src, runs_count, RUN_CONTAINER_SIZE_BITWIDTH,
-		                                            true);
-		src += runs_size;
-	}
-
-	// Load the array/bitset containers
-	if (!cardinality.empty()) {
-		idx_t arrays_size = sizeof(uint8_t) * cardinality.size();
-		arrays_in_segment = arrays_size;
-		memcpy(cardinality.data(), src, arrays_size);
-	}
-}
-
-void ContainerMetadataCollection::AddBitsetContainer() {
-	AddContainerType(false, false);
-	cardinality.push_back(BITSET_CONTAINER_SENTINEL_VALUE);
-	arrays_in_segment++;
-	count_in_segment++;
-}
-
-void ContainerMetadataCollection::AddArrayContainer(idx_t amount, bool is_inverted) {
-	AddContainerType(false, is_inverted);
-	D_ASSERT(amount < MAX_ARRAY_IDX);
-	cardinality.push_back(NumericCast<uint8_t>(amount));
-	arrays_in_segment++;
-	count_in_segment++;
-}
-
-void ContainerMetadataCollection::AddRunContainer(idx_t amount, bool is_inverted) {
-	AddContainerType(true, is_inverted);
-	D_ASSERT(amount < MAX_RUN_IDX);
-	number_of_runs.push_back(NumericCast<uint8_t>(amount));
-	runs_in_segment++;
-	count_in_segment++;
-}
-
-void ContainerMetadataCollection::AddContainerType(bool is_run, bool is_inverted) {
-	uint8_t type = 0;
-	if (is_run) {
-		type |= IS_RUN_FLAG;
-	}
-	if (is_inverted) {
-		type |= IS_INVERTED_FLAG;
-	}
-	container_type.push_back(type);
-}
-
-ContainerMetadataCollectionScanner::ContainerMetadataCollectionScanner(ContainerMetadataCollection &collection)
-    : collection(collection) {
-}
-
-ContainerMetadata ContainerMetadataCollectionScanner::GetNext() {
-	D_ASSERT(idx < collection.count_in_segment);
-	auto type = collection.container_type[idx++];
-	const bool is_inverted = (type & 1) == 1;
-	const bool is_run = ((type >> 1) & 1) == 1;
-	uint8_t amount;
-	if (is_run) {
-		amount = collection.number_of_runs[run_idx++];
-	} else {
-		amount = collection.cardinality[array_idx++];
-	}
-	if (is_run) {
-		return ContainerMetadata::RunContainer(amount);
-	}
-	if (amount == BITSET_CONTAINER_SENTINEL_VALUE) {
-		return ContainerMetadata::BitsetContainer(amount);
-	}
-	return ContainerMetadata::ArrayContainer(amount, is_inverted);
-}
-
-} // namespace roaring
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/roaring/scan.cpp b/src/duckdb/src/storage/compression/roaring/scan.cpp
deleted file mode 100644
index 73ef83bfe..000000000
--- a/src/duckdb/src/storage/compression/roaring/scan.cpp
+++ /dev/null
@@ -1,358 +0,0 @@
-#include "duckdb/storage/compression/roaring/roaring.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/likely.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/common/fast_mem.hpp"
-#include "duckdb/common/bitpacking.hpp"
-
-namespace duckdb {
-
-namespace roaring {
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-
-ContainerSegmentScan::ContainerSegmentScan(data_ptr_t data)
-    : segments(reinterpret_cast<uint8_t *>(data)), index(0), count(0) {
-}
-
-// Returns the base of the current segment, forwarding the index if the segment is depleted of values
-uint16_t ContainerSegmentScan::operator++(int) {
-	while (index < COMPRESSED_SEGMENT_COUNT && count >= segments[index]) {
-		count = 0;
-		index++;
-	}
-	count++;
-
-	// index == COMPRESSED_SEGMENT_COUNT is allowed for runs, as the last run could end at ROARING_CONTAINER_SIZE
-	D_ASSERT(index <= COMPRESSED_SEGMENT_COUNT);
-	if (index < COMPRESSED_SEGMENT_COUNT) {
-		D_ASSERT(segments[index] != 0);
-	}
-	uint16_t base = static_cast<uint16_t>(index) * COMPRESSED_SEGMENT_SIZE;
-	return base;
-}
-
-//===--------------------------------------------------------------------===//
-// ContainerScanState
-//===--------------------------------------------------------------------===//
-
-//! RunContainer
-
-RunContainerScanState::RunContainerScanState(idx_t container_index, idx_t container_size, idx_t count,
-                                             data_ptr_t data_p)
-    : ContainerScanState(container_index, container_size), count(count), data(data_p) {
-}
-
-void RunContainerScanState::ScanPartial(Vector &result, idx_t result_offset, idx_t to_scan) {
-	auto &result_mask = FlatVector::Validity(result);
-
-	// This method assumes that the validity mask starts off as having all bits set for the entries that are being
-	// scanned.
-
-	idx_t result_idx = 0;
-	if (!run_index) {
-		LoadNextRun();
-	}
-	while (!finished && result_idx < to_scan) {
-		// Either we are already inside a run, then 'start_of_run' will be scanned_count
-		// or we're skipping values until the run begins
-		auto start_of_run =
-		    MaxValue<idx_t>(MinValue<idx_t>(run.start, scanned_count + to_scan), scanned_count + result_idx);
-		result_idx = start_of_run - scanned_count;
-
-		// How much of the run are we covering?
-		idx_t run_end = run.start + 1 + run.length;
-		auto run_or_scan_end = MinValue<idx_t>(run_end, scanned_count + to_scan);
-
-		// Process the run
-		D_ASSERT(run_or_scan_end >= start_of_run);
-		if (run_or_scan_end > start_of_run) {
-			idx_t amount = run_or_scan_end - start_of_run;
-			idx_t start = result_offset + result_idx;
-			idx_t end = start + amount;
-			SetInvalidRange(result_mask, start, end);
-		}
-
-		result_idx += run_or_scan_end - start_of_run;
-		if (scanned_count + result_idx == run_end) {
-			// Fully processed the current run
-			LoadNextRun();
-		}
-	}
-	scanned_count += to_scan;
-}
-
-void RunContainerScanState::Skip(idx_t to_skip) {
-	idx_t end = scanned_count + to_skip;
-	if (!run_index) {
-		LoadNextRun();
-	}
-	while (scanned_count < end && !finished) {
-		idx_t run_end = run.start + 1 + run.length;
-		scanned_count = MinValue<idx_t>(run_end, end);
-		if (scanned_count == run_end) {
-			LoadNextRun();
-		}
-	}
-	// In case run_index has already reached count
-	scanned_count = end;
-}
-
-void RunContainerScanState::Verify() const {
-#ifdef DEBUG
-	uint16_t index = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto run = reinterpret_cast<RunContainerRLEPair *>(data)[i];
-		D_ASSERT(run.start >= index);
-		index = run.start + 1 + run.length;
-	}
-#endif
-}
-
-void RunContainerScanState::LoadNextRun() {
-	if (run_index >= count) {
-		finished = true;
-		return;
-	}
-	run = reinterpret_cast<RunContainerRLEPair *>(data)[run_index];
-	run_index++;
-}
-
-CompressedRunContainerScanState::CompressedRunContainerScanState(idx_t container_index, idx_t container_size,
-                                                                 idx_t count, data_ptr_t segments, data_ptr_t data)
-    : RunContainerScanState(container_index, container_size, count, data), segments(segments), segment(segments) {
-	D_ASSERT(count >= COMPRESSED_RUN_THRESHOLD);
-	//! Used by Verify, have to use it to avoid a compiler warning/error
-	(void)this->segments;
-}
-
-void CompressedRunContainerScanState::LoadNextRun() {
-	if (run_index >= count) {
-		finished = true;
-		return;
-	}
-	uint16_t start = segment++;
-	start += reinterpret_cast<uint8_t *>(data)[(run_index * 2) + 0];
-
-	uint16_t end = segment++;
-	end += reinterpret_cast<uint8_t *>(data)[(run_index * 2) + 1];
-
-	D_ASSERT(end > start);
-	run = RunContainerRLEPair {start, static_cast<uint16_t>(end - 1 - start)};
-	run_index++;
-}
-
-void CompressedRunContainerScanState::Verify() const {
-#ifdef DEBUG
-	uint16_t index = 0;
-	ContainerSegmentScan verify_segment(segments);
-	for (idx_t i = 0; i < count; i++) {
-		// Get the start index of the run
-		uint16_t start = verify_segment++;
-		start += reinterpret_cast<uint8_t *>(data)[(i * 2) + 0];
-
-		// Get the end index of the run
-		uint16_t end = verify_segment++;
-		end += reinterpret_cast<uint8_t *>(data)[(i * 2) + 1];
-
-		D_ASSERT(!i || start >= index);
-		D_ASSERT(end > start);
-		index = end;
-	}
-#endif
-}
-
-//! BitsetContainer
-
-BitsetContainerScanState::BitsetContainerScanState(idx_t container_index, idx_t count, validity_t *bitset)
-    : ContainerScanState(container_index, count), bitset(bitset) {
-}
-
-void BitsetContainerScanState::ScanPartial(Vector &result, idx_t result_offset, idx_t to_scan) {
-	if (!result_offset && (to_scan % ValidityMask::BITS_PER_VALUE) == 0 &&
-	    (scanned_count % ValidityMask::BITS_PER_VALUE) == 0) {
-		ValidityUncompressed::AlignedScan(reinterpret_cast<data_ptr_t>(bitset), scanned_count, result, to_scan);
-	} else {
-		ValidityUncompressed::UnalignedScan(reinterpret_cast<data_ptr_t>(bitset), container_size, scanned_count, result,
-		                                    result_offset, to_scan);
-	}
-	scanned_count += to_scan;
-}
-
-void BitsetContainerScanState::Skip(idx_t to_skip) {
-	// NO OP: we only need to forward scanned_count
-	scanned_count += to_skip;
-}
-
-void BitsetContainerScanState::Verify() const {
-	// uncompressed, nothing to verify
-	return;
-}
-
-RoaringScanState::RoaringScanState(ColumnSegment &segment) : segment(segment) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	handle = buffer_manager.Pin(segment.block);
-	auto base_ptr = handle.Ptr() + segment.GetBlockOffset();
-	data_ptr = base_ptr + sizeof(idx_t);
-
-	// Deserialize the container metadata for this segment
-	auto metadata_offset = Load<idx_t>(base_ptr);
-	auto metadata_ptr = data_ptr + metadata_offset;
-
-	auto segment_count = segment.count.load();
-	auto container_count = segment_count / ROARING_CONTAINER_SIZE;
-	if (segment_count % ROARING_CONTAINER_SIZE != 0) {
-		container_count++;
-	}
-	metadata_collection.Deserialize(metadata_ptr, container_count);
-	ContainerMetadataCollectionScanner scanner(metadata_collection);
-	data_start_position.reserve(container_count);
-	idx_t position = 0;
-	for (idx_t i = 0; i < container_count; i++) {
-		auto metadata = scanner.GetNext();
-		container_metadata.push_back(metadata);
-		if (metadata.IsUncompressed()) {
-			position = AlignValue<idx_t>(position);
-		}
-		data_start_position.push_back(position);
-		position += SkipVector(metadata);
-	}
-}
-
-idx_t RoaringScanState::SkipVector(const ContainerMetadata &metadata) {
-	// NOTE: this doesn't care about smaller containers, since only the last container can be smaller
-	return metadata.GetDataSizeInBytes(ROARING_CONTAINER_SIZE);
-}
-
-bool RoaringScanState::UseContainerStateCache(idx_t container_index, idx_t internal_offset) {
-	if (!current_container) {
-		// No container loaded yet
-		return false;
-	}
-	if (current_container->container_index != container_index) {
-		// Not the same container
-		return false;
-	}
-	if (current_container->scanned_count != internal_offset) {
-		// Not the same scan offset
-		return false;
-	}
-	return true;
-}
-
-ContainerMetadata RoaringScanState::GetContainerMetadata(idx_t container_index) {
-	return container_metadata[container_index];
-}
-
-data_ptr_t RoaringScanState::GetStartOfContainerData(idx_t container_index) {
-	return data_ptr + data_start_position[container_index];
-}
-
-ContainerScanState &RoaringScanState::LoadContainer(idx_t container_index, idx_t internal_offset) {
-	if (UseContainerStateCache(container_index, internal_offset)) {
-		return *current_container;
-	}
-	auto metadata = GetContainerMetadata(container_index);
-	auto data_ptr = GetStartOfContainerData(container_index);
-
-	auto segment_count = segment.count.load();
-	auto start_of_container = container_index * ROARING_CONTAINER_SIZE;
-	auto container_size = MinValue<idx_t>(segment_count - start_of_container, ROARING_CONTAINER_SIZE);
-	if (metadata.IsUncompressed()) {
-		current_container = make_uniq<BitsetContainerScanState>(container_index, container_size,
-		                                                        reinterpret_cast<validity_t *>(data_ptr));
-	} else if (metadata.IsRun()) {
-		D_ASSERT(metadata.IsInverted());
-		auto number_of_runs = metadata.NumberOfRuns();
-		if (number_of_runs >= COMPRESSED_RUN_THRESHOLD) {
-			auto segments = data_ptr;
-			data_ptr = segments + COMPRESSED_SEGMENT_COUNT;
-			current_container = make_uniq<CompressedRunContainerScanState>(container_index, container_size,
-			                                                               number_of_runs, segments, data_ptr);
-		} else {
-			current_container =
-			    make_uniq<RunContainerScanState>(container_index, container_size, number_of_runs, data_ptr);
-		}
-	} else {
-		auto cardinality = metadata.Cardinality();
-		if (cardinality >= COMPRESSED_ARRAY_THRESHOLD) {
-			auto segments = data_ptr;
-			data_ptr = segments + COMPRESSED_SEGMENT_COUNT;
-			if (metadata.IsInverted()) {
-				current_container = make_uniq<CompressedArrayContainerScanState<NULLS>>(
-				    container_index, container_size, cardinality, segments, data_ptr);
-			} else {
-				current_container = make_uniq<CompressedArrayContainerScanState<NON_NULLS>>(
-				    container_index, container_size, cardinality, segments, data_ptr);
-			}
-		} else {
-			if (metadata.IsInverted()) {
-				current_container =
-				    make_uniq<ArrayContainerScanState<NULLS>>(container_index, container_size, cardinality, data_ptr);
-			} else {
-				current_container = make_uniq<ArrayContainerScanState<NON_NULLS>>(container_index, container_size,
-				                                                                  cardinality, data_ptr);
-			}
-		}
-	}
-
-	current_container->Verify();
-
-	auto &scan_state = *current_container;
-	if (internal_offset) {
-		Skip(scan_state, internal_offset);
-	}
-	return *current_container;
-}
-
-void RoaringScanState::ScanInternal(ContainerScanState &scan_state, idx_t to_scan, Vector &result, idx_t offset) {
-	scan_state.ScanPartial(result, offset, to_scan);
-}
-
-idx_t RoaringScanState::GetContainerIndex(idx_t start_index, idx_t &offset) {
-	idx_t container_index = start_index / ROARING_CONTAINER_SIZE;
-	offset = start_index % ROARING_CONTAINER_SIZE;
-	return container_index;
-}
-
-void RoaringScanState::ScanPartial(idx_t start_idx, Vector &result, idx_t offset, idx_t count) {
-	result.Flatten(count);
-	idx_t remaining = count;
-	idx_t scanned = 0;
-	while (remaining) {
-		idx_t internal_offset;
-		idx_t container_idx = GetContainerIndex(start_idx + scanned, internal_offset);
-		auto &scan_state = LoadContainer(container_idx, internal_offset);
-		idx_t remaining_in_container = scan_state.container_size - scan_state.scanned_count;
-		idx_t to_scan = MinValue<idx_t>(remaining, remaining_in_container);
-		ScanInternal(scan_state, to_scan, result, offset + scanned);
-		remaining -= to_scan;
-		scanned += to_scan;
-	}
-	D_ASSERT(scanned == count);
-}
-
-void RoaringScanState::Skip(ContainerScanState &scan_state, idx_t skip_count) {
-	D_ASSERT(scan_state.scanned_count + skip_count <= scan_state.container_size);
-	if (scan_state.scanned_count + skip_count == scan_state.container_size) {
-		scan_state.scanned_count = scan_state.container_size;
-		// This skips all remaining values covered by this container
-		return;
-	}
-	scan_state.Skip(skip_count);
-}
-
-} // namespace roaring
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/string_uncompressed.cpp b/src/duckdb/src/storage/compression/string_uncompressed.cpp
deleted file mode 100644
index a2279529f..000000000
--- a/src/duckdb/src/storage/compression/string_uncompressed.cpp
+++ /dev/null
@@ -1,447 +0,0 @@
-#include "duckdb/storage/string_uncompressed.hpp"
-
-#include "duckdb/common/pair.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Storage Class
-//===--------------------------------------------------------------------===//
-UncompressedStringSegmentState::~UncompressedStringSegmentState() {
-	while (head) {
-		// prevent deep recursion here
-		head = std::move(head->next);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct StringAnalyzeState : public AnalyzeState {
-	explicit StringAnalyzeState(const CompressionInfo &info)
-	    : AnalyzeState(info), count(0), total_string_size(0), overflow_strings(0) {
-	}
-
-	idx_t count;
-	idx_t total_string_size;
-	idx_t overflow_strings;
-};
-
-unique_ptr<AnalyzeState> UncompressedStringStorage::StringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<StringAnalyzeState>(info);
-}
-
-bool UncompressedStringStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<StringAnalyzeState>();
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-
-	state.count += count;
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (vdata.validity.RowIsValid(idx)) {
-			auto string_size = data[idx].GetSize();
-			state.total_string_size += string_size;
-			if (string_size >= StringUncompressed::GetStringBlockLimit(state.info.GetBlockSize())) {
-				state.overflow_strings++;
-			}
-		}
-	}
-	return true;
-}
-
-idx_t UncompressedStringStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = state_p.Cast<StringAnalyzeState>();
-	return state.count * sizeof(int32_t) + state.total_string_size + state.overflow_strings * BIG_STRING_MARKER_SIZE;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void UncompressedStringInitPrefetch(ColumnSegment &segment, PrefetchState &prefetch_state) {
-	prefetch_state.AddBlock(segment.block);
-	auto segment_state = segment.GetSegmentState();
-	if (segment_state) {
-		auto &state = segment_state->Cast<UncompressedStringSegmentState>();
-		auto &block_manager = segment.GetBlockManager();
-		for (auto &block_id : state.on_disk_blocks) {
-			auto block_handle = state.GetHandle(block_manager, block_id);
-			prefetch_state.AddBlock(block_handle);
-		}
-	}
-}
-
-unique_ptr<SegmentScanState> UncompressedStringStorage::StringInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<StringScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	result->handle = buffer_manager.Pin(segment.block);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void UncompressedStringStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                                  Vector &result, idx_t result_offset) {
-	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = state.scan_state->Cast<StringScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, scan_state.handle);
-	auto base_data = reinterpret_cast<int32_t *>(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	int32_t previous_offset = start > 0 ? base_data[start - 1] : 0;
-
-	for (idx_t i = 0; i < scan_count; i++) {
-		// std::abs used since offsets can be negative to indicate big strings
-		auto current_offset = base_data[start + i];
-		auto string_length = UnsafeNumericCast<uint32_t>(std::abs(current_offset) - std::abs(previous_offset));
-		result_data[result_offset + i] =
-		    FetchStringFromDict(segment, dict, result, baseptr, current_offset, string_length);
-		previous_offset = base_data[start + i];
-	}
-}
-
-void UncompressedStringStorage::StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                           Vector &result) {
-	StringScanPartial(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Select
-//===--------------------------------------------------------------------===//
-void UncompressedStringStorage::Select(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count,
-                                       Vector &result, const SelectionVector &sel, idx_t sel_count) {
-	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = state.scan_state->Cast<StringScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, scan_state.handle);
-	auto base_data = reinterpret_cast<int32_t *>(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	for (idx_t i = 0; i < sel_count; i++) {
-		idx_t index = start + sel.get_index(i);
-		auto current_offset = base_data[index];
-		auto prev_offset = index > 0 ? base_data[index - 1] : 0;
-		auto string_length = UnsafeNumericCast<uint32_t>(std::abs(current_offset) - std::abs(prev_offset));
-		result_data[i] = FetchStringFromDict(segment, dict, result, baseptr, current_offset, string_length);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-BufferHandle &ColumnFetchState::GetOrInsertHandle(ColumnSegment &segment) {
-	auto primary_id = segment.block->BlockId();
-
-	auto entry = handles.find(primary_id);
-	if (entry == handles.end()) {
-		// not pinned yet: pin it
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		auto handle = buffer_manager.Pin(segment.block);
-		auto pinned_entry = handles.insert(make_pair(primary_id, std::move(handle)));
-		return pinned_entry.first->second;
-	} else {
-		// already pinned: use the pinned handle
-		return entry->second;
-	}
-}
-
-void UncompressedStringStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
-                                               Vector &result, idx_t result_idx) {
-	// fetch a single row from the string segment
-	// first pin the main buffer if it is not already pinned
-	auto &handle = state.GetOrInsertHandle(segment);
-
-	auto baseptr = handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, handle);
-	auto base_data = reinterpret_cast<int32_t *>(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	auto dict_offset = base_data[row_id];
-	uint32_t string_length;
-	if (DUCKDB_UNLIKELY(row_id == 0LL)) {
-		// edge case where this is the first string in the dict
-		string_length = NumericCast<uint32_t>(std::abs(dict_offset));
-	} else {
-		string_length = NumericCast<uint32_t>(std::abs(dict_offset) - std::abs(base_data[row_id - 1]));
-	}
-	result_data[result_idx] = FetchStringFromDict(segment, dict, result, baseptr, dict_offset, string_length);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-SerializedStringSegmentState::SerializedStringSegmentState() {
-}
-
-SerializedStringSegmentState::SerializedStringSegmentState(vector<block_id_t> blocks_p) {
-	blocks = std::move(blocks_p);
-}
-
-void SerializedStringSegmentState::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(1, "overflow_blocks", blocks);
-}
-
-unique_ptr<CompressedSegmentState>
-UncompressedStringStorage::StringInitSegment(ColumnSegment &segment, block_id_t block_id,
-                                             optional_ptr<ColumnSegmentState> segment_state) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	if (block_id == INVALID_BLOCK) {
-		auto handle = buffer_manager.Pin(segment.block);
-		StringDictionaryContainer dictionary;
-		dictionary.size = 0;
-		dictionary.end = UnsafeNumericCast<uint32_t>(segment.SegmentSize());
-		SetDictionary(segment, handle, dictionary);
-	}
-	auto result = make_uniq<UncompressedStringSegmentState>();
-	if (segment_state) {
-		auto &serialized_state = segment_state->Cast<SerializedStringSegmentState>();
-		result->on_disk_blocks = std::move(serialized_state.blocks);
-	}
-	return std::move(result);
-}
-
-idx_t UncompressedStringStorage::FinalizeAppend(ColumnSegment &segment, SegmentStatistics &) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	auto dict = GetDictionary(segment, handle);
-	D_ASSERT(dict.end == segment.SegmentSize());
-	// compute the total size required to store this segment
-	auto offset_size = DICTIONARY_HEADER_SIZE + segment.count * sizeof(int32_t);
-	auto total_size = offset_size + dict.size;
-
-	CompressionInfo info(segment.GetBlockManager().GetBlockSize());
-	if (total_size >= info.GetCompactionFlushLimit()) {
-		// the block is full enough, don't bother moving around the dictionary
-		return segment.SegmentSize();
-	}
-
-	// the block has space left: figure out how much space we can save
-	auto move_amount = segment.SegmentSize() - total_size;
-	// move the dictionary so it lines up exactly with the offsets
-	auto dataptr = handle.Ptr();
-	memmove(dataptr + offset_size, dataptr + dict.end - dict.size, dict.size);
-	dict.end -= move_amount;
-	D_ASSERT(dict.end == total_size);
-	// write the new dictionary (with the updated "end")
-	SetDictionary(segment, handle, dict);
-	return total_size;
-}
-
-//===--------------------------------------------------------------------===//
-// Serialization & Cleanup
-//===--------------------------------------------------------------------===//
-unique_ptr<ColumnSegmentState> UncompressedStringStorage::SerializeState(ColumnSegment &segment) {
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-	if (state.on_disk_blocks.empty()) {
-		// no on-disk blocks - nothing to write
-		return nullptr;
-	}
-	return make_uniq<SerializedStringSegmentState>(state.on_disk_blocks);
-}
-
-unique_ptr<ColumnSegmentState> UncompressedStringStorage::DeserializeState(Deserializer &deserializer) {
-	auto result = make_uniq<SerializedStringSegmentState>();
-	deserializer.ReadProperty(1, "overflow_blocks", result->blocks);
-	return std::move(result);
-}
-
-void UncompressedStringStorage::CleanupState(ColumnSegment &segment) {
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-	auto &block_manager = segment.GetBlockManager();
-	for (auto &block_id : state.on_disk_blocks) {
-		block_manager.MarkBlockAsModified(block_id);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction StringUncompressed::GetFunction(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::VARCHAR);
-	return CompressionFunction(
-	    CompressionType::COMPRESSION_UNCOMPRESSED, data_type, UncompressedStringStorage::StringInitAnalyze,
-	    UncompressedStringStorage::StringAnalyze, UncompressedStringStorage::StringFinalAnalyze,
-	    UncompressedFunctions::InitCompression, UncompressedFunctions::Compress,
-	    UncompressedFunctions::FinalizeCompress, UncompressedStringStorage::StringInitScan,
-	    UncompressedStringStorage::StringScan, UncompressedStringStorage::StringScanPartial,
-	    UncompressedStringStorage::StringFetchRow, UncompressedFunctions::EmptySkip,
-	    UncompressedStringStorage::StringInitSegment, UncompressedStringStorage::StringInitAppend,
-	    UncompressedStringStorage::StringAppend, UncompressedStringStorage::FinalizeAppend, nullptr,
-	    UncompressedStringStorage::SerializeState, UncompressedStringStorage::DeserializeState,
-	    UncompressedStringStorage::CleanupState, UncompressedStringInitPrefetch, UncompressedStringStorage::Select);
-}
-
-//===--------------------------------------------------------------------===//
-// Helper Functions
-//===--------------------------------------------------------------------===//
-void UncompressedStringStorage::SetDictionary(ColumnSegment &segment, BufferHandle &handle,
-                                              StringDictionaryContainer container) {
-	auto startptr = handle.Ptr() + segment.GetBlockOffset();
-	Store<uint32_t>(container.size, startptr);
-	Store<uint32_t>(container.end, startptr + sizeof(uint32_t));
-}
-
-StringDictionaryContainer UncompressedStringStorage::GetDictionary(ColumnSegment &segment, BufferHandle &handle) {
-	auto startptr = handle.Ptr() + segment.GetBlockOffset();
-	StringDictionaryContainer container;
-	container.size = Load<uint32_t>(startptr);
-	container.end = Load<uint32_t>(startptr + sizeof(uint32_t));
-	return container;
-}
-
-idx_t UncompressedStringStorage::RemainingSpace(ColumnSegment &segment, BufferHandle &handle) {
-	auto dictionary = GetDictionary(segment, handle);
-	D_ASSERT(dictionary.end == segment.SegmentSize());
-	idx_t used_space = dictionary.size + segment.count * sizeof(int32_t) + DICTIONARY_HEADER_SIZE;
-	D_ASSERT(segment.SegmentSize() >= used_space);
-	return segment.SegmentSize() - used_space;
-}
-
-void UncompressedStringStorage::WriteString(ColumnSegment &segment, string_t string, block_id_t &result_block,
-                                            int32_t &result_offset) {
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-	if (state.overflow_writer) {
-		// overflow writer is set: write string there
-		state.overflow_writer->WriteString(state, string, result_block, result_offset);
-	} else {
-		// default overflow behavior: use in-memory buffer to store the overflow string
-		WriteStringMemory(segment, string, result_block, result_offset);
-	}
-}
-
-void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string_t string, block_id_t &result_block,
-                                                  int32_t &result_offset) {
-	auto total_length = UnsafeNumericCast<uint32_t>(string.GetSize() + sizeof(uint32_t));
-	shared_ptr<BlockHandle> block;
-	BufferHandle handle;
-
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-	// check if the string fits in the current block
-	if (!state.head || state.head->offset + total_length >= state.head->size) {
-		// string does not fit, allocate space for it
-		// create a new string block
-		auto alloc_size = MaxValue<idx_t>(total_length, segment.GetBlockManager().GetBlockSize());
-		auto new_block = make_uniq<StringBlock>();
-		new_block->offset = 0;
-		new_block->size = alloc_size;
-		// allocate an in-memory buffer for it
-		handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, alloc_size, false);
-		block = handle.GetBlockHandle();
-		state.overflow_blocks.insert(make_pair(block->BlockId(), reference<StringBlock>(*new_block)));
-		new_block->block = std::move(block);
-		new_block->next = std::move(state.head);
-		state.head = std::move(new_block);
-	} else {
-		// string fits, copy it into the current block
-		handle = buffer_manager.Pin(state.head->block);
-	}
-
-	result_block = state.head->block->BlockId();
-	result_offset = UnsafeNumericCast<int32_t>(state.head->offset);
-
-	// copy the string and the length there
-	auto ptr = handle.Ptr() + state.head->offset;
-	Store<uint32_t>(UnsafeNumericCast<uint32_t>(string.GetSize()), ptr);
-	ptr += sizeof(uint32_t);
-	memcpy(ptr, string.GetData(), string.GetSize());
-	state.head->offset += total_length;
-}
-
-string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, Vector &result, block_id_t block,
-                                                       int32_t offset) {
-	auto &block_manager = segment.GetBlockManager();
-	auto &buffer_manager = block_manager.buffer_manager;
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-
-	D_ASSERT(block != INVALID_BLOCK);
-	D_ASSERT(offset < NumericCast<int32_t>(block_manager.GetBlockSize()));
-
-	if (block < MAXIMUM_BLOCK) {
-		// read the overflow string from disk
-		// pin the initial handle and read the length
-		auto block_handle = state.GetHandle(block_manager, block);
-		auto handle = buffer_manager.Pin(block_handle);
-
-		// read header
-		uint32_t length = Load<uint32_t>(handle.Ptr() + offset);
-		uint32_t remaining = length;
-		offset += sizeof(uint32_t);
-
-		// allocate a buffer to store the string
-		auto alloc_size = MaxValue<idx_t>(block_manager.GetBlockSize(), length);
-		// allocate a buffer to store the compressed string
-		// TODO: profile this to check if we need to reuse buffer
-		auto target_handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, alloc_size);
-		auto target_ptr = target_handle.Ptr();
-
-		// now append the string to the single buffer
-		while (remaining > 0) {
-			idx_t to_write = MinValue<idx_t>(remaining, block_manager.GetBlockSize() - sizeof(block_id_t) -
-			                                                UnsafeNumericCast<idx_t>(offset));
-			memcpy(target_ptr, handle.Ptr() + offset, to_write);
-			remaining -= to_write;
-			offset += UnsafeNumericCast<int32_t>(to_write);
-			target_ptr += to_write;
-			if (remaining > 0) {
-				// read the next block
-				block_id_t next_block = Load<block_id_t>(handle.Ptr() + offset);
-				block_handle = state.GetHandle(block_manager, next_block);
-				handle = buffer_manager.Pin(block_handle);
-				offset = 0;
-			}
-		}
-
-		auto final_buffer = target_handle.Ptr();
-		StringVector::AddHandle(result, std::move(target_handle));
-		return ReadString(final_buffer, 0, length);
-	}
-
-	// read the overflow string from memory
-	// first pin the handle, if it is not pinned yet
-	auto entry = state.overflow_blocks.find(block);
-	D_ASSERT(entry != state.overflow_blocks.end());
-	auto handle = buffer_manager.Pin(entry->second.get().block);
-	auto final_buffer = handle.Ptr();
-	StringVector::AddHandle(result, std::move(handle));
-	return ReadStringWithLength(final_buffer, offset);
-}
-
-string_t UncompressedStringStorage::ReadString(data_ptr_t target, int32_t offset, uint32_t string_length) {
-	auto ptr = target + offset;
-	auto str_ptr = char_ptr_cast(ptr);
-	return string_t(str_ptr, string_length);
-}
-
-string_t UncompressedStringStorage::ReadStringWithLength(data_ptr_t target, int32_t offset) {
-	auto ptr = target + offset;
-	auto str_length = Load<uint32_t>(ptr);
-	auto str_ptr = char_ptr_cast(ptr + sizeof(uint32_t));
-	return string_t(str_ptr, str_length);
-}
-
-void UncompressedStringStorage::WriteStringMarker(data_ptr_t target, block_id_t block_id, int32_t offset) {
-	memcpy(target, &block_id, sizeof(block_id_t));
-	target += sizeof(block_id_t);
-	memcpy(target, &offset, sizeof(int32_t));
-}
-
-void UncompressedStringStorage::ReadStringMarker(data_ptr_t target, block_id_t &block_id, int32_t &offset) {
-	memcpy(&block_id, target, sizeof(block_id_t));
-	target += sizeof(block_id_t);
-	memcpy(&offset, target, sizeof(int32_t));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/uncompressed.cpp b/src/duckdb/src/storage/compression/uncompressed.cpp
deleted file mode 100644
index 436b41c5a..000000000
--- a/src/duckdb/src/storage/compression/uncompressed.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/function/compression/compression.hpp"
-
-namespace duckdb {
-
-CompressionFunction UncompressedFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::UINT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-	case PhysicalType::LIST:
-	case PhysicalType::INTERVAL:
-		return FixedSizeUncompressed::GetFunction(type);
-	case PhysicalType::BIT:
-		return ValidityUncompressed::GetFunction(type);
-	case PhysicalType::VARCHAR:
-		return StringUncompressed::GetFunction(type);
-	default:
-		throw InternalException("Unsupported type for Uncompressed");
-	}
-}
-
-bool UncompressedFun::TypeIsSupported(const PhysicalType) {
-	return true;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/validity_uncompressed.cpp b/src/duckdb/src/storage/compression/validity_uncompressed.cpp
deleted file mode 100644
index 8fa4acca9..000000000
--- a/src/duckdb/src/storage/compression/validity_uncompressed.cpp
+++ /dev/null
@@ -1,542 +0,0 @@
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Mask constants
-//===--------------------------------------------------------------------===//
-// LOWER_MASKS contains masks with all the lower bits set until a specific value
-// LOWER_MASKS[0] has the 0 lowest bits set, i.e.:
-// 0b0000000000000000000000000000000000000000000000000000000000000000,
-// LOWER_MASKS[10] has the 10 lowest bits set, i.e.:
-// 0b0000000000000000000000000000000000000000000000000000000111111111,
-// etc...
-// 0b0000000000000000000000000000000000000001111111111111111111111111,
-// ...
-// 0b0000000000000000000001111111111111111111111111111111111111111111,
-// until LOWER_MASKS[64], which has all bits set:
-// 0b1111111111111111111111111111111111111111111111111111111111111111
-// generated with this python snippet:
-// for i in range(65):
-//   print(hex(int((64 - i) * '0' + i * '1', 2)) + ",")
-const validity_t ValidityUncompressed::LOWER_MASKS[] = {0x0,
-                                                        0x1,
-                                                        0x3,
-                                                        0x7,
-                                                        0xf,
-                                                        0x1f,
-                                                        0x3f,
-                                                        0x7f,
-                                                        0xff,
-                                                        0x1ff,
-                                                        0x3ff,
-                                                        0x7ff,
-                                                        0xfff,
-                                                        0x1fff,
-                                                        0x3fff,
-                                                        0x7fff,
-                                                        0xffff,
-                                                        0x1ffff,
-                                                        0x3ffff,
-                                                        0x7ffff,
-                                                        0xfffff,
-                                                        0x1fffff,
-                                                        0x3fffff,
-                                                        0x7fffff,
-                                                        0xffffff,
-                                                        0x1ffffff,
-                                                        0x3ffffff,
-                                                        0x7ffffff,
-                                                        0xfffffff,
-                                                        0x1fffffff,
-                                                        0x3fffffff,
-                                                        0x7fffffff,
-                                                        0xffffffff,
-                                                        0x1ffffffff,
-                                                        0x3ffffffff,
-                                                        0x7ffffffff,
-                                                        0xfffffffff,
-                                                        0x1fffffffff,
-                                                        0x3fffffffff,
-                                                        0x7fffffffff,
-                                                        0xffffffffff,
-                                                        0x1ffffffffff,
-                                                        0x3ffffffffff,
-                                                        0x7ffffffffff,
-                                                        0xfffffffffff,
-                                                        0x1fffffffffff,
-                                                        0x3fffffffffff,
-                                                        0x7fffffffffff,
-                                                        0xffffffffffff,
-                                                        0x1ffffffffffff,
-                                                        0x3ffffffffffff,
-                                                        0x7ffffffffffff,
-                                                        0xfffffffffffff,
-                                                        0x1fffffffffffff,
-                                                        0x3fffffffffffff,
-                                                        0x7fffffffffffff,
-                                                        0xffffffffffffff,
-                                                        0x1ffffffffffffff,
-                                                        0x3ffffffffffffff,
-                                                        0x7ffffffffffffff,
-                                                        0xfffffffffffffff,
-                                                        0x1fffffffffffffff,
-                                                        0x3fffffffffffffff,
-                                                        0x7fffffffffffffff,
-                                                        0xffffffffffffffff};
-
-// UPPER_MASKS contains masks with all the highest bits set until a specific value
-// UPPER_MASKS[0] has the 0 highest bits set, i.e.:
-// 0b0000000000000000000000000000000000000000000000000000000000000000,
-// UPPER_MASKS[10] has the 10 highest bits set, i.e.:
-// 0b1111111111110000000000000000000000000000000000000000000000000000,
-// etc...
-// 0b1111111111111111111111110000000000000000000000000000000000000000,
-// ...
-// 0b1111111111111111111111111111111111111110000000000000000000000000,
-// until UPPER_MASKS[64], which has all bits set:
-// 0b1111111111111111111111111111111111111111111111111111111111111111
-// generated with this python snippet:
-// for i in range(65):
-//   print(hex(int(i * '1' + (64 - i) * '0', 2)) + ",")
-const validity_t ValidityUncompressed::UPPER_MASKS[] = {0x0,
-                                                        0x8000000000000000,
-                                                        0xc000000000000000,
-                                                        0xe000000000000000,
-                                                        0xf000000000000000,
-                                                        0xf800000000000000,
-                                                        0xfc00000000000000,
-                                                        0xfe00000000000000,
-                                                        0xff00000000000000,
-                                                        0xff80000000000000,
-                                                        0xffc0000000000000,
-                                                        0xffe0000000000000,
-                                                        0xfff0000000000000,
-                                                        0xfff8000000000000,
-                                                        0xfffc000000000000,
-                                                        0xfffe000000000000,
-                                                        0xffff000000000000,
-                                                        0xffff800000000000,
-                                                        0xffffc00000000000,
-                                                        0xffffe00000000000,
-                                                        0xfffff00000000000,
-                                                        0xfffff80000000000,
-                                                        0xfffffc0000000000,
-                                                        0xfffffe0000000000,
-                                                        0xffffff0000000000,
-                                                        0xffffff8000000000,
-                                                        0xffffffc000000000,
-                                                        0xffffffe000000000,
-                                                        0xfffffff000000000,
-                                                        0xfffffff800000000,
-                                                        0xfffffffc00000000,
-                                                        0xfffffffe00000000,
-                                                        0xffffffff00000000,
-                                                        0xffffffff80000000,
-                                                        0xffffffffc0000000,
-                                                        0xffffffffe0000000,
-                                                        0xfffffffff0000000,
-                                                        0xfffffffff8000000,
-                                                        0xfffffffffc000000,
-                                                        0xfffffffffe000000,
-                                                        0xffffffffff000000,
-                                                        0xffffffffff800000,
-                                                        0xffffffffffc00000,
-                                                        0xffffffffffe00000,
-                                                        0xfffffffffff00000,
-                                                        0xfffffffffff80000,
-                                                        0xfffffffffffc0000,
-                                                        0xfffffffffffe0000,
-                                                        0xffffffffffff0000,
-                                                        0xffffffffffff8000,
-                                                        0xffffffffffffc000,
-                                                        0xffffffffffffe000,
-                                                        0xfffffffffffff000,
-                                                        0xfffffffffffff800,
-                                                        0xfffffffffffffc00,
-                                                        0xfffffffffffffe00,
-                                                        0xffffffffffffff00,
-                                                        0xffffffffffffff80,
-                                                        0xffffffffffffffc0,
-                                                        0xffffffffffffffe0,
-                                                        0xfffffffffffffff0,
-                                                        0xfffffffffffffff8,
-                                                        0xfffffffffffffffc,
-                                                        0xfffffffffffffffe,
-                                                        0xffffffffffffffff};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct ValidityAnalyzeState : public AnalyzeState {
-	explicit ValidityAnalyzeState(const CompressionInfo &info) : AnalyzeState(info), count(0) {
-	}
-
-	idx_t count;
-};
-
-unique_ptr<AnalyzeState> ValidityInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	return make_uniq<ValidityAnalyzeState>(info);
-}
-
-bool ValidityAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<ValidityAnalyzeState>();
-	state.count += count;
-	return true;
-}
-
-idx_t ValidityFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = state_p.Cast<ValidityAnalyzeState>();
-	return (state.count + 7) / 8;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct ValidityScanState : public SegmentScanState {
-	BufferHandle handle;
-	block_id_t block_id;
-};
-
-unique_ptr<SegmentScanState> ValidityInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<ValidityScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	result->handle = buffer_manager.Pin(segment.block);
-	result->block_id = segment.block->BlockId();
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-
-void ValidityUncompressed::UnalignedScan(data_ptr_t input, idx_t input_size, idx_t input_start, Vector &result,
-                                         idx_t result_offset, idx_t scan_count) {
-	D_ASSERT(input_start < input_size);
-	auto &result_mask = FlatVector::Validity(result);
-	auto input_data = reinterpret_cast<validity_t *>(input);
-
-#ifdef DEBUG
-	// this method relies on all the bits we are going to write to being set to valid
-	for (idx_t i = 0; i < scan_count; i++) {
-		D_ASSERT(result_mask.RowIsValid(result_offset + i));
-	}
-#endif
-#if STANDARD_VECTOR_SIZE < 128
-	// fallback for tiny vector sizes
-	// the bitwise ops we use below don't work if the vector size is too small
-	ValidityMask source_mask(input_data, input_size);
-	for (idx_t i = 0; i < scan_count; i++) {
-		if (!source_mask.RowIsValid(input_start + i)) {
-			if (result_mask.AllValid()) {
-				result_mask.Initialize();
-			}
-			result_mask.SetInvalid(result_offset + i);
-		}
-	}
-#else
-	// the code below does what the fallback code above states, but using bitwise ops:
-	auto result_data = (validity_t *)result_mask.GetData();
-
-	// set up the initial positions
-	// we need to find the validity_entry to modify, together with the bit-index WITHIN the validity entry
-	idx_t result_entry = result_offset / ValidityMask::BITS_PER_VALUE;
-	idx_t result_idx = result_offset - result_entry * ValidityMask::BITS_PER_VALUE;
-
-	// same for the input: find the validity_entry we are pulling from, together with the bit-index WITHIN that entry
-	idx_t input_entry = input_start / ValidityMask::BITS_PER_VALUE;
-	idx_t input_idx = input_start - input_entry * ValidityMask::BITS_PER_VALUE;
-
-	// now start the bit games
-	idx_t pos = 0;
-	while (pos < scan_count) {
-		// these are the current validity entries we are dealing with
-		idx_t current_result_idx = result_entry;
-		idx_t offset;
-		validity_t input_mask = input_data[input_entry];
-
-		// construct the mask to AND together with the result
-		if (result_idx < input_idx) {
-			//         +======================================+
-			// input:  |xxxxxxxxx|                            |
-			//         +======================================+
-			//
-			//         +======================================+
-			// result: |                xxxxxxxxx|            |
-			//         +======================================+
-			// 1. We shift (>>) 'input' to line up with 'result'
-			// 2. We set the bits we shifted to 1
-
-			// we have to shift the input RIGHT if the result_idx is smaller than the input_idx
-			auto shift_amount = input_idx - result_idx;
-			D_ASSERT(shift_amount > 0 && shift_amount <= ValidityMask::BITS_PER_VALUE);
-
-			input_mask = input_mask >> shift_amount;
-
-			// now the upper "shift_amount" bits are set to 0
-			// we need them to be set to 1
-			// otherwise the subsequent bitwise & will modify values outside of the range of values we want to alter
-			input_mask |= ValidityUncompressed::UPPER_MASKS[shift_amount];
-
-			// after this, we move to the next input_entry
-			offset = ValidityMask::BITS_PER_VALUE - input_idx;
-			input_entry++;
-			input_idx = 0;
-			result_idx += offset;
-		} else if (result_idx > input_idx) {
-			//         +======================================+
-			// input:  |                xxxxxxxxx|            |
-			//         +======================================+
-			//
-			//         +======================================+
-			// result: |xxxxxxxxx|                            |
-			//         +======================================+
-			// 1. We set the bits to the left of the relevant bits (x) to 0
-			// 1. We shift (<<) 'input' to line up with 'result'
-			// 2. We set the bits that we zeroed to the right of the relevant bits (x) to 1
-
-			// we have to shift the input LEFT if the result_idx is bigger than the input_idx
-			auto shift_amount = result_idx - input_idx;
-			D_ASSERT(shift_amount > 0 && shift_amount <= ValidityMask::BITS_PER_VALUE);
-
-			// to avoid overflows, we set the upper "shift_amount" values to 0 first
-			input_mask = (input_mask & ~ValidityUncompressed::UPPER_MASKS[shift_amount]) << shift_amount;
-
-			// now the lower "shift_amount" bits are set to 0
-			// we need them to be set to 1
-			// otherwise the subsequent bitwise & will modify values outside of the range of values we want to alter
-			input_mask |= ValidityUncompressed::LOWER_MASKS[shift_amount];
-
-			// after this, we move to the next result_entry
-			offset = ValidityMask::BITS_PER_VALUE - result_idx;
-			result_entry++;
-			result_idx = 0;
-			input_idx += offset;
-		} else {
-			// if the input_idx is equal to result_idx they are already aligned
-			// we just move to the next entry for both after this
-			offset = ValidityMask::BITS_PER_VALUE - result_idx;
-			input_entry++;
-			result_entry++;
-			result_idx = input_idx = 0;
-		}
-		// now we need to check if we should include the ENTIRE mask
-		// OR if we need to mask from the right side
-		pos += offset;
-		if (pos > scan_count) {
-			//        +======================================+
-			// mask:  |            |xxxxxxxxxxxxxxxxxxxxxxxxx|
-			//        +======================================+
-			//
-			// The bits on the right side of the relevant bits (x) need to stay 1, to be adjusted by later scans
-			// so we adjust the mask to clear out any 0s that might be present on the right side.
-
-			// we need to set any bits that are past the scan_count on the right-side to 1
-			// this is required so we don't influence any bits that are not part of the scan
-			input_mask |= ValidityUncompressed::UPPER_MASKS[pos - scan_count];
-		}
-		// now finally we can merge the input mask with the result mask
-		if (input_mask != ValidityMask::ValidityBuffer::MAX_ENTRY) {
-			if (!result_data) {
-				result_mask.Initialize();
-				result_data = (validity_t *)result_mask.GetData();
-			}
-			result_data[current_result_idx] &= input_mask;
-		}
-	}
-#endif
-
-#ifdef DEBUG
-	// verify that we actually accomplished the bitwise ops equivalent that we wanted to do
-	ValidityMask input_mask(input_data, input_size);
-	for (idx_t i = 0; i < scan_count; i++) {
-		D_ASSERT(result_mask.RowIsValid(result_offset + i) == input_mask.RowIsValid(input_start + i));
-	}
-#endif
-}
-
-void ValidityUncompressed::AlignedScan(data_ptr_t input, idx_t input_start, Vector &result, idx_t scan_count) {
-	D_ASSERT(input_start % ValidityMask::BITS_PER_VALUE == 0);
-
-	// aligned scan: no need to do anything fancy
-	// note: this is only an optimization which avoids having to do messy bitshifting in the common case
-	// it is not required for correctness
-	auto &result_mask = FlatVector::Validity(result);
-	auto input_data = reinterpret_cast<validity_t *>(input);
-	auto result_data = result_mask.GetData();
-	idx_t start_offset = input_start / ValidityMask::BITS_PER_VALUE;
-	idx_t entry_scan_count = (scan_count + ValidityMask::BITS_PER_VALUE - 1) / ValidityMask::BITS_PER_VALUE;
-	for (idx_t i = 0; i < entry_scan_count; i++) {
-		auto input_entry = input_data[start_offset + i];
-		if (!result_data && input_entry == ValidityMask::ValidityBuffer::MAX_ENTRY) {
-			continue;
-		}
-		if (!result_data) {
-			result_mask.Initialize();
-			result_data = result_mask.GetData();
-		}
-		result_data[i] = input_entry;
-	}
-}
-
-void ValidityScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                         idx_t result_offset) {
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	static_assert(sizeof(validity_t) == sizeof(uint64_t), "validity_t should be 64-bit");
-	auto &scan_state = state.scan_state->Cast<ValidityScanState>();
-
-	auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	D_ASSERT(scan_state.block_id == segment.block->BlockId());
-	ValidityUncompressed::UnalignedScan(buffer_ptr, segment.count, start, result, result_offset, scan_count);
-}
-
-void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	result.Flatten(scan_count);
-
-	auto start = segment.GetRelativeIndex(state.row_index);
-	if (start % ValidityMask::BITS_PER_VALUE == 0) {
-		auto &scan_state = state.scan_state->Cast<ValidityScanState>();
-
-		auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-		D_ASSERT(scan_state.block_id == segment.block->BlockId());
-		ValidityUncompressed::AlignedScan(buffer_ptr, start, result, scan_count);
-	} else {
-		// unaligned scan: fall back to scan_partial which does bitshift tricks
-		ValidityScanPartial(segment, state, scan_count, result, 0);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Select
-//===--------------------------------------------------------------------===//
-void ValiditySelect(ColumnSegment &segment, ColumnScanState &state, idx_t, Vector &result, const SelectionVector &sel,
-                    idx_t sel_count) {
-	result.Flatten(sel_count);
-
-	auto &scan_state = state.scan_state->Cast<ValidityScanState>();
-	auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto &result_mask = FlatVector::Validity(result);
-	auto input_data = reinterpret_cast<validity_t *>(buffer_ptr);
-
-	auto start = segment.GetRelativeIndex(state.row_index);
-	ValidityMask source_mask(input_data, segment.count);
-	for (idx_t i = 0; i < sel_count; i++) {
-		auto source_idx = start + sel.get_index(i);
-		if (!source_mask.RowIsValidUnsafe(source_idx)) {
-			result_mask.SetInvalid(i);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ValidityFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	D_ASSERT(row_id >= 0 && row_id < row_t(segment.count));
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	auto dataptr = handle.Ptr() + segment.GetBlockOffset();
-	ValidityMask mask(reinterpret_cast<validity_t *>(dataptr), segment.count);
-	auto &result_mask = FlatVector::Validity(result);
-	if (!mask.RowIsValidUnsafe(NumericCast<idx_t>(row_id))) {
-		result_mask.SetInvalid(result_idx);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-static unique_ptr<CompressionAppendState> ValidityInitAppend(ColumnSegment &segment) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	return make_uniq<CompressionAppendState>(std::move(handle));
-}
-
-unique_ptr<CompressedSegmentState> ValidityInitSegment(ColumnSegment &segment, block_id_t block_id,
-                                                       optional_ptr<ColumnSegmentState> segment_state) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	if (block_id == INVALID_BLOCK) {
-		auto handle = buffer_manager.Pin(segment.block);
-		memset(handle.Ptr(), 0xFF, segment.SegmentSize());
-	}
-	return nullptr;
-}
-
-idx_t ValidityAppend(CompressionAppendState &append_state, ColumnSegment &segment, SegmentStatistics &stats,
-                     UnifiedVectorFormat &data, idx_t offset, idx_t vcount) {
-	D_ASSERT(segment.GetBlockOffset() == 0);
-	auto &validity_stats = stats.statistics;
-
-	auto max_tuples = segment.SegmentSize() / ValidityMask::STANDARD_MASK_SIZE * STANDARD_VECTOR_SIZE;
-	idx_t append_count = MinValue<idx_t>(vcount, max_tuples - segment.count);
-	if (data.validity.AllValid()) {
-		// no null values: skip append
-		segment.count += append_count;
-		validity_stats.SetHasNoNullFast();
-		return append_count;
-	}
-
-	ValidityMask mask(reinterpret_cast<validity_t *>(append_state.handle.Ptr()), max_tuples);
-	for (idx_t i = 0; i < append_count; i++) {
-		auto idx = data.sel->get_index(offset + i);
-		if (!data.validity.RowIsValidUnsafe(idx)) {
-			mask.SetInvalidUnsafe(segment.count + i);
-			validity_stats.SetHasNullFast();
-		} else {
-			validity_stats.SetHasNoNullFast();
-		}
-	}
-	segment.count += append_count;
-	return append_count;
-}
-
-idx_t ValidityFinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats) {
-	return ((segment.count + STANDARD_VECTOR_SIZE - 1) / STANDARD_VECTOR_SIZE) * ValidityMask::STANDARD_MASK_SIZE;
-}
-
-void ValidityRevertAppend(ColumnSegment &segment, idx_t start_row) {
-	idx_t start_bit = start_row - segment.start;
-
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	idx_t revert_start;
-	if (start_bit % 8 != 0) {
-		// handle sub-bit stuff (yay)
-		idx_t byte_pos = start_bit / 8;
-		idx_t bit_end = (byte_pos + 1) * 8;
-		ValidityMask mask(reinterpret_cast<validity_t *>(handle.Ptr()), segment.count);
-		for (idx_t i = start_bit; i < bit_end; i++) {
-			mask.SetValid(i);
-		}
-		revert_start = bit_end / 8;
-	} else {
-		revert_start = start_bit / 8;
-	}
-	// for the rest, we just memset
-	memset(handle.Ptr() + revert_start, 0xFF, segment.SegmentSize() - revert_start);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction ValidityUncompressed::GetFunction(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::BIT);
-	return CompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, data_type, ValidityInitAnalyze,
-	                           ValidityAnalyze, ValidityFinalAnalyze, UncompressedFunctions::InitCompression,
-	                           UncompressedFunctions::Compress, UncompressedFunctions::FinalizeCompress,
-	                           ValidityInitScan, ValidityScan, ValidityScanPartial, ValidityFetchRow,
-	                           UncompressedFunctions::EmptySkip, ValidityInitSegment, ValidityInitAppend,
-	                           ValidityAppend, ValidityFinalizeAppend, ValidityRevertAppend);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/compression/zstd.cpp b/src/duckdb/src/storage/compression/zstd.cpp
deleted file mode 100644
index 6552f0dc8..000000000
--- a/src/duckdb/src/storage/compression/zstd.cpp
+++ /dev/null
@@ -1,1049 +0,0 @@
-#include "duckdb/common/bitpacking.hpp"
-#include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/function/compression/compression.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/storage/segment/uncompressed.hpp"
-
-#include "zstd.h"
-
-/*
-Data layout per segment:
-+--------------------------------------------+
-|            Vector Metadata                 |
-|   +------------------------------------+   |
-|   |   int64_t  page_id[]               |   |
-|   |   uint32_t page_offset[]           |   |
-|   |   uint64_t uncompressed_size[]     |   |
-|   |   uint64_t compressed_size[]       |   |
-|   +------------------------------------+   |
-|                                            |
-+--------------------------------------------+
-|              [Vector Data]+                |
-|   +------------------------------------+   |
-|   |   uint32_t lengths[]               |   |
-|   |   void    *compressed_data         |   |
-|   +------------------------------------+   |
-|                                            |
-+--------------------------------------------+
-*/
-
-using page_id_t = int64_t;
-using page_offset_t = uint32_t;
-using uncompressed_size_t = uint64_t;
-using compressed_size_t = uint64_t;
-using string_length_t = uint32_t;
-
-static int32_t GetCompressionLevel() {
-	return duckdb_zstd::ZSTD_defaultCLevel();
-}
-
-static constexpr idx_t ZSTD_VECTOR_SIZE = STANDARD_VECTOR_SIZE > 2048 ? STANDARD_VECTOR_SIZE : 2048;
-
-namespace duckdb {
-
-static idx_t GetWritableSpace(const CompressionInfo &info) {
-	return info.GetBlockSize() - sizeof(block_id_t);
-}
-
-static idx_t GetVectorCount(idx_t count) {
-	idx_t vector_count = count / ZSTD_VECTOR_SIZE;
-	vector_count += (count % ZSTD_VECTOR_SIZE) != 0;
-	return vector_count;
-}
-
-static idx_t GetVectorMetadataSize(idx_t vector_count) {
-	idx_t vector_metadata_size = 0;
-	vector_metadata_size += sizeof(page_id_t) * vector_count;
-
-	vector_metadata_size = AlignValue<idx_t, sizeof(page_offset_t)>(vector_metadata_size);
-	vector_metadata_size += sizeof(page_offset_t) * vector_count;
-
-	vector_metadata_size = AlignValue<idx_t, sizeof(uncompressed_size_t)>(vector_metadata_size);
-	vector_metadata_size += sizeof(uncompressed_size_t) * vector_count;
-
-	vector_metadata_size = AlignValue<idx_t, sizeof(compressed_size_t)>(vector_metadata_size);
-	vector_metadata_size += sizeof(compressed_size_t) * vector_count;
-	return vector_metadata_size;
-}
-
-struct ZSTDStorage {
-	static unique_ptr<AnalyzeState> StringInitAnalyze(ColumnData &col_data, PhysicalType type);
-	static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count);
-	static idx_t StringFinalAnalyze(AnalyzeState &state_p);
-
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointData &checkpoint_data,
-	                                                    unique_ptr<AnalyzeState> analyze_state_p);
-	static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-
-	static unique_ptr<SegmentScanState> StringInitScan(ColumnSegment &segment);
-	static void StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                              idx_t result_offset);
-	static void StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result);
-	static void StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                           idx_t result_idx);
-	static void StringSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-		// NO OP
-	}
-
-	// Segment state metadata
-	// Required because we are creating additional pages that have to be cleaned up
-
-	static unique_ptr<CompressedSegmentState> StringInitSegment(ColumnSegment &segment, block_id_t block_id,
-	                                                            optional_ptr<ColumnSegmentState> segment_state);
-	static unique_ptr<ColumnSegmentState> SerializeState(ColumnSegment &segment);
-	static unique_ptr<ColumnSegmentState> DeserializeState(Deserializer &deserializer);
-	static void CleanupState(ColumnSegment &segment);
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-
-struct ZSTDAnalyzeState : public AnalyzeState {
-public:
-	ZSTDAnalyzeState(CompressionInfo &info, DBConfig &config) : AnalyzeState(info), config(config), context(nullptr) {
-		context = duckdb_zstd::ZSTD_createCCtx();
-	}
-	~ZSTDAnalyzeState() override {
-		duckdb_zstd::ZSTD_freeCCtx(context);
-	}
-
-public:
-	inline void AppendString(const string_t &str) {
-		auto string_size = str.GetSize();
-		total_size += string_size;
-	}
-
-public:
-	DBConfig &config;
-
-	duckdb_zstd::ZSTD_CCtx *context;
-	//! The combined string lengths for all values in the segment
-	idx_t total_size = 0;
-	//! The total amount of values in the segment
-	idx_t count = 0;
-
-	//! The amount of vectors per filled segment
-	idx_t vectors_per_segment = 0;
-	//! The total amount of segments we will create
-	idx_t segment_count = 0;
-	//! Current vector in the segment
-	idx_t vectors_in_segment = 0;
-	//! Current amount of values in the vector
-	idx_t values_in_vector = 0;
-};
-
-unique_ptr<AnalyzeState> ZSTDStorage::StringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	CompressionInfo info(col_data.GetBlockManager().GetBlockSize());
-	auto &data_table_info = col_data.info;
-	auto &attached_db = data_table_info.GetDB();
-	auto &config = DBConfig::Get(attached_db);
-
-	return make_uniq<ZSTDAnalyzeState>(info, config);
-}
-
-bool ZSTDStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<ZSTDAnalyzeState>();
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(idx)) {
-			continue;
-		}
-		auto &str = data[idx];
-		auto string_size = str.GetSize();
-		state.total_size += string_size;
-	}
-	state.values_in_vector += count;
-	while (state.values_in_vector >= ZSTD_VECTOR_SIZE) {
-		if (GetVectorMetadataSize(state.vectors_in_segment + 1) > GetWritableSpace(state.info)) {
-			state.vectors_per_segment = state.vectors_in_segment;
-			state.segment_count++;
-			state.vectors_in_segment = 0;
-		} else {
-			state.vectors_in_segment++;
-		}
-		state.values_in_vector -= ZSTD_VECTOR_SIZE;
-	}
-	state.count += count;
-	return true;
-}
-
-// Compression score to determine which compression to use
-idx_t ZSTDStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = state_p.Cast<ZSTDAnalyzeState>();
-
-	if (!state.count) {
-		return NumericLimits<idx_t>::Maximum();
-	}
-
-	if (state.values_in_vector) {
-		D_ASSERT(state.values_in_vector < ZSTD_VECTOR_SIZE);
-		state.segment_count++;
-	}
-
-	double penalty;
-	idx_t average_length = state.total_size / state.count;
-	auto threshold = state.config.options.zstd_min_string_length;
-	if (average_length >= threshold) {
-		penalty = 1.0;
-	} else {
-		// Inbetween these two points you're better off using uncompressed or a different compression algorithm.
-		return NumericLimits<idx_t>::Maximum();
-	}
-
-	auto expected_compressed_size = (double)state.total_size / 2.0;
-
-	idx_t estimated_size = 0;
-	estimated_size += LossyNumericCast<idx_t>(expected_compressed_size);
-
-	estimated_size += state.count * sizeof(string_length_t);
-	estimated_size += GetVectorMetadataSize(GetVectorCount(state.count));
-
-	return LossyNumericCast<idx_t>((double)estimated_size * penalty);
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-
-class ZSTDCompressionState : public CompressionState {
-public:
-	explicit ZSTDCompressionState(ColumnDataCheckpointData &checkpoint_data,
-	                              unique_ptr<ZSTDAnalyzeState> &&analyze_state_p)
-	    : CompressionState(analyze_state_p->info), analyze_state(std::move(analyze_state_p)),
-	      checkpoint_data(checkpoint_data),
-	      partial_block_manager(checkpoint_data.GetCheckpointState().GetPartialBlockManager()),
-	      function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ZSTD)) {
-
-		total_vector_count = GetVectorCount(analyze_state->count);
-		total_segment_count = analyze_state->segment_count;
-		vectors_per_segment = analyze_state->vectors_per_segment;
-
-		segment_count = 0;
-		vector_count = 0;
-		vector_in_segment_count = 0;
-		tuple_count = 0;
-
-		idx_t offset = NewSegment();
-		SetCurrentBuffer(segment_handle);
-		current_buffer_ptr = segment_handle.Ptr() + offset;
-		D_ASSERT(GetCurrentOffset() <= GetWritableSpace(info));
-	}
-
-public:
-	void ResetOutBuffer() {
-		out_buffer.dst = current_buffer_ptr;
-		out_buffer.pos = 0;
-
-		auto remaining_space = info.GetBlockSize() - GetCurrentOffset() - sizeof(block_id_t);
-		out_buffer.size = remaining_space;
-	}
-
-	void SetCurrentBuffer(BufferHandle &handle) {
-		current_buffer = &handle;
-		current_buffer_ptr = handle.Ptr();
-	}
-
-	BufferHandle &GetExtraPageBuffer(block_id_t current_block_id) {
-		auto &block_manager = partial_block_manager.GetBlockManager();
-		auto &buffer_manager = block_manager.buffer_manager;
-
-		optional_ptr<BufferHandle> to_use;
-
-		if (in_vector) {
-			// Currently in a Vector, we have to be mindful of the buffer that the string_lengths lives on
-			// as that will have to stay writable until the Vector is finished
-			bool already_separated = current_buffer != vector_lengths_buffer;
-			if (already_separated) {
-				// Already separated, can keep using the other buffer (flush it first)
-				FlushPage(*current_buffer, current_block_id);
-				to_use = current_buffer;
-			} else {
-				// Not already separated, have to use the other page
-				to_use = current_buffer == &extra_pages[0] ? &extra_pages[1] : &extra_pages[0];
-			}
-		} else {
-			// Start of a new Vector, the string_lengths did not fit on the previous page
-			bool previous_page_is_segment = current_buffer == &segment_handle;
-			if (!previous_page_is_segment) {
-				// We're asking for a fresh buffer to start the vectors data
-				// that means the previous vector is finished - so we can flush the current page and reuse it
-				D_ASSERT(current_block_id != INVALID_BLOCK);
-				FlushPage(*current_buffer, current_block_id);
-				to_use = current_buffer;
-			} else {
-				// Previous buffer was the segment, take the first extra page in this case
-				to_use = &extra_pages[0];
-			}
-		}
-
-		if (!to_use->IsValid()) {
-			*to_use = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, block_manager.GetBlockSize());
-		}
-		return *to_use;
-	}
-
-	idx_t NewSegment() {
-		if (current_buffer == &segment_handle) {
-			// This should never happen, the string lengths + vector metadata size should always exceed a page size,
-			// even if the strings are all empty
-			throw InternalException("We are asking for a new segment, but somehow we're still writing vector data onto "
-			                        "the initial (segment) page");
-		}
-		idx_t row_start;
-		if (segment) {
-			row_start = segment->start + segment->count;
-			FlushSegment();
-		} else {
-			row_start = checkpoint_data.GetRowGroup().start;
-		}
-		CreateEmptySegment(row_start);
-
-		// Figure out how many vectors we are storing in this segment
-		idx_t vectors_in_segment;
-		if (segment_count + 1 >= total_segment_count) {
-			vectors_in_segment = total_vector_count - vector_count;
-		} else {
-			vectors_in_segment = vectors_per_segment;
-		}
-
-		idx_t offset = 0;
-		page_ids = reinterpret_cast<page_id_t *>(segment_handle.Ptr() + offset);
-		offset += (sizeof(page_id_t) * vectors_in_segment);
-
-		offset = AlignValue<idx_t, sizeof(page_offset_t)>(offset);
-		page_offsets = reinterpret_cast<page_offset_t *>(segment_handle.Ptr() + offset);
-		offset += (sizeof(page_offset_t) * vectors_in_segment);
-
-		offset = AlignValue<idx_t, sizeof(uncompressed_size_t)>(offset);
-		uncompressed_sizes = reinterpret_cast<uncompressed_size_t *>(segment_handle.Ptr() + offset);
-		offset += (sizeof(uncompressed_size_t) * vectors_in_segment);
-
-		offset = AlignValue<idx_t, sizeof(compressed_size_t)>(offset);
-		compressed_sizes = reinterpret_cast<compressed_size_t *>(segment_handle.Ptr() + offset);
-		offset += (sizeof(compressed_size_t) * vectors_in_segment);
-
-		D_ASSERT(offset == GetVectorMetadataSize(vectors_in_segment));
-		return offset;
-	}
-
-	void InitializeVector() {
-		D_ASSERT(!in_vector);
-		if (vector_count + 1 >= total_vector_count) {
-			vector_size = analyze_state->count - (ZSTD_VECTOR_SIZE * vector_count);
-		} else {
-			vector_size = ZSTD_VECTOR_SIZE;
-		}
-		auto current_offset = GetCurrentOffset();
-		current_offset = UnsafeNumericCast<page_offset_t>(
-		    AlignValue<idx_t, sizeof(string_length_t)>(UnsafeNumericCast<idx_t>(current_offset)));
-		current_buffer_ptr = current_buffer->Ptr() + current_offset;
-		compressed_size = 0;
-		uncompressed_size = 0;
-
-		if (GetVectorMetadataSize(vector_in_segment_count + 1) > GetWritableSpace(info)) {
-			D_ASSERT(vector_in_segment_count <= vectors_per_segment);
-			// Can't fit this vector on this segment anymore, have to flush and a grab new one
-			NewSegment();
-		}
-
-		if (current_offset + (vector_size * sizeof(string_length_t)) >= GetWritableSpace(info)) {
-			// Check if there is room on the current page for the vector data
-			NewPage();
-		}
-		current_offset = GetCurrentOffset();
-		starting_offset = current_offset;
-		starting_page = GetCurrentId();
-
-		vector_lengths_buffer = current_buffer;
-		string_lengths = reinterpret_cast<string_length_t *>(current_buffer->Ptr() + current_offset);
-		current_buffer_ptr = reinterpret_cast<data_ptr_t>(string_lengths);
-		current_buffer_ptr += vector_size * sizeof(string_length_t);
-		// 'out_buffer' should be set to point directly after the string_lengths
-		ResetOutBuffer();
-
-		// Initialize the context for streaming compression
-		duckdb_zstd::ZSTD_CCtx_reset(analyze_state->context, duckdb_zstd::ZSTD_reset_session_only);
-		duckdb_zstd::ZSTD_CCtx_refCDict(analyze_state->context, nullptr);
-		duckdb_zstd::ZSTD_CCtx_setParameter(analyze_state->context, duckdb_zstd::ZSTD_c_compressionLevel,
-		                                    GetCompressionLevel());
-		in_vector = true;
-	}
-
-	void CompressString(const string_t &string, bool end_of_vector) {
-		duckdb_zstd::ZSTD_inBuffer in_buffer = {/*data = */ string.GetData(),
-		                                        /*length = */ size_t(string.GetSize()),
-		                                        /*pos = */ 0};
-
-		if (!end_of_vector && string.GetSize() == 0) {
-			return;
-		}
-		uncompressed_size += string.GetSize();
-		const auto end_mode = end_of_vector ? duckdb_zstd::ZSTD_e_end : duckdb_zstd::ZSTD_e_continue;
-
-		size_t compress_result;
-		while (true) {
-			idx_t old_pos = out_buffer.pos;
-
-			compress_result =
-			    duckdb_zstd::ZSTD_compressStream2(analyze_state->context, &out_buffer, &in_buffer, end_mode);
-			D_ASSERT(out_buffer.pos >= old_pos);
-			auto diff = out_buffer.pos - old_pos;
-			compressed_size += diff;
-			current_buffer_ptr += diff;
-
-			if (duckdb_zstd::ZSTD_isError(compress_result)) {
-				throw InvalidInputException("ZSTD Compression failed: %s",
-				                            duckdb_zstd::ZSTD_getErrorName(compress_result));
-			}
-			if (compress_result == 0) {
-				// Finished
-				break;
-			}
-			if (out_buffer.pos != out_buffer.size) {
-				throw InternalException("Expected ZSTD_compressStream2 to fully utilize the current buffer, but pos is "
-				                        "%d, while size is %d",
-				                        out_buffer.pos, out_buffer.size);
-			}
-			NewPage();
-		}
-	}
-
-	void AddString(const string_t &string) {
-		if (!tuple_count) {
-			InitializeVector();
-		}
-
-		string_lengths[tuple_count] = UnsafeNumericCast<string_length_t>(string.GetSize());
-		bool final_tuple = tuple_count + 1 >= vector_size;
-		CompressString(string, final_tuple);
-
-		tuple_count++;
-		if (tuple_count == vector_size) {
-			// Reached the end of this vector
-			FlushVector();
-		}
-
-		UncompressedStringStorage::UpdateStringStats(segment->stats, string);
-	}
-
-	void NewPage(bool additional_data_page = false) {
-		block_id_t new_id = FinalizePage();
-		block_id_t current_block_id = block_id;
-		auto &buffer = GetExtraPageBuffer(current_block_id);
-		block_id = new_id;
-		SetCurrentBuffer(buffer);
-		ResetOutBuffer();
-	}
-
-	block_id_t FinalizePage() {
-		auto &block_manager = partial_block_manager.GetBlockManager();
-		auto new_id = block_manager.GetFreeBlockId();
-		auto &state = segment->GetSegmentState()->Cast<UncompressedStringSegmentState>();
-		state.RegisterBlock(block_manager, new_id);
-
-		D_ASSERT(GetCurrentOffset() <= GetWritableSpace(info));
-
-		// Write the new id at the end of the last page
-		Store<block_id_t>(new_id, current_buffer_ptr);
-		current_buffer_ptr += sizeof(block_id_t);
-		return new_id;
-	}
-
-	void FlushPage(BufferHandle &buffer, block_id_t block_id) {
-		if (block_id == INVALID_BLOCK) {
-			return;
-		}
-
-		// Write the current page to disk
-		auto &block_manager = partial_block_manager.GetBlockManager();
-		block_manager.Write(buffer.GetFileBuffer(), block_id);
-		{
-			auto lock = partial_block_manager.GetLock();
-			partial_block_manager.AddWrittenBlock(block_id);
-		}
-	}
-
-	void FlushVector() {
-		// Write the metadata for this Vector
-		page_ids[vector_in_segment_count] = starting_page;
-		page_offsets[vector_in_segment_count] = starting_offset;
-		compressed_sizes[vector_in_segment_count] = compressed_size;
-		uncompressed_sizes[vector_in_segment_count] = uncompressed_size;
-		vector_count++;
-		vector_in_segment_count++;
-		in_vector = false;
-		segment->count += tuple_count;
-
-		const bool is_last_vector = vector_count == total_vector_count;
-		tuple_count = 0;
-		if (is_last_vector) {
-			FlushPage(*current_buffer, block_id);
-			if (starting_page != block_id) {
-				FlushPage(*vector_lengths_buffer, starting_page);
-			}
-		} else {
-			if (vector_lengths_buffer == current_buffer) {
-				// We did not cross a page boundary writing this vector
-				return;
-			}
-			// Flush the page that holds the vector lengths
-			FlushPage(*vector_lengths_buffer, starting_page);
-		}
-	}
-
-	page_id_t GetCurrentId() {
-		if (&segment_handle == current_buffer.get()) {
-			return INVALID_BLOCK;
-		}
-		return block_id;
-	}
-
-	page_offset_t GetCurrentOffset() {
-		auto &handle = *current_buffer;
-		auto start_of_buffer = handle.Ptr();
-		D_ASSERT(current_buffer_ptr >= start_of_buffer);
-		auto res = (page_offset_t)(current_buffer_ptr - start_of_buffer);
-		D_ASSERT(res <= GetWritableSpace(info));
-		return res;
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpoint_data.GetDatabase();
-		auto &type = checkpoint_data.GetType();
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start,
-		                                                                info.GetBlockSize(), info.GetBlockSize());
-		segment = std::move(compressed_segment);
-
-		auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase());
-		segment_handle = buffer_manager.Pin(segment->block);
-	}
-
-	void FlushSegment() {
-		auto &state = checkpoint_data.GetCheckpointState();
-		idx_t segment_block_size;
-
-		if (current_buffer.get() == &segment_handle) {
-			segment_block_size = GetCurrentOffset();
-		} else {
-			// Block is fully used
-			segment_block_size = info.GetBlockSize();
-		}
-
-		state.FlushSegment(std::move(segment), std::move(segment_handle), segment_block_size);
-		segment_count++;
-		vector_in_segment_count = 0;
-	}
-
-	void Finalize() {
-		D_ASSERT(!tuple_count);
-		FlushSegment();
-		segment.reset();
-	}
-
-	void AddNull() {
-		AddString("");
-	}
-
-public:
-	unique_ptr<ZSTDAnalyzeState> analyze_state;
-	ColumnDataCheckpointData &checkpoint_data;
-	PartialBlockManager &partial_block_manager;
-	CompressionFunction &function;
-
-	// The segment state
-	//! Current segment index we're at
-	idx_t segment_count = 0;
-	//! The total amount of segments we're writing
-	idx_t total_segment_count = 0;
-	//! The vectors to store in the last segment
-	idx_t vectors_in_last_segment = 0;
-	//! The vectors to store in a segment (not the last one)
-	idx_t vectors_per_segment = 0;
-	unique_ptr<ColumnSegment> segment;
-	BufferHandle segment_handle;
-
-	// Non-segment buffers
-	BufferHandle extra_pages[2];
-	block_id_t block_id = INVALID_BLOCK;
-
-	// Current block state
-	optional_ptr<BufferHandle> current_buffer;
-	//! The buffer that contains the vector lengths
-	optional_ptr<BufferHandle> vector_lengths_buffer;
-	data_ptr_t current_buffer_ptr;
-
-	//===--------------------------------------------------------------------===//
-	// Vector metadata
-	//===--------------------------------------------------------------------===//
-	page_id_t starting_page;
-	page_offset_t starting_offset;
-
-	page_id_t *page_ids;
-	page_offset_t *page_offsets;
-	uncompressed_size_t *uncompressed_sizes;
-	compressed_size_t *compressed_sizes;
-	//! The amount of vectors we've seen so far
-	idx_t vector_count = 0;
-	//! The amount of vectors we've seen in the current segment
-	idx_t vector_in_segment_count = 0;
-	//! The amount of vectors we're writing
-	idx_t total_vector_count = 0;
-	//! Whether we are currently in a Vector
-	bool in_vector = false;
-	//! The compression context indicating where we are in the output buffer
-	duckdb_zstd::ZSTD_outBuffer out_buffer;
-	idx_t uncompressed_size = 0;
-	idx_t compressed_size = 0;
-	string_length_t *string_lengths;
-
-	//! Amount of tuples we have seen for the current vector
-	idx_t tuple_count = 0;
-	//! The expected size of this vector (ZSTD_VECTOR_SIZE except for the last one)
-	idx_t vector_size;
-};
-
-unique_ptr<CompressionState> ZSTDStorage::InitCompression(ColumnDataCheckpointData &checkpoint_data,
-                                                          unique_ptr<AnalyzeState> analyze_state_p) {
-	return make_uniq<ZSTDCompressionState>(checkpoint_data,
-	                                       unique_ptr_cast<AnalyzeState, ZSTDAnalyzeState>(std::move(analyze_state_p)));
-}
-
-void ZSTDStorage::Compress(CompressionState &state_p, Vector &input, idx_t count) {
-	auto &state = state_p.Cast<ZSTDCompressionState>();
-
-	// Get vector data
-	UnifiedVectorFormat vdata;
-	input.ToUnifiedFormat(count, vdata);
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		// Note: we treat nulls and empty strings the same
-		if (!vdata.validity.RowIsValid(idx) || data[idx].GetSize() == 0) {
-			state.AddNull();
-			continue;
-		}
-		state.AddString(data[idx]);
-	}
-}
-
-void ZSTDStorage::FinalizeCompress(CompressionState &state_p) {
-	auto &state = state_p.Cast<ZSTDCompressionState>();
-	state.Finalize();
-}
-
-struct ZSTDVectorScanMetadata {
-	//! The index of the (internal) vector being read
-	idx_t vector_idx;
-	block_id_t block_id;
-	page_offset_t block_offset;
-
-	uncompressed_size_t uncompressed_size;
-	compressed_size_t compressed_size;
-
-	//! The amount of tuples that are in this Vector
-	idx_t count;
-};
-
-struct ZSTDVectorScanState {
-public:
-	ZSTDVectorScanState() {
-	}
-	ZSTDVectorScanState(ZSTDVectorScanState &&other) = default;
-	ZSTDVectorScanState(const ZSTDVectorScanState &other) = delete;
-
-public:
-	//! The metadata of the vector
-	ZSTDVectorScanMetadata metadata;
-	//! The (pinned) buffer handle(s) for this vectors data
-	vector<BufferHandle> buffer_handles;
-	//! The current pointer at which we're reading the vectors data
-	data_ptr_t current_buffer_ptr;
-	//! The (uncompressed) string lengths for this vector
-	string_length_t *string_lengths;
-	//! The amount of values already consumed from the state
-	idx_t scanned_count = 0;
-	//! The amount of compressed data read
-	idx_t compressed_scan_count = 0;
-	//! The inBuffer that ZSTD_decompressStream reads the compressed data from
-	duckdb_zstd::ZSTD_inBuffer in_buffer;
-};
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct ZSTDScanState : public SegmentScanState {
-public:
-	explicit ZSTDScanState(ColumnSegment &segment)
-	    : state(segment.GetSegmentState()->Cast<UncompressedStringSegmentState>()),
-	      block_manager(segment.GetBlockManager()), buffer_manager(BufferManager::GetBufferManager(segment.db)),
-	      segment_block_offset(segment.GetBlockOffset()) {
-		decompression_context = duckdb_zstd::ZSTD_createDCtx();
-		segment_handle = buffer_manager.Pin(segment.block);
-
-		auto data = segment_handle.Ptr() + segment.GetBlockOffset();
-		idx_t offset = 0;
-
-		segment_count = segment.count.load();
-		idx_t amount_of_vectors = (segment_count / ZSTD_VECTOR_SIZE) + ((segment_count % ZSTD_VECTOR_SIZE) != 0);
-
-		// Set pointers to the Vector Metadata
-		offset = AlignValue<idx_t, sizeof(page_id_t)>(offset);
-		page_ids = reinterpret_cast<page_id_t *>(data + offset);
-		offset += (sizeof(page_id_t) * amount_of_vectors);
-
-		offset = AlignValue<idx_t, sizeof(page_offset_t)>(offset);
-		page_offsets = reinterpret_cast<page_offset_t *>(data + offset);
-		offset += (sizeof(page_offset_t) * amount_of_vectors);
-
-		offset = AlignValue<idx_t, sizeof(uncompressed_size_t)>(offset);
-		uncompressed_sizes = reinterpret_cast<uncompressed_size_t *>(data + offset);
-		offset += (sizeof(uncompressed_size_t) * amount_of_vectors);
-
-		offset = AlignValue<idx_t, sizeof(compressed_size_t)>(offset);
-		compressed_sizes = reinterpret_cast<compressed_size_t *>(data + offset);
-		offset += (sizeof(compressed_size_t) * amount_of_vectors);
-
-		scanned_count = 0;
-	}
-	~ZSTDScanState() override {
-		duckdb_zstd::ZSTD_freeDCtx(decompression_context);
-	}
-
-public:
-	idx_t GetVectorIndex(idx_t start_index, idx_t &offset) {
-		idx_t vector_idx = start_index / ZSTD_VECTOR_SIZE;
-		offset = start_index % ZSTD_VECTOR_SIZE;
-		return vector_idx;
-	}
-
-	ZSTDVectorScanMetadata GetVectorMetadata(idx_t vector_idx) {
-		idx_t previous_value_count = vector_idx * ZSTD_VECTOR_SIZE;
-		idx_t value_count = MinValue<idx_t>(segment_count - previous_value_count, ZSTD_VECTOR_SIZE);
-
-		return ZSTDVectorScanMetadata {/* vector_idx = */ vector_idx,
-		                               /* block_id = */ page_ids[vector_idx],
-		                               /* block_offset = */ page_offsets[vector_idx],
-		                               /* uncompressed_size = */ uncompressed_sizes[vector_idx],
-		                               /* compressed_size = */ compressed_sizes[vector_idx],
-		                               /* count = */ value_count};
-	}
-
-	shared_ptr<BlockHandle> LoadPage(block_id_t block_id) {
-		return state.GetHandle(block_manager, block_id);
-	}
-
-	bool UseVectorStateCache(idx_t vector_idx, idx_t internal_offset) {
-		if (!current_vector) {
-			// No vector loaded yet
-			return false;
-		}
-		if (current_vector->metadata.vector_idx != vector_idx) {
-			// Not the same vector
-			return false;
-		}
-		if (current_vector->scanned_count != internal_offset) {
-			// Not the same scan offset
-			return false;
-		}
-		return true;
-	}
-
-	ZSTDVectorScanState &LoadVector(idx_t vector_idx, idx_t internal_offset) {
-		if (UseVectorStateCache(vector_idx, internal_offset)) {
-			return *current_vector;
-		}
-		current_vector = make_uniq<ZSTDVectorScanState>();
-		current_vector->metadata = GetVectorMetadata(vector_idx);
-		auto &metadata = current_vector->metadata;
-		auto &scan_state = *current_vector;
-		data_ptr_t handle_start;
-		idx_t ptr_offset = 0;
-		if (metadata.block_id == INVALID_BLOCK) {
-			// Data lives on the segment's page
-			handle_start = segment_handle.Ptr();
-			ptr_offset += segment_block_offset;
-		} else {
-			// Data lives on an extra page, have to load the block first
-			auto block = LoadPage(metadata.block_id);
-			auto data_handle = buffer_manager.Pin(block);
-			handle_start = data_handle.Ptr();
-			scan_state.buffer_handles.push_back(std::move(data_handle));
-		}
-
-		ptr_offset += metadata.block_offset;
-		ptr_offset = AlignValue<idx_t, sizeof(string_length_t)>(ptr_offset);
-		scan_state.current_buffer_ptr = handle_start + ptr_offset;
-
-		auto vector_size = metadata.count;
-
-		scan_state.string_lengths = reinterpret_cast<string_length_t *>(scan_state.current_buffer_ptr);
-		scan_state.current_buffer_ptr += (sizeof(string_length_t) * vector_size);
-
-		// Update the in_buffer to point to the start of the compressed data frame
-		idx_t current_offset = UnsafeNumericCast<idx_t>(scan_state.current_buffer_ptr - handle_start);
-		scan_state.in_buffer.src = scan_state.current_buffer_ptr;
-		scan_state.in_buffer.pos = 0;
-		scan_state.in_buffer.size = block_manager.GetBlockSize() - sizeof(block_id_t) - current_offset;
-
-		// Initialize the context for streaming decompression
-		duckdb_zstd::ZSTD_DCtx_reset(decompression_context, duckdb_zstd::ZSTD_reset_session_only);
-		duckdb_zstd::ZSTD_DCtx_refDDict(decompression_context, nullptr);
-
-		if (internal_offset) {
-			Skip(scan_state, internal_offset);
-		}
-		return scan_state;
-	}
-
-	void LoadNextPageForVector(ZSTDVectorScanState &scan_state) {
-		if (scan_state.in_buffer.pos != scan_state.in_buffer.size) {
-			throw InternalException(
-			    "(ZSTDScanState::LoadNextPageForVector) Trying to load the next page before consuming the current one");
-		}
-		// Read the next block id from the end of the page
-		auto base_ptr =
-		    reinterpret_cast<data_ptr_t>(const_cast<void *>(scan_state.in_buffer.src)); // NOLINT: const cast
-		auto next_id_ptr = base_ptr + scan_state.in_buffer.size;
-		block_id_t next_id = Load<block_id_t>(next_id_ptr);
-
-		// Load the next page
-		auto block = LoadPage(next_id);
-		auto handle = buffer_manager.Pin(block);
-		auto ptr = handle.Ptr();
-		scan_state.buffer_handles.push_back(std::move(handle));
-		scan_state.current_buffer_ptr = ptr;
-
-		// Update the in_buffer to point to the new page
-		scan_state.in_buffer.src = ptr;
-		scan_state.in_buffer.pos = 0;
-
-		idx_t page_size = block_manager.GetBlockSize() - sizeof(block_id_t);
-		idx_t remaining_compressed_data = scan_state.metadata.compressed_size - scan_state.compressed_scan_count;
-		scan_state.in_buffer.size = MinValue<idx_t>(page_size, remaining_compressed_data);
-	}
-
-	void DecompressString(ZSTDVectorScanState &scan_state, data_ptr_t destination, idx_t uncompressed_length) {
-		if (uncompressed_length == 0) {
-			return;
-		}
-
-		duckdb_zstd::ZSTD_outBuffer out_buffer;
-
-		out_buffer.dst = destination;
-		out_buffer.pos = 0;
-		out_buffer.size = uncompressed_length;
-
-		while (true) {
-			idx_t old_pos = scan_state.in_buffer.pos;
-			size_t res = duckdb_zstd::ZSTD_decompressStream(
-			    /* zds = */ decompression_context,
-			    /* output =*/&out_buffer,
-			    /* input =*/&scan_state.in_buffer);
-			scan_state.compressed_scan_count += scan_state.in_buffer.pos - old_pos;
-			if (duckdb_zstd::ZSTD_isError(res)) {
-				throw InvalidInputException("ZSTD Decompression failed: %s", duckdb_zstd::ZSTD_getErrorName(res));
-			}
-			if (out_buffer.pos == out_buffer.size) {
-				break;
-			}
-			// Did not fully decompress, it needs a new page to read from
-			LoadNextPageForVector(scan_state);
-		}
-	}
-
-	void Skip(ZSTDVectorScanState &scan_state, idx_t count) {
-		if (!skip_buffer) {
-			skip_buffer = Allocator::DefaultAllocator().Allocate(duckdb_zstd::ZSTD_DStreamOutSize());
-		}
-
-		D_ASSERT(scan_state.scanned_count + count <= scan_state.metadata.count);
-
-		// Figure out how much we need to skip
-		string_length_t *string_lengths = &scan_state.string_lengths[scan_state.scanned_count];
-		idx_t uncompressed_length = 0;
-		for (idx_t i = 0; i < count; i++) {
-			uncompressed_length += string_lengths[i];
-		}
-
-		// Skip that many bytes by decompressing into the skip_buffer
-		idx_t remaining = uncompressed_length;
-		while (remaining) {
-			idx_t to_scan = MinValue<idx_t>(skip_buffer.GetSize(), remaining);
-			DecompressString(scan_state, skip_buffer.get(), to_scan);
-			remaining -= to_scan;
-		}
-		scan_state.scanned_count += count;
-		scanned_count += count;
-	}
-
-	void ScanInternal(ZSTDVectorScanState &scan_state, idx_t count, Vector &result, idx_t result_offset) {
-		D_ASSERT(scan_state.scanned_count + count <= scan_state.metadata.count);
-		D_ASSERT(result.GetType().InternalType() == PhysicalType::VARCHAR);
-
-		string_length_t *string_lengths = &scan_state.string_lengths[scan_state.scanned_count];
-		idx_t uncompressed_length = 0;
-		for (idx_t i = 0; i < count; i++) {
-			uncompressed_length += string_lengths[i];
-		}
-		auto empty_string = StringVector::EmptyString(result, uncompressed_length);
-		auto uncompressed_data = empty_string.GetDataWriteable();
-		auto string_data = FlatVector::GetData<string_t>(result);
-
-		DecompressString(scan_state, reinterpret_cast<data_ptr_t>(uncompressed_data), uncompressed_length);
-
-		idx_t offset = 0;
-		auto uncompressed_data_const = empty_string.GetData();
-		for (idx_t i = 0; i < count; i++) {
-			string_data[result_offset + i] = string_t(uncompressed_data_const + offset, string_lengths[i]);
-			offset += string_lengths[i];
-		}
-		scan_state.scanned_count += count;
-		scanned_count += count;
-	}
-
-	void ScanPartial(idx_t start_idx, Vector &result, idx_t offset, idx_t count) {
-		idx_t remaining = count;
-		idx_t scanned = 0;
-		while (remaining) {
-			idx_t internal_offset;
-			idx_t vector_idx = GetVectorIndex(start_idx + scanned, internal_offset);
-			auto &scan_state = LoadVector(vector_idx, internal_offset);
-			idx_t remaining_in_vector = scan_state.metadata.count - scan_state.scanned_count;
-			idx_t to_scan = MinValue<idx_t>(remaining, remaining_in_vector);
-			ScanInternal(scan_state, to_scan, result, offset + scanned);
-			remaining -= to_scan;
-			scanned += to_scan;
-		}
-		D_ASSERT(scanned == count);
-	}
-
-public:
-	UncompressedStringSegmentState &state;
-	BlockManager &block_manager;
-	BufferManager &buffer_manager;
-
-	duckdb_zstd::ZSTD_DCtx *decompression_context = nullptr;
-
-	idx_t segment_block_offset;
-	BufferHandle segment_handle;
-
-	//===--------------------------------------------------------------------===//
-	// Vector metadata
-	//===--------------------------------------------------------------------===//
-	page_id_t *page_ids;
-	page_offset_t *page_offsets;
-	uncompressed_size_t *uncompressed_sizes;
-	compressed_size_t *compressed_sizes;
-
-	//! Cache of (the scan state of) the current vector being read
-	unique_ptr<ZSTDVectorScanState> current_vector;
-
-	//! The amount of tuples stored in the segment
-	idx_t segment_count;
-	//! The amount of tuples consumed
-	idx_t scanned_count = 0;
-
-	//! Buffer for skipping data
-	AllocatedData skip_buffer;
-};
-
-unique_ptr<SegmentScanState> ZSTDStorage::StringInitScan(ColumnSegment &segment) {
-	auto result = make_uniq<ZSTDScanState>(segment);
-	return std::move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void ZSTDStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                                    idx_t result_offset) {
-	auto &scan_state = state.scan_state->template Cast<ZSTDScanState>();
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	scan_state.ScanPartial(start, result, result_offset, scan_count);
-}
-
-void ZSTDStorage::StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	StringScanPartial(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ZSTDStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                                 idx_t result_idx) {
-	ZSTDScanState scan_state(segment);
-	scan_state.ScanPartial(UnsafeNumericCast<idx_t>(row_id), result, result_idx, 1);
-}
-
-//===--------------------------------------------------------------------===//
-// Serialization & Cleanup
-//===--------------------------------------------------------------------===//
-
-unique_ptr<CompressedSegmentState> ZSTDStorage::StringInitSegment(ColumnSegment &segment, block_id_t block_id,
-                                                                  optional_ptr<ColumnSegmentState> segment_state) {
-	auto result = make_uniq<UncompressedStringSegmentState>();
-	if (segment_state) {
-		auto &serialized_state = segment_state->Cast<SerializedStringSegmentState>();
-		result->on_disk_blocks = std::move(serialized_state.blocks);
-	}
-	return std::move(result);
-}
-
-unique_ptr<ColumnSegmentState> ZSTDStorage::SerializeState(ColumnSegment &segment) {
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-	if (state.on_disk_blocks.empty()) {
-		// no on-disk blocks - nothing to write
-		return nullptr;
-	}
-	return make_uniq<SerializedStringSegmentState>(state.on_disk_blocks);
-}
-
-unique_ptr<ColumnSegmentState> ZSTDStorage::DeserializeState(Deserializer &deserializer) {
-	auto result = make_uniq<SerializedStringSegmentState>();
-	deserializer.ReadProperty(1, "overflow_blocks", result->blocks);
-	return std::move(result);
-}
-
-void ZSTDStorage::CleanupState(ColumnSegment &segment) {
-	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
-	auto &block_manager = segment.GetBlockManager();
-	for (auto &block_id : state.on_disk_blocks) {
-		block_manager.MarkBlockAsModified(block_id);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction ZSTDFun::GetFunction(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::VARCHAR);
-	auto zstd = CompressionFunction(
-	    CompressionType::COMPRESSION_ZSTD, data_type, ZSTDStorage::StringInitAnalyze, ZSTDStorage::StringAnalyze,
-	    ZSTDStorage::StringFinalAnalyze, ZSTDStorage::InitCompression, ZSTDStorage::Compress,
-	    ZSTDStorage::FinalizeCompress, ZSTDStorage::StringInitScan, ZSTDStorage::StringScan,
-	    ZSTDStorage::StringScanPartial, ZSTDStorage::StringFetchRow, ZSTDStorage::StringSkip);
-	zstd.init_segment = ZSTDStorage::StringInitSegment;
-	zstd.serialize_state = ZSTDStorage::SerializeState;
-	zstd.deserialize_state = ZSTDStorage::DeserializeState;
-	zstd.cleanup_state = ZSTDStorage::CleanupState;
-	return zstd;
-}
-
-bool ZSTDFun::TypeIsSupported(PhysicalType type) {
-	return type == PhysicalType::VARCHAR;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/data_pointer.cpp b/src/duckdb/src/storage/data_pointer.cpp
deleted file mode 100644
index 04ab0bff5..000000000
--- a/src/duckdb/src/storage/data_pointer.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/function/compression_function.hpp"
-
-namespace duckdb {
-
-DataPointer::DataPointer(BaseStatistics stats) : statistics(std::move(stats)) {
-}
-
-DataPointer::DataPointer(DataPointer &&other) noexcept : statistics(std::move(other.statistics)) {
-	std::swap(row_start, other.row_start);
-	std::swap(tuple_count, other.tuple_count);
-	std::swap(block_pointer, other.block_pointer);
-	std::swap(compression_type, other.compression_type);
-	std::swap(segment_state, other.segment_state);
-}
-
-DataPointer &DataPointer::operator=(DataPointer &&other) noexcept {
-	std::swap(row_start, other.row_start);
-	std::swap(tuple_count, other.tuple_count);
-	std::swap(block_pointer, other.block_pointer);
-	std::swap(compression_type, other.compression_type);
-	std::swap(statistics, other.statistics);
-	std::swap(segment_state, other.segment_state);
-	return *this;
-}
-
-unique_ptr<ColumnSegmentState> ColumnSegmentState::Deserialize(Deserializer &deserializer) {
-	auto compression_type = deserializer.Get<CompressionType>();
-	auto &db = deserializer.Get<DatabaseInstance &>();
-	auto &type = deserializer.Get<const LogicalType &>();
-
-	auto compression_function = DBConfig::GetConfig(db).GetCompressionFunction(compression_type, type.InternalType());
-	if (!compression_function || !compression_function->deserialize_state) {
-		throw SerializationException("Deserializing a ColumnSegmentState but could not find deserialize method");
-	}
-	return compression_function->deserialize_state(deserializer);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/data_table.cpp b/src/duckdb/src/storage/data_table.cpp
deleted file mode 100644
index 81bf50100..000000000
--- a/src/duckdb/src/storage/data_table.cpp
+++ /dev/null
@@ -1,1609 +0,0 @@
-#include "duckdb/storage/data_table.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/conflict_manager.hpp"
-#include "duckdb/common/types/constraint_conflict_info.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/planner/constraints/list.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_binder/check_binder.hpp"
-#include "duckdb/planner/expression_binder/constant_binder.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/delete_state.hpp"
-#include "duckdb/storage/table/persistent_table_data.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/standard_column_data.hpp"
-#include "duckdb/storage/table/update_state.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-namespace duckdb {
-
-DataTableInfo::DataTableInfo(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, string schema,
-                             string table)
-    : db(db), table_io_manager(std::move(table_io_manager_p)), schema(std::move(schema)), table(std::move(table)) {
-}
-
-void DataTableInfo::InitializeIndexes(ClientContext &context, const char *index_type) {
-	indexes.InitializeIndexes(context, *this, index_type);
-}
-
-bool DataTableInfo::IsTemporary() const {
-	return db.IsTemporary();
-}
-
-DataTable::DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, const string &schema,
-                     const string &table, vector<ColumnDefinition> column_definitions_p,
-                     unique_ptr<PersistentTableData> data)
-    : db(db), info(make_shared_ptr<DataTableInfo>(db, std::move(table_io_manager_p), schema, table)),
-      column_definitions(std::move(column_definitions_p)), is_root(true) {
-	// initialize the table with the existing data from disk, if any
-	auto types = GetTypes();
-	auto &io_manager = TableIOManager::Get(*this);
-	this->row_groups = make_shared_ptr<RowGroupCollection>(info, io_manager, types, 0);
-	if (data && data->row_group_count > 0) {
-		this->row_groups->Initialize(*data);
-	} else {
-		this->row_groups->InitializeEmpty();
-		D_ASSERT(row_groups->GetTotalRows() == 0);
-	}
-	row_groups->Verify();
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression &default_value)
-    : db(parent.db), info(parent.info), is_root(true) {
-	// add the column definitions from this DataTable
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-	column_definitions.emplace_back(new_column.Copy());
-
-	auto &local_storage = LocalStorage::Get(context, db);
-
-	ExpressionExecutor default_executor(context);
-	default_executor.AddExpression(default_value);
-
-	// prevent any new tuples from being added to the parent
-	lock_guard<mutex> parent_lock(parent.append_lock);
-
-	this->row_groups = parent.row_groups->AddColumn(context, new_column, default_executor);
-
-	// also add this column to client local storage
-	local_storage.AddColumn(parent, *this, new_column, default_executor);
-
-	// this table replaces the previous table, hence the parent is no longer the root DataTable
-	parent.is_root = false;
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t removed_column)
-    : db(parent.db), info(parent.info), is_root(true) {
-	// prevent any new tuples from being added to the parent
-	auto &local_storage = LocalStorage::Get(context, db);
-	lock_guard<mutex> parent_lock(parent.append_lock);
-
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-
-	info->InitializeIndexes(context);
-
-	// first check if there are any indexes that exist that point to the removed column
-	info->indexes.Scan([&](Index &index) {
-		for (auto &column_id : index.GetColumnIds()) {
-			if (column_id == removed_column) {
-				throw CatalogException("Cannot drop this column: an index depends on it!");
-			} else if (column_id > removed_column) {
-				throw CatalogException("Cannot drop this column: an index depends on a column after it!");
-			}
-		}
-		return false;
-	});
-
-	// erase the column definitions from this DataTable
-	D_ASSERT(removed_column < column_definitions.size());
-	column_definitions.erase_at(removed_column);
-
-	storage_t storage_idx = 0;
-	for (idx_t i = 0; i < column_definitions.size(); i++) {
-		auto &col = column_definitions[i];
-		col.SetOid(i);
-		if (col.Generated()) {
-			continue;
-		}
-		col.SetStorageOid(storage_idx++);
-	}
-
-	// alter the row_groups and remove the column from each of them
-	this->row_groups = parent.row_groups->RemoveColumn(removed_column);
-
-	// scan the original table, and fill the new column with the transformed value
-	local_storage.DropColumn(parent, *this, removed_column);
-
-	// this table replaces the previous table, hence the parent is no longer the root DataTable
-	parent.is_root = false;
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, BoundConstraint &constraint)
-    : db(parent.db), info(parent.info), row_groups(parent.row_groups), is_root(true) {
-
-	// ALTER COLUMN to add a new constraint.
-
-	// Clone the storage info vector or the table.
-	for (const auto &index_info : parent.info->index_storage_infos) {
-		info->index_storage_infos.push_back(IndexStorageInfo(index_info.name));
-	}
-	info->InitializeIndexes(context);
-
-	auto &local_storage = LocalStorage::Get(context, db);
-	lock_guard<mutex> parent_lock(parent.append_lock);
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-
-	if (constraint.type != ConstraintType::UNIQUE) {
-		VerifyNewConstraint(local_storage, parent, constraint);
-	}
-	local_storage.MoveStorage(parent, *this);
-	parent.is_root = false;
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_idx, const LogicalType &target_type,
-                     const vector<StorageIndex> &bound_columns, Expression &cast_expr)
-    : db(parent.db), info(parent.info), is_root(true) {
-	auto &local_storage = LocalStorage::Get(context, db);
-	// prevent any tuples from being added to the parent
-	lock_guard<mutex> lock(append_lock);
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-
-	info->InitializeIndexes(context);
-
-	// first check if there are any indexes that exist that point to the changed column
-	info->indexes.Scan([&](Index &index) {
-		for (auto &column_id : index.GetColumnIds()) {
-			if (column_id == changed_idx) {
-				throw CatalogException("Cannot change the type of this column: an index depends on it!");
-			}
-		}
-		return false;
-	});
-
-	// change the type in this DataTable
-	column_definitions[changed_idx].SetType(target_type);
-
-	// set up the statistics for the table
-	// the column that had its type changed will have the new statistics computed during conversion
-	this->row_groups = parent.row_groups->AlterType(context, changed_idx, target_type, bound_columns, cast_expr);
-
-	// scan the original table, and fill the new column with the transformed value
-	local_storage.ChangeType(parent, *this, changed_idx, target_type, bound_columns, cast_expr);
-
-	// this table replaces the previous table, hence the parent is no longer the root DataTable
-	parent.is_root = false;
-}
-
-vector<LogicalType> DataTable::GetTypes() {
-	vector<LogicalType> types;
-	for (auto &it : column_definitions) {
-		types.push_back(it.Type());
-	}
-	return types;
-}
-
-bool DataTable::IsTemporary() const {
-	return info->IsTemporary();
-}
-
-AttachedDatabase &DataTable::GetAttached() {
-	D_ASSERT(RefersToSameObject(db, info->db));
-	return db;
-}
-
-const vector<ColumnDefinition> &DataTable::Columns() const {
-	return column_definitions;
-}
-
-TableIOManager &DataTable::GetTableIOManager() {
-	return *info->table_io_manager;
-}
-
-TableIOManager &TableIOManager::Get(DataTable &table) {
-	return table.GetTableIOManager();
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void DataTable::InitializeScan(DuckTransaction &transaction, TableScanState &state,
-                               const vector<StorageIndex> &column_ids, TableFilterSet *table_filters) {
-	state.checkpoint_lock = transaction.SharedLockTable(*info);
-	auto &local_storage = LocalStorage::Get(transaction);
-	state.Initialize(column_ids, table_filters);
-	row_groups->InitializeScan(state.table_state, column_ids, table_filters);
-	local_storage.InitializeScan(*this, state.local_state, table_filters);
-}
-
-void DataTable::InitializeScanWithOffset(DuckTransaction &transaction, TableScanState &state,
-                                         const vector<StorageIndex> &column_ids, idx_t start_row, idx_t end_row) {
-	state.checkpoint_lock = transaction.SharedLockTable(*info);
-	state.Initialize(column_ids);
-	row_groups->InitializeScanWithOffset(state.table_state, column_ids, start_row, end_row);
-}
-
-idx_t DataTable::GetRowGroupSize() const {
-	return row_groups->GetRowGroupSize();
-}
-
-vector<PartitionStatistics> DataTable::GetPartitionStats(ClientContext &context) {
-	auto result = row_groups->GetPartitionStats();
-	auto &local_storage = LocalStorage::Get(context, db);
-	auto local_partitions = local_storage.GetPartitionStats(*this);
-	result.insert(result.end(), local_partitions.begin(), local_partitions.end());
-	return result;
-}
-
-idx_t DataTable::MaxThreads(ClientContext &context) const {
-	idx_t row_group_size = GetRowGroupSize();
-	idx_t parallel_scan_vector_count = row_group_size / STANDARD_VECTOR_SIZE;
-	if (ClientConfig::GetConfig(context).verify_parallelism) {
-		parallel_scan_vector_count = 1;
-	}
-	idx_t parallel_scan_tuple_count = STANDARD_VECTOR_SIZE * parallel_scan_vector_count;
-	return GetTotalRows() / parallel_scan_tuple_count + 1;
-}
-
-void DataTable::InitializeParallelScan(ClientContext &context, ParallelTableScanState &state) {
-	auto &local_storage = LocalStorage::Get(context, db);
-	auto &transaction = DuckTransaction::Get(context, db);
-	state.checkpoint_lock = transaction.SharedLockTable(*info);
-	row_groups->InitializeParallelScan(state.scan_state);
-
-	local_storage.InitializeParallelScan(*this, state.local_state);
-}
-
-bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState &state, TableScanState &scan_state) {
-	if (row_groups->NextParallelScan(context, state.scan_state, scan_state.table_state)) {
-		return true;
-	}
-	auto &local_storage = LocalStorage::Get(context, db);
-	if (local_storage.NextParallelScan(context, *this, state.local_state, scan_state.local_state)) {
-		return true;
-	} else {
-		// finished all scans: no more scans remaining
-		return false;
-	}
-}
-
-void DataTable::Scan(DuckTransaction &transaction, DataChunk &result, TableScanState &state) {
-	// scan the persistent segments
-	if (state.table_state.Scan(transaction, result)) {
-		D_ASSERT(result.size() > 0);
-		return;
-	}
-
-	// scan the transaction-local segments
-	auto &local_storage = LocalStorage::Get(transaction);
-	local_storage.Scan(state.local_state, state.GetColumnIds(), result);
-}
-
-bool DataTable::CreateIndexScan(TableScanState &state, DataChunk &result, TableScanType type) {
-	return state.table_state.ScanCommitted(result, type);
-}
-
-//===--------------------------------------------------------------------===//
-// Index Methods
-//===--------------------------------------------------------------------===//
-shared_ptr<DataTableInfo> &DataTable::GetDataTableInfo() {
-	return info;
-}
-
-void DataTable::InitializeIndexes(ClientContext &context) {
-	info->InitializeIndexes(context);
-}
-
-bool DataTable::HasIndexes() const {
-	return !info->indexes.Empty();
-}
-
-bool DataTable::HasUniqueIndexes() const {
-	if (!HasIndexes()) {
-		return false;
-	}
-	bool has_unique_index = false;
-	info->indexes.Scan([&](Index &index) {
-		if (index.IsUnique()) {
-			has_unique_index = true;
-			return true;
-		}
-		return false;
-	});
-	return has_unique_index;
-}
-
-void DataTable::AddIndex(unique_ptr<Index> index) {
-	info->indexes.AddIndex(std::move(index));
-}
-
-bool DataTable::HasForeignKeyIndex(const vector<PhysicalIndex> &keys, ForeignKeyType type) {
-	return info->indexes.FindForeignKeyIndex(keys, type) != nullptr;
-}
-
-void DataTable::SetIndexStorageInfo(vector<IndexStorageInfo> index_storage_info) {
-	info->index_storage_infos = std::move(index_storage_info);
-}
-
-void DataTable::VacuumIndexes() {
-	info->indexes.Scan([&](Index &index) {
-		if (index.IsBound()) {
-			index.Cast<BoundIndex>().Vacuum();
-		}
-		return false;
-	});
-}
-
-void DataTable::CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_t count) {
-	row_groups->CleanupAppend(lowest_transaction, start, count);
-}
-
-bool DataTable::IndexNameIsUnique(const string &name) {
-	return info->indexes.NameIsUnique(name);
-}
-
-string DataTableInfo::GetSchemaName() {
-	return schema;
-}
-
-string DataTableInfo::GetTableName() {
-	lock_guard<mutex> l(name_lock);
-	return table;
-}
-
-void DataTableInfo::SetTableName(string name) {
-	lock_guard<mutex> l(name_lock);
-	table = std::move(name);
-}
-
-string DataTable::GetTableName() const {
-	return info->GetTableName();
-}
-
-void DataTable::SetTableName(string new_name) {
-	info->SetTableName(std::move(new_name));
-}
-
-TableStorageInfo DataTable::GetStorageInfo() {
-	TableStorageInfo result;
-	result.cardinality = GetTotalRows();
-	info->indexes.Scan([&](Index &index) {
-		IndexInfo index_info;
-		index_info.is_primary = index.IsPrimary();
-		index_info.is_unique = index.IsUnique() || index_info.is_primary;
-		index_info.is_foreign = index.IsForeign();
-		index_info.column_set = index.GetColumnIdSet();
-		result.index_info.push_back(std::move(index_info));
-		return false;
-	});
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void DataTable::Fetch(DuckTransaction &transaction, DataChunk &result, const vector<StorageIndex> &column_ids,
-                      const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) {
-	auto lock = info->checkpoint_lock.GetSharedLock();
-	row_groups->Fetch(transaction, result, column_ids, row_identifiers, fetch_count, state);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-static void VerifyNotNullConstraint(TableCatalogEntry &table, Vector &vector, idx_t count, const string &col_name) {
-	if (!VectorOperations::HasNull(vector, count)) {
-		return;
-	}
-
-	throw ConstraintException("NOT NULL constraint failed: %s.%s", table.name, col_name);
-}
-
-// To avoid throwing an error at SELECT, instead this moves the error detection to INSERT
-static void VerifyGeneratedExpressionSuccess(ClientContext &context, TableCatalogEntry &table, DataChunk &chunk,
-                                             Expression &expr, column_t index) {
-	auto &col = table.GetColumn(LogicalIndex(index));
-	D_ASSERT(col.Generated());
-	ExpressionExecutor executor(context, expr);
-	Vector result(col.Type());
-	try {
-		executor.ExecuteExpression(chunk, result);
-	} catch (InternalException &ex) {
-		throw;
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		throw ConstraintException("Incorrect value for generated column \"%s %s AS (%s)\" : %s", col.Name(),
-		                          col.Type().ToString(), col.GeneratedExpression().ToString(), error.RawMessage());
-	}
-}
-
-static void VerifyCheckConstraint(ClientContext &context, TableCatalogEntry &table, Expression &expr, DataChunk &chunk,
-                                  CheckConstraint &check) {
-	ExpressionExecutor executor(context, expr);
-	Vector result(LogicalType::INTEGER);
-	try {
-		executor.ExecuteExpression(chunk, result);
-	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		throw ConstraintException("CHECK constraint failed on table %s with expression %s (Error: %s)", table.name,
-		                          check.ToString(), error.RawMessage());
-	} catch (...) {
-		// LCOV_EXCL_START
-		throw ConstraintException("CHECK constraint failed on table %s with expression %s (Unknown Error)", table.name,
-		                          check.ToString());
-	} // LCOV_EXCL_STOP
-	UnifiedVectorFormat vdata;
-	result.ToUnifiedFormat(chunk.size(), vdata);
-
-	auto dataptr = UnifiedVectorFormat::GetData<int32_t>(vdata);
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (vdata.validity.RowIsValid(idx) && dataptr[idx] == 0) {
-			throw ConstraintException("CHECK constraint failed on table %s with expression %s", table.name,
-			                          check.ToString());
-		}
-	}
-}
-
-bool DataTable::IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type) {
-	if (fk_type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ? !index.IsUnique() : !index.IsForeign()) {
-		return false;
-	}
-	if (fk_keys.size() != index.GetColumnIds().size()) {
-		return false;
-	}
-	for (auto &fk_key : fk_keys) {
-		bool is_found = false;
-		for (auto &index_key : index.GetColumnIds()) {
-			if (fk_key.index == index_key) {
-				is_found = true;
-				break;
-			}
-		}
-		if (!is_found) {
-			return false;
-		}
-	}
-	return true;
-}
-
-// Find the first index that is not null, and did not find a match
-static idx_t FirstMissingMatch(const ManagedSelection &matches) {
-	idx_t match_idx = 0;
-
-	for (idx_t i = 0; i < matches.Size(); i++) {
-		auto match = matches.IndexMapsToLocation(match_idx, i);
-		match_idx += match;
-		if (!match) {
-			// This index is missing in the matches vector
-			return i;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t LocateErrorIndex(bool is_append, const ManagedSelection &matches) {
-	// We expected to find nothing, so the first error is the first match.
-	if (!is_append) {
-		return matches[0];
-	}
-	// We expected to find matches for all of them, so the first missing match is the first error.
-	return FirstMissingMatch(matches);
-}
-
-[[noreturn]] static void ThrowForeignKeyConstraintError(idx_t failed_index, bool is_append, Index &conflict_index,
-                                                        DataChunk &input) {
-	// The index that caused the conflict has to be bound by this point (or we would not have gotten here)
-	D_ASSERT(conflict_index.IsBound());
-	auto &index = conflict_index.Cast<BoundIndex>();
-	auto verify_type = is_append ? VerifyExistenceType::APPEND_FK : VerifyExistenceType::DELETE_FK;
-	D_ASSERT(failed_index != DConstants::INVALID_INDEX);
-	auto message = index.GetConstraintViolationMessage(verify_type, failed_index, input);
-	throw ConstraintException(message);
-}
-
-bool IsForeignKeyConstraintError(bool is_append, idx_t input_count, const ManagedSelection &matches) {
-	if (is_append) {
-		// We need to find a match for all values
-		return matches.Count() != input_count;
-	} else {
-		// We should not find any matches
-		return matches.Count() != 0;
-	}
-}
-
-static bool IsAppend(VerifyExistenceType verify_type) {
-	return verify_type == VerifyExistenceType::APPEND_FK;
-}
-
-void DataTable::VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                           DataChunk &chunk, VerifyExistenceType verify_type) {
-	const vector<PhysicalIndex> *src_keys_ptr = &bfk.info.fk_keys;
-	const vector<PhysicalIndex> *dst_keys_ptr = &bfk.info.pk_keys;
-
-	bool is_append = IsAppend(verify_type);
-	if (!is_append) {
-		src_keys_ptr = &bfk.info.pk_keys;
-		dst_keys_ptr = &bfk.info.fk_keys;
-	}
-
-	auto &table_entry_ptr =
-	    Catalog::GetEntry<TableCatalogEntry>(context, db.GetName(), bfk.info.schema, bfk.info.table);
-	// make the data chunk to check
-	vector<LogicalType> types;
-	for (auto &col : table_entry_ptr.GetColumns().Physical()) {
-		types.emplace_back(col.Type());
-	}
-	DataChunk dst_chunk;
-	dst_chunk.InitializeEmpty(types);
-	for (idx_t i = 0; i < src_keys_ptr->size(); i++) {
-		dst_chunk.data[(*dst_keys_ptr)[i].index].Reference(chunk.data[(*src_keys_ptr)[i].index]);
-	}
-	dst_chunk.SetCardinality(chunk.size());
-	auto &data_table = table_entry_ptr.GetStorage();
-
-	idx_t count = dst_chunk.size();
-	if (count <= 0) {
-		return;
-	}
-
-	// Set up a way to record conflicts, rather than directly throw on them
-	unordered_set<column_t> empty_column_list;
-	ConflictInfo empty_conflict_info(empty_column_list, false);
-	ConflictManager regular_conflicts(verify_type, count, &empty_conflict_info);
-	ConflictManager transaction_conflicts(verify_type, count, &empty_conflict_info);
-	regular_conflicts.SetMode(ConflictManagerMode::SCAN);
-	transaction_conflicts.SetMode(ConflictManagerMode::SCAN);
-
-	data_table.info->indexes.VerifyForeignKey(*dst_keys_ptr, dst_chunk, regular_conflicts);
-	regular_conflicts.Finalize();
-	auto &regular_matches = regular_conflicts.Conflicts();
-
-	// check if we can insert the chunk into the reference table's local storage
-	auto &local_storage = LocalStorage::Get(context, db);
-	bool error = IsForeignKeyConstraintError(is_append, count, regular_matches);
-	bool transaction_error = false;
-	bool transaction_check = local_storage.Find(data_table);
-
-	if (transaction_check) {
-		auto &transact_index = local_storage.GetIndexes(data_table);
-		transact_index.VerifyForeignKey(*dst_keys_ptr, dst_chunk, transaction_conflicts);
-		transaction_conflicts.Finalize();
-		auto &transaction_matches = transaction_conflicts.Conflicts();
-		transaction_error = IsForeignKeyConstraintError(is_append, count, transaction_matches);
-	}
-
-	if (!transaction_error && !error) {
-		// No error occurred;
-		return;
-	}
-
-	// Some error occurred, and we likely want to throw
-	optional_ptr<Index> index;
-	optional_ptr<Index> transaction_index;
-
-	auto fk_type = is_append ? ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE : ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-	// check whether or not the chunk can be inserted or deleted into the referenced table' storage
-	index = data_table.info->indexes.FindForeignKeyIndex(*dst_keys_ptr, fk_type);
-	if (transaction_check) {
-		auto &transact_index = local_storage.GetIndexes(data_table);
-		// check whether or not the chunk can be inserted or deleted into the referenced table' storage
-		transaction_index = transact_index.FindForeignKeyIndex(*dst_keys_ptr, fk_type);
-	}
-
-	if (!transaction_check) {
-		// Only local state is checked, throw the error
-		D_ASSERT(error);
-		auto failed_index = LocateErrorIndex(is_append, regular_matches);
-		D_ASSERT(failed_index != DConstants::INVALID_INDEX);
-		ThrowForeignKeyConstraintError(failed_index, is_append, *index, dst_chunk);
-	}
-	if (transaction_error && error && is_append) {
-		// When we want to do an append, we only throw if the foreign key does not exist in both transaction and local
-		// storage
-		auto &transaction_matches = transaction_conflicts.Conflicts();
-		idx_t failed_index = DConstants::INVALID_INDEX;
-		idx_t regular_idx = 0;
-		idx_t transaction_idx = 0;
-		for (idx_t i = 0; i < count; i++) {
-			bool in_regular = regular_matches.IndexMapsToLocation(regular_idx, i);
-			regular_idx += in_regular;
-			bool in_transaction = transaction_matches.IndexMapsToLocation(transaction_idx, i);
-			transaction_idx += in_transaction;
-
-			if (!in_regular && !in_transaction) {
-				// We need to find a match for all of the input values
-				// The failed index is i, it does not show up in either regular or transaction storage
-				failed_index = i;
-				break;
-			}
-		}
-		if (failed_index == DConstants::INVALID_INDEX) {
-			// We don't throw, every value was present in either regular or transaction storage
-			return;
-		}
-		ThrowForeignKeyConstraintError(failed_index, true, *index, dst_chunk);
-	}
-	if (!is_append) {
-		D_ASSERT(transaction_check);
-		auto &transaction_matches = transaction_conflicts.Conflicts();
-		if (error) {
-			auto failed_index = LocateErrorIndex(false, regular_matches);
-			D_ASSERT(failed_index != DConstants::INVALID_INDEX);
-			ThrowForeignKeyConstraintError(failed_index, false, *index, dst_chunk);
-		} else {
-			D_ASSERT(transaction_error);
-			D_ASSERT(transaction_matches.Count() != DConstants::INVALID_INDEX);
-			auto failed_index = LocateErrorIndex(false, transaction_matches);
-			D_ASSERT(failed_index != DConstants::INVALID_INDEX);
-			ThrowForeignKeyConstraintError(failed_index, false, *transaction_index, dst_chunk);
-		}
-	}
-}
-
-void DataTable::VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                                 DataChunk &chunk) {
-	VerifyForeignKeyConstraint(bfk, context, chunk, VerifyExistenceType::APPEND_FK);
-}
-
-void DataTable::VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                                 DataChunk &chunk) {
-	VerifyForeignKeyConstraint(bfk, context, chunk, VerifyExistenceType::DELETE_FK);
-}
-
-void DataTable::VerifyNewConstraint(LocalStorage &local_storage, DataTable &parent, const BoundConstraint &constraint) {
-	if (constraint.type != ConstraintType::NOT_NULL) {
-		throw NotImplementedException("FIXME: ALTER COLUMN with such constraint is not supported yet");
-	}
-
-	parent.row_groups->VerifyNewConstraint(parent, constraint);
-	local_storage.VerifyNewConstraint(parent, constraint);
-}
-
-void DataTable::VerifyUniqueIndexes(TableIndexList &indexes, optional_ptr<LocalTableStorage> storage, DataChunk &chunk,
-                                    optional_ptr<ConflictManager> manager) {
-	// Verify the constraint without a conflict manager.
-	if (!manager) {
-		return indexes.ScanBound<ART>([&](ART &art) {
-			if (!art.IsUnique()) {
-				return false;
-			}
-
-			if (storage) {
-				auto delete_index = storage->delete_indexes.Find(art.GetIndexName());
-				art.VerifyAppend(chunk, delete_index, nullptr);
-			} else {
-				art.VerifyAppend(chunk, nullptr, nullptr);
-			}
-			return false;
-		});
-	}
-
-	// The conflict manager is only provided for statements containing ON CONFLICT.
-	auto &conflict_info = manager->GetConflictInfo();
-
-	// Find all indexes matching the conflict target.
-	indexes.ScanBound<ART>([&](ART &art) {
-		if (!art.IsUnique()) {
-			return false;
-		}
-		if (!conflict_info.ConflictTargetMatches(art)) {
-			return false;
-		}
-
-		if (storage) {
-			auto delete_index = storage->delete_indexes.Find(art.GetIndexName());
-			manager->AddIndex(art, delete_index);
-		} else {
-			manager->AddIndex(art, nullptr);
-		}
-		return false;
-	});
-
-	// Verify indexes matching the conflict target.
-	manager->SetMode(ConflictManagerMode::SCAN);
-	auto &matched_indexes = manager->MatchedIndexes();
-	auto &matched_delete_indexes = manager->MatchedDeleteIndexes();
-	for (idx_t i = 0; i < matched_indexes.size(); i++) {
-		matched_indexes[i].get().VerifyAppend(chunk, matched_delete_indexes[i], *manager);
-	}
-
-	// Scan the other indexes and throw, if there are any conflicts.
-	manager->SetMode(ConflictManagerMode::THROW);
-	indexes.ScanBound<ART>([&](ART &art) {
-		if (!art.IsUnique()) {
-			return false;
-		}
-		if (manager->MatchedIndex(art)) {
-			return false;
-		}
-
-		if (storage) {
-			auto delete_index = storage->delete_indexes.Find(art.GetIndexName());
-			art.VerifyAppend(chunk, delete_index, *manager);
-		} else {
-			art.VerifyAppend(chunk, nullptr, *manager);
-		}
-		return false;
-	});
-}
-
-void DataTable::VerifyAppendConstraints(ConstraintState &constraint_state, ClientContext &context, DataChunk &chunk,
-                                        optional_ptr<LocalTableStorage> storage,
-                                        optional_ptr<ConflictManager> manager) {
-
-	auto &table = constraint_state.table;
-
-	if (table.HasGeneratedColumns()) {
-		// Verify the generated columns against the inserted values.
-		auto binder = Binder::CreateBinder(context);
-		physical_index_set_t bound_columns;
-		CheckBinder generated_check_binder(*binder, context, table.name, table.GetColumns(), bound_columns);
-		for (auto &col : table.GetColumns().Logical()) {
-			if (!col.Generated()) {
-				continue;
-			}
-			D_ASSERT(col.Type().id() != LogicalTypeId::ANY);
-			generated_check_binder.target_type = col.Type();
-			auto to_be_bound_expression = col.GeneratedExpression().Copy();
-			auto bound_expression = generated_check_binder.Bind(to_be_bound_expression);
-			VerifyGeneratedExpressionSuccess(context, table, chunk, *bound_expression, col.Oid());
-		}
-	}
-
-	if (HasUniqueIndexes()) {
-		VerifyUniqueIndexes(info->indexes, storage, chunk, manager);
-	}
-
-	auto &constraints = table.GetConstraints();
-	for (idx_t i = 0; i < constraint_state.bound_constraints.size(); i++) {
-		auto &base_constraint = constraints[i];
-		auto &constraint = constraint_state.bound_constraints[i];
-		switch (base_constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &bound_not_null = constraint->Cast<BoundNotNullConstraint>();
-			auto &not_null = base_constraint->Cast<NotNullConstraint>();
-			auto &col = table.GetColumns().GetColumn(LogicalIndex(not_null.index));
-			VerifyNotNullConstraint(table, chunk.data[bound_not_null.index.index], chunk.size(), col.Name());
-			break;
-		}
-		case ConstraintType::CHECK: {
-			auto &check = base_constraint->Cast<CheckConstraint>();
-			auto &bound_check = constraint->Cast<BoundCheckConstraint>();
-			VerifyCheckConstraint(context, table, *bound_check.expression, chunk, check);
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			// These were handled earlier.
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = constraint->Cast<BoundForeignKeyConstraint>();
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
-			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				VerifyAppendForeignKeyConstraint(bfk, context, chunk);
-			}
-			break;
-		}
-		default:
-			throw InternalException("invalid constraint type");
-		}
-	}
-}
-
-unique_ptr<ConstraintState>
-DataTable::InitializeConstraintState(TableCatalogEntry &table,
-                                     const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-	return make_uniq<ConstraintState>(table, bound_constraints);
-}
-
-void DataTable::InitializeLocalAppend(LocalAppendState &state, TableCatalogEntry &table, ClientContext &context,
-                                      const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: adding entries to a table that has been altered!");
-	}
-	auto &local_storage = LocalStorage::Get(context, db);
-	local_storage.InitializeAppend(state, *this);
-	state.constraint_state = InitializeConstraintState(table, bound_constraints);
-}
-
-void DataTable::InitializeLocalStorage(LocalAppendState &state, TableCatalogEntry &table, ClientContext &context,
-                                       const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: adding entries to a table that has been altered!");
-	}
-
-	auto &local_storage = LocalStorage::Get(context, db);
-	local_storage.InitializeStorage(state, *this);
-	state.constraint_state = InitializeConstraintState(table, bound_constraints);
-}
-
-void DataTable::LocalAppend(LocalAppendState &state, ClientContext &context, DataChunk &chunk, bool unsafe) {
-	if (chunk.size() == 0) {
-		return;
-	}
-	if (!is_root) {
-		throw TransactionException("write conflict: adding entries to a table that has been altered");
-	}
-	chunk.Verify();
-
-	// Insert any row ids into the DELETE ART and verify constraints afterward.
-	// This happens only for the global indexes.
-	if (!unsafe) {
-		auto &constraint_state = *state.constraint_state;
-		VerifyAppendConstraints(constraint_state, context, chunk, *state.storage, nullptr);
-	}
-
-	// Append to the transaction-local data.
-	LocalStorage::Append(state, chunk);
-}
-
-void DataTable::FinalizeLocalAppend(LocalAppendState &state) {
-	LocalStorage::FinalizeAppend(state);
-}
-
-OptimisticDataWriter &DataTable::CreateOptimisticWriter(ClientContext &context) {
-	auto &local_storage = LocalStorage::Get(context, db);
-	return local_storage.CreateOptimisticWriter(*this);
-}
-
-void DataTable::FinalizeOptimisticWriter(ClientContext &context, OptimisticDataWriter &writer) {
-	auto &local_storage = LocalStorage::Get(context, db);
-	local_storage.FinalizeOptimisticWriter(*this, writer);
-}
-
-void DataTable::LocalMerge(ClientContext &context, RowGroupCollection &collection) {
-	auto &local_storage = LocalStorage::Get(context, db);
-	local_storage.LocalMerge(*this, collection);
-}
-
-void DataTable::LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
-                            const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-	LocalAppendState append_state;
-	auto &storage = table.GetStorage();
-	storage.InitializeLocalAppend(append_state, table, context, bound_constraints);
-
-	storage.LocalAppend(append_state, context, chunk, false);
-	storage.FinalizeLocalAppend(append_state);
-}
-
-void DataTable::LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
-                            const vector<unique_ptr<BoundConstraint>> &bound_constraints, Vector &row_ids,
-                            DataChunk &delete_chunk) {
-	LocalAppendState append_state;
-	auto &storage = table.GetStorage();
-	storage.InitializeLocalAppend(append_state, table, context, bound_constraints);
-	append_state.storage->AppendToDeleteIndexes(row_ids, delete_chunk);
-
-	storage.LocalAppend(append_state, context, chunk, false);
-	storage.FinalizeLocalAppend(append_state);
-}
-
-void DataTable::LocalAppend(TableCatalogEntry &table, ClientContext &context, ColumnDataCollection &collection,
-                            const vector<unique_ptr<BoundConstraint>> &bound_constraints,
-                            optional_ptr<const vector<LogicalIndex>> column_ids) {
-
-	LocalAppendState append_state;
-	auto &storage = table.GetStorage();
-	storage.InitializeLocalAppend(append_state, table, context, bound_constraints);
-
-	if (!column_ids || column_ids->empty()) {
-		for (auto &chunk : collection.Chunks()) {
-			storage.LocalAppend(append_state, context, chunk, false);
-		}
-		storage.FinalizeLocalAppend(append_state);
-		return;
-	}
-
-	auto &column_list = table.GetColumns();
-	map<PhysicalIndex, unique_ptr<Expression>> active_expressions;
-	for (idx_t i = 0; i < column_ids->size(); i++) {
-		auto &col = column_list.GetColumn((*column_ids)[i]);
-		auto expr = make_uniq<BoundReferenceExpression>(col.Name(), col.Type(), i);
-		active_expressions[col.Physical()] = std::move(expr);
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	ConstantBinder default_binder(*binder, context, "DEFAULT value");
-	vector<unique_ptr<Expression>> expressions;
-	for (idx_t i = 0; i < column_list.PhysicalColumnCount(); i++) {
-		auto expr = active_expressions.find(PhysicalIndex(i));
-		if (expr != active_expressions.end()) {
-			expressions.push_back(std::move(expr->second));
-			continue;
-		}
-
-		auto &col = column_list.GetColumn(PhysicalIndex(i));
-		if (!col.HasDefaultValue()) {
-			auto null_expr = make_uniq<BoundConstantExpression>(Value(col.Type()));
-			expressions.push_back(std::move(null_expr));
-			continue;
-		}
-
-		auto default_copy = col.DefaultValue().Copy();
-		default_binder.target_type = col.Type();
-		auto bound_default = default_binder.Bind(default_copy);
-		expressions.push_back(std::move(bound_default));
-	}
-
-	ExpressionExecutor expression_executor(context, expressions);
-	DataChunk result;
-	result.Initialize(context, table.GetTypes());
-
-	for (auto &chunk : collection.Chunks()) {
-		expression_executor.Execute(chunk, result);
-		storage.LocalAppend(append_state, context, result, false);
-		result.Reset();
-	}
-	storage.FinalizeLocalAppend(append_state);
-}
-
-void DataTable::AppendLock(TableAppendState &state) {
-	state.append_lock = unique_lock<mutex>(append_lock);
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: adding entries to a table that has been altered!");
-	}
-	state.row_start = NumericCast<row_t>(row_groups->GetTotalRows());
-	state.current_row = state.row_start;
-}
-
-void DataTable::InitializeAppend(DuckTransaction &transaction, TableAppendState &state) {
-	// obtain the append lock for this table
-	if (!state.append_lock) {
-		throw InternalException("DataTable::AppendLock should be called before DataTable::InitializeAppend");
-	}
-	row_groups->InitializeAppend(transaction, state);
-}
-
-void DataTable::Append(DataChunk &chunk, TableAppendState &state) {
-	D_ASSERT(is_root);
-	row_groups->Append(chunk, state);
-}
-
-void DataTable::FinalizeAppend(DuckTransaction &transaction, TableAppendState &state) {
-	row_groups->FinalizeAppend(transaction, state);
-}
-
-void DataTable::ScanTableSegment(DuckTransaction &transaction, idx_t row_start, idx_t count,
-                                 const std::function<void(DataChunk &chunk)> &function) {
-	if (count == 0) {
-		return;
-	}
-	idx_t end = row_start + count;
-
-	vector<StorageIndex> column_ids;
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < this->column_definitions.size(); i++) {
-		auto &col = this->column_definitions[i];
-		column_ids.emplace_back(i);
-		types.push_back(col.Type());
-	}
-	DataChunk chunk;
-	chunk.Initialize(Allocator::Get(db), types);
-
-	CreateIndexScanState state;
-
-	InitializeScanWithOffset(transaction, state, column_ids, row_start, row_start + count);
-	auto row_start_aligned = state.table_state.row_group->start + state.table_state.vector_index * STANDARD_VECTOR_SIZE;
-
-	idx_t current_row = row_start_aligned;
-	while (current_row < end) {
-		state.table_state.ScanCommitted(chunk, TableScanType::TABLE_SCAN_COMMITTED_ROWS);
-		if (chunk.size() == 0) {
-			break;
-		}
-		idx_t end_row = current_row + chunk.size();
-		// start of chunk is current_row
-		// end of chunk is end_row
-		// figure out if we need to write the entire chunk or just part of it
-		idx_t chunk_start = MaxValue<idx_t>(current_row, row_start);
-		idx_t chunk_end = MinValue<idx_t>(end_row, end);
-		D_ASSERT(chunk_start < chunk_end);
-		idx_t chunk_count = chunk_end - chunk_start;
-		if (chunk_count != chunk.size()) {
-			D_ASSERT(chunk_count <= chunk.size());
-			// need to slice the chunk before insert
-			idx_t start_in_chunk;
-			if (current_row >= row_start) {
-				start_in_chunk = 0;
-			} else {
-				start_in_chunk = row_start - current_row;
-			}
-			SelectionVector sel(start_in_chunk, chunk_count);
-			chunk.Slice(sel, chunk_count);
-			chunk.Verify();
-		}
-		function(chunk);
-		chunk.Reset();
-		current_row = end_row;
-	}
-}
-
-void DataTable::MergeStorage(RowGroupCollection &data, TableIndexList &,
-                             optional_ptr<StorageCommitState> commit_state) {
-	row_groups->MergeStorage(data, this, commit_state);
-	row_groups->Verify();
-}
-
-void DataTable::WriteToLog(DuckTransaction &transaction, WriteAheadLog &log, idx_t row_start, idx_t count,
-                           optional_ptr<StorageCommitState> commit_state) {
-	log.WriteSetTable(info->schema, info->table);
-	if (commit_state) {
-		idx_t optimistic_count = 0;
-		auto entry = commit_state->GetRowGroupData(*this, row_start, optimistic_count);
-		if (entry) {
-			D_ASSERT(optimistic_count > 0);
-			log.WriteRowGroupData(*entry);
-			if (optimistic_count > count) {
-				throw InternalException(
-				    "Optimistically written count cannot exceed actual count (got %llu, but expected count is %llu)",
-				    optimistic_count, count);
-			}
-			// write any remaining (non-optimistically written) rows to the WAL normally
-			row_start += optimistic_count;
-			count -= optimistic_count;
-			if (count == 0) {
-				return;
-			}
-		}
-	}
-	ScanTableSegment(transaction, row_start, count, [&](DataChunk &chunk) { log.WriteInsert(chunk); });
-}
-
-void DataTable::CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count) {
-	lock_guard<mutex> lock(append_lock);
-	row_groups->CommitAppend(commit_id, row_start, count);
-}
-
-void DataTable::RevertAppendInternal(idx_t start_row) {
-	D_ASSERT(is_root);
-	// revert appends made to row_groups
-	row_groups->RevertAppendInternal(start_row);
-}
-
-void DataTable::RevertAppend(DuckTransaction &transaction, idx_t start_row, idx_t count) {
-	lock_guard<mutex> lock(append_lock);
-
-	// revert any appends to indexes
-	if (!info->indexes.Empty()) {
-		idx_t current_row_base = start_row;
-		row_t row_data[STANDARD_VECTOR_SIZE];
-		Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_data));
-		idx_t scan_count = MinValue<idx_t>(count, row_groups->GetTotalRows() - start_row);
-		ScanTableSegment(transaction, start_row, scan_count, [&](DataChunk &chunk) {
-			for (idx_t i = 0; i < chunk.size(); i++) {
-				row_data[i] = NumericCast<row_t>(current_row_base + i);
-			}
-			info->indexes.Scan([&](Index &index) {
-				// We cant add to unbound indexes anyways, so there is no need to revert them
-				if (index.IsBound()) {
-					index.Cast<BoundIndex>().Delete(chunk, row_identifiers);
-				}
-				return false;
-			});
-			current_row_base += chunk.size();
-		});
-	}
-
-	// we need to vacuum the indexes to remove any buffers that are now empty
-	// due to reverting the appends
-	info->indexes.Scan([&](Index &index) {
-		// We cant add to unbound indexes anyway, so there is no need to vacuum them
-		if (index.IsBound()) {
-			index.Cast<BoundIndex>().Vacuum();
-		}
-		return false;
-	});
-
-	// revert the data table append
-	RevertAppendInternal(start_row);
-}
-
-//===--------------------------------------------------------------------===//
-// Indexes
-//===--------------------------------------------------------------------===//
-ErrorData DataTable::AppendToIndexes(TableIndexList &indexes, optional_ptr<TableIndexList> delete_indexes,
-                                     DataChunk &chunk, row_t row_start) {
-	ErrorData error;
-	if (indexes.Empty()) {
-		return error;
-	}
-
-	// first generate the vector of row identifiers
-	Vector row_ids(LogicalType::ROW_TYPE);
-	VectorOperations::GenerateSequence(row_ids, chunk.size(), row_start, 1);
-
-	vector<BoundIndex *> already_appended;
-	bool append_failed = false;
-	// now append the entries to the indices
-	indexes.Scan([&](Index &index_to_append) {
-		if (!index_to_append.IsBound()) {
-			throw InternalException("unbound index in DataTable::AppendToIndexes");
-		}
-		auto &index = index_to_append.Cast<BoundIndex>();
-
-		// Find the matching delete index.
-		optional_ptr<BoundIndex> delete_index;
-		if (index.IsUnique()) {
-			if (delete_indexes) {
-				delete_index = delete_indexes->Find(index.name);
-			}
-		}
-
-		try {
-			error = index.AppendWithDeleteIndex(chunk, row_ids, delete_index);
-		} catch (std::exception &ex) {
-			error = ErrorData(ex);
-		}
-
-		if (error.HasError()) {
-			append_failed = true;
-			return true;
-		}
-		already_appended.push_back(&index);
-		return false;
-	});
-
-	if (append_failed) {
-		// constraint violation!
-		// remove any appended entries from previous indexes (if any)
-		for (auto *index : already_appended) {
-			index->Delete(chunk, row_ids);
-		}
-	}
-	return error;
-}
-
-ErrorData DataTable::AppendToIndexes(optional_ptr<TableIndexList> delete_indexes, DataChunk &chunk, row_t row_start) {
-	D_ASSERT(is_root);
-	return AppendToIndexes(info->indexes, delete_indexes, chunk, row_start);
-}
-
-void DataTable::RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start) {
-	D_ASSERT(is_root);
-	if (info->indexes.Empty()) {
-		return;
-	}
-	// first generate the vector of row identifiers
-	Vector row_identifiers(LogicalType::ROW_TYPE);
-	VectorOperations::GenerateSequence(row_identifiers, chunk.size(), row_start, 1);
-
-	// now remove the entries from the indices
-	RemoveFromIndexes(state, chunk, row_identifiers);
-}
-
-void DataTable::RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, Vector &row_identifiers) {
-	D_ASSERT(is_root);
-	info->indexes.Scan([&](Index &index) {
-		if (!index.IsBound()) {
-			throw InternalException("Unbound index found in DataTable::RemoveFromIndexes");
-		}
-		index.Cast<BoundIndex>().Delete(chunk, row_identifiers);
-		return false;
-	});
-}
-
-void DataTable::RemoveFromIndexes(Vector &row_identifiers, idx_t count) {
-	D_ASSERT(is_root);
-	row_groups->RemoveFromIndexes(info->indexes, row_identifiers, count);
-}
-
-//===--------------------------------------------------------------------===//
-// Delete
-//===--------------------------------------------------------------------===//
-static bool TableHasDeleteConstraints(TableCatalogEntry &table) {
-	for (auto &constraint : table.GetConstraints()) {
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL:
-		case ConstraintType::CHECK:
-		case ConstraintType::UNIQUE:
-			break;
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = constraint->Cast<ForeignKeyConstraint>();
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ||
-			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				return true;
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Constraint type not implemented!");
-		}
-	}
-	return false;
-}
-
-void DataTable::VerifyDeleteConstraints(TableDeleteState &state, ClientContext &context, DataChunk &chunk) {
-	for (auto &constraint : state.constraint_state->bound_constraints) {
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL:
-		case ConstraintType::CHECK:
-		case ConstraintType::UNIQUE:
-			break;
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = constraint->Cast<BoundForeignKeyConstraint>();
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ||
-			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				VerifyDeleteForeignKeyConstraint(bfk, context, chunk);
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Constraint type not implemented!");
-		}
-	}
-}
-
-unique_ptr<TableDeleteState> DataTable::InitializeDelete(TableCatalogEntry &table, ClientContext &context,
-                                                         const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-	// initialize indexes (if any)
-	info->InitializeIndexes(context);
-
-	auto binder = Binder::CreateBinder(context);
-	vector<LogicalType> types;
-	auto result = make_uniq<TableDeleteState>();
-	result->has_delete_constraints = TableHasDeleteConstraints(table);
-	if (result->has_delete_constraints) {
-		// initialize the chunk if there are any constraints to verify
-		for (idx_t i = 0; i < column_definitions.size(); i++) {
-			result->col_ids.emplace_back(column_definitions[i].StorageOid());
-			types.emplace_back(column_definitions[i].Type());
-		}
-		result->verify_chunk.Initialize(Allocator::Get(context), types);
-		result->constraint_state = make_uniq<ConstraintState>(table, bound_constraints);
-	}
-	return result;
-}
-
-idx_t DataTable::Delete(TableDeleteState &state, ClientContext &context, Vector &row_identifiers, idx_t count) {
-	D_ASSERT(row_identifiers.GetType().InternalType() == ROW_TYPE);
-	if (count == 0) {
-		return 0;
-	}
-
-	auto &transaction = DuckTransaction::Get(context, db);
-	auto &local_storage = LocalStorage::Get(transaction);
-
-	row_identifiers.Flatten(count);
-	auto ids = FlatVector::GetData<row_t>(row_identifiers);
-
-	idx_t pos = 0;
-	idx_t delete_count = 0;
-	while (pos < count) {
-		idx_t start = pos;
-		bool is_transaction_delete = ids[pos] >= MAX_ROW_ID;
-		// figure out which batch of rows to delete now
-		for (pos++; pos < count; pos++) {
-			bool row_is_transaction_delete = ids[pos] >= MAX_ROW_ID;
-			if (row_is_transaction_delete != is_transaction_delete) {
-				break;
-			}
-		}
-		idx_t current_offset = start;
-		idx_t current_count = pos - start;
-
-		Vector offset_ids(row_identifiers, current_offset, pos);
-
-		// This is a transaction-local DELETE.
-		if (is_transaction_delete) {
-			if (state.has_delete_constraints) {
-				// perform the constraint verification
-				ColumnFetchState fetch_state;
-				local_storage.FetchChunk(*this, offset_ids, current_count, state.col_ids, state.verify_chunk,
-				                         fetch_state);
-				VerifyDeleteConstraints(state, context, state.verify_chunk);
-			}
-			delete_count += local_storage.Delete(*this, offset_ids, current_count);
-			continue;
-		}
-
-		// This is a regular DELETE.
-		if (state.has_delete_constraints) {
-			// perform the constraint verification
-			ColumnFetchState fetch_state;
-			Fetch(transaction, state.verify_chunk, state.col_ids, offset_ids, current_count, fetch_state);
-			VerifyDeleteConstraints(state, context, state.verify_chunk);
-		}
-		delete_count += row_groups->Delete(transaction, *this, ids + current_offset, current_count);
-	}
-	return delete_count;
-}
-
-//===--------------------------------------------------------------------===//
-// Update
-//===--------------------------------------------------------------------===//
-static void CreateMockChunk(vector<LogicalType> &types, const vector<PhysicalIndex> &column_ids, DataChunk &chunk,
-                            DataChunk &mock_chunk) {
-	// construct a mock DataChunk
-	mock_chunk.InitializeEmpty(types);
-	for (column_t i = 0; i < column_ids.size(); i++) {
-		mock_chunk.data[column_ids[i].index].Reference(chunk.data[i]);
-	}
-	mock_chunk.SetCardinality(chunk.size());
-}
-
-static bool CreateMockChunk(TableCatalogEntry &table, const vector<PhysicalIndex> &column_ids,
-                            physical_index_set_t &desired_column_ids, DataChunk &chunk, DataChunk &mock_chunk) {
-	idx_t found_columns = 0;
-	// check whether the desired columns are present in the UPDATE clause
-	for (column_t i = 0; i < column_ids.size(); i++) {
-		if (desired_column_ids.find(column_ids[i]) != desired_column_ids.end()) {
-			found_columns++;
-		}
-	}
-	if (found_columns == 0) {
-		// no columns were found: no need to check the constraint again
-		return false;
-	}
-	if (found_columns != desired_column_ids.size()) {
-		// not all columns in UPDATE clause are present!
-		// this should not be triggered at all as the binder should add these columns
-		throw InternalException("Not all columns required for the CHECK constraint are present in the UPDATED chunk!");
-	}
-	// construct a mock DataChunk
-	auto types = table.GetTypes();
-	CreateMockChunk(types, column_ids, chunk, mock_chunk);
-	return true;
-}
-
-void DataTable::VerifyUpdateConstraints(ConstraintState &state, ClientContext &context, DataChunk &chunk,
-                                        const vector<PhysicalIndex> &column_ids) {
-	auto &table = state.table;
-	auto &constraints = table.GetConstraints();
-	auto &bound_constraints = state.bound_constraints;
-	for (idx_t constr_idx = 0; constr_idx < bound_constraints.size(); constr_idx++) {
-		auto &base_constraint = constraints[constr_idx];
-		auto &constraint = bound_constraints[constr_idx];
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &bound_not_null = constraint->Cast<BoundNotNullConstraint>();
-			auto &not_null = base_constraint->Cast<NotNullConstraint>();
-			// check if the constraint is in the list of column_ids
-			for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
-				if (column_ids[col_idx] == bound_not_null.index) {
-					// found the column id: check the data in
-					auto &col = table.GetColumn(LogicalIndex(not_null.index));
-					VerifyNotNullConstraint(table, chunk.data[col_idx], chunk.size(), col.Name());
-					break;
-				}
-			}
-			break;
-		}
-		case ConstraintType::CHECK: {
-			auto &check = base_constraint->Cast<CheckConstraint>();
-			auto &bound_check = constraint->Cast<BoundCheckConstraint>();
-
-			DataChunk mock_chunk;
-			if (CreateMockChunk(table, column_ids, bound_check.bound_columns, chunk, mock_chunk)) {
-				VerifyCheckConstraint(context, table, *bound_check.expression, mock_chunk, check);
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE:
-		case ConstraintType::FOREIGN_KEY:
-			break;
-		default:
-			throw NotImplementedException("Constraint type not implemented!");
-		}
-	}
-
-#ifdef DEBUG
-	// Ensure that we never call UPDATE for indexed columns.
-	// Instead, we must rewrite these updates into DELETE + INSERT.
-	info->indexes.Scan([&](Index &index) {
-		D_ASSERT(index.IsBound());
-		D_ASSERT(!index.Cast<BoundIndex>().IndexIsUpdated(column_ids));
-		return false;
-	});
-#endif
-}
-
-unique_ptr<TableUpdateState> DataTable::InitializeUpdate(TableCatalogEntry &table, ClientContext &context,
-                                                         const vector<unique_ptr<BoundConstraint>> &bound_constraints) {
-	// check that there are no unknown indexes
-	info->InitializeIndexes(context);
-
-	auto result = make_uniq<TableUpdateState>();
-	result->constraint_state = InitializeConstraintState(table, bound_constraints);
-	return result;
-}
-
-void DataTable::Update(TableUpdateState &state, ClientContext &context, Vector &row_ids,
-                       const vector<PhysicalIndex> &column_ids, DataChunk &updates) {
-	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	D_ASSERT(column_ids.size() == updates.ColumnCount());
-	updates.Verify();
-
-	auto count = updates.size();
-	if (count == 0) {
-		return;
-	}
-
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: cannot update a table that has been altered!");
-	}
-
-	// first verify that no constraints are violated
-	VerifyUpdateConstraints(*state.constraint_state, context, updates, column_ids);
-
-	// now perform the actual update
-	Vector max_row_id_vec(Value::BIGINT(MAX_ROW_ID));
-	Vector row_ids_slice(LogicalType::BIGINT);
-	DataChunk updates_slice;
-	updates_slice.InitializeEmpty(updates.GetTypes());
-
-	SelectionVector sel_local_update(count), sel_global_update(count);
-	auto n_local_update = VectorOperations::GreaterThanEquals(row_ids, max_row_id_vec, nullptr, count,
-	                                                          &sel_local_update, &sel_global_update);
-	auto n_global_update = count - n_local_update;
-
-	// row id > MAX_ROW_ID? transaction-local storage
-	if (n_local_update > 0) {
-		updates_slice.Slice(updates, sel_local_update, n_local_update);
-		updates_slice.Flatten();
-		row_ids_slice.Slice(row_ids, sel_local_update, n_local_update);
-		row_ids_slice.Flatten(n_local_update);
-
-		LocalStorage::Get(context, db).Update(*this, row_ids_slice, column_ids, updates_slice);
-	}
-
-	// otherwise global storage
-	if (n_global_update > 0) {
-		auto &transaction = DuckTransaction::Get(context, db);
-		updates_slice.Slice(updates, sel_global_update, n_global_update);
-		updates_slice.Flatten();
-		row_ids_slice.Slice(row_ids, sel_global_update, n_global_update);
-		row_ids_slice.Flatten(n_global_update);
-
-		transaction.UpdateCollection(row_groups);
-		row_groups->Update(transaction, FlatVector::GetData<row_t>(row_ids_slice), column_ids, updates_slice);
-	}
-}
-
-void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
-                             const vector<column_t> &column_path, DataChunk &updates) {
-	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	D_ASSERT(updates.ColumnCount() == 1);
-	updates.Verify();
-	if (updates.size() == 0) {
-		return;
-	}
-
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: cannot update a table that has been altered!");
-	}
-
-	// now perform the actual update
-	auto &transaction = DuckTransaction::Get(context, db);
-
-	updates.Flatten();
-	row_ids.Flatten(updates.size());
-	row_groups->UpdateColumn(transaction, row_ids, column_path, updates);
-}
-
-//===--------------------------------------------------------------------===//
-// Statistics
-//===--------------------------------------------------------------------===//
-unique_ptr<BaseStatistics> DataTable::GetStatistics(ClientContext &context, column_t column_id) {
-	if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-		return nullptr;
-	}
-	return row_groups->CopyStats(column_id);
-}
-
-void DataTable::SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats) {
-	D_ASSERT(column_id != COLUMN_IDENTIFIER_ROW_ID);
-	row_groups->SetDistinct(column_id, std::move(distinct_stats));
-}
-
-unique_ptr<BlockingSample> DataTable::GetSample() {
-	return row_groups->GetSample();
-}
-
-//===--------------------------------------------------------------------===//
-// Checkpoint
-//===--------------------------------------------------------------------===//
-unique_ptr<StorageLockKey> DataTable::GetSharedCheckpointLock() {
-	return info->checkpoint_lock.GetSharedLock();
-}
-
-unique_ptr<StorageLockKey> DataTable::GetCheckpointLock() {
-	return info->checkpoint_lock.GetExclusiveLock();
-}
-
-void DataTable::Checkpoint(TableDataWriter &writer, Serializer &serializer) {
-	// checkpoint each individual row group
-	TableStatistics global_stats;
-	row_groups->CopyStats(global_stats);
-	row_groups->Checkpoint(writer, global_stats);
-	// The row group payload data has been written. Now write:
-	//   sample
-	//   column stats
-	//   row-group pointers
-	//   table pointer
-	//   index data
-	writer.FinalizeTable(global_stats, info.get(), serializer);
-}
-
-void DataTable::CommitDropColumn(idx_t index) {
-	row_groups->CommitDropColumn(index);
-}
-
-idx_t DataTable::ColumnCount() const {
-	return column_definitions.size();
-}
-
-idx_t DataTable::GetTotalRows() const {
-	return row_groups->GetTotalRows();
-}
-
-void DataTable::CommitDropTable() {
-	// commit a drop of this table: mark all blocks as modified, so they can be reclaimed later on
-	row_groups->CommitDropTable();
-
-	// propagate dropping this table to its indexes: frees all index memory
-	info->indexes.Scan([&](Index &index) {
-		D_ASSERT(index.IsBound());
-		index.Cast<BoundIndex>().CommitDrop();
-		return false;
-	});
-}
-
-//===--------------------------------------------------------------------===//
-// Column Segment Info
-//===--------------------------------------------------------------------===//
-vector<ColumnSegmentInfo> DataTable::GetColumnSegmentInfo() {
-	auto lock = GetSharedCheckpointLock();
-	return row_groups->GetColumnSegmentInfo();
-}
-
-//===--------------------------------------------------------------------===//
-// Index Constraint Creation
-//===--------------------------------------------------------------------===//
-void DataTable::AddIndex(const ColumnList &columns, const vector<LogicalIndex> &column_indexes,
-                         const IndexConstraintType type, const IndexStorageInfo &index_info) {
-	if (!IsRoot()) {
-		throw TransactionException("cannot add an index to a table that has been altered!");
-	}
-
-	// Fetch the column types and create bound column reference expressions.
-	vector<column_t> physical_ids;
-	vector<unique_ptr<Expression>> expressions;
-
-	for (const auto column_index : column_indexes) {
-		auto binding = ColumnBinding(0, physical_ids.size());
-		auto &col = columns.GetColumn(column_index);
-		auto ref = make_uniq<BoundColumnRefExpression>(col.Name(), col.Type(), binding);
-		expressions.push_back(std::move(ref));
-		physical_ids.push_back(col.Physical().index);
-	}
-
-	// Create an ART around the expressions.
-	auto &io_manager = TableIOManager::Get(*this);
-	auto art = make_uniq<ART>(index_info.name, type, physical_ids, io_manager, std::move(expressions), db, nullptr,
-	                          index_info);
-	info->indexes.AddIndex(std::move(art));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/index.cpp b/src/duckdb/src/storage/index.cpp
deleted file mode 100644
index ca136d631..000000000
--- a/src/duckdb/src/storage/index.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "duckdb/storage/index.hpp"
-#include "duckdb/common/radix.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-
-Index::Index(const vector<column_t> &column_ids, TableIOManager &table_io_manager, AttachedDatabase &db)
-
-    : column_ids(column_ids), table_io_manager(table_io_manager), db(db) {
-
-	if (!Radix::IsLittleEndian()) {
-		throw NotImplementedException("indexes are not supported on big endian architectures");
-	}
-	// create the column id set
-	column_id_set.insert(column_ids.begin(), column_ids.end());
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/local_storage.cpp b/src/duckdb/src/storage/local_storage.cpp
deleted file mode 100644
index 71b20bd10..000000000
--- a/src/duckdb/src/storage/local_storage.cpp
+++ /dev/null
@@ -1,653 +0,0 @@
-#include "duckdb/transaction/local_storage.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/partial_block_manager.hpp"
-
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &table)
-    : table_ref(table), allocator(Allocator::Get(table.db)), deleted_rows(0), optimistic_writer(table),
-      merged_storage(false) {
-
-	auto types = table.GetTypes();
-	auto data_table_info = table.GetDataTableInfo();
-	auto &io_manager = TableIOManager::Get(table);
-	row_groups = make_shared_ptr<RowGroupCollection>(data_table_info, io_manager, types, MAX_ROW_ID, 0);
-	row_groups->InitializeEmpty();
-
-	data_table_info->GetIndexes().BindAndScan<ART>(context, *data_table_info, [&](ART &art) {
-		auto constraint_type = art.GetConstraintType();
-		if (constraint_type == IndexConstraintType::NONE) {
-			return false;
-		}
-
-		// UNIQUE constraint.
-		vector<unique_ptr<Expression>> expressions;
-		vector<unique_ptr<Expression>> delete_expressions;
-		for (auto &expr : art.unbound_expressions) {
-			expressions.push_back(expr->Copy());
-			delete_expressions.push_back(expr->Copy());
-		}
-
-		// Create a delete index and a local index.
-		auto delete_index = make_uniq<ART>(art.GetIndexName(), constraint_type, art.GetColumnIds(),
-		                                   art.table_io_manager, std::move(delete_expressions), art.db);
-		delete_index->append_mode = ARTAppendMode::IGNORE_DUPLICATES;
-		delete_indexes.AddIndex(std::move(delete_index));
-
-		auto index = make_uniq<ART>(art.GetIndexName(), constraint_type, art.GetColumnIds(), art.table_io_manager,
-		                            std::move(expressions), art.db);
-		append_indexes.AddIndex(std::move(index));
-		return false;
-	});
-}
-
-LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
-                                     idx_t changed_idx, const LogicalType &target_type,
-                                     const vector<StorageIndex> &bound_columns, Expression &cast_expr)
-    : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
-      optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)),
-      merged_storage(parent.merged_storage) {
-	row_groups = parent.row_groups->AlterType(context, changed_idx, target_type, bound_columns, cast_expr);
-	parent.row_groups.reset();
-	append_indexes.Move(parent.append_indexes);
-}
-
-LocalTableStorage::LocalTableStorage(DataTable &new_dt, LocalTableStorage &parent, idx_t drop_idx)
-    : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
-      optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)),
-      merged_storage(parent.merged_storage) {
-	row_groups = parent.row_groups->RemoveColumn(drop_idx);
-	parent.row_groups.reset();
-	append_indexes.Move(parent.append_indexes);
-}
-
-LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
-                                     ColumnDefinition &new_column, ExpressionExecutor &default_executor)
-    : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
-      optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)),
-      merged_storage(parent.merged_storage) {
-	row_groups = parent.row_groups->AddColumn(context, new_column, default_executor);
-	parent.row_groups.reset();
-	append_indexes.Move(parent.append_indexes);
-}
-
-LocalTableStorage::~LocalTableStorage() {
-}
-
-void LocalTableStorage::InitializeScan(CollectionScanState &state, optional_ptr<TableFilterSet> table_filters) {
-	if (row_groups->GetTotalRows() == 0) {
-		throw InternalException("No rows in LocalTableStorage row group for scan");
-	}
-	row_groups->InitializeScan(state, state.GetColumnIds(), table_filters.get());
-}
-
-idx_t LocalTableStorage::EstimatedSize() {
-	// count the appended rows
-	idx_t appended_rows = row_groups->GetTotalRows() - deleted_rows;
-
-	// get the (estimated) size of a row (no compressions, etc.)
-	idx_t row_size = 0;
-	auto &types = row_groups->GetTypes();
-	for (auto &type : types) {
-		row_size += GetTypeIdSize(type.InternalType());
-	}
-
-	// get the index size
-	idx_t index_sizes = 0;
-	append_indexes.Scan([&](Index &index) {
-		D_ASSERT(index.IsBound());
-		index_sizes += index.Cast<BoundIndex>().GetInMemorySize();
-		return false;
-	});
-
-	// return the size of the appended rows and the index size
-	return appended_rows * row_size + index_sizes;
-}
-
-void LocalTableStorage::WriteNewRowGroup() {
-	if (deleted_rows != 0) {
-		// we have deletes - we cannot merge row groups
-		return;
-	}
-	optimistic_writer.WriteNewRowGroup(*row_groups);
-}
-
-void LocalTableStorage::FlushBlocks() {
-	const idx_t row_group_size = row_groups->GetRowGroupSize();
-	if (!merged_storage && row_groups->GetTotalRows() > row_group_size) {
-		optimistic_writer.WriteLastRowGroup(*row_groups);
-	}
-	optimistic_writer.FinalFlush();
-}
-
-ErrorData LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, RowGroupCollection &source,
-                                             TableIndexList &index_list, const vector<LogicalType> &table_types,
-                                             row_t &start_row) {
-	// only need to scan for index append
-	// figure out which columns we need to scan for the set of indexes
-	auto index_columns = index_list.GetRequiredColumns();
-	vector<StorageIndex> required_columns;
-	for (auto &col : index_columns) {
-		required_columns.emplace_back(col);
-	}
-	// create an empty mock chunk that contains all the correct types for the table
-	DataChunk mock_chunk;
-	mock_chunk.InitializeEmpty(table_types);
-	ErrorData error;
-	source.Scan(transaction, required_columns, [&](DataChunk &chunk) -> bool {
-		// construct the mock chunk by referencing the required columns
-		for (idx_t i = 0; i < required_columns.size(); i++) {
-			auto col_id = required_columns[i].GetPrimaryIndex();
-			mock_chunk.data[col_id].Reference(chunk.data[i]);
-		}
-		mock_chunk.SetCardinality(chunk);
-		// append this chunk to the indexes of the table
-		error = DataTable::AppendToIndexes(index_list, nullptr, mock_chunk, start_row);
-		if (error.HasError()) {
-			return false;
-		}
-		start_row += UnsafeNumericCast<row_t>(chunk.size());
-		return true;
-	});
-	return error;
-}
-
-void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppendState &append_state,
-                                        bool append_to_table) {
-	auto &table = table_ref.get();
-	if (append_to_table) {
-		table.InitializeAppend(transaction, append_state);
-	}
-	ErrorData error;
-	if (append_to_table) {
-		// appending: need to scan entire
-		row_groups->Scan(transaction, [&](DataChunk &chunk) -> bool {
-			// append this chunk to the indexes of the table
-			error = table.AppendToIndexes(delete_indexes, chunk, append_state.current_row);
-			if (error.HasError()) {
-				return false;
-			}
-			// append to base table
-			table.Append(chunk, append_state);
-			return true;
-		});
-	} else {
-		auto data_table_info = table.GetDataTableInfo();
-		auto &index_list = data_table_info->GetIndexes();
-		error = AppendToIndexes(transaction, *row_groups, index_list, table.GetTypes(), append_state.current_row);
-	}
-	if (error.HasError()) {
-		// need to revert all appended row ids
-		row_t current_row = append_state.row_start;
-		// remove the data from the indexes, if there are any indexes
-		row_groups->Scan(transaction, [&](DataChunk &chunk) -> bool {
-			// append this chunk to the indexes of the table
-			try {
-				table.RemoveFromIndexes(append_state, chunk, current_row);
-			} catch (std::exception &ex) { // LCOV_EXCL_START
-				error = ErrorData(ex);
-				return false;
-			} // LCOV_EXCL_STOP
-
-			current_row += UnsafeNumericCast<row_t>(chunk.size());
-			if (current_row >= append_state.current_row) {
-				// finished deleting all rows from the index: abort now
-				return false;
-			}
-			return true;
-		});
-		if (append_to_table) {
-			table.RevertAppendInternal(NumericCast<idx_t>(append_state.row_start));
-		}
-
-		// we need to vacuum the indexes to remove any buffers that are now empty
-		// due to reverting the appends
-		table.VacuumIndexes();
-		error.Throw();
-	}
-	if (append_to_table) {
-		table.FinalizeAppend(transaction, append_state);
-	}
-}
-
-OptimisticDataWriter &LocalTableStorage::CreateOptimisticWriter() {
-	auto writer = make_uniq<OptimisticDataWriter>(table_ref.get());
-	optimistic_writers.push_back(std::move(writer));
-	return *optimistic_writers.back();
-}
-
-void LocalTableStorage::FinalizeOptimisticWriter(OptimisticDataWriter &writer) {
-	// remove the writer from the set of optimistic writers
-	unique_ptr<OptimisticDataWriter> owned_writer;
-	for (idx_t i = 0; i < optimistic_writers.size(); i++) {
-		if (optimistic_writers[i].get() == &writer) {
-			owned_writer = std::move(optimistic_writers[i]);
-			optimistic_writers.erase_at(i);
-			break;
-		}
-	}
-	if (!owned_writer) {
-		throw InternalException("Error in FinalizeOptimisticWriter - could not find writer");
-	}
-	optimistic_writer.Merge(*owned_writer);
-}
-
-void LocalTableStorage::Rollback() {
-	for (auto &writer : optimistic_writers) {
-		writer->Rollback();
-	}
-	optimistic_writers.clear();
-	optimistic_writer.Rollback();
-}
-
-//===--------------------------------------------------------------------===//
-// LocalTableManager
-//===--------------------------------------------------------------------===//
-optional_ptr<LocalTableStorage> LocalTableManager::GetStorage(DataTable &table) const {
-	lock_guard<mutex> l(table_storage_lock);
-	auto entry = table_storage.find(table);
-	return entry == table_storage.end() ? nullptr : entry->second.get();
-}
-
-LocalTableStorage &LocalTableManager::GetOrCreateStorage(ClientContext &context, DataTable &table) {
-	lock_guard<mutex> l(table_storage_lock);
-	auto entry = table_storage.find(table);
-	if (entry == table_storage.end()) {
-		auto new_storage = make_shared_ptr<LocalTableStorage>(context, table);
-		auto storage = new_storage.get();
-		table_storage.insert(make_pair(reference<DataTable>(table), std::move(new_storage)));
-		return *storage;
-	} else {
-		return *entry->second.get();
-	}
-}
-
-bool LocalTableManager::IsEmpty() const {
-	lock_guard<mutex> l(table_storage_lock);
-	return table_storage.empty();
-}
-
-shared_ptr<LocalTableStorage> LocalTableManager::MoveEntry(DataTable &table) {
-	lock_guard<mutex> l(table_storage_lock);
-	auto entry = table_storage.find(table);
-	if (entry == table_storage.end()) {
-		return nullptr;
-	}
-	auto storage_entry = std::move(entry->second);
-	table_storage.erase(entry);
-	return storage_entry;
-}
-
-reference_map_t<DataTable, shared_ptr<LocalTableStorage>> LocalTableManager::MoveEntries() {
-	lock_guard<mutex> l(table_storage_lock);
-	return std::move(table_storage);
-}
-
-idx_t LocalTableManager::EstimatedSize() const {
-	lock_guard<mutex> l(table_storage_lock);
-	idx_t estimated_size = 0;
-	for (auto &storage : table_storage) {
-		estimated_size += storage.second->EstimatedSize();
-	}
-	return estimated_size;
-}
-
-void LocalTableManager::InsertEntry(DataTable &table, shared_ptr<LocalTableStorage> entry) {
-	lock_guard<mutex> l(table_storage_lock);
-	D_ASSERT(table_storage.find(table) == table_storage.end());
-	table_storage[table] = std::move(entry);
-}
-
-//===--------------------------------------------------------------------===//
-// LocalStorage
-//===--------------------------------------------------------------------===//
-LocalStorage::LocalStorage(ClientContext &context, DuckTransaction &transaction)
-    : context(context), transaction(transaction) {
-}
-
-LocalStorage::CommitState::CommitState() {
-}
-
-LocalStorage::CommitState::~CommitState() {
-}
-
-LocalStorage &LocalStorage::Get(DuckTransaction &transaction) {
-	return transaction.GetLocalStorage();
-}
-
-LocalStorage &LocalStorage::Get(ClientContext &context, AttachedDatabase &db) {
-	return DuckTransaction::Get(context, db).GetLocalStorage();
-}
-
-LocalStorage &LocalStorage::Get(ClientContext &context, Catalog &catalog) {
-	return LocalStorage::Get(context, catalog.GetAttached());
-}
-
-void LocalStorage::InitializeScan(DataTable &table, CollectionScanState &state,
-                                  optional_ptr<TableFilterSet> table_filters) {
-	auto storage = table_manager.GetStorage(table);
-	if (storage == nullptr || storage->row_groups->GetTotalRows() == 0) {
-		return;
-	}
-	storage->InitializeScan(state, table_filters);
-}
-
-void LocalStorage::Scan(CollectionScanState &state, const vector<StorageIndex> &, DataChunk &result) {
-	state.Scan(transaction, result);
-}
-
-void LocalStorage::InitializeParallelScan(DataTable &table, ParallelCollectionScanState &state) {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		state.max_row = 0;
-		state.vector_index = 0;
-		state.current_row_group = nullptr;
-	} else {
-		storage->row_groups->InitializeParallelScan(state);
-	}
-}
-
-bool LocalStorage::NextParallelScan(ClientContext &context, DataTable &table, ParallelCollectionScanState &state,
-                                    CollectionScanState &scan_state) {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		return false;
-	}
-	return storage->row_groups->NextParallelScan(context, state, scan_state);
-}
-
-void LocalStorage::InitializeAppend(LocalAppendState &state, DataTable &table) {
-	table.InitializeIndexes(context);
-	state.storage = &table_manager.GetOrCreateStorage(context, table);
-	state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state);
-}
-
-void LocalStorage::InitializeStorage(LocalAppendState &state, DataTable &table) {
-	table.InitializeIndexes(context);
-	state.storage = &table_manager.GetOrCreateStorage(context, table);
-}
-
-void LocalTableStorage::AppendToDeleteIndexes(Vector &row_ids, DataChunk &delete_chunk) {
-	if (delete_chunk.size() == 0) {
-		return;
-	}
-
-	delete_indexes.ScanBound<ART>([&](ART &art) {
-		if (!art.IsUnique()) {
-			return false;
-		}
-		auto result = art.Cast<BoundIndex>().Append(delete_chunk, row_ids);
-		if (result.HasError()) {
-			throw InternalException("unexpected constraint violation on delete ART: ", result.Message());
-		}
-		return false;
-	});
-}
-
-void LocalStorage::Append(LocalAppendState &state, DataChunk &chunk) {
-	// Append to any unique indexes.
-	auto storage = state.storage;
-	auto offset = NumericCast<idx_t>(MAX_ROW_ID) + storage->row_groups->GetTotalRows();
-	idx_t base_id = offset + state.append_state.total_append_count;
-
-	auto error = DataTable::AppendToIndexes(storage->append_indexes, storage->delete_indexes, chunk,
-	                                        NumericCast<row_t>(base_id));
-	if (error.HasError()) {
-		error.Throw();
-	}
-
-	// Append the chunk to the local storage.
-	auto new_row_group = storage->row_groups->Append(chunk, state.append_state);
-
-	// Check if we should pre-emptively flush blocks to disk.
-	if (new_row_group) {
-		storage->WriteNewRowGroup();
-	}
-}
-
-void LocalStorage::FinalizeAppend(LocalAppendState &state) {
-	state.storage->row_groups->FinalizeAppend(state.append_state.transaction, state.append_state);
-}
-
-void LocalStorage::LocalMerge(DataTable &table, RowGroupCollection &collection) {
-	auto &storage = table_manager.GetOrCreateStorage(context, table);
-	if (!storage.append_indexes.Empty()) {
-		// append data to indexes if required
-		row_t base_id = MAX_ROW_ID + NumericCast<row_t>(storage.row_groups->GetTotalRows());
-		auto error =
-		    storage.AppendToIndexes(transaction, collection, storage.append_indexes, table.GetTypes(), base_id);
-		if (error.HasError()) {
-			error.Throw();
-		}
-	}
-	storage.row_groups->MergeStorage(collection, nullptr, nullptr);
-	storage.merged_storage = true;
-}
-
-OptimisticDataWriter &LocalStorage::CreateOptimisticWriter(DataTable &table) {
-	auto &storage = table_manager.GetOrCreateStorage(context, table);
-	return storage.CreateOptimisticWriter();
-}
-
-void LocalStorage::FinalizeOptimisticWriter(DataTable &table, OptimisticDataWriter &writer) {
-	auto &storage = table_manager.GetOrCreateStorage(context, table);
-	storage.FinalizeOptimisticWriter(writer);
-}
-
-bool LocalStorage::ChangesMade() noexcept {
-	return !table_manager.IsEmpty();
-}
-
-bool LocalStorage::Find(DataTable &table) {
-	return table_manager.GetStorage(table) != nullptr;
-}
-
-idx_t LocalStorage::EstimatedSize() {
-	return table_manager.EstimatedSize();
-}
-
-idx_t LocalStorage::Delete(DataTable &table, Vector &row_ids, idx_t count) {
-	auto storage = table_manager.GetStorage(table);
-	D_ASSERT(storage);
-
-	// delete from unique indices (if any)
-	if (!storage->append_indexes.Empty()) {
-		storage->row_groups->RemoveFromIndexes(storage->append_indexes, row_ids, count);
-	}
-
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	idx_t delete_count = storage->row_groups->Delete(TransactionData(0, 0), table, ids, count);
-	storage->deleted_rows += delete_count;
-	return delete_count;
-}
-
-void LocalStorage::Update(DataTable &table, Vector &row_ids, const vector<PhysicalIndex> &column_ids,
-                          DataChunk &updates) {
-	auto storage = table_manager.GetStorage(table);
-	D_ASSERT(storage);
-
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	storage->row_groups->Update(TransactionData(0, 0), ids, column_ids, updates);
-}
-
-void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage, optional_ptr<StorageCommitState> commit_state) {
-	if (storage.is_dropped) {
-		return;
-	}
-	if (storage.row_groups->GetTotalRows() <= storage.deleted_rows) {
-		// all rows that we added were deleted
-		// rollback any partial blocks that are still outstanding
-		storage.Rollback();
-		return;
-	}
-	idx_t append_count = storage.row_groups->GetTotalRows() - storage.deleted_rows;
-	table.InitializeIndexes(context);
-
-	const idx_t row_group_size = storage.row_groups->GetRowGroupSize();
-
-	TableAppendState append_state;
-	table.AppendLock(append_state);
-	transaction.PushAppend(table, NumericCast<idx_t>(append_state.row_start), append_count);
-	if ((append_state.row_start == 0 || storage.row_groups->GetTotalRows() >= row_group_size) &&
-	    storage.deleted_rows == 0) {
-		// table is currently empty OR we are bulk appending: move over the storage directly
-		// first flush any outstanding blocks
-		storage.FlushBlocks();
-		// now append to the indexes (if there are any)
-		// FIXME: we should be able to merge the transaction-local index directly into the main table index
-		// as long we just rewrite some row-ids
-		if (table.HasIndexes()) {
-			storage.AppendToIndexes(transaction, append_state, false);
-		}
-		// finally move over the row groups
-		table.MergeStorage(*storage.row_groups, storage.append_indexes, commit_state);
-	} else {
-		// check if we have written data
-		// if we have, we cannot merge to disk after all
-		// so we need to revert the data we have already written
-		storage.Rollback();
-		// append to the indexes and append to the base table
-		storage.AppendToIndexes(transaction, append_state, true);
-	}
-
-	// possibly vacuum any excess index data
-	table.VacuumIndexes();
-}
-
-void LocalStorage::Commit(optional_ptr<StorageCommitState> commit_state) {
-	// commit local storage
-	// iterate over all entries in the table storage map and commit them
-	// after this, the local storage is no longer required and can be cleared
-	auto table_storage = table_manager.MoveEntries();
-	for (auto &entry : table_storage) {
-		auto table = entry.first;
-		auto storage = entry.second.get();
-		Flush(table, *storage, commit_state);
-		entry.second.reset();
-	}
-}
-
-void LocalStorage::Rollback() {
-	// rollback local storage
-	// after this, the local storage is no longer required and can be cleared
-	auto table_storage = table_manager.MoveEntries();
-	for (auto &entry : table_storage) {
-		auto storage = entry.second.get();
-		if (!storage) {
-			continue;
-		}
-		storage->Rollback();
-
-		entry.second.reset();
-	}
-}
-
-idx_t LocalStorage::AddedRows(DataTable &table) {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		return 0;
-	}
-	return storage->row_groups->GetTotalRows() - storage->deleted_rows;
-}
-
-vector<PartitionStatistics> LocalStorage::GetPartitionStats(DataTable &table) const {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		return vector<PartitionStatistics>();
-	}
-	return storage->row_groups->GetPartitionStats();
-}
-
-void LocalStorage::DropTable(DataTable &table) {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		return;
-	}
-	storage->is_dropped = true;
-}
-
-void LocalStorage::MoveStorage(DataTable &old_dt, DataTable &new_dt) {
-	// check if there are any pending appends for the old version of the table
-	auto new_storage = table_manager.MoveEntry(old_dt);
-	if (!new_storage) {
-		return;
-	}
-	// take over the storage from the old entry
-	new_storage->table_ref = new_dt;
-	table_manager.InsertEntry(new_dt, std::move(new_storage));
-}
-
-void LocalStorage::AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
-                             ExpressionExecutor &default_executor) {
-	// check if there are any pending appends for the old version of the table
-	auto storage = table_manager.MoveEntry(old_dt);
-	if (!storage) {
-		return;
-	}
-	auto new_storage = make_shared_ptr<LocalTableStorage>(context, new_dt, *storage, new_column, default_executor);
-	table_manager.InsertEntry(new_dt, std::move(new_storage));
-}
-
-void LocalStorage::DropColumn(DataTable &old_dt, DataTable &new_dt, idx_t removed_column) {
-	// check if there are any pending appends for the old version of the table
-	auto storage = table_manager.MoveEntry(old_dt);
-	if (!storage) {
-		return;
-	}
-	auto new_storage = make_shared_ptr<LocalTableStorage>(new_dt, *storage, removed_column);
-	table_manager.InsertEntry(new_dt, std::move(new_storage));
-}
-
-void LocalStorage::ChangeType(DataTable &old_dt, DataTable &new_dt, idx_t changed_idx, const LogicalType &target_type,
-                              const vector<StorageIndex> &bound_columns, Expression &cast_expr) {
-	// check if there are any pending appends for the old version of the table
-	auto storage = table_manager.MoveEntry(old_dt);
-	if (!storage) {
-		return;
-	}
-	auto new_storage = make_shared_ptr<LocalTableStorage>(context, new_dt, *storage, changed_idx, target_type,
-	                                                      bound_columns, cast_expr);
-	table_manager.InsertEntry(new_dt, std::move(new_storage));
-}
-
-void LocalStorage::FetchChunk(DataTable &table, Vector &row_ids, idx_t count, const vector<StorageIndex> &col_ids,
-                              DataChunk &chunk, ColumnFetchState &fetch_state) {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		throw InternalException("LocalStorage::FetchChunk - local storage not found");
-	}
-
-	storage->row_groups->Fetch(transaction, chunk, col_ids, row_ids, count, fetch_state);
-}
-
-TableIndexList &LocalStorage::GetIndexes(DataTable &table) {
-	auto storage = table_manager.GetStorage(table);
-	if (!storage) {
-		throw InternalException("LocalStorage::GetIndexes - local storage not found");
-	}
-	return storage->append_indexes;
-}
-
-optional_ptr<LocalTableStorage> LocalStorage::GetStorage(DataTable &table) {
-	return table_manager.GetStorage(table);
-}
-
-void LocalStorage::VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint) {
-	auto storage = table_manager.GetStorage(parent);
-	if (!storage) {
-		return;
-	}
-	storage->row_groups->VerifyNewConstraint(parent, constraint);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/magic_bytes.cpp b/src/duckdb/src/storage/magic_bytes.cpp
deleted file mode 100644
index 303094108..000000000
--- a/src/duckdb/src/storage/magic_bytes.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "duckdb/storage/magic_bytes.hpp"
-#include "duckdb/common/local_file_system.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
-namespace duckdb {
-
-DataFileType MagicBytes::CheckMagicBytes(FileSystem &fs, const string &path) {
-	if (path.empty() || path == IN_MEMORY_PATH) {
-		return DataFileType::DUCKDB_FILE;
-	}
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS);
-	if (!handle) {
-		return DataFileType::FILE_DOES_NOT_EXIST;
-	}
-
-	constexpr const idx_t MAGIC_BYTES_READ_SIZE = 16;
-	char buffer[MAGIC_BYTES_READ_SIZE];
-
-	handle->Read(buffer, MAGIC_BYTES_READ_SIZE);
-	if (memcmp(buffer, "SQLite format 3\0", 16) == 0) {
-		return DataFileType::SQLITE_FILE;
-	}
-	if (memcmp(buffer, "PAR1", 4) == 0) {
-		return DataFileType::PARQUET_FILE;
-	}
-	if (memcmp(buffer + MainHeader::MAGIC_BYTE_OFFSET, MainHeader::MAGIC_BYTES, MainHeader::MAGIC_BYTE_SIZE) == 0) {
-		return DataFileType::DUCKDB_FILE;
-	}
-	return DataFileType::FILE_DOES_NOT_EXIST;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/metadata/metadata_manager.cpp b/src/duckdb/src/storage/metadata/metadata_manager.cpp
deleted file mode 100644
index 04987e653..000000000
--- a/src/duckdb/src/storage/metadata/metadata_manager.cpp
+++ /dev/null
@@ -1,339 +0,0 @@
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/common/serializer/write_stream.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-#include "duckdb/storage/database_size.hpp"
-
-namespace duckdb {
-
-MetadataManager::MetadataManager(BlockManager &block_manager, BufferManager &buffer_manager)
-    : block_manager(block_manager), buffer_manager(buffer_manager) {
-}
-
-MetadataManager::~MetadataManager() {
-}
-
-MetadataHandle MetadataManager::AllocateHandle() {
-	// check if there is any free space left in an existing block
-	// if not allocate a new block
-	block_id_t free_block = INVALID_BLOCK;
-	for (auto &kv : blocks) {
-		auto &block = kv.second;
-		D_ASSERT(kv.first == block.block_id);
-		if (!block.free_blocks.empty()) {
-			free_block = kv.first;
-			break;
-		}
-	}
-	if (free_block == INVALID_BLOCK || free_block > PeekNextBlockId()) {
-		free_block = AllocateNewBlock();
-	}
-	D_ASSERT(free_block != INVALID_BLOCK);
-
-	// select the first free metadata block we can find
-	MetadataPointer pointer;
-	pointer.block_index = UnsafeNumericCast<idx_t>(free_block);
-	auto &block = blocks[free_block];
-	if (block.block->BlockId() < MAXIMUM_BLOCK) {
-		// this block is a disk-backed block, yet we are planning to write to it
-		// we need to convert it into a transient block before we can write to it
-		ConvertToTransient(block);
-		D_ASSERT(block.block->BlockId() >= MAXIMUM_BLOCK);
-	}
-	D_ASSERT(!block.free_blocks.empty());
-	pointer.index = block.free_blocks.back();
-	// mark the block as used
-	block.free_blocks.pop_back();
-	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
-	// pin the block
-	return Pin(pointer);
-}
-
-MetadataHandle MetadataManager::Pin(const MetadataPointer &pointer) {
-	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
-	auto &block = blocks[UnsafeNumericCast<int64_t>(pointer.block_index)];
-
-	MetadataHandle handle;
-	handle.pointer.block_index = pointer.block_index;
-	handle.pointer.index = pointer.index;
-	handle.handle = buffer_manager.Pin(block.block);
-	return handle;
-}
-
-void MetadataManager::ConvertToTransient(MetadataBlock &metadata_block) {
-	// pin the old block
-	auto old_buffer = buffer_manager.Pin(metadata_block.block);
-
-	// allocate a new transient block to replace it
-	auto new_buffer = buffer_manager.Allocate(MemoryTag::METADATA, block_manager.GetBlockSize(), false);
-	auto new_block = new_buffer.GetBlockHandle();
-
-	// copy the data to the transient block
-	memcpy(new_buffer.Ptr(), old_buffer.Ptr(), block_manager.GetBlockSize());
-	metadata_block.block = std::move(new_block);
-
-	// unregister the old block
-	block_manager.UnregisterBlock(metadata_block.block_id);
-}
-
-block_id_t MetadataManager::AllocateNewBlock() {
-	auto new_block_id = GetNextBlockId();
-
-	MetadataBlock new_block;
-	auto handle = buffer_manager.Allocate(MemoryTag::METADATA, block_manager.GetBlockSize(), false);
-	new_block.block = handle.GetBlockHandle();
-	new_block.block_id = new_block_id;
-	for (idx_t i = 0; i < METADATA_BLOCK_COUNT; i++) {
-		new_block.free_blocks.push_back(NumericCast<uint8_t>(METADATA_BLOCK_COUNT - i - 1));
-	}
-	// zero-initialize the handle
-	memset(handle.Ptr(), 0, block_manager.GetBlockSize());
-	AddBlock(std::move(new_block));
-	return new_block_id;
-}
-
-void MetadataManager::AddBlock(MetadataBlock new_block, bool if_exists) {
-	if (blocks.find(new_block.block_id) != blocks.end()) {
-		if (if_exists) {
-			return;
-		}
-		throw InternalException("Block id with id %llu already exists", new_block.block_id);
-	}
-	blocks[new_block.block_id] = std::move(new_block);
-}
-
-void MetadataManager::AddAndRegisterBlock(MetadataBlock block) {
-	if (block.block) {
-		throw InternalException("Calling AddAndRegisterBlock on block that already exists");
-	}
-	block.block = block_manager.RegisterBlock(block.block_id);
-	AddBlock(std::move(block), true);
-}
-
-MetaBlockPointer MetadataManager::GetDiskPointer(const MetadataPointer &pointer, uint32_t offset) {
-	idx_t block_pointer = idx_t(pointer.block_index);
-	block_pointer |= idx_t(pointer.index) << 56ULL;
-	return MetaBlockPointer(block_pointer, offset);
-}
-
-block_id_t MetaBlockPointer::GetBlockId() const {
-	return block_id_t(block_pointer & ~(idx_t(0xFF) << 56ULL));
-}
-
-uint32_t MetaBlockPointer::GetBlockIndex() const {
-	return block_pointer >> 56ULL;
-}
-
-MetadataPointer MetadataManager::FromDiskPointer(MetaBlockPointer pointer) {
-	auto block_id = pointer.GetBlockId();
-	auto index = pointer.GetBlockIndex();
-	auto entry = blocks.find(block_id);
-	if (entry == blocks.end()) { // LCOV_EXCL_START
-		throw InternalException("Failed to load metadata pointer (id %llu, idx %llu, ptr %llu)\n", block_id, index,
-		                        pointer.block_pointer);
-	} // LCOV_EXCL_STOP
-	MetadataPointer result;
-	result.block_index = UnsafeNumericCast<idx_t>(block_id);
-	result.index = UnsafeNumericCast<uint8_t>(index);
-	return result;
-}
-
-MetadataPointer MetadataManager::RegisterDiskPointer(MetaBlockPointer pointer) {
-	auto block_id = pointer.GetBlockId();
-	MetadataBlock block;
-	block.block_id = block_id;
-	AddAndRegisterBlock(block);
-	return FromDiskPointer(pointer);
-}
-
-BlockPointer MetadataManager::ToBlockPointer(MetaBlockPointer meta_pointer, const idx_t metadata_block_size) {
-	BlockPointer result;
-	result.block_id = meta_pointer.GetBlockId();
-	result.offset = meta_pointer.GetBlockIndex() * NumericCast<uint32_t>(metadata_block_size) + meta_pointer.offset;
-	D_ASSERT(result.offset < metadata_block_size * MetadataManager::METADATA_BLOCK_COUNT);
-	return result;
-}
-
-MetaBlockPointer MetadataManager::FromBlockPointer(BlockPointer block_pointer, const idx_t metadata_block_size) {
-	if (!block_pointer.IsValid()) {
-		return MetaBlockPointer();
-	}
-	idx_t index = block_pointer.offset / metadata_block_size;
-	auto offset = block_pointer.offset % metadata_block_size;
-	D_ASSERT(index < MetadataManager::METADATA_BLOCK_COUNT);
-	D_ASSERT(offset < metadata_block_size);
-	MetaBlockPointer result;
-	result.block_pointer = idx_t(block_pointer.block_id) | index << 56ULL;
-	result.offset = UnsafeNumericCast<uint32_t>(offset);
-	return result;
-}
-
-idx_t MetadataManager::BlockCount() {
-	return blocks.size();
-}
-
-void MetadataManager::Flush() {
-	const idx_t total_metadata_size = GetMetadataBlockSize() * MetadataManager::METADATA_BLOCK_COUNT;
-
-	// write the blocks of the metadata manager to disk
-	for (auto &kv : blocks) {
-		auto &block = kv.second;
-		auto handle = buffer_manager.Pin(block.block);
-		// there are a few bytes left-over at the end of the block, zero-initialize them
-		memset(handle.Ptr() + total_metadata_size, 0, block_manager.GetBlockSize() - total_metadata_size);
-		D_ASSERT(kv.first == block.block_id);
-		if (block.block->BlockId() >= MAXIMUM_BLOCK) {
-			// temporary block - convert to persistent
-			block.block = block_manager.ConvertToPersistent(kv.first, std::move(block.block), std::move(handle));
-		} else {
-			// already a persistent block - only need to write it
-			D_ASSERT(block.block->BlockId() == block.block_id);
-			block_manager.Write(handle.GetFileBuffer(), block.block_id);
-		}
-	}
-}
-
-void MetadataManager::Write(WriteStream &sink) {
-	sink.Write<uint64_t>(blocks.size());
-	for (auto &kv : blocks) {
-		kv.second.Write(sink);
-	}
-}
-
-void MetadataManager::Read(ReadStream &source) {
-	auto block_count = source.Read<uint64_t>();
-	for (idx_t i = 0; i < block_count; i++) {
-		auto block = MetadataBlock::Read(source);
-		auto entry = blocks.find(block.block_id);
-		if (entry == blocks.end()) {
-			// block does not exist yet
-			AddAndRegisterBlock(std::move(block));
-		} else {
-			// block was already created - only copy over the free list
-			entry->second.free_blocks = std::move(block.free_blocks);
-		}
-	}
-}
-
-void MetadataBlock::Write(WriteStream &sink) {
-	sink.Write<block_id_t>(block_id);
-	sink.Write<idx_t>(FreeBlocksToInteger());
-}
-
-idx_t MetadataManager::GetMetadataBlockSize() const {
-	return AlignValueFloor(block_manager.GetBlockSize() / METADATA_BLOCK_COUNT);
-}
-
-MetadataBlock MetadataBlock::Read(ReadStream &source) {
-	MetadataBlock result;
-	result.block_id = source.Read<block_id_t>();
-	auto free_list = source.Read<idx_t>();
-	result.FreeBlocksFromInteger(free_list);
-	return result;
-}
-
-idx_t MetadataBlock::FreeBlocksToInteger() {
-	idx_t result = 0;
-	for (idx_t i = 0; i < free_blocks.size(); i++) {
-		D_ASSERT(free_blocks[i] < idx_t(64));
-		idx_t mask = idx_t(1) << idx_t(free_blocks[i]);
-		result |= mask;
-	}
-	return result;
-}
-
-void MetadataBlock::FreeBlocksFromInteger(idx_t free_list) {
-	free_blocks.clear();
-	if (free_list == 0) {
-		return;
-	}
-	for (idx_t i = 64; i > 0; i--) {
-		auto index = i - 1;
-		idx_t mask = idx_t(1) << index;
-		if (free_list & mask) {
-			free_blocks.push_back(UnsafeNumericCast<uint8_t>(index));
-		}
-	}
-}
-
-void MetadataManager::MarkBlocksAsModified() {
-	// for any blocks that were modified in the last checkpoint - set them to free blocks currently
-	for (auto &kv : modified_blocks) {
-		auto block_id = kv.first;
-		idx_t modified_list = kv.second;
-		auto entry = blocks.find(block_id);
-		D_ASSERT(entry != blocks.end());
-		auto &block = entry->second;
-		idx_t current_free_blocks = block.FreeBlocksToInteger();
-		// merge the current set of free blocks with the modified blocks
-		idx_t new_free_blocks = current_free_blocks | modified_list;
-		if (new_free_blocks == NumericLimits<idx_t>::Maximum()) {
-			// if new free_blocks is all blocks - mark entire block as modified
-			blocks.erase(entry);
-			block_manager.MarkBlockAsModified(block_id);
-		} else {
-			// set the new set of free blocks
-			block.FreeBlocksFromInteger(new_free_blocks);
-		}
-	}
-
-	modified_blocks.clear();
-	for (auto &kv : blocks) {
-		auto &block = kv.second;
-		idx_t free_list = block.FreeBlocksToInteger();
-		idx_t occupied_list = ~free_list;
-		modified_blocks[block.block_id] = occupied_list;
-	}
-}
-
-void MetadataManager::ClearModifiedBlocks(const vector<MetaBlockPointer> &pointers) {
-	for (auto &pointer : pointers) {
-		auto block_id = pointer.GetBlockId();
-		auto block_index = pointer.GetBlockIndex();
-		auto entry = modified_blocks.find(block_id);
-		if (entry == modified_blocks.end()) {
-			throw InternalException("ClearModifiedBlocks - Block id %llu not found in modified_blocks", block_id);
-		}
-		auto &modified_list = entry->second;
-		// verify the block has been modified
-		D_ASSERT(modified_list && (1ULL << block_index));
-		// unset the bit
-		modified_list &= ~(1ULL << block_index);
-	}
-}
-
-vector<MetadataBlockInfo> MetadataManager::GetMetadataInfo() const {
-	vector<MetadataBlockInfo> result;
-	for (auto &block : blocks) {
-		MetadataBlockInfo block_info;
-		block_info.block_id = block.second.block_id;
-		block_info.total_blocks = MetadataManager::METADATA_BLOCK_COUNT;
-		for (auto free_block : block.second.free_blocks) {
-			block_info.free_list.push_back(free_block);
-		}
-		std::sort(block_info.free_list.begin(), block_info.free_list.end());
-		result.push_back(std::move(block_info));
-	}
-	std::sort(result.begin(), result.end(),
-	          [](const MetadataBlockInfo &a, const MetadataBlockInfo &b) { return a.block_id < b.block_id; });
-	return result;
-}
-
-vector<shared_ptr<BlockHandle>> MetadataManager::GetBlocks() const {
-	vector<shared_ptr<BlockHandle>> result;
-	for (auto &entry : blocks) {
-		result.push_back(entry.second.block);
-	}
-	return result;
-}
-
-block_id_t MetadataManager::PeekNextBlockId() {
-	return block_manager.PeekFreeBlockId();
-}
-
-block_id_t MetadataManager::GetNextBlockId() {
-	return block_manager.GetFreeBlockId();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/metadata/metadata_reader.cpp b/src/duckdb/src/storage/metadata/metadata_reader.cpp
deleted file mode 100644
index 833a6e656..000000000
--- a/src/duckdb/src/storage/metadata/metadata_reader.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-
-namespace duckdb {
-
-MetadataReader::MetadataReader(MetadataManager &manager, MetaBlockPointer pointer,
-                               optional_ptr<vector<MetaBlockPointer>> read_pointers_p, BlockReaderType type)
-    : manager(manager), type(type), next_pointer(FromDiskPointer(pointer)), has_next_block(true),
-      read_pointers(read_pointers_p), index(0), offset(0), next_offset(pointer.offset), capacity(0) {
-	if (read_pointers) {
-		D_ASSERT(read_pointers->empty());
-		read_pointers->push_back(pointer);
-	}
-}
-
-MetadataReader::MetadataReader(MetadataManager &manager, BlockPointer pointer)
-    : MetadataReader(manager, MetadataManager::FromBlockPointer(pointer, manager.GetMetadataBlockSize())) {
-}
-
-MetadataPointer MetadataReader::FromDiskPointer(MetaBlockPointer pointer) {
-	if (type == BlockReaderType::EXISTING_BLOCKS) {
-		return manager.FromDiskPointer(pointer);
-	} else {
-		return manager.RegisterDiskPointer(pointer);
-	}
-}
-
-MetadataReader::~MetadataReader() {
-}
-
-void MetadataReader::ReadData(data_ptr_t buffer, idx_t read_size) {
-	while (offset + read_size > capacity) {
-		// cannot read entire entry from block
-		// first read what we can from this block
-		idx_t to_read = capacity - offset;
-		if (to_read > 0) {
-			memcpy(buffer, Ptr(), to_read);
-			read_size -= to_read;
-			buffer += to_read;
-			offset += read_size;
-		}
-		// then move to the next block
-		ReadNextBlock();
-	}
-	// we have enough left in this block to read from the buffer
-	memcpy(buffer, Ptr(), read_size);
-	offset += read_size;
-}
-
-MetaBlockPointer MetadataReader::GetMetaBlockPointer() {
-	return manager.GetDiskPointer(block.pointer, UnsafeNumericCast<uint32_t>(offset));
-}
-
-void MetadataReader::ReadNextBlock() {
-	if (!has_next_block) {
-		throw IOException("No more data remaining in MetadataReader");
-	}
-	block = manager.Pin(next_pointer);
-	index = next_pointer.index;
-
-	idx_t next_block = Load<idx_t>(BasePtr());
-	if (next_block == idx_t(-1)) {
-		has_next_block = false;
-	} else {
-		next_pointer = FromDiskPointer(MetaBlockPointer(next_block, 0));
-		MetaBlockPointer next_block_pointer(next_block, 0);
-		if (read_pointers) {
-			read_pointers->push_back(next_block_pointer);
-		}
-	}
-	if (next_offset < sizeof(block_id_t)) {
-		next_offset = sizeof(block_id_t);
-	}
-	if (next_offset > GetMetadataManager().GetMetadataBlockSize()) {
-		throw InternalException("next_offset cannot be bigger than block size");
-	}
-	offset = next_offset;
-	next_offset = sizeof(block_id_t);
-	capacity = GetMetadataManager().GetMetadataBlockSize();
-}
-
-data_ptr_t MetadataReader::BasePtr() {
-	return block.handle.Ptr() + index * GetMetadataManager().GetMetadataBlockSize();
-}
-
-data_ptr_t MetadataReader::Ptr() {
-	return BasePtr() + offset;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/metadata/metadata_writer.cpp b/src/duckdb/src/storage/metadata/metadata_writer.cpp
deleted file mode 100644
index a059d7cca..000000000
--- a/src/duckdb/src/storage/metadata/metadata_writer.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "duckdb/storage/metadata/metadata_writer.hpp"
-#include "duckdb/storage/block_manager.hpp"
-
-namespace duckdb {
-
-MetadataWriter::MetadataWriter(MetadataManager &manager, optional_ptr<vector<MetaBlockPointer>> written_pointers_p)
-    : manager(manager), written_pointers(written_pointers_p), capacity(0), offset(0) {
-	D_ASSERT(!written_pointers || written_pointers->empty());
-}
-
-MetadataWriter::~MetadataWriter() {
-	// If there's an exception during checkpoint, this can get destroyed without
-	// flushing the data...which is fine, because none of the unwritten data
-	// will be referenced.
-	//
-	// Otherwise, we should have explicitly flushed (and thereby nulled the block).
-	D_ASSERT(!block.handle.IsValid() || Exception::UncaughtException());
-}
-
-BlockPointer MetadataWriter::GetBlockPointer() {
-	return MetadataManager::ToBlockPointer(GetMetaBlockPointer(), GetManager().GetMetadataBlockSize());
-}
-
-MetaBlockPointer MetadataWriter::GetMetaBlockPointer() {
-	if (offset >= capacity) {
-		// at the end of the block - fetch the next block
-		NextBlock();
-		D_ASSERT(capacity > 0);
-	}
-	return manager.GetDiskPointer(block.pointer, UnsafeNumericCast<uint32_t>(offset));
-}
-
-MetadataHandle MetadataWriter::NextHandle() {
-	return manager.AllocateHandle();
-}
-
-void MetadataWriter::NextBlock() {
-	// now we need to get a new block id
-	auto new_handle = NextHandle();
-
-	// write the block id of the new block to the start of the current block
-	if (capacity > 0) {
-		auto disk_block = manager.GetDiskPointer(new_handle.pointer);
-		Store<idx_t>(disk_block.block_pointer, BasePtr());
-	}
-	// now update the block id of the block
-	block = std::move(new_handle);
-	current_pointer = block.pointer;
-	offset = sizeof(idx_t);
-	capacity = GetManager().GetMetadataBlockSize();
-	Store<idx_t>(static_cast<idx_t>(-1), BasePtr());
-	if (written_pointers) {
-		written_pointers->push_back(manager.GetDiskPointer(current_pointer));
-	}
-}
-
-void MetadataWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	while (offset + write_size > capacity) {
-		// we need to make a new block
-		// first copy what we can
-		D_ASSERT(offset <= capacity);
-		idx_t copy_amount = capacity - offset;
-		if (copy_amount > 0) {
-			memcpy(Ptr(), buffer, copy_amount);
-			buffer += copy_amount;
-			offset += copy_amount;
-			write_size -= copy_amount;
-		}
-		// move forward to the next block
-		NextBlock();
-	}
-	memcpy(Ptr(), buffer, write_size);
-	offset += write_size;
-}
-
-void MetadataWriter::Flush() {
-	if (offset < capacity) {
-		// clear remaining bytes of block (if any)
-		memset(Ptr(), 0, capacity - offset);
-	}
-	block.handle.Destroy();
-}
-
-data_ptr_t MetadataWriter::BasePtr() {
-	return block.handle.Ptr() + current_pointer.index * GetManager().GetMetadataBlockSize();
-}
-
-data_ptr_t MetadataWriter::Ptr() {
-	return BasePtr() + offset;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/optimistic_data_writer.cpp b/src/duckdb/src/storage/optimistic_data_writer.cpp
deleted file mode 100644
index 0a1966c50..000000000
--- a/src/duckdb/src/storage/optimistic_data_writer.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include "duckdb/storage/optimistic_data_writer.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/partial_block_manager.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-
-namespace duckdb {
-
-OptimisticDataWriter::OptimisticDataWriter(DataTable &table) : table(table) {
-}
-
-OptimisticDataWriter::OptimisticDataWriter(DataTable &table, OptimisticDataWriter &parent) : table(table) {
-	if (parent.partial_manager) {
-		parent.partial_manager->ClearBlocks();
-	}
-}
-
-OptimisticDataWriter::~OptimisticDataWriter() {
-}
-
-bool OptimisticDataWriter::PrepareWrite() {
-	// check if we should pre-emptively write the table to disk
-	if (table.IsTemporary() || StorageManager::Get(table.GetAttached()).InMemory()) {
-		return false;
-	}
-	// we should! write the second-to-last row group to disk
-	// allocate the partial block-manager if none is allocated yet
-	if (!partial_manager) {
-		auto &block_manager = table.GetTableIOManager().GetBlockManagerForRowData();
-		partial_manager = make_uniq<PartialBlockManager>(block_manager, PartialBlockType::APPEND_TO_TABLE);
-	}
-	return true;
-}
-
-void OptimisticDataWriter::WriteNewRowGroup(RowGroupCollection &row_groups) {
-	// we finished writing a complete row group
-	if (!PrepareWrite()) {
-		return;
-	}
-	// flush second-to-last row group
-	auto row_group = row_groups.GetRowGroup(-2);
-	FlushToDisk(*row_group);
-}
-
-void OptimisticDataWriter::WriteLastRowGroup(RowGroupCollection &row_groups) {
-	// we finished writing a complete row group
-	if (!PrepareWrite()) {
-		return;
-	}
-	// flush second-to-last row group
-	auto row_group = row_groups.GetRowGroup(-1);
-	if (!row_group) {
-		return;
-	}
-	FlushToDisk(*row_group);
-}
-
-void OptimisticDataWriter::FlushToDisk(RowGroup &row_group) {
-	//! The set of column compression types (if any)
-	vector<CompressionType> compression_types;
-	D_ASSERT(compression_types.empty());
-	for (auto &column : table.Columns()) {
-		compression_types.push_back(column.CompressionType());
-	}
-	RowGroupWriteInfo info(*partial_manager, compression_types);
-	row_group.WriteToDisk(info);
-}
-
-void OptimisticDataWriter::Merge(OptimisticDataWriter &other) {
-	if (!other.partial_manager) {
-		return;
-	}
-	if (!partial_manager) {
-		partial_manager = std::move(other.partial_manager);
-		return;
-	}
-	partial_manager->Merge(*other.partial_manager);
-	other.partial_manager.reset();
-}
-
-void OptimisticDataWriter::FinalFlush() {
-	if (partial_manager) {
-		partial_manager->FlushPartialBlocks();
-		partial_manager.reset();
-	}
-}
-
-void OptimisticDataWriter::Rollback() {
-	if (partial_manager) {
-		partial_manager->Rollback();
-		partial_manager.reset();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/partial_block_manager.cpp b/src/duckdb/src/storage/partial_block_manager.cpp
deleted file mode 100644
index 3dbf89760..000000000
--- a/src/duckdb/src/storage/partial_block_manager.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-#include "duckdb/storage/partial_block_manager.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// PartialBlock
-//===--------------------------------------------------------------------===//
-
-PartialBlock::PartialBlock(PartialBlockState state, BlockManager &block_manager,
-                           const shared_ptr<BlockHandle> &block_handle)
-    : state(state), block_manager(block_manager), block_handle(block_handle) {
-}
-
-void PartialBlock::AddUninitializedRegion(idx_t start, idx_t end) {
-	uninitialized_regions.push_back({start, end});
-}
-
-void PartialBlock::FlushInternal(const idx_t free_space_left) {
-
-	// ensure that we do not leak any data
-	if (free_space_left > 0 || !uninitialized_regions.empty()) {
-		auto buffer_handle = block_manager.buffer_manager.Pin(block_handle);
-
-		// memset any uninitialized regions
-		for (auto &uninitialized : uninitialized_regions) {
-			memset(buffer_handle.Ptr() + uninitialized.start, 0, uninitialized.end - uninitialized.start);
-		}
-		// memset any free space at the end of the block to 0 prior to writing to disk
-		memset(buffer_handle.Ptr() + block_manager.GetBlockSize() - free_space_left, 0, free_space_left);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// PartialBlockManager
-//===--------------------------------------------------------------------===//
-
-PartialBlockManager::PartialBlockManager(BlockManager &block_manager, PartialBlockType partial_block_type,
-                                         optional_idx max_partial_block_size_p, uint32_t max_use_count)
-    : block_manager(block_manager), partial_block_type(partial_block_type), max_use_count(max_use_count) {
-
-	if (max_partial_block_size_p.IsValid()) {
-		max_partial_block_size = NumericCast<uint32_t>(max_partial_block_size_p.GetIndex());
-		return;
-	}
-
-	// Use the default maximum partial block size with a ratio of 20% free and 80% utilization.
-	max_partial_block_size = NumericCast<uint32_t>(block_manager.GetBlockSize() / 5 * 4);
-}
-PartialBlockManager::~PartialBlockManager() {
-}
-
-PartialBlockAllocation PartialBlockManager::GetBlockAllocation(uint32_t segment_size) {
-	PartialBlockAllocation allocation;
-	allocation.block_manager = &block_manager;
-	allocation.allocation_size = segment_size;
-
-	// if the block is less than 80% full, we consider it a "partial block"
-	// which means we will try to fit it with other blocks
-	// check if there is a partial block available we can write to
-	if (segment_size <= max_partial_block_size && GetPartialBlock(segment_size, allocation.partial_block)) {
-		//! there is! increase the reference count of this block
-		allocation.partial_block->state.block_use_count += 1;
-		allocation.state = allocation.partial_block->state;
-		if (partial_block_type == PartialBlockType::FULL_CHECKPOINT) {
-			block_manager.IncreaseBlockReferenceCount(allocation.state.block_id);
-		}
-	} else {
-		// full block: get a free block to write to
-		AllocateBlock(allocation.state, segment_size);
-	}
-	return allocation;
-}
-
-bool PartialBlockManager::HasBlockAllocation(uint32_t segment_size) {
-	return segment_size <= max_partial_block_size &&
-	       partially_filled_blocks.lower_bound(segment_size) != partially_filled_blocks.end();
-}
-
-void PartialBlockManager::AllocateBlock(PartialBlockState &state, uint32_t segment_size) {
-	D_ASSERT(segment_size <= block_manager.GetBlockSize());
-	if (partial_block_type == PartialBlockType::FULL_CHECKPOINT) {
-		state.block_id = block_manager.GetFreeBlockId();
-	} else {
-		state.block_id = INVALID_BLOCK;
-	}
-	state.block_size = NumericCast<uint32_t>(block_manager.GetBlockSize());
-	state.offset = 0;
-	state.block_use_count = 1;
-}
-
-bool PartialBlockManager::GetPartialBlock(idx_t segment_size, unique_ptr<PartialBlock> &partial_block) {
-	auto entry = partially_filled_blocks.lower_bound(segment_size);
-	if (entry == partially_filled_blocks.end()) {
-		return false;
-	}
-	// found a partially filled block! fill in the info
-	partial_block = std::move(entry->second);
-	partially_filled_blocks.erase(entry);
-
-	D_ASSERT(partial_block->state.offset > 0);
-	D_ASSERT(ValueIsAligned(partial_block->state.offset));
-	return true;
-}
-
-void PartialBlockManager::RegisterPartialBlock(PartialBlockAllocation allocation) {
-	auto &state = allocation.partial_block->state;
-	D_ASSERT(partial_block_type != PartialBlockType::FULL_CHECKPOINT || state.block_id >= 0);
-	if (state.block_use_count < max_use_count) {
-		auto unaligned_size = allocation.allocation_size + state.offset;
-		auto new_size = AlignValue(unaligned_size);
-		if (new_size != unaligned_size) {
-			// register the uninitialized region so we can correctly initialize it before writing to disk
-			allocation.partial_block->AddUninitializedRegion(unaligned_size, new_size);
-		}
-		state.offset = new_size;
-		auto new_space_left = state.block_size - new_size;
-		// check if the block is STILL partially filled after adding the segment_size
-		if (new_space_left >= block_manager.GetBlockSize() - max_partial_block_size) {
-			// the block is still partially filled: add it to the partially_filled_blocks list
-			partially_filled_blocks.insert(make_pair(new_space_left, std::move(allocation.partial_block)));
-		}
-	}
-	idx_t free_space = state.block_size - state.offset;
-	auto block_to_free = std::move(allocation.partial_block);
-	if (!block_to_free && partially_filled_blocks.size() > MAX_BLOCK_MAP_SIZE) {
-		// Free the page with the least space free.
-		auto itr = partially_filled_blocks.begin();
-		block_to_free = std::move(itr->second);
-		free_space = itr->first;
-		partially_filled_blocks.erase(itr);
-	}
-	// Flush any block that we're not going to reuse.
-	if (block_to_free) {
-		block_to_free->Flush(free_space);
-		AddWrittenBlock(block_to_free->state.block_id);
-	}
-}
-
-void PartialBlockManager::Merge(PartialBlockManager &other) {
-	if (&other == this) {
-		throw InternalException("Cannot merge into itself");
-	}
-	// for each partially filled block in the other manager, check if we can merge it into an existing block in this
-	// manager
-	for (auto &e : other.partially_filled_blocks) {
-		if (!e.second) {
-			throw InternalException("Empty partially filled block found");
-		}
-		auto used_space = NumericCast<uint32_t>(block_manager.GetBlockSize() - e.first);
-		if (HasBlockAllocation(used_space)) {
-			// we can merge this block into an existing block - merge them
-			// merge blocks
-			auto allocation = GetBlockAllocation(used_space);
-			allocation.partial_block->Merge(*e.second, allocation.state.offset, used_space);
-
-			// re-register the partial block
-			allocation.state.offset += used_space;
-			RegisterPartialBlock(std::move(allocation));
-		} else {
-			// we cannot merge this block - append it directly to the current block manager
-			partially_filled_blocks.insert(make_pair(e.first, std::move(e.second)));
-		}
-	}
-	// copy over the written blocks
-	for (auto &block_id : other.written_blocks) {
-		AddWrittenBlock(block_id);
-	}
-	other.written_blocks.clear();
-	other.partially_filled_blocks.clear();
-}
-
-void PartialBlockManager::AddWrittenBlock(block_id_t block) {
-	auto entry = written_blocks.insert(block);
-	if (!entry.second) {
-		throw InternalException("Written block already exists");
-	}
-}
-
-void PartialBlockManager::ClearBlocks() {
-	for (auto &e : partially_filled_blocks) {
-		e.second->Clear();
-	}
-	partially_filled_blocks.clear();
-}
-
-void PartialBlockManager::FlushPartialBlocks() {
-	for (auto &e : partially_filled_blocks) {
-		e.second->Flush(e.first);
-	}
-	partially_filled_blocks.clear();
-}
-
-BlockManager &PartialBlockManager::GetBlockManager() const {
-	return block_manager;
-}
-
-void PartialBlockManager::Rollback() {
-	ClearBlocks();
-	for (auto &block_id : written_blocks) {
-		block_manager.MarkBlockAsFree(block_id);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_constraint.cpp b/src/duckdb/src/storage/serialization/serialize_constraint.cpp
deleted file mode 100644
index 9993a59ed..000000000
--- a/src/duckdb/src/storage/serialization/serialize_constraint.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-
-namespace duckdb {
-
-void Constraint::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ConstraintType>(100, "type", type);
-}
-
-unique_ptr<Constraint> Constraint::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ConstraintType>(100, "type");
-	unique_ptr<Constraint> result;
-	switch (type) {
-	case ConstraintType::CHECK:
-		result = CheckConstraint::Deserialize(deserializer);
-		break;
-	case ConstraintType::FOREIGN_KEY:
-		result = ForeignKeyConstraint::Deserialize(deserializer);
-		break;
-	case ConstraintType::NOT_NULL:
-		result = NotNullConstraint::Deserialize(deserializer);
-		break;
-	case ConstraintType::UNIQUE:
-		result = UniqueConstraint::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of Constraint!");
-	}
-	return result;
-}
-
-void CheckConstraint::Serialize(Serializer &serializer) const {
-	Constraint::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "expression", expression);
-}
-
-unique_ptr<Constraint> CheckConstraint::Deserialize(Deserializer &deserializer) {
-	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "expression");
-	auto result = duckdb::unique_ptr<CheckConstraint>(new CheckConstraint(std::move(expression)));
-	return std::move(result);
-}
-
-void ForeignKeyConstraint::Serialize(Serializer &serializer) const {
-	Constraint::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<string>>(200, "pk_columns", pk_columns);
-	serializer.WritePropertyWithDefault<vector<string>>(201, "fk_columns", fk_columns);
-	serializer.WriteProperty<ForeignKeyType>(202, "fk_type", info.type);
-	serializer.WritePropertyWithDefault<string>(203, "schema", info.schema);
-	serializer.WritePropertyWithDefault<string>(204, "table", info.table);
-	serializer.WritePropertyWithDefault<vector<PhysicalIndex>>(205, "pk_keys", info.pk_keys);
-	serializer.WritePropertyWithDefault<vector<PhysicalIndex>>(206, "fk_keys", info.fk_keys);
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ForeignKeyConstraint>(new ForeignKeyConstraint());
-	deserializer.ReadPropertyWithDefault<vector<string>>(200, "pk_columns", result->pk_columns);
-	deserializer.ReadPropertyWithDefault<vector<string>>(201, "fk_columns", result->fk_columns);
-	deserializer.ReadProperty<ForeignKeyType>(202, "fk_type", result->info.type);
-	deserializer.ReadPropertyWithDefault<string>(203, "schema", result->info.schema);
-	deserializer.ReadPropertyWithDefault<string>(204, "table", result->info.table);
-	deserializer.ReadPropertyWithDefault<vector<PhysicalIndex>>(205, "pk_keys", result->info.pk_keys);
-	deserializer.ReadPropertyWithDefault<vector<PhysicalIndex>>(206, "fk_keys", result->info.fk_keys);
-	return std::move(result);
-}
-
-void NotNullConstraint::Serialize(Serializer &serializer) const {
-	Constraint::Serialize(serializer);
-	serializer.WriteProperty<LogicalIndex>(200, "index", index);
-}
-
-unique_ptr<Constraint> NotNullConstraint::Deserialize(Deserializer &deserializer) {
-	auto index = deserializer.ReadProperty<LogicalIndex>(200, "index");
-	auto result = duckdb::unique_ptr<NotNullConstraint>(new NotNullConstraint(index));
-	return std::move(result);
-}
-
-void UniqueConstraint::Serialize(Serializer &serializer) const {
-	Constraint::Serialize(serializer);
-	serializer.WritePropertyWithDefault<bool>(200, "is_primary_key", is_primary_key);
-	serializer.WriteProperty<LogicalIndex>(201, "index", index);
-	serializer.WritePropertyWithDefault<vector<string>>(202, "columns", columns);
-}
-
-unique_ptr<Constraint> UniqueConstraint::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<UniqueConstraint>(new UniqueConstraint());
-	deserializer.ReadPropertyWithDefault<bool>(200, "is_primary_key", result->is_primary_key);
-	deserializer.ReadProperty<LogicalIndex>(201, "index", result->index);
-	deserializer.ReadPropertyWithDefault<vector<string>>(202, "columns", result->columns);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_create_info.cpp b/src/duckdb/src/storage/serialization/serialize_create_info.cpp
deleted file mode 100644
index 9ec88c13b..000000000
--- a/src/duckdb/src/storage/serialization/serialize_create_info.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-
-namespace duckdb {
-
-void CreateInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<CatalogType>(100, "type", type);
-	serializer.WritePropertyWithDefault<string>(101, "catalog", catalog);
-	serializer.WritePropertyWithDefault<string>(102, "schema", schema);
-	serializer.WritePropertyWithDefault<bool>(103, "temporary", temporary);
-	serializer.WritePropertyWithDefault<bool>(104, "internal", internal);
-	serializer.WriteProperty<OnCreateConflict>(105, "on_conflict", on_conflict);
-	serializer.WritePropertyWithDefault<string>(106, "sql", sql);
-	serializer.WritePropertyWithDefault<Value>(107, "comment", comment, Value());
-	serializer.WritePropertyWithDefault<unordered_map<string, string>>(108, "tags", tags, unordered_map<string, string>());
-	if (serializer.ShouldSerialize(2)) {
-		serializer.WritePropertyWithDefault<LogicalDependencyList>(109, "dependencies", dependencies, LogicalDependencyList());
-	}
-}
-
-unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<CatalogType>(100, "type");
-	auto catalog = deserializer.ReadPropertyWithDefault<string>(101, "catalog");
-	auto schema = deserializer.ReadPropertyWithDefault<string>(102, "schema");
-	auto temporary = deserializer.ReadPropertyWithDefault<bool>(103, "temporary");
-	auto internal = deserializer.ReadPropertyWithDefault<bool>(104, "internal");
-	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>(105, "on_conflict");
-	auto sql = deserializer.ReadPropertyWithDefault<string>(106, "sql");
-	auto comment = deserializer.ReadPropertyWithExplicitDefault<Value>(107, "comment", Value());
-	auto tags = deserializer.ReadPropertyWithExplicitDefault<unordered_map<string, string>>(108, "tags", unordered_map<string, string>());
-	auto dependencies = deserializer.ReadPropertyWithExplicitDefault<LogicalDependencyList>(109, "dependencies", LogicalDependencyList());
-	deserializer.Set<CatalogType>(type);
-	unique_ptr<CreateInfo> result;
-	switch (type) {
-	case CatalogType::INDEX_ENTRY:
-		result = CreateIndexInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::MACRO_ENTRY:
-		result = CreateMacroInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::SCHEMA_ENTRY:
-		result = CreateSchemaInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::SEQUENCE_ENTRY:
-		result = CreateSequenceInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::TABLE_ENTRY:
-		result = CreateTableInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::TABLE_MACRO_ENTRY:
-		result = CreateMacroInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::TYPE_ENTRY:
-		result = CreateTypeInfo::Deserialize(deserializer);
-		break;
-	case CatalogType::VIEW_ENTRY:
-		result = CreateViewInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of CreateInfo!");
-	}
-	deserializer.Unset<CatalogType>();
-	result->catalog = std::move(catalog);
-	result->schema = std::move(schema);
-	result->temporary = temporary;
-	result->internal = internal;
-	result->on_conflict = on_conflict;
-	result->sql = std::move(sql);
-	result->comment = comment;
-	result->tags = std::move(tags);
-	result->dependencies = dependencies;
-	return result;
-}
-
-void CreateIndexInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", index_name);
-	serializer.WritePropertyWithDefault<string>(201, "table", table);
-	/* [Deleted] (DeprecatedIndexType) "index_type" */
-	serializer.WriteProperty<IndexConstraintType>(203, "constraint_type", constraint_type);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(204, "parsed_expressions", parsed_expressions);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(205, "scan_types", scan_types);
-	serializer.WritePropertyWithDefault<vector<string>>(206, "names", names);
-	serializer.WritePropertyWithDefault<vector<column_t>>(207, "column_ids", column_ids);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<Value>>(208, "options", options);
-	serializer.WritePropertyWithDefault<string>(209, "index_type_name", index_type);
-}
-
-unique_ptr<CreateInfo> CreateIndexInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->index_name);
-	deserializer.ReadPropertyWithDefault<string>(201, "table", result->table);
-	deserializer.ReadDeletedProperty<DeprecatedIndexType>(202, "index_type");
-	deserializer.ReadProperty<IndexConstraintType>(203, "constraint_type", result->constraint_type);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(204, "parsed_expressions", result->parsed_expressions);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(205, "scan_types", result->scan_types);
-	deserializer.ReadPropertyWithDefault<vector<string>>(206, "names", result->names);
-	deserializer.ReadPropertyWithDefault<vector<column_t>>(207, "column_ids", result->column_ids);
-	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<Value>>(208, "options", result->options);
-	deserializer.ReadPropertyWithDefault<string>(209, "index_type_name", result->index_type);
-	return std::move(result);
-}
-
-void CreateMacroInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WritePropertyWithDefault<unique_ptr<MacroFunction>>(201, "function", macros[0]);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<MacroFunction>>>(202, "extra_functions", GetAllButFirstFunction());
-}
-
-unique_ptr<CreateInfo> CreateMacroInfo::Deserialize(Deserializer &deserializer) {
-	auto name = deserializer.ReadPropertyWithDefault<string>(200, "name");
-	auto function = deserializer.ReadPropertyWithDefault<unique_ptr<MacroFunction>>(201, "function");
-	auto extra_functions = deserializer.ReadPropertyWithDefault<vector<unique_ptr<MacroFunction>>>(202, "extra_functions");
-	auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo(deserializer.Get<CatalogType>(), std::move(function), std::move(extra_functions)));
-	result->name = std::move(name);
-	return std::move(result);
-}
-
-void CreateSchemaInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-}
-
-unique_ptr<CreateInfo> CreateSchemaInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateSchemaInfo>(new CreateSchemaInfo());
-	return std::move(result);
-}
-
-void CreateSequenceInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WritePropertyWithDefault<uint64_t>(201, "usage_count", usage_count);
-	serializer.WritePropertyWithDefault<int64_t>(202, "increment", increment);
-	serializer.WritePropertyWithDefault<int64_t>(203, "min_value", min_value);
-	serializer.WritePropertyWithDefault<int64_t>(204, "max_value", max_value);
-	serializer.WritePropertyWithDefault<int64_t>(205, "start_value", start_value);
-	serializer.WritePropertyWithDefault<bool>(206, "cycle", cycle);
-}
-
-unique_ptr<CreateInfo> CreateSequenceInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateSequenceInfo>(new CreateSequenceInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
-	deserializer.ReadPropertyWithDefault<uint64_t>(201, "usage_count", result->usage_count);
-	deserializer.ReadPropertyWithDefault<int64_t>(202, "increment", result->increment);
-	deserializer.ReadPropertyWithDefault<int64_t>(203, "min_value", result->min_value);
-	deserializer.ReadPropertyWithDefault<int64_t>(204, "max_value", result->max_value);
-	deserializer.ReadPropertyWithDefault<int64_t>(205, "start_value", result->start_value);
-	deserializer.ReadPropertyWithDefault<bool>(206, "cycle", result->cycle);
-	return std::move(result);
-}
-
-void CreateTableInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "table", table);
-	serializer.WriteProperty<ColumnList>(201, "columns", columns);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Constraint>>>(202, "constraints", constraints);
-	serializer.WritePropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", query);
-}
-
-unique_ptr<CreateInfo> CreateTableInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateTableInfo>(new CreateTableInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "table", result->table);
-	deserializer.ReadProperty<ColumnList>(201, "columns", result->columns);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Constraint>>>(202, "constraints", result->constraints);
-	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", result->query);
-	return std::move(result);
-}
-
-void CreateTypeInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WriteProperty<LogicalType>(201, "logical_type", type);
-}
-
-unique_ptr<CreateInfo> CreateTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateTypeInfo>(new CreateTypeInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
-	deserializer.ReadProperty<LogicalType>(201, "logical_type", result->type);
-	return std::move(result);
-}
-
-void CreateViewInfo::Serialize(Serializer &serializer) const {
-	CreateInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "view_name", view_name);
-	serializer.WritePropertyWithDefault<vector<string>>(201, "aliases", aliases);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(202, "types", types);
-	serializer.WritePropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", query);
-	serializer.WritePropertyWithDefault<vector<string>>(204, "names", names);
-	serializer.WritePropertyWithDefault<vector<Value>>(205, "column_comments", column_comments, vector<Value>());
-}
-
-unique_ptr<CreateInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateViewInfo>(new CreateViewInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "view_name", result->view_name);
-	deserializer.ReadPropertyWithDefault<vector<string>>(201, "aliases", result->aliases);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(202, "types", result->types);
-	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", result->query);
-	deserializer.ReadPropertyWithDefault<vector<string>>(204, "names", result->names);
-	deserializer.ReadPropertyWithExplicitDefault<vector<Value>>(205, "column_comments", result->column_comments, vector<Value>());
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_dependency.cpp b/src/duckdb/src/storage/serialization/serialize_dependency.cpp
deleted file mode 100644
index b2c22375a..000000000
--- a/src/duckdb/src/storage/serialization/serialize_dependency.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/catalog/dependency.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-
-namespace duckdb {
-
-void CatalogEntryInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<CatalogType>(100, "type", type);
-	serializer.WritePropertyWithDefault<string>(101, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(102, "name", name);
-}
-
-CatalogEntryInfo CatalogEntryInfo::Deserialize(Deserializer &deserializer) {
-	CatalogEntryInfo result;
-	deserializer.ReadProperty<CatalogType>(100, "type", result.type);
-	deserializer.ReadPropertyWithDefault<string>(101, "schema", result.schema);
-	deserializer.ReadPropertyWithDefault<string>(102, "name", result.name);
-	return result;
-}
-
-void LogicalDependency::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<CatalogEntryInfo>(100, "entry", entry);
-	serializer.WritePropertyWithDefault<string>(101, "catalog", catalog);
-}
-
-LogicalDependency LogicalDependency::Deserialize(Deserializer &deserializer) {
-	LogicalDependency result;
-	deserializer.ReadProperty<CatalogEntryInfo>(100, "entry", result.entry);
-	deserializer.ReadPropertyWithDefault<string>(101, "catalog", result.catalog);
-	return result;
-}
-
-void LogicalDependencyList::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<create_info_set_t>(100, "set", set);
-}
-
-LogicalDependencyList LogicalDependencyList::Deserialize(Deserializer &deserializer) {
-	LogicalDependencyList result;
-	deserializer.ReadProperty<create_info_set_t>(100, "set", result.set);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_expression.cpp b/src/duckdb/src/storage/serialization/serialize_expression.cpp
deleted file mode 100644
index 28efdeb7d..000000000
--- a/src/duckdb/src/storage/serialization/serialize_expression.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/planner/expression/list.hpp"
-
-namespace duckdb {
-
-void Expression::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ExpressionClass>(100, "expression_class", expression_class);
-	serializer.WriteProperty<ExpressionType>(101, "type", type);
-	serializer.WritePropertyWithDefault<string>(102, "alias", alias);
-	serializer.WritePropertyWithDefault<optional_idx>(103, "query_location", query_location, optional_idx());
-}
-
-unique_ptr<Expression> Expression::Deserialize(Deserializer &deserializer) {
-	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "expression_class");
-	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
-	auto alias = deserializer.ReadPropertyWithDefault<string>(102, "alias");
-	auto query_location = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(103, "query_location", optional_idx());
-	deserializer.Set<ExpressionType>(type);
-	unique_ptr<Expression> result;
-	switch (expression_class) {
-	case ExpressionClass::BOUND_AGGREGATE:
-		result = BoundAggregateExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_BETWEEN:
-		result = BoundBetweenExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_CASE:
-		result = BoundCaseExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_CAST:
-		result = BoundCastExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_COLUMN_REF:
-		result = BoundColumnRefExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_COMPARISON:
-		result = BoundComparisonExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_CONJUNCTION:
-		result = BoundConjunctionExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_CONSTANT:
-		result = BoundConstantExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_DEFAULT:
-		result = BoundDefaultExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_FUNCTION:
-		result = BoundFunctionExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_LAMBDA:
-		result = BoundLambdaExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_LAMBDA_REF:
-		result = BoundLambdaRefExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_OPERATOR:
-		result = BoundOperatorExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_PARAMETER:
-		result = BoundParameterExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_REF:
-		result = BoundReferenceExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_UNNEST:
-		result = BoundUnnestExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::BOUND_WINDOW:
-		result = BoundWindowExpression::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of Expression!");
-	}
-	deserializer.Unset<ExpressionType>();
-	result->alias = std::move(alias);
-	result->query_location = query_location;
-	return result;
-}
-
-void BoundBetweenExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(200, "input", input);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(201, "lower", lower);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(202, "upper", upper);
-	serializer.WritePropertyWithDefault<bool>(203, "lower_inclusive", lower_inclusive);
-	serializer.WritePropertyWithDefault<bool>(204, "upper_inclusive", upper_inclusive);
-}
-
-unique_ptr<Expression> BoundBetweenExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BoundBetweenExpression>(new BoundBetweenExpression());
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(200, "input", result->input);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(201, "lower", result->lower);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "upper", result->upper);
-	deserializer.ReadPropertyWithDefault<bool>(203, "lower_inclusive", result->lower_inclusive);
-	deserializer.ReadPropertyWithDefault<bool>(204, "upper_inclusive", result->upper_inclusive);
-	return std::move(result);
-}
-
-void BoundCaseExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WritePropertyWithDefault<vector<BoundCaseCheck>>(201, "case_checks", case_checks);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(202, "else_expr", else_expr);
-}
-
-unique_ptr<Expression> BoundCaseExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto result = duckdb::unique_ptr<BoundCaseExpression>(new BoundCaseExpression(std::move(return_type)));
-	deserializer.ReadPropertyWithDefault<vector<BoundCaseCheck>>(201, "case_checks", result->case_checks);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "else_expr", result->else_expr);
-	return std::move(result);
-}
-
-void BoundCastExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(200, "child", child);
-	serializer.WriteProperty<LogicalType>(201, "return_type", return_type);
-	serializer.WritePropertyWithDefault<bool>(202, "try_cast", try_cast);
-}
-
-unique_ptr<Expression> BoundCastExpression::Deserialize(Deserializer &deserializer) {
-	auto child = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(200, "child");
-	auto return_type = deserializer.ReadProperty<LogicalType>(201, "return_type");
-	auto result = duckdb::unique_ptr<BoundCastExpression>(new BoundCastExpression(deserializer.Get<ClientContext &>(), std::move(child), std::move(return_type)));
-	deserializer.ReadPropertyWithDefault<bool>(202, "try_cast", result->try_cast);
-	return std::move(result);
-}
-
-void BoundColumnRefExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WriteProperty<ColumnBinding>(201, "binding", binding);
-	serializer.WritePropertyWithDefault<idx_t>(202, "depth", depth);
-}
-
-unique_ptr<Expression> BoundColumnRefExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto binding = deserializer.ReadProperty<ColumnBinding>(201, "binding");
-	auto depth = deserializer.ReadPropertyWithDefault<idx_t>(202, "depth");
-	auto result = duckdb::unique_ptr<BoundColumnRefExpression>(new BoundColumnRefExpression(std::move(return_type), binding, depth));
-	return std::move(result);
-}
-
-void BoundComparisonExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(200, "left", left);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(201, "right", right);
-}
-
-unique_ptr<Expression> BoundComparisonExpression::Deserialize(Deserializer &deserializer) {
-	auto left = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(200, "left");
-	auto right = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(201, "right");
-	auto result = duckdb::unique_ptr<BoundComparisonExpression>(new BoundComparisonExpression(deserializer.Get<ExpressionType>(), std::move(left), std::move(right)));
-	return std::move(result);
-}
-
-void BoundConjunctionExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(200, "children", children);
-}
-
-unique_ptr<Expression> BoundConjunctionExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BoundConjunctionExpression>(new BoundConjunctionExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(200, "children", result->children);
-	return std::move(result);
-}
-
-void BoundConstantExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<Value>(200, "value", value);
-}
-
-unique_ptr<Expression> BoundConstantExpression::Deserialize(Deserializer &deserializer) {
-	auto value = deserializer.ReadProperty<Value>(200, "value");
-	auto result = duckdb::unique_ptr<BoundConstantExpression>(new BoundConstantExpression(value));
-	return std::move(result);
-}
-
-void BoundDefaultExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-}
-
-unique_ptr<Expression> BoundDefaultExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto result = duckdb::unique_ptr<BoundDefaultExpression>(new BoundDefaultExpression(std::move(return_type)));
-	return std::move(result);
-}
-
-void BoundLambdaExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(201, "lambda_expr", lambda_expr);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(202, "captures", captures);
-	serializer.WritePropertyWithDefault<idx_t>(203, "parameter_count", parameter_count);
-}
-
-unique_ptr<Expression> BoundLambdaExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto lambda_expr = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(201, "lambda_expr");
-	auto captures = deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(202, "captures");
-	auto parameter_count = deserializer.ReadPropertyWithDefault<idx_t>(203, "parameter_count");
-	auto result = duckdb::unique_ptr<BoundLambdaExpression>(new BoundLambdaExpression(deserializer.Get<ExpressionType>(), std::move(return_type), std::move(lambda_expr), parameter_count));
-	result->captures = std::move(captures);
-	return std::move(result);
-}
-
-void BoundLambdaRefExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WriteProperty<ColumnBinding>(201, "binding", binding);
-	serializer.WritePropertyWithDefault<idx_t>(202, "lambda_index", lambda_idx);
-	serializer.WritePropertyWithDefault<idx_t>(203, "depth", depth);
-}
-
-unique_ptr<Expression> BoundLambdaRefExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto binding = deserializer.ReadProperty<ColumnBinding>(201, "binding");
-	auto lambda_idx = deserializer.ReadPropertyWithDefault<idx_t>(202, "lambda_index");
-	auto depth = deserializer.ReadPropertyWithDefault<idx_t>(203, "depth");
-	auto result = duckdb::unique_ptr<BoundLambdaRefExpression>(new BoundLambdaRefExpression(std::move(return_type), binding, lambda_idx, depth));
-	return std::move(result);
-}
-
-void BoundOperatorExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(201, "children", children);
-}
-
-unique_ptr<Expression> BoundOperatorExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto result = duckdb::unique_ptr<BoundOperatorExpression>(new BoundOperatorExpression(deserializer.Get<ExpressionType>(), std::move(return_type)));
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(201, "children", result->children);
-	return std::move(result);
-}
-
-void BoundParameterExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "identifier", identifier);
-	serializer.WriteProperty<LogicalType>(201, "return_type", return_type);
-	serializer.WritePropertyWithDefault<shared_ptr<BoundParameterData>>(202, "parameter_data", parameter_data);
-}
-
-unique_ptr<Expression> BoundParameterExpression::Deserialize(Deserializer &deserializer) {
-	auto identifier = deserializer.ReadPropertyWithDefault<string>(200, "identifier");
-	auto return_type = deserializer.ReadProperty<LogicalType>(201, "return_type");
-	auto parameter_data = deserializer.ReadPropertyWithDefault<shared_ptr<BoundParameterData>>(202, "parameter_data");
-	auto result = duckdb::unique_ptr<BoundParameterExpression>(new BoundParameterExpression(deserializer.Get<bound_parameter_map_t &>(), std::move(identifier), std::move(return_type), std::move(parameter_data)));
-	return std::move(result);
-}
-
-void BoundReferenceExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WritePropertyWithDefault<idx_t>(201, "index", index);
-}
-
-unique_ptr<Expression> BoundReferenceExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto index = deserializer.ReadPropertyWithDefault<idx_t>(201, "index");
-	auto result = duckdb::unique_ptr<BoundReferenceExpression>(new BoundReferenceExpression(std::move(return_type), index));
-	return std::move(result);
-}
-
-void BoundUnnestExpression::Serialize(Serializer &serializer) const {
-	Expression::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "return_type", return_type);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(201, "child", child);
-}
-
-unique_ptr<Expression> BoundUnnestExpression::Deserialize(Deserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
-	auto result = duckdb::unique_ptr<BoundUnnestExpression>(new BoundUnnestExpression(std::move(return_type)));
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(201, "child", result->child);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_extension_install_info.cpp b/src/duckdb/src/storage/serialization/serialize_extension_install_info.cpp
deleted file mode 100644
index 9d43be0ce..000000000
--- a/src/duckdb/src/storage/serialization/serialize_extension_install_info.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/main/extension_install_info.hpp"
-
-namespace duckdb {
-
-void ExtensionInstallInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ExtensionInstallMode>(100, "mode", mode);
-	serializer.WritePropertyWithDefault<string>(101, "full_path", full_path);
-	serializer.WritePropertyWithDefault<string>(102, "repository_url", repository_url);
-	serializer.WritePropertyWithDefault<string>(103, "version", version);
-	serializer.WritePropertyWithDefault<string>(104, "etag", etag);
-}
-
-unique_ptr<ExtensionInstallInfo> ExtensionInstallInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ExtensionInstallInfo>(new ExtensionInstallInfo());
-	deserializer.ReadProperty<ExtensionInstallMode>(100, "mode", result->mode);
-	deserializer.ReadPropertyWithDefault<string>(101, "full_path", result->full_path);
-	deserializer.ReadPropertyWithDefault<string>(102, "repository_url", result->repository_url);
-	deserializer.ReadPropertyWithDefault<string>(103, "version", result->version);
-	deserializer.ReadPropertyWithDefault<string>(104, "etag", result->etag);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_extra_drop_info.cpp b/src/duckdb/src/storage/serialization/serialize_extra_drop_info.cpp
deleted file mode 100644
index fcdfd4197..000000000
--- a/src/duckdb/src/storage/serialization/serialize_extra_drop_info.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/parsed_data/extra_drop_info.hpp"
-
-namespace duckdb {
-
-void ExtraDropInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ExtraDropInfoType>(100, "info_type", info_type);
-}
-
-unique_ptr<ExtraDropInfo> ExtraDropInfo::Deserialize(Deserializer &deserializer) {
-	auto info_type = deserializer.ReadProperty<ExtraDropInfoType>(100, "info_type");
-	unique_ptr<ExtraDropInfo> result;
-	switch (info_type) {
-	case ExtraDropInfoType::SECRET_INFO:
-		result = ExtraDropSecretInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of ExtraDropInfo!");
-	}
-	return result;
-}
-
-void ExtraDropSecretInfo::Serialize(Serializer &serializer) const {
-	ExtraDropInfo::Serialize(serializer);
-	serializer.WriteProperty<SecretPersistType>(200, "persist_mode", persist_mode);
-	serializer.WritePropertyWithDefault<string>(201, "secret_storage", secret_storage);
-}
-
-unique_ptr<ExtraDropInfo> ExtraDropSecretInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ExtraDropSecretInfo>(new ExtraDropSecretInfo());
-	deserializer.ReadProperty<SecretPersistType>(200, "persist_mode", result->persist_mode);
-	deserializer.ReadPropertyWithDefault<string>(201, "secret_storage", result->secret_storage);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp b/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp
deleted file mode 100644
index 9288cec21..000000000
--- a/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp
+++ /dev/null
@@ -1,762 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/planner/operator/list.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-namespace duckdb {
-
-void LogicalOperator::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<LogicalOperatorType>(100, "type", type);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<LogicalOperator>>>(101, "children", children);
-}
-
-unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<LogicalOperatorType>(100, "type");
-	auto children = deserializer.ReadPropertyWithDefault<vector<unique_ptr<LogicalOperator>>>(101, "children");
-	deserializer.Set<LogicalOperatorType>(type);
-	unique_ptr<LogicalOperator> result;
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		result = LogicalAggregate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_ALTER:
-		result = LogicalSimple::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		result = LogicalAnyJoin::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		result = LogicalComparisonJoin::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		result = LogicalSimple::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		result = LogicalColumnDataGet::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		result = LogicalComparisonJoin::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_COPY_DATABASE:
-		result = LogicalCopyDatabase::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		result = LogicalCopyToFile::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		result = LogicalCreateIndex::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		result = LogicalCreate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		result = LogicalCreate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		result = LogicalCreate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		result = LogicalCreateTable::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		result = LogicalCreate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		result = LogicalCreate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		result = LogicalCrossProduct::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_CTE_REF:
-		result = LogicalCTERef::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DELETE:
-		result = LogicalDelete::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		result = LogicalDelimGet::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		result = LogicalComparisonJoin::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DETACH:
-		result = LogicalSimple::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		result = LogicalDistinct::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DROP:
-		result = LogicalSimple::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		result = LogicalDummyScan::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		result = LogicalEmptyResult::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		result = LogicalSetOperation::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		result = LogicalExplain::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_EXPORT:
-		result = LogicalExport::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		result = LogicalExpressionGet::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		result = LogicalExtensionOperator::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_FILTER:
-		result = LogicalFilter::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_GET:
-		result = LogicalGet::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_INSERT:
-		result = LogicalInsert::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		result = LogicalSetOperation::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		result = LogicalLimit::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_LOAD:
-		result = LogicalSimple::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-		result = LogicalMaterializedCTE::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		result = LogicalOrder::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_PIVOT:
-		result = LogicalPivot::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		result = LogicalPositionalJoin::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		result = LogicalProjection::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		result = LogicalRecursiveCTE::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_RESET:
-		result = LogicalReset::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		result = LogicalSample::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_SET:
-		result = LogicalSet::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_TOP_N:
-		result = LogicalTopN::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		result = LogicalSimple::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_UNION:
-		result = LogicalSetOperation::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		result = LogicalUnnest::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_UPDATE:
-		result = LogicalUpdate::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		result = LogicalVacuum::Deserialize(deserializer);
-		break;
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		result = LogicalWindow::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of LogicalOperator!");
-	}
-	deserializer.Unset<LogicalOperatorType>();
-	result->children = std::move(children);
-	return result;
-}
-
-void FilenamePattern::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(200, "base", base);
-	serializer.WritePropertyWithDefault<idx_t>(201, "pos", pos);
-	serializer.WritePropertyWithDefault<bool>(202, "uuid", uuid);
-}
-
-FilenamePattern FilenamePattern::Deserialize(Deserializer &deserializer) {
-	FilenamePattern result;
-	deserializer.ReadPropertyWithDefault<string>(200, "base", result.base);
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "pos", result.pos);
-	deserializer.ReadPropertyWithDefault<bool>(202, "uuid", result.uuid);
-	return result;
-}
-
-void LogicalAggregate::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(200, "expressions", expressions);
-	serializer.WritePropertyWithDefault<idx_t>(201, "group_index", group_index);
-	serializer.WritePropertyWithDefault<idx_t>(202, "aggregate_index", aggregate_index);
-	serializer.WritePropertyWithDefault<idx_t>(203, "groupings_index", groupings_index);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(204, "groups", groups);
-	serializer.WritePropertyWithDefault<vector<GroupingSet>>(205, "grouping_sets", grouping_sets);
-	serializer.WritePropertyWithDefault<vector<unsafe_vector<idx_t>>>(206, "grouping_functions", grouping_functions);
-}
-
-unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(Deserializer &deserializer) {
-	auto expressions = deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(200, "expressions");
-	auto group_index = deserializer.ReadPropertyWithDefault<idx_t>(201, "group_index");
-	auto aggregate_index = deserializer.ReadPropertyWithDefault<idx_t>(202, "aggregate_index");
-	auto result = duckdb::unique_ptr<LogicalAggregate>(new LogicalAggregate(group_index, aggregate_index, std::move(expressions)));
-	deserializer.ReadPropertyWithDefault<idx_t>(203, "groupings_index", result->groupings_index);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(204, "groups", result->groups);
-	deserializer.ReadPropertyWithDefault<vector<GroupingSet>>(205, "grouping_sets", result->grouping_sets);
-	deserializer.ReadPropertyWithDefault<vector<unsafe_vector<idx_t>>>(206, "grouping_functions", result->grouping_functions);
-	return std::move(result);
-}
-
-void LogicalAnyJoin::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty<JoinType>(200, "join_type", join_type);
-	serializer.WritePropertyWithDefault<idx_t>(201, "mark_index", mark_index);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(202, "left_projection_map", left_projection_map);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(203, "right_projection_map", right_projection_map);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(204, "condition", condition);
-}
-
-unique_ptr<LogicalOperator> LogicalAnyJoin::Deserialize(Deserializer &deserializer) {
-	auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
-	auto result = duckdb::unique_ptr<LogicalAnyJoin>(new LogicalAnyJoin(join_type));
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "mark_index", result->mark_index);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(202, "left_projection_map", result->left_projection_map);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(203, "right_projection_map", result->right_projection_map);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(204, "condition", result->condition);
-	return std::move(result);
-}
-
-void LogicalCTERef::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<idx_t>(201, "cte_index", cte_index);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(202, "chunk_types", chunk_types);
-	serializer.WritePropertyWithDefault<vector<string>>(203, "bound_columns", bound_columns);
-	serializer.WriteProperty<CTEMaterialize>(204, "materialized_cte", materialized_cte);
-}
-
-unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto cte_index = deserializer.ReadPropertyWithDefault<idx_t>(201, "cte_index");
-	auto chunk_types = deserializer.ReadPropertyWithDefault<vector<LogicalType>>(202, "chunk_types");
-	auto bound_columns = deserializer.ReadPropertyWithDefault<vector<string>>(203, "bound_columns");
-	auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>(204, "materialized_cte");
-	auto result = duckdb::unique_ptr<LogicalCTERef>(new LogicalCTERef(table_index, cte_index, std::move(chunk_types), std::move(bound_columns), materialized_cte));
-	return std::move(result);
-}
-
-void LogicalColumnDataGet::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(201, "chunk_types", chunk_types);
-	serializer.WritePropertyWithDefault<optionally_owned_ptr<ColumnDataCollection>>(202, "collection", collection);
-}
-
-unique_ptr<LogicalOperator> LogicalColumnDataGet::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto chunk_types = deserializer.ReadPropertyWithDefault<vector<LogicalType>>(201, "chunk_types");
-	auto collection = deserializer.ReadPropertyWithDefault<optionally_owned_ptr<ColumnDataCollection>>(202, "collection");
-	auto result = duckdb::unique_ptr<LogicalColumnDataGet>(new LogicalColumnDataGet(table_index, std::move(chunk_types), std::move(collection)));
-	return std::move(result);
-}
-
-void LogicalComparisonJoin::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty<JoinType>(200, "join_type", join_type);
-	serializer.WritePropertyWithDefault<idx_t>(201, "mark_index", mark_index);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(202, "left_projection_map", left_projection_map);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(203, "right_projection_map", right_projection_map);
-	serializer.WritePropertyWithDefault<vector<JoinCondition>>(204, "conditions", conditions);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(205, "mark_types", mark_types);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(206, "duplicate_eliminated_columns", duplicate_eliminated_columns);
-	serializer.WritePropertyWithDefault<bool>(207, "delim_flipped", delim_flipped, false);
-}
-
-unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(Deserializer &deserializer) {
-	auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
-	auto result = duckdb::unique_ptr<LogicalComparisonJoin>(new LogicalComparisonJoin(join_type, deserializer.Get<LogicalOperatorType>()));
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "mark_index", result->mark_index);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(202, "left_projection_map", result->left_projection_map);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(203, "right_projection_map", result->right_projection_map);
-	deserializer.ReadPropertyWithDefault<vector<JoinCondition>>(204, "conditions", result->conditions);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(205, "mark_types", result->mark_types);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(206, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
-	deserializer.ReadPropertyWithExplicitDefault<bool>(207, "delim_flipped", result->delim_flipped, false);
-	return std::move(result);
-}
-
-void LogicalCopyDatabase::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CopyDatabaseInfo>>(200, "info", info);
-}
-
-unique_ptr<LogicalOperator> LogicalCopyDatabase::Deserialize(Deserializer &deserializer) {
-	auto info = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(200, "info");
-	auto result = duckdb::unique_ptr<LogicalCopyDatabase>(new LogicalCopyDatabase(std::move(info)));
-	return std::move(result);
-}
-
-void LogicalCreate::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CreateInfo>>(200, "info", info);
-}
-
-unique_ptr<LogicalOperator> LogicalCreate::Deserialize(Deserializer &deserializer) {
-	auto info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(200, "info");
-	auto result = duckdb::unique_ptr<LogicalCreate>(new LogicalCreate(deserializer.Get<LogicalOperatorType>(), deserializer.Get<ClientContext &>(), std::move(info)));
-	return std::move(result);
-}
-
-void LogicalCreateIndex::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CreateIndexInfo>>(200, "info", info);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(201, "unbound_expressions", unbound_expressions);
-	serializer.WritePropertyWithDefault<unique_ptr<AlterTableInfo>>(202, "alter_table_info", alter_table_info);
-}
-
-unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(Deserializer &deserializer) {
-	auto info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(200, "info");
-	auto unbound_expressions = deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(201, "unbound_expressions");
-	auto alter_table_info = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(202, "alter_table_info");
-	auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions), std::move(alter_table_info)));
-	return std::move(result);
-}
-
-void LogicalCreateTable::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CreateInfo>>(200, "info", info->base);
-}
-
-unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(Deserializer &deserializer) {
-	auto info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(200, "info");
-	auto result = duckdb::unique_ptr<LogicalCreateTable>(new LogicalCreateTable(deserializer.Get<ClientContext &>(), std::move(info)));
-	return std::move(result);
-}
-
-void LogicalCrossProduct::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-}
-
-unique_ptr<LogicalOperator> LogicalCrossProduct::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalCrossProduct>(new LogicalCrossProduct());
-	return std::move(result);
-}
-
-void LogicalDelete::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CreateInfo>>(200, "table_info", table.GetInfo());
-	serializer.WritePropertyWithDefault<idx_t>(201, "table_index", table_index);
-	serializer.WritePropertyWithDefault<bool>(202, "return_chunk", return_chunk);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(203, "expressions", expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalDelete::Deserialize(Deserializer &deserializer) {
-	auto table_info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(200, "table_info");
-	auto result = duckdb::unique_ptr<LogicalDelete>(new LogicalDelete(deserializer.Get<ClientContext &>(), table_info));
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "table_index", result->table_index);
-	deserializer.ReadPropertyWithDefault<bool>(202, "return_chunk", result->return_chunk);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(203, "expressions", result->expressions);
-	return std::move(result);
-}
-
-void LogicalDelimGet::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(201, "chunk_types", chunk_types);
-}
-
-unique_ptr<LogicalOperator> LogicalDelimGet::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto chunk_types = deserializer.ReadPropertyWithDefault<vector<LogicalType>>(201, "chunk_types");
-	auto result = duckdb::unique_ptr<LogicalDelimGet>(new LogicalDelimGet(table_index, std::move(chunk_types)));
-	return std::move(result);
-}
-
-void LogicalDistinct::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty<DistinctType>(200, "distinct_type", distinct_type);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(201, "distinct_targets", distinct_targets);
-	serializer.WritePropertyWithDefault<unique_ptr<BoundOrderModifier>>(202, "order_by", order_by);
-}
-
-unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(Deserializer &deserializer) {
-	auto distinct_type = deserializer.ReadProperty<DistinctType>(200, "distinct_type");
-	auto distinct_targets = deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(201, "distinct_targets");
-	auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
-	deserializer.ReadPropertyWithDefault<unique_ptr<BoundOrderModifier>>(202, "order_by", result->order_by);
-	return std::move(result);
-}
-
-void LogicalDummyScan::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-}
-
-unique_ptr<LogicalOperator> LogicalDummyScan::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto result = duckdb::unique_ptr<LogicalDummyScan>(new LogicalDummyScan(table_index));
-	return std::move(result);
-}
-
-void LogicalEmptyResult::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(200, "return_types", return_types);
-	serializer.WritePropertyWithDefault<vector<ColumnBinding>>(201, "bindings", bindings);
-}
-
-unique_ptr<LogicalOperator> LogicalEmptyResult::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(200, "return_types", result->return_types);
-	deserializer.ReadPropertyWithDefault<vector<ColumnBinding>>(201, "bindings", result->bindings);
-	return std::move(result);
-}
-
-void LogicalExplain::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty<ExplainType>(200, "explain_type", explain_type);
-	serializer.WritePropertyWithDefault<string>(201, "physical_plan", physical_plan);
-	serializer.WritePropertyWithDefault<string>(202, "logical_plan_unopt", logical_plan_unopt);
-	serializer.WritePropertyWithDefault<string>(203, "logical_plan_opt", logical_plan_opt);
-}
-
-unique_ptr<LogicalOperator> LogicalExplain::Deserialize(Deserializer &deserializer) {
-	auto explain_type = deserializer.ReadProperty<ExplainType>(200, "explain_type");
-	auto result = duckdb::unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
-	deserializer.ReadPropertyWithDefault<string>(201, "physical_plan", result->physical_plan);
-	deserializer.ReadPropertyWithDefault<string>(202, "logical_plan_unopt", result->logical_plan_unopt);
-	deserializer.ReadPropertyWithDefault<string>(203, "logical_plan_opt", result->logical_plan_opt);
-	return std::move(result);
-}
-
-void LogicalExport::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CopyInfo>>(200, "copy_info", copy_info);
-	serializer.WritePropertyWithDefault<unique_ptr<BoundExportData>>(201, "exported_tables", exported_tables);
-}
-
-unique_ptr<LogicalOperator> LogicalExport::Deserialize(Deserializer &deserializer) {
-	auto copy_info = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(200, "copy_info");
-	auto exported_tables = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(201, "exported_tables");
-	auto result = duckdb::unique_ptr<LogicalExport>(new LogicalExport(deserializer.Get<ClientContext &>(), std::move(copy_info), std::move(exported_tables)));
-	return std::move(result);
-}
-
-void LogicalExpressionGet::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(201, "expr_types", expr_types);
-	serializer.WritePropertyWithDefault<vector<vector<unique_ptr<Expression>>>>(202, "expressions", expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalExpressionGet::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto expr_types = deserializer.ReadPropertyWithDefault<vector<LogicalType>>(201, "expr_types");
-	auto expressions = deserializer.ReadPropertyWithDefault<vector<vector<unique_ptr<Expression>>>>(202, "expressions");
-	auto result = duckdb::unique_ptr<LogicalExpressionGet>(new LogicalExpressionGet(table_index, std::move(expr_types), std::move(expressions)));
-	return std::move(result);
-}
-
-void LogicalFilter::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(200, "expressions", expressions);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(201, "projection_map", projection_map);
-}
-
-unique_ptr<LogicalOperator> LogicalFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalFilter>(new LogicalFilter());
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(200, "expressions", result->expressions);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(201, "projection_map", result->projection_map);
-	return std::move(result);
-}
-
-void LogicalInsert::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CreateInfo>>(200, "table_info", table.GetInfo());
-	serializer.WritePropertyWithDefault<vector<vector<unique_ptr<Expression>>>>(201, "insert_values", insert_values);
-	serializer.WriteProperty<IndexVector<idx_t, PhysicalIndex>>(202, "column_index_map", column_index_map);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(203, "expected_types", expected_types);
-	serializer.WritePropertyWithDefault<idx_t>(204, "table_index", table_index);
-	serializer.WritePropertyWithDefault<bool>(205, "return_chunk", return_chunk);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(206, "bound_defaults", bound_defaults);
-	serializer.WriteProperty<OnConflictAction>(207, "action_type", action_type);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(208, "expected_set_types", expected_set_types);
-	serializer.WritePropertyWithDefault<unordered_set<idx_t>>(209, "on_conflict_filter", on_conflict_filter);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(210, "on_conflict_condition", on_conflict_condition);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(211, "do_update_condition", do_update_condition);
-	serializer.WritePropertyWithDefault<vector<PhysicalIndex>>(212, "set_columns", set_columns);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(213, "set_types", set_types);
-	serializer.WritePropertyWithDefault<idx_t>(214, "excluded_table_index", excluded_table_index);
-	serializer.WritePropertyWithDefault<vector<column_t>>(215, "columns_to_fetch", columns_to_fetch);
-	serializer.WritePropertyWithDefault<vector<column_t>>(216, "source_columns", source_columns);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(217, "expressions", expressions);
-	serializer.WritePropertyWithDefault<bool>(218, "update_is_del_and_insert", update_is_del_and_insert, false);
-}
-
-unique_ptr<LogicalOperator> LogicalInsert::Deserialize(Deserializer &deserializer) {
-	auto table_info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(200, "table_info");
-	auto result = duckdb::unique_ptr<LogicalInsert>(new LogicalInsert(deserializer.Get<ClientContext &>(), std::move(table_info)));
-	deserializer.ReadPropertyWithDefault<vector<vector<unique_ptr<Expression>>>>(201, "insert_values", result->insert_values);
-	deserializer.ReadProperty<IndexVector<idx_t, PhysicalIndex>>(202, "column_index_map", result->column_index_map);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(203, "expected_types", result->expected_types);
-	deserializer.ReadPropertyWithDefault<idx_t>(204, "table_index", result->table_index);
-	deserializer.ReadPropertyWithDefault<bool>(205, "return_chunk", result->return_chunk);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(206, "bound_defaults", result->bound_defaults);
-	deserializer.ReadProperty<OnConflictAction>(207, "action_type", result->action_type);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(208, "expected_set_types", result->expected_set_types);
-	deserializer.ReadPropertyWithDefault<unordered_set<idx_t>>(209, "on_conflict_filter", result->on_conflict_filter);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(210, "on_conflict_condition", result->on_conflict_condition);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(211, "do_update_condition", result->do_update_condition);
-	deserializer.ReadPropertyWithDefault<vector<PhysicalIndex>>(212, "set_columns", result->set_columns);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(213, "set_types", result->set_types);
-	deserializer.ReadPropertyWithDefault<idx_t>(214, "excluded_table_index", result->excluded_table_index);
-	deserializer.ReadPropertyWithDefault<vector<column_t>>(215, "columns_to_fetch", result->columns_to_fetch);
-	deserializer.ReadPropertyWithDefault<vector<column_t>>(216, "source_columns", result->source_columns);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(217, "expressions", result->expressions);
-	deserializer.ReadPropertyWithExplicitDefault<bool>(218, "update_is_del_and_insert", result->update_is_del_and_insert, false);
-	return std::move(result);
-}
-
-void LogicalLimit::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty<BoundLimitNode>(200, "limit_val", limit_val);
-	serializer.WriteProperty<BoundLimitNode>(201, "offset_val", offset_val);
-}
-
-unique_ptr<LogicalOperator> LogicalLimit::Deserialize(Deserializer &deserializer) {
-	auto limit_val = deserializer.ReadProperty<BoundLimitNode>(200, "limit_val");
-	auto offset_val = deserializer.ReadProperty<BoundLimitNode>(201, "offset_val");
-	auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(std::move(limit_val), std::move(offset_val)));
-	return std::move(result);
-}
-
-void LogicalMaterializedCTE::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<idx_t>(201, "column_count", column_count);
-	serializer.WritePropertyWithDefault<string>(202, "ctename", ctename);
-}
-
-unique_ptr<LogicalOperator> LogicalMaterializedCTE::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
-	deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index", result->table_index);
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "column_count", result->column_count);
-	deserializer.ReadPropertyWithDefault<string>(202, "ctename", result->ctename);
-	return std::move(result);
-}
-
-void LogicalOrder::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<BoundOrderByNode>>(200, "orders", orders);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(201, "projections", projection_map);
-}
-
-unique_ptr<LogicalOperator> LogicalOrder::Deserialize(Deserializer &deserializer) {
-	auto orders = deserializer.ReadPropertyWithDefault<vector<BoundOrderByNode>>(200, "orders");
-	auto result = duckdb::unique_ptr<LogicalOrder>(new LogicalOrder(std::move(orders)));
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(201, "projections", result->projection_map);
-	return std::move(result);
-}
-
-void LogicalPivot::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "pivot_index", pivot_index);
-	serializer.WriteProperty<BoundPivotInfo>(201, "bound_pivot", bound_pivot);
-}
-
-unique_ptr<LogicalOperator> LogicalPivot::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalPivot>(new LogicalPivot());
-	deserializer.ReadPropertyWithDefault<idx_t>(200, "pivot_index", result->pivot_index);
-	deserializer.ReadProperty<BoundPivotInfo>(201, "bound_pivot", result->bound_pivot);
-	return std::move(result);
-}
-
-void LogicalPositionalJoin::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-}
-
-unique_ptr<LogicalOperator> LogicalPositionalJoin::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalPositionalJoin>(new LogicalPositionalJoin());
-	return std::move(result);
-}
-
-void LogicalProjection::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(201, "expressions", expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalProjection::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto expressions = deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(201, "expressions");
-	auto result = duckdb::unique_ptr<LogicalProjection>(new LogicalProjection(table_index, std::move(expressions)));
-	return std::move(result);
-}
-
-void LogicalRecursiveCTE::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<bool>(200, "union_all", union_all);
-	serializer.WritePropertyWithDefault<string>(201, "ctename", ctename);
-	serializer.WritePropertyWithDefault<idx_t>(202, "table_index", table_index);
-	serializer.WritePropertyWithDefault<idx_t>(203, "column_count", column_count);
-}
-
-unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
-	deserializer.ReadPropertyWithDefault<bool>(200, "union_all", result->union_all);
-	deserializer.ReadPropertyWithDefault<string>(201, "ctename", result->ctename);
-	deserializer.ReadPropertyWithDefault<idx_t>(202, "table_index", result->table_index);
-	deserializer.ReadPropertyWithDefault<idx_t>(203, "column_count", result->column_count);
-	return std::move(result);
-}
-
-void LogicalReset::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WriteProperty<SetScope>(201, "scope", scope);
-}
-
-unique_ptr<LogicalOperator> LogicalReset::Deserialize(Deserializer &deserializer) {
-	auto name = deserializer.ReadPropertyWithDefault<string>(200, "name");
-	auto scope = deserializer.ReadProperty<SetScope>(201, "scope");
-	auto result = duckdb::unique_ptr<LogicalReset>(new LogicalReset(std::move(name), scope));
-	return std::move(result);
-}
-
-void LogicalSample::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<SampleOptions>>(200, "sample_options", sample_options);
-}
-
-unique_ptr<LogicalOperator> LogicalSample::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LogicalSample>(new LogicalSample());
-	deserializer.ReadPropertyWithDefault<unique_ptr<SampleOptions>>(200, "sample_options", result->sample_options);
-	return std::move(result);
-}
-
-void LogicalSet::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WriteProperty<Value>(201, "value", value);
-	serializer.WriteProperty<SetScope>(202, "scope", scope);
-}
-
-unique_ptr<LogicalOperator> LogicalSet::Deserialize(Deserializer &deserializer) {
-	auto name = deserializer.ReadPropertyWithDefault<string>(200, "name");
-	auto value = deserializer.ReadProperty<Value>(201, "value");
-	auto scope = deserializer.ReadProperty<SetScope>(202, "scope");
-	auto result = duckdb::unique_ptr<LogicalSet>(new LogicalSet(std::move(name), value, scope));
-	return std::move(result);
-}
-
-void LogicalSetOperation::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
-	serializer.WritePropertyWithDefault<idx_t>(201, "column_count", column_count);
-	serializer.WritePropertyWithDefault<bool>(202, "setop_all", setop_all, true);
-	serializer.WritePropertyWithDefault<bool>(203, "allow_out_of_order", allow_out_of_order, true);
-}
-
-unique_ptr<LogicalOperator> LogicalSetOperation::Deserialize(Deserializer &deserializer) {
-	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
-	auto column_count = deserializer.ReadPropertyWithDefault<idx_t>(201, "column_count");
-	auto setop_all = deserializer.ReadPropertyWithExplicitDefault<bool>(202, "setop_all", true);
-	auto allow_out_of_order = deserializer.ReadPropertyWithExplicitDefault<bool>(203, "allow_out_of_order", true);
-	auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>(), setop_all, allow_out_of_order));
-	return std::move(result);
-}
-
-void LogicalSimple::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParseInfo>>(200, "info", info);
-}
-
-unique_ptr<LogicalOperator> LogicalSimple::Deserialize(Deserializer &deserializer) {
-	auto info = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(200, "info");
-	auto result = duckdb::unique_ptr<LogicalSimple>(new LogicalSimple(deserializer.Get<LogicalOperatorType>(), std::move(info)));
-	return std::move(result);
-}
-
-void LogicalTopN::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<BoundOrderByNode>>(200, "orders", orders);
-	serializer.WritePropertyWithDefault<idx_t>(201, "limit", limit);
-	serializer.WritePropertyWithDefault<idx_t>(202, "offset", offset);
-}
-
-unique_ptr<LogicalOperator> LogicalTopN::Deserialize(Deserializer &deserializer) {
-	auto orders = deserializer.ReadPropertyWithDefault<vector<BoundOrderByNode>>(200, "orders");
-	auto limit = deserializer.ReadPropertyWithDefault<idx_t>(201, "limit");
-	auto offset = deserializer.ReadPropertyWithDefault<idx_t>(202, "offset");
-	auto result = duckdb::unique_ptr<LogicalTopN>(new LogicalTopN(std::move(orders), limit, offset));
-	return std::move(result);
-}
-
-void LogicalUnnest::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "unnest_index", unnest_index);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(201, "expressions", expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalUnnest::Deserialize(Deserializer &deserializer) {
-	auto unnest_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "unnest_index");
-	auto result = duckdb::unique_ptr<LogicalUnnest>(new LogicalUnnest(unnest_index));
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(201, "expressions", result->expressions);
-	return std::move(result);
-}
-
-void LogicalUpdate::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<CreateInfo>>(200, "table_info", table.GetInfo());
-	serializer.WritePropertyWithDefault<idx_t>(201, "table_index", table_index);
-	serializer.WritePropertyWithDefault<bool>(202, "return_chunk", return_chunk);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(203, "expressions", expressions);
-	serializer.WritePropertyWithDefault<vector<PhysicalIndex>>(204, "columns", columns);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(205, "bound_defaults", bound_defaults);
-	serializer.WritePropertyWithDefault<bool>(206, "update_is_del_and_insert", update_is_del_and_insert);
-}
-
-unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(Deserializer &deserializer) {
-	auto table_info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(200, "table_info");
-	auto result = duckdb::unique_ptr<LogicalUpdate>(new LogicalUpdate(deserializer.Get<ClientContext &>(), table_info));
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "table_index", result->table_index);
-	deserializer.ReadPropertyWithDefault<bool>(202, "return_chunk", result->return_chunk);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(203, "expressions", result->expressions);
-	deserializer.ReadPropertyWithDefault<vector<PhysicalIndex>>(204, "columns", result->columns);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(205, "bound_defaults", result->bound_defaults);
-	deserializer.ReadPropertyWithDefault<bool>(206, "update_is_del_and_insert", result->update_is_del_and_insert);
-	return std::move(result);
-}
-
-void LogicalWindow::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "window_index", window_index);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(201, "expressions", expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalWindow::Deserialize(Deserializer &deserializer) {
-	auto window_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "window_index");
-	auto result = duckdb::unique_ptr<LogicalWindow>(new LogicalWindow(window_index));
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(201, "expressions", result->expressions);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_macro_function.cpp b/src/duckdb/src/storage/serialization/serialize_macro_function.cpp
deleted file mode 100644
index 8be5988db..000000000
--- a/src/duckdb/src/storage/serialization/serialize_macro_function.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/function/macro_function.hpp"
-#include "duckdb/function/scalar_macro_function.hpp"
-#include "duckdb/function/table_macro_function.hpp"
-
-namespace duckdb {
-
-void MacroFunction::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<MacroType>(100, "type", type);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(101, "parameters", parameters);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(102, "default_parameters", default_parameters);
-}
-
-unique_ptr<MacroFunction> MacroFunction::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<MacroType>(100, "type");
-	auto parameters = deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(101, "parameters");
-	auto default_parameters = deserializer.ReadPropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(102, "default_parameters");
-	unique_ptr<MacroFunction> result;
-	switch (type) {
-	case MacroType::SCALAR_MACRO:
-		result = ScalarMacroFunction::Deserialize(deserializer);
-		break;
-	case MacroType::TABLE_MACRO:
-		result = TableMacroFunction::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of MacroFunction!");
-	}
-	result->parameters = std::move(parameters);
-	result->default_parameters = std::move(default_parameters);
-	return result;
-}
-
-void ScalarMacroFunction::Serialize(Serializer &serializer) const {
-	MacroFunction::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "expression", expression);
-}
-
-unique_ptr<MacroFunction> ScalarMacroFunction::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ScalarMacroFunction>(new ScalarMacroFunction());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "expression", result->expression);
-	return std::move(result);
-}
-
-void TableMacroFunction::Serialize(Serializer &serializer) const {
-	MacroFunction::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(200, "query_node", query_node);
-}
-
-unique_ptr<MacroFunction> TableMacroFunction::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<TableMacroFunction>(new TableMacroFunction());
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(200, "query_node", result->query_node);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_nodes.cpp b/src/duckdb/src/storage/serialization/serialize_nodes.cpp
deleted file mode 100644
index 6c0bc4ab1..000000000
--- a/src/duckdb/src/storage/serialization/serialize_nodes.cpp
+++ /dev/null
@@ -1,685 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/parser/common_table_expression_info.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
-#include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/execution/reservoir_sample.hpp"
-#include "duckdb/common/queue.hpp"
-#include "duckdb/parser/tableref/pivotref.hpp"
-#include "duckdb/planner/tableref/bound_pivotref.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/column_list.hpp"
-#include "duckdb/planner/column_binding.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
-#include "duckdb/planner/joinside.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/common/types/interval.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
-#include "duckdb/common/column_index.hpp"
-
-namespace duckdb {
-
-void BlockingSample::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<unique_ptr<BaseReservoirSampling>>(100, "base_reservoir_sample", base_reservoir_sample);
-	serializer.WriteProperty<SampleType>(101, "type", type);
-	serializer.WritePropertyWithDefault<bool>(102, "destroyed", destroyed);
-}
-
-unique_ptr<BlockingSample> BlockingSample::Deserialize(Deserializer &deserializer) {
-	auto base_reservoir_sample = deserializer.ReadPropertyWithDefault<unique_ptr<BaseReservoirSampling>>(100, "base_reservoir_sample");
-	auto type = deserializer.ReadProperty<SampleType>(101, "type");
-	auto destroyed = deserializer.ReadPropertyWithDefault<bool>(102, "destroyed");
-	unique_ptr<BlockingSample> result;
-	switch (type) {
-	case SampleType::RESERVOIR_PERCENTAGE_SAMPLE:
-		result = ReservoirSamplePercentage::Deserialize(deserializer);
-		break;
-	case SampleType::RESERVOIR_SAMPLE:
-		result = ReservoirSample::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of BlockingSample!");
-	}
-	result->base_reservoir_sample = std::move(base_reservoir_sample);
-	result->destroyed = destroyed;
-	return result;
-}
-
-void BaseReservoirSampling::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "next_index_to_sample", next_index_to_sample);
-	serializer.WriteProperty<double>(101, "min_weight_threshold", min_weight_threshold);
-	serializer.WritePropertyWithDefault<idx_t>(102, "min_weighted_entry_index", min_weighted_entry_index);
-	serializer.WritePropertyWithDefault<idx_t>(103, "num_entries_to_skip_b4_next_sample", num_entries_to_skip_b4_next_sample);
-	serializer.WritePropertyWithDefault<idx_t>(104, "num_entries_seen_total", num_entries_seen_total);
-	serializer.WritePropertyWithDefault<std::priority_queue<std::pair<double, idx_t>>>(105, "reservoir_weights", reservoir_weights);
-}
-
-unique_ptr<BaseReservoirSampling> BaseReservoirSampling::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BaseReservoirSampling>(new BaseReservoirSampling());
-	deserializer.ReadPropertyWithDefault<idx_t>(100, "next_index_to_sample", result->next_index_to_sample);
-	deserializer.ReadProperty<double>(101, "min_weight_threshold", result->min_weight_threshold);
-	deserializer.ReadPropertyWithDefault<idx_t>(102, "min_weighted_entry_index", result->min_weighted_entry_index);
-	deserializer.ReadPropertyWithDefault<idx_t>(103, "num_entries_to_skip_b4_next_sample", result->num_entries_to_skip_b4_next_sample);
-	deserializer.ReadPropertyWithDefault<idx_t>(104, "num_entries_seen_total", result->num_entries_seen_total);
-	deserializer.ReadPropertyWithDefault<std::priority_queue<std::pair<double, idx_t>>>(105, "reservoir_weights", result->reservoir_weights);
-	return result;
-}
-
-void BoundCaseCheck::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(100, "when_expr", when_expr);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(101, "then_expr", then_expr);
-}
-
-BoundCaseCheck BoundCaseCheck::Deserialize(Deserializer &deserializer) {
-	BoundCaseCheck result;
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(100, "when_expr", result.when_expr);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(101, "then_expr", result.then_expr);
-	return result;
-}
-
-void BoundLimitNode::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<LimitNodeType>(100, "type", type);
-	serializer.WritePropertyWithDefault<idx_t>(101, "constant_integer", constant_integer);
-	serializer.WriteProperty<double>(102, "constant_percentage", constant_percentage);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(103, "expression", expression);
-}
-
-BoundLimitNode BoundLimitNode::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<LimitNodeType>(100, "type");
-	auto constant_integer = deserializer.ReadPropertyWithDefault<idx_t>(101, "constant_integer");
-	auto constant_percentage = deserializer.ReadProperty<double>(102, "constant_percentage");
-	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(103, "expression");
-	BoundLimitNode result(type, constant_integer, constant_percentage, std::move(expression));
-	return result;
-}
-
-void BoundOrderByNode::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<OrderType>(100, "type", type);
-	serializer.WriteProperty<OrderByNullType>(101, "null_order", null_order);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(102, "expression", expression);
-}
-
-BoundOrderByNode BoundOrderByNode::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<OrderType>(100, "type");
-	auto null_order = deserializer.ReadProperty<OrderByNullType>(101, "null_order");
-	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(102, "expression");
-	BoundOrderByNode result(type, null_order, std::move(expression));
-	return result;
-}
-
-void BoundParameterData::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<Value>(100, "value", value);
-	serializer.WriteProperty<LogicalType>(101, "return_type", return_type);
-}
-
-shared_ptr<BoundParameterData> BoundParameterData::Deserialize(Deserializer &deserializer) {
-	auto value = deserializer.ReadProperty<Value>(100, "value");
-	auto result = duckdb::shared_ptr<BoundParameterData>(new BoundParameterData(value));
-	deserializer.ReadProperty<LogicalType>(101, "return_type", result->return_type);
-	return result;
-}
-
-void BoundPivotInfo::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "group_count", group_count);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(101, "types", types);
-	serializer.WritePropertyWithDefault<vector<string>>(102, "pivot_values", pivot_values);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<Expression>>>(103, "aggregates", aggregates);
-}
-
-BoundPivotInfo BoundPivotInfo::Deserialize(Deserializer &deserializer) {
-	BoundPivotInfo result;
-	deserializer.ReadPropertyWithDefault<idx_t>(100, "group_count", result.group_count);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(101, "types", result.types);
-	deserializer.ReadPropertyWithDefault<vector<string>>(102, "pivot_values", result.pivot_values);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(103, "aggregates", result.aggregates);
-	return result;
-}
-
-template <typename T>
-void CSVOption<T>::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<bool>(100, "set_by_user", set_by_user);
-	serializer.WriteProperty<T>(101, "value", value);
-}
-
-template <typename T>
-CSVOption<T> CSVOption<T>::Deserialize(Deserializer &deserializer) {
-	CSVOption<T> result;
-	deserializer.ReadPropertyWithDefault<bool>(100, "set_by_user", result.set_by_user);
-	deserializer.ReadProperty<T>(101, "value", result.value);
-	return result;
-}
-
-void CSVReaderOptions::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<bool>(100, "ignore_errors", ignore_errors, false);
-	serializer.WritePropertyWithDefault<idx_t>(101, "buffer_sample_size", buffer_sample_size);
-	serializer.WritePropertyWithDefault<vector<string>>(102, "null_str", null_str);
-	serializer.WriteProperty<FileCompressionType>(103, "compression", compression);
-	serializer.WritePropertyWithDefault<bool>(104, "allow_quoted_nulls", allow_quoted_nulls);
-	serializer.WriteProperty<CSVOption<idx_t>>(105, "maximum_line_size", maximum_line_size);
-	serializer.WritePropertyWithDefault<bool>(106, "normalize_names", normalize_names);
-	serializer.WritePropertyWithDefault<vector<bool>>(107, "force_not_null", force_not_null);
-	serializer.WritePropertyWithDefault<bool>(108, "all_varchar", all_varchar);
-	serializer.WritePropertyWithDefault<idx_t>(109, "sample_size_chunks", sample_size_chunks);
-	serializer.WritePropertyWithDefault<bool>(110, "auto_detect", auto_detect);
-	serializer.WritePropertyWithDefault<string>(111, "file_path", file_path);
-	serializer.WritePropertyWithDefault<string>(112, "decimal_separator", decimal_separator);
-	serializer.WritePropertyWithDefault<bool>(113, "null_padding", null_padding);
-	/* [Deleted] (idx_t) "buffer_size" */
-	serializer.WriteProperty<MultiFileReaderOptions>(115, "file_options", file_options);
-	serializer.WritePropertyWithDefault<vector<bool>>(116, "force_quote", force_quote);
-	serializer.WritePropertyWithDefault<string>(117, "rejects_table_name", rejects_table_name, "reject_errors");
-	serializer.WritePropertyWithDefault<idx_t>(118, "rejects_limit", rejects_limit);
-	/* [Deleted] (vector<string>) "rejects_recovery_columns" */
-	/* [Deleted] (vector<idx_t>) "rejects_recovery_column_ids" */
-	serializer.WriteProperty<CSVOption<char>>(121, "delimiter", GetSingleByteDelimiter());
-	serializer.WriteProperty<CSVOption<char>>(122, "quote", dialect_options.state_machine_options.quote);
-	serializer.WriteProperty<CSVOption<char>>(123, "escape", dialect_options.state_machine_options.escape);
-	serializer.WriteProperty<CSVOption<bool>>(124, "header", dialect_options.header);
-	serializer.WritePropertyWithDefault<idx_t>(125, "num_cols", dialect_options.num_cols);
-	serializer.WriteProperty<CSVOption<NewLineIdentifier>>(126, "new_line", dialect_options.state_machine_options.new_line);
-	serializer.WriteProperty<CSVOption<idx_t>>(127, "skip_rows", dialect_options.skip_rows);
-	serializer.WriteProperty<map<LogicalTypeId, CSVOption<StrpTimeFormat>>>(128, "date_format", dialect_options.date_format);
-	serializer.WritePropertyWithDefault<string>(129, "sniffer_user_mismatch_error", sniffer_user_mismatch_error);
-	serializer.WritePropertyWithDefault<bool>(130, "parallel", parallel);
-	serializer.WritePropertyWithDefault<vector<bool>>(131, "was_type_manually_set", was_type_manually_set);
-	serializer.WritePropertyWithDefault<CSVOption<string>>(132, "rejects_scan_name", rejects_scan_name, {"reject_scans"});
-	serializer.WritePropertyWithDefault<vector<string>>(133, "name_list", name_list);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(134, "sql_type_list", sql_type_list);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<idx_t>>(135, "sql_types_per_column", sql_types_per_column);
-	serializer.WritePropertyWithDefault<bool>(136, "columns_set", columns_set, false);
-	serializer.WritePropertyWithDefault<CSVOption<char>>(137, "comment", dialect_options.state_machine_options.comment, CSVOption<char>('\0'));
-	serializer.WritePropertyWithDefault<idx_t>(138, "rows_until_header", dialect_options.rows_until_header);
-	serializer.WritePropertyWithDefault<string>(139, "encoding", encoding);
-	serializer.WriteProperty<CSVOption<bool>>(140, "rfc_4180", dialect_options.state_machine_options.rfc_4180);
-	serializer.WriteProperty<CSVOption<string>>(141, "multi_byte_delimiter", GetMultiByteDelimiter());
-	serializer.WritePropertyWithDefault<bool>(142, "multi_file_reader", multi_file_reader);
-	serializer.WriteProperty<CSVOption<idx_t>>(143, "buffer_size_option", buffer_size_option);
-}
-
-CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
-	auto ignore_errors = deserializer.ReadPropertyWithExplicitDefault<bool>(100, "ignore_errors", false);
-	auto buffer_sample_size = deserializer.ReadPropertyWithDefault<idx_t>(101, "buffer_sample_size");
-	auto null_str = deserializer.ReadPropertyWithDefault<vector<string>>(102, "null_str");
-	auto compression = deserializer.ReadProperty<FileCompressionType>(103, "compression");
-	auto allow_quoted_nulls = deserializer.ReadPropertyWithDefault<bool>(104, "allow_quoted_nulls");
-	auto maximum_line_size = deserializer.ReadProperty<CSVOption<idx_t>>(105, "maximum_line_size");
-	auto normalize_names = deserializer.ReadPropertyWithDefault<bool>(106, "normalize_names");
-	auto force_not_null = deserializer.ReadPropertyWithDefault<vector<bool>>(107, "force_not_null");
-	auto all_varchar = deserializer.ReadPropertyWithDefault<bool>(108, "all_varchar");
-	auto sample_size_chunks = deserializer.ReadPropertyWithDefault<idx_t>(109, "sample_size_chunks");
-	auto auto_detect = deserializer.ReadPropertyWithDefault<bool>(110, "auto_detect");
-	auto file_path = deserializer.ReadPropertyWithDefault<string>(111, "file_path");
-	auto decimal_separator = deserializer.ReadPropertyWithDefault<string>(112, "decimal_separator");
-	auto null_padding = deserializer.ReadPropertyWithDefault<bool>(113, "null_padding");
-	deserializer.ReadDeletedProperty<idx_t>(114, "buffer_size");
-	auto file_options = deserializer.ReadProperty<MultiFileReaderOptions>(115, "file_options");
-	auto force_quote = deserializer.ReadPropertyWithDefault<vector<bool>>(116, "force_quote");
-	auto rejects_table_name = deserializer.ReadPropertyWithExplicitDefault<string>(117, "rejects_table_name", "reject_errors");
-	auto rejects_limit = deserializer.ReadPropertyWithDefault<idx_t>(118, "rejects_limit");
-	deserializer.ReadDeletedProperty<vector<string>>(119, "rejects_recovery_columns");
-	deserializer.ReadDeletedProperty<vector<idx_t>>(120, "rejects_recovery_column_ids");
-	auto dialect_options_state_machine_options_delimiter = deserializer.ReadProperty<CSVOption<char>>(121, "delimiter");
-	auto dialect_options_state_machine_options_quote = deserializer.ReadProperty<CSVOption<char>>(122, "quote");
-	auto dialect_options_state_machine_options_escape = deserializer.ReadProperty<CSVOption<char>>(123, "escape");
-	auto dialect_options_header = deserializer.ReadProperty<CSVOption<bool>>(124, "header");
-	auto dialect_options_num_cols = deserializer.ReadPropertyWithDefault<idx_t>(125, "num_cols");
-	auto dialect_options_state_machine_options_new_line = deserializer.ReadProperty<CSVOption<NewLineIdentifier>>(126, "new_line");
-	auto dialect_options_skip_rows = deserializer.ReadProperty<CSVOption<idx_t>>(127, "skip_rows");
-	auto dialect_options_date_format = deserializer.ReadProperty<map<LogicalTypeId, CSVOption<StrpTimeFormat>>>(128, "date_format");
-	auto sniffer_user_mismatch_error = deserializer.ReadPropertyWithDefault<string>(129, "sniffer_user_mismatch_error");
-	auto parallel = deserializer.ReadPropertyWithDefault<bool>(130, "parallel");
-	auto was_type_manually_set = deserializer.ReadPropertyWithDefault<vector<bool>>(131, "was_type_manually_set");
-	auto rejects_scan_name = deserializer.ReadPropertyWithExplicitDefault<CSVOption<string>>(132, "rejects_scan_name", {"reject_scans"});
-	auto name_list = deserializer.ReadPropertyWithDefault<vector<string>>(133, "name_list");
-	auto sql_type_list = deserializer.ReadPropertyWithDefault<vector<LogicalType>>(134, "sql_type_list");
-	auto sql_types_per_column = deserializer.ReadPropertyWithDefault<case_insensitive_map_t<idx_t>>(135, "sql_types_per_column");
-	auto columns_set = deserializer.ReadPropertyWithExplicitDefault<bool>(136, "columns_set", false);
-	auto dialect_options_state_machine_options_comment = deserializer.ReadPropertyWithExplicitDefault<CSVOption<char>>(137, "comment", CSVOption<char>('\0'));
-	auto dialect_options_rows_until_header = deserializer.ReadPropertyWithDefault<idx_t>(138, "rows_until_header");
-	auto encoding = deserializer.ReadPropertyWithDefault<string>(139, "encoding");
-	auto dialect_options_state_machine_options_rfc_4180 = deserializer.ReadProperty<CSVOption<bool>>(140, "rfc_4180");
-	auto multi_byte_delimiter = deserializer.ReadProperty<CSVOption<string>>(141, "multi_byte_delimiter");
-	CSVReaderOptions result(dialect_options_state_machine_options_delimiter, multi_byte_delimiter);
-	result.ignore_errors = ignore_errors;
-	result.buffer_sample_size = buffer_sample_size;
-	result.null_str = std::move(null_str);
-	result.compression = compression;
-	result.allow_quoted_nulls = allow_quoted_nulls;
-	result.maximum_line_size = maximum_line_size;
-	result.normalize_names = normalize_names;
-	result.force_not_null = std::move(force_not_null);
-	result.all_varchar = all_varchar;
-	result.sample_size_chunks = sample_size_chunks;
-	result.auto_detect = auto_detect;
-	result.file_path = std::move(file_path);
-	result.decimal_separator = std::move(decimal_separator);
-	result.null_padding = null_padding;
-	result.file_options = file_options;
-	result.force_quote = std::move(force_quote);
-	result.rejects_table_name = std::move(rejects_table_name);
-	result.rejects_limit = rejects_limit;
-	result.dialect_options.state_machine_options.quote = dialect_options_state_machine_options_quote;
-	result.dialect_options.state_machine_options.escape = dialect_options_state_machine_options_escape;
-	result.dialect_options.header = dialect_options_header;
-	result.dialect_options.num_cols = dialect_options_num_cols;
-	result.dialect_options.state_machine_options.new_line = dialect_options_state_machine_options_new_line;
-	result.dialect_options.skip_rows = dialect_options_skip_rows;
-	result.dialect_options.date_format = dialect_options_date_format;
-	result.sniffer_user_mismatch_error = std::move(sniffer_user_mismatch_error);
-	result.parallel = parallel;
-	result.was_type_manually_set = std::move(was_type_manually_set);
-	result.rejects_scan_name = rejects_scan_name;
-	result.name_list = std::move(name_list);
-	result.sql_type_list = std::move(sql_type_list);
-	result.sql_types_per_column = std::move(sql_types_per_column);
-	result.columns_set = columns_set;
-	result.dialect_options.state_machine_options.comment = dialect_options_state_machine_options_comment;
-	result.dialect_options.rows_until_header = dialect_options_rows_until_header;
-	result.encoding = std::move(encoding);
-	result.dialect_options.state_machine_options.rfc_4180 = dialect_options_state_machine_options_rfc_4180;
-	deserializer.ReadPropertyWithDefault<bool>(142, "multi_file_reader", result.multi_file_reader);
-	deserializer.ReadProperty<CSVOption<idx_t>>(143, "buffer_size_option", result.buffer_size_option);
-	return result;
-}
-
-void CaseCheck::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(100, "when_expr", when_expr);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(101, "then_expr", then_expr);
-}
-
-CaseCheck CaseCheck::Deserialize(Deserializer &deserializer) {
-	CaseCheck result;
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(100, "when_expr", result.when_expr);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(101, "then_expr", result.then_expr);
-	return result;
-}
-
-void ColumnBinding::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "table_index", table_index);
-	serializer.WritePropertyWithDefault<idx_t>(101, "column_index", column_index);
-}
-
-ColumnBinding ColumnBinding::Deserialize(Deserializer &deserializer) {
-	ColumnBinding result;
-	deserializer.ReadPropertyWithDefault<idx_t>(100, "table_index", result.table_index);
-	deserializer.ReadPropertyWithDefault<idx_t>(101, "column_index", result.column_index);
-	return result;
-}
-
-void ColumnDefinition::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(100, "name", name);
-	serializer.WriteProperty<LogicalType>(101, "type", type);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(102, "expression", expression);
-	serializer.WriteProperty<TableColumnType>(103, "category", category);
-	serializer.WriteProperty<duckdb::CompressionType>(104, "compression_type", compression_type);
-	serializer.WritePropertyWithDefault<Value>(105, "comment", comment, Value());
-	serializer.WritePropertyWithDefault<unordered_map<string, string>>(106, "tags", tags, unordered_map<string, string>());
-}
-
-ColumnDefinition ColumnDefinition::Deserialize(Deserializer &deserializer) {
-	auto name = deserializer.ReadPropertyWithDefault<string>(100, "name");
-	auto type = deserializer.ReadProperty<LogicalType>(101, "type");
-	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(102, "expression");
-	auto category = deserializer.ReadProperty<TableColumnType>(103, "category");
-	ColumnDefinition result(std::move(name), std::move(type), std::move(expression), category);
-	deserializer.ReadProperty<duckdb::CompressionType>(104, "compression_type", result.compression_type);
-	deserializer.ReadPropertyWithExplicitDefault<Value>(105, "comment", result.comment, Value());
-	deserializer.ReadPropertyWithExplicitDefault<unordered_map<string, string>>(106, "tags", result.tags, unordered_map<string, string>());
-	return result;
-}
-
-void ColumnIndex::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(1, "index", index);
-	serializer.WritePropertyWithDefault<vector<ColumnIndex>>(2, "child_indexes", child_indexes);
-}
-
-ColumnIndex ColumnIndex::Deserialize(Deserializer &deserializer) {
-	ColumnIndex result;
-	deserializer.ReadPropertyWithDefault<idx_t>(1, "index", result.index);
-	deserializer.ReadPropertyWithDefault<vector<ColumnIndex>>(2, "child_indexes", result.child_indexes);
-	return result;
-}
-
-void ColumnInfo::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<string>>(100, "names", names);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(101, "types", types);
-}
-
-ColumnInfo ColumnInfo::Deserialize(Deserializer &deserializer) {
-	ColumnInfo result;
-	deserializer.ReadPropertyWithDefault<vector<string>>(100, "names", result.names);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(101, "types", result.types);
-	return result;
-}
-
-void ColumnList::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<ColumnDefinition>>(100, "columns", columns);
-}
-
-ColumnList ColumnList::Deserialize(Deserializer &deserializer) {
-	auto columns = deserializer.ReadPropertyWithDefault<vector<ColumnDefinition>>(100, "columns");
-	ColumnList result(std::move(columns));
-	return result;
-}
-
-void CommonTableExpressionInfo::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<string>>(100, "aliases", aliases);
-	serializer.WritePropertyWithDefault<unique_ptr<SelectStatement>>(101, "query", query);
-	serializer.WriteProperty<CTEMaterialize>(102, "materialized", materialized);
-}
-
-unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CommonTableExpressionInfo>(new CommonTableExpressionInfo());
-	deserializer.ReadPropertyWithDefault<vector<string>>(100, "aliases", result->aliases);
-	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(101, "query", result->query);
-	deserializer.ReadProperty<CTEMaterialize>(102, "materialized", result->materialized);
-	return result;
-}
-
-void CommonTableExpressionMap::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<InsertionOrderPreservingMap<unique_ptr<CommonTableExpressionInfo>>>(100, "map", map);
-}
-
-CommonTableExpressionMap CommonTableExpressionMap::Deserialize(Deserializer &deserializer) {
-	CommonTableExpressionMap result;
-	deserializer.ReadPropertyWithDefault<InsertionOrderPreservingMap<unique_ptr<CommonTableExpressionInfo>>>(100, "map", result.map);
-	return result;
-}
-
-void ExportedTableData::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(1, "table_name", table_name);
-	serializer.WritePropertyWithDefault<string>(2, "schema_name", schema_name);
-	serializer.WritePropertyWithDefault<string>(3, "database_name", database_name);
-	serializer.WritePropertyWithDefault<string>(4, "file_path", file_path);
-	serializer.WritePropertyWithDefault<vector<string>>(5, "not_null_columns", not_null_columns);
-}
-
-ExportedTableData ExportedTableData::Deserialize(Deserializer &deserializer) {
-	ExportedTableData result;
-	deserializer.ReadPropertyWithDefault<string>(1, "table_name", result.table_name);
-	deserializer.ReadPropertyWithDefault<string>(2, "schema_name", result.schema_name);
-	deserializer.ReadPropertyWithDefault<string>(3, "database_name", result.database_name);
-	deserializer.ReadPropertyWithDefault<string>(4, "file_path", result.file_path);
-	deserializer.ReadPropertyWithDefault<vector<string>>(5, "not_null_columns", result.not_null_columns);
-	return result;
-}
-
-void ExportedTableInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ExportedTableData>(1, "table_data", table_data);
-}
-
-ExportedTableInfo ExportedTableInfo::Deserialize(Deserializer &deserializer) {
-	auto table_data = deserializer.ReadProperty<ExportedTableData>(1, "table_data");
-	ExportedTableInfo result(deserializer.Get<ClientContext &>(), table_data);
-	return result;
-}
-
-void HivePartitioningIndex::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(100, "value", value);
-	serializer.WritePropertyWithDefault<idx_t>(101, "index", index);
-}
-
-HivePartitioningIndex HivePartitioningIndex::Deserialize(Deserializer &deserializer) {
-	auto value = deserializer.ReadPropertyWithDefault<string>(100, "value");
-	auto index = deserializer.ReadPropertyWithDefault<idx_t>(101, "index");
-	HivePartitioningIndex result(std::move(value), index);
-	return result;
-}
-
-void JoinCondition::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(100, "left", left);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(101, "right", right);
-	serializer.WriteProperty<ExpressionType>(102, "comparison", comparison);
-}
-
-JoinCondition JoinCondition::Deserialize(Deserializer &deserializer) {
-	JoinCondition result;
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(100, "left", result.left);
-	deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(101, "right", result.right);
-	deserializer.ReadProperty<ExpressionType>(102, "comparison", result.comparison);
-	return result;
-}
-
-void LogicalType::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<LogicalTypeId>(100, "id", id_);
-	serializer.WritePropertyWithDefault<shared_ptr<ExtraTypeInfo>>(101, "type_info", type_info_);
-}
-
-LogicalType LogicalType::Deserialize(Deserializer &deserializer) {
-	auto id = deserializer.ReadProperty<LogicalTypeId>(100, "id");
-	auto type_info = deserializer.ReadPropertyWithDefault<shared_ptr<ExtraTypeInfo>>(101, "type_info");
-	LogicalType result(id, std::move(type_info));
-	return result;
-}
-
-void MultiFileReaderBindData::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "filename_idx", filename_idx);
-	serializer.WritePropertyWithDefault<vector<HivePartitioningIndex>>(101, "hive_partitioning_indexes", hive_partitioning_indexes);
-}
-
-MultiFileReaderBindData MultiFileReaderBindData::Deserialize(Deserializer &deserializer) {
-	MultiFileReaderBindData result;
-	deserializer.ReadPropertyWithDefault<idx_t>(100, "filename_idx", result.filename_idx);
-	deserializer.ReadPropertyWithDefault<vector<HivePartitioningIndex>>(101, "hive_partitioning_indexes", result.hive_partitioning_indexes);
-	return result;
-}
-
-void MultiFileReaderOptions::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<bool>(100, "filename", filename);
-	serializer.WritePropertyWithDefault<bool>(101, "hive_partitioning", hive_partitioning);
-	serializer.WritePropertyWithDefault<bool>(102, "auto_detect_hive_partitioning", auto_detect_hive_partitioning);
-	serializer.WritePropertyWithDefault<bool>(103, "union_by_name", union_by_name);
-	serializer.WritePropertyWithDefault<bool>(104, "hive_types_autocast", hive_types_autocast);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<LogicalType>>(105, "hive_types_schema", hive_types_schema);
-	serializer.WritePropertyWithDefault<string>(106, "filename_column", filename_column, MultiFileReaderOptions::DEFAULT_FILENAME_COLUMN);
-}
-
-MultiFileReaderOptions MultiFileReaderOptions::Deserialize(Deserializer &deserializer) {
-	MultiFileReaderOptions result;
-	deserializer.ReadPropertyWithDefault<bool>(100, "filename", result.filename);
-	deserializer.ReadPropertyWithDefault<bool>(101, "hive_partitioning", result.hive_partitioning);
-	deserializer.ReadPropertyWithDefault<bool>(102, "auto_detect_hive_partitioning", result.auto_detect_hive_partitioning);
-	deserializer.ReadPropertyWithDefault<bool>(103, "union_by_name", result.union_by_name);
-	deserializer.ReadPropertyWithDefault<bool>(104, "hive_types_autocast", result.hive_types_autocast);
-	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<LogicalType>>(105, "hive_types_schema", result.hive_types_schema);
-	deserializer.ReadPropertyWithExplicitDefault<string>(106, "filename_column", result.filename_column, MultiFileReaderOptions::DEFAULT_FILENAME_COLUMN);
-	return result;
-}
-
-void OrderByNode::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<OrderType>(100, "type", type);
-	serializer.WriteProperty<OrderByNullType>(101, "null_order", null_order);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(102, "expression", expression);
-}
-
-OrderByNode OrderByNode::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<OrderType>(100, "type");
-	auto null_order = deserializer.ReadProperty<OrderByNullType>(101, "null_order");
-	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(102, "expression");
-	OrderByNode result(type, null_order, std::move(expression));
-	return result;
-}
-
-void PivotColumn::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(100, "pivot_expressions", pivot_expressions);
-	serializer.WritePropertyWithDefault<vector<string>>(101, "unpivot_names", unpivot_names);
-	serializer.WritePropertyWithDefault<vector<PivotColumnEntry>>(102, "entries", entries);
-	serializer.WritePropertyWithDefault<string>(103, "pivot_enum", pivot_enum);
-}
-
-PivotColumn PivotColumn::Deserialize(Deserializer &deserializer) {
-	PivotColumn result;
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(100, "pivot_expressions", result.pivot_expressions);
-	deserializer.ReadPropertyWithDefault<vector<string>>(101, "unpivot_names", result.unpivot_names);
-	deserializer.ReadPropertyWithDefault<vector<PivotColumnEntry>>(102, "entries", result.entries);
-	deserializer.ReadPropertyWithDefault<string>(103, "pivot_enum", result.pivot_enum);
-	return result;
-}
-
-void PivotColumnEntry::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<Value>>(100, "values", values);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(101, "star_expr", expr);
-	serializer.WritePropertyWithDefault<string>(102, "alias", alias);
-}
-
-PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &deserializer) {
-	PivotColumnEntry result;
-	deserializer.ReadPropertyWithDefault<vector<Value>>(100, "values", result.values);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(101, "star_expr", result.expr);
-	deserializer.ReadPropertyWithDefault<string>(102, "alias", result.alias);
-	return result;
-}
-
-void QualifiedColumnName::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(100, "catalog", catalog);
-	serializer.WritePropertyWithDefault<string>(101, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(102, "table", table);
-	serializer.WritePropertyWithDefault<string>(103, "column", column);
-}
-
-QualifiedColumnName QualifiedColumnName::Deserialize(Deserializer &deserializer) {
-	QualifiedColumnName result;
-	deserializer.ReadPropertyWithDefault<string>(100, "catalog", result.catalog);
-	deserializer.ReadPropertyWithDefault<string>(101, "schema", result.schema);
-	deserializer.ReadPropertyWithDefault<string>(102, "table", result.table);
-	deserializer.ReadPropertyWithDefault<string>(103, "column", result.column);
-	return result;
-}
-
-void ReadCSVData::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<string>>(100, "files", files);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(101, "csv_types", csv_types);
-	serializer.WritePropertyWithDefault<vector<string>>(102, "csv_names", csv_names);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(103, "return_types", return_types);
-	serializer.WritePropertyWithDefault<vector<string>>(104, "return_names", return_names);
-	serializer.WritePropertyWithDefault<idx_t>(105, "filename_col_idx", filename_col_idx);
-	serializer.WriteProperty<CSVReaderOptions>(106, "options", options);
-	serializer.WriteProperty<MultiFileReaderBindData>(107, "reader_bind", reader_bind);
-	serializer.WritePropertyWithDefault<vector<ColumnInfo>>(108, "column_info", column_info);
-}
-
-unique_ptr<ReadCSVData> ReadCSVData::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ReadCSVData>(new ReadCSVData());
-	deserializer.ReadPropertyWithDefault<vector<string>>(100, "files", result->files);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(101, "csv_types", result->csv_types);
-	deserializer.ReadPropertyWithDefault<vector<string>>(102, "csv_names", result->csv_names);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(103, "return_types", result->return_types);
-	deserializer.ReadPropertyWithDefault<vector<string>>(104, "return_names", result->return_names);
-	deserializer.ReadPropertyWithDefault<idx_t>(105, "filename_col_idx", result->filename_col_idx);
-	deserializer.ReadProperty<CSVReaderOptions>(106, "options", result->options);
-	deserializer.ReadProperty<MultiFileReaderBindData>(107, "reader_bind", result->reader_bind);
-	deserializer.ReadPropertyWithDefault<vector<ColumnInfo>>(108, "column_info", result->column_info);
-	return result;
-}
-
-void ReservoirSample::Serialize(Serializer &serializer) const {
-	BlockingSample::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "sample_count", sample_count);
-	serializer.WritePropertyWithDefault<unique_ptr<ReservoirChunk>>(201, "reservoir_chunk", reservoir_chunk);
-}
-
-unique_ptr<BlockingSample> ReservoirSample::Deserialize(Deserializer &deserializer) {
-	auto sample_count = deserializer.ReadPropertyWithDefault<idx_t>(200, "sample_count");
-	auto reservoir_chunk = deserializer.ReadPropertyWithDefault<unique_ptr<ReservoirChunk>>(201, "reservoir_chunk");
-	auto result = duckdb::unique_ptr<ReservoirSample>(new ReservoirSample(sample_count, std::move(reservoir_chunk)));
-	return std::move(result);
-}
-
-void ReservoirSamplePercentage::Serialize(Serializer &serializer) const {
-	BlockingSample::Serialize(serializer);
-	serializer.WriteProperty<double>(200, "sample_percentage", sample_percentage);
-	serializer.WritePropertyWithDefault<idx_t>(201, "reservoir_sample_size", reservoir_sample_size);
-}
-
-unique_ptr<BlockingSample> ReservoirSamplePercentage::Deserialize(Deserializer &deserializer) {
-	auto sample_percentage = deserializer.ReadProperty<double>(200, "sample_percentage");
-	auto result = duckdb::unique_ptr<ReservoirSamplePercentage>(new ReservoirSamplePercentage(sample_percentage));
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "reservoir_sample_size", result->reservoir_sample_size);
-	return std::move(result);
-}
-
-void SampleOptions::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<Value>(100, "sample_size", sample_size);
-	serializer.WritePropertyWithDefault<bool>(101, "is_percentage", is_percentage);
-	serializer.WriteProperty<SampleMethod>(102, "method", method);
-	serializer.WritePropertyWithDefault<int64_t>(103, "seed", GetSeed());
-}
-
-unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &deserializer) {
-	auto sample_size = deserializer.ReadProperty<Value>(100, "sample_size");
-	auto is_percentage = deserializer.ReadPropertyWithDefault<bool>(101, "is_percentage");
-	auto method = deserializer.ReadProperty<SampleMethod>(102, "method");
-	auto seed = deserializer.ReadPropertyWithDefault<int64_t>(103, "seed");
-	auto result = duckdb::unique_ptr<SampleOptions>(new SampleOptions(seed));
-	result->sample_size = sample_size;
-	result->is_percentage = is_percentage;
-	result->method = method;
-	return result;
-}
-
-void StrpTimeFormat::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(100, "format_specifier", format_specifier);
-}
-
-StrpTimeFormat StrpTimeFormat::Deserialize(Deserializer &deserializer) {
-	auto format_specifier = deserializer.ReadPropertyWithDefault<string>(100, "format_specifier");
-	StrpTimeFormat result(format_specifier);
-	return result;
-}
-
-void TableFilterSet::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<unordered_map<idx_t, unique_ptr<TableFilter>>>(100, "filters", filters);
-}
-
-TableFilterSet TableFilterSet::Deserialize(Deserializer &deserializer) {
-	TableFilterSet result;
-	deserializer.ReadPropertyWithDefault<unordered_map<idx_t, unique_ptr<TableFilter>>>(100, "filters", result.filters);
-	return result;
-}
-
-void VacuumOptions::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<bool>(100, "vacuum", vacuum);
-	serializer.WritePropertyWithDefault<bool>(101, "analyze", analyze);
-}
-
-VacuumOptions VacuumOptions::Deserialize(Deserializer &deserializer) {
-	VacuumOptions result;
-	deserializer.ReadPropertyWithDefault<bool>(100, "vacuum", result.vacuum);
-	deserializer.ReadPropertyWithDefault<bool>(101, "analyze", result.analyze);
-	return result;
-}
-
-void interval_t::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<int32_t>(1, "months", months);
-	serializer.WritePropertyWithDefault<int32_t>(2, "days", days);
-	serializer.WritePropertyWithDefault<int64_t>(3, "micros", micros);
-}
-
-interval_t interval_t::Deserialize(Deserializer &deserializer) {
-	interval_t result;
-	deserializer.ReadPropertyWithDefault<int32_t>(1, "months", result.months);
-	deserializer.ReadPropertyWithDefault<int32_t>(2, "days", result.days);
-	deserializer.ReadPropertyWithDefault<int64_t>(3, "micros", result.micros);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_parse_info.cpp b/src/duckdb/src/storage/serialization/serialize_parse_info.cpp
deleted file mode 100644
index ccf98a0ce..000000000
--- a/src/duckdb/src/storage/serialization/serialize_parse_info.cpp
+++ /dev/null
@@ -1,553 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/parsed_data/parse_info.hpp"
-#include "duckdb/parser/parsed_data/alter_info.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
-#include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/parser/parsed_data/copy_database_info.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/parsed_data/detach_info.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/parser/parsed_data/load_info.hpp"
-#include "duckdb/parser/parsed_data/update_extensions_info.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
-#include "duckdb/parser/parsed_data/transaction_info.hpp"
-#include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
-
-namespace duckdb {
-
-void ParseInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ParseInfoType>(100, "info_type", info_type);
-}
-
-unique_ptr<ParseInfo> ParseInfo::Deserialize(Deserializer &deserializer) {
-	auto info_type = deserializer.ReadProperty<ParseInfoType>(100, "info_type");
-	unique_ptr<ParseInfo> result;
-	switch (info_type) {
-	case ParseInfoType::ALTER_INFO:
-		result = AlterInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::ATTACH_INFO:
-		result = AttachInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::BOUND_EXPORT_DATA:
-		result = BoundExportData::Deserialize(deserializer);
-		break;
-	case ParseInfoType::COPY_DATABASE_INFO:
-		result = CopyDatabaseInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::COPY_INFO:
-		result = CopyInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::DETACH_INFO:
-		result = DetachInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::DROP_INFO:
-		result = DropInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::LOAD_INFO:
-		result = LoadInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::PRAGMA_INFO:
-		result = PragmaInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::TRANSACTION_INFO:
-		result = TransactionInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::UPDATE_EXTENSIONS_INFO:
-		result = UpdateExtensionsInfo::Deserialize(deserializer);
-		break;
-	case ParseInfoType::VACUUM_INFO:
-		result = VacuumInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of ParseInfo!");
-	}
-	return result;
-}
-
-void AlterInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WriteProperty<AlterType>(200, "type", type);
-	serializer.WritePropertyWithDefault<string>(201, "catalog", catalog);
-	serializer.WritePropertyWithDefault<string>(202, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(203, "name", name);
-	serializer.WriteProperty<OnEntryNotFound>(204, "if_not_found", if_not_found);
-	serializer.WritePropertyWithDefault<bool>(205, "allow_internal", allow_internal);
-}
-
-unique_ptr<ParseInfo> AlterInfo::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<AlterType>(200, "type");
-	auto catalog = deserializer.ReadPropertyWithDefault<string>(201, "catalog");
-	auto schema = deserializer.ReadPropertyWithDefault<string>(202, "schema");
-	auto name = deserializer.ReadPropertyWithDefault<string>(203, "name");
-	auto if_not_found = deserializer.ReadProperty<OnEntryNotFound>(204, "if_not_found");
-	auto allow_internal = deserializer.ReadPropertyWithDefault<bool>(205, "allow_internal");
-	unique_ptr<AlterInfo> result;
-	switch (type) {
-	case AlterType::ALTER_TABLE:
-		result = AlterTableInfo::Deserialize(deserializer);
-		break;
-	case AlterType::ALTER_VIEW:
-		result = AlterViewInfo::Deserialize(deserializer);
-		break;
-	case AlterType::CHANGE_OWNERSHIP:
-		result = ChangeOwnershipInfo::Deserialize(deserializer);
-		break;
-	case AlterType::SET_COLUMN_COMMENT:
-		result = SetColumnCommentInfo::Deserialize(deserializer);
-		break;
-	case AlterType::SET_COMMENT:
-		result = SetCommentInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of AlterInfo!");
-	}
-	result->catalog = std::move(catalog);
-	result->schema = std::move(schema);
-	result->name = std::move(name);
-	result->if_not_found = if_not_found;
-	result->allow_internal = allow_internal;
-	return std::move(result);
-}
-
-void AlterTableInfo::Serialize(Serializer &serializer) const {
-	AlterInfo::Serialize(serializer);
-	serializer.WriteProperty<AlterTableType>(300, "alter_table_type", alter_table_type);
-}
-
-unique_ptr<AlterInfo> AlterTableInfo::Deserialize(Deserializer &deserializer) {
-	auto alter_table_type = deserializer.ReadProperty<AlterTableType>(300, "alter_table_type");
-	unique_ptr<AlterTableInfo> result;
-	switch (alter_table_type) {
-	case AlterTableType::ADD_COLUMN:
-		result = AddColumnInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::ADD_CONSTRAINT:
-		result = AddConstraintInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::ALTER_COLUMN_TYPE:
-		result = ChangeColumnTypeInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::DROP_NOT_NULL:
-		result = DropNotNullInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		result = AlterForeignKeyInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::REMOVE_COLUMN:
-		result = RemoveColumnInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::RENAME_COLUMN:
-		result = RenameColumnInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::RENAME_TABLE:
-		result = RenameTableInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::SET_DEFAULT:
-		result = SetDefaultInfo::Deserialize(deserializer);
-		break;
-	case AlterTableType::SET_NOT_NULL:
-		result = SetNotNullInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of AlterTableInfo!");
-	}
-	return std::move(result);
-}
-
-void AlterViewInfo::Serialize(Serializer &serializer) const {
-	AlterInfo::Serialize(serializer);
-	serializer.WriteProperty<AlterViewType>(300, "alter_view_type", alter_view_type);
-}
-
-unique_ptr<AlterInfo> AlterViewInfo::Deserialize(Deserializer &deserializer) {
-	auto alter_view_type = deserializer.ReadProperty<AlterViewType>(300, "alter_view_type");
-	unique_ptr<AlterViewInfo> result;
-	switch (alter_view_type) {
-	case AlterViewType::RENAME_VIEW:
-		result = RenameViewInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of AlterViewInfo!");
-	}
-	return std::move(result);
-}
-
-void AddColumnInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WriteProperty<ColumnDefinition>(400, "new_column", new_column);
-	serializer.WritePropertyWithDefault<bool>(401, "if_column_not_exists", if_column_not_exists);
-}
-
-unique_ptr<AlterTableInfo> AddColumnInfo::Deserialize(Deserializer &deserializer) {
-	auto new_column = deserializer.ReadProperty<ColumnDefinition>(400, "new_column");
-	auto result = duckdb::unique_ptr<AddColumnInfo>(new AddColumnInfo(std::move(new_column)));
-	deserializer.ReadPropertyWithDefault<bool>(401, "if_column_not_exists", result->if_column_not_exists);
-	return std::move(result);
-}
-
-void AddConstraintInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<Constraint>>(400, "constraint", constraint);
-}
-
-unique_ptr<AlterTableInfo> AddConstraintInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<AddConstraintInfo>(new AddConstraintInfo());
-	deserializer.ReadPropertyWithDefault<unique_ptr<Constraint>>(400, "constraint", result->constraint);
-	return std::move(result);
-}
-
-void AlterForeignKeyInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "fk_table", fk_table);
-	serializer.WritePropertyWithDefault<vector<string>>(401, "pk_columns", pk_columns);
-	serializer.WritePropertyWithDefault<vector<string>>(402, "fk_columns", fk_columns);
-	serializer.WritePropertyWithDefault<vector<PhysicalIndex>>(403, "pk_keys", pk_keys);
-	serializer.WritePropertyWithDefault<vector<PhysicalIndex>>(404, "fk_keys", fk_keys);
-	serializer.WriteProperty<AlterForeignKeyType>(405, "alter_fk_type", type);
-}
-
-unique_ptr<AlterTableInfo> AlterForeignKeyInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<AlterForeignKeyInfo>(new AlterForeignKeyInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "fk_table", result->fk_table);
-	deserializer.ReadPropertyWithDefault<vector<string>>(401, "pk_columns", result->pk_columns);
-	deserializer.ReadPropertyWithDefault<vector<string>>(402, "fk_columns", result->fk_columns);
-	deserializer.ReadPropertyWithDefault<vector<PhysicalIndex>>(403, "pk_keys", result->pk_keys);
-	deserializer.ReadPropertyWithDefault<vector<PhysicalIndex>>(404, "fk_keys", result->fk_keys);
-	deserializer.ReadProperty<AlterForeignKeyType>(405, "alter_fk_type", result->type);
-	return std::move(result);
-}
-
-void AttachInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WritePropertyWithDefault<string>(201, "path", path);
-	serializer.WritePropertyWithDefault<unordered_map<string, Value>>(202, "options", options);
-	serializer.WritePropertyWithDefault<OnCreateConflict>(203, "on_conflict", on_conflict, OnCreateConflict::ERROR_ON_CONFLICT);
-}
-
-unique_ptr<ParseInfo> AttachInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<AttachInfo>(new AttachInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
-	deserializer.ReadPropertyWithDefault<string>(201, "path", result->path);
-	deserializer.ReadPropertyWithDefault<unordered_map<string, Value>>(202, "options", result->options);
-	deserializer.ReadPropertyWithExplicitDefault<OnCreateConflict>(203, "on_conflict", result->on_conflict, OnCreateConflict::ERROR_ON_CONFLICT);
-	return std::move(result);
-}
-
-void BoundExportData::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<ExportedTableInfo>>(200, "data", data);
-}
-
-unique_ptr<ParseInfo> BoundExportData::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BoundExportData>(new BoundExportData());
-	deserializer.ReadPropertyWithDefault<vector<ExportedTableInfo>>(200, "data", result->data);
-	return std::move(result);
-}
-
-void ChangeColumnTypeInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "column_name", column_name);
-	serializer.WriteProperty<LogicalType>(401, "target_type", target_type);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(402, "expression", expression);
-}
-
-unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ChangeColumnTypeInfo>(new ChangeColumnTypeInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "column_name", result->column_name);
-	deserializer.ReadProperty<LogicalType>(401, "target_type", result->target_type);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(402, "expression", result->expression);
-	return std::move(result);
-}
-
-void ChangeOwnershipInfo::Serialize(Serializer &serializer) const {
-	AlterInfo::Serialize(serializer);
-	serializer.WriteProperty<CatalogType>(300, "entry_catalog_type", entry_catalog_type);
-	serializer.WritePropertyWithDefault<string>(301, "owner_schema", owner_schema);
-	serializer.WritePropertyWithDefault<string>(302, "owner_name", owner_name);
-}
-
-unique_ptr<AlterInfo> ChangeOwnershipInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ChangeOwnershipInfo>(new ChangeOwnershipInfo());
-	deserializer.ReadProperty<CatalogType>(300, "entry_catalog_type", result->entry_catalog_type);
-	deserializer.ReadPropertyWithDefault<string>(301, "owner_schema", result->owner_schema);
-	deserializer.ReadPropertyWithDefault<string>(302, "owner_name", result->owner_name);
-	return std::move(result);
-}
-
-void CopyDatabaseInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "target_database", target_database);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<CreateInfo>>>(201, "entries", entries);
-}
-
-unique_ptr<ParseInfo> CopyDatabaseInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CopyDatabaseInfo>(new CopyDatabaseInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "target_database", result->target_database);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<CreateInfo>>>(201, "entries", result->entries);
-	return std::move(result);
-}
-
-void CopyInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "catalog", catalog);
-	serializer.WritePropertyWithDefault<string>(201, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(202, "table", table);
-	serializer.WritePropertyWithDefault<vector<string>>(203, "select_list", select_list);
-	serializer.WritePropertyWithDefault<bool>(204, "is_from", is_from);
-	serializer.WritePropertyWithDefault<string>(205, "format", format);
-	serializer.WritePropertyWithDefault<string>(206, "file_path", file_path);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<vector<Value>>>(207, "options", options);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(208, "select_statement", select_statement);
-}
-
-unique_ptr<ParseInfo> CopyInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CopyInfo>(new CopyInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "catalog", result->catalog);
-	deserializer.ReadPropertyWithDefault<string>(201, "schema", result->schema);
-	deserializer.ReadPropertyWithDefault<string>(202, "table", result->table);
-	deserializer.ReadPropertyWithDefault<vector<string>>(203, "select_list", result->select_list);
-	deserializer.ReadPropertyWithDefault<bool>(204, "is_from", result->is_from);
-	deserializer.ReadPropertyWithDefault<string>(205, "format", result->format);
-	deserializer.ReadPropertyWithDefault<string>(206, "file_path", result->file_path);
-	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<vector<Value>>>(207, "options", result->options);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(208, "select_statement", result->select_statement);
-	return std::move(result);
-}
-
-void DetachInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WriteProperty<OnEntryNotFound>(201, "if_not_found", if_not_found);
-}
-
-unique_ptr<ParseInfo> DetachInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<DetachInfo>(new DetachInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
-	deserializer.ReadProperty<OnEntryNotFound>(201, "if_not_found", result->if_not_found);
-	return std::move(result);
-}
-
-void DropInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WriteProperty<CatalogType>(200, "type", type);
-	serializer.WritePropertyWithDefault<string>(201, "catalog", catalog);
-	serializer.WritePropertyWithDefault<string>(202, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(203, "name", name);
-	serializer.WriteProperty<OnEntryNotFound>(204, "if_not_found", if_not_found);
-	serializer.WritePropertyWithDefault<bool>(205, "cascade", cascade);
-	serializer.WritePropertyWithDefault<bool>(206, "allow_drop_internal", allow_drop_internal);
-	serializer.WritePropertyWithDefault<unique_ptr<ExtraDropInfo>>(207, "extra_drop_info", extra_drop_info);
-}
-
-unique_ptr<ParseInfo> DropInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<DropInfo>(new DropInfo());
-	deserializer.ReadProperty<CatalogType>(200, "type", result->type);
-	deserializer.ReadPropertyWithDefault<string>(201, "catalog", result->catalog);
-	deserializer.ReadPropertyWithDefault<string>(202, "schema", result->schema);
-	deserializer.ReadPropertyWithDefault<string>(203, "name", result->name);
-	deserializer.ReadProperty<OnEntryNotFound>(204, "if_not_found", result->if_not_found);
-	deserializer.ReadPropertyWithDefault<bool>(205, "cascade", result->cascade);
-	deserializer.ReadPropertyWithDefault<bool>(206, "allow_drop_internal", result->allow_drop_internal);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ExtraDropInfo>>(207, "extra_drop_info", result->extra_drop_info);
-	return std::move(result);
-}
-
-void DropNotNullInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "column_name", column_name);
-}
-
-unique_ptr<AlterTableInfo> DropNotNullInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<DropNotNullInfo>(new DropNotNullInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "column_name", result->column_name);
-	return std::move(result);
-}
-
-void LoadInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "filename", filename);
-	serializer.WriteProperty<LoadType>(201, "load_type", load_type);
-	serializer.WritePropertyWithDefault<string>(202, "repository", repository);
-	serializer.WritePropertyWithDefault<string>(203, "version", version);
-	serializer.WritePropertyWithDefault<bool>(204, "repo_is_alias", repo_is_alias);
-}
-
-unique_ptr<ParseInfo> LoadInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LoadInfo>(new LoadInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "filename", result->filename);
-	deserializer.ReadProperty<LoadType>(201, "load_type", result->load_type);
-	deserializer.ReadPropertyWithDefault<string>(202, "repository", result->repository);
-	deserializer.ReadPropertyWithDefault<string>(203, "version", result->version);
-	deserializer.ReadPropertyWithDefault<bool>(204, "repo_is_alias", result->repo_is_alias);
-	return std::move(result);
-}
-
-void PragmaInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(201, "parameters", parameters);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(202, "named_parameters", named_parameters);
-}
-
-unique_ptr<ParseInfo> PragmaInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<PragmaInfo>(new PragmaInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(201, "parameters", result->parameters);
-	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(202, "named_parameters", result->named_parameters);
-	return std::move(result);
-}
-
-void RemoveColumnInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "removed_column", removed_column);
-	serializer.WritePropertyWithDefault<bool>(401, "if_column_exists", if_column_exists);
-	serializer.WritePropertyWithDefault<bool>(402, "cascade", cascade);
-}
-
-unique_ptr<AlterTableInfo> RemoveColumnInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RemoveColumnInfo>(new RemoveColumnInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "removed_column", result->removed_column);
-	deserializer.ReadPropertyWithDefault<bool>(401, "if_column_exists", result->if_column_exists);
-	deserializer.ReadPropertyWithDefault<bool>(402, "cascade", result->cascade);
-	return std::move(result);
-}
-
-void RenameColumnInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "old_name", old_name);
-	serializer.WritePropertyWithDefault<string>(401, "new_name", new_name);
-}
-
-unique_ptr<AlterTableInfo> RenameColumnInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RenameColumnInfo>(new RenameColumnInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "old_name", result->old_name);
-	deserializer.ReadPropertyWithDefault<string>(401, "new_name", result->new_name);
-	return std::move(result);
-}
-
-void RenameTableInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "new_table_name", new_table_name);
-}
-
-unique_ptr<AlterTableInfo> RenameTableInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RenameTableInfo>(new RenameTableInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "new_table_name", result->new_table_name);
-	return std::move(result);
-}
-
-void RenameViewInfo::Serialize(Serializer &serializer) const {
-	AlterViewInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "new_view_name", new_view_name);
-}
-
-unique_ptr<AlterViewInfo> RenameViewInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RenameViewInfo>(new RenameViewInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "new_view_name", result->new_view_name);
-	return std::move(result);
-}
-
-void SetColumnCommentInfo::Serialize(Serializer &serializer) const {
-	AlterInfo::Serialize(serializer);
-	serializer.WriteProperty<CatalogType>(300, "catalog_entry_type", catalog_entry_type);
-	serializer.WriteProperty<Value>(301, "comment_value", comment_value);
-	serializer.WritePropertyWithDefault<string>(302, "column_name", column_name);
-}
-
-unique_ptr<AlterInfo> SetColumnCommentInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SetColumnCommentInfo>(new SetColumnCommentInfo());
-	deserializer.ReadProperty<CatalogType>(300, "catalog_entry_type", result->catalog_entry_type);
-	deserializer.ReadProperty<Value>(301, "comment_value", result->comment_value);
-	deserializer.ReadPropertyWithDefault<string>(302, "column_name", result->column_name);
-	return std::move(result);
-}
-
-void SetCommentInfo::Serialize(Serializer &serializer) const {
-	AlterInfo::Serialize(serializer);
-	serializer.WriteProperty<CatalogType>(300, "entry_catalog_type", entry_catalog_type);
-	serializer.WriteProperty<Value>(301, "comment_value", comment_value);
-}
-
-unique_ptr<AlterInfo> SetCommentInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SetCommentInfo>(new SetCommentInfo());
-	deserializer.ReadProperty<CatalogType>(300, "entry_catalog_type", result->entry_catalog_type);
-	deserializer.ReadProperty<Value>(301, "comment_value", result->comment_value);
-	return std::move(result);
-}
-
-void SetDefaultInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "column_name", column_name);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(401, "expression", expression);
-}
-
-unique_ptr<AlterTableInfo> SetDefaultInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SetDefaultInfo>(new SetDefaultInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "column_name", result->column_name);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(401, "expression", result->expression);
-	return std::move(result);
-}
-
-void SetNotNullInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "column_name", column_name);
-}
-
-unique_ptr<AlterTableInfo> SetNotNullInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SetNotNullInfo>(new SetNotNullInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "column_name", result->column_name);
-	return std::move(result);
-}
-
-void TransactionInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WriteProperty<TransactionType>(200, "type", type);
-	serializer.WriteProperty<TransactionModifierType>(201, "modifier", modifier);
-}
-
-unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<TransactionInfo>(new TransactionInfo());
-	deserializer.ReadProperty<TransactionType>(200, "type", result->type);
-	deserializer.ReadProperty<TransactionModifierType>(201, "modifier", result->modifier);
-	return std::move(result);
-}
-
-void UpdateExtensionsInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<string>>(200, "extensions_to_update", extensions_to_update);
-}
-
-unique_ptr<ParseInfo> UpdateExtensionsInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<UpdateExtensionsInfo>(new UpdateExtensionsInfo());
-	deserializer.ReadPropertyWithDefault<vector<string>>(200, "extensions_to_update", result->extensions_to_update);
-	return std::move(result);
-}
-
-void VacuumInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WriteProperty<VacuumOptions>(200, "options", options);
-	serializer.WritePropertyWithDefault<bool>(201, "has_table", has_table);
-	serializer.WritePropertyWithDefault<unique_ptr<TableRef>>(202, "ref", ref);
-	serializer.WritePropertyWithDefault<vector<string>>(203, "columns", columns);
-}
-
-unique_ptr<ParseInfo> VacuumInfo::Deserialize(Deserializer &deserializer) {
-	auto options = deserializer.ReadProperty<VacuumOptions>(200, "options");
-	auto result = duckdb::unique_ptr<VacuumInfo>(new VacuumInfo(options));
-	deserializer.ReadPropertyWithDefault<bool>(201, "has_table", result->has_table);
-	deserializer.ReadPropertyWithDefault<unique_ptr<TableRef>>(202, "ref", result->ref);
-	deserializer.ReadPropertyWithDefault<vector<string>>(203, "columns", result->columns);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp b/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp
deleted file mode 100644
index a5c79b3d9..000000000
--- a/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp
+++ /dev/null
@@ -1,378 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/expression/list.hpp"
-
-namespace duckdb {
-
-void ParsedExpression::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ExpressionClass>(100, "class", expression_class);
-	serializer.WriteProperty<ExpressionType>(101, "type", type);
-	serializer.WritePropertyWithDefault<string>(102, "alias", alias);
-	serializer.WritePropertyWithDefault<optional_idx>(103, "query_location", query_location, optional_idx());
-}
-
-unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &deserializer) {
-	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "class");
-	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
-	auto alias = deserializer.ReadPropertyWithDefault<string>(102, "alias");
-	auto query_location = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(103, "query_location", optional_idx());
-	deserializer.Set<ExpressionType>(type);
-	unique_ptr<ParsedExpression> result;
-	switch (expression_class) {
-	case ExpressionClass::BETWEEN:
-		result = BetweenExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::CASE:
-		result = CaseExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::CAST:
-		result = CastExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::COLLATE:
-		result = CollateExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::COLUMN_REF:
-		result = ColumnRefExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::COMPARISON:
-		result = ComparisonExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::CONJUNCTION:
-		result = ConjunctionExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::CONSTANT:
-		result = ConstantExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::DEFAULT:
-		result = DefaultExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::FUNCTION:
-		result = FunctionExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::LAMBDA:
-		result = LambdaExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::LAMBDA_REF:
-		result = LambdaRefExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::OPERATOR:
-		result = OperatorExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::PARAMETER:
-		result = ParameterExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		result = PositionalReferenceExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::STAR:
-		result = StarExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::SUBQUERY:
-		result = SubqueryExpression::Deserialize(deserializer);
-		break;
-	case ExpressionClass::WINDOW:
-		result = WindowExpression::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of ParsedExpression!");
-	}
-	deserializer.Unset<ExpressionType>();
-	result->alias = std::move(alias);
-	result->query_location = query_location;
-	return result;
-}
-
-void BetweenExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "input", input);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(201, "lower", lower);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(202, "upper", upper);
-}
-
-unique_ptr<ParsedExpression> BetweenExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BetweenExpression>(new BetweenExpression());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "input", result->input);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(201, "lower", result->lower);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(202, "upper", result->upper);
-	return std::move(result);
-}
-
-void CaseExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<CaseCheck>>(200, "case_checks", case_checks);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(201, "else_expr", else_expr);
-}
-
-unique_ptr<ParsedExpression> CaseExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
-	deserializer.ReadPropertyWithDefault<vector<CaseCheck>>(200, "case_checks", result->case_checks);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(201, "else_expr", result->else_expr);
-	return std::move(result);
-}
-
-void CastExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "child", child);
-	serializer.WriteProperty<LogicalType>(201, "cast_type", cast_type);
-	serializer.WritePropertyWithDefault<bool>(202, "try_cast", try_cast);
-}
-
-unique_ptr<ParsedExpression> CastExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CastExpression>(new CastExpression());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "child", result->child);
-	deserializer.ReadProperty<LogicalType>(201, "cast_type", result->cast_type);
-	deserializer.ReadPropertyWithDefault<bool>(202, "try_cast", result->try_cast);
-	return std::move(result);
-}
-
-void CollateExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "child", child);
-	serializer.WritePropertyWithDefault<string>(201, "collation", collation);
-}
-
-unique_ptr<ParsedExpression> CollateExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "child", result->child);
-	deserializer.ReadPropertyWithDefault<string>(201, "collation", result->collation);
-	return std::move(result);
-}
-
-void ColumnRefExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<string>>(200, "column_names", column_names);
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
-	deserializer.ReadPropertyWithDefault<vector<string>>(200, "column_names", result->column_names);
-	return std::move(result);
-}
-
-void ComparisonExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "left", left);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(201, "right", right);
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "left", result->left);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(201, "right", result->right);
-	return std::move(result);
-}
-
-void ConjunctionExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "children", children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "children", result->children);
-	return std::move(result);
-}
-
-void ConstantExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteProperty<Value>(200, "value", value);
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
-	deserializer.ReadProperty<Value>(200, "value", result->value);
-	return std::move(result);
-}
-
-void DefaultExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-}
-
-unique_ptr<ParsedExpression> DefaultExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<DefaultExpression>(new DefaultExpression());
-	return std::move(result);
-}
-
-void FunctionExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "function_name", function_name);
-	serializer.WritePropertyWithDefault<string>(201, "schema", schema);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(202, "children", children);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(203, "filter", filter);
-	serializer.WritePropertyWithDefault<unique_ptr<OrderModifier>>(204, "order_bys", order_bys);
-	serializer.WritePropertyWithDefault<bool>(205, "distinct", distinct);
-	serializer.WritePropertyWithDefault<bool>(206, "is_operator", is_operator);
-	serializer.WritePropertyWithDefault<bool>(207, "export_state", export_state);
-	serializer.WritePropertyWithDefault<string>(208, "catalog", catalog);
-}
-
-unique_ptr<ParsedExpression> FunctionExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<FunctionExpression>(new FunctionExpression());
-	deserializer.ReadPropertyWithDefault<string>(200, "function_name", result->function_name);
-	deserializer.ReadPropertyWithDefault<string>(201, "schema", result->schema);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(202, "children", result->children);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(203, "filter", result->filter);
-	auto order_bys = deserializer.ReadPropertyWithDefault<unique_ptr<ResultModifier>>(204, "order_bys");
-	result->order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(std::move(order_bys));
-	deserializer.ReadPropertyWithDefault<bool>(205, "distinct", result->distinct);
-	deserializer.ReadPropertyWithDefault<bool>(206, "is_operator", result->is_operator);
-	deserializer.ReadPropertyWithDefault<bool>(207, "export_state", result->export_state);
-	deserializer.ReadPropertyWithDefault<string>(208, "catalog", result->catalog);
-	return std::move(result);
-}
-
-void LambdaExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "lhs", lhs);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(201, "expr", expr);
-}
-
-unique_ptr<ParsedExpression> LambdaExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "lhs", result->lhs);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(201, "expr", result->expr);
-	return std::move(result);
-}
-
-void LambdaRefExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "lambda_idx", lambda_idx);
-	serializer.WritePropertyWithDefault<string>(201, "column_name", column_name);
-}
-
-unique_ptr<ParsedExpression> LambdaRefExpression::Deserialize(Deserializer &deserializer) {
-	auto lambda_idx = deserializer.ReadPropertyWithDefault<idx_t>(200, "lambda_idx");
-	auto column_name = deserializer.ReadPropertyWithDefault<string>(201, "column_name");
-	auto result = duckdb::unique_ptr<LambdaRefExpression>(new LambdaRefExpression(lambda_idx, std::move(column_name)));
-	return std::move(result);
-}
-
-void OperatorExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "children", children);
-}
-
-unique_ptr<ParsedExpression> OperatorExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "children", result->children);
-	return std::move(result);
-}
-
-void ParameterExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "identifier", identifier);
-}
-
-unique_ptr<ParsedExpression> ParameterExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
-	deserializer.ReadPropertyWithDefault<string>(200, "identifier", result->identifier);
-	return std::move(result);
-}
-
-void PositionalReferenceExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "index", index);
-}
-
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
-	deserializer.ReadPropertyWithDefault<idx_t>(200, "index", result->index);
-	return std::move(result);
-}
-
-void StarExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "relation_name", relation_name);
-	serializer.WriteProperty<case_insensitive_set_t>(201, "exclude_list", SerializedExcludeList());
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(202, "replace_list", replace_list);
-	serializer.WritePropertyWithDefault<bool>(203, "columns", columns);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(204, "expr", expr);
-	serializer.WritePropertyWithDefault<bool>(205, "unpacked", unpacked, false);
-	serializer.WritePropertyWithDefault<qualified_column_set_t>(206, "qualified_exclude_list", SerializedQualifiedExcludeList(), qualified_column_set_t());
-	serializer.WritePropertyWithDefault<qualified_column_map_t<string>>(207, "rename_list", rename_list, qualified_column_map_t<string>());
-}
-
-unique_ptr<ParsedExpression> StarExpression::Deserialize(Deserializer &deserializer) {
-	auto relation_name = deserializer.ReadPropertyWithDefault<string>(200, "relation_name");
-	auto exclude_list = deserializer.ReadProperty<case_insensitive_set_t>(201, "exclude_list");
-	auto replace_list = deserializer.ReadPropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(202, "replace_list");
-	auto columns = deserializer.ReadPropertyWithDefault<bool>(203, "columns");
-	auto expr = deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(204, "expr");
-	auto unpacked = deserializer.ReadPropertyWithExplicitDefault<bool>(205, "unpacked", false);
-	auto qualified_exclude_list = deserializer.ReadPropertyWithExplicitDefault<qualified_column_set_t>(206, "qualified_exclude_list", qualified_column_set_t());
-	auto result = duckdb::unique_ptr<StarExpression>(new StarExpression(exclude_list, qualified_exclude_list));
-	result->relation_name = std::move(relation_name);
-	result->replace_list = std::move(replace_list);
-	result->columns = columns;
-	result->expr = std::move(expr);
-	result->unpacked = unpacked;
-	deserializer.ReadPropertyWithExplicitDefault<qualified_column_map_t<string>>(207, "rename_list", result->rename_list, qualified_column_map_t<string>());
-	return std::move(result);
-}
-
-void SubqueryExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteProperty<SubqueryType>(200, "subquery_type", subquery_type);
-	serializer.WritePropertyWithDefault<unique_ptr<SelectStatement>>(201, "subquery", subquery);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(202, "child", child);
-	serializer.WriteProperty<ExpressionType>(203, "comparison_type", comparison_type);
-}
-
-unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
-	deserializer.ReadProperty<SubqueryType>(200, "subquery_type", result->subquery_type);
-	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(201, "subquery", result->subquery);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(202, "child", result->child);
-	deserializer.ReadProperty<ExpressionType>(203, "comparison_type", result->comparison_type);
-	return std::move(result);
-}
-
-void WindowExpression::Serialize(Serializer &serializer) const {
-	ParsedExpression::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "function_name", function_name);
-	serializer.WritePropertyWithDefault<string>(201, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(202, "catalog", catalog);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(203, "children", children);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(204, "partitions", partitions);
-	serializer.WritePropertyWithDefault<vector<OrderByNode>>(205, "orders", orders);
-	serializer.WriteProperty<WindowBoundary>(206, "start", start);
-	serializer.WriteProperty<WindowBoundary>(207, "end", end);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(208, "start_expr", start_expr);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(209, "end_expr", end_expr);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(210, "offset_expr", offset_expr);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(211, "default_expr", default_expr);
-	serializer.WritePropertyWithDefault<bool>(212, "ignore_nulls", ignore_nulls);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(213, "filter_expr", filter_expr);
-	serializer.WritePropertyWithDefault<WindowExcludeMode>(214, "exclude_clause", exclude_clause, WindowExcludeMode::NO_OTHER);
-	serializer.WritePropertyWithDefault<bool>(215, "distinct", distinct);
-	serializer.WritePropertyWithDefault<vector<OrderByNode>>(216, "arg_orders", arg_orders);
-}
-
-unique_ptr<ParsedExpression> WindowExpression::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadPropertyWithDefault<string>(200, "function_name", result->function_name);
-	deserializer.ReadPropertyWithDefault<string>(201, "schema", result->schema);
-	deserializer.ReadPropertyWithDefault<string>(202, "catalog", result->catalog);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(203, "children", result->children);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(204, "partitions", result->partitions);
-	deserializer.ReadPropertyWithDefault<vector<OrderByNode>>(205, "orders", result->orders);
-	deserializer.ReadProperty<WindowBoundary>(206, "start", result->start);
-	deserializer.ReadProperty<WindowBoundary>(207, "end", result->end);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(208, "start_expr", result->start_expr);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(209, "end_expr", result->end_expr);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(210, "offset_expr", result->offset_expr);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(211, "default_expr", result->default_expr);
-	deserializer.ReadPropertyWithDefault<bool>(212, "ignore_nulls", result->ignore_nulls);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(213, "filter_expr", result->filter_expr);
-	deserializer.ReadPropertyWithExplicitDefault<WindowExcludeMode>(214, "exclude_clause", result->exclude_clause, WindowExcludeMode::NO_OTHER);
-	deserializer.ReadPropertyWithDefault<bool>(215, "distinct", result->distinct);
-	deserializer.ReadPropertyWithDefault<vector<OrderByNode>>(216, "arg_orders", result->arg_orders);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_query_node.cpp b/src/duckdb/src/storage/serialization/serialize_query_node.cpp
deleted file mode 100644
index cc8280b2d..000000000
--- a/src/duckdb/src/storage/serialization/serialize_query_node.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/query_node/list.hpp"
-
-namespace duckdb {
-
-void QueryNode::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<QueryNodeType>(100, "type", type);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ResultModifier>>>(101, "modifiers", modifiers);
-	serializer.WriteProperty<CommonTableExpressionMap>(102, "cte_map", cte_map);
-}
-
-unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<QueryNodeType>(100, "type");
-	auto modifiers = deserializer.ReadPropertyWithDefault<vector<unique_ptr<ResultModifier>>>(101, "modifiers");
-	auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>(102, "cte_map");
-	unique_ptr<QueryNode> result;
-	switch (type) {
-	case QueryNodeType::CTE_NODE:
-		result = CTENode::Deserialize(deserializer);
-		break;
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = RecursiveCTENode::Deserialize(deserializer);
-		break;
-	case QueryNodeType::SELECT_NODE:
-		result = SelectNode::Deserialize(deserializer);
-		break;
-	case QueryNodeType::SET_OPERATION_NODE:
-		result = SetOperationNode::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of QueryNode!");
-	}
-	result->modifiers = std::move(modifiers);
-	result->cte_map = std::move(cte_map);
-	return result;
-}
-
-void CTENode::Serialize(Serializer &serializer) const {
-	QueryNode::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "cte_name", ctename);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(201, "query", query);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(202, "child", child);
-	serializer.WritePropertyWithDefault<vector<string>>(203, "aliases", aliases);
-}
-
-unique_ptr<QueryNode> CTENode::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
-	deserializer.ReadPropertyWithDefault<string>(200, "cte_name", result->ctename);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(201, "query", result->query);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(202, "child", result->child);
-	deserializer.ReadPropertyWithDefault<vector<string>>(203, "aliases", result->aliases);
-	return std::move(result);
-}
-
-void RecursiveCTENode::Serialize(Serializer &serializer) const {
-	QueryNode::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "cte_name", ctename);
-	serializer.WritePropertyWithDefault<bool>(201, "union_all", union_all, false);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(202, "left", left);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(203, "right", right);
-	serializer.WritePropertyWithDefault<vector<string>>(204, "aliases", aliases);
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
-	deserializer.ReadPropertyWithDefault<string>(200, "cte_name", result->ctename);
-	deserializer.ReadPropertyWithExplicitDefault<bool>(201, "union_all", result->union_all, false);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(202, "left", result->left);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(203, "right", result->right);
-	deserializer.ReadPropertyWithDefault<vector<string>>(204, "aliases", result->aliases);
-	return std::move(result);
-}
-
-void SelectNode::Serialize(Serializer &serializer) const {
-	QueryNode::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "select_list", select_list);
-	serializer.WritePropertyWithDefault<unique_ptr<TableRef>>(201, "from_table", from_table);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(202, "where_clause", where_clause);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(203, "group_expressions", groups.group_expressions);
-	serializer.WritePropertyWithDefault<vector<GroupingSet>>(204, "group_sets", groups.grouping_sets);
-	serializer.WriteProperty<AggregateHandling>(205, "aggregate_handling", aggregate_handling);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(206, "having", having);
-	serializer.WritePropertyWithDefault<unique_ptr<SampleOptions>>(207, "sample", sample);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(208, "qualify", qualify);
-}
-
-unique_ptr<QueryNode> SelectNode::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SelectNode>(new SelectNode());
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "select_list", result->select_list);
-	deserializer.ReadPropertyWithDefault<unique_ptr<TableRef>>(201, "from_table", result->from_table);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(202, "where_clause", result->where_clause);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(203, "group_expressions", result->groups.group_expressions);
-	deserializer.ReadPropertyWithDefault<vector<GroupingSet>>(204, "group_sets", result->groups.grouping_sets);
-	deserializer.ReadProperty<AggregateHandling>(205, "aggregate_handling", result->aggregate_handling);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(206, "having", result->having);
-	deserializer.ReadPropertyWithDefault<unique_ptr<SampleOptions>>(207, "sample", result->sample);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(208, "qualify", result->qualify);
-	return std::move(result);
-}
-
-void SetOperationNode::Serialize(Serializer &serializer) const {
-	QueryNode::Serialize(serializer);
-	serializer.WriteProperty<SetOperationType>(200, "setop_type", setop_type);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(201, "left", left);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(202, "right", right);
-	serializer.WritePropertyWithDefault<bool>(203, "setop_all", setop_all, true);
-}
-
-unique_ptr<QueryNode> SetOperationNode::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SetOperationNode>(new SetOperationNode());
-	deserializer.ReadProperty<SetOperationType>(200, "setop_type", result->setop_type);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(201, "left", result->left);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(202, "right", result->right);
-	deserializer.ReadPropertyWithExplicitDefault<bool>(203, "setop_all", result->setop_all, true);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp b/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp
deleted file mode 100644
index 261f106c6..000000000
--- a/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-
-namespace duckdb {
-
-void ResultModifier::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ResultModifierType>(100, "type", type);
-}
-
-unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ResultModifierType>(100, "type");
-	unique_ptr<ResultModifier> result;
-	switch (type) {
-	case ResultModifierType::DISTINCT_MODIFIER:
-		result = DistinctModifier::Deserialize(deserializer);
-		break;
-	case ResultModifierType::LIMIT_MODIFIER:
-		result = LimitModifier::Deserialize(deserializer);
-		break;
-	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-		result = LimitPercentModifier::Deserialize(deserializer);
-		break;
-	case ResultModifierType::ORDER_MODIFIER:
-		result = OrderModifier::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of ResultModifier!");
-	}
-	return result;
-}
-
-void BoundOrderModifier::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<BoundOrderByNode>>(100, "orders", orders);
-}
-
-unique_ptr<BoundOrderModifier> BoundOrderModifier::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BoundOrderModifier>(new BoundOrderModifier());
-	deserializer.ReadPropertyWithDefault<vector<BoundOrderByNode>>(100, "orders", result->orders);
-	return result;
-}
-
-void DistinctModifier::Serialize(Serializer &serializer) const {
-	ResultModifier::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "distinct_on_targets", distinct_on_targets);
-}
-
-unique_ptr<ResultModifier> DistinctModifier::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<DistinctModifier>(new DistinctModifier());
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(200, "distinct_on_targets", result->distinct_on_targets);
-	return std::move(result);
-}
-
-void LimitModifier::Serialize(Serializer &serializer) const {
-	ResultModifier::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "limit", limit);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(201, "offset", offset);
-}
-
-unique_ptr<ResultModifier> LimitModifier::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "limit", result->limit);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(201, "offset", result->offset);
-	return std::move(result);
-}
-
-void LimitPercentModifier::Serialize(Serializer &serializer) const {
-	ResultModifier::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "limit", limit);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(201, "offset", offset);
-}
-
-unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LimitPercentModifier>(new LimitPercentModifier());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "limit", result->limit);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(201, "offset", result->offset);
-	return std::move(result);
-}
-
-void OrderModifier::Serialize(Serializer &serializer) const {
-	ResultModifier::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<OrderByNode>>(200, "orders", orders);
-}
-
-unique_ptr<ResultModifier> OrderModifier::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
-	deserializer.ReadPropertyWithDefault<vector<OrderByNode>>(200, "orders", result->orders);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_statement.cpp b/src/duckdb/src/storage/serialization/serialize_statement.cpp
deleted file mode 100644
index 9c61db6e3..000000000
--- a/src/duckdb/src/storage/serialization/serialize_statement.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-
-namespace duckdb {
-
-void SelectStatement::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(100, "node", node);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<idx_t>>(101, "named_param_map", named_param_map);
-}
-
-unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SelectStatement>(new SelectStatement());
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(100, "node", result->node);
-	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<idx_t>>(101, "named_param_map", result->named_param_map);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_storage.cpp b/src/duckdb/src/storage/serialization/serialize_storage.cpp
deleted file mode 100644
index 29ac3038c..000000000
--- a/src/duckdb/src/storage/serialization/serialize_storage.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-
-namespace duckdb {
-
-void BlockPointer::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<block_id_t>(100, "block_id", block_id);
-	serializer.WritePropertyWithDefault<uint32_t>(101, "offset", offset);
-}
-
-BlockPointer BlockPointer::Deserialize(Deserializer &deserializer) {
-	auto block_id = deserializer.ReadProperty<block_id_t>(100, "block_id");
-	auto offset = deserializer.ReadPropertyWithDefault<uint32_t>(101, "offset");
-	BlockPointer result(block_id, offset);
-	return result;
-}
-
-void DataPointer::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<uint64_t>(100, "row_start", row_start);
-	serializer.WritePropertyWithDefault<uint64_t>(101, "tuple_count", tuple_count);
-	serializer.WriteProperty<BlockPointer>(102, "block_pointer", block_pointer);
-	serializer.WriteProperty<CompressionType>(103, "compression_type", compression_type);
-	serializer.WriteProperty<BaseStatistics>(104, "statistics", statistics);
-	serializer.WritePropertyWithDefault<unique_ptr<ColumnSegmentState>>(105, "segment_state", segment_state);
-}
-
-DataPointer DataPointer::Deserialize(Deserializer &deserializer) {
-	auto row_start = deserializer.ReadPropertyWithDefault<uint64_t>(100, "row_start");
-	auto tuple_count = deserializer.ReadPropertyWithDefault<uint64_t>(101, "tuple_count");
-	auto block_pointer = deserializer.ReadProperty<BlockPointer>(102, "block_pointer");
-	auto compression_type = deserializer.ReadProperty<CompressionType>(103, "compression_type");
-	auto statistics = deserializer.ReadProperty<BaseStatistics>(104, "statistics");
-	DataPointer result(std::move(statistics));
-	result.row_start = row_start;
-	result.tuple_count = tuple_count;
-	result.block_pointer = block_pointer;
-	result.compression_type = compression_type;
-	deserializer.Set<CompressionType>(compression_type);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ColumnSegmentState>>(105, "segment_state", result.segment_state);
-	deserializer.Unset<CompressionType>();
-	return result;
-}
-
-void DistinctStatistics::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "sample_count", sample_count);
-	serializer.WritePropertyWithDefault<idx_t>(101, "total_count", total_count);
-	serializer.WritePropertyWithDefault<unique_ptr<HyperLogLog>>(102, "log", log);
-}
-
-unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(Deserializer &deserializer) {
-	auto sample_count = deserializer.ReadPropertyWithDefault<idx_t>(100, "sample_count");
-	auto total_count = deserializer.ReadPropertyWithDefault<idx_t>(101, "total_count");
-	auto log = deserializer.ReadPropertyWithDefault<unique_ptr<HyperLogLog>>(102, "log");
-	auto result = duckdb::unique_ptr<DistinctStatistics>(new DistinctStatistics(std::move(log), sample_count, total_count));
-	return result;
-}
-
-void FixedSizeAllocatorInfo::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "segment_size", segment_size);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(101, "buffer_ids", buffer_ids);
-	serializer.WritePropertyWithDefault<vector<BlockPointer>>(102, "block_pointers", block_pointers);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(103, "segment_counts", segment_counts);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(104, "allocation_sizes", allocation_sizes);
-	serializer.WritePropertyWithDefault<vector<idx_t>>(105, "buffers_with_free_space", buffers_with_free_space);
-}
-
-FixedSizeAllocatorInfo FixedSizeAllocatorInfo::Deserialize(Deserializer &deserializer) {
-	FixedSizeAllocatorInfo result;
-	deserializer.ReadPropertyWithDefault<idx_t>(100, "segment_size", result.segment_size);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(101, "buffer_ids", result.buffer_ids);
-	deserializer.ReadPropertyWithDefault<vector<BlockPointer>>(102, "block_pointers", result.block_pointers);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(103, "segment_counts", result.segment_counts);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(104, "allocation_sizes", result.allocation_sizes);
-	deserializer.ReadPropertyWithDefault<vector<idx_t>>(105, "buffers_with_free_space", result.buffers_with_free_space);
-	return result;
-}
-
-void IndexStorageInfo::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<string>(100, "name", name);
-	serializer.WritePropertyWithDefault<idx_t>(101, "root", root);
-	serializer.WritePropertyWithDefault<vector<FixedSizeAllocatorInfo>>(102, "allocator_infos", allocator_infos);
-	serializer.WritePropertyWithDefault<case_insensitive_map_t<Value>>(103, "options", options, case_insensitive_map_t<Value>());
-}
-
-IndexStorageInfo IndexStorageInfo::Deserialize(Deserializer &deserializer) {
-	IndexStorageInfo result;
-	deserializer.ReadPropertyWithDefault<string>(100, "name", result.name);
-	deserializer.ReadPropertyWithDefault<idx_t>(101, "root", result.root);
-	deserializer.ReadPropertyWithDefault<vector<FixedSizeAllocatorInfo>>(102, "allocator_infos", result.allocator_infos);
-	deserializer.ReadPropertyWithExplicitDefault<case_insensitive_map_t<Value>>(103, "options", result.options, case_insensitive_map_t<Value>());
-	return result;
-}
-
-void MetaBlockPointer::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<idx_t>(100, "block_pointer", block_pointer);
-	serializer.WritePropertyWithDefault<uint32_t>(101, "offset", offset);
-}
-
-MetaBlockPointer MetaBlockPointer::Deserialize(Deserializer &deserializer) {
-	auto block_pointer = deserializer.ReadPropertyWithDefault<idx_t>(100, "block_pointer");
-	auto offset = deserializer.ReadPropertyWithDefault<uint32_t>(101, "offset");
-	MetaBlockPointer result(block_pointer, offset);
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_table_filter.cpp b/src/duckdb/src/storage/serialization/serialize_table_filter.cpp
deleted file mode 100644
index 24682aecb..000000000
--- a/src/duckdb/src/storage/serialization/serialize_table_filter.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/struct_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/planner/filter/in_filter.hpp"
-#include "duckdb/planner/filter/dynamic_filter.hpp"
-
-namespace duckdb {
-
-void TableFilter::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<TableFilterType>(100, "filter_type", filter_type);
-}
-
-unique_ptr<TableFilter> TableFilter::Deserialize(Deserializer &deserializer) {
-	auto filter_type = deserializer.ReadProperty<TableFilterType>(100, "filter_type");
-	unique_ptr<TableFilter> result;
-	switch (filter_type) {
-	case TableFilterType::CONJUNCTION_AND:
-		result = ConjunctionAndFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::CONJUNCTION_OR:
-		result = ConjunctionOrFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::CONSTANT_COMPARISON:
-		result = ConstantFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::DYNAMIC_FILTER:
-		result = DynamicFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::IN_FILTER:
-		result = InFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::IS_NOT_NULL:
-		result = IsNotNullFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::IS_NULL:
-		result = IsNullFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::OPTIONAL_FILTER:
-		result = OptionalFilter::Deserialize(deserializer);
-		break;
-	case TableFilterType::STRUCT_EXTRACT:
-		result = StructFilter::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of TableFilter!");
-	}
-	return result;
-}
-
-void ConjunctionAndFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<TableFilter>>>(200, "child_filters", child_filters);
-}
-
-unique_ptr<TableFilter> ConjunctionAndFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ConjunctionAndFilter>(new ConjunctionAndFilter());
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<TableFilter>>>(200, "child_filters", result->child_filters);
-	return std::move(result);
-}
-
-void ConjunctionOrFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<TableFilter>>>(200, "child_filters", child_filters);
-}
-
-unique_ptr<TableFilter> ConjunctionOrFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ConjunctionOrFilter>(new ConjunctionOrFilter());
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<TableFilter>>>(200, "child_filters", result->child_filters);
-	return std::move(result);
-}
-
-void ConstantFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-	serializer.WriteProperty<ExpressionType>(200, "comparison_type", comparison_type);
-	serializer.WriteProperty<Value>(201, "constant", constant);
-}
-
-unique_ptr<TableFilter> ConstantFilter::Deserialize(Deserializer &deserializer) {
-	auto comparison_type = deserializer.ReadProperty<ExpressionType>(200, "comparison_type");
-	auto constant = deserializer.ReadProperty<Value>(201, "constant");
-	auto result = duckdb::unique_ptr<ConstantFilter>(new ConstantFilter(comparison_type, constant));
-	return std::move(result);
-}
-
-void DynamicFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-}
-
-unique_ptr<TableFilter> DynamicFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<DynamicFilter>(new DynamicFilter());
-	return std::move(result);
-}
-
-void InFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<Value>>(200, "values", values);
-}
-
-unique_ptr<TableFilter> InFilter::Deserialize(Deserializer &deserializer) {
-	auto values = deserializer.ReadPropertyWithDefault<vector<Value>>(200, "values");
-	auto result = duckdb::unique_ptr<InFilter>(new InFilter(std::move(values)));
-	return std::move(result);
-}
-
-void IsNotNullFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-}
-
-unique_ptr<TableFilter> IsNotNullFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<IsNotNullFilter>(new IsNotNullFilter());
-	return std::move(result);
-}
-
-void IsNullFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-}
-
-unique_ptr<TableFilter> IsNullFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<IsNullFilter>(new IsNullFilter());
-	return std::move(result);
-}
-
-void OptionalFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<TableFilter>>(200, "child_filter", child_filter);
-}
-
-unique_ptr<TableFilter> OptionalFilter::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<OptionalFilter>(new OptionalFilter());
-	deserializer.ReadPropertyWithDefault<unique_ptr<TableFilter>>(200, "child_filter", result->child_filter);
-	return std::move(result);
-}
-
-void StructFilter::Serialize(Serializer &serializer) const {
-	TableFilter::Serialize(serializer);
-	serializer.WritePropertyWithDefault<idx_t>(200, "child_idx", child_idx);
-	serializer.WritePropertyWithDefault<string>(201, "child_name", child_name);
-	serializer.WritePropertyWithDefault<unique_ptr<TableFilter>>(202, "child_filter", child_filter);
-}
-
-unique_ptr<TableFilter> StructFilter::Deserialize(Deserializer &deserializer) {
-	auto child_idx = deserializer.ReadPropertyWithDefault<idx_t>(200, "child_idx");
-	auto child_name = deserializer.ReadPropertyWithDefault<string>(201, "child_name");
-	auto child_filter = deserializer.ReadPropertyWithDefault<unique_ptr<TableFilter>>(202, "child_filter");
-	auto result = duckdb::unique_ptr<StructFilter>(new StructFilter(child_idx, std::move(child_name), std::move(child_filter)));
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_tableref.cpp b/src/duckdb/src/storage/serialization/serialize_tableref.cpp
deleted file mode 100644
index 0283418fc..000000000
--- a/src/duckdb/src/storage/serialization/serialize_tableref.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/parser/tableref/list.hpp"
-
-namespace duckdb {
-
-void TableRef::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<TableReferenceType>(100, "type", type);
-	serializer.WritePropertyWithDefault<string>(101, "alias", alias);
-	serializer.WritePropertyWithDefault<unique_ptr<SampleOptions>>(102, "sample", sample);
-	serializer.WritePropertyWithDefault<optional_idx>(103, "query_location", query_location, optional_idx());
-}
-
-unique_ptr<TableRef> TableRef::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<TableReferenceType>(100, "type");
-	auto alias = deserializer.ReadPropertyWithDefault<string>(101, "alias");
-	auto sample = deserializer.ReadPropertyWithDefault<unique_ptr<SampleOptions>>(102, "sample");
-	auto query_location = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(103, "query_location", optional_idx());
-	unique_ptr<TableRef> result;
-	switch (type) {
-	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::COLUMN_DATA:
-		result = ColumnDataRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::EMPTY_FROM:
-		result = EmptyTableRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::PIVOT:
-		result = PivotRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::SHOW_REF:
-		result = ShowRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::Deserialize(deserializer);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of TableRef!");
-	}
-	result->alias = std::move(alias);
-	result->sample = std::move(sample);
-	result->query_location = query_location;
-	return result;
-}
-
-void BaseTableRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "schema_name", schema_name);
-	serializer.WritePropertyWithDefault<string>(201, "table_name", table_name);
-	serializer.WritePropertyWithDefault<vector<string>>(202, "column_name_alias", column_name_alias);
-	serializer.WritePropertyWithDefault<string>(203, "catalog_name", catalog_name);
-}
-
-unique_ptr<TableRef> BaseTableRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<BaseTableRef>(new BaseTableRef());
-	deserializer.ReadPropertyWithDefault<string>(200, "schema_name", result->schema_name);
-	deserializer.ReadPropertyWithDefault<string>(201, "table_name", result->table_name);
-	deserializer.ReadPropertyWithDefault<vector<string>>(202, "column_name_alias", result->column_name_alias);
-	deserializer.ReadPropertyWithDefault<string>(203, "catalog_name", result->catalog_name);
-	return std::move(result);
-}
-
-void ColumnDataRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<string>>(200, "expected_names", expected_names);
-	serializer.WritePropertyWithDefault<shared_ptr<ColumnDataCollection>>(202, "collection", collection);
-}
-
-unique_ptr<TableRef> ColumnDataRef::Deserialize(Deserializer &deserializer) {
-	auto expected_names = deserializer.ReadPropertyWithDefault<vector<string>>(200, "expected_names");
-	auto collection = deserializer.ReadPropertyWithDefault<shared_ptr<ColumnDataCollection>>(202, "collection");
-	auto result = duckdb::unique_ptr<ColumnDataRef>(new ColumnDataRef(std::move(collection), std::move(expected_names)));
-	return std::move(result);
-}
-
-void EmptyTableRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-}
-
-unique_ptr<TableRef> EmptyTableRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
-	return std::move(result);
-}
-
-void ExpressionListRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<vector<string>>(200, "expected_names", expected_names);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(201, "expected_types", expected_types);
-	serializer.WritePropertyWithDefault<vector<vector<unique_ptr<ParsedExpression>>>>(202, "values", values);
-}
-
-unique_ptr<TableRef> ExpressionListRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
-	deserializer.ReadPropertyWithDefault<vector<string>>(200, "expected_names", result->expected_names);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(201, "expected_types", result->expected_types);
-	deserializer.ReadPropertyWithDefault<vector<vector<unique_ptr<ParsedExpression>>>>(202, "values", result->values);
-	return std::move(result);
-}
-
-void JoinRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<TableRef>>(200, "left", left);
-	serializer.WritePropertyWithDefault<unique_ptr<TableRef>>(201, "right", right);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(202, "condition", condition);
-	serializer.WriteProperty<JoinType>(203, "join_type", type);
-	serializer.WriteProperty<JoinRefType>(204, "ref_type", ref_type);
-	serializer.WritePropertyWithDefault<vector<string>>(205, "using_columns", using_columns);
-	serializer.WritePropertyWithDefault<bool>(206, "delim_flipped", delim_flipped);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(207, "duplicate_eliminated_columns", duplicate_eliminated_columns);
-}
-
-unique_ptr<TableRef> JoinRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<JoinRef>(new JoinRef());
-	deserializer.ReadPropertyWithDefault<unique_ptr<TableRef>>(200, "left", result->left);
-	deserializer.ReadPropertyWithDefault<unique_ptr<TableRef>>(201, "right", result->right);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(202, "condition", result->condition);
-	deserializer.ReadProperty<JoinType>(203, "join_type", result->type);
-	deserializer.ReadProperty<JoinRefType>(204, "ref_type", result->ref_type);
-	deserializer.ReadPropertyWithDefault<vector<string>>(205, "using_columns", result->using_columns);
-	deserializer.ReadPropertyWithDefault<bool>(206, "delim_flipped", result->delim_flipped);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(207, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
-	return std::move(result);
-}
-
-void PivotRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<TableRef>>(200, "source", source);
-	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(201, "aggregates", aggregates);
-	serializer.WritePropertyWithDefault<vector<string>>(202, "unpivot_names", unpivot_names);
-	serializer.WritePropertyWithDefault<vector<PivotColumn>>(203, "pivots", pivots);
-	serializer.WritePropertyWithDefault<vector<string>>(204, "groups", groups);
-	serializer.WritePropertyWithDefault<vector<string>>(205, "column_name_alias", column_name_alias);
-	serializer.WritePropertyWithDefault<bool>(206, "include_nulls", include_nulls);
-}
-
-unique_ptr<TableRef> PivotRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
-	deserializer.ReadPropertyWithDefault<unique_ptr<TableRef>>(200, "source", result->source);
-	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(201, "aggregates", result->aggregates);
-	deserializer.ReadPropertyWithDefault<vector<string>>(202, "unpivot_names", result->unpivot_names);
-	deserializer.ReadPropertyWithDefault<vector<PivotColumn>>(203, "pivots", result->pivots);
-	deserializer.ReadPropertyWithDefault<vector<string>>(204, "groups", result->groups);
-	deserializer.ReadPropertyWithDefault<vector<string>>(205, "column_name_alias", result->column_name_alias);
-	deserializer.ReadPropertyWithDefault<bool>(206, "include_nulls", result->include_nulls);
-	return std::move(result);
-}
-
-void ShowRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "table_name", table_name);
-	serializer.WritePropertyWithDefault<unique_ptr<QueryNode>>(201, "query", query);
-	serializer.WriteProperty<ShowType>(202, "show_type", show_type);
-}
-
-unique_ptr<TableRef> ShowRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ShowRef>(new ShowRef());
-	deserializer.ReadPropertyWithDefault<string>(200, "table_name", result->table_name);
-	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(201, "query", result->query);
-	deserializer.ReadProperty<ShowType>(202, "show_type", result->show_type);
-	return std::move(result);
-}
-
-void SubqueryRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<SelectStatement>>(200, "subquery", subquery);
-	serializer.WritePropertyWithDefault<vector<string>>(201, "column_name_alias", column_name_alias);
-}
-
-unique_ptr<TableRef> SubqueryRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<SubqueryRef>(new SubqueryRef());
-	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(200, "subquery", result->subquery);
-	deserializer.ReadPropertyWithDefault<vector<string>>(201, "column_name_alias", result->column_name_alias);
-	return std::move(result);
-}
-
-void TableFunctionRef::Serialize(Serializer &serializer) const {
-	TableRef::Serialize(serializer);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(200, "function", function);
-	serializer.WritePropertyWithDefault<vector<string>>(201, "column_name_alias", column_name_alias);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<TableFunctionRef>(new TableFunctionRef());
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(200, "function", result->function);
-	deserializer.ReadPropertyWithDefault<vector<string>>(201, "column_name_alias", result->column_name_alias);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/serialization/serialize_types.cpp b/src/duckdb/src/storage/serialization/serialize_types.cpp
deleted file mode 100644
index 6f5e811ef..000000000
--- a/src/duckdb/src/storage/serialization/serialize_types.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-//===----------------------------------------------------------------------===//
-// This file is automatically generated by scripts/generate_serialization.py
-// Do not edit this file manually, your changes will be overwritten
-//===----------------------------------------------------------------------===//
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/extension_type_info.hpp"
-#include "duckdb/common/extra_type_info.hpp"
-
-namespace duckdb {
-
-void ExtraTypeInfo::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<ExtraTypeInfoType>(100, "type", type);
-	serializer.WritePropertyWithDefault<string>(101, "alias", alias);
-	/* [Deleted] (vector<Value>) "modifiers" */
-	serializer.WritePropertyWithDefault<unique_ptr<ExtensionTypeInfo>>(103, "extension_info", extension_info);
-}
-
-shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ExtraTypeInfoType>(100, "type");
-	auto alias = deserializer.ReadPropertyWithDefault<string>(101, "alias");
-	deserializer.ReadDeletedProperty<vector<Value>>(102, "modifiers");
-	auto extension_info = deserializer.ReadPropertyWithDefault<unique_ptr<ExtensionTypeInfo>>(103, "extension_info");
-	shared_ptr<ExtraTypeInfo> result;
-	switch (type) {
-	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
-		result = AggregateStateTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::ANY_TYPE_INFO:
-		result = AnyTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::ARRAY_TYPE_INFO:
-		result = ArrayTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::DECIMAL_TYPE_INFO:
-		result = DecimalTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::ENUM_TYPE_INFO:
-		result = EnumTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::GENERIC_TYPE_INFO:
-		result = make_shared_ptr<ExtraTypeInfo>(type);
-		break;
-	case ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO:
-		result = IntegerLiteralTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::INVALID_TYPE_INFO:
-		return nullptr;
-	case ExtraTypeInfoType::LIST_TYPE_INFO:
-		result = ListTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::STRING_TYPE_INFO:
-		result = StringTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::STRUCT_TYPE_INFO:
-		result = StructTypeInfo::Deserialize(deserializer);
-		break;
-	case ExtraTypeInfoType::USER_TYPE_INFO:
-		result = UserTypeInfo::Deserialize(deserializer);
-		break;
-	default:
-		throw SerializationException("Unsupported type for deserialization of ExtraTypeInfo!");
-	}
-	result->alias = std::move(alias);
-	result->extension_info = std::move(extension_info);
-	return result;
-}
-
-void AggregateStateTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "function_name", state_type.function_name);
-	serializer.WriteProperty<LogicalType>(201, "return_type", state_type.return_type);
-	serializer.WritePropertyWithDefault<vector<LogicalType>>(202, "bound_argument_types", state_type.bound_argument_types);
-}
-
-shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "function_name", result->state_type.function_name);
-	deserializer.ReadProperty<LogicalType>(201, "return_type", result->state_type.return_type);
-	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(202, "bound_argument_types", result->state_type.bound_argument_types);
-	return std::move(result);
-}
-
-void AnyTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "target_type", target_type);
-	serializer.WritePropertyWithDefault<idx_t>(201, "cast_score", cast_score);
-}
-
-shared_ptr<ExtraTypeInfo> AnyTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<AnyTypeInfo>(new AnyTypeInfo());
-	deserializer.ReadProperty<LogicalType>(200, "target_type", result->target_type);
-	deserializer.ReadPropertyWithDefault<idx_t>(201, "cast_score", result->cast_score);
-	return std::move(result);
-}
-
-void ArrayTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "child_type", child_type);
-	serializer.WritePropertyWithDefault<uint32_t>(201, "size", size);
-}
-
-shared_ptr<ExtraTypeInfo> ArrayTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto child_type = deserializer.ReadProperty<LogicalType>(200, "child_type");
-	auto size = deserializer.ReadPropertyWithDefault<uint32_t>(201, "size");
-	auto result = duckdb::shared_ptr<ArrayTypeInfo>(new ArrayTypeInfo(std::move(child_type), size));
-	return std::move(result);
-}
-
-void DecimalTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<uint8_t>(200, "width", width);
-	serializer.WritePropertyWithDefault<uint8_t>(201, "scale", scale);
-}
-
-shared_ptr<ExtraTypeInfo> DecimalTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<DecimalTypeInfo>(new DecimalTypeInfo());
-	deserializer.ReadPropertyWithDefault<uint8_t>(200, "width", result->width);
-	deserializer.ReadPropertyWithDefault<uint8_t>(201, "scale", result->scale);
-	return std::move(result);
-}
-
-void ExtensionTypeInfo::Serialize(Serializer &serializer) const {
-	serializer.WritePropertyWithDefault<vector<LogicalTypeModifier>>(100, "modifiers", modifiers);
-	serializer.WritePropertyWithDefault<unordered_map<string, Value>>(101, "properties", properties, unordered_map<string, Value>());
-}
-
-unique_ptr<ExtensionTypeInfo> ExtensionTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ExtensionTypeInfo>(new ExtensionTypeInfo());
-	deserializer.ReadPropertyWithDefault<vector<LogicalTypeModifier>>(100, "modifiers", result->modifiers);
-	deserializer.ReadPropertyWithExplicitDefault<unordered_map<string, Value>>(101, "properties", result->properties, unordered_map<string, Value>());
-	return result;
-}
-
-void IntegerLiteralTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WriteProperty<Value>(200, "constant_value", constant_value);
-}
-
-shared_ptr<ExtraTypeInfo> IntegerLiteralTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<IntegerLiteralTypeInfo>(new IntegerLiteralTypeInfo());
-	deserializer.ReadProperty<Value>(200, "constant_value", result->constant_value);
-	return std::move(result);
-}
-
-void ListTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WriteProperty<LogicalType>(200, "child_type", child_type);
-}
-
-shared_ptr<ExtraTypeInfo> ListTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<ListTypeInfo>(new ListTypeInfo());
-	deserializer.ReadProperty<LogicalType>(200, "child_type", result->child_type);
-	return std::move(result);
-}
-
-void LogicalTypeModifier::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty<Value>(100, "value", value);
-	serializer.WritePropertyWithDefault<string>(101, "label", label);
-}
-
-LogicalTypeModifier LogicalTypeModifier::Deserialize(Deserializer &deserializer) {
-	auto value = deserializer.ReadProperty<Value>(100, "value");
-	LogicalTypeModifier result(value);
-	deserializer.ReadPropertyWithDefault<string>(101, "label", result.label);
-	return result;
-}
-
-void StringTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "collation", collation);
-}
-
-shared_ptr<ExtraTypeInfo> StringTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "collation", result->collation);
-	return std::move(result);
-}
-
-void StructTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<child_list_t<LogicalType>>(200, "child_types", child_types);
-}
-
-shared_ptr<ExtraTypeInfo> StructTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
-	deserializer.ReadPropertyWithDefault<child_list_t<LogicalType>>(200, "child_types", result->child_types);
-	return std::move(result);
-}
-
-void UserTypeInfo::Serialize(Serializer &serializer) const {
-	ExtraTypeInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(200, "user_type_name", user_type_name);
-	serializer.WritePropertyWithDefault<string>(201, "catalog", catalog, string());
-	serializer.WritePropertyWithDefault<string>(202, "schema", schema, string());
-	serializer.WritePropertyWithDefault<vector<Value>>(203, "user_type_modifiers", user_type_modifiers);
-}
-
-shared_ptr<ExtraTypeInfo> UserTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::shared_ptr<UserTypeInfo>(new UserTypeInfo());
-	deserializer.ReadPropertyWithDefault<string>(200, "user_type_name", result->user_type_name);
-	deserializer.ReadPropertyWithExplicitDefault<string>(201, "catalog", result->catalog, string());
-	deserializer.ReadPropertyWithExplicitDefault<string>(202, "schema", result->schema, string());
-	deserializer.ReadPropertyWithDefault<vector<Value>>(203, "user_type_modifiers", result->user_type_modifiers);
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/single_file_block_manager.cpp b/src/duckdb/src/storage/single_file_block_manager.cpp
deleted file mode 100644
index 2b63fa247..000000000
--- a/src/duckdb/src/storage/single_file_block_manager.cpp
+++ /dev/null
@@ -1,717 +0,0 @@
-#include "duckdb/storage/single_file_block_manager.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
-
-#include <algorithm>
-#include <cstring>
-
-namespace duckdb {
-
-const char MainHeader::MAGIC_BYTES[] = "DUCK";
-
-void SerializeVersionNumber(WriteStream &ser, const string &version_str) {
-	data_t version[MainHeader::MAX_VERSION_SIZE];
-	memset(version, 0, MainHeader::MAX_VERSION_SIZE);
-	memcpy(version, version_str.c_str(), MinValue<idx_t>(version_str.size(), MainHeader::MAX_VERSION_SIZE));
-	ser.WriteData(version, MainHeader::MAX_VERSION_SIZE);
-}
-
-void DeserializeVersionNumber(ReadStream &stream, data_t *dest) {
-	memset(dest, 0, MainHeader::MAX_VERSION_SIZE);
-	stream.ReadData(dest, MainHeader::MAX_VERSION_SIZE);
-}
-
-void MainHeader::Write(WriteStream &ser) {
-	ser.WriteData(const_data_ptr_cast(MAGIC_BYTES), MAGIC_BYTE_SIZE);
-	ser.Write<uint64_t>(version_number);
-	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		ser.Write<uint64_t>(flags[i]);
-	}
-	SerializeVersionNumber(ser, DuckDB::LibraryVersion());
-	SerializeVersionNumber(ser, DuckDB::SourceID());
-}
-
-void MainHeader::CheckMagicBytes(FileHandle &handle) {
-	data_t magic_bytes[MAGIC_BYTE_SIZE];
-	if (handle.GetFileSize() < MainHeader::MAGIC_BYTE_SIZE + MainHeader::MAGIC_BYTE_OFFSET) {
-		throw IOException("The file \"%s\" exists, but it is not a valid DuckDB database file!", handle.path);
-	}
-	handle.Read(magic_bytes, MainHeader::MAGIC_BYTE_SIZE, MainHeader::MAGIC_BYTE_OFFSET);
-	if (memcmp(magic_bytes, MainHeader::MAGIC_BYTES, MainHeader::MAGIC_BYTE_SIZE) != 0) {
-		throw IOException("The file \"%s\" exists, but it is not a valid DuckDB database file!", handle.path);
-	}
-}
-
-MainHeader MainHeader::Read(ReadStream &source) {
-	data_t magic_bytes[MAGIC_BYTE_SIZE];
-	MainHeader header;
-	source.ReadData(magic_bytes, MainHeader::MAGIC_BYTE_SIZE);
-	if (memcmp(magic_bytes, MainHeader::MAGIC_BYTES, MainHeader::MAGIC_BYTE_SIZE) != 0) {
-		throw IOException("The file is not a valid DuckDB database file!");
-	}
-	header.version_number = source.Read<uint64_t>();
-	// check the version number
-	if (header.version_number != VERSION_NUMBER) {
-		auto version = GetDuckDBVersion(header.version_number);
-		string version_text;
-		if (!version.empty()) {
-			// known version
-			version_text = "DuckDB version " + string(version);
-		} else {
-			version_text = string("an ") + (VERSION_NUMBER > header.version_number ? "older development" : "newer") +
-			               string(" version of DuckDB");
-		}
-		throw IOException(
-		    "Trying to read a database file with version number %lld, but we can only read version %lld.\n"
-		    "The database file was created with %s.\n\n"
-		    "The storage of DuckDB is not yet stable; newer versions of DuckDB cannot read old database files and "
-		    "vice versa.\n"
-		    "The storage will be stabilized when version 1.0 releases.\n\n"
-		    "For now, we recommend that you load the database file in a supported version of DuckDB, and use the "
-		    "EXPORT DATABASE command "
-		    "followed by IMPORT DATABASE on the current version of DuckDB.\n\n"
-		    "See the storage page for more information: https://duckdb.org/internals/storage",
-		    header.version_number, VERSION_NUMBER, version_text);
-	}
-	// read the flags
-	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		header.flags[i] = source.Read<uint64_t>();
-	}
-	DeserializeVersionNumber(source, header.library_git_desc);
-	DeserializeVersionNumber(source, header.library_git_hash);
-	return header;
-}
-
-void DatabaseHeader::Write(WriteStream &ser) {
-	ser.Write<uint64_t>(iteration);
-	ser.Write<idx_t>(meta_block);
-	ser.Write<idx_t>(free_list);
-	ser.Write<uint64_t>(block_count);
-	ser.Write<idx_t>(block_alloc_size);
-	ser.Write<idx_t>(vector_size);
-}
-
-DatabaseHeader DatabaseHeader::Read(ReadStream &source) {
-	DatabaseHeader header;
-	header.iteration = source.Read<uint64_t>();
-	header.meta_block = source.Read<idx_t>();
-	header.free_list = source.Read<idx_t>();
-	header.block_count = source.Read<uint64_t>();
-
-	header.block_alloc_size = source.Read<idx_t>();
-
-	// backwards compatibility
-	if (!header.block_alloc_size) {
-		header.block_alloc_size = DEFAULT_BLOCK_ALLOC_SIZE;
-	}
-
-	header.vector_size = source.Read<idx_t>();
-	if (!header.vector_size) {
-		// backwards compatibility
-		header.vector_size = DEFAULT_STANDARD_VECTOR_SIZE;
-	}
-	if (header.vector_size != STANDARD_VECTOR_SIZE) {
-		throw IOException("Cannot read database file: DuckDB's compiled vector size is %llu bytes, but the file has a "
-		                  "vector size of %llu bytes.",
-		                  STANDARD_VECTOR_SIZE, header.vector_size);
-	}
-
-	return header;
-}
-
-template <class T>
-void SerializeHeaderStructure(T header, data_ptr_t ptr) {
-	MemoryStream ser(ptr, Storage::FILE_HEADER_SIZE);
-	header.Write(ser);
-}
-
-template <class T>
-T DeserializeHeaderStructure(data_ptr_t ptr) {
-	MemoryStream source(ptr, Storage::FILE_HEADER_SIZE);
-	return T::Read(source);
-}
-
-SingleFileBlockManager::SingleFileBlockManager(AttachedDatabase &db, const string &path_p,
-                                               const StorageManagerOptions &options)
-    : BlockManager(BufferManager::GetBufferManager(db), options.block_alloc_size), db(db), path(path_p),
-      header_buffer(Allocator::Get(db), FileBufferType::MANAGED_BUFFER,
-                    Storage::FILE_HEADER_SIZE - Storage::DEFAULT_BLOCK_HEADER_SIZE),
-      iteration_count(0), options(options) {
-}
-
-FileOpenFlags SingleFileBlockManager::GetFileFlags(bool create_new) const {
-	FileOpenFlags result;
-	if (options.read_only) {
-		D_ASSERT(!create_new);
-		result = FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS | FileLockType::READ_LOCK;
-	} else {
-		result = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_READ | FileLockType::WRITE_LOCK;
-		if (create_new) {
-			result |= FileFlags::FILE_FLAGS_FILE_CREATE;
-		}
-	}
-	if (options.use_direct_io) {
-		result |= FileFlags::FILE_FLAGS_DIRECT_IO;
-	}
-	// database files can be read from in parallel
-	result |= FileFlags::FILE_FLAGS_PARALLEL_ACCESS;
-	return result;
-}
-
-void SingleFileBlockManager::CreateNewDatabase() {
-	auto flags = GetFileFlags(true);
-
-	// open the RDBMS handle
-	auto &fs = FileSystem::Get(db);
-	handle = fs.OpenFile(path, flags);
-
-	// if we create a new file, we fill the metadata of the file
-	// first fill in the new header
-	header_buffer.Clear();
-
-	MainHeader main_header;
-	main_header.version_number = VERSION_NUMBER;
-	memset(main_header.flags, 0, sizeof(uint64_t) * MainHeader::FLAG_COUNT);
-
-	SerializeHeaderStructure<MainHeader>(main_header, header_buffer.buffer);
-	// now write the header to the file
-	ChecksumAndWrite(header_buffer, 0);
-	header_buffer.Clear();
-
-	// write the database headers
-	// initialize meta_block and free_list to INVALID_BLOCK because the database file does not contain any actual
-	// content yet
-	DatabaseHeader h1;
-	// header 1
-	h1.iteration = 0;
-	h1.meta_block = idx_t(INVALID_BLOCK);
-	h1.free_list = idx_t(INVALID_BLOCK);
-	h1.block_count = 0;
-	// We create the SingleFileBlockManager with the desired block allocation size before calling CreateNewDatabase.
-	h1.block_alloc_size = GetBlockAllocSize();
-	h1.vector_size = STANDARD_VECTOR_SIZE;
-	SerializeHeaderStructure<DatabaseHeader>(h1, header_buffer.buffer);
-	ChecksumAndWrite(header_buffer, Storage::FILE_HEADER_SIZE);
-
-	// header 2
-	DatabaseHeader h2;
-	h2.iteration = 0;
-	h2.meta_block = idx_t(INVALID_BLOCK);
-	h2.free_list = idx_t(INVALID_BLOCK);
-	h2.block_count = 0;
-	// We create the SingleFileBlockManager with the desired block allocation size before calling CreateNewDatabase.
-	h2.block_alloc_size = GetBlockAllocSize();
-	h2.vector_size = STANDARD_VECTOR_SIZE;
-	SerializeHeaderStructure<DatabaseHeader>(h2, header_buffer.buffer);
-	ChecksumAndWrite(header_buffer, Storage::FILE_HEADER_SIZE * 2ULL);
-
-	// ensure that writing to disk is completed before returning
-	handle->Sync();
-	// we start with h2 as active_header, this way our initial write will be in h1
-	iteration_count = 0;
-	active_header = 1;
-	max_block = 0;
-}
-
-void SingleFileBlockManager::LoadExistingDatabase() {
-	auto flags = GetFileFlags(false);
-
-	// open the RDBMS handle
-	auto &fs = FileSystem::Get(db);
-	handle = fs.OpenFile(path, flags);
-	if (!handle) {
-		// this can only happen in read-only mode - as that is when we set FILE_FLAGS_NULL_IF_NOT_EXISTS
-		throw IOException("Cannot open database \"%s\" in read-only mode: database does not exist", path);
-	}
-
-	MainHeader::CheckMagicBytes(*handle);
-	// otherwise, we check the metadata of the file
-	ReadAndChecksum(header_buffer, 0);
-	DeserializeHeaderStructure<MainHeader>(header_buffer.buffer);
-
-	// read the database headers from disk
-	DatabaseHeader h1;
-	ReadAndChecksum(header_buffer, Storage::FILE_HEADER_SIZE);
-	h1 = DeserializeHeaderStructure<DatabaseHeader>(header_buffer.buffer);
-
-	DatabaseHeader h2;
-	ReadAndChecksum(header_buffer, Storage::FILE_HEADER_SIZE * 2ULL);
-	h2 = DeserializeHeaderStructure<DatabaseHeader>(header_buffer.buffer);
-
-	// check the header with the highest iteration count
-	if (h1.iteration > h2.iteration) {
-		// h1 is active header
-		active_header = 0;
-		Initialize(h1, GetOptionalBlockAllocSize());
-	} else {
-		// h2 is active header
-		active_header = 1;
-		Initialize(h2, GetOptionalBlockAllocSize());
-	}
-	LoadFreeList();
-}
-
-void SingleFileBlockManager::ReadAndChecksum(FileBuffer &block, uint64_t location) const {
-	// read the buffer from disk
-	block.Read(*handle, location);
-
-	// compute the checksum
-	auto stored_checksum = Load<uint64_t>(block.InternalBuffer());
-	auto computed_checksum = Checksum(block.buffer, block.Size());
-
-	// verify the checksum
-	if (stored_checksum != computed_checksum) {
-		throw IOException("Corrupt database file: computed checksum %llu does not match stored checksum %llu in block "
-		                  "at location %llu",
-		                  computed_checksum, stored_checksum, location);
-	}
-}
-
-void SingleFileBlockManager::ChecksumAndWrite(FileBuffer &block, uint64_t location) const {
-	// compute the checksum and write it to the start of the buffer (if not temp buffer)
-	uint64_t checksum = Checksum(block.buffer, block.Size());
-	Store<uint64_t>(checksum, block.InternalBuffer());
-	// now write the buffer
-	block.Write(*handle, location);
-}
-
-void SingleFileBlockManager::Initialize(const DatabaseHeader &header, const optional_idx block_alloc_size) {
-	free_list_id = header.free_list;
-	meta_block = header.meta_block;
-	iteration_count = header.iteration;
-	max_block = NumericCast<block_id_t>(header.block_count);
-
-	if (block_alloc_size.IsValid() && block_alloc_size.GetIndex() != header.block_alloc_size) {
-		throw InvalidInputException("cannot initialize the same database with a different block size: provided block "
-		                            "size: %llu, file block size: %llu",
-		                            GetBlockAllocSize(), header.block_alloc_size);
-	}
-	SetBlockAllocSize(header.block_alloc_size);
-}
-
-void SingleFileBlockManager::LoadFreeList() {
-	MetaBlockPointer free_pointer(free_list_id, 0);
-	if (!free_pointer.IsValid()) {
-		// no free list
-		return;
-	}
-	MetadataReader reader(GetMetadataManager(), free_pointer, nullptr, BlockReaderType::REGISTER_BLOCKS);
-	auto free_list_count = reader.Read<uint64_t>();
-	free_list.clear();
-	for (idx_t i = 0; i < free_list_count; i++) {
-		auto block = reader.Read<block_id_t>();
-		free_list.insert(block);
-		newly_freed_list.insert(block);
-	}
-	auto multi_use_blocks_count = reader.Read<uint64_t>();
-	multi_use_blocks.clear();
-	for (idx_t i = 0; i < multi_use_blocks_count; i++) {
-		auto block_id = reader.Read<block_id_t>();
-		auto usage_count = reader.Read<uint32_t>();
-		multi_use_blocks[block_id] = usage_count;
-	}
-	GetMetadataManager().Read(reader);
-	GetMetadataManager().MarkBlocksAsModified();
-}
-
-bool SingleFileBlockManager::IsRootBlock(MetaBlockPointer root) {
-	return root.block_pointer == meta_block;
-}
-
-block_id_t SingleFileBlockManager::GetFreeBlockId() {
-	lock_guard<mutex> lock(block_lock);
-	block_id_t block;
-	if (!free_list.empty()) {
-		// The free list is not empty, so we take its first element.
-		block = *free_list.begin();
-		// erase the entry from the free list again
-		free_list.erase(free_list.begin());
-		newly_freed_list.erase(block);
-	} else {
-		block = max_block++;
-	}
-	return block;
-}
-
-block_id_t SingleFileBlockManager::PeekFreeBlockId() {
-	lock_guard<mutex> lock(block_lock);
-	if (!free_list.empty()) {
-		return *free_list.begin();
-	} else {
-		return max_block;
-	}
-}
-
-void SingleFileBlockManager::MarkBlockAsFree(block_id_t block_id) {
-	lock_guard<mutex> lock(block_lock);
-	D_ASSERT(block_id >= 0);
-	D_ASSERT(block_id < max_block);
-	if (free_list.find(block_id) != free_list.end()) {
-		throw InternalException("MarkBlockAsFree called but block %llu was already freed!", block_id);
-	}
-	multi_use_blocks.erase(block_id);
-	free_list.insert(block_id);
-	newly_freed_list.insert(block_id);
-}
-
-void SingleFileBlockManager::MarkBlockAsUsed(block_id_t block_id) {
-	lock_guard<mutex> lock(block_lock);
-	D_ASSERT(block_id >= 0);
-	if (max_block <= block_id) {
-		// the block is past the current max_block
-		// in this case we need to increment  "max_block" to "block_id"
-		// any blocks in the middle are added to the free list
-		// i.e. if max_block = 0, and block_id = 3, we need to add blocks 1 and 2 to the free list
-		while (max_block < block_id) {
-			free_list.insert(max_block);
-			max_block++;
-		}
-		max_block++;
-	} else if (free_list.find(block_id) != free_list.end()) {
-		// block is currently in the free list - erase
-		free_list.erase(block_id);
-		newly_freed_list.erase(block_id);
-	} else {
-		// block is already in use - increase reference count
-		IncreaseBlockReferenceCountInternal(block_id);
-	}
-}
-
-void SingleFileBlockManager::MarkBlockAsModified(block_id_t block_id) {
-	lock_guard<mutex> lock(block_lock);
-	D_ASSERT(block_id >= 0);
-	D_ASSERT(block_id < max_block);
-
-	// check if the block is a multi-use block
-	auto entry = multi_use_blocks.find(block_id);
-	if (entry != multi_use_blocks.end()) {
-		// it is! reduce the reference count of the block
-		entry->second--;
-		// check the reference count: is the block still a multi-use block?
-		if (entry->second <= 1) {
-			// no longer a multi-use block!
-			multi_use_blocks.erase(entry);
-		}
-		return;
-	}
-	// Check for multi-free
-	// TODO: Fix the bug that causes this assert to fire, then uncomment it.
-	// D_ASSERT(modified_blocks.find(block_id) == modified_blocks.end());
-	D_ASSERT(free_list.find(block_id) == free_list.end());
-	modified_blocks.insert(block_id);
-}
-
-void SingleFileBlockManager::IncreaseBlockReferenceCountInternal(block_id_t block_id) {
-	D_ASSERT(block_id >= 0);
-	D_ASSERT(block_id < max_block);
-	D_ASSERT(free_list.find(block_id) == free_list.end());
-	auto entry = multi_use_blocks.find(block_id);
-	if (entry != multi_use_blocks.end()) {
-		entry->second++;
-	} else {
-		multi_use_blocks[block_id] = 2;
-	}
-}
-
-void SingleFileBlockManager::VerifyBlocks(const unordered_map<block_id_t, idx_t> &block_usage_count) {
-	// probably don't need this?
-	lock_guard<mutex> lock(block_lock);
-	// all blocks should be accounted for - either in the block_usage_count, or in the free list
-	set<block_id_t> referenced_blocks;
-	for (auto &block : block_usage_count) {
-		if (block.first == INVALID_BLOCK) {
-			continue;
-		}
-		if (block.first >= max_block) {
-			throw InternalException("Block %lld is used, but it is bigger than the max block %d", block.first,
-			                        max_block);
-		}
-		referenced_blocks.insert(block.first);
-		if (block.second > 1) {
-			// multi-use block
-			auto entry = multi_use_blocks.find(block.first);
-			if (entry == multi_use_blocks.end()) {
-				throw InternalException("Block %lld was used %llu times, but not present in multi_use_blocks",
-				                        block.first, block.second);
-			}
-			if (entry->second != block.second) {
-				throw InternalException(
-				    "Block %lld was used %llu times, but multi_use_blocks says it is used %llu times", block.first,
-				    block.second, entry->second);
-			}
-		} else {
-			D_ASSERT(block.second > 0);
-			auto entry = free_list.find(block.first);
-			if (entry != free_list.end()) {
-				throw InternalException("Block %lld was used, but it is present in the free list", block.first);
-			}
-		}
-	}
-	for (auto &free_block : free_list) {
-		referenced_blocks.insert(free_block);
-	}
-	if (referenced_blocks.size() != NumericCast<idx_t>(max_block)) {
-		// not all blocks are accounted for
-		string missing_blocks;
-		for (block_id_t i = 0; i < max_block; i++) {
-			if (referenced_blocks.find(i) == referenced_blocks.end()) {
-				if (!missing_blocks.empty()) {
-					missing_blocks += ", ";
-				}
-				missing_blocks += to_string(i);
-			}
-		}
-		throw InternalException(
-		    "Blocks %s were neither present in the free list or in the block_usage_count (max block %lld)",
-		    missing_blocks, max_block);
-	}
-}
-
-void SingleFileBlockManager::IncreaseBlockReferenceCount(block_id_t block_id) {
-	lock_guard<mutex> lock(block_lock);
-	IncreaseBlockReferenceCountInternal(block_id);
-}
-
-idx_t SingleFileBlockManager::GetMetaBlock() {
-	return meta_block;
-}
-
-idx_t SingleFileBlockManager::TotalBlocks() {
-	lock_guard<mutex> lock(block_lock);
-	return NumericCast<idx_t>(max_block);
-}
-
-idx_t SingleFileBlockManager::FreeBlocks() {
-	lock_guard<mutex> lock(block_lock);
-	return free_list.size();
-}
-
-bool SingleFileBlockManager::IsRemote() {
-	return !handle->OnDiskFile();
-}
-
-unique_ptr<Block> SingleFileBlockManager::ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) {
-	D_ASSERT(source_buffer.AllocSize() == GetBlockAllocSize());
-	return make_uniq<Block>(source_buffer, block_id);
-}
-
-unique_ptr<Block> SingleFileBlockManager::CreateBlock(block_id_t block_id, FileBuffer *source_buffer) {
-	unique_ptr<Block> result;
-	if (source_buffer) {
-		result = ConvertBlock(block_id, *source_buffer);
-	} else {
-		result = make_uniq<Block>(Allocator::Get(db), block_id, GetBlockSize());
-	}
-	result->Initialize(options.debug_initialize);
-	return result;
-}
-
-idx_t SingleFileBlockManager::GetBlockLocation(block_id_t block_id) {
-	return BLOCK_START + NumericCast<idx_t>(block_id) * GetBlockAllocSize();
-}
-
-void SingleFileBlockManager::Read(Block &block) {
-	D_ASSERT(block.id >= 0);
-	D_ASSERT(std::find(free_list.begin(), free_list.end(), block.id) == free_list.end());
-	ReadAndChecksum(block, GetBlockLocation(block.id));
-}
-
-void SingleFileBlockManager::ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) {
-	D_ASSERT(start_block >= 0);
-	D_ASSERT(block_count >= 1);
-
-	// read the buffer from disk
-	auto location = GetBlockLocation(start_block);
-	buffer.Read(*handle, location);
-
-	// for each of the blocks - verify the checksum
-	auto ptr = buffer.InternalBuffer();
-	for (idx_t i = 0; i < block_count; i++) {
-		// compute the checksum
-		auto start_ptr = ptr + i * GetBlockAllocSize();
-		auto stored_checksum = Load<uint64_t>(start_ptr);
-		uint64_t computed_checksum = Checksum(start_ptr + Storage::DEFAULT_BLOCK_HEADER_SIZE, GetBlockSize());
-		// verify the checksum
-		if (stored_checksum != computed_checksum) {
-			throw IOException(
-			    "Corrupt database file: computed checksum %llu does not match stored checksum %llu in block "
-			    "at location %llu",
-			    computed_checksum, stored_checksum, location + i * GetBlockAllocSize());
-		}
-	}
-}
-
-void SingleFileBlockManager::Write(FileBuffer &buffer, block_id_t block_id) {
-	D_ASSERT(block_id >= 0);
-	ChecksumAndWrite(buffer, BLOCK_START + NumericCast<idx_t>(block_id) * GetBlockAllocSize());
-}
-
-void SingleFileBlockManager::Truncate() {
-	BlockManager::Truncate();
-	idx_t blocks_to_truncate = 0;
-	// reverse iterate over the free-list
-	for (auto entry = free_list.rbegin(); entry != free_list.rend(); entry++) {
-		auto block_id = *entry;
-		if (block_id + 1 != max_block) {
-			break;
-		}
-		blocks_to_truncate++;
-		max_block--;
-	}
-	if (blocks_to_truncate == 0) {
-		// nothing to truncate
-		return;
-	}
-	// truncate the file
-	free_list.erase(free_list.lower_bound(max_block), free_list.end());
-	newly_freed_list.erase(newly_freed_list.lower_bound(max_block), newly_freed_list.end());
-	handle->Truncate(NumericCast<int64_t>(BLOCK_START + NumericCast<idx_t>(max_block) * GetBlockAllocSize()));
-}
-
-vector<MetadataHandle> SingleFileBlockManager::GetFreeListBlocks() {
-	vector<MetadataHandle> free_list_blocks;
-	auto &metadata_manager = GetMetadataManager();
-
-	// reserve all blocks that we are going to write the free list to
-	// since these blocks are no longer free we cannot just include them in the free list!
-	auto block_size = metadata_manager.GetMetadataBlockSize() - sizeof(idx_t);
-	idx_t allocated_size = 0;
-	while (true) {
-		auto free_list_size = sizeof(uint64_t) + sizeof(block_id_t) * (free_list.size() + modified_blocks.size());
-		auto multi_use_blocks_size =
-		    sizeof(uint64_t) + (sizeof(block_id_t) + sizeof(uint32_t)) * multi_use_blocks.size();
-		auto metadata_blocks =
-		    sizeof(uint64_t) + (sizeof(block_id_t) + sizeof(idx_t)) * GetMetadataManager().BlockCount();
-		auto total_size = free_list_size + multi_use_blocks_size + metadata_blocks;
-		if (total_size < allocated_size) {
-			break;
-		}
-		auto free_list_handle = GetMetadataManager().AllocateHandle();
-		free_list_blocks.push_back(std::move(free_list_handle));
-		allocated_size += block_size;
-	}
-
-	return free_list_blocks;
-}
-
-class FreeListBlockWriter : public MetadataWriter {
-public:
-	FreeListBlockWriter(MetadataManager &manager, vector<MetadataHandle> free_list_blocks_p)
-	    : MetadataWriter(manager), free_list_blocks(std::move(free_list_blocks_p)), index(0) {
-	}
-
-	vector<MetadataHandle> free_list_blocks;
-	idx_t index;
-
-protected:
-	MetadataHandle NextHandle() override {
-		if (index >= free_list_blocks.size()) {
-			throw InternalException(
-			    "Free List Block Writer ran out of blocks, this means not enough blocks were allocated up front");
-		}
-		return std::move(free_list_blocks[index++]);
-	}
-};
-
-void SingleFileBlockManager::WriteHeader(DatabaseHeader header) {
-	auto free_list_blocks = GetFreeListBlocks();
-
-	// now handle the free list
-	auto &metadata_manager = GetMetadataManager();
-	// add all modified blocks to the free list: they can now be written to again
-	metadata_manager.MarkBlocksAsModified();
-
-	lock_guard<mutex> lock(block_lock);
-	// set the iteration count
-	header.iteration = ++iteration_count;
-
-	for (auto &block : modified_blocks) {
-		free_list.insert(block);
-		newly_freed_list.insert(block);
-	}
-	modified_blocks.clear();
-
-	if (!free_list_blocks.empty()) {
-		// there are blocks to write, either in the free_list or in the modified_blocks
-		// we write these blocks specifically to the free_list_blocks
-		// a normal MetadataWriter will fetch blocks to use from the free_list
-		// but since we are WRITING the free_list, this behavior is sub-optimal
-		FreeListBlockWriter writer(metadata_manager, std::move(free_list_blocks));
-
-		auto ptr = writer.GetMetaBlockPointer();
-		header.free_list = ptr.block_pointer;
-
-		writer.Write<uint64_t>(free_list.size());
-		for (auto &block_id : free_list) {
-			writer.Write<block_id_t>(block_id);
-		}
-		writer.Write<uint64_t>(multi_use_blocks.size());
-		for (auto &entry : multi_use_blocks) {
-			writer.Write<block_id_t>(entry.first);
-			writer.Write<uint32_t>(entry.second);
-		}
-		GetMetadataManager().Write(writer);
-		writer.Flush();
-	} else {
-		// no blocks in the free list
-		header.free_list = DConstants::INVALID_INDEX;
-	}
-	metadata_manager.Flush();
-	header.block_count = NumericCast<idx_t>(max_block);
-
-	auto &config = DBConfig::Get(db);
-	if (config.options.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE) {
-		throw FatalException("Checkpoint aborted after free list write because of PRAGMA checkpoint_abort flag");
-	}
-
-	// We need to fsync BEFORE we write the header to ensure that all the previous blocks are written as well
-	handle->Sync();
-
-	// set the header inside the buffer
-	header_buffer.Clear();
-	MemoryStream serializer;
-	header.Write(serializer);
-	memcpy(header_buffer.buffer, serializer.GetData(), serializer.GetPosition());
-	// now write the header to the file, active_header determines whether we write to h1 or h2
-	// note that if active_header is h1 we write to h2, and vice versa
-	ChecksumAndWrite(header_buffer, active_header == 1 ? Storage::FILE_HEADER_SIZE : Storage::FILE_HEADER_SIZE * 2);
-	// switch active header to the other header
-	active_header = 1 - active_header;
-	//! Ensure the header write ends up on disk
-	handle->Sync();
-	// Release the free blocks to the filesystem.
-	TrimFreeBlocks();
-}
-
-void SingleFileBlockManager::FileSync() {
-	handle->Sync();
-}
-
-void SingleFileBlockManager::TrimFreeBlocks() {
-	if (DBConfig::Get(db).options.trim_free_blocks) {
-		for (auto itr = newly_freed_list.begin(); itr != newly_freed_list.end(); ++itr) {
-			block_id_t first = *itr;
-			block_id_t last = first;
-			// Find end of contiguous range.
-			for (++itr; itr != newly_freed_list.end() && (*itr == last + 1); ++itr) {
-				last = *itr;
-			}
-			// We are now one too far.
-			--itr;
-			// Trim the range.
-			handle->Trim(BLOCK_START + (NumericCast<idx_t>(first) * GetBlockAllocSize()),
-			             NumericCast<idx_t>(last + 1 - first) * GetBlockAllocSize());
-		}
-	}
-	newly_freed_list.clear();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/standard_buffer_manager.cpp b/src/duckdb/src/storage/standard_buffer_manager.cpp
deleted file mode 100644
index c23ba16e0..000000000
--- a/src/duckdb/src/storage/standard_buffer_manager.cpp
+++ /dev/null
@@ -1,666 +0,0 @@
-#include "duckdb/storage/standard_buffer_manager.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/storage/in_memory_block_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/temporary_file_manager.hpp"
-#include "duckdb/storage/temporary_memory_manager.hpp"
-
-namespace duckdb {
-
-#ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
-static void WriteGarbageIntoBuffer(BlockLock &lock, BlockHandle &block) {
-	auto &buffer = block.GetBuffer(lock);
-	memset(buffer->buffer, 0xa5, buffer->size); // 0xa5 is default memory in debug mode
-}
-
-static void WriteGarbageIntoBuffer(BlockHandle &block) {
-	auto lock = block.GetLock();
-	WriteGarbageIntoBuffer(lock, block);
-}
-#endif
-
-struct BufferAllocatorData : PrivateAllocatorData {
-	explicit BufferAllocatorData(StandardBufferManager &manager) : manager(manager) {
-	}
-
-	StandardBufferManager &manager;
-};
-
-unique_ptr<FileBuffer> StandardBufferManager::ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
-                                                                     FileBufferType type) {
-	unique_ptr<FileBuffer> result;
-	if (type == FileBufferType::BLOCK) {
-		throw InternalException("ConstructManagedBuffer cannot be used to construct blocks");
-	}
-	if (source) {
-		auto tmp = std::move(source);
-		D_ASSERT(tmp->AllocSize() == BufferManager::GetAllocSize(size));
-		result = make_uniq<FileBuffer>(*tmp, type);
-	} else {
-		// no re-usable buffer: allocate a new buffer
-		result = make_uniq<FileBuffer>(Allocator::Get(db), type, size);
-	}
-	result->Initialize(DBConfig::GetConfig(db).options.debug_initialize);
-	return result;
-}
-
-void StandardBufferManager::SetTemporaryDirectory(const string &new_dir) {
-	lock_guard<mutex> guard(temporary_directory.lock);
-	if (temporary_directory.handle) {
-		throw NotImplementedException("Cannot switch temporary directory after the current one has been used");
-	}
-	temporary_directory.path = new_dir;
-}
-
-StandardBufferManager::StandardBufferManager(DatabaseInstance &db, string tmp)
-    : BufferManager(), db(db), buffer_pool(db.GetBufferPool()), temporary_id(MAXIMUM_BLOCK),
-      buffer_allocator(BufferAllocatorAllocate, BufferAllocatorFree, BufferAllocatorRealloc,
-                       make_uniq<BufferAllocatorData>(*this)) {
-	temp_block_manager = make_uniq<InMemoryBlockManager>(*this, DEFAULT_BLOCK_ALLOC_SIZE);
-	temporary_directory.path = std::move(tmp);
-	for (idx_t i = 0; i < MEMORY_TAG_COUNT; i++) {
-		evicted_data_per_tag[i] = 0;
-	}
-}
-
-StandardBufferManager::~StandardBufferManager() {
-}
-
-BufferPool &StandardBufferManager::GetBufferPool() const {
-	return buffer_pool;
-}
-
-TemporaryMemoryManager &StandardBufferManager::GetTemporaryMemoryManager() {
-	return buffer_pool.GetTemporaryMemoryManager();
-}
-
-idx_t StandardBufferManager::GetUsedMemory() const {
-	return buffer_pool.GetUsedMemory();
-}
-idx_t StandardBufferManager::GetMaxMemory() const {
-	return buffer_pool.GetMaxMemory();
-}
-
-idx_t StandardBufferManager::GetUsedSwap() {
-	lock_guard<mutex> guard(temporary_directory.lock);
-	if (!temporary_directory.handle) {
-		return 0;
-	}
-	return temporary_directory.handle->GetTempFile().GetTotalUsedSpaceInBytes();
-}
-
-optional_idx StandardBufferManager::GetMaxSwap() const {
-	lock_guard<mutex> guard(temporary_directory.lock);
-	if (!temporary_directory.handle) {
-		return optional_idx();
-	}
-	return temporary_directory.handle->GetTempFile().GetMaxSwapSpace();
-}
-
-idx_t StandardBufferManager::GetBlockAllocSize() const {
-	return temp_block_manager->GetBlockAllocSize();
-}
-
-idx_t StandardBufferManager::GetBlockSize() const {
-	return temp_block_manager->GetBlockSize();
-}
-
-template <typename... ARGS>
-TempBufferPoolReservation StandardBufferManager::EvictBlocksOrThrow(MemoryTag tag, idx_t memory_delta,
-                                                                    unique_ptr<FileBuffer> *buffer, ARGS... args) {
-	auto r = buffer_pool.EvictBlocks(tag, memory_delta, buffer_pool.maximum_memory, buffer);
-	if (!r.success) {
-		string extra_text = StringUtil::Format(" (%s/%s used)", StringUtil::BytesToHumanReadableString(GetUsedMemory()),
-		                                       StringUtil::BytesToHumanReadableString(GetMaxMemory()));
-		extra_text += InMemoryWarning();
-		throw OutOfMemoryException(args..., extra_text);
-	}
-	return std::move(r.reservation);
-}
-
-shared_ptr<BlockHandle> StandardBufferManager::RegisterTransientMemory(const idx_t size, const idx_t block_size) {
-	D_ASSERT(size <= block_size);
-
-	// This comparison is the reason behind passing block_size through transient memory creation.
-	// Otherwise, any non-default block size would register as small memory, causing problems when
-	// trying to convert that memory to consistent blocks later on.
-	if (size < block_size) {
-		return RegisterSmallMemory(MemoryTag::IN_MEMORY_TABLE, size);
-	}
-
-	auto buffer_handle = Allocate(MemoryTag::IN_MEMORY_TABLE, size, false);
-	return buffer_handle.GetBlockHandle();
-}
-
-shared_ptr<BlockHandle> StandardBufferManager::RegisterSmallMemory(MemoryTag tag, const idx_t size) {
-	D_ASSERT(size < GetBlockSize());
-	auto reservation = EvictBlocksOrThrow(tag, size, nullptr, "could not allocate block of size %s%s",
-	                                      StringUtil::BytesToHumanReadableString(size));
-
-	auto buffer = ConstructManagedBuffer(size, nullptr, FileBufferType::TINY_BUFFER);
-
-	// Create a new block pointer for this block.
-	auto result = make_shared_ptr<BlockHandle>(*temp_block_manager, ++temporary_id, tag, std::move(buffer),
-	                                           DestroyBufferUpon::BLOCK, size, std::move(reservation));
-#ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
-	// Initialize the memory with garbage data
-	WriteGarbageIntoBuffer(*result);
-#endif
-	return result;
-}
-
-shared_ptr<BlockHandle> StandardBufferManager::RegisterMemory(MemoryTag tag, idx_t block_size, bool can_destroy) {
-	auto alloc_size = GetAllocSize(block_size);
-
-	// Evict blocks until there is enough memory to store the buffer.
-	unique_ptr<FileBuffer> reusable_buffer;
-	auto res = EvictBlocksOrThrow(tag, alloc_size, &reusable_buffer, "could not allocate block of size %s%s",
-	                              StringUtil::BytesToHumanReadableString(alloc_size));
-
-	// Create a new buffer and a block to hold the buffer.
-	auto buffer = ConstructManagedBuffer(block_size, std::move(reusable_buffer));
-	DestroyBufferUpon destroy_buffer_upon = can_destroy ? DestroyBufferUpon::EVICTION : DestroyBufferUpon::BLOCK;
-	return make_shared_ptr<BlockHandle>(*temp_block_manager, ++temporary_id, tag, std::move(buffer),
-	                                    destroy_buffer_upon, alloc_size, std::move(res));
-}
-
-BufferHandle StandardBufferManager::Allocate(MemoryTag tag, idx_t block_size, bool can_destroy) {
-	auto block = RegisterMemory(tag, block_size, can_destroy);
-
-#ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
-	// Initialize the memory with garbage data
-	WriteGarbageIntoBuffer(*block);
-#endif
-	return Pin(block);
-}
-
-void StandardBufferManager::ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) {
-	D_ASSERT(block_size >= GetBlockSize());
-	auto lock = handle->GetLock();
-
-	auto handle_memory_usage = handle->GetMemoryUsage();
-	D_ASSERT(handle->GetState() == BlockState::BLOCK_LOADED);
-	D_ASSERT(handle_memory_usage == handle->GetBuffer(lock)->AllocSize());
-	D_ASSERT(handle_memory_usage == handle->GetMemoryCharge(lock).size);
-
-	auto req = handle->GetBuffer(lock)->CalculateMemory(block_size);
-	int64_t memory_delta = NumericCast<int64_t>(req.alloc_size) - NumericCast<int64_t>(handle_memory_usage);
-
-	if (memory_delta == 0) {
-		return;
-	} else if (memory_delta > 0) {
-		// evict blocks until we have space to resize this block
-		// unlock the handle lock during the call to EvictBlocksOrThrow
-		lock.unlock();
-		auto reservation = EvictBlocksOrThrow(handle->GetMemoryTag(), NumericCast<idx_t>(memory_delta), nullptr,
-		                                      "failed to resize block from %s to %s%s",
-		                                      StringUtil::BytesToHumanReadableString(handle_memory_usage),
-		                                      StringUtil::BytesToHumanReadableString(req.alloc_size));
-		lock.lock();
-
-		// EvictBlocks decrements 'current_memory' for us.
-		handle->MergeMemoryReservation(lock, std::move(reservation));
-	} else {
-		// no need to evict blocks, but we do need to decrement 'current_memory'.
-		handle->ResizeMemory(lock, req.alloc_size);
-	}
-
-	handle->ResizeBuffer(lock, block_size, memory_delta);
-}
-
-void StandardBufferManager::BatchRead(vector<shared_ptr<BlockHandle>> &handles, const map<block_id_t, idx_t> &load_map,
-                                      block_id_t first_block, block_id_t last_block) {
-	auto &block_manager = handles[0]->block_manager;
-	idx_t block_count = NumericCast<idx_t>(last_block - first_block + 1);
-#ifndef DUCKDB_ALTERNATIVE_VERIFY
-	if (block_count == 1) {
-		// prefetching with block_count == 1 has no performance impact since we can't batch reads
-		// skip the prefetch in this case
-		// we do it anyway if alternative_verify is on for extra testing
-		return;
-	}
-#endif
-
-	// allocate a buffer to hold the data of all of the blocks
-	auto intermediate_buffer = Allocate(MemoryTag::BASE_TABLE, block_count * block_manager.GetBlockSize());
-	// perform a batch read of the blocks into the buffer
-	block_manager.ReadBlocks(intermediate_buffer.GetFileBuffer(), first_block, block_count);
-
-	// the blocks are read - now we need to assign them to the individual blocks
-	for (idx_t block_idx = 0; block_idx < block_count; block_idx++) {
-		block_id_t block_id = first_block + NumericCast<block_id_t>(block_idx);
-		auto entry = load_map.find(block_id);
-		D_ASSERT(entry != load_map.end()); // if we allow gaps we might not return true here
-		auto &handle = handles[entry->second];
-
-		// reserve memory for the block
-		idx_t required_memory = handle->GetMemoryUsage();
-		unique_ptr<FileBuffer> reusable_buffer;
-		auto reservation = EvictBlocksOrThrow(handle->GetMemoryTag(), required_memory, &reusable_buffer,
-		                                      "failed to pin block of size %s%s",
-		                                      StringUtil::BytesToHumanReadableString(required_memory));
-		// now load the block from the buffer
-		// note that we discard the buffer handle - we do not keep it around
-		// the prefetching relies on the block handle being pinned again during the actual read before it is evicted
-		BufferHandle buf;
-		{
-			auto lock = handle->GetLock();
-			if (handle->GetState() == BlockState::BLOCK_LOADED) {
-				// the block is loaded already by another thread - free up the reservation and continue
-				reservation.Resize(0);
-				continue;
-			}
-			auto block_ptr =
-			    intermediate_buffer.GetFileBuffer().InternalBuffer() + block_idx * block_manager.GetBlockAllocSize();
-			buf = handle->LoadFromBuffer(lock, block_ptr, std::move(reusable_buffer), std::move(reservation));
-		}
-	}
-}
-
-void StandardBufferManager::Prefetch(vector<shared_ptr<BlockHandle>> &handles) {
-	// figure out which set of blocks we should load
-	map<block_id_t, idx_t> to_be_loaded;
-	for (idx_t block_idx = 0; block_idx < handles.size(); block_idx++) {
-		auto &handle = handles[block_idx];
-		if (handle->GetState() != BlockState::BLOCK_LOADED) {
-			// need to load this block - add it to the map
-			to_be_loaded.insert(make_pair(handle->BlockId(), block_idx));
-		}
-	}
-	if (to_be_loaded.empty()) {
-		// nothing to fetch
-		return;
-	}
-	// iterate over the blocks and perform bulk reads
-	block_id_t first_block = -1;
-	block_id_t previous_block_id = -1;
-	for (auto &entry : to_be_loaded) {
-		if (previous_block_id < 0) {
-			// this the first block we are seeing
-			first_block = entry.first;
-			previous_block_id = first_block;
-		} else if (previous_block_id + 1 == entry.first) {
-			// this block is adjacent to the previous block - add it to the batch read
-			previous_block_id = entry.first;
-		} else {
-			// this block is not adjacent to the previous block
-			// perform the batch read for the previous batch
-			BatchRead(handles, to_be_loaded, first_block, previous_block_id);
-
-			// set the first_block and previous_block_id to the current block
-			first_block = entry.first;
-			previous_block_id = entry.first;
-		}
-	}
-	// batch read the final batch
-	BatchRead(handles, to_be_loaded, first_block, previous_block_id);
-}
-
-BufferHandle StandardBufferManager::Pin(shared_ptr<BlockHandle> &handle) {
-	// we need to be careful not to return the BufferHandle to this block while holding the BlockHandle's lock
-	// as exiting this function's scope may cause the destructor of the BufferHandle to be called while holding the lock
-	// the destructor calls Unpin, which grabs the BlockHandle's lock again, causing a deadlock
-	BufferHandle buf;
-
-	idx_t required_memory;
-	{
-		// lock the block
-		auto lock = handle->GetLock();
-		// check if the block is already loaded
-		if (handle->GetState() == BlockState::BLOCK_LOADED) {
-			// the block is loaded, increment the reader count and set the BufferHandle
-			buf = handle->Load();
-		}
-		required_memory = handle->GetMemoryUsage();
-	}
-
-	if (buf.IsValid()) {
-		return buf; // the block was already loaded, return it without holding the BlockHandle's lock
-	} else {
-		// evict blocks until we have space for the current block
-		unique_ptr<FileBuffer> reusable_buffer;
-		auto reservation = EvictBlocksOrThrow(handle->GetMemoryTag(), required_memory, &reusable_buffer,
-		                                      "failed to pin block of size %s%s",
-		                                      StringUtil::BytesToHumanReadableString(required_memory));
-
-		// lock the handle again and repeat the check (in case anybody loaded in the meantime)
-		auto lock = handle->GetLock();
-		// check if the block is already loaded
-		if (handle->GetState() == BlockState::BLOCK_LOADED) {
-			// the block is loaded, increment the reader count and return a pointer to the handle
-			reservation.Resize(0);
-			buf = handle->Load();
-		} else {
-			// now we can actually load the current block
-			D_ASSERT(handle->Readers() == 0);
-			buf = handle->Load(std::move(reusable_buffer));
-			auto &memory_charge = handle->GetMemoryCharge(lock);
-			memory_charge = std::move(reservation);
-			// in the case of a variable sized block, the buffer may be smaller than a full block.
-			int64_t delta = NumericCast<int64_t>(handle->GetBuffer(lock)->AllocSize()) -
-			                NumericCast<int64_t>(handle->GetMemoryUsage());
-			if (delta) {
-				handle->ChangeMemoryUsage(lock, delta);
-			}
-			D_ASSERT(handle->GetMemoryUsage() == handle->GetBuffer(lock)->AllocSize());
-		}
-	}
-
-	// we should have a valid BufferHandle by now, either because the block was already loaded, or because we loaded it
-	// return it without holding the BlockHandle's lock
-	D_ASSERT(buf.IsValid());
-	return buf;
-}
-
-void StandardBufferManager::PurgeQueue(const BlockHandle &handle) {
-	buffer_pool.PurgeQueue(handle);
-}
-
-void StandardBufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
-	buffer_pool.AddToEvictionQueue(handle);
-}
-
-void StandardBufferManager::VerifyZeroReaders(BlockLock &lock, shared_ptr<BlockHandle> &handle) {
-#ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
-	unique_ptr<FileBuffer> replacement_buffer;
-	auto &allocator = Allocator::Get(db);
-	auto alloc_size = handle->GetMemoryUsage() - Storage::DEFAULT_BLOCK_HEADER_SIZE;
-	auto &buffer = handle->GetBuffer(lock);
-	if (handle->GetBufferType() == FileBufferType::BLOCK) {
-		auto block = reinterpret_cast<Block *>(buffer.get());
-		replacement_buffer = make_uniq<Block>(allocator, block->id, alloc_size);
-	} else {
-		replacement_buffer = make_uniq<FileBuffer>(allocator, buffer->GetBufferType(), alloc_size);
-	}
-	memcpy(replacement_buffer->buffer, buffer->buffer, buffer->size);
-	WriteGarbageIntoBuffer(lock, *handle);
-	buffer = std::move(replacement_buffer);
-#endif
-}
-
-void StandardBufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
-	bool purge = false;
-	{
-		auto lock = handle->GetLock();
-		if (!handle->GetBuffer(lock) || handle->GetBufferType() == FileBufferType::TINY_BUFFER) {
-			return;
-		}
-		D_ASSERT(handle->Readers() > 0);
-		auto new_readers = handle->DecrementReaders();
-		if (new_readers == 0) {
-			VerifyZeroReaders(lock, handle);
-			if (handle->MustAddToEvictionQueue()) {
-				purge = buffer_pool.AddToEvictionQueue(handle);
-			} else {
-				handle->Unload(lock);
-			}
-		}
-	}
-
-	// We do not have to keep the handle locked while purging.
-	if (purge) {
-		PurgeQueue(*handle);
-	}
-}
-
-void StandardBufferManager::SetMemoryLimit(idx_t limit) {
-	buffer_pool.SetLimit(limit, InMemoryWarning());
-}
-
-void StandardBufferManager::SetSwapLimit(optional_idx limit) {
-	lock_guard<mutex> guard(temporary_directory.lock);
-	if (temporary_directory.handle) {
-		temporary_directory.handle->GetTempFile().SetMaxSwapSpace(limit);
-	} else {
-		temporary_directory.maximum_swap_space = limit;
-	}
-}
-
-vector<MemoryInformation> StandardBufferManager::GetMemoryUsageInfo() const {
-	vector<MemoryInformation> result;
-	for (idx_t k = 0; k < MEMORY_TAG_COUNT; k++) {
-		MemoryInformation info;
-		info.tag = MemoryTag(k);
-		info.size = buffer_pool.memory_usage.GetUsedMemory(MemoryTag(k), BufferPool::MemoryUsageCaches::FLUSH);
-		info.evicted_data = evicted_data_per_tag[k].load();
-		result.push_back(info);
-	}
-	return result;
-}
-
-unique_ptr<FileBuffer> StandardBufferManager::ReadTemporaryBufferInternal(BufferManager &buffer_manager,
-                                                                          FileHandle &handle, idx_t position,
-                                                                          idx_t size,
-                                                                          unique_ptr<FileBuffer> reusable_buffer) {
-	auto buffer = buffer_manager.ConstructManagedBuffer(size, std::move(reusable_buffer));
-	buffer->Read(handle, position);
-	return buffer;
-}
-
-string StandardBufferManager::GetTemporaryPath(block_id_t id) {
-	auto &fs = FileSystem::GetFileSystem(db);
-	return fs.JoinPath(temporary_directory.path, "duckdb_temp_block-" + to_string(id) + ".block");
-}
-
-void StandardBufferManager::RequireTemporaryDirectory() {
-	if (temporary_directory.path.empty()) {
-		throw InvalidInputException(
-		    "Out-of-memory: cannot write buffer because no temporary directory is specified!\nTo enable "
-		    "temporary buffer eviction set a temporary directory using PRAGMA temp_directory='/path/to/tmp.tmp'");
-	}
-	lock_guard<mutex> guard(temporary_directory.lock);
-	if (!temporary_directory.handle) {
-		// temp directory has not been created yet: initialize it
-		temporary_directory.handle =
-		    make_uniq<TemporaryDirectoryHandle>(db, temporary_directory.path, temporary_directory.maximum_swap_space);
-	}
-}
-
-void StandardBufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) {
-
-	// WriteTemporaryBuffer assumes that we never write a buffer below DEFAULT_BLOCK_ALLOC_SIZE.
-	RequireTemporaryDirectory();
-
-	// Append to a few grouped files.
-	if (buffer.AllocSize() == GetBlockAllocSize()) {
-		evicted_data_per_tag[uint8_t(tag)] += GetBlockAllocSize();
-		temporary_directory.handle->GetTempFile().WriteTemporaryBuffer(block_id, buffer);
-		return;
-	}
-
-	// Get the path to write to.
-	auto path = GetTemporaryPath(block_id);
-	evicted_data_per_tag[uint8_t(tag)] += buffer.AllocSize();
-
-	// Create the file and write the size followed by the buffer contents.
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE);
-	temporary_directory.handle->GetTempFile().IncreaseSizeOnDisk(buffer.AllocSize() + sizeof(idx_t));
-	handle->Write(&buffer.size, sizeof(idx_t), 0);
-	buffer.Write(*handle, sizeof(idx_t));
-}
-
-unique_ptr<FileBuffer> StandardBufferManager::ReadTemporaryBuffer(MemoryTag tag, BlockHandle &block,
-                                                                  unique_ptr<FileBuffer> reusable_buffer) {
-	D_ASSERT(!temporary_directory.path.empty());
-	D_ASSERT(temporary_directory.handle.get());
-	auto id = block.BlockId();
-	if (temporary_directory.handle->GetTempFile().HasTemporaryBuffer(id)) {
-		// This is a block that was offloaded to a regular .tmp file, the file contains blocks of a fixed size
-		return temporary_directory.handle->GetTempFile().ReadTemporaryBuffer(id, std::move(reusable_buffer));
-	}
-
-	// This block contains data of variable size so we need to open it and read it to get its size.
-	idx_t block_size;
-	auto path = GetTemporaryPath(id);
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
-	handle->Read(&block_size, sizeof(idx_t), 0);
-
-	// Allocate a buffer of the file's size and read the data into that buffer.
-	auto buffer = ReadTemporaryBufferInternal(*this, *handle, sizeof(idx_t), block_size, std::move(reusable_buffer));
-	handle.reset();
-
-	// Delete the file and return the buffer.
-	DeleteTemporaryFile(block);
-	return buffer;
-}
-
-void StandardBufferManager::DeleteTemporaryFile(BlockHandle &block) {
-	auto id = block.BlockId();
-	if (temporary_directory.path.empty()) {
-		// no temporary directory specified: nothing to delete
-		return;
-	}
-	{
-		lock_guard<mutex> guard(temporary_directory.lock);
-		if (!temporary_directory.handle) {
-			// temporary directory was not initialized yet: nothing to delete
-			return;
-		}
-	}
-	// check if we should delete the file from the shared pool of files, or from the general file system
-	if (temporary_directory.handle->GetTempFile().HasTemporaryBuffer(id)) {
-		evicted_data_per_tag[uint8_t(block.GetMemoryTag())] -= GetBlockAllocSize();
-		temporary_directory.handle->GetTempFile().DeleteTemporaryBuffer(id);
-		return;
-	}
-
-	// The file is not in the shared pool of files.
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto path = GetTemporaryPath(id);
-	if (fs.FileExists(path)) {
-		evicted_data_per_tag[uint8_t(block.GetMemoryTag())] -= block.GetMemoryUsage();
-		auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
-		auto content_size = handle->GetFileSize();
-		handle.reset();
-		fs.RemoveFile(path);
-		temporary_directory.handle->GetTempFile().DecreaseSizeOnDisk(content_size);
-	}
-}
-
-bool StandardBufferManager::HasTemporaryDirectory() const {
-	return !temporary_directory.path.empty();
-}
-
-vector<TemporaryFileInformation> StandardBufferManager::GetTemporaryFiles() {
-	vector<TemporaryFileInformation> result;
-	if (temporary_directory.path.empty()) {
-		return result;
-	}
-	{
-		lock_guard<mutex> temp_handle_guard(temporary_directory.lock);
-		if (temporary_directory.handle) {
-			result = temporary_directory.handle->GetTempFile().GetTemporaryFiles();
-		}
-	}
-	auto &fs = FileSystem::GetFileSystem(db);
-	fs.ListFiles(temporary_directory.path, [&](const string &name, bool is_dir) {
-		if (is_dir) {
-			return;
-		}
-		if (!StringUtil::EndsWith(name, ".block")) {
-			return;
-		}
-
-		// Another process or thread can delete the file before we can get its file size.
-		auto handle = fs.OpenFile(name, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS);
-		if (!handle) {
-			return;
-		}
-
-		TemporaryFileInformation info;
-		info.path = name;
-		info.size = NumericCast<idx_t>(fs.GetFileSize(*handle));
-		handle.reset();
-		result.push_back(info);
-	});
-	return result;
-}
-
-const char *StandardBufferManager::InMemoryWarning() {
-	if (!temporary_directory.path.empty()) {
-		return "";
-	}
-	return "\nDatabase is launched in in-memory mode and no temporary directory is specified."
-	       "\nUnused blocks cannot be offloaded to disk."
-	       "\n\nLaunch the database with a persistent storage back-end"
-	       "\nOr set SET temp_directory='/path/to/tmp.tmp'";
-}
-
-void StandardBufferManager::ReserveMemory(idx_t size) {
-	if (size == 0) {
-		return;
-	}
-	auto reservation =
-	    EvictBlocksOrThrow(MemoryTag::EXTENSION, size, nullptr, "failed to reserve memory data of size %s%s",
-	                       StringUtil::BytesToHumanReadableString(size));
-	reservation.size = 0;
-}
-
-void StandardBufferManager::FreeReservedMemory(idx_t size) {
-	if (size == 0) {
-		return;
-	}
-	buffer_pool.memory_usage.UpdateUsedMemory(MemoryTag::EXTENSION, -(int64_t)size);
-}
-
-//===--------------------------------------------------------------------===//
-// Buffer Allocator
-//===--------------------------------------------------------------------===//
-data_ptr_t StandardBufferManager::BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &data = private_data->Cast<BufferAllocatorData>();
-	auto reservation =
-	    data.manager.EvictBlocksOrThrow(MemoryTag::ALLOCATOR, size, nullptr, "failed to allocate data of size %s%s",
-	                                    StringUtil::BytesToHumanReadableString(size));
-	// We rely on manual tracking of this one. :(
-	reservation.size = 0;
-	return Allocator::Get(data.manager.db).AllocateData(size);
-}
-
-void StandardBufferManager::BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
-	auto &data = private_data->Cast<BufferAllocatorData>();
-	BufferPoolReservation r(MemoryTag::ALLOCATOR, data.manager.GetBufferPool());
-	r.size = size;
-	r.Resize(0);
-	return Allocator::Get(data.manager.db).FreeData(pointer, size);
-}
-
-data_ptr_t StandardBufferManager::BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer,
-                                                         idx_t old_size, idx_t size) {
-	if (old_size == size) {
-		return pointer;
-	}
-	auto &data = private_data->Cast<BufferAllocatorData>();
-	BufferPoolReservation r(MemoryTag::ALLOCATOR, data.manager.GetBufferPool());
-	r.size = old_size;
-	r.Resize(size);
-	r.size = 0;
-	return Allocator::Get(data.manager.db).ReallocateData(pointer, old_size, size);
-}
-
-Allocator &BufferAllocator::Get(ClientContext &context) {
-	auto &manager = StandardBufferManager::GetBufferManager(context);
-	return manager.GetBufferAllocator();
-}
-
-Allocator &BufferAllocator::Get(DatabaseInstance &db) {
-	return StandardBufferManager::GetBufferManager(db).GetBufferAllocator();
-}
-
-Allocator &BufferAllocator::Get(AttachedDatabase &db) {
-	return BufferAllocator::Get(db.GetDatabase());
-}
-
-Allocator &StandardBufferManager::GetBufferAllocator() {
-	return buffer_allocator;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/array_stats.cpp b/src/duckdb/src/storage/statistics/array_stats.cpp
deleted file mode 100644
index ecb399d21..000000000
--- a/src/duckdb/src/storage/statistics/array_stats.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "duckdb/storage/statistics/array_stats.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-void ArrayStats::Construct(BaseStatistics &stats) {
-	stats.child_stats = unsafe_unique_array<BaseStatistics>(new BaseStatistics[1]);
-	BaseStatistics::Construct(stats.child_stats[0], ArrayType::GetChildType(stats.GetType()));
-}
-
-BaseStatistics ArrayStats::CreateUnknown(LogicalType type) {
-	auto &child_type = ArrayType::GetChildType(type);
-	BaseStatistics result(std::move(type));
-	result.InitializeUnknown();
-	result.child_stats[0].Copy(BaseStatistics::CreateUnknown(child_type));
-	return result;
-}
-
-BaseStatistics ArrayStats::CreateEmpty(LogicalType type) {
-	auto &child_type = ArrayType::GetChildType(type);
-	BaseStatistics result(std::move(type));
-	result.InitializeEmpty();
-	result.child_stats[0].Copy(BaseStatistics::CreateEmpty(child_type));
-	return result;
-}
-
-void ArrayStats::Copy(BaseStatistics &stats, const BaseStatistics &other) {
-	D_ASSERT(stats.child_stats);
-	D_ASSERT(other.child_stats);
-	stats.child_stats[0].Copy(other.child_stats[0]);
-}
-
-const BaseStatistics &ArrayStats::GetChildStats(const BaseStatistics &stats) {
-	if (stats.GetStatsType() != StatisticsType::ARRAY_STATS) {
-		throw InternalException("ArrayStats::GetChildStats called on stats that is not a array");
-	}
-	D_ASSERT(stats.child_stats);
-	return stats.child_stats[0];
-}
-BaseStatistics &ArrayStats::GetChildStats(BaseStatistics &stats) {
-	if (stats.GetStatsType() != StatisticsType::ARRAY_STATS) {
-		throw InternalException("ArrayStats::GetChildStats called on stats that is not a array");
-	}
-	D_ASSERT(stats.child_stats);
-	return stats.child_stats[0];
-}
-
-void ArrayStats::SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats) {
-	if (!new_stats) {
-		stats.child_stats[0].Copy(BaseStatistics::CreateUnknown(ArrayType::GetChildType(stats.GetType())));
-	} else {
-		stats.child_stats[0].Copy(*new_stats);
-	}
-}
-
-void ArrayStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
-	if (other.GetType().id() == LogicalTypeId::VALIDITY) {
-		return;
-	}
-
-	auto &child_stats = ArrayStats::GetChildStats(stats);
-	auto &other_child_stats = ArrayStats::GetChildStats(other);
-	child_stats.Merge(other_child_stats);
-}
-
-void ArrayStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
-	auto &child_stats = ArrayStats::GetChildStats(stats);
-	serializer.WriteProperty(200, "child_stats", child_stats);
-}
-
-void ArrayStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
-	auto &type = base.GetType();
-	D_ASSERT(type.id() == LogicalTypeId::ARRAY);
-	auto &child_type = ArrayType::GetChildType(type);
-
-	// Push the logical type of the child type to the deserialization context
-	deserializer.Set<const LogicalType &>(child_type);
-	base.child_stats[0].Copy(deserializer.ReadProperty<BaseStatistics>(200, "child_stats"));
-	deserializer.Unset<LogicalType>();
-}
-
-string ArrayStats::ToString(const BaseStatistics &stats) {
-	auto &child_stats = ArrayStats::GetChildStats(stats);
-	return StringUtil::Format("[%s]", child_stats.ToString());
-}
-
-void ArrayStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
-	auto &child_stats = ArrayStats::GetChildStats(stats);
-	auto &child_entry = ArrayVector::GetEntry(vector);
-	auto array_size = ArrayType::GetSize(vector.GetType());
-
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-
-	// Basically,
-	// 1. Count the number of valid arrays
-	// 2. Create a selection vector with the size of the number of valid arrays * array_size
-	// 3. Fill the selection vector with the offsets of all the elements in the child vector
-	//      that exist in each valid array
-	// 4. Use that selection vector to verify the child stats
-
-	idx_t valid_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		if (vdata.validity.RowIsValid(index)) {
-			valid_count++;
-		}
-	}
-
-	SelectionVector element_sel(valid_count * array_size);
-	idx_t element_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		auto offset = index * array_size;
-		if (vdata.validity.RowIsValid(index)) {
-			for (idx_t elem_idx = 0; elem_idx < array_size; elem_idx++) {
-				element_sel.set_index(element_count++, offset + elem_idx);
-			}
-		}
-	}
-
-	child_stats.Verify(child_entry, element_sel, element_count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/base_statistics.cpp b/src/duckdb/src/storage/statistics/base_statistics.cpp
deleted file mode 100644
index 106599002..000000000
--- a/src/duckdb/src/storage/statistics/base_statistics.cpp
+++ /dev/null
@@ -1,526 +0,0 @@
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/list_stats.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/storage/statistics/array_stats.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-BaseStatistics::BaseStatistics() : type(LogicalType::INVALID) {
-}
-
-BaseStatistics::BaseStatistics(LogicalType type) {
-	Construct(*this, std::move(type));
-}
-
-void BaseStatistics::Construct(BaseStatistics &stats, LogicalType type) {
-	stats.distinct_count = 0;
-	stats.type = std::move(type);
-	switch (GetStatsType(stats.type)) {
-	case StatisticsType::LIST_STATS:
-		ListStats::Construct(stats);
-		break;
-	case StatisticsType::STRUCT_STATS:
-		StructStats::Construct(stats);
-		break;
-	case StatisticsType::ARRAY_STATS:
-		ArrayStats::Construct(stats);
-		break;
-	default:
-		break;
-	}
-}
-
-BaseStatistics::~BaseStatistics() {
-}
-
-BaseStatistics::BaseStatistics(BaseStatistics &&other) noexcept {
-	std::swap(type, other.type);
-	has_null = other.has_null;
-	has_no_null = other.has_no_null;
-	distinct_count = other.distinct_count;
-	stats_union = other.stats_union;
-	std::swap(child_stats, other.child_stats);
-}
-
-BaseStatistics &BaseStatistics::operator=(BaseStatistics &&other) noexcept {
-	std::swap(type, other.type);
-	has_null = other.has_null;
-	has_no_null = other.has_no_null;
-	distinct_count = other.distinct_count;
-	stats_union = other.stats_union;
-	std::swap(child_stats, other.child_stats);
-	return *this;
-}
-
-StatisticsType BaseStatistics::GetStatsType(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::SQLNULL) {
-		return StatisticsType::BASE_STATS;
-	}
-	switch (type.InternalType()) {
-	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:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return StatisticsType::NUMERIC_STATS;
-	case PhysicalType::VARCHAR:
-		return StatisticsType::STRING_STATS;
-	case PhysicalType::STRUCT:
-		return StatisticsType::STRUCT_STATS;
-	case PhysicalType::LIST:
-		return StatisticsType::LIST_STATS;
-	case PhysicalType::ARRAY:
-		return StatisticsType::ARRAY_STATS;
-	case PhysicalType::BIT:
-	case PhysicalType::INTERVAL:
-	default:
-		return StatisticsType::BASE_STATS;
-	}
-}
-
-StatisticsType BaseStatistics::GetStatsType() const {
-	return GetStatsType(GetType());
-}
-
-void BaseStatistics::InitializeUnknown() {
-	has_null = true;
-	has_no_null = true;
-}
-
-void BaseStatistics::InitializeEmpty() {
-	has_null = false;
-	has_no_null = true;
-}
-
-bool BaseStatistics::CanHaveNull() const {
-	return has_null;
-}
-
-bool BaseStatistics::CanHaveNoNull() const {
-	return has_no_null;
-}
-
-bool BaseStatistics::IsConstant() const {
-	if (type.id() == LogicalTypeId::VALIDITY) {
-		// validity mask
-		if (CanHaveNull() && !CanHaveNoNull()) {
-			return true;
-		}
-		if (!CanHaveNull() && CanHaveNoNull()) {
-			return true;
-		}
-		return false;
-	}
-	switch (GetStatsType()) {
-	case StatisticsType::NUMERIC_STATS:
-		return NumericStats::IsConstant(*this);
-	default:
-		break;
-	}
-	return false;
-}
-
-void BaseStatistics::Merge(const BaseStatistics &other) {
-	has_null = has_null || other.has_null;
-	has_no_null = has_no_null || other.has_no_null;
-	switch (GetStatsType()) {
-	case StatisticsType::NUMERIC_STATS:
-		NumericStats::Merge(*this, other);
-		break;
-	case StatisticsType::STRING_STATS:
-		StringStats::Merge(*this, other);
-		break;
-	case StatisticsType::LIST_STATS:
-		ListStats::Merge(*this, other);
-		break;
-	case StatisticsType::STRUCT_STATS:
-		StructStats::Merge(*this, other);
-		break;
-	case StatisticsType::ARRAY_STATS:
-		ArrayStats::Merge(*this, other);
-		break;
-	default:
-		break;
-	}
-}
-
-idx_t BaseStatistics::GetDistinctCount() {
-	return distinct_count;
-}
-
-BaseStatistics BaseStatistics::CreateUnknownType(LogicalType type) {
-	switch (GetStatsType(type)) {
-	case StatisticsType::NUMERIC_STATS:
-		return NumericStats::CreateUnknown(std::move(type));
-	case StatisticsType::STRING_STATS:
-		return StringStats::CreateUnknown(std::move(type));
-	case StatisticsType::LIST_STATS:
-		return ListStats::CreateUnknown(std::move(type));
-	case StatisticsType::STRUCT_STATS:
-		return StructStats::CreateUnknown(std::move(type));
-	case StatisticsType::ARRAY_STATS:
-		return ArrayStats::CreateUnknown(std::move(type));
-	default:
-		return BaseStatistics(std::move(type));
-	}
-}
-
-BaseStatistics BaseStatistics::CreateEmptyType(LogicalType type) {
-	switch (GetStatsType(type)) {
-	case StatisticsType::NUMERIC_STATS:
-		return NumericStats::CreateEmpty(std::move(type));
-	case StatisticsType::STRING_STATS:
-		return StringStats::CreateEmpty(std::move(type));
-	case StatisticsType::LIST_STATS:
-		return ListStats::CreateEmpty(std::move(type));
-	case StatisticsType::STRUCT_STATS:
-		return StructStats::CreateEmpty(std::move(type));
-	case StatisticsType::ARRAY_STATS:
-		return ArrayStats::CreateEmpty(std::move(type));
-	default:
-		return BaseStatistics(std::move(type));
-	}
-}
-
-BaseStatistics BaseStatistics::CreateUnknown(LogicalType type) {
-	auto result = CreateUnknownType(std::move(type));
-	result.InitializeUnknown();
-	return result;
-}
-
-BaseStatistics BaseStatistics::CreateEmpty(LogicalType type) {
-	if (type.InternalType() == PhysicalType::BIT) {
-		// FIXME: this special case should not be necessary
-		// but currently InitializeEmpty sets StatsInfo::CAN_HAVE_VALID_VALUES
-		BaseStatistics result(std::move(type));
-		result.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-		result.Set(StatsInfo::CANNOT_HAVE_VALID_VALUES);
-		return result;
-	}
-	auto result = CreateEmptyType(std::move(type));
-	result.InitializeEmpty();
-	return result;
-}
-
-void BaseStatistics::Copy(const BaseStatistics &other) {
-	D_ASSERT(GetType() == other.GetType());
-	CopyBase(other);
-	stats_union = other.stats_union;
-	switch (GetStatsType()) {
-	case StatisticsType::LIST_STATS:
-		ListStats::Copy(*this, other);
-		break;
-	case StatisticsType::STRUCT_STATS:
-		StructStats::Copy(*this, other);
-		break;
-	case StatisticsType::ARRAY_STATS:
-		ArrayStats::Copy(*this, other);
-		break;
-	default:
-		break;
-	}
-}
-
-BaseStatistics BaseStatistics::Copy() const {
-	BaseStatistics result(type);
-	result.Copy(*this);
-	return result;
-}
-
-unique_ptr<BaseStatistics> BaseStatistics::ToUnique() const {
-	auto result = unique_ptr<BaseStatistics>(new BaseStatistics(type));
-	result->Copy(*this);
-	return result;
-}
-
-void BaseStatistics::CopyBase(const BaseStatistics &other) {
-	has_null = other.has_null;
-	has_no_null = other.has_no_null;
-	distinct_count = other.distinct_count;
-}
-
-void BaseStatistics::Set(StatsInfo info) {
-	switch (info) {
-	case StatsInfo::CAN_HAVE_NULL_VALUES:
-		SetHasNull();
-		break;
-	case StatsInfo::CANNOT_HAVE_NULL_VALUES:
-		has_null = false;
-		break;
-	case StatsInfo::CAN_HAVE_VALID_VALUES:
-		SetHasNoNull();
-		break;
-	case StatsInfo::CANNOT_HAVE_VALID_VALUES:
-		has_no_null = false;
-		break;
-	case StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES:
-		SetHasNull();
-		SetHasNoNull();
-		break;
-	default:
-		throw InternalException("Unrecognized StatsInfo for BaseStatistics::Set");
-	}
-}
-
-void BaseStatistics::SetHasNull() {
-	has_null = true;
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		for (idx_t c = 0; c < StructType::GetChildCount(type); c++) {
-			StructStats::GetChildStats(*this, c).SetHasNull();
-		}
-	}
-}
-
-void BaseStatistics::SetHasNoNull() {
-	has_no_null = true;
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		for (idx_t c = 0; c < StructType::GetChildCount(type); c++) {
-			StructStats::GetChildStats(*this, c).SetHasNoNull();
-		}
-	}
-}
-
-void BaseStatistics::CombineValidity(BaseStatistics &left, BaseStatistics &right) {
-	has_null = left.has_null || right.has_null;
-	has_no_null = left.has_no_null || right.has_no_null;
-}
-
-void BaseStatistics::CopyValidity(BaseStatistics &stats) {
-	has_null = stats.has_null;
-	has_no_null = stats.has_no_null;
-}
-
-void BaseStatistics::SetDistinctCount(idx_t count) {
-	this->distinct_count = count;
-}
-
-void BaseStatistics::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(100, "has_null", has_null);
-	serializer.WriteProperty(101, "has_no_null", has_no_null);
-	serializer.WriteProperty(102, "distinct_count", distinct_count);
-	serializer.WriteObject(103, "type_stats", [&](Serializer &serializer) {
-		switch (GetStatsType()) {
-		case StatisticsType::NUMERIC_STATS:
-			NumericStats::Serialize(*this, serializer);
-			break;
-		case StatisticsType::STRING_STATS:
-			StringStats::Serialize(*this, serializer);
-			break;
-		case StatisticsType::LIST_STATS:
-			ListStats::Serialize(*this, serializer);
-			break;
-		case StatisticsType::STRUCT_STATS:
-			StructStats::Serialize(*this, serializer);
-			break;
-		case StatisticsType::ARRAY_STATS:
-			ArrayStats::Serialize(*this, serializer);
-			break;
-		default:
-			break;
-		}
-	});
-}
-
-BaseStatistics BaseStatistics::Deserialize(Deserializer &deserializer) {
-	auto has_null = deserializer.ReadProperty<bool>(100, "has_null");
-	auto has_no_null = deserializer.ReadProperty<bool>(101, "has_no_null");
-	auto distinct_count = deserializer.ReadProperty<idx_t>(102, "distinct_count");
-
-	// Get the logical type from the deserializer context.
-	auto &type = deserializer.Get<const LogicalType &>();
-	auto stats_type = GetStatsType(type);
-
-	BaseStatistics stats(type);
-
-	stats.has_null = has_null;
-	stats.has_no_null = has_no_null;
-	stats.distinct_count = distinct_count;
-
-	deserializer.ReadObject(103, "type_stats", [&](Deserializer &obj) {
-		switch (stats_type) {
-		case StatisticsType::NUMERIC_STATS:
-			NumericStats::Deserialize(obj, stats);
-			break;
-		case StatisticsType::STRING_STATS:
-			StringStats::Deserialize(obj, stats);
-			break;
-		case StatisticsType::LIST_STATS:
-			ListStats::Deserialize(obj, stats);
-			break;
-		case StatisticsType::STRUCT_STATS:
-			StructStats::Deserialize(obj, stats);
-			break;
-		case StatisticsType::ARRAY_STATS:
-			ArrayStats::Deserialize(obj, stats);
-			break;
-		default:
-			break;
-		}
-	});
-
-	return stats;
-}
-
-string BaseStatistics::ToString() const {
-	auto has_n = has_null ? "true" : "false";
-	auto has_n_n = has_no_null ? "true" : "false";
-	string result =
-	    StringUtil::Format("%s%s", StringUtil::Format("[Has Null: %s, Has No Null: %s]", has_n, has_n_n),
-	                       distinct_count > 0 ? StringUtil::Format("[Approx Unique: %lld]", distinct_count) : "");
-	switch (GetStatsType()) {
-	case StatisticsType::NUMERIC_STATS:
-		result = NumericStats::ToString(*this) + result;
-		break;
-	case StatisticsType::STRING_STATS:
-		result = StringStats::ToString(*this) + result;
-		break;
-	case StatisticsType::LIST_STATS:
-		result = ListStats::ToString(*this) + result;
-		break;
-	case StatisticsType::STRUCT_STATS:
-		result = StructStats::ToString(*this) + result;
-		break;
-	case StatisticsType::ARRAY_STATS:
-		result = ArrayStats::ToString(*this) + result;
-		break;
-	default:
-		break;
-	}
-	return result;
-}
-
-void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	D_ASSERT(vector.GetType() == this->type);
-	switch (GetStatsType()) {
-	case StatisticsType::NUMERIC_STATS:
-		NumericStats::Verify(*this, vector, sel, count);
-		break;
-	case StatisticsType::STRING_STATS:
-		StringStats::Verify(*this, vector, sel, count);
-		break;
-	case StatisticsType::LIST_STATS:
-		ListStats::Verify(*this, vector, sel, count);
-		break;
-	case StatisticsType::STRUCT_STATS:
-		StructStats::Verify(*this, vector, sel, count);
-		break;
-	case StatisticsType::ARRAY_STATS:
-		ArrayStats::Verify(*this, vector, sel, count);
-		break;
-	default:
-		break;
-	}
-	if (has_null && has_no_null) {
-		// nothing to verify
-		return;
-	}
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		bool row_is_valid = vdata.validity.RowIsValid(index);
-		if (row_is_valid && !has_no_null) {
-			throw InternalException(
-			    "Statistics mismatch: vector labeled as having only NULL values, but vector contains valid values: %s",
-			    vector.ToString(count));
-		}
-		if (!row_is_valid && !has_null) {
-			throw InternalException(
-			    "Statistics mismatch: vector labeled as not having NULL values, but vector contains null values: %s",
-			    vector.ToString(count));
-		}
-	}
-}
-
-void BaseStatistics::Verify(Vector &vector, idx_t count) const {
-	auto sel = FlatVector::IncrementalSelectionVector();
-	Verify(vector, *sel, count);
-}
-
-BaseStatistics BaseStatistics::FromConstantType(const Value &input) {
-	switch (GetStatsType(input.type())) {
-	case StatisticsType::NUMERIC_STATS: {
-		auto result = NumericStats::CreateEmpty(input.type());
-		NumericStats::SetMin(result, input);
-		NumericStats::SetMax(result, input);
-		return result;
-	}
-	case StatisticsType::STRING_STATS: {
-		auto result = StringStats::CreateEmpty(input.type());
-		if (!input.IsNull()) {
-			auto &string_value = StringValue::Get(input);
-			StringStats::Update(result, string_t(string_value));
-		}
-		return result;
-	}
-	case StatisticsType::LIST_STATS: {
-		auto result = ListStats::CreateEmpty(input.type());
-		auto &child_stats = ListStats::GetChildStats(result);
-		if (!input.IsNull()) {
-			auto &list_children = ListValue::GetChildren(input);
-			for (auto &child_element : list_children) {
-				child_stats.Merge(FromConstant(child_element));
-			}
-		}
-		return result;
-	}
-	case StatisticsType::STRUCT_STATS: {
-		auto result = StructStats::CreateEmpty(input.type());
-		auto &child_types = StructType::GetChildTypes(input.type());
-		if (input.IsNull()) {
-			for (idx_t i = 0; i < child_types.size(); i++) {
-				StructStats::SetChildStats(result, i, FromConstant(Value(child_types[i].second)));
-			}
-		} else {
-			auto &struct_children = StructValue::GetChildren(input);
-			for (idx_t i = 0; i < child_types.size(); i++) {
-				StructStats::SetChildStats(result, i, FromConstant(struct_children[i]));
-			}
-		}
-		return result;
-	}
-	case StatisticsType::ARRAY_STATS: {
-		auto result = ArrayStats::CreateEmpty(input.type());
-		auto &child_stats = ArrayStats::GetChildStats(result);
-		if (!input.IsNull()) {
-			auto &list_children = ArrayValue::GetChildren(input);
-			for (auto &child_element : list_children) {
-				child_stats.Merge(FromConstant(child_element));
-			}
-		}
-		return result;
-	}
-	default:
-		return BaseStatistics(input.type());
-	}
-}
-
-BaseStatistics BaseStatistics::FromConstant(const Value &input) {
-	auto result = FromConstantType(input);
-	result.SetDistinctCount(1);
-	if (input.IsNull()) {
-		result.Set(StatsInfo::CAN_HAVE_NULL_VALUES);
-		result.Set(StatsInfo::CANNOT_HAVE_VALID_VALUES);
-	} else {
-		result.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
-		result.Set(StatsInfo::CAN_HAVE_VALID_VALUES);
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/column_statistics.cpp b/src/duckdb/src/storage/statistics/column_statistics.cpp
deleted file mode 100644
index 19784bc91..000000000
--- a/src/duckdb/src/storage/statistics/column_statistics.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "duckdb/storage/statistics/column_statistics.hpp"
-
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-
-ColumnStatistics::ColumnStatistics(BaseStatistics stats_p) : stats(std::move(stats_p)) {
-	if (DistinctStatistics::TypeIsSupported(stats.GetType())) {
-		distinct_stats = make_uniq<DistinctStatistics>();
-	}
-}
-ColumnStatistics::ColumnStatistics(BaseStatistics stats_p, unique_ptr<DistinctStatistics> distinct_stats_p)
-    : stats(std::move(stats_p)), distinct_stats(std::move(distinct_stats_p)) {
-}
-
-shared_ptr<ColumnStatistics> ColumnStatistics::CreateEmptyStats(const LogicalType &type) {
-	return make_shared_ptr<ColumnStatistics>(BaseStatistics::CreateEmpty(type));
-}
-
-void ColumnStatistics::Merge(ColumnStatistics &other) {
-	stats.Merge(other.stats);
-	if (distinct_stats && other.distinct_stats) {
-		distinct_stats->Merge(*other.distinct_stats);
-	}
-}
-
-BaseStatistics &ColumnStatistics::Statistics() {
-	return stats;
-}
-
-bool ColumnStatistics::HasDistinctStats() {
-	return distinct_stats.get();
-}
-
-DistinctStatistics &ColumnStatistics::DistinctStats() {
-	if (!distinct_stats) {
-		throw InternalException("DistinctStats called without distinct_stats");
-	}
-	return *distinct_stats;
-}
-
-void ColumnStatistics::SetDistinct(unique_ptr<DistinctStatistics> distinct) {
-	this->distinct_stats = std::move(distinct);
-}
-
-void ColumnStatistics::UpdateDistinctStatistics(Vector &v, idx_t count, Vector &hashes) {
-	if (!distinct_stats) {
-		return;
-	}
-	// we use a sample to update the distinct statistics for performance reasons
-	distinct_stats->UpdateSample(v, count, hashes);
-}
-
-shared_ptr<ColumnStatistics> ColumnStatistics::Copy() const {
-	return make_shared_ptr<ColumnStatistics>(stats.Copy(), distinct_stats ? distinct_stats->Copy() : nullptr);
-}
-
-void ColumnStatistics::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(100, "statistics", stats);
-	serializer.WritePropertyWithDefault(101, "distinct", distinct_stats, unique_ptr<DistinctStatistics>());
-}
-
-shared_ptr<ColumnStatistics> ColumnStatistics::Deserialize(Deserializer &deserializer) {
-	auto stats = deserializer.ReadProperty<BaseStatistics>(100, "statistics");
-	auto distinct_stats = deserializer.ReadPropertyWithExplicitDefault<unique_ptr<DistinctStatistics>>(
-	    101, "distinct", unique_ptr<DistinctStatistics>());
-	return make_shared_ptr<ColumnStatistics>(std::move(stats), std::move(distinct_stats));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/distinct_statistics.cpp b/src/duckdb/src/storage/statistics/distinct_statistics.cpp
deleted file mode 100644
index ddadc997e..000000000
--- a/src/duckdb/src/storage/statistics/distinct_statistics.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
-#include <math.h>
-
-namespace duckdb {
-
-DistinctStatistics::DistinctStatistics() : log(make_uniq<HyperLogLog>()), sample_count(0), total_count(0) {
-}
-
-DistinctStatistics::DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count)
-    : log(std::move(log)), sample_count(sample_count), total_count(total_count) {
-}
-
-unique_ptr<DistinctStatistics> DistinctStatistics::Copy() const {
-	return make_uniq<DistinctStatistics>(log->Copy(), sample_count, total_count);
-}
-
-void DistinctStatistics::Merge(const DistinctStatistics &other) {
-	log->Merge(*other.log);
-	sample_count += other.sample_count;
-	total_count += other.total_count;
-}
-
-void DistinctStatistics::UpdateSample(Vector &new_data, idx_t count, Vector &hashes) {
-	total_count += count;
-	const auto original_count = count;
-	const auto sample_rate = new_data.GetType().IsIntegral() ? INTEGRAL_SAMPLE_RATE : BASE_SAMPLE_RATE;
-	// Sample up to 'sample_rate' of STANDARD_VECTOR_SIZE of this vector (at least 1)
-	count = MaxValue<idx_t>(LossyNumericCast<idx_t>(sample_rate * static_cast<double>(STANDARD_VECTOR_SIZE)), 1);
-	// But never more than the original count
-	count = MinValue<idx_t>(count, original_count);
-
-	UpdateInternal(new_data, count, hashes);
-}
-
-void DistinctStatistics::Update(Vector &new_data, idx_t count, Vector &hashes) {
-	total_count += count;
-	UpdateInternal(new_data, count, hashes);
-}
-
-void DistinctStatistics::UpdateInternal(Vector &new_data, idx_t count, Vector &hashes) {
-	sample_count += count;
-	VectorOperations::Hash(new_data, hashes, count);
-
-	log->Update(new_data, hashes, count);
-}
-
-string DistinctStatistics::ToString() const {
-	return StringUtil::Format("[Approx Unique: %llu]", GetCount());
-}
-
-idx_t DistinctStatistics::GetCount() const {
-	if (sample_count == 0 || total_count == 0) {
-		return 0;
-	}
-
-	double u = static_cast<double>(MinValue<idx_t>(log->Count(), sample_count));
-	double s = static_cast<double>(sample_count.load());
-	double n = static_cast<double>(total_count.load());
-
-	// Assume this proportion of the the sampled values occurred only once
-	double u1 = pow(u / s, 2) * u;
-
-	// Estimate total uniques using Good Turing Estimation
-	idx_t estimate = LossyNumericCast<idx_t>(u + u1 / s * (n - s));
-	return MinValue<idx_t>(estimate, total_count);
-}
-
-bool DistinctStatistics::TypeIsSupported(const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT:
-	case PhysicalType::ARRAY:
-		return false; // We don't support nested types
-	case PhysicalType::BIT:
-	case PhysicalType::BOOL:
-		return false; // Doesn't make much sense
-	default:
-		return true;
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/list_stats.cpp b/src/duckdb/src/storage/statistics/list_stats.cpp
deleted file mode 100644
index d6b658af3..000000000
--- a/src/duckdb/src/storage/statistics/list_stats.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "duckdb/storage/statistics/list_stats.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-void ListStats::Construct(BaseStatistics &stats) {
-	stats.child_stats = unsafe_unique_array<BaseStatistics>(new BaseStatistics[1]);
-	BaseStatistics::Construct(stats.child_stats[0], ListType::GetChildType(stats.GetType()));
-}
-
-BaseStatistics ListStats::CreateUnknown(LogicalType type) {
-	auto &child_type = ListType::GetChildType(type);
-	BaseStatistics result(std::move(type));
-	result.InitializeUnknown();
-	result.child_stats[0].Copy(BaseStatistics::CreateUnknown(child_type));
-	return result;
-}
-
-BaseStatistics ListStats::CreateEmpty(LogicalType type) {
-	auto &child_type = ListType::GetChildType(type);
-	BaseStatistics result(std::move(type));
-	result.InitializeEmpty();
-	result.child_stats[0].Copy(BaseStatistics::CreateEmpty(child_type));
-	return result;
-}
-
-void ListStats::Copy(BaseStatistics &stats, const BaseStatistics &other) {
-	D_ASSERT(stats.child_stats);
-	D_ASSERT(other.child_stats);
-	stats.child_stats[0].Copy(other.child_stats[0]);
-}
-
-const BaseStatistics &ListStats::GetChildStats(const BaseStatistics &stats) {
-	if (stats.GetStatsType() != StatisticsType::LIST_STATS) {
-		throw InternalException("ListStats::GetChildStats called on stats that is not a list");
-	}
-	D_ASSERT(stats.child_stats);
-	return stats.child_stats[0];
-}
-BaseStatistics &ListStats::GetChildStats(BaseStatistics &stats) {
-	if (stats.GetStatsType() != StatisticsType::LIST_STATS) {
-		throw InternalException("ListStats::GetChildStats called on stats that is not a list");
-	}
-	D_ASSERT(stats.child_stats);
-	return stats.child_stats[0];
-}
-
-void ListStats::SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats) {
-	if (!new_stats) {
-		stats.child_stats[0].Copy(BaseStatistics::CreateUnknown(ListType::GetChildType(stats.GetType())));
-	} else {
-		stats.child_stats[0].Copy(*new_stats);
-	}
-}
-
-void ListStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
-	if (other.GetType().id() == LogicalTypeId::VALIDITY) {
-		return;
-	}
-
-	auto &child_stats = ListStats::GetChildStats(stats);
-	auto &other_child_stats = ListStats::GetChildStats(other);
-	child_stats.Merge(other_child_stats);
-}
-
-void ListStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
-	auto &child_stats = ListStats::GetChildStats(stats);
-	serializer.WriteProperty(200, "child_stats", child_stats);
-}
-
-void ListStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
-	auto &type = base.GetType();
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto &child_type = ListType::GetChildType(type);
-
-	// Push the logical type of the child type to the deserialization context
-	deserializer.Set<const LogicalType &>(child_type);
-	base.child_stats[0].Copy(deserializer.ReadProperty<BaseStatistics>(200, "child_stats"));
-	deserializer.Unset<LogicalType>();
-}
-
-string ListStats::ToString(const BaseStatistics &stats) {
-	auto &child_stats = ListStats::GetChildStats(stats);
-	return StringUtil::Format("[%s]", child_stats.ToString());
-}
-
-void ListStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
-	auto &child_stats = ListStats::GetChildStats(stats);
-	auto &child_entry = ListVector::GetEntry(vector);
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-
-	auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
-	idx_t total_list_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		auto list = list_data[index];
-		if (vdata.validity.RowIsValid(index)) {
-			for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-				total_list_count++;
-			}
-		}
-	}
-	SelectionVector list_sel(total_list_count);
-	idx_t list_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		auto list = list_data[index];
-		if (vdata.validity.RowIsValid(index)) {
-			for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-				list_sel.set_index(list_count++, list.offset + list_idx);
-			}
-		}
-	}
-
-	child_stats.Verify(child_entry, list_sel, list_count);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/numeric_stats.cpp b/src/duckdb/src/storage/statistics/numeric_stats.cpp
deleted file mode 100644
index a93798122..000000000
--- a/src/duckdb/src/storage/statistics/numeric_stats.cpp
+++ /dev/null
@@ -1,623 +0,0 @@
-#include "duckdb/storage/statistics/numeric_stats.hpp"
-
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-BaseStatistics NumericStats::CreateUnknown(LogicalType type) {
-	BaseStatistics result(std::move(type));
-	result.InitializeUnknown();
-	SetMin(result, Value(result.GetType()));
-	SetMax(result, Value(result.GetType()));
-	return result;
-}
-
-BaseStatistics NumericStats::CreateEmpty(LogicalType type) {
-	BaseStatistics result(std::move(type));
-	result.InitializeEmpty();
-	SetMin(result, Value::MaximumValue(result.GetType()));
-	SetMax(result, Value::MinimumValue(result.GetType()));
-	return result;
-}
-
-NumericStatsData &NumericStats::GetDataUnsafe(BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::NUMERIC_STATS);
-	return stats.stats_union.numeric_data;
-}
-
-const NumericStatsData &NumericStats::GetDataUnsafe(const BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::NUMERIC_STATS);
-	return stats.stats_union.numeric_data;
-}
-
-void NumericStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
-	if (other.GetType().id() == LogicalTypeId::VALIDITY) {
-		return;
-	}
-	D_ASSERT(stats.GetType() == other.GetType());
-	if (NumericStats::HasMin(other) && NumericStats::HasMin(stats)) {
-		auto other_min = NumericStats::Min(other);
-		if (other_min < NumericStats::Min(stats)) {
-			NumericStats::SetMin(stats, other_min);
-		}
-	} else {
-		NumericStats::SetMin(stats, Value());
-	}
-	if (NumericStats::HasMax(other) && NumericStats::HasMax(stats)) {
-		auto other_max = NumericStats::Max(other);
-		if (other_max > NumericStats::Max(stats)) {
-			NumericStats::SetMax(stats, other_max);
-		}
-	} else {
-		NumericStats::SetMax(stats, Value());
-	}
-}
-
-struct GetNumericValueUnion {
-	template <class T>
-	static T Operation(const NumericValueUnion &v);
-};
-
-template <>
-int8_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.tinyint;
-}
-
-template <>
-int16_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.smallint;
-}
-
-template <>
-int32_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.integer;
-}
-
-template <>
-int64_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.bigint;
-}
-
-template <>
-hugeint_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.hugeint;
-}
-
-template <>
-uhugeint_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.uhugeint;
-}
-
-template <>
-uint8_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.utinyint;
-}
-
-template <>
-uint16_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.usmallint;
-}
-
-template <>
-uint32_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.uinteger;
-}
-
-template <>
-uint64_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.ubigint;
-}
-
-template <>
-float GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.float_;
-}
-
-template <>
-double GetNumericValueUnion::Operation(const NumericValueUnion &v) {
-	return v.value_.double_;
-}
-
-template <class T>
-T NumericStats::GetMinUnsafe(const BaseStatistics &stats) {
-	return GetNumericValueUnion::Operation<T>(NumericStats::GetDataUnsafe(stats).min);
-}
-
-template <class T>
-T NumericStats::GetMaxUnsafe(const BaseStatistics &stats) {
-	return GetNumericValueUnion::Operation<T>(NumericStats::GetDataUnsafe(stats).max);
-}
-
-template <class T>
-bool ConstantExactRange(T min, T max, T constant) {
-	return Equals::Operation(constant, min) && Equals::Operation(constant, max);
-}
-
-template <class T>
-bool ConstantValueInRange(T min, T max, T constant) {
-	return !(LessThan::Operation(constant, min) || GreaterThan::Operation(constant, max));
-}
-
-template <class T>
-FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, ExpressionType comparison_type, T min_value,
-                                            T max_value, T constant) {
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		if (ConstantExactRange(min_value, max_value, constant)) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		if (ConstantValueInRange(min_value, max_value, constant)) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		if (!ConstantValueInRange(min_value, max_value, constant)) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (ConstantExactRange(min_value, max_value, constant)) {
-			// corner case of a cluster with one numeric equal to the target constant
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// GreaterThanEquals::Operation(X, C)
-		// this can be true only if max(X) >= C
-		// if min(X) >= C, then this is always true
-		if (GreaterThanEquals::Operation(min_value, constant)) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (GreaterThanEquals::Operation(max_value, constant)) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_GREATERTHAN:
-		// GreaterThan::Operation(X, C)
-		// this can be true only if max(X) > C
-		// if min(X) > C, then this is always true
-		if (GreaterThan::Operation(min_value, constant)) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (GreaterThan::Operation(max_value, constant)) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// LessThanEquals::Operation(X, C)
-		// this can be true only if min(X) <= C
-		// if max(X) <= C, then this is always true
-		if (LessThanEquals::Operation(max_value, constant)) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (LessThanEquals::Operation(min_value, constant)) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHAN:
-		// LessThan::Operation(X, C)
-		// this can be true only if min(X) < C
-		// if max(X) < C, then this is always true
-		if (LessThan::Operation(max_value, constant)) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (LessThan::Operation(min_value, constant)) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	default:
-		throw InternalException("Expression type in zonemap check not implemented");
-	}
-}
-
-template <class T>
-FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, ExpressionType comparison_type,
-                                            array_ptr<Value> constants) {
-	T min_value = NumericStats::GetMinUnsafe<T>(stats);
-	T max_value = NumericStats::GetMaxUnsafe<T>(stats);
-	for (auto &constant_value : constants) {
-		D_ASSERT(constant_value.type() == stats.GetType());
-		D_ASSERT(!constant_value.IsNull());
-		T constant = constant_value.GetValueUnsafe<T>();
-		auto prune_result = CheckZonemapTemplated(stats, comparison_type, min_value, max_value, constant);
-		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-	}
-	return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-}
-
-FilterPropagateResult NumericStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-                                                 array_ptr<Value> constants) {
-	if (!NumericStats::HasMinMax(stats)) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	switch (stats.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		return CheckZonemapTemplated<int8_t>(stats, comparison_type, constants);
-	case PhysicalType::INT16:
-		return CheckZonemapTemplated<int16_t>(stats, comparison_type, constants);
-	case PhysicalType::INT32:
-		return CheckZonemapTemplated<int32_t>(stats, comparison_type, constants);
-	case PhysicalType::INT64:
-		return CheckZonemapTemplated<int64_t>(stats, comparison_type, constants);
-	case PhysicalType::UINT8:
-		return CheckZonemapTemplated<uint8_t>(stats, comparison_type, constants);
-	case PhysicalType::UINT16:
-		return CheckZonemapTemplated<uint16_t>(stats, comparison_type, constants);
-	case PhysicalType::UINT32:
-		return CheckZonemapTemplated<uint32_t>(stats, comparison_type, constants);
-	case PhysicalType::UINT64:
-		return CheckZonemapTemplated<uint64_t>(stats, comparison_type, constants);
-	case PhysicalType::INT128:
-		return CheckZonemapTemplated<hugeint_t>(stats, comparison_type, constants);
-	case PhysicalType::UINT128:
-		return CheckZonemapTemplated<uhugeint_t>(stats, comparison_type, constants);
-	case PhysicalType::FLOAT:
-		return CheckZonemapTemplated<float>(stats, comparison_type, constants);
-	case PhysicalType::DOUBLE:
-		return CheckZonemapTemplated<double>(stats, comparison_type, constants);
-	default:
-		throw InternalException("Unsupported type for NumericStats::CheckZonemap");
-	}
-}
-
-bool NumericStats::IsConstant(const BaseStatistics &stats) {
-	return NumericStats::Max(stats) <= NumericStats::Min(stats);
-}
-
-void SetNumericValueInternal(const Value &input, const LogicalType &type, NumericValueUnion &val, bool &has_val) {
-	if (input.IsNull()) {
-		has_val = false;
-		return;
-	}
-	if (input.type().InternalType() != type.InternalType()) {
-		throw InternalException("SetMin or SetMax called with Value that does not match statistics' column value");
-	}
-	has_val = true;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		val.value_.boolean = BooleanValue::Get(input);
-		break;
-	case PhysicalType::INT8:
-		val.value_.tinyint = TinyIntValue::Get(input);
-		break;
-	case PhysicalType::INT16:
-		val.value_.smallint = SmallIntValue::Get(input);
-		break;
-	case PhysicalType::INT32:
-		val.value_.integer = IntegerValue::Get(input);
-		break;
-	case PhysicalType::INT64:
-		val.value_.bigint = BigIntValue::Get(input);
-		break;
-	case PhysicalType::UINT8:
-		val.value_.utinyint = UTinyIntValue::Get(input);
-		break;
-	case PhysicalType::UINT16:
-		val.value_.usmallint = USmallIntValue::Get(input);
-		break;
-	case PhysicalType::UINT32:
-		val.value_.uinteger = UIntegerValue::Get(input);
-		break;
-	case PhysicalType::UINT64:
-		val.value_.ubigint = UBigIntValue::Get(input);
-		break;
-	case PhysicalType::INT128:
-		val.value_.hugeint = HugeIntValue::Get(input);
-		break;
-	case PhysicalType::UINT128:
-		val.value_.uhugeint = UhugeIntValue::Get(input);
-		break;
-	case PhysicalType::FLOAT:
-		val.value_.float_ = FloatValue::Get(input);
-		break;
-	case PhysicalType::DOUBLE:
-		val.value_.double_ = DoubleValue::Get(input);
-		break;
-	default:
-		throw InternalException("Unsupported type for NumericStatistics::SetValueInternal");
-	}
-}
-
-void NumericStats::SetMin(BaseStatistics &stats, const Value &new_min) {
-	auto &data = NumericStats::GetDataUnsafe(stats);
-	SetNumericValueInternal(new_min, stats.GetType(), data.min, data.has_min);
-}
-
-void NumericStats::SetMax(BaseStatistics &stats, const Value &new_max) {
-	auto &data = NumericStats::GetDataUnsafe(stats);
-	SetNumericValueInternal(new_max, stats.GetType(), data.max, data.has_max);
-}
-
-Value NumericValueUnionToValueInternal(const LogicalType &type, const NumericValueUnion &val) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		return Value::BOOLEAN(val.value_.boolean);
-	case PhysicalType::INT8:
-		return Value::TINYINT(val.value_.tinyint);
-	case PhysicalType::INT16:
-		return Value::SMALLINT(val.value_.smallint);
-	case PhysicalType::INT32:
-		return Value::INTEGER(val.value_.integer);
-	case PhysicalType::INT64:
-		return Value::BIGINT(val.value_.bigint);
-	case PhysicalType::UINT8:
-		return Value::UTINYINT(val.value_.utinyint);
-	case PhysicalType::UINT16:
-		return Value::USMALLINT(val.value_.usmallint);
-	case PhysicalType::UINT32:
-		return Value::UINTEGER(val.value_.uinteger);
-	case PhysicalType::UINT64:
-		return Value::UBIGINT(val.value_.ubigint);
-	case PhysicalType::INT128:
-		return Value::HUGEINT(val.value_.hugeint);
-	case PhysicalType::UINT128:
-		return Value::UHUGEINT(val.value_.uhugeint);
-	case PhysicalType::FLOAT:
-		return Value::FLOAT(val.value_.float_);
-	case PhysicalType::DOUBLE:
-		return Value::DOUBLE(val.value_.double_);
-	default:
-		throw InternalException("Unsupported type for NumericValueUnionToValue");
-	}
-}
-
-Value NumericValueUnionToValue(const LogicalType &type, const NumericValueUnion &val) {
-	Value result = NumericValueUnionToValueInternal(type, val);
-	result.GetTypeMutable() = type;
-	return result;
-}
-
-bool NumericStats::HasMinMax(const BaseStatistics &stats) {
-	return NumericStats::HasMin(stats) && NumericStats::HasMax(stats);
-}
-
-bool NumericStats::HasMin(const BaseStatistics &stats) {
-	if (stats.GetType().id() == LogicalTypeId::SQLNULL) {
-		return false;
-	}
-	return NumericStats::GetDataUnsafe(stats).has_min;
-}
-
-bool NumericStats::HasMax(const BaseStatistics &stats) {
-	if (stats.GetType().id() == LogicalTypeId::SQLNULL) {
-		return false;
-	}
-	return NumericStats::GetDataUnsafe(stats).has_max;
-}
-
-Value NumericStats::Min(const BaseStatistics &stats) {
-	if (!NumericStats::HasMin(stats)) {
-		throw InternalException("Min() called on statistics that does not have min");
-	}
-	return NumericValueUnionToValue(stats.GetType(), NumericStats::GetDataUnsafe(stats).min);
-}
-
-Value NumericStats::Max(const BaseStatistics &stats) {
-	if (!NumericStats::HasMax(stats)) {
-		throw InternalException("Max() called on statistics that does not have max");
-	}
-	return NumericValueUnionToValue(stats.GetType(), NumericStats::GetDataUnsafe(stats).max);
-}
-
-Value NumericStats::MinOrNull(const BaseStatistics &stats) {
-	if (!NumericStats::HasMin(stats)) {
-		return Value(stats.GetType());
-	}
-	return NumericStats::Min(stats);
-}
-
-Value NumericStats::MaxOrNull(const BaseStatistics &stats) {
-	if (!NumericStats::HasMax(stats)) {
-		return Value(stats.GetType());
-	}
-	return NumericStats::Max(stats);
-}
-
-static void SerializeNumericStatsValue(const LogicalType &type, NumericValueUnion val, bool has_value,
-                                       Serializer &serializer) {
-	serializer.WriteProperty(100, "has_value", has_value);
-	if (!has_value) {
-		return;
-	}
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		serializer.WriteProperty(101, "value", val.value_.boolean);
-		break;
-	case PhysicalType::INT8:
-		serializer.WriteProperty(101, "value", val.value_.tinyint);
-		break;
-	case PhysicalType::INT16:
-		serializer.WriteProperty(101, "value", val.value_.smallint);
-		break;
-	case PhysicalType::INT32:
-		serializer.WriteProperty(101, "value", val.value_.integer);
-		break;
-	case PhysicalType::INT64:
-		serializer.WriteProperty(101, "value", val.value_.bigint);
-		break;
-	case PhysicalType::UINT8:
-		serializer.WriteProperty(101, "value", val.value_.utinyint);
-		break;
-	case PhysicalType::UINT16:
-		serializer.WriteProperty(101, "value", val.value_.usmallint);
-		break;
-	case PhysicalType::UINT32:
-		serializer.WriteProperty(101, "value", val.value_.uinteger);
-		break;
-	case PhysicalType::UINT64:
-		serializer.WriteProperty(101, "value", val.value_.ubigint);
-		break;
-	case PhysicalType::INT128:
-		serializer.WriteProperty(101, "value", val.value_.hugeint);
-		break;
-	case PhysicalType::UINT128:
-		serializer.WriteProperty(101, "value", val.value_.uhugeint);
-		break;
-	case PhysicalType::FLOAT:
-		serializer.WriteProperty(101, "value", val.value_.float_);
-		break;
-	case PhysicalType::DOUBLE:
-		serializer.WriteProperty(101, "value", val.value_.double_);
-		break;
-	default:
-		throw InternalException("Unsupported type for serializing numeric statistics");
-	}
-}
-
-static void DeserializeNumericStatsValue(const LogicalType &type, NumericValueUnion &result, bool &has_stats,
-                                         Deserializer &deserializer) {
-	auto has_value = deserializer.ReadProperty<bool>(100, "has_value");
-	if (!has_value) {
-		has_stats = false;
-		return;
-	}
-	has_stats = true;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		result.value_.boolean = deserializer.ReadProperty<bool>(101, "value");
-		break;
-	case PhysicalType::INT8:
-		result.value_.tinyint = deserializer.ReadProperty<int8_t>(101, "value");
-		break;
-	case PhysicalType::INT16:
-		result.value_.smallint = deserializer.ReadProperty<int16_t>(101, "value");
-		break;
-	case PhysicalType::INT32:
-		result.value_.integer = deserializer.ReadProperty<int32_t>(101, "value");
-		break;
-	case PhysicalType::INT64:
-		result.value_.bigint = deserializer.ReadProperty<int64_t>(101, "value");
-		break;
-	case PhysicalType::UINT8:
-		result.value_.utinyint = deserializer.ReadProperty<uint8_t>(101, "value");
-		break;
-	case PhysicalType::UINT16:
-		result.value_.usmallint = deserializer.ReadProperty<uint16_t>(101, "value");
-		break;
-	case PhysicalType::UINT32:
-		result.value_.uinteger = deserializer.ReadProperty<uint32_t>(101, "value");
-		break;
-	case PhysicalType::UINT64:
-		result.value_.ubigint = deserializer.ReadProperty<uint64_t>(101, "value");
-		break;
-	case PhysicalType::INT128:
-		result.value_.hugeint = deserializer.ReadProperty<hugeint_t>(101, "value");
-		break;
-	case PhysicalType::UINT128:
-		result.value_.uhugeint = deserializer.ReadProperty<uhugeint_t>(101, "value");
-		break;
-	case PhysicalType::FLOAT:
-		result.value_.float_ = deserializer.ReadProperty<float>(101, "value");
-		break;
-	case PhysicalType::DOUBLE:
-		result.value_.double_ = deserializer.ReadProperty<double>(101, "value");
-		break;
-	default:
-		throw InternalException("Unsupported type for serializing numeric statistics");
-	}
-}
-
-void NumericStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
-	auto &numeric_stats = NumericStats::GetDataUnsafe(stats);
-	serializer.WriteObject(200, "max", [&](Serializer &object) {
-		SerializeNumericStatsValue(stats.GetType(), numeric_stats.min, numeric_stats.has_min, object);
-	});
-	serializer.WriteObject(201, "min", [&](Serializer &object) {
-		SerializeNumericStatsValue(stats.GetType(), numeric_stats.max, numeric_stats.has_max, object);
-	});
-}
-
-void NumericStats::Deserialize(Deserializer &deserializer, BaseStatistics &result) {
-	auto &numeric_stats = NumericStats::GetDataUnsafe(result);
-
-	deserializer.ReadObject(200, "max", [&](Deserializer &object) {
-		DeserializeNumericStatsValue(result.GetType(), numeric_stats.min, numeric_stats.has_min, object);
-	});
-	deserializer.ReadObject(201, "min", [&](Deserializer &object) {
-		DeserializeNumericStatsValue(result.GetType(), numeric_stats.max, numeric_stats.has_max, object);
-	});
-}
-
-string NumericStats::ToString(const BaseStatistics &stats) {
-	return StringUtil::Format("[Min: %s, Max: %s]", NumericStats::MinOrNull(stats).ToString(),
-	                          NumericStats::MaxOrNull(stats).ToString());
-}
-
-template <class T>
-void NumericStats::TemplatedVerify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel,
-                                   idx_t count) {
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-
-	auto data = UnifiedVectorFormat::GetData<T>(vdata);
-	auto min_value = NumericStats::MinOrNull(stats);
-	auto max_value = NumericStats::MaxOrNull(stats);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		if (!vdata.validity.RowIsValid(index)) {
-			continue;
-		}
-		if (!min_value.IsNull() && LessThan::Operation(data[index], min_value.GetValueUnsafe<T>())) { // LCOV_EXCL_START
-			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
-			                        stats.ToString(), vector.ToString(count));
-		} // LCOV_EXCL_STOP
-		if (!max_value.IsNull() && GreaterThan::Operation(data[index], max_value.GetValueUnsafe<T>())) {
-			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
-			                        stats.ToString(), vector.ToString(count));
-		}
-	}
-}
-
-void NumericStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
-	auto &type = stats.GetType();
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		break;
-	case PhysicalType::INT8:
-		TemplatedVerify<int8_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedVerify<int16_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedVerify<int32_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedVerify<int64_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedVerify<uint8_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedVerify<uint16_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedVerify<uint32_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedVerify<uint64_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedVerify<hugeint_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::UINT128:
-		TemplatedVerify<uhugeint_t>(stats, vector, sel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedVerify<float>(stats, vector, sel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedVerify<double>(stats, vector, sel, count);
-		break;
-	default:
-		throw InternalException("Unsupported type %s for numeric statistics verify", type.ToString());
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/segment_statistics.cpp b/src/duckdb/src/storage/statistics/segment_statistics.cpp
deleted file mode 100644
index 697175440..000000000
--- a/src/duckdb/src/storage/statistics/segment_statistics.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-
-#include "duckdb/common/exception.hpp"
-
-namespace duckdb {
-
-SegmentStatistics::SegmentStatistics(LogicalType type) : statistics(BaseStatistics::CreateEmpty(std::move(type))) {
-}
-
-SegmentStatistics::SegmentStatistics(BaseStatistics stats) : statistics(std::move(stats)) {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/string_stats.cpp b/src/duckdb/src/storage/statistics/string_stats.cpp
deleted file mode 100644
index 691bae090..000000000
--- a/src/duckdb/src/storage/statistics/string_stats.cpp
+++ /dev/null
@@ -1,310 +0,0 @@
-#include "duckdb/storage/statistics/string_stats.hpp"
-
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "utf8proc_wrapper.hpp"
-
-namespace duckdb {
-
-BaseStatistics StringStats::CreateUnknown(LogicalType type) {
-	BaseStatistics result(std::move(type));
-	result.InitializeUnknown();
-	auto &string_data = StringStats::GetDataUnsafe(result);
-	for (idx_t i = 0; i < StringStatsData::MAX_STRING_MINMAX_SIZE; i++) {
-		string_data.min[i] = 0;
-		string_data.max[i] = 0xFF;
-	}
-	string_data.max_string_length = 0;
-	string_data.has_max_string_length = false;
-	string_data.has_unicode = true;
-	return result;
-}
-
-BaseStatistics StringStats::CreateEmpty(LogicalType type) {
-	BaseStatistics result(std::move(type));
-	result.InitializeEmpty();
-	auto &string_data = StringStats::GetDataUnsafe(result);
-	for (idx_t i = 0; i < StringStatsData::MAX_STRING_MINMAX_SIZE; i++) {
-		string_data.min[i] = 0xFF;
-		string_data.max[i] = 0;
-	}
-	string_data.max_string_length = 0;
-	string_data.has_max_string_length = true;
-	string_data.has_unicode = false;
-	return result;
-}
-
-StringStatsData &StringStats::GetDataUnsafe(BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRING_STATS);
-	return stats.stats_union.string_data;
-}
-
-const StringStatsData &StringStats::GetDataUnsafe(const BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRING_STATS);
-	return stats.stats_union.string_data;
-}
-
-bool StringStats::HasMaxStringLength(const BaseStatistics &stats) {
-	if (stats.GetType().id() == LogicalTypeId::SQLNULL) {
-		return false;
-	}
-	return StringStats::GetDataUnsafe(stats).has_max_string_length;
-}
-
-uint32_t StringStats::MaxStringLength(const BaseStatistics &stats) {
-	if (!HasMaxStringLength(stats)) {
-		throw InternalException("MaxStringLength called on statistics that does not have a max string length");
-	}
-	return StringStats::GetDataUnsafe(stats).max_string_length;
-}
-
-bool StringStats::CanContainUnicode(const BaseStatistics &stats) {
-	if (stats.GetType().id() == LogicalTypeId::SQLNULL) {
-		return true;
-	}
-	return StringStats::GetDataUnsafe(stats).has_unicode;
-}
-
-string GetStringMinMaxValue(const data_t data[]) {
-	idx_t len;
-	for (len = 0; len < StringStatsData::MAX_STRING_MINMAX_SIZE; len++) {
-		if (!data[len]) {
-			break;
-		}
-	}
-	return string(const_char_ptr_cast(data), len);
-}
-
-string StringStats::Min(const BaseStatistics &stats) {
-	return GetStringMinMaxValue(StringStats::GetDataUnsafe(stats).min);
-}
-
-string StringStats::Max(const BaseStatistics &stats) {
-	return GetStringMinMaxValue(StringStats::GetDataUnsafe(stats).max);
-}
-
-void StringStats::ResetMaxStringLength(BaseStatistics &stats) {
-	StringStats::GetDataUnsafe(stats).has_max_string_length = false;
-}
-
-void StringStats::SetContainsUnicode(BaseStatistics &stats) {
-	StringStats::GetDataUnsafe(stats).has_unicode = true;
-}
-
-void StringStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-	serializer.WriteProperty(200, "min", string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	serializer.WriteProperty(201, "max", string_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	serializer.WriteProperty(202, "has_unicode", string_data.has_unicode);
-	serializer.WriteProperty(203, "has_max_string_length", string_data.has_max_string_length);
-	serializer.WriteProperty(204, "max_string_length", string_data.max_string_length);
-}
-
-void StringStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
-	auto &string_data = StringStats::GetDataUnsafe(base);
-	deserializer.ReadProperty(200, "min", string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	deserializer.ReadProperty(201, "max", string_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	deserializer.ReadProperty(202, "has_unicode", string_data.has_unicode);
-	deserializer.ReadProperty(203, "has_max_string_length", string_data.has_max_string_length);
-	deserializer.ReadProperty(204, "max_string_length", string_data.max_string_length);
-}
-
-static int StringValueComparison(const_data_ptr_t data, idx_t len, const_data_ptr_t comparison) {
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] < comparison[i]) {
-			return -1;
-		} else if (data[i] > comparison[i]) {
-			return 1;
-		}
-	}
-	return 0;
-}
-
-static void ConstructValue(const_data_ptr_t data, idx_t size, data_t target[]) {
-	idx_t value_size = size > StringStatsData::MAX_STRING_MINMAX_SIZE ? StringStatsData::MAX_STRING_MINMAX_SIZE : size;
-	memcpy(target, data, value_size);
-	for (idx_t i = value_size; i < StringStatsData::MAX_STRING_MINMAX_SIZE; i++) {
-		target[i] = '\0';
-	}
-}
-
-void StringStats::Update(BaseStatistics &stats, const string_t &value) {
-	auto data = const_data_ptr_cast(value.GetData());
-	auto size = value.GetSize();
-
-	//! we can only fit 8 bytes, so we might need to trim our string
-	// construct the value
-	data_t target[StringStatsData::MAX_STRING_MINMAX_SIZE];
-	ConstructValue(data, size, target);
-
-	// update the min and max
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-	if (StringValueComparison(target, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.min) < 0) {
-		memcpy(string_data.min, target, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	}
-	if (StringValueComparison(target, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.max) > 0) {
-		memcpy(string_data.max, target, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	}
-	if (size > string_data.max_string_length) {
-		string_data.max_string_length = UnsafeNumericCast<uint32_t>(size);
-	}
-	if (stats.GetType().id() == LogicalTypeId::VARCHAR && !string_data.has_unicode) {
-		auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(data), size);
-		if (unicode == UnicodeType::UNICODE) {
-			string_data.has_unicode = true;
-		} else if (unicode == UnicodeType::INVALID) {
-			throw ErrorManager::InvalidUnicodeError(string(const_char_ptr_cast(data), size),
-			                                        "segment statistics update");
-		}
-	}
-}
-
-void StringStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
-	if (other.GetType().id() == LogicalTypeId::VALIDITY) {
-		return;
-	}
-	if (other.GetType().id() == LogicalTypeId::SQLNULL) {
-		return;
-	}
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-	auto &other_data = StringStats::GetDataUnsafe(other);
-	if (StringValueComparison(other_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.min) < 0) {
-		memcpy(string_data.min, other_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	}
-	if (StringValueComparison(other_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.max) > 0) {
-		memcpy(string_data.max, other_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	}
-	string_data.has_unicode = string_data.has_unicode || other_data.has_unicode;
-	string_data.has_max_string_length = string_data.has_max_string_length && other_data.has_max_string_length;
-	string_data.max_string_length = MaxValue<uint32_t>(string_data.max_string_length, other_data.max_string_length);
-}
-
-FilterPropagateResult StringStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-                                                array_ptr<Value> constants) {
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-	for (auto &constant_value : constants) {
-		D_ASSERT(constant_value.type() == stats.GetType());
-		D_ASSERT(!constant_value.IsNull());
-		auto &constant = StringValue::Get(constant_value);
-		auto prune_result = CheckZonemap(string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.max,
-		                                 StringStatsData::MAX_STRING_MINMAX_SIZE, comparison_type, constant);
-		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-	}
-	return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-}
-
-FilterPropagateResult StringStats::CheckZonemap(const_data_ptr_t min_data, idx_t min_len, const_data_ptr_t max_data,
-                                                idx_t max_len, ExpressionType comparison_type, const string &constant) {
-	auto data = const_data_ptr_cast(constant.c_str());
-	idx_t size = constant.size();
-
-	int min_comp = StringValueComparison(data, MinValue(min_len, size), min_data);
-	int max_comp = StringValueComparison(data, MinValue(max_len, size), max_data);
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		if (min_comp >= 0 && max_comp <= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_NOTEQUAL:
-		if (min_comp < 0 || max_comp > 0) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		if (max_comp <= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		if (min_comp >= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	default:
-		throw InternalException("Expression type not implemented for string statistics zone map");
-	}
-}
-
-static idx_t GetValidMinMaxSubstring(const_data_ptr_t data) {
-	for (idx_t i = 0; i < StringStatsData::MAX_STRING_MINMAX_SIZE; i++) {
-		if (data[i] == '\0') {
-			return i;
-		}
-		if ((data[i] & 0x80) != 0) {
-			return i;
-		}
-	}
-	return StringStatsData::MAX_STRING_MINMAX_SIZE;
-}
-
-string StringStats::ToString(const BaseStatistics &stats) {
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-	idx_t min_len = GetValidMinMaxSubstring(string_data.min);
-	idx_t max_len = GetValidMinMaxSubstring(string_data.max);
-	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %s]",
-	                          string(const_char_ptr_cast(string_data.min), min_len),
-	                          string(const_char_ptr_cast(string_data.max), max_len),
-	                          string_data.has_unicode ? "true" : "false",
-	                          string_data.has_max_string_length ? to_string(string_data.max_string_length) : "?");
-}
-
-void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		if (!vdata.validity.RowIsValid(index)) {
-			continue;
-		}
-		auto value = data[index];
-		auto data = value.GetData();
-		auto len = value.GetSize();
-		// LCOV_EXCL_START
-		if (string_data.has_max_string_length && len > string_data.max_string_length) {
-			throw InternalException(
-			    "Statistics mismatch: string value exceeds maximum string length.\nStatistics: %s\nVector: %s",
-			    stats.ToString(), vector.ToString(count));
-		}
-		if (stats.GetType().id() == LogicalTypeId::VARCHAR && !string_data.has_unicode) {
-			auto unicode = Utf8Proc::Analyze(data, len);
-			if (unicode == UnicodeType::UNICODE) {
-				throw InternalException("Statistics mismatch: string value contains unicode, but statistics says it "
-				                        "shouldn't.\nStatistics: %s\nVector: %s",
-				                        stats.ToString(), vector.ToString(count));
-			} else if (unicode == UnicodeType::INVALID) {
-				throw InternalException("Invalid unicode detected in vector: %s", vector.ToString(count));
-			}
-		}
-		if (StringValueComparison(const_data_ptr_cast(data),
-		                          MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE), string_data.min) < 0) {
-			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
-			                        stats.ToString(), vector.ToString(count));
-		}
-		if (StringValueComparison(const_data_ptr_cast(data),
-		                          MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE), string_data.max) > 0) {
-			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
-			                        stats.ToString(), vector.ToString(count));
-		}
-		// LCOV_EXCL_STOP
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/statistics/struct_stats.cpp b/src/duckdb/src/storage/statistics/struct_stats.cpp
deleted file mode 100644
index 64993e04e..000000000
--- a/src/duckdb/src/storage/statistics/struct_stats.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
-namespace duckdb {
-
-void StructStats::Construct(BaseStatistics &stats) {
-	auto &child_types = StructType::GetChildTypes(stats.GetType());
-	stats.child_stats = unsafe_unique_array<BaseStatistics>(new BaseStatistics[child_types.size()]);
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		BaseStatistics::Construct(stats.child_stats[i], child_types[i].second);
-	}
-}
-
-BaseStatistics StructStats::CreateUnknown(LogicalType type) {
-	auto &child_types = StructType::GetChildTypes(type);
-	BaseStatistics result(std::move(type));
-	result.InitializeUnknown();
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		result.child_stats[i].Copy(BaseStatistics::CreateUnknown(child_types[i].second));
-	}
-	return result;
-}
-
-BaseStatistics StructStats::CreateEmpty(LogicalType type) {
-	auto &child_types = StructType::GetChildTypes(type);
-	BaseStatistics result(std::move(type));
-	result.InitializeEmpty();
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		result.child_stats[i].Copy(BaseStatistics::CreateEmpty(child_types[i].second));
-	}
-	return result;
-}
-
-const BaseStatistics *StructStats::GetChildStats(const BaseStatistics &stats) {
-	if (stats.GetStatsType() != StatisticsType::STRUCT_STATS) {
-		throw InternalException("Calling StructStats::GetChildStats on stats that is not a struct");
-	}
-	return stats.child_stats.get();
-}
-
-const BaseStatistics &StructStats::GetChildStats(const BaseStatistics &stats, idx_t i) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRUCT_STATS);
-	if (i >= StructType::GetChildCount(stats.GetType())) {
-		throw InternalException("Calling StructStats::GetChildStats but there are no stats for this index");
-	}
-	return stats.child_stats[i];
-}
-
-BaseStatistics &StructStats::GetChildStats(BaseStatistics &stats, idx_t i) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRUCT_STATS);
-	if (i >= StructType::GetChildCount(stats.GetType())) {
-		throw InternalException("Calling StructStats::GetChildStats but there are no stats for this index");
-	}
-	return stats.child_stats[i];
-}
-
-void StructStats::SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRUCT_STATS);
-	D_ASSERT(i < StructType::GetChildCount(stats.GetType()));
-	stats.child_stats[i].Copy(new_stats);
-}
-
-void StructStats::SetChildStats(BaseStatistics &stats, idx_t i, unique_ptr<BaseStatistics> new_stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRUCT_STATS);
-	if (!new_stats) {
-		StructStats::SetChildStats(stats, i,
-		                           BaseStatistics::CreateUnknown(StructType::GetChildType(stats.GetType(), i)));
-	} else {
-		StructStats::SetChildStats(stats, i, *new_stats);
-	}
-}
-
-void StructStats::Copy(BaseStatistics &stats, const BaseStatistics &other) {
-	auto count = StructType::GetChildCount(stats.GetType());
-	for (idx_t i = 0; i < count; i++) {
-		stats.child_stats[i].Copy(other.child_stats[i]);
-	}
-}
-
-void StructStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
-	if (other.GetType().id() == LogicalTypeId::VALIDITY) {
-		return;
-	}
-	D_ASSERT(stats.GetType().id() == other.GetType().id());
-	D_ASSERT(StructType::GetChildCount(stats.GetType()) == StructType::GetChildCount(other.GetType()));
-	auto child_count = StructType::GetChildCount(stats.GetType());
-	for (idx_t i = 0; i < child_count; i++) {
-		stats.child_stats[i].Merge(other.child_stats[i]);
-	}
-}
-
-void StructStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
-	auto child_stats = StructStats::GetChildStats(stats);
-	auto child_count = StructType::GetChildCount(stats.GetType());
-
-	serializer.WriteList(200, "child_stats", child_count,
-	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(child_stats[i]); });
-}
-
-void StructStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
-	auto &type = base.GetType();
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-
-	auto &child_types = StructType::GetChildTypes(type);
-
-	deserializer.ReadList(200, "child_stats", [&](Deserializer::List &list, idx_t i) {
-		deserializer.Set<const LogicalType &>(child_types[i].second);
-		auto stat = list.ReadElement<BaseStatistics>();
-		base.child_stats[i].Copy(stat);
-		deserializer.Unset<LogicalType>();
-	});
-}
-
-string StructStats::ToString(const BaseStatistics &stats) {
-	string result;
-	result += " {";
-	auto &child_types = StructType::GetChildTypes(stats.GetType());
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += child_types[i].first + ": " + stats.child_stats[i].ToString();
-	}
-	result += "}";
-	return result;
-}
-
-void StructStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
-	auto &child_entries = StructVector::GetEntries(vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		stats.child_stats[i].Verify(*child_entries[i], sel, count);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/storage_info.cpp b/src/duckdb/src/storage/storage_info.cpp
deleted file mode 100644
index b814fdc34..000000000
--- a/src/duckdb/src/storage/storage_info.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#include "duckdb/storage/storage_info.hpp"
-
-#include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/optional_idx.hpp"
-
-namespace duckdb {
-
-const uint64_t VERSION_NUMBER = 64;
-
-struct StorageVersionInfo {
-	const char *version_name;
-	idx_t storage_version;
-};
-
-struct SerializationVersionInfo {
-	const char *version_name;
-	idx_t serialization_version;
-};
-
-// These sections are automatically generated by scripts/generate_storage_info.py
-// Do not edit them manually, your changes will be overwritten
-// clang-format off
-// START OF STORAGE VERSION INFO
-const uint64_t DEFAULT_STORAGE_VERSION_INFO = 64;
-static const StorageVersionInfo storage_version_info[] = {
-	{"v0.0.4", 1},
-	{"v0.1.0", 1},
-	{"v0.1.1", 1},
-	{"v0.1.2", 1},
-	{"v0.1.3", 1},
-	{"v0.1.4", 1},
-	{"v0.1.5", 1},
-	{"v0.1.6", 1},
-	{"v0.1.7", 1},
-	{"v0.1.8", 1},
-	{"v0.1.9", 1},
-	{"v0.2.0", 1},
-	{"v0.2.1", 1},
-	{"v0.2.2", 4},
-	{"v0.2.3", 6},
-	{"v0.2.4", 11},
-	{"v0.2.5", 13},
-	{"v0.2.6", 15},
-	{"v0.2.7", 17},
-	{"v0.2.8", 18},
-	{"v0.2.9", 21},
-	{"v0.3.0", 25},
-	{"v0.3.1", 27},
-	{"v0.3.2", 31},
-	{"v0.3.3", 33},
-	{"v0.3.4", 33},
-	{"v0.3.5", 33},
-	{"v0.4.0", 33},
-	{"v0.5.0", 38},
-	{"v0.5.1", 38},
-	{"v0.6.0", 39},
-	{"v0.6.1", 39},
-	{"v0.7.0", 43},
-	{"v0.7.1", 43},
-	{"v0.8.0", 51},
-	{"v0.8.1", 51},
-	{"v0.9.0", 64},
-	{"v0.9.1", 64},
-	{"v0.9.2", 64},
-	{"v0.10.0", 64},
-	{"v0.10.1", 64},
-	{"v0.10.2", 64},
-	{"v0.10.3", 64},
-	{"v1.0.0", 64},
-	{"v1.1.0", 64},
-	{"v1.1.1", 64},
-	{"v1.1.2", 64},
-	{"v1.1.3", 64},
-	{nullptr, 0}
-};
-// END OF STORAGE VERSION INFO
-static_assert(DEFAULT_STORAGE_VERSION_INFO == VERSION_NUMBER, "Check on VERSION_INFO");
-
-// START OF SERIALIZATION VERSION INFO
-const uint64_t LATEST_SERIALIZATION_VERSION_INFO = 4;
-const uint64_t DEFAULT_SERIALIZATION_VERSION_INFO = 1;
-static const SerializationVersionInfo serialization_version_info[] = {
-	{"v0.10.0", 1},
-	{"v0.10.1", 1},
-	{"v0.10.2", 1},
-	{"v0.10.3", 2},
-	{"v1.0.0", 2},
-	{"v1.1.0", 3},
-	{"v1.1.1", 3},
-	{"v1.1.2", 3},
-	{"v1.1.3", 3},
-	{"v1.2.0", 4},
-	{"latest", 4},
-	{nullptr, 0}
-};
-// END OF SERIALIZATION VERSION INFO
-// clang-format on
-
-static_assert(DEFAULT_SERIALIZATION_VERSION_INFO <= LATEST_SERIALIZATION_VERSION_INFO,
-              "Check on SERIALIZATION_VERSION_INFO");
-
-optional_idx GetStorageVersion(const char *version_string) {
-	for (idx_t i = 0; storage_version_info[i].version_name; i++) {
-		if (!strcmp(storage_version_info[i].version_name, version_string)) {
-			return storage_version_info[i].storage_version;
-		}
-	}
-	return optional_idx();
-}
-
-optional_idx GetSerializationVersion(const char *version_string) {
-	for (idx_t i = 0; serialization_version_info[i].version_name; i++) {
-		if (!strcmp(serialization_version_info[i].version_name, version_string)) {
-			return serialization_version_info[i].serialization_version;
-		}
-	}
-	return optional_idx();
-}
-
-vector<string> GetSerializationCandidates() {
-	vector<string> candidates;
-	for (idx_t i = 0; serialization_version_info[i].version_name; i++) {
-		candidates.push_back(serialization_version_info[i].version_name);
-	}
-	return candidates;
-}
-
-string GetDuckDBVersion(idx_t version_number) {
-	vector<string> versions;
-	for (idx_t i = 0; storage_version_info[i].version_name; i++) {
-		if (version_number == storage_version_info[i].storage_version) {
-			versions.push_back(string(storage_version_info[i].version_name));
-		}
-	}
-	if (versions.empty()) {
-		return string();
-	}
-	string result;
-	for (idx_t i = 0; i < versions.size(); i++) {
-		string sep = "";
-		if (i) {
-			sep = i + 1 == versions.size() ? " or " : ", ";
-		}
-		result += sep;
-		result += versions[i];
-	}
-	return result;
-}
-
-void Storage::VerifyBlockAllocSize(const idx_t block_alloc_size) {
-	if (!IsPowerOfTwo(block_alloc_size)) {
-		throw InvalidInputException("the block size must be a power of two, got %llu", block_alloc_size);
-	}
-	if (block_alloc_size < MIN_BLOCK_ALLOC_SIZE) {
-		throw InvalidInputException(
-		    "the block size must be greater or equal than the minimum block size of %llu, got %llu",
-		    MIN_BLOCK_ALLOC_SIZE, block_alloc_size);
-	}
-	if (block_alloc_size > MAX_BLOCK_ALLOC_SIZE) {
-		throw InvalidInputException(
-		    "the block size must be lesser or equal than the maximum block size of %llu, got %llu",
-		    MAX_BLOCK_ALLOC_SIZE, block_alloc_size);
-	}
-	auto max_value = NumericCast<idx_t>(NumericLimits<int32_t>().Maximum());
-	if (block_alloc_size > max_value) {
-		throw InvalidInputException(
-		    "the block size must not be greater than the maximum 32-bit signed integer value of %llu, got %llu",
-		    max_value, block_alloc_size);
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/storage_lock.cpp b/src/duckdb/src/storage/storage_lock.cpp
deleted file mode 100644
index 9b7cafb8b..000000000
--- a/src/duckdb/src/storage/storage_lock.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/assert.hpp"
-
-namespace duckdb {
-
-struct StorageLockInternals : enable_shared_from_this<StorageLockInternals> {
-public:
-	StorageLockInternals() : read_count(0) {
-	}
-
-	mutex exclusive_lock;
-	atomic<idx_t> read_count;
-
-public:
-	unique_ptr<StorageLockKey> GetExclusiveLock() {
-		exclusive_lock.lock();
-		while (read_count != 0) {
-		}
-		return make_uniq<StorageLockKey>(shared_from_this(), StorageLockType::EXCLUSIVE);
-	}
-
-	unique_ptr<StorageLockKey> GetSharedLock() {
-		exclusive_lock.lock();
-		read_count++;
-		exclusive_lock.unlock();
-		return make_uniq<StorageLockKey>(shared_from_this(), StorageLockType::SHARED);
-	}
-
-	unique_ptr<StorageLockKey> TryGetExclusiveLock() {
-		if (!exclusive_lock.try_lock()) {
-			// could not lock mutex
-			return nullptr;
-		}
-		if (read_count != 0) {
-			// there are active readers - cannot get exclusive lock
-			exclusive_lock.unlock();
-			return nullptr;
-		}
-		// success!
-		return make_uniq<StorageLockKey>(shared_from_this(), StorageLockType::EXCLUSIVE);
-	}
-
-	unique_ptr<StorageLockKey> TryUpgradeCheckpointLock(StorageLockKey &lock) {
-		if (lock.GetType() != StorageLockType::SHARED) {
-			throw InternalException("StorageLock::TryUpgradeLock called on an exclusive lock");
-		}
-		if (!exclusive_lock.try_lock()) {
-			// could not lock mutex
-			return nullptr;
-		}
-		if (read_count != 1) {
-			// other shared locks are active: failed to upgrade
-			D_ASSERT(read_count != 0);
-			exclusive_lock.unlock();
-			return nullptr;
-		}
-		// no other shared locks active: success!
-		return make_uniq<StorageLockKey>(shared_from_this(), StorageLockType::EXCLUSIVE);
-	}
-
-	void ReleaseExclusiveLock() {
-		exclusive_lock.unlock();
-	}
-	void ReleaseSharedLock() {
-		read_count--;
-	}
-};
-
-StorageLockKey::StorageLockKey(shared_ptr<StorageLockInternals> internals_p, StorageLockType type)
-    : internals(std::move(internals_p)), type(type) {
-}
-
-StorageLockKey::~StorageLockKey() {
-	if (type == StorageLockType::EXCLUSIVE) {
-		internals->ReleaseExclusiveLock();
-	} else {
-		D_ASSERT(type == StorageLockType::SHARED);
-		internals->ReleaseSharedLock();
-	}
-}
-
-StorageLock::StorageLock() : internals(make_shared_ptr<StorageLockInternals>()) {
-}
-StorageLock::~StorageLock() {
-}
-
-unique_ptr<StorageLockKey> StorageLock::GetExclusiveLock() {
-	return internals->GetExclusiveLock();
-}
-
-unique_ptr<StorageLockKey> StorageLock::TryGetExclusiveLock() {
-	return internals->TryGetExclusiveLock();
-}
-
-unique_ptr<StorageLockKey> StorageLock::GetSharedLock() {
-	return internals->GetSharedLock();
-}
-
-unique_ptr<StorageLockKey> StorageLock::TryUpgradeCheckpointLock(StorageLockKey &lock) {
-	return internals->TryUpgradeCheckpointLock(lock);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/storage_manager.cpp b/src/duckdb/src/storage/storage_manager.cpp
deleted file mode 100644
index 2f340251b..000000000
--- a/src/duckdb/src/storage/storage_manager.cpp
+++ /dev/null
@@ -1,409 +0,0 @@
-#include "duckdb/storage/storage_manager.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/function/function.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/storage/checkpoint_manager.hpp"
-#include "duckdb/storage/in_memory_block_manager.hpp"
-#include "duckdb/storage/object_cache.hpp"
-#include "duckdb/storage/single_file_block_manager.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/storage/storage_extension.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-
-namespace duckdb {
-
-StorageManager::StorageManager(AttachedDatabase &db, string path_p, bool read_only)
-    : db(db), path(std::move(path_p)), read_only(read_only) {
-
-	if (path.empty()) {
-		path = IN_MEMORY_PATH;
-		return;
-	}
-	auto &fs = FileSystem::Get(db);
-	path = fs.ExpandPath(path);
-}
-
-StorageManager::~StorageManager() {
-}
-
-StorageManager &StorageManager::Get(AttachedDatabase &db) {
-	return db.GetStorageManager();
-}
-StorageManager &StorageManager::Get(Catalog &catalog) {
-	return StorageManager::Get(catalog.GetAttached());
-}
-
-DatabaseInstance &StorageManager::GetDatabase() {
-	return db.GetDatabase();
-}
-
-BufferManager &BufferManager::GetBufferManager(ClientContext &context) {
-	return BufferManager::GetBufferManager(*context.db);
-}
-
-const BufferManager &BufferManager::GetBufferManager(const ClientContext &context) {
-	return BufferManager::GetBufferManager(*context.db);
-}
-
-ObjectCache &ObjectCache::GetObjectCache(ClientContext &context) {
-	return context.db->GetObjectCache();
-}
-
-idx_t StorageManager::GetWALSize() {
-	return wal->GetWALSize();
-}
-
-optional_ptr<WriteAheadLog> StorageManager::GetWAL() {
-	if (InMemory() || read_only || !load_complete) {
-		return nullptr;
-	}
-	return wal.get();
-}
-
-void StorageManager::ResetWAL() {
-	wal->Delete();
-}
-
-string StorageManager::GetWALPath() {
-	// we append the ".wal" **before** a question mark in case of GET parameters
-	// but only if we are not in a windows long path (which starts with \\?\)
-	std::size_t question_mark_pos = std::string::npos;
-	if (!StringUtil::StartsWith(path, "\\\\?\\")) {
-		question_mark_pos = path.find('?');
-	}
-	auto wal_path = path;
-	if (question_mark_pos != std::string::npos) {
-		wal_path.insert(question_mark_pos, ".wal");
-	} else {
-		wal_path += ".wal";
-	}
-	return wal_path;
-}
-
-bool StorageManager::InMemory() {
-	D_ASSERT(!path.empty());
-	return path == IN_MEMORY_PATH;
-}
-
-void StorageManager::Initialize(StorageOptions options) {
-	bool in_memory = InMemory();
-	if (in_memory && read_only) {
-		throw CatalogException("Cannot launch in-memory database in read-only mode!");
-	}
-
-	// Create or load the database from disk, if not in-memory mode.
-	LoadDatabase(options);
-}
-
-///////////////////////////////////////////////////////////////////////////
-class SingleFileTableIOManager : public TableIOManager {
-public:
-	explicit SingleFileTableIOManager(BlockManager &block_manager, idx_t row_group_size)
-	    : block_manager(block_manager), row_group_size(row_group_size) {
-	}
-
-	BlockManager &block_manager;
-	idx_t row_group_size;
-
-public:
-	BlockManager &GetIndexBlockManager() override {
-		return block_manager;
-	}
-	BlockManager &GetBlockManagerForRowData() override {
-		return block_manager;
-	}
-	MetadataManager &GetMetadataManager() override {
-		return block_manager.GetMetadataManager();
-	}
-	idx_t GetRowGroupSize() const override {
-		return row_group_size;
-	}
-};
-
-SingleFileStorageManager::SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only)
-    : StorageManager(db, std::move(path), read_only) {
-}
-
-void SingleFileStorageManager::LoadDatabase(StorageOptions storage_options) {
-	if (InMemory()) {
-		block_manager = make_uniq<InMemoryBlockManager>(BufferManager::GetBufferManager(db), DEFAULT_BLOCK_ALLOC_SIZE);
-		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager, DEFAULT_ROW_GROUP_SIZE);
-		return;
-	}
-
-	auto &fs = FileSystem::Get(db);
-	auto &config = DBConfig::Get(db);
-
-	StorageManagerOptions options;
-	options.read_only = read_only;
-	options.use_direct_io = config.options.use_direct_io;
-	options.debug_initialize = config.options.debug_initialize;
-
-	idx_t row_group_size = DEFAULT_ROW_GROUP_SIZE;
-	if (storage_options.row_group_size.IsValid()) {
-		row_group_size = storage_options.row_group_size.GetIndex();
-		if (row_group_size == 0) {
-			throw NotImplementedException("Invalid row group size: %llu - row group size must be bigger than 0",
-			                              row_group_size);
-		}
-		if (row_group_size % STANDARD_VECTOR_SIZE != 0) {
-			throw NotImplementedException(
-			    "Invalid row group size: %llu - row group size must be divisible by the vector size (%llu)",
-			    row_group_size, STANDARD_VECTOR_SIZE);
-		}
-	}
-	// Check if the database file already exists.
-	// Note: a file can also exist if there was a ROLLBACK on a previous transaction creating that file.
-	if (!read_only && !fs.FileExists(path)) {
-		// file does not exist and we are in read-write mode
-		// create a new file
-
-		// check if a WAL file already exists
-		auto wal_path = GetWALPath();
-		if (fs.FileExists(wal_path)) {
-			// WAL file exists but database file does not
-			// remove the WAL
-			fs.RemoveFile(wal_path);
-		}
-
-		// Set the block allocation size for the new database file.
-		if (storage_options.block_alloc_size.IsValid()) {
-			// Use the option provided by the user.
-			Storage::VerifyBlockAllocSize(storage_options.block_alloc_size.GetIndex());
-			options.block_alloc_size = storage_options.block_alloc_size;
-		} else {
-			// No explicit option provided: use the default option.
-			options.block_alloc_size = config.options.default_block_alloc_size;
-		}
-
-		// Initialize the block manager before creating a new database.
-		auto sf_block_manager = make_uniq<SingleFileBlockManager>(db, path, options);
-		sf_block_manager->CreateNewDatabase();
-		block_manager = std::move(sf_block_manager);
-		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager, row_group_size);
-		wal = make_uniq<WriteAheadLog>(db, wal_path);
-	} else {
-		// Either the file exists, or we are in read-only mode, so we
-		// try to read the existing file on disk.
-
-		// Initialize the block manager while loading the database file.
-		// We'll construct the SingleFileBlockManager with the default block allocation size,
-		// and later adjust it when reading the file header.
-		auto sf_block_manager = make_uniq<SingleFileBlockManager>(db, path, options);
-		sf_block_manager->LoadExistingDatabase();
-		block_manager = std::move(sf_block_manager);
-		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager, row_group_size);
-
-		if (storage_options.block_alloc_size.IsValid()) {
-			// user-provided block alloc size
-			idx_t block_alloc_size = storage_options.block_alloc_size.GetIndex();
-			if (block_alloc_size != block_manager->GetBlockAllocSize()) {
-				throw InvalidInputException(
-				    "block size parameter does not match the file's block size, got %llu, expected %llu",
-				    storage_options.block_alloc_size.GetIndex(), block_manager->GetBlockAllocSize());
-			}
-		}
-
-		// load the db from storage
-		auto checkpoint_reader = SingleFileCheckpointReader(*this);
-		checkpoint_reader.LoadFromStorage();
-
-		auto wal_path = GetWALPath();
-		wal = WriteAheadLog::Replay(fs, db, wal_path);
-	}
-
-	load_complete = true;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-enum class WALCommitState { IN_PROGRESS, FLUSHED, TRUNCATED };
-
-struct OptimisticallyWrittenRowGroupData {
-	OptimisticallyWrittenRowGroupData(idx_t start, idx_t count, unique_ptr<PersistentCollectionData> row_group_data_p)
-	    : start(start), count(count), row_group_data(std::move(row_group_data_p)) {
-	}
-
-	idx_t start;
-	idx_t count;
-	unique_ptr<PersistentCollectionData> row_group_data;
-};
-
-class SingleFileStorageCommitState : public StorageCommitState {
-public:
-	SingleFileStorageCommitState(StorageManager &storage, WriteAheadLog &log);
-	~SingleFileStorageCommitState() override;
-
-	//! Revert the commit
-	void RevertCommit() override;
-	// Make the commit persistent
-	void FlushCommit() override;
-
-	void AddRowGroupData(DataTable &table, idx_t start_index, idx_t count,
-	                     unique_ptr<PersistentCollectionData> row_group_data) override;
-	optional_ptr<PersistentCollectionData> GetRowGroupData(DataTable &table, idx_t start_index, idx_t &count) override;
-	bool HasRowGroupData() override;
-
-private:
-	idx_t initial_wal_size = 0;
-	idx_t initial_written = 0;
-	WriteAheadLog &wal;
-	WALCommitState state;
-	reference_map_t<DataTable, unordered_map<idx_t, OptimisticallyWrittenRowGroupData>> optimistically_written_data;
-};
-
-SingleFileStorageCommitState::SingleFileStorageCommitState(StorageManager &storage, WriteAheadLog &wal)
-    : wal(wal), state(WALCommitState::IN_PROGRESS) {
-	auto initial_size = storage.GetWALSize();
-	initial_written = wal.GetTotalWritten();
-	initial_wal_size = initial_size;
-}
-
-SingleFileStorageCommitState::~SingleFileStorageCommitState() {
-	if (state != WALCommitState::IN_PROGRESS) {
-		return;
-	}
-	try {
-		// truncate the WAL in case of a destructor
-		RevertCommit();
-	} catch (...) { // NOLINT
-	}
-}
-
-void SingleFileStorageCommitState::RevertCommit() {
-	if (state != WALCommitState::IN_PROGRESS) {
-		return;
-	}
-	if (wal.GetTotalWritten() > initial_written) {
-		// remove any entries written into the WAL by truncating it
-		wal.Truncate(initial_wal_size);
-	}
-	state = WALCommitState::TRUNCATED;
-}
-
-void SingleFileStorageCommitState::FlushCommit() {
-	if (state != WALCommitState::IN_PROGRESS) {
-		return;
-	}
-	wal.Flush();
-	state = WALCommitState::FLUSHED;
-}
-
-void SingleFileStorageCommitState::AddRowGroupData(DataTable &table, idx_t start_index, idx_t count,
-                                                   unique_ptr<PersistentCollectionData> row_group_data) {
-	if (row_group_data->HasUpdates()) {
-		// cannot serialize optimistic block pointers if in-memory updates exist
-		return;
-	}
-	if (table.HasIndexes()) {
-		// cannot serialize optimistic block pointers if the table has indexes
-		return;
-	}
-	auto &entries = optimistically_written_data[table];
-	auto entry = entries.find(start_index);
-	if (entry != entries.end()) {
-		throw InternalException("FIXME: AddOptimisticallyWrittenRowGroup is writing a duplicate row group");
-	}
-	entries.insert(
-	    make_pair(start_index, OptimisticallyWrittenRowGroupData(start_index, count, std::move(row_group_data))));
-}
-
-optional_ptr<PersistentCollectionData> SingleFileStorageCommitState::GetRowGroupData(DataTable &table,
-                                                                                     idx_t start_index, idx_t &count) {
-	auto entry = optimistically_written_data.find(table);
-	if (entry == optimistically_written_data.end()) {
-		// no data for this table
-		return nullptr;
-	}
-	auto &row_groups = entry->second;
-	auto start_entry = row_groups.find(start_index);
-	if (start_entry == row_groups.end()) {
-		// this row group was not optimistically written
-		return nullptr;
-	}
-	count = start_entry->second.count;
-	return start_entry->second.row_group_data.get();
-}
-
-bool SingleFileStorageCommitState::HasRowGroupData() {
-	return !optimistically_written_data.empty();
-}
-
-unique_ptr<StorageCommitState> SingleFileStorageManager::GenStorageCommitState(WriteAheadLog &wal) {
-	return make_uniq<SingleFileStorageCommitState>(*this, wal);
-}
-
-bool SingleFileStorageManager::IsCheckpointClean(MetaBlockPointer checkpoint_id) {
-	return block_manager->IsRootBlock(checkpoint_id);
-}
-
-void SingleFileStorageManager::CreateCheckpoint(CheckpointOptions options) {
-	if (InMemory() || read_only || !load_complete) {
-		return;
-	}
-	if (db.GetStorageExtension()) {
-		db.GetStorageExtension()->OnCheckpointStart(db, options);
-	}
-	auto &config = DBConfig::Get(db);
-	if (GetWALSize() > 0 || config.options.force_checkpoint || options.action == CheckpointAction::ALWAYS_CHECKPOINT) {
-		// we only need to checkpoint if there is anything in the WAL
-		try {
-			SingleFileCheckpointWriter checkpointer(db, *block_manager, options.type);
-			checkpointer.CreateCheckpoint();
-		} catch (std::exception &ex) {
-			ErrorData error(ex);
-			throw FatalException("Failed to create checkpoint because of error: %s", error.RawMessage());
-		}
-	}
-	if (options.wal_action == CheckpointWALAction::DELETE_WAL) {
-		ResetWAL();
-	}
-
-	if (db.GetStorageExtension()) {
-		db.GetStorageExtension()->OnCheckpointEnd(db, options);
-	}
-}
-
-DatabaseSize SingleFileStorageManager::GetDatabaseSize() {
-	// All members default to zero
-	DatabaseSize ds;
-	if (!InMemory()) {
-		ds.total_blocks = block_manager->TotalBlocks();
-		ds.block_size = block_manager->GetBlockAllocSize();
-		ds.free_blocks = block_manager->FreeBlocks();
-		ds.used_blocks = ds.total_blocks - ds.free_blocks;
-		ds.bytes = (ds.total_blocks * ds.block_size);
-		ds.wal_size = NumericCast<idx_t>(GetWALSize());
-	}
-	return ds;
-}
-
-vector<MetadataBlockInfo> SingleFileStorageManager::GetMetadataInfo() {
-	auto &metadata_manager = block_manager->GetMetadataManager();
-	return metadata_manager.GetMetadataInfo();
-}
-
-bool SingleFileStorageManager::AutomaticCheckpoint(idx_t estimated_wal_bytes) {
-	auto initial_size = NumericCast<idx_t>(GetWALSize());
-	idx_t expected_wal_size = initial_size + estimated_wal_bytes;
-	return expected_wal_size > DBConfig::Get(db).options.checkpoint_wal_size;
-}
-
-shared_ptr<TableIOManager> SingleFileStorageManager::GetTableIOManager(BoundCreateTableInfo *info /*info*/) {
-	// This is an unmanaged reference. No ref/deref overhead. Lifetime of the
-	// TableIoManager follows lifetime of the StorageManager (this).
-	return shared_ptr<TableIOManager>(shared_ptr<char>(nullptr), table_io_manager.get());
-}
-
-BlockManager &SingleFileStorageManager::GetBlockManager() {
-	return *block_manager;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/array_column_data.cpp b/src/duckdb/src/storage/table/array_column_data.cpp
deleted file mode 100644
index 148f3fd84..000000000
--- a/src/duckdb/src/storage/table/array_column_data.cpp
+++ /dev/null
@@ -1,268 +0,0 @@
-#include "duckdb/storage/table/array_column_data.hpp"
-#include "duckdb/storage/statistics/array_stats.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-ArrayColumnData::ArrayColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-                                 LogicalType type_p, optional_ptr<ColumnData> parent)
-    : ColumnData(block_manager, info, column_index, start_row, std::move(type_p), parent),
-      validity(block_manager, info, 0, start_row, *this) {
-	D_ASSERT(type.InternalType() == PhysicalType::ARRAY);
-	auto &child_type = ArrayType::GetChildType(type);
-	// the child column, with column index 1 (0 is the validity mask)
-	child_column = ColumnData::CreateColumnUnique(block_manager, info, 1, start_row, child_type, this);
-}
-
-void ArrayColumnData::SetStart(idx_t new_start) {
-	this->start = new_start;
-	child_column->SetStart(new_start);
-	validity.SetStart(new_start);
-}
-
-FilterPropagateResult ArrayColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	// FIXME: There is nothing preventing us from supporting this, but it's not implemented yet.
-	// table filters are not supported yet for fixed size list columns
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-void ArrayColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) {
-	ColumnData::InitializePrefetch(prefetch_state, scan_state, rows);
-	validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows);
-	auto array_size = ArrayType::GetSize(type);
-	child_column->InitializePrefetch(prefetch_state, scan_state.child_states[1], rows * array_size);
-}
-
-void ArrayColumnData::InitializeScan(ColumnScanState &state) {
-	// initialize the validity segment
-	D_ASSERT(state.child_states.size() == 2);
-
-	state.row_index = 0;
-	state.current = nullptr;
-
-	validity.InitializeScan(state.child_states[0]);
-
-	// initialize the child scan
-	child_column->InitializeScan(state.child_states[1]);
-}
-
-void ArrayColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	D_ASSERT(state.child_states.size() == 2);
-
-	if (row_idx == 0) {
-		// Trivial case, no offset
-		InitializeScan(state);
-		return;
-	}
-
-	state.row_index = row_idx;
-	state.current = nullptr;
-
-	// initialize the validity segment
-	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
-
-	auto array_size = ArrayType::GetSize(type);
-	auto child_count = (row_idx - start) * array_size;
-
-	D_ASSERT(child_count <= child_column->GetMaxEntry());
-	if (child_count < child_column->GetMaxEntry()) {
-		const auto child_offset = start + child_count;
-		child_column->InitializeScanWithOffset(state.child_states[1], child_offset);
-	}
-}
-
-idx_t ArrayColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                            idx_t scan_count) {
-	return ScanCount(state, result, scan_count);
-}
-
-idx_t ArrayColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-                                     idx_t scan_count) {
-	return ScanCount(state, result, scan_count);
-}
-
-idx_t ArrayColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	// Scan validity
-	auto scan_count = validity.ScanCount(state.child_states[0], result, count);
-	auto array_size = ArrayType::GetSize(type);
-	// Scan child column
-	auto &child_vec = ArrayVector::GetEntry(result);
-	child_column->ScanCount(state.child_states[1], child_vec, count * array_size);
-	return scan_count;
-}
-
-void ArrayColumnData::Skip(ColumnScanState &state, idx_t count) {
-	// Skip validity
-	validity.Skip(state.child_states[0], count);
-	// Skip child column
-	auto array_size = ArrayType::GetSize(type);
-	child_column->Skip(state.child_states[1], count * array_size);
-}
-
-void ArrayColumnData::InitializeAppend(ColumnAppendState &state) {
-	ColumnAppendState validity_append;
-	validity.InitializeAppend(validity_append);
-	state.child_appends.push_back(std::move(validity_append));
-
-	ColumnAppendState child_append;
-	child_column->InitializeAppend(child_append);
-	state.child_appends.push_back(std::move(child_append));
-}
-
-void ArrayColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
-		Vector append_vector(vector);
-		append_vector.Flatten(count);
-		Append(stats, state, append_vector, count);
-		return;
-	}
-
-	// Append validity
-	validity.Append(stats, state.child_appends[0], vector, count);
-	// Append child column
-	auto array_size = ArrayType::GetSize(type);
-	auto &child_vec = ArrayVector::GetEntry(vector);
-	child_column->Append(ArrayStats::GetChildStats(stats), state.child_appends[1], child_vec, count * array_size);
-
-	this->count += count;
-}
-
-void ArrayColumnData::RevertAppend(row_t start_row) {
-	// Revert validity
-	validity.RevertAppend(start_row);
-	// Revert child column
-	auto array_size = ArrayType::GetSize(type);
-	child_column->RevertAppend(start_row * UnsafeNumericCast<row_t>(array_size));
-
-	this->count = UnsafeNumericCast<idx_t>(start_row) - this->start;
-}
-
-idx_t ArrayColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	throw NotImplementedException("Array Fetch");
-}
-
-void ArrayColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                             idx_t update_count) {
-	throw NotImplementedException("Array Update is not supported.");
-}
-
-void ArrayColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                   Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
-	throw NotImplementedException("Array Update Column is not supported");
-}
-
-unique_ptr<BaseStatistics> ArrayColumnData::GetUpdateStatistics() {
-	return nullptr;
-}
-
-void ArrayColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                               idx_t result_idx) {
-
-	// Create state for validity & child column
-	if (state.child_states.empty()) {
-		state.child_states.push_back(make_uniq<ColumnFetchState>());
-	}
-
-	// Fetch validity
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-
-	// Fetch child column
-	auto &child_vec = ArrayVector::GetEntry(result);
-	auto &child_type = ArrayType::GetChildType(type);
-	auto array_size = ArrayType::GetSize(type);
-
-	// We need to fetch between [row_id * array_size, (row_id + 1) * array_size)
-	auto child_state = make_uniq<ColumnScanState>();
-	child_state->Initialize(child_type, nullptr);
-
-	const auto child_offset = start + (UnsafeNumericCast<idx_t>(row_id) - start) * array_size;
-
-	child_column->InitializeScanWithOffset(*child_state, child_offset);
-	Vector child_scan(child_type, array_size);
-	child_column->ScanCount(*child_state, child_scan, array_size);
-	VectorOperations::Copy(child_scan, child_vec, array_size, 0, result_idx * array_size);
-}
-
-void ArrayColumnData::CommitDropColumn() {
-	validity.CommitDropColumn();
-	child_column->CommitDropColumn();
-}
-
-struct ArrayColumnCheckpointState : public ColumnCheckpointState {
-	ArrayColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, PartialBlockManager &partial_block_manager)
-	    : ColumnCheckpointState(row_group, column_data, partial_block_manager) {
-		global_stats = ArrayStats::CreateEmpty(column_data.type).ToUnique();
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-	unique_ptr<ColumnCheckpointState> child_state;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		auto stats = global_stats->Copy();
-		ArrayStats::SetChildStats(stats, child_state->GetStatistics());
-		return stats.ToUnique();
-	}
-
-	PersistentColumnData ToPersistentData() override {
-		PersistentColumnData data(PhysicalType::ARRAY);
-		data.child_columns.push_back(validity_state->ToPersistentData());
-		data.child_columns.push_back(child_state->ToPersistentData());
-		return data;
-	}
-};
-
-unique_ptr<ColumnCheckpointState> ArrayColumnData::CreateCheckpointState(RowGroup &row_group,
-                                                                         PartialBlockManager &partial_block_manager) {
-	return make_uniq<ArrayColumnCheckpointState>(row_group, *this, partial_block_manager);
-}
-
-unique_ptr<ColumnCheckpointState> ArrayColumnData::Checkpoint(RowGroup &row_group,
-                                                              ColumnCheckpointInfo &checkpoint_info) {
-
-	auto checkpoint_state = make_uniq<ArrayColumnCheckpointState>(row_group, *this, checkpoint_info.info.manager);
-	checkpoint_state->validity_state = validity.Checkpoint(row_group, checkpoint_info);
-	checkpoint_state->child_state = child_column->Checkpoint(row_group, checkpoint_info);
-	return std::move(checkpoint_state);
-}
-
-bool ArrayColumnData::IsPersistent() {
-	return validity.IsPersistent() && child_column->IsPersistent();
-}
-
-PersistentColumnData ArrayColumnData::Serialize() {
-	PersistentColumnData persistent_data(PhysicalType::ARRAY);
-	persistent_data.child_columns.push_back(validity.Serialize());
-	persistent_data.child_columns.push_back(child_column->Serialize());
-	return persistent_data;
-}
-
-void ArrayColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) {
-	D_ASSERT(column_data.pointers.empty());
-	validity.InitializeColumn(column_data.child_columns[0], target_stats);
-	auto &child_stats = ArrayStats::GetChildStats(target_stats);
-	child_column->InitializeColumn(column_data.child_columns[1], child_stats);
-	this->count = validity.count.load();
-}
-
-void ArrayColumnData::GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path,
-                                           vector<ColumnSegmentInfo> &result) {
-	col_path.push_back(0);
-	validity.GetColumnSegmentInfo(row_group_index, col_path, result);
-	col_path.back() = 1;
-	child_column->GetColumnSegmentInfo(row_group_index, col_path, result);
-}
-
-void ArrayColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	ColumnData::Verify(parent);
-	validity.Verify(parent);
-	child_column->Verify(parent);
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/chunk_info.cpp b/src/duckdb/src/storage/table/chunk_info.cpp
deleted file mode 100644
index 6460f6f99..000000000
--- a/src/duckdb/src/storage/table/chunk_info.cpp
+++ /dev/null
@@ -1,332 +0,0 @@
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-
-namespace duckdb {
-
-struct TransactionVersionOperator {
-	static bool UseInsertedVersion(transaction_t start_time, transaction_t transaction_id, transaction_t id) {
-		return id < start_time || id == transaction_id;
-	}
-
-	static bool UseDeletedVersion(transaction_t start_time, transaction_t transaction_id, transaction_t id) {
-		return !UseInsertedVersion(start_time, transaction_id, id);
-	}
-};
-
-struct CommittedVersionOperator {
-	static bool UseInsertedVersion(transaction_t start_time, transaction_t transaction_id, transaction_t id) {
-		return true;
-	}
-
-	static bool UseDeletedVersion(transaction_t min_start_time, transaction_t min_transaction_id, transaction_t id) {
-		return (id >= min_start_time && id < TRANSACTION_ID_START) || id == NOT_DELETED_ID;
-	}
-};
-
-static bool UseVersion(TransactionData transaction, transaction_t id) {
-	return TransactionVersionOperator::UseInsertedVersion(transaction.start_time, transaction.transaction_id, id);
-}
-
-bool ChunkInfo::Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const {
-	return false;
-}
-
-void ChunkInfo::Write(WriteStream &writer) const {
-	writer.Write<ChunkInfoType>(type);
-}
-
-unique_ptr<ChunkInfo> ChunkInfo::Read(ReadStream &reader) {
-	auto type = reader.Read<ChunkInfoType>();
-	switch (type) {
-	case ChunkInfoType::EMPTY_INFO:
-		return nullptr;
-	case ChunkInfoType::CONSTANT_INFO:
-		return ChunkConstantInfo::Read(reader);
-	case ChunkInfoType::VECTOR_INFO:
-		return ChunkVectorInfo::Read(reader);
-	default:
-		throw SerializationException("Could not deserialize Chunk Info Type: unrecognized type");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Constant info
-//===--------------------------------------------------------------------===//
-ChunkConstantInfo::ChunkConstantInfo(idx_t start)
-    : ChunkInfo(start, ChunkInfoType::CONSTANT_INFO), insert_id(0), delete_id(NOT_DELETED_ID) {
-}
-
-template <class OP>
-idx_t ChunkConstantInfo::TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id,
-                                               SelectionVector &sel_vector, idx_t max_count) const {
-	if (OP::UseInsertedVersion(start_time, transaction_id, insert_id) &&
-	    OP::UseDeletedVersion(start_time, transaction_id, delete_id)) {
-		return max_count;
-	}
-	return 0;
-}
-
-idx_t ChunkConstantInfo::GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) {
-	return TemplatedGetSelVector<TransactionVersionOperator>(transaction.start_time, transaction.transaction_id,
-	                                                         sel_vector, max_count);
-}
-
-idx_t ChunkConstantInfo::GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-                                               SelectionVector &sel_vector, idx_t max_count) {
-	return TemplatedGetSelVector<CommittedVersionOperator>(min_start_id, min_transaction_id, sel_vector, max_count);
-}
-
-bool ChunkConstantInfo::Fetch(TransactionData transaction, row_t row) {
-	return UseVersion(transaction, insert_id) && !UseVersion(transaction, delete_id);
-}
-
-void ChunkConstantInfo::CommitAppend(transaction_t commit_id, idx_t start, idx_t end) {
-	D_ASSERT(start == 0 && end == STANDARD_VECTOR_SIZE);
-	insert_id = commit_id;
-}
-
-bool ChunkConstantInfo::HasDeletes() const {
-	bool is_deleted = insert_id >= TRANSACTION_ID_START || delete_id < TRANSACTION_ID_START;
-	return is_deleted;
-}
-
-idx_t ChunkConstantInfo::GetCommittedDeletedCount(idx_t max_count) {
-	return delete_id < TRANSACTION_ID_START ? max_count : 0;
-}
-
-bool ChunkConstantInfo::Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const {
-	if (delete_id != NOT_DELETED_ID) {
-		// the chunk info is labeled as deleted - we need to keep it around
-		return false;
-	}
-	if (insert_id > lowest_transaction) {
-		// there are still transactions active that need this ChunkInfo
-		return false;
-	}
-	return true;
-}
-
-void ChunkConstantInfo::Write(WriteStream &writer) const {
-	D_ASSERT(HasDeletes());
-	ChunkInfo::Write(writer);
-	writer.Write<idx_t>(start);
-}
-
-unique_ptr<ChunkInfo> ChunkConstantInfo::Read(ReadStream &reader) {
-	auto start = reader.Read<idx_t>();
-	auto info = make_uniq<ChunkConstantInfo>(start);
-	info->insert_id = 0;
-	info->delete_id = 0;
-	return std::move(info);
-}
-
-//===--------------------------------------------------------------------===//
-// Vector info
-//===--------------------------------------------------------------------===//
-ChunkVectorInfo::ChunkVectorInfo(idx_t start)
-    : ChunkInfo(start, ChunkInfoType::VECTOR_INFO), insert_id(0), same_inserted_id(true), any_deleted(false) {
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-		inserted[i] = 0;
-		deleted[i] = NOT_DELETED_ID;
-	}
-}
-
-template <class OP>
-idx_t ChunkVectorInfo::TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id,
-                                             SelectionVector &sel_vector, idx_t max_count) const {
-	idx_t count = 0;
-	if (same_inserted_id && !any_deleted) {
-		// all tuples have the same inserted id: and no tuples were deleted
-		if (OP::UseInsertedVersion(start_time, transaction_id, insert_id)) {
-			return max_count;
-		} else {
-			return 0;
-		}
-	} else if (same_inserted_id) {
-		if (!OP::UseInsertedVersion(start_time, transaction_id, insert_id)) {
-			return 0;
-		}
-		// have to check deleted flag
-		for (idx_t i = 0; i < max_count; i++) {
-			if (OP::UseDeletedVersion(start_time, transaction_id, deleted[i])) {
-				sel_vector.set_index(count++, i);
-			}
-		}
-	} else if (!any_deleted) {
-		// have to check inserted flag
-		for (idx_t i = 0; i < max_count; i++) {
-			if (OP::UseInsertedVersion(start_time, transaction_id, inserted[i])) {
-				sel_vector.set_index(count++, i);
-			}
-		}
-	} else {
-		// have to check both flags
-		for (idx_t i = 0; i < max_count; i++) {
-			if (OP::UseInsertedVersion(start_time, transaction_id, inserted[i]) &&
-			    OP::UseDeletedVersion(start_time, transaction_id, deleted[i])) {
-				sel_vector.set_index(count++, i);
-			}
-		}
-	}
-	return count;
-}
-
-idx_t ChunkVectorInfo::GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-                                    idx_t max_count) const {
-	return TemplatedGetSelVector<TransactionVersionOperator>(start_time, transaction_id, sel_vector, max_count);
-}
-
-idx_t ChunkVectorInfo::GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-                                             SelectionVector &sel_vector, idx_t max_count) {
-	return TemplatedGetSelVector<CommittedVersionOperator>(min_start_id, min_transaction_id, sel_vector, max_count);
-}
-
-idx_t ChunkVectorInfo::GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) {
-	return GetSelVector(transaction.start_time, transaction.transaction_id, sel_vector, max_count);
-}
-
-bool ChunkVectorInfo::Fetch(TransactionData transaction, row_t row) {
-	return UseVersion(transaction, inserted[row]) && !UseVersion(transaction, deleted[row]);
-}
-
-idx_t ChunkVectorInfo::Delete(transaction_t transaction_id, row_t rows[], idx_t count) {
-	any_deleted = true;
-
-	idx_t deleted_tuples = 0;
-	for (idx_t i = 0; i < count; i++) {
-		if (deleted[rows[i]] == transaction_id) {
-			continue;
-		}
-		// first check the chunk for conflicts
-		if (deleted[rows[i]] != NOT_DELETED_ID) {
-			// tuple was already deleted by another transaction
-			throw TransactionException("Conflict on tuple deletion!");
-		}
-		// after verifying that there are no conflicts we mark the tuple as deleted
-		deleted[rows[i]] = transaction_id;
-		rows[deleted_tuples] = rows[i];
-		deleted_tuples++;
-	}
-	return deleted_tuples;
-}
-
-void ChunkVectorInfo::CommitDelete(transaction_t commit_id, const DeleteInfo &info) {
-	if (info.is_consecutive) {
-		for (idx_t i = 0; i < info.count; i++) {
-			deleted[i] = commit_id;
-		}
-	} else {
-		auto rows = info.GetRows();
-		for (idx_t i = 0; i < info.count; i++) {
-			deleted[rows[i]] = commit_id;
-		}
-	}
-}
-
-void ChunkVectorInfo::Append(idx_t start, idx_t end, transaction_t commit_id) {
-	if (start == 0) {
-		insert_id = commit_id;
-	} else if (insert_id != commit_id) {
-		same_inserted_id = false;
-		insert_id = NOT_DELETED_ID;
-	}
-	for (idx_t i = start; i < end; i++) {
-		inserted[i] = commit_id;
-	}
-}
-
-void ChunkVectorInfo::CommitAppend(transaction_t commit_id, idx_t start, idx_t end) {
-	if (same_inserted_id) {
-		insert_id = commit_id;
-	}
-	for (idx_t i = start; i < end; i++) {
-		inserted[i] = commit_id;
-	}
-}
-
-bool ChunkVectorInfo::Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const {
-	if (any_deleted) {
-		// if any rows are deleted we can't clean-up
-		return false;
-	}
-	// check if the insertion markers have to be used by all transactions going forward
-	if (!same_inserted_id) {
-		for (idx_t idx = 1; idx < STANDARD_VECTOR_SIZE; idx++) {
-			if (inserted[idx] > lowest_transaction) {
-				// transaction was inserted after the lowest transaction start
-				// we still need to use an older version - cannot compress
-				return false;
-			}
-		}
-	} else if (insert_id > lowest_transaction) {
-		// transaction was inserted after the lowest transaction start
-		// we still need to use an older version - cannot compress
-		return false;
-	}
-	return true;
-}
-
-bool ChunkVectorInfo::HasDeletes() const {
-	return any_deleted;
-}
-
-idx_t ChunkVectorInfo::GetCommittedDeletedCount(idx_t max_count) {
-	if (!any_deleted) {
-		return 0;
-	}
-	idx_t delete_count = 0;
-	for (idx_t i = 0; i < max_count; i++) {
-		if (deleted[i] < TRANSACTION_ID_START) {
-			delete_count++;
-		}
-	}
-	return delete_count;
-}
-
-void ChunkVectorInfo::Write(WriteStream &writer) const {
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	transaction_t start_time = TRANSACTION_ID_START - 1;
-	transaction_t transaction_id = DConstants::INVALID_INDEX;
-	idx_t count = GetSelVector(start_time, transaction_id, sel, STANDARD_VECTOR_SIZE);
-	if (count == STANDARD_VECTOR_SIZE) {
-		// nothing is deleted: skip writing anything
-		writer.Write<ChunkInfoType>(ChunkInfoType::EMPTY_INFO);
-		return;
-	}
-	if (count == 0) {
-		// everything is deleted: write a constant vector
-		writer.Write<ChunkInfoType>(ChunkInfoType::CONSTANT_INFO);
-		writer.Write<idx_t>(start);
-		return;
-	}
-	// write a boolean vector
-	ChunkInfo::Write(writer);
-	writer.Write<idx_t>(start);
-	ValidityMask mask(STANDARD_VECTOR_SIZE);
-	mask.Initialize(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < count; i++) {
-		mask.SetInvalid(sel.get_index(i));
-	}
-	mask.Write(writer, STANDARD_VECTOR_SIZE);
-}
-
-unique_ptr<ChunkInfo> ChunkVectorInfo::Read(ReadStream &reader) {
-	auto start = reader.Read<idx_t>();
-	auto result = make_uniq<ChunkVectorInfo>(start);
-	result->any_deleted = true;
-	ValidityMask mask;
-	mask.Read(reader, STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-		if (mask.RowIsValid(i)) {
-			result->deleted[i] = 0;
-		}
-	}
-	return std::move(result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/column_checkpoint_state.cpp b/src/duckdb/src/storage/table/column_checkpoint_state.cpp
deleted file mode 100644
index a67daa060..000000000
--- a/src/duckdb/src/storage/table/column_checkpoint_state.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-
-#include "duckdb/main/config.hpp"
-
-namespace duckdb {
-
-ColumnCheckpointState::ColumnCheckpointState(RowGroup &row_group, ColumnData &column_data,
-                                             PartialBlockManager &partial_block_manager)
-    : row_group(row_group), column_data(column_data), partial_block_manager(partial_block_manager) {
-}
-
-ColumnCheckpointState::~ColumnCheckpointState() {
-}
-
-unique_ptr<BaseStatistics> ColumnCheckpointState::GetStatistics() {
-	D_ASSERT(global_stats);
-	return std::move(global_stats);
-}
-
-PartialBlockForCheckpoint::PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
-                                                     BlockManager &block_manager)
-    : PartialBlock(state, block_manager, segment.block) {
-	AddSegmentToTail(data, segment, 0);
-}
-
-PartialBlockForCheckpoint::~PartialBlockForCheckpoint() {
-	D_ASSERT(IsFlushed() || Exception::UncaughtException());
-}
-
-bool PartialBlockForCheckpoint::IsFlushed() {
-	// segments are cleared on Flush
-	return segments.empty();
-}
-
-void PartialBlockForCheckpoint::Flush(const idx_t free_space_left) {
-	if (IsFlushed()) {
-		throw InternalException("Flush called on partial block that was already flushed");
-	}
-
-	// zero-initialize unused memory
-	FlushInternal(free_space_left);
-
-	// At this point, we've already copied all data from tail_segments
-	// into the page owned by first_segment. We flush all segment data to
-	// disk with the following call.
-	// persist the first segment to disk and point the remaining segments to the same block
-	bool fetch_new_block = state.block_id == INVALID_BLOCK;
-	if (fetch_new_block) {
-		state.block_id = block_manager.GetFreeBlockId();
-	}
-
-	for (idx_t i = 0; i < segments.size(); i++) {
-		auto &segment = segments[i];
-		if (i == 0) {
-			// the first segment is converted to persistent - this writes the data for ALL segments to disk
-			D_ASSERT(segment.offset_in_block == 0);
-			segment.segment.ConvertToPersistent(&block_manager, state.block_id);
-			// update the block after it has been converted to a persistent segment
-			block_handle = segment.segment.block;
-		} else {
-			// subsequent segments are MARKED as persistent - they don't need to be rewritten
-			segment.segment.MarkAsPersistent(block_handle, segment.offset_in_block);
-			if (fetch_new_block) {
-				// if we fetched a new block we need to increase the reference count to the block
-				block_manager.IncreaseBlockReferenceCount(state.block_id);
-			}
-		}
-	}
-
-	Clear();
-}
-
-void PartialBlockForCheckpoint::Merge(PartialBlock &other_p, idx_t offset, idx_t other_size) {
-	auto &other = other_p.Cast<PartialBlockForCheckpoint>();
-
-	auto &buffer_manager = block_manager.buffer_manager;
-	// pin the source block
-	auto old_handle = buffer_manager.Pin(other.block_handle);
-	// pin the target block
-	auto new_handle = buffer_manager.Pin(block_handle);
-	// memcpy the contents of the old block to the new block
-	memcpy(new_handle.Ptr() + offset, old_handle.Ptr(), other_size);
-
-	// now copy over all segments to the new block
-	// move over the uninitialized regions
-	for (auto &region : other.uninitialized_regions) {
-		region.start += offset;
-		region.end += offset;
-		uninitialized_regions.push_back(region);
-	}
-
-	// move over the segments
-	for (auto &segment : other.segments) {
-		AddSegmentToTail(segment.data, segment.segment, NumericCast<uint32_t>(segment.offset_in_block + offset));
-	}
-
-	other.Clear();
-}
-
-void PartialBlockForCheckpoint::AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block) {
-	segments.emplace_back(data, segment, offset_in_block);
-}
-
-void PartialBlockForCheckpoint::Clear() {
-	uninitialized_regions.clear();
-	block_handle.reset();
-	segments.clear();
-}
-
-void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, BufferHandle handle, idx_t segment_size) {
-	handle.Destroy();
-	FlushSegmentInternal(std::move(segment), segment_size);
-}
-
-void ColumnCheckpointState::FlushSegmentInternal(unique_ptr<ColumnSegment> segment, idx_t segment_size) {
-	auto block_size = partial_block_manager.GetBlockManager().GetBlockSize();
-	D_ASSERT(segment_size <= block_size);
-
-	auto tuple_count = segment->count.load();
-	if (tuple_count == 0) { // LCOV_EXCL_START
-		return;
-	} // LCOV_EXCL_STOP
-
-	// merge the segment stats into the global stats
-	global_stats->Merge(segment->stats.statistics);
-
-	// get the buffer of the segment and pin it
-	auto &db = column_data.GetDatabase();
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	block_id_t block_id = INVALID_BLOCK;
-	uint32_t offset_in_block = 0;
-
-	unique_lock<mutex> partial_block_lock;
-	if (!segment->stats.statistics.IsConstant()) {
-		partial_block_lock = partial_block_manager.GetLock();
-
-		// non-constant block
-		PartialBlockAllocation allocation =
-		    partial_block_manager.GetBlockAllocation(NumericCast<uint32_t>(segment_size));
-		block_id = allocation.state.block_id;
-		offset_in_block = allocation.state.offset;
-
-		if (allocation.partial_block) {
-			// Use an existing block.
-			D_ASSERT(offset_in_block > 0);
-			auto &pstate = allocation.partial_block->Cast<PartialBlockForCheckpoint>();
-			// pin the source block
-			auto old_handle = buffer_manager.Pin(segment->block);
-			// pin the target block
-			auto new_handle = buffer_manager.Pin(pstate.block_handle);
-			// memcpy the contents of the old block to the new block
-			memcpy(new_handle.Ptr() + offset_in_block, old_handle.Ptr(), segment_size);
-			pstate.AddSegmentToTail(column_data, *segment, offset_in_block);
-		} else {
-			// Create a new block for future reuse.
-			if (segment->SegmentSize() != block_size) {
-				// the segment is smaller than the block size
-				// allocate a new block and copy the data over
-				D_ASSERT(segment->SegmentSize() < block_size);
-				segment->Resize(block_size);
-			}
-			D_ASSERT(offset_in_block == 0);
-			allocation.partial_block = make_uniq<PartialBlockForCheckpoint>(column_data, *segment, allocation.state,
-			                                                                *allocation.block_manager);
-		}
-		// Writer will decide whether to reuse this block.
-		partial_block_manager.RegisterPartialBlock(std::move(allocation));
-	} else {
-		segment->ConvertToPersistent(nullptr, INVALID_BLOCK);
-	}
-
-	// construct the data pointer
-	DataPointer data_pointer(segment->stats.statistics.Copy());
-	data_pointer.block_pointer.block_id = block_id;
-	data_pointer.block_pointer.offset = offset_in_block;
-	data_pointer.row_start = row_group.start;
-	if (!data_pointers.empty()) {
-		auto &last_pointer = data_pointers.back();
-		data_pointer.row_start = last_pointer.row_start + last_pointer.tuple_count;
-	}
-	data_pointer.tuple_count = tuple_count;
-	auto &compression_function = segment->GetCompressionFunction();
-	data_pointer.compression_type = compression_function.type;
-	if (compression_function.serialize_state) {
-		data_pointer.segment_state = compression_function.serialize_state(*segment);
-	}
-
-	// append the segment to the new segment tree
-	new_tree.AppendSegment(std::move(segment));
-	data_pointers.push_back(std::move(data_pointer));
-}
-
-PersistentColumnData ColumnCheckpointState::ToPersistentData() {
-	PersistentColumnData data(column_data.type.InternalType());
-	data.pointers = std::move(data_pointers);
-	return data;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/column_data.cpp b/src/duckdb/src/storage/table/column_data.cpp
deleted file mode 100644
index 985a59415..000000000
--- a/src/duckdb/src/storage/table/column_data.cpp
+++ /dev/null
@@ -1,958 +0,0 @@
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/compression_function.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/storage/table/list_column_data.hpp"
-#include "duckdb/storage/table/standard_column_data.hpp"
-#include "duckdb/storage/table/array_column_data.hpp"
-#include "duckdb/storage/table/struct_column_data.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/common/serializer/read_stream.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-
-namespace duckdb {
-
-ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-                       LogicalType type_p, optional_ptr<ColumnData> parent)
-    : start(start_row), count(0), block_manager(block_manager), info(info), column_index(column_index),
-      type(std::move(type_p)), allocation_size(0), parent(parent) {
-	if (!parent) {
-		stats = make_uniq<SegmentStatistics>(type);
-	}
-}
-
-ColumnData::~ColumnData() {
-}
-
-void ColumnData::SetStart(idx_t new_start) {
-	this->start = new_start;
-	idx_t offset = 0;
-	for (auto &segment : data.Segments()) {
-		segment.start = start + offset;
-		offset += segment.count;
-	}
-	data.Reinitialize();
-}
-
-DatabaseInstance &ColumnData::GetDatabase() const {
-	return info.GetDB().GetDatabase();
-}
-
-DataTableInfo &ColumnData::GetTableInfo() const {
-	return info;
-}
-
-const LogicalType &ColumnData::RootType() const {
-	if (parent) {
-		return parent->RootType();
-	}
-	return type;
-}
-
-bool ColumnData::HasUpdates() const {
-	lock_guard<mutex> update_guard(update_lock);
-	return updates.get();
-}
-
-bool ColumnData::HasChanges(idx_t start_row, idx_t end_row) const {
-	if (!updates) {
-		return false;
-	}
-	if (updates->HasUpdates(start_row, end_row)) {
-		return true;
-	}
-	return false;
-}
-
-void ColumnData::ClearUpdates() {
-	lock_guard<mutex> update_guard(update_lock);
-	updates.reset();
-}
-
-idx_t ColumnData::GetMaxEntry() {
-	return count;
-}
-
-void ColumnData::InitializeScan(ColumnScanState &state) {
-	state.current = data.GetRootSegment();
-	state.segment_tree = &data;
-	state.row_index = state.current ? state.current->start : 0;
-	state.internal_index = state.row_index;
-	state.initialized = false;
-	state.scan_state.reset();
-	state.last_offset = 0;
-}
-
-void ColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	state.current = data.GetSegment(row_idx);
-	state.segment_tree = &data;
-	state.row_index = row_idx;
-	state.internal_index = state.current->start;
-	state.initialized = false;
-	state.scan_state.reset();
-	state.last_offset = 0;
-}
-
-ScanVectorType ColumnData::GetVectorScanType(ColumnScanState &state, idx_t scan_count, Vector &result) {
-	if (result.GetVectorType() != VectorType::FLAT_VECTOR) {
-		return ScanVectorType::SCAN_ENTIRE_VECTOR;
-	}
-	if (HasUpdates()) {
-		// if we have updates we need to merge in the updates
-		// always need to scan flat vectors
-		return ScanVectorType::SCAN_FLAT_VECTOR;
-	}
-	// check if the current segment has enough data remaining
-	idx_t remaining_in_segment = state.current->start + state.current->count - state.row_index;
-	if (remaining_in_segment < scan_count) {
-		// there is not enough data remaining in the current segment so we need to scan across segments
-		// we need flat vectors here
-		return ScanVectorType::SCAN_FLAT_VECTOR;
-	}
-	return ScanVectorType::SCAN_ENTIRE_VECTOR;
-}
-
-void ColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t remaining) {
-	auto current_segment = scan_state.current;
-	if (!current_segment) {
-		return;
-	}
-	if (!scan_state.initialized) {
-		// need to prefetch for the current segment if we have not yet initialized the scan for this segment
-		scan_state.current->InitializePrefetch(prefetch_state, scan_state);
-	}
-	idx_t row_index = scan_state.row_index;
-	while (remaining > 0) {
-		idx_t scan_count = MinValue<idx_t>(remaining, current_segment->start + current_segment->count - row_index);
-		remaining -= scan_count;
-		row_index += scan_count;
-		if (remaining > 0) {
-			auto next = data.GetNextSegment(current_segment);
-			if (!next) {
-				break;
-			}
-			next->InitializePrefetch(prefetch_state, scan_state);
-			current_segment = next;
-		}
-	}
-}
-
-void ColumnData::BeginScanVectorInternal(ColumnScanState &state) {
-	state.previous_states.clear();
-	if (!state.initialized) {
-		D_ASSERT(state.current);
-		state.current->InitializeScan(state);
-		state.internal_index = state.current->start;
-		state.initialized = true;
-	}
-	D_ASSERT(data.HasSegment(state.current));
-	D_ASSERT(state.internal_index <= state.row_index);
-	if (state.internal_index < state.row_index) {
-		state.current->Skip(state);
-	}
-	D_ASSERT(state.current->type == type);
-}
-
-idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, ScanVectorType scan_type) {
-	if (scan_type == ScanVectorType::SCAN_FLAT_VECTOR && result.GetVectorType() != VectorType::FLAT_VECTOR) {
-		throw InternalException("ScanVector called with SCAN_FLAT_VECTOR but result is not a flat vector");
-	}
-	BeginScanVectorInternal(state);
-	idx_t initial_remaining = remaining;
-	while (remaining > 0) {
-		D_ASSERT(state.row_index >= state.current->start &&
-		         state.row_index <= state.current->start + state.current->count);
-		idx_t scan_count = MinValue<idx_t>(remaining, state.current->start + state.current->count - state.row_index);
-		idx_t result_offset = initial_remaining - remaining;
-		if (scan_count > 0) {
-			if (state.scan_options && state.scan_options->force_fetch_row) {
-				for (idx_t i = 0; i < scan_count; i++) {
-					ColumnFetchState fetch_state;
-					state.current->FetchRow(fetch_state, UnsafeNumericCast<row_t>(state.row_index + i), result,
-					                        result_offset + i);
-				}
-			} else {
-				state.current->Scan(state, scan_count, result, result_offset, scan_type);
-			}
-
-			state.row_index += scan_count;
-			remaining -= scan_count;
-		}
-
-		if (remaining > 0) {
-			auto next = data.GetNextSegment(state.current);
-			if (!next) {
-				break;
-			}
-			state.previous_states.emplace_back(std::move(state.scan_state));
-			state.current = next;
-			state.current->InitializeScan(state);
-			state.segment_checked = false;
-			D_ASSERT(state.row_index >= state.current->start &&
-			         state.row_index <= state.current->start + state.current->count);
-		}
-	}
-	state.internal_index = state.row_index;
-	return initial_remaining - remaining;
-}
-
-void ColumnData::SelectVector(ColumnScanState &state, Vector &result, idx_t target_count, const SelectionVector &sel,
-                              idx_t sel_count) {
-	BeginScanVectorInternal(state);
-	if (state.current->start + state.current->count - state.row_index < target_count) {
-		throw InternalException("ColumnData::SelectVector should be able to fetch everything from one segment");
-	}
-	if (state.scan_options && state.scan_options->force_fetch_row) {
-		for (idx_t i = 0; i < sel_count; i++) {
-			auto source_idx = sel.get_index(i);
-			ColumnFetchState fetch_state;
-			state.current->FetchRow(fetch_state, UnsafeNumericCast<row_t>(state.row_index + source_idx), result, i);
-		}
-	} else {
-		state.current->Select(state, target_count, result, sel, sel_count);
-	}
-	state.row_index += target_count;
-	state.internal_index = state.row_index;
-}
-
-void ColumnData::FilterVector(ColumnScanState &state, Vector &result, idx_t target_count, SelectionVector &sel,
-                              idx_t &sel_count, const TableFilter &filter) {
-	BeginScanVectorInternal(state);
-	if (state.current->start + state.current->count - state.row_index < target_count) {
-		throw InternalException("ColumnData::Filter should be able to fetch everything from one segment");
-	}
-	state.current->Filter(state, target_count, result, sel, sel_count, filter);
-	state.row_index += target_count;
-	state.internal_index = state.row_index;
-}
-
-unique_ptr<BaseStatistics> ColumnData::GetUpdateStatistics() {
-	lock_guard<mutex> update_guard(update_lock);
-	return updates ? updates->GetStatistics() : nullptr;
-}
-
-void ColumnData::FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result, idx_t scan_count,
-                              bool allow_updates, bool scan_committed) {
-	lock_guard<mutex> update_guard(update_lock);
-	if (!updates) {
-		return;
-	}
-	if (!allow_updates && updates->HasUncommittedUpdates(vector_index)) {
-		throw TransactionException("Cannot create index with outstanding updates");
-	}
-	result.Flatten(scan_count);
-	if (scan_committed) {
-		updates->FetchCommitted(vector_index, result);
-	} else {
-		updates->FetchUpdates(transaction, vector_index, result);
-	}
-}
-
-void ColumnData::FetchUpdateRow(TransactionData transaction, row_t row_id, Vector &result, idx_t result_idx) {
-	lock_guard<mutex> update_guard(update_lock);
-	if (!updates) {
-		return;
-	}
-	updates->FetchRow(transaction, NumericCast<idx_t>(row_id), result, result_idx);
-}
-
-void ColumnData::UpdateInternal(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                                idx_t update_count, Vector &base_vector) {
-	lock_guard<mutex> update_guard(update_lock);
-	if (!updates) {
-		updates = make_uniq<UpdateSegment>(*this);
-	}
-	updates->Update(transaction, column_index, update_vector, row_ids, update_count, base_vector);
-}
-
-idx_t ColumnData::ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                             idx_t target_scan, ScanVectorType scan_type, ScanVectorMode mode) {
-	auto scan_count = ScanVector(state, result, target_scan, scan_type);
-	if (scan_type != ScanVectorType::SCAN_ENTIRE_VECTOR) {
-		// if we are scanning an entire vector we cannot have updates
-		bool allow_updates = mode != ScanVectorMode::SCAN_COMMITTED_NO_UPDATES;
-		bool scan_committed = mode != ScanVectorMode::REGULAR_SCAN;
-		FetchUpdates(transaction, vector_index, result, scan_count, allow_updates, scan_committed);
-	}
-	return scan_count;
-}
-
-idx_t ColumnData::ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                             idx_t target_scan, ScanVectorMode mode) {
-	auto scan_type = GetVectorScanType(state, target_scan, result);
-	return ScanVector(transaction, vector_index, state, result, target_scan, scan_type, mode);
-}
-
-idx_t ColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
-	auto target_count = GetVectorCount(vector_index);
-	return Scan(transaction, vector_index, state, result, target_count);
-}
-
-idx_t ColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) {
-	auto target_count = GetVectorCount(vector_index);
-	return ScanCommitted(vector_index, state, result, allow_updates, target_count);
-}
-
-idx_t ColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                       idx_t scan_count) {
-	return ScanVector(transaction, vector_index, state, result, scan_count, ScanVectorMode::REGULAR_SCAN);
-}
-
-idx_t ColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-                                idx_t scan_count) {
-	auto mode = allow_updates ? ScanVectorMode::SCAN_COMMITTED : ScanVectorMode::SCAN_COMMITTED_NO_UPDATES;
-	TransactionData commit_transaction(0, 0);
-	return ScanVector(commit_transaction, vector_index, state, result, scan_count, mode);
-}
-
-idx_t ColumnData::GetVectorCount(idx_t vector_index) const {
-	idx_t current_row = vector_index * STANDARD_VECTOR_SIZE;
-	return MinValue<idx_t>(STANDARD_VECTOR_SIZE, count - current_row);
-}
-
-void ColumnData::ScanCommittedRange(idx_t row_group_start, idx_t offset_in_row_group, idx_t s_count, Vector &result) {
-	ColumnScanState child_state;
-	InitializeScanWithOffset(child_state, row_group_start + offset_in_row_group);
-	bool has_updates = HasUpdates();
-	auto scan_count = ScanVector(child_state, result, s_count, ScanVectorType::SCAN_FLAT_VECTOR);
-	if (has_updates) {
-		D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-		result.Flatten(scan_count);
-		updates->FetchCommittedRange(offset_in_row_group, s_count, result);
-	}
-}
-
-idx_t ColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t scan_count) {
-	if (scan_count == 0) {
-		return 0;
-	}
-	// ScanCount can only be used if there are no updates
-	D_ASSERT(!HasUpdates());
-	return ScanVector(state, result, scan_count, ScanVectorType::SCAN_FLAT_VECTOR);
-}
-
-void ColumnData::Filter(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                        SelectionVector &sel, idx_t &s_count, const TableFilter &filter) {
-	idx_t scan_count = Scan(transaction, vector_index, state, result);
-
-	UnifiedVectorFormat vdata;
-	result.ToUnifiedFormat(scan_count, vdata);
-	ColumnSegment::FilterSelection(sel, result, vdata, filter, scan_count, s_count);
-}
-
-void ColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                        SelectionVector &sel, idx_t s_count) {
-	Scan(transaction, vector_index, state, result);
-	result.Slice(sel, s_count);
-}
-
-void ColumnData::SelectCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel,
-                                 idx_t s_count, bool allow_updates) {
-	ScanCommitted(vector_index, state, result, allow_updates);
-	result.Slice(sel, s_count);
-}
-
-void ColumnData::Skip(ColumnScanState &state, idx_t s_count) {
-	state.Next(s_count);
-}
-
-void ColumnData::Append(BaseStatistics &append_stats, ColumnAppendState &state, Vector &vector, idx_t append_count) {
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(append_count, vdata);
-	AppendData(append_stats, state, vdata, append_count);
-}
-
-void ColumnData::Append(ColumnAppendState &state, Vector &vector, idx_t append_count) {
-	if (parent || !stats) {
-		throw InternalException("ColumnData::Append called on a column with a parent or without stats");
-	}
-	lock_guard<mutex> l(stats_lock);
-	Append(stats->statistics, state, vector, append_count);
-}
-
-FilterPropagateResult ColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	if (state.segment_checked) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	if (!state.current) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	state.segment_checked = true;
-	FilterPropagateResult prune_result;
-	{
-		lock_guard<mutex> l(stats_lock);
-		prune_result = filter.CheckStatistics(state.current->stats.statistics);
-		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-	}
-	lock_guard<mutex> l(update_lock);
-	if (!updates) {
-		// no updates - return original result
-		return prune_result;
-	}
-	auto update_stats = updates->GetStatistics();
-	// combine the update and original prune result
-	FilterPropagateResult update_result = filter.CheckStatistics(*update_stats);
-	if (prune_result == update_result) {
-		return prune_result;
-	}
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-FilterPropagateResult ColumnData::CheckZonemap(TableFilter &filter) {
-	if (!stats) {
-		throw InternalException("ColumnData::CheckZonemap called on a column without stats");
-	}
-	lock_guard<mutex> l(stats_lock);
-	return filter.CheckStatistics(stats->statistics);
-}
-
-unique_ptr<BaseStatistics> ColumnData::GetStatistics() {
-	if (!stats) {
-		throw InternalException("ColumnData::GetStatistics called on a column without stats");
-	}
-	lock_guard<mutex> l(stats_lock);
-	return stats->statistics.ToUnique();
-}
-
-void ColumnData::MergeStatistics(const BaseStatistics &other) {
-	if (!stats) {
-		throw InternalException("ColumnData::MergeStatistics called on a column without stats");
-	}
-	lock_guard<mutex> l(stats_lock);
-	return stats->statistics.Merge(other);
-}
-
-void ColumnData::MergeIntoStatistics(BaseStatistics &other) {
-	if (!stats) {
-		throw InternalException("ColumnData::MergeIntoStatistics called on a column without stats");
-	}
-	lock_guard<mutex> l(stats_lock);
-	return other.Merge(stats->statistics);
-}
-
-void ColumnData::InitializeAppend(ColumnAppendState &state) {
-	auto l = data.Lock();
-	if (data.IsEmpty(l)) {
-		// no segments yet, append an empty segment
-		AppendTransientSegment(l, start);
-	}
-	auto segment = data.GetLastSegment(l);
-	if (segment->segment_type == ColumnSegmentType::PERSISTENT || !segment->GetCompressionFunction().init_append) {
-		// we cannot append to this segment - append a new segment
-		auto total_rows = segment->start + segment->count;
-		AppendTransientSegment(l, total_rows);
-		state.current = data.GetLastSegment(l);
-	} else {
-		state.current = segment;
-	}
-
-	D_ASSERT(state.current->segment_type == ColumnSegmentType::TRANSIENT);
-	state.current->InitializeAppend(state);
-	D_ASSERT(state.current->GetCompressionFunction().append);
-}
-
-void ColumnData::AppendData(BaseStatistics &append_stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
-                            idx_t append_count) {
-	idx_t offset = 0;
-	this->count += append_count;
-	while (true) {
-		// append the data from the vector
-		idx_t copied_elements = state.current->Append(state, vdata, offset, append_count);
-		append_stats.Merge(state.current->stats.statistics);
-		if (copied_elements == append_count) {
-			// finished copying everything
-			break;
-		}
-
-		// we couldn't fit everything we wanted in the current column segment, create a new one
-		{
-			auto l = data.Lock();
-			AppendTransientSegment(l, state.current->start + state.current->count);
-			state.current = data.GetLastSegment(l);
-			state.current->InitializeAppend(state);
-		}
-		offset += copied_elements;
-		append_count -= copied_elements;
-	}
-}
-
-void ColumnData::RevertAppend(row_t start_row) {
-	auto l = data.Lock();
-	// check if this row is in the segment tree at all
-	auto last_segment = data.GetLastSegment(l);
-	if (NumericCast<idx_t>(start_row) >= last_segment->start + last_segment->count) {
-		// the start row is equal to the final portion of the column data: nothing was ever appended here
-		D_ASSERT(NumericCast<idx_t>(start_row) == last_segment->start + last_segment->count);
-		return;
-	}
-	// find the segment index that the current row belongs to
-	idx_t segment_index = data.GetSegmentIndex(l, UnsafeNumericCast<idx_t>(start_row));
-	auto segment = data.GetSegmentByIndex(l, UnsafeNumericCast<int64_t>(segment_index));
-	auto &transient = *segment;
-	D_ASSERT(transient.segment_type == ColumnSegmentType::TRANSIENT);
-
-	// remove any segments AFTER this segment: they should be deleted entirely
-	data.EraseSegments(l, segment_index);
-
-	this->count = UnsafeNumericCast<idx_t>(start_row) - this->start;
-	segment->next = nullptr;
-	transient.RevertAppend(UnsafeNumericCast<idx_t>(start_row));
-}
-
-idx_t ColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	D_ASSERT(row_id >= 0);
-	D_ASSERT(NumericCast<idx_t>(row_id) >= start);
-	// perform the fetch within the segment
-	state.row_index =
-	    start + ((UnsafeNumericCast<idx_t>(row_id) - start) / STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE);
-	state.current = data.GetSegment(state.row_index);
-	state.internal_index = state.current->start;
-	return ScanVector(state, result, STANDARD_VECTOR_SIZE, ScanVectorType::SCAN_FLAT_VECTOR);
-}
-
-void ColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                          idx_t result_idx) {
-	auto segment = data.GetSegment(UnsafeNumericCast<idx_t>(row_id));
-
-	// now perform the fetch within the segment
-	segment->FetchRow(state, row_id, result, result_idx);
-	// merge any updates made to this row
-
-	FetchUpdateRow(transaction, row_id, result, result_idx);
-}
-
-void ColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                        idx_t update_count) {
-	Vector base_vector(type);
-	ColumnScanState state;
-	auto fetch_count = Fetch(state, row_ids[0], base_vector);
-
-	base_vector.Flatten(fetch_count);
-	UpdateInternal(transaction, column_index, update_vector, row_ids, update_count, base_vector);
-}
-
-void ColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-                              row_t *row_ids, idx_t update_count, idx_t depth) {
-	// this method should only be called at the end of the path in the base column case
-	D_ASSERT(depth >= column_path.size());
-	ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
-}
-
-void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) {
-
-	const auto block_size = block_manager.GetBlockSize();
-	const auto type_size = GetTypeIdSize(type.InternalType());
-	auto vector_segment_size = block_size;
-
-	if (start_row == NumericCast<idx_t>(MAX_ROW_ID)) {
-#if STANDARD_VECTOR_SIZE < 1024
-		vector_segment_size = 1024 * type_size;
-#else
-		vector_segment_size = STANDARD_VECTOR_SIZE * type_size;
-#endif
-	}
-
-	// The segment size is bound by the block size, but can be smaller.
-	idx_t segment_size = block_size < vector_segment_size ? block_size : vector_segment_size;
-	allocation_size += segment_size;
-
-	auto &db = GetDatabase();
-	auto &config = DBConfig::GetConfig(db);
-	auto function = config.GetCompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, type.InternalType());
-
-	auto new_segment = ColumnSegment::CreateTransientSegment(db, *function, type, start_row, segment_size, block_size);
-	AppendSegment(l, std::move(new_segment));
-}
-
-void ColumnData::UpdateCompressionFunction(SegmentLock &l, const CompressionFunction &function) {
-	if (!compression) {
-		// compression is empty...
-		// if we have no segments - we have not set it yet, so assign it
-		// if we have segments, the compression is mixed, so ignore it
-		if (data.GetSegmentCount(l) == 0) {
-			compression.set(function);
-		}
-	} else if (compression->type != function.type) {
-		// we already have compression set - and we are adding a segment with a different compression
-		// compression in the segment is mixed - clear the compression pointer
-		compression.reset();
-	}
-}
-
-void ColumnData::AppendSegment(SegmentLock &l, unique_ptr<ColumnSegment> segment) {
-	UpdateCompressionFunction(l, segment->GetCompressionFunction());
-	data.AppendSegment(l, std::move(segment));
-}
-
-void ColumnData::CommitDropColumn() {
-	for (auto &segment_p : data.Segments()) {
-		auto &segment = segment_p;
-		segment.CommitDropSegment();
-	}
-}
-
-unique_ptr<ColumnCheckpointState> ColumnData::CreateCheckpointState(RowGroup &row_group,
-                                                                    PartialBlockManager &partial_block_manager) {
-	return make_uniq<ColumnCheckpointState>(row_group, *this, partial_block_manager);
-}
-
-void ColumnData::CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
-                                Vector &scan_vector) {
-	if (state.scan_options && state.scan_options->force_fetch_row) {
-		for (idx_t i = 0; i < count; i++) {
-			ColumnFetchState fetch_state;
-			segment.FetchRow(fetch_state, UnsafeNumericCast<row_t>(state.row_index + i), scan_vector, i);
-		}
-	} else {
-		segment.Scan(state, count, scan_vector, 0, ScanVectorType::SCAN_FLAT_VECTOR);
-	}
-
-	if (updates) {
-		D_ASSERT(scan_vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		updates->FetchCommittedRange(state.row_index - row_group_start, count, scan_vector);
-	}
-}
-
-unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info) {
-	// scan the segments of the column data
-	// set up the checkpoint state
-	auto checkpoint_state = CreateCheckpointState(row_group, checkpoint_info.info.manager);
-	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type).ToUnique();
-
-	auto &nodes = data.ReferenceSegments();
-	if (nodes.empty()) {
-		// empty table: flush the empty list
-		return checkpoint_state;
-	}
-
-	vector<reference<ColumnCheckpointState>> states {*checkpoint_state};
-	ColumnDataCheckpointer checkpointer(states, GetDatabase(), row_group, checkpoint_info);
-	checkpointer.Checkpoint();
-	checkpointer.FinalizeCheckpoint();
-	return checkpoint_state;
-}
-
-void ColumnData::InitializeColumn(PersistentColumnData &column_data) {
-	InitializeColumn(column_data, stats->statistics);
-}
-
-void ColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) {
-	D_ASSERT(type.InternalType() == column_data.physical_type);
-	// construct the segments based on the data pointers
-	this->count = 0;
-	for (auto &data_pointer : column_data.pointers) {
-		// Update the count and statistics
-		this->count += data_pointer.tuple_count;
-
-		// Merge the statistics. If this is a child column, the target_stats reference will point into the parents stats
-		// otherwise if this is a top level column, `stats->statistics` == `target_stats`
-
-		target_stats.Merge(data_pointer.statistics);
-
-		// create a persistent segment
-		auto segment = ColumnSegment::CreatePersistentSegment(
-		    GetDatabase(), block_manager, data_pointer.block_pointer.block_id, data_pointer.block_pointer.offset, type,
-		    data_pointer.row_start, data_pointer.tuple_count, data_pointer.compression_type,
-		    std::move(data_pointer.statistics), std::move(data_pointer.segment_state));
-
-		auto l = data.Lock();
-		AppendSegment(l, std::move(segment));
-	}
-}
-
-bool ColumnData::IsPersistent() {
-	for (auto &segment : data.Segments()) {
-		if (segment.segment_type != ColumnSegmentType::PERSISTENT) {
-			return false;
-		}
-	}
-	return true;
-}
-
-vector<DataPointer> ColumnData::GetDataPointers() {
-	vector<DataPointer> pointers;
-	for (auto &segment : data.Segments()) {
-		pointers.push_back(segment.GetDataPointer());
-	}
-	return pointers;
-}
-
-PersistentColumnData::PersistentColumnData(PhysicalType physical_type_p) : physical_type(physical_type_p) {
-}
-
-PersistentColumnData::PersistentColumnData(PhysicalType physical_type, vector<DataPointer> pointers_p)
-    : physical_type(physical_type), pointers(std::move(pointers_p)) {
-	D_ASSERT(!pointers.empty());
-}
-
-PersistentColumnData::~PersistentColumnData() {
-}
-
-void PersistentColumnData::Serialize(Serializer &serializer) const {
-	if (has_updates) {
-		throw InternalException("Column data with updates cannot be serialized");
-	}
-	serializer.WritePropertyWithDefault(100, "data_pointers", pointers);
-	if (child_columns.empty()) {
-		// validity column
-		D_ASSERT(physical_type == PhysicalType::BIT);
-		return;
-	}
-	serializer.WriteProperty(101, "validity", child_columns[0]);
-	if (physical_type == PhysicalType::ARRAY || physical_type == PhysicalType::LIST) {
-		D_ASSERT(child_columns.size() == 2);
-		serializer.WriteProperty(102, "child_column", child_columns[1]);
-	} else if (physical_type == PhysicalType::STRUCT) {
-		serializer.WriteList(102, "sub_columns", child_columns.size() - 1,
-		                     [&](Serializer::List &list, idx_t i) { list.WriteElement(child_columns[i + 1]); });
-	}
-}
-
-void PersistentColumnData::DeserializeField(Deserializer &deserializer, field_id_t field_idx, const char *field_name,
-                                            const LogicalType &type) {
-	deserializer.Set<const LogicalType &>(type);
-	child_columns.push_back(deserializer.ReadProperty<PersistentColumnData>(field_idx, field_name));
-	deserializer.Unset<LogicalType>();
-}
-
-PersistentColumnData PersistentColumnData::Deserialize(Deserializer &deserializer) {
-	auto &type = deserializer.Get<const LogicalType &>();
-	auto physical_type = type.InternalType();
-	PersistentColumnData result(physical_type);
-	deserializer.ReadPropertyWithDefault(100, "data_pointers", static_cast<vector<DataPointer> &>(result.pointers));
-	if (result.physical_type == PhysicalType::BIT) {
-		// validity: return
-		return result;
-	}
-	result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY);
-	switch (physical_type) {
-	case PhysicalType::ARRAY:
-		result.DeserializeField(deserializer, 102, "child_column", ArrayType::GetChildType(type));
-		break;
-	case PhysicalType::LIST:
-		result.DeserializeField(deserializer, 102, "child_column", ListType::GetChildType(type));
-		break;
-	case PhysicalType::STRUCT: {
-		auto &child_types = StructType::GetChildTypes(type);
-		deserializer.ReadList(102, "sub_columns", [&](Deserializer::List &list, idx_t i) {
-			deserializer.Set<const LogicalType &>(child_types[i].second);
-			result.child_columns.push_back(list.ReadElement<PersistentColumnData>());
-			deserializer.Unset<LogicalType>();
-		});
-		break;
-	}
-	default:
-		break;
-	}
-	return result;
-}
-
-bool PersistentColumnData::HasUpdates() const {
-	if (has_updates) {
-		return true;
-	}
-	for (auto &child_col : child_columns) {
-		if (child_col.HasUpdates()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-PersistentRowGroupData::PersistentRowGroupData(vector<LogicalType> types_p) : types(std::move(types_p)) {
-}
-
-void PersistentRowGroupData::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(100, "types", types);
-	serializer.WriteProperty(101, "columns", column_data);
-	serializer.WriteProperty(102, "start", start);
-	serializer.WriteProperty(103, "count", count);
-}
-
-PersistentRowGroupData PersistentRowGroupData::Deserialize(Deserializer &deserializer) {
-	PersistentRowGroupData data;
-	deserializer.ReadProperty(100, "types", data.types);
-	deserializer.ReadList(101, "columns", [&](Deserializer::List &list, idx_t i) {
-		deserializer.Set<const LogicalType &>(data.types[i]);
-		data.column_data.push_back(list.ReadElement<PersistentColumnData>());
-		deserializer.Unset<LogicalType>();
-	});
-	deserializer.ReadProperty(102, "start", data.start);
-	deserializer.ReadProperty(103, "count", data.count);
-	return data;
-}
-
-bool PersistentRowGroupData::HasUpdates() const {
-	for (auto &col : column_data) {
-		if (col.HasUpdates()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void PersistentCollectionData::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(100, "row_groups", row_group_data);
-}
-
-PersistentCollectionData PersistentCollectionData::Deserialize(Deserializer &deserializer) {
-	PersistentCollectionData data;
-	deserializer.ReadProperty(100, "row_groups", data.row_group_data);
-	return data;
-}
-
-bool PersistentCollectionData::HasUpdates() const {
-	for (auto &row_group : row_group_data) {
-		if (row_group.HasUpdates()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-PersistentColumnData ColumnData::Serialize() {
-	PersistentColumnData result(type.InternalType(), GetDataPointers());
-	result.has_updates = HasUpdates();
-	return result;
-}
-
-shared_ptr<ColumnData> ColumnData::Deserialize(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-                                               idx_t start_row, ReadStream &source, const LogicalType &type) {
-	auto entry = ColumnData::CreateColumn(block_manager, info, column_index, start_row, type, nullptr);
-
-	// deserialize the persistent column data
-	BinaryDeserializer deserializer(source);
-	deserializer.Begin();
-	deserializer.Set<DatabaseInstance &>(info.GetDB().GetDatabase());
-	CompressionInfo compression_info(block_manager.GetBlockSize());
-	deserializer.Set<const CompressionInfo &>(compression_info);
-	deserializer.Set<const LogicalType &>(type);
-	auto persistent_column_data = PersistentColumnData::Deserialize(deserializer);
-	deserializer.Unset<LogicalType>();
-	deserializer.Unset<const CompressionInfo>();
-	deserializer.Unset<DatabaseInstance>();
-	deserializer.End();
-
-	// initialize the column
-	entry->InitializeColumn(persistent_column_data, entry->stats->statistics);
-	return entry;
-}
-
-void ColumnData::GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path,
-                                      vector<ColumnSegmentInfo> &result) {
-	D_ASSERT(!col_path.empty());
-
-	// convert the column path to a string
-	string col_path_str = "[";
-	for (idx_t i = 0; i < col_path.size(); i++) {
-		if (i > 0) {
-			col_path_str += ", ";
-		}
-		col_path_str += to_string(col_path[i]);
-	}
-	col_path_str += "]";
-
-	// iterate over the segments
-	idx_t segment_idx = 0;
-	auto segment = data.GetRootSegment();
-	while (segment) {
-		ColumnSegmentInfo column_info;
-		column_info.row_group_index = row_group_index;
-		column_info.column_id = col_path[0];
-		column_info.column_path = col_path_str;
-		column_info.segment_idx = segment_idx;
-		column_info.segment_type = type.ToString();
-		column_info.segment_start = segment->start;
-		column_info.segment_count = segment->count;
-		column_info.compression_type = CompressionTypeToString(segment->GetCompressionFunction().type);
-		{
-			lock_guard<mutex> l(stats_lock);
-			column_info.segment_stats = segment->stats.statistics.ToString();
-		}
-		column_info.has_updates = ColumnData::HasUpdates();
-		// persistent
-		// block_id
-		// block_offset
-		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			column_info.persistent = true;
-			column_info.block_id = segment->GetBlockId();
-			column_info.block_offset = segment->GetBlockOffset();
-		} else {
-			column_info.persistent = false;
-		}
-		auto segment_state = segment->GetSegmentState();
-		if (segment_state) {
-			column_info.segment_info = segment_state->GetSegmentInfo();
-			column_info.additional_blocks = segment_state->GetAdditionalBlocks();
-		}
-		result.emplace_back(column_info);
-
-		segment_idx++;
-		segment = data.GetNextSegment(segment);
-	}
-}
-
-void ColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	D_ASSERT(this->start == parent.start);
-	data.Verify();
-	if (type.InternalType() == PhysicalType::STRUCT || type.InternalType() == PhysicalType::ARRAY) {
-		// structs and fixed size lists don't have segments
-		D_ASSERT(!data.GetRootSegment());
-		return;
-	}
-	idx_t current_index = 0;
-	idx_t current_start = this->start;
-	idx_t total_count = 0;
-	for (auto &segment : data.Segments()) {
-		D_ASSERT(segment.index == current_index);
-		D_ASSERT(segment.start == current_start);
-		current_start += segment.count;
-		total_count += segment.count;
-		current_index++;
-	}
-	D_ASSERT(this->count == total_count);
-#endif
-}
-
-template <class RET, class OP>
-static RET CreateColumnInternal(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-                                const LogicalType &type, optional_ptr<ColumnData> parent) {
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		return OP::template Create<StructColumnData>(block_manager, info, column_index, start_row, type, parent);
-	} else if (type.InternalType() == PhysicalType::LIST) {
-		return OP::template Create<ListColumnData>(block_manager, info, column_index, start_row, type, parent);
-	} else if (type.InternalType() == PhysicalType::ARRAY) {
-		return OP::template Create<ArrayColumnData>(block_manager, info, column_index, start_row, type, parent);
-	} else if (type.id() == LogicalTypeId::VALIDITY) {
-		return OP::template Create<ValidityColumnData>(block_manager, info, column_index, start_row, *parent);
-	}
-	return OP::template Create<StandardColumnData>(block_manager, info, column_index, start_row, type, parent);
-}
-
-shared_ptr<ColumnData> ColumnData::CreateColumn(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-                                                idx_t start_row, const LogicalType &type,
-                                                optional_ptr<ColumnData> parent) {
-	return CreateColumnInternal<shared_ptr<ColumnData>, SharedConstructor>(block_manager, info, column_index, start_row,
-	                                                                       type, parent);
-}
-
-unique_ptr<ColumnData> ColumnData::CreateColumnUnique(BlockManager &block_manager, DataTableInfo &info,
-                                                      idx_t column_index, idx_t start_row, const LogicalType &type,
-                                                      optional_ptr<ColumnData> parent) {
-	return CreateColumnInternal<unique_ptr<ColumnData>, UniqueConstructor>(block_manager, info, column_index, start_row,
-	                                                                       type, parent);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/column_data_checkpointer.cpp b/src/duckdb/src/storage/table/column_data_checkpointer.cpp
deleted file mode 100644
index ae92a6972..000000000
--- a/src/duckdb/src/storage/table/column_data_checkpointer.cpp
+++ /dev/null
@@ -1,432 +0,0 @@
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/compression/empty_validity.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-//! ColumnDataCheckpointData
-
-CompressionFunction &ColumnDataCheckpointData::GetCompressionFunction(CompressionType compression_type) {
-	auto &db = col_data->GetDatabase();
-	auto &column_type = col_data->type;
-	auto &config = DBConfig::GetConfig(db);
-	return *config.GetCompressionFunction(compression_type, column_type.InternalType());
-}
-
-DatabaseInstance &ColumnDataCheckpointData::GetDatabase() {
-	return col_data->GetDatabase();
-}
-
-const LogicalType &ColumnDataCheckpointData::GetType() const {
-	return col_data->type;
-}
-
-ColumnData &ColumnDataCheckpointData::GetColumnData() {
-	return *col_data;
-}
-
-RowGroup &ColumnDataCheckpointData::GetRowGroup() {
-	return *row_group;
-}
-
-ColumnCheckpointState &ColumnDataCheckpointData::GetCheckpointState() {
-	return *checkpoint_state;
-}
-
-//! ColumnDataCheckpointer
-
-static Vector CreateIntermediateVector(vector<reference<ColumnCheckpointState>> &states) {
-	D_ASSERT(!states.empty());
-
-	auto &first_state = states[0];
-	auto &col_data = first_state.get().column_data;
-	auto &type = col_data.type;
-	if (type.id() == LogicalTypeId::VALIDITY) {
-		return Vector(LogicalType::BOOLEAN, true, /* initialize_to_zero = */ true);
-	}
-	return Vector(type, true, false);
-}
-
-ColumnDataCheckpointer::ColumnDataCheckpointer(vector<reference<ColumnCheckpointState>> &checkpoint_states,
-                                               DatabaseInstance &db, RowGroup &row_group,
-                                               ColumnCheckpointInfo &checkpoint_info)
-    : checkpoint_states(checkpoint_states), db(db), row_group(row_group),
-      intermediate(CreateIntermediateVector(checkpoint_states)), checkpoint_info(checkpoint_info) {
-
-	auto &config = DBConfig::GetConfig(db);
-	compression_functions.resize(checkpoint_states.size());
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		auto &col_data = checkpoint_states[i].get().column_data;
-		auto to_add = config.GetCompressionFunctions(col_data.type.InternalType());
-		auto &functions = compression_functions[i];
-		for (auto &func : to_add) {
-			functions.push_back(&func.get());
-		}
-	}
-}
-
-void ColumnDataCheckpointer::ScanSegments(const std::function<void(Vector &, idx_t)> &callback) {
-	Vector scan_vector(intermediate.GetType(), nullptr);
-	auto &first_state = checkpoint_states[0];
-	auto &col_data = first_state.get().column_data;
-	auto &nodes = col_data.data.ReferenceSegments();
-
-	// TODO: scan all the nodes from all segments, no need for CheckpointScan to virtualize this I think..
-	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto &segment = *nodes[segment_idx].node;
-		ColumnScanState scan_state;
-		scan_state.current = &segment;
-		segment.InitializeScan(scan_state);
-
-		for (idx_t base_row_index = 0; base_row_index < segment.count; base_row_index += STANDARD_VECTOR_SIZE) {
-			scan_vector.Reference(intermediate);
-
-			idx_t count = MinValue<idx_t>(segment.count - base_row_index, STANDARD_VECTOR_SIZE);
-			scan_state.row_index = segment.start + base_row_index;
-
-			col_data.CheckpointScan(segment, scan_state, row_group.start, count, scan_vector);
-			callback(scan_vector, count);
-		}
-	}
-}
-
-CompressionType ForceCompression(vector<optional_ptr<CompressionFunction>> &compression_functions,
-                                 CompressionType compression_type) {
-// On of the force_compression flags has been set
-// check if this compression method is available
-#ifdef DEBUG
-	if (CompressionTypeIsDeprecated(compression_type)) {
-		throw InternalException("Deprecated compression type: %s", CompressionTypeToString(compression_type));
-	}
-#endif
-	bool found = false;
-	for (idx_t i = 0; i < compression_functions.size(); i++) {
-		auto &compression_function = *compression_functions[i];
-		if (compression_function.type == compression_type) {
-			found = true;
-			break;
-		}
-	}
-	if (!found) {
-		return CompressionType::COMPRESSION_AUTO;
-	}
-	// the force_compression method is available
-	// clear all other compression methods
-	// except the uncompressed method, so we can fall back on that
-	for (idx_t i = 0; i < compression_functions.size(); i++) {
-		auto &compression_function = *compression_functions[i];
-		if (compression_function.type == CompressionType::COMPRESSION_UNCOMPRESSED) {
-			continue;
-		}
-		if (compression_function.type != compression_type) {
-			compression_functions[i] = nullptr;
-		}
-	}
-	return compression_type;
-}
-
-void ColumnDataCheckpointer::InitAnalyze() {
-	analyze_states.resize(checkpoint_states.size());
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		if (!has_changes[i]) {
-			continue;
-		}
-
-		auto &functions = compression_functions[i];
-		auto &states = analyze_states[i];
-		auto &checkpoint_state = checkpoint_states[i];
-		auto &coldata = checkpoint_state.get().column_data;
-		states.resize(functions.size());
-		for (idx_t j = 0; j < functions.size(); j++) {
-			auto &func = functions[j];
-			if (!func) {
-				continue;
-			}
-			states[j] = func->init_analyze(coldata, coldata.type.InternalType());
-		}
-	}
-}
-
-vector<CheckpointAnalyzeResult> ColumnDataCheckpointer::DetectBestCompressionMethod() {
-	D_ASSERT(!compression_functions.empty());
-	auto &config = DBConfig::GetConfig(db);
-	vector<CompressionType> forced_methods(checkpoint_states.size(), CompressionType::COMPRESSION_AUTO);
-
-	auto compression_type = checkpoint_info.GetCompressionType();
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		auto &functions = compression_functions[i];
-		if (compression_type != CompressionType::COMPRESSION_AUTO) {
-			forced_methods[i] = ForceCompression(functions, compression_type);
-		}
-		if (compression_type == CompressionType::COMPRESSION_AUTO &&
-		    config.options.force_compression != CompressionType::COMPRESSION_AUTO) {
-			forced_methods[i] = ForceCompression(functions, config.options.force_compression);
-		}
-	}
-
-	InitAnalyze();
-
-	// scan over all the segments and run the analyze step
-	ScanSegments([&](Vector &scan_vector, idx_t count) {
-		for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-			if (!has_changes[i]) {
-				continue;
-			}
-
-			auto &functions = compression_functions[i];
-			auto &states = analyze_states[i];
-			for (idx_t j = 0; j < functions.size(); j++) {
-				auto &state = states[j];
-				auto &func = functions[j];
-
-				if (!state) {
-					continue;
-				}
-				if (!func->analyze(*state, scan_vector, count)) {
-					state = nullptr;
-					func = nullptr;
-				}
-			}
-		}
-	});
-
-	vector<CheckpointAnalyzeResult> result;
-	result.resize(checkpoint_states.size());
-
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		if (!has_changes[i]) {
-			continue;
-		}
-		auto &functions = compression_functions[i];
-		auto &states = analyze_states[i];
-		auto &forced_method = forced_methods[i];
-
-		unique_ptr<AnalyzeState> chosen_state;
-		idx_t best_score = NumericLimits<idx_t>::Maximum();
-		idx_t compression_idx = DConstants::INVALID_INDEX;
-
-		D_ASSERT(functions.size() == states.size());
-		for (idx_t j = 0; j < functions.size(); j++) {
-			auto &function = functions[j];
-			auto &state = states[j];
-
-			if (!state) {
-				continue;
-			}
-
-			//! Check if the method type is the forced method (if forced is used)
-			bool forced_method_found = function->type == forced_method;
-			// now that we have passed over all the data, we need to figure out the best method
-			// we do this using the final_analyze method
-			auto score = function->final_analyze(*state);
-
-			//! The finalize method can return this value from final_analyze to indicate it should not be used.
-			if (score == DConstants::INVALID_INDEX) {
-				continue;
-			}
-
-			if (score < best_score || forced_method_found) {
-				compression_idx = j;
-				best_score = score;
-				chosen_state = std::move(state);
-			}
-			//! If we have found the forced method, we're done
-			if (forced_method_found) {
-				break;
-			}
-		}
-
-		if (!chosen_state) {
-			auto &checkpoint_state = checkpoint_states[i];
-			auto &col_data = checkpoint_state.get().column_data;
-			throw FatalException("No suitable compression/storage method found to store column of type %s",
-			                     col_data.type.ToString());
-		}
-		D_ASSERT(compression_idx != DConstants::INVALID_INDEX);
-		result[i] = CheckpointAnalyzeResult(std::move(chosen_state), *functions[compression_idx]);
-	}
-	return result;
-}
-
-void ColumnDataCheckpointer::DropSegments() {
-	// first we check the current segments
-	// if there are any persistent segments, we will mark their old block ids as modified
-	// since the segments will be rewritten their old on disk data is no longer required
-
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		if (!has_changes[i]) {
-			continue;
-		}
-
-		auto &state = checkpoint_states[i];
-		auto &col_data = state.get().column_data;
-		auto &nodes = col_data.data.ReferenceSegments();
-
-		// Drop the segments, as we'll be replacing them with new ones, because there are changes
-		for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-			auto segment = nodes[segment_idx].node.get();
-			segment->CommitDropSegment();
-		}
-	}
-}
-
-bool ColumnDataCheckpointer::ValidityCoveredByBasedata(vector<CheckpointAnalyzeResult> &result) {
-	if (result.size() != 2) {
-		return false;
-	}
-	if (!has_changes[0]) {
-		// The base data had no changes so it will not be rewritten
-		return false;
-	}
-	auto &base = result[0];
-	D_ASSERT(base.function);
-	return base.function->validity == CompressionValidity::NO_VALIDITY_REQUIRED;
-}
-
-void ColumnDataCheckpointer::WriteToDisk() {
-	DropSegments();
-
-	// Analyze the candidate functions to select one of them to use for compression
-	auto analyze_result = DetectBestCompressionMethod();
-	if (ValidityCoveredByBasedata(analyze_result)) {
-		D_ASSERT(analyze_result.size() == 2);
-		auto &validity = analyze_result[1];
-		auto &config = DBConfig::GetConfig(db);
-		// Override the function to the COMPRESSION_EMPTY
-		// turning the compression+final compress steps into a no-op, saving a single empty segment
-		validity.function = config.GetCompressionFunction(CompressionType::COMPRESSION_EMPTY, PhysicalType::BIT);
-	}
-
-	// Initialize the compression for the selected function
-	D_ASSERT(analyze_result.size() == checkpoint_states.size());
-	vector<ColumnDataCheckpointData> checkpoint_data(checkpoint_states.size());
-	vector<unique_ptr<CompressionState>> compression_states(checkpoint_states.size());
-	for (idx_t i = 0; i < analyze_result.size(); i++) {
-		if (!has_changes[i]) {
-			continue;
-		}
-		auto &analyze_state = analyze_result[i].analyze_state;
-		auto &function = analyze_result[i].function;
-
-		auto &checkpoint_state = checkpoint_states[i];
-		auto &col_data = checkpoint_state.get().column_data;
-
-		checkpoint_data[i] =
-		    ColumnDataCheckpointData(checkpoint_state, col_data, col_data.GetDatabase(), row_group, checkpoint_info);
-		compression_states[i] = function->init_compression(checkpoint_data[i], std::move(analyze_state));
-	}
-
-	// Scan over the existing segment + changes and compress the data
-	ScanSegments([&](Vector &scan_vector, idx_t count) {
-		for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-			if (!has_changes[i]) {
-				continue;
-			}
-			auto &function = analyze_result[i].function;
-			auto &compression_state = compression_states[i];
-			function->compress(*compression_state, scan_vector, count);
-		}
-	});
-
-	// Finalize the compression
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		if (!has_changes[i]) {
-			continue;
-		}
-		auto &function = analyze_result[i].function;
-		auto &compression_state = compression_states[i];
-		function->compress_finalize(*compression_state);
-	}
-}
-
-bool ColumnDataCheckpointer::HasChanges(ColumnData &col_data) {
-	auto &nodes = col_data.data.ReferenceSegments();
-	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = nodes[segment_idx].node.get();
-		if (segment->segment_type == ColumnSegmentType::TRANSIENT) {
-			// transient segment: always need to write to disk
-			return true;
-		}
-		// persistent segment; check if there were any updates or deletions in this segment
-		idx_t start_row_idx = segment->start - row_group.start;
-		idx_t end_row_idx = start_row_idx + segment->count;
-		if (col_data.HasChanges(start_row_idx, end_row_idx)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void ColumnDataCheckpointer::WritePersistentSegments(ColumnCheckpointState &state) {
-	// all segments are persistent and there are no updates
-	// we only need to write the metadata
-
-	auto &col_data = state.column_data;
-	auto nodes = col_data.data.MoveSegments();
-
-	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = nodes[segment_idx].node.get();
-		auto pointer = segment->GetDataPointer();
-
-		// merge the persistent stats into the global column stats
-		state.global_stats->Merge(segment->stats.statistics);
-
-		// directly append the current segment to the new tree
-		state.new_tree.AppendSegment(std::move(nodes[segment_idx].node));
-
-		state.data_pointers.push_back(std::move(pointer));
-	}
-}
-
-void ColumnDataCheckpointer::Checkpoint() {
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		auto &state = checkpoint_states[i];
-		auto &col_data = state.get().column_data;
-		has_changes.push_back(HasChanges(col_data));
-	}
-
-	bool any_has_changes = false;
-	for (idx_t i = 0; i < has_changes.size(); i++) {
-		if (has_changes[i]) {
-			any_has_changes = true;
-			break;
-		}
-	}
-	if (!any_has_changes) {
-		// Nothing has undergone any changes, no need to checkpoint
-		// just move on to finalizing
-		return;
-	}
-
-	WriteToDisk();
-}
-
-void ColumnDataCheckpointer::FinalizeCheckpoint() {
-	for (idx_t i = 0; i < checkpoint_states.size(); i++) {
-		auto &state = checkpoint_states[i].get();
-		auto &col_data = state.column_data;
-		if (has_changes[i]) {
-			// Move the existing segments out of the column data
-			// they will be destructed at the end of the scope
-			auto to_delete = col_data.data.MoveSegments();
-		} else {
-			WritePersistentSegments(state);
-		}
-
-		// reset the compression function
-		col_data.compression.reset();
-		// replace the old tree with the new one
-		auto new_segments = state.new_tree.MoveSegments();
-		auto l = col_data.data.Lock();
-		for (auto &new_segment : new_segments) {
-			col_data.AppendSegment(l, std::move(new_segment.node));
-		}
-		col_data.ClearUpdates();
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/column_segment.cpp b/src/duckdb/src/storage/table/column_segment.cpp
deleted file mode 100644
index 207c663fa..000000000
--- a/src/duckdb/src/storage/table/column_segment.cpp
+++ /dev/null
@@ -1,561 +0,0 @@
-#include "duckdb/storage/table/column_segment.hpp"
-
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/struct_filter.hpp"
-#include "duckdb/storage/data_pointer.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Create
-//===--------------------------------------------------------------------===//
-
-unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstance &db, BlockManager &block_manager,
-                                                                 block_id_t block_id, idx_t offset,
-                                                                 const LogicalType &type, idx_t start, idx_t count,
-                                                                 CompressionType compression_type,
-                                                                 BaseStatistics statistics,
-                                                                 unique_ptr<ColumnSegmentState> segment_state) {
-
-	auto &config = DBConfig::GetConfig(db);
-	optional_ptr<CompressionFunction> function;
-	shared_ptr<BlockHandle> block;
-
-	if (block_id == INVALID_BLOCK) {
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, type.InternalType());
-	} else {
-		function = config.GetCompressionFunction(compression_type, type.InternalType());
-		block = block_manager.RegisterBlock(block_id);
-	}
-
-	auto segment_size = block_manager.GetBlockSize();
-	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::PERSISTENT, start, count, *function,
-	                                std::move(statistics), block_id, offset, segment_size, std::move(segment_state));
-}
-
-unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance &db, CompressionFunction &function,
-                                                                const LogicalType &type, const idx_t start,
-                                                                const idx_t segment_size, const idx_t block_size) {
-
-	// Allocate a buffer for the uncompressed segment.
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	auto block = buffer_manager.RegisterTransientMemory(segment_size, block_size);
-
-	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0U, function,
-	                                BaseStatistics::CreateEmpty(type), INVALID_BLOCK, 0U, segment_size);
-}
-
-//===--------------------------------------------------------------------===//
-// Construct/Destruct
-//===--------------------------------------------------------------------===//
-ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block_p, const LogicalType &type,
-                             const ColumnSegmentType segment_type, const idx_t start, const idx_t count,
-                             CompressionFunction &function_p, BaseStatistics statistics, const block_id_t block_id_p,
-                             const idx_t offset, const idx_t segment_size_p,
-                             const unique_ptr<ColumnSegmentState> segment_state_p)
-
-    : SegmentBase<ColumnSegment>(start, count), db(db), type(type), type_size(GetTypeIdSize(type.InternalType())),
-      segment_type(segment_type), stats(std::move(statistics)), block(std::move(block_p)), function(function_p),
-      block_id(block_id_p), offset(offset), segment_size(segment_size_p) {
-
-	if (function.get().init_segment) {
-		segment_state = function.get().init_segment(*this, block_id, segment_state_p.get());
-	}
-
-	// For constant segments (CompressionType::COMPRESSION_CONSTANT) the block is a nullptr.
-	D_ASSERT(!block || segment_size <= GetBlockManager().GetBlockSize());
-}
-
-ColumnSegment::ColumnSegment(ColumnSegment &other, const idx_t start)
-
-    : SegmentBase<ColumnSegment>(start, other.count.load()), db(other.db), type(std::move(other.type)),
-      type_size(other.type_size), segment_type(other.segment_type), stats(std::move(other.stats)),
-      block(std::move(other.block)), function(other.function), block_id(other.block_id), offset(other.offset),
-      segment_size(other.segment_size), segment_state(std::move(other.segment_state)) {
-
-	// For constant segments (CompressionType::COMPRESSION_CONSTANT) the block is a nullptr.
-	D_ASSERT(!block || segment_size <= GetBlockManager().GetBlockSize());
-}
-
-ColumnSegment::~ColumnSegment() {
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void ColumnSegment::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &) {
-	if (!block || block->BlockId() >= MAXIMUM_BLOCK) {
-		// not an on-disk block
-		return;
-	}
-	if (function.get().init_prefetch) {
-		function.get().init_prefetch(*this, prefetch_state);
-	} else {
-		prefetch_state.AddBlock(block);
-	}
-}
-
-void ColumnSegment::InitializeScan(ColumnScanState &state) {
-	state.scan_state = function.get().init_scan(*this);
-}
-
-void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset,
-                         ScanVectorType scan_type) {
-	if (scan_type == ScanVectorType::SCAN_ENTIRE_VECTOR) {
-		D_ASSERT(result_offset == 0);
-		Scan(state, scan_count, result);
-	} else {
-		D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-		ScanPartial(state, scan_count, result, result_offset);
-		D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	}
-}
-
-void ColumnSegment::Select(ColumnScanState &state, idx_t scan_count, Vector &result, const SelectionVector &sel,
-                           idx_t sel_count) {
-	if (!function.get().select) {
-		throw InternalException("ColumnSegment::Select not implemented for this compression method");
-	}
-	function.get().select(*this, state, scan_count, result, sel, sel_count);
-}
-
-void ColumnSegment::Filter(ColumnScanState &state, idx_t scan_count, Vector &result, SelectionVector &sel,
-                           idx_t &sel_count, const TableFilter &filter) {
-	if (!function.get().filter) {
-		throw InternalException("ColumnSegment::Filter not implemented for this compression method");
-	}
-	function.get().filter(*this, state, scan_count, result, sel, sel_count, filter);
-}
-
-void ColumnSegment::Skip(ColumnScanState &state) {
-	function.get().skip(*this, state, state.row_index - state.internal_index);
-	state.internal_index = state.row_index;
-}
-
-void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result) {
-	function.get().scan_vector(*this, state, scan_count, result);
-}
-
-void ColumnSegment::ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset) {
-	function.get().scan_partial(*this, state, scan_count, result, result_offset);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ColumnSegment::FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	function.get().fetch_row(*this, state, UnsafeNumericCast<int64_t>(UnsafeNumericCast<idx_t>(row_id) - this->start),
-	                         result, result_idx);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-idx_t ColumnSegment::SegmentSize() const {
-	return segment_size;
-}
-
-void ColumnSegment::Resize(idx_t new_size) {
-	D_ASSERT(new_size > segment_size);
-	D_ASSERT(offset == 0);
-	D_ASSERT(block && new_size <= GetBlockManager().GetBlockSize());
-
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	auto old_handle = buffer_manager.Pin(block);
-	auto new_handle = buffer_manager.Allocate(MemoryTag::IN_MEMORY_TABLE, new_size);
-	auto new_block = new_handle.GetBlockHandle();
-	memcpy(new_handle.Ptr(), old_handle.Ptr(), segment_size);
-
-	this->block_id = new_block->BlockId();
-	this->block = std::move(new_block);
-	this->segment_size = new_size;
-}
-
-void ColumnSegment::InitializeAppend(ColumnAppendState &state) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function.get().init_append) {
-		throw InternalException("Attempting to init append to a segment without init_append method");
-	}
-	state.append_state = function.get().init_append(*this);
-}
-
-idx_t ColumnSegment::Append(ColumnAppendState &state, UnifiedVectorFormat &append_data, idx_t offset, idx_t count) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function.get().append) {
-		throw InternalException("Attempting to append to a segment without append method");
-	}
-	return function.get().append(*state.append_state, *this, stats, append_data, offset, count);
-}
-
-idx_t ColumnSegment::FinalizeAppend(ColumnAppendState &state) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function.get().finalize_append) {
-		throw InternalException("Attempting to call FinalizeAppend on a segment without a finalize_append method");
-	}
-	auto result_count = function.get().finalize_append(*this, stats);
-	state.append_state.reset();
-	return result_count;
-}
-
-void ColumnSegment::RevertAppend(idx_t start_row) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (function.get().revert_append) {
-		function.get().revert_append(*this, start_row);
-	}
-	this->count = start_row - this->start;
-}
-
-//===--------------------------------------------------------------------===//
-// Convert To Persistent
-//===--------------------------------------------------------------------===//
-void ColumnSegment::ConvertToPersistent(optional_ptr<BlockManager> block_manager, block_id_t block_id_p) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	segment_type = ColumnSegmentType::PERSISTENT;
-
-	block_id = block_id_p;
-	offset = 0;
-
-	if (block_id == INVALID_BLOCK) {
-		// constant block: no need to write anything to disk besides the stats
-		// set up the compression function to constant
-		D_ASSERT(stats.statistics.IsConstant());
-		auto &config = DBConfig::GetConfig(db);
-		function = *config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, type.InternalType());
-		// reset the block buffer
-		block.reset();
-	} else {
-		D_ASSERT(!stats.statistics.IsConstant());
-		// non-constant block: write the block to disk
-		// the data for the block already exists in-memory of our block
-		// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-		block = block_manager->ConvertToPersistent(block_id, std::move(block));
-	}
-}
-
-void ColumnSegment::MarkAsPersistent(shared_ptr<BlockHandle> block_p, uint32_t offset_p) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	segment_type = ColumnSegmentType::PERSISTENT;
-
-	block_id = block_p->BlockId();
-	offset = offset_p;
-	block = std::move(block_p);
-}
-
-DataPointer ColumnSegment::GetDataPointer() {
-	if (segment_type != ColumnSegmentType::PERSISTENT) {
-		throw InternalException("Attempting to call ColumnSegment::GetDataPointer on a transient segment");
-	}
-	// set up the data pointer directly using the data from the persistent segment
-	DataPointer pointer(stats.statistics.Copy());
-	pointer.block_pointer.block_id = GetBlockId();
-	pointer.block_pointer.offset = NumericCast<uint32_t>(GetBlockOffset());
-	pointer.row_start = start;
-	pointer.tuple_count = count;
-	pointer.compression_type = function.get().type;
-	if (function.get().serialize_state) {
-		pointer.segment_state = function.get().serialize_state(*this);
-	}
-	return pointer;
-}
-
-//===--------------------------------------------------------------------===//
-// Drop Segment
-//===--------------------------------------------------------------------===//
-void ColumnSegment::CommitDropSegment() {
-	if (segment_type != ColumnSegmentType::PERSISTENT) {
-		// not persistent
-		return;
-	}
-	if (block_id != INVALID_BLOCK) {
-		GetBlockManager().MarkBlockAsModified(block_id);
-	}
-	if (function.get().cleanup_state) {
-		function.get().cleanup_state(*this);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Filter Selection
-//===--------------------------------------------------------------------===//
-template <class T, class OP, bool HAS_NULL>
-static idx_t TemplatedFilterSelection(UnifiedVectorFormat &vdata, T predicate, SelectionVector &sel,
-                                      idx_t approved_tuple_count, SelectionVector &result_sel) {
-	auto &mask = vdata.validity;
-	auto vec = UnifiedVectorFormat::GetData<T>(vdata);
-	idx_t result_count = 0;
-	for (idx_t i = 0; i < approved_tuple_count; i++) {
-		auto idx = sel.get_index(i);
-		auto vector_idx = vdata.sel->get_index(idx);
-		bool comparison_result =
-		    (!HAS_NULL || mask.RowIsValid(vector_idx)) && OP::Operation(vec[vector_idx], predicate);
-		result_sel.set_index(result_count, idx);
-		result_count += comparison_result;
-	}
-	return result_count;
-}
-
-template <class T>
-static void FilterSelectionSwitch(UnifiedVectorFormat &vdata, T predicate, SelectionVector &sel,
-                                  idx_t &approved_tuple_count, ExpressionType comparison_type) {
-	SelectionVector new_sel(approved_tuple_count);
-	auto &mask = vdata.validity;
-	// the inplace loops take the result as the last parameter
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, Equals, false>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, Equals, true>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_NOTEQUAL: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, NotEquals, false>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, NotEquals, true>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_LESSTHAN: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, LessThan, false>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, LessThan, true>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_GREATERTHAN: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, GreaterThan, false>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, GreaterThan, true>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO: {
-		if (mask.AllValid()) {
-			approved_tuple_count = TemplatedFilterSelection<T, LessThanEquals, false>(vdata, predicate, sel,
-			                                                                          approved_tuple_count, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, LessThanEquals, true>(vdata, predicate, sel, approved_tuple_count, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO: {
-		if (mask.AllValid()) {
-			approved_tuple_count = TemplatedFilterSelection<T, GreaterThanEquals, false>(vdata, predicate, sel,
-			                                                                             approved_tuple_count, new_sel);
-		} else {
-			approved_tuple_count = TemplatedFilterSelection<T, GreaterThanEquals, true>(vdata, predicate, sel,
-			                                                                            approved_tuple_count, new_sel);
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unknown comparison type for filter pushed down to table!");
-	}
-	sel.Initialize(new_sel);
-}
-
-template <bool IS_NULL>
-static idx_t TemplatedNullSelection(UnifiedVectorFormat &vdata, SelectionVector &sel, idx_t &approved_tuple_count) {
-	auto &mask = vdata.validity;
-	if (mask.AllValid()) {
-		// no NULL values
-		if (IS_NULL) {
-			approved_tuple_count = 0;
-			return 0;
-		} else {
-			return approved_tuple_count;
-		}
-	} else {
-		SelectionVector result_sel(approved_tuple_count);
-		idx_t result_count = 0;
-		for (idx_t i = 0; i < approved_tuple_count; i++) {
-			auto idx = sel.get_index(i);
-			auto vector_idx = vdata.sel->get_index(idx);
-			if (mask.RowIsValid(vector_idx) != IS_NULL) {
-				result_sel.set_index(result_count++, idx);
-			}
-		}
-		sel.Initialize(result_sel);
-		approved_tuple_count = result_count;
-		return result_count;
-	}
-}
-
-idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &vector, UnifiedVectorFormat &vdata,
-                                     const TableFilter &filter, idx_t scan_count, idx_t &approved_tuple_count) {
-	switch (filter.filter_type) {
-	case TableFilterType::OPTIONAL_FILTER: {
-		return scan_count;
-	}
-	case TableFilterType::CONJUNCTION_OR: {
-		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
-		idx_t count_total = 0;
-		SelectionVector result_sel(approved_tuple_count);
-		auto &conjunction_or = filter.Cast<ConjunctionOrFilter>();
-		for (auto &child_filter : conjunction_or.child_filters) {
-			SelectionVector temp_sel;
-			temp_sel.Initialize(sel);
-			idx_t temp_tuple_count = approved_tuple_count;
-			idx_t temp_count = FilterSelection(temp_sel, vector, vdata, *child_filter, scan_count, temp_tuple_count);
-			// tuples passed, move them into the actual result vector
-			for (idx_t i = 0; i < temp_count; i++) {
-				auto new_idx = temp_sel.get_index(i);
-				bool is_new_idx = true;
-				for (idx_t res_idx = 0; res_idx < count_total; res_idx++) {
-					if (result_sel.get_index(res_idx) == new_idx) {
-						is_new_idx = false;
-						break;
-					}
-				}
-				if (is_new_idx) {
-					result_sel.set_index(count_total++, new_idx);
-				}
-			}
-		}
-		sel.Initialize(result_sel);
-		approved_tuple_count = count_total;
-		return approved_tuple_count;
-	}
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
-		for (auto &child_filter : conjunction_and.child_filters) {
-			FilterSelection(sel, vector, vdata, *child_filter, scan_count, approved_tuple_count);
-		}
-		return approved_tuple_count;
-	}
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = filter.Cast<ConstantFilter>();
-		switch (vector.GetType().InternalType()) {
-		case PhysicalType::UINT8: {
-			auto predicate = UTinyIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<uint8_t>(vdata, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::UINT16: {
-			auto predicate = USmallIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<uint16_t>(vdata, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::UINT32: {
-			auto predicate = UIntegerValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<uint32_t>(vdata, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::UINT64: {
-			auto predicate = UBigIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<uint64_t>(vdata, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::INT8: {
-			auto predicate = TinyIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<int8_t>(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::INT16: {
-			auto predicate = SmallIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<int16_t>(vdata, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::INT32: {
-			auto predicate = IntegerValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<int32_t>(vdata, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::INT64: {
-			auto predicate = BigIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<int64_t>(vdata, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::INT128: {
-			auto predicate = HugeIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<hugeint_t>(vdata, predicate, sel, approved_tuple_count,
-			                                 constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::UINT128: {
-			auto predicate = UhugeIntValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<uhugeint_t>(vdata, predicate, sel, approved_tuple_count,
-			                                  constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::FLOAT: {
-			auto predicate = FloatValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<float>(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::DOUBLE: {
-			auto predicate = DoubleValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<double>(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::VARCHAR: {
-			auto predicate = string_t(StringValue::Get(constant_filter.constant));
-			FilterSelectionSwitch<string_t>(vdata, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type);
-			break;
-		}
-		case PhysicalType::BOOL: {
-			auto predicate = BooleanValue::Get(constant_filter.constant);
-			FilterSelectionSwitch<bool>(vdata, predicate, sel, approved_tuple_count, constant_filter.comparison_type);
-			break;
-		}
-		default:
-			throw InvalidTypeException(vector.GetType(), "Invalid type for filter pushed down to table comparison");
-		}
-		return approved_tuple_count;
-	}
-	case TableFilterType::IS_NULL:
-		return TemplatedNullSelection<true>(vdata, sel, approved_tuple_count);
-	case TableFilterType::IS_NOT_NULL:
-		return TemplatedNullSelection<false>(vdata, sel, approved_tuple_count);
-	case TableFilterType::STRUCT_EXTRACT: {
-		auto &struct_filter = filter.Cast<StructFilter>();
-		// Apply the filter on the child vector
-		auto &child_vec = StructVector::GetEntries(vector)[struct_filter.child_idx];
-		UnifiedVectorFormat child_data;
-		child_vec->ToUnifiedFormat(scan_count, child_data);
-		return FilterSelection(sel, *child_vec, child_data, *struct_filter.child_filter, scan_count,
-		                       approved_tuple_count);
-	}
-	default:
-		throw InternalException("FIXME: unsupported type for filter selection");
-	}
-}
-
-const CompressionFunction &ColumnSegment::GetCompressionFunction() {
-	return function.get();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/list_column_data.cpp b/src/duckdb/src/storage/table/list_column_data.cpp
deleted file mode 100644
index 03d8de085..000000000
--- a/src/duckdb/src/storage/table/list_column_data.cpp
+++ /dev/null
@@ -1,395 +0,0 @@
-#include "duckdb/storage/table/list_column_data.hpp"
-#include "duckdb/storage/statistics/list_stats.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-ListColumnData::ListColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-                               LogicalType type_p, optional_ptr<ColumnData> parent)
-    : ColumnData(block_manager, info, column_index, start_row, std::move(type_p), parent),
-      validity(block_manager, info, 0, start_row, *this) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto &child_type = ListType::GetChildType(type);
-	// the child column, with column index 1 (0 is the validity mask)
-	child_column = ColumnData::CreateColumnUnique(block_manager, info, 1, start_row, child_type, this);
-}
-
-void ListColumnData::SetStart(idx_t new_start) {
-	ColumnData::SetStart(new_start);
-	child_column->SetStart(new_start);
-	validity.SetStart(new_start);
-}
-
-FilterPropagateResult ListColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	// table filters are not supported yet for list columns
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-void ListColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) {
-	ColumnData::InitializePrefetch(prefetch_state, scan_state, rows);
-	validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows);
-
-	// we can't know how many rows we need to prefetch for the child of this list without looking at the actual data
-	// we make an estimation by looking at how many rows the child column has versus this column
-	// e.g if the child column has 10K rows, and we have 1K rows, we estimate that each list has 10 elements
-	idx_t rows_per_list = 1;
-	if (child_column->count > this->count && this->count > 0) {
-		rows_per_list = child_column->count / this->count;
-	}
-	child_column->InitializePrefetch(prefetch_state, scan_state.child_states[1], rows * rows_per_list);
-}
-
-void ListColumnData::InitializeScan(ColumnScanState &state) {
-	ColumnData::InitializeScan(state);
-
-	// initialize the validity segment
-	D_ASSERT(state.child_states.size() == 2);
-	validity.InitializeScan(state.child_states[0]);
-
-	// initialize the child scan
-	child_column->InitializeScan(state.child_states[1]);
-}
-
-uint64_t ListColumnData::FetchListOffset(idx_t row_idx) {
-	auto segment = data.GetSegment(row_idx);
-	ColumnFetchState fetch_state;
-	Vector result(type, 1);
-	segment->FetchRow(fetch_state, UnsafeNumericCast<row_t>(row_idx), result, 0U);
-
-	// initialize the child scan with the required offset
-	return FlatVector::GetData<uint64_t>(result)[0];
-}
-
-void ListColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	if (row_idx == 0) {
-		InitializeScan(state);
-		return;
-	}
-	ColumnData::InitializeScanWithOffset(state, row_idx);
-
-	// initialize the validity segment
-	D_ASSERT(state.child_states.size() == 2);
-	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
-
-	// we need to read the list at position row_idx to get the correct row offset of the child
-	auto child_offset = row_idx == start ? 0 : FetchListOffset(row_idx - 1);
-	D_ASSERT(child_offset <= child_column->GetMaxEntry());
-	if (child_offset < child_column->GetMaxEntry()) {
-		child_column->InitializeScanWithOffset(state.child_states[1], start + child_offset);
-	}
-	state.last_offset = child_offset;
-}
-
-idx_t ListColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                           idx_t scan_count) {
-	return ScanCount(state, result, scan_count);
-}
-
-idx_t ListColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-                                    idx_t scan_count) {
-	return ScanCount(state, result, scan_count);
-}
-
-idx_t ListColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	if (count == 0) {
-		return 0;
-	}
-	// updates not supported for lists
-	D_ASSERT(!updates);
-
-	Vector offset_vector(LogicalType::UBIGINT, count);
-	idx_t scan_count = ScanVector(state, offset_vector, count, ScanVectorType::SCAN_FLAT_VECTOR);
-	D_ASSERT(scan_count > 0);
-	validity.ScanCount(state.child_states[0], result, count);
-
-	UnifiedVectorFormat offsets;
-	offset_vector.ToUnifiedFormat(scan_count, offsets);
-	auto data = UnifiedVectorFormat::GetData<uint64_t>(offsets);
-	auto last_entry = data[offsets.sel->get_index(scan_count - 1)];
-
-	// shift all offsets so they are 0 at the first entry
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	auto base_offset = state.last_offset;
-	idx_t current_offset = 0;
-	for (idx_t i = 0; i < scan_count; i++) {
-		auto offset_index = offsets.sel->get_index(i);
-		result_data[i].offset = current_offset;
-		result_data[i].length = data[offset_index] - current_offset - base_offset;
-		current_offset += result_data[i].length;
-	}
-
-	D_ASSERT(last_entry >= base_offset);
-	idx_t child_scan_count = last_entry - base_offset;
-	ListVector::Reserve(result, child_scan_count);
-
-	if (child_scan_count > 0) {
-		auto &child_entry = ListVector::GetEntry(result);
-		if (child_entry.GetType().InternalType() != PhysicalType::STRUCT &&
-		    child_entry.GetType().InternalType() != PhysicalType::ARRAY &&
-		    state.child_states[1].row_index + child_scan_count > child_column->start + child_column->GetMaxEntry()) {
-			throw InternalException("ListColumnData::ScanCount - internal list scan offset is out of range");
-		}
-		child_column->ScanCount(state.child_states[1], child_entry, child_scan_count);
-	}
-	state.last_offset = last_entry;
-
-	ListVector::SetListSize(result, child_scan_count);
-	return scan_count;
-}
-
-void ListColumnData::Skip(ColumnScanState &state, idx_t count) {
-	// skip inside the validity segment
-	validity.Skip(state.child_states[0], count);
-
-	// we need to read the list entries/offsets to figure out how much to skip
-	// note that we only need to read the first and last entry
-	// however, let's just read all "count" entries for now
-	Vector offset_vector(LogicalType::UBIGINT, count);
-	idx_t scan_count = ScanVector(state, offset_vector, count, ScanVectorType::SCAN_FLAT_VECTOR);
-	D_ASSERT(scan_count > 0);
-
-	UnifiedVectorFormat offsets;
-	offset_vector.ToUnifiedFormat(scan_count, offsets);
-	auto data = UnifiedVectorFormat::GetData<uint64_t>(offsets);
-	auto last_entry = data[offsets.sel->get_index(scan_count - 1)];
-	idx_t child_scan_count = last_entry - state.last_offset;
-	if (child_scan_count == 0) {
-		return;
-	}
-	state.last_offset = last_entry;
-
-	// skip the child state forward by the child_scan_count
-	child_column->Skip(state.child_states[1], child_scan_count);
-}
-
-void ListColumnData::InitializeAppend(ColumnAppendState &state) {
-	// initialize the list offset append
-	ColumnData::InitializeAppend(state);
-
-	// initialize the validity append
-	ColumnAppendState validity_append_state;
-	validity.InitializeAppend(validity_append_state);
-	state.child_appends.push_back(std::move(validity_append_state));
-
-	// initialize the child column append
-	ColumnAppendState child_append_state;
-	child_column->InitializeAppend(child_append_state);
-	state.child_appends.push_back(std::move(child_append_state));
-}
-
-void ListColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	D_ASSERT(count > 0);
-	UnifiedVectorFormat list_data;
-	vector.ToUnifiedFormat(count, list_data);
-	auto &list_validity = list_data.validity;
-
-	// construct the list_entry_t entries to append to the column data
-	auto input_offsets = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	auto start_offset = child_column->GetMaxEntry();
-	idx_t child_count = 0;
-
-	ValidityMask append_mask(count);
-	auto append_offsets = unique_ptr<uint64_t[]>(new uint64_t[count]);
-	bool child_contiguous = true;
-	for (idx_t i = 0; i < count; i++) {
-		auto input_idx = list_data.sel->get_index(i);
-		if (list_validity.RowIsValid(input_idx)) {
-			auto &input_list = input_offsets[input_idx];
-			if (input_list.offset != child_count) {
-				child_contiguous = false;
-			}
-			append_offsets[i] = start_offset + child_count + input_list.length;
-			child_count += input_list.length;
-		} else {
-			append_mask.SetInvalid(i);
-			append_offsets[i] = start_offset + child_count;
-		}
-	}
-	auto &list_child = ListVector::GetEntry(vector);
-	Vector child_vector(list_child);
-	if (!child_contiguous) {
-		// if the child of the list vector is a non-contiguous vector (i.e. list elements are repeating or have gaps)
-		// we first push a selection vector and flatten the child vector to turn it into a contiguous vector
-		SelectionVector child_sel(child_count);
-		idx_t current_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto input_idx = list_data.sel->get_index(i);
-			if (list_validity.RowIsValid(input_idx)) {
-				auto &input_list = input_offsets[input_idx];
-				for (idx_t list_idx = 0; list_idx < input_list.length; list_idx++) {
-					child_sel.set_index(current_count++, input_list.offset + list_idx);
-				}
-			}
-		}
-		D_ASSERT(current_count == child_count);
-		child_vector.Slice(list_child, child_sel, child_count);
-	}
-
-	UnifiedVectorFormat vdata;
-	vdata.sel = FlatVector::IncrementalSelectionVector();
-	vdata.data = data_ptr_cast(append_offsets.get());
-
-	// append the child vector
-	if (child_count > 0) {
-		child_column->Append(ListStats::GetChildStats(stats), state.child_appends[1], child_vector, child_count);
-	}
-	// append the list offsets
-	ColumnData::AppendData(stats, state, vdata, count);
-	// append the validity data
-	vdata.validity = append_mask;
-	validity.AppendData(stats, state.child_appends[0], vdata, count);
-}
-
-void ListColumnData::RevertAppend(row_t start_row) {
-	ColumnData::RevertAppend(start_row);
-	validity.RevertAppend(start_row);
-	auto column_count = GetMaxEntry();
-	if (column_count > start) {
-		// revert append in the child column
-		auto list_offset = FetchListOffset(column_count - 1);
-		child_column->RevertAppend(UnsafeNumericCast<row_t>(list_offset));
-	}
-}
-
-idx_t ListColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	throw NotImplementedException("List Fetch");
-}
-
-void ListColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                            idx_t update_count) {
-	throw NotImplementedException("List Update is not supported.");
-}
-
-void ListColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
-	throw NotImplementedException("List Update Column is not supported");
-}
-
-unique_ptr<BaseStatistics> ListColumnData::GetUpdateStatistics() {
-	return nullptr;
-}
-
-void ListColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                              idx_t result_idx) {
-	// insert any child states that are required
-	// we need two (validity & list child)
-	// note that we need a scan state for the child vector
-	// this is because we will (potentially) fetch more than one tuple from the list child
-	if (state.child_states.empty()) {
-		auto child_state = make_uniq<ColumnFetchState>();
-		state.child_states.push_back(std::move(child_state));
-	}
-
-	// now perform the fetch within the segment
-	auto start_offset = idx_t(row_id) == this->start ? 0 : FetchListOffset(UnsafeNumericCast<idx_t>(row_id - 1));
-	auto end_offset = FetchListOffset(UnsafeNumericCast<idx_t>(row_id));
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-
-	auto &validity = FlatVector::Validity(result);
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	auto &list_entry = list_data[result_idx];
-	// set the list entry offset to the size of the current list
-	list_entry.offset = ListVector::GetListSize(result);
-	list_entry.length = end_offset - start_offset;
-	if (!validity.RowIsValid(result_idx)) {
-		// the list is NULL! no need to fetch the child
-		D_ASSERT(list_entry.length == 0);
-		return;
-	}
-
-	// now we need to read from the child all the elements between [offset...length]
-	auto child_scan_count = list_entry.length;
-	if (child_scan_count > 0) {
-		auto child_state = make_uniq<ColumnScanState>();
-		auto &child_type = ListType::GetChildType(result.GetType());
-		Vector child_scan(child_type, child_scan_count);
-		// seek the scan towards the specified position and read [length] entries
-		child_state->Initialize(child_type, nullptr);
-		child_column->InitializeScanWithOffset(*child_state, start + start_offset);
-		D_ASSERT(child_type.InternalType() == PhysicalType::STRUCT ||
-		         child_state->row_index + child_scan_count - this->start <= child_column->GetMaxEntry());
-		child_column->ScanCount(*child_state, child_scan, child_scan_count);
-
-		ListVector::Append(result, child_scan, child_scan_count);
-	}
-}
-
-void ListColumnData::CommitDropColumn() {
-	ColumnData::CommitDropColumn();
-	validity.CommitDropColumn();
-	child_column->CommitDropColumn();
-}
-
-struct ListColumnCheckpointState : public ColumnCheckpointState {
-	ListColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, PartialBlockManager &partial_block_manager)
-	    : ColumnCheckpointState(row_group, column_data, partial_block_manager) {
-		global_stats = ListStats::CreateEmpty(column_data.type).ToUnique();
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-	unique_ptr<ColumnCheckpointState> child_state;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		auto stats = global_stats->Copy();
-		ListStats::SetChildStats(stats, child_state->GetStatistics());
-		return stats.ToUnique();
-	}
-
-	PersistentColumnData ToPersistentData() override {
-		auto data = ColumnCheckpointState::ToPersistentData();
-		data.child_columns.push_back(validity_state->ToPersistentData());
-		data.child_columns.push_back(child_state->ToPersistentData());
-		return data;
-	}
-};
-
-unique_ptr<ColumnCheckpointState> ListColumnData::CreateCheckpointState(RowGroup &row_group,
-                                                                        PartialBlockManager &partial_block_manager) {
-	return make_uniq<ListColumnCheckpointState>(row_group, *this, partial_block_manager);
-}
-
-unique_ptr<ColumnCheckpointState> ListColumnData::Checkpoint(RowGroup &row_group,
-                                                             ColumnCheckpointInfo &checkpoint_info) {
-	auto base_state = ColumnData::Checkpoint(row_group, checkpoint_info);
-	auto validity_state = validity.Checkpoint(row_group, checkpoint_info);
-	auto child_state = child_column->Checkpoint(row_group, checkpoint_info);
-
-	auto &checkpoint_state = base_state->Cast<ListColumnCheckpointState>();
-	checkpoint_state.validity_state = std::move(validity_state);
-	checkpoint_state.child_state = std::move(child_state);
-	return base_state;
-}
-
-bool ListColumnData::IsPersistent() {
-	return ColumnData::IsPersistent() && validity.IsPersistent() && child_column->IsPersistent();
-}
-
-PersistentColumnData ListColumnData::Serialize() {
-	auto persistent_data = ColumnData::Serialize();
-	persistent_data.child_columns.push_back(validity.Serialize());
-	persistent_data.child_columns.push_back(child_column->Serialize());
-	return persistent_data;
-}
-
-void ListColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) {
-	ColumnData::InitializeColumn(column_data, target_stats);
-	validity.InitializeColumn(column_data.child_columns[0], target_stats);
-	auto &child_stats = ListStats::GetChildStats(target_stats);
-	child_column->InitializeColumn(column_data.child_columns[1], child_stats);
-}
-
-void ListColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-                                          vector<duckdb::ColumnSegmentInfo> &result) {
-	ColumnData::GetColumnSegmentInfo(row_group_index, col_path, result);
-	col_path.push_back(0);
-	validity.GetColumnSegmentInfo(row_group_index, col_path, result);
-	col_path.back() = 1;
-	child_column->GetColumnSegmentInfo(row_group_index, col_path, result);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/persistent_table_data.cpp b/src/duckdb/src/storage/table/persistent_table_data.cpp
deleted file mode 100644
index e08b8a52f..000000000
--- a/src/duckdb/src/storage/table/persistent_table_data.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "duckdb/storage/table/persistent_table_data.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-
-PersistentTableData::PersistentTableData(idx_t column_count) : total_rows(0), row_group_count(0) {
-}
-
-PersistentTableData::~PersistentTableData() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/row_group.cpp b/src/duckdb/src/storage/table/row_group.cpp
deleted file mode 100644
index 38e173e83..000000000
--- a/src/duckdb/src/storage/table/row_group.cpp
+++ /dev/null
@@ -1,1222 +0,0 @@
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/row_version_manager.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/struct_filter.hpp"
-#include "duckdb/planner/filter/optional_filter.hpp"
-#include "duckdb/execution/adaptive_filter.hpp"
-
-namespace duckdb {
-
-RowGroup::RowGroup(RowGroupCollection &collection_p, idx_t start, idx_t count)
-    : SegmentBase<RowGroup>(start, count), collection(collection_p), version_info(nullptr), allocation_size(0) {
-	Verify();
-}
-
-RowGroup::RowGroup(RowGroupCollection &collection_p, RowGroupPointer pointer)
-    : SegmentBase<RowGroup>(pointer.row_start, pointer.tuple_count), collection(collection_p), version_info(nullptr),
-      allocation_size(0) {
-	// deserialize the columns
-	if (pointer.data_pointers.size() != collection_p.GetTypes().size()) {
-		throw IOException("Row group column count is unaligned with table column count. Corrupt file?");
-	}
-	this->column_pointers = std::move(pointer.data_pointers);
-	this->columns.resize(column_pointers.size());
-	this->is_loaded = unique_ptr<atomic<bool>[]>(new atomic<bool>[columns.size()]);
-	for (idx_t c = 0; c < columns.size(); c++) {
-		this->is_loaded[c] = false;
-	}
-	this->deletes_pointers = std::move(pointer.deletes_pointers);
-	this->deletes_is_loaded = false;
-
-	Verify();
-}
-
-RowGroup::RowGroup(RowGroupCollection &collection_p, PersistentRowGroupData &data)
-    : SegmentBase<RowGroup>(data.start, data.count), collection(collection_p), version_info(nullptr),
-      allocation_size(0) {
-	auto &block_manager = GetBlockManager();
-	auto &info = GetTableInfo();
-	auto &types = collection.get().GetTypes();
-	columns.reserve(types.size());
-	for (idx_t c = 0; c < types.size(); c++) {
-		auto entry = ColumnData::CreateColumn(block_manager, info, c, data.start, types[c], nullptr);
-		entry->InitializeColumn(data.column_data[c]);
-		columns.push_back(std::move(entry));
-	}
-
-	Verify();
-}
-
-void RowGroup::MoveToCollection(RowGroupCollection &collection_p, idx_t new_start) {
-	this->collection = collection_p;
-	this->start = new_start;
-	for (auto &column : GetColumns()) {
-		column->SetStart(new_start);
-	}
-	if (!HasUnloadedDeletes()) {
-		auto vinfo = GetVersionInfo();
-		if (vinfo) {
-			vinfo->SetStart(new_start);
-		}
-	}
-}
-
-RowGroup::~RowGroup() {
-}
-
-vector<shared_ptr<ColumnData>> &RowGroup::GetColumns() {
-	// ensure all columns are loaded
-	for (idx_t c = 0; c < GetColumnCount(); c++) {
-		GetColumn(c);
-	}
-	return columns;
-}
-
-idx_t RowGroup::GetColumnCount() const {
-	return columns.size();
-}
-
-idx_t RowGroup::GetRowGroupSize() const {
-	return collection.get().GetRowGroupSize();
-}
-
-ColumnData &RowGroup::GetColumn(const StorageIndex &c) {
-	return GetColumn(c.GetPrimaryIndex());
-}
-
-ColumnData &RowGroup::GetColumn(storage_t c) {
-	D_ASSERT(c < columns.size());
-	if (!is_loaded) {
-		// not being lazy loaded
-		D_ASSERT(columns[c]);
-		return *columns[c];
-	}
-	if (is_loaded[c]) {
-		D_ASSERT(columns[c]);
-		return *columns[c];
-	}
-	lock_guard<mutex> l(row_group_lock);
-	if (columns[c]) {
-		D_ASSERT(is_loaded[c]);
-		return *columns[c];
-	}
-	if (column_pointers.size() != columns.size()) {
-		throw InternalException("Lazy loading a column but the pointer was not set");
-	}
-	auto &metadata_manager = GetCollection().GetMetadataManager();
-	auto &types = GetCollection().GetTypes();
-	auto &block_pointer = column_pointers[c];
-	MetadataReader column_data_reader(metadata_manager, block_pointer);
-	this->columns[c] =
-	    ColumnData::Deserialize(GetBlockManager(), GetTableInfo(), c, start, column_data_reader, types[c]);
-	is_loaded[c] = true;
-	if (this->columns[c]->count != this->count) {
-		throw InternalException("Corrupted database - loaded column with index %llu at row start %llu, count %llu did "
-		                        "not match count of row group %llu",
-		                        c, start, this->columns[c]->count.load(), this->count.load());
-	}
-	return *columns[c];
-}
-
-BlockManager &RowGroup::GetBlockManager() {
-	return GetCollection().GetBlockManager();
-}
-DataTableInfo &RowGroup::GetTableInfo() {
-	return GetCollection().GetTableInfo();
-}
-
-void RowGroup::InitializeEmpty(const vector<LogicalType> &types) {
-	// set up the segment trees for the column segments
-	D_ASSERT(columns.empty());
-	for (idx_t i = 0; i < types.size(); i++) {
-		auto column_data = ColumnData::CreateColumn(GetBlockManager(), GetTableInfo(), i, start, types[i]);
-		columns.push_back(std::move(column_data));
-	}
-}
-
-void ColumnScanState::Initialize(const LogicalType &type, const vector<StorageIndex> &children,
-                                 optional_ptr<TableScanOptions> options) {
-	// Register the options in the state
-	scan_options = options;
-
-	if (type.id() == LogicalTypeId::VALIDITY) {
-		// validity - nothing to initialize
-		return;
-	}
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		// validity + struct children
-		auto &struct_children = StructType::GetChildTypes(type);
-		child_states.resize(struct_children.size() + 1);
-
-		if (children.empty()) {
-			// scan all struct children
-			scan_child_column.resize(struct_children.size(), true);
-			for (idx_t i = 0; i < struct_children.size(); i++) {
-				child_states[i + 1].Initialize(struct_children[i].second, options);
-			}
-		} else {
-			// only scan the specified subset of columns
-			scan_child_column.resize(struct_children.size(), false);
-			for (idx_t i = 0; i < children.size(); i++) {
-				auto &child = children[i];
-				auto index = child.GetPrimaryIndex();
-				auto &child_indexes = child.GetChildIndexes();
-				scan_child_column[index] = true;
-				child_states[index + 1].Initialize(struct_children[index].second, child_indexes, options);
-			}
-		}
-		child_states[0].scan_options = options;
-	} else if (type.InternalType() == PhysicalType::LIST) {
-		// validity + list child
-		child_states.resize(2);
-		child_states[1].Initialize(ListType::GetChildType(type), options);
-		child_states[0].scan_options = options;
-	} else if (type.InternalType() == PhysicalType::ARRAY) {
-		// validity + array child
-		child_states.resize(2);
-		child_states[0].scan_options = options;
-		child_states[1].Initialize(ArrayType::GetChildType(type), options);
-	} else {
-		// validity
-		child_states.resize(1);
-		child_states[0].scan_options = options;
-	}
-}
-
-void ColumnScanState::Initialize(const LogicalType &type, optional_ptr<TableScanOptions> options) {
-	vector<StorageIndex> children;
-	Initialize(type, children, options);
-}
-
-void CollectionScanState::Initialize(const vector<LogicalType> &types) {
-	auto &column_ids = GetColumnIds();
-	column_scans = make_unsafe_uniq_array<ColumnScanState>(column_ids.size());
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		if (column_ids[i].IsRowIdColumn()) {
-			continue;
-		}
-		auto col_id = column_ids[i].GetPrimaryIndex();
-		column_scans[i].Initialize(types[col_id], column_ids[i].GetChildIndexes(), &GetOptions());
-	}
-}
-
-bool RowGroup::InitializeScanWithOffset(CollectionScanState &state, idx_t vector_offset) {
-	auto &column_ids = state.GetColumnIds();
-	auto &filters = state.GetFilterInfo();
-	if (!CheckZonemap(filters)) {
-		return false;
-	}
-
-	state.row_group = this;
-	state.vector_index = vector_offset;
-	state.max_row_group_row =
-	    this->start > state.max_row ? 0 : MinValue<idx_t>(this->count, state.max_row - this->start);
-	auto row_number = start + vector_offset * STANDARD_VECTOR_SIZE;
-	if (state.max_row_group_row == 0) {
-		// exceeded row groups to scan
-		return false;
-	}
-	D_ASSERT(state.column_scans);
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		const auto &column = column_ids[i];
-		if (!column.IsRowIdColumn()) {
-			auto &column_data = GetColumn(column);
-			column_data.InitializeScanWithOffset(state.column_scans[i], row_number);
-			state.column_scans[i].scan_options = &state.GetOptions();
-		} else {
-			state.column_scans[i].current = nullptr;
-		}
-	}
-	return true;
-}
-
-bool RowGroup::InitializeScan(CollectionScanState &state) {
-	auto &column_ids = state.GetColumnIds();
-	auto &filters = state.GetFilterInfo();
-	if (!CheckZonemap(filters)) {
-		return false;
-	}
-	state.row_group = this;
-	state.vector_index = 0;
-	state.max_row_group_row =
-	    this->start > state.max_row ? 0 : MinValue<idx_t>(this->count, state.max_row - this->start);
-	if (state.max_row_group_row == 0) {
-		return false;
-	}
-	D_ASSERT(state.column_scans);
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column = column_ids[i];
-		if (!column.IsRowIdColumn()) {
-			auto &column_data = GetColumn(column);
-			column_data.InitializeScan(state.column_scans[i]);
-			state.column_scans[i].scan_options = &state.GetOptions();
-		} else {
-			state.column_scans[i].current = nullptr;
-		}
-	}
-	return true;
-}
-
-unique_ptr<RowGroup> RowGroup::AlterType(RowGroupCollection &new_collection, const LogicalType &target_type,
-                                         idx_t changed_idx, ExpressionExecutor &executor,
-                                         CollectionScanState &scan_state, DataChunk &scan_chunk) {
-	Verify();
-
-	// construct a new column data for this type
-	auto column_data = ColumnData::CreateColumn(GetBlockManager(), GetTableInfo(), changed_idx, start, target_type);
-
-	ColumnAppendState append_state;
-	column_data->InitializeAppend(append_state);
-
-	// scan the original table, and fill the new column with the transformed value
-	scan_state.Initialize(GetCollection().GetTypes());
-	InitializeScan(scan_state);
-
-	DataChunk append_chunk;
-	vector<LogicalType> append_types;
-	append_types.push_back(target_type);
-	append_chunk.Initialize(Allocator::DefaultAllocator(), append_types);
-	auto &append_vector = append_chunk.data[0];
-	while (true) {
-		// scan the table
-		scan_chunk.Reset();
-		ScanCommitted(scan_state, scan_chunk, TableScanType::TABLE_SCAN_COMMITTED_ROWS);
-		if (scan_chunk.size() == 0) {
-			break;
-		}
-		// execute the expression
-		append_chunk.Reset();
-		executor.ExecuteExpression(scan_chunk, append_vector);
-		column_data->Append(append_state, append_vector, scan_chunk.size());
-	}
-
-	// set up the row_group based on this row_group
-	auto row_group = make_uniq<RowGroup>(new_collection, this->start, this->count);
-	row_group->SetVersionInfo(GetOrCreateVersionInfoPtr());
-	auto &cols = GetColumns();
-	for (idx_t i = 0; i < cols.size(); i++) {
-		if (i == changed_idx) {
-			// this is the altered column: use the new column
-			row_group->columns.push_back(std::move(column_data));
-			column_data.reset();
-		} else {
-			// this column was not altered: use the data directly
-			row_group->columns.push_back(cols[i]);
-		}
-	}
-	row_group->Verify();
-	return row_group;
-}
-
-unique_ptr<RowGroup> RowGroup::AddColumn(RowGroupCollection &new_collection, ColumnDefinition &new_column,
-                                         ExpressionExecutor &executor, Vector &result) {
-	Verify();
-
-	// construct a new column data for the new column
-	auto added_column =
-	    ColumnData::CreateColumn(GetBlockManager(), GetTableInfo(), GetColumnCount(), start, new_column.Type());
-
-	idx_t rows_to_write = this->count;
-	if (rows_to_write > 0) {
-		DataChunk dummy_chunk;
-
-		ColumnAppendState state;
-		added_column->InitializeAppend(state);
-		for (idx_t i = 0; i < rows_to_write; i += STANDARD_VECTOR_SIZE) {
-			idx_t rows_in_this_vector = MinValue<idx_t>(rows_to_write - i, STANDARD_VECTOR_SIZE);
-			dummy_chunk.SetCardinality(rows_in_this_vector);
-			executor.ExecuteExpression(dummy_chunk, result);
-			added_column->Append(state, result, rows_in_this_vector);
-		}
-	}
-
-	// set up the row_group based on this row_group
-	auto row_group = make_uniq<RowGroup>(new_collection, this->start, this->count);
-	row_group->SetVersionInfo(GetOrCreateVersionInfoPtr());
-	row_group->columns = GetColumns();
-	// now add the new column
-	row_group->columns.push_back(std::move(added_column));
-
-	row_group->Verify();
-	return row_group;
-}
-
-unique_ptr<RowGroup> RowGroup::RemoveColumn(RowGroupCollection &new_collection, idx_t removed_column) {
-	Verify();
-
-	D_ASSERT(removed_column < columns.size());
-
-	auto row_group = make_uniq<RowGroup>(new_collection, this->start, this->count);
-	row_group->SetVersionInfo(GetOrCreateVersionInfoPtr());
-	// copy over all columns except for the removed one
-	auto &cols = GetColumns();
-	for (idx_t i = 0; i < cols.size(); i++) {
-		if (i != removed_column) {
-			row_group->columns.push_back(cols[i]);
-		}
-	}
-
-	row_group->Verify();
-	return row_group;
-}
-
-void RowGroup::CommitDrop() {
-	for (idx_t column_idx = 0; column_idx < GetColumnCount(); column_idx++) {
-		CommitDropColumn(column_idx);
-	}
-}
-
-void RowGroup::CommitDropColumn(idx_t column_idx) {
-	GetColumn(column_idx).CommitDropColumn();
-}
-
-void RowGroup::NextVector(CollectionScanState &state) {
-	state.vector_index++;
-	const auto &column_ids = state.GetColumnIds();
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		const auto &column = column_ids[i];
-		if (column.IsRowIdColumn()) {
-			continue;
-		}
-		GetColumn(column).Skip(state.column_scans[i]);
-	}
-}
-
-static FilterPropagateResult CheckRowIdFilter(TableFilter &filter, idx_t beg_row, idx_t end_row) {
-	// RowId columns dont have a zonemap, but we can trivially create stats to check the filter against.
-	BaseStatistics dummy_stats = NumericStats::CreateEmpty(LogicalType::ROW_TYPE);
-	NumericStats::SetMin(dummy_stats, UnsafeNumericCast<row_t>(beg_row));
-	NumericStats::SetMax(dummy_stats, UnsafeNumericCast<row_t>(end_row));
-
-	return filter.CheckStatistics(dummy_stats);
-}
-
-bool RowGroup::CheckZonemap(ScanFilterInfo &filters) {
-	auto &filter_list = filters.GetFilterList();
-	// new row group - label all filters as up for grabs again
-	filters.CheckAllFilters();
-	for (idx_t i = 0; i < filter_list.size(); i++) {
-		auto &entry = filter_list[i];
-		auto &filter = entry.filter;
-		auto base_column_index = entry.table_column_index;
-
-		FilterPropagateResult prune_result;
-
-		if (base_column_index == COLUMN_IDENTIFIER_ROW_ID) {
-			prune_result = CheckRowIdFilter(filter, this->start, this->start + this->count);
-		} else {
-			prune_result = GetColumn(base_column_index).CheckZonemap(filter);
-		}
-
-		if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-			return false;
-		}
-		if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-			// filter is always true - no need to check it
-			// label the filter as always true so we don't need to check it anymore
-			filters.SetFilterAlwaysTrue(i);
-		}
-		if (filter.filter_type == TableFilterType::OPTIONAL_FILTER) {
-			// these are only for row group checking, set as always true so we don't check it
-			filters.SetFilterAlwaysTrue(i);
-		}
-	}
-	return true;
-}
-
-bool RowGroup::CheckZonemapSegments(CollectionScanState &state) {
-	auto &filters = state.GetFilterInfo();
-	for (auto &entry : filters.GetFilterList()) {
-		if (entry.IsAlwaysTrue()) {
-			// filter is always true - avoid checking
-			continue;
-		}
-		auto column_idx = entry.scan_column_index;
-		auto base_column_idx = entry.table_column_index;
-		auto &filter = entry.filter;
-
-		FilterPropagateResult prune_result;
-		if (base_column_idx == COLUMN_IDENTIFIER_ROW_ID) {
-			prune_result = CheckRowIdFilter(filter, this->start, this->start + this->count);
-		} else {
-			prune_result = GetColumn(base_column_idx).CheckZonemap(state.column_scans[column_idx], filter);
-		}
-
-		if (prune_result != FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-			continue;
-		}
-
-		// check zone map segment.
-		auto &column_scan_state = state.column_scans[column_idx];
-		auto current_segment = column_scan_state.current;
-		if (!current_segment) {
-			// no segment to skip
-			continue;
-		}
-		idx_t target_row = current_segment->start + current_segment->count;
-		if (target_row >= state.max_row) {
-			target_row = state.max_row;
-		}
-
-		D_ASSERT(target_row >= this->start);
-		D_ASSERT(target_row <= this->start + this->count);
-		idx_t target_vector_index = (target_row - this->start) / STANDARD_VECTOR_SIZE;
-		if (state.vector_index == target_vector_index) {
-			// we can't skip any full vectors because this segment contains less than a full vector
-			// for now we just bail-out
-			// FIXME: we could check if we can ALSO skip the next segments, in which case skipping a full vector
-			// might be possible
-			// we don't care that much though, since a single segment that fits less than a full vector is
-			// exceedingly rare
-			return true;
-		}
-		while (state.vector_index < target_vector_index) {
-			NextVector(state);
-		}
-		return false;
-	}
-
-	return true;
-}
-
-template <TableScanType TYPE>
-void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result) {
-	const bool ALLOW_UPDATES = TYPE != TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES &&
-	                           TYPE != TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED;
-	const auto &column_ids = state.GetColumnIds();
-	auto &filter_info = state.GetFilterInfo();
-	while (true) {
-		if (state.vector_index * STANDARD_VECTOR_SIZE >= state.max_row_group_row) {
-			// exceeded the amount of rows to scan
-			return;
-		}
-		idx_t current_row = state.vector_index * STANDARD_VECTOR_SIZE;
-		auto max_count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.max_row_group_row - current_row);
-
-		// check the sampling info if we have to sample this chunk
-		if (state.GetSamplingInfo().do_system_sample &&
-		    state.random.NextRandom() > state.GetSamplingInfo().sample_rate) {
-			NextVector(state);
-			continue;
-		}
-
-		//! first check the zonemap if we have to scan this partition
-		if (!CheckZonemapSegments(state)) {
-			continue;
-		}
-
-		// second, scan the version chunk manager to figure out which tuples to load for this transaction
-		idx_t count;
-		if (TYPE == TableScanType::TABLE_SCAN_REGULAR) {
-			count = state.row_group->GetSelVector(transaction, state.vector_index, state.valid_sel, max_count);
-			if (count == 0) {
-				// nothing to scan for this vector, skip the entire vector
-				NextVector(state);
-				continue;
-			}
-		} else if (TYPE == TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED) {
-			count = state.row_group->GetCommittedSelVector(transaction.start_time, transaction.transaction_id,
-			                                               state.vector_index, state.valid_sel, max_count);
-			if (count == 0) {
-				// nothing to scan for this vector, skip the entire vector
-				NextVector(state);
-				continue;
-			}
-		} else {
-			count = max_count;
-		}
-		auto &block_manager = GetBlockManager();
-#ifndef DUCKDB_ALTERNATIVE_VERIFY
-		// // in regular operation we only prefetch from remote file systems
-		// // when alternative verify is set, we always prefetch for testing purposes
-		if (block_manager.IsRemote())
-#else
-		if (!block_manager.InMemory())
-#endif
-		{
-			PrefetchState prefetch_state;
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				const auto &column = column_ids[i];
-				if (!column.IsRowIdColumn()) {
-					GetColumn(column).InitializePrefetch(prefetch_state, state.column_scans[i], max_count);
-				}
-			}
-			auto &buffer_manager = block_manager.buffer_manager;
-			buffer_manager.Prefetch(prefetch_state.blocks);
-		}
-
-		bool has_filters = filter_info.HasFilters();
-		if (count == max_count && !has_filters) {
-			// scan all vectors completely: full scan without deletions or table filters
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				const auto &column = column_ids[i];
-				if (column.IsRowIdColumn()) {
-					// scan row id
-					D_ASSERT(result.data[i].GetType().InternalType() == ROW_TYPE);
-					result.data[i].Sequence(UnsafeNumericCast<int64_t>(this->start + current_row), 1, count);
-				} else {
-					auto &col_data = GetColumn(column);
-					if (TYPE != TableScanType::TABLE_SCAN_REGULAR) {
-						col_data.ScanCommitted(state.vector_index, state.column_scans[i], result.data[i],
-						                       ALLOW_UPDATES);
-					} else {
-						col_data.Scan(transaction, state.vector_index, state.column_scans[i], result.data[i]);
-					}
-				}
-			}
-		} else {
-			// partial scan: we have deletions or table filters
-			idx_t approved_tuple_count = count;
-			SelectionVector sel;
-			if (count != max_count) {
-				sel.Initialize(state.valid_sel);
-			} else {
-				sel.Initialize(nullptr);
-			}
-			//! first, we scan the columns with filters, fetch their data and generate a selection vector.
-			//! get runtime statistics
-			auto adaptive_filter = filter_info.GetAdaptiveFilter();
-			auto filter_state = filter_info.BeginFilter();
-			if (has_filters) {
-				D_ASSERT(ALLOW_UPDATES);
-				auto &filter_list = filter_info.GetFilterList();
-				for (idx_t i = 0; i < filter_list.size(); i++) {
-					auto filter_idx = adaptive_filter->permutation[i];
-					auto &filter = filter_list[filter_idx];
-					if (filter.IsAlwaysTrue()) {
-						// this filter is always true - skip it
-						continue;
-					}
-
-					const auto scan_idx = filter.scan_column_index;
-					const auto column_idx = filter.table_column_index;
-
-					if (column_idx == COLUMN_IDENTIFIER_ROW_ID) {
-
-						// We do another quick statistics scan for row ids here
-						const auto rowid_start = this->start + current_row;
-						const auto rowid_end = this->start + current_row + max_count;
-						const auto prune_result = CheckRowIdFilter(filter.filter, rowid_start, rowid_end);
-						if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-							// We can just break out of the loop here.
-							approved_tuple_count = 0;
-							break;
-						}
-
-						// Generate row ids
-						// Create sequence for row ids
-						D_ASSERT(result.data[i].GetType().InternalType() == ROW_TYPE);
-						result.data[i].SetVectorType(VectorType::FLAT_VECTOR);
-						auto result_data = FlatVector::GetData<int64_t>(result.data[i]);
-						for (size_t sel_idx = 0; sel_idx < approved_tuple_count; sel_idx++) {
-							result_data[sel.get_index(sel_idx)] =
-							    UnsafeNumericCast<int64_t>(this->start + current_row + sel.get_index(sel_idx));
-						}
-
-						// Was this filter always true? If so, we dont need to apply it
-						if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-							continue;
-						}
-
-						// Now apply the filter
-						UnifiedVectorFormat vdata;
-						result.data[i].ToUnifiedFormat(approved_tuple_count, vdata);
-						ColumnSegment::FilterSelection(sel, result.data[i], vdata, filter.filter, approved_tuple_count,
-						                               approved_tuple_count);
-
-					} else {
-						auto &col_data = GetColumn(filter.table_column_index);
-						col_data.Filter(transaction, state.vector_index, state.column_scans[scan_idx],
-						                result.data[scan_idx], sel, approved_tuple_count, filter.filter);
-					}
-				}
-				for (auto &table_filter : filter_list) {
-					if (table_filter.IsAlwaysTrue()) {
-						continue;
-					}
-					result.data[table_filter.scan_column_index].Slice(sel, approved_tuple_count);
-				}
-			}
-			if (approved_tuple_count == 0) {
-				// all rows were filtered out by the table filters
-				D_ASSERT(has_filters);
-				result.Reset();
-				// skip this vector in all the scans that were not scanned yet
-				for (idx_t i = 0; i < column_ids.size(); i++) {
-					auto &col_idx = column_ids[i];
-					if (col_idx.IsRowIdColumn()) {
-						continue;
-					}
-					if (has_filters && filter_info.ColumnHasFilters(i)) {
-						continue;
-					}
-					auto &col_data = GetColumn(col_idx);
-					col_data.Skip(state.column_scans[i]);
-				}
-				state.vector_index++;
-				continue;
-			}
-			//! Now we use the selection vector to fetch data for the other columns.
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				if (has_filters && filter_info.ColumnHasFilters(i)) {
-					// column has already been scanned as part of the filtering process
-					continue;
-				}
-				auto &column = column_ids[i];
-				if (column.IsRowIdColumn()) {
-					D_ASSERT(result.data[i].GetType().InternalType() == ROW_TYPE);
-					result.data[i].SetVectorType(VectorType::FLAT_VECTOR);
-					auto result_data = FlatVector::GetData<int64_t>(result.data[i]);
-					for (size_t sel_idx = 0; sel_idx < approved_tuple_count; sel_idx++) {
-						result_data[sel_idx] =
-						    UnsafeNumericCast<int64_t>(this->start + current_row + sel.get_index(sel_idx));
-					}
-				} else {
-					auto &col_data = GetColumn(column);
-					if (TYPE == TableScanType::TABLE_SCAN_REGULAR) {
-						col_data.Select(transaction, state.vector_index, state.column_scans[i], result.data[i], sel,
-						                approved_tuple_count);
-					} else {
-						col_data.SelectCommitted(state.vector_index, state.column_scans[i], result.data[i], sel,
-						                         approved_tuple_count, ALLOW_UPDATES);
-					}
-				}
-			}
-			filter_info.EndFilter(filter_state);
-
-			D_ASSERT(approved_tuple_count > 0);
-			count = approved_tuple_count;
-		}
-		result.SetCardinality(count);
-		state.vector_index++;
-		break;
-	}
-}
-
-void RowGroup::Scan(TransactionData transaction, CollectionScanState &state, DataChunk &result) {
-	TemplatedScan<TableScanType::TABLE_SCAN_REGULAR>(transaction, state, result);
-}
-
-void RowGroup::ScanCommitted(CollectionScanState &state, DataChunk &result, TableScanType type) {
-	auto &transaction_manager = DuckTransactionManager::Get(GetCollection().GetAttached());
-
-	transaction_t start_ts;
-	transaction_t transaction_id;
-	if (type == TableScanType::TABLE_SCAN_LATEST_COMMITTED_ROWS) {
-		start_ts = transaction_manager.GetLastCommit() + 1;
-		transaction_id = MAX_TRANSACTION_ID;
-	} else {
-		start_ts = transaction_manager.LowestActiveStart();
-		transaction_id = transaction_manager.LowestActiveId();
-	}
-	TransactionData data(transaction_id, start_ts);
-	switch (type) {
-	case TableScanType::TABLE_SCAN_COMMITTED_ROWS:
-		TemplatedScan<TableScanType::TABLE_SCAN_COMMITTED_ROWS>(data, state, result);
-		break;
-	case TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES:
-		TemplatedScan<TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES>(data, state, result);
-		break;
-	case TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED:
-	case TableScanType::TABLE_SCAN_LATEST_COMMITTED_ROWS:
-		TemplatedScan<TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED>(data, state, result);
-		break;
-	default:
-		throw InternalException("Unrecognized table scan type");
-	}
-}
-
-optional_ptr<RowVersionManager> RowGroup::GetVersionInfo() {
-	if (!HasUnloadedDeletes()) {
-		// deletes are loaded - return the version info
-		return version_info;
-	}
-	lock_guard<mutex> lock(row_group_lock);
-	// double-check after obtaining the lock whether or not deletes are still not loaded to avoid double load
-	if (!HasUnloadedDeletes()) {
-		return version_info;
-	}
-	// deletes are not loaded - reload
-	auto root_delete = deletes_pointers[0];
-	auto loaded_info = RowVersionManager::Deserialize(root_delete, GetBlockManager().GetMetadataManager(), start);
-	SetVersionInfo(std::move(loaded_info));
-	deletes_is_loaded = true;
-	return version_info;
-}
-
-void RowGroup::SetVersionInfo(shared_ptr<RowVersionManager> version) {
-	owned_version_info = std::move(version);
-	version_info = owned_version_info.get();
-}
-
-shared_ptr<RowVersionManager> RowGroup::GetOrCreateVersionInfoInternal() {
-	// version info does not exist - need to create it
-	lock_guard<mutex> lock(row_group_lock);
-	if (!owned_version_info) {
-		auto new_info = make_shared_ptr<RowVersionManager>(start);
-		SetVersionInfo(std::move(new_info));
-	}
-	return owned_version_info;
-}
-
-shared_ptr<RowVersionManager> RowGroup::GetOrCreateVersionInfoPtr() {
-	auto vinfo = GetVersionInfo();
-	if (vinfo) {
-		// version info exists - return it directly
-		return owned_version_info;
-	}
-	return GetOrCreateVersionInfoInternal();
-}
-
-RowVersionManager &RowGroup::GetOrCreateVersionInfo() {
-	auto vinfo = GetVersionInfo();
-	if (vinfo) {
-		// version info exists - return it directly
-		return *vinfo;
-	}
-	return *GetOrCreateVersionInfoInternal();
-}
-
-idx_t RowGroup::GetSelVector(TransactionData transaction, idx_t vector_idx, SelectionVector &sel_vector,
-                             idx_t max_count) {
-	auto vinfo = GetVersionInfo();
-	if (!vinfo) {
-		return max_count;
-	}
-	return vinfo->GetSelVector(transaction, vector_idx, sel_vector, max_count);
-}
-
-idx_t RowGroup::GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
-                                      SelectionVector &sel_vector, idx_t max_count) {
-	auto vinfo = GetVersionInfo();
-	if (!vinfo) {
-		return max_count;
-	}
-	return vinfo->GetCommittedSelVector(start_time, transaction_id, vector_idx, sel_vector, max_count);
-}
-
-bool RowGroup::Fetch(TransactionData transaction, idx_t row) {
-	D_ASSERT(row < this->count);
-	auto vinfo = GetVersionInfo();
-	if (!vinfo) {
-		return true;
-	}
-	return vinfo->Fetch(transaction, row);
-}
-
-void RowGroup::FetchRow(TransactionData transaction, ColumnFetchState &state, const vector<StorageIndex> &column_ids,
-                        row_t row_id, DataChunk &result, idx_t result_idx) {
-	for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
-		auto &column = column_ids[col_idx];
-		auto &result_vector = result.data[col_idx];
-		D_ASSERT(result_vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		D_ASSERT(!FlatVector::IsNull(result_vector, result_idx));
-		if (column.IsRowIdColumn()) {
-			// row id column: fill in the row ids
-			D_ASSERT(result_vector.GetType().InternalType() == PhysicalType::INT64);
-			result_vector.SetVectorType(VectorType::FLAT_VECTOR);
-			auto data = FlatVector::GetData<row_t>(result_vector);
-			data[result_idx] = row_id;
-		} else {
-			// regular column: fetch data from the base column
-			auto &col_data = GetColumn(column);
-			col_data.FetchRow(transaction, state, row_id, result_vector, result_idx);
-		}
-	}
-}
-
-void RowGroup::AppendVersionInfo(TransactionData transaction, idx_t count) {
-	const idx_t row_group_size = GetRowGroupSize();
-	idx_t row_group_start = this->count.load();
-	idx_t row_group_end = row_group_start + count;
-	if (row_group_end > row_group_size) {
-		row_group_end = row_group_size;
-	}
-	// create the version_info if it doesn't exist yet
-	auto &vinfo = GetOrCreateVersionInfo();
-	vinfo.AppendVersionInfo(transaction, count, row_group_start, row_group_end);
-	this->count = row_group_end;
-}
-
-void RowGroup::CommitAppend(transaction_t commit_id, idx_t row_group_start, idx_t count) {
-	auto &vinfo = GetOrCreateVersionInfo();
-	vinfo.CommitAppend(commit_id, row_group_start, count);
-}
-
-void RowGroup::RevertAppend(idx_t row_group_start) {
-	auto &vinfo = GetOrCreateVersionInfo();
-	vinfo.RevertAppend(row_group_start - this->start);
-	for (auto &column : columns) {
-		column->RevertAppend(UnsafeNumericCast<row_t>(row_group_start));
-	}
-	this->count = MinValue<idx_t>(row_group_start - this->start, this->count);
-	Verify();
-}
-
-void RowGroup::InitializeAppend(RowGroupAppendState &append_state) {
-	append_state.row_group = this;
-	append_state.offset_in_row_group = this->count;
-	// for each column, initialize the append state
-	append_state.states = make_unsafe_uniq_array<ColumnAppendState>(GetColumnCount());
-	for (idx_t i = 0; i < GetColumnCount(); i++) {
-		auto &col_data = GetColumn(i);
-		col_data.InitializeAppend(append_state.states[i]);
-	}
-}
-
-void RowGroup::Append(RowGroupAppendState &state, DataChunk &chunk, idx_t append_count) {
-	// append to the current row_group
-	D_ASSERT(chunk.ColumnCount() == GetColumnCount());
-	for (idx_t i = 0; i < GetColumnCount(); i++) {
-		auto &col_data = GetColumn(i);
-		auto prev_allocation_size = col_data.GetAllocationSize();
-		col_data.Append(state.states[i], chunk.data[i], append_count);
-		allocation_size += col_data.GetAllocationSize() - prev_allocation_size;
-	}
-	state.offset_in_row_group += append_count;
-}
-
-void RowGroup::CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_t count) {
-	auto &vinfo = GetOrCreateVersionInfo();
-	vinfo.CleanupAppend(lowest_transaction, start, count);
-}
-
-void RowGroup::Update(TransactionData transaction, DataChunk &update_chunk, row_t *ids, idx_t offset, idx_t count,
-                      const vector<PhysicalIndex> &column_ids) {
-#ifdef DEBUG
-	for (size_t i = offset; i < offset + count; i++) {
-		D_ASSERT(ids[i] >= row_t(this->start) && ids[i] < row_t(this->start + this->count));
-	}
-#endif
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column = column_ids[i];
-		D_ASSERT(column.index != COLUMN_IDENTIFIER_ROW_ID);
-		auto &col_data = GetColumn(column.index);
-		D_ASSERT(col_data.type.id() == update_chunk.data[i].GetType().id());
-		if (offset > 0) {
-			Vector sliced_vector(update_chunk.data[i], offset, offset + count);
-			sliced_vector.Flatten(count);
-			col_data.Update(transaction, column.index, sliced_vector, ids + offset, count);
-		} else {
-			col_data.Update(transaction, column.index, update_chunk.data[i], ids, count);
-		}
-		MergeStatistics(column.index, *col_data.GetUpdateStatistics());
-	}
-}
-
-void RowGroup::UpdateColumn(TransactionData transaction, DataChunk &updates, Vector &row_ids,
-                            const vector<column_t> &column_path) {
-	D_ASSERT(updates.ColumnCount() == 1);
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-
-	auto primary_column_idx = column_path[0];
-	D_ASSERT(primary_column_idx != COLUMN_IDENTIFIER_ROW_ID);
-	D_ASSERT(primary_column_idx < columns.size());
-	auto &col_data = GetColumn(primary_column_idx);
-	col_data.UpdateColumn(transaction, column_path, updates.data[0], ids, updates.size(), 1);
-	MergeStatistics(primary_column_idx, *col_data.GetUpdateStatistics());
-}
-
-unique_ptr<BaseStatistics> RowGroup::GetStatistics(idx_t column_idx) {
-	auto &col_data = GetColumn(column_idx);
-	return col_data.GetStatistics();
-}
-
-void RowGroup::MergeStatistics(idx_t column_idx, const BaseStatistics &other) {
-	auto &col_data = GetColumn(column_idx);
-	col_data.MergeStatistics(other);
-}
-
-void RowGroup::MergeIntoStatistics(idx_t column_idx, BaseStatistics &other) {
-	auto &col_data = GetColumn(column_idx);
-	col_data.MergeIntoStatistics(other);
-}
-
-void RowGroup::MergeIntoStatistics(TableStatistics &other) {
-	auto stats_lock = other.GetLock();
-	for (idx_t i = 0; i < columns.size(); i++) {
-		MergeIntoStatistics(i, other.GetStats(*stats_lock, i).Statistics());
-	}
-}
-
-CompressionType ColumnCheckpointInfo::GetCompressionType() {
-	return info.compression_types[column_idx];
-}
-
-RowGroupWriteData RowGroup::WriteToDisk(RowGroupWriteInfo &info) {
-	RowGroupWriteData result;
-	result.states.reserve(columns.size());
-	result.statistics.reserve(columns.size());
-
-	// Checkpoint the individual columns of the row group
-	// Here we're iterating over columns. Each column can have multiple segments.
-	// (Some columns will be wider than others, and require different numbers
-	// of blocks to encode.) Segments cannot span blocks.
-	//
-	// Some of these columns are composite (list, struct). The data is written
-	// first sequentially, and the pointers are written later, so that the
-	// pointers all end up densely packed, and thus more cache-friendly.
-	for (idx_t column_idx = 0; column_idx < GetColumnCount(); column_idx++) {
-		auto &column = GetColumn(column_idx);
-		ColumnCheckpointInfo checkpoint_info(info, column_idx);
-		auto checkpoint_state = column.Checkpoint(*this, checkpoint_info);
-		D_ASSERT(checkpoint_state);
-
-		auto stats = checkpoint_state->GetStatistics();
-		D_ASSERT(stats);
-
-		result.statistics.push_back(stats->Copy());
-		result.states.push_back(std::move(checkpoint_state));
-	}
-	D_ASSERT(result.states.size() == result.statistics.size());
-	return result;
-}
-
-idx_t RowGroup::GetCommittedRowCount() {
-	auto vinfo = GetVersionInfo();
-	if (!vinfo) {
-		return count;
-	}
-	return count - vinfo->GetCommittedDeletedCount(count);
-}
-
-bool RowGroup::HasUnloadedDeletes() const {
-	if (deletes_pointers.empty()) {
-		// no stored deletes at all
-		return false;
-	}
-	// return whether or not the deletes have been loaded
-	return !deletes_is_loaded;
-}
-
-RowGroupWriteData RowGroup::WriteToDisk(RowGroupWriter &writer) {
-	vector<CompressionType> compression_types;
-	compression_types.reserve(columns.size());
-	for (idx_t column_idx = 0; column_idx < GetColumnCount(); column_idx++) {
-		auto &column = GetColumn(column_idx);
-		if (column.count != this->count) {
-			throw InternalException("Corrupted in-memory column - column with index %llu has misaligned count (row "
-			                        "group has %llu rows, column has %llu)",
-			                        column_idx, this->count.load(), column.count.load());
-		}
-		compression_types.push_back(writer.GetColumnCompressionType(column_idx));
-	}
-
-	RowGroupWriteInfo info(writer.GetPartialBlockManager(), compression_types, writer.GetCheckpointType());
-	return WriteToDisk(info);
-}
-
-RowGroupPointer RowGroup::Checkpoint(RowGroupWriteData write_data, RowGroupWriter &writer,
-                                     TableStatistics &global_stats) {
-	RowGroupPointer row_group_pointer;
-
-	auto lock = global_stats.GetLock();
-	for (idx_t column_idx = 0; column_idx < GetColumnCount(); column_idx++) {
-		global_stats.GetStats(*lock, column_idx).Statistics().Merge(write_data.statistics[column_idx]);
-	}
-
-	// construct the row group pointer and write the column meta data to disk
-	D_ASSERT(write_data.states.size() == columns.size());
-	row_group_pointer.row_start = start;
-	row_group_pointer.tuple_count = count;
-	for (auto &state : write_data.states) {
-		// get the current position of the table data writer
-		auto &data_writer = writer.GetPayloadWriter();
-		auto pointer = data_writer.GetMetaBlockPointer();
-
-		// store the stats and the data pointers in the row group pointers
-		row_group_pointer.data_pointers.push_back(pointer);
-
-		// Write pointers to the column segments.
-		//
-		// Just as above, the state can refer to many other states, so this
-		// can cascade recursively into more pointer writes.
-		auto persistent_data = state->ToPersistentData();
-		BinarySerializer serializer(data_writer);
-		serializer.Begin();
-		persistent_data.Serialize(serializer);
-		serializer.End();
-	}
-	row_group_pointer.deletes_pointers = CheckpointDeletes(writer.GetPayloadWriter().GetManager());
-	Verify();
-	return row_group_pointer;
-}
-
-bool RowGroup::IsPersistent() const {
-	for (auto &column : columns) {
-		if (!column->IsPersistent()) {
-			// column is not persistent
-			return false;
-		}
-	}
-	return true;
-}
-
-PersistentRowGroupData RowGroup::SerializeRowGroupInfo() const {
-	// all columns are persistent - serialize
-	PersistentRowGroupData result;
-	for (auto &col : columns) {
-		result.column_data.push_back(col->Serialize());
-	}
-	result.start = start;
-	result.count = count;
-	return result;
-}
-
-vector<MetaBlockPointer> RowGroup::CheckpointDeletes(MetadataManager &manager) {
-	if (HasUnloadedDeletes()) {
-		// deletes were not loaded so they cannot be changed
-		// re-use them as-is
-		manager.ClearModifiedBlocks(deletes_pointers);
-		return deletes_pointers;
-	}
-	auto vinfo = GetVersionInfo();
-	if (!vinfo) {
-		// no version information: write nothing
-		return vector<MetaBlockPointer>();
-	}
-	return vinfo->Checkpoint(manager);
-}
-
-void RowGroup::Serialize(RowGroupPointer &pointer, Serializer &serializer) {
-	serializer.WriteProperty(100, "row_start", pointer.row_start);
-	serializer.WriteProperty(101, "tuple_count", pointer.tuple_count);
-	serializer.WriteProperty(102, "data_pointers", pointer.data_pointers);
-	serializer.WriteProperty(103, "delete_pointers", pointer.deletes_pointers);
-}
-
-RowGroupPointer RowGroup::Deserialize(Deserializer &deserializer) {
-	RowGroupPointer result;
-	result.row_start = deserializer.ReadProperty<uint64_t>(100, "row_start");
-	result.tuple_count = deserializer.ReadProperty<uint64_t>(101, "tuple_count");
-	result.data_pointers = deserializer.ReadProperty<vector<MetaBlockPointer>>(102, "data_pointers");
-	result.deletes_pointers = deserializer.ReadProperty<vector<MetaBlockPointer>>(103, "delete_pointers");
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// GetPartitionStats
-//===--------------------------------------------------------------------===//
-PartitionStatistics RowGroup::GetPartitionStats() const {
-	PartitionStatistics result;
-	result.row_start = start;
-	result.count = count;
-	if (HasUnloadedDeletes() || version_info.load().get()) {
-		// we have version info - approx count
-		result.count_type = CountType::COUNT_APPROXIMATE;
-	} else {
-		result.count_type = CountType::COUNT_EXACT;
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// GetColumnSegmentInfo
-//===--------------------------------------------------------------------===//
-void RowGroup::GetColumnSegmentInfo(idx_t row_group_index, vector<ColumnSegmentInfo> &result) {
-	for (idx_t col_idx = 0; col_idx < GetColumnCount(); col_idx++) {
-		auto &col_data = GetColumn(col_idx);
-		col_data.GetColumnSegmentInfo(row_group_index, {col_idx}, result);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Version Delete Information
-//===--------------------------------------------------------------------===//
-class VersionDeleteState {
-public:
-	VersionDeleteState(RowGroup &info, TransactionData transaction, DataTable &table, idx_t base_row)
-	    : info(info), transaction(transaction), table(table), current_chunk(DConstants::INVALID_INDEX), count(0),
-	      base_row(base_row), delete_count(0) {
-	}
-
-	RowGroup &info;
-	TransactionData transaction;
-	DataTable &table;
-	idx_t current_chunk;
-	row_t rows[STANDARD_VECTOR_SIZE];
-	idx_t count;
-	idx_t base_row;
-	idx_t chunk_row;
-	idx_t delete_count;
-
-public:
-	void Delete(row_t row_id);
-	void Flush();
-};
-
-idx_t RowGroup::Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count) {
-	VersionDeleteState del_state(*this, transaction, table, this->start);
-
-	// obtain a write lock
-	for (idx_t i = 0; i < count; i++) {
-		D_ASSERT(ids[i] >= 0);
-		D_ASSERT(idx_t(ids[i]) >= this->start && idx_t(ids[i]) < this->start + this->count);
-		del_state.Delete(ids[i] - UnsafeNumericCast<row_t>(this->start));
-	}
-	del_state.Flush();
-	return del_state.delete_count;
-}
-
-void RowGroup::Verify() {
-#ifdef DEBUG
-	for (auto &column : GetColumns()) {
-		column->Verify(*this);
-	}
-#endif
-}
-
-idx_t RowGroup::DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count) {
-	return GetOrCreateVersionInfo().DeleteRows(vector_idx, transaction_id, rows, count);
-}
-
-void VersionDeleteState::Delete(row_t row_id) {
-	D_ASSERT(row_id >= 0);
-	idx_t vector_idx = UnsafeNumericCast<idx_t>(row_id) / STANDARD_VECTOR_SIZE;
-	idx_t idx_in_vector = UnsafeNumericCast<idx_t>(row_id) - vector_idx * STANDARD_VECTOR_SIZE;
-	if (current_chunk != vector_idx) {
-		Flush();
-
-		current_chunk = vector_idx;
-		chunk_row = vector_idx * STANDARD_VECTOR_SIZE;
-	}
-	rows[count++] = UnsafeNumericCast<row_t>(idx_in_vector);
-}
-
-void VersionDeleteState::Flush() {
-	if (count == 0) {
-		return;
-	}
-	// it is possible for delete statements to delete the same tuple multiple times when combined with a USING clause
-	// in the current_info->Delete, we check which tuples are actually deleted (excluding duplicate deletions)
-	// this is returned in the actual_delete_count
-	auto actual_delete_count = info.DeleteRows(current_chunk, transaction.transaction_id, rows, count);
-	delete_count += actual_delete_count;
-	if (transaction.transaction && actual_delete_count > 0) {
-		// now push the delete into the undo buffer, but only if any deletes were actually performed
-		transaction.transaction->PushDelete(table, info.GetOrCreateVersionInfo(), current_chunk, rows,
-		                                    actual_delete_count, base_row + chunk_row);
-	}
-	count = 0;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/row_group_collection.cpp b/src/duckdb/src/storage/table/row_group_collection.cpp
deleted file mode 100644
index 90a7236ff..000000000
--- a/src/duckdb/src/storage/table/row_group_collection.cpp
+++ /dev/null
@@ -1,1274 +0,0 @@
-#include "duckdb/storage/table/row_group_collection.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/execution/task_error_manager.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/task_executor.hpp"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/storage/checkpoint/table_data_writer.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/persistent_table_data.hpp"
-#include "duckdb/storage/table/row_group_segment_tree.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table_storage_info.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Row Group Segment Tree
-//===--------------------------------------------------------------------===//
-RowGroupSegmentTree::RowGroupSegmentTree(RowGroupCollection &collection)
-    : SegmentTree<RowGroup, true>(), collection(collection), current_row_group(0), max_row_group(0) {
-}
-RowGroupSegmentTree::~RowGroupSegmentTree() {
-}
-
-void RowGroupSegmentTree::Initialize(PersistentTableData &data) {
-	D_ASSERT(data.row_group_count > 0);
-	current_row_group = 0;
-	max_row_group = data.row_group_count;
-	finished_loading = false;
-	reader = make_uniq<MetadataReader>(collection.GetMetadataManager(), data.block_pointer);
-}
-
-unique_ptr<RowGroup> RowGroupSegmentTree::LoadSegment() {
-	if (current_row_group >= max_row_group) {
-		reader.reset();
-		finished_loading = true;
-		return nullptr;
-	}
-	BinaryDeserializer deserializer(*reader);
-	deserializer.Begin();
-	auto row_group_pointer = RowGroup::Deserialize(deserializer);
-	deserializer.End();
-	current_row_group++;
-	return make_uniq<RowGroup>(collection, std::move(row_group_pointer));
-}
-
-//===--------------------------------------------------------------------===//
-// Row Group Collection
-//===--------------------------------------------------------------------===//
-RowGroupCollection::RowGroupCollection(shared_ptr<DataTableInfo> info_p, TableIOManager &io_manager,
-                                       vector<LogicalType> types_p, idx_t row_start, idx_t total_rows)
-    : RowGroupCollection(std::move(info_p), io_manager.GetBlockManagerForRowData(), std::move(types_p), row_start,
-                         total_rows, io_manager.GetRowGroupSize()) {
-}
-
-RowGroupCollection::RowGroupCollection(shared_ptr<DataTableInfo> info_p, BlockManager &block_manager,
-                                       vector<LogicalType> types_p, idx_t row_start_p, idx_t total_rows_p,
-                                       idx_t row_group_size_p)
-    : block_manager(block_manager), row_group_size(row_group_size_p), total_rows(total_rows_p), info(std::move(info_p)),
-      types(std::move(types_p)), row_start(row_start_p), allocation_size(0) {
-	row_groups = make_shared_ptr<RowGroupSegmentTree>(*this);
-}
-
-idx_t RowGroupCollection::GetTotalRows() const {
-	return total_rows.load();
-}
-
-const vector<LogicalType> &RowGroupCollection::GetTypes() const {
-	return types;
-}
-
-Allocator &RowGroupCollection::GetAllocator() const {
-	return Allocator::Get(info->GetDB());
-}
-
-AttachedDatabase &RowGroupCollection::GetAttached() {
-	return GetTableInfo().GetDB();
-}
-
-MetadataManager &RowGroupCollection::GetMetadataManager() {
-	return GetBlockManager().GetMetadataManager();
-}
-
-//===--------------------------------------------------------------------===//
-// Initialize
-//===--------------------------------------------------------------------===//
-void RowGroupCollection::Initialize(PersistentTableData &data) {
-	D_ASSERT(this->row_start == 0);
-	auto l = row_groups->Lock();
-	this->total_rows = data.total_rows;
-	row_groups->Initialize(data);
-	stats.Initialize(types, data);
-}
-
-void RowGroupCollection::Initialize(PersistentCollectionData &data) {
-	stats.InitializeEmpty(types);
-	auto l = row_groups->Lock();
-	for (auto &row_group_data : data.row_group_data) {
-		auto row_group = make_uniq<RowGroup>(*this, row_group_data);
-		row_group->MergeIntoStatistics(stats);
-		total_rows += row_group->count;
-		row_groups->AppendSegment(l, std::move(row_group));
-	}
-}
-
-void RowGroupCollection::InitializeEmpty() {
-	stats.InitializeEmpty(types);
-}
-
-void RowGroupCollection::AppendRowGroup(SegmentLock &l, idx_t start_row) {
-	D_ASSERT(start_row >= row_start);
-	auto new_row_group = make_uniq<RowGroup>(*this, start_row, 0U);
-	new_row_group->InitializeEmpty(types);
-	row_groups->AppendSegment(l, std::move(new_row_group));
-}
-
-RowGroup *RowGroupCollection::GetRowGroup(int64_t index) {
-	return (RowGroup *)row_groups->GetSegmentByIndex(index);
-}
-
-void RowGroupCollection::Verify() {
-#ifdef DEBUG
-	idx_t current_total_rows = 0;
-	row_groups->Verify();
-	for (auto &row_group : row_groups->Segments()) {
-		row_group.Verify();
-		D_ASSERT(&row_group.GetCollection() == this);
-		D_ASSERT(row_group.start == this->row_start + current_total_rows);
-		current_total_rows += row_group.count;
-	}
-	D_ASSERT(current_total_rows == total_rows.load());
-#endif
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void RowGroupCollection::InitializeScan(CollectionScanState &state, const vector<StorageIndex> &column_ids,
-                                        TableFilterSet *table_filters) {
-	auto row_group = row_groups->GetRootSegment();
-	D_ASSERT(row_group);
-	state.row_groups = row_groups.get();
-	state.max_row = row_start + total_rows;
-	state.Initialize(GetTypes());
-	while (row_group && !row_group->InitializeScan(state)) {
-		row_group = row_groups->GetNextSegment(row_group);
-	}
-}
-
-void RowGroupCollection::InitializeCreateIndexScan(CreateIndexScanState &state) {
-	state.segment_lock = row_groups->Lock();
-}
-
-void RowGroupCollection::InitializeScanWithOffset(CollectionScanState &state, const vector<StorageIndex> &column_ids,
-                                                  idx_t start_row, idx_t end_row) {
-	auto row_group = row_groups->GetSegment(start_row);
-	D_ASSERT(row_group);
-	state.row_groups = row_groups.get();
-	state.max_row = end_row;
-	state.Initialize(GetTypes());
-	idx_t start_vector = (start_row - row_group->start) / STANDARD_VECTOR_SIZE;
-	if (!row_group->InitializeScanWithOffset(state, start_vector)) {
-		throw InternalException("Failed to initialize row group scan with offset");
-	}
-}
-
-bool RowGroupCollection::InitializeScanInRowGroup(CollectionScanState &state, RowGroupCollection &collection,
-                                                  RowGroup &row_group, idx_t vector_index, idx_t max_row) {
-	state.max_row = max_row;
-	state.row_groups = collection.row_groups.get();
-	if (!state.column_scans) {
-		// initialize the scan state
-		state.Initialize(collection.GetTypes());
-	}
-	return row_group.InitializeScanWithOffset(state, vector_index);
-}
-
-void RowGroupCollection::InitializeParallelScan(ParallelCollectionScanState &state) {
-	state.collection = this;
-	state.current_row_group = row_groups->GetRootSegment();
-	state.vector_index = 0;
-	state.max_row = row_start + total_rows;
-	state.batch_index = 0;
-	state.processed_rows = 0;
-}
-
-bool RowGroupCollection::NextParallelScan(ClientContext &context, ParallelCollectionScanState &state,
-                                          CollectionScanState &scan_state) {
-	while (true) {
-		idx_t vector_index;
-		idx_t max_row;
-		RowGroupCollection *collection;
-		RowGroup *row_group;
-		{
-			// select the next row group to scan from the parallel state
-			lock_guard<mutex> l(state.lock);
-			if (!state.current_row_group || state.current_row_group->count == 0) {
-				// no more data left to scan
-				break;
-			}
-			collection = state.collection;
-			row_group = state.current_row_group;
-			if (ClientConfig::GetConfig(context).verify_parallelism) {
-				vector_index = state.vector_index;
-				max_row = state.current_row_group->start +
-				          MinValue<idx_t>(state.current_row_group->count,
-				                          STANDARD_VECTOR_SIZE * state.vector_index + STANDARD_VECTOR_SIZE);
-				D_ASSERT(vector_index * STANDARD_VECTOR_SIZE < state.current_row_group->count);
-				state.vector_index++;
-				if (state.vector_index * STANDARD_VECTOR_SIZE >= state.current_row_group->count) {
-					state.current_row_group = row_groups->GetNextSegment(state.current_row_group);
-					state.vector_index = 0;
-				}
-			} else {
-				state.processed_rows += state.current_row_group->count;
-				vector_index = 0;
-				max_row = state.current_row_group->start + state.current_row_group->count;
-				state.current_row_group = row_groups->GetNextSegment(state.current_row_group);
-			}
-			max_row = MinValue<idx_t>(max_row, state.max_row);
-			scan_state.batch_index = ++state.batch_index;
-		}
-		D_ASSERT(collection);
-		D_ASSERT(row_group);
-
-		// initialize the scan for this row group
-		bool need_to_scan = InitializeScanInRowGroup(scan_state, *collection, *row_group, vector_index, max_row);
-		if (!need_to_scan) {
-			// skip this row group
-			continue;
-		}
-		return true;
-	}
-	lock_guard<mutex> l(state.lock);
-	scan_state.batch_index = state.batch_index;
-	return false;
-}
-
-bool RowGroupCollection::Scan(DuckTransaction &transaction, const vector<StorageIndex> &column_ids,
-                              const std::function<bool(DataChunk &chunk)> &fun) {
-	vector<LogicalType> scan_types;
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		scan_types.push_back(types[column_ids[i].GetPrimaryIndex()]);
-	}
-	DataChunk chunk;
-	chunk.Initialize(GetAllocator(), scan_types);
-
-	// initialize the scan
-	TableScanState state;
-	state.Initialize(column_ids, nullptr);
-	InitializeScan(state.local_state, column_ids, nullptr);
-
-	while (true) {
-		chunk.Reset();
-		state.local_state.Scan(transaction, chunk);
-		if (chunk.size() == 0) {
-			return true;
-		}
-		if (!fun(chunk)) {
-			return false;
-		}
-	}
-}
-
-bool RowGroupCollection::Scan(DuckTransaction &transaction, const std::function<bool(DataChunk &chunk)> &fun) {
-	vector<StorageIndex> column_ids;
-	column_ids.reserve(types.size());
-	for (idx_t i = 0; i < types.size(); i++) {
-		column_ids.emplace_back(i);
-	}
-	return Scan(transaction, column_ids, fun);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void RowGroupCollection::Fetch(TransactionData transaction, DataChunk &result, const vector<StorageIndex> &column_ids,
-                               const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) {
-	// figure out which row_group to fetch from
-	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
-	idx_t count = 0;
-	for (idx_t i = 0; i < fetch_count; i++) {
-		auto row_id = row_ids[i];
-		RowGroup *row_group;
-		{
-			idx_t segment_index;
-			auto l = row_groups->Lock();
-			if (!row_groups->TryGetSegmentIndex(l, UnsafeNumericCast<idx_t>(row_id), segment_index)) {
-				// in parallel append scenarios it is possible for the row_id
-				continue;
-			}
-			row_group = row_groups->GetSegmentByIndex(l, UnsafeNumericCast<int64_t>(segment_index));
-		}
-		if (!row_group->Fetch(transaction, UnsafeNumericCast<idx_t>(row_id) - row_group->start)) {
-			continue;
-		}
-		row_group->FetchRow(transaction, state, column_ids, row_id, result, count);
-		count++;
-	}
-	result.SetCardinality(count);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-TableAppendState::TableAppendState()
-    : row_group_append_state(*this), total_append_count(0), start_row_group(nullptr), transaction(0, 0),
-      hashes(LogicalType::HASH) {
-}
-
-TableAppendState::~TableAppendState() {
-}
-
-bool RowGroupCollection::IsEmpty() const {
-	auto l = row_groups->Lock();
-	return IsEmpty(l);
-}
-
-bool RowGroupCollection::IsEmpty(SegmentLock &l) const {
-	return row_groups->IsEmpty(l);
-}
-
-void RowGroupCollection::InitializeAppend(TransactionData transaction, TableAppendState &state) {
-	state.row_start = UnsafeNumericCast<row_t>(total_rows.load());
-	state.current_row = state.row_start;
-	state.total_append_count = 0;
-
-	// start writing to the row_groups
-	auto l = row_groups->Lock();
-	if (IsEmpty(l)) {
-		// empty row group collection: empty first row group
-		AppendRowGroup(l, row_start);
-	}
-	state.start_row_group = row_groups->GetLastSegment(l);
-	D_ASSERT(this->row_start + total_rows == state.start_row_group->start + state.start_row_group->count);
-	state.start_row_group->InitializeAppend(state.row_group_append_state);
-	state.transaction = transaction;
-
-	// initialize thread-local stats so we have less lock contention when updating distinct statistics
-	state.stats = TableStatistics();
-	state.stats.InitializeEmpty(types);
-}
-
-void RowGroupCollection::InitializeAppend(TableAppendState &state) {
-	TransactionData tdata(0, 0);
-	InitializeAppend(tdata, state);
-}
-
-bool RowGroupCollection::Append(DataChunk &chunk, TableAppendState &state) {
-	const idx_t row_group_size = GetRowGroupSize();
-	D_ASSERT(chunk.ColumnCount() == types.size());
-	chunk.Verify();
-
-	bool new_row_group = false;
-	idx_t total_append_count = chunk.size();
-	idx_t remaining = chunk.size();
-	state.total_append_count += total_append_count;
-	while (true) {
-		auto current_row_group = state.row_group_append_state.row_group;
-		// check how much we can fit into the current row_group
-		idx_t append_count =
-		    MinValue<idx_t>(remaining, row_group_size - state.row_group_append_state.offset_in_row_group);
-		if (append_count > 0) {
-			auto previous_allocation_size = current_row_group->GetAllocationSize();
-			current_row_group->Append(state.row_group_append_state, chunk, append_count);
-			allocation_size += current_row_group->GetAllocationSize() - previous_allocation_size;
-			// merge the stats
-			current_row_group->MergeIntoStatistics(stats);
-		}
-		remaining -= append_count;
-		if (remaining > 0) {
-			// we expect max 1 iteration of this loop (i.e. a single chunk should never overflow more than one
-			// row_group)
-			D_ASSERT(chunk.size() == remaining + append_count);
-			// slice the input chunk
-			if (remaining < chunk.size()) {
-				chunk.Slice(append_count, remaining);
-			}
-			// append a new row_group
-			new_row_group = true;
-			auto next_start = current_row_group->start + state.row_group_append_state.offset_in_row_group;
-
-			auto l = row_groups->Lock();
-			AppendRowGroup(l, next_start);
-			// set up the append state for this row_group
-			auto last_row_group = row_groups->GetLastSegment(l);
-			last_row_group->InitializeAppend(state.row_group_append_state);
-			continue;
-		} else {
-			break;
-		}
-	}
-	state.current_row += row_t(total_append_count);
-
-	auto local_stats_lock = state.stats.GetLock();
-
-	for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) {
-		auto &column_stats = state.stats.GetStats(*local_stats_lock, col_idx);
-		column_stats.UpdateDistinctStatistics(chunk.data[col_idx], chunk.size(), state.hashes);
-	}
-
-	auto &table_sample = state.stats.GetTableSampleRef(*local_stats_lock);
-	if (!table_sample.destroyed) {
-		D_ASSERT(table_sample.type == SampleType::RESERVOIR_SAMPLE);
-		table_sample.AddToReservoir(chunk);
-	}
-
-	return new_row_group;
-}
-
-void RowGroupCollection::FinalizeAppend(TransactionData transaction, TableAppendState &state) {
-	const idx_t row_group_size = GetRowGroupSize();
-
-	auto remaining = state.total_append_count;
-	auto row_group = state.start_row_group;
-	while (remaining > 0) {
-		auto append_count = MinValue<idx_t>(remaining, row_group_size - row_group->count);
-		row_group->AppendVersionInfo(transaction, append_count);
-		remaining -= append_count;
-		row_group = row_groups->GetNextSegment(row_group);
-	}
-	total_rows += state.total_append_count;
-
-	state.total_append_count = 0;
-	state.start_row_group = nullptr;
-
-	auto local_stats_lock = state.stats.GetLock();
-	auto global_stats_lock = stats.GetLock();
-	for (idx_t col_idx = 0; col_idx < types.size(); col_idx++) {
-		auto &global_stats = stats.GetStats(*global_stats_lock, col_idx);
-		if (!global_stats.HasDistinctStats()) {
-			continue;
-		}
-		auto &local_stats = state.stats.GetStats(*local_stats_lock, col_idx);
-		if (!local_stats.HasDistinctStats()) {
-			continue;
-		}
-		global_stats.DistinctStats().Merge(local_stats.DistinctStats());
-	}
-
-	auto local_sample = state.stats.GetTableSample(*local_stats_lock);
-	auto global_sample = stats.GetTableSample(*global_stats_lock);
-
-	if (local_sample && global_sample) {
-		D_ASSERT(global_sample->type == SampleType::RESERVOIR_SAMPLE);
-		auto &reservoir_sample = global_sample->Cast<ReservoirSample>();
-		reservoir_sample.Merge(std::move(local_sample));
-		// initialize the thread local sample again
-		auto new_local_sample = make_uniq<ReservoirSample>(reservoir_sample.GetSampleCount());
-		state.stats.SetTableSample(*local_stats_lock, std::move(new_local_sample));
-		stats.SetTableSample(*global_stats_lock, std::move(global_sample));
-	} else {
-		state.stats.SetTableSample(*local_stats_lock, std::move(local_sample));
-		stats.SetTableSample(*global_stats_lock, std::move(global_sample));
-	}
-
-	Verify();
-}
-
-void RowGroupCollection::CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count) {
-	auto row_group = row_groups->GetSegment(row_start);
-	D_ASSERT(row_group);
-	idx_t current_row = row_start;
-	idx_t remaining = count;
-	while (true) {
-		idx_t start_in_row_group = current_row - row_group->start;
-		idx_t append_count = MinValue<idx_t>(row_group->count - start_in_row_group, remaining);
-
-		row_group->CommitAppend(commit_id, start_in_row_group, append_count);
-
-		current_row += append_count;
-		remaining -= append_count;
-		if (remaining == 0) {
-			break;
-		}
-		row_group = row_groups->GetNextSegment(row_group);
-	}
-}
-
-void RowGroupCollection::RevertAppendInternal(idx_t start_row) {
-	total_rows = start_row;
-
-	auto l = row_groups->Lock();
-	idx_t segment_count = row_groups->GetSegmentCount(l);
-	if (segment_count == 0) {
-		// we have no segments to revert
-		return;
-	}
-	idx_t segment_index;
-	// find the segment index that the start row belongs to
-	if (!row_groups->TryGetSegmentIndex(l, start_row, segment_index)) {
-		// revert from the last segment
-		segment_index = segment_count - 1;
-	}
-	auto &segment = *row_groups->GetSegmentByIndex(l, UnsafeNumericCast<int64_t>(segment_index));
-
-	// remove any segments AFTER this segment: they should be deleted entirely
-	row_groups->EraseSegments(l, segment_index);
-
-	segment.next = nullptr;
-	segment.RevertAppend(start_row);
-}
-
-void RowGroupCollection::CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_t count) {
-	auto row_group = row_groups->GetSegment(start);
-	D_ASSERT(row_group);
-	idx_t current_row = start;
-	idx_t remaining = count;
-	while (true) {
-		idx_t start_in_row_group = current_row - row_group->start;
-		idx_t append_count = MinValue<idx_t>(row_group->count - start_in_row_group, remaining);
-
-		row_group->CleanupAppend(lowest_transaction, start_in_row_group, append_count);
-
-		current_row += append_count;
-		remaining -= append_count;
-		if (remaining == 0) {
-			break;
-		}
-		row_group = row_groups->GetNextSegment(row_group);
-	}
-}
-
-bool RowGroupCollection::IsPersistent() const {
-	for (auto &row_group : row_groups->Segments()) {
-		if (!row_group.IsPersistent()) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void RowGroupCollection::MergeStorage(RowGroupCollection &data, optional_ptr<DataTable> table,
-                                      optional_ptr<StorageCommitState> commit_state) {
-	D_ASSERT(data.types == types);
-	auto start_index = row_start + total_rows.load();
-	auto index = start_index;
-	auto segments = data.row_groups->MoveSegments();
-
-	// check if the row groups we are merging are optimistically written
-	// if all row groups are optimistically written we keep around the block pointers
-	unique_ptr<PersistentCollectionData> row_group_data;
-	idx_t optimistically_written_count = 0;
-	if (commit_state) {
-		for (auto &entry : segments) {
-			auto &row_group = *entry.node;
-			if (!row_group.IsPersistent()) {
-				break;
-			}
-			optimistically_written_count += row_group.count;
-		}
-		if (optimistically_written_count > 0) {
-			row_group_data = make_uniq<PersistentCollectionData>();
-		}
-	}
-	for (auto &entry : segments) {
-		auto &row_group = entry.node;
-		row_group->MoveToCollection(*this, index);
-
-		if (commit_state && (index - start_index) < optimistically_written_count) {
-			// serialize the block pointers of this row group
-			auto persistent_data = row_group->SerializeRowGroupInfo();
-			persistent_data.types = types;
-			row_group_data->row_group_data.push_back(std::move(persistent_data));
-		}
-		index += row_group->count;
-		row_groups->AppendSegment(std::move(row_group));
-	}
-	if (commit_state && optimistically_written_count > 0) {
-		// if we have serialized the row groups - push the serialized block pointers into the commit state
-		commit_state->AddRowGroupData(*table, start_index, optimistically_written_count, std::move(row_group_data));
-	}
-	stats.MergeStats(data.stats);
-	total_rows += data.total_rows.load();
-}
-
-//===--------------------------------------------------------------------===//
-// Delete
-//===--------------------------------------------------------------------===//
-idx_t RowGroupCollection::Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count) {
-	idx_t delete_count = 0;
-	// delete is in the row groups
-	// we need to figure out for each id to which row group it belongs
-	// usually all (or many) ids belong to the same row group
-	// we iterate over the ids and check for every id if it belongs to the same row group as their predecessor
-	idx_t pos = 0;
-	do {
-		idx_t start = pos;
-		auto row_group = row_groups->GetSegment(UnsafeNumericCast<idx_t>(ids[start]));
-		for (pos++; pos < count; pos++) {
-			D_ASSERT(ids[pos] >= 0);
-			// check if this id still belongs to this row group
-			if (idx_t(ids[pos]) < row_group->start) {
-				// id is before row_group start -> it does not
-				break;
-			}
-			if (idx_t(ids[pos]) >= row_group->start + row_group->count) {
-				// id is after row group end -> it does not
-				break;
-			}
-		}
-		delete_count += row_group->Delete(transaction, table, ids + start, pos - start);
-	} while (pos < count);
-
-	// When deleting destroy the sample.
-	auto stats_guard = stats.GetLock();
-	stats.DestroyTableSample(*stats_guard);
-
-	return delete_count;
-}
-
-//===--------------------------------------------------------------------===//
-// Update
-//===--------------------------------------------------------------------===//
-void RowGroupCollection::Update(TransactionData transaction, row_t *ids, const vector<PhysicalIndex> &column_ids,
-                                DataChunk &updates) {
-	idx_t pos = 0;
-	do {
-		idx_t start = pos;
-		auto row_group = row_groups->GetSegment(UnsafeNumericCast<idx_t>(ids[pos]));
-		row_t base_id =
-		    UnsafeNumericCast<row_t>(row_group->start + ((UnsafeNumericCast<idx_t>(ids[pos]) - row_group->start) /
-		                                                 STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE));
-		auto max_id = MinValue<row_t>(base_id + STANDARD_VECTOR_SIZE,
-		                              UnsafeNumericCast<row_t>(row_group->start + row_group->count));
-		for (pos++; pos < updates.size(); pos++) {
-			D_ASSERT(ids[pos] >= 0);
-			// check if this id still belongs to this vector in this row group
-			if (ids[pos] < base_id) {
-				// id is before vector start -> it does not
-				break;
-			}
-			if (ids[pos] >= max_id) {
-				// id is after the maximum id in this vector -> it does not
-				break;
-			}
-		}
-		row_group->Update(transaction, updates, ids, start, pos - start, column_ids);
-
-		auto l = stats.GetLock();
-		for (idx_t i = 0; i < column_ids.size(); i++) {
-			auto column_id = column_ids[i];
-			stats.MergeStats(*l, column_id.index, *row_group->GetStatistics(column_id.index));
-		}
-	} while (pos < updates.size());
-	// on update destroy the sample
-	auto stats_guard = stats.GetLock();
-	stats.DestroyTableSample(*stats_guard);
-}
-
-void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count) {
-	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
-
-	// initialize the fetch state
-	// FIXME: we do not need to fetch all columns, only the columns required by the indices!
-	TableScanState state;
-	vector<StorageIndex> column_ids;
-	column_ids.reserve(types.size());
-	for (idx_t i = 0; i < types.size(); i++) {
-		column_ids.emplace_back(i);
-	}
-	state.Initialize(std::move(column_ids));
-	state.table_state.max_row = row_start + total_rows;
-
-	// initialize the fetch chunk
-	DataChunk result;
-	result.Initialize(GetAllocator(), types);
-
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	// now iterate over the row ids
-	for (idx_t r = 0; r < count;) {
-		result.Reset();
-		// figure out which row_group to fetch from
-		auto row_id = row_ids[r];
-		auto row_group = row_groups->GetSegment(UnsafeNumericCast<idx_t>(row_id));
-		auto row_group_vector_idx = (UnsafeNumericCast<idx_t>(row_id) - row_group->start) / STANDARD_VECTOR_SIZE;
-		auto base_row_id = row_group_vector_idx * STANDARD_VECTOR_SIZE + row_group->start;
-
-		// fetch the current vector
-		state.table_state.Initialize(GetTypes());
-		row_group->InitializeScanWithOffset(state.table_state, row_group_vector_idx);
-		row_group->ScanCommitted(state.table_state, result, TableScanType::TABLE_SCAN_COMMITTED_ROWS);
-		result.Verify();
-
-		// check for any remaining row ids if they also fall into this vector
-		// we try to fetch handle as many rows as possible at the same time
-		idx_t sel_count = 0;
-		for (; r < count; r++) {
-			idx_t current_row = idx_t(row_ids[r]);
-			if (current_row < base_row_id || current_row >= base_row_id + result.size()) {
-				// this row-id does not fall into the current chunk - break
-				break;
-			}
-			auto row_in_vector = current_row - base_row_id;
-			D_ASSERT(row_in_vector < result.size());
-			sel.set_index(sel_count++, row_in_vector);
-		}
-		D_ASSERT(sel_count > 0);
-		// slice the vector with all rows that are present in this vector and erase from the index
-		result.Slice(sel, sel_count);
-
-		indexes.Scan([&](Index &index) {
-			if (index.IsBound()) {
-				index.Cast<BoundIndex>().Delete(result, row_identifiers);
-			} else {
-				throw MissingExtensionException(
-				    "Cannot delete from index '%s', unknown index type '%s'. You need to load the "
-				    "extension that provides this index type before table '%s' can be modified.",
-				    index.GetIndexName(), index.GetIndexType(), info->GetTableName());
-			}
-			return false;
-		});
-	}
-}
-
-void RowGroupCollection::UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
-                                      DataChunk &updates) {
-	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
-	if (first_id >= MAX_ROW_ID) {
-		throw NotImplementedException("Cannot update a column-path on transaction local data");
-	}
-	// find the row_group this id belongs to
-	auto primary_column_idx = column_path[0];
-	auto row_group = row_groups->GetSegment(UnsafeNumericCast<idx_t>(first_id));
-	row_group->UpdateColumn(transaction, updates, row_ids, column_path);
-
-	auto lock = stats.GetLock();
-	row_group->MergeIntoStatistics(primary_column_idx, stats.GetStats(*lock, primary_column_idx).Statistics());
-}
-
-//===--------------------------------------------------------------------===//
-// Checkpoint State
-//===--------------------------------------------------------------------===//
-struct CollectionCheckpointState {
-	CollectionCheckpointState(RowGroupCollection &collection, TableDataWriter &writer,
-	                          vector<SegmentNode<RowGroup>> &segments, TableStatistics &global_stats)
-	    : collection(collection), writer(writer), executor(writer.GetScheduler()), segments(segments),
-	      global_stats(global_stats) {
-		writers.resize(segments.size());
-		write_data.resize(segments.size());
-	}
-
-	RowGroupCollection &collection;
-	TableDataWriter &writer;
-	TaskExecutor executor;
-	vector<SegmentNode<RowGroup>> &segments;
-	vector<unique_ptr<RowGroupWriter>> writers;
-	vector<RowGroupWriteData> write_data;
-	TableStatistics &global_stats;
-	mutex write_lock;
-};
-
-class BaseCheckpointTask : public BaseExecutorTask {
-public:
-	explicit BaseCheckpointTask(CollectionCheckpointState &checkpoint_state)
-	    : BaseExecutorTask(checkpoint_state.executor), checkpoint_state(checkpoint_state) {
-	}
-
-protected:
-	CollectionCheckpointState &checkpoint_state;
-};
-
-class CheckpointTask : public BaseCheckpointTask {
-public:
-	CheckpointTask(CollectionCheckpointState &checkpoint_state, idx_t index)
-	    : BaseCheckpointTask(checkpoint_state), index(index) {
-	}
-
-	void ExecuteTask() override {
-		auto &entry = checkpoint_state.segments[index];
-		auto &row_group = *entry.node;
-		checkpoint_state.writers[index] = checkpoint_state.writer.GetRowGroupWriter(*entry.node);
-		checkpoint_state.write_data[index] = row_group.WriteToDisk(*checkpoint_state.writers[index]);
-	}
-
-private:
-	idx_t index;
-};
-
-//===--------------------------------------------------------------------===//
-// Vacuum
-//===--------------------------------------------------------------------===//
-struct VacuumState {
-	bool can_vacuum_deletes = false;
-	idx_t row_start = 0;
-	idx_t next_vacuum_idx = 0;
-	vector<idx_t> row_group_counts;
-};
-
-class VacuumTask : public BaseCheckpointTask {
-public:
-	VacuumTask(CollectionCheckpointState &checkpoint_state, VacuumState &vacuum_state, idx_t segment_idx,
-	           idx_t merge_count, idx_t target_count, idx_t merge_rows, idx_t row_start)
-	    : BaseCheckpointTask(checkpoint_state), vacuum_state(vacuum_state), segment_idx(segment_idx),
-	      merge_count(merge_count), target_count(target_count), merge_rows(merge_rows), row_start(row_start) {
-	}
-
-	void ExecuteTask() override {
-		auto &collection = checkpoint_state.collection;
-		const idx_t row_group_size = collection.GetRowGroupSize();
-		auto &types = collection.GetTypes();
-		// create the new set of target row groups (initially empty)
-		vector<unique_ptr<RowGroup>> new_row_groups;
-		vector<idx_t> append_counts;
-		idx_t row_group_rows = merge_rows;
-		idx_t start = row_start;
-		for (idx_t target_idx = 0; target_idx < target_count; target_idx++) {
-			idx_t current_row_group_rows = MinValue<idx_t>(row_group_rows, row_group_size);
-			auto new_row_group = make_uniq<RowGroup>(collection, start, current_row_group_rows);
-			new_row_group->InitializeEmpty(types);
-			new_row_groups.push_back(std::move(new_row_group));
-			append_counts.push_back(0);
-
-			row_group_rows -= current_row_group_rows;
-			start += current_row_group_rows;
-		}
-
-		DataChunk scan_chunk;
-		scan_chunk.Initialize(Allocator::DefaultAllocator(), types);
-
-		vector<StorageIndex> column_ids;
-		for (idx_t c = 0; c < types.size(); c++) {
-			column_ids.emplace_back(c);
-		}
-
-		idx_t current_append_idx = 0;
-
-		// fill the new row group with the merged rows
-		TableAppendState append_state;
-		new_row_groups[current_append_idx]->InitializeAppend(append_state.row_group_append_state);
-
-		TableScanState scan_state;
-		scan_state.Initialize(column_ids);
-		scan_state.table_state.Initialize(types);
-		scan_state.table_state.max_row = idx_t(-1);
-		idx_t merged_groups = 0;
-		idx_t total_row_groups = vacuum_state.row_group_counts.size();
-		for (idx_t c_idx = segment_idx; merged_groups < merge_count && c_idx < total_row_groups; c_idx++) {
-			if (vacuum_state.row_group_counts[c_idx] == 0) {
-				continue;
-			}
-			merged_groups++;
-
-			auto &current_row_group = *checkpoint_state.segments[c_idx].node;
-
-			current_row_group.InitializeScan(scan_state.table_state);
-			while (true) {
-				scan_chunk.Reset();
-
-				current_row_group.ScanCommitted(scan_state.table_state, scan_chunk,
-				                                TableScanType::TABLE_SCAN_LATEST_COMMITTED_ROWS);
-				if (scan_chunk.size() == 0) {
-					break;
-				}
-				scan_chunk.Flatten();
-				idx_t remaining = scan_chunk.size();
-				while (remaining > 0) {
-					idx_t append_count = MinValue<idx_t>(remaining, row_group_size - append_counts[current_append_idx]);
-					new_row_groups[current_append_idx]->Append(append_state.row_group_append_state, scan_chunk,
-					                                           append_count);
-					append_counts[current_append_idx] += append_count;
-					remaining -= append_count;
-					const bool row_group_full = append_counts[current_append_idx] == row_group_size;
-					const bool last_row_group = current_append_idx + 1 >= new_row_groups.size();
-					if (remaining > 0 || (row_group_full && !last_row_group)) {
-						// move to the next row group
-						current_append_idx++;
-						new_row_groups[current_append_idx]->InitializeAppend(append_state.row_group_append_state);
-						// slice chunk for the next append
-						scan_chunk.Slice(append_count, remaining);
-					}
-				}
-			}
-			// drop the row group after merging
-			current_row_group.CommitDrop();
-			checkpoint_state.segments[c_idx].node.reset();
-		}
-		idx_t total_append_count = 0;
-		for (idx_t target_idx = 0; target_idx < target_count; target_idx++) {
-			auto &row_group = new_row_groups[target_idx];
-			row_group->Verify();
-
-			// assign the new row group to the current segment
-			checkpoint_state.segments[segment_idx + target_idx].node = std::move(row_group);
-			total_append_count += append_counts[target_idx];
-		}
-		if (total_append_count != merge_rows) {
-			throw InternalException("Mismatch in row group count vs verify count in RowGroupCollection::Checkpoint");
-		}
-		// merging is complete - execute checkpoint tasks of the target row groups
-		for (idx_t i = 0; i < target_count; i++) {
-			auto checkpoint_task = collection.GetCheckpointTask(checkpoint_state, segment_idx + i);
-			checkpoint_task->ExecuteTask();
-		}
-	}
-
-private:
-	VacuumState &vacuum_state;
-	idx_t segment_idx;
-	idx_t merge_count;
-	idx_t target_count;
-	idx_t merge_rows;
-	idx_t row_start;
-};
-
-void RowGroupCollection::InitializeVacuumState(CollectionCheckpointState &checkpoint_state, VacuumState &state,
-                                               vector<SegmentNode<RowGroup>> &segments) {
-	bool is_full_checkpoint = checkpoint_state.writer.GetCheckpointType() == CheckpointType::FULL_CHECKPOINT;
-	// currently we can only vacuum deletes if we are doing a full checkpoint and there are no indexes
-	state.can_vacuum_deletes = info->GetIndexes().Empty() && is_full_checkpoint;
-	if (!state.can_vacuum_deletes) {
-		return;
-	}
-	// obtain the set of committed row counts for each row group
-	state.row_group_counts.reserve(segments.size());
-	for (auto &entry : segments) {
-		auto &row_group = *entry.node;
-		auto row_group_count = row_group.GetCommittedRowCount();
-		if (row_group_count == 0) {
-			// empty row group - we can drop it entirely
-			row_group.CommitDrop();
-			entry.node.reset();
-		}
-		state.row_group_counts.push_back(row_group_count);
-	}
-}
-
-bool RowGroupCollection::ScheduleVacuumTasks(CollectionCheckpointState &checkpoint_state, VacuumState &state,
-                                             idx_t segment_idx, bool schedule_vacuum) {
-	static constexpr const idx_t MAX_MERGE_COUNT = 3;
-
-	if (!state.can_vacuum_deletes) {
-		// we cannot vacuum deletes - cannot vacuum
-		return false;
-	}
-	if (segment_idx < state.next_vacuum_idx) {
-		// this segment is being vacuumed by a previously scheduled task
-		return true;
-	}
-	if (state.row_group_counts[segment_idx] == 0) {
-		// segment was already dropped - skip
-		D_ASSERT(!checkpoint_state.segments[segment_idx].node);
-		return false;
-	}
-	if (!schedule_vacuum) {
-		return false;
-	}
-	idx_t merge_rows;
-	idx_t next_idx = 0;
-	idx_t merge_count;
-	idx_t target_count;
-	bool perform_merge = false;
-	// check if we can merge row groups adjacent to the current segment_idx
-	// we try merging row groups into batches of 1-3 row groups
-	// our goal is to reduce the amount of row groups
-	// hence we target_count should be less than merge_count for a marge to be worth it
-	// we greedily prefer to merge to the lowest target_count
-	// i.e. we prefer to merge 2 row groups into 1, than 3 row groups into 2
-	const idx_t row_group_size = GetRowGroupSize();
-	for (target_count = 1; target_count <= MAX_MERGE_COUNT; target_count++) {
-		auto total_target_size = target_count * row_group_size;
-		merge_count = 0;
-		merge_rows = 0;
-		for (next_idx = segment_idx; next_idx < checkpoint_state.segments.size(); next_idx++) {
-			if (state.row_group_counts[next_idx] == 0) {
-				continue;
-			}
-			if (merge_rows + state.row_group_counts[next_idx] > total_target_size) {
-				// does not fit
-				break;
-			}
-			// we can merge this row group together with the other row group
-			merge_rows += state.row_group_counts[next_idx];
-			merge_count++;
-		}
-		if (target_count < merge_count) {
-			// we can reduce "merge_count" row groups to "target_count"
-			// perform the merge at this level
-			perform_merge = true;
-			break;
-		}
-	}
-	if (!perform_merge) {
-		return false;
-	}
-	// schedule the vacuum task
-	auto vacuum_task = make_uniq<VacuumTask>(checkpoint_state, state, segment_idx, merge_count, target_count,
-	                                         merge_rows, state.row_start);
-	checkpoint_state.executor.ScheduleTask(std::move(vacuum_task));
-	// skip vacuuming by the row groups we have merged
-	state.next_vacuum_idx = next_idx;
-	state.row_start += merge_rows;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Checkpoint
-//===--------------------------------------------------------------------===//
-unique_ptr<CheckpointTask> RowGroupCollection::GetCheckpointTask(CollectionCheckpointState &checkpoint_state,
-                                                                 idx_t segment_idx) {
-	return make_uniq<CheckpointTask>(checkpoint_state, segment_idx);
-}
-
-void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &global_stats) {
-	auto l = row_groups->Lock();
-	auto segments = row_groups->MoveSegments(l);
-
-	CollectionCheckpointState checkpoint_state(*this, writer, segments, global_stats);
-
-	VacuumState vacuum_state;
-	InitializeVacuumState(checkpoint_state, vacuum_state, segments);
-
-	try {
-		// schedule tasks
-		idx_t total_vacuum_tasks = 0;
-		auto &config = DBConfig::GetConfig(writer.GetDatabase());
-
-		for (idx_t segment_idx = 0; segment_idx < segments.size(); segment_idx++) {
-			auto &entry = segments[segment_idx];
-			auto vacuum_tasks = ScheduleVacuumTasks(checkpoint_state, vacuum_state, segment_idx,
-			                                        total_vacuum_tasks < config.options.max_vacuum_tasks);
-			if (vacuum_tasks) {
-				// vacuum tasks were scheduled - don't schedule a checkpoint task yet
-				total_vacuum_tasks++;
-				continue;
-			}
-			if (!entry.node) {
-				// row group was vacuumed/dropped - skip
-				continue;
-			}
-			// schedule a checkpoint task for this row group
-			entry.node->MoveToCollection(*this, vacuum_state.row_start);
-			auto checkpoint_task = GetCheckpointTask(checkpoint_state, segment_idx);
-			checkpoint_state.executor.ScheduleTask(std::move(checkpoint_task));
-			vacuum_state.row_start += entry.node->count;
-		}
-	} catch (const std::exception &e) {
-		ErrorData error(e);
-		checkpoint_state.executor.PushError(std::move(error));
-		checkpoint_state.executor.WorkOnTasks(); // ensure all tasks have completed first before rethrowing
-		throw;
-	}
-	// all tasks have been successfully scheduled - execute tasks until we are done
-	checkpoint_state.executor.WorkOnTasks();
-
-	// no errors - finalize the row groups
-	idx_t new_total_rows = 0;
-	for (idx_t segment_idx = 0; segment_idx < segments.size(); segment_idx++) {
-		auto &entry = segments[segment_idx];
-		if (!entry.node) {
-			// row group was vacuumed/dropped - skip
-			continue;
-		}
-		auto &row_group = *entry.node;
-		auto row_group_writer = std::move(checkpoint_state.writers[segment_idx]);
-		if (!row_group_writer) {
-			throw InternalException("Missing row group writer for index %llu", segment_idx);
-		}
-		auto pointer =
-		    row_group.Checkpoint(std::move(checkpoint_state.write_data[segment_idx]), *row_group_writer, global_stats);
-		writer.AddRowGroup(std::move(pointer), std::move(row_group_writer));
-		row_groups->AppendSegment(l, std::move(entry.node));
-		new_total_rows += row_group.count;
-	}
-	total_rows = new_total_rows;
-}
-
-//===--------------------------------------------------------------------===//
-// CommitDrop
-//===--------------------------------------------------------------------===//
-void RowGroupCollection::CommitDropColumn(idx_t index) {
-	for (auto &row_group : row_groups->Segments()) {
-		row_group.CommitDropColumn(index);
-	}
-}
-
-void RowGroupCollection::CommitDropTable() {
-	for (auto &row_group : row_groups->Segments()) {
-		row_group.CommitDrop();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// GetPartitionStats
-//===--------------------------------------------------------------------===//
-vector<PartitionStatistics> RowGroupCollection::GetPartitionStats() const {
-	vector<PartitionStatistics> result;
-	for (auto &row_group : row_groups->Segments()) {
-		result.push_back(row_group.GetPartitionStats());
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// GetColumnSegmentInfo
-//===--------------------------------------------------------------------===//
-vector<ColumnSegmentInfo> RowGroupCollection::GetColumnSegmentInfo() {
-	vector<ColumnSegmentInfo> result;
-	for (auto &row_group : row_groups->Segments()) {
-		row_group.GetColumnSegmentInfo(row_group.index, result);
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Alter
-//===--------------------------------------------------------------------===//
-shared_ptr<RowGroupCollection> RowGroupCollection::AddColumn(ClientContext &context, ColumnDefinition &new_column,
-                                                             ExpressionExecutor &default_executor) {
-	idx_t new_column_idx = types.size();
-	auto new_types = types;
-	new_types.push_back(new_column.GetType());
-	auto result = make_shared_ptr<RowGroupCollection>(info, block_manager, std::move(new_types), row_start,
-	                                                  total_rows.load(), row_group_size);
-
-	DataChunk dummy_chunk;
-	Vector default_vector(new_column.GetType());
-
-	result->stats.InitializeAddColumn(stats, new_column.GetType());
-	auto lock = result->stats.GetLock();
-	auto &new_column_stats = result->stats.GetStats(*lock, new_column_idx);
-
-	// fill the column with its DEFAULT value, or NULL if none is specified
-	auto new_stats = make_uniq<SegmentStatistics>(new_column.GetType());
-	for (auto &current_row_group : row_groups->Segments()) {
-		auto new_row_group = current_row_group.AddColumn(*result, new_column, default_executor, default_vector);
-		// merge in the statistics
-		new_row_group->MergeIntoStatistics(new_column_idx, new_column_stats.Statistics());
-
-		result->row_groups->AppendSegment(std::move(new_row_group));
-	}
-	// When adding a column destroy the sample
-	stats.DestroyTableSample(*lock);
-
-	return result;
-}
-
-shared_ptr<RowGroupCollection> RowGroupCollection::RemoveColumn(idx_t col_idx) {
-	D_ASSERT(col_idx < types.size());
-	auto new_types = types;
-	new_types.erase_at(col_idx);
-
-	auto result = make_shared_ptr<RowGroupCollection>(info, block_manager, std::move(new_types), row_start,
-	                                                  total_rows.load(), row_group_size);
-	result->stats.InitializeRemoveColumn(stats, col_idx);
-
-	auto result_lock = result->stats.GetLock();
-	result->stats.DestroyTableSample(*result_lock);
-
-	for (auto &current_row_group : row_groups->Segments()) {
-		auto new_row_group = current_row_group.RemoveColumn(*result, col_idx);
-		result->row_groups->AppendSegment(std::move(new_row_group));
-	}
-	return result;
-}
-
-shared_ptr<RowGroupCollection> RowGroupCollection::AlterType(ClientContext &context, idx_t changed_idx,
-                                                             const LogicalType &target_type,
-                                                             vector<StorageIndex> bound_columns,
-                                                             Expression &cast_expr) {
-	D_ASSERT(changed_idx < types.size());
-	auto new_types = types;
-	new_types[changed_idx] = target_type;
-
-	auto result = make_shared_ptr<RowGroupCollection>(info, block_manager, std::move(new_types), row_start,
-	                                                  total_rows.load(), row_group_size);
-	result->stats.InitializeAlterType(stats, changed_idx, target_type);
-
-	vector<LogicalType> scan_types;
-	for (idx_t i = 0; i < bound_columns.size(); i++) {
-		if (bound_columns[i].IsRowIdColumn()) {
-			scan_types.emplace_back(LogicalType::ROW_TYPE);
-		} else {
-			scan_types.push_back(types[bound_columns[i].GetPrimaryIndex()]);
-		}
-	}
-	DataChunk scan_chunk;
-	scan_chunk.Initialize(GetAllocator(), scan_types);
-
-	ExpressionExecutor executor(context);
-	executor.AddExpression(cast_expr);
-
-	TableScanState scan_state;
-	scan_state.Initialize(bound_columns);
-	scan_state.table_state.max_row = row_start + total_rows;
-
-	// now alter the type of the column within all of the row_groups individually
-	auto lock = result->stats.GetLock();
-	auto &changed_stats = result->stats.GetStats(*lock, changed_idx);
-	for (auto &current_row_group : row_groups->Segments()) {
-		auto new_row_group = current_row_group.AlterType(*result, target_type, changed_idx, executor,
-		                                                 scan_state.table_state, scan_chunk);
-		new_row_group->MergeIntoStatistics(changed_idx, changed_stats.Statistics());
-		result->row_groups->AppendSegment(std::move(new_row_group));
-	}
-	return result;
-}
-
-void RowGroupCollection::VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint) {
-	if (total_rows == 0) {
-		return;
-	}
-
-	// Scan the original table for NULL values.
-	auto &not_null_constraint = constraint.Cast<BoundNotNullConstraint>();
-	vector<LogicalType> scan_types;
-	auto physical_index = not_null_constraint.index.index;
-	D_ASSERT(physical_index < types.size());
-
-	scan_types.push_back(types[physical_index]);
-	DataChunk scan_chunk;
-	scan_chunk.Initialize(GetAllocator(), scan_types);
-
-	vector<StorageIndex> column_ids;
-	column_ids.emplace_back(physical_index);
-
-	// Use SCAN_COMMITTED to scan the latest data.
-	CreateIndexScanState state;
-	auto scan_type = TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED;
-	state.Initialize(column_ids, nullptr);
-	InitializeScan(state.table_state, column_ids, nullptr);
-
-	InitializeCreateIndexScan(state);
-
-	while (true) {
-		scan_chunk.Reset();
-		state.table_state.ScanCommitted(scan_chunk, state.segment_lock, scan_type);
-		if (scan_chunk.size() == 0) {
-			break;
-		}
-
-		// Verify the NOT NULL constraint.
-		if (VectorOperations::HasNull(scan_chunk.data[0], scan_chunk.size())) {
-			auto name = parent.Columns()[physical_index].GetName();
-			throw ConstraintException("NOT NULL constraint failed: %s.%s", info->GetTableName(), name);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Statistics
-//===---------------------------------------------------------------r-----===//
-void RowGroupCollection::CopyStats(TableStatistics &other_stats) {
-	stats.CopyStats(other_stats);
-}
-
-unique_ptr<BaseStatistics> RowGroupCollection::CopyStats(column_t column_id) {
-	return stats.CopyStats(column_id);
-}
-
-unique_ptr<BlockingSample> RowGroupCollection::GetSample() {
-	auto lock = stats.GetLock();
-	auto &sample = stats.GetTableSampleRef(*lock);
-	if (!sample.destroyed) {
-		D_ASSERT(sample.type == SampleType::RESERVOIR_SAMPLE);
-		auto ret = sample.Copy();
-		ret->Cast<ReservoirSample>().EvictOverBudgetSamples();
-		return ret;
-	}
-	return nullptr;
-}
-
-void RowGroupCollection::SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats) {
-	D_ASSERT(column_id != COLUMN_IDENTIFIER_ROW_ID);
-	auto stats_lock = stats.GetLock();
-	stats.GetStats(*stats_lock, column_id).SetDistinct(std::move(distinct_stats));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/row_version_manager.cpp b/src/duckdb/src/storage/table/row_version_manager.cpp
deleted file mode 100644
index a3b47a56e..000000000
--- a/src/duckdb/src/storage/table/row_version_manager.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-#include "duckdb/storage/table/row_version_manager.hpp"
-#include "duckdb/transaction/transaction_data.hpp"
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
-#include "duckdb/common/pair.hpp"
-
-namespace duckdb {
-
-RowVersionManager::RowVersionManager(idx_t start) noexcept : start(start), has_changes(false) {
-}
-
-void RowVersionManager::SetStart(idx_t new_start) {
-	lock_guard<mutex> l(version_lock);
-	this->start = new_start;
-	idx_t current_start = start;
-	for (auto &info : vector_info) {
-		if (info) {
-			info->start = current_start;
-		}
-		current_start += STANDARD_VECTOR_SIZE;
-	}
-}
-
-idx_t RowVersionManager::GetCommittedDeletedCount(idx_t count) {
-	lock_guard<mutex> l(version_lock);
-	idx_t deleted_count = 0;
-	for (idx_t r = 0, i = 0; r < count; r += STANDARD_VECTOR_SIZE, i++) {
-		if (i >= vector_info.size() || !vector_info[i]) {
-			continue;
-		}
-		idx_t max_count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, count - r);
-		if (max_count == 0) {
-			break;
-		}
-		deleted_count += vector_info[i]->GetCommittedDeletedCount(max_count);
-	}
-	return deleted_count;
-}
-
-optional_ptr<ChunkInfo> RowVersionManager::GetChunkInfo(idx_t vector_idx) {
-	if (vector_idx >= vector_info.size()) {
-		return nullptr;
-	}
-	return vector_info[vector_idx].get();
-}
-
-idx_t RowVersionManager::GetSelVector(TransactionData transaction, idx_t vector_idx, SelectionVector &sel_vector,
-                                      idx_t max_count) {
-	lock_guard<mutex> l(version_lock);
-	auto chunk_info = GetChunkInfo(vector_idx);
-	if (!chunk_info) {
-		return max_count;
-	}
-	return chunk_info->GetSelVector(transaction, sel_vector, max_count);
-}
-
-idx_t RowVersionManager::GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
-                                               SelectionVector &sel_vector, idx_t max_count) {
-	lock_guard<mutex> l(version_lock);
-	auto info = GetChunkInfo(vector_idx);
-	if (!info) {
-		return max_count;
-	}
-	return info->GetCommittedSelVector(start_time, transaction_id, sel_vector, max_count);
-}
-
-bool RowVersionManager::Fetch(TransactionData transaction, idx_t row) {
-	lock_guard<mutex> lock(version_lock);
-	idx_t vector_index = row / STANDARD_VECTOR_SIZE;
-	auto info = GetChunkInfo(vector_index);
-	if (!info) {
-		return true;
-	}
-	return info->Fetch(transaction, UnsafeNumericCast<row_t>(row - vector_index * STANDARD_VECTOR_SIZE));
-}
-
-void RowVersionManager::FillVectorInfo(idx_t vector_idx) {
-	if (vector_idx < vector_info.size()) {
-		return;
-	}
-	vector_info.reserve(vector_idx + 1);
-	for (idx_t i = vector_info.size(); i <= vector_idx; i++) {
-		vector_info.emplace_back();
-	}
-}
-
-void RowVersionManager::AppendVersionInfo(TransactionData transaction, idx_t count, idx_t row_group_start,
-                                          idx_t row_group_end) {
-	lock_guard<mutex> lock(version_lock);
-	has_changes = true;
-	idx_t start_vector_idx = row_group_start / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_idx = (row_group_end - 1) / STANDARD_VECTOR_SIZE;
-
-	// fill-up vector_info
-	FillVectorInfo(end_vector_idx);
-
-	// insert the version info nodes
-	for (idx_t vector_idx = start_vector_idx; vector_idx <= end_vector_idx; vector_idx++) {
-		idx_t vector_start =
-		    vector_idx == start_vector_idx ? row_group_start - start_vector_idx * STANDARD_VECTOR_SIZE : 0;
-		idx_t vector_end =
-		    vector_idx == end_vector_idx ? row_group_end - end_vector_idx * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-		if (vector_start == 0 && vector_end == STANDARD_VECTOR_SIZE) {
-			// entire vector is encapsulated by append: append a single constant
-			auto constant_info = make_uniq<ChunkConstantInfo>(start + vector_idx * STANDARD_VECTOR_SIZE);
-			constant_info->insert_id = transaction.transaction_id;
-			constant_info->delete_id = NOT_DELETED_ID;
-			vector_info[vector_idx] = std::move(constant_info);
-		} else {
-			// part of a vector is encapsulated: append to that part
-			optional_ptr<ChunkVectorInfo> new_info;
-			if (!vector_info[vector_idx]) {
-				// first time appending to this vector: create new info
-				auto insert_info = make_uniq<ChunkVectorInfo>(start + vector_idx * STANDARD_VECTOR_SIZE);
-				new_info = insert_info.get();
-				vector_info[vector_idx] = std::move(insert_info);
-			} else if (vector_info[vector_idx]->type == ChunkInfoType::VECTOR_INFO) {
-				// use existing vector
-				new_info = &vector_info[vector_idx]->Cast<ChunkVectorInfo>();
-			} else {
-				throw InternalException("Error in RowVersionManager::AppendVersionInfo - expected either a "
-				                        "ChunkVectorInfo or no version info");
-			}
-			new_info->Append(vector_start, vector_end, transaction.transaction_id);
-		}
-	}
-}
-
-void RowVersionManager::CommitAppend(transaction_t commit_id, idx_t row_group_start, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	idx_t row_group_end = row_group_start + count;
-
-	lock_guard<mutex> lock(version_lock);
-	idx_t start_vector_idx = row_group_start / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_idx = (row_group_end - 1) / STANDARD_VECTOR_SIZE;
-	for (idx_t vector_idx = start_vector_idx; vector_idx <= end_vector_idx; vector_idx++) {
-		idx_t vstart = vector_idx == start_vector_idx ? row_group_start - start_vector_idx * STANDARD_VECTOR_SIZE : 0;
-		idx_t vend =
-		    vector_idx == end_vector_idx ? row_group_end - end_vector_idx * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-		auto &info = *vector_info[vector_idx];
-		info.CommitAppend(commit_id, vstart, vend);
-	}
-}
-
-void RowVersionManager::CleanupAppend(transaction_t lowest_active_transaction, idx_t row_group_start, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	idx_t row_group_end = row_group_start + count;
-
-	lock_guard<mutex> lock(version_lock);
-	idx_t start_vector_idx = row_group_start / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_idx = (row_group_end - 1) / STANDARD_VECTOR_SIZE;
-	for (idx_t vector_idx = start_vector_idx; vector_idx <= end_vector_idx; vector_idx++) {
-		idx_t vcount =
-		    vector_idx == end_vector_idx ? row_group_end - end_vector_idx * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-		if (vcount != STANDARD_VECTOR_SIZE) {
-			// not written fully - skip
-			continue;
-		}
-		if (vector_idx >= vector_info.size() || !vector_info[vector_idx]) {
-			// already vacuumed - skip
-			continue;
-		}
-		auto &info = *vector_info[vector_idx];
-		// if we wrote the entire chunk info try to compress it
-		unique_ptr<ChunkInfo> new_info;
-		auto cleanup = info.Cleanup(lowest_active_transaction, new_info);
-		if (cleanup) {
-			vector_info[vector_idx] = std::move(new_info);
-		}
-	}
-}
-
-void RowVersionManager::RevertAppend(idx_t start_row) {
-	lock_guard<mutex> lock(version_lock);
-	idx_t start_vector_idx = (start_row + (STANDARD_VECTOR_SIZE - 1)) / STANDARD_VECTOR_SIZE;
-	for (idx_t vector_idx = start_vector_idx; vector_idx < vector_info.size(); vector_idx++) {
-		vector_info[vector_idx].reset();
-	}
-}
-
-ChunkVectorInfo &RowVersionManager::GetVectorInfo(idx_t vector_idx) {
-	FillVectorInfo(vector_idx);
-
-	if (!vector_info[vector_idx]) {
-		// no info yet: create it
-		vector_info[vector_idx] = make_uniq<ChunkVectorInfo>(start + vector_idx * STANDARD_VECTOR_SIZE);
-	} else if (vector_info[vector_idx]->type == ChunkInfoType::CONSTANT_INFO) {
-		auto &constant = vector_info[vector_idx]->Cast<ChunkConstantInfo>();
-		// info exists but it's a constant info: convert to a vector info
-		auto new_info = make_uniq<ChunkVectorInfo>(start + vector_idx * STANDARD_VECTOR_SIZE);
-		new_info->insert_id = constant.insert_id;
-		for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-			new_info->inserted[i] = constant.insert_id;
-		}
-		vector_info[vector_idx] = std::move(new_info);
-	}
-	D_ASSERT(vector_info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
-	return vector_info[vector_idx]->Cast<ChunkVectorInfo>();
-}
-
-idx_t RowVersionManager::DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count) {
-	lock_guard<mutex> lock(version_lock);
-	has_changes = true;
-	return GetVectorInfo(vector_idx).Delete(transaction_id, rows, count);
-}
-
-void RowVersionManager::CommitDelete(idx_t vector_idx, transaction_t commit_id, const DeleteInfo &info) {
-	lock_guard<mutex> lock(version_lock);
-	has_changes = true;
-	GetVectorInfo(vector_idx).CommitDelete(commit_id, info);
-}
-
-vector<MetaBlockPointer> RowVersionManager::Checkpoint(MetadataManager &manager) {
-	if (!has_changes && !storage_pointers.empty()) {
-		// the row version manager already exists on disk and no changes were made
-		// we can write the current pointer as-is
-		// ensure the blocks we are pointing to are not marked as free
-		manager.ClearModifiedBlocks(storage_pointers);
-		// return the root pointer
-		return storage_pointers;
-	}
-	// first count how many ChunkInfo's we need to deserialize
-	vector<pair<idx_t, reference<ChunkInfo>>> to_serialize;
-	for (idx_t vector_idx = 0; vector_idx < vector_info.size(); vector_idx++) {
-		auto chunk_info = vector_info[vector_idx].get();
-		if (!chunk_info) {
-			continue;
-		}
-		if (!chunk_info->HasDeletes()) {
-			continue;
-		}
-		to_serialize.emplace_back(vector_idx, *chunk_info);
-	}
-	if (to_serialize.empty()) {
-		return vector<MetaBlockPointer>();
-	}
-
-	storage_pointers.clear();
-
-	MetadataWriter writer(manager, &storage_pointers);
-	// now serialize the actual version information
-	writer.Write<idx_t>(to_serialize.size());
-	for (auto &entry : to_serialize) {
-		auto &vector_idx = entry.first;
-		auto &chunk_info = entry.second.get();
-		writer.Write<idx_t>(vector_idx);
-		chunk_info.Write(writer);
-	}
-	writer.Flush();
-
-	has_changes = false;
-	return storage_pointers;
-}
-
-shared_ptr<RowVersionManager> RowVersionManager::Deserialize(MetaBlockPointer delete_pointer, MetadataManager &manager,
-                                                             idx_t start) {
-	if (!delete_pointer.IsValid()) {
-		return nullptr;
-	}
-	auto version_info = make_shared_ptr<RowVersionManager>(start);
-	MetadataReader source(manager, delete_pointer, &version_info->storage_pointers);
-	auto chunk_count = source.Read<idx_t>();
-	D_ASSERT(chunk_count > 0);
-	for (idx_t i = 0; i < chunk_count; i++) {
-		idx_t vector_index = source.Read<idx_t>();
-		if (vector_index * STANDARD_VECTOR_SIZE >= Storage::MAX_ROW_GROUP_SIZE) {
-			throw IOException("In DeserializeDeletes, vector_index %llu is out of range for the max row group size of "
-			                  "%llu. Corrupted file?",
-			                  vector_index, Storage::MAX_ROW_GROUP_SIZE);
-		}
-
-		version_info->FillVectorInfo(vector_index);
-		version_info->vector_info[vector_index] = ChunkInfo::Read(source);
-	}
-	version_info->has_changes = false;
-	return version_info;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/scan_state.cpp b/src/duckdb/src/storage/table/scan_state.cpp
deleted file mode 100644
index adeccde91..000000000
--- a/src/duckdb/src/storage/table/scan_state.cpp
+++ /dev/null
@@ -1,238 +0,0 @@
-#include "duckdb/storage/table/scan_state.hpp"
-
-#include "duckdb/execution/adaptive_filter.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/table/row_group_collection.hpp"
-#include "duckdb/storage/table/row_group_segment_tree.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-namespace duckdb {
-
-TableScanState::TableScanState() : table_state(*this), local_state(*this) {
-}
-
-TableScanState::~TableScanState() {
-}
-
-void TableScanState::Initialize(vector<StorageIndex> column_ids_p, optional_ptr<TableFilterSet> table_filters,
-                                optional_ptr<SampleOptions> table_sampling) {
-	this->column_ids = std::move(column_ids_p);
-	if (table_filters) {
-		filters.Initialize(*table_filters, column_ids);
-	}
-	if (table_sampling) {
-		sampling_info.do_system_sample = table_sampling->method == SampleMethod::SYSTEM_SAMPLE;
-		sampling_info.sample_rate = table_sampling->sample_size.GetValue<double>() / 100.0;
-	}
-}
-
-const vector<StorageIndex> &TableScanState::GetColumnIds() {
-	D_ASSERT(!column_ids.empty());
-	return column_ids;
-}
-
-ScanFilterInfo::~ScanFilterInfo() {
-}
-
-ScanFilterInfo &TableScanState::GetFilterInfo() {
-	return filters;
-}
-
-ScanSamplingInfo &TableScanState::GetSamplingInfo() {
-	return sampling_info;
-}
-
-ScanFilter::ScanFilter(idx_t index, const vector<StorageIndex> &column_ids, TableFilter &filter)
-    : scan_column_index(index), table_column_index(column_ids[index].GetPrimaryIndex()), filter(filter),
-      always_true(false) {
-}
-
-void ScanFilterInfo::Initialize(TableFilterSet &filters, const vector<StorageIndex> &column_ids) {
-	D_ASSERT(!filters.filters.empty());
-	table_filters = &filters;
-	adaptive_filter = make_uniq<AdaptiveFilter>(filters);
-	filter_list.reserve(filters.filters.size());
-	for (auto &entry : filters.filters) {
-		filter_list.emplace_back(entry.first, column_ids, *entry.second);
-	}
-	column_has_filter.reserve(column_ids.size());
-	for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
-		bool has_filter = table_filters->filters.find(col_idx) != table_filters->filters.end();
-		column_has_filter.push_back(has_filter);
-	}
-	base_column_has_filter = column_has_filter;
-}
-
-bool ScanFilterInfo::ColumnHasFilters(idx_t column_idx) {
-	if (column_idx < column_has_filter.size()) {
-		return column_has_filter[column_idx];
-	} else {
-		return false;
-	}
-}
-
-bool ScanFilterInfo::HasFilters() const {
-	if (!table_filters) {
-		// no filters
-		return false;
-	}
-	// if we have filters - check if we need to check any of them
-	return always_true_filters < filter_list.size();
-}
-
-void ScanFilterInfo::CheckAllFilters() {
-	always_true_filters = 0;
-	// reset the "column_has_filter" bitmask to the original
-	for (idx_t col_idx = 0; col_idx < column_has_filter.size(); col_idx++) {
-		column_has_filter[col_idx] = base_column_has_filter[col_idx];
-	}
-	// set "always_true" in the individual filters to false
-	for (auto &filter : filter_list) {
-		filter.always_true = false;
-	}
-}
-
-void ScanFilterInfo::SetFilterAlwaysTrue(idx_t filter_idx) {
-	auto &filter = filter_list[filter_idx];
-	filter.always_true = true;
-	column_has_filter[filter.scan_column_index] = false;
-	always_true_filters++;
-}
-
-optional_ptr<AdaptiveFilter> ScanFilterInfo::GetAdaptiveFilter() {
-	return adaptive_filter.get();
-}
-
-AdaptiveFilterState ScanFilterInfo::BeginFilter() const {
-	if (!adaptive_filter) {
-		return AdaptiveFilterState();
-	}
-	return adaptive_filter->BeginFilter();
-}
-
-void ScanFilterInfo::EndFilter(AdaptiveFilterState state) {
-	if (!adaptive_filter) {
-		return;
-	}
-	adaptive_filter->EndFilter(state);
-}
-
-void ColumnScanState::NextInternal(idx_t count) {
-	if (!current) {
-		//! There is no column segment
-		return;
-	}
-	row_index += count;
-	while (row_index >= current->start + current->count) {
-		current = segment_tree->GetNextSegment(current);
-		initialized = false;
-		segment_checked = false;
-		if (!current) {
-			break;
-		}
-	}
-	D_ASSERT(!current || (row_index >= current->start && row_index < current->start + current->count));
-}
-
-void ColumnScanState::Next(idx_t count) {
-	NextInternal(count);
-	for (auto &child_state : child_states) {
-		child_state.Next(count);
-	}
-}
-
-const vector<StorageIndex> &CollectionScanState::GetColumnIds() {
-	return parent.GetColumnIds();
-}
-
-TableFilterSet &GetFilters();
-
-ScanFilterInfo &CollectionScanState::GetFilterInfo() {
-	return parent.GetFilterInfo();
-}
-
-ScanSamplingInfo &CollectionScanState::GetSamplingInfo() {
-	return parent.GetSamplingInfo();
-}
-
-TableScanOptions &CollectionScanState::GetOptions() {
-	return parent.options;
-}
-
-ParallelCollectionScanState::ParallelCollectionScanState()
-    : collection(nullptr), current_row_group(nullptr), processed_rows(0) {
-}
-
-CollectionScanState::CollectionScanState(TableScanState &parent_p)
-    : row_group(nullptr), vector_index(0), max_row_group_row(0), row_groups(nullptr), max_row(0), batch_index(0),
-      valid_sel(STANDARD_VECTOR_SIZE), random(-1), parent(parent_p) {
-}
-
-bool CollectionScanState::Scan(DuckTransaction &transaction, DataChunk &result) {
-	while (row_group) {
-		row_group->Scan(transaction, *this, result);
-		if (result.size() > 0) {
-			return true;
-		} else if (max_row <= row_group->start + row_group->count) {
-			row_group = nullptr;
-			return false;
-		} else {
-			do {
-				row_group = row_groups->GetNextSegment(row_group);
-				if (row_group) {
-					if (row_group->start >= max_row) {
-						row_group = nullptr;
-						break;
-					}
-					bool scan_row_group = row_group->InitializeScan(*this);
-					if (scan_row_group) {
-						// scan this row group
-						break;
-					}
-				}
-			} while (row_group);
-		}
-	}
-	return false;
-}
-
-bool CollectionScanState::ScanCommitted(DataChunk &result, SegmentLock &l, TableScanType type) {
-	while (row_group) {
-		row_group->ScanCommitted(*this, result, type);
-		if (result.size() > 0) {
-			return true;
-		} else {
-			row_group = row_groups->GetNextSegment(l, row_group);
-			if (row_group) {
-				row_group->InitializeScan(*this);
-			}
-		}
-	}
-	return false;
-}
-
-bool CollectionScanState::ScanCommitted(DataChunk &result, TableScanType type) {
-	while (row_group) {
-		row_group->ScanCommitted(*this, result, type);
-		if (result.size() > 0) {
-			return true;
-		} else {
-			row_group = row_groups->GetNextSegment(row_group);
-			if (row_group) {
-				row_group->InitializeScan(*this);
-			}
-		}
-	}
-	return false;
-}
-
-PrefetchState::~PrefetchState() {
-}
-
-void PrefetchState::AddBlock(shared_ptr<BlockHandle> block) {
-	blocks.push_back(std::move(block));
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/standard_column_data.cpp b/src/duckdb/src/storage/table/standard_column_data.cpp
deleted file mode 100644
index 6b6311c3d..000000000
--- a/src/duckdb/src/storage/table/standard_column_data.cpp
+++ /dev/null
@@ -1,298 +0,0 @@
-#include "duckdb/storage/table/standard_column_data.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/storage/table/column_data_checkpointer.hpp"
-
-namespace duckdb {
-
-StandardColumnData::StandardColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-                                       idx_t start_row, LogicalType type, optional_ptr<ColumnData> parent)
-    : ColumnData(block_manager, info, column_index, start_row, std::move(type), parent),
-      validity(block_manager, info, 0, start_row, *this) {
-}
-
-void StandardColumnData::SetStart(idx_t new_start) {
-	ColumnData::SetStart(new_start);
-	validity.SetStart(new_start);
-}
-
-ScanVectorType StandardColumnData::GetVectorScanType(ColumnScanState &state, idx_t scan_count, Vector &result) {
-	// if either the current column data, or the validity column data requires flat vectors, we scan flat vectors
-	auto scan_type = ColumnData::GetVectorScanType(state, scan_count, result);
-	if (scan_type == ScanVectorType::SCAN_FLAT_VECTOR) {
-		return ScanVectorType::SCAN_FLAT_VECTOR;
-	}
-	if (state.child_states.empty()) {
-		return scan_type;
-	}
-	return validity.GetVectorScanType(state.child_states[0], scan_count, result);
-}
-
-void StandardColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) {
-	ColumnData::InitializePrefetch(prefetch_state, scan_state, rows);
-	validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows);
-}
-
-void StandardColumnData::InitializeScan(ColumnScanState &state) {
-	ColumnData::InitializeScan(state);
-
-	// initialize the validity segment
-	D_ASSERT(state.child_states.size() == 1);
-	validity.InitializeScan(state.child_states[0]);
-}
-
-void StandardColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	ColumnData::InitializeScanWithOffset(state, row_idx);
-
-	// initialize the validity segment
-	D_ASSERT(state.child_states.size() == 1);
-	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
-}
-
-idx_t StandardColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                               idx_t target_count) {
-	D_ASSERT(state.row_index == state.child_states[0].row_index);
-	auto scan_type = GetVectorScanType(state, target_count, result);
-	auto mode = ScanVectorMode::REGULAR_SCAN;
-	auto scan_count = ScanVector(transaction, vector_index, state, result, target_count, scan_type, mode);
-	validity.ScanVector(transaction, vector_index, state.child_states[0], result, target_count, scan_type, mode);
-	return scan_count;
-}
-
-idx_t StandardColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-                                        idx_t target_count) {
-	D_ASSERT(state.row_index == state.child_states[0].row_index);
-	auto scan_count = ColumnData::ScanCommitted(vector_index, state, result, allow_updates, target_count);
-	validity.ScanCommitted(vector_index, state.child_states[0], result, allow_updates, target_count);
-	return scan_count;
-}
-
-idx_t StandardColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	auto scan_count = ColumnData::ScanCount(state, result, count);
-	validity.ScanCount(state.child_states[0], result, count);
-	return scan_count;
-}
-
-void StandardColumnData::Filter(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                                SelectionVector &sel, idx_t &count, const TableFilter &filter) {
-	// check if we can do a specialized select
-	// the compression functions need to support this
-	auto compression = GetCompressionFunction();
-	bool has_filter = compression && compression->filter;
-	auto validity_compression = validity.GetCompressionFunction();
-	bool validity_has_filter = validity_compression && validity_compression->filter;
-	auto target_count = GetVectorCount(vector_index);
-	auto scan_type = GetVectorScanType(state, target_count, result);
-	bool scan_entire_vector = scan_type == ScanVectorType::SCAN_ENTIRE_VECTOR;
-	bool verify_fetch_row = state.scan_options && state.scan_options->force_fetch_row;
-	if (!has_filter || !validity_has_filter || !scan_entire_vector || verify_fetch_row) {
-		// we are not scanning an entire vector - this can have several causes (updates, etc)
-		ColumnData::Filter(transaction, vector_index, state, result, sel, count, filter);
-		return;
-	}
-	FilterVector(state, result, target_count, sel, count, filter);
-	validity.FilterVector(state.child_states[0], result, target_count, sel, count, filter);
-}
-
-void StandardColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                                SelectionVector &sel, idx_t sel_count) {
-	// check if we can do a specialized select
-	// the compression functions need to support this
-	auto compression = GetCompressionFunction();
-	bool has_select = compression && compression->select;
-	auto validity_compression = validity.GetCompressionFunction();
-	bool validity_has_select = validity_compression && validity_compression->select;
-	auto target_count = GetVectorCount(vector_index);
-	auto scan_type = GetVectorScanType(state, target_count, result);
-	bool scan_entire_vector = scan_type == ScanVectorType::SCAN_ENTIRE_VECTOR;
-	if (!has_select || !validity_has_select || !scan_entire_vector) {
-		// we are not scanning an entire vector - this can have several causes (updates, etc)
-		ColumnData::Select(transaction, vector_index, state, result, sel, sel_count);
-		return;
-	}
-	SelectVector(state, result, target_count, sel, sel_count);
-	validity.SelectVector(state.child_states[0], result, target_count, sel, sel_count);
-}
-
-void StandardColumnData::InitializeAppend(ColumnAppendState &state) {
-	ColumnData::InitializeAppend(state);
-	ColumnAppendState child_append;
-	validity.InitializeAppend(child_append);
-	state.child_appends.push_back(std::move(child_append));
-}
-
-void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
-                                    idx_t count) {
-	ColumnData::AppendData(stats, state, vdata, count);
-	validity.AppendData(stats, state.child_appends[0], vdata, count);
-}
-
-void StandardColumnData::RevertAppend(row_t start_row) {
-	ColumnData::RevertAppend(start_row);
-
-	validity.RevertAppend(start_row);
-}
-
-idx_t StandardColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	// fetch validity mask
-	if (state.child_states.empty()) {
-		ColumnScanState child_state;
-		child_state.scan_options = state.scan_options;
-		state.child_states.push_back(std::move(child_state));
-	}
-	auto scan_count = ColumnData::Fetch(state, row_id, result);
-	validity.Fetch(state.child_states[0], row_id, result);
-	return scan_count;
-}
-
-void StandardColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                                idx_t update_count) {
-	ColumnData::Update(transaction, column_index, update_vector, row_ids, update_count);
-	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
-}
-
-void StandardColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                      Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
-	if (depth >= column_path.size()) {
-		// update this column
-		ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
-	} else {
-		// update the child column (i.e. the validity column)
-		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
-	}
-}
-
-unique_ptr<BaseStatistics> StandardColumnData::GetUpdateStatistics() {
-	auto stats = updates ? updates->GetStatistics() : nullptr;
-	auto validity_stats = validity.GetUpdateStatistics();
-	if (!stats && !validity_stats) {
-		return nullptr;
-	}
-	if (!stats) {
-		stats = BaseStatistics::CreateEmpty(type).ToUnique();
-	}
-	if (validity_stats) {
-		stats->Merge(*validity_stats);
-	}
-	return stats;
-}
-
-void StandardColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                                  idx_t result_idx) {
-	// find the segment the row belongs to
-	if (state.child_states.empty()) {
-		auto child_state = make_uniq<ColumnFetchState>();
-		state.child_states.push_back(std::move(child_state));
-	}
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-	ColumnData::FetchRow(transaction, state, row_id, result, result_idx);
-}
-
-void StandardColumnData::CommitDropColumn() {
-	ColumnData::CommitDropColumn();
-	validity.CommitDropColumn();
-}
-
-struct StandardColumnCheckpointState : public ColumnCheckpointState {
-	StandardColumnCheckpointState(RowGroup &row_group, ColumnData &column_data,
-	                              PartialBlockManager &partial_block_manager)
-	    : ColumnCheckpointState(row_group, column_data, partial_block_manager) {
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		D_ASSERT(global_stats);
-		return std::move(global_stats);
-	}
-
-	PersistentColumnData ToPersistentData() override {
-		auto data = ColumnCheckpointState::ToPersistentData();
-		data.child_columns.push_back(validity_state->ToPersistentData());
-		return data;
-	}
-};
-
-unique_ptr<ColumnCheckpointState>
-StandardColumnData::CreateCheckpointState(RowGroup &row_group, PartialBlockManager &partial_block_manager) {
-	return make_uniq<StandardColumnCheckpointState>(row_group, *this, partial_block_manager);
-}
-
-unique_ptr<ColumnCheckpointState> StandardColumnData::Checkpoint(RowGroup &row_group,
-                                                                 ColumnCheckpointInfo &checkpoint_info) {
-	// we need to checkpoint the main column data first
-	// that is because the checkpointing of the main column data ALSO scans the validity data
-	// to prevent reading the validity data immediately after it is checkpointed we first checkpoint the main column
-	// this is necessary for concurrent checkpointing as due to the partial block manager checkpointed data might be
-	// flushed to disk by a different thread than the one that wrote it, causing a data race
-	auto base_state = CreateCheckpointState(row_group, checkpoint_info.info.manager);
-	base_state->global_stats = BaseStatistics::CreateEmpty(type).ToUnique();
-	auto validity_state_p = validity.CreateCheckpointState(row_group, checkpoint_info.info.manager);
-	validity_state_p->global_stats = BaseStatistics::CreateEmpty(validity.type).ToUnique();
-
-	auto &validity_state = *validity_state_p;
-	auto &checkpoint_state = base_state->Cast<StandardColumnCheckpointState>();
-	checkpoint_state.validity_state = std::move(validity_state_p);
-
-	auto &nodes = data.ReferenceSegments();
-	if (nodes.empty()) {
-		// empty table: flush the empty list
-		return base_state;
-	}
-
-	vector<reference<ColumnCheckpointState>> checkpoint_states;
-	checkpoint_states.emplace_back(checkpoint_state);
-	checkpoint_states.emplace_back(validity_state);
-
-	ColumnDataCheckpointer checkpointer(checkpoint_states, GetDatabase(), row_group, checkpoint_info);
-	checkpointer.Checkpoint();
-	checkpointer.FinalizeCheckpoint();
-
-	return base_state;
-}
-
-void StandardColumnData::CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start,
-                                        idx_t count, Vector &scan_vector) {
-	ColumnData::CheckpointScan(segment, state, row_group_start, count, scan_vector);
-
-	idx_t offset_in_row_group = state.row_index - row_group_start;
-	validity.ScanCommittedRange(row_group_start, offset_in_row_group, count, scan_vector);
-}
-
-bool StandardColumnData::IsPersistent() {
-	return ColumnData::IsPersistent() && validity.IsPersistent();
-}
-
-PersistentColumnData StandardColumnData::Serialize() {
-	auto persistent_data = ColumnData::Serialize();
-	persistent_data.child_columns.push_back(validity.Serialize());
-	return persistent_data;
-}
-
-void StandardColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) {
-	ColumnData::InitializeColumn(column_data, target_stats);
-	validity.InitializeColumn(column_data.child_columns[0], target_stats);
-}
-
-void StandardColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-                                              vector<duckdb::ColumnSegmentInfo> &result) {
-	ColumnData::GetColumnSegmentInfo(row_group_index, col_path, result);
-	col_path.push_back(0);
-	validity.GetColumnSegmentInfo(row_group_index, std::move(col_path), result);
-}
-
-void StandardColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	ColumnData::Verify(parent);
-	validity.Verify(parent);
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/struct_column_data.cpp b/src/duckdb/src/storage/table/struct_column_data.cpp
deleted file mode 100644
index 5d1506b5c..000000000
--- a/src/duckdb/src/storage/table/struct_column_data.cpp
+++ /dev/null
@@ -1,369 +0,0 @@
-#include "duckdb/storage/table/struct_column_data.hpp"
-#include "duckdb/storage/statistics/struct_stats.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
-#include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-
-namespace duckdb {
-
-StructColumnData::StructColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-                                   idx_t start_row, LogicalType type_p, optional_ptr<ColumnData> parent)
-    : ColumnData(block_manager, info, column_index, start_row, std::move(type_p), parent),
-      validity(block_manager, info, 0, start_row, *this) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(!child_types.empty());
-	if (type.id() != LogicalTypeId::UNION && StructType::IsUnnamed(type)) {
-		throw InvalidInputException("A table cannot be created from an unnamed struct");
-	}
-	// the sub column index, starting at 1 (0 is the validity mask)
-	idx_t sub_column_index = 1;
-	for (auto &child_type : child_types) {
-		sub_columns.push_back(
-		    ColumnData::CreateColumnUnique(block_manager, info, sub_column_index, start_row, child_type.second, this));
-		sub_column_index++;
-	}
-}
-
-void StructColumnData::SetStart(idx_t new_start) {
-	this->start = new_start;
-	for (auto &sub_column : sub_columns) {
-		sub_column->SetStart(new_start);
-	}
-	validity.SetStart(new_start);
-}
-
-idx_t StructColumnData::GetMaxEntry() {
-	return sub_columns[0]->GetMaxEntry();
-}
-
-void StructColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) {
-	validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		if (!scan_state.scan_child_column[i]) {
-			continue;
-		}
-		sub_columns[i]->InitializePrefetch(prefetch_state, scan_state.child_states[i + 1], rows);
-	}
-}
-
-void StructColumnData::InitializeScan(ColumnScanState &state) {
-	D_ASSERT(state.child_states.size() == sub_columns.size() + 1);
-	state.row_index = 0;
-	state.current = nullptr;
-
-	// initialize the validity segment
-	validity.InitializeScan(state.child_states[0]);
-
-	// initialize the sub-columns
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		if (!state.scan_child_column[i]) {
-			continue;
-		}
-		sub_columns[i]->InitializeScan(state.child_states[i + 1]);
-	}
-}
-
-void StructColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	D_ASSERT(state.child_states.size() == sub_columns.size() + 1);
-	state.row_index = row_idx;
-	state.current = nullptr;
-
-	// initialize the validity segment
-	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
-
-	// initialize the sub-columns
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		if (!state.scan_child_column[i]) {
-			continue;
-		}
-		sub_columns[i]->InitializeScanWithOffset(state.child_states[i + 1], row_idx);
-	}
-}
-
-idx_t StructColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                             idx_t target_count) {
-	auto scan_count = validity.Scan(transaction, vector_index, state.child_states[0], result, target_count);
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		auto &target_vector = *child_entries[i];
-		if (!state.scan_child_column[i]) {
-			// if we are not scanning this vector - set it to NULL
-			target_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(target_vector, true);
-			continue;
-		}
-		sub_columns[i]->Scan(transaction, vector_index, state.child_states[i + 1], target_vector, target_count);
-	}
-	return scan_count;
-}
-
-idx_t StructColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
-                                      idx_t target_count) {
-	auto scan_count = validity.ScanCommitted(vector_index, state.child_states[0], result, allow_updates, target_count);
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		auto &target_vector = *child_entries[i];
-		if (!state.scan_child_column[i]) {
-			// if we are not scanning this vector - set it to NULL
-			target_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(target_vector, true);
-			continue;
-		}
-		sub_columns[i]->ScanCommitted(vector_index, state.child_states[i + 1], target_vector, allow_updates,
-		                              target_count);
-	}
-	return scan_count;
-}
-
-idx_t StructColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	auto scan_count = validity.ScanCount(state.child_states[0], result, count);
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		auto &target_vector = *child_entries[i];
-		if (!state.scan_child_column[i]) {
-			// if we are not scanning this vector - set it to NULL
-			target_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(target_vector, true);
-			continue;
-		}
-		sub_columns[i]->ScanCount(state.child_states[i + 1], target_vector, count);
-	}
-	return scan_count;
-}
-
-void StructColumnData::Skip(ColumnScanState &state, idx_t count) {
-	validity.Skip(state.child_states[0], count);
-
-	// skip inside the sub-columns
-	for (idx_t child_idx = 0; child_idx < sub_columns.size(); child_idx++) {
-		if (!state.scan_child_column[child_idx]) {
-			continue;
-		}
-		sub_columns[child_idx]->Skip(state.child_states[child_idx + 1], count);
-	}
-}
-
-void StructColumnData::InitializeAppend(ColumnAppendState &state) {
-	ColumnAppendState validity_append;
-	validity.InitializeAppend(validity_append);
-	state.child_appends.push_back(std::move(validity_append));
-
-	for (auto &sub_column : sub_columns) {
-		ColumnAppendState child_append;
-		sub_column->InitializeAppend(child_append);
-		state.child_appends.push_back(std::move(child_append));
-	}
-}
-
-void StructColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
-		Vector append_vector(vector);
-		append_vector.Flatten(count);
-		Append(stats, state, append_vector, count);
-		return;
-	}
-
-	// append the null values
-	validity.Append(stats, state.child_appends[0], vector, count);
-
-	auto &child_entries = StructVector::GetEntries(vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Append(StructStats::GetChildStats(stats, i), state.child_appends[i + 1], *child_entries[i],
-		                       count);
-	}
-	this->count += count;
-}
-
-void StructColumnData::RevertAppend(row_t start_row) {
-	validity.RevertAppend(start_row);
-	for (auto &sub_column : sub_columns) {
-		sub_column->RevertAppend(start_row);
-	}
-	this->count = UnsafeNumericCast<idx_t>(start_row) - this->start;
-}
-
-idx_t StructColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	// fetch validity mask
-	auto &child_entries = StructVector::GetEntries(result);
-	// insert any child states that are required
-	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
-		ColumnScanState child_state;
-		child_state.scan_options = state.scan_options;
-		state.child_states.push_back(std::move(child_state));
-	}
-	// fetch the validity state
-	idx_t scan_count = validity.Fetch(state.child_states[0], row_id, result);
-	// fetch the sub-column states
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Fetch(state.child_states[i + 1], row_id, *child_entries[i]);
-	}
-	return scan_count;
-}
-
-void StructColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                              idx_t update_count) {
-	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
-	auto &child_entries = StructVector::GetEntries(update_vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Update(transaction, column_index, *child_entries[i], row_ids, update_count);
-	}
-}
-
-void StructColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                    Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
-	// we can never DIRECTLY update a struct column
-	if (depth >= column_path.size()) {
-		throw InternalException("Attempting to directly update a struct column - this should not be possible");
-	}
-	auto update_column = column_path[depth];
-	if (update_column == 0) {
-		// update the validity column
-		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
-	} else {
-		if (update_column > sub_columns.size()) {
-			throw InternalException("Update column_path out of range");
-		}
-		sub_columns[update_column - 1]->UpdateColumn(transaction, column_path, update_vector, row_ids, update_count,
-		                                             depth + 1);
-	}
-}
-
-unique_ptr<BaseStatistics> StructColumnData::GetUpdateStatistics() {
-	// check if any child column has updates
-	auto stats = BaseStatistics::CreateEmpty(type);
-	auto validity_stats = validity.GetUpdateStatistics();
-	if (validity_stats) {
-		stats.Merge(*validity_stats);
-	}
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		auto child_stats = sub_columns[i]->GetUpdateStatistics();
-		if (child_stats) {
-			StructStats::SetChildStats(stats, i, std::move(child_stats));
-		}
-	}
-	return stats.ToUnique();
-}
-
-void StructColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                                idx_t result_idx) {
-	// fetch validity mask
-	auto &child_entries = StructVector::GetEntries(result);
-	// insert any child states that are required
-	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
-		auto child_state = make_uniq<ColumnFetchState>();
-		state.child_states.push_back(std::move(child_state));
-	}
-	// fetch the validity state
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-	// fetch the sub-column states
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->FetchRow(transaction, *state.child_states[i + 1], row_id, *child_entries[i], result_idx);
-	}
-}
-
-void StructColumnData::CommitDropColumn() {
-	validity.CommitDropColumn();
-	for (auto &sub_column : sub_columns) {
-		sub_column->CommitDropColumn();
-	}
-}
-
-struct StructColumnCheckpointState : public ColumnCheckpointState {
-	StructColumnCheckpointState(RowGroup &row_group, ColumnData &column_data,
-	                            PartialBlockManager &partial_block_manager)
-	    : ColumnCheckpointState(row_group, column_data, partial_block_manager) {
-		global_stats = StructStats::CreateEmpty(column_data.type).ToUnique();
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-	vector<unique_ptr<ColumnCheckpointState>> child_states;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		D_ASSERT(global_stats);
-		for (idx_t i = 0; i < child_states.size(); i++) {
-			StructStats::SetChildStats(*global_stats, i, child_states[i]->GetStatistics());
-		}
-		return std::move(global_stats);
-	}
-
-	PersistentColumnData ToPersistentData() override {
-		PersistentColumnData data(PhysicalType::STRUCT);
-		data.child_columns.push_back(validity_state->ToPersistentData());
-		for (auto &child_state : child_states) {
-			data.child_columns.push_back(child_state->ToPersistentData());
-		}
-		return data;
-	}
-};
-
-unique_ptr<ColumnCheckpointState> StructColumnData::CreateCheckpointState(RowGroup &row_group,
-                                                                          PartialBlockManager &partial_block_manager) {
-	return make_uniq<StructColumnCheckpointState>(row_group, *this, partial_block_manager);
-}
-
-unique_ptr<ColumnCheckpointState> StructColumnData::Checkpoint(RowGroup &row_group,
-                                                               ColumnCheckpointInfo &checkpoint_info) {
-	auto checkpoint_state = make_uniq<StructColumnCheckpointState>(row_group, *this, checkpoint_info.info.manager);
-	checkpoint_state->validity_state = validity.Checkpoint(row_group, checkpoint_info);
-	for (auto &sub_column : sub_columns) {
-		checkpoint_state->child_states.push_back(sub_column->Checkpoint(row_group, checkpoint_info));
-	}
-	return std::move(checkpoint_state);
-}
-
-bool StructColumnData::IsPersistent() {
-	if (!validity.IsPersistent()) {
-		return false;
-	}
-	for (auto &child_col : sub_columns) {
-		if (!child_col->IsPersistent()) {
-			return false;
-		}
-	}
-	return true;
-}
-
-PersistentColumnData StructColumnData::Serialize() {
-	PersistentColumnData persistent_data(PhysicalType::STRUCT);
-	persistent_data.child_columns.push_back(validity.Serialize());
-	for (auto &sub_column : sub_columns) {
-		persistent_data.child_columns.push_back(sub_column->Serialize());
-	}
-	return persistent_data;
-}
-
-void StructColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) {
-	validity.InitializeColumn(column_data.child_columns[0], target_stats);
-	for (idx_t c_idx = 0; c_idx < sub_columns.size(); c_idx++) {
-		auto &child_stats = StructStats::GetChildStats(target_stats, c_idx);
-		sub_columns[c_idx]->InitializeColumn(column_data.child_columns[c_idx + 1], child_stats);
-	}
-	this->count = validity.count.load();
-}
-
-void StructColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
-                                            vector<duckdb::ColumnSegmentInfo> &result) {
-	col_path.push_back(0);
-	validity.GetColumnSegmentInfo(row_group_index, col_path, result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		col_path.back() = i + 1;
-		sub_columns[i]->GetColumnSegmentInfo(row_group_index, col_path, result);
-	}
-}
-
-void StructColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	ColumnData::Verify(parent);
-	validity.Verify(parent);
-	for (auto &sub_column : sub_columns) {
-		sub_column->Verify(parent);
-	}
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/table_statistics.cpp b/src/duckdb/src/storage/table/table_statistics.cpp
deleted file mode 100644
index e56f98440..000000000
--- a/src/duckdb/src/storage/table/table_statistics.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-#include "duckdb/storage/table/table_statistics.hpp"
-
-#include "duckdb/common/serializer/deserializer.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/execution/reservoir_sample.hpp"
-#include "duckdb/storage/table/persistent_table_data.hpp"
-
-namespace duckdb {
-
-void TableStatistics::Initialize(const vector<LogicalType> &types, PersistentTableData &data) {
-	D_ASSERT(Empty());
-	D_ASSERT(!table_sample);
-
-	stats_lock = make_shared_ptr<mutex>();
-	column_stats = std::move(data.table_stats.column_stats);
-	if (data.table_stats.table_sample) {
-		table_sample = std::move(data.table_stats.table_sample);
-	} else {
-		table_sample = make_uniq<ReservoirSample>(static_cast<idx_t>(FIXED_SAMPLE_SIZE));
-	}
-	if (column_stats.size() != types.size()) { // LCOV_EXCL_START
-		throw IOException("Table statistics column count is not aligned with table column count. Corrupt file?");
-	} // LCOV_EXCL_STOP
-}
-
-void TableStatistics::InitializeEmpty(const vector<LogicalType> &types) {
-	D_ASSERT(Empty());
-	D_ASSERT(!table_sample);
-
-	stats_lock = make_shared_ptr<mutex>();
-	table_sample = make_uniq<ReservoirSample>(static_cast<idx_t>(FIXED_SAMPLE_SIZE));
-	for (auto &type : types) {
-		column_stats.push_back(ColumnStatistics::CreateEmptyStats(type));
-	}
-}
-
-void TableStatistics::InitializeAddColumn(TableStatistics &parent, const LogicalType &new_column_type) {
-	D_ASSERT(Empty());
-	D_ASSERT(parent.stats_lock);
-
-	stats_lock = parent.stats_lock;
-	lock_guard<mutex> lock(*stats_lock);
-	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		column_stats.push_back(parent.column_stats[i]);
-	}
-	column_stats.push_back(ColumnStatistics::CreateEmptyStats(new_column_type));
-	if (parent.table_sample) {
-		table_sample = std::move(parent.table_sample);
-	}
-	if (table_sample) {
-		table_sample->Destroy();
-	}
-}
-
-void TableStatistics::InitializeRemoveColumn(TableStatistics &parent, idx_t removed_column) {
-	D_ASSERT(Empty());
-	D_ASSERT(parent.stats_lock);
-
-	stats_lock = parent.stats_lock;
-	lock_guard<mutex> lock(*stats_lock);
-	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		if (i != removed_column) {
-			column_stats.push_back(parent.column_stats[i]);
-		}
-	}
-	if (parent.table_sample) {
-		table_sample = std::move(parent.table_sample);
-	}
-	if (table_sample) {
-		table_sample->Destroy();
-	}
-}
-
-void TableStatistics::InitializeAlterType(TableStatistics &parent, idx_t changed_idx, const LogicalType &new_type) {
-	D_ASSERT(Empty());
-	D_ASSERT(parent.stats_lock);
-
-	stats_lock = parent.stats_lock;
-	lock_guard<mutex> lock(*stats_lock);
-	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		if (i == changed_idx) {
-			column_stats.push_back(ColumnStatistics::CreateEmptyStats(new_type));
-		} else {
-			column_stats.push_back(parent.column_stats[i]);
-		}
-	}
-	if (parent.table_sample) {
-		table_sample = std::move(parent.table_sample);
-	}
-	if (table_sample) {
-		table_sample->Destroy();
-	}
-}
-
-void TableStatistics::InitializeAddConstraint(TableStatistics &parent) {
-	D_ASSERT(Empty());
-	D_ASSERT(parent.stats_lock);
-
-	stats_lock = parent.stats_lock;
-	lock_guard<mutex> lock(*stats_lock);
-	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		column_stats.push_back(parent.column_stats[i]);
-	}
-}
-
-void TableStatistics::MergeStats(TableStatistics &other) {
-	auto l = GetLock();
-	D_ASSERT(column_stats.size() == other.column_stats.size());
-	if (table_sample) {
-		if (other.table_sample) {
-			D_ASSERT(table_sample->type == SampleType::RESERVOIR_SAMPLE);
-			auto &this_reservoir = table_sample->Cast<ReservoirSample>();
-			D_ASSERT(other.table_sample->type == SampleType::RESERVOIR_SAMPLE);
-			this_reservoir.Merge(std::move(other.table_sample));
-		}
-		// if no other.table sample, do nothig
-	} else {
-		if (other.table_sample) {
-			auto &other_reservoir = other.table_sample->Cast<ReservoirSample>();
-			auto other_table_sample_copy = other_reservoir.Copy();
-			table_sample = std::move(other_table_sample_copy);
-		}
-	}
-	for (idx_t i = 0; i < column_stats.size(); i++) {
-		if (column_stats[i]) {
-			D_ASSERT(other.column_stats[i]);
-			column_stats[i]->Merge(*other.column_stats[i]);
-		}
-	}
-}
-
-void TableStatistics::MergeStats(idx_t i, BaseStatistics &stats) {
-	auto l = GetLock();
-	MergeStats(*l, i, stats);
-}
-
-void TableStatistics::MergeStats(TableStatisticsLock &lock, idx_t i, BaseStatistics &stats) {
-	column_stats[i]->Statistics().Merge(stats);
-}
-
-ColumnStatistics &TableStatistics::GetStats(TableStatisticsLock &lock, idx_t i) {
-	return *column_stats[i];
-}
-
-BlockingSample &TableStatistics::GetTableSampleRef(TableStatisticsLock &lock) {
-	D_ASSERT(table_sample);
-	return *table_sample;
-}
-
-unique_ptr<BlockingSample> TableStatistics::GetTableSample(TableStatisticsLock &lock) {
-	return std::move(table_sample);
-}
-
-void TableStatistics::SetTableSample(TableStatisticsLock &lock, unique_ptr<BlockingSample> sample) {
-	table_sample = std::move(sample);
-}
-
-void TableStatistics::DestroyTableSample(TableStatisticsLock &lock) const {
-	if (table_sample) {
-		table_sample->Destroy();
-	}
-}
-
-unique_ptr<BaseStatistics> TableStatistics::CopyStats(idx_t i) {
-	lock_guard<mutex> l(*stats_lock);
-	auto result = column_stats[i]->Statistics().Copy();
-	if (column_stats[i]->HasDistinctStats()) {
-		result.SetDistinctCount(column_stats[i]->DistinctStats().GetCount());
-	}
-	return result.ToUnique();
-}
-
-void TableStatistics::CopyStats(TableStatistics &other) {
-	TableStatisticsLock lock(*stats_lock);
-	CopyStats(lock, other);
-}
-
-void TableStatistics::CopyStats(TableStatisticsLock &lock, TableStatistics &other) {
-	D_ASSERT(other.Empty());
-	other.stats_lock = make_shared_ptr<mutex>();
-	for (auto &stats : column_stats) {
-		other.column_stats.push_back(stats->Copy());
-	}
-
-	if (table_sample) {
-		D_ASSERT(table_sample->type == SampleType::RESERVOIR_SAMPLE);
-		auto &res = table_sample->Cast<ReservoirSample>();
-		other.table_sample = res.Copy();
-	}
-}
-
-void TableStatistics::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(100, "column_stats", column_stats);
-	unique_ptr<BlockingSample> to_serialize = nullptr;
-	if (table_sample) {
-		D_ASSERT(table_sample->type == SampleType::RESERVOIR_SAMPLE);
-		auto &reservoir_sample = table_sample->Cast<ReservoirSample>();
-		to_serialize = unique_ptr_cast<BlockingSample, ReservoirSample>(reservoir_sample.Copy());
-		auto &res_serialize = to_serialize->Cast<ReservoirSample>();
-		res_serialize.EvictOverBudgetSamples();
-	}
-	serializer.WritePropertyWithDefault<unique_ptr<BlockingSample>>(101, "table_sample", to_serialize, nullptr);
-}
-
-void TableStatistics::Deserialize(Deserializer &deserializer, ColumnList &columns) {
-	auto physical_columns = columns.Physical();
-
-	auto iter = physical_columns.begin();
-	deserializer.ReadList(100, "column_stats", [&](Deserializer::List &list, idx_t i) {
-		auto &col = *iter;
-		iter.operator++();
-
-		auto type = col.GetType();
-		deserializer.Set<LogicalType &>(type);
-
-		column_stats.push_back(list.ReadElement<shared_ptr<ColumnStatistics>>());
-
-		deserializer.Unset<LogicalType>();
-	});
-	table_sample = deserializer.ReadPropertyWithDefault<unique_ptr<BlockingSample>>(101, "table_sample");
-	if (table_sample) {
-		D_ASSERT(table_sample->type == SampleType::RESERVOIR_SAMPLE);
-#ifdef DEBUG
-		if (table_sample) {
-			auto &reservoir_sample = table_sample->Cast<ReservoirSample>();
-			reservoir_sample.Verify();
-		}
-#endif
-	} else {
-		table_sample = make_uniq<ReservoirSample>(static_cast<idx_t>(FIXED_SAMPLE_SIZE));
-		table_sample->Destroy();
-	}
-}
-
-unique_ptr<TableStatisticsLock> TableStatistics::GetLock() {
-	D_ASSERT(stats_lock);
-	return make_uniq<TableStatisticsLock>(*stats_lock);
-}
-
-bool TableStatistics::Empty() {
-	D_ASSERT(column_stats.empty() == (stats_lock.get() == nullptr));
-	return column_stats.empty();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/update_segment.cpp b/src/duckdb/src/storage/table/update_segment.cpp
deleted file mode 100644
index ddee92ceb..000000000
--- a/src/duckdb/src/storage/table/update_segment.cpp
+++ /dev/null
@@ -1,1317 +0,0 @@
-#include "duckdb/storage/table/update_segment.hpp"
-
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/transaction/update_info.hpp"
-#include "duckdb/transaction/undo_buffer.hpp"
-
-#include <algorithm>
-
-namespace duckdb {
-
-static UpdateSegment::initialize_update_function_t GetInitializeUpdateFunction(PhysicalType type);
-static UpdateSegment::fetch_update_function_t GetFetchUpdateFunction(PhysicalType type);
-static UpdateSegment::fetch_committed_function_t GetFetchCommittedFunction(PhysicalType type);
-static UpdateSegment::fetch_committed_range_function_t GetFetchCommittedRangeFunction(PhysicalType type);
-
-static UpdateSegment::merge_update_function_t GetMergeUpdateFunction(PhysicalType type);
-static UpdateSegment::rollback_update_function_t GetRollbackUpdateFunction(PhysicalType type);
-static UpdateSegment::statistics_update_function_t GetStatisticsUpdateFunction(PhysicalType type);
-static UpdateSegment::fetch_row_function_t GetFetchRowFunction(PhysicalType type);
-
-UpdateSegment::UpdateSegment(ColumnData &column_data)
-    : column_data(column_data), stats(column_data.type), heap(BufferAllocator::Get(column_data.GetDatabase())) {
-	auto physical_type = column_data.type.InternalType();
-
-	this->type_size = GetTypeIdSize(physical_type);
-
-	this->initialize_update_function = GetInitializeUpdateFunction(physical_type);
-	this->fetch_update_function = GetFetchUpdateFunction(physical_type);
-	this->fetch_committed_function = GetFetchCommittedFunction(physical_type);
-	this->fetch_committed_range = GetFetchCommittedRangeFunction(physical_type);
-	this->fetch_row_function = GetFetchRowFunction(physical_type);
-	this->merge_update_function = GetMergeUpdateFunction(physical_type);
-	this->rollback_update_function = GetRollbackUpdateFunction(physical_type);
-	this->statistics_update_function = GetStatisticsUpdateFunction(physical_type);
-}
-
-UpdateSegment::~UpdateSegment() {
-}
-
-//===--------------------------------------------------------------------===//
-// Update Info Helpers
-//===--------------------------------------------------------------------===//
-Value UpdateInfo::GetValue(idx_t index) {
-	auto &type = segment->column_data.type;
-
-	auto tuple_data = GetValues();
-	switch (type.id()) {
-	case LogicalTypeId::VALIDITY:
-		return Value::BOOLEAN(reinterpret_cast<bool *>(tuple_data)[index]);
-	case LogicalTypeId::INTEGER:
-		return Value::INTEGER(reinterpret_cast<int32_t *>(tuple_data)[index]);
-	default:
-		throw NotImplementedException("Unimplemented type for UpdateInfo::GetValue");
-	}
-}
-
-void UpdateInfo::Print() {
-	Printer::Print(ToString());
-}
-
-string UpdateInfo::ToString() {
-	auto &type = segment->column_data.type;
-	string result = "Update Info [" + type.ToString() + ", Count: " + to_string(N) +
-	                ", Transaction Id: " + to_string(version_number) + "]\n";
-	auto tuples = GetTuples();
-	for (idx_t i = 0; i < N; i++) {
-		result += to_string(tuples[i]) + ": " + GetValue(i).ToString() + "\n";
-	}
-	if (HasNext()) {
-		auto next_pin = next.Pin();
-		result += "\nChild Segment: " + Get(next_pin).ToString();
-	}
-	return result;
-}
-
-sel_t *UpdateInfo::GetTuples() {
-	return reinterpret_cast<sel_t *>(data_ptr_cast(this) + sizeof(UpdateInfo));
-}
-
-data_ptr_t UpdateInfo::GetValues() {
-	return reinterpret_cast<data_ptr_t>(data_ptr_cast(this) + sizeof(UpdateInfo) + sizeof(sel_t) * max);
-}
-
-UpdateInfo &UpdateInfo::Get(UndoBufferReference &entry) {
-	auto update_info = reinterpret_cast<UpdateInfo *>(entry.Ptr());
-	return *update_info;
-}
-
-bool UpdateInfo::HasPrev() const {
-	return prev.entry;
-}
-
-bool UpdateInfo::HasNext() const {
-	return next.entry;
-}
-
-idx_t UpdateInfo::GetAllocSize(idx_t type_size) {
-	return AlignValue<idx_t>(sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE);
-}
-
-void UpdateInfo::Initialize(UpdateInfo &info, transaction_t transaction_id) {
-	info.max = STANDARD_VECTOR_SIZE;
-	info.version_number = transaction_id;
-	info.segment = nullptr;
-	info.prev.entry = nullptr;
-	info.next.entry = nullptr;
-}
-
-void UpdateInfo::Verify() {
-#ifdef DEBUG
-	auto tuples = GetTuples();
-	for (idx_t i = 1; i < N; i++) {
-		D_ASSERT(tuples[i] > tuples[i - 1] && tuples[i] < STANDARD_VECTOR_SIZE);
-	}
-#endif
-}
-
-//===--------------------------------------------------------------------===//
-// Update Fetch
-//===--------------------------------------------------------------------===//
-static void MergeValidityInfo(UpdateInfo &current, ValidityMask &result_mask) {
-	auto tuples = current.GetTuples();
-	auto info_data = current.GetData<bool>();
-	for (idx_t i = 0; i < current.N; i++) {
-		result_mask.Set(tuples[i], info_data[i]);
-	}
-}
-
-static void UpdateMergeValidity(transaction_t start_time, transaction_t transaction_id, UpdateInfo &info,
-                                Vector &result) {
-	auto &result_mask = FlatVector::Validity(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id,
-	                                  [&](UpdateInfo &current) { MergeValidityInfo(current, result_mask); });
-}
-
-template <class T>
-static void MergeUpdateInfo(UpdateInfo &current, T *result_data) {
-	auto tuples = current.GetTuples();
-	auto info_data = current.GetData<T>();
-	if (current.N == STANDARD_VECTOR_SIZE) {
-		// special case: update touches ALL tuples of this vector
-		// in this case we can just memcpy the data
-		// since the layout of the update info is guaranteed to be [0, 1, 2, 3, ...]
-		memcpy(result_data, info_data, sizeof(T) * current.N);
-	} else {
-		for (idx_t i = 0; i < current.N; i++) {
-			result_data[tuples[i]] = info_data[i];
-		}
-	}
-}
-
-template <class T>
-static void UpdateMergeFetch(transaction_t start_time, transaction_t transaction_id, UpdateInfo &info, Vector &result) {
-	auto result_data = FlatVector::GetData<T>(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id,
-	                                  [&](UpdateInfo &current) { MergeUpdateInfo<T>(current, result_data); });
-}
-
-static UpdateSegment::fetch_update_function_t GetFetchUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return UpdateMergeValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return UpdateMergeFetch<int8_t>;
-	case PhysicalType::INT16:
-		return UpdateMergeFetch<int16_t>;
-	case PhysicalType::INT32:
-		return UpdateMergeFetch<int32_t>;
-	case PhysicalType::INT64:
-		return UpdateMergeFetch<int64_t>;
-	case PhysicalType::UINT8:
-		return UpdateMergeFetch<uint8_t>;
-	case PhysicalType::UINT16:
-		return UpdateMergeFetch<uint16_t>;
-	case PhysicalType::UINT32:
-		return UpdateMergeFetch<uint32_t>;
-	case PhysicalType::UINT64:
-		return UpdateMergeFetch<uint64_t>;
-	case PhysicalType::INT128:
-		return UpdateMergeFetch<hugeint_t>;
-	case PhysicalType::UINT128:
-		return UpdateMergeFetch<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return UpdateMergeFetch<float>;
-	case PhysicalType::DOUBLE:
-		return UpdateMergeFetch<double>;
-	case PhysicalType::INTERVAL:
-		return UpdateMergeFetch<interval_t>;
-	case PhysicalType::VARCHAR:
-		return UpdateMergeFetch<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-UndoBufferPointer UpdateSegment::GetUpdateNode(idx_t vector_idx) const {
-	if (!root) {
-		return UndoBufferPointer();
-	}
-	if (vector_idx >= root->info.size()) {
-		return UndoBufferPointer();
-	}
-	return root->info[vector_idx];
-}
-
-void UpdateSegment::FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result) {
-	auto lock_handle = lock.GetSharedLock();
-	auto node = GetUpdateNode(vector_index);
-	if (!node.IsSet()) {
-		return;
-	}
-	// FIXME: normalify if this is not the case... need to pass in count?
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto pin = node.Pin();
-	fetch_update_function(transaction.start_time, transaction.transaction_id, UpdateInfo::Get(pin), result);
-}
-
-UpdateNode::UpdateNode(BufferManager &manager) : allocator(manager) {
-}
-
-UpdateNode::~UpdateNode() {
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Committed
-//===--------------------------------------------------------------------===//
-static void FetchCommittedValidity(UpdateInfo &info, Vector &result) {
-	auto &result_mask = FlatVector::Validity(result);
-	MergeValidityInfo(info, result_mask);
-}
-
-template <class T>
-static void TemplatedFetchCommitted(UpdateInfo &info, Vector &result) {
-	auto result_data = FlatVector::GetData<T>(result);
-	MergeUpdateInfo<T>(info, result_data);
-}
-
-static UpdateSegment::fetch_committed_function_t GetFetchCommittedFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return FetchCommittedValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedFetchCommitted<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedFetchCommitted<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedFetchCommitted<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedFetchCommitted<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedFetchCommitted<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedFetchCommitted<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedFetchCommitted<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedFetchCommitted<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedFetchCommitted<hugeint_t>;
-	case PhysicalType::UINT128:
-		return TemplatedFetchCommitted<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedFetchCommitted<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedFetchCommitted<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedFetchCommitted<interval_t>;
-	case PhysicalType::VARCHAR:
-		return TemplatedFetchCommitted<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-void UpdateSegment::FetchCommitted(idx_t vector_index, Vector &result) {
-	auto lock_handle = lock.GetSharedLock();
-	auto node = GetUpdateNode(vector_index);
-	if (!node.IsSet()) {
-		return;
-	}
-	// FIXME: normalify if this is not the case... need to pass in count?
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto pin = node.Pin();
-	fetch_committed_function(UpdateInfo::Get(pin), result);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Range
-//===--------------------------------------------------------------------===//
-static void MergeUpdateInfoRangeValidity(UpdateInfo &current, idx_t start, idx_t end, idx_t result_offset,
-                                         ValidityMask &result_mask) {
-	auto tuples = current.GetTuples();
-	auto info_data = current.GetData<bool>();
-	for (idx_t i = 0; i < current.N; i++) {
-		auto tuple_idx = tuples[i];
-		if (tuple_idx < start) {
-			continue;
-		} else if (tuple_idx >= end) {
-			break;
-		}
-		auto result_idx = result_offset + tuple_idx - start;
-		result_mask.Set(result_idx, info_data[i]);
-	}
-}
-
-static void FetchCommittedRangeValidity(UpdateInfo &info, idx_t start, idx_t end, idx_t result_offset, Vector &result) {
-	auto &result_mask = FlatVector::Validity(result);
-	MergeUpdateInfoRangeValidity(info, start, end, result_offset, result_mask);
-}
-
-template <class T>
-static void MergeUpdateInfoRange(UpdateInfo &current, idx_t start, idx_t end, idx_t result_offset, T *result_data) {
-	auto tuples = current.GetTuples();
-	auto info_data = current.GetData<T>();
-	for (idx_t i = 0; i < current.N; i++) {
-		auto tuple_idx = tuples[i];
-		if (tuple_idx < start) {
-			continue;
-		} else if (tuple_idx >= end) {
-			break;
-		}
-		auto result_idx = result_offset + tuple_idx - start;
-		result_data[result_idx] = info_data[i];
-	}
-}
-
-template <class T>
-static void TemplatedFetchCommittedRange(UpdateInfo &info, idx_t start, idx_t end, idx_t result_offset,
-                                         Vector &result) {
-	auto result_data = FlatVector::GetData<T>(result);
-	MergeUpdateInfoRange<T>(info, start, end, result_offset, result_data);
-}
-
-static UpdateSegment::fetch_committed_range_function_t GetFetchCommittedRangeFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return FetchCommittedRangeValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedFetchCommittedRange<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedFetchCommittedRange<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedFetchCommittedRange<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedFetchCommittedRange<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedFetchCommittedRange<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedFetchCommittedRange<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedFetchCommittedRange<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedFetchCommittedRange<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedFetchCommittedRange<hugeint_t>;
-	case PhysicalType::UINT128:
-		return TemplatedFetchCommittedRange<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedFetchCommittedRange<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedFetchCommittedRange<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedFetchCommittedRange<interval_t>;
-	case PhysicalType::VARCHAR:
-		return TemplatedFetchCommittedRange<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-void UpdateSegment::FetchCommittedRange(idx_t start_row, idx_t count, Vector &result) {
-	D_ASSERT(count > 0);
-	if (!root) {
-		return;
-	}
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	idx_t end_row = start_row + count;
-	idx_t start_vector = start_row / STANDARD_VECTOR_SIZE;
-	idx_t end_vector = (end_row - 1) / STANDARD_VECTOR_SIZE;
-	D_ASSERT(start_vector <= end_vector);
-
-	for (idx_t vector_idx = start_vector; vector_idx <= end_vector; vector_idx++) {
-		auto entry = GetUpdateNode(vector_idx);
-		if (!entry.IsSet()) {
-			continue;
-		}
-		auto pin = entry.Pin();
-		idx_t start_in_vector = vector_idx == start_vector ? start_row - start_vector * STANDARD_VECTOR_SIZE : 0;
-		idx_t end_in_vector =
-		    vector_idx == end_vector ? end_row - end_vector * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-		D_ASSERT(start_in_vector < end_in_vector);
-		D_ASSERT(end_in_vector > 0 && end_in_vector <= STANDARD_VECTOR_SIZE);
-		idx_t result_offset = ((vector_idx * STANDARD_VECTOR_SIZE) + start_in_vector) - start_row;
-		fetch_committed_range(UpdateInfo::Get(pin), start_in_vector, end_in_vector, result_offset, result);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Row
-//===--------------------------------------------------------------------===//
-static void FetchRowValidity(transaction_t start_time, transaction_t transaction_id, UpdateInfo &info, idx_t row_idx,
-                             Vector &result, idx_t result_idx) {
-	auto &result_mask = FlatVector::Validity(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id, [&](UpdateInfo &current) {
-		auto info_data = current.GetData<bool>();
-		auto tuples = current.GetTuples();
-		// FIXME: we could do a binary search in here
-		for (idx_t i = 0; i < current.N; i++) {
-			if (tuples[i] == row_idx) {
-				result_mask.Set(result_idx, info_data[i]);
-				break;
-			} else if (tuples[i] > row_idx) {
-				break;
-			}
-		}
-	});
-}
-
-template <class T>
-static void TemplatedFetchRow(transaction_t start_time, transaction_t transaction_id, UpdateInfo &info, idx_t row_idx,
-                              Vector &result, idx_t result_idx) {
-	auto result_data = FlatVector::GetData<T>(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id, [&](UpdateInfo &current) {
-		auto info_data = current.GetData<T>();
-		auto tuples = current.GetTuples();
-		// FIXME: we could do a binary search in here
-		for (idx_t i = 0; i < current.N; i++) {
-			if (tuples[i] == row_idx) {
-				result_data[result_idx] = info_data[i];
-				break;
-			} else if (tuples[i] > row_idx) {
-				break;
-			}
-		}
-	});
-}
-
-static UpdateSegment::fetch_row_function_t GetFetchRowFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return FetchRowValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedFetchRow<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedFetchRow<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedFetchRow<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedFetchRow<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedFetchRow<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedFetchRow<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedFetchRow<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedFetchRow<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedFetchRow<hugeint_t>;
-	case PhysicalType::UINT128:
-		return TemplatedFetchRow<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedFetchRow<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedFetchRow<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedFetchRow<interval_t>;
-	case PhysicalType::VARCHAR:
-		return TemplatedFetchRow<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment fetch row");
-	}
-}
-
-void UpdateSegment::FetchRow(TransactionData transaction, idx_t row_id, Vector &result, idx_t result_idx) {
-	idx_t vector_index = (row_id - column_data.start) / STANDARD_VECTOR_SIZE;
-	auto entry = GetUpdateNode(vector_index);
-	if (!entry.IsSet()) {
-		return;
-	}
-	idx_t row_in_vector = (row_id - column_data.start) - vector_index * STANDARD_VECTOR_SIZE;
-	auto pin = entry.Pin();
-	fetch_row_function(transaction.start_time, transaction.transaction_id, UpdateInfo::Get(pin), row_in_vector, result,
-	                   result_idx);
-}
-
-//===--------------------------------------------------------------------===//
-// Rollback update
-//===--------------------------------------------------------------------===//
-template <class T>
-static void RollbackUpdate(UpdateInfo &base_info, UpdateInfo &rollback_info) {
-	auto base_data = base_info.GetData<T>();
-	auto base_tuples = base_info.GetTuples();
-	auto rollback_data = rollback_info.GetData<T>();
-	auto rollback_tuples = rollback_info.GetTuples();
-	idx_t base_offset = 0;
-	for (idx_t i = 0; i < rollback_info.N; i++) {
-		auto id = rollback_tuples[i];
-		while (base_tuples[base_offset] < id) {
-			base_offset++;
-			D_ASSERT(base_offset < base_info.N);
-		}
-		base_data[base_offset] = rollback_data[i];
-	}
-}
-
-static UpdateSegment::rollback_update_function_t GetRollbackUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return RollbackUpdate<bool>;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return RollbackUpdate<int8_t>;
-	case PhysicalType::INT16:
-		return RollbackUpdate<int16_t>;
-	case PhysicalType::INT32:
-		return RollbackUpdate<int32_t>;
-	case PhysicalType::INT64:
-		return RollbackUpdate<int64_t>;
-	case PhysicalType::UINT8:
-		return RollbackUpdate<uint8_t>;
-	case PhysicalType::UINT16:
-		return RollbackUpdate<uint16_t>;
-	case PhysicalType::UINT32:
-		return RollbackUpdate<uint32_t>;
-	case PhysicalType::UINT64:
-		return RollbackUpdate<uint64_t>;
-	case PhysicalType::INT128:
-		return RollbackUpdate<hugeint_t>;
-	case PhysicalType::UINT128:
-		return RollbackUpdate<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return RollbackUpdate<float>;
-	case PhysicalType::DOUBLE:
-		return RollbackUpdate<double>;
-	case PhysicalType::INTERVAL:
-		return RollbackUpdate<interval_t>;
-	case PhysicalType::VARCHAR:
-		return RollbackUpdate<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for uncompressed segment");
-	}
-}
-
-void UpdateSegment::RollbackUpdate(UpdateInfo &info) {
-	// obtain an exclusive lock
-	auto lock_handle = lock.GetExclusiveLock();
-
-	// move the data from the UpdateInfo back into the base info
-	auto entry = GetUpdateNode(info.vector_index);
-	if (!entry.IsSet()) {
-		return;
-	}
-	auto pin = entry.Pin();
-	rollback_update_function(UpdateInfo::Get(pin), info);
-
-	// clean up the update chain
-	CleanupUpdateInternal(*lock_handle, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Cleanup Update
-//===--------------------------------------------------------------------===//
-void UpdateSegment::CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo &info) {
-	D_ASSERT(info.HasPrev());
-	auto prev = info.prev;
-	{
-		auto pin = prev.Pin();
-		auto &prev_info = UpdateInfo::Get(pin);
-		prev_info.next = info.next;
-	}
-	if (info.HasNext()) {
-		auto next = info.next;
-		auto next_pin = next.Pin();
-		auto &next_info = UpdateInfo::Get(next_pin);
-		next_info.prev = prev;
-	}
-}
-
-void UpdateSegment::CleanupUpdate(UpdateInfo &info) {
-	// obtain an exclusive lock
-	auto lock_handle = lock.GetExclusiveLock();
-	CleanupUpdateInternal(*lock_handle, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Check for conflicts in update
-//===--------------------------------------------------------------------===//
-static void CheckForConflicts(UndoBufferPointer next_ptr, TransactionData transaction, row_t *ids,
-                              const SelectionVector &sel, idx_t count, row_t offset, UndoBufferReference &node_ref) {
-	while (next_ptr.IsSet()) {
-		auto pin = next_ptr.Pin();
-		auto &info = UpdateInfo::Get(pin);
-		if (info.version_number == transaction.transaction_id) {
-			// this UpdateInfo belongs to the current transaction, set it in the node
-			node_ref = std::move(pin);
-		} else if (info.version_number > transaction.start_time) {
-			// potential conflict, check that tuple ids do not conflict
-			// as both ids and info->tuples are sorted, this is similar to a merge join
-			idx_t i = 0, j = 0;
-			auto tuples = info.GetTuples();
-			while (true) {
-				auto id = ids[sel.get_index(i)] - offset;
-				if (id == tuples[j]) {
-					throw TransactionException("Conflict on update!");
-				} else if (id < tuples[j]) {
-					// id < the current tuple in info, move to next id
-					i++;
-					if (i == count) {
-						break;
-					}
-				} else {
-					// id > the current tuple, move to next tuple in info
-					j++;
-					if (j == info.N) {
-						break;
-					}
-				}
-			}
-		}
-		next_ptr = info.next;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Initialize update info
-//===--------------------------------------------------------------------===//
-void UpdateSegment::InitializeUpdateInfo(UpdateInfo &info, row_t *ids, const SelectionVector &sel, idx_t count,
-                                         idx_t vector_index, idx_t vector_offset) {
-	info.segment = this;
-	info.vector_index = vector_index;
-	info.prev = UndoBufferPointer();
-	info.next = UndoBufferPointer();
-
-	// set up the tuple ids
-	info.N = UnsafeNumericCast<sel_t>(count);
-	auto tuples = info.GetTuples();
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto id = ids[idx];
-		D_ASSERT(idx_t(id) >= vector_offset && idx_t(id) < vector_offset + STANDARD_VECTOR_SIZE);
-		tuples[i] = NumericCast<sel_t>(NumericCast<idx_t>(id) - vector_offset);
-	};
-}
-
-static void InitializeUpdateValidity(UpdateInfo &base_info, Vector &base_data, UpdateInfo &update_info, Vector &update,
-                                     const SelectionVector &sel) {
-	auto &update_mask = FlatVector::Validity(update);
-	auto tuple_data = update_info.GetData<bool>();
-
-	if (!update_mask.AllValid()) {
-		for (idx_t i = 0; i < update_info.N; i++) {
-			auto idx = sel.get_index(i);
-			tuple_data[i] = update_mask.RowIsValidUnsafe(idx);
-		}
-	} else {
-		for (idx_t i = 0; i < update_info.N; i++) {
-			tuple_data[i] = true;
-		}
-	}
-
-	auto &base_mask = FlatVector::Validity(base_data);
-	auto base_tuple_data = base_info.GetData<bool>();
-	auto base_tuples = base_info.GetTuples();
-	if (!base_mask.AllValid()) {
-		for (idx_t i = 0; i < base_info.N; i++) {
-			base_tuple_data[i] = base_mask.RowIsValidUnsafe(base_tuples[i]);
-		}
-	} else {
-		for (idx_t i = 0; i < base_info.N; i++) {
-			base_tuple_data[i] = true;
-		}
-	}
-}
-
-struct UpdateSelectElement {
-	template <class T>
-	static T Operation(UpdateSegment &segment, T element) {
-		return element;
-	}
-};
-
-template <>
-string_t UpdateSelectElement::Operation(UpdateSegment &segment, string_t element) {
-	return element.IsInlined() ? element : segment.GetStringHeap().AddBlob(element);
-}
-
-template <class T>
-static void InitializeUpdateData(UpdateInfo &base_info, Vector &base_data, UpdateInfo &update_info, Vector &update,
-                                 const SelectionVector &sel) {
-	auto update_data = FlatVector::GetData<T>(update);
-	auto tuple_data = update_info.GetData<T>();
-
-	for (idx_t i = 0; i < update_info.N; i++) {
-		auto idx = sel.get_index(i);
-		tuple_data[i] = update_data[idx];
-	}
-
-	auto base_array_data = FlatVector::GetData<T>(base_data);
-	auto &base_validity = FlatVector::Validity(base_data);
-	auto base_tuple_data = base_info.GetData<T>();
-	auto base_tuples = base_info.GetTuples();
-	for (idx_t i = 0; i < base_info.N; i++) {
-		auto base_idx = base_tuples[i];
-		if (!base_validity.RowIsValid(base_idx)) {
-			continue;
-		}
-		base_tuple_data[i] = UpdateSelectElement::Operation<T>(*base_info.segment, base_array_data[base_idx]);
-	}
-}
-
-static UpdateSegment::initialize_update_function_t GetInitializeUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return InitializeUpdateValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return InitializeUpdateData<int8_t>;
-	case PhysicalType::INT16:
-		return InitializeUpdateData<int16_t>;
-	case PhysicalType::INT32:
-		return InitializeUpdateData<int32_t>;
-	case PhysicalType::INT64:
-		return InitializeUpdateData<int64_t>;
-	case PhysicalType::UINT8:
-		return InitializeUpdateData<uint8_t>;
-	case PhysicalType::UINT16:
-		return InitializeUpdateData<uint16_t>;
-	case PhysicalType::UINT32:
-		return InitializeUpdateData<uint32_t>;
-	case PhysicalType::UINT64:
-		return InitializeUpdateData<uint64_t>;
-	case PhysicalType::INT128:
-		return InitializeUpdateData<hugeint_t>;
-	case PhysicalType::UINT128:
-		return InitializeUpdateData<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return InitializeUpdateData<float>;
-	case PhysicalType::DOUBLE:
-		return InitializeUpdateData<double>;
-	case PhysicalType::INTERVAL:
-		return InitializeUpdateData<interval_t>;
-	case PhysicalType::VARCHAR:
-		return InitializeUpdateData<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Merge update info
-//===--------------------------------------------------------------------===//
-template <class F1, class F2, class F3>
-static idx_t MergeLoop(row_t a[], sel_t b[], idx_t acount, idx_t bcount, idx_t aoffset, F1 merge, F2 pick_a, F3 pick_b,
-                       const SelectionVector &asel) {
-	idx_t aidx = 0, bidx = 0;
-	idx_t count = 0;
-	while (aidx < acount && bidx < bcount) {
-		auto a_index = asel.get_index(aidx);
-		auto a_id = UnsafeNumericCast<idx_t>(a[a_index]) - aoffset;
-		auto b_id = b[bidx];
-		if (a_id == b_id) {
-			merge(a_id, a_index, bidx, count);
-			aidx++;
-			bidx++;
-			count++;
-		} else if (a_id < b_id) {
-			pick_a(a_id, a_index, count);
-			aidx++;
-			count++;
-		} else {
-			pick_b(b_id, bidx, count);
-			bidx++;
-			count++;
-		}
-	}
-	for (; aidx < acount; aidx++) {
-		auto a_index = asel.get_index(aidx);
-		pick_a(UnsafeNumericCast<idx_t>(a[a_index]) - aoffset, a_index, count);
-		count++;
-	}
-	for (; bidx < bcount; bidx++) {
-		pick_b(b[bidx], bidx, count);
-		count++;
-	}
-	return count;
-}
-
-struct ExtractStandardEntry {
-	template <class T, class V>
-	static T Extract(V *data, idx_t entry) {
-		return data[entry];
-	}
-};
-
-struct ExtractValidityEntry {
-	template <class T, class V>
-	static T Extract(V *data, idx_t entry) {
-		return data->RowIsValid(entry);
-	}
-};
-
-template <class T, class V, class OP = ExtractStandardEntry>
-static void MergeUpdateLoopInternal(UpdateInfo &base_info, V *base_table_data, UpdateInfo &update_info,
-                                    V *update_vector_data, row_t *ids, idx_t count, const SelectionVector &sel) {
-	auto base_id = base_info.segment->column_data.start + base_info.vector_index * STANDARD_VECTOR_SIZE;
-#ifdef DEBUG
-	// all of these should be sorted, otherwise the below algorithm does not work
-	for (idx_t i = 1; i < count; i++) {
-		auto prev_idx = sel.get_index(i - 1);
-		auto idx = sel.get_index(i);
-		D_ASSERT(ids[idx] > ids[prev_idx] && ids[idx] >= row_t(base_id) &&
-		         ids[idx] < row_t(base_id + STANDARD_VECTOR_SIZE));
-	}
-#endif
-
-	// we have a new batch of updates (update, ids, count)
-	// we already have existing updates (base_info)
-	// and potentially, this transaction already has updates present (update_info)
-	// we need to merge these all together so that the latest updates get merged into base_info
-	// and the "old" values (fetched from EITHER base_info OR from base_data) get placed into update_info
-	auto base_info_data = base_info.GetData<T>();
-	auto base_tuples = base_info.GetTuples();
-	auto update_info_data = update_info.GetData<T>();
-	auto update_tuples = update_info.GetTuples();
-
-	// we first do the merging of the old values
-	// what we are trying to do here is update the "update_info" of this transaction with all the old data we require
-	// this means we need to merge (1) any previously updated values (stored in update_info->tuples)
-	// together with (2)
-	// to simplify this, we create new arrays here
-	// we memcpy these over afterwards
-	T result_values[STANDARD_VECTOR_SIZE];
-	sel_t result_ids[STANDARD_VECTOR_SIZE];
-
-	idx_t base_info_offset = 0;
-	idx_t update_info_offset = 0;
-	idx_t result_offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		// we have to merge the info for "ids[i]"
-		auto update_id = UnsafeNumericCast<idx_t>(ids[idx]) - base_id;
-
-		while (update_info_offset < update_info.N && update_tuples[update_info_offset] < update_id) {
-			// old id comes before the current id: write it
-			result_values[result_offset] = update_info_data[update_info_offset];
-			result_ids[result_offset++] = update_tuples[update_info_offset];
-			update_info_offset++;
-		}
-		// write the new id
-		if (update_info_offset < update_info.N && update_tuples[update_info_offset] == update_id) {
-			// we have an id that is equivalent in the current update info: write the update info
-			result_values[result_offset] = update_info_data[update_info_offset];
-			result_ids[result_offset++] = update_tuples[update_info_offset];
-			update_info_offset++;
-			continue;
-		}
-
-		/// now check if we have the current update_id in the base_info, or if we should fetch it from the base data
-		while (base_info_offset < base_info.N && base_tuples[base_info_offset] < update_id) {
-			base_info_offset++;
-		}
-		if (base_info_offset < base_info.N && base_tuples[base_info_offset] == update_id) {
-			// it is! we have to move the tuple from base_info->ids[base_info_offset] to update_info
-			result_values[result_offset] = base_info_data[base_info_offset];
-		} else {
-			// it is not! we have to move base_table_data[update_id] to update_info
-			result_values[result_offset] = UpdateSelectElement::Operation<T>(
-			    *base_info.segment, OP::template Extract<T, V>(base_table_data, update_id));
-		}
-		result_ids[result_offset++] = UnsafeNumericCast<sel_t>(update_id);
-	}
-	// write any remaining entries from the old updates
-	while (update_info_offset < update_info.N) {
-		result_values[result_offset] = update_info_data[update_info_offset];
-		result_ids[result_offset++] = update_tuples[update_info_offset];
-		update_info_offset++;
-	}
-	// now copy them back
-	update_info.N = UnsafeNumericCast<sel_t>(result_offset);
-	memcpy(update_info_data, result_values, result_offset * sizeof(T));
-	memcpy(update_tuples, result_ids, result_offset * sizeof(sel_t));
-
-	// now we merge the new values into the base_info
-	result_offset = 0;
-	auto pick_new = [&](idx_t id, idx_t aidx, idx_t count) {
-		result_values[result_offset] = OP::template Extract<T, V>(update_vector_data, aidx);
-		result_ids[result_offset] = UnsafeNumericCast<sel_t>(id);
-		result_offset++;
-	};
-	auto pick_old = [&](idx_t id, idx_t bidx, idx_t count) {
-		result_values[result_offset] = base_info_data[bidx];
-		result_ids[result_offset] = UnsafeNumericCast<sel_t>(id);
-		result_offset++;
-	};
-	// now we perform a merge of the new ids with the old ids
-	auto merge = [&](idx_t id, idx_t aidx, idx_t bidx, idx_t count) {
-		pick_new(id, aidx, count);
-	};
-	MergeLoop(ids, base_tuples, count, base_info.N, base_id, merge, pick_new, pick_old, sel);
-
-	base_info.N = UnsafeNumericCast<sel_t>(result_offset);
-	memcpy(base_info_data, result_values, result_offset * sizeof(T));
-	memcpy(base_tuples, result_ids, result_offset * sizeof(sel_t));
-}
-
-static void MergeValidityLoop(UpdateInfo &base_info, Vector &base_data, UpdateInfo &update_info, Vector &update,
-                              row_t *ids, idx_t count, const SelectionVector &sel) {
-	auto &base_validity = FlatVector::Validity(base_data);
-	auto &update_validity = FlatVector::Validity(update);
-	MergeUpdateLoopInternal<bool, ValidityMask, ExtractValidityEntry>(base_info, &base_validity, update_info,
-	                                                                  &update_validity, ids, count, sel);
-}
-
-template <class T>
-static void MergeUpdateLoop(UpdateInfo &base_info, Vector &base_data, UpdateInfo &update_info, Vector &update,
-                            row_t *ids, idx_t count, const SelectionVector &sel) {
-	auto base_table_data = FlatVector::GetData<T>(base_data);
-	auto update_vector_data = FlatVector::GetData<T>(update);
-	MergeUpdateLoopInternal<T, T>(base_info, base_table_data, update_info, update_vector_data, ids, count, sel);
-}
-
-static UpdateSegment::merge_update_function_t GetMergeUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return MergeValidityLoop;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return MergeUpdateLoop<int8_t>;
-	case PhysicalType::INT16:
-		return MergeUpdateLoop<int16_t>;
-	case PhysicalType::INT32:
-		return MergeUpdateLoop<int32_t>;
-	case PhysicalType::INT64:
-		return MergeUpdateLoop<int64_t>;
-	case PhysicalType::UINT8:
-		return MergeUpdateLoop<uint8_t>;
-	case PhysicalType::UINT16:
-		return MergeUpdateLoop<uint16_t>;
-	case PhysicalType::UINT32:
-		return MergeUpdateLoop<uint32_t>;
-	case PhysicalType::UINT64:
-		return MergeUpdateLoop<uint64_t>;
-	case PhysicalType::INT128:
-		return MergeUpdateLoop<hugeint_t>;
-	case PhysicalType::UINT128:
-		return MergeUpdateLoop<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return MergeUpdateLoop<float>;
-	case PhysicalType::DOUBLE:
-		return MergeUpdateLoop<double>;
-	case PhysicalType::INTERVAL:
-		return MergeUpdateLoop<interval_t>;
-	case PhysicalType::VARCHAR:
-		return MergeUpdateLoop<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for uncompressed segment");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Update statistics
-//===--------------------------------------------------------------------===//
-unique_ptr<BaseStatistics> UpdateSegment::GetStatistics() {
-	lock_guard<mutex> stats_guard(stats_lock);
-	return stats.statistics.ToUnique();
-}
-
-idx_t UpdateValidityStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
-                               SelectionVector &sel) {
-	auto &mask = FlatVector::Validity(update);
-	auto &validity = stats.statistics;
-	if (!mask.AllValid() && !validity.CanHaveNull()) {
-		for (idx_t i = 0; i < count; i++) {
-			if (!mask.RowIsValid(i)) {
-				validity.SetHasNullFast();
-				break;
-			}
-		}
-	}
-	sel.Initialize(nullptr);
-	return count;
-}
-
-template <class T>
-idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
-                                       SelectionVector &sel) {
-	auto update_data = FlatVector::GetData<T>(update);
-	auto &mask = FlatVector::Validity(update);
-
-	if (mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			stats.statistics.UpdateNumericStats<T>(update_data[i]);
-		}
-		sel.Initialize(nullptr);
-		return count;
-	} else {
-		idx_t not_null_count = 0;
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			if (mask.RowIsValid(i)) {
-				sel.set_index(not_null_count++, i);
-				stats.statistics.UpdateNumericStats<T>(update_data[i]);
-			}
-		}
-		return not_null_count;
-	}
-}
-
-idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
-                             SelectionVector &sel) {
-	auto update_data = FlatVector::GetData<string_t>(update);
-	auto &mask = FlatVector::Validity(update);
-	if (mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			StringStats::Update(stats.statistics, update_data[i]);
-			if (!update_data[i].IsInlined()) {
-				update_data[i] = segment->GetStringHeap().AddBlob(update_data[i]);
-			}
-		}
-		sel.Initialize(nullptr);
-		return count;
-	} else {
-		idx_t not_null_count = 0;
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			if (mask.RowIsValid(i)) {
-				sel.set_index(not_null_count++, i);
-				StringStats::Update(stats.statistics, update_data[i]);
-				if (!update_data[i].IsInlined()) {
-					update_data[i] = segment->GetStringHeap().AddBlob(update_data[i]);
-				}
-			}
-		}
-		return not_null_count;
-	}
-}
-
-UpdateSegment::statistics_update_function_t GetStatisticsUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return UpdateValidityStatistics;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedUpdateNumericStatistics<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedUpdateNumericStatistics<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedUpdateNumericStatistics<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedUpdateNumericStatistics<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedUpdateNumericStatistics<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedUpdateNumericStatistics<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedUpdateNumericStatistics<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedUpdateNumericStatistics<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedUpdateNumericStatistics<hugeint_t>;
-	case PhysicalType::UINT128:
-		return TemplatedUpdateNumericStatistics<uhugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedUpdateNumericStatistics<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedUpdateNumericStatistics<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedUpdateNumericStatistics<interval_t>;
-	case PhysicalType::VARCHAR:
-		return UpdateStringStatistics;
-	default:
-		throw NotImplementedException("Unimplemented type for uncompressed segment");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Update
-//===--------------------------------------------------------------------===//
-static idx_t SortSelectionVector(SelectionVector &sel, idx_t count, row_t *ids) {
-	D_ASSERT(count > 0);
-
-	bool is_sorted = true;
-	for (idx_t i = 1; i < count; i++) {
-		auto prev_idx = sel.get_index(i - 1);
-		auto idx = sel.get_index(i);
-		if (ids[idx] <= ids[prev_idx]) {
-			is_sorted = false;
-			break;
-		}
-	}
-	if (is_sorted) {
-		// already sorted: bailout
-		return count;
-	}
-	// not sorted: need to sort the selection vector
-	SelectionVector sorted_sel(count);
-	for (idx_t i = 0; i < count; i++) {
-		sorted_sel.set_index(i, sel.get_index(i));
-	}
-	std::sort(sorted_sel.data(), sorted_sel.data() + count, [&](sel_t l, sel_t r) { return ids[l] < ids[r]; });
-	// eliminate any duplicates
-	idx_t pos = 1;
-	for (idx_t i = 1; i < count; i++) {
-		auto prev_idx = sorted_sel.get_index(i - 1);
-		auto idx = sorted_sel.get_index(i);
-		D_ASSERT(ids[idx] >= ids[prev_idx]);
-		if (ids[prev_idx] != ids[idx]) {
-			sorted_sel.set_index(pos++, idx);
-		}
-	}
-#ifdef DEBUG
-	for (idx_t i = 1; i < pos; i++) {
-		auto prev_idx = sorted_sel.get_index(i - 1);
-		auto idx = sorted_sel.get_index(i);
-		D_ASSERT(ids[idx] > ids[prev_idx]);
-	}
-#endif
-
-	sel.Initialize(sorted_sel);
-	D_ASSERT(pos > 0);
-	return pos;
-}
-
-UpdateInfo *CreateEmptyUpdateInfo(TransactionData transaction, idx_t type_size, idx_t count,
-                                  unsafe_unique_array<char> &data) {
-	data = make_unsafe_uniq_array_uninitialized<char>(UpdateInfo::GetAllocSize(type_size));
-	auto update_info = reinterpret_cast<UpdateInfo *>(data.get());
-	UpdateInfo::Initialize(*update_info, transaction.transaction_id);
-	return update_info;
-}
-
-void UpdateSegment::InitializeUpdateInfo(idx_t vector_idx) {
-	// create the versions for this segment, if there are none yet
-	if (!root) {
-		root = make_uniq<UpdateNode>(column_data.block_manager.buffer_manager);
-	}
-	if (vector_idx < root->info.size()) {
-		return;
-	}
-	root->info.reserve(vector_idx + 1);
-	for (idx_t i = root->info.size(); i <= vector_idx; i++) {
-		root->info.emplace_back();
-	}
-}
-
-void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
-                           Vector &base_data) {
-	// obtain an exclusive lock
-	auto write_lock = lock.GetExclusiveLock();
-
-	update.Flatten(count);
-
-	// update statistics
-	SelectionVector sel;
-	{
-		lock_guard<mutex> stats_guard(stats_lock);
-		count = statistics_update_function(this, stats, update, count, sel);
-	}
-	if (count == 0) {
-		return;
-	}
-
-	// subsequent algorithms used by the update require row ids to be (1) sorted, and (2) unique
-	// this is usually the case for "standard" queries (e.g. UPDATE tbl SET x=bla WHERE cond)
-	// however, for more exotic queries involving e.g. cross products/joins this might not be the case
-	// hence we explicitly check here if the ids are sorted and, if not, sort + duplicate eliminate them
-	count = SortSelectionVector(sel, count, ids);
-	D_ASSERT(count > 0);
-
-	// get the vector index based on the first id
-	// we assert that all updates must be part of the same vector
-	auto first_id = ids[sel.get_index(0)];
-	idx_t vector_index = (UnsafeNumericCast<idx_t>(first_id) - column_data.start) / STANDARD_VECTOR_SIZE;
-	idx_t vector_offset = column_data.start + vector_index * STANDARD_VECTOR_SIZE;
-	InitializeUpdateInfo(vector_index);
-
-	D_ASSERT(idx_t(first_id) >= column_data.start);
-
-	if (root->info[vector_index].IsSet()) {
-		// there is already a version here, check if there are any conflicts and search for the node that belongs to
-		// this transaction in the version chain
-		auto root_pointer = root->info[vector_index];
-		auto root_pin = root_pointer.Pin();
-		auto &base_info = UpdateInfo::Get(root_pin);
-
-		UndoBufferReference node_ref;
-		CheckForConflicts(base_info.next, transaction, ids, sel, count, UnsafeNumericCast<row_t>(vector_offset),
-		                  node_ref);
-
-		// there are no conflicts - continue with the update
-		unsafe_unique_array<char> update_info_data;
-		optional_ptr<UpdateInfo> node;
-		if (!node_ref.IsSet()) {
-			// no updates made yet by this transaction: initially the update info to empty
-			if (transaction.transaction) {
-				auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-				node_ref = dtransaction.CreateUpdateInfo(type_size, count);
-				node = &UpdateInfo::Get(node_ref);
-			} else {
-				node = CreateEmptyUpdateInfo(transaction, type_size, count, update_info_data);
-			}
-			node->segment = this;
-			node->vector_index = vector_index;
-			node->N = 0;
-			node->column_index = column_index;
-
-			// insert the new node into the chain
-			node->next = base_info.next;
-			if (node->next.IsSet()) {
-				auto next_pin = node->next.Pin();
-				auto &next_info = UpdateInfo::Get(next_pin);
-				next_info.prev = node_ref.GetBufferPointer();
-			}
-			node->prev = root_pointer;
-			base_info.next = transaction.transaction ? node_ref.GetBufferPointer() : UndoBufferPointer();
-		} else {
-			// we already had updates made to this transaction
-			node = &UpdateInfo::Get(node_ref);
-		}
-		base_info.Verify();
-		node->Verify();
-
-		// now we are going to perform the merge
-		merge_update_function(base_info, base_data, *node, update, ids, count, sel);
-
-		base_info.Verify();
-		node->Verify();
-	} else {
-		// there is no version info yet: create the top level update info and fill it with the updates
-		// allocate space for the UpdateInfo in the allocator
-		idx_t alloc_size = UpdateInfo::GetAllocSize(type_size);
-		auto handle = root->allocator.Allocate(alloc_size);
-		auto &update_info = UpdateInfo::Get(handle);
-		UpdateInfo::Initialize(update_info, TRANSACTION_ID_START - 1);
-		update_info.column_index = column_index;
-
-		InitializeUpdateInfo(update_info, ids, sel, count, vector_index, vector_offset);
-
-		// now create the transaction level update info in the undo log
-		unsafe_unique_array<char> update_info_data;
-		UndoBufferReference node_ref;
-		optional_ptr<UpdateInfo> transaction_node;
-		if (transaction.transaction) {
-			node_ref = transaction.transaction->CreateUpdateInfo(type_size, count);
-			transaction_node = &UpdateInfo::Get(node_ref);
-		} else {
-			transaction_node = CreateEmptyUpdateInfo(transaction, type_size, count, update_info_data);
-		}
-
-		InitializeUpdateInfo(*transaction_node, ids, sel, count, vector_index, vector_offset);
-
-		// we write the updates in the update node data, and write the updates in the info
-		initialize_update_function(*transaction_node, base_data, update_info, update, sel);
-
-		update_info.next = transaction.transaction ? node_ref.GetBufferPointer() : UndoBufferPointer();
-		update_info.prev = UndoBufferPointer();
-		transaction_node->next = UndoBufferPointer();
-		transaction_node->prev = handle.GetBufferPointer();
-		transaction_node->column_index = column_index;
-
-		transaction_node->Verify();
-		update_info.Verify();
-
-		root->info[vector_index] = handle.GetBufferPointer();
-	}
-}
-
-bool UpdateSegment::HasUpdates() const {
-	return root.get() != nullptr;
-}
-
-bool UpdateSegment::HasUpdates(idx_t vector_index) const {
-	auto read_lock = lock.GetSharedLock();
-	return GetUpdateNode(vector_index).IsSet();
-}
-
-bool UpdateSegment::HasUncommittedUpdates(idx_t vector_index) {
-	auto read_lock = lock.GetSharedLock();
-	auto entry = GetUpdateNode(vector_index);
-	if (!entry.IsSet()) {
-		return false;
-	}
-	auto pin = entry.Pin();
-	auto &info = UpdateInfo::Get(pin);
-	if (info.HasNext()) {
-		return true;
-	}
-	return false;
-}
-
-bool UpdateSegment::HasUpdates(idx_t start_row_index, idx_t end_row_index) {
-	auto read_lock = lock.GetSharedLock();
-	if (!root) {
-		return false;
-	}
-	idx_t base_vector_index = start_row_index / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_index = end_row_index / STANDARD_VECTOR_SIZE;
-	for (idx_t i = base_vector_index; i <= end_vector_index; i++) {
-		auto entry = GetUpdateNode(i);
-		if (entry.IsSet()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table/validity_column_data.cpp b/src/duckdb/src/storage/table/validity_column_data.cpp
deleted file mode 100644
index fc8a9e1ea..000000000
--- a/src/duckdb/src/storage/table/validity_column_data.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "duckdb/storage/table/validity_column_data.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-
-namespace duckdb {
-
-ValidityColumnData::ValidityColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-                                       idx_t start_row, ColumnData &parent)
-    : ColumnData(block_manager, info, column_index, start_row, LogicalType(LogicalTypeId::VALIDITY), &parent) {
-}
-
-FilterPropagateResult ValidityColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-void ValidityColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
-                                    idx_t count) {
-	lock_guard<mutex> l(stats_lock);
-	ColumnData::AppendData(stats, state, vdata, count);
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/table_index_list.cpp b/src/duckdb/src/storage/table_index_list.cpp
deleted file mode 100644
index 010162e84..000000000
--- a/src/duckdb/src/storage/table_index_list.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-#include "duckdb/storage/table/table_index_list.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/common/types/conflict_manager.hpp"
-#include "duckdb/execution/index/index_type_set.hpp"
-#include "duckdb/execution/index/unbound_index.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/planner/expression_binder/index_binder.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/data_table_info.hpp"
-
-namespace duckdb {
-
-void TableIndexList::AddIndex(unique_ptr<Index> index) {
-	D_ASSERT(index);
-	lock_guard<mutex> lock(indexes_lock);
-	indexes.push_back(std::move(index));
-}
-
-void TableIndexList::RemoveIndex(const string &name) {
-	lock_guard<mutex> lock(indexes_lock);
-
-	for (idx_t i = 0; i < indexes.size(); i++) {
-		auto &index = indexes[i];
-		if (index->GetIndexName() == name) {
-			indexes.erase_at(i);
-			break;
-		}
-	}
-}
-
-void TableIndexList::CommitDrop(const string &name) {
-	lock_guard<mutex> lock(indexes_lock);
-
-	for (auto &index : indexes) {
-		if (index->GetIndexName() == name) {
-			index->CommitDrop();
-		}
-	}
-}
-
-bool TableIndexList::NameIsUnique(const string &name) {
-	lock_guard<mutex> lock(indexes_lock);
-
-	// Only covers PK, FK, and UNIQUE indexes.
-	for (const auto &index : indexes) {
-		if (index->IsPrimary() || index->IsForeign() || index->IsUnique()) {
-			if (index->GetIndexName() == name) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-optional_ptr<BoundIndex> TableIndexList::Find(const string &name) {
-	for (auto &index : indexes) {
-		if (index->GetIndexName() == name) {
-			return index->Cast<BoundIndex>();
-		}
-	}
-	return nullptr;
-}
-
-void TableIndexList::InitializeIndexes(ClientContext &context, DataTableInfo &table_info, const char *index_type) {
-	// Fast path: do we have any unbound indexes?
-	bool needs_binding = false;
-	{
-		lock_guard<mutex> lock(indexes_lock);
-		for (auto &index : indexes) {
-			if (!index->IsBound() && (index_type == nullptr || index->GetIndexType() == index_type)) {
-				needs_binding = true;
-				break;
-			}
-		}
-	}
-	if (!needs_binding) {
-		return;
-	}
-
-	// Get the table from the catalog, so we can add it to the binder.
-	auto &catalog = table_info.GetDB().GetCatalog();
-	auto schema = table_info.GetSchemaName();
-	auto table_name = table_info.GetTableName();
-	auto &table_entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, schema, table_name);
-	auto &table = table_entry.Cast<DuckTableEntry>();
-
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	for (auto &col : table.GetColumns().Logical()) {
-		column_types.push_back(col.Type());
-		column_names.push_back(col.Name());
-	}
-
-	lock_guard<mutex> lock(indexes_lock);
-	for (auto &index : indexes) {
-		if (!index->IsBound() && (index_type == nullptr || index->GetIndexType() == index_type)) {
-			// Create a binder to bind this index.
-			auto binder = Binder::CreateBinder(context);
-
-			// Add the table to the binder.
-			vector<ColumnIndex> dummy_column_ids;
-			binder->bind_context.AddBaseTable(0, string(), column_names, column_types, dummy_column_ids, table);
-
-			// Create an IndexBinder to bind the index
-			IndexBinder idx_binder(*binder, context);
-
-			// Replace the unbound index with a bound index.
-			auto bound_idx = idx_binder.BindIndex(index->Cast<UnboundIndex>());
-			index = std::move(bound_idx);
-		}
-	}
-}
-
-bool TableIndexList::Empty() {
-	lock_guard<mutex> lock(indexes_lock);
-	return indexes.empty();
-}
-
-idx_t TableIndexList::Count() {
-	lock_guard<mutex> lock(indexes_lock);
-	return indexes.size();
-}
-
-void TableIndexList::Move(TableIndexList &other) {
-	D_ASSERT(indexes.empty());
-	indexes = std::move(other.indexes);
-}
-
-Index *TableIndexList::FindForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, const ForeignKeyType fk_type) {
-	for (auto &index : indexes) {
-		if (DataTable::IsForeignKeyIndex(fk_keys, *index, fk_type)) {
-			return &(*index);
-		}
-	}
-	return nullptr;
-}
-
-void TableIndexList::VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, DataChunk &chunk,
-                                      ConflictManager &conflict_manager) {
-	auto fk_type = conflict_manager.LookupType() == VerifyExistenceType::APPEND_FK
-	                   ? ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE
-	                   : ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-
-	// Check whether the chunk can be inserted or deleted into the referenced table storage.
-	auto index = FindForeignKeyIndex(fk_keys, fk_type);
-	if (!index) {
-		throw InternalException("Internal Foreign Key error: could not find index to verify...");
-	}
-	if (!index->IsBound()) {
-		throw InternalException("Internal Foreign Key error: trying to verify an unbound index...");
-	}
-	index->Cast<BoundIndex>().VerifyConstraint(chunk, nullptr, conflict_manager);
-}
-
-unordered_set<column_t> TableIndexList::GetRequiredColumns() {
-	lock_guard<mutex> lock(indexes_lock);
-	unordered_set<column_t> column_ids;
-	for (auto &index : indexes) {
-		for (auto col_id : index->GetColumnIds()) {
-			column_ids.insert(col_id);
-		}
-	}
-	return column_ids;
-}
-
-vector<IndexStorageInfo> TableIndexList::GetStorageInfos(const case_insensitive_map_t<Value> &options) {
-	vector<IndexStorageInfo> infos;
-	for (auto &index : indexes) {
-		if (index->IsBound()) {
-			auto info = index->Cast<BoundIndex>().GetStorageInfo(options, false);
-			D_ASSERT(info.IsValid() && !info.name.empty());
-			infos.push_back(info);
-			continue;
-		}
-
-		auto info = index->Cast<UnboundIndex>().GetStorageInfo();
-		D_ASSERT(info.IsValid() && !info.name.empty());
-		infos.push_back(info);
-	}
-
-	return infos;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/temporary_file_manager.cpp b/src/duckdb/src/storage/temporary_file_manager.cpp
deleted file mode 100644
index 478f5e338..000000000
--- a/src/duckdb/src/storage/temporary_file_manager.cpp
+++ /dev/null
@@ -1,693 +0,0 @@
-#include "duckdb/storage/temporary_file_manager.hpp"
-
-#include "duckdb/common/chrono.hpp"
-#include "duckdb/common/enum_util.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/storage/buffer/temporary_file_information.hpp"
-#include "duckdb/storage/standard_buffer_manager.hpp"
-#include "zstd.h"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// TemporaryBufferSize
-//===--------------------------------------------------------------------===//
-bool TemporaryBufferSizeIsValid(const TemporaryBufferSize size) {
-	switch (size) {
-	case TemporaryBufferSize::S32K:
-	case TemporaryBufferSize::S64K:
-	case TemporaryBufferSize::S96K:
-	case TemporaryBufferSize::S128K:
-	case TemporaryBufferSize::S160K:
-	case TemporaryBufferSize::S192K:
-	case TemporaryBufferSize::S224K:
-	case TemporaryBufferSize::DEFAULT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-static TemporaryBufferSize SizeToTemporaryBufferSize(const idx_t size) {
-	D_ASSERT(size != 0 && size % TEMPORARY_BUFFER_SIZE_GRANULARITY == 0);
-	const auto res = static_cast<TemporaryBufferSize>(size);
-	D_ASSERT(TemporaryBufferSizeIsValid(res));
-	return res;
-}
-
-static idx_t TemporaryBufferSizeToSize(const TemporaryBufferSize size) {
-	D_ASSERT(TemporaryBufferSizeIsValid(size));
-	return static_cast<idx_t>(size);
-}
-
-static TemporaryBufferSize RoundUpSizeToTemporaryBufferSize(const idx_t size) {
-	return SizeToTemporaryBufferSize(AlignValue<idx_t, TEMPORARY_BUFFER_SIZE_GRANULARITY>(size));
-}
-
-static const vector<TemporaryBufferSize> TemporaryBufferSizes() {
-	return {TemporaryBufferSize::S32K,  TemporaryBufferSize::S64K,   TemporaryBufferSize::S96K,
-	        TemporaryBufferSize::S128K, TemporaryBufferSize::S160K,  TemporaryBufferSize::S192K,
-	        TemporaryBufferSize::S224K, TemporaryBufferSize::DEFAULT};
-}
-
-static TemporaryBufferSize MinimumCompressedTemporaryBufferSize() {
-	return TemporaryBufferSize::S32K;
-}
-
-static TemporaryBufferSize MaximumCompressedTemporaryBufferSize() {
-	return TemporaryBufferSize::S224K;
-}
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileIdentifier/TemporaryFileIndex
-//===--------------------------------------------------------------------===//
-TemporaryFileIdentifier::TemporaryFileIdentifier() : size(TemporaryBufferSize::INVALID) {
-}
-
-TemporaryFileIdentifier::TemporaryFileIdentifier(TemporaryBufferSize size_p, idx_t file_index_p)
-    : size(size_p), file_index(file_index_p) {
-}
-
-bool TemporaryFileIdentifier::IsValid() const {
-	return size != TemporaryBufferSize::INVALID && file_index.IsValid();
-}
-
-TemporaryFileIndex::TemporaryFileIndex() {
-}
-
-TemporaryFileIndex::TemporaryFileIndex(TemporaryFileIdentifier identifier_p, idx_t block_index_p)
-    : identifier(identifier_p), block_index(block_index_p) {
-}
-
-bool TemporaryFileIndex::IsValid() const {
-	return identifier.IsValid() && block_index.IsValid();
-}
-
-//===--------------------------------------------------------------------===//
-// BlockIndexManager
-//===--------------------------------------------------------------------===//
-BlockIndexManager::BlockIndexManager() : max_index(0), manager(nullptr) {
-}
-
-BlockIndexManager::BlockIndexManager(TemporaryFileManager &manager) : max_index(0), manager(&manager) {
-}
-
-idx_t BlockIndexManager::GetNewBlockIndex(const TemporaryBufferSize size) {
-	auto index = GetNewBlockIndexInternal(size);
-	indexes_in_use.insert(index);
-	return index;
-}
-
-bool BlockIndexManager::RemoveIndex(idx_t index, const TemporaryBufferSize size) {
-	// remove this block from the set of blocks
-	auto entry = indexes_in_use.find(index);
-	if (entry == indexes_in_use.end()) {
-		throw InternalException("RemoveIndex - index %llu not found in indexes_in_use", index);
-	}
-	indexes_in_use.erase(entry);
-	free_indexes.insert(index);
-	// check if we can truncate the file
-
-	// get the max_index in use right now
-	auto max_index_in_use = indexes_in_use.empty() ? 0 : *indexes_in_use.rbegin() + 1;
-	if (max_index_in_use < max_index) {
-		// max index in use is lower than the max_index
-		// reduce the max_index
-		SetMaxIndex(max_index_in_use, size);
-		// we can remove any free_indexes that are larger than the current max_index
-		while (HasFreeBlocks()) {
-			auto max_entry = *free_indexes.rbegin();
-			if (max_entry < max_index) {
-				break;
-			}
-			free_indexes.erase(max_entry);
-		}
-		return true;
-	}
-	return false;
-}
-
-idx_t BlockIndexManager::GetMaxIndex() const {
-	return max_index;
-}
-
-bool BlockIndexManager::HasFreeBlocks() const {
-	return !free_indexes.empty();
-}
-
-idx_t BlockIndexManager::GetNewBlockIndexInternal(const TemporaryBufferSize size) {
-	if (!HasFreeBlocks()) {
-		auto new_index = max_index;
-		SetMaxIndex(max_index + 1, size);
-		return new_index;
-	}
-	auto entry = free_indexes.begin();
-	auto index = *entry;
-	free_indexes.erase(entry);
-	return index;
-}
-
-void BlockIndexManager::SetMaxIndex(const idx_t new_index, const TemporaryBufferSize size) {
-	const auto temp_file_block_size =
-	    size == TemporaryBufferSize::DEFAULT ? DEFAULT_BLOCK_ALLOC_SIZE : TemporaryBufferSizeToSize(size);
-	if (!manager) {
-		max_index = new_index;
-	} else {
-		auto old = max_index;
-		if (new_index < old) {
-			max_index = new_index;
-			const auto difference = old - new_index;
-			const auto size_on_disk = difference * temp_file_block_size;
-			manager->DecreaseSizeOnDisk(size_on_disk);
-		} else if (new_index > old) {
-			const auto difference = new_index - old;
-			const auto size_on_disk = difference * temp_file_block_size;
-			manager->IncreaseSizeOnDisk(size_on_disk);
-			// Increase can throw, so this is only updated after it was successfully updated
-			max_index = new_index;
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileHandle
-//===--------------------------------------------------------------------===//
-TemporaryFileHandle::TemporaryFileHandle(TemporaryFileManager &manager, TemporaryFileIdentifier identifier_p,
-                                         idx_t temp_file_count)
-    : db(manager.db), identifier(identifier_p), max_allowed_index((1 << temp_file_count) * MAX_ALLOWED_INDEX_BASE),
-      path(manager.CreateTemporaryFileName(identifier)), index_manager(manager) {
-}
-
-TemporaryFileHandle::TemporaryFileLock::TemporaryFileLock(mutex &mutex) : lock(mutex) {
-}
-
-TemporaryFileIndex TemporaryFileHandle::TryGetBlockIndex() {
-	TemporaryFileLock lock(file_lock);
-	if (index_manager.GetMaxIndex() >= max_allowed_index && index_manager.HasFreeBlocks()) {
-		// file is at capacity
-		return TemporaryFileIndex();
-	}
-	// open the file handle if it does not yet exist
-	CreateFileIfNotExists(lock);
-	// fetch a new block index to write to
-	auto block_index = index_manager.GetNewBlockIndex(identifier.size);
-	return TemporaryFileIndex(identifier, block_index);
-}
-
-unique_ptr<FileBuffer> TemporaryFileHandle::ReadTemporaryBuffer(idx_t block_index,
-                                                                unique_ptr<FileBuffer> reusable_buffer) const {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	if (identifier.size == TemporaryBufferSize::DEFAULT) {
-		return StandardBufferManager::ReadTemporaryBufferInternal(
-		    buffer_manager, *handle, GetPositionInFile(block_index), buffer_manager.GetBlockSize(),
-		    std::move(reusable_buffer));
-	}
-
-	// Read compressed buffer
-	auto compressed_buffer = Allocator::Get(db).Allocate(TemporaryBufferSizeToSize(identifier.size));
-	handle->Read(compressed_buffer.get(), compressed_buffer.GetSize(), GetPositionInFile(block_index));
-
-	// Decompress into buffer
-	auto buffer = buffer_manager.ConstructManagedBuffer(buffer_manager.GetBlockSize(), std::move(reusable_buffer));
-
-	const auto compressed_size = Load<idx_t>(compressed_buffer.get());
-	D_ASSERT(!duckdb_zstd::ZSTD_isError(compressed_size));
-	const auto decompressed_size = duckdb_zstd::ZSTD_decompress(
-	    buffer->InternalBuffer(), buffer->AllocSize(), compressed_buffer.get() + sizeof(idx_t), compressed_size);
-	(void)decompressed_size;
-	D_ASSERT(!duckdb_zstd::ZSTD_isError(decompressed_size));
-
-	D_ASSERT(decompressed_size == buffer->AllocSize());
-	return buffer;
-}
-
-void TemporaryFileHandle::WriteTemporaryBuffer(FileBuffer &buffer, const idx_t block_index,
-                                               AllocatedData &compressed_buffer) const {
-	// We group DEFAULT_BLOCK_ALLOC_SIZE blocks into the same file.
-	D_ASSERT(buffer.AllocSize() == BufferManager::GetBufferManager(db).GetBlockAllocSize());
-	if (identifier.size == TemporaryBufferSize::DEFAULT) {
-		buffer.Write(*handle, GetPositionInFile(block_index));
-	} else {
-		handle->Write(compressed_buffer.get(), TemporaryBufferSizeToSize(identifier.size),
-		              GetPositionInFile(block_index));
-	}
-}
-
-void TemporaryFileHandle::EraseBlockIndex(block_id_t block_index) {
-	// remove the block (and potentially truncate the temp file)
-	TemporaryFileLock lock(file_lock);
-	D_ASSERT(handle);
-	RemoveTempBlockIndex(lock, NumericCast<idx_t>(block_index));
-}
-
-bool TemporaryFileHandle::DeleteIfEmpty() {
-	TemporaryFileLock lock(file_lock);
-	if (index_manager.GetMaxIndex() > 0) {
-		// there are still blocks in this file
-		return false;
-	}
-	// the file is empty: delete it
-	handle.reset();
-	auto &fs = FileSystem::GetFileSystem(db);
-	fs.RemoveFile(path);
-	return true;
-}
-
-TemporaryFileInformation TemporaryFileHandle::GetTemporaryFile() {
-	TemporaryFileLock lock(file_lock);
-	TemporaryFileInformation info;
-	info.path = path;
-	info.size = GetPositionInFile(index_manager.GetMaxIndex());
-	return info;
-}
-
-void TemporaryFileHandle::CreateFileIfNotExists(TemporaryFileLock &) {
-	if (handle) {
-		return;
-	}
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto open_flags = FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE;
-	handle = fs.OpenFile(path, open_flags);
-}
-
-void TemporaryFileHandle::RemoveTempBlockIndex(TemporaryFileLock &, idx_t index) {
-	// remove the block index from the index manager
-	if (index_manager.RemoveIndex(index, identifier.size)) {
-		// the max_index that is currently in use has decreased
-		// as a result we can truncate the file
-#ifndef WIN32 // this ended up causing issues when sorting
-		auto max_index = index_manager.GetMaxIndex();
-		auto &fs = FileSystem::GetFileSystem(db);
-		fs.Truncate(*handle, NumericCast<int64_t>(GetPositionInFile(max_index + 1)));
-#endif
-	}
-}
-
-idx_t TemporaryFileHandle::GetPositionInFile(const idx_t index) const {
-	return index * static_cast<idx_t>(identifier.size);
-}
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileMap
-//===--------------------------------------------------------------------===//
-TemporaryFileMap::TemporaryFileMap(TemporaryFileManager &manager_p) : manager(manager_p) {
-}
-
-void TemporaryFileMap::Clear() {
-	files.clear();
-}
-
-TemporaryFileMap::temporary_file_map_t &TemporaryFileMap::GetMapForSize(const TemporaryBufferSize size) {
-	D_ASSERT(TemporaryBufferSizeIsValid(size));
-	return files[size];
-}
-
-optional_ptr<TemporaryFileHandle> TemporaryFileMap::GetFile(const TemporaryFileIdentifier &identifier) {
-	D_ASSERT(identifier.IsValid());
-	auto &map = GetMapForSize(identifier.size);
-	const auto it = map.find(identifier.file_index.GetIndex());
-	return it == map.end() ? nullptr : it->second.get();
-}
-
-TemporaryFileHandle &TemporaryFileMap::CreateFile(const TemporaryFileIdentifier &identifier) {
-	D_ASSERT(identifier.IsValid());
-	D_ASSERT(!GetFile(identifier));
-	auto &map = GetMapForSize(identifier.size);
-	const auto res =
-	    map.emplace(identifier.file_index.GetIndex(), make_uniq<TemporaryFileHandle>(manager, identifier, map.size()));
-	D_ASSERT(res.second);
-	return *res.first->second;
-}
-
-void TemporaryFileMap::EraseFile(const TemporaryFileIdentifier &identifier) {
-	D_ASSERT(identifier.IsValid());
-	D_ASSERT(GetFile(identifier));
-	GetMapForSize(identifier.size).erase(identifier.file_index.GetIndex());
-}
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileCompressionLevel/TemporaryFileCompressionAdaptivity
-//===--------------------------------------------------------------------===//
-TemporaryFileCompressionAdaptivity::TemporaryFileCompressionAdaptivity() : last_uncompressed_write_ns(INITIAL_NS) {
-	for (idx_t i = 0; i < LEVELS; i++) {
-		last_compressed_writes_ns[i] = INITIAL_NS;
-	}
-}
-
-int64_t TemporaryFileCompressionAdaptivity::GetCurrentTimeNanos() {
-	return duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
-}
-
-TemporaryCompressionLevel TemporaryFileCompressionAdaptivity::IndexToLevel(const idx_t index) {
-	return static_cast<TemporaryCompressionLevel>(NumericCast<int>(index) * 2 - 5);
-}
-
-idx_t TemporaryFileCompressionAdaptivity::LevelToIndex(const TemporaryCompressionLevel level) {
-	return NumericCast<idx_t>((static_cast<int>(level) + 5) / 2);
-}
-
-TemporaryCompressionLevel TemporaryFileCompressionAdaptivity::MinimumCompressionLevel() {
-	return IndexToLevel(0);
-}
-
-TemporaryCompressionLevel TemporaryFileCompressionAdaptivity::MaximumCompressionLevel() {
-	return IndexToLevel(LEVELS - 1);
-}
-
-TemporaryCompressionLevel TemporaryFileCompressionAdaptivity::GetCompressionLevel() {
-	idx_t min_compression_idx = 0;
-	TemporaryCompressionLevel level;
-
-	double ratio;
-	bool should_compress;
-
-	bool should_deviate;
-	bool deviate_uncompressed;
-	{
-		lock_guard<mutex> guard(random_engine.lock);
-
-		auto min_compressed_time = last_compressed_writes_ns[min_compression_idx];
-		for (idx_t compression_idx = 1; compression_idx < LEVELS; compression_idx++) {
-			const auto time = last_compressed_writes_ns[compression_idx];
-			if (time < min_compressed_time) {
-				min_compression_idx = compression_idx;
-				min_compressed_time = time;
-			}
-		}
-		level = IndexToLevel(min_compression_idx);
-
-		ratio = static_cast<double>(min_compressed_time) / static_cast<double>(last_uncompressed_write_ns);
-		should_compress = ratio < DURATION_RATIO_THRESHOLD;
-
-		should_deviate = random_engine.NextRandom() < COMPRESSION_DEVIATION;
-		deviate_uncompressed = random_engine.NextRandom() < 0.5; // Coin flip to deviate with just uncompressed
-	}
-
-	TemporaryCompressionLevel result;
-	if (!should_deviate) {
-		result = should_compress ? level : TemporaryCompressionLevel::UNCOMPRESSED; // Don't deviate
-	} else if (!should_compress) {
-		result = MinimumCompressionLevel(); // Deviate from uncompressed -> go to fastest level
-	} else if (deviate_uncompressed) {
-		result = TemporaryCompressionLevel::UNCOMPRESSED;
-	} else if (level == MaximumCompressionLevel()) {
-		result = IndexToLevel(min_compression_idx - 1); // At highest level, go down one
-	} else if (ratio < 1.0) { // Compressed writes are faster, try increasing the compression level
-		result = IndexToLevel(min_compression_idx + 1);
-	} else { // Compressed writes are slower, try decreasing the compression level
-		result = level == MinimumCompressionLevel()
-		             ? TemporaryCompressionLevel::UNCOMPRESSED // Already lowest level, go to uncompressed
-		             : IndexToLevel(min_compression_idx - 1);
-	}
-	return result;
-}
-
-void TemporaryFileCompressionAdaptivity::Update(const TemporaryCompressionLevel level, const int64_t time_before_ns) {
-	const auto duration = GetCurrentTimeNanos() - time_before_ns;
-	auto &last_write_ns = level == TemporaryCompressionLevel::UNCOMPRESSED
-	                          ? last_uncompressed_write_ns
-	                          : last_compressed_writes_ns[LevelToIndex(level)];
-	lock_guard<mutex> guard(random_engine.lock);
-	last_write_ns = (last_write_ns * (WEIGHT - 1) + duration) / WEIGHT;
-}
-
-//===--------------------------------------------------------------------===//
-// TemporaryFileManager
-//===--------------------------------------------------------------------===//
-TemporaryFileManager::TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p)
-    : db(db), temp_directory(temp_directory_p), files(*this), size_on_disk(0), max_swap_space(0) {
-}
-
-TemporaryFileManager::~TemporaryFileManager() {
-	files.Clear();
-}
-
-TemporaryFileManager::TemporaryFileManagerLock::TemporaryFileManagerLock(mutex &mutex) : lock(mutex) {
-}
-
-void TemporaryFileManager::WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) {
-	// We group DEFAULT_BLOCK_ALLOC_SIZE blocks into the same file.
-	D_ASSERT(buffer.AllocSize() == BufferManager::GetBufferManager(db).GetBlockAllocSize());
-
-	const auto adaptivity_idx = TaskScheduler::GetEstimatedCPUId() % COMPRESSION_ADAPTIVITIES;
-	auto &compression_adaptivity = compression_adaptivities[adaptivity_idx];
-
-	const auto time_before_ns = TemporaryFileCompressionAdaptivity::GetCurrentTimeNanos();
-	AllocatedData compressed_buffer;
-	const auto compression_result = CompressBuffer(compression_adaptivity, buffer, compressed_buffer);
-
-	TemporaryFileIndex index;
-	optional_ptr<TemporaryFileHandle> handle;
-	{
-		TemporaryFileManagerLock lock(manager_lock);
-		// first check if we can write to an open existing file
-		for (auto &entry : files.GetMapForSize(compression_result.size)) {
-			auto &temp_file = entry.second;
-			index = temp_file->TryGetBlockIndex();
-			if (index.IsValid()) {
-				handle = entry.second.get();
-				break;
-			}
-		}
-		if (!handle) {
-			// no existing handle to write to; we need to create & open a new file
-			auto &size = compression_result.size;
-			const TemporaryFileIdentifier identifier(size, index_managers[size].GetNewBlockIndex(size));
-			auto &new_file = files.CreateFile(identifier);
-			index = new_file.TryGetBlockIndex();
-			handle = &new_file;
-		}
-		D_ASSERT(used_blocks.find(block_id) == used_blocks.end());
-		used_blocks[block_id] = index;
-	}
-	D_ASSERT(handle);
-	D_ASSERT(index.IsValid());
-
-	handle->WriteTemporaryBuffer(buffer, index.block_index.GetIndex(), compressed_buffer);
-
-	compression_adaptivity.Update(compression_result.level, time_before_ns);
-}
-
-TemporaryFileManager::CompressionResult
-TemporaryFileManager::CompressBuffer(TemporaryFileCompressionAdaptivity &compression_adaptivity, FileBuffer &buffer,
-                                     AllocatedData &compressed_buffer) {
-	if (buffer.AllocSize() <= TemporaryBufferSizeToSize(MinimumCompressedTemporaryBufferSize())) {
-		// Buffer size is less or equal to the minimum compressed size - no point compressing
-		return {TemporaryBufferSize::DEFAULT, TemporaryCompressionLevel::UNCOMPRESSED};
-	}
-
-	const auto level = compression_adaptivity.GetCompressionLevel();
-	if (level == TemporaryCompressionLevel::UNCOMPRESSED) {
-		return {TemporaryBufferSize::DEFAULT, TemporaryCompressionLevel::UNCOMPRESSED};
-	}
-
-	const auto compression_level = static_cast<int>(level);
-	D_ASSERT(compression_level >= duckdb_zstd::ZSTD_minCLevel() && compression_level <= duckdb_zstd::ZSTD_maxCLevel());
-	const auto zstd_bound = duckdb_zstd::ZSTD_compressBound(buffer.AllocSize());
-	compressed_buffer = Allocator::Get(db).Allocate(sizeof(idx_t) + zstd_bound);
-	const auto zstd_size = duckdb_zstd::ZSTD_compress(compressed_buffer.get() + sizeof(idx_t), zstd_bound,
-	                                                  buffer.InternalBuffer(), buffer.AllocSize(), compression_level);
-	D_ASSERT(!duckdb_zstd::ZSTD_isError(zstd_size));
-	Store<idx_t>(zstd_size, compressed_buffer.get());
-	const auto compressed_size = sizeof(idx_t) + zstd_size;
-
-	if (compressed_size > TemporaryBufferSizeToSize(MaximumCompressedTemporaryBufferSize())) {
-		return {TemporaryBufferSize::DEFAULT, level}; // Use default size if compression ratio is bad
-	}
-
-	return {RoundUpSizeToTemporaryBufferSize(compressed_size), level};
-}
-
-bool TemporaryFileManager::HasTemporaryBuffer(block_id_t block_id) {
-	lock_guard<mutex> lock(manager_lock);
-	return used_blocks.find(block_id) != used_blocks.end();
-}
-
-idx_t TemporaryFileManager::GetTotalUsedSpaceInBytes() const {
-	return size_on_disk.load();
-}
-
-optional_idx TemporaryFileManager::GetMaxSwapSpace() const {
-	return max_swap_space;
-}
-
-static idx_t GetDefaultMax(const string &path) {
-	D_ASSERT(!path.empty());
-	auto disk_space = FileSystem::GetAvailableDiskSpace(path);
-	// Use the available disk space
-	// We have made sure that the file exists before we call this, it shouldn't fail
-	if (!disk_space.IsValid()) {
-		// But if it does (i.e because the system call is not implemented)
-		// we don't cap the available swap space
-		return DConstants::INVALID_INDEX - 1;
-	}
-	// Only use 90% of the available disk space
-	return static_cast<idx_t>(static_cast<double>(disk_space.GetIndex()) * 0.9);
-}
-
-void TemporaryFileManager::SetMaxSwapSpace(optional_idx limit) {
-	idx_t new_limit;
-	if (limit.IsValid()) {
-		new_limit = limit.GetIndex();
-	} else {
-		new_limit = GetDefaultMax(temp_directory);
-	}
-
-	auto current_size_on_disk = GetTotalUsedSpaceInBytes();
-	if (current_size_on_disk > new_limit) {
-		auto used = StringUtil::BytesToHumanReadableString(current_size_on_disk);
-		auto max = StringUtil::BytesToHumanReadableString(new_limit);
-		throw OutOfMemoryException(
-		    R"(failed to adjust the 'max_temp_directory_size', currently used space (%s) exceeds the new limit (%s)
-Please increase the limit or destroy the buffers stored in the temp directory by e.g removing temporary tables.
-To get usage information of the temp_directory, use 'CALL duckdb_temporary_files();'
-		)",
-		    used, max);
-	}
-	max_swap_space = new_limit;
-}
-
-void TemporaryFileManager::IncreaseSizeOnDisk(idx_t bytes) {
-	auto current_size_on_disk = GetTotalUsedSpaceInBytes();
-	if (current_size_on_disk + bytes > max_swap_space) {
-		auto used = StringUtil::BytesToHumanReadableString(current_size_on_disk);
-		auto max = StringUtil::BytesToHumanReadableString(max_swap_space);
-		auto data_size = StringUtil::BytesToHumanReadableString(bytes);
-		throw OutOfMemoryException(R"(failed to offload data block of size %s (%s/%s used).
-This limit was set by the 'max_temp_directory_size' setting.
-By default, this setting utilizes the available disk space on the drive where the 'temp_directory' is located.
-You can adjust this setting, by using (for example) PRAGMA max_temp_directory_size='10GiB')",
-		                           data_size, used, max);
-	}
-	size_on_disk += bytes;
-}
-
-void TemporaryFileManager::DecreaseSizeOnDisk(idx_t bytes) {
-	size_on_disk -= bytes;
-}
-
-unique_ptr<FileBuffer> TemporaryFileManager::ReadTemporaryBuffer(block_id_t id,
-                                                                 unique_ptr<FileBuffer> reusable_buffer) {
-	TemporaryFileIndex index;
-	optional_ptr<TemporaryFileHandle> handle;
-	{
-		TemporaryFileManagerLock lock(manager_lock);
-		index = GetTempBlockIndex(lock, id);
-		handle = GetFileHandle(lock, index.identifier);
-	}
-
-	auto buffer = handle->ReadTemporaryBuffer(index.block_index.GetIndex(), std::move(reusable_buffer));
-	{
-		// remove the block (and potentially erase the temp file)
-		TemporaryFileManagerLock lock(manager_lock);
-		EraseUsedBlock(lock, id, *handle, index);
-	}
-	return buffer;
-}
-
-void TemporaryFileManager::DeleteTemporaryBuffer(block_id_t id) {
-	TemporaryFileManagerLock lock(manager_lock);
-	auto index = GetTempBlockIndex(lock, id);
-	auto handle = GetFileHandle(lock, index.identifier);
-	EraseUsedBlock(lock, id, *handle, index);
-}
-
-vector<TemporaryFileInformation> TemporaryFileManager::GetTemporaryFiles() {
-	lock_guard<mutex> lock(manager_lock);
-	vector<TemporaryFileInformation> result;
-	for (auto &size : TemporaryBufferSizes()) {
-		for (const auto &file : files.GetMapForSize(size)) {
-			result.push_back(file.second->GetTemporaryFile());
-		}
-	}
-	return result;
-}
-
-void TemporaryFileManager::EraseUsedBlock(TemporaryFileManagerLock &lock, block_id_t id, TemporaryFileHandle &handle,
-                                          TemporaryFileIndex index) {
-	auto entry = used_blocks.find(id);
-	if (entry == used_blocks.end()) {
-		throw InternalException("EraseUsedBlock - Block %llu not found in used blocks", id);
-	}
-	used_blocks.erase(entry);
-	handle.EraseBlockIndex(NumericCast<block_id_t>(index.block_index.GetIndex()));
-	if (handle.DeleteIfEmpty()) {
-		EraseFileHandle(lock, index.identifier);
-	}
-}
-
-string TemporaryFileManager::CreateTemporaryFileName(const TemporaryFileIdentifier &identifier) const {
-	return FileSystem::GetFileSystem(db).JoinPath(
-	    temp_directory, StringUtil::Format("duckdb_temp_storage_%s-%llu.tmp", EnumUtil::ToString(identifier.size),
-	                                       identifier.file_index.GetIndex()));
-}
-
-optional_ptr<TemporaryFileHandle> TemporaryFileManager::GetFileHandle(TemporaryFileManagerLock &,
-                                                                      const TemporaryFileIdentifier &identifier) {
-	D_ASSERT(identifier.IsValid());
-	return files.GetFile(identifier);
-}
-
-TemporaryFileIndex TemporaryFileManager::GetTempBlockIndex(TemporaryFileManagerLock &, block_id_t id) {
-	D_ASSERT(used_blocks.find(id) != used_blocks.end());
-	return used_blocks[id];
-}
-
-void TemporaryFileManager::EraseFileHandle(TemporaryFileManagerLock &, const TemporaryFileIdentifier &identifier) {
-	D_ASSERT(identifier.IsValid());
-	files.EraseFile(identifier);
-	index_managers[identifier.size].RemoveIndex(identifier.file_index.GetIndex(), identifier.size);
-}
-
-//===--------------------------------------------------------------------===//
-// TemporaryDirectoryHandle
-//===--------------------------------------------------------------------===//
-TemporaryDirectoryHandle::TemporaryDirectoryHandle(DatabaseInstance &db, string path_p, optional_idx max_swap_space)
-    : db(db), temp_directory(std::move(path_p)), temp_file(make_uniq<TemporaryFileManager>(db, temp_directory)) {
-	auto &fs = FileSystem::GetFileSystem(db);
-	D_ASSERT(!temp_directory.empty());
-	if (!fs.DirectoryExists(temp_directory)) {
-		fs.CreateDirectory(temp_directory);
-		created_directory = true;
-	}
-	temp_file->SetMaxSwapSpace(max_swap_space);
-}
-
-TemporaryDirectoryHandle::~TemporaryDirectoryHandle() {
-	// first release any temporary files
-	temp_file.reset();
-	// then delete the temporary file directory
-	auto &fs = FileSystem::GetFileSystem(db);
-	if (!temp_directory.empty()) {
-		bool delete_directory = created_directory;
-		vector<string> files_to_delete;
-		if (!created_directory) {
-			bool deleted_everything = true;
-			fs.ListFiles(temp_directory, [&](const string &path, bool isdir) {
-				if (isdir) {
-					deleted_everything = false;
-					return;
-				}
-				if (!StringUtil::StartsWith(path, "duckdb_temp_")) {
-					deleted_everything = false;
-					return;
-				}
-				files_to_delete.push_back(path);
-			});
-		}
-		if (delete_directory) {
-			// we want to remove all files in the directory
-			fs.RemoveDirectory(temp_directory);
-		} else {
-			for (auto &file : files_to_delete) {
-				fs.RemoveFile(fs.JoinPath(temp_directory, file));
-			}
-		}
-	}
-}
-
-TemporaryFileManager &TemporaryDirectoryHandle::GetTempFile() const {
-	return *temp_file;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/temporary_memory_manager.cpp b/src/duckdb/src/storage/temporary_memory_manager.cpp
deleted file mode 100644
index a2bf67bc5..000000000
--- a/src/duckdb/src/storage/temporary_memory_manager.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-#include "duckdb/storage/temporary_memory_manager.hpp"
-
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-#include <cmath>
-
-namespace duckdb {
-
-TemporaryMemoryState::TemporaryMemoryState(TemporaryMemoryManager &temporary_memory_manager_p,
-                                           idx_t minimum_reservation_p)
-    : temporary_memory_manager(temporary_memory_manager_p), remaining_size(0),
-      minimum_reservation(minimum_reservation_p), reservation(0), materialization_penalty(1) {
-}
-
-TemporaryMemoryState::~TemporaryMemoryState() {
-	temporary_memory_manager.Unregister(*this);
-}
-
-void TemporaryMemoryState::SetRemainingSize(idx_t new_remaining_size) {
-	auto guard = temporary_memory_manager.Lock();
-	temporary_memory_manager.SetRemainingSize(*this, new_remaining_size);
-}
-
-void TemporaryMemoryState::SetRemainingSizeAndUpdateReservation(ClientContext &context, idx_t new_remaining_size) {
-	D_ASSERT(new_remaining_size != 0); // Use SetZero instead
-	auto guard = temporary_memory_manager.Lock();
-	temporary_memory_manager.SetRemainingSize(*this, new_remaining_size);
-	temporary_memory_manager.UpdateState(context, *this);
-}
-
-void TemporaryMemoryState::SetZero() {
-	auto guard = temporary_memory_manager.Lock();
-	temporary_memory_manager.SetRemainingSize(*this, 0);
-	temporary_memory_manager.SetReservation(*this, 0);
-}
-
-idx_t TemporaryMemoryState::GetRemainingSize() const {
-	return remaining_size;
-}
-
-void TemporaryMemoryState::SetMinimumReservation(idx_t new_minimum_reservation) {
-	minimum_reservation = new_minimum_reservation;
-}
-
-idx_t TemporaryMemoryState::GetMinimumReservation() const {
-	return minimum_reservation;
-}
-
-void TemporaryMemoryState::UpdateReservation(ClientContext &context) {
-	auto guard = temporary_memory_manager.Lock();
-	temporary_memory_manager.UpdateState(context, *this);
-}
-
-idx_t TemporaryMemoryState::GetReservation() const {
-	return reservation;
-}
-
-void TemporaryMemoryState::SetMaterializationPenalty(idx_t new_materialization_penalty) {
-	auto guard = temporary_memory_manager.Lock();
-	materialization_penalty = new_materialization_penalty;
-}
-
-idx_t TemporaryMemoryState::GetMaterializationPenalty() const {
-	return materialization_penalty;
-}
-
-TemporaryMemoryManager::TemporaryMemoryManager() : reservation(0), remaining_size(0) {
-}
-
-unique_lock<mutex> TemporaryMemoryManager::Lock() {
-	return unique_lock<mutex>(lock);
-}
-
-void TemporaryMemoryManager::Unregister(TemporaryMemoryState &temporary_memory_state) {
-	auto guard = Lock();
-
-	SetReservation(temporary_memory_state, 0);
-	SetRemainingSize(temporary_memory_state, 0);
-	active_states.erase(temporary_memory_state);
-
-	Verify();
-}
-
-void TemporaryMemoryManager::UpdateConfiguration(ClientContext &context) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	auto &task_scheduler = TaskScheduler::GetScheduler(context);
-
-	memory_limit =
-	    LossyNumericCast<idx_t>(MAXIMUM_MEMORY_LIMIT_RATIO * static_cast<double>(buffer_manager.GetMaxMemory()));
-	has_temporary_directory = buffer_manager.HasTemporaryDirectory();
-	num_threads = NumericCast<idx_t>(task_scheduler.NumberOfThreads());
-	query_max_memory = buffer_manager.GetQueryMaxMemory();
-}
-
-TemporaryMemoryManager &TemporaryMemoryManager::Get(ClientContext &context) {
-	return BufferManager::GetBufferManager(context).GetTemporaryMemoryManager();
-}
-
-unique_ptr<TemporaryMemoryState> TemporaryMemoryManager::Register(ClientContext &context) {
-	auto guard = Lock();
-	UpdateConfiguration(context);
-
-	auto minimum_reservation = MinValue(num_threads * MINIMUM_RESERVATION_PER_STATE_PER_THREAD,
-	                                    memory_limit / MINIMUM_RESERVATION_MEMORY_LIMIT_DIVISOR);
-	auto result = unique_ptr<TemporaryMemoryState>(new TemporaryMemoryState(*this, minimum_reservation));
-	SetRemainingSize(*result, result->GetMinimumReservation());
-	SetReservation(*result, result->GetMinimumReservation());
-	active_states.insert(*result);
-
-	Verify();
-	return result;
-}
-
-void TemporaryMemoryManager::UpdateState(ClientContext &context, TemporaryMemoryState &temporary_memory_state) {
-	UpdateConfiguration(context);
-
-	// The lower bound for the reservation of this state is either the minimum reservation or the remaining size
-	const auto lower_bound =
-	    MinValue(temporary_memory_state.GetMinimumReservation(), temporary_memory_state.GetRemainingSize());
-
-	if (temporary_memory_state.GetRemainingSize() == 0) {
-		// Sometimes set to 0 to denote end of state (before actually deleting the state)
-		SetReservation(temporary_memory_state, 0);
-	} else if (context.config.force_external) {
-		// We're forcing external processing. Give it the minimum
-		SetReservation(temporary_memory_state, lower_bound);
-	} else if (!has_temporary_directory) {
-		// We cannot offload, so we cannot limit memory usage. Set reservation equal to the remaining size
-		SetReservation(temporary_memory_state, temporary_memory_state.GetRemainingSize());
-	} else if (reservation - temporary_memory_state.GetReservation() + lower_bound >= memory_limit) {
-		// We overshot. Set reservation equal to the minimum
-		SetReservation(temporary_memory_state, lower_bound);
-	} else {
-		// The upper bound for the reservation of this state is the minimum of:
-		// 1. Remaining size of the state
-		// 2. The max memory per query
-		// 3. MAXIMUM_FREE_MEMORY_RATIO * free memory
-		auto upper_bound = MinValue(temporary_memory_state.GetRemainingSize(), query_max_memory);
-		const auto free_memory = memory_limit - (reservation - temporary_memory_state.GetReservation());
-		upper_bound = MinValue(upper_bound,
-		                       LossyNumericCast<idx_t>(MAXIMUM_FREE_MEMORY_RATIO * static_cast<double>(free_memory)));
-		upper_bound = MinValue(upper_bound, free_memory);
-
-		idx_t new_reservation;
-		if (lower_bound >= upper_bound) {
-			new_reservation = lower_bound;
-		} else {
-			new_reservation = remaining_size > memory_limit ? ComputeReservation(temporary_memory_state) : upper_bound;
-		}
-
-		SetReservation(temporary_memory_state, new_reservation);
-	}
-
-	Verify();
-}
-
-void TemporaryMemoryManager::SetRemainingSize(TemporaryMemoryState &temporary_memory_state, idx_t new_remaining_size) {
-	D_ASSERT(this->remaining_size >= temporary_memory_state.GetRemainingSize());
-	this->remaining_size -= temporary_memory_state.GetRemainingSize();
-	temporary_memory_state.remaining_size = new_remaining_size;
-	this->remaining_size += temporary_memory_state.GetRemainingSize();
-}
-
-void TemporaryMemoryManager::SetReservation(TemporaryMemoryState &temporary_memory_state, idx_t new_reservation) {
-	D_ASSERT(this->reservation >= temporary_memory_state.GetReservation());
-	this->reservation -= temporary_memory_state.GetReservation();
-	temporary_memory_state.reservation = new_reservation;
-	this->reservation += temporary_memory_state.GetReservation();
-}
-
-//! Compute initial reservation for use in ComputeReservation
-static idx_t ComputeInitialReservation(const TemporaryMemoryState &temporary_memory_state) {
-	// Maximum of minimum reservation and the current reservation
-	auto result = MaxValue(temporary_memory_state.GetMinimumReservation(), temporary_memory_state.GetReservation());
-	// Bounded by the remaining size
-	result = MinValue(result, temporary_memory_state.GetRemainingSize());
-	// At least 1
-	return MaxValue<idx_t>(result, 1);
-}
-
-static void ComputeDerivatives(const vector<reference<const TemporaryMemoryState>> &states, const vector<idx_t> &res,
-                               vector<double> &der, const idx_t n) {
-	// Cost function takes "throughput" (reservation / size) of each operator as its principal input
-	double prod_siz = 1;
-	double prod_res = 1;
-	double mat_cost = 0;
-	for (idx_t i = 0; i < n; i++) {
-		auto &state = states[i].get();
-		const auto resd = static_cast<double>(res[i]);
-		const auto sizd = static_cast<double>(MaxValue<idx_t>(state.GetRemainingSize(), 1));
-		const auto pend = static_cast<double>(state.GetMaterializationPenalty());
-		prod_res *= resd;
-		prod_siz *= sizd;
-		mat_cost += pend * (1 - resd / sizd); // Materialization cost: sum of (1 - throughput)
-	}
-	const double nd = static_cast<double>(n);                    // n as double for convenience
-	const double tp_mult = 1 - pow(prod_res / prod_siz, 1 / nd); // Throughput multiplier: 1 - geomean throughputs
-
-	// Cost function: materialization cost * (1 - throughput multiplier), but we don't actually need to compute it
-	// here. We need to compute the derivative with respect to every reservation, stored in "der"
-	// Just use https://www.derivative-calculator.net with this (n = 3) to see what's going on
-	// (3 - (a_1/s_1)-(a_2/s_2)-(a_3/s_3))*(1-((a_1/s_1)*(a_2/s_2)*(a_3/s_3))^(1/3))
-	const double intermediate = -(pow(prod_res, 1 / nd) * mat_cost) / (nd * pow(prod_siz, 1 / nd));
-	for (idx_t i = 0; i < n; i++) {
-		auto &state = states[i].get();
-		const auto resd = static_cast<double>(res[i]);
-		const auto sizd = static_cast<double>(MaxValue<idx_t>(state.GetRemainingSize(), 1));
-		const auto pend = static_cast<double>(state.GetMaterializationPenalty());
-		der[i] = intermediate / resd - pend * tp_mult / sizd;
-	}
-}
-
-idx_t TemporaryMemoryManager::ComputeReservation(const TemporaryMemoryState &temporary_memory_state) const {
-	static constexpr idx_t OPTIMIZATION_ITERATIONS_MULTIPLIER = 5;
-
-	// Use vectors for ease
-	optional_idx state_index;
-	vector<reference<const TemporaryMemoryState>> states;
-	vector<idx_t> res;
-	vector<double> der;
-	idx_t sum_of_initial_res = 0;
-
-	idx_t i = 0;
-	for (auto &state : active_states) {
-		const auto initial_reservation = ComputeInitialReservation(state);
-		sum_of_initial_res += initial_reservation;
-		if (RefersToSameObject(state.get(), temporary_memory_state)) {
-			state_index = i;
-		} else if (initial_reservation >= state.get().GetRemainingSize()) {
-			continue;
-		}
-		states.emplace_back(state);
-		res.push_back(initial_reservation);
-		der.push_back(NumericLimits<double>::Maximum());
-		i++;
-	}
-	const idx_t n = i;
-
-	if (sum_of_initial_res >= memory_limit) {
-		return res[state_index.GetIndex()];
-	}
-	const auto free_memory = memory_limit - sum_of_initial_res;
-
-	// Distribute memory in OPTIMIZATION_ITERATIONS
-	idx_t remaining_memory = free_memory;
-	const idx_t optimization_iterations = OPTIMIZATION_ITERATIONS_MULTIPLIER * n;
-	for (idx_t opt_idx = 0; opt_idx < optimization_iterations; opt_idx++) {
-		D_ASSERT(remaining_memory != 0);
-		ComputeDerivatives(states, res, der, n);
-
-		// Find the index of the state with the lowest derivative
-		idx_t min_idx = 0;
-		double min_der = NumericLimits<double>::Maximum();
-		for (i = 0; i < n; i++) {
-			auto &state = states[i].get();
-			if (res[i] >= state.GetRemainingSize()) {
-				continue; // We can't increase the reservation of "maxed" states, so we skip these
-			}
-			if (der[i] < min_der) {
-				min_idx = i;
-				min_der = der[i];
-			}
-		}
-		auto &min_state = states[min_idx].get();
-
-		// This is how much memory we will distribute in this round
-		const auto iter_memory = ExactNumericCast<idx_t>(
-		    std::ceil(static_cast<double>(remaining_memory) / static_cast<double>(optimization_iterations - opt_idx)));
-
-		// Compute how much we can add
-		const auto state_room = min_state.GetRemainingSize() - res[min_idx];
-		const auto delta = MinValue(iter_memory, state_room);
-		D_ASSERT(delta <= remaining_memory);
-
-		// Update counts
-		res[min_idx] += delta;
-		remaining_memory -= delta;
-	}
-	D_ASSERT(remaining_memory == 0);
-
-	// We computed how the memory should be assigned to the states,
-	// but we did not yet take into account the upper bound of MAXIMUM_FREE_MEMORY_RATIO * free_memory.
-	// We don't simply bound this state's reservation because order matters,
-	// and this function is called in arbitrary order for all active states.
-	// So, we order the states by derivative (as if they got the max reservation),
-	// and assign the states with the lowest derivate first.
-	// This way, order does not matter _as much_, and the "best" states will _likely_ get more memory
-	vector<idx_t> idxs(n, 0);
-	vector<idx_t> max_res(n, 0);
-	for (i = 0; i < n; i++) {
-		idxs[i] = i;
-		max_res[i] = states[i].get().GetRemainingSize() - 1;
-	}
-	ComputeDerivatives(states, max_res, der, n);
-	std::sort(idxs.begin(), idxs.end(), [&](const idx_t &lhs, const idx_t &rhs) { return der[lhs] < der[rhs]; });
-
-	// Loop through sorted indices until we encounter the state index
-	remaining_memory = free_memory;
-	for (const auto idx : idxs) {
-		auto &state = states[idx].get();
-		D_ASSERT(res[idx] <= state.GetRemainingSize());
-		const auto initial_state_reservation = ComputeInitialReservation(state);
-		const auto upper_bound = LossyNumericCast<idx_t>(
-		    MAXIMUM_FREE_MEMORY_RATIO * static_cast<double>(initial_state_reservation + remaining_memory));
-		auto state_reservation = MinValue(res[idx], upper_bound);
-		// But make sure it's never less than the initial reservation
-		state_reservation = MaxValue(state_reservation, initial_state_reservation);
-		// If this is the current state, we can just return
-		if (idx == state_index.GetIndex()) {
-			return state_reservation;
-		}
-		// Decrement the remaining memory
-		const auto delta = state_reservation - initial_state_reservation;
-		remaining_memory -= delta;
-	}
-
-	// We cannot have gotten through the loop above without finding the current state
-	throw InternalException("Did not find state_index in ComputeOptimalReservation");
-}
-
-void TemporaryMemoryManager::Verify() const {
-#ifdef DEBUG
-	idx_t total_reservation = 0;
-	idx_t total_remaining_size = 0;
-	for (auto &active_state : active_states) {
-		total_reservation += active_state.get().GetReservation();
-		total_remaining_size += active_state.get().GetRemainingSize();
-	}
-	D_ASSERT(total_reservation == this->reservation);
-	D_ASSERT(total_remaining_size == this->remaining_size);
-#endif
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/wal_replay.cpp b/src/duckdb/src/storage/wal_replay.cpp
deleted file mode 100644
index eefe70ef6..000000000
--- a/src/duckdb/src/storage/wal_replay.cpp
+++ /dev/null
@@ -1,844 +0,0 @@
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/buffered_file_reader.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/index_type_set.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/connection.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/drop_info.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression_binder/index_binder.hpp"
-#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/table/delete_state.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-
-namespace duckdb {
-
-class ReplayState {
-public:
-	ReplayState(AttachedDatabase &db, ClientContext &context) : db(db), context(context), catalog(db.GetCatalog()) {
-	}
-
-	AttachedDatabase &db;
-	ClientContext &context;
-	Catalog &catalog;
-	optional_ptr<TableCatalogEntry> current_table;
-	MetaBlockPointer checkpoint_id;
-	idx_t wal_version = 1;
-};
-
-class WriteAheadLogDeserializer {
-public:
-	WriteAheadLogDeserializer(ReplayState &state_p, BufferedFileReader &stream_p, bool deserialize_only = false)
-	    : state(state_p), db(state.db), context(state.context), catalog(state.catalog), data(nullptr),
-	      stream(nullptr, 0), deserializer(stream_p), deserialize_only(deserialize_only) {
-	}
-	WriteAheadLogDeserializer(ReplayState &state_p, unique_ptr<data_t[]> data_p, idx_t size,
-	                          bool deserialize_only = false)
-	    : state(state_p), db(state.db), context(state.context), catalog(state.catalog), data(std::move(data_p)),
-	      stream(data.get(), size), deserializer(stream), deserialize_only(deserialize_only) {
-	}
-
-	static WriteAheadLogDeserializer Open(ReplayState &state_p, BufferedFileReader &stream,
-	                                      bool deserialize_only = false) {
-		if (state_p.wal_version == 1) {
-			// old WAL versions do not have checksums
-			return WriteAheadLogDeserializer(state_p, stream, deserialize_only);
-		}
-		if (state_p.wal_version != 2) {
-			throw IOException("Failed to read WAL of version %llu - can only read version 1 and 2",
-			                  state_p.wal_version);
-		}
-		// read the checksum and size
-		auto size = stream.Read<uint64_t>();
-		auto stored_checksum = stream.Read<uint64_t>();
-		auto offset = stream.CurrentOffset();
-		auto file_size = stream.FileSize();
-
-		if (offset + size > file_size) {
-			throw SerializationException(
-			    "Corrupt WAL file: entry size exceeded remaining data in file at byte position %llu "
-			    "(found entry with size %llu bytes, file size %llu bytes)",
-			    offset, size, file_size);
-		}
-
-		// allocate a buffer and read data into the buffer
-		auto buffer = unique_ptr<data_t[]>(new data_t[size]);
-		stream.ReadData(buffer.get(), size);
-
-		// compute and verify the checksum
-		auto computed_checksum = Checksum(buffer.get(), size);
-		if (stored_checksum != computed_checksum) {
-			throw IOException("Corrupt WAL file: entry at byte position %llu computed checksum %llu does not match "
-			                  "stored checksum %llu",
-			                  offset, computed_checksum, stored_checksum);
-		}
-		return WriteAheadLogDeserializer(state_p, std::move(buffer), size, deserialize_only);
-	}
-
-	bool ReplayEntry() {
-		deserializer.Begin();
-		auto wal_type = deserializer.ReadProperty<WALType>(100, "wal_type");
-		if (wal_type == WALType::WAL_FLUSH) {
-			deserializer.End();
-			return true;
-		}
-		ReplayEntry(wal_type);
-		deserializer.End();
-		return false;
-	}
-
-	bool DeserializeOnly() {
-		return deserialize_only;
-	}
-
-protected:
-	void ReplayEntry(WALType wal_type);
-
-	void ReplayVersion();
-
-	void ReplayCreateTable();
-	void ReplayDropTable();
-	void ReplayAlter();
-
-	void ReplayCreateView();
-	void ReplayDropView();
-
-	void ReplayCreateSchema();
-	void ReplayDropSchema();
-
-	void ReplayCreateType();
-	void ReplayDropType();
-
-	void ReplayCreateSequence();
-	void ReplayDropSequence();
-	void ReplaySequenceValue();
-
-	void ReplayCreateMacro();
-	void ReplayDropMacro();
-
-	void ReplayCreateTableMacro();
-	void ReplayDropTableMacro();
-
-	void ReplayCreateIndex();
-	void ReplayDropIndex();
-
-	void ReplayUseTable();
-	void ReplayInsert();
-	void ReplayRowGroupData();
-	void ReplayDelete();
-	void ReplayUpdate();
-	void ReplayCheckpoint();
-
-private:
-	ReplayState &state;
-	AttachedDatabase &db;
-	ClientContext &context;
-	Catalog &catalog;
-	unique_ptr<data_t[]> data;
-	MemoryStream stream;
-	BinaryDeserializer deserializer;
-	bool deserialize_only;
-};
-
-//===--------------------------------------------------------------------===//
-// Replay
-//===--------------------------------------------------------------------===//
-unique_ptr<WriteAheadLog> WriteAheadLog::Replay(FileSystem &fs, AttachedDatabase &db, const string &wal_path) {
-	auto handle = fs.OpenFile(wal_path, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS);
-	if (!handle) {
-		// WAL does not exist - instantiate an empty WAL
-		return make_uniq<WriteAheadLog>(db, wal_path);
-	}
-	auto wal_handle = ReplayInternal(db, std::move(handle));
-	if (wal_handle) {
-		return wal_handle;
-	}
-	// replay returning NULL indicates we can nuke the WAL entirely - but only if this is not a read-only connection
-	if (!db.IsReadOnly()) {
-		fs.RemoveFile(wal_path);
-	}
-	return make_uniq<WriteAheadLog>(db, wal_path);
-}
-unique_ptr<WriteAheadLog> WriteAheadLog::ReplayInternal(AttachedDatabase &database, unique_ptr<FileHandle> handle) {
-	Connection con(database.GetDatabase());
-	auto wal_path = handle->GetPath();
-	BufferedFileReader reader(FileSystem::Get(database), std::move(handle));
-	if (reader.Finished()) {
-		// WAL file exists but it is empty - we can delete the file
-		return nullptr;
-	}
-
-	con.BeginTransaction();
-	MetaTransaction::Get(*con.context).ModifyDatabase(database);
-
-	auto &config = DBConfig::GetConfig(database.GetDatabase());
-	// first deserialize the WAL to look for a checkpoint flag
-	// if there is a checkpoint flag, we might have already flushed the contents of the WAL to disk
-	ReplayState checkpoint_state(database, *con.context);
-	try {
-		while (true) {
-			// read the current entry (deserialize only)
-			auto deserializer = WriteAheadLogDeserializer::Open(checkpoint_state, reader, true);
-			if (deserializer.ReplayEntry()) {
-				// check if the file is exhausted
-				if (reader.Finished()) {
-					// we finished reading the file: break
-					break;
-				}
-			}
-		}
-	} catch (std::exception &ex) { // LCOV_EXCL_START
-		ErrorData error(ex);
-		// ignore serialization exceptions - they signal a torn WAL
-		if (error.Type() != ExceptionType::SERIALIZATION) {
-			error.Throw("Failure while replaying WAL file \"" + wal_path + "\": ");
-		}
-	} // LCOV_EXCL_STOP
-	if (checkpoint_state.checkpoint_id.IsValid()) {
-		// there is a checkpoint flag: check if we need to deserialize the WAL
-		auto &manager = database.GetStorageManager();
-		if (manager.IsCheckpointClean(checkpoint_state.checkpoint_id)) {
-			// the contents of the WAL have already been checkpointed
-			// we can safely truncate the WAL and ignore its contents
-			return nullptr;
-		}
-	}
-
-	// we need to recover from the WAL: actually set up the replay state
-	ReplayState state(database, *con.context);
-
-	// reset the reader - we are going to read the WAL from the beginning again
-	reader.Reset();
-
-	// replay the WAL
-	// note that everything is wrapped inside a try/catch block here
-	// there can be errors in WAL replay because of a corrupt WAL file
-	idx_t successful_offset = 0;
-	bool all_succeeded = false;
-	try {
-		while (true) {
-			// read the current entry
-			auto deserializer = WriteAheadLogDeserializer::Open(state, reader);
-			if (deserializer.ReplayEntry()) {
-				con.Commit();
-				successful_offset = reader.offset;
-				// check if the file is exhausted
-				if (reader.Finished()) {
-					// we finished reading the file: break
-					all_succeeded = true;
-					break;
-				}
-				con.BeginTransaction();
-				MetaTransaction::Get(*con.context).ModifyDatabase(database);
-			}
-		}
-	} catch (std::exception &ex) { // LCOV_EXCL_START
-		// exception thrown in WAL replay: rollback
-		con.Query("ROLLBACK");
-		ErrorData error(ex);
-		// serialization failure means a truncated WAL
-		// these failures are ignored unless abort_on_wal_failure is true
-		// other failures always result in an error
-		if (config.options.abort_on_wal_failure || error.Type() != ExceptionType::SERIALIZATION) {
-			error.Throw("Failure while replaying WAL file \"" + wal_path + "\": ");
-		}
-	} catch (...) {
-		// exception thrown in WAL replay: rollback
-		con.Query("ROLLBACK");
-		throw;
-	} // LCOV_EXCL_STOP
-	auto init_state = all_succeeded ? WALInitState::UNINITIALIZED : WALInitState::UNINITIALIZED_REQUIRES_TRUNCATE;
-	return make_uniq<WriteAheadLog>(database, wal_path, successful_offset, init_state);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Entries
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayEntry(WALType entry_type) {
-	switch (entry_type) {
-	case WALType::WAL_VERSION:
-		ReplayVersion();
-		break;
-	case WALType::CREATE_TABLE:
-		ReplayCreateTable();
-		break;
-	case WALType::DROP_TABLE:
-		ReplayDropTable();
-		break;
-	case WALType::ALTER_INFO:
-		ReplayAlter();
-		break;
-	case WALType::CREATE_VIEW:
-		ReplayCreateView();
-		break;
-	case WALType::DROP_VIEW:
-		ReplayDropView();
-		break;
-	case WALType::CREATE_SCHEMA:
-		ReplayCreateSchema();
-		break;
-	case WALType::DROP_SCHEMA:
-		ReplayDropSchema();
-		break;
-	case WALType::CREATE_SEQUENCE:
-		ReplayCreateSequence();
-		break;
-	case WALType::DROP_SEQUENCE:
-		ReplayDropSequence();
-		break;
-	case WALType::SEQUENCE_VALUE:
-		ReplaySequenceValue();
-		break;
-	case WALType::CREATE_MACRO:
-		ReplayCreateMacro();
-		break;
-	case WALType::DROP_MACRO:
-		ReplayDropMacro();
-		break;
-	case WALType::CREATE_TABLE_MACRO:
-		ReplayCreateTableMacro();
-		break;
-	case WALType::DROP_TABLE_MACRO:
-		ReplayDropTableMacro();
-		break;
-	case WALType::CREATE_INDEX:
-		ReplayCreateIndex();
-		break;
-	case WALType::DROP_INDEX:
-		ReplayDropIndex();
-		break;
-	case WALType::USE_TABLE:
-		ReplayUseTable();
-		break;
-	case WALType::INSERT_TUPLE:
-		ReplayInsert();
-		break;
-	case WALType::ROW_GROUP_DATA:
-		ReplayRowGroupData();
-		break;
-	case WALType::DELETE_TUPLE:
-		ReplayDelete();
-		break;
-	case WALType::UPDATE_TUPLE:
-		ReplayUpdate();
-		break;
-	case WALType::CHECKPOINT:
-		ReplayCheckpoint();
-		break;
-	case WALType::CREATE_TYPE:
-		ReplayCreateType();
-		break;
-	case WALType::DROP_TYPE:
-		ReplayDropType();
-		break;
-	default:
-		throw InternalException("Invalid WAL entry type!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Version
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayVersion() {
-	state.wal_version = deserializer.ReadProperty<idx_t>(101, "version");
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Table
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateTable() {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "table");
-	if (DeserializeOnly()) {
-		return;
-	}
-	// bind the constraints to the table again
-	auto binder = Binder::CreateBinder(context);
-	auto &schema = catalog.GetSchema(context, info->schema);
-	auto bound_info = Binder::BindCreateTableCheckpoint(std::move(info), schema);
-
-	catalog.CreateTable(context, *bound_info);
-}
-
-void WriteAheadLogDeserializer::ReplayDropTable() {
-	DropInfo info;
-
-	info.type = CatalogType::TABLE_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-void ReplayWithoutIndex(ClientContext &context, Catalog &catalog, AlterInfo &info, const bool only_deserialize) {
-	if (only_deserialize) {
-		return;
-	}
-	catalog.Alter(context, info);
-}
-
-void ReplayIndexData(AttachedDatabase &db, BinaryDeserializer &deserializer, IndexStorageInfo &info,
-                     const bool deserialize_only) {
-	D_ASSERT(info.IsValid() && !info.name.empty());
-
-	auto &storage_manager = db.GetStorageManager();
-	auto &single_file_sm = storage_manager.Cast<SingleFileStorageManager>();
-	auto &block_manager = single_file_sm.block_manager;
-	auto &buffer_manager = block_manager->buffer_manager;
-
-	deserializer.ReadList(103, "index_storage", [&](Deserializer::List &list, idx_t i) {
-		auto &data_info = info.allocator_infos[i];
-
-		// Read the data into buffer handles and convert them to blocks on disk.
-		for (idx_t j = 0; j < data_info.allocation_sizes.size(); j++) {
-
-			// Read the data into a buffer handle.
-			auto buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager->GetBlockSize(), false);
-			auto block_handle = buffer_handle.GetBlockHandle();
-			auto data_ptr = buffer_handle.Ptr();
-
-			list.ReadElement<bool>(data_ptr, data_info.allocation_sizes[j]);
-
-			// Convert the buffer handle to a persistent block and store the block id.
-			if (!deserialize_only) {
-				auto block_id = block_manager->GetFreeBlockId();
-				block_manager->ConvertToPersistent(block_id, std::move(block_handle), std::move(buffer_handle));
-				data_info.block_pointers[j].block_id = block_id;
-			}
-		}
-	});
-}
-
-void WriteAheadLogDeserializer::ReplayAlter() {
-	auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "info");
-	auto &alter_info = info->Cast<AlterInfo>();
-	if (!alter_info.IsAddPrimaryKey()) {
-		return ReplayWithoutIndex(context, catalog, alter_info, DeserializeOnly());
-	}
-
-	auto index_storage_info = deserializer.ReadProperty<IndexStorageInfo>(102, "index_storage_info");
-	ReplayIndexData(db, deserializer, index_storage_info, DeserializeOnly());
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	auto &table_info = alter_info.Cast<AlterTableInfo>();
-	auto &constraint_info = table_info.Cast<AddConstraintInfo>();
-	auto &unique_info = constraint_info.constraint->Cast<UniqueConstraint>();
-
-	auto &table =
-	    catalog.GetEntry<TableCatalogEntry>(context, table_info.schema, table_info.name).Cast<DuckTableEntry>();
-	auto &column_list = table.GetColumns();
-
-	// Add the table to the bind context to bind the parsed expressions.
-	auto binder = Binder::CreateBinder(context);
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	for (auto &col : column_list.Logical()) {
-		column_types.push_back(col.Type());
-		column_names.push_back(col.Name());
-	}
-
-	// Create a binder to bind the parsed expressions.
-	vector<ColumnIndex> column_indexes;
-	binder->bind_context.AddBaseTable(0, string(), column_names, column_types, column_indexes, table);
-	IndexBinder idx_binder(*binder, context);
-
-	// Bind the parsed expressions to create unbound expressions.
-	vector<unique_ptr<Expression>> unbound_expressions;
-	auto logical_indexes = unique_info.GetLogicalIndexes(column_list);
-	for (const auto &logical_index : logical_indexes) {
-		auto &col = column_list.GetColumn(logical_index);
-		unique_ptr<ParsedExpression> parsed = make_uniq<ColumnRefExpression>(col.GetName(), table_info.name);
-		unbound_expressions.push_back(idx_binder.Bind(parsed));
-	}
-
-	vector<column_t> column_ids;
-	for (auto &column_index : column_indexes) {
-		column_ids.push_back(column_index.GetPrimaryIndex());
-	}
-
-	auto &storage = table.GetStorage();
-	CreateIndexInput input(TableIOManager::Get(storage), storage.db, IndexConstraintType::PRIMARY,
-	                       index_storage_info.name, column_ids, unbound_expressions, index_storage_info,
-	                       index_storage_info.options);
-
-	auto index_type = context.db->config.GetIndexTypes().FindByName(ART::TYPE_NAME);
-	auto index_instance = index_type->create_instance(input);
-	storage.AddIndex(std::move(index_instance));
-
-	catalog.Alter(context, alter_info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay View
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateView() {
-	auto entry = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "view");
-	if (DeserializeOnly()) {
-		return;
-	}
-	catalog.CreateView(context, entry->Cast<CreateViewInfo>());
-}
-
-void WriteAheadLogDeserializer::ReplayDropView() {
-	DropInfo info;
-	info.type = CatalogType::VIEW_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-	catalog.DropEntry(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Schema
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateSchema() {
-	CreateSchemaInfo info;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.CreateSchema(context, info);
-}
-
-void WriteAheadLogDeserializer::ReplayDropSchema() {
-	DropInfo info;
-
-	info.type = CatalogType::SCHEMA_ENTRY;
-	info.name = deserializer.ReadProperty<string>(101, "schema");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Custom Type
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateType() {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "type");
-	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateType(context, info->Cast<CreateTypeInfo>());
-}
-
-void WriteAheadLogDeserializer::ReplayDropType() {
-	DropInfo info;
-
-	info.type = CatalogType::TYPE_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Sequence
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateSequence() {
-	auto entry = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "sequence");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.CreateSequence(context, entry->Cast<CreateSequenceInfo>());
-}
-
-void WriteAheadLogDeserializer::ReplayDropSequence() {
-	DropInfo info;
-	info.type = CatalogType::SEQUENCE_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-void WriteAheadLogDeserializer::ReplaySequenceValue() {
-	auto schema = deserializer.ReadProperty<string>(101, "schema");
-	auto name = deserializer.ReadProperty<string>(102, "name");
-	auto usage_count = deserializer.ReadProperty<uint64_t>(103, "usage_count");
-	auto counter = deserializer.ReadProperty<int64_t>(104, "counter");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	// fetch the sequence from the catalog
-	auto &seq = catalog.GetEntry<SequenceCatalogEntry>(context, schema, name);
-	seq.ReplayValue(usage_count, counter);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Macro
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateMacro() {
-	auto entry = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "macro");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.CreateFunction(context, entry->Cast<CreateMacroInfo>());
-}
-
-void WriteAheadLogDeserializer::ReplayDropMacro() {
-	DropInfo info;
-	info.type = CatalogType::MACRO_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Table Macro
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateTableMacro() {
-	auto entry = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "table_macro");
-	if (DeserializeOnly()) {
-		return;
-	}
-	catalog.CreateFunction(context, entry->Cast<CreateMacroInfo>());
-}
-
-void WriteAheadLogDeserializer::ReplayDropTableMacro() {
-	DropInfo info;
-	info.type = CatalogType::TABLE_MACRO_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Index
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayCreateIndex() {
-	auto create_info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(101, "index_catalog_entry");
-	auto index_info = deserializer.ReadProperty<IndexStorageInfo>(102, "index_storage_info");
-
-	ReplayIndexData(db, deserializer, index_info, DeserializeOnly());
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	auto &info = create_info->Cast<CreateIndexInfo>();
-
-	// Ensure that the index type exists.
-	if (info.index_type.empty()) {
-		info.index_type = ART::TYPE_NAME;
-	}
-
-	auto index_type = context.db->config.GetIndexTypes().FindByName(info.index_type);
-	if (!index_type) {
-		throw InternalException("Index type \"%s\" not recognized", info.index_type);
-	}
-
-	// Create the index in the catalog.
-	auto &table = catalog.GetEntry<TableCatalogEntry>(context, create_info->schema, info.table).Cast<DuckTableEntry>();
-	auto &index = table.schema.CreateIndex(context, info, table)->Cast<DuckIndexEntry>();
-
-	// Add the table to the bind context to bind the parsed expressions.
-	auto binder = Binder::CreateBinder(context);
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	for (auto &col : table.GetColumns().Logical()) {
-		column_types.push_back(col.Type());
-		column_names.push_back(col.Name());
-	}
-
-	// create a binder to bind the parsed expressions
-	vector<ColumnIndex> column_ids;
-	binder->bind_context.AddBaseTable(0, string(), column_names, column_types, column_ids, table);
-	IndexBinder idx_binder(*binder, context);
-
-	// Bind the parsed expressions to create unbound expressions.
-	vector<unique_ptr<Expression>> unbound_expressions;
-	for (auto &expr : index.parsed_expressions) {
-		auto copy = expr->Copy();
-		unbound_expressions.push_back(idx_binder.Bind(copy));
-	}
-
-	auto &storage = table.GetStorage();
-	CreateIndexInput input(TableIOManager::Get(storage), storage.db, info.constraint_type, info.index_name,
-	                       info.column_ids, unbound_expressions, index_info, info.options);
-	auto index_instance = index_type->create_instance(input);
-	storage.AddIndex(std::move(index_instance));
-}
-
-void WriteAheadLogDeserializer::ReplayDropIndex() {
-	DropInfo info;
-	info.type = CatalogType::INDEX_ENTRY;
-	info.schema = deserializer.ReadProperty<string>(101, "schema");
-	info.name = deserializer.ReadProperty<string>(102, "name");
-	if (DeserializeOnly()) {
-		return;
-	}
-
-	catalog.DropEntry(context, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Data
-//===--------------------------------------------------------------------===//
-void WriteAheadLogDeserializer::ReplayUseTable() {
-	auto schema_name = deserializer.ReadProperty<string>(101, "schema");
-	auto table_name = deserializer.ReadProperty<string>(102, "table");
-	if (DeserializeOnly()) {
-		return;
-	}
-	state.current_table = &catalog.GetEntry<TableCatalogEntry>(context, schema_name, table_name);
-}
-
-void WriteAheadLogDeserializer::ReplayInsert() {
-	DataChunk chunk;
-	deserializer.ReadObject(101, "chunk", [&](Deserializer &object) { chunk.Deserialize(object); });
-	if (DeserializeOnly()) {
-		return;
-	}
-	if (!state.current_table) {
-		throw InternalException("Corrupt WAL: insert without table");
-	}
-
-	// Append to the current table without constraint verification.
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	auto &storage = state.current_table->GetStorage();
-	storage.LocalAppend(*state.current_table, context, chunk, bound_constraints);
-}
-
-static void MarkBlocksAsUsed(BlockManager &manager, const PersistentColumnData &col_data) {
-	for (auto &pointer : col_data.pointers) {
-		auto block_id = pointer.block_pointer.block_id;
-		if (block_id != INVALID_BLOCK) {
-			manager.MarkBlockAsUsed(block_id);
-		}
-		if (pointer.segment_state) {
-			for (auto &block : pointer.segment_state->blocks) {
-				manager.MarkBlockAsUsed(block);
-			}
-		}
-	}
-	for (auto &child_column : col_data.child_columns) {
-		MarkBlocksAsUsed(manager, child_column);
-	}
-}
-
-void WriteAheadLogDeserializer::ReplayRowGroupData() {
-	auto &block_manager = db.GetStorageManager().GetBlockManager();
-	PersistentCollectionData data;
-	deserializer.Set<DatabaseInstance &>(db.GetDatabase());
-	CompressionInfo compression_info(block_manager.GetBlockSize());
-	deserializer.Set<const CompressionInfo &>(compression_info);
-	deserializer.ReadProperty(101, "row_group_data", data);
-	deserializer.Unset<const CompressionInfo>();
-	deserializer.Unset<DatabaseInstance>();
-	if (DeserializeOnly()) {
-		// label blocks in data as used - they will be used after the WAL replay is finished
-		// we need to do this during the deserialization phase to ensure the blocks will not be overwritten
-		// by previous deserialization steps
-		for (auto &group : data.row_group_data) {
-			for (auto &col_data : group.column_data) {
-				MarkBlocksAsUsed(block_manager, col_data);
-			}
-		}
-		return;
-	}
-	if (!state.current_table) {
-		throw InternalException("Corrupt WAL: insert without table");
-	}
-	auto &storage = state.current_table->GetStorage();
-	auto &table_info = storage.GetDataTableInfo();
-	RowGroupCollection new_row_groups(table_info, table_info->GetIOManager(), storage.GetTypes(), 0);
-	new_row_groups.Initialize(data);
-	TableIndexList index_list;
-	storage.MergeStorage(new_row_groups, index_list, nullptr);
-}
-
-void WriteAheadLogDeserializer::ReplayDelete() {
-	DataChunk chunk;
-	deserializer.ReadObject(101, "chunk", [&](Deserializer &object) { chunk.Deserialize(object); });
-	if (DeserializeOnly()) {
-		return;
-	}
-	if (!state.current_table) {
-		throw InternalException("Corrupt WAL: delete without table");
-	}
-
-	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
-	row_t row_ids[1];
-	Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_ids));
-
-	auto source_ids = FlatVector::GetData<row_t>(chunk.data[0]);
-	// delete the tuples from the current table
-	TableDeleteState delete_state;
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		row_ids[0] = source_ids[i];
-		state.current_table->GetStorage().Delete(delete_state, context, row_identifiers, 1);
-	}
-}
-
-void WriteAheadLogDeserializer::ReplayUpdate() {
-	auto column_path = deserializer.ReadProperty<vector<column_t>>(101, "column_indexes");
-
-	DataChunk chunk;
-	deserializer.ReadObject(102, "chunk", [&](Deserializer &object) { chunk.Deserialize(object); });
-
-	if (DeserializeOnly()) {
-		return;
-	}
-	if (!state.current_table) {
-		throw InternalException("Corrupt WAL: update without table");
-	}
-
-	if (column_path[0] >= state.current_table->GetColumns().PhysicalColumnCount()) {
-		throw InternalException("Corrupt WAL: column index for update out of bounds");
-	}
-
-	// remove the row id vector from the chunk
-	auto row_ids = std::move(chunk.data.back());
-	chunk.data.pop_back();
-
-	// now perform the update
-	state.current_table->GetStorage().UpdateColumn(*state.current_table, context, row_ids, column_path, chunk);
-}
-
-void WriteAheadLogDeserializer::ReplayCheckpoint() {
-	state.checkpoint_id = deserializer.ReadProperty<MetaBlockPointer>(101, "meta_block");
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/storage/write_ahead_log.cpp b/src/duckdb/src/storage/write_ahead_log.cpp
deleted file mode 100644
index 1a1b4250d..000000000
--- a/src/duckdb/src/storage/write_ahead_log.cpp
+++ /dev/null
@@ -1,453 +0,0 @@
-#include "duckdb/storage/write_ahead_log.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/common/checksum.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/index.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/data_table_info.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
-
-namespace duckdb {
-
-constexpr uint64_t WAL_VERSION_NUMBER = 2;
-
-WriteAheadLog::WriteAheadLog(AttachedDatabase &database, const string &wal_path, idx_t wal_size,
-                             WALInitState init_state)
-    : database(database), wal_path(wal_path), wal_size(wal_size), init_state(init_state) {
-}
-
-WriteAheadLog::~WriteAheadLog() {
-}
-
-BufferedFileWriter &WriteAheadLog::Initialize() {
-	if (Initialized()) {
-		return *writer;
-	}
-	lock_guard<mutex> lock(wal_lock);
-	if (!writer) {
-		writer = make_uniq<BufferedFileWriter>(FileSystem::Get(database), wal_path,
-		                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE |
-		                                           FileFlags::FILE_FLAGS_APPEND);
-		if (init_state == WALInitState::UNINITIALIZED_REQUIRES_TRUNCATE) {
-			writer->Truncate(wal_size);
-		}
-		wal_size = writer->GetFileSize();
-		init_state = WALInitState::INITIALIZED;
-	}
-	return *writer;
-}
-
-//! Gets the total bytes written to the WAL since startup
-idx_t WriteAheadLog::GetWALSize() const {
-	D_ASSERT(init_state != WALInitState::NO_WAL || wal_size == 0);
-	return wal_size;
-}
-
-idx_t WriteAheadLog::GetTotalWritten() const {
-	if (!Initialized()) {
-		return 0;
-	}
-	return writer->GetTotalWritten();
-}
-
-void WriteAheadLog::Truncate(idx_t size) {
-	if (init_state == WALInitState::NO_WAL) {
-		// no WAL to truncate
-		return;
-	}
-	if (!Initialized()) {
-		init_state = WALInitState::UNINITIALIZED_REQUIRES_TRUNCATE;
-		wal_size = size;
-		return;
-	}
-	writer->Truncate(size);
-	wal_size = writer->GetFileSize();
-}
-
-bool WriteAheadLog::Initialized() const {
-	return init_state == WALInitState::INITIALIZED;
-}
-
-void WriteAheadLog::Delete() {
-	if (init_state == WALInitState::NO_WAL) {
-		// no WAL to delete
-		return;
-	}
-	writer.reset();
-	auto &fs = FileSystem::Get(database);
-	fs.RemoveFile(wal_path);
-	init_state = WALInitState::NO_WAL;
-	wal_size = 0;
-}
-
-//===--------------------------------------------------------------------===//
-// Serializer
-//===--------------------------------------------------------------------===//
-class ChecksumWriter : public WriteStream {
-public:
-	explicit ChecksumWriter(WriteAheadLog &wal) : wal(wal) {
-	}
-
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) override {
-		// buffer data into the memory stream
-		memory_stream.WriteData(buffer, write_size);
-	}
-
-	void Flush() {
-		if (!stream) {
-			stream = wal.Initialize();
-		}
-		auto data = memory_stream.GetData();
-		auto size = memory_stream.GetPosition();
-		// compute the checksum over the entry
-		auto checksum = Checksum(data, size);
-		// write the checksum and the length of the entry
-		stream->Write<uint64_t>(size);
-		stream->Write<uint64_t>(checksum);
-		// write data to the underlying stream
-		stream->WriteData(memory_stream.GetData(), memory_stream.GetPosition());
-		// rewind the buffer
-		memory_stream.Rewind();
-	}
-
-private:
-	WriteAheadLog &wal;
-	optional_ptr<WriteStream> stream;
-	MemoryStream memory_stream;
-};
-
-class WriteAheadLogSerializer {
-public:
-	WriteAheadLogSerializer(WriteAheadLog &wal, WALType wal_type) : checksum_writer(wal), serializer(checksum_writer) {
-		if (!wal.Initialized()) {
-			wal.Initialize();
-		}
-		// write a version marker if none has been written yet
-		wal.WriteVersion();
-		serializer.Begin();
-		serializer.WriteProperty(100, "wal_type", wal_type);
-	}
-
-	void End() {
-		serializer.End();
-		checksum_writer.Flush();
-	}
-
-	template <class T>
-	void WriteProperty(const field_id_t field_id, const char *tag, const T &value) {
-		serializer.WriteProperty(field_id, tag, value);
-	}
-
-	template <class FUNC>
-	void WriteList(const field_id_t field_id, const char *tag, idx_t count, FUNC func) {
-		serializer.WriteList(field_id, tag, count, func);
-	}
-
-private:
-	ChecksumWriter checksum_writer;
-	BinarySerializer serializer;
-};
-
-//===--------------------------------------------------------------------===//
-// Write Entries
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteVersion() {
-	D_ASSERT(writer);
-	if (writer->GetFileSize() > 0) {
-		// already written - no need to write a version marker
-		return;
-	}
-	// write the version marker
-	// note that we explicitly do not checksum the version entry
-	BinarySerializer serializer(*writer);
-	serializer.Begin();
-	serializer.WriteProperty(100, "wal_type", WALType::WAL_VERSION);
-	serializer.WriteProperty(101, "version", idx_t(WAL_VERSION_NUMBER));
-	serializer.End();
-}
-
-void WriteAheadLog::WriteCheckpoint(MetaBlockPointer meta_block) {
-	WriteAheadLogSerializer serializer(*this, WALType::CHECKPOINT);
-	serializer.WriteProperty(101, "meta_block", meta_block);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// CREATE TABLE
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateTable(const TableCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_TABLE);
-	serializer.WriteProperty(101, "table", &entry);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// DROP TABLE
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropTable(const TableCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_TABLE);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// CREATE SCHEMA
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSchema(const SchemaCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_SCHEMA);
-	serializer.WriteProperty(101, "schema", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// SEQUENCES
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSequence(const SequenceCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_SEQUENCE);
-	serializer.WriteProperty(101, "sequence", &entry);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDropSequence(const SequenceCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_SEQUENCE);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteSequenceValue(SequenceValue val) {
-	auto &sequence = *val.entry;
-	WriteAheadLogSerializer serializer(*this, WALType::SEQUENCE_VALUE);
-	serializer.WriteProperty(101, "schema", sequence.schema.name);
-	serializer.WriteProperty(102, "name", sequence.name);
-	serializer.WriteProperty(103, "usage_count", val.usage_count);
-	serializer.WriteProperty(104, "counter", val.counter);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// MACROS
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateMacro(const ScalarMacroCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_MACRO);
-	serializer.WriteProperty(101, "macro", &entry);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDropMacro(const ScalarMacroCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_MACRO);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteCreateTableMacro(const TableMacroCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_TABLE_MACRO);
-	serializer.WriteProperty(101, "table", &entry);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDropTableMacro(const TableMacroCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_TABLE_MACRO);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// Indexes
-//===--------------------------------------------------------------------===//
-
-void SerializeIndex(AttachedDatabase &db, WriteAheadLogSerializer &serializer, TableIndexList &list,
-                    const string &name) {
-	const auto &db_options = db.GetDatabase().config.options;
-	auto v1_0_0_storage = db_options.serialization_compatibility.serialization_version < 3;
-	case_insensitive_map_t<Value> options;
-	if (!v1_0_0_storage) {
-		options.emplace("v1_0_0_storage", v1_0_0_storage);
-	}
-
-	list.Scan([&](Index &index) {
-		if (name == index.GetIndexName()) {
-			// We never write an unbound index to the WAL.
-			D_ASSERT(index.IsBound());
-
-			const auto &info = index.Cast<BoundIndex>().GetStorageInfo(options, true);
-			serializer.WriteProperty(102, "index_storage_info", info);
-			serializer.WriteList(103, "index_storage", info.buffers.size(), [&](Serializer::List &list, idx_t i) {
-				auto &buffers = info.buffers[i];
-				for (auto buffer : buffers) {
-					list.WriteElement(buffer.buffer_ptr, buffer.allocation_size);
-				}
-			});
-			return true;
-		}
-		return false;
-	});
-}
-
-void WriteAheadLog::WriteCreateIndex(const IndexCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_INDEX);
-	serializer.WriteProperty(101, "index_catalog_entry", &entry);
-
-	// Serialize the index data to the persistent storage and write the metadata.
-	auto &index_entry = entry.Cast<DuckIndexEntry>();
-	auto &list = index_entry.GetDataTableInfo().GetIndexes();
-	SerializeIndex(database, serializer, list, index_entry.name);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDropIndex(const IndexCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_INDEX);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// Custom Types
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateType(const TypeCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_TYPE);
-	serializer.WriteProperty(101, "type", &entry);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDropType(const TypeCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_TYPE);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// VIEWS
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateView(const ViewCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::CREATE_VIEW);
-	serializer.WriteProperty(101, "view", &entry);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDropView(const ViewCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_VIEW);
-	serializer.WriteProperty(101, "schema", entry.schema.name);
-	serializer.WriteProperty(102, "name", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// DROP SCHEMA
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropSchema(const SchemaCatalogEntry &entry) {
-	WriteAheadLogSerializer serializer(*this, WALType::DROP_SCHEMA);
-	serializer.WriteProperty(101, "schema", entry.name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// DATA
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteSetTable(const string &schema, const string &table) {
-	WriteAheadLogSerializer serializer(*this, WALType::USE_TABLE);
-	serializer.WriteProperty(101, "schema", schema);
-	serializer.WriteProperty(102, "table", table);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteInsert(DataChunk &chunk) {
-	D_ASSERT(chunk.size() > 0);
-	chunk.Verify();
-
-	WriteAheadLogSerializer serializer(*this, WALType::INSERT_TUPLE);
-	serializer.WriteProperty(101, "chunk", chunk);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteRowGroupData(const PersistentCollectionData &data) {
-	D_ASSERT(!data.row_group_data.empty());
-
-	WriteAheadLogSerializer serializer(*this, WALType::ROW_GROUP_DATA);
-	serializer.WriteProperty(101, "row_group_data", data);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteDelete(DataChunk &chunk) {
-	D_ASSERT(chunk.size() > 0);
-	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
-	chunk.Verify();
-
-	WriteAheadLogSerializer serializer(*this, WALType::DELETE_TUPLE);
-	serializer.WriteProperty(101, "chunk", chunk);
-	serializer.End();
-}
-
-void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column_indexes) {
-	D_ASSERT(chunk.size() > 0);
-	D_ASSERT(chunk.ColumnCount() == 2);
-	D_ASSERT(chunk.data[1].GetType().id() == LogicalType::ROW_TYPE);
-	chunk.Verify();
-
-	WriteAheadLogSerializer serializer(*this, WALType::UPDATE_TUPLE);
-	serializer.WriteProperty(101, "column_indexes", column_indexes);
-	serializer.WriteProperty(102, "chunk", chunk);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// Write ALTER Statement
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(CatalogEntry &entry, const AlterInfo &info) {
-	WriteAheadLogSerializer serializer(*this, WALType::ALTER_INFO);
-	serializer.WriteProperty(101, "info", &info);
-
-	if (!info.IsAddPrimaryKey()) {
-		return serializer.End();
-	}
-
-	auto &table_info = info.Cast<AlterTableInfo>();
-	auto &constraint_info = table_info.Cast<AddConstraintInfo>();
-	auto &unique = constraint_info.constraint->Cast<UniqueConstraint>();
-
-	auto &table_entry = entry.Cast<DuckTableEntry>();
-	auto &parent = table_entry.Parent().Cast<DuckTableEntry>();
-	auto &parent_info = parent.GetStorage().GetDataTableInfo();
-	auto &list = parent_info->GetIndexes();
-
-	auto name = unique.GetName(parent.name);
-	SerializeIndex(database, serializer, list, name);
-	serializer.End();
-}
-
-//===--------------------------------------------------------------------===//
-// FLUSH
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::Flush() {
-	if (!writer) {
-		return;
-	}
-
-	// write an empty entry
-	WriteAheadLogSerializer serializer(*this, WALType::WAL_FLUSH);
-	serializer.End();
-
-	// flushes all changes made to the WAL to disk
-	writer->Sync();
-	wal_size = writer->GetFileSize();
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/cleanup_state.cpp b/src/duckdb/src/transaction/cleanup_state.cpp
deleted file mode 100644
index f9a17f265..000000000
--- a/src/duckdb/src/transaction/cleanup_state.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "duckdb/transaction/cleanup_state.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-#include "duckdb/transaction/update_info.hpp"
-#include "duckdb/transaction/append_info.hpp"
-
-#include "duckdb/storage/data_table.hpp"
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/table/row_version_manager.hpp"
-
-namespace duckdb {
-
-CleanupState::CleanupState(transaction_t lowest_active_transaction)
-    : lowest_active_transaction(lowest_active_transaction), current_table(nullptr), count(0) {
-}
-
-CleanupState::~CleanupState() {
-	Flush();
-}
-
-void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry);
-		auto &entry = *catalog_entry;
-		D_ASSERT(entry.set);
-		entry.set->CleanupEntry(entry);
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		auto info = reinterpret_cast<AppendInfo *>(data);
-		// mark the tuples as committed
-		info->table->CleanupAppend(lowest_active_transaction, info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		auto info = reinterpret_cast<DeleteInfo *>(data);
-		CleanupDelete(*info);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		auto info = reinterpret_cast<UpdateInfo *>(data);
-		CleanupUpdate(*info);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-void CleanupState::CleanupUpdate(UpdateInfo &info) {
-	// remove the update info from the update chain
-	info.segment->CleanupUpdate(info);
-}
-
-void CleanupState::CleanupDelete(DeleteInfo &info) {
-	auto version_table = info.table;
-	if (!version_table->HasIndexes()) {
-		// this table has no indexes: no cleanup to be done
-		return;
-	}
-
-	if (current_table != version_table) {
-		// table for this entry differs from previous table: flush and switch to the new table
-		Flush();
-		current_table = version_table;
-	}
-
-	// possibly vacuum any indexes in this table later
-	indexed_tables[current_table->GetTableName()] = current_table;
-
-	count = 0;
-	if (info.is_consecutive) {
-		for (idx_t i = 0; i < info.count; i++) {
-			row_numbers[count++] = UnsafeNumericCast<int64_t>(info.base_row + i);
-		}
-	} else {
-		auto rows = info.GetRows();
-		for (idx_t i = 0; i < info.count; i++) {
-			row_numbers[count++] = UnsafeNumericCast<int64_t>(info.base_row + rows[i]);
-		}
-	}
-	Flush();
-}
-
-void CleanupState::Flush() {
-	if (count == 0) {
-		return;
-	}
-
-	// set up the row identifiers vector
-	Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_numbers));
-
-	// delete the tuples from all the indexes
-	try {
-		current_table->RemoveFromIndexes(row_identifiers, count);
-	} catch (...) { // NOLINT: ignore errors here
-	}
-
-	count = 0;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/commit_state.cpp b/src/duckdb/src/transaction/commit_state.cpp
deleted file mode 100644
index d4b934d58..000000000
--- a/src/duckdb/src/transaction/commit_state.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-#include "duckdb/transaction/commit_state.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/row_version_manager.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/transaction/append_info.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-#include "duckdb/transaction/update_info.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-
-namespace duckdb {
-
-CommitState::CommitState(DuckTransaction &transaction_p, transaction_t commit_id)
-    : transaction(transaction_p), commit_id(commit_id) {
-}
-
-void CommitState::CommitEntryDrop(CatalogEntry &entry, data_ptr_t dataptr) {
-	if (entry.temporary || entry.Parent().temporary) {
-		return;
-	}
-
-	// look at the type of the parent entry
-	auto &parent = entry.Parent();
-
-	switch (parent.type) {
-	case CatalogType::TABLE_ENTRY:
-	case CatalogType::VIEW_ENTRY:
-	case CatalogType::INDEX_ENTRY:
-	case CatalogType::SEQUENCE_ENTRY:
-	case CatalogType::TYPE_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-		if (entry.type == CatalogType::RENAMED_ENTRY || entry.type == parent.type) {
-			// ALTER statement, read the extra data after the entry
-			auto extra_data_size = Load<idx_t>(dataptr);
-			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
-
-			MemoryStream source(extra_data, extra_data_size);
-			BinaryDeserializer deserializer(source);
-			deserializer.Begin();
-			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
-			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
-			deserializer.End();
-
-			switch (parent.type) {
-			case CatalogType::TABLE_ENTRY:
-				if (!column_name.empty()) {
-					D_ASSERT(entry.type != CatalogType::RENAMED_ENTRY);
-					auto &table_entry = entry.Cast<DuckTableEntry>();
-					D_ASSERT(table_entry.IsDuckTable());
-					// write the alter table in the log
-					table_entry.CommitAlter(column_name);
-				}
-				break;
-			case CatalogType::VIEW_ENTRY:
-			case CatalogType::INDEX_ENTRY:
-			case CatalogType::SEQUENCE_ENTRY:
-			case CatalogType::TYPE_ENTRY:
-			case CatalogType::MACRO_ENTRY:
-			case CatalogType::TABLE_MACRO_ENTRY:
-				(void)column_name;
-				break;
-			default:
-				throw InternalException("Don't know how to alter this type!");
-			}
-		} else {
-			switch (parent.type) {
-			case CatalogType::TABLE_ENTRY:
-			case CatalogType::VIEW_ENTRY:
-			case CatalogType::INDEX_ENTRY:
-			case CatalogType::SEQUENCE_ENTRY:
-			case CatalogType::TYPE_ENTRY:
-			case CatalogType::MACRO_ENTRY:
-			case CatalogType::TABLE_MACRO_ENTRY:
-				break;
-			default:
-				throw InternalException("Don't know how to create this type!");
-			}
-		}
-		break;
-	case CatalogType::SCHEMA_ENTRY:
-		break;
-	case CatalogType::RENAMED_ENTRY:
-		// This is a rename, nothing needs to be done for this
-		break;
-	case CatalogType::DELETED_ENTRY:
-		switch (entry.type) {
-		case CatalogType::TABLE_ENTRY: {
-			auto &table_entry = entry.Cast<DuckTableEntry>();
-			D_ASSERT(table_entry.IsDuckTable());
-
-			// If the table was renamed, we do not need to drop the DataTable.
-			table_entry.CommitDrop();
-			break;
-		}
-		case CatalogType::INDEX_ENTRY: {
-			auto &index_entry = entry.Cast<DuckIndexEntry>();
-			index_entry.CommitDrop();
-			break;
-		}
-		default:
-			// no action required
-			break;
-		}
-		break;
-	case CatalogType::DATABASE_ENTRY:
-	case CatalogType::PREPARED_STATEMENT:
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-	case CatalogType::COPY_FUNCTION_ENTRY:
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-	case CatalogType::COLLATION_ENTRY:
-	case CatalogType::DEPENDENCY_ENTRY:
-	case CatalogType::SECRET_ENTRY:
-	case CatalogType::SECRET_TYPE_ENTRY:
-	case CatalogType::SECRET_FUNCTION_ENTRY:
-		// do nothing, these entries are not persisted to disk
-		break;
-	default:
-		throw InternalException("UndoBuffer - don't know how to write this entry to the WAL");
-	}
-}
-
-void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		auto &old_entry = *Load<CatalogEntry *>(data);
-		D_ASSERT(old_entry.HasParent());
-
-		auto &catalog = old_entry.ParentCatalog();
-		D_ASSERT(catalog.IsDuckCatalog());
-
-		auto &new_entry = old_entry.Parent();
-		if (new_entry.type == CatalogType::DEPENDENCY_ENTRY) {
-			auto &dep = new_entry.Cast<DependencyEntry>();
-			if (dep.Side() == DependencyEntryType::SUBJECT) {
-				new_entry.set->VerifyExistenceOfDependency(commit_id, new_entry);
-			}
-		} else if (new_entry.type == CatalogType::DELETED_ENTRY && old_entry.set) {
-			old_entry.set->CommitDrop(commit_id, transaction.start_time, old_entry);
-		}
-		// Grab a write lock on the catalog
-		auto &duck_catalog = catalog.Cast<DuckCatalog>();
-		lock_guard<mutex> write_lock(duck_catalog.GetWriteLock());
-		lock_guard<mutex> read_lock(old_entry.set->GetCatalogLock());
-		// Set the timestamp of the catalog entry to the given commit_id, marking it as committed
-		CatalogSet::UpdateTimestamp(old_entry.Parent(), commit_id);
-
-		// drop any blocks associated with the catalog entry if possible (e.g. in case of a DROP or ALTER)
-		CommitEntryDrop(old_entry, data + sizeof(CatalogEntry *));
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		// append:
-		auto info = reinterpret_cast<AppendInfo *>(data);
-		// mark the tuples as committed
-		info->table->CommitAppend(commit_id, info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		// deletion:
-		auto info = reinterpret_cast<DeleteInfo *>(data);
-		// mark the tuples as committed
-		info->version_info->CommitDelete(info->vector_idx, commit_id, *info);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		// update:
-		auto info = reinterpret_cast<UpdateInfo *>(data);
-		info->version_number = commit_id;
-		break;
-	}
-	case UndoFlags::SEQUENCE_VALUE: {
-		break;
-	}
-	default:
-		throw InternalException("UndoBuffer - don't know how to commit this type!");
-	}
-}
-
-void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
-	transaction_t transaction_id = commit_id;
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		// set the commit timestamp of the catalog entry to the given id
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry->HasParent());
-		CatalogSet::UpdateTimestamp(catalog_entry->Parent(), transaction_id);
-		if (catalog_entry->name != catalog_entry->Parent().name) {
-			CatalogSet::UpdateTimestamp(*catalog_entry, transaction_id);
-		}
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		auto info = reinterpret_cast<AppendInfo *>(data);
-		// revert this append
-		info->table->RevertAppend(transaction, info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		// deletion:
-		auto info = reinterpret_cast<DeleteInfo *>(data);
-		// revert the commit by writing the (uncommitted) transaction_id back into the version info
-		info->version_info->CommitDelete(info->vector_idx, transaction_id, *info);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		// update:
-		auto info = reinterpret_cast<UpdateInfo *>(data);
-		info->version_number = transaction_id;
-		break;
-	}
-	case UndoFlags::SEQUENCE_VALUE: {
-		break;
-	}
-	default:
-		throw InternalException("UndoBuffer - don't know how to revert commit of this type!");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/duck_transaction.cpp b/src/duckdb/src/transaction/duck_transaction.cpp
deleted file mode 100644
index 273f256b6..000000000
--- a/src/duckdb/src/transaction/duck_transaction.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-
-#include "duckdb/transaction/append_info.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-#include "duckdb/transaction/update_info.hpp"
-#include "duckdb/transaction/local_storage.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/table/data_table_info.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
-
-namespace duckdb {
-
-TransactionData::TransactionData(DuckTransaction &transaction_p) // NOLINT
-    : transaction(&transaction_p), transaction_id(transaction_p.transaction_id), start_time(transaction_p.start_time) {
-}
-TransactionData::TransactionData(transaction_t transaction_id_p, transaction_t start_time_p)
-    : transaction(nullptr), transaction_id(transaction_id_p), start_time(start_time_p) {
-}
-
-DuckTransaction::DuckTransaction(DuckTransactionManager &manager, ClientContext &context_p, transaction_t start_time,
-                                 transaction_t transaction_id, idx_t catalog_version_p)
-    : Transaction(manager, context_p), start_time(start_time), transaction_id(transaction_id), commit_id(0),
-      highest_active_query(0), catalog_version(catalog_version_p), transaction_manager(manager),
-      undo_buffer(*this, context_p), storage(make_uniq<LocalStorage>(context_p, *this)) {
-}
-
-DuckTransaction::~DuckTransaction() {
-}
-
-DuckTransaction &DuckTransaction::Get(ClientContext &context, AttachedDatabase &db) {
-	return DuckTransaction::Get(context, db.GetCatalog());
-}
-
-DuckTransaction &DuckTransaction::Get(ClientContext &context, Catalog &catalog) {
-	auto &transaction = Transaction::Get(context, catalog);
-	if (!transaction.IsDuckTransaction()) {
-		throw InternalException("DuckTransaction::Get called on non-DuckDB transaction");
-	}
-	return transaction.Cast<DuckTransaction>();
-}
-
-LocalStorage &DuckTransaction::GetLocalStorage() {
-	return *storage;
-}
-
-void DuckTransaction::PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data, idx_t extra_data_size) {
-	idx_t alloc_size = sizeof(CatalogEntry *);
-	if (extra_data_size > 0) {
-		alloc_size += extra_data_size + sizeof(idx_t);
-	}
-
-	auto undo_entry = undo_buffer.CreateEntry(UndoFlags::CATALOG_ENTRY, alloc_size);
-	auto ptr = undo_entry.Ptr();
-	// store the pointer to the catalog entry
-	Store<CatalogEntry *>(&entry, ptr);
-	if (extra_data_size > 0) {
-		// copy the extra data behind the catalog entry pointer (if any)
-		ptr += sizeof(CatalogEntry *);
-		// first store the extra data size
-		Store<idx_t>(extra_data_size, ptr);
-		ptr += sizeof(idx_t);
-		// then copy over the actual data
-		memcpy(ptr, extra_data, extra_data_size);
-	}
-}
-
-void DuckTransaction::PushDelete(DataTable &table, RowVersionManager &info, idx_t vector_idx, row_t rows[], idx_t count,
-                                 idx_t base_row) {
-	bool is_consecutive = true;
-	// check if the rows are consecutive
-	for (idx_t i = 0; i < count; i++) {
-		if (rows[i] != row_t(i)) {
-			is_consecutive = false;
-			break;
-		}
-	}
-	idx_t alloc_size = sizeof(DeleteInfo);
-	if (!is_consecutive) {
-		// if rows are not consecutive we need to allocate row identifiers
-		alloc_size += sizeof(uint16_t) * count;
-	}
-
-	auto undo_entry = undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, alloc_size);
-	auto delete_info = reinterpret_cast<DeleteInfo *>(undo_entry.Ptr());
-	delete_info->version_info = &info;
-	delete_info->vector_idx = vector_idx;
-	delete_info->table = &table;
-	delete_info->count = count;
-	delete_info->base_row = base_row;
-	delete_info->is_consecutive = is_consecutive;
-	if (!is_consecutive) {
-		// if rows are not consecutive
-		auto delete_rows = delete_info->GetRows();
-		for (idx_t i = 0; i < count; i++) {
-			delete_rows[i] = NumericCast<uint16_t>(rows[i]);
-		}
-	}
-}
-
-void DuckTransaction::PushAppend(DataTable &table, idx_t start_row, idx_t row_count) {
-	auto undo_entry = undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo));
-	auto append_info = reinterpret_cast<AppendInfo *>(undo_entry.Ptr());
-	append_info->table = &table;
-	append_info->start_row = start_row;
-	append_info->count = row_count;
-}
-
-UndoBufferReference DuckTransaction::CreateUpdateInfo(idx_t type_size, idx_t entries) {
-	idx_t alloc_size = UpdateInfo::GetAllocSize(type_size);
-	auto undo_entry = undo_buffer.CreateEntry(UndoFlags::UPDATE_TUPLE, alloc_size);
-	auto &update_info = UpdateInfo::Get(undo_entry);
-	UpdateInfo::Initialize(update_info, transaction_id);
-	return undo_entry;
-}
-
-void DuckTransaction::PushSequenceUsage(SequenceCatalogEntry &sequence, const SequenceData &data) {
-	lock_guard<mutex> l(sequence_lock);
-	auto entry = sequence_usage.find(sequence);
-	if (entry == sequence_usage.end()) {
-		auto undo_entry = undo_buffer.CreateEntry(UndoFlags::SEQUENCE_VALUE, sizeof(SequenceValue));
-		auto sequence_info = reinterpret_cast<SequenceValue *>(undo_entry.Ptr());
-		sequence_info->entry = &sequence;
-		sequence_info->usage_count = data.usage_count;
-		sequence_info->counter = data.counter;
-		sequence_usage.emplace(sequence, *sequence_info);
-	} else {
-		auto &sequence_info = entry->second.get();
-		D_ASSERT(RefersToSameObject(*sequence_info.entry, sequence));
-		sequence_info.usage_count = data.usage_count;
-		sequence_info.counter = data.counter;
-	}
-}
-
-void DuckTransaction::UpdateCollection(shared_ptr<RowGroupCollection> &collection) {
-	auto collection_ref = reference<RowGroupCollection>(*collection);
-	auto entry = updated_collections.find(collection_ref);
-	if (entry != updated_collections.end()) {
-		// already exists
-		return;
-	}
-	updated_collections.insert(make_pair(collection_ref, collection));
-}
-
-bool DuckTransaction::ChangesMade() {
-	return undo_buffer.ChangesMade() || storage->ChangesMade();
-}
-
-UndoBufferProperties DuckTransaction::GetUndoProperties() {
-	return undo_buffer.GetProperties();
-}
-
-bool DuckTransaction::AutomaticCheckpoint(AttachedDatabase &db, const UndoBufferProperties &properties) {
-	if (!ChangesMade()) {
-		// read-only transactions cannot trigger an automated checkpoint
-		return false;
-	}
-	if (db.IsReadOnly()) {
-		// when attaching a database in read-only mode we cannot checkpoint
-		// note that attaching a database in read-only mode does NOT mean we never make changes
-		// WAL replay can make changes to the database - but only in the in-memory copy of the
-		return false;
-	}
-	auto &storage_manager = db.GetStorageManager();
-	return storage_manager.AutomaticCheckpoint(storage->EstimatedSize() + properties.estimated_size);
-}
-
-bool DuckTransaction::ShouldWriteToWAL(AttachedDatabase &db) {
-	if (!ChangesMade()) {
-		return false;
-	}
-	if (db.IsSystem()) {
-		return false;
-	}
-	auto &storage_manager = db.GetStorageManager();
-	auto log = storage_manager.GetWAL();
-	if (!log) {
-		return false;
-	}
-	return true;
-}
-
-ErrorData DuckTransaction::WriteToWAL(AttachedDatabase &db, unique_ptr<StorageCommitState> &commit_state) noexcept {
-	try {
-		D_ASSERT(ShouldWriteToWAL(db));
-		auto &storage_manager = db.GetStorageManager();
-		auto log = storage_manager.GetWAL();
-		commit_state = storage_manager.GenStorageCommitState(*log);
-		storage->Commit(commit_state.get());
-		undo_buffer.WriteToWAL(*log, commit_state.get());
-		if (commit_state->HasRowGroupData()) {
-			// if we have optimistically written any data AND we are writing to the WAL, we have written references to
-			// optimistically written blocks
-			// hence we need to ensure those optimistically written blocks are persisted
-			storage_manager.GetBlockManager().FileSync();
-		}
-	} catch (std::exception &ex) {
-		if (commit_state) {
-			commit_state->RevertCommit();
-			commit_state.reset();
-		}
-		return ErrorData(ex);
-	}
-	return ErrorData();
-}
-
-ErrorData DuckTransaction::Commit(AttachedDatabase &db, transaction_t new_commit_id,
-                                  unique_ptr<StorageCommitState> commit_state) noexcept {
-	// "checkpoint" parameter indicates if the caller will checkpoint. If checkpoint ==
-	//    true: Then this function will NOT write to the WAL or flush/persist.
-	//          This method only makes commit in memory, expecting caller to checkpoint/flush.
-	//    false: Then this function WILL write to the WAL and Flush/Persist it.
-	this->commit_id = new_commit_id;
-	if (!ChangesMade()) {
-		// no need to flush anything if we made no changes
-		return ErrorData();
-	}
-	D_ASSERT(db.IsSystem() || db.IsTemporary() || !IsReadOnly());
-
-	UndoBuffer::IteratorState iterator_state;
-	try {
-		storage->Commit(commit_state.get());
-		undo_buffer.Commit(iterator_state, commit_id);
-		if (commit_state) {
-			// if we have written to the WAL - flush after the commit has been successful
-			commit_state->FlushCommit();
-		}
-		return ErrorData();
-	} catch (std::exception &ex) {
-		undo_buffer.RevertCommit(iterator_state, this->transaction_id);
-		if (commit_state) {
-			// if we have written to the WAL - truncate the WAL on failure
-			commit_state->RevertCommit();
-		}
-		return ErrorData(ex);
-	}
-}
-
-ErrorData DuckTransaction::Rollback() {
-	try {
-		storage->Rollback();
-		undo_buffer.Rollback();
-		return ErrorData();
-	} catch (std::exception &ex) {
-		return ErrorData(ex);
-	}
-}
-
-void DuckTransaction::Cleanup(transaction_t lowest_active_transaction) {
-	undo_buffer.Cleanup(lowest_active_transaction);
-}
-
-void DuckTransaction::SetReadWrite() {
-	Transaction::SetReadWrite();
-	// obtain a shared checkpoint lock to prevent concurrent checkpoints while this transaction is running
-	write_lock = transaction_manager.SharedCheckpointLock();
-}
-
-unique_ptr<StorageLockKey> DuckTransaction::TryGetCheckpointLock() {
-	if (!write_lock) {
-		throw InternalException("TryUpgradeCheckpointLock - but thread has no shared lock!?");
-	}
-	return transaction_manager.TryUpgradeCheckpointLock(*write_lock);
-}
-
-shared_ptr<CheckpointLock> DuckTransaction::SharedLockTable(DataTableInfo &info) {
-	unique_lock<mutex> transaction_lock(active_locks_lock);
-	auto entry = active_locks.find(info);
-	if (entry == active_locks.end()) {
-		entry = active_locks.insert(entry, make_pair(std::ref(info), make_uniq<ActiveTableLock>()));
-	}
-	auto &active_table_lock = *entry->second;
-	transaction_lock.unlock(); // release transaction-level lock before acquiring table-level lock
-	lock_guard<mutex> table_lock(active_table_lock.checkpoint_lock_mutex);
-	auto checkpoint_lock = active_table_lock.checkpoint_lock.lock();
-	// check if it is expired (or has never been acquired yet)
-	if (checkpoint_lock) {
-		// not expired - return it
-		return checkpoint_lock;
-	}
-	// no existing lock - obtain it
-	checkpoint_lock = make_shared_ptr<CheckpointLock>(info.GetSharedLock());
-	// store it for future reference
-	active_table_lock.checkpoint_lock = checkpoint_lock;
-	return checkpoint_lock;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/duck_transaction_manager.cpp b/src/duckdb/src/transaction/duck_transaction_manager.cpp
deleted file mode 100644
index 15248dabd..000000000
--- a/src/duckdb/src/transaction/duck_transaction_manager.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-
-namespace duckdb {
-
-DuckTransactionManager::DuckTransactionManager(AttachedDatabase &db) : TransactionManager(db) {
-	// start timestamp starts at two
-	current_start_timestamp = 2;
-	// transaction ID starts very high:
-	// it should be much higher than the current start timestamp
-	// if transaction_id < start_timestamp for any set of active transactions
-	// uncommitted data could be read by
-	current_transaction_id = TRANSACTION_ID_START;
-	lowest_active_id = TRANSACTION_ID_START;
-	lowest_active_start = MAX_TRANSACTION_ID;
-	if (!db.GetCatalog().IsDuckCatalog()) {
-		// Specifically the StorageManager of the DuckCatalog is relied on, with `db.GetStorageManager`
-		throw InternalException("DuckTransactionManager should only be created together with a DuckCatalog");
-	}
-}
-
-DuckTransactionManager::~DuckTransactionManager() {
-}
-
-DuckTransactionManager &DuckTransactionManager::Get(AttachedDatabase &db) {
-	auto &transaction_manager = TransactionManager::Get(db);
-	if (!transaction_manager.IsDuckTransactionManager()) {
-		throw InternalException("Calling DuckTransactionManager::Get on non-DuckDB transaction manager");
-	}
-	return reinterpret_cast<DuckTransactionManager &>(transaction_manager);
-}
-
-Transaction &DuckTransactionManager::StartTransaction(ClientContext &context) {
-	// obtain the transaction lock during this function
-	auto &meta_transaction = MetaTransaction::Get(context);
-	unique_ptr<lock_guard<mutex>> start_lock;
-	if (!meta_transaction.IsReadOnly()) {
-		start_lock = make_uniq<lock_guard<mutex>>(start_transaction_lock);
-	}
-	lock_guard<mutex> lock(transaction_lock);
-	if (current_start_timestamp >= TRANSACTION_ID_START) { // LCOV_EXCL_START
-		throw InternalException("Cannot start more transactions, ran out of "
-		                        "transaction identifiers!");
-	} // LCOV_EXCL_STOP
-
-	// obtain the start time and transaction ID of this transaction
-	transaction_t start_time = current_start_timestamp++;
-	transaction_t transaction_id = current_transaction_id++;
-	if (active_transactions.empty()) {
-		lowest_active_start = start_time;
-		lowest_active_id = transaction_id;
-	}
-
-	// create the actual transaction
-	auto transaction = make_uniq<DuckTransaction>(*this, context, start_time, transaction_id, last_committed_version);
-	auto &transaction_ref = *transaction;
-
-	// store it in the set of active transactions
-	active_transactions.push_back(std::move(transaction));
-	return transaction_ref;
-}
-
-DuckTransactionManager::CheckpointDecision::CheckpointDecision(string reason_p)
-    : can_checkpoint(false), reason(std::move(reason_p)) {
-}
-
-DuckTransactionManager::CheckpointDecision::CheckpointDecision(CheckpointType type) : can_checkpoint(true), type(type) {
-}
-
-DuckTransactionManager::CheckpointDecision::~CheckpointDecision() {
-}
-
-DuckTransactionManager::CheckpointDecision
-DuckTransactionManager::CanCheckpoint(DuckTransaction &transaction, unique_ptr<StorageLockKey> &lock,
-                                      const UndoBufferProperties &undo_properties) {
-	if (db.IsSystem()) {
-		return CheckpointDecision("system transaction");
-	}
-	auto &storage_manager = db.GetStorageManager();
-	if (storage_manager.InMemory()) {
-		return CheckpointDecision("in memory db");
-	}
-	if (!storage_manager.IsLoaded()) {
-		return CheckpointDecision("cannot checkpoint while loading");
-	}
-	if (!transaction.AutomaticCheckpoint(db, undo_properties)) {
-		return CheckpointDecision("no reason to automatically checkpoint");
-	}
-	auto &config = DBConfig::GetConfig(db.GetDatabase());
-	if (config.options.debug_skip_checkpoint_on_commit) {
-		return CheckpointDecision("checkpointing on commit disabled through configuration");
-	}
-	// try to lock the checkpoint lock
-	lock = transaction.TryGetCheckpointLock();
-	if (!lock) {
-		return CheckpointDecision("Failed to obtain checkpoint lock - another thread is writing/checkpointing or "
-		                          "another read transaction relies on data that is not yet committed");
-	}
-	auto checkpoint_type = CheckpointType::FULL_CHECKPOINT;
-	if (undo_properties.has_updates || undo_properties.has_deletes || undo_properties.has_dropped_entries) {
-		// if we have made updates/deletes/catalog changes in this transaction we might need to change our strategy
-		// in the presence of other transactions
-		string other_transactions;
-		for (auto &active_transaction : active_transactions) {
-			if (!RefersToSameObject(*active_transaction, transaction)) {
-				if (!other_transactions.empty()) {
-					other_transactions += ", ";
-				}
-				other_transactions += "[" + to_string(active_transaction->transaction_id) + "]";
-			}
-		}
-		if (!other_transactions.empty()) {
-			// there are other transactions!
-			// these active transactions might need data from BEFORE this transaction
-			// we might need to change our strategy here based on what changes THIS transaction has made
-			if (undo_properties.has_dropped_entries) {
-				// this transaction has changed the catalog - we cannot checkpoint
-				return CheckpointDecision("Transaction has dropped catalog entries and there are other transactions "
-				                          "active\nActive transactions: " +
-				                          other_transactions);
-			} else if (undo_properties.has_updates) {
-				// this transaction has performed updates - we cannot checkpoint
-				return CheckpointDecision(
-				    "Transaction has performed updates and there are other transactions active\nActive transactions: " +
-				    other_transactions);
-			} else {
-				// this transaction has performed deletes - we cannot vacuum - initiate a concurrent checkpoint instead
-				D_ASSERT(undo_properties.has_deletes);
-				checkpoint_type = CheckpointType::CONCURRENT_CHECKPOINT;
-			}
-		}
-	}
-	return CheckpointDecision(checkpoint_type);
-}
-
-void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
-	auto &storage_manager = db.GetStorageManager();
-	if (storage_manager.InMemory()) {
-		return;
-	}
-
-	auto current = Transaction::TryGet(context, db);
-	if (current) {
-		if (force) {
-			throw TransactionException(
-			    "Cannot FORCE CHECKPOINT: the current transaction has been started for this database");
-		} else {
-			auto &duck_transaction = current->Cast<DuckTransaction>();
-			if (duck_transaction.ChangesMade()) {
-				throw TransactionException("Cannot CHECKPOINT: the current transaction has transaction local changes");
-			}
-		}
-	}
-
-	unique_ptr<StorageLockKey> lock;
-	if (!force) {
-		// not a force checkpoint
-		// try to get the checkpoint lock
-		lock = checkpoint_lock.TryGetExclusiveLock();
-		if (!lock) {
-			// we could not manage to get the lock - cancel
-			throw TransactionException("Cannot CHECKPOINT: there are other write transactions active. Try using FORCE "
-			                           "CHECKPOINT to wait until all active transactions are finished");
-		}
-
-	} else {
-		// force checkpoint - wait to get an exclusive lock
-		// grab the start_transaction_lock to prevent new transactions from starting
-		lock_guard<mutex> start_lock(start_transaction_lock);
-		// wait until any active transactions are finished
-		while (!lock) {
-			if (context.interrupted) {
-				throw InterruptException();
-			}
-			lock = checkpoint_lock.TryGetExclusiveLock();
-		}
-	}
-	CheckpointOptions options;
-	if (GetLastCommit() > LowestActiveStart()) {
-		// we cannot do a full checkpoint if any transaction needs to read old data
-		options.type = CheckpointType::CONCURRENT_CHECKPOINT;
-	}
-	storage_manager.CreateCheckpoint(options);
-}
-
-unique_ptr<StorageLockKey> DuckTransactionManager::SharedCheckpointLock() {
-	return checkpoint_lock.GetSharedLock();
-}
-
-unique_ptr<StorageLockKey> DuckTransactionManager::TryUpgradeCheckpointLock(StorageLockKey &lock) {
-	return checkpoint_lock.TryUpgradeCheckpointLock(lock);
-}
-
-transaction_t DuckTransactionManager::GetCommitTimestamp() {
-	auto commit_ts = current_start_timestamp++;
-	last_commit = commit_ts;
-	return commit_ts;
-}
-
-ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Transaction &transaction_p) {
-	auto &transaction = transaction_p.Cast<DuckTransaction>();
-	unique_lock<mutex> tlock(transaction_lock);
-	if (!db.IsSystem() && !db.IsTemporary()) {
-		if (transaction.ChangesMade()) {
-			if (transaction.IsReadOnly()) {
-				throw InternalException("Attempting to commit a transaction that is read-only but has made changes - "
-				                        "this should not be possible");
-			}
-		}
-	}
-
-	// check if we can checkpoint
-	unique_ptr<StorageLockKey> lock;
-	auto undo_properties = transaction.GetUndoProperties();
-	auto checkpoint_decision = CanCheckpoint(transaction, lock, undo_properties);
-	ErrorData error;
-	unique_ptr<lock_guard<mutex>> held_wal_lock;
-	unique_ptr<StorageCommitState> commit_state;
-	if (!checkpoint_decision.can_checkpoint && transaction.ShouldWriteToWAL(db)) {
-		// if we are committing changes and we are not checkpointing, we need to write to the WAL
-		// since WAL writes can take a long time - we grab the WAL lock here and unlock the transaction lock
-		// read-only transactions can bypass this branch and start/commit while the WAL write is happening
-		if (!transaction.HasWriteLock()) {
-			// sanity check - this transaction should have a write lock
-			// the write lock prevents other transactions from checkpointing until this transaction is fully finished
-			// if we do not hold the write lock here, other transactions can bypass this branch by auto-checkpoint
-			// this would lead to a checkpoint WHILE this thread is writing to the WAL
-			// this should never happen
-			throw InternalException("Transaction writing to WAL does not have the write lock");
-		}
-		// unlock the transaction lock while we write to the WAL
-		tlock.unlock();
-		// grab the WAL lock and hold it until the entire commit is finished
-		held_wal_lock = make_uniq<lock_guard<mutex>>(wal_lock);
-		error = transaction.WriteToWAL(db, commit_state);
-
-		// after we finish writing to the WAL we grab the transaction lock again
-		tlock.lock();
-	}
-	// obtain a commit id for the transaction
-	transaction_t commit_id = GetCommitTimestamp();
-	// commit the UndoBuffer of the transaction
-	if (!error.HasError()) {
-		error = transaction.Commit(db, commit_id, std::move(commit_state));
-	}
-	if (error.HasError()) {
-		// commit unsuccessful: rollback the transaction instead
-		checkpoint_decision = CheckpointDecision(error.Message());
-		transaction.commit_id = 0;
-		auto rollback_error = transaction.Rollback();
-		if (rollback_error.HasError()) {
-			throw FatalException("Failed to rollback transaction. Cannot continue operation.\nError: %s",
-			                     rollback_error.Message());
-		}
-	} else {
-		// check if catalog changes were made
-		if (transaction.catalog_version >= TRANSACTION_ID_START) {
-			transaction.catalog_version = ++last_committed_version;
-		}
-	}
-	OnCommitCheckpointDecision(checkpoint_decision, transaction);
-
-	if (!checkpoint_decision.can_checkpoint && lock) {
-		// we won't checkpoint after all: unlock the checkpoint lock again
-		lock.reset();
-	}
-
-	// commit successful: remove the transaction id from the list of active transactions
-	// potentially resulting in garbage collection
-	bool store_transaction = undo_properties.has_updates || undo_properties.has_index_deletes ||
-	                         undo_properties.has_catalog_changes || error.HasError();
-	RemoveTransaction(transaction, store_transaction);
-	// now perform a checkpoint if (1) we are able to checkpoint, and (2) the WAL has reached sufficient size to
-	// checkpoint
-	if (checkpoint_decision.can_checkpoint) {
-		D_ASSERT(lock);
-		// we can unlock the transaction lock while checkpointing
-		tlock.unlock();
-		// checkpoint the database to disk
-		CheckpointOptions options;
-		options.action = CheckpointAction::ALWAYS_CHECKPOINT;
-		options.type = checkpoint_decision.type;
-		auto &storage_manager = db.GetStorageManager();
-		storage_manager.CreateCheckpoint(options);
-	}
-	return error;
-}
-
-void DuckTransactionManager::RollbackTransaction(Transaction &transaction_p) {
-	auto &transaction = transaction_p.Cast<DuckTransaction>();
-	// obtain the transaction lock during this function
-	lock_guard<mutex> lock(transaction_lock);
-
-	// rollback the transaction
-	auto error = transaction.Rollback();
-
-	// remove the transaction id from the list of active transactions
-	// potentially resulting in garbage collection
-	RemoveTransaction(transaction);
-
-	if (error.HasError()) {
-		throw FatalException("Failed to rollback transaction. Cannot continue operation.\nError: %s", error.Message());
-	}
-}
-
-void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noexcept {
-	RemoveTransaction(transaction, transaction.ChangesMade());
-}
-
-void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction, bool store_transaction) noexcept {
-	// remove the transaction from the list of active transactions
-	idx_t t_index = active_transactions.size();
-	// check for the lowest and highest start time in the list of transactions
-	transaction_t lowest_start_time = TRANSACTION_ID_START;
-	transaction_t lowest_transaction_id = MAX_TRANSACTION_ID;
-	transaction_t lowest_active_query = MAXIMUM_QUERY_ID;
-	for (idx_t i = 0; i < active_transactions.size(); i++) {
-		if (active_transactions[i].get() == &transaction) {
-			t_index = i;
-		} else {
-			transaction_t active_query = active_transactions[i]->active_query;
-			lowest_start_time = MinValue(lowest_start_time, active_transactions[i]->start_time);
-			lowest_active_query = MinValue(lowest_active_query, active_query);
-			lowest_transaction_id = MinValue(lowest_transaction_id, active_transactions[i]->transaction_id);
-		}
-	}
-	lowest_active_start = lowest_start_time;
-	lowest_active_id = lowest_transaction_id;
-
-	transaction_t lowest_stored_query = lowest_start_time;
-	D_ASSERT(t_index != active_transactions.size());
-	auto current_transaction = std::move(active_transactions[t_index]);
-	auto current_query = DatabaseManager::Get(db).ActiveQueryNumber();
-	if (store_transaction) {
-		// if the transaction made any changes we need to keep it around
-		if (transaction.commit_id != 0) {
-			// the transaction was committed, add it to the list of recently
-			// committed transactions
-			recently_committed_transactions.push_back(std::move(current_transaction));
-		} else {
-			// the transaction was aborted, but we might still need its information
-			// add it to the set of transactions awaiting GC
-			current_transaction->highest_active_query = current_query;
-			old_transactions.push_back(std::move(current_transaction));
-		}
-	} else if (transaction.ChangesMade()) {
-		transaction.Cleanup(lowest_start_time);
-	}
-	// remove the transaction from the set of currently active transactions
-	active_transactions.unsafe_erase_at(t_index);
-	// traverse the recently_committed transactions to see if we can remove any
-	idx_t i = 0;
-	for (; i < recently_committed_transactions.size(); i++) {
-		D_ASSERT(recently_committed_transactions[i]);
-		lowest_stored_query = MinValue(recently_committed_transactions[i]->start_time, lowest_stored_query);
-		if (recently_committed_transactions[i]->commit_id < lowest_start_time) {
-			// changes made BEFORE this transaction are no longer relevant
-			// we can cleanup the undo buffer
-
-			// HOWEVER: any currently running QUERY can still be using
-			// the version information after the cleanup!
-
-			// if we remove the UndoBuffer immediately, we have a race
-			// condition
-
-			// we can only safely do the actual memory cleanup when all the
-			// currently active queries have finished running! (actually,
-			// when all the currently active scans have finished running...)
-			recently_committed_transactions[i]->Cleanup(lowest_start_time);
-			// store the current highest active query
-			recently_committed_transactions[i]->highest_active_query = current_query;
-			// move it to the list of transactions awaiting GC
-			old_transactions.push_back(std::move(recently_committed_transactions[i]));
-		} else {
-			// recently_committed_transactions is ordered on commit_id
-			// implicitly thus if the current one is bigger than
-			// lowest_start_time any subsequent ones are also bigger
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected transactions: remove them from the list
-		recently_committed_transactions.erase(recently_committed_transactions.begin(),
-		                                      recently_committed_transactions.begin() + static_cast<int64_t>(i));
-	}
-	// check if we can free the memory of any old transactions
-	i = active_transactions.empty() ? old_transactions.size() : 0;
-	for (; i < old_transactions.size(); i++) {
-		D_ASSERT(old_transactions[i]);
-		D_ASSERT(old_transactions[i]->highest_active_query > 0);
-		if (old_transactions[i]->highest_active_query >= lowest_active_query) {
-			// there is still a query running that could be using
-			// this transactions' data
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected transactions: remove them from the list
-		old_transactions.erase(old_transactions.begin(), old_transactions.begin() + static_cast<int64_t>(i));
-	}
-}
-
-idx_t DuckTransactionManager::GetCatalogVersion(Transaction &transaction_p) {
-	auto &transaction = transaction_p.Cast<DuckTransaction>();
-	return transaction.catalog_version;
-}
-
-void DuckTransactionManager::PushCatalogEntry(Transaction &transaction_p, duckdb::CatalogEntry &entry,
-                                              duckdb::data_ptr_t extra_data, duckdb::idx_t extra_data_size) {
-	auto &transaction = transaction_p.Cast<DuckTransaction>();
-	if (!db.IsSystem() && !db.IsTemporary() && transaction.IsReadOnly()) {
-		throw InternalException("Attempting to do catalog changes on a transaction that is read-only - "
-		                        "this should not be possible");
-	}
-	transaction.catalog_version = ++last_uncommitted_catalog_version;
-	transaction.PushCatalogEntry(entry, extra_data, extra_data_size);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/meta_transaction.cpp b/src/duckdb/src/transaction/meta_transaction.cpp
deleted file mode 100644
index 4c4baceca..000000000
--- a/src/duckdb/src/transaction/meta_transaction.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-
-namespace duckdb {
-
-MetaTransaction::MetaTransaction(ClientContext &context_p, timestamp_t start_timestamp_p)
-    : context(context_p), start_timestamp(start_timestamp_p), active_query(MAXIMUM_QUERY_ID),
-      modified_database(nullptr), is_read_only(false) {
-}
-
-MetaTransaction &MetaTransaction::Get(ClientContext &context) {
-	return context.transaction.ActiveTransaction();
-}
-
-ValidChecker &ValidChecker::Get(MetaTransaction &transaction) {
-	return transaction.transaction_validity;
-}
-
-Transaction &Transaction::Get(ClientContext &context, AttachedDatabase &db) {
-	auto &meta_transaction = MetaTransaction::Get(context);
-	return meta_transaction.GetTransaction(db);
-}
-
-optional_ptr<Transaction> Transaction::TryGet(ClientContext &context, AttachedDatabase &db) {
-	auto &meta_transaction = MetaTransaction::Get(context);
-	return meta_transaction.TryGetTransaction(db);
-}
-
-#ifdef DEBUG
-static void VerifyAllTransactionsUnique(AttachedDatabase &db, vector<reference<AttachedDatabase>> &all_transactions) {
-	for (auto &tx : all_transactions) {
-		if (RefersToSameObject(db, tx.get())) {
-			throw InternalException("Database is already present in all_transactions");
-		}
-	}
-}
-#endif
-
-optional_ptr<Transaction> MetaTransaction::TryGetTransaction(AttachedDatabase &db) {
-	lock_guard<mutex> guard(lock);
-	auto entry = transactions.find(db);
-	if (entry == transactions.end()) {
-		return nullptr;
-	} else {
-		return &entry->second.get();
-	}
-}
-
-Transaction &MetaTransaction::GetTransaction(AttachedDatabase &db) {
-	lock_guard<mutex> guard(lock);
-	auto entry = transactions.find(db);
-	if (entry == transactions.end()) {
-		auto &new_transaction = db.GetTransactionManager().StartTransaction(context);
-		new_transaction.active_query = active_query;
-#ifdef DEBUG
-		VerifyAllTransactionsUnique(db, all_transactions);
-#endif
-		all_transactions.push_back(db);
-		transactions.insert(make_pair(reference<AttachedDatabase>(db), reference<Transaction>(new_transaction)));
-
-		return new_transaction;
-	} else {
-		D_ASSERT(entry->second.get().active_query == active_query);
-		return entry->second;
-	}
-}
-
-void MetaTransaction::RemoveTransaction(AttachedDatabase &db) {
-	auto entry = transactions.find(db);
-	if (entry == transactions.end()) {
-		throw InternalException("MetaTransaction::RemoveTransaction called but meta transaction did not have a "
-		                        "transaction for this database");
-	}
-	transactions.erase(entry);
-	for (idx_t i = 0; i < all_transactions.size(); i++) {
-		auto &db_entry = all_transactions[i];
-		if (RefersToSameObject(db_entry.get(), db)) {
-			all_transactions.erase_at(i);
-			break;
-		}
-	}
-}
-
-void MetaTransaction::SetReadOnly() {
-	if (modified_database) {
-		throw InternalException("Cannot set MetaTransaction to read only - modifications have already been made");
-	}
-	this->is_read_only = true;
-}
-
-bool MetaTransaction::IsReadOnly() const {
-	return is_read_only;
-}
-
-Transaction &Transaction::Get(ClientContext &context, Catalog &catalog) {
-	return Transaction::Get(context, catalog.GetAttached());
-}
-
-ErrorData MetaTransaction::Commit() {
-	ErrorData error;
-#ifdef DEBUG
-	reference_set_t<AttachedDatabase> committed_tx;
-#endif
-	// commit transactions in reverse order
-	for (idx_t i = all_transactions.size(); i > 0; i--) {
-		auto &db = all_transactions[i - 1].get();
-		auto entry = transactions.find(db);
-		if (entry == transactions.end()) {
-			throw InternalException("Could not find transaction corresponding to database in MetaTransaction");
-		}
-#ifdef DEBUG
-		auto already_committed = committed_tx.insert(db).second == false;
-		if (already_committed) {
-			throw InternalException("All databases inside all_transactions should be unique, invariant broken!");
-		}
-#endif
-		auto &transaction_manager = db.GetTransactionManager();
-		auto &transaction = entry->second.get();
-		if (!error.HasError()) {
-			// commit
-			error = transaction_manager.CommitTransaction(context, transaction);
-		} else {
-			// we have encountered an error previously - roll back subsequent entries
-			transaction_manager.RollbackTransaction(transaction);
-		}
-	}
-	return error;
-}
-
-void MetaTransaction::Rollback() {
-	// rollback transactions in reverse order
-	for (idx_t i = all_transactions.size(); i > 0; i--) {
-		auto &db = all_transactions[i - 1].get();
-		auto &transaction_manager = db.GetTransactionManager();
-		auto entry = transactions.find(db);
-		D_ASSERT(entry != transactions.end());
-		auto &transaction = entry->second.get();
-		transaction_manager.RollbackTransaction(transaction);
-	}
-}
-
-idx_t MetaTransaction::GetActiveQuery() {
-	return active_query;
-}
-
-void MetaTransaction::SetActiveQuery(transaction_t query_number) {
-	active_query = query_number;
-	for (auto &entry : transactions) {
-		entry.second.get().active_query = query_number;
-	}
-}
-
-void MetaTransaction::ModifyDatabase(AttachedDatabase &db) {
-	if (db.IsSystem() || db.IsTemporary()) {
-		// we can always modify the system and temp databases
-		return;
-	}
-	if (IsReadOnly()) {
-		throw TransactionException("Cannot write to database \"%s\" - transaction is launched in read-only mode",
-		                           db.GetName());
-	}
-	if (!modified_database) {
-		modified_database = &db;
-
-		auto &transaction = GetTransaction(db);
-		transaction.SetReadWrite();
-		return;
-	}
-	if (&db != modified_database.get()) {
-		throw TransactionException(
-		    "Attempting to write to database \"%s\" in a transaction that has already modified database \"%s\" - a "
-		    "single transaction can only write to a single attached database.",
-		    db.GetName(), modified_database->GetName());
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/rollback_state.cpp b/src/duckdb/src/transaction/rollback_state.cpp
deleted file mode 100644
index 335c35eff..000000000
--- a/src/duckdb/src/transaction/rollback_state.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "duckdb/transaction/rollback_state.hpp"
-#include "duckdb/transaction/append_info.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-#include "duckdb/transaction/update_info.hpp"
-
-#include "duckdb/storage/table/chunk_info.hpp"
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/table/row_version_manager.hpp"
-
-namespace duckdb {
-
-RollbackState::RollbackState(DuckTransaction &transaction_p) : transaction(transaction_p) {
-}
-
-void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		// Load and undo the catalog entry.
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry->set);
-		catalog_entry->set->Undo(*catalog_entry);
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		auto info = reinterpret_cast<AppendInfo *>(data);
-		// revert the append in the base table
-		info->table->RevertAppend(transaction, info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		auto info = reinterpret_cast<DeleteInfo *>(data);
-		// reset the deleted flag on rollback
-		info->version_info->CommitDelete(info->vector_idx, NOT_DELETED_ID, *info);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		auto info = reinterpret_cast<UpdateInfo *>(data);
-		info->segment->RollbackUpdate(*info);
-		break;
-	}
-	case UndoFlags::SEQUENCE_VALUE:
-		break;
-	default: // LCOV_EXCL_START
-		D_ASSERT(type == UndoFlags::EMPTY_ENTRY);
-		break;
-	} // LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/transaction.cpp b/src/duckdb/src/transaction/transaction.cpp
deleted file mode 100644
index 1f18a6d56..000000000
--- a/src/duckdb/src/transaction/transaction.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/main/client_context.hpp"
-
-namespace duckdb {
-
-Transaction::Transaction(TransactionManager &manager_p, ClientContext &context_p)
-    : manager(manager_p), context(context_p.shared_from_this()), active_query(MAXIMUM_QUERY_ID), is_read_only(true) {
-}
-
-Transaction::~Transaction() {
-}
-
-bool Transaction::IsReadOnly() {
-	return is_read_only;
-}
-
-void Transaction::SetReadWrite() {
-	D_ASSERT(is_read_only);
-	is_read_only = false;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/transaction_context.cpp b/src/duckdb/src/transaction/transaction_context.cpp
deleted file mode 100644
index 67f8cfec4..000000000
--- a/src/duckdb/src/transaction/transaction_context.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "duckdb/transaction/transaction_context.hpp"
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/client_context_state.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-
-namespace duckdb {
-
-TransactionContext::TransactionContext(ClientContext &context)
-    : context(context), auto_commit(true), current_transaction(nullptr) {
-}
-
-TransactionContext::~TransactionContext() {
-	if (current_transaction) {
-		try {
-			Rollback(nullptr);
-		} catch (...) { // NOLINT
-		}
-	}
-}
-
-void TransactionContext::BeginTransaction() {
-	if (current_transaction) {
-		throw TransactionException("cannot start a transaction within a transaction");
-	}
-	auto start_timestamp = Timestamp::GetCurrentTimestamp();
-	current_transaction = make_uniq<MetaTransaction>(context, start_timestamp);
-
-	// Notify any registered state of transaction begin
-	for (auto &state : context.registered_state->States()) {
-		state->TransactionBegin(*current_transaction, context);
-	}
-}
-
-void TransactionContext::Commit() {
-	if (!current_transaction) {
-		throw TransactionException("failed to commit: no transaction active");
-	}
-	auto transaction = std::move(current_transaction);
-	ClearTransaction();
-	auto error = transaction->Commit();
-	// Notify any registered state of transaction commit
-	if (error.HasError()) {
-		for (auto const &s : context.registered_state->States()) {
-			s->TransactionRollback(*transaction, context, error);
-		}
-		throw TransactionException("Failed to commit: %s", error.RawMessage());
-	} else {
-		for (auto &state : context.registered_state->States()) {
-			state->TransactionCommit(*transaction, context);
-		}
-	}
-}
-
-void TransactionContext::SetAutoCommit(bool value) {
-	auto_commit = value;
-	if (!auto_commit && !current_transaction) {
-		BeginTransaction();
-	}
-}
-
-void TransactionContext::SetReadOnly() {
-	current_transaction->SetReadOnly();
-}
-
-void TransactionContext::Rollback(optional_ptr<ErrorData> error) {
-	if (!current_transaction) {
-		throw TransactionException("failed to rollback: no transaction active");
-	}
-	auto transaction = std::move(current_transaction);
-	ClearTransaction();
-	ErrorData rollback_error;
-	try {
-		transaction->Rollback();
-	} catch (std::exception &ex) {
-		rollback_error = ErrorData(ex);
-	}
-	// Notify any registered state of transaction rollback
-	for (auto const &s : context.registered_state->States()) {
-		s->TransactionRollback(*transaction, context, error);
-	}
-	if (rollback_error.HasError()) {
-		rollback_error.Throw();
-	}
-}
-
-void TransactionContext::ClearTransaction() {
-	SetAutoCommit(true);
-	current_transaction = nullptr;
-}
-
-idx_t TransactionContext::GetActiveQuery() {
-	if (!current_transaction) {
-		throw InternalException("GetActiveQuery called without active transaction");
-	}
-	return current_transaction->GetActiveQuery();
-}
-
-void TransactionContext::ResetActiveQuery() {
-	if (current_transaction) {
-		SetActiveQuery(MAXIMUM_QUERY_ID);
-	}
-}
-
-void TransactionContext::SetActiveQuery(transaction_t query_number) {
-	if (!current_transaction) {
-		throw InternalException("SetActiveQuery called without active transaction");
-	}
-	current_transaction->SetActiveQuery(query_number);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/transaction_manager.cpp b/src/duckdb/src/transaction/transaction_manager.cpp
deleted file mode 100644
index 90ec3a425..000000000
--- a/src/duckdb/src/transaction/transaction_manager.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "duckdb/transaction/transaction_manager.hpp"
-
-namespace duckdb {
-
-TransactionManager::TransactionManager(AttachedDatabase &db) : db(db) {
-}
-
-TransactionManager::~TransactionManager() {
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/undo_buffer.cpp b/src/duckdb/src/transaction/undo_buffer.cpp
deleted file mode 100644
index e352ff473..000000000
--- a/src/duckdb/src/transaction/undo_buffer.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-#include "duckdb/transaction/undo_buffer.hpp"
-
-#include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/list.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/pair.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/transaction/cleanup_state.hpp"
-#include "duckdb/transaction/commit_state.hpp"
-#include "duckdb/transaction/rollback_state.hpp"
-#include "duckdb/execution/index/bound_index.hpp"
-#include "duckdb/transaction/wal_write_state.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-constexpr uint32_t UNDO_ENTRY_HEADER_SIZE = sizeof(UndoFlags) + sizeof(uint32_t);
-
-UndoBuffer::UndoBuffer(DuckTransaction &transaction_p, ClientContext &context_p)
-    : transaction(transaction_p), allocator(BufferManager::GetBufferManager(context_p)) {
-}
-
-UndoBufferReference UndoBuffer::CreateEntry(UndoFlags type, idx_t len) {
-	idx_t alloc_len = AlignValue<idx_t>(len + UNDO_ENTRY_HEADER_SIZE);
-	auto handle = allocator.Allocate(alloc_len);
-	auto data = handle.Ptr();
-	// write the undo entry metadata
-	Store<UndoFlags>(type, data);
-	data += sizeof(UndoFlags);
-	Store<uint32_t>(UnsafeNumericCast<uint32_t>(alloc_len - UNDO_ENTRY_HEADER_SIZE), data);
-	// increment the position of the header past the undo entry metadata
-	handle.position += UNDO_ENTRY_HEADER_SIZE;
-	return handle;
-}
-
-template <class T>
-void UndoBuffer::IterateEntries(UndoBuffer::IteratorState &state, T &&callback) {
-	// iterate in insertion order: start with the tail
-	state.current = allocator.tail.get();
-	while (state.current) {
-		state.handle = allocator.buffer_manager.Pin(state.current->block);
-		state.start = state.handle.Ptr();
-		state.end = state.start + state.current->position;
-		while (state.start < state.end) {
-			UndoFlags type = Load<UndoFlags>(state.start);
-			state.start += sizeof(UndoFlags);
-
-			uint32_t len = Load<uint32_t>(state.start);
-			state.start += sizeof(uint32_t);
-			callback(type, state.start);
-			state.start += len;
-		}
-		state.current = state.current->prev;
-	}
-}
-
-template <class T>
-void UndoBuffer::IterateEntries(UndoBuffer::IteratorState &state, UndoBuffer::IteratorState &end_state, T &&callback) {
-	// iterate in insertion order: start with the tail
-	state.current = allocator.tail.get();
-	while (state.current) {
-		state.handle = allocator.buffer_manager.Pin(state.current->block);
-		state.start = state.handle.Ptr();
-		state.end = state.current == end_state.current ? end_state.start : state.start + state.current->position;
-		while (state.start < state.end) {
-			auto type = Load<UndoFlags>(state.start);
-			state.start += sizeof(UndoFlags);
-			auto len = Load<uint32_t>(state.start);
-			state.start += sizeof(uint32_t);
-			callback(type, state.start);
-			state.start += len;
-		}
-		if (state.current == end_state.current) {
-			// finished executing until the current end state
-			return;
-		}
-		state.current = state.current->prev;
-	}
-}
-
-template <class T>
-void UndoBuffer::ReverseIterateEntries(T &&callback) {
-	// iterate in reverse insertion order: start with the head
-	auto current = allocator.head.get();
-	while (current) {
-		auto handle = allocator.buffer_manager.Pin(current->block);
-		data_ptr_t start = handle.Ptr();
-		data_ptr_t end = start + current->position;
-		// create a vector with all nodes in this chunk
-		vector<pair<UndoFlags, data_ptr_t>> nodes;
-		while (start < end) {
-			auto type = Load<UndoFlags>(start);
-			start += sizeof(UndoFlags);
-			auto len = Load<uint32_t>(start);
-			start += sizeof(uint32_t);
-			nodes.emplace_back(type, start);
-			start += len;
-		}
-		// iterate over it in reverse order
-		for (idx_t i = nodes.size(); i > 0; i--) {
-			callback(nodes[i - 1].first, nodes[i - 1].second);
-		}
-		current = current->next.get();
-	}
-}
-
-bool UndoBuffer::ChangesMade() {
-	// we need to search for any index creation entries
-	return allocator.head.get();
-}
-
-UndoBufferProperties UndoBuffer::GetProperties() {
-	UndoBufferProperties properties;
-	if (!ChangesMade()) {
-		return properties;
-	}
-	auto node = allocator.head.get();
-	while (node) {
-		properties.estimated_size += node->position;
-		node = node->next.get();
-	}
-
-	// we need to search for any index creation entries
-	IteratorState iterator_state;
-	IterateEntries(iterator_state, [&](UndoFlags entry_type, data_ptr_t data) {
-		switch (entry_type) {
-		case UndoFlags::UPDATE_TUPLE:
-			properties.has_updates = true;
-			break;
-		case UndoFlags::DELETE_TUPLE: {
-			auto info = reinterpret_cast<DeleteInfo *>(data);
-			if (info->is_consecutive) {
-				properties.estimated_size += sizeof(row_t) * info->count;
-			}
-			if (info->table->HasIndexes()) {
-				properties.has_index_deletes = true;
-			}
-			properties.has_deletes = true;
-			break;
-		}
-		case UndoFlags::CATALOG_ENTRY: {
-			properties.has_catalog_changes = true;
-
-			auto catalog_entry = Load<CatalogEntry *>(data);
-			auto &parent = catalog_entry->Parent();
-			switch (parent.type) {
-			case CatalogType::DELETED_ENTRY:
-				properties.has_dropped_entries = true;
-				break;
-			case CatalogType::INDEX_ENTRY: {
-				auto &index = parent.Cast<DuckIndexEntry>();
-				properties.estimated_size += index.initial_index_size;
-				break;
-			}
-			default:
-				break;
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	});
-	return properties;
-}
-
-void UndoBuffer::Cleanup(transaction_t lowest_active_transaction) {
-	// garbage collect everything in the Undo Chunk
-	// this should only happen if
-	//  (1) the transaction this UndoBuffer belongs to has successfully
-	//  committed
-	//      (on Rollback the Rollback() function should be called, that clears
-	//      the chunks)
-	//  (2) there is no active transaction with start_id < commit_id of this
-	//  transaction
-	CleanupState state(lowest_active_transaction);
-	UndoBuffer::IteratorState iterator_state;
-	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CleanupEntry(type, data); });
-
-	// possibly vacuum indexes
-	for (auto &table : state.indexed_tables) {
-		table.second->VacuumIndexes();
-	}
-}
-
-void UndoBuffer::WriteToWAL(WriteAheadLog &wal, optional_ptr<StorageCommitState> commit_state) {
-	WALWriteState state(transaction, wal, commit_state);
-	UndoBuffer::IteratorState iterator_state;
-	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry(type, data); });
-}
-
-void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, transaction_t commit_id) {
-	CommitState state(transaction, commit_id);
-	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry(type, data); });
-}
-
-void UndoBuffer::RevertCommit(UndoBuffer::IteratorState &end_state, transaction_t transaction_id) {
-	CommitState state(transaction, transaction_id);
-	UndoBuffer::IteratorState start_state;
-	IterateEntries(start_state, end_state, [&](UndoFlags type, data_ptr_t data) { state.RevertCommit(type, data); });
-}
-
-void UndoBuffer::Rollback() {
-	// rollback needs to be performed in reverse
-	RollbackState state(transaction);
-	ReverseIterateEntries([&](UndoFlags type, data_ptr_t data) { state.RollbackEntry(type, data); });
-}
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/undo_buffer_allocator.cpp b/src/duckdb/src/transaction/undo_buffer_allocator.cpp
deleted file mode 100644
index 20e3bdf19..000000000
--- a/src/duckdb/src/transaction/undo_buffer_allocator.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#include "duckdb/transaction/undo_buffer_allocator.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-UndoBufferEntry::~UndoBufferEntry() {
-	if (next) {
-		auto current_next = std::move(next);
-		while (current_next) {
-			current_next = std::move(current_next->next);
-		}
-	}
-}
-UndoBufferPointer UndoBufferReference::GetBufferPointer() {
-	return UndoBufferPointer(*entry, position);
-}
-
-UndoBufferReference UndoBufferPointer::Pin() const {
-	if (!entry) {
-		throw InternalException("UndoBufferPointer::Pin called but no entry was found");
-	}
-	D_ASSERT(entry->capacity >= position);
-	auto handle = entry->buffer_manager.Pin(entry->block);
-	return UndoBufferReference(*entry, std::move(handle), position);
-}
-
-UndoBufferAllocator::UndoBufferAllocator(BufferManager &buffer_manager) : buffer_manager(buffer_manager) {
-}
-
-UndoBufferReference UndoBufferAllocator::Allocate(idx_t alloc_len) {
-	D_ASSERT(!head || head->position <= head->capacity);
-	BufferHandle handle;
-	if (!head || head->position + alloc_len > head->capacity) {
-		// no space in current head - allocate a new block
-		auto block_size = buffer_manager.GetBlockSize();
-		;
-		idx_t capacity;
-		if (!head && alloc_len <= 4096) {
-			capacity = 4096;
-		} else {
-			capacity = block_size;
-		}
-		if (capacity < alloc_len) {
-			capacity = NextPowerOfTwo(alloc_len);
-		}
-		auto entry = make_uniq<UndoBufferEntry>(buffer_manager);
-		if (capacity < block_size) {
-			entry->block = buffer_manager.RegisterSmallMemory(MemoryTag::TRANSACTION, capacity);
-			handle = buffer_manager.Pin(entry->block);
-		} else {
-			handle = buffer_manager.Allocate(MemoryTag::TRANSACTION, capacity, false);
-			entry->block = handle.GetBlockHandle();
-		}
-		entry->capacity = capacity;
-		entry->position = 0;
-		// add block to the chain
-		if (head) {
-			head->prev = entry.get();
-			entry->next = std::move(head);
-		} else {
-			tail = entry.get();
-		}
-		head = std::move(entry);
-	} else {
-		handle = buffer_manager.Pin(head->block);
-	}
-	idx_t current_position = head->position;
-	head->position += alloc_len;
-	return UndoBufferReference(*head, std::move(handle), current_position);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/transaction/wal_write_state.cpp b/src/duckdb/src/transaction/wal_write_state.cpp
deleted file mode 100644
index 275a12571..000000000
--- a/src/duckdb/src/transaction/wal_write_state.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-#include "duckdb/transaction/wal_write_state.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/table/chunk_info.hpp"
-#include "duckdb/storage/table/column_data.hpp"
-#include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/storage/table/row_version_manager.hpp"
-#include "duckdb/storage/table/update_segment.hpp"
-#include "duckdb/storage/write_ahead_log.hpp"
-#include "duckdb/transaction/append_info.hpp"
-#include "duckdb/transaction/delete_info.hpp"
-#include "duckdb/transaction/update_info.hpp"
-
-namespace duckdb {
-
-WALWriteState::WALWriteState(DuckTransaction &transaction_p, WriteAheadLog &log,
-                             optional_ptr<StorageCommitState> commit_state)
-    : transaction(transaction_p), log(log), commit_state(commit_state), current_table_info(nullptr) {
-}
-
-void WALWriteState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
-	if (current_table_info != table_info) {
-		// write the current table to the log
-		log.WriteSetTable(table_info->GetSchemaName(), table_info->GetTableName());
-		current_table_info = table_info;
-	}
-}
-
-void WALWriteState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
-	if (entry.temporary || entry.Parent().temporary) {
-		return;
-	}
-
-	// look at the type of the parent entry
-	auto &parent = entry.Parent();
-
-	switch (parent.type) {
-	case CatalogType::TABLE_ENTRY:
-	case CatalogType::VIEW_ENTRY:
-	case CatalogType::INDEX_ENTRY:
-	case CatalogType::SEQUENCE_ENTRY:
-	case CatalogType::TYPE_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-		if (entry.type == CatalogType::RENAMED_ENTRY || entry.type == parent.type) {
-			// ALTER statement, read the extra data after the entry
-			auto extra_data_size = Load<idx_t>(dataptr);
-			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
-
-			MemoryStream source(extra_data, extra_data_size);
-			BinaryDeserializer deserializer(source);
-			deserializer.Begin();
-			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
-			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
-			deserializer.End();
-
-			auto &alter_info = parse_info->Cast<AlterInfo>();
-			log.WriteAlter(entry, alter_info);
-		} else {
-			switch (parent.type) {
-			case CatalogType::TABLE_ENTRY:
-				// CREATE TABLE statement
-				log.WriteCreateTable(parent.Cast<TableCatalogEntry>());
-				break;
-			case CatalogType::VIEW_ENTRY:
-				// CREATE VIEW statement
-				log.WriteCreateView(parent.Cast<ViewCatalogEntry>());
-				break;
-			case CatalogType::INDEX_ENTRY:
-				// CREATE INDEX statement
-				log.WriteCreateIndex(parent.Cast<IndexCatalogEntry>());
-				break;
-			case CatalogType::SEQUENCE_ENTRY:
-				// CREATE SEQUENCE statement
-				log.WriteCreateSequence(parent.Cast<SequenceCatalogEntry>());
-				break;
-			case CatalogType::TYPE_ENTRY:
-				// CREATE TYPE statement
-				log.WriteCreateType(parent.Cast<TypeCatalogEntry>());
-				break;
-			case CatalogType::MACRO_ENTRY:
-				log.WriteCreateMacro(parent.Cast<ScalarMacroCatalogEntry>());
-				break;
-			case CatalogType::TABLE_MACRO_ENTRY:
-				log.WriteCreateTableMacro(parent.Cast<TableMacroCatalogEntry>());
-				break;
-			default:
-				throw InternalException("Don't know how to create this type!");
-			}
-		}
-		break;
-	case CatalogType::SCHEMA_ENTRY:
-		if (entry.type == CatalogType::RENAMED_ENTRY || entry.type == CatalogType::SCHEMA_ENTRY) {
-			// ALTER TABLE statement, skip it
-			return;
-		}
-		log.WriteCreateSchema(parent.Cast<SchemaCatalogEntry>());
-		break;
-	case CatalogType::RENAMED_ENTRY:
-		// This is a rename, nothing needs to be done for this
-		break;
-	case CatalogType::DELETED_ENTRY:
-		switch (entry.type) {
-		case CatalogType::TABLE_ENTRY: {
-			auto &table_entry = entry.Cast<DuckTableEntry>();
-			D_ASSERT(table_entry.IsDuckTable());
-			log.WriteDropTable(table_entry);
-			break;
-		}
-		case CatalogType::SCHEMA_ENTRY:
-			log.WriteDropSchema(entry.Cast<SchemaCatalogEntry>());
-			break;
-		case CatalogType::VIEW_ENTRY:
-			log.WriteDropView(entry.Cast<ViewCatalogEntry>());
-			break;
-		case CatalogType::SEQUENCE_ENTRY:
-			log.WriteDropSequence(entry.Cast<SequenceCatalogEntry>());
-			break;
-		case CatalogType::MACRO_ENTRY:
-			log.WriteDropMacro(entry.Cast<ScalarMacroCatalogEntry>());
-			break;
-		case CatalogType::TABLE_MACRO_ENTRY:
-			log.WriteDropTableMacro(entry.Cast<TableMacroCatalogEntry>());
-			break;
-		case CatalogType::TYPE_ENTRY:
-			log.WriteDropType(entry.Cast<TypeCatalogEntry>());
-			break;
-		case CatalogType::INDEX_ENTRY: {
-			log.WriteDropIndex(entry.Cast<IndexCatalogEntry>());
-			break;
-		}
-		case CatalogType::RENAMED_ENTRY:
-		case CatalogType::PREPARED_STATEMENT:
-		case CatalogType::SCALAR_FUNCTION_ENTRY:
-		case CatalogType::DEPENDENCY_ENTRY:
-		case CatalogType::SECRET_ENTRY:
-		case CatalogType::SECRET_TYPE_ENTRY:
-		case CatalogType::SECRET_FUNCTION_ENTRY:
-			// do nothing, prepared statements and scalar functions aren't persisted to disk
-			break;
-		default:
-			throw InternalException("Don't know how to drop this type!");
-		}
-		break;
-	case CatalogType::PREPARED_STATEMENT:
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-	case CatalogType::COPY_FUNCTION_ENTRY:
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-	case CatalogType::COLLATION_ENTRY:
-	case CatalogType::DEPENDENCY_ENTRY:
-	case CatalogType::SECRET_ENTRY:
-	case CatalogType::SECRET_TYPE_ENTRY:
-	case CatalogType::SECRET_FUNCTION_ENTRY:
-		// do nothing, these entries are not persisted to disk
-		break;
-	default:
-		throw InternalException("UndoBuffer - don't know how to write this entry to the WAL");
-	}
-}
-
-void WALWriteState::WriteDelete(DeleteInfo &info) {
-	// switch to the current table, if necessary
-	SwitchTable(info.table->GetDataTableInfo().get(), UndoFlags::DELETE_TUPLE);
-
-	if (!delete_chunk) {
-		delete_chunk = make_uniq<DataChunk>();
-		vector<LogicalType> delete_types = {LogicalType::ROW_TYPE};
-		delete_chunk->Initialize(Allocator::DefaultAllocator(), delete_types);
-	}
-	auto rows = FlatVector::GetData<row_t>(delete_chunk->data[0]);
-	if (info.is_consecutive) {
-		for (idx_t i = 0; i < info.count; i++) {
-			rows[i] = UnsafeNumericCast<int64_t>(info.base_row + i);
-		}
-	} else {
-		auto delete_rows = info.GetRows();
-		for (idx_t i = 0; i < info.count; i++) {
-			rows[i] = UnsafeNumericCast<int64_t>(info.base_row) + delete_rows[i];
-		}
-	}
-	delete_chunk->SetCardinality(info.count);
-	log.WriteDelete(*delete_chunk);
-}
-
-void WALWriteState::WriteUpdate(UpdateInfo &info) {
-	// switch to the current table, if necessary
-	auto &column_data = info.segment->column_data;
-	auto &table_info = column_data.GetTableInfo();
-
-	SwitchTable(&table_info, UndoFlags::UPDATE_TUPLE);
-
-	// initialize the update chunk
-	vector<LogicalType> update_types;
-	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
-		update_types.emplace_back(LogicalType::BOOLEAN);
-	} else {
-		update_types.push_back(column_data.type);
-	}
-	update_types.emplace_back(LogicalType::ROW_TYPE);
-
-	update_chunk = make_uniq<DataChunk>();
-	update_chunk->Initialize(Allocator::DefaultAllocator(), update_types);
-
-	// fetch the updated values from the base segment
-	info.segment->FetchCommitted(info.vector_index, update_chunk->data[0]);
-
-	// write the row ids into the chunk
-	auto row_ids = FlatVector::GetData<row_t>(update_chunk->data[1]);
-	idx_t start = column_data.start + info.vector_index * STANDARD_VECTOR_SIZE;
-	auto tuples = info.GetTuples();
-	for (idx_t i = 0; i < info.N; i++) {
-		row_ids[tuples[i]] = UnsafeNumericCast<int64_t>(start + tuples[i]);
-	}
-	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
-		// zero-initialize the booleans
-		// FIXME: this is only required because of NullValue<T> in Vector::Serialize...
-		auto booleans = FlatVector::GetData<bool>(update_chunk->data[0]);
-		for (idx_t i = 0; i < info.N; i++) {
-			auto idx = tuples[i];
-			booleans[idx] = false;
-		}
-	}
-	SelectionVector sel(tuples);
-	update_chunk->Slice(sel, info.N);
-
-	// construct the column index path
-	vector<column_t> column_indexes;
-	reference<const ColumnData> current_column_data = column_data;
-	while (current_column_data.get().HasParent()) {
-		column_indexes.push_back(current_column_data.get().column_index);
-		current_column_data = current_column_data.get().Parent();
-	}
-	column_indexes.push_back(info.column_index);
-	std::reverse(column_indexes.begin(), column_indexes.end());
-
-	log.WriteUpdate(*update_chunk, column_indexes);
-}
-
-void WALWriteState::CommitEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		// set the commit timestamp of the catalog entry to the given id
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry->HasParent());
-		// push the catalog update to the WAL
-		WriteCatalogEntry(*catalog_entry, data + sizeof(CatalogEntry *));
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		// append:
-		auto info = reinterpret_cast<AppendInfo *>(data);
-		if (!info->table->IsTemporary()) {
-			info->table->WriteToLog(transaction, log, info->start_row, info->count, commit_state.get());
-		}
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		// deletion:
-		auto info = reinterpret_cast<DeleteInfo *>(data);
-		if (!info->table->IsTemporary()) {
-			WriteDelete(*info);
-		}
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		// update:
-		auto info = reinterpret_cast<UpdateInfo *>(data);
-		if (!info->segment->column_data.GetTableInfo().IsTemporary()) {
-			WriteUpdate(*info);
-		}
-		break;
-	}
-	case UndoFlags::SEQUENCE_VALUE: {
-		auto info = reinterpret_cast<SequenceValue *>(data);
-		log.WriteSequenceValue(*info);
-		break;
-	}
-	default:
-		throw InternalException("UndoBuffer - don't know how to commit this type!");
-	}
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/copied_statement_verifier.cpp b/src/duckdb/src/verification/copied_statement_verifier.cpp
deleted file mode 100644
index ff7825bd5..000000000
--- a/src/duckdb/src/verification/copied_statement_verifier.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/verification/copied_statement_verifier.hpp"
-
-namespace duckdb {
-
-CopiedStatementVerifier::CopiedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-                                                 optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::COPIED, "Copied", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-CopiedStatementVerifier::Create(const SQLStatement &statement,
-                                optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	return make_uniq<CopiedStatementVerifier>(statement.Copy(), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/deserialized_statement_verifier.cpp b/src/duckdb/src/verification/deserialized_statement_verifier.cpp
deleted file mode 100644
index a841d64bb..000000000
--- a/src/duckdb/src/verification/deserialized_statement_verifier.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "duckdb/verification/deserialized_statement_verifier.hpp"
-
-#include "duckdb/common/serializer/binary_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/memory_stream.hpp"
-namespace duckdb {
-
-DeserializedStatementVerifier::DeserializedStatementVerifier(
-    unique_ptr<SQLStatement> statement_p, optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::DESERIALIZED, "Deserialized", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-DeserializedStatementVerifier::Create(const SQLStatement &statement,
-                                      optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-
-	auto &select_stmt = statement.Cast<SelectStatement>();
-	MemoryStream stream;
-	BinarySerializer::Serialize(select_stmt, stream);
-	stream.Rewind();
-	auto result = BinaryDeserializer::Deserialize<SelectStatement>(stream);
-
-	return make_uniq<DeserializedStatementVerifier>(std::move(result), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/external_statement_verifier.cpp b/src/duckdb/src/verification/external_statement_verifier.cpp
deleted file mode 100644
index 0d3e40da3..000000000
--- a/src/duckdb/src/verification/external_statement_verifier.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/verification/external_statement_verifier.hpp"
-
-namespace duckdb {
-
-ExternalStatementVerifier::ExternalStatementVerifier(
-    unique_ptr<SQLStatement> statement_p, optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::EXTERNAL, "External", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-ExternalStatementVerifier::Create(const SQLStatement &statement,
-                                  optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	return make_uniq<ExternalStatementVerifier>(statement.Copy(), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/fetch_row_verifier.cpp b/src/duckdb/src/verification/fetch_row_verifier.cpp
deleted file mode 100644
index 5a4d4ba23..000000000
--- a/src/duckdb/src/verification/fetch_row_verifier.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/verification/fetch_row_verifier.hpp"
-
-namespace duckdb {
-
-FetchRowVerifier::FetchRowVerifier(unique_ptr<SQLStatement> statement_p,
-                                   optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::FETCH_ROW_AS_SCAN, "FetchRow as Scan", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-FetchRowVerifier::Create(const SQLStatement &statement_p,
-                         optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	return make_uniq<FetchRowVerifier>(statement_p.Copy(), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/no_operator_caching_verifier.cpp b/src/duckdb/src/verification/no_operator_caching_verifier.cpp
deleted file mode 100644
index 0ca57036f..000000000
--- a/src/duckdb/src/verification/no_operator_caching_verifier.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "duckdb/verification/no_operator_caching_verifier.hpp"
-
-namespace duckdb {
-
-NoOperatorCachingVerifier::NoOperatorCachingVerifier(
-    unique_ptr<SQLStatement> statement_p, optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::NO_OPERATOR_CACHING, "No operator caching", std::move(statement_p),
-                        parameters) {
-}
-
-unique_ptr<StatementVerifier>
-NoOperatorCachingVerifier::Create(const SQLStatement &statement_p,
-                                  optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	return make_uniq<NoOperatorCachingVerifier>(statement_p.Copy(), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/parsed_statement_verifier.cpp b/src/duckdb/src/verification/parsed_statement_verifier.cpp
deleted file mode 100644
index ff9075dc4..000000000
--- a/src/duckdb/src/verification/parsed_statement_verifier.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "duckdb/verification/parsed_statement_verifier.hpp"
-
-#include "duckdb/parser/parser.hpp"
-
-namespace duckdb {
-
-ParsedStatementVerifier::ParsedStatementVerifier(unique_ptr<SQLStatement> statement_p,
-                                                 optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::PARSED, "Parsed", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-ParsedStatementVerifier::Create(const SQLStatement &statement,
-                                optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	auto query_str = statement.ToString();
-	Parser parser;
-	try {
-		parser.ParseQuery(query_str);
-	} catch (std::exception &ex) {
-		throw InternalException("Parsed statement verification failed. Query:\n%s\n\nError: %s", query_str, ex.what());
-	}
-	D_ASSERT(parser.statements.size() == 1);
-	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-	return make_uniq<ParsedStatementVerifier>(std::move(parser.statements[0]), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/prepared_statement_verifier.cpp b/src/duckdb/src/verification/prepared_statement_verifier.cpp
deleted file mode 100644
index 2458d4714..000000000
--- a/src/duckdb/src/verification/prepared_statement_verifier.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "duckdb/verification/prepared_statement_verifier.hpp"
-
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/parser/expression/parameter_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/statement/drop_statement.hpp"
-#include "duckdb/parser/statement/execute_statement.hpp"
-#include "duckdb/parser/statement/prepare_statement.hpp"
-
-namespace duckdb {
-
-PreparedStatementVerifier::PreparedStatementVerifier(
-    unique_ptr<SQLStatement> statement_p, optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::PREPARED, "Prepared", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-PreparedStatementVerifier::Create(const SQLStatement &statement,
-                                  optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	return make_uniq<PreparedStatementVerifier>(statement.Copy(), parameters);
-}
-
-void PreparedStatementVerifier::Extract() {
-	auto &select = *statement;
-	// replace all the constants from the select statement and replace them with parameter expressions
-	ParsedExpressionIterator::EnumerateQueryNodeChildren(
-	    *select.node, [&](unique_ptr<ParsedExpression> &child) { ConvertConstants(child); });
-	for (auto &kv : values) {
-		statement->named_param_map[kv.first] = 0;
-	}
-	// create the PREPARE and EXECUTE statements
-	string name = "__duckdb_verification_prepared_statement";
-	auto prepare = make_uniq<PrepareStatement>();
-	prepare->name = name;
-	prepare->statement = std::move(statement);
-
-	auto execute = make_uniq<ExecuteStatement>();
-	execute->name = name;
-	execute->named_values = std::move(values);
-
-	auto dealloc = make_uniq<DropStatement>();
-	dealloc->info->type = CatalogType::PREPARED_STATEMENT;
-	dealloc->info->name = string(name);
-
-	prepare_statement = std::move(prepare);
-	execute_statement = std::move(execute);
-	dealloc_statement = std::move(dealloc);
-}
-
-void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &child) {
-	if (child->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
-		// constant: extract the constant value
-		auto alias = child->GetAlias();
-		child->ClearAlias();
-		// check if the value already exists
-		idx_t index = values.size();
-		auto identifier = std::to_string(index + 1);
-		const auto predicate = [&](const std::pair<const string, unique_ptr<ParsedExpression>> &pair) {
-			return pair.second->Equals(*child.get());
-		};
-		auto result = std::find_if(values.begin(), values.end(), predicate);
-		if (result == values.end()) {
-			// If it doesn't exist yet, add it
-			values[identifier] = std::move(child);
-		} else {
-			identifier = result->first;
-		}
-
-		// replace it with an expression
-		auto parameter = make_uniq<ParameterExpression>();
-		parameter->identifier = identifier;
-		parameter->SetAlias(alias);
-		child = std::move(parameter);
-		return;
-	}
-	ParsedExpressionIterator::EnumerateChildren(*child,
-	                                            [&](unique_ptr<ParsedExpression> &child) { ConvertConstants(child); });
-}
-
-bool PreparedStatementVerifier::Run(
-    ClientContext &context, const string &query,
-    const std::function<unique_ptr<QueryResult>(const string &, unique_ptr<SQLStatement>,
-                                                optional_ptr<case_insensitive_map_t<BoundParameterData>>)> &run) {
-	bool failed = false;
-	// verify that we can extract all constants from the query and run the query as a prepared statement
-	// create the PREPARE and EXECUTE statements
-	Extract();
-	// execute the prepared statements
-	try {
-		auto prepare_result = run(string(), std::move(prepare_statement), parameters);
-		if (prepare_result->HasError()) {
-			prepare_result->ThrowError("Failed prepare during verify: ");
-		}
-		auto execute_result = run(string(), std::move(execute_statement), parameters);
-		if (execute_result->HasError()) {
-			execute_result->ThrowError("Failed execute during verify: ");
-		}
-		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(execute_result));
-	} catch (const std::exception &ex) {
-		ErrorData error(ex);
-		if (error.Type() != ExceptionType::PARAMETER_NOT_ALLOWED) {
-			materialized_result = make_uniq<MaterializedQueryResult>(std::move(error));
-		}
-		failed = true;
-	}
-	run(string(), std::move(dealloc_statement), parameters);
-	context.interrupted = false;
-
-	return failed;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/statement_verifier.cpp b/src/duckdb/src/verification/statement_verifier.cpp
deleted file mode 100644
index fb8fc71ac..000000000
--- a/src/duckdb/src/verification/statement_verifier.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-#include "duckdb/verification/statement_verifier.hpp"
-
-#include "duckdb/common/error_data.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/verification/copied_statement_verifier.hpp"
-#include "duckdb/verification/deserialized_statement_verifier.hpp"
-#include "duckdb/verification/external_statement_verifier.hpp"
-#include "duckdb/verification/parsed_statement_verifier.hpp"
-#include "duckdb/verification/prepared_statement_verifier.hpp"
-#include "duckdb/verification/unoptimized_statement_verifier.hpp"
-#include "duckdb/verification/no_operator_caching_verifier.hpp"
-#include "duckdb/verification/fetch_row_verifier.hpp"
-
-namespace duckdb {
-
-StatementVerifier::StatementVerifier(VerificationType type, string name, unique_ptr<SQLStatement> statement_p,
-                                     optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters_p)
-    : type(type), name(std::move(name)),
-      statement(unique_ptr_cast<SQLStatement, SelectStatement>(std::move(statement_p))), parameters(parameters_p),
-      select_list(statement->node->GetSelectList()) {
-}
-
-StatementVerifier::StatementVerifier(unique_ptr<SQLStatement> statement_p,
-                                     optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::ORIGINAL, "Original", std::move(statement_p), parameters) {
-}
-
-StatementVerifier::~StatementVerifier() noexcept {
-}
-
-unique_ptr<StatementVerifier>
-StatementVerifier::Create(VerificationType type, const SQLStatement &statement_p,
-                          optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	switch (type) {
-	case VerificationType::COPIED:
-		return CopiedStatementVerifier::Create(statement_p, parameters);
-	case VerificationType::DESERIALIZED:
-		return DeserializedStatementVerifier::Create(statement_p, parameters);
-	case VerificationType::PARSED:
-		return ParsedStatementVerifier::Create(statement_p, parameters);
-	case VerificationType::UNOPTIMIZED:
-		return UnoptimizedStatementVerifier::Create(statement_p, parameters);
-	case VerificationType::NO_OPERATOR_CACHING:
-		return NoOperatorCachingVerifier::Create(statement_p, parameters);
-	case VerificationType::PREPARED:
-		return PreparedStatementVerifier::Create(statement_p, parameters);
-	case VerificationType::EXTERNAL:
-		return ExternalStatementVerifier::Create(statement_p, parameters);
-	case VerificationType::FETCH_ROW_AS_SCAN:
-		return FetchRowVerifier::Create(statement_p, parameters);
-	case VerificationType::INVALID:
-	default:
-		throw InternalException("Invalid statement verification type!");
-	}
-}
-
-void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
-	// Only the original statement should check other statements
-	D_ASSERT(type == VerificationType::ORIGINAL);
-
-	// Check equality
-	if (other.RequireEquality()) {
-		D_ASSERT(statement->Equals(*other.statement));
-	}
-
-#ifdef DEBUG
-	// Now perform checking on the expressions
-	D_ASSERT(select_list.size() == other.select_list.size());
-	const auto expr_count = select_list.size();
-	if (other.RequireEquality()) {
-		for (idx_t i = 0; i < expr_count; i++) {
-			// Run the ToString, to verify that it doesn't crash
-			select_list[i]->ToString();
-
-			if (select_list[i]->HasSubquery()) {
-				continue;
-			}
-
-			// Check that the expressions are equivalent
-			D_ASSERT(select_list[i]->Equals(*other.select_list[i]));
-			// Check that the hashes are equivalent too
-			D_ASSERT(select_list[i]->Hash() == other.select_list[i]->Hash());
-
-			other.select_list[i]->Verify();
-		}
-	}
-#endif
-}
-
-void StatementVerifier::CheckExpressions() const {
-#ifdef DEBUG
-	D_ASSERT(type == VerificationType::ORIGINAL);
-	// Perform additional checking within the expressions
-	const auto expr_count = select_list.size();
-	for (idx_t outer_idx = 0; outer_idx < expr_count; outer_idx++) {
-		auto hash = select_list[outer_idx]->Hash();
-		for (idx_t inner_idx = 0; inner_idx < expr_count; inner_idx++) {
-			auto hash2 = select_list[inner_idx]->Hash();
-			if (hash != hash2) {
-				// if the hashes are not equivalent, the expressions should not be equivalent
-				D_ASSERT(!select_list[outer_idx]->Equals(*select_list[inner_idx]));
-			}
-		}
-	}
-#endif
-}
-
-bool StatementVerifier::Run(
-    ClientContext &context, const string &query,
-    const std::function<unique_ptr<QueryResult>(const string &, unique_ptr<SQLStatement>,
-                                                optional_ptr<case_insensitive_map_t<BoundParameterData>>)> &run) {
-	bool failed = false;
-
-	context.interrupted = false;
-	context.config.enable_optimizer = !DisableOptimizer();
-	context.config.enable_caching_operators = !DisableOperatorCaching();
-	context.config.force_external = ForceExternal();
-	context.config.force_fetch_row = ForceFetchRow();
-	try {
-		auto result = run(query, std::move(statement), parameters);
-		if (result->HasError()) {
-			failed = true;
-		}
-		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
-	} catch (std::exception &ex) {
-		failed = true;
-		materialized_result = make_uniq<MaterializedQueryResult>(ErrorData(ex));
-	}
-	context.interrupted = false;
-
-	return failed;
-}
-
-string StatementVerifier::CompareResults(const StatementVerifier &other) {
-	D_ASSERT(type == VerificationType::ORIGINAL);
-	string error;
-	if (materialized_result->HasError() != other.materialized_result->HasError()) { // LCOV_EXCL_START
-		string result = other.name + " statement differs from original result!\n";
-		result += "Original Result:\n" + materialized_result->ToString();
-		result += other.name + ":\n" + other.materialized_result->ToString();
-		return result;
-	} // LCOV_EXCL_STOP
-	if (materialized_result->HasError()) {
-		return "";
-	}
-	if (!ColumnDataCollection::ResultEquals(materialized_result->Collection(), other.materialized_result->Collection(),
-	                                        error)) { // LCOV_EXCL_START
-		string result = other.name + " statement differs from original result!\n";
-		result += "Original Result:\n" + materialized_result->ToString();
-		result += other.name + ":\n" + other.materialized_result->ToString();
-		result += "\n\n---------------------------------\n" + error;
-		return result;
-	} // LCOV_EXCL_STOP
-
-	return "";
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/src/verification/unoptimized_statement_verifier.cpp b/src/duckdb/src/verification/unoptimized_statement_verifier.cpp
deleted file mode 100644
index fd2dd1f72..000000000
--- a/src/duckdb/src/verification/unoptimized_statement_verifier.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "duckdb/verification/unoptimized_statement_verifier.hpp"
-
-namespace duckdb {
-
-UnoptimizedStatementVerifier::UnoptimizedStatementVerifier(
-    unique_ptr<SQLStatement> statement_p, optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
-    : StatementVerifier(VerificationType::UNOPTIMIZED, "Unoptimized", std::move(statement_p), parameters) {
-}
-
-unique_ptr<StatementVerifier>
-UnoptimizedStatementVerifier::Create(const SQLStatement &statement_p,
-                                     optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
-	return make_uniq<UnoptimizedStatementVerifier>(statement_p.Copy(), parameters);
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/third_party/brotli/common/brotli_constants.h b/src/duckdb/third_party/brotli/common/brotli_constants.h
deleted file mode 100644
index cb52343e2..000000000
--- a/src/duckdb/third_party/brotli/common/brotli_constants.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/**
- * @file
- * Common constants used in decoder and encoder API.
- */
-
-#ifndef BROTLI_COMMON_CONSTANTS_H_
-#define BROTLI_COMMON_CONSTANTS_H_
-
-#include <brotli/port.h>
-#include <brotli/types.h>
-
-#include "brotli_platform.h"
-
-namespace  duckdb_brotli {
-
-/* Specification: 7.3. Encoding of the context map */
-#define BROTLI_CONTEXT_MAP_MAX_RLE 16
-
-/* Specification: 2. Compressed representation overview */
-#define BROTLI_MAX_NUMBER_OF_BLOCK_TYPES 256
-
-/* Specification: 3.3. Alphabet sizes: insert-and-copy length */
-#define BROTLI_NUM_LITERAL_SYMBOLS 256
-#define BROTLI_NUM_COMMAND_SYMBOLS 704
-#define BROTLI_NUM_BLOCK_LEN_SYMBOLS 26
-#define BROTLI_MAX_CONTEXT_MAP_SYMBOLS (BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + \
-                                        BROTLI_CONTEXT_MAP_MAX_RLE)
-#define BROTLI_MAX_BLOCK_TYPE_SYMBOLS (BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 2)
-
-/* Specification: 3.5. Complex prefix codes */
-#define BROTLI_REPEAT_PREVIOUS_CODE_LENGTH 16
-#define BROTLI_REPEAT_ZERO_CODE_LENGTH 17
-#define BROTLI_CODE_LENGTH_CODES (BROTLI_REPEAT_ZERO_CODE_LENGTH + 1)
-/* "code length of 8 is repeated" */
-#define BROTLI_INITIAL_REPEATED_CODE_LENGTH 8
-
-/* "Large Window Brotli" */
-
-/**
- * The theoretical maximum number of distance bits specified for large window
- * brotli, for 64-bit encoders and decoders. Even when in practice 32-bit
- * encoders and decoders only support up to 30 max distance bits, the value is
- * set to 62 because it affects the large window brotli file format.
- * Specifically, it affects the encoding of simple huffman tree for distances,
- * see Specification RFC 7932 chapter 3.4.
- */
-#define BROTLI_LARGE_MAX_DISTANCE_BITS 62U
-#define BROTLI_LARGE_MIN_WBITS 10
-/**
- * The maximum supported large brotli window bits by the encoder and decoder.
- * Large window brotli allows up to 62 bits, however the current encoder and
- * decoder, designed for 32-bit integers, only support up to 30 bits maximum.
- */
-#define BROTLI_LARGE_MAX_WBITS 30
-
-/* Specification: 4. Encoding of distances */
-#define BROTLI_NUM_DISTANCE_SHORT_CODES 16
-/**
- * Maximal number of "postfix" bits.
- *
- * Number of "postfix" bits is stored as 2 bits in meta-block header.
- */
-#define BROTLI_MAX_NPOSTFIX 3
-#define BROTLI_MAX_NDIRECT 120
-#define BROTLI_MAX_DISTANCE_BITS 24U
-#define BROTLI_DISTANCE_ALPHABET_SIZE(NPOSTFIX, NDIRECT, MAXNBITS) ( \
-    BROTLI_NUM_DISTANCE_SHORT_CODES + (NDIRECT) +                    \
-    ((MAXNBITS) << ((NPOSTFIX) + 1)))
-/* BROTLI_NUM_DISTANCE_SYMBOLS == 1128 */
-#define BROTLI_NUM_DISTANCE_SYMBOLS \
-    BROTLI_DISTANCE_ALPHABET_SIZE(  \
-        BROTLI_MAX_NDIRECT, BROTLI_MAX_NPOSTFIX, BROTLI_LARGE_MAX_DISTANCE_BITS)
-
-/* ((1 << 26) - 4) is the maximal distance that can be expressed in RFC 7932
-   brotli stream using NPOSTFIX = 0 and NDIRECT = 0. With other NPOSTFIX and
-   NDIRECT values distances up to ((1 << 29) + 88) could be expressed. */
-#define BROTLI_MAX_DISTANCE 0x3FFFFFC
-
-/* ((1 << 31) - 4) is the safe distance limit. Using this number as a limit
-   allows safe distance calculation without overflows, given the distance
-   alphabet size is limited to corresponding size
-   (see kLargeWindowDistanceCodeLimits). */
-#define BROTLI_MAX_ALLOWED_DISTANCE 0x7FFFFFFC
-
-
-/* Specification: 4. Encoding of Literal Insertion Lengths and Copy Lengths */
-#define BROTLI_NUM_INS_COPY_CODES 24
-
-/* 7.1. Context modes and context ID lookup for literals */
-/* "context IDs for literals are in the range of 0..63" */
-#define BROTLI_LITERAL_CONTEXT_BITS 6
-
-/* 7.2. Context ID for distances */
-#define BROTLI_DISTANCE_CONTEXT_BITS 2
-
-/* 9.1. Format of the Stream Header */
-/* Number of slack bytes for window size. Don't confuse
-   with BROTLI_NUM_DISTANCE_SHORT_CODES. */
-#define BROTLI_WINDOW_GAP 16
-#define BROTLI_MAX_BACKWARD_LIMIT(W) (((size_t)1 << (W)) - BROTLI_WINDOW_GAP)
-
-typedef struct BrotliDistanceCodeLimit {
-  uint32_t max_alphabet_size;
-  uint32_t max_distance;
-} BrotliDistanceCodeLimit;
-
-/* This function calculates maximal size of distance alphabet, such that the
-   distances greater than the given values can not be represented.
-
-   This limits are designed to support fast and safe 32-bit decoders.
-   "32-bit" means that signed integer values up to ((1 << 31) - 1) could be
-   safely expressed.
-
-   Brotli distance alphabet symbols do not represent consecutive distance
-   ranges. Each distance alphabet symbol (excluding direct distances and short
-   codes), represent interleaved (for NPOSTFIX > 0) range of distances.
-   A "group" of consecutive (1 << NPOSTFIX) symbols represent non-interleaved
-   range. Two consecutive groups require the same amount of "extra bits".
-
-   It is important that distance alphabet represents complete "groups".
-   To avoid complex logic on encoder side about interleaved ranges
-   it was decided to restrict both sides to complete distance code "groups".
- */
-BROTLI_UNUSED_FUNCTION BrotliDistanceCodeLimit BrotliCalculateDistanceCodeLimit(
-    uint32_t max_distance, uint32_t npostfix, uint32_t ndirect) {
-  BrotliDistanceCodeLimit result;
-  /* Marking this function as unused, because not all files
-     including "constants.h" use it -> compiler warns about that. */
-  BROTLI_UNUSED(&BrotliCalculateDistanceCodeLimit);
-  if (max_distance <= ndirect) {
-    /* This case never happens / exists only for the sake of completeness. */
-    result.max_alphabet_size = max_distance + BROTLI_NUM_DISTANCE_SHORT_CODES;
-    result.max_distance = max_distance;
-    return result;
-  } else {
-    /* The first prohibited value. */
-    uint32_t forbidden_distance = max_distance + 1;
-    /* Subtract "directly" encoded region. */
-    uint32_t offset = forbidden_distance - ndirect - 1;
-    uint32_t ndistbits = 0;
-    uint32_t tmp;
-    uint32_t half;
-    uint32_t group;
-    /* Postfix for the last dcode in the group. */
-    uint32_t postfix = (1u << npostfix) - 1;
-    uint32_t extra;
-    uint32_t start;
-    /* Remove postfix and "head-start". */
-    offset = (offset >> npostfix) + 4;
-    /* Calculate the number of distance bits. */
-    tmp = offset / 2;
-    /* Poor-man's log2floor, to avoid extra dependencies. */
-    while (tmp != 0) {ndistbits++; tmp = tmp >> 1;}
-    /* One bit is covered with subrange addressing ("half"). */
-    ndistbits--;
-    /* Find subrange. */
-    half = (offset >> ndistbits) & 1;
-    /* Calculate the "group" part of dcode. */
-    group = ((ndistbits - 1) << 1) | half;
-    /* Calculated "group" covers the prohibited distance value. */
-    if (group == 0) {
-      /* This case is added for correctness; does not occur for limit > 128. */
-      result.max_alphabet_size = ndirect + BROTLI_NUM_DISTANCE_SHORT_CODES;
-      result.max_distance = ndirect;
-      return result;
-    }
-    /* Decrement "group", so it is the last permitted "group". */
-    group--;
-    /* After group was decremented, ndistbits and half must be recalculated. */
-    ndistbits = (group >> 1) + 1;
-    /* The last available distance in the subrange has all extra bits set. */
-    extra = (1u << ndistbits) - 1;
-    /* Calculate region start. NB: ndistbits >= 1. */
-    start = (1u << (ndistbits + 1)) - 4;
-    /* Move to subregion. */
-    start += (group & 1) << ndistbits;
-    /* Calculate the alphabet size. */
-    result.max_alphabet_size = ((group << npostfix) | postfix) + ndirect +
-        BROTLI_NUM_DISTANCE_SHORT_CODES + 1;
-    /* Calculate the maximal distance representable by alphabet. */
-    result.max_distance = ((start + extra) << npostfix) + postfix + ndirect + 1;
-    return result;
-  }
-}
-
-/* Represents the range of values belonging to a prefix code:
-   [offset, offset + 2^nbits) */
-typedef struct {
-  uint16_t offset;
-  uint8_t nbits;
-} BrotliPrefixCodeRange;
-
-/* "Soft-private", it is exported, but not "advertised" as API. */
-BROTLI_COMMON_API extern const BrotliPrefixCodeRange
-    _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
-
-}
-#endif  /* BROTLI_COMMON_CONSTANTS_H_ */
diff --git a/src/duckdb/third_party/brotli/common/brotli_platform.h b/src/duckdb/third_party/brotli/common/brotli_platform.h
deleted file mode 100644
index b24bef2d2..000000000
--- a/src/duckdb/third_party/brotli/common/brotli_platform.h
+++ /dev/null
@@ -1,543 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-Distributed under MIT license.
-See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Macros for compiler / platform specific features and build options.
-
-   Build options are:
-	* BROTLI_BUILD_32_BIT disables 64-bit optimizations
-	* BROTLI_BUILD_64_BIT forces to use 64-bit optimizations
-	* BROTLI_BUILD_BIG_ENDIAN forces to use big-endian optimizations
-	* BROTLI_BUILD_ENDIAN_NEUTRAL disables endian-aware optimizations
-	* BROTLI_BUILD_LITTLE_ENDIAN forces to use little-endian optimizations
-	* BROTLI_BUILD_NO_RBIT disables "rbit" optimization for ARM CPUs
-	* BROTLI_BUILD_NO_UNALIGNED_READ_FAST forces off the fast-unaligned-read
-	  optimizations (mainly for testing purposes)
-	* BROTLI_DEBUG dumps file name and line number when decoder detects stream
-	  or memory error
-	* BROTLI_ENABLE_LOG enables asserts and dumps various state information
-	* BROTLI_ENABLE_DUMP overrides default "dump" behaviour
-*/
-
-#ifndef BROTLI_COMMON_PLATFORM_H_
-#define BROTLI_COMMON_PLATFORM_H_
-
-#include <string.h>  /* memcpy */
-
-#include <brotli/port.h>
-#include <brotli/types.h>
-
-#if defined(OS_LINUX) || defined(OS_CYGWIN) || defined(__EMSCRIPTEN__)
-#include <endian.h>
-#elif defined(OS_FREEBSD)
-#include <machine/endian.h>
-#elif defined(OS_MACOSX)
-#include <machine/endian.h>
-/* Let's try and follow the Linux convention */
-#define BROTLI_X_BYTE_ORDER BYTE_ORDER
-#define BROTLI_X_LITTLE_ENDIAN LITTLE_ENDIAN
-#define BROTLI_X_BIG_ENDIAN BIG_ENDIAN
-#endif
-
-#if BROTLI_MSVC_VERSION_CHECK(18, 0, 0)
-#include <intrin.h>
-#endif
-
-#if defined(BROTLI_ENABLE_LOG) || defined(BROTLI_DEBUG)
-#include <assert.h>
-#include <stdio.h>
-#endif
-
-/* The following macros were borrowed from https://github.com/nemequ/hedley
-* with permission of original author - Evan Nemerson <evan@nemerson.com> */
-
-/* >>> >>> >>> hedley macros */
-
-/* Define "BROTLI_PREDICT_TRUE" and "BROTLI_PREDICT_FALSE" macros for capable
-   compilers.
-
-To apply compiler hint, enclose the branching condition into macros, like this:
-
-  if (BROTLI_PREDICT_TRUE(zero == 0)) {
-	// main execution path
-  } else {
-	// compiler should place this code outside of main execution path
-  }
-
-OR:
-
-  if (BROTLI_PREDICT_FALSE(something_rare_or_unexpected_happens)) {
-	// compiler should place this code outside of main execution path
-  }
-
-*/
-#if BROTLI_GNUC_HAS_BUILTIN(__builtin_expect, 3, 0, 0) || \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0) ||               \
- BROTLI_SUNPRO_VERSION_CHECK(5, 15, 0) ||              \
- BROTLI_ARM_VERSION_CHECK(4, 1, 0) ||                  \
- BROTLI_IBM_VERSION_CHECK(10, 1, 0) ||                 \
- BROTLI_TI_VERSION_CHECK(7, 3, 0) ||                   \
- BROTLI_TINYC_VERSION_CHECK(0, 9, 27)
-#define BROTLI_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
-#define BROTLI_PREDICT_FALSE(x) (__builtin_expect(x, 0))
-#else
-#define BROTLI_PREDICT_FALSE(x) (x)
-#define BROTLI_PREDICT_TRUE(x) (x)
-#endif
-
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
- !defined(__cplusplus)
-#define BROTLI_RESTRICT restrict
-#elif BROTLI_GNUC_VERSION_CHECK(3, 1, 0) ||                         \
- BROTLI_MSVC_VERSION_CHECK(14, 0, 0) ||                          \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0) ||                         \
- BROTLI_ARM_VERSION_CHECK(4, 1, 0) ||                            \
- BROTLI_IBM_VERSION_CHECK(10, 1, 0) ||                           \
- BROTLI_PGI_VERSION_CHECK(17, 10, 0) ||                          \
- BROTLI_TI_VERSION_CHECK(8, 0, 0) ||                             \
- BROTLI_IAR_VERSION_CHECK(8, 0, 0) ||                            \
- (BROTLI_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus))
-#define BROTLI_RESTRICT __restrict
-#elif BROTLI_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus)
-#define BROTLI_RESTRICT _Restrict
-#else
-#define BROTLI_RESTRICT
-#endif
-
-#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
- (defined(__cplusplus) && (__cplusplus >= 199711L))
-#define BROTLI_MAYBE_INLINE inline
-#elif defined(__GNUC_STDC_INLINE__) || defined(__GNUC_GNU_INLINE__) || \
- BROTLI_ARM_VERSION_CHECK(6, 2, 0)
-#define BROTLI_MAYBE_INLINE __inline__
-#elif BROTLI_MSVC_VERSION_CHECK(12, 0, 0) || \
- BROTLI_ARM_VERSION_CHECK(4, 1, 0) || BROTLI_TI_VERSION_CHECK(8, 0, 0)
-#define BROTLI_MAYBE_INLINE __inline
-#else
-#define BROTLI_MAYBE_INLINE
-#endif
-
-#if BROTLI_GNUC_HAS_ATTRIBUTE(always_inline, 4, 0, 0) ||                       \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0) ||                                    \
- BROTLI_SUNPRO_VERSION_CHECK(5, 11, 0) ||                                   \
- BROTLI_ARM_VERSION_CHECK(4, 1, 0) ||                                       \
- BROTLI_IBM_VERSION_CHECK(10, 1, 0) ||                                      \
- BROTLI_TI_VERSION_CHECK(8, 0, 0) ||                                        \
- (BROTLI_TI_VERSION_CHECK(7, 3, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
-#define BROTLI_INLINE BROTLI_MAYBE_INLINE __attribute__((__always_inline__))
-#elif BROTLI_MSVC_VERSION_CHECK(12, 0, 0)
-#define BROTLI_INLINE BROTLI_MAYBE_INLINE __forceinline
-#elif BROTLI_TI_VERSION_CHECK(7, 0, 0) && defined(__cplusplus)
-#define BROTLI_INLINE BROTLI_MAYBE_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
-#elif BROTLI_IAR_VERSION_CHECK(8, 0, 0)
-#define BROTLI_INLINE BROTLI_MAYBE_INLINE _Pragma("inline=forced")
-#else
-#define BROTLI_INLINE BROTLI_MAYBE_INLINE
-#endif
-
-#if BROTLI_GNUC_HAS_ATTRIBUTE(noinline, 4, 0, 0) ||                            \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0) ||                                    \
- BROTLI_SUNPRO_VERSION_CHECK(5, 11, 0) ||                                   \
- BROTLI_ARM_VERSION_CHECK(4, 1, 0) ||                                       \
- BROTLI_IBM_VERSION_CHECK(10, 1, 0) ||                                      \
- BROTLI_TI_VERSION_CHECK(8, 0, 0) ||                                        \
- (BROTLI_TI_VERSION_CHECK(7, 3, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
-#define BROTLI_NOINLINE __attribute__((__noinline__))
-#elif BROTLI_MSVC_VERSION_CHECK(13, 10, 0)
-#define BROTLI_NOINLINE __declspec(noinline)
-#elif BROTLI_PGI_VERSION_CHECK(10, 2, 0)
-#define BROTLI_NOINLINE _Pragma("noinline")
-#elif BROTLI_TI_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
-#define BROTLI_NOINLINE _Pragma("FUNC_CANNOT_INLINE;")
-#elif BROTLI_IAR_VERSION_CHECK(8, 0, 0)
-#define BROTLI_NOINLINE _Pragma("inline=never")
-#else
-#define BROTLI_NOINLINE
-#endif
-
-/* <<< <<< <<< end of hedley macros. */
-
-#if BROTLI_GNUC_HAS_ATTRIBUTE(unused, 2, 7, 0) || \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
-#define BROTLI_UNUSED_FUNCTION static BROTLI_INLINE __attribute__ ((unused))
-#else
-#define BROTLI_UNUSED_FUNCTION static BROTLI_INLINE
-#endif
-
-#if BROTLI_GNUC_HAS_ATTRIBUTE(aligned, 2, 7, 0)
-#define BROTLI_ALIGNED(N) __attribute__((aligned(N)))
-#else
-#define BROTLI_ALIGNED(N)
-#endif
-
-#if (defined(__ARM_ARCH) && (__ARM_ARCH == 7)) || \
- (defined(M_ARM) && (M_ARM == 7))
-#define BROTLI_TARGET_ARMV7
-#endif  /* ARMv7 */
-
-#if (defined(__ARM_ARCH) && (__ARM_ARCH == 8)) || \
- defined(__aarch64__) || defined(__ARM64_ARCH_8__)
-#define BROTLI_TARGET_ARMV8_ANY
-
-#if defined(__ARM_32BIT_STATE)
-#define BROTLI_TARGET_ARMV8_32
-#elif defined(__ARM_64BIT_STATE)
-#define BROTLI_TARGET_ARMV8_64
-#endif
-
-#endif  /* ARMv8 */
-
-#if defined(__ARM_NEON__) || defined(__ARM_NEON)
-#define BROTLI_TARGET_NEON
-#endif
-
-#if defined(__i386) || defined(_M_IX86)
-#define BROTLI_TARGET_X86
-#endif
-
-#if defined(__x86_64__) || defined(_M_X64)
-#define BROTLI_TARGET_X64
-#endif
-
-#if defined(__PPC64__)
-#define BROTLI_TARGET_POWERPC64
-#endif
-
-#if defined(__riscv) && defined(__riscv_xlen) && __riscv_xlen == 64
-#define BROTLI_TARGET_RISCV64
-#endif
-
-#if defined(__loongarch_lp64)
-#define BROTLI_TARGET_LOONGARCH64
-#endif
-
-#if defined(BROTLI_TARGET_X64) || defined(BROTLI_TARGET_ARMV8_64) || \
- defined(BROTLI_TARGET_POWERPC64) || defined(BROTLI_TARGET_RISCV64) || \
- defined(BROTLI_TARGET_LOONGARCH64)
-#define BROTLI_TARGET_64_BITS 1
-#else
-#define BROTLI_TARGET_64_BITS 0
-#endif
-
-#if defined(BROTLI_BUILD_64_BIT)
-#define BROTLI_64_BITS 1
-#elif defined(BROTLI_BUILD_32_BIT)
-#define BROTLI_64_BITS 0
-#else
-#define BROTLI_64_BITS BROTLI_TARGET_64_BITS
-#endif
-
-#if (BROTLI_64_BITS)
-#define brotli_reg_t uint64_t
-#else
-#define brotli_reg_t uint32_t
-#endif
-
-#if defined(BROTLI_BUILD_BIG_ENDIAN)
-#define BROTLI_BIG_ENDIAN 1
-#elif defined(BROTLI_BUILD_LITTLE_ENDIAN)
-#define BROTLI_LITTLE_ENDIAN 1
-#elif defined(BROTLI_BUILD_ENDIAN_NEUTRAL)
-/* Just break elif chain. */
-#elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define BROTLI_LITTLE_ENDIAN 1
-#elif defined(_WIN32) || defined(BROTLI_TARGET_X64)
-/* Win32 & x64 can currently always be assumed to be little endian */
-#define BROTLI_LITTLE_ENDIAN 1
-#elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#define BROTLI_BIG_ENDIAN 1
-#elif defined(BROTLI_X_BYTE_ORDER)
-#if BROTLI_X_BYTE_ORDER == BROTLI_X_LITTLE_ENDIAN
-#define BROTLI_LITTLE_ENDIAN 1
-#elif BROTLI_X_BYTE_ORDER == BROTLI_X_BIG_ENDIAN
-#define BROTLI_BIG_ENDIAN 1
-#endif
-#endif  /* BROTLI_X_BYTE_ORDER */
-
-#if !defined(BROTLI_LITTLE_ENDIAN)
-#define BROTLI_LITTLE_ENDIAN 0
-#endif
-
-#if !defined(BROTLI_BIG_ENDIAN)
-#define BROTLI_BIG_ENDIAN 0
-#endif
-
-#if defined(BROTLI_X_BYTE_ORDER)
-#undef BROTLI_X_BYTE_ORDER
-#undef BROTLI_X_LITTLE_ENDIAN
-#undef BROTLI_X_BIG_ENDIAN
-#endif
-
-#if defined(BROTLI_BUILD_NO_UNALIGNED_READ_FAST)
-#define BROTLI_UNALIGNED_READ_FAST (!!0)
-#elif defined(BROTLI_TARGET_X86) || defined(BROTLI_TARGET_X64) ||       \
- defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY) || \
- defined(BROTLI_TARGET_RISCV64) || defined(BROTLI_TARGET_LOONGARCH64)
-/* These targets are known to generate efficient code for unaligned reads
-* (e.g. a single instruction, not multiple 1-byte loads, shifted and or'd
-* together). */
-#define BROTLI_UNALIGNED_READ_FAST (!!1)
-#else
-#define BROTLI_UNALIGNED_READ_FAST (!!0)
-#endif
-
-/* Portable unaligned memory access: read / write values via memcpy. */
-static BROTLI_INLINE uint16_t BrotliUnalignedRead16(const void* p) {
-	uint16_t t;
-	memcpy(&t, p, sizeof t);
-	return t;
-}
-static BROTLI_INLINE uint32_t BrotliUnalignedRead32(const void* p) {
-	uint32_t t;
-	memcpy(&t, p, sizeof t);
-	return t;
-}
-static BROTLI_INLINE uint64_t BrotliUnalignedRead64(const void* p) {
-	uint64_t t;
-	memcpy(&t, p, sizeof t);
-	return t;
-}
-static BROTLI_INLINE void BrotliUnalignedWrite64(void* p, uint64_t v) {
-	memcpy(p, &v, sizeof v);
-}
-
-#if BROTLI_LITTLE_ENDIAN
-/* Straight endianness. Just read / write values. */
-#define BROTLI_UNALIGNED_LOAD16LE BrotliUnalignedRead16
-#define BROTLI_UNALIGNED_LOAD32LE BrotliUnalignedRead32
-#define BROTLI_UNALIGNED_LOAD64LE BrotliUnalignedRead64
-#define BROTLI_UNALIGNED_STORE64LE BrotliUnalignedWrite64
-#elif BROTLI_BIG_ENDIAN  /* BROTLI_LITTLE_ENDIAN */
-/* Explain compiler to byte-swap values. */
-#define BROTLI_BSWAP16_(V) ((uint16_t)( \
-(((V) & 0xFFU) << 8) | \
-(((V) >> 8) & 0xFFU)))
-static BROTLI_INLINE uint16_t BROTLI_UNALIGNED_LOAD16LE(const void* p) {
-	uint16_t value = BrotliUnalignedRead16(p);
-	return BROTLI_BSWAP16_(value);
-}
-#define BROTLI_BSWAP32_(V) ( \
-(((V) & 0xFFU) << 24) | (((V) & 0xFF00U) << 8) | \
-(((V) >> 8) & 0xFF00U) | (((V) >> 24) & 0xFFU))
-static BROTLI_INLINE uint32_t BROTLI_UNALIGNED_LOAD32LE(const void* p) {
-	uint32_t value = BrotliUnalignedRead32(p);
-	return BROTLI_BSWAP32_(value);
-}
-#define BROTLI_BSWAP64_(V) ( \
-(((V) & 0xFFU) << 56) | (((V) & 0xFF00U) << 40) | \
-(((V) & 0xFF0000U) << 24) | (((V) & 0xFF000000U) << 8) | \
-(((V) >> 8) & 0xFF000000U) | (((V) >> 24) & 0xFF0000U) | \
-(((V) >> 40) & 0xFF00U) | (((V) >> 56) & 0xFFU))
-static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void* p) {
-	uint64_t value = BrotliUnalignedRead64(p);
-	return BROTLI_BSWAP64_(value);
-}
-static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void* p, uint64_t v) {
-	uint64_t value = BROTLI_BSWAP64_(v);
-	BrotliUnalignedWrite64(p, value);
-}
-#else  /* BROTLI_LITTLE_ENDIAN */
-/* Read / store values byte-wise; hopefully compiler will understand. */
-static BROTLI_INLINE uint16_t BROTLI_UNALIGNED_LOAD16LE(const void* p) {
-	const uint8_t* in = (const uint8_t*)p;
-	return (uint16_t)(in[0] | (in[1] << 8));
-}
-static BROTLI_INLINE uint32_t BROTLI_UNALIGNED_LOAD32LE(const void* p) {
-	const uint8_t* in = (const uint8_t*)p;
-	uint32_t value = (uint32_t)(in[0]);
-	value |= (uint32_t)(in[1]) << 8;
-	value |= (uint32_t)(in[2]) << 16;
-	value |= (uint32_t)(in[3]) << 24;
-	return value;
-}
-static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void* p) {
-	const uint8_t* in = (const uint8_t*)p;
-	uint64_t value = (uint64_t)(in[0]);
-	value |= (uint64_t)(in[1]) << 8;
-	value |= (uint64_t)(in[2]) << 16;
-	value |= (uint64_t)(in[3]) << 24;
-	value |= (uint64_t)(in[4]) << 32;
-	value |= (uint64_t)(in[5]) << 40;
-	value |= (uint64_t)(in[6]) << 48;
-	value |= (uint64_t)(in[7]) << 56;
-	return value;
-}
-static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void* p, uint64_t v) {
-	uint8_t* out = (uint8_t*)p;
-	out[0] = (uint8_t)v;
-	out[1] = (uint8_t)(v >> 8);
-	out[2] = (uint8_t)(v >> 16);
-	out[3] = (uint8_t)(v >> 24);
-	out[4] = (uint8_t)(v >> 32);
-	out[5] = (uint8_t)(v >> 40);
-	out[6] = (uint8_t)(v >> 48);
-	out[7] = (uint8_t)(v >> 56);
-}
-#endif  /* BROTLI_LITTLE_ENDIAN */
-
-static BROTLI_INLINE void* BROTLI_UNALIGNED_LOAD_PTR(const void* p) {
-	void* v;
-	memcpy(&v, p, sizeof(void*));
-	return v;
-}
-
-static BROTLI_INLINE void BROTLI_UNALIGNED_STORE_PTR(void* p, const void* v) {
-	memcpy(p, &v, sizeof(void*));
-}
-
-/* BROTLI_IS_CONSTANT macros returns true for compile-time constants. */
-#if BROTLI_GNUC_HAS_BUILTIN(__builtin_constant_p, 3, 0, 1) || \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
-#define BROTLI_IS_CONSTANT(x) (!!__builtin_constant_p(x))
-#else
-#define BROTLI_IS_CONSTANT(x) (!!0)
-#endif
-
-#if defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY)
-#define BROTLI_HAS_UBFX (!!1)
-#else
-#define BROTLI_HAS_UBFX (!!0)
-#endif
-
-#if defined(BROTLI_ENABLE_LOG)
-#define BROTLI_LOG(x) printf x
-#else
-#define BROTLI_LOG(x)
-#endif
-
-#if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG)
-#define BROTLI_ENABLE_DUMP_DEFAULT 1
-#define BROTLI_DCHECK(x) assert(x)
-#else
-#define BROTLI_ENABLE_DUMP_DEFAULT 0
-#define BROTLI_DCHECK(x)
-#endif
-
-#if !defined(BROTLI_ENABLE_DUMP)
-#define BROTLI_ENABLE_DUMP BROTLI_ENABLE_DUMP_DEFAULT
-#endif
-
-#if BROTLI_ENABLE_DUMP
-static BROTLI_INLINE void BrotliDump(const char* f, int l, const char* fn) {
-	fprintf(stderr, "%s:%d (%s)\n", f, l, fn);
-	fflush(stderr);
-}
-#define BROTLI_DUMP() BrotliDump(__FILE__, __LINE__, __FUNCTION__)
-#else
-#define BROTLI_DUMP() (void)(0)
-#endif
-
-/* BrotliRBit assumes brotli_reg_t fits native CPU register type. */
-#if (BROTLI_64_BITS == BROTLI_TARGET_64_BITS)
-/* TODO(eustas): add appropriate icc/sunpro/arm/ibm/ti checks. */
-#if (BROTLI_GNUC_VERSION_CHECK(3, 0, 0) || defined(__llvm__)) && \
- !defined(BROTLI_BUILD_NO_RBIT)
-#if defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY)
-/* TODO(eustas): detect ARMv6T2 and enable this code for it. */
-static BROTLI_INLINE brotli_reg_t BrotliRBit(brotli_reg_t input) {
-	brotli_reg_t output;
-	__asm__("rbit %0, %1\n" : "=r"(output) : "r"(input));
-	return output;
-}
-#define BROTLI_RBIT(x) BrotliRBit(x)
-#endif  /* armv7 / armv8 */
-#endif  /* gcc || clang */
-#endif  /* brotli_reg_t is native */
-#if !defined(BROTLI_RBIT)
-static BROTLI_INLINE void BrotliRBit(void) { /* Should break build if used. */ }
-#endif  /* BROTLI_RBIT */
-
-#define BROTLI_REPEAT_4(X) {X; X; X; X;}
-#define BROTLI_REPEAT_5(X) {X; X; X; X; X;}
-#define BROTLI_REPEAT_6(X) {X; X; X; X; X; X;}
-
-#define BROTLI_UNUSED(X) (void)(X)
-
-#define BROTLI_MIN_MAX(T)                                                      \
-static BROTLI_INLINE T brotli_min_ ## T (T a, T b) { return a < b ? a : b; } \
-static BROTLI_INLINE T brotli_max_ ## T (T a, T b) { return a > b ? a : b; }
-BROTLI_MIN_MAX(double) BROTLI_MIN_MAX(float) BROTLI_MIN_MAX(int)
-	BROTLI_MIN_MAX(size_t) BROTLI_MIN_MAX(uint32_t) BROTLI_MIN_MAX(uint8_t)
-#undef BROTLI_MIN_MAX
-#define BROTLI_MIN(T, A, B) (brotli_min_ ## T((A), (B)))
-#define BROTLI_MAX(T, A, B) (brotli_max_ ## T((A), (B)))
-
-#define BROTLI_SWAP(T, A, I, J) { \
-T __brotli_swap_tmp = (A)[(I)]; \
-(A)[(I)] = (A)[(J)];            \
-(A)[(J)] = __brotli_swap_tmp;   \
-}
-
-#if BROTLI_64_BITS
-#if BROTLI_GNUC_HAS_BUILTIN(__builtin_ctzll, 3, 4, 0) || \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
-#define BROTLI_TZCNT64 __builtin_ctzll
-#elif BROTLI_MSVC_VERSION_CHECK(18, 0, 0)
-#if defined(BROTLI_TARGET_X64)
-#define BROTLI_TZCNT64 _tzcnt_u64
-#else /* BROTLI_TARGET_X64 */
-		static BROTLI_INLINE uint32_t BrotliBsf64Msvc(uint64_t x) {
-	uint32_t lsb;
-	_BitScanForward64(&lsb, x);
-	return lsb;
-}
-#define BROTLI_TZCNT64 BrotliBsf64Msvc
-#endif /* BROTLI_TARGET_X64 */
-#endif /* __builtin_ctzll */
-#endif /* BROTLI_64_BITS */
-
-#if BROTLI_GNUC_HAS_BUILTIN(__builtin_clz, 3, 4, 0) || \
- BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
-#define BROTLI_BSR32(x) (31u ^ (uint32_t)__builtin_clz(x))
-#elif BROTLI_MSVC_VERSION_CHECK(18, 0, 0)
-		static BROTLI_INLINE uint32_t BrotliBsr32Msvc(uint32_t x) {
-	unsigned long msb;
-	_BitScanReverse(&msb, x);
-	return (uint32_t)msb;
-}
-#define BROTLI_BSR32 BrotliBsr32Msvc
-#endif /* __builtin_clz */
-
-		namespace duckdb_brotli {
-
-	/* Default brotli_alloc_func */
-	BROTLI_COMMON_API void *BrotliDefaultAllocFunc(void *opaque, size_t size);
-
-	/* Default brotli_free_func */
-	BROTLI_COMMON_API void BrotliDefaultFreeFunc(void *opaque, void *address);
-
-	BROTLI_UNUSED_FUNCTION void BrotliSuppressUnusedFunctions(void) {
-		BROTLI_UNUSED(&BrotliSuppressUnusedFunctions);
-		BROTLI_UNUSED(&BrotliUnalignedRead16);
-		BROTLI_UNUSED(&BrotliUnalignedRead32);
-		BROTLI_UNUSED(&BrotliUnalignedRead64);
-		BROTLI_UNUSED(&BrotliUnalignedWrite64);
-		BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD16LE);
-		BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD32LE);
-		BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD64LE);
-		BROTLI_UNUSED(&BROTLI_UNALIGNED_STORE64LE);
-		BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD_PTR);
-		BROTLI_UNUSED(&BROTLI_UNALIGNED_STORE_PTR);
-		BROTLI_UNUSED(&BrotliRBit);
-		BROTLI_UNUSED(&brotli_min_double);
-		BROTLI_UNUSED(&brotli_max_double);
-		BROTLI_UNUSED(&brotli_min_float);
-		BROTLI_UNUSED(&brotli_max_float);
-		BROTLI_UNUSED(&brotli_min_int);
-		BROTLI_UNUSED(&brotli_max_int);
-		BROTLI_UNUSED(&brotli_min_size_t);
-		BROTLI_UNUSED(&brotli_max_size_t);
-		BROTLI_UNUSED(&brotli_min_uint32_t);
-		BROTLI_UNUSED(&brotli_max_uint32_t);
-		BROTLI_UNUSED(&brotli_min_uint8_t);
-		BROTLI_UNUSED(&brotli_max_uint8_t);
-		BROTLI_UNUSED(&BrotliDefaultAllocFunc);
-		BROTLI_UNUSED(&BrotliDefaultFreeFunc);
-#if BROTLI_ENABLE_DUMP
-		BROTLI_UNUSED(&BrotliDump);
-#endif
-	}
-}
-#endif  /* BROTLI_COMMON_PLATFORM_H_ */
diff --git a/src/duckdb/third_party/brotli/common/constants.cpp b/src/duckdb/third_party/brotli/common/constants.cpp
deleted file mode 100644
index 23f291c28..000000000
--- a/src/duckdb/third_party/brotli/common/constants.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "brotli_constants.h"
-
-using namespace duckdb_brotli;
-
-const BrotliPrefixCodeRange
-    duckdb_brotli::_kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = {
-        {1, 2},     {5, 2},     {9, 2},   {13, 2},    {17, 3},    {25, 3},
-        {33, 3},    {41, 3},    {49, 4},  {65, 4},    {81, 4},    {97, 4},
-        {113, 5},   {145, 5},   {177, 5}, {209, 5},   {241, 6},   {305, 6},
-        {369, 7},   {497, 8},   {753, 9}, {1265, 10}, {2289, 11}, {4337, 12},
-        {8433, 13}, {16625, 24}};
diff --git a/src/duckdb/third_party/brotli/common/context.cpp b/src/duckdb/third_party/brotli/common/context.cpp
deleted file mode 100644
index 2cc58005a..000000000
--- a/src/duckdb/third_party/brotli/common/context.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-#include "context.h"
-
-#include <brotli/types.h>
-
-/* Common context lookup table for all context modes. */
-const uint8_t duckdb_brotli::_kBrotliContextLookupTable[2048] = {
-  /* CONTEXT_LSB6, last byte. */
-   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-
-  /* CONTEXT_LSB6, second last byte, */
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-
-  /* CONTEXT_MSB6, last byte. */
-   0,  0,  0,  0,  1,  1,  1,  1,  2,  2,  2,  2,  3,  3,  3,  3,
-   4,  4,  4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,
-   8,  8,  8,  8,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 11,
-  12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15,
-  16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19,
-  20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23,
-  24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27,
-  28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31,
-  32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35,
-  36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 39,
-  40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43,
-  44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47,
-  48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51, 51, 51,
-  52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55,
-  56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58, 59, 59, 59, 59,
-  60, 60, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 63, 63, 63, 63,
-
-  /* CONTEXT_MSB6, second last byte, */
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-
-  /* CONTEXT_UTF8, last byte. */
-  /* ASCII range. */
-   0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  4,  0,  0,  4,  0,  0,
-   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-   8, 12, 16, 12, 12, 20, 12, 16, 24, 28, 12, 12, 32, 12, 36, 12,
-  44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 32, 32, 24, 40, 28, 12,
-  12, 48, 52, 52, 52, 48, 52, 52, 52, 48, 52, 52, 52, 52, 52, 48,
-  52, 52, 52, 52, 52, 48, 52, 52, 52, 52, 52, 24, 12, 28, 12, 12,
-  12, 56, 60, 60, 60, 56, 60, 60, 60, 56, 60, 60, 60, 60, 60, 56,
-  60, 60, 60, 60, 60, 56, 60, 60, 60, 60, 60, 24, 12, 28, 12,  0,
-  /* UTF8 continuation byte range. */
-  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
-  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
-  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
-  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
-  /* UTF8 lead byte range. */
-  2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
-  2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
-  2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
-  2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
-
-  /* CONTEXT_UTF8 second last byte. */
-  /* ASCII range. */
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
-  1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
-  1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 0,
-  /* UTF8 continuation byte range. */
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  /* UTF8 lead byte range. */
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-
-  /* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */
-   0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
-  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-  32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-  32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-  32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-  40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-  40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-  40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-  48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56,
-
-  /* CONTEXT_SIGNED, second last byte. */
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7,
-};
diff --git a/src/duckdb/third_party/brotli/common/context.h b/src/duckdb/third_party/brotli/common/context.h
deleted file mode 100644
index 4e575528f..000000000
--- a/src/duckdb/third_party/brotli/common/context.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Lookup table to map the previous two bytes to a context id.
-
-  There are four different context modeling modes defined here:
-    CONTEXT_LSB6: context id is the least significant 6 bits of the last byte,
-    CONTEXT_MSB6: context id is the most significant 6 bits of the last byte,
-    CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text,
-    CONTEXT_SIGNED: second-order context model tuned for signed integers.
-
-  If |p1| and |p2| are the previous two bytes, and |mode| is current context
-  mode, we calculate the context as:
-
-    context = ContextLut(mode)[p1] | ContextLut(mode)[p2 + 256].
-
-  For CONTEXT_UTF8 mode, if the previous two bytes are ASCII characters
-  (i.e. < 128), this will be equivalent to
-
-    context = 4 * context1(p1) + context2(p2),
-
-  where context1 is based on the previous byte in the following way:
-
-    0  : non-ASCII control
-    1  : \t, \n, \r
-    2  : space
-    3  : other punctuation
-    4  : " '
-    5  : %
-    6  : ( < [ {
-    7  : ) > ] }
-    8  : , ; :
-    9  : .
-    10 : =
-    11 : number
-    12 : upper-case vowel
-    13 : upper-case consonant
-    14 : lower-case vowel
-    15 : lower-case consonant
-
-  and context2 is based on the second last byte:
-
-    0 : control, space
-    1 : punctuation
-    2 : upper-case letter, number
-    3 : lower-case letter
-
-  If the last byte is ASCII, and the second last byte is not (in a valid UTF8
-  stream it will be a continuation byte, value between 128 and 191), the
-  context is the same as if the second last byte was an ASCII control or space.
-
-  If the last byte is a UTF8 lead byte (value >= 192), then the next byte will
-  be a continuation byte and the context id is 2 or 3 depending on the LSB of
-  the last byte and to a lesser extent on the second last byte if it is ASCII.
-
-  If the last byte is a UTF8 continuation byte, the second last byte can be:
-    - continuation byte: the next byte is probably ASCII or lead byte (assuming
-      4-byte UTF8 characters are rare) and the context id is 0 or 1.
-    - lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1
-    - lead byte (208 - 255): next byte is continuation byte, context is 2 or 3
-
-  The possible value combinations of the previous two bytes, the range of
-  context ids and the type of the next byte is summarized in the table below:
-
-  |--------\-----------------------------------------------------------------|
-  |         \                         Last byte                              |
-  | Second   \---------------------------------------------------------------|
-  | last byte \    ASCII            |   cont. byte        |   lead byte      |
-  |            \   (0-127)          |   (128-191)         |   (192-)         |
-  |=============|===================|=====================|==================|
-  |  ASCII      | next: ASCII/lead  |  not valid          |  next: cont.     |
-  |  (0-127)    | context: 4 - 63   |                     |  context: 2 - 3  |
-  |-------------|-------------------|---------------------|------------------|
-  |  cont. byte | next: ASCII/lead  |  next: ASCII/lead   |  next: cont.     |
-  |  (128-191)  | context: 4 - 63   |  context: 0 - 1     |  context: 2 - 3  |
-  |-------------|-------------------|---------------------|------------------|
-  |  lead byte  | not valid         |  next: ASCII/lead   |  not valid       |
-  |  (192-207)  |                   |  context: 0 - 1     |                  |
-  |-------------|-------------------|---------------------|------------------|
-  |  lead byte  | not valid         |  next: cont.        |  not valid       |
-  |  (208-)     |                   |  context: 2 - 3     |                  |
-  |-------------|-------------------|---------------------|------------------|
-*/
-
-#ifndef BROTLI_COMMON_CONTEXT_H_
-#define BROTLI_COMMON_CONTEXT_H_
-
-#include <brotli/port.h>
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-typedef enum ContextType { CONTEXT_LSB6 = 0, CONTEXT_MSB6 = 1, CONTEXT_UTF8 = 2, CONTEXT_SIGNED = 3 } ContextType;
-
-/* "Soft-private", it is exported, but not "advertised" as API. */
-/* Common context lookup table for all context modes. */
-BROTLI_COMMON_API extern const uint8_t _kBrotliContextLookupTable[2048];
-
-typedef const uint8_t *ContextLut;
-
-/* typeof(MODE) == ContextType; returns ContextLut */
-#define BROTLI_CONTEXT_LUT(MODE) (&_kBrotliContextLookupTable[(MODE) << 9])
-
-/* typeof(LUT) == ContextLut */
-#define BROTLI_CONTEXT(P1, P2, LUT) ((LUT)[P1] | ((LUT) + 256)[P2])
-}
-#endif  /* BROTLI_COMMON_CONTEXT_H_ */
diff --git a/src/duckdb/third_party/brotli/common/dictionary.cpp b/src/duckdb/third_party/brotli/common/dictionary.cpp
deleted file mode 100644
index 78bec35d8..000000000
--- a/src/duckdb/third_party/brotli/common/dictionary.cpp
+++ /dev/null
@@ -1,5912 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "dictionary.h"
-#include "brotli_platform.h"
-
-using namespace duckdb_brotli;
-
-#if !defined(BROTLI_EXTERNAL_DICTIONARY_DATA)
-static const uint8_t kBrotliDictionaryData[] =
-/* GENERATED CODE START */
-{
-116,105,109,101,100,111,119,110,108,105,102,101,108,101,102,116,98,97,99,107,99,
-111,100,101,100,97,116,97,115,104,111,119,111,110,108,121,115,105,116,101,99,105
-,116,121,111,112,101,110,106,117,115,116,108,105,107,101,102,114,101,101,119,111
-,114,107,116,101,120,116,121,101,97,114,111,118,101,114,98,111,100,121,108,111,
-118,101,102,111,114,109,98,111,111,107,112,108,97,121,108,105,118,101,108,105,
-110,101,104,101,108,112,104,111,109,101,115,105,100,101,109,111,114,101,119,111,
-114,100,108,111,110,103,116,104,101,109,118,105,101,119,102,105,110,100,112,97,
-103,101,100,97,121,115,102,117,108,108,104,101,97,100,116,101,114,109,101,97,99,
-104,97,114,101,97,102,114,111,109,116,114,117,101,109,97,114,107,97,98,108,101,
-117,112,111,110,104,105,103,104,100,97,116,101,108,97,110,100,110,101,119,115,
-101,118,101,110,110,101,120,116,99,97,115,101,98,111,116,104,112,111,115,116,117
-,115,101,100,109,97,100,101,104,97,110,100,104,101,114,101,119,104,97,116,110,97
-,109,101,76,105,110,107,98,108,111,103,115,105,122,101,98,97,115,101,104,101,108
-,100,109,97,107,101,109,97,105,110,117,115,101,114,39,41,32,43,104,111,108,100,
-101,110,100,115,119,105,116,104,78,101,119,115,114,101,97,100,119,101,114,101,
-115,105,103,110,116,97,107,101,104,97,118,101,103,97,109,101,115,101,101,110,99,
-97,108,108,112,97,116,104,119,101,108,108,112,108,117,115,109,101,110,117,102,
-105,108,109,112,97,114,116,106,111,105,110,116,104,105,115,108,105,115,116,103,
-111,111,100,110,101,101,100,119,97,121,115,119,101,115,116,106,111,98,115,109,
-105,110,100,97,108,115,111,108,111,103,111,114,105,99,104,117,115,101,115,108,97
-,115,116,116,101,97,109,97,114,109,121,102,111,111,100,107,105,110,103,119,105,
-108,108,101,97,115,116,119,97,114,100,98,101,115,116,102,105,114,101,80,97,103,
-101,107,110,111,119,97,119,97,121,46,112,110,103,109,111,118,101,116,104,97,110,
-108,111,97,100,103,105,118,101,115,101,108,102,110,111,116,101,109,117,99,104,
-102,101,101,100,109,97,110,121,114,111,99,107,105,99,111,110,111,110,99,101,108,
-111,111,107,104,105,100,101,100,105,101,100,72,111,109,101,114,117,108,101,104,
-111,115,116,97,106,97,120,105,110,102,111,99,108,117,98,108,97,119,115,108,101,
-115,115,104,97,108,102,115,111,109,101,115,117,99,104,122,111,110,101,49,48,48,
-37,111,110,101,115,99,97,114,101,84,105,109,101,114,97,99,101,98,108,117,101,102
-,111,117,114,119,101,101,107,102,97,99,101,104,111,112,101,103,97,118,101,104,97
-,114,100,108,111,115,116,119,104,101,110,112,97,114,107,107,101,112,116,112,97,
-115,115,115,104,105,112,114,111,111,109,72,84,77,76,112,108,97,110,84,121,112,
-101,100,111,110,101,115,97,118,101,107,101,101,112,102,108,97,103,108,105,110,
-107,115,111,108,100,102,105,118,101,116,111,111,107,114,97,116,101,116,111,119,
-110,106,117,109,112,116,104,117,115,100,97,114,107,99,97,114,100,102,105,108,101
-,102,101,97,114,115,116,97,121,107,105,108,108,116,104,97,116,102,97,108,108,97,
-117,116,111,101,118,101,114,46,99,111,109,116,97,108,107,115,104,111,112,118,111
-,116,101,100,101,101,112,109,111,100,101,114,101,115,116,116,117,114,110,98,111,
-114,110,98,97,110,100,102,101,108,108,114,111,115,101,117,114,108,40,115,107,105
-,110,114,111,108,101,99,111,109,101,97,99,116,115,97,103,101,115,109,101,101,116
-,103,111,108,100,46,106,112,103,105,116,101,109,118,97,114,121,102,101,108,116,
-116,104,101,110,115,101,110,100,100,114,111,112,86,105,101,119,99,111,112,121,49
-,46,48,34,60,47,97,62,115,116,111,112,101,108,115,101,108,105,101,115,116,111,
-117,114,112,97,99,107,46,103,105,102,112,97,115,116,99,115,115,63,103,114,97,121
-,109,101,97,110,38,103,116,59,114,105,100,101,115,104,111,116,108,97,116,101,115
-,97,105,100,114,111,97,100,118,97,114,32,102,101,101,108,106,111,104,110,114,105
-,99,107,112,111,114,116,102,97,115,116,39,85,65,45,100,101,97,100,60,47,98,62,
-112,111,111,114,98,105,108,108,116,121,112,101,85,46,83,46,119,111,111,100,109,
-117,115,116,50,112,120,59,73,110,102,111,114,97,110,107,119,105,100,101,119,97,
-110,116,119,97,108,108,108,101,97,100,91,48,93,59,112,97,117,108,119,97,118,101,
-115,117,114,101,36,40,39,35,119,97,105,116,109,97,115,115,97,114,109,115,103,111
-,101,115,103,97,105,110,108,97,110,103,112,97,105,100,33,45,45,32,108,111,99,107
-,117,110,105,116,114,111,111,116,119,97,108,107,102,105,114,109,119,105,102,101,
-120,109,108,34,115,111,110,103,116,101,115,116,50,48,112,120,107,105,110,100,114
-,111,119,115,116,111,111,108,102,111,110,116,109,97,105,108,115,97,102,101,115,
-116,97,114,109,97,112,115,99,111,114,101,114,97,105,110,102,108,111,119,98,97,98
-,121,115,112,97,110,115,97,121,115,52,112,120,59,54,112,120,59,97,114,116,115,
-102,111,111,116,114,101,97,108,119,105,107,105,104,101,97,116,115,116,101,112,
-116,114,105,112,111,114,103,47,108,97,107,101,119,101,97,107,116,111,108,100,70,
-111,114,109,99,97,115,116,102,97,110,115,98,97,110,107,118,101,114,121,114,117,
-110,115,106,117,108,121,116,97,115,107,49,112,120,59,103,111,97,108,103,114,101,
-119,115,108,111,119,101,100,103,101,105,100,61,34,115,101,116,115,53,112,120,59,
-46,106,115,63,52,48,112,120,105,102,32,40,115,111,111,110,115,101,97,116,110,111
-,110,101,116,117,98,101,122,101,114,111,115,101,110,116,114,101,101,100,102,97,
-99,116,105,110,116,111,103,105,102,116,104,97,114,109,49,56,112,120,99,97,109,
-101,104,105,108,108,98,111,108,100,122,111,111,109,118,111,105,100,101,97,115,
-121,114,105,110,103,102,105,108,108,112,101,97,107,105,110,105,116,99,111,115,
-116,51,112,120,59,106,97,99,107,116,97,103,115,98,105,116,115,114,111,108,108,
-101,100,105,116,107,110,101,119,110,101,97,114,60,33,45,45,103,114,111,119,74,83
-,79,78,100,117,116,121,78,97,109,101,115,97,108,101,121,111,117,32,108,111,116,
-115,112,97,105,110,106,97,122,122,99,111,108,100,101,121,101,115,102,105,115,104
-,119,119,119,46,114,105,115,107,116,97,98,115,112,114,101,118,49,48,112,120,114,
-105,115,101,50,53,112,120,66,108,117,101,100,105,110,103,51,48,48,44,98,97,108,
-108,102,111,114,100,101,97,114,110,119,105,108,100,98,111,120,46,102,97,105,114,
-108,97,99,107,118,101,114,115,112,97,105,114,106,117,110,101,116,101,99,104,105,
-102,40,33,112,105,99,107,101,118,105,108,36,40,34,35,119,97,114,109,108,111,114,
-100,100,111,101,115,112,117,108,108,44,48,48,48,105,100,101,97,100,114,97,119,
-104,117,103,101,115,112,111,116,102,117,110,100,98,117,114,110,104,114,101,102,
-99,101,108,108,107,101,121,115,116,105,99,107,104,111,117,114,108,111,115,115,
-102,117,101,108,49,50,112,120,115,117,105,116,100,101,97,108,82,83,83,34,97,103,
-101,100,103,114,101,121,71,69,84,34,101,97,115,101,97,105,109,115,103,105,114,
-108,97,105,100,115,56,112,120,59,110,97,118,121,103,114,105,100,116,105,112,115,
-35,57,57,57,119,97,114,115,108,97,100,121,99,97,114,115,41,59,32,125,112,104,112
-,63,104,101,108,108,116,97,108,108,119,104,111,109,122,104,58,229,42,47,13,10,32
-,49,48,48,104,97,108,108,46,10,10,65,55,112,120,59,112,117,115,104,99,104,97,116
-,48,112,120,59,99,114,101,119,42,47,60,47,104,97,115,104,55,53,112,120,102,108,
-97,116,114,97,114,101,32,38,38,32,116,101,108,108,99,97,109,112,111,110,116,111,
-108,97,105,100,109,105,115,115,115,107,105,112,116,101,110,116,102,105,110,101,
-109,97,108,101,103,101,116,115,112,108,111,116,52,48,48,44,13,10,13,10,99,111,
-111,108,102,101,101,116,46,112,104,112,60,98,114,62,101,114,105,99,109,111,115,
-116,103,117,105,100,98,101,108,108,100,101,115,99,104,97,105,114,109,97,116,104,
-97,116,111,109,47,105,109,103,38,35,56,50,108,117,99,107,99,101,110,116,48,48,48
-,59,116,105,110,121,103,111,110,101,104,116,109,108,115,101,108,108,100,114,117,
-103,70,82,69,69,110,111,100,101,110,105,99,107,63,105,100,61,108,111,115,101,110
-,117,108,108,118,97,115,116,119,105,110,100,82,83,83,32,119,101,97,114,114,101,
-108,121,98,101,101,110,115,97,109,101,100,117,107,101,110,97,115,97,99,97,112,
-101,119,105,115,104,103,117,108,102,84,50,51,58,104,105,116,115,115,108,111,116,
-103,97,116,101,107,105,99,107,98,108,117,114,116,104,101,121,49,53,112,120,39,39
-,41,59,41,59,34,62,109,115,105,101,119,105,110,115,98,105,114,100,115,111,114,
-116,98,101,116,97,115,101,101,107,84,49,56,58,111,114,100,115,116,114,101,101,
-109,97,108,108,54,48,112,120,102,97,114,109,226,128,153,115,98,111,121,115,91,48
-,93,46,39,41,59,34,80,79,83,84,98,101,97,114,107,105,100,115,41,59,125,125,109,
-97,114,121,116,101,110,100,40,85,75,41,113,117,97,100,122,104,58,230,45,115,105,
-122,45,45,45,45,112,114,111,112,39,41,59,13,108,105,102,116,84,49,57,58,118,105,
-99,101,97,110,100,121,100,101,98,116,62,82,83,83,112,111,111,108,110,101,99,107,
-98,108,111,119,84,49,54,58,100,111,111,114,101,118,97,108,84,49,55,58,108,101,
-116,115,102,97,105,108,111,114,97,108,112,111,108,108,110,111,118,97,99,111,108,
-115,103,101,110,101,32,226,128,148,115,111,102,116,114,111,109,101,116,105,108,
-108,114,111,115,115,60,104,51,62,112,111,117,114,102,97,100,101,112,105,110,107,
-60,116,114,62,109,105,110,105,41,124,33,40,109,105,110,101,122,104,58,232,98,97,
-114,115,104,101,97,114,48,48,41,59,109,105,108,107,32,45,45,62,105,114,111,110,
-102,114,101,100,100,105,115,107,119,101,110,116,115,111,105,108,112,117,116,115,
-47,106,115,47,104,111,108,121,84,50,50,58,73,83,66,78,84,50,48,58,97,100,97,109,
-115,101,101,115,60,104,50,62,106,115,111,110,39,44,32,39,99,111,110,116,84,50,49
-,58,32,82,83,83,108,111,111,112,97,115,105,97,109,111,111,110,60,47,112,62,115,
-111,117,108,76,73,78,69,102,111,114,116,99,97,114,116,84,49,52,58,60,104,49,62,
-56,48,112,120,33,45,45,60,57,112,120,59,84,48,52,58,109,105,107,101,58,52,54,90,
-110,105,99,101,105,110,99,104,89,111,114,107,114,105,99,101,122,104,58,228,39,41
-,41,59,112,117,114,101,109,97,103,101,112,97,114,97,116,111,110,101,98,111,110,
-100,58,51,55,90,95,111,102,95,39,93,41,59,48,48,48,44,122,104,58,231,116,97,110,
-107,121,97,114,100,98,111,119,108,98,117,115,104,58,53,54,90,74,97,118,97,51,48,
-112,120,10,124,125,10,37,67,51,37,58,51,52,90,106,101,102,102,69,88,80,73,99,97,
-115,104,118,105,115,97,103,111,108,102,115,110,111,119,122,104,58,233,113,117,
-101,114,46,99,115,115,115,105,99,107,109,101,97,116,109,105,110,46,98,105,110,
-100,100,101,108,108,104,105,114,101,112,105,99,115,114,101,110,116,58,51,54,90,
-72,84,84,80,45,50,48,49,102,111,116,111,119,111,108,102,69,78,68,32,120,98,111,
-120,58,53,52,90,66,79,68,89,100,105,99,107,59,10,125,10,101,120,105,116,58,51,53
-,90,118,97,114,115,98,101,97,116,39,125,41,59,100,105,101,116,57,57,57,59,97,110
-,110,101,125,125,60,47,91,105,93,46,76,97,110,103,107,109,194,178,119,105,114,
-101,116,111,121,115,97,100,100,115,115,101,97,108,97,108,101,120,59,10,9,125,101
-,99,104,111,110,105,110,101,46,111,114,103,48,48,53,41,116,111,110,121,106,101,
-119,115,115,97,110,100,108,101,103,115,114,111,111,102,48,48,48,41,32,50,48,48,
-119,105,110,101,103,101,97,114,100,111,103,115,98,111,111,116,103,97,114,121,99,
-117,116,115,116,121,108,101,116,101,109,112,116,105,111,110,46,120,109,108,99,
-111,99,107,103,97,110,103,36,40,39,46,53,48,112,120,80,104,46,68,109,105,115,99,
-97,108,97,110,108,111,97,110,100,101,115,107,109,105,108,101,114,121,97,110,117,
-110,105,120,100,105,115,99,41,59,125,10,100,117,115,116,99,108,105,112,41,46,10,
-10,55,48,112,120,45,50,48,48,68,86,68,115,55,93,62,60,116,97,112,101,100,101,109
-,111,105,43,43,41,119,97,103,101,101,117,114,111,112,104,105,108,111,112,116,115
-,104,111,108,101,70,65,81,115,97,115,105,110,45,50,54,84,108,97,98,115,112,101,
-116,115,85,82,76,32,98,117,108,107,99,111,111,107,59,125,13,10,72,69,65,68,91,48
-,93,41,97,98,98,114,106,117,97,110,40,49,57,56,108,101,115,104,116,119,105,110,
-60,47,105,62,115,111,110,121,103,117,121,115,102,117,99,107,112,105,112,101,124,
-45,10,33,48,48,50,41,110,100,111,119,91,49,93,59,91,93,59,10,76,111,103,32,115,
-97,108,116,13,10,9,9,98,97,110,103,116,114,105,109,98,97,116,104,41,123,13,10,48
-,48,112,120,10,125,41,59,107,111,58,236,102,101,101,115,97,100,62,13,115,58,47,
-47,32,91,93,59,116,111,108,108,112,108,117,103,40,41,123,10,123,13,10,32,46,106,
-115,39,50,48,48,112,100,117,97,108,98,111,97,116,46,74,80,71,41,59,10,125,113,
-117,111,116,41,59,10,10,39,41,59,10,13,10,125,13,50,48,49,52,50,48,49,53,50,48,
-49,54,50,48,49,55,50,48,49,56,50,48,49,57,50,48,50,48,50,48,50,49,50,48,50,50,50
-,48,50,51,50,48,50,52,50,48,50,53,50,48,50,54,50,48,50,55,50,48,50,56,50,48,50,
-57,50,48,51,48,50,48,51,49,50,48,51,50,50,48,51,51,50,48,51,52,50,48,51,53,50,48
-,51,54,50,48,51,55,50,48,49,51,50,48,49,50,50,48,49,49,50,48,49,48,50,48,48,57,
-50,48,48,56,50,48,48,55,50,48,48,54,50,48,48,53,50,48,48,52,50,48,48,51,50,48,48
-,50,50,48,48,49,50,48,48,48,49,57,57,57,49,57,57,56,49,57,57,55,49,57,57,54,49,
-57,57,53,49,57,57,52,49,57,57,51,49,57,57,50,49,57,57,49,49,57,57,48,49,57,56,57
-,49,57,56,56,49,57,56,55,49,57,56,54,49,57,56,53,49,57,56,52,49,57,56,51,49,57,
-56,50,49,57,56,49,49,57,56,48,49,57,55,57,49,57,55,56,49,57,55,55,49,57,55,54,49
-,57,55,53,49,57,55,52,49,57,55,51,49,57,55,50,49,57,55,49,49,57,55,48,49,57,54,
-57,49,57,54,56,49,57,54,55,49,57,54,54,49,57,54,53,49,57,54,52,49,57,54,51,49,57
-,54,50,49,57,54,49,49,57,54,48,49,57,53,57,49,57,53,56,49,57,53,55,49,57,53,54,
-49,57,53,53,49,57,53,52,49,57,53,51,49,57,53,50,49,57,53,49,49,57,53,48,49,48,48
-,48,49,48,50,52,49,51,57,52,48,48,48,48,57,57,57,57,99,111,109,111,109,195,161,
-115,101,115,116,101,101,115,116,97,112,101,114,111,116,111,100,111,104,97,99,101
-,99,97,100,97,97,195,177,111,98,105,101,110,100,195,173,97,97,115,195,173,118,
-105,100,97,99,97,115,111,111,116,114,111,102,111,114,111,115,111,108,111,111,116
-,114,97,99,117,97,108,100,105,106,111,115,105,100,111,103,114,97,110,116,105,112
-,111,116,101,109,97,100,101,98,101,97,108,103,111,113,117,195,169,101,115,116,
-111,110,97,100,97,116,114,101,115,112,111,99,111,99,97,115,97,98,97,106,111,116,
-111,100,97,115,105,110,111,97,103,117,97,112,117,101,115,117,110,111,115,97,110,
-116,101,100,105,99,101,108,117,105,115,101,108,108,97,109,97,121,111,122,111,110
-,97,97,109,111,114,112,105,115,111,111,98,114,97,99,108,105,99,101,108,108,111,
-100,105,111,115,104,111,114,97,99,97,115,105,208,183,208,176,208,189,208,176,208
-,190,208,188,209,128,208,176,209,128,209,131,209,130,208,176,208,189,208,181,208
-,191,208,190,208,190,209,130,208,184,208,183,208,189,208,190,208,180,208,190,209
-,130,208,190,208,182,208,181,208,190,208,189,208,184,209,133,208,157,208,176,208
-,181,208,181,208,177,209,139,208,188,209,139,208,146,209,139,209,129,208,190,208
-,178,209,139,208,178,208,190,208,157,208,190,208,190,208,177,208,159,208,190,208
-,187,208,184,208,189,208,184,208,160,208,164,208,157,208,181,208,156,209,139,209
-,130,209,139,208,158,208,189,208,184,208,188,208,180,208,176,208,151,208,176,208
-,148,208,176,208,157,209,131,208,158,208,177,209,130,208,181,208,152,208,183,208
-,181,208,185,208,189,209,131,208,188,208,188,208,162,209,139,209,131,208,182,217
-,129,217,138,216,163,217,134,217,133,216,167,217,133,216,185,217,131,217,132,216
-,163,217,136,216,177,216,175,217,138,216,167,217,129,217,137,217,135,217,136,217
-,132,217,133,217,132,217,131,216,167,217,136,217,132,217,135,216,168,216,179,216
-,167,217,132,216,165,217,134,217,135,217,138,216,163,217,138,217,130,216,175,217
-,135,217,132,216,171,217,133,216,168,217,135,217,132,217,136,217,132,217,138,216
-,168,217,132,216,167,217,138,216,168,217,131,216,180,217,138,216,167,217,133,216
-,163,217,133,217,134,216,170,216,168,217,138,217,132,217,134,216,173,216,168,217
-,135,217,133,217,133,216,180,217,136,216,180,102,105,114,115,116,118,105,100,101
-,111,108,105,103,104,116,119,111,114,108,100,109,101,100,105,97,119,104,105,116,
-101,99,108,111,115,101,98,108,97,99,107,114,105,103,104,116,115,109,97,108,108,
-98,111,111,107,115,112,108,97,99,101,109,117,115,105,99,102,105,101,108,100,111,
-114,100,101,114,112,111,105,110,116,118,97,108,117,101,108,101,118,101,108,116,
-97,98,108,101,98,111,97,114,100,104,111,117,115,101,103,114,111,117,112,119,111,
-114,107,115,121,101,97,114,115,115,116,97,116,101,116,111,100,97,121,119,97,116,
-101,114,115,116,97,114,116,115,116,121,108,101,100,101,97,116,104,112,111,119,
-101,114,112,104,111,110,101,110,105,103,104,116,101,114,114,111,114,105,110,112,
-117,116,97,98,111,117,116,116,101,114,109,115,116,105,116,108,101,116,111,111,
-108,115,101,118,101,110,116,108,111,99,97,108,116,105,109,101,115,108,97,114,103
-,101,119,111,114,100,115,103,97,109,101,115,115,104,111,114,116,115,112,97,99,
-101,102,111,99,117,115,99,108,101,97,114,109,111,100,101,108,98,108,111,99,107,
-103,117,105,100,101,114,97,100,105,111,115,104,97,114,101,119,111,109,101,110,97
-,103,97,105,110,109,111,110,101,121,105,109,97,103,101,110,97,109,101,115,121,
-111,117,110,103,108,105,110,101,115,108,97,116,101,114,99,111,108,111,114,103,
-114,101,101,110,102,114,111,110,116,38,97,109,112,59,119,97,116,99,104,102,111,
-114,99,101,112,114,105,99,101,114,117,108,101,115,98,101,103,105,110,97,102,116,
-101,114,118,105,115,105,116,105,115,115,117,101,97,114,101,97,115,98,101,108,111
-,119,105,110,100,101,120,116,111,116,97,108,104,111,117,114,115,108,97,98,101,
-108,112,114,105,110,116,112,114,101,115,115,98,117,105,108,116,108,105,110,107,
-115,115,112,101,101,100,115,116,117,100,121,116,114,97,100,101,102,111,117,110,
-100,115,101,110,115,101,117,110,100,101,114,115,104,111,119,110,102,111,114,109,
-115,114,97,110,103,101,97,100,100,101,100,115,116,105,108,108,109,111,118,101,
-100,116,97,107,101,110,97,98,111,118,101,102,108,97,115,104,102,105,120,101,100,
-111,102,116,101,110,111,116,104,101,114,118,105,101,119,115,99,104,101,99,107,
-108,101,103,97,108,114,105,118,101,114,105,116,101,109,115,113,117,105,99,107,
-115,104,97,112,101,104,117,109,97,110,101,120,105,115,116,103,111,105,110,103,
-109,111,118,105,101,116,104,105,114,100,98,97,115,105,99,112,101,97,99,101,115,
-116,97,103,101,119,105,100,116,104,108,111,103,105,110,105,100,101,97,115,119,
-114,111,116,101,112,97,103,101,115,117,115,101,114,115,100,114,105,118,101,115,
-116,111,114,101,98,114,101,97,107,115,111,117,116,104,118,111,105,99,101,115,105
-,116,101,115,109,111,110,116,104,119,104,101,114,101,98,117,105,108,100,119,104,
-105,99,104,101,97,114,116,104,102,111,114,117,109,116,104,114,101,101,115,112,
-111,114,116,112,97,114,116,121,67,108,105,99,107,108,111,119,101,114,108,105,118
-,101,115,99,108,97,115,115,108,97,121,101,114,101,110,116,114,121,115,116,111,
-114,121,117,115,97,103,101,115,111,117,110,100,99,111,117,114,116,121,111,117,
-114,32,98,105,114,116,104,112,111,112,117,112,116,121,112,101,115,97,112,112,108
-,121,73,109,97,103,101,98,101,105,110,103,117,112,112,101,114,110,111,116,101,
-115,101,118,101,114,121,115,104,111,119,115,109,101,97,110,115,101,120,116,114,
-97,109,97,116,99,104,116,114,97,99,107,107,110,111,119,110,101,97,114,108,121,98
-,101,103,97,110,115,117,112,101,114,112,97,112,101,114,110,111,114,116,104,108,
-101,97,114,110,103,105,118,101,110,110,97,109,101,100,101,110,100,101,100,84,101
-,114,109,115,112,97,114,116,115,71,114,111,117,112,98,114,97,110,100,117,115,105
-,110,103,119,111,109,97,110,102,97,108,115,101,114,101,97,100,121,97,117,100,105
-,111,116,97,107,101,115,119,104,105,108,101,46,99,111,109,47,108,105,118,101,100
-,99,97,115,101,115,100,97,105,108,121,99,104,105,108,100,103,114,101,97,116,106,
-117,100,103,101,116,104,111,115,101,117,110,105,116,115,110,101,118,101,114,98,
-114,111,97,100,99,111,97,115,116,99,111,118,101,114,97,112,112,108,101,102,105,
-108,101,115,99,121,99,108,101,115,99,101,110,101,112,108,97,110,115,99,108,105,
-99,107,119,114,105,116,101,113,117,101,101,110,112,105,101,99,101,101,109,97,105
-,108,102,114,97,109,101,111,108,100,101,114,112,104,111,116,111,108,105,109,105,
-116,99,97,99,104,101,99,105,118,105,108,115,99,97,108,101,101,110,116,101,114,
-116,104,101,109,101,116,104,101,114,101,116,111,117,99,104,98,111,117,110,100,
-114,111,121,97,108,97,115,107,101,100,119,104,111,108,101,115,105,110,99,101,115
-,116,111,99,107,32,110,97,109,101,102,97,105,116,104,104,101,97,114,116,101,109,
-112,116,121,111,102,102,101,114,115,99,111,112,101,111,119,110,101,100,109,105,
-103,104,116,97,108,98,117,109,116,104,105,110,107,98,108,111,111,100,97,114,114,
-97,121,109,97,106,111,114,116,114,117,115,116,99,97,110,111,110,117,110,105,111,
-110,99,111,117,110,116,118,97,108,105,100,115,116,111,110,101,83,116,121,108,101
-,76,111,103,105,110,104,97,112,112,121,111,99,99,117,114,108,101,102,116,58,102,
-114,101,115,104,113,117,105,116,101,102,105,108,109,115,103,114,97,100,101,110,
-101,101,100,115,117,114,98,97,110,102,105,103,104,116,98,97,115,105,115,104,111,
-118,101,114,97,117,116,111,59,114,111,117,116,101,46,104,116,109,108,109,105,120
-,101,100,102,105,110,97,108,89,111,117,114,32,115,108,105,100,101,116,111,112,
-105,99,98,114,111,119,110,97,108,111,110,101,100,114,97,119,110,115,112,108,105,
-116,114,101,97,99,104,82,105,103,104,116,100,97,116,101,115,109,97,114,99,104,
-113,117,111,116,101,103,111,111,100,115,76,105,110,107,115,100,111,117,98,116,97
-,115,121,110,99,116,104,117,109,98,97,108,108,111,119,99,104,105,101,102,121,111
-,117,116,104,110,111,118,101,108,49,48,112,120,59,115,101,114,118,101,117,110,
-116,105,108,104,97,110,100,115,67,104,101,99,107,83,112,97,99,101,113,117,101,
-114,121,106,97,109,101,115,101,113,117,97,108,116,119,105,99,101,48,44,48,48,48,
-83,116,97,114,116,112,97,110,101,108,115,111,110,103,115,114,111,117,110,100,101
-,105,103,104,116,115,104,105,102,116,119,111,114,116,104,112,111,115,116,115,108
-,101,97,100,115,119,101,101,107,115,97,118,111,105,100,116,104,101,115,101,109,
-105,108,101,115,112,108,97,110,101,115,109,97,114,116,97,108,112,104,97,112,108,
-97,110,116,109,97,114,107,115,114,97,116,101,115,112,108,97,121,115,99,108,97,
-105,109,115,97,108,101,115,116,101,120,116,115,115,116,97,114,115,119,114,111,
-110,103,60,47,104,51,62,116,104,105,110,103,46,111,114,103,47,109,117,108,116,
-105,104,101,97,114,100,80,111,119,101,114,115,116,97,110,100,116,111,107,101,110
-,115,111,108,105,100,40,116,104,105,115,98,114,105,110,103,115,104,105,112,115,
-115,116,97,102,102,116,114,105,101,100,99,97,108,108,115,102,117,108,108,121,102
-,97,99,116,115,97,103,101,110,116,84,104,105,115,32,47,47,45,45,62,97,100,109,
-105,110,101,103,121,112,116,69,118,101,110,116,49,53,112,120,59,69,109,97,105,
-108,116,114,117,101,34,99,114,111,115,115,115,112,101,110,116,98,108,111,103,115
-,98,111,120,34,62,110,111,116,101,100,108,101,97,118,101,99,104,105,110,97,115,
-105,122,101,115,103,117,101,115,116,60,47,104,52,62,114,111,98,111,116,104,101,
-97,118,121,116,114,117,101,44,115,101,118,101,110,103,114,97,110,100,99,114,105,
-109,101,115,105,103,110,115,97,119,97,114,101,100,97,110,99,101,112,104,97,115,
-101,62,60,33,45,45,101,110,95,85,83,38,35,51,57,59,50,48,48,112,120,95,110,97,
-109,101,108,97,116,105,110,101,110,106,111,121,97,106,97,120,46,97,116,105,111,
-110,115,109,105,116,104,85,46,83,46,32,104,111,108,100,115,112,101,116,101,114,
-105,110,100,105,97,110,97,118,34,62,99,104,97,105,110,115,99,111,114,101,99,111,
-109,101,115,100,111,105,110,103,112,114,105,111,114,83,104,97,114,101,49,57,57,
-48,115,114,111,109,97,110,108,105,115,116,115,106,97,112,97,110,102,97,108,108,
-115,116,114,105,97,108,111,119,110,101,114,97,103,114,101,101,60,47,104,50,62,97
-,98,117,115,101,97,108,101,114,116,111,112,101,114,97,34,45,47,47,87,99,97,114,
-100,115,104,105,108,108,115,116,101,97,109,115,80,104,111,116,111,116,114,117,
-116,104,99,108,101,97,110,46,112,104,112,63,115,97,105,110,116,109,101,116,97,
-108,108,111,117,105,115,109,101,97,110,116,112,114,111,111,102,98,114,105,101,
-102,114,111,119,34,62,103,101,110,114,101,116,114,117,99,107,108,111,111,107,115
-,86,97,108,117,101,70,114,97,109,101,46,110,101,116,47,45,45,62,10,60,116,114,
-121,32,123,10,118,97,114,32,109,97,107,101,115,99,111,115,116,115,112,108,97,105
-,110,97,100,117,108,116,113,117,101,115,116,116,114,97,105,110,108,97,98,111,114
-,104,101,108,112,115,99,97,117,115,101,109,97,103,105,99,109,111,116,111,114,116
-,104,101,105,114,50,53,48,112,120,108,101,97,115,116,115,116,101,112,115,67,111,
-117,110,116,99,111,117,108,100,103,108,97,115,115,115,105,100,101,115,102,117,
-110,100,115,104,111,116,101,108,97,119,97,114,100,109,111,117,116,104,109,111,
-118,101,115,112,97,114,105,115,103,105,118,101,115,100,117,116,99,104,116,101,
-120,97,115,102,114,117,105,116,110,117,108,108,44,124,124,91,93,59,116,111,112,
-34,62,10,60,33,45,45,80,79,83,84,34,111,99,101,97,110,60,98,114,47,62,102,108,
-111,111,114,115,112,101,97,107,100,101,112,116,104,32,115,105,122,101,98,97,110,
-107,115,99,97,116,99,104,99,104,97,114,116,50,48,112,120,59,97,108,105,103,110,
-100,101,97,108,115,119,111,117,108,100,53,48,112,120,59,117,114,108,61,34,112,97
-,114,107,115,109,111,117,115,101,77,111,115,116,32,46,46,46,60,47,97,109,111,110
-,103,98,114,97,105,110,98,111,100,121,32,110,111,110,101,59,98,97,115,101,100,99
-,97,114,114,121,100,114,97,102,116,114,101,102,101,114,112,97,103,101,95,104,111
-,109,101,46,109,101,116,101,114,100,101,108,97,121,100,114,101,97,109,112,114,
-111,118,101,106,111,105,110,116,60,47,116,114,62,100,114,117,103,115,60,33,45,45
-,32,97,112,114,105,108,105,100,101,97,108,97,108,108,101,110,101,120,97,99,116,
-102,111,114,116,104,99,111,100,101,115,108,111,103,105,99,86,105,101,119,32,115,
-101,101,109,115,98,108,97,110,107,112,111,114,116,115,32,40,50,48,48,115,97,118,
-101,100,95,108,105,110,107,103,111,97,108,115,103,114,97,110,116,103,114,101,101
-,107,104,111,109,101,115,114,105,110,103,115,114,97,116,101,100,51,48,112,120,59
-,119,104,111,115,101,112,97,114,115,101,40,41,59,34,32,66,108,111,99,107,108,105
-,110,117,120,106,111,110,101,115,112,105,120,101,108,39,41,59,34,62,41,59,105,
-102,40,45,108,101,102,116,100,97,118,105,100,104,111,114,115,101,70,111,99,117,
-115,114,97,105,115,101,98,111,120,101,115,84,114,97,99,107,101,109,101,110,116,
-60,47,101,109,62,98,97,114,34,62,46,115,114,99,61,116,111,119,101,114,97,108,116
-,61,34,99,97,98,108,101,104,101,110,114,121,50,52,112,120,59,115,101,116,117,112
-,105,116,97,108,121,115,104,97,114,112,109,105,110,111,114,116,97,115,116,101,
-119,97,110,116,115,116,104,105,115,46,114,101,115,101,116,119,104,101,101,108,
-103,105,114,108,115,47,99,115,115,47,49,48,48,37,59,99,108,117,98,115,115,116,
-117,102,102,98,105,98,108,101,118,111,116,101,115,32,49,48,48,48,107,111,114,101
-,97,125,41,59,13,10,98,97,110,100,115,113,117,101,117,101,61,32,123,125,59,56,48
-,112,120,59,99,107,105,110,103,123,13,10,9,9,97,104,101,97,100,99,108,111,99,107
-,105,114,105,115,104,108,105,107,101,32,114,97,116,105,111,115,116,97,116,115,70
-,111,114,109,34,121,97,104,111,111,41,91,48,93,59,65,98,111,117,116,102,105,110,
-100,115,60,47,104,49,62,100,101,98,117,103,116,97,115,107,115,85,82,76,32,61,99,
-101,108,108,115,125,41,40,41,59,49,50,112,120,59,112,114,105,109,101,116,101,108
-,108,115,116,117,114,110,115,48,120,54,48,48,46,106,112,103,34,115,112,97,105,
-110,98,101,97,99,104,116,97,120,101,115,109,105,99,114,111,97,110,103,101,108,45
-,45,62,60,47,103,105,102,116,115,115,116,101,118,101,45,108,105,110,107,98,111,
-100,121,46,125,41,59,10,9,109,111,117,110,116,32,40,49,57,57,70,65,81,60,47,114,
-111,103,101,114,102,114,97,110,107,67,108,97,115,115,50,56,112,120,59,102,101,
-101,100,115,60,104,49,62,60,115,99,111,116,116,116,101,115,116,115,50,50,112,120
-,59,100,114,105,110,107,41,32,124,124,32,108,101,119,105,115,115,104,97,108,108,
-35,48,51,57,59,32,102,111,114,32,108,111,118,101,100,119,97,115,116,101,48,48,
-112,120,59,106,97,58,227,130,115,105,109,111,110,60,102,111,110,116,114,101,112,
-108,121,109,101,101,116,115,117,110,116,101,114,99,104,101,97,112,116,105,103,
-104,116,66,114,97,110,100,41,32,33,61,32,100,114,101,115,115,99,108,105,112,115,
-114,111,111,109,115,111,110,107,101,121,109,111,98,105,108,109,97,105,110,46,78,
-97,109,101,32,112,108,97,116,101,102,117,110,110,121,116,114,101,101,115,99,111,
-109,47,34,49,46,106,112,103,119,109,111,100,101,112,97,114,97,109,83,84,65,82,84
-,108,101,102,116,32,105,100,100,101,110,44,32,50,48,49,41,59,10,125,10,102,111,
-114,109,46,118,105,114,117,115,99,104,97,105,114,116,114,97,110,115,119,111,114,
-115,116,80,97,103,101,115,105,116,105,111,110,112,97,116,99,104,60,33,45,45,10,
-111,45,99,97,99,102,105,114,109,115,116,111,117,114,115,44,48,48,48,32,97,115,
-105,97,110,105,43,43,41,123,97,100,111,98,101,39,41,91,48,93,105,100,61,49,48,98
-,111,116,104,59,109,101,110,117,32,46,50,46,109,105,46,112,110,103,34,107,101,
-118,105,110,99,111,97,99,104,67,104,105,108,100,98,114,117,99,101,50,46,106,112,
-103,85,82,76,41,43,46,106,112,103,124,115,117,105,116,101,115,108,105,99,101,104
-,97,114,114,121,49,50,48,34,32,115,119,101,101,116,116,114,62,13,10,110,97,109,
-101,61,100,105,101,103,111,112,97,103,101,32,115,119,105,115,115,45,45,62,10,10,
-35,102,102,102,59,34,62,76,111,103,46,99,111,109,34,116,114,101,97,116,115,104,
-101,101,116,41,32,38,38,32,49,52,112,120,59,115,108,101,101,112,110,116,101,110,
-116,102,105,108,101,100,106,97,58,227,131,105,100,61,34,99,78,97,109,101,34,119,
-111,114,115,101,115,104,111,116,115,45,98,111,120,45,100,101,108,116,97,10,38,
-108,116,59,98,101,97,114,115,58,52,56,90,60,100,97,116,97,45,114,117,114,97,108,
-60,47,97,62,32,115,112,101,110,100,98,97,107,101,114,115,104,111,112,115,61,32,
-34,34,59,112,104,112,34,62,99,116,105,111,110,49,51,112,120,59,98,114,105,97,110
-,104,101,108,108,111,115,105,122,101,61,111,61,37,50,70,32,106,111,105,110,109,
-97,121,98,101,60,105,109,103,32,105,109,103,34,62,44,32,102,106,115,105,109,103,
-34,32,34,41,91,48,93,77,84,111,112,66,84,121,112,101,34,110,101,119,108,121,68,
-97,110,115,107,99,122,101,99,104,116,114,97,105,108,107,110,111,119,115,60,47,
-104,53,62,102,97,113,34,62,122,104,45,99,110,49,48,41,59,10,45,49,34,41,59,116,
-121,112,101,61,98,108,117,101,115,116,114,117,108,121,100,97,118,105,115,46,106,
-115,39,59,62,13,10,60,33,115,116,101,101,108,32,121,111,117,32,104,50,62,13,10,
-102,111,114,109,32,106,101,115,117,115,49,48,48,37,32,109,101,110,117,46,13,10,9
-,13,10,119,97,108,101,115,114,105,115,107,115,117,109,101,110,116,100,100,105,
-110,103,98,45,108,105,107,116,101,97,99,104,103,105,102,34,32,118,101,103,97,115
-,100,97,110,115,107,101,101,115,116,105,115,104,113,105,112,115,117,111,109,105,
-115,111,98,114,101,100,101,115,100,101,101,110,116,114,101,116,111,100,111,115,
-112,117,101,100,101,97,195,177,111,115,101,115,116,195,161,116,105,101,110,101,
-104,97,115,116,97,111,116,114,111,115,112,97,114,116,101,100,111,110,100,101,110
-,117,101,118,111,104,97,99,101,114,102,111,114,109,97,109,105,115,109,111,109,
-101,106,111,114,109,117,110,100,111,97,113,117,195,173,100,195,173,97,115,115,
-195,179,108,111,97,121,117,100,97,102,101,99,104,97,116,111,100,97,115,116,97,
-110,116,111,109,101,110,111,115,100,97,116,111,115,111,116,114,97,115,115,105,
-116,105,111,109,117,99,104,111,97,104,111,114,97,108,117,103,97,114,109,97,121,
-111,114,101,115,116,111,115,104,111,114,97,115,116,101,110,101,114,97,110,116,
-101,115,102,111,116,111,115,101,115,116,97,115,112,97,195,173,115,110,117,101,
-118,97,115,97,108,117,100,102,111,114,111,115,109,101,100,105,111,113,117,105,
-101,110,109,101,115,101,115,112,111,100,101,114,99,104,105,108,101,115,101,114,
-195,161,118,101,99,101,115,100,101,99,105,114,106,111,115,195,169,101,115,116,97
-,114,118,101,110,116,97,103,114,117,112,111,104,101,99,104,111,101,108,108,111,
-115,116,101,110,103,111,97,109,105,103,111,99,111,115,97,115,110,105,118,101,108
-,103,101,110,116,101,109,105,115,109,97,97,105,114,101,115,106,117,108,105,111,
-116,101,109,97,115,104,97,99,105,97,102,97,118,111,114,106,117,110,105,111,108,
-105,98,114,101,112,117,110,116,111,98,117,101,110,111,97,117,116,111,114,97,98,
-114,105,108,98,117,101,110,97,116,101,120,116,111,109,97,114,122,111,115,97,98,
-101,114,108,105,115,116,97,108,117,101,103,111,99,195,179,109,111,101,110,101,
-114,111,106,117,101,103,111,112,101,114,195,186,104,97,98,101,114,101,115,116,
-111,121,110,117,110,99,97,109,117,106,101,114,118,97,108,111,114,102,117,101,114
-,97,108,105,98,114,111,103,117,115,116,97,105,103,117,97,108,118,111,116,111,115
-,99,97,115,111,115,103,117,195,173,97,112,117,101,100,111,115,111,109,111,115,97
-,118,105,115,111,117,115,116,101,100,100,101,98,101,110,110,111,99,104,101,98,
-117,115,99,97,102,97,108,116,97,101,117,114,111,115,115,101,114,105,101,100,105,
-99,104,111,99,117,114,115,111,99,108,97,118,101,99,97,115,97,115,108,101,195,179
-,110,112,108,97,122,111,108,97,114,103,111,111,98,114,97,115,118,105,115,116,97,
-97,112,111,121,111,106,117,110,116,111,116,114,97,116,97,118,105,115,116,111,99,
-114,101,97,114,99,97,109,112,111,104,101,109,111,115,99,105,110,99,111,99,97,114
-,103,111,112,105,115,111,115,111,114,100,101,110,104,97,99,101,110,195,161,114,
-101,97,100,105,115,99,111,112,101,100,114,111,99,101,114,99,97,112,117,101,100,
-97,112,97,112,101,108,109,101,110,111,114,195,186,116,105,108,99,108,97,114,111,
-106,111,114,103,101,99,97,108,108,101,112,111,110,101,114,116,97,114,100,101,110
-,97,100,105,101,109,97,114,99,97,115,105,103,117,101,101,108,108,97,115,115,105,
-103,108,111,99,111,99,104,101,109,111,116,111,115,109,97,100,114,101,99,108,97,
-115,101,114,101,115,116,111,110,105,195,177,111,113,117,101,100,97,112,97,115,97
-,114,98,97,110,99,111,104,105,106,111,115,118,105,97,106,101,112,97,98,108,111,
-195,169,115,116,101,118,105,101,110,101,114,101,105,110,111,100,101,106,97,114,
-102,111,110,100,111,99,97,110,97,108,110,111,114,116,101,108,101,116,114,97,99,
-97,117,115,97,116,111,109,97,114,109,97,110,111,115,108,117,110,101,115,97,117,
-116,111,115,118,105,108,108,97,118,101,110,100,111,112,101,115,97,114,116,105,
-112,111,115,116,101,110,103,97,109,97,114,99,111,108,108,101,118,97,112,97,100,
-114,101,117,110,105,100,111,118,97,109,111,115,122,111,110,97,115,97,109,98,111,
-115,98,97,110,100,97,109,97,114,105,97,97,98,117,115,111,109,117,99,104,97,115,
-117,98,105,114,114,105,111,106,97,118,105,118,105,114,103,114,97,100,111,99,104,
-105,99,97,97,108,108,195,173,106,111,118,101,110,100,105,99,104,97,101,115,116,
-97,110,116,97,108,101,115,115,97,108,105,114,115,117,101,108,111,112,101,115,111
-,115,102,105,110,101,115,108,108,97,109,97,98,117,115,99,111,195,169,115,116,97,
-108,108,101,103,97,110,101,103,114,111,112,108,97,122,97,104,117,109,111,114,112
-,97,103,97,114,106,117,110,116,97,100,111,98,108,101,105,115,108,97,115,98,111,
-108,115,97,98,97,195,177,111,104,97,98,108,97,108,117,99,104,97,195,129,114,101,
-97,100,105,99,101,110,106,117,103,97,114,110,111,116,97,115,118,97,108,108,101,
-97,108,108,195,161,99,97,114,103,97,100,111,108,111,114,97,98,97,106,111,101,115
-,116,195,169,103,117,115,116,111,109,101,110,116,101,109,97,114,105,111,102,105,
-114,109,97,99,111,115,116,111,102,105,99,104,97,112,108,97,116,97,104,111,103,97
-,114,97,114,116,101,115,108,101,121,101,115,97,113,117,101,108,109,117,115,101,
-111,98,97,115,101,115,112,111,99,111,115,109,105,116,97,100,99,105,101,108,111,
-99,104,105,99,111,109,105,101,100,111,103,97,110,97,114,115,97,110,116,111,101,
-116,97,112,97,100,101,98,101,115,112,108,97,121,97,114,101,100,101,115,115,105,
-101,116,101,99,111,114,116,101,99,111,114,101,97,100,117,100,97,115,100,101,115,
-101,111,118,105,101,106,111,100,101,115,101,97,97,103,117,97,115,38,113,117,111,
-116,59,100,111,109,97,105,110,99,111,109,109,111,110,115,116,97,116,117,115,101,
-118,101,110,116,115,109,97,115,116,101,114,115,121,115,116,101,109,97,99,116,105
-,111,110,98,97,110,110,101,114,114,101,109,111,118,101,115,99,114,111,108,108,
-117,112,100,97,116,101,103,108,111,98,97,108,109,101,100,105,117,109,102,105,108
-,116,101,114,110,117,109,98,101,114,99,104,97,110,103,101,114,101,115,117,108,
-116,112,117,98,108,105,99,115,99,114,101,101,110,99,104,111,111,115,101,110,111,
-114,109,97,108,116,114,97,118,101,108,105,115,115,117,101,115,115,111,117,114,99
-,101,116,97,114,103,101,116,115,112,114,105,110,103,109,111,100,117,108,101,109,
-111,98,105,108,101,115,119,105,116,99,104,112,104,111,116,111,115,98,111,114,100
-,101,114,114,101,103,105,111,110,105,116,115,101,108,102,115,111,99,105,97,108,
-97,99,116,105,118,101,99,111,108,117,109,110,114,101,99,111,114,100,102,111,108,
-108,111,119,116,105,116,108,101,62,101,105,116,104,101,114,108,101,110,103,116,
-104,102,97,109,105,108,121,102,114,105,101,110,100,108,97,121,111,117,116,97,117
-,116,104,111,114,99,114,101,97,116,101,114,101,118,105,101,119,115,117,109,109,
-101,114,115,101,114,118,101,114,112,108,97,121,101,100,112,108,97,121,101,114,
-101,120,112,97,110,100,112,111,108,105,99,121,102,111,114,109,97,116,100,111,117
-,98,108,101,112,111,105,110,116,115,115,101,114,105,101,115,112,101,114,115,111,
-110,108,105,118,105,110,103,100,101,115,105,103,110,109,111,110,116,104,115,102,
-111,114,99,101,115,117,110,105,113,117,101,119,101,105,103,104,116,112,101,111,
-112,108,101,101,110,101,114,103,121,110,97,116,117,114,101,115,101,97,114,99,104
-,102,105,103,117,114,101,104,97,118,105,110,103,99,117,115,116,111,109,111,102,
-102,115,101,116,108,101,116,116,101,114,119,105,110,100,111,119,115,117,98,109,
-105,116,114,101,110,100,101,114,103,114,111,117,112,115,117,112,108,111,97,100,
-104,101,97,108,116,104,109,101,116,104,111,100,118,105,100,101,111,115,115,99,
-104,111,111,108,102,117,116,117,114,101,115,104,97,100,111,119,100,101,98,97,116
-,101,118,97,108,117,101,115,79,98,106,101,99,116,111,116,104,101,114,115,114,105
-,103,104,116,115,108,101,97,103,117,101,99,104,114,111,109,101,115,105,109,112,
-108,101,110,111,116,105,99,101,115,104,97,114,101,100,101,110,100,105,110,103,
-115,101,97,115,111,110,114,101,112,111,114,116,111,110,108,105,110,101,115,113,
-117,97,114,101,98,117,116,116,111,110,105,109,97,103,101,115,101,110,97,98,108,
-101,109,111,118,105,110,103,108,97,116,101,115,116,119,105,110,116,101,114,70,
-114,97,110,99,101,112,101,114,105,111,100,115,116,114,111,110,103,114,101,112,
-101,97,116,76,111,110,100,111,110,100,101,116,97,105,108,102,111,114,109,101,100
-,100,101,109,97,110,100,115,101,99,117,114,101,112,97,115,115,101,100,116,111,
-103,103,108,101,112,108,97,99,101,115,100,101,118,105,99,101,115,116,97,116,105,
-99,99,105,116,105,101,115,115,116,114,101,97,109,121,101,108,108,111,119,97,116,
-116,97,99,107,115,116,114,101,101,116,102,108,105,103,104,116,104,105,100,100,
-101,110,105,110,102,111,34,62,111,112,101,110,101,100,117,115,101,102,117,108,
-118,97,108,108,101,121,99,97,117,115,101,115,108,101,97,100,101,114,115,101,99,
-114,101,116,115,101,99,111,110,100,100,97,109,97,103,101,115,112,111,114,116,115
-,101,120,99,101,112,116,114,97,116,105,110,103,115,105,103,110,101,100,116,104,
-105,110,103,115,101,102,102,101,99,116,102,105,101,108,100,115,115,116,97,116,
-101,115,111,102,102,105,99,101,118,105,115,117,97,108,101,100,105,116,111,114,
-118,111,108,117,109,101,82,101,112,111,114,116,109,117,115,101,117,109,109,111,
-118,105,101,115,112,97,114,101,110,116,97,99,99,101,115,115,109,111,115,116,108,
-121,109,111,116,104,101,114,34,32,105,100,61,34,109,97,114,107,101,116,103,114,
-111,117,110,100,99,104,97,110,99,101,115,117,114,118,101,121,98,101,102,111,114,
-101,115,121,109,98,111,108,109,111,109,101,110,116,115,112,101,101,99,104,109,
-111,116,105,111,110,105,110,115,105,100,101,109,97,116,116,101,114,67,101,110,
-116,101,114,111,98,106,101,99,116,101,120,105,115,116,115,109,105,100,100,108,
-101,69,117,114,111,112,101,103,114,111,119,116,104,108,101,103,97,99,121,109,97,
-110,110,101,114,101,110,111,117,103,104,99,97,114,101,101,114,97,110,115,119,101
-,114,111,114,105,103,105,110,112,111,114,116,97,108,99,108,105,101,110,116,115,
-101,108,101,99,116,114,97,110,100,111,109,99,108,111,115,101,100,116,111,112,105
-,99,115,99,111,109,105,110,103,102,97,116,104,101,114,111,112,116,105,111,110,
-115,105,109,112,108,121,114,97,105,115,101,100,101,115,99,97,112,101,99,104,111,
-115,101,110,99,104,117,114,99,104,100,101,102,105,110,101,114,101,97,115,111,110
-,99,111,114,110,101,114,111,117,116,112,117,116,109,101,109,111,114,121,105,102,
-114,97,109,101,112,111,108,105,99,101,109,111,100,101,108,115,78,117,109,98,101,
-114,100,117,114,105,110,103,111,102,102,101,114,115,115,116,121,108,101,115,107,
-105,108,108,101,100,108,105,115,116,101,100,99,97,108,108,101,100,115,105,108,
-118,101,114,109,97,114,103,105,110,100,101,108,101,116,101,98,101,116,116,101,
-114,98,114,111,119,115,101,108,105,109,105,116,115,71,108,111,98,97,108,115,105,
-110,103,108,101,119,105,100,103,101,116,99,101,110,116,101,114,98,117,100,103,
-101,116,110,111,119,114,97,112,99,114,101,100,105,116,99,108,97,105,109,115,101,
-110,103,105,110,101,115,97,102,101,116,121,99,104,111,105,99,101,115,112,105,114
-,105,116,45,115,116,121,108,101,115,112,114,101,97,100,109,97,107,105,110,103,
-110,101,101,100,101,100,114,117,115,115,105,97,112,108,101,97,115,101,101,120,
-116,101,110,116,83,99,114,105,112,116,98,114,111,107,101,110,97,108,108,111,119,
-115,99,104,97,114,103,101,100,105,118,105,100,101,102,97,99,116,111,114,109,101,
-109,98,101,114,45,98,97,115,101,100,116,104,101,111,114,121,99,111,110,102,105,
-103,97,114,111,117,110,100,119,111,114,107,101,100,104,101,108,112,101,100,67,
-104,117,114,99,104,105,109,112,97,99,116,115,104,111,117,108,100,97,108,119,97,
-121,115,108,111,103,111,34,32,98,111,116,116,111,109,108,105,115,116,34,62,41,
-123,118,97,114,32,112,114,101,102,105,120,111,114,97,110,103,101,72,101,97,100,
-101,114,46,112,117,115,104,40,99,111,117,112,108,101,103,97,114,100,101,110,98,
-114,105,100,103,101,108,97,117,110,99,104,82,101,118,105,101,119,116,97,107,105,
-110,103,118,105,115,105,111,110,108,105,116,116,108,101,100,97,116,105,110,103,
-66,117,116,116,111,110,98,101,97,117,116,121,116,104,101,109,101,115,102,111,114
-,103,111,116,83,101,97,114,99,104,97,110,99,104,111,114,97,108,109,111,115,116,
-108,111,97,100,101,100,67,104,97,110,103,101,114,101,116,117,114,110,115,116,114
-,105,110,103,114,101,108,111,97,100,77,111,98,105,108,101,105,110,99,111,109,101
-,115,117,112,112,108,121,83,111,117,114,99,101,111,114,100,101,114,115,118,105,
-101,119,101,100,38,110,98,115,112,59,99,111,117,114,115,101,65,98,111,117,116,32
-,105,115,108,97,110,100,60,104,116,109,108,32,99,111,111,107,105,101,110,97,109,
-101,61,34,97,109,97,122,111,110,109,111,100,101,114,110,97,100,118,105,99,101,
-105,110,60,47,97,62,58,32,84,104,101,32,100,105,97,108,111,103,104,111,117,115,
-101,115,66,69,71,73,78,32,77,101,120,105,99,111,115,116,97,114,116,115,99,101,
-110,116,114,101,104,101,105,103,104,116,97,100,100,105,110,103,73,115,108,97,110
-,100,97,115,115,101,116,115,69,109,112,105,114,101,83,99,104,111,111,108,101,102
-,102,111,114,116,100,105,114,101,99,116,110,101,97,114,108,121,109,97,110,117,97
-,108,83,101,108,101,99,116,46,10,10,79,110,101,106,111,105,110,101,100,109,101,
-110,117,34,62,80,104,105,108,105,112,97,119,97,114,100,115,104,97,110,100,108,
-101,105,109,112,111,114,116,79,102,102,105,99,101,114,101,103,97,114,100,115,107
-,105,108,108,115,110,97,116,105,111,110,83,112,111,114,116,115,100,101,103,114,
-101,101,119,101,101,107,108,121,32,40,101,46,103,46,98,101,104,105,110,100,100,
-111,99,116,111,114,108,111,103,103,101,100,117,110,105,116,101,100,60,47,98,62,
-60,47,98,101,103,105,110,115,112,108,97,110,116,115,97,115,115,105,115,116,97,
-114,116,105,115,116,105,115,115,117,101,100,51,48,48,112,120,124,99,97,110,97,
-100,97,97,103,101,110,99,121,115,99,104,101,109,101,114,101,109,97,105,110,66,
-114,97,122,105,108,115,97,109,112,108,101,108,111,103,111,34,62,98,101,121,111,
-110,100,45,115,99,97,108,101,97,99,99,101,112,116,115,101,114,118,101,100,109,97
-,114,105,110,101,70,111,111,116,101,114,99,97,109,101,114,97,60,47,104,49,62,10,
-95,102,111,114,109,34,108,101,97,118,101,115,115,116,114,101,115,115,34,32,47,62
-,13,10,46,103,105,102,34,32,111,110,108,111,97,100,108,111,97,100,101,114,79,120
-,102,111,114,100,115,105,115,116,101,114,115,117,114,118,105,118,108,105,115,116
-,101,110,102,101,109,97,108,101,68,101,115,105,103,110,115,105,122,101,61,34,97,
-112,112,101,97,108,116,101,120,116,34,62,108,101,118,101,108,115,116,104,97,110,
-107,115,104,105,103,104,101,114,102,111,114,99,101,100,97,110,105,109,97,108,97,
-110,121,111,110,101,65,102,114,105,99,97,97,103,114,101,101,100,114,101,99,101,
-110,116,80,101,111,112,108,101,60,98,114,32,47,62,119,111,110,100,101,114,112,
-114,105,99,101,115,116,117,114,110,101,100,124,124,32,123,125,59,109,97,105,110,
-34,62,105,110,108,105,110,101,115,117,110,100,97,121,119,114,97,112,34,62,102,97
-,105,108,101,100,99,101,110,115,117,115,109,105,110,117,116,101,98,101,97,99,111
-,110,113,117,111,116,101,115,49,53,48,112,120,124,101,115,116,97,116,101,114,101
-,109,111,116,101,101,109,97,105,108,34,108,105,110,107,101,100,114,105,103,104,
-116,59,115,105,103,110,97,108,102,111,114,109,97,108,49,46,104,116,109,108,115,
-105,103,110,117,112,112,114,105,110,99,101,102,108,111,97,116,58,46,112,110,103,
-34,32,102,111,114,117,109,46,65,99,99,101,115,115,112,97,112,101,114,115,115,111
-,117,110,100,115,101,120,116,101,110,100,72,101,105,103,104,116,115,108,105,100,
-101,114,85,84,70,45,56,34,38,97,109,112,59,32,66,101,102,111,114,101,46,32,87,
-105,116,104,115,116,117,100,105,111,111,119,110,101,114,115,109,97,110,97,103,
-101,112,114,111,102,105,116,106,81,117,101,114,121,97,110,110,117,97,108,112,97,
-114,97,109,115,98,111,117,103,104,116,102,97,109,111,117,115,103,111,111,103,108
-,101,108,111,110,103,101,114,105,43,43,41,32,123,105,115,114,97,101,108,115,97,
-121,105,110,103,100,101,99,105,100,101,104,111,109,101,34,62,104,101,97,100,101,
-114,101,110,115,117,114,101,98,114,97,110,99,104,112,105,101,99,101,115,98,108,
-111,99,107,59,115,116,97,116,101,100,116,111,112,34,62,60,114,97,99,105,110,103,
-114,101,115,105,122,101,45,45,38,103,116,59,112,97,99,105,116,121,115,101,120,
-117,97,108,98,117,114,101,97,117,46,106,112,103,34,32,49,48,44,48,48,48,111,98,
-116,97,105,110,116,105,116,108,101,115,97,109,111,117,110,116,44,32,73,110,99,46
-,99,111,109,101,100,121,109,101,110,117,34,32,108,121,114,105,99,115,116,111,100
-,97,121,46,105,110,100,101,101,100,99,111,117,110,116,121,95,108,111,103,111,46,
-70,97,109,105,108,121,108,111,111,107,101,100,77,97,114,107,101,116,108,115,101,
-32,105,102,80,108,97,121,101,114,116,117,114,107,101,121,41,59,118,97,114,32,102
-,111,114,101,115,116,103,105,118,105,110,103,101,114,114,111,114,115,68,111,109,
-97,105,110,125,101,108,115,101,123,105,110,115,101,114,116,66,108,111,103,60,47,
-102,111,111,116,101,114,108,111,103,105,110,46,102,97,115,116,101,114,97,103,101
-,110,116,115,60,98,111,100,121,32,49,48,112,120,32,48,112,114,97,103,109,97,102,
-114,105,100,97,121,106,117,110,105,111,114,100,111,108,108,97,114,112,108,97,99,
-101,100,99,111,118,101,114,115,112,108,117,103,105,110,53,44,48,48,48,32,112,97,
-103,101,34,62,98,111,115,116,111,110,46,116,101,115,116,40,97,118,97,116,97,114,
-116,101,115,116,101,100,95,99,111,117,110,116,102,111,114,117,109,115,115,99,104
-,101,109,97,105,110,100,101,120,44,102,105,108,108,101,100,115,104,97,114,101,
-115,114,101,97,100,101,114,97,108,101,114,116,40,97,112,112,101,97,114,83,117,98
-,109,105,116,108,105,110,101,34,62,98,111,100,121,34,62,10,42,32,84,104,101,84,
-104,111,117,103,104,115,101,101,105,110,103,106,101,114,115,101,121,78,101,119,
-115,60,47,118,101,114,105,102,121,101,120,112,101,114,116,105,110,106,117,114,
-121,119,105,100,116,104,61,67,111,111,107,105,101,83,84,65,82,84,32,97,99,114,
-111,115,115,95,105,109,97,103,101,116,104,114,101,97,100,110,97,116,105,118,101,
-112,111,99,107,101,116,98,111,120,34,62,10,83,121,115,116,101,109,32,68,97,118,
-105,100,99,97,110,99,101,114,116,97,98,108,101,115,112,114,111,118,101,100,65,
-112,114,105,108,32,114,101,97,108,108,121,100,114,105,118,101,114,105,116,101,
-109,34,62,109,111,114,101,34,62,98,111,97,114,100,115,99,111,108,111,114,115,99,
-97,109,112,117,115,102,105,114,115,116,32,124,124,32,91,93,59,109,101,100,105,97
-,46,103,117,105,116,97,114,102,105,110,105,115,104,119,105,100,116,104,58,115,
-104,111,119,101,100,79,116,104,101,114,32,46,112,104,112,34,32,97,115,115,117,
-109,101,108,97,121,101,114,115,119,105,108,115,111,110,115,116,111,114,101,115,
-114,101,108,105,101,102,115,119,101,100,101,110,67,117,115,116,111,109,101,97,
-115,105,108,121,32,121,111,117,114,32,83,116,114,105,110,103,10,10,87,104,105,
-108,116,97,121,108,111,114,99,108,101,97,114,58,114,101,115,111,114,116,102,114,
-101,110,99,104,116,104,111,117,103,104,34,41,32,43,32,34,60,98,111,100,121,62,98
-,117,121,105,110,103,98,114,97,110,100,115,77,101,109,98,101,114,110,97,109,101,
-34,62,111,112,112,105,110,103,115,101,99,116,111,114,53,112,120,59,34,62,118,115
-,112,97,99,101,112,111,115,116,101,114,109,97,106,111,114,32,99,111,102,102,101,
-101,109,97,114,116,105,110,109,97,116,117,114,101,104,97,112,112,101,110,60,47,
-110,97,118,62,107,97,110,115,97,115,108,105,110,107,34,62,73,109,97,103,101,115,
-61,102,97,108,115,101,119,104,105,108,101,32,104,115,112,97,99,101,48,38,97,109,
-112,59,32,10,10,73,110,32,32,112,111,119,101,114,80,111,108,115,107,105,45,99,
-111,108,111,114,106,111,114,100,97,110,66,111,116,116,111,109,83,116,97,114,116,
-32,45,99,111,117,110,116,50,46,104,116,109,108,110,101,119,115,34,62,48,49,46,
-106,112,103,79,110,108,105,110,101,45,114,105,103,104,116,109,105,108,108,101,
-114,115,101,110,105,111,114,73,83,66,78,32,48,48,44,48,48,48,32,103,117,105,100,
-101,115,118,97,108,117,101,41,101,99,116,105,111,110,114,101,112,97,105,114,46,
-120,109,108,34,32,32,114,105,103,104,116,115,46,104,116,109,108,45,98,108,111,99
-,107,114,101,103,69,120,112,58,104,111,118,101,114,119,105,116,104,105,110,118,
-105,114,103,105,110,112,104,111,110,101,115,60,47,116,114,62,13,117,115,105,110,
-103,32,10,9,118,97,114,32,62,39,41,59,10,9,60,47,116,100,62,10,60,47,116,114,62,
-10,98,97,104,97,115,97,98,114,97,115,105,108,103,97,108,101,103,111,109,97,103,
-121,97,114,112,111,108,115,107,105,115,114,112,115,107,105,216,177,216,175,217,
-136,228,184,173,230,150,135,231,174,128,228,189,147,231,185,129,233,171,148,228,
-191,161,230,129,175,228,184,173,229,155,189,230,136,145,228,187,172,228,184,128,
-228,184,170,229,133,172,229,143,184,231,174,161,231,144,134,232,174,186,229,157,
-155,229,143,175,228,187,165,230,156,141,229,138,161,230,151,182,233,151,180,228,
-184,170,228,186,186,228,186,167,229,147,129,232,135,170,229,183,177,228,188,129,
-228,184,154,230,159,165,231,156,139,229,183,165,228,189,156,232,129,148,231,179,
-187,230,178,161,230,156,137,231,189,145,231,171,153,230,137,128,230,156,137,232,
-175,132,232,174,186,228,184,173,229,191,131,230,150,135,231,171,160,231,148,168,
-230,136,183,233,166,150,233,161,181,228,189,156,232,128,133,230,138,128,230,156,
-175,233,151,174,233,162,152,231,155,184,229,133,179,228,184,139,232,189,189,230,
-144,156,231,180,162,228,189,191,231,148,168,232,189,175,228,187,182,229,156,168,
-231,186,191,228,184,187,233,162,152,232,181,132,230,150,153,232,167,134,233,162,
-145,229,155,158,229,164,141,230,179,168,229,134,140,231,189,145,231,187,156,230,
-148,182,232,151,143,229,134,133,229,174,185,230,142,168,232,141,144,229,184,130,
-229,156,186,230,182,136,230,129,175,231,169,186,233,151,180,229,143,145,229,184,
-131,228,187,128,228,185,136,229,165,189,229,143,139,231,148,159,230,180,187,229,
-155,190,231,137,135,229,143,145,229,177,149,229,166,130,230,158,156,230,137,139,
-230,156,186,230,150,176,233,151,187,230,156,128,230,150,176,230,150,185,229,188,
-143,229,140,151,228,186,172,230,143,144,228,190,155,229,133,179,228,186,142,230,
-155,180,229,164,154,232,191,153,228,184,170,231,179,187,231,187,159,231,159,165,
-233,129,147,230,184,184,230,136,143,229,185,191,229,145,138,229,133,182,228,187,
-150,229,143,145,232,161,168,229,174,137,229,133,168,231,172,172,228,184,128,228,
-188,154,229,145,152,232,191,155,232,161,140,231,130,185,229,135,187,231,137,136,
-230,157,131,231,148,181,229,173,144,228,184,150,231,149,140,232,174,190,232,174,
-161,229,133,141,232,180,185,230,149,153,232,130,178,229,138,160,229,133,165,230,
-180,187,229,138,168,228,187,150,228,187,172,229,149,134,229,147,129,229,141,154,
-229,174,162,231,142,176,229,156,168,228,184,138,230,181,183,229,166,130,228,189,
-149,229,183,178,231,187,143,231,149,153,232,168,128,232,175,166,231,187,134,231,
-164,190,229,140,186,231,153,187,229,189,149,230,156,172,231,171,153,233,156,128,
-232,166,129,228,187,183,230,160,188,230,148,175,230,140,129,229,155,189,233,153,
-133,233,147,190,230,142,165,229,155,189,229,174,182,229,187,186,232,174,190,230,
-156,139,229,143,139,233,152,133,232,175,187,230,179,149,229,190,139,228,189,141,
-231,189,174,231,187,143,230,181,142,233,128,137,230,139,169,232,191,153,230,160,
-183,229,189,147,229,137,141,229,136,134,231,177,187,230,142,146,232,161,140,229,
-155,160,228,184,186,228,186,164,230,152,147,230,156,128,229,144,142,233,159,179,
-228,185,144,228,184,141,232,131,189,233,128,154,232,191,135,232,161,140,228,184,
-154,231,167,145,230,138,128,229,143,175,232,131,189,232,174,190,229,164,135,229,
-144,136,228,189,156,229,164,167,229,174,182,231,164,190,228,188,154,231,160,148,
-231,169,182,228,184,147,228,184,154,229,133,168,233,131,168,233,161,185,231,155,
-174,232,191,153,233,135,140,232,191,152,230,152,175,229,188,128,229,167,139,230,
-131,133,229,134,181,231,148,181,232,132,145,230,150,135,228,187,182,229,147,129,
-231,137,140,229,184,174,229,138,169,230,150,135,229,140,150,232,181,132,230,186,
-144,229,164,167,229,173,166,229,173,166,228,185,160,229,156,176,229,157,128,230,
-181,143,232,167,136,230,138,149,232,181,132,229,183,165,231,168,139,232,166,129,
-230,177,130,230,128,142,228,185,136,230,151,182,229,128,153,229,138,159,232,131,
-189,228,184,187,232,166,129,231,155,174,229,137,141,232,181,132,232,174,175,229,
-159,142,229,184,130,230,150,185,230,179,149,231,148,181,229,189,177,230,139,155,
-232,129,152,229,163,176,230,152,142,228,187,187,228,189,149,229,129,165,229,186,
-183,230,149,176,230,141,174,231,190,142,229,155,189,230,177,189,232,189,166,228,
-187,139,231,187,141,228,189,134,230,152,175,228,186,164,230,181,129,231,148,159,
-228,186,167,230,137,128,228,187,165,231,148,181,232,175,157,230,152,190,231,164,
-186,228,184,128,228,186,155,229,141,149,228,189,141,228,186,186,229,145,152,229,
-136,134,230,158,144,229,156,176,229,155,190,230,151,133,230,184,184,229,183,165,
-229,133,183,229,173,166,231,148,159,231,179,187,229,136,151,231,189,145,229,143,
-139,229,184,150,229,173,144,229,175,134,231,160,129,233,162,145,233,129,147,230,
-142,167,229,136,182,229,156,176,229,140,186,229,159,186,230,156,172,229,133,168,
-229,155,189,231,189,145,228,184,138,233,135,141,232,166,129,231,172,172,228,186,
-140,229,150,156,230,172,162,232,191,155,229,133,165,229,143,139,230,131,133,232,
-191,153,228,186,155,232,128,131,232,175,149,229,143,145,231,142,176,229,159,185,
-232,174,173,228,187,165,228,184,138,230,148,191,229,186,156,230,136,144,228,184,
-186,231,142,175,229,162,131,233,166,153,230,184,175,229,144,140,230,151,182,229,
-168,177,228,185,144,229,143,145,233,128,129,228,184,128,229,174,154,229,188,128,
-229,143,145,228,189,156,229,147,129,230,160,135,229,135,134,230,172,162,232,191,
-142,232,167,163,229,134,179,229,156,176,230,150,185,228,184,128,228,184,139,228,
-187,165,229,143,138,232,180,163,228,187,187,230,136,150,232,128,133,229,174,162,
-230,136,183,228,187,163,232,161,168,231,167,175,229,136,134,229,165,179,228,186,
-186,230,149,176,231,160,129,233,148,128,229,148,174,229,135,186,231,142,176,231,
-166,187,231,186,191,229,186,148,231,148,168,229,136,151,232,161,168,228,184,141,
-229,144,140,231,188,150,232,190,145,231,187,159,232,174,161,230,159,165,232,175,
-162,228,184,141,232,166,129,230,156,137,229,133,179,230,156,186,230,158,132,229,
-190,136,229,164,154,230,146,173,230,148,190,231,187,132,231,187,135,230,148,191,
-231,173,150,231,155,180,230,142,165,232,131,189,229,138,155,230,157,165,230,186,
-144,230,153,130,233,150,147,231,156,139,229,136,176,231,131,173,233,151,168,229,
-133,179,233,148,174,228,184,147,229,140,186,233,157,158,229,184,184,232,139,177,
-232,175,173,231,153,190,229,186,166,229,184,140,230,156,155,231,190,142,229,165,
-179,230,175,148,232,190,131,231,159,165,232,175,134,232,167,132,229,174,154,229,
-187,186,232,174,174,233,131,168,233,151,168,230,132,143,232,167,129,231,178,190,
-229,189,169,230,151,165,230,156,172,230,143,144,233,171,152,229,143,145,232,168,
-128,230,150,185,233,157,162,229,159,186,233,135,145,229,164,132,231,144,134,230,
-157,131,233,153,144,229,189,177,231,137,135,233,147,182,232,161,140,232,191,152,
-230,156,137,229,136,134,228,186,171,231,137,169,229,147,129,231,187,143,232,144,
-165,230,183,187,229,138,160,228,184,147,229,174,182,232,191,153,231,167,141,232,
-175,157,233,162,152,232,181,183,230,157,165,228,184,154,229,138,161,229,133,172,
-229,145,138,232,174,176,229,189,149,231,174,128,228,187,139,232,180,168,233,135,
-143,231,148,183,228,186,186,229,189,177,229,147,141,229,188,149,231,148,168,230,
-138,165,229,145,138,233,131,168,229,136,134,229,191,171,233,128,159,229,146,168,
-232,175,162,230,151,182,229,176,154,230,179,168,230,132,143,231,148,179,232,175,
-183,229,173,166,230,160,161,229,186,148,232,175,165,229,142,134,229,143,178,229,
-143,170,230,152,175,232,191,148,229,155,158,232,180,173,228,185,176,229,144,141,
-231,167,176,228,184,186,228,186,134,230,136,144,229,138,159,232,175,180,230,152,
-142,228,190,155,229,186,148,229,173,169,229,173,144,228,184,147,233,162,152,231,
-168,139,229,186,143,228,184,128,232,136,172,230,156,131,229,147,161,229,143,170,
-230,156,137,229,133,182,229,174,131,228,191,157,230,138,164,232,128,140,228,184,
-148,228,187,138,229,164,169,231,170,151,229,143,163,229,138,168,230,128,129,231,
-138,182,230,128,129,231,137,185,229,136,171,232,174,164,228,184,186,229,191,133,
-233,161,187,230,155,180,230,150,176,229,176,143,232,175,180,230,136,145,229,128,
-145,228,189,156,228,184,186,229,170,146,228,189,147,229,140,133,230,139,172,233,
-130,163,228,185,136,228,184,128,230,160,183,229,155,189,229,134,133,230,152,175,
-229,144,166,230,160,185,230,141,174,231,148,181,232,167,134,229,173,166,233,153,
-162,229,133,183,230,156,137,232,191,135,231,168,139,231,148,177,228,186,142,228,
-186,186,230,137,141,229,135,186,230,157,165,228,184,141,232,191,135,230,173,163,
-229,156,168,230,152,142,230,152,159,230,149,133,228,186,139,229,133,179,231,179,
-187,230,160,135,233,162,152,229,149,134,229,138,161,232,190,147,229,133,165,228,
-184,128,231,155,180,229,159,186,231,161,128,230,149,153,229,173,166,228,186,134,
-232,167,163,229,187,186,231,173,145,231,187,147,230,158,156,229,133,168,231,144,
-131,233,128,154,231,159,165,232,174,161,229,136,146,229,175,185,228,186,142,232,
-137,186,230,156,175,231,155,184,229,134,140,229,143,145,231,148,159,231,156,159,
-231,154,132,229,187,186,231,171,139,231,173,137,231,186,167,231,177,187,229,158,
-139,231,187,143,233,170,140,229,174,158,231,142,176,229,136,182,228,189,156,230,
-157,165,232,135,170,230,160,135,231,173,190,228,187,165,228,184,139,229,142,159,
-229,136,155,230,151,160,230,179,149,229,133,182,228,184,173,229,128,139,228,186,
-186,228,184,128,229,136,135,230,140,135,229,141,151,229,133,179,233,151,173,233,
-155,134,229,155,162,231,172,172,228,184,137,229,133,179,230,179,168,229,155,160,
-230,173,164,231,133,167,231,137,135,230,183,177,229,156,179,229,149,134,228,184,
-154,229,185,191,229,183,158,230,151,165,230,156,159,233,171,152,231,186,167,230,
-156,128,232,191,145,231,187,188,229,144,136,232,161,168,231,164,186,228,184,147,
-232,190,145,232,161,140,228,184,186,228,186,164,233,128,154,232,175,132,228,187,
-183,232,167,137,229,190,151,231,178,190,229,141,142,229,174,182,229,186,173,229,
-174,140,230,136,144,230,132,159,232,167,137,229,174,137,232,163,133,229,190,151,
-229,136,176,233,130,174,228,187,182,229,136,182,229,186,166,233,163,159,229,147,
-129,232,153,189,231,132,182,232,189,172,232,189,189,230,138,165,228,187,183,232,
-174,176,232,128,133,230,150,185,230,161,136,232,161,140,230,148,191,228,186,186,
-230,176,145,231,148,168,229,147,129,228,184,156,232,165,191,230,143,144,229,135,
-186,233,133,146,229,186,151,231,132,182,229,144,142,228,187,152,230,172,190,231,
-131,173,231,130,185,228,187,165,229,137,141,229,174,140,229,133,168,229,143,145,
-229,184,150,232,174,190,231,189,174,233,162,134,229,175,188,229,183,165,228,184,
-154,229,140,187,233,153,162,231,156,139,231,156,139,231,187,143,229,133,184,229,
-142,159,229,155,160,229,185,179,229,143,176,229,144,132,231,167,141,229,162,158,
-229,138,160,230,157,144,230,150,153,230,150,176,229,162,158,228,185,139,229,144,
-142,232,129,140,228,184,154,230,149,136,230,158,156,228,187,138,229,185,180,232,
-174,186,230,150,135,230,136,145,229,155,189,229,145,138,232,175,137,231,137,136,
-228,184,187,228,191,174,230,148,185,229,143,130,228,184,142,230,137,147,229,141,
-176,229,191,171,228,185,144,230,156,186,230,162,176,232,167,130,231,130,185,229,
-173,152,229,156,168,231,178,190,231,165,158,232,142,183,229,190,151,229,136,169,
-231,148,168,231,187,167,231,187,173,228,189,160,228,187,172,232,191,153,228,185,
-136,230,168,161,229,188,143,232,175,173,232,168,128,232,131,189,229,164,159,233,
-155,133,232,153,142,230,147,141,228,189,156,233,163,142,230,160,188,228,184,128,
-232,181,183,231,167,145,229,173,166,228,189,147,232,130,178,231,159,173,228,191,
-161,230,157,161,228,187,182,230,178,187,231,150,151,232,191,144,229,138,168,228,
-186,167,228,184,154,228,188,154,232,174,174,229,175,188,232,136,170,229,133,136,
-231,148,159,232,129,148,231,155,159,229,143,175,230,152,175,229,149,143,233,161,
-140,231,187,147,230,158,132,228,189,156,231,148,168,232,176,131,230,159,165,232,
-179,135,230,150,153,232,135,170,229,138,168,232,180,159,232,180,163,229,134,156,
-228,184,154,232,174,191,233,151,174,229,174,158,230,150,189,230,142,165,229,143,
-151,232,174,168,232,174,186,233,130,163,228,184,170,229,143,141,233,166,136,229,
-138,160,229,188,186,229,165,179,230,128,167,232,140,131,229,155,180,230,156,141,
-229,139,153,228,188,145,233,151,178,228,187,138,230,151,165,229,174,162,230,156,
-141,232,167,128,231,156,139,229,143,130,229,138,160,231,154,132,232,175,157,228,
-184,128,231,130,185,228,191,157,232,175,129,229,155,190,228,185,166,230,156,137,
-230,149,136,230,181,139,232,175,149,231,167,187,229,138,168,230,137,141,232,131,
-189,229,134,179,229,174,154,232,130,161,231,165,168,228,184,141,230,150,173,233,
-156,128,230,177,130,228,184,141,229,190,151,229,138,158,230,179,149,228,185,139,
-233,151,180,233,135,135,231,148,168,232,144,165,233,148,128,230,138,149,232,175,
-137,231,155,174,230,160,135,231,136,177,230,131,133,230,145,132,229,189,177,230,
-156,137,228,186,155,232,164,135,232,163,189,230,150,135,229,173,166,230,156,186,
-228,188,154,230,149,176,229,173,151,232,163,133,228,191,174,232,180,173,231,137,
-169,229,134,156,230,157,145,229,133,168,233,157,162,231,178,190,229,147,129,229,
-133,182,229,174,158,228,186,139,230,131,133,230,176,180,229,185,179,230,143,144,
-231,164,186,228,184,138,229,184,130,232,176,162,232,176,162,230,153,174,233,128,
-154,230,149,153,229,184,136,228,184,138,228,188,160,231,177,187,229,136,171,230,
-173,140,230,155,178,230,139,165,230,156,137,229,136,155,230,150,176,233,133,141,
-228,187,182,229,143,170,232,166,129,230,151,182,228,187,163,232,179,135,232,168,
-138,232,190,190,229,136,176,228,186,186,231,148,159,232,174,162,233,152,133,232,
-128,129,229,184,136,229,177,149,231,164,186,229,191,131,231,144,134,232,180,180,
-229,173,144,231,182,178,231,171,153,228,184,187,233,161,140,232,135,170,231,132,
-182,231,186,167,229,136,171,231,174,128,229,141,149,230,148,185,233,157,169,233,
-130,163,228,186,155,230,157,165,232,175,180,230,137,147,229,188,128,228,187,163,
-231,160,129,229,136,160,233,153,164,232,175,129,229,136,184,232,138,130,231,155,
-174,233,135,141,231,130,185,230,172,161,230,149,184,229,164,154,229,176,145,232,
-167,132,229,136,146,232,181,132,233,135,145,230,137,190,229,136,176,228,187,165,
-229,144,142,229,164,167,229,133,168,228,184,187,233,161,181,230,156,128,228,189,
-179,229,155,158,231,173,148,229,164,169,228,184,139,228,191,157,233,154,156,231,
-142,176,228,187,163,230,163,128,230,159,165,230,138,149,231,165,168,229,176,143,
-230,151,182,230,178,146,230,156,137,230,173,163,229,184,184,231,148,154,232,135,
-179,228,187,163,231,144,134,231,155,174,229,189,149,229,133,172,229,188,128,229,
-164,141,229,136,182,233,135,145,232,158,141,229,185,184,231,166,143,231,137,136,
-230,156,172,229,189,162,230,136,144,229,135,134,229,164,135,232,161,140,230,131,
-133,229,155,158,229,136,176,230,128,157,230,131,179,230,128,142,230,160,183,229,
-141,143,232,174,174,232,174,164,232,175,129,230,156,128,229,165,189,228,186,167,
-231,148,159,230,140,137,231,133,167,230,156,141,232,163,133,229,185,191,228,184,
-156,229,138,168,230,188,171,233,135,135,232,180,173,230,150,176,230,137,139,231,
-187,132,229,155,190,233,157,162,230,157,191,229,143,130,232,128,131,230,148,191,
-230,178,187,229,174,185,230,152,147,229,164,169,229,156,176,229,138,170,229,138,
-155,228,186,186,228,187,172,229,141,135,231,186,167,233,128,159,229,186,166,228,
-186,186,231,137,169,232,176,131,230,149,180,230,181,129,232,161,140,233,128,160,
-230,136,144,230,150,135,229,173,151,233,159,169,229,155,189,232,180,184,230,152,
-147,229,188,128,229,177,149,231,155,184,233,151,156,232,161,168,231,142,176,229,
-189,177,232,167,134,229,166,130,230,173,164,231,190,142,229,174,185,229,164,167,
-229,176,143,230,138,165,233,129,147,230,157,161,230,172,190,229,191,131,230,131,
-133,232,174,184,229,164,154,230,179,149,232,167,132,229,174,182,229,177,133,228,
-185,166,229,186,151,232,191,158,230,142,165,231,171,139,229,141,179,228,184,190,
-230,138,165,230,138,128,229,183,167,229,165,165,232,191,144,231,153,187,229,133,
-165,228,187,165,230,157,165,231,144,134,232,174,186,228,186,139,228,187,182,232,
-135,170,231,148,177,228,184,173,229,141,142,229,138,158,229,133,172,229,166,136,
-229,166,136,231,156,159,230,173,163,228,184,141,233,148,153,229,133,168,230,150,
-135,229,144,136,229,144,140,228,187,183,229,128,188,229,136,171,228,186,186,231,
-155,145,231,157,163,229,133,183,228,189,147,228,184,150,231,186,170,229,155,162,
-233,152,159,229,136,155,228,184,154,230,137,191,230,139,133,229,162,158,233,149,
-191,230,156,137,228,186,186,228,191,157,230,140,129,229,149,134,229,174,182,231,
-187,180,228,191,174,229,143,176,230,185,190,229,183,166,229,143,179,232,130,161,
-228,187,189,231,173,148,230,161,136,229,174,158,233,153,133,231,148,181,228,191,
-161,231,187,143,231,144,134,231,148,159,229,145,189,229,174,163,228,188,160,228,
-187,187,229,138,161,230,173,163,229,188,143,231,137,185,232,137,178,228,184,139,
-230,157,165,229,141,143,228,188,154,229,143,170,232,131,189,229,189,147,231,132,
-182,233,135,141,230,150,176,229,133,167,229,174,185,230,140,135,229,175,188,232,
-191,144,232,161,140,230,151,165,229,191,151,232,179,163,229,174,182,232,182,133,
-232,191,135,229,156,159,229,156,176,230,181,153,230,177,159,230,148,175,228,187,
-152,230,142,168,229,135,186,231,171,153,233,149,191,230,157,173,229,183,158,230,
-137,167,232,161,140,229,136,182,233,128,160,228,185,139,228,184,128,230,142,168,
-229,185,191,231,142,176,229,156,186,230,143,143,232,191,176,229,143,152,229,140,
-150,228,188,160,231,187,159,230,173,140,230,137,139,228,191,157,233,153,169,232,
-175,190,231,168,139,229,140,187,231,150,151,231,187,143,232,191,135,232,191,135,
-229,142,187,228,185,139,229,137,141,230,148,182,229,133,165,229,185,180,229,186,
-166,230,157,130,229,191,151,231,190,142,228,184,189,230,156,128,233,171,152,231,
-153,187,233,153,134,230,156,170,230,157,165,229,138,160,229,183,165,229,133,141,
-232,180,163,230,149,153,231,168,139,231,137,136,229,157,151,232,186,171,228,189,
-147,233,135,141,229,186,134,229,135,186,229,148,174,230,136,144,230,156,172,229,
-189,162,229,188,143,229,156,159,232,177,134,229,135,186,229,131,185,228,184,156,
-230,150,185,233,130,174,231,174,177,229,141,151,228,186,172,230,177,130,232,129,
-140,229,143,150,229,190,151,232,129,140,228,189,141,231,155,184,228,191,161,233,
-161,181,233,157,162,229,136,134,233,146,159,231,189,145,233,161,181,231,161,174,
-229,174,154,229,155,190,228,190,139,231,189,145,229,157,128,231,167,175,230,158,
-129,233,148,153,232,175,175,231,155,174,231,154,132,229,174,157,232,180,157,230,
-156,186,229,133,179,233,163,142,233,153,169,230,142,136,230,157,131,231,151,133,
-230,175,146,229,174,160,231,137,169,233,153,164,228,186,134,232,169,149,232,171,
-150,231,150,190,231,151,133,229,143,138,230,151,182,230,177,130,232,180,173,231,
-171,153,231,130,185,229,132,191,231,171,165,230,175,143,229,164,169,228,184,173,
-229,164,174,232,174,164,232,175,134,230,175,143,228,184,170,229,164,169,230,180,
-165,229,173,151,228,189,147,229,143,176,231,129,163,231,187,180,230,138,164,230,
-156,172,233,161,181,228,184,170,230,128,167,229,174,152,230,150,185,229,184,184,
-232,167,129,231,155,184,230,156,186,230,136,152,231,149,165,229,186,148,229,189,
-147,229,190,139,229,184,136,230,150,185,228,190,191,230,160,161,229,155,173,232,
-130,161,229,184,130,230,136,191,229,177,139,230,160,143,231,155,174,229,145,152,
-229,183,165,229,175,188,232,135,180,231,170,129,231,132,182,233,129,147,229,133,
-183,230,156,172,231,189,145,231,187,147,229,144,136,230,161,163,230,161,136,229,
-138,179,229,138,168,229,143,166,229,164,150,231,190,142,229,133,131,229,188,149,
-232,181,183,230,148,185,229,143,152,231,172,172,229,155,155,228,188,154,232,174,
-161,232,170,170,230,152,142,233,154,144,231,167,129,229,174,157,229,174,157,232,
-167,132,232,140,131,230,182,136,232,180,185,229,133,177,229,144,140,229,191,152,
-232,174,176,228,189,147,231,179,187,229,184,166,230,157,165,229,144,141,229,173,
-151,231,153,188,232,161,168,229,188,128,230,148,190,229,138,160,231,155,159,229,
-143,151,229,136,176,228,186,140,230,137,139,229,164,167,233,135,143,230,136,144,
-228,186,186,230,149,176,233,135,143,229,133,177,228,186,171,229,140,186,229,159,
-159,229,165,179,229,173,169,229,142,159,229,136,153,230,137,128,229,156,168,231,
-187,147,230,157,159,233,128,154,228,191,161,232,182,133,231,186,167,233,133,141,
-231,189,174,229,189,147,230,151,182,228,188,152,231,167,128,230,128,167,230,132,
-159,230,136,191,228,186,167,233,129,138,230,136,178,229,135,186,229,143,163,230,
-143,144,228,186,164,229,176,177,228,184,154,228,191,157,229,129,165,231,168,139,
-229,186,166,229,143,130,230,149,176,228,186,139,228,184,154,230,149,180,228,184,
-170,229,177,177,228,184,156,230,131,133,230,132,159,231,137,185,230,174,138,229,
-136,134,233,161,158,230,144,156,229,176,139,229,177,158,228,186,142,233,151,168,
-230,136,183,232,180,162,229,138,161,229,163,176,233,159,179,229,143,138,229,133,
-182,232,180,162,231,187,143,229,157,154,230,140,129,229,185,178,233,131,168,230,
-136,144,231,171,139,229,136,169,231,155,138,232,128,131,232,153,145,230,136,144,
-233,131,189,229,140,133,232,163,133,231,148,168,230,136,182,230,175,148,232,181,
-155,230,150,135,230,152,142,230,139,155,229,149,134,229,174,140,230,149,180,231,
-156,159,230,152,175,231,156,188,231,157,155,228,188,153,228,188,180,229,168,129,
-230,156,155,233,162,134,229,159,159,229,141,171,231,148,159,228,188,152,230,131,
-160,232,171,150,229,163,135,229,133,172,229,133,177,232,137,175,229,165,189,229,
-133,133,229,136,134,231,172,166,229,144,136,233,153,132,228,187,182,231,137,185,
-231,130,185,228,184,141,229,143,175,232,139,177,230,150,135,232,181,132,228,186,
-167,230,160,185,230,156,172,230,152,142,230,152,190,229,175,134,231,162,188,229,
-133,172,228,188,151,230,176,145,230,151,143,230,155,180,229,138,160,228,186,171,
-229,143,151,229,144,140,229,173,166,229,144,175,229,138,168,233,128,130,229,144,
-136,229,142,159,230,157,165,233,151,174,231,173,148,230,156,172,230,150,135,231,
-190,142,233,163,159,231,187,191,232,137,178,231,168,179,229,174,154,231,187,136,
-228,186,142,231,148,159,231,137,169,228,190,155,230,177,130,230,144,156,231,139,
-144,229,138,155,233,135,143,228,184,165,233,135,141,230,176,184,232,191,156,229,
-134,153,231,156,159,230,156,137,233,153,144,231,171,158,228,186,137,229,175,185,
-232,177,161,232,180,185,231,148,168,228,184,141,229,165,189,231,187,157,229,175,
-185,229,141,129,229,136,134,228,191,131,232,191,155,231,130,185,232,175,132,229,
-189,177,233,159,179,228,188,152,229,138,191,228,184,141,229,176,145,230,172,163,
-232,181,143,229,185,182,228,184,148,230,156,137,231,130,185,230,150,185,229,144,
-145,229,133,168,230,150,176,228,191,161,231,148,168,232,174,190,230,150,189,229,
-189,162,232,177,161,232,181,132,230,160,188,231,170,129,231,160,180,233,154,143,
-231,157,128,233,135,141,229,164,167,228,186,142,230,152,175,230,175,149,228,184,
-154,230,153,186,232,131,189,229,140,150,229,183,165,229,174,140,231,190,142,229,
-149,134,229,159,142,231,187,159,228,184,128,229,135,186,231,137,136,230,137,147,
-233,128,160,231,148,162,229,147,129,230,166,130,229,134,181,231,148,168,228,186,
-142,228,191,157,231,149,153,229,155,160,231,180,160,228,184,173,229,156,139,229,
-173,152,229,130,168,232,180,180,229,155,190,230,156,128,230,132,155,233,149,191,
-230,156,159,229,143,163,228,187,183,231,144,134,232,180,162,229,159,186,229,156,
-176,229,174,137,230,142,146,230,173,166,230,177,137,233,135,140,233,157,162,229,
-136,155,229,187,186,229,164,169,231,169,186,233,166,150,229,133,136,229,174,140,
-229,150,132,233,169,177,229,138,168,228,184,139,233,157,162,228,184,141,229,134,
-141,232,175,154,228,191,161,230,132,143,228,185,137,233,152,179,229,133,137,232,
-139,177,229,155,189,230,188,130,228,186,174,229,134,155,228,186,139,231,142,169,
-229,174,182,231,190,164,228,188,151,229,134,156,230,176,145,229,141,179,229,143,
-175,229,144,141,231,168,177,229,174,182,229,133,183,229,138,168,231,148,187,230,
-131,179,229,136,176,230,179,168,230,152,142,229,176,143,229,173,166,230,128,167,
-232,131,189,232,128,131,231,160,148,231,161,172,228,187,182,232,167,130,231,156,
-139,230,184,133,230,165,154,230,144,158,231,172,145,233,166,150,233,160,129,233,
-187,132,233,135,145,233,128,130,231,148,168,230,177,159,232,139,143,231,156,159,
-229,174,158,228,184,187,231,174,161,233,152,182,230,174,181,232,168,187,229,134,
-138,231,191,187,232,175,145,230,157,131,229,136,169,229,129,154,229,165,189,228,
-188,188,228,185,142,233,128,154,232,174,175,230,150,189,229,183,165,231,139,128,
-230,133,139,228,185,159,232,174,184,231,142,175,228,191,157,229,159,185,229,133,
-187,230,166,130,229,191,181,229,164,167,229,158,139,230,156,186,231,165,168,231,
-144,134,232,167,163,229,140,191,229,144,141,99,117,97,110,100,111,101,110,118,
-105,97,114,109,97,100,114,105,100,98,117,115,99,97,114,105,110,105,99,105,111,
-116,105,101,109,112,111,112,111,114,113,117,101,99,117,101,110,116,97,101,115,
-116,97,100,111,112,117,101,100,101,110,106,117,101,103,111,115,99,111,110,116,
-114,97,101,115,116,195,161,110,110,111,109,98,114,101,116,105,101,110,101,110,
-112,101,114,102,105,108,109,97,110,101,114,97,97,109,105,103,111,115,99,105,117,
-100,97,100,99,101,110,116,114,111,97,117,110,113,117,101,112,117,101,100,101,115
-,100,101,110,116,114,111,112,114,105,109,101,114,112,114,101,99,105,111,115,101,
-103,195,186,110,98,117,101,110,111,115,118,111,108,118,101,114,112,117,110,116,
-111,115,115,101,109,97,110,97,104,97,98,195,173,97,97,103,111,115,116,111,110,
-117,101,118,111,115,117,110,105,100,111,115,99,97,114,108,111,115,101,113,117,
-105,112,111,110,105,195,177,111,115,109,117,99,104,111,115,97,108,103,117,110,97
-,99,111,114,114,101,111,105,109,97,103,101,110,112,97,114,116,105,114,97,114,114
-,105,98,97,109,97,114,195,173,97,104,111,109,98,114,101,101,109,112,108,101,111,
-118,101,114,100,97,100,99,97,109,98,105,111,109,117,99,104,97,115,102,117,101,
-114,111,110,112,97,115,97,100,111,108,195,173,110,101,97,112,97,114,101,99,101,
-110,117,101,118,97,115,99,117,114,115,111,115,101,115,116,97,98,97,113,117,105,
-101,114,111,108,105,98,114,111,115,99,117,97,110,116,111,97,99,99,101,115,111,
-109,105,103,117,101,108,118,97,114,105,111,115,99,117,97,116,114,111,116,105,101
-,110,101,115,103,114,117,112,111,115,115,101,114,195,161,110,101,117,114,111,112
-,97,109,101,100,105,111,115,102,114,101,110,116,101,97,99,101,114,99,97,100,101,
-109,195,161,115,111,102,101,114,116,97,99,111,99,104,101,115,109,111,100,101,108
-,111,105,116,97,108,105,97,108,101,116,114,97,115,97,108,103,195,186,110,99,111,
-109,112,114,97,99,117,97,108,101,115,101,120,105,115,116,101,99,117,101,114,112,
-111,115,105,101,110,100,111,112,114,101,110,115,97,108,108,101,103,97,114,118,
-105,97,106,101,115,100,105,110,101,114,111,109,117,114,99,105,97,112,111,100,114
-,195,161,112,117,101,115,116,111,100,105,97,114,105,111,112,117,101,98,108,111,
-113,117,105,101,114,101,109,97,110,117,101,108,112,114,111,112,105,111,99,114,
-105,115,105,115,99,105,101,114,116,111,115,101,103,117,114,111,109,117,101,114,
-116,101,102,117,101,110,116,101,99,101,114,114,97,114,103,114,97,110,100,101,101
-,102,101,99,116,111,112,97,114,116,101,115,109,101,100,105,100,97,112,114,111,
-112,105,97,111,102,114,101,99,101,116,105,101,114,114,97,101,45,109,97,105,108,
-118,97,114,105,97,115,102,111,114,109,97,115,102,117,116,117,114,111,111,98,106,
-101,116,111,115,101,103,117,105,114,114,105,101,115,103,111,110,111,114,109,97,
-115,109,105,115,109,111,115,195,186,110,105,99,111,99,97,109,105,110,111,115,105
-,116,105,111,115,114,97,122,195,179,110,100,101,98,105,100,111,112,114,117,101,
-98,97,116,111,108,101,100,111,116,101,110,195,173,97,106,101,115,195,186,115,101
-,115,112,101,114,111,99,111,99,105,110,97,111,114,105,103,101,110,116,105,101,
-110,100,97,99,105,101,110,116,111,99,195,161,100,105,122,104,97,98,108,97,114,
-115,101,114,195,173,97,108,97,116,105,110,97,102,117,101,114,122,97,101,115,116,
-105,108,111,103,117,101,114,114,97,101,110,116,114,97,114,195,169,120,105,116,
-111,108,195,179,112,101,122,97,103,101,110,100,97,118,195,173,100,101,111,101,
-118,105,116,97,114,112,97,103,105,110,97,109,101,116,114,111,115,106,97,118,105,
-101,114,112,97,100,114,101,115,102,195,161,99,105,108,99,97,98,101,122,97,195,
-161,114,101,97,115,115,97,108,105,100,97,101,110,118,195,173,111,106,97,112,195,
-179,110,97,98,117,115,111,115,98,105,101,110,101,115,116,101,120,116,111,115,108
-,108,101,118,97,114,112,117,101,100,97,110,102,117,101,114,116,101,99,111,109,
-195,186,110,99,108,97,115,101,115,104,117,109,97,110,111,116,101,110,105,100,111
-,98,105,108,98,97,111,117,110,105,100,97,100,101,115,116,195,161,115,101,100,105
-,116,97,114,99,114,101,97,100,111,208,180,208,187,209,143,209,135,209,130,208,
-190,208,186,208,176,208,186,208,184,208,187,208,184,209,141,209,130,208,190,208,
-178,209,129,208,181,208,181,208,179,208,190,208,191,209,128,208,184,209,130,208,
-176,208,186,208,181,209,137,208,181,209,131,208,182,208,181,208,154,208,176,208,
-186,208,177,208,181,208,183,208,177,209,139,208,187,208,190,208,189,208,184,208,
-146,209,129,208,181,208,191,208,190,208,180,208,173,209,130,208,190,209,130,208,
-190,208,188,209,135,208,181,208,188,208,189,208,181,209,130,208,187,208,181,209,
-130,209,128,208,176,208,183,208,190,208,189,208,176,208,179,208,180,208,181,208,
-188,208,189,208,181,208,148,208,187,209,143,208,159,209,128,208,184,208,189,208,
-176,209,129,208,189,208,184,209,133,209,130,208,181,208,188,208,186,209,130,208,
-190,208,179,208,190,208,180,208,178,208,190,209,130,209,130,208,176,208,188,208,
-161,208,168,208,144,208,188,208,176,209,143,208,167,209,130,208,190,208,178,208,
-176,209,129,208,178,208,176,208,188,208,181,208,188,209,131,208,162,208,176,208,
-186,208,180,208,178,208,176,208,189,208,176,208,188,209,141,209,130,208,184,209,
-141,209,130,209,131,208,146,208,176,208,188,209,130,208,181,209,133,208,191,209,
-128,208,190,209,130,209,131,209,130,208,189,208,176,208,180,208,180,208,189,209,
-143,208,146,208,190,209,130,209,130,209,128,208,184,208,189,208,181,208,185,208,
-146,208,176,209,129,208,189,208,184,208,188,209,129,208,176,208,188,209,130,208,
-190,209,130,209,128,209,131,208,177,208,158,208,189,208,184,208,188,208,184,209,
-128,208,189,208,181,208,181,208,158,208,158,208,158,208,187,208,184,209,134,209,
-141,209,130,208,176,208,158,208,189,208,176,208,189,208,181,208,188,208,180,208,
-190,208,188,208,188,208,190,208,185,208,180,208,178,208,181,208,190,208,189,208,
-190,209,129,209,131,208,180,224,164,149,224,165,135,224,164,185,224,165,136,224,
-164,149,224,165,128,224,164,184,224,165,135,224,164,149,224,164,190,224,164,149,
-224,165,139,224,164,148,224,164,176,224,164,170,224,164,176,224,164,168,224,165,
-135,224,164,143,224,164,149,224,164,149,224,164,191,224,164,173,224,165,128,224,
-164,135,224,164,184,224,164,149,224,164,176,224,164,164,224,165,139,224,164,185,
-224,165,139,224,164,134,224,164,170,224,164,185,224,165,128,224,164,175,224,164,
-185,224,164,175,224,164,190,224,164,164,224,164,149,224,164,165,224,164,190,106,
-97,103,114,97,110,224,164,134,224,164,156,224,164,156,224,165,139,224,164,133,
-224,164,172,224,164,166,224,165,139,224,164,151,224,164,136,224,164,156,224,164,
-190,224,164,151,224,164,143,224,164,185,224,164,174,224,164,135,224,164,168,224,
-164,181,224,164,185,224,164,175,224,165,135,224,164,165,224,165,135,224,164,165,
-224,165,128,224,164,152,224,164,176,224,164,156,224,164,172,224,164,166,224,165,
-128,224,164,149,224,164,136,224,164,156,224,165,128,224,164,181,224,165,135,224,
-164,168,224,164,136,224,164,168,224,164,143,224,164,185,224,164,176,224,164,137,
-224,164,184,224,164,174,224,165,135,224,164,149,224,164,174,224,164,181,224,165,
-139,224,164,178,224,165,135,224,164,184,224,164,172,224,164,174,224,164,136,224,
-164,166,224,165,135,224,164,147,224,164,176,224,164,134,224,164,174,224,164,172,
-224,164,184,224,164,173,224,164,176,224,164,172,224,164,168,224,164,154,224,164,
-178,224,164,174,224,164,168,224,164,134,224,164,151,224,164,184,224,165,128,224,
-164,178,224,165,128,216,185,217,132,217,137,216,165,217,132,217,137,217,135,216,
-176,216,167,216,162,216,174,216,177,216,185,216,175,216,175,216,167,217,132,217,
-137,217,135,216,176,217,135,216,181,217,136,216,177,216,186,217,138,216,177,217,
-131,216,167,217,134,217,136,217,132,216,167,216,168,217,138,217,134,216,185,216,
-177,216,182,216,176,217,132,217,131,217,135,217,134,216,167,217,138,217,136,217,
-133,217,130,216,167,217,132,216,185,217,132,217,138,216,167,217,134,216,167,217,
-132,217,131,217,134,216,173,216,170,217,137,217,130,216,168,217,132,217,136,216,
-173,216,169,216,167,216,174,216,177,217,129,217,130,216,183,216,185,216,168,216,
-175,216,177,217,131,217,134,216,165,216,176,216,167,217,131,217,133,216,167,216,
-167,216,173,216,175,216,165,217,132,216,167,217,129,217,138,217,135,216,168,216,
-185,216,182,217,131,217,138,217,129,216,168,216,173,216,171,217,136,217,133,217,
-134,217,136,217,135,217,136,216,163,217,134,216,167,216,172,216,175,216,167,217,
-132,217,135,216,167,216,179,217,132,217,133,216,185,217,134,216,175,217,132,217,
-138,216,179,216,185,216,168,216,177,216,181,217,132,217,137,217,133,217,134,216,
-176,216,168,217,135,216,167,216,163,217,134,217,135,217,133,216,171,217,132,217,
-131,217,134,216,170,216,167,217,132,216,167,216,173,217,138,216,171,217,133,216,
-181,216,177,216,180,216,177,216,173,216,173,217,136,217,132,217,136,217,129,217,
-138,216,167,216,176,216,167,217,132,217,131,217,132,217,133,216,177,216,169,216,
-167,217,134,216,170,216,167,217,132,217,129,216,163,216,168,217,136,216,174,216,
-167,216,181,216,163,217,134,216,170,216,167,217,134,217,135,216,167,217,132,217,
-138,216,185,216,182,217,136,217,136,217,130,216,175,216,167,216,168,217,134,216,
-174,217,138,216,177,216,168,217,134,216,170,217,132,217,131,217,133,216,180,216,
-167,216,161,217,136,217,135,217,138,216,167,216,168,217,136,217,130,216,181,216,
-181,217,136,217,133,216,167,216,177,217,130,217,133,216,163,216,173,216,175,217,
-134,216,173,217,134,216,185,216,175,217,133,216,177,216,163,217,138,216,167,216,
-173,216,169,217,131,216,170,216,168,216,175,217,136,217,134,217,138,216,172,216,
-168,217,133,217,134,217,135,216,170,216,173,216,170,216,172,217,135,216,169,216,
-179,217,134,216,169,217,138,216,170,217,133,217,131,216,177,216,169,216,186,216,
-178,216,169,217,134,217,129,216,179,216,168,217,138,216,170,217,132,217,132,217,
-135,217,132,217,134,216,167,216,170,217,132,217,131,217,130,217,132,216,168,217,
-132,217,133,216,167,216,185,217,134,217,135,216,163,217,136,217,132,216,180,217,
-138,216,161,217,134,217,136,216,177,216,163,217,133,216,167,217,129,217,138,217,
-131,216,168,217,131,217,132,216,176,216,167,216,170,216,177,216,170,216,168,216,
-168,216,163,217,134,217,135,217,133,216,179,216,167,217,134,217,131,216,168,217,
-138,216,185,217,129,217,130,216,175,216,173,216,179,217,134,217,132,217,135,217,
-133,216,180,216,185,216,177,216,163,217,135,217,132,216,180,217,135,216,177,217,
-130,216,183,216,177,216,183,217,132,216,168,112,114,111,102,105,108,101,115,101,
-114,118,105,99,101,100,101,102,97,117,108,116,104,105,109,115,101,108,102,100,
-101,116,97,105,108,115,99,111,110,116,101,110,116,115,117,112,112,111,114,116,
-115,116,97,114,116,101,100,109,101,115,115,97,103,101,115,117,99,99,101,115,115,
-102,97,115,104,105,111,110,60,116,105,116,108,101,62,99,111,117,110,116,114,121,
-97,99,99,111,117,110,116,99,114,101,97,116,101,100,115,116,111,114,105,101,115,
-114,101,115,117,108,116,115,114,117,110,110,105,110,103,112,114,111,99,101,115,
-115,119,114,105,116,105,110,103,111,98,106,101,99,116,115,118,105,115,105,98,108
-,101,119,101,108,99,111,109,101,97,114,116,105,99,108,101,117,110,107,110,111,
-119,110,110,101,116,119,111,114,107,99,111,109,112,97,110,121,100,121,110,97,109
-,105,99,98,114,111,119,115,101,114,112,114,105,118,97,99,121,112,114,111,98,108,
-101,109,83,101,114,118,105,99,101,114,101,115,112,101,99,116,100,105,115,112,108
-,97,121,114,101,113,117,101,115,116,114,101,115,101,114,118,101,119,101,98,115,
-105,116,101,104,105,115,116,111,114,121,102,114,105,101,110,100,115,111,112,116,
-105,111,110,115,119,111,114,107,105,110,103,118,101,114,115,105,111,110,109,105,
-108,108,105,111,110,99,104,97,110,110,101,108,119,105,110,100,111,119,46,97,100,
-100,114,101,115,115,118,105,115,105,116,101,100,119,101,97,116,104,101,114,99,
-111,114,114,101,99,116,112,114,111,100,117,99,116,101,100,105,114,101,99,116,102
-,111,114,119,97,114,100,121,111,117,32,99,97,110,114,101,109,111,118,101,100,115
-,117,98,106,101,99,116,99,111,110,116,114,111,108,97,114,99,104,105,118,101,99,
-117,114,114,101,110,116,114,101,97,100,105,110,103,108,105,98,114,97,114,121,108
-,105,109,105,116,101,100,109,97,110,97,103,101,114,102,117,114,116,104,101,114,
-115,117,109,109,97,114,121,109,97,99,104,105,110,101,109,105,110,117,116,101,115
-,112,114,105,118,97,116,101,99,111,110,116,101,120,116,112,114,111,103,114,97,
-109,115,111,99,105,101,116,121,110,117,109,98,101,114,115,119,114,105,116,116,
-101,110,101,110,97,98,108,101,100,116,114,105,103,103,101,114,115,111,117,114,99
-,101,115,108,111,97,100,105,110,103,101,108,101,109,101,110,116,112,97,114,116,
-110,101,114,102,105,110,97,108,108,121,112,101,114,102,101,99,116,109,101,97,110
-,105,110,103,115,121,115,116,101,109,115,107,101,101,112,105,110,103,99,117,108,
-116,117,114,101,38,113,117,111,116,59,44,106,111,117,114,110,97,108,112,114,111,
-106,101,99,116,115,117,114,102,97,99,101,115,38,113,117,111,116,59,101,120,112,
-105,114,101,115,114,101,118,105,101,119,115,98,97,108,97,110,99,101,69,110,103,
-108,105,115,104,67,111,110,116,101,110,116,116,104,114,111,117,103,104,80,108,
-101,97,115,101,32,111,112,105,110,105,111,110,99,111,110,116,97,99,116,97,118,
-101,114,97,103,101,112,114,105,109,97,114,121,118,105,108,108,97,103,101,83,112,
-97,110,105,115,104,103,97,108,108,101,114,121,100,101,99,108,105,110,101,109,101
-,101,116,105,110,103,109,105,115,115,105,111,110,112,111,112,117,108,97,114,113,
-117,97,108,105,116,121,109,101,97,115,117,114,101,103,101,110,101,114,97,108,115
-,112,101,99,105,101,115,115,101,115,115,105,111,110,115,101,99,116,105,111,110,
-119,114,105,116,101,114,115,99,111,117,110,116,101,114,105,110,105,116,105,97,
-108,114,101,112,111,114,116,115,102,105,103,117,114,101,115,109,101,109,98,101,
-114,115,104,111,108,100,105,110,103,100,105,115,112,117,116,101,101,97,114,108,
-105,101,114,101,120,112,114,101,115,115,100,105,103,105,116,97,108,112,105,99,
-116,117,114,101,65,110,111,116,104,101,114,109,97,114,114,105,101,100,116,114,97
-,102,102,105,99,108,101,97,100,105,110,103,99,104,97,110,103,101,100,99,101,110,
-116,114,97,108,118,105,99,116,111,114,121,105,109,97,103,101,115,47,114,101,97,
-115,111,110,115,115,116,117,100,105,101,115,102,101,97,116,117,114,101,108,105,
-115,116,105,110,103,109,117,115,116,32,98,101,115,99,104,111,111,108,115,86,101,
-114,115,105,111,110,117,115,117,97,108,108,121,101,112,105,115,111,100,101,112,
-108,97,121,105,110,103,103,114,111,119,105,110,103,111,98,118,105,111,117,115,
-111,118,101,114,108,97,121,112,114,101,115,101,110,116,97,99,116,105,111,110,115
-,60,47,117,108,62,13,10,119,114,97,112,112,101,114,97,108,114,101,97,100,121,99,
-101,114,116,97,105,110,114,101,97,108,105,116,121,115,116,111,114,97,103,101,97,
-110,111,116,104,101,114,100,101,115,107,116,111,112,111,102,102,101,114,101,100,
-112,97,116,116,101,114,110,117,110,117,115,117,97,108,68,105,103,105,116,97,108,
-99,97,112,105,116,97,108,87,101,98,115,105,116,101,102,97,105,108,117,114,101,99
-,111,110,110,101,99,116,114,101,100,117,99,101,100,65,110,100,114,111,105,100,
-100,101,99,97,100,101,115,114,101,103,117,108,97,114,32,38,97,109,112,59,32,97,
-110,105,109,97,108,115,114,101,108,101,97,115,101,65,117,116,111,109,97,116,103,
-101,116,116,105,110,103,109,101,116,104,111,100,115,110,111,116,104,105,110,103,
-80,111,112,117,108,97,114,99,97,112,116,105,111,110,108,101,116,116,101,114,115,
-99,97,112,116,117,114,101,115,99,105,101,110,99,101,108,105,99,101,110,115,101,
-99,104,97,110,103,101,115,69,110,103,108,97,110,100,61,49,38,97,109,112,59,72,
-105,115,116,111,114,121,32,61,32,110,101,119,32,67,101,110,116,114,97,108,117,
-112,100,97,116,101,100,83,112,101,99,105,97,108,78,101,116,119,111,114,107,114,
-101,113,117,105,114,101,99,111,109,109,101,110,116,119,97,114,110,105,110,103,67
-,111,108,108,101,103,101,116,111,111,108,98,97,114,114,101,109,97,105,110,115,98
-,101,99,97,117,115,101,101,108,101,99,116,101,100,68,101,117,116,115,99,104,102,
-105,110,97,110,99,101,119,111,114,107,101,114,115,113,117,105,99,107,108,121,98,
-101,116,119,101,101,110,101,120,97,99,116,108,121,115,101,116,116,105,110,103,
-100,105,115,101,97,115,101,83,111,99,105,101,116,121,119,101,97,112,111,110,115,
-101,120,104,105,98,105,116,38,108,116,59,33,45,45,67,111,110,116,114,111,108,99,
-108,97,115,115,101,115,99,111,118,101,114,101,100,111,117,116,108,105,110,101,97
-,116,116,97,99,107,115,100,101,118,105,99,101,115,40,119,105,110,100,111,119,112
-,117,114,112,111,115,101,116,105,116,108,101,61,34,77,111,98,105,108,101,32,107,
-105,108,108,105,110,103,115,104,111,119,105,110,103,73,116,97,108,105,97,110,100
-,114,111,112,112,101,100,104,101,97,118,105,108,121,101,102,102,101,99,116,115,
-45,49,39,93,41,59,10,99,111,110,102,105,114,109,67,117,114,114,101,110,116,97,
-100,118,97,110,99,101,115,104,97,114,105,110,103,111,112,101,110,105,110,103,100
-,114,97,119,105,110,103,98,105,108,108,105,111,110,111,114,100,101,114,101,100,
-71,101,114,109,97,110,121,114,101,108,97,116,101,100,60,47,102,111,114,109,62,
-105,110,99,108,117,100,101,119,104,101,116,104,101,114,100,101,102,105,110,101,
-100,83,99,105,101,110,99,101,99,97,116,97,108,111,103,65,114,116,105,99,108,101,
-98,117,116,116,111,110,115,108,97,114,103,101,115,116,117,110,105,102,111,114,
-109,106,111,117,114,110,101,121,115,105,100,101,98,97,114,67,104,105,99,97,103,
-111,104,111,108,105,100,97,121,71,101,110,101,114,97,108,112,97,115,115,97,103,
-101,44,38,113,117,111,116,59,97,110,105,109,97,116,101,102,101,101,108,105,110,
-103,97,114,114,105,118,101,100,112,97,115,115,105,110,103,110,97,116,117,114,97,
-108,114,111,117,103,104,108,121,46,10,10,84,104,101,32,98,117,116,32,110,111,116
-,100,101,110,115,105,116,121,66,114,105,116,97,105,110,67,104,105,110,101,115,
-101,108,97,99,107,32,111,102,116,114,105,98,117,116,101,73,114,101,108,97,110,
-100,34,32,100,97,116,97,45,102,97,99,116,111,114,115,114,101,99,101,105,118,101,
-116,104,97,116,32,105,115,76,105,98,114,97,114,121,104,117,115,98,97,110,100,105
-,110,32,102,97,99,116,97,102,102,97,105,114,115,67,104,97,114,108,101,115,114,97
-,100,105,99,97,108,98,114,111,117,103,104,116,102,105,110,100,105,110,103,108,97
-,110,100,105,110,103,58,108,97,110,103,61,34,114,101,116,117,114,110,32,108,101,
-97,100,101,114,115,112,108,97,110,110,101,100,112,114,101,109,105,117,109,112,97
-,99,107,97,103,101,65,109,101,114,105,99,97,69,100,105,116,105,111,110,93,38,113
-,117,111,116,59,77,101,115,115,97,103,101,110,101,101,100,32,116,111,118,97,108,
-117,101,61,34,99,111,109,112,108,101,120,108,111,111,107,105,110,103,115,116,97,
-116,105,111,110,98,101,108,105,101,118,101,115,109,97,108,108,101,114,45,109,111
-,98,105,108,101,114,101,99,111,114,100,115,119,97,110,116,32,116,111,107,105,110
-,100,32,111,102,70,105,114,101,102,111,120,121,111,117,32,97,114,101,115,105,109
-,105,108,97,114,115,116,117,100,105,101,100,109,97,120,105,109,117,109,104,101,
-97,100,105,110,103,114,97,112,105,100,108,121,99,108,105,109,97,116,101,107,105,
-110,103,100,111,109,101,109,101,114,103,101,100,97,109,111,117,110,116,115,102,
-111,117,110,100,101,100,112,105,111,110,101,101,114,102,111,114,109,117,108,97,
-100,121,110,97,115,116,121,104,111,119,32,116,111,32,83,117,112,112,111,114,116,
-114,101,118,101,110,117,101,101,99,111,110,111,109,121,82,101,115,117,108,116,
-115,98,114,111,116,104,101,114,115,111,108,100,105,101,114,108,97,114,103,101,
-108,121,99,97,108,108,105,110,103,46,38,113,117,111,116,59,65,99,99,111,117,110,
-116,69,100,119,97,114,100,32,115,101,103,109,101,110,116,82,111,98,101,114,116,
-32,101,102,102,111,114,116,115,80,97,99,105,102,105,99,108,101,97,114,110,101,
-100,117,112,32,119,105,116,104,104,101,105,103,104,116,58,119,101,32,104,97,118,
-101,65,110,103,101,108,101,115,110,97,116,105,111,110,115,95,115,101,97,114,99,
-104,97,112,112,108,105,101,100,97,99,113,117,105,114,101,109,97,115,115,105,118,
-101,103,114,97,110,116,101,100,58,32,102,97,108,115,101,116,114,101,97,116,101,
-100,98,105,103,103,101,115,116,98,101,110,101,102,105,116,100,114,105,118,105,
-110,103,83,116,117,100,105,101,115,109,105,110,105,109,117,109,112,101,114,104,
-97,112,115,109,111,114,110,105,110,103,115,101,108,108,105,110,103,105,115,32,
-117,115,101,100,114,101,118,101,114,115,101,118,97,114,105,97,110,116,32,114,111
-,108,101,61,34,109,105,115,115,105,110,103,97,99,104,105,101,118,101,112,114,111
-,109,111,116,101,115,116,117,100,101,110,116,115,111,109,101,111,110,101,101,120
-,116,114,101,109,101,114,101,115,116,111,114,101,98,111,116,116,111,109,58,101,
-118,111,108,118,101,100,97,108,108,32,116,104,101,115,105,116,101,109,97,112,101
-,110,103,108,105,115,104,119,97,121,32,116,111,32,32,65,117,103,117,115,116,115,
-121,109,98,111,108,115,67,111,109,112,97,110,121,109,97,116,116,101,114,115,109,
-117,115,105,99,97,108,97,103,97,105,110,115,116,115,101,114,118,105,110,103,125,
-41,40,41,59,13,10,112,97,121,109,101,110,116,116,114,111,117,98,108,101,99,111,
-110,99,101,112,116,99,111,109,112,97,114,101,112,97,114,101,110,116,115,112,108,
-97,121,101,114,115,114,101,103,105,111,110,115,109,111,110,105,116,111,114,32,39
-,39,84,104,101,32,119,105,110,110,105,110,103,101,120,112,108,111,114,101,97,100
-,97,112,116,101,100,71,97,108,108,101,114,121,112,114,111,100,117,99,101,97,98,
-105,108,105,116,121,101,110,104,97,110,99,101,99,97,114,101,101,114,115,41,46,32
-,84,104,101,32,99,111,108,108,101,99,116,83,101,97,114,99,104,32,97,110,99,105,
-101,110,116,101,120,105,115,116,101,100,102,111,111,116,101,114,32,104,97,110,
-100,108,101,114,112,114,105,110,116,101,100,99,111,110,115,111,108,101,69,97,115
-,116,101,114,110,101,120,112,111,114,116,115,119,105,110,100,111,119,115,67,104,
-97,110,110,101,108,105,108,108,101,103,97,108,110,101,117,116,114,97,108,115,117
-,103,103,101,115,116,95,104,101,97,100,101,114,115,105,103,110,105,110,103,46,
-104,116,109,108,34,62,115,101,116,116,108,101,100,119,101,115,116,101,114,110,99
-,97,117,115,105,110,103,45,119,101,98,107,105,116,99,108,97,105,109,101,100,74,
-117,115,116,105,99,101,99,104,97,112,116,101,114,118,105,99,116,105,109,115,84,
-104,111,109,97,115,32,109,111,122,105,108,108,97,112,114,111,109,105,115,101,112
-,97,114,116,105,101,115,101,100,105,116,105,111,110,111,117,116,115,105,100,101,
-58,102,97,108,115,101,44,104,117,110,100,114,101,100,79,108,121,109,112,105,99,
-95,98,117,116,116,111,110,97,117,116,104,111,114,115,114,101,97,99,104,101,100,
-99,104,114,111,110,105,99,100,101,109,97,110,100,115,115,101,99,111,110,100,115,
-112,114,111,116,101,99,116,97,100,111,112,116,101,100,112,114,101,112,97,114,101
-,110,101,105,116,104,101,114,103,114,101,97,116,108,121,103,114,101,97,116,101,
-114,111,118,101,114,97,108,108,105,109,112,114,111,118,101,99,111,109,109,97,110
-,100,115,112,101,99,105,97,108,115,101,97,114,99,104,46,119,111,114,115,104,105,
-112,102,117,110,100,105,110,103,116,104,111,117,103,104,116,104,105,103,104,101,
-115,116,105,110,115,116,101,97,100,117,116,105,108,105,116,121,113,117,97,114,
-116,101,114,67,117,108,116,117,114,101,116,101,115,116,105,110,103,99,108,101,97
-,114,108,121,101,120,112,111,115,101,100,66,114,111,119,115,101,114,108,105,98,
-101,114,97,108,125,32,99,97,116,99,104,80,114,111,106,101,99,116,101,120,97,109,
-112,108,101,104,105,100,101,40,41,59,70,108,111,114,105,100,97,97,110,115,119,
-101,114,115,97,108,108,111,119,101,100,69,109,112,101,114,111,114,100,101,102,
-101,110,115,101,115,101,114,105,111,117,115,102,114,101,101,100,111,109,83,101,
-118,101,114,97,108,45,98,117,116,116,111,110,70,117,114,116,104,101,114,111,117,
-116,32,111,102,32,33,61,32,110,117,108,108,116,114,97,105,110,101,100,68,101,110
-,109,97,114,107,118,111,105,100,40,48,41,47,97,108,108,46,106,115,112,114,101,
-118,101,110,116,82,101,113,117,101,115,116,83,116,101,112,104,101,110,10,10,87,
-104,101,110,32,111,98,115,101,114,118,101,60,47,104,50,62,13,10,77,111,100,101,
-114,110,32,112,114,111,118,105,100,101,34,32,97,108,116,61,34,98,111,114,100,101
-,114,115,46,10,10,70,111,114,32,10,10,77,97,110,121,32,97,114,116,105,115,116,
-115,112,111,119,101,114,101,100,112,101,114,102,111,114,109,102,105,99,116,105,
-111,110,116,121,112,101,32,111,102,109,101,100,105,99,97,108,116,105,99,107,101,
-116,115,111,112,112,111,115,101,100,67,111,117,110,99,105,108,119,105,116,110,
-101,115,115,106,117,115,116,105,99,101,71,101,111,114,103,101,32,66,101,108,103,
-105,117,109,46,46,46,60,47,97,62,116,119,105,116,116,101,114,110,111,116,97,98,
-108,121,119,97,105,116,105,110,103,119,97,114,102,97,114,101,32,79,116,104,101,
-114,32,114,97,110,107,105,110,103,112,104,114,97,115,101,115,109,101,110,116,105
-,111,110,115,117,114,118,105,118,101,115,99,104,111,108,97,114,60,47,112,62,13,
-10,32,67,111,117,110,116,114,121,105,103,110,111,114,101,100,108,111,115,115,32,
-111,102,106,117,115,116,32,97,115,71,101,111,114,103,105,97,115,116,114,97,110,
-103,101,60,104,101,97,100,62,60,115,116,111,112,112,101,100,49,39,93,41,59,13,10
-,105,115,108,97,110,100,115,110,111,116,97,98,108,101,98,111,114,100,101,114,58,
-108,105,115,116,32,111,102,99,97,114,114,105,101,100,49,48,48,44,48,48,48,60,47,
-104,51,62,10,32,115,101,118,101,114,97,108,98,101,99,111,109,101,115,115,101,108
-,101,99,116,32,119,101,100,100,105,110,103,48,48,46,104,116,109,108,109,111,110,
-97,114,99,104,111,102,102,32,116,104,101,116,101,97,99,104,101,114,104,105,103,
-104,108,121,32,98,105,111,108,111,103,121,108,105,102,101,32,111,102,111,114,32,
-101,118,101,110,114,105,115,101,32,111,102,38,114,97,113,117,111,59,112,108,117,
-115,111,110,101,104,117,110,116,105,110,103,40,116,104,111,117,103,104,68,111,
-117,103,108,97,115,106,111,105,110,105,110,103,99,105,114,99,108,101,115,70,111,
-114,32,116,104,101,65,110,99,105,101,110,116,86,105,101,116,110,97,109,118,101,
-104,105,99,108,101,115,117,99,104,32,97,115,99,114,121,115,116,97,108,118,97,108
-,117,101,32,61,87,105,110,100,111,119,115,101,110,106,111,121,101,100,97,32,115,
-109,97,108,108,97,115,115,117,109,101,100,60,97,32,105,100,61,34,102,111,114,101
-,105,103,110,32,65,108,108,32,114,105,104,111,119,32,116,104,101,68,105,115,112,
-108,97,121,114,101,116,105,114,101,100,104,111,119,101,118,101,114,104,105,100,
-100,101,110,59,98,97,116,116,108,101,115,115,101,101,107,105,110,103,99,97,98,
-105,110,101,116,119,97,115,32,110,111,116,108,111,111,107,32,97,116,99,111,110,
-100,117,99,116,103,101,116,32,116,104,101,74,97,110,117,97,114,121,104,97,112,
-112,101,110,115,116,117,114,110,105,110,103,97,58,104,111,118,101,114,79,110,108
-,105,110,101,32,70,114,101,110,99,104,32,108,97,99,107,105,110,103,116,121,112,
-105,99,97,108,101,120,116,114,97,99,116,101,110,101,109,105,101,115,101,118,101,
-110,32,105,102,103,101,110,101,114,97,116,100,101,99,105,100,101,100,97,114,101,
-32,110,111,116,47,115,101,97,114,99,104,98,101,108,105,101,102,115,45,105,109,97
-,103,101,58,108,111,99,97,116,101,100,115,116,97,116,105,99,46,108,111,103,105,
-110,34,62,99,111,110,118,101,114,116,118,105,111,108,101,110,116,101,110,116,101
-,114,101,100,102,105,114,115,116,34,62,99,105,114,99,117,105,116,70,105,110,108,
-97,110,100,99,104,101,109,105,115,116,115,104,101,32,119,97,115,49,48,112,120,59
-,34,62,97,115,32,115,117,99,104,100,105,118,105,100,101,100,60,47,115,112,97,110
-,62,119,105,108,108,32,98,101,108,105,110,101,32,111,102,97,32,103,114,101,97,
-116,109,121,115,116,101,114,121,47,105,110,100,101,120,46,102,97,108,108,105,110
-,103,100,117,101,32,116,111,32,114,97,105,108,119,97,121,99,111,108,108,101,103,
-101,109,111,110,115,116,101,114,100,101,115,99,101,110,116,105,116,32,119,105,
-116,104,110,117,99,108,101,97,114,74,101,119,105,115,104,32,112,114,111,116,101,
-115,116,66,114,105,116,105,115,104,102,108,111,119,101,114,115,112,114,101,100,
-105,99,116,114,101,102,111,114,109,115,98,117,116,116,111,110,32,119,104,111,32,
-119,97,115,108,101,99,116,117,114,101,105,110,115,116,97,110,116,115,117,105,99,
-105,100,101,103,101,110,101,114,105,99,112,101,114,105,111,100,115,109,97,114,
-107,101,116,115,83,111,99,105,97,108,32,102,105,115,104,105,110,103,99,111,109,
-98,105,110,101,103,114,97,112,104,105,99,119,105,110,110,101,114,115,60,98,114,
-32,47,62,60,98,121,32,116,104,101,32,78,97,116,117,114,97,108,80,114,105,118,97,
-99,121,99,111,111,107,105,101,115,111,117,116,99,111,109,101,114,101,115,111,108
-,118,101,83,119,101,100,105,115,104,98,114,105,101,102,108,121,80,101,114,115,
-105,97,110,115,111,32,109,117,99,104,67,101,110,116,117,114,121,100,101,112,105,
-99,116,115,99,111,108,117,109,110,115,104,111,117,115,105,110,103,115,99,114,105
-,112,116,115,110,101,120,116,32,116,111,98,101,97,114,105,110,103,109,97,112,112
-,105,110,103,114,101,118,105,115,101,100,106,81,117,101,114,121,40,45,119,105,
-100,116,104,58,116,105,116,108,101,34,62,116,111,111,108,116,105,112,83,101,99,
-116,105,111,110,100,101,115,105,103,110,115,84,117,114,107,105,115,104,121,111,
-117,110,103,101,114,46,109,97,116,99,104,40,125,41,40,41,59,10,10,98,117,114,110
-,105,110,103,111,112,101,114,97,116,101,100,101,103,114,101,101,115,115,111,117,
-114,99,101,61,82,105,99,104,97,114,100,99,108,111,115,101,108,121,112,108,97,115
-,116,105,99,101,110,116,114,105,101,115,60,47,116,114,62,13,10,99,111,108,111,
-114,58,35,117,108,32,105,100,61,34,112,111,115,115,101,115,115,114,111,108,108,
-105,110,103,112,104,121,115,105,99,115,102,97,105,108,105,110,103,101,120,101,99
-,117,116,101,99,111,110,116,101,115,116,108,105,110,107,32,116,111,68,101,102,97
-,117,108,116,60,98,114,32,47,62,10,58,32,116,114,117,101,44,99,104,97,114,116,
-101,114,116,111,117,114,105,115,109,99,108,97,115,115,105,99,112,114,111,99,101,
-101,100,101,120,112,108,97,105,110,60,47,104,49,62,13,10,111,110,108,105,110,101
-,46,63,120,109,108,32,118,101,104,101,108,112,105,110,103,100,105,97,109,111,110
-,100,117,115,101,32,116,104,101,97,105,114,108,105,110,101,101,110,100,32,45,45,
-62,41,46,97,116,116,114,40,114,101,97,100,101,114,115,104,111,115,116,105,110,
-103,35,102,102,102,102,102,102,114,101,97,108,105,122,101,86,105,110,99,101,110,
-116,115,105,103,110,97,108,115,32,115,114,99,61,34,47,80,114,111,100,117,99,116,
-100,101,115,112,105,116,101,100,105,118,101,114,115,101,116,101,108,108,105,110,
-103,80,117,98,108,105,99,32,104,101,108,100,32,105,110,74,111,115,101,112,104,32
-,116,104,101,97,116,114,101,97,102,102,101,99,116,115,60,115,116,121,108,101,62,
-97,32,108,97,114,103,101,100,111,101,115,110,39,116,108,97,116,101,114,44,32,69,
-108,101,109,101,110,116,102,97,118,105,99,111,110,99,114,101,97,116,111,114,72,
-117,110,103,97,114,121,65,105,114,112,111,114,116,115,101,101,32,116,104,101,115
-,111,32,116,104,97,116,77,105,99,104,97,101,108,83,121,115,116,101,109,115,80,
-114,111,103,114,97,109,115,44,32,97,110,100,32,32,119,105,100,116,104,61,101,38,
-113,117,111,116,59,116,114,97,100,105,110,103,108,101,102,116,34,62,10,112,101,
-114,115,111,110,115,71,111,108,100,101,110,32,65,102,102,97,105,114,115,103,114,
-97,109,109,97,114,102,111,114,109,105,110,103,100,101,115,116,114,111,121,105,
-100,101,97,32,111,102,99,97,115,101,32,111,102,111,108,100,101,115,116,32,116,
-104,105,115,32,105,115,46,115,114,99,32,61,32,99,97,114,116,111,111,110,114,101,
-103,105,115,116,114,67,111,109,109,111,110,115,77,117,115,108,105,109,115,87,104
-,97,116,32,105,115,105,110,32,109,97,110,121,109,97,114,107,105,110,103,114,101,
-118,101,97,108,115,73,110,100,101,101,100,44,101,113,117,97,108,108,121,47,115,
-104,111,119,95,97,111,117,116,100,111,111,114,101,115,99,97,112,101,40,65,117,
-115,116,114,105,97,103,101,110,101,116,105,99,115,121,115,116,101,109,44,73,110,
-32,116,104,101,32,115,105,116,116,105,110,103,72,101,32,97,108,115,111,73,115,
-108,97,110,100,115,65,99,97,100,101,109,121,10,9,9,60,33,45,45,68,97,110,105,101
-,108,32,98,105,110,100,105,110,103,98,108,111,99,107,34,62,105,109,112,111,115,
-101,100,117,116,105,108,105,122,101,65,98,114,97,104,97,109,40,101,120,99,101,
-112,116,123,119,105,100,116,104,58,112,117,116,116,105,110,103,41,46,104,116,109
-,108,40,124,124,32,91,93,59,10,68,65,84,65,91,32,42,107,105,116,99,104,101,110,
-109,111,117,110,116,101,100,97,99,116,117,97,108,32,100,105,97,108,101,99,116,
-109,97,105,110,108,121,32,95,98,108,97,110,107,39,105,110,115,116,97,108,108,101
-,120,112,101,114,116,115,105,102,40,116,121,112,101,73,116,32,97,108,115,111,38,
-99,111,112,121,59,32,34,62,84,101,114,109,115,98,111,114,110,32,105,110,79,112,
-116,105,111,110,115,101,97,115,116,101,114,110,116,97,108,107,105,110,103,99,111
-,110,99,101,114,110,103,97,105,110,101,100,32,111,110,103,111,105,110,103,106,
-117,115,116,105,102,121,99,114,105,116,105,99,115,102,97,99,116,111,114,121,105,
-116,115,32,111,119,110,97,115,115,97,117,108,116,105,110,118,105,116,101,100,108
-,97,115,116,105,110,103,104,105,115,32,111,119,110,104,114,101,102,61,34,47,34,
-32,114,101,108,61,34,100,101,118,101,108,111,112,99,111,110,99,101,114,116,100,
-105,97,103,114,97,109,100,111,108,108,97,114,115,99,108,117,115,116,101,114,112,
-104,112,63,105,100,61,97,108,99,111,104,111,108,41,59,125,41,40,41,59,117,115,
-105,110,103,32,97,62,60,115,112,97,110,62,118,101,115,115,101,108,115,114,101,
-118,105,118,97,108,65,100,100,114,101,115,115,97,109,97,116,101,117,114,97,110,
-100,114,111,105,100,97,108,108,101,103,101,100,105,108,108,110,101,115,115,119,
-97,108,107,105,110,103,99,101,110,116,101,114,115,113,117,97,108,105,102,121,109
-,97,116,99,104,101,115,117,110,105,102,105,101,100,101,120,116,105,110,99,116,68
-,101,102,101,110,115,101,100,105,101,100,32,105,110,10,9,60,33,45,45,32,99,117,
-115,116,111,109,115,108,105,110,107,105,110,103,76,105,116,116,108,101,32,66,111
-,111,107,32,111,102,101,118,101,110,105,110,103,109,105,110,46,106,115,63,97,114
-,101,32,116,104,101,107,111,110,116,97,107,116,116,111,100,97,121,39,115,46,104,
-116,109,108,34,32,116,97,114,103,101,116,61,119,101,97,114,105,110,103,65,108,
-108,32,82,105,103,59,10,125,41,40,41,59,114,97,105,115,105,110,103,32,65,108,115
-,111,44,32,99,114,117,99,105,97,108,97,98,111,117,116,34,62,100,101,99,108,97,
-114,101,45,45,62,10,60,115,99,102,105,114,101,102,111,120,97,115,32,109,117,99,
-104,97,112,112,108,105,101,115,105,110,100,101,120,44,32,115,44,32,98,117,116,32
-,116,121,112,101,32,61,32,10,13,10,60,33,45,45,116,111,119,97,114,100,115,82,101
-,99,111,114,100,115,80,114,105,118,97,116,101,70,111,114,101,105,103,110,80,114,
-101,109,105,101,114,99,104,111,105,99,101,115,86,105,114,116,117,97,108,114,101,
-116,117,114,110,115,67,111,109,109,101,110,116,80,111,119,101,114,101,100,105,
-110,108,105,110,101,59,112,111,118,101,114,116,121,99,104,97,109,98,101,114,76,
-105,118,105,110,103,32,118,111,108,117,109,101,115,65,110,116,104,111,110,121,
-108,111,103,105,110,34,32,82,101,108,97,116,101,100,69,99,111,110,111,109,121,
-114,101,97,99,104,101,115,99,117,116,116,105,110,103,103,114,97,118,105,116,121,
-108,105,102,101,32,105,110,67,104,97,112,116,101,114,45,115,104,97,100,111,119,
-78,111,116,97,98,108,101,60,47,116,100,62,13,10,32,114,101,116,117,114,110,115,
-116,97,100,105,117,109,119,105,100,103,101,116,115,118,97,114,121,105,110,103,
-116,114,97,118,101,108,115,104,101,108,100,32,98,121,119,104,111,32,97,114,101,
-119,111,114,107,32,105,110,102,97,99,117,108,116,121,97,110,103,117,108,97,114,
-119,104,111,32,104,97,100,97,105,114,112,111,114,116,116,111,119,110,32,111,102,
-10,10,83,111,109,101,32,39,99,108,105,99,107,39,99,104,97,114,103,101,115,107,
-101,121,119,111,114,100,105,116,32,119,105,108,108,99,105,116,121,32,111,102,40,
-116,104,105,115,41,59,65,110,100,114,101,119,32,117,110,105,113,117,101,32,99,
-104,101,99,107,101,100,111,114,32,109,111,114,101,51,48,48,112,120,59,32,114,101
-,116,117,114,110,59,114,115,105,111,110,61,34,112,108,117,103,105,110,115,119,
-105,116,104,105,110,32,104,101,114,115,101,108,102,83,116,97,116,105,111,110,70,
-101,100,101,114,97,108,118,101,110,116,117,114,101,112,117,98,108,105,115,104,
-115,101,110,116,32,116,111,116,101,110,115,105,111,110,97,99,116,114,101,115,115
-,99,111,109,101,32,116,111,102,105,110,103,101,114,115,68,117,107,101,32,111,102
-,112,101,111,112,108,101,44,101,120,112,108,111,105,116,119,104,97,116,32,105,
-115,104,97,114,109,111,110,121,97,32,109,97,106,111,114,34,58,34,104,116,116,112
-,105,110,32,104,105,115,32,109,101,110,117,34,62,10,109,111,110,116,104,108,121,
-111,102,102,105,99,101,114,99,111,117,110,99,105,108,103,97,105,110,105,110,103,
-101,118,101,110,32,105,110,83,117,109,109,97,114,121,100,97,116,101,32,111,102,
-108,111,121,97,108,116,121,102,105,116,110,101,115,115,97,110,100,32,119,97,115,
-101,109,112,101,114,111,114,115,117,112,114,101,109,101,83,101,99,111,110,100,32
-,104,101,97,114,105,110,103,82,117,115,115,105,97,110,108,111,110,103,101,115,
-116,65,108,98,101,114,116,97,108,97,116,101,114,97,108,115,101,116,32,111,102,32
-,115,109,97,108,108,34,62,46,97,112,112,101,110,100,100,111,32,119,105,116,104,
-102,101,100,101,114,97,108,98,97,110,107,32,111,102,98,101,110,101,97,116,104,68
-,101,115,112,105,116,101,67,97,112,105,116,97,108,103,114,111,117,110,100,115,41
-,44,32,97,110,100,32,112,101,114,99,101,110,116,105,116,32,102,114,111,109,99,
-108,111,115,105,110,103,99,111,110,116,97,105,110,73,110,115,116,101,97,100,102,
-105,102,116,101,101,110,97,115,32,119,101,108,108,46,121,97,104,111,111,46,114,
-101,115,112,111,110,100,102,105,103,104,116,101,114,111,98,115,99,117,114,101,
-114,101,102,108,101,99,116,111,114,103,97,110,105,99,61,32,77,97,116,104,46,101,
-100,105,116,105,110,103,111,110,108,105,110,101,32,112,97,100,100,105,110,103,97
-,32,119,104,111,108,101,111,110,101,114,114,111,114,121,101,97,114,32,111,102,
-101,110,100,32,111,102,32,98,97,114,114,105,101,114,119,104,101,110,32,105,116,
-104,101,97,100,101,114,32,104,111,109,101,32,111,102,114,101,115,117,109,101,100
-,114,101,110,97,109,101,100,115,116,114,111,110,103,62,104,101,97,116,105,110,
-103,114,101,116,97,105,110,115,99,108,111,117,100,102,114,119,97,121,32,111,102,
-32,77,97,114,99,104,32,49,107,110,111,119,105,110,103,105,110,32,112,97,114,116,
-66,101,116,119,101,101,110,108,101,115,115,111,110,115,99,108,111,115,101,115,
-116,118,105,114,116,117,97,108,108,105,110,107,115,34,62,99,114,111,115,115,101,
-100,69,78,68,32,45,45,62,102,97,109,111,117,115,32,97,119,97,114,100,101,100,76,
-105,99,101,110,115,101,72,101,97,108,116,104,32,102,97,105,114,108,121,32,119,
-101,97,108,116,104,121,109,105,110,105,109,97,108,65,102,114,105,99,97,110,99,
-111,109,112,101,116,101,108,97,98,101,108,34,62,115,105,110,103,105,110,103,102,
-97,114,109,101,114,115,66,114,97,115,105,108,41,100,105,115,99,117,115,115,114,
-101,112,108,97,99,101,71,114,101,103,111,114,121,102,111,110,116,32,99,111,112,
-117,114,115,117,101,100,97,112,112,101,97,114,115,109,97,107,101,32,117,112,114,
-111,117,110,100,101,100,98,111,116,104,32,111,102,98,108,111,99,107,101,100,115,
-97,119,32,116,104,101,111,102,102,105,99,101,115,99,111,108,111,117,114,115,105,
-102,40,100,111,99,117,119,104,101,110,32,104,101,101,110,102,111,114,99,101,112,
-117,115,104,40,102,117,65,117,103,117,115,116,32,85,84,70,45,56,34,62,70,97,110,
-116,97,115,121,105,110,32,109,111,115,116,105,110,106,117,114,101,100,85,115,117
-,97,108,108,121,102,97,114,109,105,110,103,99,108,111,115,117,114,101,111,98,106
-,101,99,116,32,100,101,102,101,110,99,101,117,115,101,32,111,102,32,77,101,100,
-105,99,97,108,60,98,111,100,121,62,10,101,118,105,100,101,110,116,98,101,32,117,
-115,101,100,107,101,121,67,111,100,101,115,105,120,116,101,101,110,73,115,108,97
-,109,105,99,35,48,48,48,48,48,48,101,110,116,105,114,101,32,119,105,100,101,108,
-121,32,97,99,116,105,118,101,32,40,116,121,112,101,111,102,111,110,101,32,99,97,
-110,99,111,108,111,114,32,61,115,112,101,97,107,101,114,101,120,116,101,110,100,
-115,80,104,121,115,105,99,115,116,101,114,114,97,105,110,60,116,98,111,100,121,
-62,102,117,110,101,114,97,108,118,105,101,119,105,110,103,109,105,100,100,108,
-101,32,99,114,105,99,107,101,116,112,114,111,112,104,101,116,115,104,105,102,116
-,101,100,100,111,99,116,111,114,115,82,117,115,115,101,108,108,32,116,97,114,103
-,101,116,99,111,109,112,97,99,116,97,108,103,101,98,114,97,115,111,99,105,97,108
-,45,98,117,108,107,32,111,102,109,97,110,32,97,110,100,60,47,116,100,62,10,32,
-104,101,32,108,101,102,116,41,46,118,97,108,40,41,102,97,108,115,101,41,59,108,
-111,103,105,99,97,108,98,97,110,107,105,110,103,104,111,109,101,32,116,111,110,
-97,109,105,110,103,32,65,114,105,122,111,110,97,99,114,101,100,105,116,115,41,59
-,10,125,41,59,10,102,111,117,110,100,101,114,105,110,32,116,117,114,110,67,111,
-108,108,105,110,115,98,101,102,111,114,101,32,66,117,116,32,116,104,101,99,104,
-97,114,103,101,100,84,105,116,108,101,34,62,67,97,112,116,97,105,110,115,112,101
-,108,108,101,100,103,111,100,100,101,115,115,84,97,103,32,45,45,62,65,100,100,
-105,110,103,58,98,117,116,32,119,97,115,82,101,99,101,110,116,32,112,97,116,105,
-101,110,116,98,97,99,107,32,105,110,61,102,97,108,115,101,38,76,105,110,99,111,
-108,110,119,101,32,107,110,111,119,67,111,117,110,116,101,114,74,117,100,97,105,
-115,109,115,99,114,105,112,116,32,97,108,116,101,114,101,100,39,93,41,59,10,32,
-32,104,97,115,32,116,104,101,117,110,99,108,101,97,114,69,118,101,110,116,39,44,
-98,111,116,104,32,105,110,110,111,116,32,97,108,108,10,10,60,33,45,45,32,112,108
-,97,99,105,110,103,104,97,114,100,32,116,111,32,99,101,110,116,101,114,115,111,
-114,116,32,111,102,99,108,105,101,110,116,115,115,116,114,101,101,116,115,66,101
-,114,110,97,114,100,97,115,115,101,114,116,115,116,101,110,100,32,116,111,102,97
-,110,116,97,115,121,100,111,119,110,32,105,110,104,97,114,98,111,117,114,70,114,
-101,101,100,111,109,106,101,119,101,108,114,121,47,97,98,111,117,116,46,46,115,
-101,97,114,99,104,108,101,103,101,110,100,115,105,115,32,109,97,100,101,109,111,
-100,101,114,110,32,111,110,108,121,32,111,110,111,110,108,121,32,116,111,105,109
-,97,103,101,34,32,108,105,110,101,97,114,32,112,97,105,110,116,101,114,97,110,
-100,32,110,111,116,114,97,114,101,108,121,32,97,99,114,111,110,121,109,100,101,
-108,105,118,101,114,115,104,111,114,116,101,114,48,48,38,97,109,112,59,97,115,32
-,109,97,110,121,119,105,100,116,104,61,34,47,42,32,60,33,91,67,116,105,116,108,
-101,32,61,111,102,32,116,104,101,32,108,111,119,101,115,116,32,112,105,99,107,
-101,100,32,101,115,99,97,112,101,100,117,115,101,115,32,111,102,112,101,111,112,
-108,101,115,32,80,117,98,108,105,99,77,97,116,116,104,101,119,116,97,99,116,105,
-99,115,100,97,109,97,103,101,100,119,97,121,32,102,111,114,108,97,119,115,32,111
-,102,101,97,115,121,32,116,111,32,119,105,110,100,111,119,115,116,114,111,110,
-103,32,32,115,105,109,112,108,101,125,99,97,116,99,104,40,115,101,118,101,110,
-116,104,105,110,102,111,98,111,120,119,101,110,116,32,116,111,112,97,105,110,116
-,101,100,99,105,116,105,122,101,110,73,32,100,111,110,39,116,114,101,116,114,101
-,97,116,46,32,83,111,109,101,32,119,119,46,34,41,59,10,98,111,109,98,105,110,103
-,109,97,105,108,116,111,58,109,97,100,101,32,105,110,46,32,77,97,110,121,32,99,
-97,114,114,105,101,115,124,124,123,125,59,119,105,119,111,114,107,32,111,102,115
-,121,110,111,110,121,109,100,101,102,101,97,116,115,102,97,118,111,114,101,100,
-111,112,116,105,99,97,108,112,97,103,101,84,114,97,117,110,108,101,115,115,32,
-115,101,110,100,105,110,103,108,101,102,116,34,62,60,99,111,109,83,99,111,114,65
-,108,108,32,116,104,101,106,81,117,101,114,121,46,116,111,117,114,105,115,116,67
-,108,97,115,115,105,99,102,97,108,115,101,34,32,87,105,108,104,101,108,109,115,
-117,98,117,114,98,115,103,101,110,117,105,110,101,98,105,115,104,111,112,115,46,
-115,112,108,105,116,40,103,108,111,98,97,108,32,102,111,108,108,111,119,115,98,
-111,100,121,32,111,102,110,111,109,105,110,97,108,67,111,110,116,97,99,116,115,
-101,99,117,108,97,114,108,101,102,116,32,116,111,99,104,105,101,102,108,121,45,
-104,105,100,100,101,110,45,98,97,110,110,101,114,60,47,108,105,62,10,10,46,32,87
-,104,101,110,32,105,110,32,98,111,116,104,100,105,115,109,105,115,115,69,120,112
-,108,111,114,101,97,108,119,97,121,115,32,118,105,97,32,116,104,101,115,112,97,
-195,177,111,108,119,101,108,102,97,114,101,114,117,108,105,110,103,32,97,114,114
-,97,110,103,101,99,97,112,116,97,105,110,104,105,115,32,115,111,110,114,117,108,
-101,32,111,102,104,101,32,116,111,111,107,105,116,115,101,108,102,44,61,48,38,97
-,109,112,59,40,99,97,108,108,101,100,115,97,109,112,108,101,115,116,111,32,109,
-97,107,101,99,111,109,47,112,97,103,77,97,114,116,105,110,32,75,101,110,110,101,
-100,121,97,99,99,101,112,116,115,102,117,108,108,32,111,102,104,97,110,100,108,
-101,100,66,101,115,105,100,101,115,47,47,45,45,62,60,47,97,98,108,101,32,116,111
-,116,97,114,103,101,116,115,101,115,115,101,110,99,101,104,105,109,32,116,111,32
-,105,116,115,32,98,121,32,99,111,109,109,111,110,46,109,105,110,101,114,97,108,
-116,111,32,116,97,107,101,119,97,121,115,32,116,111,115,46,111,114,103,47,108,97
-,100,118,105,115,101,100,112,101,110,97,108,116,121,115,105,109,112,108,101,58,
-105,102,32,116,104,101,121,76,101,116,116,101,114,115,97,32,115,104,111,114,116,
-72,101,114,98,101,114,116,115,116,114,105,107,101,115,32,103,114,111,117,112,115
-,46,108,101,110,103,116,104,102,108,105,103,104,116,115,111,118,101,114,108,97,
-112,115,108,111,119,108,121,32,108,101,115,115,101,114,32,115,111,99,105,97,108,
-32,60,47,112,62,10,9,9,105,116,32,105,110,116,111,114,97,110,107,101,100,32,114,
-97,116,101,32,111,102,117,108,62,13,10,32,32,97,116,116,101,109,112,116,112,97,
-105,114,32,111,102,109,97,107,101,32,105,116,75,111,110,116,97,107,116,65,110,
-116,111,110,105,111,104,97,118,105,110,103,32,114,97,116,105,110,103,115,32,97,
-99,116,105,118,101,115,116,114,101,97,109,115,116,114,97,112,112,101,100,34,41,
-46,99,115,115,40,104,111,115,116,105,108,101,108,101,97,100,32,116,111,108,105,
-116,116,108,101,32,103,114,111,117,112,115,44,80,105,99,116,117,114,101,45,45,62
-,13,10,13,10,32,114,111,119,115,61,34,32,111,98,106,101,99,116,105,110,118,101,
-114,115,101,60,102,111,111,116,101,114,67,117,115,116,111,109,86,62,60,92,47,115
-,99,114,115,111,108,118,105,110,103,67,104,97,109,98,101,114,115,108,97,118,101,
-114,121,119,111,117,110,100,101,100,119,104,101,114,101,97,115,33,61,32,39,117,
-110,100,102,111,114,32,97,108,108,112,97,114,116,108,121,32,45,114,105,103,104,
-116,58,65,114,97,98,105,97,110,98,97,99,107,101,100,32,99,101,110,116,117,114,
-121,117,110,105,116,32,111,102,109,111,98,105,108,101,45,69,117,114,111,112,101,
-44,105,115,32,104,111,109,101,114,105,115,107,32,111,102,100,101,115,105,114,101
-,100,67,108,105,110,116,111,110,99,111,115,116,32,111,102,97,103,101,32,111,102,
-32,98,101,99,111,109,101,32,110,111,110,101,32,111,102,112,38,113,117,111,116,59
-,77,105,100,100,108,101,32,101,97,100,39,41,91,48,67,114,105,116,105,99,115,115,
-116,117,100,105,111,115,62,38,99,111,112,121,59,103,114,111,117,112,34,62,97,115
-,115,101,109,98,108,109,97,107,105,110,103,32,112,114,101,115,115,101,100,119,
-105,100,103,101,116,46,112,115,58,34,32,63,32,114,101,98,117,105,108,116,98,121,
-32,115,111,109,101,70,111,114,109,101,114,32,101,100,105,116,111,114,115,100,101
-,108,97,121,101,100,67,97,110,111,110,105,99,104,97,100,32,116,104,101,112,117,
-115,104,105,110,103,99,108,97,115,115,61,34,98,117,116,32,97,114,101,112,97,114,
-116,105,97,108,66,97,98,121,108,111,110,98,111,116,116,111,109,32,99,97,114,114,
-105,101,114,67,111,109,109,97,110,100,105,116,115,32,117,115,101,65,115,32,119,
-105,116,104,99,111,117,114,115,101,115,97,32,116,104,105,114,100,100,101,110,111
-,116,101,115,97,108,115,111,32,105,110,72,111,117,115,116,111,110,50,48,112,120,
-59,34,62,97,99,99,117,115,101,100,100,111,117,98,108,101,32,103,111,97,108,32,
-111,102,70,97,109,111,117,115,32,41,46,98,105,110,100,40,112,114,105,101,115,116
-,115,32,79,110,108,105,110,101,105,110,32,74,117,108,121,115,116,32,43,32,34,103
-,99,111,110,115,117,108,116,100,101,99,105,109,97,108,104,101,108,112,102,117,
-108,114,101,118,105,118,101,100,105,115,32,118,101,114,121,114,39,43,39,105,112,
-116,108,111,115,105,110,103,32,102,101,109,97,108,101,115,105,115,32,97,108,115,
-111,115,116,114,105,110,103,115,100,97,121,115,32,111,102,97,114,114,105,118,97,
-108,102,117,116,117,114,101,32,60,111,98,106,101,99,116,102,111,114,99,105,110,
-103,83,116,114,105,110,103,40,34,32,47,62,10,9,9,104,101,114,101,32,105,115,101,
-110,99,111,100,101,100,46,32,32,84,104,101,32,98,97,108,108,111,111,110,100,111,
-110,101,32,98,121,47,99,111,109,109,111,110,98,103,99,111,108,111,114,108,97,119
-,32,111,102,32,73,110,100,105,97,110,97,97,118,111,105,100,101,100,98,117,116,32
-,116,104,101,50,112,120,32,51,112,120,106,113,117,101,114,121,46,97,102,116,101,
-114,32,97,112,111,108,105,99,121,46,109,101,110,32,97,110,100,102,111,111,116,
-101,114,45,61,32,116,114,117,101,59,102,111,114,32,117,115,101,115,99,114,101,
-101,110,46,73,110,100,105,97,110,32,105,109,97,103,101,32,61,102,97,109,105,108,
-121,44,104,116,116,112,58,47,47,32,38,110,98,115,112,59,100,114,105,118,101,114,
-115,101,116,101,114,110,97,108,115,97,109,101,32,97,115,110,111,116,105,99,101,
-100,118,105,101,119,101,114,115,125,41,40,41,59,10,32,105,115,32,109,111,114,101
-,115,101,97,115,111,110,115,102,111,114,109,101,114,32,116,104,101,32,110,101,
-119,105,115,32,106,117,115,116,99,111,110,115,101,110,116,32,83,101,97,114,99,
-104,119,97,115,32,116,104,101,119,104,121,32,116,104,101,115,104,105,112,112,101
-,100,98,114,62,60,98,114,62,119,105,100,116,104,58,32,104,101,105,103,104,116,61
-,109,97,100,101,32,111,102,99,117,105,115,105,110,101,105,115,32,116,104,97,116,
-97,32,118,101,114,121,32,65,100,109,105,114,97,108,32,102,105,120,101,100,59,110
-,111,114,109,97,108,32,77,105,115,115,105,111,110,80,114,101,115,115,44,32,111,
-110,116,97,114,105,111,99,104,97,114,115,101,116,116,114,121,32,116,111,32,105,
-110,118,97,100,101,100,61,34,116,114,117,101,34,115,112,97,99,105,110,103,105,
-115,32,109,111,115,116,97,32,109,111,114,101,32,116,111,116,97,108,108,121,102,
-97,108,108,32,111,102,125,41,59,13,10,32,32,105,109,109,101,110,115,101,116,105,
-109,101,32,105,110,115,101,116,32,111,117,116,115,97,116,105,115,102,121,116,111
-,32,102,105,110,100,100,111,119,110,32,116,111,108,111,116,32,111,102,32,80,108,
-97,121,101,114,115,105,110,32,74,117,110,101,113,117,97,110,116,117,109,110,111,
-116,32,116,104,101,116,105,109,101,32,116,111,100,105,115,116,97,110,116,70,105,
-110,110,105,115,104,115,114,99,32,61,32,40,115,105,110,103,108,101,32,104,101,
-108,112,32,111,102,71,101,114,109,97,110,32,108,97,119,32,97,110,100,108,97,98,
-101,108,101,100,102,111,114,101,115,116,115,99,111,111,107,105,110,103,115,112,
-97,99,101,34,62,104,101,97,100,101,114,45,119,101,108,108,32,97,115,83,116,97,
-110,108,101,121,98,114,105,100,103,101,115,47,103,108,111,98,97,108,67,114,111,
-97,116,105,97,32,65,98,111,117,116,32,91,48,93,59,10,32,32,105,116,44,32,97,110,
-100,103,114,111,117,112,101,100,98,101,105,110,103,32,97,41,123,116,104,114,111,
-119,104,101,32,109,97,100,101,108,105,103,104,116,101,114,101,116,104,105,99,97,
-108,70,70,70,70,70,70,34,98,111,116,116,111,109,34,108,105,107,101,32,97,32,101,
-109,112,108,111,121,115,108,105,118,101,32,105,110,97,115,32,115,101,101,110,112
-,114,105,110,116,101,114,109,111,115,116,32,111,102,117,98,45,108,105,110,107,
-114,101,106,101,99,116,115,97,110,100,32,117,115,101,105,109,97,103,101,34,62,
-115,117,99,99,101,101,100,102,101,101,100,105,110,103,78,117,99,108,101,97,114,
-105,110,102,111,114,109,97,116,111,32,104,101,108,112,87,111,109,101,110,39,115,
-78,101,105,116,104,101,114,77,101,120,105,99,97,110,112,114,111,116,101,105,110,
-60,116,97,98,108,101,32,98,121,32,109,97,110,121,104,101,97,108,116,104,121,108,
-97,119,115,117,105,116,100,101,118,105,115,101,100,46,112,117,115,104,40,123,115
-,101,108,108,101,114,115,115,105,109,112,108,121,32,84,104,114,111,117,103,104,
-46,99,111,111,107,105,101,32,73,109,97,103,101,40,111,108,100,101,114,34,62,117,
-115,46,106,115,34,62,32,83,105,110,99,101,32,117,110,105,118,101,114,115,108,97,
-114,103,101,114,32,111,112,101,110,32,116,111,33,45,45,32,101,110,100,108,105,
-101,115,32,105,110,39,93,41,59,13,10,32,32,109,97,114,107,101,116,119,104,111,32
-,105,115,32,40,34,68,79,77,67,111,109,97,110,97,103,101,100,111,110,101,32,102,
-111,114,116,121,112,101,111,102,32,75,105,110,103,100,111,109,112,114,111,102,
-105,116,115,112,114,111,112,111,115,101,116,111,32,115,104,111,119,99,101,110,
-116,101,114,59,109,97,100,101,32,105,116,100,114,101,115,115,101,100,119,101,114
-,101,32,105,110,109,105,120,116,117,114,101,112,114,101,99,105,115,101,97,114,
-105,115,105,110,103,115,114,99,32,61,32,39,109,97,107,101,32,97,32,115,101,99,
-117,114,101,100,66,97,112,116,105,115,116,118,111,116,105,110,103,32,10,9,9,118,
-97,114,32,77,97,114,99,104,32,50,103,114,101,119,32,117,112,67,108,105,109,97,
-116,101,46,114,101,109,111,118,101,115,107,105,108,108,101,100,119,97,121,32,116
-,104,101,60,47,104,101,97,100,62,102,97,99,101,32,111,102,97,99,116,105,110,103,
-32,114,105,103,104,116,34,62,116,111,32,119,111,114,107,114,101,100,117,99,101,
-115,104,97,115,32,104,97,100,101,114,101,99,116,101,100,115,104,111,119,40,41,59
-,97,99,116,105,111,110,61,98,111,111,107,32,111,102,97,110,32,97,114,101,97,61,
-61,32,34,104,116,116,60,104,101,97,100,101,114,10,60,104,116,109,108,62,99,111,
-110,102,111,114,109,102,97,99,105,110,103,32,99,111,111,107,105,101,46,114,101,
-108,121,32,111,110,104,111,115,116,101,100,32,46,99,117,115,116,111,109,104,101,
-32,119,101,110,116,98,117,116,32,102,111,114,115,112,114,101,97,100,32,70,97,109
-,105,108,121,32,97,32,109,101,97,110,115,111,117,116,32,116,104,101,102,111,114,
-117,109,115,46,102,111,111,116,97,103,101,34,62,77,111,98,105,108,67,108,101,109
-,101,110,116,115,34,32,105,100,61,34,97,115,32,104,105,103,104,105,110,116,101,
-110,115,101,45,45,62,60,33,45,45,102,101,109,97,108,101,32,105,115,32,115,101,
-101,110,105,109,112,108,105,101,100,115,101,116,32,116,104,101,97,32,115,116,97,
-116,101,97,110,100,32,104,105,115,102,97,115,116,101,115,116,98,101,115,105,100,
-101,115,98,117,116,116,111,110,95,98,111,117,110,100,101,100,34,62,60,105,109,
-103,32,73,110,102,111,98,111,120,101,118,101,110,116,115,44,97,32,121,111,117,
-110,103,97,110,100,32,97,114,101,78,97,116,105,118,101,32,99,104,101,97,112,101,
-114,84,105,109,101,111,117,116,97,110,100,32,104,97,115,101,110,103,105,110,101,
-115,119,111,110,32,116,104,101,40,109,111,115,116,108,121,114,105,103,104,116,58
-,32,102,105,110,100,32,97,32,45,98,111,116,116,111,109,80,114,105,110,99,101,32,
-97,114,101,97,32,111,102,109,111,114,101,32,111,102,115,101,97,114,99,104,95,110
-,97,116,117,114,101,44,108,101,103,97,108,108,121,112,101,114,105,111,100,44,108
-,97,110,100,32,111,102,111,114,32,119,105,116,104,105,110,100,117,99,101,100,112
-,114,111,118,105,110,103,109,105,115,115,105,108,101,108,111,99,97,108,108,121,
-65,103,97,105,110,115,116,116,104,101,32,119,97,121,107,38,113,117,111,116,59,
-112,120,59,34,62,13,10,112,117,115,104,101,100,32,97,98,97,110,100,111,110,110,
-117,109,101,114,97,108,67,101,114,116,97,105,110,73,110,32,116,104,105,115,109,
-111,114,101,32,105,110,111,114,32,115,111,109,101,110,97,109,101,32,105,115,97,
-110,100,44,32,105,110,99,114,111,119,110,101,100,73,83,66,78,32,48,45,99,114,101
-,97,116,101,115,79,99,116,111,98,101,114,109,97,121,32,110,111,116,99,101,110,
-116,101,114,32,108,97,116,101,32,105,110,68,101,102,101,110,99,101,101,110,97,99
-,116,101,100,119,105,115,104,32,116,111,98,114,111,97,100,108,121,99,111,111,108
-,105,110,103,111,110,108,111,97,100,61,105,116,46,32,84,104,101,114,101,99,111,
-118,101,114,77,101,109,98,101,114,115,104,101,105,103,104,116,32,97,115,115,117,
-109,101,115,60,104,116,109,108,62,10,112,101,111,112,108,101,46,105,110,32,111,
-110,101,32,61,119,105,110,100,111,119,102,111,111,116,101,114,95,97,32,103,111,
-111,100,32,114,101,107,108,97,109,97,111,116,104,101,114,115,44,116,111,32,116,
-104,105,115,95,99,111,111,107,105,101,112,97,110,101,108,34,62,76,111,110,100,
-111,110,44,100,101,102,105,110,101,115,99,114,117,115,104,101,100,98,97,112,116,
-105,115,109,99,111,97,115,116,97,108,115,116,97,116,117,115,32,116,105,116,108,
-101,34,32,109,111,118,101,32,116,111,108,111,115,116,32,105,110,98,101,116,116,
-101,114,32,105,109,112,108,105,101,115,114,105,118,97,108,114,121,115,101,114,
-118,101,114,115,32,83,121,115,116,101,109,80,101,114,104,97,112,115,101,115,32,
-97,110,100,32,99,111,110,116,101,110,100,102,108,111,119,105,110,103,108,97,115,
-116,101,100,32,114,105,115,101,32,105,110,71,101,110,101,115,105,115,118,105,101
-,119,32,111,102,114,105,115,105,110,103,32,115,101,101,109,32,116,111,98,117,116
-,32,105,110,32,98,97,99,107,105,110,103,104,101,32,119,105,108,108,103,105,118,
-101,110,32,97,103,105,118,105,110,103,32,99,105,116,105,101,115,46,102,108,111,
-119,32,111,102,32,76,97,116,101,114,32,97,108,108,32,98,117,116,72,105,103,104,
-119,97,121,111,110,108,121,32,98,121,115,105,103,110,32,111,102,104,101,32,100,
-111,101,115,100,105,102,102,101,114,115,98,97,116,116,101,114,121,38,97,109,112,
-59,108,97,115,105,110,103,108,101,115,116,104,114,101,97,116,115,105,110,116,101
-,103,101,114,116,97,107,101,32,111,110,114,101,102,117,115,101,100,99,97,108,108
-,101,100,32,61,85,83,38,97,109,112,83,101,101,32,116,104,101,110,97,116,105,118,
-101,115,98,121,32,116,104,105,115,115,121,115,116,101,109,46,104,101,97,100,32,
-111,102,58,104,111,118,101,114,44,108,101,115,98,105,97,110,115,117,114,110,97,
-109,101,97,110,100,32,97,108,108,99,111,109,109,111,110,47,104,101,97,100,101,
-114,95,95,112,97,114,97,109,115,72,97,114,118,97,114,100,47,112,105,120,101,108,
-46,114,101,109,111,118,97,108,115,111,32,108,111,110,103,114,111,108,101,32,111,
-102,106,111,105,110,116,108,121,115,107,121,115,99,114,97,85,110,105,99,111,100,
-101,98,114,32,47,62,13,10,65,116,108,97,110,116,97,110,117,99,108,101,117,115,67
-,111,117,110,116,121,44,112,117,114,101,108,121,32,99,111,117,110,116,34,62,101,
-97,115,105,108,121,32,98,117,105,108,100,32,97,111,110,99,108,105,99,107,97,32,
-103,105,118,101,110,112,111,105,110,116,101,114,104,38,113,117,111,116,59,101,
-118,101,110,116,115,32,101,108,115,101,32,123,10,100,105,116,105,111,110,115,110
-,111,119,32,116,104,101,44,32,119,105,116,104,32,109,97,110,32,119,104,111,111,
-114,103,47,87,101,98,111,110,101,32,97,110,100,99,97,118,97,108,114,121,72,101,
-32,100,105,101,100,115,101,97,116,116,108,101,48,48,44,48,48,48,32,123,119,105,
-110,100,111,119,104,97,118,101,32,116,111,105,102,40,119,105,110,100,97,110,100,
-32,105,116,115,115,111,108,101,108,121,32,109,38,113,117,111,116,59,114,101,110,
-101,119,101,100,68,101,116,114,111,105,116,97,109,111,110,103,115,116,101,105,
-116,104,101,114,32,116,104,101,109,32,105,110,83,101,110,97,116,111,114,85,115,
-60,47,97,62,60,75,105,110,103,32,111,102,70,114,97,110,99,105,115,45,112,114,111
-,100,117,99,104,101,32,117,115,101,100,97,114,116,32,97,110,100,104,105,109,32,
-97,110,100,117,115,101,100,32,98,121,115,99,111,114,105,110,103,97,116,32,104,
-111,109,101,116,111,32,104,97,118,101,114,101,108,97,116,101,115,105,98,105,108,
-105,116,121,102,97,99,116,105,111,110,66,117,102,102,97,108,111,108,105,110,107,
-34,62,60,119,104,97,116,32,104,101,102,114,101,101,32,116,111,67,105,116,121,32,
-111,102,99,111,109,101,32,105,110,115,101,99,116,111,114,115,99,111,117,110,116,
-101,100,111,110,101,32,100,97,121,110,101,114,118,111,117,115,115,113,117,97,114
-,101,32,125,59,105,102,40,103,111,105,110,32,119,104,97,116,105,109,103,34,32,97
-,108,105,115,32,111,110,108,121,115,101,97,114,99,104,47,116,117,101,115,100,97,
-121,108,111,111,115,101,108,121,83,111,108,111,109,111,110,115,101,120,117,97,
-108,32,45,32,60,97,32,104,114,109,101,100,105,117,109,34,68,79,32,78,79,84,32,70
-,114,97,110,99,101,44,119,105,116,104,32,97,32,119,97,114,32,97,110,100,115,101,
-99,111,110,100,32,116,97,107,101,32,97,32,62,13,10,13,10,13,10,109,97,114,107,
-101,116,46,104,105,103,104,119,97,121,100,111,110,101,32,105,110,99,116,105,118,
-105,116,121,34,108,97,115,116,34,62,111,98,108,105,103,101,100,114,105,115,101,
-32,116,111,34,117,110,100,101,102,105,109,97,100,101,32,116,111,32,69,97,114,108
-,121,32,112,114,97,105,115,101,100,105,110,32,105,116,115,32,102,111,114,32,104,
-105,115,97,116,104,108,101,116,101,74,117,112,105,116,101,114,89,97,104,111,111,
-33,32,116,101,114,109,101,100,32,115,111,32,109,97,110,121,114,101,97,108,108,
-121,32,115,46,32,84,104,101,32,97,32,119,111,109,97,110,63,118,97,108,117,101,61
-,100,105,114,101,99,116,32,114,105,103,104,116,34,32,98,105,99,121,99,108,101,97
-,99,105,110,103,61,34,100,97,121,32,97,110,100,115,116,97,116,105,110,103,82,97,
-116,104,101,114,44,104,105,103,104,101,114,32,79,102,102,105,99,101,32,97,114,
-101,32,110,111,119,116,105,109,101,115,44,32,119,104,101,110,32,97,32,112,97,121
-,32,102,111,114,111,110,32,116,104,105,115,45,108,105,110,107,34,62,59,98,111,
-114,100,101,114,97,114,111,117,110,100,32,97,110,110,117,97,108,32,116,104,101,
-32,78,101,119,112,117,116,32,116,104,101,46,99,111,109,34,32,116,97,107,105,110,
-32,116,111,97,32,98,114,105,101,102,40,105,110,32,116,104,101,103,114,111,117,
-112,115,46,59,32,119,105,100,116,104,101,110,122,121,109,101,115,115,105,109,112
-,108,101,32,105,110,32,108,97,116,101,123,114,101,116,117,114,110,116,104,101,
-114,97,112,121,97,32,112,111,105,110,116,98,97,110,110,105,110,103,105,110,107,
-115,34,62,10,40,41,59,34,32,114,101,97,32,112,108,97,99,101,92,117,48,48,51,67,
-97,97,98,111,117,116,32,97,116,114,62,13,10,9,9,99,99,111,117,110,116,32,103,105
-,118,101,115,32,97,60,83,67,82,73,80,84,82,97,105,108,119,97,121,116,104,101,109
-,101,115,47,116,111,111,108,98,111,120,66,121,73,100,40,34,120,104,117,109,97,
-110,115,44,119,97,116,99,104,101,115,105,110,32,115,111,109,101,32,105,102,32,40
-,119,105,99,111,109,105,110,103,32,102,111,114,109,97,116,115,32,85,110,100,101,
-114,32,98,117,116,32,104,97,115,104,97,110,100,101,100,32,109,97,100,101,32,98,
-121,116,104,97,110,32,105,110,102,101,97,114,32,111,102,100,101,110,111,116,101,
-100,47,105,102,114,97,109,101,108,101,102,116,32,105,110,118,111,108,116,97,103,
-101,105,110,32,101,97,99,104,97,38,113,117,111,116,59,98,97,115,101,32,111,102,
-73,110,32,109,97,110,121,117,110,100,101,114,103,111,114,101,103,105,109,101,115
-,97,99,116,105,111,110,32,60,47,112,62,13,10,60,117,115,116,111,109,86,97,59,38,
-103,116,59,60,47,105,109,112,111,114,116,115,111,114,32,116,104,97,116,109,111,
-115,116,108,121,32,38,97,109,112,59,114,101,32,115,105,122,101,61,34,60,47,97,62
-,60,47,104,97,32,99,108,97,115,115,112,97,115,115,105,118,101,72,111,115,116,32,
-61,32,87,104,101,116,104,101,114,102,101,114,116,105,108,101,86,97,114,105,111,
-117,115,61,91,93,59,40,102,117,99,97,109,101,114,97,115,47,62,60,47,116,100,62,
-97,99,116,115,32,97,115,73,110,32,115,111,109,101,62,13,10,13,10,60,33,111,114,
-103,97,110,105,115,32,60,98,114,32,47,62,66,101,105,106,105,110,103,99,97,116,97
-,108,195,160,100,101,117,116,115,99,104,101,117,114,111,112,101,117,101,117,115,
-107,97,114,97,103,97,101,105,108,103,101,115,118,101,110,115,107,97,101,115,112,
-97,195,177,97,109,101,110,115,97,106,101,117,115,117,97,114,105,111,116,114,97,
-98,97,106,111,109,195,169,120,105,99,111,112,195,161,103,105,110,97,115,105,101,
-109,112,114,101,115,105,115,116,101,109,97,111,99,116,117,98,114,101,100,117,114
-,97,110,116,101,97,195,177,97,100,105,114,101,109,112,114,101,115,97,109,111,109
-,101,110,116,111,110,117,101,115,116,114,111,112,114,105,109,101,114,97,116,114,
-97,118,195,169,115,103,114,97,99,105,97,115,110,117,101,115,116,114,97,112,114,
-111,99,101,115,111,101,115,116,97,100,111,115,99,97,108,105,100,97,100,112,101,
-114,115,111,110,97,110,195,186,109,101,114,111,97,99,117,101,114,100,111,109,195
-,186,115,105,99,97,109,105,101,109,98,114,111,111,102,101,114,116,97,115,97,108,
-103,117,110,111,115,112,97,195,173,115,101,115,101,106,101,109,112,108,111,100,
-101,114,101,99,104,111,97,100,101,109,195,161,115,112,114,105,118,97,100,111,97,
-103,114,101,103,97,114,101,110,108,97,99,101,115,112,111,115,105,98,108,101,104,
-111,116,101,108,101,115,115,101,118,105,108,108,97,112,114,105,109,101,114,111,
-195,186,108,116,105,109,111,101,118,101,110,116,111,115,97,114,99,104,105,118,
-111,99,117,108,116,117,114,97,109,117,106,101,114,101,115,101,110,116,114,97,100
-,97,97,110,117,110,99,105,111,101,109,98,97,114,103,111,109,101,114,99,97,100,
-111,103,114,97,110,100,101,115,101,115,116,117,100,105,111,109,101,106,111,114,
-101,115,102,101,98,114,101,114,111,100,105,115,101,195,177,111,116,117,114,105,
-115,109,111,99,195,179,100,105,103,111,112,111,114,116,97,100,97,101,115,112,97,
-99,105,111,102,97,109,105,108,105,97,97,110,116,111,110,105,111,112,101,114,109,
-105,116,101,103,117,97,114,100,97,114,97,108,103,117,110,97,115,112,114,101,99,
-105,111,115,97,108,103,117,105,101,110,115,101,110,116,105,100,111,118,105,115,
-105,116,97,115,116,195,173,116,117,108,111,99,111,110,111,99,101,114,115,101,103
-,117,110,100,111,99,111,110,115,101,106,111,102,114,97,110,99,105,97,109,105,110
-,117,116,111,115,115,101,103,117,110,100,97,116,101,110,101,109,111,115,101,102,
-101,99,116,111,115,109,195,161,108,97,103,97,115,101,115,105,195,179,110,114,101
-,118,105,115,116,97,103,114,97,110,97,100,97,99,111,109,112,114,97,114,105,110,
-103,114,101,115,111,103,97,114,99,195,173,97,97,99,99,105,195,179,110,101,99,117
-,97,100,111,114,113,117,105,101,110,101,115,105,110,99,108,117,115,111,100,101,
-98,101,114,195,161,109,97,116,101,114,105,97,104,111,109,98,114,101,115,109,117,
-101,115,116,114,97,112,111,100,114,195,173,97,109,97,195,177,97,110,97,195,186,
-108,116,105,109,97,101,115,116,97,109,111,115,111,102,105,99,105,97,108,116,97,
-109,98,105,101,110,110,105,110,103,195,186,110,115,97,108,117,100,111,115,112,
-111,100,101,109,111,115,109,101,106,111,114,97,114,112,111,115,105,116,105,111,
-110,98,117,115,105,110,101,115,115,104,111,109,101,112,97,103,101,115,101,99,117
-,114,105,116,121,108,97,110,103,117,97,103,101,115,116,97,110,100,97,114,100,99,
-97,109,112,97,105,103,110,102,101,97,116,117,114,101,115,99,97,116,101,103,111,
-114,121,101,120,116,101,114,110,97,108,99,104,105,108,100,114,101,110,114,101,
-115,101,114,118,101,100,114,101,115,101,97,114,99,104,101,120,99,104,97,110,103,
-101,102,97,118,111,114,105,116,101,116,101,109,112,108,97,116,101,109,105,108,
-105,116,97,114,121,105,110,100,117,115,116,114,121,115,101,114,118,105,99,101,
-115,109,97,116,101,114,105,97,108,112,114,111,100,117,99,116,115,122,45,105,110,
-100,101,120,58,99,111,109,109,101,110,116,115,115,111,102,116,119,97,114,101,99,
-111,109,112,108,101,116,101,99,97,108,101,110,100,97,114,112,108,97,116,102,111,
-114,109,97,114,116,105,99,108,101,115,114,101,113,117,105,114,101,100,109,111,
-118,101,109,101,110,116,113,117,101,115,116,105,111,110,98,117,105,108,100,105,
-110,103,112,111,108,105,116,105,99,115,112,111,115,115,105,98,108,101,114,101,
-108,105,103,105,111,110,112,104,121,115,105,99,97,108,102,101,101,100,98,97,99,
-107,114,101,103,105,115,116,101,114,112,105,99,116,117,114,101,115,100,105,115,
-97,98,108,101,100,112,114,111,116,111,99,111,108,97,117,100,105,101,110,99,101,
-115,101,116,116,105,110,103,115,97,99,116,105,118,105,116,121,101,108,101,109,
-101,110,116,115,108,101,97,114,110,105,110,103,97,110,121,116,104,105,110,103,97
-,98,115,116,114,97,99,116,112,114,111,103,114,101,115,115,111,118,101,114,118,
-105,101,119,109,97,103,97,122,105,110,101,101,99,111,110,111,109,105,99,116,114,
-97,105,110,105,110,103,112,114,101,115,115,117,114,101,118,97,114,105,111,117,
-115,32,60,115,116,114,111,110,103,62,112,114,111,112,101,114,116,121,115,104,111
-,112,112,105,110,103,116,111,103,101,116,104,101,114,97,100,118,97,110,99,101,
-100,98,101,104,97,118,105,111,114,100,111,119,110,108,111,97,100,102,101,97,116,
-117,114,101,100,102,111,111,116,98,97,108,108,115,101,108,101,99,116,101,100,76,
-97,110,103,117,97,103,101,100,105,115,116,97,110,99,101,114,101,109,101,109,98,
-101,114,116,114,97,99,107,105,110,103,112,97,115,115,119,111,114,100,109,111,100
-,105,102,105,101,100,115,116,117,100,101,110,116,115,100,105,114,101,99,116,108,
-121,102,105,103,104,116,105,110,103,110,111,114,116,104,101,114,110,100,97,116,
-97,98,97,115,101,102,101,115,116,105,118,97,108,98,114,101,97,107,105,110,103,
-108,111,99,97,116,105,111,110,105,110,116,101,114,110,101,116,100,114,111,112,
-100,111,119,110,112,114,97,99,116,105,99,101,101,118,105,100,101,110,99,101,102,
-117,110,99,116,105,111,110,109,97,114,114,105,97,103,101,114,101,115,112,111,110
-,115,101,112,114,111,98,108,101,109,115,110,101,103,97,116,105,118,101,112,114,
-111,103,114,97,109,115,97,110,97,108,121,115,105,115,114,101,108,101,97,115,101,
-100,98,97,110,110,101,114,34,62,112,117,114,99,104,97,115,101,112,111,108,105,99
-,105,101,115,114,101,103,105,111,110,97,108,99,114,101,97,116,105,118,101,97,114
-,103,117,109,101,110,116,98,111,111,107,109,97,114,107,114,101,102,101,114,114,
-101,114,99,104,101,109,105,99,97,108,100,105,118,105,115,105,111,110,99,97,108,
-108,98,97,99,107,115,101,112,97,114,97,116,101,112,114,111,106,101,99,116,115,99
-,111,110,102,108,105,99,116,104,97,114,100,119,97,114,101,105,110,116,101,114,
-101,115,116,100,101,108,105,118,101,114,121,109,111,117,110,116,97,105,110,111,
-98,116,97,105,110,101,100,61,32,102,97,108,115,101,59,102,111,114,40,118,97,114,
-32,97,99,99,101,112,116,101,100,99,97,112,97,99,105,116,121,99,111,109,112,117,
-116,101,114,105,100,101,110,116,105,116,121,97,105,114,99,114,97,102,116,101,109
-,112,108,111,121,101,100,112,114,111,112,111,115,101,100,100,111,109,101,115,116
-,105,99,105,110,99,108,117,100,101,115,112,114,111,118,105,100,101,100,104,111,
-115,112,105,116,97,108,118,101,114,116,105,99,97,108,99,111,108,108,97,112,115,
-101,97,112,112,114,111,97,99,104,112,97,114,116,110,101,114,115,108,111,103,111,
-34,62,60,97,100,97,117,103,104,116,101,114,97,117,116,104,111,114,34,32,99,117,
-108,116,117,114,97,108,102,97,109,105,108,105,101,115,47,105,109,97,103,101,115,
-47,97,115,115,101,109,98,108,121,112,111,119,101,114,102,117,108,116,101,97,99,
-104,105,110,103,102,105,110,105,115,104,101,100,100,105,115,116,114,105,99,116,
-99,114,105,116,105,99,97,108,99,103,105,45,98,105,110,47,112,117,114,112,111,115
-,101,115,114,101,113,117,105,114,101,115,101,108,101,99,116,105,111,110,98,101,
-99,111,109,105,110,103,112,114,111,118,105,100,101,115,97,99,97,100,101,109,105,
-99,101,120,101,114,99,105,115,101,97,99,116,117,97,108,108,121,109,101,100,105,
-99,105,110,101,99,111,110,115,116,97,110,116,97,99,99,105,100,101,110,116,77,97,
-103,97,122,105,110,101,100,111,99,117,109,101,110,116,115,116,97,114,116,105,110
-,103,98,111,116,116,111,109,34,62,111,98,115,101,114,118,101,100,58,32,38,113,
-117,111,116,59,101,120,116,101,110,100,101,100,112,114,101,118,105,111,117,115,
-83,111,102,116,119,97,114,101,99,117,115,116,111,109,101,114,100,101,99,105,115,
-105,111,110,115,116,114,101,110,103,116,104,100,101,116,97,105,108,101,100,115,
-108,105,103,104,116,108,121,112,108,97,110,110,105,110,103,116,101,120,116,97,
-114,101,97,99,117,114,114,101,110,99,121,101,118,101,114,121,111,110,101,115,116
-,114,97,105,103,104,116,116,114,97,110,115,102,101,114,112,111,115,105,116,105,
-118,101,112,114,111,100,117,99,101,100,104,101,114,105,116,97,103,101,115,104,
-105,112,112,105,110,103,97,98,115,111,108,117,116,101,114,101,99,101,105,118,101
-,100,114,101,108,101,118,97,110,116,98,117,116,116,111,110,34,32,118,105,111,108
-,101,110,99,101,97,110,121,119,104,101,114,101,98,101,110,101,102,105,116,115,
-108,97,117,110,99,104,101,100,114,101,99,101,110,116,108,121,97,108,108,105,97,
-110,99,101,102,111,108,108,111,119,101,100,109,117,108,116,105,112,108,101,98,
-117,108,108,101,116,105,110,105,110,99,108,117,100,101,100,111,99,99,117,114,114
-,101,100,105,110,116,101,114,110,97,108,36,40,116,104,105,115,41,46,114,101,112,
-117,98,108,105,99,62,60,116,114,62,60,116,100,99,111,110,103,114,101,115,115,114
-,101,99,111,114,100,101,100,117,108,116,105,109,97,116,101,115,111,108,117,116,
-105,111,110,60,117,108,32,105,100,61,34,100,105,115,99,111,118,101,114,72,111,
-109,101,60,47,97,62,119,101,98,115,105,116,101,115,110,101,116,119,111,114,107,
-115,97,108,116,104,111,117,103,104,101,110,116,105,114,101,108,121,109,101,109,
-111,114,105,97,108,109,101,115,115,97,103,101,115,99,111,110,116,105,110,117,101
-,97,99,116,105,118,101,34,62,115,111,109,101,119,104,97,116,118,105,99,116,111,
-114,105,97,87,101,115,116,101,114,110,32,32,116,105,116,108,101,61,34,76,111,99,
-97,116,105,111,110,99,111,110,116,114,97,99,116,118,105,115,105,116,111,114,115,
-68,111,119,110,108,111,97,100,119,105,116,104,111,117,116,32,114,105,103,104,116
-,34,62,10,109,101,97,115,117,114,101,115,119,105,100,116,104,32,61,32,118,97,114
-,105,97,98,108,101,105,110,118,111,108,118,101,100,118,105,114,103,105,110,105,
-97,110,111,114,109,97,108,108,121,104,97,112,112,101,110,101,100,97,99,99,111,
-117,110,116,115,115,116,97,110,100,105,110,103,110,97,116,105,111,110,97,108,82,
-101,103,105,115,116,101,114,112,114,101,112,97,114,101,100,99,111,110,116,114,
-111,108,115,97,99,99,117,114,97,116,101,98,105,114,116,104,100,97,121,115,116,
-114,97,116,101,103,121,111,102,102,105,99,105,97,108,103,114,97,112,104,105,99,
-115,99,114,105,109,105,110,97,108,112,111,115,115,105,98,108,121,99,111,110,115,
-117,109,101,114,80,101,114,115,111,110,97,108,115,112,101,97,107,105,110,103,118
-,97,108,105,100,97,116,101,97,99,104,105,101,118,101,100,46,106,112,103,34,32,47
-,62,109,97,99,104,105,110,101,115,60,47,104,50,62,10,32,32,107,101,121,119,111,
-114,100,115,102,114,105,101,110,100,108,121,98,114,111,116,104,101,114,115,99,
-111,109,98,105,110,101,100,111,114,105,103,105,110,97,108,99,111,109,112,111,115
-,101,100,101,120,112,101,99,116,101,100,97,100,101,113,117,97,116,101,112,97,107
-,105,115,116,97,110,102,111,108,108,111,119,34,32,118,97,108,117,97,98,108,101,
-60,47,108,97,98,101,108,62,114,101,108,97,116,105,118,101,98,114,105,110,103,105
-,110,103,105,110,99,114,101,97,115,101,103,111,118,101,114,110,111,114,112,108,
-117,103,105,110,115,47,76,105,115,116,32,111,102,32,72,101,97,100,101,114,34,62,
-34,32,110,97,109,101,61,34,32,40,38,113,117,111,116,59,103,114,97,100,117,97,116
-,101,60,47,104,101,97,100,62,10,99,111,109,109,101,114,99,101,109,97,108,97,121,
-115,105,97,100,105,114,101,99,116,111,114,109,97,105,110,116,97,105,110,59,104,
-101,105,103,104,116,58,115,99,104,101,100,117,108,101,99,104,97,110,103,105,110,
-103,98,97,99,107,32,116,111,32,99,97,116,104,111,108,105,99,112,97,116,116,101,
-114,110,115,99,111,108,111,114,58,32,35,103,114,101,97,116,101,115,116,115,117,
-112,112,108,105,101,115,114,101,108,105,97,98,108,101,60,47,117,108,62,10,9,9,60
-,115,101,108,101,99,116,32,99,105,116,105,122,101,110,115,99,108,111,116,104,105
-,110,103,119,97,116,99,104,105,110,103,60,108,105,32,105,100,61,34,115,112,101,
-99,105,102,105,99,99,97,114,114,121,105,110,103,115,101,110,116,101,110,99,101,
-60,99,101,110,116,101,114,62,99,111,110,116,114,97,115,116,116,104,105,110,107,
-105,110,103,99,97,116,99,104,40,101,41,115,111,117,116,104,101,114,110,77,105,99
-,104,97,101,108,32,109,101,114,99,104,97,110,116,99,97,114,111,117,115,101,108,
-112,97,100,100,105,110,103,58,105,110,116,101,114,105,111,114,46,115,112,108,105
-,116,40,34,108,105,122,97,116,105,111,110,79,99,116,111,98,101,114,32,41,123,114
-,101,116,117,114,110,105,109,112,114,111,118,101,100,45,45,38,103,116,59,10,10,
-99,111,118,101,114,97,103,101,99,104,97,105,114,109,97,110,46,112,110,103,34,32,
-47,62,115,117,98,106,101,99,116,115,82,105,99,104,97,114,100,32,119,104,97,116,
-101,118,101,114,112,114,111,98,97,98,108,121,114,101,99,111,118,101,114,121,98,
-97,115,101,98,97,108,108,106,117,100,103,109,101,110,116,99,111,110,110,101,99,
-116,46,46,99,115,115,34,32,47,62,32,119,101,98,115,105,116,101,114,101,112,111,
-114,116,101,100,100,101,102,97,117,108,116,34,47,62,60,47,97,62,13,10,101,108,
-101,99,116,114,105,99,115,99,111,116,108,97,110,100,99,114,101,97,116,105,111,
-110,113,117,97,110,116,105,116,121,46,32,73,83,66,78,32,48,100,105,100,32,110,
-111,116,32,105,110,115,116,97,110,99,101,45,115,101,97,114,99,104,45,34,32,108,
-97,110,103,61,34,115,112,101,97,107,101,114,115,67,111,109,112,117,116,101,114,
-99,111,110,116,97,105,110,115,97,114,99,104,105,118,101,115,109,105,110,105,115,
-116,101,114,114,101,97,99,116,105,111,110,100,105,115,99,111,117,110,116,73,116,
-97,108,105,97,110,111,99,114,105,116,101,114,105,97,115,116,114,111,110,103,108,
-121,58,32,39,104,116,116,112,58,39,115,99,114,105,112,116,39,99,111,118,101,114,
-105,110,103,111,102,102,101,114,105,110,103,97,112,112,101,97,114,101,100,66,114
-,105,116,105,115,104,32,105,100,101,110,116,105,102,121,70,97,99,101,98,111,111,
-107,110,117,109,101,114,111,117,115,118,101,104,105,99,108,101,115,99,111,110,99
-,101,114,110,115,65,109,101,114,105,99,97,110,104,97,110,100,108,105,110,103,100
-,105,118,32,105,100,61,34,87,105,108,108,105,97,109,32,112,114,111,118,105,100,
-101,114,95,99,111,110,116,101,110,116,97,99,99,117,114,97,99,121,115,101,99,116,
-105,111,110,32,97,110,100,101,114,115,111,110,102,108,101,120,105,98,108,101,67,
-97,116,101,103,111,114,121,108,97,119,114,101,110,99,101,60,115,99,114,105,112,
-116,62,108,97,121,111,117,116,61,34,97,112,112,114,111,118,101,100,32,109,97,120
-,105,109,117,109,104,101,97,100,101,114,34,62,60,47,116,97,98,108,101,62,83,101,
-114,118,105,99,101,115,104,97,109,105,108,116,111,110,99,117,114,114,101,110,116
-,32,99,97,110,97,100,105,97,110,99,104,97,110,110,101,108,115,47,116,104,101,109
-,101,115,47,47,97,114,116,105,99,108,101,111,112,116,105,111,110,97,108,112,111,
-114,116,117,103,97,108,118,97,108,117,101,61,34,34,105,110,116,101,114,118,97,
-108,119,105,114,101,108,101,115,115,101,110,116,105,116,108,101,100,97,103,101,
-110,99,105,101,115,83,101,97,114,99,104,34,32,109,101,97,115,117,114,101,100,116
-,104,111,117,115,97,110,100,115,112,101,110,100,105,110,103,38,104,101,108,108,
-105,112,59,110,101,119,32,68,97,116,101,34,32,115,105,122,101,61,34,112,97,103,
-101,78,97,109,101,109,105,100,100,108,101,34,32,34,32,47,62,60,47,97,62,104,105,
-100,100,101,110,34,62,115,101,113,117,101,110,99,101,112,101,114,115,111,110,97,
-108,111,118,101,114,102,108,111,119,111,112,105,110,105,111,110,115,105,108,108,
-105,110,111,105,115,108,105,110,107,115,34,62,10,9,60,116,105,116,108,101,62,118
-,101,114,115,105,111,110,115,115,97,116,117,114,100,97,121,116,101,114,109,105,
-110,97,108,105,116,101,109,112,114,111,112,101,110,103,105,110,101,101,114,115,
-101,99,116,105,111,110,115,100,101,115,105,103,110,101,114,112,114,111,112,111,
-115,97,108,61,34,102,97,108,115,101,34,69,115,112,97,195,177,111,108,114,101,108
-,101,97,115,101,115,115,117,98,109,105,116,34,32,101,114,38,113,117,111,116,59,
-97,100,100,105,116,105,111,110,115,121,109,112,116,111,109,115,111,114,105,101,
-110,116,101,100,114,101,115,111,117,114,99,101,114,105,103,104,116,34,62,60,112,
-108,101,97,115,117,114,101,115,116,97,116,105,111,110,115,104,105,115,116,111,
-114,121,46,108,101,97,118,105,110,103,32,32,98,111,114,100,101,114,61,99,111,110
-,116,101,110,116,115,99,101,110,116,101,114,34,62,46,10,10,83,111,109,101,32,100
-,105,114,101,99,116,101,100,115,117,105,116,97,98,108,101,98,117,108,103,97,114,
-105,97,46,115,104,111,119,40,41,59,100,101,115,105,103,110,101,100,71,101,110,
-101,114,97,108,32,99,111,110,99,101,112,116,115,69,120,97,109,112,108,101,115,
-119,105,108,108,105,97,109,115,79,114,105,103,105,110,97,108,34,62,60,115,112,97
-,110,62,115,101,97,114,99,104,34,62,111,112,101,114,97,116,111,114,114,101,113,
-117,101,115,116,115,97,32,38,113,117,111,116,59,97,108,108,111,119,105,110,103,
-68,111,99,117,109,101,110,116,114,101,118,105,115,105,111,110,46,32,10,10,84,104
-,101,32,121,111,117,114,115,101,108,102,67,111,110,116,97,99,116,32,109,105,99,
-104,105,103,97,110,69,110,103,108,105,115,104,32,99,111,108,117,109,98,105,97,
-112,114,105,111,114,105,116,121,112,114,105,110,116,105,110,103,100,114,105,110,
-107,105,110,103,102,97,99,105,108,105,116,121,114,101,116,117,114,110,101,100,67
-,111,110,116,101,110,116,32,111,102,102,105,99,101,114,115,82,117,115,115,105,97
-,110,32,103,101,110,101,114,97,116,101,45,56,56,53,57,45,49,34,105,110,100,105,
-99,97,116,101,102,97,109,105,108,105,97,114,32,113,117,97,108,105,116,121,109,97
-,114,103,105,110,58,48,32,99,111,110,116,101,110,116,118,105,101,119,112,111,114
-,116,99,111,110,116,97,99,116,115,45,116,105,116,108,101,34,62,112,111,114,116,
-97,98,108,101,46,108,101,110,103,116,104,32,101,108,105,103,105,98,108,101,105,
-110,118,111,108,118,101,115,97,116,108,97,110,116,105,99,111,110,108,111,97,100,
-61,34,100,101,102,97,117,108,116,46,115,117,112,112,108,105,101,100,112,97,121,
-109,101,110,116,115,103,108,111,115,115,97,114,121,10,10,65,102,116,101,114,32,
-103,117,105,100,97,110,99,101,60,47,116,100,62,60,116,100,101,110,99,111,100,105
-,110,103,109,105,100,100,108,101,34,62,99,97,109,101,32,116,111,32,100,105,115,
-112,108,97,121,115,115,99,111,116,116,105,115,104,106,111,110,97,116,104,97,110,
-109,97,106,111,114,105,116,121,119,105,100,103,101,116,115,46,99,108,105,110,105
-,99,97,108,116,104,97,105,108,97,110,100,116,101,97,99,104,101,114,115,60,104,
-101,97,100,62,10,9,97,102,102,101,99,116,101,100,115,117,112,112,111,114,116,115
-,112,111,105,110,116,101,114,59,116,111,83,116,114,105,110,103,60,47,115,109,97,
-108,108,62,111,107,108,97,104,111,109,97,119,105,108,108,32,98,101,32,105,110,
-118,101,115,116,111,114,48,34,32,97,108,116,61,34,104,111,108,105,100,97,121,115
-,82,101,115,111,117,114,99,101,108,105,99,101,110,115,101,100,32,40,119,104,105,
-99,104,32,46,32,65,102,116,101,114,32,99,111,110,115,105,100,101,114,118,105,115
-,105,116,105,110,103,101,120,112,108,111,114,101,114,112,114,105,109,97,114,121,
-32,115,101,97,114,99,104,34,32,97,110,100,114,111,105,100,34,113,117,105,99,107,
-108,121,32,109,101,101,116,105,110,103,115,101,115,116,105,109,97,116,101,59,114
-,101,116,117,114,110,32,59,99,111,108,111,114,58,35,32,104,101,105,103,104,116,
-61,97,112,112,114,111,118,97,108,44,32,38,113,117,111,116,59,32,99,104,101,99,
-107,101,100,46,109,105,110,46,106,115,34,109,97,103,110,101,116,105,99,62,60,47,
-97,62,60,47,104,102,111,114,101,99,97,115,116,46,32,87,104,105,108,101,32,116,
-104,117,114,115,100,97,121,100,118,101,114,116,105,115,101,38,101,97,99,117,116,
-101,59,104,97,115,67,108,97,115,115,101,118,97,108,117,97,116,101,111,114,100,
-101,114,105,110,103,101,120,105,115,116,105,110,103,112,97,116,105,101,110,116,
-115,32,79,110,108,105,110,101,32,99,111,108,111,114,97,100,111,79,112,116,105,
-111,110,115,34,99,97,109,112,98,101,108,108,60,33,45,45,32,101,110,100,60,47,115
-,112,97,110,62,60,60,98,114,32,47,62,13,10,95,112,111,112,117,112,115,124,115,99
-,105,101,110,99,101,115,44,38,113,117,111,116,59,32,113,117,97,108,105,116,121,
-32,87,105,110,100,111,119,115,32,97,115,115,105,103,110,101,100,104,101,105,103,
-104,116,58,32,60,98,32,99,108,97,115,115,108,101,38,113,117,111,116,59,32,118,97
-,108,117,101,61,34,32,67,111,109,112,97,110,121,101,120,97,109,112,108,101,115,
-60,105,102,114,97,109,101,32,98,101,108,105,101,118,101,115,112,114,101,115,101,
-110,116,115,109,97,114,115,104,97,108,108,112,97,114,116,32,111,102,32,112,114,
-111,112,101,114,108,121,41,46,10,10,84,104,101,32,116,97,120,111,110,111,109,121
-,109,117,99,104,32,111,102,32,60,47,115,112,97,110,62,10,34,32,100,97,116,97,45,
-115,114,116,117,103,117,195,170,115,115,99,114,111,108,108,84,111,32,112,114,111
-,106,101,99,116,60,104,101,97,100,62,13,10,97,116,116,111,114,110,101,121,101,
-109,112,104,97,115,105,115,115,112,111,110,115,111,114,115,102,97,110,99,121,98,
-111,120,119,111,114,108,100,39,115,32,119,105,108,100,108,105,102,101,99,104,101
-,99,107,101,100,61,115,101,115,115,105,111,110,115,112,114,111,103,114,97,109,
-109,112,120,59,102,111,110,116,45,32,80,114,111,106,101,99,116,106,111,117,114,
-110,97,108,115,98,101,108,105,101,118,101,100,118,97,99,97,116,105,111,110,116,
-104,111,109,112,115,111,110,108,105,103,104,116,105,110,103,97,110,100,32,116,
-104,101,32,115,112,101,99,105,97,108,32,98,111,114,100,101,114,61,48,99,104,101,
-99,107,105,110,103,60,47,116,98,111,100,121,62,60,98,117,116,116,111,110,32,67,
-111,109,112,108,101,116,101,99,108,101,97,114,102,105,120,10,60,104,101,97,100,
-62,10,97,114,116,105,99,108,101,32,60,115,101,99,116,105,111,110,102,105,110,100
-,105,110,103,115,114,111,108,101,32,105,110,32,112,111,112,117,108,97,114,32,32,
-79,99,116,111,98,101,114,119,101,98,115,105,116,101,32,101,120,112,111,115,117,
-114,101,117,115,101,100,32,116,111,32,32,99,104,97,110,103,101,115,111,112,101,
-114,97,116,101,100,99,108,105,99,107,105,110,103,101,110,116,101,114,105,110,103
-,99,111,109,109,97,110,100,115,105,110,102,111,114,109,101,100,32,110,117,109,98
-,101,114,115,32,32,60,47,100,105,118,62,99,114,101,97,116,105,110,103,111,110,83
-,117,98,109,105,116,109,97,114,121,108,97,110,100,99,111,108,108,101,103,101,115
-,97,110,97,108,121,116,105,99,108,105,115,116,105,110,103,115,99,111,110,116,97,
-99,116,46,108,111,103,103,101,100,73,110,97,100,118,105,115,111,114,121,115,105,
-98,108,105,110,103,115,99,111,110,116,101,110,116,34,115,38,113,117,111,116,59,
-41,115,46,32,84,104,105,115,32,112,97,99,107,97,103,101,115,99,104,101,99,107,98
-,111,120,115,117,103,103,101,115,116,115,112,114,101,103,110,97,110,116,116,111,
-109,111,114,114,111,119,115,112,97,99,105,110,103,61,105,99,111,110,46,112,110,
-103,106,97,112,97,110,101,115,101,99,111,100,101,98,97,115,101,98,117,116,116,
-111,110,34,62,103,97,109,98,108,105,110,103,115,117,99,104,32,97,115,32,44,32,
-119,104,105,108,101,32,60,47,115,112,97,110,62,32,109,105,115,115,111,117,114,
-105,115,112,111,114,116,105,110,103,116,111,112,58,49,112,120,32,46,60,47,115,
-112,97,110,62,116,101,110,115,105,111,110,115,119,105,100,116,104,61,34,50,108,
-97,122,121,108,111,97,100,110,111,118,101,109,98,101,114,117,115,101,100,32,105,
-110,32,104,101,105,103,104,116,61,34,99,114,105,112,116,34,62,10,38,110,98,115,
-112,59,60,47,60,116,114,62,60,116,100,32,104,101,105,103,104,116,58,50,47,112,
-114,111,100,117,99,116,99,111,117,110,116,114,121,32,105,110,99,108,117,100,101,
-32,102,111,111,116,101,114,34,32,38,108,116,59,33,45,45,32,116,105,116,108,101,
-34,62,60,47,106,113,117,101,114,121,46,60,47,102,111,114,109,62,10,40,231,174,
-128,228,189,147,41,40,231,185,129,233,171,148,41,104,114,118,97,116,115,107,105,
-105,116,97,108,105,97,110,111,114,111,109,195,162,110,196,131,116,195,188,114,
-107,195,167,101,216,167,216,177,216,175,217,136,116,97,109,98,105,195,169,110,
-110,111,116,105,99,105,97,115,109,101,110,115,97,106,101,115,112,101,114,115,111
-,110,97,115,100,101,114,101,99,104,111,115,110,97,99,105,111,110,97,108,115,101,
-114,118,105,99,105,111,99,111,110,116,97,99,116,111,117,115,117,97,114,105,111,
-115,112,114,111,103,114,97,109,97,103,111,98,105,101,114,110,111,101,109,112,114
-,101,115,97,115,97,110,117,110,99,105,111,115,118,97,108,101,110,99,105,97,99,
-111,108,111,109,98,105,97,100,101,115,112,117,195,169,115,100,101,112,111,114,
-116,101,115,112,114,111,121,101,99,116,111,112,114,111,100,117,99,116,111,112,
-195,186,98,108,105,99,111,110,111,115,111,116,114,111,115,104,105,115,116,111,
-114,105,97,112,114,101,115,101,110,116,101,109,105,108,108,111,110,101,115,109,
-101,100,105,97,110,116,101,112,114,101,103,117,110,116,97,97,110,116,101,114,105
-,111,114,114,101,99,117,114,115,111,115,112,114,111,98,108,101,109,97,115,97,110
-,116,105,97,103,111,110,117,101,115,116,114,111,115,111,112,105,110,105,195,179,
-110,105,109,112,114,105,109,105,114,109,105,101,110,116,114,97,115,97,109,195,
-169,114,105,99,97,118,101,110,100,101,100,111,114,115,111,99,105,101,100,97,100,
-114,101,115,112,101,99,116,111,114,101,97,108,105,122,97,114,114,101,103,105,115
-,116,114,111,112,97,108,97,98,114,97,115,105,110,116,101,114,195,169,115,101,110
-,116,111,110,99,101,115,101,115,112,101,99,105,97,108,109,105,101,109,98,114,111
-,115,114,101,97,108,105,100,97,100,99,195,179,114,100,111,98,97,122,97,114,97,
-103,111,122,97,112,195,161,103,105,110,97,115,115,111,99,105,97,108,101,115,98,
-108,111,113,117,101,97,114,103,101,115,116,105,195,179,110,97,108,113,117,105,
-108,101,114,115,105,115,116,101,109,97,115,99,105,101,110,99,105,97,115,99,111,
-109,112,108,101,116,111,118,101,114,115,105,195,179,110,99,111,109,112,108,101,
-116,97,101,115,116,117,100,105,111,115,112,195,186,98,108,105,99,97,111,98,106,
-101,116,105,118,111,97,108,105,99,97,110,116,101,98,117,115,99,97,100,111,114,99
-,97,110,116,105,100,97,100,101,110,116,114,97,100,97,115,97,99,99,105,111,110,
-101,115,97,114,99,104,105,118,111,115,115,117,112,101,114,105,111,114,109,97,121
-,111,114,195,173,97,97,108,101,109,97,110,105,97,102,117,110,99,105,195,179,110,
-195,186,108,116,105,109,111,115,104,97,99,105,101,110,100,111,97,113,117,101,108
-,108,111,115,101,100,105,99,105,195,179,110,102,101,114,110,97,110,100,111,97,
-109,98,105,101,110,116,101,102,97,99,101,98,111,111,107,110,117,101,115,116,114,
-97,115,99,108,105,101,110,116,101,115,112,114,111,99,101,115,111,115,98,97,115,
-116,97,110,116,101,112,114,101,115,101,110,116,97,114,101,112,111,114,116,97,114
-,99,111,110,103,114,101,115,111,112,117,98,108,105,99,97,114,99,111,109,101,114,
-99,105,111,99,111,110,116,114,97,116,111,106,195,179,118,101,110,101,115,100,105
-,115,116,114,105,116,111,116,195,169,99,110,105,99,97,99,111,110,106,117,110,116
-,111,101,110,101,114,103,195,173,97,116,114,97,98,97,106,97,114,97,115,116,117,
-114,105,97,115,114,101,99,105,101,110,116,101,117,116,105,108,105,122,97,114,98,
-111,108,101,116,195,173,110,115,97,108,118,97,100,111,114,99,111,114,114,101,99,
-116,97,116,114,97,98,97,106,111,115,112,114,105,109,101,114,111,115,110,101,103,
-111,99,105,111,115,108,105,98,101,114,116,97,100,100,101,116,97,108,108,101,115,
-112,97,110,116,97,108,108,97,112,114,195,179,120,105,109,111,97,108,109,101,114,
-195,173,97,97,110,105,109,97,108,101,115,113,117,105,195,169,110,101,115,99,111,
-114,97,122,195,179,110,115,101,99,99,105,195,179,110,98,117,115,99,97,110,100,
-111,111,112,99,105,111,110,101,115,101,120,116,101,114,105,111,114,99,111,110,99
-,101,112,116,111,116,111,100,97,118,195,173,97,103,97,108,101,114,195,173,97,101
-,115,99,114,105,98,105,114,109,101,100,105,99,105,110,97,108,105,99,101,110,99,
-105,97,99,111,110,115,117,108,116,97,97,115,112,101,99,116,111,115,99,114,195,
-173,116,105,99,97,100,195,179,108,97,114,101,115,106,117,115,116,105,99,105,97,
-100,101,98,101,114,195,161,110,112,101,114,195,173,111,100,111,110,101,99,101,
-115,105,116,97,109,97,110,116,101,110,101,114,112,101,113,117,101,195,177,111,
-114,101,99,105,98,105,100,97,116,114,105,98,117,110,97,108,116,101,110,101,114,
-105,102,101,99,97,110,99,105,195,179,110,99,97,110,97,114,105,97,115,100,101,115
-,99,97,114,103,97,100,105,118,101,114,115,111,115,109,97,108,108,111,114,99,97,
-114,101,113,117,105,101,114,101,116,195,169,99,110,105,99,111,100,101,98,101,114
-,195,173,97,118,105,118,105,101,110,100,97,102,105,110,97,110,122,97,115,97,100,
-101,108,97,110,116,101,102,117,110,99,105,111,110,97,99,111,110,115,101,106,111,
-115,100,105,102,195,173,99,105,108,99,105,117,100,97,100,101,115,97,110,116,105,
-103,117,97,115,97,118,97,110,122,97,100,97,116,195,169,114,109,105,110,111,117,
-110,105,100,97,100,101,115,115,195,161,110,99,104,101,122,99,97,109,112,97,195,
-177,97,115,111,102,116,111,110,105,99,114,101,118,105,115,116,97,115,99,111,110,
-116,105,101,110,101,115,101,99,116,111,114,101,115,109,111,109,101,110,116,111,
-115,102,97,99,117,108,116,97,100,99,114,195,169,100,105,116,111,100,105,118,101,
-114,115,97,115,115,117,112,117,101,115,116,111,102,97,99,116,111,114,101,115,115
-,101,103,117,110,100,111,115,112,101,113,117,101,195,177,97,208,179,208,190,208,
-180,208,176,208,181,209,129,208,187,208,184,208,181,209,129,209,130,209,140,208,
-177,209,139,208,187,208,190,208,177,209,139,209,130,209,140,209,141,209,130,208,
-190,208,188,208,149,209,129,208,187,208,184,209,130,208,190,208,179,208,190,208,
-188,208,181,208,189,209,143,208,178,209,129,208,181,209,133,209,141,209,130,208,
-190,208,185,208,180,208,176,208,182,208,181,208,177,209,139,208,187,208,184,208,
-179,208,190,208,180,209,131,208,180,208,181,208,189,209,140,209,141,209,130,208,
-190,209,130,208,177,209,139,208,187,208,176,209,129,208,181,208,177,209,143,208,
-190,208,180,208,184,208,189,209,129,208,181,208,177,208,181,208,189,208,176,208,
-180,208,190,209,129,208,176,208,185,209,130,209,132,208,190,209,130,208,190,208,
-189,208,181,208,179,208,190,209,129,208,178,208,190,208,184,209,129,208,178,208,
-190,208,185,208,184,208,179,209,128,209,139,209,130,208,190,208,182,208,181,208,
-178,209,129,208,181,208,188,209,129,208,178,208,190,209,142,208,187,208,184,209,
-136,209,140,209,141,209,130,208,184,209,133,208,191,208,190,208,186,208,176,208,
-180,208,189,208,181,208,185,208,180,208,190,208,188,208,176,208,188,208,184,209,
-128,208,176,208,187,208,184,208,177,208,190,209,130,208,181,208,188,209,131,209,
-133,208,190,209,130,209,143,208,180,208,178,209,131,209,133,209,129,208,181,209,
-130,208,184,208,187,209,142,208,180,208,184,208,180,208,181,208,187,208,190,208,
-188,208,184,209,128,208,181,209,130,208,181,208,177,209,143,209,129,208,178,208,
-190,208,181,208,178,208,184,208,180,208,181,209,135,208,181,208,179,208,190,209,
-141,209,130,208,184,208,188,209,129,209,135,208,181,209,130,209,130,208,181,208,
-188,209,139,209,134,208,181,208,189,209,139,209,129,209,130,208,176,208,187,208,
-178,208,181,208,180,209,140,209,130,208,181,208,188,208,181,208,178,208,190,208,
-180,209,139,209,130,208,181,208,177,208,181,208,178,209,139,209,136,208,181,208,
-189,208,176,208,188,208,184,209,130,208,184,208,191,208,176,209,130,208,190,208,
-188,209,131,208,191,209,128,208,176,208,178,208,187,208,184,209,134,208,176,208,
-190,208,180,208,189,208,176,208,179,208,190,208,180,209,139,208,183,208,189,208,
-176,209,142,208,188,208,190,208,179,209,131,208,180,209,128,209,131,208,179,208,
-178,209,129,208,181,208,185,208,184,208,180,208,181,209,130,208,186,208,184,208,
-189,208,190,208,190,208,180,208,189,208,190,208,180,208,181,208,187,208,176,208,
-180,208,181,208,187,208,181,209,129,209,128,208,190,208,186,208,184,209,142,208,
-189,209,143,208,178,208,181,209,129,209,140,208,149,209,129,209,130,209,140,209,
-128,208,176,208,183,208,176,208,189,208,176,209,136,208,184,216,167,217,132,217,
-132,217,135,216,167,217,132,216,170,217,138,216,172,217,133,217,138,216,185,216,
-174,216,167,216,181,216,169,216,167,217,132,216,176,217,138,216,185,217,132,217,
-138,217,135,216,172,216,175,217,138,216,175,216,167,217,132,216,162,217,134,216,
-167,217,132,216,177,216,175,216,170,216,173,217,131,217,133,216,181,217,129,216,
-173,216,169,217,131,216,167,217,134,216,170,216,167,217,132,217,132,217,138,217,
-138,217,131,217,136,217,134,216,180,216,168,217,131,216,169,217,129,217,138,217,
-135,216,167,216,168,217,134,216,167,216,170,216,173,217,136,216,167,216,161,216,
-163,217,131,216,171,216,177,216,174,217,132,216,167,217,132,216,167,217,132,216,
-173,216,168,216,175,217,132,217,138,217,132,216,175,216,177,217,136,216,179,216,
-167,216,182,216,186,216,183,216,170,217,131,217,136,217,134,217,135,217,134,216,
-167,217,131,216,179,216,167,216,173,216,169,217,134,216,167,216,175,217,138,216,
-167,217,132,216,183,216,168,216,185,217,132,217,138,217,131,216,180,217,131,216,
-177,216,167,217,138,217,133,217,131,217,134,217,133,217,134,217,135,216,167,216,
-180,216,177,217,131,216,169,216,177,216,166,217,138,216,179,217,134,216,180,217,
-138,216,183,217,133,216,167,216,176,216,167,216,167,217,132,217,129,217,134,216,
-180,216,168,216,167,216,168,216,170,216,185,216,168,216,177,216,177,216,173,217,
-133,216,169,217,131,216,167,217,129,216,169,217,138,217,130,217,136,217,132,217,
-133,216,177,217,131,216,178,217,131,217,132,217,133,216,169,216,163,216,173,217,
-133,216,175,217,130,217,132,216,168,217,138,217,138,216,185,217,134,217,138,216,
-181,217,136,216,177,216,169,216,183,216,177,217,138,217,130,216,180,216,167,216,
-177,217,131,216,172,217,136,216,167,217,132,216,163,216,174,216,177,217,137,217,
-133,216,185,217,134,216,167,216,167,216,168,216,173,216,171,216,185,216,177,217,
-136,216,182,216,168,216,180,217,131,217,132,217,133,216,179,216,172,217,132,216,
-168,217,134,216,167,217,134,216,174,216,167,217,132,216,175,217,131,216,170,216,
-167,216,168,217,131,217,132,217,138,216,169,216,168,216,175,217,136,217,134,216,
-163,217,138,216,182,216,167,217,138,217,136,216,172,216,175,217,129,216,177,217,
-138,217,130,217,131,216,170,216,168,216,170,216,163,217,129,216,182,217,132,217,
-133,216,183,216,168,216,174,216,167,217,131,216,171,216,177,216,168,216,167,216,
-177,217,131,216,167,217,129,216,182,217,132,216,167,216,173,217,132,217,137,217,
-134,217,129,216,179,217,135,216,163,217,138,216,167,217,133,216,177,216,175,217,
-136,216,175,216,163,217,134,217,135,216,167,216,175,217,138,217,134,216,167,216,
-167,217,132,216,167,217,134,217,133,216,185,216,177,216,182,216,170,216,185,217,
-132,217,133,216,175,216,167,216,174,217,132,217,133,217,133,217,131,217,134,0,0,
-0,0,0,0,0,0,1,0,1,0,1,0,1,0,2,0,2,0,2,0,2,0,4,0,4,0,4,0,4,0,0,1,2,3,4,5,6,7,7,6,
-5,4,3,2,1,0,8,9,10,11,12,13,14,15,15,14,13,12,11,10,9,8,16,17,18,19,20,21,22,23,
-23,22,21,20,19,18,17,16,24,25,26,27,28,29,30,31,31,30,29,28,27,26,25,24,255,255,
-255,255,0,0,0,0,0,0,0,0,255,255,255,255,1,0,0,0,2,0,0,0,2,0,0,0,1,0,0,0,1,0,0,0,
-3,0,0,0,255,255,0,1,0,0,0,1,0,0,255,255,0,1,0,0,0,8,0,8,0,8,0,8,0,0,0,1,0,2,0,3,
-0,4,0,5,0,6,0,7,114,101,115,111,117,114,99,101,115,99,111,117,110,116,114,105,
-101,115,113,117,101,115,116,105,111,110,115,101,113,117,105,112,109,101,110,116,
-99,111,109,109,117,110,105,116,121,97,118,97,105,108,97,98,108,101,104,105,103,
-104,108,105,103,104,116,68,84,68,47,120,104,116,109,108,109,97,114,107,101,116,
-105,110,103,107,110,111,119,108,101,100,103,101,115,111,109,101,116,104,105,110,
-103,99,111,110,116,97,105,110,101,114,100,105,114,101,99,116,105,111,110,115,117
-,98,115,99,114,105,98,101,97,100,118,101,114,116,105,115,101,99,104,97,114,97,99
-,116,101,114,34,32,118,97,108,117,101,61,34,60,47,115,101,108,101,99,116,62,65,
-117,115,116,114,97,108,105,97,34,32,99,108,97,115,115,61,34,115,105,116,117,97,
-116,105,111,110,97,117,116,104,111,114,105,116,121,102,111,108,108,111,119,105,
-110,103,112,114,105,109,97,114,105,108,121,111,112,101,114,97,116,105,111,110,99
-,104,97,108,108,101,110,103,101,100,101,118,101,108,111,112,101,100,97,110,111,
-110,121,109,111,117,115,102,117,110,99,116,105,111,110,32,102,117,110,99,116,105
-,111,110,115,99,111,109,112,97,110,105,101,115,115,116,114,117,99,116,117,114,
-101,97,103,114,101,101,109,101,110,116,34,32,116,105,116,108,101,61,34,112,111,
-116,101,110,116,105,97,108,101,100,117,99,97,116,105,111,110,97,114,103,117,109,
-101,110,116,115,115,101,99,111,110,100,97,114,121,99,111,112,121,114,105,103,104
-,116,108,97,110,103,117,97,103,101,115,101,120,99,108,117,115,105,118,101,99,111
-,110,100,105,116,105,111,110,60,47,102,111,114,109,62,13,10,115,116,97,116,101,
-109,101,110,116,97,116,116,101,110,116,105,111,110,66,105,111,103,114,97,112,104
-,121,125,32,101,108,115,101,32,123,10,115,111,108,117,116,105,111,110,115,119,
-104,101,110,32,116,104,101,32,65,110,97,108,121,116,105,99,115,116,101,109,112,
-108,97,116,101,115,100,97,110,103,101,114,111,117,115,115,97,116,101,108,108,105
-,116,101,100,111,99,117,109,101,110,116,115,112,117,98,108,105,115,104,101,114,
-105,109,112,111,114,116,97,110,116,112,114,111,116,111,116,121,112,101,105,110,
-102,108,117,101,110,99,101,38,114,97,113,117,111,59,60,47,101,102,102,101,99,116
-,105,118,101,103,101,110,101,114,97,108,108,121,116,114,97,110,115,102,111,114,
-109,98,101,97,117,116,105,102,117,108,116,114,97,110,115,112,111,114,116,111,114
-,103,97,110,105,122,101,100,112,117,98,108,105,115,104,101,100,112,114,111,109,
-105,110,101,110,116,117,110,116,105,108,32,116,104,101,116,104,117,109,98,110,97
-,105,108,78,97,116,105,111,110,97,108,32,46,102,111,99,117,115,40,41,59,111,118,
-101,114,32,116,104,101,32,109,105,103,114,97,116,105,111,110,97,110,110,111,117,
-110,99,101,100,102,111,111,116,101,114,34,62,10,101,120,99,101,112,116,105,111,
-110,108,101,115,115,32,116,104,97,110,101,120,112,101,110,115,105,118,101,102,
-111,114,109,97,116,105,111,110,102,114,97,109,101,119,111,114,107,116,101,114,
-114,105,116,111,114,121,110,100,105,99,97,116,105,111,110,99,117,114,114,101,110
-,116,108,121,99,108,97,115,115,78,97,109,101,99,114,105,116,105,99,105,115,109,
-116,114,97,100,105,116,105,111,110,101,108,115,101,119,104,101,114,101,65,108,
-101,120,97,110,100,101,114,97,112,112,111,105,110,116,101,100,109,97,116,101,114
-,105,97,108,115,98,114,111,97,100,99,97,115,116,109,101,110,116,105,111,110,101,
-100,97,102,102,105,108,105,97,116,101,60,47,111,112,116,105,111,110,62,116,114,
-101,97,116,109,101,110,116,100,105,102,102,101,114,101,110,116,47,100,101,102,97
-,117,108,116,46,80,114,101,115,105,100,101,110,116,111,110,99,108,105,99,107,61,
-34,98,105,111,103,114,97,112,104,121,111,116,104,101,114,119,105,115,101,112,101
-,114,109,97,110,101,110,116,70,114,97,110,195,167,97,105,115,72,111,108,108,121,
-119,111,111,100,101,120,112,97,110,115,105,111,110,115,116,97,110,100,97,114,100
-,115,60,47,115,116,121,108,101,62,10,114,101,100,117,99,116,105,111,110,68,101,
-99,101,109,98,101,114,32,112,114,101,102,101,114,114,101,100,67,97,109,98,114,
-105,100,103,101,111,112,112,111,110,101,110,116,115,66,117,115,105,110,101,115,
-115,32,99,111,110,102,117,115,105,111,110,62,10,60,116,105,116,108,101,62,112,
-114,101,115,101,110,116,101,100,101,120,112,108,97,105,110,101,100,100,111,101,
-115,32,110,111,116,32,119,111,114,108,100,119,105,100,101,105,110,116,101,114,
-102,97,99,101,112,111,115,105,116,105,111,110,115,110,101,119,115,112,97,112,101
-,114,60,47,116,97,98,108,101,62,10,109,111,117,110,116,97,105,110,115,108,105,
-107,101,32,116,104,101,32,101,115,115,101,110,116,105,97,108,102,105,110,97,110,
-99,105,97,108,115,101,108,101,99,116,105,111,110,97,99,116,105,111,110,61,34,47,
-97,98,97,110,100,111,110,101,100,69,100,117,99,97,116,105,111,110,112,97,114,115
-,101,73,110,116,40,115,116,97,98,105,108,105,116,121,117,110,97,98,108,101,32,
-116,111,60,47,116,105,116,108,101,62,10,114,101,108,97,116,105,111,110,115,78,
-111,116,101,32,116,104,97,116,101,102,102,105,99,105,101,110,116,112,101,114,102
-,111,114,109,101,100,116,119,111,32,121,101,97,114,115,83,105,110,99,101,32,116,
-104,101,116,104,101,114,101,102,111,114,101,119,114,97,112,112,101,114,34,62,97,
-108,116,101,114,110,97,116,101,105,110,99,114,101,97,115,101,100,66,97,116,116,
-108,101,32,111,102,112,101,114,99,101,105,118,101,100,116,114,121,105,110,103,32
-,116,111,110,101,99,101,115,115,97,114,121,112,111,114,116,114,97,121,101,100,
-101,108,101,99,116,105,111,110,115,69,108,105,122,97,98,101,116,104,60,47,105,
-102,114,97,109,101,62,100,105,115,99,111,118,101,114,121,105,110,115,117,114,97,
-110,99,101,115,46,108,101,110,103,116,104,59,108,101,103,101,110,100,97,114,121,
-71,101,111,103,114,97,112,104,121,99,97,110,100,105,100,97,116,101,99,111,114,
-112,111,114,97,116,101,115,111,109,101,116,105,109,101,115,115,101,114,118,105,
-99,101,115,46,105,110,104,101,114,105,116,101,100,60,47,115,116,114,111,110,103,
-62,67,111,109,109,117,110,105,116,121,114,101,108,105,103,105,111,117,115,108,
-111,99,97,116,105,111,110,115,67,111,109,109,105,116,116,101,101,98,117,105,108,
-100,105,110,103,115,116,104,101,32,119,111,114,108,100,110,111,32,108,111,110,
-103,101,114,98,101,103,105,110,110,105,110,103,114,101,102,101,114,101,110,99,
-101,99,97,110,110,111,116,32,98,101,102,114,101,113,117,101,110,99,121,116,121,
-112,105,99,97,108,108,121,105,110,116,111,32,116,104,101,32,114,101,108,97,116,
-105,118,101,59,114,101,99,111,114,100,105,110,103,112,114,101,115,105,100,101,
-110,116,105,110,105,116,105,97,108,108,121,116,101,99,104,110,105,113,117,101,
-116,104,101,32,111,116,104,101,114,105,116,32,99,97,110,32,98,101,101,120,105,
-115,116,101,110,99,101,117,110,100,101,114,108,105,110,101,116,104,105,115,32,
-116,105,109,101,116,101,108,101,112,104,111,110,101,105,116,101,109,115,99,111,
-112,101,112,114,97,99,116,105,99,101,115,97,100,118,97,110,116,97,103,101,41,59,
-114,101,116,117,114,110,32,70,111,114,32,111,116,104,101,114,112,114,111,118,105
-,100,105,110,103,100,101,109,111,99,114,97,99,121,98,111,116,104,32,116,104,101,
-32,101,120,116,101,110,115,105,118,101,115,117,102,102,101,114,105,110,103,115,
-117,112,112,111,114,116,101,100,99,111,109,112,117,116,101,114,115,32,102,117,
-110,99,116,105,111,110,112,114,97,99,116,105,99,97,108,115,97,105,100,32,116,104
-,97,116,105,116,32,109,97,121,32,98,101,69,110,103,108,105,115,104,60,47,102,114
-,111,109,32,116,104,101,32,115,99,104,101,100,117,108,101,100,100,111,119,110,
-108,111,97,100,115,60,47,108,97,98,101,108,62,10,115,117,115,112,101,99,116,101,
-100,109,97,114,103,105,110,58,32,48,115,112,105,114,105,116,117,97,108,60,47,104
-,101,97,100,62,10,10,109,105,99,114,111,115,111,102,116,103,114,97,100,117,97,
-108,108,121,100,105,115,99,117,115,115,101,100,104,101,32,98,101,99,97,109,101,
-101,120,101,99,117,116,105,118,101,106,113,117,101,114,121,46,106,115,104,111,
-117,115,101,104,111,108,100,99,111,110,102,105,114,109,101,100,112,117,114,99,
-104,97,115,101,100,108,105,116,101,114,97,108,108,121,100,101,115,116,114,111,
-121,101,100,117,112,32,116,111,32,116,104,101,118,97,114,105,97,116,105,111,110,
-114,101,109,97,105,110,105,110,103,105,116,32,105,115,32,110,111,116,99,101,110,
-116,117,114,105,101,115,74,97,112,97,110,101,115,101,32,97,109,111,110,103,32,
-116,104,101,99,111,109,112,108,101,116,101,100,97,108,103,111,114,105,116,104,
-109,105,110,116,101,114,101,115,116,115,114,101,98,101,108,108,105,111,110,117,
-110,100,101,102,105,110,101,100,101,110,99,111,117,114,97,103,101,114,101,115,
-105,122,97,98,108,101,105,110,118,111,108,118,105,110,103,115,101,110,115,105,
-116,105,118,101,117,110,105,118,101,114,115,97,108,112,114,111,118,105,115,105,
-111,110,40,97,108,116,104,111,117,103,104,102,101,97,116,117,114,105,110,103,99,
-111,110,100,117,99,116,101,100,41,44,32,119,104,105,99,104,32,99,111,110,116,105
-,110,117,101,100,45,104,101,97,100,101,114,34,62,70,101,98,114,117,97,114,121,32
-,110,117,109,101,114,111,117,115,32,111,118,101,114,102,108,111,119,58,99,111,
-109,112,111,110,101,110,116,102,114,97,103,109,101,110,116,115,101,120,99,101,
-108,108,101,110,116,99,111,108,115,112,97,110,61,34,116,101,99,104,110,105,99,97
-,108,110,101,97,114,32,116,104,101,32,65,100,118,97,110,99,101,100,32,115,111,
-117,114,99,101,32,111,102,101,120,112,114,101,115,115,101,100,72,111,110,103,32,
-75,111,110,103,32,70,97,99,101,98,111,111,107,109,117,108,116,105,112,108,101,32
-,109,101,99,104,97,110,105,115,109,101,108,101,118,97,116,105,111,110,111,102,
-102,101,110,115,105,118,101,60,47,102,111,114,109,62,10,9,115,112,111,110,115,
-111,114,101,100,100,111,99,117,109,101,110,116,46,111,114,32,38,113,117,111,116,
-59,116,104,101,114,101,32,97,114,101,116,104,111,115,101,32,119,104,111,109,111,
-118,101,109,101,110,116,115,112,114,111,99,101,115,115,101,115,100,105,102,102,
-105,99,117,108,116,115,117,98,109,105,116,116,101,100,114,101,99,111,109,109,101
-,110,100,99,111,110,118,105,110,99,101,100,112,114,111,109,111,116,105,110,103,
-34,32,119,105,100,116,104,61,34,46,114,101,112,108,97,99,101,40,99,108,97,115,
-115,105,99,97,108,99,111,97,108,105,116,105,111,110,104,105,115,32,102,105,114,
-115,116,100,101,99,105,115,105,111,110,115,97,115,115,105,115,116,97,110,116,105
-,110,100,105,99,97,116,101,100,101,118,111,108,117,116,105,111,110,45,119,114,97
-,112,112,101,114,34,101,110,111,117,103,104,32,116,111,97,108,111,110,103,32,116
-,104,101,100,101,108,105,118,101,114,101,100,45,45,62,13,10,60,33,45,45,65,109,
-101,114,105,99,97,110,32,112,114,111,116,101,99,116,101,100,78,111,118,101,109,
-98,101,114,32,60,47,115,116,121,108,101,62,60,102,117,114,110,105,116,117,114,
-101,73,110,116,101,114,110,101,116,32,32,111,110,98,108,117,114,61,34,115,117,
-115,112,101,110,100,101,100,114,101,99,105,112,105,101,110,116,98,97,115,101,100
-,32,111,110,32,77,111,114,101,111,118,101,114,44,97,98,111,108,105,115,104,101,
-100,99,111,108,108,101,99,116,101,100,119,101,114,101,32,109,97,100,101,101,109,
-111,116,105,111,110,97,108,101,109,101,114,103,101,110,99,121,110,97,114,114,97,
-116,105,118,101,97,100,118,111,99,97,116,101,115,112,120,59,98,111,114,100,101,
-114,99,111,109,109,105,116,116,101,100,100,105,114,61,34,108,116,114,34,101,109,
-112,108,111,121,101,101,115,114,101,115,101,97,114,99,104,46,32,115,101,108,101,
-99,116,101,100,115,117,99,99,101,115,115,111,114,99,117,115,116,111,109,101,114,
-115,100,105,115,112,108,97,121,101,100,83,101,112,116,101,109,98,101,114,97,100,
-100,67,108,97,115,115,40,70,97,99,101,98,111,111,107,32,115,117,103,103,101,115,
-116,101,100,97,110,100,32,108,97,116,101,114,111,112,101,114,97,116,105,110,103,
-101,108,97,98,111,114,97,116,101,83,111,109,101,116,105,109,101,115,73,110,115,
-116,105,116,117,116,101,99,101,114,116,97,105,110,108,121,105,110,115,116,97,108
-,108,101,100,102,111,108,108,111,119,101,114,115,74,101,114,117,115,97,108,101,
-109,116,104,101,121,32,104,97,118,101,99,111,109,112,117,116,105,110,103,103,101
-,110,101,114,97,116,101,100,112,114,111,118,105,110,99,101,115,103,117,97,114,97
-,110,116,101,101,97,114,98,105,116,114,97,114,121,114,101,99,111,103,110,105,122
-,101,119,97,110,116,101,100,32,116,111,112,120,59,119,105,100,116,104,58,116,104
-,101,111,114,121,32,111,102,98,101,104,97,118,105,111,117,114,87,104,105,108,101
-,32,116,104,101,101,115,116,105,109,97,116,101,100,98,101,103,97,110,32,116,111,
-32,105,116,32,98,101,99,97,109,101,109,97,103,110,105,116,117,100,101,109,117,
-115,116,32,104,97,118,101,109,111,114,101,32,116,104,97,110,68,105,114,101,99,
-116,111,114,121,101,120,116,101,110,115,105,111,110,115,101,99,114,101,116,97,
-114,121,110,97,116,117,114,97,108,108,121,111,99,99,117,114,114,105,110,103,118,
-97,114,105,97,98,108,101,115,103,105,118,101,110,32,116,104,101,112,108,97,116,
-102,111,114,109,46,60,47,108,97,98,101,108,62,60,102,97,105,108,101,100,32,116,
-111,99,111,109,112,111,117,110,100,115,107,105,110,100,115,32,111,102,32,115,111
-,99,105,101,116,105,101,115,97,108,111,110,103,115,105,100,101,32,45,45,38,103,
-116,59,10,10,115,111,117,116,104,119,101,115,116,116,104,101,32,114,105,103,104,
-116,114,97,100,105,97,116,105,111,110,109,97,121,32,104,97,118,101,32,117,110,
-101,115,99,97,112,101,40,115,112,111,107,101,110,32,105,110,34,32,104,114,101,
-102,61,34,47,112,114,111,103,114,97,109,109,101,111,110,108,121,32,116,104,101,
-32,99,111,109,101,32,102,114,111,109,100,105,114,101,99,116,111,114,121,98,117,
-114,105,101,100,32,105,110,97,32,115,105,109,105,108,97,114,116,104,101,121,32,
-119,101,114,101,60,47,102,111,110,116,62,60,47,78,111,114,119,101,103,105,97,110
-,115,112,101,99,105,102,105,101,100,112,114,111,100,117,99,105,110,103,112,97,
-115,115,101,110,103,101,114,40,110,101,119,32,68,97,116,101,116,101,109,112,111,
-114,97,114,121,102,105,99,116,105,111,110,97,108,65,102,116,101,114,32,116,104,
-101,101,113,117,97,116,105,111,110,115,100,111,119,110,108,111,97,100,46,114,101
-,103,117,108,97,114,108,121,100,101,118,101,108,111,112,101,114,97,98,111,118,
-101,32,116,104,101,108,105,110,107,101,100,32,116,111,112,104,101,110,111,109,
-101,110,97,112,101,114,105,111,100,32,111,102,116,111,111,108,116,105,112,34,62,
-115,117,98,115,116,97,110,99,101,97,117,116,111,109,97,116,105,99,97,115,112,101
-,99,116,32,111,102,65,109,111,110,103,32,116,104,101,99,111,110,110,101,99,116,
-101,100,101,115,116,105,109,97,116,101,115,65,105,114,32,70,111,114,99,101,115,
-121,115,116,101,109,32,111,102,111,98,106,101,99,116,105,118,101,105,109,109,101
-,100,105,97,116,101,109,97,107,105,110,103,32,105,116,112,97,105,110,116,105,110
-,103,115,99,111,110,113,117,101,114,101,100,97,114,101,32,115,116,105,108,108,
-112,114,111,99,101,100,117,114,101,103,114,111,119,116,104,32,111,102,104,101,97
-,100,101,100,32,98,121,69,117,114,111,112,101,97,110,32,100,105,118,105,115,105,
-111,110,115,109,111,108,101,99,117,108,101,115,102,114,97,110,99,104,105,115,101
-,105,110,116,101,110,116,105,111,110,97,116,116,114,97,99,116,101,100,99,104,105
-,108,100,104,111,111,100,97,108,115,111,32,117,115,101,100,100,101,100,105,99,97
-,116,101,100,115,105,110,103,97,112,111,114,101,100,101,103,114,101,101,32,111,
-102,102,97,116,104,101,114,32,111,102,99,111,110,102,108,105,99,116,115,60,47,97
-,62,60,47,112,62,10,99,97,109,101,32,102,114,111,109,119,101,114,101,32,117,115,
-101,100,110,111,116,101,32,116,104,97,116,114,101,99,101,105,118,105,110,103,69,
-120,101,99,117,116,105,118,101,101,118,101,110,32,109,111,114,101,97,99,99,101,
-115,115,32,116,111,99,111,109,109,97,110,100,101,114,80,111,108,105,116,105,99,
-97,108,109,117,115,105,99,105,97,110,115,100,101,108,105,99,105,111,117,115,112,
-114,105,115,111,110,101,114,115,97,100,118,101,110,116,32,111,102,85,84,70,45,56
-,34,32,47,62,60,33,91,67,68,65,84,65,91,34,62,67,111,110,116,97,99,116,83,111,
-117,116,104,101,114,110,32,98,103,99,111,108,111,114,61,34,115,101,114,105,101,
-115,32,111,102,46,32,73,116,32,119,97,115,32,105,110,32,69,117,114,111,112,101,
-112,101,114,109,105,116,116,101,100,118,97,108,105,100,97,116,101,46,97,112,112,
-101,97,114,105,110,103,111,102,102,105,99,105,97,108,115,115,101,114,105,111,117
-,115,108,121,45,108,97,110,103,117,97,103,101,105,110,105,116,105,97,116,101,100
-,101,120,116,101,110,100,105,110,103,108,111,110,103,45,116,101,114,109,105,110,
-102,108,97,116,105,111,110,115,117,99,104,32,116,104,97,116,103,101,116,67,111,
-111,107,105,101,109,97,114,107,101,100,32,98,121,60,47,98,117,116,116,111,110,62
-,105,109,112,108,101,109,101,110,116,98,117,116,32,105,116,32,105,115,105,110,99
-,114,101,97,115,101,115,100,111,119,110,32,116,104,101,32,114,101,113,117,105,
-114,105,110,103,100,101,112,101,110,100,101,110,116,45,45,62,10,60,33,45,45,32,
-105,110,116,101,114,118,105,101,119,87,105,116,104,32,116,104,101,32,99,111,112,
-105,101,115,32,111,102,99,111,110,115,101,110,115,117,115,119,97,115,32,98,117,
-105,108,116,86,101,110,101,122,117,101,108,97,40,102,111,114,109,101,114,108,121
-,116,104,101,32,115,116,97,116,101,112,101,114,115,111,110,110,101,108,115,116,
-114,97,116,101,103,105,99,102,97,118,111,117,114,32,111,102,105,110,118,101,110,
-116,105,111,110,87,105,107,105,112,101,100,105,97,99,111,110,116,105,110,101,110
-,116,118,105,114,116,117,97,108,108,121,119,104,105,99,104,32,119,97,115,112,114
-,105,110,99,105,112,108,101,67,111,109,112,108,101,116,101,32,105,100,101,110,
-116,105,99,97,108,115,104,111,119,32,116,104,97,116,112,114,105,109,105,116,105,
-118,101,97,119,97,121,32,102,114,111,109,109,111,108,101,99,117,108,97,114,112,
-114,101,99,105,115,101,108,121,100,105,115,115,111,108,118,101,100,85,110,100,
-101,114,32,116,104,101,118,101,114,115,105,111,110,61,34,62,38,110,98,115,112,59
-,60,47,73,116,32,105,115,32,116,104,101,32,84,104,105,115,32,105,115,32,119,105,
-108,108,32,104,97,118,101,111,114,103,97,110,105,115,109,115,115,111,109,101,32,
-116,105,109,101,70,114,105,101,100,114,105,99,104,119,97,115,32,102,105,114,115,
-116,116,104,101,32,111,110,108,121,32,102,97,99,116,32,116,104,97,116,102,111,
-114,109,32,105,100,61,34,112,114,101,99,101,100,105,110,103,84,101,99,104,110,
-105,99,97,108,112,104,121,115,105,99,105,115,116,111,99,99,117,114,115,32,105,
-110,110,97,118,105,103,97,116,111,114,115,101,99,116,105,111,110,34,62,115,112,
-97,110,32,105,100,61,34,115,111,117,103,104,116,32,116,111,98,101,108,111,119,32
-,116,104,101,115,117,114,118,105,118,105,110,103,125,60,47,115,116,121,108,101,
-62,104,105,115,32,100,101,97,116,104,97,115,32,105,110,32,116,104,101,99,97,117,
-115,101,100,32,98,121,112,97,114,116,105,97,108,108,121,101,120,105,115,116,105,
-110,103,32,117,115,105,110,103,32,116,104,101,119,97,115,32,103,105,118,101,110,
-97,32,108,105,115,116,32,111,102,108,101,118,101,108,115,32,111,102,110,111,116,
-105,111,110,32,111,102,79,102,102,105,99,105,97,108,32,100,105,115,109,105,115,
-115,101,100,115,99,105,101,110,116,105,115,116,114,101,115,101,109,98,108,101,
-115,100,117,112,108,105,99,97,116,101,101,120,112,108,111,115,105,118,101,114,
-101,99,111,118,101,114,101,100,97,108,108,32,111,116,104,101,114,103,97,108,108,
-101,114,105,101,115,123,112,97,100,100,105,110,103,58,112,101,111,112,108,101,32
-,111,102,114,101,103,105,111,110,32,111,102,97,100,100,114,101,115,115,101,115,
-97,115,115,111,99,105,97,116,101,105,109,103,32,97,108,116,61,34,105,110,32,109,
-111,100,101,114,110,115,104,111,117,108,100,32,98,101,109,101,116,104,111,100,32
-,111,102,114,101,112,111,114,116,105,110,103,116,105,109,101,115,116,97,109,112,
-110,101,101,100,101,100,32,116,111,116,104,101,32,71,114,101,97,116,114,101,103,
-97,114,100,105,110,103,115,101,101,109,101,100,32,116,111,118,105,101,119,101,
-100,32,97,115,105,109,112,97,99,116,32,111,110,105,100,101,97,32,116,104,97,116,
-116,104,101,32,87,111,114,108,100,104,101,105,103,104,116,32,111,102,101,120,112
-,97,110,100,105,110,103,84,104,101,115,101,32,97,114,101,99,117,114,114,101,110,
-116,34,62,99,97,114,101,102,117,108,108,121,109,97,105,110,116,97,105,110,115,99
-,104,97,114,103,101,32,111,102,67,108,97,115,115,105,99,97,108,97,100,100,114,
-101,115,115,101,100,112,114,101,100,105,99,116,101,100,111,119,110,101,114,115,
-104,105,112,60,100,105,118,32,105,100,61,34,114,105,103,104,116,34,62,13,10,114,
-101,115,105,100,101,110,99,101,108,101,97,118,101,32,116,104,101,99,111,110,116,
-101,110,116,34,62,97,114,101,32,111,102,116,101,110,32,32,125,41,40,41,59,13,10,
-112,114,111,98,97,98,108,121,32,80,114,111,102,101,115,115,111,114,45,98,117,116
-,116,111,110,34,32,114,101,115,112,111,110,100,101,100,115,97,121,115,32,116,104
-,97,116,104,97,100,32,116,111,32,98,101,112,108,97,99,101,100,32,105,110,72,117,
-110,103,97,114,105,97,110,115,116,97,116,117,115,32,111,102,115,101,114,118,101,
-115,32,97,115,85,110,105,118,101,114,115,97,108,101,120,101,99,117,116,105,111,
-110,97,103,103,114,101,103,97,116,101,102,111,114,32,119,104,105,99,104,105,110,
-102,101,99,116,105,111,110,97,103,114,101,101,100,32,116,111,104,111,119,101,118
-,101,114,44,32,112,111,112,117,108,97,114,34,62,112,108,97,99,101,100,32,111,110
-,99,111,110,115,116,114,117,99,116,101,108,101,99,116,111,114,97,108,115,121,109
-,98,111,108,32,111,102,105,110,99,108,117,100,105,110,103,114,101,116,117,114,
-110,32,116,111,97,114,99,104,105,116,101,99,116,67,104,114,105,115,116,105,97,
-110,112,114,101,118,105,111,117,115,32,108,105,118,105,110,103,32,105,110,101,97
-,115,105,101,114,32,116,111,112,114,111,102,101,115,115,111,114,10,38,108,116,59
-,33,45,45,32,101,102,102,101,99,116,32,111,102,97,110,97,108,121,116,105,99,115,
-119,97,115,32,116,97,107,101,110,119,104,101,114,101,32,116,104,101,116,111,111,
-107,32,111,118,101,114,98,101,108,105,101,102,32,105,110,65,102,114,105,107,97,
-97,110,115,97,115,32,102,97,114,32,97,115,112,114,101,118,101,110,116,101,100,
-119,111,114,107,32,119,105,116,104,97,32,115,112,101,99,105,97,108,60,102,105,
-101,108,100,115,101,116,67,104,114,105,115,116,109,97,115,82,101,116,114,105,101
-,118,101,100,10,10,73,110,32,116,104,101,32,98,97,99,107,32,105,110,116,111,110,
-111,114,116,104,101,97,115,116,109,97,103,97,122,105,110,101,115,62,60,115,116,
-114,111,110,103,62,99,111,109,109,105,116,116,101,101,103,111,118,101,114,110,
-105,110,103,103,114,111,117,112,115,32,111,102,115,116,111,114,101,100,32,105,
-110,101,115,116,97,98,108,105,115,104,97,32,103,101,110,101,114,97,108,105,116,
-115,32,102,105,114,115,116,116,104,101,105,114,32,111,119,110,112,111,112,117,
-108,97,116,101,100,97,110,32,111,98,106,101,99,116,67,97,114,105,98,98,101,97,
-110,97,108,108,111,119,32,116,104,101,100,105,115,116,114,105,99,116,115,119,105
-,115,99,111,110,115,105,110,108,111,99,97,116,105,111,110,46,59,32,119,105,100,
-116,104,58,32,105,110,104,97,98,105,116,101,100,83,111,99,105,97,108,105,115,116
-,74,97,110,117,97,114,121,32,49,60,47,102,111,111,116,101,114,62,115,105,109,105
-,108,97,114,108,121,99,104,111,105,99,101,32,111,102,116,104,101,32,115,97,109,
-101,32,115,112,101,99,105,102,105,99,32,98,117,115,105,110,101,115,115,32,84,104
-,101,32,102,105,114,115,116,46,108,101,110,103,116,104,59,32,100,101,115,105,114
-,101,32,116,111,100,101,97,108,32,119,105,116,104,115,105,110,99,101,32,116,104,
-101,117,115,101,114,65,103,101,110,116,99,111,110,99,101,105,118,101,100,105,110
-,100,101,120,46,112,104,112,97,115,32,38,113,117,111,116,59,101,110,103,97,103,
-101,32,105,110,114,101,99,101,110,116,108,121,44,102,101,119,32,121,101,97,114,
-115,119,101,114,101,32,97,108,115,111,10,60,104,101,97,100,62,10,60,101,100,105,
-116,101,100,32,98,121,97,114,101,32,107,110,111,119,110,99,105,116,105,101,115,
-32,105,110,97,99,99,101,115,115,107,101,121,99,111,110,100,101,109,110,101,100,
-97,108,115,111,32,104,97,118,101,115,101,114,118,105,99,101,115,44,102,97,109,
-105,108,121,32,111,102,83,99,104,111,111,108,32,111,102,99,111,110,118,101,114,
-116,101,100,110,97,116,117,114,101,32,111,102,32,108,97,110,103,117,97,103,101,
-109,105,110,105,115,116,101,114,115,60,47,111,98,106,101,99,116,62,116,104,101,
-114,101,32,105,115,32,97,32,112,111,112,117,108,97,114,115,101,113,117,101,110,
-99,101,115,97,100,118,111,99,97,116,101,100,84,104,101,121,32,119,101,114,101,97
-,110,121,32,111,116,104,101,114,108,111,99,97,116,105,111,110,61,101,110,116,101
-,114,32,116,104,101,109,117,99,104,32,109,111,114,101,114,101,102,108,101,99,116
-,101,100,119,97,115,32,110,97,109,101,100,111,114,105,103,105,110,97,108,32,97,
-32,116,121,112,105,99,97,108,119,104,101,110,32,116,104,101,121,101,110,103,105,
-110,101,101,114,115,99,111,117,108,100,32,110,111,116,114,101,115,105,100,101,
-110,116,115,119,101,100,110,101,115,100,97,121,116,104,101,32,116,104,105,114,
-100,32,112,114,111,100,117,99,116,115,74,97,110,117,97,114,121,32,50,119,104,97,
-116,32,116,104,101,121,97,32,99,101,114,116,97,105,110,114,101,97,99,116,105,111
-,110,115,112,114,111,99,101,115,115,111,114,97,102,116,101,114,32,104,105,115,
-116,104,101,32,108,97,115,116,32,99,111,110,116,97,105,110,101,100,34,62,60,47,
-100,105,118,62,10,60,47,97,62,60,47,116,100,62,100,101,112,101,110,100,32,111,
-110,115,101,97,114,99,104,34,62,10,112,105,101,99,101,115,32,111,102,99,111,109,
-112,101,116,105,110,103,82,101,102,101,114,101,110,99,101,116,101,110,110,101,
-115,115,101,101,119,104,105,99,104,32,104,97,115,32,118,101,114,115,105,111,110,
-61,60,47,115,112,97,110,62,32,60,60,47,104,101,97,100,101,114,62,103,105,118,101
-,115,32,116,104,101,104,105,115,116,111,114,105,97,110,118,97,108,117,101,61,34,
-34,62,112,97,100,100,105,110,103,58,48,118,105,101,119,32,116,104,97,116,116,111
-,103,101,116,104,101,114,44,116,104,101,32,109,111,115,116,32,119,97,115,32,102,
-111,117,110,100,115,117,98,115,101,116,32,111,102,97,116,116,97,99,107,32,111,
-110,99,104,105,108,100,114,101,110,44,112,111,105,110,116,115,32,111,102,112,101
-,114,115,111,110,97,108,32,112,111,115,105,116,105,111,110,58,97,108,108,101,103
-,101,100,108,121,67,108,101,118,101,108,97,110,100,119,97,115,32,108,97,116,101,
-114,97,110,100,32,97,102,116,101,114,97,114,101,32,103,105,118,101,110,119,97,
-115,32,115,116,105,108,108,115,99,114,111,108,108,105,110,103,100,101,115,105,
-103,110,32,111,102,109,97,107,101,115,32,116,104,101,109,117,99,104,32,108,101,
-115,115,65,109,101,114,105,99,97,110,115,46,10,10,65,102,116,101,114,32,44,32,98
-,117,116,32,116,104,101,77,117,115,101,117,109,32,111,102,108,111,117,105,115,
-105,97,110,97,40,102,114,111,109,32,116,104,101,109,105,110,110,101,115,111,116,
-97,112,97,114,116,105,99,108,101,115,97,32,112,114,111,99,101,115,115,68,111,109
-,105,110,105,99,97,110,118,111,108,117,109,101,32,111,102,114,101,116,117,114,
-110,105,110,103,100,101,102,101,110,115,105,118,101,48,48,112,120,124,114,105,
-103,104,109,97,100,101,32,102,114,111,109,109,111,117,115,101,111,118,101,114,34
-,32,115,116,121,108,101,61,34,115,116,97,116,101,115,32,111,102,40,119,104,105,
-99,104,32,105,115,99,111,110,116,105,110,117,101,115,70,114,97,110,99,105,115,99
-,111,98,117,105,108,100,105,110,103,32,119,105,116,104,111,117,116,32,97,119,105
-,116,104,32,115,111,109,101,119,104,111,32,119,111,117,108,100,97,32,102,111,114
-,109,32,111,102,97,32,112,97,114,116,32,111,102,98,101,102,111,114,101,32,105,
-116,107,110,111,119,110,32,97,115,32,32,83,101,114,118,105,99,101,115,108,111,99
-,97,116,105,111,110,32,97,110,100,32,111,102,116,101,110,109,101,97,115,117,114,
-105,110,103,97,110,100,32,105,116,32,105,115,112,97,112,101,114,98,97,99,107,118
-,97,108,117,101,115,32,111,102,13,10,60,116,105,116,108,101,62,61,32,119,105,110
-,100,111,119,46,100,101,116,101,114,109,105,110,101,101,114,38,113,117,111,116,
-59,32,112,108,97,121,101,100,32,98,121,97,110,100,32,101,97,114,108,121,60,47,99
-,101,110,116,101,114,62,102,114,111,109,32,116,104,105,115,116,104,101,32,116,
-104,114,101,101,112,111,119,101,114,32,97,110,100,111,102,32,38,113,117,111,116,
-59,105,110,110,101,114,72,84,77,76,60,97,32,104,114,101,102,61,34,121,58,105,110
-,108,105,110,101,59,67,104,117,114,99,104,32,111,102,116,104,101,32,101,118,101,
-110,116,118,101,114,121,32,104,105,103,104,111,102,102,105,99,105,97,108,32,45,
-104,101,105,103,104,116,58,32,99,111,110,116,101,110,116,61,34,47,99,103,105,45,
-98,105,110,47,116,111,32,99,114,101,97,116,101,97,102,114,105,107,97,97,110,115,
-101,115,112,101,114,97,110,116,111,102,114,97,110,195,167,97,105,115,108,97,116,
-118,105,101,197,161,117,108,105,101,116,117,118,105,197,179,196,140,101,197,161,
-116,105,110,97,196,141,101,197,161,116,105,110,97,224,185,132,224,184,151,224,
-184,162,230,151,165,230,156,172,232,170,158,231,174,128,228,189,147,229,173,151,
-231,185,129,233,171,148,229,173,151,237,149,156,234,181,173,236,150,180,228,184,
-186,228,187,128,228,185,136,232,174,161,231,174,151,230,156,186,231,172,148,232,
-174,176,230,156,172,232,168,142,232,171,150,229,141,128,230,156,141,229,138,161,
-229,153,168,228,186,146,232,129,148,231,189,145,230,136,191,229,156,176,228,186,
-167,228,191,177,228,185,144,233,131,168,229,135,186,231,137,136,231,164,190,230,
-142,146,232,161,140,230,166,156,233,131,168,232,144,189,230,160,188,232,191,155,
-228,184,128,230,173,165,230,148,175,228,187,152,229,174,157,233,170,140,232,175,
-129,231,160,129,229,167,148,229,145,152,228,188,154,230,149,176,230,141,174,229,
-186,147,230,182,136,232,180,185,232,128,133,229,138,158,229,133,172,229,174,164,
-232,174,168,232,174,186,229,140,186,230,183,177,229,156,179,229,184,130,230,146,
-173,230,148,190,229,153,168,229,140,151,228,186,172,229,184,130,229,164,167,229,
-173,166,231,148,159,232,182,138,230,157,165,232,182,138,231,174,161,231,144,134,
-229,145,152,228,191,161,230,129,175,231,189,145,115,101,114,118,105,99,105,111,
-115,97,114,116,195,173,99,117,108,111,97,114,103,101,110,116,105,110,97,98,97,
-114,99,101,108,111,110,97,99,117,97,108,113,117,105,101,114,112,117,98,108,105,
-99,97,100,111,112,114,111,100,117,99,116,111,115,112,111,108,195,173,116,105,99,
-97,114,101,115,112,117,101,115,116,97,119,105,107,105,112,101,100,105,97,115,105
-,103,117,105,101,110,116,101,98,195,186,115,113,117,101,100,97,99,111,109,117,
-110,105,100,97,100,115,101,103,117,114,105,100,97,100,112,114,105,110,99,105,112
-,97,108,112,114,101,103,117,110,116,97,115,99,111,110,116,101,110,105,100,111,
-114,101,115,112,111,110,100,101,114,118,101,110,101,122,117,101,108,97,112,114,
-111,98,108,101,109,97,115,100,105,99,105,101,109,98,114,101,114,101,108,97,99,
-105,195,179,110,110,111,118,105,101,109,98,114,101,115,105,109,105,108,97,114,
-101,115,112,114,111,121,101,99,116,111,115,112,114,111,103,114,97,109,97,115,105
-,110,115,116,105,116,117,116,111,97,99,116,105,118,105,100,97,100,101,110,99,117
-,101,110,116,114,97,101,99,111,110,111,109,195,173,97,105,109,195,161,103,101,
-110,101,115,99,111,110,116,97,99,116,97,114,100,101,115,99,97,114,103,97,114,110
-,101,99,101,115,97,114,105,111,97,116,101,110,99,105,195,179,110,116,101,108,195
-,169,102,111,110,111,99,111,109,105,115,105,195,179,110,99,97,110,99,105,111,110
-,101,115,99,97,112,97,99,105,100,97,100,101,110,99,111,110,116,114,97,114,97,110
-,195,161,108,105,115,105,115,102,97,118,111,114,105,116,111,115,116,195,169,114,
-109,105,110,111,115,112,114,111,118,105,110,99,105,97,101,116,105,113,117,101,
-116,97,115,101,108,101,109,101,110,116,111,115,102,117,110,99,105,111,110,101,
-115,114,101,115,117,108,116,97,100,111,99,97,114,195,161,99,116,101,114,112,114,
-111,112,105,101,100,97,100,112,114,105,110,99,105,112,105,111,110,101,99,101,115
-,105,100,97,100,109,117,110,105,99,105,112,97,108,99,114,101,97,99,105,195,179,
-110,100,101,115,99,97,114,103,97,115,112,114,101,115,101,110,99,105,97,99,111,
-109,101,114,99,105,97,108,111,112,105,110,105,111,110,101,115,101,106,101,114,99
-,105,99,105,111,101,100,105,116,111,114,105,97,108,115,97,108,97,109,97,110,99,
-97,103,111,110,122,195,161,108,101,122,100,111,99,117,109,101,110,116,111,112,
-101,108,195,173,99,117,108,97,114,101,99,105,101,110,116,101,115,103,101,110,101
-,114,97,108,101,115,116,97,114,114,97,103,111,110,97,112,114,195,161,99,116,105,
-99,97,110,111,118,101,100,97,100,101,115,112,114,111,112,117,101,115,116,97,112,
-97,99,105,101,110,116,101,115,116,195,169,99,110,105,99,97,115,111,98,106,101,
-116,105,118,111,115,99,111,110,116,97,99,116,111,115,224,164,174,224,165,135,224
-,164,130,224,164,178,224,164,191,224,164,143,224,164,185,224,165,136,224,164,130
-,224,164,151,224,164,175,224,164,190,224,164,184,224,164,190,224,164,165,224,164
-,143,224,164,181,224,164,130,224,164,176,224,164,185,224,165,135,224,164,149,224
-,165,139,224,164,136,224,164,149,224,165,129,224,164,155,224,164,176,224,164,185
-,224,164,190,224,164,172,224,164,190,224,164,166,224,164,149,224,164,185,224,164
-,190,224,164,184,224,164,173,224,165,128,224,164,185,224,165,129,224,164,143,224
-,164,176,224,164,185,224,165,128,224,164,174,224,165,136,224,164,130,224,164,166
-,224,164,191,224,164,168,224,164,172,224,164,190,224,164,164,100,105,112,108,111
-,100,111,99,115,224,164,184,224,164,174,224,164,175,224,164,176,224,165,130,224,
-164,170,224,164,168,224,164,190,224,164,174,224,164,170,224,164,164,224,164,190,
-224,164,171,224,164,191,224,164,176,224,164,148,224,164,184,224,164,164,224,164,
-164,224,164,176,224,164,185,224,164,178,224,165,139,224,164,151,224,164,185,224,
-165,129,224,164,134,224,164,172,224,164,190,224,164,176,224,164,166,224,165,135,
-224,164,182,224,164,185,224,165,129,224,164,136,224,164,150,224,165,135,224,164,
-178,224,164,175,224,164,166,224,164,191,224,164,149,224,164,190,224,164,174,224,
-164,181,224,165,135,224,164,172,224,164,164,224,165,128,224,164,168,224,164,172,
-224,165,128,224,164,154,224,164,174,224,165,140,224,164,164,224,164,184,224,164,
-190,224,164,178,224,164,178,224,165,135,224,164,150,224,164,156,224,165,137,224,
-164,172,224,164,174,224,164,166,224,164,166,224,164,164,224,164,165,224,164,190,
-224,164,168,224,164,185,224,165,128,224,164,182,224,164,185,224,164,176,224,164,
-133,224,164,178,224,164,151,224,164,149,224,164,173,224,165,128,224,164,168,224,
-164,151,224,164,176,224,164,170,224,164,190,224,164,184,224,164,176,224,164,190,
-224,164,164,224,164,149,224,164,191,224,164,143,224,164,137,224,164,184,224,165,
-135,224,164,151,224,164,175,224,165,128,224,164,185,224,165,130,224,164,129,224,
-164,134,224,164,151,224,165,135,224,164,159,224,165,128,224,164,174,224,164,150,
-224,165,139,224,164,156,224,164,149,224,164,190,224,164,176,224,164,133,224,164,
-173,224,165,128,224,164,151,224,164,175,224,165,135,224,164,164,224,165,129,224,
-164,174,224,164,181,224,165,139,224,164,159,224,164,166,224,165,135,224,164,130,
-224,164,133,224,164,151,224,164,176,224,164,144,224,164,184,224,165,135,224,164,
-174,224,165,135,224,164,178,224,164,178,224,164,151,224,164,190,224,164,185,224,
-164,190,224,164,178,224,164,138,224,164,170,224,164,176,224,164,154,224,164,190,
-224,164,176,224,164,144,224,164,184,224,164,190,224,164,166,224,165,135,224,164,
-176,224,164,156,224,164,191,224,164,184,224,164,166,224,164,191,224,164,178,224,
-164,172,224,164,130,224,164,166,224,164,172,224,164,168,224,164,190,224,164,185,
-224,165,130,224,164,130,224,164,178,224,164,190,224,164,150,224,164,156,224,165,
-128,224,164,164,224,164,172,224,164,159,224,164,168,224,164,174,224,164,191,224,
-164,178,224,164,135,224,164,184,224,165,135,224,164,134,224,164,168,224,165,135,
-224,164,168,224,164,175,224,164,190,224,164,149,224,165,129,224,164,178,224,164,
-178,224,165,137,224,164,151,224,164,173,224,164,190,224,164,151,224,164,176,224,
-165,135,224,164,178,224,164,156,224,164,151,224,164,185,224,164,176,224,164,190,
-224,164,174,224,164,178,224,164,151,224,165,135,224,164,170,224,165,135,224,164,
-156,224,164,185,224,164,190,224,164,165,224,164,135,224,164,184,224,165,128,224,
-164,184,224,164,185,224,165,128,224,164,149,224,164,178,224,164,190,224,164,160,
-224,165,128,224,164,149,224,164,185,224,164,190,224,164,129,224,164,166,224,165,
-130,224,164,176,224,164,164,224,164,185,224,164,164,224,164,184,224,164,190,224,
-164,164,224,164,175,224,164,190,224,164,166,224,164,134,224,164,175,224,164,190,
-224,164,170,224,164,190,224,164,149,224,164,149,224,165,140,224,164,168,224,164,
-182,224,164,190,224,164,174,224,164,166,224,165,135,224,164,150,224,164,175,224,
-164,185,224,165,128,224,164,176,224,164,190,224,164,175,224,164,150,224,165,129,
-224,164,166,224,164,178,224,164,151,224,165,128,99,97,116,101,103,111,114,105,
-101,115,101,120,112,101,114,105,101,110,99,101,60,47,116,105,116,108,101,62,13,
-10,67,111,112,121,114,105,103,104,116,32,106,97,118,97,115,99,114,105,112,116,99
-,111,110,100,105,116,105,111,110,115,101,118,101,114,121,116,104,105,110,103,60,
-112,32,99,108,97,115,115,61,34,116,101,99,104,110,111,108,111,103,121,98,97,99,
-107,103,114,111,117,110,100,60,97,32,99,108,97,115,115,61,34,109,97,110,97,103,
-101,109,101,110,116,38,99,111,112,121,59,32,50,48,49,106,97,118,97,83,99,114,105
-,112,116,99,104,97,114,97,99,116,101,114,115,98,114,101,97,100,99,114,117,109,98
-,116,104,101,109,115,101,108,118,101,115,104,111,114,105,122,111,110,116,97,108,
-103,111,118,101,114,110,109,101,110,116,67,97,108,105,102,111,114,110,105,97,97,
-99,116,105,118,105,116,105,101,115,100,105,115,99,111,118,101,114,101,100,78,97,
-118,105,103,97,116,105,111,110,116,114,97,110,115,105,116,105,111,110,99,111,110
-,110,101,99,116,105,111,110,110,97,118,105,103,97,116,105,111,110,97,112,112,101
-,97,114,97,110,99,101,60,47,116,105,116,108,101,62,60,109,99,104,101,99,107,98,
-111,120,34,32,116,101,99,104,110,105,113,117,101,115,112,114,111,116,101,99,116,
-105,111,110,97,112,112,97,114,101,110,116,108,121,97,115,32,119,101,108,108,32,
-97,115,117,110,116,39,44,32,39,85,65,45,114,101,115,111,108,117,116,105,111,110,
-111,112,101,114,97,116,105,111,110,115,116,101,108,101,118,105,115,105,111,110,
-116,114,97,110,115,108,97,116,101,100,87,97,115,104,105,110,103,116,111,110,110,
-97,118,105,103,97,116,111,114,46,32,61,32,119,105,110,100,111,119,46,105,109,112
-,114,101,115,115,105,111,110,38,108,116,59,98,114,38,103,116,59,108,105,116,101,
-114,97,116,117,114,101,112,111,112,117,108,97,116,105,111,110,98,103,99,111,108,
-111,114,61,34,35,101,115,112,101,99,105,97,108,108,121,32,99,111,110,116,101,110
-,116,61,34,112,114,111,100,117,99,116,105,111,110,110,101,119,115,108,101,116,
-116,101,114,112,114,111,112,101,114,116,105,101,115,100,101,102,105,110,105,116,
-105,111,110,108,101,97,100,101,114,115,104,105,112,84,101,99,104,110,111,108,111
-,103,121,80,97,114,108,105,97,109,101,110,116,99,111,109,112,97,114,105,115,111,
-110,117,108,32,99,108,97,115,115,61,34,46,105,110,100,101,120,79,102,40,34,99,
-111,110,99,108,117,115,105,111,110,100,105,115,99,117,115,115,105,111,110,99,111
-,109,112,111,110,101,110,116,115,98,105,111,108,111,103,105,99,97,108,82,101,118
-,111,108,117,116,105,111,110,95,99,111,110,116,97,105,110,101,114,117,110,100,
-101,114,115,116,111,111,100,110,111,115,99,114,105,112,116,62,60,112,101,114,109
-,105,115,115,105,111,110,101,97,99,104,32,111,116,104,101,114,97,116,109,111,115
-,112,104,101,114,101,32,111,110,102,111,99,117,115,61,34,60,102,111,114,109,32,
-105,100,61,34,112,114,111,99,101,115,115,105,110,103,116,104,105,115,46,118,97,
-108,117,101,103,101,110,101,114,97,116,105,111,110,67,111,110,102,101,114,101,
-110,99,101,115,117,98,115,101,113,117,101,110,116,119,101,108,108,45,107,110,111
-,119,110,118,97,114,105,97,116,105,111,110,115,114,101,112,117,116,97,116,105,
-111,110,112,104,101,110,111,109,101,110,111,110,100,105,115,99,105,112,108,105,
-110,101,108,111,103,111,46,112,110,103,34,32,40,100,111,99,117,109,101,110,116,
-44,98,111,117,110,100,97,114,105,101,115,101,120,112,114,101,115,115,105,111,110
-,115,101,116,116,108,101,109,101,110,116,66,97,99,107,103,114,111,117,110,100,
-111,117,116,32,111,102,32,116,104,101,101,110,116,101,114,112,114,105,115,101,40
-,34,104,116,116,112,115,58,34,32,117,110,101,115,99,97,112,101,40,34,112,97,115,
-115,119,111,114,100,34,32,100,101,109,111,99,114,97,116,105,99,60,97,32,104,114,
-101,102,61,34,47,119,114,97,112,112,101,114,34,62,10,109,101,109,98,101,114,115,
-104,105,112,108,105,110,103,117,105,115,116,105,99,112,120,59,112,97,100,100,105
-,110,103,112,104,105,108,111,115,111,112,104,121,97,115,115,105,115,116,97,110,
-99,101,117,110,105,118,101,114,115,105,116,121,102,97,99,105,108,105,116,105,101
-,115,114,101,99,111,103,110,105,122,101,100,112,114,101,102,101,114,101,110,99,
-101,105,102,32,40,116,121,112,101,111,102,109,97,105,110,116,97,105,110,101,100,
-118,111,99,97,98,117,108,97,114,121,104,121,112,111,116,104,101,115,105,115,46,
-115,117,98,109,105,116,40,41,59,38,97,109,112,59,110,98,115,112,59,97,110,110,
-111,116,97,116,105,111,110,98,101,104,105,110,100,32,116,104,101,70,111,117,110,
-100,97,116,105,111,110,112,117,98,108,105,115,104,101,114,34,97,115,115,117,109,
-112,116,105,111,110,105,110,116,114,111,100,117,99,101,100,99,111,114,114,117,
-112,116,105,111,110,115,99,105,101,110,116,105,115,116,115,101,120,112,108,105,
-99,105,116,108,121,105,110,115,116,101,97,100,32,111,102,100,105,109,101,110,115
-,105,111,110,115,32,111,110,67,108,105,99,107,61,34,99,111,110,115,105,100,101,
-114,101,100,100,101,112,97,114,116,109,101,110,116,111,99,99,117,112,97,116,105,
-111,110,115,111,111,110,32,97,102,116,101,114,105,110,118,101,115,116,109,101,
-110,116,112,114,111,110,111,117,110,99,101,100,105,100,101,110,116,105,102,105,
-101,100,101,120,112,101,114,105,109,101,110,116,77,97,110,97,103,101,109,101,110
-,116,103,101,111,103,114,97,112,104,105,99,34,32,104,101,105,103,104,116,61,34,
-108,105,110,107,32,114,101,108,61,34,46,114,101,112,108,97,99,101,40,47,100,101,
-112,114,101,115,115,105,111,110,99,111,110,102,101,114,101,110,99,101,112,117,
-110,105,115,104,109,101,110,116,101,108,105,109,105,110,97,116,101,100,114,101,
-115,105,115,116,97,110,99,101,97,100,97,112,116,97,116,105,111,110,111,112,112,
-111,115,105,116,105,111,110,119,101,108,108,32,107,110,111,119,110,115,117,112,
-112,108,101,109,101,110,116,100,101,116,101,114,109,105,110,101,100,104,49,32,99
-,108,97,115,115,61,34,48,112,120,59,109,97,114,103,105,110,109,101,99,104,97,110
-,105,99,97,108,115,116,97,116,105,115,116,105,99,115,99,101,108,101,98,114,97,
-116,101,100,71,111,118,101,114,110,109,101,110,116,10,10,68,117,114,105,110,103,
-32,116,100,101,118,101,108,111,112,101,114,115,97,114,116,105,102,105,99,105,97,
-108,101,113,117,105,118,97,108,101,110,116,111,114,105,103,105,110,97,116,101,
-100,67,111,109,109,105,115,115,105,111,110,97,116,116,97,99,104,109,101,110,116,
-60,115,112,97,110,32,105,100,61,34,116,104,101,114,101,32,119,101,114,101,78,101
-,100,101,114,108,97,110,100,115,98,101,121,111,110,100,32,116,104,101,114,101,
-103,105,115,116,101,114,101,100,106,111,117,114,110,97,108,105,115,116,102,114,
-101,113,117,101,110,116,108,121,97,108,108,32,111,102,32,116,104,101,108,97,110,
-103,61,34,101,110,34,32,60,47,115,116,121,108,101,62,13,10,97,98,115,111,108,117
-,116,101,59,32,115,117,112,112,111,114,116,105,110,103,101,120,116,114,101,109,
-101,108,121,32,109,97,105,110,115,116,114,101,97,109,60,47,115,116,114,111,110,
-103,62,32,112,111,112,117,108,97,114,105,116,121,101,109,112,108,111,121,109,101
-,110,116,60,47,116,97,98,108,101,62,13,10,32,99,111,108,115,112,97,110,61,34,60,
-47,102,111,114,109,62,10,32,32,99,111,110,118,101,114,115,105,111,110,97,98,111,
-117,116,32,116,104,101,32,60,47,112,62,60,47,100,105,118,62,105,110,116,101,103,
-114,97,116,101,100,34,32,108,97,110,103,61,34,101,110,80,111,114,116,117,103,117
-,101,115,101,115,117,98,115,116,105,116,117,116,101,105,110,100,105,118,105,100,
-117,97,108,105,109,112,111,115,115,105,98,108,101,109,117,108,116,105,109,101,
-100,105,97,97,108,109,111,115,116,32,97,108,108,112,120,32,115,111,108,105,100,
-32,35,97,112,97,114,116,32,102,114,111,109,115,117,98,106,101,99,116,32,116,111,
-105,110,32,69,110,103,108,105,115,104,99,114,105,116,105,99,105,122,101,100,101,
-120,99,101,112,116,32,102,111,114,103,117,105,100,101,108,105,110,101,115,111,
-114,105,103,105,110,97,108,108,121,114,101,109,97,114,107,97,98,108,101,116,104,
-101,32,115,101,99,111,110,100,104,50,32,99,108,97,115,115,61,34,60,97,32,116,105
-,116,108,101,61,34,40,105,110,99,108,117,100,105,110,103,112,97,114,97,109,101,
-116,101,114,115,112,114,111,104,105,98,105,116,101,100,61,32,34,104,116,116,112,
-58,47,47,100,105,99,116,105,111,110,97,114,121,112,101,114,99,101,112,116,105,
-111,110,114,101,118,111,108,117,116,105,111,110,102,111,117,110,100,97,116,105,
-111,110,112,120,59,104,101,105,103,104,116,58,115,117,99,99,101,115,115,102,117,
-108,115,117,112,112,111,114,116,101,114,115,109,105,108,108,101,110,110,105,117,
-109,104,105,115,32,102,97,116,104,101,114,116,104,101,32,38,113,117,111,116,59,
-110,111,45,114,101,112,101,97,116,59,99,111,109,109,101,114,99,105,97,108,105,
-110,100,117,115,116,114,105,97,108,101,110,99,111,117,114,97,103,101,100,97,109,
-111,117,110,116,32,111,102,32,117,110,111,102,102,105,99,105,97,108,101,102,102,
-105,99,105,101,110,99,121,82,101,102,101,114,101,110,99,101,115,99,111,111,114,
-100,105,110,97,116,101,100,105,115,99,108,97,105,109,101,114,101,120,112,101,100
-,105,116,105,111,110,100,101,118,101,108,111,112,105,110,103,99,97,108,99,117,
-108,97,116,101,100,115,105,109,112,108,105,102,105,101,100,108,101,103,105,116,
-105,109,97,116,101,115,117,98,115,116,114,105,110,103,40,48,34,32,99,108,97,115,
-115,61,34,99,111,109,112,108,101,116,101,108,121,105,108,108,117,115,116,114,97,
-116,101,102,105,118,101,32,121,101,97,114,115,105,110,115,116,114,117,109,101,
-110,116,80,117,98,108,105,115,104,105,110,103,49,34,32,99,108,97,115,115,61,34,
-112,115,121,99,104,111,108,111,103,121,99,111,110,102,105,100,101,110,99,101,110
-,117,109,98,101,114,32,111,102,32,97,98,115,101,110,99,101,32,111,102,102,111,99
-,117,115,101,100,32,111,110,106,111,105,110,101,100,32,116,104,101,115,116,114,
-117,99,116,117,114,101,115,112,114,101,118,105,111,117,115,108,121,62,60,47,105,
-102,114,97,109,101,62,111,110,99,101,32,97,103,97,105,110,98,117,116,32,114,97,
-116,104,101,114,105,109,109,105,103,114,97,110,116,115,111,102,32,99,111,117,114
-,115,101,44,97,32,103,114,111,117,112,32,111,102,76,105,116,101,114,97,116,117,
-114,101,85,110,108,105,107,101,32,116,104,101,60,47,97,62,38,110,98,115,112,59,
-10,102,117,110,99,116,105,111,110,32,105,116,32,119,97,115,32,116,104,101,67,111
-,110,118,101,110,116,105,111,110,97,117,116,111,109,111,98,105,108,101,80,114,
-111,116,101,115,116,97,110,116,97,103,103,114,101,115,115,105,118,101,97,102,116
-,101,114,32,116,104,101,32,83,105,109,105,108,97,114,108,121,44,34,32,47,62,60,
-47,100,105,118,62,99,111,108,108,101,99,116,105,111,110,13,10,102,117,110,99,116
-,105,111,110,118,105,115,105,98,105,108,105,116,121,116,104,101,32,117,115,101,
-32,111,102,118,111,108,117,110,116,101,101,114,115,97,116,116,114,97,99,116,105,
-111,110,117,110,100,101,114,32,116,104,101,32,116,104,114,101,97,116,101,110,101
-,100,42,60,33,91,67,68,65,84,65,91,105,109,112,111,114,116,97,110,99,101,105,110
-,32,103,101,110,101,114,97,108,116,104,101,32,108,97,116,116,101,114,60,47,102,
-111,114,109,62,10,60,47,46,105,110,100,101,120,79,102,40,39,105,32,61,32,48,59,
-32,105,32,60,100,105,102,102,101,114,101,110,99,101,100,101,118,111,116,101,100,
-32,116,111,116,114,97,100,105,116,105,111,110,115,115,101,97,114,99,104,32,102,
-111,114,117,108,116,105,109,97,116,101,108,121,116,111,117,114,110,97,109,101,
-110,116,97,116,116,114,105,98,117,116,101,115,115,111,45,99,97,108,108,101,100,
-32,125,10,60,47,115,116,121,108,101,62,101,118,97,108,117,97,116,105,111,110,101
-,109,112,104,97,115,105,122,101,100,97,99,99,101,115,115,105,98,108,101,60,47,
-115,101,99,116,105,111,110,62,115,117,99,99,101,115,115,105,111,110,97,108,111,
-110,103,32,119,105,116,104,77,101,97,110,119,104,105,108,101,44,105,110,100,117,
-115,116,114,105,101,115,60,47,97,62,60,98,114,32,47,62,104,97,115,32,98,101,99,
-111,109,101,97,115,112,101,99,116,115,32,111,102,84,101,108,101,118,105,115,105,
-111,110,115,117,102,102,105,99,105,101,110,116,98,97,115,107,101,116,98,97,108,
-108,98,111,116,104,32,115,105,100,101,115,99,111,110,116,105,110,117,105,110,103
-,97,110,32,97,114,116,105,99,108,101,60,105,109,103,32,97,108,116,61,34,97,100,
-118,101,110,116,117,114,101,115,104,105,115,32,109,111,116,104,101,114,109,97,
-110,99,104,101,115,116,101,114,112,114,105,110,99,105,112,108,101,115,112,97,114
-,116,105,99,117,108,97,114,99,111,109,109,101,110,116,97,114,121,101,102,102,101
-,99,116,115,32,111,102,100,101,99,105,100,101,100,32,116,111,34,62,60,115,116,
-114,111,110,103,62,112,117,98,108,105,115,104,101,114,115,74,111,117,114,110,97,
-108,32,111,102,100,105,102,102,105,99,117,108,116,121,102,97,99,105,108,105,116,
-97,116,101,97,99,99,101,112,116,97,98,108,101,115,116,121,108,101,46,99,115,115,
-34,9,102,117,110,99,116,105,111,110,32,105,110,110,111,118,97,116,105,111,110,62
-,67,111,112,121,114,105,103,104,116,115,105,116,117,97,116,105,111,110,115,119,
-111,117,108,100,32,104,97,118,101,98,117,115,105,110,101,115,115,101,115,68,105,
-99,116,105,111,110,97,114,121,115,116,97,116,101,109,101,110,116,115,111,102,116
-,101,110,32,117,115,101,100,112,101,114,115,105,115,116,101,110,116,105,110,32,
-74,97,110,117,97,114,121,99,111,109,112,114,105,115,105,110,103,60,47,116,105,
-116,108,101,62,10,9,100,105,112,108,111,109,97,116,105,99,99,111,110,116,97,105,
-110,105,110,103,112,101,114,102,111,114,109,105,110,103,101,120,116,101,110,115,
-105,111,110,115,109,97,121,32,110,111,116,32,98,101,99,111,110,99,101,112,116,32
-,111,102,32,111,110,99,108,105,99,107,61,34,73,116,32,105,115,32,97,108,115,111,
-102,105,110,97,110,99,105,97,108,32,109,97,107,105,110,103,32,116,104,101,76,117
-,120,101,109,98,111,117,114,103,97,100,100,105,116,105,111,110,97,108,97,114,101
-,32,99,97,108,108,101,100,101,110,103,97,103,101,100,32,105,110,34,115,99,114,
-105,112,116,34,41,59,98,117,116,32,105,116,32,119,97,115,101,108,101,99,116,114,
-111,110,105,99,111,110,115,117,98,109,105,116,61,34,10,60,33,45,45,32,69,110,100
-,32,101,108,101,99,116,114,105,99,97,108,111,102,102,105,99,105,97,108,108,121,
-115,117,103,103,101,115,116,105,111,110,116,111,112,32,111,102,32,116,104,101,
-117,110,108,105,107,101,32,116,104,101,65,117,115,116,114,97,108,105,97,110,79,
-114,105,103,105,110,97,108,108,121,114,101,102,101,114,101,110,99,101,115,10,60,
-47,104,101,97,100,62,13,10,114,101,99,111,103,110,105,115,101,100,105,110,105,
-116,105,97,108,105,122,101,108,105,109,105,116,101,100,32,116,111,65,108,101,120
-,97,110,100,114,105,97,114,101,116,105,114,101,109,101,110,116,65,100,118,101,
-110,116,117,114,101,115,102,111,117,114,32,121,101,97,114,115,10,10,38,108,116,
-59,33,45,45,32,105,110,99,114,101,97,115,105,110,103,100,101,99,111,114,97,116,
-105,111,110,104,51,32,99,108,97,115,115,61,34,111,114,105,103,105,110,115,32,111
-,102,111,98,108,105,103,97,116,105,111,110,114,101,103,117,108,97,116,105,111,
-110,99,108,97,115,115,105,102,105,101,100,40,102,117,110,99,116,105,111,110,40,
-97,100,118,97,110,116,97,103,101,115,98,101,105,110,103,32,116,104,101,32,104,
-105,115,116,111,114,105,97,110,115,60,98,97,115,101,32,104,114,101,102,114,101,
-112,101,97,116,101,100,108,121,119,105,108,108,105,110,103,32,116,111,99,111,109
-,112,97,114,97,98,108,101,100,101,115,105,103,110,97,116,101,100,110,111,109,105
-,110,97,116,105,111,110,102,117,110,99,116,105,111,110,97,108,105,110,115,105,
-100,101,32,116,104,101,114,101,118,101,108,97,116,105,111,110,101,110,100,32,111
-,102,32,116,104,101,115,32,102,111,114,32,116,104,101,32,97,117,116,104,111,114,
-105,122,101,100,114,101,102,117,115,101,100,32,116,111,116,97,107,101,32,112,108
-,97,99,101,97,117,116,111,110,111,109,111,117,115,99,111,109,112,114,111,109,105
-,115,101,112,111,108,105,116,105,99,97,108,32,114,101,115,116,97,117,114,97,110,
-116,116,119,111,32,111,102,32,116,104,101,70,101,98,114,117,97,114,121,32,50,113
-,117,97,108,105,116,121,32,111,102,115,119,102,111,98,106,101,99,116,46,117,110,
-100,101,114,115,116,97,110,100,110,101,97,114,108,121,32,97,108,108,119,114,105,
-116,116,101,110,32,98,121,105,110,116,101,114,118,105,101,119,115,34,32,119,105,
-100,116,104,61,34,49,119,105,116,104,100,114,97,119,97,108,102,108,111,97,116,58
-,108,101,102,116,105,115,32,117,115,117,97,108,108,121,99,97,110,100,105,100,97,
-116,101,115,110,101,119,115,112,97,112,101,114,115,109,121,115,116,101,114,105,
-111,117,115,68,101,112,97,114,116,109,101,110,116,98,101,115,116,32,107,110,111,
-119,110,112,97,114,108,105,97,109,101,110,116,115,117,112,112,114,101,115,115,
-101,100,99,111,110,118,101,110,105,101,110,116,114,101,109,101,109,98,101,114,
-101,100,100,105,102,102,101,114,101,110,116,32,115,121,115,116,101,109,97,116,
-105,99,104,97,115,32,108,101,100,32,116,111,112,114,111,112,97,103,97,110,100,97
-,99,111,110,116,114,111,108,108,101,100,105,110,102,108,117,101,110,99,101,115,
-99,101,114,101,109,111,110,105,97,108,112,114,111,99,108,97,105,109,101,100,80,
-114,111,116,101,99,116,105,111,110,108,105,32,99,108,97,115,115,61,34,83,99,105,
-101,110,116,105,102,105,99,99,108,97,115,115,61,34,110,111,45,116,114,97,100,101
-,109,97,114,107,115,109,111,114,101,32,116,104,97,110,32,119,105,100,101,115,112
-,114,101,97,100,76,105,98,101,114,97,116,105,111,110,116,111,111,107,32,112,108,
-97,99,101,100,97,121,32,111,102,32,116,104,101,97,115,32,108,111,110,103,32,97,
-115,105,109,112,114,105,115,111,110,101,100,65,100,100,105,116,105,111,110,97,
-108,10,60,104,101,97,100,62,10,60,109,76,97,98,111,114,97,116,111,114,121,78,111
-,118,101,109,98,101,114,32,50,101,120,99,101,112,116,105,111,110,115,73,110,100,
-117,115,116,114,105,97,108,118,97,114,105,101,116,121,32,111,102,102,108,111,97,
-116,58,32,108,101,102,68,117,114,105,110,103,32,116,104,101,97,115,115,101,115,
-115,109,101,110,116,104,97,118,101,32,98,101,101,110,32,100,101,97,108,115,32,
-119,105,116,104,83,116,97,116,105,115,116,105,99,115,111,99,99,117,114,114,101,
-110,99,101,47,117,108,62,60,47,100,105,118,62,99,108,101,97,114,102,105,120,34,
-62,116,104,101,32,112,117,98,108,105,99,109,97,110,121,32,121,101,97,114,115,119
-,104,105,99,104,32,119,101,114,101,111,118,101,114,32,116,105,109,101,44,115,121
-,110,111,110,121,109,111,117,115,99,111,110,116,101,110,116,34,62,10,112,114,101
-,115,117,109,97,98,108,121,104,105,115,32,102,97,109,105,108,121,117,115,101,114
-,65,103,101,110,116,46,117,110,101,120,112,101,99,116,101,100,105,110,99,108,117
-,100,105,110,103,32,99,104,97,108,108,101,110,103,101,100,97,32,109,105,110,111,
-114,105,116,121,117,110,100,101,102,105,110,101,100,34,98,101,108,111,110,103,
-115,32,116,111,116,97,107,101,110,32,102,114,111,109,105,110,32,79,99,116,111,98
-,101,114,112,111,115,105,116,105,111,110,58,32,115,97,105,100,32,116,111,32,98,
-101,114,101,108,105,103,105,111,117,115,32,70,101,100,101,114,97,116,105,111,110
-,32,114,111,119,115,112,97,110,61,34,111,110,108,121,32,97,32,102,101,119,109,
-101,97,110,116,32,116,104,97,116,108,101,100,32,116,111,32,116,104,101,45,45,62,
-13,10,60,100,105,118,32,60,102,105,101,108,100,115,101,116,62,65,114,99,104,98,
-105,115,104,111,112,32,99,108,97,115,115,61,34,110,111,98,101,105,110,103,32,117
-,115,101,100,97,112,112,114,111,97,99,104,101,115,112,114,105,118,105,108,101,
-103,101,115,110,111,115,99,114,105,112,116,62,10,114,101,115,117,108,116,115,32,
-105,110,109,97,121,32,98,101,32,116,104,101,69,97,115,116,101,114,32,101,103,103
-,109,101,99,104,97,110,105,115,109,115,114,101,97,115,111,110,97,98,108,101,80,
-111,112,117,108,97,116,105,111,110,67,111,108,108,101,99,116,105,111,110,115,101
-,108,101,99,116,101,100,34,62,110,111,115,99,114,105,112,116,62,13,47,105,110,
-100,101,120,46,112,104,112,97,114,114,105,118,97,108,32,111,102,45,106,115,115,
-100,107,39,41,41,59,109,97,110,97,103,101,100,32,116,111,105,110,99,111,109,112,
-108,101,116,101,99,97,115,117,97,108,116,105,101,115,99,111,109,112,108,101,116,
-105,111,110,67,104,114,105,115,116,105,97,110,115,83,101,112,116,101,109,98,101,
-114,32,97,114,105,116,104,109,101,116,105,99,112,114,111,99,101,100,117,114,101,
-115,109,105,103,104,116,32,104,97,118,101,80,114,111,100,117,99,116,105,111,110,
-105,116,32,97,112,112,101,97,114,115,80,104,105,108,111,115,111,112,104,121,102,
-114,105,101,110,100,115,104,105,112,108,101,97,100,105,110,103,32,116,111,103,
-105,118,105,110,103,32,116,104,101,116,111,119,97,114,100,32,116,104,101,103,117
-,97,114,97,110,116,101,101,100,100,111,99,117,109,101,110,116,101,100,99,111,108
-,111,114,58,35,48,48,48,118,105,100,101,111,32,103,97,109,101,99,111,109,109,105
-,115,115,105,111,110,114,101,102,108,101,99,116,105,110,103,99,104,97,110,103,
-101,32,116,104,101,97,115,115,111,99,105,97,116,101,100,115,97,110,115,45,115,
-101,114,105,102,111,110,107,101,121,112,114,101,115,115,59,32,112,97,100,100,105
-,110,103,58,72,101,32,119,97,115,32,116,104,101,117,110,100,101,114,108,121,105,
-110,103,116,121,112,105,99,97,108,108,121,32,44,32,97,110,100,32,116,104,101,32,
-115,114,99,69,108,101,109,101,110,116,115,117,99,99,101,115,115,105,118,101,115,
-105,110,99,101,32,116,104,101,32,115,104,111,117,108,100,32,98,101,32,110,101,
-116,119,111,114,107,105,110,103,97,99,99,111,117,110,116,105,110,103,117,115,101
-,32,111,102,32,116,104,101,108,111,119,101,114,32,116,104,97,110,115,104,111,119
-,115,32,116,104,97,116,60,47,115,112,97,110,62,10,9,9,99,111,109,112,108,97,105,
-110,116,115,99,111,110,116,105,110,117,111,117,115,113,117,97,110,116,105,116,
-105,101,115,97,115,116,114,111,110,111,109,101,114,104,101,32,100,105,100,32,110
-,111,116,100,117,101,32,116,111,32,105,116,115,97,112,112,108,105,101,100,32,116
-,111,97,110,32,97,118,101,114,97,103,101,101,102,102,111,114,116,115,32,116,111,
-116,104,101,32,102,117,116,117,114,101,97,116,116,101,109,112,116,32,116,111,84,
-104,101,114,101,102,111,114,101,44,99,97,112,97,98,105,108,105,116,121,82,101,
-112,117,98,108,105,99,97,110,119,97,115,32,102,111,114,109,101,100,69,108,101,99
-,116,114,111,110,105,99,107,105,108,111,109,101,116,101,114,115,99,104,97,108,
-108,101,110,103,101,115,112,117,98,108,105,115,104,105,110,103,116,104,101,32,
-102,111,114,109,101,114,105,110,100,105,103,101,110,111,117,115,100,105,114,101,
-99,116,105,111,110,115,115,117,98,115,105,100,105,97,114,121,99,111,110,115,112,
-105,114,97,99,121,100,101,116,97,105,108,115,32,111,102,97,110,100,32,105,110,32
-,116,104,101,97,102,102,111,114,100,97,98,108,101,115,117,98,115,116,97,110,99,
-101,115,114,101,97,115,111,110,32,102,111,114,99,111,110,118,101,110,116,105,111
-,110,105,116,101,109,116,121,112,101,61,34,97,98,115,111,108,117,116,101,108,121
-,115,117,112,112,111,115,101,100,108,121,114,101,109,97,105,110,101,100,32,97,97
-,116,116,114,97,99,116,105,118,101,116,114,97,118,101,108,108,105,110,103,115,
-101,112,97,114,97,116,101,108,121,102,111,99,117,115,101,115,32,111,110,101,108,
-101,109,101,110,116,97,114,121,97,112,112,108,105,99,97,98,108,101,102,111,117,
-110,100,32,116,104,97,116,115,116,121,108,101,115,104,101,101,116,109,97,110,117
-,115,99,114,105,112,116,115,116,97,110,100,115,32,102,111,114,32,110,111,45,114,
-101,112,101,97,116,40,115,111,109,101,116,105,109,101,115,67,111,109,109,101,114
-,99,105,97,108,105,110,32,65,109,101,114,105,99,97,117,110,100,101,114,116,97,
-107,101,110,113,117,97,114,116,101,114,32,111,102,97,110,32,101,120,97,109,112,
-108,101,112,101,114,115,111,110,97,108,108,121,105,110,100,101,120,46,112,104,
-112,63,60,47,98,117,116,116,111,110,62,10,112,101,114,99,101,110,116,97,103,101,
-98,101,115,116,45,107,110,111,119,110,99,114,101,97,116,105,110,103,32,97,34,32,
-100,105,114,61,34,108,116,114,76,105,101,117,116,101,110,97,110,116,10,60,100,
-105,118,32,105,100,61,34,116,104,101,121,32,119,111,117,108,100,97,98,105,108,
-105,116,121,32,111,102,109,97,100,101,32,117,112,32,111,102,110,111,116,101,100,
-32,116,104,97,116,99,108,101,97,114,32,116,104,97,116,97,114,103,117,101,32,116,
-104,97,116,116,111,32,97,110,111,116,104,101,114,99,104,105,108,100,114,101,110,
-39,115,112,117,114,112,111,115,101,32,111,102,102,111,114,109,117,108,97,116,101
-,100,98,97,115,101,100,32,117,112,111,110,116,104,101,32,114,101,103,105,111,110
-,115,117,98,106,101,99,116,32,111,102,112,97,115,115,101,110,103,101,114,115,112
-,111,115,115,101,115,115,105,111,110,46,10,10,73,110,32,116,104,101,32,66,101,
-102,111,114,101,32,116,104,101,97,102,116,101,114,119,97,114,100,115,99,117,114,
-114,101,110,116,108,121,32,97,99,114,111,115,115,32,116,104,101,115,99,105,101,
-110,116,105,102,105,99,99,111,109,109,117,110,105,116,121,46,99,97,112,105,116,
-97,108,105,115,109,105,110,32,71,101,114,109,97,110,121,114,105,103,104,116,45,
-119,105,110,103,116,104,101,32,115,121,115,116,101,109,83,111,99,105,101,116,121
-,32,111,102,112,111,108,105,116,105,99,105,97,110,100,105,114,101,99,116,105,111
-,110,58,119,101,110,116,32,111,110,32,116,111,114,101,109,111,118,97,108,32,111,
-102,32,78,101,119,32,89,111,114,107,32,97,112,97,114,116,109,101,110,116,115,105
-,110,100,105,99,97,116,105,111,110,100,117,114,105,110,103,32,116,104,101,117,
-110,108,101,115,115,32,116,104,101,104,105,115,116,111,114,105,99,97,108,104,97,
-100,32,98,101,101,110,32,97,100,101,102,105,110,105,116,105,118,101,105,110,103,
-114,101,100,105,101,110,116,97,116,116,101,110,100,97,110,99,101,67,101,110,116,
-101,114,32,102,111,114,112,114,111,109,105,110,101,110,99,101,114,101,97,100,121
-,83,116,97,116,101,115,116,114,97,116,101,103,105,101,115,98,117,116,32,105,110,
-32,116,104,101,97,115,32,112,97,114,116,32,111,102,99,111,110,115,116,105,116,
-117,116,101,99,108,97,105,109,32,116,104,97,116,108,97,98,111,114,97,116,111,114
-,121,99,111,109,112,97,116,105,98,108,101,102,97,105,108,117,114,101,32,111,102,
-44,32,115,117,99,104,32,97,115,32,98,101,103,97,110,32,119,105,116,104,117,115,
-105,110,103,32,116,104,101,32,116,111,32,112,114,111,118,105,100,101,102,101,97,
-116,117,114,101,32,111,102,102,114,111,109,32,119,104,105,99,104,47,34,32,99,108
-,97,115,115,61,34,103,101,111,108,111,103,105,99,97,108,115,101,118,101,114,97,
-108,32,111,102,100,101,108,105,98,101,114,97,116,101,105,109,112,111,114,116,97,
-110,116,32,104,111,108,100,115,32,116,104,97,116,105,110,103,38,113,117,111,116,
-59,32,118,97,108,105,103,110,61,116,111,112,116,104,101,32,71,101,114,109,97,110
-,111,117,116,115,105,100,101,32,111,102,110,101,103,111,116,105,97,116,101,100,
-104,105,115,32,99,97,114,101,101,114,115,101,112,97,114,97,116,105,111,110,105,
-100,61,34,115,101,97,114,99,104,119,97,115,32,99,97,108,108,101,100,116,104,101,
-32,102,111,117,114,116,104,114,101,99,114,101,97,116,105,111,110,111,116,104,101
-,114,32,116,104,97,110,112,114,101,118,101,110,116,105,111,110,119,104,105,108,
-101,32,116,104,101,32,101,100,117,99,97,116,105,111,110,44,99,111,110,110,101,99
-,116,105,110,103,97,99,99,117,114,97,116,101,108,121,119,101,114,101,32,98,117,
-105,108,116,119,97,115,32,107,105,108,108,101,100,97,103,114,101,101,109,101,110
-,116,115,109,117,99,104,32,109,111,114,101,32,68,117,101,32,116,111,32,116,104,
-101,119,105,100,116,104,58,32,49,48,48,115,111,109,101,32,111,116,104,101,114,75
-,105,110,103,100,111,109,32,111,102,116,104,101,32,101,110,116,105,114,101,102,
-97,109,111,117,115,32,102,111,114,116,111,32,99,111,110,110,101,99,116,111,98,
-106,101,99,116,105,118,101,115,116,104,101,32,70,114,101,110,99,104,112,101,111,
-112,108,101,32,97,110,100,102,101,97,116,117,114,101,100,34,62,105,115,32,115,97
-,105,100,32,116,111,115,116,114,117,99,116,117,114,97,108,114,101,102,101,114,
-101,110,100,117,109,109,111,115,116,32,111,102,116,101,110,97,32,115,101,112,97,
-114,97,116,101,45,62,10,60,100,105,118,32,105,100,32,79,102,102,105,99,105,97,
-108,32,119,111,114,108,100,119,105,100,101,46,97,114,105,97,45,108,97,98,101,108
-,116,104,101,32,112,108,97,110,101,116,97,110,100,32,105,116,32,119,97,115,100,
-34,32,118,97,108,117,101,61,34,108,111,111,107,105,110,103,32,97,116,98,101,110,
-101,102,105,99,105,97,108,97,114,101,32,105,110,32,116,104,101,109,111,110,105,
-116,111,114,105,110,103,114,101,112,111,114,116,101,100,108,121,116,104,101,32,
-109,111,100,101,114,110,119,111,114,107,105,110,103,32,111,110,97,108,108,111,
-119,101,100,32,116,111,119,104,101,114,101,32,116,104,101,32,105,110,110,111,118
-,97,116,105,118,101,60,47,97,62,60,47,100,105,118,62,115,111,117,110,100,116,114
-,97,99,107,115,101,97,114,99,104,70,111,114,109,116,101,110,100,32,116,111,32,98
-,101,105,110,112,117,116,32,105,100,61,34,111,112,101,110,105,110,103,32,111,102
-,114,101,115,116,114,105,99,116,101,100,97,100,111,112,116,101,100,32,98,121,97,
-100,100,114,101,115,115,105,110,103,116,104,101,111,108,111,103,105,97,110,109,
-101,116,104,111,100,115,32,111,102,118,97,114,105,97,110,116,32,111,102,67,104,
-114,105,115,116,105,97,110,32,118,101,114,121,32,108,97,114,103,101,97,117,116,
-111,109,111,116,105,118,101,98,121,32,102,97,114,32,116,104,101,114,97,110,103,
-101,32,102,114,111,109,112,117,114,115,117,105,116,32,111,102,102,111,108,108,
-111,119,32,116,104,101,98,114,111,117,103,104,116,32,116,111,105,110,32,69,110,
-103,108,97,110,100,97,103,114,101,101,32,116,104,97,116,97,99,99,117,115,101,100
-,32,111,102,99,111,109,101,115,32,102,114,111,109,112,114,101,118,101,110,116,
-105,110,103,100,105,118,32,115,116,121,108,101,61,104,105,115,32,111,114,32,104,
-101,114,116,114,101,109,101,110,100,111,117,115,102,114,101,101,100,111,109,32,
-111,102,99,111,110,99,101,114,110,105,110,103,48,32,49,101,109,32,49,101,109,59,
-66,97,115,107,101,116,98,97,108,108,47,115,116,121,108,101,46,99,115,115,97,110,
-32,101,97,114,108,105,101,114,101,118,101,110,32,97,102,116,101,114,47,34,32,116
-,105,116,108,101,61,34,46,99,111,109,47,105,110,100,101,120,116,97,107,105,110,
-103,32,116,104,101,112,105,116,116,115,98,117,114,103,104,99,111,110,116,101,110
-,116,34,62,13,60,115,99,114,105,112,116,62,40,102,116,117,114,110,101,100,32,111
-,117,116,104,97,118,105,110,103,32,116,104,101,60,47,115,112,97,110,62,13,10,32,
-111,99,99,97,115,105,111,110,97,108,98,101,99,97,117,115,101,32,105,116,115,116,
-97,114,116,101,100,32,116,111,112,104,121,115,105,99,97,108,108,121,62,60,47,100
-,105,118,62,10,32,32,99,114,101,97,116,101,100,32,98,121,67,117,114,114,101,110,
-116,108,121,44,32,98,103,99,111,108,111,114,61,34,116,97,98,105,110,100,101,120,
-61,34,100,105,115,97,115,116,114,111,117,115,65,110,97,108,121,116,105,99,115,32
-,97,108,115,111,32,104,97,115,32,97,62,60,100,105,118,32,105,100,61,34,60,47,115
-,116,121,108,101,62,10,60,99,97,108,108,101,100,32,102,111,114,115,105,110,103,
-101,114,32,97,110,100,46,115,114,99,32,61,32,34,47,47,118,105,111,108,97,116,105
-,111,110,115,116,104,105,115,32,112,111,105,110,116,99,111,110,115,116,97,110,
-116,108,121,105,115,32,108,111,99,97,116,101,100,114,101,99,111,114,100,105,110,
-103,115,100,32,102,114,111,109,32,116,104,101,110,101,100,101,114,108,97,110,100
-,115,112,111,114,116,117,103,117,195,170,115,215,162,215,145,215,168,215,153,215
-,170,217,129,216,167,216,177,216,179,219,140,100,101,115,97,114,114,111,108,108,
-111,99,111,109,101,110,116,97,114,105,111,101,100,117,99,97,99,105,195,179,110,
-115,101,112,116,105,101,109,98,114,101,114,101,103,105,115,116,114,97,100,111,
-100,105,114,101,99,99,105,195,179,110,117,98,105,99,97,99,105,195,179,110,112,
-117,98,108,105,99,105,100,97,100,114,101,115,112,117,101,115,116,97,115,114,101,
-115,117,108,116,97,100,111,115,105,109,112,111,114,116,97,110,116,101,114,101,
-115,101,114,118,97,100,111,115,97,114,116,195,173,99,117,108,111,115,100,105,102
-,101,114,101,110,116,101,115,115,105,103,117,105,101,110,116,101,115,114,101,112
-,195,186,98,108,105,99,97,115,105,116,117,97,99,105,195,179,110,109,105,110,105,
-115,116,101,114,105,111,112,114,105,118,97,99,105,100,97,100,100,105,114,101,99,
-116,111,114,105,111,102,111,114,109,97,99,105,195,179,110,112,111,98,108,97,99,
-105,195,179,110,112,114,101,115,105,100,101,110,116,101,99,111,110,116,101,110,
-105,100,111,115,97,99,99,101,115,111,114,105,111,115,116,101,99,104,110,111,114,
-97,116,105,112,101,114,115,111,110,97,108,101,115,99,97,116,101,103,111,114,195,
-173,97,101,115,112,101,99,105,97,108,101,115,100,105,115,112,111,110,105,98,108,
-101,97,99,116,117,97,108,105,100,97,100,114,101,102,101,114,101,110,99,105,97,
-118,97,108,108,97,100,111,108,105,100,98,105,98,108,105,111,116,101,99,97,114,
-101,108,97,99,105,111,110,101,115,99,97,108,101,110,100,97,114,105,111,112,111,
-108,195,173,116,105,99,97,115,97,110,116,101,114,105,111,114,101,115,100,111,99,
-117,109,101,110,116,111,115,110,97,116,117,114,97,108,101,122,97,109,97,116,101,
-114,105,97,108,101,115,100,105,102,101,114,101,110,99,105,97,101,99,111,110,195,
-179,109,105,99,97,116,114,97,110,115,112,111,114,116,101,114,111,100,114,195,173
-,103,117,101,122,112,97,114,116,105,99,105,112,97,114,101,110,99,117,101,110,116
-,114,97,110,100,105,115,99,117,115,105,195,179,110,101,115,116,114,117,99,116,
-117,114,97,102,117,110,100,97,99,105,195,179,110,102,114,101,99,117,101,110,116,
-101,115,112,101,114,109,97,110,101,110,116,101,116,111,116,97,108,109,101,110,
-116,101,208,188,208,190,208,182,208,189,208,190,208,177,209,131,208,180,208,181,
-209,130,208,188,208,190,208,182,208,181,209,130,208,178,209,128,208,181,208,188,
-209,143,209,130,208,176,208,186,208,182,208,181,209,135,209,130,208,190,208,177,
-209,139,208,177,208,190,208,187,208,181,208,181,208,190,209,135,208,181,208,189,
-209,140,209,141,209,130,208,190,208,179,208,190,208,186,208,190,208,179,208,180,
-208,176,208,191,208,190,209,129,208,187,208,181,208,178,209,129,208,181,208,179,
-208,190,209,129,208,176,208,185,209,130,208,181,209,135,208,181,209,128,208,181,
-208,183,208,188,208,190,208,179,209,131,209,130,209,129,208,176,208,185,209,130,
-208,176,208,182,208,184,208,183,208,189,208,184,208,188,208,181,208,182,208,180,
-209,131,208,177,209,131,208,180,209,131,209,130,208,159,208,190,208,184,209,129,
-208,186,208,183,208,180,208,181,209,129,209,140,208,178,208,184,208,180,208,181,
-208,190,209,129,208,178,209,143,208,183,208,184,208,189,209,131,208,182,208,189,
-208,190,209,129,208,178,208,190,208,181,208,185,208,187,209,142,208,180,208,181,
-208,185,208,191,208,190,209,128,208,189,208,190,208,188,208,189,208,190,208,179,
-208,190,208,180,208,181,209,130,208,181,208,185,209,129,208,178,208,190,208,184,
-209,133,208,191,209,128,208,176,208,178,208,176,209,130,208,176,208,186,208,190,
-208,185,208,188,208,181,209,129,209,130,208,190,208,184,208,188,208,181,208,181,
-209,130,208,182,208,184,208,183,208,189,209,140,208,190,208,180,208,189,208,190,
-208,185,208,187,209,131,209,135,209,136,208,181,208,191,208,181,209,128,208,181,
-208,180,209,135,208,176,209,129,209,130,208,184,209,135,208,176,209,129,209,130,
-209,140,209,128,208,176,208,177,208,190,209,130,208,189,208,190,208,178,209,139,
-209,133,208,191,209,128,208,176,208,178,208,190,209,129,208,190,208,177,208,190,
-208,185,208,191,208,190,209,130,208,190,208,188,208,188,208,181,208,189,208,181,
-208,181,209,135,208,184,209,129,208,187,208,181,208,189,208,190,208,178,209,139,
-208,181,209,131,209,129,208,187,209,131,208,179,208,190,208,186,208,190,208,187,
-208,190,208,189,208,176,208,183,208,176,208,180,209,130,208,176,208,186,208,190,
-208,181,209,130,208,190,208,179,208,180,208,176,208,191,208,190,209,135,209,130,
-208,184,208,159,208,190,209,129,208,187,208,181,209,130,208,176,208,186,208,184,
-208,181,208,189,208,190,208,178,209,139,208,185,209,129,209,130,208,190,208,184,
-209,130,209,130,208,176,208,186,208,184,209,133,209,129,209,128,208,176,208,183,
-209,131,208,161,208,176,208,189,208,186,209,130,209,132,208,190,209,128,209,131,
-208,188,208,154,208,190,208,179,208,180,208,176,208,186,208,189,208,184,208,179,
-208,184,209,129,208,187,208,190,208,178,208,176,208,189,208,176,209,136,208,181,
-208,185,208,189,208,176,208,185,209,130,208,184,209,129,208,178,208,190,208,184,
-208,188,209,129,208,178,209,143,208,183,209,140,208,187,209,142,208,177,208,190,
-208,185,209,135,208,176,209,129,209,130,208,190,209,129,209,128,208,181,208,180,
-208,184,208,154,209,128,208,190,208,188,208,181,208,164,208,190,209,128,209,131,
-208,188,209,128,209,139,208,189,208,186,208,181,209,129,209,130,208,176,208,187,
-208,184,208,191,208,190,208,184,209,129,208,186,209,130,209,139,209,129,209,143,
-209,135,208,188,208,181,209,129,209,143,209,134,209,134,208,181,208,189,209,130,
-209,128,209,130,209,128,209,131,208,180,208,176,209,129,208,176,208,188,209,139,
-209,133,209,128,209,139,208,189,208,186,208,176,208,157,208,190,208,178,209,139,
-208,185,209,135,208,176,209,129,208,190,208,178,208,188,208,181,209,129,209,130,
-208,176,209,132,208,184,208,187,209,140,208,188,208,188,208,176,209,128,209,130,
-208,176,209,129,209,130,209,128,208,176,208,189,208,188,208,181,209,129,209,130,
-208,181,209,130,208,181,208,186,209,129,209,130,208,189,208,176,209,136,208,184,
-209,133,208,188,208,184,208,189,209,131,209,130,208,184,208,188,208,181,208,189,
-208,184,208,184,208,188,208,181,209,142,209,130,208,189,208,190,208,188,208,181,
-209,128,208,179,208,190,209,128,208,190,208,180,209,129,208,176,208,188,208,190,
-208,188,209,141,209,130,208,190,208,188,209,131,208,186,208,190,208,189,209,134,
-208,181,209,129,208,178,208,190,208,181,208,188,208,186,208,176,208,186,208,190,
-208,185,208,144,209,128,209,133,208,184,208,178,217,133,217,134,216,170,216,175,
-217,137,216,165,216,177,216,179,216,167,217,132,216,177,216,179,216,167,217,132,
-216,169,216,167,217,132,216,185,216,167,217,133,217,131,216,170,216,168,217,135,
-216,167,216,168,216,177,216,167,217,133,216,172,216,167,217,132,217,138,217,136,
-217,133,216,167,217,132,216,181,217,136,216,177,216,172,216,175,217,138,216,175,
-216,169,216,167,217,132,216,185,216,182,217,136,216,165,216,182,216,167,217,129,
-216,169,216,167,217,132,217,130,216,179,217,133,216,167,217,132,216,185,216,167,
-216,168,216,170,216,173,217,133,217,138,217,132,217,133,217,132,217,129,216,167,
-216,170,217,133,217,132,216,170,217,130,217,137,216,170,216,185,216,175,217,138,
-217,132,216,167,217,132,216,180,216,185,216,177,216,163,216,174,216,168,216,167,
-216,177,216,170,216,183,217,136,217,138,216,177,216,185,217,132,217,138,217,131,
-217,133,216,165,216,177,217,129,216,167,217,130,216,183,217,132,216,168,216,167,
-216,170,216,167,217,132,217,132,216,186,216,169,216,170,216,177,216,170,217,138,
-216,168,216,167,217,132,217,134,216,167,216,179,216,167,217,132,216,180,217,138,
-216,174,217,133,217,134,216,170,216,175,217,138,216,167,217,132,216,185,216,177,
-216,168,216,167,217,132,217,130,216,181,216,181,216,167,217,129,217,132,216,167,
-217,133,216,185,217,132,217,138,217,135,216,167,216,170,216,173,216,175,217,138,
-216,171,216,167,217,132,217,132,217,135,217,133,216,167,217,132,216,185,217,133,
-217,132,217,133,217,131,216,170,216,168,216,169,217,138,217,133,217,131,217,134,
-217,131,216,167,217,132,216,183,217,129,217,132,217,129,217,138,216,175,217,138,
-217,136,216,165,216,175,216,167,216,177,216,169,216,170,216,167,216,177,217,138,
-216,174,216,167,217,132,216,181,216,173,216,169,216,170,216,179,216,172,217,138,
-217,132,216,167,217,132,217,136,217,130,216,170,216,185,217,134,216,175,217,133,
-216,167,217,133,216,175,217,138,217,134,216,169,216,170,216,181,217,133,217,138,
-217,133,216,163,216,177,216,180,217,138,217,129,216,167,217,132,216,176,217,138,
-217,134,216,185,216,177,216,168,217,138,216,169,216,168,217,136,216,167,216,168,
-216,169,216,163,217,132,216,185,216,167,216,168,216,167,217,132,216,179,217,129,
-216,177,217,133,216,180,216,167,217,131,217,132,216,170,216,185,216,167,217,132,
-217,137,216,167,217,132,216,163,217,136,217,132,216,167,217,132,216,179,217,134,
-216,169,216,172,216,167,217,133,216,185,216,169,216,167,217,132,216,181,216,173,
-217,129,216,167,217,132,216,175,217,138,217,134,217,131,217,132,217,133,216,167,
-216,170,216,167,217,132,216,174,216,167,216,181,216,167,217,132,217,133,217,132,
-217,129,216,163,216,185,216,182,216,167,216,161,217,131,216,170,216,167,216,168,
-216,169,216,167,217,132,216,174,217,138,216,177,216,177,216,179,216,167,216,166,
-217,132,216,167,217,132,217,130,217,132,216,168,216,167,217,132,216,163,216,175,
-216,168,217,133,217,130,216,167,216,183,216,185,217,133,216,177,216,167,216,179,
-217,132,217,133,217,134,216,183,217,130,216,169,216,167,217,132,217,131,216,170,
-216,168,216,167,217,132,216,177,216,172,217,132,216,167,216,180,216,170,216,177,
-217,131,216,167,217,132,217,130,216,175,217,133,217,138,216,185,216,183,217,138,
-217,131,115,66,121,84,97,103,78,97,109,101,40,46,106,112,103,34,32,97,108,116,61
-,34,49,112,120,32,115,111,108,105,100,32,35,46,103,105,102,34,32,97,108,116,61,
-34,116,114,97,110,115,112,97,114,101,110,116,105,110,102,111,114,109,97,116,105,
-111,110,97,112,112,108,105,99,97,116,105,111,110,34,32,111,110,99,108,105,99,107
-,61,34,101,115,116,97,98,108,105,115,104,101,100,97,100,118,101,114,116,105,115,
-105,110,103,46,112,110,103,34,32,97,108,116,61,34,101,110,118,105,114,111,110,
-109,101,110,116,112,101,114,102,111,114,109,97,110,99,101,97,112,112,114,111,112
-,114,105,97,116,101,38,97,109,112,59,109,100,97,115,104,59,105,109,109,101,100,
-105,97,116,101,108,121,60,47,115,116,114,111,110,103,62,60,47,114,97,116,104,101
-,114,32,116,104,97,110,116,101,109,112,101,114,97,116,117,114,101,100,101,118,
-101,108,111,112,109,101,110,116,99,111,109,112,101,116,105,116,105,111,110,112,
-108,97,99,101,104,111,108,100,101,114,118,105,115,105,98,105,108,105,116,121,58,
-99,111,112,121,114,105,103,104,116,34,62,48,34,32,104,101,105,103,104,116,61,34,
-101,118,101,110,32,116,104,111,117,103,104,114,101,112,108,97,99,101,109,101,110
-,116,100,101,115,116,105,110,97,116,105,111,110,67,111,114,112,111,114,97,116,
-105,111,110,60,117,108,32,99,108,97,115,115,61,34,65,115,115,111,99,105,97,116,
-105,111,110,105,110,100,105,118,105,100,117,97,108,115,112,101,114,115,112,101,
-99,116,105,118,101,115,101,116,84,105,109,101,111,117,116,40,117,114,108,40,104,
-116,116,112,58,47,47,109,97,116,104,101,109,97,116,105,99,115,109,97,114,103,105
-,110,45,116,111,112,58,101,118,101,110,116,117,97,108,108,121,32,100,101,115,99,
-114,105,112,116,105,111,110,41,32,110,111,45,114,101,112,101,97,116,99,111,108,
-108,101,99,116,105,111,110,115,46,74,80,71,124,116,104,117,109,98,124,112,97,114
-,116,105,99,105,112,97,116,101,47,104,101,97,100,62,60,98,111,100,121,102,108,
-111,97,116,58,108,101,102,116,59,60,108,105,32,99,108,97,115,115,61,34,104,117,
-110,100,114,101,100,115,32,111,102,10,10,72,111,119,101,118,101,114,44,32,99,111
-,109,112,111,115,105,116,105,111,110,99,108,101,97,114,58,98,111,116,104,59,99,
-111,111,112,101,114,97,116,105,111,110,119,105,116,104,105,110,32,116,104,101,32
-,108,97,98,101,108,32,102,111,114,61,34,98,111,114,100,101,114,45,116,111,112,58
-,78,101,119,32,90,101,97,108,97,110,100,114,101,99,111,109,109,101,110,100,101,
-100,112,104,111,116,111,103,114,97,112,104,121,105,110,116,101,114,101,115,116,
-105,110,103,38,108,116,59,115,117,112,38,103,116,59,99,111,110,116,114,111,118,
-101,114,115,121,78,101,116,104,101,114,108,97,110,100,115,97,108,116,101,114,110
-,97,116,105,118,101,109,97,120,108,101,110,103,116,104,61,34,115,119,105,116,122
-,101,114,108,97,110,100,68,101,118,101,108,111,112,109,101,110,116,101,115,115,
-101,110,116,105,97,108,108,121,10,10,65,108,116,104,111,117,103,104,32,60,47,116
-,101,120,116,97,114,101,97,62,116,104,117,110,100,101,114,98,105,114,100,114,101
-,112,114,101,115,101,110,116,101,100,38,97,109,112,59,110,100,97,115,104,59,115,
-112,101,99,117,108,97,116,105,111,110,99,111,109,109,117,110,105,116,105,101,115
-,108,101,103,105,115,108,97,116,105,111,110,101,108,101,99,116,114,111,110,105,
-99,115,10,9,60,100,105,118,32,105,100,61,34,105,108,108,117,115,116,114,97,116,
-101,100,101,110,103,105,110,101,101,114,105,110,103,116,101,114,114,105,116,111,
-114,105,101,115,97,117,116,104,111,114,105,116,105,101,115,100,105,115,116,114,
-105,98,117,116,101,100,54,34,32,104,101,105,103,104,116,61,34,115,97,110,115,45,
-115,101,114,105,102,59,99,97,112,97,98,108,101,32,111,102,32,100,105,115,97,112,
-112,101,97,114,101,100,105,110,116,101,114,97,99,116,105,118,101,108,111,111,107
-,105,110,103,32,102,111,114,105,116,32,119,111,117,108,100,32,98,101,65,102,103,
-104,97,110,105,115,116,97,110,119,97,115,32,99,114,101,97,116,101,100,77,97,116,
-104,46,102,108,111,111,114,40,115,117,114,114,111,117,110,100,105,110,103,99,97,
-110,32,97,108,115,111,32,98,101,111,98,115,101,114,118,97,116,105,111,110,109,97
-,105,110,116,101,110,97,110,99,101,101,110,99,111,117,110,116,101,114,101,100,60
-,104,50,32,99,108,97,115,115,61,34,109,111,114,101,32,114,101,99,101,110,116,105
-,116,32,104,97,115,32,98,101,101,110,105,110,118,97,115,105,111,110,32,111,102,
-41,46,103,101,116,84,105,109,101,40,41,102,117,110,100,97,109,101,110,116,97,108
-,68,101,115,112,105,116,101,32,116,104,101,34,62,60,100,105,118,32,105,100,61,34
-,105,110,115,112,105,114,97,116,105,111,110,101,120,97,109,105,110,97,116,105,
-111,110,112,114,101,112,97,114,97,116,105,111,110,101,120,112,108,97,110,97,116,
-105,111,110,60,105,110,112,117,116,32,105,100,61,34,60,47,97,62,60,47,115,112,97
-,110,62,118,101,114,115,105,111,110,115,32,111,102,105,110,115,116,114,117,109,
-101,110,116,115,98,101,102,111,114,101,32,116,104,101,32,32,61,32,39,104,116,116
-,112,58,47,47,68,101,115,99,114,105,112,116,105,111,110,114,101,108,97,116,105,
-118,101,108,121,32,46,115,117,98,115,116,114,105,110,103,40,101,97,99,104,32,111
-,102,32,116,104,101,101,120,112,101,114,105,109,101,110,116,115,105,110,102,108,
-117,101,110,116,105,97,108,105,110,116,101,103,114,97,116,105,111,110,109,97,110
-,121,32,112,101,111,112,108,101,100,117,101,32,116,111,32,116,104,101,32,99,111,
-109,98,105,110,97,116,105,111,110,100,111,32,110,111,116,32,104,97,118,101,77,
-105,100,100,108,101,32,69,97,115,116,60,110,111,115,99,114,105,112,116,62,60,99,
-111,112,121,114,105,103,104,116,34,32,112,101,114,104,97,112,115,32,116,104,101,
-105,110,115,116,105,116,117,116,105,111,110,105,110,32,68,101,99,101,109,98,101,
-114,97,114,114,97,110,103,101,109,101,110,116,109,111,115,116,32,102,97,109,111,
-117,115,112,101,114,115,111,110,97,108,105,116,121,99,114,101,97,116,105,111,110
-,32,111,102,108,105,109,105,116,97,116,105,111,110,115,101,120,99,108,117,115,
-105,118,101,108,121,115,111,118,101,114,101,105,103,110,116,121,45,99,111,110,
-116,101,110,116,34,62,10,60,116,100,32,99,108,97,115,115,61,34,117,110,100,101,
-114,103,114,111,117,110,100,112,97,114,97,108,108,101,108,32,116,111,100,111,99,
-116,114,105,110,101,32,111,102,111,99,99,117,112,105,101,100,32,98,121,116,101,
-114,109,105,110,111,108,111,103,121,82,101,110,97,105,115,115,97,110,99,101,97,
-32,110,117,109,98,101,114,32,111,102,115,117,112,112,111,114,116,32,102,111,114,
-101,120,112,108,111,114,97,116,105,111,110,114,101,99,111,103,110,105,116,105,
-111,110,112,114,101,100,101,99,101,115,115,111,114,60,105,109,103,32,115,114,99,
-61,34,47,60,104,49,32,99,108,97,115,115,61,34,112,117,98,108,105,99,97,116,105,
-111,110,109,97,121,32,97,108,115,111,32,98,101,115,112,101,99,105,97,108,105,122
-,101,100,60,47,102,105,101,108,100,115,101,116,62,112,114,111,103,114,101,115,
-115,105,118,101,109,105,108,108,105,111,110,115,32,111,102,115,116,97,116,101,
-115,32,116,104,97,116,101,110,102,111,114,99,101,109,101,110,116,97,114,111,117,
-110,100,32,116,104,101,32,111,110,101,32,97,110,111,116,104,101,114,46,112,97,
-114,101,110,116,78,111,100,101,97,103,114,105,99,117,108,116,117,114,101,65,108,
-116,101,114,110,97,116,105,118,101,114,101,115,101,97,114,99,104,101,114,115,116
-,111,119,97,114,100,115,32,116,104,101,77,111,115,116,32,111,102,32,116,104,101,
-109,97,110,121,32,111,116,104,101,114,32,40,101,115,112,101,99,105,97,108,108,
-121,60,116,100,32,119,105,100,116,104,61,34,59,119,105,100,116,104,58,49,48,48,
-37,105,110,100,101,112,101,110,100,101,110,116,60,104,51,32,99,108,97,115,115,61
-,34,32,111,110,99,104,97,110,103,101,61,34,41,46,97,100,100,67,108,97,115,115,40
-,105,110,116,101,114,97,99,116,105,111,110,79,110,101,32,111,102,32,116,104,101,
-32,100,97,117,103,104,116,101,114,32,111,102,97,99,99,101,115,115,111,114,105,
-101,115,98,114,97,110,99,104,101,115,32,111,102,13,10,60,100,105,118,32,105,100,
-61,34,116,104,101,32,108,97,114,103,101,115,116,100,101,99,108,97,114,97,116,105
-,111,110,114,101,103,117,108,97,116,105,111,110,115,73,110,102,111,114,109,97,
-116,105,111,110,116,114,97,110,115,108,97,116,105,111,110,100,111,99,117,109,101
-,110,116,97,114,121,105,110,32,111,114,100,101,114,32,116,111,34,62,10,60,104,
-101,97,100,62,10,60,34,32,104,101,105,103,104,116,61,34,49,97,99,114,111,115,115
-,32,116,104,101,32,111,114,105,101,110,116,97,116,105,111,110,41,59,60,47,115,99
-,114,105,112,116,62,105,109,112,108,101,109,101,110,116,101,100,99,97,110,32,98,
-101,32,115,101,101,110,116,104,101,114,101,32,119,97,115,32,97,100,101,109,111,
-110,115,116,114,97,116,101,99,111,110,116,97,105,110,101,114,34,62,99,111,110,
-110,101,99,116,105,111,110,115,116,104,101,32,66,114,105,116,105,115,104,119,97,
-115,32,119,114,105,116,116,101,110,33,105,109,112,111,114,116,97,110,116,59,112,
-120,59,32,109,97,114,103,105,110,45,102,111,108,108,111,119,101,100,32,98,121,97
-,98,105,108,105,116,121,32,116,111,32,99,111,109,112,108,105,99,97,116,101,100,
-100,117,114,105,110,103,32,116,104,101,32,105,109,109,105,103,114,97,116,105,111
-,110,97,108,115,111,32,99,97,108,108,101,100,60,104,52,32,99,108,97,115,115,61,
-34,100,105,115,116,105,110,99,116,105,111,110,114,101,112,108,97,99,101,100,32,
-98,121,103,111,118,101,114,110,109,101,110,116,115,108,111,99,97,116,105,111,110
-,32,111,102,105,110,32,78,111,118,101,109,98,101,114,119,104,101,116,104,101,114
-,32,116,104,101,60,47,112,62,10,60,47,100,105,118,62,97,99,113,117,105,115,105,
-116,105,111,110,99,97,108,108,101,100,32,116,104,101,32,112,101,114,115,101,99,
-117,116,105,111,110,100,101,115,105,103,110,97,116,105,111,110,123,102,111,110,
-116,45,115,105,122,101,58,97,112,112,101,97,114,101,100,32,105,110,105,110,118,
-101,115,116,105,103,97,116,101,101,120,112,101,114,105,101,110,99,101,100,109,
-111,115,116,32,108,105,107,101,108,121,119,105,100,101,108,121,32,117,115,101,
-100,100,105,115,99,117,115,115,105,111,110,115,112,114,101,115,101,110,99,101,32
-,111,102,32,40,100,111,99,117,109,101,110,116,46,101,120,116,101,110,115,105,118
-,101,108,121,73,116,32,104,97,115,32,98,101,101,110,105,116,32,100,111,101,115,
-32,110,111,116,99,111,110,116,114,97,114,121,32,116,111,105,110,104,97,98,105,
-116,97,110,116,115,105,109,112,114,111,118,101,109,101,110,116,115,99,104,111,
-108,97,114,115,104,105,112,99,111,110,115,117,109,112,116,105,111,110,105,110,
-115,116,114,117,99,116,105,111,110,102,111,114,32,101,120,97,109,112,108,101,111
-,110,101,32,111,114,32,109,111,114,101,112,120,59,32,112,97,100,100,105,110,103,
-116,104,101,32,99,117,114,114,101,110,116,97,32,115,101,114,105,101,115,32,111,
-102,97,114,101,32,117,115,117,97,108,108,121,114,111,108,101,32,105,110,32,116,
-104,101,112,114,101,118,105,111,117,115,108,121,32,100,101,114,105,118,97,116,
-105,118,101,115,101,118,105,100,101,110,99,101,32,111,102,101,120,112,101,114,
-105,101,110,99,101,115,99,111,108,111,114,115,99,104,101,109,101,115,116,97,116,
-101,100,32,116,104,97,116,99,101,114,116,105,102,105,99,97,116,101,60,47,97,62,
-60,47,100,105,118,62,10,32,115,101,108,101,99,116,101,100,61,34,104,105,103,104,
-32,115,99,104,111,111,108,114,101,115,112,111,110,115,101,32,116,111,99,111,109,
-102,111,114,116,97,98,108,101,97,100,111,112,116,105,111,110,32,111,102,116,104,
-114,101,101,32,121,101,97,114,115,116,104,101,32,99,111,117,110,116,114,121,105,
-110,32,70,101,98,114,117,97,114,121,115,111,32,116,104,97,116,32,116,104,101,112
-,101,111,112,108,101,32,119,104,111,32,112,114,111,118,105,100,101,100,32,98,121
-,60,112,97,114,97,109,32,110,97,109,101,97,102,102,101,99,116,101,100,32,98,121,
-105,110,32,116,101,114,109,115,32,111,102,97,112,112,111,105,110,116,109,101,110
-,116,73,83,79,45,56,56,53,57,45,49,34,119,97,115,32,98,111,114,110,32,105,110,
-104,105,115,116,111,114,105,99,97,108,32,114,101,103,97,114,100,101,100,32,97,
-115,109,101,97,115,117,114,101,109,101,110,116,105,115,32,98,97,115,101,100,32,
-111,110,32,97,110,100,32,111,116,104,101,114,32,58,32,102,117,110,99,116,105,111
-,110,40,115,105,103,110,105,102,105,99,97,110,116,99,101,108,101,98,114,97,116,
-105,111,110,116,114,97,110,115,109,105,116,116,101,100,47,106,115,47,106,113,117
-,101,114,121,46,105,115,32,107,110,111,119,110,32,97,115,116,104,101,111,114,101
-,116,105,99,97,108,32,116,97,98,105,110,100,101,120,61,34,105,116,32,99,111,117,
-108,100,32,98,101,60,110,111,115,99,114,105,112,116,62,10,104,97,118,105,110,103
-,32,98,101,101,110,13,10,60,104,101,97,100,62,13,10,60,32,38,113,117,111,116,59,
-84,104,101,32,99,111,109,112,105,108,97,116,105,111,110,104,101,32,104,97,100,32
-,98,101,101,110,112,114,111,100,117,99,101,100,32,98,121,112,104,105,108,111,115
-,111,112,104,101,114,99,111,110,115,116,114,117,99,116,101,100,105,110,116,101,
-110,100,101,100,32,116,111,97,109,111,110,103,32,111,116,104,101,114,99,111,109,
-112,97,114,101,100,32,116,111,116,111,32,115,97,121,32,116,104,97,116,69,110,103
-,105,110,101,101,114,105,110,103,97,32,100,105,102,102,101,114,101,110,116,114,
-101,102,101,114,114,101,100,32,116,111,100,105,102,102,101,114,101,110,99,101,
-115,98,101,108,105,101,102,32,116,104,97,116,112,104,111,116,111,103,114,97,112,
-104,115,105,100,101,110,116,105,102,121,105,110,103,72,105,115,116,111,114,121,
-32,111,102,32,82,101,112,117,98,108,105,99,32,111,102,110,101,99,101,115,115,97,
-114,105,108,121,112,114,111,98,97,98,105,108,105,116,121,116,101,99,104,110,105,
-99,97,108,108,121,108,101,97,118,105,110,103,32,116,104,101,115,112,101,99,116,
-97,99,117,108,97,114,102,114,97,99,116,105,111,110,32,111,102,101,108,101,99,116
-,114,105,99,105,116,121,104,101,97,100,32,111,102,32,116,104,101,114,101,115,116
-,97,117,114,97,110,116,115,112,97,114,116,110,101,114,115,104,105,112,101,109,
-112,104,97,115,105,115,32,111,110,109,111,115,116,32,114,101,99,101,110,116,115,
-104,97,114,101,32,119,105,116,104,32,115,97,121,105,110,103,32,116,104,97,116,
-102,105,108,108,101,100,32,119,105,116,104,100,101,115,105,103,110,101,100,32,
-116,111,105,116,32,105,115,32,111,102,116,101,110,34,62,60,47,105,102,114,97,109
-,101,62,97,115,32,102,111,108,108,111,119,115,58,109,101,114,103,101,100,32,119,
-105,116,104,116,104,114,111,117,103,104,32,116,104,101,99,111,109,109,101,114,99
-,105,97,108,32,112,111,105,110,116,101,100,32,111,117,116,111,112,112,111,114,
-116,117,110,105,116,121,118,105,101,119,32,111,102,32,116,104,101,114,101,113,
-117,105,114,101,109,101,110,116,100,105,118,105,115,105,111,110,32,111,102,112,
-114,111,103,114,97,109,109,105,110,103,104,101,32,114,101,99,101,105,118,101,100
-,115,101,116,73,110,116,101,114,118,97,108,34,62,60,47,115,112,97,110,62,60,47,
-105,110,32,78,101,119,32,89,111,114,107,97,100,100,105,116,105,111,110,97,108,32
-,99,111,109,112,114,101,115,115,105,111,110,10,10,60,100,105,118,32,105,100,61,
-34,105,110,99,111,114,112,111,114,97,116,101,59,60,47,115,99,114,105,112,116,62,
-60,97,116,116,97,99,104,69,118,101,110,116,98,101,99,97,109,101,32,116,104,101,
-32,34,32,116,97,114,103,101,116,61,34,95,99,97,114,114,105,101,100,32,111,117,
-116,83,111,109,101,32,111,102,32,116,104,101,115,99,105,101,110,99,101,32,97,110
-,100,116,104,101,32,116,105,109,101,32,111,102,67,111,110,116,97,105,110,101,114
-,34,62,109,97,105,110,116,97,105,110,105,110,103,67,104,114,105,115,116,111,112,
-104,101,114,77,117,99,104,32,111,102,32,116,104,101,119,114,105,116,105,110,103,
-115,32,111,102,34,32,104,101,105,103,104,116,61,34,50,115,105,122,101,32,111,102
-,32,116,104,101,118,101,114,115,105,111,110,32,111,102,32,109,105,120,116,117,
-114,101,32,111,102,32,98,101,116,119,101,101,110,32,116,104,101,69,120,97,109,
-112,108,101,115,32,111,102,101,100,117,99,97,116,105,111,110,97,108,99,111,109,
-112,101,116,105,116,105,118,101,32,111,110,115,117,98,109,105,116,61,34,100,105,
-114,101,99,116,111,114,32,111,102,100,105,115,116,105,110,99,116,105,118,101,47,
-68,84,68,32,88,72,84,77,76,32,114,101,108,97,116,105,110,103,32,116,111,116,101,
-110,100,101,110,99,121,32,116,111,112,114,111,118,105,110,99,101,32,111,102,119,
-104,105,99,104,32,119,111,117,108,100,100,101,115,112,105,116,101,32,116,104,101
-,115,99,105,101,110,116,105,102,105,99,32,108,101,103,105,115,108,97,116,117,114
-,101,46,105,110,110,101,114,72,84,77,76,32,97,108,108,101,103,97,116,105,111,110
-,115,65,103,114,105,99,117,108,116,117,114,101,119,97,115,32,117,115,101,100,32,
-105,110,97,112,112,114,111,97,99,104,32,116,111,105,110,116,101,108,108,105,103,
-101,110,116,121,101,97,114,115,32,108,97,116,101,114,44,115,97,110,115,45,115,
-101,114,105,102,100,101,116,101,114,109,105,110,105,110,103,80,101,114,102,111,
-114,109,97,110,99,101,97,112,112,101,97,114,97,110,99,101,115,44,32,119,104,105,
-99,104,32,105,115,32,102,111,117,110,100,97,116,105,111,110,115,97,98,98,114,101
-,118,105,97,116,101,100,104,105,103,104,101,114,32,116,104,97,110,115,32,102,114
-,111,109,32,116,104,101,32,105,110,100,105,118,105,100,117,97,108,32,99,111,109,
-112,111,115,101,100,32,111,102,115,117,112,112,111,115,101,100,32,116,111,99,108
-,97,105,109,115,32,116,104,97,116,97,116,116,114,105,98,117,116,105,111,110,102,
-111,110,116,45,115,105,122,101,58,49,101,108,101,109,101,110,116,115,32,111,102,
-72,105,115,116,111,114,105,99,97,108,32,104,105,115,32,98,114,111,116,104,101,
-114,97,116,32,116,104,101,32,116,105,109,101,97,110,110,105,118,101,114,115,97,
-114,121,103,111,118,101,114,110,101,100,32,98,121,114,101,108,97,116,101,100,32,
-116,111,32,117,108,116,105,109,97,116,101,108,121,32,105,110,110,111,118,97,116,
-105,111,110,115,105,116,32,105,115,32,115,116,105,108,108,99,97,110,32,111,110,
-108,121,32,98,101,100,101,102,105,110,105,116,105,111,110,115,116,111,71,77,84,
-83,116,114,105,110,103,65,32,110,117,109,98,101,114,32,111,102,105,109,103,32,99
-,108,97,115,115,61,34,69,118,101,110,116,117,97,108,108,121,44,119,97,115,32,99,
-104,97,110,103,101,100,111,99,99,117,114,114,101,100,32,105,110,110,101,105,103,
-104,98,111,114,105,110,103,100,105,115,116,105,110,103,117,105,115,104,119,104,
-101,110,32,104,101,32,119,97,115,105,110,116,114,111,100,117,99,105,110,103,116,
-101,114,114,101,115,116,114,105,97,108,77,97,110,121,32,111,102,32,116,104,101,
-97,114,103,117,101,115,32,116,104,97,116,97,110,32,65,109,101,114,105,99,97,110,
-99,111,110,113,117,101,115,116,32,111,102,119,105,100,101,115,112,114,101,97,100
-,32,119,101,114,101,32,107,105,108,108,101,100,115,99,114,101,101,110,32,97,110,
-100,32,73,110,32,111,114,100,101,114,32,116,111,101,120,112,101,99,116,101,100,
-32,116,111,100,101,115,99,101,110,100,97,110,116,115,97,114,101,32,108,111,99,97
-,116,101,100,108,101,103,105,115,108,97,116,105,118,101,103,101,110,101,114,97,
-116,105,111,110,115,32,98,97,99,107,103,114,111,117,110,100,109,111,115,116,32,
-112,101,111,112,108,101,121,101,97,114,115,32,97,102,116,101,114,116,104,101,114
-,101,32,105,115,32,110,111,116,104,101,32,104,105,103,104,101,115,116,102,114,
-101,113,117,101,110,116,108,121,32,116,104,101,121,32,100,111,32,110,111,116,97,
-114,103,117,101,100,32,116,104,97,116,115,104,111,119,101,100,32,116,104,97,116,
-112,114,101,100,111,109,105,110,97,110,116,116,104,101,111,108,111,103,105,99,97
-,108,98,121,32,116,104,101,32,116,105,109,101,99,111,110,115,105,100,101,114,105
-,110,103,115,104,111,114,116,45,108,105,118,101,100,60,47,115,112,97,110,62,60,
-47,97,62,99,97,110,32,98,101,32,117,115,101,100,118,101,114,121,32,108,105,116,
-116,108,101,111,110,101,32,111,102,32,116,104,101,32,104,97,100,32,97,108,114,
-101,97,100,121,105,110,116,101,114,112,114,101,116,101,100,99,111,109,109,117,
-110,105,99,97,116,101,102,101,97,116,117,114,101,115,32,111,102,103,111,118,101,
-114,110,109,101,110,116,44,60,47,110,111,115,99,114,105,112,116,62,101,110,116,
-101,114,101,100,32,116,104,101,34,32,104,101,105,103,104,116,61,34,51,73,110,100
-,101,112,101,110,100,101,110,116,112,111,112,117,108,97,116,105,111,110,115,108,
-97,114,103,101,45,115,99,97,108,101,46,32,65,108,116,104,111,117,103,104,32,117,
-115,101,100,32,105,110,32,116,104,101,100,101,115,116,114,117,99,116,105,111,110
-,112,111,115,115,105,98,105,108,105,116,121,115,116,97,114,116,105,110,103,32,
-105,110,116,119,111,32,111,114,32,109,111,114,101,101,120,112,114,101,115,115,
-105,111,110,115,115,117,98,111,114,100,105,110,97,116,101,108,97,114,103,101,114
-,32,116,104,97,110,104,105,115,116,111,114,121,32,97,110,100,60,47,111,112,116,
-105,111,110,62,13,10,67,111,110,116,105,110,101,110,116,97,108,101,108,105,109,
-105,110,97,116,105,110,103,119,105,108,108,32,110,111,116,32,98,101,112,114,97,
-99,116,105,99,101,32,111,102,105,110,32,102,114,111,110,116,32,111,102,115,105,
-116,101,32,111,102,32,116,104,101,101,110,115,117,114,101,32,116,104,97,116,116,
-111,32,99,114,101,97,116,101,32,97,109,105,115,115,105,115,115,105,112,112,105,
-112,111,116,101,110,116,105,97,108,108,121,111,117,116,115,116,97,110,100,105,
-110,103,98,101,116,116,101,114,32,116,104,97,110,119,104,97,116,32,105,115,32,
-110,111,119,115,105,116,117,97,116,101,100,32,105,110,109,101,116,97,32,110,97,
-109,101,61,34,84,114,97,100,105,116,105,111,110,97,108,115,117,103,103,101,115,
-116,105,111,110,115,84,114,97,110,115,108,97,116,105,111,110,116,104,101,32,102,
-111,114,109,32,111,102,97,116,109,111,115,112,104,101,114,105,99,105,100,101,111
-,108,111,103,105,99,97,108,101,110,116,101,114,112,114,105,115,101,115,99,97,108
-,99,117,108,97,116,105,110,103,101,97,115,116,32,111,102,32,116,104,101,114,101,
-109,110,97,110,116,115,32,111,102,112,108,117,103,105,110,115,112,97,103,101,47,
-105,110,100,101,120,46,112,104,112,63,114,101,109,97,105,110,101,100,32,105,110,
-116,114,97,110,115,102,111,114,109,101,100,72,101,32,119,97,115,32,97,108,115,
-111,119,97,115,32,97,108,114,101,97,100,121,115,116,97,116,105,115,116,105,99,97
-,108,105,110,32,102,97,118,111,114,32,111,102,77,105,110,105,115,116,114,121,32,
-111,102,109,111,118,101,109,101,110,116,32,111,102,102,111,114,109,117,108,97,
-116,105,111,110,105,115,32,114,101,113,117,105,114,101,100,60,108,105,110,107,32
-,114,101,108,61,34,84,104,105,115,32,105,115,32,116,104,101,32,60,97,32,104,114,
-101,102,61,34,47,112,111,112,117,108,97,114,105,122,101,100,105,110,118,111,108,
-118,101,100,32,105,110,97,114,101,32,117,115,101,100,32,116,111,97,110,100,32,
-115,101,118,101,114,97,108,109,97,100,101,32,98,121,32,116,104,101,115,101,101,
-109,115,32,116,111,32,98,101,108,105,107,101,108,121,32,116,104,97,116,80,97,108
-,101,115,116,105,110,105,97,110,110,97,109,101,100,32,97,102,116,101,114,105,116
-,32,104,97,100,32,98,101,101,110,109,111,115,116,32,99,111,109,109,111,110,116,
-111,32,114,101,102,101,114,32,116,111,98,117,116,32,116,104,105,115,32,105,115,
-99,111,110,115,101,99,117,116,105,118,101,116,101,109,112,111,114,97,114,105,108
-,121,73,110,32,103,101,110,101,114,97,108,44,99,111,110,118,101,110,116,105,111,
-110,115,116,97,107,101,115,32,112,108,97,99,101,115,117,98,100,105,118,105,115,
-105,111,110,116,101,114,114,105,116,111,114,105,97,108,111,112,101,114,97,116,
-105,111,110,97,108,112,101,114,109,97,110,101,110,116,108,121,119,97,115,32,108,
-97,114,103,101,108,121,111,117,116,98,114,101,97,107,32,111,102,105,110,32,116,
-104,101,32,112,97,115,116,102,111,108,108,111,119,105,110,103,32,97,32,120,109,
-108,110,115,58,111,103,61,34,62,60,97,32,99,108,97,115,115,61,34,99,108,97,115,
-115,61,34,116,101,120,116,67,111,110,118,101,114,115,105,111,110,32,109,97,121,
-32,98,101,32,117,115,101,100,109,97,110,117,102,97,99,116,117,114,101,97,102,116
-,101,114,32,98,101,105,110,103,99,108,101,97,114,102,105,120,34,62,10,113,117,
-101,115,116,105,111,110,32,111,102,119,97,115,32,101,108,101,99,116,101,100,116,
-111,32,98,101,99,111,109,101,32,97,98,101,99,97,117,115,101,32,111,102,32,115,
-111,109,101,32,112,101,111,112,108,101,105,110,115,112,105,114,101,100,32,98,121
-,115,117,99,99,101,115,115,102,117,108,32,97,32,116,105,109,101,32,119,104,101,
-110,109,111,114,101,32,99,111,109,109,111,110,97,109,111,110,103,115,116,32,116,
-104,101,97,110,32,111,102,102,105,99,105,97,108,119,105,100,116,104,58,49,48,48,
-37,59,116,101,99,104,110,111,108,111,103,121,44,119,97,115,32,97,100,111,112,116
-,101,100,116,111,32,107,101,101,112,32,116,104,101,115,101,116,116,108,101,109,
-101,110,116,115,108,105,118,101,32,98,105,114,116,104,115,105,110,100,101,120,46
-,104,116,109,108,34,67,111,110,110,101,99,116,105,99,117,116,97,115,115,105,103,
-110,101,100,32,116,111,38,97,109,112,59,116,105,109,101,115,59,97,99,99,111,117,
-110,116,32,102,111,114,97,108,105,103,110,61,114,105,103,104,116,116,104,101,32,
-99,111,109,112,97,110,121,97,108,119,97,121,115,32,98,101,101,110,114,101,116,
-117,114,110,101,100,32,116,111,105,110,118,111,108,118,101,109,101,110,116,66,
-101,99,97,117,115,101,32,116,104,101,116,104,105,115,32,112,101,114,105,111,100,
-34,32,110,97,109,101,61,34,113,34,32,99,111,110,102,105,110,101,100,32,116,111,
-97,32,114,101,115,117,108,116,32,111,102,118,97,108,117,101,61,34,34,32,47,62,
-105,115,32,97,99,116,117,97,108,108,121,69,110,118,105,114,111,110,109,101,110,
-116,13,10,60,47,104,101,97,100,62,13,10,67,111,110,118,101,114,115,101,108,121,
-44,62,10,60,100,105,118,32,105,100,61,34,48,34,32,119,105,100,116,104,61,34,49,
-105,115,32,112,114,111,98,97,98,108,121,104,97,118,101,32,98,101,99,111,109,101,
-99,111,110,116,114,111,108,108,105,110,103,116,104,101,32,112,114,111,98,108,101
-,109,99,105,116,105,122,101,110,115,32,111,102,112,111,108,105,116,105,99,105,97
-,110,115,114,101,97,99,104,101,100,32,116,104,101,97,115,32,101,97,114,108,121,
-32,97,115,58,110,111,110,101,59,32,111,118,101,114,60,116,97,98,108,101,32,99,
-101,108,108,118,97,108,105,100,105,116,121,32,111,102,100,105,114,101,99,116,108
-,121,32,116,111,111,110,109,111,117,115,101,100,111,119,110,119,104,101,114,101,
-32,105,116,32,105,115,119,104,101,110,32,105,116,32,119,97,115,109,101,109,98,
-101,114,115,32,111,102,32,114,101,108,97,116,105,111,110,32,116,111,97,99,99,111
-,109,109,111,100,97,116,101,97,108,111,110,103,32,119,105,116,104,32,73,110,32,
-116,104,101,32,108,97,116,101,116,104,101,32,69,110,103,108,105,115,104,100,101,
-108,105,99,105,111,117,115,34,62,116,104,105,115,32,105,115,32,110,111,116,116,
-104,101,32,112,114,101,115,101,110,116,105,102,32,116,104,101,121,32,97,114,101,
-97,110,100,32,102,105,110,97,108,108,121,97,32,109,97,116,116,101,114,32,111,102
-,13,10,9,60,47,100,105,118,62,13,10,13,10,60,47,115,99,114,105,112,116,62,102,97
-,115,116,101,114,32,116,104,97,110,109,97,106,111,114,105,116,121,32,111,102,97,
-102,116,101,114,32,119,104,105,99,104,99,111,109,112,97,114,97,116,105,118,101,
-116,111,32,109,97,105,110,116,97,105,110,105,109,112,114,111,118,101,32,116,104,
-101,97,119,97,114,100,101,100,32,116,104,101,101,114,34,32,99,108,97,115,115,61,
-34,102,114,97,109,101,98,111,114,100,101,114,114,101,115,116,111,114,97,116,105,
-111,110,105,110,32,116,104,101,32,115,97,109,101,97,110,97,108,121,115,105,115,
-32,111,102,116,104,101,105,114,32,102,105,114,115,116,68,117,114,105,110,103,32,
-116,104,101,32,99,111,110,116,105,110,101,110,116,97,108,115,101,113,117,101,110
-,99,101,32,111,102,102,117,110,99,116,105,111,110,40,41,123,102,111,110,116,45,
-115,105,122,101,58,32,119,111,114,107,32,111,110,32,116,104,101,60,47,115,99,114
-,105,112,116,62,10,60,98,101,103,105,110,115,32,119,105,116,104,106,97,118,97,
-115,99,114,105,112,116,58,99,111,110,115,116,105,116,117,101,110,116,119,97,115,
-32,102,111,117,110,100,101,100,101,113,117,105,108,105,98,114,105,117,109,97,115
-,115,117,109,101,32,116,104,97,116,105,115,32,103,105,118,101,110,32,98,121,110,
-101,101,100,115,32,116,111,32,98,101,99,111,111,114,100,105,110,97,116,101,115,
-116,104,101,32,118,97,114,105,111,117,115,97,114,101,32,112,97,114,116,32,111,
-102,111,110,108,121,32,105,110,32,116,104,101,115,101,99,116,105,111,110,115,32,
-111,102,105,115,32,97,32,99,111,109,109,111,110,116,104,101,111,114,105,101,115,
-32,111,102,100,105,115,99,111,118,101,114,105,101,115,97,115,115,111,99,105,97,
-116,105,111,110,101,100,103,101,32,111,102,32,116,104,101,115,116,114,101,110,
-103,116,104,32,111,102,112,111,115,105,116,105,111,110,32,105,110,112,114,101,
-115,101,110,116,45,100,97,121,117,110,105,118,101,114,115,97,108,108,121,116,111
-,32,102,111,114,109,32,116,104,101,98,117,116,32,105,110,115,116,101,97,100,99,
-111,114,112,111,114,97,116,105,111,110,97,116,116,97,99,104,101,100,32,116,111,
-105,115,32,99,111,109,109,111,110,108,121,114,101,97,115,111,110,115,32,102,111,
-114,32,38,113,117,111,116,59,116,104,101,32,99,97,110,32,98,101,32,109,97,100,
-101,119,97,115,32,97,98,108,101,32,116,111,119,104,105,99,104,32,109,101,97,110,
-115,98,117,116,32,100,105,100,32,110,111,116,111,110,77,111,117,115,101,79,118,
-101,114,97,115,32,112,111,115,115,105,98,108,101,111,112,101,114,97,116,101,100,
-32,98,121,99,111,109,105,110,103,32,102,114,111,109,116,104,101,32,112,114,105,
-109,97,114,121,97,100,100,105,116,105,111,110,32,111,102,102,111,114,32,115,101,
-118,101,114,97,108,116,114,97,110,115,102,101,114,114,101,100,97,32,112,101,114,
-105,111,100,32,111,102,97,114,101,32,97,98,108,101,32,116,111,104,111,119,101,
-118,101,114,44,32,105,116,115,104,111,117,108,100,32,104,97,118,101,109,117,99,
-104,32,108,97,114,103,101,114,10,9,60,47,115,99,114,105,112,116,62,97,100,111,
-112,116,101,100,32,116,104,101,112,114,111,112,101,114,116,121,32,111,102,100,
-105,114,101,99,116,101,100,32,98,121,101,102,102,101,99,116,105,118,101,108,121,
-119,97,115,32,98,114,111,117,103,104,116,99,104,105,108,100,114,101,110,32,111,
-102,80,114,111,103,114,97,109,109,105,110,103,108,111,110,103,101,114,32,116,104
-,97,110,109,97,110,117,115,99,114,105,112,116,115,119,97,114,32,97,103,97,105,
-110,115,116,98,121,32,109,101,97,110,115,32,111,102,97,110,100,32,109,111,115,
-116,32,111,102,115,105,109,105,108,97,114,32,116,111,32,112,114,111,112,114,105,
-101,116,97,114,121,111,114,105,103,105,110,97,116,105,110,103,112,114,101,115,
-116,105,103,105,111,117,115,103,114,97,109,109,97,116,105,99,97,108,101,120,112,
-101,114,105,101,110,99,101,46,116,111,32,109,97,107,101,32,116,104,101,73,116,32
-,119,97,115,32,97,108,115,111,105,115,32,102,111,117,110,100,32,105,110,99,111,
-109,112,101,116,105,116,111,114,115,105,110,32,116,104,101,32,85,46,83,46,114,
-101,112,108,97,99,101,32,116,104,101,98,114,111,117,103,104,116,32,116,104,101,
-99,97,108,99,117,108,97,116,105,111,110,102,97,108,108,32,111,102,32,116,104,101
-,116,104,101,32,103,101,110,101,114,97,108,112,114,97,99,116,105,99,97,108,108,
-121,105,110,32,104,111,110,111,114,32,111,102,114,101,108,101,97,115,101,100,32,
-105,110,114,101,115,105,100,101,110,116,105,97,108,97,110,100,32,115,111,109,101
-,32,111,102,107,105,110,103,32,111,102,32,116,104,101,114,101,97,99,116,105,111,
-110,32,116,111,49,115,116,32,69,97,114,108,32,111,102,99,117,108,116,117,114,101
-,32,97,110,100,112,114,105,110,99,105,112,97,108,108,121,60,47,116,105,116,108,
-101,62,10,32,32,116,104,101,121,32,99,97,110,32,98,101,98,97,99,107,32,116,111,
-32,116,104,101,115,111,109,101,32,111,102,32,104,105,115,101,120,112,111,115,117
-,114,101,32,116,111,97,114,101,32,115,105,109,105,108,97,114,102,111,114,109,32,
-111,102,32,116,104,101,97,100,100,70,97,118,111,114,105,116,101,99,105,116,105,
-122,101,110,115,104,105,112,112,97,114,116,32,105,110,32,116,104,101,112,101,111
-,112,108,101,32,119,105,116,104,105,110,32,112,114,97,99,116,105,99,101,116,111,
-32,99,111,110,116,105,110,117,101,38,97,109,112,59,109,105,110,117,115,59,97,112
-,112,114,111,118,101,100,32,98,121,32,116,104,101,32,102,105,114,115,116,32,97,
-108,108,111,119,101,100,32,116,104,101,97,110,100,32,102,111,114,32,116,104,101,
-102,117,110,99,116,105,111,110,105,110,103,112,108,97,121,105,110,103,32,116,104
-,101,115,111,108,117,116,105,111,110,32,116,111,104,101,105,103,104,116,61,34,48
-,34,32,105,110,32,104,105,115,32,98,111,111,107,109,111,114,101,32,116,104,97,
-110,32,97,102,111,108,108,111,119,115,32,116,104,101,99,114,101,97,116,101,100,
-32,116,104,101,112,114,101,115,101,110,99,101,32,105,110,38,110,98,115,112,59,60
-,47,116,100,62,110,97,116,105,111,110,97,108,105,115,116,116,104,101,32,105,100,
-101,97,32,111,102,97,32,99,104,97,114,97,99,116,101,114,119,101,114,101,32,102,
-111,114,99,101,100,32,99,108,97,115,115,61,34,98,116,110,100,97,121,115,32,111,
-102,32,116,104,101,102,101,97,116,117,114,101,100,32,105,110,115,104,111,119,105
-,110,103,32,116,104,101,105,110,116,101,114,101,115,116,32,105,110,105,110,32,
-112,108,97,99,101,32,111,102,116,117,114,110,32,111,102,32,116,104,101,116,104,
-101,32,104,101,97,100,32,111,102,76,111,114,100,32,111,102,32,116,104,101,112,
-111,108,105,116,105,99,97,108,108,121,104,97,115,32,105,116,115,32,111,119,110,
-69,100,117,99,97,116,105,111,110,97,108,97,112,112,114,111,118,97,108,32,111,102
-,115,111,109,101,32,111,102,32,116,104,101,101,97,99,104,32,111,116,104,101,114,
-44,98,101,104,97,118,105,111,114,32,111,102,97,110,100,32,98,101,99,97,117,115,
-101,97,110,100,32,97,110,111,116,104,101,114,97,112,112,101,97,114,101,100,32,
-111,110,114,101,99,111,114,100,101,100,32,105,110,98,108,97,99,107,38,113,117,
-111,116,59,109,97,121,32,105,110,99,108,117,100,101,116,104,101,32,119,111,114,
-108,100,39,115,99,97,110,32,108,101,97,100,32,116,111,114,101,102,101,114,115,32
-,116,111,32,97,98,111,114,100,101,114,61,34,48,34,32,103,111,118,101,114,110,109
-,101,110,116,32,119,105,110,110,105,110,103,32,116,104,101,114,101,115,117,108,
-116,101,100,32,105,110,32,119,104,105,108,101,32,116,104,101,32,87,97,115,104,
-105,110,103,116,111,110,44,116,104,101,32,115,117,98,106,101,99,116,99,105,116,
-121,32,105,110,32,116,104,101,62,60,47,100,105,118,62,13,10,9,9,114,101,102,108,
-101,99,116,32,116,104,101,116,111,32,99,111,109,112,108,101,116,101,98,101,99,97
-,109,101,32,109,111,114,101,114,97,100,105,111,97,99,116,105,118,101,114,101,106
-,101,99,116,101,100,32,98,121,119,105,116,104,111,117,116,32,97,110,121,104,105,
-115,32,102,97,116,104,101,114,44,119,104,105,99,104,32,99,111,117,108,100,99,111
-,112,121,32,111,102,32,116,104,101,116,111,32,105,110,100,105,99,97,116,101,97,
-32,112,111,108,105,116,105,99,97,108,97,99,99,111,117,110,116,115,32,111,102,99,
-111,110,115,116,105,116,117,116,101,115,119,111,114,107,101,100,32,119,105,116,
-104,101,114,60,47,97,62,60,47,108,105,62,111,102,32,104,105,115,32,108,105,102,
-101,97,99,99,111,109,112,97,110,105,101,100,99,108,105,101,110,116,87,105,100,
-116,104,112,114,101,118,101,110,116,32,116,104,101,76,101,103,105,115,108,97,116
-,105,118,101,100,105,102,102,101,114,101,110,116,108,121,116,111,103,101,116,104
-,101,114,32,105,110,104,97,115,32,115,101,118,101,114,97,108,102,111,114,32,97,
-110,111,116,104,101,114,116,101,120,116,32,111,102,32,116,104,101,102,111,117,
-110,100,101,100,32,116,104,101,101,32,119,105,116,104,32,116,104,101,32,105,115,
-32,117,115,101,100,32,102,111,114,99,104,97,110,103,101,100,32,116,104,101,117,
-115,117,97,108,108,121,32,116,104,101,112,108,97,99,101,32,119,104,101,114,101,
-119,104,101,114,101,97,115,32,116,104,101,62,32,60,97,32,104,114,101,102,61,34,
-34,62,60,97,32,104,114,101,102,61,34,116,104,101,109,115,101,108,118,101,115,44,
-97,108,116,104,111,117,103,104,32,104,101,116,104,97,116,32,99,97,110,32,98,101,
-116,114,97,100,105,116,105,111,110,97,108,114,111,108,101,32,111,102,32,116,104,
-101,97,115,32,97,32,114,101,115,117,108,116,114,101,109,111,118,101,67,104,105,
-108,100,100,101,115,105,103,110,101,100,32,98,121,119,101,115,116,32,111,102,32,
-116,104,101,83,111,109,101,32,112,101,111,112,108,101,112,114,111,100,117,99,116
-,105,111,110,44,115,105,100,101,32,111,102,32,116,104,101,110,101,119,115,108,
-101,116,116,101,114,115,117,115,101,100,32,98,121,32,116,104,101,100,111,119,110
-,32,116,111,32,116,104,101,97,99,99,101,112,116,101,100,32,98,121,108,105,118,
-101,32,105,110,32,116,104,101,97,116,116,101,109,112,116,115,32,116,111,111,117,
-116,115,105,100,101,32,116,104,101,102,114,101,113,117,101,110,99,105,101,115,72
-,111,119,101,118,101,114,44,32,105,110,112,114,111,103,114,97,109,109,101,114,
-115,97,116,32,108,101,97,115,116,32,105,110,97,112,112,114,111,120,105,109,97,
-116,101,97,108,116,104,111,117,103,104,32,105,116,119,97,115,32,112,97,114,116,
-32,111,102,97,110,100,32,118,97,114,105,111,117,115,71,111,118,101,114,110,111,
-114,32,111,102,116,104,101,32,97,114,116,105,99,108,101,116,117,114,110,101,100,
-32,105,110,116,111,62,60,97,32,104,114,101,102,61,34,47,116,104,101,32,101,99,
-111,110,111,109,121,105,115,32,116,104,101,32,109,111,115,116,109,111,115,116,32
-,119,105,100,101,108,121,119,111,117,108,100,32,108,97,116,101,114,97,110,100,32
-,112,101,114,104,97,112,115,114,105,115,101,32,116,111,32,116,104,101,111,99,99,
-117,114,115,32,119,104,101,110,117,110,100,101,114,32,119,104,105,99,104,99,111,
-110,100,105,116,105,111,110,115,46,116,104,101,32,119,101,115,116,101,114,110,
-116,104,101,111,114,121,32,116,104,97,116,105,115,32,112,114,111,100,117,99,101,
-100,116,104,101,32,99,105,116,121,32,111,102,105,110,32,119,104,105,99,104,32,
-104,101,115,101,101,110,32,105,110,32,116,104,101,116,104,101,32,99,101,110,116,
-114,97,108,98,117,105,108,100,105,110,103,32,111,102,109,97,110,121,32,111,102,
-32,104,105,115,97,114,101,97,32,111,102,32,116,104,101,105,115,32,116,104,101,32
-,111,110,108,121,109,111,115,116,32,111,102,32,116,104,101,109,97,110,121,32,111
-,102,32,116,104,101,116,104,101,32,87,101,115,116,101,114,110,84,104,101,114,101
-,32,105,115,32,110,111,101,120,116,101,110,100,101,100,32,116,111,83,116,97,116,
-105,115,116,105,99,97,108,99,111,108,115,112,97,110,61,50,32,124,115,104,111,114
-,116,32,115,116,111,114,121,112,111,115,115,105,98,108,101,32,116,111,116,111,
-112,111,108,111,103,105,99,97,108,99,114,105,116,105,99,97,108,32,111,102,114,
-101,112,111,114,116,101,100,32,116,111,97,32,67,104,114,105,115,116,105,97,110,
-100,101,99,105,115,105,111,110,32,116,111,105,115,32,101,113,117,97,108,32,116,
-111,112,114,111,98,108,101,109,115,32,111,102,84,104,105,115,32,99,97,110,32,98,
-101,109,101,114,99,104,97,110,100,105,115,101,102,111,114,32,109,111,115,116,32,
-111,102,110,111,32,101,118,105,100,101,110,99,101,101,100,105,116,105,111,110,
-115,32,111,102,101,108,101,109,101,110,116,115,32,105,110,38,113,117,111,116,59,
-46,32,84,104,101,99,111,109,47,105,109,97,103,101,115,47,119,104,105,99,104,32,
-109,97,107,101,115,116,104,101,32,112,114,111,99,101,115,115,114,101,109,97,105,
-110,115,32,116,104,101,108,105,116,101,114,97,116,117,114,101,44,105,115,32,97,
-32,109,101,109,98,101,114,116,104,101,32,112,111,112,117,108,97,114,116,104,101,
-32,97,110,99,105,101,110,116,112,114,111,98,108,101,109,115,32,105,110,116,105,
-109,101,32,111,102,32,116,104,101,100,101,102,101,97,116,101,100,32,98,121,98,
-111,100,121,32,111,102,32,116,104,101,97,32,102,101,119,32,121,101,97,114,115,
-109,117,99,104,32,111,102,32,116,104,101,116,104,101,32,119,111,114,107,32,111,
-102,67,97,108,105,102,111,114,110,105,97,44,115,101,114,118,101,100,32,97,115,32
-,97,103,111,118,101,114,110,109,101,110,116,46,99,111,110,99,101,112,116,115,32,
-111,102,109,111,118,101,109,101,110,116,32,105,110,9,9,60,100,105,118,32,105,100
-,61,34,105,116,34,32,118,97,108,117,101,61,34,108,97,110,103,117,97,103,101,32,
-111,102,97,115,32,116,104,101,121,32,97,114,101,112,114,111,100,117,99,101,100,
-32,105,110,105,115,32,116,104,97,116,32,116,104,101,101,120,112,108,97,105,110,
-32,116,104,101,100,105,118,62,60,47,100,105,118,62,10,72,111,119,101,118,101,114
-,32,116,104,101,108,101,97,100,32,116,111,32,116,104,101,9,60,97,32,104,114,101,
-102,61,34,47,119,97,115,32,103,114,97,110,116,101,100,112,101,111,112,108,101,32
-,104,97,118,101,99,111,110,116,105,110,117,97,108,108,121,119,97,115,32,115,101,
-101,110,32,97,115,97,110,100,32,114,101,108,97,116,101,100,116,104,101,32,114,
-111,108,101,32,111,102,112,114,111,112,111,115,101,100,32,98,121,111,102,32,116,
-104,101,32,98,101,115,116,101,97,99,104,32,111,116,104,101,114,46,67,111,110,115
-,116,97,110,116,105,110,101,112,101,111,112,108,101,32,102,114,111,109,100,105,
-97,108,101,99,116,115,32,111,102,116,111,32,114,101,118,105,115,105,111,110,119,
-97,115,32,114,101,110,97,109,101,100,97,32,115,111,117,114,99,101,32,111,102,116
-,104,101,32,105,110,105,116,105,97,108,108,97,117,110,99,104,101,100,32,105,110,
-112,114,111,118,105,100,101,32,116,104,101,116,111,32,116,104,101,32,119,101,115
-,116,119,104,101,114,101,32,116,104,101,114,101,97,110,100,32,115,105,109,105,
-108,97,114,98,101,116,119,101,101,110,32,116,119,111,105,115,32,97,108,115,111,
-32,116,104,101,69,110,103,108,105,115,104,32,97,110,100,99,111,110,100,105,116,
-105,111,110,115,44,116,104,97,116,32,105,116,32,119,97,115,101,110,116,105,116,
-108,101,100,32,116,111,116,104,101,109,115,101,108,118,101,115,46,113,117,97,110
-,116,105,116,121,32,111,102,114,97,110,115,112,97,114,101,110,99,121,116,104,101
-,32,115,97,109,101,32,97,115,116,111,32,106,111,105,110,32,116,104,101,99,111,
-117,110,116,114,121,32,97,110,100,116,104,105,115,32,105,115,32,116,104,101,84,
-104,105,115,32,108,101,100,32,116,111,97,32,115,116,97,116,101,109,101,110,116,
-99,111,110,116,114,97,115,116,32,116,111,108,97,115,116,73,110,100,101,120,79,
-102,116,104,114,111,117,103,104,32,104,105,115,105,115,32,100,101,115,105,103,
-110,101,100,116,104,101,32,116,101,114,109,32,105,115,105,115,32,112,114,111,118
-,105,100,101,100,112,114,111,116,101,99,116,32,116,104,101,110,103,60,47,97,62,
-60,47,108,105,62,84,104,101,32,99,117,114,114,101,110,116,116,104,101,32,115,105
-,116,101,32,111,102,115,117,98,115,116,97,110,116,105,97,108,101,120,112,101,114
-,105,101,110,99,101,44,105,110,32,116,104,101,32,87,101,115,116,116,104,101,121,
-32,115,104,111,117,108,100,115,108,111,118,101,110,196,141,105,110,97,99,111,109
-,101,110,116,97,114,105,111,115,117,110,105,118,101,114,115,105,100,97,100,99,
-111,110,100,105,99,105,111,110,101,115,97,99,116,105,118,105,100,97,100,101,115,
-101,120,112,101,114,105,101,110,99,105,97,116,101,99,110,111,108,111,103,195,173
-,97,112,114,111,100,117,99,99,105,195,179,110,112,117,110,116,117,97,99,105,195,
-179,110,97,112,108,105,99,97,99,105,195,179,110,99,111,110,116,114,97,115,101,
-195,177,97,99,97,116,101,103,111,114,195,173,97,115,114,101,103,105,115,116,114,
-97,114,115,101,112,114,111,102,101,115,105,111,110,97,108,116,114,97,116,97,109,
-105,101,110,116,111,114,101,103,195,173,115,116,114,97,116,101,115,101,99,114,
-101,116,97,114,195,173,97,112,114,105,110,99,105,112,97,108,101,115,112,114,111,
-116,101,99,99,105,195,179,110,105,109,112,111,114,116,97,110,116,101,115,105,109
-,112,111,114,116,97,110,99,105,97,112,111,115,105,98,105,108,105,100,97,100,105,
-110,116,101,114,101,115,97,110,116,101,99,114,101,99,105,109,105,101,110,116,111
-,110,101,99,101,115,105,100,97,100,101,115,115,117,115,99,114,105,98,105,114,115
-,101,97,115,111,99,105,97,99,105,195,179,110,100,105,115,112,111,110,105,98,108,
-101,115,101,118,97,108,117,97,99,105,195,179,110,101,115,116,117,100,105,97,110,
-116,101,115,114,101,115,112,111,110,115,97,98,108,101,114,101,115,111,108,117,99
-,105,195,179,110,103,117,97,100,97,108,97,106,97,114,97,114,101,103,105,115,116,
-114,97,100,111,115,111,112,111,114,116,117,110,105,100,97,100,99,111,109,101,114
-,99,105,97,108,101,115,102,111,116,111,103,114,97,102,195,173,97,97,117,116,111,
-114,105,100,97,100,101,115,105,110,103,101,110,105,101,114,195,173,97,116,101,
-108,101,118,105,115,105,195,179,110,99,111,109,112,101,116,101,110,99,105,97,111
-,112,101,114,97,99,105,111,110,101,115,101,115,116,97,98,108,101,99,105,100,111,
-115,105,109,112,108,101,109,101,110,116,101,97,99,116,117,97,108,109,101,110,116
-,101,110,97,118,101,103,97,99,105,195,179,110,99,111,110,102,111,114,109,105,100
-,97,100,108,105,110,101,45,104,101,105,103,104,116,58,102,111,110,116,45,102,97,
-109,105,108,121,58,34,32,58,32,34,104,116,116,112,58,47,47,97,112,112,108,105,99
-,97,116,105,111,110,115,108,105,110,107,34,32,104,114,101,102,61,34,115,112,101,
-99,105,102,105,99,97,108,108,121,47,47,60,33,91,67,68,65,84,65,91,10,79,114,103,
-97,110,105,122,97,116,105,111,110,100,105,115,116,114,105,98,117,116,105,111,110
-,48,112,120,59,32,104,101,105,103,104,116,58,114,101,108,97,116,105,111,110,115,
-104,105,112,100,101,118,105,99,101,45,119,105,100,116,104,60,100,105,118,32,99,
-108,97,115,115,61,34,60,108,97,98,101,108,32,102,111,114,61,34,114,101,103,105,
-115,116,114,97,116,105,111,110,60,47,110,111,115,99,114,105,112,116,62,10,47,105
-,110,100,101,120,46,104,116,109,108,34,119,105,110,100,111,119,46,111,112,101,
-110,40,32,33,105,109,112,111,114,116,97,110,116,59,97,112,112,108,105,99,97,116,
-105,111,110,47,105,110,100,101,112,101,110,100,101,110,99,101,47,47,119,119,119,
-46,103,111,111,103,108,101,111,114,103,97,110,105,122,97,116,105,111,110,97,117,
-116,111,99,111,109,112,108,101,116,101,114,101,113,117,105,114,101,109,101,110,
-116,115,99,111,110,115,101,114,118,97,116,105,118,101,60,102,111,114,109,32,110,
-97,109,101,61,34,105,110,116,101,108,108,101,99,116,117,97,108,109,97,114,103,
-105,110,45,108,101,102,116,58,49,56,116,104,32,99,101,110,116,117,114,121,97,110
-,32,105,109,112,111,114,116,97,110,116,105,110,115,116,105,116,117,116,105,111,
-110,115,97,98,98,114,101,118,105,97,116,105,111,110,60,105,109,103,32,99,108,97,
-115,115,61,34,111,114,103,97,110,105,115,97,116,105,111,110,99,105,118,105,108,
-105,122,97,116,105,111,110,49,57,116,104,32,99,101,110,116,117,114,121,97,114,99
-,104,105,116,101,99,116,117,114,101,105,110,99,111,114,112,111,114,97,116,101,
-100,50,48,116,104,32,99,101,110,116,117,114,121,45,99,111,110,116,97,105,110,101
-,114,34,62,109,111,115,116,32,110,111,116,97,98,108,121,47,62,60,47,97,62,60,47,
-100,105,118,62,110,111,116,105,102,105,99,97,116,105,111,110,39,117,110,100,101,
-102,105,110,101,100,39,41,70,117,114,116,104,101,114,109,111,114,101,44,98,101,
-108,105,101,118,101,32,116,104,97,116,105,110,110,101,114,72,84,77,76,32,61,32,
-112,114,105,111,114,32,116,111,32,116,104,101,100,114,97,109,97,116,105,99,97,
-108,108,121,114,101,102,101,114,114,105,110,103,32,116,111,110,101,103,111,116,
-105,97,116,105,111,110,115,104,101,97,100,113,117,97,114,116,101,114,115,83,111,
-117,116,104,32,65,102,114,105,99,97,117,110,115,117,99,99,101,115,115,102,117,
-108,80,101,110,110,115,121,108,118,97,110,105,97,65,115,32,97,32,114,101,115,117
-,108,116,44,60,104,116,109,108,32,108,97,110,103,61,34,38,108,116,59,47,115,117,
-112,38,103,116,59,100,101,97,108,105,110,103,32,119,105,116,104,112,104,105,108,
-97,100,101,108,112,104,105,97,104,105,115,116,111,114,105,99,97,108,108,121,41,
-59,60,47,115,99,114,105,112,116,62,10,112,97,100,100,105,110,103,45,116,111,112,
-58,101,120,112,101,114,105,109,101,110,116,97,108,103,101,116,65,116,116,114,105
-,98,117,116,101,105,110,115,116,114,117,99,116,105,111,110,115,116,101,99,104,
-110,111,108,111,103,105,101,115,112,97,114,116,32,111,102,32,116,104,101,32,61,
-102,117,110,99,116,105,111,110,40,41,123,115,117,98,115,99,114,105,112,116,105,
-111,110,108,46,100,116,100,34,62,13,10,60,104,116,103,101,111,103,114,97,112,104
-,105,99,97,108,67,111,110,115,116,105,116,117,116,105,111,110,39,44,32,102,117,
-110,99,116,105,111,110,40,115,117,112,112,111,114,116,101,100,32,98,121,97,103,
-114,105,99,117,108,116,117,114,97,108,99,111,110,115,116,114,117,99,116,105,111,
-110,112,117,98,108,105,99,97,116,105,111,110,115,102,111,110,116,45,115,105,122,
-101,58,32,49,97,32,118,97,114,105,101,116,121,32,111,102,60,100,105,118,32,115,
-116,121,108,101,61,34,69,110,99,121,99,108,111,112,101,100,105,97,105,102,114,97
-,109,101,32,115,114,99,61,34,100,101,109,111,110,115,116,114,97,116,101,100,97,
-99,99,111,109,112,108,105,115,104,101,100,117,110,105,118,101,114,115,105,116,
-105,101,115,68,101,109,111,103,114,97,112,104,105,99,115,41,59,60,47,115,99,114,
-105,112,116,62,60,100,101,100,105,99,97,116,101,100,32,116,111,107,110,111,119,
-108,101,100,103,101,32,111,102,115,97,116,105,115,102,97,99,116,105,111,110,112,
-97,114,116,105,99,117,108,97,114,108,121,60,47,100,105,118,62,60,47,100,105,118,
-62,69,110,103,108,105,115,104,32,40,85,83,41,97,112,112,101,110,100,67,104,105,
-108,100,40,116,114,97,110,115,109,105,115,115,105,111,110,115,46,32,72,111,119,
-101,118,101,114,44,32,105,110,116,101,108,108,105,103,101,110,99,101,34,32,116,
-97,98,105,110,100,101,120,61,34,102,108,111,97,116,58,114,105,103,104,116,59,67,
-111,109,109,111,110,119,101,97,108,116,104,114,97,110,103,105,110,103,32,102,114
-,111,109,105,110,32,119,104,105,99,104,32,116,104,101,97,116,32,108,101,97,115,
-116,32,111,110,101,114,101,112,114,111,100,117,99,116,105,111,110,101,110,99,121
-,99,108,111,112,101,100,105,97,59,102,111,110,116,45,115,105,122,101,58,49,106,
-117,114,105,115,100,105,99,116,105,111,110,97,116,32,116,104,97,116,32,116,105,
-109,101,34,62,60,97,32,99,108,97,115,115,61,34,73,110,32,97,100,100,105,116,105,
-111,110,44,100,101,115,99,114,105,112,116,105,111,110,43,99,111,110,118,101,114,
-115,97,116,105,111,110,99,111,110,116,97,99,116,32,119,105,116,104,105,115,32,
-103,101,110,101,114,97,108,108,121,114,34,32,99,111,110,116,101,110,116,61,34,
-114,101,112,114,101,115,101,110,116,105,110,103,38,108,116,59,109,97,116,104,38,
-103,116,59,112,114,101,115,101,110,116,97,116,105,111,110,111,99,99,97,115,105,
-111,110,97,108,108,121,60,105,109,103,32,119,105,100,116,104,61,34,110,97,118,
-105,103,97,116,105,111,110,34,62,99,111,109,112,101,110,115,97,116,105,111,110,
-99,104,97,109,112,105,111,110,115,104,105,112,109,101,100,105,97,61,34,97,108,
-108,34,32,118,105,111,108,97,116,105,111,110,32,111,102,114,101,102,101,114,101,
-110,99,101,32,116,111,114,101,116,117,114,110,32,116,114,117,101,59,83,116,114,
-105,99,116,47,47,69,78,34,32,116,114,97,110,115,97,99,116,105,111,110,115,105,
-110,116,101,114,118,101,110,116,105,111,110,118,101,114,105,102,105,99,97,116,
-105,111,110,73,110,102,111,114,109,97,116,105,111,110,32,100,105,102,102,105,99,
-117,108,116,105,101,115,67,104,97,109,112,105,111,110,115,104,105,112,99,97,112,
-97,98,105,108,105,116,105,101,115,60,33,91,101,110,100,105,102,93,45,45,62,125,
-10,60,47,115,99,114,105,112,116,62,10,67,104,114,105,115,116,105,97,110,105,116,
-121,102,111,114,32,101,120,97,109,112,108,101,44,80,114,111,102,101,115,115,105,
-111,110,97,108,114,101,115,116,114,105,99,116,105,111,110,115,115,117,103,103,
-101,115,116,32,116,104,97,116,119,97,115,32,114,101,108,101,97,115,101,100,40,
-115,117,99,104,32,97,115,32,116,104,101,114,101,109,111,118,101,67,108,97,115,
-115,40,117,110,101,109,112,108,111,121,109,101,110,116,116,104,101,32,65,109,101
-,114,105,99,97,110,115,116,114,117,99,116,117,114,101,32,111,102,47,105,110,100,
-101,120,46,104,116,109,108,32,112,117,98,108,105,115,104,101,100,32,105,110,115,
-112,97,110,32,99,108,97,115,115,61,34,34,62,60,97,32,104,114,101,102,61,34,47,
-105,110,116,114,111,100,117,99,116,105,111,110,98,101,108,111,110,103,105,110,
-103,32,116,111,99,108,97,105,109,101,100,32,116,104,97,116,99,111,110,115,101,
-113,117,101,110,99,101,115,60,109,101,116,97,32,110,97,109,101,61,34,71,117,105,
-100,101,32,116,111,32,116,104,101,111,118,101,114,119,104,101,108,109,105,110,
-103,97,103,97,105,110,115,116,32,116,104,101,32,99,111,110,99,101,110,116,114,97
-,116,101,100,44,10,46,110,111,110,116,111,117,99,104,32,111,98,115,101,114,118,
-97,116,105,111,110,115,60,47,97,62,10,60,47,100,105,118,62,10,102,32,40,100,111,
-99,117,109,101,110,116,46,98,111,114,100,101,114,58,32,49,112,120,32,123,102,111
-,110,116,45,115,105,122,101,58,49,116,114,101,97,116,109,101,110,116,32,111,102,
-48,34,32,104,101,105,103,104,116,61,34,49,109,111,100,105,102,105,99,97,116,105,
-111,110,73,110,100,101,112,101,110,100,101,110,99,101,100,105,118,105,100,101,
-100,32,105,110,116,111,103,114,101,97,116,101,114,32,116,104,97,110,97,99,104,
-105,101,118,101,109,101,110,116,115,101,115,116,97,98,108,105,115,104,105,110,
-103,74,97,118,97,83,99,114,105,112,116,34,32,110,101,118,101,114,116,104,101,108
-,101,115,115,115,105,103,110,105,102,105,99,97,110,99,101,66,114,111,97,100,99,
-97,115,116,105,110,103,62,38,110,98,115,112,59,60,47,116,100,62,99,111,110,116,
-97,105,110,101,114,34,62,10,115,117,99,104,32,97,115,32,116,104,101,32,105,110,
-102,108,117,101,110,99,101,32,111,102,97,32,112,97,114,116,105,99,117,108,97,114
-,115,114,99,61,39,104,116,116,112,58,47,47,110,97,118,105,103,97,116,105,111,110
-,34,32,104,97,108,102,32,111,102,32,116,104,101,32,115,117,98,115,116,97,110,116
-,105,97,108,32,38,110,98,115,112,59,60,47,100,105,118,62,97,100,118,97,110,116,
-97,103,101,32,111,102,100,105,115,99,111,118,101,114,121,32,111,102,102,117,110,
-100,97,109,101,110,116,97,108,32,109,101,116,114,111,112,111,108,105,116,97,110,
-116,104,101,32,111,112,112,111,115,105,116,101,34,32,120,109,108,58,108,97,110,
-103,61,34,100,101,108,105,98,101,114,97,116,101,108,121,97,108,105,103,110,61,99
-,101,110,116,101,114,101,118,111,108,117,116,105,111,110,32,111,102,112,114,101,
-115,101,114,118,97,116,105,111,110,105,109,112,114,111,118,101,109,101,110,116,
-115,98,101,103,105,110,110,105,110,103,32,105,110,74,101,115,117,115,32,67,104,
-114,105,115,116,80,117,98,108,105,99,97,116,105,111,110,115,100,105,115,97,103,
-114,101,101,109,101,110,116,116,101,120,116,45,97,108,105,103,110,58,114,44,32,
-102,117,110,99,116,105,111,110,40,41,115,105,109,105,108,97,114,105,116,105,101,
-115,98,111,100,121,62,60,47,104,116,109,108,62,105,115,32,99,117,114,114,101,110
-,116,108,121,97,108,112,104,97,98,101,116,105,99,97,108,105,115,32,115,111,109,
-101,116,105,109,101,115,116,121,112,101,61,34,105,109,97,103,101,47,109,97,110,
-121,32,111,102,32,116,104,101,32,102,108,111,119,58,104,105,100,100,101,110,59,
-97,118,97,105,108,97,98,108,101,32,105,110,100,101,115,99,114,105,98,101,32,116,
-104,101,101,120,105,115,116,101,110,99,101,32,111,102,97,108,108,32,111,118,101,
-114,32,116,104,101,116,104,101,32,73,110,116,101,114,110,101,116,9,60,117,108,32
-,99,108,97,115,115,61,34,105,110,115,116,97,108,108,97,116,105,111,110,110,101,
-105,103,104,98,111,114,104,111,111,100,97,114,109,101,100,32,102,111,114,99,101,
-115,114,101,100,117,99,105,110,103,32,116,104,101,99,111,110,116,105,110,117,101
-,115,32,116,111,78,111,110,101,116,104,101,108,101,115,115,44,116,101,109,112,
-101,114,97,116,117,114,101,115,10,9,9,60,97,32,104,114,101,102,61,34,99,108,111,
-115,101,32,116,111,32,116,104,101,101,120,97,109,112,108,101,115,32,111,102,32,
-105,115,32,97,98,111,117,116,32,116,104,101,40,115,101,101,32,98,101,108,111,119
-,41,46,34,32,105,100,61,34,115,101,97,114,99,104,112,114,111,102,101,115,115,105
-,111,110,97,108,105,115,32,97,118,97,105,108,97,98,108,101,116,104,101,32,111,
-102,102,105,99,105,97,108,9,9,60,47,115,99,114,105,112,116,62,10,10,9,9,60,100,
-105,118,32,105,100,61,34,97,99,99,101,108,101,114,97,116,105,111,110,116,104,114
-,111,117,103,104,32,116,104,101,32,72,97,108,108,32,111,102,32,70,97,109,101,100
-,101,115,99,114,105,112,116,105,111,110,115,116,114,97,110,115,108,97,116,105,
-111,110,115,105,110,116,101,114,102,101,114,101,110,99,101,32,116,121,112,101,61
-,39,116,101,120,116,47,114,101,99,101,110,116,32,121,101,97,114,115,105,110,32,
-116,104,101,32,119,111,114,108,100,118,101,114,121,32,112,111,112,117,108,97,114
-,123,98,97,99,107,103,114,111,117,110,100,58,116,114,97,100,105,116,105,111,110,
-97,108,32,115,111,109,101,32,111,102,32,116,104,101,32,99,111,110,110,101,99,116
-,101,100,32,116,111,101,120,112,108,111,105,116,97,116,105,111,110,101,109,101,
-114,103,101,110,99,101,32,111,102,99,111,110,115,116,105,116,117,116,105,111,110
-,65,32,72,105,115,116,111,114,121,32,111,102,115,105,103,110,105,102,105,99,97,
-110,116,32,109,97,110,117,102,97,99,116,117,114,101,100,101,120,112,101,99,116,
-97,116,105,111,110,115,62,60,110,111,115,99,114,105,112,116,62,60,99,97,110,32,
-98,101,32,102,111,117,110,100,98,101,99,97,117,115,101,32,116,104,101,32,104,97,
-115,32,110,111,116,32,98,101,101,110,110,101,105,103,104,98,111,117,114,105,110,
-103,119,105,116,104,111,117,116,32,116,104,101,32,97,100,100,101,100,32,116,111,
-32,116,104,101,9,60,108,105,32,99,108,97,115,115,61,34,105,110,115,116,114,117,
-109,101,110,116,97,108,83,111,118,105,101,116,32,85,110,105,111,110,97,99,107,
-110,111,119,108,101,100,103,101,100,119,104,105,99,104,32,99,97,110,32,98,101,
-110,97,109,101,32,102,111,114,32,116,104,101,97,116,116,101,110,116,105,111,110,
-32,116,111,97,116,116,101,109,112,116,115,32,116,111,32,100,101,118,101,108,111,
-112,109,101,110,116,115,73,110,32,102,97,99,116,44,32,116,104,101,60,108,105,32,
-99,108,97,115,115,61,34,97,105,109,112,108,105,99,97,116,105,111,110,115,115,117
-,105,116,97,98,108,101,32,102,111,114,109,117,99,104,32,111,102,32,116,104,101,
-32,99,111,108,111,110,105,122,97,116,105,111,110,112,114,101,115,105,100,101,110
-,116,105,97,108,99,97,110,99,101,108,66,117,98,98,108,101,32,73,110,102,111,114,
-109,97,116,105,111,110,109,111,115,116,32,111,102,32,116,104,101,32,105,115,32,
-100,101,115,99,114,105,98,101,100,114,101,115,116,32,111,102,32,116,104,101,32,
-109,111,114,101,32,111,114,32,108,101,115,115,105,110,32,83,101,112,116,101,109,
-98,101,114,73,110,116,101,108,108,105,103,101,110,99,101,115,114,99,61,34,104,
-116,116,112,58,47,47,112,120,59,32,104,101,105,103,104,116,58,32,97,118,97,105,
-108,97,98,108,101,32,116,111,109,97,110,117,102,97,99,116,117,114,101,114,104,
-117,109,97,110,32,114,105,103,104,116,115,108,105,110,107,32,104,114,101,102,61,
-34,47,97,118,97,105,108,97,98,105,108,105,116,121,112,114,111,112,111,114,116,
-105,111,110,97,108,111,117,116,115,105,100,101,32,116,104,101,32,97,115,116,114,
-111,110,111,109,105,99,97,108,104,117,109,97,110,32,98,101,105,110,103,115,110,
-97,109,101,32,111,102,32,116,104,101,32,97,114,101,32,102,111,117,110,100,32,105
-,110,97,114,101,32,98,97,115,101,100,32,111,110,115,109,97,108,108,101,114,32,
-116,104,97,110,97,32,112,101,114,115,111,110,32,119,104,111,101,120,112,97,110,
-115,105,111,110,32,111,102,97,114,103,117,105,110,103,32,116,104,97,116,110,111,
-119,32,107,110,111,119,110,32,97,115,73,110,32,116,104,101,32,101,97,114,108,121
-,105,110,116,101,114,109,101,100,105,97,116,101,100,101,114,105,118,101,100,32,
-102,114,111,109,83,99,97,110,100,105,110,97,118,105,97,110,60,47,97,62,60,47,100
-,105,118,62,13,10,99,111,110,115,105,100,101,114,32,116,104,101,97,110,32,101,
-115,116,105,109,97,116,101,100,116,104,101,32,78,97,116,105,111,110,97,108,60,
-100,105,118,32,105,100,61,34,112,97,103,114,101,115,117,108,116,105,110,103,32,
-105,110,99,111,109,109,105,115,115,105,111,110,101,100,97,110,97,108,111,103,111
-,117,115,32,116,111,97,114,101,32,114,101,113,117,105,114,101,100,47,117,108,62,
-10,60,47,100,105,118,62,10,119,97,115,32,98,97,115,101,100,32,111,110,97,110,100
-,32,98,101,99,97,109,101,32,97,38,110,98,115,112,59,38,110,98,115,112,59,116,34,
-32,118,97,108,117,101,61,34,34,32,119,97,115,32,99,97,112,116,117,114,101,100,
-110,111,32,109,111,114,101,32,116,104,97,110,114,101,115,112,101,99,116,105,118,
-101,108,121,99,111,110,116,105,110,117,101,32,116,111,32,62,13,10,60,104,101,97,
-100,62,13,10,60,119,101,114,101,32,99,114,101,97,116,101,100,109,111,114,101,32,
-103,101,110,101,114,97,108,105,110,102,111,114,109,97,116,105,111,110,32,117,115
-,101,100,32,102,111,114,32,116,104,101,105,110,100,101,112,101,110,100,101,110,
-116,32,116,104,101,32,73,109,112,101,114,105,97,108,99,111,109,112,111,110,101,
-110,116,32,111,102,116,111,32,116,104,101,32,110,111,114,116,104,105,110,99,108,
-117,100,101,32,116,104,101,32,67,111,110,115,116,114,117,99,116,105,111,110,115,
-105,100,101,32,111,102,32,116,104,101,32,119,111,117,108,100,32,110,111,116,32,
-98,101,102,111,114,32,105,110,115,116,97,110,99,101,105,110,118,101,110,116,105,
-111,110,32,111,102,109,111,114,101,32,99,111,109,112,108,101,120,99,111,108,108,
-101,99,116,105,118,101,108,121,98,97,99,107,103,114,111,117,110,100,58,32,116,
-101,120,116,45,97,108,105,103,110,58,32,105,116,115,32,111,114,105,103,105,110,
-97,108,105,110,116,111,32,97,99,99,111,117,110,116,116,104,105,115,32,112,114,
-111,99,101,115,115,97,110,32,101,120,116,101,110,115,105,118,101,104,111,119,101
-,118,101,114,44,32,116,104,101,116,104,101,121,32,97,114,101,32,110,111,116,114,
-101,106,101,99,116,101,100,32,116,104,101,99,114,105,116,105,99,105,115,109,32,
-111,102,100,117,114,105,110,103,32,119,104,105,99,104,112,114,111,98,97,98,108,
-121,32,116,104,101,116,104,105,115,32,97,114,116,105,99,108,101,40,102,117,110,
-99,116,105,111,110,40,41,123,73,116,32,115,104,111,117,108,100,32,98,101,97,110,
-32,97,103,114,101,101,109,101,110,116,97,99,99,105,100,101,110,116,97,108,108,
-121,100,105,102,102,101,114,115,32,102,114,111,109,65,114,99,104,105,116,101,99,
-116,117,114,101,98,101,116,116,101,114,32,107,110,111,119,110,97,114,114,97,110,
-103,101,109,101,110,116,115,105,110,102,108,117,101,110,99,101,32,111,110,97,116
-,116,101,110,100,101,100,32,116,104,101,105,100,101,110,116,105,99,97,108,32,116
-,111,115,111,117,116,104,32,111,102,32,116,104,101,112,97,115,115,32,116,104,114
-,111,117,103,104,120,109,108,34,32,116,105,116,108,101,61,34,119,101,105,103,104
-,116,58,98,111,108,100,59,99,114,101,97,116,105,110,103,32,116,104,101,100,105,
-115,112,108,97,121,58,110,111,110,101,114,101,112,108,97,99,101,100,32,116,104,
-101,60,105,109,103,32,115,114,99,61,34,47,105,104,116,116,112,115,58,47,47,119,
-119,119,46,87,111,114,108,100,32,87,97,114,32,73,73,116,101,115,116,105,109,111,
-110,105,97,108,115,102,111,117,110,100,32,105,110,32,116,104,101,114,101,113,117
-,105,114,101,100,32,116,111,32,97,110,100,32,116,104,97,116,32,116,104,101,98,
-101,116,119,101,101,110,32,116,104,101,32,119,97,115,32,100,101,115,105,103,110,
-101,100,99,111,110,115,105,115,116,115,32,111,102,32,99,111,110,115,105,100,101,
-114,97,98,108,121,112,117,98,108,105,115,104,101,100,32,98,121,116,104,101,32,
-108,97,110,103,117,97,103,101,67,111,110,115,101,114,118,97,116,105,111,110,99,
-111,110,115,105,115,116,101,100,32,111,102,114,101,102,101,114,32,116,111,32,116
-,104,101,98,97,99,107,32,116,111,32,116,104,101,32,99,115,115,34,32,109,101,100,
-105,97,61,34,80,101,111,112,108,101,32,102,114,111,109,32,97,118,97,105,108,97,
-98,108,101,32,111,110,112,114,111,118,101,100,32,116,111,32,98,101,115,117,103,
-103,101,115,116,105,111,110,115,34,119,97,115,32,107,110,111,119,110,32,97,115,
-118,97,114,105,101,116,105,101,115,32,111,102,108,105,107,101,108,121,32,116,111
-,32,98,101,99,111,109,112,114,105,115,101,100,32,111,102,115,117,112,112,111,114
-,116,32,116,104,101,32,104,97,110,100,115,32,111,102,32,116,104,101,99,111,117,
-112,108,101,100,32,119,105,116,104,99,111,110,110,101,99,116,32,97,110,100,32,98
-,111,114,100,101,114,58,110,111,110,101,59,112,101,114,102,111,114,109,97,110,99
-,101,115,98,101,102,111,114,101,32,98,101,105,110,103,108,97,116,101,114,32,98,
-101,99,97,109,101,99,97,108,99,117,108,97,116,105,111,110,115,111,102,116,101,
-110,32,99,97,108,108,101,100,114,101,115,105,100,101,110,116,115,32,111,102,109,
-101,97,110,105,110,103,32,116,104,97,116,62,60,108,105,32,99,108,97,115,115,61,
-34,101,118,105,100,101,110,99,101,32,102,111,114,101,120,112,108,97,110,97,116,
-105,111,110,115,101,110,118,105,114,111,110,109,101,110,116,115,34,62,60,47,97,
-62,60,47,100,105,118,62,119,104,105,99,104,32,97,108,108,111,119,115,73,110,116,
-114,111,100,117,99,116,105,111,110,100,101,118,101,108,111,112,101,100,32,98,121
-,97,32,119,105,100,101,32,114,97,110,103,101,111,110,32,98,101,104,97,108,102,32
-,111,102,118,97,108,105,103,110,61,34,116,111,112,34,112,114,105,110,99,105,112,
-108,101,32,111,102,97,116,32,116,104,101,32,116,105,109,101,44,60,47,110,111,115
-,99,114,105,112,116,62,13,115,97,105,100,32,116,111,32,104,97,118,101,105,110,32
-,116,104,101,32,102,105,114,115,116,119,104,105,108,101,32,111,116,104,101,114,
-115,104,121,112,111,116,104,101,116,105,99,97,108,112,104,105,108,111,115,111,
-112,104,101,114,115,112,111,119,101,114,32,111,102,32,116,104,101,99,111,110,116
-,97,105,110,101,100,32,105,110,112,101,114,102,111,114,109,101,100,32,98,121,105
-,110,97,98,105,108,105,116,121,32,116,111,119,101,114,101,32,119,114,105,116,116
-,101,110,115,112,97,110,32,115,116,121,108,101,61,34,105,110,112,117,116,32,110,
-97,109,101,61,34,116,104,101,32,113,117,101,115,116,105,111,110,105,110,116,101,
-110,100,101,100,32,102,111,114,114,101,106,101,99,116,105,111,110,32,111,102,105
-,109,112,108,105,101,115,32,116,104,97,116,105,110,118,101,110,116,101,100,32,
-116,104,101,116,104,101,32,115,116,97,110,100,97,114,100,119,97,115,32,112,114,
-111,98,97,98,108,121,108,105,110,107,32,98,101,116,119,101,101,110,112,114,111,
-102,101,115,115,111,114,32,111,102,105,110,116,101,114,97,99,116,105,111,110,115
-,99,104,97,110,103,105,110,103,32,116,104,101,73,110,100,105,97,110,32,79,99,101
-,97,110,32,99,108,97,115,115,61,34,108,97,115,116,119,111,114,107,105,110,103,32
-,119,105,116,104,39,104,116,116,112,58,47,47,119,119,119,46,121,101,97,114,115,
-32,98,101,102,111,114,101,84,104,105,115,32,119,97,115,32,116,104,101,114,101,99
-,114,101,97,116,105,111,110,97,108,101,110,116,101,114,105,110,103,32,116,104,
-101,109,101,97,115,117,114,101,109,101,110,116,115,97,110,32,101,120,116,114,101
-,109,101,108,121,118,97,108,117,101,32,111,102,32,116,104,101,115,116,97,114,116
-,32,111,102,32,116,104,101,10,60,47,115,99,114,105,112,116,62,10,10,97,110,32,
-101,102,102,111,114,116,32,116,111,105,110,99,114,101,97,115,101,32,116,104,101,
-116,111,32,116,104,101,32,115,111,117,116,104,115,112,97,99,105,110,103,61,34,48
-,34,62,115,117,102,102,105,99,105,101,110,116,108,121,116,104,101,32,69,117,114,
-111,112,101,97,110,99,111,110,118,101,114,116,101,100,32,116,111,99,108,101,97,
-114,84,105,109,101,111,117,116,100,105,100,32,110,111,116,32,104,97,118,101,99,
-111,110,115,101,113,117,101,110,116,108,121,102,111,114,32,116,104,101,32,110,
-101,120,116,101,120,116,101,110,115,105,111,110,32,111,102,101,99,111,110,111,
-109,105,99,32,97,110,100,97,108,116,104,111,117,103,104,32,116,104,101,97,114,
-101,32,112,114,111,100,117,99,101,100,97,110,100,32,119,105,116,104,32,116,104,
-101,105,110,115,117,102,102,105,99,105,101,110,116,103,105,118,101,110,32,98,121
-,32,116,104,101,115,116,97,116,105,110,103,32,116,104,97,116,101,120,112,101,110
-,100,105,116,117,114,101,115,60,47,115,112,97,110,62,60,47,97,62,10,116,104,111,
-117,103,104,116,32,116,104,97,116,111,110,32,116,104,101,32,98,97,115,105,115,99
-,101,108,108,112,97,100,100,105,110,103,61,105,109,97,103,101,32,111,102,32,116,
-104,101,114,101,116,117,114,110,105,110,103,32,116,111,105,110,102,111,114,109,
-97,116,105,111,110,44,115,101,112,97,114,97,116,101,100,32,98,121,97,115,115,97,
-115,115,105,110,97,116,101,100,115,34,32,99,111,110,116,101,110,116,61,34,97,117
-,116,104,111,114,105,116,121,32,111,102,110,111,114,116,104,119,101,115,116,101,
-114,110,60,47,100,105,118,62,10,60,100,105,118,32,34,62,60,47,100,105,118,62,13,
-10,32,32,99,111,110,115,117,108,116,97,116,105,111,110,99,111,109,109,117,110,
-105,116,121,32,111,102,116,104,101,32,110,97,116,105,111,110,97,108,105,116,32,
-115,104,111,117,108,100,32,98,101,112,97,114,116,105,99,105,112,97,110,116,115,
-32,97,108,105,103,110,61,34,108,101,102,116,116,104,101,32,103,114,101,97,116,
-101,115,116,115,101,108,101,99,116,105,111,110,32,111,102,115,117,112,101,114,
-110,97,116,117,114,97,108,100,101,112,101,110,100,101,110,116,32,111,110,105,115
-,32,109,101,110,116,105,111,110,101,100,97,108,108,111,119,105,110,103,32,116,
-104,101,119,97,115,32,105,110,118,101,110,116,101,100,97,99,99,111,109,112,97,
-110,121,105,110,103,104,105,115,32,112,101,114,115,111,110,97,108,97,118,97,105,
-108,97,98,108,101,32,97,116,115,116,117,100,121,32,111,102,32,116,104,101,111,
-110,32,116,104,101,32,111,116,104,101,114,101,120,101,99,117,116,105,111,110,32,
-111,102,72,117,109,97,110,32,82,105,103,104,116,115,116,101,114,109,115,32,111,
-102,32,116,104,101,97,115,115,111,99,105,97,116,105,111,110,115,114,101,115,101,
-97,114,99,104,32,97,110,100,115,117,99,99,101,101,100,101,100,32,98,121,100,101,
-102,101,97,116,101,100,32,116,104,101,97,110,100,32,102,114,111,109,32,116,104,
-101,98,117,116,32,116,104,101,121,32,97,114,101,99,111,109,109,97,110,100,101,
-114,32,111,102,115,116,97,116,101,32,111,102,32,116,104,101,121,101,97,114,115,
-32,111,102,32,97,103,101,116,104,101,32,115,116,117,100,121,32,111,102,60,117,
-108,32,99,108,97,115,115,61,34,115,112,108,97,99,101,32,105,110,32,116,104,101,
-119,104,101,114,101,32,104,101,32,119,97,115,60,108,105,32,99,108,97,115,115,61,
-34,102,116,104,101,114,101,32,97,114,101,32,110,111,119,104,105,99,104,32,98,101
-,99,97,109,101,104,101,32,112,117,98,108,105,115,104,101,100,101,120,112,114,101
-,115,115,101,100,32,105,110,116,111,32,119,104,105,99,104,32,116,104,101,99,111,
-109,109,105,115,115,105,111,110,101,114,102,111,110,116,45,119,101,105,103,104,
-116,58,116,101,114,114,105,116,111,114,121,32,111,102,101,120,116,101,110,115,
-105,111,110,115,34,62,82,111,109,97,110,32,69,109,112,105,114,101,101,113,117,97
-,108,32,116,111,32,116,104,101,73,110,32,99,111,110,116,114,97,115,116,44,104,
-111,119,101,118,101,114,44,32,97,110,100,105,115,32,116,121,112,105,99,97,108,
-108,121,97,110,100,32,104,105,115,32,119,105,102,101,40,97,108,115,111,32,99,97,
-108,108,101,100,62,60,117,108,32,99,108,97,115,115,61,34,101,102,102,101,99,116,
-105,118,101,108,121,32,101,118,111,108,118,101,100,32,105,110,116,111,115,101,
-101,109,32,116,111,32,104,97,118,101,119,104,105,99,104,32,105,115,32,116,104,
-101,116,104,101,114,101,32,119,97,115,32,110,111,97,110,32,101,120,99,101,108,
-108,101,110,116,97,108,108,32,111,102,32,116,104,101,115,101,100,101,115,99,114,
-105,98,101,100,32,98,121,73,110,32,112,114,97,99,116,105,99,101,44,98,114,111,97
-,100,99,97,115,116,105,110,103,99,104,97,114,103,101,100,32,119,105,116,104,114,
-101,102,108,101,99,116,101,100,32,105,110,115,117,98,106,101,99,116,101,100,32,
-116,111,109,105,108,105,116,97,114,121,32,97,110,100,116,111,32,116,104,101,32,
-112,111,105,110,116,101,99,111,110,111,109,105,99,97,108,108,121,115,101,116,84,
-97,114,103,101,116,105,110,103,97,114,101,32,97,99,116,117,97,108,108,121,118,
-105,99,116,111,114,121,32,111,118,101,114,40,41,59,60,47,115,99,114,105,112,116,
-62,99,111,110,116,105,110,117,111,117,115,108,121,114,101,113,117,105,114,101,
-100,32,102,111,114,101,118,111,108,117,116,105,111,110,97,114,121,97,110,32,101,
-102,102,101,99,116,105,118,101,110,111,114,116,104,32,111,102,32,116,104,101,44,
-32,119,104,105,99,104,32,119,97,115,32,102,114,111,110,116,32,111,102,32,116,104
-,101,111,114,32,111,116,104,101,114,119,105,115,101,115,111,109,101,32,102,111,
-114,109,32,111,102,104,97,100,32,110,111,116,32,98,101,101,110,103,101,110,101,
-114,97,116,101,100,32,98,121,105,110,102,111,114,109,97,116,105,111,110,46,112,
-101,114,109,105,116,116,101,100,32,116,111,105,110,99,108,117,100,101,115,32,116
-,104,101,100,101,118,101,108,111,112,109,101,110,116,44,101,110,116,101,114,101,
-100,32,105,110,116,111,116,104,101,32,112,114,101,118,105,111,117,115,99,111,110
-,115,105,115,116,101,110,116,108,121,97,114,101,32,107,110,111,119,110,32,97,115
-,116,104,101,32,102,105,101,108,100,32,111,102,116,104,105,115,32,116,121,112,
-101,32,111,102,103,105,118,101,110,32,116,111,32,116,104,101,116,104,101,32,116,
-105,116,108,101,32,111,102,99,111,110,116,97,105,110,115,32,116,104,101,105,110,
-115,116,97,110,99,101,115,32,111,102,105,110,32,116,104,101,32,110,111,114,116,
-104,100,117,101,32,116,111,32,116,104,101,105,114,97,114,101,32,100,101,115,105,
-103,110,101,100,99,111,114,112,111,114,97,116,105,111,110,115,119,97,115,32,116,
-104,97,116,32,116,104,101,111,110,101,32,111,102,32,116,104,101,115,101,109,111,
-114,101,32,112,111,112,117,108,97,114,115,117,99,99,101,101,100,101,100,32,105,
-110,115,117,112,112,111,114,116,32,102,114,111,109,105,110,32,100,105,102,102,
-101,114,101,110,116,100,111,109,105,110,97,116,101,100,32,98,121,100,101,115,105
-,103,110,101,100,32,102,111,114,111,119,110,101,114,115,104,105,112,32,111,102,
-97,110,100,32,112,111,115,115,105,98,108,121,115,116,97,110,100,97,114,100,105,
-122,101,100,114,101,115,112,111,110,115,101,84,101,120,116,119,97,115,32,105,110
-,116,101,110,100,101,100,114,101,99,101,105,118,101,100,32,116,104,101,97,115,
-115,117,109,101,100,32,116,104,97,116,97,114,101,97,115,32,111,102,32,116,104,
-101,112,114,105,109,97,114,105,108,121,32,105,110,116,104,101,32,98,97,115,105,
-115,32,111,102,105,110,32,116,104,101,32,115,101,110,115,101,97,99,99,111,117,
-110,116,115,32,102,111,114,100,101,115,116,114,111,121,101,100,32,98,121,97,116,
-32,108,101,97,115,116,32,116,119,111,119,97,115,32,100,101,99,108,97,114,101,100
-,99,111,117,108,100,32,110,111,116,32,98,101,83,101,99,114,101,116,97,114,121,32
-,111,102,97,112,112,101,97,114,32,116,111,32,98,101,109,97,114,103,105,110,45,
-116,111,112,58,49,47,94,92,115,43,124,92,115,43,36,47,103,101,41,123,116,104,114
-,111,119,32,101,125,59,116,104,101,32,115,116,97,114,116,32,111,102,116,119,111,
-32,115,101,112,97,114,97,116,101,108,97,110,103,117,97,103,101,32,97,110,100,119
-,104,111,32,104,97,100,32,98,101,101,110,111,112,101,114,97,116,105,111,110,32,
-111,102,100,101,97,116,104,32,111,102,32,116,104,101,114,101,97,108,32,110,117,
-109,98,101,114,115,9,60,108,105,110,107,32,114,101,108,61,34,112,114,111,118,105
-,100,101,100,32,116,104,101,116,104,101,32,115,116,111,114,121,32,111,102,99,111
-,109,112,101,116,105,116,105,111,110,115,101,110,103,108,105,115,104,32,40,85,75
-,41,101,110,103,108,105,115,104,32,40,85,83,41,208,156,208,190,208,189,208,179,
-208,190,208,187,208,161,209,128,208,191,209,129,208,186,208,184,209,129,209,128,
-208,191,209,129,208,186,208,184,209,129,209,128,208,191,209,129,208,186,208,190,
-217,132,216,185,216,177,216,168,217,138,216,169,230,173,163,233,171,148,228,184,
-173,230,150,135,231,174,128,228,189,147,228,184,173,230,150,135,231,185,129,228,
-189,147,228,184,173,230,150,135,230,156,137,233,153,144,229,133,172,229,143,184,
-228,186,186,230,176,145,230,148,191,229,186,156,233,152,191,233,135,140,229,183,
-180,229,183,180,231,164,190,228,188,154,228,184,187,228,185,137,230,147,141,228,
-189,156,231,179,187,231,187,159,230,148,191,231,173,150,230,179,149,232,167,132,
-105,110,102,111,114,109,97,99,105,195,179,110,104,101,114,114,97,109,105,101,110
-,116,97,115,101,108,101,99,116,114,195,179,110,105,99,111,100,101,115,99,114,105
-,112,99,105,195,179,110,99,108,97,115,105,102,105,99,97,100,111,115,99,111,110,
-111,99,105,109,105,101,110,116,111,112,117,98,108,105,99,97,99,105,195,179,110,
-114,101,108,97,99,105,111,110,97,100,97,115,105,110,102,111,114,109,195,161,116,
-105,99,97,114,101,108,97,99,105,111,110,97,100,111,115,100,101,112,97,114,116,97
-,109,101,110,116,111,116,114,97,98,97,106,97,100,111,114,101,115,100,105,114,101
-,99,116,97,109,101,110,116,101,97,121,117,110,116,97,109,105,101,110,116,111,109
-,101,114,99,97,100,111,76,105,98,114,101,99,111,110,116,195,161,99,116,101,110,
-111,115,104,97,98,105,116,97,99,105,111,110,101,115,99,117,109,112,108,105,109,
-105,101,110,116,111,114,101,115,116,97,117,114,97,110,116,101,115,100,105,115,
-112,111,115,105,99,105,195,179,110,99,111,110,115,101,99,117,101,110,99,105,97,
-101,108,101,99,116,114,195,179,110,105,99,97,97,112,108,105,99,97,99,105,111,110
-,101,115,100,101,115,99,111,110,101,99,116,97,100,111,105,110,115,116,97,108,97,
-99,105,195,179,110,114,101,97,108,105,122,97,99,105,195,179,110,117,116,105,108,
-105,122,97,99,105,195,179,110,101,110,99,105,99,108,111,112,101,100,105,97,101,
-110,102,101,114,109,101,100,97,100,101,115,105,110,115,116,114,117,109,101,110,
-116,111,115,101,120,112,101,114,105,101,110,99,105,97,115,105,110,115,116,105,
-116,117,99,105,195,179,110,112,97,114,116,105,99,117,108,97,114,101,115,115,117,
-98,99,97,116,101,103,111,114,105,97,209,130,208,190,208,187,209,140,208,186,208,
-190,208,160,208,190,209,129,209,129,208,184,208,184,209,128,208,176,208,177,208,
-190,209,130,209,139,208,177,208,190,208,187,209,140,209,136,208,181,208,191,209,
-128,208,190,209,129,209,130,208,190,208,188,208,190,208,182,208,181,209,130,208,
-181,208,180,209,128,209,131,208,179,208,184,209,133,209,129,208,187,209,131,209,
-135,208,176,208,181,209,129,208,181,208,185,209,135,208,176,209,129,208,178,209,
-129,208,181,208,179,208,180,208,176,208,160,208,190,209,129,209,129,208,184,209,
-143,208,156,208,190,209,129,208,186,208,178,208,181,208,180,209,128,209,131,208,
-179,208,184,208,181,208,179,208,190,209,128,208,190,208,180,208,176,208,178,208,
-190,208,191,209,128,208,190,209,129,208,180,208,176,208,189,208,189,209,139,209,
-133,208,180,208,190,208,187,208,182,208,189,209,139,208,184,208,188,208,181,208,
-189,208,189,208,190,208,156,208,190,209,129,208,186,208,178,209,139,209,128,209,
-131,208,177,208,187,208,181,208,185,208,156,208,190,209,129,208,186,208,178,208,
-176,209,129,209,130,209,128,208,176,208,189,209,139,208,189,208,184,209,135,208,
-181,208,179,208,190,209,128,208,176,208,177,208,190,209,130,208,181,208,180,208,
-190,208,187,208,182,208,181,208,189,209,131,209,129,208,187,209,131,208,179,208,
-184,209,130,208,181,208,191,208,181,209,128,209,140,208,158,208,180,208,189,208,
-176,208,186,208,190,208,191,208,190,209,130,208,190,208,188,209,131,209,128,208,
-176,208,177,208,190,209,130,209,131,208,176,208,191,209,128,208,181,208,187,209,
-143,208,178,208,190,208,190,208,177,209,137,208,181,208,190,208,180,208,189,208,
-190,208,179,208,190,209,129,208,178,208,190,208,181,208,179,208,190,209,129,209,
-130,208,176,209,130,209,140,208,184,208,180,209,128,209,131,208,179,208,190,208,
-185,209,132,208,190,209,128,209,131,208,188,208,181,209,133,208,190,209,128,208,
-190,209,136,208,190,208,191,209,128,208,190,209,130,208,184,208,178,209,129,209,
-129,209,139,208,187,208,186,208,176,208,186,208,176,208,182,208,180,209,139,208,
-185,208,178,208,187,208,176,209,129,209,130,208,184,208,179,209,128,209,131,208,
-191,208,191,209,139,208,178,208,188,208,181,209,129,209,130,208,181,209,128,208,
-176,208,177,208,190,209,130,208,176,209,129,208,186,208,176,208,183,208,176,208,
-187,208,191,208,181,209,128,208,178,209,139,208,185,208,180,208,181,208,187,208,
-176,209,130,209,140,208,180,208,181,208,189,209,140,208,179,208,184,208,191,208,
-181,209,128,208,184,208,190,208,180,208,177,208,184,208,183,208,189,208,181,209,
-129,208,190,209,129,208,189,208,190,208,178,208,181,208,188,208,190,208,188,208,
-181,208,189,209,130,208,186,209,131,208,191,208,184,209,130,209,140,208,180,208,
-190,208,187,208,182,208,189,208,176,209,128,208,176,208,188,208,186,208,176,209,
-133,208,189,208,176,209,135,208,176,208,187,208,190,208,160,208,176,208,177,208,
-190,209,130,208,176,208,162,208,190,208,187,209,140,208,186,208,190,209,129,208,
-190,208,178,209,129,208,181,208,188,208,178,209,130,208,190,209,128,208,190,208,
-185,208,189,208,176,209,135,208,176,208,187,208,176,209,129,208,191,208,184,209,
-129,208,190,208,186,209,129,208,187,209,131,208,182,208,177,209,139,209,129,208,
-184,209,129,209,130,208,181,208,188,208,191,208,181,209,135,208,176,209,130,208,
-184,208,189,208,190,208,178,208,190,208,179,208,190,208,191,208,190,208,188,208,
-190,209,137,208,184,209,129,208,176,208,185,209,130,208,190,208,178,208,191,208,
-190,209,135,208,181,208,188,209,131,208,191,208,190,208,188,208,190,209,137,209,
-140,208,180,208,190,208,187,208,182,208,189,208,190,209,129,209,129,209,139,208,
-187,208,186,208,184,208,177,209,139,209,129,209,130,209,128,208,190,208,180,208,
-176,208,189,208,189,209,139,208,181,208,188,208,189,208,190,208,179,208,184,208,
-181,208,191,209,128,208,190,208,181,208,186,209,130,208,161,208,181,208,185,209,
-135,208,176,209,129,208,188,208,190,208,180,208,181,208,187,208,184,209,130,208,
-176,208,186,208,190,208,179,208,190,208,190,208,189,208,187,208,176,208,185,208,
-189,208,179,208,190,209,128,208,190,208,180,208,181,208,178,208,181,209,128,209,
-129,208,184,209,143,209,129,209,130,209,128,208,176,208,189,208,181,209,132,208,
-184,208,187,209,140,208,188,209,139,209,131,209,128,208,190,208,178,208,189,209,
-143,209,128,208,176,208,183,208,189,209,139,209,133,208,184,209,129,208,186,208,
-176,209,130,209,140,208,189,208,181,208,180,208,181,208,187,209,142,209,143,208,
-189,208,178,208,176,209,128,209,143,208,188,208,181,208,189,209,140,209,136,208,
-181,208,188,208,189,208,190,208,179,208,184,209,133,208,180,208,176,208,189,208,
-189,208,190,208,185,208,183,208,189,208,176,209,135,208,184,209,130,208,189,208,
-181,208,187,209,140,208,183,209,143,209,132,208,190,209,128,209,131,208,188,208,
-176,208,162,208,181,208,191,208,181,209,128,209,140,208,188,208,181,209,129,209,
-143,209,134,208,176,208,183,208,176,209,137,208,184,209,130,209,139,208,155,209,
-131,209,135,209,136,208,184,208,181,224,164,168,224,164,185,224,165,128,224,164,
-130,224,164,149,224,164,176,224,164,168,224,165,135,224,164,133,224,164,170,224,
-164,168,224,165,135,224,164,149,224,164,191,224,164,175,224,164,190,224,164,149,
-224,164,176,224,165,135,224,164,130,224,164,133,224,164,168,224,165,141,224,164,
-175,224,164,149,224,165,141,224,164,175,224,164,190,224,164,151,224,164,190,224,
-164,135,224,164,161,224,164,172,224,164,190,224,164,176,224,165,135,224,164,149,
-224,164,191,224,164,184,224,165,128,224,164,166,224,164,191,224,164,175,224,164,
-190,224,164,170,224,164,185,224,164,178,224,165,135,224,164,184,224,164,191,224,
-164,130,224,164,185,224,164,173,224,164,190,224,164,176,224,164,164,224,164,133,
-224,164,170,224,164,168,224,165,128,224,164,181,224,164,190,224,164,178,224,165,
-135,224,164,184,224,165,135,224,164,181,224,164,190,224,164,149,224,164,176,224,
-164,164,224,165,135,224,164,174,224,165,135,224,164,176,224,165,135,224,164,185,
-224,165,139,224,164,168,224,165,135,224,164,184,224,164,149,224,164,164,224,165,
-135,224,164,172,224,164,185,224,165,129,224,164,164,224,164,184,224,164,190,224,
-164,135,224,164,159,224,164,185,224,165,139,224,164,151,224,164,190,224,164,156,
-224,164,190,224,164,168,224,165,135,224,164,174,224,164,191,224,164,168,224,164,
-159,224,164,149,224,164,176,224,164,164,224,164,190,224,164,149,224,164,176,224,
-164,168,224,164,190,224,164,137,224,164,168,224,164,149,224,165,135,224,164,175,
-224,164,185,224,164,190,224,164,129,224,164,184,224,164,172,224,164,184,224,165,
-135,224,164,173,224,164,190,224,164,183,224,164,190,224,164,134,224,164,170,224,
-164,149,224,165,135,224,164,178,224,164,191,224,164,175,224,165,135,224,164,182,
-224,165,129,224,164,176,224,165,130,224,164,135,224,164,184,224,164,149,224,165,
-135,224,164,152,224,164,130,224,164,159,224,165,135,224,164,174,224,165,135,224,
-164,176,224,165,128,224,164,184,224,164,149,224,164,164,224,164,190,224,164,174,
-224,165,135,224,164,176,224,164,190,224,164,178,224,165,135,224,164,149,224,164,
-176,224,164,133,224,164,167,224,164,191,224,164,149,224,164,133,224,164,170,224,
-164,168,224,164,190,224,164,184,224,164,174,224,164,190,224,164,156,224,164,174,
-224,165,129,224,164,157,224,165,135,224,164,149,224,164,190,224,164,176,224,164,
-163,224,164,185,224,165,139,224,164,164,224,164,190,224,164,149,224,164,161,224,
-164,188,224,165,128,224,164,175,224,164,185,224,164,190,224,164,130,224,164,185,
-224,165,139,224,164,159,224,164,178,224,164,182,224,164,172,224,165,141,224,164,
-166,224,164,178,224,164,191,224,164,175,224,164,190,224,164,156,224,165,128,224,
-164,181,224,164,168,224,164,156,224,164,190,224,164,164,224,164,190,224,164,149,
-224,165,136,224,164,184,224,165,135,224,164,134,224,164,170,224,164,149,224,164,
-190,224,164,181,224,164,190,224,164,178,224,165,128,224,164,166,224,165,135,224,
-164,168,224,165,135,224,164,170,224,165,130,224,164,176,224,165,128,224,164,170,
-224,164,190,224,164,168,224,165,128,224,164,137,224,164,184,224,164,149,224,165,
-135,224,164,185,224,165,139,224,164,151,224,165,128,224,164,172,224,165,136,224,
-164,160,224,164,149,224,164,134,224,164,170,224,164,149,224,165,128,224,164,181,
-224,164,176,224,165,141,224,164,183,224,164,151,224,164,190,224,164,130,224,164,
-181,224,164,134,224,164,170,224,164,149,224,165,139,224,164,156,224,164,191,224,
-164,178,224,164,190,224,164,156,224,164,190,224,164,168,224,164,190,224,164,184,
-224,164,185,224,164,174,224,164,164,224,164,185,224,164,174,224,165,135,224,164,
-130,224,164,137,224,164,168,224,164,149,224,165,128,224,164,175,224,164,190,224,
-164,185,224,165,130,224,164,166,224,164,176,224,165,141,224,164,156,224,164,184,
-224,165,130,224,164,154,224,165,128,224,164,170,224,164,184,224,164,130,224,164,
-166,224,164,184,224,164,181,224,164,190,224,164,178,224,164,185,224,165,139,224,
-164,168,224,164,190,224,164,185,224,165,139,224,164,164,224,165,128,224,164,156,
-224,165,136,224,164,184,224,165,135,224,164,181,224,164,190,224,164,170,224,164,
-184,224,164,156,224,164,168,224,164,164,224,164,190,224,164,168,224,165,135,224,
-164,164,224,164,190,224,164,156,224,164,190,224,164,176,224,165,128,224,164,152,
-224,164,190,224,164,175,224,164,178,224,164,156,224,164,191,224,164,178,224,165,
-135,224,164,168,224,165,128,224,164,154,224,165,135,224,164,156,224,164,190,224,
-164,130,224,164,154,224,164,170,224,164,164,224,165,141,224,164,176,224,164,151,
-224,165,130,224,164,151,224,164,178,224,164,156,224,164,190,224,164,164,224,165,
-135,224,164,172,224,164,190,224,164,185,224,164,176,224,164,134,224,164,170,224,
-164,168,224,165,135,224,164,181,224,164,190,224,164,185,224,164,168,224,164,135,
-224,164,184,224,164,149,224,164,190,224,164,184,224,165,129,224,164,172,224,164,
-185,224,164,176,224,164,185,224,164,168,224,165,135,224,164,135,224,164,184,224,
-164,184,224,165,135,224,164,184,224,164,185,224,164,191,224,164,164,224,164,172,
-224,164,161,224,164,188,224,165,135,224,164,152,224,164,159,224,164,168,224,164,
-190,224,164,164,224,164,178,224,164,190,224,164,182,224,164,170,224,164,190,224,
-164,130,224,164,154,224,164,182,224,165,141,224,164,176,224,165,128,224,164,172,
-224,164,161,224,164,188,224,165,128,224,164,185,224,165,139,224,164,164,224,165,
-135,224,164,184,224,164,190,224,164,136,224,164,159,224,164,182,224,164,190,224,
-164,175,224,164,166,224,164,184,224,164,149,224,164,164,224,165,128,224,164,156,
-224,164,190,224,164,164,224,165,128,224,164,181,224,164,190,224,164,178,224,164,
-190,224,164,185,224,164,156,224,164,190,224,164,176,224,164,170,224,164,159,224,
-164,168,224,164,190,224,164,176,224,164,150,224,164,168,224,165,135,224,164,184,
-224,164,161,224,164,188,224,164,149,224,164,174,224,164,191,224,164,178,224,164,
-190,224,164,137,224,164,184,224,164,149,224,165,128,224,164,149,224,165,135,224,
-164,181,224,164,178,224,164,178,224,164,151,224,164,164,224,164,190,224,164,150,
-224,164,190,224,164,168,224,164,190,224,164,133,224,164,176,224,165,141,224,164,
-165,224,164,156,224,164,185,224,164,190,224,164,130,224,164,166,224,165,135,224,
-164,150,224,164,190,224,164,170,224,164,185,224,164,178,224,165,128,224,164,168,
-224,164,191,224,164,175,224,164,174,224,164,172,224,164,191,224,164,168,224,164,
-190,224,164,172,224,165,136,224,164,130,224,164,149,224,164,149,224,164,185,224,
-165,128,224,164,130,224,164,149,224,164,185,224,164,168,224,164,190,224,164,166,
-224,165,135,224,164,164,224,164,190,224,164,185,224,164,174,224,164,178,224,165,
-135,224,164,149,224,164,190,224,164,171,224,165,128,224,164,156,224,164,172,224,
-164,149,224,164,191,224,164,164,224,165,129,224,164,176,224,164,164,224,164,174,
-224,164,190,224,164,130,224,164,151,224,164,181,224,164,185,224,165,128,224,164,
-130,224,164,176,224,165,139,224,164,156,224,164,188,224,164,174,224,164,191,224,
-164,178,224,165,128,224,164,134,224,164,176,224,165,139,224,164,170,224,164,184,
-224,165,135,224,164,168,224,164,190,224,164,175,224,164,190,224,164,166,224,164,
-181,224,164,178,224,165,135,224,164,168,224,165,135,224,164,150,224,164,190,224,
-164,164,224,164,190,224,164,149,224,164,176,224,165,128,224,164,172,224,164,137,
-224,164,168,224,164,149,224,164,190,224,164,156,224,164,181,224,164,190,224,164,
-172,224,164,170,224,165,130,224,164,176,224,164,190,224,164,172,224,164,161,224,
-164,188,224,164,190,224,164,184,224,165,140,224,164,166,224,164,190,224,164,182,
-224,165,135,224,164,175,224,164,176,224,164,149,224,164,191,224,164,175,224,165,
-135,224,164,149,224,164,185,224,164,190,224,164,130,224,164,133,224,164,149,224,
-164,184,224,164,176,224,164,172,224,164,168,224,164,190,224,164,143,224,164,181,
-224,164,185,224,164,190,224,164,130,224,164,184,224,165,141,224,164,165,224,164,
-178,224,164,174,224,164,191,224,164,178,224,165,135,224,164,178,224,165,135,224,
-164,150,224,164,149,224,164,181,224,164,191,224,164,183,224,164,175,224,164,149,
-224,165,141,224,164,176,224,164,130,224,164,184,224,164,174,224,165,130,224,164,
-185,224,164,165,224,164,190,224,164,168,224,164,190,216,170,216,179,216,170,216,
-183,217,138,216,185,217,133,216,180,216,167,216,177,217,131,216,169,216,168,217,
-136,216,167,216,179,216,183,216,169,216,167,217,132,216,181,217,129,216,173,216,
-169,217,133,217,136,216,167,216,182,217,138,216,185,216,167,217,132,216,174,216,
-167,216,181,216,169,216,167,217,132,217,133,216,178,217,138,216,175,216,167,217,
-132,216,185,216,167,217,133,216,169,216,167,217,132,217,131,216,167,216,170,216,
-168,216,167,217,132,216,177,216,175,217,136,216,175,216,168,216,177,217,134,216,
-167,217,133,216,172,216,167,217,132,216,175,217,136,217,132,216,169,216,167,217,
-132,216,185,216,167,217,132,217,133,216,167,217,132,217,133,217,136,217,130,216,
-185,216,167,217,132,216,185,216,177,216,168,217,138,216,167,217,132,216,179,216,
-177,217,138,216,185,216,167,217,132,216,172,217,136,216,167,217,132,216,167,217,
-132,216,176,217,135,216,167,216,168,216,167,217,132,216,173,217,138,216,167,216,
-169,216,167,217,132,216,173,217,130,217,136,217,130,216,167,217,132,217,131,216,
-177,217,138,217,133,216,167,217,132,216,185,216,177,216,167,217,130,217,133,216,
-173,217,129,217,136,216,184,216,169,216,167,217,132,216,171,216,167,217,134,217,
-138,217,133,216,180,216,167,217,135,216,175,216,169,216,167,217,132,217,133,216,
-177,216,163,216,169,216,167,217,132,217,130,216,177,216,162,217,134,216,167,217,
-132,216,180,216,168,216,167,216,168,216,167,217,132,216,173,217,136,216,167,216,
-177,216,167,217,132,216,172,216,175,217,138,216,175,216,167,217,132,216,163,216,
-179,216,177,216,169,216,167,217,132,216,185,217,132,217,136,217,133,217,133,216,
-172,217,133,217,136,216,185,216,169,216,167,217,132,216,177,216,173,217,133,217,
-134,216,167,217,132,217,134,217,130,216,167,216,183,217,129,217,132,216,179,216,
-183,217,138,217,134,216,167,217,132,217,131,217,136,217,138,216,170,216,167,217,
-132,216,175,217,134,217,138,216,167,216,168,216,177,217,131,216,167,216,170,217,
-135,216,167,217,132,216,177,217,138,216,167,216,182,216,170,216,173,217,138,216,
-167,216,170,217,138,216,168,216,170,217,136,217,130,217,138,216,170,216,167,217,
-132,216,163,217,136,217,132,217,137,216,167,217,132,216,168,216,177,217,138,216,
-175,216,167,217,132,217,131,217,132,216,167,217,133,216,167,217,132,216,177,216,
-167,216,168,216,183,216,167,217,132,216,180,216,174,216,181,217,138,216,179,217,
-138,216,167,216,177,216,167,216,170,216,167,217,132,216,171,216,167,217,132,216,
-171,216,167,217,132,216,181,217,132,216,167,216,169,216,167,217,132,216,173,216,
-175,217,138,216,171,216,167,217,132,216,178,217,136,216,167,216,177,216,167,217,
-132,216,174,217,132,217,138,216,172,216,167,217,132,216,172,217,133,217,138,216,
-185,216,167,217,132,216,185,216,167,217,133,217,135,216,167,217,132,216,172,217,
-133,216,167,217,132,216,167,217,132,216,179,216,167,216,185,216,169,217,133,216,
-180,216,167,217,135,216,175,217,135,216,167,217,132,216,177,216,166,217,138,216,
-179,216,167,217,132,216,175,216,174,217,136,217,132,216,167,217,132,217,129,217,
-134,217,138,216,169,216,167,217,132,217,131,216,170,216,167,216,168,216,167,217,
-132,216,175,217,136,216,177,217,138,216,167,217,132,216,175,216,177,217,136,216,
-179,216,167,216,179,216,170,216,186,216,177,217,130,216,170,216,181,216,167,217,
-133,217,138,217,133,216,167,217,132,216,168,217,134,216,167,216,170,216,167,217,
-132,216,185,216,184,217,138,217,133,101,110,116,101,114,116,97,105,110,109,101,
-110,116,117,110,100,101,114,115,116,97,110,100,105,110,103,32,61,32,102,117,110,
-99,116,105,111,110,40,41,46,106,112,103,34,32,119,105,100,116,104,61,34,99,111,
-110,102,105,103,117,114,97,116,105,111,110,46,112,110,103,34,32,119,105,100,116,
-104,61,34,60,98,111,100,121,32,99,108,97,115,115,61,34,77,97,116,104,46,114,97,
-110,100,111,109,40,41,99,111,110,116,101,109,112,111,114,97,114,121,32,85,110,
-105,116,101,100,32,83,116,97,116,101,115,99,105,114,99,117,109,115,116,97,110,99
-,101,115,46,97,112,112,101,110,100,67,104,105,108,100,40,111,114,103,97,110,105,
-122,97,116,105,111,110,115,60,115,112,97,110,32,99,108,97,115,115,61,34,34,62,60
-,105,109,103,32,115,114,99,61,34,47,100,105,115,116,105,110,103,117,105,115,104,
-101,100,116,104,111,117,115,97,110,100,115,32,111,102,32,99,111,109,109,117,110,
-105,99,97,116,105,111,110,99,108,101,97,114,34,62,60,47,100,105,118,62,105,110,
-118,101,115,116,105,103,97,116,105,111,110,102,97,118,105,99,111,110,46,105,99,
-111,34,32,109,97,114,103,105,110,45,114,105,103,104,116,58,98,97,115,101,100,32,
-111,110,32,116,104,101,32,77,97,115,115,97,99,104,117,115,101,116,116,115,116,97
-,98,108,101,32,98,111,114,100,101,114,61,105,110,116,101,114,110,97,116,105,111,
-110,97,108,97,108,115,111,32,107,110,111,119,110,32,97,115,112,114,111,110,117,
-110,99,105,97,116,105,111,110,98,97,99,107,103,114,111,117,110,100,58,35,102,112
-,97,100,100,105,110,103,45,108,101,102,116,58,70,111,114,32,101,120,97,109,112,
-108,101,44,32,109,105,115,99,101,108,108,97,110,101,111,117,115,38,108,116,59,47
-,109,97,116,104,38,103,116,59,112,115,121,99,104,111,108,111,103,105,99,97,108,
-105,110,32,112,97,114,116,105,99,117,108,97,114,101,97,114,99,104,34,32,116,121,
-112,101,61,34,102,111,114,109,32,109,101,116,104,111,100,61,34,97,115,32,111,112
-,112,111,115,101,100,32,116,111,83,117,112,114,101,109,101,32,67,111,117,114,116
-,111,99,99,97,115,105,111,110,97,108,108,121,32,65,100,100,105,116,105,111,110,
-97,108,108,121,44,78,111,114,116,104,32,65,109,101,114,105,99,97,112,120,59,98,
-97,99,107,103,114,111,117,110,100,111,112,112,111,114,116,117,110,105,116,105,
-101,115,69,110,116,101,114,116,97,105,110,109,101,110,116,46,116,111,76,111,119,
-101,114,67,97,115,101,40,109,97,110,117,102,97,99,116,117,114,105,110,103,112,
-114,111,102,101,115,115,105,111,110,97,108,32,99,111,109,98,105,110,101,100,32,
-119,105,116,104,70,111,114,32,105,110,115,116,97,110,99,101,44,99,111,110,115,
-105,115,116,105,110,103,32,111,102,34,32,109,97,120,108,101,110,103,116,104,61,
-34,114,101,116,117,114,110,32,102,97,108,115,101,59,99,111,110,115,99,105,111,
-117,115,110,101,115,115,77,101,100,105,116,101,114,114,97,110,101,97,110,101,120
-,116,114,97,111,114,100,105,110,97,114,121,97,115,115,97,115,115,105,110,97,116,
-105,111,110,115,117,98,115,101,113,117,101,110,116,108,121,32,98,117,116,116,111
-,110,32,116,121,112,101,61,34,116,104,101,32,110,117,109,98,101,114,32,111,102,
-116,104,101,32,111,114,105,103,105,110,97,108,32,99,111,109,112,114,101,104,101,
-110,115,105,118,101,114,101,102,101,114,115,32,116,111,32,116,104,101,60,47,117,
-108,62,10,60,47,100,105,118,62,10,112,104,105,108,111,115,111,112,104,105,99,97,
-108,108,111,99,97,116,105,111,110,46,104,114,101,102,119,97,115,32,112,117,98,
-108,105,115,104,101,100,83,97,110,32,70,114,97,110,99,105,115,99,111,40,102,117,
-110,99,116,105,111,110,40,41,123,10,60,100,105,118,32,105,100,61,34,109,97,105,
-110,115,111,112,104,105,115,116,105,99,97,116,101,100,109,97,116,104,101,109,97,
-116,105,99,97,108,32,47,104,101,97,100,62,13,10,60,98,111,100,121,115,117,103,
-103,101,115,116,115,32,116,104,97,116,100,111,99,117,109,101,110,116,97,116,105,
-111,110,99,111,110,99,101,110,116,114,97,116,105,111,110,114,101,108,97,116,105,
-111,110,115,104,105,112,115,109,97,121,32,104,97,118,101,32,98,101,101,110,40,
-102,111,114,32,101,120,97,109,112,108,101,44,84,104,105,115,32,97,114,116,105,99
-,108,101,32,105,110,32,115,111,109,101,32,99,97,115,101,115,112,97,114,116,115,
-32,111,102,32,116,104,101,32,100,101,102,105,110,105,116,105,111,110,32,111,102,
-71,114,101,97,116,32,66,114,105,116,97,105,110,32,99,101,108,108,112,97,100,100,
-105,110,103,61,101,113,117,105,118,97,108,101,110,116,32,116,111,112,108,97,99,
-101,104,111,108,100,101,114,61,34,59,32,102,111,110,116,45,115,105,122,101,58,32
-,106,117,115,116,105,102,105,99,97,116,105,111,110,98,101,108,105,101,118,101,
-100,32,116,104,97,116,115,117,102,102,101,114,101,100,32,102,114,111,109,97,116,
-116,101,109,112,116,101,100,32,116,111,32,108,101,97,100,101,114,32,111,102,32,
-116,104,101,99,114,105,112,116,34,32,115,114,99,61,34,47,40,102,117,110,99,116,
-105,111,110,40,41,32,123,97,114,101,32,97,118,97,105,108,97,98,108,101,10,9,60,
-108,105,110,107,32,114,101,108,61,34,32,115,114,99,61,39,104,116,116,112,58,47,
-47,105,110,116,101,114,101,115,116,101,100,32,105,110,99,111,110,118,101,110,116
-,105,111,110,97,108,32,34,32,97,108,116,61,34,34,32,47,62,60,47,97,114,101,32,
-103,101,110,101,114,97,108,108,121,104,97,115,32,97,108,115,111,32,98,101,101,
-110,109,111,115,116,32,112,111,112,117,108,97,114,32,99,111,114,114,101,115,112,
-111,110,100,105,110,103,99,114,101,100,105,116,101,100,32,119,105,116,104,116,
-121,108,101,61,34,98,111,114,100,101,114,58,60,47,97,62,60,47,115,112,97,110,62,
-60,47,46,103,105,102,34,32,119,105,100,116,104,61,34,60,105,102,114,97,109,101,
-32,115,114,99,61,34,116,97,98,108,101,32,99,108,97,115,115,61,34,105,110,108,105
-,110,101,45,98,108,111,99,107,59,97,99,99,111,114,100,105,110,103,32,116,111,32,
-116,111,103,101,116,104,101,114,32,119,105,116,104,97,112,112,114,111,120,105,
-109,97,116,101,108,121,112,97,114,108,105,97,109,101,110,116,97,114,121,109,111,
-114,101,32,97,110,100,32,109,111,114,101,100,105,115,112,108,97,121,58,110,111,
-110,101,59,116,114,97,100,105,116,105,111,110,97,108,108,121,112,114,101,100,111
-,109,105,110,97,110,116,108,121,38,110,98,115,112,59,124,38,110,98,115,112,59,38
-,110,98,115,112,59,60,47,115,112,97,110,62,32,99,101,108,108,115,112,97,99,105,
-110,103,61,60,105,110,112,117,116,32,110,97,109,101,61,34,111,114,34,32,99,111,
-110,116,101,110,116,61,34,99,111,110,116,114,111,118,101,114,115,105,97,108,112,
-114,111,112,101,114,116,121,61,34,111,103,58,47,120,45,115,104,111,99,107,119,97
-,118,101,45,100,101,109,111,110,115,116,114,97,116,105,111,110,115,117,114,114,
-111,117,110,100,101,100,32,98,121,78,101,118,101,114,116,104,101,108,101,115,115
-,44,119,97,115,32,116,104,101,32,102,105,114,115,116,99,111,110,115,105,100,101,
-114,97,98,108,101,32,65,108,116,104,111,117,103,104,32,116,104,101,32,99,111,108
-,108,97,98,111,114,97,116,105,111,110,115,104,111,117,108,100,32,110,111,116,32,
-98,101,112,114,111,112,111,114,116,105,111,110,32,111,102,60,115,112,97,110,32,
-115,116,121,108,101,61,34,107,110,111,119,110,32,97,115,32,116,104,101,32,115,
-104,111,114,116,108,121,32,97,102,116,101,114,102,111,114,32,105,110,115,116,97,
-110,99,101,44,100,101,115,99,114,105,98,101,100,32,97,115,32,47,104,101,97,100,
-62,10,60,98,111,100,121,32,115,116,97,114,116,105,110,103,32,119,105,116,104,105
-,110,99,114,101,97,115,105,110,103,108,121,32,116,104,101,32,102,97,99,116,32,
-116,104,97,116,100,105,115,99,117,115,115,105,111,110,32,111,102,109,105,100,100
-,108,101,32,111,102,32,116,104,101,97,110,32,105,110,100,105,118,105,100,117,97,
-108,100,105,102,102,105,99,117,108,116,32,116,111,32,112,111,105,110,116,32,111,
-102,32,118,105,101,119,104,111,109,111,115,101,120,117,97,108,105,116,121,97,99,
-99,101,112,116,97,110,99,101,32,111,102,60,47,115,112,97,110,62,60,47,100,105,
-118,62,109,97,110,117,102,97,99,116,117,114,101,114,115,111,114,105,103,105,110,
-32,111,102,32,116,104,101,99,111,109,109,111,110,108,121,32,117,115,101,100,105,
-109,112,111,114,116,97,110,99,101,32,111,102,100,101,110,111,109,105,110,97,116,
-105,111,110,115,98,97,99,107,103,114,111,117,110,100,58,32,35,108,101,110,103,
-116,104,32,111,102,32,116,104,101,100,101,116,101,114,109,105,110,97,116,105,111
-,110,97,32,115,105,103,110,105,102,105,99,97,110,116,34,32,98,111,114,100,101,
-114,61,34,48,34,62,114,101,118,111,108,117,116,105,111,110,97,114,121,112,114,
-105,110,99,105,112,108,101,115,32,111,102,105,115,32,99,111,110,115,105,100,101,
-114,101,100,119,97,115,32,100,101,118,101,108,111,112,101,100,73,110,100,111,45,
-69,117,114,111,112,101,97,110,118,117,108,110,101,114,97,98,108,101,32,116,111,
-112,114,111,112,111,110,101,110,116,115,32,111,102,97,114,101,32,115,111,109,101
-,116,105,109,101,115,99,108,111,115,101,114,32,116,111,32,116,104,101,78,101,119
-,32,89,111,114,107,32,67,105,116,121,32,110,97,109,101,61,34,115,101,97,114,99,
-104,97,116,116,114,105,98,117,116,101,100,32,116,111,99,111,117,114,115,101,32,
-111,102,32,116,104,101,109,97,116,104,101,109,97,116,105,99,105,97,110,98,121,32
-,116,104,101,32,101,110,100,32,111,102,97,116,32,116,104,101,32,101,110,100,32,
-111,102,34,32,98,111,114,100,101,114,61,34,48,34,32,116,101,99,104,110,111,108,
-111,103,105,99,97,108,46,114,101,109,111,118,101,67,108,97,115,115,40,98,114,97,
-110,99,104,32,111,102,32,116,104,101,101,118,105,100,101,110,99,101,32,116,104,
-97,116,33,91,101,110,100,105,102,93,45,45,62,13,10,73,110,115,116,105,116,117,
-116,101,32,111,102,32,105,110,116,111,32,97,32,115,105,110,103,108,101,114,101,
-115,112,101,99,116,105,118,101,108,121,46,97,110,100,32,116,104,101,114,101,102,
-111,114,101,112,114,111,112,101,114,116,105,101,115,32,111,102,105,115,32,108,
-111,99,97,116,101,100,32,105,110,115,111,109,101,32,111,102,32,119,104,105,99,
-104,84,104,101,114,101,32,105,115,32,97,108,115,111,99,111,110,116,105,110,117,
-101,100,32,116,111,32,97,112,112,101,97,114,97,110,99,101,32,111,102,32,38,97,
-109,112,59,110,100,97,115,104,59,32,100,101,115,99,114,105,98,101,115,32,116,104
-,101,99,111,110,115,105,100,101,114,97,116,105,111,110,97,117,116,104,111,114,32
-,111,102,32,116,104,101,105,110,100,101,112,101,110,100,101,110,116,108,121,101,
-113,117,105,112,112,101,100,32,119,105,116,104,100,111,101,115,32,110,111,116,32
-,104,97,118,101,60,47,97,62,60,97,32,104,114,101,102,61,34,99,111,110,102,117,
-115,101,100,32,119,105,116,104,60,108,105,110,107,32,104,114,101,102,61,34,47,97
-,116,32,116,104,101,32,97,103,101,32,111,102,97,112,112,101,97,114,32,105,110,32
-,116,104,101,84,104,101,115,101,32,105,110,99,108,117,100,101,114,101,103,97,114
-,100,108,101,115,115,32,111,102,99,111,117,108,100,32,98,101,32,117,115,101,100,
-32,115,116,121,108,101,61,38,113,117,111,116,59,115,101,118,101,114,97,108,32,
-116,105,109,101,115,114,101,112,114,101,115,101,110,116,32,116,104,101,98,111,
-100,121,62,10,60,47,104,116,109,108,62,116,104,111,117,103,104,116,32,116,111,32
-,98,101,112,111,112,117,108,97,116,105,111,110,32,111,102,112,111,115,115,105,98
-,105,108,105,116,105,101,115,112,101,114,99,101,110,116,97,103,101,32,111,102,97
-,99,99,101,115,115,32,116,111,32,116,104,101,97,110,32,97,116,116,101,109,112,
-116,32,116,111,112,114,111,100,117,99,116,105,111,110,32,111,102,106,113,117,101
-,114,121,47,106,113,117,101,114,121,116,119,111,32,100,105,102,102,101,114,101,
-110,116,98,101,108,111,110,103,32,116,111,32,116,104,101,101,115,116,97,98,108,
-105,115,104,109,101,110,116,114,101,112,108,97,99,105,110,103,32,116,104,101,100
-,101,115,99,114,105,112,116,105,111,110,34,32,100,101,116,101,114,109,105,110,
-101,32,116,104,101,97,118,97,105,108,97,98,108,101,32,102,111,114,65,99,99,111,
-114,100,105,110,103,32,116,111,32,119,105,100,101,32,114,97,110,103,101,32,111,
-102,9,60,100,105,118,32,99,108,97,115,115,61,34,109,111,114,101,32,99,111,109,
-109,111,110,108,121,111,114,103,97,110,105,115,97,116,105,111,110,115,102,117,
-110,99,116,105,111,110,97,108,105,116,121,119,97,115,32,99,111,109,112,108,101,
-116,101,100,32,38,97,109,112,59,109,100,97,115,104,59,32,112,97,114,116,105,99,
-105,112,97,116,105,111,110,116,104,101,32,99,104,97,114,97,99,116,101,114,97,110
-,32,97,100,100,105,116,105,111,110,97,108,97,112,112,101,97,114,115,32,116,111,
-32,98,101,102,97,99,116,32,116,104,97,116,32,116,104,101,97,110,32,101,120,97,
-109,112,108,101,32,111,102,115,105,103,110,105,102,105,99,97,110,116,108,121,111
-,110,109,111,117,115,101,111,118,101,114,61,34,98,101,99,97,117,115,101,32,116,
-104,101,121,32,97,115,121,110,99,32,61,32,116,114,117,101,59,112,114,111,98,108,
-101,109,115,32,119,105,116,104,115,101,101,109,115,32,116,111,32,104,97,118,101,
-116,104,101,32,114,101,115,117,108,116,32,111,102,32,115,114,99,61,34,104,116,
-116,112,58,47,47,102,97,109,105,108,105,97,114,32,119,105,116,104,112,111,115,
-115,101,115,115,105,111,110,32,111,102,102,117,110,99,116,105,111,110,32,40,41,
-32,123,116,111,111,107,32,112,108,97,99,101,32,105,110,97,110,100,32,115,111,109
-,101,116,105,109,101,115,115,117,98,115,116,97,110,116,105,97,108,108,121,60,115
-,112,97,110,62,60,47,115,112,97,110,62,105,115,32,111,102,116,101,110,32,117,115
-,101,100,105,110,32,97,110,32,97,116,116,101,109,112,116,103,114,101,97,116,32,
-100,101,97,108,32,111,102,69,110,118,105,114,111,110,109,101,110,116,97,108,115,
-117,99,99,101,115,115,102,117,108,108,121,32,118,105,114,116,117,97,108,108,121,
-32,97,108,108,50,48,116,104,32,99,101,110,116,117,114,121,44,112,114,111,102,101
-,115,115,105,111,110,97,108,115,110,101,99,101,115,115,97,114,121,32,116,111,32,
-100,101,116,101,114,109,105,110,101,100,32,98,121,99,111,109,112,97,116,105,98,
-105,108,105,116,121,98,101,99,97,117,115,101,32,105,116,32,105,115,68,105,99,116
-,105,111,110,97,114,121,32,111,102,109,111,100,105,102,105,99,97,116,105,111,110
-,115,84,104,101,32,102,111,108,108,111,119,105,110,103,109,97,121,32,114,101,102
-,101,114,32,116,111,58,67,111,110,115,101,113,117,101,110,116,108,121,44,73,110,
-116,101,114,110,97,116,105,111,110,97,108,97,108,116,104,111,117,103,104,32,115,
-111,109,101,116,104,97,116,32,119,111,117,108,100,32,98,101,119,111,114,108,100,
-39,115,32,102,105,114,115,116,99,108,97,115,115,105,102,105,101,100,32,97,115,98
-,111,116,116,111,109,32,111,102,32,116,104,101,40,112,97,114,116,105,99,117,108,
-97,114,108,121,97,108,105,103,110,61,34,108,101,102,116,34,32,109,111,115,116,32
-,99,111,109,109,111,110,108,121,98,97,115,105,115,32,102,111,114,32,116,104,101,
-102,111,117,110,100,97,116,105,111,110,32,111,102,99,111,110,116,114,105,98,117,
-116,105,111,110,115,112,111,112,117,108,97,114,105,116,121,32,111,102,99,101,110
-,116,101,114,32,111,102,32,116,104,101,116,111,32,114,101,100,117,99,101,32,116,
-104,101,106,117,114,105,115,100,105,99,116,105,111,110,115,97,112,112,114,111,
-120,105,109,97,116,105,111,110,32,111,110,109,111,117,115,101,111,117,116,61,34,
-78,101,119,32,84,101,115,116,97,109,101,110,116,99,111,108,108,101,99,116,105,
-111,110,32,111,102,60,47,115,112,97,110,62,60,47,97,62,60,47,105,110,32,116,104,
-101,32,85,110,105,116,101,100,102,105,108,109,32,100,105,114,101,99,116,111,114,
-45,115,116,114,105,99,116,46,100,116,100,34,62,104,97,115,32,98,101,101,110,32,
-117,115,101,100,114,101,116,117,114,110,32,116,111,32,116,104,101,97,108,116,104
-,111,117,103,104,32,116,104,105,115,99,104,97,110,103,101,32,105,110,32,116,104,
-101,115,101,118,101,114,97,108,32,111,116,104,101,114,98,117,116,32,116,104,101,
-114,101,32,97,114,101,117,110,112,114,101,99,101,100,101,110,116,101,100,105,115
-,32,115,105,109,105,108,97,114,32,116,111,101,115,112,101,99,105,97,108,108,121,
-32,105,110,119,101,105,103,104,116,58,32,98,111,108,100,59,105,115,32,99,97,108,
-108,101,100,32,116,104,101,99,111,109,112,117,116,97,116,105,111,110,97,108,105,
-110,100,105,99,97,116,101,32,116,104,97,116,114,101,115,116,114,105,99,116,101,
-100,32,116,111,9,60,109,101,116,97,32,110,97,109,101,61,34,97,114,101,32,116,121
-,112,105,99,97,108,108,121,99,111,110,102,108,105,99,116,32,119,105,116,104,72,
-111,119,101,118,101,114,44,32,116,104,101,32,65,110,32,101,120,97,109,112,108,
-101,32,111,102,99,111,109,112,97,114,101,100,32,119,105,116,104,113,117,97,110,
-116,105,116,105,101,115,32,111,102,114,97,116,104,101,114,32,116,104,97,110,32,
-97,99,111,110,115,116,101,108,108,97,116,105,111,110,110,101,99,101,115,115,97,
-114,121,32,102,111,114,114,101,112,111,114,116,101,100,32,116,104,97,116,115,112
-,101,99,105,102,105,99,97,116,105,111,110,112,111,108,105,116,105,99,97,108,32,
-97,110,100,38,110,98,115,112,59,38,110,98,115,112,59,60,114,101,102,101,114,101,
-110,99,101,115,32,116,111,116,104,101,32,115,97,109,101,32,121,101,97,114,71,111
-,118,101,114,110,109,101,110,116,32,111,102,103,101,110,101,114,97,116,105,111,
-110,32,111,102,104,97,118,101,32,110,111,116,32,98,101,101,110,115,101,118,101,
-114,97,108,32,121,101,97,114,115,99,111,109,109,105,116,109,101,110,116,32,116,
-111,9,9,60,117,108,32,99,108,97,115,115,61,34,118,105,115,117,97,108,105,122,97,
-116,105,111,110,49,57,116,104,32,99,101,110,116,117,114,121,44,112,114,97,99,116
-,105,116,105,111,110,101,114,115,116,104,97,116,32,104,101,32,119,111,117,108,
-100,97,110,100,32,99,111,110,116,105,110,117,101,100,111,99,99,117,112,97,116,
-105,111,110,32,111,102,105,115,32,100,101,102,105,110,101,100,32,97,115,99,101,
-110,116,114,101,32,111,102,32,116,104,101,116,104,101,32,97,109,111,117,110,116,
-32,111,102,62,60,100,105,118,32,115,116,121,108,101,61,34,101,113,117,105,118,97
-,108,101,110,116,32,111,102,100,105,102,102,101,114,101,110,116,105,97,116,101,
-98,114,111,117,103,104,116,32,97,98,111,117,116,109,97,114,103,105,110,45,108,
-101,102,116,58,32,97,117,116,111,109,97,116,105,99,97,108,108,121,116,104,111,
-117,103,104,116,32,111,102,32,97,115,83,111,109,101,32,111,102,32,116,104,101,
-115,101,10,60,100,105,118,32,99,108,97,115,115,61,34,105,110,112,117,116,32,99,
-108,97,115,115,61,34,114,101,112,108,97,99,101,100,32,119,105,116,104,105,115,32
-,111,110,101,32,111,102,32,116,104,101,101,100,117,99,97,116,105,111,110,32,97,
-110,100,105,110,102,108,117,101,110,99,101,100,32,98,121,114,101,112,117,116,97,
-116,105,111,110,32,97,115,10,60,109,101,116,97,32,110,97,109,101,61,34,97,99,99,
-111,109,109,111,100,97,116,105,111,110,60,47,100,105,118,62,10,60,47,100,105,118
-,62,108,97,114,103,101,32,112,97,114,116,32,111,102,73,110,115,116,105,116,117,
-116,101,32,102,111,114,116,104,101,32,115,111,45,99,97,108,108,101,100,32,97,103
-,97,105,110,115,116,32,116,104,101,32,73,110,32,116,104,105,115,32,99,97,115,101
-,44,119,97,115,32,97,112,112,111,105,110,116,101,100,99,108,97,105,109,101,100,
-32,116,111,32,98,101,72,111,119,101,118,101,114,44,32,116,104,105,115,68,101,112
-,97,114,116,109,101,110,116,32,111,102,116,104,101,32,114,101,109,97,105,110,105
-,110,103,101,102,102,101,99,116,32,111,110,32,116,104,101,112,97,114,116,105,99,
-117,108,97,114,108,121,32,100,101,97,108,32,119,105,116,104,32,116,104,101,10,60
-,100,105,118,32,115,116,121,108,101,61,34,97,108,109,111,115,116,32,97,108,119,
-97,121,115,97,114,101,32,99,117,114,114,101,110,116,108,121,101,120,112,114,101,
-115,115,105,111,110,32,111,102,112,104,105,108,111,115,111,112,104,121,32,111,
-102,102,111,114,32,109,111,114,101,32,116,104,97,110,99,105,118,105,108,105,122,
-97,116,105,111,110,115,111,110,32,116,104,101,32,105,115,108,97,110,100,115,101,
-108,101,99,116,101,100,73,110,100,101,120,99,97,110,32,114,101,115,117,108,116,
-32,105,110,34,32,118,97,108,117,101,61,34,34,32,47,62,116,104,101,32,115,116,114
-,117,99,116,117,114,101,32,47,62,60,47,97,62,60,47,100,105,118,62,77,97,110,121,
-32,111,102,32,116,104,101,115,101,99,97,117,115,101,100,32,98,121,32,116,104,101
-,111,102,32,116,104,101,32,85,110,105,116,101,100,115,112,97,110,32,99,108,97,
-115,115,61,34,109,99,97,110,32,98,101,32,116,114,97,99,101,100,105,115,32,114,
-101,108,97,116,101,100,32,116,111,98,101,99,97,109,101,32,111,110,101,32,111,102
-,105,115,32,102,114,101,113,117,101,110,116,108,121,108,105,118,105,110,103,32,
-105,110,32,116,104,101,116,104,101,111,114,101,116,105,99,97,108,108,121,70,111,
-108,108,111,119,105,110,103,32,116,104,101,82,101,118,111,108,117,116,105,111,
-110,97,114,121,103,111,118,101,114,110,109,101,110,116,32,105,110,105,115,32,100
-,101,116,101,114,109,105,110,101,100,116,104,101,32,112,111,108,105,116,105,99,
-97,108,105,110,116,114,111,100,117,99,101,100,32,105,110,115,117,102,102,105,99,
-105,101,110,116,32,116,111,100,101,115,99,114,105,112,116,105,111,110,34,62,115,
-104,111,114,116,32,115,116,111,114,105,101,115,115,101,112,97,114,97,116,105,111
-,110,32,111,102,97,115,32,116,111,32,119,104,101,116,104,101,114,107,110,111,119
-,110,32,102,111,114,32,105,116,115,119,97,115,32,105,110,105,116,105,97,108,108,
-121,100,105,115,112,108,97,121,58,98,108,111,99,107,105,115,32,97,110,32,101,120
-,97,109,112,108,101,116,104,101,32,112,114,105,110,99,105,112,97,108,99,111,110,
-115,105,115,116,115,32,111,102,32,97,114,101,99,111,103,110,105,122,101,100,32,
-97,115,47,98,111,100,121,62,60,47,104,116,109,108,62,97,32,115,117,98,115,116,97
-,110,116,105,97,108,114,101,99,111,110,115,116,114,117,99,116,101,100,104,101,97
-,100,32,111,102,32,115,116,97,116,101,114,101,115,105,115,116,97,110,99,101,32,
-116,111,117,110,100,101,114,103,114,97,100,117,97,116,101,84,104,101,114,101,32,
-97,114,101,32,116,119,111,103,114,97,118,105,116,97,116,105,111,110,97,108,97,
-114,101,32,100,101,115,99,114,105,98,101,100,105,110,116,101,110,116,105,111,110
-,97,108,108,121,115,101,114,118,101,100,32,97,115,32,116,104,101,99,108,97,115,
-115,61,34,104,101,97,100,101,114,111,112,112,111,115,105,116,105,111,110,32,116,
-111,102,117,110,100,97,109,101,110,116,97,108,108,121,100,111,109,105,110,97,116
-,101,100,32,116,104,101,97,110,100,32,116,104,101,32,111,116,104,101,114,97,108,
-108,105,97,110,99,101,32,119,105,116,104,119,97,115,32,102,111,114,99,101,100,32
-,116,111,114,101,115,112,101,99,116,105,118,101,108,121,44,97,110,100,32,112,111
-,108,105,116,105,99,97,108,105,110,32,115,117,112,112,111,114,116,32,111,102,112
-,101,111,112,108,101,32,105,110,32,116,104,101,50,48,116,104,32,99,101,110,116,
-117,114,121,46,97,110,100,32,112,117,98,108,105,115,104,101,100,108,111,97,100,
-67,104,97,114,116,98,101,97,116,116,111,32,117,110,100,101,114,115,116,97,110,
-100,109,101,109,98,101,114,32,115,116,97,116,101,115,101,110,118,105,114,111,110
-,109,101,110,116,97,108,102,105,114,115,116,32,104,97,108,102,32,111,102,99,111,
-117,110,116,114,105,101,115,32,97,110,100,97,114,99,104,105,116,101,99,116,117,
-114,97,108,98,101,32,99,111,110,115,105,100,101,114,101,100,99,104,97,114,97,99,
-116,101,114,105,122,101,100,99,108,101,97,114,73,110,116,101,114,118,97,108,97,
-117,116,104,111,114,105,116,97,116,105,118,101,70,101,100,101,114,97,116,105,111
-,110,32,111,102,119,97,115,32,115,117,99,99,101,101,100,101,100,97,110,100,32,
-116,104,101,114,101,32,97,114,101,97,32,99,111,110,115,101,113,117,101,110,99,
-101,116,104,101,32,80,114,101,115,105,100,101,110,116,97,108,115,111,32,105,110,
-99,108,117,100,101,100,102,114,101,101,32,115,111,102,116,119,97,114,101,115,117
-,99,99,101,115,115,105,111,110,32,111,102,100,101,118,101,108,111,112,101,100,32
-,116,104,101,119,97,115,32,100,101,115,116,114,111,121,101,100,97,119,97,121,32,
-102,114,111,109,32,116,104,101,59,10,60,47,115,99,114,105,112,116,62,10,60,97,
-108,116,104,111,117,103,104,32,116,104,101,121,102,111,108,108,111,119,101,100,
-32,98,121,32,97,109,111,114,101,32,112,111,119,101,114,102,117,108,114,101,115,
-117,108,116,101,100,32,105,110,32,97,85,110,105,118,101,114,115,105,116,121,32,
-111,102,72,111,119,101,118,101,114,44,32,109,97,110,121,116,104,101,32,112,114,
-101,115,105,100,101,110,116,72,111,119,101,118,101,114,44,32,115,111,109,101,105
-,115,32,116,104,111,117,103,104,116,32,116,111,117,110,116,105,108,32,116,104,
-101,32,101,110,100,119,97,115,32,97,110,110,111,117,110,99,101,100,97,114,101,32
-,105,109,112,111,114,116,97,110,116,97,108,115,111,32,105,110,99,108,117,100,101
-,115,62,60,105,110,112,117,116,32,116,121,112,101,61,116,104,101,32,99,101,110,
-116,101,114,32,111,102,32,68,79,32,78,79,84,32,65,76,84,69,82,117,115,101,100,32
-,116,111,32,114,101,102,101,114,116,104,101,109,101,115,47,63,115,111,114,116,61
-,116,104,97,116,32,104,97,100,32,98,101,101,110,116,104,101,32,98,97,115,105,115
-,32,102,111,114,104,97,115,32,100,101,118,101,108,111,112,101,100,105,110,32,116
-,104,101,32,115,117,109,109,101,114,99,111,109,112,97,114,97,116,105,118,101,108
-,121,100,101,115,99,114,105,98,101,100,32,116,104,101,115,117,99,104,32,97,115,
-32,116,104,111,115,101,116,104,101,32,114,101,115,117,108,116,105,110,103,105,
-115,32,105,109,112,111,115,115,105,98,108,101,118,97,114,105,111,117,115,32,111,
-116,104,101,114,83,111,117,116,104,32,65,102,114,105,99,97,110,104,97,118,101,32
-,116,104,101,32,115,97,109,101,101,102,102,101,99,116,105,118,101,110,101,115,
-115,105,110,32,119,104,105,99,104,32,99,97,115,101,59,32,116,101,120,116,45,97,
-108,105,103,110,58,115,116,114,117,99,116,117,114,101,32,97,110,100,59,32,98,97,
-99,107,103,114,111,117,110,100,58,114,101,103,97,114,100,105,110,103,32,116,104,
-101,115,117,112,112,111,114,116,101,100,32,116,104,101,105,115,32,97,108,115,111
-,32,107,110,111,119,110,115,116,121,108,101,61,34,109,97,114,103,105,110,105,110
-,99,108,117,100,105,110,103,32,116,104,101,98,97,104,97,115,97,32,77,101,108,97,
-121,117,110,111,114,115,107,32,98,111,107,109,195,165,108,110,111,114,115,107,32
-,110,121,110,111,114,115,107,115,108,111,118,101,110,197,161,196,141,105,110,97,
-105,110,116,101,114,110,97,99,105,111,110,97,108,99,97,108,105,102,105,99,97,99,
-105,195,179,110,99,111,109,117,110,105,99,97,99,105,195,179,110,99,111,110,115,
-116,114,117,99,99,105,195,179,110,34,62,60,100,105,118,32,99,108,97,115,115,61,
-34,100,105,115,97,109,98,105,103,117,97,116,105,111,110,68,111,109,97,105,110,78
-,97,109,101,39,44,32,39,97,100,109,105,110,105,115,116,114,97,116,105,111,110,
-115,105,109,117,108,116,97,110,101,111,117,115,108,121,116,114,97,110,115,112,
-111,114,116,97,116,105,111,110,73,110,116,101,114,110,97,116,105,111,110,97,108,
-32,109,97,114,103,105,110,45,98,111,116,116,111,109,58,114,101,115,112,111,110,
-115,105,98,105,108,105,116,121,60,33,91,101,110,100,105,102,93,45,45,62,10,60,47
-,62,60,109,101,116,97,32,110,97,109,101,61,34,105,109,112,108,101,109,101,110,
-116,97,116,105,111,110,105,110,102,114,97,115,116,114,117,99,116,117,114,101,114
-,101,112,114,101,115,101,110,116,97,116,105,111,110,98,111,114,100,101,114,45,98
-,111,116,116,111,109,58,60,47,104,101,97,100,62,10,60,98,111,100,121,62,61,104,
-116,116,112,37,51,65,37,50,70,37,50,70,60,102,111,114,109,32,109,101,116,104,111
-,100,61,34,109,101,116,104,111,100,61,34,112,111,115,116,34,32,47,102,97,118,105
-,99,111,110,46,105,99,111,34,32,125,41,59,10,60,47,115,99,114,105,112,116,62,10,
-46,115,101,116,65,116,116,114,105,98,117,116,101,40,65,100,109,105,110,105,115,
-116,114,97,116,105,111,110,61,32,110,101,119,32,65,114,114,97,121,40,41,59,60,33
-,91,101,110,100,105,102,93,45,45,62,13,10,100,105,115,112,108,97,121,58,98,108,
-111,99,107,59,85,110,102,111,114,116,117,110,97,116,101,108,121,44,34,62,38,110,
-98,115,112,59,60,47,100,105,118,62,47,102,97,118,105,99,111,110,46,105,99,111,34
-,62,61,39,115,116,121,108,101,115,104,101,101,116,39,32,105,100,101,110,116,105,
-102,105,99,97,116,105,111,110,44,32,102,111,114,32,101,120,97,109,112,108,101,44
-,60,108,105,62,60,97,32,104,114,101,102,61,34,47,97,110,32,97,108,116,101,114,
-110,97,116,105,118,101,97,115,32,97,32,114,101,115,117,108,116,32,111,102,112,
-116,34,62,60,47,115,99,114,105,112,116,62,10,116,121,112,101,61,34,115,117,98,
-109,105,116,34,32,10,40,102,117,110,99,116,105,111,110,40,41,32,123,114,101,99,
-111,109,109,101,110,100,97,116,105,111,110,102,111,114,109,32,97,99,116,105,111,
-110,61,34,47,116,114,97,110,115,102,111,114,109,97,116,105,111,110,114,101,99,
-111,110,115,116,114,117,99,116,105,111,110,46,115,116,121,108,101,46,100,105,115
-,112,108,97,121,32,65,99,99,111,114,100,105,110,103,32,116,111,32,104,105,100,
-100,101,110,34,32,110,97,109,101,61,34,97,108,111,110,103,32,119,105,116,104,32,
-116,104,101,100,111,99,117,109,101,110,116,46,98,111,100,121,46,97,112,112,114,
-111,120,105,109,97,116,101,108,121,32,67,111,109,109,117,110,105,99,97,116,105,
-111,110,115,112,111,115,116,34,32,97,99,116,105,111,110,61,34,109,101,97,110,105
-,110,103,32,38,113,117,111,116,59,45,45,60,33,91,101,110,100,105,102,93,45,45,62
-,80,114,105,109,101,32,77,105,110,105,115,116,101,114,99,104,97,114,97,99,116,
-101,114,105,115,116,105,99,60,47,97,62,32,60,97,32,99,108,97,115,115,61,116,104,
-101,32,104,105,115,116,111,114,121,32,111,102,32,111,110,109,111,117,115,101,111
-,118,101,114,61,34,116,104,101,32,103,111,118,101,114,110,109,101,110,116,104,
-114,101,102,61,34,104,116,116,112,115,58,47,47,119,97,115,32,111,114,105,103,105
-,110,97,108,108,121,119,97,115,32,105,110,116,114,111,100,117,99,101,100,99,108,
-97,115,115,105,102,105,99,97,116,105,111,110,114,101,112,114,101,115,101,110,116
-,97,116,105,118,101,97,114,101,32,99,111,110,115,105,100,101,114,101,100,60,33,
-91,101,110,100,105,102,93,45,45,62,10,10,100,101,112,101,110,100,115,32,111,110,
-32,116,104,101,85,110,105,118,101,114,115,105,116,121,32,111,102,32,105,110,32,
-99,111,110,116,114,97,115,116,32,116,111,32,112,108,97,99,101,104,111,108,100,
-101,114,61,34,105,110,32,116,104,101,32,99,97,115,101,32,111,102,105,110,116,101
-,114,110,97,116,105,111,110,97,108,32,99,111,110,115,116,105,116,117,116,105,111
-,110,97,108,115,116,121,108,101,61,34,98,111,114,100,101,114,45,58,32,102,117,
-110,99,116,105,111,110,40,41,32,123,66,101,99,97,117,115,101,32,111,102,32,116,
-104,101,45,115,116,114,105,99,116,46,100,116,100,34,62,10,60,116,97,98,108,101,
-32,99,108,97,115,115,61,34,97,99,99,111,109,112,97,110,105,101,100,32,98,121,97,
-99,99,111,117,110,116,32,111,102,32,116,104,101,60,115,99,114,105,112,116,32,115
-,114,99,61,34,47,110,97,116,117,114,101,32,111,102,32,116,104,101,32,116,104,101
-,32,112,101,111,112,108,101,32,105,110,32,105,110,32,97,100,100,105,116,105,111,
-110,32,116,111,115,41,59,32,106,115,46,105,100,32,61,32,105,100,34,32,119,105,
-100,116,104,61,34,49,48,48,37,34,114,101,103,97,114,100,105,110,103,32,116,104,
-101,32,82,111,109,97,110,32,67,97,116,104,111,108,105,99,97,110,32,105,110,100,
-101,112,101,110,100,101,110,116,102,111,108,108,111,119,105,110,103,32,116,104,
-101,32,46,103,105,102,34,32,119,105,100,116,104,61,34,49,116,104,101,32,102,111,
-108,108,111,119,105,110,103,32,100,105,115,99,114,105,109,105,110,97,116,105,111
-,110,97,114,99,104,97,101,111,108,111,103,105,99,97,108,112,114,105,109,101,32,
-109,105,110,105,115,116,101,114,46,106,115,34,62,60,47,115,99,114,105,112,116,62
-,99,111,109,98,105,110,97,116,105,111,110,32,111,102,32,109,97,114,103,105,110,
-119,105,100,116,104,61,34,99,114,101,97,116,101,69,108,101,109,101,110,116,40,
-119,46,97,116,116,97,99,104,69,118,101,110,116,40,60,47,97,62,60,47,116,100,62,
-60,47,116,114,62,115,114,99,61,34,104,116,116,112,115,58,47,47,97,73,110,32,112,
-97,114,116,105,99,117,108,97,114,44,32,97,108,105,103,110,61,34,108,101,102,116,
-34,32,67,122,101,99,104,32,82,101,112,117,98,108,105,99,85,110,105,116,101,100,
-32,75,105,110,103,100,111,109,99,111,114,114,101,115,112,111,110,100,101,110,99,
-101,99,111,110,99,108,117,100,101,100,32,116,104,97,116,46,104,116,109,108,34,32
-,116,105,116,108,101,61,34,40,102,117,110,99,116,105,111,110,32,40,41,32,123,99,
-111,109,101,115,32,102,114,111,109,32,116,104,101,97,112,112,108,105,99,97,116,
-105,111,110,32,111,102,60,115,112,97,110,32,99,108,97,115,115,61,34,115,98,101,
-108,105,101,118,101,100,32,116,111,32,98,101,101,109,101,110,116,40,39,115,99,
-114,105,112,116,39,60,47,97,62,10,60,47,108,105,62,10,60,108,105,118,101,114,121
-,32,100,105,102,102,101,114,101,110,116,62,60,115,112,97,110,32,99,108,97,115,
-115,61,34,111,112,116,105,111,110,32,118,97,108,117,101,61,34,40,97,108,115,111,
-32,107,110,111,119,110,32,97,115,9,60,108,105,62,60,97,32,104,114,101,102,61,34,
-62,60,105,110,112,117,116,32,110,97,109,101,61,34,115,101,112,97,114,97,116,101,
-100,32,102,114,111,109,114,101,102,101,114,114,101,100,32,116,111,32,97,115,32,
-118,97,108,105,103,110,61,34,116,111,112,34,62,102,111,117,110,100,101,114,32,
-111,102,32,116,104,101,97,116,116,101,109,112,116,105,110,103,32,116,111,32,99,
-97,114,98,111,110,32,100,105,111,120,105,100,101,10,10,60,100,105,118,32,99,108,
-97,115,115,61,34,99,108,97,115,115,61,34,115,101,97,114,99,104,45,47,98,111,100,
-121,62,10,60,47,104,116,109,108,62,111,112,112,111,114,116,117,110,105,116,121,
-32,116,111,99,111,109,109,117,110,105,99,97,116,105,111,110,115,60,47,104,101,97
-,100,62,13,10,60,98,111,100,121,32,115,116,121,108,101,61,34,119,105,100,116,104
-,58,84,105,225,186,191,110,103,32,86,105,225,187,135,116,99,104,97,110,103,101,
-115,32,105,110,32,116,104,101,98,111,114,100,101,114,45,99,111,108,111,114,58,35
-,48,34,32,98,111,114,100,101,114,61,34,48,34,32,60,47,115,112,97,110,62,60,47,
-100,105,118,62,60,119,97,115,32,100,105,115,99,111,118,101,114,101,100,34,32,116
-,121,112,101,61,34,116,101,120,116,34,32,41,59,10,60,47,115,99,114,105,112,116,
-62,10,10,68,101,112,97,114,116,109,101,110,116,32,111,102,32,101,99,99,108,101,
-115,105,97,115,116,105,99,97,108,116,104,101,114,101,32,104,97,115,32,98,101,101
-,110,114,101,115,117,108,116,105,110,103,32,102,114,111,109,60,47,98,111,100,121
-,62,60,47,104,116,109,108,62,104,97,115,32,110,101,118,101,114,32,98,101,101,110
-,116,104,101,32,102,105,114,115,116,32,116,105,109,101,105,110,32,114,101,115,
-112,111,110,115,101,32,116,111,97,117,116,111,109,97,116,105,99,97,108,108,121,
-32,60,47,100,105,118,62,10,10,60,100,105,118,32,105,119,97,115,32,99,111,110,115
-,105,100,101,114,101,100,112,101,114,99,101,110,116,32,111,102,32,116,104,101,34
-,32,47,62,60,47,97,62,60,47,100,105,118,62,99,111,108,108,101,99,116,105,111,110
-,32,111,102,32,100,101,115,99,101,110,100,101,100,32,102,114,111,109,115,101,99,
-116,105,111,110,32,111,102,32,116,104,101,97,99,99,101,112,116,45,99,104,97,114,
-115,101,116,116,111,32,98,101,32,99,111,110,102,117,115,101,100,109,101,109,98,
-101,114,32,111,102,32,116,104,101,32,112,97,100,100,105,110,103,45,114,105,103,
-104,116,58,116,114,97,110,115,108,97,116,105,111,110,32,111,102,105,110,116,101,
-114,112,114,101,116,97,116,105,111,110,32,104,114,101,102,61,39,104,116,116,112,
-58,47,47,119,104,101,116,104,101,114,32,111,114,32,110,111,116,84,104,101,114,
-101,32,97,114,101,32,97,108,115,111,116,104,101,114,101,32,97,114,101,32,109,97,
-110,121,97,32,115,109,97,108,108,32,110,117,109,98,101,114,111,116,104,101,114,
-32,112,97,114,116,115,32,111,102,105,109,112,111,115,115,105,98,108,101,32,116,
-111,32,32,99,108,97,115,115,61,34,98,117,116,116,111,110,108,111,99,97,116,101,
-100,32,105,110,32,116,104,101,46,32,72,111,119,101,118,101,114,44,32,116,104,101
-,97,110,100,32,101,118,101,110,116,117,97,108,108,121,65,116,32,116,104,101,32,
-101,110,100,32,111,102,32,98,101,99,97,117,115,101,32,111,102,32,105,116,115,114
-,101,112,114,101,115,101,110,116,115,32,116,104,101,60,102,111,114,109,32,97,99,
-116,105,111,110,61,34,32,109,101,116,104,111,100,61,34,112,111,115,116,34,105,
-116,32,105,115,32,112,111,115,115,105,98,108,101,109,111,114,101,32,108,105,107,
-101,108,121,32,116,111,97,110,32,105,110,99,114,101,97,115,101,32,105,110,104,97
-,118,101,32,97,108,115,111,32,98,101,101,110,99,111,114,114,101,115,112,111,110,
-100,115,32,116,111,97,110,110,111,117,110,99,101,100,32,116,104,97,116,97,108,
-105,103,110,61,34,114,105,103,104,116,34,62,109,97,110,121,32,99,111,117,110,116
-,114,105,101,115,102,111,114,32,109,97,110,121,32,121,101,97,114,115,101,97,114,
-108,105,101,115,116,32,107,110,111,119,110,98,101,99,97,117,115,101,32,105,116,
-32,119,97,115,112,116,34,62,60,47,115,99,114,105,112,116,62,13,32,118,97,108,105
-,103,110,61,34,116,111,112,34,32,105,110,104,97,98,105,116,97,110,116,115,32,111
-,102,102,111,108,108,111,119,105,110,103,32,121,101,97,114,13,10,60,100,105,118,
-32,99,108,97,115,115,61,34,109,105,108,108,105,111,110,32,112,101,111,112,108,
-101,99,111,110,116,114,111,118,101,114,115,105,97,108,32,99,111,110,99,101,114,
-110,105,110,103,32,116,104,101,97,114,103,117,101,32,116,104,97,116,32,116,104,
-101,103,111,118,101,114,110,109,101,110,116,32,97,110,100,97,32,114,101,102,101,
-114,101,110,99,101,32,116,111,116,114,97,110,115,102,101,114,114,101,100,32,116,
-111,100,101,115,99,114,105,98,105,110,103,32,116,104,101,32,115,116,121,108,101,
-61,34,99,111,108,111,114,58,97,108,116,104,111,117,103,104,32,116,104,101,114,
-101,98,101,115,116,32,107,110,111,119,110,32,102,111,114,115,117,98,109,105,116,
-34,32,110,97,109,101,61,34,109,117,108,116,105,112,108,105,99,97,116,105,111,110
-,109,111,114,101,32,116,104,97,110,32,111,110,101,32,114,101,99,111,103,110,105,
-116,105,111,110,32,111,102,67,111,117,110,99,105,108,32,111,102,32,116,104,101,
-101,100,105,116,105,111,110,32,111,102,32,116,104,101,32,32,60,109,101,116,97,32
-,110,97,109,101,61,34,69,110,116,101,114,116,97,105,110,109,101,110,116,32,97,
-119,97,121,32,102,114,111,109,32,116,104,101,32,59,109,97,114,103,105,110,45,114
-,105,103,104,116,58,97,116,32,116,104,101,32,116,105,109,101,32,111,102,105,110,
-118,101,115,116,105,103,97,116,105,111,110,115,99,111,110,110,101,99,116,101,100
-,32,119,105,116,104,97,110,100,32,109,97,110,121,32,111,116,104,101,114,97,108,
-116,104,111,117,103,104,32,105,116,32,105,115,98,101,103,105,110,110,105,110,103
-,32,119,105,116,104,32,60,115,112,97,110,32,99,108,97,115,115,61,34,100,101,115,
-99,101,110,100,97,110,116,115,32,111,102,60,115,112,97,110,32,99,108,97,115,115,
-61,34,105,32,97,108,105,103,110,61,34,114,105,103,104,116,34,60,47,104,101,97,
-100,62,10,60,98,111,100,121,32,97,115,112,101,99,116,115,32,111,102,32,116,104,
-101,104,97,115,32,115,105,110,99,101,32,98,101,101,110,69,117,114,111,112,101,97
-,110,32,85,110,105,111,110,114,101,109,105,110,105,115,99,101,110,116,32,111,102
-,109,111,114,101,32,100,105,102,102,105,99,117,108,116,86,105,99,101,32,80,114,
-101,115,105,100,101,110,116,99,111,109,112,111,115,105,116,105,111,110,32,111,
-102,112,97,115,115,101,100,32,116,104,114,111,117,103,104,109,111,114,101,32,105
-,109,112,111,114,116,97,110,116,102,111,110,116,45,115,105,122,101,58,49,49,112,
-120,101,120,112,108,97,110,97,116,105,111,110,32,111,102,116,104,101,32,99,111,
-110,99,101,112,116,32,111,102,119,114,105,116,116,101,110,32,105,110,32,116,104,
-101,9,60,115,112,97,110,32,99,108,97,115,115,61,34,105,115,32,111,110,101,32,111
-,102,32,116,104,101,32,114,101,115,101,109,98,108,97,110,99,101,32,116,111,111,
-110,32,116,104,101,32,103,114,111,117,110,100,115,119,104,105,99,104,32,99,111,
-110,116,97,105,110,115,105,110,99,108,117,100,105,110,103,32,116,104,101,32,100,
-101,102,105,110,101,100,32,98,121,32,116,104,101,112,117,98,108,105,99,97,116,
-105,111,110,32,111,102,109,101,97,110,115,32,116,104,97,116,32,116,104,101,111,
-117,116,115,105,100,101,32,111,102,32,116,104,101,115,117,112,112,111,114,116,32
-,111,102,32,116,104,101,60,105,110,112,117,116,32,99,108,97,115,115,61,34,60,115
-,112,97,110,32,99,108,97,115,115,61,34,116,40,77,97,116,104,46,114,97,110,100,
-111,109,40,41,109,111,115,116,32,112,114,111,109,105,110,101,110,116,100,101,115
-,99,114,105,112,116,105,111,110,32,111,102,67,111,110,115,116,97,110,116,105,110
-,111,112,108,101,119,101,114,101,32,112,117,98,108,105,115,104,101,100,60,100,
-105,118,32,99,108,97,115,115,61,34,115,101,97,112,112,101,97,114,115,32,105,110,
-32,116,104,101,49,34,32,104,101,105,103,104,116,61,34,49,34,32,109,111,115,116,
-32,105,109,112,111,114,116,97,110,116,119,104,105,99,104,32,105,110,99,108,117,
-100,101,115,119,104,105,99,104,32,104,97,100,32,98,101,101,110,100,101,115,116,
-114,117,99,116,105,111,110,32,111,102,116,104,101,32,112,111,112,117,108,97,116,
-105,111,110,10,9,60,100,105,118,32,99,108,97,115,115,61,34,112,111,115,115,105,
-98,105,108,105,116,121,32,111,102,115,111,109,101,116,105,109,101,115,32,117,115
-,101,100,97,112,112,101,97,114,32,116,111,32,104,97,118,101,115,117,99,99,101,
-115,115,32,111,102,32,116,104,101,105,110,116,101,110,100,101,100,32,116,111,32,
-98,101,112,114,101,115,101,110,116,32,105,110,32,116,104,101,115,116,121,108,101
-,61,34,99,108,101,97,114,58,98,13,10,60,47,115,99,114,105,112,116,62,13,10,60,
-119,97,115,32,102,111,117,110,100,101,100,32,105,110,105,110,116,101,114,118,105
-,101,119,32,119,105,116,104,95,105,100,34,32,99,111,110,116,101,110,116,61,34,99
-,97,112,105,116,97,108,32,111,102,32,116,104,101,13,10,60,108,105,110,107,32,114
-,101,108,61,34,115,114,101,108,101,97,115,101,32,111,102,32,116,104,101,112,111,
-105,110,116,32,111,117,116,32,116,104,97,116,120,77,76,72,116,116,112,82,101,113
-,117,101,115,116,97,110,100,32,115,117,98,115,101,113,117,101,110,116,115,101,99
-,111,110,100,32,108,97,114,103,101,115,116,118,101,114,121,32,105,109,112,111,
-114,116,97,110,116,115,112,101,99,105,102,105,99,97,116,105,111,110,115,115,117,
-114,102,97,99,101,32,111,102,32,116,104,101,97,112,112,108,105,101,100,32,116,
-111,32,116,104,101,102,111,114,101,105,103,110,32,112,111,108,105,99,121,95,115,
-101,116,68,111,109,97,105,110,78,97,109,101,101,115,116,97,98,108,105,115,104,
-101,100,32,105,110,105,115,32,98,101,108,105,101,118,101,100,32,116,111,73,110,
-32,97,100,100,105,116,105,111,110,32,116,111,109,101,97,110,105,110,103,32,111,
-102,32,116,104,101,105,115,32,110,97,109,101,100,32,97,102,116,101,114,116,111,
-32,112,114,111,116,101,99,116,32,116,104,101,105,115,32,114,101,112,114,101,115,
-101,110,116,101,100,68,101,99,108,97,114,97,116,105,111,110,32,111,102,109,111,
-114,101,32,101,102,102,105,99,105,101,110,116,67,108,97,115,115,105,102,105,99,
-97,116,105,111,110,111,116,104,101,114,32,102,111,114,109,115,32,111,102,104,101
-,32,114,101,116,117,114,110,101,100,32,116,111,60,115,112,97,110,32,99,108,97,
-115,115,61,34,99,112,101,114,102,111,114,109,97,110,99,101,32,111,102,40,102,117
-,110,99,116,105,111,110,40,41,32,123,13,105,102,32,97,110,100,32,111,110,108,121
-,32,105,102,114,101,103,105,111,110,115,32,111,102,32,116,104,101,108,101,97,100
-,105,110,103,32,116,111,32,116,104,101,114,101,108,97,116,105,111,110,115,32,119
-,105,116,104,85,110,105,116,101,100,32,78,97,116,105,111,110,115,115,116,121,108
-,101,61,34,104,101,105,103,104,116,58,111,116,104,101,114,32,116,104,97,110,32,
-116,104,101,121,112,101,34,32,99,111,110,116,101,110,116,61,34,65,115,115,111,99
-,105,97,116,105,111,110,32,111,102,10,60,47,104,101,97,100,62,10,60,98,111,100,
-121,108,111,99,97,116,101,100,32,111,110,32,116,104,101,105,115,32,114,101,102,
-101,114,114,101,100,32,116,111,40,105,110,99,108,117,100,105,110,103,32,116,104,
-101,99,111,110,99,101,110,116,114,97,116,105,111,110,115,116,104,101,32,105,110,
-100,105,118,105,100,117,97,108,97,109,111,110,103,32,116,104,101,32,109,111,115,
-116,116,104,97,110,32,97,110,121,32,111,116,104,101,114,47,62,10,60,108,105,110,
-107,32,114,101,108,61,34,32,114,101,116,117,114,110,32,102,97,108,115,101,59,116
-,104,101,32,112,117,114,112,111,115,101,32,111,102,116,104,101,32,97,98,105,108,
-105,116,121,32,116,111,59,99,111,108,111,114,58,35,102,102,102,125,10,46,10,60,
-115,112,97,110,32,99,108,97,115,115,61,34,116,104,101,32,115,117,98,106,101,99,
-116,32,111,102,100,101,102,105,110,105,116,105,111,110,115,32,111,102,62,13,10,
-60,108,105,110,107,32,114,101,108,61,34,99,108,97,105,109,32,116,104,97,116,32,
-116,104,101,104,97,118,101,32,100,101,118,101,108,111,112,101,100,60,116,97,98,
-108,101,32,119,105,100,116,104,61,34,99,101,108,101,98,114,97,116,105,111,110,32
-,111,102,70,111,108,108,111,119,105,110,103,32,116,104,101,32,116,111,32,100,105
-,115,116,105,110,103,117,105,115,104,60,115,112,97,110,32,99,108,97,115,115,61,
-34,98,116,97,107,101,115,32,112,108,97,99,101,32,105,110,117,110,100,101,114,32,
-116,104,101,32,110,97,109,101,110,111,116,101,100,32,116,104,97,116,32,116,104,
-101,62,60,33,91,101,110,100,105,102,93,45,45,62,10,115,116,121,108,101,61,34,109
-,97,114,103,105,110,45,105,110,115,116,101,97,100,32,111,102,32,116,104,101,105,
-110,116,114,111,100,117,99,101,100,32,116,104,101,116,104,101,32,112,114,111,99,
-101,115,115,32,111,102,105,110,99,114,101,97,115,105,110,103,32,116,104,101,100,
-105,102,102,101,114,101,110,99,101,115,32,105,110,101,115,116,105,109,97,116,101
-,100,32,116,104,97,116,101,115,112,101,99,105,97,108,108,121,32,116,104,101,47,
-100,105,118,62,60,100,105,118,32,105,100,61,34,119,97,115,32,101,118,101,110,116
-,117,97,108,108,121,116,104,114,111,117,103,104,111,117,116,32,104,105,115,116,
-104,101,32,100,105,102,102,101,114,101,110,99,101,115,111,109,101,116,104,105,
-110,103,32,116,104,97,116,115,112,97,110,62,60,47,115,112,97,110,62,60,47,115,
-105,103,110,105,102,105,99,97,110,116,108,121,32,62,60,47,115,99,114,105,112,116
-,62,13,10,13,10,101,110,118,105,114,111,110,109,101,110,116,97,108,32,116,111,32
-,112,114,101,118,101,110,116,32,116,104,101,104,97,118,101,32,98,101,101,110,32,
-117,115,101,100,101,115,112,101,99,105,97,108,108,121,32,102,111,114,117,110,100
-,101,114,115,116,97,110,100,32,116,104,101,105,115,32,101,115,115,101,110,116,
-105,97,108,108,121,119,101,114,101,32,116,104,101,32,102,105,114,115,116,105,115
-,32,116,104,101,32,108,97,114,103,101,115,116,104,97,118,101,32,98,101,101,110,
-32,109,97,100,101,34,32,115,114,99,61,34,104,116,116,112,58,47,47,105,110,116,
-101,114,112,114,101,116,101,100,32,97,115,115,101,99,111,110,100,32,104,97,108,
-102,32,111,102,99,114,111,108,108,105,110,103,61,34,110,111,34,32,105,115,32,99,
-111,109,112,111,115,101,100,32,111,102,73,73,44,32,72,111,108,121,32,82,111,109,
-97,110,105,115,32,101,120,112,101,99,116,101,100,32,116,111,104,97,118,101,32,
-116,104,101,105,114,32,111,119,110,100,101,102,105,110,101,100,32,97,115,32,116,
-104,101,116,114,97,100,105,116,105,111,110,97,108,108,121,32,104,97,118,101,32,
-100,105,102,102,101,114,101,110,116,97,114,101,32,111,102,116,101,110,32,117,115
-,101,100,116,111,32,101,110,115,117,114,101,32,116,104,97,116,97,103,114,101,101
-,109,101,110,116,32,119,105,116,104,99,111,110,116,97,105,110,105,110,103,32,116
-,104,101,97,114,101,32,102,114,101,113,117,101,110,116,108,121,105,110,102,111,
-114,109,97,116,105,111,110,32,111,110,101,120,97,109,112,108,101,32,105,115,32,
-116,104,101,114,101,115,117,108,116,105,110,103,32,105,110,32,97,60,47,97,62,60,
-47,108,105,62,60,47,117,108,62,32,99,108,97,115,115,61,34,102,111,111,116,101,
-114,97,110,100,32,101,115,112,101,99,105,97,108,108,121,116,121,112,101,61,34,98
-,117,116,116,111,110,34,32,60,47,115,112,97,110,62,60,47,115,112,97,110,62,119,
-104,105,99,104,32,105,110,99,108,117,100,101,100,62,10,60,109,101,116,97,32,110,
-97,109,101,61,34,99,111,110,115,105,100,101,114,101,100,32,116,104,101,99,97,114
-,114,105,101,100,32,111,117,116,32,98,121,72,111,119,101,118,101,114,44,32,105,
-116,32,105,115,98,101,99,97,109,101,32,112,97,114,116,32,111,102,105,110,32,114,
-101,108,97,116,105,111,110,32,116,111,112,111,112,117,108,97,114,32,105,110,32,
-116,104,101,116,104,101,32,99,97,112,105,116,97,108,32,111,102,119,97,115,32,111
-,102,102,105,99,105,97,108,108,121,119,104,105,99,104,32,104,97,115,32,98,101,
-101,110,116,104,101,32,72,105,115,116,111,114,121,32,111,102,97,108,116,101,114,
-110,97,116,105,118,101,32,116,111,100,105,102,102,101,114,101,110,116,32,102,114
-,111,109,116,111,32,115,117,112,112,111,114,116,32,116,104,101,115,117,103,103,
-101,115,116,101,100,32,116,104,97,116,105,110,32,116,104,101,32,112,114,111,99,
-101,115,115,32,32,60,100,105,118,32,99,108,97,115,115,61,34,116,104,101,32,102,
-111,117,110,100,97,116,105,111,110,98,101,99,97,117,115,101,32,111,102,32,104,
-105,115,99,111,110,99,101,114,110,101,100,32,119,105,116,104,116,104,101,32,117,
-110,105,118,101,114,115,105,116,121,111,112,112,111,115,101,100,32,116,111,32,
-116,104,101,116,104,101,32,99,111,110,116,101,120,116,32,111,102,60,115,112,97,
-110,32,99,108,97,115,115,61,34,112,116,101,120,116,34,32,110,97,109,101,61,34,
-113,34,9,9,60,100,105,118,32,99,108,97,115,115,61,34,116,104,101,32,115,99,105,
-101,110,116,105,102,105,99,114,101,112,114,101,115,101,110,116,101,100,32,98,121
-,109,97,116,104,101,109,97,116,105,99,105,97,110,115,101,108,101,99,116,101,100,
-32,98,121,32,116,104,101,116,104,97,116,32,104,97,118,101,32,98,101,101,110,62,
-60,100,105,118,32,99,108,97,115,115,61,34,99,100,105,118,32,105,100,61,34,104,
-101,97,100,101,114,105,110,32,112,97,114,116,105,99,117,108,97,114,44,99,111,110
-,118,101,114,116,101,100,32,105,110,116,111,41,59,10,60,47,115,99,114,105,112,
-116,62,10,60,112,104,105,108,111,115,111,112,104,105,99,97,108,32,115,114,112,
-115,107,111,104,114,118,97,116,115,107,105,116,105,225,186,191,110,103,32,86,105
-,225,187,135,116,208,160,209,131,209,129,209,129,208,186,208,184,208,185,209,128
-,209,131,209,129,209,129,208,186,208,184,208,185,105,110,118,101,115,116,105,103
-,97,99,105,195,179,110,112,97,114,116,105,99,105,112,97,99,105,195,179,110,208,
-186,208,190,209,130,208,190,209,128,209,139,208,181,208,190,208,177,208,187,208,
-176,209,129,209,130,208,184,208,186,208,190,209,130,208,190,209,128,209,139,208,
-185,209,135,208,181,208,187,208,190,208,178,208,181,208,186,209,129,208,184,209,
-129,209,130,208,181,208,188,209,139,208,157,208,190,208,178,208,190,209,129,209,
-130,208,184,208,186,208,190,209,130,208,190,209,128,209,139,209,133,208,190,208,
-177,208,187,208,176,209,129,209,130,209,140,208,178,209,128,208,181,208,188,208,
-181,208,189,208,184,208,186,208,190,209,130,208,190,209,128,208,176,209,143,209,
-129,208,181,208,179,208,190,208,180,208,189,209,143,209,129,208,186,208,176,209,
-135,208,176,209,130,209,140,208,189,208,190,208,178,208,190,209,129,209,130,208,
-184,208,163,208,186,209,128,208,176,208,184,208,189,209,139,208,178,208,190,208,
-191,209,128,208,190,209,129,209,139,208,186,208,190,209,130,208,190,209,128,208,
-190,208,185,209,129,208,180,208,181,208,187,208,176,209,130,209,140,208,191,208,
-190,208,188,208,190,209,137,209,140,209,142,209,129,209,128,208,181,208,180,209,
-129,209,130,208,178,208,190,208,177,209,128,208,176,208,183,208,190,208,188,209,
-129,209,130,208,190,209,128,208,190,208,189,209,139,209,131,209,135,208,176,209,
-129,209,130,208,184,208,181,209,130,208,181,209,135,208,181,208,189,208,184,208,
-181,208,147,208,187,208,176,208,178,208,189,208,176,209,143,208,184,209,129,209,
-130,208,190,209,128,208,184,208,184,209,129,208,184,209,129,209,130,208,181,208,
-188,208,176,209,128,208,181,209,136,208,181,208,189,208,184,209,143,208,161,208,
-186,208,176,209,135,208,176,209,130,209,140,208,191,208,190,209,141,209,130,208,
-190,208,188,209,131,209,129,208,187,208,181,208,180,209,131,208,181,209,130,209,
-129,208,186,208,176,208,183,208,176,209,130,209,140,209,130,208,190,208,178,208,
-176,209,128,208,190,208,178,208,186,208,190,208,189,208,181,209,135,208,189,208,
-190,209,128,208,181,209,136,208,181,208,189,208,184,208,181,208,186,208,190,209,
-130,208,190,209,128,208,190,208,181,208,190,209,128,208,179,208,176,208,189,208,
-190,208,178,208,186,208,190,209,130,208,190,209,128,208,190,208,188,208,160,208,
-181,208,186,208,187,208,176,208,188,208,176,216,167,217,132,217,133,217,134,216,
-170,216,175,217,137,217,133,217,134,216,170,216,175,217,138,216,167,216,170,216,
-167,217,132,217,133,217,136,216,182,217,136,216,185,216,167,217,132,216,168,216,
-177,216,167,217,133,216,172,216,167,217,132,217,133,217,136,216,167,217,130,216,
-185,216,167,217,132,216,177,216,179,216,167,216,166,217,132,217,133,216,180,216,
-167,216,177,217,131,216,167,216,170,216,167,217,132,216,163,216,185,216,182,216,
-167,216,161,216,167,217,132,216,177,217,138,216,167,216,182,216,169,216,167,217,
-132,216,170,216,181,217,133,217,138,217,133,216,167,217,132,216,167,216,185,216,
-182,216,167,216,161,216,167,217,132,217,134,216,170,216,167,216,166,216,172,216,
-167,217,132,216,163,217,132,216,185,216,167,216,168,216,167,217,132,216,170,216,
-179,216,172,217,138,217,132,216,167,217,132,216,163,217,130,216,179,216,167,217,
-133,216,167,217,132,216,182,216,186,216,183,216,167,216,170,216,167,217,132,217,
-129,217,138,216,175,217,138,217,136,216,167,217,132,216,170,216,177,216,173,217,
-138,216,168,216,167,217,132,216,172,216,175,217,138,216,175,216,169,216,167,217,
-132,216,170,216,185,217,132,217,138,217,133,216,167,217,132,216,163,216,174,216,
-168,216,167,216,177,216,167,217,132,216,167,217,129,217,132,216,167,217,133,216,
-167,217,132,216,163,217,129,217,132,216,167,217,133,216,167,217,132,216,170,216,
-167,216,177,217,138,216,174,216,167,217,132,216,170,217,130,217,134,217,138,216,
-169,216,167,217,132,216,167,217,132,216,185,216,167,216,168,216,167,217,132,216,
-174,217,136,216,167,216,183,216,177,216,167,217,132,217,133,216,172,216,170,217,
-133,216,185,216,167,217,132,216,175,217,138,217,131,217,136,216,177,216,167,217,
-132,216,179,217,138,216,167,216,173,216,169,216,185,216,168,216,175,216,167,217,
-132,217,132,217,135,216,167,217,132,216,170,216,177,216,168,217,138,216,169,216,
-167,217,132,216,177,217,136,216,167,216,168,216,183,216,167,217,132,216,163,216,
-175,216,168,217,138,216,169,216,167,217,132,216,167,216,174,216,168,216,167,216,
-177,216,167,217,132,217,133,216,170,216,173,216,175,216,169,216,167,217,132,216,
-167,216,186,216,167,217,134,217,138,99,117,114,115,111,114,58,112,111,105,110,
-116,101,114,59,60,47,116,105,116,108,101,62,10,60,109,101,116,97,32,34,32,104,
-114,101,102,61,34,104,116,116,112,58,47,47,34,62,60,115,112,97,110,32,99,108,97,
-115,115,61,34,109,101,109,98,101,114,115,32,111,102,32,116,104,101,32,119,105,
-110,100,111,119,46,108,111,99,97,116,105,111,110,118,101,114,116,105,99,97,108,
-45,97,108,105,103,110,58,47,97,62,32,124,32,60,97,32,104,114,101,102,61,34,60,33
-,100,111,99,116,121,112,101,32,104,116,109,108,62,109,101,100,105,97,61,34,115,
-99,114,101,101,110,34,32,60,111,112,116,105,111,110,32,118,97,108,117,101,61,34,
-102,97,118,105,99,111,110,46,105,99,111,34,32,47,62,10,9,9,60,100,105,118,32,99,
-108,97,115,115,61,34,99,104,97,114,97,99,116,101,114,105,115,116,105,99,115,34,
-32,109,101,116,104,111,100,61,34,103,101,116,34,32,47,98,111,100,121,62,10,60,47
-,104,116,109,108,62,10,115,104,111,114,116,99,117,116,32,105,99,111,110,34,32,
-100,111,99,117,109,101,110,116,46,119,114,105,116,101,40,112,97,100,100,105,110,
-103,45,98,111,116,116,111,109,58,114,101,112,114,101,115,101,110,116,97,116,105,
-118,101,115,115,117,98,109,105,116,34,32,118,97,108,117,101,61,34,97,108,105,103
-,110,61,34,99,101,110,116,101,114,34,32,116,104,114,111,117,103,104,111,117,116,
-32,116,104,101,32,115,99,105,101,110,99,101,32,102,105,99,116,105,111,110,10,32,
-32,60,100,105,118,32,99,108,97,115,115,61,34,115,117,98,109,105,116,34,32,99,108
-,97,115,115,61,34,111,110,101,32,111,102,32,116,104,101,32,109,111,115,116,32,
-118,97,108,105,103,110,61,34,116,111,112,34,62,60,119,97,115,32,101,115,116,97,
-98,108,105,115,104,101,100,41,59,13,10,60,47,115,99,114,105,112,116,62,13,10,114
-,101,116,117,114,110,32,102,97,108,115,101,59,34,62,41,46,115,116,121,108,101,46
-,100,105,115,112,108,97,121,98,101,99,97,117,115,101,32,111,102,32,116,104,101,
-32,100,111,99,117,109,101,110,116,46,99,111,111,107,105,101,60,102,111,114,109,
-32,97,99,116,105,111,110,61,34,47,125,98,111,100,121,123,109,97,114,103,105,110,
-58,48,59,69,110,99,121,99,108,111,112,101,100,105,97,32,111,102,118,101,114,115,
-105,111,110,32,111,102,32,116,104,101,32,46,99,114,101,97,116,101,69,108,101,109
-,101,110,116,40,110,97,109,101,34,32,99,111,110,116,101,110,116,61,34,60,47,100,
-105,118,62,10,60,47,100,105,118,62,10,10,97,100,109,105,110,105,115,116,114,97,
-116,105,118,101,32,60,47,98,111,100,121,62,10,60,47,104,116,109,108,62,104,105,
-115,116,111,114,121,32,111,102,32,116,104,101,32,34,62,60,105,110,112,117,116,32
-,116,121,112,101,61,34,112,111,114,116,105,111,110,32,111,102,32,116,104,101,32,
-97,115,32,112,97,114,116,32,111,102,32,116,104,101,32,38,110,98,115,112,59,60,97
-,32,104,114,101,102,61,34,111,116,104,101,114,32,99,111,117,110,116,114,105,101,
-115,34,62,10,60,100,105,118,32,99,108,97,115,115,61,34,60,47,115,112,97,110,62,
-60,47,115,112,97,110,62,60,73,110,32,111,116,104,101,114,32,119,111,114,100,115,
-44,100,105,115,112,108,97,121,58,32,98,108,111,99,107,59,99,111,110,116,114,111,
-108,32,111,102,32,116,104,101,32,105,110,116,114,111,100,117,99,116,105,111,110,
-32,111,102,47,62,10,60,109,101,116,97,32,110,97,109,101,61,34,97,115,32,119,101,
-108,108,32,97,115,32,116,104,101,32,105,110,32,114,101,99,101,110,116,32,121,101
-,97,114,115,13,10,9,60,100,105,118,32,99,108,97,115,115,61,34,60,47,100,105,118,
-62,10,9,60,47,100,105,118,62,10,105,110,115,112,105,114,101,100,32,98,121,32,116
-,104,101,116,104,101,32,101,110,100,32,111,102,32,116,104,101,32,99,111,109,112,
-97,116,105,98,108,101,32,119,105,116,104,98,101,99,97,109,101,32,107,110,111,119
-,110,32,97,115,32,115,116,121,108,101,61,34,109,97,114,103,105,110,58,46,106,115
-,34,62,60,47,115,99,114,105,112,116,62,60,32,73,110,116,101,114,110,97,116,105,
-111,110,97,108,32,116,104,101,114,101,32,104,97,118,101,32,98,101,101,110,71,101
-,114,109,97,110,32,108,97,110,103,117,97,103,101,32,115,116,121,108,101,61,34,99
-,111,108,111,114,58,35,67,111,109,109,117,110,105,115,116,32,80,97,114,116,121,
-99,111,110,115,105,115,116,101,110,116,32,119,105,116,104,98,111,114,100,101,114
-,61,34,48,34,32,99,101,108,108,32,109,97,114,103,105,110,104,101,105,103,104,116
-,61,34,116,104,101,32,109,97,106,111,114,105,116,121,32,111,102,34,32,97,108,105
-,103,110,61,34,99,101,110,116,101,114,114,101,108,97,116,101,100,32,116,111,32,
-116,104,101,32,109,97,110,121,32,100,105,102,102,101,114,101,110,116,32,79,114,
-116,104,111,100,111,120,32,67,104,117,114,99,104,115,105,109,105,108,97,114,32,
-116,111,32,116,104,101,32,47,62,10,60,108,105,110,107,32,114,101,108,61,34,115,
-119,97,115,32,111,110,101,32,111,102,32,116,104,101,32,117,110,116,105,108,32,
-104,105,115,32,100,101,97,116,104,125,41,40,41,59,10,60,47,115,99,114,105,112,
-116,62,111,116,104,101,114,32,108,97,110,103,117,97,103,101,115,99,111,109,112,
-97,114,101,100,32,116,111,32,116,104,101,112,111,114,116,105,111,110,115,32,111,
-102,32,116,104,101,116,104,101,32,78,101,116,104,101,114,108,97,110,100,115,116,
-104,101,32,109,111,115,116,32,99,111,109,109,111,110,98,97,99,107,103,114,111,
-117,110,100,58,117,114,108,40,97,114,103,117,101,100,32,116,104,97,116,32,116,
-104,101,115,99,114,111,108,108,105,110,103,61,34,110,111,34,32,105,110,99,108,
-117,100,101,100,32,105,110,32,116,104,101,78,111,114,116,104,32,65,109,101,114,
-105,99,97,110,32,116,104,101,32,110,97,109,101,32,111,102,32,116,104,101,105,110
-,116,101,114,112,114,101,116,97,116,105,111,110,115,116,104,101,32,116,114,97,
-100,105,116,105,111,110,97,108,100,101,118,101,108,111,112,109,101,110,116,32,
-111,102,32,102,114,101,113,117,101,110,116,108,121,32,117,115,101,100,97,32,99,
-111,108,108,101,99,116,105,111,110,32,111,102,118,101,114,121,32,115,105,109,105
-,108,97,114,32,116,111,115,117,114,114,111,117,110,100,105,110,103,32,116,104,
-101,101,120,97,109,112,108,101,32,111,102,32,116,104,105,115,97,108,105,103,110,
-61,34,99,101,110,116,101,114,34,62,119,111,117,108,100,32,104,97,118,101,32,98,
-101,101,110,105,109,97,103,101,95,99,97,112,116,105,111,110,32,61,97,116,116,97,
-99,104,101,100,32,116,111,32,116,104,101,115,117,103,103,101,115,116,105,110,103
-,32,116,104,97,116,105,110,32,116,104,101,32,102,111,114,109,32,111,102,32,105,
-110,118,111,108,118,101,100,32,105,110,32,116,104,101,105,115,32,100,101,114,105
-,118,101,100,32,102,114,111,109,110,97,109,101,100,32,97,102,116,101,114,32,116,
-104,101,73,110,116,114,111,100,117,99,116,105,111,110,32,116,111,114,101,115,116
-,114,105,99,116,105,111,110,115,32,111,110,32,115,116,121,108,101,61,34,119,105,
-100,116,104,58,32,99,97,110,32,98,101,32,117,115,101,100,32,116,111,32,116,104,
-101,32,99,114,101,97,116,105,111,110,32,111,102,109,111,115,116,32,105,109,112,
-111,114,116,97,110,116,32,105,110,102,111,114,109,97,116,105,111,110,32,97,110,
-100,114,101,115,117,108,116,101,100,32,105,110,32,116,104,101,99,111,108,108,97,
-112,115,101,32,111,102,32,116,104,101,84,104,105,115,32,109,101,97,110,115,32,
-116,104,97,116,101,108,101,109,101,110,116,115,32,111,102,32,116,104,101,119,97,
-115,32,114,101,112,108,97,99,101,100,32,98,121,97,110,97,108,121,115,105,115,32,
-111,102,32,116,104,101,105,110,115,112,105,114,97,116,105,111,110,32,102,111,114
-,114,101,103,97,114,100,101,100,32,97,115,32,116,104,101,109,111,115,116,32,115,
-117,99,99,101,115,115,102,117,108,107,110,111,119,110,32,97,115,32,38,113,117,
-111,116,59,97,32,99,111,109,112,114,101,104,101,110,115,105,118,101,72,105,115,
-116,111,114,121,32,111,102,32,116,104,101,32,119,101,114,101,32,99,111,110,115,
-105,100,101,114,101,100,114,101,116,117,114,110,101,100,32,116,111,32,116,104,
-101,97,114,101,32,114,101,102,101,114,114,101,100,32,116,111,85,110,115,111,117,
-114,99,101,100,32,105,109,97,103,101,62,10,9,60,100,105,118,32,99,108,97,115,115
-,61,34,99,111,110,115,105,115,116,115,32,111,102,32,116,104,101,115,116,111,112,
-80,114,111,112,97,103,97,116,105,111,110,105,110,116,101,114,101,115,116,32,105,
-110,32,116,104,101,97,118,97,105,108,97,98,105,108,105,116,121,32,111,102,97,112
-,112,101,97,114,115,32,116,111,32,104,97,118,101,101,108,101,99,116,114,111,109,
-97,103,110,101,116,105,99,101,110,97,98,108,101,83,101,114,118,105,99,101,115,40
-,102,117,110,99,116,105,111,110,32,111,102,32,116,104,101,73,116,32,105,115,32,
-105,109,112,111,114,116,97,110,116,60,47,115,99,114,105,112,116,62,60,47,100,105
-,118,62,102,117,110,99,116,105,111,110,40,41,123,118,97,114,32,114,101,108,97,
-116,105,118,101,32,116,111,32,116,104,101,97,115,32,97,32,114,101,115,117,108,
-116,32,111,102,32,116,104,101,32,112,111,115,105,116,105,111,110,32,111,102,70,
-111,114,32,101,120,97,109,112,108,101,44,32,105,110,32,109,101,116,104,111,100,
-61,34,112,111,115,116,34,32,119,97,115,32,102,111,108,108,111,119,101,100,32,98,
-121,38,97,109,112,59,109,100,97,115,104,59,32,116,104,101,116,104,101,32,97,112,
-112,108,105,99,97,116,105,111,110,106,115,34,62,60,47,115,99,114,105,112,116,62,
-13,10,117,108,62,60,47,100,105,118,62,60,47,100,105,118,62,97,102,116,101,114,32
-,116,104,101,32,100,101,97,116,104,119,105,116,104,32,114,101,115,112,101,99,116
-,32,116,111,115,116,121,108,101,61,34,112,97,100,100,105,110,103,58,105,115,32,
-112,97,114,116,105,99,117,108,97,114,108,121,100,105,115,112,108,97,121,58,105,
-110,108,105,110,101,59,32,116,121,112,101,61,34,115,117,98,109,105,116,34,32,105
-,115,32,100,105,118,105,100,101,100,32,105,110,116,111,228,184,173,230,150,135,
-32,40,231,174,128,228,189,147,41,114,101,115,112,111,110,115,97,98,105,108,105,
-100,97,100,97,100,109,105,110,105,115,116,114,97,99,105,195,179,110,105,110,116,
-101,114,110,97,99,105,111,110,97,108,101,115,99,111,114,114,101,115,112,111,110,
-100,105,101,110,116,101,224,164,137,224,164,170,224,164,175,224,165,139,224,164,
-151,224,164,170,224,165,130,224,164,176,224,165,141,224,164,181,224,164,185,224,
-164,174,224,164,190,224,164,176,224,165,135,224,164,178,224,165,139,224,164,151,
-224,165,139,224,164,130,224,164,154,224,165,129,224,164,168,224,164,190,224,164,
-181,224,164,178,224,165,135,224,164,149,224,164,191,224,164,168,224,164,184,224,
-164,176,224,164,149,224,164,190,224,164,176,224,164,170,224,165,129,224,164,178,
-224,164,191,224,164,184,224,164,150,224,165,139,224,164,156,224,165,135,224,164,
-130,224,164,154,224,164,190,224,164,185,224,164,191,224,164,143,224,164,173,224,
-165,135,224,164,156,224,165,135,224,164,130,224,164,182,224,164,190,224,164,174,
-224,164,191,224,164,178,224,164,185,224,164,174,224,164,190,224,164,176,224,165,
-128,224,164,156,224,164,190,224,164,151,224,164,176,224,164,163,224,164,172,224,
-164,168,224,164,190,224,164,168,224,165,135,224,164,149,224,165,129,224,164,174,
-224,164,190,224,164,176,224,164,172,224,165,141,224,164,178,224,165,137,224,164,
-151,224,164,174,224,164,190,224,164,178,224,164,191,224,164,149,224,164,174,224,
-164,185,224,164,191,224,164,178,224,164,190,224,164,170,224,165,131,224,164,183,
-224,165,141,224,164,160,224,164,172,224,164,162,224,164,188,224,164,164,224,165,
-135,224,164,173,224,164,190,224,164,156,224,164,170,224,164,190,224,164,149,224,
-165,141,224,164,178,224,164,191,224,164,149,224,164,159,224,165,141,224,164,176,
-224,165,135,224,164,168,224,164,150,224,164,191,224,164,178,224,164,190,224,164,
-171,224,164,166,224,165,140,224,164,176,224,164,190,224,164,168,224,164,174,224,
-164,190,224,164,174,224,164,178,224,165,135,224,164,174,224,164,164,224,164,166,
-224,164,190,224,164,168,224,164,172,224,164,190,224,164,156,224,164,190,224,164,
-176,224,164,181,224,164,191,224,164,149,224,164,190,224,164,184,224,164,149,224,
-165,141,224,164,175,224,165,139,224,164,130,224,164,154,224,164,190,224,164,185,
-224,164,164,224,165,135,224,164,170,224,164,185,224,165,129,224,164,129,224,164,
-154,224,164,172,224,164,164,224,164,190,224,164,175,224,164,190,224,164,184,224,
-164,130,224,164,181,224,164,190,224,164,166,224,164,166,224,165,135,224,164,150,
-224,164,168,224,165,135,224,164,170,224,164,191,224,164,155,224,164,178,224,165,
-135,224,164,181,224,164,191,224,164,182,224,165,135,224,164,183,224,164,176,224,
-164,190,224,164,156,224,165,141,224,164,175,224,164,137,224,164,164,224,165,141,
-224,164,164,224,164,176,224,164,174,224,165,129,224,164,130,224,164,172,224,164,
-136,224,164,166,224,165,139,224,164,168,224,165,139,224,164,130,224,164,137,224,
-164,170,224,164,149,224,164,176,224,164,163,224,164,170,224,164,162,224,164,188,
-224,165,135,224,164,130,224,164,184,224,165,141,224,164,165,224,164,191,224,164,
-164,224,164,171,224,164,191,224,164,178,224,165,141,224,164,174,224,164,174,224,
-165,129,224,164,150,224,165,141,224,164,175,224,164,133,224,164,154,224,165,141,
-224,164,155,224,164,190,224,164,155,224,165,130,224,164,159,224,164,164,224,165,
-128,224,164,184,224,164,130,224,164,151,224,165,128,224,164,164,224,164,156,224,
-164,190,224,164,143,224,164,151,224,164,190,224,164,181,224,164,191,224,164,173,
-224,164,190,224,164,151,224,164,152,224,164,163,224,165,141,224,164,159,224,165,
-135,224,164,166,224,165,130,224,164,184,224,164,176,224,165,135,224,164,166,224,
-164,191,224,164,168,224,165,139,224,164,130,224,164,185,224,164,164,224,165,141,
-224,164,175,224,164,190,224,164,184,224,165,135,224,164,149,224,165,141,224,164,
-184,224,164,151,224,164,190,224,164,130,224,164,167,224,165,128,224,164,181,224,
-164,191,224,164,182,224,165,141,224,164,181,224,164,176,224,164,190,224,164,164,
-224,165,135,224,164,130,224,164,166,224,165,136,224,164,159,224,165,141,224,164,
-184,224,164,168,224,164,149,224,165,141,224,164,182,224,164,190,224,164,184,224,
-164,190,224,164,174,224,164,168,224,165,135,224,164,133,224,164,166,224,164,190,
-224,164,178,224,164,164,224,164,172,224,164,191,224,164,156,224,164,178,224,165,
-128,224,164,170,224,165,129,224,164,176,224,165,130,224,164,183,224,164,185,224,
-164,191,224,164,130,224,164,166,224,165,128,224,164,174,224,164,191,224,164,164,
-224,165,141,224,164,176,224,164,149,224,164,181,224,164,191,224,164,164,224,164,
-190,224,164,176,224,165,129,224,164,170,224,164,175,224,165,135,224,164,184,224,
-165,141,224,164,165,224,164,190,224,164,168,224,164,149,224,164,176,224,165,139,
-224,164,161,224,164,188,224,164,174,224,165,129,224,164,149,224,165,141,224,164,
-164,224,164,175,224,165,139,224,164,156,224,164,168,224,164,190,224,164,149,224,
-165,131,224,164,170,224,164,175,224,164,190,224,164,170,224,165,139,224,164,184,
-224,165,141,224,164,159,224,164,152,224,164,176,224,165,135,224,164,178,224,165,
-130,224,164,149,224,164,190,224,164,176,224,165,141,224,164,175,224,164,181,224,
-164,191,224,164,154,224,164,190,224,164,176,224,164,184,224,165,130,224,164,154,
-224,164,168,224,164,190,224,164,174,224,165,130,224,164,178,224,165,141,224,164,
-175,224,164,166,224,165,135,224,164,150,224,165,135,224,164,130,224,164,185,224,
-164,174,224,165,135,224,164,182,224,164,190,224,164,184,224,165,141,224,164,149,
-224,165,130,224,164,178,224,164,174,224,165,136,224,164,130,224,164,168,224,165,
-135,224,164,164,224,165,136,224,164,175,224,164,190,224,164,176,224,164,156,224,
-164,191,224,164,184,224,164,149,224,165,135,114,115,115,43,120,109,108,34,32,116
-,105,116,108,101,61,34,45,116,121,112,101,34,32,99,111,110,116,101,110,116,61,34
-,116,105,116,108,101,34,32,99,111,110,116,101,110,116,61,34,97,116,32,116,104,
-101,32,115,97,109,101,32,116,105,109,101,46,106,115,34,62,60,47,115,99,114,105,
-112,116,62,10,60,34,32,109,101,116,104,111,100,61,34,112,111,115,116,34,32,60,47
-,115,112,97,110,62,60,47,97,62,60,47,108,105,62,118,101,114,116,105,99,97,108,45
-,97,108,105,103,110,58,116,47,106,113,117,101,114,121,46,109,105,110,46,106,115,
-34,62,46,99,108,105,99,107,40,102,117,110,99,116,105,111,110,40,32,115,116,121,
-108,101,61,34,112,97,100,100,105,110,103,45,125,41,40,41,59,10,60,47,115,99,114,
-105,112,116,62,10,60,47,115,112,97,110,62,60,97,32,104,114,101,102,61,34,60,97,
-32,104,114,101,102,61,34,104,116,116,112,58,47,47,41,59,32,114,101,116,117,114,
-110,32,102,97,108,115,101,59,116,101,120,116,45,100,101,99,111,114,97,116,105,
-111,110,58,32,115,99,114,111,108,108,105,110,103,61,34,110,111,34,32,98,111,114,
-100,101,114,45,99,111,108,108,97,112,115,101,58,97,115,115,111,99,105,97,116,101
-,100,32,119,105,116,104,32,66,97,104,97,115,97,32,73,110,100,111,110,101,115,105
-,97,69,110,103,108,105,115,104,32,108,97,110,103,117,97,103,101,60,116,101,120,
-116,32,120,109,108,58,115,112,97,99,101,61,46,103,105,102,34,32,98,111,114,100,
-101,114,61,34,48,34,60,47,98,111,100,121,62,10,60,47,104,116,109,108,62,10,111,
-118,101,114,102,108,111,119,58,104,105,100,100,101,110,59,105,109,103,32,115,114
-,99,61,34,104,116,116,112,58,47,47,97,100,100,69,118,101,110,116,76,105,115,116,
-101,110,101,114,114,101,115,112,111,110,115,105,98,108,101,32,102,111,114,32,115
-,46,106,115,34,62,60,47,115,99,114,105,112,116,62,10,47,102,97,118,105,99,111,
-110,46,105,99,111,34,32,47,62,111,112,101,114,97,116,105,110,103,32,115,121,115,
-116,101,109,34,32,115,116,121,108,101,61,34,119,105,100,116,104,58,49,116,97,114
-,103,101,116,61,34,95,98,108,97,110,107,34,62,83,116,97,116,101,32,85,110,105,
-118,101,114,115,105,116,121,116,101,120,116,45,97,108,105,103,110,58,108,101,102
-,116,59,10,100,111,99,117,109,101,110,116,46,119,114,105,116,101,40,44,32,105,
-110,99,108,117,100,105,110,103,32,116,104,101,32,97,114,111,117,110,100,32,116,
-104,101,32,119,111,114,108,100,41,59,13,10,60,47,115,99,114,105,112,116,62,13,10
-,60,34,32,115,116,121,108,101,61,34,104,101,105,103,104,116,58,59,111,118,101,
-114,102,108,111,119,58,104,105,100,100,101,110,109,111,114,101,32,105,110,102,
-111,114,109,97,116,105,111,110,97,110,32,105,110,116,101,114,110,97,116,105,111,
-110,97,108,97,32,109,101,109,98,101,114,32,111,102,32,116,104,101,32,111,110,101
-,32,111,102,32,116,104,101,32,102,105,114,115,116,99,97,110,32,98,101,32,102,111
-,117,110,100,32,105,110,32,60,47,100,105,118,62,10,9,9,60,47,100,105,118,62,10,
-100,105,115,112,108,97,121,58,32,110,111,110,101,59,34,62,34,32,47,62,10,60,108,
-105,110,107,32,114,101,108,61,34,10,32,32,40,102,117,110,99,116,105,111,110,40,
-41,32,123,116,104,101,32,49,53,116,104,32,99,101,110,116,117,114,121,46,112,114,
-101,118,101,110,116,68,101,102,97,117,108,116,40,108,97,114,103,101,32,110,117,
-109,98,101,114,32,111,102,32,66,121,122,97,110,116,105,110,101,32,69,109,112,105
-,114,101,46,106,112,103,124,116,104,117,109,98,124,108,101,102,116,124,118,97,
-115,116,32,109,97,106,111,114,105,116,121,32,111,102,109,97,106,111,114,105,116,
-121,32,111,102,32,116,104,101,32,32,97,108,105,103,110,61,34,99,101,110,116,101,
-114,34,62,85,110,105,118,101,114,115,105,116,121,32,80,114,101,115,115,100,111,
-109,105,110,97,116,101,100,32,98,121,32,116,104,101,83,101,99,111,110,100,32,87,
-111,114,108,100,32,87,97,114,100,105,115,116,114,105,98,117,116,105,111,110,32,
-111,102,32,115,116,121,108,101,61,34,112,111,115,105,116,105,111,110,58,116,104,
-101,32,114,101,115,116,32,111,102,32,116,104,101,32,99,104,97,114,97,99,116,101,
-114,105,122,101,100,32,98,121,32,114,101,108,61,34,110,111,102,111,108,108,111,
-119,34,62,100,101,114,105,118,101,115,32,102,114,111,109,32,116,104,101,114,97,
-116,104,101,114,32,116,104,97,110,32,116,104,101,32,97,32,99,111,109,98,105,110,
-97,116,105,111,110,32,111,102,115,116,121,108,101,61,34,119,105,100,116,104,58,
-49,48,48,69,110,103,108,105,115,104,45,115,112,101,97,107,105,110,103,99,111,109
-,112,117,116,101,114,32,115,99,105,101,110,99,101,98,111,114,100,101,114,61,34,
-48,34,32,97,108,116,61,34,116,104,101,32,101,120,105,115,116,101,110,99,101,32,
-111,102,68,101,109,111,99,114,97,116,105,99,32,80,97,114,116,121,34,32,115,116,
-121,108,101,61,34,109,97,114,103,105,110,45,70,111,114,32,116,104,105,115,32,114
-,101,97,115,111,110,44,46,106,115,34,62,60,47,115,99,114,105,112,116,62,10,9,115
-,66,121,84,97,103,78,97,109,101,40,115,41,91,48,93,106,115,34,62,60,47,115,99,
-114,105,112,116,62,13,10,60,46,106,115,34,62,60,47,115,99,114,105,112,116,62,13,
-10,108,105,110,107,32,114,101,108,61,34,105,99,111,110,34,32,39,32,97,108,116,61
-,39,39,32,99,108,97,115,115,61,39,102,111,114,109,97,116,105,111,110,32,111,102,
-32,116,104,101,118,101,114,115,105,111,110,115,32,111,102,32,116,104,101,32,60,
-47,97,62,60,47,100,105,118,62,60,47,100,105,118,62,47,112,97,103,101,62,10,32,32
-,60,112,97,103,101,62,10,60,100,105,118,32,99,108,97,115,115,61,34,99,111,110,
-116,98,101,99,97,109,101,32,116,104,101,32,102,105,114,115,116,98,97,104,97,115,
-97,32,73,110,100,111,110,101,115,105,97,101,110,103,108,105,115,104,32,40,115,
-105,109,112,108,101,41,206,149,206,187,206,187,206,183,206,189,206,185,206,186,
-206,172,209,133,209,128,208,178,208,176,209,130,209,129,208,186,208,184,208,186,
-208,190,208,188,208,191,208,176,208,189,208,184,208,184,209,143,208,178,208,187,
-209,143,208,181,209,130,209,129,209,143,208,148,208,190,208,177,208,176,208,178,
-208,184,209,130,209,140,209,135,208,181,208,187,208,190,208,178,208,181,208,186,
-208,176,209,128,208,176,208,183,208,178,208,184,209,130,208,184,209,143,208,152,
-208,189,209,130,208,181,209,128,208,189,208,181,209,130,208,158,209,130,208,178,
-208,181,209,130,208,184,209,130,209,140,208,189,208,176,208,191,209,128,208,184,
-208,188,208,181,209,128,208,184,208,189,209,130,208,181,209,128,208,189,208,181,
-209,130,208,186,208,190,209,130,208,190,209,128,208,190,208,179,208,190,209,129,
-209,130,209,128,208,176,208,189,208,184,209,134,209,139,208,186,208,176,209,135,
-208,181,209,129,209,130,208,178,208,181,209,131,209,129,208,187,208,190,208,178,
-208,184,209,143,209,133,208,191,209,128,208,190,208,177,208,187,208,181,208,188,
-209,139,208,191,208,190,208,187,209,131,209,135,208,184,209,130,209,140,209,143,
-208,178,208,187,209,143,209,142,209,130,209,129,209,143,208,189,208,176,208,184,
-208,177,208,190,208,187,208,181,208,181,208,186,208,190,208,188,208,191,208,176,
-208,189,208,184,209,143,208,178,208,189,208,184,208,188,208,176,208,189,208,184,
-208,181,209,129,209,128,208,181,208,180,209,129,209,130,208,178,208,176,216,167,
-217,132,217,133,217,136,216,167,216,182,217,138,216,185,216,167,217,132,216,177,
-216,166,217,138,216,179,217,138,216,169,216,167,217,132,216,167,217,134,216,170,
-217,130,216,167,217,132,217,133,216,180,216,167,216,177,217,131,216,167,216,170,
-217,131,216,167,217,132,216,179,217,138,216,167,216,177,216,167,216,170,216,167,
-217,132,217,133,217,131,216,170,217,136,216,168,216,169,216,167,217,132,216,179,
-216,185,217,136,216,175,217,138,216,169,216,167,216,173,216,181,216,167,216,166,
-217,138,216,167,216,170,216,167,217,132,216,185,216,167,217,132,217,133,217,138,
-216,169,216,167,217,132,216,181,217,136,216,170,217,138,216,167,216,170,216,167,
-217,132,216,167,217,134,216,170,216,177,217,134,216,170,216,167,217,132,216,170,
-216,181,216,167,217,133,217,138,217,133,216,167,217,132,216,165,216,179,217,132,
-216,167,217,133,217,138,216,167,217,132,217,133,216,180,216,167,216,177,217,131,
-216,169,216,167,217,132,217,133,216,177,216,166,217,138,216,167,216,170,114,111,
-98,111,116,115,34,32,99,111,110,116,101,110,116,61,34,60,100,105,118,32,105,100,
-61,34,102,111,111,116,101,114,34,62,116,104,101,32,85,110,105,116,101,100,32,83,
-116,97,116,101,115,60,105,109,103,32,115,114,99,61,34,104,116,116,112,58,47,47,
-46,106,112,103,124,114,105,103,104,116,124,116,104,117,109,98,124,46,106,115,34,
-62,60,47,115,99,114,105,112,116,62,13,10,60,108,111,99,97,116,105,111,110,46,112
-,114,111,116,111,99,111,108,102,114,97,109,101,98,111,114,100,101,114,61,34,48,
-34,32,115,34,32,47,62,10,60,109,101,116,97,32,110,97,109,101,61,34,60,47,97,62,
-60,47,100,105,118,62,60,47,100,105,118,62,60,102,111,110,116,45,119,101,105,103,
-104,116,58,98,111,108,100,59,38,113,117,111,116,59,32,97,110,100,32,38,113,117,
-111,116,59,100,101,112,101,110,100,105,110,103,32,111,110,32,116,104,101,32,109,
-97,114,103,105,110,58,48,59,112,97,100,100,105,110,103,58,34,32,114,101,108,61,
-34,110,111,102,111,108,108,111,119,34,32,80,114,101,115,105,100,101,110,116,32,
-111,102,32,116,104,101,32,116,119,101,110,116,105,101,116,104,32,99,101,110,116,
-117,114,121,101,118,105,115,105,111,110,62,10,32,32,60,47,112,97,103,101,73,110,
-116,101,114,110,101,116,32,69,120,112,108,111,114,101,114,97,46,97,115,121,110,
-99,32,61,32,116,114,117,101,59,13,10,105,110,102,111,114,109,97,116,105,111,110,
-32,97,98,111,117,116,60,100,105,118,32,105,100,61,34,104,101,97,100,101,114,34,
-62,34,32,97,99,116,105,111,110,61,34,104,116,116,112,58,47,47,60,97,32,104,114,
-101,102,61,34,104,116,116,112,115,58,47,47,60,100,105,118,32,105,100,61,34,99,
-111,110,116,101,110,116,34,60,47,100,105,118,62,13,10,60,47,100,105,118,62,13,10
-,60,100,101,114,105,118,101,100,32,102,114,111,109,32,116,104,101,32,60,105,109,
-103,32,115,114,99,61,39,104,116,116,112,58,47,47,97,99,99,111,114,100,105,110,
-103,32,116,111,32,116,104,101,32,10,60,47,98,111,100,121,62,10,60,47,104,116,109
-,108,62,10,115,116,121,108,101,61,34,102,111,110,116,45,115,105,122,101,58,115,
-99,114,105,112,116,32,108,97,110,103,117,97,103,101,61,34,65,114,105,97,108,44,
-32,72,101,108,118,101,116,105,99,97,44,60,47,97,62,60,115,112,97,110,32,99,108,
-97,115,115,61,34,60,47,115,99,114,105,112,116,62,60,115,99,114,105,112,116,32,
-112,111,108,105,116,105,99,97,108,32,112,97,114,116,105,101,115,116,100,62,60,47
-,116,114,62,60,47,116,97,98,108,101,62,60,104,114,101,102,61,34,104,116,116,112,
-58,47,47,119,119,119,46,105,110,116,101,114,112,114,101,116,97,116,105,111,110,
-32,111,102,114,101,108,61,34,115,116,121,108,101,115,104,101,101,116,34,32,100,
-111,99,117,109,101,110,116,46,119,114,105,116,101,40,39,60,99,104,97,114,115,101
-,116,61,34,117,116,102,45,56,34,62,10,98,101,103,105,110,110,105,110,103,32,111,
-102,32,116,104,101,32,114,101,118,101,97,108,101,100,32,116,104,97,116,32,116,
-104,101,116,101,108,101,118,105,115,105,111,110,32,115,101,114,105,101,115,34,32
-,114,101,108,61,34,110,111,102,111,108,108,111,119,34,62,32,116,97,114,103,101,
-116,61,34,95,98,108,97,110,107,34,62,99,108,97,105,109,105,110,103,32,116,104,97
-,116,32,116,104,101,104,116,116,112,37,51,65,37,50,70,37,50,70,119,119,119,46,
-109,97,110,105,102,101,115,116,97,116,105,111,110,115,32,111,102,80,114,105,109,
-101,32,77,105,110,105,115,116,101,114,32,111,102,105,110,102,108,117,101,110,99,
-101,100,32,98,121,32,116,104,101,99,108,97,115,115,61,34,99,108,101,97,114,102,
-105,120,34,62,47,100,105,118,62,13,10,60,47,100,105,118,62,13,10,13,10,116,104,
-114,101,101,45,100,105,109,101,110,115,105,111,110,97,108,67,104,117,114,99,104,
-32,111,102,32,69,110,103,108,97,110,100,111,102,32,78,111,114,116,104,32,67,97,
-114,111,108,105,110,97,115,113,117,97,114,101,32,107,105,108,111,109,101,116,114
-,101,115,46,97,100,100,69,118,101,110,116,76,105,115,116,101,110,101,114,100,105
-,115,116,105,110,99,116,32,102,114,111,109,32,116,104,101,99,111,109,109,111,110
-,108,121,32,107,110,111,119,110,32,97,115,80,104,111,110,101,116,105,99,32,65,
-108,112,104,97,98,101,116,100,101,99,108,97,114,101,100,32,116,104,97,116,32,116
-,104,101,99,111,110,116,114,111,108,108,101,100,32,98,121,32,116,104,101,66,101,
-110,106,97,109,105,110,32,70,114,97,110,107,108,105,110,114,111,108,101,45,112,
-108,97,121,105,110,103,32,103,97,109,101,116,104,101,32,85,110,105,118,101,114,
-115,105,116,121,32,111,102,105,110,32,87,101,115,116,101,114,110,32,69,117,114,
-111,112,101,112,101,114,115,111,110,97,108,32,99,111,109,112,117,116,101,114,80,
-114,111,106,101,99,116,32,71,117,116,101,110,98,101,114,103,114,101,103,97,114,
-100,108,101,115,115,32,111,102,32,116,104,101,104,97,115,32,98,101,101,110,32,
-112,114,111,112,111,115,101,100,116,111,103,101,116,104,101,114,32,119,105,116,
-104,32,116,104,101,62,60,47,108,105,62,60,108,105,32,99,108,97,115,115,61,34,105
-,110,32,115,111,109,101,32,99,111,117,110,116,114,105,101,115,109,105,110,46,106
-,115,34,62,60,47,115,99,114,105,112,116,62,111,102,32,116,104,101,32,112,111,112
-,117,108,97,116,105,111,110,111,102,102,105,99,105,97,108,32,108,97,110,103,117,
-97,103,101,60,105,109,103,32,115,114,99,61,34,105,109,97,103,101,115,47,105,100,
-101,110,116,105,102,105,101,100,32,98,121,32,116,104,101,110,97,116,117,114,97,
-108,32,114,101,115,111,117,114,99,101,115,99,108,97,115,115,105,102,105,99,97,
-116,105,111,110,32,111,102,99,97,110,32,98,101,32,99,111,110,115,105,100,101,114
-,101,100,113,117,97,110,116,117,109,32,109,101,99,104,97,110,105,99,115,78,101,
-118,101,114,116,104,101,108,101,115,115,44,32,116,104,101,109,105,108,108,105,
-111,110,32,121,101,97,114,115,32,97,103,111,60,47,98,111,100,121,62,13,10,60,47,
-104,116,109,108,62,13,206,149,206,187,206,187,206,183,206,189,206,185,206,186,
-206,172,10,116,97,107,101,32,97,100,118,97,110,116,97,103,101,32,111,102,97,110,
-100,44,32,97,99,99,111,114,100,105,110,103,32,116,111,97,116,116,114,105,98,117,
-116,101,100,32,116,111,32,116,104,101,77,105,99,114,111,115,111,102,116,32,87,
-105,110,100,111,119,115,116,104,101,32,102,105,114,115,116,32,99,101,110,116,117
-,114,121,117,110,100,101,114,32,116,104,101,32,99,111,110,116,114,111,108,100,
-105,118,32,99,108,97,115,115,61,34,104,101,97,100,101,114,115,104,111,114,116,
-108,121,32,97,102,116,101,114,32,116,104,101,110,111,116,97,98,108,101,32,101,
-120,99,101,112,116,105,111,110,116,101,110,115,32,111,102,32,116,104,111,117,115
-,97,110,100,115,115,101,118,101,114,97,108,32,100,105,102,102,101,114,101,110,
-116,97,114,111,117,110,100,32,116,104,101,32,119,111,114,108,100,46,114,101,97,
-99,104,105,110,103,32,109,105,108,105,116,97,114,121,105,115,111,108,97,116,101,
-100,32,102,114,111,109,32,116,104,101,111,112,112,111,115,105,116,105,111,110,32
-,116,111,32,116,104,101,116,104,101,32,79,108,100,32,84,101,115,116,97,109,101,
-110,116,65,102,114,105,99,97,110,32,65,109,101,114,105,99,97,110,115,105,110,115
-,101,114,116,101,100,32,105,110,116,111,32,116,104,101,115,101,112,97,114,97,116
-,101,32,102,114,111,109,32,116,104,101,109,101,116,114,111,112,111,108,105,116,
-97,110,32,97,114,101,97,109,97,107,101,115,32,105,116,32,112,111,115,115,105,98,
-108,101,97,99,107,110,111,119,108,101,100,103,101,100,32,116,104,97,116,97,114,
-103,117,97,98,108,121,32,116,104,101,32,109,111,115,116,116,121,112,101,61,34,
-116,101,120,116,47,99,115,115,34,62,10,116,104,101,32,73,110,116,101,114,110,97,
-116,105,111,110,97,108,65,99,99,111,114,100,105,110,103,32,116,111,32,116,104,
-101,32,112,101,61,34,116,101,120,116,47,99,115,115,34,32,47,62,10,99,111,105,110
-,99,105,100,101,32,119,105,116,104,32,116,104,101,116,119,111,45,116,104,105,114
-,100,115,32,111,102,32,116,104,101,68,117,114,105,110,103,32,116,104,105,115,32,
-116,105,109,101,44,100,117,114,105,110,103,32,116,104,101,32,112,101,114,105,111
-,100,97,110,110,111,117,110,99,101,100,32,116,104,97,116,32,104,101,116,104,101,
-32,105,110,116,101,114,110,97,116,105,111,110,97,108,97,110,100,32,109,111,114,
-101,32,114,101,99,101,110,116,108,121,98,101,108,105,101,118,101,100,32,116,104,
-97,116,32,116,104,101,99,111,110,115,99,105,111,117,115,110,101,115,115,32,97,
-110,100,102,111,114,109,101,114,108,121,32,107,110,111,119,110,32,97,115,115,117
-,114,114,111,117,110,100,101,100,32,98,121,32,116,104,101,102,105,114,115,116,32
-,97,112,112,101,97,114,101,100,32,105,110,111,99,99,97,115,105,111,110,97,108,
-108,121,32,117,115,101,100,112,111,115,105,116,105,111,110,58,97,98,115,111,108,
-117,116,101,59,34,32,116,97,114,103,101,116,61,34,95,98,108,97,110,107,34,32,112
-,111,115,105,116,105,111,110,58,114,101,108,97,116,105,118,101,59,116,101,120,
-116,45,97,108,105,103,110,58,99,101,110,116,101,114,59,106,97,120,47,108,105,98,
-115,47,106,113,117,101,114,121,47,49,46,98,97,99,107,103,114,111,117,110,100,45,
-99,111,108,111,114,58,35,116,121,112,101,61,34,97,112,112,108,105,99,97,116,105,
-111,110,47,97,110,103,117,97,103,101,34,32,99,111,110,116,101,110,116,61,34,60,
-109,101,116,97,32,104,116,116,112,45,101,113,117,105,118,61,34,80,114,105,118,97
-,99,121,32,80,111,108,105,99,121,60,47,97,62,101,40,34,37,51,67,115,99,114,105,
-112,116,32,115,114,99,61,39,34,32,116,97,114,103,101,116,61,34,95,98,108,97,110,
-107,34,62,79,110,32,116,104,101,32,111,116,104,101,114,32,104,97,110,100,44,46,
-106,112,103,124,116,104,117,109,98,124,114,105,103,104,116,124,50,60,47,100,105,
-118,62,60,100,105,118,32,99,108,97,115,115,61,34,60,100,105,118,32,115,116,121,
-108,101,61,34,102,108,111,97,116,58,110,105,110,101,116,101,101,110,116,104,32,
-99,101,110,116,117,114,121,60,47,98,111,100,121,62,13,10,60,47,104,116,109,108,
-62,13,10,60,105,109,103,32,115,114,99,61,34,104,116,116,112,58,47,47,115,59,116,
-101,120,116,45,97,108,105,103,110,58,99,101,110,116,101,114,102,111,110,116,45,
-119,101,105,103,104,116,58,32,98,111,108,100,59,32,65,99,99,111,114,100,105,110,
-103,32,116,111,32,116,104,101,32,100,105,102,102,101,114,101,110,99,101,32,98,
-101,116,119,101,101,110,34,32,102,114,97,109,101,98,111,114,100,101,114,61,34,48
-,34,32,34,32,115,116,121,108,101,61,34,112,111,115,105,116,105,111,110,58,108,
-105,110,107,32,104,114,101,102,61,34,104,116,116,112,58,47,47,104,116,109,108,52
-,47,108,111,111,115,101,46,100,116,100,34,62,10,100,117,114,105,110,103,32,116,
-104,105,115,32,112,101,114,105,111,100,60,47,116,100,62,60,47,116,114,62,60,47,
-116,97,98,108,101,62,99,108,111,115,101,108,121,32,114,101,108,97,116,101,100,32
-,116,111,102,111,114,32,116,104,101,32,102,105,114,115,116,32,116,105,109,101,59
-,102,111,110,116,45,119,101,105,103,104,116,58,98,111,108,100,59,105,110,112,117
-,116,32,116,121,112,101,61,34,116,101,120,116,34,32,60,115,112,97,110,32,115,116
-,121,108,101,61,34,102,111,110,116,45,111,110,114,101,97,100,121,115,116,97,116,
-101,99,104,97,110,103,101,9,60,100,105,118,32,99,108,97,115,115,61,34,99,108,101
-,97,114,100,111,99,117,109,101,110,116,46,108,111,99,97,116,105,111,110,46,32,70
-,111,114,32,101,120,97,109,112,108,101,44,32,116,104,101,32,97,32,119,105,100,
-101,32,118,97,114,105,101,116,121,32,111,102,32,60,33,68,79,67,84,89,80,69,32,
-104,116,109,108,62,13,10,60,38,110,98,115,112,59,38,110,98,115,112,59,38,110,98,
-115,112,59,34,62,60,97,32,104,114,101,102,61,34,104,116,116,112,58,47,47,115,116
-,121,108,101,61,34,102,108,111,97,116,58,108,101,102,116,59,99,111,110,99,101,
-114,110,101,100,32,119,105,116,104,32,116,104,101,61,104,116,116,112,37,51,65,37
-,50,70,37,50,70,119,119,119,46,105,110,32,112,111,112,117,108,97,114,32,99,117,
-108,116,117,114,101,116,121,112,101,61,34,116,101,120,116,47,99,115,115,34,32,47
-,62,105,116,32,105,115,32,112,111,115,115,105,98,108,101,32,116,111,32,72,97,114
-,118,97,114,100,32,85,110,105,118,101,114,115,105,116,121,116,121,108,101,115,
-104,101,101,116,34,32,104,114,101,102,61,34,47,116,104,101,32,109,97,105,110,32,
-99,104,97,114,97,99,116,101,114,79,120,102,111,114,100,32,85,110,105,118,101,114
-,115,105,116,121,32,32,110,97,109,101,61,34,107,101,121,119,111,114,100,115,34,
-32,99,115,116,121,108,101,61,34,116,101,120,116,45,97,108,105,103,110,58,116,104
-,101,32,85,110,105,116,101,100,32,75,105,110,103,100,111,109,102,101,100,101,114
-,97,108,32,103,111,118,101,114,110,109,101,110,116,60,100,105,118,32,115,116,121
-,108,101,61,34,109,97,114,103,105,110,32,100,101,112,101,110,100,105,110,103,32,
-111,110,32,116,104,101,32,100,101,115,99,114,105,112,116,105,111,110,32,111,102,
-32,116,104,101,60,100,105,118,32,99,108,97,115,115,61,34,104,101,97,100,101,114,
-46,109,105,110,46,106,115,34,62,60,47,115,99,114,105,112,116,62,100,101,115,116,
-114,117,99,116,105,111,110,32,111,102,32,116,104,101,115,108,105,103,104,116,108
-,121,32,100,105,102,102,101,114,101,110,116,105,110,32,97,99,99,111,114,100,97,
-110,99,101,32,119,105,116,104,116,101,108,101,99,111,109,109,117,110,105,99,97,
-116,105,111,110,115,105,110,100,105,99,97,116,101,115,32,116,104,97,116,32,116,
-104,101,115,104,111,114,116,108,121,32,116,104,101,114,101,97,102,116,101,114,
-101,115,112,101,99,105,97,108,108,121,32,105,110,32,116,104,101,32,69,117,114,
-111,112,101,97,110,32,99,111,117,110,116,114,105,101,115,72,111,119,101,118,101,
-114,44,32,116,104,101,114,101,32,97,114,101,115,114,99,61,34,104,116,116,112,58,
-47,47,115,116,97,116,105,99,115,117,103,103,101,115,116,101,100,32,116,104,97,
-116,32,116,104,101,34,32,115,114,99,61,34,104,116,116,112,58,47,47,119,119,119,
-46,97,32,108,97,114,103,101,32,110,117,109,98,101,114,32,111,102,32,84,101,108,
-101,99,111,109,109,117,110,105,99,97,116,105,111,110,115,34,32,114,101,108,61,34
-,110,111,102,111,108,108,111,119,34,32,116,72,111,108,121,32,82,111,109,97,110,
-32,69,109,112,101,114,111,114,97,108,109,111,115,116,32,101,120,99,108,117,115,
-105,118,101,108,121,34,32,98,111,114,100,101,114,61,34,48,34,32,97,108,116,61,34
-,83,101,99,114,101,116,97,114,121,32,111,102,32,83,116,97,116,101,99,117,108,109
-,105,110,97,116,105,110,103,32,105,110,32,116,104,101,67,73,65,32,87,111,114,108
-,100,32,70,97,99,116,98,111,111,107,116,104,101,32,109,111,115,116,32,105,109,
-112,111,114,116,97,110,116,97,110,110,105,118,101,114,115,97,114,121,32,111,102,
-32,116,104,101,115,116,121,108,101,61,34,98,97,99,107,103,114,111,117,110,100,45
-,60,108,105,62,60,101,109,62,60,97,32,104,114,101,102,61,34,47,116,104,101,32,65
-,116,108,97,110,116,105,99,32,79,99,101,97,110,115,116,114,105,99,116,108,121,32
-,115,112,101,97,107,105,110,103,44,115,104,111,114,116,108,121,32,98,101,102,111
-,114,101,32,116,104,101,100,105,102,102,101,114,101,110,116,32,116,121,112,101,
-115,32,111,102,116,104,101,32,79,116,116,111,109,97,110,32,69,109,112,105,114,
-101,62,60,105,109,103,32,115,114,99,61,34,104,116,116,112,58,47,47,65,110,32,73,
-110,116,114,111,100,117,99,116,105,111,110,32,116,111,99,111,110,115,101,113,117
-,101,110,99,101,32,111,102,32,116,104,101,100,101,112,97,114,116,117,114,101,32,
-102,114,111,109,32,116,104,101,67,111,110,102,101,100,101,114,97,116,101,32,83,
-116,97,116,101,115,105,110,100,105,103,101,110,111,117,115,32,112,101,111,112,
-108,101,115,80,114,111,99,101,101,100,105,110,103,115,32,111,102,32,116,104,101,
-105,110,102,111,114,109,97,116,105,111,110,32,111,110,32,116,104,101,116,104,101
-,111,114,105,101,115,32,104,97,118,101,32,98,101,101,110,105,110,118,111,108,118
-,101,109,101,110,116,32,105,110,32,116,104,101,100,105,118,105,100,101,100,32,
-105,110,116,111,32,116,104,114,101,101,97,100,106,97,99,101,110,116,32,99,111,
-117,110,116,114,105,101,115,105,115,32,114,101,115,112,111,110,115,105,98,108,
-101,32,102,111,114,100,105,115,115,111,108,117,116,105,111,110,32,111,102,32,116
-,104,101,99,111,108,108,97,98,111,114,97,116,105,111,110,32,119,105,116,104,119,
-105,100,101,108,121,32,114,101,103,97,114,100,101,100,32,97,115,104,105,115,32,
-99,111,110,116,101,109,112,111,114,97,114,105,101,115,102,111,117,110,100,105,
-110,103,32,109,101,109,98,101,114,32,111,102,68,111,109,105,110,105,99,97,110,32
-,82,101,112,117,98,108,105,99,103,101,110,101,114,97,108,108,121,32,97,99,99,101
-,112,116,101,100,116,104,101,32,112,111,115,115,105,98,105,108,105,116,121,32,
-111,102,97,114,101,32,97,108,115,111,32,97,118,97,105,108,97,98,108,101,117,110,
-100,101,114,32,99,111,110,115,116,114,117,99,116,105,111,110,114,101,115,116,111
-,114,97,116,105,111,110,32,111,102,32,116,104,101,116,104,101,32,103,101,110,101
-,114,97,108,32,112,117,98,108,105,99,105,115,32,97,108,109,111,115,116,32,101,
-110,116,105,114,101,108,121,112,97,115,115,101,115,32,116,104,114,111,117,103,
-104,32,116,104,101,104,97,115,32,98,101,101,110,32,115,117,103,103,101,115,116,
-101,100,99,111,109,112,117,116,101,114,32,97,110,100,32,118,105,100,101,111,71,
-101,114,109,97,110,105,99,32,108,97,110,103,117,97,103,101,115,32,97,99,99,111,
-114,100,105,110,103,32,116,111,32,116,104,101,32,100,105,102,102,101,114,101,110
-,116,32,102,114,111,109,32,116,104,101,115,104,111,114,116,108,121,32,97,102,116
-,101,114,119,97,114,100,115,104,114,101,102,61,34,104,116,116,112,115,58,47,47,
-119,119,119,46,114,101,99,101,110,116,32,100,101,118,101,108,111,112,109,101,110
-,116,66,111,97,114,100,32,111,102,32,68,105,114,101,99,116,111,114,115,60,100,
-105,118,32,99,108,97,115,115,61,34,115,101,97,114,99,104,124,32,60,97,32,104,114
-,101,102,61,34,104,116,116,112,58,47,47,73,110,32,112,97,114,116,105,99,117,108,
-97,114,44,32,116,104,101,77,117,108,116,105,112,108,101,32,102,111,111,116,110,
-111,116,101,115,111,114,32,111,116,104,101,114,32,115,117,98,115,116,97,110,99,
-101,116,104,111,117,115,97,110,100,115,32,111,102,32,121,101,97,114,115,116,114,
-97,110,115,108,97,116,105,111,110,32,111,102,32,116,104,101,60,47,100,105,118,62
-,13,10,60,47,100,105,118,62,13,10,13,10,60,97,32,104,114,101,102,61,34,105,110,
-100,101,120,46,112,104,112,119,97,115,32,101,115,116,97,98,108,105,115,104,101,
-100,32,105,110,109,105,110,46,106,115,34,62,60,47,115,99,114,105,112,116,62,10,
-112,97,114,116,105,99,105,112,97,116,101,32,105,110,32,116,104,101,97,32,115,116
-,114,111,110,103,32,105,110,102,108,117,101,110,99,101,115,116,121,108,101,61,34
-,109,97,114,103,105,110,45,116,111,112,58,114,101,112,114,101,115,101,110,116,
-101,100,32,98,121,32,116,104,101,103,114,97,100,117,97,116,101,100,32,102,114,
-111,109,32,116,104,101,84,114,97,100,105,116,105,111,110,97,108,108,121,44,32,
-116,104,101,69,108,101,109,101,110,116,40,34,115,99,114,105,112,116,34,41,59,72,
-111,119,101,118,101,114,44,32,115,105,110,99,101,32,116,104,101,47,100,105,118,
-62,10,60,47,100,105,118,62,10,60,100,105,118,32,108,101,102,116,59,32,109,97,114
-,103,105,110,45,108,101,102,116,58,112,114,111,116,101,99,116,105,111,110,32,97,
-103,97,105,110,115,116,48,59,32,118,101,114,116,105,99,97,108,45,97,108,105,103,
-110,58,85,110,102,111,114,116,117,110,97,116,101,108,121,44,32,116,104,101,116,
-121,112,101,61,34,105,109,97,103,101,47,120,45,105,99,111,110,47,100,105,118,62,
-10,60,100,105,118,32,99,108,97,115,115,61,34,32,99,108,97,115,115,61,34,99,108,
-101,97,114,102,105,120,34,62,60,100,105,118,32,99,108,97,115,115,61,34,102,111,
-111,116,101,114,9,9,60,47,100,105,118,62,10,9,9,60,47,100,105,118,62,10,116,104,
-101,32,109,111,116,105,111,110,32,112,105,99,116,117,114,101,208,145,209,138,208
-,187,208,179,208,176,209,128,209,129,208,186,208,184,208,177,209,138,208,187,208
-,179,208,176,209,128,209,129,208,186,208,184,208,164,208,181,208,180,208,181,209
-,128,208,176,209,134,208,184,208,184,208,189,208,181,209,129,208,186,208,190,208
-,187,209,140,208,186,208,190,209,129,208,190,208,190,208,177,209,137,208,181,208
-,189,208,184,208,181,209,129,208,190,208,190,208,177,209,137,208,181,208,189,208
-,184,209,143,208,191,209,128,208,190,208,179,209,128,208,176,208,188,208,188,209
-,139,208,158,209,130,208,191,209,128,208,176,208,178,208,184,209,130,209,140,208
-,177,208,181,209,129,208,191,208,187,208,176,209,130,208,189,208,190,208,188,208
-,176,209,130,208,181,209,128,208,184,208,176,208,187,209,139,208,191,208,190,208
-,183,208,178,208,190,208,187,209,143,208,181,209,130,208,191,208,190,209,129,208
-,187,208,181,208,180,208,189,208,184,208,181,209,128,208,176,208,183,208,187,208
-,184,209,135,208,189,209,139,209,133,208,191,209,128,208,190,208,180,209,131,208
-,186,209,134,208,184,208,184,208,191,209,128,208,190,208,179,209,128,208,176,208
-,188,208,188,208,176,208,191,208,190,208,187,208,189,208,190,209,129,209,130,209
-,140,209,142,208,189,208,176,209,133,208,190,208,180,208,184,209,130,209,129,209
-,143,208,184,208,183,208,177,209,128,208,176,208,189,208,189,208,190,208,181,208
-,189,208,176,209,129,208,181,208,187,208,181,208,189,208,184,209,143,208,184,208
-,183,208,188,208,181,208,189,208,181,208,189,208,184,209,143,208,186,208,176,209
-,130,208,181,208,179,208,190,209,128,208,184,208,184,208,144,208,187,208,181,208
-,186,209,129,208,176,208,189,208,180,209,128,224,164,166,224,165,141,224,164,181
-,224,164,190,224,164,176,224,164,190,224,164,174,224,165,136,224,164,168,224,165
-,129,224,164,133,224,164,178,224,164,170,224,165,141,224,164,176,224,164,166,224
-,164,190,224,164,168,224,164,173,224,164,190,224,164,176,224,164,164,224,165,128
-,224,164,175,224,164,133,224,164,168,224,165,129,224,164,166,224,165,135,224,164
-,182,224,164,185,224,164,191,224,164,168,224,165,141,224,164,166,224,165,128,224
-,164,135,224,164,130,224,164,161,224,164,191,224,164,175,224,164,190,224,164,166
-,224,164,191,224,164,178,224,165,141,224,164,178,224,165,128,224,164,133,224,164
-,167,224,164,191,224,164,149,224,164,190,224,164,176,224,164,181,224,165,128,224
-,164,161,224,164,191,224,164,175,224,165,139,224,164,154,224,164,191,224,164,159
-,224,165,141,224,164,160,224,165,135,224,164,184,224,164,174,224,164,190,224,164
-,154,224,164,190,224,164,176,224,164,156,224,164,130,224,164,149,224,165,141,224
-,164,182,224,164,168,224,164,166,224,165,129,224,164,168,224,164,191,224,164,175
-,224,164,190,224,164,170,224,165,141,224,164,176,224,164,175,224,165,139,224,164
-,151,224,164,133,224,164,168,224,165,129,224,164,184,224,164,190,224,164,176,224
-,164,145,224,164,168,224,164,178,224,164,190,224,164,135,224,164,168,224,164,170
-,224,164,190,224,164,176,224,165,141,224,164,159,224,165,128,224,164,182,224,164
-,176,224,165,141,224,164,164,224,165,139,224,164,130,224,164,178,224,165,139,224
-,164,149,224,164,184,224,164,173,224,164,190,224,164,171,224,164,188,224,165,141
-,224,164,178,224,165,136,224,164,182,224,164,182,224,164,176,224,165,141,224,164
-,164,224,165,135,224,164,130,224,164,170,224,165,141,224,164,176,224,164,166,224
-,165,135,224,164,182,224,164,170,224,165,141,224,164,178,224,165,135,224,164,175
-,224,164,176,224,164,149,224,165,135,224,164,130,224,164,166,224,165,141,224,164
-,176,224,164,184,224,165,141,224,164,165,224,164,191,224,164,164,224,164,191,224
-,164,137,224,164,164,224,165,141,224,164,170,224,164,190,224,164,166,224,164,137
-,224,164,168,224,165,141,224,164,185,224,165,135,224,164,130,224,164,154,224,164
-,191,224,164,159,224,165,141,224,164,160,224,164,190,224,164,175,224,164,190,224
-,164,164,224,165,141,224,164,176,224,164,190,224,164,156,224,165,141,224,164,175
-,224,164,190,224,164,166,224,164,190,224,164,170,224,165,129,224,164,176,224,164
-,190,224,164,168,224,165,135,224,164,156,224,165,139,224,164,161,224,164,188,224
-,165,135,224,164,130,224,164,133,224,164,168,224,165,129,224,164,181,224,164,190
-,224,164,166,224,164,182,224,165,141,224,164,176,224,165,135,224,164,163,224,165
-,128,224,164,182,224,164,191,224,164,149,224,165,141,224,164,183,224,164,190,224
-,164,184,224,164,176,224,164,149,224,164,190,224,164,176,224,165,128,224,164,184
-,224,164,130,224,164,151,224,165,141,224,164,176,224,164,185,224,164,170,224,164
-,176,224,164,191,224,164,163,224,164,190,224,164,174,224,164,172,224,165,141,224
-,164,176,224,164,190,224,164,130,224,164,161,224,164,172,224,164,154,224,165,141
-,224,164,154,224,165,139,224,164,130,224,164,137,224,164,170,224,164,178,224,164
-,172,224,165,141,224,164,167,224,164,174,224,164,130,224,164,164,224,165,141,224
-,164,176,224,165,128,224,164,184,224,164,130,224,164,170,224,164,176,224,165,141
-,224,164,149,224,164,137,224,164,174,224,165,141,224,164,174,224,165,128,224,164
-,166,224,164,174,224,164,190,224,164,167,224,165,141,224,164,175,224,164,174,224
-,164,184,224,164,185,224,164,190,224,164,175,224,164,164,224,164,190,224,164,182
-,224,164,172,224,165,141,224,164,166,224,165,139,224,164,130,224,164,174,224,165
-,128,224,164,161,224,164,191,224,164,175,224,164,190,224,164,134,224,164,136,224
-,164,170,224,165,128,224,164,143,224,164,178,224,164,174,224,165,139,224,164,172
-,224,164,190,224,164,135,224,164,178,224,164,184,224,164,130,224,164,150,224,165
-,141,224,164,175,224,164,190,224,164,134,224,164,170,224,164,176,224,165,135,224
-,164,182,224,164,168,224,164,133,224,164,168,224,165,129,224,164,172,224,164,130
-,224,164,167,224,164,172,224,164,190,224,164,156,224,164,188,224,164,190,224,164
-,176,224,164,168,224,164,181,224,165,128,224,164,168,224,164,164,224,164,174,224
-,164,170,224,165,141,224,164,176,224,164,174,224,165,129,224,164,150,224,164,170
-,224,165,141,224,164,176,224,164,182,224,165,141,224,164,168,224,164,170,224,164
-,176,224,164,191,224,164,181,224,164,190,224,164,176,224,164,168,224,165,129,224
-,164,149,224,164,184,224,164,190,224,164,168,224,164,184,224,164,174,224,164,176
-,224,165,141,224,164,165,224,164,168,224,164,134,224,164,175,224,165,139,224,164
-,156,224,164,191,224,164,164,224,164,184,224,165,139,224,164,174,224,164,181,224
-,164,190,224,164,176,216,167,217,132,217,133,216,180,216,167,216,177,217,131,216
-,167,216,170,216,167,217,132,217,133,217,134,216,170,216,175,217,138,216,167,216
-,170,216,167,217,132,217,131,217,133,216,168,217,138,217,136,216,170,216,177,216
-,167,217,132,217,133,216,180,216,167,217,135,216,175,216,167,216,170,216,185,216
-,175,216,175,216,167,217,132,216,178,217,136,216,167,216,177,216,185,216,175,216
-,175,216,167,217,132,216,177,216,175,217,136,216,175,216,167,217,132,216,165,216
-,179,217,132,216,167,217,133,217,138,216,169,216,167,217,132,217,129,217,136,216
-,170,217,136,216,180,217,136,216,168,216,167,217,132,217,133,216,179,216,167,216
-,168,217,130,216,167,216,170,216,167,217,132,217,133,216,185,217,132,217,136,217
-,133,216,167,216,170,216,167,217,132,217,133,216,179,217,132,216,179,217,132,216
-,167,216,170,216,167,217,132,216,172,216,177,216,167,217,129,217,138,217,131,216
-,179,216,167,217,132,216,167,216,179,217,132,216,167,217,133,217,138,216,169,216
-,167,217,132,216,167,216,170,216,181,216,167,217,132,216,167,216,170,107,101,121
-,119,111,114,100,115,34,32,99,111,110,116,101,110,116,61,34,119,51,46,111,114,
-103,47,49,57,57,57,47,120,104,116,109,108,34,62,60,97,32,116,97,114,103,101,116,
-61,34,95,98,108,97,110,107,34,32,116,101,120,116,47,104,116,109,108,59,32,99,104
-,97,114,115,101,116,61,34,32,116,97,114,103,101,116,61,34,95,98,108,97,110,107,
-34,62,60,116,97,98,108,101,32,99,101,108,108,112,97,100,100,105,110,103,61,34,97
-,117,116,111,99,111,109,112,108,101,116,101,61,34,111,102,102,34,32,116,101,120,
-116,45,97,108,105,103,110,58,32,99,101,110,116,101,114,59,116,111,32,108,97,115,
-116,32,118,101,114,115,105,111,110,32,98,121,32,98,97,99,107,103,114,111,117,110
-,100,45,99,111,108,111,114,58,32,35,34,32,104,114,101,102,61,34,104,116,116,112,
-58,47,47,119,119,119,46,47,100,105,118,62,60,47,100,105,118,62,60,100,105,118,32
-,105,100,61,60,97,32,104,114,101,102,61,34,35,34,32,99,108,97,115,115,61,34,34,
-62,60,105,109,103,32,115,114,99,61,34,104,116,116,112,58,47,47,99,114,105,112,
-116,34,32,115,114,99,61,34,104,116,116,112,58,47,47,10,60,115,99,114,105,112,116
-,32,108,97,110,103,117,97,103,101,61,34,47,47,69,78,34,32,34,104,116,116,112,58,
-47,47,119,119,119,46,119,101,110,99,111,100,101,85,82,73,67,111,109,112,111,110,
-101,110,116,40,34,32,104,114,101,102,61,34,106,97,118,97,115,99,114,105,112,116,
-58,60,100,105,118,32,99,108,97,115,115,61,34,99,111,110,116,101,110,116,100,111,
-99,117,109,101,110,116,46,119,114,105,116,101,40,39,60,115,99,112,111,115,105,
-116,105,111,110,58,32,97,98,115,111,108,117,116,101,59,115,99,114,105,112,116,32
-,115,114,99,61,34,104,116,116,112,58,47,47,32,115,116,121,108,101,61,34,109,97,
-114,103,105,110,45,116,111,112,58,46,109,105,110,46,106,115,34,62,60,47,115,99,
-114,105,112,116,62,10,60,47,100,105,118,62,10,60,100,105,118,32,99,108,97,115,
-115,61,34,119,51,46,111,114,103,47,49,57,57,57,47,120,104,116,109,108,34,32,10,
-13,10,60,47,98,111,100,121,62,13,10,60,47,104,116,109,108,62,100,105,115,116,105
-,110,99,116,105,111,110,32,98,101,116,119,101,101,110,47,34,32,116,97,114,103,
-101,116,61,34,95,98,108,97,110,107,34,62,60,108,105,110,107,32,104,114,101,102,
-61,34,104,116,116,112,58,47,47,101,110,99,111,100,105,110,103,61,34,117,116,102,
-45,56,34,63,62,10,119,46,97,100,100,69,118,101,110,116,76,105,115,116,101,110,
-101,114,63,97,99,116,105,111,110,61,34,104,116,116,112,58,47,47,119,119,119,46,
-105,99,111,110,34,32,104,114,101,102,61,34,104,116,116,112,58,47,47,32,115,116,
-121,108,101,61,34,98,97,99,107,103,114,111,117,110,100,58,116,121,112,101,61,34,
-116,101,120,116,47,99,115,115,34,32,47,62,10,109,101,116,97,32,112,114,111,112,
-101,114,116,121,61,34,111,103,58,116,60,105,110,112,117,116,32,116,121,112,101,
-61,34,116,101,120,116,34,32,32,115,116,121,108,101,61,34,116,101,120,116,45,97,
-108,105,103,110,58,116,104,101,32,100,101,118,101,108,111,112,109,101,110,116,32
-,111,102,32,116,121,108,101,115,104,101,101,116,34,32,116,121,112,101,61,34,116,
-101,104,116,109,108,59,32,99,104,97,114,115,101,116,61,117,116,102,45,56,105,115
-,32,99,111,110,115,105,100,101,114,101,100,32,116,111,32,98,101,116,97,98,108,
-101,32,119,105,100,116,104,61,34,49,48,48,37,34,32,73,110,32,97,100,100,105,116,
-105,111,110,32,116,111,32,116,104,101,32,99,111,110,116,114,105,98,117,116,101,
-100,32,116,111,32,116,104,101,32,100,105,102,102,101,114,101,110,99,101,115,32,
-98,101,116,119,101,101,110,100,101,118,101,108,111,112,109,101,110,116,32,111,
-102,32,116,104,101,32,73,116,32,105,115,32,105,109,112,111,114,116,97,110,116,32
-,116,111,32,60,47,115,99,114,105,112,116,62,10,10,60,115,99,114,105,112,116,32,
-32,115,116,121,108,101,61,34,102,111,110,116,45,115,105,122,101,58,49,62,60,47,
-115,112,97,110,62,60,115,112,97,110,32,105,100,61,103,98,76,105,98,114,97,114,
-121,32,111,102,32,67,111,110,103,114,101,115,115,60,105,109,103,32,115,114,99,61
-,34,104,116,116,112,58,47,47,105,109,69,110,103,108,105,115,104,32,116,114,97,
-110,115,108,97,116,105,111,110,65,99,97,100,101,109,121,32,111,102,32,83,99,105,
-101,110,99,101,115,100,105,118,32,115,116,121,108,101,61,34,100,105,115,112,108,
-97,121,58,99,111,110,115,116,114,117,99,116,105,111,110,32,111,102,32,116,104,
-101,46,103,101,116,69,108,101,109,101,110,116,66,121,73,100,40,105,100,41,105,
-110,32,99,111,110,106,117,110,99,116,105,111,110,32,119,105,116,104,69,108,101,
-109,101,110,116,40,39,115,99,114,105,112,116,39,41,59,32,60,109,101,116,97,32,
-112,114,111,112,101,114,116,121,61,34,111,103,58,208,145,209,138,208,187,208,179
-,208,176,209,128,209,129,208,186,208,184,10,32,116,121,112,101,61,34,116,101,120
-,116,34,32,110,97,109,101,61,34,62,80,114,105,118,97,99,121,32,80,111,108,105,99
-,121,60,47,97,62,97,100,109,105,110,105,115,116,101,114,101,100,32,98,121,32,116
-,104,101,101,110,97,98,108,101,83,105,110,103,108,101,82,101,113,117,101,115,116
-,115,116,121,108,101,61,38,113,117,111,116,59,109,97,114,103,105,110,58,60,47,
-100,105,118,62,60,47,100,105,118,62,60,47,100,105,118,62,60,62,60,105,109,103,32
-,115,114,99,61,34,104,116,116,112,58,47,47,105,32,115,116,121,108,101,61,38,113,
-117,111,116,59,102,108,111,97,116,58,114,101,102,101,114,114,101,100,32,116,111,
-32,97,115,32,116,104,101,32,116,111,116,97,108,32,112,111,112,117,108,97,116,105
-,111,110,32,111,102,105,110,32,87,97,115,104,105,110,103,116,111,110,44,32,68,46
-,67,46,32,115,116,121,108,101,61,34,98,97,99,107,103,114,111,117,110,100,45,97,
-109,111,110,103,32,111,116,104,101,114,32,116,104,105,110,103,115,44,111,114,103
-,97,110,105,122,97,116,105,111,110,32,111,102,32,116,104,101,112,97,114,116,105,
-99,105,112,97,116,101,100,32,105,110,32,116,104,101,116,104,101,32,105,110,116,
-114,111,100,117,99,116,105,111,110,32,111,102,105,100,101,110,116,105,102,105,
-101,100,32,119,105,116,104,32,116,104,101,102,105,99,116,105,111,110,97,108,32,
-99,104,97,114,97,99,116,101,114,32,79,120,102,111,114,100,32,85,110,105,118,101,
-114,115,105,116,121,32,109,105,115,117,110,100,101,114,115,116,97,110,100,105,
-110,103,32,111,102,84,104,101,114,101,32,97,114,101,44,32,104,111,119,101,118,
-101,114,44,115,116,121,108,101,115,104,101,101,116,34,32,104,114,101,102,61,34,
-47,67,111,108,117,109,98,105,97,32,85,110,105,118,101,114,115,105,116,121,101,
-120,112,97,110,100,101,100,32,116,111,32,105,110,99,108,117,100,101,117,115,117,
-97,108,108,121,32,114,101,102,101,114,114,101,100,32,116,111,105,110,100,105,99,
-97,116,105,110,103,32,116,104,97,116,32,116,104,101,104,97,118,101,32,115,117,
-103,103,101,115,116,101,100,32,116,104,97,116,97,102,102,105,108,105,97,116,101,
-100,32,119,105,116,104,32,116,104,101,99,111,114,114,101,108,97,116,105,111,110,
-32,98,101,116,119,101,101,110,110,117,109,98,101,114,32,111,102,32,100,105,102,
-102,101,114,101,110,116,62,60,47,116,100,62,60,47,116,114,62,60,47,116,97,98,108
-,101,62,82,101,112,117,98,108,105,99,32,111,102,32,73,114,101,108,97,110,100,10,
-60,47,115,99,114,105,112,116,62,10,60,115,99,114,105,112,116,32,117,110,100,101,
-114,32,116,104,101,32,105,110,102,108,117,101,110,99,101,99,111,110,116,114,105,
-98,117,116,105,111,110,32,116,111,32,116,104,101,79,102,102,105,99,105,97,108,32
-,119,101,98,115,105,116,101,32,111,102,104,101,97,100,113,117,97,114,116,101,114
-,115,32,111,102,32,116,104,101,99,101,110,116,101,114,101,100,32,97,114,111,117,
-110,100,32,116,104,101,105,109,112,108,105,99,97,116,105,111,110,115,32,111,102,
-32,116,104,101,104,97,118,101,32,98,101,101,110,32,100,101,118,101,108,111,112,
-101,100,70,101,100,101,114,97,108,32,82,101,112,117,98,108,105,99,32,111,102,98,
-101,99,97,109,101,32,105,110,99,114,101,97,115,105,110,103,108,121,99,111,110,
-116,105,110,117,97,116,105,111,110,32,111,102,32,116,104,101,78,111,116,101,44,
-32,104,111,119,101,118,101,114,44,32,116,104,97,116,115,105,109,105,108,97,114,
-32,116,111,32,116,104,97,116,32,111,102,32,99,97,112,97,98,105,108,105,116,105,
-101,115,32,111,102,32,116,104,101,97,99,99,111,114,100,97,110,99,101,32,119,105,
-116,104,32,116,104,101,112,97,114,116,105,99,105,112,97,110,116,115,32,105,110,
-32,116,104,101,102,117,114,116,104,101,114,32,100,101,118,101,108,111,112,109,
-101,110,116,117,110,100,101,114,32,116,104,101,32,100,105,114,101,99,116,105,111
-,110,105,115,32,111,102,116,101,110,32,99,111,110,115,105,100,101,114,101,100,
-104,105,115,32,121,111,117,110,103,101,114,32,98,114,111,116,104,101,114,60,47,
-116,100,62,60,47,116,114,62,60,47,116,97,98,108,101,62,60,97,32,104,116,116,112,
-45,101,113,117,105,118,61,34,88,45,85,65,45,112,104,121,115,105,99,97,108,32,112
-,114,111,112,101,114,116,105,101,115,111,102,32,66,114,105,116,105,115,104,32,67
-,111,108,117,109,98,105,97,104,97,115,32,98,101,101,110,32,99,114,105,116,105,99
-,105,122,101,100,40,119,105,116,104,32,116,104,101,32,101,120,99,101,112,116,105
-,111,110,113,117,101,115,116,105,111,110,115,32,97,98,111,117,116,32,116,104,101
-,112,97,115,115,105,110,103,32,116,104,114,111,117,103,104,32,116,104,101,48,34,
-32,99,101,108,108,112,97,100,100,105,110,103,61,34,48,34,32,116,104,111,117,115,
-97,110,100,115,32,111,102,32,112,101,111,112,108,101,114,101,100,105,114,101,99,
-116,115,32,104,101,114,101,46,32,70,111,114,104,97,118,101,32,99,104,105,108,100
-,114,101,110,32,117,110,100,101,114,37,51,69,37,51,67,47,115,99,114,105,112,116,
-37,51,69,34,41,41,59,60,97,32,104,114,101,102,61,34,104,116,116,112,58,47,47,119
-,119,119,46,60,108,105,62,60,97,32,104,114,101,102,61,34,104,116,116,112,58,47,
-47,115,105,116,101,95,110,97,109,101,34,32,99,111,110,116,101,110,116,61,34,116,
-101,120,116,45,100,101,99,111,114,97,116,105,111,110,58,110,111,110,101,115,116,
-121,108,101,61,34,100,105,115,112,108,97,121,58,32,110,111,110,101,60,109,101,
-116,97,32,104,116,116,112,45,101,113,117,105,118,61,34,88,45,110,101,119,32,68,
-97,116,101,40,41,46,103,101,116,84,105,109,101,40,41,32,116,121,112,101,61,34,
-105,109,97,103,101,47,120,45,105,99,111,110,34,60,47,115,112,97,110,62,60,115,
-112,97,110,32,99,108,97,115,115,61,34,108,97,110,103,117,97,103,101,61,34,106,97
-,118,97,115,99,114,105,112,116,119,105,110,100,111,119,46,108,111,99,97,116,105,
-111,110,46,104,114,101,102,60,97,32,104,114,101,102,61,34,106,97,118,97,115,99,
-114,105,112,116,58,45,45,62,13,10,60,115,99,114,105,112,116,32,116,121,112,101,
-61,34,116,60,97,32,104,114,101,102,61,39,104,116,116,112,58,47,47,119,119,119,46
-,104,111,114,116,99,117,116,32,105,99,111,110,34,32,104,114,101,102,61,34,60,47,
-100,105,118,62,13,10,60,100,105,118,32,99,108,97,115,115,61,34,60,115,99,114,105
-,112,116,32,115,114,99,61,34,104,116,116,112,58,47,47,34,32,114,101,108,61,34,
-115,116,121,108,101,115,104,101,101,116,34,32,116,60,47,100,105,118,62,10,60,115
-,99,114,105,112,116,32,116,121,112,101,61,47,97,62,32,60,97,32,104,114,101,102,
-61,34,104,116,116,112,58,47,47,32,97,108,108,111,119,84,114,97,110,115,112,97,
-114,101,110,99,121,61,34,88,45,85,65,45,67,111,109,112,97,116,105,98,108,101,34,
-32,99,111,110,114,101,108,97,116,105,111,110,115,104,105,112,32,98,101,116,119,
-101,101,110,10,60,47,115,99,114,105,112,116,62,13,10,60,115,99,114,105,112,116,
-32,60,47,97,62,60,47,108,105,62,60,47,117,108,62,60,47,100,105,118,62,97,115,115
-,111,99,105,97,116,101,100,32,119,105,116,104,32,116,104,101,32,112,114,111,103,
-114,97,109,109,105,110,103,32,108,97,110,103,117,97,103,101,60,47,97,62,60,97,32
-,104,114,101,102,61,34,104,116,116,112,58,47,47,60,47,97,62,60,47,108,105,62,60,
-108,105,32,99,108,97,115,115,61,34,102,111,114,109,32,97,99,116,105,111,110,61,
-34,104,116,116,112,58,47,47,60,100,105,118,32,115,116,121,108,101,61,34,100,105,
-115,112,108,97,121,58,116,121,112,101,61,34,116,101,120,116,34,32,110,97,109,101
-,61,34,113,34,60,116,97,98,108,101,32,119,105,100,116,104,61,34,49,48,48,37,34,
-32,98,97,99,107,103,114,111,117,110,100,45,112,111,115,105,116,105,111,110,58,34
-,32,98,111,114,100,101,114,61,34,48,34,32,119,105,100,116,104,61,34,114,101,108,
-61,34,115,104,111,114,116,99,117,116,32,105,99,111,110,34,32,104,54,62,60,117,
-108,62,60,108,105,62,60,97,32,104,114,101,102,61,34,32,32,60,109,101,116,97,32,
-104,116,116,112,45,101,113,117,105,118,61,34,99,115,115,34,32,109,101,100,105,97
-,61,34,115,99,114,101,101,110,34,32,114,101,115,112,111,110,115,105,98,108,101,
-32,102,111,114,32,116,104,101,32,34,32,116,121,112,101,61,34,97,112,112,108,105,
-99,97,116,105,111,110,47,34,32,115,116,121,108,101,61,34,98,97,99,107,103,114,
-111,117,110,100,45,104,116,109,108,59,32,99,104,97,114,115,101,116,61,117,116,
-102,45,56,34,32,97,108,108,111,119,116,114,97,110,115,112,97,114,101,110,99,121,
-61,34,115,116,121,108,101,115,104,101,101,116,34,32,116,121,112,101,61,34,116,
-101,13,10,60,109,101,116,97,32,104,116,116,112,45,101,113,117,105,118,61,34,62,
-60,47,115,112,97,110,62,60,115,112,97,110,32,99,108,97,115,115,61,34,48,34,32,99
-,101,108,108,115,112,97,99,105,110,103,61,34,48,34,62,59,10,60,47,115,99,114,105
-,112,116,62,10,60,115,99,114,105,112,116,32,115,111,109,101,116,105,109,101,115,
-32,99,97,108,108,101,100,32,116,104,101,100,111,101,115,32,110,111,116,32,110,
-101,99,101,115,115,97,114,105,108,121,70,111,114,32,109,111,114,101,32,105,110,
-102,111,114,109,97,116,105,111,110,97,116,32,116,104,101,32,98,101,103,105,110,
-110,105,110,103,32,111,102,32,60,33,68,79,67,84,89,80,69,32,104,116,109,108,62,
-60,104,116,109,108,112,97,114,116,105,99,117,108,97,114,108,121,32,105,110,32,
-116,104,101,32,116,121,112,101,61,34,104,105,100,100,101,110,34,32,110,97,109,
-101,61,34,106,97,118,97,115,99,114,105,112,116,58,118,111,105,100,40,48,41,59,34
-,101,102,102,101,99,116,105,118,101,110,101,115,115,32,111,102,32,116,104,101,32
-,97,117,116,111,99,111,109,112,108,101,116,101,61,34,111,102,102,34,32,103,101,
-110,101,114,97,108,108,121,32,99,111,110,115,105,100,101,114,101,100,62,60,105,
-110,112,117,116,32,116,121,112,101,61,34,116,101,120,116,34,32,34,62,60,47,115,
-99,114,105,112,116,62,13,10,60,115,99,114,105,112,116,116,104,114,111,117,103,
-104,111,117,116,32,116,104,101,32,119,111,114,108,100,99,111,109,109,111,110,32,
-109,105,115,99,111,110,99,101,112,116,105,111,110,97,115,115,111,99,105,97,116,
-105,111,110,32,119,105,116,104,32,116,104,101,60,47,100,105,118,62,10,60,47,100,
-105,118,62,10,60,100,105,118,32,99,100,117,114,105,110,103,32,104,105,115,32,108
-,105,102,101,116,105,109,101,44,99,111,114,114,101,115,112,111,110,100,105,110,
-103,32,116,111,32,116,104,101,116,121,112,101,61,34,105,109,97,103,101,47,120,45
-,105,99,111,110,34,32,97,110,32,105,110,99,114,101,97,115,105,110,103,32,110,117
-,109,98,101,114,100,105,112,108,111,109,97,116,105,99,32,114,101,108,97,116,105,
-111,110,115,97,114,101,32,111,102,116,101,110,32,99,111,110,115,105,100,101,114,
-101,100,109,101,116,97,32,99,104,97,114,115,101,116,61,34,117,116,102,45,56,34,
-32,60,105,110,112,117,116,32,116,121,112,101,61,34,116,101,120,116,34,32,101,120
-,97,109,112,108,101,115,32,105,110,99,108,117,100,101,32,116,104,101,34,62,60,
-105,109,103,32,115,114,99,61,34,104,116,116,112,58,47,47,105,112,97,114,116,105,
-99,105,112,97,116,105,111,110,32,105,110,32,116,104,101,116,104,101,32,101,115,
-116,97,98,108,105,115,104,109,101,110,116,32,111,102,10,60,47,100,105,118,62,10,
-60,100,105,118,32,99,108,97,115,115,61,34,38,97,109,112,59,110,98,115,112,59,38,
-97,109,112,59,110,98,115,112,59,116,111,32,100,101,116,101,114,109,105,110,101,
-32,119,104,101,116,104,101,114,113,117,105,116,101,32,100,105,102,102,101,114,
-101,110,116,32,102,114,111,109,109,97,114,107,101,100,32,116,104,101,32,98,101,
-103,105,110,110,105,110,103,100,105,115,116,97,110,99,101,32,98,101,116,119,101,
-101,110,32,116,104,101,99,111,110,116,114,105,98,117,116,105,111,110,115,32,116,
-111,32,116,104,101,99,111,110,102,108,105,99,116,32,98,101,116,119,101,101,110,
-32,116,104,101,119,105,100,101,108,121,32,99,111,110,115,105,100,101,114,101,100
-,32,116,111,119,97,115,32,111,110,101,32,111,102,32,116,104,101,32,102,105,114,
-115,116,119,105,116,104,32,118,97,114,121,105,110,103,32,100,101,103,114,101,101
-,115,104,97,118,101,32,115,112,101,99,117,108,97,116,101,100,32,116,104,97,116,
-40,100,111,99,117,109,101,110,116,46,103,101,116,69,108,101,109,101,110,116,112,
-97,114,116,105,99,105,112,97,116,105,110,103,32,105,110,32,116,104,101,111,114,
-105,103,105,110,97,108,108,121,32,100,101,118,101,108,111,112,101,100,101,116,97
-,32,99,104,97,114,115,101,116,61,34,117,116,102,45,56,34,62,32,116,121,112,101,
-61,34,116,101,120,116,47,99,115,115,34,32,47,62,10,105,110,116,101,114,99,104,97
-,110,103,101,97,98,108,121,32,119,105,116,104,109,111,114,101,32,99,108,111,115,
-101,108,121,32,114,101,108,97,116,101,100,115,111,99,105,97,108,32,97,110,100,32
-,112,111,108,105,116,105,99,97,108,116,104,97,116,32,119,111,117,108,100,32,111,
-116,104,101,114,119,105,115,101,112,101,114,112,101,110,100,105,99,117,108,97,
-114,32,116,111,32,116,104,101,115,116,121,108,101,32,116,121,112,101,61,34,116,
-101,120,116,47,99,115,115,116,121,112,101,61,34,115,117,98,109,105,116,34,32,110
-,97,109,101,61,34,102,97,109,105,108,105,101,115,32,114,101,115,105,100,105,110,
-103,32,105,110,100,101,118,101,108,111,112,105,110,103,32,99,111,117,110,116,114
-,105,101,115,99,111,109,112,117,116,101,114,32,112,114,111,103,114,97,109,109,
-105,110,103,101,99,111,110,111,109,105,99,32,100,101,118,101,108,111,112,109,101
-,110,116,100,101,116,101,114,109,105,110,97,116,105,111,110,32,111,102,32,116,
-104,101,102,111,114,32,109,111,114,101,32,105,110,102,111,114,109,97,116,105,111
-,110,111,110,32,115,101,118,101,114,97,108,32,111,99,99,97,115,105,111,110,115,
-112,111,114,116,117,103,117,195,170,115,32,40,69,117,114,111,112,101,117,41,208,
-163,208,186,209,128,208,176,209,151,208,189,209,129,209,140,208,186,208,176,209,
-131,208,186,209,128,208,176,209,151,208,189,209,129,209,140,208,186,208,176,208,
-160,208,190,209,129,209,129,208,184,208,185,209,129,208,186,208,190,208,185,208,
-188,208,176,209,130,208,181,209,128,208,184,208,176,208,187,208,190,208,178,208,
-184,208,189,209,132,208,190,209,128,208,188,208,176,209,134,208,184,208,184,209,
-131,208,191,209,128,208,176,208,178,208,187,208,181,208,189,208,184,209,143,208,
-189,208,181,208,190,208,177,209,133,208,190,208,180,208,184,208,188,208,190,208,
-184,208,189,209,132,208,190,209,128,208,188,208,176,209,134,208,184,209,143,208,
-152,208,189,209,132,208,190,209,128,208,188,208,176,209,134,208,184,209,143,208,
-160,208,181,209,129,208,191,209,131,208,177,208,187,208,184,208,186,208,184,208,
-186,208,190,208,187,208,184,209,135,208,181,209,129,209,130,208,178,208,190,208,
-184,208,189,209,132,208,190,209,128,208,188,208,176,209,134,208,184,209,142,209,
-130,208,181,209,128,209,128,208,184,209,130,208,190,209,128,208,184,208,184,208,
-180,208,190,209,129,209,130,208,176,209,130,208,190,209,135,208,189,208,190,216,
-167,217,132,217,133,216,170,217,136,216,167,216,172,216,175,217,136,217,134,216,
-167,217,132,216,167,216,180,216,170,216,177,216,167,217,131,216,167,216,170,216,
-167,217,132,216,167,217,130,216,170,216,177,216,167,216,173,216,167,216,170,104,
-116,109,108,59,32,99,104,97,114,115,101,116,61,85,84,70,45,56,34,32,115,101,116,
-84,105,109,101,111,117,116,40,102,117,110,99,116,105,111,110,40,41,100,105,115,
-112,108,97,121,58,105,110,108,105,110,101,45,98,108,111,99,107,59,60,105,110,112
-,117,116,32,116,121,112,101,61,34,115,117,98,109,105,116,34,32,116,121,112,101,
-32,61,32,39,116,101,120,116,47,106,97,118,97,115,99,114,105,60,105,109,103,32,
-115,114,99,61,34,104,116,116,112,58,47,47,119,119,119,46,34,32,34,104,116,116,
-112,58,47,47,119,119,119,46,119,51,46,111,114,103,47,115,104,111,114,116,99,117,
-116,32,105,99,111,110,34,32,104,114,101,102,61,34,34,32,97,117,116,111,99,111,
-109,112,108,101,116,101,61,34,111,102,102,34,32,60,47,97,62,60,47,100,105,118,62
-,60,100,105,118,32,99,108,97,115,115,61,60,47,97,62,60,47,108,105,62,10,60,108,
-105,32,99,108,97,115,115,61,34,99,115,115,34,32,116,121,112,101,61,34,116,101,
-120,116,47,99,115,115,34,32,60,102,111,114,109,32,97,99,116,105,111,110,61,34,
-104,116,116,112,58,47,47,120,116,47,99,115,115,34,32,104,114,101,102,61,34,104,
-116,116,112,58,47,47,108,105,110,107,32,114,101,108,61,34,97,108,116,101,114,110
-,97,116,101,34,32,13,10,60,115,99,114,105,112,116,32,116,121,112,101,61,34,116,
-101,120,116,47,32,111,110,99,108,105,99,107,61,34,106,97,118,97,115,99,114,105,
-112,116,58,40,110,101,119,32,68,97,116,101,41,46,103,101,116,84,105,109,101,40,
-41,125,104,101,105,103,104,116,61,34,49,34,32,119,105,100,116,104,61,34,49,34,32
-,80,101,111,112,108,101,39,115,32,82,101,112,117,98,108,105,99,32,111,102,32,32,
-60,97,32,104,114,101,102,61,34,104,116,116,112,58,47,47,119,119,119,46,116,101,
-120,116,45,100,101,99,111,114,97,116,105,111,110,58,117,110,100,101,114,116,104,
-101,32,98,101,103,105,110,110,105,110,103,32,111,102,32,116,104,101,32,60,47,100
-,105,118,62,10,60,47,100,105,118,62,10,60,47,100,105,118,62,10,101,115,116,97,98
-,108,105,115,104,109,101,110,116,32,111,102,32,116,104,101,32,60,47,100,105,118,
-62,60,47,100,105,118,62,60,47,100,105,118,62,60,47,100,35,118,105,101,119,112,
-111,114,116,123,109,105,110,45,104,101,105,103,104,116,58,10,60,115,99,114,105,
-112,116,32,115,114,99,61,34,104,116,116,112,58,47,47,111,112,116,105,111,110,62,
-60,111,112,116,105,111,110,32,118,97,108,117,101,61,111,102,116,101,110,32,114,
-101,102,101,114,114,101,100,32,116,111,32,97,115,32,47,111,112,116,105,111,110,
-62,10,60,111,112,116,105,111,110,32,118,97,108,117,60,33,68,79,67,84,89,80,69,32
-,104,116,109,108,62,10,60,33,45,45,91,73,110,116,101,114,110,97,116,105,111,110,
-97,108,32,65,105,114,112,111,114,116,62,10,60,97,32,104,114,101,102,61,34,104,
-116,116,112,58,47,47,119,119,119,60,47,97,62,60,97,32,104,114,101,102,61,34,104,
-116,116,112,58,47,47,119,224,184,160,224,184,178,224,184,169,224,184,178,224,185
-,132,224,184,151,224,184,162,225,131,165,225,131,144,225,131,160,225,131,151,225
-,131,163,225,131,154,225,131,152,230,173,163,233,171,148,228,184,173,230,150,135
-,32,40,231,185,129,233,171,148,41,224,164,168,224,164,191,224,164,176,224,165,
-141,224,164,166,224,165,135,224,164,182,224,164,161,224,164,190,224,164,137,224,
-164,168,224,164,178,224,165,139,224,164,161,224,164,149,224,165,141,224,164,183,
-224,165,135,224,164,164,224,165,141,224,164,176,224,164,156,224,164,190,224,164,
-168,224,164,149,224,164,190,224,164,176,224,165,128,224,164,184,224,164,130,224,
-164,172,224,164,130,224,164,167,224,164,191,224,164,164,224,164,184,224,165,141,
-224,164,165,224,164,190,224,164,170,224,164,168,224,164,190,224,164,184,224,165,
-141,224,164,181,224,165,128,224,164,149,224,164,190,224,164,176,224,164,184,224,
-164,130,224,164,184,224,165,141,224,164,149,224,164,176,224,164,163,224,164,184,
-224,164,190,224,164,174,224,164,151,224,165,141,224,164,176,224,165,128,224,164,
-154,224,164,191,224,164,159,224,165,141,224,164,160,224,165,139,224,164,130,224,
-164,181,224,164,191,224,164,156,224,165,141,224,164,158,224,164,190,224,164,168,
-224,164,133,224,164,174,224,165,135,224,164,176,224,164,191,224,164,149,224,164,
-190,224,164,181,224,164,191,224,164,173,224,164,191,224,164,168,224,165,141,224,
-164,168,224,164,151,224,164,190,224,164,161,224,164,191,224,164,175,224,164,190,
-224,164,129,224,164,149,224,165,141,224,164,175,224,165,139,224,164,130,224,164,
-149,224,164,191,224,164,184,224,165,129,224,164,176,224,164,149,224,165,141,224,
-164,183,224,164,190,224,164,170,224,164,185,224,165,129,224,164,129,224,164,154,
-224,164,164,224,165,128,224,164,170,224,165,141,224,164,176,224,164,172,224,164,
-130,224,164,167,224,164,168,224,164,159,224,164,191,224,164,170,224,165,141,224,
-164,170,224,164,163,224,165,128,224,164,149,224,165,141,224,164,176,224,164,191,
-224,164,149,224,165,135,224,164,159,224,164,170,224,165,141,224,164,176,224,164,
-190,224,164,176,224,164,130,224,164,173,224,164,170,224,165,141,224,164,176,224,
-164,190,224,164,170,224,165,141,224,164,164,224,164,174,224,164,190,224,164,178,
-224,164,191,224,164,149,224,165,139,224,164,130,224,164,176,224,164,171,224,164,
-188,224,165,141,224,164,164,224,164,190,224,164,176,224,164,168,224,164,191,224,
-164,176,224,165,141,224,164,174,224,164,190,224,164,163,224,164,178,224,164,191,
-224,164,174,224,164,191,224,164,159,224,165,135,224,164,161,100,101,115,99,114,
-105,112,116,105,111,110,34,32,99,111,110,116,101,110,116,61,34,100,111,99,117,
-109,101,110,116,46,108,111,99,97,116,105,111,110,46,112,114,111,116,46,103,101,
-116,69,108,101,109,101,110,116,115,66,121,84,97,103,78,97,109,101,40,60,33,68,79
-,67,84,89,80,69,32,104,116,109,108,62,10,60,104,116,109,108,32,60,109,101,116,97
-,32,99,104,97,114,115,101,116,61,34,117,116,102,45,56,34,62,58,117,114,108,34,32
-,99,111,110,116,101,110,116,61,34,104,116,116,112,58,47,47,46,99,115,115,34,32,
-114,101,108,61,34,115,116,121,108,101,115,104,101,101,116,34,115,116,121,108,101
-,32,116,121,112,101,61,34,116,101,120,116,47,99,115,115,34,62,116,121,112,101,61
-,34,116,101,120,116,47,99,115,115,34,32,104,114,101,102,61,34,119,51,46,111,114,
-103,47,49,57,57,57,47,120,104,116,109,108,34,32,120,109,108,116,121,112,101,61,
-34,116,101,120,116,47,106,97,118,97,115,99,114,105,112,116,34,32,109,101,116,104
-,111,100,61,34,103,101,116,34,32,97,99,116,105,111,110,61,34,108,105,110,107,32,
-114,101,108,61,34,115,116,121,108,101,115,104,101,101,116,34,32,32,61,32,100,111
-,99,117,109,101,110,116,46,103,101,116,69,108,101,109,101,110,116,116,121,112,
-101,61,34,105,109,97,103,101,47,120,45,105,99,111,110,34,32,47,62,99,101,108,108
-,112,97,100,100,105,110,103,61,34,48,34,32,99,101,108,108,115,112,46,99,115,115,
-34,32,116,121,112,101,61,34,116,101,120,116,47,99,115,115,34,32,60,47,97,62,60,
-47,108,105,62,60,108,105,62,60,97,32,104,114,101,102,61,34,34,32,119,105,100,116
-,104,61,34,49,34,32,104,101,105,103,104,116,61,34,49,34,34,62,60,97,32,104,114,
-101,102,61,34,104,116,116,112,58,47,47,119,119,119,46,115,116,121,108,101,61,34,
-100,105,115,112,108,97,121,58,110,111,110,101,59,34,62,97,108,116,101,114,110,97
-,116,101,34,32,116,121,112,101,61,34,97,112,112,108,105,45,47,47,87,51,67,47,47,
-68,84,68,32,88,72,84,77,76,32,49,46,48,32,101,108,108,115,112,97,99,105,110,103,
-61,34,48,34,32,99,101,108,108,112,97,100,32,116,121,112,101,61,34,104,105,100,
-100,101,110,34,32,118,97,108,117,101,61,34,47,97,62,38,110,98,115,112,59,60,115,
-112,97,110,32,114,111,108,101,61,34,115,10,60,105,110,112,117,116,32,116,121,112
-,101,61,34,104,105,100,100,101,110,34,32,108,97,110,103,117,97,103,101,61,34,74,
-97,118,97,83,99,114,105,112,116,34,32,32,100,111,99,117,109,101,110,116,46,103,
-101,116,69,108,101,109,101,110,116,115,66,103,61,34,48,34,32,99,101,108,108,115,
-112,97,99,105,110,103,61,34,48,34,32,121,112,101,61,34,116,101,120,116,47,99,115
-,115,34,32,109,101,100,105,97,61,34,116,121,112,101,61,39,116,101,120,116,47,106
-,97,118,97,115,99,114,105,112,116,39,119,105,116,104,32,116,104,101,32,101,120,
-99,101,112,116,105,111,110,32,111,102,32,121,112,101,61,34,116,101,120,116,47,99
-,115,115,34,32,114,101,108,61,34,115,116,32,104,101,105,103,104,116,61,34,49,34,
-32,119,105,100,116,104,61,34,49,34,32,61,39,43,101,110,99,111,100,101,85,82,73,
-67,111,109,112,111,110,101,110,116,40,60,108,105,110,107,32,114,101,108,61,34,97
-,108,116,101,114,110,97,116,101,34,32,10,98,111,100,121,44,32,116,114,44,32,105,
-110,112,117,116,44,32,116,101,120,116,109,101,116,97,32,110,97,109,101,61,34,114
-,111,98,111,116,115,34,32,99,111,110,109,101,116,104,111,100,61,34,112,111,115,
-116,34,32,97,99,116,105,111,110,61,34,62,10,60,97,32,104,114,101,102,61,34,104,
-116,116,112,58,47,47,119,119,119,46,99,115,115,34,32,114,101,108,61,34,115,116,
-121,108,101,115,104,101,101,116,34,32,60,47,100,105,118,62,60,47,100,105,118,62,
-60,100,105,118,32,99,108,97,115,115,108,97,110,103,117,97,103,101,61,34,106,97,
-118,97,115,99,114,105,112,116,34,62,97,114,105,97,45,104,105,100,100,101,110,61,
-34,116,114,117,101,34,62,194,183,60,114,105,112,116,34,32,116,121,112,101,61,34,
-116,101,120,116,47,106,97,118,97,115,108,61,48,59,125,41,40,41,59,10,40,102,117,
-110,99,116,105,111,110,40,41,123,98,97,99,107,103,114,111,117,110,100,45,105,109
-,97,103,101,58,32,117,114,108,40,47,97,62,60,47,108,105,62,60,108,105,62,60,97,
-32,104,114,101,102,61,34,104,9,9,60,108,105,62,60,97,32,104,114,101,102,61,34,
-104,116,116,112,58,47,47,97,116,111,114,34,32,97,114,105,97,45,104,105,100,100,
-101,110,61,34,116,114,117,62,32,60,97,32,104,114,101,102,61,34,104,116,116,112,
-58,47,47,119,119,119,46,108,97,110,103,117,97,103,101,61,34,106,97,118,97,115,99
-,114,105,112,116,34,32,47,111,112,116,105,111,110,62,10,60,111,112,116,105,111,
-110,32,118,97,108,117,101,47,100,105,118,62,60,47,100,105,118,62,60,100,105,118,
-32,99,108,97,115,115,61,114,97,116,111,114,34,32,97,114,105,97,45,104,105,100,
-100,101,110,61,34,116,114,101,61,40,110,101,119,32,68,97,116,101,41,46,103,101,
-116,84,105,109,101,40,41,112,111,114,116,117,103,117,195,170,115,32,40,100,111,
-32,66,114,97,115,105,108,41,208,190,209,128,208,179,208,176,208,189,208,184,208,
-183,208,176,209,134,208,184,208,184,208,178,208,190,208,183,208,188,208,190,208,
-182,208,189,208,190,209,129,209,130,209,140,208,190,208,177,209,128,208,176,208,
-183,208,190,208,178,208,176,208,189,208,184,209,143,209,128,208,181,208,179,208,
-184,209,129,209,130,209,128,208,176,209,134,208,184,208,184,208,178,208,190,208,
-183,208,188,208,190,208,182,208,189,208,190,209,129,209,130,208,184,208,190,208,
-177,209,143,208,183,208,176,209,130,208,181,208,187,209,140,208,189,208,176,60,
-33,68,79,67,84,89,80,69,32,104,116,109,108,32,80,85,66,76,73,67,32,34,110,116,45
-,84,121,112,101,34,32,99,111,110,116,101,110,116,61,34,116,101,120,116,47,60,109
-,101,116,97,32,104,116,116,112,45,101,113,117,105,118,61,34,67,111,110,116,101,
-114,97,110,115,105,116,105,111,110,97,108,47,47,69,78,34,32,34,104,116,116,112,
-58,60,104,116,109,108,32,120,109,108,110,115,61,34,104,116,116,112,58,47,47,119,
-119,119,45,47,47,87,51,67,47,47,68,84,68,32,88,72,84,77,76,32,49,46,48,32,84,68,
-84,68,47,120,104,116,109,108,49,45,116,114,97,110,115,105,116,105,111,110,97,108
-,47,47,119,119,119,46,119,51,46,111,114,103,47,84,82,47,120,104,116,109,108,49,
-47,112,101,32,61,32,39,116,101,120,116,47,106,97,118,97,115,99,114,105,112,116,
-39,59,60,109,101,116,97,32,110,97,109,101,61,34,100,101,115,99,114,105,112,116,
-105,111,110,112,97,114,101,110,116,78,111,100,101,46,105,110,115,101,114,116,66,
-101,102,111,114,101,60,105,110,112,117,116,32,116,121,112,101,61,34,104,105,100,
-100,101,110,34,32,110,97,106,115,34,32,116,121,112,101,61,34,116,101,120,116,47,
-106,97,118,97,115,99,114,105,40,100,111,99,117,109,101,110,116,41,46,114,101,97,
-100,121,40,102,117,110,99,116,105,115,99,114,105,112,116,32,116,121,112,101,61,
-34,116,101,120,116,47,106,97,118,97,115,105,109,97,103,101,34,32,99,111,110,116,
-101,110,116,61,34,104,116,116,112,58,47,47,85,65,45,67,111,109,112,97,116,105,98
-,108,101,34,32,99,111,110,116,101,110,116,61,116,109,108,59,32,99,104,97,114,115
-,101,116,61,117,116,102,45,56,34,32,47,62,10,108,105,110,107,32,114,101,108,61,
-34,115,104,111,114,116,99,117,116,32,105,99,111,110,60,108,105,110,107,32,114,
-101,108,61,34,115,116,121,108,101,115,104,101,101,116,34,32,60,47,115,99,114,105
-,112,116,62,10,60,115,99,114,105,112,116,32,116,121,112,101,61,61,32,100,111,99,
-117,109,101,110,116,46,99,114,101,97,116,101,69,108,101,109,101,110,60,97,32,116
-,97,114,103,101,116,61,34,95,98,108,97,110,107,34,32,104,114,101,102,61,32,100,
-111,99,117,109,101,110,116,46,103,101,116,69,108,101,109,101,110,116,115,66,105,
-110,112,117,116,32,116,121,112,101,61,34,116,101,120,116,34,32,110,97,109,101,61
-,97,46,116,121,112,101,32,61,32,39,116,101,120,116,47,106,97,118,97,115,99,114,
-105,110,112,117,116,32,116,121,112,101,61,34,104,105,100,100,101,110,34,32,110,
-97,109,101,104,116,109,108,59,32,99,104,97,114,115,101,116,61,117,116,102,45,56,
-34,32,47,62,100,116,100,34,62,10,60,104,116,109,108,32,120,109,108,110,115,61,34
-,104,116,116,112,45,47,47,87,51,67,47,47,68,84,68,32,72,84,77,76,32,52,46,48,49,
-32,84,101,110,116,115,66,121,84,97,103,78,97,109,101,40,39,115,99,114,105,112,
-116,39,41,105,110,112,117,116,32,116,121,112,101,61,34,104,105,100,100,101,110,
-34,32,110,97,109,60,115,99,114,105,112,116,32,116,121,112,101,61,34,116,101,120,
-116,47,106,97,118,97,115,34,32,115,116,121,108,101,61,34,100,105,115,112,108,97,
-121,58,110,111,110,101,59,34,62,100,111,99,117,109,101,110,116,46,103,101,116,69
-,108,101,109,101,110,116,66,121,73,100,40,61,100,111,99,117,109,101,110,116,46,
-99,114,101,97,116,101,69,108,101,109,101,110,116,40,39,32,116,121,112,101,61,39,
-116,101,120,116,47,106,97,118,97,115,99,114,105,112,116,39,105,110,112,117,116,
-32,116,121,112,101,61,34,116,101,120,116,34,32,110,97,109,101,61,34,100,46,103,
-101,116,69,108,101,109,101,110,116,115,66,121,84,97,103,78,97,109,101,40,115,110
-,105,99,97,108,34,32,104,114,101,102,61,34,104,116,116,112,58,47,47,119,119,119,
-46,67,47,47,68,84,68,32,72,84,77,76,32,52,46,48,49,32,84,114,97,110,115,105,116,
-60,115,116,121,108,101,32,116,121,112,101,61,34,116,101,120,116,47,99,115,115,34
-,62,10,10,60,115,116,121,108,101,32,116,121,112,101,61,34,116,101,120,116,47,99,
-115,115,34,62,105,111,110,97,108,46,100,116,100,34,62,10,60,104,116,109,108,32,
-120,109,108,110,115,61,104,116,116,112,45,101,113,117,105,118,61,34,67,111,110,
-116,101,110,116,45,84,121,112,101,100,105,110,103,61,34,48,34,32,99,101,108,108,
-115,112,97,99,105,110,103,61,34,48,34,104,116,109,108,59,32,99,104,97,114,115,
-101,116,61,117,116,102,45,56,34,32,47,62,10,32,115,116,121,108,101,61,34,100,105
-,115,112,108,97,121,58,110,111,110,101,59,34,62,60,60,108,105,62,60,97,32,104,
-114,101,102,61,34,104,116,116,112,58,47,47,119,119,119,46,32,116,121,112,101,61,
-39,116,101,120,116,47,106,97,118,97,115,99,114,105,112,116,39,62,208,180,208,181
-,209,143,209,130,208,181,208,187,209,140,208,189,208,190,209,129,209,130,208,184
-,209,129,208,190,208,190,209,130,208,178,208,181,209,130,209,129,209,130,208,178
-,208,184,208,184,208,191,209,128,208,190,208,184,208,183,208,178,208,190,208,180
-,209,129,209,130,208,178,208,176,208,177,208,181,208,183,208,190,208,191,208,176
-,209,129,208,189,208,190,209,129,209,130,208,184,224,164,170,224,165,129,224,164
-,184,224,165,141,224,164,164,224,164,191,224,164,149,224,164,190,224,164,149,224
-,164,190,224,164,130,224,164,151,224,165,141,224,164,176,224,165,135,224,164,184
-,224,164,137,224,164,168,224,165,141,224,164,185,224,165,139,224,164,130,224,164
-,168,224,165,135,224,164,181,224,164,191,224,164,167,224,164,190,224,164,168,224
-,164,184,224,164,173,224,164,190,224,164,171,224,164,191,224,164,149,224,165,141
-,224,164,184,224,164,191,224,164,130,224,164,151,224,164,184,224,165,129,224,164
-,176,224,164,149,224,165,141,224,164,183,224,164,191,224,164,164,224,164,149,224
-,165,137,224,164,170,224,165,128,224,164,176,224,164,190,224,164,135,224,164,159
-,224,164,181,224,164,191,224,164,156,224,165,141,224,164,158,224,164,190,224,164
-,170,224,164,168,224,164,149,224,164,190,224,164,176,224,165,141,224,164,176,224
-,164,181,224,164,190,224,164,136,224,164,184,224,164,149,224,165,141,224,164,176
-,224,164,191,224,164,175,224,164,164,224,164,190
-}
-/* GENERATED CODE END */
-;
-#endif  /* !BROTLI_EXTERNAL_DICTIONARY_DATA */
-
-#if !defined(BROTLI_EXTERNAL_DICTIONARY_DATA)
-static const BrotliDictionary kBrotliDictionary = {
-#else
-static BrotliDictionary kBrotliDictionary = {
-#endif
-  /* size_bits_by_length */
-  {
-    0, 0, 0, 0, 10, 10, 11, 11,
-    10, 10, 10, 10, 10, 9, 9, 8,
-    7, 7, 8, 7, 7, 6, 6, 5,
-    5, 0, 0, 0, 0, 0, 0, 0
-  },
-
-  /* offsets_by_length */
-  {
-    0, 0, 0, 0, 0, 4096, 9216, 21504,
-    35840, 44032, 53248, 63488, 74752, 87040, 93696, 100864,
-    104704, 106752, 108928, 113536, 115968, 118528, 119872, 121280,
-    122016, 122784, 122784, 122784, 122784, 122784, 122784, 122784
-  },
-
-  /* data_size ==  sizeof(kBrotliDictionaryData) */
-  122784,
-
-  /* data */
-#if defined(BROTLI_EXTERNAL_DICTIONARY_DATA)
-  NULL
-#else
-  kBrotliDictionaryData
-#endif
-};
-
-const BrotliDictionary* duckdb_brotli::BrotliGetDictionary(void) {
-  return &kBrotliDictionary;
-}
-
-void duckdb_brotli::BrotliSetDictionaryData(const uint8_t* data) {
-#if defined(BROTLI_EXTERNAL_DICTIONARY_DATA)
-  if (!!data && !kBrotliDictionary.data) {
-    kBrotliDictionary.data = data;
-  }
-#else
-  BROTLI_UNUSED(data);  // Appease -Werror=unused-parameter
-#endif
-}
-
-
diff --git a/src/duckdb/third_party/brotli/common/dictionary.h b/src/duckdb/third_party/brotli/common/dictionary.h
deleted file mode 100644
index 5afa77604..000000000
--- a/src/duckdb/third_party/brotli/common/dictionary.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Collection of static dictionary words. */
-
-#ifndef BROTLI_COMMON_DICTIONARY_H_
-#define BROTLI_COMMON_DICTIONARY_H_
-
-#include <brotli/port.h>
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-typedef struct BrotliDictionary {
-  /**
-   * Number of bits to encode index of dictionary word in a bucket.
-   *
-   * Specification: Appendix A. Static Dictionary Data
-   *
-   * Words in a dictionary are bucketed by length.
-   * @c 0 means that there are no words of a given length.
-   * Dictionary consists of words with length of [4..24] bytes.
-   * Values at [0..3] and [25..31] indices should not be addressed.
-   */
-  uint8_t size_bits_by_length[32];
-
-  /* assert(offset[i + 1] == offset[i] + (bits[i] ? (i << bits[i]) : 0)) */
-  uint32_t offsets_by_length[32];
-
-  /* assert(data_size == offsets_by_length[31]) */
-  size_t data_size;
-
-  /* Data array is not bound, and should obey to size_bits_by_length values.
-     Specified size matches default (RFC 7932) dictionary. Its size is
-     defined by data_size */
-  const uint8_t* data;
-} BrotliDictionary;
-
-BROTLI_COMMON_API const BrotliDictionary* BrotliGetDictionary(void);
-
-/**
- * Sets dictionary data.
- *
- * When dictionary data is already set / present, this method is no-op.
- *
- * Dictionary data MUST be provided before BrotliGetDictionary is invoked.
- * This method is used ONLY in multi-client environment (e.g. C + Java),
- * to reduce storage by sharing single dictionary between implementations.
- */
-BROTLI_COMMON_API void BrotliSetDictionaryData(const uint8_t* data);
-
-#define BROTLI_MIN_DICTIONARY_WORD_LENGTH 4
-#define BROTLI_MAX_DICTIONARY_WORD_LENGTH 24
-
-}
-
-#endif  /* BROTLI_COMMON_DICTIONARY_H_ */
diff --git a/src/duckdb/third_party/brotli/common/platform.cpp b/src/duckdb/third_party/brotli/common/platform.cpp
deleted file mode 100644
index fd09ac025..000000000
--- a/src/duckdb/third_party/brotli/common/platform.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include <stdlib.h>
-
-#include <brotli/types.h>
-
-#include "brotli_platform.h"
-
-
-/* Default brotli_alloc_func */
-void*  duckdb_brotli::BrotliDefaultAllocFunc(void* opaque, size_t size) {
-  BROTLI_UNUSED(opaque);
-  return malloc(size);
-}
-
-/* Default brotli_free_func */
-void  duckdb_brotli::BrotliDefaultFreeFunc(void* opaque, void* address) {
-  BROTLI_UNUSED(opaque);
-  free(address);
-}
diff --git a/src/duckdb/third_party/brotli/common/shared_dictionary.cpp b/src/duckdb/third_party/brotli/common/shared_dictionary.cpp
deleted file mode 100644
index 3b951c989..000000000
--- a/src/duckdb/third_party/brotli/common/shared_dictionary.cpp
+++ /dev/null
@@ -1,517 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Shared Dictionary definition and utilities. */
-
-#include <brotli/shared_dictionary.h>
-
-#include <memory.h>
-#include <stdlib.h>  /* malloc, free */
-#include <stdio.h>
-
-#include "dictionary.h"
-#include "brotli_platform.h"
-#include "shared_dictionary_internal.h"
-
-using namespace duckdb_brotli;
-
-#if defined(BROTLI_EXPERIMENTAL)
-
-#define BROTLI_NUM_ENCODED_LENGTHS (SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH \
-    - SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH + 1)
-
-/* Max allowed by spec */
-#define BROTLI_MAX_SIZE_BITS 15u
-
-/* Returns BROTLI_TRUE on success, BROTLI_FALSE on failure. */
-static BROTLI_BOOL ReadBool(const uint8_t* encoded, size_t size, size_t* pos,
-    BROTLI_BOOL* result) {
-  uint8_t value;
-  size_t position = *pos;
-  if (position >= size) return BROTLI_FALSE;  /* past file end */
-  value = encoded[position++];
-  if (value > 1) return BROTLI_FALSE;  /* invalid bool */
-  *result = TO_BROTLI_BOOL(value);
-  *pos = position;
-  return BROTLI_TRUE;  /* success */
-}
-
-/* Returns BROTLI_TRUE on success, BROTLI_FALSE on failure. */
-static BROTLI_BOOL ReadUint8(const uint8_t* encoded, size_t size, size_t* pos,
-    uint8_t* result) {
-  size_t position = *pos;
-  if (position + sizeof(uint8_t) > size) return BROTLI_FALSE;
-  *result = encoded[position++];
-  *pos = position;
-  return BROTLI_TRUE;
-}
-
-/* Returns BROTLI_TRUE on success, BROTLI_FALSE on failure. */
-static BROTLI_BOOL ReadUint16(const uint8_t* encoded, size_t size, size_t* pos,
-    uint16_t* result) {
-  size_t position = *pos;
-  if (position + sizeof(uint16_t) > size) return BROTLI_FALSE;
-  *result = BROTLI_UNALIGNED_LOAD16LE(&encoded[position]);
-  position += 2;
-  *pos = position;
-  return BROTLI_TRUE;
-}
-
-/* Reads a varint into a uint32_t, and returns error if it's too large */
-/* Returns BROTLI_TRUE on success, BROTLI_FALSE on failure. */
-static BROTLI_BOOL ReadVarint32(const uint8_t* encoded, size_t size,
-    size_t* pos, uint32_t* result) {
-  int num = 0;
-  uint8_t byte;
-  *result = 0;
-  for (;;) {
-    if (*pos >= size) return BROTLI_FALSE;
-    byte = encoded[(*pos)++];
-    if (num == 4 && byte > 15) return BROTLI_FALSE;
-    *result |= (uint32_t)(byte & 127) << (num * 7);
-    if (byte < 128) return BROTLI_TRUE;
-    num++;
-  }
-}
-
-/* Returns the total length of word list. */
-static size_t BrotliSizeBitsToOffsets(const uint8_t* size_bits_by_length,
-    uint32_t* offsets_by_length) {
-  uint32_t pos = 0;
-  uint32_t i;
-  for (i = 0; i <= SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH; i++) {
-    offsets_by_length[i] = pos;
-    if (size_bits_by_length[i] != 0) {
-      pos += i << size_bits_by_length[i];
-    }
-  }
-  return pos;
-}
-
-static BROTLI_BOOL ParseWordList(size_t size, const uint8_t* encoded,
-    size_t* pos, BrotliDictionary* out) {
-  size_t offset;
-  size_t i;
-  size_t position = *pos;
-  if (position + BROTLI_NUM_ENCODED_LENGTHS > size) {
-    return BROTLI_FALSE;
-  }
-
-  memset(out->size_bits_by_length, 0, SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH);
-  memcpy(out->size_bits_by_length + SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH,
-      &encoded[position], BROTLI_NUM_ENCODED_LENGTHS);
-  for (i = SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH;
-      i <= SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH; i++) {
-    if (out->size_bits_by_length[i] > BROTLI_MAX_SIZE_BITS) {
-      return BROTLI_FALSE;
-    }
-  }
-  position += BROTLI_NUM_ENCODED_LENGTHS;
-  offset = BrotliSizeBitsToOffsets(
-      out->size_bits_by_length, out->offsets_by_length);
-
-  out->data = &encoded[position];
-  out->data_size = offset;
-  position += offset;
-  if (position > size) return BROTLI_FALSE;
-  *pos = position;
-  return BROTLI_TRUE;
-}
-
-/* Computes the cutOffTransforms of a BrotliTransforms which already has the
-   transforms data correctly filled in. */
-static void ComputeCutoffTransforms(BrotliTransforms* transforms) {
-  uint32_t i;
-  for (i = 0; i < BROTLI_TRANSFORMS_MAX_CUT_OFF + 1; i++) {
-    transforms->cutOffTransforms[i] = -1;
-  }
-  for (i = 0; i < transforms->num_transforms; i++) {
-    const uint8_t* prefix = BROTLI_TRANSFORM_PREFIX(transforms, i);
-    uint8_t type = BROTLI_TRANSFORM_TYPE(transforms, i);
-    const uint8_t* suffix = BROTLI_TRANSFORM_SUFFIX(transforms, i);
-    if (type <= BROTLI_TRANSFORM_OMIT_LAST_9 && *prefix == 0 && *suffix == 0 &&
-        transforms->cutOffTransforms[type] == -1) {
-      transforms->cutOffTransforms[type] = (int16_t)i;
-    }
-  }
-}
-
-static BROTLI_BOOL ParsePrefixSuffixTable(size_t size, const uint8_t* encoded,
-    size_t* pos, BrotliTransforms* out, uint16_t* out_table,
-    size_t* out_table_size) {
-  size_t position = *pos;
-  size_t offset = 0;
-  size_t stringlet_count = 0;  /* NUM_PREFIX_SUFFIX */
-  size_t data_length = 0;
-
-  /* PREFIX_SUFFIX_LENGTH */
-  if (!ReadUint16(encoded, size, &position, &out->prefix_suffix_size)) {
-    return BROTLI_FALSE;
-  }
-  data_length = out->prefix_suffix_size;
-
-  /* Must at least have space for null terminator. */
-  if (data_length < 1) return BROTLI_FALSE;
-  out->prefix_suffix = &encoded[position];
-  if (position + data_length >= size) return BROTLI_FALSE;
-  while (BROTLI_TRUE) {
-    /* STRING_LENGTH */
-    size_t stringlet_len = encoded[position + offset];
-    out_table[stringlet_count] = (uint16_t)offset;
-    stringlet_count++;
-    offset++;
-    if (stringlet_len == 0) {
-      if (offset == data_length) {
-        break;
-      } else {
-        return BROTLI_FALSE;
-      }
-    }
-    if (stringlet_count > 255) return BROTLI_FALSE;
-    offset += stringlet_len;
-    if (offset >= data_length) return BROTLI_FALSE;
-  }
-
-  position += data_length;
-  *pos = position;
-  *out_table_size = (uint16_t)stringlet_count;
-  return BROTLI_TRUE;
-}
-
-static BROTLI_BOOL ParseTransformsList(size_t size, const uint8_t* encoded,
-    size_t* pos, BrotliTransforms* out, uint16_t* prefix_suffix_table,
-    size_t* prefix_suffix_count) {
-  uint32_t i;
-  BROTLI_BOOL has_params = BROTLI_FALSE;
-  BROTLI_BOOL prefix_suffix_ok = BROTLI_FALSE;
-  size_t position = *pos;
-  size_t stringlet_cnt = 0;
-  if (position >= size) return BROTLI_FALSE;
-
-  prefix_suffix_ok = ParsePrefixSuffixTable(
-      size, encoded, &position, out, prefix_suffix_table, &stringlet_cnt);
-  if (!prefix_suffix_ok) return BROTLI_FALSE;
-  out->prefix_suffix_map = prefix_suffix_table;
-  *prefix_suffix_count = stringlet_cnt;
-
-  out->num_transforms = encoded[position++];
-  out->transforms = &encoded[position];
-  position += (size_t)out->num_transforms * 3;
-  if (position > size) return BROTLI_FALSE;
-  /* Check for errors and read extra parameters. */
-  for (i = 0; i < out->num_transforms; i++) {
-    uint8_t prefix_id = BROTLI_TRANSFORM_PREFIX_ID(out, i);
-    uint8_t type = BROTLI_TRANSFORM_TYPE(out, i);
-    uint8_t suffix_id = BROTLI_TRANSFORM_SUFFIX_ID(out, i);
-    if (prefix_id >= stringlet_cnt) return BROTLI_FALSE;
-    if (type >= BROTLI_NUM_TRANSFORM_TYPES) return BROTLI_FALSE;
-    if (suffix_id >= stringlet_cnt) return BROTLI_FALSE;
-    if (type == BROTLI_TRANSFORM_SHIFT_FIRST ||
-        type == BROTLI_TRANSFORM_SHIFT_ALL) {
-      has_params = BROTLI_TRUE;
-    }
-  }
-  if (has_params) {
-    out->params = &encoded[position];
-    position += (size_t)out->num_transforms * 2;
-    if (position > size) return BROTLI_FALSE;
-    for (i = 0; i < out->num_transforms; i++) {
-      uint8_t type = BROTLI_TRANSFORM_TYPE(out, i);
-      if (type != BROTLI_TRANSFORM_SHIFT_FIRST &&
-          type != BROTLI_TRANSFORM_SHIFT_ALL) {
-        if (out->params[i * 2] != 0 || out->params[i * 2 + 1] != 0) {
-          return BROTLI_FALSE;
-        }
-      }
-    }
-  } else {
-    out->params = NULL;
-  }
-  ComputeCutoffTransforms(out);
-  *pos = position;
-  return BROTLI_TRUE;
-}
-
-static BROTLI_BOOL DryParseDictionary(const uint8_t* encoded,
-    size_t size, uint32_t* num_prefix, BROTLI_BOOL* is_custom_static_dict) {
-  size_t pos = 0;
-  uint32_t chunk_size = 0;
-  uint8_t num_word_lists;
-  uint8_t num_transform_lists;
-  *is_custom_static_dict = BROTLI_FALSE;
-  *num_prefix = 0;
-
-  /* Skip magic header bytes. */
-  pos += 2;
-
-  /* LZ77_DICTIONARY_LENGTH */
-  if (!ReadVarint32(encoded, size, &pos, &chunk_size)) return BROTLI_FALSE;
-  if (chunk_size != 0) {
-    /* This limitation is not specified but the 32-bit Brotli decoder for now */
-    if (chunk_size > 1073741823) return BROTLI_FALSE;
-    *num_prefix = 1;
-    if (pos + chunk_size > size) return BROTLI_FALSE;
-    pos += chunk_size;
-  }
-
-  if (!ReadUint8(encoded, size, &pos, &num_word_lists)) {
-    return BROTLI_FALSE;
-  }
-  if (!ReadUint8(encoded, size, &pos, &num_transform_lists)) {
-    return BROTLI_FALSE;
-  }
-
-  if (num_word_lists > 0 || num_transform_lists > 0) {
-    *is_custom_static_dict = BROTLI_TRUE;
-  }
-
-  return BROTLI_TRUE;
-}
-
-static BROTLI_BOOL ParseDictionary(const uint8_t* encoded, size_t size,
-    BrotliSharedDictionary* dict) {
-  uint32_t i;
-  size_t pos = 0;
-  uint32_t chunk_size = 0;
-  size_t total_prefix_suffix_count = 0;
-  size_t trasform_list_start[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
-  uint16_t temporary_prefix_suffix_table[256];
-
-  /* Skip magic header bytes. */
-  pos += 2;
-
-  /* LZ77_DICTIONARY_LENGTH */
-  if (!ReadVarint32(encoded, size, &pos, &chunk_size)) return BROTLI_FALSE;
-  if (chunk_size != 0) {
-    if (pos + chunk_size > size) return BROTLI_FALSE;
-    dict->prefix_size[dict->num_prefix] = chunk_size;
-    dict->prefix[dict->num_prefix] = &encoded[pos];
-    dict->num_prefix++;
-    /* LZ77_DICTIONARY_LENGTH bytes. */
-    pos += chunk_size;
-  }
-
-  /* NUM_WORD_LISTS */
-  if (!ReadUint8(encoded, size, &pos, &dict->num_word_lists)) {
-    return BROTLI_FALSE;
-  }
-  if (dict->num_word_lists > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
-    return BROTLI_FALSE;
-  }
-
-  if (dict->num_word_lists != 0) {
-    dict->words_instances = (BrotliDictionary*)dict->alloc_func(
-        dict->memory_manager_opaque,
-        dict->num_word_lists * sizeof(*dict->words_instances));
-    if (!dict->words_instances) return BROTLI_FALSE;  /* OOM */
-  }
-  for (i = 0; i < dict->num_word_lists; i++) {
-    if (!ParseWordList(size, encoded, &pos, &dict->words_instances[i])) {
-      return BROTLI_FALSE;
-    }
-  }
-
-  /* NUM_TRANSFORM_LISTS */
-  if (!ReadUint8(encoded, size, &pos, &dict->num_transform_lists)) {
-    return BROTLI_FALSE;
-  }
-  if (dict->num_transform_lists > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
-    return BROTLI_FALSE;
-  }
-
-  if (dict->num_transform_lists != 0) {
-    dict->transforms_instances = (BrotliTransforms*)dict->alloc_func(
-        dict->memory_manager_opaque,
-        dict->num_transform_lists * sizeof(*dict->transforms_instances));
-    if (!dict->transforms_instances) return BROTLI_FALSE;  /* OOM */
-  }
-  for (i = 0; i < dict->num_transform_lists; i++) {
-    BROTLI_BOOL ok = BROTLI_FALSE;
-    size_t prefix_suffix_count = 0;
-    trasform_list_start[i] = pos;
-    dict->transforms_instances[i].prefix_suffix_map =
-        temporary_prefix_suffix_table;
-    ok = ParseTransformsList(
-        size, encoded, &pos, &dict->transforms_instances[i],
-        temporary_prefix_suffix_table, &prefix_suffix_count);
-    if (!ok) return BROTLI_FALSE;
-    total_prefix_suffix_count += prefix_suffix_count;
-  }
-  if (total_prefix_suffix_count != 0) {
-    dict->prefix_suffix_maps = (uint16_t*)dict->alloc_func(
-        dict->memory_manager_opaque,
-        total_prefix_suffix_count * sizeof(*dict->prefix_suffix_maps));
-    if (!dict->prefix_suffix_maps) return BROTLI_FALSE;  /* OOM */
-  }
-  total_prefix_suffix_count = 0;
-  for (i = 0; i < dict->num_transform_lists; i++) {
-    size_t prefix_suffix_count = 0;
-    size_t position = trasform_list_start[i];
-    uint16_t* prefix_suffix_map =
-      &dict->prefix_suffix_maps[total_prefix_suffix_count];
-    BROTLI_BOOL ok = ParsePrefixSuffixTable(
-        size, encoded, &position, &dict->transforms_instances[i],
-        prefix_suffix_map, &prefix_suffix_count);
-    if (!ok) return BROTLI_FALSE;
-    dict->transforms_instances[i].prefix_suffix_map = prefix_suffix_map;
-    total_prefix_suffix_count += prefix_suffix_count;
-  }
-
-  if (dict->num_word_lists != 0 || dict->num_transform_lists != 0) {
-    if (!ReadUint8(encoded, size, &pos, &dict->num_dictionaries)) {
-      return BROTLI_FALSE;
-    }
-    if (dict->num_dictionaries == 0 ||
-        dict->num_dictionaries > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
-      return BROTLI_FALSE;
-    }
-    for (i = 0; i < dict->num_dictionaries; i++) {
-      uint8_t words_index;
-      uint8_t transforms_index;
-      if (!ReadUint8(encoded, size, &pos, &words_index)) {
-        return BROTLI_FALSE;
-      }
-      if (words_index > dict->num_word_lists) return BROTLI_FALSE;
-      if (!ReadUint8(encoded, size, &pos, &transforms_index)) {
-        return BROTLI_FALSE;
-      }
-      if (transforms_index > dict->num_transform_lists) return BROTLI_FALSE;
-      dict->words[i] = words_index == dict->num_word_lists ?
-          BrotliGetDictionary() : &dict->words_instances[words_index];
-      dict->transforms[i] = transforms_index == dict->num_transform_lists ?
-          BrotliGetTransforms(): &dict->transforms_instances[transforms_index];
-    }
-    /* CONTEXT_ENABLED */
-    if (!ReadBool(encoded, size, &pos, &dict->context_based)) {
-      return BROTLI_FALSE;
-    }
-
-    /* CONTEXT_MAP */
-    if (dict->context_based) {
-      for (i = 0; i < SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS; i++) {
-        if (!ReadUint8(encoded, size, &pos, &dict->context_map[i])) {
-          return BROTLI_FALSE;
-        }
-        if (dict->context_map[i] >= dict->num_dictionaries) {
-          return BROTLI_FALSE;
-        }
-      }
-    }
-  } else {
-    dict->context_based = BROTLI_FALSE;
-    dict->num_dictionaries = 1;
-    dict->words[0] = BrotliGetDictionary();
-    dict->transforms[0] = BrotliGetTransforms();
-  }
-
-  return BROTLI_TRUE;
-}
-
-/* Decodes shared dictionary and verifies correctness.
-   Returns BROTLI_TRUE if dictionary is valid, BROTLI_FALSE otherwise.
-   The BrotliSharedDictionary must already have been initialized. If the
-   BrotliSharedDictionary already contains data, compound dictionaries
-   will be appended, but an error will be returned if it already has
-   custom words or transforms.
-   TODO(lode): link to RFC for shared brotli once published. */
-static BROTLI_BOOL DecodeSharedDictionary(
-    const uint8_t* encoded, size_t size, BrotliSharedDictionary* dict) {
-  uint32_t num_prefix = 0;
-  BROTLI_BOOL is_custom_static_dict = BROTLI_FALSE;
-  BROTLI_BOOL has_custom_static_dict =
-      dict->num_word_lists > 0 || dict->num_transform_lists > 0;
-
-  /* Check magic header bytes. */
-  if (size < 2) return BROTLI_FALSE;
-  if (encoded[0] != 0x91 || encoded[1] != 0) return BROTLI_FALSE;
-
-  if (!DryParseDictionary(encoded, size, &num_prefix, &is_custom_static_dict)) {
-    return BROTLI_FALSE;
-  }
-
-  if (num_prefix + dict->num_prefix > SHARED_BROTLI_MAX_COMPOUND_DICTS) {
-    return BROTLI_FALSE;
-  }
-
-  /* Cannot combine different static dictionaries, only prefix dictionaries */
-  if (has_custom_static_dict && is_custom_static_dict) return BROTLI_FALSE;
-
-  return ParseDictionary(encoded, size, dict);
-}
-
-#endif  /* BROTLI_EXPERIMENTAL */
-
-void duckdb_brotli::BrotliSharedDictionaryDestroyInstance(
-    BrotliSharedDictionary* dict) {
-  if (!dict) {
-    return;
-  } else {
-    brotli_free_func free_func = dict->free_func;
-    void* opaque = dict->memory_manager_opaque;
-    /* Cleanup. */
-    free_func(opaque, dict->words_instances);
-    free_func(opaque, dict->transforms_instances);
-    free_func(opaque, dict->prefix_suffix_maps);
-    /* Self-destruction. */
-    free_func(opaque, dict);
-  }
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliSharedDictionaryAttach(
-    BrotliSharedDictionary* dict, BrotliSharedDictionaryType type,
-    size_t data_size, const uint8_t data[BROTLI_ARRAY_PARAM(data_size)]) {
-  if (!dict) {
-    return BROTLI_FALSE;
-  }
-#if defined(BROTLI_EXPERIMENTAL)
-  if (type == BROTLI_SHARED_DICTIONARY_SERIALIZED) {
-    return DecodeSharedDictionary(data, data_size, dict);
-  }
-#endif  /* BROTLI_EXPERIMENTAL */
-  if (type == BROTLI_SHARED_DICTIONARY_RAW) {
-    if (dict->num_prefix >= SHARED_BROTLI_MAX_COMPOUND_DICTS) {
-      return BROTLI_FALSE;
-    }
-    dict->prefix_size[dict->num_prefix] = data_size;
-    dict->prefix[dict->num_prefix] = data;
-    dict->num_prefix++;
-    return BROTLI_TRUE;
-  }
-  return BROTLI_FALSE;
-}
-
-BrotliSharedDictionary* duckdb_brotli::BrotliSharedDictionaryCreateInstance(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
-  BrotliSharedDictionary* dict = 0;
-  if (!alloc_func && !free_func) {
-    dict = (BrotliSharedDictionary*)malloc(sizeof(BrotliSharedDictionary));
-  } else if (alloc_func && free_func) {
-    dict = (BrotliSharedDictionary*)alloc_func(
-        opaque, sizeof(BrotliSharedDictionary));
-  }
-  if (dict == 0) {
-    return 0;
-  }
-
-  /* TODO(eustas): explicitly initialize all the fields? */
-  memset(dict, 0, sizeof(BrotliSharedDictionary));
-
-  dict->context_based = BROTLI_FALSE;
-  dict->num_dictionaries = 1;
-  dict->num_word_lists = 0;
-  dict->num_transform_lists = 0;
-
-  dict->words[0] = BrotliGetDictionary();
-  dict->transforms[0] = BrotliGetTransforms();
-
-  dict->alloc_func = alloc_func ? alloc_func :  duckdb_brotli::BrotliDefaultAllocFunc;
-  dict->free_func = free_func ? free_func :  duckdb_brotli::BrotliDefaultFreeFunc;
-  dict->memory_manager_opaque = opaque;
-
-  return dict;
-}
-
-
diff --git a/src/duckdb/third_party/brotli/common/shared_dictionary_internal.h b/src/duckdb/third_party/brotli/common/shared_dictionary_internal.h
deleted file mode 100644
index 1f2d85b38..000000000
--- a/src/duckdb/third_party/brotli/common/shared_dictionary_internal.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* (Transparent) Shared Dictionary definition. */
-
-#ifndef BROTLI_COMMON_SHARED_DICTIONARY_INTERNAL_H_
-#define BROTLI_COMMON_SHARED_DICTIONARY_INTERNAL_H_
-
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-#include "dictionary.h"
-#include "transform.h"
-
-namespace duckdb_brotli {
-
-struct BrotliSharedDictionaryStruct {
-  /* LZ77 prefixes (compound dictionary). */
-  uint32_t num_prefix;  /* max SHARED_BROTLI_MAX_COMPOUND_DICTS */
-  size_t prefix_size[SHARED_BROTLI_MAX_COMPOUND_DICTS];
-  const uint8_t* prefix[SHARED_BROTLI_MAX_COMPOUND_DICTS];
-
-  /* If set, the context map is used to select word and transform list from 64
-     contexts, if not set, the context map is not used and only words[0] and
-     transforms[0] are to be used. */
-  BROTLI_BOOL context_based;
-
-  uint8_t context_map[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
-
-  /* Amount of word_list+transform_list combinations. */
-  uint8_t num_dictionaries;
-
-  /* Must use num_dictionaries values. */
-  const BrotliDictionary* words[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
-
-  /* Must use num_dictionaries values. */
-  const BrotliTransforms* transforms[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
-
-  /* Amount of custom word lists. May be 0 if only Brotli's built-in is used */
-  uint8_t num_word_lists;
-
-  /* Contents of the custom words lists. Must be NULL if num_word_lists is 0. */
-  BrotliDictionary* words_instances;
-
-  /* Amount of custom transform lists. May be 0 if only Brotli's built-in is
-     used */
-  uint8_t num_transform_lists;
-
-  /* Contents of the custom transform lists. Must be NULL if num_transform_lists
-     is 0. */
-  BrotliTransforms* transforms_instances;
-
-  /* Concatenated prefix_suffix_maps of the custom transform lists. Must be NULL
-     if num_transform_lists is 0. */
-  uint16_t* prefix_suffix_maps;
-
-  /* Memory management */
-  brotli_alloc_func alloc_func;
-  brotli_free_func free_func;
-  void* memory_manager_opaque;
-};
-
-typedef struct BrotliSharedDictionaryStruct BrotliSharedDictionaryInternal;
-#define BrotliSharedDictionary BrotliSharedDictionaryInternal
-
-}
-
-#endif  /* BROTLI_COMMON_SHARED_DICTIONARY_INTERNAL_H_ */
diff --git a/src/duckdb/third_party/brotli/common/transform.cpp b/src/duckdb/third_party/brotli/common/transform.cpp
deleted file mode 100644
index 9ab4ca260..000000000
--- a/src/duckdb/third_party/brotli/common/transform.cpp
+++ /dev/null
@@ -1,287 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "transform.h"
-
-using namespace duckdb_brotli;
-
-/* RFC 7932 transforms string data */
-static const char kPrefixSuffix[217] =
-      "\1 \2, \10 of the \4 of \2s \1.\5 and \4 "
-/* 0x  _0 _2  __5        _E    _3  _6 _8     _E */
-      "in \1\"\4 to \2\">\1\n\2. \1]\5 for \3 a \6 "
-/* 2x     _3_ _5    _A_  _D_ _F  _2 _4     _A   _E */
-      "that \1\'\6 with \6 from \4 by \1(\6. T"
-/* 4x       _5_ _7      _E      _5    _A _C */
-      "he \4 on \4 as \4 is \4ing \2\n\t\1:\3ed "
-/* 6x     _3    _8    _D    _2    _7_ _ _A _C */
-      "\2=\"\4 at \3ly \1,\2=\'\5.com/\7. This \5"
-/* 8x  _0 _ _3    _8   _C _E _ _1     _7       _F */
-      " not \3er \3al \4ful \4ive \5less \4es"
-/* Ax       _5   _9   _D    _2    _7     _D */
-      "t \4ize \2\xc2\xa0\4ous \5 the \2e "; /* \0 - implicit trailing zero. */
-/* Cx    _2    _7___ ___ _A    _F     _5        _8 */
-
-static const uint16_t kPrefixSuffixMap[50] = {
-  0x00, 0x02, 0x05, 0x0E, 0x13, 0x16, 0x18, 0x1E, 0x23, 0x25,
-  0x2A, 0x2D, 0x2F, 0x32, 0x34, 0x3A, 0x3E, 0x45, 0x47, 0x4E,
-  0x55, 0x5A, 0x5C, 0x63, 0x68, 0x6D, 0x72, 0x77, 0x7A, 0x7C,
-  0x80, 0x83, 0x88, 0x8C, 0x8E, 0x91, 0x97, 0x9F, 0xA5, 0xA9,
-  0xAD, 0xB2, 0xB7, 0xBD, 0xC2, 0xC7, 0xCA, 0xCF, 0xD5, 0xD8
-};
-
-/* RFC 7932 transforms */
-static const uint8_t kTransformsData[] = {
-  49, BROTLI_TRANSFORM_IDENTITY, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 0,
-   0, BROTLI_TRANSFORM_IDENTITY, 0,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_1, 49,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 0,
-  49, BROTLI_TRANSFORM_IDENTITY, 47,
-   0, BROTLI_TRANSFORM_IDENTITY, 49,
-   4, BROTLI_TRANSFORM_IDENTITY, 0,
-  49, BROTLI_TRANSFORM_IDENTITY, 3,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 6,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_2, 49,
-  49, BROTLI_TRANSFORM_OMIT_LAST_1, 49,
-   1, BROTLI_TRANSFORM_IDENTITY, 0,
-  49, BROTLI_TRANSFORM_IDENTITY, 1,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 0,
-  49, BROTLI_TRANSFORM_IDENTITY, 7,
-  49, BROTLI_TRANSFORM_IDENTITY, 9,
-  48, BROTLI_TRANSFORM_IDENTITY, 0,
-  49, BROTLI_TRANSFORM_IDENTITY, 8,
-  49, BROTLI_TRANSFORM_IDENTITY, 5,
-  49, BROTLI_TRANSFORM_IDENTITY, 10,
-  49, BROTLI_TRANSFORM_IDENTITY, 11,
-  49, BROTLI_TRANSFORM_OMIT_LAST_3, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 13,
-  49, BROTLI_TRANSFORM_IDENTITY, 14,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_3, 49,
-  49, BROTLI_TRANSFORM_OMIT_LAST_2, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 15,
-  49, BROTLI_TRANSFORM_IDENTITY, 16,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 12,
-   5, BROTLI_TRANSFORM_IDENTITY, 49,
-   0, BROTLI_TRANSFORM_IDENTITY, 1,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_4, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 18,
-  49, BROTLI_TRANSFORM_IDENTITY, 17,
-  49, BROTLI_TRANSFORM_IDENTITY, 19,
-  49, BROTLI_TRANSFORM_IDENTITY, 20,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_5, 49,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_6, 49,
-  47, BROTLI_TRANSFORM_IDENTITY, 49,
-  49, BROTLI_TRANSFORM_OMIT_LAST_4, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 22,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 23,
-  49, BROTLI_TRANSFORM_IDENTITY, 24,
-  49, BROTLI_TRANSFORM_IDENTITY, 25,
-  49, BROTLI_TRANSFORM_OMIT_LAST_7, 49,
-  49, BROTLI_TRANSFORM_OMIT_LAST_1, 26,
-  49, BROTLI_TRANSFORM_IDENTITY, 27,
-  49, BROTLI_TRANSFORM_IDENTITY, 28,
-   0, BROTLI_TRANSFORM_IDENTITY, 12,
-  49, BROTLI_TRANSFORM_IDENTITY, 29,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_9, 49,
-  49, BROTLI_TRANSFORM_OMIT_FIRST_7, 49,
-  49, BROTLI_TRANSFORM_OMIT_LAST_6, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 21,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 1,
-  49, BROTLI_TRANSFORM_OMIT_LAST_8, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 31,
-  49, BROTLI_TRANSFORM_IDENTITY, 32,
-  47, BROTLI_TRANSFORM_IDENTITY, 3,
-  49, BROTLI_TRANSFORM_OMIT_LAST_5, 49,
-  49, BROTLI_TRANSFORM_OMIT_LAST_9, 49,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 1,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 8,
-   5, BROTLI_TRANSFORM_IDENTITY, 21,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 0,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 10,
-  49, BROTLI_TRANSFORM_IDENTITY, 30,
-   0, BROTLI_TRANSFORM_IDENTITY, 5,
-  35, BROTLI_TRANSFORM_IDENTITY, 49,
-  47, BROTLI_TRANSFORM_IDENTITY, 2,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 17,
-  49, BROTLI_TRANSFORM_IDENTITY, 36,
-  49, BROTLI_TRANSFORM_IDENTITY, 33,
-   5, BROTLI_TRANSFORM_IDENTITY, 0,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 21,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 5,
-  49, BROTLI_TRANSFORM_IDENTITY, 37,
-   0, BROTLI_TRANSFORM_IDENTITY, 30,
-  49, BROTLI_TRANSFORM_IDENTITY, 38,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 0,
-  49, BROTLI_TRANSFORM_IDENTITY, 39,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 49,
-  49, BROTLI_TRANSFORM_IDENTITY, 34,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 8,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 12,
-   0, BROTLI_TRANSFORM_IDENTITY, 21,
-  49, BROTLI_TRANSFORM_IDENTITY, 40,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 12,
-  49, BROTLI_TRANSFORM_IDENTITY, 41,
-  49, BROTLI_TRANSFORM_IDENTITY, 42,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 17,
-  49, BROTLI_TRANSFORM_IDENTITY, 43,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 5,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 10,
-   0, BROTLI_TRANSFORM_IDENTITY, 34,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 33,
-  49, BROTLI_TRANSFORM_IDENTITY, 44,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 5,
-  45, BROTLI_TRANSFORM_IDENTITY, 49,
-   0, BROTLI_TRANSFORM_IDENTITY, 33,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 30,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 30,
-  49, BROTLI_TRANSFORM_IDENTITY, 46,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 1,
-  49, BROTLI_TRANSFORM_UPPERCASE_FIRST, 34,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 33,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 30,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 1,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 33,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 21,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 12,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 5,
-  49, BROTLI_TRANSFORM_UPPERCASE_ALL, 34,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 12,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 30,
-   0, BROTLI_TRANSFORM_UPPERCASE_ALL, 34,
-   0, BROTLI_TRANSFORM_UPPERCASE_FIRST, 34,
-};
-
-static const BrotliTransforms kBrotliTransforms = {
-  sizeof(kPrefixSuffix),
-  (const uint8_t*)kPrefixSuffix,
-  kPrefixSuffixMap,
-  sizeof(kTransformsData) / (3 * sizeof(kTransformsData[0])),
-  kTransformsData,
-  NULL,  /* no extra parameters */
-  {0, 12, 27, 23, 42, 63, 56, 48, 59, 64}
-};
-
-const BrotliTransforms* duckdb_brotli::BrotliGetTransforms(void) {
-  return &kBrotliTransforms;
-}
-
-static int ToUpperCase(uint8_t* p) {
-  if (p[0] < 0xC0) {
-    if (p[0] >= 'a' && p[0] <= 'z') {
-      p[0] ^= 32;
-    }
-    return 1;
-  }
-  /* An overly simplified uppercasing model for UTF-8. */
-  if (p[0] < 0xE0) {
-    p[1] ^= 32;
-    return 2;
-  }
-  /* An arbitrary transform for three byte characters. */
-  p[2] ^= 5;
-  return 3;
-}
-
-static int Shift(uint8_t* word, int word_len, uint16_t parameter) {
-  /* Limited sign extension: scalar < (1 << 24). */
-  uint32_t scalar =
-      (parameter & 0x7FFFu) + (0x1000000u - (parameter & 0x8000u));
-  if (word[0] < 0x80) {
-    /* 1-byte rune / 0sssssss / 7 bit scalar (ASCII). */
-    scalar += (uint32_t)word[0];
-    word[0] = (uint8_t)(scalar & 0x7Fu);
-    return 1;
-  } else if (word[0] < 0xC0) {
-    /* Continuation / 10AAAAAA. */
-    return 1;
-  } else if (word[0] < 0xE0) {
-    /* 2-byte rune / 110sssss AAssssss / 11 bit scalar. */
-    if (word_len < 2) return 1;
-    scalar += (uint32_t)((word[1] & 0x3Fu) | ((word[0] & 0x1Fu) << 6u));
-    word[0] = (uint8_t)(0xC0 | ((scalar >> 6u) & 0x1F));
-    word[1] = (uint8_t)((word[1] & 0xC0) | (scalar & 0x3F));
-    return 2;
-  } else if (word[0] < 0xF0) {
-    /* 3-byte rune / 1110ssss AAssssss BBssssss / 16 bit scalar. */
-    if (word_len < 3) return word_len;
-    scalar += (uint32_t)((word[2] & 0x3Fu) | ((word[1] & 0x3Fu) << 6u) |
-        ((word[0] & 0x0Fu) << 12u));
-    word[0] = (uint8_t)(0xE0 | ((scalar >> 12u) & 0x0F));
-    word[1] = (uint8_t)((word[1] & 0xC0) | ((scalar >> 6u) & 0x3F));
-    word[2] = (uint8_t)((word[2] & 0xC0) | (scalar & 0x3F));
-    return 3;
-  } else if (word[0] < 0xF8) {
-    /* 4-byte rune / 11110sss AAssssss BBssssss CCssssss / 21 bit scalar. */
-    if (word_len < 4) return word_len;
-    scalar += (uint32_t)((word[3] & 0x3Fu) | ((word[2] & 0x3Fu) << 6u) |
-        ((word[1] & 0x3Fu) << 12u) | ((word[0] & 0x07u) << 18u));
-    word[0] = (uint8_t)(0xF0 | ((scalar >> 18u) & 0x07));
-    word[1] = (uint8_t)((word[1] & 0xC0) | ((scalar >> 12u) & 0x3F));
-    word[2] = (uint8_t)((word[2] & 0xC0) | ((scalar >> 6u) & 0x3F));
-    word[3] = (uint8_t)((word[3] & 0xC0) | (scalar & 0x3F));
-    return 4;
-  }
-  return 1;
-}
-
-int duckdb_brotli::BrotliTransformDictionaryWord(uint8_t* dst, const uint8_t* word, int len,
-    const BrotliTransforms* transforms, int transform_idx) {
-  int idx = 0;
-  const uint8_t* prefix = BROTLI_TRANSFORM_PREFIX(transforms, transform_idx);
-  uint8_t type = BROTLI_TRANSFORM_TYPE(transforms, transform_idx);
-  const uint8_t* suffix = BROTLI_TRANSFORM_SUFFIX(transforms, transform_idx);
-  {
-    int prefix_len = *prefix++;
-    while (prefix_len--) { dst[idx++] = *prefix++; }
-  }
-  {
-    const int t = type;
-    int i = 0;
-    if (t <= BROTLI_TRANSFORM_OMIT_LAST_9) {
-      len -= t;
-    } else if (t >= BROTLI_TRANSFORM_OMIT_FIRST_1
-        && t <= BROTLI_TRANSFORM_OMIT_FIRST_9) {
-      int skip = t - (BROTLI_TRANSFORM_OMIT_FIRST_1 - 1);
-      word += skip;
-      len -= skip;
-    }
-    while (i < len) { dst[idx++] = word[i++]; }
-    if (t == BROTLI_TRANSFORM_UPPERCASE_FIRST) {
-      ToUpperCase(&dst[idx - len]);
-    } else if (t == BROTLI_TRANSFORM_UPPERCASE_ALL) {
-      uint8_t* uppercase = &dst[idx - len];
-      while (len > 0) {
-        int step = ToUpperCase(uppercase);
-        uppercase += step;
-        len -= step;
-      }
-    } else if (t == BROTLI_TRANSFORM_SHIFT_FIRST) {
-      uint16_t param = (uint16_t)(transforms->params[transform_idx * 2]
-          + (transforms->params[transform_idx * 2 + 1] << 8u));
-      Shift(&dst[idx - len], len, param);
-    } else if (t == BROTLI_TRANSFORM_SHIFT_ALL) {
-      uint16_t param = (uint16_t)(transforms->params[transform_idx * 2]
-          + (transforms->params[transform_idx * 2 + 1] << 8u));
-      uint8_t* shift = &dst[idx - len];
-      while (len > 0) {
-        int step = Shift(shift, len, param);
-        shift += step;
-        len -= step;
-      }
-    }
-  }
-  {
-    int suffix_len = *suffix++;
-    while (suffix_len--) { dst[idx++] = *suffix++; }
-    return idx;
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/common/transform.h b/src/duckdb/third_party/brotli/common/transform.h
deleted file mode 100644
index 3a5a42f9a..000000000
--- a/src/duckdb/third_party/brotli/common/transform.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/* transforms is a part of ABI, but not API.
-
-   It means that there are some functions that are supposed to be in "common"
-   library, but header itself is not placed into include/brotli. This way,
-   aforementioned functions will be available only to brotli internals.
- */
-
-#ifndef BROTLI_COMMON_TRANSFORM_H_
-#define BROTLI_COMMON_TRANSFORM_H_
-
-#include <brotli/port.h>
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-enum BrotliWordTransformType {
-	BROTLI_TRANSFORM_IDENTITY = 0,
-	BROTLI_TRANSFORM_OMIT_LAST_1 = 1,
-	BROTLI_TRANSFORM_OMIT_LAST_2 = 2,
-	BROTLI_TRANSFORM_OMIT_LAST_3 = 3,
-	BROTLI_TRANSFORM_OMIT_LAST_4 = 4,
-	BROTLI_TRANSFORM_OMIT_LAST_5 = 5,
-	BROTLI_TRANSFORM_OMIT_LAST_6 = 6,
-	BROTLI_TRANSFORM_OMIT_LAST_7 = 7,
-	BROTLI_TRANSFORM_OMIT_LAST_8 = 8,
-	BROTLI_TRANSFORM_OMIT_LAST_9 = 9,
-	BROTLI_TRANSFORM_UPPERCASE_FIRST = 10,
-	BROTLI_TRANSFORM_UPPERCASE_ALL = 11,
-	BROTLI_TRANSFORM_OMIT_FIRST_1 = 12,
-	BROTLI_TRANSFORM_OMIT_FIRST_2 = 13,
-	BROTLI_TRANSFORM_OMIT_FIRST_3 = 14,
-	BROTLI_TRANSFORM_OMIT_FIRST_4 = 15,
-	BROTLI_TRANSFORM_OMIT_FIRST_5 = 16,
-	BROTLI_TRANSFORM_OMIT_FIRST_6 = 17,
-	BROTLI_TRANSFORM_OMIT_FIRST_7 = 18,
-	BROTLI_TRANSFORM_OMIT_FIRST_8 = 19,
-	BROTLI_TRANSFORM_OMIT_FIRST_9 = 20,
-	BROTLI_TRANSFORM_SHIFT_FIRST = 21,
-	BROTLI_TRANSFORM_SHIFT_ALL = 22,
-	BROTLI_NUM_TRANSFORM_TYPES /* Counts transforms, not a transform itself. */
-};
-
-#define BROTLI_TRANSFORMS_MAX_CUT_OFF BROTLI_TRANSFORM_OMIT_LAST_9
-
-typedef struct BrotliTransforms {
-	uint16_t prefix_suffix_size;
-	/* Last character must be null, so prefix_suffix_size must be at least 1. */
-	const uint8_t *prefix_suffix;
-	const uint16_t *prefix_suffix_map;
-	uint32_t num_transforms;
-	/* Each entry is a [prefix_id, transform, suffix_id] triplet. */
-	const uint8_t *transforms;
-	/* Shift for BROTLI_TRANSFORM_SHIFT_FIRST and BROTLI_TRANSFORM_SHIFT_ALL,
-	   must be NULL if and only if no such transforms are present. */
-	const uint8_t *params;
-	/* Indices of transforms like ["", BROTLI_TRANSFORM_OMIT_LAST_#, ""].
-	   0-th element corresponds to ["", BROTLI_TRANSFORM_IDENTITY, ""].
-	   -1, if cut-off transform does not exist. */
-	int16_t cutOffTransforms[BROTLI_TRANSFORMS_MAX_CUT_OFF + 1];
-} BrotliTransforms;
-
-/* T is BrotliTransforms*; result is uint8_t. */
-#define BROTLI_TRANSFORM_PREFIX_ID(T, I) ((T)->transforms[((I) * 3) + 0])
-#define BROTLI_TRANSFORM_TYPE(T, I)      ((T)->transforms[((I) * 3) + 1])
-#define BROTLI_TRANSFORM_SUFFIX_ID(T, I) ((T)->transforms[((I) * 3) + 2])
-
-/* T is BrotliTransforms*; result is const uint8_t*. */
-#define BROTLI_TRANSFORM_PREFIX(T, I) (&(T)->prefix_suffix[(T)->prefix_suffix_map[BROTLI_TRANSFORM_PREFIX_ID(T, I)]])
-#define BROTLI_TRANSFORM_SUFFIX(T, I) (&(T)->prefix_suffix[(T)->prefix_suffix_map[BROTLI_TRANSFORM_SUFFIX_ID(T, I)]])
-
-BROTLI_COMMON_API const BrotliTransforms *BrotliGetTransforms(void);
-
-BROTLI_COMMON_API int BrotliTransformDictionaryWord(uint8_t *dst, const uint8_t *word, int len,
-                                                    const BrotliTransforms *transforms, int transform_idx);
-}
-
-#endif  /* BROTLI_COMMON_TRANSFORM_H_ */
diff --git a/src/duckdb/third_party/brotli/common/version.h b/src/duckdb/third_party/brotli/common/version.h
deleted file mode 100644
index 8098040f6..000000000
--- a/src/duckdb/third_party/brotli/common/version.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Version definition. */
-
-#ifndef BROTLI_COMMON_VERSION_H_
-#define BROTLI_COMMON_VERSION_H_
-
-/* Compose 3 components into a single number. In a hexadecimal representation
-   B and C components occupy exactly 3 digits. */
-#define BROTLI_MAKE_HEX_VERSION(A, B, C) ((A << 24) | (B << 12) | C)
-
-/* Those macros should only be used when library is compiled together with
-   the client. If library is dynamically linked, use BrotliDecoderVersion and
-   BrotliEncoderVersion methods. */
-
-#define BROTLI_VERSION_MAJOR 1
-#define BROTLI_VERSION_MINOR 1
-#define BROTLI_VERSION_PATCH 0
-
-#define BROTLI_VERSION BROTLI_MAKE_HEX_VERSION(                     \
-  BROTLI_VERSION_MAJOR, BROTLI_VERSION_MINOR, BROTLI_VERSION_PATCH)
-
-/* This macro is used by build system to produce Libtool-friendly soname. See
-   https://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html
-   Version evolution rules:
-    - interfaces added (or change is compatible)      -> current+1:0:age+1
-    - interfaces removed (or changed is incompatible) -> current+1:0:0
-    - interfaces not changed                          -> current:revision+1:age
- */
-
-#define BROTLI_ABI_CURRENT  2
-#define BROTLI_ABI_REVISION 0
-#define BROTLI_ABI_AGE      1
-
-#if BROTLI_VERSION_MAJOR != (BROTLI_ABI_CURRENT - BROTLI_ABI_AGE)
-#error ABI/API version inconsistency
-#endif
-
-#if BROTLI_VERSION_MINOR != BROTLI_ABI_AGE
-#error ABI/API version inconsistency
-#endif
-
-#if BROTLI_VERSION_PATCH != BROTLI_ABI_REVISION
-#error ABI/API version inconsistency
-#endif
-
-#endif  /* BROTLI_COMMON_VERSION_H_ */
diff --git a/src/duckdb/third_party/brotli/dec/bit_reader.cpp b/src/duckdb/third_party/brotli/dec/bit_reader.cpp
deleted file mode 100644
index f5fbd0a1d..000000000
--- a/src/duckdb/third_party/brotli/dec/bit_reader.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Bit reading helpers */
-
-#include "bit_reader.h"
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-using namespace duckdb_brotli;
-
-const brotli_reg_t duckdb_brotli::kBrotliBitMask[33] = {   0x00000000,
-    0x00000001, 0x00000003, 0x00000007, 0x0000000F,
-    0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
-    0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
-    0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
-    0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
-    0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
-    0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
-    0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
-};
-
-void duckdb_brotli::BrotliInitBitReader(BrotliBitReader* const br) {
-  br->val_ = 0;
-  br->bit_pos_ = 0;
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliWarmupBitReader(BrotliBitReader* const br) {
-  size_t aligned_read_mask = (sizeof(br->val_) >> 1) - 1;
-  /* Fixing alignment after unaligned BrotliFillWindow would result accumulator
-     overflow. If unalignment is caused by BrotliSafeReadBits, then there is
-     enough space in accumulator to fix alignment. */
-  if (BROTLI_UNALIGNED_READ_FAST) {
-    aligned_read_mask = 0;
-  }
-  if (BrotliGetAvailableBits(br) == 0) {
-    br->val_ = 0;
-    if (!BrotliPullByte(br)) {
-      return BROTLI_FALSE;
-    }
-  }
-
-  while ((((size_t)br->next_in) & aligned_read_mask) != 0) {
-    if (!BrotliPullByte(br)) {
-      /* If we consumed all the input, we don't care about the alignment. */
-      return BROTLI_TRUE;
-    }
-  }
-  return BROTLI_TRUE;
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliSafeReadBits32Slow(BrotliBitReader* const br,
-    brotli_reg_t n_bits, brotli_reg_t* val) {
-  brotli_reg_t low_val;
-  brotli_reg_t high_val;
-  BrotliBitReaderState memento;
-  BROTLI_DCHECK(n_bits <= 32);
-  BROTLI_DCHECK(n_bits > 24);
-  BrotliBitReaderSaveState(br, &memento);
-  if (!BrotliSafeReadBits(br, 16, &low_val) ||
-      !BrotliSafeReadBits(br, n_bits - 16, &high_val)) {
-    BrotliBitReaderRestoreState(br, &memento);
-    return BROTLI_FALSE;
-  }
-  *val = low_val | (high_val << 16);
-  return BROTLI_TRUE;
-}
-
-
diff --git a/src/duckdb/third_party/brotli/dec/bit_reader.h b/src/duckdb/third_party/brotli/dec/bit_reader.h
deleted file mode 100644
index d97de61ea..000000000
--- a/src/duckdb/third_party/brotli/dec/bit_reader.h
+++ /dev/null
@@ -1,419 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Bit reading helpers */
-
-#ifndef BROTLI_DEC_BIT_READER_H_
-#define BROTLI_DEC_BIT_READER_H_
-
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-#define BROTLI_SHORT_FILL_BIT_WINDOW_READ (sizeof(brotli_reg_t) >> 1)
-
-/* 162 bits + 7 bytes */
-#define BROTLI_FAST_INPUT_SLACK 28
-
-BROTLI_INTERNAL extern const brotli_reg_t kBrotliBitMask[33];
-
-static BROTLI_INLINE brotli_reg_t BitMask(brotli_reg_t n) {
-  if (BROTLI_IS_CONSTANT(n) || BROTLI_HAS_UBFX) {
-    /* Masking with this expression turns to a single
-       "Unsigned Bit Field Extract" UBFX instruction on ARM. */
-    return ~(~((brotli_reg_t)0) << n);
-  } else {
-    return kBrotliBitMask[n];
-  }
-}
-
-typedef struct {
-  brotli_reg_t val_;       /* pre-fetched bits */
-  brotli_reg_t bit_pos_;   /* current bit-reading position in val_ */
-  const uint8_t* next_in;  /* the byte we're reading from */
-  const uint8_t* guard_in; /* position from which "fast-path" is prohibited */
-  const uint8_t* last_in;  /* == next_in + avail_in */
-} BrotliBitReader;
-
-typedef struct {
-  brotli_reg_t val_;
-  brotli_reg_t bit_pos_;
-  const uint8_t* next_in;
-  size_t avail_in;
-} BrotliBitReaderState;
-
-/* Initializes the BrotliBitReader fields. */
-BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* br);
-
-/* Ensures that accumulator is not empty.
-   May consume up to sizeof(brotli_reg_t) - 1 bytes of input.
-   Returns BROTLI_FALSE if data is required but there is no input available.
-   For !BROTLI_UNALIGNED_READ_FAST this function also prepares bit reader for
-   aligned reading. */
-BROTLI_INTERNAL BROTLI_BOOL BrotliWarmupBitReader(BrotliBitReader* br);
-
-/* Fallback for BrotliSafeReadBits32. Extracted as noninlined method to unburden
-   the main code-path. Never called for RFC brotli streams, required only for
-   "large-window" mode and other extensions. */
-BROTLI_INTERNAL BROTLI_NOINLINE BROTLI_BOOL BrotliSafeReadBits32Slow(
-    BrotliBitReader* br, brotli_reg_t n_bits, brotli_reg_t* val);
-
-static BROTLI_INLINE size_t
-BrotliBitReaderGetAvailIn(BrotliBitReader* const br) {
-  return (size_t)(br->last_in - br->next_in);
-}
-
-static BROTLI_INLINE void BrotliBitReaderSaveState(
-    BrotliBitReader* const from, BrotliBitReaderState* to) {
-  to->val_ = from->val_;
-  to->bit_pos_ = from->bit_pos_;
-  to->next_in = from->next_in;
-  to->avail_in = BrotliBitReaderGetAvailIn(from);
-}
-
-static BROTLI_INLINE void BrotliBitReaderSetInput(
-    BrotliBitReader* const br, const uint8_t* next_in, size_t avail_in) {
-  br->next_in = next_in;
-  br->last_in = (avail_in == 0) ? next_in : (next_in + avail_in);
-  if (avail_in + 1 > BROTLI_FAST_INPUT_SLACK) {
-    br->guard_in = next_in + (avail_in + 1 - BROTLI_FAST_INPUT_SLACK);
-  } else {
-    br->guard_in = next_in;
-  }
-}
-
-static BROTLI_INLINE void BrotliBitReaderRestoreState(
-    BrotliBitReader* const to, BrotliBitReaderState* from) {
-  to->val_ = from->val_;
-  to->bit_pos_ = from->bit_pos_;
-  to->next_in = from->next_in;
-  BrotliBitReaderSetInput(to, from->next_in, from->avail_in);
-}
-
-static BROTLI_INLINE brotli_reg_t BrotliGetAvailableBits(
-    const BrotliBitReader* br) {
-  return br->bit_pos_;
-}
-
-/* Returns amount of unread bytes the bit reader still has buffered from the
-   BrotliInput, including whole bytes in br->val_. Result is capped with
-   maximal ring-buffer size (larger number won't be utilized anyway). */
-static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) {
-  static const size_t kCap = (size_t)1 << BROTLI_LARGE_MAX_WBITS;
-  size_t avail_in = BrotliBitReaderGetAvailIn(br);
-  if (avail_in > kCap) return kCap;
-  return avail_in + (BrotliGetAvailableBits(br) >> 3);
-}
-
-/* Checks if there is at least |num| bytes left in the input ring-buffer
-   (excluding the bits remaining in br->val_). */
-static BROTLI_INLINE BROTLI_BOOL BrotliCheckInputAmount(
-    BrotliBitReader* const br) {
-  return TO_BROTLI_BOOL(br->next_in < br->guard_in);
-}
-
-/* Load more bits into accumulator. */
-static BROTLI_INLINE brotli_reg_t BrotliBitReaderLoadBits(brotli_reg_t val,
-                                                          brotli_reg_t new_bits,
-                                                          brotli_reg_t count,
-                                                          brotli_reg_t offset) {
-  BROTLI_DCHECK(
-      !((val >> offset) & ~new_bits & ~(~((brotli_reg_t)0) << count)));
-  (void)count;
-  return val | (new_bits << offset);
-}
-
-/* Guarantees that there are at least |n_bits| + 1 bits in accumulator.
-   Precondition: accumulator contains at least 1 bit.
-   |n_bits| should be in the range [1..24] for regular build. For portable
-   non-64-bit little-endian build only 16 bits are safe to request. */
-static BROTLI_INLINE void BrotliFillBitWindow(
-    BrotliBitReader* const br, brotli_reg_t n_bits) {
-#if (BROTLI_64_BITS)
-  if (BROTLI_UNALIGNED_READ_FAST && BROTLI_IS_CONSTANT(n_bits) &&
-      (n_bits <= 8)) {
-    brotli_reg_t bit_pos = br->bit_pos_;
-    if (bit_pos <= 8) {
-      br->val_ = BrotliBitReaderLoadBits(br->val_,
-          BROTLI_UNALIGNED_LOAD64LE(br->next_in), 56, bit_pos);
-      br->bit_pos_ = bit_pos + 56;
-      br->next_in += 7;
-    }
-  } else if (BROTLI_UNALIGNED_READ_FAST && BROTLI_IS_CONSTANT(n_bits) &&
-             (n_bits <= 16)) {
-    brotli_reg_t bit_pos = br->bit_pos_;
-    if (bit_pos <= 16) {
-      br->val_ = BrotliBitReaderLoadBits(br->val_,
-          BROTLI_UNALIGNED_LOAD64LE(br->next_in), 48, bit_pos);
-      br->bit_pos_ = bit_pos + 48;
-      br->next_in += 6;
-    }
-  } else {
-    brotli_reg_t bit_pos = br->bit_pos_;
-    if (bit_pos <= 32) {
-      br->val_ = BrotliBitReaderLoadBits(br->val_,
-          (uint64_t)BROTLI_UNALIGNED_LOAD32LE(br->next_in), 32, bit_pos);
-      br->bit_pos_ = bit_pos + 32;
-      br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
-    }
-  }
-#else
-  if (BROTLI_UNALIGNED_READ_FAST && BROTLI_IS_CONSTANT(n_bits) &&
-      (n_bits <= 8)) {
-    brotli_reg_t bit_pos = br->bit_pos_;
-    if (bit_pos <= 8) {
-      br->val_ = BrotliBitReaderLoadBits(br->val_,
-          BROTLI_UNALIGNED_LOAD32LE(br->next_in), 24, bit_pos);
-      br->bit_pos_ = bit_pos + 24;
-      br->next_in += 3;
-    }
-  } else {
-    brotli_reg_t bit_pos = br->bit_pos_;
-    if (bit_pos <= 16) {
-      br->val_ = BrotliBitReaderLoadBits(br->val_,
-          (uint32_t)BROTLI_UNALIGNED_LOAD16LE(br->next_in), 16, bit_pos);
-      br->bit_pos_ = bit_pos + 16;
-      br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
-    }
-  }
-#endif
-}
-
-/* Mostly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
-   more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
-static BROTLI_INLINE void BrotliFillBitWindow16(BrotliBitReader* const br) {
-  BrotliFillBitWindow(br, 17);
-}
-
-/* Tries to pull one byte of input to accumulator.
-   Returns BROTLI_FALSE if there is no input available. */
-static BROTLI_INLINE BROTLI_BOOL BrotliPullByte(BrotliBitReader* const br) {
-  if (br->next_in == br->last_in) {
-    return BROTLI_FALSE;
-  }
-  br->val_ = BrotliBitReaderLoadBits(br->val_,
-      (brotli_reg_t)*br->next_in, 8, br->bit_pos_);
-  br->bit_pos_ += 8;
-  ++br->next_in;
-  return BROTLI_TRUE;
-}
-
-/* Returns currently available bits.
-   The number of valid bits could be calculated by BrotliGetAvailableBits. */
-static BROTLI_INLINE brotli_reg_t BrotliGetBitsUnmasked(
-    BrotliBitReader* const br) {
-  return br->val_;
-}
-
-/* Like BrotliGetBits, but does not mask the result.
-   The result contains at least 16 valid bits. */
-static BROTLI_INLINE brotli_reg_t BrotliGet16BitsUnmasked(
-    BrotliBitReader* const br) {
-  BrotliFillBitWindow(br, 16);
-  return (brotli_reg_t)BrotliGetBitsUnmasked(br);
-}
-
-/* Returns the specified number of bits from |br| without advancing bit
-   position. */
-static BROTLI_INLINE brotli_reg_t BrotliGetBits(
-    BrotliBitReader* const br, brotli_reg_t n_bits) {
-  BrotliFillBitWindow(br, n_bits);
-  return BrotliGetBitsUnmasked(br) & BitMask(n_bits);
-}
-
-/* Tries to peek the specified amount of bits. Returns BROTLI_FALSE, if there
-   is not enough input. */
-static BROTLI_INLINE BROTLI_BOOL BrotliSafeGetBits(
-    BrotliBitReader* const br, brotli_reg_t n_bits, brotli_reg_t* val) {
-  while (BrotliGetAvailableBits(br) < n_bits) {
-    if (!BrotliPullByte(br)) {
-      return BROTLI_FALSE;
-    }
-  }
-  *val = BrotliGetBitsUnmasked(br) & BitMask(n_bits);
-  return BROTLI_TRUE;
-}
-
-/* Advances the bit pos by |n_bits|. */
-static BROTLI_INLINE void BrotliDropBits(
-    BrotliBitReader* const br, brotli_reg_t n_bits) {
-  br->bit_pos_ -= n_bits;
-  br->val_ >>= n_bits;
-}
-
-/* Make sure that there are no spectre bits in accumulator.
-   This is important for the cases when some bytes are skipped
-   (i.e. never placed into accumulator). */
-static BROTLI_INLINE void BrotliBitReaderNormalize(BrotliBitReader* br) {
-  /* Actually, it is enough to normalize when br->bit_pos_ == 0 */
-  if (br->bit_pos_ < (sizeof(brotli_reg_t) << 3u)) {
-    br->val_ &= (((brotli_reg_t)1) << br->bit_pos_) - 1;
-  }
-}
-
-static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
-  brotli_reg_t unused_bytes = BrotliGetAvailableBits(br) >> 3;
-  brotli_reg_t unused_bits = unused_bytes << 3;
-  br->next_in =
-      (unused_bytes == 0) ? br->next_in : (br->next_in - unused_bytes);
-  br->bit_pos_ -= unused_bits;
-  BrotliBitReaderNormalize(br);
-}
-
-/* Reads the specified number of bits from |br| and advances the bit pos.
-   Precondition: accumulator MUST contain at least |n_bits|. */
-static BROTLI_INLINE void BrotliTakeBits(BrotliBitReader* const br,
-                                         brotli_reg_t n_bits,
-                                         brotli_reg_t* val) {
-  *val = BrotliGetBitsUnmasked(br) & BitMask(n_bits);
-  BROTLI_LOG(("[BrotliTakeBits]  %d %d %d val: %6x\n",
-              (int)BrotliBitReaderGetAvailIn(br), (int)br->bit_pos_,
-              (int)n_bits, (int)*val));
-  BrotliDropBits(br, n_bits);
-}
-
-/* Reads the specified number of bits from |br| and advances the bit pos.
-   Assumes that there is enough input to perform BrotliFillBitWindow.
-   Up to 24 bits are allowed to be requested from this method. */
-static BROTLI_INLINE brotli_reg_t BrotliReadBits24(
-    BrotliBitReader* const br, brotli_reg_t n_bits) {
-  BROTLI_DCHECK(n_bits <= 24);
-  if (BROTLI_64_BITS || (n_bits <= 16)) {
-    brotli_reg_t val;
-    BrotliFillBitWindow(br, n_bits);
-    BrotliTakeBits(br, n_bits, &val);
-    return val;
-  } else {
-    brotli_reg_t low_val;
-    brotli_reg_t high_val;
-    BrotliFillBitWindow(br, 16);
-    BrotliTakeBits(br, 16, &low_val);
-    BrotliFillBitWindow(br, 8);
-    BrotliTakeBits(br, n_bits - 16, &high_val);
-    return low_val | (high_val << 16);
-  }
-}
-
-/* Same as BrotliReadBits24, but allows reading up to 32 bits. */
-static BROTLI_INLINE brotli_reg_t BrotliReadBits32(
-    BrotliBitReader* const br, brotli_reg_t n_bits) {
-  BROTLI_DCHECK(n_bits <= 32);
-  if (BROTLI_64_BITS || (n_bits <= 16)) {
-    brotli_reg_t val;
-    BrotliFillBitWindow(br, n_bits);
-    BrotliTakeBits(br, n_bits, &val);
-    return val;
-  } else {
-    brotli_reg_t low_val;
-    brotli_reg_t high_val;
-    BrotliFillBitWindow(br, 16);
-    BrotliTakeBits(br, 16, &low_val);
-    BrotliFillBitWindow(br, 16);
-    BrotliTakeBits(br, n_bits - 16, &high_val);
-    return low_val | (high_val << 16);
-  }
-}
-
-/* Tries to read the specified amount of bits. Returns BROTLI_FALSE, if there
-   is not enough input. |n_bits| MUST be positive.
-   Up to 24 bits are allowed to be requested from this method. */
-static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits(
-    BrotliBitReader* const br, brotli_reg_t n_bits, brotli_reg_t* val) {
-  BROTLI_DCHECK(n_bits <= 24);
-  while (BrotliGetAvailableBits(br) < n_bits) {
-    if (!BrotliPullByte(br)) {
-      return BROTLI_FALSE;
-    }
-  }
-  BrotliTakeBits(br, n_bits, val);
-  return BROTLI_TRUE;
-}
-
-/* Same as BrotliSafeReadBits, but allows reading up to 32 bits. */
-static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits32(
-    BrotliBitReader* const br, brotli_reg_t n_bits, brotli_reg_t* val) {
-  BROTLI_DCHECK(n_bits <= 32);
-  if (BROTLI_64_BITS || (n_bits <= 24)) {
-    while (BrotliGetAvailableBits(br) < n_bits) {
-      if (!BrotliPullByte(br)) {
-        return BROTLI_FALSE;
-      }
-    }
-    BrotliTakeBits(br, n_bits, val);
-    return BROTLI_TRUE;
-  } else {
-    return BrotliSafeReadBits32Slow(br, n_bits, val);
-  }
-}
-
-/* Advances the bit reader position to the next byte boundary and verifies
-   that any skipped bits are set to zero. */
-static BROTLI_INLINE BROTLI_BOOL BrotliJumpToByteBoundary(BrotliBitReader* br) {
-  brotli_reg_t pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
-  brotli_reg_t pad_bits = 0;
-  if (pad_bits_count != 0) {
-    BrotliTakeBits(br, pad_bits_count, &pad_bits);
-  }
-  BrotliBitReaderNormalize(br);
-  return TO_BROTLI_BOOL(pad_bits == 0);
-}
-
-static BROTLI_INLINE void BrotliDropBytes(BrotliBitReader* br, size_t num) {
-  /* Check detour is legal: accumulator must to be empty. */
-  BROTLI_DCHECK(br->bit_pos_ == 0);
-  BROTLI_DCHECK(br->val_ == 0);
-  br->next_in += num;
-}
-
-/* Copies remaining input bytes stored in the bit reader to the output. Value
-   |num| may not be larger than BrotliGetRemainingBytes. The bit reader must be
-   warmed up again after this. */
-static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
-                                          BrotliBitReader* br, size_t num) {
-  while (BrotliGetAvailableBits(br) >= 8 && num > 0) {
-    *dest = (uint8_t)BrotliGetBitsUnmasked(br);
-    BrotliDropBits(br, 8);
-    ++dest;
-    --num;
-  }
-  BrotliBitReaderNormalize(br);
-  if (num > 0) {
-    memcpy(dest, br->next_in, num);
-    BrotliDropBytes(br, num);
-  }
-}
-
-BROTLI_UNUSED_FUNCTION void BrotliBitReaderSuppressUnusedFunctions(void) {
-  BROTLI_UNUSED(&BrotliBitReaderSuppressUnusedFunctions);
-
-  BROTLI_UNUSED(&BrotliBitReaderGetAvailIn);
-  BROTLI_UNUSED(&BrotliBitReaderLoadBits);
-  BROTLI_UNUSED(&BrotliBitReaderRestoreState);
-  BROTLI_UNUSED(&BrotliBitReaderSaveState);
-  BROTLI_UNUSED(&BrotliBitReaderSetInput);
-  BROTLI_UNUSED(&BrotliBitReaderUnload);
-  BROTLI_UNUSED(&BrotliCheckInputAmount);
-  BROTLI_UNUSED(&BrotliCopyBytes);
-  BROTLI_UNUSED(&BrotliFillBitWindow16);
-  BROTLI_UNUSED(&BrotliGet16BitsUnmasked);
-  BROTLI_UNUSED(&BrotliGetBits);
-  BROTLI_UNUSED(&BrotliGetRemainingBytes);
-  BROTLI_UNUSED(&BrotliJumpToByteBoundary);
-  BROTLI_UNUSED(&BrotliReadBits24);
-  BROTLI_UNUSED(&BrotliReadBits32);
-  BROTLI_UNUSED(&BrotliSafeGetBits);
-  BROTLI_UNUSED(&BrotliSafeReadBits);
-  BROTLI_UNUSED(&BrotliSafeReadBits32);
-}
-
-}
-
-#endif  /* BROTLI_DEC_BIT_READER_H_ */
diff --git a/src/duckdb/third_party/brotli/dec/decode.cpp b/src/duckdb/third_party/brotli/dec/decode.cpp
deleted file mode 100644
index 2ee17d695..000000000
--- a/src/duckdb/third_party/brotli/dec/decode.cpp
+++ /dev/null
@@ -1,2758 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include <brotli/decode.h>
-
-#include <stdlib.h>  /* free, malloc */
-#include <string.h>  /* memcpy, memset */
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "../common/shared_dictionary_internal.h"
-#include "../common/transform.h"
-#include "../common/version.h"
-#include "bit_reader.h"
-#include "huffman.h"
-#include "prefix.h"
-#include "state.h"
-
-#if defined(BROTLI_TARGET_NEON)
-#include <arm_neon.h>
-#endif
-
-namespace duckdb_brotli {
-
-#define BROTLI_FAILURE(CODE) (BROTLI_DUMP(), CODE)
-
-#define BROTLI_LOG_UINT(name) BROTLI_LOG(("[%s] %s = %lu\n", __func__, #name, (unsigned long)(name)))
-#define BROTLI_LOG_ARRAY_INDEX(array_name, idx)                     \
-  BROTLI_LOG(("[%s] %s[%lu] = %lu\n", __func__, #array_name, (unsigned long)(idx), (unsigned long)array_name[idx]))
-
-#define HUFFMAN_TABLE_BITS 8U
-#define HUFFMAN_TABLE_MASK 0xFF
-
-/* We need the slack region for the following reasons:
-    - doing up to two 16-byte copies for fast backward copying
-    - inserting transformed dictionary word:
-        255 prefix + 32 base + 255 suffix */
-static const brotli_reg_t kRingBufferWriteAheadSlack = 542;
-
-static const uint8_t kCodeLengthCodeOrder[BROTLI_CODE_LENGTH_CODES] = {
-    1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-};
-
-/* Static prefix code for the complex code length code lengths. */
-static const uint8_t kCodeLengthPrefixLength[16] = {
-    2, 2, 2, 3, 2, 2, 2, 4, 2, 2, 2, 3, 2, 2, 2, 4,
-};
-
-static const uint8_t kCodeLengthPrefixValue[16] = {
-    0, 4, 3, 2, 0, 4, 3, 1, 0, 4, 3, 2, 0, 4, 3, 5,
-};
-
-BROTLI_BOOL BrotliDecoderSetParameter(BrotliDecoderState *state, BrotliDecoderParameter p, uint32_t value) {
-	if (state->state != BROTLI_STATE_UNINITED)
-		return BROTLI_FALSE;
-	switch (p) {
-	case BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION:
-		state->canny_ringbuffer_allocation = !!value ? 0 : 1;
-		return BROTLI_TRUE;
-
-	case BROTLI_DECODER_PARAM_LARGE_WINDOW:
-		state->large_window = TO_BROTLI_BOOL(!!value);
-		return BROTLI_TRUE;
-
-	default:
-		return BROTLI_FALSE;
-	}
-}
-
-BrotliDecoderState *BrotliDecoderCreateInstance(brotli_alloc_func alloc_func, brotli_free_func free_func,
-                                                void *opaque) {
-	BrotliDecoderState *state = 0;
-	if (!alloc_func && !free_func) {
-		state = (BrotliDecoderState *)malloc(sizeof(BrotliDecoderState));
-	} else if (alloc_func && free_func) {
-		state = (BrotliDecoderState *)alloc_func(opaque, sizeof(BrotliDecoderState));
-	}
-	if (state == 0) {
-		BROTLI_DUMP();
-		return 0;
-	}
-	if (!BrotliDecoderStateInit(state, alloc_func, free_func, opaque)) {
-		BROTLI_DUMP();
-		if (!alloc_func && !free_func) {
-			free(state);
-		} else if (alloc_func && free_func) {
-			free_func(opaque, state);
-		}
-		return 0;
-	}
-	return state;
-}
-
-/* Deinitializes and frees BrotliDecoderState instance. */
-void BrotliDecoderDestroyInstance(BrotliDecoderState *state) {
-	if (!state) {
-		return;
-	} else {
-		brotli_free_func free_func = state->free_func;
-		void *opaque = state->memory_manager_opaque;
-		BrotliDecoderStateCleanup(state);
-		free_func(opaque, state);
-	}
-}
-
-/* Saves error code and converts it to BrotliDecoderResult. */
-static BROTLI_NOINLINE BrotliDecoderResult SaveErrorCode(BrotliDecoderState *s, BrotliDecoderErrorCode e,
-                                                         size_t consumed_input) {
-	s->error_code = (int)e;
-	s->used_input += consumed_input;
-	if ((s->buffer_length != 0) && (s->br.next_in == s->br.last_in)) {
-		/* If internal buffer is depleted at last, reset it. */
-		s->buffer_length = 0;
-	}
-	switch (e) {
-	case BROTLI_DECODER_SUCCESS:
-		return BROTLI_DECODER_RESULT_SUCCESS;
-
-	case BROTLI_DECODER_NEEDS_MORE_INPUT:
-		return BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
-
-	case BROTLI_DECODER_NEEDS_MORE_OUTPUT:
-		return BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT;
-
-	default:
-		return BROTLI_DECODER_RESULT_ERROR;
-	}
-}
-
-/* Decodes WBITS by reading 1 - 7 bits, or 0x11 for "Large Window Brotli".
-   Precondition: bit-reader accumulator has at least 8 bits. */
-static BrotliDecoderErrorCode DecodeWindowBits(BrotliDecoderState *s, BrotliBitReader *br) {
-	brotli_reg_t n;
-	BROTLI_BOOL large_window = s->large_window;
-	s->large_window = BROTLI_FALSE;
-	BrotliTakeBits(br, 1, &n);
-	if (n == 0) {
-		s->window_bits = 16;
-		return BROTLI_DECODER_SUCCESS;
-	}
-	BrotliTakeBits(br, 3, &n);
-	if (n != 0) {
-		s->window_bits = (17u + n) & 63u;
-		return BROTLI_DECODER_SUCCESS;
-	}
-	BrotliTakeBits(br, 3, &n);
-	if (n == 1) {
-		if (large_window) {
-			BrotliTakeBits(br, 1, &n);
-			if (n == 1) {
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS);
-			}
-			s->large_window = BROTLI_TRUE;
-			return BROTLI_DECODER_SUCCESS;
-		} else {
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS);
-		}
-	}
-	if (n != 0) {
-		s->window_bits = (8u + n) & 63u;
-		return BROTLI_DECODER_SUCCESS;
-	}
-	s->window_bits = 17;
-	return BROTLI_DECODER_SUCCESS;
-}
-
-static BROTLI_INLINE void memmove16(uint8_t *dst, uint8_t *src) {
-#if defined(BROTLI_TARGET_NEON)
-	vst1q_u8(dst, vld1q_u8(src));
-#else
-	uint32_t buffer[4];
-	memcpy(buffer, src, 16);
-	memcpy(dst, buffer, 16);
-#endif
-}
-
-/* Decodes a number in the range [0..255], by reading 1 - 11 bits. */
-static BROTLI_NOINLINE BrotliDecoderErrorCode DecodeVarLenUint8(BrotliDecoderState *s, BrotliBitReader *br,
-                                                                brotli_reg_t *value) {
-	brotli_reg_t bits;
-	switch (s->substate_decode_uint8) {
-	case BROTLI_STATE_DECODE_UINT8_NONE:
-		if (BROTLI_PREDICT_FALSE(!BrotliSafeReadBits(br, 1, &bits))) {
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		if (bits == 0) {
-			*value = 0;
-			return BROTLI_DECODER_SUCCESS;
-		}
-		/* Fall through. */
-
-	case BROTLI_STATE_DECODE_UINT8_SHORT:
-		if (BROTLI_PREDICT_FALSE(!BrotliSafeReadBits(br, 3, &bits))) {
-			s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_SHORT;
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		if (bits == 0) {
-			*value = 1;
-			s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
-			return BROTLI_DECODER_SUCCESS;
-		}
-		/* Use output value as a temporary storage. It MUST be persisted. */
-		*value = bits;
-		/* Fall through. */
-
-	case BROTLI_STATE_DECODE_UINT8_LONG:
-		if (BROTLI_PREDICT_FALSE(!BrotliSafeReadBits(br, *value, &bits))) {
-			s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_LONG;
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		*value = (1U << *value) + bits;
-		s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
-		return BROTLI_DECODER_SUCCESS;
-
-	default:
-		return BROTLI_FAILURE(BROTLI_DECODER_ERROR_UNREACHABLE); /* COV_NF_LINE */
-	}
-}
-
-/* Decodes a metablock length and flags by reading 2 - 31 bits. */
-static BrotliDecoderErrorCode BROTLI_NOINLINE DecodeMetaBlockLength(BrotliDecoderState *s, BrotliBitReader *br) {
-	brotli_reg_t bits;
-	int i;
-	for (;;) {
-		switch (s->substate_metablock_header) {
-		case BROTLI_STATE_METABLOCK_HEADER_NONE:
-			if (!BrotliSafeReadBits(br, 1, &bits)) {
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			s->is_last_metablock = bits ? 1 : 0;
-			s->meta_block_remaining_len = 0;
-			s->is_uncompressed = 0;
-			s->is_metadata = 0;
-			if (!s->is_last_metablock) {
-				s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NIBBLES;
-				break;
-			}
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_EMPTY;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER_EMPTY:
-			if (!BrotliSafeReadBits(br, 1, &bits)) {
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			if (bits) {
-				s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-				return BROTLI_DECODER_SUCCESS;
-			}
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NIBBLES;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER_NIBBLES:
-			if (!BrotliSafeReadBits(br, 2, &bits)) {
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			s->size_nibbles = (uint8_t)(bits + 4);
-			s->loop_counter = 0;
-			if (bits == 3) {
-				s->is_metadata = 1;
-				s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_RESERVED;
-				break;
-			}
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_SIZE;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER_SIZE:
-			i = s->loop_counter;
-			for (; i < (int)s->size_nibbles; ++i) {
-				if (!BrotliSafeReadBits(br, 4, &bits)) {
-					s->loop_counter = i;
-					return BROTLI_DECODER_NEEDS_MORE_INPUT;
-				}
-				if (i + 1 == (int)s->size_nibbles && s->size_nibbles > 4 && bits == 0) {
-					return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE);
-				}
-				s->meta_block_remaining_len |= (int)(bits << (i * 4));
-			}
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED:
-			if (!s->is_last_metablock) {
-				if (!BrotliSafeReadBits(br, 1, &bits)) {
-					return BROTLI_DECODER_NEEDS_MORE_INPUT;
-				}
-				s->is_uncompressed = bits ? 1 : 0;
-			}
-			++s->meta_block_remaining_len;
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-			return BROTLI_DECODER_SUCCESS;
-
-		case BROTLI_STATE_METABLOCK_HEADER_RESERVED:
-			if (!BrotliSafeReadBits(br, 1, &bits)) {
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			if (bits != 0) {
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_RESERVED);
-			}
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_BYTES;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER_BYTES:
-			if (!BrotliSafeReadBits(br, 2, &bits)) {
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			if (bits == 0) {
-				s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-				return BROTLI_DECODER_SUCCESS;
-			}
-			s->size_nibbles = (uint8_t)bits;
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_METADATA;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER_METADATA:
-			i = s->loop_counter;
-			for (; i < (int)s->size_nibbles; ++i) {
-				if (!BrotliSafeReadBits(br, 8, &bits)) {
-					s->loop_counter = i;
-					return BROTLI_DECODER_NEEDS_MORE_INPUT;
-				}
-				if (i + 1 == (int)s->size_nibbles && s->size_nibbles > 1 && bits == 0) {
-					return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE);
-				}
-				s->meta_block_remaining_len |= (int)(bits << (i * 8));
-			}
-			++s->meta_block_remaining_len;
-			s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-			return BROTLI_DECODER_SUCCESS;
-
-		default:
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_UNREACHABLE); /* COV_NF_LINE */
-		}
-	}
-}
-
-/* Decodes the Huffman code.
-   This method doesn't read data from the bit reader, BUT drops the amount of
-   bits that correspond to the decoded symbol.
-   bits MUST contain at least 15 (BROTLI_HUFFMAN_MAX_CODE_LENGTH) valid bits. */
-static BROTLI_INLINE brotli_reg_t DecodeSymbol(brotli_reg_t bits, const HuffmanCode *table, BrotliBitReader *br) {
-	BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table);
-	BROTLI_HC_ADJUST_TABLE_INDEX(table, bits & HUFFMAN_TABLE_MASK);
-	if (BROTLI_HC_FAST_LOAD_BITS(table) > HUFFMAN_TABLE_BITS) {
-		brotli_reg_t nbits = BROTLI_HC_FAST_LOAD_BITS(table) - HUFFMAN_TABLE_BITS;
-		BrotliDropBits(br, HUFFMAN_TABLE_BITS);
-		BROTLI_HC_ADJUST_TABLE_INDEX(table, BROTLI_HC_FAST_LOAD_VALUE(table) +
-		                                        ((bits >> HUFFMAN_TABLE_BITS) & BitMask(nbits)));
-	}
-	BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(table));
-	return BROTLI_HC_FAST_LOAD_VALUE(table);
-}
-
-/* Reads and decodes the next Huffman code from bit-stream.
-   This method peeks 16 bits of input and drops 0 - 15 of them. */
-static BROTLI_INLINE brotli_reg_t ReadSymbol(const HuffmanCode *table, BrotliBitReader *br) {
-	return DecodeSymbol(BrotliGet16BitsUnmasked(br), table, br);
-}
-
-/* Same as DecodeSymbol, but it is known that there is less than 15 bits of
-   input are currently available. */
-static BROTLI_NOINLINE BROTLI_BOOL SafeDecodeSymbol(const HuffmanCode *table, BrotliBitReader *br,
-                                                    brotli_reg_t *result) {
-	brotli_reg_t val;
-	brotli_reg_t available_bits = BrotliGetAvailableBits(br);
-	BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table);
-	if (available_bits == 0) {
-		if (BROTLI_HC_FAST_LOAD_BITS(table) == 0) {
-			*result = BROTLI_HC_FAST_LOAD_VALUE(table);
-			return BROTLI_TRUE;
-		}
-		return BROTLI_FALSE; /* No valid bits at all. */
-	}
-	val = BrotliGetBitsUnmasked(br);
-	BROTLI_HC_ADJUST_TABLE_INDEX(table, val & HUFFMAN_TABLE_MASK);
-	if (BROTLI_HC_FAST_LOAD_BITS(table) <= HUFFMAN_TABLE_BITS) {
-		if (BROTLI_HC_FAST_LOAD_BITS(table) <= available_bits) {
-			BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(table));
-			*result = BROTLI_HC_FAST_LOAD_VALUE(table);
-			return BROTLI_TRUE;
-		} else {
-			return BROTLI_FALSE; /* Not enough bits for the first level. */
-		}
-	}
-	if (available_bits <= HUFFMAN_TABLE_BITS) {
-		return BROTLI_FALSE; /* Not enough bits to move to the second level. */
-	}
-
-	/* Speculatively drop HUFFMAN_TABLE_BITS. */
-	val = (val & BitMask(BROTLI_HC_FAST_LOAD_BITS(table))) >> HUFFMAN_TABLE_BITS;
-	available_bits -= HUFFMAN_TABLE_BITS;
-	BROTLI_HC_ADJUST_TABLE_INDEX(table, BROTLI_HC_FAST_LOAD_VALUE(table) + val);
-	if (available_bits < BROTLI_HC_FAST_LOAD_BITS(table)) {
-		return BROTLI_FALSE; /* Not enough bits for the second level. */
-	}
-
-	BrotliDropBits(br, HUFFMAN_TABLE_BITS + BROTLI_HC_FAST_LOAD_BITS(table));
-	*result = BROTLI_HC_FAST_LOAD_VALUE(table);
-	return BROTLI_TRUE;
-}
-
-static BROTLI_INLINE BROTLI_BOOL SafeReadSymbol(const HuffmanCode *table, BrotliBitReader *br, brotli_reg_t *result) {
-	brotli_reg_t val;
-	if (BROTLI_PREDICT_TRUE(BrotliSafeGetBits(br, 15, &val))) {
-		*result = DecodeSymbol(val, table, br);
-		return BROTLI_TRUE;
-	}
-	return SafeDecodeSymbol(table, br, result);
-}
-
-/* Makes a look-up in first level Huffman table. Peeks 8 bits. */
-static BROTLI_INLINE void PreloadSymbol(int safe, const HuffmanCode *table, BrotliBitReader *br, brotli_reg_t *bits,
-                                        brotli_reg_t *value) {
-	if (safe) {
-		return;
-	}
-	BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table);
-	BROTLI_HC_ADJUST_TABLE_INDEX(table, BrotliGetBits(br, HUFFMAN_TABLE_BITS));
-	*bits = BROTLI_HC_FAST_LOAD_BITS(table);
-	*value = BROTLI_HC_FAST_LOAD_VALUE(table);
-}
-
-/* Decodes the next Huffman code using data prepared by PreloadSymbol.
-   Reads 0 - 15 bits. Also peeks 8 following bits. */
-static BROTLI_INLINE brotli_reg_t ReadPreloadedSymbol(const HuffmanCode *table, BrotliBitReader *br, brotli_reg_t *bits,
-                                                      brotli_reg_t *value) {
-	brotli_reg_t result = *value;
-	if (BROTLI_PREDICT_FALSE(*bits > HUFFMAN_TABLE_BITS)) {
-		brotli_reg_t val = BrotliGet16BitsUnmasked(br);
-		const HuffmanCode *ext = table + (val & HUFFMAN_TABLE_MASK) + *value;
-		brotli_reg_t mask = BitMask((*bits - HUFFMAN_TABLE_BITS));
-		BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(ext);
-		BrotliDropBits(br, HUFFMAN_TABLE_BITS);
-		BROTLI_HC_ADJUST_TABLE_INDEX(ext, (val >> HUFFMAN_TABLE_BITS) & mask);
-		BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(ext));
-		result = BROTLI_HC_FAST_LOAD_VALUE(ext);
-	} else {
-		BrotliDropBits(br, *bits);
-	}
-	PreloadSymbol(0, table, br, bits, value);
-	return result;
-}
-
-static BROTLI_INLINE brotli_reg_t Log2Floor(brotli_reg_t x) {
-	brotli_reg_t result = 0;
-	while (x) {
-		x >>= 1;
-		++result;
-	}
-	return result;
-}
-
-/* Reads (s->symbol + 1) symbols.
-   Totally 1..4 symbols are read, 1..11 bits each.
-   The list of symbols MUST NOT contain duplicates. */
-static BrotliDecoderErrorCode ReadSimpleHuffmanSymbols(brotli_reg_t alphabet_size_max, brotli_reg_t alphabet_size_limit,
-                                                       BrotliDecoderState *s) {
-	/* max_bits == 1..11; symbol == 0..3; 1..44 bits will be read. */
-	BrotliBitReader *br = &s->br;
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-	brotli_reg_t max_bits = Log2Floor(alphabet_size_max - 1);
-	brotli_reg_t i = h->sub_loop_counter;
-	brotli_reg_t num_symbols = h->symbol;
-	while (i <= num_symbols) {
-		brotli_reg_t v;
-		if (BROTLI_PREDICT_FALSE(!BrotliSafeReadBits(br, max_bits, &v))) {
-			h->sub_loop_counter = i;
-			h->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_READ;
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		if (v >= alphabet_size_limit) {
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET);
-		}
-		h->symbols_lists_array[i] = (uint16_t)v;
-		BROTLI_LOG_UINT(h->symbols_lists_array[i]);
-		++i;
-	}
-
-	for (i = 0; i < num_symbols; ++i) {
-		brotli_reg_t k = i + 1;
-		for (; k <= num_symbols; ++k) {
-			if (h->symbols_lists_array[i] == h->symbols_lists_array[k]) {
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME);
-			}
-		}
-	}
-
-	return BROTLI_DECODER_SUCCESS;
-}
-
-/* Process single decoded symbol code length:
-    A) reset the repeat variable
-    B) remember code length (if it is not 0)
-    C) extend corresponding index-chain
-    D) reduce the Huffman space
-    E) update the histogram */
-static BROTLI_INLINE void ProcessSingleCodeLength(brotli_reg_t code_len, brotli_reg_t *symbol, brotli_reg_t *repeat,
-                                                  brotli_reg_t *space, brotli_reg_t *prev_code_len,
-                                                  uint16_t *symbol_lists, uint16_t *code_length_histo,
-                                                  int *next_symbol) {
-	*repeat = 0;
-	if (code_len != 0) { /* code_len == 1..15 */
-		symbol_lists[next_symbol[code_len]] = (uint16_t)(*symbol);
-		next_symbol[code_len] = (int)(*symbol);
-		*prev_code_len = code_len;
-		*space -= 32768U >> code_len;
-		code_length_histo[code_len]++;
-		BROTLI_LOG(("[ReadHuffmanCode] code_length[%d] = %d\n", (int)*symbol, (int)code_len));
-	}
-	(*symbol)++;
-}
-
-/* Process repeated symbol code length.
-    A) Check if it is the extension of previous repeat sequence; if the decoded
-       value is not BROTLI_REPEAT_PREVIOUS_CODE_LENGTH, then it is a new
-       symbol-skip
-    B) Update repeat variable
-    C) Check if operation is feasible (fits alphabet)
-    D) For each symbol do the same operations as in ProcessSingleCodeLength
-
-   PRECONDITION: code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH or
-                 code_len == BROTLI_REPEAT_ZERO_CODE_LENGTH */
-static BROTLI_INLINE void ProcessRepeatedCodeLength(brotli_reg_t code_len, brotli_reg_t repeat_delta,
-                                                    brotli_reg_t alphabet_size, brotli_reg_t *symbol,
-                                                    brotli_reg_t *repeat, brotli_reg_t *space,
-                                                    brotli_reg_t *prev_code_len, brotli_reg_t *repeat_code_len,
-                                                    uint16_t *symbol_lists, uint16_t *code_length_histo,
-                                                    int *next_symbol) {
-	brotli_reg_t old_repeat;
-	brotli_reg_t extra_bits = 3; /* for BROTLI_REPEAT_ZERO_CODE_LENGTH */
-	brotli_reg_t new_len = 0;    /* for BROTLI_REPEAT_ZERO_CODE_LENGTH */
-	if (code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH) {
-		new_len = *prev_code_len;
-		extra_bits = 2;
-	}
-	if (*repeat_code_len != new_len) {
-		*repeat = 0;
-		*repeat_code_len = new_len;
-	}
-	old_repeat = *repeat;
-	if (*repeat > 0) {
-		*repeat -= 2;
-		*repeat <<= extra_bits;
-	}
-	*repeat += repeat_delta + 3U;
-	repeat_delta = *repeat - old_repeat;
-	if (*symbol + repeat_delta > alphabet_size) {
-		BROTLI_DUMP();
-		*symbol = alphabet_size;
-		*space = 0xFFFFF;
-		return;
-	}
-	BROTLI_LOG(("[ReadHuffmanCode] code_length[%d..%d] = %d\n", (int)*symbol, (int)(*symbol + repeat_delta - 1),
-	            (int)*repeat_code_len));
-	if (*repeat_code_len != 0) {
-		brotli_reg_t last = *symbol + repeat_delta;
-		int next = next_symbol[*repeat_code_len];
-		do {
-			symbol_lists[next] = (uint16_t)*symbol;
-			next = (int)*symbol;
-		} while (++(*symbol) != last);
-		next_symbol[*repeat_code_len] = next;
-		*space -= repeat_delta << (15 - *repeat_code_len);
-		code_length_histo[*repeat_code_len] = (uint16_t)(code_length_histo[*repeat_code_len] + repeat_delta);
-	} else {
-		*symbol += repeat_delta;
-	}
-}
-
-/* Reads and decodes symbol codelengths. */
-static BrotliDecoderErrorCode ReadSymbolCodeLengths(brotli_reg_t alphabet_size, BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-	brotli_reg_t symbol = h->symbol;
-	brotli_reg_t repeat = h->repeat;
-	brotli_reg_t space = h->space;
-	brotli_reg_t prev_code_len = h->prev_code_len;
-	brotli_reg_t repeat_code_len = h->repeat_code_len;
-	uint16_t *symbol_lists = h->symbol_lists;
-	uint16_t *code_length_histo = h->code_length_histo;
-	int *next_symbol = h->next_symbol;
-	if (!BrotliWarmupBitReader(br)) {
-		return BROTLI_DECODER_NEEDS_MORE_INPUT;
-	}
-	while (symbol < alphabet_size && space > 0) {
-		const HuffmanCode *p = h->table;
-		brotli_reg_t code_len;
-		BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(p);
-		if (!BrotliCheckInputAmount(br)) {
-			h->symbol = symbol;
-			h->repeat = repeat;
-			h->prev_code_len = prev_code_len;
-			h->repeat_code_len = repeat_code_len;
-			h->space = space;
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		BrotliFillBitWindow16(br);
-		BROTLI_HC_ADJUST_TABLE_INDEX(p,
-		                             BrotliGetBitsUnmasked(br) & BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH));
-		BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(p)); /* Use 1..5 bits. */
-		code_len = BROTLI_HC_FAST_LOAD_VALUE(p);         /* code_len == 0..17 */
-		if (code_len < BROTLI_REPEAT_PREVIOUS_CODE_LENGTH) {
-			ProcessSingleCodeLength(code_len, &symbol, &repeat, &space, &prev_code_len, symbol_lists, code_length_histo,
-			                        next_symbol);
-		} else { /* code_len == 16..17, extra_bits == 2..3 */
-			brotli_reg_t extra_bits = (code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH) ? 2 : 3;
-			brotli_reg_t repeat_delta = BrotliGetBitsUnmasked(br) & BitMask(extra_bits);
-			BrotliDropBits(br, extra_bits);
-			ProcessRepeatedCodeLength(code_len, repeat_delta, alphabet_size, &symbol, &repeat, &space, &prev_code_len,
-			                          &repeat_code_len, symbol_lists, code_length_histo, next_symbol);
-		}
-	}
-	h->space = space;
-	return BROTLI_DECODER_SUCCESS;
-}
-
-static BrotliDecoderErrorCode SafeReadSymbolCodeLengths(brotli_reg_t alphabet_size, BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-	BROTLI_BOOL get_byte = BROTLI_FALSE;
-	while (h->symbol < alphabet_size && h->space > 0) {
-		const HuffmanCode *p = h->table;
-		brotli_reg_t code_len;
-		brotli_reg_t available_bits;
-		brotli_reg_t bits = 0;
-		BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(p);
-		if (get_byte && !BrotliPullByte(br))
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		get_byte = BROTLI_FALSE;
-		available_bits = BrotliGetAvailableBits(br);
-		if (available_bits != 0) {
-			bits = (uint32_t)BrotliGetBitsUnmasked(br);
-		}
-		BROTLI_HC_ADJUST_TABLE_INDEX(p, bits & BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH));
-		if (BROTLI_HC_FAST_LOAD_BITS(p) > available_bits) {
-			get_byte = BROTLI_TRUE;
-			continue;
-		}
-		code_len = BROTLI_HC_FAST_LOAD_VALUE(p); /* code_len == 0..17 */
-		if (code_len < BROTLI_REPEAT_PREVIOUS_CODE_LENGTH) {
-			BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(p));
-			ProcessSingleCodeLength(code_len, &h->symbol, &h->repeat, &h->space, &h->prev_code_len, h->symbol_lists,
-			                        h->code_length_histo, h->next_symbol);
-		} else { /* code_len == 16..17, extra_bits == 2..3 */
-			brotli_reg_t extra_bits = code_len - 14U;
-			brotli_reg_t repeat_delta = (bits >> BROTLI_HC_FAST_LOAD_BITS(p)) & BitMask(extra_bits);
-			if (available_bits < BROTLI_HC_FAST_LOAD_BITS(p) + extra_bits) {
-				get_byte = BROTLI_TRUE;
-				continue;
-			}
-			BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(p) + extra_bits);
-			ProcessRepeatedCodeLength(code_len, repeat_delta, alphabet_size, &h->symbol, &h->repeat, &h->space,
-			                          &h->prev_code_len, &h->repeat_code_len, h->symbol_lists, h->code_length_histo,
-			                          h->next_symbol);
-		}
-	}
-	return BROTLI_DECODER_SUCCESS;
-}
-
-/* Reads and decodes 15..18 codes using static prefix code.
-   Each code is 2..4 bits long. In total 30..72 bits are used. */
-static BrotliDecoderErrorCode ReadCodeLengthCodeLengths(BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-	brotli_reg_t num_codes = h->repeat;
-	brotli_reg_t space = h->space;
-	brotli_reg_t i = h->sub_loop_counter;
-	for (; i < BROTLI_CODE_LENGTH_CODES; ++i) {
-		const uint8_t code_len_idx = kCodeLengthCodeOrder[i];
-		brotli_reg_t ix;
-		brotli_reg_t v;
-		if (BROTLI_PREDICT_FALSE(!BrotliSafeGetBits(br, 4, &ix))) {
-			brotli_reg_t available_bits = BrotliGetAvailableBits(br);
-			if (available_bits != 0) {
-				ix = BrotliGetBitsUnmasked(br) & 0xF;
-			} else {
-				ix = 0;
-			}
-			if (kCodeLengthPrefixLength[ix] > available_bits) {
-				h->sub_loop_counter = i;
-				h->repeat = num_codes;
-				h->space = space;
-				h->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX;
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-		}
-		v = kCodeLengthPrefixValue[ix];
-		BrotliDropBits(br, kCodeLengthPrefixLength[ix]);
-		h->code_length_code_lengths[code_len_idx] = (uint8_t)v;
-		BROTLI_LOG_ARRAY_INDEX(h->code_length_code_lengths, code_len_idx);
-		if (v != 0) {
-			space = space - (32U >> v);
-			++num_codes;
-			++h->code_length_histo[v];
-			if (space - 1U >= 32U) {
-				/* space is 0 or wrapped around. */
-				break;
-			}
-		}
-	}
-	if (!(num_codes == 1 || space == 0)) {
-		return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_CL_SPACE);
-	}
-	return BROTLI_DECODER_SUCCESS;
-}
-
-/* Decodes the Huffman tables.
-   There are 2 scenarios:
-    A) Huffman code contains only few symbols (1..4). Those symbols are read
-       directly; their code lengths are defined by the number of symbols.
-       For this scenario 4 - 49 bits will be read.
-
-    B) 2-phase decoding:
-    B.1) Small Huffman table is decoded; it is specified with code lengths
-         encoded with predefined entropy code. 32 - 74 bits are used.
-    B.2) Decoded table is used to decode code lengths of symbols in resulting
-         Huffman table. In worst case 3520 bits are read. */
-static BrotliDecoderErrorCode ReadHuffmanCode(brotli_reg_t alphabet_size_max, brotli_reg_t alphabet_size_limit,
-                                              HuffmanCode *table, brotli_reg_t *opt_table_size, BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-	/* State machine. */
-	for (;;) {
-		switch (h->substate_huffman) {
-		case BROTLI_STATE_HUFFMAN_NONE:
-			if (!BrotliSafeReadBits(br, 2, &h->sub_loop_counter)) {
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			BROTLI_LOG_UINT(h->sub_loop_counter);
-			/* The value is used as follows:
-			   1 for simple code;
-			   0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */
-			if (h->sub_loop_counter != 1) {
-				h->space = 32;
-				h->repeat = 0; /* num_codes */
-				memset(&h->code_length_histo[0], 0,
-				       sizeof(h->code_length_histo[0]) * (BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1));
-				memset(&h->code_length_code_lengths[0], 0, sizeof(h->code_length_code_lengths));
-				h->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX;
-				continue;
-			}
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_SIMPLE_SIZE:
-			/* Read symbols, codes & code lengths directly. */
-			if (!BrotliSafeReadBits(br, 2, &h->symbol)) { /* num_symbols */
-				h->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_SIZE;
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			h->sub_loop_counter = 0;
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_SIMPLE_READ: {
-			BrotliDecoderErrorCode result = ReadSimpleHuffmanSymbols(alphabet_size_max, alphabet_size_limit, s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				return result;
-			}
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_SIMPLE_BUILD: {
-			brotli_reg_t table_size;
-			if (h->symbol == 3) {
-				brotli_reg_t bits;
-				if (!BrotliSafeReadBits(br, 1, &bits)) {
-					h->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_BUILD;
-					return BROTLI_DECODER_NEEDS_MORE_INPUT;
-				}
-				h->symbol += bits;
-			}
-			BROTLI_LOG_UINT(h->symbol);
-			table_size =
-			    BrotliBuildSimpleHuffmanTable(table, HUFFMAN_TABLE_BITS, h->symbols_lists_array, (uint32_t)h->symbol);
-			if (opt_table_size) {
-				*opt_table_size = table_size;
-			}
-			h->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
-			return BROTLI_DECODER_SUCCESS;
-		}
-
-		/* Decode Huffman-coded code lengths. */
-		case BROTLI_STATE_HUFFMAN_COMPLEX: {
-			brotli_reg_t i;
-			BrotliDecoderErrorCode result = ReadCodeLengthCodeLengths(s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				return result;
-			}
-			BrotliBuildCodeLengthsHuffmanTable(h->table, h->code_length_code_lengths, h->code_length_histo);
-			memset(&h->code_length_histo[0], 0, sizeof(h->code_length_histo));
-			for (i = 0; i <= BROTLI_HUFFMAN_MAX_CODE_LENGTH; ++i) {
-				h->next_symbol[i] = (int)i - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
-				h->symbol_lists[h->next_symbol[i]] = 0xFFFF;
-			}
-
-			h->symbol = 0;
-			h->prev_code_len = BROTLI_INITIAL_REPEATED_CODE_LENGTH;
-			h->repeat = 0;
-			h->repeat_code_len = 0;
-			h->space = 32768;
-			h->substate_huffman = BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS: {
-			brotli_reg_t table_size;
-			BrotliDecoderErrorCode result = ReadSymbolCodeLengths(alphabet_size_limit, s);
-			if (result == BROTLI_DECODER_NEEDS_MORE_INPUT) {
-				result = SafeReadSymbolCodeLengths(alphabet_size_limit, s);
-			}
-			if (result != BROTLI_DECODER_SUCCESS) {
-				return result;
-			}
-
-			if (h->space != 0) {
-				BROTLI_LOG(("[ReadHuffmanCode] space = %d\n", (int)h->space));
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE);
-			}
-			table_size = BrotliBuildHuffmanTable(table, HUFFMAN_TABLE_BITS, h->symbol_lists, h->code_length_histo);
-			if (opt_table_size) {
-				*opt_table_size = table_size;
-			}
-			h->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
-			return BROTLI_DECODER_SUCCESS;
-		}
-
-		default:
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_UNREACHABLE); /* COV_NF_LINE */
-		}
-	}
-}
-
-/* Decodes a block length by reading 3..39 bits. */
-static BROTLI_INLINE brotli_reg_t ReadBlockLength(const HuffmanCode *table, BrotliBitReader *br) {
-	brotli_reg_t code;
-	brotli_reg_t nbits;
-	code = ReadSymbol(table, br);
-	nbits = _kBrotliPrefixCodeRanges[code].nbits; /* nbits == 2..24 */
-	return _kBrotliPrefixCodeRanges[code].offset + BrotliReadBits24(br, nbits);
-}
-
-/* WARNING: if state is not BROTLI_STATE_READ_BLOCK_LENGTH_NONE, then
-   reading can't be continued with ReadBlockLength. */
-static BROTLI_INLINE BROTLI_BOOL SafeReadBlockLength(BrotliDecoderState *s, brotli_reg_t *result,
-                                                     const HuffmanCode *table, BrotliBitReader *br) {
-	brotli_reg_t index;
-	if (s->substate_read_block_length == BROTLI_STATE_READ_BLOCK_LENGTH_NONE) {
-		if (!SafeReadSymbol(table, br, &index)) {
-			return BROTLI_FALSE;
-		}
-	} else {
-		index = s->block_length_index;
-	}
-	{
-		brotli_reg_t bits;
-		brotli_reg_t nbits = _kBrotliPrefixCodeRanges[index].nbits;
-		brotli_reg_t offset = _kBrotliPrefixCodeRanges[index].offset;
-		if (!BrotliSafeReadBits(br, nbits, &bits)) {
-			s->block_length_index = index;
-			s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX;
-			return BROTLI_FALSE;
-		}
-		*result = offset + bits;
-		s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
-		return BROTLI_TRUE;
-	}
-}
-
-/* Transform:
-    1) initialize list L with values 0, 1,... 255
-    2) For each input element X:
-    2.1) let Y = L[X]
-    2.2) remove X-th element from L
-    2.3) prepend Y to L
-    2.4) append Y to output
-
-   In most cases max(Y) <= 7, so most of L remains intact.
-   To reduce the cost of initialization, we reuse L, remember the upper bound
-   of Y values, and reinitialize only first elements in L.
-
-   Most of input values are 0 and 1. To reduce number of branches, we replace
-   inner for loop with do-while. */
-static BROTLI_NOINLINE void InverseMoveToFrontTransform(uint8_t *v, brotli_reg_t v_len, BrotliDecoderState *state) {
-	/* Reinitialize elements that could have been changed. */
-	brotli_reg_t i = 1;
-	brotli_reg_t upper_bound = state->mtf_upper_bound;
-	uint32_t *mtf = &state->mtf[1]; /* Make mtf[-1] addressable. */
-	uint8_t *mtf_u8 = (uint8_t *)mtf;
-	/* Load endian-aware constant. */
-	const uint8_t b0123[4] = {0, 1, 2, 3};
-	uint32_t pattern;
-	memcpy(&pattern, &b0123, 4);
-
-	/* Initialize list using 4 consequent values pattern. */
-	mtf[0] = pattern;
-	do {
-		pattern += 0x04040404; /* Advance all 4 values by 4. */
-		mtf[i] = pattern;
-		i++;
-	} while (i <= upper_bound);
-
-	/* Transform the input. */
-	upper_bound = 0;
-	for (i = 0; i < v_len; ++i) {
-		int index = v[i];
-		uint8_t value = mtf_u8[index];
-		upper_bound |= v[i];
-		v[i] = value;
-		mtf_u8[-1] = value;
-		do {
-			index--;
-			mtf_u8[index + 1] = mtf_u8[index];
-		} while (index >= 0);
-	}
-	/* Remember amount of elements to be reinitialized. */
-	state->mtf_upper_bound = upper_bound >> 2;
-}
-
-/* Decodes a series of Huffman table using ReadHuffmanCode function. */
-static BrotliDecoderErrorCode HuffmanTreeGroupDecode(HuffmanTreeGroup *group, BrotliDecoderState *s) {
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-	if (h->substate_tree_group != BROTLI_STATE_TREE_GROUP_LOOP) {
-		h->next = group->codes;
-		h->htree_index = 0;
-		h->substate_tree_group = BROTLI_STATE_TREE_GROUP_LOOP;
-	}
-	while (h->htree_index < group->num_htrees) {
-		brotli_reg_t table_size;
-		BrotliDecoderErrorCode result =
-		    ReadHuffmanCode(group->alphabet_size_max, group->alphabet_size_limit, h->next, &table_size, s);
-		if (result != BROTLI_DECODER_SUCCESS)
-			return result;
-		group->htrees[h->htree_index] = h->next;
-		h->next += table_size;
-		++h->htree_index;
-	}
-	h->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE;
-	return BROTLI_DECODER_SUCCESS;
-}
-
-/* Decodes a context map.
-   Decoding is done in 4 phases:
-    1) Read auxiliary information (6..16 bits) and allocate memory.
-       In case of trivial context map, decoding is finished at this phase.
-    2) Decode Huffman table using ReadHuffmanCode function.
-       This table will be used for reading context map items.
-    3) Read context map items; "0" values could be run-length encoded.
-    4) Optionally, apply InverseMoveToFront transform to the resulting map. */
-static BrotliDecoderErrorCode DecodeContextMap(brotli_reg_t context_map_size, brotli_reg_t *num_htrees,
-                                               uint8_t **context_map_arg, BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-	BrotliDecoderErrorCode result = BROTLI_DECODER_SUCCESS;
-	BrotliMetablockHeaderArena *h = &s->arena.header;
-
-	switch ((int)h->substate_context_map) {
-	case BROTLI_STATE_CONTEXT_MAP_NONE:
-		result = DecodeVarLenUint8(s, br, num_htrees);
-		if (result != BROTLI_DECODER_SUCCESS) {
-			return result;
-		}
-		(*num_htrees)++;
-		h->context_index = 0;
-		BROTLI_LOG_UINT(context_map_size);
-		BROTLI_LOG_UINT(*num_htrees);
-		*context_map_arg = (uint8_t *)BROTLI_DECODER_ALLOC(s, (size_t)context_map_size);
-		if (*context_map_arg == 0) {
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP);
-		}
-		if (*num_htrees <= 1) {
-			memset(*context_map_arg, 0, (size_t)context_map_size);
-			return BROTLI_DECODER_SUCCESS;
-		}
-		h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_READ_PREFIX;
-		/* Fall through. */
-
-	case BROTLI_STATE_CONTEXT_MAP_READ_PREFIX: {
-		brotli_reg_t bits;
-		/* In next stage ReadHuffmanCode uses at least 4 bits, so it is safe
-		   to peek 4 bits ahead. */
-		if (!BrotliSafeGetBits(br, 5, &bits)) {
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		if ((bits & 1) != 0) { /* Use RLE for zeros. */
-			h->max_run_length_prefix = (bits >> 1) + 1;
-			BrotliDropBits(br, 5);
-		} else {
-			h->max_run_length_prefix = 0;
-			BrotliDropBits(br, 1);
-		}
-		BROTLI_LOG_UINT(h->max_run_length_prefix);
-		h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_HUFFMAN;
-	}
-		/* Fall through. */
-
-	case BROTLI_STATE_CONTEXT_MAP_HUFFMAN: {
-		brotli_reg_t alphabet_size = *num_htrees + h->max_run_length_prefix;
-		result = ReadHuffmanCode(alphabet_size, alphabet_size, h->context_map_table, NULL, s);
-		if (result != BROTLI_DECODER_SUCCESS)
-			return result;
-		h->code = 0xFFFF;
-		h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_DECODE;
-	}
-		/* Fall through. */
-
-	case BROTLI_STATE_CONTEXT_MAP_DECODE: {
-		brotli_reg_t context_index = h->context_index;
-		brotli_reg_t max_run_length_prefix = h->max_run_length_prefix;
-		uint8_t *context_map = *context_map_arg;
-		brotli_reg_t code = h->code;
-		BROTLI_BOOL skip_preamble = (code != 0xFFFF);
-		while (context_index < context_map_size || skip_preamble) {
-			if (!skip_preamble) {
-				if (!SafeReadSymbol(h->context_map_table, br, &code)) {
-					h->code = 0xFFFF;
-					h->context_index = context_index;
-					return BROTLI_DECODER_NEEDS_MORE_INPUT;
-				}
-				BROTLI_LOG_UINT(code);
-
-				if (code == 0) {
-					context_map[context_index++] = 0;
-					continue;
-				}
-				if (code > max_run_length_prefix) {
-					context_map[context_index++] = (uint8_t)(code - max_run_length_prefix);
-					continue;
-				}
-			} else {
-				skip_preamble = BROTLI_FALSE;
-			}
-			/* RLE sub-stage. */
-			{
-				brotli_reg_t reps;
-				if (!BrotliSafeReadBits(br, code, &reps)) {
-					h->code = code;
-					h->context_index = context_index;
-					return BROTLI_DECODER_NEEDS_MORE_INPUT;
-				}
-				reps += 1U << code;
-				BROTLI_LOG_UINT(reps);
-				if (context_index + reps > context_map_size) {
-					return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT);
-				}
-				do {
-					context_map[context_index++] = 0;
-				} while (--reps);
-			}
-		}
-	}
-		/* Fall through. */
-
-	case BROTLI_STATE_CONTEXT_MAP_TRANSFORM: {
-		brotli_reg_t bits;
-		if (!BrotliSafeReadBits(br, 1, &bits)) {
-			h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_TRANSFORM;
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		if (bits != 0) {
-			InverseMoveToFrontTransform(*context_map_arg, context_map_size, s);
-		}
-		h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE;
-		return BROTLI_DECODER_SUCCESS;
-	}
-
-	default:
-		return BROTLI_FAILURE(BROTLI_DECODER_ERROR_UNREACHABLE); /* COV_NF_LINE */
-	}
-}
-
-/* Decodes a command or literal and updates block type ring-buffer.
-   Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(int safe, BrotliDecoderState *s, int tree_type) {
-	brotli_reg_t max_block_type = s->num_block_types[tree_type];
-	const HuffmanCode *type_tree = &s->block_type_trees[tree_type * BROTLI_HUFFMAN_MAX_SIZE_258];
-	const HuffmanCode *len_tree = &s->block_len_trees[tree_type * BROTLI_HUFFMAN_MAX_SIZE_26];
-	BrotliBitReader *br = &s->br;
-	brotli_reg_t *ringbuffer = &s->block_type_rb[tree_type * 2];
-	brotli_reg_t block_type;
-	if (max_block_type <= 1) {
-		return BROTLI_FALSE;
-	}
-
-	/* Read 0..15 + 3..39 bits. */
-	if (!safe) {
-		block_type = ReadSymbol(type_tree, br);
-		s->block_length[tree_type] = ReadBlockLength(len_tree, br);
-	} else {
-		BrotliBitReaderState memento;
-		BrotliBitReaderSaveState(br, &memento);
-		if (!SafeReadSymbol(type_tree, br, &block_type))
-			return BROTLI_FALSE;
-		if (!SafeReadBlockLength(s, &s->block_length[tree_type], len_tree, br)) {
-			s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
-			BrotliBitReaderRestoreState(br, &memento);
-			return BROTLI_FALSE;
-		}
-	}
-
-	if (block_type == 1) {
-		block_type = ringbuffer[1] + 1;
-	} else if (block_type == 0) {
-		block_type = ringbuffer[0];
-	} else {
-		block_type -= 2;
-	}
-	if (block_type >= max_block_type) {
-		block_type -= max_block_type;
-	}
-	ringbuffer[0] = ringbuffer[1];
-	ringbuffer[1] = block_type;
-	return BROTLI_TRUE;
-}
-
-static BROTLI_INLINE void DetectTrivialLiteralBlockTypes(BrotliDecoderState *s) {
-	size_t i;
-	for (i = 0; i < 8; ++i)
-		s->trivial_literal_contexts[i] = 0;
-	for (i = 0; i < s->num_block_types[0]; i++) {
-		size_t offset = i << BROTLI_LITERAL_CONTEXT_BITS;
-		size_t error = 0;
-		size_t sample = s->context_map[offset];
-		size_t j;
-		for (j = 0; j < (1u << BROTLI_LITERAL_CONTEXT_BITS);) {
-			/* NOLINTNEXTLINE(bugprone-macro-repeated-side-effects) */
-			BROTLI_REPEAT_4({ error |= s->context_map[offset + j++] ^ sample; })
-		}
-		if (error == 0) {
-			s->trivial_literal_contexts[i >> 5] |= 1u << (i & 31);
-		}
-	}
-}
-
-static BROTLI_INLINE void PrepareLiteralDecoding(BrotliDecoderState *s) {
-	uint8_t context_mode;
-	size_t trivial;
-	brotli_reg_t block_type = s->block_type_rb[1];
-	brotli_reg_t context_offset = block_type << BROTLI_LITERAL_CONTEXT_BITS;
-	s->context_map_slice = s->context_map + context_offset;
-	trivial = s->trivial_literal_contexts[block_type >> 5];
-	s->trivial_literal_context = (trivial >> (block_type & 31)) & 1;
-	s->literal_htree = s->literal_hgroup.htrees[s->context_map_slice[0]];
-	context_mode = s->context_modes[block_type] & 3;
-	s->context_lookup = BROTLI_CONTEXT_LUT(context_mode);
-}
-
-/* Decodes the block type and updates the state for literal context.
-   Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeLiteralBlockSwitchInternal(int safe, BrotliDecoderState *s) {
-	if (!DecodeBlockTypeAndLength(safe, s, 0)) {
-		return BROTLI_FALSE;
-	}
-	PrepareLiteralDecoding(s);
-	return BROTLI_TRUE;
-}
-
-static void BROTLI_NOINLINE DecodeLiteralBlockSwitch(BrotliDecoderState *s) {
-	DecodeLiteralBlockSwitchInternal(0, s);
-}
-
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeLiteralBlockSwitch(BrotliDecoderState *s) {
-	return DecodeLiteralBlockSwitchInternal(1, s);
-}
-
-/* Block switch for insert/copy length.
-   Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeCommandBlockSwitchInternal(int safe, BrotliDecoderState *s) {
-	if (!DecodeBlockTypeAndLength(safe, s, 1)) {
-		return BROTLI_FALSE;
-	}
-	s->htree_command = s->insert_copy_hgroup.htrees[s->block_type_rb[3]];
-	return BROTLI_TRUE;
-}
-
-static void BROTLI_NOINLINE DecodeCommandBlockSwitch(BrotliDecoderState *s) {
-	DecodeCommandBlockSwitchInternal(0, s);
-}
-
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeCommandBlockSwitch(BrotliDecoderState *s) {
-	return DecodeCommandBlockSwitchInternal(1, s);
-}
-
-/* Block switch for distance codes.
-   Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeDistanceBlockSwitchInternal(int safe, BrotliDecoderState *s) {
-	if (!DecodeBlockTypeAndLength(safe, s, 2)) {
-		return BROTLI_FALSE;
-	}
-	s->dist_context_map_slice = s->dist_context_map + (s->block_type_rb[5] << BROTLI_DISTANCE_CONTEXT_BITS);
-	s->dist_htree_index = s->dist_context_map_slice[s->distance_context];
-	return BROTLI_TRUE;
-}
-
-static void BROTLI_NOINLINE DecodeDistanceBlockSwitch(BrotliDecoderState *s) {
-	DecodeDistanceBlockSwitchInternal(0, s);
-}
-
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeDistanceBlockSwitch(BrotliDecoderState *s) {
-	return DecodeDistanceBlockSwitchInternal(1, s);
-}
-
-static size_t UnwrittenBytes(const BrotliDecoderState *s, BROTLI_BOOL wrap) {
-	size_t pos = wrap && s->pos > s->ringbuffer_size ? (size_t)s->ringbuffer_size : (size_t)(s->pos);
-	size_t partial_pos_rb = (s->rb_roundtrips * (size_t)s->ringbuffer_size) + pos;
-	return partial_pos_rb - s->partial_pos_out;
-}
-
-/* Dumps output.
-   Returns BROTLI_DECODER_NEEDS_MORE_OUTPUT only if there is more output to push
-   and either ring-buffer is as big as window size, or |force| is true. */
-static BrotliDecoderErrorCode BROTLI_NOINLINE WriteRingBuffer(BrotliDecoderState *s, size_t *available_out,
-                                                              uint8_t **next_out, size_t *total_out,
-                                                              BROTLI_BOOL force) {
-	uint8_t *start = s->ringbuffer + (s->partial_pos_out & (size_t)s->ringbuffer_mask);
-	size_t to_write = UnwrittenBytes(s, BROTLI_TRUE);
-	size_t num_written = *available_out;
-	if (num_written > to_write) {
-		num_written = to_write;
-	}
-	if (s->meta_block_remaining_len < 0) {
-		return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1);
-	}
-	if (next_out && !*next_out) {
-		*next_out = start;
-	} else {
-		if (next_out) {
-			memcpy(*next_out, start, num_written);
-			*next_out += num_written;
-		}
-	}
-	*available_out -= num_written;
-	BROTLI_LOG_UINT(to_write);
-	BROTLI_LOG_UINT(num_written);
-	s->partial_pos_out += num_written;
-	if (total_out) {
-		*total_out = s->partial_pos_out;
-	}
-	if (num_written < to_write) {
-		if (s->ringbuffer_size == (1 << s->window_bits) || force) {
-			return BROTLI_DECODER_NEEDS_MORE_OUTPUT;
-		} else {
-			return BROTLI_DECODER_SUCCESS;
-		}
-	}
-	/* Wrap ring buffer only if it has reached its maximal size. */
-	if (s->ringbuffer_size == (1 << s->window_bits) && s->pos >= s->ringbuffer_size) {
-		s->pos -= s->ringbuffer_size;
-		s->rb_roundtrips++;
-		s->should_wrap_ringbuffer = (size_t)s->pos != 0 ? 1 : 0;
-	}
-	return BROTLI_DECODER_SUCCESS;
-}
-
-static void BROTLI_NOINLINE WrapRingBuffer(BrotliDecoderState *s) {
-	if (s->should_wrap_ringbuffer) {
-		memcpy(s->ringbuffer, s->ringbuffer_end, (size_t)s->pos);
-		s->should_wrap_ringbuffer = 0;
-	}
-}
-
-/* Allocates ring-buffer.
-
-   s->ringbuffer_size MUST be updated by BrotliCalculateRingBufferSize before
-   this function is called.
-
-   Last two bytes of ring-buffer are initialized to 0, so context calculation
-   could be done uniformly for the first two and all other positions. */
-static BROTLI_BOOL BROTLI_NOINLINE BrotliEnsureRingBuffer(BrotliDecoderState *s) {
-	uint8_t *old_ringbuffer = s->ringbuffer;
-	if (s->ringbuffer_size == s->new_ringbuffer_size) {
-		return BROTLI_TRUE;
-	}
-
-	s->ringbuffer = (uint8_t *)BROTLI_DECODER_ALLOC(s, (size_t)(s->new_ringbuffer_size) + kRingBufferWriteAheadSlack);
-	if (s->ringbuffer == 0) {
-		/* Restore previous value. */
-		s->ringbuffer = old_ringbuffer;
-		return BROTLI_FALSE;
-	}
-	s->ringbuffer[s->new_ringbuffer_size - 2] = 0;
-	s->ringbuffer[s->new_ringbuffer_size - 1] = 0;
-
-	if (!!old_ringbuffer) {
-		memcpy(s->ringbuffer, old_ringbuffer, (size_t)s->pos);
-		BROTLI_DECODER_FREE(s, old_ringbuffer);
-	}
-
-	s->ringbuffer_size = s->new_ringbuffer_size;
-	s->ringbuffer_mask = s->new_ringbuffer_size - 1;
-	s->ringbuffer_end = s->ringbuffer + s->ringbuffer_size;
-
-	return BROTLI_TRUE;
-}
-
-static BrotliDecoderErrorCode BROTLI_NOINLINE SkipMetadataBlock(BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-
-	if (s->meta_block_remaining_len == 0) {
-		return BROTLI_DECODER_SUCCESS;
-	}
-
-	BROTLI_DCHECK((BrotliGetAvailableBits(br) & 7) == 0);
-
-	/* Drain accumulator. */
-	if (BrotliGetAvailableBits(br) >= 8) {
-		uint8_t buffer[8];
-		int nbytes = (int)(BrotliGetAvailableBits(br)) >> 3;
-		BROTLI_DCHECK(nbytes <= 8);
-		if (nbytes > s->meta_block_remaining_len) {
-			nbytes = s->meta_block_remaining_len;
-		}
-		BrotliCopyBytes(buffer, br, (size_t)nbytes);
-		if (s->metadata_chunk_func) {
-			s->metadata_chunk_func(s->metadata_callback_opaque, buffer, (size_t)nbytes);
-		}
-		s->meta_block_remaining_len -= nbytes;
-		if (s->meta_block_remaining_len == 0) {
-			return BROTLI_DECODER_SUCCESS;
-		}
-	}
-
-	/* Direct access to metadata is possible. */
-	int nbytes = (int)BrotliGetRemainingBytes(br);
-	if (nbytes > s->meta_block_remaining_len) {
-		nbytes = s->meta_block_remaining_len;
-	}
-	if (nbytes > 0) {
-		if (s->metadata_chunk_func) {
-			s->metadata_chunk_func(s->metadata_callback_opaque, br->next_in, (size_t)nbytes);
-		}
-		BrotliDropBytes(br, (size_t)nbytes);
-		s->meta_block_remaining_len -= nbytes;
-		if (s->meta_block_remaining_len == 0) {
-			return BROTLI_DECODER_SUCCESS;
-		}
-	}
-
-	BROTLI_DCHECK(BrotliGetRemainingBytes(br) == 0);
-
-	return BROTLI_DECODER_NEEDS_MORE_INPUT;
-}
-
-static BrotliDecoderErrorCode BROTLI_NOINLINE CopyUncompressedBlockToOutput(size_t *available_out, uint8_t **next_out,
-                                                                            size_t *total_out, BrotliDecoderState *s) {
-	/* TODO(eustas): avoid allocation for single uncompressed block. */
-	if (!BrotliEnsureRingBuffer(s)) {
-		return BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1);
-	}
-
-	/* State machine */
-	for (;;) {
-		switch (s->substate_uncompressed) {
-		case BROTLI_STATE_UNCOMPRESSED_NONE: {
-			int nbytes = (int)BrotliGetRemainingBytes(&s->br);
-			if (nbytes > s->meta_block_remaining_len) {
-				nbytes = s->meta_block_remaining_len;
-			}
-			if (s->pos + nbytes > s->ringbuffer_size) {
-				nbytes = s->ringbuffer_size - s->pos;
-			}
-			/* Copy remaining bytes from s->br.buf_ to ring-buffer. */
-			BrotliCopyBytes(&s->ringbuffer[s->pos], &s->br, (size_t)nbytes);
-			s->pos += nbytes;
-			s->meta_block_remaining_len -= nbytes;
-			if (s->pos < 1 << s->window_bits) {
-				if (s->meta_block_remaining_len == 0) {
-					return BROTLI_DECODER_SUCCESS;
-				}
-				return BROTLI_DECODER_NEEDS_MORE_INPUT;
-			}
-			s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_WRITE;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_UNCOMPRESSED_WRITE: {
-			BrotliDecoderErrorCode result;
-			result = WriteRingBuffer(s, available_out, next_out, total_out, BROTLI_FALSE);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				return result;
-			}
-			if (s->ringbuffer_size == 1 << s->window_bits) {
-				s->max_distance = s->max_backward_distance;
-			}
-			s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE;
-			break;
-		}
-		}
-	}
-	BROTLI_DCHECK(0); /* Unreachable */
-}
-
-static BROTLI_BOOL AttachCompoundDictionary(BrotliDecoderState *state, const uint8_t *data, size_t size) {
-	BrotliDecoderCompoundDictionary *addon = state->compound_dictionary;
-	if (state->state != BROTLI_STATE_UNINITED)
-		return BROTLI_FALSE;
-	if (!addon) {
-		addon = (BrotliDecoderCompoundDictionary *)BROTLI_DECODER_ALLOC(state, sizeof(BrotliDecoderCompoundDictionary));
-		if (!addon)
-			return BROTLI_FALSE;
-		addon->num_chunks = 0;
-		addon->total_size = 0;
-		addon->br_length = 0;
-		addon->br_copied = 0;
-		addon->block_bits = -1;
-		addon->chunk_offsets[0] = 0;
-		state->compound_dictionary = addon;
-	}
-	if (addon->num_chunks == 15)
-		return BROTLI_FALSE;
-	addon->chunks[addon->num_chunks] = data;
-	addon->num_chunks++;
-	addon->total_size += (int)size;
-	addon->chunk_offsets[addon->num_chunks] = addon->total_size;
-	return BROTLI_TRUE;
-}
-
-static void EnsureCoumpoundDictionaryInitialized(BrotliDecoderState *state) {
-	BrotliDecoderCompoundDictionary *addon = state->compound_dictionary;
-	/* 256 = (1 << 8) slots in block map. */
-	int block_bits = 8;
-	int cursor = 0;
-	int index = 0;
-	if (addon->block_bits != -1)
-		return;
-	while (((addon->total_size - 1) >> block_bits) != 0)
-		block_bits++;
-	block_bits -= 8;
-	addon->block_bits = block_bits;
-	while (cursor < addon->total_size) {
-		while (addon->chunk_offsets[index + 1] < cursor)
-			index++;
-		addon->block_map[cursor >> block_bits] = (uint8_t)index;
-		cursor += 1 << block_bits;
-	}
-}
-
-static BROTLI_BOOL InitializeCompoundDictionaryCopy(BrotliDecoderState *s, int address, int length) {
-	BrotliDecoderCompoundDictionary *addon = s->compound_dictionary;
-	int index;
-	EnsureCoumpoundDictionaryInitialized(s);
-	index = addon->block_map[address >> addon->block_bits];
-	while (address >= addon->chunk_offsets[index + 1])
-		index++;
-	if (addon->total_size < address + length)
-		return BROTLI_FALSE;
-	/* Update the recent distances cache. */
-	s->dist_rb[s->dist_rb_idx & 3] = s->distance_code;
-	++s->dist_rb_idx;
-	s->meta_block_remaining_len -= length;
-	addon->br_index = index;
-	addon->br_offset = address - addon->chunk_offsets[index];
-	addon->br_length = length;
-	addon->br_copied = 0;
-	return BROTLI_TRUE;
-}
-
-static int GetCompoundDictionarySize(BrotliDecoderState *s) {
-	return s->compound_dictionary ? s->compound_dictionary->total_size : 0;
-}
-
-static int CopyFromCompoundDictionary(BrotliDecoderState *s, int pos) {
-	BrotliDecoderCompoundDictionary *addon = s->compound_dictionary;
-	int orig_pos = pos;
-	while (addon->br_length != addon->br_copied) {
-		uint8_t *copy_dst = &s->ringbuffer[pos];
-		const uint8_t *copy_src = addon->chunks[addon->br_index] + addon->br_offset;
-		int space = s->ringbuffer_size - pos;
-		int rem_chunk_length =
-		    (addon->chunk_offsets[addon->br_index + 1] - addon->chunk_offsets[addon->br_index]) - addon->br_offset;
-		int length = addon->br_length - addon->br_copied;
-		if (length > rem_chunk_length)
-			length = rem_chunk_length;
-		if (length > space)
-			length = space;
-		memcpy(copy_dst, copy_src, (size_t)length);
-		pos += length;
-		addon->br_offset += length;
-		addon->br_copied += length;
-		if (length == rem_chunk_length) {
-			addon->br_index++;
-			addon->br_offset = 0;
-		}
-		if (pos == s->ringbuffer_size)
-			break;
-	}
-	return pos - orig_pos;
-}
-
-BROTLI_BOOL BrotliDecoderAttachDictionary(BrotliDecoderState *state, BrotliSharedDictionaryType type, size_t data_size,
-                                          const uint8_t data[BROTLI_ARRAY_PARAM(data_size)]) {
-	brotli_reg_t i;
-	brotli_reg_t num_prefix_before = state->dictionary->num_prefix;
-	if (state->state != BROTLI_STATE_UNINITED)
-		return BROTLI_FALSE;
-	if (!BrotliSharedDictionaryAttach(state->dictionary, type, data_size, data)) {
-		return BROTLI_FALSE;
-	}
-	for (i = num_prefix_before; i < state->dictionary->num_prefix; i++) {
-		if (!AttachCompoundDictionary(state, state->dictionary->prefix[i], state->dictionary->prefix_size[i])) {
-			return BROTLI_FALSE;
-		}
-	}
-	return BROTLI_TRUE;
-}
-
-/* Calculates the smallest feasible ring buffer.
-
-   If we know the data size is small, do not allocate more ring buffer
-   size than needed to reduce memory usage.
-
-   When this method is called, metablock size and flags MUST be decoded. */
-static void BROTLI_NOINLINE BrotliCalculateRingBufferSize(BrotliDecoderState *s) {
-	int window_size = 1 << s->window_bits;
-	int new_ringbuffer_size = window_size;
-	/* We need at least 2 bytes of ring buffer size to get the last two
-	   bytes for context from there */
-	int min_size = s->ringbuffer_size ? s->ringbuffer_size : 1024;
-	int output_size;
-
-	/* If maximum is already reached, no further extension is retired. */
-	if (s->ringbuffer_size == window_size) {
-		return;
-	}
-
-	/* Metadata blocks does not touch ring buffer. */
-	if (s->is_metadata) {
-		return;
-	}
-
-	if (!s->ringbuffer) {
-		output_size = 0;
-	} else {
-		output_size = s->pos;
-	}
-	output_size += s->meta_block_remaining_len;
-	min_size = min_size < output_size ? output_size : min_size;
-
-	if (!!s->canny_ringbuffer_allocation) {
-		/* Reduce ring buffer size to save memory when server is unscrupulous.
-		   In worst case memory usage might be 1.5x bigger for a short period of
-		   ring buffer reallocation. */
-		while ((new_ringbuffer_size >> 1) >= min_size) {
-			new_ringbuffer_size >>= 1;
-		}
-	}
-
-	s->new_ringbuffer_size = new_ringbuffer_size;
-}
-
-/* Reads 1..256 2-bit context modes. */
-static BrotliDecoderErrorCode ReadContextModes(BrotliDecoderState *s) {
-	BrotliBitReader *br = &s->br;
-	int i = s->loop_counter;
-
-	while (i < (int)s->num_block_types[0]) {
-		brotli_reg_t bits;
-		if (!BrotliSafeReadBits(br, 2, &bits)) {
-			s->loop_counter = i;
-			return BROTLI_DECODER_NEEDS_MORE_INPUT;
-		}
-		s->context_modes[i] = (uint8_t)bits;
-		BROTLI_LOG_ARRAY_INDEX(s->context_modes, i);
-		i++;
-	}
-	return BROTLI_DECODER_SUCCESS;
-}
-
-static BROTLI_INLINE void TakeDistanceFromRingBuffer(BrotliDecoderState *s) {
-	int offset = s->distance_code - 3;
-	if (s->distance_code <= 3) {
-		/* Compensate double distance-ring-buffer roll for dictionary items. */
-		s->distance_context = 1 >> s->distance_code;
-		s->distance_code = s->dist_rb[(s->dist_rb_idx - offset) & 3];
-		s->dist_rb_idx -= s->distance_context;
-	} else {
-		int index_delta = 3;
-		int delta;
-		int base = s->distance_code - 10;
-		if (s->distance_code < 10) {
-			base = s->distance_code - 4;
-		} else {
-			index_delta = 2;
-		}
-		/* Unpack one of six 4-bit values. */
-		delta = ((0x605142 >> (4 * base)) & 0xF) - 3;
-		s->distance_code = s->dist_rb[(s->dist_rb_idx + index_delta) & 0x3] + delta;
-		if (s->distance_code <= 0) {
-			/* A huge distance will cause a BROTLI_FAILURE() soon.
-			   This is a little faster than failing here. */
-			s->distance_code = 0x7FFFFFFF;
-		}
-	}
-}
-
-static BROTLI_INLINE BROTLI_BOOL SafeReadBits(BrotliBitReader *const br, brotli_reg_t n_bits, brotli_reg_t *val) {
-	if (n_bits != 0) {
-		return BrotliSafeReadBits(br, n_bits, val);
-	} else {
-		*val = 0;
-		return BROTLI_TRUE;
-	}
-}
-
-static BROTLI_INLINE BROTLI_BOOL SafeReadBits32(BrotliBitReader *const br, brotli_reg_t n_bits, brotli_reg_t *val) {
-	if (n_bits != 0) {
-		return BrotliSafeReadBits32(br, n_bits, val);
-	} else {
-		*val = 0;
-		return BROTLI_TRUE;
-	}
-}
-
-/*
-   RFC 7932 Section 4 with "..." shortenings and "[]" emendations.
-
-   Each distance ... is represented with a pair <distance code, extra bits>...
-   The distance code is encoded using a prefix code... The number of extra bits
-   can be 0..24... Two additional parameters: NPOSTFIX (0..3), and ...
-   NDIRECT (0..120) ... are encoded in the meta-block header...
-
-   The first 16 distance symbols ... reference past distances... ring buffer ...
-   Next NDIRECT distance symbols ... represent distances from 1 to NDIRECT...
-   [For] distance symbols 16 + NDIRECT and greater ... the number of extra bits
-   ... is given by the following formula:
-
-   [ xcode = dcode - NDIRECT - 16 ]
-   ndistbits = 1 + [ xcode ] >> (NPOSTFIX + 1)
-
-   ...
-*/
-
-/*
-   RFC 7932 Section 9.2 with "..." shortenings and "[]" emendations.
-
-   ... to get the actual value of the parameter NDIRECT, left-shift this
-   four-bit number by NPOSTFIX bits ...
-*/
-
-/* Remaining formulas from RFC 7932 Section 4 could be rewritten as following:
-
-     alphabet_size = 16 + NDIRECT + (max_distbits << (NPOSTFIX + 1))
-
-     half = ((xcode >> NPOSTFIX) & 1) << ndistbits
-     postfix = xcode & ((1 << NPOSTFIX) - 1)
-     range_start = 2 * (1 << ndistbits - 1 - 1)
-
-     distance = (range_start + half + extra) << NPOSTFIX + postfix + NDIRECT + 1
-
-   NB: ndistbits >= 1 -> range_start >= 0
-   NB: range_start has factor 2, as the range is covered by 2 "halves"
-   NB: extra -1 offset in range_start formula covers the absence of
-       ndistbits = 0 case
-   NB: when NPOSTFIX = 0, NDIRECT is not greater than 15
-
-   In other words, xcode has the following binary structure - XXXHPPP:
-    - XXX represent the number of extra distance bits
-    - H selects upper / lower range of distances
-    - PPP represent "postfix"
-
-  "Regular" distance encoding has NPOSTFIX = 0; omitting the postfix part
-  simplifies distance calculation.
-
-  Using NPOSTFIX > 0 allows cheaper encoding of regular structures, e.g. where
-  most of distances have the same reminder of division by 2/4/8. For example,
-  the table of int32_t values that come from different sources; if it is likely
-  that 3 highest bytes of values from the same source are the same, then
-  copy distance often looks like 4x + y.
-
-  Distance calculation could be rewritten to:
-
-    ndistbits = NDISTBITS(NDIRECT, NPOSTFIX)[dcode]
-    distance = OFFSET(NDIRECT, NPOSTFIX)[dcode] + extra << NPOSTFIX
-
-  NDISTBITS and OFFSET could be pre-calculated, as NDIRECT and NPOSTFIX could
-  change only once per meta-block.
-*/
-
-/* Calculates distance lookup table.
-   NB: it is possible to have all 64 tables precalculated. */
-static void CalculateDistanceLut(BrotliDecoderState *s) {
-	BrotliMetablockBodyArena *b = &s->arena.body;
-	brotli_reg_t npostfix = s->distance_postfix_bits;
-	brotli_reg_t ndirect = s->num_direct_distance_codes;
-	brotli_reg_t alphabet_size_limit = s->distance_hgroup.alphabet_size_limit;
-	brotli_reg_t postfix = 1u << npostfix;
-	brotli_reg_t j;
-	brotli_reg_t bits = 1;
-	brotli_reg_t half = 0;
-
-	/* Skip short codes. */
-	brotli_reg_t i = BROTLI_NUM_DISTANCE_SHORT_CODES;
-
-	/* Fill direct codes. */
-	for (j = 0; j < ndirect; ++j) {
-		b->dist_extra_bits[i] = 0;
-		b->dist_offset[i] = j + 1;
-		++i;
-	}
-
-	/* Fill regular distance codes. */
-	while (i < alphabet_size_limit) {
-		brotli_reg_t base = ndirect + ((((2 + half) << bits) - 4) << npostfix) + 1;
-		/* Always fill the complete group. */
-		for (j = 0; j < postfix; ++j) {
-			b->dist_extra_bits[i] = (uint8_t)bits;
-			b->dist_offset[i] = base + j;
-			++i;
-		}
-		bits = bits + half;
-		half = half ^ 1;
-	}
-}
-
-/* Precondition: s->distance_code < 0. */
-static BROTLI_INLINE BROTLI_BOOL ReadDistanceInternal(int safe, BrotliDecoderState *s, BrotliBitReader *br) {
-	BrotliMetablockBodyArena *b = &s->arena.body;
-	brotli_reg_t code;
-	brotli_reg_t bits;
-	BrotliBitReaderState memento;
-	HuffmanCode *distance_tree = s->distance_hgroup.htrees[s->dist_htree_index];
-	if (!safe) {
-		code = ReadSymbol(distance_tree, br);
-	} else {
-		BrotliBitReaderSaveState(br, &memento);
-		if (!SafeReadSymbol(distance_tree, br, &code)) {
-			return BROTLI_FALSE;
-		}
-	}
-	--s->block_length[2];
-	/* Convert the distance code to the actual distance by possibly
-	   looking up past distances from the s->dist_rb. */
-	s->distance_context = 0;
-	if ((code & ~0xFu) == 0) {
-		s->distance_code = (int)code;
-		TakeDistanceFromRingBuffer(s);
-		return BROTLI_TRUE;
-	}
-	if (!safe) {
-		bits = BrotliReadBits32(br, b->dist_extra_bits[code]);
-	} else {
-		if (!SafeReadBits32(br, b->dist_extra_bits[code], &bits)) {
-			++s->block_length[2];
-			BrotliBitReaderRestoreState(br, &memento);
-			return BROTLI_FALSE;
-		}
-	}
-	s->distance_code = (int)(b->dist_offset[code] + (bits << s->distance_postfix_bits));
-	return BROTLI_TRUE;
-}
-
-static BROTLI_INLINE void ReadDistance(BrotliDecoderState *s, BrotliBitReader *br) {
-	ReadDistanceInternal(0, s, br);
-}
-
-static BROTLI_INLINE BROTLI_BOOL SafeReadDistance(BrotliDecoderState *s, BrotliBitReader *br) {
-	return ReadDistanceInternal(1, s, br);
-}
-
-static BROTLI_INLINE BROTLI_BOOL ReadCommandInternal(int safe, BrotliDecoderState *s, BrotliBitReader *br,
-                                                     int *insert_length) {
-	brotli_reg_t cmd_code;
-	brotli_reg_t insert_len_extra = 0;
-	brotli_reg_t copy_length;
-	CmdLutElement v;
-	BrotliBitReaderState memento;
-	if (!safe) {
-		cmd_code = ReadSymbol(s->htree_command, br);
-	} else {
-		BrotliBitReaderSaveState(br, &memento);
-		if (!SafeReadSymbol(s->htree_command, br, &cmd_code)) {
-			return BROTLI_FALSE;
-		}
-	}
-	v = kCmdLut[cmd_code];
-	s->distance_code = v.distance_code;
-	s->distance_context = v.context;
-	s->dist_htree_index = s->dist_context_map_slice[s->distance_context];
-	*insert_length = v.insert_len_offset;
-	if (!safe) {
-		if (BROTLI_PREDICT_FALSE(v.insert_len_extra_bits != 0)) {
-			insert_len_extra = BrotliReadBits24(br, v.insert_len_extra_bits);
-		}
-		copy_length = BrotliReadBits24(br, v.copy_len_extra_bits);
-	} else {
-		if (!SafeReadBits(br, v.insert_len_extra_bits, &insert_len_extra) ||
-		    !SafeReadBits(br, v.copy_len_extra_bits, &copy_length)) {
-			BrotliBitReaderRestoreState(br, &memento);
-			return BROTLI_FALSE;
-		}
-	}
-	s->copy_length = (int)copy_length + v.copy_len_offset;
-	--s->block_length[1];
-	*insert_length += (int)insert_len_extra;
-	return BROTLI_TRUE;
-}
-
-static BROTLI_INLINE void ReadCommand(BrotliDecoderState *s, BrotliBitReader *br, int *insert_length) {
-	ReadCommandInternal(0, s, br, insert_length);
-}
-
-static BROTLI_INLINE BROTLI_BOOL SafeReadCommand(BrotliDecoderState *s, BrotliBitReader *br, int *insert_length) {
-	return ReadCommandInternal(1, s, br, insert_length);
-}
-
-static BROTLI_INLINE BROTLI_BOOL CheckInputAmount(int safe, BrotliBitReader *const br) {
-	if (safe) {
-		return BROTLI_TRUE;
-	}
-	return BrotliCheckInputAmount(br);
-}
-
-#define BROTLI_SAFE(METHOD)                       \
-  {                                               \
-    if (safe) {                                   \
-      if (!Safe##METHOD) {                        \
-        result = BROTLI_DECODER_NEEDS_MORE_INPUT; \
-        goto saveStateAndReturn;                  \
-      }                                           \
-    } else {                                      \
-      METHOD;                                     \
-    }                                             \
-  }
-
-static BROTLI_INLINE BrotliDecoderErrorCode ProcessCommandsInternal(int safe, BrotliDecoderState *s) {
-	int pos = s->pos;
-	int i = s->loop_counter;
-	BrotliDecoderErrorCode result = BROTLI_DECODER_SUCCESS;
-	BrotliBitReader *br = &s->br;
-	int compound_dictionary_size = GetCompoundDictionarySize(s);
-
-	if (!CheckInputAmount(safe, br)) {
-		result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-		goto saveStateAndReturn;
-	}
-	if (!safe) {
-		BROTLI_UNUSED(BrotliWarmupBitReader(br));
-	}
-
-	/* Jump into state machine. */
-	if (s->state == BROTLI_STATE_COMMAND_BEGIN) {
-		goto CommandBegin;
-	} else if (s->state == BROTLI_STATE_COMMAND_INNER) {
-		goto CommandInner;
-	} else if (s->state == BROTLI_STATE_COMMAND_POST_DECODE_LITERALS) {
-		goto CommandPostDecodeLiterals;
-	} else if (s->state == BROTLI_STATE_COMMAND_POST_WRAP_COPY) {
-		goto CommandPostWrapCopy;
-	} else {
-		return BROTLI_FAILURE(BROTLI_DECODER_ERROR_UNREACHABLE); /* COV_NF_LINE */
-	}
-
-CommandBegin:
-	if (safe) {
-		s->state = BROTLI_STATE_COMMAND_BEGIN;
-	}
-	if (!CheckInputAmount(safe, br)) {
-		s->state = BROTLI_STATE_COMMAND_BEGIN;
-		result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-		goto saveStateAndReturn;
-	}
-	if (BROTLI_PREDICT_FALSE(s->block_length[1] == 0)) {
-		BROTLI_SAFE(DecodeCommandBlockSwitch(s));
-		goto CommandBegin;
-	}
-	/* Read the insert/copy length in the command. */
-	BROTLI_SAFE(ReadCommand(s, br, &i));
-	BROTLI_LOG(("[ProcessCommandsInternal] pos = %d insert = %d copy = %d\n", pos, i, s->copy_length));
-	if (i == 0) {
-		goto CommandPostDecodeLiterals;
-	}
-	s->meta_block_remaining_len -= i;
-
-CommandInner:
-	if (safe) {
-		s->state = BROTLI_STATE_COMMAND_INNER;
-	}
-	/* Read the literals in the command. */
-	if (s->trivial_literal_context) {
-		brotli_reg_t bits;
-		brotli_reg_t value;
-		PreloadSymbol(safe, s->literal_htree, br, &bits, &value);
-		do {
-			if (!CheckInputAmount(safe, br)) {
-				s->state = BROTLI_STATE_COMMAND_INNER;
-				result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-				goto saveStateAndReturn;
-			}
-			if (BROTLI_PREDICT_FALSE(s->block_length[0] == 0)) {
-				goto NextLiteralBlock;
-			}
-			if (!safe) {
-				s->ringbuffer[pos] = (uint8_t)ReadPreloadedSymbol(s->literal_htree, br, &bits, &value);
-			} else {
-				brotli_reg_t literal;
-				if (!SafeReadSymbol(s->literal_htree, br, &literal)) {
-					result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-					goto saveStateAndReturn;
-				}
-				s->ringbuffer[pos] = (uint8_t)literal;
-			}
-			--s->block_length[0];
-			BROTLI_LOG_ARRAY_INDEX(s->ringbuffer, pos);
-			++pos;
-			if (BROTLI_PREDICT_FALSE(pos == s->ringbuffer_size)) {
-				s->state = BROTLI_STATE_COMMAND_INNER_WRITE;
-				--i;
-				goto saveStateAndReturn;
-			}
-		} while (--i != 0);
-	} else {
-		uint8_t p1 = s->ringbuffer[(pos - 1) & s->ringbuffer_mask];
-		uint8_t p2 = s->ringbuffer[(pos - 2) & s->ringbuffer_mask];
-		do {
-			const HuffmanCode *hc;
-			uint8_t context;
-			if (!CheckInputAmount(safe, br)) {
-				s->state = BROTLI_STATE_COMMAND_INNER;
-				result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-				goto saveStateAndReturn;
-			}
-			if (BROTLI_PREDICT_FALSE(s->block_length[0] == 0)) {
-				goto NextLiteralBlock;
-			}
-			context = BROTLI_CONTEXT(p1, p2, s->context_lookup);
-			BROTLI_LOG_UINT(context);
-			hc = s->literal_hgroup.htrees[s->context_map_slice[context]];
-			p2 = p1;
-			if (!safe) {
-				p1 = (uint8_t)ReadSymbol(hc, br);
-			} else {
-				brotli_reg_t literal;
-				if (!SafeReadSymbol(hc, br, &literal)) {
-					result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-					goto saveStateAndReturn;
-				}
-				p1 = (uint8_t)literal;
-			}
-			s->ringbuffer[pos] = p1;
-			--s->block_length[0];
-			BROTLI_LOG_UINT(s->context_map_slice[context]);
-			BROTLI_LOG_ARRAY_INDEX(s->ringbuffer, pos & s->ringbuffer_mask);
-			++pos;
-			if (BROTLI_PREDICT_FALSE(pos == s->ringbuffer_size)) {
-				s->state = BROTLI_STATE_COMMAND_INNER_WRITE;
-				--i;
-				goto saveStateAndReturn;
-			}
-		} while (--i != 0);
-	}
-	BROTLI_LOG_UINT(s->meta_block_remaining_len);
-	if (BROTLI_PREDICT_FALSE(s->meta_block_remaining_len <= 0)) {
-		s->state = BROTLI_STATE_METABLOCK_DONE;
-		goto saveStateAndReturn;
-	}
-
-CommandPostDecodeLiterals:
-	if (safe) {
-		s->state = BROTLI_STATE_COMMAND_POST_DECODE_LITERALS;
-	}
-	if (s->distance_code >= 0) {
-		/* Implicit distance case. */
-		s->distance_context = s->distance_code ? 0 : 1;
-		--s->dist_rb_idx;
-		s->distance_code = s->dist_rb[s->dist_rb_idx & 3];
-	} else {
-		/* Read distance code in the command, unless it was implicitly zero. */
-		if (BROTLI_PREDICT_FALSE(s->block_length[2] == 0)) {
-			BROTLI_SAFE(DecodeDistanceBlockSwitch(s));
-		}
-		BROTLI_SAFE(ReadDistance(s, br));
-	}
-	BROTLI_LOG(("[ProcessCommandsInternal] pos = %d distance = %d\n", pos, s->distance_code));
-	if (s->max_distance != s->max_backward_distance) {
-		s->max_distance = (pos < s->max_backward_distance) ? pos : s->max_backward_distance;
-	}
-	i = s->copy_length;
-	/* Apply copy of LZ77 back-reference, or static dictionary reference if
-	   the distance is larger than the max LZ77 distance */
-	if (s->distance_code > s->max_distance) {
-		/* The maximum allowed distance is BROTLI_MAX_ALLOWED_DISTANCE = 0x7FFFFFFC.
-		   With this choice, no signed overflow can occur after decoding
-		   a special distance code (e.g., after adding 3 to the last distance). */
-		if (s->distance_code > BROTLI_MAX_ALLOWED_DISTANCE) {
-			BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-			            "len: %d bytes left: %d\n",
-			            pos, s->distance_code, i, s->meta_block_remaining_len));
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_DISTANCE);
-		}
-		if (s->distance_code - s->max_distance - 1 < compound_dictionary_size) {
-			int address = compound_dictionary_size - (s->distance_code - s->max_distance);
-			if (!InitializeCompoundDictionaryCopy(s, address, i)) {
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_COMPOUND_DICTIONARY);
-			}
-			pos += CopyFromCompoundDictionary(s, pos);
-			if (pos >= s->ringbuffer_size) {
-				s->state = BROTLI_STATE_COMMAND_POST_WRITE_1;
-				goto saveStateAndReturn;
-			}
-		} else if (i >= SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH && i <= SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH) {
-			uint8_t p1 = s->ringbuffer[(pos - 1) & s->ringbuffer_mask];
-			uint8_t p2 = s->ringbuffer[(pos - 2) & s->ringbuffer_mask];
-			uint8_t dict_id = s->dictionary->context_based
-			                      ? s->dictionary->context_map[BROTLI_CONTEXT(p1, p2, s->context_lookup)]
-			                      : 0;
-			const BrotliDictionary *words = s->dictionary->words[dict_id];
-			const BrotliTransforms *transforms = s->dictionary->transforms[dict_id];
-			int offset = (int)words->offsets_by_length[i];
-			brotli_reg_t shift = words->size_bits_by_length[i];
-			int address = s->distance_code - s->max_distance - 1 - compound_dictionary_size;
-			int mask = (int)BitMask(shift);
-			int word_idx = address & mask;
-			int transform_idx = address >> shift;
-			/* Compensate double distance-ring-buffer roll. */
-			s->dist_rb_idx += s->distance_context;
-			offset += word_idx * i;
-			/* If the distance is out of bound, select a next static dictionary if
-			   there exist multiple. */
-			if ((transform_idx >= (int)transforms->num_transforms || words->size_bits_by_length[i] == 0) &&
-			    s->dictionary->num_dictionaries > 1) {
-				uint8_t dict_id2;
-				int dist_remaining = address - (int)(((1u << shift) & ~1u)) * (int)transforms->num_transforms;
-				for (dict_id2 = 0; dict_id2 < s->dictionary->num_dictionaries; dict_id2++) {
-					const BrotliDictionary *words2 = s->dictionary->words[dict_id2];
-					if (dict_id2 != dict_id && words2->size_bits_by_length[i] != 0) {
-						const BrotliTransforms *transforms2 = s->dictionary->transforms[dict_id2];
-						brotli_reg_t shift2 = words2->size_bits_by_length[i];
-						int num = (int)((1u << shift2) & ~1u) * (int)transforms2->num_transforms;
-						if (dist_remaining < num) {
-							dict_id = dict_id2;
-							words = words2;
-							transforms = transforms2;
-							address = dist_remaining;
-							shift = shift2;
-							mask = (int)BitMask(shift);
-							word_idx = address & mask;
-							transform_idx = address >> shift;
-							offset = (int)words->offsets_by_length[i] + word_idx * i;
-							break;
-						}
-						dist_remaining -= num;
-					}
-				}
-			}
-			if (BROTLI_PREDICT_FALSE(words->size_bits_by_length[i] == 0)) {
-				BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-				            "len: %d bytes left: %d\n",
-				            pos, s->distance_code, i, s->meta_block_remaining_len));
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_DICTIONARY);
-			}
-			if (BROTLI_PREDICT_FALSE(!words->data)) {
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET);
-			}
-			if (transform_idx < (int)transforms->num_transforms) {
-				const uint8_t *word = &words->data[offset];
-				int len = i;
-				if (transform_idx == transforms->cutOffTransforms[0]) {
-					memcpy(&s->ringbuffer[pos], word, (size_t)len);
-					BROTLI_LOG(("[ProcessCommandsInternal] dictionary word: [%.*s]\n", len, word));
-				} else {
-					len = BrotliTransformDictionaryWord(&s->ringbuffer[pos], word, len, transforms, transform_idx);
-					BROTLI_LOG(("[ProcessCommandsInternal] dictionary word: [%.*s],"
-					            " transform_idx = %d, transformed: [%.*s]\n",
-					            i, word, transform_idx, len, &s->ringbuffer[pos]));
-					if (len == 0 && s->distance_code <= 120) {
-						BROTLI_LOG(("Invalid length-0 dictionary word after transform\n"));
-						return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_TRANSFORM);
-					}
-				}
-				pos += len;
-				s->meta_block_remaining_len -= len;
-				if (pos >= s->ringbuffer_size) {
-					s->state = BROTLI_STATE_COMMAND_POST_WRITE_1;
-					goto saveStateAndReturn;
-				}
-			} else {
-				BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-				            "len: %d bytes left: %d\n",
-				            pos, s->distance_code, i, s->meta_block_remaining_len));
-				return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_TRANSFORM);
-			}
-		} else {
-			BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-			            "len: %d bytes left: %d\n",
-			            pos, s->distance_code, i, s->meta_block_remaining_len));
-			return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_DICTIONARY);
-		}
-	} else {
-		int src_start = (pos - s->distance_code) & s->ringbuffer_mask;
-		uint8_t *copy_dst = &s->ringbuffer[pos];
-		uint8_t *copy_src = &s->ringbuffer[src_start];
-		int dst_end = pos + i;
-		int src_end = src_start + i;
-		/* Update the recent distances cache. */
-		s->dist_rb[s->dist_rb_idx & 3] = s->distance_code;
-		++s->dist_rb_idx;
-		s->meta_block_remaining_len -= i;
-		/* There are 32+ bytes of slack in the ring-buffer allocation.
-		   Also, we have 16 short codes, that make these 16 bytes irrelevant
-		   in the ring-buffer. Let's copy over them as a first guess. */
-		memmove16(copy_dst, copy_src);
-		if (src_end > pos && dst_end > src_start) {
-			/* Regions intersect. */
-			goto CommandPostWrapCopy;
-		}
-		if (dst_end >= s->ringbuffer_size || src_end >= s->ringbuffer_size) {
-			/* At least one region wraps. */
-			goto CommandPostWrapCopy;
-		}
-		pos += i;
-		if (i > 16) {
-			if (i > 32) {
-				memcpy(copy_dst + 16, copy_src + 16, (size_t)(i - 16));
-			} else {
-				/* This branch covers about 45% cases.
-				   Fixed size short copy allows more compiler optimizations. */
-				memmove16(copy_dst + 16, copy_src + 16);
-			}
-		}
-	}
-	BROTLI_LOG_UINT(s->meta_block_remaining_len);
-	if (s->meta_block_remaining_len <= 0) {
-		/* Next metablock, if any. */
-		s->state = BROTLI_STATE_METABLOCK_DONE;
-		goto saveStateAndReturn;
-	} else {
-		goto CommandBegin;
-	}
-CommandPostWrapCopy: {
-	int wrap_guard = s->ringbuffer_size - pos;
-	while (--i >= 0) {
-		s->ringbuffer[pos] = s->ringbuffer[(pos - s->distance_code) & s->ringbuffer_mask];
-		++pos;
-		if (BROTLI_PREDICT_FALSE(--wrap_guard == 0)) {
-			s->state = BROTLI_STATE_COMMAND_POST_WRITE_2;
-			goto saveStateAndReturn;
-		}
-	}
-}
-	if (s->meta_block_remaining_len <= 0) {
-		/* Next metablock, if any. */
-		s->state = BROTLI_STATE_METABLOCK_DONE;
-		goto saveStateAndReturn;
-	} else {
-		goto CommandBegin;
-	}
-
-NextLiteralBlock:
-	BROTLI_SAFE(DecodeLiteralBlockSwitch(s));
-	goto CommandInner;
-
-saveStateAndReturn:
-	s->pos = pos;
-	s->loop_counter = i;
-	return result;
-}
-
-#undef BROTLI_SAFE
-
-static BROTLI_NOINLINE BrotliDecoderErrorCode ProcessCommands(BrotliDecoderState *s) {
-	return ProcessCommandsInternal(0, s);
-}
-
-static BROTLI_NOINLINE BrotliDecoderErrorCode SafeProcessCommands(BrotliDecoderState *s) {
-	return ProcessCommandsInternal(1, s);
-}
-
-BrotliDecoderResult BrotliDecoderDecompress(size_t encoded_size,
-                                            const uint8_t encoded_buffer[BROTLI_ARRAY_PARAM(encoded_size)],
-                                            size_t *decoded_size,
-                                            uint8_t decoded_buffer[BROTLI_ARRAY_PARAM(*decoded_size)]) {
-	BrotliDecoderState s;
-	BrotliDecoderResult result;
-	size_t total_out = 0;
-	size_t available_in = encoded_size;
-	const uint8_t *next_in = encoded_buffer;
-	size_t available_out = *decoded_size;
-	uint8_t *next_out = decoded_buffer;
-	if (!BrotliDecoderStateInit(&s, 0, 0, 0)) {
-		return BROTLI_DECODER_RESULT_ERROR;
-	}
-	result = BrotliDecoderDecompressStream(&s, &available_in, &next_in, &available_out, &next_out, &total_out);
-	*decoded_size = total_out;
-	BrotliDecoderStateCleanup(&s);
-	if (result != BROTLI_DECODER_RESULT_SUCCESS) {
-		result = BROTLI_DECODER_RESULT_ERROR;
-	}
-	return result;
-}
-
-/* Invariant: input stream is never overconsumed:
-    - invalid input implies that the whole stream is invalid -> any amount of
-      input could be read and discarded
-    - when result is "needs more input", then at least one more byte is REQUIRED
-      to complete decoding; all input data MUST be consumed by decoder, so
-      client could swap the input buffer
-    - when result is "needs more output" decoder MUST ensure that it doesn't
-      hold more than 7 bits in bit reader; this saves client from swapping input
-      buffer ahead of time
-    - when result is "success" decoder MUST return all unused data back to input
-      buffer; this is possible because the invariant is held on enter */
-BrotliDecoderResult BrotliDecoderDecompressStream(BrotliDecoderState *s, size_t *available_in, const uint8_t **next_in,
-                                                  size_t *available_out, uint8_t **next_out, size_t *total_out) {
-	BrotliDecoderErrorCode result = BROTLI_DECODER_SUCCESS;
-	BrotliBitReader *br = &s->br;
-	size_t input_size = *available_in;
-#define BROTLI_SAVE_ERROR_CODE(code) SaveErrorCode(s, (code), input_size - *available_in)
-	/* Ensure that |total_out| is set, even if no data will ever be pushed out. */
-	if (total_out) {
-		*total_out = s->partial_pos_out;
-	}
-	/* Do not try to process further in a case of unrecoverable error. */
-	if ((int)s->error_code < 0) {
-		return BROTLI_DECODER_RESULT_ERROR;
-	}
-	if (*available_out && (!next_out || !*next_out)) {
-		return BROTLI_SAVE_ERROR_CODE(BROTLI_FAILURE(BROTLI_DECODER_ERROR_INVALID_ARGUMENTS));
-	}
-	if (!*available_out)
-		next_out = 0;
-	if (s->buffer_length == 0) { /* Just connect bit reader to input stream. */
-		BrotliBitReaderSetInput(br, *next_in, *available_in);
-	} else {
-		/* At least one byte of input is required. More than one byte of input may
-		   be required to complete the transaction -> reading more data must be
-		   done in a loop -> do it in a main loop. */
-		result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-		BrotliBitReaderSetInput(br, &s->buffer.u8[0], s->buffer_length);
-	}
-	/* State machine */
-	for (;;) {
-		if (result != BROTLI_DECODER_SUCCESS) {
-			/* Error, needs more input/output. */
-			if (result == BROTLI_DECODER_NEEDS_MORE_INPUT) {
-				if (s->ringbuffer != 0) { /* Pro-actively push output. */
-					BrotliDecoderErrorCode intermediate_result =
-					    WriteRingBuffer(s, available_out, next_out, total_out, BROTLI_TRUE);
-					/* WriteRingBuffer checks s->meta_block_remaining_len validity. */
-					if ((int)intermediate_result < 0) {
-						result = intermediate_result;
-						break;
-					}
-				}
-				if (s->buffer_length != 0) { /* Used with internal buffer. */
-					if (br->next_in == br->last_in) {
-						/* Successfully finished read transaction.
-						   Accumulator contains less than 8 bits, because internal buffer
-						   is expanded byte-by-byte until it is enough to complete read. */
-						s->buffer_length = 0;
-						/* Switch to input stream and restart. */
-						result = BROTLI_DECODER_SUCCESS;
-						BrotliBitReaderSetInput(br, *next_in, *available_in);
-						continue;
-					} else if (*available_in != 0) {
-						/* Not enough data in buffer, but can take one more byte from
-						   input stream. */
-						result = BROTLI_DECODER_SUCCESS;
-						BROTLI_DCHECK(s->buffer_length < 8);
-						s->buffer.u8[s->buffer_length] = **next_in;
-						s->buffer_length++;
-						BrotliBitReaderSetInput(br, &s->buffer.u8[0], s->buffer_length);
-						(*next_in)++;
-						(*available_in)--;
-						/* Retry with more data in buffer. */
-						continue;
-					}
-					/* Can't finish reading and no more input. */
-					break;
-				} else { /* Input stream doesn't contain enough input. */
-					/* Copy tail to internal buffer and return. */
-					*next_in = br->next_in;
-					*available_in = BrotliBitReaderGetAvailIn(br);
-					while (*available_in) {
-						s->buffer.u8[s->buffer_length] = **next_in;
-						s->buffer_length++;
-						(*next_in)++;
-						(*available_in)--;
-					}
-					break;
-				}
-				/* Unreachable. */
-			}
-
-			/* Fail or needs more output. */
-
-			if (s->buffer_length != 0) {
-				/* Just consumed the buffered input and produced some output. Otherwise
-				   it would result in "needs more input". Reset internal buffer. */
-				s->buffer_length = 0;
-			} else {
-				/* Using input stream in last iteration. When decoder switches to input
-				   stream it has less than 8 bits in accumulator, so it is safe to
-				   return unused accumulator bits there. */
-				BrotliBitReaderUnload(br);
-				*available_in = BrotliBitReaderGetAvailIn(br);
-				*next_in = br->next_in;
-			}
-			break;
-		}
-		switch (s->state) {
-		case BROTLI_STATE_UNINITED:
-			/* Prepare to the first read. */
-			if (!BrotliWarmupBitReader(br)) {
-				result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-				break;
-			}
-			/* Decode window size. */
-			result = DecodeWindowBits(s, br); /* Reads 1..8 bits. */
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			if (s->large_window) {
-				s->state = BROTLI_STATE_LARGE_WINDOW_BITS;
-				break;
-			}
-			s->state = BROTLI_STATE_INITIALIZE;
-			break;
-
-		case BROTLI_STATE_LARGE_WINDOW_BITS: {
-			brotli_reg_t bits;
-			if (!BrotliSafeReadBits(br, 6, &bits)) {
-				result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-				break;
-			}
-			s->window_bits = bits & 63u;
-			if (s->window_bits < BROTLI_LARGE_MIN_WBITS || s->window_bits > BROTLI_LARGE_MAX_WBITS) {
-				result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS);
-				break;
-			}
-			s->state = BROTLI_STATE_INITIALIZE;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_INITIALIZE:
-			BROTLI_LOG_UINT(s->window_bits);
-			/* Maximum distance, see section 9.1. of the spec. */
-			s->max_backward_distance = (1 << s->window_bits) - BROTLI_WINDOW_GAP;
-
-			/* Allocate memory for both block_type_trees and block_len_trees. */
-			s->block_type_trees = (HuffmanCode *)BROTLI_DECODER_ALLOC(
-			    s, sizeof(HuffmanCode) * 3 * (BROTLI_HUFFMAN_MAX_SIZE_258 + BROTLI_HUFFMAN_MAX_SIZE_26));
-			if (s->block_type_trees == 0) {
-				result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES);
-				break;
-			}
-			s->block_len_trees = s->block_type_trees + 3 * BROTLI_HUFFMAN_MAX_SIZE_258;
-
-			s->state = BROTLI_STATE_METABLOCK_BEGIN;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_BEGIN:
-			BrotliDecoderStateMetablockBegin(s);
-			BROTLI_LOG_UINT(s->pos);
-			s->state = BROTLI_STATE_METABLOCK_HEADER;
-			/* Fall through. */
-
-		case BROTLI_STATE_METABLOCK_HEADER:
-			result = DecodeMetaBlockLength(s, br); /* Reads 2 - 31 bits. */
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			BROTLI_LOG_UINT(s->is_last_metablock);
-			BROTLI_LOG_UINT(s->meta_block_remaining_len);
-			BROTLI_LOG_UINT(s->is_metadata);
-			BROTLI_LOG_UINT(s->is_uncompressed);
-			if (s->is_metadata || s->is_uncompressed) {
-				if (!BrotliJumpToByteBoundary(br)) {
-					result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_PADDING_1);
-					break;
-				}
-			}
-			if (s->is_metadata) {
-				s->state = BROTLI_STATE_METADATA;
-				if (s->metadata_start_func) {
-					s->metadata_start_func(s->metadata_callback_opaque, (size_t)s->meta_block_remaining_len);
-				}
-				break;
-			}
-			if (s->meta_block_remaining_len == 0) {
-				s->state = BROTLI_STATE_METABLOCK_DONE;
-				break;
-			}
-			BrotliCalculateRingBufferSize(s);
-			if (s->is_uncompressed) {
-				s->state = BROTLI_STATE_UNCOMPRESSED;
-				break;
-			}
-			s->state = BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_HEADER;
-			/* Fall through. */
-
-		case BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_HEADER: {
-			BrotliMetablockHeaderArena *h = &s->arena.header;
-			s->loop_counter = 0;
-			/* Initialize compressed metablock header arena. */
-			h->sub_loop_counter = 0;
-			/* Make small negative indexes addressable. */
-			h->symbol_lists = &h->symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1];
-			h->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
-			h->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE;
-			h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE;
-			s->state = BROTLI_STATE_HUFFMAN_CODE_0;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_CODE_0:
-			if (s->loop_counter >= 3) {
-				s->state = BROTLI_STATE_METABLOCK_HEADER_2;
-				break;
-			}
-			/* Reads 1..11 bits. */
-			result = DecodeVarLenUint8(s, br, &s->num_block_types[s->loop_counter]);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			s->num_block_types[s->loop_counter]++;
-			BROTLI_LOG_UINT(s->num_block_types[s->loop_counter]);
-			if (s->num_block_types[s->loop_counter] < 2) {
-				s->loop_counter++;
-				break;
-			}
-			s->state = BROTLI_STATE_HUFFMAN_CODE_1;
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_CODE_1: {
-			brotli_reg_t alphabet_size = s->num_block_types[s->loop_counter] + 2;
-			int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_SIZE_258;
-			result = ReadHuffmanCode(alphabet_size, alphabet_size, &s->block_type_trees[tree_offset], NULL, s);
-			if (result != BROTLI_DECODER_SUCCESS)
-				break;
-			s->state = BROTLI_STATE_HUFFMAN_CODE_2;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_CODE_2: {
-			brotli_reg_t alphabet_size = BROTLI_NUM_BLOCK_LEN_SYMBOLS;
-			int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_SIZE_26;
-			result = ReadHuffmanCode(alphabet_size, alphabet_size, &s->block_len_trees[tree_offset], NULL, s);
-			if (result != BROTLI_DECODER_SUCCESS)
-				break;
-			s->state = BROTLI_STATE_HUFFMAN_CODE_3;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_HUFFMAN_CODE_3: {
-			int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_SIZE_26;
-			if (!SafeReadBlockLength(s, &s->block_length[s->loop_counter], &s->block_len_trees[tree_offset], br)) {
-				result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-				break;
-			}
-			BROTLI_LOG_UINT(s->block_length[s->loop_counter]);
-			s->loop_counter++;
-			s->state = BROTLI_STATE_HUFFMAN_CODE_0;
-			break;
-		}
-
-		case BROTLI_STATE_UNCOMPRESSED: {
-			result = CopyUncompressedBlockToOutput(available_out, next_out, total_out, s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			s->state = BROTLI_STATE_METABLOCK_DONE;
-			break;
-		}
-
-		case BROTLI_STATE_METADATA:
-			result = SkipMetadataBlock(s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			s->state = BROTLI_STATE_METABLOCK_DONE;
-			break;
-
-		case BROTLI_STATE_METABLOCK_HEADER_2: {
-			brotli_reg_t bits;
-			if (!BrotliSafeReadBits(br, 6, &bits)) {
-				result = BROTLI_DECODER_NEEDS_MORE_INPUT;
-				break;
-			}
-			s->distance_postfix_bits = bits & BitMask(2);
-			bits >>= 2;
-			s->num_direct_distance_codes = bits << s->distance_postfix_bits;
-			BROTLI_LOG_UINT(s->num_direct_distance_codes);
-			BROTLI_LOG_UINT(s->distance_postfix_bits);
-			s->context_modes = (uint8_t *)BROTLI_DECODER_ALLOC(s, (size_t)s->num_block_types[0]);
-			if (s->context_modes == 0) {
-				result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES);
-				break;
-			}
-			s->loop_counter = 0;
-			s->state = BROTLI_STATE_CONTEXT_MODES;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_CONTEXT_MODES:
-			result = ReadContextModes(s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			s->state = BROTLI_STATE_CONTEXT_MAP_1;
-			/* Fall through. */
-
-		case BROTLI_STATE_CONTEXT_MAP_1:
-			result = DecodeContextMap(s->num_block_types[0] << BROTLI_LITERAL_CONTEXT_BITS, &s->num_literal_htrees,
-			                          &s->context_map, s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			DetectTrivialLiteralBlockTypes(s);
-			s->state = BROTLI_STATE_CONTEXT_MAP_2;
-			/* Fall through. */
-
-		case BROTLI_STATE_CONTEXT_MAP_2: {
-			brotli_reg_t npostfix = s->distance_postfix_bits;
-			brotli_reg_t ndirect = s->num_direct_distance_codes;
-			brotli_reg_t distance_alphabet_size_max =
-			    BROTLI_DISTANCE_ALPHABET_SIZE(npostfix, ndirect, BROTLI_MAX_DISTANCE_BITS);
-			brotli_reg_t distance_alphabet_size_limit = distance_alphabet_size_max;
-			BROTLI_BOOL allocation_success = BROTLI_TRUE;
-			if (s->large_window) {
-				BrotliDistanceCodeLimit limit = BrotliCalculateDistanceCodeLimit(BROTLI_MAX_ALLOWED_DISTANCE,
-				                                                                 (uint32_t)npostfix, (uint32_t)ndirect);
-				distance_alphabet_size_max =
-				    BROTLI_DISTANCE_ALPHABET_SIZE(npostfix, ndirect, BROTLI_LARGE_MAX_DISTANCE_BITS);
-				distance_alphabet_size_limit = limit.max_alphabet_size;
-			}
-			result = DecodeContextMap(s->num_block_types[2] << BROTLI_DISTANCE_CONTEXT_BITS, &s->num_dist_htrees,
-			                          &s->dist_context_map, s);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			allocation_success &= BrotliDecoderHuffmanTreeGroupInit(s, &s->literal_hgroup, BROTLI_NUM_LITERAL_SYMBOLS,
-			                                                        BROTLI_NUM_LITERAL_SYMBOLS, s->num_literal_htrees);
-			allocation_success &=
-			    BrotliDecoderHuffmanTreeGroupInit(s, &s->insert_copy_hgroup, BROTLI_NUM_COMMAND_SYMBOLS,
-			                                      BROTLI_NUM_COMMAND_SYMBOLS, s->num_block_types[1]);
-			allocation_success &= BrotliDecoderHuffmanTreeGroupInit(s, &s->distance_hgroup, distance_alphabet_size_max,
-			                                                        distance_alphabet_size_limit, s->num_dist_htrees);
-			if (!allocation_success) {
-				return BROTLI_SAVE_ERROR_CODE(BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS));
-			}
-			s->loop_counter = 0;
-			s->state = BROTLI_STATE_TREE_GROUP;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_TREE_GROUP: {
-			HuffmanTreeGroup *hgroup = NULL;
-			switch (s->loop_counter) {
-			case 0:
-				hgroup = &s->literal_hgroup;
-				break;
-			case 1:
-				hgroup = &s->insert_copy_hgroup;
-				break;
-			case 2:
-				hgroup = &s->distance_hgroup;
-				break;
-			default:
-				return BROTLI_SAVE_ERROR_CODE(BROTLI_FAILURE(BROTLI_DECODER_ERROR_UNREACHABLE)); /* COV_NF_LINE */
-			}
-			result = HuffmanTreeGroupDecode(hgroup, s);
-			if (result != BROTLI_DECODER_SUCCESS)
-				break;
-			s->loop_counter++;
-			if (s->loop_counter < 3) {
-				break;
-			}
-			s->state = BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_BODY;
-		}
-			/* Fall through. */
-
-		case BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_BODY:
-			PrepareLiteralDecoding(s);
-			s->dist_context_map_slice = s->dist_context_map;
-			s->htree_command = s->insert_copy_hgroup.htrees[0];
-			if (!BrotliEnsureRingBuffer(s)) {
-				result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2);
-				break;
-			}
-			CalculateDistanceLut(s);
-			s->state = BROTLI_STATE_COMMAND_BEGIN;
-			/* Fall through. */
-
-		case BROTLI_STATE_COMMAND_BEGIN:
-		/* Fall through. */
-		case BROTLI_STATE_COMMAND_INNER:
-		/* Fall through. */
-		case BROTLI_STATE_COMMAND_POST_DECODE_LITERALS:
-		/* Fall through. */
-		case BROTLI_STATE_COMMAND_POST_WRAP_COPY:
-			result = ProcessCommands(s);
-			if (result == BROTLI_DECODER_NEEDS_MORE_INPUT) {
-				result = SafeProcessCommands(s);
-			}
-			break;
-
-		case BROTLI_STATE_COMMAND_INNER_WRITE:
-		/* Fall through. */
-		case BROTLI_STATE_COMMAND_POST_WRITE_1:
-		/* Fall through. */
-		case BROTLI_STATE_COMMAND_POST_WRITE_2:
-			result = WriteRingBuffer(s, available_out, next_out, total_out, BROTLI_FALSE);
-			if (result != BROTLI_DECODER_SUCCESS) {
-				break;
-			}
-			WrapRingBuffer(s);
-			if (s->ringbuffer_size == 1 << s->window_bits) {
-				s->max_distance = s->max_backward_distance;
-			}
-			if (s->state == BROTLI_STATE_COMMAND_POST_WRITE_1) {
-				BrotliDecoderCompoundDictionary *addon = s->compound_dictionary;
-				if (addon && (addon->br_length != addon->br_copied)) {
-					s->pos += CopyFromCompoundDictionary(s, s->pos);
-					if (s->pos >= s->ringbuffer_size)
-						continue;
-				}
-				if (s->meta_block_remaining_len == 0) {
-					/* Next metablock, if any. */
-					s->state = BROTLI_STATE_METABLOCK_DONE;
-				} else {
-					s->state = BROTLI_STATE_COMMAND_BEGIN;
-				}
-				break;
-			} else if (s->state == BROTLI_STATE_COMMAND_POST_WRITE_2) {
-				s->state = BROTLI_STATE_COMMAND_POST_WRAP_COPY;
-			} else { /* BROTLI_STATE_COMMAND_INNER_WRITE */
-				if (s->loop_counter == 0) {
-					if (s->meta_block_remaining_len == 0) {
-						s->state = BROTLI_STATE_METABLOCK_DONE;
-					} else {
-						s->state = BROTLI_STATE_COMMAND_POST_DECODE_LITERALS;
-					}
-					break;
-				}
-				s->state = BROTLI_STATE_COMMAND_INNER;
-			}
-			break;
-
-		case BROTLI_STATE_METABLOCK_DONE:
-			if (s->meta_block_remaining_len < 0) {
-				result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2);
-				break;
-			}
-			BrotliDecoderStateCleanupAfterMetablock(s);
-			if (!s->is_last_metablock) {
-				s->state = BROTLI_STATE_METABLOCK_BEGIN;
-				break;
-			}
-			if (!BrotliJumpToByteBoundary(br)) {
-				result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_PADDING_2);
-				break;
-			}
-			if (s->buffer_length == 0) {
-				BrotliBitReaderUnload(br);
-				*available_in = BrotliBitReaderGetAvailIn(br);
-				*next_in = br->next_in;
-			}
-			s->state = BROTLI_STATE_DONE;
-			/* Fall through. */
-
-		case BROTLI_STATE_DONE:
-			if (s->ringbuffer != 0) {
-				result = WriteRingBuffer(s, available_out, next_out, total_out, BROTLI_TRUE);
-				if (result != BROTLI_DECODER_SUCCESS) {
-					break;
-				}
-			}
-			return BROTLI_SAVE_ERROR_CODE(result);
-		}
-	}
-	return BROTLI_SAVE_ERROR_CODE(result);
-#undef BROTLI_SAVE_ERROR_CODE
-}
-
-BROTLI_BOOL BrotliDecoderHasMoreOutput(const BrotliDecoderState *s) {
-	/* After unrecoverable error remaining output is considered nonsensical. */
-	if ((int)s->error_code < 0) {
-		return BROTLI_FALSE;
-	}
-	return TO_BROTLI_BOOL(s->ringbuffer != 0 && UnwrittenBytes(s, BROTLI_FALSE) != 0);
-}
-
-const uint8_t *BrotliDecoderTakeOutput(BrotliDecoderState *s, size_t *size) {
-	uint8_t *result = 0;
-	size_t available_out = *size ? *size : 1u << 24;
-	size_t requested_out = available_out;
-	BrotliDecoderErrorCode status;
-	if ((s->ringbuffer == 0) || ((int)s->error_code < 0)) {
-		*size = 0;
-		return 0;
-	}
-	WrapRingBuffer(s);
-	status = WriteRingBuffer(s, &available_out, &result, 0, BROTLI_TRUE);
-	/* Either WriteRingBuffer returns those "success" codes... */
-	if (status == BROTLI_DECODER_SUCCESS || status == BROTLI_DECODER_NEEDS_MORE_OUTPUT) {
-		*size = requested_out - available_out;
-	} else {
-		/* ... or stream is broken. Normally this should be caught by
-		   BrotliDecoderDecompressStream, this is just a safeguard. */
-		if ((int)status < 0)
-			SaveErrorCode(s, status, 0);
-		*size = 0;
-		result = 0;
-	}
-	return result;
-}
-
-BROTLI_BOOL BrotliDecoderIsUsed(const BrotliDecoderState *s) {
-	return TO_BROTLI_BOOL(s->state != BROTLI_STATE_UNINITED || BrotliGetAvailableBits(&s->br) != 0);
-}
-
-BROTLI_BOOL BrotliDecoderIsFinished(const BrotliDecoderState *s) {
-	return TO_BROTLI_BOOL(s->state == BROTLI_STATE_DONE) && !BrotliDecoderHasMoreOutput(s);
-}
-
-BrotliDecoderErrorCode BrotliDecoderGetErrorCode(const BrotliDecoderState *s) {
-	return (BrotliDecoderErrorCode)s->error_code;
-}
-
-const char *BrotliDecoderErrorString(BrotliDecoderErrorCode c) {
-	switch (c) {
-#define BROTLI_ERROR_CODE_CASE_(PREFIX, NAME, CODE) \
-    case BROTLI_DECODER##PREFIX##NAME: return #PREFIX #NAME;
-#define BROTLI_NOTHING_
-		BROTLI_DECODER_ERROR_CODES_LIST(BROTLI_ERROR_CODE_CASE_, BROTLI_NOTHING_)
-#undef BROTLI_ERROR_CODE_CASE_
-#undef BROTLI_NOTHING_
-	default:
-		return "INVALID";
-	}
-}
-
-uint32_t BrotliDecoderVersion(void) {
-	return BROTLI_VERSION;
-}
-
-void BrotliDecoderSetMetadataCallbacks(BrotliDecoderState *state, brotli_decoder_metadata_start_func start_func,
-                                       brotli_decoder_metadata_chunk_func chunk_func, void *opaque) {
-	state->metadata_start_func = start_func;
-	state->metadata_chunk_func = chunk_func;
-	state->metadata_callback_opaque = opaque;
-}
-
-/* Escalate internal functions visibility; for testing purposes only. */
-#if defined(BROTLI_TEST)
-BROTLI_BOOL SafeReadSymbolForTest(const HuffmanCode *, BrotliBitReader *, brotli_reg_t *);
-BROTLI_BOOL SafeReadSymbolForTest(const HuffmanCode *table, BrotliBitReader *br, brotli_reg_t *result) {
-	return SafeReadSymbol(table, br, result);
-}
-
-void InverseMoveToFrontTransformForTest(uint8_t *, brotli_reg_t, BrotliDecoderState *);
-void InverseMoveToFrontTransformForTest(uint8_t *v, brotli_reg_t l, BrotliDecoderState *s) {
-	InverseMoveToFrontTransform(v, l, s);
-}
-#endif
-
-}
diff --git a/src/duckdb/third_party/brotli/dec/huffman.cpp b/src/duckdb/third_party/brotli/dec/huffman.cpp
deleted file mode 100644
index 08494665e..000000000
--- a/src/duckdb/third_party/brotli/dec/huffman.cpp
+++ /dev/null
@@ -1,338 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Utilities for building Huffman decoding tables. */
-
-#include "huffman.h"
-
-#include <string.h>  /* memcpy, memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-
-using namespace duckdb_brotli;
-
-#define BROTLI_REVERSE_BITS_MAX 8
-
-#if defined(BROTLI_RBIT)
-#define BROTLI_REVERSE_BITS_BASE \
-  ((sizeof(brotli_reg_t) << 3) - BROTLI_REVERSE_BITS_MAX)
-#else
-#define BROTLI_REVERSE_BITS_BASE 0
-static uint8_t kReverseBits[1 << BROTLI_REVERSE_BITS_MAX] = {
-  0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
-  0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
-  0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
-  0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
-  0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
-  0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
-  0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
-  0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
-  0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
-  0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
-  0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
-  0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
-  0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
-  0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
-  0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
-  0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
-  0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
-  0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
-  0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
-  0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
-  0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
-  0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
-  0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
-  0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
-  0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
-  0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
-  0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
-  0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
-  0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
-  0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
-  0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
-  0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
-};
-#endif  /* BROTLI_RBIT */
-
-#define BROTLI_REVERSE_BITS_LOWEST \
-  ((brotli_reg_t)1 << (BROTLI_REVERSE_BITS_MAX - 1 + BROTLI_REVERSE_BITS_BASE))
-
-/* Returns reverse(num >> BROTLI_REVERSE_BITS_BASE, BROTLI_REVERSE_BITS_MAX),
-   where reverse(value, len) is the bit-wise reversal of the len least
-   significant bits of value. */
-static BROTLI_INLINE brotli_reg_t BrotliReverseBits(brotli_reg_t num) {
-#if defined(BROTLI_RBIT)
-  return BROTLI_RBIT(num);
-#else
-  return kReverseBits[num];
-#endif
-}
-
-/* Stores code in table[0], table[step], table[2*step], ..., table[end] */
-/* Assumes that end is an integer multiple of step */
-static BROTLI_INLINE void ReplicateValue(HuffmanCode* table,
-                                         int step, int end,
-                                         HuffmanCode code) {
-  do {
-    end -= step;
-    table[end] = code;
-  } while (end > 0);
-}
-
-/* Returns the table width of the next 2nd level table. |count| is the histogram
-   of bit lengths for the remaining symbols, |len| is the code length of the
-   next processed symbol. */
-static BROTLI_INLINE int NextTableBitSize(const uint16_t* const count,
-                                          int len, int root_bits) {
-  int left = 1 << (len - root_bits);
-  while (len < BROTLI_HUFFMAN_MAX_CODE_LENGTH) {
-    left -= count[len];
-    if (left <= 0) break;
-    ++len;
-    left <<= 1;
-  }
-  return len - root_bits;
-}
-
-void duckdb_brotli::BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
-                                        const uint8_t* const code_lengths,
-                                        uint16_t* count) {
-  HuffmanCode code;       /* current table entry */
-  int symbol;             /* symbol index in original or sorted table */
-  brotli_reg_t key;       /* prefix code */
-  brotli_reg_t key_step;  /* prefix code addend */
-  int step;               /* step size to replicate values in current table */
-  int table_size;         /* size of current table */
-  int sorted[BROTLI_CODE_LENGTH_CODES];  /* symbols sorted by code length */
-  /* offsets in sorted table for each length */
-  int offset[BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1];
-  int bits;
-  int bits_count;
-  BROTLI_DCHECK(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH <=
-                BROTLI_REVERSE_BITS_MAX);
-  BROTLI_DCHECK(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH == 5);
-
-  /* Generate offsets into sorted symbol table by code length. */
-  symbol = -1;
-  bits = 1;
-  /* BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH == 5 */
-  BROTLI_REPEAT_5({
-    symbol += count[bits];
-    offset[bits] = symbol;
-    bits++;
-  });
-  /* Symbols with code length 0 are placed after all other symbols. */
-  offset[0] = BROTLI_CODE_LENGTH_CODES - 1;
-
-  /* Sort symbols by length, by symbol order within each length. */
-  symbol = BROTLI_CODE_LENGTH_CODES;
-  do {
-    BROTLI_REPEAT_6({
-      symbol--;
-      sorted[offset[code_lengths[symbol]]--] = symbol;
-    });
-  } while (symbol != 0);
-
-  table_size = 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH;
-
-  /* Special case: all symbols but one have 0 code length. */
-  if (offset[0] == 0) {
-    code = ConstructHuffmanCode(0, (uint16_t)sorted[0]);
-    for (key = 0; key < (brotli_reg_t)table_size; ++key) {
-      table[key] = code;
-    }
-    return;
-  }
-
-  /* Fill in table. */
-  key = 0;
-  key_step = BROTLI_REVERSE_BITS_LOWEST;
-  symbol = 0;
-  bits = 1;
-  step = 2;
-  do {
-    for (bits_count = count[bits]; bits_count != 0; --bits_count) {
-      code = ConstructHuffmanCode((uint8_t)bits, (uint16_t)sorted[symbol++]);
-      ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
-      key += key_step;
-    }
-    step <<= 1;
-    key_step >>= 1;
-  } while (++bits <= BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH);
-}
-
-uint32_t duckdb_brotli::BrotliBuildHuffmanTable(HuffmanCode* root_table,
-                                 int root_bits,
-                                 const uint16_t* const symbol_lists,
-                                 uint16_t* count) {
-  HuffmanCode code;       /* current table entry */
-  HuffmanCode* table;     /* next available space in table */
-  int len;                /* current code length */
-  int symbol;             /* symbol index in original or sorted table */
-  brotli_reg_t key;       /* prefix code */
-  brotli_reg_t key_step;  /* prefix code addend */
-  brotli_reg_t sub_key;   /* 2nd level table prefix code */
-  brotli_reg_t sub_key_step;  /* 2nd level table prefix code addend */
-  int step;               /* step size to replicate values in current table */
-  int table_bits;         /* key length of current table */
-  int table_size;         /* size of current table */
-  int total_size;         /* sum of root table size and 2nd level table sizes */
-  int max_length = -1;
-  int bits;
-  int bits_count;
-
-  BROTLI_DCHECK(root_bits <= BROTLI_REVERSE_BITS_MAX);
-  BROTLI_DCHECK(BROTLI_HUFFMAN_MAX_CODE_LENGTH - root_bits <=
-                BROTLI_REVERSE_BITS_MAX);
-
-  while (symbol_lists[max_length] == 0xFFFF) max_length--;
-  max_length += BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1;
-
-  table = root_table;
-  table_bits = root_bits;
-  table_size = 1 << table_bits;
-  total_size = table_size;
-
-  /* Fill in the root table. Reduce the table size to if possible,
-     and create the repetitions by memcpy. */
-  if (table_bits > max_length) {
-    table_bits = max_length;
-    table_size = 1 << table_bits;
-  }
-  key = 0;
-  key_step = BROTLI_REVERSE_BITS_LOWEST;
-  bits = 1;
-  step = 2;
-  do {
-    symbol = bits - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
-    for (bits_count = count[bits]; bits_count != 0; --bits_count) {
-      symbol = symbol_lists[symbol];
-      code = ConstructHuffmanCode((uint8_t)bits, (uint16_t)symbol);
-      ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
-      key += key_step;
-    }
-    step <<= 1;
-    key_step >>= 1;
-  } while (++bits <= table_bits);
-
-  /* If root_bits != table_bits then replicate to fill the remaining slots. */
-  while (total_size != table_size) {
-    memcpy(&table[table_size], &table[0],
-           (size_t)table_size * sizeof(table[0]));
-    table_size <<= 1;
-  }
-
-  /* Fill in 2nd level tables and add pointers to root table. */
-  key_step = BROTLI_REVERSE_BITS_LOWEST >> (root_bits - 1);
-  sub_key = (BROTLI_REVERSE_BITS_LOWEST << 1);
-  sub_key_step = BROTLI_REVERSE_BITS_LOWEST;
-  for (len = root_bits + 1, step = 2; len <= max_length; ++len) {
-    symbol = len - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
-    for (; count[len] != 0; --count[len]) {
-      if (sub_key == (BROTLI_REVERSE_BITS_LOWEST << 1U)) {
-        table += table_size;
-        table_bits = NextTableBitSize(count, len, root_bits);
-        table_size = 1 << table_bits;
-        total_size += table_size;
-        sub_key = BrotliReverseBits(key);
-        key += key_step;
-        root_table[sub_key] = ConstructHuffmanCode(
-            (uint8_t)(table_bits + root_bits),
-            (uint16_t)(((size_t)(table - root_table)) - sub_key));
-        sub_key = 0;
-      }
-      symbol = symbol_lists[symbol];
-      code = ConstructHuffmanCode((uint8_t)(len - root_bits), (uint16_t)symbol);
-      ReplicateValue(
-          &table[BrotliReverseBits(sub_key)], step, table_size, code);
-      sub_key += sub_key_step;
-    }
-    step <<= 1;
-    sub_key_step >>= 1;
-  }
-  return (uint32_t)total_size;
-}
-
-uint32_t duckdb_brotli::BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
-                                       int root_bits,
-                                       uint16_t* val,
-                                       uint32_t num_symbols) {
-  uint32_t table_size = 1;
-  const uint32_t goal_size = 1U << root_bits;
-  switch (num_symbols) {
-    case 0:
-      table[0] = ConstructHuffmanCode(0, val[0]);
-      break;
-    case 1:
-      if (val[1] > val[0]) {
-        table[0] = ConstructHuffmanCode(1, val[0]);
-        table[1] = ConstructHuffmanCode(1, val[1]);
-      } else {
-        table[0] = ConstructHuffmanCode(1, val[1]);
-        table[1] = ConstructHuffmanCode(1, val[0]);
-      }
-      table_size = 2;
-      break;
-    case 2:
-      table[0] = ConstructHuffmanCode(1, val[0]);
-      table[2] = ConstructHuffmanCode(1, val[0]);
-      if (val[2] > val[1]) {
-        table[1] = ConstructHuffmanCode(2, val[1]);
-        table[3] = ConstructHuffmanCode(2, val[2]);
-      } else {
-        table[1] = ConstructHuffmanCode(2, val[2]);
-        table[3] = ConstructHuffmanCode(2, val[1]);
-      }
-      table_size = 4;
-      break;
-    case 3: {
-      int i, k;
-      for (i = 0; i < 3; ++i) {
-        for (k = i + 1; k < 4; ++k) {
-          if (val[k] < val[i]) {
-            uint16_t t = val[k];
-            val[k] = val[i];
-            val[i] = t;
-          }
-        }
-      }
-      table[0] = ConstructHuffmanCode(2, val[0]);
-      table[2] = ConstructHuffmanCode(2, val[1]);
-      table[1] = ConstructHuffmanCode(2, val[2]);
-      table[3] = ConstructHuffmanCode(2, val[3]);
-      table_size = 4;
-      break;
-    }
-    case 4: {
-      if (val[3] < val[2]) {
-        uint16_t t = val[3];
-        val[3] = val[2];
-        val[2] = t;
-      }
-      table[0] = ConstructHuffmanCode(1, val[0]);
-      table[1] = ConstructHuffmanCode(2, val[1]);
-      table[2] = ConstructHuffmanCode(1, val[0]);
-      table[3] = ConstructHuffmanCode(3, val[2]);
-      table[4] = ConstructHuffmanCode(1, val[0]);
-      table[5] = ConstructHuffmanCode(2, val[1]);
-      table[6] = ConstructHuffmanCode(1, val[0]);
-      table[7] = ConstructHuffmanCode(3, val[3]);
-      table_size = 8;
-      break;
-    }
-  }
-  while (table_size != goal_size) {
-    memcpy(&table[table_size], &table[0],
-           (size_t)table_size * sizeof(table[0]));
-    table_size <<= 1;
-  }
-  return goal_size;
-}
-
-
diff --git a/src/duckdb/third_party/brotli/dec/huffman.h b/src/duckdb/third_party/brotli/dec/huffman.h
deleted file mode 100644
index 6569834f3..000000000
--- a/src/duckdb/third_party/brotli/dec/huffman.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Utilities for building Huffman decoding tables. */
-
-#ifndef BROTLI_DEC_HUFFMAN_H_
-#define BROTLI_DEC_HUFFMAN_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-#define BROTLI_HUFFMAN_MAX_CODE_LENGTH 15
-
-/* BROTLI_NUM_BLOCK_LEN_SYMBOLS == 26 */
-#define BROTLI_HUFFMAN_MAX_SIZE_26 396
-/* BROTLI_MAX_BLOCK_TYPE_SYMBOLS == 258 */
-#define BROTLI_HUFFMAN_MAX_SIZE_258 632
-/* BROTLI_MAX_CONTEXT_MAP_SYMBOLS == 272 */
-#define BROTLI_HUFFMAN_MAX_SIZE_272 646
-
-#define BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH 5
-
-#if ((defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_32)) && \
-  BROTLI_GNUC_HAS_ATTRIBUTE(aligned, 2, 7, 0))
-#define BROTLI_HUFFMAN_CODE_FAST_LOAD
-#endif
-
-#if !defined(BROTLI_HUFFMAN_CODE_FAST_LOAD)
-/* Do not create this struct directly - use the ConstructHuffmanCode
- * constructor below! */
-typedef struct {
-  uint8_t bits;    /* number of bits used for this symbol */
-  uint16_t value;  /* symbol value or table offset */
-} HuffmanCode;
-
-static BROTLI_INLINE HuffmanCode ConstructHuffmanCode(const uint8_t bits,
-    const uint16_t value) {
-  HuffmanCode h;
-  h.bits = bits;
-  h.value = value;
-  return h;
-}
-
-/* Please use the following macros to optimize HuffmanCode accesses in hot
- * paths.
- *
- * For example, assuming |table| contains a HuffmanCode pointer:
- *
- *   BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table);
- *   BROTLI_HC_ADJUST_TABLE_INDEX(table, index_into_table);
- *   *bits = BROTLI_HC_GET_BITS(table);
- *   *value = BROTLI_HC_GET_VALUE(table);
- *   BROTLI_HC_ADJUST_TABLE_INDEX(table, offset);
- *   *bits2 = BROTLI_HC_GET_BITS(table);
- *   *value2 = BROTLI_HC_GET_VALUE(table);
- *
- */
-
-#define BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(H)
-#define BROTLI_HC_ADJUST_TABLE_INDEX(H, V) H += (V)
-
-/* These must be given a HuffmanCode pointer! */
-#define BROTLI_HC_FAST_LOAD_BITS(H) (H->bits)
-#define BROTLI_HC_FAST_LOAD_VALUE(H) (H->value)
-
-#else /* BROTLI_HUFFMAN_CODE_FAST_LOAD */
-
-typedef BROTLI_ALIGNED(4) uint32_t HuffmanCode;
-
-static BROTLI_INLINE HuffmanCode ConstructHuffmanCode(const uint8_t bits,
-    const uint16_t value) {
-  return (HuffmanCode) ((value & 0xFFFF) << 16) | (bits & 0xFF);
-}
-
-#define BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(H) uint32_t __fastload_##H = (*H)
-#define BROTLI_HC_ADJUST_TABLE_INDEX(H, V) H += (V); __fastload_##H = (*H)
-
-/* These must be given a HuffmanCode pointer! */
-#define BROTLI_HC_FAST_LOAD_BITS(H) ((__fastload_##H) & 0xFF)
-#define BROTLI_HC_FAST_LOAD_VALUE(H) ((__fastload_##H) >> 16)
-#endif /* BROTLI_HUFFMAN_CODE_FAST_LOAD */
-
-/* Builds Huffman lookup table assuming code lengths are in symbol order. */
-BROTLI_INTERNAL void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table,
-    const uint8_t* const code_lengths, uint16_t* count);
-
-/* Builds Huffman lookup table assuming code lengths are in symbol order.
-   Returns size of resulting table. */
-BROTLI_INTERNAL uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
-    int root_bits, const uint16_t* const symbol_lists, uint16_t* count);
-
-/* Builds a simple Huffman table. The |num_symbols| parameter is to be
-   interpreted as follows: 0 means 1 symbol, 1 means 2 symbols,
-   2 means 3 symbols, 3 means 4 symbols with lengths [2, 2, 2, 2],
-   4 means 4 symbols with lengths [1, 2, 3, 3]. */
-BROTLI_INTERNAL uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
-    int root_bits, uint16_t* symbols, uint32_t num_symbols);
-
-/* Contains a collection of Huffman trees with the same alphabet size. */
-/* alphabet_size_limit is needed due to simple codes, since
-   log2(alphabet_size_max) could be greater than log2(alphabet_size_limit). */
-typedef struct {
-  HuffmanCode** htrees;
-  HuffmanCode* codes;
-  uint16_t alphabet_size_max;
-  uint16_t alphabet_size_limit;
-  uint16_t num_htrees;
-} HuffmanTreeGroup;
-
-}
-
-#endif  /* BROTLI_DEC_HUFFMAN_H_ */
diff --git a/src/duckdb/third_party/brotli/dec/prefix.h b/src/duckdb/third_party/brotli/dec/prefix.h
deleted file mode 100644
index 08240a739..000000000
--- a/src/duckdb/third_party/brotli/dec/prefix.h
+++ /dev/null
@@ -1,733 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Lookup tables to map prefix codes to value ranges. This is used during
-   decoding of the block lengths, literal insertion lengths and copy lengths. */
-
-#ifndef BROTLI_DEC_PREFIX_H_
-#define BROTLI_DEC_PREFIX_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-
-typedef struct CmdLutElement {
-  uint8_t insert_len_extra_bits;
-  uint8_t copy_len_extra_bits;
-  int8_t distance_code;
-  uint8_t context;
-  uint16_t insert_len_offset;
-  uint16_t copy_len_offset;
-} CmdLutElement;
-
-static const CmdLutElement kCmdLut[BROTLI_NUM_COMMAND_SYMBOLS] = {
-  { 0x00, 0x00, 0, 0x00, 0x0000, 0x0002 },
-  { 0x00, 0x00, 0, 0x01, 0x0000, 0x0003 },
-  { 0x00, 0x00, 0, 0x02, 0x0000, 0x0004 },
-  { 0x00, 0x00, 0, 0x03, 0x0000, 0x0005 },
-  { 0x00, 0x00, 0, 0x03, 0x0000, 0x0006 },
-  { 0x00, 0x00, 0, 0x03, 0x0000, 0x0007 },
-  { 0x00, 0x00, 0, 0x03, 0x0000, 0x0008 },
-  { 0x00, 0x00, 0, 0x03, 0x0000, 0x0009 },
-  { 0x00, 0x00, 0, 0x00, 0x0001, 0x0002 },
-  { 0x00, 0x00, 0, 0x01, 0x0001, 0x0003 },
-  { 0x00, 0x00, 0, 0x02, 0x0001, 0x0004 },
-  { 0x00, 0x00, 0, 0x03, 0x0001, 0x0005 },
-  { 0x00, 0x00, 0, 0x03, 0x0001, 0x0006 },
-  { 0x00, 0x00, 0, 0x03, 0x0001, 0x0007 },
-  { 0x00, 0x00, 0, 0x03, 0x0001, 0x0008 },
-  { 0x00, 0x00, 0, 0x03, 0x0001, 0x0009 },
-  { 0x00, 0x00, 0, 0x00, 0x0002, 0x0002 },
-  { 0x00, 0x00, 0, 0x01, 0x0002, 0x0003 },
-  { 0x00, 0x00, 0, 0x02, 0x0002, 0x0004 },
-  { 0x00, 0x00, 0, 0x03, 0x0002, 0x0005 },
-  { 0x00, 0x00, 0, 0x03, 0x0002, 0x0006 },
-  { 0x00, 0x00, 0, 0x03, 0x0002, 0x0007 },
-  { 0x00, 0x00, 0, 0x03, 0x0002, 0x0008 },
-  { 0x00, 0x00, 0, 0x03, 0x0002, 0x0009 },
-  { 0x00, 0x00, 0, 0x00, 0x0003, 0x0002 },
-  { 0x00, 0x00, 0, 0x01, 0x0003, 0x0003 },
-  { 0x00, 0x00, 0, 0x02, 0x0003, 0x0004 },
-  { 0x00, 0x00, 0, 0x03, 0x0003, 0x0005 },
-  { 0x00, 0x00, 0, 0x03, 0x0003, 0x0006 },
-  { 0x00, 0x00, 0, 0x03, 0x0003, 0x0007 },
-  { 0x00, 0x00, 0, 0x03, 0x0003, 0x0008 },
-  { 0x00, 0x00, 0, 0x03, 0x0003, 0x0009 },
-  { 0x00, 0x00, 0, 0x00, 0x0004, 0x0002 },
-  { 0x00, 0x00, 0, 0x01, 0x0004, 0x0003 },
-  { 0x00, 0x00, 0, 0x02, 0x0004, 0x0004 },
-  { 0x00, 0x00, 0, 0x03, 0x0004, 0x0005 },
-  { 0x00, 0x00, 0, 0x03, 0x0004, 0x0006 },
-  { 0x00, 0x00, 0, 0x03, 0x0004, 0x0007 },
-  { 0x00, 0x00, 0, 0x03, 0x0004, 0x0008 },
-  { 0x00, 0x00, 0, 0x03, 0x0004, 0x0009 },
-  { 0x00, 0x00, 0, 0x00, 0x0005, 0x0002 },
-  { 0x00, 0x00, 0, 0x01, 0x0005, 0x0003 },
-  { 0x00, 0x00, 0, 0x02, 0x0005, 0x0004 },
-  { 0x00, 0x00, 0, 0x03, 0x0005, 0x0005 },
-  { 0x00, 0x00, 0, 0x03, 0x0005, 0x0006 },
-  { 0x00, 0x00, 0, 0x03, 0x0005, 0x0007 },
-  { 0x00, 0x00, 0, 0x03, 0x0005, 0x0008 },
-  { 0x00, 0x00, 0, 0x03, 0x0005, 0x0009 },
-  { 0x01, 0x00, 0, 0x00, 0x0006, 0x0002 },
-  { 0x01, 0x00, 0, 0x01, 0x0006, 0x0003 },
-  { 0x01, 0x00, 0, 0x02, 0x0006, 0x0004 },
-  { 0x01, 0x00, 0, 0x03, 0x0006, 0x0005 },
-  { 0x01, 0x00, 0, 0x03, 0x0006, 0x0006 },
-  { 0x01, 0x00, 0, 0x03, 0x0006, 0x0007 },
-  { 0x01, 0x00, 0, 0x03, 0x0006, 0x0008 },
-  { 0x01, 0x00, 0, 0x03, 0x0006, 0x0009 },
-  { 0x01, 0x00, 0, 0x00, 0x0008, 0x0002 },
-  { 0x01, 0x00, 0, 0x01, 0x0008, 0x0003 },
-  { 0x01, 0x00, 0, 0x02, 0x0008, 0x0004 },
-  { 0x01, 0x00, 0, 0x03, 0x0008, 0x0005 },
-  { 0x01, 0x00, 0, 0x03, 0x0008, 0x0006 },
-  { 0x01, 0x00, 0, 0x03, 0x0008, 0x0007 },
-  { 0x01, 0x00, 0, 0x03, 0x0008, 0x0008 },
-  { 0x01, 0x00, 0, 0x03, 0x0008, 0x0009 },
-  { 0x00, 0x01, 0, 0x03, 0x0000, 0x000a },
-  { 0x00, 0x01, 0, 0x03, 0x0000, 0x000c },
-  { 0x00, 0x02, 0, 0x03, 0x0000, 0x000e },
-  { 0x00, 0x02, 0, 0x03, 0x0000, 0x0012 },
-  { 0x00, 0x03, 0, 0x03, 0x0000, 0x0016 },
-  { 0x00, 0x03, 0, 0x03, 0x0000, 0x001e },
-  { 0x00, 0x04, 0, 0x03, 0x0000, 0x0026 },
-  { 0x00, 0x04, 0, 0x03, 0x0000, 0x0036 },
-  { 0x00, 0x01, 0, 0x03, 0x0001, 0x000a },
-  { 0x00, 0x01, 0, 0x03, 0x0001, 0x000c },
-  { 0x00, 0x02, 0, 0x03, 0x0001, 0x000e },
-  { 0x00, 0x02, 0, 0x03, 0x0001, 0x0012 },
-  { 0x00, 0x03, 0, 0x03, 0x0001, 0x0016 },
-  { 0x00, 0x03, 0, 0x03, 0x0001, 0x001e },
-  { 0x00, 0x04, 0, 0x03, 0x0001, 0x0026 },
-  { 0x00, 0x04, 0, 0x03, 0x0001, 0x0036 },
-  { 0x00, 0x01, 0, 0x03, 0x0002, 0x000a },
-  { 0x00, 0x01, 0, 0x03, 0x0002, 0x000c },
-  { 0x00, 0x02, 0, 0x03, 0x0002, 0x000e },
-  { 0x00, 0x02, 0, 0x03, 0x0002, 0x0012 },
-  { 0x00, 0x03, 0, 0x03, 0x0002, 0x0016 },
-  { 0x00, 0x03, 0, 0x03, 0x0002, 0x001e },
-  { 0x00, 0x04, 0, 0x03, 0x0002, 0x0026 },
-  { 0x00, 0x04, 0, 0x03, 0x0002, 0x0036 },
-  { 0x00, 0x01, 0, 0x03, 0x0003, 0x000a },
-  { 0x00, 0x01, 0, 0x03, 0x0003, 0x000c },
-  { 0x00, 0x02, 0, 0x03, 0x0003, 0x000e },
-  { 0x00, 0x02, 0, 0x03, 0x0003, 0x0012 },
-  { 0x00, 0x03, 0, 0x03, 0x0003, 0x0016 },
-  { 0x00, 0x03, 0, 0x03, 0x0003, 0x001e },
-  { 0x00, 0x04, 0, 0x03, 0x0003, 0x0026 },
-  { 0x00, 0x04, 0, 0x03, 0x0003, 0x0036 },
-  { 0x00, 0x01, 0, 0x03, 0x0004, 0x000a },
-  { 0x00, 0x01, 0, 0x03, 0x0004, 0x000c },
-  { 0x00, 0x02, 0, 0x03, 0x0004, 0x000e },
-  { 0x00, 0x02, 0, 0x03, 0x0004, 0x0012 },
-  { 0x00, 0x03, 0, 0x03, 0x0004, 0x0016 },
-  { 0x00, 0x03, 0, 0x03, 0x0004, 0x001e },
-  { 0x00, 0x04, 0, 0x03, 0x0004, 0x0026 },
-  { 0x00, 0x04, 0, 0x03, 0x0004, 0x0036 },
-  { 0x00, 0x01, 0, 0x03, 0x0005, 0x000a },
-  { 0x00, 0x01, 0, 0x03, 0x0005, 0x000c },
-  { 0x00, 0x02, 0, 0x03, 0x0005, 0x000e },
-  { 0x00, 0x02, 0, 0x03, 0x0005, 0x0012 },
-  { 0x00, 0x03, 0, 0x03, 0x0005, 0x0016 },
-  { 0x00, 0x03, 0, 0x03, 0x0005, 0x001e },
-  { 0x00, 0x04, 0, 0x03, 0x0005, 0x0026 },
-  { 0x00, 0x04, 0, 0x03, 0x0005, 0x0036 },
-  { 0x01, 0x01, 0, 0x03, 0x0006, 0x000a },
-  { 0x01, 0x01, 0, 0x03, 0x0006, 0x000c },
-  { 0x01, 0x02, 0, 0x03, 0x0006, 0x000e },
-  { 0x01, 0x02, 0, 0x03, 0x0006, 0x0012 },
-  { 0x01, 0x03, 0, 0x03, 0x0006, 0x0016 },
-  { 0x01, 0x03, 0, 0x03, 0x0006, 0x001e },
-  { 0x01, 0x04, 0, 0x03, 0x0006, 0x0026 },
-  { 0x01, 0x04, 0, 0x03, 0x0006, 0x0036 },
-  { 0x01, 0x01, 0, 0x03, 0x0008, 0x000a },
-  { 0x01, 0x01, 0, 0x03, 0x0008, 0x000c },
-  { 0x01, 0x02, 0, 0x03, 0x0008, 0x000e },
-  { 0x01, 0x02, 0, 0x03, 0x0008, 0x0012 },
-  { 0x01, 0x03, 0, 0x03, 0x0008, 0x0016 },
-  { 0x01, 0x03, 0, 0x03, 0x0008, 0x001e },
-  { 0x01, 0x04, 0, 0x03, 0x0008, 0x0026 },
-  { 0x01, 0x04, 0, 0x03, 0x0008, 0x0036 },
-  { 0x00, 0x00, -1, 0x00, 0x0000, 0x0002 },
-  { 0x00, 0x00, -1, 0x01, 0x0000, 0x0003 },
-  { 0x00, 0x00, -1, 0x02, 0x0000, 0x0004 },
-  { 0x00, 0x00, -1, 0x03, 0x0000, 0x0005 },
-  { 0x00, 0x00, -1, 0x03, 0x0000, 0x0006 },
-  { 0x00, 0x00, -1, 0x03, 0x0000, 0x0007 },
-  { 0x00, 0x00, -1, 0x03, 0x0000, 0x0008 },
-  { 0x00, 0x00, -1, 0x03, 0x0000, 0x0009 },
-  { 0x00, 0x00, -1, 0x00, 0x0001, 0x0002 },
-  { 0x00, 0x00, -1, 0x01, 0x0001, 0x0003 },
-  { 0x00, 0x00, -1, 0x02, 0x0001, 0x0004 },
-  { 0x00, 0x00, -1, 0x03, 0x0001, 0x0005 },
-  { 0x00, 0x00, -1, 0x03, 0x0001, 0x0006 },
-  { 0x00, 0x00, -1, 0x03, 0x0001, 0x0007 },
-  { 0x00, 0x00, -1, 0x03, 0x0001, 0x0008 },
-  { 0x00, 0x00, -1, 0x03, 0x0001, 0x0009 },
-  { 0x00, 0x00, -1, 0x00, 0x0002, 0x0002 },
-  { 0x00, 0x00, -1, 0x01, 0x0002, 0x0003 },
-  { 0x00, 0x00, -1, 0x02, 0x0002, 0x0004 },
-  { 0x00, 0x00, -1, 0x03, 0x0002, 0x0005 },
-  { 0x00, 0x00, -1, 0x03, 0x0002, 0x0006 },
-  { 0x00, 0x00, -1, 0x03, 0x0002, 0x0007 },
-  { 0x00, 0x00, -1, 0x03, 0x0002, 0x0008 },
-  { 0x00, 0x00, -1, 0x03, 0x0002, 0x0009 },
-  { 0x00, 0x00, -1, 0x00, 0x0003, 0x0002 },
-  { 0x00, 0x00, -1, 0x01, 0x0003, 0x0003 },
-  { 0x00, 0x00, -1, 0x02, 0x0003, 0x0004 },
-  { 0x00, 0x00, -1, 0x03, 0x0003, 0x0005 },
-  { 0x00, 0x00, -1, 0x03, 0x0003, 0x0006 },
-  { 0x00, 0x00, -1, 0x03, 0x0003, 0x0007 },
-  { 0x00, 0x00, -1, 0x03, 0x0003, 0x0008 },
-  { 0x00, 0x00, -1, 0x03, 0x0003, 0x0009 },
-  { 0x00, 0x00, -1, 0x00, 0x0004, 0x0002 },
-  { 0x00, 0x00, -1, 0x01, 0x0004, 0x0003 },
-  { 0x00, 0x00, -1, 0x02, 0x0004, 0x0004 },
-  { 0x00, 0x00, -1, 0x03, 0x0004, 0x0005 },
-  { 0x00, 0x00, -1, 0x03, 0x0004, 0x0006 },
-  { 0x00, 0x00, -1, 0x03, 0x0004, 0x0007 },
-  { 0x00, 0x00, -1, 0x03, 0x0004, 0x0008 },
-  { 0x00, 0x00, -1, 0x03, 0x0004, 0x0009 },
-  { 0x00, 0x00, -1, 0x00, 0x0005, 0x0002 },
-  { 0x00, 0x00, -1, 0x01, 0x0005, 0x0003 },
-  { 0x00, 0x00, -1, 0x02, 0x0005, 0x0004 },
-  { 0x00, 0x00, -1, 0x03, 0x0005, 0x0005 },
-  { 0x00, 0x00, -1, 0x03, 0x0005, 0x0006 },
-  { 0x00, 0x00, -1, 0x03, 0x0005, 0x0007 },
-  { 0x00, 0x00, -1, 0x03, 0x0005, 0x0008 },
-  { 0x00, 0x00, -1, 0x03, 0x0005, 0x0009 },
-  { 0x01, 0x00, -1, 0x00, 0x0006, 0x0002 },
-  { 0x01, 0x00, -1, 0x01, 0x0006, 0x0003 },
-  { 0x01, 0x00, -1, 0x02, 0x0006, 0x0004 },
-  { 0x01, 0x00, -1, 0x03, 0x0006, 0x0005 },
-  { 0x01, 0x00, -1, 0x03, 0x0006, 0x0006 },
-  { 0x01, 0x00, -1, 0x03, 0x0006, 0x0007 },
-  { 0x01, 0x00, -1, 0x03, 0x0006, 0x0008 },
-  { 0x01, 0x00, -1, 0x03, 0x0006, 0x0009 },
-  { 0x01, 0x00, -1, 0x00, 0x0008, 0x0002 },
-  { 0x01, 0x00, -1, 0x01, 0x0008, 0x0003 },
-  { 0x01, 0x00, -1, 0x02, 0x0008, 0x0004 },
-  { 0x01, 0x00, -1, 0x03, 0x0008, 0x0005 },
-  { 0x01, 0x00, -1, 0x03, 0x0008, 0x0006 },
-  { 0x01, 0x00, -1, 0x03, 0x0008, 0x0007 },
-  { 0x01, 0x00, -1, 0x03, 0x0008, 0x0008 },
-  { 0x01, 0x00, -1, 0x03, 0x0008, 0x0009 },
-  { 0x00, 0x01, -1, 0x03, 0x0000, 0x000a },
-  { 0x00, 0x01, -1, 0x03, 0x0000, 0x000c },
-  { 0x00, 0x02, -1, 0x03, 0x0000, 0x000e },
-  { 0x00, 0x02, -1, 0x03, 0x0000, 0x0012 },
-  { 0x00, 0x03, -1, 0x03, 0x0000, 0x0016 },
-  { 0x00, 0x03, -1, 0x03, 0x0000, 0x001e },
-  { 0x00, 0x04, -1, 0x03, 0x0000, 0x0026 },
-  { 0x00, 0x04, -1, 0x03, 0x0000, 0x0036 },
-  { 0x00, 0x01, -1, 0x03, 0x0001, 0x000a },
-  { 0x00, 0x01, -1, 0x03, 0x0001, 0x000c },
-  { 0x00, 0x02, -1, 0x03, 0x0001, 0x000e },
-  { 0x00, 0x02, -1, 0x03, 0x0001, 0x0012 },
-  { 0x00, 0x03, -1, 0x03, 0x0001, 0x0016 },
-  { 0x00, 0x03, -1, 0x03, 0x0001, 0x001e },
-  { 0x00, 0x04, -1, 0x03, 0x0001, 0x0026 },
-  { 0x00, 0x04, -1, 0x03, 0x0001, 0x0036 },
-  { 0x00, 0x01, -1, 0x03, 0x0002, 0x000a },
-  { 0x00, 0x01, -1, 0x03, 0x0002, 0x000c },
-  { 0x00, 0x02, -1, 0x03, 0x0002, 0x000e },
-  { 0x00, 0x02, -1, 0x03, 0x0002, 0x0012 },
-  { 0x00, 0x03, -1, 0x03, 0x0002, 0x0016 },
-  { 0x00, 0x03, -1, 0x03, 0x0002, 0x001e },
-  { 0x00, 0x04, -1, 0x03, 0x0002, 0x0026 },
-  { 0x00, 0x04, -1, 0x03, 0x0002, 0x0036 },
-  { 0x00, 0x01, -1, 0x03, 0x0003, 0x000a },
-  { 0x00, 0x01, -1, 0x03, 0x0003, 0x000c },
-  { 0x00, 0x02, -1, 0x03, 0x0003, 0x000e },
-  { 0x00, 0x02, -1, 0x03, 0x0003, 0x0012 },
-  { 0x00, 0x03, -1, 0x03, 0x0003, 0x0016 },
-  { 0x00, 0x03, -1, 0x03, 0x0003, 0x001e },
-  { 0x00, 0x04, -1, 0x03, 0x0003, 0x0026 },
-  { 0x00, 0x04, -1, 0x03, 0x0003, 0x0036 },
-  { 0x00, 0x01, -1, 0x03, 0x0004, 0x000a },
-  { 0x00, 0x01, -1, 0x03, 0x0004, 0x000c },
-  { 0x00, 0x02, -1, 0x03, 0x0004, 0x000e },
-  { 0x00, 0x02, -1, 0x03, 0x0004, 0x0012 },
-  { 0x00, 0x03, -1, 0x03, 0x0004, 0x0016 },
-  { 0x00, 0x03, -1, 0x03, 0x0004, 0x001e },
-  { 0x00, 0x04, -1, 0x03, 0x0004, 0x0026 },
-  { 0x00, 0x04, -1, 0x03, 0x0004, 0x0036 },
-  { 0x00, 0x01, -1, 0x03, 0x0005, 0x000a },
-  { 0x00, 0x01, -1, 0x03, 0x0005, 0x000c },
-  { 0x00, 0x02, -1, 0x03, 0x0005, 0x000e },
-  { 0x00, 0x02, -1, 0x03, 0x0005, 0x0012 },
-  { 0x00, 0x03, -1, 0x03, 0x0005, 0x0016 },
-  { 0x00, 0x03, -1, 0x03, 0x0005, 0x001e },
-  { 0x00, 0x04, -1, 0x03, 0x0005, 0x0026 },
-  { 0x00, 0x04, -1, 0x03, 0x0005, 0x0036 },
-  { 0x01, 0x01, -1, 0x03, 0x0006, 0x000a },
-  { 0x01, 0x01, -1, 0x03, 0x0006, 0x000c },
-  { 0x01, 0x02, -1, 0x03, 0x0006, 0x000e },
-  { 0x01, 0x02, -1, 0x03, 0x0006, 0x0012 },
-  { 0x01, 0x03, -1, 0x03, 0x0006, 0x0016 },
-  { 0x01, 0x03, -1, 0x03, 0x0006, 0x001e },
-  { 0x01, 0x04, -1, 0x03, 0x0006, 0x0026 },
-  { 0x01, 0x04, -1, 0x03, 0x0006, 0x0036 },
-  { 0x01, 0x01, -1, 0x03, 0x0008, 0x000a },
-  { 0x01, 0x01, -1, 0x03, 0x0008, 0x000c },
-  { 0x01, 0x02, -1, 0x03, 0x0008, 0x000e },
-  { 0x01, 0x02, -1, 0x03, 0x0008, 0x0012 },
-  { 0x01, 0x03, -1, 0x03, 0x0008, 0x0016 },
-  { 0x01, 0x03, -1, 0x03, 0x0008, 0x001e },
-  { 0x01, 0x04, -1, 0x03, 0x0008, 0x0026 },
-  { 0x01, 0x04, -1, 0x03, 0x0008, 0x0036 },
-  { 0x02, 0x00, -1, 0x00, 0x000a, 0x0002 },
-  { 0x02, 0x00, -1, 0x01, 0x000a, 0x0003 },
-  { 0x02, 0x00, -1, 0x02, 0x000a, 0x0004 },
-  { 0x02, 0x00, -1, 0x03, 0x000a, 0x0005 },
-  { 0x02, 0x00, -1, 0x03, 0x000a, 0x0006 },
-  { 0x02, 0x00, -1, 0x03, 0x000a, 0x0007 },
-  { 0x02, 0x00, -1, 0x03, 0x000a, 0x0008 },
-  { 0x02, 0x00, -1, 0x03, 0x000a, 0x0009 },
-  { 0x02, 0x00, -1, 0x00, 0x000e, 0x0002 },
-  { 0x02, 0x00, -1, 0x01, 0x000e, 0x0003 },
-  { 0x02, 0x00, -1, 0x02, 0x000e, 0x0004 },
-  { 0x02, 0x00, -1, 0x03, 0x000e, 0x0005 },
-  { 0x02, 0x00, -1, 0x03, 0x000e, 0x0006 },
-  { 0x02, 0x00, -1, 0x03, 0x000e, 0x0007 },
-  { 0x02, 0x00, -1, 0x03, 0x000e, 0x0008 },
-  { 0x02, 0x00, -1, 0x03, 0x000e, 0x0009 },
-  { 0x03, 0x00, -1, 0x00, 0x0012, 0x0002 },
-  { 0x03, 0x00, -1, 0x01, 0x0012, 0x0003 },
-  { 0x03, 0x00, -1, 0x02, 0x0012, 0x0004 },
-  { 0x03, 0x00, -1, 0x03, 0x0012, 0x0005 },
-  { 0x03, 0x00, -1, 0x03, 0x0012, 0x0006 },
-  { 0x03, 0x00, -1, 0x03, 0x0012, 0x0007 },
-  { 0x03, 0x00, -1, 0x03, 0x0012, 0x0008 },
-  { 0x03, 0x00, -1, 0x03, 0x0012, 0x0009 },
-  { 0x03, 0x00, -1, 0x00, 0x001a, 0x0002 },
-  { 0x03, 0x00, -1, 0x01, 0x001a, 0x0003 },
-  { 0x03, 0x00, -1, 0x02, 0x001a, 0x0004 },
-  { 0x03, 0x00, -1, 0x03, 0x001a, 0x0005 },
-  { 0x03, 0x00, -1, 0x03, 0x001a, 0x0006 },
-  { 0x03, 0x00, -1, 0x03, 0x001a, 0x0007 },
-  { 0x03, 0x00, -1, 0x03, 0x001a, 0x0008 },
-  { 0x03, 0x00, -1, 0x03, 0x001a, 0x0009 },
-  { 0x04, 0x00, -1, 0x00, 0x0022, 0x0002 },
-  { 0x04, 0x00, -1, 0x01, 0x0022, 0x0003 },
-  { 0x04, 0x00, -1, 0x02, 0x0022, 0x0004 },
-  { 0x04, 0x00, -1, 0x03, 0x0022, 0x0005 },
-  { 0x04, 0x00, -1, 0x03, 0x0022, 0x0006 },
-  { 0x04, 0x00, -1, 0x03, 0x0022, 0x0007 },
-  { 0x04, 0x00, -1, 0x03, 0x0022, 0x0008 },
-  { 0x04, 0x00, -1, 0x03, 0x0022, 0x0009 },
-  { 0x04, 0x00, -1, 0x00, 0x0032, 0x0002 },
-  { 0x04, 0x00, -1, 0x01, 0x0032, 0x0003 },
-  { 0x04, 0x00, -1, 0x02, 0x0032, 0x0004 },
-  { 0x04, 0x00, -1, 0x03, 0x0032, 0x0005 },
-  { 0x04, 0x00, -1, 0x03, 0x0032, 0x0006 },
-  { 0x04, 0x00, -1, 0x03, 0x0032, 0x0007 },
-  { 0x04, 0x00, -1, 0x03, 0x0032, 0x0008 },
-  { 0x04, 0x00, -1, 0x03, 0x0032, 0x0009 },
-  { 0x05, 0x00, -1, 0x00, 0x0042, 0x0002 },
-  { 0x05, 0x00, -1, 0x01, 0x0042, 0x0003 },
-  { 0x05, 0x00, -1, 0x02, 0x0042, 0x0004 },
-  { 0x05, 0x00, -1, 0x03, 0x0042, 0x0005 },
-  { 0x05, 0x00, -1, 0x03, 0x0042, 0x0006 },
-  { 0x05, 0x00, -1, 0x03, 0x0042, 0x0007 },
-  { 0x05, 0x00, -1, 0x03, 0x0042, 0x0008 },
-  { 0x05, 0x00, -1, 0x03, 0x0042, 0x0009 },
-  { 0x05, 0x00, -1, 0x00, 0x0062, 0x0002 },
-  { 0x05, 0x00, -1, 0x01, 0x0062, 0x0003 },
-  { 0x05, 0x00, -1, 0x02, 0x0062, 0x0004 },
-  { 0x05, 0x00, -1, 0x03, 0x0062, 0x0005 },
-  { 0x05, 0x00, -1, 0x03, 0x0062, 0x0006 },
-  { 0x05, 0x00, -1, 0x03, 0x0062, 0x0007 },
-  { 0x05, 0x00, -1, 0x03, 0x0062, 0x0008 },
-  { 0x05, 0x00, -1, 0x03, 0x0062, 0x0009 },
-  { 0x02, 0x01, -1, 0x03, 0x000a, 0x000a },
-  { 0x02, 0x01, -1, 0x03, 0x000a, 0x000c },
-  { 0x02, 0x02, -1, 0x03, 0x000a, 0x000e },
-  { 0x02, 0x02, -1, 0x03, 0x000a, 0x0012 },
-  { 0x02, 0x03, -1, 0x03, 0x000a, 0x0016 },
-  { 0x02, 0x03, -1, 0x03, 0x000a, 0x001e },
-  { 0x02, 0x04, -1, 0x03, 0x000a, 0x0026 },
-  { 0x02, 0x04, -1, 0x03, 0x000a, 0x0036 },
-  { 0x02, 0x01, -1, 0x03, 0x000e, 0x000a },
-  { 0x02, 0x01, -1, 0x03, 0x000e, 0x000c },
-  { 0x02, 0x02, -1, 0x03, 0x000e, 0x000e },
-  { 0x02, 0x02, -1, 0x03, 0x000e, 0x0012 },
-  { 0x02, 0x03, -1, 0x03, 0x000e, 0x0016 },
-  { 0x02, 0x03, -1, 0x03, 0x000e, 0x001e },
-  { 0x02, 0x04, -1, 0x03, 0x000e, 0x0026 },
-  { 0x02, 0x04, -1, 0x03, 0x000e, 0x0036 },
-  { 0x03, 0x01, -1, 0x03, 0x0012, 0x000a },
-  { 0x03, 0x01, -1, 0x03, 0x0012, 0x000c },
-  { 0x03, 0x02, -1, 0x03, 0x0012, 0x000e },
-  { 0x03, 0x02, -1, 0x03, 0x0012, 0x0012 },
-  { 0x03, 0x03, -1, 0x03, 0x0012, 0x0016 },
-  { 0x03, 0x03, -1, 0x03, 0x0012, 0x001e },
-  { 0x03, 0x04, -1, 0x03, 0x0012, 0x0026 },
-  { 0x03, 0x04, -1, 0x03, 0x0012, 0x0036 },
-  { 0x03, 0x01, -1, 0x03, 0x001a, 0x000a },
-  { 0x03, 0x01, -1, 0x03, 0x001a, 0x000c },
-  { 0x03, 0x02, -1, 0x03, 0x001a, 0x000e },
-  { 0x03, 0x02, -1, 0x03, 0x001a, 0x0012 },
-  { 0x03, 0x03, -1, 0x03, 0x001a, 0x0016 },
-  { 0x03, 0x03, -1, 0x03, 0x001a, 0x001e },
-  { 0x03, 0x04, -1, 0x03, 0x001a, 0x0026 },
-  { 0x03, 0x04, -1, 0x03, 0x001a, 0x0036 },
-  { 0x04, 0x01, -1, 0x03, 0x0022, 0x000a },
-  { 0x04, 0x01, -1, 0x03, 0x0022, 0x000c },
-  { 0x04, 0x02, -1, 0x03, 0x0022, 0x000e },
-  { 0x04, 0x02, -1, 0x03, 0x0022, 0x0012 },
-  { 0x04, 0x03, -1, 0x03, 0x0022, 0x0016 },
-  { 0x04, 0x03, -1, 0x03, 0x0022, 0x001e },
-  { 0x04, 0x04, -1, 0x03, 0x0022, 0x0026 },
-  { 0x04, 0x04, -1, 0x03, 0x0022, 0x0036 },
-  { 0x04, 0x01, -1, 0x03, 0x0032, 0x000a },
-  { 0x04, 0x01, -1, 0x03, 0x0032, 0x000c },
-  { 0x04, 0x02, -1, 0x03, 0x0032, 0x000e },
-  { 0x04, 0x02, -1, 0x03, 0x0032, 0x0012 },
-  { 0x04, 0x03, -1, 0x03, 0x0032, 0x0016 },
-  { 0x04, 0x03, -1, 0x03, 0x0032, 0x001e },
-  { 0x04, 0x04, -1, 0x03, 0x0032, 0x0026 },
-  { 0x04, 0x04, -1, 0x03, 0x0032, 0x0036 },
-  { 0x05, 0x01, -1, 0x03, 0x0042, 0x000a },
-  { 0x05, 0x01, -1, 0x03, 0x0042, 0x000c },
-  { 0x05, 0x02, -1, 0x03, 0x0042, 0x000e },
-  { 0x05, 0x02, -1, 0x03, 0x0042, 0x0012 },
-  { 0x05, 0x03, -1, 0x03, 0x0042, 0x0016 },
-  { 0x05, 0x03, -1, 0x03, 0x0042, 0x001e },
-  { 0x05, 0x04, -1, 0x03, 0x0042, 0x0026 },
-  { 0x05, 0x04, -1, 0x03, 0x0042, 0x0036 },
-  { 0x05, 0x01, -1, 0x03, 0x0062, 0x000a },
-  { 0x05, 0x01, -1, 0x03, 0x0062, 0x000c },
-  { 0x05, 0x02, -1, 0x03, 0x0062, 0x000e },
-  { 0x05, 0x02, -1, 0x03, 0x0062, 0x0012 },
-  { 0x05, 0x03, -1, 0x03, 0x0062, 0x0016 },
-  { 0x05, 0x03, -1, 0x03, 0x0062, 0x001e },
-  { 0x05, 0x04, -1, 0x03, 0x0062, 0x0026 },
-  { 0x05, 0x04, -1, 0x03, 0x0062, 0x0036 },
-  { 0x00, 0x05, -1, 0x03, 0x0000, 0x0046 },
-  { 0x00, 0x05, -1, 0x03, 0x0000, 0x0066 },
-  { 0x00, 0x06, -1, 0x03, 0x0000, 0x0086 },
-  { 0x00, 0x07, -1, 0x03, 0x0000, 0x00c6 },
-  { 0x00, 0x08, -1, 0x03, 0x0000, 0x0146 },
-  { 0x00, 0x09, -1, 0x03, 0x0000, 0x0246 },
-  { 0x00, 0x0a, -1, 0x03, 0x0000, 0x0446 },
-  { 0x00, 0x18, -1, 0x03, 0x0000, 0x0846 },
-  { 0x00, 0x05, -1, 0x03, 0x0001, 0x0046 },
-  { 0x00, 0x05, -1, 0x03, 0x0001, 0x0066 },
-  { 0x00, 0x06, -1, 0x03, 0x0001, 0x0086 },
-  { 0x00, 0x07, -1, 0x03, 0x0001, 0x00c6 },
-  { 0x00, 0x08, -1, 0x03, 0x0001, 0x0146 },
-  { 0x00, 0x09, -1, 0x03, 0x0001, 0x0246 },
-  { 0x00, 0x0a, -1, 0x03, 0x0001, 0x0446 },
-  { 0x00, 0x18, -1, 0x03, 0x0001, 0x0846 },
-  { 0x00, 0x05, -1, 0x03, 0x0002, 0x0046 },
-  { 0x00, 0x05, -1, 0x03, 0x0002, 0x0066 },
-  { 0x00, 0x06, -1, 0x03, 0x0002, 0x0086 },
-  { 0x00, 0x07, -1, 0x03, 0x0002, 0x00c6 },
-  { 0x00, 0x08, -1, 0x03, 0x0002, 0x0146 },
-  { 0x00, 0x09, -1, 0x03, 0x0002, 0x0246 },
-  { 0x00, 0x0a, -1, 0x03, 0x0002, 0x0446 },
-  { 0x00, 0x18, -1, 0x03, 0x0002, 0x0846 },
-  { 0x00, 0x05, -1, 0x03, 0x0003, 0x0046 },
-  { 0x00, 0x05, -1, 0x03, 0x0003, 0x0066 },
-  { 0x00, 0x06, -1, 0x03, 0x0003, 0x0086 },
-  { 0x00, 0x07, -1, 0x03, 0x0003, 0x00c6 },
-  { 0x00, 0x08, -1, 0x03, 0x0003, 0x0146 },
-  { 0x00, 0x09, -1, 0x03, 0x0003, 0x0246 },
-  { 0x00, 0x0a, -1, 0x03, 0x0003, 0x0446 },
-  { 0x00, 0x18, -1, 0x03, 0x0003, 0x0846 },
-  { 0x00, 0x05, -1, 0x03, 0x0004, 0x0046 },
-  { 0x00, 0x05, -1, 0x03, 0x0004, 0x0066 },
-  { 0x00, 0x06, -1, 0x03, 0x0004, 0x0086 },
-  { 0x00, 0x07, -1, 0x03, 0x0004, 0x00c6 },
-  { 0x00, 0x08, -1, 0x03, 0x0004, 0x0146 },
-  { 0x00, 0x09, -1, 0x03, 0x0004, 0x0246 },
-  { 0x00, 0x0a, -1, 0x03, 0x0004, 0x0446 },
-  { 0x00, 0x18, -1, 0x03, 0x0004, 0x0846 },
-  { 0x00, 0x05, -1, 0x03, 0x0005, 0x0046 },
-  { 0x00, 0x05, -1, 0x03, 0x0005, 0x0066 },
-  { 0x00, 0x06, -1, 0x03, 0x0005, 0x0086 },
-  { 0x00, 0x07, -1, 0x03, 0x0005, 0x00c6 },
-  { 0x00, 0x08, -1, 0x03, 0x0005, 0x0146 },
-  { 0x00, 0x09, -1, 0x03, 0x0005, 0x0246 },
-  { 0x00, 0x0a, -1, 0x03, 0x0005, 0x0446 },
-  { 0x00, 0x18, -1, 0x03, 0x0005, 0x0846 },
-  { 0x01, 0x05, -1, 0x03, 0x0006, 0x0046 },
-  { 0x01, 0x05, -1, 0x03, 0x0006, 0x0066 },
-  { 0x01, 0x06, -1, 0x03, 0x0006, 0x0086 },
-  { 0x01, 0x07, -1, 0x03, 0x0006, 0x00c6 },
-  { 0x01, 0x08, -1, 0x03, 0x0006, 0x0146 },
-  { 0x01, 0x09, -1, 0x03, 0x0006, 0x0246 },
-  { 0x01, 0x0a, -1, 0x03, 0x0006, 0x0446 },
-  { 0x01, 0x18, -1, 0x03, 0x0006, 0x0846 },
-  { 0x01, 0x05, -1, 0x03, 0x0008, 0x0046 },
-  { 0x01, 0x05, -1, 0x03, 0x0008, 0x0066 },
-  { 0x01, 0x06, -1, 0x03, 0x0008, 0x0086 },
-  { 0x01, 0x07, -1, 0x03, 0x0008, 0x00c6 },
-  { 0x01, 0x08, -1, 0x03, 0x0008, 0x0146 },
-  { 0x01, 0x09, -1, 0x03, 0x0008, 0x0246 },
-  { 0x01, 0x0a, -1, 0x03, 0x0008, 0x0446 },
-  { 0x01, 0x18, -1, 0x03, 0x0008, 0x0846 },
-  { 0x06, 0x00, -1, 0x00, 0x0082, 0x0002 },
-  { 0x06, 0x00, -1, 0x01, 0x0082, 0x0003 },
-  { 0x06, 0x00, -1, 0x02, 0x0082, 0x0004 },
-  { 0x06, 0x00, -1, 0x03, 0x0082, 0x0005 },
-  { 0x06, 0x00, -1, 0x03, 0x0082, 0x0006 },
-  { 0x06, 0x00, -1, 0x03, 0x0082, 0x0007 },
-  { 0x06, 0x00, -1, 0x03, 0x0082, 0x0008 },
-  { 0x06, 0x00, -1, 0x03, 0x0082, 0x0009 },
-  { 0x07, 0x00, -1, 0x00, 0x00c2, 0x0002 },
-  { 0x07, 0x00, -1, 0x01, 0x00c2, 0x0003 },
-  { 0x07, 0x00, -1, 0x02, 0x00c2, 0x0004 },
-  { 0x07, 0x00, -1, 0x03, 0x00c2, 0x0005 },
-  { 0x07, 0x00, -1, 0x03, 0x00c2, 0x0006 },
-  { 0x07, 0x00, -1, 0x03, 0x00c2, 0x0007 },
-  { 0x07, 0x00, -1, 0x03, 0x00c2, 0x0008 },
-  { 0x07, 0x00, -1, 0x03, 0x00c2, 0x0009 },
-  { 0x08, 0x00, -1, 0x00, 0x0142, 0x0002 },
-  { 0x08, 0x00, -1, 0x01, 0x0142, 0x0003 },
-  { 0x08, 0x00, -1, 0x02, 0x0142, 0x0004 },
-  { 0x08, 0x00, -1, 0x03, 0x0142, 0x0005 },
-  { 0x08, 0x00, -1, 0x03, 0x0142, 0x0006 },
-  { 0x08, 0x00, -1, 0x03, 0x0142, 0x0007 },
-  { 0x08, 0x00, -1, 0x03, 0x0142, 0x0008 },
-  { 0x08, 0x00, -1, 0x03, 0x0142, 0x0009 },
-  { 0x09, 0x00, -1, 0x00, 0x0242, 0x0002 },
-  { 0x09, 0x00, -1, 0x01, 0x0242, 0x0003 },
-  { 0x09, 0x00, -1, 0x02, 0x0242, 0x0004 },
-  { 0x09, 0x00, -1, 0x03, 0x0242, 0x0005 },
-  { 0x09, 0x00, -1, 0x03, 0x0242, 0x0006 },
-  { 0x09, 0x00, -1, 0x03, 0x0242, 0x0007 },
-  { 0x09, 0x00, -1, 0x03, 0x0242, 0x0008 },
-  { 0x09, 0x00, -1, 0x03, 0x0242, 0x0009 },
-  { 0x0a, 0x00, -1, 0x00, 0x0442, 0x0002 },
-  { 0x0a, 0x00, -1, 0x01, 0x0442, 0x0003 },
-  { 0x0a, 0x00, -1, 0x02, 0x0442, 0x0004 },
-  { 0x0a, 0x00, -1, 0x03, 0x0442, 0x0005 },
-  { 0x0a, 0x00, -1, 0x03, 0x0442, 0x0006 },
-  { 0x0a, 0x00, -1, 0x03, 0x0442, 0x0007 },
-  { 0x0a, 0x00, -1, 0x03, 0x0442, 0x0008 },
-  { 0x0a, 0x00, -1, 0x03, 0x0442, 0x0009 },
-  { 0x0c, 0x00, -1, 0x00, 0x0842, 0x0002 },
-  { 0x0c, 0x00, -1, 0x01, 0x0842, 0x0003 },
-  { 0x0c, 0x00, -1, 0x02, 0x0842, 0x0004 },
-  { 0x0c, 0x00, -1, 0x03, 0x0842, 0x0005 },
-  { 0x0c, 0x00, -1, 0x03, 0x0842, 0x0006 },
-  { 0x0c, 0x00, -1, 0x03, 0x0842, 0x0007 },
-  { 0x0c, 0x00, -1, 0x03, 0x0842, 0x0008 },
-  { 0x0c, 0x00, -1, 0x03, 0x0842, 0x0009 },
-  { 0x0e, 0x00, -1, 0x00, 0x1842, 0x0002 },
-  { 0x0e, 0x00, -1, 0x01, 0x1842, 0x0003 },
-  { 0x0e, 0x00, -1, 0x02, 0x1842, 0x0004 },
-  { 0x0e, 0x00, -1, 0x03, 0x1842, 0x0005 },
-  { 0x0e, 0x00, -1, 0x03, 0x1842, 0x0006 },
-  { 0x0e, 0x00, -1, 0x03, 0x1842, 0x0007 },
-  { 0x0e, 0x00, -1, 0x03, 0x1842, 0x0008 },
-  { 0x0e, 0x00, -1, 0x03, 0x1842, 0x0009 },
-  { 0x18, 0x00, -1, 0x00, 0x5842, 0x0002 },
-  { 0x18, 0x00, -1, 0x01, 0x5842, 0x0003 },
-  { 0x18, 0x00, -1, 0x02, 0x5842, 0x0004 },
-  { 0x18, 0x00, -1, 0x03, 0x5842, 0x0005 },
-  { 0x18, 0x00, -1, 0x03, 0x5842, 0x0006 },
-  { 0x18, 0x00, -1, 0x03, 0x5842, 0x0007 },
-  { 0x18, 0x00, -1, 0x03, 0x5842, 0x0008 },
-  { 0x18, 0x00, -1, 0x03, 0x5842, 0x0009 },
-  { 0x02, 0x05, -1, 0x03, 0x000a, 0x0046 },
-  { 0x02, 0x05, -1, 0x03, 0x000a, 0x0066 },
-  { 0x02, 0x06, -1, 0x03, 0x000a, 0x0086 },
-  { 0x02, 0x07, -1, 0x03, 0x000a, 0x00c6 },
-  { 0x02, 0x08, -1, 0x03, 0x000a, 0x0146 },
-  { 0x02, 0x09, -1, 0x03, 0x000a, 0x0246 },
-  { 0x02, 0x0a, -1, 0x03, 0x000a, 0x0446 },
-  { 0x02, 0x18, -1, 0x03, 0x000a, 0x0846 },
-  { 0x02, 0x05, -1, 0x03, 0x000e, 0x0046 },
-  { 0x02, 0x05, -1, 0x03, 0x000e, 0x0066 },
-  { 0x02, 0x06, -1, 0x03, 0x000e, 0x0086 },
-  { 0x02, 0x07, -1, 0x03, 0x000e, 0x00c6 },
-  { 0x02, 0x08, -1, 0x03, 0x000e, 0x0146 },
-  { 0x02, 0x09, -1, 0x03, 0x000e, 0x0246 },
-  { 0x02, 0x0a, -1, 0x03, 0x000e, 0x0446 },
-  { 0x02, 0x18, -1, 0x03, 0x000e, 0x0846 },
-  { 0x03, 0x05, -1, 0x03, 0x0012, 0x0046 },
-  { 0x03, 0x05, -1, 0x03, 0x0012, 0x0066 },
-  { 0x03, 0x06, -1, 0x03, 0x0012, 0x0086 },
-  { 0x03, 0x07, -1, 0x03, 0x0012, 0x00c6 },
-  { 0x03, 0x08, -1, 0x03, 0x0012, 0x0146 },
-  { 0x03, 0x09, -1, 0x03, 0x0012, 0x0246 },
-  { 0x03, 0x0a, -1, 0x03, 0x0012, 0x0446 },
-  { 0x03, 0x18, -1, 0x03, 0x0012, 0x0846 },
-  { 0x03, 0x05, -1, 0x03, 0x001a, 0x0046 },
-  { 0x03, 0x05, -1, 0x03, 0x001a, 0x0066 },
-  { 0x03, 0x06, -1, 0x03, 0x001a, 0x0086 },
-  { 0x03, 0x07, -1, 0x03, 0x001a, 0x00c6 },
-  { 0x03, 0x08, -1, 0x03, 0x001a, 0x0146 },
-  { 0x03, 0x09, -1, 0x03, 0x001a, 0x0246 },
-  { 0x03, 0x0a, -1, 0x03, 0x001a, 0x0446 },
-  { 0x03, 0x18, -1, 0x03, 0x001a, 0x0846 },
-  { 0x04, 0x05, -1, 0x03, 0x0022, 0x0046 },
-  { 0x04, 0x05, -1, 0x03, 0x0022, 0x0066 },
-  { 0x04, 0x06, -1, 0x03, 0x0022, 0x0086 },
-  { 0x04, 0x07, -1, 0x03, 0x0022, 0x00c6 },
-  { 0x04, 0x08, -1, 0x03, 0x0022, 0x0146 },
-  { 0x04, 0x09, -1, 0x03, 0x0022, 0x0246 },
-  { 0x04, 0x0a, -1, 0x03, 0x0022, 0x0446 },
-  { 0x04, 0x18, -1, 0x03, 0x0022, 0x0846 },
-  { 0x04, 0x05, -1, 0x03, 0x0032, 0x0046 },
-  { 0x04, 0x05, -1, 0x03, 0x0032, 0x0066 },
-  { 0x04, 0x06, -1, 0x03, 0x0032, 0x0086 },
-  { 0x04, 0x07, -1, 0x03, 0x0032, 0x00c6 },
-  { 0x04, 0x08, -1, 0x03, 0x0032, 0x0146 },
-  { 0x04, 0x09, -1, 0x03, 0x0032, 0x0246 },
-  { 0x04, 0x0a, -1, 0x03, 0x0032, 0x0446 },
-  { 0x04, 0x18, -1, 0x03, 0x0032, 0x0846 },
-  { 0x05, 0x05, -1, 0x03, 0x0042, 0x0046 },
-  { 0x05, 0x05, -1, 0x03, 0x0042, 0x0066 },
-  { 0x05, 0x06, -1, 0x03, 0x0042, 0x0086 },
-  { 0x05, 0x07, -1, 0x03, 0x0042, 0x00c6 },
-  { 0x05, 0x08, -1, 0x03, 0x0042, 0x0146 },
-  { 0x05, 0x09, -1, 0x03, 0x0042, 0x0246 },
-  { 0x05, 0x0a, -1, 0x03, 0x0042, 0x0446 },
-  { 0x05, 0x18, -1, 0x03, 0x0042, 0x0846 },
-  { 0x05, 0x05, -1, 0x03, 0x0062, 0x0046 },
-  { 0x05, 0x05, -1, 0x03, 0x0062, 0x0066 },
-  { 0x05, 0x06, -1, 0x03, 0x0062, 0x0086 },
-  { 0x05, 0x07, -1, 0x03, 0x0062, 0x00c6 },
-  { 0x05, 0x08, -1, 0x03, 0x0062, 0x0146 },
-  { 0x05, 0x09, -1, 0x03, 0x0062, 0x0246 },
-  { 0x05, 0x0a, -1, 0x03, 0x0062, 0x0446 },
-  { 0x05, 0x18, -1, 0x03, 0x0062, 0x0846 },
-  { 0x06, 0x01, -1, 0x03, 0x0082, 0x000a },
-  { 0x06, 0x01, -1, 0x03, 0x0082, 0x000c },
-  { 0x06, 0x02, -1, 0x03, 0x0082, 0x000e },
-  { 0x06, 0x02, -1, 0x03, 0x0082, 0x0012 },
-  { 0x06, 0x03, -1, 0x03, 0x0082, 0x0016 },
-  { 0x06, 0x03, -1, 0x03, 0x0082, 0x001e },
-  { 0x06, 0x04, -1, 0x03, 0x0082, 0x0026 },
-  { 0x06, 0x04, -1, 0x03, 0x0082, 0x0036 },
-  { 0x07, 0x01, -1, 0x03, 0x00c2, 0x000a },
-  { 0x07, 0x01, -1, 0x03, 0x00c2, 0x000c },
-  { 0x07, 0x02, -1, 0x03, 0x00c2, 0x000e },
-  { 0x07, 0x02, -1, 0x03, 0x00c2, 0x0012 },
-  { 0x07, 0x03, -1, 0x03, 0x00c2, 0x0016 },
-  { 0x07, 0x03, -1, 0x03, 0x00c2, 0x001e },
-  { 0x07, 0x04, -1, 0x03, 0x00c2, 0x0026 },
-  { 0x07, 0x04, -1, 0x03, 0x00c2, 0x0036 },
-  { 0x08, 0x01, -1, 0x03, 0x0142, 0x000a },
-  { 0x08, 0x01, -1, 0x03, 0x0142, 0x000c },
-  { 0x08, 0x02, -1, 0x03, 0x0142, 0x000e },
-  { 0x08, 0x02, -1, 0x03, 0x0142, 0x0012 },
-  { 0x08, 0x03, -1, 0x03, 0x0142, 0x0016 },
-  { 0x08, 0x03, -1, 0x03, 0x0142, 0x001e },
-  { 0x08, 0x04, -1, 0x03, 0x0142, 0x0026 },
-  { 0x08, 0x04, -1, 0x03, 0x0142, 0x0036 },
-  { 0x09, 0x01, -1, 0x03, 0x0242, 0x000a },
-  { 0x09, 0x01, -1, 0x03, 0x0242, 0x000c },
-  { 0x09, 0x02, -1, 0x03, 0x0242, 0x000e },
-  { 0x09, 0x02, -1, 0x03, 0x0242, 0x0012 },
-  { 0x09, 0x03, -1, 0x03, 0x0242, 0x0016 },
-  { 0x09, 0x03, -1, 0x03, 0x0242, 0x001e },
-  { 0x09, 0x04, -1, 0x03, 0x0242, 0x0026 },
-  { 0x09, 0x04, -1, 0x03, 0x0242, 0x0036 },
-  { 0x0a, 0x01, -1, 0x03, 0x0442, 0x000a },
-  { 0x0a, 0x01, -1, 0x03, 0x0442, 0x000c },
-  { 0x0a, 0x02, -1, 0x03, 0x0442, 0x000e },
-  { 0x0a, 0x02, -1, 0x03, 0x0442, 0x0012 },
-  { 0x0a, 0x03, -1, 0x03, 0x0442, 0x0016 },
-  { 0x0a, 0x03, -1, 0x03, 0x0442, 0x001e },
-  { 0x0a, 0x04, -1, 0x03, 0x0442, 0x0026 },
-  { 0x0a, 0x04, -1, 0x03, 0x0442, 0x0036 },
-  { 0x0c, 0x01, -1, 0x03, 0x0842, 0x000a },
-  { 0x0c, 0x01, -1, 0x03, 0x0842, 0x000c },
-  { 0x0c, 0x02, -1, 0x03, 0x0842, 0x000e },
-  { 0x0c, 0x02, -1, 0x03, 0x0842, 0x0012 },
-  { 0x0c, 0x03, -1, 0x03, 0x0842, 0x0016 },
-  { 0x0c, 0x03, -1, 0x03, 0x0842, 0x001e },
-  { 0x0c, 0x04, -1, 0x03, 0x0842, 0x0026 },
-  { 0x0c, 0x04, -1, 0x03, 0x0842, 0x0036 },
-  { 0x0e, 0x01, -1, 0x03, 0x1842, 0x000a },
-  { 0x0e, 0x01, -1, 0x03, 0x1842, 0x000c },
-  { 0x0e, 0x02, -1, 0x03, 0x1842, 0x000e },
-  { 0x0e, 0x02, -1, 0x03, 0x1842, 0x0012 },
-  { 0x0e, 0x03, -1, 0x03, 0x1842, 0x0016 },
-  { 0x0e, 0x03, -1, 0x03, 0x1842, 0x001e },
-  { 0x0e, 0x04, -1, 0x03, 0x1842, 0x0026 },
-  { 0x0e, 0x04, -1, 0x03, 0x1842, 0x0036 },
-  { 0x18, 0x01, -1, 0x03, 0x5842, 0x000a },
-  { 0x18, 0x01, -1, 0x03, 0x5842, 0x000c },
-  { 0x18, 0x02, -1, 0x03, 0x5842, 0x000e },
-  { 0x18, 0x02, -1, 0x03, 0x5842, 0x0012 },
-  { 0x18, 0x03, -1, 0x03, 0x5842, 0x0016 },
-  { 0x18, 0x03, -1, 0x03, 0x5842, 0x001e },
-  { 0x18, 0x04, -1, 0x03, 0x5842, 0x0026 },
-  { 0x18, 0x04, -1, 0x03, 0x5842, 0x0036 },
-  { 0x06, 0x05, -1, 0x03, 0x0082, 0x0046 },
-  { 0x06, 0x05, -1, 0x03, 0x0082, 0x0066 },
-  { 0x06, 0x06, -1, 0x03, 0x0082, 0x0086 },
-  { 0x06, 0x07, -1, 0x03, 0x0082, 0x00c6 },
-  { 0x06, 0x08, -1, 0x03, 0x0082, 0x0146 },
-  { 0x06, 0x09, -1, 0x03, 0x0082, 0x0246 },
-  { 0x06, 0x0a, -1, 0x03, 0x0082, 0x0446 },
-  { 0x06, 0x18, -1, 0x03, 0x0082, 0x0846 },
-  { 0x07, 0x05, -1, 0x03, 0x00c2, 0x0046 },
-  { 0x07, 0x05, -1, 0x03, 0x00c2, 0x0066 },
-  { 0x07, 0x06, -1, 0x03, 0x00c2, 0x0086 },
-  { 0x07, 0x07, -1, 0x03, 0x00c2, 0x00c6 },
-  { 0x07, 0x08, -1, 0x03, 0x00c2, 0x0146 },
-  { 0x07, 0x09, -1, 0x03, 0x00c2, 0x0246 },
-  { 0x07, 0x0a, -1, 0x03, 0x00c2, 0x0446 },
-  { 0x07, 0x18, -1, 0x03, 0x00c2, 0x0846 },
-  { 0x08, 0x05, -1, 0x03, 0x0142, 0x0046 },
-  { 0x08, 0x05, -1, 0x03, 0x0142, 0x0066 },
-  { 0x08, 0x06, -1, 0x03, 0x0142, 0x0086 },
-  { 0x08, 0x07, -1, 0x03, 0x0142, 0x00c6 },
-  { 0x08, 0x08, -1, 0x03, 0x0142, 0x0146 },
-  { 0x08, 0x09, -1, 0x03, 0x0142, 0x0246 },
-  { 0x08, 0x0a, -1, 0x03, 0x0142, 0x0446 },
-  { 0x08, 0x18, -1, 0x03, 0x0142, 0x0846 },
-  { 0x09, 0x05, -1, 0x03, 0x0242, 0x0046 },
-  { 0x09, 0x05, -1, 0x03, 0x0242, 0x0066 },
-  { 0x09, 0x06, -1, 0x03, 0x0242, 0x0086 },
-  { 0x09, 0x07, -1, 0x03, 0x0242, 0x00c6 },
-  { 0x09, 0x08, -1, 0x03, 0x0242, 0x0146 },
-  { 0x09, 0x09, -1, 0x03, 0x0242, 0x0246 },
-  { 0x09, 0x0a, -1, 0x03, 0x0242, 0x0446 },
-  { 0x09, 0x18, -1, 0x03, 0x0242, 0x0846 },
-  { 0x0a, 0x05, -1, 0x03, 0x0442, 0x0046 },
-  { 0x0a, 0x05, -1, 0x03, 0x0442, 0x0066 },
-  { 0x0a, 0x06, -1, 0x03, 0x0442, 0x0086 },
-  { 0x0a, 0x07, -1, 0x03, 0x0442, 0x00c6 },
-  { 0x0a, 0x08, -1, 0x03, 0x0442, 0x0146 },
-  { 0x0a, 0x09, -1, 0x03, 0x0442, 0x0246 },
-  { 0x0a, 0x0a, -1, 0x03, 0x0442, 0x0446 },
-  { 0x0a, 0x18, -1, 0x03, 0x0442, 0x0846 },
-  { 0x0c, 0x05, -1, 0x03, 0x0842, 0x0046 },
-  { 0x0c, 0x05, -1, 0x03, 0x0842, 0x0066 },
-  { 0x0c, 0x06, -1, 0x03, 0x0842, 0x0086 },
-  { 0x0c, 0x07, -1, 0x03, 0x0842, 0x00c6 },
-  { 0x0c, 0x08, -1, 0x03, 0x0842, 0x0146 },
-  { 0x0c, 0x09, -1, 0x03, 0x0842, 0x0246 },
-  { 0x0c, 0x0a, -1, 0x03, 0x0842, 0x0446 },
-  { 0x0c, 0x18, -1, 0x03, 0x0842, 0x0846 },
-  { 0x0e, 0x05, -1, 0x03, 0x1842, 0x0046 },
-  { 0x0e, 0x05, -1, 0x03, 0x1842, 0x0066 },
-  { 0x0e, 0x06, -1, 0x03, 0x1842, 0x0086 },
-  { 0x0e, 0x07, -1, 0x03, 0x1842, 0x00c6 },
-  { 0x0e, 0x08, -1, 0x03, 0x1842, 0x0146 },
-  { 0x0e, 0x09, -1, 0x03, 0x1842, 0x0246 },
-  { 0x0e, 0x0a, -1, 0x03, 0x1842, 0x0446 },
-  { 0x0e, 0x18, -1, 0x03, 0x1842, 0x0846 },
-  { 0x18, 0x05, -1, 0x03, 0x5842, 0x0046 },
-  { 0x18, 0x05, -1, 0x03, 0x5842, 0x0066 },
-  { 0x18, 0x06, -1, 0x03, 0x5842, 0x0086 },
-  { 0x18, 0x07, -1, 0x03, 0x5842, 0x00c6 },
-  { 0x18, 0x08, -1, 0x03, 0x5842, 0x0146 },
-  { 0x18, 0x09, -1, 0x03, 0x5842, 0x0246 },
-  { 0x18, 0x0a, -1, 0x03, 0x5842, 0x0446 },
-  { 0x18, 0x18, -1, 0x03, 0x5842, 0x0846 },
-};
-
-#endif  /* BROTLI_DEC_PREFIX_H_ */
diff --git a/src/duckdb/third_party/brotli/dec/state.cpp b/src/duckdb/third_party/brotli/dec/state.cpp
deleted file mode 100644
index 08b8dea3d..000000000
--- a/src/duckdb/third_party/brotli/dec/state.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "state.h"
-
-#include <stdlib.h>  /* free, malloc */
-
-#include <brotli/types.h>
-
-#include "../common/dictionary.h"
-#include "huffman.h"
-
-using namespace duckdb_brotli;
-
-BROTLI_BOOL duckdb_brotli::BrotliDecoderStateInit(BrotliDecoderState* s,
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
-  if (!alloc_func) {
-    s->alloc_func = BrotliDefaultAllocFunc;
-    s->free_func = BrotliDefaultFreeFunc;
-    s->memory_manager_opaque = 0;
-  } else {
-    s->alloc_func = alloc_func;
-    s->free_func = free_func;
-    s->memory_manager_opaque = opaque;
-  }
-
-  s->error_code = 0; /* BROTLI_DECODER_NO_ERROR */
-
-  BrotliInitBitReader(&s->br);
-  s->state = BROTLI_STATE_UNINITED;
-  s->large_window = 0;
-  s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-  s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE;
-  s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
-  s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
-
-  s->buffer_length = 0;
-  s->loop_counter = 0;
-  s->pos = 0;
-  s->rb_roundtrips = 0;
-  s->partial_pos_out = 0;
-  s->used_input = 0;
-
-  s->block_type_trees = NULL;
-  s->block_len_trees = NULL;
-  s->ringbuffer = NULL;
-  s->ringbuffer_size = 0;
-  s->new_ringbuffer_size = 0;
-  s->ringbuffer_mask = 0;
-
-  s->context_map = NULL;
-  s->context_modes = NULL;
-  s->dist_context_map = NULL;
-  s->context_map_slice = NULL;
-  s->dist_context_map_slice = NULL;
-
-  s->literal_hgroup.codes = NULL;
-  s->literal_hgroup.htrees = NULL;
-  s->insert_copy_hgroup.codes = NULL;
-  s->insert_copy_hgroup.htrees = NULL;
-  s->distance_hgroup.codes = NULL;
-  s->distance_hgroup.htrees = NULL;
-
-  s->is_last_metablock = 0;
-  s->is_uncompressed = 0;
-  s->is_metadata = 0;
-  s->should_wrap_ringbuffer = 0;
-  s->canny_ringbuffer_allocation = 1;
-
-  s->window_bits = 0;
-  s->max_distance = 0;
-  s->dist_rb[0] = 16;
-  s->dist_rb[1] = 15;
-  s->dist_rb[2] = 11;
-  s->dist_rb[3] = 4;
-  s->dist_rb_idx = 0;
-  s->block_type_trees = NULL;
-  s->block_len_trees = NULL;
-
-  s->mtf_upper_bound = 63;
-
-  s->compound_dictionary = NULL;
-  s->dictionary =
-      BrotliSharedDictionaryCreateInstance(alloc_func, free_func, opaque);
-  if (!s->dictionary) return BROTLI_FALSE;
-
-  s->metadata_start_func = NULL;
-  s->metadata_chunk_func = NULL;
-  s->metadata_callback_opaque = 0;
-
-  return BROTLI_TRUE;
-}
-
-void duckdb_brotli::BrotliDecoderStateMetablockBegin(BrotliDecoderState* s) {
-  s->meta_block_remaining_len = 0;
-  s->block_length[0] = BROTLI_BLOCK_SIZE_CAP;
-  s->block_length[1] = BROTLI_BLOCK_SIZE_CAP;
-  s->block_length[2] = BROTLI_BLOCK_SIZE_CAP;
-  s->num_block_types[0] = 1;
-  s->num_block_types[1] = 1;
-  s->num_block_types[2] = 1;
-  s->block_type_rb[0] = 1;
-  s->block_type_rb[1] = 0;
-  s->block_type_rb[2] = 1;
-  s->block_type_rb[3] = 0;
-  s->block_type_rb[4] = 1;
-  s->block_type_rb[5] = 0;
-  s->context_map = NULL;
-  s->context_modes = NULL;
-  s->dist_context_map = NULL;
-  s->context_map_slice = NULL;
-  s->literal_htree = NULL;
-  s->dist_context_map_slice = NULL;
-  s->dist_htree_index = 0;
-  s->context_lookup = NULL;
-  s->literal_hgroup.codes = NULL;
-  s->literal_hgroup.htrees = NULL;
-  s->insert_copy_hgroup.codes = NULL;
-  s->insert_copy_hgroup.htrees = NULL;
-  s->distance_hgroup.codes = NULL;
-  s->distance_hgroup.htrees = NULL;
-}
-
-void duckdb_brotli::BrotliDecoderStateCleanupAfterMetablock(BrotliDecoderState* s) {
-  BROTLI_DECODER_FREE(s, s->context_modes);
-  BROTLI_DECODER_FREE(s, s->context_map);
-  BROTLI_DECODER_FREE(s, s->dist_context_map);
-  BROTLI_DECODER_FREE(s, s->literal_hgroup.htrees);
-  BROTLI_DECODER_FREE(s, s->insert_copy_hgroup.htrees);
-  BROTLI_DECODER_FREE(s, s->distance_hgroup.htrees);
-}
-
-#ifdef BROTLI_REPORTING
-/* When BROTLI_REPORTING is defined extra reporting module have to be linked. */
-void BrotliDecoderOnFinish(const BrotliDecoderState* s);
-#define BROTLI_DECODER_ON_FINISH(s) BrotliDecoderOnFinish(s);
-#else
-#if !defined(BROTLI_DECODER_ON_FINISH)
-#define BROTLI_DECODER_ON_FINISH(s) (void)(s);
-#endif
-#endif
-
-void duckdb_brotli::BrotliDecoderStateCleanup(BrotliDecoderState* s) {
-  BrotliDecoderStateCleanupAfterMetablock(s);
-
-  BROTLI_DECODER_ON_FINISH(s);
-
-  BROTLI_DECODER_FREE(s, s->compound_dictionary);
-  BrotliSharedDictionaryDestroyInstance(s->dictionary);
-  s->dictionary = NULL;
-  BROTLI_DECODER_FREE(s, s->ringbuffer);
-  BROTLI_DECODER_FREE(s, s->block_type_trees);
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliDecoderHuffmanTreeGroupInit(BrotliDecoderState* s,
-    HuffmanTreeGroup* group, brotli_reg_t alphabet_size_max,
-    brotli_reg_t alphabet_size_limit, brotli_reg_t ntrees) {
-  /* 376 = 256 (1-st level table) + 4 + 7 + 15 + 31 + 63 (2-nd level mix-tables)
-     This number is discovered "unlimited" "enough" calculator; it is actually
-     a wee bigger than required in several cases (especially for alphabets with
-     less than 16 symbols). */
-  const size_t max_table_size = alphabet_size_limit + 376;
-  const size_t code_size = sizeof(HuffmanCode) * ntrees * max_table_size;
-  const size_t htree_size = sizeof(HuffmanCode*) * ntrees;
-  /* Pointer alignment is, hopefully, wider than sizeof(HuffmanCode). */
-  HuffmanCode** p = (HuffmanCode**)BROTLI_DECODER_ALLOC(s,
-      code_size + htree_size);
-  group->alphabet_size_max = (uint16_t)alphabet_size_max;
-  group->alphabet_size_limit = (uint16_t)alphabet_size_limit;
-  group->num_htrees = (uint16_t)ntrees;
-  group->htrees = p;
-  group->codes = (HuffmanCode*)(&p[ntrees]);
-  return !!p;
-}
-
diff --git a/src/duckdb/third_party/brotli/dec/state.h b/src/duckdb/third_party/brotli/dec/state.h
deleted file mode 100644
index fcfe4ab41..000000000
--- a/src/duckdb/third_party/brotli/dec/state.h
+++ /dev/null
@@ -1,386 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Brotli state for partial streaming decoding. */
-
-#ifndef BROTLI_DEC_STATE_H_
-#define BROTLI_DEC_STATE_H_
-
-#include <brotli/decode.h>
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "../common/transform.h"
-#include "bit_reader.h"
-#include "huffman.h"
-
-namespace duckdb_brotli {
-
-/* Graphviz diagram that describes state transitions:
-
-digraph States {
-  graph [compound=true]
-  concentrate=true
-  node [shape="box"]
-
-  UNINITED -> {LARGE_WINDOW_BITS -> INITIALIZE}
-  subgraph cluster_metablock_workflow {
-    style="rounded"
-    label=< <B>METABLOCK CYCLE</B> >
-    METABLOCK_BEGIN -> METABLOCK_HEADER
-    METABLOCK_HEADER:sw -> METADATA
-    METABLOCK_HEADER:s -> UNCOMPRESSED
-    METABLOCK_HEADER:se -> METABLOCK_DONE:ne
-    METADATA:s -> METABLOCK_DONE:w
-    UNCOMPRESSED:s -> METABLOCK_DONE:n
-    METABLOCK_DONE:e -> METABLOCK_BEGIN:e [constraint="false"]
-  }
-  INITIALIZE -> METABLOCK_BEGIN
-  METABLOCK_DONE -> DONE
-
-  subgraph cluster_compressed_metablock {
-    style="rounded"
-    label=< <B>COMPRESSED METABLOCK</B> >
-
-    subgraph cluster_command {
-      style="rounded"
-      label=< <B>HOT LOOP</B> >
-
-      _METABLOCK_DONE_PORT_ [shape=point style=invis]
-
-      {
-        // Set different shape for nodes returning from "compressed metablock".
-        node [shape=invhouse]; CMD_INNER CMD_POST_DECODE_LITERALS;
-        CMD_POST_WRAP_COPY; CMD_INNER_WRITE; CMD_POST_WRITE_1;
-      }
-
-      CMD_BEGIN -> CMD_INNER -> CMD_POST_DECODE_LITERALS -> CMD_POST_WRAP_COPY
-
-      // IO ("write") nodes are not in the hot loop!
-      CMD_INNER_WRITE [style=dashed]
-      CMD_INNER -> CMD_INNER_WRITE
-      CMD_POST_WRITE_1 [style=dashed]
-      CMD_POST_DECODE_LITERALS -> CMD_POST_WRITE_1
-      CMD_POST_WRITE_2 [style=dashed]
-      CMD_POST_WRAP_COPY -> CMD_POST_WRITE_2
-
-      CMD_POST_WRITE_1 -> CMD_BEGIN:s [constraint="false"]
-      CMD_INNER_WRITE -> {CMD_INNER CMD_POST_DECODE_LITERALS}
-          [constraint="false"]
-      CMD_BEGIN:ne -> CMD_POST_DECODE_LITERALS [constraint="false"]
-      CMD_POST_WRAP_COPY -> CMD_BEGIN [constraint="false"]
-      CMD_POST_DECODE_LITERALS -> CMD_BEGIN:ne [constraint="false"]
-      CMD_POST_WRITE_2 -> CMD_POST_WRAP_COPY [constraint="false"]
-      {rank=same; CMD_BEGIN; CMD_INNER; CMD_POST_DECODE_LITERALS;
-          CMD_POST_WRAP_COPY}
-      {rank=same; CMD_INNER_WRITE; CMD_POST_WRITE_1; CMD_POST_WRITE_2}
-
-      {CMD_INNER CMD_POST_DECODE_LITERALS CMD_POST_WRAP_COPY} ->
-          _METABLOCK_DONE_PORT_ [style=invis]
-      {CMD_INNER_WRITE CMD_POST_WRITE_1} -> _METABLOCK_DONE_PORT_
-          [constraint="false" style=invis]
-    }
-
-    BEFORE_COMPRESSED_METABLOCK_HEADER:s -> HUFFMAN_CODE_0:n
-    HUFFMAN_CODE_0 -> HUFFMAN_CODE_1 -> HUFFMAN_CODE_2 -> HUFFMAN_CODE_3
-    HUFFMAN_CODE_0 -> METABLOCK_HEADER_2 -> CONTEXT_MODES -> CONTEXT_MAP_1
-    CONTEXT_MAP_1 -> CONTEXT_MAP_2 -> TREE_GROUP
-    TREE_GROUP -> BEFORE_COMPRESSED_METABLOCK_BODY:e
-    BEFORE_COMPRESSED_METABLOCK_BODY:s -> CMD_BEGIN:n
-
-    HUFFMAN_CODE_3:e -> HUFFMAN_CODE_0:ne [constraint="false"]
-    {rank=same; HUFFMAN_CODE_0; HUFFMAN_CODE_1; HUFFMAN_CODE_2; HUFFMAN_CODE_3}
-    {rank=same; METABLOCK_HEADER_2; CONTEXT_MODES; CONTEXT_MAP_1; CONTEXT_MAP_2;
-        TREE_GROUP}
-  }
-  METABLOCK_HEADER:e -> BEFORE_COMPRESSED_METABLOCK_HEADER:n
-
-  _METABLOCK_DONE_PORT_ -> METABLOCK_DONE:se
-      [constraint="false" ltail=cluster_command]
-
-  UNINITED [shape=Mdiamond];
-  DONE [shape=Msquare];
-}
-
-
- */
-
-typedef enum {
-	BROTLI_STATE_UNINITED,
-	BROTLI_STATE_LARGE_WINDOW_BITS,
-	BROTLI_STATE_INITIALIZE,
-	BROTLI_STATE_METABLOCK_BEGIN,
-	BROTLI_STATE_METABLOCK_HEADER,
-	BROTLI_STATE_METABLOCK_HEADER_2,
-	BROTLI_STATE_CONTEXT_MODES,
-	BROTLI_STATE_COMMAND_BEGIN,
-	BROTLI_STATE_COMMAND_INNER,
-	BROTLI_STATE_COMMAND_POST_DECODE_LITERALS,
-	BROTLI_STATE_COMMAND_POST_WRAP_COPY,
-	BROTLI_STATE_UNCOMPRESSED,
-	BROTLI_STATE_METADATA,
-	BROTLI_STATE_COMMAND_INNER_WRITE,
-	BROTLI_STATE_METABLOCK_DONE,
-	BROTLI_STATE_COMMAND_POST_WRITE_1,
-	BROTLI_STATE_COMMAND_POST_WRITE_2,
-	BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_HEADER,
-	BROTLI_STATE_HUFFMAN_CODE_0,
-	BROTLI_STATE_HUFFMAN_CODE_1,
-	BROTLI_STATE_HUFFMAN_CODE_2,
-	BROTLI_STATE_HUFFMAN_CODE_3,
-	BROTLI_STATE_CONTEXT_MAP_1,
-	BROTLI_STATE_CONTEXT_MAP_2,
-	BROTLI_STATE_TREE_GROUP,
-	BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_BODY,
-	BROTLI_STATE_DONE
-} BrotliRunningState;
-
-typedef enum {
-	BROTLI_STATE_METABLOCK_HEADER_NONE,
-	BROTLI_STATE_METABLOCK_HEADER_EMPTY,
-	BROTLI_STATE_METABLOCK_HEADER_NIBBLES,
-	BROTLI_STATE_METABLOCK_HEADER_SIZE,
-	BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED,
-	BROTLI_STATE_METABLOCK_HEADER_RESERVED,
-	BROTLI_STATE_METABLOCK_HEADER_BYTES,
-	BROTLI_STATE_METABLOCK_HEADER_METADATA
-} BrotliRunningMetablockHeaderState;
-
-typedef enum { BROTLI_STATE_UNCOMPRESSED_NONE, BROTLI_STATE_UNCOMPRESSED_WRITE } BrotliRunningUncompressedState;
-
-typedef enum { BROTLI_STATE_TREE_GROUP_NONE, BROTLI_STATE_TREE_GROUP_LOOP } BrotliRunningTreeGroupState;
-
-typedef enum {
-	BROTLI_STATE_CONTEXT_MAP_NONE,
-	BROTLI_STATE_CONTEXT_MAP_READ_PREFIX,
-	BROTLI_STATE_CONTEXT_MAP_HUFFMAN,
-	BROTLI_STATE_CONTEXT_MAP_DECODE,
-	BROTLI_STATE_CONTEXT_MAP_TRANSFORM
-} BrotliRunningContextMapState;
-
-typedef enum {
-	BROTLI_STATE_HUFFMAN_NONE,
-	BROTLI_STATE_HUFFMAN_SIMPLE_SIZE,
-	BROTLI_STATE_HUFFMAN_SIMPLE_READ,
-	BROTLI_STATE_HUFFMAN_SIMPLE_BUILD,
-	BROTLI_STATE_HUFFMAN_COMPLEX,
-	BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS
-} BrotliRunningHuffmanState;
-
-typedef enum {
-	BROTLI_STATE_DECODE_UINT8_NONE,
-	BROTLI_STATE_DECODE_UINT8_SHORT,
-	BROTLI_STATE_DECODE_UINT8_LONG
-} BrotliRunningDecodeUint8State;
-
-typedef enum {
-	BROTLI_STATE_READ_BLOCK_LENGTH_NONE,
-	BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX
-} BrotliRunningReadBlockLengthState;
-
-/* BrotliDecoderState addon, used for Compound Dictionary functionality. */
-typedef struct BrotliDecoderCompoundDictionary {
-	int num_chunks;
-	int total_size;
-	int br_index;
-	int br_offset;
-	int br_length;
-	int br_copied;
-	const uint8_t *chunks[16];
-	int chunk_offsets[16];
-	int block_bits;
-	uint8_t block_map[256];
-} BrotliDecoderCompoundDictionary;
-
-typedef struct BrotliMetablockHeaderArena {
-	BrotliRunningTreeGroupState substate_tree_group;
-	BrotliRunningContextMapState substate_context_map;
-	BrotliRunningHuffmanState substate_huffman;
-
-	brotli_reg_t sub_loop_counter;
-
-	brotli_reg_t repeat_code_len;
-	brotli_reg_t prev_code_len;
-
-	/* For ReadHuffmanCode. */
-	brotli_reg_t symbol;
-	brotli_reg_t repeat;
-	brotli_reg_t space;
-
-	/* Huffman table for "histograms". */
-	HuffmanCode table[32];
-	/* List of heads of symbol chains. */
-	uint16_t *symbol_lists;
-	/* Storage from symbol_lists. */
-	uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + BROTLI_NUM_COMMAND_SYMBOLS];
-	/* Tails of symbol chains. */
-	int next_symbol[32];
-	uint8_t code_length_code_lengths[BROTLI_CODE_LENGTH_CODES];
-	/* Population counts for the code lengths. */
-	uint16_t code_length_histo[16];
-	/* TODO(eustas): +2 bytes padding */
-
-	/* For HuffmanTreeGroupDecode. */
-	int htree_index;
-	HuffmanCode *next;
-
-	/* For DecodeContextMap. */
-	brotli_reg_t context_index;
-	brotli_reg_t max_run_length_prefix;
-	brotli_reg_t code;
-	HuffmanCode context_map_table[BROTLI_HUFFMAN_MAX_SIZE_272];
-} BrotliMetablockHeaderArena;
-
-typedef struct BrotliMetablockBodyArena {
-	uint8_t dist_extra_bits[544];
-	brotli_reg_t dist_offset[544];
-} BrotliMetablockBodyArena;
-
-struct BrotliDecoderStateStruct {
-	BrotliRunningState state;
-
-	/* This counter is reused for several disjoint loops. */
-	int loop_counter;
-
-	BrotliBitReader br;
-
-	brotli_alloc_func alloc_func;
-	brotli_free_func free_func;
-	void *memory_manager_opaque;
-
-	/* Temporary storage for remaining input. Brotli stream format is designed in
-	   a way, that 64 bits are enough to make progress in decoding. */
-	union {
-		uint64_t u64;
-		uint8_t u8[8];
-	} buffer;
-	brotli_reg_t buffer_length;
-
-	int pos;
-	int max_backward_distance;
-	int max_distance;
-	int ringbuffer_size;
-	int ringbuffer_mask;
-	int dist_rb_idx;
-	int dist_rb[4];
-	int error_code;
-	int meta_block_remaining_len;
-
-	uint8_t *ringbuffer;
-	uint8_t *ringbuffer_end;
-	HuffmanCode *htree_command;
-	const uint8_t *context_lookup;
-	uint8_t *context_map_slice;
-	uint8_t *dist_context_map_slice;
-
-	/* This ring buffer holds a few past copy distances that will be used by
-	   some special distance codes. */
-	HuffmanTreeGroup literal_hgroup;
-	HuffmanTreeGroup insert_copy_hgroup;
-	HuffmanTreeGroup distance_hgroup;
-	HuffmanCode *block_type_trees;
-	HuffmanCode *block_len_trees;
-	/* This is true if the literal context map histogram type always matches the
-	   block type. It is then not needed to keep the context (faster decoding). */
-	int trivial_literal_context;
-	/* Distance context is actual after command is decoded and before distance is
-	   computed. After distance computation it is used as a temporary variable. */
-	int distance_context;
-	brotli_reg_t block_length[3];
-	brotli_reg_t block_length_index;
-	brotli_reg_t num_block_types[3];
-	brotli_reg_t block_type_rb[6];
-	brotli_reg_t distance_postfix_bits;
-	brotli_reg_t num_direct_distance_codes;
-	brotli_reg_t num_dist_htrees;
-	uint8_t *dist_context_map;
-	HuffmanCode *literal_htree;
-
-	/* For partial write operations. */
-	size_t rb_roundtrips;   /* how many times we went around the ring-buffer */
-	size_t partial_pos_out; /* how much output to the user in total */
-
-	/* For InverseMoveToFrontTransform. */
-	brotli_reg_t mtf_upper_bound;
-	uint32_t mtf[64 + 1];
-
-	int copy_length;
-	int distance_code;
-
-	uint8_t dist_htree_index;
-	/* TODO(eustas): +3 bytes padding */
-
-	/* Less used attributes are at the end of this struct. */
-
-	brotli_decoder_metadata_start_func metadata_start_func;
-	brotli_decoder_metadata_chunk_func metadata_chunk_func;
-	void *metadata_callback_opaque;
-
-	/* For reporting. */
-	uint64_t used_input; /* how many bytes of input are consumed */
-
-	/* States inside function calls. */
-	BrotliRunningMetablockHeaderState substate_metablock_header;
-	BrotliRunningUncompressedState substate_uncompressed;
-	BrotliRunningDecodeUint8State substate_decode_uint8;
-	BrotliRunningReadBlockLengthState substate_read_block_length;
-
-	int new_ringbuffer_size;
-	/* TODO(eustas): +4 bytes padding */
-
-	unsigned int is_last_metablock : 1;
-	unsigned int is_uncompressed : 1;
-	unsigned int is_metadata : 1;
-	unsigned int should_wrap_ringbuffer : 1;
-	unsigned int canny_ringbuffer_allocation : 1;
-	unsigned int large_window : 1;
-	unsigned int window_bits : 6;
-	unsigned int size_nibbles : 8;
-	/* TODO(eustas): +12 bits padding */
-
-	brotli_reg_t num_literal_htrees;
-	uint8_t *context_map;
-	uint8_t *context_modes;
-
-	BrotliSharedDictionary *dictionary;
-	BrotliDecoderCompoundDictionary *compound_dictionary;
-
-	uint32_t trivial_literal_contexts[8]; /* 256 bits */
-
-	union {
-		BrotliMetablockHeaderArena header;
-		BrotliMetablockBodyArena body;
-	} arena;
-};
-
-typedef struct BrotliDecoderStateStruct BrotliDecoderStateInternal;
-#define BrotliDecoderState BrotliDecoderStateInternal
-
-BROTLI_INTERNAL BROTLI_BOOL BrotliDecoderStateInit(BrotliDecoderState *s, brotli_alloc_func alloc_func,
-                                                   brotli_free_func free_func, void *opaque);
-BROTLI_INTERNAL void BrotliDecoderStateCleanup(BrotliDecoderState *s);
-BROTLI_INTERNAL void BrotliDecoderStateMetablockBegin(BrotliDecoderState *s);
-BROTLI_INTERNAL void BrotliDecoderStateCleanupAfterMetablock(BrotliDecoderState *s);
-BROTLI_INTERNAL BROTLI_BOOL BrotliDecoderHuffmanTreeGroupInit(BrotliDecoderState *s, HuffmanTreeGroup *group,
-                                                              brotli_reg_t alphabet_size_max,
-                                                              brotli_reg_t alphabet_size_limit, brotli_reg_t ntrees);
-
-#define BROTLI_DECODER_ALLOC(S, L) S->alloc_func(S->memory_manager_opaque, L)
-
-#define BROTLI_DECODER_FREE(S, X) {          \
-  S->free_func(S->memory_manager_opaque, X); \
-  X = NULL;                                  \
-}
-
-/* Literal/Command/Distance block size maximum; same as maximum metablock size;
-   used as block size when there is no block switching. */
-#define BROTLI_BLOCK_SIZE_CAP (1U << 24)
-
-}
-#endif  /* BROTLI_DEC_STATE_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/backward_references.cpp b/src/duckdb/third_party/brotli/enc/backward_references.cpp
deleted file mode 100644
index 5f338adc1..000000000
--- a/src/duckdb/third_party/brotli/enc/backward_references.cpp
+++ /dev/null
@@ -1,3775 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function to find backward reference copies. */
-
-#include "backward_references.h"
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "command.h"
-#include "compound_dictionary.h"
-#include "dictionary_hash.h"
-#include "encoder_dict.h"
-#include "memory.h"
-#include "quality.h"
-
-using namespace duckdb_brotli;
-
-static BROTLI_INLINE size_t ComputeDistanceCode(size_t distance,
-                                                size_t max_distance,
-                                                const int* dist_cache) {
-  if (distance <= max_distance) {
-    size_t distance_plus_3 = distance + 3;
-    size_t offset0 = distance_plus_3 - (size_t)dist_cache[0];
-    size_t offset1 = distance_plus_3 - (size_t)dist_cache[1];
-    if (distance == (size_t)dist_cache[0]) {
-      return 0;
-    } else if (distance == (size_t)dist_cache[1]) {
-      return 1;
-    } else if (offset0 < 7) {
-      return (0x9750468 >> (4 * offset0)) & 0xF;
-    } else if (offset1 < 7) {
-      return (0xFDB1ACE >> (4 * offset1)) & 0xF;
-    } else if (distance == (size_t)dist_cache[2]) {
-      return 2;
-    } else if (distance == (size_t)dist_cache[3]) {
-      return 3;
-    }
-  }
-  return distance + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
-}
-
-#define EXPAND_CAT(a, b) CAT(a, b)
-#define CAT(a, b) a ## b
-#define FN(X) EXPAND_CAT(X, HASHER())
-#define EXPORT_FN(X) EXPAND_CAT(X, EXPAND_CAT(PREFIX(), HASHER()))
-
-#define PREFIX() N
-#define ENABLE_COMPOUND_DICTIONARY 0
-
-#define HASHER() H2
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H3
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H4
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H5
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H6
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H40
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H41
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H42
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H54
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H35
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H55
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#define HASHER() H65
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#undef ENABLE_COMPOUND_DICTIONARY
-#undef PREFIX
-#define PREFIX() D
-#define ENABLE_COMPOUND_DICTIONARY 1
-
-#define HASHER() H5
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-#define HASHER() H6
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-#define HASHER() H40
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-#define HASHER() H41
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-#define HASHER() H42
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-#define HASHER() H55
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-#define HASHER() H65
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: EXPORT_FN, FN */
-
-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  HASHER()* privat = &hasher->privat.FN(_);
-  /* Set maximum distance, see section 9.1. of the spec. */
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t position_offset = params->stream_offset;
-
-  const Command* const orig_commands = commands;
-  size_t insert_length = *last_insert_len;
-  const size_t pos_end = position + num_bytes;
-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
-
-  /* For speed up heuristics for random data. */
-  const size_t random_heuristics_window_size =
-      LiteralSpreeLengthForSparseSearch(params);
-  size_t apply_random_heuristics = position + random_heuristics_window_size;
-  const size_t gap = params->dictionary.compound.total_size;
-
-  /* Minimum score to accept a backward reference. */
-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
-
-  FN(PrepareDistanceCache)(privat, dist_cache);
-
-  while (position + FN(HashTypeLength)() < pos_end) {
-    size_t max_length = pos_end - position;
-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        position + position_offset, max_backward_limit);
-    HasherSearchResult sr;
-    int dict_id = 0;
-    uint8_t p1 = 0;
-    uint8_t p2 = 0;
-    if (params->dictionary.contextual.context_based) {
-      p1 = position >= 1 ?
-          ringbuffer[(size_t)(position - 1) & ringbuffer_mask] : 0;
-      p2 = position >= 2 ?
-          ringbuffer[(size_t)(position - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    sr.len = 0;
-    sr.len_code_delta = 0;
-    sr.distance = 0;
-    sr.score = kMinScore;
-    FN(FindLongestMatch)(privat, params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
-    if (ENABLE_COMPOUND_DICTIONARY) {
-      LookupCompoundDictionaryMatch(&params->dictionary.compound, ringbuffer,
-          ringbuffer_mask, dist_cache, position, max_length,
-          dictionary_start, params->dist.max_distance, &sr);
-    }
-    if (sr.score > kMinScore) {
-      /* Found a match. Let's look for something even better ahead. */
-      int delayed_backward_references_in_row = 0;
-      --max_length;
-      for (;; --max_length) {
-        const score_t cost_diff_lazy = 175;
-        HasherSearchResult sr2;
-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_code_delta = 0;
-        sr2.distance = 0;
-        sr2.score = kMinScore;
-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        dictionary_start = BROTLI_MIN(size_t,
-            position + 1 + position_offset, max_backward_limit);
-        if (params->dictionary.contextual.context_based) {
-          p2 = p1;
-          p1 = ringbuffer[position & ringbuffer_mask];
-          dict_id = params->dictionary.contextual.context_map[
-              BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-        }
-        FN(FindLongestMatch)(privat,
-            params->dictionary.contextual.dict[dict_id],
-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, dictionary_start + gap, params->dist.max_distance,
-            &sr2);
-        if (ENABLE_COMPOUND_DICTIONARY) {
-          LookupCompoundDictionaryMatch(
-              &params->dictionary.compound, ringbuffer,
-              ringbuffer_mask, dist_cache, position + 1, max_length,
-              dictionary_start, params->dist.max_distance, &sr2);
-        }
-        if (sr2.score >= sr.score + cost_diff_lazy) {
-          /* Ok, let's just write one byte for now and start a match from the
-             next byte. */
-          ++position;
-          ++insert_length;
-          sr = sr2;
-          if (++delayed_backward_references_in_row < 4 &&
-              position + FN(HashTypeLength)() < pos_end) {
-            continue;
-          }
-        }
-        break;
-      }
-      apply_random_heuristics =
-          position + 2 * sr.len + random_heuristics_window_size;
-      dictionary_start = BROTLI_MIN(size_t,
-          position + position_offset, max_backward_limit);
-      {
-        /* The first 16 codes are special short-codes,
-           and the minimum offset is 1. */
-        size_t distance_code = ComputeDistanceCode(
-            sr.distance, dictionary_start + gap, dist_cache);
-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
-          dist_cache[3] = dist_cache[2];
-          dist_cache[2] = dist_cache[1];
-          dist_cache[1] = dist_cache[0];
-          dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(privat, dist_cache);
-        }
-        InitCommand(commands++, &params->dist, insert_length,
-            sr.len, sr.len_code_delta, distance_code);
-      }
-      *num_literals += insert_length;
-      insert_length = 0;
-      /* Put the hash keys into the table, if there are enough bytes left.
-         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them.
-         Avoid hash poisoning with RLE data. */
-      {
-        size_t range_start = position + 2;
-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
-        if (sr.distance < (sr.len >> 2)) {
-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
-              range_start, position + sr.len - (sr.distance << 2)));
-        }
-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
-                       range_end);
-      }
-      position += sr.len;
-    } else {
-      ++insert_length;
-      ++position;
-      /* If we have not seen matches for a long time, we can skip some
-         match lookups. Unsuccessful match lookups are very very expensive
-         and this kind of a heuristic speeds up compression quite
-         a lot. */
-      if (position > apply_random_heuristics) {
-        /* Going through uncompressible data, jump. */
-        if (position >
-            apply_random_heuristics + 4 * random_heuristics_window_size) {
-          /* It is quite a long time since we saw a copy, so we assume
-             that this data is not compressible, and store hashes less
-             often. Hashes of non compressible data are less likely to
-             turn out to be useful in the future, too, so we store less of
-             them to not to flood out the hash table of good compressible
-             data. */
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
-          for (; position < pos_jump; position += 4) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 4;
-          }
-        } else {
-          const size_t kMargin =
-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
-          size_t pos_jump =
-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
-          for (; position < pos_jump; position += 2) {
-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
-            insert_length += 2;
-          }
-        }
-      }
-    }
-  }
-  insert_length += pos_end - position;
-  *last_insert_len = insert_length;
-  *num_commands += (size_t)(commands - orig_commands);
-}
-#undef HASHER
-
-#undef ENABLE_COMPOUND_DICTIONARY
-#undef PREFIX
-
-#undef EXPORT_FN
-#undef FN
-#undef CAT
-#undef EXPAND_CAT
-
-void duckdb_brotli::BrotliCreateBackwardReferences(size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  if (params->dictionary.compound.num_chunks != 0) {
-    switch (params->hasher.type) {
-#define CASE_(N)                                                    \
-      case N:                                                       \
-        CreateBackwardReferencesDH ## N(num_bytes,                  \
-            position, ringbuffer, ringbuffer_mask,                  \
-            literal_context_lut, params, hasher, dist_cache,        \
-            last_insert_len, commands, num_commands, num_literals); \
-        return;
-      CASE_(5)
-      CASE_(6)
-      CASE_(40)
-      CASE_(41)
-      CASE_(42)
-      CASE_(55)
-      CASE_(65)
-#undef CASE_
-      default:
-        BROTLI_DCHECK(false);
-        break;
-    }
-  }
-
-  switch (params->hasher.type) {
-#define CASE_(N)                                                  \
-    case N:                                                       \
-      CreateBackwardReferencesNH ## N(num_bytes,                  \
-          position, ringbuffer, ringbuffer_mask,                  \
-          literal_context_lut, params, hasher, dist_cache,        \
-          last_insert_len, commands, num_commands, num_literals); \
-      return;
-    FOR_GENERIC_HASHERS(CASE_)
-#undef CASE_
-    default:
-      BROTLI_DCHECK(false);
-      break;
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/backward_references.h b/src/duckdb/third_party/brotli/enc/backward_references.h
deleted file mode 100644
index 16a71faa2..000000000
--- a/src/duckdb/third_party/brotli/enc/backward_references.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function to find backward reference copies. */
-
-#ifndef BROTLI_ENC_BACKWARD_REFERENCES_H_
-#define BROTLI_ENC_BACKWARD_REFERENCES_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "command.h"
-#include "brotli_hash.h"
-#include "quality.h"
-
-namespace duckdb_brotli {
-
-/* "commands" points to the next output command to write to, "*num_commands" is
-   initially the total amount of commands output by previous
-   CreateBackwardReferences calls, and must be incremented by the amount written
-   by this call. */
-BROTLI_INTERNAL void BrotliCreateBackwardReferences(size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals);
-
-}
-
-#endif  /* BROTLI_ENC_BACKWARD_REFERENCES_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/backward_references_hq.cpp b/src/duckdb/third_party/brotli/enc/backward_references_hq.cpp
deleted file mode 100644
index bd51819ce..000000000
--- a/src/duckdb/third_party/brotli/enc/backward_references_hq.cpp
+++ /dev/null
@@ -1,935 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function to find backward reference copies. */
-
-#include "backward_references_hq.h"
-
-#include <string.h>  /* memcpy, memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "command.h"
-#include "compound_dictionary.h"
-#include "encoder_dict.h"
-#include "fast_log.h"
-#include "find_match_length.h"
-#include "literal_cost.h"
-#include "memory.h"
-#include "brotli_params.h"
-#include "prefix.h"
-#include "quality.h"
-
-using namespace duckdb_brotli;
-
-/* BrotliCalculateDistanceCodeLimit(BROTLI_MAX_ALLOWED_DISTANCE, 3, 120). */
-#define BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE 544
-
-static const float kInfinity = 1.7e38f;  /* ~= 2 ^ 127 */
-
-static const uint32_t kDistanceCacheIndex[] = {
-  0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
-};
-static const int kDistanceCacheOffset[] = {
-  0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3
-};
-
-void duckdb_brotli::BrotliInitZopfliNodes(ZopfliNode* array, size_t length) {
-  ZopfliNode stub;
-  size_t i;
-  stub.length = 1;
-  stub.distance = 0;
-  stub.dcode_insert_length = 0;
-  stub.u.cost = kInfinity;
-  for (i = 0; i < length; ++i) array[i] = stub;
-}
-
-static BROTLI_INLINE uint32_t ZopfliNodeCopyLength(const ZopfliNode* self) {
-  return self->length & 0x1FFFFFF;
-}
-
-static BROTLI_INLINE uint32_t ZopfliNodeLengthCode(const ZopfliNode* self) {
-  const uint32_t modifier = self->length >> 25;
-  return ZopfliNodeCopyLength(self) + 9u - modifier;
-}
-
-static BROTLI_INLINE uint32_t ZopfliNodeCopyDistance(const ZopfliNode* self) {
-  return self->distance;
-}
-
-static BROTLI_INLINE uint32_t ZopfliNodeDistanceCode(const ZopfliNode* self) {
-  const uint32_t short_code = self->dcode_insert_length >> 27;
-  return short_code == 0 ?
-      ZopfliNodeCopyDistance(self) + BROTLI_NUM_DISTANCE_SHORT_CODES - 1 :
-      short_code - 1;
-}
-
-static BROTLI_INLINE uint32_t ZopfliNodeCommandLength(const ZopfliNode* self) {
-  return ZopfliNodeCopyLength(self) + (self->dcode_insert_length & 0x7FFFFFF);
-}
-
-/* Temporary data for ZopfliCostModelSetFromCommands. */
-typedef struct ZopfliCostModelArena {
-  uint32_t histogram_literal[BROTLI_NUM_LITERAL_SYMBOLS];
-  uint32_t histogram_cmd[BROTLI_NUM_COMMAND_SYMBOLS];
-  uint32_t histogram_dist[BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE];
-  float cost_literal[BROTLI_NUM_LITERAL_SYMBOLS];
-} ZopfliCostModelArena;
-
-/* Histogram based cost model for zopflification. */
-typedef struct ZopfliCostModel {
-  /* The insert and copy length symbols. */
-  float cost_cmd_[BROTLI_NUM_COMMAND_SYMBOLS];
-  float* cost_dist_;
-  uint32_t distance_histogram_size;
-  /* Cumulative costs of literals per position in the stream. */
-  float* literal_costs_;
-  float min_cost_cmd_;
-  size_t num_bytes_;
-
-  /* Temporary data. */
-  union {
-    size_t literal_histograms[3 * 256];
-    ZopfliCostModelArena arena;
-  };
-} ZopfliCostModel;
-
-static void InitZopfliCostModel(
-    MemoryManager* m, ZopfliCostModel* self, const BrotliDistanceParams* dist,
-    size_t num_bytes) {
-  self->num_bytes_ = num_bytes;
-  self->literal_costs_ = BROTLI_ALLOC(m, float, num_bytes + 2);
-  self->cost_dist_ = BROTLI_ALLOC(m, float, dist->alphabet_size_limit);
-  self->distance_histogram_size = dist->alphabet_size_limit;
-  if (BROTLI_IS_OOM(m)) return;
-}
-
-static void CleanupZopfliCostModel(MemoryManager* m, ZopfliCostModel* self) {
-  BROTLI_FREE(m, self->literal_costs_);
-  BROTLI_FREE(m, self->cost_dist_);
-}
-
-static void SetCost(const uint32_t* histogram, size_t histogram_size,
-                    BROTLI_BOOL literal_histogram, float* cost) {
-  size_t sum = 0;
-  size_t missing_symbol_sum;
-  float log2sum;
-  float missing_symbol_cost;
-  size_t i;
-  for (i = 0; i < histogram_size; i++) {
-    sum += histogram[i];
-  }
-  log2sum = (float)FastLog2(sum);
-  missing_symbol_sum = sum;
-  if (!literal_histogram) {
-    for (i = 0; i < histogram_size; i++) {
-      if (histogram[i] == 0) missing_symbol_sum++;
-    }
-  }
-  missing_symbol_cost = (float)FastLog2(missing_symbol_sum) + 2;
-  for (i = 0; i < histogram_size; i++) {
-    if (histogram[i] == 0) {
-      cost[i] = missing_symbol_cost;
-      continue;
-    }
-
-    /* Shannon bits for this symbol. */
-    cost[i] = log2sum - (float)FastLog2(histogram[i]);
-
-    /* Cannot be coded with less than 1 bit */
-    if (cost[i] < 1) cost[i] = 1;
-  }
-}
-
-static void ZopfliCostModelSetFromCommands(ZopfliCostModel* self,
-                                           size_t position,
-                                           const uint8_t* ringbuffer,
-                                           size_t ringbuffer_mask,
-                                           const Command* commands,
-                                           size_t num_commands,
-                                           size_t last_insert_len) {
-  ZopfliCostModelArena* arena = &self->arena;
-  size_t pos = position - last_insert_len;
-  float min_cost_cmd = kInfinity;
-  size_t i;
-  float* cost_cmd = self->cost_cmd_;
-
-  memset(arena->histogram_literal, 0, sizeof(arena->histogram_literal));
-  memset(arena->histogram_cmd, 0, sizeof(arena->histogram_cmd));
-  memset(arena->histogram_dist, 0, sizeof(arena->histogram_dist));
-
-  for (i = 0; i < num_commands; i++) {
-    size_t inslength = commands[i].insert_len_;
-    size_t copylength = CommandCopyLen(&commands[i]);
-    size_t distcode = commands[i].dist_prefix_ & 0x3FF;
-    size_t cmdcode = commands[i].cmd_prefix_;
-    size_t j;
-
-    arena->histogram_cmd[cmdcode]++;
-    if (cmdcode >= 128) arena->histogram_dist[distcode]++;
-
-    for (j = 0; j < inslength; j++) {
-      arena->histogram_literal[ringbuffer[(pos + j) & ringbuffer_mask]]++;
-    }
-
-    pos += inslength + copylength;
-  }
-
-  SetCost(arena->histogram_literal, BROTLI_NUM_LITERAL_SYMBOLS, BROTLI_TRUE,
-          arena->cost_literal);
-  SetCost(arena->histogram_cmd, BROTLI_NUM_COMMAND_SYMBOLS, BROTLI_FALSE,
-          cost_cmd);
-  SetCost(arena->histogram_dist, self->distance_histogram_size, BROTLI_FALSE,
-          self->cost_dist_);
-
-  for (i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; ++i) {
-    min_cost_cmd = BROTLI_MIN(float, min_cost_cmd, cost_cmd[i]);
-  }
-  self->min_cost_cmd_ = min_cost_cmd;
-
-  {
-    float* literal_costs = self->literal_costs_;
-    float literal_carry = 0.0;
-    size_t num_bytes = self->num_bytes_;
-    literal_costs[0] = 0.0;
-    for (i = 0; i < num_bytes; ++i) {
-      literal_carry +=
-          arena->cost_literal[ringbuffer[(position + i) & ringbuffer_mask]];
-      literal_costs[i + 1] = literal_costs[i] + literal_carry;
-      literal_carry -= literal_costs[i + 1] - literal_costs[i];
-    }
-  }
-}
-
-static void ZopfliCostModelSetFromLiteralCosts(ZopfliCostModel* self,
-                                               size_t position,
-                                               const uint8_t* ringbuffer,
-                                               size_t ringbuffer_mask) {
-  float* literal_costs = self->literal_costs_;
-  float literal_carry = 0.0;
-  float* cost_dist = self->cost_dist_;
-  float* cost_cmd = self->cost_cmd_;
-  size_t num_bytes = self->num_bytes_;
-  size_t i;
-  BrotliEstimateBitCostsForLiterals(position, num_bytes, ringbuffer_mask,
-                                    ringbuffer, self->literal_histograms,
-                                    &literal_costs[1]);
-  literal_costs[0] = 0.0;
-  for (i = 0; i < num_bytes; ++i) {
-    literal_carry += literal_costs[i + 1];
-    literal_costs[i + 1] = literal_costs[i] + literal_carry;
-    literal_carry -= literal_costs[i + 1] - literal_costs[i];
-  }
-  for (i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; ++i) {
-    cost_cmd[i] = (float)FastLog2(11 + (uint32_t)i);
-  }
-  for (i = 0; i < self->distance_histogram_size; ++i) {
-    cost_dist[i] = (float)FastLog2(20 + (uint32_t)i);
-  }
-  self->min_cost_cmd_ = (float)FastLog2(11);
-}
-
-static BROTLI_INLINE float ZopfliCostModelGetCommandCost(
-    const ZopfliCostModel* self, uint16_t cmdcode) {
-  return self->cost_cmd_[cmdcode];
-}
-
-static BROTLI_INLINE float ZopfliCostModelGetDistanceCost(
-    const ZopfliCostModel* self, size_t distcode) {
-  return self->cost_dist_[distcode];
-}
-
-static BROTLI_INLINE float ZopfliCostModelGetLiteralCosts(
-    const ZopfliCostModel* self, size_t from, size_t to) {
-  return self->literal_costs_[to] - self->literal_costs_[from];
-}
-
-static BROTLI_INLINE float ZopfliCostModelGetMinCostCmd(
-    const ZopfliCostModel* self) {
-  return self->min_cost_cmd_;
-}
-
-/* REQUIRES: len >= 2, start_pos <= pos */
-/* REQUIRES: cost < kInfinity, nodes[start_pos].cost < kInfinity */
-/* Maintains the "ZopfliNode array invariant". */
-static BROTLI_INLINE void UpdateZopfliNode(ZopfliNode* nodes, size_t pos,
-    size_t start_pos, size_t len, size_t len_code, size_t dist,
-    size_t short_code, float cost) {
-  ZopfliNode* next = &nodes[pos + len];
-  next->length = (uint32_t)(len | ((len + 9u - len_code) << 25));
-  next->distance = (uint32_t)dist;
-  next->dcode_insert_length = (uint32_t)(
-      (short_code << 27) | (pos - start_pos));
-  next->u.cost = cost;
-}
-
-typedef struct PosData {
-  size_t pos;
-  int distance_cache[4];
-  float costdiff;
-  float cost;
-} PosData;
-
-/* Maintains the smallest 8 cost difference together with their positions */
-typedef struct StartPosQueue {
-  PosData q_[8];
-  size_t idx_;
-} StartPosQueue;
-
-static BROTLI_INLINE void InitStartPosQueue(StartPosQueue* self) {
-  self->idx_ = 0;
-}
-
-static size_t StartPosQueueSize(const StartPosQueue* self) {
-  return BROTLI_MIN(size_t, self->idx_, 8);
-}
-
-static void StartPosQueuePush(StartPosQueue* self, const PosData* posdata) {
-  size_t offset = ~(self->idx_++) & 7;
-  size_t len = StartPosQueueSize(self);
-  size_t i;
-  PosData* q = self->q_;
-  q[offset] = *posdata;
-  /* Restore the sorted order. In the list of |len| items at most |len - 1|
-     adjacent element comparisons / swaps are required. */
-  for (i = 1; i < len; ++i) {
-    if (q[offset & 7].costdiff > q[(offset + 1) & 7].costdiff) {
-      BROTLI_SWAP(PosData, q, offset & 7, (offset + 1) & 7);
-    }
-    ++offset;
-  }
-}
-
-static const PosData* StartPosQueueAt(const StartPosQueue* self, size_t k) {
-  return &self->q_[(k - self->idx_) & 7];
-}
-
-/* Returns the minimum possible copy length that can improve the cost of any */
-/* future position. */
-static size_t ComputeMinimumCopyLength(const float start_cost,
-                                       const ZopfliNode* nodes,
-                                       const size_t num_bytes,
-                                       const size_t pos) {
-  /* Compute the minimum possible cost of reaching any future position. */
-  float min_cost = start_cost;
-  size_t len = 2;
-  size_t next_len_bucket = 4;
-  size_t next_len_offset = 10;
-  while (pos + len <= num_bytes && nodes[pos + len].u.cost <= min_cost) {
-    /* We already reached (pos + len) with no more cost than the minimum
-       possible cost of reaching anything from this pos, so there is no point in
-       looking for lengths <= len. */
-    ++len;
-    if (len == next_len_offset) {
-      /* We reached the next copy length code bucket, so we add one more
-         extra bit to the minimum cost. */
-      min_cost += 1.0f;
-      next_len_offset += next_len_bucket;
-      next_len_bucket *= 2;
-    }
-  }
-  return len;
-}
-
-/* REQUIRES: nodes[pos].cost < kInfinity
-   REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
-static uint32_t ComputeDistanceShortcut(const size_t block_start,
-                                        const size_t pos,
-                                        const size_t max_backward_limit,
-                                        const size_t gap,
-                                        const ZopfliNode* nodes) {
-  const size_t clen = ZopfliNodeCopyLength(&nodes[pos]);
-  const size_t ilen = nodes[pos].dcode_insert_length & 0x7FFFFFF;
-  const size_t dist = ZopfliNodeCopyDistance(&nodes[pos]);
-  /* Since |block_start + pos| is the end position of the command, the copy part
-     starts from |block_start + pos - clen|. Distances that are greater than
-     this or greater than |max_backward_limit| + |gap| are static dictionary
-     references, and do not update the last distances.
-     Also distance code 0 (last distance) does not update the last distances. */
-  if (pos == 0) {
-    return 0;
-  } else if (dist + clen <= block_start + pos + gap &&
-             dist <= max_backward_limit + gap &&
-             ZopfliNodeDistanceCode(&nodes[pos]) > 0) {
-    return (uint32_t)pos;
-  } else {
-    return nodes[pos - clen - ilen].u.shortcut;
-  }
-}
-
-/* Fills in dist_cache[0..3] with the last four distances (as defined by
-   Section 4. of the Spec) that would be used at (block_start + pos) if we
-   used the shortest path of commands from block_start, computed from
-   nodes[0..pos]. The last four distances at block_start are in
-   starting_dist_cache[0..3].
-   REQUIRES: nodes[pos].cost < kInfinity
-   REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
-static void ComputeDistanceCache(const size_t pos,
-                                 const int* starting_dist_cache,
-                                 const ZopfliNode* nodes,
-                                 int* dist_cache) {
-  int idx = 0;
-  size_t p = nodes[pos].u.shortcut;
-  while (idx < 4 && p > 0) {
-    const size_t ilen = nodes[p].dcode_insert_length & 0x7FFFFFF;
-    const size_t clen = ZopfliNodeCopyLength(&nodes[p]);
-    const size_t dist = ZopfliNodeCopyDistance(&nodes[p]);
-    dist_cache[idx++] = (int)dist;
-    /* Because of prerequisite, p >= clen + ilen >= 2. */
-    p = nodes[p - clen - ilen].u.shortcut;
-  }
-  for (; idx < 4; ++idx) {
-    dist_cache[idx] = *starting_dist_cache++;
-  }
-}
-
-/* Maintains "ZopfliNode array invariant" and pushes node to the queue, if it
-   is eligible. */
-static void EvaluateNode(
-    const size_t block_start, const size_t pos, const size_t max_backward_limit,
-    const size_t gap, const int* starting_dist_cache,
-    const ZopfliCostModel* model, StartPosQueue* queue, ZopfliNode* nodes) {
-  /* Save cost, because ComputeDistanceCache invalidates it. */
-  float node_cost = nodes[pos].u.cost;
-  nodes[pos].u.shortcut = ComputeDistanceShortcut(
-      block_start, pos, max_backward_limit, gap, nodes);
-  if (node_cost <= ZopfliCostModelGetLiteralCosts(model, 0, pos)) {
-    PosData posdata;
-    posdata.pos = pos;
-    posdata.cost = node_cost;
-    posdata.costdiff = node_cost -
-        ZopfliCostModelGetLiteralCosts(model, 0, pos);
-    ComputeDistanceCache(
-        pos, starting_dist_cache, nodes, posdata.distance_cache);
-    StartPosQueuePush(queue, &posdata);
-  }
-}
-
-/* Returns longest copy length. */
-static size_t UpdateNodes(
-    const size_t num_bytes, const size_t block_start, const size_t pos,
-    const uint8_t* ringbuffer, const size_t ringbuffer_mask,
-    const BrotliEncoderParams* params, const size_t max_backward_limit,
-    const int* starting_dist_cache, const size_t num_matches,
-    const BackwardMatch* matches, const ZopfliCostModel* model,
-    StartPosQueue* queue, ZopfliNode* nodes) {
-  const size_t stream_offset = params->stream_offset;
-  const size_t cur_ix = block_start + pos;
-  const size_t cur_ix_masked = cur_ix & ringbuffer_mask;
-  const size_t max_distance = BROTLI_MIN(size_t, cur_ix, max_backward_limit);
-  const size_t dictionary_start = BROTLI_MIN(size_t,
-      cur_ix + stream_offset, max_backward_limit);
-  const size_t max_len = num_bytes - pos;
-  const size_t max_zopfli_len = MaxZopfliLen(params);
-  const size_t max_iters = MaxZopfliCandidates(params);
-  size_t min_len;
-  size_t result = 0;
-  size_t k;
-  const CompoundDictionary* addon = &params->dictionary.compound;
-  size_t gap = addon->total_size;
-
-  EvaluateNode(block_start + stream_offset, pos, max_backward_limit, gap,
-      starting_dist_cache, model, queue, nodes);
-
-  {
-    const PosData* posdata = StartPosQueueAt(queue, 0);
-    float min_cost = (posdata->cost + ZopfliCostModelGetMinCostCmd(model) +
-        ZopfliCostModelGetLiteralCosts(model, posdata->pos, pos));
-    min_len = ComputeMinimumCopyLength(min_cost, nodes, num_bytes, pos);
-  }
-
-  /* Go over the command starting positions in order of increasing cost
-     difference. */
-  for (k = 0; k < max_iters && k < StartPosQueueSize(queue); ++k) {
-    const PosData* posdata = StartPosQueueAt(queue, k);
-    const size_t start = posdata->pos;
-    const uint16_t inscode = GetInsertLengthCode(pos - start);
-    const float start_costdiff = posdata->costdiff;
-    const float base_cost = start_costdiff + (float)GetInsertExtra(inscode) +
-        ZopfliCostModelGetLiteralCosts(model, 0, pos);
-
-    /* Look for last distance matches using the distance cache from this
-       starting position. */
-    size_t best_len = min_len - 1;
-    size_t j = 0;
-    for (; j < BROTLI_NUM_DISTANCE_SHORT_CODES && best_len < max_len; ++j) {
-      const size_t idx = kDistanceCacheIndex[j];
-      const size_t backward =
-          (size_t)(posdata->distance_cache[idx] + kDistanceCacheOffset[j]);
-      size_t prev_ix = cur_ix - backward;
-      size_t len = 0;
-      uint8_t continuation = ringbuffer[cur_ix_masked + best_len];
-      if (cur_ix_masked + best_len > ringbuffer_mask) {
-        break;
-      }
-      if (BROTLI_PREDICT_FALSE(backward > dictionary_start + gap)) {
-        /* Word dictionary -> ignore. */
-        continue;
-      }
-      if (backward <= max_distance) {
-        /* Regular backward reference. */
-        if (prev_ix >= cur_ix) {
-          continue;
-        }
-
-        prev_ix &= ringbuffer_mask;
-        if (prev_ix + best_len > ringbuffer_mask ||
-            continuation != ringbuffer[prev_ix + best_len]) {
-          continue;
-        }
-        len = FindMatchLengthWithLimit(&ringbuffer[prev_ix],
-                                       &ringbuffer[cur_ix_masked],
-                                       max_len);
-      } else if (backward > dictionary_start) {
-        size_t d = 0;
-        size_t offset;
-        size_t limit;
-        const uint8_t* source;
-        offset = dictionary_start + 1 + addon->total_size - 1;
-        while (offset >= backward + addon->chunk_offsets[d + 1]) d++;
-        source = addon->chunk_source[d];
-        offset = offset - addon->chunk_offsets[d] - backward;
-        limit = addon->chunk_offsets[d + 1] - addon->chunk_offsets[d] - offset;
-        limit = limit > max_len ? max_len : limit;
-        if (best_len >= limit ||
-            continuation != source[offset + best_len]) {
-          continue;
-        }
-        len = FindMatchLengthWithLimit(&source[offset],
-                                       &ringbuffer[cur_ix_masked],
-                                       limit);
-      } else {
-        /* "Gray" area. It is addressable by decoder, but this encoder
-           instance does not have that data -> should not touch it. */
-        continue;
-      }
-      {
-        const float dist_cost = base_cost +
-            ZopfliCostModelGetDistanceCost(model, j);
-        size_t l;
-        for (l = best_len + 1; l <= len; ++l) {
-          const uint16_t copycode = GetCopyLengthCode(l);
-          const uint16_t cmdcode =
-              CombineLengthCodes(inscode, copycode, j == 0);
-          const float cost = (cmdcode < 128 ? base_cost : dist_cost) +
-              (float)GetCopyExtra(copycode) +
-              ZopfliCostModelGetCommandCost(model, cmdcode);
-          if (cost < nodes[pos + l].u.cost) {
-            UpdateZopfliNode(nodes, pos, start, l, l, backward, j + 1, cost);
-            result = BROTLI_MAX(size_t, result, l);
-          }
-          best_len = l;
-        }
-      }
-    }
-
-    /* At higher iterations look only for new last distance matches, since
-       looking only for new command start positions with the same distances
-       does not help much. */
-    if (k >= 2) continue;
-
-    {
-      /* Loop through all possible copy lengths at this position. */
-      size_t len = min_len;
-      for (j = 0; j < num_matches; ++j) {
-        BackwardMatch match = matches[j];
-        size_t dist = match.distance;
-        BROTLI_BOOL is_dictionary_match =
-            TO_BROTLI_BOOL(dist > dictionary_start + gap);
-        /* We already tried all possible last distance matches, so we can use
-           normal distance code here. */
-        size_t dist_code = dist + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
-        uint16_t dist_symbol;
-        uint32_t distextra;
-        uint32_t distnumextra;
-        float dist_cost;
-        size_t max_match_len;
-        PrefixEncodeCopyDistance(
-            dist_code, params->dist.num_direct_distance_codes,
-            params->dist.distance_postfix_bits, &dist_symbol, &distextra);
-        distnumextra = dist_symbol >> 10;
-        dist_cost = base_cost + (float)distnumextra +
-            ZopfliCostModelGetDistanceCost(model, dist_symbol & 0x3FF);
-
-        /* Try all copy lengths up until the maximum copy length corresponding
-           to this distance. If the distance refers to the static dictionary, or
-           the maximum length is long enough, try only one maximum length. */
-        max_match_len = BackwardMatchLength(&match);
-        if (len < max_match_len &&
-            (is_dictionary_match || max_match_len > max_zopfli_len)) {
-          len = max_match_len;
-        }
-        for (; len <= max_match_len; ++len) {
-          const size_t len_code =
-              is_dictionary_match ? BackwardMatchLengthCode(&match) : len;
-          const uint16_t copycode = GetCopyLengthCode(len_code);
-          const uint16_t cmdcode = CombineLengthCodes(inscode, copycode, 0);
-          const float cost = dist_cost + (float)GetCopyExtra(copycode) +
-              ZopfliCostModelGetCommandCost(model, cmdcode);
-          if (cost < nodes[pos + len].u.cost) {
-            UpdateZopfliNode(nodes, pos, start, len, len_code, dist, 0, cost);
-            result = BROTLI_MAX(size_t, result, len);
-          }
-        }
-      }
-    }
-  }
-  return result;
-}
-
-static size_t ComputeShortestPathFromNodes(size_t num_bytes,
-    ZopfliNode* nodes) {
-  size_t index = num_bytes;
-  size_t num_commands = 0;
-  while ((nodes[index].dcode_insert_length & 0x7FFFFFF) == 0 &&
-      nodes[index].length == 1) --index;
-  nodes[index].u.next = BROTLI_UINT32_MAX;
-  while (index != 0) {
-    size_t len = ZopfliNodeCommandLength(&nodes[index]);
-    index -= len;
-    nodes[index].u.next = (uint32_t)len;
-    num_commands++;
-  }
-  return num_commands;
-}
-
-/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
-void duckdb_brotli::BrotliZopfliCreateCommands(const size_t num_bytes,
-    const size_t block_start, const ZopfliNode* nodes, int* dist_cache,
-    size_t* last_insert_len, const BrotliEncoderParams* params,
-    Command* commands, size_t* num_literals) {
-  const size_t stream_offset = params->stream_offset;
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  size_t pos = 0;
-  uint32_t offset = nodes[0].u.next;
-  size_t i;
-  size_t gap = params->dictionary.compound.total_size;
-  for (i = 0; offset != BROTLI_UINT32_MAX; i++) {
-    const ZopfliNode* next = &nodes[pos + offset];
-    size_t copy_length = ZopfliNodeCopyLength(next);
-    size_t insert_length = next->dcode_insert_length & 0x7FFFFFF;
-    pos += insert_length;
-    offset = next->u.next;
-    if (i == 0) {
-      insert_length += *last_insert_len;
-      *last_insert_len = 0;
-    }
-    {
-      size_t distance = ZopfliNodeCopyDistance(next);
-      size_t len_code = ZopfliNodeLengthCode(next);
-      size_t dictionary_start = BROTLI_MIN(size_t,
-          block_start + pos + stream_offset, max_backward_limit);
-      BROTLI_BOOL is_dictionary =
-          TO_BROTLI_BOOL(distance > dictionary_start + gap);
-      size_t dist_code = ZopfliNodeDistanceCode(next);
-      InitCommand(&commands[i], &params->dist, insert_length,
-          copy_length, (int)len_code - (int)copy_length, dist_code);
-
-      if (!is_dictionary && dist_code > 0) {
-        dist_cache[3] = dist_cache[2];
-        dist_cache[2] = dist_cache[1];
-        dist_cache[1] = dist_cache[0];
-        dist_cache[0] = (int)distance;
-      }
-    }
-
-    *num_literals += insert_length;
-    pos += copy_length;
-  }
-  *last_insert_len += num_bytes - pos;
-}
-
-static size_t ZopfliIterate(size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    const BrotliEncoderParams* params, const size_t gap, const int* dist_cache,
-    const ZopfliCostModel* model, const uint32_t* num_matches,
-    const BackwardMatch* matches, ZopfliNode* nodes) {
-  const size_t stream_offset = params->stream_offset;
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t max_zopfli_len = MaxZopfliLen(params);
-  StartPosQueue queue;
-  size_t cur_match_pos = 0;
-  size_t i;
-  nodes[0].length = 0;
-  nodes[0].u.cost = 0;
-  InitStartPosQueue(&queue);
-  for (i = 0; i + 3 < num_bytes; i++) {
-    size_t skip = UpdateNodes(num_bytes, position, i, ringbuffer,
-        ringbuffer_mask, params, max_backward_limit, dist_cache,
-        num_matches[i], &matches[cur_match_pos], model, &queue, nodes);
-    if (skip < BROTLI_LONG_COPY_QUICK_STEP) skip = 0;
-    cur_match_pos += num_matches[i];
-    if (num_matches[i] == 1 &&
-        BackwardMatchLength(&matches[cur_match_pos - 1]) > max_zopfli_len) {
-      skip = BROTLI_MAX(size_t,
-          BackwardMatchLength(&matches[cur_match_pos - 1]), skip);
-    }
-    if (skip > 1) {
-      skip--;
-      while (skip) {
-        i++;
-        if (i + 3 >= num_bytes) break;
-        EvaluateNode(position + stream_offset, i, max_backward_limit, gap,
-            dist_cache, model, &queue, nodes);
-        cur_match_pos += num_matches[i];
-        skip--;
-      }
-    }
-  }
-  return ComputeShortestPathFromNodes(num_bytes, nodes);
-}
-
-static void MergeMatches(BackwardMatch* dst,
-    BackwardMatch* src1, size_t len1, BackwardMatch* src2, size_t len2) {
-  while (len1 > 0 && len2 > 0) {
-    size_t l1 = BackwardMatchLength(src1);
-    size_t l2 = BackwardMatchLength(src2);
-    if (l1 < l2 || ((l1 == l2) && (src1->distance < src2->distance))) {
-      *dst++ = *src1++;
-      len1--;
-    } else {
-      *dst++ = *src2++;
-      len2--;
-    }
-  }
-  while (len1-- > 0) *dst++ = *src1++;
-  while (len2-- > 0) *dst++ = *src2++;
-}
-
-/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
-size_t duckdb_brotli::BrotliZopfliComputeShortestPath(MemoryManager* m, size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    const int* dist_cache, Hasher* hasher, ZopfliNode* nodes) {
-  const size_t stream_offset = params->stream_offset;
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  const size_t max_zopfli_len = MaxZopfliLen(params);
-  StartPosQueue queue;
-  BackwardMatch* BROTLI_RESTRICT matches =
-      BROTLI_ALLOC(m, BackwardMatch, 2 * (MAX_NUM_MATCHES_H10 + 64));
-  const size_t store_end = num_bytes >= StoreLookaheadH10() ?
-      position + num_bytes - StoreLookaheadH10() + 1 : position;
-  size_t i;
-  const CompoundDictionary* addon = &params->dictionary.compound;
-  size_t gap = addon->total_size;
-  size_t lz_matches_offset =
-      (addon->num_chunks != 0) ? (MAX_NUM_MATCHES_H10 + 128) : 0;
-  ZopfliCostModel* model = BROTLI_ALLOC(m, ZopfliCostModel, 1);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(model) || BROTLI_IS_NULL(matches)) {
-    return 0;
-  }
-  nodes[0].length = 0;
-  nodes[0].u.cost = 0;
-  InitZopfliCostModel(m, model, &params->dist, num_bytes);
-  if (BROTLI_IS_OOM(m)) return 0;
-  ZopfliCostModelSetFromLiteralCosts(
-      model, position, ringbuffer, ringbuffer_mask);
-  InitStartPosQueue(&queue);
-  for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; i++) {
-    const size_t pos = position + i;
-    const size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
-    const size_t dictionary_start = BROTLI_MIN(size_t,
-        pos + stream_offset, max_backward_limit);
-    size_t skip;
-    size_t num_matches;
-    int dict_id = 0;
-    if (params->dictionary.contextual.context_based) {
-      uint8_t p1 = pos >= 1 ?
-          ringbuffer[(size_t)(pos - 1) & ringbuffer_mask] : 0;
-      uint8_t p2 = pos >= 2 ?
-          ringbuffer[(size_t)(pos - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    num_matches = FindAllMatchesH10(&hasher->privat._H10,
-        params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, pos, num_bytes - i, max_distance,
-        dictionary_start + gap, params, &matches[lz_matches_offset]);
-    if (addon->num_chunks != 0) {
-      size_t cd_matches = LookupAllCompoundDictionaryMatches(addon,
-          ringbuffer, ringbuffer_mask, pos, 3, num_bytes - i,
-          dictionary_start, params->dist.max_distance,
-          &matches[lz_matches_offset - 64], 64);
-      MergeMatches(matches, &matches[lz_matches_offset - 64], cd_matches,
-          &matches[lz_matches_offset], num_matches);
-      num_matches += cd_matches;
-    }
-    if (num_matches > 0 &&
-        BackwardMatchLength(&matches[num_matches - 1]) > max_zopfli_len) {
-      matches[0] = matches[num_matches - 1];
-      num_matches = 1;
-    }
-    skip = UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask,
-        params, max_backward_limit, dist_cache, num_matches, matches, model,
-        &queue, nodes);
-    if (skip < BROTLI_LONG_COPY_QUICK_STEP) skip = 0;
-    if (num_matches == 1 && BackwardMatchLength(&matches[0]) > max_zopfli_len) {
-      skip = BROTLI_MAX(size_t, BackwardMatchLength(&matches[0]), skip);
-    }
-    if (skip > 1) {
-      /* Add the tail of the copy to the hasher. */
-      StoreRangeH10(&hasher->privat._H10,
-          ringbuffer, ringbuffer_mask, pos + 1, BROTLI_MIN(
-          size_t, pos + skip, store_end));
-      skip--;
-      while (skip) {
-        i++;
-        if (i + HashTypeLengthH10() - 1 >= num_bytes) break;
-        EvaluateNode(position + stream_offset, i, max_backward_limit, gap,
-            dist_cache, model, &queue, nodes);
-        skip--;
-      }
-    }
-  }
-  CleanupZopfliCostModel(m, model);
-  BROTLI_FREE(m, model);
-  BROTLI_FREE(m, matches);
-  return ComputeShortestPathFromNodes(num_bytes, nodes);
-}
-
-void duckdb_brotli::BrotliCreateZopfliBackwardReferences(MemoryManager* m, size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  ZopfliNode* nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(nodes)) return;
-  BrotliInitZopfliNodes(nodes, num_bytes + 1);
-  *num_commands += BrotliZopfliComputeShortestPath(m, num_bytes,
-      position, ringbuffer, ringbuffer_mask, literal_context_lut, params,
-      dist_cache, hasher, nodes);
-  if (BROTLI_IS_OOM(m)) return;
-  BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache,
-      last_insert_len, params, commands, num_literals);
-  BROTLI_FREE(m, nodes);
-}
-
-void duckdb_brotli::BrotliCreateHqZopfliBackwardReferences(MemoryManager* m, size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals) {
-  const size_t stream_offset = params->stream_offset;
-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
-  uint32_t* num_matches = BROTLI_ALLOC(m, uint32_t, num_bytes);
-  size_t matches_size = 4 * num_bytes;
-  const size_t store_end = num_bytes >= StoreLookaheadH10() ?
-      position + num_bytes - StoreLookaheadH10() + 1 : position;
-  size_t cur_match_pos = 0;
-  size_t i;
-  size_t orig_num_literals;
-  size_t orig_last_insert_len;
-  int orig_dist_cache[4];
-  size_t orig_num_commands;
-  ZopfliCostModel* model = BROTLI_ALLOC(m, ZopfliCostModel, 1);
-  ZopfliNode* nodes;
-  BackwardMatch* matches = BROTLI_ALLOC(m, BackwardMatch, matches_size);
-  const CompoundDictionary* addon = &params->dictionary.compound;
-  size_t gap = addon->total_size;
-  size_t shadow_matches =
-      (addon->num_chunks != 0) ? (MAX_NUM_MATCHES_H10 + 128) : 0;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(model) ||
-      BROTLI_IS_NULL(num_matches) || BROTLI_IS_NULL(matches)) {
-    return;
-  }
-  for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; ++i) {
-    const size_t pos = position + i;
-    size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
-    size_t dictionary_start = BROTLI_MIN(size_t,
-        pos + stream_offset, max_backward_limit);
-    size_t max_length = num_bytes - i;
-    size_t num_found_matches;
-    size_t cur_match_end;
-    size_t j;
-    int dict_id = 0;
-    if (params->dictionary.contextual.context_based) {
-      uint8_t p1 = pos >= 1 ?
-          ringbuffer[(size_t)(pos - 1) & ringbuffer_mask] : 0;
-      uint8_t p2 = pos >= 2 ?
-          ringbuffer[(size_t)(pos - 2) & ringbuffer_mask] : 0;
-      dict_id = params->dictionary.contextual.context_map[
-          BROTLI_CONTEXT(p1, p2, literal_context_lut)];
-    }
-    /* Ensure that we have enough free slots. */
-    BROTLI_ENSURE_CAPACITY(m, BackwardMatch, matches, matches_size,
-        cur_match_pos + MAX_NUM_MATCHES_H10 + shadow_matches);
-    if (BROTLI_IS_OOM(m)) return;
-    num_found_matches = FindAllMatchesH10(&hasher->privat._H10,
-        params->dictionary.contextual.dict[dict_id],
-        ringbuffer, ringbuffer_mask, pos, max_length,
-        max_distance, dictionary_start + gap, params,
-        &matches[cur_match_pos + shadow_matches]);
-    if (addon->num_chunks != 0) {
-      size_t cd_matches = LookupAllCompoundDictionaryMatches(addon,
-          ringbuffer, ringbuffer_mask, pos, 3, max_length,
-          dictionary_start, params->dist.max_distance,
-          &matches[cur_match_pos + shadow_matches - 64], 64);
-      MergeMatches(&matches[cur_match_pos],
-          &matches[cur_match_pos + shadow_matches - 64], cd_matches,
-          &matches[cur_match_pos + shadow_matches], num_found_matches);
-      num_found_matches += cd_matches;
-    }
-    cur_match_end = cur_match_pos + num_found_matches;
-    for (j = cur_match_pos; j + 1 < cur_match_end; ++j) {
-      BROTLI_DCHECK(BackwardMatchLength(&matches[j]) <=
-          BackwardMatchLength(&matches[j + 1]));
-    }
-    num_matches[i] = (uint32_t)num_found_matches;
-    if (num_found_matches > 0) {
-      const size_t match_len = BackwardMatchLength(&matches[cur_match_end - 1]);
-      if (match_len > MAX_ZOPFLI_LEN_QUALITY_11) {
-        const size_t skip = match_len - 1;
-        matches[cur_match_pos++] = matches[cur_match_end - 1];
-        num_matches[i] = 1;
-        /* Add the tail of the copy to the hasher. */
-        StoreRangeH10(&hasher->privat._H10,
-                      ringbuffer, ringbuffer_mask, pos + 1,
-                      BROTLI_MIN(size_t, pos + match_len, store_end));
-        memset(&num_matches[i + 1], 0, skip * sizeof(num_matches[0]));
-        i += skip;
-      } else {
-        cur_match_pos = cur_match_end;
-      }
-    }
-  }
-  orig_num_literals = *num_literals;
-  orig_last_insert_len = *last_insert_len;
-  memcpy(orig_dist_cache, dist_cache, 4 * sizeof(dist_cache[0]));
-  orig_num_commands = *num_commands;
-  nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(nodes)) return;
-  InitZopfliCostModel(m, model, &params->dist, num_bytes);
-  if (BROTLI_IS_OOM(m)) return;
-  for (i = 0; i < 2; i++) {
-    BrotliInitZopfliNodes(nodes, num_bytes + 1);
-    if (i == 0) {
-      ZopfliCostModelSetFromLiteralCosts(
-          model, position, ringbuffer, ringbuffer_mask);
-    } else {
-      ZopfliCostModelSetFromCommands(model, position, ringbuffer,
-          ringbuffer_mask, commands, *num_commands - orig_num_commands,
-          orig_last_insert_len);
-    }
-    *num_commands = orig_num_commands;
-    *num_literals = orig_num_literals;
-    *last_insert_len = orig_last_insert_len;
-    memcpy(dist_cache, orig_dist_cache, 4 * sizeof(dist_cache[0]));
-    *num_commands += ZopfliIterate(num_bytes, position, ringbuffer,
-        ringbuffer_mask, params, gap, dist_cache, model, num_matches, matches,
-        nodes);
-    BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache,
-        last_insert_len, params, commands, num_literals);
-  }
-  CleanupZopfliCostModel(m, model);
-  BROTLI_FREE(m, model);
-  BROTLI_FREE(m, nodes);
-  BROTLI_FREE(m, matches);
-  BROTLI_FREE(m, num_matches);
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/backward_references_hq.h b/src/duckdb/third_party/brotli/enc/backward_references_hq.h
deleted file mode 100644
index f5a6cdcba..000000000
--- a/src/duckdb/third_party/brotli/enc/backward_references_hq.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function to find backward reference copies. */
-
-#ifndef BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_
-#define BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "command.h"
-#include "brotli_hash.h"
-#include "memory.h"
-#include "quality.h"
-
-namespace duckdb_brotli {
-
-BROTLI_INTERNAL void BrotliCreateZopfliBackwardReferences(MemoryManager* m,
-    size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals);
-
-BROTLI_INTERNAL void BrotliCreateHqZopfliBackwardReferences(MemoryManager* m,
-    size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
-    Command* commands, size_t* num_commands, size_t* num_literals);
-
-typedef struct ZopfliNode {
-  /* Best length to get up to this byte (not including this byte itself)
-     highest 7 bit is used to reconstruct the length code. */
-  uint32_t length;
-  /* Distance associated with the length. */
-  uint32_t distance;
-  /* Number of literal inserts before this copy; highest 5 bits contain
-     distance short code + 1 (or zero if no short code). */
-  uint32_t dcode_insert_length;
-
-  /* This union holds information used by dynamic-programming. During forward
-     pass |cost| it used to store the goal function. When node is processed its
-     |cost| is invalidated in favor of |shortcut|. On path back-tracing pass
-     |next| is assigned the offset to next node on the path. */
-  union {
-    /* Smallest cost to get to this byte from the beginning, as found so far. */
-    float cost;
-    /* Offset to the next node on the path. Equals to command_length() of the
-       next node on the path. For last node equals to BROTLI_UINT32_MAX */
-    uint32_t next;
-    /* Node position that provides next distance for distance cache. */
-    uint32_t shortcut;
-  } u;
-} ZopfliNode;
-
-BROTLI_INTERNAL void BrotliInitZopfliNodes(ZopfliNode* array, size_t length);
-
-/* Computes the shortest path of commands from position to at most
-   position + num_bytes.
-
-   On return, path->size() is the number of commands found and path[i] is the
-   length of the i-th command (copy length plus insert length).
-   Note that the sum of the lengths of all commands can be less than num_bytes.
-
-   On return, the nodes[0..num_bytes] array will have the following
-   "ZopfliNode array invariant":
-   For each i in [1..num_bytes], if nodes[i].cost < kInfinity, then
-     (1) nodes[i].copy_length() >= 2
-     (2) nodes[i].command_length() <= i and
-     (3) nodes[i - nodes[i].command_length()].cost < kInfinity */
-BROTLI_INTERNAL size_t BrotliZopfliComputeShortestPath(
-    MemoryManager* m, size_t num_bytes,
-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
-    const int* dist_cache, Hasher* hasher, ZopfliNode* nodes);
-
-BROTLI_INTERNAL void BrotliZopfliCreateCommands(
-    const size_t num_bytes, const size_t block_start, const ZopfliNode* nodes,
-    int* dist_cache, size_t* last_insert_len, const BrotliEncoderParams* params,
-    Command* commands, size_t* num_literals);
-
-}
-
-#endif  /* BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/bit_cost.cpp b/src/duckdb/third_party/brotli/enc/bit_cost.cpp
deleted file mode 100644
index c9c988acf..000000000
--- a/src/duckdb/third_party/brotli/enc/bit_cost.cpp
+++ /dev/null
@@ -1,410 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Functions to estimate the bit cost of Huffman trees. */
-
-#include "bit_cost.h"
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "fast_log.h"
-#include "histogram.h"
-
-using namespace duckdb_brotli;
-
-#define FN(X) duckdb_brotli:: X ## Literal
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-double FN(BrotliPopulationCost)(const HistogramType* histogram) {
-  static const double kOneSymbolHistogramCost = 12;
-  static const double kTwoSymbolHistogramCost = 20;
-  static const double kThreeSymbolHistogramCost = 28;
-  static const double kFourSymbolHistogramCost = 37;
-  const size_t data_size = FN(HistogramDataSize)();
-  int count = 0;
-  size_t s[5];
-  double bits = 0.0;
-  size_t i;
-  if (histogram->total_count_ == 0) {
-    return kOneSymbolHistogramCost;
-  }
-  for (i = 0; i < data_size; ++i) {
-    if (histogram->data_[i] > 0) {
-      s[count] = i;
-      ++count;
-      if (count > 4) break;
-    }
-  }
-  if (count == 1) {
-    return kOneSymbolHistogramCost;
-  }
-  if (count == 2) {
-    return (kTwoSymbolHistogramCost + (double)histogram->total_count_);
-  }
-  if (count == 3) {
-    const uint32_t histo0 = histogram->data_[s[0]];
-    const uint32_t histo1 = histogram->data_[s[1]];
-    const uint32_t histo2 = histogram->data_[s[2]];
-    const uint32_t histomax =
-        BROTLI_MAX(uint32_t, histo0, BROTLI_MAX(uint32_t, histo1, histo2));
-    return (kThreeSymbolHistogramCost +
-            2 * (histo0 + histo1 + histo2) - histomax);
-  }
-  if (count == 4) {
-    uint32_t histo[4];
-    uint32_t h23;
-    uint32_t histomax;
-    for (i = 0; i < 4; ++i) {
-      histo[i] = histogram->data_[s[i]];
-    }
-    /* Sort */
-    for (i = 0; i < 4; ++i) {
-      size_t j;
-      for (j = i + 1; j < 4; ++j) {
-        if (histo[j] > histo[i]) {
-          BROTLI_SWAP(uint32_t, histo, j, i);
-        }
-      }
-    }
-    h23 = histo[2] + histo[3];
-    histomax = BROTLI_MAX(uint32_t, h23, histo[0]);
-    return (kFourSymbolHistogramCost +
-            3 * h23 + 2 * (histo[0] + histo[1]) - histomax);
-  }
-
-  {
-    /* In this loop we compute the entropy of the histogram and simultaneously
-       build a simplified histogram of the code length codes where we use the
-       zero repeat code 17, but we don't use the non-zero repeat code 16. */
-    size_t max_depth = 1;
-    uint32_t depth_histo[BROTLI_CODE_LENGTH_CODES] = { 0 };
-    const double log2total = FastLog2(histogram->total_count_);
-    for (i = 0; i < data_size;) {
-      if (histogram->data_[i] > 0) {
-        /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) =
-                                    = log2(total_count) - log2(count(symbol)) */
-        double log2p = log2total - FastLog2(histogram->data_[i]);
-        /* Approximate the bit depth by round(-log2(P(symbol))) */
-        size_t depth = (size_t)(log2p + 0.5);
-        bits += histogram->data_[i] * log2p;
-        if (depth > 15) {
-          depth = 15;
-        }
-        if (depth > max_depth) {
-          max_depth = depth;
-        }
-        ++depth_histo[depth];
-        ++i;
-      } else {
-        /* Compute the run length of zeros and add the appropriate number of 0
-           and 17 code length codes to the code length code histogram. */
-        uint32_t reps = 1;
-        size_t k;
-        for (k = i + 1; k < data_size && histogram->data_[k] == 0; ++k) {
-          ++reps;
-        }
-        i += reps;
-        if (i == data_size) {
-          /* Don't add any cost for the last zero run, since these are encoded
-             only implicitly. */
-          break;
-        }
-        if (reps < 3) {
-          depth_histo[0] += reps;
-        } else {
-          reps -= 2;
-          while (reps > 0) {
-            ++depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH];
-            /* Add the 3 extra bits for the 17 code length code. */
-            bits += 3;
-            reps >>= 3;
-          }
-        }
-      }
-    }
-    /* Add the estimated encoding cost of the code length code histogram. */
-    bits += (double)(18 + 2 * max_depth);
-    /* Add the entropy of the code length code histogram. */
-    bits += BitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES);
-  }
-  return bits;
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) duckdb_brotli:: X ## Command
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-double FN(BrotliPopulationCost)(const HistogramType* histogram) {
-  static const double kOneSymbolHistogramCost = 12;
-  static const double kTwoSymbolHistogramCost = 20;
-  static const double kThreeSymbolHistogramCost = 28;
-  static const double kFourSymbolHistogramCost = 37;
-  const size_t data_size = FN(HistogramDataSize)();
-  int count = 0;
-  size_t s[5];
-  double bits = 0.0;
-  size_t i;
-  if (histogram->total_count_ == 0) {
-    return kOneSymbolHistogramCost;
-  }
-  for (i = 0; i < data_size; ++i) {
-    if (histogram->data_[i] > 0) {
-      s[count] = i;
-      ++count;
-      if (count > 4) break;
-    }
-  }
-  if (count == 1) {
-    return kOneSymbolHistogramCost;
-  }
-  if (count == 2) {
-    return (kTwoSymbolHistogramCost + (double)histogram->total_count_);
-  }
-  if (count == 3) {
-    const uint32_t histo0 = histogram->data_[s[0]];
-    const uint32_t histo1 = histogram->data_[s[1]];
-    const uint32_t histo2 = histogram->data_[s[2]];
-    const uint32_t histomax =
-        BROTLI_MAX(uint32_t, histo0, BROTLI_MAX(uint32_t, histo1, histo2));
-    return (kThreeSymbolHistogramCost +
-            2 * (histo0 + histo1 + histo2) - histomax);
-  }
-  if (count == 4) {
-    uint32_t histo[4];
-    uint32_t h23;
-    uint32_t histomax;
-    for (i = 0; i < 4; ++i) {
-      histo[i] = histogram->data_[s[i]];
-    }
-    /* Sort */
-    for (i = 0; i < 4; ++i) {
-      size_t j;
-      for (j = i + 1; j < 4; ++j) {
-        if (histo[j] > histo[i]) {
-          BROTLI_SWAP(uint32_t, histo, j, i);
-        }
-      }
-    }
-    h23 = histo[2] + histo[3];
-    histomax = BROTLI_MAX(uint32_t, h23, histo[0]);
-    return (kFourSymbolHistogramCost +
-            3 * h23 + 2 * (histo[0] + histo[1]) - histomax);
-  }
-
-  {
-    /* In this loop we compute the entropy of the histogram and simultaneously
-       build a simplified histogram of the code length codes where we use the
-       zero repeat code 17, but we don't use the non-zero repeat code 16. */
-    size_t max_depth = 1;
-    uint32_t depth_histo[BROTLI_CODE_LENGTH_CODES] = { 0 };
-    const double log2total = FastLog2(histogram->total_count_);
-    for (i = 0; i < data_size;) {
-      if (histogram->data_[i] > 0) {
-        /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) =
-                                    = log2(total_count) - log2(count(symbol)) */
-        double log2p = log2total - FastLog2(histogram->data_[i]);
-        /* Approximate the bit depth by round(-log2(P(symbol))) */
-        size_t depth = (size_t)(log2p + 0.5);
-        bits += histogram->data_[i] * log2p;
-        if (depth > 15) {
-          depth = 15;
-        }
-        if (depth > max_depth) {
-          max_depth = depth;
-        }
-        ++depth_histo[depth];
-        ++i;
-      } else {
-        /* Compute the run length of zeros and add the appropriate number of 0
-           and 17 code length codes to the code length code histogram. */
-        uint32_t reps = 1;
-        size_t k;
-        for (k = i + 1; k < data_size && histogram->data_[k] == 0; ++k) {
-          ++reps;
-        }
-        i += reps;
-        if (i == data_size) {
-          /* Don't add any cost for the last zero run, since these are encoded
-             only implicitly. */
-          break;
-        }
-        if (reps < 3) {
-          depth_histo[0] += reps;
-        } else {
-          reps -= 2;
-          while (reps > 0) {
-            ++depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH];
-            /* Add the 3 extra bits for the 17 code length code. */
-            bits += 3;
-            reps >>= 3;
-          }
-        }
-      }
-    }
-    /* Add the estimated encoding cost of the code length code histogram. */
-    bits += (double)(18 + 2 * max_depth);
-    /* Add the entropy of the code length code histogram. */
-    bits += BitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES);
-  }
-  return bits;
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) duckdb_brotli:: X ## Distance
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-double FN(BrotliPopulationCost)(const HistogramType* histogram) {
-  static const double kOneSymbolHistogramCost = 12;
-  static const double kTwoSymbolHistogramCost = 20;
-  static const double kThreeSymbolHistogramCost = 28;
-  static const double kFourSymbolHistogramCost = 37;
-  const size_t data_size = FN(HistogramDataSize)();
-  int count = 0;
-  size_t s[5];
-  double bits = 0.0;
-  size_t i;
-  if (histogram->total_count_ == 0) {
-    return kOneSymbolHistogramCost;
-  }
-  for (i = 0; i < data_size; ++i) {
-    if (histogram->data_[i] > 0) {
-      s[count] = i;
-      ++count;
-      if (count > 4) break;
-    }
-  }
-  if (count == 1) {
-    return kOneSymbolHistogramCost;
-  }
-  if (count == 2) {
-    return (kTwoSymbolHistogramCost + (double)histogram->total_count_);
-  }
-  if (count == 3) {
-    const uint32_t histo0 = histogram->data_[s[0]];
-    const uint32_t histo1 = histogram->data_[s[1]];
-    const uint32_t histo2 = histogram->data_[s[2]];
-    const uint32_t histomax =
-        BROTLI_MAX(uint32_t, histo0, BROTLI_MAX(uint32_t, histo1, histo2));
-    return (kThreeSymbolHistogramCost +
-            2 * (histo0 + histo1 + histo2) - histomax);
-  }
-  if (count == 4) {
-    uint32_t histo[4];
-    uint32_t h23;
-    uint32_t histomax;
-    for (i = 0; i < 4; ++i) {
-      histo[i] = histogram->data_[s[i]];
-    }
-    /* Sort */
-    for (i = 0; i < 4; ++i) {
-      size_t j;
-      for (j = i + 1; j < 4; ++j) {
-        if (histo[j] > histo[i]) {
-          BROTLI_SWAP(uint32_t, histo, j, i);
-        }
-      }
-    }
-    h23 = histo[2] + histo[3];
-    histomax = BROTLI_MAX(uint32_t, h23, histo[0]);
-    return (kFourSymbolHistogramCost +
-            3 * h23 + 2 * (histo[0] + histo[1]) - histomax);
-  }
-
-  {
-    /* In this loop we compute the entropy of the histogram and simultaneously
-       build a simplified histogram of the code length codes where we use the
-       zero repeat code 17, but we don't use the non-zero repeat code 16. */
-    size_t max_depth = 1;
-    uint32_t depth_histo[BROTLI_CODE_LENGTH_CODES] = { 0 };
-    const double log2total = FastLog2(histogram->total_count_);
-    for (i = 0; i < data_size;) {
-      if (histogram->data_[i] > 0) {
-        /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) =
-                                    = log2(total_count) - log2(count(symbol)) */
-        double log2p = log2total - FastLog2(histogram->data_[i]);
-        /* Approximate the bit depth by round(-log2(P(symbol))) */
-        size_t depth = (size_t)(log2p + 0.5);
-        bits += histogram->data_[i] * log2p;
-        if (depth > 15) {
-          depth = 15;
-        }
-        if (depth > max_depth) {
-          max_depth = depth;
-        }
-        ++depth_histo[depth];
-        ++i;
-      } else {
-        /* Compute the run length of zeros and add the appropriate number of 0
-           and 17 code length codes to the code length code histogram. */
-        uint32_t reps = 1;
-        size_t k;
-        for (k = i + 1; k < data_size && histogram->data_[k] == 0; ++k) {
-          ++reps;
-        }
-        i += reps;
-        if (i == data_size) {
-          /* Don't add any cost for the last zero run, since these are encoded
-             only implicitly. */
-          break;
-        }
-        if (reps < 3) {
-          depth_histo[0] += reps;
-        } else {
-          reps -= 2;
-          while (reps > 0) {
-            ++depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH];
-            /* Add the 3 extra bits for the 17 code length code. */
-            bits += 3;
-            reps >>= 3;
-          }
-        }
-      }
-    }
-    /* Add the estimated encoding cost of the code length code histogram. */
-    bits += (double)(18 + 2 * max_depth);
-    /* Add the entropy of the code length code histogram. */
-    bits += BitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES);
-  }
-  return bits;
-}
-
-#undef HistogramType
-#undef FN
-
-
diff --git a/src/duckdb/third_party/brotli/enc/bit_cost.h b/src/duckdb/third_party/brotli/enc/bit_cost.h
deleted file mode 100644
index 6ef61d81a..000000000
--- a/src/duckdb/third_party/brotli/enc/bit_cost.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Functions to estimate the bit cost of Huffman trees. */
-
-#ifndef BROTLI_ENC_BIT_COST_H_
-#define BROTLI_ENC_BIT_COST_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "fast_log.h"
-#include "histogram.h"
-
-namespace duckdb_brotli {
-
-static BROTLI_INLINE double ShannonEntropy(
-    const uint32_t* population, size_t size, size_t* total) {
-  size_t sum = 0;
-  double retval = 0;
-  const uint32_t* population_end = population + size;
-  size_t p;
-  if (size & 1) {
-    goto odd_number_of_elements_left;
-  }
-  while (population < population_end) {
-    p = *population++;
-    sum += p;
-    retval -= (double)p * FastLog2(p);
- odd_number_of_elements_left:
-    p = *population++;
-    sum += p;
-    retval -= (double)p * FastLog2(p);
-  }
-  if (sum) retval += (double)sum * FastLog2(sum);
-  *total = sum;
-  return retval;
-}
-
-static BROTLI_INLINE double BitsEntropy(
-    const uint32_t* population, size_t size) {
-  size_t sum;
-  double retval = ShannonEntropy(population, size, &sum);
-  if (retval < (double)sum) {
-    /* At least one bit per literal is needed. */
-    retval = (double)sum;
-  }
-  return retval;
-}
-
-BROTLI_INTERNAL double BrotliPopulationCostLiteral(const HistogramLiteral*);
-BROTLI_INTERNAL double BrotliPopulationCostCommand(const HistogramCommand*);
-BROTLI_INTERNAL double BrotliPopulationCostDistance(const HistogramDistance*);
-
-}
-
-#endif  /* BROTLI_ENC_BIT_COST_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/block_splitter.cpp b/src/duckdb/third_party/brotli/enc/block_splitter.cpp
deleted file mode 100644
index 7208c61b4..000000000
--- a/src/duckdb/third_party/brotli/enc/block_splitter.cpp
+++ /dev/null
@@ -1,1653 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Block split point selection utilities. */
-
-#include "block_splitter.h"
-
-#include <string.h>  /* memcpy, memset */
-
-#include "../common/brotli_platform.h"
-#include "bit_cost.h"
-#include "cluster.h"
-#include "command.h"
-#include "fast_log.h"
-#include "histogram.h"
-#include "memory.h"
-#include "quality.h"
-
-using namespace duckdb_brotli;
-
-static const size_t kMaxLiteralHistograms = 100;
-static const size_t kMaxCommandHistograms = 50;
-static const double kLiteralBlockSwitchCost = 28.1;
-static const double kCommandBlockSwitchCost = 13.5;
-static const double kDistanceBlockSwitchCost = 14.6;
-static const size_t kLiteralStrideLength = 70;
-static const size_t kCommandStrideLength = 40;
-static const size_t kDistanceStrideLength = 40;
-static const size_t kSymbolsPerLiteralHistogram = 544;
-static const size_t kSymbolsPerCommandHistogram = 530;
-static const size_t kSymbolsPerDistanceHistogram = 544;
-static const size_t kMinLengthForBlockSplitting = 128;
-static const size_t kIterMulForRefining = 2;
-static const size_t kMinItersForRefining = 100;
-
-static size_t CountLiterals(const Command* cmds, const size_t num_commands) {
-  /* Count how many we have. */
-  size_t total_length = 0;
-  size_t i;
-  for (i = 0; i < num_commands; ++i) {
-    total_length += cmds[i].insert_len_;
-  }
-  return total_length;
-}
-
-static void CopyLiteralsToByteArray(const Command* cmds,
-                                    const size_t num_commands,
-                                    const uint8_t* data,
-                                    const size_t offset,
-                                    const size_t mask,
-                                    uint8_t* literals) {
-  size_t pos = 0;
-  size_t from_pos = offset & mask;
-  size_t i;
-  for (i = 0; i < num_commands; ++i) {
-    size_t insert_len = cmds[i].insert_len_;
-    if (from_pos + insert_len > mask) {
-      size_t head_size = mask + 1 - from_pos;
-      memcpy(literals + pos, data + from_pos, head_size);
-      from_pos = 0;
-      pos += head_size;
-      insert_len -= head_size;
-    }
-    if (insert_len > 0) {
-      memcpy(literals + pos, data + from_pos, insert_len);
-      pos += insert_len;
-    }
-    from_pos = (from_pos + insert_len + CommandCopyLen(&cmds[i])) & mask;
-  }
-}
-
-static BROTLI_INLINE uint32_t MyRand(uint32_t* seed) {
-  /* Initial seed should be 7. In this case, loop length is (1 << 29). */
-  *seed *= 16807U;
-  return *seed;
-}
-
-static BROTLI_INLINE double BitCost(size_t count) {
-  return count == 0 ? -2.0 : FastLog2(count);
-}
-
-#define HISTOGRAMS_PER_BATCH 64
-#define CLUSTERS_PER_BATCH 16
-
-#define FN(X) X ## Literal
-#define DataType uint8_t
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, DataType */
-
-#define HistogramType FN(Histogram)
-
-static void FN(InitialEntropyCodes)(const DataType* data, size_t length,
-                                    size_t stride,
-                                    size_t num_histograms,
-                                    HistogramType* histograms) {
-  uint32_t seed = 7;
-  size_t block_length = length / num_histograms;
-  size_t i;
-  FN(ClearHistograms)(histograms, num_histograms);
-  for (i = 0; i < num_histograms; ++i) {
-    size_t pos = length * i / num_histograms;
-    if (i != 0) {
-      pos += MyRand(&seed) % block_length;
-    }
-    if (pos + stride >= length) {
-      pos = length - stride - 1;
-    }
-    FN(HistogramAddVector)(&histograms[i], data + pos, stride);
-  }
-}
-
-static void FN(RandomSample)(uint32_t* seed,
-                             const DataType* data,
-                             size_t length,
-                             size_t stride,
-                             HistogramType* sample) {
-  size_t pos = 0;
-  if (stride >= length) {
-    stride = length;
-  } else {
-    pos = MyRand(seed) % (length - stride + 1);
-  }
-  FN(HistogramAddVector)(sample, data + pos, stride);
-}
-
-static void FN(RefineEntropyCodes)(const DataType* data, size_t length,
-                                   size_t stride,
-                                   size_t num_histograms,
-                                   HistogramType* histograms,
-                                   HistogramType* tmp) {
-  size_t iters =
-      kIterMulForRefining * length / stride + kMinItersForRefining;
-  uint32_t seed = 7;
-  size_t iter;
-  iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms;
-  for (iter = 0; iter < iters; ++iter) {
-    FN(HistogramClear)(tmp);
-    FN(RandomSample)(&seed, data, length, stride, tmp);
-    FN(HistogramAddHistogram)(&histograms[iter % num_histograms], tmp);
-  }
-}
-
-/* Assigns a block id from the range [0, num_histograms) to each data element
-   in data[0..length) and fills in block_id[0..length) with the assigned values.
-   Returns the number of blocks, i.e. one plus the number of block switches. */
-static size_t FN(FindBlocks)(const DataType* data, const size_t length,
-                             const double block_switch_bitcost,
-                             const size_t num_histograms,
-                             const HistogramType* histograms,
-                             double* insert_cost,
-                             double* cost,
-                             uint8_t* switch_signal,
-                             uint8_t* block_id) {
-  const size_t alphabet_size = FN(HistogramDataSize)();
-  const size_t bitmap_len = (num_histograms + 7) >> 3;
-  size_t num_blocks = 1;
-  size_t byte_ix;
-  size_t i;
-  size_t j;
-  BROTLI_DCHECK(num_histograms <= 256);
-
-  /* Trivial case: single historgram -> single block type. */
-  if (num_histograms <= 1) {
-    for (i = 0; i < length; ++i) {
-      block_id[i] = 0;
-    }
-    return 1;
-  }
-
-  /* Fill bitcost for each symbol of all histograms.
-   * Non-existing symbol cost: 2 + log2(total_count).
-   * Regular symbol cost: -log2(symbol_count / total_count). */
-  memset(insert_cost, 0,
-         sizeof(insert_cost[0]) * alphabet_size * num_histograms);
-  for (i = 0; i < num_histograms; ++i) {
-    insert_cost[i] = FastLog2((uint32_t)histograms[i].total_count_);
-  }
-  for (i = alphabet_size; i != 0;) {
-    /* Reverse order to use the 0-th row as a temporary storage. */
-    --i;
-    for (j = 0; j < num_histograms; ++j) {
-      insert_cost[i * num_histograms + j] =
-          insert_cost[j] - BitCost(histograms[j].data_[i]);
-    }
-  }
-
-  /* After each iteration of this loop, cost[k] will contain the difference
-     between the minimum cost of arriving at the current byte position using
-     entropy code k, and the minimum cost of arriving at the current byte
-     position. This difference is capped at the block switch cost, and if it
-     reaches block switch cost, it means that when we trace back from the last
-     position, we need to switch here. */
-  memset(cost, 0, sizeof(cost[0]) * num_histograms);
-  memset(switch_signal, 0, sizeof(switch_signal[0]) * length * bitmap_len);
-  for (byte_ix = 0; byte_ix < length; ++byte_ix) {
-    size_t ix = byte_ix * bitmap_len;
-    size_t symbol = data[byte_ix];
-    size_t insert_cost_ix = symbol * num_histograms;
-    double min_cost = 1e99;
-    double block_switch_cost = block_switch_bitcost;
-    size_t k;
-    for (k = 0; k < num_histograms; ++k) {
-      /* We are coding the symbol with entropy code k. */
-      cost[k] += insert_cost[insert_cost_ix + k];
-      if (cost[k] < min_cost) {
-        min_cost = cost[k];
-        block_id[byte_ix] = (uint8_t)k;
-      }
-    }
-    /* More blocks for the beginning. */
-    if (byte_ix < 2000) {
-      block_switch_cost *= 0.77 + 0.07 * (double)byte_ix / 2000;
-    }
-    for (k = 0; k < num_histograms; ++k) {
-      cost[k] -= min_cost;
-      if (cost[k] >= block_switch_cost) {
-        const uint8_t mask = (uint8_t)(1u << (k & 7));
-        cost[k] = block_switch_cost;
-        BROTLI_DCHECK((k >> 3) < bitmap_len);
-        switch_signal[ix + (k >> 3)] |= mask;
-      }
-    }
-  }
-
-  byte_ix = length - 1;
-  {  /* Trace back from the last position and switch at the marked places. */
-    size_t ix = byte_ix * bitmap_len;
-    uint8_t cur_id = block_id[byte_ix];
-    while (byte_ix > 0) {
-      const uint8_t mask = (uint8_t)(1u << (cur_id & 7));
-      BROTLI_DCHECK(((size_t)cur_id >> 3) < bitmap_len);
-      --byte_ix;
-      ix -= bitmap_len;
-      if (switch_signal[ix + (cur_id >> 3)] & mask) {
-        if (cur_id != block_id[byte_ix]) {
-          cur_id = block_id[byte_ix];
-          ++num_blocks;
-        }
-      }
-      block_id[byte_ix] = cur_id;
-    }
-  }
-  return num_blocks;
-}
-
-static size_t FN(RemapBlockIds)(uint8_t* block_ids, const size_t length,
-                                uint16_t* new_id, const size_t num_histograms) {
-  static const uint16_t kInvalidId = 256;
-  uint16_t next_id = 0;
-  size_t i;
-  for (i = 0; i < num_histograms; ++i) {
-    new_id[i] = kInvalidId;
-  }
-  for (i = 0; i < length; ++i) {
-    BROTLI_DCHECK(block_ids[i] < num_histograms);
-    if (new_id[block_ids[i]] == kInvalidId) {
-      new_id[block_ids[i]] = next_id++;
-    }
-  }
-  for (i = 0; i < length; ++i) {
-    block_ids[i] = (uint8_t)new_id[block_ids[i]];
-    BROTLI_DCHECK(block_ids[i] < num_histograms);
-  }
-  BROTLI_DCHECK(next_id <= num_histograms);
-  return next_id;
-}
-
-static void FN(BuildBlockHistograms)(const DataType* data, const size_t length,
-                                     const uint8_t* block_ids,
-                                     const size_t num_histograms,
-                                     HistogramType* histograms) {
-  size_t i;
-  FN(ClearHistograms)(histograms, num_histograms);
-  for (i = 0; i < length; ++i) {
-    FN(HistogramAdd)(&histograms[block_ids[i]], data[i]);
-  }
-}
-
-/* Given the initial partitioning build partitioning with limited number
- * of histograms (and block types). */
-static void FN(ClusterBlocks)(MemoryManager* m,
-                              const DataType* data, const size_t length,
-                              const size_t num_blocks,
-                              uint8_t* block_ids,
-                              BlockSplit* split) {
-  uint32_t* histogram_symbols = BROTLI_ALLOC(m, uint32_t, num_blocks);
-  uint32_t* u32 =
-      BROTLI_ALLOC(m, uint32_t, num_blocks + 4 * HISTOGRAMS_PER_BATCH);
-  const size_t expected_num_clusters = CLUSTERS_PER_BATCH *
-      (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH;
-  size_t all_histograms_size = 0;
-  size_t all_histograms_capacity = expected_num_clusters;
-  HistogramType* all_histograms =
-      BROTLI_ALLOC(m, HistogramType, all_histograms_capacity);
-  size_t cluster_size_size = 0;
-  size_t cluster_size_capacity = expected_num_clusters;
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, cluster_size_capacity);
-  size_t num_clusters = 0;
-  HistogramType* histograms = BROTLI_ALLOC(m, HistogramType,
-      BROTLI_MIN(size_t, num_blocks, HISTOGRAMS_PER_BATCH));
-  size_t max_num_pairs =
-      HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2;
-  size_t pairs_capacity = max_num_pairs + 1;
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity);
-  size_t pos = 0;
-  uint32_t* clusters;
-  size_t num_final_clusters;
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index;
-  size_t i;
-  uint32_t* BROTLI_RESTRICT const sizes = u32 + 0 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const new_clusters = u32 + 1 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const symbols = u32 + 2 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const remap = u32 + 3 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const block_lengths =
-      u32 + 4 * HISTOGRAMS_PER_BATCH;
-  /* TODO(eustas): move to arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 2);
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histogram_symbols) ||
-      BROTLI_IS_NULL(u32) || BROTLI_IS_NULL(all_histograms) ||
-      BROTLI_IS_NULL(cluster_size) || BROTLI_IS_NULL(histograms) ||
-      BROTLI_IS_NULL(pairs) || BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  memset(u32, 0, (num_blocks + 4 * HISTOGRAMS_PER_BATCH) * sizeof(uint32_t));
-
-  /* Calculate block lengths (convert repeating values -> series length). */
-  {
-    size_t block_idx = 0;
-    for (i = 0; i < length; ++i) {
-      BROTLI_DCHECK(block_idx < num_blocks);
-      ++block_lengths[block_idx];
-      if (i + 1 == length || block_ids[i] != block_ids[i + 1]) {
-        ++block_idx;
-      }
-    }
-    BROTLI_DCHECK(block_idx == num_blocks);
-  }
-
-  /* Pre-cluster blocks (cluster batches). */
-  for (i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH) {
-    const size_t num_to_combine =
-        BROTLI_MIN(size_t, num_blocks - i, HISTOGRAMS_PER_BATCH);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      size_t k;
-      size_t block_length = block_lengths[i + j];
-      FN(HistogramClear)(&histograms[j]);
-      for (k = 0; k < block_length; ++k) {
-        FN(HistogramAdd)(&histograms[j], data[pos++]);
-      }
-      histograms[j].bit_cost_ = FN(BrotliPopulationCost)(&histograms[j]);
-      new_clusters[j] = (uint32_t)j;
-      symbols[j] = (uint32_t)j;
-      sizes[j] = 1;
-    }
-    num_new_clusters = FN(BrotliHistogramCombine)(
-        histograms, tmp, sizes, symbols, new_clusters, pairs, num_to_combine,
-        num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs);
-    BROTLI_ENSURE_CAPACITY(m, HistogramType, all_histograms,
-        all_histograms_capacity, all_histograms_size + num_new_clusters);
-    BROTLI_ENSURE_CAPACITY(m, uint32_t, cluster_size,
-        cluster_size_capacity, cluster_size_size + num_new_clusters);
-    if (BROTLI_IS_OOM(m)) return;
-    for (j = 0; j < num_new_clusters; ++j) {
-      all_histograms[all_histograms_size++] = histograms[new_clusters[j]];
-      cluster_size[cluster_size_size++] = sizes[new_clusters[j]];
-      remap[new_clusters[j]] = (uint32_t)j;
-    }
-    for (j = 0; j < num_to_combine; ++j) {
-      histogram_symbols[i + j] = (uint32_t)num_clusters + remap[symbols[j]];
-    }
-    num_clusters += num_new_clusters;
-    BROTLI_DCHECK(num_clusters == cluster_size_size);
-    BROTLI_DCHECK(num_clusters == all_histograms_size);
-  }
-  BROTLI_FREE(m, histograms);
-
-  /* Final clustering. */
-  max_num_pairs =
-      BROTLI_MIN(size_t, 64 * num_clusters, (num_clusters / 2) * num_clusters);
-  if (pairs_capacity < max_num_pairs + 1) {
-    BROTLI_FREE(m, pairs);
-    pairs = BROTLI_ALLOC(m, HistogramPair, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(pairs)) return;
-  }
-  clusters = BROTLI_ALLOC(m, uint32_t, num_clusters);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(clusters)) return;
-  for (i = 0; i < num_clusters; ++i) {
-    clusters[i] = (uint32_t)i;
-  }
-  num_final_clusters = FN(BrotliHistogramCombine)(
-      all_histograms, tmp, cluster_size, histogram_symbols, clusters, pairs,
-      num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES,
-      max_num_pairs);
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-
-  /* Assign blocks to final histograms. */
-  new_index = BROTLI_ALLOC(m, uint32_t, num_clusters);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return;
-  for (i = 0; i < num_clusters; ++i) new_index[i] = kInvalidIndex;
-  pos = 0;
-  {
-    uint32_t next_index = 0;
-    for (i = 0; i < num_blocks; ++i) {
-      size_t j;
-      uint32_t best_out;
-      double best_bits;
-      FN(HistogramClear)(tmp);
-      for (j = 0; j < block_lengths[i]; ++j) {
-        FN(HistogramAdd)(tmp, data[pos++]);
-      }
-      /* Among equally good histograms prefer last used. */
-      /* TODO(eustas): should we give a block-switch discount here? */
-      best_out = (i == 0) ? histogram_symbols[0] : histogram_symbols[i - 1];
-      best_bits = FN(BrotliHistogramBitCostDistance)(
-          tmp, &all_histograms[best_out], tmp + 1);
-      for (j = 0; j < num_final_clusters; ++j) {
-        const double cur_bits = FN(BrotliHistogramBitCostDistance)(
-            tmp, &all_histograms[clusters[j]], tmp + 1);
-        if (cur_bits < best_bits) {
-          best_bits = cur_bits;
-          best_out = clusters[j];
-        }
-      }
-      histogram_symbols[i] = best_out;
-      if (new_index[best_out] == kInvalidIndex) {
-        new_index[best_out] = next_index++;
-      }
-    }
-  }
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  BROTLI_FREE(m, all_histograms);
-  BROTLI_ENSURE_CAPACITY(
-      m, uint8_t, split->types, split->types_alloc_size, num_blocks);
-  BROTLI_ENSURE_CAPACITY(
-      m, uint32_t, split->lengths, split->lengths_alloc_size, num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-
-  /* Rewrite final assignment to block-split. There might be less blocks
-   * than |num_blocks| due to clustering. */
-  {
-    uint32_t cur_length = 0;
-    size_t block_idx = 0;
-    uint8_t max_type = 0;
-    for (i = 0; i < num_blocks; ++i) {
-      cur_length += block_lengths[i];
-      if (i + 1 == num_blocks ||
-          histogram_symbols[i] != histogram_symbols[i + 1]) {
-        const uint8_t id = (uint8_t)new_index[histogram_symbols[i]];
-        split->types[block_idx] = id;
-        split->lengths[block_idx] = cur_length;
-        max_type = BROTLI_MAX(uint8_t, max_type, id);
-        cur_length = 0;
-        ++block_idx;
-      }
-    }
-    split->num_blocks = block_idx;
-    split->num_types = (size_t)max_type + 1;
-  }
-  BROTLI_FREE(m, new_index);
-  BROTLI_FREE(m, u32);
-  BROTLI_FREE(m, histogram_symbols);
-}
-
-/* Create BlockSplit (partitioning) given the limits, estimates and "effort"
- * parameters.
- *
- * NB: max_histograms is often less than number of histograms allowed by format;
- *     this is done intentionally, to save some "space" for context-aware
- *     clustering (here entropy is estimated for context-free symbols). */
-static void FN(SplitByteVector)(MemoryManager* m,
-                                const DataType* data, const size_t length,
-                                const size_t symbols_per_histogram,
-                                const size_t max_histograms,
-                                const size_t sampling_stride_length,
-                                const double block_switch_cost,
-                                const BrotliEncoderParams* params,
-                                BlockSplit* split) {
-  const size_t data_size = FN(HistogramDataSize)();
-  HistogramType* histograms;
-  HistogramType* tmp;
-  /* Calculate number of histograms; initial estimate is one histogram per
-   * specified amount of symbols; however, this value is capped. */
-  size_t num_histograms = length / symbols_per_histogram + 1;
-  if (num_histograms > max_histograms) {
-    num_histograms = max_histograms;
-  }
-
-  /* Corner case: no input. */
-  if (length == 0) {
-    split->num_types = 1;
-    return;
-  }
-
-  if (length < kMinLengthForBlockSplitting) {
-    BROTLI_ENSURE_CAPACITY(m, uint8_t,
-        split->types, split->types_alloc_size, split->num_blocks + 1);
-    BROTLI_ENSURE_CAPACITY(m, uint32_t,
-        split->lengths, split->lengths_alloc_size, split->num_blocks + 1);
-    if (BROTLI_IS_OOM(m)) return;
-    split->num_types = 1;
-    split->types[split->num_blocks] = 0;
-    split->lengths[split->num_blocks] = (uint32_t)length;
-    split->num_blocks++;
-    return;
-  }
-  histograms = BROTLI_ALLOC(m, HistogramType, num_histograms + 1);
-  tmp = histograms + num_histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histograms)) return;
-  /* Find good entropy codes. */
-  FN(InitialEntropyCodes)(data, length,
-                          sampling_stride_length,
-                          num_histograms, histograms);
-  FN(RefineEntropyCodes)(data, length,
-                         sampling_stride_length,
-                         num_histograms, histograms, tmp);
-  {
-    /* Find a good path through literals with the good entropy codes. */
-    uint8_t* block_ids = BROTLI_ALLOC(m, uint8_t, length);
-    size_t num_blocks = 0;
-    const size_t bitmaplen = (num_histograms + 7) >> 3;
-    double* insert_cost = BROTLI_ALLOC(m, double, data_size * num_histograms);
-    double* cost = BROTLI_ALLOC(m, double, num_histograms);
-    uint8_t* switch_signal = BROTLI_ALLOC(m, uint8_t, length * bitmaplen);
-    uint16_t* new_id = BROTLI_ALLOC(m, uint16_t, num_histograms);
-    const size_t iters = params->quality < HQ_ZOPFLIFICATION_QUALITY ? 3 : 10;
-    size_t i;
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(block_ids) ||
-        BROTLI_IS_NULL(insert_cost) || BROTLI_IS_NULL(cost) ||
-        BROTLI_IS_NULL(switch_signal) || BROTLI_IS_NULL(new_id)) {
-      return;
-    }
-    for (i = 0; i < iters; ++i) {
-      num_blocks = FN(FindBlocks)(data, length,
-                                  block_switch_cost,
-                                  num_histograms, histograms,
-                                  insert_cost, cost, switch_signal,
-                                  block_ids);
-      num_histograms = FN(RemapBlockIds)(block_ids, length,
-                                         new_id, num_histograms);
-      FN(BuildBlockHistograms)(data, length, block_ids,
-                               num_histograms, histograms);
-    }
-    BROTLI_FREE(m, insert_cost);
-    BROTLI_FREE(m, cost);
-    BROTLI_FREE(m, switch_signal);
-    BROTLI_FREE(m, new_id);
-    BROTLI_FREE(m, histograms);
-    FN(ClusterBlocks)(m, data, length, num_blocks, block_ids, split);
-    if (BROTLI_IS_OOM(m)) return;
-    BROTLI_FREE(m, block_ids);
-  }
-}
-
-#undef HistogramType
-#undef DataType
-#undef FN
-
-#define FN(X) X ## Command
-#define DataType uint16_t
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, DataType */
-
-#define HistogramType FN(Histogram)
-
-static void FN(InitialEntropyCodes)(const DataType* data, size_t length,
-                                    size_t stride,
-                                    size_t num_histograms,
-                                    HistogramType* histograms) {
-  uint32_t seed = 7;
-  size_t block_length = length / num_histograms;
-  size_t i;
-  FN(ClearHistograms)(histograms, num_histograms);
-  for (i = 0; i < num_histograms; ++i) {
-    size_t pos = length * i / num_histograms;
-    if (i != 0) {
-      pos += MyRand(&seed) % block_length;
-    }
-    if (pos + stride >= length) {
-      pos = length - stride - 1;
-    }
-    FN(HistogramAddVector)(&histograms[i], data + pos, stride);
-  }
-}
-
-static void FN(RandomSample)(uint32_t* seed,
-                             const DataType* data,
-                             size_t length,
-                             size_t stride,
-                             HistogramType* sample) {
-  size_t pos = 0;
-  if (stride >= length) {
-    stride = length;
-  } else {
-    pos = MyRand(seed) % (length - stride + 1);
-  }
-  FN(HistogramAddVector)(sample, data + pos, stride);
-}
-
-static void FN(RefineEntropyCodes)(const DataType* data, size_t length,
-                                   size_t stride,
-                                   size_t num_histograms,
-                                   HistogramType* histograms,
-                                   HistogramType* tmp) {
-  size_t iters =
-      kIterMulForRefining * length / stride + kMinItersForRefining;
-  uint32_t seed = 7;
-  size_t iter;
-  iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms;
-  for (iter = 0; iter < iters; ++iter) {
-    FN(HistogramClear)(tmp);
-    FN(RandomSample)(&seed, data, length, stride, tmp);
-    FN(HistogramAddHistogram)(&histograms[iter % num_histograms], tmp);
-  }
-}
-
-/* Assigns a block id from the range [0, num_histograms) to each data element
-   in data[0..length) and fills in block_id[0..length) with the assigned values.
-   Returns the number of blocks, i.e. one plus the number of block switches. */
-static size_t FN(FindBlocks)(const DataType* data, const size_t length,
-                             const double block_switch_bitcost,
-                             const size_t num_histograms,
-                             const HistogramType* histograms,
-                             double* insert_cost,
-                             double* cost,
-                             uint8_t* switch_signal,
-                             uint8_t* block_id) {
-  const size_t alphabet_size = FN(HistogramDataSize)();
-  const size_t bitmap_len = (num_histograms + 7) >> 3;
-  size_t num_blocks = 1;
-  size_t byte_ix;
-  size_t i;
-  size_t j;
-  BROTLI_DCHECK(num_histograms <= 256);
-
-  /* Trivial case: single historgram -> single block type. */
-  if (num_histograms <= 1) {
-    for (i = 0; i < length; ++i) {
-      block_id[i] = 0;
-    }
-    return 1;
-  }
-
-  /* Fill bitcost for each symbol of all histograms.
-   * Non-existing symbol cost: 2 + log2(total_count).
-   * Regular symbol cost: -log2(symbol_count / total_count). */
-  memset(insert_cost, 0,
-         sizeof(insert_cost[0]) * alphabet_size * num_histograms);
-  for (i = 0; i < num_histograms; ++i) {
-    insert_cost[i] = FastLog2((uint32_t)histograms[i].total_count_);
-  }
-  for (i = alphabet_size; i != 0;) {
-    /* Reverse order to use the 0-th row as a temporary storage. */
-    --i;
-    for (j = 0; j < num_histograms; ++j) {
-      insert_cost[i * num_histograms + j] =
-          insert_cost[j] - BitCost(histograms[j].data_[i]);
-    }
-  }
-
-  /* After each iteration of this loop, cost[k] will contain the difference
-     between the minimum cost of arriving at the current byte position using
-     entropy code k, and the minimum cost of arriving at the current byte
-     position. This difference is capped at the block switch cost, and if it
-     reaches block switch cost, it means that when we trace back from the last
-     position, we need to switch here. */
-  memset(cost, 0, sizeof(cost[0]) * num_histograms);
-  memset(switch_signal, 0, sizeof(switch_signal[0]) * length * bitmap_len);
-  for (byte_ix = 0; byte_ix < length; ++byte_ix) {
-    size_t ix = byte_ix * bitmap_len;
-    size_t symbol = data[byte_ix];
-    size_t insert_cost_ix = symbol * num_histograms;
-    double min_cost = 1e99;
-    double block_switch_cost = block_switch_bitcost;
-    size_t k;
-    for (k = 0; k < num_histograms; ++k) {
-      /* We are coding the symbol with entropy code k. */
-      cost[k] += insert_cost[insert_cost_ix + k];
-      if (cost[k] < min_cost) {
-        min_cost = cost[k];
-        block_id[byte_ix] = (uint8_t)k;
-      }
-    }
-    /* More blocks for the beginning. */
-    if (byte_ix < 2000) {
-      block_switch_cost *= 0.77 + 0.07 * (double)byte_ix / 2000;
-    }
-    for (k = 0; k < num_histograms; ++k) {
-      cost[k] -= min_cost;
-      if (cost[k] >= block_switch_cost) {
-        const uint8_t mask = (uint8_t)(1u << (k & 7));
-        cost[k] = block_switch_cost;
-        BROTLI_DCHECK((k >> 3) < bitmap_len);
-        switch_signal[ix + (k >> 3)] |= mask;
-      }
-    }
-  }
-
-  byte_ix = length - 1;
-  {  /* Trace back from the last position and switch at the marked places. */
-    size_t ix = byte_ix * bitmap_len;
-    uint8_t cur_id = block_id[byte_ix];
-    while (byte_ix > 0) {
-      const uint8_t mask = (uint8_t)(1u << (cur_id & 7));
-      BROTLI_DCHECK(((size_t)cur_id >> 3) < bitmap_len);
-      --byte_ix;
-      ix -= bitmap_len;
-      if (switch_signal[ix + (cur_id >> 3)] & mask) {
-        if (cur_id != block_id[byte_ix]) {
-          cur_id = block_id[byte_ix];
-          ++num_blocks;
-        }
-      }
-      block_id[byte_ix] = cur_id;
-    }
-  }
-  return num_blocks;
-}
-
-static size_t FN(RemapBlockIds)(uint8_t* block_ids, const size_t length,
-                                uint16_t* new_id, const size_t num_histograms) {
-  static const uint16_t kInvalidId = 256;
-  uint16_t next_id = 0;
-  size_t i;
-  for (i = 0; i < num_histograms; ++i) {
-    new_id[i] = kInvalidId;
-  }
-  for (i = 0; i < length; ++i) {
-    BROTLI_DCHECK(block_ids[i] < num_histograms);
-    if (new_id[block_ids[i]] == kInvalidId) {
-      new_id[block_ids[i]] = next_id++;
-    }
-  }
-  for (i = 0; i < length; ++i) {
-    block_ids[i] = (uint8_t)new_id[block_ids[i]];
-    BROTLI_DCHECK(block_ids[i] < num_histograms);
-  }
-  BROTLI_DCHECK(next_id <= num_histograms);
-  return next_id;
-}
-
-static void FN(BuildBlockHistograms)(const DataType* data, const size_t length,
-                                     const uint8_t* block_ids,
-                                     const size_t num_histograms,
-                                     HistogramType* histograms) {
-  size_t i;
-  FN(ClearHistograms)(histograms, num_histograms);
-  for (i = 0; i < length; ++i) {
-    FN(HistogramAdd)(&histograms[block_ids[i]], data[i]);
-  }
-}
-
-/* Given the initial partitioning build partitioning with limited number
- * of histograms (and block types). */
-static void FN(ClusterBlocks)(MemoryManager* m,
-                              const DataType* data, const size_t length,
-                              const size_t num_blocks,
-                              uint8_t* block_ids,
-                              BlockSplit* split) {
-  uint32_t* histogram_symbols = BROTLI_ALLOC(m, uint32_t, num_blocks);
-  uint32_t* u32 =
-      BROTLI_ALLOC(m, uint32_t, num_blocks + 4 * HISTOGRAMS_PER_BATCH);
-  const size_t expected_num_clusters = CLUSTERS_PER_BATCH *
-      (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH;
-  size_t all_histograms_size = 0;
-  size_t all_histograms_capacity = expected_num_clusters;
-  HistogramType* all_histograms =
-      BROTLI_ALLOC(m, HistogramType, all_histograms_capacity);
-  size_t cluster_size_size = 0;
-  size_t cluster_size_capacity = expected_num_clusters;
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, cluster_size_capacity);
-  size_t num_clusters = 0;
-  HistogramType* histograms = BROTLI_ALLOC(m, HistogramType,
-      BROTLI_MIN(size_t, num_blocks, HISTOGRAMS_PER_BATCH));
-  size_t max_num_pairs =
-      HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2;
-  size_t pairs_capacity = max_num_pairs + 1;
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity);
-  size_t pos = 0;
-  uint32_t* clusters;
-  size_t num_final_clusters;
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index;
-  size_t i;
-  uint32_t* BROTLI_RESTRICT const sizes = u32 + 0 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const new_clusters = u32 + 1 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const symbols = u32 + 2 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const remap = u32 + 3 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const block_lengths =
-      u32 + 4 * HISTOGRAMS_PER_BATCH;
-  /* TODO(eustas): move to arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 2);
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histogram_symbols) ||
-      BROTLI_IS_NULL(u32) || BROTLI_IS_NULL(all_histograms) ||
-      BROTLI_IS_NULL(cluster_size) || BROTLI_IS_NULL(histograms) ||
-      BROTLI_IS_NULL(pairs) || BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  memset(u32, 0, (num_blocks + 4 * HISTOGRAMS_PER_BATCH) * sizeof(uint32_t));
-
-  /* Calculate block lengths (convert repeating values -> series length). */
-  {
-    size_t block_idx = 0;
-    for (i = 0; i < length; ++i) {
-      BROTLI_DCHECK(block_idx < num_blocks);
-      ++block_lengths[block_idx];
-      if (i + 1 == length || block_ids[i] != block_ids[i + 1]) {
-        ++block_idx;
-      }
-    }
-    BROTLI_DCHECK(block_idx == num_blocks);
-  }
-
-  /* Pre-cluster blocks (cluster batches). */
-  for (i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH) {
-    const size_t num_to_combine =
-        BROTLI_MIN(size_t, num_blocks - i, HISTOGRAMS_PER_BATCH);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      size_t k;
-      size_t block_length = block_lengths[i + j];
-      FN(HistogramClear)(&histograms[j]);
-      for (k = 0; k < block_length; ++k) {
-        FN(HistogramAdd)(&histograms[j], data[pos++]);
-      }
-      histograms[j].bit_cost_ = FN(BrotliPopulationCost)(&histograms[j]);
-      new_clusters[j] = (uint32_t)j;
-      symbols[j] = (uint32_t)j;
-      sizes[j] = 1;
-    }
-    num_new_clusters = FN(BrotliHistogramCombine)(
-        histograms, tmp, sizes, symbols, new_clusters, pairs, num_to_combine,
-        num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs);
-    BROTLI_ENSURE_CAPACITY(m, HistogramType, all_histograms,
-        all_histograms_capacity, all_histograms_size + num_new_clusters);
-    BROTLI_ENSURE_CAPACITY(m, uint32_t, cluster_size,
-        cluster_size_capacity, cluster_size_size + num_new_clusters);
-    if (BROTLI_IS_OOM(m)) return;
-    for (j = 0; j < num_new_clusters; ++j) {
-      all_histograms[all_histograms_size++] = histograms[new_clusters[j]];
-      cluster_size[cluster_size_size++] = sizes[new_clusters[j]];
-      remap[new_clusters[j]] = (uint32_t)j;
-    }
-    for (j = 0; j < num_to_combine; ++j) {
-      histogram_symbols[i + j] = (uint32_t)num_clusters + remap[symbols[j]];
-    }
-    num_clusters += num_new_clusters;
-    BROTLI_DCHECK(num_clusters == cluster_size_size);
-    BROTLI_DCHECK(num_clusters == all_histograms_size);
-  }
-  BROTLI_FREE(m, histograms);
-
-  /* Final clustering. */
-  max_num_pairs =
-      BROTLI_MIN(size_t, 64 * num_clusters, (num_clusters / 2) * num_clusters);
-  if (pairs_capacity < max_num_pairs + 1) {
-    BROTLI_FREE(m, pairs);
-    pairs = BROTLI_ALLOC(m, HistogramPair, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(pairs)) return;
-  }
-  clusters = BROTLI_ALLOC(m, uint32_t, num_clusters);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(clusters)) return;
-  for (i = 0; i < num_clusters; ++i) {
-    clusters[i] = (uint32_t)i;
-  }
-  num_final_clusters = FN(BrotliHistogramCombine)(
-      all_histograms, tmp, cluster_size, histogram_symbols, clusters, pairs,
-      num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES,
-      max_num_pairs);
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-
-  /* Assign blocks to final histograms. */
-  new_index = BROTLI_ALLOC(m, uint32_t, num_clusters);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return;
-  for (i = 0; i < num_clusters; ++i) new_index[i] = kInvalidIndex;
-  pos = 0;
-  {
-    uint32_t next_index = 0;
-    for (i = 0; i < num_blocks; ++i) {
-      size_t j;
-      uint32_t best_out;
-      double best_bits;
-      FN(HistogramClear)(tmp);
-      for (j = 0; j < block_lengths[i]; ++j) {
-        FN(HistogramAdd)(tmp, data[pos++]);
-      }
-      /* Among equally good histograms prefer last used. */
-      /* TODO(eustas): should we give a block-switch discount here? */
-      best_out = (i == 0) ? histogram_symbols[0] : histogram_symbols[i - 1];
-      best_bits = FN(BrotliHistogramBitCostDistance)(
-          tmp, &all_histograms[best_out], tmp + 1);
-      for (j = 0; j < num_final_clusters; ++j) {
-        const double cur_bits = FN(BrotliHistogramBitCostDistance)(
-            tmp, &all_histograms[clusters[j]], tmp + 1);
-        if (cur_bits < best_bits) {
-          best_bits = cur_bits;
-          best_out = clusters[j];
-        }
-      }
-      histogram_symbols[i] = best_out;
-      if (new_index[best_out] == kInvalidIndex) {
-        new_index[best_out] = next_index++;
-      }
-    }
-  }
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  BROTLI_FREE(m, all_histograms);
-  BROTLI_ENSURE_CAPACITY(
-      m, uint8_t, split->types, split->types_alloc_size, num_blocks);
-  BROTLI_ENSURE_CAPACITY(
-      m, uint32_t, split->lengths, split->lengths_alloc_size, num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-
-  /* Rewrite final assignment to block-split. There might be less blocks
-   * than |num_blocks| due to clustering. */
-  {
-    uint32_t cur_length = 0;
-    size_t block_idx = 0;
-    uint8_t max_type = 0;
-    for (i = 0; i < num_blocks; ++i) {
-      cur_length += block_lengths[i];
-      if (i + 1 == num_blocks ||
-          histogram_symbols[i] != histogram_symbols[i + 1]) {
-        const uint8_t id = (uint8_t)new_index[histogram_symbols[i]];
-        split->types[block_idx] = id;
-        split->lengths[block_idx] = cur_length;
-        max_type = BROTLI_MAX(uint8_t, max_type, id);
-        cur_length = 0;
-        ++block_idx;
-      }
-    }
-    split->num_blocks = block_idx;
-    split->num_types = (size_t)max_type + 1;
-  }
-  BROTLI_FREE(m, new_index);
-  BROTLI_FREE(m, u32);
-  BROTLI_FREE(m, histogram_symbols);
-}
-
-/* Create BlockSplit (partitioning) given the limits, estimates and "effort"
- * parameters.
- *
- * NB: max_histograms is often less than number of histograms allowed by format;
- *     this is done intentionally, to save some "space" for context-aware
- *     clustering (here entropy is estimated for context-free symbols). */
-static void FN(SplitByteVector)(MemoryManager* m,
-                                const DataType* data, const size_t length,
-                                const size_t symbols_per_histogram,
-                                const size_t max_histograms,
-                                const size_t sampling_stride_length,
-                                const double block_switch_cost,
-                                const BrotliEncoderParams* params,
-                                BlockSplit* split) {
-  const size_t data_size = FN(HistogramDataSize)();
-  HistogramType* histograms;
-  HistogramType* tmp;
-  /* Calculate number of histograms; initial estimate is one histogram per
-   * specified amount of symbols; however, this value is capped. */
-  size_t num_histograms = length / symbols_per_histogram + 1;
-  if (num_histograms > max_histograms) {
-    num_histograms = max_histograms;
-  }
-
-  /* Corner case: no input. */
-  if (length == 0) {
-    split->num_types = 1;
-    return;
-  }
-
-  if (length < kMinLengthForBlockSplitting) {
-    BROTLI_ENSURE_CAPACITY(m, uint8_t,
-        split->types, split->types_alloc_size, split->num_blocks + 1);
-    BROTLI_ENSURE_CAPACITY(m, uint32_t,
-        split->lengths, split->lengths_alloc_size, split->num_blocks + 1);
-    if (BROTLI_IS_OOM(m)) return;
-    split->num_types = 1;
-    split->types[split->num_blocks] = 0;
-    split->lengths[split->num_blocks] = (uint32_t)length;
-    split->num_blocks++;
-    return;
-  }
-  histograms = BROTLI_ALLOC(m, HistogramType, num_histograms + 1);
-  tmp = histograms + num_histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histograms)) return;
-  /* Find good entropy codes. */
-  FN(InitialEntropyCodes)(data, length,
-                          sampling_stride_length,
-                          num_histograms, histograms);
-  FN(RefineEntropyCodes)(data, length,
-                         sampling_stride_length,
-                         num_histograms, histograms, tmp);
-  {
-    /* Find a good path through literals with the good entropy codes. */
-    uint8_t* block_ids = BROTLI_ALLOC(m, uint8_t, length);
-    size_t num_blocks = 0;
-    const size_t bitmaplen = (num_histograms + 7) >> 3;
-    double* insert_cost = BROTLI_ALLOC(m, double, data_size * num_histograms);
-    double* cost = BROTLI_ALLOC(m, double, num_histograms);
-    uint8_t* switch_signal = BROTLI_ALLOC(m, uint8_t, length * bitmaplen);
-    uint16_t* new_id = BROTLI_ALLOC(m, uint16_t, num_histograms);
-    const size_t iters = params->quality < HQ_ZOPFLIFICATION_QUALITY ? 3 : 10;
-    size_t i;
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(block_ids) ||
-        BROTLI_IS_NULL(insert_cost) || BROTLI_IS_NULL(cost) ||
-        BROTLI_IS_NULL(switch_signal) || BROTLI_IS_NULL(new_id)) {
-      return;
-    }
-    for (i = 0; i < iters; ++i) {
-      num_blocks = FN(FindBlocks)(data, length,
-                                  block_switch_cost,
-                                  num_histograms, histograms,
-                                  insert_cost, cost, switch_signal,
-                                  block_ids);
-      num_histograms = FN(RemapBlockIds)(block_ids, length,
-                                         new_id, num_histograms);
-      FN(BuildBlockHistograms)(data, length, block_ids,
-                               num_histograms, histograms);
-    }
-    BROTLI_FREE(m, insert_cost);
-    BROTLI_FREE(m, cost);
-    BROTLI_FREE(m, switch_signal);
-    BROTLI_FREE(m, new_id);
-    BROTLI_FREE(m, histograms);
-    FN(ClusterBlocks)(m, data, length, num_blocks, block_ids, split);
-    if (BROTLI_IS_OOM(m)) return;
-    BROTLI_FREE(m, block_ids);
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Distance
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, DataType */
-
-#define HistogramType FN(Histogram)
-
-static void FN(InitialEntropyCodes)(const DataType* data, size_t length,
-                                    size_t stride,
-                                    size_t num_histograms,
-                                    HistogramType* histograms) {
-  uint32_t seed = 7;
-  size_t block_length = length / num_histograms;
-  size_t i;
-  FN(ClearHistograms)(histograms, num_histograms);
-  for (i = 0; i < num_histograms; ++i) {
-    size_t pos = length * i / num_histograms;
-    if (i != 0) {
-      pos += MyRand(&seed) % block_length;
-    }
-    if (pos + stride >= length) {
-      pos = length - stride - 1;
-    }
-    FN(HistogramAddVector)(&histograms[i], data + pos, stride);
-  }
-}
-
-static void FN(RandomSample)(uint32_t* seed,
-                             const DataType* data,
-                             size_t length,
-                             size_t stride,
-                             HistogramType* sample) {
-  size_t pos = 0;
-  if (stride >= length) {
-    stride = length;
-  } else {
-    pos = MyRand(seed) % (length - stride + 1);
-  }
-  FN(HistogramAddVector)(sample, data + pos, stride);
-}
-
-static void FN(RefineEntropyCodes)(const DataType* data, size_t length,
-                                   size_t stride,
-                                   size_t num_histograms,
-                                   HistogramType* histograms,
-                                   HistogramType* tmp) {
-  size_t iters =
-      kIterMulForRefining * length / stride + kMinItersForRefining;
-  uint32_t seed = 7;
-  size_t iter;
-  iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms;
-  for (iter = 0; iter < iters; ++iter) {
-    FN(HistogramClear)(tmp);
-    FN(RandomSample)(&seed, data, length, stride, tmp);
-    FN(HistogramAddHistogram)(&histograms[iter % num_histograms], tmp);
-  }
-}
-
-/* Assigns a block id from the range [0, num_histograms) to each data element
-   in data[0..length) and fills in block_id[0..length) with the assigned values.
-   Returns the number of blocks, i.e. one plus the number of block switches. */
-static size_t FN(FindBlocks)(const DataType* data, const size_t length,
-                             const double block_switch_bitcost,
-                             const size_t num_histograms,
-                             const HistogramType* histograms,
-                             double* insert_cost,
-                             double* cost,
-                             uint8_t* switch_signal,
-                             uint8_t* block_id) {
-  const size_t alphabet_size = FN(HistogramDataSize)();
-  const size_t bitmap_len = (num_histograms + 7) >> 3;
-  size_t num_blocks = 1;
-  size_t byte_ix;
-  size_t i;
-  size_t j;
-  BROTLI_DCHECK(num_histograms <= 256);
-
-  /* Trivial case: single historgram -> single block type. */
-  if (num_histograms <= 1) {
-    for (i = 0; i < length; ++i) {
-      block_id[i] = 0;
-    }
-    return 1;
-  }
-
-  /* Fill bitcost for each symbol of all histograms.
-   * Non-existing symbol cost: 2 + log2(total_count).
-   * Regular symbol cost: -log2(symbol_count / total_count). */
-  memset(insert_cost, 0,
-         sizeof(insert_cost[0]) * alphabet_size * num_histograms);
-  for (i = 0; i < num_histograms; ++i) {
-    insert_cost[i] = FastLog2((uint32_t)histograms[i].total_count_);
-  }
-  for (i = alphabet_size; i != 0;) {
-    /* Reverse order to use the 0-th row as a temporary storage. */
-    --i;
-    for (j = 0; j < num_histograms; ++j) {
-      insert_cost[i * num_histograms + j] =
-          insert_cost[j] - BitCost(histograms[j].data_[i]);
-    }
-  }
-
-  /* After each iteration of this loop, cost[k] will contain the difference
-     between the minimum cost of arriving at the current byte position using
-     entropy code k, and the minimum cost of arriving at the current byte
-     position. This difference is capped at the block switch cost, and if it
-     reaches block switch cost, it means that when we trace back from the last
-     position, we need to switch here. */
-  memset(cost, 0, sizeof(cost[0]) * num_histograms);
-  memset(switch_signal, 0, sizeof(switch_signal[0]) * length * bitmap_len);
-  for (byte_ix = 0; byte_ix < length; ++byte_ix) {
-    size_t ix = byte_ix * bitmap_len;
-    size_t symbol = data[byte_ix];
-    size_t insert_cost_ix = symbol * num_histograms;
-    double min_cost = 1e99;
-    double block_switch_cost = block_switch_bitcost;
-    size_t k;
-    for (k = 0; k < num_histograms; ++k) {
-      /* We are coding the symbol with entropy code k. */
-      cost[k] += insert_cost[insert_cost_ix + k];
-      if (cost[k] < min_cost) {
-        min_cost = cost[k];
-        block_id[byte_ix] = (uint8_t)k;
-      }
-    }
-    /* More blocks for the beginning. */
-    if (byte_ix < 2000) {
-      block_switch_cost *= 0.77 + 0.07 * (double)byte_ix / 2000;
-    }
-    for (k = 0; k < num_histograms; ++k) {
-      cost[k] -= min_cost;
-      if (cost[k] >= block_switch_cost) {
-        const uint8_t mask = (uint8_t)(1u << (k & 7));
-        cost[k] = block_switch_cost;
-        BROTLI_DCHECK((k >> 3) < bitmap_len);
-        switch_signal[ix + (k >> 3)] |= mask;
-      }
-    }
-  }
-
-  byte_ix = length - 1;
-  {  /* Trace back from the last position and switch at the marked places. */
-    size_t ix = byte_ix * bitmap_len;
-    uint8_t cur_id = block_id[byte_ix];
-    while (byte_ix > 0) {
-      const uint8_t mask = (uint8_t)(1u << (cur_id & 7));
-      BROTLI_DCHECK(((size_t)cur_id >> 3) < bitmap_len);
-      --byte_ix;
-      ix -= bitmap_len;
-      if (switch_signal[ix + (cur_id >> 3)] & mask) {
-        if (cur_id != block_id[byte_ix]) {
-          cur_id = block_id[byte_ix];
-          ++num_blocks;
-        }
-      }
-      block_id[byte_ix] = cur_id;
-    }
-  }
-  return num_blocks;
-}
-
-static size_t FN(RemapBlockIds)(uint8_t* block_ids, const size_t length,
-                                uint16_t* new_id, const size_t num_histograms) {
-  static const uint16_t kInvalidId = 256;
-  uint16_t next_id = 0;
-  size_t i;
-  for (i = 0; i < num_histograms; ++i) {
-    new_id[i] = kInvalidId;
-  }
-  for (i = 0; i < length; ++i) {
-    BROTLI_DCHECK(block_ids[i] < num_histograms);
-    if (new_id[block_ids[i]] == kInvalidId) {
-      new_id[block_ids[i]] = next_id++;
-    }
-  }
-  for (i = 0; i < length; ++i) {
-    block_ids[i] = (uint8_t)new_id[block_ids[i]];
-    BROTLI_DCHECK(block_ids[i] < num_histograms);
-  }
-  BROTLI_DCHECK(next_id <= num_histograms);
-  return next_id;
-}
-
-static void FN(BuildBlockHistograms)(const DataType* data, const size_t length,
-                                     const uint8_t* block_ids,
-                                     const size_t num_histograms,
-                                     HistogramType* histograms) {
-  size_t i;
-  FN(ClearHistograms)(histograms, num_histograms);
-  for (i = 0; i < length; ++i) {
-    FN(HistogramAdd)(&histograms[block_ids[i]], data[i]);
-  }
-}
-
-/* Given the initial partitioning build partitioning with limited number
- * of histograms (and block types). */
-static void FN(ClusterBlocks)(MemoryManager* m,
-                              const DataType* data, const size_t length,
-                              const size_t num_blocks,
-                              uint8_t* block_ids,
-                              BlockSplit* split) {
-  uint32_t* histogram_symbols = BROTLI_ALLOC(m, uint32_t, num_blocks);
-  uint32_t* u32 =
-      BROTLI_ALLOC(m, uint32_t, num_blocks + 4 * HISTOGRAMS_PER_BATCH);
-  const size_t expected_num_clusters = CLUSTERS_PER_BATCH *
-      (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH;
-  size_t all_histograms_size = 0;
-  size_t all_histograms_capacity = expected_num_clusters;
-  HistogramType* all_histograms =
-      BROTLI_ALLOC(m, HistogramType, all_histograms_capacity);
-  size_t cluster_size_size = 0;
-  size_t cluster_size_capacity = expected_num_clusters;
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, cluster_size_capacity);
-  size_t num_clusters = 0;
-  HistogramType* histograms = BROTLI_ALLOC(m, HistogramType,
-      BROTLI_MIN(size_t, num_blocks, HISTOGRAMS_PER_BATCH));
-  size_t max_num_pairs =
-      HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2;
-  size_t pairs_capacity = max_num_pairs + 1;
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity);
-  size_t pos = 0;
-  uint32_t* clusters;
-  size_t num_final_clusters;
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index;
-  size_t i;
-  uint32_t* BROTLI_RESTRICT const sizes = u32 + 0 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const new_clusters = u32 + 1 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const symbols = u32 + 2 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const remap = u32 + 3 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const block_lengths =
-      u32 + 4 * HISTOGRAMS_PER_BATCH;
-  /* TODO(eustas): move to arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 2);
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histogram_symbols) ||
-      BROTLI_IS_NULL(u32) || BROTLI_IS_NULL(all_histograms) ||
-      BROTLI_IS_NULL(cluster_size) || BROTLI_IS_NULL(histograms) ||
-      BROTLI_IS_NULL(pairs) || BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  memset(u32, 0, (num_blocks + 4 * HISTOGRAMS_PER_BATCH) * sizeof(uint32_t));
-
-  /* Calculate block lengths (convert repeating values -> series length). */
-  {
-    size_t block_idx = 0;
-    for (i = 0; i < length; ++i) {
-      BROTLI_DCHECK(block_idx < num_blocks);
-      ++block_lengths[block_idx];
-      if (i + 1 == length || block_ids[i] != block_ids[i + 1]) {
-        ++block_idx;
-      }
-    }
-    BROTLI_DCHECK(block_idx == num_blocks);
-  }
-
-  /* Pre-cluster blocks (cluster batches). */
-  for (i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH) {
-    const size_t num_to_combine =
-        BROTLI_MIN(size_t, num_blocks - i, HISTOGRAMS_PER_BATCH);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      size_t k;
-      size_t block_length = block_lengths[i + j];
-      FN(HistogramClear)(&histograms[j]);
-      for (k = 0; k < block_length; ++k) {
-        FN(HistogramAdd)(&histograms[j], data[pos++]);
-      }
-      histograms[j].bit_cost_ = FN(BrotliPopulationCost)(&histograms[j]);
-      new_clusters[j] = (uint32_t)j;
-      symbols[j] = (uint32_t)j;
-      sizes[j] = 1;
-    }
-    num_new_clusters = FN(BrotliHistogramCombine)(
-        histograms, tmp, sizes, symbols, new_clusters, pairs, num_to_combine,
-        num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs);
-    BROTLI_ENSURE_CAPACITY(m, HistogramType, all_histograms,
-        all_histograms_capacity, all_histograms_size + num_new_clusters);
-    BROTLI_ENSURE_CAPACITY(m, uint32_t, cluster_size,
-        cluster_size_capacity, cluster_size_size + num_new_clusters);
-    if (BROTLI_IS_OOM(m)) return;
-    for (j = 0; j < num_new_clusters; ++j) {
-      all_histograms[all_histograms_size++] = histograms[new_clusters[j]];
-      cluster_size[cluster_size_size++] = sizes[new_clusters[j]];
-      remap[new_clusters[j]] = (uint32_t)j;
-    }
-    for (j = 0; j < num_to_combine; ++j) {
-      histogram_symbols[i + j] = (uint32_t)num_clusters + remap[symbols[j]];
-    }
-    num_clusters += num_new_clusters;
-    BROTLI_DCHECK(num_clusters == cluster_size_size);
-    BROTLI_DCHECK(num_clusters == all_histograms_size);
-  }
-  BROTLI_FREE(m, histograms);
-
-  /* Final clustering. */
-  max_num_pairs =
-      BROTLI_MIN(size_t, 64 * num_clusters, (num_clusters / 2) * num_clusters);
-  if (pairs_capacity < max_num_pairs + 1) {
-    BROTLI_FREE(m, pairs);
-    pairs = BROTLI_ALLOC(m, HistogramPair, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(pairs)) return;
-  }
-  clusters = BROTLI_ALLOC(m, uint32_t, num_clusters);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(clusters)) return;
-  for (i = 0; i < num_clusters; ++i) {
-    clusters[i] = (uint32_t)i;
-  }
-  num_final_clusters = FN(BrotliHistogramCombine)(
-      all_histograms, tmp, cluster_size, histogram_symbols, clusters, pairs,
-      num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES,
-      max_num_pairs);
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-
-  /* Assign blocks to final histograms. */
-  new_index = BROTLI_ALLOC(m, uint32_t, num_clusters);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return;
-  for (i = 0; i < num_clusters; ++i) new_index[i] = kInvalidIndex;
-  pos = 0;
-  {
-    uint32_t next_index = 0;
-    for (i = 0; i < num_blocks; ++i) {
-      size_t j;
-      uint32_t best_out;
-      double best_bits;
-      FN(HistogramClear)(tmp);
-      for (j = 0; j < block_lengths[i]; ++j) {
-        FN(HistogramAdd)(tmp, data[pos++]);
-      }
-      /* Among equally good histograms prefer last used. */
-      /* TODO(eustas): should we give a block-switch discount here? */
-      best_out = (i == 0) ? histogram_symbols[0] : histogram_symbols[i - 1];
-      best_bits = FN(BrotliHistogramBitCostDistance)(
-          tmp, &all_histograms[best_out], tmp + 1);
-      for (j = 0; j < num_final_clusters; ++j) {
-        const double cur_bits = FN(BrotliHistogramBitCostDistance)(
-            tmp, &all_histograms[clusters[j]], tmp + 1);
-        if (cur_bits < best_bits) {
-          best_bits = cur_bits;
-          best_out = clusters[j];
-        }
-      }
-      histogram_symbols[i] = best_out;
-      if (new_index[best_out] == kInvalidIndex) {
-        new_index[best_out] = next_index++;
-      }
-    }
-  }
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  BROTLI_FREE(m, all_histograms);
-  BROTLI_ENSURE_CAPACITY(
-      m, uint8_t, split->types, split->types_alloc_size, num_blocks);
-  BROTLI_ENSURE_CAPACITY(
-      m, uint32_t, split->lengths, split->lengths_alloc_size, num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-
-  /* Rewrite final assignment to block-split. There might be less blocks
-   * than |num_blocks| due to clustering. */
-  {
-    uint32_t cur_length = 0;
-    size_t block_idx = 0;
-    uint8_t max_type = 0;
-    for (i = 0; i < num_blocks; ++i) {
-      cur_length += block_lengths[i];
-      if (i + 1 == num_blocks ||
-          histogram_symbols[i] != histogram_symbols[i + 1]) {
-        const uint8_t id = (uint8_t)new_index[histogram_symbols[i]];
-        split->types[block_idx] = id;
-        split->lengths[block_idx] = cur_length;
-        max_type = BROTLI_MAX(uint8_t, max_type, id);
-        cur_length = 0;
-        ++block_idx;
-      }
-    }
-    split->num_blocks = block_idx;
-    split->num_types = (size_t)max_type + 1;
-  }
-  BROTLI_FREE(m, new_index);
-  BROTLI_FREE(m, u32);
-  BROTLI_FREE(m, histogram_symbols);
-}
-
-/* Create BlockSplit (partitioning) given the limits, estimates and "effort"
- * parameters.
- *
- * NB: max_histograms is often less than number of histograms allowed by format;
- *     this is done intentionally, to save some "space" for context-aware
- *     clustering (here entropy is estimated for context-free symbols). */
-static void FN(SplitByteVector)(MemoryManager* m,
-                                const DataType* data, const size_t length,
-                                const size_t symbols_per_histogram,
-                                const size_t max_histograms,
-                                const size_t sampling_stride_length,
-                                const double block_switch_cost,
-                                const BrotliEncoderParams* params,
-                                BlockSplit* split) {
-  const size_t data_size = FN(HistogramDataSize)();
-  HistogramType* histograms;
-  HistogramType* tmp;
-  /* Calculate number of histograms; initial estimate is one histogram per
-   * specified amount of symbols; however, this value is capped. */
-  size_t num_histograms = length / symbols_per_histogram + 1;
-  if (num_histograms > max_histograms) {
-    num_histograms = max_histograms;
-  }
-
-  /* Corner case: no input. */
-  if (length == 0) {
-    split->num_types = 1;
-    return;
-  }
-
-  if (length < kMinLengthForBlockSplitting) {
-    BROTLI_ENSURE_CAPACITY(m, uint8_t,
-        split->types, split->types_alloc_size, split->num_blocks + 1);
-    BROTLI_ENSURE_CAPACITY(m, uint32_t,
-        split->lengths, split->lengths_alloc_size, split->num_blocks + 1);
-    if (BROTLI_IS_OOM(m)) return;
-    split->num_types = 1;
-    split->types[split->num_blocks] = 0;
-    split->lengths[split->num_blocks] = (uint32_t)length;
-    split->num_blocks++;
-    return;
-  }
-  histograms = BROTLI_ALLOC(m, HistogramType, num_histograms + 1);
-  tmp = histograms + num_histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histograms)) return;
-  /* Find good entropy codes. */
-  FN(InitialEntropyCodes)(data, length,
-                          sampling_stride_length,
-                          num_histograms, histograms);
-  FN(RefineEntropyCodes)(data, length,
-                         sampling_stride_length,
-                         num_histograms, histograms, tmp);
-  {
-    /* Find a good path through literals with the good entropy codes. */
-    uint8_t* block_ids = BROTLI_ALLOC(m, uint8_t, length);
-    size_t num_blocks = 0;
-    const size_t bitmaplen = (num_histograms + 7) >> 3;
-    double* insert_cost = BROTLI_ALLOC(m, double, data_size * num_histograms);
-    double* cost = BROTLI_ALLOC(m, double, num_histograms);
-    uint8_t* switch_signal = BROTLI_ALLOC(m, uint8_t, length * bitmaplen);
-    uint16_t* new_id = BROTLI_ALLOC(m, uint16_t, num_histograms);
-    const size_t iters = params->quality < HQ_ZOPFLIFICATION_QUALITY ? 3 : 10;
-    size_t i;
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(block_ids) ||
-        BROTLI_IS_NULL(insert_cost) || BROTLI_IS_NULL(cost) ||
-        BROTLI_IS_NULL(switch_signal) || BROTLI_IS_NULL(new_id)) {
-      return;
-    }
-    for (i = 0; i < iters; ++i) {
-      num_blocks = FN(FindBlocks)(data, length,
-                                  block_switch_cost,
-                                  num_histograms, histograms,
-                                  insert_cost, cost, switch_signal,
-                                  block_ids);
-      num_histograms = FN(RemapBlockIds)(block_ids, length,
-                                         new_id, num_histograms);
-      FN(BuildBlockHistograms)(data, length, block_ids,
-                               num_histograms, histograms);
-    }
-    BROTLI_FREE(m, insert_cost);
-    BROTLI_FREE(m, cost);
-    BROTLI_FREE(m, switch_signal);
-    BROTLI_FREE(m, new_id);
-    BROTLI_FREE(m, histograms);
-    FN(ClusterBlocks)(m, data, length, num_blocks, block_ids, split);
-    if (BROTLI_IS_OOM(m)) return;
-    BROTLI_FREE(m, block_ids);
-  }
-}
-
-#undef HistogramType
-#undef DataType
-#undef FN
-
-void duckdb_brotli::BrotliInitBlockSplit(BlockSplit* self) {
-  self->num_types = 0;
-  self->num_blocks = 0;
-  self->types = 0;
-  self->lengths = 0;
-  self->types_alloc_size = 0;
-  self->lengths_alloc_size = 0;
-}
-
-void duckdb_brotli::BrotliDestroyBlockSplit(MemoryManager* m, BlockSplit* self) {
-  BROTLI_FREE(m, self->types);
-  BROTLI_FREE(m, self->lengths);
-}
-
-/* Extracts literals, command distance and prefix codes, then applies
- * SplitByteVector to create partitioning. */
-void duckdb_brotli::BrotliSplitBlock(MemoryManager* m,
-                      const Command* cmds,
-                      const size_t num_commands,
-                      const uint8_t* data,
-                      const size_t pos,
-                      const size_t mask,
-                      const BrotliEncoderParams* params,
-                      BlockSplit* literal_split,
-                      BlockSplit* insert_and_copy_split,
-                      BlockSplit* dist_split) {
-  {
-    size_t literals_count = CountLiterals(cmds, num_commands);
-    uint8_t* literals = BROTLI_ALLOC(m, uint8_t, literals_count);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literals)) return;
-    /* Create a continuous array of literals. */
-    CopyLiteralsToByteArray(cmds, num_commands, data, pos, mask, literals);
-    /* Create the block split on the array of literals.
-     * Literal histograms can have alphabet size up to 256.
-     * Though, to accomodate context modeling, less than half of maximum size
-     * is allowed. */
-    SplitByteVectorLiteral(
-        m, literals, literals_count,
-        kSymbolsPerLiteralHistogram, kMaxLiteralHistograms,
-        kLiteralStrideLength, kLiteralBlockSwitchCost, params,
-        literal_split);
-    if (BROTLI_IS_OOM(m)) return;
-    BROTLI_FREE(m, literals);
-    /* NB: this might be a good place for injecting extra splitting without
-     *     increasing encoder complexity; however, output parition would be less
-     *     optimal than one produced with forced splitting inside
-     *     SplitByteVector (FindBlocks / ClusterBlocks). */
-  }
-
-  {
-    /* Compute prefix codes for commands. */
-    uint16_t* insert_and_copy_codes = BROTLI_ALLOC(m, uint16_t, num_commands);
-    size_t i;
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(insert_and_copy_codes)) return;
-    for (i = 0; i < num_commands; ++i) {
-      insert_and_copy_codes[i] = cmds[i].cmd_prefix_;
-    }
-    /* Create the block split on the array of command prefixes. */
-    SplitByteVectorCommand(
-        m, insert_and_copy_codes, num_commands,
-        kSymbolsPerCommandHistogram, kMaxCommandHistograms,
-        kCommandStrideLength, kCommandBlockSwitchCost, params,
-        insert_and_copy_split);
-    if (BROTLI_IS_OOM(m)) return;
-    /* TODO(eustas): reuse for distances? */
-    BROTLI_FREE(m, insert_and_copy_codes);
-  }
-
-  {
-    /* Create a continuous array of distance prefixes. */
-    uint16_t* distance_prefixes = BROTLI_ALLOC(m, uint16_t, num_commands);
-    size_t j = 0;
-    size_t i;
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(distance_prefixes)) return;
-    for (i = 0; i < num_commands; ++i) {
-      const Command* cmd = &cmds[i];
-      if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
-        distance_prefixes[j++] = cmd->dist_prefix_ & 0x3FF;
-      }
-    }
-    /* Create the block split on the array of distance prefixes. */
-    SplitByteVectorDistance(
-        m, distance_prefixes, j,
-        kSymbolsPerDistanceHistogram, kMaxCommandHistograms,
-        kDistanceStrideLength, kDistanceBlockSwitchCost, params,
-        dist_split);
-    if (BROTLI_IS_OOM(m)) return;
-    BROTLI_FREE(m, distance_prefixes);
-  }
-}
-
-#if defined(BROTLI_TEST)
-size_t CountLiteralsForTest(const Command*, const size_t);
-size_t CountLiteralsForTest(const Command* cmds, const size_t num_commands) {
-  return CountLiterals(cmds, num_commands);
-}
-
-void CopyLiteralsToByteArrayForTest(const Command*,
-    const size_t, const uint8_t*, const size_t, const size_t, uint8_t*);
-void CopyLiteralsToByteArrayForTest(const Command* cmds,
-    const size_t num_commands, const uint8_t* data, const size_t offset,
-    const size_t mask, uint8_t* literals) {
-  CopyLiteralsToByteArray(cmds, num_commands, data, offset, mask, literals);
-}
-#endif
-
-
diff --git a/src/duckdb/third_party/brotli/enc/block_splitter.h b/src/duckdb/third_party/brotli/enc/block_splitter.h
deleted file mode 100644
index c5e438e32..000000000
--- a/src/duckdb/third_party/brotli/enc/block_splitter.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Block split point selection utilities. */
-
-#ifndef BROTLI_ENC_BLOCK_SPLITTER_H_
-#define BROTLI_ENC_BLOCK_SPLITTER_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "command.h"
-#include "memory.h"
-#include "quality.h"
-
-namespace duckdb_brotli {
-
-typedef struct BlockSplit {
-  size_t num_types;  /* Amount of distinct types */
-  size_t num_blocks;  /* Amount of values in types and length */
-  uint8_t* types;
-  uint32_t* lengths;
-
-  size_t types_alloc_size;
-  size_t lengths_alloc_size;
-} BlockSplit;
-
-BROTLI_INTERNAL void BrotliInitBlockSplit(BlockSplit* self);
-BROTLI_INTERNAL void BrotliDestroyBlockSplit(MemoryManager* m,
-                                             BlockSplit* self);
-
-BROTLI_INTERNAL void BrotliSplitBlock(MemoryManager* m,
-                                      const Command* cmds,
-                                      const size_t num_commands,
-                                      const uint8_t* data,
-                                      const size_t offset,
-                                      const size_t mask,
-                                      const BrotliEncoderParams* params,
-                                      BlockSplit* literal_split,
-                                      BlockSplit* insert_and_copy_split,
-                                      BlockSplit* dist_split);
-
-}
-
-#endif  /* BROTLI_ENC_BLOCK_SPLITTER_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/brotli_bit_stream.cpp b/src/duckdb/third_party/brotli/enc/brotli_bit_stream.cpp
deleted file mode 100644
index 81256e610..000000000
--- a/src/duckdb/third_party/brotli/enc/brotli_bit_stream.cpp
+++ /dev/null
@@ -1,1431 +0,0 @@
-/* Copyright 2014 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Brotli bit stream functions to support the low level format. There are no
-   compression algorithms here, just the right ordering of bits to match the
-   specs. */
-
-#include "brotli_bit_stream.h"
-
-#include <string.h>  /* memcpy, memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/brotli_platform.h"
-#include "entropy_encode.h"
-#include "entropy_encode_static.h"
-#include "fast_log.h"
-#include "histogram.h"
-#include "memory.h"
-#include "write_bits.h"
-
-using namespace duckdb_brotli;
-
-#define MAX_HUFFMAN_TREE_SIZE (2 * BROTLI_NUM_COMMAND_SYMBOLS + 1)
-/* The maximum size of Huffman dictionary for distances assuming that
-   NPOSTFIX = 0 and NDIRECT = 0. */
-#define MAX_SIMPLE_DISTANCE_ALPHABET_SIZE \
-  BROTLI_DISTANCE_ALPHABET_SIZE(0, 0, BROTLI_LARGE_MAX_DISTANCE_BITS)
-/* MAX_SIMPLE_DISTANCE_ALPHABET_SIZE == 140 */
-
-static BROTLI_INLINE uint32_t BlockLengthPrefixCode(uint32_t len) {
-  uint32_t code = (len >= 177) ? (len >= 753 ? 20 : 14) : (len >= 41 ? 7 : 0);
-  while (code < (BROTLI_NUM_BLOCK_LEN_SYMBOLS - 1) &&
-      len >= _kBrotliPrefixCodeRanges[code + 1].offset) ++code;
-  return code;
-}
-
-static BROTLI_INLINE void GetBlockLengthPrefixCode(uint32_t len, size_t* code,
-    uint32_t* n_extra, uint32_t* extra) {
-  *code = BlockLengthPrefixCode(len);
-  *n_extra = _kBrotliPrefixCodeRanges[*code].nbits;
-  *extra = len - _kBrotliPrefixCodeRanges[*code].offset;
-}
-
-typedef struct BlockTypeCodeCalculator {
-  size_t last_type;
-  size_t second_last_type;
-} BlockTypeCodeCalculator;
-
-static void InitBlockTypeCodeCalculator(BlockTypeCodeCalculator* self) {
-  self->last_type = 1;
-  self->second_last_type = 0;
-}
-
-static BROTLI_INLINE size_t NextBlockTypeCode(
-    BlockTypeCodeCalculator* calculator, uint8_t type) {
-  size_t type_code = (type == calculator->last_type + 1) ? 1u :
-      (type == calculator->second_last_type) ? 0u : type + 2u;
-  calculator->second_last_type = calculator->last_type;
-  calculator->last_type = type;
-  return type_code;
-}
-
-/* |nibblesbits| represents the 2 bits to encode MNIBBLES (0-3)
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
-static void BrotliEncodeMlen(size_t length, uint64_t* bits,
-                             size_t* numbits, uint64_t* nibblesbits) {
-  size_t lg = (length == 1) ? 1 : Log2FloorNonZero((uint32_t)(length - 1)) + 1;
-  size_t mnibbles = (lg < 16 ? 16 : (lg + 3)) / 4;
-  BROTLI_DCHECK(length > 0);
-  BROTLI_DCHECK(length <= (1 << 24));
-  BROTLI_DCHECK(lg <= 24);
-  *nibblesbits = mnibbles - 4;
-  *numbits = mnibbles * 4;
-  *bits = length - 1;
-}
-
-static BROTLI_INLINE void StoreCommandExtra(
-    const Command* cmd, size_t* storage_ix, uint8_t* storage) {
-  uint32_t copylen_code = CommandCopyLenCode(cmd);
-  uint16_t inscode = GetInsertLengthCode(cmd->insert_len_);
-  uint16_t copycode = GetCopyLengthCode(copylen_code);
-  uint32_t insnumextra = GetInsertExtra(inscode);
-  uint64_t insextraval = cmd->insert_len_ - GetInsertBase(inscode);
-  uint64_t copyextraval = copylen_code - GetCopyBase(copycode);
-  uint64_t bits = (copyextraval << insnumextra) | insextraval;
-  BrotliWriteBits(
-      insnumextra + GetCopyExtra(copycode), bits, storage_ix, storage);
-}
-
-/* Data structure that stores almost everything that is needed to encode each
-   block switch command. */
-typedef struct BlockSplitCode {
-  BlockTypeCodeCalculator type_code_calculator;
-  uint8_t type_depths[BROTLI_MAX_BLOCK_TYPE_SYMBOLS];
-  uint16_t type_bits[BROTLI_MAX_BLOCK_TYPE_SYMBOLS];
-  uint8_t length_depths[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
-  uint16_t length_bits[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
-} BlockSplitCode;
-
-/* Stores a number between 0 and 255. */
-static void StoreVarLenUint8(size_t n, size_t* storage_ix, uint8_t* storage) {
-  if (n == 0) {
-    BrotliWriteBits(1, 0, storage_ix, storage);
-  } else {
-    size_t nbits = Log2FloorNonZero(n);
-    BrotliWriteBits(1, 1, storage_ix, storage);
-    BrotliWriteBits(3, nbits, storage_ix, storage);
-    BrotliWriteBits(nbits, n - ((size_t)1 << nbits), storage_ix, storage);
-  }
-}
-
-/* Stores the compressed meta-block header.
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
-static void StoreCompressedMetaBlockHeader(BROTLI_BOOL is_final_block,
-                                           size_t length,
-                                           size_t* storage_ix,
-                                           uint8_t* storage) {
-  uint64_t lenbits;
-  size_t nlenbits;
-  uint64_t nibblesbits;
-
-  /* Write ISLAST bit. */
-  BrotliWriteBits(1, (uint64_t)is_final_block, storage_ix, storage);
-  /* Write ISEMPTY bit. */
-  if (is_final_block) {
-    BrotliWriteBits(1, 0, storage_ix, storage);
-  }
-
-  BrotliEncodeMlen(length, &lenbits, &nlenbits, &nibblesbits);
-  BrotliWriteBits(2, nibblesbits, storage_ix, storage);
-  BrotliWriteBits(nlenbits, lenbits, storage_ix, storage);
-
-  if (!is_final_block) {
-    /* Write ISUNCOMPRESSED bit. */
-    BrotliWriteBits(1, 0, storage_ix, storage);
-  }
-}
-
-/* Stores the uncompressed meta-block header.
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
-static void BrotliStoreUncompressedMetaBlockHeader(size_t length,
-                                                   size_t* storage_ix,
-                                                   uint8_t* storage) {
-  uint64_t lenbits;
-  size_t nlenbits;
-  uint64_t nibblesbits;
-
-  /* Write ISLAST bit.
-     Uncompressed block cannot be the last one, so set to 0. */
-  BrotliWriteBits(1, 0, storage_ix, storage);
-  BrotliEncodeMlen(length, &lenbits, &nlenbits, &nibblesbits);
-  BrotliWriteBits(2, nibblesbits, storage_ix, storage);
-  BrotliWriteBits(nlenbits, lenbits, storage_ix, storage);
-  /* Write ISUNCOMPRESSED bit. */
-  BrotliWriteBits(1, 1, storage_ix, storage);
-}
-
-static void BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(
-    const int num_codes, const uint8_t* code_length_bitdepth,
-    size_t* storage_ix, uint8_t* storage) {
-  static const uint8_t kStorageOrder[BROTLI_CODE_LENGTH_CODES] = {
-    1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15
-  };
-  /* The bit lengths of the Huffman code over the code length alphabet
-     are compressed with the following static Huffman code:
-       Symbol   Code
-       ------   ----
-       0          00
-       1        1110
-       2         110
-       3          01
-       4          10
-       5        1111 */
-  static const uint8_t kHuffmanBitLengthHuffmanCodeSymbols[6] = {
-     0, 7, 3, 2, 1, 15
-  };
-  static const uint8_t kHuffmanBitLengthHuffmanCodeBitLengths[6] = {
-    2, 4, 3, 2, 2, 4
-  };
-
-  size_t skip_some = 0;  /* skips none. */
-
-  /* Throw away trailing zeros: */
-  size_t codes_to_store = BROTLI_CODE_LENGTH_CODES;
-  if (num_codes > 1) {
-    for (; codes_to_store > 0; --codes_to_store) {
-      if (code_length_bitdepth[kStorageOrder[codes_to_store - 1]] != 0) {
-        break;
-      }
-    }
-  }
-  if (code_length_bitdepth[kStorageOrder[0]] == 0 &&
-      code_length_bitdepth[kStorageOrder[1]] == 0) {
-    skip_some = 2;  /* skips two. */
-    if (code_length_bitdepth[kStorageOrder[2]] == 0) {
-      skip_some = 3;  /* skips three. */
-    }
-  }
-  BrotliWriteBits(2, skip_some, storage_ix, storage);
-  {
-    size_t i;
-    for (i = skip_some; i < codes_to_store; ++i) {
-      size_t l = code_length_bitdepth[kStorageOrder[i]];
-      BrotliWriteBits(kHuffmanBitLengthHuffmanCodeBitLengths[l],
-          kHuffmanBitLengthHuffmanCodeSymbols[l], storage_ix, storage);
-    }
-  }
-}
-
-static void BrotliStoreHuffmanTreeToBitMask(
-    const size_t huffman_tree_size, const uint8_t* huffman_tree,
-    const uint8_t* huffman_tree_extra_bits, const uint8_t* code_length_bitdepth,
-    const uint16_t* code_length_bitdepth_symbols,
-    size_t* BROTLI_RESTRICT storage_ix, uint8_t* BROTLI_RESTRICT storage) {
-  size_t i;
-  for (i = 0; i < huffman_tree_size; ++i) {
-    size_t ix = huffman_tree[i];
-    BrotliWriteBits(code_length_bitdepth[ix], code_length_bitdepth_symbols[ix],
-                    storage_ix, storage);
-    /* Extra bits */
-    switch (ix) {
-      case BROTLI_REPEAT_PREVIOUS_CODE_LENGTH:
-        BrotliWriteBits(2, huffman_tree_extra_bits[i], storage_ix, storage);
-        break;
-      case BROTLI_REPEAT_ZERO_CODE_LENGTH:
-        BrotliWriteBits(3, huffman_tree_extra_bits[i], storage_ix, storage);
-        break;
-    }
-  }
-}
-
-static void StoreSimpleHuffmanTree(const uint8_t* depths,
-                                   size_t symbols[4],
-                                   size_t num_symbols,
-                                   size_t max_bits,
-                                   size_t* storage_ix, uint8_t* storage) {
-  /* value of 1 indicates a simple Huffman code */
-  BrotliWriteBits(2, 1, storage_ix, storage);
-  BrotliWriteBits(2, num_symbols - 1, storage_ix, storage);  /* NSYM - 1 */
-
-  {
-    /* Sort */
-    size_t i;
-    for (i = 0; i < num_symbols; i++) {
-      size_t j;
-      for (j = i + 1; j < num_symbols; j++) {
-        if (depths[symbols[j]] < depths[symbols[i]]) {
-          BROTLI_SWAP(size_t, symbols, j, i);
-        }
-      }
-    }
-  }
-
-  if (num_symbols == 2) {
-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
-  } else if (num_symbols == 3) {
-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
-  } else {
-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[3], storage_ix, storage);
-    /* tree-select */
-    BrotliWriteBits(1, depths[symbols[0]] == 1 ? 1 : 0, storage_ix, storage);
-  }
-}
-
-/* num = alphabet size
-   depths = symbol depths */
-void duckdb_brotli::BrotliStoreHuffmanTree(const uint8_t* depths, size_t num,
-                            HuffmanTree* tree,
-                            size_t* storage_ix, uint8_t* storage) {
-  /* Write the Huffman tree into the brotli-representation.
-     The command alphabet is the largest, so this allocation will fit all
-     alphabets. */
-  /* TODO(eustas): fix me */
-  uint8_t huffman_tree[BROTLI_NUM_COMMAND_SYMBOLS];
-  uint8_t huffman_tree_extra_bits[BROTLI_NUM_COMMAND_SYMBOLS];
-  size_t huffman_tree_size = 0;
-  uint8_t code_length_bitdepth[BROTLI_CODE_LENGTH_CODES] = { 0 };
-  uint16_t code_length_bitdepth_symbols[BROTLI_CODE_LENGTH_CODES];
-  uint32_t huffman_tree_histogram[BROTLI_CODE_LENGTH_CODES] = { 0 };
-  size_t i;
-  int num_codes = 0;
-  size_t code = 0;
-
-  BROTLI_DCHECK(num <= BROTLI_NUM_COMMAND_SYMBOLS);
-
-  BrotliWriteHuffmanTree(depths, num, &huffman_tree_size, huffman_tree,
-                         huffman_tree_extra_bits);
-
-  /* Calculate the statistics of the Huffman tree in brotli-representation. */
-  for (i = 0; i < huffman_tree_size; ++i) {
-    ++huffman_tree_histogram[huffman_tree[i]];
-  }
-
-  for (i = 0; i < BROTLI_CODE_LENGTH_CODES; ++i) {
-    if (huffman_tree_histogram[i]) {
-      if (num_codes == 0) {
-        code = i;
-        num_codes = 1;
-      } else if (num_codes == 1) {
-        num_codes = 2;
-        break;
-      }
-    }
-  }
-
-  /* Calculate another Huffman tree to use for compressing both the
-     earlier Huffman tree with. */
-  BrotliCreateHuffmanTree(huffman_tree_histogram, BROTLI_CODE_LENGTH_CODES,
-                          5, tree, code_length_bitdepth);
-  BrotliConvertBitDepthsToSymbols(code_length_bitdepth,
-                                  BROTLI_CODE_LENGTH_CODES,
-                                  code_length_bitdepth_symbols);
-
-  /* Now, we have all the data, let's start storing it */
-  BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(num_codes, code_length_bitdepth,
-                                               storage_ix, storage);
-
-  if (num_codes == 1) {
-    code_length_bitdepth[code] = 0;
-  }
-
-  /* Store the real Huffman tree now. */
-  BrotliStoreHuffmanTreeToBitMask(huffman_tree_size,
-                                  huffman_tree,
-                                  huffman_tree_extra_bits,
-                                  code_length_bitdepth,
-                                  code_length_bitdepth_symbols,
-                                  storage_ix, storage);
-}
-
-/* Builds a Huffman tree from histogram[0:length] into depth[0:length] and
-   bits[0:length] and stores the encoded tree to the bit stream. */
-static void BuildAndStoreHuffmanTree(const uint32_t* histogram,
-                                     const size_t histogram_length,
-                                     const size_t alphabet_size,
-                                     HuffmanTree* tree,
-                                     uint8_t* depth,
-                                     uint16_t* bits,
-                                     size_t* storage_ix,
-                                     uint8_t* storage) {
-  size_t count = 0;
-  size_t s4[4] = { 0 };
-  size_t i;
-  size_t max_bits = 0;
-  for (i = 0; i < histogram_length; i++) {
-    if (histogram[i]) {
-      if (count < 4) {
-        s4[count] = i;
-      } else if (count > 4) {
-        break;
-      }
-      count++;
-    }
-  }
-
-  {
-    size_t max_bits_counter = alphabet_size - 1;
-    while (max_bits_counter) {
-      max_bits_counter >>= 1;
-      ++max_bits;
-    }
-  }
-
-  if (count <= 1) {
-    BrotliWriteBits(4, 1, storage_ix, storage);
-    BrotliWriteBits(max_bits, s4[0], storage_ix, storage);
-    depth[s4[0]] = 0;
-    bits[s4[0]] = 0;
-    return;
-  }
-
-  memset(depth, 0, histogram_length * sizeof(depth[0]));
-  BrotliCreateHuffmanTree(histogram, histogram_length, 15, tree, depth);
-  BrotliConvertBitDepthsToSymbols(depth, histogram_length, bits);
-
-  if (count <= 4) {
-    StoreSimpleHuffmanTree(depth, s4, count, max_bits, storage_ix, storage);
-  } else {
-    BrotliStoreHuffmanTree(depth, histogram_length, tree, storage_ix, storage);
-  }
-}
-
-static BROTLI_INLINE BROTLI_BOOL SortHuffmanTree(
-    const HuffmanTree* v0, const HuffmanTree* v1) {
-  return TO_BROTLI_BOOL(v0->total_count_ < v1->total_count_);
-}
-
-void duckdb_brotli::BrotliBuildAndStoreHuffmanTreeFast(HuffmanTree* tree,
-                                        const uint32_t* histogram,
-                                        const size_t histogram_total,
-                                        const size_t max_bits,
-                                        uint8_t* depth, uint16_t* bits,
-                                        size_t* storage_ix,
-                                        uint8_t* storage) {
-  size_t count = 0;
-  size_t symbols[4] = { 0 };
-  size_t length = 0;
-  size_t total = histogram_total;
-  while (total != 0) {
-    if (histogram[length]) {
-      if (count < 4) {
-        symbols[count] = length;
-      }
-      ++count;
-      total -= histogram[length];
-    }
-    ++length;
-  }
-
-  if (count <= 1) {
-    BrotliWriteBits(4, 1, storage_ix, storage);
-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-    depth[symbols[0]] = 0;
-    bits[symbols[0]] = 0;
-    return;
-  }
-
-  memset(depth, 0, length * sizeof(depth[0]));
-  {
-    uint32_t count_limit;
-    for (count_limit = 1; ; count_limit *= 2) {
-      HuffmanTree* node = tree;
-      size_t l;
-      for (l = length; l != 0;) {
-        --l;
-        if (histogram[l]) {
-          if (BROTLI_PREDICT_TRUE(histogram[l] >= count_limit)) {
-            InitHuffmanTree(node, histogram[l], -1, (int16_t)l);
-          } else {
-            InitHuffmanTree(node, count_limit, -1, (int16_t)l);
-          }
-          ++node;
-        }
-      }
-      {
-        const int n = (int)(node - tree);
-        HuffmanTree sentinel;
-        int i = 0;      /* Points to the next leaf node. */
-        int j = n + 1;  /* Points to the next non-leaf node. */
-        int k;
-
-        SortHuffmanTreeItems(tree, (size_t)n, SortHuffmanTree);
-        /* The nodes are:
-           [0, n): the sorted leaf nodes that we start with.
-           [n]: we add a sentinel here.
-           [n + 1, 2n): new parent nodes are added here, starting from
-                        (n+1). These are naturally in ascending order.
-           [2n]: we add a sentinel at the end as well.
-           There will be (2n+1) elements at the end. */
-        InitHuffmanTree(&sentinel, BROTLI_UINT32_MAX, -1, -1);
-        *node++ = sentinel;
-        *node++ = sentinel;
-
-        for (k = n - 1; k > 0; --k) {
-          int left, right;
-          if (tree[i].total_count_ <= tree[j].total_count_) {
-            left = i;
-            ++i;
-          } else {
-            left = j;
-            ++j;
-          }
-          if (tree[i].total_count_ <= tree[j].total_count_) {
-            right = i;
-            ++i;
-          } else {
-            right = j;
-            ++j;
-          }
-          /* The sentinel node becomes the parent node. */
-          node[-1].total_count_ =
-              tree[left].total_count_ + tree[right].total_count_;
-          node[-1].index_left_ = (int16_t)left;
-          node[-1].index_right_or_value_ = (int16_t)right;
-          /* Add back the last sentinel node. */
-          *node++ = sentinel;
-        }
-        if (BrotliSetDepth(2 * n - 1, tree, depth, 14)) {
-          /* We need to pack the Huffman tree in 14 bits. If this was not
-             successful, add fake entities to the lowest values and retry. */
-          break;
-        }
-      }
-    }
-  }
-  BrotliConvertBitDepthsToSymbols(depth, length, bits);
-  if (count <= 4) {
-    size_t i;
-    /* value of 1 indicates a simple Huffman code */
-    BrotliWriteBits(2, 1, storage_ix, storage);
-    BrotliWriteBits(2, count - 1, storage_ix, storage);  /* NSYM - 1 */
-
-    /* Sort */
-    for (i = 0; i < count; i++) {
-      size_t j;
-      for (j = i + 1; j < count; j++) {
-        if (depth[symbols[j]] < depth[symbols[i]]) {
-          BROTLI_SWAP(size_t, symbols, j, i);
-        }
-      }
-    }
-
-    if (count == 2) {
-      BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-      BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
-    } else if (count == 3) {
-      BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-      BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
-      BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
-    } else {
-      BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
-      BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
-      BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
-      BrotliWriteBits(max_bits, symbols[3], storage_ix, storage);
-      /* tree-select */
-      BrotliWriteBits(1, depth[symbols[0]] == 1 ? 1 : 0, storage_ix, storage);
-    }
-  } else {
-    uint8_t previous_value = 8;
-    size_t i;
-    /* Complex Huffman Tree */
-    StoreStaticCodeLengthCode(storage_ix, storage);
-
-    /* Actual RLE coding. */
-    for (i = 0; i < length;) {
-      const uint8_t value = depth[i];
-      size_t reps = 1;
-      size_t k;
-      for (k = i + 1; k < length && depth[k] == value; ++k) {
-        ++reps;
-      }
-      i += reps;
-      if (value == 0) {
-        BrotliWriteBits(kZeroRepsDepth[reps], kZeroRepsBits[reps],
-                        storage_ix, storage);
-      } else {
-        if (previous_value != value) {
-          BrotliWriteBits(kCodeLengthDepth[value], kCodeLengthBits[value],
-                          storage_ix, storage);
-          --reps;
-        }
-        if (reps < 3) {
-          while (reps != 0) {
-            reps--;
-            BrotliWriteBits(kCodeLengthDepth[value], kCodeLengthBits[value],
-                            storage_ix, storage);
-          }
-        } else {
-          reps -= 3;
-          BrotliWriteBits(kNonZeroRepsDepth[reps], kNonZeroRepsBits[reps],
-                          storage_ix, storage);
-        }
-        previous_value = value;
-      }
-    }
-  }
-}
-
-static size_t IndexOf(const uint8_t* v, size_t v_size, uint8_t value) {
-  size_t i = 0;
-  for (; i < v_size; ++i) {
-    if (v[i] == value) return i;
-  }
-  return i;
-}
-
-static void MoveToFront(uint8_t* v, size_t index) {
-  uint8_t value = v[index];
-  size_t i;
-  for (i = index; i != 0; --i) {
-    v[i] = v[i - 1];
-  }
-  v[0] = value;
-}
-
-static void MoveToFrontTransform(const uint32_t* BROTLI_RESTRICT v_in,
-                                 const size_t v_size,
-                                 uint32_t* v_out) {
-  size_t i;
-  uint8_t mtf[256];
-  uint32_t max_value;
-  if (v_size == 0) {
-    return;
-  }
-  max_value = v_in[0];
-  for (i = 1; i < v_size; ++i) {
-    if (v_in[i] > max_value) max_value = v_in[i];
-  }
-  BROTLI_DCHECK(max_value < 256u);
-  for (i = 0; i <= max_value; ++i) {
-    mtf[i] = (uint8_t)i;
-  }
-  {
-    size_t mtf_size = max_value + 1;
-    for (i = 0; i < v_size; ++i) {
-      size_t index = IndexOf(mtf, mtf_size, (uint8_t)v_in[i]);
-      BROTLI_DCHECK(index < mtf_size);
-      v_out[i] = (uint32_t)index;
-      MoveToFront(mtf, index);
-    }
-  }
-}
-
-/* Finds runs of zeros in v[0..in_size) and replaces them with a prefix code of
-   the run length plus extra bits (lower 9 bits is the prefix code and the rest
-   are the extra bits). Non-zero values in v[] are shifted by
-   *max_length_prefix. Will not create prefix codes bigger than the initial
-   value of *max_run_length_prefix. The prefix code of run length L is simply
-   Log2Floor(L) and the number of extra bits is the same as the prefix code. */
-static void RunLengthCodeZeros(const size_t in_size,
-    uint32_t* BROTLI_RESTRICT v, size_t* BROTLI_RESTRICT out_size,
-    uint32_t* BROTLI_RESTRICT max_run_length_prefix) {
-  uint32_t max_reps = 0;
-  size_t i;
-  uint32_t max_prefix;
-  for (i = 0; i < in_size;) {
-    uint32_t reps = 0;
-    for (; i < in_size && v[i] != 0; ++i) ;
-    for (; i < in_size && v[i] == 0; ++i) {
-      ++reps;
-    }
-    max_reps = BROTLI_MAX(uint32_t, reps, max_reps);
-  }
-  max_prefix = max_reps > 0 ? Log2FloorNonZero(max_reps) : 0;
-  max_prefix = BROTLI_MIN(uint32_t, max_prefix, *max_run_length_prefix);
-  *max_run_length_prefix = max_prefix;
-  *out_size = 0;
-  for (i = 0; i < in_size;) {
-    BROTLI_DCHECK(*out_size <= i);
-    if (v[i] != 0) {
-      v[*out_size] = v[i] + *max_run_length_prefix;
-      ++i;
-      ++(*out_size);
-    } else {
-      uint32_t reps = 1;
-      size_t k;
-      for (k = i + 1; k < in_size && v[k] == 0; ++k) {
-        ++reps;
-      }
-      i += reps;
-      while (reps != 0) {
-        if (reps < (2u << max_prefix)) {
-          uint32_t run_length_prefix = Log2FloorNonZero(reps);
-          const uint32_t extra_bits = reps - (1u << run_length_prefix);
-          v[*out_size] = run_length_prefix + (extra_bits << 9);
-          ++(*out_size);
-          break;
-        } else {
-          const uint32_t extra_bits = (1u << max_prefix) - 1u;
-          v[*out_size] = max_prefix + (extra_bits << 9);
-          reps -= (2u << max_prefix) - 1u;
-          ++(*out_size);
-        }
-      }
-    }
-  }
-}
-
-#define SYMBOL_BITS 9
-
-typedef struct EncodeContextMapArena {
-  uint32_t histogram[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
-  uint8_t depths[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
-  uint16_t bits[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
-} EncodeContextMapArena;
-
-static void EncodeContextMap(MemoryManager* m,
-                             EncodeContextMapArena* arena,
-                             const uint32_t* context_map,
-                             size_t context_map_size,
-                             size_t num_clusters,
-                             HuffmanTree* tree,
-                             size_t* storage_ix, uint8_t* storage) {
-  size_t i;
-  uint32_t* rle_symbols;
-  uint32_t max_run_length_prefix = 6;
-  size_t num_rle_symbols = 0;
-  uint32_t* BROTLI_RESTRICT const histogram = arena->histogram;
-  static const uint32_t kSymbolMask = (1u << SYMBOL_BITS) - 1u;
-  uint8_t* BROTLI_RESTRICT const depths = arena->depths;
-  uint16_t* BROTLI_RESTRICT const bits = arena->bits;
-
-  StoreVarLenUint8(num_clusters - 1, storage_ix, storage);
-
-  if (num_clusters == 1) {
-    return;
-  }
-
-  rle_symbols = BROTLI_ALLOC(m, uint32_t, context_map_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(rle_symbols)) return;
-  MoveToFrontTransform(context_map, context_map_size, rle_symbols);
-  RunLengthCodeZeros(context_map_size, rle_symbols,
-                     &num_rle_symbols, &max_run_length_prefix);
-  memset(histogram, 0, sizeof(arena->histogram));
-  for (i = 0; i < num_rle_symbols; ++i) {
-    ++histogram[rle_symbols[i] & kSymbolMask];
-  }
-  {
-    BROTLI_BOOL use_rle = TO_BROTLI_BOOL(max_run_length_prefix > 0);
-    BrotliWriteBits(1, (uint64_t)use_rle, storage_ix, storage);
-    if (use_rle) {
-      BrotliWriteBits(4, max_run_length_prefix - 1, storage_ix, storage);
-    }
-  }
-  BuildAndStoreHuffmanTree(histogram, num_clusters + max_run_length_prefix,
-                           num_clusters + max_run_length_prefix,
-                           tree, depths, bits, storage_ix, storage);
-  for (i = 0; i < num_rle_symbols; ++i) {
-    const uint32_t rle_symbol = rle_symbols[i] & kSymbolMask;
-    const uint32_t extra_bits_val = rle_symbols[i] >> SYMBOL_BITS;
-    BrotliWriteBits(depths[rle_symbol], bits[rle_symbol], storage_ix, storage);
-    if (rle_symbol > 0 && rle_symbol <= max_run_length_prefix) {
-      BrotliWriteBits(rle_symbol, extra_bits_val, storage_ix, storage);
-    }
-  }
-  BrotliWriteBits(1, 1, storage_ix, storage);  /* use move-to-front */
-  BROTLI_FREE(m, rle_symbols);
-}
-
-/* Stores the block switch command with index block_ix to the bit stream. */
-static BROTLI_INLINE void StoreBlockSwitch(BlockSplitCode* code,
-                                           const uint32_t block_len,
-                                           const uint8_t block_type,
-                                           BROTLI_BOOL is_first_block,
-                                           size_t* storage_ix,
-                                           uint8_t* storage) {
-  size_t typecode = NextBlockTypeCode(&code->type_code_calculator, block_type);
-  size_t lencode;
-  uint32_t len_nextra;
-  uint32_t len_extra;
-  if (!is_first_block) {
-    BrotliWriteBits(code->type_depths[typecode], code->type_bits[typecode],
-                    storage_ix, storage);
-  }
-  GetBlockLengthPrefixCode(block_len, &lencode, &len_nextra, &len_extra);
-
-  BrotliWriteBits(code->length_depths[lencode], code->length_bits[lencode],
-                  storage_ix, storage);
-  BrotliWriteBits(len_nextra, len_extra, storage_ix, storage);
-}
-
-/* Builds a BlockSplitCode data structure from the block split given by the
-   vector of block types and block lengths and stores it to the bit stream. */
-static void BuildAndStoreBlockSplitCode(const uint8_t* types,
-                                        const uint32_t* lengths,
-                                        const size_t num_blocks,
-                                        const size_t num_types,
-                                        HuffmanTree* tree,
-                                        BlockSplitCode* code,
-                                        size_t* storage_ix,
-                                        uint8_t* storage) {
-  uint32_t type_histo[BROTLI_MAX_BLOCK_TYPE_SYMBOLS];
-  uint32_t length_histo[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
-  size_t i;
-  BlockTypeCodeCalculator type_code_calculator;
-  memset(type_histo, 0, (num_types + 2) * sizeof(type_histo[0]));
-  memset(length_histo, 0, sizeof(length_histo));
-  InitBlockTypeCodeCalculator(&type_code_calculator);
-  for (i = 0; i < num_blocks; ++i) {
-    size_t type_code = NextBlockTypeCode(&type_code_calculator, types[i]);
-    if (i != 0) ++type_histo[type_code];
-    ++length_histo[BlockLengthPrefixCode(lengths[i])];
-  }
-  StoreVarLenUint8(num_types - 1, storage_ix, storage);
-  if (num_types > 1) {  /* TODO(eustas): else? could StoreBlockSwitch occur? */
-    BuildAndStoreHuffmanTree(&type_histo[0], num_types + 2, num_types + 2, tree,
-                             &code->type_depths[0], &code->type_bits[0],
-                             storage_ix, storage);
-    BuildAndStoreHuffmanTree(&length_histo[0], BROTLI_NUM_BLOCK_LEN_SYMBOLS,
-                             BROTLI_NUM_BLOCK_LEN_SYMBOLS,
-                             tree, &code->length_depths[0],
-                             &code->length_bits[0], storage_ix, storage);
-    StoreBlockSwitch(code, lengths[0], types[0], 1, storage_ix, storage);
-  }
-}
-
-/* Stores a context map where the histogram type is always the block type. */
-static void StoreTrivialContextMap(EncodeContextMapArena* arena,
-                                   size_t num_types,
-                                   size_t context_bits,
-                                   HuffmanTree* tree,
-                                   size_t* storage_ix,
-                                   uint8_t* storage) {
-  StoreVarLenUint8(num_types - 1, storage_ix, storage);
-  if (num_types > 1) {
-    size_t repeat_code = context_bits - 1u;
-    size_t repeat_bits = (1u << repeat_code) - 1u;
-    size_t alphabet_size = num_types + repeat_code;
-    uint32_t* BROTLI_RESTRICT const histogram = arena->histogram;
-    uint8_t* BROTLI_RESTRICT const depths = arena->depths;
-    uint16_t* BROTLI_RESTRICT const bits = arena->bits;
-    size_t i;
-    memset(histogram, 0, alphabet_size * sizeof(histogram[0]));
-    /* Write RLEMAX. */
-    BrotliWriteBits(1, 1, storage_ix, storage);
-    BrotliWriteBits(4, repeat_code - 1, storage_ix, storage);
-    histogram[repeat_code] = (uint32_t)num_types;
-    histogram[0] = 1;
-    for (i = context_bits; i < alphabet_size; ++i) {
-      histogram[i] = 1;
-    }
-    BuildAndStoreHuffmanTree(histogram, alphabet_size, alphabet_size,
-                             tree, depths, bits, storage_ix, storage);
-    for (i = 0; i < num_types; ++i) {
-      size_t code = (i == 0 ? 0 : i + context_bits - 1);
-      BrotliWriteBits(depths[code], bits[code], storage_ix, storage);
-      BrotliWriteBits(
-          depths[repeat_code], bits[repeat_code], storage_ix, storage);
-      BrotliWriteBits(repeat_code, repeat_bits, storage_ix, storage);
-    }
-    /* Write IMTF (inverse-move-to-front) bit. */
-    BrotliWriteBits(1, 1, storage_ix, storage);
-  }
-}
-
-/* Manages the encoding of one block category (literal, command or distance). */
-typedef struct BlockEncoder {
-  size_t histogram_length_;
-  size_t num_block_types_;
-  const uint8_t* block_types_;  /* Not owned. */
-  const uint32_t* block_lengths_;  /* Not owned. */
-  size_t num_blocks_;
-  BlockSplitCode block_split_code_;
-  size_t block_ix_;
-  size_t block_len_;
-  size_t entropy_ix_;
-  uint8_t* depths_;
-  uint16_t* bits_;
-} BlockEncoder;
-
-static void InitBlockEncoder(BlockEncoder* self, size_t histogram_length,
-    size_t num_block_types, const uint8_t* block_types,
-    const uint32_t* block_lengths, const size_t num_blocks) {
-  self->histogram_length_ = histogram_length;
-  self->num_block_types_ = num_block_types;
-  self->block_types_ = block_types;
-  self->block_lengths_ = block_lengths;
-  self->num_blocks_ = num_blocks;
-  InitBlockTypeCodeCalculator(&self->block_split_code_.type_code_calculator);
-  self->block_ix_ = 0;
-  self->block_len_ = num_blocks == 0 ? 0 : block_lengths[0];
-  self->entropy_ix_ = 0;
-  self->depths_ = 0;
-  self->bits_ = 0;
-}
-
-static void CleanupBlockEncoder(MemoryManager* m, BlockEncoder* self) {
-  BROTLI_FREE(m, self->depths_);
-  BROTLI_FREE(m, self->bits_);
-}
-
-/* Creates entropy codes of block lengths and block types and stores them
-   to the bit stream. */
-static void BuildAndStoreBlockSwitchEntropyCodes(BlockEncoder* self,
-    HuffmanTree* tree, size_t* storage_ix, uint8_t* storage) {
-  BuildAndStoreBlockSplitCode(self->block_types_, self->block_lengths_,
-      self->num_blocks_, self->num_block_types_, tree, &self->block_split_code_,
-      storage_ix, storage);
-}
-
-/* Stores the next symbol with the entropy code of the current block type.
-   Updates the block type and block length at block boundaries. */
-static void StoreSymbol(BlockEncoder* self, size_t symbol, size_t* storage_ix,
-    uint8_t* storage) {
-  if (self->block_len_ == 0) {
-    size_t block_ix = ++self->block_ix_;
-    uint32_t block_len = self->block_lengths_[block_ix];
-    uint8_t block_type = self->block_types_[block_ix];
-    self->block_len_ = block_len;
-    self->entropy_ix_ = block_type * self->histogram_length_;
-    StoreBlockSwitch(&self->block_split_code_, block_len, block_type, 0,
-        storage_ix, storage);
-  }
-  --self->block_len_;
-  {
-    size_t ix = self->entropy_ix_ + symbol;
-    BrotliWriteBits(self->depths_[ix], self->bits_[ix], storage_ix, storage);
-  }
-}
-
-/* Stores the next symbol with the entropy code of the current block type and
-   context value.
-   Updates the block type and block length at block boundaries. */
-static void StoreSymbolWithContext(BlockEncoder* self, size_t symbol,
-    size_t context, const uint32_t* context_map, size_t* storage_ix,
-    uint8_t* storage, const size_t context_bits) {
-  if (self->block_len_ == 0) {
-    size_t block_ix = ++self->block_ix_;
-    uint32_t block_len = self->block_lengths_[block_ix];
-    uint8_t block_type = self->block_types_[block_ix];
-    self->block_len_ = block_len;
-    self->entropy_ix_ = (size_t)block_type << context_bits;
-    StoreBlockSwitch(&self->block_split_code_, block_len, block_type, 0,
-        storage_ix, storage);
-  }
-  --self->block_len_;
-  {
-    size_t histo_ix = context_map[self->entropy_ix_ + context];
-    size_t ix = histo_ix * self->histogram_length_ + symbol;
-    BrotliWriteBits(self->depths_[ix], self->bits_[ix], storage_ix, storage);
-  }
-}
-
-#define FN(X) X ## Literal
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2014 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-/* Creates entropy codes for all block types and stores them to the bit
-   stream. */
-static void FN(BuildAndStoreEntropyCodes)(MemoryManager* m, BlockEncoder* self,
-    const HistogramType* histograms, const size_t histograms_size,
-    const size_t alphabet_size, HuffmanTree* tree,
-    size_t* storage_ix, uint8_t* storage) {
-  const size_t table_size = histograms_size * self->histogram_length_;
-  self->depths_ = BROTLI_ALLOC(m, uint8_t, table_size);
-  self->bits_ = BROTLI_ALLOC(m, uint16_t, table_size);
-  if (BROTLI_IS_OOM(m)) return;
-
-  {
-    size_t i;
-    for (i = 0; i < histograms_size; ++i) {
-      size_t ix = i * self->histogram_length_;
-      BuildAndStoreHuffmanTree(&histograms[i].data_[0], self->histogram_length_,
-          alphabet_size, tree, &self->depths_[ix], &self->bits_[ix],
-          storage_ix, storage);
-    }
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Command
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2014 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-/* Creates entropy codes for all block types and stores them to the bit
-   stream. */
-static void FN(BuildAndStoreEntropyCodes)(MemoryManager* m, BlockEncoder* self,
-    const HistogramType* histograms, const size_t histograms_size,
-    const size_t alphabet_size, HuffmanTree* tree,
-    size_t* storage_ix, uint8_t* storage) {
-  const size_t table_size = histograms_size * self->histogram_length_;
-  self->depths_ = BROTLI_ALLOC(m, uint8_t, table_size);
-  self->bits_ = BROTLI_ALLOC(m, uint16_t, table_size);
-  if (BROTLI_IS_OOM(m)) return;
-
-  {
-    size_t i;
-    for (i = 0; i < histograms_size; ++i) {
-      size_t ix = i * self->histogram_length_;
-      BuildAndStoreHuffmanTree(&histograms[i].data_[0], self->histogram_length_,
-          alphabet_size, tree, &self->depths_[ix], &self->bits_[ix],
-          storage_ix, storage);
-    }
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Distance
-/* NOLINTNEXTLINE(build/include) */
-/* NOLINT(build/header_guard) */
-/* Copyright 2014 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-/* Creates entropy codes for all block types and stores them to the bit
-   stream. */
-static void FN(BuildAndStoreEntropyCodes)(MemoryManager* m, BlockEncoder* self,
-    const HistogramType* histograms, const size_t histograms_size,
-    const size_t alphabet_size, HuffmanTree* tree,
-    size_t* storage_ix, uint8_t* storage) {
-  const size_t table_size = histograms_size * self->histogram_length_;
-  self->depths_ = BROTLI_ALLOC(m, uint8_t, table_size);
-  self->bits_ = BROTLI_ALLOC(m, uint16_t, table_size);
-  if (BROTLI_IS_OOM(m)) return;
-
-  {
-    size_t i;
-    for (i = 0; i < histograms_size; ++i) {
-      size_t ix = i * self->histogram_length_;
-      BuildAndStoreHuffmanTree(&histograms[i].data_[0], self->histogram_length_,
-          alphabet_size, tree, &self->depths_[ix], &self->bits_[ix],
-          storage_ix, storage);
-    }
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-static void JumpToByteBoundary(size_t* storage_ix, uint8_t* storage) {
-  *storage_ix = (*storage_ix + 7u) & ~7u;
-  storage[*storage_ix >> 3] = 0;
-}
-
-typedef struct StoreMetablockArena {
-  BlockEncoder literal_enc;
-  BlockEncoder command_enc;
-  BlockEncoder distance_enc;
-  EncodeContextMapArena context_map_arena;
-} StoreMetablockArena;
-
-void duckdb_brotli::BrotliStoreMetaBlock(MemoryManager* m,
-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
-    uint8_t prev_byte, uint8_t prev_byte2, BROTLI_BOOL is_last,
-    const BrotliEncoderParams* params, ContextType literal_context_mode,
-    const Command* commands, size_t n_commands, const MetaBlockSplit* mb,
-    size_t* storage_ix, uint8_t* storage) {
-
-  size_t pos = start_pos;
-  size_t i;
-  uint32_t num_distance_symbols = params->dist.alphabet_size_max;
-  uint32_t num_effective_distance_symbols = params->dist.alphabet_size_limit;
-  HuffmanTree* tree;
-  ContextLut literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
-  StoreMetablockArena* arena = NULL;
-  BlockEncoder* literal_enc = NULL;
-  BlockEncoder* command_enc = NULL;
-  BlockEncoder* distance_enc = NULL;
-  const BrotliDistanceParams* dist = &params->dist;
-  BROTLI_DCHECK(
-      num_effective_distance_symbols <= BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS);
-
-  StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);
-
-  tree = BROTLI_ALLOC(m, HuffmanTree, MAX_HUFFMAN_TREE_SIZE);
-  arena = BROTLI_ALLOC(m, StoreMetablockArena, 1);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tree) || BROTLI_IS_NULL(arena)) return;
-  literal_enc = &arena->literal_enc;
-  command_enc = &arena->command_enc;
-  distance_enc = &arena->distance_enc;
-  InitBlockEncoder(literal_enc, BROTLI_NUM_LITERAL_SYMBOLS,
-      mb->literal_split.num_types, mb->literal_split.types,
-      mb->literal_split.lengths, mb->literal_split.num_blocks);
-  InitBlockEncoder(command_enc, BROTLI_NUM_COMMAND_SYMBOLS,
-      mb->command_split.num_types, mb->command_split.types,
-      mb->command_split.lengths, mb->command_split.num_blocks);
-  InitBlockEncoder(distance_enc, num_effective_distance_symbols,
-      mb->distance_split.num_types, mb->distance_split.types,
-      mb->distance_split.lengths, mb->distance_split.num_blocks);
-
-  BuildAndStoreBlockSwitchEntropyCodes(literal_enc, tree, storage_ix, storage);
-  BuildAndStoreBlockSwitchEntropyCodes(command_enc, tree, storage_ix, storage);
-  BuildAndStoreBlockSwitchEntropyCodes(distance_enc, tree, storage_ix, storage);
-
-  BrotliWriteBits(2, dist->distance_postfix_bits, storage_ix, storage);
-  BrotliWriteBits(
-      4, dist->num_direct_distance_codes >> dist->distance_postfix_bits,
-      storage_ix, storage);
-  for (i = 0; i < mb->literal_split.num_types; ++i) {
-    BrotliWriteBits(2, literal_context_mode, storage_ix, storage);
-  }
-
-  if (mb->literal_context_map_size == 0) {
-    StoreTrivialContextMap(
-        &arena->context_map_arena, mb->literal_histograms_size,
-        BROTLI_LITERAL_CONTEXT_BITS, tree, storage_ix, storage);
-  } else {
-    EncodeContextMap(m, &arena->context_map_arena,
-        mb->literal_context_map, mb->literal_context_map_size,
-        mb->literal_histograms_size, tree, storage_ix, storage);
-    if (BROTLI_IS_OOM(m)) return;
-  }
-
-  if (mb->distance_context_map_size == 0) {
-    StoreTrivialContextMap(
-        &arena->context_map_arena, mb->distance_histograms_size,
-        BROTLI_DISTANCE_CONTEXT_BITS, tree, storage_ix, storage);
-  } else {
-    EncodeContextMap(m, &arena->context_map_arena,
-        mb->distance_context_map, mb->distance_context_map_size,
-        mb->distance_histograms_size, tree, storage_ix, storage);
-    if (BROTLI_IS_OOM(m)) return;
-  }
-
-  BuildAndStoreEntropyCodesLiteral(m, literal_enc, mb->literal_histograms,
-      mb->literal_histograms_size, BROTLI_NUM_LITERAL_SYMBOLS, tree,
-      storage_ix, storage);
-  if (BROTLI_IS_OOM(m)) return;
-  BuildAndStoreEntropyCodesCommand(m, command_enc, mb->command_histograms,
-      mb->command_histograms_size, BROTLI_NUM_COMMAND_SYMBOLS, tree,
-      storage_ix, storage);
-  if (BROTLI_IS_OOM(m)) return;
-  BuildAndStoreEntropyCodesDistance(m, distance_enc, mb->distance_histograms,
-      mb->distance_histograms_size, num_distance_symbols, tree,
-      storage_ix, storage);
-  if (BROTLI_IS_OOM(m)) return;
-  BROTLI_FREE(m, tree);
-
-  for (i = 0; i < n_commands; ++i) {
-    const Command cmd = commands[i];
-    size_t cmd_code = cmd.cmd_prefix_;
-    StoreSymbol(command_enc, cmd_code, storage_ix, storage);
-    StoreCommandExtra(&cmd, storage_ix, storage);
-    if (mb->literal_context_map_size == 0) {
-      size_t j;
-      for (j = cmd.insert_len_; j != 0; --j) {
-        StoreSymbol(literal_enc, input[pos & mask], storage_ix, storage);
-        ++pos;
-      }
-    } else {
-      size_t j;
-      for (j = cmd.insert_len_; j != 0; --j) {
-        size_t context =
-            BROTLI_CONTEXT(prev_byte, prev_byte2, literal_context_lut);
-        uint8_t literal = input[pos & mask];
-        StoreSymbolWithContext(literal_enc, literal, context,
-            mb->literal_context_map, storage_ix, storage,
-            BROTLI_LITERAL_CONTEXT_BITS);
-        prev_byte2 = prev_byte;
-        prev_byte = literal;
-        ++pos;
-      }
-    }
-    pos += CommandCopyLen(&cmd);
-    if (CommandCopyLen(&cmd)) {
-      prev_byte2 = input[(pos - 2) & mask];
-      prev_byte = input[(pos - 1) & mask];
-      if (cmd.cmd_prefix_ >= 128) {
-        size_t dist_code = cmd.dist_prefix_ & 0x3FF;
-        uint32_t distnumextra = cmd.dist_prefix_ >> 10;
-        uint64_t distextra = cmd.dist_extra_;
-        if (mb->distance_context_map_size == 0) {
-          StoreSymbol(distance_enc, dist_code, storage_ix, storage);
-        } else {
-          size_t context = CommandDistanceContext(&cmd);
-          StoreSymbolWithContext(distance_enc, dist_code, context,
-              mb->distance_context_map, storage_ix, storage,
-              BROTLI_DISTANCE_CONTEXT_BITS);
-        }
-        BrotliWriteBits(distnumextra, distextra, storage_ix, storage);
-      }
-    }
-  }
-  CleanupBlockEncoder(m, distance_enc);
-  CleanupBlockEncoder(m, command_enc);
-  CleanupBlockEncoder(m, literal_enc);
-  BROTLI_FREE(m, arena);
-  if (is_last) {
-    JumpToByteBoundary(storage_ix, storage);
-  }
-}
-
-static void BuildHistograms(const uint8_t* input,
-                            size_t start_pos,
-                            size_t mask,
-                            const Command* commands,
-                            size_t n_commands,
-                            HistogramLiteral* lit_histo,
-                            HistogramCommand* cmd_histo,
-                            HistogramDistance* dist_histo) {
-  size_t pos = start_pos;
-  size_t i;
-  for (i = 0; i < n_commands; ++i) {
-    const Command cmd = commands[i];
-    size_t j;
-    HistogramAddCommand(cmd_histo, cmd.cmd_prefix_);
-    for (j = cmd.insert_len_; j != 0; --j) {
-      HistogramAddLiteral(lit_histo, input[pos & mask]);
-      ++pos;
-    }
-    pos += CommandCopyLen(&cmd);
-    if (CommandCopyLen(&cmd) && cmd.cmd_prefix_ >= 128) {
-      HistogramAddDistance(dist_histo, cmd.dist_prefix_ & 0x3FF);
-    }
-  }
-}
-
-static void StoreDataWithHuffmanCodes(const uint8_t* input,
-                                      size_t start_pos,
-                                      size_t mask,
-                                      const Command* commands,
-                                      size_t n_commands,
-                                      const uint8_t* lit_depth,
-                                      const uint16_t* lit_bits,
-                                      const uint8_t* cmd_depth,
-                                      const uint16_t* cmd_bits,
-                                      const uint8_t* dist_depth,
-                                      const uint16_t* dist_bits,
-                                      size_t* storage_ix,
-                                      uint8_t* storage) {
-  size_t pos = start_pos;
-  size_t i;
-  for (i = 0; i < n_commands; ++i) {
-    const Command cmd = commands[i];
-    const size_t cmd_code = cmd.cmd_prefix_;
-    size_t j;
-    BrotliWriteBits(
-        cmd_depth[cmd_code], cmd_bits[cmd_code], storage_ix, storage);
-    StoreCommandExtra(&cmd, storage_ix, storage);
-    for (j = cmd.insert_len_; j != 0; --j) {
-      const uint8_t literal = input[pos & mask];
-      BrotliWriteBits(
-          lit_depth[literal], lit_bits[literal], storage_ix, storage);
-      ++pos;
-    }
-    pos += CommandCopyLen(&cmd);
-    if (CommandCopyLen(&cmd) && cmd.cmd_prefix_ >= 128) {
-      const size_t dist_code = cmd.dist_prefix_ & 0x3FF;
-      const uint32_t distnumextra = cmd.dist_prefix_ >> 10;
-      const uint32_t distextra = cmd.dist_extra_;
-      BrotliWriteBits(dist_depth[dist_code], dist_bits[dist_code],
-                      storage_ix, storage);
-      BrotliWriteBits(distnumextra, distextra, storage_ix, storage);
-    }
-  }
-}
-
-/* TODO(eustas): pull alloc/dealloc to caller? */
-typedef struct MetablockArena {
-  HistogramLiteral lit_histo;
-  HistogramCommand cmd_histo;
-  HistogramDistance dist_histo;
-  /* TODO(eustas): merge bits and depth? */
-  uint8_t lit_depth[BROTLI_NUM_LITERAL_SYMBOLS];
-  uint16_t lit_bits[BROTLI_NUM_LITERAL_SYMBOLS];
-  uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS];
-  uint16_t cmd_bits[BROTLI_NUM_COMMAND_SYMBOLS];
-  uint8_t dist_depth[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];
-  uint16_t dist_bits[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];
-  HuffmanTree tree[MAX_HUFFMAN_TREE_SIZE];
-} MetablockArena;
-
-void duckdb_brotli::BrotliStoreMetaBlockTrivial(MemoryManager* m,
-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
-    const Command* commands, size_t n_commands,
-    size_t* storage_ix, uint8_t* storage) {
-  MetablockArena* arena = BROTLI_ALLOC(m, MetablockArena, 1);
-  uint32_t num_distance_symbols = params->dist.alphabet_size_max;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(arena)) return;
-
-  StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);
-
-  HistogramClearLiteral(&arena->lit_histo);
-  HistogramClearCommand(&arena->cmd_histo);
-  HistogramClearDistance(&arena->dist_histo);
-
-  BuildHistograms(input, start_pos, mask, commands, n_commands,
-                  &arena->lit_histo, &arena->cmd_histo, &arena->dist_histo);
-
-  BrotliWriteBits(13, 0, storage_ix, storage);
-
-  BuildAndStoreHuffmanTree(arena->lit_histo.data_, BROTLI_NUM_LITERAL_SYMBOLS,
-                           BROTLI_NUM_LITERAL_SYMBOLS, arena->tree,
-                           arena->lit_depth, arena->lit_bits,
-                           storage_ix, storage);
-  BuildAndStoreHuffmanTree(arena->cmd_histo.data_, BROTLI_NUM_COMMAND_SYMBOLS,
-                           BROTLI_NUM_COMMAND_SYMBOLS, arena->tree,
-                           arena->cmd_depth, arena->cmd_bits,
-                           storage_ix, storage);
-  BuildAndStoreHuffmanTree(arena->dist_histo.data_,
-                           MAX_SIMPLE_DISTANCE_ALPHABET_SIZE,
-                           num_distance_symbols, arena->tree,
-                           arena->dist_depth, arena->dist_bits,
-                           storage_ix, storage);
-  StoreDataWithHuffmanCodes(input, start_pos, mask, commands,
-                            n_commands, arena->lit_depth, arena->lit_bits,
-                            arena->cmd_depth, arena->cmd_bits,
-                            arena->dist_depth, arena->dist_bits,
-                            storage_ix, storage);
-  BROTLI_FREE(m, arena);
-  if (is_last) {
-    JumpToByteBoundary(storage_ix, storage);
-  }
-}
-
-void duckdb_brotli::BrotliStoreMetaBlockFast(MemoryManager* m,
-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
-    const Command* commands, size_t n_commands,
-    size_t* storage_ix, uint8_t* storage) {
-  MetablockArena* arena = BROTLI_ALLOC(m, MetablockArena, 1);
-  uint32_t num_distance_symbols = params->dist.alphabet_size_max;
-  uint32_t distance_alphabet_bits =
-      Log2FloorNonZero(num_distance_symbols - 1) + 1;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(arena)) return;
-
-  StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);
-
-  BrotliWriteBits(13, 0, storage_ix, storage);
-
-  if (n_commands <= 128) {
-    uint32_t histogram[BROTLI_NUM_LITERAL_SYMBOLS] = { 0 };
-    size_t pos = start_pos;
-    size_t num_literals = 0;
-    size_t i;
-    for (i = 0; i < n_commands; ++i) {
-      const Command cmd = commands[i];
-      size_t j;
-      for (j = cmd.insert_len_; j != 0; --j) {
-        ++histogram[input[pos & mask]];
-        ++pos;
-      }
-      num_literals += cmd.insert_len_;
-      pos += CommandCopyLen(&cmd);
-    }
-    BrotliBuildAndStoreHuffmanTreeFast(arena->tree, histogram, num_literals,
-                                       /* max_bits = */ 8,
-                                       arena->lit_depth, arena->lit_bits,
-                                       storage_ix, storage);
-    StoreStaticCommandHuffmanTree(storage_ix, storage);
-    StoreStaticDistanceHuffmanTree(storage_ix, storage);
-    StoreDataWithHuffmanCodes(input, start_pos, mask, commands,
-                              n_commands, arena->lit_depth, arena->lit_bits,
-                              kStaticCommandCodeDepth,
-                              kStaticCommandCodeBits,
-                              kStaticDistanceCodeDepth,
-                              kStaticDistanceCodeBits,
-                              storage_ix, storage);
-  } else {
-    HistogramClearLiteral(&arena->lit_histo);
-    HistogramClearCommand(&arena->cmd_histo);
-    HistogramClearDistance(&arena->dist_histo);
-    BuildHistograms(input, start_pos, mask, commands, n_commands,
-                    &arena->lit_histo, &arena->cmd_histo, &arena->dist_histo);
-    BrotliBuildAndStoreHuffmanTreeFast(arena->tree, arena->lit_histo.data_,
-                                       arena->lit_histo.total_count_,
-                                       /* max_bits = */ 8,
-                                       arena->lit_depth, arena->lit_bits,
-                                       storage_ix, storage);
-    BrotliBuildAndStoreHuffmanTreeFast(arena->tree, arena->cmd_histo.data_,
-                                       arena->cmd_histo.total_count_,
-                                       /* max_bits = */ 10,
-                                       arena->cmd_depth, arena->cmd_bits,
-                                       storage_ix, storage);
-    BrotliBuildAndStoreHuffmanTreeFast(arena->tree, arena->dist_histo.data_,
-                                       arena->dist_histo.total_count_,
-                                       /* max_bits = */
-                                       distance_alphabet_bits,
-                                       arena->dist_depth, arena->dist_bits,
-                                       storage_ix, storage);
-    StoreDataWithHuffmanCodes(input, start_pos, mask, commands,
-                              n_commands, arena->lit_depth, arena->lit_bits,
-                              arena->cmd_depth, arena->cmd_bits,
-                              arena->dist_depth, arena->dist_bits,
-                              storage_ix, storage);
-  }
-
-  BROTLI_FREE(m, arena);
-
-  if (is_last) {
-    JumpToByteBoundary(storage_ix, storage);
-  }
-}
-
-/* This is for storing uncompressed blocks (simple raw storage of
-   bytes-as-bytes). */
-void duckdb_brotli::BrotliStoreUncompressedMetaBlock(BROTLI_BOOL is_final_block,
-                                      const uint8_t* BROTLI_RESTRICT input,
-                                      size_t position, size_t mask,
-                                      size_t len,
-                                      size_t* BROTLI_RESTRICT storage_ix,
-                                      uint8_t* BROTLI_RESTRICT storage) {
-  size_t masked_pos = position & mask;
-  BrotliStoreUncompressedMetaBlockHeader(len, storage_ix, storage);
-  JumpToByteBoundary(storage_ix, storage);
-
-  if (masked_pos + len > mask + 1) {
-    size_t len1 = mask + 1 - masked_pos;
-    memcpy(&storage[*storage_ix >> 3], &input[masked_pos], len1);
-    *storage_ix += len1 << 3;
-    len -= len1;
-    masked_pos = 0;
-  }
-  memcpy(&storage[*storage_ix >> 3], &input[masked_pos], len);
-  *storage_ix += len << 3;
-
-  /* We need to clear the next 4 bytes to continue to be
-     compatible with BrotliWriteBits. */
-  BrotliWriteBitsPrepareStorage(*storage_ix, storage);
-
-  /* Since the uncompressed block itself may not be the final block, add an
-     empty one after this. */
-  if (is_final_block) {
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
-    JumpToByteBoundary(storage_ix, storage);
-  }
-}
-
-#if defined(BROTLI_TEST)
-void GetBlockLengthPrefixCodeForTest(uint32_t len, size_t* code,
-                                     uint32_t* n_extra, uint32_t* extra) {
-  GetBlockLengthPrefixCode(len, code, n_extra, extra);
-}
-#endif
-
-
diff --git a/src/duckdb/third_party/brotli/enc/brotli_bit_stream.h b/src/duckdb/third_party/brotli/enc/brotli_bit_stream.h
deleted file mode 100644
index 242c0f7fd..000000000
--- a/src/duckdb/third_party/brotli/enc/brotli_bit_stream.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/* Copyright 2014 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Functions to convert brotli-related data structures into the
-   brotli bit stream. The functions here operate under
-   assumption that there is enough space in the storage, i.e., there are
-   no out-of-range checks anywhere.
-
-   These functions do bit addressing into a byte array. The byte array
-   is called "storage" and the index to the bit is called storage_ix
-   in function arguments. */
-
-#ifndef BROTLI_ENC_BROTLI_BIT_STREAM_H_
-#define BROTLI_ENC_BROTLI_BIT_STREAM_H_
-
-#include <brotli/types.h>
-
-#include "../common/context.h"
-#include "../common/brotli_platform.h"
-#include "command.h"
-#include "entropy_encode.h"
-#include "memory.h"
-#include "metablock.h"
-
-namespace duckdb_brotli {
-
-/* All Store functions here will use a storage_ix, which is always the bit
-   position for the current storage. */
-
-BROTLI_INTERNAL void BrotliStoreHuffmanTree(const uint8_t* depths, size_t num,
-    HuffmanTree* tree, size_t* storage_ix, uint8_t* storage);
-
-BROTLI_INTERNAL void BrotliBuildAndStoreHuffmanTreeFast(
-    HuffmanTree* tree, const uint32_t* histogram, const size_t histogram_total,
-    const size_t max_bits, uint8_t* depth, uint16_t* bits, size_t* storage_ix,
-    uint8_t* storage);
-
-/* REQUIRES: length > 0 */
-/* REQUIRES: length <= (1 << 24) */
-BROTLI_INTERNAL void BrotliStoreMetaBlock(MemoryManager* m,
-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
-    uint8_t prev_byte, uint8_t prev_byte2, BROTLI_BOOL is_last,
-    const BrotliEncoderParams* params, ContextType literal_context_mode,
-    const Command* commands, size_t n_commands, const MetaBlockSplit* mb,
-    size_t* storage_ix, uint8_t* storage);
-
-/* Stores the meta-block without doing any block splitting, just collects
-   one histogram per block category and uses that for entropy coding.
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
-BROTLI_INTERNAL void BrotliStoreMetaBlockTrivial(MemoryManager* m,
-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
-    const Command* commands, size_t n_commands,
-    size_t* storage_ix, uint8_t* storage);
-
-/* Same as above, but uses static prefix codes for histograms with a only a few
-   symbols, and uses static code length prefix codes for all other histograms.
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
-BROTLI_INTERNAL void BrotliStoreMetaBlockFast(MemoryManager* m,
-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
-    const Command* commands, size_t n_commands,
-    size_t* storage_ix, uint8_t* storage);
-
-/* This is for storing uncompressed blocks (simple raw storage of
-   bytes-as-bytes).
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
-BROTLI_INTERNAL void BrotliStoreUncompressedMetaBlock(
-    BROTLI_BOOL is_final_block, const uint8_t* BROTLI_RESTRICT input,
-    size_t position, size_t mask, size_t len,
-    size_t* BROTLI_RESTRICT storage_ix, uint8_t* BROTLI_RESTRICT storage);
-
-#if defined(BROTLI_TEST)
-void GetBlockLengthPrefixCodeForTest(uint32_t, size_t*, uint32_t*, uint32_t*);
-#endif
-
-}
-
-#endif  /* BROTLI_ENC_BROTLI_BIT_STREAM_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/brotli_hash.h b/src/duckdb/third_party/brotli/enc/brotli_hash.h
deleted file mode 100644
index 70fc83e34..000000000
--- a/src/duckdb/third_party/brotli/enc/brotli_hash.h
+++ /dev/null
@@ -1,4349 +0,0 @@
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data. */
-
-#ifndef BROTLI_ENC_HASH_H_
-#define BROTLI_ENC_HASH_H_
-
-#include <stdlib.h>  /* exit */
-#include <string.h>  /* memcmp, memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "compound_dictionary.h"
-#include "encoder_dict.h"
-#include "fast_log.h"
-#include "find_match_length.h"
-#include "memory.h"
-#include "quality.h"
-#include "static_dict.h"
-
-namespace duckdb_brotli {
-
-typedef struct {
-  /**
-   * Dynamically allocated areas; regular hasher uses one or two allocations;
-   * "composite" hasher uses up to 4 allocations.
-   */
-  void* extra[4];
-
-  /**
-   * False before the fisrt invocation of HasherSetup (where "extra" memory)
-   * is allocated.
-   */
-  BROTLI_BOOL is_setup_;
-
-  size_t dict_num_lookups;
-  size_t dict_num_matches;
-
-  BrotliHasherParams params;
-
-  /**
-   * False if hasher needs to be "prepared" before use (before the first
-   * invocation of HasherSetup or after HasherReset). "preparation" is hasher
-   * data initialization (using input ringbuffer).
-   */
-  BROTLI_BOOL is_prepared_;
-} HasherCommon;
-
-#define score_t size_t
-
-static const uint32_t kCutoffTransformsCount = 10;
-/*   0,  12,   27,    23,    42,    63,    56,    48,    59,    64 */
-/* 0+0, 4+8, 8+19, 12+11, 16+26, 20+43, 24+32, 28+20, 32+27, 36+28 */
-static const uint64_t kCutoffTransforms =
-    BROTLI_MAKE_UINT64_T(0x071B520A, 0xDA2D3200);
-
-typedef struct HasherSearchResult {
-  size_t len;
-  size_t distance;
-  score_t score;
-  int len_code_delta; /* == len_code - len */
-} HasherSearchResult;
-
-/* kHashMul32 multiplier has these properties:
-   * The multiplier must be odd. Otherwise we may lose the highest bit.
-   * No long streaks of ones or zeros.
-   * There is no effort to ensure that it is a prime, the oddity is enough
-     for this use.
-   * The number has been tuned heuristically against compression benchmarks. */
-static const uint32_t kHashMul32 = 0x1E35A7BD;
-static const uint64_t kHashMul64 =
-    BROTLI_MAKE_UINT64_T(0x1FE35A7Bu, 0xD3579BD3u);
-
-static BROTLI_INLINE uint32_t Hash14(const uint8_t* data) {
-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - 14);
-}
-
-static BROTLI_INLINE void PrepareDistanceCache(
-    int* BROTLI_RESTRICT distance_cache, const int num_distances) {
-  if (num_distances > 4) {
-    int last_distance = distance_cache[0];
-    distance_cache[4] = last_distance - 1;
-    distance_cache[5] = last_distance + 1;
-    distance_cache[6] = last_distance - 2;
-    distance_cache[7] = last_distance + 2;
-    distance_cache[8] = last_distance - 3;
-    distance_cache[9] = last_distance + 3;
-    if (num_distances > 10) {
-      int next_last_distance = distance_cache[1];
-      distance_cache[10] = next_last_distance - 1;
-      distance_cache[11] = next_last_distance + 1;
-      distance_cache[12] = next_last_distance - 2;
-      distance_cache[13] = next_last_distance + 2;
-      distance_cache[14] = next_last_distance - 3;
-      distance_cache[15] = next_last_distance + 3;
-    }
-  }
-}
-
-#define BROTLI_LITERAL_BYTE_SCORE 135
-#define BROTLI_DISTANCE_BIT_PENALTY 30
-/* Score must be positive after applying maximal penalty. */
-#define BROTLI_SCORE_BASE (BROTLI_DISTANCE_BIT_PENALTY * 8 * sizeof(size_t))
-
-/* Usually, we always choose the longest backward reference. This function
-   allows for the exception of that rule.
-
-   If we choose a backward reference that is further away, it will
-   usually be coded with more bits. We approximate this by assuming
-   log2(distance). If the distance can be expressed in terms of the
-   last four distances, we use some heuristic constants to estimate
-   the bits cost. For the first up to four literals we use the bit
-   cost of the literals from the literal cost model, after that we
-   use the average bit cost of the cost model.
-
-   This function is used to sometimes discard a longer backward reference
-   when it is not much longer and the bit cost for encoding it is more
-   than the saved literals.
-
-   backward_reference_offset MUST be positive. */
-static BROTLI_INLINE score_t BackwardReferenceScore(
-    size_t copy_length, size_t backward_reference_offset) {
-  return BROTLI_SCORE_BASE + BROTLI_LITERAL_BYTE_SCORE * (score_t)copy_length -
-      BROTLI_DISTANCE_BIT_PENALTY * Log2FloorNonZero(backward_reference_offset);
-}
-
-static BROTLI_INLINE score_t BackwardReferenceScoreUsingLastDistance(
-    size_t copy_length) {
-  return BROTLI_LITERAL_BYTE_SCORE * (score_t)copy_length +
-      BROTLI_SCORE_BASE + 15;
-}
-
-static BROTLI_INLINE score_t BackwardReferencePenaltyUsingLastDistance(
-    size_t distance_short_code) {
-  return (score_t)39 + ((0x1CA10 >> (distance_short_code & 0xE)) & 0xE);
-}
-
-static BROTLI_INLINE BROTLI_BOOL TestStaticDictionaryItem(
-    const BrotliEncoderDictionary* dictionary, size_t len, size_t word_idx,
-    const uint8_t* data, size_t max_length, size_t max_backward,
-    size_t max_distance, HasherSearchResult* out) {
-  size_t offset;
-  size_t matchlen;
-  size_t backward;
-  score_t score;
-  offset = dictionary->words->offsets_by_length[len] + len * word_idx;
-  if (len > max_length) {
-    return BROTLI_FALSE;
-  }
-
-  matchlen =
-      FindMatchLengthWithLimit(data, &dictionary->words->data[offset], len);
-  if (matchlen + dictionary->cutoffTransformsCount <= len || matchlen == 0) {
-    return BROTLI_FALSE;
-  }
-  {
-    size_t cut = len - matchlen;
-    size_t transform_id = (cut << 2) +
-        (size_t)((dictionary->cutoffTransforms >> (cut * 6)) & 0x3F);
-    backward = max_backward + 1 + word_idx +
-        (transform_id << dictionary->words->size_bits_by_length[len]);
-  }
-  if (backward > max_distance) {
-    return BROTLI_FALSE;
-  }
-  score = BackwardReferenceScore(matchlen, backward);
-  if (score < out->score) {
-    return BROTLI_FALSE;
-  }
-  out->len = matchlen;
-  out->len_code_delta = (int)len - (int)matchlen;
-  out->distance = backward;
-  out->score = score;
-  return BROTLI_TRUE;
-}
-
-static BROTLI_INLINE void SearchInStaticDictionary(
-    const BrotliEncoderDictionary* dictionary,
-    HasherCommon* common, const uint8_t* data, size_t max_length,
-    size_t max_backward, size_t max_distance,
-    HasherSearchResult* out, BROTLI_BOOL shallow) {
-  size_t key;
-  size_t i;
-  if (common->dict_num_matches < (common->dict_num_lookups >> 7)) {
-    return;
-  }
-  key = Hash14(data) << 1;
-  for (i = 0; i < (shallow ? 1u : 2u); ++i, ++key) {
-    common->dict_num_lookups++;
-    if (dictionary->hash_table_lengths[key] != 0) {
-      BROTLI_BOOL item_matches = TestStaticDictionaryItem(
-          dictionary, dictionary->hash_table_lengths[key],
-          dictionary->hash_table_words[key], data,
-          max_length, max_backward, max_distance, out);
-      if (item_matches) {
-        common->dict_num_matches++;
-      }
-    }
-  }
-}
-
-typedef struct BackwardMatch {
-  uint32_t distance;
-  uint32_t length_and_code;
-} BackwardMatch;
-
-static BROTLI_INLINE void InitBackwardMatch(BackwardMatch* self,
-    size_t dist, size_t len) {
-  self->distance = (uint32_t)dist;
-  self->length_and_code = (uint32_t)(len << 5);
-}
-
-static BROTLI_INLINE void InitDictionaryBackwardMatch(BackwardMatch* self,
-    size_t dist, size_t len, size_t len_code) {
-  self->distance = (uint32_t)dist;
-  self->length_and_code =
-      (uint32_t)((len << 5) | (len == len_code ? 0 : len_code));
-}
-
-static BROTLI_INLINE size_t BackwardMatchLength(const BackwardMatch* self) {
-  return self->length_and_code >> 5;
-}
-
-static BROTLI_INLINE size_t BackwardMatchLengthCode(const BackwardMatch* self) {
-  size_t code = self->length_and_code & 31;
-  return code ? code : BackwardMatchLength(self);
-}
-
-#define EXPAND_CAT(a, b) CAT(a, b)
-#define CAT(a, b) a ## b
-#define FN(X) EXPAND_CAT(X, HASHER())
-
-#define HASHER() H10
-#define BUCKET_BITS 17
-#define MAX_TREE_SEARCH_DEPTH 64
-#define MAX_TREE_COMP_LENGTH 128
-/* NOLINT(build/header_guard) */
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, MAX_TREE_COMP_LENGTH,
-                        MAX_TREE_SEARCH_DEPTH */
-
-/* A (forgetful) hash table where each hash bucket contains a binary tree of
-   sequences whose first 4 bytes share the same hash code.
-   Each sequence is MAX_TREE_COMP_LENGTH long and is identified by its starting
-   position in the input data. The binary tree is sorted by the lexicographic
-   order of the sequences, and it is also a max-heap with respect to the
-   starting positions. */
-
-#define HashToBinaryTree HASHER()
-
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
-  return MAX_TREE_COMP_LENGTH;
-}
-
-static uint32_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - BUCKET_BITS);
-}
-
-typedef struct HashToBinaryTree {
-  /* The window size minus 1 */
-  size_t window_mask_;
-
-  /* Hash table that maps the 4-byte hashes of the sequence to the last
-     position where this hash was found, which is the root of the binary
-     tree of sequences that share this hash bucket. */
-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
-
-  /* A position used to mark a non-existent sequence, i.e. a tree is empty if
-     its root is at invalid_pos_ and a node is a leaf if both its children
-     are at invalid_pos_. */
-  uint32_t invalid_pos_;
-
-  /* --- Dynamic size members --- */
-
-  /* The union of the binary trees of each hash bucket. The root of the tree
-     corresponding to a hash is a sequence starting at buckets_[hash] and
-     the left and right children of a sequence starting at pos are
-     forest_[2 * pos] and forest_[2 * pos + 1]. */
-  uint32_t* forest_;  /* uint32_t[2 * num_nodes] */
-} HashToBinaryTree;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashToBinaryTree* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->buckets_ = (uint32_t*)common->extra[0];
-  self->forest_ = (uint32_t*)common->extra[1];
-
-  self->window_mask_ = (1u << params->lgwin) - 1u;
-  self->invalid_pos_ = (uint32_t)(0 - self->window_mask_);
-}
-
-static void FN(Prepare)
-    (HashToBinaryTree* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t invalid_pos = self->invalid_pos_;
-  uint32_t i;
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  BROTLI_UNUSED(data);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  for (i = 0; i < BUCKET_SIZE; i++) {
-    buckets[i] = invalid_pos;
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  size_t num_nodes = (size_t)1 << params->lgwin;
-  if (one_shot && input_size < num_nodes) {
-    num_nodes = input_size;
-  }
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE;
-  alloc_size[1] = 2 * sizeof(uint32_t) * num_nodes;
-}
-
-static BROTLI_INLINE size_t FN(LeftChildIndex)(
-    HashToBinaryTree* BROTLI_RESTRICT self,
-    const size_t pos) {
-  return 2 * (pos & self->window_mask_);
-}
-
-static BROTLI_INLINE size_t FN(RightChildIndex)(
-    HashToBinaryTree* BROTLI_RESTRICT self,
-    const size_t pos) {
-  return 2 * (pos & self->window_mask_) + 1;
-}
-
-/* Stores the hash of the next 4 bytes and in a single tree-traversal, the
-   hash bucket's binary tree is searched for matches and is re-rooted at the
-   current position.
-
-   If less than MAX_TREE_COMP_LENGTH data is available, the hash bucket of the
-   current position is searched for matches, but the state of the hash table
-   is not changed, since we can not know the final sorting order of the
-   current (incomplete) sequence.
-
-   This function must be called with increasing cur_ix positions. */
-static BROTLI_INLINE BackwardMatch* FN(StoreAndFindMatches)(
-    HashToBinaryTree* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t cur_ix, const size_t ring_buffer_mask, const size_t max_length,
-    const size_t max_backward, size_t* const BROTLI_RESTRICT best_len,
-    BackwardMatch* BROTLI_RESTRICT matches) {
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  const size_t max_comp_len =
-      BROTLI_MIN(size_t, max_length, MAX_TREE_COMP_LENGTH);
-  const BROTLI_BOOL should_reroot_tree =
-      TO_BROTLI_BOOL(max_length >= MAX_TREE_COMP_LENGTH);
-  const uint32_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  uint32_t* BROTLI_RESTRICT forest = self->forest_;
-  size_t prev_ix = buckets[key];
-  /* The forest index of the rightmost node of the left subtree of the new
-     root, updated as we traverse and re-root the tree of the hash bucket. */
-  size_t node_left = FN(LeftChildIndex)(self, cur_ix);
-  /* The forest index of the leftmost node of the right subtree of the new
-     root, updated as we traverse and re-root the tree of the hash bucket. */
-  size_t node_right = FN(RightChildIndex)(self, cur_ix);
-  /* The match length of the rightmost node of the left subtree of the new
-     root, updated as we traverse and re-root the tree of the hash bucket. */
-  size_t best_len_left = 0;
-  /* The match length of the leftmost node of the right subtree of the new
-     root, updated as we traverse and re-root the tree of the hash bucket. */
-  size_t best_len_right = 0;
-  size_t depth_remaining;
-  if (should_reroot_tree) {
-    buckets[key] = (uint32_t)cur_ix;
-  }
-  for (depth_remaining = MAX_TREE_SEARCH_DEPTH; ; --depth_remaining) {
-    const size_t backward = cur_ix - prev_ix;
-    const size_t prev_ix_masked = prev_ix & ring_buffer_mask;
-    if (backward == 0 || backward > max_backward || depth_remaining == 0) {
-      if (should_reroot_tree) {
-        forest[node_left] = self->invalid_pos_;
-        forest[node_right] = self->invalid_pos_;
-      }
-      break;
-    }
-    {
-      const size_t cur_len = BROTLI_MIN(size_t, best_len_left, best_len_right);
-      size_t len;
-      BROTLI_DCHECK(cur_len <= MAX_TREE_COMP_LENGTH);
-      len = cur_len +
-          FindMatchLengthWithLimit(&data[cur_ix_masked + cur_len],
-                                   &data[prev_ix_masked + cur_len],
-                                   max_length - cur_len);
-      BROTLI_DCHECK(
-          0 == memcmp(&data[cur_ix_masked], &data[prev_ix_masked], len));
-      if (matches && len > *best_len) {
-        *best_len = len;
-        InitBackwardMatch(matches++, backward, len);
-      }
-      if (len >= max_comp_len) {
-        if (should_reroot_tree) {
-          forest[node_left] = forest[FN(LeftChildIndex)(self, prev_ix)];
-          forest[node_right] = forest[FN(RightChildIndex)(self, prev_ix)];
-        }
-        break;
-      }
-      if (data[cur_ix_masked + len] > data[prev_ix_masked + len]) {
-        best_len_left = len;
-        if (should_reroot_tree) {
-          forest[node_left] = (uint32_t)prev_ix;
-        }
-        node_left = FN(RightChildIndex)(self, prev_ix);
-        prev_ix = forest[node_left];
-      } else {
-        best_len_right = len;
-        if (should_reroot_tree) {
-          forest[node_right] = (uint32_t)prev_ix;
-        }
-        node_right = FN(LeftChildIndex)(self, prev_ix);
-        prev_ix = forest[node_right];
-      }
-    }
-  }
-  return matches;
-}
-
-/* Finds all backward matches of &data[cur_ix & ring_buffer_mask] up to the
-   length of max_length and stores the position cur_ix in the hash table.
-
-   Sets *num_matches to the number of matches found, and stores the found
-   matches in matches[0] to matches[*num_matches - 1]. The matches will be
-   sorted by strictly increasing length and (non-strictly) increasing
-   distance. */
-static BROTLI_INLINE size_t FN(FindAllMatches)(
-    HashToBinaryTree* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const BrotliEncoderParams* params,
-    BackwardMatch* matches) {
-  BackwardMatch* const orig_matches = matches;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  size_t best_len = 1;
-  const size_t short_match_max_backward =
-      params->quality != HQ_ZOPFLIFICATION_QUALITY ? 16 : 64;
-  size_t stop = cur_ix - short_match_max_backward;
-  uint32_t dict_matches[BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1];
-  size_t i;
-  if (cur_ix < short_match_max_backward) { stop = 0; }
-  for (i = cur_ix - 1; i > stop && best_len <= 2; --i) {
-    size_t prev_ix = i;
-    const size_t backward = cur_ix - prev_ix;
-    if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
-      break;
-    }
-    prev_ix &= ring_buffer_mask;
-    if (data[cur_ix_masked] != data[prev_ix] ||
-        data[cur_ix_masked + 1] != data[prev_ix + 1]) {
-      continue;
-    }
-    {
-      const size_t len =
-          FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
-                                   max_length);
-      if (len > best_len) {
-        best_len = len;
-        InitBackwardMatch(matches++, backward, len);
-      }
-    }
-  }
-  if (best_len < max_length) {
-    matches = FN(StoreAndFindMatches)(self, data, cur_ix,
-        ring_buffer_mask, max_length, max_backward, &best_len, matches);
-  }
-  for (i = 0; i <= BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN; ++i) {
-    dict_matches[i] = kInvalidMatch;
-  }
-  {
-    size_t minlen = BROTLI_MAX(size_t, 4, best_len + 1);
-    if (BrotliFindAllStaticDictionaryMatches(dictionary,
-        &data[cur_ix_masked], minlen, max_length, &dict_matches[0])) {
-      size_t maxlen = BROTLI_MIN(
-          size_t, BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN, max_length);
-      size_t l;
-      for (l = minlen; l <= maxlen; ++l) {
-        uint32_t dict_id = dict_matches[l];
-        if (dict_id < kInvalidMatch) {
-          size_t distance = dictionary_distance + (dict_id >> 5) + 1;
-          if (distance <= params->dist.max_distance) {
-            InitDictionaryBackwardMatch(matches++, distance, l, dict_id & 31);
-          }
-        }
-      }
-    }
-  }
-  return (size_t)(matches - orig_matches);
-}
-
-/* Stores the hash of the next 4 bytes and re-roots the binary tree at the
-   current sequence, without returning any matches.
-   REQUIRES: ix + MAX_TREE_COMP_LENGTH <= end-of-current-block */
-static BROTLI_INLINE void FN(Store)(HashToBinaryTree* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data,
-    const size_t mask, const size_t ix) {
-  /* Maximum distance is window size - 16, see section 9.1. of the spec. */
-  const size_t max_backward = self->window_mask_ - BROTLI_WINDOW_GAP + 1;
-  FN(StoreAndFindMatches)(self, data, ix, mask, MAX_TREE_COMP_LENGTH,
-      max_backward, NULL, NULL);
-}
-
-static BROTLI_INLINE void FN(StoreRange)(HashToBinaryTree* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i = ix_start;
-  size_t j = ix_start;
-  if (ix_start + 63 <= ix_end) {
-    i = ix_end - 63;
-  }
-  if (ix_start + 512 <= i) {
-    for (; j < i; j += 8) {
-      FN(Store)(self, data, mask, j);
-    }
-  }
-  for (; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashToBinaryTree* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 &&
-      position >= MAX_TREE_COMP_LENGTH) {
-    /* Store the last `MAX_TREE_COMP_LENGTH - 1` positions in the hasher.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    const size_t i_start = position - MAX_TREE_COMP_LENGTH + 1;
-    const size_t i_end = BROTLI_MIN(size_t, position, i_start + num_bytes);
-    size_t i;
-    for (i = i_start; i < i_end; ++i) {
-      /* Maximum distance is window size - 16, see section 9.1. of the spec.
-         Furthermore, we have to make sure that we don't look further back
-         from the start of the next block than the window size, otherwise we
-         could access already overwritten areas of the ring-buffer. */
-      const size_t max_backward =
-          self->window_mask_ - BROTLI_MAX(size_t,
-                                          BROTLI_WINDOW_GAP - 1,
-                                          position - i);
-      /* We know that i + MAX_TREE_COMP_LENGTH <= position + num_bytes, i.e. the
-         end of the current block and that we have at least
-         MAX_TREE_COMP_LENGTH tail in the ring-buffer. */
-      FN(StoreAndFindMatches)(self, ringbuffer, i, ringbuffer_mask,
-          MAX_TREE_COMP_LENGTH, max_backward, NULL, NULL);
-    }
-  }
-}
-
-#undef BUCKET_SIZE
-
-#undef HashToBinaryTree
-#undef MAX_TREE_SEARCH_DEPTH
-#undef MAX_TREE_COMP_LENGTH
-#undef BUCKET_BITS
-#undef HASHER
-/* MAX_NUM_MATCHES == 64 + MAX_TREE_SEARCH_DEPTH */
-#define MAX_NUM_MATCHES_H10 128
-
-/* For BUCKET_SWEEP_BITS == 0, enabling the dictionary lookup makes compression
-   a little faster (0.5% - 1%) and it compresses 0.15% better on small text
-   and HTML inputs. */
-
-#define HASHER() H2
-#define BUCKET_BITS 16
-#define BUCKET_SWEEP_BITS 0
-#define HASH_LEN 5
-#define USE_DICTIONARY 1
-/* NOLINT(build/header_guard) */
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP_BITS, HASH_LEN,
-                        USE_DICTIONARY
- */
-
-#define HashLongestMatchQuickly HASHER()
-
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-#define BUCKET_MASK (BUCKET_SIZE - 1)
-#define BUCKET_SWEEP (1 << BUCKET_SWEEP_BITS)
-#define BUCKET_SWEEP_MASK ((BUCKET_SWEEP - 1) << 3)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
-
-/* HashBytes is the function that chooses the bucket to place
-   the address in. The HashLongestMatch and HashLongestMatchQuickly
-   classes have separate, different implementations of hashing. */
-static uint32_t FN(HashBytes)(const uint8_t* data) {
-  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8 * HASH_LEN)) *
-                      kHashMul64);
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return (uint32_t)(h >> (64 - BUCKET_BITS));
-}
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   This is a hash map of fixed size (BUCKET_SIZE). */
-typedef struct HashLongestMatchQuickly {
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
-} HashLongestMatchQuickly;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-
-  BROTLI_UNUSED(params);
-  self->buckets_ = (uint32_t*)common->extra[0];
-}
-
-static void FN(Prepare)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 5;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      const uint32_t key = FN(HashBytes)(&data[i]);
-      if (BUCKET_SWEEP == 1) {
-        buckets[key] = 0;
-      } else {
-        uint32_t j;
-        for (j = 0; j < BUCKET_SWEEP; ++j) {
-          buckets[(key + (j << 3)) & BUCKET_MASK] = 0;
-        }
-      }
-    }
-  } else {
-    /* It is not strictly necessary to fill this buffer here, but
-       not filling will make the results of the compression stochastic
-       (but correct). This is because random data would cause the
-       system to find accidentally good backward references here and there. */
-    memset(buckets, 0, sizeof(uint32_t) * BUCKET_SIZE);
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE;
-}
-
-/* Look at 5 bytes at &data[ix & mask].
-   Compute a hash from these, and store the value somewhere within
-   [ix .. ix+3]. */
-static BROTLI_INLINE void FN(Store)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  const uint32_t key = FN(HashBytes)(&data[ix & mask]);
-  if (BUCKET_SWEEP == 1) {
-    self->buckets_[key] = (uint32_t)ix;
-  } else {
-    /* Wiggle the value with the bucket sweep range. */
-    const uint32_t off = ix & BUCKET_SWEEP_MASK;
-    self->buckets_[(key + off) & BUCKET_MASK] = (uint32_t)ix;
-  }
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(distance_cache);
-}
-
-/* Find a longest backward match of &data[cur_ix & ring_buffer_mask]
-   up to the length of max_length and stores the position cur_ix in the
-   hash table.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t best_len_in = out->len;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  int compare_char = data[cur_ix_masked + best_len_in];
-  size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  size_t key_out;
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = best_len_in;
-  size_t cached_backward = (size_t)distance_cache[0];
-  size_t prev_ix = cur_ix - cached_backward;
-  out->len_code_delta = 0;
-  if (prev_ix < cur_ix) {
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char == data[prev_ix + best_len]) {
-      const size_t len = FindMatchLengthWithLimit(
-          &data[prev_ix], &data[cur_ix_masked], max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          out->len = len;
-          out->distance = cached_backward;
-          out->score = score;
-          if (BUCKET_SWEEP == 1) {
-            buckets[key] = (uint32_t)cur_ix;
-            return;
-          } else {
-            best_len = len;
-            best_score = score;
-            compare_char = data[cur_ix_masked + len];
-          }
-        }
-      }
-    }
-  }
-  if (BUCKET_SWEEP == 1) {
-    size_t backward;
-    size_t len;
-    /* Only one to look for, don't bother to prepare for a loop. */
-    prev_ix = buckets[key];
-    buckets[key] = (uint32_t)cur_ix;
-    backward = cur_ix - prev_ix;
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char != data[prev_ix + best_len_in]) {
-      return;
-    }
-    if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-      return;
-    }
-    len = FindMatchLengthWithLimit(&data[prev_ix],
-                                   &data[cur_ix_masked],
-                                   max_length);
-    if (len >= 4) {
-      const score_t score = BackwardReferenceScore(len, backward);
-      if (best_score < score) {
-        out->len = len;
-        out->distance = backward;
-        out->score = score;
-        return;
-      }
-    }
-  } else {
-    size_t keys[BUCKET_SWEEP];
-    size_t i;
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      keys[i] = (key + (i << 3)) & BUCKET_MASK;
-    }
-    key_out = keys[(cur_ix & BUCKET_SWEEP_MASK) >> 3];
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      size_t len;
-      size_t backward;
-      prev_ix = buckets[keys[i]];
-      backward = cur_ix - prev_ix;
-      prev_ix &= (uint32_t)ring_buffer_mask;
-      if (compare_char != data[prev_ix + best_len]) {
-        continue;
-      }
-      if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-        continue;
-      }
-      len = FindMatchLengthWithLimit(&data[prev_ix],
-                                     &data[cur_ix_masked],
-                                     max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScore(len, backward);
-        if (best_score < score) {
-          best_len = len;
-          out->len = len;
-          compare_char = data[cur_ix_masked + len];
-          best_score = score;
-          out->score = score;
-          out->distance = backward;
-        }
-      }
-    }
-  }
-  if (USE_DICTIONARY && min_score == out->score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_TRUE);
-  }
-  if (BUCKET_SWEEP != 1) {
-    buckets[key_out] = (uint32_t)cur_ix;
-  }
-}
-
-#undef BUCKET_SWEEP_MASK
-#undef BUCKET_SWEEP
-#undef BUCKET_MASK
-#undef BUCKET_SIZE
-
-#undef HashLongestMatchQuickly
-#undef BUCKET_SWEEP_BITS
-#undef USE_DICTIONARY
-#undef HASHER
-
-#define HASHER() H3
-#define BUCKET_SWEEP_BITS 1
-#define USE_DICTIONARY 0
-/* NOLINT(build/header_guard) */
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP_BITS, HASH_LEN,
-                        USE_DICTIONARY
- */
-
-#define HashLongestMatchQuickly HASHER()
-
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-#define BUCKET_MASK (BUCKET_SIZE - 1)
-#define BUCKET_SWEEP (1 << BUCKET_SWEEP_BITS)
-#define BUCKET_SWEEP_MASK ((BUCKET_SWEEP - 1) << 3)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
-
-/* HashBytes is the function that chooses the bucket to place
-   the address in. The HashLongestMatch and HashLongestMatchQuickly
-   classes have separate, different implementations of hashing. */
-static uint32_t FN(HashBytes)(const uint8_t* data) {
-  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8 * HASH_LEN)) *
-                      kHashMul64);
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return (uint32_t)(h >> (64 - BUCKET_BITS));
-}
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   This is a hash map of fixed size (BUCKET_SIZE). */
-typedef struct HashLongestMatchQuickly {
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
-} HashLongestMatchQuickly;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-
-  BROTLI_UNUSED(params);
-  self->buckets_ = (uint32_t*)common->extra[0];
-}
-
-static void FN(Prepare)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 5;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      const uint32_t key = FN(HashBytes)(&data[i]);
-      if (BUCKET_SWEEP == 1) {
-        buckets[key] = 0;
-      } else {
-        uint32_t j;
-        for (j = 0; j < BUCKET_SWEEP; ++j) {
-          buckets[(key + (j << 3)) & BUCKET_MASK] = 0;
-        }
-      }
-    }
-  } else {
-    /* It is not strictly necessary to fill this buffer here, but
-       not filling will make the results of the compression stochastic
-       (but correct). This is because random data would cause the
-       system to find accidentally good backward references here and there. */
-    memset(buckets, 0, sizeof(uint32_t) * BUCKET_SIZE);
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE;
-}
-
-/* Look at 5 bytes at &data[ix & mask].
-   Compute a hash from these, and store the value somewhere within
-   [ix .. ix+3]. */
-static BROTLI_INLINE void FN(Store)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  const uint32_t key = FN(HashBytes)(&data[ix & mask]);
-  if (BUCKET_SWEEP == 1) {
-    self->buckets_[key] = (uint32_t)ix;
-  } else {
-    /* Wiggle the value with the bucket sweep range. */
-    const uint32_t off = ix & BUCKET_SWEEP_MASK;
-    self->buckets_[(key + off) & BUCKET_MASK] = (uint32_t)ix;
-  }
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(distance_cache);
-}
-
-/* Find a longest backward match of &data[cur_ix & ring_buffer_mask]
-   up to the length of max_length and stores the position cur_ix in the
-   hash table.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t best_len_in = out->len;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  int compare_char = data[cur_ix_masked + best_len_in];
-  size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  size_t key_out;
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = best_len_in;
-  size_t cached_backward = (size_t)distance_cache[0];
-  size_t prev_ix = cur_ix - cached_backward;
-  out->len_code_delta = 0;
-  if (prev_ix < cur_ix) {
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char == data[prev_ix + best_len]) {
-      const size_t len = FindMatchLengthWithLimit(
-          &data[prev_ix], &data[cur_ix_masked], max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          out->len = len;
-          out->distance = cached_backward;
-          out->score = score;
-          if (BUCKET_SWEEP == 1) {
-            buckets[key] = (uint32_t)cur_ix;
-            return;
-          } else {
-            best_len = len;
-            best_score = score;
-            compare_char = data[cur_ix_masked + len];
-          }
-        }
-      }
-    }
-  }
-  if (BUCKET_SWEEP == 1) {
-    size_t backward;
-    size_t len;
-    /* Only one to look for, don't bother to prepare for a loop. */
-    prev_ix = buckets[key];
-    buckets[key] = (uint32_t)cur_ix;
-    backward = cur_ix - prev_ix;
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char != data[prev_ix + best_len_in]) {
-      return;
-    }
-    if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-      return;
-    }
-    len = FindMatchLengthWithLimit(&data[prev_ix],
-                                   &data[cur_ix_masked],
-                                   max_length);
-    if (len >= 4) {
-      const score_t score = BackwardReferenceScore(len, backward);
-      if (best_score < score) {
-        out->len = len;
-        out->distance = backward;
-        out->score = score;
-        return;
-      }
-    }
-  } else {
-    size_t keys[BUCKET_SWEEP];
-    size_t i;
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      keys[i] = (key + (i << 3)) & BUCKET_MASK;
-    }
-    key_out = keys[(cur_ix & BUCKET_SWEEP_MASK) >> 3];
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      size_t len;
-      size_t backward;
-      prev_ix = buckets[keys[i]];
-      backward = cur_ix - prev_ix;
-      prev_ix &= (uint32_t)ring_buffer_mask;
-      if (compare_char != data[prev_ix + best_len]) {
-        continue;
-      }
-      if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-        continue;
-      }
-      len = FindMatchLengthWithLimit(&data[prev_ix],
-                                     &data[cur_ix_masked],
-                                     max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScore(len, backward);
-        if (best_score < score) {
-          best_len = len;
-          out->len = len;
-          compare_char = data[cur_ix_masked + len];
-          best_score = score;
-          out->score = score;
-          out->distance = backward;
-        }
-      }
-    }
-  }
-  if (USE_DICTIONARY && min_score == out->score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_TRUE);
-  }
-  if (BUCKET_SWEEP != 1) {
-    buckets[key_out] = (uint32_t)cur_ix;
-  }
-}
-
-#undef BUCKET_SWEEP_MASK
-#undef BUCKET_SWEEP
-#undef BUCKET_MASK
-#undef BUCKET_SIZE
-
-#undef HashLongestMatchQuickly
-#undef USE_DICTIONARY
-#undef BUCKET_SWEEP_BITS
-#undef BUCKET_BITS
-#undef HASHER
-
-#define HASHER() H4
-#define BUCKET_BITS 17
-#define BUCKET_SWEEP_BITS 2
-#define USE_DICTIONARY 1
-/* NOLINT(build/header_guard) */
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP_BITS, HASH_LEN,
-                        USE_DICTIONARY
- */
-
-#define HashLongestMatchQuickly HASHER()
-
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-#define BUCKET_MASK (BUCKET_SIZE - 1)
-#define BUCKET_SWEEP (1 << BUCKET_SWEEP_BITS)
-#define BUCKET_SWEEP_MASK ((BUCKET_SWEEP - 1) << 3)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
-
-/* HashBytes is the function that chooses the bucket to place
-   the address in. The HashLongestMatch and HashLongestMatchQuickly
-   classes have separate, different implementations of hashing. */
-static uint32_t FN(HashBytes)(const uint8_t* data) {
-  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8 * HASH_LEN)) *
-                      kHashMul64);
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return (uint32_t)(h >> (64 - BUCKET_BITS));
-}
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   This is a hash map of fixed size (BUCKET_SIZE). */
-typedef struct HashLongestMatchQuickly {
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
-} HashLongestMatchQuickly;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-
-  BROTLI_UNUSED(params);
-  self->buckets_ = (uint32_t*)common->extra[0];
-}
-
-static void FN(Prepare)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 5;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      const uint32_t key = FN(HashBytes)(&data[i]);
-      if (BUCKET_SWEEP == 1) {
-        buckets[key] = 0;
-      } else {
-        uint32_t j;
-        for (j = 0; j < BUCKET_SWEEP; ++j) {
-          buckets[(key + (j << 3)) & BUCKET_MASK] = 0;
-        }
-      }
-    }
-  } else {
-    /* It is not strictly necessary to fill this buffer here, but
-       not filling will make the results of the compression stochastic
-       (but correct). This is because random data would cause the
-       system to find accidentally good backward references here and there. */
-    memset(buckets, 0, sizeof(uint32_t) * BUCKET_SIZE);
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE;
-}
-
-/* Look at 5 bytes at &data[ix & mask].
-   Compute a hash from these, and store the value somewhere within
-   [ix .. ix+3]. */
-static BROTLI_INLINE void FN(Store)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  const uint32_t key = FN(HashBytes)(&data[ix & mask]);
-  if (BUCKET_SWEEP == 1) {
-    self->buckets_[key] = (uint32_t)ix;
-  } else {
-    /* Wiggle the value with the bucket sweep range. */
-    const uint32_t off = ix & BUCKET_SWEEP_MASK;
-    self->buckets_[(key + off) & BUCKET_MASK] = (uint32_t)ix;
-  }
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(distance_cache);
-}
-
-/* Find a longest backward match of &data[cur_ix & ring_buffer_mask]
-   up to the length of max_length and stores the position cur_ix in the
-   hash table.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t best_len_in = out->len;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  int compare_char = data[cur_ix_masked + best_len_in];
-  size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  size_t key_out;
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = best_len_in;
-  size_t cached_backward = (size_t)distance_cache[0];
-  size_t prev_ix = cur_ix - cached_backward;
-  out->len_code_delta = 0;
-  if (prev_ix < cur_ix) {
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char == data[prev_ix + best_len]) {
-      const size_t len = FindMatchLengthWithLimit(
-          &data[prev_ix], &data[cur_ix_masked], max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          out->len = len;
-          out->distance = cached_backward;
-          out->score = score;
-          if (BUCKET_SWEEP == 1) {
-            buckets[key] = (uint32_t)cur_ix;
-            return;
-          } else {
-            best_len = len;
-            best_score = score;
-            compare_char = data[cur_ix_masked + len];
-          }
-        }
-      }
-    }
-  }
-  if (BUCKET_SWEEP == 1) {
-    size_t backward;
-    size_t len;
-    /* Only one to look for, don't bother to prepare for a loop. */
-    prev_ix = buckets[key];
-    buckets[key] = (uint32_t)cur_ix;
-    backward = cur_ix - prev_ix;
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char != data[prev_ix + best_len_in]) {
-      return;
-    }
-    if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-      return;
-    }
-    len = FindMatchLengthWithLimit(&data[prev_ix],
-                                   &data[cur_ix_masked],
-                                   max_length);
-    if (len >= 4) {
-      const score_t score = BackwardReferenceScore(len, backward);
-      if (best_score < score) {
-        out->len = len;
-        out->distance = backward;
-        out->score = score;
-        return;
-      }
-    }
-  } else {
-    size_t keys[BUCKET_SWEEP];
-    size_t i;
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      keys[i] = (key + (i << 3)) & BUCKET_MASK;
-    }
-    key_out = keys[(cur_ix & BUCKET_SWEEP_MASK) >> 3];
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      size_t len;
-      size_t backward;
-      prev_ix = buckets[keys[i]];
-      backward = cur_ix - prev_ix;
-      prev_ix &= (uint32_t)ring_buffer_mask;
-      if (compare_char != data[prev_ix + best_len]) {
-        continue;
-      }
-      if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-        continue;
-      }
-      len = FindMatchLengthWithLimit(&data[prev_ix],
-                                     &data[cur_ix_masked],
-                                     max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScore(len, backward);
-        if (best_score < score) {
-          best_len = len;
-          out->len = len;
-          compare_char = data[cur_ix_masked + len];
-          best_score = score;
-          out->score = score;
-          out->distance = backward;
-        }
-      }
-    }
-  }
-  if (USE_DICTIONARY && min_score == out->score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_TRUE);
-  }
-  if (BUCKET_SWEEP != 1) {
-    buckets[key_out] = (uint32_t)cur_ix;
-  }
-}
-
-#undef BUCKET_SWEEP_MASK
-#undef BUCKET_SWEEP
-#undef BUCKET_MASK
-#undef BUCKET_SIZE
-
-#undef HashLongestMatchQuickly
-#undef USE_DICTIONARY
-#undef HASH_LEN
-#undef BUCKET_SWEEP_BITS
-#undef BUCKET_BITS
-#undef HASHER
-
-#define HASHER() H5
-/* NOLINT(build/header_guard) */
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   This is a hash map of fixed size (bucket_size_) to a ring buffer of
-   fixed size (block_size_). The ring buffer contains the last block_size_
-   index positions of the given hash key in the compressed data. */
-
-#define HashLongestMatch HASHER()
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
-
-/* HashBytes is the function that chooses the bucket to place the address in. */
-static uint32_t FN(HashBytes)(
-    const uint8_t* BROTLI_RESTRICT data, const int shift) {
-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return (uint32_t)(h >> shift);
-}
-
-typedef struct HashLongestMatch {
-  /* Number of hash buckets. */
-  size_t bucket_size_;
-  /* Only block_size_ newest backward references are kept,
-     and the older are forgotten. */
-  size_t block_size_;
-  /* Left-shift for computing hash bucket index from hash value. */
-  int hash_shift_;
-  /* Mask for accessing entries in a block (in a ring-buffer manner). */
-  uint32_t block_mask_;
-
-  int block_bits_;
-  int num_last_distances_to_check_;
-
-  /* Shortcuts. */
-  HasherCommon* common_;
-
-  /* --- Dynamic size members --- */
-
-  /* Number of entries in a particular bucket. */
-  uint16_t* num_;  /* uint16_t[bucket_size]; */
-
-  /* Buckets containing block_size_ of backward references. */
-  uint32_t* buckets_;  /* uint32_t[bucket_size * block_size]; */
-} HashLongestMatch;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashLongestMatch* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common_ = common;
-
-  BROTLI_UNUSED(params);
-  self->hash_shift_ = 32 - common->params.bucket_bits;
-  self->bucket_size_ = (size_t)1 << common->params.bucket_bits;
-  self->block_size_ = (size_t)1 << common->params.block_bits;
-  self->block_mask_ = (uint32_t)(self->block_size_ - 1);
-  self->num_ = (uint16_t*)common->extra[0];
-  self->buckets_ = (uint32_t*)common->extra[1];
-  self->block_bits_ = common->params.block_bits;
-  self->num_last_distances_to_check_ =
-      common->params.num_last_distances_to_check;
-}
-
-static void FN(Prepare)(
-    HashLongestMatch* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint16_t* BROTLI_RESTRICT num = self->num_;
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = self->bucket_size_ >> 6;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      const uint32_t key = FN(HashBytes)(&data[i], self->hash_shift_);
-      num[key] = 0;
-    }
-  } else {
-    memset(num, 0, self->bucket_size_ * sizeof(num[0]));
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  size_t bucket_size = (size_t)1 << params->hasher.bucket_bits;
-  size_t block_size = (size_t)1 << params->hasher.block_bits;
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint16_t) * bucket_size;
-  alloc_size[1] = sizeof(uint32_t) * bucket_size * block_size;
-}
-
-/* Look at 4 bytes at &data[ix & mask].
-   Compute a hash from these, and store the value of ix at that position. */
-static BROTLI_INLINE void FN(Store)(
-    HashLongestMatch* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t mask, const size_t ix) {
-  const uint32_t key = FN(HashBytes)(&data[ix & mask], self->hash_shift_);
-  const size_t minor_ix = self->num_[key] & self->block_mask_;
-  const size_t offset = minor_ix + (key << self->block_bits_);
-  self->buckets_[offset] = (uint32_t)ix;
-  ++self->num_[key];
-}
-
-static BROTLI_INLINE void FN(StoreRange)(HashLongestMatch* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashLongestMatch* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashLongestMatch* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  PrepareDistanceCache(distance_cache, self->num_last_distances_to_check_);
-}
-
-/* Find a longest backward match of &data[cur_ix] up to the length of
-   max_length and stores the position cur_ix in the hash table.
-
-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
-             values; if this method is invoked repeatedly with the same distance
-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashLongestMatch* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint16_t* BROTLI_RESTRICT num = self->num_;
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  /* Don't accept a short copy from far away. */
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = out->len;
-  size_t i;
-  out->len = 0;
-  out->len_code_delta = 0;
-  /* Try last distance first. */
-  for (i = 0; i < (size_t)self->num_last_distances_to_check_; ++i) {
-    const size_t backward = (size_t)distance_cache[i];
-    size_t prev_ix = (size_t)(cur_ix - backward);
-    if (prev_ix >= cur_ix) {
-      continue;
-    }
-    if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
-      continue;
-    }
-    prev_ix &= ring_buffer_mask;
-
-    if (cur_ix_masked + best_len > ring_buffer_mask ||
-        prev_ix + best_len > ring_buffer_mask ||
-        data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-      continue;
-    }
-    {
-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                  &data[cur_ix_masked],
-                                                  max_length);
-      if (len >= 3 || (len == 2 && i < 2)) {
-        /* Comparing for >= 2 does not change the semantics, but just saves for
-           a few unnecessary binary logarithms in backward reference score,
-           since we are not interested in such short matches. */
-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-  }
-  {
-    const uint32_t key =
-        FN(HashBytes)(&data[cur_ix_masked], self->hash_shift_);
-    uint32_t* BROTLI_RESTRICT bucket = &buckets[key << self->block_bits_];
-    const size_t down =
-        (num[key] > self->block_size_) ? (num[key] - self->block_size_) : 0u;
-    for (i = num[key]; i > down;) {
-      size_t prev_ix = bucket[--i & self->block_mask_];
-      const size_t backward = cur_ix - prev_ix;
-      if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
-        break;
-      }
-      prev_ix &= ring_buffer_mask;
-      if (cur_ix_masked + best_len > ring_buffer_mask ||
-          prev_ix + best_len > ring_buffer_mask ||
-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-        continue;
-      }
-      {
-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                    &data[cur_ix_masked],
-                                                    max_length);
-        if (len >= 4) {
-          /* Comparing for >= 3 does not change the semantics, but just saves
-             for a few unnecessary binary logarithms in backward reference
-             score, since we are not interested in such short matches. */
-          score_t score = BackwardReferenceScore(len, backward);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
-    ++num[key];
-  }
-  if (min_score == out->score) {
-    SearchInStaticDictionary(dictionary,
-        self->common_, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_FALSE);
-  }
-}
-
-#undef HashLongestMatch
-#undef HASHER
-
-#define HASHER() H6
-/* NOLINT(build/header_guard) */
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   This is a hash map of fixed size (bucket_size_) to a ring buffer of
-   fixed size (block_size_). The ring buffer contains the last block_size_
-   index positions of the given hash key in the compressed data. */
-
-#define HashLongestMatch HASHER()
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
-
-/* HashBytes is the function that chooses the bucket to place the address in. */
-static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data,
-                                          uint64_t hash_mul) {
-  const uint64_t h = BROTLI_UNALIGNED_LOAD64LE(data) * hash_mul;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return (size_t)(h >> (64 - 15));
-}
-
-typedef struct HashLongestMatch {
-  /* Number of hash buckets. */
-  size_t bucket_size_;
-  /* Only block_size_ newest backward references are kept,
-     and the older are forgotten. */
-  size_t block_size_;
-  /* Hash multiplier tuned to match length. */
-  uint64_t hash_mul_;
-  /* Mask for accessing entries in a block (in a ring-buffer manner). */
-  uint32_t block_mask_;
-
-  int block_bits_;
-  int num_last_distances_to_check_;
-
-  /* Shortcuts. */
-  HasherCommon* common_;
-
-  /* --- Dynamic size members --- */
-
-  /* Number of entries in a particular bucket. */
-  uint16_t* num_;  /* uint16_t[bucket_size]; */
-
-  /* Buckets containing block_size_ of backward references. */
-  uint32_t* buckets_;  /* uint32_t[bucket_size * block_size]; */
-} HashLongestMatch;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashLongestMatch* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common_ = common;
-
-  BROTLI_UNUSED(params);
-  self->hash_mul_ = kHashMul64 << (64 - 5 * 8);
-  BROTLI_DCHECK(common->params.bucket_bits == 15);
-  self->bucket_size_ = (size_t)1 << common->params.bucket_bits;
-  self->block_bits_ = common->params.block_bits;
-  self->block_size_ = (size_t)1 << common->params.block_bits;
-  self->block_mask_ = (uint32_t)(self->block_size_ - 1);
-  self->num_last_distances_to_check_ =
-      common->params.num_last_distances_to_check;
-  self->num_ = (uint16_t*)common->extra[0];
-  self->buckets_ = (uint32_t*)common->extra[1];
-}
-
-static void FN(Prepare)(
-    HashLongestMatch* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint16_t* BROTLI_RESTRICT num = self->num_;
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = self->bucket_size_ >> 6;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      const size_t key = FN(HashBytes)(&data[i], self->hash_mul_);
-      num[key] = 0;
-    }
-  } else {
-    memset(num, 0, self->bucket_size_ * sizeof(num[0]));
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  size_t bucket_size = (size_t)1 << params->hasher.bucket_bits;
-  size_t block_size = (size_t)1 << params->hasher.block_bits;
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint16_t) * bucket_size;
-  alloc_size[1] = sizeof(uint32_t) * bucket_size * block_size;
-}
-
-/* Look at 4 bytes at &data[ix & mask].
-   Compute a hash from these, and store the value of ix at that position. */
-static BROTLI_INLINE void FN(Store)(
-    HashLongestMatch* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t mask, const size_t ix) {
-  uint16_t* BROTLI_RESTRICT num = self->num_;
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t key = FN(HashBytes)(&data[ix & mask], self->hash_mul_);
-  const size_t minor_ix = num[key] & self->block_mask_;
-  const size_t offset = minor_ix + (key << self->block_bits_);
-  ++num[key];
-  buckets[offset] = (uint32_t)ix;
-}
-
-static BROTLI_INLINE void FN(StoreRange)(HashLongestMatch* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashLongestMatch* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashLongestMatch* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  PrepareDistanceCache(distance_cache, self->num_last_distances_to_check_);
-}
-
-/* Find a longest backward match of &data[cur_ix] up to the length of
-   max_length and stores the position cur_ix in the hash table.
-
-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
-             values; if this method is invoked repeatedly with the same distance
-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashLongestMatch* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint16_t* BROTLI_RESTRICT num = self->num_;
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  /* Don't accept a short copy from far away. */
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = out->len;
-  size_t i;
-  out->len = 0;
-  out->len_code_delta = 0;
-  /* Try last distance first. */
-  for (i = 0; i < (size_t)self->num_last_distances_to_check_; ++i) {
-    const size_t backward = (size_t)distance_cache[i];
-    size_t prev_ix = (size_t)(cur_ix - backward);
-    if (prev_ix >= cur_ix) {
-      continue;
-    }
-    if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
-      continue;
-    }
-    prev_ix &= ring_buffer_mask;
-
-    if (cur_ix_masked + best_len > ring_buffer_mask ||
-        prev_ix + best_len > ring_buffer_mask ||
-        data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-      continue;
-    }
-    {
-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                  &data[cur_ix_masked],
-                                                  max_length);
-      if (len >= 3 || (len == 2 && i < 2)) {
-        /* Comparing for >= 2 does not change the semantics, but just saves for
-           a few unnecessary binary logarithms in backward reference score,
-           since we are not interested in such short matches. */
-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-  }
-  {
-    const size_t key = FN(HashBytes)(&data[cur_ix_masked], self->hash_mul_);
-    uint32_t* BROTLI_RESTRICT bucket = &buckets[key << self->block_bits_];
-    const size_t down =
-        (num[key] > self->block_size_) ?
-        (num[key] - self->block_size_) : 0u;
-    const uint32_t first4 = BrotliUnalignedRead32(data + cur_ix_masked);
-    const size_t max_length_m4 = max_length - 4;
-    i = num[key];
-    for (; i > down;) {
-      size_t prev_ix = bucket[--i & self->block_mask_];
-      uint32_t current4;
-      const size_t backward = cur_ix - prev_ix;
-      if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
-        break;
-      }
-      prev_ix &= ring_buffer_mask;
-      if (cur_ix_masked + best_len > ring_buffer_mask ||
-          prev_ix + best_len > ring_buffer_mask ||
-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-        continue;
-      }
-      current4 = BrotliUnalignedRead32(data + prev_ix);
-      if (first4 != current4) continue;
-      {
-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix + 4],
-                                                    &data[cur_ix_masked + 4],
-                                                    max_length_m4) + 4;
-        const score_t score = BackwardReferenceScore(len, backward);
-        if (best_score < score) {
-          best_score = score;
-          best_len = len;
-          out->len = best_len;
-          out->distance = backward;
-          out->score = best_score;
-        }
-      }
-    }
-    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
-    ++num[key];
-  }
-  if (min_score == out->score) {
-    SearchInStaticDictionary(dictionary,
-        self->common_, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_FALSE);
-  }
-}
-
-#undef HashLongestMatch
-#undef HASHER
-
-#define BUCKET_BITS 15
-
-#define NUM_LAST_DISTANCES_TO_CHECK 4
-#define NUM_BANKS 1
-#define BANK_BITS 16
-#define HASHER() H40
-/* NOLINT(build/header_guard) */
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, NUM_BANKS, BANK_BITS,
-                        NUM_LAST_DISTANCES_TO_CHECK */
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   Hashes are stored in chains which are bucketed to groups. Group of chains
-   share a storage "bank". When more than "bank size" chain nodes are added,
-   oldest nodes are replaced; this way several chains may share a tail. */
-
-#define HashForgetfulChain HASHER()
-
-#define BANK_SIZE (1 << BANK_BITS)
-
-/* Number of hash buckets. */
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-
-#define CAPPED_CHAINS 0
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
-
-/* HashBytes is the function that chooses the bucket to place the address in.*/
-static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
-  const uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - BUCKET_BITS);
-}
-
-typedef struct FN(Slot) {
-  uint16_t delta;
-  uint16_t next;
-} FN(Slot);
-
-typedef struct FN(Bank) {
-  FN(Slot) slots[BANK_SIZE];
-} FN(Bank);
-
-typedef struct HashForgetfulChain {
-  uint16_t free_slot_idx[NUM_BANKS];  /* Up to 1KiB. Move to dynamic? */
-  size_t max_hops;
-
-  /* Shortcuts. */
-  void* extra[2];
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  /* uint32_t addr[BUCKET_SIZE]; */
-
-  /* uint16_t head[BUCKET_SIZE]; */
-
-  /* Truncated hash used for quick rejection of "distance cache" candidates. */
-  /* uint8_t tiny_hash[65536];*/
-
-  /* FN(Bank) banks[NUM_BANKS]; */
-} HashForgetfulChain;
-
-static uint32_t* FN(Addr)(void* extra) {
-  return (uint32_t*)extra;
-}
-
-static uint16_t* FN(Head)(void* extra) {
-  return (uint16_t*)(&FN(Addr)(extra)[BUCKET_SIZE]);
-}
-
-static uint8_t* FN(TinyHash)(void* extra) {
-  return (uint8_t*)(&FN(Head)(extra)[BUCKET_SIZE]);
-}
-
-static FN(Bank)* FN(Banks)(void* extra) {
-  return (FN(Bank)*)(extra);
-}
-
-static void FN(Initialize)(
-    HasherCommon* common, HashForgetfulChain* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-  self->extra[0] = common->extra[0];
-  self->extra[1] = common->extra[1];
-
-  self->max_hops = (params->quality > 6 ? 7u : 8u) << (params->quality - 4);
-}
-
-static void FN(Prepare)(
-    HashForgetfulChain* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 6;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      size_t bucket = FN(HashBytes)(&data[i]);
-      /* See InitEmpty comment. */
-      addr[bucket] = 0xCCCCCCCC;
-      head[bucket] = 0xCCCC;
-    }
-  } else {
-    /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position
-       processed by hasher never reaches 3GB + 64M; this makes all new chains
-       to be terminated after the first node. */
-    memset(addr, 0xCC, sizeof(uint32_t) * BUCKET_SIZE);
-    memset(head, 0, sizeof(uint16_t) * BUCKET_SIZE);
-  }
-  memset(tiny_hash, 0, sizeof(uint8_t) * 65536);
-  memset(self->free_slot_idx, 0, sizeof(self->free_slot_idx));
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE +
-                  sizeof(uint16_t) * BUCKET_SIZE + sizeof(uint8_t) * 65536;
-  alloc_size[1] = sizeof(FN(Bank)) * NUM_BANKS;
-}
-
-/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend
-   node to corresponding chain; also update tiny_hash for current position. */
-static BROTLI_INLINE void FN(Store)(HashForgetfulChain* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
-  const size_t key = FN(HashBytes)(&data[ix & mask]);
-  const size_t bank = key & (NUM_BANKS - 1);
-  const size_t idx = self->free_slot_idx[bank]++ & (BANK_SIZE - 1);
-  size_t delta = ix - addr[key];
-  tiny_hash[(uint16_t)ix] = (uint8_t)key;
-  if (delta > 0xFFFF) delta = CAPPED_CHAINS ? 0 : 0xFFFF;
-  banks[bank].slots[idx].delta = (uint16_t)delta;
-  banks[bank].slots[idx].next = head[key];
-  addr[key] = (uint32_t)ix;
-  head[key] = (uint16_t)idx;
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  PrepareDistanceCache(distance_cache, NUM_LAST_DISTANCES_TO_CHECK);
-}
-
-/* Find a longest backward match of &data[cur_ix] up to the length of
-   max_length and stores the position cur_ix in the hash table.
-
-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
-             values; if this method is invoked repeatedly with the same distance
-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hashes = FN(TinyHash)(self->extra[0]);
-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  /* Don't accept a short copy from far away. */
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = out->len;
-  size_t i;
-  const size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  const uint8_t tiny_hash = (uint8_t)(key);
-  out->len = 0;
-  out->len_code_delta = 0;
-  /* Try last distance first. */
-  for (i = 0; i < NUM_LAST_DISTANCES_TO_CHECK; ++i) {
-    const size_t backward = (size_t)distance_cache[i];
-    size_t prev_ix = (cur_ix - backward);
-    /* For distance code 0 we want to consider 2-byte matches. */
-    if (i > 0 && tiny_hashes[(uint16_t)prev_ix] != tiny_hash) continue;
-    if (prev_ix >= cur_ix || backward > max_backward) {
-      continue;
-    }
-    prev_ix &= ring_buffer_mask;
-    {
-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                  &data[cur_ix_masked],
-                                                  max_length);
-      if (len >= 2) {
-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-  }
-  {
-    const size_t bank = key & (NUM_BANKS - 1);
-    size_t backward = 0;
-    size_t hops = self->max_hops;
-    size_t delta = cur_ix - addr[key];
-    size_t slot = head[key];
-    while (hops--) {
-      size_t prev_ix;
-      size_t last = slot;
-      backward += delta;
-      if (backward > max_backward || (CAPPED_CHAINS && !delta)) break;
-      prev_ix = (cur_ix - backward) & ring_buffer_mask;
-      slot = banks[bank].slots[last].next;
-      delta = banks[bank].slots[last].delta;
-      if (cur_ix_masked + best_len > ring_buffer_mask ||
-          prev_ix + best_len > ring_buffer_mask ||
-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-        continue;
-      }
-      {
-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                    &data[cur_ix_masked],
-                                                    max_length);
-        if (len >= 4) {
-          /* Comparing for >= 3 does not change the semantics, but just saves
-             for a few unnecessary binary logarithms in backward reference
-             score, since we are not interested in such short matches. */
-          score_t score = BackwardReferenceScore(len, backward);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-    FN(Store)(self, data, ring_buffer_mask, cur_ix);
-  }
-  if (out->score == min_score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_FALSE);
-  }
-}
-
-#undef BANK_SIZE
-#undef BUCKET_SIZE
-#undef CAPPED_CHAINS
-
-#undef HashForgetfulChain
-#undef HASHER
-#undef NUM_LAST_DISTANCES_TO_CHECK
-
-#define NUM_LAST_DISTANCES_TO_CHECK 10
-#define HASHER() H41
-/* NOLINT(build/header_guard) */
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, NUM_BANKS, BANK_BITS,
-                        NUM_LAST_DISTANCES_TO_CHECK */
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   Hashes are stored in chains which are bucketed to groups. Group of chains
-   share a storage "bank". When more than "bank size" chain nodes are added,
-   oldest nodes are replaced; this way several chains may share a tail. */
-
-#define HashForgetfulChain HASHER()
-
-#define BANK_SIZE (1 << BANK_BITS)
-
-/* Number of hash buckets. */
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-
-#define CAPPED_CHAINS 0
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
-
-/* HashBytes is the function that chooses the bucket to place the address in.*/
-static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
-  const uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - BUCKET_BITS);
-}
-
-typedef struct FN(Slot) {
-  uint16_t delta;
-  uint16_t next;
-} FN(Slot);
-
-typedef struct FN(Bank) {
-  FN(Slot) slots[BANK_SIZE];
-} FN(Bank);
-
-typedef struct HashForgetfulChain {
-  uint16_t free_slot_idx[NUM_BANKS];  /* Up to 1KiB. Move to dynamic? */
-  size_t max_hops;
-
-  /* Shortcuts. */
-  void* extra[2];
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  /* uint32_t addr[BUCKET_SIZE]; */
-
-  /* uint16_t head[BUCKET_SIZE]; */
-
-  /* Truncated hash used for quick rejection of "distance cache" candidates. */
-  /* uint8_t tiny_hash[65536];*/
-
-  /* FN(Bank) banks[NUM_BANKS]; */
-} HashForgetfulChain;
-
-static uint32_t* FN(Addr)(void* extra) {
-  return (uint32_t*)extra;
-}
-
-static uint16_t* FN(Head)(void* extra) {
-  return (uint16_t*)(&FN(Addr)(extra)[BUCKET_SIZE]);
-}
-
-static uint8_t* FN(TinyHash)(void* extra) {
-  return (uint8_t*)(&FN(Head)(extra)[BUCKET_SIZE]);
-}
-
-static FN(Bank)* FN(Banks)(void* extra) {
-  return (FN(Bank)*)(extra);
-}
-
-static void FN(Initialize)(
-    HasherCommon* common, HashForgetfulChain* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-  self->extra[0] = common->extra[0];
-  self->extra[1] = common->extra[1];
-
-  self->max_hops = (params->quality > 6 ? 7u : 8u) << (params->quality - 4);
-}
-
-static void FN(Prepare)(
-    HashForgetfulChain* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 6;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      size_t bucket = FN(HashBytes)(&data[i]);
-      /* See InitEmpty comment. */
-      addr[bucket] = 0xCCCCCCCC;
-      head[bucket] = 0xCCCC;
-    }
-  } else {
-    /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position
-       processed by hasher never reaches 3GB + 64M; this makes all new chains
-       to be terminated after the first node. */
-    memset(addr, 0xCC, sizeof(uint32_t) * BUCKET_SIZE);
-    memset(head, 0, sizeof(uint16_t) * BUCKET_SIZE);
-  }
-  memset(tiny_hash, 0, sizeof(uint8_t) * 65536);
-  memset(self->free_slot_idx, 0, sizeof(self->free_slot_idx));
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE +
-                  sizeof(uint16_t) * BUCKET_SIZE + sizeof(uint8_t) * 65536;
-  alloc_size[1] = sizeof(FN(Bank)) * NUM_BANKS;
-}
-
-/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend
-   node to corresponding chain; also update tiny_hash for current position. */
-static BROTLI_INLINE void FN(Store)(HashForgetfulChain* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
-  const size_t key = FN(HashBytes)(&data[ix & mask]);
-  const size_t bank = key & (NUM_BANKS - 1);
-  const size_t idx = self->free_slot_idx[bank]++ & (BANK_SIZE - 1);
-  size_t delta = ix - addr[key];
-  tiny_hash[(uint16_t)ix] = (uint8_t)key;
-  if (delta > 0xFFFF) delta = CAPPED_CHAINS ? 0 : 0xFFFF;
-  banks[bank].slots[idx].delta = (uint16_t)delta;
-  banks[bank].slots[idx].next = head[key];
-  addr[key] = (uint32_t)ix;
-  head[key] = (uint16_t)idx;
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  PrepareDistanceCache(distance_cache, NUM_LAST_DISTANCES_TO_CHECK);
-}
-
-/* Find a longest backward match of &data[cur_ix] up to the length of
-   max_length and stores the position cur_ix in the hash table.
-
-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
-             values; if this method is invoked repeatedly with the same distance
-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hashes = FN(TinyHash)(self->extra[0]);
-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  /* Don't accept a short copy from far away. */
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = out->len;
-  size_t i;
-  const size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  const uint8_t tiny_hash = (uint8_t)(key);
-  out->len = 0;
-  out->len_code_delta = 0;
-  /* Try last distance first. */
-  for (i = 0; i < NUM_LAST_DISTANCES_TO_CHECK; ++i) {
-    const size_t backward = (size_t)distance_cache[i];
-    size_t prev_ix = (cur_ix - backward);
-    /* For distance code 0 we want to consider 2-byte matches. */
-    if (i > 0 && tiny_hashes[(uint16_t)prev_ix] != tiny_hash) continue;
-    if (prev_ix >= cur_ix || backward > max_backward) {
-      continue;
-    }
-    prev_ix &= ring_buffer_mask;
-    {
-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                  &data[cur_ix_masked],
-                                                  max_length);
-      if (len >= 2) {
-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-  }
-  {
-    const size_t bank = key & (NUM_BANKS - 1);
-    size_t backward = 0;
-    size_t hops = self->max_hops;
-    size_t delta = cur_ix - addr[key];
-    size_t slot = head[key];
-    while (hops--) {
-      size_t prev_ix;
-      size_t last = slot;
-      backward += delta;
-      if (backward > max_backward || (CAPPED_CHAINS && !delta)) break;
-      prev_ix = (cur_ix - backward) & ring_buffer_mask;
-      slot = banks[bank].slots[last].next;
-      delta = banks[bank].slots[last].delta;
-      if (cur_ix_masked + best_len > ring_buffer_mask ||
-          prev_ix + best_len > ring_buffer_mask ||
-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-        continue;
-      }
-      {
-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                    &data[cur_ix_masked],
-                                                    max_length);
-        if (len >= 4) {
-          /* Comparing for >= 3 does not change the semantics, but just saves
-             for a few unnecessary binary logarithms in backward reference
-             score, since we are not interested in such short matches. */
-          score_t score = BackwardReferenceScore(len, backward);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-    FN(Store)(self, data, ring_buffer_mask, cur_ix);
-  }
-  if (out->score == min_score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_FALSE);
-  }
-}
-
-#undef BANK_SIZE
-#undef BUCKET_SIZE
-#undef CAPPED_CHAINS
-
-#undef HashForgetfulChain
-#undef HASHER
-#undef NUM_LAST_DISTANCES_TO_CHECK
-#undef NUM_BANKS
-#undef BANK_BITS
-
-#define NUM_LAST_DISTANCES_TO_CHECK 16
-#define NUM_BANKS 512
-#define BANK_BITS 9
-#define HASHER() H42
-/* NOLINT(build/header_guard) */
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, NUM_BANKS, BANK_BITS,
-                        NUM_LAST_DISTANCES_TO_CHECK */
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   Hashes are stored in chains which are bucketed to groups. Group of chains
-   share a storage "bank". When more than "bank size" chain nodes are added,
-   oldest nodes are replaced; this way several chains may share a tail. */
-
-#define HashForgetfulChain HASHER()
-
-#define BANK_SIZE (1 << BANK_BITS)
-
-/* Number of hash buckets. */
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-
-#define CAPPED_CHAINS 0
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
-
-/* HashBytes is the function that chooses the bucket to place the address in.*/
-static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
-  const uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - BUCKET_BITS);
-}
-
-typedef struct FN(Slot) {
-  uint16_t delta;
-  uint16_t next;
-} FN(Slot);
-
-typedef struct FN(Bank) {
-  FN(Slot) slots[BANK_SIZE];
-} FN(Bank);
-
-typedef struct HashForgetfulChain {
-  uint16_t free_slot_idx[NUM_BANKS];  /* Up to 1KiB. Move to dynamic? */
-  size_t max_hops;
-
-  /* Shortcuts. */
-  void* extra[2];
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  /* uint32_t addr[BUCKET_SIZE]; */
-
-  /* uint16_t head[BUCKET_SIZE]; */
-
-  /* Truncated hash used for quick rejection of "distance cache" candidates. */
-  /* uint8_t tiny_hash[65536];*/
-
-  /* FN(Bank) banks[NUM_BANKS]; */
-} HashForgetfulChain;
-
-static uint32_t* FN(Addr)(void* extra) {
-  return (uint32_t*)extra;
-}
-
-static uint16_t* FN(Head)(void* extra) {
-  return (uint16_t*)(&FN(Addr)(extra)[BUCKET_SIZE]);
-}
-
-static uint8_t* FN(TinyHash)(void* extra) {
-  return (uint8_t*)(&FN(Head)(extra)[BUCKET_SIZE]);
-}
-
-static FN(Bank)* FN(Banks)(void* extra) {
-  return (FN(Bank)*)(extra);
-}
-
-static void FN(Initialize)(
-    HasherCommon* common, HashForgetfulChain* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-  self->extra[0] = common->extra[0];
-  self->extra[1] = common->extra[1];
-
-  self->max_hops = (params->quality > 6 ? 7u : 8u) << (params->quality - 4);
-}
-
-static void FN(Prepare)(
-    HashForgetfulChain* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 6;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      size_t bucket = FN(HashBytes)(&data[i]);
-      /* See InitEmpty comment. */
-      addr[bucket] = 0xCCCCCCCC;
-      head[bucket] = 0xCCCC;
-    }
-  } else {
-    /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position
-       processed by hasher never reaches 3GB + 64M; this makes all new chains
-       to be terminated after the first node. */
-    memset(addr, 0xCC, sizeof(uint32_t) * BUCKET_SIZE);
-    memset(head, 0, sizeof(uint16_t) * BUCKET_SIZE);
-  }
-  memset(tiny_hash, 0, sizeof(uint8_t) * 65536);
-  memset(self->free_slot_idx, 0, sizeof(self->free_slot_idx));
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE +
-                  sizeof(uint16_t) * BUCKET_SIZE + sizeof(uint8_t) * 65536;
-  alloc_size[1] = sizeof(FN(Bank)) * NUM_BANKS;
-}
-
-/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend
-   node to corresponding chain; also update tiny_hash for current position. */
-static BROTLI_INLINE void FN(Store)(HashForgetfulChain* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
-  const size_t key = FN(HashBytes)(&data[ix & mask]);
-  const size_t bank = key & (NUM_BANKS - 1);
-  const size_t idx = self->free_slot_idx[bank]++ & (BANK_SIZE - 1);
-  size_t delta = ix - addr[key];
-  tiny_hash[(uint16_t)ix] = (uint8_t)key;
-  if (delta > 0xFFFF) delta = CAPPED_CHAINS ? 0 : 0xFFFF;
-  banks[bank].slots[idx].delta = (uint16_t)delta;
-  banks[bank].slots[idx].next = head[key];
-  addr[key] = (uint32_t)ix;
-  head[key] = (uint16_t)idx;
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  PrepareDistanceCache(distance_cache, NUM_LAST_DISTANCES_TO_CHECK);
-}
-
-/* Find a longest backward match of &data[cur_ix] up to the length of
-   max_length and stores the position cur_ix in the hash table.
-
-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
-             values; if this method is invoked repeatedly with the same distance
-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashForgetfulChain* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
-  uint8_t* BROTLI_RESTRICT tiny_hashes = FN(TinyHash)(self->extra[0]);
-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  /* Don't accept a short copy from far away. */
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = out->len;
-  size_t i;
-  const size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  const uint8_t tiny_hash = (uint8_t)(key);
-  out->len = 0;
-  out->len_code_delta = 0;
-  /* Try last distance first. */
-  for (i = 0; i < NUM_LAST_DISTANCES_TO_CHECK; ++i) {
-    const size_t backward = (size_t)distance_cache[i];
-    size_t prev_ix = (cur_ix - backward);
-    /* For distance code 0 we want to consider 2-byte matches. */
-    if (i > 0 && tiny_hashes[(uint16_t)prev_ix] != tiny_hash) continue;
-    if (prev_ix >= cur_ix || backward > max_backward) {
-      continue;
-    }
-    prev_ix &= ring_buffer_mask;
-    {
-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                  &data[cur_ix_masked],
-                                                  max_length);
-      if (len >= 2) {
-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-  }
-  {
-    const size_t bank = key & (NUM_BANKS - 1);
-    size_t backward = 0;
-    size_t hops = self->max_hops;
-    size_t delta = cur_ix - addr[key];
-    size_t slot = head[key];
-    while (hops--) {
-      size_t prev_ix;
-      size_t last = slot;
-      backward += delta;
-      if (backward > max_backward || (CAPPED_CHAINS && !delta)) break;
-      prev_ix = (cur_ix - backward) & ring_buffer_mask;
-      slot = banks[bank].slots[last].next;
-      delta = banks[bank].slots[last].delta;
-      if (cur_ix_masked + best_len > ring_buffer_mask ||
-          prev_ix + best_len > ring_buffer_mask ||
-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-        continue;
-      }
-      {
-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
-                                                    &data[cur_ix_masked],
-                                                    max_length);
-        if (len >= 4) {
-          /* Comparing for >= 3 does not change the semantics, but just saves
-             for a few unnecessary binary logarithms in backward reference
-             score, since we are not interested in such short matches. */
-          score_t score = BackwardReferenceScore(len, backward);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            out->len = best_len;
-            out->distance = backward;
-            out->score = best_score;
-          }
-        }
-      }
-    }
-    FN(Store)(self, data, ring_buffer_mask, cur_ix);
-  }
-  if (out->score == min_score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_FALSE);
-  }
-}
-
-#undef BANK_SIZE
-#undef BUCKET_SIZE
-#undef CAPPED_CHAINS
-
-#undef HashForgetfulChain
-#undef HASHER
-#undef NUM_LAST_DISTANCES_TO_CHECK
-#undef NUM_BANKS
-#undef BANK_BITS
-
-#undef BUCKET_BITS
-
-#define HASHER() H54
-#define BUCKET_BITS 20
-#define BUCKET_SWEEP_BITS 2
-#define HASH_LEN 7
-#define USE_DICTIONARY 0
-/* NOLINT(build/header_guard) */
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP_BITS, HASH_LEN,
-                        USE_DICTIONARY
- */
-
-#define HashLongestMatchQuickly HASHER()
-
-#define BUCKET_SIZE (1 << BUCKET_BITS)
-#define BUCKET_MASK (BUCKET_SIZE - 1)
-#define BUCKET_SWEEP (1 << BUCKET_SWEEP_BITS)
-#define BUCKET_SWEEP_MASK ((BUCKET_SWEEP - 1) << 3)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
-
-/* HashBytes is the function that chooses the bucket to place
-   the address in. The HashLongestMatch and HashLongestMatchQuickly
-   classes have separate, different implementations of hashing. */
-static uint32_t FN(HashBytes)(const uint8_t* data) {
-  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8 * HASH_LEN)) *
-                      kHashMul64);
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return (uint32_t)(h >> (64 - BUCKET_BITS));
-}
-
-/* A (forgetful) hash table to the data seen by the compressor, to
-   help create backward references to previous data.
-
-   This is a hash map of fixed size (BUCKET_SIZE). */
-typedef struct HashLongestMatchQuickly {
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  /* --- Dynamic size members --- */
-
-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
-} HashLongestMatchQuickly;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  self->common = common;
-
-  BROTLI_UNUSED(params);
-  self->buckets_ = (uint32_t*)common->extra[0];
-}
-
-static void FN(Prepare)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  /* Partial preparation is 100 times slower (per socket). */
-  size_t partial_prepare_threshold = BUCKET_SIZE >> 5;
-  if (one_shot && input_size <= partial_prepare_threshold) {
-    size_t i;
-    for (i = 0; i < input_size; ++i) {
-      const uint32_t key = FN(HashBytes)(&data[i]);
-      if (BUCKET_SWEEP == 1) {
-        buckets[key] = 0;
-      } else {
-        uint32_t j;
-        for (j = 0; j < BUCKET_SWEEP; ++j) {
-          buckets[(key + (j << 3)) & BUCKET_MASK] = 0;
-        }
-      }
-    }
-  } else {
-    /* It is not strictly necessary to fill this buffer here, but
-       not filling will make the results of the compression stochastic
-       (but correct). This is because random data would cause the
-       system to find accidentally good backward references here and there. */
-    memset(buckets, 0, sizeof(uint32_t) * BUCKET_SIZE);
-  }
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE;
-}
-
-/* Look at 5 bytes at &data[ix & mask].
-   Compute a hash from these, and store the value somewhere within
-   [ix .. ix+3]. */
-static BROTLI_INLINE void FN(Store)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  const uint32_t key = FN(HashBytes)(&data[ix & mask]);
-  if (BUCKET_SWEEP == 1) {
-    self->buckets_[key] = (uint32_t)ix;
-  } else {
-    /* Wiggle the value with the bucket sweep range. */
-    const uint32_t off = ix & BUCKET_SWEEP_MASK;
-    self->buckets_[(key + off) & BUCKET_MASK] = (uint32_t)ix;
-  }
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  size_t i;
-  for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(self, data, mask, i);
-  }
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask) {
-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
-    /* Prepare the hashes for three last bytes of the last write.
-       These could not be calculated before, since they require knowledge
-       of both the previous and the current block. */
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
-  }
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(distance_cache);
-}
-
-/* Find a longest backward match of &data[cur_ix & ring_buffer_mask]
-   up to the length of max_length and stores the position cur_ix in the
-   hash table.
-
-   Does not look for matches longer than max_length.
-   Does not look for matches further away than max_backward.
-   Writes the best match into |out|.
-   |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
-  const size_t best_len_in = out->len;
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  int compare_char = data[cur_ix_masked + best_len_in];
-  size_t key = FN(HashBytes)(&data[cur_ix_masked]);
-  size_t key_out;
-  score_t min_score = out->score;
-  score_t best_score = out->score;
-  size_t best_len = best_len_in;
-  size_t cached_backward = (size_t)distance_cache[0];
-  size_t prev_ix = cur_ix - cached_backward;
-  out->len_code_delta = 0;
-  if (prev_ix < cur_ix) {
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char == data[prev_ix + best_len]) {
-      const size_t len = FindMatchLengthWithLimit(
-          &data[prev_ix], &data[cur_ix_masked], max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScoreUsingLastDistance(len);
-        if (best_score < score) {
-          out->len = len;
-          out->distance = cached_backward;
-          out->score = score;
-          if (BUCKET_SWEEP == 1) {
-            buckets[key] = (uint32_t)cur_ix;
-            return;
-          } else {
-            best_len = len;
-            best_score = score;
-            compare_char = data[cur_ix_masked + len];
-          }
-        }
-      }
-    }
-  }
-  if (BUCKET_SWEEP == 1) {
-    size_t backward;
-    size_t len;
-    /* Only one to look for, don't bother to prepare for a loop. */
-    prev_ix = buckets[key];
-    buckets[key] = (uint32_t)cur_ix;
-    backward = cur_ix - prev_ix;
-    prev_ix &= (uint32_t)ring_buffer_mask;
-    if (compare_char != data[prev_ix + best_len_in]) {
-      return;
-    }
-    if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-      return;
-    }
-    len = FindMatchLengthWithLimit(&data[prev_ix],
-                                   &data[cur_ix_masked],
-                                   max_length);
-    if (len >= 4) {
-      const score_t score = BackwardReferenceScore(len, backward);
-      if (best_score < score) {
-        out->len = len;
-        out->distance = backward;
-        out->score = score;
-        return;
-      }
-    }
-  } else {
-    size_t keys[BUCKET_SWEEP];
-    size_t i;
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      keys[i] = (key + (i << 3)) & BUCKET_MASK;
-    }
-    key_out = keys[(cur_ix & BUCKET_SWEEP_MASK) >> 3];
-    for (i = 0; i < BUCKET_SWEEP; ++i) {
-      size_t len;
-      size_t backward;
-      prev_ix = buckets[keys[i]];
-      backward = cur_ix - prev_ix;
-      prev_ix &= (uint32_t)ring_buffer_mask;
-      if (compare_char != data[prev_ix + best_len]) {
-        continue;
-      }
-      if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-        continue;
-      }
-      len = FindMatchLengthWithLimit(&data[prev_ix],
-                                     &data[cur_ix_masked],
-                                     max_length);
-      if (len >= 4) {
-        const score_t score = BackwardReferenceScore(len, backward);
-        if (best_score < score) {
-          best_len = len;
-          out->len = len;
-          compare_char = data[cur_ix_masked + len];
-          best_score = score;
-          out->score = score;
-          out->distance = backward;
-        }
-      }
-    }
-  }
-  if (USE_DICTIONARY && min_score == out->score) {
-    SearchInStaticDictionary(dictionary,
-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
-        max_distance, out, BROTLI_TRUE);
-  }
-  if (BUCKET_SWEEP != 1) {
-    buckets[key_out] = (uint32_t)cur_ix;
-  }
-}
-
-#undef BUCKET_SWEEP_MASK
-#undef BUCKET_SWEEP
-#undef BUCKET_MASK
-#undef BUCKET_SIZE
-
-#undef HashLongestMatchQuickly
-#undef USE_DICTIONARY
-#undef HASH_LEN
-#undef BUCKET_SWEEP_BITS
-#undef BUCKET_BITS
-#undef HASHER
-
-/* fast large window hashers */
-
-#define HASHER() HROLLING_FAST
-#define CHUNKLEN 32
-#define JUMP 4
-#define NUMBUCKETS 16777216
-#define MASK ((NUMBUCKETS * 64) - 1)
-/* NOLINT(build/header_guard) */
-/* Copyright 2018 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, JUMP, NUMBUCKETS, MASK, CHUNKLEN */
-/* NUMBUCKETS / (MASK + 1) = probability of storing and using hash code. */
-/* JUMP = skip bytes for speedup */
-
-/* Rolling hash for long distance long string matches. Stores one position
-   per bucket, bucket key is computed over a long region. */
-
-#define HashRolling HASHER()
-
-static const uint32_t FN(kRollingHashMul32) = 69069;
-static const uint32_t FN(kInvalidPos) = 0xffffffff;
-
-/* This hasher uses a longer forward length, but returning a higher value here
-   will hurt compression by the main hasher when combined with a composite
-   hasher. The hasher tests for forward itself instead. */
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
-
-/* Computes a code from a single byte. A lookup table of 256 values could be
-   used, but simply adding 1 works about as good. */
-static uint32_t FN(HashByte)(uint8_t byte) {
-  return (uint32_t)byte + 1u;
-}
-
-static uint32_t FN(HashRollingFunctionInitial)(uint32_t state, uint8_t add,
-                                               uint32_t factor) {
-  return (uint32_t)(factor * state + FN(HashByte)(add));
-}
-
-static uint32_t FN(HashRollingFunction)(uint32_t state, uint8_t add,
-                                        uint8_t rem, uint32_t factor,
-                                        uint32_t factor_remove) {
-  return (uint32_t)(factor * state +
-      FN(HashByte)(add) - factor_remove * FN(HashByte)(rem));
-}
-
-typedef struct HashRolling {
-  uint32_t state;
-  uint32_t* table;
-  size_t next_ix;
-
-  uint32_t chunk_len;
-  uint32_t factor;
-  uint32_t factor_remove;
-} HashRolling;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashRolling* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  size_t i;
-  self->state = 0;
-  self->next_ix = 0;
-
-  self->factor = FN(kRollingHashMul32);
-
-  /* Compute the factor of the oldest byte to remove: factor**steps modulo
-     0xffffffff (the multiplications rely on 32-bit overflow) */
-  self->factor_remove = 1;
-  for (i = 0; i < CHUNKLEN; i += JUMP) {
-    self->factor_remove *= self->factor;
-  }
-
-  self->table = (uint32_t*)common->extra[0];
-  for (i = 0; i < NUMBUCKETS; i++) {
-    self->table[i] = FN(kInvalidPos);
-  }
-
-  BROTLI_UNUSED(params);
-}
-
-static void FN(Prepare)(HashRolling* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  size_t i;
-  /* Too small size, cannot use this hasher. */
-  if (input_size < CHUNKLEN) return;
-  self->state = 0;
-  for (i = 0; i < CHUNKLEN; i += JUMP) {
-    self->state = FN(HashRollingFunctionInitial)(
-        self->state, data[i], self->factor);
-  }
-  BROTLI_UNUSED(one_shot);
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = NUMBUCKETS * sizeof(uint32_t);
-}
-
-static BROTLI_INLINE void FN(Store)(HashRolling* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(data);
-  BROTLI_UNUSED(mask);
-  BROTLI_UNUSED(ix);
-}
-
-static BROTLI_INLINE void FN(StoreRange)(HashRolling* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(data);
-  BROTLI_UNUSED(mask);
-  BROTLI_UNUSED(ix_start);
-  BROTLI_UNUSED(ix_end);
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashRolling* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  /* In this case we must re-initialize the hasher from scratch from the
-     current position. */
-  size_t position_masked;
-  size_t available = num_bytes;
-  if ((position & (JUMP - 1)) != 0) {
-    size_t diff = JUMP - (position & (JUMP - 1));
-    available = (diff > available) ? 0 : (available - diff);
-    position += diff;
-  }
-  position_masked = position & ring_buffer_mask;
-  /* wrapping around ringbuffer not handled. */
-  if (available > ring_buffer_mask - position_masked) {
-    available = ring_buffer_mask - position_masked;
-  }
-
-  FN(Prepare)(self, BROTLI_FALSE, available,
-      ringbuffer + (position & ring_buffer_mask));
-  self->next_ix = position;
-  BROTLI_UNUSED(num_bytes);
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashRolling* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(distance_cache);
-}
-
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashRolling* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  size_t pos;
-
-  if ((cur_ix & (JUMP - 1)) != 0) return;
-
-  /* Not enough lookahead */
-  if (max_length < CHUNKLEN) return;
-
-  for (pos = self->next_ix; pos <= cur_ix; pos += JUMP) {
-    uint32_t code = self->state & MASK;
-
-    uint8_t rem = data[pos & ring_buffer_mask];
-    uint8_t add = data[(pos + CHUNKLEN) & ring_buffer_mask];
-    size_t found_ix = FN(kInvalidPos);
-
-    self->state = FN(HashRollingFunction)(
-        self->state, add, rem, self->factor, self->factor_remove);
-
-    if (code < NUMBUCKETS) {
-      found_ix = self->table[code];
-      self->table[code] = (uint32_t)pos;
-      if (pos == cur_ix && found_ix != FN(kInvalidPos)) {
-        /* The cast to 32-bit makes backward distances up to 4GB work even
-           if cur_ix is above 4GB, despite using 32-bit values in the table. */
-        size_t backward = (uint32_t)(cur_ix - found_ix);
-        if (backward <= max_backward) {
-          const size_t found_ix_masked = found_ix & ring_buffer_mask;
-          const size_t len = FindMatchLengthWithLimit(&data[found_ix_masked],
-                                                      &data[cur_ix_masked],
-                                                      max_length);
-          if (len >= 4 && len > out->len) {
-            score_t score = BackwardReferenceScore(len, backward);
-            if (score > out->score) {
-              out->len = len;
-              out->distance = backward;
-              out->score = score;
-              out->len_code_delta = 0;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  self->next_ix = cur_ix + JUMP;
-
-  /* NOTE: this hasher does not search in the dictionary. It is used as
-     backup-hasher, the main hasher already searches in it. */
-  BROTLI_UNUSED(dictionary);
-  BROTLI_UNUSED(distance_cache);
-  BROTLI_UNUSED(dictionary_distance);
-  BROTLI_UNUSED(max_distance);
-}
-
-#undef HashRolling
-#undef JUMP
-#undef HASHER
-
-
-#define HASHER() HROLLING
-#define JUMP 1
-/* NOLINT(build/header_guard) */
-/* Copyright 2018 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, JUMP, NUMBUCKETS, MASK, CHUNKLEN */
-/* NUMBUCKETS / (MASK + 1) = probability of storing and using hash code. */
-/* JUMP = skip bytes for speedup */
-
-/* Rolling hash for long distance long string matches. Stores one position
-   per bucket, bucket key is computed over a long region. */
-
-#define HashRolling HASHER()
-
-static const uint32_t FN(kRollingHashMul32) = 69069;
-static const uint32_t FN(kInvalidPos) = 0xffffffff;
-
-/* This hasher uses a longer forward length, but returning a higher value here
-   will hurt compression by the main hasher when combined with a composite
-   hasher. The hasher tests for forward itself instead. */
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
-
-/* Computes a code from a single byte. A lookup table of 256 values could be
-   used, but simply adding 1 works about as good. */
-static uint32_t FN(HashByte)(uint8_t byte) {
-  return (uint32_t)byte + 1u;
-}
-
-static uint32_t FN(HashRollingFunctionInitial)(uint32_t state, uint8_t add,
-                                               uint32_t factor) {
-  return (uint32_t)(factor * state + FN(HashByte)(add));
-}
-
-static uint32_t FN(HashRollingFunction)(uint32_t state, uint8_t add,
-                                        uint8_t rem, uint32_t factor,
-                                        uint32_t factor_remove) {
-  return (uint32_t)(factor * state +
-      FN(HashByte)(add) - factor_remove * FN(HashByte)(rem));
-}
-
-typedef struct HashRolling {
-  uint32_t state;
-  uint32_t* table;
-  size_t next_ix;
-
-  uint32_t chunk_len;
-  uint32_t factor;
-  uint32_t factor_remove;
-} HashRolling;
-
-static void FN(Initialize)(
-    HasherCommon* common, HashRolling* BROTLI_RESTRICT self,
-    const BrotliEncoderParams* params) {
-  size_t i;
-  self->state = 0;
-  self->next_ix = 0;
-
-  self->factor = FN(kRollingHashMul32);
-
-  /* Compute the factor of the oldest byte to remove: factor**steps modulo
-     0xffffffff (the multiplications rely on 32-bit overflow) */
-  self->factor_remove = 1;
-  for (i = 0; i < CHUNKLEN; i += JUMP) {
-    self->factor_remove *= self->factor;
-  }
-
-  self->table = (uint32_t*)common->extra[0];
-  for (i = 0; i < NUMBUCKETS; i++) {
-    self->table[i] = FN(kInvalidPos);
-  }
-
-  BROTLI_UNUSED(params);
-}
-
-static void FN(Prepare)(HashRolling* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  size_t i;
-  /* Too small size, cannot use this hasher. */
-  if (input_size < CHUNKLEN) return;
-  self->state = 0;
-  for (i = 0; i < CHUNKLEN; i += JUMP) {
-    self->state = FN(HashRollingFunctionInitial)(
-        self->state, data[i], self->factor);
-  }
-  BROTLI_UNUSED(one_shot);
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  BROTLI_UNUSED(params);
-  BROTLI_UNUSED(one_shot);
-  BROTLI_UNUSED(input_size);
-  alloc_size[0] = NUMBUCKETS * sizeof(uint32_t);
-}
-
-static BROTLI_INLINE void FN(Store)(HashRolling* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(data);
-  BROTLI_UNUSED(mask);
-  BROTLI_UNUSED(ix);
-}
-
-static BROTLI_INLINE void FN(StoreRange)(HashRolling* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
-    const size_t ix_start, const size_t ix_end) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(data);
-  BROTLI_UNUSED(mask);
-  BROTLI_UNUSED(ix_start);
-  BROTLI_UNUSED(ix_end);
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashRolling* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  /* In this case we must re-initialize the hasher from scratch from the
-     current position. */
-  size_t position_masked;
-  size_t available = num_bytes;
-  if ((position & (JUMP - 1)) != 0) {
-    size_t diff = JUMP - (position & (JUMP - 1));
-    available = (diff > available) ? 0 : (available - diff);
-    position += diff;
-  }
-  position_masked = position & ring_buffer_mask;
-  /* wrapping around ringbuffer not handled. */
-  if (available > ring_buffer_mask - position_masked) {
-    available = ring_buffer_mask - position_masked;
-  }
-
-  FN(Prepare)(self, BROTLI_FALSE, available,
-      ringbuffer + (position & ring_buffer_mask));
-  self->next_ix = position;
-  BROTLI_UNUSED(num_bytes);
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashRolling* BROTLI_RESTRICT self,
-    int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(self);
-  BROTLI_UNUSED(distance_cache);
-}
-
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashRolling* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  size_t pos;
-
-  if ((cur_ix & (JUMP - 1)) != 0) return;
-
-  /* Not enough lookahead */
-  if (max_length < CHUNKLEN) return;
-
-  for (pos = self->next_ix; pos <= cur_ix; pos += JUMP) {
-    uint32_t code = self->state & MASK;
-
-    uint8_t rem = data[pos & ring_buffer_mask];
-    uint8_t add = data[(pos + CHUNKLEN) & ring_buffer_mask];
-    size_t found_ix = FN(kInvalidPos);
-
-    self->state = FN(HashRollingFunction)(
-        self->state, add, rem, self->factor, self->factor_remove);
-
-    if (code < NUMBUCKETS) {
-      found_ix = self->table[code];
-      self->table[code] = (uint32_t)pos;
-      if (pos == cur_ix && found_ix != FN(kInvalidPos)) {
-        /* The cast to 32-bit makes backward distances up to 4GB work even
-           if cur_ix is above 4GB, despite using 32-bit values in the table. */
-        size_t backward = (uint32_t)(cur_ix - found_ix);
-        if (backward <= max_backward) {
-          const size_t found_ix_masked = found_ix & ring_buffer_mask;
-          const size_t len = FindMatchLengthWithLimit(&data[found_ix_masked],
-                                                      &data[cur_ix_masked],
-                                                      max_length);
-          if (len >= 4 && len > out->len) {
-            score_t score = BackwardReferenceScore(len, backward);
-            if (score > out->score) {
-              out->len = len;
-              out->distance = backward;
-              out->score = score;
-              out->len_code_delta = 0;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  self->next_ix = cur_ix + JUMP;
-
-  /* NOTE: this hasher does not search in the dictionary. It is used as
-     backup-hasher, the main hasher already searches in it. */
-  BROTLI_UNUSED(dictionary);
-  BROTLI_UNUSED(distance_cache);
-  BROTLI_UNUSED(dictionary_distance);
-  BROTLI_UNUSED(max_distance);
-}
-
-#undef HashRolling
-#undef MASK
-#undef NUMBUCKETS
-#undef JUMP
-#undef CHUNKLEN
-#undef HASHER
-
-#define HASHER() H35
-#define HASHER_A H3
-#define HASHER_B HROLLING_FAST
-/* NOLINT(build/header_guard) */
-/* Copyright 2018 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, HASHER_A, HASHER_B */
-
-/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A
-   and HASHER_B. */
-
-#define HashComposite HASHER()
-
-#define FN_A(X) EXPAND_CAT(X, HASHER_A)
-#define FN_B(X) EXPAND_CAT(X, HASHER_B)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) {
-  size_t a =  FN_A(HashTypeLength)();
-  size_t b =  FN_B(HashTypeLength)();
-  return a > b ? a : b;
-}
-
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
-  size_t a =  FN_A(StoreLookahead)();
-  size_t b =  FN_B(StoreLookahead)();
-  return a > b ? a : b;
-}
-
-typedef struct HashComposite {
-  HASHER_A ha;
-  HASHER_B hb;
-  HasherCommon ha_common;
-  HasherCommon hb_common;
-
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  BROTLI_BOOL fresh;
-  const BrotliEncoderParams* params;
-} HashComposite;
-
-static void FN(Initialize)(HasherCommon* common,
-    HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
-  self->common = common;
-
-  self->ha_common = *self->common;
-  self->hb_common = *self->common;
-  self->fresh = BROTLI_TRUE;
-  self->params = params;
-  /* TODO(lode): Initialize of the hashers is deferred to Prepare (and params
-     remembered here) because we don't get the one_shot and input_size params
-     here that are needed to know the memory size of them. Instead provide
-     those params to all hashers FN(Initialize) */
-}
-
-static void FN(Prepare)(
-    HashComposite* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  if (self->fresh) {
-    self->fresh = BROTLI_FALSE;
-    self->ha_common.extra[0] = self->common->extra[0];
-    self->ha_common.extra[1] = self->common->extra[1];
-    self->ha_common.extra[2] = NULL;
-    self->ha_common.extra[3] = NULL;
-    self->hb_common.extra[0] = self->common->extra[2];
-    self->hb_common.extra[1] = self->common->extra[3];
-    self->hb_common.extra[2] = NULL;
-    self->hb_common.extra[3] = NULL;
-
-    FN_A(Initialize)(&self->ha_common, &self->ha, self->params);
-    FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
-  }
-  FN_A(Prepare)(&self->ha, one_shot, input_size, data);
-  FN_B(Prepare)(&self->hb, one_shot, input_size, data);
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  size_t alloc_size_a[4] = {0};
-  size_t alloc_size_b[4] = {0};
-  FN_A(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_a);
-  FN_B(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_b);
-  /* Should never happen. */
-  /* Can't call exit() on CRAN. */
-  alloc_size[0] = alloc_size_a[0];
-  alloc_size[1] = alloc_size_a[1];
-  alloc_size[2] = alloc_size_b[0];
-  alloc_size[3] = alloc_size_b[1];
-}
-
-static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  FN_A(Store)(&self->ha, data, mask, ix);
-  FN_B(Store)(&self->hb, data, mask, ix);
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t mask, const size_t ix_start,
-    const size_t ix_end) {
-  FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
-  FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashComposite* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
-      ringbuffer, ring_buffer_mask);
-  FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
-      ringbuffer, ring_buffer_mask);
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
-  FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
-  FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
-}
-
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashComposite* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
-      max_distance, out);
-  FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
-      max_distance, out);
-}
-
-#undef HashComposite
-#undef HASHER_A
-#undef HASHER_B
-#undef HASHER
-
-#define HASHER() H55
-#define HASHER_A H54
-#define HASHER_B HROLLING_FAST
-/* NOLINT(build/header_guard) */
-/* Copyright 2018 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, HASHER_A, HASHER_B */
-
-/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A
-   and HASHER_B. */
-
-#define HashComposite HASHER()
-
-#define FN_A(X) EXPAND_CAT(X, HASHER_A)
-#define FN_B(X) EXPAND_CAT(X, HASHER_B)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) {
-  size_t a =  FN_A(HashTypeLength)();
-  size_t b =  FN_B(HashTypeLength)();
-  return a > b ? a : b;
-}
-
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
-  size_t a =  FN_A(StoreLookahead)();
-  size_t b =  FN_B(StoreLookahead)();
-  return a > b ? a : b;
-}
-
-typedef struct HashComposite {
-  HASHER_A ha;
-  HASHER_B hb;
-  HasherCommon ha_common;
-  HasherCommon hb_common;
-
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  BROTLI_BOOL fresh;
-  const BrotliEncoderParams* params;
-} HashComposite;
-
-static void FN(Initialize)(HasherCommon* common,
-    HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
-  self->common = common;
-
-  self->ha_common = *self->common;
-  self->hb_common = *self->common;
-  self->fresh = BROTLI_TRUE;
-  self->params = params;
-  /* TODO(lode): Initialize of the hashers is deferred to Prepare (and params
-     remembered here) because we don't get the one_shot and input_size params
-     here that are needed to know the memory size of them. Instead provide
-     those params to all hashers FN(Initialize) */
-}
-
-static void FN(Prepare)(
-    HashComposite* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  if (self->fresh) {
-    self->fresh = BROTLI_FALSE;
-    self->ha_common.extra[0] = self->common->extra[0];
-    self->ha_common.extra[1] = self->common->extra[1];
-    self->ha_common.extra[2] = NULL;
-    self->ha_common.extra[3] = NULL;
-    self->hb_common.extra[0] = self->common->extra[2];
-    self->hb_common.extra[1] = self->common->extra[3];
-    self->hb_common.extra[2] = NULL;
-    self->hb_common.extra[3] = NULL;
-
-    FN_A(Initialize)(&self->ha_common, &self->ha, self->params);
-    FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
-  }
-  FN_A(Prepare)(&self->ha, one_shot, input_size, data);
-  FN_B(Prepare)(&self->hb, one_shot, input_size, data);
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  size_t alloc_size_a[4] = {0};
-  size_t alloc_size_b[4] = {0};
-  FN_A(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_a);
-  FN_B(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_b);
-  /* Should never happen. */
-  /* Can't call exit() on CRAN. */
-  alloc_size[0] = alloc_size_a[0];
-  alloc_size[1] = alloc_size_a[1];
-  alloc_size[2] = alloc_size_b[0];
-  alloc_size[3] = alloc_size_b[1];
-}
-
-static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  FN_A(Store)(&self->ha, data, mask, ix);
-  FN_B(Store)(&self->hb, data, mask, ix);
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t mask, const size_t ix_start,
-    const size_t ix_end) {
-  FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
-  FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashComposite* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
-      ringbuffer, ring_buffer_mask);
-  FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
-      ringbuffer, ring_buffer_mask);
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
-  FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
-  FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
-}
-
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashComposite* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
-      max_distance, out);
-  FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
-      max_distance, out);
-}
-
-#undef HashComposite
-#undef HASHER_A
-#undef HASHER_B
-#undef HASHER
-
-#define HASHER() H65
-#define HASHER_A H6
-#define HASHER_B HROLLING
-/* NOLINT(build/header_guard) */
-/* Copyright 2018 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, HASHER_A, HASHER_B */
-
-/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A
-   and HASHER_B. */
-
-#define HashComposite HASHER()
-
-#define FN_A(X) EXPAND_CAT(X, HASHER_A)
-#define FN_B(X) EXPAND_CAT(X, HASHER_B)
-
-static BROTLI_INLINE size_t FN(HashTypeLength)(void) {
-  size_t a =  FN_A(HashTypeLength)();
-  size_t b =  FN_B(HashTypeLength)();
-  return a > b ? a : b;
-}
-
-static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
-  size_t a =  FN_A(StoreLookahead)();
-  size_t b =  FN_B(StoreLookahead)();
-  return a > b ? a : b;
-}
-
-typedef struct HashComposite {
-  HASHER_A ha;
-  HASHER_B hb;
-  HasherCommon ha_common;
-  HasherCommon hb_common;
-
-  /* Shortcuts. */
-  HasherCommon* common;
-
-  BROTLI_BOOL fresh;
-  const BrotliEncoderParams* params;
-} HashComposite;
-
-static void FN(Initialize)(HasherCommon* common,
-    HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
-  self->common = common;
-
-  self->ha_common = *self->common;
-  self->hb_common = *self->common;
-  self->fresh = BROTLI_TRUE;
-  self->params = params;
-  /* TODO(lode): Initialize of the hashers is deferred to Prepare (and params
-     remembered here) because we don't get the one_shot and input_size params
-     here that are needed to know the memory size of them. Instead provide
-     those params to all hashers FN(Initialize) */
-}
-
-static void FN(Prepare)(
-    HashComposite* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
-  if (self->fresh) {
-    self->fresh = BROTLI_FALSE;
-    self->ha_common.extra[0] = self->common->extra[0];
-    self->ha_common.extra[1] = self->common->extra[1];
-    self->ha_common.extra[2] = NULL;
-    self->ha_common.extra[3] = NULL;
-    self->hb_common.extra[0] = self->common->extra[2];
-    self->hb_common.extra[1] = self->common->extra[3];
-    self->hb_common.extra[2] = NULL;
-    self->hb_common.extra[3] = NULL;
-
-    FN_A(Initialize)(&self->ha_common, &self->ha, self->params);
-    FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
-  }
-  FN_A(Prepare)(&self->ha, one_shot, input_size, data);
-  FN_B(Prepare)(&self->hb, one_shot, input_size, data);
-}
-
-static BROTLI_INLINE void FN(HashMemAllocInBytes)(
-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size, size_t* alloc_size) {
-  size_t alloc_size_a[4] = {0};
-  size_t alloc_size_b[4] = {0};
-  FN_A(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_a);
-  FN_B(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_b);
-  /* Should never happen. */
-  /* Can't call exit() on CRAN. */
-  alloc_size[0] = alloc_size_a[0];
-  alloc_size[1] = alloc_size_a[1];
-  alloc_size[2] = alloc_size_b[0];
-  alloc_size[3] = alloc_size_b[1];
-}
-
-static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  FN_A(Store)(&self->ha, data, mask, ix);
-  FN_B(Store)(&self->hb, data, mask, ix);
-}
-
-static BROTLI_INLINE void FN(StoreRange)(
-    HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t mask, const size_t ix_start,
-    const size_t ix_end) {
-  FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
-  FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
-}
-
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
-    HashComposite* BROTLI_RESTRICT self,
-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
-    size_t ring_buffer_mask) {
-  FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
-      ringbuffer, ring_buffer_mask);
-  FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
-      ringbuffer, ring_buffer_mask);
-}
-
-static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
-  FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
-  FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
-}
-
-static BROTLI_INLINE void FN(FindLongestMatch)(
-    HashComposite* BROTLI_RESTRICT self,
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
-    const size_t dictionary_distance, const size_t max_distance,
-    HasherSearchResult* BROTLI_RESTRICT out) {
-  FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
-      max_distance, out);
-  FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
-      max_distance, out);
-}
-
-#undef HashComposite
-#undef HASHER_A
-#undef HASHER_B
-#undef HASHER
-
-#undef FN
-#undef CAT
-#undef EXPAND_CAT
-
-#define FOR_SIMPLE_HASHERS(H) H(2) H(3) H(4) H(5) H(6) H(40) H(41) H(42) H(54)
-#define FOR_COMPOSITE_HASHERS(H) H(35) H(55) H(65)
-#define FOR_GENERIC_HASHERS(H) FOR_SIMPLE_HASHERS(H) FOR_COMPOSITE_HASHERS(H)
-#define FOR_ALL_HASHERS(H) FOR_GENERIC_HASHERS(H) H(10)
-
-typedef struct {
-  HasherCommon common;
-
-  union {
-#define MEMBER_(N) \
-    H ## N _H ## N;
-    FOR_ALL_HASHERS(MEMBER_)
-#undef MEMBER_
-  } privat;
-} Hasher;
-
-/* MUST be invoked before any other method. */
-static BROTLI_INLINE void HasherInit(Hasher* hasher) {
-  hasher->common.is_setup_ = BROTLI_FALSE;
-  hasher->common.extra[0] = NULL;
-  hasher->common.extra[1] = NULL;
-  hasher->common.extra[2] = NULL;
-  hasher->common.extra[3] = NULL;
-}
-
-static BROTLI_INLINE void DestroyHasher(MemoryManager* m, Hasher* hasher) {
-  if (hasher->common.extra[0] != NULL) BROTLI_FREE(m, hasher->common.extra[0]);
-  if (hasher->common.extra[1] != NULL) BROTLI_FREE(m, hasher->common.extra[1]);
-  if (hasher->common.extra[2] != NULL) BROTLI_FREE(m, hasher->common.extra[2]);
-  if (hasher->common.extra[3] != NULL) BROTLI_FREE(m, hasher->common.extra[3]);
-}
-
-static BROTLI_INLINE void HasherReset(Hasher* hasher) {
-  hasher->common.is_prepared_ = BROTLI_FALSE;
-}
-
-static BROTLI_INLINE void HasherSize(const BrotliEncoderParams* params,
-    BROTLI_BOOL one_shot, const size_t input_size, size_t* alloc_size) {
-  switch (params->hasher.type) {
-#define SIZE_(N)                                                           \
-    case N:                                                                \
-      HashMemAllocInBytesH ## N(params, one_shot, input_size, alloc_size); \
-      break;
-    FOR_ALL_HASHERS(SIZE_)
-#undef SIZE_
-    default:
-      break;
-  }
-}
-
-static BROTLI_INLINE void HasherSetup(MemoryManager* m, Hasher* hasher,
-    BrotliEncoderParams* params, const uint8_t* data, size_t position,
-    size_t input_size, BROTLI_BOOL is_last) {
-  BROTLI_BOOL one_shot = (position == 0 && is_last);
-  if (!hasher->common.is_setup_) {
-    size_t alloc_size[4] = {0};
-    size_t i;
-    ChooseHasher(params, &params->hasher);
-    hasher->common.params = params->hasher;
-    hasher->common.dict_num_lookups = 0;
-    hasher->common.dict_num_matches = 0;
-    HasherSize(params, one_shot, input_size, alloc_size);
-    for (i = 0; i < 4; ++i) {
-      if (alloc_size[i] == 0) continue;
-      hasher->common.extra[i] = BROTLI_ALLOC(m, uint8_t, alloc_size[i]);
-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(hasher->common.extra[i])) return;
-    }
-    switch (hasher->common.params.type) {
-#define INITIALIZE_(N)                        \
-      case N:                                 \
-        InitializeH ## N(&hasher->common,     \
-            &hasher->privat._H ## N, params); \
-        break;
-      FOR_ALL_HASHERS(INITIALIZE_);
-#undef INITIALIZE_
-      default:
-        break;
-    }
-    HasherReset(hasher);
-    hasher->common.is_setup_ = BROTLI_TRUE;
-  }
-
-  if (!hasher->common.is_prepared_) {
-    switch (hasher->common.params.type) {
-#define PREPARE_(N)                      \
-      case N:                            \
-        PrepareH ## N(                   \
-            &hasher->privat._H ## N,     \
-            one_shot, input_size, data); \
-        break;
-      FOR_ALL_HASHERS(PREPARE_)
-#undef PREPARE_
-      default: break;
-    }
-    hasher->common.is_prepared_ = BROTLI_TRUE;
-  }
-}
-
-static BROTLI_INLINE void InitOrStitchToPreviousBlock(
-    MemoryManager* m, Hasher* hasher, const uint8_t* data, size_t mask,
-    BrotliEncoderParams* params, size_t position, size_t input_size,
-    BROTLI_BOOL is_last) {
-  HasherSetup(m, hasher, params, data, position, input_size, is_last);
-  if (BROTLI_IS_OOM(m)) return;
-  switch (hasher->common.params.type) {
-#define INIT_(N)                             \
-    case N:                                  \
-      StitchToPreviousBlockH ## N(           \
-          &hasher->privat._H ## N,           \
-          input_size, position, data, mask); \
-    break;
-    FOR_ALL_HASHERS(INIT_)
-#undef INIT_
-    default: break;
-  }
-}
-
-/* NB: when seamless dictionary-ring-buffer copies are implemented, don't forget
-       to add proper guards for non-zero-BROTLI_PARAM_STREAM_OFFSET. */
-static BROTLI_INLINE void FindCompoundDictionaryMatch(
-    const PreparedDictionary* self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length, const size_t distance_offset,
-    const size_t max_distance, HasherSearchResult* BROTLI_RESTRICT out) {
-  const uint32_t source_size = self->source_size;
-  const size_t boundary = distance_offset - source_size;
-  const uint32_t hash_bits = self->hash_bits;
-  const uint32_t bucket_bits = self->bucket_bits;
-  const uint32_t slot_bits = self->slot_bits;
-
-  const uint32_t hash_shift = 64u - bucket_bits;
-  const uint32_t slot_mask = (~((uint32_t)0U)) >> (32 - slot_bits);
-  const uint64_t hash_mask = (~((uint64_t)0U)) >> (64 - hash_bits);
-
-  const uint32_t* slot_offsets = (uint32_t*)(&self[1]);
-  const uint16_t* heads = (uint16_t*)(&slot_offsets[1u << slot_bits]);
-  const uint32_t* items = (uint32_t*)(&heads[1u << bucket_bits]);
-  const uint8_t* source = NULL;
-
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  score_t best_score = out->score;
-  size_t best_len = out->len;
-  size_t i;
-  const uint64_t h =
-      (BROTLI_UNALIGNED_LOAD64LE(&data[cur_ix_masked]) & hash_mask) *
-      kPreparedDictionaryHashMul64Long;
-  const uint32_t key = (uint32_t)(h >> hash_shift);
-  const uint32_t slot = key & slot_mask;
-  const uint32_t head = heads[key];
-  const uint32_t* BROTLI_RESTRICT chain = &items[slot_offsets[slot] + head];
-  uint32_t item = (head == 0xFFFF) ? 1 : 0;
-
-  const void* tail = (void*)&items[self->num_items];
-  if (self->magic == kPreparedDictionaryMagic) {
-    source = (const uint8_t*)tail;
-  } else {
-    /* kLeanPreparedDictionaryMagic */
-    source = (const uint8_t*)BROTLI_UNALIGNED_LOAD_PTR((const uint8_t**)tail);
-  }
-
-  for (i = 0; i < 4; ++i) {
-    const size_t distance = (size_t)distance_cache[i];
-    size_t offset;
-    size_t limit;
-    size_t len;
-    if (distance <= boundary || distance > distance_offset) continue;
-    offset = distance_offset - distance;
-    limit = source_size - offset;
-    limit = limit > max_length ? max_length : limit;
-    len = FindMatchLengthWithLimit(&source[offset], &data[cur_ix_masked],
-                                   limit);
-    if (len >= 2) {
-      score_t score = BackwardReferenceScoreUsingLastDistance(len);
-      if (best_score < score) {
-        if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
-        if (best_score < score) {
-          best_score = score;
-          if (len > best_len) best_len = len;
-          out->len = len;
-          out->len_code_delta = 0;
-          out->distance = distance;
-          out->score = best_score;
-        }
-      }
-    }
-  }
-  while (item == 0) {
-    size_t offset;
-    size_t distance;
-    size_t limit;
-    item = *chain;
-    chain++;
-    offset = item & 0x7FFFFFFF;
-    item &= 0x80000000;
-    distance = distance_offset - offset;
-    limit = source_size - offset;
-    limit = (limit > max_length) ? max_length : limit;
-    if (distance > max_distance) continue;
-    if (cur_ix_masked + best_len > ring_buffer_mask ||
-        best_len >= limit ||
-        data[cur_ix_masked + best_len] != source[offset + best_len]) {
-      continue;
-    }
-    {
-      const size_t len = FindMatchLengthWithLimit(&source[offset],
-                                                  &data[cur_ix_masked],
-                                                  limit);
-      if (len >= 4) {
-        score_t score = BackwardReferenceScore(len, distance);
-        if (best_score < score) {
-          best_score = score;
-          best_len = len;
-          out->len = best_len;
-          out->len_code_delta = 0;
-          out->distance = distance;
-          out->score = best_score;
-        }
-      }
-    }
-  }
-}
-
-/* NB: when seamless dictionary-ring-buffer copies are implemented, don't forget
-       to add proper guards for non-zero-BROTLI_PARAM_STREAM_OFFSET. */
-static BROTLI_INLINE size_t FindAllCompoundDictionaryMatches(
-    const PreparedDictionary* self, const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const size_t cur_ix, const size_t min_length,
-    const size_t max_length, const size_t distance_offset,
-    const size_t max_distance, BackwardMatch* matches, size_t match_limit) {
-  const uint32_t source_size = self->source_size;
-  const uint32_t hash_bits = self->hash_bits;
-  const uint32_t bucket_bits = self->bucket_bits;
-  const uint32_t slot_bits = self->slot_bits;
-
-  const uint32_t hash_shift = 64u - bucket_bits;
-  const uint32_t slot_mask = (~((uint32_t)0U)) >> (32 - slot_bits);
-  const uint64_t hash_mask = (~((uint64_t)0U)) >> (64 - hash_bits);
-
-  const uint32_t* slot_offsets = (uint32_t*)(&self[1]);
-  const uint16_t* heads = (uint16_t*)(&slot_offsets[1u << slot_bits]);
-  const uint32_t* items = (uint32_t*)(&heads[1u << bucket_bits]);
-  const uint8_t* source = NULL;
-
-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  size_t best_len = min_length;
-  const uint64_t h =
-      (BROTLI_UNALIGNED_LOAD64LE(&data[cur_ix_masked]) & hash_mask) *
-      kPreparedDictionaryHashMul64Long;
-  const uint32_t key = (uint32_t)(h >> hash_shift);
-  const uint32_t slot = key & slot_mask;
-  const uint32_t head = heads[key];
-  const uint32_t* BROTLI_RESTRICT chain = &items[slot_offsets[slot] + head];
-  uint32_t item = (head == 0xFFFF) ? 1 : 0;
-  size_t found = 0;
-
-  const void* tail = (void*)&items[self->num_items];
-  if (self->magic == kPreparedDictionaryMagic) {
-    source = (const uint8_t*)tail;
-  } else {
-    /* kLeanPreparedDictionaryMagic */
-    source = (const uint8_t*)BROTLI_UNALIGNED_LOAD_PTR((const uint8_t**)tail);
-  }
-
-  while (item == 0) {
-    size_t offset;
-    size_t distance;
-    size_t limit;
-    size_t len;
-    item = *chain;
-    chain++;
-    offset = item & 0x7FFFFFFF;
-    item &= 0x80000000;
-    distance = distance_offset - offset;
-    limit = source_size - offset;
-    limit = (limit > max_length) ? max_length : limit;
-    if (distance > max_distance) continue;
-    if (cur_ix_masked + best_len > ring_buffer_mask ||
-        best_len >= limit ||
-        data[cur_ix_masked + best_len] != source[offset + best_len]) {
-      continue;
-    }
-    len = FindMatchLengthWithLimit(
-        &source[offset], &data[cur_ix_masked], limit);
-    if (len > best_len) {
-      best_len = len;
-      InitBackwardMatch(matches++, distance, len);
-      found++;
-      if (found == match_limit) break;
-    }
-  }
-  return found;
-}
-
-static BROTLI_INLINE void LookupCompoundDictionaryMatch(
-    const CompoundDictionary* addon, const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
-    const size_t cur_ix, const size_t max_length,
-    const size_t max_ring_buffer_distance, const size_t max_distance,
-    HasherSearchResult* sr) {
-  size_t base_offset = max_ring_buffer_distance + 1 + addon->total_size - 1;
-  size_t d;
-  for (d = 0; d < addon->num_chunks; ++d) {
-    /* Only one prepared dictionary type is currently supported. */
-    FindCompoundDictionaryMatch(
-        (const PreparedDictionary*)addon->chunks[d], data, ring_buffer_mask,
-        distance_cache, cur_ix, max_length,
-        base_offset - addon->chunk_offsets[d], max_distance, sr);
-  }
-}
-
-static BROTLI_INLINE size_t LookupAllCompoundDictionaryMatches(
-    const CompoundDictionary* addon, const uint8_t* BROTLI_RESTRICT data,
-    const size_t ring_buffer_mask, const size_t cur_ix, size_t min_length,
-    const size_t max_length, const size_t max_ring_buffer_distance,
-    const size_t max_distance, BackwardMatch* matches,
-    size_t match_limit) {
-  size_t base_offset = max_ring_buffer_distance + 1 + addon->total_size - 1;
-  size_t d;
-  size_t total_found = 0;
-  for (d = 0; d < addon->num_chunks; ++d) {
-    /* Only one prepared dictionary type is currently supported. */
-    total_found += FindAllCompoundDictionaryMatches(
-        (const PreparedDictionary*)addon->chunks[d], data, ring_buffer_mask,
-        cur_ix, min_length, max_length, base_offset - addon->chunk_offsets[d],
-        max_distance, matches + total_found, match_limit - total_found);
-    if (total_found == match_limit) break;
-    if (total_found > 0) {
-      min_length = BackwardMatchLength(&matches[total_found - 1]);
-    }
-  }
-  return total_found;
-}
-
-}
-
-#endif  /* BROTLI_ENC_HASH_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/brotli_params.h b/src/duckdb/third_party/brotli/enc/brotli_params.h
deleted file mode 100644
index 4564179d2..000000000
--- a/src/duckdb/third_party/brotli/enc/brotli_params.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Parameters for the Brotli encoder with chosen quality levels. */
-
-#ifndef BROTLI_ENC_PARAMS_H_
-#define BROTLI_ENC_PARAMS_H_
-
-#include <brotli/encode.h>
-
-#include "encoder_dict.h"
-
-typedef struct BrotliHasherParams {
-  int type;
-  int bucket_bits;
-  int block_bits;
-  int num_last_distances_to_check;
-} BrotliHasherParams;
-
-typedef struct BrotliDistanceParams {
-  uint32_t distance_postfix_bits;
-  uint32_t num_direct_distance_codes;
-  uint32_t alphabet_size_max;
-  uint32_t alphabet_size_limit;
-  size_t max_distance;
-} BrotliDistanceParams;
-
-/* Encoding parameters */
-typedef struct BrotliEncoderParams {
-  BrotliEncoderMode mode;
-  int quality;
-  int lgwin;
-  int lgblock;
-  size_t stream_offset;
-  size_t size_hint;
-  BROTLI_BOOL disable_literal_context_modeling;
-  BROTLI_BOOL large_window;
-  BrotliHasherParams hasher;
-  BrotliDistanceParams dist;
-  /* TODO(eustas): rename to BrotliShared... */
-  duckdb_brotli::SharedEncoderDictionary dictionary;
-} BrotliEncoderParams;
-
-#endif  /* BROTLI_ENC_PARAMS_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/cluster.cpp b/src/duckdb/third_party/brotli/enc/cluster.cpp
deleted file mode 100644
index 90d19a694..000000000
--- a/src/duckdb/third_party/brotli/enc/cluster.cpp
+++ /dev/null
@@ -1,1025 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Functions for clustering similar histograms together. */
-
-#include "cluster.h"
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "bit_cost.h"  /* BrotliPopulationCost */
-#include "fast_log.h"
-#include "histogram.h"
-#include "memory.h"
-
-using namespace duckdb_brotli;
-
-static BROTLI_INLINE BROTLI_BOOL HistogramPairIsLess(
-    const HistogramPair* p1, const HistogramPair* p2) {
-  if (p1->cost_diff != p2->cost_diff) {
-    return TO_BROTLI_BOOL(p1->cost_diff > p2->cost_diff);
-  }
-  return TO_BROTLI_BOOL((p1->idx2 - p1->idx1) > (p2->idx2 - p2->idx1));
-}
-
-/* Returns entropy reduction of the context map when we combine two clusters. */
-static BROTLI_INLINE double ClusterCostDiff(size_t size_a, size_t size_b) {
-  size_t size_c = size_a + size_b;
-  return (double)size_a * FastLog2(size_a) +
-    (double)size_b * FastLog2(size_b) -
-    (double)size_c * FastLog2(size_c);
-}
-
-#define CODE(X) X
-
-#define FN(X) duckdb_brotli:: X ## Literal
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, CODE */
-
-#define HistogramType FN(Histogram)
-
-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
-    const HistogramType* out, HistogramType* tmp, const uint32_t* cluster_size,
-    uint32_t idx1, uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
-    size_t* num_pairs) CODE({
-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
-  HistogramPair p;
-  p.idx1 = p.idx2 = 0;
-  p.cost_diff = p.cost_combo = 0;
-  if (idx1 == idx2) {
-    return;
-  }
-  if (idx2 < idx1) {
-    uint32_t t = idx2;
-    idx2 = idx1;
-    idx1 = t;
-  }
-  p.idx1 = idx1;
-  p.idx2 = idx2;
-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
-  p.cost_diff -= out[idx1].bit_cost_;
-  p.cost_diff -= out[idx2].bit_cost_;
-
-  if (out[idx1].total_count_ == 0) {
-    p.cost_combo = out[idx2].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else if (out[idx2].total_count_ == 0) {
-    p.cost_combo = out[idx1].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else {
-    double threshold = *num_pairs == 0 ? 1e99 :
-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
-    double cost_combo;
-    *tmp = out[idx1];
-    FN(HistogramAddHistogram)(tmp, &out[idx2]);
-    cost_combo = FN(BrotliPopulationCost)(tmp);
-    if (cost_combo < threshold - p.cost_diff) {
-      p.cost_combo = cost_combo;
-      is_good_pair = BROTLI_TRUE;
-    }
-  }
-  if (is_good_pair) {
-    p.cost_diff += p.cost_combo;
-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
-      /* Replace the top of the queue if needed. */
-      if (*num_pairs < max_num_pairs) {
-        pairs[*num_pairs] = pairs[0];
-        ++(*num_pairs);
-      }
-      pairs[0] = p;
-    } else if (*num_pairs < max_num_pairs) {
-      pairs[*num_pairs] = p;
-      ++(*num_pairs);
-    }
-  }
-})
-
-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
-                                                  HistogramType* tmp,
-                                                  uint32_t* cluster_size,
-                                                  uint32_t* symbols,
-                                                  uint32_t* clusters,
-                                                  HistogramPair* pairs,
-                                                  size_t num_clusters,
-                                                  size_t symbols_size,
-                                                  size_t max_clusters,
-                                                  size_t max_num_pairs) CODE({
-  double cost_diff_threshold = 0.0;
-  size_t min_cluster_size = 1;
-  size_t num_pairs = 0;
-
-  {
-    /* We maintain a vector of histogram pairs, with the property that the pair
-       with the maximum bit cost reduction is the first. */
-    size_t idx1;
-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
-      size_t idx2;
-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
-        FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, clusters[idx1],
-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
-      }
-    }
-  }
-
-  while (num_clusters > min_cluster_size) {
-    uint32_t best_idx1;
-    uint32_t best_idx2;
-    size_t i;
-    if (pairs[0].cost_diff >= cost_diff_threshold) {
-      cost_diff_threshold = 1e99;
-      min_cluster_size = max_clusters;
-      continue;
-    }
-    /* Take the best pair from the top of heap. */
-    best_idx1 = pairs[0].idx1;
-    best_idx2 = pairs[0].idx2;
-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
-    cluster_size[best_idx1] += cluster_size[best_idx2];
-    for (i = 0; i < symbols_size; ++i) {
-      if (symbols[i] == best_idx2) {
-        symbols[i] = best_idx1;
-      }
-    }
-    for (i = 0; i < num_clusters; ++i) {
-      if (clusters[i] == best_idx2) {
-        memmove(&clusters[i], &clusters[i + 1],
-                (num_clusters - i - 1) * sizeof(clusters[0]));
-        break;
-      }
-    }
-    --num_clusters;
-    {
-      /* Remove pairs intersecting the just combined best pair. */
-      size_t copy_to_idx = 0;
-      for (i = 0; i < num_pairs; ++i) {
-        HistogramPair* p = &pairs[i];
-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
-          /* Remove invalid pair from the queue. */
-          continue;
-        }
-        if (HistogramPairIsLess(&pairs[0], p)) {
-          /* Replace the top of the queue if needed. */
-          HistogramPair front = pairs[0];
-          pairs[0] = *p;
-          pairs[copy_to_idx] = front;
-        } else {
-          pairs[copy_to_idx] = *p;
-        }
-        ++copy_to_idx;
-      }
-      num_pairs = copy_to_idx;
-    }
-
-    /* Push new pairs formed with the combined histogram to the heap. */
-    for (i = 0; i < num_clusters; ++i) {
-      FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, best_idx1,
-          clusters[i], max_num_pairs, &pairs[0], &num_pairs);
-    }
-  }
-  return num_clusters;
-})
-
-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
-    const HistogramType* histogram, const HistogramType* candidate,
-    HistogramType* tmp) CODE({
-  if (histogram->total_count_ == 0) {
-    return 0.0;
-  } else {
-    *tmp = *histogram;
-    FN(HistogramAddHistogram)(tmp, candidate);
-    return FN(BrotliPopulationCost)(tmp) - candidate->bit_cost_;
-  }
-})
-
-/* Find the best 'out' histogram for each of the 'in' histograms.
-   When called, clusters[0..num_clusters) contains the unique values from
-   symbols[0..in_size), but this property is not preserved in this function.
-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
-    HistogramType* out, HistogramType* tmp, uint32_t* symbols) CODE({
-  size_t i;
-  for (i = 0; i < in_size; ++i) {
-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
-    double best_bits =
-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out], tmp);
-    size_t j;
-    for (j = 0; j < num_clusters; ++j) {
-      const double cur_bits =
-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]], tmp);
-      if (cur_bits < best_bits) {
-        best_bits = cur_bits;
-        best_out = clusters[j];
-      }
-    }
-    symbols[i] = best_out;
-  }
-
-  /* Recompute each out based on raw and symbols. */
-  for (i = 0; i < num_clusters; ++i) {
-    FN(HistogramClear)(&out[clusters[i]]);
-  }
-  for (i = 0; i < in_size; ++i) {
-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
-  }
-})
-
-/* Reorders elements of the out[0..length) array and changes values in
-   symbols[0..length) array in the following way:
-     * when called, symbols[] contains indexes into out[], and has N unique
-       values (possibly N < length)
-     * on return, symbols'[i] = f(symbols[i]) and
-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
-       where f is a bijection between the range of symbols[] and [0..N), and
-       the first occurrences of values in symbols'[i] come in consecutive
-       increasing order.
-   Returns N, the number of unique values in symbols[]. */
-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
-  uint32_t next_index;
-  HistogramType* tmp;
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
-  for (i = 0; i < length; ++i) {
-      new_index[i] = kInvalidIndex;
-  }
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == kInvalidIndex) {
-      new_index[symbols[i]] = next_index;
-      ++next_index;
-    }
-  }
-  /* TODO(eustas): by using idea of "cycle-sort" we can avoid allocation of
-     tmp and reduce the number of copying by the factor of 2. */
-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == next_index) {
-      tmp[next_index] = out[symbols[i]];
-      ++next_index;
-    }
-    symbols[i] = new_index[symbols[i]];
-  }
-  BROTLI_FREE(m, new_index);
-  for (i = 0; i < next_index; ++i) {
-    out[i] = tmp[i];
-  }
-  BROTLI_FREE(m, tmp);
-  return next_index;
-})
-
-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
-    MemoryManager* m, const HistogramType* in, const size_t in_size,
-    size_t max_histograms, HistogramType* out, size_t* out_size,
-    uint32_t* histogram_symbols) CODE({
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
-  size_t num_clusters = 0;
-  const size_t max_input_histograms = 64;
-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
-  /* For the first pass of clustering, we allow all pairs. */
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
-  /* TODO(eustas): move to "persistent" arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 1);
-  size_t i;
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)|| BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    cluster_size[i] = 1;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    out[i] = in[i];
-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
-    histogram_symbols[i] = (uint32_t)i;
-  }
-
-  for (i = 0; i < in_size; i += max_input_histograms) {
-    size_t num_to_combine =
-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      clusters[num_clusters + j] = (uint32_t)(i + j);
-    }
-    num_new_clusters =
-        FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                   &histogram_symbols[i],
-                                   &clusters[num_clusters], pairs,
-                                   num_to_combine, num_to_combine,
-                                   max_histograms, pairs_capacity);
-    num_clusters += num_new_clusters;
-  }
-
-  {
-    /* For the second pass, we limit the total number of histogram pairs.
-       After this limit is reached, we only keep searching for the best pair. */
-    size_t max_num_pairs = BROTLI_MIN(size_t,
-        64 * num_clusters, (num_clusters / 2) * num_clusters);
-    BROTLI_ENSURE_CAPACITY(
-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m)) return;
-
-    /* Collapse similar histograms. */
-    num_clusters = FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                              histogram_symbols, clusters,
-                                              pairs, num_clusters, in_size,
-                                              max_histograms, max_num_pairs);
-  }
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-  /* Find the optimal map from original histograms to the final ones. */
-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
-                           out, tmp, histogram_symbols);
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  /* Convert the context map to a canonical form. */
-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
-  if (BROTLI_IS_OOM(m)) return;
-})
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) duckdb_brotli:: X ## Command
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, CODE */
-
-#define HistogramType FN(Histogram)
-
-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
-    const HistogramType* out, HistogramType* tmp, const uint32_t* cluster_size,
-    uint32_t idx1, uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
-    size_t* num_pairs) CODE({
-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
-  HistogramPair p;
-  p.idx1 = p.idx2 = 0;
-  p.cost_diff = p.cost_combo = 0;
-  if (idx1 == idx2) {
-    return;
-  }
-  if (idx2 < idx1) {
-    uint32_t t = idx2;
-    idx2 = idx1;
-    idx1 = t;
-  }
-  p.idx1 = idx1;
-  p.idx2 = idx2;
-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
-  p.cost_diff -= out[idx1].bit_cost_;
-  p.cost_diff -= out[idx2].bit_cost_;
-
-  if (out[idx1].total_count_ == 0) {
-    p.cost_combo = out[idx2].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else if (out[idx2].total_count_ == 0) {
-    p.cost_combo = out[idx1].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else {
-    double threshold = *num_pairs == 0 ? 1e99 :
-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
-    double cost_combo;
-    *tmp = out[idx1];
-    FN(HistogramAddHistogram)(tmp, &out[idx2]);
-    cost_combo = FN(BrotliPopulationCost)(tmp);
-    if (cost_combo < threshold - p.cost_diff) {
-      p.cost_combo = cost_combo;
-      is_good_pair = BROTLI_TRUE;
-    }
-  }
-  if (is_good_pair) {
-    p.cost_diff += p.cost_combo;
-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
-      /* Replace the top of the queue if needed. */
-      if (*num_pairs < max_num_pairs) {
-        pairs[*num_pairs] = pairs[0];
-        ++(*num_pairs);
-      }
-      pairs[0] = p;
-    } else if (*num_pairs < max_num_pairs) {
-      pairs[*num_pairs] = p;
-      ++(*num_pairs);
-    }
-  }
-})
-
-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
-                                                  HistogramType* tmp,
-                                                  uint32_t* cluster_size,
-                                                  uint32_t* symbols,
-                                                  uint32_t* clusters,
-                                                  HistogramPair* pairs,
-                                                  size_t num_clusters,
-                                                  size_t symbols_size,
-                                                  size_t max_clusters,
-                                                  size_t max_num_pairs) CODE({
-  double cost_diff_threshold = 0.0;
-  size_t min_cluster_size = 1;
-  size_t num_pairs = 0;
-
-  {
-    /* We maintain a vector of histogram pairs, with the property that the pair
-       with the maximum bit cost reduction is the first. */
-    size_t idx1;
-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
-      size_t idx2;
-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
-        FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, clusters[idx1],
-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
-      }
-    }
-  }
-
-  while (num_clusters > min_cluster_size) {
-    uint32_t best_idx1;
-    uint32_t best_idx2;
-    size_t i;
-    if (pairs[0].cost_diff >= cost_diff_threshold) {
-      cost_diff_threshold = 1e99;
-      min_cluster_size = max_clusters;
-      continue;
-    }
-    /* Take the best pair from the top of heap. */
-    best_idx1 = pairs[0].idx1;
-    best_idx2 = pairs[0].idx2;
-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
-    cluster_size[best_idx1] += cluster_size[best_idx2];
-    for (i = 0; i < symbols_size; ++i) {
-      if (symbols[i] == best_idx2) {
-        symbols[i] = best_idx1;
-      }
-    }
-    for (i = 0; i < num_clusters; ++i) {
-      if (clusters[i] == best_idx2) {
-        memmove(&clusters[i], &clusters[i + 1],
-                (num_clusters - i - 1) * sizeof(clusters[0]));
-        break;
-      }
-    }
-    --num_clusters;
-    {
-      /* Remove pairs intersecting the just combined best pair. */
-      size_t copy_to_idx = 0;
-      for (i = 0; i < num_pairs; ++i) {
-        HistogramPair* p = &pairs[i];
-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
-          /* Remove invalid pair from the queue. */
-          continue;
-        }
-        if (HistogramPairIsLess(&pairs[0], p)) {
-          /* Replace the top of the queue if needed. */
-          HistogramPair front = pairs[0];
-          pairs[0] = *p;
-          pairs[copy_to_idx] = front;
-        } else {
-          pairs[copy_to_idx] = *p;
-        }
-        ++copy_to_idx;
-      }
-      num_pairs = copy_to_idx;
-    }
-
-    /* Push new pairs formed with the combined histogram to the heap. */
-    for (i = 0; i < num_clusters; ++i) {
-      FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, best_idx1,
-          clusters[i], max_num_pairs, &pairs[0], &num_pairs);
-    }
-  }
-  return num_clusters;
-})
-
-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
-    const HistogramType* histogram, const HistogramType* candidate,
-    HistogramType* tmp) CODE({
-  if (histogram->total_count_ == 0) {
-    return 0.0;
-  } else {
-    *tmp = *histogram;
-    FN(HistogramAddHistogram)(tmp, candidate);
-    return FN(BrotliPopulationCost)(tmp) - candidate->bit_cost_;
-  }
-})
-
-/* Find the best 'out' histogram for each of the 'in' histograms.
-   When called, clusters[0..num_clusters) contains the unique values from
-   symbols[0..in_size), but this property is not preserved in this function.
-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
-    HistogramType* out, HistogramType* tmp, uint32_t* symbols) CODE({
-  size_t i;
-  for (i = 0; i < in_size; ++i) {
-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
-    double best_bits =
-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out], tmp);
-    size_t j;
-    for (j = 0; j < num_clusters; ++j) {
-      const double cur_bits =
-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]], tmp);
-      if (cur_bits < best_bits) {
-        best_bits = cur_bits;
-        best_out = clusters[j];
-      }
-    }
-    symbols[i] = best_out;
-  }
-
-  /* Recompute each out based on raw and symbols. */
-  for (i = 0; i < num_clusters; ++i) {
-    FN(HistogramClear)(&out[clusters[i]]);
-  }
-  for (i = 0; i < in_size; ++i) {
-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
-  }
-})
-
-/* Reorders elements of the out[0..length) array and changes values in
-   symbols[0..length) array in the following way:
-     * when called, symbols[] contains indexes into out[], and has N unique
-       values (possibly N < length)
-     * on return, symbols'[i] = f(symbols[i]) and
-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
-       where f is a bijection between the range of symbols[] and [0..N), and
-       the first occurrences of values in symbols'[i] come in consecutive
-       increasing order.
-   Returns N, the number of unique values in symbols[]. */
-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
-  uint32_t next_index;
-  HistogramType* tmp;
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
-  for (i = 0; i < length; ++i) {
-      new_index[i] = kInvalidIndex;
-  }
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == kInvalidIndex) {
-      new_index[symbols[i]] = next_index;
-      ++next_index;
-    }
-  }
-  /* TODO(eustas): by using idea of "cycle-sort" we can avoid allocation of
-     tmp and reduce the number of copying by the factor of 2. */
-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == next_index) {
-      tmp[next_index] = out[symbols[i]];
-      ++next_index;
-    }
-    symbols[i] = new_index[symbols[i]];
-  }
-  BROTLI_FREE(m, new_index);
-  for (i = 0; i < next_index; ++i) {
-    out[i] = tmp[i];
-  }
-  BROTLI_FREE(m, tmp);
-  return next_index;
-})
-
-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
-    MemoryManager* m, const HistogramType* in, const size_t in_size,
-    size_t max_histograms, HistogramType* out, size_t* out_size,
-    uint32_t* histogram_symbols) CODE({
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
-  size_t num_clusters = 0;
-  const size_t max_input_histograms = 64;
-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
-  /* For the first pass of clustering, we allow all pairs. */
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
-  /* TODO(eustas): move to "persistent" arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 1);
-  size_t i;
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)|| BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    cluster_size[i] = 1;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    out[i] = in[i];
-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
-    histogram_symbols[i] = (uint32_t)i;
-  }
-
-  for (i = 0; i < in_size; i += max_input_histograms) {
-    size_t num_to_combine =
-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      clusters[num_clusters + j] = (uint32_t)(i + j);
-    }
-    num_new_clusters =
-        FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                   &histogram_symbols[i],
-                                   &clusters[num_clusters], pairs,
-                                   num_to_combine, num_to_combine,
-                                   max_histograms, pairs_capacity);
-    num_clusters += num_new_clusters;
-  }
-
-  {
-    /* For the second pass, we limit the total number of histogram pairs.
-       After this limit is reached, we only keep searching for the best pair. */
-    size_t max_num_pairs = BROTLI_MIN(size_t,
-        64 * num_clusters, (num_clusters / 2) * num_clusters);
-    BROTLI_ENSURE_CAPACITY(
-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m)) return;
-
-    /* Collapse similar histograms. */
-    num_clusters = FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                              histogram_symbols, clusters,
-                                              pairs, num_clusters, in_size,
-                                              max_histograms, max_num_pairs);
-  }
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-  /* Find the optimal map from original histograms to the final ones. */
-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
-                           out, tmp, histogram_symbols);
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  /* Convert the context map to a canonical form. */
-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
-  if (BROTLI_IS_OOM(m)) return;
-})
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) duckdb_brotli:: X ## Distance
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, CODE */
-
-#define HistogramType FN(Histogram)
-
-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
-    const HistogramType* out, HistogramType* tmp, const uint32_t* cluster_size,
-    uint32_t idx1, uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
-    size_t* num_pairs) CODE({
-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
-  HistogramPair p;
-  p.idx1 = p.idx2 = 0;
-  p.cost_diff = p.cost_combo = 0;
-  if (idx1 == idx2) {
-    return;
-  }
-  if (idx2 < idx1) {
-    uint32_t t = idx2;
-    idx2 = idx1;
-    idx1 = t;
-  }
-  p.idx1 = idx1;
-  p.idx2 = idx2;
-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
-  p.cost_diff -= out[idx1].bit_cost_;
-  p.cost_diff -= out[idx2].bit_cost_;
-
-  if (out[idx1].total_count_ == 0) {
-    p.cost_combo = out[idx2].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else if (out[idx2].total_count_ == 0) {
-    p.cost_combo = out[idx1].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else {
-    double threshold = *num_pairs == 0 ? 1e99 :
-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
-    double cost_combo;
-    *tmp = out[idx1];
-    FN(HistogramAddHistogram)(tmp, &out[idx2]);
-    cost_combo = FN(BrotliPopulationCost)(tmp);
-    if (cost_combo < threshold - p.cost_diff) {
-      p.cost_combo = cost_combo;
-      is_good_pair = BROTLI_TRUE;
-    }
-  }
-  if (is_good_pair) {
-    p.cost_diff += p.cost_combo;
-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
-      /* Replace the top of the queue if needed. */
-      if (*num_pairs < max_num_pairs) {
-        pairs[*num_pairs] = pairs[0];
-        ++(*num_pairs);
-      }
-      pairs[0] = p;
-    } else if (*num_pairs < max_num_pairs) {
-      pairs[*num_pairs] = p;
-      ++(*num_pairs);
-    }
-  }
-})
-
-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
-                                                  HistogramType* tmp,
-                                                  uint32_t* cluster_size,
-                                                  uint32_t* symbols,
-                                                  uint32_t* clusters,
-                                                  HistogramPair* pairs,
-                                                  size_t num_clusters,
-                                                  size_t symbols_size,
-                                                  size_t max_clusters,
-                                                  size_t max_num_pairs) CODE({
-  double cost_diff_threshold = 0.0;
-  size_t min_cluster_size = 1;
-  size_t num_pairs = 0;
-
-  {
-    /* We maintain a vector of histogram pairs, with the property that the pair
-       with the maximum bit cost reduction is the first. */
-    size_t idx1;
-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
-      size_t idx2;
-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
-        FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, clusters[idx1],
-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
-      }
-    }
-  }
-
-  while (num_clusters > min_cluster_size) {
-    uint32_t best_idx1;
-    uint32_t best_idx2;
-    size_t i;
-    if (pairs[0].cost_diff >= cost_diff_threshold) {
-      cost_diff_threshold = 1e99;
-      min_cluster_size = max_clusters;
-      continue;
-    }
-    /* Take the best pair from the top of heap. */
-    best_idx1 = pairs[0].idx1;
-    best_idx2 = pairs[0].idx2;
-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
-    cluster_size[best_idx1] += cluster_size[best_idx2];
-    for (i = 0; i < symbols_size; ++i) {
-      if (symbols[i] == best_idx2) {
-        symbols[i] = best_idx1;
-      }
-    }
-    for (i = 0; i < num_clusters; ++i) {
-      if (clusters[i] == best_idx2) {
-        memmove(&clusters[i], &clusters[i + 1],
-                (num_clusters - i - 1) * sizeof(clusters[0]));
-        break;
-      }
-    }
-    --num_clusters;
-    {
-      /* Remove pairs intersecting the just combined best pair. */
-      size_t copy_to_idx = 0;
-      for (i = 0; i < num_pairs; ++i) {
-        HistogramPair* p = &pairs[i];
-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
-          /* Remove invalid pair from the queue. */
-          continue;
-        }
-        if (HistogramPairIsLess(&pairs[0], p)) {
-          /* Replace the top of the queue if needed. */
-          HistogramPair front = pairs[0];
-          pairs[0] = *p;
-          pairs[copy_to_idx] = front;
-        } else {
-          pairs[copy_to_idx] = *p;
-        }
-        ++copy_to_idx;
-      }
-      num_pairs = copy_to_idx;
-    }
-
-    /* Push new pairs formed with the combined histogram to the heap. */
-    for (i = 0; i < num_clusters; ++i) {
-      FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, best_idx1,
-          clusters[i], max_num_pairs, &pairs[0], &num_pairs);
-    }
-  }
-  return num_clusters;
-})
-
-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
-    const HistogramType* histogram, const HistogramType* candidate,
-    HistogramType* tmp) CODE({
-  if (histogram->total_count_ == 0) {
-    return 0.0;
-  } else {
-    *tmp = *histogram;
-    FN(HistogramAddHistogram)(tmp, candidate);
-    return FN(BrotliPopulationCost)(tmp) - candidate->bit_cost_;
-  }
-})
-
-/* Find the best 'out' histogram for each of the 'in' histograms.
-   When called, clusters[0..num_clusters) contains the unique values from
-   symbols[0..in_size), but this property is not preserved in this function.
-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
-    HistogramType* out, HistogramType* tmp, uint32_t* symbols) CODE({
-  size_t i;
-  for (i = 0; i < in_size; ++i) {
-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
-    double best_bits =
-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out], tmp);
-    size_t j;
-    for (j = 0; j < num_clusters; ++j) {
-      const double cur_bits =
-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]], tmp);
-      if (cur_bits < best_bits) {
-        best_bits = cur_bits;
-        best_out = clusters[j];
-      }
-    }
-    symbols[i] = best_out;
-  }
-
-  /* Recompute each out based on raw and symbols. */
-  for (i = 0; i < num_clusters; ++i) {
-    FN(HistogramClear)(&out[clusters[i]]);
-  }
-  for (i = 0; i < in_size; ++i) {
-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
-  }
-})
-
-/* Reorders elements of the out[0..length) array and changes values in
-   symbols[0..length) array in the following way:
-     * when called, symbols[] contains indexes into out[], and has N unique
-       values (possibly N < length)
-     * on return, symbols'[i] = f(symbols[i]) and
-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
-       where f is a bijection between the range of symbols[] and [0..N), and
-       the first occurrences of values in symbols'[i] come in consecutive
-       increasing order.
-   Returns N, the number of unique values in symbols[]. */
-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
-  uint32_t next_index;
-  HistogramType* tmp;
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
-  for (i = 0; i < length; ++i) {
-      new_index[i] = kInvalidIndex;
-  }
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == kInvalidIndex) {
-      new_index[symbols[i]] = next_index;
-      ++next_index;
-    }
-  }
-  /* TODO(eustas): by using idea of "cycle-sort" we can avoid allocation of
-     tmp and reduce the number of copying by the factor of 2. */
-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == next_index) {
-      tmp[next_index] = out[symbols[i]];
-      ++next_index;
-    }
-    symbols[i] = new_index[symbols[i]];
-  }
-  BROTLI_FREE(m, new_index);
-  for (i = 0; i < next_index; ++i) {
-    out[i] = tmp[i];
-  }
-  BROTLI_FREE(m, tmp);
-  return next_index;
-})
-
-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
-    MemoryManager* m, const HistogramType* in, const size_t in_size,
-    size_t max_histograms, HistogramType* out, size_t* out_size,
-    uint32_t* histogram_symbols) CODE({
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
-  size_t num_clusters = 0;
-  const size_t max_input_histograms = 64;
-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
-  /* For the first pass of clustering, we allow all pairs. */
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
-  /* TODO(eustas): move to "persistent" arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 1);
-  size_t i;
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)|| BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    cluster_size[i] = 1;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    out[i] = in[i];
-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
-    histogram_symbols[i] = (uint32_t)i;
-  }
-
-  for (i = 0; i < in_size; i += max_input_histograms) {
-    size_t num_to_combine =
-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      clusters[num_clusters + j] = (uint32_t)(i + j);
-    }
-    num_new_clusters =
-        FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                   &histogram_symbols[i],
-                                   &clusters[num_clusters], pairs,
-                                   num_to_combine, num_to_combine,
-                                   max_histograms, pairs_capacity);
-    num_clusters += num_new_clusters;
-  }
-
-  {
-    /* For the second pass, we limit the total number of histogram pairs.
-       After this limit is reached, we only keep searching for the best pair. */
-    size_t max_num_pairs = BROTLI_MIN(size_t,
-        64 * num_clusters, (num_clusters / 2) * num_clusters);
-    BROTLI_ENSURE_CAPACITY(
-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m)) return;
-
-    /* Collapse similar histograms. */
-    num_clusters = FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                              histogram_symbols, clusters,
-                                              pairs, num_clusters, in_size,
-                                              max_histograms, max_num_pairs);
-  }
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-  /* Find the optimal map from original histograms to the final ones. */
-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
-                           out, tmp, histogram_symbols);
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  /* Convert the context map to a canonical form. */
-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
-  if (BROTLI_IS_OOM(m)) return;
-})
-
-#undef HistogramType
-#undef FN
-
-#undef CODE
-
-
diff --git a/src/duckdb/third_party/brotli/enc/cluster.h b/src/duckdb/third_party/brotli/enc/cluster.h
deleted file mode 100644
index ffd496678..000000000
--- a/src/duckdb/third_party/brotli/enc/cluster.h
+++ /dev/null
@@ -1,1017 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Functions for clustering similar histograms together. */
-
-#ifndef BROTLI_ENC_CLUSTER_H_
-#define BROTLI_ENC_CLUSTER_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "histogram.h"
-#include "memory.h"
-
-namespace duckdb_brotli {
-
-typedef struct HistogramPair {
-  uint32_t idx1;
-  uint32_t idx2;
-  double cost_combo;
-  double cost_diff;
-} HistogramPair;
-
-#define CODE(X) /* Declaration */;
-
-#define FN(X) X ## Literal
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, CODE */
-
-#define HistogramType FN(Histogram)
-
-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
-    const HistogramType* out, HistogramType* tmp, const uint32_t* cluster_size,
-    uint32_t idx1, uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
-    size_t* num_pairs) CODE({
-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
-  HistogramPair p;
-  p.idx1 = p.idx2 = 0;
-  p.cost_diff = p.cost_combo = 0;
-  if (idx1 == idx2) {
-    return;
-  }
-  if (idx2 < idx1) {
-    uint32_t t = idx2;
-    idx2 = idx1;
-    idx1 = t;
-  }
-  p.idx1 = idx1;
-  p.idx2 = idx2;
-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
-  p.cost_diff -= out[idx1].bit_cost_;
-  p.cost_diff -= out[idx2].bit_cost_;
-
-  if (out[idx1].total_count_ == 0) {
-    p.cost_combo = out[idx2].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else if (out[idx2].total_count_ == 0) {
-    p.cost_combo = out[idx1].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else {
-    double threshold = *num_pairs == 0 ? 1e99 :
-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
-    double cost_combo;
-    *tmp = out[idx1];
-    FN(HistogramAddHistogram)(tmp, &out[idx2]);
-    cost_combo = FN(BrotliPopulationCost)(tmp);
-    if (cost_combo < threshold - p.cost_diff) {
-      p.cost_combo = cost_combo;
-      is_good_pair = BROTLI_TRUE;
-    }
-  }
-  if (is_good_pair) {
-    p.cost_diff += p.cost_combo;
-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
-      /* Replace the top of the queue if needed. */
-      if (*num_pairs < max_num_pairs) {
-        pairs[*num_pairs] = pairs[0];
-        ++(*num_pairs);
-      }
-      pairs[0] = p;
-    } else if (*num_pairs < max_num_pairs) {
-      pairs[*num_pairs] = p;
-      ++(*num_pairs);
-    }
-  }
-})
-
-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
-                                                  HistogramType* tmp,
-                                                  uint32_t* cluster_size,
-                                                  uint32_t* symbols,
-                                                  uint32_t* clusters,
-                                                  HistogramPair* pairs,
-                                                  size_t num_clusters,
-                                                  size_t symbols_size,
-                                                  size_t max_clusters,
-                                                  size_t max_num_pairs) CODE({
-  double cost_diff_threshold = 0.0;
-  size_t min_cluster_size = 1;
-  size_t num_pairs = 0;
-
-  {
-    /* We maintain a vector of histogram pairs, with the property that the pair
-       with the maximum bit cost reduction is the first. */
-    size_t idx1;
-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
-      size_t idx2;
-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
-        FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, clusters[idx1],
-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
-      }
-    }
-  }
-
-  while (num_clusters > min_cluster_size) {
-    uint32_t best_idx1;
-    uint32_t best_idx2;
-    size_t i;
-    if (pairs[0].cost_diff >= cost_diff_threshold) {
-      cost_diff_threshold = 1e99;
-      min_cluster_size = max_clusters;
-      continue;
-    }
-    /* Take the best pair from the top of heap. */
-    best_idx1 = pairs[0].idx1;
-    best_idx2 = pairs[0].idx2;
-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
-    cluster_size[best_idx1] += cluster_size[best_idx2];
-    for (i = 0; i < symbols_size; ++i) {
-      if (symbols[i] == best_idx2) {
-        symbols[i] = best_idx1;
-      }
-    }
-    for (i = 0; i < num_clusters; ++i) {
-      if (clusters[i] == best_idx2) {
-        memmove(&clusters[i], &clusters[i + 1],
-                (num_clusters - i - 1) * sizeof(clusters[0]));
-        break;
-      }
-    }
-    --num_clusters;
-    {
-      /* Remove pairs intersecting the just combined best pair. */
-      size_t copy_to_idx = 0;
-      for (i = 0; i < num_pairs; ++i) {
-        HistogramPair* p = &pairs[i];
-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
-          /* Remove invalid pair from the queue. */
-          continue;
-        }
-        if (HistogramPairIsLess(&pairs[0], p)) {
-          /* Replace the top of the queue if needed. */
-          HistogramPair front = pairs[0];
-          pairs[0] = *p;
-          pairs[copy_to_idx] = front;
-        } else {
-          pairs[copy_to_idx] = *p;
-        }
-        ++copy_to_idx;
-      }
-      num_pairs = copy_to_idx;
-    }
-
-    /* Push new pairs formed with the combined histogram to the heap. */
-    for (i = 0; i < num_clusters; ++i) {
-      FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, best_idx1,
-          clusters[i], max_num_pairs, &pairs[0], &num_pairs);
-    }
-  }
-  return num_clusters;
-})
-
-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
-    const HistogramType* histogram, const HistogramType* candidate,
-    HistogramType* tmp) CODE({
-  if (histogram->total_count_ == 0) {
-    return 0.0;
-  } else {
-    *tmp = *histogram;
-    FN(HistogramAddHistogram)(tmp, candidate);
-    return FN(BrotliPopulationCost)(tmp) - candidate->bit_cost_;
-  }
-})
-
-/* Find the best 'out' histogram for each of the 'in' histograms.
-   When called, clusters[0..num_clusters) contains the unique values from
-   symbols[0..in_size), but this property is not preserved in this function.
-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
-    HistogramType* out, HistogramType* tmp, uint32_t* symbols) CODE({
-  size_t i;
-  for (i = 0; i < in_size; ++i) {
-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
-    double best_bits =
-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out], tmp);
-    size_t j;
-    for (j = 0; j < num_clusters; ++j) {
-      const double cur_bits =
-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]], tmp);
-      if (cur_bits < best_bits) {
-        best_bits = cur_bits;
-        best_out = clusters[j];
-      }
-    }
-    symbols[i] = best_out;
-  }
-
-  /* Recompute each out based on raw and symbols. */
-  for (i = 0; i < num_clusters; ++i) {
-    FN(HistogramClear)(&out[clusters[i]]);
-  }
-  for (i = 0; i < in_size; ++i) {
-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
-  }
-})
-
-/* Reorders elements of the out[0..length) array and changes values in
-   symbols[0..length) array in the following way:
-     * when called, symbols[] contains indexes into out[], and has N unique
-       values (possibly N < length)
-     * on return, symbols'[i] = f(symbols[i]) and
-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
-       where f is a bijection between the range of symbols[] and [0..N), and
-       the first occurrences of values in symbols'[i] come in consecutive
-       increasing order.
-   Returns N, the number of unique values in symbols[]. */
-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
-  uint32_t next_index;
-  HistogramType* tmp;
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
-  for (i = 0; i < length; ++i) {
-      new_index[i] = kInvalidIndex;
-  }
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == kInvalidIndex) {
-      new_index[symbols[i]] = next_index;
-      ++next_index;
-    }
-  }
-  /* TODO(eustas): by using idea of "cycle-sort" we can avoid allocation of
-     tmp and reduce the number of copying by the factor of 2. */
-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == next_index) {
-      tmp[next_index] = out[symbols[i]];
-      ++next_index;
-    }
-    symbols[i] = new_index[symbols[i]];
-  }
-  BROTLI_FREE(m, new_index);
-  for (i = 0; i < next_index; ++i) {
-    out[i] = tmp[i];
-  }
-  BROTLI_FREE(m, tmp);
-  return next_index;
-})
-
-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
-    MemoryManager* m, const HistogramType* in, const size_t in_size,
-    size_t max_histograms, HistogramType* out, size_t* out_size,
-    uint32_t* histogram_symbols) CODE({
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
-  size_t num_clusters = 0;
-  const size_t max_input_histograms = 64;
-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
-  /* For the first pass of clustering, we allow all pairs. */
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
-  /* TODO(eustas): move to "persistent" arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 1);
-  size_t i;
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)|| BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    cluster_size[i] = 1;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    out[i] = in[i];
-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
-    histogram_symbols[i] = (uint32_t)i;
-  }
-
-  for (i = 0; i < in_size; i += max_input_histograms) {
-    size_t num_to_combine =
-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      clusters[num_clusters + j] = (uint32_t)(i + j);
-    }
-    num_new_clusters =
-        FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                   &histogram_symbols[i],
-                                   &clusters[num_clusters], pairs,
-                                   num_to_combine, num_to_combine,
-                                   max_histograms, pairs_capacity);
-    num_clusters += num_new_clusters;
-  }
-
-  {
-    /* For the second pass, we limit the total number of histogram pairs.
-       After this limit is reached, we only keep searching for the best pair. */
-    size_t max_num_pairs = BROTLI_MIN(size_t,
-        64 * num_clusters, (num_clusters / 2) * num_clusters);
-    BROTLI_ENSURE_CAPACITY(
-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m)) return;
-
-    /* Collapse similar histograms. */
-    num_clusters = FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                              histogram_symbols, clusters,
-                                              pairs, num_clusters, in_size,
-                                              max_histograms, max_num_pairs);
-  }
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-  /* Find the optimal map from original histograms to the final ones. */
-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
-                           out, tmp, histogram_symbols);
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  /* Convert the context map to a canonical form. */
-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
-  if (BROTLI_IS_OOM(m)) return;
-})
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Command
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, CODE */
-
-#define HistogramType FN(Histogram)
-
-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
-    const HistogramType* out, HistogramType* tmp, const uint32_t* cluster_size,
-    uint32_t idx1, uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
-    size_t* num_pairs) CODE({
-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
-  HistogramPair p;
-  p.idx1 = p.idx2 = 0;
-  p.cost_diff = p.cost_combo = 0;
-  if (idx1 == idx2) {
-    return;
-  }
-  if (idx2 < idx1) {
-    uint32_t t = idx2;
-    idx2 = idx1;
-    idx1 = t;
-  }
-  p.idx1 = idx1;
-  p.idx2 = idx2;
-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
-  p.cost_diff -= out[idx1].bit_cost_;
-  p.cost_diff -= out[idx2].bit_cost_;
-
-  if (out[idx1].total_count_ == 0) {
-    p.cost_combo = out[idx2].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else if (out[idx2].total_count_ == 0) {
-    p.cost_combo = out[idx1].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else {
-    double threshold = *num_pairs == 0 ? 1e99 :
-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
-    double cost_combo;
-    *tmp = out[idx1];
-    FN(HistogramAddHistogram)(tmp, &out[idx2]);
-    cost_combo = FN(BrotliPopulationCost)(tmp);
-    if (cost_combo < threshold - p.cost_diff) {
-      p.cost_combo = cost_combo;
-      is_good_pair = BROTLI_TRUE;
-    }
-  }
-  if (is_good_pair) {
-    p.cost_diff += p.cost_combo;
-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
-      /* Replace the top of the queue if needed. */
-      if (*num_pairs < max_num_pairs) {
-        pairs[*num_pairs] = pairs[0];
-        ++(*num_pairs);
-      }
-      pairs[0] = p;
-    } else if (*num_pairs < max_num_pairs) {
-      pairs[*num_pairs] = p;
-      ++(*num_pairs);
-    }
-  }
-})
-
-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
-                                                  HistogramType* tmp,
-                                                  uint32_t* cluster_size,
-                                                  uint32_t* symbols,
-                                                  uint32_t* clusters,
-                                                  HistogramPair* pairs,
-                                                  size_t num_clusters,
-                                                  size_t symbols_size,
-                                                  size_t max_clusters,
-                                                  size_t max_num_pairs) CODE({
-  double cost_diff_threshold = 0.0;
-  size_t min_cluster_size = 1;
-  size_t num_pairs = 0;
-
-  {
-    /* We maintain a vector of histogram pairs, with the property that the pair
-       with the maximum bit cost reduction is the first. */
-    size_t idx1;
-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
-      size_t idx2;
-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
-        FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, clusters[idx1],
-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
-      }
-    }
-  }
-
-  while (num_clusters > min_cluster_size) {
-    uint32_t best_idx1;
-    uint32_t best_idx2;
-    size_t i;
-    if (pairs[0].cost_diff >= cost_diff_threshold) {
-      cost_diff_threshold = 1e99;
-      min_cluster_size = max_clusters;
-      continue;
-    }
-    /* Take the best pair from the top of heap. */
-    best_idx1 = pairs[0].idx1;
-    best_idx2 = pairs[0].idx2;
-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
-    cluster_size[best_idx1] += cluster_size[best_idx2];
-    for (i = 0; i < symbols_size; ++i) {
-      if (symbols[i] == best_idx2) {
-        symbols[i] = best_idx1;
-      }
-    }
-    for (i = 0; i < num_clusters; ++i) {
-      if (clusters[i] == best_idx2) {
-        memmove(&clusters[i], &clusters[i + 1],
-                (num_clusters - i - 1) * sizeof(clusters[0]));
-        break;
-      }
-    }
-    --num_clusters;
-    {
-      /* Remove pairs intersecting the just combined best pair. */
-      size_t copy_to_idx = 0;
-      for (i = 0; i < num_pairs; ++i) {
-        HistogramPair* p = &pairs[i];
-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
-          /* Remove invalid pair from the queue. */
-          continue;
-        }
-        if (HistogramPairIsLess(&pairs[0], p)) {
-          /* Replace the top of the queue if needed. */
-          HistogramPair front = pairs[0];
-          pairs[0] = *p;
-          pairs[copy_to_idx] = front;
-        } else {
-          pairs[copy_to_idx] = *p;
-        }
-        ++copy_to_idx;
-      }
-      num_pairs = copy_to_idx;
-    }
-
-    /* Push new pairs formed with the combined histogram to the heap. */
-    for (i = 0; i < num_clusters; ++i) {
-      FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, best_idx1,
-          clusters[i], max_num_pairs, &pairs[0], &num_pairs);
-    }
-  }
-  return num_clusters;
-})
-
-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
-    const HistogramType* histogram, const HistogramType* candidate,
-    HistogramType* tmp) CODE({
-  if (histogram->total_count_ == 0) {
-    return 0.0;
-  } else {
-    *tmp = *histogram;
-    FN(HistogramAddHistogram)(tmp, candidate);
-    return FN(BrotliPopulationCost)(tmp) - candidate->bit_cost_;
-  }
-})
-
-/* Find the best 'out' histogram for each of the 'in' histograms.
-   When called, clusters[0..num_clusters) contains the unique values from
-   symbols[0..in_size), but this property is not preserved in this function.
-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
-    HistogramType* out, HistogramType* tmp, uint32_t* symbols) CODE({
-  size_t i;
-  for (i = 0; i < in_size; ++i) {
-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
-    double best_bits =
-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out], tmp);
-    size_t j;
-    for (j = 0; j < num_clusters; ++j) {
-      const double cur_bits =
-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]], tmp);
-      if (cur_bits < best_bits) {
-        best_bits = cur_bits;
-        best_out = clusters[j];
-      }
-    }
-    symbols[i] = best_out;
-  }
-
-  /* Recompute each out based on raw and symbols. */
-  for (i = 0; i < num_clusters; ++i) {
-    FN(HistogramClear)(&out[clusters[i]]);
-  }
-  for (i = 0; i < in_size; ++i) {
-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
-  }
-})
-
-/* Reorders elements of the out[0..length) array and changes values in
-   symbols[0..length) array in the following way:
-     * when called, symbols[] contains indexes into out[], and has N unique
-       values (possibly N < length)
-     * on return, symbols'[i] = f(symbols[i]) and
-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
-       where f is a bijection between the range of symbols[] and [0..N), and
-       the first occurrences of values in symbols'[i] come in consecutive
-       increasing order.
-   Returns N, the number of unique values in symbols[]. */
-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
-  uint32_t next_index;
-  HistogramType* tmp;
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
-  for (i = 0; i < length; ++i) {
-      new_index[i] = kInvalidIndex;
-  }
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == kInvalidIndex) {
-      new_index[symbols[i]] = next_index;
-      ++next_index;
-    }
-  }
-  /* TODO(eustas): by using idea of "cycle-sort" we can avoid allocation of
-     tmp and reduce the number of copying by the factor of 2. */
-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == next_index) {
-      tmp[next_index] = out[symbols[i]];
-      ++next_index;
-    }
-    symbols[i] = new_index[symbols[i]];
-  }
-  BROTLI_FREE(m, new_index);
-  for (i = 0; i < next_index; ++i) {
-    out[i] = tmp[i];
-  }
-  BROTLI_FREE(m, tmp);
-  return next_index;
-})
-
-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
-    MemoryManager* m, const HistogramType* in, const size_t in_size,
-    size_t max_histograms, HistogramType* out, size_t* out_size,
-    uint32_t* histogram_symbols) CODE({
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
-  size_t num_clusters = 0;
-  const size_t max_input_histograms = 64;
-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
-  /* For the first pass of clustering, we allow all pairs. */
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
-  /* TODO(eustas): move to "persistent" arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 1);
-  size_t i;
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)|| BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    cluster_size[i] = 1;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    out[i] = in[i];
-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
-    histogram_symbols[i] = (uint32_t)i;
-  }
-
-  for (i = 0; i < in_size; i += max_input_histograms) {
-    size_t num_to_combine =
-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      clusters[num_clusters + j] = (uint32_t)(i + j);
-    }
-    num_new_clusters =
-        FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                   &histogram_symbols[i],
-                                   &clusters[num_clusters], pairs,
-                                   num_to_combine, num_to_combine,
-                                   max_histograms, pairs_capacity);
-    num_clusters += num_new_clusters;
-  }
-
-  {
-    /* For the second pass, we limit the total number of histogram pairs.
-       After this limit is reached, we only keep searching for the best pair. */
-    size_t max_num_pairs = BROTLI_MIN(size_t,
-        64 * num_clusters, (num_clusters / 2) * num_clusters);
-    BROTLI_ENSURE_CAPACITY(
-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m)) return;
-
-    /* Collapse similar histograms. */
-    num_clusters = FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                              histogram_symbols, clusters,
-                                              pairs, num_clusters, in_size,
-                                              max_histograms, max_num_pairs);
-  }
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-  /* Find the optimal map from original histograms to the final ones. */
-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
-                           out, tmp, histogram_symbols);
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  /* Convert the context map to a canonical form. */
-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
-  if (BROTLI_IS_OOM(m)) return;
-})
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Distance
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN, CODE */
-
-#define HistogramType FN(Histogram)
-
-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
-    const HistogramType* out, HistogramType* tmp, const uint32_t* cluster_size,
-    uint32_t idx1, uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
-    size_t* num_pairs) CODE({
-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
-  HistogramPair p;
-  p.idx1 = p.idx2 = 0;
-  p.cost_diff = p.cost_combo = 0;
-  if (idx1 == idx2) {
-    return;
-  }
-  if (idx2 < idx1) {
-    uint32_t t = idx2;
-    idx2 = idx1;
-    idx1 = t;
-  }
-  p.idx1 = idx1;
-  p.idx2 = idx2;
-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
-  p.cost_diff -= out[idx1].bit_cost_;
-  p.cost_diff -= out[idx2].bit_cost_;
-
-  if (out[idx1].total_count_ == 0) {
-    p.cost_combo = out[idx2].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else if (out[idx2].total_count_ == 0) {
-    p.cost_combo = out[idx1].bit_cost_;
-    is_good_pair = BROTLI_TRUE;
-  } else {
-    double threshold = *num_pairs == 0 ? 1e99 :
-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
-    double cost_combo;
-    *tmp = out[idx1];
-    FN(HistogramAddHistogram)(tmp, &out[idx2]);
-    cost_combo = FN(BrotliPopulationCost)(tmp);
-    if (cost_combo < threshold - p.cost_diff) {
-      p.cost_combo = cost_combo;
-      is_good_pair = BROTLI_TRUE;
-    }
-  }
-  if (is_good_pair) {
-    p.cost_diff += p.cost_combo;
-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
-      /* Replace the top of the queue if needed. */
-      if (*num_pairs < max_num_pairs) {
-        pairs[*num_pairs] = pairs[0];
-        ++(*num_pairs);
-      }
-      pairs[0] = p;
-    } else if (*num_pairs < max_num_pairs) {
-      pairs[*num_pairs] = p;
-      ++(*num_pairs);
-    }
-  }
-})
-
-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
-                                                  HistogramType* tmp,
-                                                  uint32_t* cluster_size,
-                                                  uint32_t* symbols,
-                                                  uint32_t* clusters,
-                                                  HistogramPair* pairs,
-                                                  size_t num_clusters,
-                                                  size_t symbols_size,
-                                                  size_t max_clusters,
-                                                  size_t max_num_pairs) CODE({
-  double cost_diff_threshold = 0.0;
-  size_t min_cluster_size = 1;
-  size_t num_pairs = 0;
-
-  {
-    /* We maintain a vector of histogram pairs, with the property that the pair
-       with the maximum bit cost reduction is the first. */
-    size_t idx1;
-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
-      size_t idx2;
-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
-        FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, clusters[idx1],
-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
-      }
-    }
-  }
-
-  while (num_clusters > min_cluster_size) {
-    uint32_t best_idx1;
-    uint32_t best_idx2;
-    size_t i;
-    if (pairs[0].cost_diff >= cost_diff_threshold) {
-      cost_diff_threshold = 1e99;
-      min_cluster_size = max_clusters;
-      continue;
-    }
-    /* Take the best pair from the top of heap. */
-    best_idx1 = pairs[0].idx1;
-    best_idx2 = pairs[0].idx2;
-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
-    cluster_size[best_idx1] += cluster_size[best_idx2];
-    for (i = 0; i < symbols_size; ++i) {
-      if (symbols[i] == best_idx2) {
-        symbols[i] = best_idx1;
-      }
-    }
-    for (i = 0; i < num_clusters; ++i) {
-      if (clusters[i] == best_idx2) {
-        memmove(&clusters[i], &clusters[i + 1],
-                (num_clusters - i - 1) * sizeof(clusters[0]));
-        break;
-      }
-    }
-    --num_clusters;
-    {
-      /* Remove pairs intersecting the just combined best pair. */
-      size_t copy_to_idx = 0;
-      for (i = 0; i < num_pairs; ++i) {
-        HistogramPair* p = &pairs[i];
-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
-          /* Remove invalid pair from the queue. */
-          continue;
-        }
-        if (HistogramPairIsLess(&pairs[0], p)) {
-          /* Replace the top of the queue if needed. */
-          HistogramPair front = pairs[0];
-          pairs[0] = *p;
-          pairs[copy_to_idx] = front;
-        } else {
-          pairs[copy_to_idx] = *p;
-        }
-        ++copy_to_idx;
-      }
-      num_pairs = copy_to_idx;
-    }
-
-    /* Push new pairs formed with the combined histogram to the heap. */
-    for (i = 0; i < num_clusters; ++i) {
-      FN(BrotliCompareAndPushToQueue)(out, tmp, cluster_size, best_idx1,
-          clusters[i], max_num_pairs, &pairs[0], &num_pairs);
-    }
-  }
-  return num_clusters;
-})
-
-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
-    const HistogramType* histogram, const HistogramType* candidate,
-    HistogramType* tmp) CODE({
-  if (histogram->total_count_ == 0) {
-    return 0.0;
-  } else {
-    *tmp = *histogram;
-    FN(HistogramAddHistogram)(tmp, candidate);
-    return FN(BrotliPopulationCost)(tmp) - candidate->bit_cost_;
-  }
-})
-
-/* Find the best 'out' histogram for each of the 'in' histograms.
-   When called, clusters[0..num_clusters) contains the unique values from
-   symbols[0..in_size), but this property is not preserved in this function.
-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
-    HistogramType* out, HistogramType* tmp, uint32_t* symbols) CODE({
-  size_t i;
-  for (i = 0; i < in_size; ++i) {
-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
-    double best_bits =
-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out], tmp);
-    size_t j;
-    for (j = 0; j < num_clusters; ++j) {
-      const double cur_bits =
-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]], tmp);
-      if (cur_bits < best_bits) {
-        best_bits = cur_bits;
-        best_out = clusters[j];
-      }
-    }
-    symbols[i] = best_out;
-  }
-
-  /* Recompute each out based on raw and symbols. */
-  for (i = 0; i < num_clusters; ++i) {
-    FN(HistogramClear)(&out[clusters[i]]);
-  }
-  for (i = 0; i < in_size; ++i) {
-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
-  }
-})
-
-/* Reorders elements of the out[0..length) array and changes values in
-   symbols[0..length) array in the following way:
-     * when called, symbols[] contains indexes into out[], and has N unique
-       values (possibly N < length)
-     * on return, symbols'[i] = f(symbols[i]) and
-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
-       where f is a bijection between the range of symbols[] and [0..N), and
-       the first occurrences of values in symbols'[i] come in consecutive
-       increasing order.
-   Returns N, the number of unique values in symbols[]. */
-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
-  uint32_t next_index;
-  HistogramType* tmp;
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
-  for (i = 0; i < length; ++i) {
-      new_index[i] = kInvalidIndex;
-  }
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == kInvalidIndex) {
-      new_index[symbols[i]] = next_index;
-      ++next_index;
-    }
-  }
-  /* TODO(eustas): by using idea of "cycle-sort" we can avoid allocation of
-     tmp and reduce the number of copying by the factor of 2. */
-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
-  next_index = 0;
-  for (i = 0; i < length; ++i) {
-    if (new_index[symbols[i]] == next_index) {
-      tmp[next_index] = out[symbols[i]];
-      ++next_index;
-    }
-    symbols[i] = new_index[symbols[i]];
-  }
-  BROTLI_FREE(m, new_index);
-  for (i = 0; i < next_index; ++i) {
-    out[i] = tmp[i];
-  }
-  BROTLI_FREE(m, tmp);
-  return next_index;
-})
-
-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
-    MemoryManager* m, const HistogramType* in, const size_t in_size,
-    size_t max_histograms, HistogramType* out, size_t* out_size,
-    uint32_t* histogram_symbols) CODE({
-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
-  size_t num_clusters = 0;
-  const size_t max_input_histograms = 64;
-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
-  /* For the first pass of clustering, we allow all pairs. */
-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
-  /* TODO(eustas): move to "persistent" arena? */
-  HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 1);
-  size_t i;
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)|| BROTLI_IS_NULL(tmp)) {
-    return;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    cluster_size[i] = 1;
-  }
-
-  for (i = 0; i < in_size; ++i) {
-    out[i] = in[i];
-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
-    histogram_symbols[i] = (uint32_t)i;
-  }
-
-  for (i = 0; i < in_size; i += max_input_histograms) {
-    size_t num_to_combine =
-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
-    size_t num_new_clusters;
-    size_t j;
-    for (j = 0; j < num_to_combine; ++j) {
-      clusters[num_clusters + j] = (uint32_t)(i + j);
-    }
-    num_new_clusters =
-        FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                   &histogram_symbols[i],
-                                   &clusters[num_clusters], pairs,
-                                   num_to_combine, num_to_combine,
-                                   max_histograms, pairs_capacity);
-    num_clusters += num_new_clusters;
-  }
-
-  {
-    /* For the second pass, we limit the total number of histogram pairs.
-       After this limit is reached, we only keep searching for the best pair. */
-    size_t max_num_pairs = BROTLI_MIN(size_t,
-        64 * num_clusters, (num_clusters / 2) * num_clusters);
-    BROTLI_ENSURE_CAPACITY(
-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
-    if (BROTLI_IS_OOM(m)) return;
-
-    /* Collapse similar histograms. */
-    num_clusters = FN(BrotliHistogramCombine)(out, tmp, cluster_size,
-                                              histogram_symbols, clusters,
-                                              pairs, num_clusters, in_size,
-                                              max_histograms, max_num_pairs);
-  }
-  BROTLI_FREE(m, pairs);
-  BROTLI_FREE(m, cluster_size);
-  /* Find the optimal map from original histograms to the final ones. */
-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
-                           out, tmp, histogram_symbols);
-  BROTLI_FREE(m, tmp);
-  BROTLI_FREE(m, clusters);
-  /* Convert the context map to a canonical form. */
-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
-  if (BROTLI_IS_OOM(m)) return;
-})
-
-#undef HistogramType
-#undef FN
-
-#undef CODE
-
-}
-
-#endif  /* BROTLI_ENC_CLUSTER_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/command.cpp b/src/duckdb/third_party/brotli/enc/command.cpp
deleted file mode 100644
index 9aed7778b..000000000
--- a/src/duckdb/third_party/brotli/enc/command.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "command.h"
-
-#include <brotli/types.h>
-
-using namespace duckdb_brotli;
-
-const uint32_t duckdb_brotli::kBrotliInsBase[BROTLI_NUM_INS_COPY_CODES] = {
-    0,  1,  2,  3,  4,   5,   6,   8,   10,   14,   18,   26,
-    34, 50, 66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594};
-const uint32_t duckdb_brotli::kBrotliInsExtra[BROTLI_NUM_INS_COPY_CODES] = {
-    0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 12, 14, 24};
-const uint32_t duckdb_brotli::kBrotliCopyBase[BROTLI_NUM_INS_COPY_CODES] = {
-    2,  3,  4,  5,  6,  7,   8,   9,   10,  12,  14,   18,
-    22, 30, 38, 54, 70, 102, 134, 198, 326, 582, 1094, 2118};
-const uint32_t duckdb_brotli::kBrotliCopyExtra[BROTLI_NUM_INS_COPY_CODES] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 24};
-
-
diff --git a/src/duckdb/third_party/brotli/enc/command.h b/src/duckdb/third_party/brotli/enc/command.h
deleted file mode 100644
index 443f39423..000000000
--- a/src/duckdb/third_party/brotli/enc/command.h
+++ /dev/null
@@ -1,187 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* This class models a sequence of literals and a backward reference copy. */
-
-#ifndef BROTLI_ENC_COMMAND_H_
-#define BROTLI_ENC_COMMAND_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "fast_log.h"
-#include "brotli_params.h"
-#include "prefix.h"
-
-namespace duckdb_brotli {
-
-BROTLI_INTERNAL extern const uint32_t
-    kBrotliInsBase[BROTLI_NUM_INS_COPY_CODES];
-BROTLI_INTERNAL extern const uint32_t
-    kBrotliInsExtra[BROTLI_NUM_INS_COPY_CODES];
-BROTLI_INTERNAL extern const uint32_t
-    kBrotliCopyBase[BROTLI_NUM_INS_COPY_CODES];
-BROTLI_INTERNAL extern const uint32_t
-    kBrotliCopyExtra[BROTLI_NUM_INS_COPY_CODES];
-
-static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
-  if (insertlen < 6) {
-    return (uint16_t)insertlen;
-  } else if (insertlen < 130) {
-    uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
-    return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
-  } else if (insertlen < 2114) {
-    return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
-  } else if (insertlen < 6210) {
-    return 21u;
-  } else if (insertlen < 22594) {
-    return 22u;
-  } else {
-    return 23u;
-  }
-}
-
-static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
-  if (copylen < 10) {
-    return (uint16_t)(copylen - 2);
-  } else if (copylen < 134) {
-    uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
-    return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
-  } else if (copylen < 2118) {
-    return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
-  } else {
-    return 23u;
-  }
-}
-
-static BROTLI_INLINE uint16_t CombineLengthCodes(
-    uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
-  uint16_t bits64 =
-      (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3u));
-  if (use_last_distance && inscode < 8u && copycode < 16u) {
-    return (copycode < 8u) ? bits64 : (bits64 | 64u);
-  } else {
-    /* Specification: 5 Encoding of ... (last table) */
-    /* offset = 2 * index, where index is in range [0..8] */
-    uint32_t offset = 2u * ((copycode >> 3u) + 3u * (inscode >> 3u));
-    /* All values in specification are K * 64,
-       where   K = [2, 3, 6, 4, 5, 8, 7, 9, 10],
-           i + 1 = [1, 2, 3, 4, 5, 6, 7, 8,  9],
-       K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1,  2] = D.
-       All values in D require only 2 bits to encode.
-       Magic constant is shifted 6 bits left, to avoid final multiplication. */
-    offset = (offset << 5u) + 0x40u + ((0x520D40u >> offset) & 0xC0u);
-    return (uint16_t)(offset | bits64);
-  }
-}
-
-static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
-                                        BROTLI_BOOL use_last_distance,
-                                        uint16_t* code) {
-  uint16_t inscode = GetInsertLengthCode(insertlen);
-  uint16_t copycode = GetCopyLengthCode(copylen);
-  *code = CombineLengthCodes(inscode, copycode, use_last_distance);
-}
-
-static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
-  return kBrotliInsBase[inscode];
-}
-
-static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
-  return kBrotliInsExtra[inscode];
-}
-
-static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
-  return kBrotliCopyBase[copycode];
-}
-
-static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
-  return kBrotliCopyExtra[copycode];
-}
-
-typedef struct Command {
-  uint32_t insert_len_;
-  /* Stores copy_len in low 25 bits and copy_code - copy_len in high 7 bit. */
-  uint32_t copy_len_;
-  /* Stores distance extra bits. */
-  uint32_t dist_extra_;
-  uint16_t cmd_prefix_;
-  /* Stores distance code in low 10 bits
-     and number of extra bits in high 6 bits. */
-  uint16_t dist_prefix_;
-} Command;
-
-/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
-static BROTLI_INLINE void InitCommand(Command* self,
-    const BrotliDistanceParams* dist, size_t insertlen,
-    size_t copylen, int copylen_code_delta, size_t distance_code) {
-  /* Don't rely on signed int representation, use honest casts. */
-  uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
-  self->insert_len_ = (uint32_t)insertlen;
-  self->copy_len_ = (uint32_t)(copylen | (delta << 25));
-  /* The distance prefix and extra bits are stored in this Command as if
-     npostfix and ndirect were 0, they are only recomputed later after the
-     clustering if needed. */
-  PrefixEncodeCopyDistance(
-      distance_code, dist->num_direct_distance_codes,
-      dist->distance_postfix_bits, &self->dist_prefix_, &self->dist_extra_);
-  GetLengthCode(
-      insertlen, (size_t)((int)copylen + copylen_code_delta),
-      TO_BROTLI_BOOL((self->dist_prefix_ & 0x3FF) == 0), &self->cmd_prefix_);
-}
-
-static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
-  self->insert_len_ = (uint32_t)insertlen;
-  self->copy_len_ = 4 << 25;
-  self->dist_extra_ = 0;
-  self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
-  GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
-}
-
-static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(
-    const Command* self, const BrotliDistanceParams* dist) {
-  if ((self->dist_prefix_ & 0x3FFu) <
-      BROTLI_NUM_DISTANCE_SHORT_CODES + dist->num_direct_distance_codes) {
-    return self->dist_prefix_ & 0x3FFu;
-  } else {
-    uint32_t dcode = self->dist_prefix_ & 0x3FFu;
-    uint32_t nbits = self->dist_prefix_ >> 10;
-    uint32_t extra = self->dist_extra_;
-    uint32_t postfix_mask = (1U << dist->distance_postfix_bits) - 1U;
-    uint32_t hcode = (dcode - dist->num_direct_distance_codes -
-        BROTLI_NUM_DISTANCE_SHORT_CODES) >>
-        dist->distance_postfix_bits;
-    uint32_t lcode = (dcode - dist->num_direct_distance_codes -
-        BROTLI_NUM_DISTANCE_SHORT_CODES) & postfix_mask;
-    uint32_t offset = ((2U + (hcode & 1U)) << nbits) - 4U;
-    return ((offset + extra) << dist->distance_postfix_bits) + lcode +
-        dist->num_direct_distance_codes + BROTLI_NUM_DISTANCE_SHORT_CODES;
-  }
-}
-
-static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
-  uint32_t r = self->cmd_prefix_ >> 6;
-  uint32_t c = self->cmd_prefix_ & 7;
-  if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
-    return c;
-  }
-  return 3;
-}
-
-static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
-  return self->copy_len_ & 0x1FFFFFF;
-}
-
-static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
-  uint32_t modifier = self->copy_len_ >> 25;
-  int32_t delta = (int8_t)((uint8_t)(modifier | ((modifier & 0x40) << 1)));
-  return (uint32_t)((int32_t)(self->copy_len_ & 0x1FFFFFF) + delta);
-}
-
-}
-
-#endif  /* BROTLI_ENC_COMMAND_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/compound_dictionary.cpp b/src/duckdb/third_party/brotli/enc/compound_dictionary.cpp
deleted file mode 100644
index 9a602b745..000000000
--- a/src/duckdb/third_party/brotli/enc/compound_dictionary.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "compound_dictionary.h"
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "memory.h"
-#include "quality.h"
-
-using namespace duckdb_brotli;
-
-static PreparedDictionary* CreatePreparedDictionaryWithParams(MemoryManager* m,
-    const uint8_t* source, size_t source_size, uint32_t bucket_bits,
-    uint32_t slot_bits, uint32_t hash_bits, uint16_t bucket_limit) {
-  /* Step 1: create "bloated" hasher. */
-  uint32_t num_slots = 1u << slot_bits;
-  uint32_t num_buckets = 1u << bucket_bits;
-  uint32_t hash_shift = 64u - bucket_bits;
-  uint64_t hash_mask = (~((uint64_t)0U)) >> (64 - hash_bits);
-  uint32_t slot_mask = num_slots - 1;
-  size_t alloc_size = (sizeof(uint32_t) << slot_bits) +
-      (sizeof(uint32_t) << slot_bits) +
-      (sizeof(uint16_t) << bucket_bits) +
-      (sizeof(uint32_t) << bucket_bits) +
-      (sizeof(uint32_t) * source_size);
-  uint8_t* flat = NULL;
-  PreparedDictionary* result = NULL;
-  uint16_t* num = NULL;
-  uint32_t* bucket_heads = NULL;
-  uint32_t* next_bucket = NULL;
-  uint32_t* slot_offsets = NULL;
-  uint16_t* heads = NULL;
-  uint32_t* items = NULL;
-  uint8_t** source_ref = NULL;
-  uint32_t i;
-  uint32_t* slot_size = NULL;
-  uint32_t* slot_limit = NULL;
-  uint32_t total_items = 0;
-  if (slot_bits > 16) return NULL;
-  if (slot_bits > bucket_bits) return NULL;
-  if (bucket_bits - slot_bits >= 16) return NULL;
-
-  flat = BROTLI_ALLOC(m, uint8_t, alloc_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(flat)) return NULL;
-
-  slot_size = (uint32_t*)flat;
-  slot_limit = (uint32_t*)(&slot_size[num_slots]);
-  num = (uint16_t*)(&slot_limit[num_slots]);
-  bucket_heads = (uint32_t*)(&num[num_buckets]);
-  next_bucket = (uint32_t*)(&bucket_heads[num_buckets]);
-  memset(num, 0, num_buckets * sizeof(num[0]));
-
-  /* TODO(eustas): apply custom "store" order. */
-  for (i = 0; i + 7 < source_size; ++i) {
-    const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(&source[i]) & hash_mask) *
-        kPreparedDictionaryHashMul64Long;
-    const uint32_t key = (uint32_t)(h >> hash_shift);
-    uint16_t count = num[key];
-    next_bucket[i] = (count == 0) ? ((uint32_t)(-1)) : bucket_heads[key];
-    bucket_heads[key] = i;
-    count++;
-    if (count > bucket_limit) count = bucket_limit;
-    num[key] = count;
-  }
-
-  /* Step 2: find slot limits. */
-  for (i = 0; i < num_slots; ++i) {
-    BROTLI_BOOL overflow = BROTLI_FALSE;
-    slot_limit[i] = bucket_limit;
-    while (BROTLI_TRUE) {
-      uint32_t limit = slot_limit[i];
-      size_t j;
-      uint32_t count = 0;
-      overflow = BROTLI_FALSE;
-      for (j = i; j < num_buckets; j += num_slots) {
-        uint32_t size = num[j];
-        /* Last chain may span behind 64K limit; overflow happens only if
-           we are about to use 0xFFFF+ as item offset. */
-        if (count >= 0xFFFF) {
-          overflow = BROTLI_TRUE;
-          break;
-        }
-        if (size > limit) size = limit;
-        count += size;
-      }
-      if (!overflow) {
-        slot_size[i] = count;
-        total_items += count;
-        break;
-      }
-      slot_limit[i]--;
-    }
-  }
-
-  /* Step 3: transfer data to "slim" hasher. */
-  alloc_size = sizeof(PreparedDictionary) + (sizeof(uint32_t) << slot_bits) +
-      (sizeof(uint16_t) << bucket_bits) + (sizeof(uint32_t) * total_items) +
-      sizeof(uint8_t*);
-
-  result = (PreparedDictionary*)BROTLI_ALLOC(m, uint8_t, alloc_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(result)) {
-    BROTLI_FREE(m, flat);
-    return NULL;
-  }
-  slot_offsets = (uint32_t*)(&result[1]);
-  heads = (uint16_t*)(&slot_offsets[num_slots]);
-  items = (uint32_t*)(&heads[num_buckets]);
-  source_ref = (uint8_t**)(&items[total_items]);
-
-  result->magic = kLeanPreparedDictionaryMagic;
-  result->num_items = total_items;
-  result->source_size = (uint32_t)source_size;
-  result->hash_bits = hash_bits;
-  result->bucket_bits = bucket_bits;
-  result->slot_bits = slot_bits;
-  BROTLI_UNALIGNED_STORE_PTR(source_ref, source);
-
-  total_items = 0;
-  for (i = 0; i < num_slots; ++i) {
-    slot_offsets[i] = total_items;
-    total_items += slot_size[i];
-    slot_size[i] = 0;
-  }
-  for (i = 0; i < num_buckets; ++i) {
-    uint32_t slot = i & slot_mask;
-    uint32_t count = num[i];
-    uint32_t pos;
-    size_t j;
-    size_t cursor = slot_size[slot];
-    if (count > slot_limit[slot]) count = slot_limit[slot];
-    if (count == 0) {
-      heads[i] = 0xFFFF;
-      continue;
-    }
-    heads[i] = (uint16_t)cursor;
-    cursor += slot_offsets[slot];
-    slot_size[slot] += count;
-    pos = bucket_heads[i];
-    for (j = 0; j < count; j++) {
-      items[cursor++] = pos;
-      pos = next_bucket[pos];
-    }
-    items[cursor - 1] |= 0x80000000;
-  }
-
-  BROTLI_FREE(m, flat);
-  return result;
-}
-
-PreparedDictionary* duckdb_brotli::CreatePreparedDictionary(MemoryManager* m,
-    const uint8_t* source, size_t source_size) {
-  uint32_t bucket_bits = 17;
-  uint32_t slot_bits = 7;
-  uint32_t hash_bits = 40;
-  uint16_t bucket_limit = 32;
-  size_t volume = 16u << bucket_bits;
-  /* Tune parameters to fit dictionary size. */
-  while (volume < source_size && bucket_bits < 22) {
-    bucket_bits++;
-    slot_bits++;
-    volume <<= 1;
-  }
-  return CreatePreparedDictionaryWithParams(m,
-      source, source_size, bucket_bits, slot_bits, hash_bits, bucket_limit);
-}
-
-void duckdb_brotli::DestroyPreparedDictionary(MemoryManager* m,
-    PreparedDictionary* dictionary) {
-  if (!dictionary) return;
-  BROTLI_FREE(m, dictionary);
-}
-
-BROTLI_BOOL duckdb_brotli::AttachPreparedDictionary(
-    CompoundDictionary* compound, const PreparedDictionary* dictionary) {
-  size_t length = 0;
-  size_t index = 0;
-
-  if (compound->num_chunks == SHARED_BROTLI_MAX_COMPOUND_DICTS) {
-    return BROTLI_FALSE;
-  }
-
-  if (!dictionary) return BROTLI_FALSE;
-
-  length = dictionary->source_size;
-  index = compound->num_chunks;
-  compound->total_size += length;
-  compound->chunks[index] = dictionary;
-  compound->chunk_offsets[index + 1] = compound->total_size;
-  {
-    uint32_t* slot_offsets = (uint32_t*)(&dictionary[1]);
-    uint16_t* heads = (uint16_t*)(&slot_offsets[1u << dictionary->slot_bits]);
-    uint32_t* items = (uint32_t*)(&heads[1u << dictionary->bucket_bits]);
-    const void* tail = (void*)&items[dictionary->num_items];
-    if (dictionary->magic == kPreparedDictionaryMagic) {
-      compound->chunk_source[index] = (const uint8_t*)tail;
-    } else {
-      /* dictionary->magic == kLeanPreparedDictionaryMagic */
-      compound->chunk_source[index] =
-          (const uint8_t*)BROTLI_UNALIGNED_LOAD_PTR((const uint8_t**)tail);
-    }
-  }
-  compound->num_chunks++;
-  return BROTLI_TRUE;
-}
diff --git a/src/duckdb/third_party/brotli/enc/compound_dictionary.h b/src/duckdb/third_party/brotli/enc/compound_dictionary.h
deleted file mode 100644
index 78cd5bfcc..000000000
--- a/src/duckdb/third_party/brotli/enc/compound_dictionary.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#ifndef BROTLI_ENC_PREPARED_DICTIONARY_H_
-#define BROTLI_ENC_PREPARED_DICTIONARY_H_
-
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "../common/brotli_constants.h"
-#include "memory.h"
-
-namespace duckdb_brotli {
-
-/* "Fat" prepared dictionary, could be cooked outside of C implementation,
- * e.g. on Java side. LZ77 data is copied inside PreparedDictionary struct. */
-static const uint32_t kPreparedDictionaryMagic = 0xDEBCEDE0;
-
-static const uint32_t kSharedDictionaryMagic = 0xDEBCEDE1;
-
-static const uint32_t kManagedDictionaryMagic = 0xDEBCEDE2;
-
-/* "Lean" prepared dictionary. LZ77 data is referenced. It is the responsibility
- * of caller of "prepare dictionary" to keep the LZ77 data while prepared
- * dictionary is in use. */
-static const uint32_t kLeanPreparedDictionaryMagic = 0xDEBCEDE3;
-
-static const uint64_t kPreparedDictionaryHashMul64Long = BROTLI_MAKE_UINT64_T(0x1FE35A7Bu, 0xD3579BD3u);
-
-typedef struct PreparedDictionary {
-	uint32_t magic;
-	uint32_t num_items;
-	uint32_t source_size;
-	uint32_t hash_bits;
-	uint32_t bucket_bits;
-	uint32_t slot_bits;
-
-	/* --- Dynamic size members --- */
-
-	/* uint32_t slot_offsets[1 << slot_bits]; */
-	/* uint16_t heads[1 << bucket_bits]; */
-	/* uint32_t items[variable]; */
-
-	/* [maybe] uint8_t* source_ref, depending on magic. */
-	/* [maybe] uint8_t source[source_size], depending on magic. */
-} PreparedDictionary;
-
-BROTLI_INTERNAL PreparedDictionary *CreatePreparedDictionary(duckdb_brotli::MemoryManager *m, const uint8_t *source,
-                                                             size_t source_size);
-
-BROTLI_INTERNAL void DestroyPreparedDictionary(duckdb_brotli::MemoryManager *m, PreparedDictionary *dictionary);
-
-typedef struct CompoundDictionary {
-	/* LZ77 prefix, compound dictionary */
-	size_t num_chunks;
-	size_t total_size;
-	/* Client instances. */
-	const PreparedDictionary *chunks[SHARED_BROTLI_MAX_COMPOUND_DICTS + 1];
-	const uint8_t *chunk_source[SHARED_BROTLI_MAX_COMPOUND_DICTS + 1];
-	size_t chunk_offsets[SHARED_BROTLI_MAX_COMPOUND_DICTS + 1];
-
-	size_t num_prepared_instances_;
-	/* Owned instances. */
-	PreparedDictionary *prepared_instances_[SHARED_BROTLI_MAX_COMPOUND_DICTS + 1];
-} CompoundDictionary;
-
-BROTLI_INTERNAL BROTLI_BOOL AttachPreparedDictionary(CompoundDictionary *compound,
-                                                     const PreparedDictionary *dictionary);
-
-}
-#endif /* BROTLI_ENC_PREPARED_DICTIONARY */
diff --git a/src/duckdb/third_party/brotli/enc/compress_fragment.cpp b/src/duckdb/third_party/brotli/enc/compress_fragment.cpp
deleted file mode 100644
index 0a323e355..000000000
--- a/src/duckdb/third_party/brotli/enc/compress_fragment.cpp
+++ /dev/null
@@ -1,796 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function for fast encoding of an input fragment, independently from the input
-   history. This function uses one-pass processing: when we find a backward
-   match, we immediately emit the corresponding command and literal codes to
-   the bit stream.
-
-   Adapted from the CompressFragment() function in
-   https://github.com/google/snappy/blob/master/snappy.cc */
-
-#include "compress_fragment.h"
-
-#include <string.h>  /* memcmp, memcpy, memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "brotli_bit_stream.h"
-#include "entropy_encode.h"
-#include "fast_log.h"
-#include "find_match_length.h"
-#include "write_bits.h"
-
-using namespace duckdb_brotli;
-
-#define MAX_DISTANCE (long)BROTLI_MAX_BACKWARD_LIMIT(18)
-
-/* kHashMul32 multiplier has these properties:
-   * The multiplier must be odd. Otherwise we may lose the highest bit.
-   * No long streaks of ones or zeros.
-   * There is no effort to ensure that it is a prime, the oddity is enough
-     for this use.
-   * The number has been tuned heuristically against compression benchmarks. */
-static const uint32_t kHashMul32 = 0x1E35A7BD;
-
-static BROTLI_INLINE uint32_t Hash(const uint8_t* p, size_t shift) {
-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(p) << 24) * kHashMul32;
-  return (uint32_t)(h >> shift);
-}
-
-static BROTLI_INLINE uint32_t HashBytesAtOffset(
-    uint64_t v, int offset, size_t shift) {
-  BROTLI_DCHECK(offset >= 0);
-  BROTLI_DCHECK(offset <= 3);
-  {
-    const uint64_t h = ((v >> (8 * offset)) << 24) * kHashMul32;
-    return (uint32_t)(h >> shift);
-  }
-}
-
-static BROTLI_INLINE BROTLI_BOOL IsMatch(const uint8_t* p1, const uint8_t* p2) {
-  return TO_BROTLI_BOOL(
-      BrotliUnalignedRead32(p1) == BrotliUnalignedRead32(p2) &&
-      p1[4] == p2[4]);
-}
-
-/* Builds a literal prefix code into "depths" and "bits" based on the statistics
-   of the "input" string and stores it into the bit stream.
-   Note that the prefix code here is built from the pre-LZ77 input, therefore
-   we can only approximate the statistics of the actual literal stream.
-   Moreover, for long inputs we build a histogram from a sample of the input
-   and thus have to assign a non-zero depth for each literal.
-   Returns estimated compression ratio millibytes/char for encoding given input
-   with generated code. */
-static size_t BuildAndStoreLiteralPrefixCode(BrotliOnePassArena* s,
-                                             const uint8_t* input,
-                                             const size_t input_size,
-                                             uint8_t depths[256],
-                                             uint16_t bits[256],
-                                             size_t* storage_ix,
-                                             uint8_t* storage) {
-  uint32_t* BROTLI_RESTRICT const histogram = s->histogram;
-  size_t histogram_total;
-  size_t i;
-  memset(histogram, 0, sizeof(s->histogram));
-
-  if (input_size < (1 << 15)) {
-    for (i = 0; i < input_size; ++i) {
-      ++histogram[input[i]];
-    }
-    histogram_total = input_size;
-    for (i = 0; i < 256; ++i) {
-      /* We weigh the first 11 samples with weight 3 to account for the
-         balancing effect of the LZ77 phase on the histogram. */
-      const uint32_t adjust = 2 * BROTLI_MIN(uint32_t, histogram[i], 11u);
-      histogram[i] += adjust;
-      histogram_total += adjust;
-    }
-  } else {
-    static const size_t kSampleRate = 29;
-    for (i = 0; i < input_size; i += kSampleRate) {
-      ++histogram[input[i]];
-    }
-    histogram_total = (input_size + kSampleRate - 1) / kSampleRate;
-    for (i = 0; i < 256; ++i) {
-      /* We add 1 to each population count to avoid 0 bit depths (since this is
-         only a sample and we don't know if the symbol appears or not), and we
-         weigh the first 11 samples with weight 3 to account for the balancing
-         effect of the LZ77 phase on the histogram (more frequent symbols are
-         more likely to be in backward references instead as literals). */
-      const uint32_t adjust = 1 + 2 * BROTLI_MIN(uint32_t, histogram[i], 11u);
-      histogram[i] += adjust;
-      histogram_total += adjust;
-    }
-  }
-  BrotliBuildAndStoreHuffmanTreeFast(s->tree, histogram, histogram_total,
-                                     /* max_bits = */ 8,
-                                     depths, bits, storage_ix, storage);
-  {
-    size_t literal_ratio = 0;
-    for (i = 0; i < 256; ++i) {
-      if (histogram[i]) literal_ratio += histogram[i] * depths[i];
-    }
-    /* Estimated encoding ratio, millibytes per symbol. */
-    return (literal_ratio * 125) / histogram_total;
-  }
-}
-
-/* Builds a command and distance prefix code (each 64 symbols) into "depth" and
-   "bits" based on "histogram" and stores it into the bit stream. */
-static void BuildAndStoreCommandPrefixCode(BrotliOnePassArena* s,
-    size_t* storage_ix, uint8_t* storage) {
-  const uint32_t* const histogram = s->cmd_histo;
-  uint8_t* const depth = s->cmd_depth;
-  uint16_t* const bits = s->cmd_bits;
-  uint8_t* BROTLI_RESTRICT const tmp_depth = s->tmp_depth;
-  uint16_t* BROTLI_RESTRICT const tmp_bits = s->tmp_bits;
-  /* TODO(eustas): do only once on initialization. */
-  memset(tmp_depth, 0, BROTLI_NUM_COMMAND_SYMBOLS);
-
-  BrotliCreateHuffmanTree(histogram, 64, 15, s->tree, depth);
-  BrotliCreateHuffmanTree(&histogram[64], 64, 14, s->tree, &depth[64]);
-  /* We have to jump through a few hoops here in order to compute
-     the command bits because the symbols are in a different order than in
-     the full alphabet. This looks complicated, but having the symbols
-     in this order in the command bits saves a few branches in the Emit*
-     functions. */
-  memcpy(tmp_depth, depth, 24);
-  memcpy(tmp_depth + 24, depth + 40, 8);
-  memcpy(tmp_depth + 32, depth + 24, 8);
-  memcpy(tmp_depth + 40, depth + 48, 8);
-  memcpy(tmp_depth + 48, depth + 32, 8);
-  memcpy(tmp_depth + 56, depth + 56, 8);
-  BrotliConvertBitDepthsToSymbols(tmp_depth, 64, tmp_bits);
-  memcpy(bits, tmp_bits, 48);
-  memcpy(bits + 24, tmp_bits + 32, 16);
-  memcpy(bits + 32, tmp_bits + 48, 16);
-  memcpy(bits + 40, tmp_bits + 24, 16);
-  memcpy(bits + 48, tmp_bits + 40, 16);
-  memcpy(bits + 56, tmp_bits + 56, 16);
-  BrotliConvertBitDepthsToSymbols(&depth[64], 64, &bits[64]);
-  {
-    /* Create the bit length array for the full command alphabet. */
-    size_t i;
-    memset(tmp_depth, 0, 64);  /* only 64 first values were used */
-    memcpy(tmp_depth, depth, 8);
-    memcpy(tmp_depth + 64, depth + 8, 8);
-    memcpy(tmp_depth + 128, depth + 16, 8);
-    memcpy(tmp_depth + 192, depth + 24, 8);
-    memcpy(tmp_depth + 384, depth + 32, 8);
-    for (i = 0; i < 8; ++i) {
-      tmp_depth[128 + 8 * i] = depth[40 + i];
-      tmp_depth[256 + 8 * i] = depth[48 + i];
-      tmp_depth[448 + 8 * i] = depth[56 + i];
-    }
-    /* TODO(eustas): could/should full-length machinery be avoided? */
-    BrotliStoreHuffmanTree(
-        tmp_depth, BROTLI_NUM_COMMAND_SYMBOLS, s->tree, storage_ix, storage);
-  }
-  BrotliStoreHuffmanTree(&depth[64], 64, s->tree, storage_ix, storage);
-}
-
-/* REQUIRES: insertlen < 6210 */
-static BROTLI_INLINE void EmitInsertLen(size_t insertlen,
-                                        const uint8_t depth[128],
-                                        const uint16_t bits[128],
-                                        uint32_t histo[128],
-                                        size_t* storage_ix,
-                                        uint8_t* storage) {
-  if (insertlen < 6) {
-    const size_t code = insertlen + 40;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    ++histo[code];
-  } else if (insertlen < 130) {
-    const size_t tail = insertlen - 2;
-    const uint32_t nbits = Log2FloorNonZero(tail) - 1u;
-    const size_t prefix = tail >> nbits;
-    const size_t inscode = (nbits << 1) + prefix + 42;
-    BrotliWriteBits(depth[inscode], bits[inscode], storage_ix, storage);
-    BrotliWriteBits(nbits, tail - (prefix << nbits), storage_ix, storage);
-    ++histo[inscode];
-  } else if (insertlen < 2114) {
-    const size_t tail = insertlen - 66;
-    const uint32_t nbits = Log2FloorNonZero(tail);
-    const size_t code = nbits + 50;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    BrotliWriteBits(nbits, tail - ((size_t)1 << nbits), storage_ix, storage);
-    ++histo[code];
-  } else {
-    BrotliWriteBits(depth[61], bits[61], storage_ix, storage);
-    BrotliWriteBits(12, insertlen - 2114, storage_ix, storage);
-    ++histo[61];
-  }
-}
-
-static BROTLI_INLINE void EmitLongInsertLen(size_t insertlen,
-                                            const uint8_t depth[128],
-                                            const uint16_t bits[128],
-                                            uint32_t histo[128],
-                                            size_t* storage_ix,
-                                            uint8_t* storage) {
-  if (insertlen < 22594) {
-    BrotliWriteBits(depth[62], bits[62], storage_ix, storage);
-    BrotliWriteBits(14, insertlen - 6210, storage_ix, storage);
-    ++histo[62];
-  } else {
-    BrotliWriteBits(depth[63], bits[63], storage_ix, storage);
-    BrotliWriteBits(24, insertlen - 22594, storage_ix, storage);
-    ++histo[63];
-  }
-}
-
-static BROTLI_INLINE void EmitCopyLen(size_t copylen,
-                                      const uint8_t depth[128],
-                                      const uint16_t bits[128],
-                                      uint32_t histo[128],
-                                      size_t* storage_ix,
-                                      uint8_t* storage) {
-  if (copylen < 10) {
-    BrotliWriteBits(
-        depth[copylen + 14], bits[copylen + 14], storage_ix, storage);
-    ++histo[copylen + 14];
-  } else if (copylen < 134) {
-    const size_t tail = copylen - 6;
-    const uint32_t nbits = Log2FloorNonZero(tail) - 1u;
-    const size_t prefix = tail >> nbits;
-    const size_t code = (nbits << 1) + prefix + 20;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    BrotliWriteBits(nbits, tail - (prefix << nbits), storage_ix, storage);
-    ++histo[code];
-  } else if (copylen < 2118) {
-    const size_t tail = copylen - 70;
-    const uint32_t nbits = Log2FloorNonZero(tail);
-    const size_t code = nbits + 28;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    BrotliWriteBits(nbits, tail - ((size_t)1 << nbits), storage_ix, storage);
-    ++histo[code];
-  } else {
-    BrotliWriteBits(depth[39], bits[39], storage_ix, storage);
-    BrotliWriteBits(24, copylen - 2118, storage_ix, storage);
-    ++histo[39];
-  }
-}
-
-static BROTLI_INLINE void EmitCopyLenLastDistance(size_t copylen,
-                                                  const uint8_t depth[128],
-                                                  const uint16_t bits[128],
-                                                  uint32_t histo[128],
-                                                  size_t* storage_ix,
-                                                  uint8_t* storage) {
-  if (copylen < 12) {
-    BrotliWriteBits(depth[copylen - 4], bits[copylen - 4], storage_ix, storage);
-    ++histo[copylen - 4];
-  } else if (copylen < 72) {
-    const size_t tail = copylen - 8;
-    const uint32_t nbits = Log2FloorNonZero(tail) - 1;
-    const size_t prefix = tail >> nbits;
-    const size_t code = (nbits << 1) + prefix + 4;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    BrotliWriteBits(nbits, tail - (prefix << nbits), storage_ix, storage);
-    ++histo[code];
-  } else if (copylen < 136) {
-    const size_t tail = copylen - 8;
-    const size_t code = (tail >> 5) + 30;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    BrotliWriteBits(5, tail & 31, storage_ix, storage);
-    BrotliWriteBits(depth[64], bits[64], storage_ix, storage);
-    ++histo[code];
-    ++histo[64];
-  } else if (copylen < 2120) {
-    const size_t tail = copylen - 72;
-    const uint32_t nbits = Log2FloorNonZero(tail);
-    const size_t code = nbits + 28;
-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
-    BrotliWriteBits(nbits, tail - ((size_t)1 << nbits), storage_ix, storage);
-    BrotliWriteBits(depth[64], bits[64], storage_ix, storage);
-    ++histo[code];
-    ++histo[64];
-  } else {
-    BrotliWriteBits(depth[39], bits[39], storage_ix, storage);
-    BrotliWriteBits(24, copylen - 2120, storage_ix, storage);
-    BrotliWriteBits(depth[64], bits[64], storage_ix, storage);
-    ++histo[39];
-    ++histo[64];
-  }
-}
-
-static BROTLI_INLINE void EmitDistance(size_t distance,
-                                       const uint8_t depth[128],
-                                       const uint16_t bits[128],
-                                       uint32_t histo[128],
-                                       size_t* storage_ix, uint8_t* storage) {
-  const size_t d = distance + 3;
-  const uint32_t nbits = Log2FloorNonZero(d) - 1u;
-  const size_t prefix = (d >> nbits) & 1;
-  const size_t offset = (2 + prefix) << nbits;
-  const size_t distcode = 2 * (nbits - 1) + prefix + 80;
-  BrotliWriteBits(depth[distcode], bits[distcode], storage_ix, storage);
-  BrotliWriteBits(nbits, d - offset, storage_ix, storage);
-  ++histo[distcode];
-}
-
-static BROTLI_INLINE void EmitLiterals(const uint8_t* input, const size_t len,
-                                       const uint8_t depth[256],
-                                       const uint16_t bits[256],
-                                       size_t* storage_ix, uint8_t* storage) {
-  size_t j;
-  for (j = 0; j < len; j++) {
-    const uint8_t lit = input[j];
-    BrotliWriteBits(depth[lit], bits[lit], storage_ix, storage);
-  }
-}
-
-/* REQUIRES: len <= 1 << 24. */
-static void BrotliStoreMetaBlockHeader(
-    size_t len, BROTLI_BOOL is_uncompressed, size_t* storage_ix,
-    uint8_t* storage) {
-  size_t nibbles = 6;
-  /* ISLAST */
-  BrotliWriteBits(1, 0, storage_ix, storage);
-  if (len <= (1U << 16)) {
-    nibbles = 4;
-  } else if (len <= (1U << 20)) {
-    nibbles = 5;
-  }
-  BrotliWriteBits(2, nibbles - 4, storage_ix, storage);
-  BrotliWriteBits(nibbles * 4, len - 1, storage_ix, storage);
-  /* ISUNCOMPRESSED */
-  BrotliWriteBits(1, (uint64_t)is_uncompressed, storage_ix, storage);
-}
-
-static void UpdateBits(size_t n_bits, uint32_t bits, size_t pos,
-    uint8_t* array) {
-  while (n_bits > 0) {
-    size_t byte_pos = pos >> 3;
-    size_t n_unchanged_bits = pos & 7;
-    size_t n_changed_bits = BROTLI_MIN(size_t, n_bits, 8 - n_unchanged_bits);
-    size_t total_bits = n_unchanged_bits + n_changed_bits;
-    uint32_t mask =
-        (~((1u << total_bits) - 1u)) | ((1u << n_unchanged_bits) - 1u);
-    uint32_t unchanged_bits = array[byte_pos] & mask;
-    uint32_t changed_bits = bits & ((1u << n_changed_bits) - 1u);
-    array[byte_pos] =
-        (uint8_t)((changed_bits << n_unchanged_bits) | unchanged_bits);
-    n_bits -= n_changed_bits;
-    bits >>= n_changed_bits;
-    pos += n_changed_bits;
-  }
-}
-
-static void RewindBitPosition(const size_t new_storage_ix,
-                              size_t* storage_ix, uint8_t* storage) {
-  const size_t bitpos = new_storage_ix & 7;
-  const size_t mask = (1u << bitpos) - 1;
-  storage[new_storage_ix >> 3] &= (uint8_t)mask;
-  *storage_ix = new_storage_ix;
-}
-
-static BROTLI_BOOL ShouldMergeBlock(BrotliOnePassArena* s,
-    const uint8_t* data, size_t len, const uint8_t* depths) {
-  uint32_t* BROTLI_RESTRICT const histo = s->histogram;
-  static const size_t kSampleRate = 43;
-  size_t i;
-  memset(histo, 0, sizeof(s->histogram));
-  for (i = 0; i < len; i += kSampleRate) {
-    ++histo[data[i]];
-  }
-  {
-    const size_t total = (len + kSampleRate - 1) / kSampleRate;
-    double r = (FastLog2(total) + 0.5) * (double)total + 200;
-    for (i = 0; i < 256; ++i) {
-      r -= (double)histo[i] * (depths[i] + FastLog2(histo[i]));
-    }
-    return TO_BROTLI_BOOL(r >= 0.0);
-  }
-}
-
-/* Acceptable loss for uncompressible speedup is 2% */
-#define MIN_RATIO 980
-
-static BROTLI_INLINE BROTLI_BOOL ShouldUseUncompressedMode(
-    const uint8_t* metablock_start, const uint8_t* next_emit,
-    const size_t insertlen, const size_t literal_ratio) {
-  const size_t compressed = (size_t)(next_emit - metablock_start);
-  if (compressed * 50 > insertlen) {
-    return BROTLI_FALSE;
-  } else {
-    return TO_BROTLI_BOOL(literal_ratio > MIN_RATIO);
-  }
-}
-
-static void EmitUncompressedMetaBlock(const uint8_t* begin, const uint8_t* end,
-                                      const size_t storage_ix_start,
-                                      size_t* storage_ix, uint8_t* storage) {
-  const size_t len = (size_t)(end - begin);
-  RewindBitPosition(storage_ix_start, storage_ix, storage);
-  BrotliStoreMetaBlockHeader(len, 1, storage_ix, storage);
-  *storage_ix = (*storage_ix + 7u) & ~7u;
-  memcpy(&storage[*storage_ix >> 3], begin, len);
-  *storage_ix += len << 3;
-  storage[*storage_ix >> 3] = 0;
-}
-
-static uint32_t kCmdHistoSeed[128] = {
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 0, 0, 0, 0,
-};
-
-static BROTLI_INLINE void BrotliCompressFragmentFastImpl(
-    BrotliOnePassArena* s, const uint8_t* input, size_t input_size,
-    BROTLI_BOOL is_last, int* table, size_t table_bits,
-    size_t* storage_ix, uint8_t* storage) {
-  uint8_t* BROTLI_RESTRICT const cmd_depth = s->cmd_depth;
-  uint16_t* BROTLI_RESTRICT const cmd_bits = s->cmd_bits;
-  uint32_t* BROTLI_RESTRICT const cmd_histo = s->cmd_histo;
-  uint8_t* BROTLI_RESTRICT const lit_depth = s->lit_depth;
-  uint16_t* BROTLI_RESTRICT const lit_bits = s->lit_bits;
-  const uint8_t* ip_end;
-
-  /* "next_emit" is a pointer to the first byte that is not covered by a
-     previous copy. Bytes between "next_emit" and the start of the next copy or
-     the end of the input will be emitted as literal bytes. */
-  const uint8_t* next_emit = input;
-  /* Save the start of the first block for position and distance computations.
-  */
-  const uint8_t* base_ip = input;
-
-  static const size_t kFirstBlockSize = 3 << 15;
-  static const size_t kMergeBlockSize = 1 << 16;
-
-  const size_t kInputMarginBytes = BROTLI_WINDOW_GAP;
-  const size_t kMinMatchLen = 5;
-
-  const uint8_t* metablock_start = input;
-  size_t block_size = BROTLI_MIN(size_t, input_size, kFirstBlockSize);
-  size_t total_block_size = block_size;
-  /* Save the bit position of the MLEN field of the meta-block header, so that
-     we can update it later if we decide to extend this meta-block. */
-  size_t mlen_storage_ix = *storage_ix + 3;
-
-  size_t literal_ratio;
-
-  const uint8_t* ip;
-  int last_distance;
-
-  const size_t shift = 64u - table_bits;
-
-  BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
-  /* No block splits, no contexts. */
-  BrotliWriteBits(13, 0, storage_ix, storage);
-
-  literal_ratio = BuildAndStoreLiteralPrefixCode(
-      s, input, block_size, s->lit_depth, s->lit_bits, storage_ix, storage);
-
-  {
-    /* Store the pre-compressed command and distance prefix codes. */
-    size_t i;
-    for (i = 0; i + 7 < s->cmd_code_numbits; i += 8) {
-      BrotliWriteBits(8, s->cmd_code[i >> 3], storage_ix, storage);
-    }
-  }
-  BrotliWriteBits(s->cmd_code_numbits & 7,
-                  s->cmd_code[s->cmd_code_numbits >> 3], storage_ix, storage);
-
- emit_commands:
-  /* Initialize the command and distance histograms. We will gather
-     statistics of command and distance codes during the processing
-     of this block and use it to update the command and distance
-     prefix codes for the next block. */
-  memcpy(s->cmd_histo, kCmdHistoSeed, sizeof(kCmdHistoSeed));
-
-  /* "ip" is the input pointer. */
-  ip = input;
-  last_distance = -1;
-  ip_end = input + block_size;
-
-  if (BROTLI_PREDICT_TRUE(block_size >= kInputMarginBytes)) {
-    /* For the last block, we need to keep a 16 bytes margin so that we can be
-       sure that all distances are at most window size - 16.
-       For all other blocks, we only need to keep a margin of 5 bytes so that
-       we don't go over the block size with a copy. */
-    const size_t len_limit = BROTLI_MIN(size_t, block_size - kMinMatchLen,
-                                        input_size - kInputMarginBytes);
-    const uint8_t* ip_limit = input + len_limit;
-
-    uint32_t next_hash;
-    for (next_hash = Hash(++ip, shift); ; ) {
-      /* Step 1: Scan forward in the input looking for a 5-byte-long match.
-         If we get close to exhausting the input then goto emit_remainder.
-
-         Heuristic match skipping: If 32 bytes are scanned with no matches
-         found, start looking only at every other byte. If 32 more bytes are
-         scanned, look at every third byte, etc.. When a match is found,
-         immediately go back to looking at every byte. This is a small loss
-         (~5% performance, ~0.1% density) for compressible data due to more
-         bookkeeping, but for non-compressible data (such as JPEG) it's a huge
-         win since the compressor quickly "realizes" the data is incompressible
-         and doesn't bother looking for matches everywhere.
-
-         The "skip" variable keeps track of how many bytes there are since the
-         last match; dividing it by 32 (i.e. right-shifting by five) gives the
-         number of bytes to move ahead for each iteration. */
-      uint32_t skip = 32;
-
-      const uint8_t* next_ip = ip;
-      const uint8_t* candidate;
-      BROTLI_DCHECK(next_emit < ip);
-trawl:
-      do {
-        uint32_t hash = next_hash;
-        uint32_t bytes_between_hash_lookups = skip++ >> 5;
-        BROTLI_DCHECK(hash == Hash(next_ip, shift));
-        ip = next_ip;
-        next_ip = ip + bytes_between_hash_lookups;
-        if (BROTLI_PREDICT_FALSE(next_ip > ip_limit)) {
-          goto emit_remainder;
-        }
-        next_hash = Hash(next_ip, shift);
-        candidate = ip - last_distance;
-        if (IsMatch(ip, candidate)) {
-          if (BROTLI_PREDICT_TRUE(candidate < ip)) {
-            table[hash] = (int)(ip - base_ip);
-            break;
-          }
-        }
-        candidate = base_ip + table[hash];
-        BROTLI_DCHECK(candidate >= base_ip);
-        BROTLI_DCHECK(candidate < ip);
-
-        table[hash] = (int)(ip - base_ip);
-      } while (BROTLI_PREDICT_TRUE(!IsMatch(ip, candidate)));
-
-      /* Check copy distance. If candidate is not feasible, continue search.
-         Checking is done outside of hot loop to reduce overhead. */
-      if (ip - candidate > MAX_DISTANCE) goto trawl;
-
-      /* Step 2: Emit the found match together with the literal bytes from
-         "next_emit" to the bit stream, and then see if we can find a next match
-         immediately afterwards. Repeat until we find no match for the input
-         without emitting some literal bytes. */
-
-      {
-        /* We have a 5-byte match at ip, and we need to emit bytes in
-           [next_emit, ip). */
-        const uint8_t* base = ip;
-        size_t matched = 5 + FindMatchLengthWithLimit(
-            candidate + 5, ip + 5, (size_t)(ip_end - ip) - 5);
-        int distance = (int)(base - candidate);  /* > 0 */
-        size_t insert = (size_t)(base - next_emit);
-        ip += matched;
-        BROTLI_LOG(("[CompressFragment] pos = %d insert = %lu copy = %d\n",
-                    (int)(next_emit - base_ip), (unsigned long)insert, 2));
-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
-        if (BROTLI_PREDICT_TRUE(insert < 6210)) {
-          EmitInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
-                        storage_ix, storage);
-        } else if (ShouldUseUncompressedMode(metablock_start, next_emit, insert,
-                                             literal_ratio)) {
-          EmitUncompressedMetaBlock(metablock_start, base, mlen_storage_ix - 3,
-                                    storage_ix, storage);
-          input_size -= (size_t)(base - input);
-          input = base;
-          next_emit = input;
-          goto next_block;
-        } else {
-          EmitLongInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
-                            storage_ix, storage);
-        }
-        EmitLiterals(next_emit, insert, lit_depth, lit_bits,
-                     storage_ix, storage);
-        if (distance == last_distance) {
-          BrotliWriteBits(cmd_depth[64], cmd_bits[64], storage_ix, storage);
-          ++cmd_histo[64];
-        } else {
-          EmitDistance((size_t)distance, cmd_depth, cmd_bits,
-                       cmd_histo, storage_ix, storage);
-          last_distance = distance;
-        }
-        EmitCopyLenLastDistance(matched, cmd_depth, cmd_bits, cmd_histo,
-                                storage_ix, storage);
-        BROTLI_LOG(("[CompressFragment] pos = %d distance = %d\n"
-                    "[CompressFragment] pos = %d insert = %d copy = %d\n"
-                    "[CompressFragment] pos = %d distance = %d\n",
-                    (int)(base - base_ip), (int)distance,
-                    (int)(base - base_ip) + 2, 0, (int)matched - 2,
-                    (int)(base - base_ip) + 2, (int)distance));
-
-        next_emit = ip;
-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        /* We could immediately start working at ip now, but to improve
-           compression we first update "table" with the hashes of some positions
-           within the last copy. */
-        {
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
-          uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
-          uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
-          table[prev_hash] = (int)(ip - base_ip - 3);
-          prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
-          table[prev_hash] = (int)(ip - base_ip - 2);
-          prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
-          table[prev_hash] = (int)(ip - base_ip - 1);
-
-          candidate = base_ip + table[cur_hash];
-          table[cur_hash] = (int)(ip - base_ip);
-        }
-      }
-
-      while (IsMatch(ip, candidate)) {
-        /* We have a 5-byte match at ip, and no need to emit any literal bytes
-           prior to ip. */
-        const uint8_t* base = ip;
-        size_t matched = 5 + FindMatchLengthWithLimit(
-            candidate + 5, ip + 5, (size_t)(ip_end - ip) - 5);
-        if (ip - candidate > MAX_DISTANCE) break;
-        ip += matched;
-        last_distance = (int)(base - candidate);  /* > 0 */
-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
-        EmitCopyLen(matched, cmd_depth, cmd_bits, cmd_histo,
-                    storage_ix, storage);
-        EmitDistance((size_t)last_distance, cmd_depth, cmd_bits,
-                     cmd_histo, storage_ix, storage);
-        BROTLI_LOG(("[CompressFragment] pos = %d insert = %d copy = %d\n"
-                    "[CompressFragment] pos = %d distance = %d\n",
-                    (int)(base - base_ip), 0, (int)matched,
-                    (int)(base - base_ip), (int)last_distance));
-
-        next_emit = ip;
-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        /* We could immediately start working at ip now, but to improve
-           compression we first update "table" with the hashes of some positions
-           within the last copy. */
-        {
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
-          uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
-          uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
-          table[prev_hash] = (int)(ip - base_ip - 3);
-          prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
-          table[prev_hash] = (int)(ip - base_ip - 2);
-          prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
-          table[prev_hash] = (int)(ip - base_ip - 1);
-
-          candidate = base_ip + table[cur_hash];
-          table[cur_hash] = (int)(ip - base_ip);
-        }
-      }
-
-      next_hash = Hash(++ip, shift);
-    }
-  }
-
- emit_remainder:
-  BROTLI_DCHECK(next_emit <= ip_end);
-  input += block_size;
-  input_size -= block_size;
-  block_size = BROTLI_MIN(size_t, input_size, kMergeBlockSize);
-
-  /* Decide if we want to continue this meta-block instead of emitting the
-     last insert-only command. */
-  if (input_size > 0 &&
-      total_block_size + block_size <= (1 << 20) &&
-      ShouldMergeBlock(s, input, block_size, lit_depth)) {
-    BROTLI_DCHECK(total_block_size > (1 << 16));
-    /* Update the size of the current meta-block and continue emitting commands.
-       We can do this because the current size and the new size both have 5
-       nibbles. */
-    total_block_size += block_size;
-    UpdateBits(20, (uint32_t)(total_block_size - 1), mlen_storage_ix, storage);
-    goto emit_commands;
-  }
-
-  /* Emit the remaining bytes as literals. */
-  if (next_emit < ip_end) {
-    const size_t insert = (size_t)(ip_end - next_emit);
-    BROTLI_LOG(("[CompressFragment] pos = %d insert = %lu copy = %d\n",
-                (int)(next_emit - base_ip), (unsigned long)insert, 2));
-    if (BROTLI_PREDICT_TRUE(insert < 6210)) {
-      EmitInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
-                    storage_ix, storage);
-      EmitLiterals(next_emit, insert, lit_depth, lit_bits, storage_ix, storage);
-    } else if (ShouldUseUncompressedMode(metablock_start, next_emit, insert,
-                                         literal_ratio)) {
-      EmitUncompressedMetaBlock(metablock_start, ip_end, mlen_storage_ix - 3,
-                                storage_ix, storage);
-    } else {
-      EmitLongInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
-                        storage_ix, storage);
-      EmitLiterals(next_emit, insert, lit_depth, lit_bits,
-                   storage_ix, storage);
-    }
-  }
-  next_emit = ip_end;
-
-next_block:
-  /* If we have more data, write a new meta-block header and prefix codes and
-     then continue emitting commands. */
-  if (input_size > 0) {
-    metablock_start = input;
-    block_size = BROTLI_MIN(size_t, input_size, kFirstBlockSize);
-    total_block_size = block_size;
-    /* Save the bit position of the MLEN field of the meta-block header, so that
-       we can update it later if we decide to extend this meta-block. */
-    mlen_storage_ix = *storage_ix + 3;
-    BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
-    /* No block splits, no contexts. */
-    BrotliWriteBits(13, 0, storage_ix, storage);
-    literal_ratio = BuildAndStoreLiteralPrefixCode(
-        s, input, block_size, lit_depth, lit_bits, storage_ix, storage);
-    BuildAndStoreCommandPrefixCode(s, storage_ix, storage);
-    goto emit_commands;
-  }
-
-  if (!is_last) {
-    /* If this is not the last block, update the command and distance prefix
-       codes for the next block and store the compressed forms. */
-    s->cmd_code[0] = 0;
-    s->cmd_code_numbits = 0;
-    BuildAndStoreCommandPrefixCode(s, &s->cmd_code_numbits, s->cmd_code);
-  }
-}
-
-#define FOR_TABLE_BITS_(X) X(9) X(11) X(13) X(15)
-
-#define BAKE_METHOD_PARAM_(B) \
-static BROTLI_NOINLINE void BrotliCompressFragmentFastImpl ## B(             \
-    BrotliOnePassArena* s, const uint8_t* input, size_t input_size,          \
-    BROTLI_BOOL is_last, int* table, size_t* storage_ix, uint8_t* storage) { \
-  BrotliCompressFragmentFastImpl(s, input, input_size, is_last, table, B,    \
-      storage_ix, storage);                                                  \
-}
-FOR_TABLE_BITS_(BAKE_METHOD_PARAM_)
-#undef BAKE_METHOD_PARAM_
-
-void duckdb_brotli::BrotliCompressFragmentFast(
-    BrotliOnePassArena* s, const uint8_t* input, size_t input_size,
-    BROTLI_BOOL is_last, int* table, size_t table_size,
-    size_t* storage_ix, uint8_t* storage) {
-  const size_t initial_storage_ix = *storage_ix;
-  const size_t table_bits = Log2FloorNonZero(table_size);
-
-  if (input_size == 0) {
-    BROTLI_DCHECK(is_last);
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
-    *storage_ix = (*storage_ix + 7u) & ~7u;
-    return;
-  }
-
-  switch (table_bits) {
-#define CASE_(B)                                                     \
-    case B:                                                          \
-      BrotliCompressFragmentFastImpl ## B(                           \
-          s, input, input_size, is_last, table, storage_ix, storage);\
-      break;
-    FOR_TABLE_BITS_(CASE_)
-#undef CASE_
-    default: BROTLI_DCHECK(0); break;
-  }
-
-  /* If output is larger than single uncompressed block, rewrite it. */
-  if (*storage_ix - initial_storage_ix > 31 + (input_size << 3)) {
-    EmitUncompressedMetaBlock(input, input + input_size, initial_storage_ix,
-                              storage_ix, storage);
-  }
-
-  if (is_last) {
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
-    *storage_ix = (*storage_ix + 7u) & ~7u;
-  }
-}
-
-#undef FOR_TABLE_BITS_
-
-
diff --git a/src/duckdb/third_party/brotli/enc/compress_fragment.h b/src/duckdb/third_party/brotli/enc/compress_fragment.h
deleted file mode 100644
index dbfe82cc4..000000000
--- a/src/duckdb/third_party/brotli/enc/compress_fragment.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function for fast encoding of an input fragment, independently from the input
-   history. This function uses one-pass processing: when we find a backward
-   match, we immediately emit the corresponding command and literal codes to
-   the bit stream. */
-
-#ifndef BROTLI_ENC_COMPRESS_FRAGMENT_H_
-#define BROTLI_ENC_COMPRESS_FRAGMENT_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "entropy_encode.h"
-
-namespace duckdb_brotli {
-
-typedef struct BrotliOnePassArena {
-  uint8_t lit_depth[256];
-  uint16_t lit_bits[256];
-
-  /* Command and distance prefix codes (each 64 symbols, stored back-to-back)
-     used for the next block. The command prefix code is over a smaller alphabet
-     with the following 64 symbols:
-        0 - 15: insert length code 0, copy length code 0 - 15, same distance
-       16 - 39: insert length code 0, copy length code 0 - 23
-       40 - 63: insert length code 0 - 23, copy length code 0
-     Note that symbols 16 and 40 represent the same code in the full alphabet,
-     but we do not use either of them. */
-  uint8_t cmd_depth[128];
-  uint16_t cmd_bits[128];
-  uint32_t cmd_histo[128];
-
-  /* The compressed form of the command and distance prefix codes for the next
-     block. */
-  uint8_t cmd_code[512];
-  size_t cmd_code_numbits;
-
-  HuffmanTree tree[2 * BROTLI_NUM_LITERAL_SYMBOLS + 1];
-  uint32_t histogram[256];
-  uint8_t tmp_depth[BROTLI_NUM_COMMAND_SYMBOLS];
-  uint16_t tmp_bits[64];
-} BrotliOnePassArena;
-
-/* Compresses "input" string to the "*storage" buffer as one or more complete
-   meta-blocks, and updates the "*storage_ix" bit position.
-
-   If "is_last" is 1, emits an additional empty last meta-block.
-
-   "cmd_depth" and "cmd_bits" contain the command and distance prefix codes
-   (see comment in encode.h) used for the encoding of this input fragment.
-   If "is_last" is 0, they are updated to reflect the statistics
-   of this input fragment, to be used for the encoding of the next fragment.
-
-   "*cmd_code_numbits" is the number of bits of the compressed representation
-   of the command and distance prefix codes, and "cmd_code" is an array of
-   at least "(*cmd_code_numbits + 7) >> 3" size that contains the compressed
-   command and distance prefix codes. If "is_last" is 0, these are also
-   updated to represent the updated "cmd_depth" and "cmd_bits".
-
-   REQUIRES: "input_size" is greater than zero, or "is_last" is 1.
-   REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24).
-   REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-   REQUIRES: "table_size" is an odd (9, 11, 13, 15) power of two
-   OUTPUT: maximal copy distance <= |input_size|
-   OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */
-BROTLI_INTERNAL void BrotliCompressFragmentFast(BrotliOnePassArena* s,
-                                                const uint8_t* input,
-                                                size_t input_size,
-                                                BROTLI_BOOL is_last,
-                                                int* table, size_t table_size,
-                                                size_t* storage_ix,
-                                                uint8_t* storage);
-
-}
-
-#endif  /* BROTLI_ENC_COMPRESS_FRAGMENT_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp b/src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp
deleted file mode 100644
index 1cc436aa7..000000000
--- a/src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp
+++ /dev/null
@@ -1,653 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function for fast encoding of an input fragment, independently from the input
-   history. This function uses two-pass processing: in the first pass we save
-   the found backward matches and literal bytes into a buffer, and in the
-   second pass we emit them into the bit stream using prefix codes built based
-   on the actual command and literal byte histograms. */
-
-#include "compress_fragment_two_pass.h"
-
-#include <string.h>  /* memcmp, memcpy, memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "bit_cost.h"
-#include "brotli_bit_stream.h"
-#include "entropy_encode.h"
-#include "fast_log.h"
-#include "find_match_length.h"
-#include "write_bits.h"
-
-using namespace duckdb_brotli;
-
-#define MAX_DISTANCE (long)BROTLI_MAX_BACKWARD_LIMIT(18)
-
-/* kHashMul32 multiplier has these properties:
-   * The multiplier must be odd. Otherwise we may lose the highest bit.
-   * No long streaks of ones or zeros.
-   * There is no effort to ensure that it is a prime, the oddity is enough
-     for this use.
-   * The number has been tuned heuristically against compression benchmarks. */
-static const uint32_t kHashMul32 = 0x1E35A7BD;
-
-static BROTLI_INLINE uint32_t Hash(const uint8_t* p,
-    size_t shift, size_t length) {
-  const uint64_t h =
-      (BROTLI_UNALIGNED_LOAD64LE(p) << ((8 - length) * 8)) * kHashMul32;
-  return (uint32_t)(h >> shift);
-}
-
-static BROTLI_INLINE uint32_t HashBytesAtOffset(uint64_t v, size_t offset,
-    size_t shift, size_t length) {
-  BROTLI_DCHECK(offset <= 8 - length);
-  {
-    const uint64_t h = ((v >> (8 * offset)) << ((8 - length) * 8)) * kHashMul32;
-    return (uint32_t)(h >> shift);
-  }
-}
-
-static BROTLI_INLINE BROTLI_BOOL IsMatch(const uint8_t* p1, const uint8_t* p2,
-    size_t length) {
-  if (BrotliUnalignedRead32(p1) == BrotliUnalignedRead32(p2)) {
-    if (length == 4) return BROTLI_TRUE;
-    return TO_BROTLI_BOOL(p1[4] == p2[4] && p1[5] == p2[5]);
-  }
-  return BROTLI_FALSE;
-}
-
-/* Builds a command and distance prefix code (each 64 symbols) into "depth" and
-   "bits" based on "histogram" and stores it into the bit stream. */
-static void BuildAndStoreCommandPrefixCode(BrotliTwoPassArena* s,
-                                           size_t* storage_ix,
-                                           uint8_t* storage) {
-  /* Tree size for building a tree over 64 symbols is 2 * 64 + 1. */
-  /* TODO(eustas): initialize once. */
-  memset(s->tmp_depth, 0, sizeof(s->tmp_depth));
-  BrotliCreateHuffmanTree(s->cmd_histo, 64, 15, s->tmp_tree, s->cmd_depth);
-  BrotliCreateHuffmanTree(&s->cmd_histo[64], 64, 14, s->tmp_tree,
-                          &s->cmd_depth[64]);
-  /* We have to jump through a few hoops here in order to compute
-     the command bits because the symbols are in a different order than in
-     the full alphabet. This looks complicated, but having the symbols
-     in this order in the command bits saves a few branches in the Emit*
-     functions. */
-  memcpy(s->tmp_depth, s->cmd_depth + 24, 24);
-  memcpy(s->tmp_depth + 24, s->cmd_depth, 8);
-  memcpy(s->tmp_depth + 32, s->cmd_depth + 48, 8);
-  memcpy(s->tmp_depth + 40, s->cmd_depth + 8, 8);
-  memcpy(s->tmp_depth + 48, s->cmd_depth + 56, 8);
-  memcpy(s->tmp_depth + 56, s->cmd_depth + 16, 8);
-  BrotliConvertBitDepthsToSymbols(s->tmp_depth, 64, s->tmp_bits);
-  memcpy(s->cmd_bits, s->tmp_bits + 24, 16);
-  memcpy(s->cmd_bits + 8, s->tmp_bits + 40, 16);
-  memcpy(s->cmd_bits + 16, s->tmp_bits + 56, 16);
-  memcpy(s->cmd_bits + 24, s->tmp_bits, 48);
-  memcpy(s->cmd_bits + 48, s->tmp_bits + 32, 16);
-  memcpy(s->cmd_bits + 56, s->tmp_bits + 48, 16);
-  BrotliConvertBitDepthsToSymbols(&s->cmd_depth[64], 64, &s->cmd_bits[64]);
-  {
-    /* Create the bit length array for the full command alphabet. */
-    size_t i;
-    memset(s->tmp_depth, 0, 64); /* only 64 first values were used */
-    memcpy(s->tmp_depth, s->cmd_depth + 24, 8);
-    memcpy(s->tmp_depth + 64, s->cmd_depth + 32, 8);
-    memcpy(s->tmp_depth + 128, s->cmd_depth + 40, 8);
-    memcpy(s->tmp_depth + 192, s->cmd_depth + 48, 8);
-    memcpy(s->tmp_depth + 384, s->cmd_depth + 56, 8);
-    for (i = 0; i < 8; ++i) {
-      s->tmp_depth[128 + 8 * i] = s->cmd_depth[i];
-      s->tmp_depth[256 + 8 * i] = s->cmd_depth[8 + i];
-      s->tmp_depth[448 + 8 * i] = s->cmd_depth[16 + i];
-    }
-    BrotliStoreHuffmanTree(s->tmp_depth, BROTLI_NUM_COMMAND_SYMBOLS,
-                           s->tmp_tree, storage_ix, storage);
-  }
-  BrotliStoreHuffmanTree(&s->cmd_depth[64], 64, s->tmp_tree, storage_ix,
-                         storage);
-}
-
-static BROTLI_INLINE void EmitInsertLen(
-    uint32_t insertlen, uint32_t** commands) {
-  if (insertlen < 6) {
-    **commands = insertlen;
-  } else if (insertlen < 130) {
-    const uint32_t tail = insertlen - 2;
-    const uint32_t nbits = Log2FloorNonZero(tail) - 1u;
-    const uint32_t prefix = tail >> nbits;
-    const uint32_t inscode = (nbits << 1) + prefix + 2;
-    const uint32_t extra = tail - (prefix << nbits);
-    **commands = inscode | (extra << 8);
-  } else if (insertlen < 2114) {
-    const uint32_t tail = insertlen - 66;
-    const uint32_t nbits = Log2FloorNonZero(tail);
-    const uint32_t code = nbits + 10;
-    const uint32_t extra = tail - (1u << nbits);
-    **commands = code | (extra << 8);
-  } else if (insertlen < 6210) {
-    const uint32_t extra = insertlen - 2114;
-    **commands = 21 | (extra << 8);
-  } else if (insertlen < 22594) {
-    const uint32_t extra = insertlen - 6210;
-    **commands = 22 | (extra << 8);
-  } else {
-    const uint32_t extra = insertlen - 22594;
-    **commands = 23 | (extra << 8);
-  }
-  ++(*commands);
-}
-
-static BROTLI_INLINE void EmitCopyLen(size_t copylen, uint32_t** commands) {
-  if (copylen < 10) {
-    **commands = (uint32_t)(copylen + 38);
-  } else if (copylen < 134) {
-    const size_t tail = copylen - 6;
-    const size_t nbits = Log2FloorNonZero(tail) - 1;
-    const size_t prefix = tail >> nbits;
-    const size_t code = (nbits << 1) + prefix + 44;
-    const size_t extra = tail - (prefix << nbits);
-    **commands = (uint32_t)(code | (extra << 8));
-  } else if (copylen < 2118) {
-    const size_t tail = copylen - 70;
-    const size_t nbits = Log2FloorNonZero(tail);
-    const size_t code = nbits + 52;
-    const size_t extra = tail - ((size_t)1 << nbits);
-    **commands = (uint32_t)(code | (extra << 8));
-  } else {
-    const size_t extra = copylen - 2118;
-    **commands = (uint32_t)(63 | (extra << 8));
-  }
-  ++(*commands);
-}
-
-static BROTLI_INLINE void EmitCopyLenLastDistance(
-    size_t copylen, uint32_t** commands) {
-  if (copylen < 12) {
-    **commands = (uint32_t)(copylen + 20);
-    ++(*commands);
-  } else if (copylen < 72) {
-    const size_t tail = copylen - 8;
-    const size_t nbits = Log2FloorNonZero(tail) - 1;
-    const size_t prefix = tail >> nbits;
-    const size_t code = (nbits << 1) + prefix + 28;
-    const size_t extra = tail - (prefix << nbits);
-    **commands = (uint32_t)(code | (extra << 8));
-    ++(*commands);
-  } else if (copylen < 136) {
-    const size_t tail = copylen - 8;
-    const size_t code = (tail >> 5) + 54;
-    const size_t extra = tail & 31;
-    **commands = (uint32_t)(code | (extra << 8));
-    ++(*commands);
-    **commands = 64;
-    ++(*commands);
-  } else if (copylen < 2120) {
-    const size_t tail = copylen - 72;
-    const size_t nbits = Log2FloorNonZero(tail);
-    const size_t code = nbits + 52;
-    const size_t extra = tail - ((size_t)1 << nbits);
-    **commands = (uint32_t)(code | (extra << 8));
-    ++(*commands);
-    **commands = 64;
-    ++(*commands);
-  } else {
-    const size_t extra = copylen - 2120;
-    **commands = (uint32_t)(63 | (extra << 8));
-    ++(*commands);
-    **commands = 64;
-    ++(*commands);
-  }
-}
-
-static BROTLI_INLINE void EmitDistance(uint32_t distance, uint32_t** commands) {
-  uint32_t d = distance + 3;
-  uint32_t nbits = Log2FloorNonZero(d) - 1;
-  const uint32_t prefix = (d >> nbits) & 1;
-  const uint32_t offset = (2 + prefix) << nbits;
-  const uint32_t distcode = 2 * (nbits - 1) + prefix + 80;
-  uint32_t extra = d - offset;
-  **commands = distcode | (extra << 8);
-  ++(*commands);
-}
-
-/* REQUIRES: len <= 1 << 24. */
-static void BrotliStoreMetaBlockHeader(
-    size_t len, BROTLI_BOOL is_uncompressed, size_t* storage_ix,
-    uint8_t* storage) {
-  size_t nibbles = 6;
-  /* ISLAST */
-  BrotliWriteBits(1, 0, storage_ix, storage);
-  if (len <= (1U << 16)) {
-    nibbles = 4;
-  } else if (len <= (1U << 20)) {
-    nibbles = 5;
-  }
-  BrotliWriteBits(2, nibbles - 4, storage_ix, storage);
-  BrotliWriteBits(nibbles * 4, len - 1, storage_ix, storage);
-  /* ISUNCOMPRESSED */
-  BrotliWriteBits(1, (uint64_t)is_uncompressed, storage_ix, storage);
-}
-
-static BROTLI_INLINE void CreateCommands(const uint8_t* input,
-    size_t block_size, size_t input_size, const uint8_t* base_ip, int* table,
-    size_t table_bits, size_t min_match,
-    uint8_t** literals, uint32_t** commands) {
-  /* "ip" is the input pointer. */
-  const uint8_t* ip = input;
-  const size_t shift = 64u - table_bits;
-  const uint8_t* ip_end = input + block_size;
-  /* "next_emit" is a pointer to the first byte that is not covered by a
-     previous copy. Bytes between "next_emit" and the start of the next copy or
-     the end of the input will be emitted as literal bytes. */
-  const uint8_t* next_emit = input;
-
-  int last_distance = -1;
-  const size_t kInputMarginBytes = BROTLI_WINDOW_GAP;
-
-  if (BROTLI_PREDICT_TRUE(block_size >= kInputMarginBytes)) {
-    /* For the last block, we need to keep a 16 bytes margin so that we can be
-       sure that all distances are at most window size - 16.
-       For all other blocks, we only need to keep a margin of 5 bytes so that
-       we don't go over the block size with a copy. */
-    const size_t len_limit = BROTLI_MIN(size_t, block_size - min_match,
-                                        input_size - kInputMarginBytes);
-    const uint8_t* ip_limit = input + len_limit;
-
-    uint32_t next_hash;
-    for (next_hash = Hash(++ip, shift, min_match); ; ) {
-      /* Step 1: Scan forward in the input looking for a 6-byte-long match.
-         If we get close to exhausting the input then goto emit_remainder.
-
-         Heuristic match skipping: If 32 bytes are scanned with no matches
-         found, start looking only at every other byte. If 32 more bytes are
-         scanned, look at every third byte, etc.. When a match is found,
-         immediately go back to looking at every byte. This is a small loss
-         (~5% performance, ~0.1% density) for compressible data due to more
-         bookkeeping, but for non-compressible data (such as JPEG) it's a huge
-         win since the compressor quickly "realizes" the data is incompressible
-         and doesn't bother looking for matches everywhere.
-
-         The "skip" variable keeps track of how many bytes there are since the
-         last match; dividing it by 32 (ie. right-shifting by five) gives the
-         number of bytes to move ahead for each iteration. */
-      uint32_t skip = 32;
-
-      const uint8_t* next_ip = ip;
-      const uint8_t* candidate;
-
-      BROTLI_DCHECK(next_emit < ip);
-trawl:
-      do {
-        uint32_t hash = next_hash;
-        uint32_t bytes_between_hash_lookups = skip++ >> 5;
-        ip = next_ip;
-        BROTLI_DCHECK(hash == Hash(ip, shift, min_match));
-        next_ip = ip + bytes_between_hash_lookups;
-        if (BROTLI_PREDICT_FALSE(next_ip > ip_limit)) {
-          goto emit_remainder;
-        }
-        next_hash = Hash(next_ip, shift, min_match);
-        candidate = ip - last_distance;
-        if (IsMatch(ip, candidate, min_match)) {
-          if (BROTLI_PREDICT_TRUE(candidate < ip)) {
-            table[hash] = (int)(ip - base_ip);
-            break;
-          }
-        }
-        candidate = base_ip + table[hash];
-        BROTLI_DCHECK(candidate >= base_ip);
-        BROTLI_DCHECK(candidate < ip);
-
-        table[hash] = (int)(ip - base_ip);
-      } while (BROTLI_PREDICT_TRUE(!IsMatch(ip, candidate, min_match)));
-
-      /* Check copy distance. If candidate is not feasible, continue search.
-         Checking is done outside of hot loop to reduce overhead. */
-      if (ip - candidate > MAX_DISTANCE) goto trawl;
-
-      /* Step 2: Emit the found match together with the literal bytes from
-         "next_emit", and then see if we can find a next match immediately
-         afterwards. Repeat until we find no match for the input
-         without emitting some literal bytes. */
-
-      {
-        /* We have a 6-byte match at ip, and we need to emit bytes in
-           [next_emit, ip). */
-        const uint8_t* base = ip;
-        size_t matched = min_match + FindMatchLengthWithLimit(
-            candidate + min_match, ip + min_match,
-            (size_t)(ip_end - ip) - min_match);
-        int distance = (int)(base - candidate);  /* > 0 */
-        int insert = (int)(base - next_emit);
-        ip += matched;
-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
-        EmitInsertLen((uint32_t)insert, commands);
-        BROTLI_LOG(("[CompressFragment] pos = %d insert = %d copy = %d\n",
-                    (int)(next_emit - base_ip), insert, 2));
-        memcpy(*literals, next_emit, (size_t)insert);
-        *literals += insert;
-        if (distance == last_distance) {
-          **commands = 64;
-          ++(*commands);
-        } else {
-          EmitDistance((uint32_t)distance, commands);
-          last_distance = distance;
-        }
-        EmitCopyLenLastDistance(matched, commands);
-        BROTLI_LOG(("[CompressFragment] pos = %d distance = %d\n"
-                    "[CompressFragment] pos = %d insert = %d copy = %d\n"
-                    "[CompressFragment] pos = %d distance = %d\n",
-                    (int)(base - base_ip), (int)distance,
-                    (int)(base - base_ip) + 2, 0, (int)matched - 2,
-                    (int)(base - base_ip) + 2, (int)distance));
-
-        next_emit = ip;
-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        {
-          /* We could immediately start working at ip now, but to improve
-             compression we first update "table" with the hashes of some
-             positions within the last copy. */
-          uint64_t input_bytes;
-          uint32_t cur_hash;
-          uint32_t prev_hash;
-          if (min_match == 4) {
-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
-            cur_hash = HashBytesAtOffset(input_bytes, 3, shift, min_match);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 3);
-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 2);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 1);
-          } else {
-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 5);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 5);
-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 4);
-            prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 3);
-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 2);
-            cur_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 2);
-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 1);
-          }
-
-          candidate = base_ip + table[cur_hash];
-          table[cur_hash] = (int)(ip - base_ip);
-        }
-      }
-
-      while (ip - candidate <= MAX_DISTANCE &&
-          IsMatch(ip, candidate, min_match)) {
-        /* We have a 6-byte match at ip, and no need to emit any
-           literal bytes prior to ip. */
-        const uint8_t* base = ip;
-        size_t matched = min_match + FindMatchLengthWithLimit(
-            candidate + min_match, ip + min_match,
-            (size_t)(ip_end - ip) - min_match);
-        ip += matched;
-        last_distance = (int)(base - candidate);  /* > 0 */
-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
-        EmitCopyLen(matched, commands);
-        EmitDistance((uint32_t)last_distance, commands);
-        BROTLI_LOG(("[CompressFragment] pos = %d insert = %d copy = %d\n"
-                    "[CompressFragment] pos = %d distance = %d\n",
-                    (int)(base - base_ip), 0, (int)matched,
-                    (int)(base - base_ip), (int)last_distance));
-
-        next_emit = ip;
-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        {
-          /* We could immediately start working at ip now, but to improve
-             compression we first update "table" with the hashes of some
-             positions within the last copy. */
-          uint64_t input_bytes;
-          uint32_t cur_hash;
-          uint32_t prev_hash;
-          if (min_match == 4) {
-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
-            cur_hash = HashBytesAtOffset(input_bytes, 3, shift, min_match);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 3);
-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 2);
-            prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 1);
-          } else {
-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 5);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 5);
-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 4);
-            prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 3);
-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 2);
-            cur_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 2);
-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
-            table[prev_hash] = (int)(ip - base_ip - 1);
-          }
-
-          candidate = base_ip + table[cur_hash];
-          table[cur_hash] = (int)(ip - base_ip);
-        }
-      }
-
-      next_hash = Hash(++ip, shift, min_match);
-    }
-  }
-
-emit_remainder:
-  BROTLI_DCHECK(next_emit <= ip_end);
-  /* Emit the remaining bytes as literals. */
-  if (next_emit < ip_end) {
-    const uint32_t insert = (uint32_t)(ip_end - next_emit);
-    EmitInsertLen(insert, commands);
-    BROTLI_LOG(("[CompressFragment] pos = %d insert = %d copy = %d\n",
-                (int)(next_emit - base_ip), insert, 2));
-    memcpy(*literals, next_emit, insert);
-    *literals += insert;
-  }
-}
-
-static void StoreCommands(BrotliTwoPassArena* s,
-                          const uint8_t* literals, const size_t num_literals,
-                          const uint32_t* commands, const size_t num_commands,
-                          size_t* storage_ix, uint8_t* storage) {
-  static const uint32_t kNumExtraBits[128] = {
-      0,  0,  0,  0,  0,  0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,
-      6,  7,  8,  9,  10, 12, 14, 24, 0,  0,  0,  0,  0,  0,  0,  0,
-      1,  1,  2,  2,  3,  3,  4,  4,  0,  0,  0,  0,  0,  0,  0,  0,
-      1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  7,  8,  9,  10, 24,
-      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-      1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,  7,  7,  8,  8,
-      9,  9,  10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
-      17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24,
-  };
-  static const uint32_t kInsertOffset[24] = {
-      0,  1,  2,  3,  4,   5,   6,   8,   10,   14,   18,   26,
-      34, 50, 66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594,
-  };
-
-  size_t i;
-  memset(s->lit_histo, 0, sizeof(s->lit_histo));
-  /* TODO(eustas): is that necessary? */
-  memset(s->cmd_depth, 0, sizeof(s->cmd_depth));
-  /* TODO(eustas): is that necessary? */
-  memset(s->cmd_bits, 0, sizeof(s->cmd_bits));
-  memset(s->cmd_histo, 0, sizeof(s->cmd_histo));
-  for (i = 0; i < num_literals; ++i) {
-    ++s->lit_histo[literals[i]];
-  }
-  BrotliBuildAndStoreHuffmanTreeFast(s->tmp_tree, s->lit_histo, num_literals,
-                                     /* max_bits = */ 8, s->lit_depth,
-                                     s->lit_bits, storage_ix, storage);
-
-  for (i = 0; i < num_commands; ++i) {
-    const uint32_t code = commands[i] & 0xFF;
-    BROTLI_DCHECK(code < 128);
-    ++s->cmd_histo[code];
-  }
-  s->cmd_histo[1] += 1;
-  s->cmd_histo[2] += 1;
-  s->cmd_histo[64] += 1;
-  s->cmd_histo[84] += 1;
-  BuildAndStoreCommandPrefixCode(s, storage_ix, storage);
-
-  for (i = 0; i < num_commands; ++i) {
-    const uint32_t cmd = commands[i];
-    const uint32_t code = cmd & 0xFF;
-    const uint32_t extra = cmd >> 8;
-    BROTLI_DCHECK(code < 128);
-    BrotliWriteBits(s->cmd_depth[code], s->cmd_bits[code], storage_ix, storage);
-    BrotliWriteBits(kNumExtraBits[code], extra, storage_ix, storage);
-    if (code < 24) {
-      const uint32_t insert = kInsertOffset[code] + extra;
-      uint32_t j;
-      for (j = 0; j < insert; ++j) {
-        const uint8_t lit = *literals;
-        BrotliWriteBits(s->lit_depth[lit], s->lit_bits[lit], storage_ix,
-                        storage);
-        ++literals;
-      }
-    }
-  }
-}
-
-/* Acceptable loss for uncompressible speedup is 2% */
-#define MIN_RATIO 0.98
-#define SAMPLE_RATE 43
-
-static BROTLI_BOOL ShouldCompress(BrotliTwoPassArena* s,
-    const uint8_t* input, size_t input_size, size_t num_literals) {
-  double corpus_size = (double)input_size;
-  if ((double)num_literals < MIN_RATIO * corpus_size) {
-    return BROTLI_TRUE;
-  } else {
-    const double max_total_bit_cost = corpus_size * 8 * MIN_RATIO / SAMPLE_RATE;
-    size_t i;
-    memset(s->lit_histo, 0, sizeof(s->lit_histo));
-    for (i = 0; i < input_size; i += SAMPLE_RATE) {
-      ++s->lit_histo[input[i]];
-    }
-    return TO_BROTLI_BOOL(BitsEntropy(s->lit_histo, 256) < max_total_bit_cost);
-  }
-}
-
-static void RewindBitPosition(const size_t new_storage_ix,
-                              size_t* storage_ix, uint8_t* storage) {
-  const size_t bitpos = new_storage_ix & 7;
-  const size_t mask = (1u << bitpos) - 1;
-  storage[new_storage_ix >> 3] &= (uint8_t)mask;
-  *storage_ix = new_storage_ix;
-}
-
-static void EmitUncompressedMetaBlock(const uint8_t* input, size_t input_size,
-                                      size_t* storage_ix, uint8_t* storage) {
-  BrotliStoreMetaBlockHeader(input_size, 1, storage_ix, storage);
-  *storage_ix = (*storage_ix + 7u) & ~7u;
-  memcpy(&storage[*storage_ix >> 3], input, input_size);
-  *storage_ix += input_size << 3;
-  storage[*storage_ix >> 3] = 0;
-}
-
-static BROTLI_INLINE void BrotliCompressFragmentTwoPassImpl(
-    BrotliTwoPassArena* s, const uint8_t* input, size_t input_size,
-    BROTLI_BOOL is_last, uint32_t* command_buf, uint8_t* literal_buf,
-    int* table, size_t table_bits, size_t min_match,
-    size_t* storage_ix, uint8_t* storage) {
-  /* Save the start of the first block for position and distance computations.
-  */
-  const uint8_t* base_ip = input;
-  BROTLI_UNUSED(is_last);
-
-  while (input_size > 0) {
-    size_t block_size =
-        BROTLI_MIN(size_t, input_size, kCompressFragmentTwoPassBlockSize);
-    uint32_t* commands = command_buf;
-    uint8_t* literals = literal_buf;
-    size_t num_literals;
-    CreateCommands(input, block_size, input_size, base_ip, table,
-                   table_bits, min_match, &literals, &commands);
-    num_literals = (size_t)(literals - literal_buf);
-    if (ShouldCompress(s, input, block_size, num_literals)) {
-      const size_t num_commands = (size_t)(commands - command_buf);
-      BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
-      /* No block splits, no contexts. */
-      BrotliWriteBits(13, 0, storage_ix, storage);
-      StoreCommands(s, literal_buf, num_literals, command_buf, num_commands,
-                    storage_ix, storage);
-    } else {
-      /* Since we did not find many backward references and the entropy of
-         the data is close to 8 bits, we can simply emit an uncompressed block.
-         This makes compression speed of uncompressible data about 3x faster. */
-      EmitUncompressedMetaBlock(input, block_size, storage_ix, storage);
-    }
-    input += block_size;
-    input_size -= block_size;
-  }
-}
-
-#define FOR_TABLE_BITS_(X) \
-  X(8) X(9) X(10) X(11) X(12) X(13) X(14) X(15) X(16) X(17)
-
-#define BAKE_METHOD_PARAM_(B)                                                  \
-static BROTLI_NOINLINE void BrotliCompressFragmentTwoPassImpl ## B(            \
-    BrotliTwoPassArena* s, const uint8_t* input, size_t input_size,            \
-    BROTLI_BOOL is_last, uint32_t* command_buf, uint8_t* literal_buf,          \
-    int* table, size_t* storage_ix, uint8_t* storage) {                        \
-  size_t min_match = (B <= 15) ? 4 : 6;                                        \
-  BrotliCompressFragmentTwoPassImpl(s, input, input_size, is_last, command_buf,\
-      literal_buf, table, B, min_match, storage_ix, storage);                  \
-}
-FOR_TABLE_BITS_(BAKE_METHOD_PARAM_)
-#undef BAKE_METHOD_PARAM_
-
-void duckdb_brotli::BrotliCompressFragmentTwoPass(
-    BrotliTwoPassArena* s, const uint8_t* input, size_t input_size,
-    BROTLI_BOOL is_last, uint32_t* command_buf, uint8_t* literal_buf,
-    int* table, size_t table_size, size_t* storage_ix, uint8_t* storage) {
-  const size_t initial_storage_ix = *storage_ix;
-  const size_t table_bits = Log2FloorNonZero(table_size);
-  switch (table_bits) {
-#define CASE_(B)                                      \
-    case B:                                           \
-      BrotliCompressFragmentTwoPassImpl ## B(         \
-          s, input, input_size, is_last, command_buf, \
-          literal_buf, table, storage_ix, storage);   \
-      break;
-    FOR_TABLE_BITS_(CASE_)
-#undef CASE_
-    default: BROTLI_DCHECK(0); break;
-  }
-
-  /* If output is larger than single uncompressed block, rewrite it. */
-  if (*storage_ix - initial_storage_ix > 31 + (input_size << 3)) {
-    RewindBitPosition(initial_storage_ix, storage_ix, storage);
-    EmitUncompressedMetaBlock(input, input_size, storage_ix, storage);
-  }
-
-  if (is_last) {
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
-    *storage_ix = (*storage_ix + 7u) & ~7u;
-  }
-}
-
-#undef FOR_TABLE_BITS_
-
-
diff --git a/src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.h b/src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.h
deleted file mode 100644
index d4edb537b..000000000
--- a/src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function for fast encoding of an input fragment, independently from the input
-   history. This function uses two-pass processing: in the first pass we save
-   the found backward matches and literal bytes into a buffer, and in the
-   second pass we emit them into the bit stream using prefix codes built based
-   on the actual command and literal byte histograms. */
-
-#ifndef BROTLI_ENC_COMPRESS_FRAGMENT_TWO_PASS_H_
-#define BROTLI_ENC_COMPRESS_FRAGMENT_TWO_PASS_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "entropy_encode.h"
-
-namespace duckdb_brotli {
-
-/* TODO(eustas): turn to macro. */
-static const size_t kCompressFragmentTwoPassBlockSize = 1 << 17;
-
-typedef struct BrotliTwoPassArena {
-  uint32_t lit_histo[256];
-  uint8_t lit_depth[256];
-  uint16_t lit_bits[256];
-
-  uint32_t cmd_histo[128];
-  uint8_t cmd_depth[128];
-  uint16_t cmd_bits[128];
-
-  /* BuildAndStoreCommandPrefixCode */
-  HuffmanTree tmp_tree[2 * BROTLI_NUM_LITERAL_SYMBOLS + 1];
-  uint8_t tmp_depth[BROTLI_NUM_COMMAND_SYMBOLS];
-  uint16_t tmp_bits[64];
-} BrotliTwoPassArena;
-
-/* Compresses "input" string to the "*storage" buffer as one or more complete
-   meta-blocks, and updates the "*storage_ix" bit position.
-
-   If "is_last" is 1, emits an additional empty last meta-block.
-
-   REQUIRES: "input_size" is greater than zero, or "is_last" is 1.
-   REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24).
-   REQUIRES: "command_buf" and "literal_buf" point to at least
-              kCompressFragmentTwoPassBlockSize long arrays.
-   REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-   REQUIRES: "table_size" is a power of two
-   OUTPUT: maximal copy distance <= |input_size|
-   OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */
-BROTLI_INTERNAL void BrotliCompressFragmentTwoPass(BrotliTwoPassArena* s,
-                                                   const uint8_t* input,
-                                                   size_t input_size,
-                                                   BROTLI_BOOL is_last,
-                                                   uint32_t* command_buf,
-                                                   uint8_t* literal_buf,
-                                                   int* table,
-                                                   size_t table_size,
-                                                   size_t* storage_ix,
-                                                   uint8_t* storage);
-
-}
-
-#endif  /* BROTLI_ENC_COMPRESS_FRAGMENT_TWO_PASS_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/dictionary_hash.cpp b/src/duckdb/third_party/brotli/enc/dictionary_hash.cpp
deleted file mode 100644
index ae665b24b..000000000
--- a/src/duckdb/third_party/brotli/enc/dictionary_hash.cpp
+++ /dev/null
@@ -1,1844 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Hash table on the 4-byte prefixes of static dictionary words. */
-
-#include "../common/brotli_platform.h"
-#include "dictionary_hash.h"
-
-using namespace duckdb_brotli;
-
-/* GENERATED CODE START */
-BROTLI_INTERNAL const uint16_t duckdb_brotli::kStaticDictionaryHashWords[32768] = {
-1002,0,0,0,0,0,0,0,0,683,0,0,0,0,0,0,0,1265,0,0,0,0,0,1431,0,0,0,0,0,0,40,0,0,0,
-0,155,8,741,0,624,0,0,0,0,0,0,0,0,0,0,0,0,66,503,0,0,0,451,0,0,0,0,0,0,0,835,70,
-0,0,539,0,0,0,0,0,0,0,0,0,113,0,0,0,0,718,0,0,0,0,0,0,520,0,1070,0,0,0,0,0,1515,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,610,0,0,750,0,0,0,307,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,964,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,999,0,0,0,0,0,0,0,0,
-645,75,0,649,52,282,0,200,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1621,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,211,225,0,0,687,718,0,0,110,0,58,0,0,0,0,0,0,345,0,0,301,0,0,
-0,203,0,0,1154,674,1949,0,0,0,0,0,0,0,0,0,259,0,0,0,0,0,0,0,1275,0,0,0,1231,254,
-0,0,0,0,0,0,0,277,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,0,0,800,0,0,0,29,
-116,100,490,0,0,0,0,0,1641,0,543,0,0,0,0,41,181,0,657,0,0,202,25,0,0,0,0,0,0,0,
-0,0,0,423,0,0,0,113,0,0,0,927,963,0,976,0,206,0,0,0,0,0,0,0,0,0,2002,0,0,0,0,0,
-0,0,0,0,0,0,696,0,1170,0,0,0,0,226,13,0,769,678,551,0,0,0,0,0,0,57,0,0,0,10,188,
-0,0,0,624,0,0,0,0,0,0,0,0,0,1941,130,0,0,0,0,378,269,0,0,528,0,1146,0,0,0,1105,
-0,1616,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,656,0,1940,0,0,0,0,0,173,0,0,0,0,0,0,0,0,0,
-0,0,457,342,810,0,0,0,0,620,0,0,0,0,0,0,0,967,95,447,406,0,0,0,477,0,1268,944,
-1941,0,0,0,629,0,0,0,0,0,375,0,0,0,1636,0,0,0,0,774,0,1,1034,0,0,0,0,0,824,0,0,
-0,0,0,118,0,0,560,296,0,0,0,0,0,0,0,0,1009,894,0,0,0,0,0,0,0,0,0,0,0,0,0,1474,
-366,0,0,0,0,0,0,0,0,0,79,1723,0,0,200,0,0,0,0,0,0,0,0,1759,372,0,16,0,943,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,258,0,0,900,1839,707,30,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,2004,0,0,10,115,0,50,0,0,0,0,0,0,0,0,0,0,520,1,0,738,98,482,0,0,0,0,
-0,0,0,0,0,0,701,2,0,0,0,0,0,0,0,0,557,0,0,0,0,0,0,0,0,0,347,0,0,0,0,572,0,0,0,0,
-0,0,0,0,0,832,0,0,797,809,0,0,0,0,0,0,0,0,0,0,0,528,0,0,0,861,0,0,294,0,0,0,109,
-0,0,0,0,0,0,0,0,1187,290,266,0,0,0,0,49,50,748,0,0,466,399,0,0,0,0,0,0,0,378,0,
-519,0,0,0,0,0,0,0,0,0,0,0,0,667,351,902,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,180,
-0,0,869,0,0,0,0,0,0,0,260,0,0,0,0,0,0,0,0,0,0,523,36,0,0,587,510,809,29,260,0,0,
-0,0,0,0,0,0,570,0,565,0,1464,0,0,0,0,0,0,10,0,0,787,399,380,200,0,0,0,0,516,0,
-844,887,0,0,0,0,0,0,0,44,0,0,0,305,1655,0,0,0,0,0,0,0,0,0,0,0,0,0,0,786,10,0,0,
-0,0,0,0,0,0,0,2031,0,0,0,0,0,684,0,0,0,0,0,1480,0,0,0,27,0,0,0,395,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,813,511,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,0,0,0,206,
-496,0,0,0,0,0,909,0,891,0,0,0,0,0,0,0,0,0,687,0,0,0,1342,0,0,0,0,0,0,0,0,0,0,
-160,41,0,0,0,0,0,0,0,0,0,0,0,1718,778,0,0,0,0,0,0,0,0,0,0,1610,0,0,0,0,0,115,0,
-0,0,0,314,294,0,0,0,983,178,193,0,0,0,0,0,0,0,0,0,174,0,0,0,0,0,0,0,0,0,0,848,
-1796,0,0,0,0,0,0,221,0,687,1660,0,0,0,0,262,0,0,179,0,0,0,0,0,66,0,773,0,352,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,35,0,152,0,0,1197,0,0,0,0,0,0,0,0,0,0,0,0,560,0,0,
-564,0,0,0,797,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,556,0,819,0,0,0,0,0,0,0,0,719,544,
-637,5,0,0,0,0,0,0,0,0,0,0,0,101,0,1441,0,0,0,893,0,0,0,0,0,0,0,0,0,238,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,1296,0,0,969,1729,314,60,0,0,0,0,0,1144,0,1147,0,0,0,0,0,
-0,0,0,0,0,437,1853,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,828,0,176,0,0,0,0,0,0,434,39,0,
-0,0,0,0,159,0,0,0,902,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,270,0,0,0,0,801,556,0,0,
-0,0,0,0,0,416,19,197,369,0,0,0,0,0,0,0,0,0,28,34,0,757,0,0,898,1553,0,721,0,0,0,
-0,1012,0,0,0,0,1102,0,898,183,0,0,0,0,0,0,0,136,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,277,0,0,0,435,0,0,0,0,0,1311,0,0,0,0,
-0,0,211,437,0,0,0,28,0,0,750,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2012,0,702,
-0,808,0,0,0,0,739,166,0,0,0,0,0,0,719,170,500,0,0,0,0,0,0,0,0,1500,327,0,0,450,
-0,0,0,1318,0,0,0,1602,0,0,331,754,0,0,0,0,0,1368,0,0,557,0,0,0,799,850,0,0,0,0,
-0,0,0,0,908,0,0,0,0,0,19,62,459,0,0,0,0,0,0,0,0,0,0,0,0,1802,0,0,0,0,0,0,0,0,0,
-1397,0,0,0,0,120,238,0,0,0,0,0,0,0,0,0,0,0,1324,0,0,0,0,0,0,0,0,602,201,0,0,164,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,615,0,0,0,0,0,0,0,0,0,0,0,0,0,1243,0,0,0,0,968,0,0,
-0,0,0,0,882,0,0,0,907,329,100,0,0,0,0,0,0,0,0,0,0,0,176,26,9,0,0,265,256,0,0,0,
-0,0,0,0,0,0,643,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,610,0,0,0,0,973,2001,0,
-0,0,0,0,0,522,0,0,0,0,0,0,0,0,0,0,0,553,0,0,0,0,0,0,1582,0,1578,0,0,0,0,0,0,0,0,
-0,0,0,795,0,0,0,432,0,0,0,0,0,0,84,126,0,0,0,0,790,0,377,64,0,1529,0,0,0,0,530,
-1857,539,1104,0,0,0,0,0,0,0,0,0,0,0,0,977,0,0,0,34,0,0,0,0,0,0,0,0,0,0,0,24,26,
-0,0,918,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,183,379,0,0,0,0,0,0,0,792,
-0,0,0,0,0,0,0,0,0,1920,0,0,0,0,0,0,0,0,0,771,0,0,0,1979,0,901,254,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,140,0,0,0,0,0,440,37,0,
-508,0,0,0,513,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,533,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,752,920,0,1048,0,153,0,
-0,391,0,0,1952,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,640,0,483,69,1616,0,0,0,0,0,734,
-0,0,0,0,0,0,480,0,495,0,472,0,0,0,0,0,0,0,0,874,229,0,0,0,0,948,0,0,0,0,0,0,0,0,
-1009,748,0,555,0,0,0,0,0,0,193,0,653,0,0,0,0,0,0,0,0,0,0,984,0,0,0,172,0,0,0,0,
-0,0,0,0,83,1568,0,0,384,0,0,0,0,0,0,0,164,880,0,0,0,0,0,0,0,0,0,0,0,367,121,0,0,
-828,0,0,0,0,0,0,0,1541,0,0,0,0,0,0,0,343,0,0,0,0,0,0,0,0,561,57,0,0,0,0,0,0,0,
-926,0,0,0,0,827,0,194,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,
-0,0,0,896,1249,0,0,0,0,0,1614,0,0,0,860,0,0,0,0,0,0,0,0,964,102,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,899,0,569,0,0,0,0,795,2045,0,0,0,
-0,0,0,104,52,0,0,0,0,0,604,0,0,0,0,779,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,
-494,0,677,0,0,0,0,0,0,0,508,0,0,0,0,0,0,0,0,0,1014,0,957,0,0,630,310,0,0,0,570,
-0,0,449,0,64,537,0,0,0,0,0,0,0,244,0,0,0,0,0,0,0,0,0,0,0,0,0,0,702,1650,49,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,1279,0,0,0,0,0,0,0,896,0,0,
-178,0,0,0,0,0,0,0,0,0,0,0,0,0,808,695,0,0,0,0,539,1117,0,0,0,0,0,0,0,0,257,0,
-1003,0,0,0,1,448,0,516,0,0,960,0,125,4,0,1268,30,748,0,0,852,0,0,0,6,0,0,848,
-236,1385,862,1811,0,0,0,0,698,803,0,0,0,0,0,0,0,610,992,0,0,878,0,1847,0,0,0,0,
-0,0,0,383,0,1404,0,0,0,0,986,0,347,0,0,0,0,0,0,0,0,0,0,0,592,572,0,1411,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,606,0,0,0,0,0,0,
-0,0,0,0,0,0,0,1829,0,0,0,0,0,0,0,0,0,0,0,0,700,748,0,0,0,0,0,0,365,0,0,127,0,0,
-83,198,0,0,0,0,0,0,864,55,0,0,0,0,726,1752,0,0,0,0,0,0,0,0,0,0,0,0,0,1066,0,764,
-0,0,0,0,683,0,550,309,0,0,874,1212,0,0,0,1364,0,986,381,723,0,0,0,1573,0,0,0,0,
-0,1025,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1559,0,0,0,0,493,133,0,0,0,0,148,
-119,0,0,0,0,0,0,537,14,541,0,635,126,0,0,0,495,0,0,0,0,861,998,1009,0,0,0,0,0,0,
-0,359,368,0,0,0,0,304,1577,0,0,0,0,0,1107,0,0,0,0,0,929,0,0,0,1142,0,0,0,0,289,
-175,0,432,0,219,0,0,0,0,0,785,0,0,595,0,0,0,0,0,0,0,0,0,0,0,0,0,80,0,0,0,0,0,0,
-931,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1323,0,0,0,0,290,0,559,1751,127,0,0,0,
-934,1167,0,963,0,260,0,0,0,573,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-580,1689,0,0,0,0,0,0,0,0,0,1164,0,0,982,1922,0,63,0,0,0,0,0,793,0,0,0,0,0,0,0,0,
-0,0,0,0,0,67,790,0,0,0,0,0,0,0,0,0,0,391,443,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,271,0,0,0,0,0,0,0,0,0,0,0,1140,0,0,0,0,340,300,0,897,0,0,0,0,0,0,
-0,0,0,0,890,0,0,0,0,818,321,53,0,0,0,0,0,0,0,0,0,468,0,243,0,870,0,0,0,1765,121,
-0,0,0,180,518,0,822,419,634,0,0,0,0,0,0,0,0,0,898,0,0,0,0,454,36,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,806,0,0,0,0,0,0,0,0,0,0,0,0,1326,0,104,0,0,0,0,0,0,0,
-0,0,260,0,0,0,0,0,0,0,0,0,0,0,0,542,45,0,0,263,1516,42,0,0,0,0,0,468,0,1005,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,288,87,0,0,0,0,0,0,0,0,502,988,133,0,0,0,0,0,0,
-141,0,0,872,1842,0,0,0,0,0,0,0,0,261,619,0,0,0,0,189,246,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,678,0,0,0,0,0,0,0,0,0,0,0,0,285,35,0,517,0,0,0,0,0,0,0,0,0,0,
-540,214,667,0,74,0,0,125,0,0,0,0,0,761,131,0,0,0,0,0,0,0,0,0,0,0,0,0,333,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1338,94,0,0,0,0,0,0,0,0,0,0,0,0,449,0,646,103,
-86,641,2028,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,869,87,277,117,39,0,0,0,0,0,0,0,0,938,
-297,0,0,0,0,558,464,0,0,0,0,0,0,0,0,0,0,731,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1608,0,
-0,0,0,0,0,0,1429,0,0,733,1010,0,0,338,1656,0,0,0,1038,979,2010,0,0,0,0,0,0,0,
-1005,0,0,121,0,0,0,219,20,0,0,0,0,0,0,872,1440,0,0,0,683,0,1070,0,0,522,0,0,0,0,
-439,669,0,0,0,0,0,0,0,0,1245,0,0,0,0,0,1218,0,0,547,233,0,0,0,0,0,0,0,0,0,482,0,
-0,0,0,0,0,0,886,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,795,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,371,0,0,0,0,0,0,0,0,0,0,0,0,0,622,0,625,0,0,0,339,29,0,0,338,0,0,0,
-0,130,0,0,0,0,0,0,0,0,0,307,0,0,0,0,0,0,0,0,0,0,2044,0,0,0,0,0,0,0,0,308,770,0,
-0,0,0,0,1266,0,0,0,0,0,0,0,0,0,400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,690,739,0,0,
-0,0,0,0,0,990,0,0,0,1831,0,0,0,0,0,0,0,0,0,0,0,0,0,613,0,0,0,0,0,0,0,0,0,0,0,0,
-0,763,0,878,0,0,0,977,0,100,0,0,0,0,0,0,0,0,0,463,0,0,0,0,623,318,0,0,296,463,
-137,0,0,454,0,0,0,1527,58,0,0,0,0,0,0,0,18,48,0,0,0,0,0,729,0,0,0,442,0,0,0,0,
-40,449,0,853,0,0,0,0,0,0,227,0,0,0,0,0,0,1491,0,0,0,0,0,0,0,0,0,0,161,55,0,450,
-0,1174,62,0,207,0,0,0,0,0,0,0,0,869,0,0,0,0,80,213,0,0,0,0,0,0,0,0,0,0,354,820,
-0,0,747,0,0,0,954,0,0,1073,0,556,0,0,0,692,0,191,0,804,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,831,162,0,0,35,0,0,0,0,0,0,0,0,1235,0,0,0,0,0,1234,0,0,
-0,0,0,0,0,0,0,0,96,0,0,0,0,0,0,0,149,0,0,0,902,204,0,0,833,0,287,366,0,0,0,0,0,
-0,992,2020,0,0,0,0,0,0,0,0,0,0,0,356,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,784,0,0,567,
-630,0,0,0,539,0,0,27,0,0,0,0,0,0,0,0,0,0,755,0,0,0,0,0,0,0,0,0,0,0,0,814,0,0,0,
-0,0,0,0,0,0,0,0,0,0,987,0,0,255,761,194,0,1086,0,0,0,0,0,0,1016,0,0,1396,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,562,271,913,0,0,0,0,0,0,0,0,320,153,45,475,0,0,
-0,0,0,0,0,713,0,327,0,0,0,0,0,0,604,552,3,359,0,0,0,0,853,80,0,0,0,0,0,0,0,2016,
-6,887,0,0,0,0,975,0,961,0,0,0,0,0,916,1891,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,100,101,390,708,0,0,0,587,983,512,0,0,0,0,0,0,0,0,0,0,0,645,0,0,0,851,0,0,0,
-0,0,498,140,217,0,0,0,1448,0,0,0,0,0,0,0,0,0,905,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-643,105,0,792,0,0,0,0,0,0,0,0,0,0,0,0,56,0,0,0,0,0,0,0,0,0,0,535,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1748,0,0,0,0,0,754,0,0,0,0,0,0,0,0,0,0,0,0,91,0,0,1565,0,91,792,
-939,3,370,0,0,0,0,95,0,0,0,0,551,7,619,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1150,0,
-0,0,0,0,0,0,0,0,0,0,0,0,671,0,0,0,0,0,888,368,149,0,0,105,1134,0,983,0,0,458,31,
-0,643,0,0,0,312,0,740,0,0,0,1642,0,0,0,0,0,0,0,236,0,0,0,0,0,0,0,59,68,0,0,0,0,
-0,867,795,0,0,0,0,970,1977,0,0,0,0,0,0,0,1148,0,775,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,970,0,0,0,0,0,0,0,0,0,665,71,0,0,0,0,827,0,0,0,0,0,0,0,0,0,
-0,479,0,0,0,0,0,0,0,0,99,607,0,0,0,0,0,0,0,1960,0,0,0,793,0,0,871,41,0,0,241,94,
-0,0,0,0,209,0,0,1497,0,0,0,0,0,0,0,0,0,98,0,0,0,463,0,0,0,0,291,0,0,0,0,0,0,0,0,
-0,0,984,0,0,0,0,0,205,0,0,0,0,0,0,205,42,0,801,0,0,0,0,0,635,0,0,533,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,371,0,1282,0,0,0,825,0,0,0,0,0,0,0,0,0,357,879,467,0,317,0,0,
-0,0,0,0,0,924,0,0,0,0,849,1795,0,0,0,0,895,1799,43,0,0,0,0,0,0,0,0,0,0,1820,0,0,
-0,0,0,0,0,525,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,0,493,0,174,417,0,0,
-0,0,0,583,733,0,0,0,0,0,0,481,215,0,0,0,0,477,0,0,0,0,0,0,0,0,308,0,0,0,0,0,0,0,
-0,297,126,0,0,361,1551,0,0,0,0,0,0,871,1807,0,0,0,0,0,1307,0,685,0,0,0,0,0,0,0,
-797,0,858,0,565,0,0,0,0,0,0,0,0,0,0,0,0,434,252,826,0,0,0,0,0,0,791,0,0,0,0,509,
-231,178,601,0,0,0,0,0,0,0,0,43,1591,0,0,0,0,0,1683,0,0,0,0,45,0,0,0,0,0,0,0,0,0,
-0,1120,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,556,494,0,398,0,0,0,1030,0,0,0,0,0,0,
-168,0,0,0,0,0,0,0,0,0,0,973,0,642,0,0,0,0,0,0,0,0,0,1615,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,378,594,0,1093,0,679,112,0,0,0,0,1492,540,1374,714,
-1486,0,0,0,0,825,1511,0,0,0,0,0,0,0,0,0,0,0,0,0,952,0,0,736,143,0,700,0,1540,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1557,0,0,0,860,990,0,0,0,807,0,0,0,0,0,131,
-515,0,646,0,0,0,0,117,728,508,121,0,0,0,0,0,0,357,0,0,0,0,0,0,237,0,0,0,0,0,0,0,
-0,0,1784,0,0,0,0,0,0,0,0,0,0,0,713,348,1536,0,738,0,0,0,0,0,0,0,434,0,0,0,0,0,0,
-366,1877,39,0,0,0,0,0,0,580,0,0,0,0,0,0,0,0,0,0,0,0,0,0,873,0,0,0,0,171,0,625,
-550,107,343,943,0,0,0,0,0,0,0,768,0,0,0,0,0,0,0,799,0,0,0,894,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1673,0,0,0,0,0,0,0,0,0,0,0,1052,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-272,0,441,0,0,3,9,0,0,0,1182,0,1346,0,0,0,0,0,0,0,0,682,0,0,1004,24,0,0,968,0,0,
-0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,185,0,0,0,578,
-474,0,0,0,0,0,0,0,0,0,0,0,0,0,0,113,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,556,0,0,0,0,0,0,16,1317,0,0,97,0,0,0,703,0,0,0,0,0,0,0,0,892,0,0,0,1571,0,0,
-426,186,0,1101,0,0,0,0,0,0,0,0,937,585,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,644,291,
-0,0,0,0,749,0,162,0,0,381,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,762,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,628,21,0,0,0,0,0,0,0,0,919,0,0,0,0,0,0,0,0,0,
-633,0,0,0,0,332,0,0,0,0,0,0,0,0,0,1489,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,832,398,0,645,0,0,0,13,0,0,0,0,0,0,0,0,0,0,20,0,800,0,0,0,0,0,0,0,0,0,
-0,0,0,0,1993,0,0,0,0,769,0,0,0,665,0,0,0,0,0,0,0,0,0,0,1426,0,0,0,0,60,0,0,0,
-641,1874,0,644,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1757,0,0,0,0,0,937,0,1652,0,654,0,
-0,0,0,0,0,0,527,0,0,0,0,0,0,0,0,0,0,0,0,0,226,0,0,0,0,0,1486,0,0,0,0,0,0,0,0,0,
-0,0,325,0,0,0,0,0,0,0,1345,0,0,91,0,404,0,0,0,0,0,0,0,0,0,0,0,0,973,0,0,0,0,0,0,
-0,1176,0,549,0,0,0,0,0,0,0,0,0,0,976,0,0,0,0,0,21,0,0,0,0,0,51,0,0,0,0,314,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,198,6,0,1093,0,0,0,0,0,0,0,0,0,
-0,0,0,0,1776,0,0,0,0,0,1528,0,419,0,0,0,0,0,0,0,0,76,138,0,0,0,0,638,29,0,0,0,0,
-0,0,0,1418,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1710,0,0,0,0,0,
-0,0,0,0,0,0,0,532,23,0,0,0,0,0,0,0,862,0,0,946,592,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,70,0,0,0,0,0,0,0,0,0,812,0,0,0,76,0,0,988,0,442,0,0,0,896,0,0,0,0,0,0,
-483,0,0,0,0,1709,0,0,0,0,0,0,119,0,0,0,117,0,309,0,0,0,0,0,596,976,0,0,0,0,0,0,
-0,0,0,0,0,768,0,0,0,0,0,0,0,0,0,518,0,0,0,0,0,0,0,0,0,0,0,0,0,0,863,0,0,0,24,
-145,1020,0,0,1984,0,0,0,0,0,0,0,658,0,0,0,0,0,0,0,0,0,0,106,1827,0,1010,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,582,87,0,0,0,0,0,0,0,267,0,0,0,703,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,496,0,0,0,0,1121,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,249,561,0,0,0,0,0,
-0,0,760,0,0,154,0,0,0,255,0,419,323,0,0,0,0,0,368,0,0,0,0,0,0,0,0,0,0,522,0,0,0,
-0,0,0,0,551,562,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,92,0,0,0,0,
-0,0,0,284,525,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,958,0,0,594,0,0,0,0,0,0,6,479,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,61,0,0,0,0,0,0,0,820,1641,0,1556,0,0,0,0,0,0,0,302,0,0,
-0,0,0,148,0,0,676,0,0,0,0,0,0,1674,0,0,0,0,0,0,178,0,0,0,0,0,0,0,94,389,0,0,0,0,
-91,8,0,0,0,0,0,0,0,0,0,0,112,0,0,0,0,0,0,0,0,0,0,747,0,0,0,0,0,0,0,1746,0,0,0,0,
-0,24,0,1352,158,1530,0,0,718,130,280,1401,0,0,0,0,0,1946,8,0,0,0,0,1607,0,0,0,0,
-0,0,882,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,417,0,0,0,1597,633,433,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,234,0,0,0,0,0,0,0,0,680,1950,0,0,0,0,249,5,0,0,0,
-0,0,0,0,0,0,1216,0,1773,0,0,0,0,0,0,0,0,0,0,0,0,0,0,509,180,0,0,0,0,0,0,0,1002,
-0,0,0,0,0,0,0,0,0,0,0,0,0,931,0,0,0,0,0,0,0,0,747,943,0,1837,0,0,0,0,0,0,0,641,
-0,0,0,0,280,0,0,0,5,0,0,0,0,0,72,545,0,0,0,0,0,0,0,0,0,742,0,0,254,151,872,0,0,
-0,0,0,0,0,0,0,0,0,0,921,0,0,517,833,0,1680,0,0,436,251,584,0,0,0,0,0,0,0,0,0,0,
-0,24,500,0,0,0,0,0,0,0,0,195,1775,514,389,0,0,0,0,0,0,0,743,0,0,0,0,0,0,292,0,0,
-0,227,1283,774,1805,0,0,0,0,0,0,0,0,0,0,119,81,0,0,0,0,0,0,0,0,0,0,0,0,0,0,913,
-1910,0,0,0,1826,490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1162,700,30,
-0,0,0,721,839,0,0,0,617,0,0,0,0,0,0,0,0,0,169,428,0,0,0,0,0,1648,637,1205,0,0,0,
-1596,0,0,4,266,0,0,0,0,0,0,0,0,0,0,0,862,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,
-0,279,157,391,604,0,0,713,945,877,973,0,0,0,0,0,0,0,0,0,0,0,0,0,0,859,567,628,
-1846,0,0,0,0,0,0,0,0,0,762,0,0,191,0,0,0,0,298,0,0,767,909,0,0,0,0,0,0,0,795,0,
-0,301,0,0,1970,0,0,0,0,0,0,0,0,0,1236,0,0,0,0,0,0,644,369,15,0,160,71,0,0,0,0,0,
-1447,0,0,0,0,0,0,0,0,735,1255,76,0,0,0,0,0,0,0,0,0,0,474,0,0,0,0,0,0,0,0,0,0,
-841,0,0,0,0,0,0,0,0,0,0,836,0,0,0,0,0,1622,0,0,735,0,0,0,0,1601,804,1390,394,0,
-0,0,0,0,0,96,0,289,0,0,35,688,0,0,0,667,0,513,0,0,0,0,0,0,0,2034,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,704,0,1524,0,1078,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,306,
-0,0,0,0,0,0,0,431,0,1196,0,0,54,0,15,1448,0,1418,0,0,0,0,0,0,0,0,0,907,0,0,0,0,
-0,0,194,1767,0,0,0,0,0,840,0,900,0,0,0,0,0,0,0,0,0,0,0,1436,0,0,0,0,642,1560,0,
-0,0,0,0,0,94,386,0,0,0,0,0,0,0,0,0,0,830,416,0,0,20,731,0,0,0,0,0,0,0,0,697,0,0,
-662,0,0,0,0,0,0,0,0,0,861,0,0,0,0,0,0,0,871,671,864,0,928,7,0,332,0,0,0,0,1055,
-0,0,0,0,0,0,986,0,0,0,0,0,44,76,0,0,0,0,0,0,0,0,0,0,300,0,0,0,0,0,0,0,175,518,
-831,1108,0,0,0,836,0,1852,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,843,1804,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,246,0,0,0,610,202,0,0,36,0,0,0,240,654,13,0,0,0,0,0,0,0,
-0,391,0,403,0,0,0,0,0,0,0,0,0,0,75,0,366,815,0,0,631,0,0,0,0,0,0,0,0,345,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,952,0,0,0,0,0,0,0,0,0,0,0,673,35,662,0,287,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,5,34,0,0,0,0,0,0,0,0,151,0,427,0,0,382,0,0,0,329,0,0,279,0,0,0,
-0,0,0,0,0,0,0,906,0,0,366,843,0,1443,0,1372,992,0,36,123,0,649,0,0,0,0,0,767,0,
-1018,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,995,0,0,0,0,0,0,0,72,368,0,0,1345,0,0,0,
-589,0,0,0,0,0,0,0,0,0,1988,0,0,220,541,0,0,0,686,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,32,196,0,0,0,0,0,0,0,0,0,0,0,0,0,381,0,0,0,0,0,0,0,0,0,1452,0,
-0,0,616,0,0,0,0,0,0,0,0,0,1229,0,0,0,0,0,0,0,0,0,0,667,120,0,0,0,0,0,0,0,1146,0,
-0,0,0,0,0,0,0,0,0,0,352,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,935,0,1050,0,
-147,88,0,0,923,0,0,0,0,0,934,0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,341,222,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,
-637,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1159,0,0,0,847,0,0,0,0,0,0,683,0,867,944,0,0,
-0,0,0,1809,0,0,0,0,0,0,0,0,0,0,395,170,0,0,0,0,0,0,0,0,0,0,618,535,0,1625,0,0,0,
-0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,778,0,0,0,0,0,46,0,2032,0,0,37,
-1458,0,938,363,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,314,0,0,0,0,0,0,889,0,0,0,0,0,0,0,
-0,0,0,0,462,0,0,0,0,525,0,0,23,0,0,0,0,0,0,0,0,0,0,0,676,0,0,0,0,0,0,0,0,0,0,0,
-0,498,725,0,0,0,0,7,0,0,0,0,773,0,0,0,164,0,0,0,0,0,0,0,0,936,583,659,1462,0,
-220,0,0,0,0,803,0,0,544,119,0,0,0,0,0,0,0,0,0,0,0,181,176,0,1192,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,1878,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,0,0,0,0,0,
-944,0,0,0,0,0,0,0,273,0,0,0,0,0,855,0,0,0,0,5,127,0,0,0,0,0,0,0,0,752,230,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,162,0,654,48,156,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,197,
-0,0,0,0,0,0,0,963,0,0,0,0,0,0,0,0,0,0,858,0,0,0,0,0,0,0,0,0,0,676,1978,0,0,102,
-972,0,0,0,0,0,0,0,361,0,461,0,0,0,472,0,0,0,0,0,0,0,0,0,0,0,0,0,0,747,905,0,0,0,
-155,0,0,0,0,0,0,0,0,0,0,319,163,0,0,0,0,0,0,0,0,0,848,0,0,36,631,0,0,0,0,0,1769,
-0,0,0,0,0,144,0,0,0,0,0,0,0,0,0,0,369,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,555,247,0,0,
-996,0,0,189,0,0,0,0,0,0,0,0,0,0,280,0,0,0,0,0,0,0,0,0,0,0,526,746,0,0,345,0,0,0,
-1017,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,651,428,0,0,0,1162,230,327,546,792,0,0,0,
-1203,0,0,0,0,0,0,0,0,0,672,189,0,0,0,0,0,0,99,0,0,0,298,0,0,0,0,0,0,555,397,0,0,
-0,0,0,1157,0,0,0,0,0,0,0,0,0,0,398,1523,0,366,0,0,787,0,0,0,282,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,157,0,941,0,0,0,0,0,1336,0,0,116,0,0,0,0,0,0,787,0,0,0,0,0,0,0,0,0,
-0,170,160,0,1815,0,0,0,0,0,866,0,0,0,0,0,0,0,0,0,689,0,0,0,0,820,0,498,108,0,0,
-0,1119,0,0,0,244,609,1005,0,581,0,0,0,0,0,895,0,0,0,1898,0,0,0,0,0,926,0,0,0,0,
-0,0,0,0,0,0,0,0,0,538,496,294,301,0,0,0,18,0,0,757,0,0,0,0,0,1263,0,820,0,722,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2028,0,0,0,0,124,1875,0,0,0,881,0,0,0,1348,
-0,0,0,0,0,0,0,911,0,954,0,0,0,0,414,0,0,0,0,517,0,0,0,0,0,816,0,0,0,0,0,0,0,0,
-713,0,0,0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,593,150,0,0,0,0,
-0,553,0,0,0,0,0,0,0,0,0,0,108,0,0,0,0,420,0,0,0,0,0,0,0,0,0,0,0,1777,0,0,55,493,
-0,0,81,0,321,980,0,0,0,0,0,0,0,0,0,0,0,0,0,0,362,112,0,74,0,0,0,0,0,0,0,625,0,0,
-0,0,0,0,377,16,0,0,61,281,0,0,0,0,0,0,0,0,0,0,0,0,0,0,224,1031,0,0,0,0,0,0,51,0,
-0,0,0,0,0,0,211,309,15,125,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,789,173,0,439,9,648,
-0,0,294,0,0,0,0,0,0,0,374,8,0,1099,0,0,0,0,0,0,0,575,0,0,0,518,0,0,0,702,0,0,0,
-0,0,0,87,0,0,0,438,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,464,122,0,0,0,1802,0,0,0,0,
-0,0,499,0,0,0,87,476,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,840,283,0,0,0,0,1620,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,609,1160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,600,
-323,372,0,0,0,0,471,722,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,
-477,1304,0,1774,0,0,88,0,438,12,0,0,0,0,0,0,0,0,671,997,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,639,22,0,0,782,681,0,0,0,0,0,0,0,0,0,0,1013,664,0,942,0,1349,0,0,0,0,0,0,0,
-0,0,0,0,0,356,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,215,289,0,1975,
-109,450,0,0,0,0,0,0,0,0,0,0,705,0,0,664,0,0,0,0,0,0,0,1238,0,0,318,0,0,0,0,0,0,
-0,0,0,0,0,0,0,960,1872,0,0,0,0,0,0,0,0,0,0,0,0,0,0,103,0,0,0,0,0,0,0,0,0,239,
-777,0,26,0,0,0,0,0,0,0,0,0,0,0,0,375,414,0,17,0,0,0,1350,0,955,0,0,0,0,0,0,0,0,
-887,960,0,0,0,0,0,0,0,0,0,0,708,710,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,919,0,0,0,
-0,502,280,7,45,0,0,0,0,777,0,0,0,0,410,0,1110,0,0,0,0,0,0,414,341,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,787,0,0,0,436,0,0,0,0,0,0,0,1707,613,377,96,0,0,0,0,451,
-0,0,0,0,0,0,0,0,0,0,0,0,0,680,0,483,916,0,0,0,0,0,0,937,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,739,0,0,0,0,0,0,0,0,82,0,0,663,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,128,0,0,0,0,0,0,0,0,1087,0,0,0,0,0,0,0,503,0,0,0,0,0,0,9,113,104,324,0,460,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,935,702,434,485,1014,949,423,0,900,
-0,0,0,0,0,0,0,2018,574,0,0,0,0,0,0,0,0,0,0,0,0,1206,0,0,0,0,0,0,0,0,38,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,1022,0,0,0,0,143,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,2029,0,0,0,0,0,0,0,0,0,0,0,0,523,0,0,0,0,0,0,625,0,0,425,37,0,0,0,1943,0,0,0,
-0,0,765,0,0,0,0,0,0,0,0,0,0,551,0,0,0,0,0,0,0,0,0,0,0,0,168,0,0,1010,0,0,1994,0,
-0,0,91,0,0,0,0,532,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1884,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,240,15,0,0,0,1227,0,1534,0,0,0,0,0,0,0,0,0,0,0,0,0,0,392,0,
-0,0,0,0,0,0,0,0,0,0,0,655,562,395,0,0,0,501,1019,0,0,0,0,509,267,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1099,0,0,0,0,0,0,948,0,0,0,0,0,0,0,
-462,114,0,0,258,404,0,1717,0,0,0,0,82,1061,0,724,0,0,0,0,0,1133,0,0,0,0,0,0,
-1021,841,0,1021,0,0,0,0,0,0,0,0,0,0,488,373,37,0,0,0,0,564,0,0,0,0,0,513,0,0,0,
-825,0,0,899,0,0,778,0,0,12,1417,0,1116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,114,545,0,5,
-0,0,0,0,0,0,0,192,0,0,763,0,0,0,0,0,0,0,755,759,0,0,0,0,0,0,0,0,0,370,0,1237,0,
-0,0,0,0,0,298,87,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,
-0,0,0,0,814,991,0,757,57,0,0,0,0,0,0,0,0,0,540,0,0,0,0,608,0,0,0,0,0,0,0,0,1014,
-0,0,0,902,0,0,0,0,553,1668,0,0,0,0,0,0,0,0,0,559,60,0,0,0,0,0,511,0,0,675,0,0,
-156,0,0,0,0,0,0,709,0,698,0,0,0,1745,0,0,0,0,0,0,0,0,0,714,0,0,0,0,0,0,0,0,206,
-8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,776,0,0,0,0,0,0,0,0,0,1272,0,0,
-0,0,0,1059,0,0,0,0,0,0,406,0,0,0,0,0,0,0,0,0,0,947,0,0,0,0,0,0,168,0,0,0,0,0,0,
-870,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,554,0,0,0,0,784,908,0,0,0,0,0,0,
-0,396,358,0,0,0,0,0,0,0,0,2,228,0,0,0,0,0,0,0,0,0,0,0,845,14,0,716,1820,594,0,
-81,1428,0,161,0,782,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,0,0,998,0,
-0,0,0,0,0,0,0,0,0,0,0,1043,0,1496,0,0,0,0,0,0,0,0,781,0,0,0,0,0,0,0,817,1114,0,
-1814,958,0,0,0,0,812,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,139,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,236,643,0,0,0,0,0,0,0,0,0,1172,0,0,0,0,0,0,0,0,0,1338,0,0,0,
-0,0,0,0,0,0,0,0,54,0,0,0,256,0,0,351,0,955,1885,0,469,0,0,0,1270,0,744,0,313,0,
-0,0,0,0,0,0,0,402,969,0,0,0,0,0,0,50,0,0,0,0,572,0,0,0,0,847,0,0,0,0,0,0,0,248,
-43,0,369,0,0,0,0,0,0,0,0,0,0,0,0,0,766,0,363,0,0,0,0,0,0,0,0,0,0,0,678,0,0,409,
-258,82,249,0,0,0,0,0,0,0,0,0,0,0,0,32,393,0,788,0,0,0,1281,509,1968,0,0,0,0,39,
-291,0,0,0,589,0,0,54,1059,0,0,0,0,0,0,824,0,0,0,0,0,0,0,0,0,0,1005,0,1598,0,0,0,
-0,0,919,0,0,0,0,0,0,0,0,52,132,0,0,0,0,0,328,0,0,0,0,173,0,0,0,0,0,65,1411,0,0,
-0,0,0,0,0,0,0,0,442,0,842,0,0,0,0,0,0,0,0,0,534,0,0,0,0,0,0,0,0,0,0,0,0,0,845,
-210,0,0,0,0,0,0,0,0,892,0,0,223,0,0,0,0,529,0,0,0,807,0,137,218,0,1444,0,0,0,0,
-0,332,661,0,0,0,0,0,0,0,76,1517,0,0,0,0,0,0,0,0,0,0,0,418,0,0,0,0,0,0,0,0,481,
-379,0,0,0,0,0,149,18,0,0,0,0,0,0,0,0,742,304,142,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,799,925,195,51,0,0,0,0,688,0,0,0,0,697,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,1169,751,0,0,0,452,929,0,221,0,1437,0,0,0,0,955,1251,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,0,132,0,0,0,0,0,865,0,0,0,0,0,0,0,767,
-672,42,0,0,0,1050,0,0,0,0,0,0,0,0,368,44,0,0,0,0,0,0,0,570,29,0,0,0,0,0,0,227,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,522,0,0,0,0,0,0,0,1529,0,0,0,0,0,0,739,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1667,0,0,0,0,0,0,132,511,0,138,208,1020,0,0,23,565,0,344,0,0,0,
-0,0,922,0,0,0,0,0,0,0,240,0,0,415,171,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,402,0,0,754,31,716,0,982,731,0,0,0,0,0,0,0,888,0,0,0,803,847,0,0,823,
-0,0,0,0,0,0,785,0,0,2,0,0,0,0,0,0,0,532,0,0,681,0,0,314,0,384,684,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,649,447,0,1818,1007,0,321,0,66,360,0,0,0,385,0,0,0,0,0,0,
-0,900,73,254,0,0,0,0,683,1959,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,86,0,0,725,0,0,0,0,0,196,0,0,0,0,0,831,0,0,0,0,723,0,0,0,0,0,994,627,0,0,
-0,0,0,0,0,0,0,0,764,66,0,0,0,0,205,36,0,0,0,0,0,0,0,950,0,0,0,887,111,0,0,831,
-388,165,0,0,0,0,0,155,0,0,0,0,0,0,0,0,0,0,0,0,0,0,780,755,0,0,0,0,898,146,0,0,0,
-0,0,0,0,45,7,0,0,0,0,0,0,0,0,607,0,0,0,0,0,0,65,0,0,0,0,0,0,0,0,0,88,0,0,0,0,0,
-621,600,0,367,0,0,0,0,0,0,0,561,0,559,0,585,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-287,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,672,157,0,0,0,0,714,0,0,0,
-0,0,456,0,925,0,0,0,0,0,0,0,0,19,0,0,0,0,1473,0,0,0,0,0,0,0,0,0,0,113,0,0,0,0,0,
-0,0,0,0,0,0,0,0,69,463,0,0,82,193,2,471,0,0,0,0,633,0,0,0,0,0,0,1148,129,1392,
-542,803,0,0,0,0,0,0,0,0,0,0,0,0,438,0,0,0,0,0,0,875,0,0,0,0,0,237,0,0,0,0,0,0,0,
-65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,563,0,0,0,9,444,0,0,43,1260,0,0,0,0,0,0,
-971,0,0,699,0,0,0,0,0,1116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,829,242,0,
-0,593,0,0,0,0,0,0,0,0,201,36,224,0,0,0,0,0,0,1430,0,1806,0,523,0,0,212,1889,0,0,
-0,827,0,0,0,0,0,2043,136,242,0,0,0,0,0,0,284,148,10,0,0,0,0,0,0,1249,0,0,0,807,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,0,0,494,0,0,0,0,0,0,0,0,1510,0,0,0,0,0,
-0,0,0,0,0,505,1306,0,0,764,268,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,384,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1703,0,0,0,0,159,964,583,0,0,0,
-0,0,0,515,0,0,854,0,0,0,0,0,0,0,0,0,0,0,0,1123,0,0,0,0,0,0,0,136,0,0,0,0,0,1782,
-0,0,44,1287,0,0,0,0,0,732,0,0,0,0,313,679,0,0,316,0,0,0,0,595,0,0,0,0,0,0,753,
-147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,137,0,0,0,0,414,0,1762,0,0,0,0,0,0,0,0,
-0,0,0,599,0,0,0,0,0,0,0,0,0,1749,0,0,0,1627,0,488,0,0,0,0,0,83,0,0,0,0,676,0,0,
-1639,0,0,0,0,0,0,0,0,0,278,0,0,0,0,0,0,97,0,14,1085,0,0,0,0,0,0,781,388,0,849,
-59,229,0,0,0,0,0,1115,0,0,0,0,108,0,0,0,0,700,0,0,0,0,0,0,0,0,0,1414,0,0,0,0,0,
-0,0,0,0,0,0,0,0,660,737,1035,0,0,0,0,0,0,521,690,0,0,0,0,0,0,0,0,0,0,0,0,272,0,
-0,0,0,0,0,0,0,0,0,1744,0,0,0,0,0,0,128,733,0,0,277,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
-0,0,0,0,0,0,0,0,0,936,1981,40,0,0,0,0,0,0,0,0,775,0,0,0,0,0,0,0,0,0,306,0,0,0,0,
-0,0,0,979,0,0,0,0,0,611,0,0,0,0,0,178,0,0,0,1969,0,0,0,0,0,0,0,664,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,390,0,0,0,1510,0,0,0,0,0,0,0,0,0,0,0,493,0,0,37,0,0,0,0,724,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,1537,0,0,168,473,0,0,0,105,0,0,0,0,
-627,438,0,0,0,0,0,0,0,0,0,0,11,1256,0,0,0,1626,0,779,0,0,0,0,25,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,308,0,0,0,0,0,741,0,671,0,0,0,0,649,150,0,0,99,521,0,0,3,339,0,0,0,
-543,0,0,0,0,0,0,0,0,0,1358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,234,155,
-0,0,0,0,0,0,0,1628,0,766,0,0,0,0,0,0,0,0,0,0,0,0,0,829,0,0,0,1445,0,0,0,486,0,0,
-0,0,2,1635,0,0,0,0,558,0,0,0,0,0,0,0,0,0,0,1461,0,0,0,0,0,599,0,0,0,0,0,0,0,0,0,
-1376,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,447,0,0,66,1432,0,0,0,0,
-0,0,307,0,413,609,0,0,0,930,0,0,0,0,21,939,0,0,0,0,0,962,4,651,0,0,0,0,15,579,0,
-0,0,0,0,597,0,0,0,0,0,981,0,0,0,545,0,0,0,0,0,0,0,1558,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,800,17,0,0,17,0,907,0,0,0,110,0,0,0,53,458,0,1983,0,0,0,0,0,0,0,0,0,0,443,0,
-0,0,0,0,0,0,0,0,0,0,924,1844,0,1232,0,0,0,0,70,519,0,993,0,0,0,0,0,0,14,530,0,
-907,0,0,0,0,0,733,0,0,0,0,0,0,0,0,55,0,188,531,56,0,0,1693,0,0,0,0,0,0,0,0,441,
-0,192,928,0,0,0,0,0,241,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1525,0,259,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,512,185,0,464,1603,0,0,0,0,0,0,0,0,0,0,0,1113,
-284,720,0,0,722,0,0,0,0,0,13,0,0,0,0,0,0,0,4,289,43,0,0,0,0,0,0,1694,0,0,0,0,
-193,0,0,0,0,409,0,0,0,0,0,0,0,0,0,0,0,0,308,0,0,1863,0,0,0,0,0,0,0,0,0,790,0,0,
-745,1002,0,0,0,0,0,0,0,0,0,289,68,477,13,0,0,0,0,0,0,0,0,0,0,609,0,0,0,0,0,0,0,
-0,0,0,0,367,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,528,0,0,0,0,0,0,0,0,0,694,58,
-548,0,0,0,0,0,0,687,0,0,0,0,1749,0,0,0,0,0,0,0,0,1004,661,0,0,0,0,0,0,445,0,0,0,
-74,0,0,0,0,213,0,0,0,0,0,0,0,0,0,0,0,0,0,834,0,0,189,1672,0,0,0,0,0,0,0,1548,
-192,0,0,0,0,0,0,0,0,0,0,0,0,0,32,751,0,78,0,0,0,0,0,0,544,1602,105,473,0,0,0,0,
-0,0,156,1949,0,1779,0,0,0,0,0,0,0,0,0,0,0,763,0,0,0,0,0,0,0,0,29,0,0,0,0,0,0,0,
-0,0,0,883,0,0,0,0,0,0,0,488,0,617,0,0,50,0,694,1518,785,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,546,0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,1016,0,0,0,577,0,0,0,0,0,0,
-184,935,114,720,0,0,100,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,95,14,0,969,0,0,0,0,0,0,0,
-727,0,1021,0,0,0,0,0,1190,0,0,0,0,0,0,0,0,0,0,0,0,0,153,0,0,0,0,0,0,0,0,0,798,0,
-587,0,0,695,42,0,1929,141,957,0,465,7,908,0,0,450,148,0,0,0,1166,0,0,0,0,0,0,0,
-0,0,0,0,0,253,0,1003,0,0,0,0,0,0,0,0,0,0,0,46,0,0,879,0,806,0,1868,0,0,0,0,0,
-1846,0,0,0,730,0,0,0,0,0,0,0,965,0,0,0,0,506,0,0,0,10,0,0,0,22,0,0,0,0,0,0,0,0,
-0,0,0,0,0,960,296,0,0,0,0,0,0,0,0,0,0,0,587,0,0,0,0,20,0,0,0,32,982,0,0,0,0,0,0,
-0,0,0,0,941,0,0,0,0,435,0,0,0,0,0,0,71,419,0,0,0,0,0,0,688,740,94,345,0,0,679,
-582,0,0,0,0,0,0,0,945,0,0,0,0,0,0,0,0,0,0,0,0,539,0,684,1993,0,0,0,659,0,583,0,
-803,0,704,0,0,0,0,0,198,181,347,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,481,405,203,0,0,99,826,0,0,0,0,0,0,0,492,0,408,0,0,0,0,0,0,0,0,0,0,4,0,0,
-0,0,665,349,137,0,0,0,0,612,1270,0,0,0,0,0,371,0,0,0,826,0,0,0,0,21,1535,858,
-374,0,0,0,0,0,0,311,0,0,0,991,1968,0,0,0,0,494,1647,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,769,0,0,0,0,0,642,0,0,157,123,0,0,0,1435,0,0,0,0,0,0,0,0,0,0,79,0,0,0,
-0,0,0,1425,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,393,486,1690,0,0,0,0,
-0,0,0,0,0,0,0,0,756,184,0,0,0,1382,0,0,0,175,0,1493,0,1007,0,0,0,0,0,0,0,0,0,0,
-0,219,0,0,0,0,515,99,0,851,0,0,0,0,0,1278,0,0,0,0,0,0,0,1000,982,0,762,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,910,1819,0,0,0,0,0,0,906,0,0,0,0,0,0,0,0,0,0,1730,0,0,
-0,0,0,0,0,0,0,0,0,1185,0,0,0,0,0,0,0,0,40,0,0,0,147,0,0,0,0,0,0,0,0,0,0,0,0,0,
-650,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,30,0,553,0,0,20,597,0,1614,0,0,0,0,0,327,
-49,0,0,0,0,0,0,0,78,0,0,786,134,0,0,0,12,496,0,0,0,0,0,0,0,0,0,0,42,204,0,614,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,147,247,0,0,0,0,942,0,0,2023,0,0,0,0,
-0,0,67,285,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1309,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,532,0,0,0,0,0,0,0,
-1692,0,0,0,0,55,1704,0,0,0,0,988,0,0,0,223,0,0,0,0,0,0,0,57,1123,0,0,0,0,0,1764,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2015,0,0,0,1599,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,129,0,0,0,0,0,0,0,0,0,0,0,534,0,0,0,0,0,0,0,0,0,0,0,
-0,0,504,621,1248,321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1397,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,441,75,0,0,0,0,0,0,0,0,0,0,841,0,0,0,0,0,693,0,650,314,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,913,0,0,0,0,0,0,0,0,0,0,0,0,0,0,880,0,475,0,
-0,1016,179,602,111,329,0,0,0,1864,0,0,0,0,846,1888,0,0,780,0,0,0,82,0,0,0,0,821,
-0,0,0,0,0,0,0,0,0,0,0,956,112,0,0,0,261,455,0,0,0,0,0,0,337,385,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,184,1865,0,0,721,16,0,486,0,0,0,265,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,621,0,0,0,0,0,0,0,0,234,0,0,815,0,0,743,
-1987,205,197,0,0,0,0,0,0,0,0,0,314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,219,452,589,0,
-176,333,0,0,0,0,0,0,0,1110,47,0,0,0,0,0,0,0,0,0,0,0,864,0,0,300,0,1237,0,0,0,0,
-0,0,0,0,0,0,0,1685,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,135,395,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,631,0,0,0,0,0,0,835,0,0,0,606,459,0,979,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,612,0,0,0,0,0,0,0,0,158,372,0,854,0,0,0,0,0,
-0,0,1492,0,0,0,833,0,0,0,0,0,0,0,1739,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-195,0,0,0,0,0,0,0,0,730,1997,0,0,0,0,0,0,0,0,61,0,0,0,0,0,0,0,266,751,0,0,0,0,0,
-0,0,821,0,0,0,715,0,0,0,868,0,959,0,0,0,0,0,0,0,0,0,0,0,1053,0,0,0,950,0,1081,0,
-1595,0,0,0,0,59,0,0,0,0,0,0,0,0,0,0,47,684,0,0,0,0,0,0,1606,0,777,0,1020,0,0,0,
-1094,0,0,0,0,0,0,0,350,0,0,0,0,0,0,242,1812,0,0,0,967,0,0,0,473,286,0,0,0,0,0,0,
-798,629,222,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,513,337,306,0,0,0,0,0,0,0,0,0,
-146,0,0,1646,0,0,0,0,0,465,0,0,0,525,0,0,0,0,0,0,299,165,0,0,0,0,0,0,0,1064,0,0,
-0,0,0,596,0,0,0,0,0,0,0,0,0,0,0,0,0,0,238,1741,0,1233,451,1824,0,0,0,0,733,495,
-0,0,0,0,0,1204,0,0,0,559,341,0,224,21,0,0,0,0,0,0,0,0,97,1446,0,0,0,0,0,0,0,729,
-0,0,565,727,0,1948,0,0,0,519,0,0,0,0,0,0,0,0,0,1193,0,0,0,0,0,0,790,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,323,2,201,0,0,59,0,0,34,0,896,961,0,1285,0,0,46,0,479,0,0,
-0,0,549,0,663,0,0,0,0,0,783,65,682,0,0,0,0,0,11,0,0,0,0,0,522,0,0,0,52,0,0,0,0,
-0,383,0,0,0,0,0,0,0,0,127,0,0,0,0,0,397,194,0,0,635,0,0,0,0,0,0,0,0,0,0,975,0,0,
-0,0,0,0,0,0,0,0,116,0,51,0,0,858,0,1075,535,448,0,0,0,0,0,610,0,0,0,0,0,0,0,0,0,
-0,191,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,267,673,319,94,92,0,551,0,0,218,
-1406,69,256,0,0,952,1980,0,833,0,0,0,0,0,0,0,0,0,0,0,0,39,0,0,0,0,0,0,0,81,0,0,
-0,352,634,0,0,0,0,0,618,0,0,0,0,0,0,73,339,0,0,0,0,0,0,0,0,0,0,0,0,0,0,169,759,
-0,0,0,0,0,0,0,0,0,0,0,0,0,1075,0,0,0,0,0,0,482,649,0,0,0,0,0,0,0,0,386,336,0,0,
-0,1035,0,0,0,0,0,0,0,0,0,0,0,924,0,73,0,0,0,0,0,1971,0,0,0,0,0,0,0,0,0,1344,0,
-501,0,0,0,0,0,0,0,0,46,799,0,0,0,0,0,0,0,276,0,0,0,0,0,0,0,770,0,0,0,0,0,0,0,0,
-0,0,0,0,0,158,0,0,0,0,0,1432,0,0,0,0,0,0,0,0,0,0,25,0,0,2001,0,0,0,0,0,0,0,0,0,
-0,0,0,0,478,0,0,0,0,0,0,91,1461,211,602,0,0,0,0,0,0,0,0,0,1068,0,0,124,567,0,0,
-0,1006,0,0,0,0,0,0,0,0,0,735,812,0,0,323,0,0,0,304,0,0,0,0,0,0,0,0,0,148,0,0,0,
-0,0,0,0,0,0,523,0,0,144,730,0,0,981,0,0,111,0,0,132,0,0,0,0,0,0,890,0,0,0,0,0,
-444,0,1787,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,2041,932,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,937,0,995,0,0,255,0,0,138,863,965,0,0,631,0,0,0,0,1394,16,652,0,0,0,0,0,0,
-0,0,0,0,0,0,0,897,0,321,0,0,0,0,0,922,0,619,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,844,0,0,0,0,0,0,1659,0,1100,0,0,0,1173,0,1930,268,251,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,390,711,0,0,0,0,0,0,0,0,0,0,0,0,0,744,0,0,0,0,0,0,0,0,0,624,0,0,0,
-1998,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1125,0,0,0,594,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,268,0,0,0,0,0,0,0,563,0,0,0,0,0,0,0,0,2,39,0,0,0,1332,0,0,0,0,0,
-0,0,508,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,66,796,0,0,0,0,527,0,0,0,0,98,0,0,576,0,
-0,0,0,0,122,0,276,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,645,0,0,0,0,
-0,0,0,0,0,0,0,290,0,0,762,1292,0,0,0,1315,0,1955,0,0,0,0,0,0,0,0,0,0,210,131,0,
-0,0,0,797,0,38,0,11,488,0,936,0,441,0,0,0,0,0,595,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-991,0,0,0,0,0,0,0,0,0,0,0,653,0,523,0,0,0,903,0,0,0,0,0,0,0,0,0,0,0,0,80,0,0,0,
-0,0,0,0,0,0,432,0,0,314,0,0,0,0,232,1368,534,0,0,0,0,0,27,0,0,0,12,0,0,0,0,0,0,
-0,0,0,264,736,0,1657,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1117,0,127,0,0,0,1208,0,1294,
-0,0,0,0,364,0,0,0,0,0,125,1334,0,0,0,0,0,0,0,0,0,0,0,0,0,0,792,0,0,0,0,0,0,0,
-849,699,0,0,0,0,0,968,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1446,
-124,397,0,0,0,0,0,0,0,0,0,0,0,641,0,0,0,0,0,0,0,0,0,0,0,0,127,346,0,0,517,75,0,
-0,0,0,0,0,0,0,83,0,0,0,0,0,0,1031,0,0,0,0,0,0,0,1470,0,954,0,0,345,304,410,0,0,
-0,0,734,0,0,0,0,0,1822,0,0,0,1798,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,161,
-1865,69,0,0,0,0,0,0,922,0,0,0,0,0,0,0,0,0,0,0,541,0,627,0,0,0,0,0,0,0,0,0,166,0,
-0,0,0,0,0,0,0,0,849,0,0,0,0,0,0,0,717,0,0,0,0,0,0,0,0,0,0,0,0,0,0,600,0,0,0,0,0,
-0,654,0,0,188,273,0,0,0,543,0,410,87,0,0,941,0,0,186,250,0,1785,0,0,0,0,0,1339,
-462,961,0,780,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,529,0,0,0,0,0,0,474,1276,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,24,948,0,0,0,0,657,753,0,0,0,0,941,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,706,985,837,0,1861,0,0,0,0,0,0,0,0,0,0,0,0,0,0,292,933,0,0,0,0,0,
-0,0,0,0,767,0,0,0,0,0,0,0,641,0,0,0,1233,114,0,883,0,274,2008,0,1794,285,0,0,
-571,0,0,0,0,0,0,0,0,0,0,823,960,16,617,0,431,0,0,0,0,0,0,0,0,0,0,567,0,401,0,2,
-781,424,33,0,2006,0,0,274,0,0,1882,0,794,0,0,0,1848,0,0,0,0,0,0,448,47,0,0,0,
-1199,0,0,0,0,0,0,0,0,417,0,0,0,0,0,0,0,0,0,0,295,0,0,0,0,0,0,0,1019,0,0,0,0,0,0,
-0,0,0,0,0,0,0,620,0,0,0,0,464,0,0,0,0,208,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,442,0,930,0,0,0,0,0,516,68,0,0,0,0,0,1128,104,0,0,0,0,0,0,0,0,787,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,491,0,0,0,0,0,0,711,0,0,9,0,101,441,0,0,0,0,0,0,0,0,
-0,0,160,396,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,679,326,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,1128,0,0,0,0,0,737,0,1796,0,0,0,0,0,0,0,0,0,0,0,0,338,574,0,0,
-0,0,0,1096,491,405,0,0,0,0,0,1081,0,0,0,0,0,0,0,0,0,0,0,0,0,1676,0,1207,0,0,0,0,
-0,0,969,354,0,0,0,0,598,0,297,0,0,0,0,0,0,0,0,1772,751,0,37,0,0,1828,0,0,0,0,0,
-0,0,0,0,257,191,582,0,0,0,0,0,0,790,0,0,0,0,0,47,0,0,0,0,0,0,0,449,306,1011,0,0,
-0,0,0,299,0,0,0,0,0,0,837,0,0,0,0,0,0,10,329,0,0,0,0,0,1320,0,0,0,0,0,0,158,657,
-0,1191,0,0,0,0,0,0,7,0,974,1939,0,1665,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,288,
-66,0,0,0,0,494,175,0,1643,0,0,0,0,0,0,0,0,570,750,719,0,0,0,0,0,0,0,0,0,0,0,0,0,
-13,0,0,1247,0,0,221,356,0,0,0,0,0,0,0,0,0,0,694,1809,0,0,0,0,0,0,0,411,0,44,31,
-0,0,0,0,669,0,673,0,0,0,0,0,0,0,0,0,1303,704,299,0,0,0,275,0,0,216,1761,0,0,0,0,
-0,0,0,0,0,0,0,1319,0,0,428,0,0,0,0,0,0,0,0,0,0,514,0,0,0,0,0,0,49,55,102,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,364,0,0,0,0,379,0,921,971,52,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1258,0,0,0,1058,0,0,0,0,0,656,0,0,0,0,0,144,0,0,0,0,0,0,0,0,0,0,
-0,1373,10,605,0,0,0,0,0,0,0,838,0,1012,0,0,0,0,0,0,0,0,0,0,0,0,0,0,154,365,0,0,
-0,0,0,0,0,0,0,340,0,0,0,0,0,810,0,0,0,0,0,0,495,0,0,0,0,0,0,0,0,0,261,0,535,248,
-0,358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,567,445,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,697,0,0,0,1336,0,0,0,0,0,0,0,0,917,174,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,972,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,351,0,0,0,0,0,0,0,0,0,0,
-0,0,0,286,0,0,56,438,0,0,0,0,0,1950,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,738,0,0,0,0,0,
-0,0,0,0,0,969,2047,0,0,0,0,0,0,0,818,0,0,0,0,0,0,0,866,0,0,0,0,0,0,0,1467,0,0,0,
-0,0,0,0,0,0,0,0,0,0,972,0,355,0,0,0,116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,267,189,104,0,0,0,0,1613,0,0,0,0,0,0,0,116,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,886,0,86,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,45,0,0,863,0,0,0,0,0,
-0,0,1953,450,1773,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,381,0,0,0,0,0,0,0,
-0,0,0,0,0,1142,0,1189,0,0,0,663,0,0,0,0,0,0,0,846,0,0,528,0,393,378,0,0,0,0,0,0,
-325,899,680,1880,0,1770,0,0,0,0,0,648,0,0,0,0,0,0,185,167,0,2046,0,0,0,0,0,0,
-249,1645,0,152,0,0,0,1733,0,0,0,0,0,1006,0,0,0,0,0,420,0,0,0,832,0,0,0,0,0,351,
-0,0,0,0,6,40,0,0,60,0,0,0,0,1354,745,724,0,0,0,0,0,0,0,0,772,1951,275,108,639,0,
-0,0,0,0,0,0,0,0,500,1758,0,0,0,0,0,0,0,0,0,0,0,1886,711,205,0,0,965,865,0,0,0,
-534,0,0,0,0,691,0,0,0,237,443,0,878,0,0,0,0,0,1410,0,0,0,0,0,0,0,0,0,0,0,0,0,
-995,0,0,0,0,0,0,0,0,0,0,0,0,0,578,0,0,0,0,881,0,0,0,0,0,0,0,0,822,0,923,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,924,0,0,0,665,0,0,0,0,0,1901,0,0,0,0,0,950,498,93,
-0,0,0,1451,0,0,0,0,0,747,828,788,400,184,0,198,0,0,0,0,0,0,0,0,0,0,0,994,0,0,0,
-0,0,0,0,0,615,320,0,0,0,978,843,905,0,0,0,0,0,0,0,0,850,974,0,0,0,0,6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,509,0,0,0,0,0,273,0,0,0,0,0,0,0,0,0,0,0,0,0,
-201,0,0,0,1041,0,0,0,1040,0,0,0,0,0,0,0,0,0,693,234,774,0,336,0,1399,22,0,805,
-802,777,167,789,0,0,1705,0,0,0,0,0,0,0,0,0,0,0,10,13,11,0,0,204,264,0,0,56,0,0,
-1917,0,470,0,0,0,0,0,0,0,0,0,0,0,1198,0,0,0,0,0,0,0,0,0,0,1015,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,715,0,0,1002,0,0,0,298,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,867,0,0,724,0,0,0,0,0,0,0,0,0,0,0,0,768,0,0,0,0,0,1066,0,0,0,0,67,0,174,948,
-0,0,0,0,0,0,0,0,0,0,0,0,0,764,0,0,0,0,75,137,0,756,0,0,0,0,0,0,1008,842,643,0,0,
-0,67,0,0,0,0,0,0,0,0,0,0,0,135,821,0,0,0,0,0,0,0,0,736,0,389,355,0,0,786,0,0,0,
-0,0,0,2044,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1030,0,0,0,1083,0,0,0,0,0,
-1226,0,0,0,0,356,319,8,389,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,474,0,0,0,427,
-0,413,0,730,0,0,0,0,0,373,0,0,0,0,0,0,0,0,0,799,0,0,0,1793,0,0,0,322,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,89,290,2,0,0,0,0,0,0,0,0,0,0,672,
-699,1860,0,0,0,737,0,0,0,1612,0,0,0,0,0,0,0,0,0,0,0,145,124,884,0,0,0,0,0,387,0,
-0,0,0,0,0,0,0,0,0,0,679,0,550,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1305,0,0,0,0,0,0,0,
-576,0,0,0,0,0,0,0,686,0,607,0,0,37,0,0,0,0,0,0,0,0,0,101,1726,0,0,0,0,0,958,0,0,
-0,903,0,0,0,0,147,0,0,0,0,0,0,0,0,0,0,0,367,0,0,0,0,690,0,705,273,0,0,887,0,0,0,
-0,0,0,0,0,0,0,0,90,0,0,0,0,0,0,0,908,0,0,0,0,0,0,0,1261,0,0,497,1235,0,429,0,0,
-0,0,904,0,12,125,0,0,0,841,0,0,0,0,0,860,946,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,768,0,770,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,271,0,0,0,0,0,0,0,719,0,699,581,0,0,0,0,0,0,0,0,0,0,862,304,0,631,0,0,0,0,880,
-1513,0,0,0,0,0,981,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,434,0,0,0,0,0,550,0,0,476,930,
-824,553,0,0,452,0,151,0,0,0,0,0,0,772,0,292,135,0,0,0,0,0,0,0,504,0,0,1089,0,0,
-0,0,0,0,0,0,0,0,0,783,0,0,0,0,0,0,206,393,0,0,0,0,0,0,0,0,232,912,0,0,0,0,0,977,
-0,0,716,98,0,0,0,0,0,733,0,0,0,0,0,0,0,0,19,0,0,0,0,668,0,360,0,0,0,0,0,0,656,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,726,0,0,0,0,0,0,0,0,0,0,0,0,72,0,0,1269,0,0,463,0,
-0,0,0,0,0,1454,0,1287,245,0,989,0,0,0,0,0,0,0,0,0,107,164,0,0,0,0,0,0,0,1061,0,
-0,0,0,2,484,0,0,0,0,0,0,0,1127,0,0,0,0,0,0,0,460,0,0,0,0,0,932,0,0,0,0,0,0,0,
-588,625,0,0,0,0,76,92,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-763,0,622,0,0,0,253,0,546,0,0,110,0,256,916,0,0,35,212,0,0,746,0,0,0,150,0,0,
-1466,0,0,0,1299,0,0,0,0,0,0,0,0,0,1518,0,0,0,0,0,0,0,0,0,0,0,0,0,1229,0,0,0,816,
-0,0,0,0,0,0,159,0,0,0,0,0,734,869,126,1716,0,0,0,0,0,0,202,232,0,0,0,0,212,0,0,
-0,0,0,111,1003,0,0,0,0,0,0,0,0,0,0,0,1712,0,0,216,0,0,0,0,516,0,0,0,0,0,650,0,0,
-0,0,57,99,0,0,0,0,300,574,0,0,0,0,1023,0,0,302,0,1871,0,728,252,0,0,461,0,0,0,
-323,0,0,0,0,0,0,775,461,0,0,0,0,0,0,172,0,0,464,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,73,727,0,1023,0,0,0,0,0,0,0,0,0,0,577,0,0,0,0,0,0,0,0,1037,0,0,0,0,0,0,
-0,0,280,677,0,0,0,0,0,0,0,0,0,0,0,799,0,0,0,0,159,0,446,1730,0,0,0,0,0,0,0,0,0,
-395,0,0,0,0,145,0,0,0,0,0,0,0,20,0,0,426,608,0,0,0,0,0,977,0,250,0,0,0,0,0,100,
-0,0,0,0,1982,0,0,0,0,0,476,0,0,0,0,0,0,594,76,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,447,0,0,0,0,526,0,0,14,1124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,188,0,0,0,0,0,0,0,0,362,301,0,0,0,1743,0,178,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,872,0,831,0,0,208,202,0,0,0,0,0,0,0,1954,0,
-0,0,0,516,872,0,0,313,224,0,0,24,0,11,546,0,0,0,1937,242,241,46,0,0,0,830,1273,
-0,0,0,0,0,0,0,825,327,1006,0,0,0,0,0,1580,516,366,0,0,0,0,0,1736,0,0,0,0,0,0,0,
-0,0,0,0,1935,0,826,0,0,0,0,139,331,0,0,0,0,0,0,0,0,0,0,0,288,0,916,0,0,0,0,0,
-1888,0,0,0,0,0,0,0,1471,0,1570,0,394,0,0,0,0,0,0,0,1931,0,1719,0,658,228,0,0,0,
-0,0,374,0,0,0,0,735,0,0,0,0,0,0,323,498,0,1063,0,0,0,0,155,0,0,0,0,0,0,0,0,906,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1139,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,616,
-902,0,0,0,0,0,692,0,0,0,0,0,0,823,0,0,0,305,0,0,0,0,0,0,0,681,0,0,0,0,0,214,
-1004,0,0,0,0,0,0,0,23,0,0,1703,0,0,0,0,0,0,0,0,0,1443,0,0,19,714,0,0,0,0,64,737,
-0,0,345,1758,0,0,579,47,0,0,539,139,0,0,0,0,388,0,0,0,0,253,0,0,0,0,0,0,252,0,
-745,0,0,0,0,0,0,0,0,0,0,0,504,107,0,871,0,0,0,229,0,0,0,0,0,903,0,0,71,0,0,549,
-6,47,0,0,0,0,0,0,0,0,0,980,865,705,0,0,0,161,0,0,0,0,143,1331,0,0,0,1388,33,724,
-0,0,0,19,0,0,0,395,0,0,0,0,0,846,210,0,0,0,122,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,695,937,497,0,0,0,0,0,718,0,0,0,0,0,0,0,1581,0,
-0,0,0,0,0,161,49,0,0,0,0,0,0,0,0,0,597,0,0,0,1094,0,0,0,811,908,0,0,0,0,0,0,0,0,
-0,0,1471,0,0,0,0,0,0,0,0,0,0,42,1935,0,0,0,2014,66,2007,0,0,586,0,0,0,0,0,0,0,0,
-0,28,1077,0,0,0,1221,0,0,62,0,0,0,0,0,0,0,0,0,0,1766,0,0,0,0,0,0,0,0,0,0,0,0,25,
-0,499,1388,0,0,97,10,0,0,0,0,0,481,0,0,0,0,0,0,0,0,0,0,37,134,155,486,0,1442,0,
-0,0,0,0,591,0,0,0,0,0,0,310,1173,0,0,0,0,409,1156,0,0,0,482,0,0,263,926,0,0,0,0,
-0,0,0,0,0,0,0,0,0,804,0,0,0,0,0,0,0,0,0,0,0,0,0,1265,0,415,0,348,0,0,0,1012,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,165,1803,0,0,0,0,0,0,0,408,
-0,0,0,0,0,0,257,1321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1138,0,0,0,249,0,
-0,0,576,0,0,0,0,231,0,0,0,288,0,0,0,0,0,0,0,0,0,433,1487,569,1678,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,87,0,0,0,0,0,779,538,0,0,0,413,0,0,0,
-0,0,0,0,0,0,0,495,0,0,0,0,0,191,54,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,530,567,
-0,0,0,0,0,1484,0,0,0,0,0,0,815,609,0,0,0,0,0,484,0,0,0,0,0,0,0,0,0,0,900,0,0,0,
-0,1335,0,1724,0,0,0,0,0,0,0,0,0,0,0,640,0,0,0,0,0,0,0,0,0,0,0,1831,0,0,0,0,0,0,
-0,0,0,0,0,0,0,474,0,0,0,0,0,0,0,0,0,1103,0,1504,655,1034,0,0,0,0,0,305,0,0,0,0,
-0,0,0,0,0,1236,0,0,429,217,0,0,0,0,739,278,0,0,0,0,0,0,0,708,0,0,0,0,0,1840,233,
-0,0,0,0,0,0,0,0,2017,0,0,0,0,0,1488,0,0,0,1590,0,0,0,0,0,1800,28,0,0,0,0,0,0,0,
-0,0,45,0,36,0,22,1442,378,0,0,0,0,0,0,1507,0,0,0,0,0,0,0,0,0,0,39,0,0,1054,725,
-1955,0,2036,0,0,0,0,0,0,0,0,0,0,896,1871,0,0,0,0,0,0,0,0,0,0,805,0,0,0,0,2046,0,
-0,0,0,17,712,0,617,55,320,271,0,0,0,0,0,0,0,0,0,445,0,184,103,0,0,0,0,0,0,0,0,
-659,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,676,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-337,0,0,0,506,0,0,0,0,0,843,77,0,458,0,0,0,0,0,1420,382,109,142,330,0,0,0,0,0,0,
-0,0,0,0,0,0,87,0,0,0,492,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1239,0,0,0,0,0,0,
-211,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1049,0,321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,1985,0,0,122,0,0,234,0,0,0,1098,0,0,0,0,0,0,549,253,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,522,131,0,0,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,507,0,0,0,0,811,630,0,0,0,343,
-0,0,0,0,0,448,591,455,0,1381,0,0,0,0,0,0,0,575,0,0,0,0,0,1175,0,0,0,0,0,0,0,0,0,
-653,0,0,0,1761,0,1198,0,0,0,0,297,1127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,678,0,0,
-164,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,35,0,45,0,0,0,0,0,121,0,0,0,0,0,0,
-0,0,125,0,0,0,1622,0,0,0,0,0,721,145,0,0,0,970,792,0,0,0,715,0,0,0,0,0,1999,0,0,
-74,531,0,0,65,0,0,0,105,220,0,0,0,0,0,0,0,960,0,0,0,0,0,0,428,19,0,0,401,96,0,0,
-0,0,0,1595,116,0,1021,0,0,0,0,0,750,1961,0,0,148,0,0,0,0,0,0,0,0,0,0,0,0,0,75,0,
-0,1383,0,0,0,0,0,0,0,0,0,0,0,0,0,0,779,0,0,0,0,0,0,0,0,598,0,424,0,0,0,0,0,0,0,
-1222,0,0,0,876,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,133,0,0,0,0,187,0,8,0,0,0,0,0,
-0,0,429,0,685,0,0,0,0,0,0,0,0,0,0,0,132,472,0,0,0,0,0,0,0,0,0,938,0,0,874,0,0,0,
-0,0,774,0,0,0,0,0,92,0,0,0,0,0,0,830,701,0,0,0,0,0,426,350,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,603,59,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,0,441,163,4,0,
-0,0,0,0,0,0,0,0,806,0,0,0,0,0,0,233,0,0,0,0,1994,0,1739,0,0,393,0,47,1038,0,0,0,
-309,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,363,0,0,0,175,0,0,0,0,0,0,0,666,
-0,0,1675,0,1600,0,0,0,808,0,0,0,0,0,0,0,0,0,0,0,280,54,0,0,0,0,0,0,0,0,421,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,249,0,0,103,254,0,262,1,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,805,0,0,0,0,0,0,0,0,0,1630,0,0,0,0,0,0,0,0,0,0,0,0,0,671,972,989,0,0,
-0,0,0,0,0,889,0,0,0,1382,0,0,0,0,0,0,0,775,0,0,0,0,0,0,0,0,0,0,388,202,0,0,0,0,
-16,560,0,0,0,841,0,0,566,0,0,0,938,0,0,0,0,0,0,0,0,0,0,912,0,0,0,1361,0,0,0,0,0,
-0,618,236,0,1854,0,0,318,190,0,1376,0,0,0,0,0,0,0,349,0,0,0,0,951,1972,0,0,0,0,
-0,0,344,0,0,0,0,0,0,0,0,850,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,910,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,163,85,0,487,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,145,0,83,0,0,1013,0,0,0,1922,0,0,169,557,66,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,1193,82,0,352,454,57,0,0,1333,396,107,0,370,0,0,0,0,0,0,0,0,0,204,0,0,0,
-0,0,1706,0,0,0,0,0,0,0,0,0,0,0,0,394,1204,0,0,0,0,0,1007,0,0,0,1696,0,1519,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,981,0,0,0,0,1072,0,0,0,712,0,1629,0,0,0,0,0,0,0,728,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1271,0,0,0,1608,16,0,0,0,0,485,0,0,0,0,0,0,
-153,27,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1991,0,0,0,0,0,0,0,0,52,0,21,0,
-0,0,0,0,0,0,0,0,819,0,0,0,0,0,917,0,0,0,0,784,0,0,0,0,135,0,0,0,0,0,454,0,0,0,0,
-0,0,0,0,0,852,1719,0,0,0,0,0,852,0,0,0,0,0,952,0,0,0,0,568,0,0,0,0,0,448,0,0,0,
-67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1826,657,0,729,666,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-669,0,0,0,0,0,0,0,402,0,0,152,0,0,0,0,912,0,0,0,0,0,0,51,320,0,445,0,0,0,0,308,
-0,0,0,0,0,386,0,0,239,0,0,130,83,0,143,0,348,0,0,0,0,0,0,0,958,0,0,0,0,0,210,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,430,0,0,0,0,0,0,0,0,0,0,0,0,7,213,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,801,0,0,0,0,0,0,0,0,0,936,0,108,0,0,
-0,0,0,0,0,0,0,885,587,219,398,364,0,1165,0,0,342,241,303,0,0,0,0,0,0,0,0,0,0,
-1454,0,0,0,0,0,0,0,0,0,0,254,562,0,786,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1294,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,493,216,0,0,0,0,219,341,0,0,0,0,0,
-0,0,0,0,0,130,1734,154,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,701,604,0,0,879,0,195,
-666,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1669,0,0,0,1791,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1228,0,0,0,0,0,623,0,0,0,0,0,0,0,798,0,0,0,0,0,0,0,0,0,0,0,0,84,
-122,0,0,0,837,0,0,0,0,0,0,1013,0,0,577,0,0,0,460,932,0,0,0,0,0,0,0,0,0,0,0,31,
-131,0,0,0,605,0,0,0,1246,0,0,0,0,68,278,165,307,781,0,0,0,0,0,0,33,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,1113,0,0,720,1953,203,0,0,0,0,0,0,0,425,326,0,0,0,0,0,
-0,0,0,0,0,241,1316,0,0,0,0,0,416,0,0,0,1300,0,847,0,0,662,358,0,0,0,0,839,1823,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,654,1522,0,0,0,0,0,0,163,0,0,0,0,0,314,978,0,0,0,
-601,0,0,0,0,0,946,434,0,0,0,402,411,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,1467,
-410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,483,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,677,0,0,0,0,0,0,0,0,0,0,0,0,70,0,0,0,0,1405,0,0,0,0,0,0,108,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,777,0,0,0,0,0,747,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,505,0,326,0,0,164,628,654,0,0,0,
-37,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,668,152,0,0,0,0,0,0,0,0,0,0,0,581,
-0,0,0,0,44,126,89,0,0,0,0,0,0,0,0,1531,0,0,0,0,0,0,0,0,203,1167,0,0,0,0,0,0,0,0,
-531,1232,0,0,0,0,0,943,0,670,231,880,0,1617,0,0,0,1957,0,0,0,0,0,0,0,975,0,0,0,
-0,0,0,0,0,0,0,0,242,0,0,0,0,0,0,0,0,0,421,0,0,14,834,0,0,0,0,0,0,0,0,0,0,0,0,
-465,0,0,0,0,0,834,688,413,855,0,0,0,590,0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0,0,0,0,
-0,45,169,0,0,0,0,0,0,0,0,0,0,0,198,0,0,565,585,0,0,0,0,0,0,0,0,0,0,0,0,0,691,0,
-0,0,593,0,0,0,0,0,0,0,0,0,913,116,0,0,0,0,1360,0,0,0,802,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,673,308,0,709,1006,1895,0,228,0,0,0,1840,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,608,0,0,0,0,0,0,0,0,0,1573,0,2039,136,540,0,0,0,0,0,0,0,
-897,0,0,938,1878,0,0,0,0,0,0,0,0,0,1469,0,999,0,299,0,0,0,0,0,0,0,578,0,0,0,0,0,
-456,0,0,0,1679,163,693,0,0,0,0,0,0,48,755,0,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,
-1091,0,0,0,0,695,0,0,1464,0,0,0,0,0,975,0,0,335,0,0,1979,0,0,0,0,269,1566,630,
-396,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1815,634,0,0,0,966,0,0,0,0,0,0,0,9,
-412,0,958,0,0,579,382,0,212,0,0,0,0,965,681,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,655,
-0,0,0,0,67,0,0,0,0,0,0,751,0,0,0,0,423,231,0,0,1016,300,0,0,0,0,100,237,0,0,0,
-1370,0,0,0,1208,0,0,0,0,0,1219,129,0,0,0,0,0,0,0,0,0,0,0,0,0,0,199,0,0,427,0,0,
-0,0,949,665,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,712,0,0,0,0,0,1186,0,0,0,0,0,0,0,0,0,0,295,312,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-151,0,0,0,0,588,4,0,0,0,0,0,414,104,0,0,757,263,0,561,0,0,0,320,0,0,0,0,0,0,0,0,
-0,0,0,225,0,0,0,0,37,817,0,974,0,0,0,0,0,0,0,0,0,0,0,0,0,2026,131,235,16,0,590,
-1157,0,0,0,0,0,0,0,0,221,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,140,390,0,0,0,0,
-0,0,0,1144,0,0,0,464,0,0,0,0,0,0,0,0,0,0,0,0,204,407,303,1218,0,0,0,0,5,325,0,0,
-0,0,12,800,0,1783,0,0,0,0,0,0,0,0,0,0,504,621,0,0,0,0,0,0,0,0,0,920,0,376,0,0,0,
-0,0,218,580,0,768,454,0,0,0,0,0,0,0,0,0,0,0,0,676,0,0,0,0,0,0,164,0,0,0,0,0,0,0,
-0,50,0,0,0,0,0,0,0,0,0,0,0,0,0,120,285,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,226,343,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,29,0,0,1812,0,0,8,0,0,0,21,1125,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,1327,0,0,0,0,575,1598,0,0,0,0,0,0,0,0,0,895,0,0,0,959,0,0,
-0,0,0,1759,173,0,0,0,0,266,261,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,1427,0,0,300,1033,0,0,0,0,0,0,0,0,0,0,0,584,0,0,0,0,52,734,
-0,0,217,239,0,1129,0,0,0,0,0,0,0,0,732,20,0,0,0,0,0,0,0,0,0,0,0,418,0,0,0,613,0,
-0,0,0,0,0,0,0,0,632,0,0,85,984,0,0,0,0,909,694,7,1109,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,167,0,0,0,0,280,62,0,0,33,0,0,359,186,980,0,0,0,0,0,0,0,0,0,0,0,585,0,0,0,
-211,0,0,336,145,0,1130,0,873,0,0,840,263,0,0,0,0,0,0,0,0,0,916,0,0,0,0,0,0,0,0,
-0,0,155,0,0,0,461,97,0,0,0,0,0,1356,0,0,0,0,0,0,0,593,0,0,0,0,0,1392,0,0,0,0,
-126,0,0,0,0,1179,0,0,0,0,0,162,0,0,0,0,0,765,0,187,0,1286,0,0,0,0,0,0,0,0,0,635,
-0,0,23,215,0,0,0,1306,0,0,97,716,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,657,0,
-0,0,0,0,0,0,0,299,0,0,0,0,0,0,134,0,0,0,0,0,0,0,0,0,0,0,658,1082,0,0,0,0,0,2002,
-0,0,0,0,0,0,833,248,0,0,0,0,0,1654,0,0,531,0,0,0,0,0,0,634,0,0,0,0,0,0,0,0,0,
-853,573,249,0,0,0,0,0,0,0,0,527,0,0,0,0,1419,0,0,0,0,0,0,20,49,0,0,0,992,0,0,0,
-728,0,0,0,0,0,0,0,0,0,0,0,0,497,1579,0,0,0,0,62,268,0,0,0,0,0,0,0,1201,0,0,0,0,
-0,0,0,0,0,0,0,0,495,193,0,0,0,0,106,0,0,859,0,0,23,0,0,0,0,0,0,0,813,925,0,0,
-223,613,953,0,0,0,0,0,0,0,0,666,0,0,0,0,0,0,0,0,0,670,0,0,40,216,0,0,0,0,0,0,
-259,0,0,0,440,1114,0,0,0,0,0,0,0,0,74,475,0,0,188,139,0,797,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,1572,0,0,0,0,39,0,0,0,0,0,0,0,0,0,0,0,0,1594,0,0,0,0,0,0,0,290,0,232,
-0,0,887,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,521,14,0,0,0,0,0,741,0,0,0,992,0,
-0,0,0,0,0,0,0,111,0,0,425,0,0,0,0,0,789,0,0,0,1593,0,1768,0,0,233,0,0,0,0,943,0,
-0,0,0,0,0,0,955,225,245,0,0,0,0,0,0,241,0,0,0,0,1943,0,0,0,1284,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,709,0,0,0,0,0,0,554,0,0,0,0,0,0,0,0,1564,0,0,0,
-443,0,0,0,0,0,0,280,0,0,0,0,0,0,0,0,729,0,0,0,348,0,0,0,0,0,0,0,758,848,298,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,829,1422,189,121,0,0,632,812,0,0,556,0,0,0,0,0,436,172,
-530,844,232,984,0,0,0,0,0,0,0,0,0,0,147,0,0,0,0,0,0,0,0,537,0,0,0,0,0,859,0,0,
-842,0,0,0,0,0,0,0,0,0,0,1291,0,0,0,0,0,0,0,0,0,0,0,1482,612,392,0,0,0,262,31,0,
-0,0,0,0,0,0,0,0,0,753,549,0,0,0,0,0,0,696,0,0,0,0,0,0,0,834,0,0,0,0,0,771,0,0,0,
-0,0,0,0,0,0,0,0,0,0,921,0,0,0,674,0,0,0,0,0,0,0,0,0,0,308,444,0,0,0,0,0,0,805,
-180,0,0,278,271,0,0,214,505,0,1215,0,0,0,0,0,0,387,271,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,1645,42,92,0,459,0,0,330,1557,0,0,0,0,0,0,0,0,113,18,0,0,0,
-1742,0,0,0,965,0,0,0,0,0,0,0,0,0,0,0,0,0,182,0,0,65,0,0,0,0,0,0,0,0,0,0,0,0,973,
-0,0,0,0,0,328,0,0,588,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1786,
-0,0,962,1985,0,0,0,308,508,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,588,0,0,0,0,0,0,614,793,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,290,0,0,0,0,0,0,0,0,0,0,1136,0,0,0,0,0,0,0,0,0,0,796,719,0,0,
-326,210,0,0,0,701,758,472,0,0,0,1947,278,1079,0,0,0,0,0,0,497,41,0,0,634,46,961,
-0,810,524,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,532,0,997,0,0,0,0,0,0,0,0,0,0,0,1301,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1298,0,671,0,0,0,306,0,0,0,0,0,0,0,0,0,0,
-693,1823,0,0,0,759,0,0,0,0,0,1932,0,0,0,0,0,0,0,0,0,0,0,0,0,0,88,182,0,0,0,1964,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,521,0,0,0,0,0,0,424,857,0,0,0,0,671,328,0,
-529,0,0,0,0,0,716,0,1509,80,67,0,0,0,0,59,141,0,0,0,0,0,0,783,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1498,0,0,0,0,343,430,803,1183,677,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1357,53,0,0,0,0,590,0,0,0,0,0,0,0,0,0,0,
-0,0,0,329,0,0,0,0,0,0,0,469,0,0,0,0,0,0,0,0,0,0,460,0,0,1743,0,0,963,340,0,0,0,
-0,0,1603,0,0,250,0,0,0,0,0,646,218,0,1794,0,0,0,571,0,455,0,0,0,1012,0,0,0,0,0,
-0,0,0,0,0,0,0,597,161,0,349,0,524,0,0,0,0,0,0,0,0,0,0,0,0,322,432,0,0,0,0,0,0,
-325,223,0,0,0,0,0,566,0,0,0,1394,481,436,0,48,457,610,756,618,0,0,0,755,0,1217,
-0,0,0,0,0,197,0,0,0,0,0,0,0,0,0,0,0,0,0,0,544,492,107,414,0,0,0,0,0,0,0,0,0,0,0,
-1007,0,0,0,0,5,0,0,1580,0,0,0,0,0,0,0,0,0,0,0,0,0,673,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,1843,0,0,0,0,0,0,0,0,0,165,0,0,0,0,0,0,809,885,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,498,0,0,0,306,9,0,0,0,0,0,0,0,437,721,146,0,0,0,0,0,0,0,0,0,0,0,177,0,0,0,0,
-0,0,0,1377,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,200,0,959,0,0,0,1928,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1435,0,481,0,0,0,0,0,0,142,84,0,0,0,0,0,
-1015,0,0,0,315,0,0,0,0,0,0,759,0,0,0,0,0,0,0,0,712,0,0,0,1722,0,0,0,0,0,0,0,0,0,
-0,0,0,222,0,985,1414,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1273,
-538,706,0,0,0,0,0,0,0,0,115,0,0,0,0,0,0,0,0,0,0,1781,0,0,0,0,0,431,97,665,42,
-237,0,0,0,264,0,0,213,0,0,0,0,0,0,0,455,0,0,0,906,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-624,0,574,0,0,0,0,0,0,0,0,0,0,0,0,354,0,0,0,1558,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,
-235,723,1813,0,0,0,957,0,830,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,496,0,0,0,0,0,0,0,
-547,239,88,0,0,0,0,0,0,0,0,0,1310,0,0,0,0,0,0,0,0,80,1076,0,0,118,0,0,0,479,274,
-0,0,0,0,0,0,0,0,0,0,0,497,0,0,669,261,0,0,0,0,13,0,0,0,0,0,0,791,250,642,0,0,0,
-1429,939,949,0,0,0,0,0,0,0,0,0,0,0,0,0,818,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,982,330,0,0,0,0,545,0,0,0,0,0,0,947,0,1188,0,0,0,0,0,904,0,0,0,0,0,1372,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,693,377,0,0,0,0,0,0,0,0,0,0,0,0,0,0,695,0,0,
-713,386,0,0,0,0,128,1575,0,0,0,0,0,0,424,893,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,904,0,0,0,0,0,552,322,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,1808,49,0,0,0,0,
-1832,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,421,0,0,442,415,0,0,289,
-0,0,0,0,0,206,110,0,0,0,0,0,205,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-19,1539,0,0,0,0,0,1340,0,1194,0,0,0,0,0,0,0,0,549,0,0,0,0,0,0,0,0,1720,0,0,0,0,
-0,0,0,0,0,319,0,0,0,0,112,1180,0,0,0,0,0,0,0,0,0,0,0,967,0,0,0,0,0,0,0,0,0,1940,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,735,0,0,0,0,0,0,0,0,0,897,132,0,0,0,0,0,0,0,
-0,0,0,38,838,0,0,0,379,218,8,660,1017,0,0,0,0,0,0,111,387,647,877,0,0,53,790,0,
-0,0,0,0,0,0,0,458,0,0,0,0,0,0,954,0,0,0,394,0,1367,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,882,0,0,0,0,0,0,0,1409,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,38,124,342,199,0,0,0,0,
-0,0,0,0,0,0,724,628,0,0,0,0,804,266,0,0,0,0,0,208,0,79,0,0,0,0,0,0,0,0,741,0,0,
-0,0,0,0,0,0,0,0,606,0,1494,821,1553,0,0,135,405,0,0,178,100,0,0,0,0,0,0,0,0,0,0,
-0,0,0,481,0,0,0,1378,0,0,0,0,0,0,0,0,0,0,0,0,0,791,33,1227,857,0,467,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,86,128,0,0,0,0,0,0,587,0,0,0,692,1018,0,
-195,0,0,0,0,0,0,0,1546,0,0,0,0,0,0,0,0,0,0,0,684,0,0,345,0,0,0,0,0,0,365,0,1683,
-0,0,472,0,433,0,0,0,0,0,0,0,28,0,0,0,997,0,705,3,0,0,0,0,0,0,0,0,0,229,0,0,0,0,
-102,0,0,0,0,866,1022,0,0,0,0,0,0,0,0,0,55,0,115,0,0,0,0,933,0,0,0,0,0,0,0,702,0,
-0,0,0,0,0,0,1728,26,484,0,0,0,185,618,417,0,803,0,0,0,0,0,0,0,0,0,0,0,1262,0,0,
-0,0,0,0,0,0,0,0,0,0,0,633,0,0,0,0,0,0,0,0,0,0,0,0,0,479,262,0,0,0,0,0,0,830,0,0,
-0,0,26,70,0,0,0,0,0,0,0,0,217,0,640,51,0,0,360,1586,0,0,0,0,0,652,0,0,0,0,0,766,
-0,0,0,0,298,737,0,0,0,0,0,0,0,0,0,0,655,222,906,0,0,1013,991,2009,0,0,0,0,503,0,
-0,0,216,154,0,0,0,716,0,844,0,0,0,0,621,252,0,0,0,0,748,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,103,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,576,0,0,0,648,0,0,0,331,0,0,0,
-0,0,0,0,0,0,0,0,0,632,0,0,0,518,107,0,0,0,0,0,0,0,0,851,0,0,0,0,504,0,0,0,0,0,0,
-0,0,0,0,0,0,7,883,0,0,0,0,0,0,0,922,0,0,0,0,0,0,0,0,91,993,0,0,0,0,0,0,200,131,
-10,0,0,0,0,0,0,0,0,0,0,0,0,0,365,1433,0,0,0,0,28,103,0,0,798,1013,0,0,0,0,0,0,0,
-0,39,1925,0,853,0,0,271,519,0,0,0,0,338,0,0,300,470,419,0,0,0,0,0,0,836,0,0,0,0,
-0,0,1937,0,0,0,0,0,393,0,0,357,0,0,0,0,0,703,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,387,0,0,0,0,0,0,75,708,453,1351,0,303,0,0,772,0,0,0,0,0,0,0,0,749,0,0,
-0,0,0,0,0,0,0,0,0,0,0,1065,0,0,717,226,0,0,0,0,0,890,431,626,0,0,0,0,706,0,0,0,
-51,698,0,0,0,0,0,0,0,0,0,0,0,828,0,0,17,0,0,0,0,1929,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,871,498,0,101,1793,0,0,0,0,0,0,435,0,
-0,0,0,0,966,0,129,1644,0,0,0,0,0,0,0,0,0,0,0,0,0,997,502,0,0,0,0,0,0,0,0,0,0,0,
-0,823,0,1927,0,0,0,0,98,1756,0,0,0,0,0,0,0,0,0,0,0,0,8,0,160,1046,0,492,0,0,0,0,
-0,0,129,45,0,0,0,0,0,0,353,558,0,0,0,0,0,785,0,0,0,1145,189,0,0,0,26,353,0,0,0,
-0,0,2024,0,0,0,606,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,855,0,0,0,0,0,0,0,0,0,0,0,
-0,0,2011,0,0,5,4,0,0,461,764,0,0,0,1449,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1445,0,0,
-0,1168,0,0,0,233,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,0,0,216,0,0,0,286,0,0,0,
-3,0,0,0,723,536,0,0,0,0,0,285,0,0,0,560,0,0,0,0,0,690,0,0,0,0,0,1246,0,0,63,0,
-33,0,0,0,0,0,520,1862,0,0,0,0,0,0,0,0,0,0,0,0,630,0,0,0,0,554,0,0,0,0,0,1001,0,
-0,0,0,0,446,0,0,0,0,0,0,0,1313,0,0,837,636,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,278,
-0,0,0,0,0,0,0,0,868,0,0,0,0,1010,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-1231,0,304,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,93,1408,794,
-843,704,0,285,114,485,898,145,0,19,2035,0,0,0,1933,0,0,0,0,0,0,0,1728,0,0,0,0,0,
-0,0,0,746,0,0,0,0,0,0,0,995,1964,0,0,0,0,0,0,0,0,0,0,0,1550,0,874,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,1018,0,0,0,814,126,0,0,1264,0,0,814,955,0,0,0,0,0,0,
-0,981,0,0,0,0,0,0,0,0,915,56,0,0,100,0,0,0,0,0,0,0,0,0,638,0,0,0,0,738,0,0,0,0,
-0,0,0,0,0,758,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1112,0,0,214,0,0,0,133,0,196,
-168,0,0,0,0,0,1152,0,1245,0,0,538,169,871,1816,0,0,413,133,0,0,0,978,0,0,43,93,
-371,0,0,0,0,0,0,526,25,0,754,335,0,0,0,0,182,0,0,0,0,0,0,0,0,0,0,0,39,601,0,0,0,
-0,0,0,0,181,370,0,0,1652,358,0,0,0,0,0,0,0,0,0,176,286,0,788,0,0,0,0,0,1223,780,
-254,1003,896,0,0,0,1447,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,744,0,0,0,0,0,126,0,
-41,788,0,0,0,629,0,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,420,37,1900,0,0,0,0,542,1570,957,0,0,0,0,0,0,
-0,373,31,0,0,0,0,125,325,0,0,0,0,0,0,323,0,0,1547,0,0,0,0,0,0,0,0,0,0,0,0,0,
-1216,0,0,0,0,0,0,198,1905,629,15,0,0,0,0,0,0,20,75,543,1353,0,0,0,533,0,0,6,0,0,
-0,0,0,0,538,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,11,0,0,0,284,659,0,989,0,0,0,0,0,
-0,0,0,0,848,0,0,507,0,0,0,0,0,0,0,0,188,991,884,0,0,0,0,60,959,0,0,0,0,0,1653,0,
-0,922,337,0,638,0,0,500,0,0,0,0,0,0,0,0,0,0,0,166,0,0,0,0,0,0,0,0,0,0,0,0,418,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,760,0,0,0,0,0,0,1277,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,770,0,0,0,0,0,0,0,243,89,0,0,0,0,0,0,0,0,0,1396,0,
-560,0,0,3,1658,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,586,0,0,1271,0,0,0,505,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,637,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1947,
-41,445,0,0,0,0,0,0,0,0,57,189,0,0,371,0,0,0,0,552,0,883,0,923,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,875,0,0,0,1788,49,0,0,0,0,0,
-0,0,0,0,0,0,661,0,0,1945,0,0,0,0,0,794,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,1135,0,0,0,745,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,410,0,976,0,0,0,0,0,703,0,0,
-0,0,0,0,187,322,0,0,0,227,0,0,0,0,560,0,31,1395,0,0,0,0,0,466,0,0,0,0,643,167,0,
-0,0,1428,0,412,0,0,0,0,0,0,0,0,0,1118,562,0,0,0,0,0,256,0,0,0,0,0,0,1771,0,0,0,
-0,0,1190,132,0,66,0,0,0,0,0,0,0,0,0,0,317,0,0,0,63,0,0,0,0,0,0,0,1475,0,0,0,0,0,
-0,0,288,0,0,0,0,608,0,0,0,0,0,0,0,0,1225,0,1189,0,0,0,0,0,0,0,1468,0,0,0,0,0,
-689,120,0,0,0,0,0,0,0,1,0,329,0,0,0,0,226,0,0,0,0,0,1855,0,0,461,0,0,0,0,1346,0,
-0,0,0,0,85,0,0,299,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1171,0,0,
-0,980,0,0,0,0,0,0,0,0,637,279,0,0,0,0,0,293,0,0,0,0,528,17,0,0,0,0,5,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,601,0,0,0,0,0,0,779,0,
-196,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1322,737,752,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,412,192,80,0,0,8,1470,0,0,0,0,0,0,0,0,0,873,0,0,0,0,0,835,0,0,0,0,256,
-38,986,0,0,0,0,0,0,0,0,0,91,257,278,911,0,0,0,0,0,0,0,0,749,151,0,0,0,0,0,0,0,0,
-0,0,0,0,989,0,0,990,0,0,90,194,0,0,0,0,0,425,0,0,0,0,0,774,0,0,0,0,0,0,0,0,0,0,
-646,827,752,0,0,0,662,0,22,21,0,0,0,0,0,0,95,239,0,0,0,431,0,0,0,0,0,874,0,0,
-265,65,0,0,0,1350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1887,0,0,0,0,0,0,0,809,
-0,696,0,1074,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,630,0,0,802,0,0,0,56,776,0,
-970,0,0,797,0,0,0,0,0,400,0,0,1951,0,0,41,0,11,118,0,0,0,0,0,0,0,0,251,615,0,0,
-0,1044,0,0,0,0,0,0,0,0,0,0,0,225,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,370,0,0,0,0,
-104,48,209,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,930,0,0,0,0,
-0,0,0,0,0,0,0,1286,0,759,0,120,385,0,0,0,429,0,0,0,0,0,0,0,0,820,0,0,0,0,0,0,
-199,0,10,151,0,0,0,761,365,0,0,0,0,0,0,0,0,0,46,1086,0,0,0,0,11,1624,58,344,0,0,
-1008,1868,0,0,0,888,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,711,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,440,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,914,1913,0,958,0,885,0,0,0,0,0,0,0,0,0,0,0,
-0,0,847,276,0,302,65,0,0,0,510,0,1514,0,0,0,0,0,0,152,291,0,0,0,0,0,0,0,0,0,0,0,
-0,282,589,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,463,42,0,0,0,0,0,372,0,0,0,0,0,0,0,
-0,0,680,0,0,0,0,0,0,0,0,977,1997,0,0,0,810,0,0,0,0,0,0,0,0,0,1390,0,0,0,644,0,0,
-867,982,0,0,0,0,0,0,0,540,0,123,0,0,0,1978,0,0,0,0,789,623,0,1723,0,1220,0,0,0,
-0,0,0,0,480,0,0,0,0,0,0,0,0,0,0,0,888,0,0,0,0,0,0,0,0,0,0,0,0,299,1995,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,788,179,0,0,0,0,0,0,431,156,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1373,39,80,196,0,0,507,0,0,0,646,0,0,0,0,
-0,1214,0,0,0,0,926,0,0,0,1,114,0,0,0,0,0,446,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,490,0,0,0,491,0,1584,0,0,507,250,0,0,0,158,
-10,362,1,0,0,0,0,0,0,0,0,0,408,228,860,480,0,779,0,0,0,557,0,0,142,197,0,0,0,0,
-0,0,0,0,0,0,0,1490,11,378,316,1057,0,0,18,579,299,1546,0,177,0,0,0,0,0,0,0,0,0,
-411,0,0,0,0,727,439,0,0,0,0,0,1528,0,0,0,0,0,0,58,0,482,0,0,0,505,1952,0,0,0,0,
-0,0,0,0,0,0,0,242,0,0,0,0,0,0,0,953,0,0,0,0,802,0,0,0,0,0,0,0,0,0,0,290,0,0,791,
-52,0,0,0,0,0,0,0,0,0,0,0,112,0,0,0,0,0,1028,0,0,138,0,0,0,0,1811,0,0,0,0,0,0,
-934,1821,0,0,0,0,371,38,0,0,0,1296,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,723,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1330,0,0,0,0,0,0,0,1255,296,109,0,0,0,0,0,660,0,0,0,0,270,591,0,
-0,0,0,0,0,0,1090,81,0,0,0,0,391,0,0,0,0,249,322,0,0,0,0,0,0,0,1412,0,0,0,0,0,0,
-0,0,0,0,526,632,0,0,0,0,0,0,235,144,0,0,0,0,0,940,0,0,0,52,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,309,196,0,0,0,0,0,1912,0,1290,0,686,0,0,625,0,0,0,0,0,0,0,0,0,0,0,412,0,
-0,0,0,43,0,0,0,0,11,967,758,0,0,0,0,0,0,0,0,0,0,0,0,0,0,220,0,0,0,0,0,0,0,0,0,0,
-873,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,890,0,0,2,0,0,0,0,0,0,0,0,1774,
-393,263,0,0,0,0,0,0,818,456,0,0,251,178,393,97,0,0,0,0,0,674,168,0,0,0,0,0,0,0,
-159,1639,0,0,0,0,0,0,0,0,59,934,0,191,0,0,0,0,346,165,0,877,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,128,0,0,0,0,0,0,1297,0,0,0,0,0,0,164,0,0,0,15,132,241,1073,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,228,324,53,0,0,910,0,0,0,0,0,0,0,0,734,705,
-217,73,0,0,0,0,0,0,0,0,636,389,0,1409,0,0,0,0,0,893,0,0,0,0,21,0,0,0,0,0,0,0,0,
-0,0,0,0,0,721,0,0,0,959,0,0,0,0,1433,0,0,0,0,0,0,0,0,0,0,0,0,174,189,0,0,0,0,0,
-0,0,0,0,0,22,2,0,0,815,354,0,0,0,0,425,0,411,60,13,1611,0,0,0,0,0,0,0,0,0,0,0,0,
-0,1478,596,0,0,398,0,50,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,1159,0,0,0,0,0,
-592,223,0,0,0,0,0,0,0,245,64,0,0,0,0,278,0,604,0,0,1502,265,0,0,0,0,0,0,0,310,
-1763,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,129,0,0,0,0,0,0,0,0,0,1356,0,0,0,0,0,0,0,
-0,505,0,0,0,0,0,0,0,1000,0,0,966,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,839,0,0,0,0,0,0,
-0,0,0,0,0,0,0,637,0,0,0,0,0,0,0,0,0,0,0,0,0,0,590,0,0,0,0,280,0,0,0,1386,0,0,0,
-281,0,1064,0,0,0,0,0,917,0,0,15,555,0,0,1014,1883,0,0,0,965,0,0,117,33,0,0,0,
-801,0,0,0,0,0,877,0,824,0,0,0,0,0,0,0,0,0,0,0,365,0,0,0,0,0,0,774,7,0,430,0,0,
-231,360,0,0,0,0,0,0,0,0,822,740,0,0,929,1485,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,852,0,0,0,0,17,0,0,0,0,0,0,1001,0,0,0,0,35,831,0,0,384,457,0,0,0,1351,0,27,
-0,0,984,0,264,552,0,401,0,0,0,710,0,1211,0,0,11,205,0,0,0,0,0,0,0,0,0,0,0,0,5,
-579,0,717,0,0,1011,0,0,0,0,0,0,0,0,0,0,0,0,0,0,805,0,0,0,0,0,0,0,0,0,0,0,489,0,
-0,0,1024,0,0,0,0,0,0,0,0,0,892,0,0,0,0,0,0,0,0,0,0,0,0,473,0,0,0,659,864,0,0,0,
-0,0,0,152,819,0,51,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,0,229,0,0,0,0,674,0,0,0,0,0,
-0,0,0,0,770,52,79,0,0,0,1666,0,409,0,0,0,0,0,0,0,195,0,688,0,0,0,0,0,0,0,0,0,0,
-0,889,174,160,0,0,0,0,0,0,0,0,0,0,0,0,0,872,0,918,569,268,0,0,0,1224,0,1361,0,0,
-0,0,0,0,0,0,0,374,0,0,0,0,0,731,0,0,0,0,190,0,0,0,0,0,0,0,202,506,444,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,835,0,17,1526,0,0,0,0,0,477,0,0,
-994,1374,76,0,0,0,0,0,0,0,355,287,0,1389,0,0,0,0,0,0,455,384,0,0,0,264,0,0,0,0,
-0,0,0,0,0,0,0,0,1001,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,851,175,359,0,0,0,0,0,0,0,
-0,287,740,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,857,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-819,1402,0,0,0,0,0,0,174,224,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1649,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,655,573,0,0,0,0,0,0,0,0,128,351,0,0,0,0,0,0,
-0,0,0,0,0,918,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,687,0,0,0,0,0,0,0,0,0,1525,
-0,0,0,1009,0,0,0,0,0,0,0,340,0,0,0,0,0,0,0,0,0,0,861,0,176,0,0,0,0,0,0,0,0,0,96,
-985,0,615,0,0,0,0,0,0,0,1919,0,0,0,0,0,1131,0,0,0,0,0,0,0,247,0,0,0,0,27,23,0,0,
-0,0,0,0,0,0,38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1015,0,0,0,0,0,1088,0,0,
-0,0,0,1585,0,0,0,0,227,0,0,0,478,360,0,0,0,95,0,0,0,0,0,0,699,0,0,0,26,0,0,0,0,
-1119,0,0,0,739,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,741,67,0,0,0,0,0,0,464,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,0,96,0,0,0,26,342,0,0,0,0,0,0,203,0,0,449,0,
-0,0,0,0,0,0,0,0,0,256,311,0,0,0,0,0,0,758,0,0,0,0,0,0,0,0,827,0,0,0,0,581,64,0,
-1047,0,0,0,0,0,288,0,0,0,0,0,1375,0,0,0,0,0,0,0,0,0,0,0,1309,0,0,0,0,0,0,0,0,
-376,12,0,0,0,0,0,154,0,1520,0,1753,95,502,0,0,0,0,0,0,0,269,291,1197,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,1341,0,1017,0,0,0,0,0,0,0,
-0,857,1810,533,0,0,1453,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,836,211,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,19,0,156,0,0,0,0,1009,0,0,0,0,0,0,0,0,0,0,0,0,0,820,0,0,
-0,0,0,0,0,0,0,228,0,0,0,1131,0,1276,0,0,0,0,0,0,0,0,0,0,0,0,849,1792,0,0,389,
-291,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,525,0,0,
-0,453,0,0,0,0,666,0,0,0,422,0,355,0,0,0,0,165,0,260,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,865,0,0,0,0,0,0,0,1625,0,0,0,234,0,1383,0,0,0,0,0,0,0,0,306,0,0,0,802,1921,
-0,0,0,0,0,0,180,0,0,0,0,1312,814,0,0,0,0,0,0,0,0,0,0,707,0,0,0,1493,11,61,733,0,
-0,0,341,0,0,0,98,0,0,0,0,0,0,0,0,0,0,0,1014,0,0,0,0,0,0,0,142,102,0,0,30,0,0,
-823,0,1045,0,0,0,1930,0,1512,0,0,0,0,0,0,0,87,0,1243,245,0,0,0,0,0,0,0,48,68,0,
-0,0,0,0,0,0,0,126,77,625,938,0,0,351,0,0,0,174,1668,0,707,0,0,0,0,0,0,0,0,0,0,0,
-403,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,282,0,0,0,0,0,0,8,44,0,0,363,115,0,0,0,0,0,0,
-0,0,0,0,0,0,545,761,0,0,835,1254,0,0,0,0,930,1936,0,0,0,0,0,0,0,0,653,0,0,0,0,0,
-344,0,0,1483,673,185,0,0,460,93,753,478,0,0,0,0,0,1020,0,0,0,0,0,0,0,103,0,0,0,
-499,0,0,0,0,0,0,207,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,968,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,3,0,0,0,0,399,0,0,0,0,224,563,0,0,0,0,0,704,0,0,0,0,0,0,0,0,0,0,0,
-1559,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,861,0,0,0,0,946,333,746,0,0,0,0,0,
-0,0,910,0,0,0,0,0,0,0,0,0,0,0,0,0,652,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-1393,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1514,0,0,0,0,201,0,510,717,0,0,528,0,0,0,0,
-20,0,0,0,1251,0,0,0,1163,0,0,0,307,0,0,0,0,0,1091,0,0,0,0,0,0,0,0,0,0,0,429,0,0,
-0,881,0,0,0,0,0,621,0,0,0,0,0,0,0,736,0,348,0,868,0,0,0,0,433,0,0,0,771,1495,0,
-0,0,0,215,0,0,0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,55,0,0,0,0,0,0,0,112,62,0,856,270,
-0,572,0,0,0,0,939,0,0,0,0,0,0,0,352,0,0,0,0,0,0,0,0,0,647,0,0,0,0,10,0,0,0,0,0,
-0,0,220,0,0,0,0,0,0,0,0,0,0,0,0,0,464,0,0,109,0,0,0,1746,0,0,0,515,0,0,0,566,0,
-0,0,0,0,0,67,40,0,0,722,992,0,0,923,0,0,0,0,0,0,1145,0,0,0,0,0,0,0,0,0,0,0,568,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,0,0,0,0,645,0,0,328,0,0,0,0,0,0,0,0,0,0,0,0,
-1363,0,0,0,0,0,1280,0,0,0,0,0,0,0,0,0,0,7,28,360,162,0,0,0,0,0,0,0,0,0,0,0,764,
-0,0,833,862,0,856,0,0,0,0,0,0,736,92,0,0,948,1944,0,1479,63,590,0,0,0,1521,0,0,
-0,709,0,0,61,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,483,0,0,0,0,1213,
-0,0,0,0,29,1022,0,1712,0,466,0,0,0,0,0,0,0,0,0,0,0,0,0,731,0,0,0,0,0,0,171,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,241,0,0,0,0,0,0,0,0,0,0,0,964,2005,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,1100,0,0,0,954,0,0,0,0,0,0,0,0,0,1958,0,0,34,549,994,0,0,449,
-137,850,0,0,670,146,0,0,0,0,518,159,0,0,0,0,0,0,0,0,151,0,0,1027,0,0,0,0,0,0,0,
-0,0,0,983,0,0,0,0,993,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,501,0,0,0,
-0,0,0,0,0,0,452,0,0,0,0,0,0,0,0,0,0,233,149,0,0,0,0,0,0,0,0,582,0,0,0,801,0,0,0,
-0,0,0,70,0,0,369,0,36,0,0,0,0,0,0,0,204,721,430,241,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1817,16,1078,1021,0,0,
-406,0,0,0,0,0,69,0,0,0,0,0,1830,0,0,0,824,0,0,0,0,0,0,0,0,0,826,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,816,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1000,717,1845,0,423,0,0,
-0,0,0,0,0,0,510,0,0,1048,0,0,0,618,0,0,0,520,0,0,0,0,990,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,321,0,0,0,0,0,0,0,1135,0,0,921,0,0,0,24,397,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,856,0,0,0,139,282,981,0,288,0,0,0,1890,651,56,0,0,0,0,0,0,0,
-0,261,0,0,0,0,0,0,0,0,0,0,0,617,1403,0,1205,0,0,563,0,0,0,0,0,0,0,0,333,0,0,0,0,
-0,369,0,0,0,0,0,0,0,0,0,622,0,0,0,1407,0,0,0,0,0,0,0,0,0,0,0,0,624,160,0,363,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,619,0,174,292,0,0,656,616,0,0,0,685,0,0,0,0,0,0,0,0,0,0,0,0,0,647,0,0,0,631,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1267,0,0,0,1797,0,0,0,1684,0,0,469,0,531,
-1230,73,0,0,0,0,0,0,0,0,0,268,0,0,0,0,0,102,558,109,65,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,595,0,0,0,0,0,374,1832,0,0,0,0,0,0,16,0,405,6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,881,0,1495,0,0,0,0,0,0,0,0,0,142,0,0,0,0,0,0,0,0,0,0,21,466,23,
-257,0,0,0,0,0,0,77,404,0,0,0,0,0,0,712,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,860,
-1848,0,0,652,629,0,0,0,0,13,377,0,1842,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1501,0,
-0,0,1906,0,0,0,0,0,0,0,0,0,0,0,0,0,491,234,171,0,0,0,0,631,1186,0,0,0,0,0,0,0,0,
-0,0,0,0,931,0,170,0,0,0,0,0,0,0,0,0,0,1587,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-765,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,424,0,0,714,0,0,0,0,685,0,0,0,0,0,
-0,285,0,0,0,0,0,0,429,0,0,0,0,0,0,0,0,0,0,71,18,0,0,0,0,0,0,0,0,0,0,116,828,0,0,
-0,0,0,0,289,0,0,0,0,0,0,0,0,675,0,0,0,1424,0,0,0,0,0,647,0,0,0,1334,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,36,209,0,0,0,0,0,0,0,342,0,0,0,928,0,0,0,0,0,1838,118,856,654,
-318,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,915,895,454,0,0,513,1425,0,0,
-0,0,0,0,791,0,153,0,0,0,0,0,0,796,909,445,345,0,0,0,0,0,0,0,0,578,0,0,0,1387,0,
-0,0,555,0,0,0,0,0,0,766,0,0,0,0,0,0,0,0,0,0,541,0,0,0,0,0,0,0,0,0,0,0,0,0,880,0,
-0,0,0,0,1506,0,0,983,0,768,0,0,0,0,584,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,737,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,226,30,426,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-117,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,462,0,0,0,385,0,398,0,0,0,0,0,0,
-0,0,0,347,0,0,0,0,125,1259,644,136,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,469,0,0,0,0,0,
-1367,0,0,0,0,0,0,0,0,0,0,0,719,0,0,0,0,0,0,0,0,0,0,0,0,0,1423,0,0,0,0,0,0,0,0,0,
-749,0,0,0,0,546,645,0,0,0,0,0,0,277,0,0,1275,0,0,0,0,0,0,0,453,536,555,0,0,987,
-1107,0,0,90,0,0,0,0,0,0,0,0,860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-257,0,1768,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1071,0,0,0,0,0,0,0,0,0,0,0,0,0,83,
-0,835,0,0,0,0,0,0,0,2006,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,696,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,95,1718,0,0,0,0,0,0,0,26,0,550,0,0,0,0,0,901,0,0,0,0,0,
-0,822,0,0,122,0,0,0,807,0,0,0,0,0,262,0,620,601,34,0,0,170,0,0,0,0,537,0,0,0,0,
-0,0,0,0,0,332,0,0,208,1909,182,261,0,0,0,1721,0,0,0,0,0,933,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,1609,0,895,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,812,0,0,942,1916,0,0,0,0,
-0,0,0,778,0,0,0,137,0,1314,0,0,0,0,0,0,0,1661,0,0,0,0,0,0,0,1591,0,0,0,0,0,0,
-820,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,185,89,0,1160,230,6,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,63,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1740,0,0,177,
-170,0,1961,0,0,0,0,0,0,0,0,0,0,0,0,91,0,17,44,0,0,0,0,0,0,0,0,0,270,0,296,0,0,0,
-0,0,0,0,1523,0,0,0,0,0,0,0,0,0,0,757,7,0,0,0,0,0,0,0,0,0,0,530,588,0,0,0,0,0,0,
-0,0,0,786,0,0,0,0,0,580,627,88,447,57,0,0,0,0,0,0,0,0,845,735,0,0,0,0,0,31,15,0,
-460,521,12,424,0,0,0,1302,0,0,0,0,0,0,0,595,0,0,0,13,548,97,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,1472,452,1767,0,0,0,0,0,0,0,0,0,0,115,0,0,0,0,0,0,1543,0,1111,0,0,0,0,
-1,0,359,488,0,267,0,0,0,1983,0,0,0,0,0,0,0,1155,0,1575,0,1438,31,0,0,377,101,0,
-0,0,0,0,0,0,0,0,0,0,0,0,476,0,0,0,0,0,0,0,0,2023,0,0,0,0,0,1836,0,0,0,0,35,843,
-0,0,0,0,0,0,0,554,0,0,0,536,625,207,0,1371,0,0,0,424,785,336,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,896,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,750,0,0,0,0,238,0,0,
-0,0,0,383,0,0,0,0,0,0,0,0,603,725,11,0,0,0,0,0,0,0,0,0,476,0,0,0,0,0,1552,0,0,0,
-0,0,0,0,680,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,435,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-1431,0,0,13,112,0,0,356,0,0,0,0,0,0,0,0,0,0,1963,0,0,0,1244,18,0,0,0,0,0,0,867,
-0,0,0,0,0,0,50,708,73,592,0,502,0,0,0,0,0,0,161,347,0,0,0,0,470,33,0,246,571,10,
-0,465,614,0,237,0,0,0,0,0,24,18,0,506,0,0,0,0,0,0,33,309,0,0,0,0,0,0,0,0,0,0,
-140,0,0,0,0,1056,0,0,0,1704,0,0,0,0,0,0,0,1036,0,0,0,0,0,0,0,0,0,1315,432,86,
-264,524,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,107,0,0,0,0,0,123,927,0,0,957,1149,0,0,
-0,0,0,778,0,502,196,0,0,0,0,1312,0,0,0,0,0,0,0,855,0,0,0,0,0,0,0,0,0,0,45,1400,
-0,0,0,1003,0,0,0,0,0,1097,0,0,0,0,0,0,0,0,545,612,0,0,0,0,0,0,0,0,0,0,0,0,54,0,
-0,0,0,172,0,0,0,1029,0,0,0,0,0,0,0,0,0,568,0,0,0,732,617,0,0,974,94,989,733,0,0,
-0,0,0,0,1789,0,0,665,2015,0,0,0,0,0,0,806,287,0,0,0,0,0,1539,0,0,0,0,0,0,0,0,0,
-0,182,1563,0,0,0,0,0,0,0,0,0,484,0,0,0,0,0,1623,0,0,0,0,0,0,0,0,878,1833,0,1569,
-0,0,0,0,0,0,0,0,93,0,715,994,0,0,0,0,0,63,0,591,0,0,0,0,0,0,0,749,0,0,0,0,547,
-366,0,0,0,1747,0,0,0,0,0,0,0,89,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1463,0,772,
-893,0,0,0,48,0,0,941,0,0,690,1785,106,440,0,0,0,0,0,0,0,0,0,0,32,0,332,216,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,852,0,
-0,416,564,0,918,0,1764,0,0,3,0,0,274,0,0,0,0,501,0,0,0,0,0,0,0,851,743,0,49,0,
-879,0,0,47,0,0,0,0,0,0,865,0,1202,0,0,0,0,0,0,47,272,0,0,0,0,0,0,0,0,0,0,0,1455,
-0,0,0,0,891,1911,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,761,0,0,0,0,0,0,0,0,0,407,0,
-183,0,0,490,0,0,0,0,0,0,0,35,731,0,0,0,0,0,0,0,819,0,0,0,0,0,0,0,0,0,0,0,0,0,
-575,0,0,0,0,45,818,0,0,77,222,0,0,0,0,849,1880,0,0,0,633,0,1308,0,0,0,0,0,0,0,0,
-0,0,86,0,0,0,0,0,0,0,0,0,0,0,0,0,0,817,0,0,0,0,0,0,0,0,0,882,0,0,0,914,0,0,0,0,
-0,0,0,0,0,0,865,0,0,426,399,58,0,0,0,0,0,0,538,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,876,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,139,566,0,63,12,0,0,0,
-0,0,0,0,0,0,0,0,0,0,3,114,0,0,0,0,0,0,0,0,576,0,0,0,0,0,0,0,0,933,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,692,0,0,0,0,0,0,0,0,0,0,0,0,752,0,0,0,0,
-0,0,0,0,375,0,1011,0,0,96,0,0,0,0,0,0,0,0,0,148,0,0,0,0,0,0,0,0,0,0,0,337,56,
-666,0,246,394,0,0,0,0,0,0,0,0,437,0,0,0,506,0,0,0,0,1003,0,1163,0,328,0,0,0,0,0,
-0,0,0,1000,0,0,0,0,0,744,101,0,0,0,0,0,726,0,0,176,0,146,9,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,839,0,0,0,0,0,0,223,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,246,1931,29,0,0,1771,0,0,0,0,0,846,6,157,0,0,0,0,0,0,0,0,0,875,0,0,477,
-773,177,639,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1747,0,0,0,0,158,873,0,659,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,391,0,0,0,0,0,0,0,0,0,0,0,0,668,883,0,78,628,0,0,0,
-0,0,0,0,0,0,0,0,0,1460,0,962,0,0,0,0,0,460,0,0,0,0,0,0,0,0,0,0,0,0,0,0,34,199,0,
-0,0,388,474,0,271,0,333,608,0,0,0,0,0,0,49,0,988,0,707,617,0,0,0,0,0,0,0,756,0,
-0,0,0,0,1583,0,0,0,0,0,0,0,0,0,0,285,0,0,0,0,0,0,0,0,0,0,0,0,0,0,344,0,0,0,0,0,
-0,0,0,515,1709,0,0,0,0,0,0,0,0,404,0,0,0,0,500,0,0,0,0,0,0,0,0,0,68,216,0,0,0,0,
-0,0,0,488,353,0,0,177,236,0,0,458,490,0,0,0,0,0,0,756,1504,0,757,0,1735,0,0,108,
-598,0,0,0,0};
-BROTLI_INTERNAL const uint8_t duckdb_brotli::kStaticDictionaryHashLengths[32768] = {
-8,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,12,0,0,0,0,4,22,5,0,
-4,0,0,0,0,0,0,0,0,0,0,0,0,14,6,0,0,0,5,0,0,0,0,0,0,0,7,13,0,0,4,0,0,0,0,0,0,0,0,
-0,6,0,0,0,0,8,0,0,0,0,0,0,7,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,4,0,0,0,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,10,4,0,5,13,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,8,7,0,0,9,0,8,0,0,0,0,0,0,6,0,
-0,9,0,0,0,11,0,0,6,8,7,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,6,8,0,0,0,0,0,
-0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,9,0,0,0,8,4,13,7,0,0,0,0,0,
-7,0,5,0,0,0,0,8,5,0,5,0,0,8,7,0,0,0,0,0,0,0,0,0,0,9,0,0,0,8,0,0,0,10,4,0,5,0,4,
-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,8,7,0,4,9,4,0,0,0,0,0,0,
-9,0,0,0,8,5,0,0,0,6,0,0,0,0,0,0,0,0,0,7,18,0,0,0,0,4,9,0,0,4,0,6,0,0,0,6,0,6,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,5,8,7,0,0,0,
-0,9,0,0,0,0,0,0,0,8,6,10,6,0,0,0,4,0,6,8,6,0,0,0,4,0,0,0,0,0,5,0,0,0,6,0,0,0,0,
-10,0,12,7,0,0,0,0,0,4,0,0,0,0,0,5,0,0,8,7,0,0,0,0,0,0,0,0,9,5,0,0,0,0,0,0,0,0,0,
-0,0,0,0,6,11,0,0,0,0,0,0,0,0,0,8,7,0,0,10,0,0,0,0,0,0,0,0,6,10,0,17,0,8,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,8,6,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-7,0,0,11,4,0,5,0,0,0,0,0,0,0,0,0,0,10,5,0,6,8,5,0,0,0,0,0,0,0,0,0,0,11,5,0,0,0,
-0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,9,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,8,7,0,0,0,0,0,
-0,0,0,0,0,0,5,0,0,0,6,0,0,10,0,0,0,20,0,0,0,0,0,0,0,0,6,9,5,0,0,0,0,10,4,8,0,0,
-4,13,0,0,0,0,0,0,0,9,0,9,0,0,0,0,0,0,0,0,0,0,0,0,4,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,12,0,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,12,5,0,0,10,4,10,7,13,
-0,0,0,0,0,0,0,0,6,0,6,0,6,0,0,0,0,0,0,19,0,0,4,12,6,9,0,0,0,0,4,0,4,11,0,0,0,0,
-0,0,0,12,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,4,0,0,0,0,0,0,0,0,0,6,0,0,0,0,
-0,5,0,0,0,0,0,6,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,9,6,0,0,0,0,0,4,0,4,0,0,0,0,0,0,0,0,0,4,0,0,0,
-6,0,0,0,0,0,0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,6,0,0,
-0,0,0,5,0,0,0,0,14,4,0,0,0,4,12,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,6,0,
-0,0,0,0,0,12,0,9,6,0,0,0,0,13,0,0,5,0,0,0,0,0,4,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,13,0,9,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,5,0,0,0,6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,8,7,8,4,0,0,0,0,0,0,0,0,0,0,0,7,0,7,0,0,0,4,0,
-0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,6,8,4,0,0,0,0,0,6,0,7,0,
-0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,7,0,0,0,0,0,0,9,5,0,0,
-0,0,0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,9,4,0,0,0,0,0,0,0,4,
-12,5,11,0,0,0,0,0,0,0,0,0,8,7,0,5,0,0,8,7,0,5,0,0,0,0,8,0,0,0,0,7,0,4,10,0,0,0,
-0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-13,5,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,0,14,5,0,0,0,7,0,0,10,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,6,0,4,0,5,0,0,0,0,8,5,0,0,0,0,0,0,9,5,9,0,0,0,0,0,0,0,0,6,9,0,
-0,4,0,0,0,7,0,0,0,6,0,0,10,4,0,0,0,0,0,6,0,0,10,0,0,0,8,5,0,0,0,0,0,0,0,0,10,0,
-0,0,0,0,18,4,12,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,8,7,0,0,0,
-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,4,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,
-0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,8,0,0,0,0,0,0,6,0,0,0,4,10,5,0,0,0,0,0,0,0,0,0,0,
-0,4,8,7,0,0,8,6,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,
-0,0,0,8,6,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,
-0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,8,7,0,0,0,0,8,0,12,6,0,6,0,0,0,0,9,7,11,7,0,0,0,
-0,0,0,0,0,0,0,0,0,11,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,10,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,
-0,0,0,6,0,0,0,7,0,4,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,14,0,0,0,0,0,8,4,0,4,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,20,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,12,5,0,7,0,5,0,0,10,0,0,7,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,6,0,4,9,7,0,0,0,
-0,0,7,0,0,0,0,0,0,10,0,9,0,9,0,0,0,0,0,0,0,0,4,9,0,0,0,0,6,0,0,0,0,0,0,0,0,11,4,
-0,6,0,0,0,0,0,0,8,0,8,0,0,0,0,0,0,0,0,0,0,4,0,0,0,5,0,0,0,0,0,0,0,0,13,6,0,0,11,
-0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,6,18,0,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
-0,5,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,6,0,0,0,0,9,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,11,
-4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,4,0,0,0,0,8,
-6,0,0,0,0,0,0,9,6,0,0,0,0,0,4,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,
-0,6,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,6,0,6,0,0,10,6,0,0,0,7,0,0,8,0,8,7,0,
-0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,18,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,
-0,0,0,8,7,0,0,0,0,0,0,0,0,12,0,12,0,0,0,11,6,0,5,0,0,12,0,12,5,0,7,11,6,0,0,11,
-0,0,0,12,0,0,4,12,7,8,6,0,0,0,0,8,5,0,0,0,0,0,0,0,4,11,0,0,6,0,7,0,0,0,0,0,0,0,
-5,0,6,0,0,0,0,8,0,10,0,0,0,0,0,0,0,0,0,0,0,9,7,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
-0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,0,0,10,0,0,5,0,0,12,6,0,0,0,0,0,0,10,6,0,0,0,0,8,
-6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,5,0,0,0,0,11,0,10,6,0,0,8,6,0,0,0,6,0,7,10,6,0,
-0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,10,7,0,0,0,0,
-10,6,0,0,0,0,0,0,8,5,11,0,8,4,0,0,0,4,0,0,0,0,9,4,8,0,0,0,0,0,0,0,11,6,0,0,0,0,
-10,7,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,7,0,0,0,0,9,6,0,5,0,7,0,0,0,0,0,7,0,0,11,0,0,
-0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
-0,0,0,0,13,0,8,6,13,0,0,0,11,7,0,7,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,6,0,0,9,6,0,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
-0,0,0,0,0,5,9,0,0,0,0,0,0,0,0,0,0,4,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,9,7,0,7,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,
-5,11,5,0,0,0,0,0,0,0,0,0,4,0,7,0,6,0,0,0,6,20,0,0,0,10,7,0,5,14,4,0,0,0,0,0,0,0,
-0,0,6,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,
-0,0,6,0,4,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,0,11,6,15,0,0,0,0,0,
-10,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,7,0,0,0,0,0,0,0,0,9,7,13,0,0,0,0,0,
-0,7,0,0,8,6,0,0,0,0,0,0,0,0,9,4,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,5,0,0,0,0,0,0,0,0,0,0,0,0,8,5,0,4,0,0,0,0,0,0,0,0,0,0,12,6,8,0,12,0,0,7,0,0,0,
-0,0,5,10,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
-14,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,8,7,10,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,18,6,
-14,7,0,0,0,0,0,0,0,0,11,6,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,11,7,0,0,10,7,0,0,0,6,8,6,0,0,0,0,0,0,0,6,0,0,
-19,0,0,0,9,5,0,0,0,0,0,0,11,7,0,0,0,7,0,6,0,0,11,0,0,0,0,4,8,0,0,0,0,0,0,0,0,6,
-0,0,0,0,0,6,0,0,8,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
-0,7,0,0,0,7,15,0,0,5,0,0,0,0,10,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,7,0,0,
-0,0,0,0,0,0,9,6,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-11,7,0,0,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,
-0,0,5,0,4,0,0,0,4,0,4,0,0,0,0,0,0,0,0,0,6,0,0,0,0,11,6,0,0,8,5,14,0,0,4,0,0,0,7,
-17,0,0,0,0,0,0,0,13,5,0,0,0,0,0,5,0,0,0,5,0,0,0,0,16,6,0,4,0,0,0,0,0,0,12,0,0,0,
-0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,5,0,5,0,6,10,0,12,0,0,0,0,0,0,0,0,7,0,0,0,0,8,4,
-0,0,0,0,0,0,0,0,0,0,8,7,0,0,8,0,0,0,8,0,0,6,0,7,0,0,0,5,0,6,0,4,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,22,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,
-0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,18,0,0,0,9,4,0,0,8,0,9,7,0,0,0,0,0,0,8,6,0,0,0,0,
-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,9,7,0,0,0,6,0,0,14,0,0,0,0,
-0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,7,10,4,
-0,6,0,0,0,0,0,0,8,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,9,6,0,0,0,0,0,0,
-0,0,11,6,12,7,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,0,9,6,11,6,0,0,0,0,9,5,0,0,0,0,0,0,
-0,6,8,5,0,0,0,0,8,0,10,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,
-5,10,7,0,0,0,5,8,7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,4,8,7,0,0,0,6,0,0,
-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,22,
-0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,5,0,0,0,0,0,0,0,
-0,0,0,0,0,17,0,0,6,0,6,12,4,19,6,0,0,0,0,16,0,0,0,0,7,15,7,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,4,10,4,0,0,8,7,0,7,0,0,9,
-4,0,6,0,0,0,4,0,5,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,7,10,0,0,0,0,0,11,7,0,0,
-0,0,12,6,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,
-0,0,0,0,0,0,0,0,0,10,4,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,8,7,0,0,
-0,0,0,0,0,6,0,0,0,4,0,0,11,4,0,0,12,7,0,0,0,0,9,0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,
-4,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,9,4,0,6,0,0,0,0,0,4,
-0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0,0,5,0,0,0,0,0,0,0,0,0,7,9,6,0,7,0,
-0,0,0,0,0,0,6,0,0,0,0,8,6,0,0,0,0,10,6,11,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,5,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,5,0,4,8,0,0,0,0,0,9,7,0,0,0,0,0,0,
-13,5,0,0,0,0,8,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,5,0,0,11,7,0,0,0,0,0,0,8,6,0,
-0,0,0,0,7,0,4,0,0,0,0,0,0,0,5,0,6,0,5,0,0,0,0,0,0,0,0,0,0,0,0,10,4,9,0,0,0,0,0,
-0,4,0,0,0,0,10,5,10,7,0,0,0,0,0,0,0,0,16,7,0,0,0,0,0,7,0,0,0,0,11,0,0,0,0,0,0,0,
-0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,5,0,4,0,0,0,7,0,0,0,0,0,0,13,0,0,
-0,0,0,0,0,0,0,0,7,0,4,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,13,7,0,7,0,4,16,0,0,0,0,6,8,7,9,7,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,6,0,0,8,5,0,4,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,11,7,0,0,11,
-0,0,0,0,0,9,5,0,4,0,0,0,0,9,7,8,6,0,0,0,0,0,0,10,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
-0,7,0,0,0,0,0,0,0,0,0,0,0,4,10,6,0,7,0,0,0,0,0,0,0,5,0,0,0,0,0,0,10,7,10,0,0,0,
-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,7,0,6,8,7,12,4,0,0,0,0,0,0,0,5,14,
-0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,
-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,0,20,4,0,0,0,7,0,6,0,0,0,0,0,0,0,0,8,0,
-0,6,15,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,12,0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,5,0,0,0,0,0,0,8,6,0,0,18,0,0,0,10,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,9,6,0,
-6,0,0,0,0,0,0,0,0,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,9,0,9,0,0,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,9,5,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,10,0,0,0,0,7,0,0,0,0,0,0,0,0,0,7,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,0,8,0,0,0,16,0,0,0,0,0,0,0,
-0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,8,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
-6,0,0,0,0,11,0,0,0,9,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,7,0,7,0,6,
-0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,
-0,0,0,0,0,0,0,6,0,0,18,0,8,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,7,0,4,0,0,0,
-0,0,0,0,0,0,0,8,0,0,0,0,0,16,0,0,0,0,0,16,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,18,0,0,0,0,0,0,0,0,0,9,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,4,0,
-0,0,0,0,0,0,0,9,4,0,0,0,0,12,5,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,12,5,0,0,0,0,0,0,0,5,0,0,10,6,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,9,0,0,0,11,0,0,6,0,6,0,0,
-0,7,0,0,0,0,0,0,8,0,0,0,0,6,0,0,0,0,0,0,19,0,0,0,12,0,9,0,0,0,0,0,10,7,0,0,0,0,
-0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,16,7,12,
-0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,6,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,10,5,0,0,0,0,0,0,0,4,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,7,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,0,4,0,0,9,0,0,0,8,0,12,4,0,0,0,0,
-0,4,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,5,0,
-0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,0,0,8,6,0,6,0,0,0,0,0,0,
-0,4,0,0,0,0,0,6,0,0,9,0,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,10,6,0,0,0,0,8,
-6,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,7,0,6,
-10,7,0,0,10,5,11,6,0,0,0,0,0,7,16,0,0,0,0,6,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,5,0,0,0,7,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,
-0,0,0,0,0,8,7,0,0,0,0,11,6,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-8,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,12,7,0,7,0,0,0,
-0,0,0,0,6,0,0,0,0,9,0,0,0,23,0,0,0,0,0,10,5,0,0,0,0,0,0,0,0,0,4,0,0,11,7,10,0,0,
-0,0,0,0,0,0,0,0,0,0,6,0,0,8,7,0,7,0,0,8,7,8,0,0,0,0,0,0,0,0,0,0,0,14,5,0,0,0,0,
-0,0,0,0,18,6,8,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,11,0,0,0,9,7,12,6,0,0,0,0,0,0,0,0,
-0,0,12,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,7,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,8,7,0,0,0,6,10,0,0,0,9,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,6,
-10,7,0,0,0,7,0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,
-0,0,0,8,7,8,6,0,0,11,7,10,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,4,8,7,0,0,0,0,0,0,0,0,
-0,5,0,0,13,0,0,0,0,5,0,0,9,7,0,0,0,0,0,0,0,4,0,0,11,0,0,7,0,0,0,0,0,0,0,0,0,6,0,
-0,0,0,0,0,12,7,19,0,8,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,10,6,8,0,0,0,0,0,0,0,0,0,0,
-6,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,7,0,0,12,0,0,0,0,6,9,6,
-14,0,0,0,0,0,0,6,0,5,0,0,8,7,0,0,0,6,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,5,0,
-7,0,0,10,0,9,7,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,12,6,0,0,0,0,0,5,0,6,0,0,0,0,
-0,0,0,0,0,0,0,6,0,0,0,0,9,7,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,0,0,0,11,7,0,0,13,7,
-0,0,0,0,0,0,0,0,12,0,0,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,6,11,5,0,5,13,0,8,0,
-0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,11,5,
-9,6,0,0,0,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,10,0,0,0,8,5,0,0,9,0,0,0,8,7,9,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,0,
-0,11,0,13,6,0,0,9,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,
-0,0,0,0,0,5,21,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,5,0,0,0,0,0,0,0,0,10,0,8,0,
-0,6,0,0,0,4,0,0,9,0,0,0,0,0,0,0,0,0,0,4,0,0,8,6,0,6,0,7,10,0,8,4,0,4,0,0,0,0,0,
-5,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,6,12,0,0,7,0,0,0,5,0,0,
-0,0,0,0,0,0,0,6,0,0,8,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-15,7,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,24,7,0,0,0,0,0,0,0,0,0,
-7,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,
-0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,4,12,0,0,7,0,0,0,0,0,5,0,0,0,0,0,0,0,0,15,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,8,0,0,0,
-0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,9,0,9,6,
-0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,8,4,0,7,0,0,0,0,0,0,0,0,
-22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,4,0,7,0,0,21,7,0,7,9,6,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,8,0,0,6,
-0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,23,0,0,0,0,7,0,0,0,
-4,0,0,0,0,0,0,0,0,9,4,11,7,0,5,0,0,0,0,11,0,0,4,20,0,0,0,0,0,0,0,0,0,0,0,11,5,0,
-7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-21,0,0,0,0,0,0,7,0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,11,6,0,0,0,0,0,0,0,0,9,6,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,5,0,4,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,
-0,0,0,10,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,7,0,0,11,7,0,0,0,0,0,0,0,4,
-0,4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,8,7,0,
-0,0,0,0,0,0,0,0,6,0,0,21,6,0,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,14,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,8,0,0,7,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,
-0,0,0,8,7,0,0,11,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,7,13,7,10,4,0,
-0,0,6,0,0,0,0,0,0,0,0,0,5,10,0,0,0,0,0,0,5,0,0,0,7,0,0,0,0,0,0,8,4,0,0,0,0,0,6,
-0,0,0,0,0,0,0,0,0,0,12,7,0,6,0,0,10,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,
-0,0,0,0,7,0,0,8,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,10,5,0,6,0,0,0,0,0,4,0,0,0,0,
-0,0,0,0,0,4,0,0,0,0,9,0,11,4,0,0,0,6,0,0,0,5,12,7,0,5,0,0,0,0,0,4,0,0,0,7,0,0,0,
-0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,13,6,10,0,0,0,17,0,0,4,0,0,0,0,0,6,0,4,0,5,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,11,7,0,0,0,7,0,0,0,6,0,0,0,0,0,0,
-0,6,0,4,0,0,0,0,8,0,0,0,0,5,0,0,0,0,0,4,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,9,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,0,0,
-0,0,7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,16,4,0,0,11,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-8,7,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,8,6,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
-7,0,0,0,0,0,0,9,0,0,0,0,0,0,0,12,5,10,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,
-5,18,7,0,0,14,0,0,0,0,0,0,0,9,4,0,7,0,0,0,0,0,0,0,5,0,0,0,6,0,0,0,6,0,0,0,0,0,0,
-8,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,7,0,0,0,0,0,0,11,0,0,0,
-10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,14,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-11,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,14,6,0,0,0,0,11,4,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,10,7,0,6,0,0,9,0,9,5,0,0,0,0,0,
-0,0,0,10,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,8,5,0,0,0,0,0,0,0,0,0,0,11,4,0,6,
-0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,12,4,0,6,8,6,0,0,0,0,0,0,0,0,0,0,8,0,0,5,0,0,0,0,0,0,0,7,0,0,13,0,0,0,0,0,0,0,
-0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,12,7,0,6,0,0,0,
-0,0,0,0,0,0,0,0,0,13,4,0,7,0,0,0,7,0,7,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,0,0,0,0,
-9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,10,6,21,5,0,0,0,0,8,0,0,0,0,4,0,
-7,0,0,0,0,0,0,11,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,4,0,0,0,0,0,0,
-0,7,9,6,11,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,7,10,0,0,0,0,0,0,6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,19,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,18,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,9,4,10,4,0,7,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,9,7,9,7,10,4,0,7,0,0,0,0,0,0,0,6,12,0,
-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
-0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,8,0,
-0,0,0,0,0,5,0,0,8,7,0,0,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,
-0,0,0,0,4,0,0,8,0,0,6,0,0,0,7,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,7,9,7,0,0,0,4,8,0,0,0,0,6,11,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,10,0,0,0,0,0,0,0,13,4,0,0,
-12,6,0,6,0,0,0,0,8,7,0,7,0,0,0,0,0,6,0,0,0,0,0,0,12,6,0,4,0,0,0,0,0,0,0,0,0,0,9,
-7,22,0,0,0,0,4,0,0,0,0,0,6,0,0,0,4,0,0,9,0,0,6,0,0,24,7,0,7,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,10,6,0,5,0,0,0,0,0,0,0,7,0,0,8,0,0,0,0,0,0,0,10,5,0,0,0,0,0,0,0,0,0,7,0,
-7,0,0,0,0,0,0,13,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,0,
-0,0,0,0,0,7,12,0,9,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,8,0,0,0,0,0,0,0,0,4,0,0,0,7,0,
-0,0,0,8,7,0,0,0,0,0,0,0,0,0,4,18,0,0,0,0,0,10,0,0,5,0,0,11,0,0,0,0,0,0,5,0,6,0,
-0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,
-4,0,0,0,0,0,0,10,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,
-0,0,0,5,8,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,20,7,0,0,0,0,0,0,0,0,0,0,0,4,9,0,12,
-6,8,0,14,7,0,5,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,10,0,0,
-0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,9,6,0,7,12,0,0,0,0,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,
-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,4,0,0,9,0,
-12,6,0,5,0,0,0,6,0,4,0,6,0,0,0,0,0,0,0,0,10,7,0,0,0,0,0,0,8,0,0,0,0,4,0,0,0,0,
-10,0,0,0,0,0,0,0,8,6,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,0,0,0,0,
-6,0,0,12,6,20,5,0,0,0,0,0,0,0,0,0,0,0,0,9,5,0,5,0,0,0,6,13,7,0,0,0,0,15,6,0,0,0,
-6,0,0,13,7,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,5,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
-10,6,0,0,0,0,0,6,0,0,0,0,9,0,0,0,0,0,19,6,0,0,0,0,0,0,0,0,0,0,13,0,11,0,0,0,0,0,
-0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,0,10,0,0,6,0,0,0,0,8,0,0,
-0,9,0,15,4,0,6,0,0,0,0,0,6,12,0,0,0,0,0,0,0,14,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,
-0,0,0,0,0,8,7,0,0,0,0,0,6,10,0,0,0,0,0,0,0,0,7,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,7,10,5,0,0,0,0,8,0,0,0,0,4,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,6,12,0,0,0,10,7,0,5,0,6,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,6,0,4,0,0,0,0,0,7,0,0,0,0,0,0,0,4,9,6,0,0,0,7,0,0,0,0,0,0,0,0,8,6,0,0,
-0,0,0,0,0,4,12,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,7,0,
-0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,12,6,0,6,9,4,0,0,8,4,0,6,
-0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,8,0,0,6,13,4,0,5,8,0,0,0,0,0,0,0,8,0,0,0,10,5,0,0,9,0,0,0,0,0,0,6,0,0,
-24,0,0,0,0,0,0,0,8,0,0,7,0,0,12,0,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,
-6,8,0,10,0,9,7,0,0,0,5,0,0,0,0,0,0,0,4,8,5,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,4,0,0,0,0,0,6,0,0,0,0,0,5,0,0,0,0,8,0,0,
-0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,10,4,0,0,0,0,0,0,0,6,0,0,0,4,20,0,0,7,
-10,6,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,9,6,0,0,0,0,0,0,0,4,
-12,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,9,4,0,5,0,0,
-0,0,0,0,0,6,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,6,9,0,0,0,0,7,0,0,0,0,0,6,0,5,0,0,0,0,0,0,0,0,9,0,0,0,
-0,6,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,17,7,0,0,13,6,14,6,0,0,0,0,
-8,0,0,0,0,0,0,7,12,7,8,7,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,4,0,0,0,0,0,4,0,
-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,12,4,0,0,10,7,0,0,0,
-0,0,0,10,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,12,0,0,6,
-0,0,0,0,0,0,0,0,8,7,12,0,0,0,0,0,0,6,0,6,0,4,0,0,18,6,0,0,0,6,0,0,0,0,0,6,10,6,
-0,0,0,0,0,0,8,7,14,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,
-0,0,0,8,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,7,0,0,10,5,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
-0,0,9,4,8,0,0,0,0,0,0,4,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,0,0,0,
-0,6,0,0,9,7,0,0,0,0,0,5,0,0,0,0,8,7,0,0,14,0,0,0,0,6,0,0,0,0,0,0,9,6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,5,0,7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
-0,0,0,6,0,0,0,6,0,4,0,0,0,0,0,4,0,0,0,0,12,0,0,7,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,
-0,12,0,16,6,0,0,0,0,0,0,11,7,0,4,8,7,0,0,0,0,0,6,0,0,0,0,16,0,0,0,0,6,0,0,0,0,0,
-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,10,7,0,0,0,0,0,0,12,7,0,0,0,0,0,0,0,0,0,0,
-0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,13,4,0,0,10,0,0,0,0,0,0,0,0,0,19,0,0,0,
-0,0,0,0,0,0,0,0,0,0,8,6,22,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,
-5,0,0,0,0,0,5,0,0,0,0,0,5,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-4,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,0,18,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,14,7,0,0,11,5,0,0,0,5,0,0,0,0,12,5,0,0,0,0,0,0,0,0,0,0,24,6,0,0,
-0,7,0,4,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,7,0,4,0,0,0,0,8,7,0,0,
-9,6,0,0,14,5,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,12,6,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,7,0,0,0,5,0,0,
-0,0,12,7,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,6,0,0,13,7,0,0,0,0,0,0,14,0,11,4,0,
-0,0,4,0,0,0,0,14,5,0,0,0,0,0,5,11,5,0,0,0,0,22,5,0,0,0,0,0,7,0,0,0,0,0,4,0,0,0,
-4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,17,0,10,0,0,0,8,0,0,0,19,
-5,18,7,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,10,6,0,6,0,0,0,0,10,4,0,4,0,
-0,0,0,0,0,14,7,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,0,9,6,12,0,0,6,0,0,0,0,0,0,0,0,
-12,0,10,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,4,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,13,0,9,7,0,0,0,0,0,0,0,0,0,0,0,7,9,7,0,0,8,0,0,0,0,0,
-22,0,0,0,0,0,0,0,23,6,14,0,0,0,0,0,0,7,0,0,0,0,11,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,
-0,0,10,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,8,5,0,0,0,0,0,0,0,0,0,7,11,6,21,0,0,0,0,0,
-0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,
-0,0,0,0,0,0,0,4,9,7,0,0,0,0,0,0,12,0,0,0,0,7,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,9,
-0,0,0,20,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,11,7,0,0,0,0,0,0,0,6,15,0,0,
-0,0,0,0,0,0,0,0,0,0,0,12,4,0,5,0,0,0,0,0,0,11,7,17,6,0,0,0,0,0,0,15,6,0,7,0,0,0,
-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,6,0,5,
-0,0,11,0,11,7,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,
-17,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,8,7,9,6,0,0,14,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,
-8,7,0,4,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
-0,0,0,5,0,4,0,0,8,7,0,6,12,5,0,7,18,7,0,0,8,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,
-10,0,11,0,0,0,0,0,0,0,0,0,0,0,9,0,0,4,0,6,0,7,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,
-7,0,0,0,0,8,0,0,0,15,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,0,0,
-0,0,6,0,0,0,0,23,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,5,0,0,0,0,0,0,8,6,0,0,
-0,0,0,0,12,7,9,7,0,0,10,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,9,0,8,7,0,0,0,
-6,0,6,0,4,0,5,0,0,0,0,0,5,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,7,10,5,0,0,11,6,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,4,9,7,0,
-0,0,0,11,7,0,0,0,0,0,5,0,0,0,7,0,0,0,0,23,6,11,4,0,0,0,0,0,0,9,0,0,0,10,6,0,0,0,
-0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,10,6,0,0,0,7,0,0,
-0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,
-6,11,7,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,6,0,0,0,5,0,6,0,6,0,0,0,0,0,0,0,0,0,0,
-0,6,0,0,0,0,8,7,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,4,10,0,8,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,10,6,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,
-0,0,0,0,0,0,10,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,11,6,0,4,0,0,14,5,0,7,0,0,0,0,0,6,16,0,0,0,0,0,0,0,10,0,0,7,15,0,0,0,11,7,0,0,
-0,0,0,0,0,0,0,0,8,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,5,0,0,0,
-0,8,0,0,6,0,0,0,0,0,0,9,5,0,0,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,6,0,
-0,0,0,0,0,0,7,0,0,0,0,15,7,0,0,0,0,8,0,0,0,14,0,0,0,0,0,0,0,16,7,0,0,0,0,0,7,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,12,6,11,7,
-9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,
-7,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,12,0,10,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,8,0,0,5,8,7,10,6,0,0,0,7,0,0,0,0,12,6,
-0,0,9,0,0,0,12,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,10,0,0,0,10,5,0,0,0,0,0,0,9,6,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,6,0,0,9,5,0,4,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,9,0,0,5,0,0,8,7,8,
-6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,10,0,9,4,0,0,0,0,0,0,0,6,
-11,0,0,0,0,0,0,0,0,0,0,0,8,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,8,7,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,
-0,0,0,10,0,0,0,8,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,
-0,0,8,4,0,5,0,0,0,0,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,8,5,0,0,0,
-0,0,0,0,7,0,0,0,6,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,0,6,0,7,0,0,0,0,
-20,0,0,0,0,0,0,0,0,0,0,7,9,0,0,0,0,0,0,6,0,6,0,7,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,
-0,0,0,14,7,0,0,0,5,0,0,22,4,10,0,0,0,0,0,0,4,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,11,5,13,0,0,0,0,0,0,0,0,0,8,0,0,7,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,0,10,7,0,
-0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,7,0,7,14,6,0,0,0,0,9,5,
-0,0,0,0,0,6,0,0,0,5,10,0,8,6,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,6,0,0,8,4,0,6,0,
-0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,
-14,0,0,5,0,0,18,0,8,4,0,6,0,0,20,0,13,0,0,0,0,7,0,4,0,0,0,0,0,4,8,4,0,0,0,0,0,6,
-0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,4,0,0,0,0,0,0,0,0,14,0,0,0,0,0,9,7,0,0,9,0,0,0,0,
-0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,20,0,14,0,0,4,0,6,8,5,0,0,0,0,0,7,0,0,0,0,0,0,
-0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,10,4,12,7,0,6,0,0,9,7,10,5,
-0,0,8,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,0,0,18,0,0,0,14,7,0,0,0,0,0,4,
-0,0,0,0,0,0,17,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,4,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,
-0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,8,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,5,0,7,0,0,0,0,0,
-7,0,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,8,5,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,5,0,
-0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,23,0,0,7,0,0,0,0,0,0,
-0,0,0,0,0,0,0,4,0,0,0,0,0,0,12,7,8,4,0,0,0,0,0,0,0,0,0,6,0,0,9,5,0,0,0,7,0,0,0,
-0,0,0,0,0,0,4,10,0,0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,5,0,0,18,7,
-0,0,8,0,0,5,0,0,10,0,0,0,0,0,0,6,0,0,0,0,0,5,0,7,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,
-6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,6,0,0,10,0,0,5,10,4,0,0,12,0,0,0,0,
-6,22,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,7,0,5,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,6,0,7,0,0,0,6,0,6,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,7,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,
-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,16,6,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,12,7,0,0,0,0,9,0,0,0,0,6,0,0,11,0,0,0,0,0,13,0,9,6,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,0,0,10,7,0,0,0,7,0,6,0,
-0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,11,0,15,0,22,7,0,4,0,6,0,0,0,0,0,7,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,
-18,0,0,0,0,0,0,0,0,0,14,0,0,4,0,0,0,0,8,7,9,0,0,0,0,0,9,0,0,0,14,0,0,0,0,0,0,0,
-0,0,11,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,7,0,0,0,6,0,6,0,0,0,0,8,0,0,0,0,
-0,11,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,9,4,0,0,0,0,0,4,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,8,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,
-0,0,0,0,0,0,8,6,0,0,9,5,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,5,0,
-0,10,6,9,0,0,0,0,6,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
-11,7,12,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,4,0,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,
-0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,5,0,0,10,6,
-0,0,0,4,0,7,13,0,0,4,0,0,11,4,0,6,0,0,0,0,0,6,8,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,5,0,0,0,0,12,6,0,0,0,0,
-11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,11,5,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,
-7,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,6,17,0,9,0,10,6,0,6,12,0,0,4,0,0,0,
-0,0,0,0,0,0,0,8,5,12,7,0,4,0,0,0,0,0,0,0,0,0,0,11,0,9,0,10,6,11,5,0,7,0,0,8,0,0,
-7,0,4,0,0,0,7,0,0,0,0,0,0,8,6,0,0,0,6,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,6,0,
-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,11,0,0,0,0,6,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,10,0,0,0,0,0,8,6,0,0,0,0,0,6,12,0,0,0,0,0,
-0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,6,0,0,16,0,11,5,0,0,0,0,0,
-0,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,9,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,6,10,
-7,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,0,9,5,0,0,0,0,8,0,9,0,0,
-0,0,0,0,0,0,7,10,0,13,0,0,6,0,0,0,0,0,0,0,0,0,6,9,4,0,0,0,0,0,0,10,0,0,0,0,0,10,
-0,0,0,0,0,0,0,10,6,11,0,0,0,0,0,9,0,0,0,0,0,0,4,0,0,0,0,0,0,10,5,0,0,0,0,0,6,0,
-0,0,0,0,0,18,4,0,7,0,0,0,0,0,0,24,0,8,6,0,7,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,
-0,8,5,0,0,0,0,10,7,0,6,0,0,0,0,0,0,0,0,8,5,10,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,
-6,0,0,8,7,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,4,0,5,15,0,0,0,0,7,0,7,0,0,0,0,
-0,0,0,0,0,6,10,5,0,0,0,6,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,12,0,0,0,0,0,0,0,0,
-0,0,5,0,0,0,0,0,0,14,4,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,11,0,10,4,9,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,7,0,0,0,
-0,0,0,0,0,0,0,0,7,13,7,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,
-0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,8,0,10,6,0,4,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,
-0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,9,7,0,0,0,0,0,6,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,6,0,0,0,
-0,0,0,0,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0,0,5,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,11,0,0,0,0,6,0,0,0,0,0,0,0,6,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,0,0,
-6,0,0,0,0,0,0,0,6,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,
-0,0,0,0,0,0,0,6,0,6,0,0,0,5,0,0,0,0,0,0,0,5,0,0,10,0,11,5,0,0,0,0,0,0,14,7,9,7,
-0,6,0,0,0,0,0,4,0,0,0,0,0,0,11,7,0,6,0,0,0,0,0,0,9,7,0,4,0,0,0,7,0,0,0,0,0,5,0,
-0,0,0,0,5,0,0,0,7,0,0,0,0,0,5,0,0,0,0,17,5,0,0,8,0,0,0,0,6,9,4,0,0,0,0,0,0,0,0,
-8,7,11,7,9,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,6,9,5,0,0,8,6,0,0,0,5,0,
-0,0,0,9,0,0,0,9,6,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,
-0,0,0,0,4,0,0,0,0,10,0,0,0,0,0,0,0,0,4,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,4,0,0,0,5,0,0,0,0,0,7,0,0,0,0,0,7,13,5,0,0,0,7,0,0,0,0,0,7,9,6,11,7,0,7,0,0,0,
-0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,8,5,0,0,0,5,9,4,0,0,0,0,0,0,0,0,8,4,0,0,0,0,
-24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,
-0,0,0,0,6,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,5,11,6,0,4,0,7,20,0,8,5,9,5,9,0,0,6,
-0,0,0,0,0,0,0,0,0,0,0,7,23,5,0,0,8,4,0,0,10,0,0,6,0,5,0,0,0,0,0,0,0,0,0,0,0,7,0,
-0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,9,0,0,0,
-10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,
-6,0,0,0,0,14,0,18,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,9,6,0,4,0,0,0,0,0,0,8,4,
-11,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,12,0,10,7,0,0,10,0,0,0,0,
-0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,6,0,0,0,0,8,
-6,10,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,4,0,6,0,4,0,0,0,0,0,5,0,0,
-0,0,0,0,0,0,0,7,0,0,0,7,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,17,7,11,0,0,0,0,0,0,0,0,0,0,4,12,6,0,0,0,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
-0,5,12,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,6,0,0,20,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,4,
-0,0,0,5,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,6,0,4,13,0,0,7,0,0,0,0,0,0,
-0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,12,6,0,7,0,0,0,0,10,0,23,6,0,0,
-0,4,0,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-10,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,11,0,9,7,0,0,
-0,0,0,0,0,0,0,0,9,7,0,4,0,0,0,0,8,7,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
-0,0,0,0,0,6,0,0,10,7,10,5,0,0,8,0,8,0,0,0,0,0,0,4,0,5,10,0,0,0,0,0,0,0,9,0,0,6,
-0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,11,7,0,0,0,0,0,0,0,0,9,4,0,0,0,0,0,6,0,0,8,
-7,0,0,0,0,0,5,0,0,0,0,0,0,0,0,10,0,0,0,0,5,0,4,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,24,7,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,6,0,0,9,0,0,0,0,0,0,7,0,6,13,0,8,
-0,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,6,0,0,0,0,8,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,
-4,0,0,0,0,0,4,0,0,0,0,0,0,0,6,8,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,4,0,4,0,0,0,5,0,7,0,0,10,0,10,7,0,0,12,5,0,0,9,0,0,0,10,0,
-0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,
-12,0,0,0,0,0,8,5,13,6,0,0,0,0,0,0,9,4,0,0,0,0,8,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,
-0,0,6,0,0,14,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,17,6,0,0,0,0,12,6,0,0,0,0,8,0,0,7,0,
-7,0,4,9,0,0,6,0,0,0,6,0,0,0,0,0,0,8,7,0,0,0,0,0,0,11,0,0,4,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,18,7,0,4,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,6,0,0,0,0,0,
-0,0,0,12,5,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,8,0,11,7,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
-11,0,0,0,0,0,0,0,21,0,0,6,10,0,0,0,0,0,9,0,10,0,0,0,0,0,11,0,0,0,0,6,0,0,0,0,0,
-5,0,0,0,0,0,0,10,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,4,0,0,23,7,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,9,7,0,0,0,7,
-0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0,
-11,6,0,0,0,0,0,0,0,6,0,0,0,0,10,7,0,0,9,4,0,0,11,0,8,5,0,0,0,7,8,5,22,0,0,0,9,6,
-0,0,0,0,0,0,0,6,10,4,0,0,0,0,0,7,9,4,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,
-0,0,0,11,6,0,0,0,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,7,0,0,0,0,0,0,0,6,0,6,0,4,0,0,
-0,0,0,0,0,7,0,7,0,4,13,0,0,0,0,0,8,0,0,0,0,7,0,0,0,0,0,0,11,6,0,7,0,0,0,0,9,0,0,
-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,8,0,0,0,0,0,8,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,6,0,0,0,0,13,5,8,0,0,
-0,0,0,0,0,14,0,0,6,0,0,0,0,0,0,0,0,0,7,0,0,17,6,0,0,0,0,13,4,0,0,9,6,0,0,10,5,0,
-0,10,5,0,0,0,0,13,0,0,0,0,6,0,0,0,0,0,0,10,0,12,0,0,0,0,0,0,0,0,0,0,0,8,4,0,4,0,
-0,0,4,0,0,0,0,0,4,0,0,12,0,0,5,9,4,0,0,0,0,0,0,0,0,0,5,8,5,0,0,0,7,0,0,0,0,8,7,
-0,0,0,6,12,5,0,0,0,5,0,0,0,5,0,0,0,0,0,4,12,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,7,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,
-0,9,6,0,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,4,11,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,
-0,0,0,0,12,7,0,0,0,7,10,7,0,0,11,0,0,0,0,0,0,0,0,0,11,7,0,0,0,6,0,0,11,0,0,0,0,
-0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,22,0,10,7,0,0,8,5,0,0,0,0,0,5,0,0,0,0,0,0,
-0,0,0,0,9,6,8,7,0,6,0,0,0,0,0,5,0,0,0,0,0,0,8,7,0,0,0,0,9,7,0,0,0,6,0,0,8,7,0,0,
-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,4,0,5,0,0,0,4,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,6,0,0,0,0,0,0,0,4,0,0,0,0,0,0,9,
-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,5,0,0,0,0,14,0,0,0,
-9,0,0,0,0,0,0,0,0,0,9,7,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,12,0,0,0,0,0,12,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,10,7,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,6,0,0,0,0,0,0,9,6,0,0,0,0,0,6,0,0,0,0,0,
-0,0,0,0,0,9,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,6,0,7,12,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
-0,7,0,0,8,6,0,0,0,0,10,7,0,0,0,0,0,0,0,6,0,0,0,0,0,6,12,0,0,0,0,0,0,0,0,6,0,0,0,
-0,0,6,0,0,0,6,0,0,0,0,0,6,16,0,0,0,0,0,0,0,0,0,9,0,17,0,14,7,8,0,0,0,0,0,0,6,0,
-0,0,0,0,0,0,0,0,0,11,0,0,6,8,7,0,6,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,0,0,
-9,0,0,0,0,7,0,0,0,0,11,5,0,4,9,6,8,0,0,0,0,0,0,0,0,0,10,0,11,7,0,0,0,0,0,0,0,0,
-9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,
-0,0,0,12,0,0,0,0,0,10,5,0,4,0,0,0,0,0,7,10,6,11,6,0,0,0,0,0,0,0,0,0,0,0,0,17,0,
-0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,8,0,0,4,0,0,0,6,0,0,0,
-0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,4,0,0,0,0,9,6,0,0,0,4,0,0,0,0,0,4,10,7,0,7,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,
-0,0,0,0,0,0,6,0,0,0,6,0,6,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,18,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,13,0,0,0,0,0,10,0,0,0,0,0,0,0,0,4,
-0,0,0,6,0,0,0,0,0,4,8,0,0,0,11,7,0,0,0,4,0,0,0,0,0,7,0,0,8,5,0,0,16,0,0,0,13,6,
-0,0,0,0,0,0,0,6,0,0,0,0,20,0,11,6,0,0,8,7,0,0,0,0,0,6,17,0,8,0,0,0,0,0,8,7,0,0,
-9,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,
-0,0,4,0,7,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,8,
-0,8,0,0,0,0,0,0,0,11,0,8,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,6,0,0,9,0,
-0,0,0,0,8,0,0,0,0,0,18,0,0,0,0,0,0,4,9,0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,9,6,0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,8,7,0,0,0,0,0,0,0,0,
-0,4,0,0,0,0,0,0,14,0,0,0,0,7,0,6,0,0,8,0,20,7,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,8,0,0,0,14,0,0,0,0,0,0,0,8,0,0,7,0,6,0,0,0,7,0,0,0,0,0,0,0,0,
-0,0,0,4,12,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,10,6,0,
-5,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
-0,0,0,5,8,4,0,0,0,0,0,0,0,4,0,0,0,7,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,12,7,0,
-0,0,0,13,6,0,0,0,7,0,0,8,0,0,0,8,0,0,0,0,0,0,0,0,0,0,5,0,0,0,7,0,0,0,0,0,0,11,5,
-0,6,0,0,8,5,0,7,0,0,0,0,0,0,0,7,0,0,0,0,8,6,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,4,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-14,0,10,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,19,0,0,4,0,0,0,7,
-0,0,11,5,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,16,0,10,5,18,0,0,7,9,6,0,5,0,0,0,0,0,
-0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,5,0,0,0,7,0,6,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,4,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,23,0,0,0,0,5,0,0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,14,0,20,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,
-11,0,0,0,0,7,0,0,0,0,15,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,7,0,0,0,0,
-0,4,0,0,0,0,10,0,0,0,0,0,9,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,10,0,11,6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,5,0,0,11,0,0,0,0,7,0,0,0,0,0,0,8,7,0,
-4,0,0,0,0,11,0,0,0,0,0,11,0,0,5,0,0,8,7,0,4,0,7,0,0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,0,0,
-0,0,4,11,5,10,7,0,7,0,0,9,6,9,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,9,4,0,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,8,6,0,0,0,0,11,7,0,0,0,0,0,0,0,0,0,0,11,7,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,8,5,0,0,8,0,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,
-10,7,0,0,0,6,0,0,0,0,0,0,8,0,0,6,0,0,0,6,10,0,0,0,0,0,0,0,0,0,0,0,8,5,0,0,0,6,0,
-0,0,6,0,0,0,0,9,5,8,5,8,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,
-0,8,7,10,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,0,5,0,0,0,6,0,7,0,0,
-10,5,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,11,0,0,0,0,0,13,4,
-0,0,0,4,0,0,0,0,0,5,8,0,0,0,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,7,14,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,7,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,5,0,0,15,6,10,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,14,6,10,0,0,0,0,0,0,0,0,6,0,
-0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,6,0,5,11,4,0,6,0,0,0,7,0,0,0,0,
-0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,5,0,0,8,5,0,0,0,0,0,0,0,0,0,0,
-0,0,10,0,0,0,0,0,9,6,9,4,0,0,0,4,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,8,5,0,
-0,0,0,0,0,0,0,0,0,0,4,0,0,11,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,
-0,0,0,7,12,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,
-4,9,6,0,4,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,6,0,
-7,8,6,0,0,0,0,0,0,0,4,0,0,9,6,0,0,0,0,0,0,0,0,0,6,0,5,0,4,0,0,0,0,0,0,0,5,0,0,0,
-0,0,5,0,0,0,7,12,7,0,0,0,0,0,0,18,4,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,6,0,0,0,
-0,12,0,0,7,0,0,0,0,0,7,0,0,13,0,0,6,0,0,0,0,8,7,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,7,10,5,0,0,8,0,0,0,0,0,0,0,8,6,0,7,0,0,8,4,0,4,0,0,0,0,10,4,0,0,14,0,
-0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,17,0,0,0,0,0,0,6,0,0,0,0,8,6,0,0,10,5,0,0,0,0,8,
-6,0,0,0,6,0,0,0,7,0,0,0,0,0,6,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,12,0,0,0,0,6,
-8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
-0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,4,24,0,0,
-0,0,0,12,6,0,0,10,6,0,5,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,17,7,0,5,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,11,5,9,0,8,7,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,10,7,0,0,0,0,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,5,8,7,0,0,0,
-0,8,5,0,0,0,0,10,7,0,7,0,0,0,0,0,0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,6,0,4,0,0,0,0,
-0,6,12,0,8,7,0,0,0,0,0,0,0,0,0,0,16,0,10,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,22,0,0,0,
-0,0,0,0,0,0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,22,0,0,6,0,0,21,0,0,0,22,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-6,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,7,8,0,0,0,0,6,14,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,6,0,0,0,0,0,0,
-0,0,0,0,0,6,0,0,0,0,8,5,0,0,11,7,0,6,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,
-6,0,0,0,5,0,0,0,0,0,0,0,0,0,4,0,0,8,7,0,0,0,0,8,5,11,7,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,8,5,0,0,10,0,0,4,13,7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,0,0,13,6,
-0,6,0,7,0,0,8,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,15,0,0,0,10,7,0,0,0,0,0,
-7,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,19,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,6,0,5,
-0,7,0,0,0,0,0,0,0,0,0,6,0,0,11,4,0,0,0,6,0,0,13,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,8,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,
-0,7,0,0,0,0,0,0,11,7,0,0,0,0,0,6,0,0,10,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,5,11,6,
-0,0,0,0,0,0,0,0,10,0,0,0,0,6,0,0,0,0,0,0,8,7,0,0,0,5,0,0,0,5,0,0,0,0,0,0,0,0,0,
-0,0,0,8,7,0,0,0,0,9,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,10,0,
-0,6,0,0,13,0,0,0,0,0,0,0,9,6,0,0,8,6,8,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,0,
-0,9,7,0,0,0,0,0,0,11,0,0,0,10,7,0,0,0,0,0,0,0,0,9,6,0,0,12,4,0,4,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,6,0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,5,0,0,
-9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,
-16,0,0,4,0,0,0,0,0,7,0,0,0,6,0,6,0,0,11,0,0,0,0,5,0,0,0,0,0,0,0,4,8,5,0,0,0,0,0,
-0,14,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,
-0,0,8,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,
-0,0,0,0,6,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,14,7,0,0,9,7,0,0,11,0,0,0,0,0,10,
-4,11,5,13,6,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,5,0,0,0,0,0,4,0,0,9,0,0,0,0,
-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,6,12,5,0,0,0,6,14,0,0,0,0,0,0,0,0,0,0,4,9,4,
-0,0,0,0,0,5,0,0,0,0,0,0,0,4,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,5,0,0,
-0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,11,6,0,0,13,7,0,0,13,6,0,7,0,0,0,0,0,0,8,6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,10,6,0,4,0,0,12,6,0,0,0,0,0,0,0,0,10,6,
-0,0,0,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,6,0,
-0,0,0,0,7,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,6,0,
-0,0,7,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,
-0,0,0,5,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,
-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,8,7,0,0,8,5,0,0,0,4,9,5,0,0,0,7,10,6,0,0,
-0,0,0,0,9,7,0,0,8,5,8,0,8,4,0,0,13,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,
-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,
-0,11,7,0,0,0,7,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,5,0,0,0,7,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,9,7,0,0,0,0,8,5,0,4,0,0,0,0,0,6,0,6,14,
-6,0,0,0,0,9,6,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,6,0,0,0,0,14,7,9,7,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,16,
-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,14,0,
-0,6,0,0,8,6,0,0,0,0,0,6,0,0,12,0,0,0,0,0,8,5,0,7,11,0,0,5,0,4,0,0,0,6,0,0,0,0,0,
-0,0,0,0,0,0,0,9,6,0,4,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,10,5,0,0,0,0,
-0,4,0,0,0,7,11,6,0,4,8,5,9,5,0,0,0,5,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,8,5,14,7,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,16,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,9,6,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,9,0,0,0,12,5,0,0,0,0,0,0,0,4,10,5,0,0,0,0,0,0,0,0,0,0,0,6,0,
-0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,4,0,0,0,6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,10,4,0,0,0,0,0,5,0,0,0,4,
-0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,8,0,10,7,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,10,7,0,0,0,0,0,0,0,0,15,0,0,0,
-0,0,0,0,0,0,0,7,0,0,0,0,0,7,10,7,9,7,0,0,0,7,0,0,8,0,0,0,0,0,0,0,9,0,0,0,8,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,8,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,7,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,15,7,12,6,0,0,0,7,0,5,0,0,0,0,0,0,0,0,0,0,0,0,18,0,0,5,0,0,0,0,
-0,0,0,6,9,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,9,7,0,0,14,0,0,0,11,7,0,0,0,0,0,
-0,0,0,0,0,0,4,0,0,11,7,0,0,0,0,8,0,0,0,0,0,0,6,8,7,0,0,0,7,10,4,0,0,0,0,0,0,0,0,
-0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,10,0,0,0,0,0,0,
-6,0,6,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,11,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,7,0,0,10,7,0,0,0,0,9,7,0,0,0,0,0,0,13,7,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,12,0,
-0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,9,6,0,0,11,0,0,
-0,0,0,14,4,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,7,0,0,
-0,0,0,6,0,7,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,0,20,
-7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,8,0,0,0,0,0,0,0,0,0,11,5,0,0,0,0,0,0,0,0,0,0,10,4,0,0,0,5,8,5,10,4,0,0,0,0,0,
-0,13,6,9,7,0,0,10,7,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,6,0,0,0,7,0,6,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,10,7,0,0,
-0,0,0,0,0,0,0,0,12,4,0,0,0,0,8,7,0,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,
-0,0,0,0,6,0,6,9,6,0,0,12,5,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,0,
-0,0,0,0,0,0,0,0,0,5,8,7,9,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,11,
-4,0,0,0,0,0,0,8,0,0,0,10,7,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,0,
-0,0,0,0,0,5,0,6,0,0,10,0,14,0,0,0,0,0,0,0,23,0,0,0,12,0,10,5,0,0,0,0,0,0,0,0,0,
-5,0,0,0,0,8,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,22,0,8,0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,
-0,0,0,0,0,6,18,4,0,0,0,7,10,6,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,
-0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,7,10,0,0,0,0,0,0,6,0,0,0,0,11,5,0,0,0,0,0,0,0,0,
-15,0,8,6,0,0,13,7,0,0,0,0,0,7,0,0,0,0,0,7,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,9,5,9,
-0,0,6,8,6,0,0,0,0,10,0,0,0,18,5,0,0,0,5,0,7,0,0,0,0,8,6,0,0,0,0,9,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,14,0,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,6,0,0,0,5,0,
-0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,8,5,0,0,0,0,0,0,0,0,9,0,0,0,0,4,0,0,0,0,0,0,0,0,
-0,0,0,0,20,5,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,9,5,0,0,0,0,0,0,8,4,24,0,0,0,0,0,0,
-0,0,0,0,0,0,0,9,7,0,0,0,0,10,5,0,0,8,5,0,0,0,0,0,0,0,0,12,7,0,6,0,0,10,6,0,0,0,
-0,14,0,0,4,9,5,0,0,0,0,0,0,9,0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,8,0,0,0,0,0,11,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,8,5,11,7,0,4,0,0,10,0,0,0,0,
-0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,11,6,0,0,0,0,0,5,14,6,0,0,0,0,10,0,0,
-0,13,4,0,0,0,0,0,0,0,0,0,0,0,6,0,0,10,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,7,12,0,10,6,0,0,0,0,0,0,10,0,0,0,0,0,10,0,9,
-7,0,0,0,0,0,0,0,0,0,0,0,0,0,7,8,0,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,0,9,7,0,0,0,
-0,0,0,0,0,0,0,0,0,24,0,11,7,0,7,0,0,0,0,0,0,8,6,0,0,0,0,0,0,8,7,0,0,0,0,0,5,0,0,
-0,6,9,0,0,0,23,5,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,7,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,0,0,18,4,0,0,11,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
-0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,9,0,0,0,11,0,0,0,23,0,0,
-0,10,4,0,0,0,0,0,7,0,0,0,7,0,0,0,0,0,4,0,0,0,0,0,7,0,0,19,0,11,0,0,0,0,0,12,7,0,
-0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,5,0,0,0,0,0,5,0,0,0,0,0,5,0,0,0,0,0,0,0,6,0,0,
-9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,4,0,0,0,0,10,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,22,0,8,7,10,4,11,0,13,5,8,7,9,0,8,7,0,0,0,7,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,
-0,8,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,4,0,0,0,4,11,0,0,6,0,0,8,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,5,0,0,
-20,0,0,0,0,0,0,0,0,0,11,0,0,0,0,5,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,7,0,0,14,0,0,0,9,0,13,7,0,0,0,0,0,6,0,7,0,0,8,6,10,6,0,0,8,6,0,0,0,6,0,
-0,12,6,9,0,0,0,0,0,0,5,9,0,12,4,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,8,5,0,0,0,0,0,
-0,0,4,8,0,0,6,8,0,0,0,0,0,0,0,0,0,13,6,0,7,0,0,0,0,0,6,8,7,8,6,0,0,0,7,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,18,0,11,4,0,0,0,5,0,0,0,0,0,0,0,0,0,0,
-0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,14,
-6,0,0,0,0,12,7,8,0,0,0,0,0,0,0,8,7,0,0,0,0,10,4,0,0,0,0,0,0,10,0,0,6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,15,6,9,7,0,0,0,0,0,0,15,6,11,7,0,0,0,7,0,0,21,0,0,
-0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,17,6,0,0,10,5,0,5,0,0,0,0,0,0,0,0,0,7,
-0,0,10,0,0,0,0,0,0,0,0,4,11,5,0,0,0,0,16,7,0,0,0,0,0,6,0,0,8,7,0,4,0,0,10,0,0,0,
-0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,8,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,
-0,0,0,10,4,0,0,0,0,0,0,0,0,0,6,0,5,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,
-0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,6,10,7,0,0,0,0,0,0,0,0,8,4,0,0,10,0,0,0,0,4,0,6,0,6,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,7,17,0,0,0,0,0,
-0,0,0,0,0,0,10,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-6,0,0,0,5,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,5,0,4,0,0,0,0,0,6,0,0,0,0,0,0,10,5,0,0,
-0,5,0,0,0,0,9,0,19,7,0,0,0,0,0,7,0,0,0,0,10,6,0,0,0,6,0,5,0,0,0,0,0,0,0,0,0,6,8,
-0,0,0,0,0,11,0,0,0,0,0,0,6,0,0,0,0,0,7,9,0,15,0,0,0,0,0,0,0,0,0,0,4,0,0,0,5,0,0,
-0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,0,0,0,9,0,0,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,6,0,0,
-0,0,0,6,10,0,0,0,0,0,0,0,23,0,14,0,0,0,0,7,0,0,0,0,0,7,0,0,9,0,0,0,0,7,0,0,0,0,
-0,6,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,
-0,0,0,0,0,9,5,0,0,0,0,0,4,0,0,0,0,9,5,0,0,0,0,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,10,0,0,0,0,0,0,5,0,4,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,11,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,14,7,0,0,12,7,0,0,0,
-0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,8,6,10,0,0,0,0,0,0,0,0,0,10,7,8,5,0,0,0,0,0,0,
-0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,5,0,0,9,5,0,0,0,0,0,5,0,0,0,0,0,4,0,0,0,
-0,0,0,0,0,0,0,12,4,11,0,0,0,9,0,11,7,0,0,0,0,0,0,10,6,0,0,0,6,0,0,0,0,15,5,0,0,
-11,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,4,0,4,0,6,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,8,0,0,0,19,7,0,4,0,0,9,0,0,0,0,0,10,0,
-0,6,0,0,13,0,12,6,0,0,0,0,0,0,0,0,10,7,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,13,7,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,4,9,0,0,0,10,0,0,0,0,0,0,0,
-0,5,0,0,0,0,0,0,10,0,23,6,0,0,0,6,8,0,0,0,0,0,0,0,0,0,17,7,0,0,0,0,11,6,22,5,0,
-0,9,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,5,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,4,11,0,9,4,0,0,
-0,7,0,7,0,0,0,0,0,0,12,4,0,0,0,0,0,0,0,0,0,0,0,0,11,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-4,0,0,11,5,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,6,0,0,0,4,0,0,0,0,
-0,0,0,0,0,7,0,0,0,4,0,0,10,4,0,0,0,0,0,0,0,7,0,7,0,0,0,6,0,0,0,0,8,6,0,6,0,6,0,
-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,6,22,6,12,0,0,6,0,0,0,6,0,0,0,0,0,7,0,0,0,0,11,0,0,0,
-9,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,6,0,0,0,6,0,6,0,0,8,7,0,0,0,4,9,7,19,0,0,0,0,0,0,0,0,0,9,6,10,6,0,6,0,0,0,
-4,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,6,16,7,10,6,0,0,23,6,11,7,0,4,0,0,0,0,0,0,0,0,0,
-5,0,0,0,0,10,7,0,0,0,0,0,7,0,0,0,0,0,0,15,0,10,0,0,0,14,6,0,0,0,0,0,0,0,0,0,0,0,
-5,0,0,0,0,0,0,0,5,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,5,0,0,11,5,0,0,0,0,0,0,0,0,0,0,
-0,4,0,0,0,0,0,6,0,0,10,0,0,0,0,7,0,0,0,0,0,0,10,6,0,0,0,0,8,4,0,0,0,7,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,12,5,0,0,0,0,
-0,6,0,0,0,0,9,6,0,0,0,0,0,0,0,6,9,0,0,0,0,6,0,0,0,0,8,7,0,0,0,0,0,0,0,6,0,0,0,0,
-0,0,0,0,0,0,10,5,0,0,0,0,0,0,8,6,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,8,5,0,0,0,0,0,7,0,7,0,4,0,0,10,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,5,0,0,0,0,13,
-7,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,7,0,0,13,0,0,0,0,0,0,0,0,7,10,5,0,0,0,0,0,0,9,7,0,0,8,6,9,
-5,0,0,0,0,0,6,12,0,0,0,0,0,0,0,18,6,0,0,0,0,0,0,0,0,19,7,0,4,0,0,0,0,9,5,0,5,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,7,0,0,0,0,0,0,14,0,0,0,23,7,8,7,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,22,0,0,7,0,0,0,0,0,0,0,0,9,7,8,4,0,
-0,0,0,0,0,0,0,8,5,0,6,0,0,0,0,0,6,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,
-8,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,12,5,0,0,0,0,0,0,0,0,0,0,8,6,0,0,11,7,0,0,0,
-0,12,0,8,6,19,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,11,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,11,7,0,0,0,0,0,4,10,0,0,0,0,0,0,0,8,7,0,0,0,0,14,0,8,0,0,6,10,0,0,
-0,0,0,0,0,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,0,0,
-0,0,0,0,13,0,0,0,0,0,0,0,11,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,
-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,5,0,0,0,6,0,0,0,5,0,7,0,0,0,
-0,0,6,0,0,21,7,0,0,9,6,0,0,0,6,0,0,13,7,0,0,0,5,0,0,0,0,0,4,0,6,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,0,11,5,0,6,0,0,10,5,0,0,0,0,0,0,0,0,9,6,0,0,8,7,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,9,0,0,0,0,0,0,6,0,0,0,0,15,4,0,0,12,7,0,0,0,6,
-0,7,0,0,8,0,9,5,0,4,0,0,0,6,0,6,0,0,23,4,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,4,0,0,8,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,0,0,0,0,0,0,
-7,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,12,6,0,0,0,0,0,0,10,7,0,7,0,0,0,0,0,0,0,0,0,0,
-9,0,0,0,0,0,8,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,11,5,0,0,0,6,0,6,0,0,0,0,0,0,0,6,0,
-4,0,0,0,0,0,0,0,0,0,0,0,5,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,8,7,0,0,0,6,0,6,0,
-0,0,0,0,0,0,0,0,5,0,0,0,0,0,5,0,0,0,0,11,0,0,0,0,0,0,0,10,5,9,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,23,7,0,0,0,0,0,7,0,0,10,6,18,0,0,0,
-0,0,0,0,8,7,0,6,0,0,0,0,0,0,8,5,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,
-0,0,0,0,0,6,0,0,0,4,12,7,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,13,5,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,
-11,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,
-0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,10,0,11,0,0,0,0,0,0,0,0,0,
-17,5,0,4,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,0,0,0,8,7,0,0,0,0,0,0,0,
-0,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,
-10,0,0,0,8,6,0,0,0,7,0,0,0,0,0,0,8,0,0,0,14,0,0,0,0,7,0,0,0,4,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,9,4,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,
-10,0,0,0,16,5,0,0,0,0,0,0,8,0,0,4,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,10,0,0,0,
-0,0,0,0,0,5,0,0,0,0,12,5,0,7,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,
-0,0,0,0,0,0,0,12,6,0,0,0,0,0,7,0,6,0,6,12,6,0,0,0,0,0,0,0,4,8,7,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,10,6,8,0,0,
-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-16,0,8,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,23,5,0,0,0,7,0,6,0,
-0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,14,0,0,0,0,7,0,0,0,4,17,5,0,0,0,0,11,0,9,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,6,0,0,0,5,0,7,0,0,0,0,0,0,0,0,8,0,0,0,
-12,6,0,0,0,0,0,0,13,0,0,0,0,7,9,0,0,0,0,0,0,0,0,0,0,5,0,0,0,7,10,7,12,0,0,0,9,0,
-0,0,14,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,15,6,0,0,23,0,0,7,0,6,0,0,0,7,0,6,
-0,0,0,0,0,0,0,6,0,6,9,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,8,7,9,4,0,0,10,0,0,0,10,
-6,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,6,0,0,0,0,0,0,9,4,
-0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,0,9,6,0,0,0,0,8,6,0,0,0,0,0,0,0,0,12,0,0,
-0,0,0,8,0,0,6,11,6,0,0,8,7,8,5,0,0,0,0,0,5,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,0,
-10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,
-7,0,0,0,0,9,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,8,0,0,0,0,6,12,5,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,10,0,10,
-7,0,0,8,0,0,0,0,4,0,0,0,6,0,0,0,6,0,0,0,6,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,
-0,0,4,0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,6,0,5,0,0,0,0,8,0,0,0,10,7,0,0,0,0,10,0,0,0,
-0,0,13,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,19,7,0,4,12,0,8,0,0,0,0,6,0,0,0,0,
-0,0,0,6,0,0,0,0,0,0,0,0,0,4,0,0,0,0,18,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,
-0,14,0,0,4,0,0,0,6,0,0,0,6,0,0,0,7,0,0,0,0,0,0,10,4,0,0,9,7,0,0,11,0,0,0,0,0,0,
-7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,4,0,0,12,0,0,0,
-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,22,5,9,7,0,0,0,0,0,0,0,0,0,
-0,0,6,0,0,9,6,0,5,0,0,0,0,0,0,10,5,0,0,8,6,0,6,10,5,0,0,0,6,0,0,0,6,0,0,20,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,0,17,4,0,7,0,6,
-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
-0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,
-0,0,7,0,0,8,6,12,0,0,7,18,7,0,0,8,4,0,0,0,0,9,6,0,0,0,0,0,0,0,0,13,0,0,6,0,0,0,
-0,0,0,0,0,0,0,10,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,0,
-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,12,0,0,0,8,0,0,0,0,0,0,
-4,0,0,10,0,16,0,0,0,0,0,0,0,12,7,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,16,6,10,0,0,5,0,0,0,0,0,6,0,0,0,0,
-0,7,0,0,0,7,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,5,8,7,0,7,0,0,0,0,0,0,0,0,8,0,0,6,0,0,0,6,0,0,0,4,0,0,0,0,
-8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,7,0,0,8,0,0,0,
-9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,13,5,0,5,0,0,0,7,8,4,0,0,0,0,0,0,0,
-0,12,0,0,0,0,0,0,0,0,0,0,0,8,6,0,6,0,0,11,0,0,0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,
-0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,11,6,0,0,10,6,0,0,
-0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
-0,0,0,6,0,0,0,7,0,0,9,0,8,7,11,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,9,6,10,5,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,10,7,0,0,0,0,0,0,11,0,9,6,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,15,5,12,5,
-0,0,0,0,0,0,12,7,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,12,6,0,
-0,0,0,24,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,10,4,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,9,0,11,0,0,0,0,0,0,0,0,0,0,6,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
-0,0,8,0,0,0,0,7,0,0,0,0,0,0,10,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,0,
-0,0,0,0,0,14,7,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,0,0,6,0,0,0,6,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,7,20,7,11,4,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,7,9,6,0,0,12,7,0,0,0,0,0,0,10,0,12,0,
-0,0,0,0,0,4,9,6,13,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,5,0,0,0,0,0,0,8,0,0,0,0,0,0,
-0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,11,0,9,0,0,0,0,4,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,5,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
-0,4,0,5,0,0,0,0,0,0,0,0,0,4,0,0,0,0,9,7,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
-0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,
-0,0,0,0,8,7,0,0,0,0,0,0,12,0,0,6,0,0,0,0,0,0,0,6,8,4,0,0,10,7,0,0,10,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,5,
-0,4,0,0,0,0,0,6,0,0,0,0,0,0,8,0,0,6,0,0,0,6,0,0,0,0,0,7,0,5,8,4,0,0,9,0,0,0,0,4,
-0,0,0,0,0,0,0,0,0,5,0,0,15,6,8,6,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,9,6,0,0,0,0,0,0,0,7,0,0,0,4,0,
-6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,9,5,0,6,12,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,0,12,7,0,0,0,0,
-0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,11,4,0,0,0,0,0,0,0,0,0,0,10,
-7,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,7,8,7,9,6,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,5,12,0,
-10,5,12,6,0,0,0,7,0,0,0,0,0,0,0,5,0,0,0,5,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
-11,7,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,0,6,0,7,0,0,0,0,8,0,8,5,0,6,0,0,0,6,0,0,0,
-0,0,0,0,6,0,6,0,6,9,0,0,5,17,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,7,0,0,
-0,0,0,7,0,0,0,0,16,5,0,0,0,0,0,0,0,4,0,0,0,5,11,5,0,7,0,0,0,4,8,7,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,12,0,0,0,
-0,0,12,0,0,0,0,0,0,0,0,4,10,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,20,5,0,0,
-10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,12,0,0,0,0,0,0,6,0,0,0,0,0,0,9,4,10,7,0,4,0,0,
-0,0,0,0,10,6,0,0,0,0,8,4,0,7,8,6,0,6,8,0,10,0,0,0,0,0,13,5,0,6,0,0,0,0,0,0,22,4,
-0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,10,
-5,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,10,4,0,0,10,7,0,0,0,0,0,5,0,
-5,8,0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,4,0,0,0,0,0,6,0,0,
-0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,
-4,0,0,0,4,10,0,0,6,13,7,8,0,0,0,0,0,0,7,0,0,12,7,0,0,0,0,0,0,10,5,0,0,0,0,0,6,0,
-0,0,0,0,0,0,0,0,0,13,7,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,6,0,6,
-0,0,0,0,0,0,0,0,12,0,8,4,0,0,0,0,0,4,0,4,0,0,0,0,0,0,0,5,0,0,0,0,12,5,0,0,0,7,0,
-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,10,0,0,0,20,0,0,5,0,0,10,
-7,11,7,0,0,0,0,0,0,0,0,0,0,17,0,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,10,7,0,4,0,6,0,0,24,0,0,5,0,0,0,0,8,0,0,
-0,0,0,0,0,10,5,0,4,0,6,0,0,8,0,0,0,0,0,0,4,0,6,0,0,0,0,0,0,9,5,0,0,0,0,0,0,0,0,
-0,0,0,6,0,0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,0,7,
-0,0,13,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
-17,7,0,0,11,6,0,0,0,0,12,6,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,10,0,0,4,8,6,0,0,0,
-0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,9,5,0,7,18,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,8,0,0,0,
-0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
-0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,4,0,6,0,0,9,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,
-0,0,0,8,7,10,0,8,5,0,0,0,0,0,0,0,0,9,0,0,0,10,0,0,0,0,6,0,7,0,4,0,0,0,0,0,0,0,0,
-8,0,0,0,0,0,8,4,0,0,0,0,0,5,0,0,10,0,12,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-4,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,6,11,0,0,
-7,0,0,0,0,0,6,10,5,0,0,0,0,0,0,0,0,0,5,0,0,9,5,12,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,6,0,0,0,0,13,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,
-0,0,0,8,4,0,6,12,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,11,4,0,0,0,6,14,0,11,0,9,6,0,0,0,0,0,0,22,0,12,0,8,6,0,0,0,0,0,0,0,6,0,
-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,
-10,7,0,0,0,0,0,0,0,0,9,0,0,0,0,4,0,0,0,0,0,0,0,0,0,5,11,0,0,0,0,0,0,0,8,6,0,0,9,
-7,0,0,12,4,0,0,0,0,0,0,12,6,0,6,0,7,0,0,8,5,0,0,0,0};
-/* GENERATED CODE END */
-
-
diff --git a/src/duckdb/third_party/brotli/enc/dictionary_hash.h b/src/duckdb/third_party/brotli/enc/dictionary_hash.h
deleted file mode 100644
index 28cfdef94..000000000
--- a/src/duckdb/third_party/brotli/enc/dictionary_hash.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Hash table on the 4-byte prefixes of static dictionary words. */
-
-#ifndef BROTLI_ENC_DICTIONARY_HASH_H_
-#define BROTLI_ENC_DICTIONARY_HASH_H_
-
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-extern const uint16_t kStaticDictionaryHashWords[32768];
-extern const uint8_t kStaticDictionaryHashLengths[32768];
-
-}
-
-#endif  /* BROTLI_ENC_DICTIONARY_HASH_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/encode.cpp b/src/duckdb/third_party/brotli/enc/encode.cpp
deleted file mode 100644
index 9d1af50cb..000000000
--- a/src/duckdb/third_party/brotli/enc/encode.cpp
+++ /dev/null
@@ -1,1990 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Implementation of Brotli compressor. */
-
-#include <brotli/encode.h>
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-#include <stdlib.h>  /* free, malloc */
-#include <string.h>  /* memcpy, memset */
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/brotli_platform.h"
-#include "../common/version.h"
-#include "backward_references.h"
-#include "backward_references_hq.h"
-#include "bit_cost.h"
-#include "brotli_bit_stream.h"
-#include "compress_fragment.h"
-#include "compress_fragment_two_pass.h"
-#include "dictionary_hash.h"
-#include "encoder_dict.h"
-#include "entropy_encode.h"
-#include "fast_log.h"
-#include "brotli_hash.h"
-#include "histogram.h"
-#include "memory.h"
-#include "metablock.h"
-#include "prefix.h"
-#include "state.h"
-#include "quality.h"
-#include "ringbuffer.h"
-#include "utf8_util.h"
-#include "write_bits.h"
-
-using namespace duckdb_brotli;
-
-#define COPY_ARRAY(dst, src) memcpy(dst, src, sizeof(src));
-
-static size_t InputBlockSize(BrotliEncoderState* s) {
-  return (size_t)1 << s->params.lgblock;
-}
-
-static uint64_t UnprocessedInputSize(BrotliEncoderState* s) {
-  return s->input_pos_ - s->last_processed_pos_;
-}
-
-static size_t RemainingInputBlockSize(BrotliEncoderState* s) {
-  const uint64_t delta = UnprocessedInputSize(s);
-  size_t block_size = InputBlockSize(s);
-  if (delta >= block_size) return 0;
-  return block_size - (size_t)delta;
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliEncoderSetParameter(
-    BrotliEncoderState* state, BrotliEncoderParameter p, uint32_t value) {
-  /* Changing parameters on the fly is not implemented yet. */
-  if (state->is_initialized_) return BROTLI_FALSE;
-  /* TODO(eustas): Validate/clamp parameters here. */
-  switch (p) {
-    case BROTLI_PARAM_MODE:
-      state->params.mode = (BrotliEncoderMode)value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_QUALITY:
-      state->params.quality = (int)value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_LGWIN:
-      state->params.lgwin = (int)value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_LGBLOCK:
-      state->params.lgblock = (int)value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING:
-      if ((value != 0) && (value != 1)) return BROTLI_FALSE;
-      state->params.disable_literal_context_modeling = TO_BROTLI_BOOL(!!value);
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_SIZE_HINT:
-      state->params.size_hint = value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_LARGE_WINDOW:
-      state->params.large_window = TO_BROTLI_BOOL(!!value);
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_NPOSTFIX:
-      state->params.dist.distance_postfix_bits = value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_NDIRECT:
-      state->params.dist.num_direct_distance_codes = value;
-      return BROTLI_TRUE;
-
-    case BROTLI_PARAM_STREAM_OFFSET:
-      if (value > (1u << 30)) return BROTLI_FALSE;
-      state->params.stream_offset = value;
-      return BROTLI_TRUE;
-
-    default: return BROTLI_FALSE;
-  }
-}
-
-/* Wraps 64-bit input position to 32-bit ring-buffer position preserving
-   "not-a-first-lap" feature. */
-static uint32_t WrapPosition(uint64_t position) {
-  uint32_t result = (uint32_t)position;
-  uint64_t gb = position >> 30;
-  if (gb > 2) {
-    /* Wrap every 2GiB; The first 3GB are continuous. */
-    result = (result & ((1u << 30) - 1)) | ((uint32_t)((gb - 1) & 1) + 1) << 30;
-  }
-  return result;
-}
-
-static uint8_t* GetBrotliStorage(BrotliEncoderState* s, size_t size) {
-  MemoryManager* m = &s->memory_manager_;
-  if (s->storage_size_ < size) {
-    BROTLI_FREE(m, s->storage_);
-    s->storage_ = BROTLI_ALLOC(m, uint8_t, size);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->storage_)) return NULL;
-    s->storage_size_ = size;
-  }
-  return s->storage_;
-}
-
-static size_t HashTableSize(size_t max_table_size, size_t input_size) {
-  size_t htsize = 256;
-  while (htsize < max_table_size && htsize < input_size) {
-    htsize <<= 1;
-  }
-  return htsize;
-}
-
-static int* GetHashTable(BrotliEncoderState* s, int quality,
-                         size_t input_size, size_t* table_size) {
-  /* Use smaller hash table when input.size() is smaller, since we
-     fill the table, incurring O(hash table size) overhead for
-     compression, and if the input is short, we won't need that
-     many hash table entries anyway. */
-  MemoryManager* m = &s->memory_manager_;
-  const size_t max_table_size = MaxHashTableSize(quality);
-  size_t htsize = HashTableSize(max_table_size, input_size);
-  int* table;
-  BROTLI_DCHECK(max_table_size >= 256);
-  if (quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
-    /* Only odd shifts are supported by fast-one-pass. */
-    if ((htsize & 0xAAAAA) == 0) {
-      htsize <<= 1;
-    }
-  }
-
-  if (htsize <= sizeof(s->small_table_) / sizeof(s->small_table_[0])) {
-    table = s->small_table_;
-  } else {
-    if (htsize > s->large_table_size_) {
-      s->large_table_size_ = htsize;
-      BROTLI_FREE(m, s->large_table_);
-      s->large_table_ = BROTLI_ALLOC(m, int, htsize);
-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->large_table_)) return 0;
-    }
-    table = s->large_table_;
-  }
-
-  *table_size = htsize;
-  memset(table, 0, htsize * sizeof(*table));
-  return table;
-}
-
-static void EncodeWindowBits(int lgwin, BROTLI_BOOL large_window,
-    uint16_t* last_bytes, uint8_t* last_bytes_bits) {
-  if (large_window) {
-    *last_bytes = (uint16_t)(((lgwin & 0x3F) << 8) | 0x11);
-    *last_bytes_bits = 14;
-  } else {
-    if (lgwin == 16) {
-      *last_bytes = 0;
-      *last_bytes_bits = 1;
-    } else if (lgwin == 17) {
-      *last_bytes = 1;
-      *last_bytes_bits = 7;
-    } else if (lgwin > 17) {
-      *last_bytes = (uint16_t)(((lgwin - 17) << 1) | 0x01);
-      *last_bytes_bits = 4;
-    } else {
-      *last_bytes = (uint16_t)(((lgwin - 8) << 4) | 0x01);
-      *last_bytes_bits = 7;
-    }
-  }
-}
-
-/* TODO(eustas): move to compress_fragment.c? */
-/* Initializes the command and distance prefix codes for the first block. */
-static void InitCommandPrefixCodes(BrotliOnePassArena* s) {
-  static const uint8_t kDefaultCommandDepths[128] = {
-    0, 4, 4, 5, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8,
-    0, 0, 0, 4, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7,
-    7, 7, 10, 10, 10, 10, 10, 10, 0, 4, 4, 5, 5, 5, 6, 6,
-    7, 8, 8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-    5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4,
-    4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 8, 10,
-    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-  };
-  static const uint16_t kDefaultCommandBits[128] = {
-    0,   0,   8,   9,   3,  35,   7,   71,
-    39, 103,  23,  47, 175, 111, 239,   31,
-    0,   0,   0,   4,  12,   2,  10,    6,
-    13,  29,  11,  43,  27,  59,  87,   55,
-    15,  79, 319, 831, 191, 703, 447,  959,
-    0,  14,   1,  25,   5,  21,  19,   51,
-    119, 159,  95, 223, 479, 991,  63,  575,
-    127, 639, 383, 895, 255, 767, 511, 1023,
-    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    27, 59, 7, 39, 23, 55, 30, 1, 17, 9, 25, 5, 0, 8, 4, 12,
-    2, 10, 6, 21, 13, 29, 3, 19, 11, 15, 47, 31, 95, 63, 127, 255,
-    767, 2815, 1791, 3839, 511, 2559, 1535, 3583, 1023, 3071, 2047, 4095,
-  };
-  static const uint8_t kDefaultCommandCode[] = {
-    0xff, 0x77, 0xd5, 0xbf, 0xe7, 0xde, 0xea, 0x9e, 0x51, 0x5d, 0xde, 0xc6,
-    0x70, 0x57, 0xbc, 0x58, 0x58, 0x58, 0xd8, 0xd8, 0x58, 0xd5, 0xcb, 0x8c,
-    0xea, 0xe0, 0xc3, 0x87, 0x1f, 0x83, 0xc1, 0x60, 0x1c, 0x67, 0xb2, 0xaa,
-    0x06, 0x83, 0xc1, 0x60, 0x30, 0x18, 0xcc, 0xa1, 0xce, 0x88, 0x54, 0x94,
-    0x46, 0xe1, 0xb0, 0xd0, 0x4e, 0xb2, 0xf7, 0x04, 0x00,
-  };
-  static const size_t kDefaultCommandCodeNumBits = 448;
-  COPY_ARRAY(s->cmd_depth, kDefaultCommandDepths);
-  COPY_ARRAY(s->cmd_bits, kDefaultCommandBits);
-
-  /* Initialize the pre-compressed form of the command and distance prefix
-     codes. */
-  COPY_ARRAY(s->cmd_code, kDefaultCommandCode);
-  s->cmd_code_numbits = kDefaultCommandCodeNumBits;
-}
-
-/* Decide about the context map based on the ability of the prediction
-   ability of the previous byte UTF8-prefix on the next byte. The
-   prediction ability is calculated as Shannon entropy. Here we need
-   Shannon entropy instead of 'BitsEntropy' since the prefix will be
-   encoded with the remaining 6 bits of the following byte, and
-   BitsEntropy will assume that symbol to be stored alone using Huffman
-   coding. */
-static void ChooseContextMap(int quality,
-                             uint32_t* bigram_histo,
-                             size_t* num_literal_contexts,
-                             const uint32_t** literal_context_map) {
-  static const uint32_t kStaticContextMapContinuation[64] = {
-    1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  };
-  static const uint32_t kStaticContextMapSimpleUTF8[64] = {
-    0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  };
-
-  uint32_t monogram_histo[3] = { 0 };
-  uint32_t two_prefix_histo[6] = { 0 };
-  size_t total;
-  size_t i;
-  size_t dummy;
-  double entropy[4];
-  for (i = 0; i < 9; ++i) {
-    monogram_histo[i % 3] += bigram_histo[i];
-    two_prefix_histo[i % 6] += bigram_histo[i];
-  }
-  entropy[1] = ShannonEntropy(monogram_histo, 3, &dummy);
-  entropy[2] = (ShannonEntropy(two_prefix_histo, 3, &dummy) +
-                ShannonEntropy(two_prefix_histo + 3, 3, &dummy));
-  entropy[3] = 0;
-  for (i = 0; i < 3; ++i) {
-    entropy[3] += ShannonEntropy(bigram_histo + 3 * i, 3, &dummy);
-  }
-
-  total = monogram_histo[0] + monogram_histo[1] + monogram_histo[2];
-  BROTLI_DCHECK(total != 0);
-  entropy[0] = 1.0 / (double)total;
-  entropy[1] *= entropy[0];
-  entropy[2] *= entropy[0];
-  entropy[3] *= entropy[0];
-
-  if (quality < MIN_QUALITY_FOR_HQ_CONTEXT_MODELING) {
-    /* 3 context models is a bit slower, don't use it at lower qualities. */
-    entropy[3] = entropy[1] * 10;
-  }
-  /* If expected savings by symbol are less than 0.2 bits, skip the
-     context modeling -- in exchange for faster decoding speed. */
-  if (entropy[1] - entropy[2] < 0.2 &&
-      entropy[1] - entropy[3] < 0.2) {
-    *num_literal_contexts = 1;
-  } else if (entropy[2] - entropy[3] < 0.02) {
-    *num_literal_contexts = 2;
-    *literal_context_map = kStaticContextMapSimpleUTF8;
-  } else {
-    *num_literal_contexts = 3;
-    *literal_context_map = kStaticContextMapContinuation;
-  }
-}
-
-/* Decide if we want to use a more complex static context map containing 13
-   context values, based on the entropy reduction of histograms over the
-   first 5 bits of literals. */
-static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
-    size_t start_pos, size_t length, size_t mask, int quality, size_t size_hint,
-    size_t* num_literal_contexts, const uint32_t** literal_context_map,
-    uint32_t* arena) {
-  static const uint32_t kStaticContextMapComplexUTF8[64] = {
-    11, 11, 12, 12, /* 0 special */
-    0, 0, 0, 0, /* 4 lf */
-    1, 1, 9, 9, /* 8 space */
-    2, 2, 2, 2, /* !, first after space/lf and after something else. */
-    1, 1, 1, 1, /* " */
-    8, 3, 3, 3, /* % */
-    1, 1, 1, 1, /* ({[ */
-    2, 2, 2, 2, /* }]) */
-    8, 4, 4, 4, /* :; */
-    8, 7, 4, 4, /* . */
-    8, 0, 0, 0, /* > */
-    3, 3, 3, 3, /* [0..9] */
-    5, 5, 10, 5, /* [A-Z] */
-    5, 5, 10, 5,
-    6, 6, 6, 6, /* [a-z] */
-    6, 6, 6, 6,
-  };
-  BROTLI_UNUSED(quality);
-  /* Try the more complex static context map only for long data. */
-  if (size_hint < (1 << 20)) {
-    return BROTLI_FALSE;
-  } else {
-    const size_t end_pos = start_pos + length;
-    /* To make entropy calculations faster, we collect histograms
-       over the 5 most significant bits of literals. One histogram
-       without context and 13 additional histograms for each context value. */
-    uint32_t* BROTLI_RESTRICT const combined_histo = arena;
-    uint32_t* BROTLI_RESTRICT const context_histo = arena + 32;
-    uint32_t total = 0;
-    double entropy[3];
-    size_t dummy;
-    size_t i;
-    ContextLut utf8_lut = BROTLI_CONTEXT_LUT(CONTEXT_UTF8);
-    memset(arena, 0, sizeof(arena[0]) * 32 * 14);
-    for (; start_pos + 64 <= end_pos; start_pos += 4096) {
-      const size_t stride_end_pos = start_pos + 64;
-      uint8_t prev2 = input[start_pos & mask];
-      uint8_t prev1 = input[(start_pos + 1) & mask];
-      size_t pos;
-      /* To make the analysis of the data faster we only examine 64 byte long
-         strides at every 4kB intervals. */
-      for (pos = start_pos + 2; pos < stride_end_pos; ++pos) {
-        const uint8_t literal = input[pos & mask];
-        const uint8_t context = (uint8_t)kStaticContextMapComplexUTF8[
-            BROTLI_CONTEXT(prev1, prev2, utf8_lut)];
-        ++total;
-        ++combined_histo[literal >> 3];
-        ++context_histo[(context << 5) + (literal >> 3)];
-        prev2 = prev1;
-        prev1 = literal;
-      }
-    }
-    entropy[1] = ShannonEntropy(combined_histo, 32, &dummy);
-    entropy[2] = 0;
-    for (i = 0; i < 13; ++i) {
-      entropy[2] += ShannonEntropy(context_histo + (i << 5), 32, &dummy);
-    }
-    entropy[0] = 1.0 / (double)total;
-    entropy[1] *= entropy[0];
-    entropy[2] *= entropy[0];
-    /* The triggering heuristics below were tuned by compressing the individual
-       files of the silesia corpus. If we skip this kind of context modeling
-       for not very well compressible input (i.e. entropy using context modeling
-       is 60% of maximal entropy) or if expected savings by symbol are less
-       than 0.2 bits, then in every case when it triggers, the final compression
-       ratio is improved. Note however that this heuristics might be too strict
-       for some cases and could be tuned further. */
-    if (entropy[2] > 3.0 || entropy[1] - entropy[2] < 0.2) {
-      return BROTLI_FALSE;
-    } else {
-      *num_literal_contexts = 13;
-      *literal_context_map = kStaticContextMapComplexUTF8;
-      return BROTLI_TRUE;
-    }
-  }
-}
-
-static void DecideOverLiteralContextModeling(const uint8_t* input,
-    size_t start_pos, size_t length, size_t mask, int quality, size_t size_hint,
-    size_t* num_literal_contexts, const uint32_t** literal_context_map,
-    uint32_t* arena) {
-  if (quality < MIN_QUALITY_FOR_CONTEXT_MODELING || length < 64) {
-    return;
-  } else if (ShouldUseComplexStaticContextMap(
-      input, start_pos, length, mask, quality, size_hint,
-      num_literal_contexts, literal_context_map, arena)) {
-    /* Context map was already set, nothing else to do. */
-  } else {
-    /* Gather bi-gram data of the UTF8 byte prefixes. To make the analysis of
-       UTF8 data faster we only examine 64 byte long strides at every 4kB
-       intervals. */
-    const size_t end_pos = start_pos + length;
-    uint32_t* BROTLI_RESTRICT const bigram_prefix_histo = arena;
-    memset(bigram_prefix_histo, 0, sizeof(arena[0]) * 9);
-    for (; start_pos + 64 <= end_pos; start_pos += 4096) {
-      static const int lut[4] = { 0, 0, 1, 2 };
-      const size_t stride_end_pos = start_pos + 64;
-      int prev = lut[input[start_pos & mask] >> 6] * 3;
-      size_t pos;
-      for (pos = start_pos + 1; pos < stride_end_pos; ++pos) {
-        const uint8_t literal = input[pos & mask];
-        ++bigram_prefix_histo[prev + lut[literal >> 6]];
-        prev = lut[literal >> 6] * 3;
-      }
-    }
-    ChooseContextMap(quality, &bigram_prefix_histo[0], num_literal_contexts,
-                     literal_context_map);
-  }
-}
-
-static BROTLI_BOOL ShouldCompress(
-    const uint8_t* data, const size_t mask, const uint64_t last_flush_pos,
-    const size_t bytes, const size_t num_literals, const size_t num_commands) {
-  /* TODO(eustas): find more precise minimal block overhead. */
-  if (bytes <= 2) return BROTLI_FALSE;
-  if (num_commands < (bytes >> 8) + 2) {
-    if ((double)num_literals > 0.99 * (double)bytes) {
-      uint32_t literal_histo[256] = { 0 };
-      static const uint32_t kSampleRate = 13;
-      static const double kMinEntropy = 7.92;
-      const double bit_cost_threshold =
-          (double)bytes * kMinEntropy / kSampleRate;
-      size_t t = (bytes + kSampleRate - 1) / kSampleRate;
-      uint32_t pos = (uint32_t)last_flush_pos;
-      size_t i;
-      for (i = 0; i < t; i++) {
-        ++literal_histo[data[pos & mask]];
-        pos += kSampleRate;
-      }
-      if (BitsEntropy(literal_histo, 256) > bit_cost_threshold) {
-        return BROTLI_FALSE;
-      }
-    }
-  }
-  return BROTLI_TRUE;
-}
-
-/* Chooses the literal context mode for a metablock */
-static ContextType ChooseContextMode(const BrotliEncoderParams* params,
-    const uint8_t* data, const size_t pos, const size_t mask,
-    const size_t length) {
-  /* We only do the computation for the option of something else than
-     CONTEXT_UTF8 for the highest qualities */
-  if (params->quality >= MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING &&
-      !BrotliIsMostlyUTF8(data, pos, mask, length, kMinUTF8Ratio)) {
-    return CONTEXT_SIGNED;
-  }
-  return CONTEXT_UTF8;
-}
-
-static void WriteMetaBlockInternal(MemoryManager* m,
-                                   const uint8_t* data,
-                                   const size_t mask,
-                                   const uint64_t last_flush_pos,
-                                   const size_t bytes,
-                                   const BROTLI_BOOL is_last,
-                                   ContextType literal_context_mode,
-                                   const BrotliEncoderParams* params,
-                                   const uint8_t prev_byte,
-                                   const uint8_t prev_byte2,
-                                   const size_t num_literals,
-                                   const size_t num_commands,
-                                   Command* commands,
-                                   const int* saved_dist_cache,
-                                   int* dist_cache,
-                                   size_t* storage_ix,
-                                   uint8_t* storage) {
-  const uint32_t wrapped_last_flush_pos = WrapPosition(last_flush_pos);
-  uint16_t last_bytes;
-  uint8_t last_bytes_bits;
-  ContextLut literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
-  BrotliEncoderParams block_params = *params;
-
-  if (bytes == 0) {
-    /* Write the ISLAST and ISEMPTY bits. */
-    BrotliWriteBits(2, 3, storage_ix, storage);
-    *storage_ix = (*storage_ix + 7u) & ~7u;
-    return;
-  }
-
-  if (!ShouldCompress(data, mask, last_flush_pos, bytes,
-                      num_literals, num_commands)) {
-    /* Restore the distance cache, as its last update by
-       CreateBackwardReferences is now unused. */
-    memcpy(dist_cache, saved_dist_cache, 4 * sizeof(dist_cache[0]));
-    BrotliStoreUncompressedMetaBlock(is_last, data,
-                                     wrapped_last_flush_pos, mask, bytes,
-                                     storage_ix, storage);
-    return;
-  }
-
-  BROTLI_DCHECK(*storage_ix <= 14);
-  last_bytes = (uint16_t)((storage[1] << 8) | storage[0]);
-  last_bytes_bits = (uint8_t)(*storage_ix);
-  if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
-    BrotliStoreMetaBlockFast(m, data, wrapped_last_flush_pos,
-                             bytes, mask, is_last, params,
-                             commands, num_commands,
-                             storage_ix, storage);
-    if (BROTLI_IS_OOM(m)) return;
-  } else if (params->quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
-    BrotliStoreMetaBlockTrivial(m, data, wrapped_last_flush_pos,
-                                bytes, mask, is_last, params,
-                                commands, num_commands,
-                                storage_ix, storage);
-    if (BROTLI_IS_OOM(m)) return;
-  } else {
-    MetaBlockSplit mb;
-    InitMetaBlockSplit(&mb);
-    if (params->quality < MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING) {
-      size_t num_literal_contexts = 1;
-      const uint32_t* literal_context_map = NULL;
-      if (!params->disable_literal_context_modeling) {
-        /* TODO(eustas): pull to higher level and reuse. */
-        uint32_t* arena = BROTLI_ALLOC(m, uint32_t, 14 * 32);
-        if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(arena)) return;
-        DecideOverLiteralContextModeling(
-            data, wrapped_last_flush_pos, bytes, mask, params->quality,
-            params->size_hint, &num_literal_contexts,
-            &literal_context_map, arena);
-        BROTLI_FREE(m, arena);
-      }
-      BrotliBuildMetaBlockGreedy(m, data, wrapped_last_flush_pos, mask,
-          prev_byte, prev_byte2, literal_context_lut, num_literal_contexts,
-          literal_context_map, commands, num_commands, &mb);
-      if (BROTLI_IS_OOM(m)) return;
-    } else {
-      BrotliBuildMetaBlock(m, data, wrapped_last_flush_pos, mask, &block_params,
-                           prev_byte, prev_byte2,
-                           commands, num_commands,
-                           literal_context_mode,
-                           &mb);
-      if (BROTLI_IS_OOM(m)) return;
-    }
-    if (params->quality >= MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS) {
-      /* The number of distance symbols effectively used for distance
-         histograms. It might be less than distance alphabet size
-         for "Large Window Brotli" (32-bit). */
-      BrotliOptimizeHistograms(block_params.dist.alphabet_size_limit, &mb);
-    }
-    BrotliStoreMetaBlock(m, data, wrapped_last_flush_pos, bytes, mask,
-                         prev_byte, prev_byte2,
-                         is_last,
-                         &block_params,
-                         literal_context_mode,
-                         commands, num_commands,
-                         &mb,
-                         storage_ix, storage);
-    if (BROTLI_IS_OOM(m)) return;
-    DestroyMetaBlockSplit(m, &mb);
-  }
-  if (bytes + 4 < (*storage_ix >> 3)) {
-    /* Restore the distance cache and last byte. */
-    memcpy(dist_cache, saved_dist_cache, 4 * sizeof(dist_cache[0]));
-    storage[0] = (uint8_t)last_bytes;
-    storage[1] = (uint8_t)(last_bytes >> 8);
-    *storage_ix = last_bytes_bits;
-    BrotliStoreUncompressedMetaBlock(is_last, data,
-                                     wrapped_last_flush_pos, mask,
-                                     bytes, storage_ix, storage);
-  }
-}
-
-static void ChooseDistanceParams(BrotliEncoderParams* params) {
-  uint32_t distance_postfix_bits = 0;
-  uint32_t num_direct_distance_codes = 0;
-
-  if (params->quality >= MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS) {
-    uint32_t ndirect_msb;
-    if (params->mode == BROTLI_MODE_FONT) {
-      distance_postfix_bits = 1;
-      num_direct_distance_codes = 12;
-    } else {
-      distance_postfix_bits = params->dist.distance_postfix_bits;
-      num_direct_distance_codes = params->dist.num_direct_distance_codes;
-    }
-    ndirect_msb = (num_direct_distance_codes >> distance_postfix_bits) & 0x0F;
-    if (distance_postfix_bits > BROTLI_MAX_NPOSTFIX ||
-        num_direct_distance_codes > BROTLI_MAX_NDIRECT ||
-        (ndirect_msb << distance_postfix_bits) != num_direct_distance_codes) {
-      distance_postfix_bits = 0;
-      num_direct_distance_codes = 0;
-    }
-  }
-
-  BrotliInitDistanceParams(&params->dist, distance_postfix_bits,
-                           num_direct_distance_codes, params->large_window);
-}
-
-static BROTLI_BOOL EnsureInitialized(BrotliEncoderState* s) {
-  MemoryManager* m = &s->memory_manager_;
-  if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  if (s->is_initialized_) return BROTLI_TRUE;
-
-  s->last_bytes_bits_ = 0;
-  s->last_bytes_ = 0;
-  s->flint_ = BROTLI_FLINT_DONE;
-  s->remaining_metadata_bytes_ = BROTLI_UINT32_MAX;
-
-  SanitizeParams(&s->params);
-  s->params.lgblock = ComputeLgBlock(&s->params);
-  ChooseDistanceParams(&s->params);
-
-  if (s->params.stream_offset != 0) {
-    s->flint_ = BROTLI_FLINT_NEEDS_2_BYTES;
-    /* Poison the distance cache. -16 +- 3 is still less than zero (invalid). */
-    s->dist_cache_[0] = -16;
-    s->dist_cache_[1] = -16;
-    s->dist_cache_[2] = -16;
-    s->dist_cache_[3] = -16;
-    memcpy(s->saved_dist_cache_, s->dist_cache_, sizeof(s->saved_dist_cache_));
-  }
-
-  RingBufferSetup(&s->params, &s->ringbuffer_);
-
-  /* Initialize last byte with stream header. */
-  {
-    int lgwin = s->params.lgwin;
-    if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
-        s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-      lgwin = BROTLI_MAX(int, lgwin, 18);
-    }
-    if (s->params.stream_offset == 0) {
-      EncodeWindowBits(lgwin, s->params.large_window,
-                       &s->last_bytes_, &s->last_bytes_bits_);
-    } else {
-      /* Bigger values have the same effect, but could cause overflows. */
-      s->params.stream_offset = BROTLI_MIN(size_t,
-          s->params.stream_offset, BROTLI_MAX_BACKWARD_LIMIT(lgwin));
-    }
-  }
-
-  if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
-    s->one_pass_arena_ = BROTLI_ALLOC(m, BrotliOnePassArena, 1);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    InitCommandPrefixCodes(s->one_pass_arena_);
-  } else if (s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    s->two_pass_arena_ = BROTLI_ALLOC(m, BrotliTwoPassArena, 1);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  }
-
-  s->is_initialized_ = BROTLI_TRUE;
-  return BROTLI_TRUE;
-}
-
-static void BrotliEncoderInitParams(BrotliEncoderParams* params) {
-  params->mode = BROTLI_DEFAULT_MODE;
-  params->large_window = BROTLI_FALSE;
-  params->quality = BROTLI_DEFAULT_QUALITY;
-  params->lgwin = BROTLI_DEFAULT_WINDOW;
-  params->lgblock = 0;
-  params->stream_offset = 0;
-  params->size_hint = 0;
-  params->disable_literal_context_modeling = BROTLI_FALSE;
-  BrotliInitSharedEncoderDictionary(&params->dictionary);
-  params->dist.distance_postfix_bits = 0;
-  params->dist.num_direct_distance_codes = 0;
-  params->dist.alphabet_size_max =
-      BROTLI_DISTANCE_ALPHABET_SIZE(0, 0, BROTLI_MAX_DISTANCE_BITS);
-  params->dist.alphabet_size_limit = params->dist.alphabet_size_max;
-  params->dist.max_distance = BROTLI_MAX_DISTANCE;
-}
-
-static void BrotliEncoderCleanupParams(MemoryManager* m,
-    BrotliEncoderParams* params) {
-  BrotliCleanupSharedEncoderDictionary(m, &params->dictionary);
-}
-
-static void BrotliEncoderInitState(BrotliEncoderState* s) {
-  BrotliEncoderInitParams(&s->params);
-  s->input_pos_ = 0;
-  s->num_commands_ = 0;
-  s->num_literals_ = 0;
-  s->last_insert_len_ = 0;
-  s->last_flush_pos_ = 0;
-  s->last_processed_pos_ = 0;
-  s->prev_byte_ = 0;
-  s->prev_byte2_ = 0;
-  s->storage_size_ = 0;
-  s->storage_ = 0;
-  HasherInit(&s->hasher_);
-  s->large_table_ = NULL;
-  s->large_table_size_ = 0;
-  s->one_pass_arena_ = NULL;
-  s->two_pass_arena_ = NULL;
-  s->command_buf_ = NULL;
-  s->literal_buf_ = NULL;
-  s->total_in_ = 0;
-  s->next_out_ = NULL;
-  s->available_out_ = 0;
-  s->total_out_ = 0;
-  s->stream_state_ = BROTLI_STREAM_PROCESSING;
-  s->is_last_block_emitted_ = BROTLI_FALSE;
-  s->is_initialized_ = BROTLI_FALSE;
-
-  RingBufferInit(&s->ringbuffer_);
-
-  s->commands_ = 0;
-  s->cmd_alloc_size_ = 0;
-
-  /* Initialize distance cache. */
-  s->dist_cache_[0] = 4;
-  s->dist_cache_[1] = 11;
-  s->dist_cache_[2] = 15;
-  s->dist_cache_[3] = 16;
-  /* Save the state of the distance cache in case we need to restore it for
-     emitting an uncompressed block. */
-  memcpy(s->saved_dist_cache_, s->dist_cache_, sizeof(s->saved_dist_cache_));
-}
-
-BrotliEncoderState* duckdb_brotli::BrotliEncoderCreateInstance(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
-  BrotliEncoderState* state = (BrotliEncoderState*)BrotliBootstrapAlloc(
-      sizeof(BrotliEncoderState), alloc_func, free_func, opaque);
-  if (state == NULL) {
-    /* BROTLI_DUMP(); */
-    return 0;
-  }
-  BrotliInitMemoryManager(
-      &state->memory_manager_, alloc_func, free_func, opaque);
-  BrotliEncoderInitState(state);
-  return state;
-}
-
-#ifdef BROTLI_REPORTING
-/* When BROTLI_REPORTING is defined extra reporting module have to be linked. */
-void BrotliEncoderOnFinish(const BrotliEncoderState* s);
-#define BROTLI_ENCODER_ON_FINISH(s) BrotliEncoderOnFinish(s);
-#else
-#if !defined(BROTLI_ENCODER_ON_FINISH)
-#define BROTLI_ENCODER_ON_FINISH(s) (void)(s);
-#endif
-#endif
-
-static void BrotliEncoderCleanupState(BrotliEncoderState* s) {
-  MemoryManager* m = &s->memory_manager_;
-
-  BROTLI_ENCODER_ON_FINISH(s);
-
-  if (BROTLI_IS_OOM(m)) {
-    BrotliWipeOutMemoryManager(m);
-    return;
-  }
-
-  BROTLI_FREE(m, s->storage_);
-  BROTLI_FREE(m, s->commands_);
-  RingBufferFree(m, &s->ringbuffer_);
-  DestroyHasher(m, &s->hasher_);
-  BROTLI_FREE(m, s->large_table_);
-  BROTLI_FREE(m, s->one_pass_arena_);
-  BROTLI_FREE(m, s->two_pass_arena_);
-  BROTLI_FREE(m, s->command_buf_);
-  BROTLI_FREE(m, s->literal_buf_);
-  BrotliEncoderCleanupParams(m, &s->params);
-}
-
-/* Deinitializes and frees BrotliEncoderState instance. */
-void duckdb_brotli::BrotliEncoderDestroyInstance(BrotliEncoderState* state) {
-  if (!state) {
-    return;
-  } else {
-    BrotliEncoderCleanupState(state);
-    BrotliBootstrapFree(state, &state->memory_manager_);
-  }
-}
-
-/*
-   Copies the given input data to the internal ring buffer of the compressor.
-   No processing of the data occurs at this time and this function can be
-   called multiple times before calling WriteBrotliData() to process the
-   accumulated input. At most input_block_size() bytes of input data can be
-   copied to the ring buffer, otherwise the next WriteBrotliData() will fail.
- */
-static void CopyInputToRingBuffer(BrotliEncoderState* s,
-                                  const size_t input_size,
-                                  const uint8_t* input_buffer) {
-  RingBuffer* ringbuffer_ = &s->ringbuffer_;
-  MemoryManager* m = &s->memory_manager_;
-  RingBufferWrite(m, input_buffer, input_size, ringbuffer_);
-  if (BROTLI_IS_OOM(m)) return;
-  s->input_pos_ += input_size;
-
-  /* TL;DR: If needed, initialize 7 more bytes in the ring buffer to make the
-     hashing not depend on uninitialized data. This makes compression
-     deterministic and it prevents uninitialized memory warnings in Valgrind.
-     Even without erasing, the output would be valid (but nondeterministic).
-
-     Background information: The compressor stores short (at most 8 bytes)
-     substrings of the input already read in a hash table, and detects
-     repetitions by looking up such substrings in the hash table. If it
-     can find a substring, it checks whether the substring is really there
-     in the ring buffer (or it's just a hash collision). Should the hash
-     table become corrupt, this check makes sure that the output is
-     still valid, albeit the compression ratio would be bad.
-
-     The compressor populates the hash table from the ring buffer as it's
-     reading new bytes from the input. However, at the last few indexes of
-     the ring buffer, there are not enough bytes to build full-length
-     substrings from. Since the hash table always contains full-length
-     substrings, we erase with dummy zeros here to make sure that those
-     substrings will contain zeros at the end instead of uninitialized
-     data.
-
-     Please note that erasing is not necessary (because the
-     memory region is already initialized since he ring buffer
-     has a `tail' that holds a copy of the beginning,) so we
-     skip erasing if we have already gone around at least once in
-     the ring buffer.
-
-     Only clear during the first round of ring-buffer writes. On
-     subsequent rounds data in the ring-buffer would be affected. */
-  if (ringbuffer_->pos_ <= ringbuffer_->mask_) {
-    /* This is the first time when the ring buffer is being written.
-       We clear 7 bytes just after the bytes that have been copied from
-       the input buffer.
-
-       The ring-buffer has a "tail" that holds a copy of the beginning,
-       but only once the ring buffer has been fully written once, i.e.,
-       pos <= mask. For the first time, we need to write values
-       in this tail (where index may be larger than mask), so that
-       we have exactly defined behavior and don't read uninitialized
-       memory. Due to performance reasons, hashing reads data using a
-       LOAD64, which can go 7 bytes beyond the bytes written in the
-       ring-buffer. */
-    memset(ringbuffer_->buffer_ + ringbuffer_->pos_, 0, 7);
-  }
-}
-
-/* Marks all input as processed.
-   Returns true if position wrapping occurs. */
-static BROTLI_BOOL UpdateLastProcessedPos(BrotliEncoderState* s) {
-  uint32_t wrapped_last_processed_pos = WrapPosition(s->last_processed_pos_);
-  uint32_t wrapped_input_pos = WrapPosition(s->input_pos_);
-  s->last_processed_pos_ = s->input_pos_;
-  return TO_BROTLI_BOOL(wrapped_input_pos < wrapped_last_processed_pos);
-}
-
-static void ExtendLastCommand(BrotliEncoderState* s, uint32_t* bytes,
-                              uint32_t* wrapped_last_processed_pos) {
-  Command* last_command = &s->commands_[s->num_commands_ - 1];
-  const uint8_t* data = s->ringbuffer_.buffer_;
-  const uint32_t mask = s->ringbuffer_.mask_;
-  uint64_t max_backward_distance =
-      (((uint64_t)1) << s->params.lgwin) - BROTLI_WINDOW_GAP;
-  uint64_t last_copy_len = last_command->copy_len_ & 0x1FFFFFF;
-  uint64_t last_processed_pos = s->last_processed_pos_ - last_copy_len;
-  uint64_t max_distance = last_processed_pos < max_backward_distance ?
-      last_processed_pos : max_backward_distance;
-  uint64_t cmd_dist = (uint64_t)s->dist_cache_[0];
-  uint32_t distance_code = CommandRestoreDistanceCode(last_command,
-                                                      &s->params.dist);
-  const CompoundDictionary* dict = &s->params.dictionary.compound;
-  size_t compound_dictionary_size = dict->total_size;
-  if (distance_code < BROTLI_NUM_DISTANCE_SHORT_CODES ||
-      distance_code - (BROTLI_NUM_DISTANCE_SHORT_CODES - 1) == cmd_dist) {
-    if (cmd_dist <= max_distance) {
-      while (*bytes != 0 && data[*wrapped_last_processed_pos & mask] ==
-             data[(*wrapped_last_processed_pos - cmd_dist) & mask]) {
-        last_command->copy_len_++;
-        (*bytes)--;
-        (*wrapped_last_processed_pos)++;
-      }
-    } else {
-      if ((cmd_dist - max_distance - 1) < compound_dictionary_size &&
-          last_copy_len < cmd_dist - max_distance) {
-        size_t address =
-            compound_dictionary_size - (size_t)(cmd_dist - max_distance) +
-            (size_t)last_copy_len;
-        size_t br_index = 0;
-        size_t br_offset;
-        const uint8_t* chunk;
-        size_t chunk_length;
-        while (address >= dict->chunk_offsets[br_index + 1]) br_index++;
-        br_offset = address - dict->chunk_offsets[br_index];
-        chunk = dict->chunk_source[br_index];
-        chunk_length =
-            dict->chunk_offsets[br_index + 1] - dict->chunk_offsets[br_index];
-        while (*bytes != 0 && data[*wrapped_last_processed_pos & mask] ==
-               chunk[br_offset]) {
-          last_command->copy_len_++;
-          (*bytes)--;
-          (*wrapped_last_processed_pos)++;
-          if (++br_offset == chunk_length) {
-            br_index++;
-            br_offset = 0;
-            if (br_index != dict->num_chunks) {
-              chunk = dict->chunk_source[br_index];
-              chunk_length = dict->chunk_offsets[br_index + 1] -
-                  dict->chunk_offsets[br_index];
-            } else {
-              break;
-            }
-          }
-        }
-      }
-    }
-    /* The copy length is at most the metablock size, and thus expressible. */
-    GetLengthCode(last_command->insert_len_,
-                  (size_t)((int)(last_command->copy_len_ & 0x1FFFFFF) +
-                           (int)(last_command->copy_len_ >> 25)),
-                  TO_BROTLI_BOOL((last_command->dist_prefix_ & 0x3FF) == 0),
-                  &last_command->cmd_prefix_);
-  }
-}
-
-/*
-   Processes the accumulated input data and sets |*out_size| to the length of
-   the new output meta-block, or to zero if no new output meta-block has been
-   created (in this case the processed input data is buffered internally).
-   If |*out_size| is positive, |*output| points to the start of the output
-   data. If |is_last| or |force_flush| is BROTLI_TRUE, an output meta-block is
-   always created. However, until |is_last| is BROTLI_TRUE encoder may retain up
-   to 7 bits of the last byte of output. Byte-alignment could be enforced by
-   emitting an empty meta-data block.
-   Returns BROTLI_FALSE if the size of the input data is larger than
-   input_block_size().
- */
-static BROTLI_BOOL EncodeData(
-    BrotliEncoderState* s, const BROTLI_BOOL is_last,
-    const BROTLI_BOOL force_flush, size_t* out_size, uint8_t** output) {
-  const uint64_t delta = UnprocessedInputSize(s);
-  uint32_t bytes = (uint32_t)delta;
-  uint32_t wrapped_last_processed_pos = WrapPosition(s->last_processed_pos_);
-  uint8_t* data;
-  uint32_t mask;
-  MemoryManager* m = &s->memory_manager_;
-  ContextType literal_context_mode;
-  ContextLut literal_context_lut;
-  BROTLI_BOOL fast_compress =
-      s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
-      s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY;
-
-  data = s->ringbuffer_.buffer_;
-  mask = s->ringbuffer_.mask_;
-
-  if (delta == 0) {  /* No new input; still might want to flush or finish. */
-    if (!data) {  /* No input has been processed so far. */
-      if (is_last) {  /* Emit complete finalized stream. */
-        BROTLI_DCHECK(s->last_bytes_bits_ <= 14);
-        s->last_bytes_ |= (uint16_t)(3u << s->last_bytes_bits_);
-        s->last_bytes_bits_ = (uint8_t)(s->last_bytes_bits_ + 2u);
-        s->tiny_buf_.u8[0] = (uint8_t)s->last_bytes_;
-        s->tiny_buf_.u8[1] = (uint8_t)(s->last_bytes_ >> 8);
-        *output = s->tiny_buf_.u8;
-        *out_size = (s->last_bytes_bits_ + 7u) >> 3u;
-        return BROTLI_TRUE;
-      } else {  /* No data, not last -> no-op. */
-        *out_size = 0;
-        return BROTLI_TRUE;
-      }
-    } else {
-      /* Fast compress performs flush every block -> flush is no-op. */
-      if (!is_last && (!force_flush || fast_compress)) {  /* Another no-op. */
-        *out_size = 0;
-        return BROTLI_TRUE;
-      }
-    }
-  }
-  BROTLI_DCHECK(data);
-
-  if (s->params.quality > s->params.dictionary.max_quality) return BROTLI_FALSE;
-  /* Adding more blocks after "last" block is forbidden. */
-  if (s->is_last_block_emitted_) return BROTLI_FALSE;
-  if (is_last) s->is_last_block_emitted_ = BROTLI_TRUE;
-
-  if (delta > InputBlockSize(s)) {
-    return BROTLI_FALSE;
-  }
-  if (s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY &&
-      !s->command_buf_) {
-    s->command_buf_ =
-        BROTLI_ALLOC(m, uint32_t, kCompressFragmentTwoPassBlockSize);
-    s->literal_buf_ =
-        BROTLI_ALLOC(m, uint8_t, kCompressFragmentTwoPassBlockSize);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->command_buf_) ||
-        BROTLI_IS_NULL(s->literal_buf_)) {
-      return BROTLI_FALSE;
-    }
-  }
-
-  if (fast_compress) {
-    uint8_t* storage;
-    size_t storage_ix = s->last_bytes_bits_;
-    size_t table_size;
-    int* table;
-
-    storage = GetBrotliStorage(s, 2 * bytes + 503);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    storage[0] = (uint8_t)s->last_bytes_;
-    storage[1] = (uint8_t)(s->last_bytes_ >> 8);
-    table = GetHashTable(s, s->params.quality, bytes, &table_size);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
-      BrotliCompressFragmentFast(
-          s->one_pass_arena_, &data[wrapped_last_processed_pos & mask],
-          bytes, is_last,
-          table, table_size,
-          &storage_ix, storage);
-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    } else {
-      BrotliCompressFragmentTwoPass(
-          s->two_pass_arena_, &data[wrapped_last_processed_pos & mask],
-          bytes, is_last,
-          s->command_buf_, s->literal_buf_,
-          table, table_size,
-          &storage_ix, storage);
-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    }
-    s->last_bytes_ = (uint16_t)(storage[storage_ix >> 3]);
-    s->last_bytes_bits_ = storage_ix & 7u;
-    UpdateLastProcessedPos(s);
-    *output = &storage[0];
-    *out_size = storage_ix >> 3;
-    return BROTLI_TRUE;
-  }
-
-  {
-    /* Theoretical max number of commands is 1 per 2 bytes. */
-    size_t newsize = s->num_commands_ + bytes / 2 + 1;
-    if (newsize > s->cmd_alloc_size_) {
-      Command* new_commands;
-      /* Reserve a bit more memory to allow merging with a next block
-         without reallocation: that would impact speed. */
-      newsize += (bytes / 4) + 16;
-      s->cmd_alloc_size_ = newsize;
-      new_commands = BROTLI_ALLOC(m, Command, newsize);
-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_commands)) return BROTLI_FALSE;
-      if (s->commands_) {
-        memcpy(new_commands, s->commands_, sizeof(Command) * s->num_commands_);
-        BROTLI_FREE(m, s->commands_);
-      }
-      s->commands_ = new_commands;
-    }
-  }
-
-  InitOrStitchToPreviousBlock(m, &s->hasher_, data, mask, &s->params,
-      wrapped_last_processed_pos, bytes, is_last);
-
-  literal_context_mode = ChooseContextMode(
-      &s->params, data, WrapPosition(s->last_flush_pos_),
-      mask, (size_t)(s->input_pos_ - s->last_flush_pos_));
-  literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
-
-  if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-
-  if (s->num_commands_ && s->last_insert_len_ == 0) {
-    ExtendLastCommand(s, &bytes, &wrapped_last_processed_pos);
-  }
-
-  if (s->params.quality == ZOPFLIFICATION_QUALITY) {
-    BROTLI_DCHECK(s->params.hasher.type == 10);
-    BrotliCreateZopfliBackwardReferences(m, bytes, wrapped_last_processed_pos,
-        data, mask, literal_context_lut, &s->params,
-        &s->hasher_, s->dist_cache_,
-        &s->last_insert_len_, &s->commands_[s->num_commands_],
-        &s->num_commands_, &s->num_literals_);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  } else if (s->params.quality == HQ_ZOPFLIFICATION_QUALITY) {
-    BROTLI_DCHECK(s->params.hasher.type == 10);
-    BrotliCreateHqZopfliBackwardReferences(m, bytes, wrapped_last_processed_pos,
-        data, mask, literal_context_lut, &s->params,
-        &s->hasher_, s->dist_cache_,
-        &s->last_insert_len_, &s->commands_[s->num_commands_],
-        &s->num_commands_, &s->num_literals_);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  } else {
-    BrotliCreateBackwardReferences(bytes, wrapped_last_processed_pos,
-        data, mask, literal_context_lut, &s->params,
-        &s->hasher_, s->dist_cache_,
-        &s->last_insert_len_, &s->commands_[s->num_commands_],
-        &s->num_commands_, &s->num_literals_);
-  }
-
-  {
-    const size_t max_length = MaxMetablockSize(&s->params);
-    const size_t max_literals = max_length / 8;
-    const size_t max_commands = max_length / 8;
-    const size_t processed_bytes = (size_t)(s->input_pos_ - s->last_flush_pos_);
-    /* If maximal possible additional block doesn't fit metablock, flush now. */
-    /* TODO(eustas): Postpone decision until next block arrives? */
-    const BROTLI_BOOL next_input_fits_metablock = TO_BROTLI_BOOL(
-        processed_bytes + InputBlockSize(s) <= max_length);
-    /* If block splitting is not used, then flush as soon as there is some
-       amount of commands / literals produced. */
-    const BROTLI_BOOL should_flush = TO_BROTLI_BOOL(
-        s->params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT &&
-        s->num_literals_ + s->num_commands_ >= MAX_NUM_DELAYED_SYMBOLS);
-    if (!is_last && !force_flush && !should_flush &&
-        next_input_fits_metablock &&
-        s->num_literals_ < max_literals &&
-        s->num_commands_ < max_commands) {
-      /* Merge with next input block. Everything will happen later. */
-      if (UpdateLastProcessedPos(s)) {
-        HasherReset(&s->hasher_);
-      }
-      *out_size = 0;
-      return BROTLI_TRUE;
-    }
-  }
-
-  /* Create the last insert-only command. */
-  if (s->last_insert_len_ > 0) {
-    InitInsertCommand(&s->commands_[s->num_commands_++], s->last_insert_len_);
-    s->num_literals_ += s->last_insert_len_;
-    s->last_insert_len_ = 0;
-  }
-
-  if (!is_last && s->input_pos_ == s->last_flush_pos_) {
-    /* We have no new input data and we don't have to finish the stream, so
-       nothing to do. */
-    *out_size = 0;
-    return BROTLI_TRUE;
-  }
-  BROTLI_DCHECK(s->input_pos_ >= s->last_flush_pos_);
-  BROTLI_DCHECK(s->input_pos_ > s->last_flush_pos_ || is_last);
-  BROTLI_DCHECK(s->input_pos_ - s->last_flush_pos_ <= 1u << 24);
-  {
-    const uint32_t metablock_size =
-        (uint32_t)(s->input_pos_ - s->last_flush_pos_);
-    uint8_t* storage = GetBrotliStorage(s, 2 * metablock_size + 503);
-    size_t storage_ix = s->last_bytes_bits_;
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    storage[0] = (uint8_t)s->last_bytes_;
-    storage[1] = (uint8_t)(s->last_bytes_ >> 8);
-    WriteMetaBlockInternal(
-        m, data, mask, s->last_flush_pos_, metablock_size, is_last,
-        literal_context_mode, &s->params, s->prev_byte_, s->prev_byte2_,
-        s->num_literals_, s->num_commands_, s->commands_, s->saved_dist_cache_,
-        s->dist_cache_, &storage_ix, storage);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    s->last_bytes_ = (uint16_t)(storage[storage_ix >> 3]);
-    s->last_bytes_bits_ = storage_ix & 7u;
-    s->last_flush_pos_ = s->input_pos_;
-    if (UpdateLastProcessedPos(s)) {
-      HasherReset(&s->hasher_);
-    }
-    if (s->last_flush_pos_ > 0) {
-      s->prev_byte_ = data[((uint32_t)s->last_flush_pos_ - 1) & mask];
-    }
-    if (s->last_flush_pos_ > 1) {
-      s->prev_byte2_ = data[(uint32_t)(s->last_flush_pos_ - 2) & mask];
-    }
-    s->num_commands_ = 0;
-    s->num_literals_ = 0;
-    /* Save the state of the distance cache in case we need to restore it for
-       emitting an uncompressed block. */
-    memcpy(s->saved_dist_cache_, s->dist_cache_, sizeof(s->saved_dist_cache_));
-    *output = &storage[0];
-    *out_size = storage_ix >> 3;
-    return BROTLI_TRUE;
-  }
-}
-
-/* Dumps remaining output bits and metadata header to |header|.
-   Returns number of produced bytes.
-   REQUIRED: |header| should be 8-byte aligned and at least 16 bytes long.
-   REQUIRED: |block_size| <= (1 << 24). */
-static size_t WriteMetadataHeader(
-    BrotliEncoderState* s, const size_t block_size, uint8_t* header) {
-  size_t storage_ix;
-  storage_ix = s->last_bytes_bits_;
-  header[0] = (uint8_t)s->last_bytes_;
-  header[1] = (uint8_t)(s->last_bytes_ >> 8);
-  s->last_bytes_ = 0;
-  s->last_bytes_bits_ = 0;
-
-  BrotliWriteBits(1, 0, &storage_ix, header);
-  BrotliWriteBits(2, 3, &storage_ix, header);
-  BrotliWriteBits(1, 0, &storage_ix, header);
-  if (block_size == 0) {
-    BrotliWriteBits(2, 0, &storage_ix, header);
-  } else {
-    uint32_t nbits = (block_size == 1) ? 1 :
-        (Log2FloorNonZero((uint32_t)block_size - 1) + 1);
-    uint32_t nbytes = (nbits + 7) / 8;
-    BrotliWriteBits(2, nbytes, &storage_ix, header);
-    BrotliWriteBits(8 * nbytes, block_size - 1, &storage_ix, header);
-  }
-  return (storage_ix + 7u) >> 3;
-}
-
-size_t duckdb_brotli::BrotliEncoderMaxCompressedSize(size_t input_size) {
-  /* [window bits / empty metadata] + N * [uncompressed] + [last empty] */
-  size_t num_large_blocks = input_size >> 14;
-  size_t overhead = 2 + (4 * num_large_blocks) + 3 + 1;
-  size_t result = input_size + overhead;
-  if (input_size == 0) return 2;
-  return (result < input_size) ? 0 : result;
-}
-
-/* Wraps data to uncompressed brotli stream with minimal window size.
-   |output| should point at region with at least BrotliEncoderMaxCompressedSize
-   addressable bytes.
-   Returns the length of stream. */
-static size_t MakeUncompressedStream(
-    const uint8_t* input, size_t input_size, uint8_t* output) {
-  size_t size = input_size;
-  size_t result = 0;
-  size_t offset = 0;
-  if (input_size == 0) {
-    output[0] = 6;
-    return 1;
-  }
-  output[result++] = 0x21;  /* window bits = 10, is_last = false */
-  output[result++] = 0x03;  /* empty metadata, padding */
-  while (size > 0) {
-    uint32_t nibbles = 0;
-    uint32_t chunk_size;
-    uint32_t bits;
-    chunk_size = (size > (1u << 24)) ? (1u << 24) : (uint32_t)size;
-    if (chunk_size > (1u << 16)) nibbles = (chunk_size > (1u << 20)) ? 2 : 1;
-    bits =
-        (nibbles << 1) | ((chunk_size - 1) << 3) | (1u << (19 + 4 * nibbles));
-    output[result++] = (uint8_t)bits;
-    output[result++] = (uint8_t)(bits >> 8);
-    output[result++] = (uint8_t)(bits >> 16);
-    if (nibbles == 2) output[result++] = (uint8_t)(bits >> 24);
-    memcpy(&output[result], &input[offset], chunk_size);
-    result += chunk_size;
-    offset += chunk_size;
-    size -= chunk_size;
-  }
-  output[result++] = 3;
-  return result;
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliEncoderCompress(
-    int quality, int lgwin, BrotliEncoderMode mode, size_t input_size,
-    const uint8_t input_buffer[BROTLI_ARRAY_PARAM(input_size)],
-    size_t* encoded_size,
-    uint8_t encoded_buffer[BROTLI_ARRAY_PARAM(*encoded_size)]) {
-  BrotliEncoderState* s;
-  size_t out_size = *encoded_size;
-  const uint8_t* input_start = input_buffer;
-  uint8_t* output_start = encoded_buffer;
-  size_t max_out_size = BrotliEncoderMaxCompressedSize(input_size);
-  if (out_size == 0) {
-    /* Output buffer needs at least one byte. */
-    return BROTLI_FALSE;
-  }
-  if (input_size == 0) {
-    /* Handle the special case of empty input. */
-    *encoded_size = 1;
-    *encoded_buffer = 6;
-    return BROTLI_TRUE;
-  }
-
-  s = BrotliEncoderCreateInstance(0, 0, 0);
-  if (!s) {
-    return BROTLI_FALSE;
-  } else {
-    size_t available_in = input_size;
-    const uint8_t* next_in = input_buffer;
-    size_t available_out = *encoded_size;
-    uint8_t* next_out = encoded_buffer;
-    size_t total_out = 0;
-    BROTLI_BOOL result = BROTLI_FALSE;
-    /* TODO(eustas): check that parameters are sane. */
-    BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, (uint32_t)quality);
-    BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, (uint32_t)lgwin);
-    BrotliEncoderSetParameter(s, BROTLI_PARAM_MODE, (uint32_t)mode);
-    BrotliEncoderSetParameter(s, BROTLI_PARAM_SIZE_HINT, (uint32_t)input_size);
-    if (lgwin > BROTLI_MAX_WINDOW_BITS) {
-      BrotliEncoderSetParameter(s, BROTLI_PARAM_LARGE_WINDOW, BROTLI_TRUE);
-    }
-    result = BrotliEncoderCompressStream(s, BROTLI_OPERATION_FINISH,
-        &available_in, &next_in, &available_out, &next_out, &total_out);
-    if (!BrotliEncoderIsFinished(s)) result = 0;
-    *encoded_size = total_out;
-    BrotliEncoderDestroyInstance(s);
-    if (!result || (max_out_size && *encoded_size > max_out_size)) {
-      goto fallback;
-    }
-    return BROTLI_TRUE;
-  }
-fallback:
-  *encoded_size = 0;
-  if (!max_out_size) return BROTLI_FALSE;
-  if (out_size >= max_out_size) {
-    *encoded_size =
-        MakeUncompressedStream(input_start, input_size, output_start);
-    return BROTLI_TRUE;
-  }
-  return BROTLI_FALSE;
-}
-
-static void InjectBytePaddingBlock(BrotliEncoderState* s) {
-  uint32_t seal = s->last_bytes_;
-  size_t seal_bits = s->last_bytes_bits_;
-  uint8_t* destination;
-  s->last_bytes_ = 0;
-  s->last_bytes_bits_ = 0;
-  /* is_last = 0, data_nibbles = 11, reserved = 0, meta_nibbles = 00 */
-  seal |= 0x6u << seal_bits;
-  seal_bits += 6;
-  /* If we have already created storage, then append to it.
-     Storage is valid until next block is being compressed. */
-  if (s->next_out_) {
-    destination = s->next_out_ + s->available_out_;
-  } else {
-    destination = s->tiny_buf_.u8;
-    s->next_out_ = destination;
-  }
-  destination[0] = (uint8_t)seal;
-  if (seal_bits > 8) destination[1] = (uint8_t)(seal >> 8);
-  if (seal_bits > 16) destination[2] = (uint8_t)(seal >> 16);
-  s->available_out_ += (seal_bits + 7) >> 3;
-}
-
-/* Fills the |total_out|, if it is not NULL. */
-static void SetTotalOut(BrotliEncoderState* s, size_t* total_out) {
-  if (total_out) {
-    /* Saturating conversion uint64_t -> size_t */
-    size_t result = (size_t)-1;
-    if (s->total_out_ < result) {
-      result = (size_t)s->total_out_;
-    }
-    *total_out = result;
-  }
-}
-
-/* Injects padding bits or pushes compressed data to output.
-   Returns false if nothing is done. */
-static BROTLI_BOOL InjectFlushOrPushOutput(BrotliEncoderState* s,
-    size_t* available_out, uint8_t** next_out, size_t* total_out) {
-  if (s->stream_state_ == BROTLI_STREAM_FLUSH_REQUESTED &&
-      s->last_bytes_bits_ != 0) {
-    InjectBytePaddingBlock(s);
-    return BROTLI_TRUE;
-  }
-
-  if (s->available_out_ != 0 && *available_out != 0) {
-    size_t copy_output_size =
-        BROTLI_MIN(size_t, s->available_out_, *available_out);
-    memcpy(*next_out, s->next_out_, copy_output_size);
-    *next_out += copy_output_size;
-    *available_out -= copy_output_size;
-    s->next_out_ += copy_output_size;
-    s->available_out_ -= copy_output_size;
-    s->total_out_ += copy_output_size;
-    SetTotalOut(s, total_out);
-    return BROTLI_TRUE;
-  }
-
-  return BROTLI_FALSE;
-}
-
-static void CheckFlushComplete(BrotliEncoderState* s) {
-  if (s->stream_state_ == BROTLI_STREAM_FLUSH_REQUESTED &&
-      s->available_out_ == 0) {
-    s->stream_state_ = BROTLI_STREAM_PROCESSING;
-    s->next_out_ = 0;
-  }
-}
-
-static BROTLI_BOOL BrotliEncoderCompressStreamFast(
-    BrotliEncoderState* s, BrotliEncoderOperation op, size_t* available_in,
-    const uint8_t** next_in, size_t* available_out, uint8_t** next_out,
-    size_t* total_out) {
-  const size_t block_size_limit = (size_t)1 << s->params.lgwin;
-  const size_t buf_size = BROTLI_MIN(size_t, kCompressFragmentTwoPassBlockSize,
-      BROTLI_MIN(size_t, *available_in, block_size_limit));
-  uint32_t* tmp_command_buf = NULL;
-  uint32_t* command_buf = NULL;
-  uint8_t* tmp_literal_buf = NULL;
-  uint8_t* literal_buf = NULL;
-  MemoryManager* m = &s->memory_manager_;
-  if (s->params.quality != FAST_ONE_PASS_COMPRESSION_QUALITY &&
-      s->params.quality != FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    return BROTLI_FALSE;
-  }
-  if (s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    if (!s->command_buf_ && buf_size == kCompressFragmentTwoPassBlockSize) {
-      s->command_buf_ =
-          BROTLI_ALLOC(m, uint32_t, kCompressFragmentTwoPassBlockSize);
-      s->literal_buf_ =
-          BROTLI_ALLOC(m, uint8_t, kCompressFragmentTwoPassBlockSize);
-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->command_buf_) ||
-          BROTLI_IS_NULL(s->literal_buf_)) {
-        return BROTLI_FALSE;
-      }
-    }
-    if (s->command_buf_) {
-      command_buf = s->command_buf_;
-      literal_buf = s->literal_buf_;
-    } else {
-      tmp_command_buf = BROTLI_ALLOC(m, uint32_t, buf_size);
-      tmp_literal_buf = BROTLI_ALLOC(m, uint8_t, buf_size);
-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp_command_buf) ||
-          BROTLI_IS_NULL(tmp_literal_buf)) {
-        return BROTLI_FALSE;
-      }
-      command_buf = tmp_command_buf;
-      literal_buf = tmp_literal_buf;
-    }
-  }
-
-  while (BROTLI_TRUE) {
-    if (InjectFlushOrPushOutput(s, available_out, next_out, total_out)) {
-      continue;
-    }
-
-    /* Compress block only when internal output buffer is empty, stream is not
-       finished, there is no pending flush request, and there is either
-       additional input or pending operation. */
-    if (s->available_out_ == 0 &&
-        s->stream_state_ == BROTLI_STREAM_PROCESSING &&
-        (*available_in != 0 || op != BROTLI_OPERATION_PROCESS)) {
-      size_t block_size = BROTLI_MIN(size_t, block_size_limit, *available_in);
-      BROTLI_BOOL is_last =
-          (*available_in == block_size) && (op == BROTLI_OPERATION_FINISH);
-      BROTLI_BOOL force_flush =
-          (*available_in == block_size) && (op == BROTLI_OPERATION_FLUSH);
-      size_t max_out_size = 2 * block_size + 503;
-      BROTLI_BOOL inplace = BROTLI_TRUE;
-      uint8_t* storage = NULL;
-      size_t storage_ix = s->last_bytes_bits_;
-      size_t table_size;
-      int* table;
-
-      if (force_flush && block_size == 0) {
-        s->stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED;
-        continue;
-      }
-      if (max_out_size <= *available_out) {
-        storage = *next_out;
-      } else {
-        inplace = BROTLI_FALSE;
-        storage = GetBrotliStorage(s, max_out_size);
-        if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-      }
-      storage[0] = (uint8_t)s->last_bytes_;
-      storage[1] = (uint8_t)(s->last_bytes_ >> 8);
-      table = GetHashTable(s, s->params.quality, block_size, &table_size);
-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-
-      if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
-        BrotliCompressFragmentFast(s->one_pass_arena_, *next_in, block_size,
-            is_last, table, table_size, &storage_ix, storage);
-        if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-      } else {
-        BrotliCompressFragmentTwoPass(s->two_pass_arena_, *next_in, block_size,
-            is_last, command_buf, literal_buf, table, table_size,
-            &storage_ix, storage);
-        if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-      }
-      if (block_size != 0) {
-        *next_in += block_size;
-        *available_in -= block_size;
-        s->total_in_ += block_size;
-      }
-      if (inplace) {
-        size_t out_bytes = storage_ix >> 3;
-        BROTLI_DCHECK(out_bytes <= *available_out);
-        BROTLI_DCHECK((storage_ix & 7) == 0 || out_bytes < *available_out);
-        *next_out += out_bytes;
-        *available_out -= out_bytes;
-        s->total_out_ += out_bytes;
-        SetTotalOut(s, total_out);
-      } else {
-        size_t out_bytes = storage_ix >> 3;
-        s->next_out_ = storage;
-        s->available_out_ = out_bytes;
-      }
-      s->last_bytes_ = (uint16_t)(storage[storage_ix >> 3]);
-      s->last_bytes_bits_ = storage_ix & 7u;
-
-      if (force_flush) s->stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED;
-      if (is_last) s->stream_state_ = BROTLI_STREAM_FINISHED;
-      continue;
-    }
-    break;
-  }
-  BROTLI_FREE(m, tmp_command_buf);
-  BROTLI_FREE(m, tmp_literal_buf);
-  CheckFlushComplete(s);
-  return BROTLI_TRUE;
-}
-
-static BROTLI_BOOL ProcessMetadata(
-    BrotliEncoderState* s, size_t* available_in, const uint8_t** next_in,
-    size_t* available_out, uint8_t** next_out, size_t* total_out) {
-  if (*available_in > (1u << 24)) return BROTLI_FALSE;
-  /* Switch to metadata block workflow, if required. */
-  if (s->stream_state_ == BROTLI_STREAM_PROCESSING) {
-    s->remaining_metadata_bytes_ = (uint32_t)*available_in;
-    s->stream_state_ = BROTLI_STREAM_METADATA_HEAD;
-  }
-  if (s->stream_state_ != BROTLI_STREAM_METADATA_HEAD &&
-      s->stream_state_ != BROTLI_STREAM_METADATA_BODY) {
-    return BROTLI_FALSE;
-  }
-
-  while (BROTLI_TRUE) {
-    if (InjectFlushOrPushOutput(s, available_out, next_out, total_out)) {
-      continue;
-    }
-    if (s->available_out_ != 0) break;
-
-    if (s->input_pos_ != s->last_flush_pos_) {
-      BROTLI_BOOL result = EncodeData(s, BROTLI_FALSE, BROTLI_TRUE,
-          &s->available_out_, &s->next_out_);
-      if (!result) return BROTLI_FALSE;
-      continue;
-    }
-
-    if (s->stream_state_ == BROTLI_STREAM_METADATA_HEAD) {
-      s->next_out_ = s->tiny_buf_.u8;
-      s->available_out_ =
-          WriteMetadataHeader(s, s->remaining_metadata_bytes_, s->next_out_);
-      s->stream_state_ = BROTLI_STREAM_METADATA_BODY;
-      continue;
-    } else {
-      /* Exit workflow only when there is no more input and no more output.
-         Otherwise client may continue producing empty metadata blocks. */
-      if (s->remaining_metadata_bytes_ == 0) {
-        s->remaining_metadata_bytes_ = BROTLI_UINT32_MAX;
-        s->stream_state_ = BROTLI_STREAM_PROCESSING;
-        break;
-      }
-      if (*available_out) {
-        /* Directly copy input to output. */
-        uint32_t copy = (uint32_t)BROTLI_MIN(
-            size_t, s->remaining_metadata_bytes_, *available_out);
-        memcpy(*next_out, *next_in, copy);
-        *next_in += copy;
-        *available_in -= copy;
-        s->total_in_ += copy;  /* not actually data input, though */
-        s->remaining_metadata_bytes_ -= copy;
-        *next_out += copy;
-        *available_out -= copy;
-      } else {
-        /* This guarantees progress in "TakeOutput" workflow. */
-        uint32_t copy = BROTLI_MIN(uint32_t, s->remaining_metadata_bytes_, 16);
-        s->next_out_ = s->tiny_buf_.u8;
-        memcpy(s->next_out_, *next_in, copy);
-        *next_in += copy;
-        *available_in -= copy;
-        s->total_in_ += copy;  /* not actually data input, though */
-        s->remaining_metadata_bytes_ -= copy;
-        s->available_out_ = copy;
-      }
-      continue;
-    }
-  }
-
-  return BROTLI_TRUE;
-}
-
-static void UpdateSizeHint(BrotliEncoderState* s, size_t available_in) {
-  if (s->params.size_hint == 0) {
-    uint64_t delta = UnprocessedInputSize(s);
-    uint64_t tail = available_in;
-    uint32_t limit = 1u << 30;
-    uint32_t total;
-    if ((delta >= limit) || (tail >= limit) || ((delta + tail) >= limit)) {
-      total = limit;
-    } else {
-      total = (uint32_t)(delta + tail);
-    }
-    s->params.size_hint = total;
-  }
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliEncoderCompressStream(
-    BrotliEncoderState* s, BrotliEncoderOperation op, size_t* available_in,
-    const uint8_t** next_in, size_t* available_out, uint8_t** next_out,
-    size_t* total_out) {
-  if (!EnsureInitialized(s)) return BROTLI_FALSE;
-
-  /* Unfinished metadata block; check requirements. */
-  if (s->remaining_metadata_bytes_ != BROTLI_UINT32_MAX) {
-    if (*available_in != s->remaining_metadata_bytes_) return BROTLI_FALSE;
-    if (op != BROTLI_OPERATION_EMIT_METADATA) return BROTLI_FALSE;
-  }
-
-  if (op == BROTLI_OPERATION_EMIT_METADATA) {
-    UpdateSizeHint(s, 0);  /* First data metablock might be emitted here. */
-    return ProcessMetadata(
-        s, available_in, next_in, available_out, next_out, total_out);
-  }
-
-  if (s->stream_state_ == BROTLI_STREAM_METADATA_HEAD ||
-      s->stream_state_ == BROTLI_STREAM_METADATA_BODY) {
-    return BROTLI_FALSE;
-  }
-
-  if (s->stream_state_ != BROTLI_STREAM_PROCESSING && *available_in != 0) {
-    return BROTLI_FALSE;
-  }
-  if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
-      s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    return BrotliEncoderCompressStreamFast(s, op, available_in, next_in,
-        available_out, next_out, total_out);
-  }
-  while (BROTLI_TRUE) {
-    size_t remaining_block_size = RemainingInputBlockSize(s);
-    /* Shorten input to flint size. */
-    if (s->flint_ >= 0 && remaining_block_size > (size_t)s->flint_) {
-      remaining_block_size = (size_t)s->flint_;
-    }
-
-    if (remaining_block_size != 0 && *available_in != 0) {
-      size_t copy_input_size =
-          BROTLI_MIN(size_t, remaining_block_size, *available_in);
-      CopyInputToRingBuffer(s, copy_input_size, *next_in);
-      *next_in += copy_input_size;
-      *available_in -= copy_input_size;
-      s->total_in_ += copy_input_size;
-      if (s->flint_ > 0) s->flint_ = (int8_t)(s->flint_ - (int)copy_input_size);
-      continue;
-    }
-
-    if (InjectFlushOrPushOutput(s, available_out, next_out, total_out)) {
-      /* Exit the "emit flint" workflow. */
-      if (s->flint_ == BROTLI_FLINT_WAITING_FOR_FLUSHING) {
-        CheckFlushComplete(s);
-        if (s->stream_state_ == BROTLI_STREAM_PROCESSING) {
-          s->flint_ = BROTLI_FLINT_DONE;
-        }
-      }
-      continue;
-    }
-
-    /* Compress data only when internal output buffer is empty, stream is not
-       finished and there is no pending flush request. */
-    if (s->available_out_ == 0 &&
-        s->stream_state_ == BROTLI_STREAM_PROCESSING) {
-      if (remaining_block_size == 0 || op != BROTLI_OPERATION_PROCESS) {
-        BROTLI_BOOL is_last = TO_BROTLI_BOOL(
-            (*available_in == 0) && op == BROTLI_OPERATION_FINISH);
-        BROTLI_BOOL force_flush = TO_BROTLI_BOOL(
-            (*available_in == 0) && op == BROTLI_OPERATION_FLUSH);
-        BROTLI_BOOL result;
-        /* Force emitting (uncompressed) piece containing flint. */
-        if (!is_last && s->flint_ == 0) {
-          s->flint_ = BROTLI_FLINT_WAITING_FOR_FLUSHING;
-          force_flush = BROTLI_TRUE;
-        }
-        UpdateSizeHint(s, *available_in);
-        result = EncodeData(s, is_last, force_flush,
-            &s->available_out_, &s->next_out_);
-        if (!result) return BROTLI_FALSE;
-        if (force_flush) s->stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED;
-        if (is_last) s->stream_state_ = BROTLI_STREAM_FINISHED;
-        continue;
-      }
-    }
-    break;
-  }
-  CheckFlushComplete(s);
-  return BROTLI_TRUE;
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliEncoderIsFinished(BrotliEncoderState* s) {
-  return TO_BROTLI_BOOL(s->stream_state_ == BROTLI_STREAM_FINISHED &&
-      !BrotliEncoderHasMoreOutput(s));
-}
-
-BROTLI_BOOL duckdb_brotli::BrotliEncoderHasMoreOutput(BrotliEncoderState* s) {
-  return TO_BROTLI_BOOL(s->available_out_ != 0);
-}
-
-const uint8_t* BrotliEncoderTakeOutput(BrotliEncoderState* s, size_t* size) {
-  size_t consumed_size = s->available_out_;
-  uint8_t* result = s->next_out_;
-  if (*size) {
-    consumed_size = BROTLI_MIN(size_t, *size, s->available_out_);
-  }
-  if (consumed_size) {
-    s->next_out_ += consumed_size;
-    s->available_out_ -= consumed_size;
-    s->total_out_ += consumed_size;
-    CheckFlushComplete(s);
-    *size = consumed_size;
-  } else {
-    *size = 0;
-    result = 0;
-  }
-  return result;
-}
-
-uint32_t duckdb_brotli::BrotliEncoderVersion(void) {
-  return BROTLI_VERSION;
-}
-
-BrotliEncoderPreparedDictionary*  duckdb_brotli::BrotliEncoderPrepareDictionary(
-    BrotliSharedDictionaryType type, size_t size,
-    const uint8_t data[BROTLI_ARRAY_PARAM(size)], int quality,
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
-  ManagedDictionary* managed_dictionary = NULL;
-  BROTLI_BOOL type_is_known = BROTLI_FALSE;
-  type_is_known |= (type == BROTLI_SHARED_DICTIONARY_RAW);
-#if defined(BROTLI_EXPERIMENTAL)
-  type_is_known |= (type == BROTLI_SHARED_DICTIONARY_SERIALIZED);
-#endif  /* BROTLI_EXPERIMENTAL */
-  if (!type_is_known) {
-    return NULL;
-  }
-  managed_dictionary =
-      BrotliCreateManagedDictionary(alloc_func, free_func, opaque);
-  if (managed_dictionary == NULL) {
-    return NULL;
-  }
-  if (type == BROTLI_SHARED_DICTIONARY_RAW) {
-    managed_dictionary->dictionary = (uint32_t*)CreatePreparedDictionary(
-        &managed_dictionary->memory_manager_, data, size);
-  }
-#if defined(BROTLI_EXPERIMENTAL)
-  if (type == BROTLI_SHARED_DICTIONARY_SERIALIZED) {
-    SharedEncoderDictionary* dict = (SharedEncoderDictionary*)BrotliAllocate(
-        &managed_dictionary->memory_manager_, sizeof(SharedEncoderDictionary));
-    managed_dictionary->dictionary = (uint32_t*)dict;
-    if (dict != NULL) {
-      BROTLI_BOOL ok = BrotliInitCustomSharedEncoderDictionary(
-          &managed_dictionary->memory_manager_, data, size, quality, dict);
-      if (!ok) {
-        BrotliFree(&managed_dictionary->memory_manager_, dict);
-        managed_dictionary->dictionary = NULL;
-      }
-    }
-  }
-#else  /* BROTLI_EXPERIMENTAL */
-  (void)quality;
-#endif  /* BROTLI_EXPERIMENTAL */
-  if (managed_dictionary->dictionary == NULL) {
-    BrotliDestroyManagedDictionary(managed_dictionary);
-    return NULL;
-  }
-  return (BrotliEncoderPreparedDictionary*)managed_dictionary;
-}
-
-void BrotliEncoderDestroyPreparedDictionary(
-    BrotliEncoderPreparedDictionary* dictionary) {
-  ManagedDictionary* dict = (ManagedDictionary*)dictionary;
-  if (!dictionary) return;
-  /* First field of dictionary structs. */
-  /* Only managed dictionaries are eligible for destruction by this method. */
-  if (dict->magic != kManagedDictionaryMagic) {
-    return;
-  }
-  if (dict->dictionary == NULL) {
-    /* This should never ever happen. */
-  } else if (*dict->dictionary == kLeanPreparedDictionaryMagic) {
-    DestroyPreparedDictionary(
-        &dict->memory_manager_, (PreparedDictionary*)dict->dictionary);
-  } else if (*dict->dictionary == kSharedDictionaryMagic) {
-    BrotliCleanupSharedEncoderDictionary(&dict->memory_manager_,
-        (SharedEncoderDictionary*)dict->dictionary);
-    BrotliFree(&dict->memory_manager_, dict->dictionary);
-  } else {
-    /* There is also kPreparedDictionaryMagic, but such instances should be
-     * constructed and destroyed by different means. */
-  }
-  dict->dictionary = NULL;
-  BrotliDestroyManagedDictionary(dict);
-}
-
-BROTLI_BOOL BrotliEncoderAttachPreparedDictionary(BrotliEncoderState* state,
-    const BrotliEncoderPreparedDictionary* dictionary) {
-  /* First field of dictionary structs */
-  const BrotliEncoderPreparedDictionary* dict = dictionary;
-  uint32_t magic = *((const uint32_t*)dict);
-  SharedEncoderDictionary* current = NULL;
-  if (magic == kManagedDictionaryMagic) {
-    /* Unwrap managed dictionary. */
-    ManagedDictionary* managed_dictionary = (ManagedDictionary*)dict;
-    magic = *managed_dictionary->dictionary;
-    dict = (BrotliEncoderPreparedDictionary*)managed_dictionary->dictionary;
-  }
-  current = &state->params.dictionary;
-  if (magic == kPreparedDictionaryMagic ||
-      magic == kLeanPreparedDictionaryMagic) {
-    const PreparedDictionary* prepared = (const PreparedDictionary*)dict;
-    if (!AttachPreparedDictionary(&current->compound, prepared)) {
-      return BROTLI_FALSE;
-    }
-  } else if (magic == kSharedDictionaryMagic) {
-    const SharedEncoderDictionary* attached =
-        (const SharedEncoderDictionary*)dict;
-    BROTLI_BOOL was_default = !current->contextual.context_based &&
-        current->contextual.num_dictionaries == 1 &&
-        current->contextual.dict[0]->hash_table_words ==
-        kStaticDictionaryHashWords &&
-        current->contextual.dict[0]->hash_table_lengths ==
-        kStaticDictionaryHashLengths;
-    BROTLI_BOOL new_default = !attached->contextual.context_based &&
-        attached->contextual.num_dictionaries == 1 &&
-        attached->contextual.dict[0]->hash_table_words ==
-        kStaticDictionaryHashWords &&
-        attached->contextual.dict[0]->hash_table_lengths ==
-        kStaticDictionaryHashLengths;
-    size_t i;
-    if (state->is_initialized_) return BROTLI_FALSE;
-    current->max_quality =
-        BROTLI_MIN(int, current->max_quality, attached->max_quality);
-    for (i = 0; i < attached->compound.num_chunks; i++) {
-      if (!AttachPreparedDictionary(&current->compound,
-          attached->compound.chunks[i])) {
-        return BROTLI_FALSE;
-      }
-    }
-    if (!new_default) {
-      if (!was_default) return BROTLI_FALSE;
-      /* Copy by value, but then set num_instances_ to 0 because their memory
-      is managed by attached, not by current */
-      current->contextual = attached->contextual;
-      current->contextual.num_instances_ = 0;
-    }
-  } else {
-    return BROTLI_FALSE;
-  }
-  return BROTLI_TRUE;
-}
-
-size_t  duckdb_brotli::BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin,
-                                            size_t input_size) {
-  BrotliEncoderParams params;
-  size_t memory_manager_slots = BROTLI_ENCODER_MEMORY_MANAGER_SLOTS;
-  size_t memory_manager_size = memory_manager_slots * sizeof(void*);
-  BrotliEncoderInitParams(&params);
-  params.quality = quality;
-  params.lgwin = lgwin;
-  params.size_hint = input_size;
-  params.large_window = lgwin > BROTLI_MAX_WINDOW_BITS;
-  SanitizeParams(&params);
-  params.lgblock = ComputeLgBlock(&params);
-  ChooseHasher(&params, &params.hasher);
-  if (params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
-      params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    size_t state_size = sizeof(BrotliEncoderState);
-    size_t block_size = BROTLI_MIN(size_t, input_size, (1ul << params.lgwin));
-    size_t hash_table_size =
-        HashTableSize(MaxHashTableSize(params.quality), block_size);
-    size_t hash_size =
-        (hash_table_size < (1u << 10)) ? 0 : sizeof(int) * hash_table_size;
-    size_t cmdbuf_size = params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY ?
-        5 * BROTLI_MIN(size_t, block_size, 1ul << 17) : 0;
-    if (params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
-      state_size += sizeof(BrotliOnePassArena);
-    } else {
-      state_size += sizeof(BrotliTwoPassArena);
-    }
-    return hash_size + cmdbuf_size + state_size;
-  } else {
-    size_t short_ringbuffer_size = (size_t)1 << params.lgblock;
-    int ringbuffer_bits = ComputeRbBits(&params);
-    size_t ringbuffer_size = input_size < short_ringbuffer_size ?
-        input_size : (1u << ringbuffer_bits) + short_ringbuffer_size;
-    size_t hash_size[4] = {0};
-    size_t metablock_size =
-        BROTLI_MIN(size_t, input_size, MaxMetablockSize(&params));
-    size_t inputblock_size =
-        BROTLI_MIN(size_t, input_size, (size_t)1 << params.lgblock);
-    size_t cmdbuf_size = metablock_size * 2 + inputblock_size * 6;
-    size_t outbuf_size = metablock_size * 2 + 503;
-    size_t histogram_size = 0;
-    HasherSize(&params, BROTLI_TRUE, input_size, hash_size);
-    if (params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
-      cmdbuf_size = BROTLI_MIN(size_t, cmdbuf_size,
-          MAX_NUM_DELAYED_SYMBOLS * sizeof(Command) + inputblock_size * 12);
-    }
-    if (params.quality >= MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING) {
-      /* Only a very rough estimation, based on enwik8. */
-      histogram_size = 200 << 20;
-    } else if (params.quality >= MIN_QUALITY_FOR_BLOCK_SPLIT) {
-      size_t literal_histograms =
-          BROTLI_MIN(size_t, metablock_size / 6144, 256);
-      size_t command_histograms =
-          BROTLI_MIN(size_t, metablock_size / 6144, 256);
-      size_t distance_histograms =
-          BROTLI_MIN(size_t, metablock_size / 6144, 256);
-      histogram_size = literal_histograms * sizeof(HistogramLiteral) +
-                       command_histograms * sizeof(HistogramCommand) +
-                       distance_histograms * sizeof(HistogramDistance);
-    }
-    return (memory_manager_size + ringbuffer_size +
-            hash_size[0] + hash_size[1] + hash_size[2] + hash_size[3] +
-            cmdbuf_size +
-            outbuf_size +
-            histogram_size);
-  }
-}
-size_t duckdb_brotli::BrotliEncoderGetPreparedDictionarySize(
-    const BrotliEncoderPreparedDictionary* prepared_dictionary) {
-  /* First field of dictionary structs */
-  const BrotliEncoderPreparedDictionary* prepared = prepared_dictionary;
-  uint32_t magic = *((const uint32_t*)prepared);
-  size_t overhead = 0;
-  if (magic == kManagedDictionaryMagic) {
-    const ManagedDictionary* managed = (const ManagedDictionary*)prepared;
-    overhead = sizeof(ManagedDictionary);
-    magic = *managed->dictionary;
-    prepared = (const BrotliEncoderPreparedDictionary*)managed->dictionary;
-  }
-
-  if (magic == kPreparedDictionaryMagic) {
-    const PreparedDictionary* dictionary =
-        (const PreparedDictionary*)prepared;
-    /* Keep in sync with step 3 of CreatePreparedDictionary */
-    return sizeof(PreparedDictionary) + dictionary->source_size +
-        (sizeof(uint32_t) << dictionary->slot_bits) +
-        (sizeof(uint16_t) << dictionary->bucket_bits) +
-        (sizeof(uint32_t) * dictionary->num_items) + overhead;
-  } else if (magic == kLeanPreparedDictionaryMagic) {
-    const PreparedDictionary* dictionary =
-        (const PreparedDictionary*)prepared;
-    /* Keep in sync with step 3 of CreatePreparedDictionary */
-    return sizeof(PreparedDictionary) + sizeof(uint8_t*) +
-        (sizeof(uint32_t) << dictionary->slot_bits) +
-        (sizeof(uint16_t) << dictionary->bucket_bits) +
-        (sizeof(uint32_t) * dictionary->num_items) + overhead;
-  } else if (magic == kSharedDictionaryMagic) {
-    const SharedEncoderDictionary* dictionary =
-        (const SharedEncoderDictionary*)prepared;
-    const CompoundDictionary* compound = &dictionary->compound;
-    const ContextualEncoderDictionary* contextual = &dictionary->contextual;
-    size_t result = sizeof(*dictionary);
-    size_t i;
-    size_t num_instances;
-    const BrotliEncoderDictionary* instances;
-    for (i = 0; i < compound->num_prepared_instances_; i++) {
-      size_t size = BrotliEncoderGetPreparedDictionarySize(
-          (const BrotliEncoderPreparedDictionary*)
-          compound->prepared_instances_[i]);
-      if (!size) return 0;  /* error */
-      result += size;
-    }
-    if (contextual->context_based) {
-      num_instances = contextual->num_instances_;
-      instances = contextual->instances_;
-      result += sizeof(*instances) * num_instances;
-    } else {
-      num_instances = 1;
-      instances = &contextual->instance_;
-    }
-    for (i = 0; i < num_instances; i++) {
-      const BrotliEncoderDictionary* dict = &instances[i];
-      result += dict->trie.pool_capacity * sizeof(BrotliTrieNode);
-      if (dict->hash_table_data_words_) {
-        result += sizeof(kStaticDictionaryHashWords);
-      }
-      if (dict->hash_table_data_lengths_) {
-        result += sizeof(kStaticDictionaryHashLengths);
-      }
-      if (dict->buckets_data_) {
-        result += sizeof(*dict->buckets_data_) * dict->buckets_alloc_size_;
-      }
-      if (dict->dict_words_data_) {
-        result += sizeof(*dict->dict_words) * dict->dict_words_alloc_size_;
-      }
-      if (dict->words_instance_) {
-        result += sizeof(*dict->words_instance_);
-        /* data_size not added here: it is never allocated by the
-           SharedEncoderDictionary, instead it always points to the file
-           already loaded in memory. So if the caller wants to include
-           this memory as well, add the size of the loaded dictionary
-           file to this. */
-      }
-    }
-    return result + overhead;
-  }
-  return 0;  /* error */
-}
-
-#if defined(BROTLI_TEST)
-size_t MakeUncompressedStreamForTest(const uint8_t*, size_t, uint8_t*);
-size_t MakeUncompressedStreamForTest(
-    const uint8_t* input, size_t input_size, uint8_t* output) {
-  return MakeUncompressedStream(input, input_size, output);
-}
-#endif
diff --git a/src/duckdb/third_party/brotli/enc/encoder_dict.cpp b/src/duckdb/third_party/brotli/enc/encoder_dict.cpp
deleted file mode 100644
index 3f5a0fcb1..000000000
--- a/src/duckdb/third_party/brotli/enc/encoder_dict.cpp
+++ /dev/null
@@ -1,636 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "encoder_dict.h"
-
-#include <stdlib.h>  /* malloc, free */
-
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "../common/shared_dictionary_internal.h"
-#include "../common/transform.h"
-#include "compound_dictionary.h"
-#include "dictionary_hash.h"
-#include "memory.h"
-#include "quality.h"
-#include "brotli_hash.h"
-
-using namespace duckdb_brotli;
-
-#define NUM_HASH_BITS 15u
-#define NUM_HASH_BUCKETS (1u << NUM_HASH_BITS)
-
-static void BrotliTrieInit(BrotliTrie* trie) {
-  trie->pool_capacity = 0;
-  trie->pool_size = 0;
-  trie->pool = 0;
-
-  /* Set up the root node */
-  trie->root.single = 0;
-  trie->root.len_ = 0;
-  trie->root.idx_ = 0;
-  trie->root.sub = 0;
-}
-
-static void BrotliTrieFree(MemoryManager* m, BrotliTrie* trie) {
-  BrotliFree(m, trie->pool);
-}
-
-/* Initializes to RFC 7932 static dictionary / transforms. */
-static void InitEncoderDictionary(BrotliEncoderDictionary* dict) {
-  dict->words = BrotliGetDictionary();
-  dict->num_transforms = (uint32_t)BrotliGetTransforms()->num_transforms;
-
-  dict->hash_table_words = kStaticDictionaryHashWords;
-  dict->hash_table_lengths = kStaticDictionaryHashLengths;
-  dict->buckets = kStaticDictionaryBuckets;
-  dict->dict_words = kStaticDictionaryWords;
-
-  dict->cutoffTransformsCount = kCutoffTransformsCount;
-  dict->cutoffTransforms = kCutoffTransforms;
-
-  dict->parent = 0;
-
-  dict->hash_table_data_words_ = 0;
-  dict->hash_table_data_lengths_ = 0;
-  dict->buckets_alloc_size_ = 0;
-  dict->buckets_data_ = 0;
-  dict->dict_words_alloc_size_ = 0;
-  dict->dict_words_data_ = 0;
-  dict->words_instance_ = 0;
-  dict->has_words_heavy = BROTLI_FALSE;
-  BrotliTrieInit(&dict->trie);
-}
-
-static void BrotliDestroyEncoderDictionary(MemoryManager* m,
-    BrotliEncoderDictionary* dict) {
-  BrotliFree(m, dict->hash_table_data_words_);
-  BrotliFree(m, dict->hash_table_data_lengths_);
-  BrotliFree(m, dict->buckets_data_);
-  BrotliFree(m, dict->dict_words_data_);
-  BrotliFree(m, dict->words_instance_);
-  BrotliTrieFree(m, &dict->trie);
-}
-
-#if defined(BROTLI_EXPERIMENTAL)
-/* Word length must be at least 4 bytes */
-static uint32_t Hash(const uint8_t* data, int bits) {
-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - bits);
-}
-
-/* Theoretical max possible word size after transform */
-#define kTransformedBufferSize \
-    (256 + 256 + SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH)
-
-/* To be safe buffer must have at least kTransformedBufferSize */
-static void TransformedDictionaryWord(uint32_t word_idx, int len, int transform,
-    const BrotliTransforms* transforms,
-    const BrotliEncoderDictionary* dict,
-    uint8_t* buffer, size_t* size) {
-  const uint8_t* dict_word = &dict->words->data[
-      dict->words->offsets_by_length[len] + (uint32_t)len * word_idx];
-  *size = (size_t)BrotliTransformDictionaryWord(buffer, dict_word, len,
-      transforms, transform);
-}
-
-static DictWord MakeDictWord(uint8_t len, uint8_t transform, uint16_t idx) {
-  DictWord result;
-  result.len = len;
-  result.transform = transform;
-  result.idx = idx;
-  return result;
-}
-
-static uint32_t BrotliTrieAlloc(MemoryManager* m, size_t num, BrotliTrie* trie,
-                                BrotliTrieNode** keep) {
-  uint32_t result;
-  uint32_t keep_index = 0;
-  if (keep && *keep != &trie->root) {
-    /* Optional node to keep, since address may change after re-allocating */
-    keep_index = (uint32_t)(*keep - trie->pool);
-  }
-  if (trie->pool_size == 0) {
-    /* Have a dummy node in the front. We do not want the result to be 0, it
-    must be at least 1, 0 represents "null pointer" */
-    trie->pool_size = 1;
-  }
-  BROTLI_ENSURE_CAPACITY(m, BrotliTrieNode, trie->pool, trie->pool_capacity,
-                         trie->pool_size + num);
-  if (BROTLI_IS_OOM(m)) return 0;
-  /* Init the new nodes to empty */
-  memset(trie->pool + trie->pool_size, 0, sizeof(*trie->pool) * num);
-  result = (uint32_t)trie->pool_size;
-  trie->pool_size += num;
-  if (keep && *keep != &trie->root) {
-    *keep = trie->pool + keep_index;
-  }
-  return result;
-}
-
-/**
- * len and idx: payload for last node
- * word, size: the string
- * index: position in the string
- */
-static BROTLI_BOOL BrotliTrieNodeAdd(MemoryManager* m, uint8_t len,
-    uint32_t idx, const uint8_t* word, size_t size, int index,
-    BrotliTrieNode* node, BrotliTrie* trie) {
-  BrotliTrieNode* child = 0;
-  uint8_t c;
-  if ((size_t)index == size) {
-    if (!node->len_ || idx < node->idx_) {
-      node->len_ = len;
-      node->idx_ = idx;
-    }
-    return BROTLI_TRUE;
-  }
-  c = word[index];
-  if (node->single && c != node->c) {
-    BrotliTrieNode old = trie->pool[node->sub];
-    uint32_t new_nodes = BrotliTrieAlloc(m, 32, trie, &node);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    node->single = 0;
-    node->sub = new_nodes;
-    trie->pool[node->sub + (node->c >> 4)].sub = new_nodes + 16;
-    trie->pool[trie->pool[node->sub + (node->c >> 4)].sub + (node->c & 15)] =
-        old;
-  }
-  if (!node->sub) {
-    uint32_t new_node = BrotliTrieAlloc(m, 1, trie, &node);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    node->single = 1;
-    node->c = c;
-    node->sub = new_node;
-  }
-  if (node->single) {
-    child = &trie->pool[node->sub];
-  } else {
-    if (!trie->pool[node->sub + (c >> 4)].sub) {
-      uint32_t new_nodes = BrotliTrieAlloc(m, 16, trie, &node);
-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-      trie->pool[node->sub + (c >> 4)].sub = new_nodes;
-    }
-    child = &trie->pool[trie->pool[node->sub + (c >> 4)].sub + (c & 15)];
-  }
-  return BrotliTrieNodeAdd(m, len, idx, word, size, index + 1, child, trie);
-}
-
-static BROTLI_BOOL BrotliTrieAdd(MemoryManager* m, uint8_t len, uint32_t idx,
-                          const uint8_t* word, size_t size, BrotliTrie* trie) {
-  return BrotliTrieNodeAdd(m, len, idx, word, size, 0, &trie->root, trie);
-}
-
-const BrotliTrieNode* BrotliTrieSub(const BrotliTrie* trie,
-                                    const BrotliTrieNode* node, uint8_t c) {
-  BrotliTrieNode* temp_node;
-  if (node->single) {
-    if (node->c == c) return &trie->pool[node->sub];
-    return 0;
-  }
-  if (!node->sub) return 0;
-  temp_node = &trie->pool[node->sub + (c >> 4)];
-  if (!temp_node->sub) return 0;
-  return &trie->pool[temp_node->sub + (c & 15)];
-}
-
-static const BrotliTrieNode* BrotliTrieFind(const BrotliTrie* trie,
-                                            const uint8_t* word, size_t size) {
-  const BrotliTrieNode* node = &trie->root;
-  size_t i;
-  for (i = 0; i < size; i++) {
-    node = BrotliTrieSub(trie, node, word[i]);
-    if (!node) return 0;
-  }
-  return node;
-}
-
-static BROTLI_BOOL BuildDictionaryLut(MemoryManager* m,
-    const BrotliTransforms* transforms,
-    BrotliEncoderDictionary* dict) {
-  uint32_t i;
-  DictWord* dict_words;
-  uint16_t* buckets;
-  DictWord** words_by_hash;
-  size_t* words_by_hash_size;
-  size_t* words_by_hash_capacity;
-  BrotliTrie dedup;
-  uint8_t word[kTransformedBufferSize];
-  size_t word_size;
-  size_t total = 0;
-  uint8_t l;
-  uint16_t idx;
-
-  BrotliTrieInit(&dedup);
-
-  words_by_hash = (DictWord**)BrotliAllocate(m,
-      sizeof(*words_by_hash) * NUM_HASH_BUCKETS);
-  words_by_hash_size = (size_t*)BrotliAllocate(m,
-      sizeof(*words_by_hash_size) * NUM_HASH_BUCKETS);
-  words_by_hash_capacity = (size_t*)BrotliAllocate(m,
-      sizeof(*words_by_hash_capacity) * NUM_HASH_BUCKETS);
-  if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  memset(words_by_hash, 0, sizeof(*words_by_hash) * NUM_HASH_BUCKETS);
-  memset(words_by_hash_size, 0, sizeof(*words_by_hash_size) * NUM_HASH_BUCKETS);
-  memset(words_by_hash_capacity, 0,
-         sizeof(*words_by_hash_capacity) * NUM_HASH_BUCKETS);
-
-  if (transforms->num_transforms > 0) {
-    for (l = SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH;
-        l <= SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH; ++l) {
-      uint16_t n = dict->words->size_bits_by_length[l] ?
-          (uint16_t)(1 << dict->words->size_bits_by_length[l]) : 0u;
-      for (idx = 0; idx < n; ++idx) {
-        uint32_t key;
-        /* First transform (usually identity) */
-        TransformedDictionaryWord(idx, l, 0, transforms, dict, word,
-                                  &word_size);
-        /* Cannot hash words smaller than 4 bytes */
-        if (word_size < 4) {
-          /* Break instead of continue, all next words of this length will have
-             same length after transform */
-          break;
-        }
-        if (!BrotliTrieAdd(m, 0, idx, word, word_size, &dedup)) {
-          return BROTLI_FALSE;
-        }
-        key = Hash(word, NUM_HASH_BITS);
-        BROTLI_ENSURE_CAPACITY_APPEND(m, DictWord, words_by_hash[key],
-            words_by_hash_capacity[key], words_by_hash_size[key],
-            MakeDictWord(l, 0, idx));
-        ++total;
-      }
-    }
-  }
-
-  /* These LUT transforms only supported if no custom transforms. This is
-     ok, we will use the heavy trie instead. */
-  if (transforms == BrotliGetTransforms()) {
-    for (l = SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH;
-        l <= SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH; ++l) {
-      uint16_t n = dict->words->size_bits_by_length[l] ?
-          (uint16_t)(1 << dict->words->size_bits_by_length[l]) : 0u;
-      for (idx = 0; idx < n; ++idx) {
-        int k;
-        BROTLI_BOOL is_ascii = BROTLI_TRUE;
-        size_t offset = dict->words->offsets_by_length[l] + (size_t)l * idx;
-        const uint8_t* data = &dict->words->data[offset];
-        for (k = 0; k < l; ++k) {
-          if (data[k] >= 128) is_ascii = BROTLI_FALSE;
-        }
-        if (data[0] < 128) {
-          int transform = 9;  /* {empty, uppercase first, empty} */
-          uint32_t ix = idx + (uint32_t)transform * n;
-          const BrotliTrieNode* it;
-          TransformedDictionaryWord(idx, l, transform, transforms,
-                                   dict, word, &word_size);
-          it = BrotliTrieFind(&dedup, word, word_size);
-          if (!it || it->idx_ > ix) {
-            uint32_t key = Hash(word, NUM_HASH_BITS);
-            if (!BrotliTrieAdd(m, 0, ix, word, word_size, &dedup)) {
-              return BROTLI_FALSE;
-            }
-            BROTLI_ENSURE_CAPACITY_APPEND(m, DictWord, words_by_hash[key],
-                words_by_hash_capacity[key], words_by_hash_size[key],
-                MakeDictWord(l, BROTLI_TRANSFORM_UPPERCASE_FIRST, idx));
-            ++total;
-          }
-        }
-        if (is_ascii) {
-          int transform = 44;  /* {empty, uppercase all, empty} */
-          uint32_t ix = idx + (uint32_t)transform * n;
-          const BrotliTrieNode* it;
-          TransformedDictionaryWord(idx, l, transform, transforms,
-                                    dict, word, &word_size);
-          it = BrotliTrieFind(&dedup, word, word_size);
-          if (!it || it->idx_ > ix) {
-            uint32_t key = Hash(word, NUM_HASH_BITS);
-            if (!BrotliTrieAdd(m, 0, ix, word, word_size, &dedup)) {
-              return BROTLI_FALSE;
-            }
-            BROTLI_ENSURE_CAPACITY_APPEND(m, DictWord, words_by_hash[key],
-                words_by_hash_capacity[key], words_by_hash_size[key],
-                MakeDictWord(l, BROTLI_TRANSFORM_UPPERCASE_ALL, idx));
-            ++total;
-          }
-        }
-      }
-    }
-  }
-
-  dict_words = (DictWord*)BrotliAllocate(m,
-      sizeof(*dict->dict_words) * (total + 1));
-  buckets = (uint16_t*)BrotliAllocate(m,
-      sizeof(*dict->buckets) * NUM_HASH_BUCKETS);
-  if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  dict->dict_words_alloc_size_ = total + 1;
-  dict->dict_words = dict->dict_words_data_ = dict_words;
-  dict->buckets_alloc_size_ = NUM_HASH_BUCKETS;
-  dict->buckets = dict->buckets_data_ = buckets;
-
-  /* Unused; makes offsets start from 1. */
-  dict_words[0] = MakeDictWord(0, 0, 0);
-  total = 1;
-  for (i = 0; i < NUM_HASH_BUCKETS; ++i) {
-    size_t num_words = words_by_hash_size[i];
-    if (num_words > 0) {
-      buckets[i] = (uint16_t)(total);
-      memcpy(&dict_words[total], &words_by_hash[i][0],
-          sizeof(dict_words[0]) * num_words);
-      total += num_words;
-      dict_words[total - 1].len |= 0x80;
-    } else {
-      buckets[i] = 0;
-    }
-  }
-
-  for (i = 0; i < NUM_HASH_BUCKETS; ++i) {
-    BrotliFree(m, words_by_hash[i]);
-  }
-  BrotliFree(m, words_by_hash);
-  BrotliFree(m, words_by_hash_size);
-  BrotliFree(m, words_by_hash_capacity);
-  BrotliTrieFree(m, &dedup);
-
-  return BROTLI_TRUE;
-}
-
-static void BuildDictionaryHashTable(uint16_t* hash_table_words,
-    uint8_t* hash_table_lengths, const BrotliDictionary* dict) {
-  int j, len;
-  /* The order of the loops is such that in case of collision, words with
-     shorter length are preferred, and in case of same length, words with
-     smaller index. There is only a single word per bucket. */
-  /* TODO(lode): consider adding optional user-supplied frequency_map to use
-     for preferred words instead, this can make the encoder better for
-     quality 9 and below without affecting the decoder */
-  memset(hash_table_words, 0, sizeof(kStaticDictionaryHashWords));
-  memset(hash_table_lengths, 0, sizeof(kStaticDictionaryHashLengths));
-  for (len = SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH;
-      len >= SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH; --len) {
-    const size_t num_words = dict->size_bits_by_length[len] ?
-        (1u << dict->size_bits_by_length[len]) : 0;
-    for (j = (int)num_words - 1; j >= 0; --j) {
-      size_t offset = dict->offsets_by_length[len] +
-          (size_t)len * (size_t)j;
-      const uint8_t* word = &dict->data[offset];
-      const uint32_t key = Hash(word, 14);
-      int idx = (int)(key << 1) + (len < 8 ? 1 : 0);
-      BROTLI_DCHECK(idx < (int)NUM_HASH_BUCKETS);
-      hash_table_words[idx] = (uint16_t)j;
-      hash_table_lengths[idx] = (uint8_t)len;
-    }
-  }
-}
-
-static BROTLI_BOOL GenerateWordsHeavy(MemoryManager* m,
-    const BrotliTransforms* transforms,
-    BrotliEncoderDictionary* dict) {
-  int i, j, l;
-  for (j = (int)transforms->num_transforms - 1; j >= 0 ; --j) {
-    for (l = 0; l < 32; l++) {
-      int num = (int)((1u << dict->words->size_bits_by_length[l]) & ~1u);
-      for (i = 0; i < num; i++) {
-        uint8_t transformed[kTransformedBufferSize];
-        size_t size;
-        TransformedDictionaryWord(
-            (uint32_t)i, l, j, transforms, dict, transformed, &size);
-        if (size < 4) continue;
-        if (!BrotliTrieAdd(m, (uint8_t)l, (uint32_t)(i + num * j),
-            transformed, size, &dict->trie)) {
-          return BROTLI_FALSE;
-        }
-      }
-    }
-  }
-  return BROTLI_TRUE;
-}
-
-/* Computes cutoffTransformsCount (in count) and cutoffTransforms (in data) for
-   the custom transforms, where possible within the limits of the
-   cutoffTransforms encoding. The fast encoder uses this to do fast lookup for
-   transforms that remove the N last characters (OmitLast). */
-static void ComputeCutoffTransforms(
-    const BrotliTransforms* transforms,
-    uint32_t* count, uint64_t* data) {
-  int i;
-  /* The encoding in a 64-bit integer of transform N in the data is: (N << 2) +
-     ((cutoffTransforms >> (N * 6)) & 0x3F), so for example the identity
-     transform code must be 0-63, for N=1 the transform code must be 4-67, ...,
-     for N=9 it must be 36-99.
-     TODO(lode): consider a simple flexible uint8_t[10] instead of the uint64_t
-     for the cutoff transforms, so that shared dictionaries can have the
-     OmitLast transforms anywhere without loss. */
-  *count = 0;
-  *data = 0;
-  for (i = 0; i < BROTLI_TRANSFORMS_MAX_CUT_OFF + 1; i++) {
-    int idx = transforms->cutOffTransforms[i];
-    if (idx == -1) break;  /* Not found */
-    if (idx < (i << 2)) break;  /* Too small for the encoding */
-    if (idx >= (i << 2) + 64) break;  /* Too large for the encoding */
-    (*count)++;
-    *data |= (uint64_t)(((uint64_t)idx -
-        ((uint64_t)i << 2u)) << ((uint64_t)i * 6u));
-  }
-}
-
-static BROTLI_BOOL ComputeDictionary(MemoryManager* m, int quality,
-    const BrotliTransforms* transforms,
-    BrotliEncoderDictionary* current) {
-  int default_words = current->words == BrotliGetDictionary();
-  int default_transforms = transforms == BrotliGetTransforms();
-
-  if (default_words && default_transforms) {
-    /* hashes are already set to Brotli defaults */
-    return BROTLI_TRUE;
-  }
-
-  current->hash_table_data_words_ = (uint16_t*)BrotliAllocate(
-      m, sizeof(kStaticDictionaryHashWords));
-  current->hash_table_data_lengths_ = (uint8_t*)BrotliAllocate(
-      m, sizeof(kStaticDictionaryHashLengths));
-  if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-  current->hash_table_words = current->hash_table_data_words_;
-  current->hash_table_lengths = current->hash_table_data_lengths_;
-
-  BuildDictionaryHashTable(current->hash_table_data_words_,
-      current->hash_table_data_lengths_, current->words);
-
-  ComputeCutoffTransforms(transforms,
-      &current->cutoffTransformsCount, &current->cutoffTransforms);
-
-  /* Only compute the data for slow encoder if the requested quality is high
-     enough to need it */
-  if (quality >= ZOPFLIFICATION_QUALITY) {
-    if (!BuildDictionaryLut(m, transforms, current)) return BROTLI_FALSE;
-
-    /* For the built-in Brotli transforms, there is a hard-coded function to
-       handle all transforms, but for custom transforms, we use the following
-       large hammer instead */
-    current->has_words_heavy = !default_transforms;
-    if (current->has_words_heavy) {
-      if (!GenerateWordsHeavy(m, transforms, current)) return BROTLI_FALSE;
-    }
-  }
-
-  return BROTLI_TRUE;
-}
-#endif  /* BROTLI_EXPERIMENTAL */
-
-void duckdb_brotli::BrotliInitSharedEncoderDictionary(SharedEncoderDictionary* dict) {
-  dict->magic = kSharedDictionaryMagic;
-
-  dict->compound.num_chunks = 0;
-  dict->compound.total_size = 0;
-  dict->compound.chunk_offsets[0] = 0;
-  dict->compound.num_prepared_instances_ = 0;
-
-  dict->contextual.context_based = 0;
-  dict->contextual.num_dictionaries = 1;
-  dict->contextual.instances_ = 0;
-  dict->contextual.num_instances_ = 1;  /* The instance_ field */
-  dict->contextual.dict[0] = &dict->contextual.instance_;
-  InitEncoderDictionary(&dict->contextual.instance_);
-  dict->contextual.instance_.parent = &dict->contextual;
-
-  dict->max_quality = BROTLI_MAX_QUALITY;
-}
-
-#if defined(BROTLI_EXPERIMENTAL)
-/* TODO(eustas): make sure that tooling will warn user if not all the cutoff
-   transforms are available (for low-quality encoder). */
-static BROTLI_BOOL InitCustomSharedEncoderDictionary(
-    MemoryManager* m, const BrotliSharedDictionary* decoded_dict,
-    int quality, SharedEncoderDictionary* dict) {
-  ContextualEncoderDictionary* contextual;
-  CompoundDictionary* compound;
-  BrotliEncoderDictionary* instances;
-  int i;
-  BrotliInitSharedEncoderDictionary(dict);
-
-  contextual = &dict->contextual;
-  compound = &dict->compound;
-
-  for (i = 0; i < (int)decoded_dict->num_prefix; i++) {
-    PreparedDictionary* prepared = CreatePreparedDictionary(m,
-        decoded_dict->prefix[i], decoded_dict->prefix_size[i]);
-    AttachPreparedDictionary(compound, prepared);
-    /* remember for cleanup */
-    compound->prepared_instances_[
-        compound->num_prepared_instances_++] = prepared;
-  }
-
-  dict->max_quality = quality;
-  contextual->context_based = decoded_dict->context_based;
-  if (decoded_dict->context_based) {
-    memcpy(contextual->context_map, decoded_dict->context_map,
-        SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS);
-  }
-
-  contextual->num_dictionaries = decoded_dict->num_dictionaries;
-  contextual->num_instances_ = decoded_dict->num_dictionaries;
-  if (contextual->num_instances_ == 1) {
-    instances = &contextual->instance_;
-  } else {
-    contextual->instances_ = (BrotliEncoderDictionary*)
-        BrotliAllocate(m, sizeof(*contextual->instances_) *
-        contextual->num_instances_);
-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-    instances = contextual->instances_;
-  }
-  for (i = 0; i < (int)contextual->num_instances_; i++) {
-    BrotliEncoderDictionary* current = &instances[i];
-    InitEncoderDictionary(current);
-    current->parent = &dict->contextual;
-    if (decoded_dict->words[i] == BrotliGetDictionary()) {
-      current->words = BrotliGetDictionary();
-    } else {
-      current->words_instance_ = (BrotliDictionary*)BrotliAllocate(
-          m, sizeof(BrotliDictionary));
-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
-      *current->words_instance_ = *decoded_dict->words[i];
-      current->words = current->words_instance_;
-    }
-    current->num_transforms =
-        (uint32_t)decoded_dict->transforms[i]->num_transforms;
-    if (!ComputeDictionary(
-        m, quality, decoded_dict->transforms[i], current)) {
-      return BROTLI_FALSE;
-    }
-
-    contextual->dict[i] = current;
-  }
-
-  return BROTLI_TRUE;  /* success */
-}
-
-BROTLI_BOOL BrotliInitCustomSharedEncoderDictionary(
-    MemoryManager* m, const uint8_t* encoded_dict, size_t size,
-    int quality, SharedEncoderDictionary* dict) {
-  BROTLI_BOOL success = BROTLI_FALSE;
-  BrotliSharedDictionary* decoded_dict = BrotliSharedDictionaryCreateInstance(
-      m->alloc_func, m->free_func, m->opaque);
-  if (!decoded_dict) {  /* OOM */
-    return BROTLI_FALSE;
-  }
-  success = BrotliSharedDictionaryAttach(
-      decoded_dict, BROTLI_SHARED_DICTIONARY_SERIALIZED, size, encoded_dict);
-  if (success) {
-    success = InitCustomSharedEncoderDictionary(m,
-        decoded_dict, quality, dict);
-  }
-  BrotliSharedDictionaryDestroyInstance(decoded_dict);
-  return success;
-}
-#endif  /* BROTLI_EXPERIMENTAL */
-
-void duckdb_brotli::BrotliCleanupSharedEncoderDictionary(MemoryManager* m,
-                                          SharedEncoderDictionary* dict) {
-  size_t i;
-  for (i = 0; i < dict->compound.num_prepared_instances_; i++) {
-    DestroyPreparedDictionary(m,
-        (PreparedDictionary*)dict->compound.prepared_instances_[i]);
-  }
-  if (dict->contextual.num_instances_ == 1) {
-    BrotliDestroyEncoderDictionary(m, &dict->contextual.instance_);
-  } else if (dict->contextual.num_instances_ > 1) {
-    for (i = 0; i < dict->contextual.num_instances_; i++) {
-      BrotliDestroyEncoderDictionary(m, &dict->contextual.instances_[i]);
-    }
-    BrotliFree(m, dict->contextual.instances_);
-  }
-}
-
-ManagedDictionary* duckdb_brotli::BrotliCreateManagedDictionary(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
-  ManagedDictionary* result = (ManagedDictionary*)BrotliBootstrapAlloc(
-      sizeof(ManagedDictionary), alloc_func, free_func, opaque);
-  if (result == NULL) return NULL;
-
-  result->magic = kManagedDictionaryMagic;
-  BrotliInitMemoryManager(
-      &result->memory_manager_, alloc_func, free_func, opaque);
-  result->dictionary = NULL;
-
-  return result;
-}
-
-void duckdb_brotli::BrotliDestroyManagedDictionary(ManagedDictionary* dictionary) {
-  if (!dictionary) return;
-  BrotliBootstrapFree(dictionary, &dictionary->memory_manager_);
-}
-
-/* Escalate internal functions visibility; for testing purposes only. */
-#if defined(BROTLI_TEST)
-void InitEncoderDictionaryForTest(BrotliEncoderDictionary*);
-void InitEncoderDictionaryForTest(BrotliEncoderDictionary* d) {
-  InitEncoderDictionary(d);
-}
-#endif
-
-
diff --git a/src/duckdb/third_party/brotli/enc/encoder_dict.h b/src/duckdb/third_party/brotli/enc/encoder_dict.h
deleted file mode 100644
index 99a82a6e6..000000000
--- a/src/duckdb/third_party/brotli/enc/encoder_dict.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#ifndef BROTLI_ENC_ENCODER_DICT_H_
-#define BROTLI_ENC_ENCODER_DICT_H_
-
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "compound_dictionary.h"
-#include "memory.h"
-#include "static_dict_lut.h"
-
-namespace duckdb_brotli {
-
-/*
-Dictionary hierarchy for Encoder:
--SharedEncoderDictionary
---CompoundDictionary
----PreparedDictionary [up to 15x]
-   = prefix dictionary with precomputed hashes
---ContextualEncoderDictionary
----BrotliEncoderDictionary [up to 64x]
-   = for each context, precomputed static dictionary with words + transforms
-
-Dictionary hiearchy from common: similar, but without precomputed hashes
--BrotliSharedDictionary
---BrotliDictionary [up to 64x]
---BrotliTransforms [up to 64x]
---const uint8_t* prefix [up to 15x]: compound dictionaries
-*/
-
-typedef struct BrotliTrieNode {
-  uint8_t single;  /* if 1, sub is a single node for c instead of 256 */
-  uint8_t c;
-  uint8_t len_;  /* untransformed length */
-  uint32_t idx_;  /* word index + num words * transform index */
-  uint32_t sub;  /* index of sub node(s) in the pool */
-} BrotliTrieNode;
-
-typedef struct BrotliTrie {
-  BrotliTrieNode* pool;
-  size_t pool_capacity;
-  size_t pool_size;
-  BrotliTrieNode root;
-} BrotliTrie;
-
-#if defined(BROTLI_EXPERIMENTAL)
-BROTLI_INTERNAL const BrotliTrieNode* BrotliTrieSub(const BrotliTrie* trie,
-    const BrotliTrieNode* node, uint8_t c);
-#endif  /* BROTLI_EXPERIMENTAL */
-
-/* Dictionary data (words and transforms) for 1 possible context */
-typedef struct BrotliEncoderDictionary {
-  const BrotliDictionary* words;
-  uint32_t num_transforms;
-
-  /* cut off for fast encoder */
-  uint32_t cutoffTransformsCount;
-  uint64_t cutoffTransforms;
-
-  /* from dictionary_hash.h, for fast encoder */
-  const uint16_t* hash_table_words;
-  const uint8_t* hash_table_lengths;
-
-  /* from static_dict_lut.h, for slow encoder */
-  const uint16_t* buckets;
-  const DictWord* dict_words;
-  /* Heavy version, for use by slow encoder when there are custom transforms.
-     Contains every possible transformed dictionary word in a trie. It encodes
-     about as fast as the non-heavy encoder but consumes a lot of memory and
-     takes time to build. */
-  BrotliTrie trie;
-  BROTLI_BOOL has_words_heavy;
-
-  /* Reference to other dictionaries. */
-  const struct ContextualEncoderDictionary* parent;
-
-  /* Allocated memory, used only when not using the Brotli defaults */
-  uint16_t* hash_table_data_words_;
-  uint8_t* hash_table_data_lengths_;
-  size_t buckets_alloc_size_;
-  uint16_t* buckets_data_;
-  size_t dict_words_alloc_size_;
-  DictWord* dict_words_data_;
-  BrotliDictionary* words_instance_;
-} BrotliEncoderDictionary;
-
-/* Dictionary data for all 64 contexts */
-typedef struct ContextualEncoderDictionary {
-  BROTLI_BOOL context_based;
-  uint8_t num_dictionaries;
-  uint8_t context_map[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
-  const BrotliEncoderDictionary* dict[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
-
-  /* If num_instances_ is 1, instance_ is used, else dynamic allocation with
-     instances_ is used. */
-  size_t num_instances_;
-  BrotliEncoderDictionary instance_;
-  BrotliEncoderDictionary* instances_;
-} ContextualEncoderDictionary;
-
-typedef struct SharedEncoderDictionary {
-  /* Magic value to distinguish this struct from PreparedDictionary for
-     certain external usages. */
-  uint32_t magic;
-
-  /* LZ77 prefix, compound dictionary */
-  CompoundDictionary compound;
-
-  /* Custom static dictionary (optionally context-based) */
-  ContextualEncoderDictionary contextual;
-
-  /* The maximum quality the dictionary was computed for */
-  int max_quality;
-} SharedEncoderDictionary;
-
-typedef struct ManagedDictionary {
-  uint32_t magic;
-  MemoryManager memory_manager_;
-  uint32_t* dictionary;
-} ManagedDictionary;
-
-/* Initializes to the brotli built-in dictionary */
-BROTLI_INTERNAL void BrotliInitSharedEncoderDictionary(
-    SharedEncoderDictionary* dict);
-
-#if defined(BROTLI_EXPERIMENTAL)
-/* Initializes to shared dictionary that will be parsed from
-   encoded_dict. Requires that you keep the encoded_dict buffer
-   around, parts of data will point to it. */
-BROTLI_INTERNAL BROTLI_BOOL BrotliInitCustomSharedEncoderDictionary(
-    MemoryManager* m, const uint8_t* encoded_dict, size_t size,
-    int quality, SharedEncoderDictionary* dict);
-#endif  /* BROTLI_EXPERIMENTAL */
-
-BROTLI_INTERNAL void BrotliCleanupSharedEncoderDictionary(
-    MemoryManager* m, SharedEncoderDictionary* dict);
-
-BROTLI_INTERNAL ManagedDictionary* BrotliCreateManagedDictionary(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
-
-BROTLI_INTERNAL void BrotliDestroyManagedDictionary(
-    ManagedDictionary* dictionary);
-
-}
-
-#endif  /* BROTLI_ENC_ENCODER_DICT_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/entropy_encode.cpp b/src/duckdb/third_party/brotli/enc/entropy_encode.cpp
deleted file mode 100644
index e56f82046..000000000
--- a/src/duckdb/third_party/brotli/enc/entropy_encode.cpp
+++ /dev/null
@@ -1,500 +0,0 @@
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Entropy encoding (Huffman) utilities. */
-
-#include "entropy_encode.h"
-
-#include <string.h>  /* memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-
-using namespace duckdb_brotli;
-
-const size_t duckdb_brotli::kBrotliShellGaps[] = {132, 57, 23, 10, 4, 1};
-
-BROTLI_BOOL duckdb_brotli::BrotliSetDepth(
-    int p0, HuffmanTree* pool, uint8_t* depth, int max_depth) {
-  int stack[16];
-  int level = 0;
-  int p = p0;
-  BROTLI_DCHECK(max_depth <= 15);
-  stack[0] = -1;
-  while (BROTLI_TRUE) {
-    if (pool[p].index_left_ >= 0) {
-      level++;
-      if (level > max_depth) return BROTLI_FALSE;
-      stack[level] = pool[p].index_right_or_value_;
-      p = pool[p].index_left_;
-      continue;
-    } else {
-      depth[pool[p].index_right_or_value_] = (uint8_t)level;
-    }
-    while (level >= 0 && stack[level] == -1) level--;
-    if (level < 0) return BROTLI_TRUE;
-    p = stack[level];
-    stack[level] = -1;
-  }
-}
-
-/* Sort the root nodes, least popular first. */
-static BROTLI_INLINE BROTLI_BOOL SortHuffmanTree(
-    const HuffmanTree* v0, const HuffmanTree* v1) {
-  if (v0->total_count_ != v1->total_count_) {
-    return TO_BROTLI_BOOL(v0->total_count_ < v1->total_count_);
-  }
-  return TO_BROTLI_BOOL(v0->index_right_or_value_ > v1->index_right_or_value_);
-}
-
-/* This function will create a Huffman tree.
-
-   The catch here is that the tree cannot be arbitrarily deep.
-   Brotli specifies a maximum depth of 15 bits for "code trees"
-   and 7 bits for "code length code trees."
-
-   count_limit is the value that is to be faked as the minimum value
-   and this minimum value is raised until the tree matches the
-   maximum length requirement.
-
-   This algorithm is not of excellent performance for very long data blocks,
-   especially when population counts are longer than 2**tree_limit, but
-   we are not planning to use this with extremely long blocks.
-
-   See http://en.wikipedia.org/wiki/Huffman_coding */
-void duckdb_brotli::BrotliCreateHuffmanTree(const uint32_t* data,
-                             const size_t length,
-                             const int tree_limit,
-                             HuffmanTree* tree,
-                             uint8_t* depth) {
-  uint32_t count_limit;
-  HuffmanTree sentinel;
-  InitHuffmanTree(&sentinel, BROTLI_UINT32_MAX, -1, -1);
-  /* For block sizes below 64 kB, we never need to do a second iteration
-     of this loop. Probably all of our block sizes will be smaller than
-     that, so this loop is mostly of academic interest. If we actually
-     would need this, we would be better off with the Katajainen algorithm. */
-  for (count_limit = 1; ; count_limit *= 2) {
-    size_t n = 0;
-    size_t i;
-    size_t j;
-    size_t k;
-    for (i = length; i != 0;) {
-      --i;
-      if (data[i]) {
-        const uint32_t count = BROTLI_MAX(uint32_t, data[i], count_limit);
-        InitHuffmanTree(&tree[n++], count, -1, (int16_t)i);
-      }
-    }
-
-    if (n == 1) {
-      depth[tree[0].index_right_or_value_] = 1;  /* Only one element. */
-      break;
-    }
-
-    SortHuffmanTreeItems(tree, n, SortHuffmanTree);
-
-    /* The nodes are:
-       [0, n): the sorted leaf nodes that we start with.
-       [n]: we add a sentinel here.
-       [n + 1, 2n): new parent nodes are added here, starting from
-                    (n+1). These are naturally in ascending order.
-       [2n]: we add a sentinel at the end as well.
-       There will be (2n+1) elements at the end. */
-    tree[n] = sentinel;
-    tree[n + 1] = sentinel;
-
-    i = 0;      /* Points to the next leaf node. */
-    j = n + 1;  /* Points to the next non-leaf node. */
-    for (k = n - 1; k != 0; --k) {
-      size_t left, right;
-      if (tree[i].total_count_ <= tree[j].total_count_) {
-        left = i;
-        ++i;
-      } else {
-        left = j;
-        ++j;
-      }
-      if (tree[i].total_count_ <= tree[j].total_count_) {
-        right = i;
-        ++i;
-      } else {
-        right = j;
-        ++j;
-      }
-
-      {
-        /* The sentinel node becomes the parent node. */
-        size_t j_end = 2 * n - k;
-        tree[j_end].total_count_ =
-            tree[left].total_count_ + tree[right].total_count_;
-        tree[j_end].index_left_ = (int16_t)left;
-        tree[j_end].index_right_or_value_ = (int16_t)right;
-
-        /* Add back the last sentinel node. */
-        tree[j_end + 1] = sentinel;
-      }
-    }
-    if (BrotliSetDepth((int)(2 * n - 1), &tree[0], depth, tree_limit)) {
-      /* We need to pack the Huffman tree in tree_limit bits. If this was not
-         successful, add fake entities to the lowest values and retry. */
-      break;
-    }
-  }
-}
-
-static void Reverse(uint8_t* v, size_t start, size_t end) {
-  --end;
-  while (start < end) {
-    uint8_t tmp = v[start];
-    v[start] = v[end];
-    v[end] = tmp;
-    ++start;
-    --end;
-  }
-}
-
-static void BrotliWriteHuffmanTreeRepetitions(
-    const uint8_t previous_value,
-    const uint8_t value,
-    size_t repetitions,
-    size_t* tree_size,
-    uint8_t* tree,
-    uint8_t* extra_bits_data) {
-  BROTLI_DCHECK(repetitions > 0);
-  if (previous_value != value) {
-    tree[*tree_size] = value;
-    extra_bits_data[*tree_size] = 0;
-    ++(*tree_size);
-    --repetitions;
-  }
-  if (repetitions == 7) {
-    tree[*tree_size] = value;
-    extra_bits_data[*tree_size] = 0;
-    ++(*tree_size);
-    --repetitions;
-  }
-  if (repetitions < 3) {
-    size_t i;
-    for (i = 0; i < repetitions; ++i) {
-      tree[*tree_size] = value;
-      extra_bits_data[*tree_size] = 0;
-      ++(*tree_size);
-    }
-  } else {
-    size_t start = *tree_size;
-    repetitions -= 3;
-    while (BROTLI_TRUE) {
-      tree[*tree_size] = BROTLI_REPEAT_PREVIOUS_CODE_LENGTH;
-      extra_bits_data[*tree_size] = repetitions & 0x3;
-      ++(*tree_size);
-      repetitions >>= 2;
-      if (repetitions == 0) {
-        break;
-      }
-      --repetitions;
-    }
-    Reverse(tree, start, *tree_size);
-    Reverse(extra_bits_data, start, *tree_size);
-  }
-}
-
-static void BrotliWriteHuffmanTreeRepetitionsZeros(
-    size_t repetitions,
-    size_t* tree_size,
-    uint8_t* tree,
-    uint8_t* extra_bits_data) {
-  if (repetitions == 11) {
-    tree[*tree_size] = 0;
-    extra_bits_data[*tree_size] = 0;
-    ++(*tree_size);
-    --repetitions;
-  }
-  if (repetitions < 3) {
-    size_t i;
-    for (i = 0; i < repetitions; ++i) {
-      tree[*tree_size] = 0;
-      extra_bits_data[*tree_size] = 0;
-      ++(*tree_size);
-    }
-  } else {
-    size_t start = *tree_size;
-    repetitions -= 3;
-    while (BROTLI_TRUE) {
-      tree[*tree_size] = BROTLI_REPEAT_ZERO_CODE_LENGTH;
-      extra_bits_data[*tree_size] = repetitions & 0x7;
-      ++(*tree_size);
-      repetitions >>= 3;
-      if (repetitions == 0) {
-        break;
-      }
-      --repetitions;
-    }
-    Reverse(tree, start, *tree_size);
-    Reverse(extra_bits_data, start, *tree_size);
-  }
-}
-
-void duckdb_brotli::BrotliOptimizeHuffmanCountsForRle(size_t length, uint32_t* counts,
-                                       uint8_t* good_for_rle) {
-  size_t nonzero_count = 0;
-  size_t stride;
-  size_t limit;
-  size_t sum;
-  const size_t streak_limit = 1240;
-  /* Let's make the Huffman code more compatible with RLE encoding. */
-  size_t i;
-  for (i = 0; i < length; i++) {
-    if (counts[i]) {
-      ++nonzero_count;
-    }
-  }
-  if (nonzero_count < 16) {
-    return;
-  }
-  while (length != 0 && counts[length - 1] == 0) {
-    --length;
-  }
-  if (length == 0) {
-    return;  /* All zeros. */
-  }
-  /* Now counts[0..length - 1] does not have trailing zeros. */
-  {
-    size_t nonzeros = 0;
-    uint32_t smallest_nonzero = 1 << 30;
-    for (i = 0; i < length; ++i) {
-      if (counts[i] != 0) {
-        ++nonzeros;
-        if (smallest_nonzero > counts[i]) {
-          smallest_nonzero = counts[i];
-        }
-      }
-    }
-    if (nonzeros < 5) {
-      /* Small histogram will model it well. */
-      return;
-    }
-    if (smallest_nonzero < 4) {
-      size_t zeros = length - nonzeros;
-      if (zeros < 6) {
-        for (i = 1; i < length - 1; ++i) {
-          if (counts[i - 1] != 0 && counts[i] == 0 && counts[i + 1] != 0) {
-            counts[i] = 1;
-          }
-        }
-      }
-    }
-    if (nonzeros < 28) {
-      return;
-    }
-  }
-  /* 2) Let's mark all population counts that already can be encoded
-     with an RLE code. */
-  memset(good_for_rle, 0, length);
-  {
-    /* Let's not spoil any of the existing good RLE codes.
-       Mark any seq of 0's that is longer as 5 as a good_for_rle.
-       Mark any seq of non-0's that is longer as 7 as a good_for_rle. */
-    uint32_t symbol = counts[0];
-    size_t step = 0;
-    for (i = 0; i <= length; ++i) {
-      if (i == length || counts[i] != symbol) {
-        if ((symbol == 0 && step >= 5) ||
-            (symbol != 0 && step >= 7)) {
-          size_t k;
-          for (k = 0; k < step; ++k) {
-            good_for_rle[i - k - 1] = 1;
-          }
-        }
-        step = 1;
-        if (i != length) {
-          symbol = counts[i];
-        }
-      } else {
-        ++step;
-      }
-    }
-  }
-  /* 3) Let's replace those population counts that lead to more RLE codes.
-     Math here is in 24.8 fixed point representation. */
-  stride = 0;
-  limit = 256 * (counts[0] + counts[1] + counts[2]) / 3 + 420;
-  sum = 0;
-  for (i = 0; i <= length; ++i) {
-    if (i == length || good_for_rle[i] ||
-        (i != 0 && good_for_rle[i - 1]) ||
-        (256 * counts[i] - limit + streak_limit) >= 2 * streak_limit) {
-      if (stride >= 4 || (stride >= 3 && sum == 0)) {
-        size_t k;
-        /* The stride must end, collapse what we have, if we have enough (4). */
-        size_t count = (sum + stride / 2) / stride;
-        if (count == 0) {
-          count = 1;
-        }
-        if (sum == 0) {
-          /* Don't make an all zeros stride to be upgraded to ones. */
-          count = 0;
-        }
-        for (k = 0; k < stride; ++k) {
-          /* We don't want to change value at counts[i],
-             that is already belonging to the next stride. Thus - 1. */
-          counts[i - k - 1] = (uint32_t)count;
-        }
-      }
-      stride = 0;
-      sum = 0;
-      if (i < length - 2) {
-        /* All interesting strides have a count of at least 4, */
-        /* at least when non-zeros. */
-        limit = 256 * (counts[i] + counts[i + 1] + counts[i + 2]) / 3 + 420;
-      } else if (i < length) {
-        limit = 256 * counts[i];
-      } else {
-        limit = 0;
-      }
-    }
-    ++stride;
-    if (i != length) {
-      sum += counts[i];
-      if (stride >= 4) {
-        limit = (256 * sum + stride / 2) / stride;
-      }
-      if (stride == 4) {
-        limit += 120;
-      }
-    }
-  }
-}
-
-static void DecideOverRleUse(const uint8_t* depth, const size_t length,
-                             BROTLI_BOOL* use_rle_for_non_zero,
-                             BROTLI_BOOL* use_rle_for_zero) {
-  size_t total_reps_zero = 0;
-  size_t total_reps_non_zero = 0;
-  size_t count_reps_zero = 1;
-  size_t count_reps_non_zero = 1;
-  size_t i;
-  for (i = 0; i < length;) {
-    const uint8_t value = depth[i];
-    size_t reps = 1;
-    size_t k;
-    for (k = i + 1; k < length && depth[k] == value; ++k) {
-      ++reps;
-    }
-    if (reps >= 3 && value == 0) {
-      total_reps_zero += reps;
-      ++count_reps_zero;
-    }
-    if (reps >= 4 && value != 0) {
-      total_reps_non_zero += reps;
-      ++count_reps_non_zero;
-    }
-    i += reps;
-  }
-  *use_rle_for_non_zero =
-      TO_BROTLI_BOOL(total_reps_non_zero > count_reps_non_zero * 2);
-  *use_rle_for_zero = TO_BROTLI_BOOL(total_reps_zero > count_reps_zero * 2);
-}
-
-void duckdb_brotli::BrotliWriteHuffmanTree(const uint8_t* depth,
-                            size_t length,
-                            size_t* tree_size,
-                            uint8_t* tree,
-                            uint8_t* extra_bits_data) {
-  uint8_t previous_value = BROTLI_INITIAL_REPEATED_CODE_LENGTH;
-  size_t i;
-  BROTLI_BOOL use_rle_for_non_zero = BROTLI_FALSE;
-  BROTLI_BOOL use_rle_for_zero = BROTLI_FALSE;
-
-  /* Throw away trailing zeros. */
-  size_t new_length = length;
-  for (i = 0; i < length; ++i) {
-    if (depth[length - i - 1] == 0) {
-      --new_length;
-    } else {
-      break;
-    }
-  }
-
-  /* First gather statistics on if it is a good idea to do RLE. */
-  if (length > 50) {
-    /* Find RLE coding for longer codes.
-       Shorter codes seem not to benefit from RLE. */
-    DecideOverRleUse(depth, new_length,
-                     &use_rle_for_non_zero, &use_rle_for_zero);
-  }
-
-  /* Actual RLE coding. */
-  for (i = 0; i < new_length;) {
-    const uint8_t value = depth[i];
-    size_t reps = 1;
-    if ((value != 0 && use_rle_for_non_zero) ||
-        (value == 0 && use_rle_for_zero)) {
-      size_t k;
-      for (k = i + 1; k < new_length && depth[k] == value; ++k) {
-        ++reps;
-      }
-    }
-    if (value == 0) {
-      BrotliWriteHuffmanTreeRepetitionsZeros(
-          reps, tree_size, tree, extra_bits_data);
-    } else {
-      BrotliWriteHuffmanTreeRepetitions(previous_value,
-                                        value, reps, tree_size,
-                                        tree, extra_bits_data);
-      previous_value = value;
-    }
-    i += reps;
-  }
-}
-
-static uint16_t BrotliReverseBits(size_t num_bits, uint16_t bits) {
-  static const size_t kLut[16] = {  /* Pre-reversed 4-bit values. */
-    0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E,
-    0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F
-  };
-  size_t retval = kLut[bits & 0x0F];
-  size_t i;
-  for (i = 4; i < num_bits; i += 4) {
-    retval <<= 4;
-    bits = (uint16_t)(bits >> 4);
-    retval |= kLut[bits & 0x0F];
-  }
-  retval >>= ((0 - num_bits) & 0x03);
-  return (uint16_t)retval;
-}
-
-/* 0..15 are values for bits */
-#define MAX_HUFFMAN_BITS 16
-
-void duckdb_brotli::BrotliConvertBitDepthsToSymbols(const uint8_t* depth,
-                                     size_t len,
-                                     uint16_t* bits) {
-  /* In Brotli, all bit depths are [1..15]
-     0 bit depth means that the symbol does not exist. */
-  uint16_t bl_count[MAX_HUFFMAN_BITS] = { 0 };
-  uint16_t next_code[MAX_HUFFMAN_BITS];
-  size_t i;
-  int code = 0;
-  for (i = 0; i < len; ++i) {
-    ++bl_count[depth[i]];
-  }
-  bl_count[0] = 0;
-  next_code[0] = 0;
-  for (i = 1; i < MAX_HUFFMAN_BITS; ++i) {
-    code = (code + bl_count[i - 1]) << 1;
-    next_code[i] = (uint16_t)code;
-  }
-  for (i = 0; i < len; ++i) {
-    if (depth[i]) {
-      bits[i] = BrotliReverseBits(depth[i], next_code[depth[i]]++);
-    }
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/entropy_encode.h b/src/duckdb/third_party/brotli/enc/entropy_encode.h
deleted file mode 100644
index ade29d513..000000000
--- a/src/duckdb/third_party/brotli/enc/entropy_encode.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Entropy encoding (Huffman) utilities. */
-
-#ifndef BROTLI_ENC_ENTROPY_ENCODE_H_
-#define BROTLI_ENC_ENTROPY_ENCODE_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-/* A node of a Huffman tree. */
-typedef struct HuffmanTree {
-  uint32_t total_count_;
-  int16_t index_left_;
-  int16_t index_right_or_value_;
-} HuffmanTree;
-
-static BROTLI_INLINE void InitHuffmanTree(HuffmanTree* self, uint32_t count,
-    int16_t left, int16_t right) {
-  self->total_count_ = count;
-  self->index_left_ = left;
-  self->index_right_or_value_ = right;
-}
-
-/* Returns 1 is assignment of depths succeeded, otherwise 0. */
-BROTLI_INTERNAL BROTLI_BOOL BrotliSetDepth(
-    int p, HuffmanTree* pool, uint8_t* depth, int max_depth);
-
-/* This function will create a Huffman tree.
-
-   The (data,length) contains the population counts.
-   The tree_limit is the maximum bit depth of the Huffman codes.
-
-   The depth contains the tree, i.e., how many bits are used for
-   the symbol.
-
-   The actual Huffman tree is constructed in the tree[] array, which has to
-   be at least 2 * length + 1 long.
-
-   See http://en.wikipedia.org/wiki/Huffman_coding */
-BROTLI_INTERNAL void BrotliCreateHuffmanTree(const uint32_t* data,
-                                             const size_t length,
-                                             const int tree_limit,
-                                             HuffmanTree* tree,
-                                             uint8_t* depth);
-
-/* Change the population counts in a way that the consequent
-   Huffman tree compression, especially its RLE-part will be more
-   likely to compress this data more efficiently.
-
-   length contains the size of the histogram.
-   counts contains the population counts.
-   good_for_rle is a buffer of at least length size */
-BROTLI_INTERNAL void BrotliOptimizeHuffmanCountsForRle(
-    size_t length, uint32_t* counts, uint8_t* good_for_rle);
-
-/* Write a Huffman tree from bit depths into the bit-stream representation
-   of a Huffman tree. The generated Huffman tree is to be compressed once
-   more using a Huffman tree */
-BROTLI_INTERNAL void BrotliWriteHuffmanTree(const uint8_t* depth,
-                                            size_t num,
-                                            size_t* tree_size,
-                                            uint8_t* tree,
-                                            uint8_t* extra_bits_data);
-
-/* Get the actual bit values for a tree of bit depths. */
-BROTLI_INTERNAL void BrotliConvertBitDepthsToSymbols(const uint8_t* depth,
-                                                     size_t len,
-                                                     uint16_t* bits);
-
-BROTLI_INTERNAL extern const size_t kBrotliShellGaps[6];
-/* Input size optimized Shell sort. */
-typedef BROTLI_BOOL (*HuffmanTreeComparator)(
-    const HuffmanTree*, const HuffmanTree*);
-static BROTLI_INLINE void SortHuffmanTreeItems(HuffmanTree* items,
-    const size_t n, HuffmanTreeComparator comparator) {
-  if (n < 13) {
-    /* Insertion sort. */
-    size_t i;
-    for (i = 1; i < n; ++i) {
-      HuffmanTree tmp = items[i];
-      size_t k = i;
-      size_t j = i - 1;
-      while (comparator(&tmp, &items[j])) {
-        items[k] = items[j];
-        k = j;
-        if (!j--) break;
-      }
-      items[k] = tmp;
-    }
-    return;
-  } else {
-    /* Shell sort. */
-    int g = n < 57 ? 2 : 0;
-    for (; g < 6; ++g) {
-      size_t gap = kBrotliShellGaps[g];
-      size_t i;
-      for (i = gap; i < n; ++i) {
-        size_t j = i;
-        HuffmanTree tmp = items[i];
-        for (; j >= gap && comparator(&tmp, &items[j - gap]); j -= gap) {
-          items[j] = items[j - gap];
-        }
-        items[j] = tmp;
-      }
-    }
-  }
-}
-
-}
-
-#endif  /* BROTLI_ENC_ENTROPY_ENCODE_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/entropy_encode_static.h b/src/duckdb/third_party/brotli/enc/entropy_encode_static.h
deleted file mode 100644
index 860a37820..000000000
--- a/src/duckdb/third_party/brotli/enc/entropy_encode_static.h
+++ /dev/null
@@ -1,538 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Static entropy codes used for faster meta-block encoding. */
-
-#ifndef BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
-#define BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "write_bits.h"
-
-namespace duckdb_brotli {
-
-static const uint8_t kCodeLengthDepth[18] = {
-  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 0, 4, 4,
-};
-
-static const uint8_t kStaticCommandCodeDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-};
-
-static const uint8_t kStaticDistanceCodeDepth[64] = {
-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-};
-
-/* GENERATED CODE START */
-static const uint32_t kCodeLengthBits[18] = {
-  0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 15, 31, 0, 11, 7,
-};
-
-static BROTLI_INLINE void StoreStaticCodeLengthCode(
-    size_t* storage_ix, uint8_t* storage) {
-  BrotliWriteBits(
-      40, BROTLI_MAKE_UINT64_T(0x0000FFu, 0x55555554u), storage_ix, storage);
-}
-
-static const uint64_t kZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
-  0x00000000, 0x00000000, 0x00000000, 0x00000007, 0x00000017, 0x00000027,
-  0x00000037, 0x00000047, 0x00000057, 0x00000067, 0x00000077, 0x00000770,
-  0x00000b87, 0x00001387, 0x00001b87, 0x00002387, 0x00002b87, 0x00003387,
-  0x00003b87, 0x00000397, 0x00000b97, 0x00001397, 0x00001b97, 0x00002397,
-  0x00002b97, 0x00003397, 0x00003b97, 0x000003a7, 0x00000ba7, 0x000013a7,
-  0x00001ba7, 0x000023a7, 0x00002ba7, 0x000033a7, 0x00003ba7, 0x000003b7,
-  0x00000bb7, 0x000013b7, 0x00001bb7, 0x000023b7, 0x00002bb7, 0x000033b7,
-  0x00003bb7, 0x000003c7, 0x00000bc7, 0x000013c7, 0x00001bc7, 0x000023c7,
-  0x00002bc7, 0x000033c7, 0x00003bc7, 0x000003d7, 0x00000bd7, 0x000013d7,
-  0x00001bd7, 0x000023d7, 0x00002bd7, 0x000033d7, 0x00003bd7, 0x000003e7,
-  0x00000be7, 0x000013e7, 0x00001be7, 0x000023e7, 0x00002be7, 0x000033e7,
-  0x00003be7, 0x000003f7, 0x00000bf7, 0x000013f7, 0x00001bf7, 0x000023f7,
-  0x00002bf7, 0x000033f7, 0x00003bf7, 0x0001c387, 0x0005c387, 0x0009c387,
-  0x000dc387, 0x0011c387, 0x0015c387, 0x0019c387, 0x001dc387, 0x0001cb87,
-  0x0005cb87, 0x0009cb87, 0x000dcb87, 0x0011cb87, 0x0015cb87, 0x0019cb87,
-  0x001dcb87, 0x0001d387, 0x0005d387, 0x0009d387, 0x000dd387, 0x0011d387,
-  0x0015d387, 0x0019d387, 0x001dd387, 0x0001db87, 0x0005db87, 0x0009db87,
-  0x000ddb87, 0x0011db87, 0x0015db87, 0x0019db87, 0x001ddb87, 0x0001e387,
-  0x0005e387, 0x0009e387, 0x000de387, 0x0011e387, 0x0015e387, 0x0019e387,
-  0x001de387, 0x0001eb87, 0x0005eb87, 0x0009eb87, 0x000deb87, 0x0011eb87,
-  0x0015eb87, 0x0019eb87, 0x001deb87, 0x0001f387, 0x0005f387, 0x0009f387,
-  0x000df387, 0x0011f387, 0x0015f387, 0x0019f387, 0x001df387, 0x0001fb87,
-  0x0005fb87, 0x0009fb87, 0x000dfb87, 0x0011fb87, 0x0015fb87, 0x0019fb87,
-  0x001dfb87, 0x0001c397, 0x0005c397, 0x0009c397, 0x000dc397, 0x0011c397,
-  0x0015c397, 0x0019c397, 0x001dc397, 0x0001cb97, 0x0005cb97, 0x0009cb97,
-  0x000dcb97, 0x0011cb97, 0x0015cb97, 0x0019cb97, 0x001dcb97, 0x0001d397,
-  0x0005d397, 0x0009d397, 0x000dd397, 0x0011d397, 0x0015d397, 0x0019d397,
-  0x001dd397, 0x0001db97, 0x0005db97, 0x0009db97, 0x000ddb97, 0x0011db97,
-  0x0015db97, 0x0019db97, 0x001ddb97, 0x0001e397, 0x0005e397, 0x0009e397,
-  0x000de397, 0x0011e397, 0x0015e397, 0x0019e397, 0x001de397, 0x0001eb97,
-  0x0005eb97, 0x0009eb97, 0x000deb97, 0x0011eb97, 0x0015eb97, 0x0019eb97,
-  0x001deb97, 0x0001f397, 0x0005f397, 0x0009f397, 0x000df397, 0x0011f397,
-  0x0015f397, 0x0019f397, 0x001df397, 0x0001fb97, 0x0005fb97, 0x0009fb97,
-  0x000dfb97, 0x0011fb97, 0x0015fb97, 0x0019fb97, 0x001dfb97, 0x0001c3a7,
-  0x0005c3a7, 0x0009c3a7, 0x000dc3a7, 0x0011c3a7, 0x0015c3a7, 0x0019c3a7,
-  0x001dc3a7, 0x0001cba7, 0x0005cba7, 0x0009cba7, 0x000dcba7, 0x0011cba7,
-  0x0015cba7, 0x0019cba7, 0x001dcba7, 0x0001d3a7, 0x0005d3a7, 0x0009d3a7,
-  0x000dd3a7, 0x0011d3a7, 0x0015d3a7, 0x0019d3a7, 0x001dd3a7, 0x0001dba7,
-  0x0005dba7, 0x0009dba7, 0x000ddba7, 0x0011dba7, 0x0015dba7, 0x0019dba7,
-  0x001ddba7, 0x0001e3a7, 0x0005e3a7, 0x0009e3a7, 0x000de3a7, 0x0011e3a7,
-  0x0015e3a7, 0x0019e3a7, 0x001de3a7, 0x0001eba7, 0x0005eba7, 0x0009eba7,
-  0x000deba7, 0x0011eba7, 0x0015eba7, 0x0019eba7, 0x001deba7, 0x0001f3a7,
-  0x0005f3a7, 0x0009f3a7, 0x000df3a7, 0x0011f3a7, 0x0015f3a7, 0x0019f3a7,
-  0x001df3a7, 0x0001fba7, 0x0005fba7, 0x0009fba7, 0x000dfba7, 0x0011fba7,
-  0x0015fba7, 0x0019fba7, 0x001dfba7, 0x0001c3b7, 0x0005c3b7, 0x0009c3b7,
-  0x000dc3b7, 0x0011c3b7, 0x0015c3b7, 0x0019c3b7, 0x001dc3b7, 0x0001cbb7,
-  0x0005cbb7, 0x0009cbb7, 0x000dcbb7, 0x0011cbb7, 0x0015cbb7, 0x0019cbb7,
-  0x001dcbb7, 0x0001d3b7, 0x0005d3b7, 0x0009d3b7, 0x000dd3b7, 0x0011d3b7,
-  0x0015d3b7, 0x0019d3b7, 0x001dd3b7, 0x0001dbb7, 0x0005dbb7, 0x0009dbb7,
-  0x000ddbb7, 0x0011dbb7, 0x0015dbb7, 0x0019dbb7, 0x001ddbb7, 0x0001e3b7,
-  0x0005e3b7, 0x0009e3b7, 0x000de3b7, 0x0011e3b7, 0x0015e3b7, 0x0019e3b7,
-  0x001de3b7, 0x0001ebb7, 0x0005ebb7, 0x0009ebb7, 0x000debb7, 0x0011ebb7,
-  0x0015ebb7, 0x0019ebb7, 0x001debb7, 0x0001f3b7, 0x0005f3b7, 0x0009f3b7,
-  0x000df3b7, 0x0011f3b7, 0x0015f3b7, 0x0019f3b7, 0x001df3b7, 0x0001fbb7,
-  0x0005fbb7, 0x0009fbb7, 0x000dfbb7, 0x0011fbb7, 0x0015fbb7, 0x0019fbb7,
-  0x001dfbb7, 0x0001c3c7, 0x0005c3c7, 0x0009c3c7, 0x000dc3c7, 0x0011c3c7,
-  0x0015c3c7, 0x0019c3c7, 0x001dc3c7, 0x0001cbc7, 0x0005cbc7, 0x0009cbc7,
-  0x000dcbc7, 0x0011cbc7, 0x0015cbc7, 0x0019cbc7, 0x001dcbc7, 0x0001d3c7,
-  0x0005d3c7, 0x0009d3c7, 0x000dd3c7, 0x0011d3c7, 0x0015d3c7, 0x0019d3c7,
-  0x001dd3c7, 0x0001dbc7, 0x0005dbc7, 0x0009dbc7, 0x000ddbc7, 0x0011dbc7,
-  0x0015dbc7, 0x0019dbc7, 0x001ddbc7, 0x0001e3c7, 0x0005e3c7, 0x0009e3c7,
-  0x000de3c7, 0x0011e3c7, 0x0015e3c7, 0x0019e3c7, 0x001de3c7, 0x0001ebc7,
-  0x0005ebc7, 0x0009ebc7, 0x000debc7, 0x0011ebc7, 0x0015ebc7, 0x0019ebc7,
-  0x001debc7, 0x0001f3c7, 0x0005f3c7, 0x0009f3c7, 0x000df3c7, 0x0011f3c7,
-  0x0015f3c7, 0x0019f3c7, 0x001df3c7, 0x0001fbc7, 0x0005fbc7, 0x0009fbc7,
-  0x000dfbc7, 0x0011fbc7, 0x0015fbc7, 0x0019fbc7, 0x001dfbc7, 0x0001c3d7,
-  0x0005c3d7, 0x0009c3d7, 0x000dc3d7, 0x0011c3d7, 0x0015c3d7, 0x0019c3d7,
-  0x001dc3d7, 0x0001cbd7, 0x0005cbd7, 0x0009cbd7, 0x000dcbd7, 0x0011cbd7,
-  0x0015cbd7, 0x0019cbd7, 0x001dcbd7, 0x0001d3d7, 0x0005d3d7, 0x0009d3d7,
-  0x000dd3d7, 0x0011d3d7, 0x0015d3d7, 0x0019d3d7, 0x001dd3d7, 0x0001dbd7,
-  0x0005dbd7, 0x0009dbd7, 0x000ddbd7, 0x0011dbd7, 0x0015dbd7, 0x0019dbd7,
-  0x001ddbd7, 0x0001e3d7, 0x0005e3d7, 0x0009e3d7, 0x000de3d7, 0x0011e3d7,
-  0x0015e3d7, 0x0019e3d7, 0x001de3d7, 0x0001ebd7, 0x0005ebd7, 0x0009ebd7,
-  0x000debd7, 0x0011ebd7, 0x0015ebd7, 0x0019ebd7, 0x001debd7, 0x0001f3d7,
-  0x0005f3d7, 0x0009f3d7, 0x000df3d7, 0x0011f3d7, 0x0015f3d7, 0x0019f3d7,
-  0x001df3d7, 0x0001fbd7, 0x0005fbd7, 0x0009fbd7, 0x000dfbd7, 0x0011fbd7,
-  0x0015fbd7, 0x0019fbd7, 0x001dfbd7, 0x0001c3e7, 0x0005c3e7, 0x0009c3e7,
-  0x000dc3e7, 0x0011c3e7, 0x0015c3e7, 0x0019c3e7, 0x001dc3e7, 0x0001cbe7,
-  0x0005cbe7, 0x0009cbe7, 0x000dcbe7, 0x0011cbe7, 0x0015cbe7, 0x0019cbe7,
-  0x001dcbe7, 0x0001d3e7, 0x0005d3e7, 0x0009d3e7, 0x000dd3e7, 0x0011d3e7,
-  0x0015d3e7, 0x0019d3e7, 0x001dd3e7, 0x0001dbe7, 0x0005dbe7, 0x0009dbe7,
-  0x000ddbe7, 0x0011dbe7, 0x0015dbe7, 0x0019dbe7, 0x001ddbe7, 0x0001e3e7,
-  0x0005e3e7, 0x0009e3e7, 0x000de3e7, 0x0011e3e7, 0x0015e3e7, 0x0019e3e7,
-  0x001de3e7, 0x0001ebe7, 0x0005ebe7, 0x0009ebe7, 0x000debe7, 0x0011ebe7,
-  0x0015ebe7, 0x0019ebe7, 0x001debe7, 0x0001f3e7, 0x0005f3e7, 0x0009f3e7,
-  0x000df3e7, 0x0011f3e7, 0x0015f3e7, 0x0019f3e7, 0x001df3e7, 0x0001fbe7,
-  0x0005fbe7, 0x0009fbe7, 0x000dfbe7, 0x0011fbe7, 0x0015fbe7, 0x0019fbe7,
-  0x001dfbe7, 0x0001c3f7, 0x0005c3f7, 0x0009c3f7, 0x000dc3f7, 0x0011c3f7,
-  0x0015c3f7, 0x0019c3f7, 0x001dc3f7, 0x0001cbf7, 0x0005cbf7, 0x0009cbf7,
-  0x000dcbf7, 0x0011cbf7, 0x0015cbf7, 0x0019cbf7, 0x001dcbf7, 0x0001d3f7,
-  0x0005d3f7, 0x0009d3f7, 0x000dd3f7, 0x0011d3f7, 0x0015d3f7, 0x0019d3f7,
-  0x001dd3f7, 0x0001dbf7, 0x0005dbf7, 0x0009dbf7, 0x000ddbf7, 0x0011dbf7,
-  0x0015dbf7, 0x0019dbf7, 0x001ddbf7, 0x0001e3f7, 0x0005e3f7, 0x0009e3f7,
-  0x000de3f7, 0x0011e3f7, 0x0015e3f7, 0x0019e3f7, 0x001de3f7, 0x0001ebf7,
-  0x0005ebf7, 0x0009ebf7, 0x000debf7, 0x0011ebf7, 0x0015ebf7, 0x0019ebf7,
-  0x001debf7, 0x0001f3f7, 0x0005f3f7, 0x0009f3f7, 0x000df3f7, 0x0011f3f7,
-  0x0015f3f7, 0x0019f3f7, 0x001df3f7, 0x0001fbf7, 0x0005fbf7, 0x0009fbf7,
-  0x000dfbf7, 0x0011fbf7, 0x0015fbf7, 0x0019fbf7, 0x001dfbf7, 0x00e1c387,
-  0x02e1c387, 0x04e1c387, 0x06e1c387, 0x08e1c387, 0x0ae1c387, 0x0ce1c387,
-  0x0ee1c387, 0x00e5c387, 0x02e5c387, 0x04e5c387, 0x06e5c387, 0x08e5c387,
-  0x0ae5c387, 0x0ce5c387, 0x0ee5c387, 0x00e9c387, 0x02e9c387, 0x04e9c387,
-  0x06e9c387, 0x08e9c387, 0x0ae9c387, 0x0ce9c387, 0x0ee9c387, 0x00edc387,
-  0x02edc387, 0x04edc387, 0x06edc387, 0x08edc387, 0x0aedc387, 0x0cedc387,
-  0x0eedc387, 0x00f1c387, 0x02f1c387, 0x04f1c387, 0x06f1c387, 0x08f1c387,
-  0x0af1c387, 0x0cf1c387, 0x0ef1c387, 0x00f5c387, 0x02f5c387, 0x04f5c387,
-  0x06f5c387, 0x08f5c387, 0x0af5c387, 0x0cf5c387, 0x0ef5c387, 0x00f9c387,
-  0x02f9c387, 0x04f9c387, 0x06f9c387, 0x08f9c387, 0x0af9c387, 0x0cf9c387,
-  0x0ef9c387, 0x00fdc387, 0x02fdc387, 0x04fdc387, 0x06fdc387, 0x08fdc387,
-  0x0afdc387, 0x0cfdc387, 0x0efdc387, 0x00e1cb87, 0x02e1cb87, 0x04e1cb87,
-  0x06e1cb87, 0x08e1cb87, 0x0ae1cb87, 0x0ce1cb87, 0x0ee1cb87, 0x00e5cb87,
-  0x02e5cb87, 0x04e5cb87, 0x06e5cb87, 0x08e5cb87, 0x0ae5cb87, 0x0ce5cb87,
-  0x0ee5cb87, 0x00e9cb87, 0x02e9cb87, 0x04e9cb87, 0x06e9cb87, 0x08e9cb87,
-  0x0ae9cb87, 0x0ce9cb87, 0x0ee9cb87, 0x00edcb87, 0x02edcb87, 0x04edcb87,
-  0x06edcb87, 0x08edcb87, 0x0aedcb87, 0x0cedcb87, 0x0eedcb87, 0x00f1cb87,
-  0x02f1cb87, 0x04f1cb87, 0x06f1cb87, 0x08f1cb87, 0x0af1cb87, 0x0cf1cb87,
-  0x0ef1cb87, 0x00f5cb87, 0x02f5cb87, 0x04f5cb87, 0x06f5cb87, 0x08f5cb87,
-  0x0af5cb87, 0x0cf5cb87, 0x0ef5cb87, 0x00f9cb87, 0x02f9cb87, 0x04f9cb87,
-  0x06f9cb87, 0x08f9cb87,
-};
-
-static const uint32_t kZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
-   0,  4,  8,  7,  7,  7,  7,  7,  7,  7,  7, 11, 14, 14, 14, 14,
-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-};
-
-static const uint64_t kNonZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
-  0x0000000b, 0x0000001b, 0x0000002b, 0x0000003b, 0x000002cb, 0x000006cb,
-  0x00000acb, 0x00000ecb, 0x000002db, 0x000006db, 0x00000adb, 0x00000edb,
-  0x000002eb, 0x000006eb, 0x00000aeb, 0x00000eeb, 0x000002fb, 0x000006fb,
-  0x00000afb, 0x00000efb, 0x0000b2cb, 0x0001b2cb, 0x0002b2cb, 0x0003b2cb,
-  0x0000b6cb, 0x0001b6cb, 0x0002b6cb, 0x0003b6cb, 0x0000bacb, 0x0001bacb,
-  0x0002bacb, 0x0003bacb, 0x0000becb, 0x0001becb, 0x0002becb, 0x0003becb,
-  0x0000b2db, 0x0001b2db, 0x0002b2db, 0x0003b2db, 0x0000b6db, 0x0001b6db,
-  0x0002b6db, 0x0003b6db, 0x0000badb, 0x0001badb, 0x0002badb, 0x0003badb,
-  0x0000bedb, 0x0001bedb, 0x0002bedb, 0x0003bedb, 0x0000b2eb, 0x0001b2eb,
-  0x0002b2eb, 0x0003b2eb, 0x0000b6eb, 0x0001b6eb, 0x0002b6eb, 0x0003b6eb,
-  0x0000baeb, 0x0001baeb, 0x0002baeb, 0x0003baeb, 0x0000beeb, 0x0001beeb,
-  0x0002beeb, 0x0003beeb, 0x0000b2fb, 0x0001b2fb, 0x0002b2fb, 0x0003b2fb,
-  0x0000b6fb, 0x0001b6fb, 0x0002b6fb, 0x0003b6fb, 0x0000bafb, 0x0001bafb,
-  0x0002bafb, 0x0003bafb, 0x0000befb, 0x0001befb, 0x0002befb, 0x0003befb,
-  0x002cb2cb, 0x006cb2cb, 0x00acb2cb, 0x00ecb2cb, 0x002db2cb, 0x006db2cb,
-  0x00adb2cb, 0x00edb2cb, 0x002eb2cb, 0x006eb2cb, 0x00aeb2cb, 0x00eeb2cb,
-  0x002fb2cb, 0x006fb2cb, 0x00afb2cb, 0x00efb2cb, 0x002cb6cb, 0x006cb6cb,
-  0x00acb6cb, 0x00ecb6cb, 0x002db6cb, 0x006db6cb, 0x00adb6cb, 0x00edb6cb,
-  0x002eb6cb, 0x006eb6cb, 0x00aeb6cb, 0x00eeb6cb, 0x002fb6cb, 0x006fb6cb,
-  0x00afb6cb, 0x00efb6cb, 0x002cbacb, 0x006cbacb, 0x00acbacb, 0x00ecbacb,
-  0x002dbacb, 0x006dbacb, 0x00adbacb, 0x00edbacb, 0x002ebacb, 0x006ebacb,
-  0x00aebacb, 0x00eebacb, 0x002fbacb, 0x006fbacb, 0x00afbacb, 0x00efbacb,
-  0x002cbecb, 0x006cbecb, 0x00acbecb, 0x00ecbecb, 0x002dbecb, 0x006dbecb,
-  0x00adbecb, 0x00edbecb, 0x002ebecb, 0x006ebecb, 0x00aebecb, 0x00eebecb,
-  0x002fbecb, 0x006fbecb, 0x00afbecb, 0x00efbecb, 0x002cb2db, 0x006cb2db,
-  0x00acb2db, 0x00ecb2db, 0x002db2db, 0x006db2db, 0x00adb2db, 0x00edb2db,
-  0x002eb2db, 0x006eb2db, 0x00aeb2db, 0x00eeb2db, 0x002fb2db, 0x006fb2db,
-  0x00afb2db, 0x00efb2db, 0x002cb6db, 0x006cb6db, 0x00acb6db, 0x00ecb6db,
-  0x002db6db, 0x006db6db, 0x00adb6db, 0x00edb6db, 0x002eb6db, 0x006eb6db,
-  0x00aeb6db, 0x00eeb6db, 0x002fb6db, 0x006fb6db, 0x00afb6db, 0x00efb6db,
-  0x002cbadb, 0x006cbadb, 0x00acbadb, 0x00ecbadb, 0x002dbadb, 0x006dbadb,
-  0x00adbadb, 0x00edbadb, 0x002ebadb, 0x006ebadb, 0x00aebadb, 0x00eebadb,
-  0x002fbadb, 0x006fbadb, 0x00afbadb, 0x00efbadb, 0x002cbedb, 0x006cbedb,
-  0x00acbedb, 0x00ecbedb, 0x002dbedb, 0x006dbedb, 0x00adbedb, 0x00edbedb,
-  0x002ebedb, 0x006ebedb, 0x00aebedb, 0x00eebedb, 0x002fbedb, 0x006fbedb,
-  0x00afbedb, 0x00efbedb, 0x002cb2eb, 0x006cb2eb, 0x00acb2eb, 0x00ecb2eb,
-  0x002db2eb, 0x006db2eb, 0x00adb2eb, 0x00edb2eb, 0x002eb2eb, 0x006eb2eb,
-  0x00aeb2eb, 0x00eeb2eb, 0x002fb2eb, 0x006fb2eb, 0x00afb2eb, 0x00efb2eb,
-  0x002cb6eb, 0x006cb6eb, 0x00acb6eb, 0x00ecb6eb, 0x002db6eb, 0x006db6eb,
-  0x00adb6eb, 0x00edb6eb, 0x002eb6eb, 0x006eb6eb, 0x00aeb6eb, 0x00eeb6eb,
-  0x002fb6eb, 0x006fb6eb, 0x00afb6eb, 0x00efb6eb, 0x002cbaeb, 0x006cbaeb,
-  0x00acbaeb, 0x00ecbaeb, 0x002dbaeb, 0x006dbaeb, 0x00adbaeb, 0x00edbaeb,
-  0x002ebaeb, 0x006ebaeb, 0x00aebaeb, 0x00eebaeb, 0x002fbaeb, 0x006fbaeb,
-  0x00afbaeb, 0x00efbaeb, 0x002cbeeb, 0x006cbeeb, 0x00acbeeb, 0x00ecbeeb,
-  0x002dbeeb, 0x006dbeeb, 0x00adbeeb, 0x00edbeeb, 0x002ebeeb, 0x006ebeeb,
-  0x00aebeeb, 0x00eebeeb, 0x002fbeeb, 0x006fbeeb, 0x00afbeeb, 0x00efbeeb,
-  0x002cb2fb, 0x006cb2fb, 0x00acb2fb, 0x00ecb2fb, 0x002db2fb, 0x006db2fb,
-  0x00adb2fb, 0x00edb2fb, 0x002eb2fb, 0x006eb2fb, 0x00aeb2fb, 0x00eeb2fb,
-  0x002fb2fb, 0x006fb2fb, 0x00afb2fb, 0x00efb2fb, 0x002cb6fb, 0x006cb6fb,
-  0x00acb6fb, 0x00ecb6fb, 0x002db6fb, 0x006db6fb, 0x00adb6fb, 0x00edb6fb,
-  0x002eb6fb, 0x006eb6fb, 0x00aeb6fb, 0x00eeb6fb, 0x002fb6fb, 0x006fb6fb,
-  0x00afb6fb, 0x00efb6fb, 0x002cbafb, 0x006cbafb, 0x00acbafb, 0x00ecbafb,
-  0x002dbafb, 0x006dbafb, 0x00adbafb, 0x00edbafb, 0x002ebafb, 0x006ebafb,
-  0x00aebafb, 0x00eebafb, 0x002fbafb, 0x006fbafb, 0x00afbafb, 0x00efbafb,
-  0x002cbefb, 0x006cbefb, 0x00acbefb, 0x00ecbefb, 0x002dbefb, 0x006dbefb,
-  0x00adbefb, 0x00edbefb, 0x002ebefb, 0x006ebefb, 0x00aebefb, 0x00eebefb,
-  0x002fbefb, 0x006fbefb, 0x00afbefb, 0x00efbefb, 0x0b2cb2cb, 0x1b2cb2cb,
-  0x2b2cb2cb, 0x3b2cb2cb, 0x0b6cb2cb, 0x1b6cb2cb, 0x2b6cb2cb, 0x3b6cb2cb,
-  0x0bacb2cb, 0x1bacb2cb, 0x2bacb2cb, 0x3bacb2cb, 0x0becb2cb, 0x1becb2cb,
-  0x2becb2cb, 0x3becb2cb, 0x0b2db2cb, 0x1b2db2cb, 0x2b2db2cb, 0x3b2db2cb,
-  0x0b6db2cb, 0x1b6db2cb, 0x2b6db2cb, 0x3b6db2cb, 0x0badb2cb, 0x1badb2cb,
-  0x2badb2cb, 0x3badb2cb, 0x0bedb2cb, 0x1bedb2cb, 0x2bedb2cb, 0x3bedb2cb,
-  0x0b2eb2cb, 0x1b2eb2cb, 0x2b2eb2cb, 0x3b2eb2cb, 0x0b6eb2cb, 0x1b6eb2cb,
-  0x2b6eb2cb, 0x3b6eb2cb, 0x0baeb2cb, 0x1baeb2cb, 0x2baeb2cb, 0x3baeb2cb,
-  0x0beeb2cb, 0x1beeb2cb, 0x2beeb2cb, 0x3beeb2cb, 0x0b2fb2cb, 0x1b2fb2cb,
-  0x2b2fb2cb, 0x3b2fb2cb, 0x0b6fb2cb, 0x1b6fb2cb, 0x2b6fb2cb, 0x3b6fb2cb,
-  0x0bafb2cb, 0x1bafb2cb, 0x2bafb2cb, 0x3bafb2cb, 0x0befb2cb, 0x1befb2cb,
-  0x2befb2cb, 0x3befb2cb, 0x0b2cb6cb, 0x1b2cb6cb, 0x2b2cb6cb, 0x3b2cb6cb,
-  0x0b6cb6cb, 0x1b6cb6cb, 0x2b6cb6cb, 0x3b6cb6cb, 0x0bacb6cb, 0x1bacb6cb,
-  0x2bacb6cb, 0x3bacb6cb, 0x0becb6cb, 0x1becb6cb, 0x2becb6cb, 0x3becb6cb,
-  0x0b2db6cb, 0x1b2db6cb, 0x2b2db6cb, 0x3b2db6cb, 0x0b6db6cb, 0x1b6db6cb,
-  0x2b6db6cb, 0x3b6db6cb, 0x0badb6cb, 0x1badb6cb, 0x2badb6cb, 0x3badb6cb,
-  0x0bedb6cb, 0x1bedb6cb, 0x2bedb6cb, 0x3bedb6cb, 0x0b2eb6cb, 0x1b2eb6cb,
-  0x2b2eb6cb, 0x3b2eb6cb, 0x0b6eb6cb, 0x1b6eb6cb, 0x2b6eb6cb, 0x3b6eb6cb,
-  0x0baeb6cb, 0x1baeb6cb, 0x2baeb6cb, 0x3baeb6cb, 0x0beeb6cb, 0x1beeb6cb,
-  0x2beeb6cb, 0x3beeb6cb, 0x0b2fb6cb, 0x1b2fb6cb, 0x2b2fb6cb, 0x3b2fb6cb,
-  0x0b6fb6cb, 0x1b6fb6cb, 0x2b6fb6cb, 0x3b6fb6cb, 0x0bafb6cb, 0x1bafb6cb,
-  0x2bafb6cb, 0x3bafb6cb, 0x0befb6cb, 0x1befb6cb, 0x2befb6cb, 0x3befb6cb,
-  0x0b2cbacb, 0x1b2cbacb, 0x2b2cbacb, 0x3b2cbacb, 0x0b6cbacb, 0x1b6cbacb,
-  0x2b6cbacb, 0x3b6cbacb, 0x0bacbacb, 0x1bacbacb, 0x2bacbacb, 0x3bacbacb,
-  0x0becbacb, 0x1becbacb, 0x2becbacb, 0x3becbacb, 0x0b2dbacb, 0x1b2dbacb,
-  0x2b2dbacb, 0x3b2dbacb, 0x0b6dbacb, 0x1b6dbacb, 0x2b6dbacb, 0x3b6dbacb,
-  0x0badbacb, 0x1badbacb, 0x2badbacb, 0x3badbacb, 0x0bedbacb, 0x1bedbacb,
-  0x2bedbacb, 0x3bedbacb, 0x0b2ebacb, 0x1b2ebacb, 0x2b2ebacb, 0x3b2ebacb,
-  0x0b6ebacb, 0x1b6ebacb, 0x2b6ebacb, 0x3b6ebacb, 0x0baebacb, 0x1baebacb,
-  0x2baebacb, 0x3baebacb, 0x0beebacb, 0x1beebacb, 0x2beebacb, 0x3beebacb,
-  0x0b2fbacb, 0x1b2fbacb, 0x2b2fbacb, 0x3b2fbacb, 0x0b6fbacb, 0x1b6fbacb,
-  0x2b6fbacb, 0x3b6fbacb, 0x0bafbacb, 0x1bafbacb, 0x2bafbacb, 0x3bafbacb,
-  0x0befbacb, 0x1befbacb, 0x2befbacb, 0x3befbacb, 0x0b2cbecb, 0x1b2cbecb,
-  0x2b2cbecb, 0x3b2cbecb, 0x0b6cbecb, 0x1b6cbecb, 0x2b6cbecb, 0x3b6cbecb,
-  0x0bacbecb, 0x1bacbecb, 0x2bacbecb, 0x3bacbecb, 0x0becbecb, 0x1becbecb,
-  0x2becbecb, 0x3becbecb, 0x0b2dbecb, 0x1b2dbecb, 0x2b2dbecb, 0x3b2dbecb,
-  0x0b6dbecb, 0x1b6dbecb, 0x2b6dbecb, 0x3b6dbecb, 0x0badbecb, 0x1badbecb,
-  0x2badbecb, 0x3badbecb, 0x0bedbecb, 0x1bedbecb, 0x2bedbecb, 0x3bedbecb,
-  0x0b2ebecb, 0x1b2ebecb, 0x2b2ebecb, 0x3b2ebecb, 0x0b6ebecb, 0x1b6ebecb,
-  0x2b6ebecb, 0x3b6ebecb, 0x0baebecb, 0x1baebecb, 0x2baebecb, 0x3baebecb,
-  0x0beebecb, 0x1beebecb, 0x2beebecb, 0x3beebecb, 0x0b2fbecb, 0x1b2fbecb,
-  0x2b2fbecb, 0x3b2fbecb, 0x0b6fbecb, 0x1b6fbecb, 0x2b6fbecb, 0x3b6fbecb,
-  0x0bafbecb, 0x1bafbecb, 0x2bafbecb, 0x3bafbecb, 0x0befbecb, 0x1befbecb,
-  0x2befbecb, 0x3befbecb, 0x0b2cb2db, 0x1b2cb2db, 0x2b2cb2db, 0x3b2cb2db,
-  0x0b6cb2db, 0x1b6cb2db, 0x2b6cb2db, 0x3b6cb2db, 0x0bacb2db, 0x1bacb2db,
-  0x2bacb2db, 0x3bacb2db, 0x0becb2db, 0x1becb2db, 0x2becb2db, 0x3becb2db,
-  0x0b2db2db, 0x1b2db2db, 0x2b2db2db, 0x3b2db2db, 0x0b6db2db, 0x1b6db2db,
-  0x2b6db2db, 0x3b6db2db, 0x0badb2db, 0x1badb2db, 0x2badb2db, 0x3badb2db,
-  0x0bedb2db, 0x1bedb2db, 0x2bedb2db, 0x3bedb2db, 0x0b2eb2db, 0x1b2eb2db,
-  0x2b2eb2db, 0x3b2eb2db, 0x0b6eb2db, 0x1b6eb2db, 0x2b6eb2db, 0x3b6eb2db,
-  0x0baeb2db, 0x1baeb2db, 0x2baeb2db, 0x3baeb2db, 0x0beeb2db, 0x1beeb2db,
-  0x2beeb2db, 0x3beeb2db, 0x0b2fb2db, 0x1b2fb2db, 0x2b2fb2db, 0x3b2fb2db,
-  0x0b6fb2db, 0x1b6fb2db, 0x2b6fb2db, 0x3b6fb2db, 0x0bafb2db, 0x1bafb2db,
-  0x2bafb2db, 0x3bafb2db, 0x0befb2db, 0x1befb2db, 0x2befb2db, 0x3befb2db,
-  0x0b2cb6db, 0x1b2cb6db, 0x2b2cb6db, 0x3b2cb6db, 0x0b6cb6db, 0x1b6cb6db,
-  0x2b6cb6db, 0x3b6cb6db, 0x0bacb6db, 0x1bacb6db, 0x2bacb6db, 0x3bacb6db,
-  0x0becb6db, 0x1becb6db, 0x2becb6db, 0x3becb6db, 0x0b2db6db, 0x1b2db6db,
-  0x2b2db6db, 0x3b2db6db, 0x0b6db6db, 0x1b6db6db, 0x2b6db6db, 0x3b6db6db,
-  0x0badb6db, 0x1badb6db, 0x2badb6db, 0x3badb6db, 0x0bedb6db, 0x1bedb6db,
-  0x2bedb6db, 0x3bedb6db, 0x0b2eb6db, 0x1b2eb6db, 0x2b2eb6db, 0x3b2eb6db,
-  0x0b6eb6db, 0x1b6eb6db, 0x2b6eb6db, 0x3b6eb6db, 0x0baeb6db, 0x1baeb6db,
-  0x2baeb6db, 0x3baeb6db,
-};
-
-static const uint32_t kNonZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
-   6,  6,  6,  6, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-  12, 12, 12, 12, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-  18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-  18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-  18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-  18, 18, 18, 18, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
-};
-
-static const uint16_t kStaticCommandCodeBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
-    0,  256,  128,  384,   64,  320,  192,  448,
-   32,  288,  160,  416,   96,  352,  224,  480,
-   16,  272,  144,  400,   80,  336,  208,  464,
-   48,  304,  176,  432,  112,  368,  240,  496,
-    8,  264,  136,  392,   72,  328,  200,  456,
-   40,  296,  168,  424,  104,  360,  232,  488,
-   24,  280,  152,  408,   88,  344,  216,  472,
-   56,  312,  184,  440,  120,  376,  248,  504,
-    4,  260,  132,  388,   68,  324,  196,  452,
-   36,  292,  164,  420,  100,  356,  228,  484,
-   20,  276,  148,  404,   84,  340,  212,  468,
-   52,  308,  180,  436,  116,  372,  244,  500,
-   12,  268,  140,  396,   76,  332,  204,  460,
-   44,  300,  172,  428,  108,  364,  236,  492,
-   28,  284,  156,  412,   92,  348,  220,  476,
-   60,  316,  188,  444,  124,  380,  252,  508,
-    2,  258,  130,  386,   66,  322,  194,  450,
-   34,  290,  162,  418,   98,  354,  226,  482,
-   18,  274,  146,  402,   82,  338,  210,  466,
-   50,  306,  178,  434,  114,  370,  242,  498,
-   10,  266,  138,  394,   74,  330,  202,  458,
-   42,  298,  170,  426,  106,  362,  234,  490,
-   26,  282,  154,  410,   90,  346,  218,  474,
-   58,  314,  186,  442,  122,  378,  250,  506,
-    6,  262,  134,  390,   70,  326,  198,  454,
-   38,  294,  166,  422,  102,  358,  230,  486,
-   22,  278,  150,  406,   86,  342,  214,  470,
-   54,  310,  182,  438,  118,  374,  246,  502,
-   14,  270,  142,  398,   78,  334,  206,  462,
-   46,  302,  174,  430,  110,  366,  238,  494,
-   30,  286,  158,  414,   94,  350,  222,  478,
-   62,  318,  190,  446,  126,  382,  254,  510,
-    1,  257,  129,  385,   65,  321,  193,  449,
-   33,  289,  161,  417,   97,  353,  225,  481,
-   17,  273,  145,  401,   81,  337,  209,  465,
-   49,  305,  177,  433,  113,  369,  241,  497,
-    9,  265,  137,  393,   73,  329,  201,  457,
-   41,  297,  169,  425,  105,  361,  233,  489,
-   25,  281,  153,  409,   89,  345,  217,  473,
-   57,  313,  185,  441,  121,  377,  249,  505,
-    5,  261,  133,  389,   69,  325,  197,  453,
-   37,  293,  165,  421,  101,  357,  229,  485,
-   21,  277,  149,  405,   85,  341,  213,  469,
-   53,  309,  181,  437,  117,  373,  245,  501,
-   13,  269,  141,  397,   77,  333,  205,  461,
-   45,  301,  173,  429,  109,  365,  237,  493,
-   29,  285,  157,  413,   93,  349,  221,  477,
-   61,  317,  189,  445,  125,  381,  253,  509,
-    3,  259,  131,  387,   67,  323,  195,  451,
-   35,  291,  163,  419,   99,  355,  227,  483,
-   19,  275,  147,  403,   83,  339,  211,  467,
-   51,  307,  179,  435,  115,  371,  243,  499,
-   11,  267,  139,  395,   75,  331,  203,  459,
-   43,  299,  171,  427,  107,  363,  235,  491,
-   27,  283,  155,  411,   91,  347,  219,  475,
-   59,  315,  187,  443,  123,  379,  251,  507,
-    7, 1031,  519, 1543,  263, 1287,  775, 1799,
-  135, 1159,  647, 1671,  391, 1415,  903, 1927,
-   71, 1095,  583, 1607,  327, 1351,  839, 1863,
-  199, 1223,  711, 1735,  455, 1479,  967, 1991,
-   39, 1063,  551, 1575,  295, 1319,  807, 1831,
-  167, 1191,  679, 1703,  423, 1447,  935, 1959,
-  103, 1127,  615, 1639,  359, 1383,  871, 1895,
-  231, 1255,  743, 1767,  487, 1511,  999, 2023,
-   23, 1047,  535, 1559,  279, 1303,  791, 1815,
-  151, 1175,  663, 1687,  407, 1431,  919, 1943,
-   87, 1111,  599, 1623,  343, 1367,  855, 1879,
-  215, 1239,  727, 1751,  471, 1495,  983, 2007,
-   55, 1079,  567, 1591,  311, 1335,  823, 1847,
-  183, 1207,  695, 1719,  439, 1463,  951, 1975,
-  119, 1143,  631, 1655,  375, 1399,  887, 1911,
-  247, 1271,  759, 1783,  503, 1527, 1015, 2039,
-   15, 1039,  527, 1551,  271, 1295,  783, 1807,
-  143, 1167,  655, 1679,  399, 1423,  911, 1935,
-   79, 1103,  591, 1615,  335, 1359,  847, 1871,
-  207, 1231,  719, 1743,  463, 1487,  975, 1999,
-   47, 1071,  559, 1583,  303, 1327,  815, 1839,
-  175, 1199,  687, 1711,  431, 1455,  943, 1967,
-  111, 1135,  623, 1647,  367, 1391,  879, 1903,
-  239, 1263,  751, 1775,  495, 1519, 1007, 2031,
-   31, 1055,  543, 1567,  287, 1311,  799, 1823,
-  159, 1183,  671, 1695,  415, 1439,  927, 1951,
-   95, 1119,  607, 1631,  351, 1375,  863, 1887,
-  223, 1247,  735, 1759,  479, 1503,  991, 2015,
-   63, 1087,  575, 1599,  319, 1343,  831, 1855,
-  191, 1215,  703, 1727,  447, 1471,  959, 1983,
-  127, 1151,  639, 1663,  383, 1407,  895, 1919,
-  255, 1279,  767, 1791,  511, 1535, 1023, 2047,
-};
-
-static BROTLI_INLINE void StoreStaticCommandHuffmanTree(
-    size_t* storage_ix, uint8_t* storage) {
-  BrotliWriteBits(
-      56, BROTLI_MAKE_UINT64_T(0x926244U, 0x16307003U), storage_ix, storage);
-  BrotliWriteBits(3, 0x00000000U, storage_ix, storage);
-}
-
-static const uint16_t kStaticDistanceCodeBits[64] = {
-   0, 32, 16, 48,  8, 40, 24, 56,  4, 36, 20, 52, 12, 44, 28, 60,
-   2, 34, 18, 50, 10, 42, 26, 58,  6, 38, 22, 54, 14, 46, 30, 62,
-   1, 33, 17, 49,  9, 41, 25, 57,  5, 37, 21, 53, 13, 45, 29, 61,
-   3, 35, 19, 51, 11, 43, 27, 59,  7, 39, 23, 55, 15, 47, 31, 63,
-};
-
-static BROTLI_INLINE void StoreStaticDistanceHuffmanTree(
-    size_t* storage_ix, uint8_t* storage) {
-  BrotliWriteBits(28, 0x0369DC03u, storage_ix, storage);
-}
-/* GENERATED CODE END */
-
-}
-
-#endif  /* BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/fast_log.cpp b/src/duckdb/third_party/brotli/enc/fast_log.cpp
deleted file mode 100644
index 790152b0c..000000000
--- a/src/duckdb/third_party/brotli/enc/fast_log.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "fast_log.h"
-
-using namespace duckdb_brotli;
-
-/* ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */
-const double duckdb_brotli::kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE] = {
-  0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
-  1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
-  2.5849625007211561f, 2.8073549220576042f, 3.0000000000000000f,
-  3.1699250014423126f, 3.3219280948873626f, 3.4594316186372978f,
-  3.5849625007211565f, 3.7004397181410922f, 3.8073549220576037f,
-  3.9068905956085187f, 4.0000000000000000f, 4.0874628412503400f,
-  4.1699250014423122f, 4.2479275134435852f, 4.3219280948873626f,
-  4.3923174227787607f, 4.4594316186372973f, 4.5235619560570131f,
-  4.5849625007211570f, 4.6438561897747244f, 4.7004397181410926f,
-  4.7548875021634691f, 4.8073549220576037f, 4.8579809951275728f,
-  4.9068905956085187f, 4.9541963103868758f, 5.0000000000000000f,
-  5.0443941193584534f, 5.0874628412503400f, 5.1292830169449664f,
-  5.1699250014423122f, 5.2094533656289501f, 5.2479275134435852f,
-  5.2854022188622487f, 5.3219280948873626f, 5.3575520046180838f,
-  5.3923174227787607f, 5.4262647547020979f, 5.4594316186372973f,
-  5.4918530963296748f, 5.5235619560570131f, 5.5545888516776376f,
-  5.5849625007211570f, 5.6147098441152083f, 5.6438561897747244f,
-  5.6724253419714961f, 5.7004397181410926f, 5.7279204545631996f,
-  5.7548875021634691f, 5.7813597135246599f, 5.8073549220576046f,
-  5.8328900141647422f, 5.8579809951275719f, 5.8826430493618416f,
-  5.9068905956085187f, 5.9307373375628867f, 5.9541963103868758f,
-  5.9772799234999168f, 6.0000000000000000f, 6.0223678130284544f,
-  6.0443941193584534f, 6.0660891904577721f, 6.0874628412503400f,
-  6.1085244567781700f, 6.1292830169449672f, 6.1497471195046822f,
-  6.1699250014423122f, 6.1898245588800176f, 6.2094533656289510f,
-  6.2288186904958804f, 6.2479275134435861f, 6.2667865406949019f,
-  6.2854022188622487f, 6.3037807481771031f, 6.3219280948873617f,
-  6.3398500028846252f, 6.3575520046180847f, 6.3750394313469254f,
-  6.3923174227787598f, 6.4093909361377026f, 6.4262647547020979f,
-  6.4429434958487288f, 6.4594316186372982f, 6.4757334309663976f,
-  6.4918530963296748f, 6.5077946401986964f, 6.5235619560570131f,
-  6.5391588111080319f, 6.5545888516776376f, 6.5698556083309478f,
-  6.5849625007211561f, 6.5999128421871278f, 6.6147098441152092f,
-  6.6293566200796095f, 6.6438561897747253f, 6.6582114827517955f,
-  6.6724253419714952f, 6.6865005271832185f, 6.7004397181410917f,
-  6.7142455176661224f, 6.7279204545631988f, 6.7414669864011465f,
-  6.7548875021634691f, 6.7681843247769260f, 6.7813597135246599f,
-  6.7944158663501062f, 6.8073549220576037f, 6.8201789624151887f,
-  6.8328900141647422f, 6.8454900509443757f, 6.8579809951275719f,
-  6.8703647195834048f, 6.8826430493618416f, 6.8948177633079437f,
-  6.9068905956085187f, 6.9188632372745955f, 6.9307373375628867f,
-  6.9425145053392399f, 6.9541963103868758f, 6.9657842846620879f,
-  6.9772799234999168f, 6.9886846867721664f, 7.0000000000000000f,
-  7.0112272554232540f, 7.0223678130284544f, 7.0334230015374501f,
-  7.0443941193584534f, 7.0552824355011898f, 7.0660891904577721f,
-  7.0768155970508317f, 7.0874628412503400f, 7.0980320829605272f,
-  7.1085244567781700f, 7.1189410727235076f, 7.1292830169449664f,
-  7.1395513523987937f, 7.1497471195046822f, 7.1598713367783891f,
-  7.1699250014423130f, 7.1799090900149345f, 7.1898245588800176f,
-  7.1996723448363644f, 7.2094533656289492f, 7.2191685204621621f,
-  7.2288186904958804f, 7.2384047393250794f, 7.2479275134435861f,
-  7.2573878426926521f, 7.2667865406949019f, 7.2761244052742384f,
-  7.2854022188622487f, 7.2946207488916270f, 7.3037807481771031f,
-  7.3128829552843557f, 7.3219280948873617f, 7.3309168781146177f,
-  7.3398500028846243f, 7.3487281542310781f, 7.3575520046180847f,
-  7.3663222142458151f, 7.3750394313469254f, 7.3837042924740528f,
-  7.3923174227787607f, 7.4008794362821844f, 7.4093909361377026f,
-  7.4178525148858991f, 7.4262647547020979f, 7.4346282276367255f,
-  7.4429434958487288f, 7.4512111118323299f, 7.4594316186372973f,
-  7.4676055500829976f, 7.4757334309663976f, 7.4838157772642564f,
-  7.4918530963296748f, 7.4998458870832057f, 7.5077946401986964f,
-  7.5156998382840436f, 7.5235619560570131f, 7.5313814605163119f,
-  7.5391588111080319f, 7.5468944598876373f, 7.5545888516776376f,
-  7.5622424242210728f, 7.5698556083309478f, 7.5774288280357487f,
-  7.5849625007211561f, 7.5924570372680806f, 7.5999128421871278f,
-  7.6073303137496113f, 7.6147098441152075f, 7.6220518194563764f,
-  7.6293566200796095f, 7.6366246205436488f, 7.6438561897747244f,
-  7.6510516911789290f, 7.6582114827517955f, 7.6653359171851765f,
-  7.6724253419714952f, 7.6794800995054464f, 7.6865005271832185f,
-  7.6934869574993252f, 7.7004397181410926f, 7.7073591320808825f,
-  7.7142455176661224f, 7.7210991887071856f, 7.7279204545631996f,
-  7.7347096202258392f, 7.7414669864011465f, 7.7481928495894596f,
-  7.7548875021634691f, 7.7615512324444795f, 7.7681843247769260f,
-  7.7747870596011737f, 7.7813597135246608f, 7.7879025593914317f,
-  7.7944158663501062f, 7.8008998999203047f, 7.8073549220576037f,
-  7.8137811912170374f, 7.8201789624151887f, 7.8265484872909159f,
-  7.8328900141647422f, 7.8392037880969445f, 7.8454900509443757f,
-  7.8517490414160571f, 7.8579809951275719f, 7.8641861446542798f,
-  7.8703647195834048f, 7.8765169465650002f, 7.8826430493618425f,
-  7.8887432488982601f, 7.8948177633079446f, 7.9008668079807496f,
-  7.9068905956085187f, 7.9128893362299619f, 7.9188632372745955f,
-  7.9248125036057813f, 7.9307373375628867f, 7.9366379390025719f,
-  7.9425145053392399f, 7.9483672315846778f, 7.9541963103868758f,
-  7.9600019320680806f, 7.9657842846620870f, 7.9715435539507720f,
-  7.9772799234999168f, 7.9829935746943104f, 7.9886846867721664f,
-  7.9943534368588578f
-};
-
-
diff --git a/src/duckdb/third_party/brotli/enc/fast_log.h b/src/duckdb/third_party/brotli/enc/fast_log.h
deleted file mode 100644
index 455bd8034..000000000
--- a/src/duckdb/third_party/brotli/enc/fast_log.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Utilities for fast computation of logarithms. */
-
-#ifndef BROTLI_ENC_FAST_LOG_H_
-#define BROTLI_ENC_FAST_LOG_H_
-
-#include <math.h>
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-static BROTLI_INLINE uint32_t Log2FloorNonZero(size_t n) {
-#if defined(BROTLI_BSR32)
-  return BROTLI_BSR32((uint32_t)n);
-#else
-  uint32_t result = 0;
-  while (n >>= 1) result++;
-  return result;
-#endif
-}
-
-#define BROTLI_LOG2_TABLE_SIZE 256
-
-/* A lookup table for small values of log2(int) to be used in entropy
-   computation. */
-BROTLI_INTERNAL extern const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE];
-
-/* Visual Studio 2012 and Android API levels < 18 do not have the log2()
- * function defined, so we use log() and a multiplication instead. */
-#if !defined(BROTLI_HAVE_LOG2)
-#if ((defined(_MSC_VER) && _MSC_VER <= 1700) || \
-     (defined(__ANDROID_API__) && __ANDROID_API__ < 18))
-#define BROTLI_HAVE_LOG2 0
-#else
-#define BROTLI_HAVE_LOG2 1
-#endif
-#endif
-
-#define LOG_2_INV 1.4426950408889634
-
-/* Faster logarithm for small integers, with the property of log2(0) == 0. */
-static BROTLI_INLINE double FastLog2(size_t v) {
-  if (v < BROTLI_LOG2_TABLE_SIZE) {
-    return kBrotliLog2Table[v];
-  }
-#if !(BROTLI_HAVE_LOG2)
-  return log((double)v) * LOG_2_INV;
-#else
-  return log2((double)v);
-#endif
-}
-
-}
-
-#endif  /* BROTLI_ENC_FAST_LOG_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/find_match_length.h b/src/duckdb/third_party/brotli/enc/find_match_length.h
deleted file mode 100644
index fb74483e2..000000000
--- a/src/duckdb/third_party/brotli/enc/find_match_length.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Function to find maximal matching prefixes of strings. */
-
-#ifndef BROTLI_ENC_FIND_MATCH_LENGTH_H_
-#define BROTLI_ENC_FIND_MATCH_LENGTH_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-/* Separate implementation for little-endian 64-bit targets, for speed. */
-#if defined(BROTLI_TZCNT64) && BROTLI_64_BITS && BROTLI_LITTLE_ENDIAN
-static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
-                                                     const uint8_t* s2,
-                                                     size_t limit) {
-  const uint8_t *s1_orig = s1;
-  for (; limit >= 8; limit -= 8) {
-    uint64_t x = BROTLI_UNALIGNED_LOAD64LE(s2) ^
-                 BROTLI_UNALIGNED_LOAD64LE(s1);
-    s2 += 8;
-    if (x != 0) {
-      size_t matching_bits = (size_t)BROTLI_TZCNT64(x);
-      return (size_t)(s1 - s1_orig) + (matching_bits >> 3);
-    }
-    s1 += 8;
-  }
-  while (limit && *s1 == *s2) {
-    limit--;
-    ++s2;
-    ++s1;
-  }
-  return (size_t)(s1 - s1_orig);
-}
-#else
-static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
-                                                     const uint8_t* s2,
-                                                     size_t limit) {
-  size_t matched = 0;
-  const uint8_t* s2_limit = s2 + limit;
-  const uint8_t* s2_ptr = s2;
-  /* Find out how long the match is. We loop over the data 32 bits at a
-     time until we find a 32-bit block that doesn't match; then we find
-     the first non-matching bit and use that to calculate the total
-     length of the match. */
-  while (s2_ptr <= s2_limit - 4 &&
-         BrotliUnalignedRead32(s2_ptr) ==
-         BrotliUnalignedRead32(s1 + matched)) {
-    s2_ptr += 4;
-    matched += 4;
-  }
-  while ((s2_ptr < s2_limit) && (s1[matched] == *s2_ptr)) {
-    ++s2_ptr;
-    ++matched;
-  }
-  return matched;
-}
-#endif
-
-}
-
-#endif  /* BROTLI_ENC_FIND_MATCH_LENGTH_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/histogram.cpp b/src/duckdb/third_party/brotli/enc/histogram.cpp
deleted file mode 100644
index 5a9fba9c9..000000000
--- a/src/duckdb/third_party/brotli/enc/histogram.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Build per-context histograms of literals, commands and distance codes. */
-
-#include "histogram.h"
-
-#include "../common/context.h"
-#include "block_splitter.h"
-#include "command.h"
-
-using namespace duckdb_brotli;
-
-typedef struct BlockSplitIterator {
-  const BlockSplit* split_;  /* Not owned. */
-  size_t idx_;
-  size_t type_;
-  size_t length_;
-} BlockSplitIterator;
-
-static void InitBlockSplitIterator(BlockSplitIterator* self,
-    const BlockSplit* split) {
-  self->split_ = split;
-  self->idx_ = 0;
-  self->type_ = 0;
-  self->length_ = split->lengths ? split->lengths[0] : 0;
-}
-
-static void BlockSplitIteratorNext(BlockSplitIterator* self) {
-  if (self->length_ == 0) {
-    ++self->idx_;
-    self->type_ = self->split_->types[self->idx_];
-    self->length_ = self->split_->lengths[self->idx_];
-  }
-  --self->length_;
-}
-
-void duckdb_brotli::BrotliBuildHistogramsWithContext(
-    const Command* cmds, const size_t num_commands,
-    const BlockSplit* literal_split, const BlockSplit* insert_and_copy_split,
-    const BlockSplit* dist_split, const uint8_t* ringbuffer, size_t start_pos,
-    size_t mask, uint8_t prev_byte, uint8_t prev_byte2,
-    const ContextType* context_modes, HistogramLiteral* literal_histograms,
-    HistogramCommand* insert_and_copy_histograms,
-    HistogramDistance* copy_dist_histograms) {
-  size_t pos = start_pos;
-  BlockSplitIterator literal_it;
-  BlockSplitIterator insert_and_copy_it;
-  BlockSplitIterator dist_it;
-  size_t i;
-
-  InitBlockSplitIterator(&literal_it, literal_split);
-  InitBlockSplitIterator(&insert_and_copy_it, insert_and_copy_split);
-  InitBlockSplitIterator(&dist_it, dist_split);
-  for (i = 0; i < num_commands; ++i) {
-    const Command* cmd = &cmds[i];
-    size_t j;
-    BlockSplitIteratorNext(&insert_and_copy_it);
-    HistogramAddCommand(&insert_and_copy_histograms[insert_and_copy_it.type_],
-        cmd->cmd_prefix_);
-    /* TODO(eustas): unwrap iterator blocks. */
-    for (j = cmd->insert_len_; j != 0; --j) {
-      size_t context;
-      BlockSplitIteratorNext(&literal_it);
-      context = literal_it.type_;
-      if (context_modes) {
-        ContextLut lut = BROTLI_CONTEXT_LUT(context_modes[context]);
-        context = (context << BROTLI_LITERAL_CONTEXT_BITS) +
-            BROTLI_CONTEXT(prev_byte, prev_byte2, lut);
-      }
-      HistogramAddLiteral(&literal_histograms[context],
-          ringbuffer[pos & mask]);
-      prev_byte2 = prev_byte;
-      prev_byte = ringbuffer[pos & mask];
-      ++pos;
-    }
-    pos += CommandCopyLen(cmd);
-    if (CommandCopyLen(cmd)) {
-      prev_byte2 = ringbuffer[(pos - 2) & mask];
-      prev_byte = ringbuffer[(pos - 1) & mask];
-      if (cmd->cmd_prefix_ >= 128) {
-        size_t context;
-        BlockSplitIteratorNext(&dist_it);
-        context = (dist_it.type_ << BROTLI_DISTANCE_CONTEXT_BITS) +
-            CommandDistanceContext(cmd);
-        HistogramAddDistance(&copy_dist_histograms[context],
-            cmd->dist_prefix_ & 0x3FF);
-      }
-    }
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/histogram.h b/src/duckdb/third_party/brotli/enc/histogram.h
deleted file mode 100644
index 3ac082ad8..000000000
--- a/src/duckdb/third_party/brotli/enc/histogram.h
+++ /dev/null
@@ -1,210 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Models the histograms of literals, commands and distance codes. */
-
-#ifndef BROTLI_ENC_HISTOGRAM_H_
-#define BROTLI_ENC_HISTOGRAM_H_
-
-#include <string.h>  /* memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/brotli_platform.h"
-#include "block_splitter.h"
-#include "command.h"
-
-namespace duckdb_brotli {
-
-/* The distance symbols effectively used by "Large Window Brotli" (32-bit). */
-#define BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS 544
-
-#define FN(X) X ## Literal
-#define DATA_SIZE BROTLI_NUM_LITERAL_SYMBOLS
-#define DataType uint8_t
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: Histogram, DATA_SIZE, DataType */
-
-/* A simple container for histograms of data in blocks. */
-
-typedef struct FN(Histogram) {
-  uint32_t data_[DATA_SIZE];
-  size_t total_count_;
-  double bit_cost_;
-} FN(Histogram);
-
-static BROTLI_INLINE void FN(HistogramClear)(FN(Histogram)* self) {
-  memset(self->data_, 0, sizeof(self->data_));
-  self->total_count_ = 0;
-  self->bit_cost_ = HUGE_VAL;
-}
-
-static BROTLI_INLINE void FN(ClearHistograms)(
-    FN(Histogram)* array, size_t length) {
-  size_t i;
-  for (i = 0; i < length; ++i) FN(HistogramClear)(array + i);
-}
-
-static BROTLI_INLINE void FN(HistogramAdd)(FN(Histogram)* self, size_t val) {
-  ++self->data_[val];
-  ++self->total_count_;
-}
-
-static BROTLI_INLINE void FN(HistogramAddVector)(FN(Histogram)* self,
-    const DataType* p, size_t n) {
-  self->total_count_ += n;
-  n += 1;
-  while (--n) ++self->data_[*p++];
-}
-
-static BROTLI_INLINE void FN(HistogramAddHistogram)(FN(Histogram)* self,
-    const FN(Histogram)* v) {
-  size_t i;
-  self->total_count_ += v->total_count_;
-  for (i = 0; i < DATA_SIZE; ++i) {
-    self->data_[i] += v->data_[i];
-  }
-}
-
-static BROTLI_INLINE size_t FN(HistogramDataSize)(void) { return DATA_SIZE; }
-#undef DataType
-#undef DATA_SIZE
-#undef FN
-
-#define FN(X) X ## Command
-#define DataType uint16_t
-#define DATA_SIZE BROTLI_NUM_COMMAND_SYMBOLS
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: Histogram, DATA_SIZE, DataType */
-
-/* A simple container for histograms of data in blocks. */
-
-typedef struct FN(Histogram) {
-  uint32_t data_[DATA_SIZE];
-  size_t total_count_;
-  double bit_cost_;
-} FN(Histogram);
-
-static BROTLI_INLINE void FN(HistogramClear)(FN(Histogram)* self) {
-  memset(self->data_, 0, sizeof(self->data_));
-  self->total_count_ = 0;
-  self->bit_cost_ = HUGE_VAL;
-}
-
-static BROTLI_INLINE void FN(ClearHistograms)(
-    FN(Histogram)* array, size_t length) {
-  size_t i;
-  for (i = 0; i < length; ++i) FN(HistogramClear)(array + i);
-}
-
-static BROTLI_INLINE void FN(HistogramAdd)(FN(Histogram)* self, size_t val) {
-  ++self->data_[val];
-  ++self->total_count_;
-}
-
-static BROTLI_INLINE void FN(HistogramAddVector)(FN(Histogram)* self,
-    const DataType* p, size_t n) {
-  self->total_count_ += n;
-  n += 1;
-  while (--n) ++self->data_[*p++];
-}
-
-static BROTLI_INLINE void FN(HistogramAddHistogram)(FN(Histogram)* self,
-    const FN(Histogram)* v) {
-  size_t i;
-  self->total_count_ += v->total_count_;
-  for (i = 0; i < DATA_SIZE; ++i) {
-    self->data_[i] += v->data_[i];
-  }
-}
-
-static BROTLI_INLINE size_t FN(HistogramDataSize)(void) { return DATA_SIZE; }
-#undef DATA_SIZE
-#undef FN
-
-#define FN(X) X ## Distance
-#define DATA_SIZE BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS
-/* NOLINT(build/header_guard) */
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: Histogram, DATA_SIZE, DataType */
-
-/* A simple container for histograms of data in blocks. */
-
-typedef struct FN(Histogram) {
-  uint32_t data_[DATA_SIZE];
-  size_t total_count_;
-  double bit_cost_;
-} FN(Histogram);
-
-static BROTLI_INLINE void FN(HistogramClear)(FN(Histogram)* self) {
-  memset(self->data_, 0, sizeof(self->data_));
-  self->total_count_ = 0;
-  self->bit_cost_ = HUGE_VAL;
-}
-
-static BROTLI_INLINE void FN(ClearHistograms)(
-    FN(Histogram)* array, size_t length) {
-  size_t i;
-  for (i = 0; i < length; ++i) FN(HistogramClear)(array + i);
-}
-
-static BROTLI_INLINE void FN(HistogramAdd)(FN(Histogram)* self, size_t val) {
-  ++self->data_[val];
-  ++self->total_count_;
-}
-
-static BROTLI_INLINE void FN(HistogramAddVector)(FN(Histogram)* self,
-    const DataType* p, size_t n) {
-  self->total_count_ += n;
-  n += 1;
-  while (--n) ++self->data_[*p++];
-}
-
-static BROTLI_INLINE void FN(HistogramAddHistogram)(FN(Histogram)* self,
-    const FN(Histogram)* v) {
-  size_t i;
-  self->total_count_ += v->total_count_;
-  for (i = 0; i < DATA_SIZE; ++i) {
-    self->data_[i] += v->data_[i];
-  }
-}
-
-static BROTLI_INLINE size_t FN(HistogramDataSize)(void) { return DATA_SIZE; }
-#undef DataType
-#undef DATA_SIZE
-#undef FN
-
-BROTLI_INTERNAL void BrotliBuildHistogramsWithContext(
-    const Command* cmds, const size_t num_commands,
-    const BlockSplit* literal_split, const BlockSplit* insert_and_copy_split,
-    const BlockSplit* dist_split, const uint8_t* ringbuffer, size_t pos,
-    size_t mask, uint8_t prev_byte, uint8_t prev_byte2,
-    const ContextType* context_modes, HistogramLiteral* literal_histograms,
-    HistogramCommand* insert_and_copy_histograms,
-    HistogramDistance* copy_dist_histograms);
-
-}
-
-#endif  /* BROTLI_ENC_HISTOGRAM_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/literal_cost.cpp b/src/duckdb/third_party/brotli/enc/literal_cost.cpp
deleted file mode 100644
index 3ffdb6cc1..000000000
--- a/src/duckdb/third_party/brotli/enc/literal_cost.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Literal cost model to allow backward reference replacement to be efficient.
-*/
-
-#include "literal_cost.h"
-
-#include <string.h>  /* memset */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "fast_log.h"
-#include "utf8_util.h"
-
-using namespace duckdb_brotli;
-
-static size_t UTF8Position(size_t last, size_t c, size_t clamp) {
-  if (c < 128) {
-    return 0;  /* Next one is the 'Byte 1' again. */
-  } else if (c >= 192) {  /* Next one is the 'Byte 2' of utf-8 encoding. */
-    return BROTLI_MIN(size_t, 1, clamp);
-  } else {
-    /* Let's decide over the last byte if this ends the sequence. */
-    if (last < 0xE0) {
-      return 0;  /* Completed two or three byte coding. */
-    } else {  /* Next one is the 'Byte 3' of utf-8 encoding. */
-      return BROTLI_MIN(size_t, 2, clamp);
-    }
-  }
-}
-
-static size_t DecideMultiByteStatsLevel(size_t pos, size_t len, size_t mask,
-                                        const uint8_t* data) {
-  size_t counts[3] = { 0 };
-  size_t max_utf8 = 1;  /* should be 2, but 1 compresses better. */
-  size_t last_c = 0;
-  size_t i;
-  for (i = 0; i < len; ++i) {
-    size_t c = data[(pos + i) & mask];
-    ++counts[UTF8Position(last_c, c, 2)];
-    last_c = c;
-  }
-  if (counts[2] < 500) {
-    max_utf8 = 1;
-  }
-  if (counts[1] + counts[2] < 25) {
-    max_utf8 = 0;
-  }
-  return max_utf8;
-}
-
-static void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
-                                            const uint8_t* data,
-                                            size_t* histogram, float* cost) {
-  /* max_utf8 is 0 (normal ASCII single byte modeling),
-     1 (for 2-byte UTF-8 modeling), or 2 (for 3-byte UTF-8 modeling). */
-  const size_t max_utf8 = DecideMultiByteStatsLevel(pos, len, mask, data);
-  size_t window_half = 495;
-  size_t in_window = BROTLI_MIN(size_t, window_half, len);
-  size_t in_window_utf8[3] = { 0 };
-  size_t i;
-  memset(histogram, 0, 3 * 256 * sizeof(histogram[0]));
-
-  {  /* Bootstrap histograms. */
-    size_t last_c = 0;
-    size_t utf8_pos = 0;
-    for (i = 0; i < in_window; ++i) {
-      size_t c = data[(pos + i) & mask];
-      ++histogram[256 * utf8_pos + c];
-      ++in_window_utf8[utf8_pos];
-      utf8_pos = UTF8Position(last_c, c, max_utf8);
-      last_c = c;
-    }
-  }
-
-  /* Compute bit costs with sliding window. */
-  for (i = 0; i < len; ++i) {
-    if (i >= window_half) {
-      /* Remove a byte in the past. */
-      size_t c =
-          i < window_half + 1 ? 0 : data[(pos + i - window_half - 1) & mask];
-      size_t last_c =
-          i < window_half + 2 ? 0 : data[(pos + i - window_half - 2) & mask];
-      size_t utf8_pos2 = UTF8Position(last_c, c, max_utf8);
-      --histogram[256 * utf8_pos2 + data[(pos + i - window_half) & mask]];
-      --in_window_utf8[utf8_pos2];
-    }
-    if (i + window_half < len) {
-      /* Add a byte in the future. */
-      size_t c = data[(pos + i + window_half - 1) & mask];
-      size_t last_c = data[(pos + i + window_half - 2) & mask];
-      size_t utf8_pos2 = UTF8Position(last_c, c, max_utf8);
-      ++histogram[256 * utf8_pos2 + data[(pos + i + window_half) & mask]];
-      ++in_window_utf8[utf8_pos2];
-    }
-    {
-      size_t c = i < 1 ? 0 : data[(pos + i - 1) & mask];
-      size_t last_c = i < 2 ? 0 : data[(pos + i - 2) & mask];
-      size_t utf8_pos = UTF8Position(last_c, c, max_utf8);
-      size_t masked_pos = (pos + i) & mask;
-      size_t histo = histogram[256 * utf8_pos + data[masked_pos]];
-      double lit_cost;
-      if (histo == 0) {
-        histo = 1;
-      }
-      lit_cost = FastLog2(in_window_utf8[utf8_pos]) - FastLog2(histo);
-      lit_cost += 0.02905;
-      if (lit_cost < 1.0) {
-        lit_cost *= 0.5;
-        lit_cost += 0.5;
-      }
-      /* Make the first bytes more expensive -- seems to help, not sure why.
-         Perhaps because the entropy source is changing its properties
-         rapidly in the beginning of the file, perhaps because the beginning
-         of the data is a statistical "anomaly". */
-      if (i < 2000) {
-        lit_cost += 0.7 - ((double)(2000 - i) / 2000.0 * 0.35);
-      }
-      cost[i] = (float)lit_cost;
-    }
-  }
-}
-
-void duckdb_brotli::BrotliEstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
-                                       const uint8_t* data,
-                                       size_t* histogram, float* cost) {
-  if (BrotliIsMostlyUTF8(data, pos, mask, len, kMinUTF8Ratio)) {
-    EstimateBitCostsForLiteralsUTF8(pos, len, mask, data, histogram, cost);
-    return;
-  } else {
-    size_t window_half = 2000;
-    size_t in_window = BROTLI_MIN(size_t, window_half, len);
-    size_t i;
-    memset(histogram, 0, 256 * sizeof(histogram[0]));
-
-    /* Bootstrap histogram. */
-    for (i = 0; i < in_window; ++i) {
-      ++histogram[data[(pos + i) & mask]];
-    }
-
-    /* Compute bit costs with sliding window. */
-    for (i = 0; i < len; ++i) {
-      size_t histo;
-      if (i >= window_half) {
-        /* Remove a byte in the past. */
-        --histogram[data[(pos + i - window_half) & mask]];
-        --in_window;
-      }
-      if (i + window_half < len) {
-        /* Add a byte in the future. */
-        ++histogram[data[(pos + i + window_half) & mask]];
-        ++in_window;
-      }
-      histo = histogram[data[(pos + i) & mask]];
-      if (histo == 0) {
-        histo = 1;
-      }
-      {
-        double lit_cost = FastLog2(in_window) - FastLog2(histo);
-        lit_cost += 0.029;
-        if (lit_cost < 1.0) {
-          lit_cost *= 0.5;
-          lit_cost += 0.5;
-        }
-        cost[i] = (float)lit_cost;
-      }
-    }
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/literal_cost.h b/src/duckdb/third_party/brotli/enc/literal_cost.h
deleted file mode 100644
index 17ae559a8..000000000
--- a/src/duckdb/third_party/brotli/enc/literal_cost.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Literal cost model to allow backward reference replacement to be efficient.
-*/
-
-#ifndef BROTLI_ENC_LITERAL_COST_H_
-#define BROTLI_ENC_LITERAL_COST_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-/* Estimates how many bits the literals in the interval [pos, pos + len) in the
-   ring-buffer (data, mask) will take entropy coded and writes these estimates
-   to the cost[0..len) array. */
-BROTLI_INTERNAL void BrotliEstimateBitCostsForLiterals(
-    size_t pos, size_t len, size_t mask, const uint8_t* data, size_t* histogram,
-    float* cost);
-
-}
-
-#endif  /* BROTLI_ENC_LITERAL_COST_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/memory.cpp b/src/duckdb/third_party/brotli/enc/memory.cpp
deleted file mode 100644
index 8a5c67128..000000000
--- a/src/duckdb/third_party/brotli/enc/memory.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Algorithms for distributing the literals and commands of a metablock between
-   block types and contexts. */
-
-#include "memory.h"
-
-#include <stdlib.h>  /* exit, free, malloc */
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-using namespace duckdb_brotli;
-
-#define MAX_NEW_ALLOCATED (BROTLI_ENCODER_MEMORY_MANAGER_SLOTS >> 2)
-#define MAX_NEW_FREED (BROTLI_ENCODER_MEMORY_MANAGER_SLOTS >> 2)
-#define MAX_PERM_ALLOCATED (BROTLI_ENCODER_MEMORY_MANAGER_SLOTS >> 1)
-
-#define PERM_ALLOCATED_OFFSET 0
-#define NEW_ALLOCATED_OFFSET MAX_PERM_ALLOCATED
-#define NEW_FREED_OFFSET (MAX_PERM_ALLOCATED + MAX_NEW_ALLOCATED)
-
-void duckdb_brotli::BrotliInitMemoryManager(
-    MemoryManager* m, brotli_alloc_func alloc_func, brotli_free_func free_func,
-    void* opaque) {
-  if (!alloc_func) {
-    m->alloc_func = duckdb_brotli::BrotliDefaultAllocFunc;
-    m->free_func =  duckdb_brotli::BrotliDefaultFreeFunc;
-    m->opaque = 0;
-  } else {
-    m->alloc_func = alloc_func;
-    m->free_func = free_func;
-    m->opaque = opaque;
-  }
-#if !defined(BROTLI_ENCODER_EXIT_ON_OOM)
-  m->is_oom = BROTLI_FALSE;
-  m->perm_allocated = 0;
-  m->new_allocated = 0;
-  m->new_freed = 0;
-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
-}
-
-#if defined(BROTLI_ENCODER_EXIT_ON_OOM)
-
-void* duckdb_brotli::BrotliAllocate(MemoryManager* m, size_t n) {
-  void* result = m->alloc_func(m->opaque, n);
-  if (!result) exit(EXIT_FAILURE);
-  return result;
-}
-
-void duckdb_brotli::BrotliFree(MemoryManager* m, void* p) {
-  m->free_func(m->opaque, p);
-}
-
-void duckdb_brotli::BrotliWipeOutMemoryManager(MemoryManager* m) {
-  BROTLI_UNUSED(m);
-}
-
-#else  /* BROTLI_ENCODER_EXIT_ON_OOM */
-
-void SortPointers(void** items, const size_t n) {
-  /* Shell sort. */
-  /* TODO(eustas): fine-tune for "many slots" case */
-  static const size_t gaps[] = {23, 10, 4, 1};
-  int g = 0;
-  for (; g < 4; ++g) {
-    size_t gap = gaps[g];
-    size_t i;
-    for (i = gap; i < n; ++i) {
-      size_t j = i;
-      void* tmp = items[i];
-      for (; j >= gap && tmp < items[j - gap]; j -= gap) {
-        items[j] = items[j - gap];
-      }
-      items[j] = tmp;
-    }
-  }
-}
-
-static size_t Annihilate(void** a, size_t a_len, void** b, size_t b_len) {
-  size_t a_read_index = 0;
-  size_t b_read_index = 0;
-  size_t a_write_index = 0;
-  size_t b_write_index = 0;
-  size_t annihilated = 0;
-  while (a_read_index < a_len && b_read_index < b_len) {
-    if (a[a_read_index] == b[b_read_index]) {
-      a_read_index++;
-      b_read_index++;
-      annihilated++;
-    } else if (a[a_read_index] < b[b_read_index]) {
-      a[a_write_index++] = a[a_read_index++];
-    } else {
-      b[b_write_index++] = b[b_read_index++];
-    }
-  }
-  while (a_read_index < a_len) a[a_write_index++] = a[a_read_index++];
-  while (b_read_index < b_len) b[b_write_index++] = b[b_read_index++];
-  return annihilated;
-}
-
-static void CollectGarbagePointers(MemoryManager* m) {
-  size_t annihilated;
-  SortPointers(m->pointers + NEW_ALLOCATED_OFFSET, m->new_allocated);
-  SortPointers(m->pointers + NEW_FREED_OFFSET, m->new_freed);
-  annihilated = Annihilate(
-      m->pointers + NEW_ALLOCATED_OFFSET, m->new_allocated,
-      m->pointers + NEW_FREED_OFFSET, m->new_freed);
-  m->new_allocated -= annihilated;
-  m->new_freed -= annihilated;
-
-  if (m->new_freed != 0) {
-    annihilated = Annihilate(
-        m->pointers + PERM_ALLOCATED_OFFSET, m->perm_allocated,
-        m->pointers + NEW_FREED_OFFSET, m->new_freed);
-    m->perm_allocated -= annihilated;
-    m->new_freed -= annihilated;
-    BROTLI_DCHECK(m->new_freed == 0);
-  }
-
-  if (m->new_allocated != 0) {
-    BROTLI_DCHECK(m->perm_allocated + m->new_allocated <= MAX_PERM_ALLOCATED);
-    memcpy(m->pointers + PERM_ALLOCATED_OFFSET + m->perm_allocated,
-           m->pointers + NEW_ALLOCATED_OFFSET,
-           sizeof(void*) * m->new_allocated);
-    m->perm_allocated += m->new_allocated;
-    m->new_allocated = 0;
-    SortPointers(m->pointers + PERM_ALLOCATED_OFFSET, m->perm_allocated);
-  }
-}
-
-void* duckdb_brotli::BrotliAllocate(MemoryManager* m, size_t n) {
-  void* result = m->alloc_func(m->opaque, n);
-  if (!result) {
-    m->is_oom = BROTLI_TRUE;
-    return NULL;
-  }
-  if (m->new_allocated == MAX_NEW_ALLOCATED) CollectGarbagePointers(m);
-  m->pointers[NEW_ALLOCATED_OFFSET + (m->new_allocated++)] = result;
-  return result;
-}
-
-void duckdb_brotli::BrotliFree(MemoryManager* m, void* p) {
-  if (!p) return;
-  m->free_func(m->opaque, p);
-  if (m->new_freed == MAX_NEW_FREED) CollectGarbagePointers(m);
-  m->pointers[NEW_FREED_OFFSET + (m->new_freed++)] = p;
-}
-
-void duckdb_brotli::BrotliWipeOutMemoryManager(MemoryManager* m) {
-  size_t i;
-  CollectGarbagePointers(m);
-  /* Now all unfreed pointers are in perm-allocated list. */
-  for (i = 0; i < m->perm_allocated; ++i) {
-    m->free_func(m->opaque, m->pointers[PERM_ALLOCATED_OFFSET + i]);
-  }
-  m->perm_allocated = 0;
-}
-
-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
-
-void* duckdb_brotli::BrotliBootstrapAlloc(size_t size,
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
-  if (!alloc_func && !free_func) {
-    return malloc(size);
-  } else if (alloc_func && free_func) {
-    return alloc_func(opaque, size);
-  }
-  return NULL;
-}
-
-void duckdb_brotli::BrotliBootstrapFree(void* address, MemoryManager* m) {
-  if (!address) {
-    /* Should not happen! */
-    return;
-  } else {
-    /* Copy values, as those would be freed. */
-    brotli_free_func free_func = m->free_func;
-    void* opaque = m->opaque;
-    free_func(opaque, address);
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/memory.h b/src/duckdb/third_party/brotli/enc/memory.h
deleted file mode 100644
index 2c693d552..000000000
--- a/src/duckdb/third_party/brotli/enc/memory.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Macros for memory management. */
-
-#ifndef BROTLI_ENC_MEMORY_H_
-#define BROTLI_ENC_MEMORY_H_
-
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-#if !defined(BROTLI_ENCODER_CLEANUP_ON_OOM) && \
-    !defined(BROTLI_ENCODER_EXIT_ON_OOM)
-#define BROTLI_ENCODER_EXIT_ON_OOM
-#endif
-
-#if !defined(BROTLI_ENCODER_EXIT_ON_OOM)
-#if defined(BROTLI_EXPERIMENTAL)
-#define BROTLI_ENCODER_MEMORY_MANAGER_SLOTS (48*1024)
-#else  /* BROTLI_EXPERIMENTAL */
-#define BROTLI_ENCODER_MEMORY_MANAGER_SLOTS 256
-#endif  /* BROTLI_EXPERIMENTAL */
-#else /* BROTLI_ENCODER_EXIT_ON_OOM */
-#define BROTLI_ENCODER_MEMORY_MANAGER_SLOTS 0
-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
-
-typedef struct MemoryManager {
-  brotli_alloc_func alloc_func;
-  brotli_free_func free_func;
-  void* opaque;
-#if !defined(BROTLI_ENCODER_EXIT_ON_OOM)
-  BROTLI_BOOL is_oom;
-  size_t perm_allocated;
-  size_t new_allocated;
-  size_t new_freed;
-  void* pointers[BROTLI_ENCODER_MEMORY_MANAGER_SLOTS];
-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
-} MemoryManager;
-
-BROTLI_INTERNAL void BrotliInitMemoryManager(
-    MemoryManager* m, brotli_alloc_func alloc_func, brotli_free_func free_func,
-    void* opaque);
-
-BROTLI_INTERNAL void* BrotliAllocate(MemoryManager* m, size_t n);
-#define BROTLI_ALLOC(M, T, N)                               \
-  ((N) > 0 ? ((T*)BrotliAllocate((M), (N) * sizeof(T))) : NULL)
-
-BROTLI_INTERNAL void BrotliFree(MemoryManager* m, void* p);
-#define BROTLI_FREE(M, P) { \
-  BrotliFree((M), (P));     \
-  P = NULL;                 \
-}
-
-#if defined(BROTLI_ENCODER_EXIT_ON_OOM)
-#define BROTLI_IS_OOM(M) (!!0)
-#else  /* BROTLI_ENCODER_EXIT_ON_OOM */
-#define BROTLI_IS_OOM(M) (!!(M)->is_oom)
-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
-
-/*
-BROTLI_IS_NULL is a fake check, BROTLI_IS_OOM does the heavy lifting.
-The only purpose of it is to explain static analyzers the state of things.
-NB: use ONLY together with BROTLI_IS_OOM
-    AND ONLY for allocations in the current scope.
- */
-#if defined(__clang_analyzer__) && !defined(BROTLI_ENCODER_EXIT_ON_OOM)
-#define BROTLI_IS_NULL(A) ((A) == nullptr)
-#else  /* defined(__clang_analyzer__) */
-#define BROTLI_IS_NULL(A) (!!0)
-#endif  /* defined(__clang_analyzer__) */
-
-BROTLI_INTERNAL void BrotliWipeOutMemoryManager(MemoryManager* m);
-
-/*
-Dynamically grows array capacity to at least the requested size
-M: MemoryManager
-T: data type
-A: array
-C: capacity
-R: requested size
-*/
-#define BROTLI_ENSURE_CAPACITY(M, T, A, C, R) {                    \
-  if (C < (R)) {                                                   \
-    size_t _new_size = (C == 0) ? (R) : C;                         \
-    T* new_array;                                                  \
-    while (_new_size < (R)) _new_size *= 2;                        \
-    new_array = BROTLI_ALLOC((M), T, _new_size);                   \
-    if (!BROTLI_IS_OOM(M) && !BROTLI_IS_NULL(new_array) && C != 0) \
-      memcpy(new_array, A, C * sizeof(T));                         \
-    BROTLI_FREE((M), A);                                           \
-    A = new_array;                                                 \
-    C = _new_size;                                                 \
-  }                                                                \
-}
-
-/*
-Appends value and dynamically grows array capacity when needed
-M: MemoryManager
-T: data type
-A: array
-C: array capacity
-S: array size
-V: value to append
-*/
-#define BROTLI_ENSURE_CAPACITY_APPEND(M, T, A, C, S, V) { \
-  (S)++;                                                  \
-  BROTLI_ENSURE_CAPACITY(M, T, A, C, S);                  \
-  A[(S) - 1] = (V);                                       \
-}
-
-/* "Bootstrap" allocations are not tracked by memory manager; should be used
-   only to allocate MemoryManager itself (or structure containing it). */
-BROTLI_INTERNAL void* BrotliBootstrapAlloc(size_t size,
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
-BROTLI_INTERNAL void BrotliBootstrapFree(void* address, MemoryManager* m);
-
-}
-
-#endif  /* BROTLI_ENC_MEMORY_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/metablock.cpp b/src/duckdb/third_party/brotli/enc/metablock.cpp
deleted file mode 100644
index a5758c24e..000000000
--- a/src/duckdb/third_party/brotli/enc/metablock.cpp
+++ /dev/null
@@ -1,1225 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Algorithms for distributing the literals and commands of a metablock between
-   block types and contexts. */
-
-#include "metablock.h"
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/context.h"
-#include "../common/brotli_platform.h"
-#include "bit_cost.h"
-#include "block_splitter.h"
-#include "cluster.h"
-#include "entropy_encode.h"
-#include "histogram.h"
-#include "memory.h"
-#include "quality.h"
-
-using namespace duckdb_brotli;
-
-void duckdb_brotli::BrotliInitDistanceParams(BrotliDistanceParams* dist_params,
-    uint32_t npostfix, uint32_t ndirect, BROTLI_BOOL large_window) {
-  uint32_t alphabet_size_max;
-  uint32_t alphabet_size_limit;
-  uint32_t max_distance;
-
-  dist_params->distance_postfix_bits = npostfix;
-  dist_params->num_direct_distance_codes = ndirect;
-
-  alphabet_size_max = BROTLI_DISTANCE_ALPHABET_SIZE(
-      npostfix, ndirect, BROTLI_MAX_DISTANCE_BITS);
-  alphabet_size_limit = alphabet_size_max;
-  max_distance = ndirect + (1U << (BROTLI_MAX_DISTANCE_BITS + npostfix + 2)) -
-      (1U << (npostfix + 2));
-
-  if (large_window) {
-    BrotliDistanceCodeLimit limit = BrotliCalculateDistanceCodeLimit(
-        BROTLI_MAX_ALLOWED_DISTANCE, npostfix, ndirect);
-    alphabet_size_max = BROTLI_DISTANCE_ALPHABET_SIZE(
-        npostfix, ndirect, BROTLI_LARGE_MAX_DISTANCE_BITS);
-    alphabet_size_limit = limit.max_alphabet_size;
-    max_distance = limit.max_distance;
-  }
-
-  dist_params->alphabet_size_max = alphabet_size_max;
-  dist_params->alphabet_size_limit = alphabet_size_limit;
-  dist_params->max_distance = max_distance;
-}
-
-static void RecomputeDistancePrefixes(Command* cmds,
-                                      size_t num_commands,
-                                      const BrotliDistanceParams* orig_params,
-                                      const BrotliDistanceParams* new_params) {
-  size_t i;
-
-  if (orig_params->distance_postfix_bits == new_params->distance_postfix_bits &&
-      orig_params->num_direct_distance_codes ==
-      new_params->num_direct_distance_codes) {
-    return;
-  }
-
-  for (i = 0; i < num_commands; ++i) {
-    Command* cmd = &cmds[i];
-    if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
-      PrefixEncodeCopyDistance(CommandRestoreDistanceCode(cmd, orig_params),
-                               new_params->num_direct_distance_codes,
-                               new_params->distance_postfix_bits,
-                               &cmd->dist_prefix_,
-                               &cmd->dist_extra_);
-    }
-  }
-}
-
-static BROTLI_BOOL ComputeDistanceCost(const Command* cmds,
-                                       size_t num_commands,
-                                       const BrotliDistanceParams* orig_params,
-                                       const BrotliDistanceParams* new_params,
-                                       double* cost,
-                                       HistogramDistance* tmp) {
-  size_t i;
-  BROTLI_BOOL equal_params = BROTLI_FALSE;
-  uint16_t dist_prefix;
-  uint32_t dist_extra;
-  double extra_bits = 0.0;
-  HistogramClearDistance(tmp);
-
-  if (orig_params->distance_postfix_bits == new_params->distance_postfix_bits &&
-      orig_params->num_direct_distance_codes ==
-      new_params->num_direct_distance_codes) {
-    equal_params = BROTLI_TRUE;
-  }
-
-  for (i = 0; i < num_commands; i++) {
-    const Command* cmd = &cmds[i];
-    if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
-      if (equal_params) {
-        dist_prefix = cmd->dist_prefix_;
-      } else {
-        uint32_t distance = CommandRestoreDistanceCode(cmd, orig_params);
-        if (distance > new_params->max_distance) {
-          return BROTLI_FALSE;
-        }
-        PrefixEncodeCopyDistance(distance,
-                                 new_params->num_direct_distance_codes,
-                                 new_params->distance_postfix_bits,
-                                 &dist_prefix,
-                                 &dist_extra);
-      }
-      HistogramAddDistance(tmp, dist_prefix & 0x3FF);
-      extra_bits += dist_prefix >> 10;
-    }
-  }
-
-  *cost = BrotliPopulationCostDistance(tmp) + extra_bits;
-  return BROTLI_TRUE;
-}
-
-void duckdb_brotli::BrotliBuildMetaBlock(MemoryManager* m,
-                          const uint8_t* ringbuffer,
-                          const size_t pos,
-                          const size_t mask,
-                          BrotliEncoderParams* params,
-                          uint8_t prev_byte,
-                          uint8_t prev_byte2,
-                          Command* cmds,
-                          size_t num_commands,
-                          ContextType literal_context_mode,
-                          MetaBlockSplit* mb) {
-  /* Histogram ids need to fit in one byte. */
-  static const size_t kMaxNumberOfHistograms = 256;
-  HistogramDistance* distance_histograms;
-  HistogramLiteral* literal_histograms;
-  ContextType* literal_context_modes = NULL;
-  size_t literal_histograms_size;
-  size_t distance_histograms_size;
-  size_t i;
-  size_t literal_context_multiplier = 1;
-  uint32_t npostfix;
-  uint32_t ndirect_msb = 0;
-  BROTLI_BOOL check_orig = BROTLI_TRUE;
-  double best_dist_cost = 1e99;
-  BrotliDistanceParams orig_params = params->dist;
-  BrotliDistanceParams new_params = params->dist;
-  HistogramDistance* tmp = BROTLI_ALLOC(m, HistogramDistance, 1);
-
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return;
-
-  for (npostfix = 0; npostfix <= BROTLI_MAX_NPOSTFIX; npostfix++) {
-    for (; ndirect_msb < 16; ndirect_msb++) {
-      uint32_t ndirect = ndirect_msb << npostfix;
-      BROTLI_BOOL skip;
-      double dist_cost;
-      BrotliInitDistanceParams(&new_params, npostfix, ndirect,
-                               params->large_window);
-      if (npostfix == orig_params.distance_postfix_bits &&
-          ndirect == orig_params.num_direct_distance_codes) {
-        check_orig = BROTLI_FALSE;
-      }
-      skip = !ComputeDistanceCost(
-          cmds, num_commands, &orig_params, &new_params, &dist_cost, tmp);
-      if (skip || (dist_cost > best_dist_cost)) {
-        break;
-      }
-      best_dist_cost = dist_cost;
-      params->dist = new_params;
-    }
-    if (ndirect_msb > 0) ndirect_msb--;
-    ndirect_msb /= 2;
-  }
-  if (check_orig) {
-    double dist_cost;
-    ComputeDistanceCost(cmds, num_commands, &orig_params, &orig_params,
-                        &dist_cost, tmp);
-    if (dist_cost < best_dist_cost) {
-      /* NB: currently unused; uncomment when more param tuning is added. */
-      /* best_dist_cost = dist_cost; */
-      params->dist = orig_params;
-    }
-  }
-  BROTLI_FREE(m, tmp);
-  RecomputeDistancePrefixes(cmds, num_commands, &orig_params, &params->dist);
-
-  BrotliSplitBlock(m, cmds, num_commands,
-                   ringbuffer, pos, mask, params,
-                   &mb->literal_split,
-                   &mb->command_split,
-                   &mb->distance_split);
-  if (BROTLI_IS_OOM(m)) return;
-
-  if (!params->disable_literal_context_modeling) {
-    literal_context_multiplier = 1 << BROTLI_LITERAL_CONTEXT_BITS;
-    literal_context_modes =
-        BROTLI_ALLOC(m, ContextType, mb->literal_split.num_types);
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literal_context_modes)) return;
-    for (i = 0; i < mb->literal_split.num_types; ++i) {
-      literal_context_modes[i] = literal_context_mode;
-    }
-  }
-
-  literal_histograms_size =
-      mb->literal_split.num_types * literal_context_multiplier;
-  literal_histograms =
-      BROTLI_ALLOC(m, HistogramLiteral, literal_histograms_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literal_histograms)) return;
-  ClearHistogramsLiteral(literal_histograms, literal_histograms_size);
-
-  distance_histograms_size =
-      mb->distance_split.num_types << BROTLI_DISTANCE_CONTEXT_BITS;
-  distance_histograms =
-      BROTLI_ALLOC(m, HistogramDistance, distance_histograms_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(distance_histograms)) return;
-  ClearHistogramsDistance(distance_histograms, distance_histograms_size);
-
-  BROTLI_DCHECK(mb->command_histograms == 0);
-  mb->command_histograms_size = mb->command_split.num_types;
-  mb->command_histograms =
-      BROTLI_ALLOC(m, HistogramCommand, mb->command_histograms_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->command_histograms)) return;
-  ClearHistogramsCommand(mb->command_histograms, mb->command_histograms_size);
-
-  BrotliBuildHistogramsWithContext(cmds, num_commands,
-      &mb->literal_split, &mb->command_split, &mb->distance_split,
-      ringbuffer, pos, mask, prev_byte, prev_byte2, literal_context_modes,
-      literal_histograms, mb->command_histograms, distance_histograms);
-  BROTLI_FREE(m, literal_context_modes);
-
-  BROTLI_DCHECK(mb->literal_context_map == 0);
-  mb->literal_context_map_size =
-      mb->literal_split.num_types << BROTLI_LITERAL_CONTEXT_BITS;
-  mb->literal_context_map =
-      BROTLI_ALLOC(m, uint32_t, mb->literal_context_map_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->literal_context_map)) return;
-
-  BROTLI_DCHECK(mb->literal_histograms == 0);
-  mb->literal_histograms_size = mb->literal_context_map_size;
-  mb->literal_histograms =
-      BROTLI_ALLOC(m, HistogramLiteral, mb->literal_histograms_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->literal_histograms)) return;
-
-  BrotliClusterHistogramsLiteral(m, literal_histograms, literal_histograms_size,
-      kMaxNumberOfHistograms, mb->literal_histograms,
-      &mb->literal_histograms_size, mb->literal_context_map);
-  if (BROTLI_IS_OOM(m)) return;
-  BROTLI_FREE(m, literal_histograms);
-
-  if (params->disable_literal_context_modeling) {
-    /* Distribute assignment to all contexts. */
-    for (i = mb->literal_split.num_types; i != 0;) {
-      size_t j = 0;
-      i--;
-      for (; j < (1 << BROTLI_LITERAL_CONTEXT_BITS); j++) {
-        mb->literal_context_map[(i << BROTLI_LITERAL_CONTEXT_BITS) + j] =
-            mb->literal_context_map[i];
-      }
-    }
-  }
-
-  BROTLI_DCHECK(mb->distance_context_map == 0);
-  mb->distance_context_map_size =
-      mb->distance_split.num_types << BROTLI_DISTANCE_CONTEXT_BITS;
-  mb->distance_context_map =
-      BROTLI_ALLOC(m, uint32_t, mb->distance_context_map_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->distance_context_map)) return;
-
-  BROTLI_DCHECK(mb->distance_histograms == 0);
-  mb->distance_histograms_size = mb->distance_context_map_size;
-  mb->distance_histograms =
-      BROTLI_ALLOC(m, HistogramDistance, mb->distance_histograms_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->distance_histograms)) return;
-
-  BrotliClusterHistogramsDistance(m, distance_histograms,
-                                  mb->distance_context_map_size,
-                                  kMaxNumberOfHistograms,
-                                  mb->distance_histograms,
-                                  &mb->distance_histograms_size,
-                                  mb->distance_context_map);
-  if (BROTLI_IS_OOM(m)) return;
-  BROTLI_FREE(m, distance_histograms);
-}
-
-#define FN(X) X ## Literal
-/* NOLINT(build/header_guard) */
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-/* Greedy block splitter for one block category (literal, command or distance).
-*/
-typedef struct FN(BlockSplitter) {
-  /* Alphabet size of particular block category. */
-  size_t alphabet_size_;
-  /* We collect at least this many symbols for each block. */
-  size_t min_block_size_;
-  /* We merge histograms A and B if
-       entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
-     where A is the current histogram and B is the histogram of the last or the
-     second last block type. */
-  double split_threshold_;
-
-  size_t num_blocks_;
-  BlockSplit* split_;  /* not owned */
-  HistogramType* histograms_;  /* not owned */
-  size_t* histograms_size_;  /* not owned */
-
-  /* Temporary storage for BlockSplitterFinishBlock. */
-  HistogramType combined_histo[2];
-
-  /* The number of symbols that we want to collect before deciding on whether
-     or not to merge the block with a previous one or emit a new block. */
-  size_t target_block_size_;
-  /* The number of symbols in the current histogram. */
-  size_t block_size_;
-  /* Offset of the current histogram. */
-  size_t curr_histogram_ix_;
-  /* Offset of the histograms of the previous two block types. */
-  size_t last_histogram_ix_[2];
-  /* Entropy of the previous two block types. */
-  double last_entropy_[2];
-  /* The number of times we merged the current block with the last one. */
-  size_t merge_last_count_;
-} FN(BlockSplitter);
-
-static void FN(InitBlockSplitter)(
-    MemoryManager* m, FN(BlockSplitter)* self, size_t alphabet_size,
-    size_t min_block_size, double split_threshold, size_t num_symbols,
-    BlockSplit* split, HistogramType** histograms, size_t* histograms_size) {
-  size_t max_num_blocks = num_symbols / min_block_size + 1;
-  /* We have to allocate one more histogram than the maximum number of block
-     types for the current histogram when the meta-block is too big. */
-  size_t max_num_types =
-      BROTLI_MIN(size_t, max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 1);
-  self->alphabet_size_ = alphabet_size;
-  self->min_block_size_ = min_block_size;
-  self->split_threshold_ = split_threshold;
-  self->num_blocks_ = 0;
-  self->split_ = split;
-  self->histograms_size_ = histograms_size;
-  self->target_block_size_ = min_block_size;
-  self->block_size_ = 0;
-  self->curr_histogram_ix_ = 0;
-  self->merge_last_count_ = 0;
-  BROTLI_ENSURE_CAPACITY(m, uint8_t,
-      split->types, split->types_alloc_size, max_num_blocks);
-  BROTLI_ENSURE_CAPACITY(m, uint32_t,
-      split->lengths, split->lengths_alloc_size, max_num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-  self->split_->num_blocks = max_num_blocks;
-  BROTLI_DCHECK(*histograms == 0);
-  *histograms_size = max_num_types;
-  *histograms = BROTLI_ALLOC(m, HistogramType, *histograms_size);
-  self->histograms_ = *histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(*histograms)) return;
-  /* Clear only current histogram. */
-  FN(HistogramClear)(&self->histograms_[0]);
-  self->last_histogram_ix_[0] = self->last_histogram_ix_[1] = 0;
-}
-
-/* Does either of three things:
-     (1) emits the current block with a new block type;
-     (2) emits the current block with the type of the second last block;
-     (3) merges the current block with the last block. */
-static void FN(BlockSplitterFinishBlock)(
-    FN(BlockSplitter)* self, BROTLI_BOOL is_final) {
-  BlockSplit* split = self->split_;
-  double* last_entropy = self->last_entropy_;
-  HistogramType* histograms = self->histograms_;
-  self->block_size_ =
-      BROTLI_MAX(size_t, self->block_size_, self->min_block_size_);
-  if (self->num_blocks_ == 0) {
-    /* Create first block. */
-    split->lengths[0] = (uint32_t)self->block_size_;
-    split->types[0] = 0;
-    last_entropy[0] =
-        BitsEntropy(histograms[0].data_, self->alphabet_size_);
-    last_entropy[1] = last_entropy[0];
-    ++self->num_blocks_;
-    ++split->num_types;
-    ++self->curr_histogram_ix_;
-    if (self->curr_histogram_ix_ < *self->histograms_size_)
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-    self->block_size_ = 0;
-  } else if (self->block_size_ > 0) {
-    double entropy = BitsEntropy(histograms[self->curr_histogram_ix_].data_,
-                                 self->alphabet_size_);
-    double combined_entropy[2];
-    double diff[2];
-    size_t j;
-    for (j = 0; j < 2; ++j) {
-      size_t last_histogram_ix = self->last_histogram_ix_[j];
-      self->combined_histo[j] = histograms[self->curr_histogram_ix_];
-      FN(HistogramAddHistogram)(&self->combined_histo[j],
-          &histograms[last_histogram_ix]);
-      combined_entropy[j] = BitsEntropy(
-          &self->combined_histo[j].data_[0], self->alphabet_size_);
-      diff[j] = combined_entropy[j] - entropy - last_entropy[j];
-    }
-
-    if (split->num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES &&
-        diff[0] > self->split_threshold_ &&
-        diff[1] > self->split_threshold_) {
-      /* Create new block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = (uint8_t)split->num_types;
-      self->last_histogram_ix_[1] = self->last_histogram_ix_[0];
-      self->last_histogram_ix_[0] = (uint8_t)split->num_types;
-      last_entropy[1] = last_entropy[0];
-      last_entropy[0] = entropy;
-      ++self->num_blocks_;
-      ++split->num_types;
-      ++self->curr_histogram_ix_;
-      if (self->curr_histogram_ix_ < *self->histograms_size_)
-        FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      self->block_size_ = 0;
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else if (diff[1] < diff[0] - 20.0) {
-      /* Combine this block with second last block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = split->types[self->num_blocks_ - 2];
-      BROTLI_SWAP(size_t, self->last_histogram_ix_, 0, 1);
-      histograms[self->last_histogram_ix_[0]] = self->combined_histo[1];
-      last_entropy[1] = last_entropy[0];
-      last_entropy[0] = combined_entropy[1];
-      ++self->num_blocks_;
-      self->block_size_ = 0;
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else {
-      /* Combine this block with last block. */
-      split->lengths[self->num_blocks_ - 1] += (uint32_t)self->block_size_;
-      histograms[self->last_histogram_ix_[0]] = self->combined_histo[0];
-      last_entropy[0] = combined_entropy[0];
-      if (split->num_types == 1) {
-        last_entropy[1] = last_entropy[0];
-      }
-      self->block_size_ = 0;
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      if (++self->merge_last_count_ > 1) {
-        self->target_block_size_ += self->min_block_size_;
-      }
-    }
-  }
-  if (is_final) {
-    *self->histograms_size_ = split->num_types;
-    split->num_blocks = self->num_blocks_;
-  }
-}
-
-/* Adds the next symbol to the current histogram. When the current histogram
-   reaches the target size, decides on merging the block. */
-static void FN(BlockSplitterAddSymbol)(FN(BlockSplitter)* self, size_t symbol) {
-  FN(HistogramAdd)(&self->histograms_[self->curr_histogram_ix_], symbol);
-  ++self->block_size_;
-  if (self->block_size_ == self->target_block_size_) {
-    FN(BlockSplitterFinishBlock)(self, /* is_final = */ BROTLI_FALSE);
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Command
-/* NOLINT(build/header_guard) */
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-/* Greedy block splitter for one block category (literal, command or distance).
-*/
-typedef struct FN(BlockSplitter) {
-  /* Alphabet size of particular block category. */
-  size_t alphabet_size_;
-  /* We collect at least this many symbols for each block. */
-  size_t min_block_size_;
-  /* We merge histograms A and B if
-       entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
-     where A is the current histogram and B is the histogram of the last or the
-     second last block type. */
-  double split_threshold_;
-
-  size_t num_blocks_;
-  BlockSplit* split_;  /* not owned */
-  HistogramType* histograms_;  /* not owned */
-  size_t* histograms_size_;  /* not owned */
-
-  /* Temporary storage for BlockSplitterFinishBlock. */
-  HistogramType combined_histo[2];
-
-  /* The number of symbols that we want to collect before deciding on whether
-     or not to merge the block with a previous one or emit a new block. */
-  size_t target_block_size_;
-  /* The number of symbols in the current histogram. */
-  size_t block_size_;
-  /* Offset of the current histogram. */
-  size_t curr_histogram_ix_;
-  /* Offset of the histograms of the previous two block types. */
-  size_t last_histogram_ix_[2];
-  /* Entropy of the previous two block types. */
-  double last_entropy_[2];
-  /* The number of times we merged the current block with the last one. */
-  size_t merge_last_count_;
-} FN(BlockSplitter);
-
-static void FN(InitBlockSplitter)(
-    MemoryManager* m, FN(BlockSplitter)* self, size_t alphabet_size,
-    size_t min_block_size, double split_threshold, size_t num_symbols,
-    BlockSplit* split, HistogramType** histograms, size_t* histograms_size) {
-  size_t max_num_blocks = num_symbols / min_block_size + 1;
-  /* We have to allocate one more histogram than the maximum number of block
-     types for the current histogram when the meta-block is too big. */
-  size_t max_num_types =
-      BROTLI_MIN(size_t, max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 1);
-  self->alphabet_size_ = alphabet_size;
-  self->min_block_size_ = min_block_size;
-  self->split_threshold_ = split_threshold;
-  self->num_blocks_ = 0;
-  self->split_ = split;
-  self->histograms_size_ = histograms_size;
-  self->target_block_size_ = min_block_size;
-  self->block_size_ = 0;
-  self->curr_histogram_ix_ = 0;
-  self->merge_last_count_ = 0;
-  BROTLI_ENSURE_CAPACITY(m, uint8_t,
-      split->types, split->types_alloc_size, max_num_blocks);
-  BROTLI_ENSURE_CAPACITY(m, uint32_t,
-      split->lengths, split->lengths_alloc_size, max_num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-  self->split_->num_blocks = max_num_blocks;
-  BROTLI_DCHECK(*histograms == 0);
-  *histograms_size = max_num_types;
-  *histograms = BROTLI_ALLOC(m, HistogramType, *histograms_size);
-  self->histograms_ = *histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(*histograms)) return;
-  /* Clear only current histogram. */
-  FN(HistogramClear)(&self->histograms_[0]);
-  self->last_histogram_ix_[0] = self->last_histogram_ix_[1] = 0;
-}
-
-/* Does either of three things:
-     (1) emits the current block with a new block type;
-     (2) emits the current block with the type of the second last block;
-     (3) merges the current block with the last block. */
-static void FN(BlockSplitterFinishBlock)(
-    FN(BlockSplitter)* self, BROTLI_BOOL is_final) {
-  BlockSplit* split = self->split_;
-  double* last_entropy = self->last_entropy_;
-  HistogramType* histograms = self->histograms_;
-  self->block_size_ =
-      BROTLI_MAX(size_t, self->block_size_, self->min_block_size_);
-  if (self->num_blocks_ == 0) {
-    /* Create first block. */
-    split->lengths[0] = (uint32_t)self->block_size_;
-    split->types[0] = 0;
-    last_entropy[0] =
-        BitsEntropy(histograms[0].data_, self->alphabet_size_);
-    last_entropy[1] = last_entropy[0];
-    ++self->num_blocks_;
-    ++split->num_types;
-    ++self->curr_histogram_ix_;
-    if (self->curr_histogram_ix_ < *self->histograms_size_)
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-    self->block_size_ = 0;
-  } else if (self->block_size_ > 0) {
-    double entropy = BitsEntropy(histograms[self->curr_histogram_ix_].data_,
-                                 self->alphabet_size_);
-    double combined_entropy[2];
-    double diff[2];
-    size_t j;
-    for (j = 0; j < 2; ++j) {
-      size_t last_histogram_ix = self->last_histogram_ix_[j];
-      self->combined_histo[j] = histograms[self->curr_histogram_ix_];
-      FN(HistogramAddHistogram)(&self->combined_histo[j],
-          &histograms[last_histogram_ix]);
-      combined_entropy[j] = BitsEntropy(
-          &self->combined_histo[j].data_[0], self->alphabet_size_);
-      diff[j] = combined_entropy[j] - entropy - last_entropy[j];
-    }
-
-    if (split->num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES &&
-        diff[0] > self->split_threshold_ &&
-        diff[1] > self->split_threshold_) {
-      /* Create new block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = (uint8_t)split->num_types;
-      self->last_histogram_ix_[1] = self->last_histogram_ix_[0];
-      self->last_histogram_ix_[0] = (uint8_t)split->num_types;
-      last_entropy[1] = last_entropy[0];
-      last_entropy[0] = entropy;
-      ++self->num_blocks_;
-      ++split->num_types;
-      ++self->curr_histogram_ix_;
-      if (self->curr_histogram_ix_ < *self->histograms_size_)
-        FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      self->block_size_ = 0;
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else if (diff[1] < diff[0] - 20.0) {
-      /* Combine this block with second last block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = split->types[self->num_blocks_ - 2];
-      BROTLI_SWAP(size_t, self->last_histogram_ix_, 0, 1);
-      histograms[self->last_histogram_ix_[0]] = self->combined_histo[1];
-      last_entropy[1] = last_entropy[0];
-      last_entropy[0] = combined_entropy[1];
-      ++self->num_blocks_;
-      self->block_size_ = 0;
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else {
-      /* Combine this block with last block. */
-      split->lengths[self->num_blocks_ - 1] += (uint32_t)self->block_size_;
-      histograms[self->last_histogram_ix_[0]] = self->combined_histo[0];
-      last_entropy[0] = combined_entropy[0];
-      if (split->num_types == 1) {
-        last_entropy[1] = last_entropy[0];
-      }
-      self->block_size_ = 0;
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      if (++self->merge_last_count_ > 1) {
-        self->target_block_size_ += self->min_block_size_;
-      }
-    }
-  }
-  if (is_final) {
-    *self->histograms_size_ = split->num_types;
-    split->num_blocks = self->num_blocks_;
-  }
-}
-
-/* Adds the next symbol to the current histogram. When the current histogram
-   reaches the target size, decides on merging the block. */
-static void FN(BlockSplitterAddSymbol)(FN(BlockSplitter)* self, size_t symbol) {
-  FN(HistogramAdd)(&self->histograms_[self->curr_histogram_ix_], symbol);
-  ++self->block_size_;
-  if (self->block_size_ == self->target_block_size_) {
-    FN(BlockSplitterFinishBlock)(self, /* is_final = */ BROTLI_FALSE);
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-#define FN(X) X ## Distance
-/* NOLINT(build/header_guard) */
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* template parameters: FN */
-
-#define HistogramType FN(Histogram)
-
-/* Greedy block splitter for one block category (literal, command or distance).
-*/
-typedef struct FN(BlockSplitter) {
-  /* Alphabet size of particular block category. */
-  size_t alphabet_size_;
-  /* We collect at least this many symbols for each block. */
-  size_t min_block_size_;
-  /* We merge histograms A and B if
-       entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
-     where A is the current histogram and B is the histogram of the last or the
-     second last block type. */
-  double split_threshold_;
-
-  size_t num_blocks_;
-  BlockSplit* split_;  /* not owned */
-  HistogramType* histograms_;  /* not owned */
-  size_t* histograms_size_;  /* not owned */
-
-  /* Temporary storage for BlockSplitterFinishBlock. */
-  HistogramType combined_histo[2];
-
-  /* The number of symbols that we want to collect before deciding on whether
-     or not to merge the block with a previous one or emit a new block. */
-  size_t target_block_size_;
-  /* The number of symbols in the current histogram. */
-  size_t block_size_;
-  /* Offset of the current histogram. */
-  size_t curr_histogram_ix_;
-  /* Offset of the histograms of the previous two block types. */
-  size_t last_histogram_ix_[2];
-  /* Entropy of the previous two block types. */
-  double last_entropy_[2];
-  /* The number of times we merged the current block with the last one. */
-  size_t merge_last_count_;
-} FN(BlockSplitter);
-
-static void FN(InitBlockSplitter)(
-    MemoryManager* m, FN(BlockSplitter)* self, size_t alphabet_size,
-    size_t min_block_size, double split_threshold, size_t num_symbols,
-    BlockSplit* split, HistogramType** histograms, size_t* histograms_size) {
-  size_t max_num_blocks = num_symbols / min_block_size + 1;
-  /* We have to allocate one more histogram than the maximum number of block
-     types for the current histogram when the meta-block is too big. */
-  size_t max_num_types =
-      BROTLI_MIN(size_t, max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 1);
-  self->alphabet_size_ = alphabet_size;
-  self->min_block_size_ = min_block_size;
-  self->split_threshold_ = split_threshold;
-  self->num_blocks_ = 0;
-  self->split_ = split;
-  self->histograms_size_ = histograms_size;
-  self->target_block_size_ = min_block_size;
-  self->block_size_ = 0;
-  self->curr_histogram_ix_ = 0;
-  self->merge_last_count_ = 0;
-  BROTLI_ENSURE_CAPACITY(m, uint8_t,
-      split->types, split->types_alloc_size, max_num_blocks);
-  BROTLI_ENSURE_CAPACITY(m, uint32_t,
-      split->lengths, split->lengths_alloc_size, max_num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-  self->split_->num_blocks = max_num_blocks;
-  BROTLI_DCHECK(*histograms == 0);
-  *histograms_size = max_num_types;
-  *histograms = BROTLI_ALLOC(m, HistogramType, *histograms_size);
-  self->histograms_ = *histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(*histograms)) return;
-  /* Clear only current histogram. */
-  FN(HistogramClear)(&self->histograms_[0]);
-  self->last_histogram_ix_[0] = self->last_histogram_ix_[1] = 0;
-}
-
-/* Does either of three things:
-     (1) emits the current block with a new block type;
-     (2) emits the current block with the type of the second last block;
-     (3) merges the current block with the last block. */
-static void FN(BlockSplitterFinishBlock)(
-    FN(BlockSplitter)* self, BROTLI_BOOL is_final) {
-  BlockSplit* split = self->split_;
-  double* last_entropy = self->last_entropy_;
-  HistogramType* histograms = self->histograms_;
-  self->block_size_ =
-      BROTLI_MAX(size_t, self->block_size_, self->min_block_size_);
-  if (self->num_blocks_ == 0) {
-    /* Create first block. */
-    split->lengths[0] = (uint32_t)self->block_size_;
-    split->types[0] = 0;
-    last_entropy[0] =
-        BitsEntropy(histograms[0].data_, self->alphabet_size_);
-    last_entropy[1] = last_entropy[0];
-    ++self->num_blocks_;
-    ++split->num_types;
-    ++self->curr_histogram_ix_;
-    if (self->curr_histogram_ix_ < *self->histograms_size_)
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-    self->block_size_ = 0;
-  } else if (self->block_size_ > 0) {
-    double entropy = BitsEntropy(histograms[self->curr_histogram_ix_].data_,
-                                 self->alphabet_size_);
-    double combined_entropy[2];
-    double diff[2];
-    size_t j;
-    for (j = 0; j < 2; ++j) {
-      size_t last_histogram_ix = self->last_histogram_ix_[j];
-      self->combined_histo[j] = histograms[self->curr_histogram_ix_];
-      FN(HistogramAddHistogram)(&self->combined_histo[j],
-          &histograms[last_histogram_ix]);
-      combined_entropy[j] = BitsEntropy(
-          &self->combined_histo[j].data_[0], self->alphabet_size_);
-      diff[j] = combined_entropy[j] - entropy - last_entropy[j];
-    }
-
-    if (split->num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES &&
-        diff[0] > self->split_threshold_ &&
-        diff[1] > self->split_threshold_) {
-      /* Create new block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = (uint8_t)split->num_types;
-      self->last_histogram_ix_[1] = self->last_histogram_ix_[0];
-      self->last_histogram_ix_[0] = (uint8_t)split->num_types;
-      last_entropy[1] = last_entropy[0];
-      last_entropy[0] = entropy;
-      ++self->num_blocks_;
-      ++split->num_types;
-      ++self->curr_histogram_ix_;
-      if (self->curr_histogram_ix_ < *self->histograms_size_)
-        FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      self->block_size_ = 0;
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else if (diff[1] < diff[0] - 20.0) {
-      /* Combine this block with second last block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = split->types[self->num_blocks_ - 2];
-      BROTLI_SWAP(size_t, self->last_histogram_ix_, 0, 1);
-      histograms[self->last_histogram_ix_[0]] = self->combined_histo[1];
-      last_entropy[1] = last_entropy[0];
-      last_entropy[0] = combined_entropy[1];
-      ++self->num_blocks_;
-      self->block_size_ = 0;
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else {
-      /* Combine this block with last block. */
-      split->lengths[self->num_blocks_ - 1] += (uint32_t)self->block_size_;
-      histograms[self->last_histogram_ix_[0]] = self->combined_histo[0];
-      last_entropy[0] = combined_entropy[0];
-      if (split->num_types == 1) {
-        last_entropy[1] = last_entropy[0];
-      }
-      self->block_size_ = 0;
-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
-      if (++self->merge_last_count_ > 1) {
-        self->target_block_size_ += self->min_block_size_;
-      }
-    }
-  }
-  if (is_final) {
-    *self->histograms_size_ = split->num_types;
-    split->num_blocks = self->num_blocks_;
-  }
-}
-
-/* Adds the next symbol to the current histogram. When the current histogram
-   reaches the target size, decides on merging the block. */
-static void FN(BlockSplitterAddSymbol)(FN(BlockSplitter)* self, size_t symbol) {
-  FN(HistogramAdd)(&self->histograms_[self->curr_histogram_ix_], symbol);
-  ++self->block_size_;
-  if (self->block_size_ == self->target_block_size_) {
-    FN(BlockSplitterFinishBlock)(self, /* is_final = */ BROTLI_FALSE);
-  }
-}
-
-#undef HistogramType
-#undef FN
-
-#define BROTLI_MAX_STATIC_CONTEXTS 13
-
-/* Greedy block splitter for one block category (literal, command or distance).
-   Gathers histograms for all context buckets. */
-typedef struct ContextBlockSplitter {
-  /* Alphabet size of particular block category. */
-  size_t alphabet_size_;
-  size_t num_contexts_;
-  size_t max_block_types_;
-  /* We collect at least this many symbols for each block. */
-  size_t min_block_size_;
-  /* We merge histograms A and B if
-       entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
-     where A is the current histogram and B is the histogram of the last or the
-     second last block type. */
-  double split_threshold_;
-
-  size_t num_blocks_;
-  BlockSplit* split_;  /* not owned */
-  HistogramLiteral* histograms_;  /* not owned */
-  size_t* histograms_size_;  /* not owned */
-
-  /* The number of symbols that we want to collect before deciding on whether
-     or not to merge the block with a previous one or emit a new block. */
-  size_t target_block_size_;
-  /* The number of symbols in the current histogram. */
-  size_t block_size_;
-  /* Offset of the current histogram. */
-  size_t curr_histogram_ix_;
-  /* Offset of the histograms of the previous two block types. */
-  size_t last_histogram_ix_[2];
-  /* Entropy of the previous two block types. */
-  double last_entropy_[2 * BROTLI_MAX_STATIC_CONTEXTS];
-  /* The number of times we merged the current block with the last one. */
-  size_t merge_last_count_;
-} ContextBlockSplitter;
-
-static void InitContextBlockSplitter(
-    MemoryManager* m, ContextBlockSplitter* self, size_t alphabet_size,
-    size_t num_contexts, size_t min_block_size, double split_threshold,
-    size_t num_symbols, BlockSplit* split, HistogramLiteral** histograms,
-    size_t* histograms_size) {
-  size_t max_num_blocks = num_symbols / min_block_size + 1;
-  size_t max_num_types;
-  BROTLI_DCHECK(num_contexts <= BROTLI_MAX_STATIC_CONTEXTS);
-
-  self->alphabet_size_ = alphabet_size;
-  self->num_contexts_ = num_contexts;
-  self->max_block_types_ = BROTLI_MAX_NUMBER_OF_BLOCK_TYPES / num_contexts;
-  self->min_block_size_ = min_block_size;
-  self->split_threshold_ = split_threshold;
-  self->num_blocks_ = 0;
-  self->split_ = split;
-  self->histograms_size_ = histograms_size;
-  self->target_block_size_ = min_block_size;
-  self->block_size_ = 0;
-  self->curr_histogram_ix_ = 0;
-  self->merge_last_count_ = 0;
-
-  /* We have to allocate one more histogram than the maximum number of block
-     types for the current histogram when the meta-block is too big. */
-  max_num_types =
-      BROTLI_MIN(size_t, max_num_blocks, self->max_block_types_ + 1);
-  BROTLI_ENSURE_CAPACITY(m, uint8_t,
-      split->types, split->types_alloc_size, max_num_blocks);
-  BROTLI_ENSURE_CAPACITY(m, uint32_t,
-      split->lengths, split->lengths_alloc_size, max_num_blocks);
-  if (BROTLI_IS_OOM(m)) return;
-  split->num_blocks = max_num_blocks;
-  if (BROTLI_IS_OOM(m)) return;
-  BROTLI_DCHECK(*histograms == 0);
-  *histograms_size = max_num_types * num_contexts;
-  *histograms = BROTLI_ALLOC(m, HistogramLiteral, *histograms_size);
-  self->histograms_ = *histograms;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(*histograms)) return;
-  /* Clear only current histogram. */
-  ClearHistogramsLiteral(&self->histograms_[0], num_contexts);
-  self->last_histogram_ix_[0] = self->last_histogram_ix_[1] = 0;
-}
-
-/* Does either of three things:
-     (1) emits the current block with a new block type;
-     (2) emits the current block with the type of the second last block;
-     (3) merges the current block with the last block. */
-static void ContextBlockSplitterFinishBlock(
-    ContextBlockSplitter* self, MemoryManager* m, BROTLI_BOOL is_final) {
-  BlockSplit* split = self->split_;
-  const size_t num_contexts = self->num_contexts_;
-  double* last_entropy = self->last_entropy_;
-  HistogramLiteral* histograms = self->histograms_;
-
-  if (self->block_size_ < self->min_block_size_) {
-    self->block_size_ = self->min_block_size_;
-  }
-  if (self->num_blocks_ == 0) {
-    size_t i;
-    /* Create first block. */
-    split->lengths[0] = (uint32_t)self->block_size_;
-    split->types[0] = 0;
-
-    for (i = 0; i < num_contexts; ++i) {
-      last_entropy[i] =
-          BitsEntropy(histograms[i].data_, self->alphabet_size_);
-      last_entropy[num_contexts + i] = last_entropy[i];
-    }
-    ++self->num_blocks_;
-    ++split->num_types;
-    self->curr_histogram_ix_ += num_contexts;
-    if (self->curr_histogram_ix_ < *self->histograms_size_) {
-      ClearHistogramsLiteral(
-          &self->histograms_[self->curr_histogram_ix_], self->num_contexts_);
-    }
-    self->block_size_ = 0;
-  } else if (self->block_size_ > 0) {
-    /* Try merging the set of histograms for the current block type with the
-       respective set of histograms for the last and second last block types.
-       Decide over the split based on the total reduction of entropy across
-       all contexts. */
-    double entropy[BROTLI_MAX_STATIC_CONTEXTS];
-    HistogramLiteral* combined_histo =
-        BROTLI_ALLOC(m, HistogramLiteral, 2 * num_contexts);
-    double combined_entropy[2 * BROTLI_MAX_STATIC_CONTEXTS];
-    double diff[2] = { 0.0 };
-    size_t i;
-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(combined_histo)) return;
-    for (i = 0; i < num_contexts; ++i) {
-      size_t curr_histo_ix = self->curr_histogram_ix_ + i;
-      size_t j;
-      entropy[i] = BitsEntropy(histograms[curr_histo_ix].data_,
-                               self->alphabet_size_);
-      for (j = 0; j < 2; ++j) {
-        size_t jx = j * num_contexts + i;
-        size_t last_histogram_ix = self->last_histogram_ix_[j] + i;
-        combined_histo[jx] = histograms[curr_histo_ix];
-        HistogramAddHistogramLiteral(&combined_histo[jx],
-            &histograms[last_histogram_ix]);
-        combined_entropy[jx] = BitsEntropy(
-            &combined_histo[jx].data_[0], self->alphabet_size_);
-        diff[j] += combined_entropy[jx] - entropy[i] - last_entropy[jx];
-      }
-    }
-
-    if (split->num_types < self->max_block_types_ &&
-        diff[0] > self->split_threshold_ &&
-        diff[1] > self->split_threshold_) {
-      /* Create new block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = (uint8_t)split->num_types;
-      self->last_histogram_ix_[1] = self->last_histogram_ix_[0];
-      self->last_histogram_ix_[0] = split->num_types * num_contexts;
-      for (i = 0; i < num_contexts; ++i) {
-        last_entropy[num_contexts + i] = last_entropy[i];
-        last_entropy[i] = entropy[i];
-      }
-      ++self->num_blocks_;
-      ++split->num_types;
-      self->curr_histogram_ix_ += num_contexts;
-      if (self->curr_histogram_ix_ < *self->histograms_size_) {
-        ClearHistogramsLiteral(
-            &self->histograms_[self->curr_histogram_ix_], self->num_contexts_);
-      }
-      self->block_size_ = 0;
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else if (diff[1] < diff[0] - 20.0) {
-      /* Combine this block with second last block. */
-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
-      split->types[self->num_blocks_] = split->types[self->num_blocks_ - 2];
-      BROTLI_SWAP(size_t, self->last_histogram_ix_, 0, 1);
-      for (i = 0; i < num_contexts; ++i) {
-        histograms[self->last_histogram_ix_[0] + i] =
-            combined_histo[num_contexts + i];
-        last_entropy[num_contexts + i] = last_entropy[i];
-        last_entropy[i] = combined_entropy[num_contexts + i];
-        HistogramClearLiteral(&histograms[self->curr_histogram_ix_ + i]);
-      }
-      ++self->num_blocks_;
-      self->block_size_ = 0;
-      self->merge_last_count_ = 0;
-      self->target_block_size_ = self->min_block_size_;
-    } else {
-      /* Combine this block with last block. */
-      split->lengths[self->num_blocks_ - 1] += (uint32_t)self->block_size_;
-      for (i = 0; i < num_contexts; ++i) {
-        histograms[self->last_histogram_ix_[0] + i] = combined_histo[i];
-        last_entropy[i] = combined_entropy[i];
-        if (split->num_types == 1) {
-          last_entropy[num_contexts + i] = last_entropy[i];
-        }
-        HistogramClearLiteral(&histograms[self->curr_histogram_ix_ + i]);
-      }
-      self->block_size_ = 0;
-      if (++self->merge_last_count_ > 1) {
-        self->target_block_size_ += self->min_block_size_;
-      }
-    }
-    BROTLI_FREE(m, combined_histo);
-  }
-  if (is_final) {
-    *self->histograms_size_ = split->num_types * num_contexts;
-    split->num_blocks = self->num_blocks_;
-  }
-}
-
-/* Adds the next symbol to the current block type and context. When the
-   current block reaches the target size, decides on merging the block. */
-static void ContextBlockSplitterAddSymbol(
-    ContextBlockSplitter* self, MemoryManager* m,
-    size_t symbol, size_t context) {
-  HistogramAddLiteral(&self->histograms_[self->curr_histogram_ix_ + context],
-      symbol);
-  ++self->block_size_;
-  if (self->block_size_ == self->target_block_size_) {
-    ContextBlockSplitterFinishBlock(self, m, /* is_final = */ BROTLI_FALSE);
-    if (BROTLI_IS_OOM(m)) return;
-  }
-}
-
-static void MapStaticContexts(MemoryManager* m,
-                              size_t num_contexts,
-                              const uint32_t* static_context_map,
-                              MetaBlockSplit* mb) {
-  size_t i;
-  BROTLI_DCHECK(mb->literal_context_map == 0);
-  mb->literal_context_map_size =
-      mb->literal_split.num_types << BROTLI_LITERAL_CONTEXT_BITS;
-  mb->literal_context_map =
-      BROTLI_ALLOC(m, uint32_t, mb->literal_context_map_size);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->literal_context_map)) return;
-
-  for (i = 0; i < mb->literal_split.num_types; ++i) {
-    uint32_t offset = (uint32_t)(i * num_contexts);
-    size_t j;
-    for (j = 0; j < (1u << BROTLI_LITERAL_CONTEXT_BITS); ++j) {
-      mb->literal_context_map[(i << BROTLI_LITERAL_CONTEXT_BITS) + j] =
-          offset + static_context_map[j];
-    }
-  }
-}
-
-typedef struct GreedyMetablockArena {
-  union {
-    BlockSplitterLiteral plain;
-    ContextBlockSplitter ctx;
-  } lit_blocks;
-  BlockSplitterCommand cmd_blocks;
-  BlockSplitterDistance dist_blocks;
-} GreedyMetablockArena;
-
-static BROTLI_INLINE void BrotliBuildMetaBlockGreedyInternal(
-    MemoryManager* m, GreedyMetablockArena* arena, const uint8_t* ringbuffer,
-    size_t pos, size_t mask, uint8_t prev_byte, uint8_t prev_byte2,
-    ContextLut literal_context_lut, const size_t num_contexts,
-    const uint32_t* static_context_map, const Command* commands,
-    size_t n_commands, MetaBlockSplit* mb) {
-  size_t num_literals = 0;
-  size_t i;
-  for (i = 0; i < n_commands; ++i) {
-    num_literals += commands[i].insert_len_;
-  }
-
-  if (num_contexts == 1) {
-    InitBlockSplitterLiteral(m, &arena->lit_blocks.plain, 256, 512, 400.0,
-        num_literals, &mb->literal_split, &mb->literal_histograms,
-        &mb->literal_histograms_size);
-  } else {
-    InitContextBlockSplitter(m, &arena->lit_blocks.ctx, 256, num_contexts, 512,
-        400.0, num_literals, &mb->literal_split, &mb->literal_histograms,
-        &mb->literal_histograms_size);
-  }
-  if (BROTLI_IS_OOM(m)) return;
-  InitBlockSplitterCommand(m, &arena->cmd_blocks, BROTLI_NUM_COMMAND_SYMBOLS,
-      1024, 500.0, n_commands, &mb->command_split, &mb->command_histograms,
-      &mb->command_histograms_size);
-  if (BROTLI_IS_OOM(m)) return;
-  InitBlockSplitterDistance(m, &arena->dist_blocks, 64, 512, 100.0, n_commands,
-      &mb->distance_split, &mb->distance_histograms,
-      &mb->distance_histograms_size);
-  if (BROTLI_IS_OOM(m)) return;
-
-  for (i = 0; i < n_commands; ++i) {
-    const Command cmd = commands[i];
-    size_t j;
-    BlockSplitterAddSymbolCommand(&arena->cmd_blocks, cmd.cmd_prefix_);
-    for (j = cmd.insert_len_; j != 0; --j) {
-      uint8_t literal = ringbuffer[pos & mask];
-      if (num_contexts == 1) {
-        BlockSplitterAddSymbolLiteral(&arena->lit_blocks.plain, literal);
-      } else {
-        size_t context =
-            BROTLI_CONTEXT(prev_byte, prev_byte2, literal_context_lut);
-        ContextBlockSplitterAddSymbol(&arena->lit_blocks.ctx, m, literal,
-                                      static_context_map[context]);
-        if (BROTLI_IS_OOM(m)) return;
-      }
-      prev_byte2 = prev_byte;
-      prev_byte = literal;
-      ++pos;
-    }
-    pos += CommandCopyLen(&cmd);
-    if (CommandCopyLen(&cmd)) {
-      prev_byte2 = ringbuffer[(pos - 2) & mask];
-      prev_byte = ringbuffer[(pos - 1) & mask];
-      if (cmd.cmd_prefix_ >= 128) {
-        BlockSplitterAddSymbolDistance(
-            &arena->dist_blocks, cmd.dist_prefix_ & 0x3FF);
-      }
-    }
-  }
-
-  if (num_contexts == 1) {
-    BlockSplitterFinishBlockLiteral(
-        &arena->lit_blocks.plain, /* is_final = */ BROTLI_TRUE);
-  } else {
-    ContextBlockSplitterFinishBlock(
-        &arena->lit_blocks.ctx, m, /* is_final = */ BROTLI_TRUE);
-    if (BROTLI_IS_OOM(m)) return;
-  }
-  BlockSplitterFinishBlockCommand(
-      &arena->cmd_blocks, /* is_final = */ BROTLI_TRUE);
-  BlockSplitterFinishBlockDistance(
-      &arena->dist_blocks, /* is_final = */ BROTLI_TRUE);
-
-  if (num_contexts > 1) {
-    MapStaticContexts(m, num_contexts, static_context_map, mb);
-  }
-}
-
-void duckdb_brotli::BrotliBuildMetaBlockGreedy(MemoryManager* m,
-                                const uint8_t* ringbuffer,
-                                size_t pos,
-                                size_t mask,
-                                uint8_t prev_byte,
-                                uint8_t prev_byte2,
-                                ContextLut literal_context_lut,
-                                size_t num_contexts,
-                                const uint32_t* static_context_map,
-                                const Command* commands,
-                                size_t n_commands,
-                                MetaBlockSplit* mb) {
-  GreedyMetablockArena* arena = BROTLI_ALLOC(m, GreedyMetablockArena, 1);
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(arena)) return;
-  if (num_contexts == 1) {
-    BrotliBuildMetaBlockGreedyInternal(m, arena, ringbuffer, pos, mask,
-        prev_byte, prev_byte2, literal_context_lut, 1, NULL, commands,
-        n_commands, mb);
-  } else {
-    BrotliBuildMetaBlockGreedyInternal(m, arena, ringbuffer, pos, mask,
-        prev_byte, prev_byte2, literal_context_lut, num_contexts,
-        static_context_map, commands, n_commands, mb);
-  }
-  BROTLI_FREE(m, arena);
-}
-
-void duckdb_brotli::BrotliOptimizeHistograms(uint32_t num_distance_codes,
-                              MetaBlockSplit* mb) {
-  uint8_t good_for_rle[BROTLI_NUM_COMMAND_SYMBOLS];
-  size_t i;
-  for (i = 0; i < mb->literal_histograms_size; ++i) {
-    BrotliOptimizeHuffmanCountsForRle(256, mb->literal_histograms[i].data_,
-                                      good_for_rle);
-  }
-  for (i = 0; i < mb->command_histograms_size; ++i) {
-    BrotliOptimizeHuffmanCountsForRle(BROTLI_NUM_COMMAND_SYMBOLS,
-                                      mb->command_histograms[i].data_,
-                                      good_for_rle);
-  }
-  for (i = 0; i < mb->distance_histograms_size; ++i) {
-    BrotliOptimizeHuffmanCountsForRle(num_distance_codes,
-                                      mb->distance_histograms[i].data_,
-                                      good_for_rle);
-  }
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/metablock.h b/src/duckdb/third_party/brotli/enc/metablock.h
deleted file mode 100644
index 1a5077c1e..000000000
--- a/src/duckdb/third_party/brotli/enc/metablock.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Algorithms for distributing the literals and commands of a metablock between
-   block types and contexts. */
-
-#ifndef BROTLI_ENC_METABLOCK_H_
-#define BROTLI_ENC_METABLOCK_H_
-
-#include <brotli/types.h>
-
-#include "../common/context.h"
-#include "../common/brotli_platform.h"
-#include "block_splitter.h"
-#include "command.h"
-#include "histogram.h"
-#include "memory.h"
-#include "quality.h"
-
-namespace duckdb_brotli {
-
-typedef struct MetaBlockSplit {
-  BlockSplit literal_split;
-  BlockSplit command_split;
-  BlockSplit distance_split;
-  uint32_t* literal_context_map;
-  size_t literal_context_map_size;
-  uint32_t* distance_context_map;
-  size_t distance_context_map_size;
-  HistogramLiteral* literal_histograms;
-  size_t literal_histograms_size;
-  HistogramCommand* command_histograms;
-  size_t command_histograms_size;
-  HistogramDistance* distance_histograms;
-  size_t distance_histograms_size;
-} MetaBlockSplit;
-
-static BROTLI_INLINE void InitMetaBlockSplit(MetaBlockSplit* mb) {
-  BrotliInitBlockSplit(&mb->literal_split);
-  BrotliInitBlockSplit(&mb->command_split);
-  BrotliInitBlockSplit(&mb->distance_split);
-  mb->literal_context_map = 0;
-  mb->literal_context_map_size = 0;
-  mb->distance_context_map = 0;
-  mb->distance_context_map_size = 0;
-  mb->literal_histograms = 0;
-  mb->literal_histograms_size = 0;
-  mb->command_histograms = 0;
-  mb->command_histograms_size = 0;
-  mb->distance_histograms = 0;
-  mb->distance_histograms_size = 0;
-}
-
-static BROTLI_INLINE void DestroyMetaBlockSplit(
-    MemoryManager* m, MetaBlockSplit* mb) {
-  BrotliDestroyBlockSplit(m, &mb->literal_split);
-  BrotliDestroyBlockSplit(m, &mb->command_split);
-  BrotliDestroyBlockSplit(m, &mb->distance_split);
-  BROTLI_FREE(m, mb->literal_context_map);
-  BROTLI_FREE(m, mb->distance_context_map);
-  BROTLI_FREE(m, mb->literal_histograms);
-  BROTLI_FREE(m, mb->command_histograms);
-  BROTLI_FREE(m, mb->distance_histograms);
-}
-
-/* Uses the slow shortest-path block splitter and does context clustering.
-   The distance parameters are dynamically selected based on the commands
-   which get recomputed under the new distance parameters. The new distance
-   parameters are stored into *params. */
-BROTLI_INTERNAL void BrotliBuildMetaBlock(MemoryManager* m,
-                                          const uint8_t* ringbuffer,
-                                          const size_t pos,
-                                          const size_t mask,
-                                          BrotliEncoderParams* params,
-                                          uint8_t prev_byte,
-                                          uint8_t prev_byte2,
-                                          Command* cmds,
-                                          size_t num_commands,
-                                          ContextType literal_context_mode,
-                                          MetaBlockSplit* mb);
-
-/* Uses a fast greedy block splitter that tries to merge current block with the
-   last or the second last block and uses a static context clustering which
-   is the same for all block types. */
-BROTLI_INTERNAL void BrotliBuildMetaBlockGreedy(
-    MemoryManager* m, const uint8_t* ringbuffer, size_t pos, size_t mask,
-    uint8_t prev_byte, uint8_t prev_byte2, ContextLut literal_context_lut,
-    size_t num_contexts, const uint32_t* static_context_map,
-    const Command* commands, size_t n_commands, MetaBlockSplit* mb);
-
-BROTLI_INTERNAL void BrotliOptimizeHistograms(uint32_t num_distance_codes,
-                                              MetaBlockSplit* mb);
-
-BROTLI_INTERNAL void BrotliInitDistanceParams(BrotliDistanceParams* params,
-    uint32_t npostfix, uint32_t ndirect, BROTLI_BOOL large_window);
-
-}
-
-#endif  /* BROTLI_ENC_METABLOCK_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/prefix.h b/src/duckdb/third_party/brotli/enc/prefix.h
deleted file mode 100644
index 1bb5e1de8..000000000
--- a/src/duckdb/third_party/brotli/enc/prefix.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Functions for encoding of integers into prefix codes the amount of extra
-   bits, and the actual values of the extra bits. */
-
-#ifndef BROTLI_ENC_PREFIX_H_
-#define BROTLI_ENC_PREFIX_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_constants.h"
-#include "../common/brotli_platform.h"
-#include "fast_log.h"
-
-namespace duckdb_brotli {
-
-/* Here distance_code is an intermediate code, i.e. one of the special codes or
-   the actual distance increased by BROTLI_NUM_DISTANCE_SHORT_CODES - 1. */
-static BROTLI_INLINE void PrefixEncodeCopyDistance(size_t distance_code,
-                                                   size_t num_direct_codes,
-                                                   size_t postfix_bits,
-                                                   uint16_t* code,
-                                                   uint32_t* extra_bits) {
-  if (distance_code < BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_codes) {
-    *code = (uint16_t)distance_code;
-    *extra_bits = 0;
-    return;
-  } else {
-    size_t dist = ((size_t)1 << (postfix_bits + 2u)) +
-        (distance_code - BROTLI_NUM_DISTANCE_SHORT_CODES - num_direct_codes);
-    size_t bucket = Log2FloorNonZero(dist) - 1;
-    size_t postfix_mask = (1u << postfix_bits) - 1;
-    size_t postfix = dist & postfix_mask;
-    size_t prefix = (dist >> bucket) & 1;
-    size_t offset = (2 + prefix) << bucket;
-    size_t nbits = bucket - postfix_bits;
-    *code = (uint16_t)((nbits << 10) |
-        (BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_codes +
-         ((2 * (nbits - 1) + prefix) << postfix_bits) + postfix));
-    *extra_bits = (uint32_t)((dist - offset) >> postfix_bits);
-  }
-}
-
-}
-
-#endif  /* BROTLI_ENC_PREFIX_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/quality.h b/src/duckdb/third_party/brotli/enc/quality.h
deleted file mode 100644
index 62ac33d1f..000000000
--- a/src/duckdb/third_party/brotli/enc/quality.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Constants and formulas that affect speed-ratio trade-offs and thus define
-   quality levels. */
-
-#ifndef BROTLI_ENC_QUALITY_H_
-#define BROTLI_ENC_QUALITY_H_
-
-#include <brotli/encode.h>
-
-#include "../common/brotli_platform.h"
-#include "brotli_params.h"
-
-#define FAST_ONE_PASS_COMPRESSION_QUALITY 0
-#define FAST_TWO_PASS_COMPRESSION_QUALITY 1
-#define ZOPFLIFICATION_QUALITY 10
-#define HQ_ZOPFLIFICATION_QUALITY 11
-
-#define MAX_QUALITY_FOR_STATIC_ENTROPY_CODES 2
-#define MIN_QUALITY_FOR_BLOCK_SPLIT 4
-#define MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS 4
-#define MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS 4
-#define MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH 5
-#define MIN_QUALITY_FOR_CONTEXT_MODELING 5
-#define MIN_QUALITY_FOR_HQ_CONTEXT_MODELING 7
-#define MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING 10
-
-/* For quality below MIN_QUALITY_FOR_BLOCK_SPLIT there is no block splitting,
-   so we buffer at most this much literals and commands. */
-#define MAX_NUM_DELAYED_SYMBOLS 0x2FFF
-
-/* Returns hash-table size for quality levels 0 and 1. */
-static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
-  return quality == FAST_ONE_PASS_COMPRESSION_QUALITY ? 1 << 15 : 1 << 17;
-}
-
-/* The maximum length for which the zopflification uses distinct distances. */
-#define MAX_ZOPFLI_LEN_QUALITY_10 150
-#define MAX_ZOPFLI_LEN_QUALITY_11 325
-
-/* Do not thoroughly search when a long copy is found. */
-#define BROTLI_LONG_COPY_QUICK_STEP 16384
-
-static BROTLI_INLINE size_t MaxZopfliLen(const BrotliEncoderParams* params) {
-  return params->quality <= 10 ?
-      MAX_ZOPFLI_LEN_QUALITY_10 :
-      MAX_ZOPFLI_LEN_QUALITY_11;
-}
-
-/* Number of best candidates to evaluate to expand Zopfli chain. */
-static BROTLI_INLINE size_t MaxZopfliCandidates(
-  const BrotliEncoderParams* params) {
-  return params->quality <= 10 ? 1 : 5;
-}
-
-static BROTLI_INLINE void SanitizeParams(BrotliEncoderParams* params) {
-  params->quality = BROTLI_MIN(int, BROTLI_MAX_QUALITY,
-      BROTLI_MAX(int, BROTLI_MIN_QUALITY, params->quality));
-  if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
-    params->large_window = BROTLI_FALSE;
-  }
-  if (params->lgwin < BROTLI_MIN_WINDOW_BITS) {
-    params->lgwin = BROTLI_MIN_WINDOW_BITS;
-  } else {
-    int max_lgwin = params->large_window ? BROTLI_LARGE_MAX_WINDOW_BITS :
-                                           BROTLI_MAX_WINDOW_BITS;
-    if (params->lgwin > max_lgwin) params->lgwin = max_lgwin;
-  }
-}
-
-/* Returns optimized lg_block value. */
-static BROTLI_INLINE int ComputeLgBlock(const BrotliEncoderParams* params) {
-  int lgblock = params->lgblock;
-  if (params->quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
-      params->quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    lgblock = params->lgwin;
-  } else if (params->quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
-    lgblock = 14;
-  } else if (lgblock == 0) {
-    lgblock = 16;
-    if (params->quality >= 9 && params->lgwin > lgblock) {
-      lgblock = BROTLI_MIN(int, 18, params->lgwin);
-    }
-  } else {
-    lgblock = BROTLI_MIN(int, BROTLI_MAX_INPUT_BLOCK_BITS,
-        BROTLI_MAX(int, BROTLI_MIN_INPUT_BLOCK_BITS, lgblock));
-  }
-  return lgblock;
-}
-
-/* Returns log2 of the size of main ring buffer area.
-   Allocate at least lgwin + 1 bits for the ring buffer so that the newly
-   added block fits there completely and we still get lgwin bits and at least
-   read_block_size_bits + 1 bits because the copy tail length needs to be
-   smaller than ring-buffer size. */
-static BROTLI_INLINE int ComputeRbBits(const BrotliEncoderParams* params) {
-  return 1 + BROTLI_MAX(int, params->lgwin, params->lgblock);
-}
-
-static BROTLI_INLINE size_t MaxMetablockSize(
-    const BrotliEncoderParams* params) {
-  int bits =
-      BROTLI_MIN(int, ComputeRbBits(params), BROTLI_MAX_INPUT_BLOCK_BITS);
-  return (size_t)1 << bits;
-}
-
-/* When searching for backward references and have not seen matches for a long
-   time, we can skip some match lookups. Unsuccessful match lookups are very
-   expensive and this kind of a heuristic speeds up compression quite a lot.
-   At first 8 byte strides are taken and every second byte is put to hasher.
-   After 4x more literals stride by 16 bytes, every put 4-th byte to hasher.
-   Applied only to qualities 2 to 9. */
-static BROTLI_INLINE size_t LiteralSpreeLengthForSparseSearch(
-    const BrotliEncoderParams* params) {
-  return params->quality < 9 ? 64 : 512;
-}
-
-/* Quality to hasher mapping:
-
-   - q02: h02 (longest_match_quickly), b16, l5
-
-   - q03: h03 (longest_match_quickly), b17, l5
-
-   - q04: h04 (longest_match_quickly), b17, l5
-   - q04: h54 (longest_match_quickly), b20, l7 | for large files
-
-   - q05: h05 (longest_match        ), b14, l4
-   - q05: h06 (longest_match64      ), b15, l5 | for large files
-   - q05: h40 (forgetful_chain      ), b15, l4 | for small window
-
-   - q06: h05 (longest_match        ), b14, l4
-   - q06: h06 (longest_match64      ), b15, l5 | for large files
-   - q06: h40 (forgetful_chain      ), b15, l4 | for small window
-
-   - q07: h05 (longest_match        ), b15, l4
-   - q07: h06 (longest_match64      ), b15, l5 | for large files
-   - q07: h41 (forgetful_chain      ), b15, l4 | for small window
-
-   - q08: h05 (longest_match        ), b15, l4
-   - q08: h06 (longest_match64      ), b15, l5 | for large files
-   - q08: h41 (forgetful_chain      ), b15, l4 | for small window
-
-   - q09: h05 (longest_match        ), b15, l4
-   - q09: h06 (longest_match64      ), b15, l5 | for large files
-   - q09: h42 (forgetful_chain      ), b15, l4 | for small window
-
-   - q10: t10 (to_binary_tree       ), b17, l128
-
-   - q11: t10 (to_binary_tree       ), b17, l128
-
-  Where "q" is quality, "h" is hasher type, "b" is bucket bits,
-  "l" is source len. */
-static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
-                                       BrotliHasherParams* hparams) {
-  if (params->quality > 9) {
-    hparams->type = 10;
-  } else if (params->quality == 4 && params->size_hint >= (1 << 20)) {
-    hparams->type = 54;
-  } else if (params->quality < 5) {
-    hparams->type = params->quality;
-  } else if (params->lgwin <= 16) {
-    hparams->type = params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
-  } else if (params->size_hint >= (1 << 20) && params->lgwin >= 19) {
-    hparams->type = 6;
-    hparams->block_bits = params->quality - 1;
-    hparams->bucket_bits = 15;
-    hparams->num_last_distances_to_check =
-        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
-  } else {
-    /* TODO(eustas): often previous setting (H6) is faster and denser; consider
-                     adding an option to use it. */
-    hparams->type = 5;
-    hparams->block_bits = params->quality - 1;
-    hparams->bucket_bits = params->quality < 7 ? 14 : 15;
-    hparams->num_last_distances_to_check =
-        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
-  }
-
-  if (params->lgwin > 24) {
-    /* Different hashers for large window brotli: not for qualities <= 2,
-       these are too fast for large window. Not for qualities >= 10: their
-       hasher already works well with large window. So the changes are:
-       H3 --> H35: for quality 3.
-       H54 --> H55: for quality 4 with size hint > 1MB
-       H6 --> H65: for qualities 5, 6, 7, 8, 9. */
-    if (hparams->type == 3) {
-      hparams->type = 35;
-    }
-    if (hparams->type == 54) {
-      hparams->type = 55;
-    }
-    if (hparams->type == 6) {
-      hparams->type = 65;
-    }
-  }
-}
-
-#endif  /* BROTLI_ENC_QUALITY_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/ringbuffer.h b/src/duckdb/third_party/brotli/enc/ringbuffer.h
deleted file mode 100644
index b7e8113b8..000000000
--- a/src/duckdb/third_party/brotli/enc/ringbuffer.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Sliding window over the input data. */
-
-#ifndef BROTLI_ENC_RINGBUFFER_H_
-#define BROTLI_ENC_RINGBUFFER_H_
-
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-#include "memory.h"
-#include "quality.h"
-
-namespace duckdb_brotli {
-
-/* A RingBuffer(window_bits, tail_bits) contains `1 << window_bits' bytes of
-   data in a circular manner: writing a byte writes it to:
-     `position() % (1 << window_bits)'.
-   For convenience, the RingBuffer array contains another copy of the
-   first `1 << tail_bits' bytes:
-     buffer_[i] == buffer_[i + (1 << window_bits)], if i < (1 << tail_bits),
-   and another copy of the last two bytes:
-     buffer_[-1] == buffer_[(1 << window_bits) - 1] and
-     buffer_[-2] == buffer_[(1 << window_bits) - 2]. */
-typedef struct RingBuffer {
-  /* Size of the ring-buffer is (1 << window_bits) + tail_size_. */
-  const uint32_t size_;
-  const uint32_t mask_;
-  const uint32_t tail_size_;
-  const uint32_t total_size_;
-
-  uint32_t cur_size_;
-  /* Position to write in the ring buffer. */
-  uint32_t pos_;
-  /* The actual ring buffer containing the copy of the last two bytes, the data,
-     and the copy of the beginning as a tail. */
-  uint8_t* data_;
-  /* The start of the ring-buffer. */
-  uint8_t* buffer_;
-} RingBuffer;
-
-static BROTLI_INLINE void RingBufferInit(RingBuffer* rb) {
-  rb->cur_size_ = 0;
-  rb->pos_ = 0;
-  rb->data_ = 0;
-  rb->buffer_ = 0;
-}
-
-static BROTLI_INLINE void RingBufferSetup(
-    const BrotliEncoderParams* params, RingBuffer* rb) {
-  int window_bits = ComputeRbBits(params);
-  int tail_bits = params->lgblock;
-  *(uint32_t*)&rb->size_ = 1u << window_bits;
-  *(uint32_t*)&rb->mask_ = (1u << window_bits) - 1;
-  *(uint32_t*)&rb->tail_size_ = 1u << tail_bits;
-  *(uint32_t*)&rb->total_size_ = rb->size_ + rb->tail_size_;
-}
-
-static BROTLI_INLINE void RingBufferFree(MemoryManager* m, RingBuffer* rb) {
-  BROTLI_FREE(m, rb->data_);
-}
-
-/* Allocates or re-allocates data_ to the given length + plus some slack
-   region before and after. Fills the slack regions with zeros. */
-static BROTLI_INLINE void RingBufferInitBuffer(
-    MemoryManager* m, const uint32_t buflen, RingBuffer* rb) {
-  static const size_t kSlackForEightByteHashingEverywhere = 7;
-  uint8_t* new_data = BROTLI_ALLOC(
-      m, uint8_t, 2 + buflen + kSlackForEightByteHashingEverywhere);
-  size_t i;
-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_data)) return;
-  if (rb->data_) {
-    memcpy(new_data, rb->data_,
-        2 + rb->cur_size_ + kSlackForEightByteHashingEverywhere);
-    BROTLI_FREE(m, rb->data_);
-  }
-  rb->data_ = new_data;
-  rb->cur_size_ = buflen;
-  rb->buffer_ = rb->data_ + 2;
-  rb->buffer_[-2] = rb->buffer_[-1] = 0;
-  for (i = 0; i < kSlackForEightByteHashingEverywhere; ++i) {
-    rb->buffer_[rb->cur_size_ + i] = 0;
-  }
-}
-
-static BROTLI_INLINE void RingBufferWriteTail(
-    const uint8_t* bytes, size_t n, RingBuffer* rb) {
-  const size_t masked_pos = rb->pos_ & rb->mask_;
-  if (BROTLI_PREDICT_FALSE(masked_pos < rb->tail_size_)) {
-    /* Just fill the tail buffer with the beginning data. */
-    const size_t p = rb->size_ + masked_pos;
-    memcpy(&rb->buffer_[p], bytes,
-        BROTLI_MIN(size_t, n, rb->tail_size_ - masked_pos));
-  }
-}
-
-/* Push bytes into the ring buffer. */
-static BROTLI_INLINE void RingBufferWrite(
-    MemoryManager* m, const uint8_t* bytes, size_t n, RingBuffer* rb) {
-  if (rb->pos_ == 0 && n < rb->tail_size_) {
-    /* Special case for the first write: to process the first block, we don't
-       need to allocate the whole ring-buffer and we don't need the tail
-       either. However, we do this memory usage optimization only if the
-       first write is less than the tail size, which is also the input block
-       size, otherwise it is likely that other blocks will follow and we
-       will need to reallocate to the full size anyway. */
-    rb->pos_ = (uint32_t)n;
-    RingBufferInitBuffer(m, rb->pos_, rb);
-    if (BROTLI_IS_OOM(m)) return;
-    memcpy(rb->buffer_, bytes, n);
-    return;
-  }
-  if (rb->cur_size_ < rb->total_size_) {
-    /* Lazily allocate the full buffer. */
-    RingBufferInitBuffer(m, rb->total_size_, rb);
-    if (BROTLI_IS_OOM(m)) return;
-    /* Initialize the last two bytes to zero, so that we don't have to worry
-       later when we copy the last two bytes to the first two positions. */
-    rb->buffer_[rb->size_ - 2] = 0;
-    rb->buffer_[rb->size_ - 1] = 0;
-    /* Initialize tail; might be touched by "best_len++" optimization when
-       ring buffer is "full". */
-    rb->buffer_[rb->size_] = 241;
-  }
-  {
-    const size_t masked_pos = rb->pos_ & rb->mask_;
-    /* The length of the writes is limited so that we do not need to worry
-       about a write */
-    RingBufferWriteTail(bytes, n, rb);
-    if (BROTLI_PREDICT_TRUE(masked_pos + n <= rb->size_)) {
-      /* A single write fits. */
-      memcpy(&rb->buffer_[masked_pos], bytes, n);
-    } else {
-      /* Split into two writes.
-         Copy into the end of the buffer, including the tail buffer. */
-      memcpy(&rb->buffer_[masked_pos], bytes,
-             BROTLI_MIN(size_t, n, rb->total_size_ - masked_pos));
-      /* Copy into the beginning of the buffer */
-      memcpy(&rb->buffer_[0], bytes + (rb->size_ - masked_pos),
-             n - (rb->size_ - masked_pos));
-    }
-  }
-  {
-    BROTLI_BOOL not_first_lap = (rb->pos_ & (1u << 31)) != 0;
-    uint32_t rb_pos_mask = (1u << 31) - 1;
-    rb->buffer_[-2] = rb->buffer_[rb->size_ - 2];
-    rb->buffer_[-1] = rb->buffer_[rb->size_ - 1];
-    rb->pos_ = (rb->pos_ & rb_pos_mask) + (uint32_t)(n & rb_pos_mask);
-    if (not_first_lap) {
-      /* Wrap, but preserve not-a-first-lap feature. */
-      rb->pos_ |= 1u << 31;
-    }
-  }
-}
-
-}
-
-#endif  /* BROTLI_ENC_RINGBUFFER_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/state.h b/src/duckdb/third_party/brotli/enc/state.h
deleted file mode 100644
index acdbc0ad2..000000000
--- a/src/duckdb/third_party/brotli/enc/state.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/* Copyright 2022 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Encoder state. */
-
-#ifndef BROTLI_ENC_STATE_H_
-#define BROTLI_ENC_STATE_H_
-
-#include <brotli/types.h>
-
-#include "command.h"
-#include "compress_fragment.h"
-#include "compress_fragment_two_pass.h"
-#include "brotli_hash.h"
-#include "memory.h"
-#include "brotli_params.h"
-#include "ringbuffer.h"
-
-namespace duckdb_brotli {
-
-typedef enum BrotliEncoderStreamState {
-	/* Default state. */
-	BROTLI_STREAM_PROCESSING = 0,
-	/* Intermediate state; after next block is emitted, byte-padding should be
-	   performed before getting back to default state. */
-	BROTLI_STREAM_FLUSH_REQUESTED = 1,
-	/* Last metablock was produced; no more input is acceptable. */
-	BROTLI_STREAM_FINISHED = 2,
-	/* Flushing compressed block and writing meta-data block header. */
-	BROTLI_STREAM_METADATA_HEAD = 3,
-	/* Writing metadata block body. */
-	BROTLI_STREAM_METADATA_BODY = 4
-} BrotliEncoderStreamState;
-
-typedef enum BrotliEncoderFlintState {
-	BROTLI_FLINT_NEEDS_2_BYTES = 2,
-	BROTLI_FLINT_NEEDS_1_BYTE = 1,
-	BROTLI_FLINT_WAITING_FOR_PROCESSING = 0,
-	BROTLI_FLINT_WAITING_FOR_FLUSHING = -1,
-	BROTLI_FLINT_DONE = -2
-} BrotliEncoderFlintState;
-
-typedef struct BrotliEncoderStateStruct {
-	BrotliEncoderParams params;
-
-	MemoryManager memory_manager_;
-
-	uint64_t input_pos_;
-	RingBuffer ringbuffer_;
-	size_t cmd_alloc_size_;
-	Command *commands_;
-	size_t num_commands_;
-	size_t num_literals_;
-	size_t last_insert_len_;
-	uint64_t last_flush_pos_;
-	uint64_t last_processed_pos_;
-	int dist_cache_[BROTLI_NUM_DISTANCE_SHORT_CODES];
-	int saved_dist_cache_[4];
-	uint16_t last_bytes_;
-	uint8_t last_bytes_bits_;
-	/* "Flint" is a tiny uncompressed block emitted before the continuation
-	   block to unwire literal context from previous data. Despite being int8_t,
-	   field is actually BrotliEncoderFlintState enum. */
-	int8_t flint_;
-	uint8_t prev_byte_;
-	uint8_t prev_byte2_;
-	size_t storage_size_;
-	uint8_t *storage_;
-
-	Hasher hasher_;
-
-	/* Hash table for FAST_ONE_PASS_COMPRESSION_QUALITY mode. */
-	int small_table_[1 << 10]; /* 4KiB */
-	int *large_table_;         /* Allocated only when needed */
-	size_t large_table_size_;
-
-	BrotliOnePassArena *one_pass_arena_;
-	BrotliTwoPassArena *two_pass_arena_;
-
-	/* Command and literal buffers for FAST_TWO_PASS_COMPRESSION_QUALITY. */
-	uint32_t *command_buf_;
-	uint8_t *literal_buf_;
-
-	uint64_t total_in_;
-	uint8_t *next_out_;
-	size_t available_out_;
-	uint64_t total_out_;
-	/* Temporary buffer for padding flush bits or metadata block header / body. */
-	union {
-		uint64_t u64[2];
-		uint8_t u8[16];
-	} tiny_buf_;
-	uint32_t remaining_metadata_bytes_;
-	BrotliEncoderStreamState stream_state_;
-
-	BROTLI_BOOL is_last_block_emitted_;
-	BROTLI_BOOL is_initialized_;
-} BrotliEncoderStateStruct;
-
-typedef struct BrotliEncoderStateStruct BrotliEncoderStateInternal;
-#define BrotliEncoderState BrotliEncoderStateInternal
-}
-#endif  // BROTLI_ENC_STATE_H_
diff --git a/src/duckdb/third_party/brotli/enc/static_dict.cpp b/src/duckdb/third_party/brotli/enc/static_dict.cpp
deleted file mode 100644
index 26b638717..000000000
--- a/src/duckdb/third_party/brotli/enc/static_dict.cpp
+++ /dev/null
@@ -1,538 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-#include "static_dict.h"
-
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "../common/transform.h"
-#include "encoder_dict.h"
-#include "find_match_length.h"
-
-using namespace duckdb_brotli;
-
-static BROTLI_INLINE uint32_t Hash(const uint8_t* data) {
-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kDictHashMul32;
-  /* The higher bits contain more mixture from the multiplication,
-     so we take our results from there. */
-  return h >> (32 - kDictNumBits);
-}
-
-static BROTLI_INLINE void AddMatch(size_t distance, size_t len, size_t len_code,
-                                   uint32_t* matches) {
-  uint32_t match = (uint32_t)((distance << 5) + len_code);
-  matches[len] = BROTLI_MIN(uint32_t, matches[len], match);
-}
-
-static BROTLI_INLINE size_t DictMatchLength(const BrotliDictionary* dictionary,
-                                            const uint8_t* data,
-                                            size_t id,
-                                            size_t len,
-                                            size_t maxlen) {
-  const size_t offset = dictionary->offsets_by_length[len] + len * id;
-  return FindMatchLengthWithLimit(&dictionary->data[offset], data,
-                                  BROTLI_MIN(size_t, len, maxlen));
-}
-
-static BROTLI_INLINE BROTLI_BOOL IsMatch(const BrotliDictionary* dictionary,
-    DictWord w, const uint8_t* data, size_t max_length) {
-  if (w.len > max_length) {
-    return BROTLI_FALSE;
-  } else {
-    const size_t offset = dictionary->offsets_by_length[w.len] +
-        (size_t)w.len * (size_t)w.idx;
-    const uint8_t* dict = &dictionary->data[offset];
-    if (w.transform == 0) {
-      /* Match against base dictionary word. */
-      return
-          TO_BROTLI_BOOL(FindMatchLengthWithLimit(dict, data, w.len) == w.len);
-    } else if (w.transform == 10) {
-      /* Match against uppercase first transform.
-         Note that there are only ASCII uppercase words in the lookup table. */
-      return TO_BROTLI_BOOL(dict[0] >= 'a' && dict[0] <= 'z' &&
-              (dict[0] ^ 32) == data[0] &&
-              FindMatchLengthWithLimit(&dict[1], &data[1], w.len - 1u) ==
-              w.len - 1u);
-    } else {
-      /* Match against uppercase all transform.
-         Note that there are only ASCII uppercase words in the lookup table. */
-      size_t i;
-      for (i = 0; i < w.len; ++i) {
-        if (dict[i] >= 'a' && dict[i] <= 'z') {
-          if ((dict[i] ^ 32) != data[i]) return BROTLI_FALSE;
-        } else {
-          if (dict[i] != data[i]) return BROTLI_FALSE;
-        }
-      }
-      return BROTLI_TRUE;
-    }
-  }
-}
-
-/* Finds matches for a single static dictionary */
-static BROTLI_BOOL BrotliFindAllStaticDictionaryMatchesFor(
-    const BrotliEncoderDictionary* dictionary, const uint8_t* data,
-    size_t min_length, size_t max_length, uint32_t* matches) {
-  BROTLI_BOOL has_found_match = BROTLI_FALSE;
-#if defined(BROTLI_EXPERIMENTAL)
-  if (dictionary->has_words_heavy) {
-    const BrotliTrieNode* node = &dictionary->trie.root;
-    size_t l = 0;
-    while (node && l < max_length) {
-      uint8_t c;
-      if (l >= min_length && node->len_) {
-        AddMatch(node->idx_, l, node->len_, matches);
-        has_found_match = BROTLI_TRUE;
-      }
-      c = data[l++];
-      node = BrotliTrieSub(&dictionary->trie, node, c);
-    }
-    return has_found_match;
-  }
-#endif  /* BROTLI_EXPERIMENTAL */
-  {
-    size_t offset = dictionary->buckets[Hash(data)];
-    BROTLI_BOOL end = !offset;
-    while (!end) {
-      DictWord w = dictionary->dict_words[offset++];
-      const size_t l = w.len & 0x1F;
-      const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
-      const size_t id = w.idx;
-      end = !!(w.len & 0x80);
-      w.len = (uint8_t)l;
-      if (w.transform == 0) {
-        const size_t matchlen =
-            DictMatchLength(dictionary->words, data, id, l, max_length);
-        const uint8_t* s;
-        size_t minlen;
-        size_t maxlen;
-        size_t len;
-        /* Transform "" + BROTLI_TRANSFORM_IDENTITY + "" */
-        if (matchlen == l) {
-          AddMatch(id, l, l, matches);
-          has_found_match = BROTLI_TRUE;
-        }
-        /* Transforms "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "" and
-                      "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "ing " */
-        if (matchlen >= l - 1) {
-          AddMatch(id + 12 * n, l - 1, l, matches);
-          if (l + 2 < max_length &&
-              data[l - 1] == 'i' && data[l] == 'n' && data[l + 1] == 'g' &&
-              data[l + 2] == ' ') {
-            AddMatch(id + 49 * n, l + 3, l, matches);
-          }
-          has_found_match = BROTLI_TRUE;
-        }
-        /* Transform "" + BROTLI_TRANSFORM_OMIT_LAST_# + "" (# = 2 .. 9) */
-        minlen = min_length;
-        if (l > 9) minlen = BROTLI_MAX(size_t, minlen, l - 9);
-        maxlen = BROTLI_MIN(size_t, matchlen, l - 2);
-        for (len = minlen; len <= maxlen; ++len) {
-          size_t cut = l - len;
-          size_t transform_id = (cut << 2) +
-              (size_t)((dictionary->cutoffTransforms >> (cut * 6)) & 0x3F);
-          AddMatch(id + transform_id * n, len, l, matches);
-          has_found_match = BROTLI_TRUE;
-        }
-        if (matchlen < l || l + 6 >= max_length) {
-          continue;
-        }
-        s = &data[l];
-        /* Transforms "" + BROTLI_TRANSFORM_IDENTITY + <suffix> */
-        if (s[0] == ' ') {
-          AddMatch(id + n, l + 1, l, matches);
-          if (s[1] == 'a') {
-            if (s[2] == ' ') {
-              AddMatch(id + 28 * n, l + 3, l, matches);
-            } else if (s[2] == 's') {
-              if (s[3] == ' ') AddMatch(id + 46 * n, l + 4, l, matches);
-            } else if (s[2] == 't') {
-              if (s[3] == ' ') AddMatch(id + 60 * n, l + 4, l, matches);
-            } else if (s[2] == 'n') {
-              if (s[3] == 'd' && s[4] == ' ') {
-                AddMatch(id + 10 * n, l + 5, l, matches);
-              }
-            }
-          } else if (s[1] == 'b') {
-            if (s[2] == 'y' && s[3] == ' ') {
-              AddMatch(id + 38 * n, l + 4, l, matches);
-            }
-          } else if (s[1] == 'i') {
-            if (s[2] == 'n') {
-              if (s[3] == ' ') AddMatch(id + 16 * n, l + 4, l, matches);
-            } else if (s[2] == 's') {
-              if (s[3] == ' ') AddMatch(id + 47 * n, l + 4, l, matches);
-            }
-          } else if (s[1] == 'f') {
-            if (s[2] == 'o') {
-              if (s[3] == 'r' && s[4] == ' ') {
-                AddMatch(id + 25 * n, l + 5, l, matches);
-              }
-            } else if (s[2] == 'r') {
-              if (s[3] == 'o' && s[4] == 'm' && s[5] == ' ') {
-                AddMatch(id + 37 * n, l + 6, l, matches);
-              }
-            }
-          } else if (s[1] == 'o') {
-            if (s[2] == 'f') {
-              if (s[3] == ' ') AddMatch(id + 8 * n, l + 4, l, matches);
-            } else if (s[2] == 'n') {
-              if (s[3] == ' ') AddMatch(id + 45 * n, l + 4, l, matches);
-            }
-          } else if (s[1] == 'n') {
-            if (s[2] == 'o' && s[3] == 't' && s[4] == ' ') {
-              AddMatch(id + 80 * n, l + 5, l, matches);
-            }
-          } else if (s[1] == 't') {
-            if (s[2] == 'h') {
-              if (s[3] == 'e') {
-                if (s[4] == ' ') AddMatch(id + 5 * n, l + 5, l, matches);
-              } else if (s[3] == 'a') {
-                if (s[4] == 't' && s[5] == ' ') {
-                  AddMatch(id + 29 * n, l + 6, l, matches);
-                }
-              }
-            } else if (s[2] == 'o') {
-              if (s[3] == ' ') AddMatch(id + 17 * n, l + 4, l, matches);
-            }
-          } else if (s[1] == 'w') {
-            if (s[2] == 'i' && s[3] == 't' && s[4] == 'h' && s[5] == ' ') {
-              AddMatch(id + 35 * n, l + 6, l, matches);
-            }
-          }
-        } else if (s[0] == '"') {
-          AddMatch(id + 19 * n, l + 1, l, matches);
-          if (s[1] == '>') {
-            AddMatch(id + 21 * n, l + 2, l, matches);
-          }
-        } else if (s[0] == '.') {
-          AddMatch(id + 20 * n, l + 1, l, matches);
-          if (s[1] == ' ') {
-            AddMatch(id + 31 * n, l + 2, l, matches);
-            if (s[2] == 'T' && s[3] == 'h') {
-              if (s[4] == 'e') {
-                if (s[5] == ' ') AddMatch(id + 43 * n, l + 6, l, matches);
-              } else if (s[4] == 'i') {
-                if (s[5] == 's' && s[6] == ' ') {
-                  AddMatch(id + 75 * n, l + 7, l, matches);
-                }
-              }
-            }
-          }
-        } else if (s[0] == ',') {
-          AddMatch(id + 76 * n, l + 1, l, matches);
-          if (s[1] == ' ') {
-            AddMatch(id + 14 * n, l + 2, l, matches);
-          }
-        } else if (s[0] == '\n') {
-          AddMatch(id + 22 * n, l + 1, l, matches);
-          if (s[1] == '\t') {
-            AddMatch(id + 50 * n, l + 2, l, matches);
-          }
-        } else if (s[0] == ']') {
-          AddMatch(id + 24 * n, l + 1, l, matches);
-        } else if (s[0] == '\'') {
-          AddMatch(id + 36 * n, l + 1, l, matches);
-        } else if (s[0] == ':') {
-          AddMatch(id + 51 * n, l + 1, l, matches);
-        } else if (s[0] == '(') {
-          AddMatch(id + 57 * n, l + 1, l, matches);
-        } else if (s[0] == '=') {
-          if (s[1] == '"') {
-            AddMatch(id + 70 * n, l + 2, l, matches);
-          } else if (s[1] == '\'') {
-            AddMatch(id + 86 * n, l + 2, l, matches);
-          }
-        } else if (s[0] == 'a') {
-          if (s[1] == 'l' && s[2] == ' ') {
-            AddMatch(id + 84 * n, l + 3, l, matches);
-          }
-        } else if (s[0] == 'e') {
-          if (s[1] == 'd') {
-            if (s[2] == ' ') AddMatch(id + 53 * n, l + 3, l, matches);
-          } else if (s[1] == 'r') {
-            if (s[2] == ' ') AddMatch(id + 82 * n, l + 3, l, matches);
-          } else if (s[1] == 's') {
-            if (s[2] == 't' && s[3] == ' ') {
-              AddMatch(id + 95 * n, l + 4, l, matches);
-            }
-          }
-        } else if (s[0] == 'f') {
-          if (s[1] == 'u' && s[2] == 'l' && s[3] == ' ') {
-            AddMatch(id + 90 * n, l + 4, l, matches);
-          }
-        } else if (s[0] == 'i') {
-          if (s[1] == 'v') {
-            if (s[2] == 'e' && s[3] == ' ') {
-              AddMatch(id + 92 * n, l + 4, l, matches);
-            }
-          } else if (s[1] == 'z') {
-            if (s[2] == 'e' && s[3] == ' ') {
-              AddMatch(id + 100 * n, l + 4, l, matches);
-            }
-          }
-        } else if (s[0] == 'l') {
-          if (s[1] == 'e') {
-            if (s[2] == 's' && s[3] == 's' && s[4] == ' ') {
-              AddMatch(id + 93 * n, l + 5, l, matches);
-            }
-          } else if (s[1] == 'y') {
-            if (s[2] == ' ') AddMatch(id + 61 * n, l + 3, l, matches);
-          }
-        } else if (s[0] == 'o') {
-          if (s[1] == 'u' && s[2] == 's' && s[3] == ' ') {
-            AddMatch(id + 106 * n, l + 4, l, matches);
-          }
-        }
-      } else {
-        /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and
-               is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL)
-           transform. */
-        const BROTLI_BOOL is_all_caps =
-            TO_BROTLI_BOOL(w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST);
-        const uint8_t* s;
-        if (!IsMatch(dictionary->words, w, data, max_length)) {
-          continue;
-        }
-        /* Transform "" + kUppercase{First,All} + "" */
-        AddMatch(id + (is_all_caps ? 44 : 9) * n, l, l, matches);
-        has_found_match = BROTLI_TRUE;
-        if (l + 1 >= max_length) {
-          continue;
-        }
-        /* Transforms "" + kUppercase{First,All} + <suffix> */
-        s = &data[l];
-        if (s[0] == ' ') {
-          AddMatch(id + (is_all_caps ? 68 : 4) * n, l + 1, l, matches);
-        } else if (s[0] == '"') {
-          AddMatch(id + (is_all_caps ? 87 : 66) * n, l + 1, l, matches);
-          if (s[1] == '>') {
-            AddMatch(id + (is_all_caps ? 97 : 69) * n, l + 2, l, matches);
-          }
-        } else if (s[0] == '.') {
-          AddMatch(id + (is_all_caps ? 101 : 79) * n, l + 1, l, matches);
-          if (s[1] == ' ') {
-            AddMatch(id + (is_all_caps ? 114 : 88) * n, l + 2, l, matches);
-          }
-        } else if (s[0] == ',') {
-          AddMatch(id + (is_all_caps ? 112 : 99) * n, l + 1, l, matches);
-          if (s[1] == ' ') {
-            AddMatch(id + (is_all_caps ? 107 : 58) * n, l + 2, l, matches);
-          }
-        } else if (s[0] == '\'') {
-          AddMatch(id + (is_all_caps ? 94 : 74) * n, l + 1, l, matches);
-        } else if (s[0] == '(') {
-          AddMatch(id + (is_all_caps ? 113 : 78) * n, l + 1, l, matches);
-        } else if (s[0] == '=') {
-          if (s[1] == '"') {
-            AddMatch(id + (is_all_caps ? 105 : 104) * n, l + 2, l, matches);
-          } else if (s[1] == '\'') {
-            AddMatch(id + (is_all_caps ? 116 : 108) * n, l + 2, l, matches);
-          }
-        }
-      }
-    }
-  }
-  /* Transforms with prefixes " " and "." */
-  if (max_length >= 5 && (data[0] == ' ' || data[0] == '.')) {
-    BROTLI_BOOL is_space = TO_BROTLI_BOOL(data[0] == ' ');
-    size_t offset = dictionary->buckets[Hash(&data[1])];
-    BROTLI_BOOL end = !offset;
-    while (!end) {
-      DictWord w = dictionary->dict_words[offset++];
-      const size_t l = w.len & 0x1F;
-      const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
-      const size_t id = w.idx;
-      end = !!(w.len & 0x80);
-      w.len = (uint8_t)l;
-      if (w.transform == 0) {
-        const uint8_t* s;
-        if (!IsMatch(dictionary->words, w, &data[1], max_length - 1)) {
-          continue;
-        }
-        /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + "" and
-                      "." + BROTLI_TRANSFORM_IDENTITY + "" */
-        AddMatch(id + (is_space ? 6 : 32) * n, l + 1, l, matches);
-        has_found_match = BROTLI_TRUE;
-        if (l + 2 >= max_length) {
-          continue;
-        }
-        /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + <suffix> and
-                      "." + BROTLI_TRANSFORM_IDENTITY + <suffix>
-        */
-        s = &data[l + 1];
-        if (s[0] == ' ') {
-          AddMatch(id + (is_space ? 2 : 77) * n, l + 2, l, matches);
-        } else if (s[0] == '(') {
-          AddMatch(id + (is_space ? 89 : 67) * n, l + 2, l, matches);
-        } else if (is_space) {
-          if (s[0] == ',') {
-            AddMatch(id + 103 * n, l + 2, l, matches);
-            if (s[1] == ' ') {
-              AddMatch(id + 33 * n, l + 3, l, matches);
-            }
-          } else if (s[0] == '.') {
-            AddMatch(id + 71 * n, l + 2, l, matches);
-            if (s[1] == ' ') {
-              AddMatch(id + 52 * n, l + 3, l, matches);
-            }
-          } else if (s[0] == '=') {
-            if (s[1] == '"') {
-              AddMatch(id + 81 * n, l + 3, l, matches);
-            } else if (s[1] == '\'') {
-              AddMatch(id + 98 * n, l + 3, l, matches);
-            }
-          }
-        }
-      } else if (is_space) {
-        /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and
-               is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL)
-           transform. */
-        const BROTLI_BOOL is_all_caps =
-            TO_BROTLI_BOOL(w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST);
-        const uint8_t* s;
-        if (!IsMatch(dictionary->words, w, &data[1], max_length - 1)) {
-          continue;
-        }
-        /* Transforms " " + kUppercase{First,All} + "" */
-        AddMatch(id + (is_all_caps ? 85 : 30) * n, l + 1, l, matches);
-        has_found_match = BROTLI_TRUE;
-        if (l + 2 >= max_length) {
-          continue;
-        }
-        /* Transforms " " + kUppercase{First,All} + <suffix> */
-        s = &data[l + 1];
-        if (s[0] == ' ') {
-          AddMatch(id + (is_all_caps ? 83 : 15) * n, l + 2, l, matches);
-        } else if (s[0] == ',') {
-          if (!is_all_caps) {
-            AddMatch(id + 109 * n, l + 2, l, matches);
-          }
-          if (s[1] == ' ') {
-            AddMatch(id + (is_all_caps ? 111 : 65) * n, l + 3, l, matches);
-          }
-        } else if (s[0] == '.') {
-          AddMatch(id + (is_all_caps ? 115 : 96) * n, l + 2, l, matches);
-          if (s[1] == ' ') {
-            AddMatch(id + (is_all_caps ? 117 : 91) * n, l + 3, l, matches);
-          }
-        } else if (s[0] == '=') {
-          if (s[1] == '"') {
-            AddMatch(id + (is_all_caps ? 110 : 118) * n, l + 3, l, matches);
-          } else if (s[1] == '\'') {
-            AddMatch(id + (is_all_caps ? 119 : 120) * n, l + 3, l, matches);
-          }
-        }
-      }
-    }
-  }
-  if (max_length >= 6) {
-    /* Transforms with prefixes "e ", "s ", ", " and "\xC2\xA0" */
-    if ((data[1] == ' ' &&
-         (data[0] == 'e' || data[0] == 's' || data[0] == ',')) ||
-        (data[0] == 0xC2 && data[1] == 0xA0)) {
-      size_t offset = dictionary->buckets[Hash(&data[2])];
-      BROTLI_BOOL end = !offset;
-      while (!end) {
-        DictWord w = dictionary->dict_words[offset++];
-        const size_t l = w.len & 0x1F;
-        const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
-        const size_t id = w.idx;
-        end = !!(w.len & 0x80);
-        w.len = (uint8_t)l;
-        if (w.transform == 0 &&
-            IsMatch(dictionary->words, w, &data[2], max_length - 2)) {
-          if (data[0] == 0xC2) {
-            AddMatch(id + 102 * n, l + 2, l, matches);
-            has_found_match = BROTLI_TRUE;
-          } else if (l + 2 < max_length && data[l + 2] == ' ') {
-            size_t t = data[0] == 'e' ? 18 : (data[0] == 's' ? 7 : 13);
-            AddMatch(id + t * n, l + 3, l, matches);
-            has_found_match = BROTLI_TRUE;
-          }
-        }
-      }
-    }
-  }
-  if (max_length >= 9) {
-    /* Transforms with prefixes " the " and ".com/" */
-    if ((data[0] == ' ' && data[1] == 't' && data[2] == 'h' &&
-         data[3] == 'e' && data[4] == ' ') ||
-        (data[0] == '.' && data[1] == 'c' && data[2] == 'o' &&
-         data[3] == 'm' && data[4] == '/')) {
-      size_t offset = dictionary->buckets[Hash(&data[5])];
-      BROTLI_BOOL end = !offset;
-      while (!end) {
-        DictWord w = dictionary->dict_words[offset++];
-        const size_t l = w.len & 0x1F;
-        const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
-        const size_t id = w.idx;
-        end = !!(w.len & 0x80);
-        w.len = (uint8_t)l;
-        if (w.transform == 0 &&
-            IsMatch(dictionary->words, w, &data[5], max_length - 5)) {
-          AddMatch(id + (data[0] == ' ' ? 41 : 72) * n, l + 5, l, matches);
-          has_found_match = BROTLI_TRUE;
-          if (l + 5 < max_length) {
-            const uint8_t* s = &data[l + 5];
-            if (data[0] == ' ') {
-              if (l + 8 < max_length &&
-                  s[0] == ' ' && s[1] == 'o' && s[2] == 'f' && s[3] == ' ') {
-                AddMatch(id + 62 * n, l + 9, l, matches);
-                if (l + 12 < max_length &&
-                    s[4] == 't' && s[5] == 'h' && s[6] == 'e' && s[7] == ' ') {
-                  AddMatch(id + 73 * n, l + 13, l, matches);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return has_found_match;
-}
-
-/* Finds matches for one or more dictionaries, if multiple are present
-   in the contextual dictionary */
-BROTLI_BOOL duckdb_brotli::BrotliFindAllStaticDictionaryMatches(
-    const BrotliEncoderDictionary* dictionary, const uint8_t* data,
-    size_t min_length, size_t max_length, uint32_t* matches) {
-  BROTLI_BOOL has_found_match =
-      BrotliFindAllStaticDictionaryMatchesFor(
-          dictionary, data, min_length, max_length, matches);
-
-  if (!!dictionary->parent && dictionary->parent->num_dictionaries > 1) {
-    uint32_t matches2[BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1];
-    int l;
-    const BrotliEncoderDictionary* dictionary2 = dictionary->parent->dict[0];
-    if (dictionary2 == dictionary) {
-      dictionary2 = dictionary->parent->dict[1];
-    }
-
-    for (l = 0; l < BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1; l++) {
-      matches2[l] = kInvalidMatch;
-    }
-
-    has_found_match |= BrotliFindAllStaticDictionaryMatchesFor(
-        dictionary2, data, min_length, max_length, matches2);
-
-    for (l = 0; l < BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1; l++) {
-      if (matches2[l] != kInvalidMatch) {
-        uint32_t dist = (uint32_t)(matches2[l] >> 5);
-        uint32_t len_code = matches2[l] & 31;
-        uint32_t skipdist = (uint32_t)((uint32_t)(1 << dictionary->words->
-            size_bits_by_length[len_code]) & ~1u) *
-            (uint32_t)dictionary->num_transforms;
-        /* TODO(lode): check for dist overflow */
-        dist += skipdist;
-        AddMatch(dist, (size_t)l, len_code, matches);
-      }
-    }
-  }
-  return has_found_match;
-}
-
diff --git a/src/duckdb/third_party/brotli/enc/static_dict.h b/src/duckdb/third_party/brotli/enc/static_dict.h
deleted file mode 100644
index 45c805cc2..000000000
--- a/src/duckdb/third_party/brotli/enc/static_dict.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Class to model the static dictionary. */
-
-#ifndef BROTLI_ENC_STATIC_DICT_H_
-#define BROTLI_ENC_STATIC_DICT_H_
-
-#include <brotli/types.h>
-
-#include "../common/dictionary.h"
-#include "../common/brotli_platform.h"
-#include "encoder_dict.h"
-
-namespace duckdb_brotli {
-
-#define BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN 37
-static const uint32_t kInvalidMatch = 0xFFFFFFF;
-
-/* Matches data against static dictionary words, and for each length l,
-   for which a match is found, updates matches[l] to be the minimum possible
-     (distance << 5) + len_code.
-   Returns 1 if matches have been found, otherwise 0.
-   Prerequisites:
-     matches array is at least BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1 long
-     all elements are initialized to kInvalidMatch */
-BROTLI_INTERNAL BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
-    const BrotliEncoderDictionary* dictionary,
-    const uint8_t* data, size_t min_length, size_t max_length,
-    uint32_t* matches);
-
-}
-
-#endif  /* BROTLI_ENC_STATIC_DICT_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/static_dict_lut.h b/src/duckdb/third_party/brotli/enc/static_dict_lut.h
deleted file mode 100644
index 2ce39a298..000000000
--- a/src/duckdb/third_party/brotli/enc/static_dict_lut.h
+++ /dev/null
@@ -1,5862 +0,0 @@
-/* Copyright 2015 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Lookup table for static dictionary and transforms. */
-
-#ifndef BROTLI_ENC_STATIC_DICT_LUT_H_
-#define BROTLI_ENC_STATIC_DICT_LUT_H_
-
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-typedef struct DictWord {
-  /* Highest bit is used to indicate end of bucket. */
-  uint8_t len;
-  uint8_t transform;
-  uint16_t idx;
-} DictWord;
-
-/* GENERATED CODE START */
-static const int kDictNumBits = 15;
-static const uint32_t kDictHashMul32 = 0x1E35A7BD;
-
-static const uint16_t kStaticDictionaryBuckets[32768] = {
-1,0,0,0,0,0,0,0,0,3,6,0,0,0,0,0,20,0,0,0,21,0,22,0,0,0,0,0,0,0,0,23,0,0,25,0,29,
-0,53,0,0,0,0,0,0,55,0,0,0,0,0,0,61,76,0,0,0,94,0,0,0,0,0,0,96,0,97,0,98,0,0,0,0,
-0,0,0,99,101,106,108,0,0,0,0,0,110,0,111,112,0,113,118,124,0,0,0,0,0,125,128,0,0
-,0,0,129,0,0,131,0,0,0,0,0,0,132,0,0,135,0,0,0,137,0,0,0,0,0,138,139,0,0,0,0,0,0
-,0,142,143,144,0,0,0,0,0,145,0,0,0,146,149,151,152,0,0,153,0,0,0,0,0,0,0,0,0,0,0
-,0,0,0,0,154,0,0,0,0,0,0,155,0,0,0,0,160,182,0,0,0,0,0,0,183,0,0,0,188,189,0,0,
-192,0,0,0,0,0,0,194,0,0,0,0,0,0,0,0,197,202,209,0,0,210,0,224,0,0,0,225,0,0,0,0,
-0,0,0,0,0,0,231,0,0,0,232,0,240,0,0,242,0,0,0,0,0,0,0,0,0,0,0,244,0,0,0,246,0,0,
-249,251,253,0,0,0,0,0,258,0,0,261,263,0,0,0,267,0,0,268,0,269,0,0,0,0,0,0,0,0,0,
-271,0,0,0,0,0,0,272,0,273,0,277,0,278,286,0,0,0,0,287,0,289,290,291,0,0,0,295,0,
-0,296,297,0,0,0,0,0,0,0,0,0,0,298,0,0,0,299,0,0,305,0,324,0,0,0,0,0,327,0,328,
-329,0,0,0,0,336,0,0,340,0,341,342,343,0,0,346,0,348,0,0,0,0,0,0,349,351,0,0,355,
-0,363,0,364,0,368,369,0,370,0,0,0,0,0,0,0,372,0,0,0,0,0,0,0,0,0,0,0,373,0,375,0,
-0,0,0,376,377,0,0,394,395,396,0,0,398,0,0,0,0,400,0,0,408,0,0,0,0,420,0,0,0,0,0,
-0,421,0,0,422,423,0,0,429,435,436,442,0,0,443,0,444,445,453,456,0,457,0,0,0,0,0,
-458,0,0,0,459,0,0,0,460,0,462,463,465,0,0,0,0,0,0,466,469,0,0,0,0,0,0,470,0,0,0,
-474,0,476,0,0,0,0,483,0,485,0,0,0,486,0,0,488,491,492,0,0,497,499,500,0,501,0,0,
-0,505,0,0,506,0,0,0,507,0,0,0,509,0,0,0,0,511,512,519,0,0,0,0,0,0,529,530,0,0,0,
-534,0,0,0,0,543,0,0,0,0,0,0,0,0,0,553,0,0,0,0,557,560,0,0,0,0,0,0,561,0,564,0,0,
-0,0,0,0,565,566,0,575,0,619,0,620,0,0,623,624,0,0,0,625,0,0,626,627,0,0,628,0,0,
-0,0,630,0,631,0,0,0,0,0,0,0,0,0,641,0,0,0,0,643,656,668,0,0,0,673,0,0,0,674,0,0,
-0,0,0,0,0,0,682,0,687,0,690,0,693,699,700,0,0,0,0,0,0,704,705,0,0,0,0,707,710,0,
-711,0,0,0,0,726,0,0,729,0,0,0,730,731,0,0,0,0,0,752,0,0,0,762,0,763,0,0,767,0,0,
-0,770,774,0,0,775,0,0,0,0,0,0,0,0,0,0,776,0,0,0,777,783,0,0,0,785,788,0,0,0,0,
-790,0,0,0,793,0,0,0,0,794,0,0,804,819,821,0,827,0,0,0,834,0,0,835,0,0,0,841,0,
-844,0,850,851,859,0,860,0,0,0,0,0,0,0,874,0,876,0,877,890,0,0,0,0,0,0,0,0,893,
-894,898,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,899,0,0,0,900,904,906,0,0,0,907,0,908,909,
-0,910,0,0,0,0,911,0,0,0,0,0,916,0,0,0,922,925,0,930,0,934,0,0,0,0,0,943,0,0,944,
-0,953,954,0,0,0,0,0,0,955,0,962,963,0,0,976,0,0,977,978,979,980,0,981,0,0,0,0,
-984,0,0,985,0,0,987,989,991,0,0,0,0,0,0,0,0,0,992,0,0,0,993,0,0,0,0,0,0,996,0,0,
-0,1000,0,0,0,0,0,1002,0,0,0,0,1005,1007,0,0,0,1009,0,0,0,1010,0,0,0,0,0,0,1011,0
-,1012,0,0,0,0,1014,1016,0,0,0,1020,0,1021,0,0,0,0,1022,0,0,0,1024,0,0,0,0,0,0,
-1025,0,0,1026,1027,0,0,0,0,0,1031,0,1033,0,0,0,0,1034,0,0,0,1037,1040,0,0,0,1042
-,1043,0,0,1053,0,1054,0,0,1057,0,0,0,1058,0,0,1060,0,0,0,0,0,0,0,1061,0,0,1062,0
-,0,0,0,1063,0,0,0,0,1064,0,0,0,0,0,1065,0,0,0,0,1066,1067,0,0,0,1069,1070,1072,0
-,0,0,0,0,0,1073,0,1075,0,0,0,0,0,0,1080,1084,0,0,0,0,1088,0,0,0,0,0,0,1094,0,
-1095,0,1107,0,0,0,1112,1114,0,1119,0,1122,0,0,1126,0,1129,0,1130,0,0,0,0,0,1132,
-0,0,0,0,0,0,1144,0,0,1145,1146,0,1148,1149,0,0,1150,1151,0,0,0,0,1152,0,1153,0,0
-,0,0,0,1154,0,1163,0,0,0,1164,0,0,0,0,0,1165,0,1167,0,1170,0,0,0,0,0,1171,1172,0
-,0,0,0,0,0,0,0,1173,1175,1177,0,1186,0,0,0,0,0,0,0,0,0,0,1195,0,0,1221,0,0,1224,
-0,0,1227,0,0,0,0,0,1228,1229,0,0,1230,0,0,0,0,0,0,0,0,0,1231,0,0,0,1233,0,0,1243
-,1244,1246,1248,0,0,0,0,1254,1255,1258,1259,0,0,0,1260,0,0,1261,0,0,0,1262,1264,
-0,0,1265,0,0,0,0,0,0,0,0,0,0,0,0,1266,0,1267,0,0,0,0,1273,1274,1276,1289,0,0,
-1291,1292,1293,0,0,1294,1295,1296,0,0,0,0,1302,0,1304,0,0,0,0,0,0,0,0,0,1311,
-1312,0,1314,0,1316,1320,1321,0,0,0,0,0,0,0,1322,1323,1324,0,1335,0,1336,0,0,0,0,
-1341,1342,0,1346,0,1357,0,0,0,1358,1360,0,0,0,0,0,0,1361,0,0,0,1362,1365,0,1366,
-0,0,0,0,0,0,0,1379,0,0,0,0,0,0,0,0,0,0,0,0,1386,0,1388,0,0,0,0,0,0,0,0,0,0,0,0,0
-,0,1395,0,0,0,0,1403,0,1405,0,0,1407,0,0,0,0,0,1408,1409,0,1410,0,0,0,1412,1413,
-1416,0,0,1429,1451,0,0,1454,0,0,0,0,0,0,0,1455,0,0,0,0,0,0,0,1456,0,0,0,0,1459,
-1460,1461,1475,0,0,0,0,0,0,1477,0,1480,0,1481,0,0,1486,0,0,1495,0,0,0,1496,0,0,
-1498,1499,1501,1520,1521,0,0,0,1526,0,0,0,0,1528,1529,0,1533,1536,0,0,0,1537,
-1538,1549,0,1550,1558,1559,1572,0,1573,0,0,0,0,0,0,0,0,0,1575,0,0,0,0,0,1579,0,
-1599,0,1603,0,1604,0,1605,0,0,0,0,0,1608,1610,0,0,0,0,1611,0,1615,0,1616,1618,0,
-1619,0,0,1622,0,0,0,0,1634,0,0,0,1635,0,0,0,1641,0,0,0,0,0,0,0,0,0,1643,0,0,0,
-1650,0,0,1652,0,0,0,0,0,1653,0,0,0,1654,0,0,0,0,1655,0,1662,0,0,1663,1664,0,0,
-1668,0,0,1669,1670,0,1672,1673,0,0,0,0,0,1674,0,0,0,1675,1676,1680,0,1682,0,0,
-1687,0,0,0,0,0,1704,0,0,1705,0,0,1721,0,0,0,0,1734,1735,0,0,0,0,1737,0,0,0,0,
-1739,0,0,1740,0,0,0,0,0,0,0,0,0,0,1741,1743,0,0,0,0,1745,0,0,0,1749,0,0,0,1751,0
-,0,0,0,0,0,1760,0,0,0,0,1765,0,0,0,0,0,1784,0,1785,1787,0,0,0,0,1788,1789,0,0,0,
-0,1790,1791,1793,0,1798,1799,0,0,0,0,1801,0,1803,1805,0,0,0,1806,1811,0,1812,
-1814,0,1821,0,0,0,0,0,1822,1833,0,0,0,0,0,0,1848,0,0,0,0,0,0,1857,0,0,0,1859,0,0
-,0,0,1861,0,0,0,0,0,0,0,1866,0,1921,1925,0,0,0,1929,1930,0,0,0,0,0,0,0,0,0,1931,
-0,0,0,0,1932,0,0,0,1934,0,0,0,0,0,0,0,0,1946,0,0,1948,0,0,0,0,1950,0,1957,0,1958
-,0,0,0,0,0,1965,1967,0,0,0,0,1968,0,1969,0,1971,1972,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-,0,1973,0,0,0,0,1975,0,0,0,0,1976,1979,0,1982,0,0,0,0,1984,1988,0,0,0,0,1990,
-2004,2008,0,0,0,2012,2013,0,0,0,0,0,0,0,0,0,0,2015,0,2016,2017,0,0,0,0,2021,0,0,
-2025,0,0,0,0,0,2029,2036,2040,0,2042,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2043,0,0,0,0,0,
-2045,0,0,0,0,0,0,0,2046,2047,0,2048,2049,0,2059,0,0,2063,0,2064,2065,0,0,2066,0,
-0,0,0,0,0,2069,0,0,0,0,2070,0,2071,0,2072,0,0,0,0,2080,2082,2083,0,0,0,0,0,2085,
-0,2086,2088,2089,2105,0,0,0,0,2107,0,0,2116,2117,0,2120,0,0,2122,0,0,0,0,0,2123,
-0,0,2125,2127,2128,0,0,0,2130,0,0,0,2137,2139,2140,2141,0,0,0,0,0,0,0,0,0,2144,
-2145,0,0,2146,2149,0,0,0,0,2150,0,0,2151,2158,0,2159,0,2160,0,0,0,0,0,0,2161,
-2162,0,0,2194,2202,0,0,0,0,0,0,2205,2217,0,2220,0,2221,0,2222,2224,0,0,0,0,2237,
-0,0,0,0,0,2238,0,2239,2241,0,0,2242,0,0,0,0,0,2243,0,0,0,0,0,0,2252,0,0,2253,0,0
-,0,2257,2258,0,0,0,2260,0,0,0,0,0,0,0,2262,0,2264,0,0,0,0,0,2269,2270,0,0,0,0,0,
-0,0,0,0,2271,0,2273,0,0,0,0,2277,0,0,0,0,2278,0,0,0,0,2279,0,2280,0,2283,0,0,0,0
-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2287,0,0,0,0,0,0,0,2289,2290,0,0,0,0,2291,0,2292,0,
-0,0,2293,2295,2296,0,0,0,0,0,0,0,2298,0,0,0,0,0,2303,0,2305,0,0,2306,0,2307,0,0,
-0,0,0,0,0,0,0,0,0,0,2313,2314,2315,2316,0,0,2318,0,2319,0,2322,0,0,2323,0,2324,0
-,2326,0,0,0,0,0,0,0,2335,0,2336,2338,2339,0,2340,0,0,0,2355,0,2375,0,2382,2386,0
-,2387,0,0,2394,0,0,0,0,2395,0,2397,0,0,0,0,0,2398,0,0,0,0,0,0,0,2399,2402,2404,
-2408,2411,0,0,0,2413,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2415,0,0,2416,2417,2419,0,2420,
-0,0,0,0,0,2425,0,0,0,2426,0,0,0,0,0,0,0,0,0,0,0,0,2427,2428,0,2429,0,0,2430,2434
-,0,2436,0,0,0,0,0,0,2441,2442,0,2445,0,0,2446,2457,0,2459,0,0,2462,0,2464,0,2477
-,0,2478,2486,0,0,0,2491,0,0,2493,0,0,2494,0,2495,0,2513,2523,0,0,0,0,2524,0,0,0,
-0,0,0,2528,2529,2530,0,0,2531,0,2533,0,0,2534,2535,0,2536,2537,0,2538,0,2539,
-2540,0,0,0,2545,2546,0,0,0,0,0,0,0,2548,0,0,2549,0,2550,2555,0,0,0,0,0,2557,0,
-2560,0,0,0,0,0,0,0,0,0,0,0,2561,0,2576,0,0,0,0,0,0,0,0,0,2577,2578,0,0,0,2579,0,
-0,0,0,0,0,0,2580,0,0,0,0,2581,0,0,0,0,2583,0,2584,0,2588,2590,0,0,0,2591,0,0,0,0
-,2593,2594,0,2595,0,2601,2602,0,0,2603,0,2605,0,0,0,2606,2607,2611,0,2615,0,0,0,
-2617,0,0,0,0,0,0,0,0,0,0,0,0,0,2619,0,0,2620,0,0,0,2621,0,2623,0,2625,0,0,2628,
-2629,0,0,2635,2636,2637,0,0,2639,0,0,0,2642,0,0,0,0,2643,0,2644,0,2649,0,0,0,0,0
-,0,2655,2656,0,0,2657,0,0,0,0,0,2658,0,0,0,0,0,2659,0,0,0,0,2664,2685,0,2687,0,
-2688,0,0,2689,0,0,2694,0,2695,0,0,2698,0,2701,2706,0,0,0,2707,0,2709,2710,2711,0
-,0,0,2720,2730,2735,0,0,0,0,2738,2740,0,0,0,0,2747,0,0,0,0,0,0,2748,0,0,2749,0,0
-,0,0,0,2750,0,0,2752,2754,0,0,0,0,0,2758,0,0,0,0,2762,0,0,0,0,2763,0,0,0,0,0,0,0
-,2764,2767,0,0,0,0,2768,0,0,2770,0,0,0,0,0,0,0,2771,0,0,0,0,0,0,0,0,0,2772,0,0,0
-,0,0,2773,2776,0,0,2783,0,0,2784,0,2789,0,2790,0,0,0,2792,0,0,0,0,0,0,0,0,0,0,
-2793,2795,0,0,0,0,0,0,2796,0,0,0,0,0,0,2797,2799,0,0,0,0,2803,0,0,0,0,2806,0,
-2807,2808,2817,2819,0,0,0,0,0,2821,0,0,0,0,2822,2823,0,0,0,0,0,0,0,2824,0,0,2828
-,0,2834,0,0,0,0,0,0,2836,0,2838,0,0,2839,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2841,
-0,0,0,2842,0,0,0,0,0,2843,2844,0,0,0,0,2846,0,0,2847,0,2849,0,2853,0,0,0,0,0,
-2857,0,0,0,0,2858,0,2859,0,0,2860,0,2862,2868,0,0,0,0,2875,0,2876,0,0,2877,2878,
-2884,2889,2890,0,0,2891,0,0,2892,0,0,0,2906,2912,0,2913,0,0,0,0,0,0,0,0,2916,0,
-2934,0,0,0,0,0,2935,0,0,0,0,2939,0,2940,0,0,0,0,0,0,0,2941,0,0,0,2946,0,2949,0,0
-,2950,2954,2955,0,0,0,2959,2961,0,0,2962,0,2963,0,0,0,0,0,0,2964,2965,2966,2967,
-0,0,0,0,0,0,0,2969,0,0,0,0,0,2970,2975,0,2982,2983,2984,0,0,0,0,0,2989,0,0,2990,
-0,0,0,0,0,0,0,2991,0,0,0,0,0,0,0,0,2998,0,3000,3001,0,0,3002,0,0,0,3003,0,0,3012
-,0,0,3022,0,0,3024,0,0,3025,3027,0,0,0,3030,0,0,0,0,3034,3035,0,0,3036,0,3039,0,
-3049,0,0,3050,0,0,0,0,0,0,3051,0,3053,0,0,0,0,3057,0,3058,0,0,0,0,0,0,0,0,3063,0
-,0,3073,3074,3078,3079,0,3080,3086,0,0,0,0,0,0,0,0,3087,0,3092,0,3095,0,3099,0,0
-,0,3100,0,3101,3102,0,3122,0,0,0,3124,0,3125,0,0,0,0,0,0,3132,3134,0,0,3136,0,0,
-0,0,0,0,0,3147,0,0,3149,0,0,0,0,0,3150,3151,3152,0,0,0,0,3158,0,0,3160,0,0,3161,
-0,0,3162,0,3163,3166,3168,0,0,3169,3170,0,0,3171,0,0,0,0,0,0,0,3182,0,3184,0,0,
-3188,0,0,3194,0,0,0,0,0,0,3204,0,0,0,0,3209,0,0,0,0,0,0,0,0,0,0,0,3216,3217,0,0,
-0,0,0,0,0,3219,0,0,3220,3222,0,3223,0,0,0,0,3224,0,3225,3226,0,3228,3233,0,3239,
-3241,3242,0,0,3251,3252,3253,3255,0,0,0,0,0,0,0,0,3260,0,0,3261,0,0,0,3267,0,0,0
-,0,0,0,0,0,3271,0,0,0,3278,0,3282,0,0,0,3284,0,0,0,3285,3286,0,0,0,0,0,0,0,3287,
-3292,0,0,0,0,3294,3296,0,0,3299,3300,3301,0,3302,0,0,0,0,0,3304,3306,0,0,0,0,0,0
-,3308,0,0,0,0,0,0,0,0,0,3311,0,0,0,0,0,0,0,0,3312,3314,3315,0,3318,0,0,0,0,0,0,0
-,0,3319,0,0,0,0,0,3321,0,0,0,0,0,0,0,0,0,3322,0,0,3324,3325,0,0,3326,0,0,3328,
-3329,3331,0,0,3335,0,0,3337,0,3338,0,0,0,0,3343,3347,0,0,0,3348,0,0,3351,0,0,0,0
-,0,0,3354,0,0,0,0,0,0,0,0,0,0,3355,0,0,3365,3366,3367,0,0,0,0,0,0,3368,3369,0,
-3370,0,0,3373,0,0,3376,0,0,3377,0,3379,3387,0,0,0,0,0,3390,0,0,0,0,0,0,0,3402,0,
-3403,3436,3437,3439,0,0,3441,0,0,0,3442,0,0,3449,0,0,0,3450,0,0,0,0,0,0,0,3451,0
-,0,3452,0,3453,3456,0,3457,0,0,3458,0,3459,0,0,0,0,0,0,0,0,0,3460,0,0,3469,3470,
-0,0,3475,0,0,0,3480,3487,3489,0,3490,0,0,3491,3499,0,3500,0,0,3501,0,0,0,3502,0,
-3514,0,0,0,3516,3517,0,0,0,3518,0,0,0,0,3520,3521,3522,0,0,3526,3530,0,0,0,0,
-3531,0,0,0,0,3536,0,0,0,0,0,0,0,3539,3541,0,0,3542,3544,0,3547,3548,0,0,3550,0,
-3553,0,0,0,0,0,0,0,3554,0,3555,0,3558,0,3559,0,0,0,0,0,0,0,0,3563,0,3581,0,0,0,
-3599,0,0,0,3600,0,3601,0,3602,3603,0,0,3606,3608,0,3610,3611,0,0,0,0,0,0,0,0,0,
-3612,3616,3619,0,0,0,0,0,0,0,0,0,0,0,0,0,3624,3628,0,3629,3634,3635,0,0,0,0,0,0,
-3636,0,3637,0,0,3638,3651,0,0,0,0,0,0,3652,3653,0,0,0,0,3656,3657,0,0,0,0,0,3658
-,0,0,0,0,3659,0,3661,3663,3664,0,3665,0,3692,0,0,0,3694,3696,0,0,0,0,0,0,0,0,0,0
-,0,0,3698,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3700,0,0,3701,0,0,0,3708,3709,0,0,0,3711
-,3712,0,0,0,0,0,3723,0,3724,3725,0,0,3726,0,0,0,0,0,0,3728,3729,0,3734,3735,3737
-,0,0,0,3743,0,3745,0,0,3746,0,0,3747,3748,0,3757,0,3759,3766,3767,0,3768,0,0,0,0
-,3769,0,0,3771,0,3774,0,0,0,0,0,0,3775,0,0,0,0,0,0,3776,0,3777,3786,0,3788,3789,
-0,0,0,0,0,0,0,0,0,3791,0,3811,0,0,0,0,0,3814,3815,3816,3820,0,0,0,0,0,0,0,3821,0
-,0,3825,0,0,0,0,3835,0,0,3848,3849,0,0,0,0,3850,3851,3853,0,0,0,0,3859,0,3860,
-3862,0,0,0,0,0,3863,0,0,0,0,0,0,0,0,3873,0,3874,0,3875,3886,0,3887,0,0,0,0,3892,
-3913,0,3914,0,0,0,3925,3931,0,0,0,0,3934,3941,3942,0,0,0,0,3943,0,0,0,3944,0,0,0
-,0,0,3945,0,3947,0,0,0,3956,3957,0,0,0,0,0,0,0,0,0,3958,0,3959,3965,0,0,0,0,3966
-,0,0,0,3967,0,0,0,3968,3974,0,0,0,0,0,3975,3977,3978,0,0,0,0,3980,0,3985,0,0,0,0
-,0,0,0,0,3986,4011,0,0,4017,0,0,0,0,0,0,0,0,0,0,0,4018,0,0,0,0,4019,0,4023,0,0,0
-,4027,4028,0,0,0,0,0,0,0,0,4031,4034,0,0,4035,4037,4039,4040,0,0,0,0,0,4059,0,
-4060,4061,0,4062,4063,4066,0,0,4072,0,0,0,0,0,0,0,0,0,0,0,0,0,4088,0,0,0,0,0,
-4091,0,0,0,0,4094,4095,0,0,4096,0,0,0,0,0,4098,4099,0,0,0,4101,0,4104,0,0,0,4105
-,4108,0,4113,0,0,4115,4116,0,4126,0,0,4127,0,0,0,0,0,0,0,4128,4132,4133,0,4134,0
-,0,0,4137,0,0,4141,0,0,0,0,4144,4146,4147,0,0,0,0,4148,0,0,4311,0,0,0,4314,4329,
-0,4331,4332,0,4333,0,4334,0,0,0,4335,0,4336,0,0,0,4337,0,0,0,4342,4345,4346,4350
-,0,4351,4352,0,4354,4355,0,0,4364,0,0,0,0,4369,0,0,0,4373,0,4374,0,0,0,0,4377,0,
-0,0,0,4378,0,0,0,4380,0,0,0,4381,4382,0,0,0,0,0,0,0,4384,0,0,0,0,4385,0,0,0,4386
-,0,0,0,4391,4398,0,0,0,0,4407,4409,0,0,0,0,4410,0,0,4411,0,4414,4415,4418,0,4427
-,4428,4430,0,4431,0,4448,0,0,0,0,0,4449,0,0,0,4451,4452,0,4453,4454,0,4456,0,0,0
-,0,0,0,0,4459,0,4463,0,0,0,0,0,4466,0,4467,0,4469,0,0,0,0,0,0,0,0,0,0,0,0,0,4470
-,4471,0,4473,0,0,4475,0,0,0,0,4477,4478,0,0,0,4479,4481,0,4482,0,4484,0,0,0,0,0,
-0,0,4486,0,0,4488,0,0,4497,0,4508,0,0,4510,4511,0,4520,4523,0,4524,0,4525,0,4527
-,0,0,4528,0,0,0,0,4530,0,4531,0,0,4532,0,0,0,4533,0,0,0,0,0,4535,0,0,0,4536,0,0,
-0,0,0,4541,4543,4544,4545,4547,0,4548,0,0,0,0,4550,4551,0,4553,0,0,0,0,4562,0,0,
-4571,0,0,0,4574,0,0,0,4575,0,4576,0,4577,0,0,0,4581,0,0,0,0,0,4582,0,0,4586,0,0,
-0,4588,0,0,4597,0,4598,0,0,0,0,4616,4617,0,4618,0,0,0,0,4619,0,4620,0,0,4621,0,
-4624,0,0,0,0,0,4625,0,0,0,0,4657,0,4659,0,4667,0,0,0,4668,4670,0,4672,0,0,0,0,0,
-4673,4676,0,0,0,0,4687,0,0,0,0,4697,0,0,0,0,4699,0,4701,0,0,0,0,4702,0,0,4706,0,
-0,4713,0,0,0,4714,4715,4716,0,0,0,0,0,0,0,0,0,0,0,0,4717,0,0,4720,0,4721,4729,
-4735,0,0,0,4737,0,0,0,4739,0,0,0,4740,0,0,0,4741,0,0,0,0,0,4742,0,4745,4746,4747
-,0,0,0,0,0,0,0,0,4748,0,0,0,4749,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4751,
-4786,0,4787,0,4788,4796,0,0,4797,4798,0,4799,4806,4807,0,0,0,0,4809,4810,0,0,0,0
-,0,0,4811,0,0,0,0,0,4812,0,4813,0,0,4815,0,4821,4822,0,0,0,0,4823,0,0,0,0,0,0,0,
-0,0,0,4824,0,0,0,0,4826,0,0,0,4828,0,4829,0,0,0,4843,0,0,4847,0,4853,4855,4858,0
-,0,0,0,0,4859,0,4864,0,0,4879,0,0,0,0,4880,0,0,0,0,4881,0,4882,0,0,0,0,0,0,0,0,0
-,4883,0,0,0,0,4884,0,0,0,0,0,4886,4887,4888,4894,4896,0,4902,0,0,4905,0,0,4915,0
-,0,0,0,0,0,0,4916,4917,4919,4921,0,0,0,0,0,4926,0,0,0,0,4927,0,0,0,0,0,0,0,0,
-4929,0,4930,4931,0,4938,0,4952,0,4953,4957,4960,4964,0,0,0,0,0,0,0,5019,5020,
-5022,0,0,0,0,0,5023,0,0,0,5024,0,0,0,5025,0,0,0,0,5028,0,0,0,0,5029,5030,5031,0,
-5033,0,0,0,0,0,0,0,0,0,5034,5035,0,5036,0,0,5037,0,0,0,0,5038,0,0,5039,0,0,0,
-5041,5042,0,0,0,0,5044,5049,5054,0,5055,0,5057,0,0,0,5060,0,0,0,0,0,5063,0,5064,
-5065,0,5067,0,0,0,5068,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5076,0,0,0,0,0,0,
-0,5077,0,0,5078,5080,0,0,5083,0,0,0,0,0,0,0,0,5085,0,0,0,0,0,0,5098,5099,5101,
-5105,5107,0,5108,0,5109,0,0,0,0,0,0,0,5110,0,0,0,0,0,5117,5118,0,5121,0,5122,0,0
-,5130,0,0,0,5137,0,0,0,5148,0,0,0,0,0,0,0,5151,5154,0,0,0,5155,0,0,5156,5159,
-5161,0,0,0,0,5162,0,0,0,0,5163,5164,0,5166,0,0,0,0,0,0,0,0,0,0,5167,0,0,0,5172,0
-,0,0,0,0,0,5178,5179,0,0,5190,0,0,5191,5192,5194,0,0,5198,5201,0,0,0,0,0,5203,0,
-5206,5209,0,0,0,0,0,0,5213,0,5214,5216,0,0,0,0,0,5217,0,0,0,0,0,0,0,0,5218,5219,
-0,5231,0,0,5244,5249,0,5254,0,5255,0,0,5257,0,0,0,0,0,5258,0,5260,5270,0,5277,0,
-0,0,0,0,0,5280,5281,5282,5283,0,0,0,0,0,5284,0,5285,0,0,0,0,0,5287,5288,0,0,0,0,
-0,0,0,0,0,0,5289,5291,0,0,5294,0,0,5295,0,0,0,0,0,0,0,5304,0,0,5306,5307,5308,0,
-5309,0,0,5310,0,0,0,0,5311,5312,0,5313,0,0,0,0,0,5316,0,0,0,5317,0,0,0,0,0,0,0,0
-,0,5325,0,0,0,0,0,0,5326,0,5327,5329,0,5332,0,0,0,0,5338,0,0,0,0,0,0,0,0,5340,0,
-0,5341,0,0,0,5342,0,5343,5344,0,0,5345,0,0,0,0,0,0,5347,5348,0,0,0,0,0,0,0,0,0,
-5349,0,5350,0,5354,0,0,0,0,5358,0,0,5359,0,0,5361,0,0,5365,0,5367,0,5373,0,0,0,
-5379,0,0,0,5380,0,0,0,5382,0,5384,0,0,0,0,0,0,5385,0,0,0,0,5387,0,0,0,0,0,0,5388
-,5390,5393,0,0,0,0,0,0,0,0,0,0,0,5396,0,0,0,0,5397,5402,0,0,0,0,0,5403,0,0,0,
-5404,5405,0,0,0,0,0,0,0,0,0,0,0,0,5406,0,0,0,0,5410,0,0,5411,0,5415,0,0,0,0,5416
-,5434,0,0,0,0,0,0,0,0,0,0,0,5438,0,5440,0,0,0,0,0,0,5441,5442,0,0,0,5443,5444,
-5447,0,0,5448,5449,5451,0,0,0,5456,5457,0,0,0,5459,0,0,0,5461,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,5464,0,5466,0,0,5467,0,5470,0,0,5473,0,0,5474,0,0,5476,0,0,0,0,0,0,0,0
-,0,0,0,5477,0,0,0,0,0,0,0,5484,0,0,5485,5486,0,0,0,0,0,5488,0,0,0,0,0,0,0,5489,0
-,0,0,0,0,5507,0,0,0,5510,0,5511,0,0,5512,0,0,0,5513,0,5515,0,0,5516,5517,0,5518,
-0,0,5522,0,0,0,0,0,5534,5535,0,0,5536,0,5538,0,0,5543,0,5544,0,0,5545,0,5547,0,
-5557,0,0,5558,0,5560,5567,0,0,0,0,5568,0,0,0,5571,5573,0,5574,0,5575,0,0,0,0,
-5577,0,0,5598,0,0,0,0,0,0,0,0,0,5600,5609,0,0,0,0,5610,0,0,5612,0,5624,0,5625,0,
-0,0,5629,0,5641,0,5642,5643,0,0,0,0,0,0,5651,0,0,0,5652,5653,0,5661,5662,5678,0,
-5679,0,0,0,0,5685,5686,0,0,0,0,0,5690,5692,0,5703,0,0,0,0,0,5706,0,0,0,0,5707,0,
-0,0,0,0,0,5708,0,0,5709,0,5710,0,0,0,5712,0,5733,0,5734,5735,0,0,5744,5751,0,0,0
-,0,0,0,0,0,0,0,0,0,5752,0,5754,0,0,0,0,0,0,5757,5758,0,5760,5761,0,0,0,0,5763,
-5764,5765,0,5766,0,5767,5768,0,5770,0,0,0,0,5776,5780,0,0,0,0,5782,0,0,0,0,5784,
-0,0,5788,0,0,0,0,0,0,0,0,0,0,0,5797,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5799,0,0,5801,
-0,0,0,5811,0,0,0,0,0,0,5816,0,0,5827,0,0,0,0,0,0,0,0,5830,5831,0,0,5832,0,0,5833
-,0,5835,5844,5845,0,5846,0,0,0,0,0,5850,0,0,0,0,0,5852,0,5855,5857,0,0,5859,0,
-5861,0,0,5863,0,5865,0,0,0,5873,5875,0,0,0,5877,0,5879,0,0,0,5888,0,0,5889,5891,
-0,5894,0,0,0,0,0,0,5895,0,5897,0,0,0,0,0,0,5907,0,5911,0,0,5912,0,5913,5922,5924
-,0,5927,5928,0,0,0,0,5929,5930,0,5933,0,0,0,0,5949,0,0,5951,0,0,0,0,0,0,0,0,5953
-,0,0,5954,0,5959,5960,5961,0,5964,0,0,0,5976,5978,5987,5990,0,0,0,0,0,5991,0,
-5992,0,0,0,5994,5995,0,0,5996,0,0,6001,6003,0,0,0,0,6007,0,0,0,0,0,6008,0,0,6009
-,0,6010,0,0,0,6011,6015,0,6017,0,6019,0,6023,0,0,0,0,0,0,0,6025,0,0,0,0,0,0,0,0,
-0,0,6026,0,6030,0,0,6032,0,0,0,6033,6038,6040,0,0,0,6041,6045,0,0,6046,0,0,6053,
-0,0,6054,0,6055,0,0,0,0,0,0,6057,0,6063,0,0,0,6064,0,6066,6071,6072,0,0,0,0,0,0,
-6075,6076,0,0,6077,0,0,0,0,0,0,0,0,0,6078,6079,0,0,0,0,0,0,0,0,6080,0,6083,0,0,0
-,0,0,6084,0,0,6088,0,6089,0,0,6093,6105,0,0,6107,0,6110,0,0,0,6111,6125,6126,0,0
-,0,6129,0,0,0,0,6130,0,0,0,6131,6134,0,0,0,0,0,0,6142,0,0,0,0,0,6144,0,0,6146,
-6151,6153,0,6156,0,6163,0,6180,6181,0,0,0,0,0,6182,0,0,0,0,6184,6195,0,0,6206,0,
-6208,0,0,6212,6213,6214,0,6215,0,0,0,6228,0,0,0,6234,0,0,0,0,0,0,6235,6240,0,
-6242,6243,6244,0,6250,6255,0,0,0,0,0,6257,0,0,0,6258,6278,0,6284,0,0,0,6285,0,0,
-0,0,0,0,0,0,6286,0,0,0,6320,0,0,6322,6332,0,0,0,0,0,0,0,0,6334,0,0,0,0,0,0,0,
-6335,0,0,6337,0,6338,0,6339,6340,0,0,6356,6357,6369,0,0,0,6370,6371,6372,0,6373,
-0,0,0,0,0,6376,0,0,0,0,0,6382,6383,6384,0,0,0,0,6386,0,6389,6397,6400,6411,0,
-6414,0,0,0,0,0,0,0,6415,6416,0,0,0,0,0,0,6417,0,0,0,0,6418,0,0,0,0,0,0,0,6420,0,
-6421,6423,6425,0,6429,6430,0,6433,6438,0,0,0,0,0,0,0,0,0,0,6439,6440,0,0,6441,0,
-0,6444,0,0,0,0,6446,0,0,0,0,6447,6448,0,0,6450,0,0,0,6454,0,0,6455,0,6461,0,0,0,
-0,0,0,6462,0,0,6463,0,6464,0,6465,6467,0,0,0,6468,0,6479,6480,0,0,0,0,0,0,0,6481
-,0,0,6485,6487,0,0,0,0,0,0,6493,0,0,0,0,0,0,0,0,6494,6495,6496,0,0,0,0,0,6498,0,
-0,0,6507,6508,0,0,0,0,0,0,0,0,0,0,6511,6512,0,0,0,0,6513,0,0,0,6514,0,0,0,0,0,
-6516,0,0,6517,6518,0,0,0,6519,6520,6521,0,6523,0,0,0,0,6524,6528,0,6530,0,0,6532
-,0,6578,0,0,0,6583,0,6584,0,0,0,6587,0,0,0,6590,0,6591,0,0,0,0,0,6592,0,0,0,0,
-6593,6594,0,0,0,0,0,6599,6600,0,0,6601,6602,6604,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-6608,0,0,0,0,0,0,0,0,6610,6611,0,6615,0,6616,6618,6620,0,6637,0,0,0,0,6639,0,0,0
-,0,6641,0,6642,0,0,0,6647,0,6660,6663,0,6664,0,6666,6669,0,6675,6676,6677,0,0,0,
-0,0,0,0,0,0,6678,0,0,0,6679,0,6680,0,0,0,0,0,0,0,6693,0,0,0,0,0,0,0,0,0,6704,
-6705,6706,0,0,6711,6713,0,0,0,0,0,6716,0,0,0,6717,0,6719,6724,0,0,0,0,0,0,0,0,
-6725,6726,0,0,0,0,0,6728,6729,6735,0,6737,6742,0,0,6743,6750,0,6751,0,0,6752,
-6753,0,0,0,0,0,0,6754,0,0,0,0,0,6756,0,0,0,0,0,0,6763,0,0,6764,6765,0,0,0,6770,0
-,0,0,6776,6780,0,6781,0,0,0,6783,0,6784,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-6785,0,0,0,6792,0,0,0,6793,0,0,6802,0,0,0,0,0,6803,0,0,0,6804,0,0,0,6812,0,0,
-6823,0,6824,6839,0,0,0,0,6852,0,0,6854,0,6856,6857,0,0,0,0,0,0,0,0,0,6867,0,6868
-,6870,6872,0,0,0,6873,6874,0,0,0,0,0,6875,0,0,6877,0,0,0,0,0,0,0,6878,0,0,0,6879
-,0,6880,0,0,0,0,0,0,0,0,0,0,6887,0,6888,6891,6893,0,6895,0,0,0,0,0,0,0,0,6899,0,
-0,0,0,6901,0,0,0,0,6910,0,6911,0,0,6912,0,0,6913,6914,0,0,0,6915,0,0,0,6916,6919
-,0,0,0,0,0,0,6924,0,6925,0,0,0,6926,6927,6928,0,6929,0,6930,0,0,6931,6935,0,6936
-,0,0,0,0,6939,6940,6941,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6942,6948,6949,0,0,0,0,0,0
-,0,6952,6954,6963,6965,6966,0,0,6967,6968,0,0,0,0,0,0,0,0,0,6969,0,0,6970,6979,0
-,0,6980,0,0,6983,0,0,0,0,0,6984,0,0,0,0,0,0,0,6988,6990,6992,0,0,0,0,0,0,0,6995,
-0,0,0,7012,0,0,0,0,0,0,0,0,0,7019,0,0,0,0,0,0,0,0,7021,0,0,7022,7023,7028,0,7030
-,7033,0,0,0,0,0,0,7038,0,0,0,0,0,0,0,0,0,0,7039,0,0,0,0,0,7046,0,7047,0,0,0,0,0,
-0,0,0,0,0,0,7048,7052,0,0,0,0,0,7054,0,7060,0,0,0,0,7061,0,7065,0,0,0,0,7067,
-7069,0,7070,7071,7072,0,0,7078,0,7080,7081,0,7083,0,0,0,7084,7087,7088,0,0,7090,
-0,7093,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7107,0,0,7108,0,0,0,0,0,0,0,0,7110,0,7114,0
-,0,0,0,0,0,0,7115,0,7116,0,0,0,0,0,7117,0,0,7118,0,0,7124,0,7125,0,0,7126,0,0,0,
-0,7128,0,0,0,0,0,7129,0,7130,0,7132,7133,0,0,7134,0,0,7139,0,7148,7150,0,0,0,0,
-7152,0,0,0,7153,7156,7157,0,0,0,0,0,7158,0,0,0,0,0,0,0,0,0,0,7163,7165,7169,0,
-7171,0,0,0,0,0,0,0,0,0,7172,0,7173,7181,0,0,0,0,0,7182,7185,0,0,0,0,7187,0,7201,
-7204,0,0,0,0,0,7206,7207,0,0,0,0,7211,7216,0,7218,0,0,0,0,7226,7228,7230,7232,
-7233,7235,7237,0,0,0,0,7238,7241,0,7242,0,0,7247,0,0,0,7266,0,0,0,0,0,0,0,7289,0
-,0,7290,7291,0,0,7292,0,7297,0,0,0,0,0,0,0,0,0,0,7300,0,7301,0,0,0,0,0,0,0,0,0,0
-,0,0,7302,0,0,0,0,7305,0,0,0,0,7307,0,7308,0,7310,0,7335,0,0,0,0,0,0,0,7337,0,
-7343,7347,0,0,0,0,0,7348,0,7349,7350,7352,7354,0,0,0,0,7357,0,7358,7366,0,7367,
-7368,0,0,7373,0,0,0,7374,0,0,0,0,0,0,0,7376,0,0,0,7377,0,0,0,0,0,7378,0,7379,
-7380,0,0,0,0,0,7383,0,0,7386,0,0,0,0,7398,0,0,0,7399,7400,0,7401,0,0,0,0,0,0,0,
-7402,0,0,0,0,0,7405,0,0,0,0,0,7406,0,0,0,0,0,0,0,0,7421,7427,7429,0,0,0,7435,0,0
-,7436,0,0,0,7437,0,0,0,0,0,0,7438,7443,0,7446,0,7448,0,0,0,0,0,0,0,0,0,0,7456,0,
-0,0,0,0,7457,0,0,7461,0,0,0,0,0,7462,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7463,7466,7472,
-0,7476,0,0,7490,0,7491,0,0,7493,0,0,0,7498,7499,0,0,7508,0,0,0,0,0,7512,0,0,0,
-7513,7514,7516,0,0,0,0,7518,0,0,7519,7521,7522,0,0,0,7526,0,0,7529,0,0,7531,0,
-7536,0,7538,0,7539,0,0,7541,7542,7546,0,0,0,0,0,7547,0,7548,0,0,0,0,0,7550,0,0,
-7552,7553,0,0,0,0,0,0,0,0,0,0,7554,7563,0,7573,0,0,0,0,0,0,7574,7576,0,7578,7581
-,7583,0,0,0,7584,0,7587,0,0,0,0,0,7589,0,0,0,7594,0,0,7595,0,0,7600,7602,7610,0,
-0,0,0,0,7612,0,7613,7614,0,0,7615,0,0,7616,0,7620,0,7621,7622,0,7623,0,0,0,0,
-7626,0,0,0,0,7627,7629,7631,0,0,7633,0,0,0,0,0,7639,0,7640,7642,0,0,7643,0,0,0,0
-,7644,0,0,0,0,0,0,0,7645,0,0,0,0,0,7661,7662,7663,7665,0,7666,0,7667,0,7684,7688
-,7690,0,7691,0,0,0,0,0,0,7692,0,0,7700,0,7707,0,7708,0,7709,0,7721,0,0,0,7722,0,
-7724,0,0,0,0,0,0,7729,7731,0,7732,0,7733,7735,0,0,0,0,0,0,0,7739,0,0,7741,7745,0
-,7748,0,0,0,7751,0,0,0,7752,0,0,0,0,0,0,0,7753,0,0,7756,0,7757,0,7759,0,7760,0,0
-,0,0,7761,7768,0,0,7769,0,0,7770,0,0,7771,0,0,7772,0,0,7773,0,0,0,0,0,7778,7783,
-0,0,0,0,0,7784,7785,0,7790,0,0,0,0,7792,0,7798,0,0,0,0,0,7799,0,7810,0,0,7813,0,
-7814,0,7816,0,7818,7824,7825,7826,0,7828,7830,0,0,0,7840,0,7842,0,7843,0,0,0,0,
-7844,0,0,0,0,0,0,0,7846,0,0,0,0,0,7856,7857,7858,7862,0,7865,0,0,7866,0,0,7913,0
-,0,0,0,7914,0,0,7915,7917,7918,7919,0,7920,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7921,
-7922,0,7924,0,0,7925,0,0,7927,0,7930,7935,0,0,7937,0,0,0,0,0,0,7939,0,7940,0,0,0
-,0,0,7941,0,0,0,0,7945,0,0,0,0,7949,0,0,0,0,0,0,0,0,7950,0,7953,0,0,0,0,0,0,0,
-7968,0,0,0,0,7969,7972,7992,0,7993,0,0,0,0,0,0,0,0,0,0,0,7994,0,0,0,0,8007,8008,
-0,0,0,0,0,0,0,0,0,0,0,0,8010,0,0,0,8012,0,0,0,0,0,0,0,0,8018,0,8028,8029,0,0,
-8030,0,0,8032,8033,0,0,8034,8036,0,0,0,0,0,0,0,0,0,0,8037,0,0,0,8043,8052,8059,
-8060,0,0,8061,0,0,0,8062,0,8063,0,8064,0,8066,8068,0,0,0,8080,8081,0,8089,0,0,0,
-0,0,8092,0,0,0,0,0,0,8093,8110,0,0,0,0,0,0,0,8111,0,0,0,0,0,8112,8115,0,8117,0,0
-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8120,8121,8122,8128,8129,8130,8131,0,0,8139,0,0,
-8144,0,0,0,0,8145,8146,8153,0,0,0,0,0,0,0,0,8154,0,8157,8160,8162,0,8164,8165,0,
-0,0,0,8166,8167,0,0,8179,0,0,0,8185,0,0,0,8186,0,0,8187,0,0,0,8188,0,0,0,0,0,
-8204,0,0,0,0,8210,0,0,0,0,0,8213,0,8214,0,0,8215,0,0,0,0,0,0,8218,0,0,0,0,0,0,0,
-0,0,8219,0,8221,0,0,8222,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8225,0,0,0,8233,0,0,
-8242,0,0,0,0,0,0,0,0,0,0,0,8247,0,8248,8252,0,8256,8257,0,0,8261,0,8264,8265,0,0
-,0,0,8267,0,0,0,8269,0,0,0,0,0,0,0,0,0,8270,0,0,0,8278,0,8279,8283,0,0,8285,8286
-,8289,8292,0,0,0,0,8293,8295,8299,8300,8301,0,0,0,0,0,0,8304,8307,0,0,0,0,0,0,0,
-8321,0,0,0,8322,8323,8325,8326,8327,0,0,8332,8338,0,0,8340,0,0,0,0,0,8350,0,0,
-8351,0,8354,8355,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8360,8372,0,0,0,0,0,0,0,0,8377,0,0,
-0,0,8380,0,0,0,8383,0,8384,0,0,0,0,8386,8392,0,0,8394,0,0,0,0,0,0,0,8396,8397,0,
-8398,0,8399,0,0,0,0,0,8400,0,8401,8410,8411,0,8412,8413,8422,0,0,0,0,8423,0,0,0,
-0,8424,0,0,8425,0,0,0,0,0,0,0,8441,8442,0,0,0,0,0,0,8443,0,0,8444,0,8447,0,0,0,0
-,8451,0,8458,0,8462,0,0,8468,0,8469,0,0,0,8470,0,8473,8479,8480,0,0,0,0,8481,
-8483,0,0,0,0,0,0,0,0,0,8484,0,0,8490,0,0,0,0,0,0,8491,8493,8494,0,8528,0,0,0,0,0
-,0,0,8530,0,0,0,0,0,0,0,0,8534,8538,8540,0,0,8541,0,0,8545,0,8557,0,0,8569,8570,
-0,0,8571,8574,8575,8579,0,8583,0,0,0,0,8591,0,0,0,0,0,0,0,0,8606,0,8607,0,0,0,0,
-0,0,0,0,0,8608,0,0,8609,0,0,0,8610,0,0,0,8611,0,0,8613,8617,8621,0,0,8622,0,8623
-,0,8624,8625,0,0,0,0,0,0,0,0,0,8637,8638,8639,8650,0,0,0,0,8652,8654,8655,0,0,0,
-0,0,0,0,0,0,0,8656,0,0,0,0,0,8657,0,0,0,0,0,0,0,0,0,8658,0,0,8659,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,8660,0,0,0,0,0,0,8661,8663,8664,0,0,0,0,8665,0,8669,0,
-0,0,0,0,0,0,8671,8674,0,8684,0,8686,0,0,0,8689,0,0,0,8690,0,8706,0,0,0,0,0,0,0,0
-,0,0,0,8710,0,8711,8713,8714,8724,8727,8728,8733,8736,0,8737,8739,0,0,0,0,8742,
-8743,8745,8754,0,0,0,0,8756,0,0,0,0,0,0,8757,8760,0,0,0,0,0,8762,8763,8764,0,
-8766,8769,8770,8773,0,8774,0,8779,0,0,0,0,8780,0,0,8781,0,0,8783,0,0,0,0,0,0,0,0
-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8784,0,0,0,0,0,0,0,0,8785,0,0,0,0,8786,0,0,0,0,8788
-,8790,0,0,0,8803,0,8813,8814,0,0,0,0,0,8815,8816,0,0,0,0,8818,0,0,0,0,8822,8828,
-8829,0,8831,0,0,0,0,8833,0,0,0,8834,0,0,0,8835,0,8836,0,0,0,8837,0,0,0,0,0,0,
-8838,8839,0,0,0,0,0,0,0,0,0,0,0,8840,0,0,0,8841,0,8842,0,0,0,8846,0,0,0,0,0,0,0,
-8847,0,8848,0,0,8864,0,0,8866,0,0,8870,8872,0,0,8873,8874,0,0,0,0,0,0,8875,0,
-8876,0,0,0,0,8896,8900,0,0,0,0,8901,0,0,0,0,0,8904,0,8907,0,0,0,0,8911,8912,8913
-,0,0,0,8914,0,8915,0,0,0,0,0,0,0,0,0,0,0,0,8916,0,0,0,8929,0,0,0,0,0,0,0,0,0,0,
-8930,0,8932,0,8943,0,0,0,8945,8947,0,0,0,0,8949,0,8950,0,8954,8957,0,0,8970,0,0,
-0,0,8971,0,8996,0,0,0,0,8997,9000,0,0,0,0,9001,9002,0,9004,9009,9024,0,0,0,0,0,0
-,0,0,0,0,0,0,9027,9082,0,0,9083,9089,0,0,0,0,0,0,9090,0,0,0,9092,0,0,9093,0,9095
-,0,0,9096,9097,9101,9102,0,0,0,0,0,0,0,0,9112,0,0,0,0,0,0,9114,0,0,9120,0,9121,
-9122,0,0,0,9123,9124,0,0,9125,0,0,9126,0,9127,0,0,9129,9131,0,0,0,9132,0,0,9136,
-0,9144,0,0,9148,0,0,0,0,0,0,9149,0,9152,9163,0,0,9165,0,0,0,0,0,0,0,0,0,0,0,0,0,
-9166,0,9169,0,0,0,0,0,0,0,9170,0,0,0,0,9172,0,9174,9175,9176,0,9177,0,0,0,0,0,0,
-0,0,9186,0,9187,0,0,0,9188,9189,0,0,9190,0,0,0,0,9191,0,0,0,9193,0,0,0,0,9197,
-9198,0,0,0,9208,9211,0,0,0,0,9216,9217,0,9220,0,0,0,0,9221,9222,9223,0,9224,9225
-,0,0,9227,0,9228,9229,0,0,9230,0,9232,0,9233,0,0,0,0,0,9234,9235,0,0,9237,0,0,0,
-0,0,0,0,0,9238,9240,0,0,9241,0,0,0,0,9244,0,0,0,0,9247,0,0,0,0,0,0,0,0,0,0,9248,
-0,0,0,9249,0,0,0,0,0,9250,0,0,0,0,9251,0,0,9252,9255,0,0,0,9256,0,0,0,0,0,0,0,
-9257,0,0,9258,0,0,0,0,0,0,9259,0,0,0,0,0,9262,9263,0,0,9265,9266,0,0,0,0,0,0,0,0
-,9268,9271,0,0,0,0,0,0,0,0,0,9273,0,0,0,9276,9277,9279,0,0,0,0,0,0,0,9280,0,0,
-9293,0,0,0,0,0,9297,9301,0,0,0,0,0,0,0,0,0,0,0,9308,9309,9313,9321,9322,0,9326,
-9327,0,0,9477,0,9479,0,0,0,0,9482,0,0,0,9483,0,9484,0,0,0,0,0,0,0,0,0,9485,0,0,
-9486,0,0,0,9489,0,0,0,0,9490,9491,0,0,0,0,9493,0,9495,9496,0,0,0,0,0,0,0,0,9500,
-0,9502,0,0,0,0,0,9504,9507,0,9509,0,9511,0,0,9513,0,0,0,0,0,0,0,0,9515,0,0,0,0,0
-,0,9516,9517,0,0,0,0,9532,0,0,9533,0,0,9538,0,9539,9540,0,0,0,0,9541,0,0,0,9542,
-0,0,0,0,0,0,0,0,9544,9545,0,9546,0,0,0,0,0,0,9547,9548,0,0,0,9550,0,9557,0,9558,
-0,9561,0,9563,9570,0,9572,9574,9575,0,0,0,9577,9592,0,0,9596,0,0,0,9598,0,9600,0
-,9601,0,0,0,0,0,0,9608,0,9638,9639,0,0,0,0,0,0,0,9641,0,0,9643,9644,9645,9646,0,
-0,0,9648,0,0,0,0,0,0,0,9650,9654,0,0,0,0,0,0,0,0,9655,0,0,0,0,0,9656,0,9657,0,0,
-0,0,9658,0,0,9659,0,0,9664,0,0,9665,0,9667,9669,0,0,0,0,0,0,0,0,0,0,0,0,9671,0,
-9673,9681,0,0,0,0,9682,9683,9684,0,0,0,0,9686,9698,0,0,9700,9701,9702,0,9703,
-9717,0,0,0,0,9718,0,9726,0,0,0,0,9727,0,0,0,9728,0,9742,0,9744,0,0,0,9750,0,9754
-,9755,0,0,0,0,0,9756,0,9757,9768,0,9769,0,0,0,9770,9771,0,9773,0,9774,0,9775,0,0
-,0,9776,9777,9784,0,0,0,9786,0,9789,0,0,0,0,9793,9794,0,0,0,9808,0,0,0,0,0,9811,
-0,0,0,0,0,0,0,0,0,0,0,0,9812,0,9820,0,9823,0,9828,0,0,0,0,9830,0,0,9833,9836,0,0
-,0,9840,0,0,0,9841,0,0,9842,0,9845,0,0,0,9847,9848,0,0,9855,0,0,0,0,0,0,9856,
-9863,9865,0,0,0,0,0,0,0,0,9866,9867,9868,9873,9875,0,0,0,0,0,0,9880,0,9886,0,0,0
-,9887,0,0,9891,0,0,0,0,0,0,0,9906,9907,9908,0,0,0,9909,0,0,0,0,0,0,9910,0,0,0,0,
-9913,0,0,0,0,9914,0,0,0,0,0,9922,0,0,0,0,9923,9925,0,0,0,0,0,0,9930,0,0,0,9931,0
-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9932,0,9939,0,0,9940,9962,9966,0,9969,9970,0,0,9974
-,0,9979,9981,9982,0,0,0,9985,0,0,0,0,0,0,9987,0,0,0,0,0,0,0,9988,9993,0,0,9994,0
-,0,0,9997,0,10004,0,0,0,0,0,10007,10019,10020,10022,0,0,0,10031,0,0,0,0,0,10032,
-0,0,10034,0,10036,0,0,0,0,10038,0,10039,10040,10041,10042,0,0,0,0,0,10043,0,0,0,
-0,0,10045,10054,0,0,0,0,10055,0,0,10057,10058,0,0,0,0,0,0,10059,0,0,0,0,0,0,0,
-10060,0,0,0,0,0,0,0,10063,0,10066,0,0,0,10070,0,10072,0,0,10076,10077,0,0,10084,
-0,10087,10090,10091,0,0,0,10094,10097,0,0,0,0,0,0,10098,0,0,0,0,0,0,10103,0,
-10104,0,10108,0,0,0,0,0,0,0,0,10120,0,0,0,10122,0,0,10125,0,0,0,0,10127,10128,0,
-0,10134,0,10135,10136,0,10137,0,0,10147,0,10149,10150,0,0,10156,0,10158,10159,
-10160,10168,0,0,10171,0,10173,0,0,0,10176,0,0,0,0,10177,0,0,0,0,10178,0,0,0,0,
-10194,0,10202,0,0,10203,10204,0,10205,10206,0,10207,0,0,0,0,10209,0,0,0,0,0,0,0,
-10213,0,0,0,0,0,0,10217,0,10229,0,10230,10231,0,0,10232,0,0,10237,10238,10244,0,
-0,0,0,0,10250,0,10252,0,0,0,0,0,0,10255,0,0,10257,0,0,0,0,0,0,10258,0,10259,0,0,
-0,0,0,0,0,0,10260,0,0,0,0,0,0,0,10284,10288,10289,0,0,0,10290,0,10296,0,0,0,0,0,
-10297,0,0,0,0,0,0,10298,0,0,0,0,10299,10303,0,0,0,0,0,10306,0,0,0,10307,0,10308,
-0,0,0,0,10311,0,0,0,0,0,0,0,10315,10317,0,0,0,10318,10319,0,10321,0,10326,0,
-10328,0,0,0,0,10329,0,0,10331,0,10332,0,0,0,0,0,0,10334,0,0,10335,10338,0,0,0,0,
-0,10339,10349,0,0,0,0,0,0,10351,0,10353,0,0,0,0,0,0,10362,0,10368,0,10369,0,0,0,
-10372,10373,0,0,0,0,0,10374,0,0,0,10375,0,10376,0,0,10386,10388,10390,0,0,0,0,0,
-0,0,10391,0,0,10392,10394,0,0,10396,0,10397,0,10403,0,0,0,0,0,0,0,0,10404,0,
-10405,10410,0,0,10411,0,10412,0,0,0,0,0,0,0,10421,10422,10423,0,0,0,0,0,0,0,0,0,
-10425,0,0,10427,0,0,10430,0,0,0,0,0,10432,0,10433,10434,0,0,0,0,10436,10437,0,
-10438,0,10439,0,10444,10446,0,0,0,0,0,10448,0,0,0,0,0,10449,0,0,0,0,0,0,0,10451,
-0,10453,0,0,0,10454,10457,0,0,10459,0,10469,0,0,0,0,0,10472,10481,0,0,0,0,0,
-10482,10483,0,10492,0,0,0,0,0,0,0,0,0,0,10499,0,0,0,10502,0,0,10510,0,10521,
-10524,0,0,10525,10526,10528,0,0,0,0,0,0,0,0,10530,0,0,0,0,10533,0,10534,0,0,0,0,
-0,0,0,0,0,0,10535,10536,0,0,10544,0,10553,10556,0,10557,10559,0,0,0,0,0,10562,
-10563,10564,0,10565,0,0,0,10566,0,10567,0,0,0,0,10575,0,0,10576,0,10578,0,0,0,0,
-0,0,0,0,0,0,10585,10586,10587,10589,0,10590,0,0,10594,0,0,0,0,0,10598,0,0,10601,
-0,0,0,10602,0,10603,0,10604,0,10605,0,0,10607,0,10626,0,10627,0,0,0,0,0,10629,
-10630,10631,0,0,0,10646,0,0,0,10647,0,10650,0,10651,0,0,0,10652,10653,10655,0,
-10658,0,0,10659,0,10667,0,0,0,0,10669,0,0,0,0,0,0,0,0,0,10670,0,0,0,10671,0,0,0,
-0,10672,10673,0,10674,0,0,0,10676,0,0,0,0,0,0,10678,0,10682,0,0,10692,0,10697,0,
-0,0,0,10698,0,0,0,10700,0,0,0,0,0,10703,0,10704,0,0,0,0,0,0,0,10705,0,10715,
-10718,10720,0,0,10722,0,0,0,0,0,0,0,0,10723,0,0,0,0,10726,0,0,0,0,0,10727,10730,
-10743,0,0,0,0,0,0,10744,0,0,10745,0,0,0,0,0,0,10748,0,0,0,0,10750,0,0,10752,
-10753,0,0,0,10756,0,0,0,0,0,0,10758,0,0,0,10759,0,10769,0,0,10772,0,0,0,0,0,0,
-10773,0,0,0,10777,0,0,10779,0,0,0,0,0,0,0,0,10780,10784,0,0,0,10789,0,0,0,10791,
-0,0,0,0,0,0,0,0,0,10795,0,0,10796,0,10808,0,10809,0,0,0,10810,0,0,0,10812,0,0,
-10814,0,0,0,0,0,0,0,0,0,10815,0,0,0,0,10816,10817,0,0,0,0,10819,0,10820,0,0,0,0,
-10821,10822,10823,0,10826,10849,0,0,0,0,10850,0,0,10852,0,10853,0,0,10856,0,0,
-10857,10858,10859,10860,0,0,0,0,0,0,10863,0,10866,10867,10872,10890,0,0,10891,
-10892,0,0,0,0,0,10893,0,0,0,10896,10899,0,0,10900,10902,0,0,0,0,0,10903,0,0,0,0,
-0,0,0,0,0,0,0,0,10905,0,10906,0,0,0,0,10908,10911,0,10912,0,0,10916,0,0,0,0,0,
-10917,0,10918,0,0,0,10923,0,0,0,0,0,10924,0,0,10928,10929,0,0,10930,0,0,0,10932,
-0,0,0,0,10939,0,0,10945,0,0,0,10947,0,0,10948,0,0,0,0,0,0,0,0,0,0,0,0,10958,0,
-10960,10962,0,0,10964,0,0,0,10966,0,0,0,0,0,0,0,0,0,0,10967,0,0,0,10968,0,0,0,
-10973,0,0,0,0,0,10975,0,0,0,10976,10978,0,0,10982,10984,10987,0,0,10988,0,10989,
-0,0,10991,0,0,0,0,10992,0,0,0,10993,0,10995,0,0,0,10996,10997,0,0,0,10998,0,
-10999,0,11001,0,0,0,0,0,0,11010,11012,0,11013,11016,11017,0,0,11019,11020,11021,
-0,0,0,0,0,0,0,0,0,0,0,0,11022,0,0,11023,11029,0,0,0,0,11031,0,0,0,11034,0,0,0,0,
-11055,0,0,0,0,0,11056,11060,0,0,0,0,0,0,11061,0,0,11064,11065,0,11066,0,11069,0,
-11085,0,0,0,0,0,11086,0,0,0,11088,0,0,0,11094,0,0,0,11095,11096,0,0,0,0,0,0,
-11097,11098,0,0,0,0,0,0,11099,0,0,11102,11108,0,0,0,11109,0,11114,11119,0,11131,
-0,0,0,11142,0,0,11143,0,11146,0,11147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11148,0,
-11149,11152,11153,11154,0,11156,0,11157,0,0,0,11158,0,0,11159,11160,0,0,0,0,0,0,
-0,0,0,0,0,0,11163,0,0,11164,11166,0,0,0,11172,11174,0,0,0,11176,0,0,0,0,0,11182,
-11183,0,0,0,11184,11187,0,0,11188,11189,0,0,0,0,0,0,11194,0,0,0,0,0,0,0,11200,
-11202,0,0,0,0,0,0,11203,0,11204,0,0,0,0,0,11205,0,0,0,11206,0,11207,0,0,11209,0,
-11211,0,11214,0,0,11231,0,0,0,11293,11295,0,0,11296,11297,11302,0,0,0,11307,0,0,
-0,0,11309,11310,0,11311,0,0,0,11313,0,11314,0,0,0,0,11334,0,11338,0,0,0,11339,0,
-0,0,0,0,11340,0,11341,11342,0,11344,0,11345,0,0,0,11348,11349,0,0,11350,0,0,0,
-11355,0,0,0,0,0,0,11356,0,11357,11370,0,0,11371,0,11374,11376,0,0,0,11377,0,0,
-11378,11383,0,11386,11399,0,11400,11406,0,0,0,11408,0,0,11409,11412,0,0,0,0,
-11417,0,0,0,11418,0,11421,0,11426,11429,0,0,0,0,0,11430,0,11437,0,11438,0,0,0,0,
-0,11440,11453,0,0,0,0,0,0,11454,0,0,0,0,11455,0,0,11456,11460,11461,11463,0,
-11469,0,11473,0,0,0,0,11474,0,0,0,11475,0,11476,11477,11480,0,0,0,0,11481,0,0,
-11484,0,0,11487,0,0,0,0,0,0,0,0,0,0,11497,0,0,11502,0,11509,0,0,11510,11511,
-11513,0,0,0,0,0,0,0,0,0,0,11515,0,0,0,0,11516,0,11520,11521,0,0,0,0,0,0,0,0,0,0,
-0,11529,11530,11531,11534,0,0,11543,0,0,0,0,0,11547,0,11548,0,0,0,0,0,11552,
-11556,0,11557,0,0,11559,0,11560,0,0,0,0,0,0,11561,0,0,11563,11564,0,11565,0,0,0,
-0,11567,0,0,0,11569,0,11574,0,11575,0,0,0,11577,0,11578,0,0,0,11580,11581,0,0,0,
-11582,11584,0,0,0,0,0,0,0,11587,0,11588,11591,0,11595,0,0,0,0,0,0,0,0,11596,0,
-11597,0,0,0,0,11598,11601,0,0,0,11602,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11603,
-11604,0,11606,0,0,11608,0,0,0,0,11610,0,0,11611,0,0,0,0,11613,0,11622,0,0,0,
-11623,0,0,0,0,11625,0,0,11626,11627,11628,11630,0,0,0,0,0,0,11639,0,0,11646,0,
-11648,11649,0,11650,0,0,0,0,0,0,0,0,0,11651,0,0,11652,11653,11656,0,0,11677,
-11679,0,0,0,0,11680,0,0,11681,0,11685,0,0,0,0,0,0,0,0,11688,0,0,0,11716,0,11719,
-0,0,0,0,0,11721,0,0,11724,11743,0,0,0,0,0,0,0,0,11745,11748,11750,0,0,0,0,0,
-11751,0,0,0,11752,11754,0,11755,0,0,0,0,0,0,0,11759,0,0,0,0,0,0,11760,0,0,0,
-11761,0,0,0,0,0,0,11766,11767,0,11772,11773,0,11774,0,0,11775,0,11777,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,11778,11780,0,0,0,0,0,0,0,11783,0,11784,0,0,0,11785,
-0,0,0,11786,0,0,0,0,11788,0,0,11789,11791,11792,0,0,0,0,11795,11834,11835,11836,
-0,0,11837,0,0,0,11838,0,0,11846,11851,0,11852,0,11869,0,0,0,11871,0,0,0,11872,
-11874,0,0,0,0,0,0,11875,0,11876,11877,0,0,0,0,0,0,0,0,0,0,11883,0,0,0,0,0,0,0,
-11884,0,11885,0,11886,0,0,11887,0,11894,11895,11897,11909,11910,0,11912,11918,0,
-0,11920,0,11922,11924,11927,11928,0,0,0,0,11929,0,11934,0,0,0,0,0,11941,11943,
-11944,0,11945,0,0,0,0,11948,11949,0,0,0,0,11953,0,11954,0,11955,0,11956,0,0,0,0,
-0,11957,0,0,11959,0,0,0,0,0,0,0,0,11961,0,0,0,0,0,11978,0,0,0,11979,11980,11986,
-11987,0,11992,0,0,0,0,0,11993,0,0,0,11994,0,11999,12004,12005,12006,0,0,0,0,0,
-12011,0,0,12012,12014,0,0,12015,0,0,12019,12028,0,0,12029,0,0,12032,12033,0,0,0,
-0,12034,0,12041,12043,0,0,12044,0,0,0,0,0,0,0,12046,0,0,0,0,0,0,0,12054,12055,0,
-12056,0,0,0,12060,12064,0,0,0,0,0,12065,12067,12068,0,0,0,0,0,0,0,0,12074,0,0,0,
-12075,12076,0,0,0,12079,0,12081,12086,12087,0,0,12088,0,0,0,0,12089,0,12092,0,0,
-0,0,12097,0,0,0,0,0,0,0,0,12098,0,0,0,0,0,0,0,0,0,0,0,0,0,12102,12103,12104,
-12111,0,0,12114,12116,0,0,0,12118,0,0,0,12119,12120,12128,0,0,0,0,12130,0,0,0,0,
-0,0,12131,0,0,0,12132,12134,0,0,0,0,12137,0,12139,0,12141,0,0,12142,0,0,0,12144,
-0,0,0,0,0,12145,0,12148,0,12153,0,0,0,0,12154,12171,12173,0,0,0,12175,0,0,0,0,
-12178,0,0,0,0,0,0,0,12183,0,0,0,0,0,0,0,0,12184,0,0,0,12186,0,0,0,0,0,12187,
-12188,0,0,12189,0,12196,0,12197,0,0,12198,0,12201,0,0,0,0,12203,0,12209,0,0,0,0,
-12210,12211,12212,12213,0,12217,12218,0,0,0,0,0,0,0,0,0,12222,0,0,0,0,0,0,0,
-12223,0,0,12229,0,0,0,0,12233,0,0,0,0,12234,0,0,12236,12242,0,0,0,12243,0,0,0,
-12244,12253,0,12254,12256,0,12257,0,0,12275,0,0,0,0,0,12277,0,0,0,0,0,12278,0,
-12289,0,0,12290,0,12292,12293,0,0,12294,0,12295,0,0,12296,0,12297,0,12298,0,0,0,
-0,12301,0,0,0,0,0,0,0,0,0,0,0,0,0,12309,0,12338,12340,0,0,0,0,12341,0,0,0,0,0,0,
-0,0,12342,12343,0,12344,0,0,0,0,0,0,0,0,0,12345,0,0,0,0,0,0,0,0,12346,0,0,0,0,
-12348,0,0,0,0,0,0,0,0,0,0,0,0,12350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12351,0,12355,
-12356,12357,0,0,12367,12370,12371,0,0,0,0,0,12372,12376,0,0,0,0,0,0,0,0,12379,0,
-12382,0,12383,0,0,12384,0,0,0,0,12393,0,0,12394,0,0,0,0,12398,12403,0,0,12404,0,
-0,0,0,0,0,0,0,0,0,0,0,0,12410,0,0,0,12411,0,0,0,12412,0,0,0,0,12420,0,12421,0,0,
-0,0,0,12423,0,12425,12429,0,0,0,12431,12432,0,0,0,0,0,0,0,0,0,0,0,0,12434,0,0,0,
-0,0,12435,12436,0,0,0,0,0,0,0,0,12437,0,0,0,0,0,12438,0,0,0,0,0,0,0,0,12445,0,0,
-0,12450,12451,0,0,0,0,0,0,0,0,12452,12475,0,0,12493,12494,0,0,0,12495,0,0,0,0,
-12496,12502,12509,0,0,0,0,12510,0,12512,12513,0,0,0,0,12514,0,0,0,12515,0,12520,
-0,0,0,12524,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12527,0,0,0,12528,0,0,0,12529,0,0,0,
-0,0,12530,0,12535,0,0,12536,0,12538,0,0,0,0,0,0,0,0,0,0,0,0,12540,0,12548,0,0,0,
-0,0,12550,0,0,0,12551,12552,0,0,0,12554,0,0,0,0,0,0,0,0,12555,0,0,12562,0,12565,
-0,12566,0,0,0,0,0,0,0,0,0,0,0,0,12569,0,0,0,12571,12574,0,0,0,0,0,0,0,12577,0,0,
-0,0,0,0,0,12578,12579,12603,0,12608,0,0,12611,0,12612,0,12615,0,12625,0,0,0,0,
-12627,12646,0,12648,0,0,12657,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12670,0,0,12671,0,
-12673,12677,0,0,0,0,0,0,0,0,0,0,0,12679,0,12681,0,12682,12693,0,12694,0,12697,0,
-12701,0,0,0,12703,12704,0,0,0,0,12707,12737,0,0,12739,0,0,12740,0,0,12742,12743,
-0,0,0,0,0,0,0,0,0,12745,0,12746,12747,0,12748,0,0,12759,12767,0,0,0,0,12773,0,
-12774,12778,0,0,0,0,0,0,0,12779,0,0,0,0,0,12780,12793,0,12824,0,12825,0,12836,0,
-0,0,0,12839,0,12842,0,0,0,0,0,0,0,0,0,0,0,0,12843,12845,0,12846,0,0,0,0,12847,0,
-0,12850,12852,12853,0,0,0,12854,0,0,0,12855,0,12856,0,12858,0,0,12859,0,12862,0,
-12863,0,0,12866,0,12869,12872,12873,0,0,0,0,0,0,0,0,0,12875,0,12877,0,0,12878,0,
-0,0,0,0,0,0,0,0,12884,12885,12888,0,12889,0,0,0,0,12893,0,0,0,12895,12896,12898,
-0,0,0,0,0,0,0,12902,0,12909,12910,0,12926,0,12928,0,0,0,12929,0,12930,0,0,0,0,
-12931,0,12932,12933,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12934,0,12942,0,0,0,0,12944,
-0,0,0,0,0,0,0,0,12946,0,0,12948,0,0,12949,0,0,0,0,12950,0,0,0,0,12951,0,12952,0,
-12953,0,0,0,12954,12958,12959,0,0,0,0,0,12960,12964,0,0,0,0,0,12966,0,0,0,0,0,0,
-0,0,12970,0,12971,0,0,0,0,0,0,12972,0,0,12982,0,0,0,12984,12985,0,12986,12996,
-12997,13001,13002,0,0,0,0,13004,0,0,13005,0,0,13007,13009,0,13017,0,0,0,13020,0,
-13021,0,0,0,0,0,0,0,0,0,0,13022,0,0,0,0,0,0,0,0,13024,13027,0,0,0,0,0,13028,0,0,
-13029,0,0,0,0,0,0,0,13032,0,13037,0,0,0,0,0,0,13040,0,0,13041,0,0,0,13043,13044,
-13046,0,0,0,0,13047,0,0,0,0,0,0,0,13049,13054,0,13056,0,0,13060,13061,0,0,0,0,0,
-13067,0,0,13068,0,13071,0,0,0,0,0,13077,13078,0,0,0,0,0,13079,13080,13081,0,
-13082,0,0,0,13085,0,0,0,0,0,0,0,13086,0,13087,13088,0,0,0,0,0,13094,0,13099,0,
-13100,0,0,0,13101,0,13125,13126,13128,13129,0,0,13130,0,13131,0,0,0,0,0,0,13134,
-0,0,0,0,0,0,0,0,0,0,0,13150,0,13168,0,0,0,0,0,0,0,0,0,13169,0,0,13170,0,0,0,0,
-13174,0,0,0,13176,0,0,0,0,0,13177,0,13178,13183,13187,0,0,0,13189,0,0,13190,0,0,
-13191,0,0,13206,0,0,0,13207,0,0,0,0,0,0,0,0,0,0,13212,0,0,13219,13232,0,0,0,
-13241,0,13249,13253,0,0,0,0,0,13255,13259,0,13260,13261,0,13262,0,13272,0,0,0,0,
-13276,0,0,0,0,13277,13299,0,0,13301,13302,0,0,13303,0,0,13305,0,13310,0,0,0,
-13311,0,0,0,0,13325,0,13328,0,0,0,13329,0,0,0,0,0,0,13330,0,0,13331,0,13335,0,0,
-13342,0,0,0,0,0,13343,0,13354,0,13362,0,13366,13367,13369,0,0,13371,13372,0,
-13373,13374,0,13376,0,13380,13381,13386,0,13387,13388,0,13389,13391,13395,0,0,0,
-0,0,13401,13409,0,13410,0,0,0,0,13420,0,0,0,0,0,13422,0,0,0,0,13423,0,0,0,0,
-13425,0,0,0,0,0,13427,0,0,0,13428,0,0,13430,13438,0,13439,0,13445,0,13448,13449,
-0,0,0,0,0,0,13451,0,13457,0,0,0,0,13458,13459,0,13460,0,0,0,0,13464,13465,13466,
-13470,0,13471,13472,13474,13475,0,13476,0,0,13478,13479,0,13481,0,0,0,0,13487,0,
-13490,0,13493,0,0,13494,0,0,13495,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13496,13497,0,
-13500,0,0,13516,13522,0,0,13525,13528,0,0,0,13530,13535,0,13537,13539,0,13540,0,
-13543,0,13544,0,0,0,0,0,0,13545,0,0,0,0,0,0,13547,0,0,0,13549,13555,0,0,0,13556,
-13557,0,0,0,0,0,0,0,13558,0,13563,0,0,0,0,13564,0,0,0,0,0,0,0,0,13566,0,0,0,0,0,
-0,13569,0,0,13571,0,0,0,0,13573,0,0,0,0,0,0,13578,0,0,0,0,0,0,0,0,0,0,13581,0,
-13586,0,13595,0,13600,0,0,0,0,0,0,0,0,13601,13603,0,13604,13605,13606,13607,0,0,
-13617,13618,0,0,0,0,0,0,0,13623,0,13625,13627,0,0,0,0,0,0,0,0,13629,0,0,0,13634,
-0,0,0,13638,0,0,0,0,0,0,0,0,13654,0,0,0,0,0,0,0,0,0,0,13656,0,13659,0,0,13660,0,
-0,13662,0,0,0,13663,0,13664,0,0,0,0,0,13668,0,13669,13671,0,0,13672,0,0,0,0,0,0,
-13675,13685,0,13686,0,0,0,13687,0,0,0,13692,13694,13697,0,0,0,13702,0,0,0,0,0,
-13705,0,0,0,0,13707,0,0,0,13714,0,0,0,0,0,0,0,0,0,13715,0,13716,13717,0,0,13719,
-13724,13730,13731,0,0,0,0,0,0,0,0,13732,0,0,0,0,0,0,0,13734,0,13736,0,0,13737,
-13738,13747,0,13751,0,0,13752,0,0,0,13753,0,13757,0,0,13762,13763,0,13764,13765,
-0,13766,0,0,13767,0,0,0,13768,0,0,0,0,0,0,0,13769,0,0,13772,0,13775,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,13776,13778,13787,0,0,0,13797,0,13798,0,13801,0,13804,
-13806,0,0,0,0,13816,13817,0,0,0,0,0,0,0,0,0,0,0,0,0,13834,0,13836,0,0,13838,0,0,
-13839,0,13840,0,0,0,0,13842,0,0,0,0,0,0,13843,0,0,0,0,0,0,0,0,0,13845,0,0,0,0,0,
-13858,0,0,13860,0,0,13861,0,0,13862,13863,0,13868,0,13869,13870,0,0,0,0,0,0,0,0,
-0,0,13872,0,0,0,0,13873,13878,0,0,0,0,0,0,0,0,0,0,13886,0,13888,13889,13890,0,0,
-13891,13894,0,13897,13899,13900,13904,0,0,13906,0,0,0,13909,0,0,0,13910,0,0,0,
-13911,0,0,0,0,0,13912,13917,0,0,0,0,13918,0,13919,0,0,13920,0,0,0,13921,0,0,
-13922,0,0,0,0,0,0,0,13924,0,13927,0,0,0,0,0,13932,0,13933,0,13934,0,0,13935,0,
-13944,0,0,0,13954,0,0,13955,0,0,0,0,13956,0,13957,0,13967,13969,0,0,0,0,0,0,0,0,
-0,0,0,0,13970,13990,0,13991,13994,0,13995,0,0,0,0,13996,0,0,13999,0,0,0,14018,0,
-14019,0,14021,0,0,0,0,0,0,14041,0,0,0,0,0,0,0,0,14043,0,0,0,0,14046,0,0,0,14048,
-14049,0,0,0,0,0,0,0,0,0,0,14051,0,0,14052,14056,0,14063,0,14064,14066,0,0,14067,
-0,0,0,0,0,0,0,0,0,14068,0,0,0,14072,0,14074,14075,0,14076,14079,14085,14086,
-14087,14093,0,0,0,0,14095,0,0,0,0,0,0,14096,14097,0,0,0,0,0,0,0,14098,0,14102,0,
-0,0,0,0,14103,0,0,0,14104,0,0,14105,0,0,0,14107,14108,0,0,14109,0,0,0,0,0,0,0,0,
-14117,0,0,0,0,14118,0,0,0,0,14119,0,0,14120,0,0,14121,0,14122,14127,0,14128,
-14136,0,0,14138,0,14140,0,0,0,14141,14142,0,0,0,0,14146,0,0,14149,0,14151,0,0,0,
-14152,0,0,14153,0,0,0,0,0,0,0,0,0,14154,0,14156,14157,0,0,14159,0,14161,0,0,0,0,
-14162,0,0,0,0,0,0,14163,0,0,14173,0,0,0,0,0,0,14174,0,0,14176,0,0,14178,0,0,
-14179,14181,0,0,14182,14185,14187,0,14190,0,0,14197,0,0,0,0,0,0,0,0,0,0,0,0,
-14198,0,0,0,0,0,0,14199,14200,0,0,0,14204,0,0,14208,0,0,0,0,0,0,0,0,0,0,0,14231,
-0,0,0,0,0,0,0,0,0,14234,0,0,14235,0,0,0,14240,14241,0,0,0,14246,0,0,0,14247,0,
-14250,0,0,14251,0,0,14254,0,0,14256,0,0,0,14260,0,14261,0,0,0,0,14262,14267,
-14269,0,0,14277,0,0,14278,0,14279,14282,0,0,0,14283,0,0,0,14284,14285,0,0,0,0,
-14286,0,0,0,14288,0,0,0,14289,0,14290,0,14293,14301,14302,14304,14305,0,14307,0,
-14308,14309,0,0,0,0,0,0,0,0,0,0,0,14311,14312,0,0,14317,0,0,0,0,0,0,0,14318,0,0,
-0,0,14320,0,0,0,0,14321,14322,0,0,0,0,0,14326,14329,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-14330,14331,0,0,0,0,14332,0,0,0,14333,0,0,14337,14340,0,14341,0,0,14342,0,14345,
-14346,0,0,14347,0,14362,0,0,0,0,0,14364,14365,14371,0,14373,0,0,14374,0,14379,0,
-14400,0,0,0,0,0,14401,0,0,14405,0,14406,0,14408,14409,0,0,0,14417,0,0,14424,0,0,
-0,0,0,0,0,0,0,14430,0,0,0,14431,0,0,14435,0,14440,0,0,0,0,0,0,14442,0,0,14443,0,
-0,0,0,0,14446,0,0,0,0,0,0,0,14454,0,14457,0,14460,0,0,14466,0,0,0,0,0,14467,0,0,
-0,0,0,0,14469,0,14477,0,0,0,0,0,0,14478,14482,0,0,0,14483,0,0,0,14485,14486,0,0,
-0,14487,14488,14489,14492,14493,14494,14495,14496,14497,0,14499,0,14501,0,0,0,0,
-0,0,0,0,0,0,14502,0,14507,14512,14513,14514,0,0,0,0,0,0,0,0,0,0,0,14515,14526,
-14530,0,14537,0,14544,0,14547,0,0,14548,14550,14551,0,0,14552,0,0,0,14553,0,
-14554,0,0,0,0,14556,14564,0,0,14565,14566,0,0,0,0,0,0,14568,0,0,14569,0,0,0,
-14571,14576,0,0,14577,14578,14579,0,0,14580,0,0,0,0,14582,0,0,0,0,0,0,0,0,0,0,0,
-0,14583,0,0,0,0,0,14587,0,14588,0,0,14600,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,14601,0,0,14604,14605,14611,0,14613,0,0,0,0,14615,0,0,0,0,0,0,14627,0,14628,0,
-0,0,0,14631,0,14633,14634,0,0,0,0,14635,0,0,0,0,0,0,0,0,14636,0,0,14639,14642,0,
-0,0,0,14644,0,0,0,0,14645,14646,0,14653,0,0,14654,0,14658,0,14661,0,0,0,14665,0,
-0,0,14668,0,0,0,0,0,0,0,0,0,14669,0,0,14670,0,0,0,14680,0,0,14681,0,0,0,0,0,
-14682,14683,0,0,0,0,14686,0,0,0,0,14687,14697,0,0,0,0,14699,14705,14711,0,0,0,0,
-0,0,0,0,0,0,14712,0,0,0,14713,0,0,0,0,14719,0,14720,14721,14726,0,0,0,14728,
-14729,0,0,0,0,14731,0,0,0,0,0,0,0,14733,14736,14737,0,0,14740,14742,0,0,0,14744,
-14753,0,0,0,0,14755,14758,14760,0,0,0,0,0,14761,14762,14765,14771,0,14772,0,
-14773,14774,0,0,14775,0,0,14776,0,0,0,0,14777,0,14779,0,0,14782,0,0,14785,14786,
-14788,0,0,0,0,0,14795,0,0,0,0,0,0,14798,0,14803,14804,14806,0,0,0,14809,0,0,0,0,
-0,0,14810,0,0,0,0,14811,0,14812,0,0,0,0,0,14815,0,0,0,0,0,0,0,0,14816,0,14818,0,
-0,0,0,0,0,14819,0,14820,0,14823,0,0,0,14824,0,0,14826,14827,0,0,0,0,0,0,0,0,0,0,
-0,0,14830,0,0,0,0,0,14833,0,14845,0,0,0,0,0,14846,0,0,14847,14871,0,14873,0,
-14876,0,14877,14878,14880,0,0,0,0,0,14881,0,14882,14894,0,0,0,0,14895,0,14907,0,
-14908,0,0,0,0,0,0,0,14911,0,0,0,0,14920,0,0,14931,0,14932,14934,14935,0,0,14936,
-0,14945,0,0,0,0,0,0,0,14947,0,0,14948,14949,14951,0,0,14952,0,0,0,14964,14973,0,
-0,14990,0,0,0,0,14995,0,0,14998,15001,0,0,15002,15020,0,0,0,0,0,0,15021,0,15022,
-0,0,0,0,15023,0,0,15025,15029,15033,0,0,0,15034,0,0,0,15035,0,0,0,0,0,15043,
-15044,0,0,0,15045,15046,15048,15050,0,15065,0,0,0,0,15066,0,0,15075,15082,15084,
-0,0,15085,15086,0,0,0,0,0,0,0,0,15088,0,0,0,15089,0,0,0,0,15094,0,15096,0,15097,
-0,15100,0,0,15102,0,0,0,0,0,0,0,0,15105,0,0,15106,0,15109,15113,0,0,0,15115,0,
-15118,0,0,0,0,0,0,15119,0,0,15120,0,0,0,0,0,15123,15129,0,0,0,15130,0,15131,0,0,
-15134,0,15135,0,0,0,15137,15138,0,0,0,0,0,0,15139,0,0,0,0,0,15140,0,0,15154,
-15162,0,15169,15170,0,15175,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15177,0,15178,15179,0,
-0,0,0,0,15183,0,0,0,0,0,0,0,0,0,0,0,0,15185,15187,0,15194,15195,15196,0,0,0,0,0,
-0,0,15204,0,0,0,0,15206,0,0,0,0,0,15207,0,0,0,0,0,0,0,0,0,15213,0,15214,0,0,0,0,
-0,0,0,15232,0,0,0,0,15234,0,15238,15240,0,15248,0,0,0,0,15250,15251,0,0,0,0,0,0,
-0,15252,0,0,0,15255,15262,15266,0,0,0,15267,0,0,0,15277,15279,0,0,0,15280,15281,
-15282,0,0,0,0,0,15285,0,0,0,0,15289,0,0,15291,0,0,0,0,0,0,0,15296,15297,0,0,
-15304,0,0,0,0,15306,0,0,0,0,0,0,15307,15308,0,15309,0,0,15311,0,0,15312,15313,0,
-0,0,0,0,0,0,0,0,0,0,0,15314,15317,0,0,0,15318,15319,0,0,0,0,15320,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,15321,0,0,0,0,0,15324,0,15325,15326,0,15330,0,0,0,0,15334,0,
-15335,0,15341,0,0,15342,0,0,15343,15344,0,0,0,0,15345,0,0,0,0,15347,0,0,15348,
-15349,15350,0,15356,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15357,0,15358,0,0,0,0,0,0,0,
-15359,15360,15364,0,15380,0,0,0,0,0,15392,0,0,15393,0,15395,0,0,0,0,0,0,0,0,
-15396,0,0,15397,15398,0,0,0,0,0,0,0,0,0,15399,0,15400,0,0,0,15402,0,15405,15410,
-0,0,0,0,15411,0,0,0,15412,0,15416,0,0,0,0,0,0,0,15428,0,15435,0,0,15438,0,0,0,0,
-15439,0,0,0,15440,0,0,0,15441,15449,15451,0,0,0,0,0,0,0,15452,0,0,15455,0,0,0,
-15456,0,0,15458,0,15460,15461,0,0,0,0,0,15462,15464,0,15465,0,0,15466,0,0,15467,
-0,0,0,0,0,15468,0,0,0,0,15481,0,0,15484,0,15485,15486,0,0,0,15487,0,0,0,0,0,
-15488,0,15492,15498,0,0,0,15499,0,0,0,15500,0,15501,0,0,15512,0,15522,0,0,0,
-15524,0,15525,15526,0,0,15527,0,0,15545,15546,0,15548,15552,0,15553,0,0,0,15554,
-0,15555,0,15557,15565,15573,15577,15578,0,15582,0,15583,0,0,0,0,0,0,0,0,0,0,0,0,
-0,15586,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15588,0,0,0,0,0,15589,0,0,0,0,0,0,0,15593,
-15594,0,0,0,0,15595,0,0,0,0,0,0,15596,0,0,0,15597,0,0,0,0,15600,0,0,15601,0,0,0,
-0,15602,15603,0,0,0,0,0,0,15604,0,15609,0,0,15612,0,0,15613,0,0,15615,15617,
-15618,0,0,15620,0,15636,15637,0,0,15649,0,0,0,0,0,0,0,15650,0,0,15651,0,0,0,
-15656,0,15658,0,0,0,15664,0,0,15665,0,0,15668,0,0,0,0,0,15669,0,0,15674,0,0,
-15675,0,0,0,0,15676,0,0,0,0,0,0,0,0,0,0,0,15677,0,0,0,0,15678,0,0,0,0,0,15679,0,
-0,15681,0,15686,0,0,0,0,15687,0,15688,0,0,15690,0,0,0,15697,0,15699,15700,0,0,0,
-0,0,0,0,0,0,15701,0,15702,15703,0,15704,0,15705,0,15707,0,15709,0,15712,15716,0,
-15717,0,15718,15720,0,0,0,0,0,15724,0,0,0,15725,0,15726,0,0,0,15740,0,15745,
-15746,0,0,15747,0,15748,0,0,0,0,0,15749,0,0,0,15752,0,15753,0,0,0,0,0,0,15759,0,
-0,0,15765,0,0,0,0,0,0,0,0,0,15767,0,0,0,15771,0,0,15784,0,0,0,0,15785,15790,
-15791,0,0,15792,0,0,0,15807,0,15811,0,0,0,0,0,0,0,0,0,0,0,0,15818,0,0,0,15819,0,
-0,0,0,15821,0,0,0,0,0,15822,15824,0,0,15827,0,0,15829,15831,0,15832,0,0,15833,0,
-15835,15838,15839,15843,0,0,0,0,0,0,0,0,0,0,0,15844,0,0,0,0,15845,15851,15856,0,
-0,0,0,0,0,0,15858,15860,0,15861,0,0,0,15864,0,0,0,0,15865,0,0,0,0,0,0,15866,0,
-15872,0,0,15876,0,0,0,0,15877,15878,15883,15885,0,0,15888,0,0,0,0,0,15889,15890,
-0,0,0,0,0,0,0,0,15892,0,0,0,0,0,0,0,15893,0,0,15894,0,0,0,15895,0,15896,15897,0,
-15898,15901,15902,0,15911,15915,0,15916,0,15924,15935,0,15937,0,0,0,0,0,15950,0,
-0,0,0,0,0,0,15958,0,0,0,15961,0,0,15966,0,15967,0,0,15977,0,0,15978,0,0,15981,
-15982,15983,0,0,0,0,0,0,0,15986,0,0,0,15990,0,15991,15995,15998,0,15999,0,16000,
-0,0,0,0,16008,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16009,16011,0,16013,0,0,0,0,
-0,0,0,0,16014,0,0,16015,16023,16024,16025,0,0,16026,0,16030,0,16032,0,16033,0,0,
-0,0,0,0,16035,16036,16037,0,0,0,0,0,16039,0,0,0,0,16041,0,0,0,0,0,16043,16044,0,
-0,16047,0,0,0,16048,0,0,16049,16050,16052,0,0,0,0,0,16055,0,0,0,0,0,0,0,0,16056,
-0,0,0,0,0,0,0,16058,16060,16061,0,0,16063,0,0,16064,0,0,0,16067,16068,0,0,16069,
-16078,0,0,0,16079,0,0,0,16080,0,16081,0,0,0,16088,0,0,0,0,0,0,0,0,0,0,0,16089,
-16093,0,16097,0,16103,0,16104,16105,0,0,16256,0,0,16259,0,0,0,0,0,0,0,16260,
-16261,0,0,16262,0,0,16263,0,16268,0,0,0,0,0,0,0,16269,0,0,16270,16273,0,16274,0,
-0,0,0,16275,16276,16277,16280,0,0,0,16281,16284,0,0,0,16286,0,16289,0,0,0,0,0,0,
-0,0,0,16290,0,0,0,0,16291,0,0,0,0,0,0,0,16292,0,0,0,0,0,0,0,0,16293,16295,16297,
-0,16302,0,16304,0,16305,0,16306,0,0,0,0,0,0,0,0,0,0,0,0,16307,16308,16312,0,0,0,
-0,0,0,16313,16315,0,16318,0,0,0,16321,0,0,0,0,0,0,0,16326,16333,16336,0,0,0,0,
-16337,16340,0,0,0,0,0,16345,0,0,16346,0,0,0,0,0,0,0,0,0,16347,0,0,16348,0,0,0,0,
-16349,0,0,0,16350,0,16357,0,0,0,0,16359,16360,0,0,0,0,16362,16363,16364,16365,0,
-0,16366,0,0,0,0,16367,16368,0,16369,16374,0,0,0,0,0,0,0,16376,0,0,0,0,16378,
-16379,0,16380,0,0,0,16381,16383,0,0,0,0,0,16390,0,0,0,16399,0,16402,16404,16406,
-16407,0,0,0,16409,16411,0,0,0,0,16412,0,16413,16415,16423,0,0,0,0,0,16424,0,0,0,
-16428,16434,16435,16449,0,16450,16451,0,0,0,16453,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-16454,0,0,16456,16458,0,0,16459,0,0,16460,0,0,0,0,16462,0,16463,0,0,16466,0,0,0,
-0,0,16479,0,0,16480,0,16481,16484,0,0,0,0,0,0,0,0,0,0,16485,0,0,0,0,0,0,16489,0,
-0,0,0,0,16491,0,0,16498,0,0,16503,0,16505,0,0,0,0,0,0,0,0,16506,0,0,0,16508,
-16509,0,0,0,0,0,0,0,0,16511,16513,0,0,0,16516,0,16517,0,16519,0,16529,0,0,16531,
-0,0,0,0,0,0,16534,0,0,16541,16542,0,0,0,0,0,0,0,0,0,16543,16547,16548,0,0,0,
-16551,0,16552,0,0,0,16553,0,0,16558,0,0,16562,16565,0,0,0,16570,0,0,0,16573,
-16585,0,0,0,16586,16587,16595,0,16596,0,16598,0,0,0,16600,0,0,0,0,0,0,0,0,0,0,0,
-0,0,16601,0,0,0,0,16603,0,0,0,0,0,0,0,16604,16612,0,0,0,0,16613,0,16618,0,0,0,
-16640,0,0,16641,0,0,0,0,0,0,16645,0,0,0,0,16646,0,0,0,0,0,0,16651,0,0,0,0,16653,
-16654,0,0,0,16655,0,0,16656,16667,0,0,0,0,16671,0,16672,0,0,0,16673,0,0,0,0,0,
-16676,0,16686,0,0,0,0,16689,0,16690,0,16692,0,16693,0,16694,0,16696,0,0,0,16705,
-0,0,0,0,0,0,16707,0,0,0,16709,0,0,0,0,16711,0,16712,16713,0,0,0,16715,0,0,0,0,
-16716,0,0,0,0,0,0,0,0,0,16718,16724,0,0,16726,16727,0,0,0,0,0,0,0,16728,0,16729,
-0,0,16730,0,0,0,0,0,16731,0,0,0,16732,0,0,0,0,16734,16738,0,0,0,0,0,0,0,0,16743,
-0,0,16745,0,0,0,0,0,16749,0,16752,0,0,0,0,16756,0,0,16758,0,16759,0,0,0,0,0,
-16760,0,0,0,0,0,0,0,16762,0,16769,0,16770,0,16772,0,0,0,16777,16780,0,0,0,0,0,0,
-16781,0,0,16782,0,16784,0,0,16785,16787,16792,0,0,16794,0,0,0,16798,0,0,16809,0,
-0,16814,16816,16817,0,16819,0,0,0,0,0,0,0,0,0,0,16820,0,0,16836,16839,0,0,16841,
-16851,16857,0,0,16858,16859,0,0,16860,0,0,0,0,0,0,0,0,16862,0,16863,0,0,0,0,0,0,
-0,16864,0,0,0,0,0,0,0,16876,0,16881,16882,0,16885,16886,0,16887,0,0,0,16889,
-16891,0,0,0,0,0,16894,16895,0,0,0,0,0,0,0,0,0,0,0,16897,0,16898,0,0,0,0,0,16913,
-0,0,16924,16925,16926,0,0,16927,0,0,0,16937,16938,0,0,0,16940,16941,0,0,0,16942,
-16945,0,16946,16949,16950,0,0,0,16952,16955,0,0,0,16965,0,16969,0,0,16975,0,0,
-16976,0,0,0,0,16978,0,0,16981,0,16983,16989,0,0,0,0,16990,0,0,16991,0,0,0,16993,
-0,16994,16996,17000,0,0,0,0,0,17002,17004,0,17006,0,0,17007,0,0,0,0,17008,17013,
-17014,0,0,0,0,0,0,0,0,0,17021,0,17031,0,0,0,0,0,17033,17036,0,17038,0,0,17039,0,
-17045,0,0,17046,17047,0,0,0,0,17048,0,17049,17050,0,17051,17053,0,17054,0,17055,
-0,0,0,0,0,17063,0,0,17064,0,0,0,0,0,0,0,17065,0,0,17068,0,0,0,0,0,17072,0,0,0,0,
-0,0,17073,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17074,0,17080,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,17081,17083,17084,0,0,0,17085,0,0,0,0,17092,0,0,0,0,0,0,0,
-0,0,17093,0,17095,17102,0,0,0,0,0,0,17103,0,0,17105,0,17107,0,0,0,0,17114,0,0,0,
-0,0,17115,17125,17127,0,0,17128,0,0,0,17129,17130,0,17131,0,0,0,0,0,17132,17135,
-17145,0,0,0,0,0,0,0,0,17146,0,17147,0,17148,0,0,0,0,0,0,17149,17150,0,17151,
-17153,0,17155,0,0,0,0,17163,17171,0,17174,0,0,0,0,17179,0,0,17182,17185,0,0,0,0,
-0,17186,0,0,17188,0,0,0,0,0,0,0,17189,17191,0,17194,0,0,0,0,0,0,0,0,0,17195,
-17196,17203,17204,0,0,17205,17217,0,0,0,0,0,17218,0,0,0,0,17219,0,17220,0,17221,
-0,0,17230,0,0,0,0,0,17236,0,17238,17239,0,0,0,17241,17244,0,0,17245,0,17248,0,0,
-17251,0,17252,0,0,17264,0,17266,0,0,0,17268,0,0,0,0,17271,17272,0,17273,0,17295,
-0,17302,0,17305,0,0,0,17306,0,0,0,0,0,0,0,17308,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-17309,0,17310,17313,0,0,0,0,17314,17315,0,17317,0,0,0,0,17318,0,0,0,0,0,0,0,
-17320,0,0,0,0,0,0,17334,0,17344,17348,0,0,0,17350,17351,0,0,17353,0,0,17354,0,0,
-0,0,0,0,0,0,0,17355,0,0,0,0,0,0,17356,17357,0,0,17359,0,0,0,17371,0,17372,0,0,0,
-17393,0,0,0,0,17394,0,0,0,0,0,17395,0,0,17399,0,0,0,17401,17417,0,17418,0,17419,
-0,0,0,0,0,17422,17423,0,0,0,0,0,17424,0,0,0,0,0,17428,17429,17433,0,0,0,17437,0,
-0,17441,0,0,17442,0,0,17453,0,0,0,0,0,0,0,0,17454,17456,17462,0,0,17466,0,0,
-17468,0,0,17469,0,0,0,0,17470,0,17475,0,0,0,0,0,17479,0,0,0,17483,17484,0,17485,
-0,17486,0,17491,17492,0,0,17493,0,17494,17495,0,0,0,17496,0,0,0,17497,0,0,0,
-17502,0,0,0,0,0,17503,0,17505,0,17507,0,0,0,17512,17513,17514,0,0,17515,0,0,0,
-17519,0,0,0,17522,0,0,17523,0,0,0,0,0,0,0,0,0,17527,0,0,0,17528,0,0,0,17534,0,0,
-0,0,17536,0,0,0,17539,0,17540,17543,17549,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17556,
-0,0,17558,0,17559,0,0,17560,0,0,0,17563,0,0,0,0,0,0,17564,0,0,17565,17566,0,
-17567,0,0,0,0,0,0,17569,17570,0,17575,0,0,0,0,0,0,0,0,0,0,0,17581,0,0,0,17582,
-17583,0,17586,0,0,17587,0,0,0,0,0,0,0,17588,0,0,0,0,17596,17597,0,0,17598,17600,
-0,0,0,0,0,0,17601,0,0,0,17604,0,0,17605,0,0,17607,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,17612,0,0,17618,0,17621,17622,0,0,0,0,17623,0,0,17624,0,0,17630,0,0,
-17631,17633,17634,0,0,0,0,0,0,0,17635,0,0,17636,0,0,17637,0,17638,0,17640,0,0,0,
-0,0,0,0,0,0,0,17641,0,0,0,0,0,0,0,0,0,0,17643,0,0,0,0,17645,0,0,0,0,0,0,0,0,
-17646,17662,0,0,0,0,0,0,0,0,0,17663,17664,0,17665,17666,0,0,0,17669,17671,17673,
-0,17679,0,0,0,0,0,0,0,17684,0,0,0,17686,0,17714,0,0,17720,17722,17726,0,0,17728,
-0,0,17729,0,0,0,17732,0,17733,0,17734,0,0,0,17735,0,0,0,0,17737,0,0,0,0,17739,0,
-0,0,17741,17742,0,0,0,0,17743,17744,17745,0,0,0,17749,0,17750,17751,17752,17754,
-17761,17762,0,17763,0,17766,0,17772,0,0,0,0,0,17775,0,0,0,0,0,0,0,17776,0,0,
-17777,0,0,17778,17779,0,17782,17783,0,0,0,0,0,0,0,0,0,0,17784,0,0,0,0,0,0,0,
-17821,0,0,0,17822,0,0,0,17823,17825,0,0,0,0,0,17826,17831,17832,17833,0,0,17845,
-0,0,0,17846,0,0,0,17848,17850,17854,0,17855,0,0,17859,0,0,0,0,0,0,17860,17861,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17870,17871,0,0,0,0,0,0,17872,0,0,0,17879,0,
-0,0,17881,17883,0,17884,0,17885,0,0,17886,0,0,17887,17891,17953,0,0,0,0,17954,0,
-0,17955,0,17968,0,0,17972,0,0,0,0,0,17974,0,0,0,0,17976,17978,0,0,17983,0,0,0,0,
-18003,0,0,0,0,0,18007,0,0,0,0,0,18009,0,0,0,0,0,0,0,18010,0,0,0,0,0,0,18012,0,0,
-18014,0,0,0,18015,0,0,0,18016,0,18017,0,0,0,18030,0,0,0,0,0,0,0,18031,0,0,18036,
-18037,18038,0,0,18049,18056,0,18057,18058,0,18059,0,0,0,0,0,0,0,0,18062,0,0,0,0,
-18064,0,0,0,0,0,0,0,0,18067,0,0,0,18068,0,0,18075,0,0,18078,18093,18094,0,0,0,0,
-0,0,0,0,18097,0,0,0,0,0,18098,18100,0,0,0,18108,0,18111,0,0,18112,0,18113,0,0,
-18115,18116,0,18118,0,0,0,0,18121,0,0,0,0,18123,0,0,0,0,0,0,0,0,0,18124,0,0,0,0,
-18125,18126,0,18127,0,0,18128,18135,0,0,0,0,0,0,0,0,0,18150,0,0,0,0,0,18151,
-18152,0,0,18156,18164,0,18166,18171,0,0,0,0,0,0,0,0,0,18172,18183,0,18184,0,0,0,
-0,18185,0,18187,0,0,0,0,0,18188,0,0,0,0,0,0,0,0,18189,0,0,18190,0,0,18191,18192,
-0,0,18194,18195,18196,0,0,0,18197,0,18203,0,18204,0,0,0,0,18205,0,0,0,18207,
-18208,0,0,18214,0,0,0,18215,18216,0,0,0,18220,0,0,18222,0,0,0,0,0,18223,0,18225,
-18231,0,18234,0,18235,0,0,0,0,18240,0,0,18241,18242,0,0,0,0,0,18243,18251,0,
-18253,0,18254,0,0,0,18266,0,0,0,0,0,0,18269,18270,18271,18273,18281,0,0,0,0,0,0,
-0,0,0,0,0,0,18282,0,18283,0,18284,0,0,0,0,0,0,18285,0,18287,18289,0,0,18290,0,0,
-0,0,18308,0,0,0,18310,0,0,0,0,0,0,0,0,0,0,0,0,18311,0,18312,18313,0,18315,0,0,
-18316,18320,0,18331,0,18332,0,18336,0,0,0,0,18337,0,18340,0,0,0,0,0,0,0,0,0,
-18341,0,18344,18345,0,18346,0,0,0,0,0,18348,0,18351,0,0,18356,0,0,0,0,0,0,18357,
-0,0,0,0,0,18367,0,0,0,18368,0,18369,0,18370,18371,0,0,0,18437,18444,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,18445,18450,0,0,0,0,18451,0,18452,0,0,0,18453,0,0,0,0,0,18455,0,
-0,0,18456,0,18457,0,18460,0,0,18461,0,0,0,0,0,0,0,0,18466,0,0,18467,0,0,0,0,
-18473,0,0,0,18476,0,18477,0,0,0,18478,18479,18480,0,0,0,18485,0,0,0,18486,0,0,0,
-0,0,0,18488,18490,0,0,0,0,0,0,18491,0,0,0,0,0,18495,0,0,18496,0,0,0,0,0,0,18505,
-0,18521,0,18522,18523,0,0,0,18525,18526,0,0,0,0,0,18527,0,0,0,0,18532,18533,0,
-18534,0,0,0,0,0,0,18535,18537,0,18538,0,0,0,0,0,0,18540,18541,18542,18543,0,
-18546,0,0,0,0,18553,18556,0,0,18558,0,0,18569,18571,0,0,0,18572,0,18574,0,0,0,0,
-18586,0,0,0,0,0,18588,0,0,18589,0,0,0,0,0,0,18590,0,18592,0,0,0,0,18594,0,0,0,
-18596,0,0,18597,18598,0,0,18601,0,0,0,0,18602,0,0,0,18603,18604,0,18605,0,0,0,0,
-18608,0,0,18611,0,0,0,0,0,0,0,0,0,18612,0,18616,0,0,18617,18619,0,0,0,18628,0,0,
-0,18629,0,0,18630,0,0,0,0,0,0,0,18631,0,18632,0,0,18635,18637,0,0,0,0,0,0,18641,
-18643,18648,0,18652,0,0,18653,0,18655,18656,0,0,0,18657,0,0,18666,18674,0,0,0,0,
-18677,18684,18685,0,0,18686,0,0,18690,0,0,0,0,0,0,0,18695,18696,0,0,0,0,0,0,0,0,
-0,0,18697,0,0,18700,0,0,0,0,0,0,18702,0,18708,0,0,18709,0,18710,0,0,18711,0,
-18714,0,0,18718,0,0,0,0,0,0,18719,0,0,18722,0,18726,0,0,0,0,0,0,0,0,0,0,0,0,0,
-18731,0,0,0,0,0,18739,18741,0,0,18742,0,18743,18744,18746,18748,0,18752,18753,0,
-0,18754,18763,0,18765,0,0,0,18766,0,0,0,18769,0,0,0,0,0,18773,18778,18779,18781,
-0,0,18784,18787,0,18788,0,18793,0,0,0,0,0,0,18795,0,0,18800,0,0,0,0,0,18801,
-18804,0,0,0,0,0,0,0,18806,0,0,0,18811,18815,18816,0,0,0,0,18825,0,0,18827,18829,
-0,0,18830,0,0,0,0,18831,0,0,18832,0,0,0,0,18833,0,18840,0,18841,0,18842,0,0,0,0,
-18843,0,18844,0,0,0,0,0,0,18845,18846,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-18848,0,0,0,18853,18860,0,0,18862,18866,0,0,18867,18869,0,0,18874,18881,18891,0,
-0,0,0,0,0,0,0,0,0,18892,0,0,0,0,0,0,0,0,18895,0,18896,0,0,0,18900,0,0,0,18901,0,
-18902,18915,18916,0,0,0,0,0,0,0,0,18919,0,0,0,0,0,18920,0,0,0,18921,18929,0,0,0,
-0,18930,0,0,0,0,0,0,18932,0,0,0,0,18934,18942,0,0,0,18951,18957,0,0,0,0,18958,0,
-0,0,0,18959,18960,0,0,18961,0,0,18962,0,0,0,0,18963,18964,0,0,0,18965,0,18967,0,
-0,0,0,0,0,0,0,0,18968,0,18969,0,18970,18973,18976,0,0,0,0,0,0,18977,0,0,0,18981,
-0,0,0,18990,0,18998,0,0,0,0,0,18999,19003,0,0,19005,0,0,0,19006,0,0,0,0,0,0,
-19008,19011,0,0,19018,0,0,19019,0,19024,0,19031,19032,0,19039,0,19041,19050,0,0,
-0,19051,19055,19056,0,19059,19063,19064,0,0,19088,0,0,0,19093,19094,0,0,0,0,
-19095,0,19096,0,0,0,19097,0,0,19098,0,19099,19100,0,0,19103,0,0,0,0,0,0,0,19111,
-0,0,0,0,0,0,19112,0,0,0,19116,19117,0,19121,19122,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,19123,19124,0,0,0,0,0,0,0,19125,19126,0,19128,0,0,0,0,0,0,0,0,0,0,
-19129,19130,19131,19132,0,0,19146,0,0,19147,19156,19158,0,0,0,0,0,0,0,0,19182,
-19185,0,0,19187,0,0,0,19193,0,0,0,0,0,19194,0,19197,0,0,0,0,19198,0,0,0,0,0,0,0,
-0,0,0,19202,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19203,0,19205,19210,
-0,0,0,19213,0,19218,0,0,0,19223,19229,0,0,19230,0,0,19231,19232,19233,19239,0,0,
-0,0,0,19240,0,19248,19249,0,0,0,0,19254,0,19256,19258,19259,0,0,19261,0,19266,0,
-0,0,19272,0,19278,19281,19282,0,0,0,0,0,0,0,0,0,0,0,0,19283,0,0,19284,0,0,19285,
-19287,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19288,19291,0,19292,0,0,0,0,19297,0,19298,0,0,
-0,0,19302,19303,0,0,0,0,19304,19305,0,0,0,0,19314,0,0,19315,0,0,19321,0,0,0,0,0,
-0,0,19322,0,19333,0,19334,19335,0,19336,19337,0,0,0,0,0,0,0,0,0,0,0,19346,0,0,
-19353,0,19354,19362,0,19366,19367,0,0,19369,0,19375,0,19377,19380,19388,0,0,0,0,
-0,19389,19390,0,0,0,0,19392,0,0,0,0,0,19402,0,0,0,0,0,0,0,0,19412,0,0,19413,
-19422,0,19424,0,0,0,19425,0,0,0,19428,0,0,0,0,19431,0,0,0,0,0,19432,0,0,0,0,0,
-19448,19459,0,0,19461,0,19462,19463,0,19467,19474,19482,0,0,0,0,19494,0,0,0,0,
-19501,0,0,0,0,0,0,0,0,0,0,19502,19504,0,0,0,0,0,0,0,19505,0,0,0,0,19506,19507,0,
-0,0,19508,0,0,19511,0,0,19514,0,19515,0,19516,0,19518,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,19530,0,19537,19538,0,19543,19546,0,19547,19551,0,0,0,0,0,0,19552,
-19553,0,0,0,0,0,0,0,0,0,0,0,0,19555,0,0,19556,0,0,0,0,0,0,0,0,0,0,0,0,19560,
-19561,0,0,19562,0,0,0,0,0,0,19565,19567,0,19568,0,0,0,19569,19570,0,19578,0,0,0,
-0,19580,0,0,0,0,19581,19584,0,0,0,0,0,0,0,19585,19586,0,0,0,19587,19588,0,19589,
-0,0,0,0,0,0,19592,19593,19599,0,19600,0,0,19604,0,0,19605,0,19606,19608,19610,0,
-19613,19614,0,0,0,0,0,0,19616,19617,0,0,19618,0,0,19619,0,0,0,19620,19621,19631,
-0,0,19632,19634,19636,0,19643,0,0,19644,19658,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,19659,0,0,0,0,0,0,0,0,0,0,0,19675,19677,0,0,0,0,19679,0,19683,0,19684,0,0,
-0,0,0,0,19687,0,0,0,0,0,0,0,0,19688,19689,19692,0,0,0,0,0,0,0,19695,19697,0,0,0,
-0,0,19698,19699,0,0,19700,0,19702,0,0,19703,0,0,0,0,0,0,19704,19708,0,19710,0,
-19713,0,0,0,19715,0,0,0,0,19718,0,0,0,0,0,0,0,19720,0,19722,0,0,19725,0,0,0,0,0,
-0,0,0,0,0,0,0,0,19730,0,0,0,0,0,19731,0,19734,19735,19739,0,0,19740,0,19741,0,0,
-0,19746,0,0,19747,0,19771,0,0,0,0,0,0,0,0,19772,19775,0,0,0,0,0,0,19778,0,0,0,0,
-0,19779,0,0,19780,19790,0,19791,0,0,19792,0,0,0,19793,0,0,19796,19797,0,0,0,
-19799,0,0,0,19801,0,0,0,0,19803,0,19804,0,19805,0,0,19807,0,0,0,19808,0,0,0,0,0,
-0,19809,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19816,0,19821,0,19822,19830,19831,0,0,
-0,19833,0,0,0,0,0,0,0,0,0,0,19838,0,0,0,0,19839,0,0,19843,0,0,0,0,19845,0,0,0,0,
-19847,0,0,19848,0,19849,0,0,0,0,0,0,0,19851,0,0,0,19854,0,0,0,0,0,0,0,0,0,19864,
-0,19865,0,19866,0,0,0,0,0,0,0,19868,0,0,19870,0,0,19871,0,0,19872,19873,19875,0,
-19880,19882,19884,0,0,19885,19886,19888,0,0,0,0,0,0,0,0,0,0,0,0,19890,19892,
-19893,0,0,19894,0,0,0,19895,0,19896,19902,0,0,19903,0,0,19905,0,0,0,19906,0,
-19908,0,19909,19911,0,0,0,19913,19920,0,19938,19939,19940,0,0,0,0,0,0,0,19942,0,
-19943,0,19945,0,0,0,19951,19952,19954,19960,0,19965,0,19971,0,0,0,0,0,19975,0,
-19976,0,19990,0,0,19991,0,19993,0,19995,0,0,0,19998,19999,20001,0,20003,20005,0,
-20011,20012,0,0,0,0,0,0,20014,0,20020,0,0,0,0,20021,0,0,0,0,0,20023,20024,0,0,0,
-0,0,20025,0,0,20027,0,0,20029,0,0,20032,0,0,0,0,20044,20045,0,20048,20049,0,0,
-20050,0,20052,0,0,20054,20057,0,0,0,0,0,0,0,0,0,20059,0,0,20061,0,20062,0,20064,
-0,0,20066,0,0,20067,0,0,0,0,20069,0,0,0,0,0,0,20070,20071,0,0,0,0,0,0,0,0,0,0,0,
-20072,0,0,20073,20074,0,0,0,0,0,20075,0,20078,0,0,0,0,20080,0,20081,0,0,0,0,0,0,
-20095,0,20098,0,0,0,0,0,0,0,20107,0,0,0,0,0,0,0,0,20112,0,0,0,20113,20114,0,0,0,
-20115,20123,20124,0,0,0,20131,20133,20134,0,0,0,0,20136,0,0,20137,20138,20150,0,
-20152,0,0,0,20153,0,0,20154,0,0,0,20158,0,20163,0,0,20164,0,0,0,0,0,0,0,20166,0,
-20168,0,20170,0,20175,0,0,20178,0,0,0,0,20223,0,0,0,0,20224,0,20226,0,0,20230,0,
-20231,0,0,0,0,20232,0,0,20233,20234,0,20244,0,20247,0,0,0,0,0,0,20249,0,0,0,
-20250,0,0,0,0,20251,0,20253,0,20254,0,0,0,0,20256,0,0,20264,0,0,0,0,20266,0,0,0,
-20278,0,0,20279,20282,0,0,0,0,0,20283,0,20284,0,20285,0,20287,20290,0,0,0,0,
-20292,0,0,0,0,20293,20297,0,0,0,0,0,0,20299,0,20300,20303,0,0,0,0,0,0,20307,0,0,
-20308,0,20309,0,20310,0,0,0,0,0,0,20312,0,0,0,20314,0,0,0,0,20315,20316,0,20322,
-0,0,0,0,0,0,20339,0,0,0,20342,0,0,0,0,20352,0,0,0,0,0,0,0,0,0,0,20362,0,0,20365,
-0,20375,20377,0,0,0,0,0,0,0,0,0,0,0,20378,20379,0,20380,0,0,20381,0,20382,0,
-20383,0,20388,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20390,20392,20393,0,0,20395,0,0,0,0,0,
-20396,0,0,0,0,0,0,0,0,20398,20415,0,0,0,20417,0,0,20420,0,0,20426,20428,0,20431,
-0,0,20432,0,20433,20434,20435,0,0,0,0,20440,0,0,0,0,0,20442,0,20443,0,20446,0,0,
-0,0,20448,0,20451,0,0,0,0,0,0,0,0,0,20452,20453,0,0,20454,0,0,0,0,0,0,20457,0,
-20458,0,0,0,20465,0,0,0,0,0,20469,0,0,0,20473,0,20476,0,0,0,0,0,0,0,0,20477,0,0,
-20485,0,0,20486,0,0,20487,0,20496,0,20497,0,0,20498,0,0,0,0,0,0,0,0,0,0,20499,
-20500,0,20501,0,0,0,0,0,20520,20527,0,20529,0,0,0,0,20539,0,0,20540,0,0,0,20543,
-0,0,0,20546,0,0,0,0,0,20548,0,0,20563,0,0,20564,0,20566,0,0,0,0,0,20589,0,0,0,0,
-20590,0,0,20593,20594,0,0,0,0,20595,0,20597,20598,0,0,0,20618,20620,0,0,0,0,
-20621,0,0,0,0,20627,0,0,0,0,0,20628,0,0,0,20629,0,20630,0,0,20639,0,0,0,0,0,
-20707,0,0,20709,0,0,0,20713,20714,0,0,0,0,0,20724,20725,0,0,0,0,20726,20728,
-20729,0,20733,0,20734,0,20735,20736,0,20737,0,0,20744,0,20745,0,20748,0,0,20749,
-0,0,0,0,0,0,0,0,20750,0,0,0,0,20754,0,0,0,20761,0,0,20763,0,0,0,0,0,0,0,20766,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,20767,0,0,0,0,20768,0,20769,20777,0,0,0,0,0,0,20785,0,
-0,0,20786,20795,20801,0,20802,0,20807,0,0,20808,0,0,20810,0,0,20811,0,20812,0,0,
-0,0,0,20813,0,0,20818,20820,20821,0,0,0,20822,0,20823,0,0,0,20826,0,0,0,0,0,0,0,
-20829,20830,20831,0,20832,20836,0,0,20839,0,0,20840,20842,0,20843,0,20844,0,
-20854,0,0,0,20855,0,0,0,0,20856,0,0,0,20869,0,0,20871,0,0,0,0,0,0,0,20873,0,0,0,
-0,0,20876,0,0,0,0,0,20880,0,0,20882,0,0,0,0,20883,20884,0,0,20890,0,0,0,0,0,0,0,
-0,0,20891,0,0,0,0,0,20905,0,20906,20910,0,0,20912,20915,0,0,0,0,0,20916,0,20917,
-0,20919,20920,20922,0,20927,0,20928,20929,20930,0,0,20935,0,0,20939,0,0,20941,0,
-0,0,20943,0,0,0,20946,20947,0,0,0,0,0,20950,0,20954,0,0,20955,20964,0,0,20967,0,
-0,0,0,0,20973,20975,0,0,0,20984,0,20987,20988,0,0,0,0,0,20989,0,0,0,20995,0,
-20998,0,20999,0,0,0,0,21000,21001,0,0,0,0,21008,0,21010,0,21016,0,0,0,21017,
-21018,0,0,0,0,0,21021,21026,21027,21028,0,0,21029,0,0,0,0,0,21030,0,0,0,0,0,0,0,
-0,0,0,0,0,0,21031,21032,0,0,0,0,0,21037,0,0,21038,0,0,0,0,0,0,0,0,0,21039,0,
-21041,0,21046,21047,0,0,0,21049,21053,0,0,21057,21064,21065,0,0,21066,21067,0,0,
-0,21069,0,0,0,21071,21072,0,0,21073,0,21074,0,0,21078,0,0,0,0,21079,0,0,21080,
-21081,0,0,21086,21087,0,21089,0,0,0,0,0,0,0,21091,0,21093,0,21094,0,0,0,0,0,0,0,
-0,21095,0,0,0,0,0,21096,0,21098,0,0,0,0,0,0,0,21099,0,0,21100,21101,21102,0,0,0,
-0,0,21103,0,21104,0,0,0,0,0,21105,21108,21109,0,0,21112,21113,0,0,0,0,0,0,21115,
-21122,21123,0,0,0,0,0,21125,0,0,0,0,0,0,0,0,21129,21131,0,0,21134,0,0,0,21137,
-21142,0,21143,0,0,21144,0,21145,21146,0,21152,21154,21155,21156,0,0,0,21160,0,0,
-0,0,0,0,21161,0,21164,0,21166,0,0,0,0,21170,0,0,0,0,21171,0,0,21172,0,21174,0,
-21175,0,0,0,0,0,21176,21179,21188,0,0,0,21189,0,0,21190,0,0,0,21192,0,0,21193,0,
-0,0,21198,0,21212,0,0,21213,0,0,0,0,0,0,21215,21216,0,0,21223,21225,0,21226,0,0,
-0,0,21227,21228,0,0,21229,0,0,0,0,21230,21236,0,0,0,0,0,0,0,0,0,0,0,0,0,21237,0,
-0,21238,21239,0,0,0,0,21256,0,0,0,0,0,21257,0,0,0,0,0,0,0,21259,0,0,0,21263,0,
-21272,0,21274,0,21282,0,0,0,0,0,0,0,0,21283,0,0,0,0,0,0,0,0,21294,0,0,21297,0,0,
-0,0,21298,0,0,0,21299,0,21300,21302,0,21316,0,21318,21322,21323,0,21324,0,21326,
-0,0,0,21327,21328,0,0,0,21352,0,0,21354,21361,0,0,0,0,0,0,0,0,0,0,0,0,0,21362,0,
-0,0,21363,0,0,0,0,0,0,0,0,0,21366,0,0,21367,21372,21374,0,0,0,21375,21377,0,
-21378,0,0,0,21380,0,0,0,0,0,0,0,0,0,0,21381,0,0,0,0,0,0,21382,0,21383,0,0,21384,
-0,0,21385,0,0,0,0,21389,21390,0,0,0,0,0,0,0,0,0,0,0,0,0,21397,21398,0,0,0,0,0,0,
-0,0,0,0,21399,0,21400,0,0,0,0,21402,0,0,0,21403,21404,0,21405,21406,0,0,0,21407,
-0,0,0,0,0,0,0,0,0,0,0,0,21408,0,0,0,0,21409,0,21421,0,21422,0,0,0,21425,21428,0,
-0,0,0,21429,0,0,0,0,0,21433,0,0,0,0,0,0,0,0,0,0,21434,0,21443,0,21444,21449,0,
-21452,0,21453,21454,0,0,0,21457,0,0,21458,0,0,0,21460,21461,0,0,21464,0,0,0,
-21473,21478,0,0,21479,0,0,21481,21483,0,0,0,0,0,0,0,0,21484,0,0,21485,21486,0,0,
-21488,0,0,0,0,0,0,21523,0,0,21525,0,0,0,0,0,0,0,21526,0,0,0,0,0,0,21529,21530,0,
-0,21531,0,0,21533,0,0,21539,21564,0,21567,0,0,0,0,0,0,0,0,21575,0,0,0,0,21577,0,
-0,0,0,0,21591,0,0,21604,0,0,0,0,0,0,0,0,0,21605,0,21606,0,0,21617,21618,21619,
-21620,0,0,0,0,0,0,0,0,0,0,0,0,0,21623,0,0,0,0,21631,0,21635,0,0,0,0,21639,21646,
-21653,21662,0,0,21663,21664,0,21666,0,0,21667,0,21670,21672,21673,0,21674,21683,
-0,0,0,0,0,21684,0,21694,0,0,0,0,21695,21700,0,21703,0,21704,0,0,21709,0,0,0,
-21710,0,0,0,0,0,0,0,0,21711,0,0,0,21712,0,21717,0,21730,0,0,0,21731,21733,0,0,0,
-0,21737,21741,21742,0,21747,0,0,0,21749,0,0,0,0,0,0,0,0,0,0,0,0,0,21750,0,0,0,0,
-0,21752,0,0,0,0,21753,0,0,0,0,0,0,21755,21756,0,21757,0,0,0,0,0,0,21760,0,0,
-21763,0,0,0,0,0,0,0,0,0,21764,0,0,21766,0,0,21767,0,0,0,0,0,0,0,0,0,21773,0,
-21774,0,0,21775,0,0,0,0,21776,0,0,21777,0,0,0,0,0,0,0,0,0,21780,21787,21788,
-21791,0,0,0,21797,0,0,0,0,0,21805,0,0,0,0,21806,0,21807,21809,0,21810,21811,0,
-21817,21819,21820,0,21823,0,21824,0,0,21825,0,0,21826,21832,0,0,0,0,0,21833,
-21848,21849,0,0,21867,21870,21871,21873,0,0,0,21874,0,0,0,0,0,0,0,0,0,21875,0,
-21878,0,0,0,21879,0,21881,21886,0,0,0,0,21887,0,0,21888,21894,21895,21897,0,
-21901,0,21904,0,0,21906,0,0,0,21909,21910,21911,0,0,21912,0,0,21913,21914,21915,
-0,21919,0,0,0,0,0,0,0,21921,0,0,21922,21933,21939,0,0,0,0,0,0,0,0,0,0,0,21944,0,
-0,0,0,0,21945,0,21947,0,0,0,0,0,0,0,0,0,0,21949,0,0,0,21950,0,0,0,0,0,0,0,0,0,0,
-0,0,0,21951,0,21952,0,0,0,0,0,0,0,0,0,21954,21957,0,0,0,0,21958,0,21959,0,0,0,0,
-0,0,21962,21963,0,0,0,0,0,0,0,0,21964,21965,0,0,21969,21970,0,0,0,21974,0,0,
-21980,21981,0,21982,0,0,0,0,0,21985,0,21988,0,21992,0,21999,0,0,0,0,0,0,22001,0,
-22002,0,0,0,0,0,0,22003,0,0,0,0,0,22004,0,0,0,22008,0,22009,22015,0,0,22016,0,0,
-0,22017,22019,0,0,0,0,0,0,0,0,0,22020,0,0,0,0,0,0,0,0,0,0,22021,22037,0,22039,0,
-0,0,22040,0,0,0,22048,22049,0,0,22053,22055,22056,22059,0,0,22060,22061,0,0,
-22064,0,0,0,0,22066,0,0,0,0,0,0,0,22073,0,0,0,22074,22075,0,0,0,0,0,0,0,22076,0,
-0,0,0,22077,22084,22099,0,0,0,0,0,0,0,22104,0,0,22107,0,22108,0,22109,0,22110,0,
-0,0,0,0,0,0,22111,22119,0,22120,22122,0,0,0,0,22125,0,0,0,22128,22129,0,0,0,0,0,
-0,22141,0,0,0,22142,0,0,22144,22146,0,22148,22149,22151,22154,0,0,0,22162,0,0,0,
-0,22164,22177,0,0,0,0,22179,0,22182,22183,0,0,22184,22188,0,0,0,0,0,0,0,0,22190,
-0,22194,22201,0,0,22208,0,22209,0,22212,0,0,22215,0,22223,22231,0,0,22232,0,
-22234,0,0,22235,22236,0,22237,0,22240,0,0,0,0,0,22241,0,0,0,22242,22246,22247,0,
-0,0,22259,22268,0,22269,0,0,0,0,0,0,0,22270,0,0,0,0,22271,0,22272,0,22277,0,0,0,
-0,0,22278,22280,22283,22286,0,0,22287,22289,0,0,22290,0,22293,0,0,0,0,0,0,0,0,0,
-0,22295,0,22301,22302,0,0,0,22305,0,22308,0,0,0,0,0,0,0,0,0,0,22315,0,0,0,22317,
-0,22334,0,0,0,22335,0,0,0,0,0,22336,0,22338,22344,0,22347,22349,0,22350,0,0,0,0,
-0,0,0,22357,0,0,0,0,0,22358,0,0,0,0,0,0,0,0,0,0,22359,22360,0,0,0,0,0,0,0,0,
-22361,22366,0,0,22369,0,22370,22373,0,0,0,0,0,22375,0,22377,0,0,0,0,0,22378,0,0,
-0,0,22381,0,0,0,0,22382,0,22383,0,0,0,0,0,0,0,0,0,22391,0,0,22392,22395,22396,
-22402,0,0,0,0,0,0,0,0,0,0,0,0,0,22405,0,0,22406,0,0,22408,0,0,22409,22410,0,0,0,
-0,0,0,22424,0,0,0,0,22426,0,0,0,22427,0,22428,0,22432,0,22435,22442,22443,0,0,0,
-0,22444,0,0,0,0,0,22446,0,22454,0,22455,0,0,0,22465,0,22470,0,22471,0,0,0,0,
-22472,22473,0,22487,0,0,0,22488,0,0,0,0,22489,0,0,22499,0,0,0,0,0,0,22514,0,0,
-22515,0,0,0,0,0,0,0,22516,0,0,0,22517,22520,0,0,0,22534,0,0,22535,0,0,22536,0,
-22540,22553,0,22555,0,0,0,0,22561,0,0,22562,0,0,0,0,0,0,0,0,0,0,0,22566,0,0,0,0,
-22567,22568,0,0,22575,0,22579,0,22582,22583,22585,0,0,0,0,0,22586,0,0,22587,0,0,
-22590,0,0,0,0,0,22591,0,22592,0,0,0,0,0,22593,0,22602,0,0,22604,0,0,22609,0,0,
-22618,0,0,0,0,0,0,22619,0,22624,22625,0,0,22638,0,0,0,0,0,22639,0,0,22640,0,0,0,
-0,0,0,0,22644,0,22645,22647,0,0,0,0,22652,22653,0,0,0,22654,0,22655,0,0,0,22656,
-0,0,0,0,0,0,0,0,0,0,22673,22675,22676,0,0,22678,22679,0,22691,0,0,0,0,0,0,0,
-22693,0,0,22696,0,22699,22707,22708,0,0,0,0,0,0,0,0,22718,0,22719,0,0,0,0,22723,
-0,0,0,22724,22725,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22726,22728,0,0,0,0,0,0,0,0,22729,
-0,0,22731,0,0,0,0,22732,22735,22736,0,0,0,0,22739,0,22749,0,0,22751,0,0,0,0,0,0,
-0,0,0,0,0,22758,0,0,0,0,0,22760,0,0,0,0,0,22764,22765,22766,0,22768,0,0,0,0,0,
-22769,22770,0,0,0,0,0,0,22771,0,0,22772,22775,0,22776,22777,22780,0,0,22782,
-22784,0,22787,0,22789,22796,0,0,0,0,0,22798,0,0,0,0,0,0,22802,0,22803,22804,0,0,
-0,0,0,0,0,0,0,0,22805,0,0,22810,22811,22814,22816,0,22825,22826,0,22831,22833,0,
-0,0,0,0,0,0,0,0,22834,0,22836,22838,0,22839,0,0,0,0,0,22840,0,22847,0,0,0,0,0,
-22856,22857,0,22858,22859,0,0,22862,0,0,22864,0,0,0,0,22865,0,0,0,0,0,0,0,0,0,0,
-0,22866,0,22867,22868,0,0,0,0,22869,0,22871,0,22872,0,22873,22881,22882,22884,
-22885,0,0,0,0,0,0,0,22886,22887,0,22894,0,22895,0,0,0,22900,0,22901,0,0,0,0,
-22904,0,0,0,0,22905,22907,0,0,0,22915,22917,0,0,22918,0,0,0,22920,0,0,0,22929,
-22930,0,0,0,22941,22942,0,0,0,22943,0,0,0,22944,0,0,0,0,0,0,0,22946,0,22947,0,0,
-22954,0,22956,0,0,22962,0,0,0,0,0,0,0,22963,0,0,22964,0,0,0,0,0,0,0,22965,0,
-22968,0,0,0,22969,0,0,0,0,0,22970,0,22971,0,0,0,0,0,22978,0,0,22979,0,22987,0,0,
-22989,0,0,0,0,0,0,22990,0,23005,0,0,0,0,0,0,0,23006,23007,23008,0,0,23023,23024,
-23029,0,0,0,0,23030,0,0,0,0,0,23032,0,0,0,0,0,23035,0,0,0,0,23038,0,0,0,23048,0,
-23049,23052,23053,23060,23061,0,23063,0,0,0,0,23067,23068,0,0,0,23069,23073,0,0,
-0,23127,0,23128,0,0,0,0,0,23129,0,23138,23141,0,23149,0,0,23150,0,0,0,23152,0,0,
-0,0,0,0,0,0,23154,0,0,0,0,23157,23159,23160,0,0,0,0,0,0,0,0,0,0,0,0,23180,0,0,0,
-0,23181,0,0,23188,0,23189,0,0,0,0,0,0,0,0,0,0,0,0,23195,0,0,23196,23199,0,0,0,0,
-0,0,0,0,0,23202,0,23204,0,23207,0,23209,23210,0,0,0,0,0,0,23227,23229,0,0,23230,
-23234,23238,0,0,0,23245,23246,23248,0,0,0,0,23249,23254,0,0,0,23265,0,0,0,0,0,0,
-0,23268,0,23276,0,0,0,0,23277,0,23297,0,23298,0,0,0,0,23299,0,23302,0,0,23303,
-23312,0,0,23314,0,23320,0,0,0,0,23324,0,23325,0,23328,0,23334,0,0,0,23337,0,0,0,
-0,23343,23344,23346,0,23348,0,0,0,0,0,0,0,0,23353,0,0,0,0,23355,0,23356,23358,0,
-0,0,23359,23360,0,23361,0,23367,0,23369,0,0,23373,0,23378,23379,0,23382,23383,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,23387,0,0,0,0,0,0,23388,23390,0,0,23393,23398,0,0,0,
-23399,0,0,0,23400,0,0,0,0,23401,0,0,0,23415,0,0,0,0,0,0,0,0,23416,0,23422,0,
-23443,23444,0,0,0,0,23448,0,23454,0,0,0,0,0,0,23456,0,0,23458,23464,0,0,0,0,0,0,
-23465,0,0,0,23470,23471,0,0,23472,0,0,0,23473,23496,0,0,0,0,0,0,0,0,23497,0,
-23499,0,0,23502,0,0,23503,0,0,23513,0,0,23515,0,0,0,23517,0,0,0,0,23518,23519,
-23521,23524,0,23525,23528,23539,0,0,0,0,0,23541,0,0,23544,0,0,23556,0,0,23557,0,
-0,0,0,0,0,0,0,0,0,0,0,0,23559,0,23560,0,0,23561,0,0,23566,0,0,0,0,0,23568,23569,
-23570,0,0,0,0,23571,0,23574,0,0,0,0,0,0,0,0,0,0,0,23575,0,23579,0,0,23581,0,0,0,
-0,0,0,23587,0,0,0,0,0,0,0,23596,23598,0,0,0,0,23602,23606,0,0,23607,0,23608,0,0,
-0,23614,23616,0,0,0,0,0,23618,0,0,23619,0,0,0,0,23621,23626,0,23627,0,0,0,0,0,0,
-0,23629,0,23630,0,0,0,0,23634,0,23636,0,0,0,0,0,0,23638,0,0,0,0,23640,23667,0,
-23669,0,0,0,23681,0,0,0,0,0,0,0,23682,0,23683,0,0,0,0,0,23684,0,0,0,23685,23689,
-0,23693,23694,23700,0,23702,0,23709,0,0,0,0,0,0,0,23712,0,0,0,0,0,23714,0,0,
-23715,0,0,0,0,23718,0,0,23720,0,0,0,0,23722,0,0,0,23726,23729,0,23741,23746,0,
-23748,0,0,0,0,23749,0,0,0,0,0,23750,0,0,0,0,23751,0,23753,0,0,0,0,23757,23765,0,
-0,0,23770,0,0,0,0,0,0,0,23771,0,23772,23781,0,0,23796,0,0,0,0,23798,0,23799,0,0,
-0,23802,0,0,23806,0,23807,0,0,23808,0,23809,0,23819,0,0,0,23821,0,23827,0,0,0,
-23829,0,0,0,0,0,0,0,23830,0,0,0,0,0,0,23832,23833,23834,23835,0,0,0,0,23837,
-23838,0,0,0,0,0,23846,0,0,0,0,0,0,23847,0,0,0,0,0,23879,23881,0,0,23882,23883,
-23895,0,23899,0,0,0,0,23901,0,0,0,0,0,0,23902,0,0,0,0,0,23903,23905,0,23906,0,
-23907,23918,23919,23920,0,23922,0,23924,0,23927,0,23934,0,23937,23941,0,23942,
-23946,0,0,0,0,0,23955,23956,23958,0,0,0,0,0,0,23959,0,23962,23965,0,23966,0,0,0,
-0,23967,23968,0,0,23973,0,0,23974,0,0,0,0,23975,0,23976,0,0,0,0,0,0,0,0,0,0,0,0,
-0,23977,0,0,0,0,0,0,0,0,23980,0,0,23984,0,23985,0,0,23987,0,0,23988,23990,23991,
-0,0,0,0,0,0,23992,0,0,0,0,0,0,0,0,23994,0,0,0,23998,0,0,0,0,0,0,0,0,0,23999,0,0,
-24003,0,24004,0,24006,0,0,0,24007,0,0,24008,0,0,0,0,0,0,0,24009,0,0,24010,0,0,
-24011,0,0,24013,24014,0,0,24015,24016,24027,0,24028,24029,0,24030,0,0,0,0,0,
-24033,24034,0,24035,0,0,24036,0,0,24044,0,24048,24049,24063,24067,0,24068,24070,
-0,0,24071,24078,24087,0,24090,0,0,0,24095,0,24098,24101,24104,24106,0,24107,0,0,
-0,24108,0,0,0,0,24110,24111,0,24113,0,0,24115,24120,0,0,0,0,0,0,24124,0,24125,0,
-24126,0,24127,0,0,0,0,0,24135,0,0,24136,0,24137,24142,0,0,0,24146,0,0,24147,
-24149,24154,0,24163,0,0,0,24165,24166,24167,0,0,0,0,0,0,0,0,0,0,24169,24170,
-24175,0,0,0,24178,0,0,24179,0,0,24181,0,24184,24197,0,24201,24204,0,0,0,0,0,0,
-24206,24212,24220,0,0,0,24224,0,0,0,0,0,0,0,0,24226,0,24234,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,24235,0,24236,0,0,0,0,0,24239,24240,24241,0,0,24248,0,0,24249,0,
-24251,0,0,0,0,0,0,24253,0,24268,0,0,0,24269,0,24271,24272,0,0,0,0,24273,0,0,
-24274,0,0,24279,0,0,0,0,0,0,0,24280,0,24293,24294,0,0,0,0,0,0,24296,0,0,24323,0,
-0,0,24329,24330,24331,24339,0,24351,0,0,24369,24370,0,0,0,24371,0,0,0,0,24372,
-24373,24374,0,0,0,0,0,24378,0,0,0,0,24379,0,24381,0,24383,24389,0,24390,0,0,
-24394,24395,24400,0,0,0,24401,24402,0,24406,0,0,0,24411,0,0,0,24415,0,24416,0,0,
-0,0,0,24417,0,24419,0,24422,0,24423,24428,0,24435,0,0,0,24439,0,0,0,24440,24442,
-24446,0,0,0,24447,24448,24449,24452,0,0,0,0,24453,24457,0,0,24458,24459,24460,0,
-24465,0,0,0,0,0,0,0,24470,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24471,0,24473,
-24474,24475,24476,0,24478,0,0,0,0,24480,0,0,0,0,0,0,0,0,0,0,24481,0,0,0,0,0,0,0,
-0,0,0,24482,24485,0,0,0,0,24486,0,0,0,24488,0,0,0,24494,0,0,0,0,24497,0,0,24498,
-0,0,0,24499,24506,0,0,0,24507,0,0,24511,0,0,24513,24514,0,0,0,0,0,24517,0,24518,
-0,24520,0,24521,24524,24525,0,0,0,0,0,24527,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24528,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24537,24539,0,24540,0,0,0,24548,0,0,0,0,0,24549,
-24550,0,0,0,24553,24554,0,24555,0,24556,0,24558,0,0,0,0,0,24560,0,0,0,24561,0,0,
-0,0,0,24562,0,0,0,0,0,0,0,0,0,0,0,0,0,24567,0,0,0,0,0,24569,0,0,0,24574,0,24575,
-0,0,0,0,0,0,0,0,0,0,0,24577,24581,0,24584,0,0,0,0,0,24585,0,0,0,0,0,24586,0,0,
-24587,0,24588,0,0,0,0,0,0,0,0,0,0,24590,24591,0,0,0,0,24592,0,0,0,0,0,0,0,24594,
-0,0,0,0,0,0,0,24596,24597,0,0,0,0,24602,24603,0,0,0,0,24604,0,0,24605,0,24610,0,
-0,24611,0,0,0,0,24612,24615,24616,24624,0,0,0,24627,0,24638,24639,0,0,0,0,24640,
-0,0,0,24655,24656,24657,0,0,0,0,0,0,0,0,24662,0,24663,24664,0,0,0,0,0,24665,0,0,
-0,0,24667,0,0,0,0,0,0,24668,24669,0,24670,24674,0,0,0,24675,0,24678,0,0,24679,0,
-0,0,24681,0,24683,0,0,0,0,24684,0,24685,0,0,24686,0,0,24688,24689,0,0,0,0,24690,
-24691,0,0,0,0,0,0,0,24697,0,24698,0,0,0,0,0,0,0,0,24709,0,0,0,0,0,24710,0,24712,
-0,0,0,0,0,0,24713,24714,0,24715,0,24716,24718,0,24719,0,0,0,0,24720,0,0,24725,0,
-0,24738,0,24749,24750,0,0,0,24752,0,0,0,24753,0,0,0,24758,0,0,0,0,0,24762,0,
-24763,0,0,0,0,0,0,0,24764,0,0,0,0,0,24765,24767,24768,0,24772,0,0,0,0,24773,0,0,
-0,0,24777,0,0,0,0,0,24785,0,24786,24788,0,0,0,24789,0,0,0,0,24794,24798,0,24799,
-24800,0,0,0,24803,0,24804,24806,0,24807,0,0,0,24810,0,0,0,0,0,0,24827,24828,0,
-24835,0,0,0,0,0,0,24836,0,0,0,0,0,24839,0,24843,24844,0,0,0,0,0,0,0,0,0,0,24847,
-0,0,24848,0,0,0,0,0,0,24849,0,24850,24851,0,0,0,24852,0,24853,0,0,0,0,0,0,0,0,0,
-24854,0,24855,0,0,24868,0,0,0,24883,0,0,0,24884,0,24895,24897,0,0,0,0,0,24899,0,
-0,0,0,0,24900,0,24913,0,0,0,0,0,0,24914,0,0,24917,24930,24931,0,0,0,24932,0,0,
-24939,0,0,24942,0,0,0,0,0,0,0,0,0,24945,24950,0,24951,0,0,24953,0,0,0,24954,0,
-24959,0,0,0,24961,0,0,24962,0,24964,24968,24970,24972,0,0,0,0,0,24976,0,0,0,
-24977,0,24982,0,0,24983,0,0,24984,0,0,0,24993,0,0,0,24994,0,0,25001,0,0,0,25003,
-0,0,25018,0,0,25023,0,0,0,25034,0,0,25035,25036,0,25037,0,0,0,0,0,0,0,25039,0,0,
-0,0,0,25040,0,0,0,0,0,0,0,25042,0,0,25043,25045,0,0,0,0,0,0,25049,0,0,25051,0,
-25052,25053,0,0,25054,0,0,0,25055,0,0,0,0,25057,25059,0,0,25060,25064,0,25065,
-25069,25070,0,0,0,0,25072,0,25073,0,25090,0,0,25092,25093,25101,0,0,0,0,0,0,
-25105,25108,0,0,25113,0,0,25115,25116,0,0,0,0,0,0,25117,0,0,0,25120,25121,0,0,0,
-0,0,0,0,25125,0,0,0,25126,0,25130,25134,0,25139,0,25143,0,0,0,25151,0,25161,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25163,0,0,0,0,0,0,0,25174,0,25175,0,25207,0,0,
-0,25209,0,0,0,0,25213,0,25219,0,25223,0,25225,0,0,0,25227,0,0,0,25228,0,0,0,
-25229,0,0,0,0,0,0,0,25231,25233,0,0,0,0,25237,25239,0,0,0,25243,0,0,0,25252,0,
-25257,25258,0,0,0,0,25260,25265,0,25268,0,0,25273,25324,0,25325,0,25326,0,0,0,0,
-0,0,0,0,25327,0,0,0,0,0,25328,0,0,0,0,0,0,25332,0,0,0,25333,0,0,0,25336,25337,
-25338,0,0,25343,0,25350,0,0,0,0,0,0,0,25352,0,25354,0,25375,0,25379,0,0,0,0,
-25384,0,0,0,0,0,0,0,0,0,25386,0,25388,0,25390,0,0,25399,0,0,25401,0,0,0,25402,0,
-0,0,25407,0,0,0,0,0,0,0,0,0,0,0,25413,25415,0,0,25417,0,0,0,0,0,0,0,25419,0,0,0,
-25421,0,0,0,25424,0,0,0,0,25433,0,0,0,0,0,0,0,0,0,25435,0,0,0,0,0,0,25436,0,0,0,
-25437,0,0,25440,0,0,0,0,0,0,25442,0,0,25443,0,25446,0,0,25449,0,0,0,25450,0,0,0,
-0,25452,0,25453,25454,25455,0,0,0,25456,0,25457,0,0,0,25459,0,25461,0,25468,0,0,
-0,0,0,0,0,0,25469,0,0,0,0,0,25471,0,0,0,0,0,25474,0,0,0,0,0,0,0,0,25475,0,0,0,0,
-25477,0,0,0,0,25483,0,0,0,0,0,25484,0,0,0,0,0,0,0,0,0,0,0,0,25485,0,25497,0,0,
-25498,0,25504,0,25510,0,25512,0,0,25513,25514,0,0,0,0,0,0,25517,25518,25519,0,
-25520,0,0,0,0,0,0,0,25521,0,25522,25527,25534,0,25536,0,25537,0,0,25548,25550,0,
-0,25551,0,25552,0,0,0,0,0,25554,0,25555,0,25556,25557,25568,0,0,0,25570,25571,0,
-0,0,0,0,0,25574,0,0,0,0,25579,0,0,0,25581,0,0,0,25582,0,0,0,0,0,0,0,0,0,25588,0,
-0,0,0,25589,0,0,0,0,25590,0,25591,25592,25593,0,25594,0,0,0,25596,0,25597,25615,
-0,0,0,0,0,25618,0,0,0,0,25619,25623,0,0,25629,0,0,25631,0,0,0,25635,25636,0,0,
-25649,0,0,0,0,25654,0,0,0,25661,25663,0,0,25671,0,0,25678,25698,0,25699,25702,
-25703,0,0,0,0,0,0,0,0,25704,0,0,0,0,0,25706,0,0,25710,0,25711,0,25712,0,25715,
-25716,25717,0,0,25718,25728,25732,0,0,0,25734,0,0,0,0,0,0,0,0,0,25737,0,0,25739,
-0,0,0,25740,0,25741,25745,0,25746,0,25748,25772,25778,0,0,0,0,0,25780,0,0,0,0,
-25781,0,25782,25784,25785,0,0,0,25789,0,0,0,0,0,0,25797,25801,0,0,0,25808,25809,
-0,0,25811,25814,25815,0,0,25817,0,0,0,0,0,0,0,0,25820,0,0,0,0,25832,25833,0,0,0,
-25846,0,0,0,25847,25848,0,0,0,0,0,0,0,0,0,25849,25850,0,0,25851,0,0,25852,0,
-25862,0,0,0,25863,25865,0,0,0,0,0,0,0,25867,25868,0,25869,25874,0,25875,0,25876,
-25877,0,0,0,0,25878,25902,0,0,0,0,0,0,0,25903,25904,25905,0,0,0,25908,25909,0,0,
-0,0,25910,0,0,0,0,0,0,0,25912,0,25913,0,0,0,0,0,0,0,0,25914,0,0,25916,0,0,0,0,0,
-25917,25927,0,0,0,0,25928,0,0,25930,0,0,0,25933,0,0,25938,25942,0,0,0,0,0,0,0,
-25945,0,25950,0,25956,0,0,25961,25962,0,0,25963,0,25964,25965,25966,0,0,0,0,0,
-25967,0,0,0,0,25968,0,0,0,25969,25971,0,0,0,0,0,25973,25975,0,0,0,0,0,0,0,25978,
-0,25981,0,0,0,25982,0,0,0,25984,0,0,0,0,0,0,0,25993,0,0,0,0,0,0,0,0,0,0,0,0,0,
-26002,0,0,0,26005,0,0,0,26006,26007,0,0,26014,26015,26016,0,0,0,0,0,0,26017,
-26018,26020,0,26022,26023,0,0,0,26024,26028,0,26029,26033,26034,26044,0,0,0,0,0,
-26046,0,0,26047,0,0,26049,0,26050,0,26051,0,0,0,0,0,26053,0,0,0,0,26054,26059,0,
-0,0,0,0,0,26060,0,26066,0,0,0,0,0,0,0,0,0,0,0,0,26067,0,26069,0,0,26071,0,0,0,
-26073,0,26074,26077,0,0,0,0,26078,0,0,0,26079,0,26090,0,0,26094,0,0,0,0,0,0,0,0,
-26095,0,0,0,0,0,0,0,0,0,0,0,26096,26101,0,26107,26122,0,26124,0,0,26125,0,0,0,0,
-0,0,26136,26141,26155,0,0,0,0,0,0,0,0,0,26164,26166,0,0,0,26167,0,26170,26171,0,
-0,26172,0,0,26174,0,0,0,0,0,0,0,0,0,0,0,0,0,26175,0,0,0,26176,26177,0,26321,
-26322,0,26323,0,0,26324,0,0,0,0,0,0,0,26325,0,26331,0,0,0,0,0,0,26335,0,0,0,
-26350,0,0,0,26379,0,0,26382,26383,26385,0,0,26392,26406,0,0,0,0,26411,0,0,0,0,0,
-26412,0,0,26420,0,0,26423,0,26424,26426,26432,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-26435,0,26436,0,0,0,0,0,26441,0,26444,0,0,0,26446,0,0,0,0,26447,0,0,0,0,26449,0,
-26450,26452,0,26453,26454,0,0,0,26455,0,0,0,26456,0,0,26458,0,0,26460,0,26463,0,
-0,0,0,0,0,0,0,26464,26470,0,0,0,0,0,0,0,0,0,26473,0,0,26474,0,0,0,0,0,0,0,26475,
-0,0,0,0,0,0,0,26477,0,26485,0,0,26486,0,26487,0,0,26488,26493,26494,0,0,26495,0,
-26497,26504,26506,0,0,0,0,0,26507,0,0,0,0,0,26509,0,0,26510,0,0,0,0,0,0,0,0,0,0,
-0,0,0,26512,0,26513,26515,0,0,0,26518,0,0,0,26519,0,26524,26526,0,0,0,26527,0,
-26532,0,26533,26537,26558,0,0,0,26559,0,0,0,26571,0,0,26573,0,26588,0,26593,0,0,
-0,0,0,0,26603,0,26604,0,0,0,0,0,0,0,0,0,0,26606,0,0,0,0,0,0,0,26607,26609,26611,
-26614,0,0,0,26616,26620,0,26621,0,0,0,0,0,26627,0,26629,0,0,26630,0,0,26632,
-26643,0,0,0,26644,0,0,0,0,0,0,0,0,0,26646,26647,0,0,0,26650,0,0,26656,0,0,0,0,
-26663,26670,26671,0,0,0,26685,26686,26687,0,26689,0,0,0,0,26744,0,26745,0,26747,
-26748,0,26749,26750,26751,0,0,0,0,26752,26755,0,0,0,26756,26769,0,0,0,26774,0,0,
-0,0,0,26775,0,26777,26778,0,26786,0,0,0,26787,0,0,0,0,0,0,0,0,0,0,0,0,0,26788,0,
-0,26789,0,0,0,0,0,26791,0,26792,26793,0,0,0,26794,0,26797,26798,0,0,0,26800,0,0,
-26803,0,26804,0,0,0,0,0,0,0,0,0,26805,0,0,26808,0,0,26809,0,0,0,0,0,0,0,26812,0,
-26825,0,0,0,0,0,0,0,26826,0,0,26827,26829,26834,0,0,0,0,26835,0,0,26849,0,26851,
-0,0,0,0,0,0,0,0,0,26852,0,26853,26857,0,26858,0,26859,0,0,0,0,0,0,0,26876,0,
-26878,26882,26883,0,0,0,0,26890,26894,0,0,0,0,26895,26896,0,0,0,0,0,26900,0,0,0,
-0,0,0,0,26911,26913,26914,26915,26916,26919,0,0,0,26921,26922,0,0,26925,0,0,0,
-26928,0,0,26929,26930,0,0,0,26931,0,26932,0,0,0,0,0,26933,0,0,0,0,0,0,26937,0,0,
-26943,0,0,26944,0,0,0,26946,0,0,0,0,0,0,0,26956,0,26958,0,0,26963,0,0,0,0,0,0,0,
-26965,0,26969,26970,26972,0,0,0,0,0,26973,0,26974,0,26978,0,26980,0,0,0,0,0,0,
-26982,0,26986,26987,0,26990,0,0,0,0,27003,27006,0,0,27007,27010,27012,27013,0,0,
-0,0,0,0,0,0,27014,27015,27018,0,27019,0,0,0,0,0,27025,0,0,0,27026,0,0,0,0,27029,
-27030,27031,27034,0,0,27036,27037,0,0,0,27038,27042,0,0,0,27044,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,27045,0,0,0,0,0,0,0,27046,0,0,0,0,0,0,0,27047,27049,0,27050,0,0,0,
-27051,27052,0,27055,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27056,27058,27059,0,
-27061,0,27064,0,0,0,0,0,27069,0,0,27070,0,0,0,0,0,0,0,27072,0,0,0,0,0,0,0,0,
-27076,0,0,0,0,0,27078,0,27079,0,0,0,27081,0,0,0,0,0,0,27082,0,27083,27086,0,0,0,
-0,27087,0,0,0,0,0,27088,27090,0,27094,0,0,27095,0,27099,27102,0,0,0,27103,0,0,0,
-0,27105,0,0,0,27106,0,0,0,0,0,0,27107,0,0,0,0,27108,27117,0,0,0,0,27118,0,0,
-27124,0,27126,0,0,27130,27131,0,0,0,0,0,0,27147,0,0,0,0,27148,27149,0,0,0,0,
-27150,27151,0,27152,0,27159,0,0,0,27164,0,0,0,0,0,0,0,27175,0,27189,0,0,27191,0,
-27193,0,27195,0,27198,0,0,0,0,0,27200,0,0,0,0,27202,0,0,0,0,27203,0,0,27204,0,0,
-27206,0,27207,0,0,0,0,27209,0,0,0,27213,0,0,27216,27219,27220,27222,27223,0,
-27224,0,27225,27226,0,0,27233,0,0,0,0,27235,0,27237,0,27238,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,27239,0,27242,27243,0,27250,0,0,0,27251,0,27253,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,27254,27255,27258,0,0,0,27259,0,0,0,0,0,0,27267,0,27276,27278,
-0,0,0,0,0,0,0,0,0,27296,27297,27301,0,0,0,0,0,0,27302,0,0,0,0,0,0,27312,27313,0,
-0,0,0,0,27318,0,27320,0,27329,0,27330,27331,0,27332,0,0,0,0,27340,0,0,0,27348,0,
-0,0,0,0,0,27350,0,27351,0,0,0,0,27355,0,0,27358,27359,27361,0,0,0,27365,0,27367,
-0,27376,27378,0,0,27379,0,0,0,0,0,0,27396,0,27397,27404,0,0,0,0,0,27408,0,0,0,0,
-27453,0,0,0,27456,0,0,0,27458,0,0,0,0,0,0,0,27459,0,0,0,27460,0,0,27461,0,27465,
-27467,0,0,27469,0,27470,0,27471,0,27477,27482,0,0,0,0,0,0,27484,0,0,0,0,0,0,
-27485,0,0,0,0,0,27493,0,27494,27502,0,0,0,0,0,0,0,0,0,0,0,0,27511,27532,0,0,0,
-27533,27545,0,0,0,27546,0,0,0,0,0,0,0,0,0,0,27547,0,0,27549,27550,0,27551,0,0,0,
-0,0,0,0,27555,0,0,27571,0,27573,27574,27575,27577,0,27578,0,0,27579,27585,0,0,0,
-0,0,27586,0,0,27588,27589,0,0,0,0,27596,0,0,27600,0,0,0,0,0,0,0,0,0,0,0,27608,0,
-0,0,0,0,0,0,0,0,0,0,27610,0,0,0,27618,0,0,27620,0,0,0,27631,0,0,27632,27634,0,
-27636,27638,0,0,0,27643,0,27644,27649,0,0,0,0,0,0,0,0,0,0,0,0,0,27651,27660,0,
-27661,0,0,0,0,0,0,0,27662,0,0,27664,0,27665,0,0,0,27669,0,27671,0,0,0,27673,
-27674,0,0,0,27682,0,0,0,27711,0,27712,27713,27719,27720,0,0,27728,0,27729,0,0,0,
-0,0,0,0,0,0,27731,0,0,27732,0,27733,0,27738,0,0,0,27742,0,0,0,27743,27744,0,0,0,
-0,0,0,27745,27746,0,0,0,27747,27748,27751,27752,0,0,0,27768,27770,0,0,0,27774,
-27775,0,27776,27777,0,0,27781,0,27784,0,27786,0,0,27791,0,27792,27793,27804,0,
-27812,27813,0,0,0,0,0,0,0,0,27814,0,27825,0,27827,0,0,0,0,27828,27861,27862,0,0,
-0,27864,0,0,0,27865,27884,0,27889,0,0,0,0,0,27890,0,27891,0,0,0,27892,0,0,0,0,0,
-27897,27898,0,0,27899,0,0,0,27901,27905,0,0,27920,0,0,27921,0,27922,0,0,0,27931,
-27934,0,0,0,0,0,0,0,0,0,0,27941,0,27942,0,27945,0,27947,27954,0,0,0,0,27960,
-27963,0,0,0,0,0,0,0,0,27964,27965,0,0,0,27967,0,27969,27975,0,27976,27977,0,
-27981,0,27983,28051,28052,0,0,0,0,0,28056,0,0,0,0,0,0,28058,28059,0,0,28061,0,0,
-0,0,0,0,0,28063,0,0,0,0,0,0,28066,0,0,0,0,0,0,28069,28070,28072,0,28073,0,0,
-28074,0,0,0,0,28075,0,0,0,0,0,0,0,28078,0,0,0,0,28085,0,0,0,0,28086,0,0,0,0,0,0,
-28088,0,0,0,0,0,0,0,0,28090,0,28097,28114,28115,0,0,0,0,0,0,0,28116,0,0,0,0,0,
-28118,0,28129,0,28131,0,0,28135,0,0,0,28140,28141,0,0,0,28146,0,0,0,0,28152,0,0,
-0,0,28155,28157,28161,0,0,0,0,28166,0,28167,0,0,0,0,0,0,0,0,0,0,0,28172,0,0,0,0,
-0,0,28173,0,0,28175,0,0,0,0,0,0,0,0,0,28178,28188,0,28190,0,0,0,0,0,28191,0,
-28193,28206,0,0,28207,28209,0,28211,0,28213,0,0,0,28215,28216,28217,0,28222,0,
-28223,28225,0,0,0,28226,0,28227,28229,28232,0,0,0,0,0,0,0,0,0,28235,0,28241,0,0,
-28242,0,0,0,0,28243,0,0,0,28245,0,0,0,28248,28250,0,28251,28252,0,0,0,0,0,0,
-28253,0,0,28254,28255,0,0,28256,0,0,28258,0,0,0,0,0,28259,0,0,28260,0,0,28261,0,
-0,0,0,28262,28263,0,0,28264,0,0,0,28266,0,28268,28269,0,28270,28272,28274,0,
-28277,28278,0,0,0,28279,0,28280,28281,28283,0,28292,0,28294,0,28297,0,0,0,0,
-28299,0,0,0,0,0,28300,0,0,0,0,0,0,0,28301,0,0,0,0,0,0,0,0,0,0,0,0,0,28302,28303,
-0,0,0,0,28304,0,0,28305,0,28312,0,28313,28314,0,0,0,0,0,0,28315,0,0,0,28320,
-28321,0,0,28328,0,0,0,28329,28338,0,28339,0,0,28344,0,0,0,0,0,0,0,0,28347,0,0,0,
-0,0,0,0,0,28348,0,0,0,0,0,28411,0,28412,28413,0,28416,0,0,0,28420,0,0,0,0,0,
-28421,0,0,0,0,28423,0,0,0,28424,0,0,28428,0,0,0,0,0,28429,0,0,0,28431,28434,0,
-28458,0,0,0,0,0,0,0,0,0,0,0,28464,0,0,0,0,28465,0,28467,0,0,0,0,0,0,28471,0,0,0,
-0,28474,0,28480,0,28481,0,0,28485,0,0,0,0,28486,28488,0,0,28489,0,0,0,0,28492,0,
-0,0,28495,0,28497,0,28499,0,0,0,0,28500,0,0,28502,28503,0,0,0,28508,0,0,0,28510,
-0,0,28512,28513,28514,28521,0,28526,0,28527,28528,0,0,0,0,28529,0,0,28532,0,0,
-28537,28538,0,0,0,28539,0,28548,0,28553,28554,0,0,0,0,0,0,0,0,0,0,0,0,28560,
-28563,0,0,28564,0,0,0,0,28565,0,0,0,0,0,0,0,28566,28568,0,0,0,0,0,0,28569,0,0,0,
-28570,0,28572,28573,0,0,0,0,28575,0,0,0,0,28576,28581,28588,0,0,28589,0,0,0,
-28590,28595,0,28598,0,0,28601,0,0,28605,0,0,0,0,28614,28615,28619,0,0,0,0,0,0,
-28620,0,28626,0,0,28628,0,28631,0,28632,0,0,0,0,0,0,28635,0,0,0,28637,28638,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28639,0,28643,0,0,28652,0,0,0,28662,0,
-28670,28671,0,0,0,0,0,0,0,0,0,28672,28673,28675,28676,0,0,0,0,0,0,0,28691,0,0,0,
-28695,0,0,0,28696,0,28697,28698,0,28705,0,28707,28708,28710,0,0,0,0,0,0,0,28711,
-28728,0,0,0,28736,0,0,0,28737,0,0,0,0,0,0,0,0,0,28738,0,28739,0,28741,0,0,28742,
-0,0,0,0,0,0,0,0,0,0,0,28745,0,0,0,0,0,0,28749,28750,28752,28754,28756,0,28757,0,
-0,0,0,28759,28760,0,0,0,0,0,0,28762,0,0,0,28764,0,0,0,0,0,0,28766,0,28767,28768,
-0,0,0,0,28769,28770,0,0,0,0,0,0,0,0,0,0,0,0,0,28771,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,28772,0,28773,0,28782,0,0,0,0,0,0,28784,0,28785,0,28786,0,0,0,28787,0,0,0,
-28797,0,0,0,0,0,0,28799,0,0,28801,0,0,0,0,28802,0,28805,0,0,28806,0,0,28807,0,0,
-0,0,0,0,0,28808,0,0,0,0,0,28810,28812,0,0,28816,28819,0,0,28821,0,28826,0,0,0,
-28842,28852,0,0,28853,0,28854,28855,0,0,0,28857,0,0,0,28858,0,28867,28868,28869,
-0,0,0,28874,28880,28882,28890,28892,0,0,0,0,0,0,0,28895,0,0,0,28898,28899,0,0,0,
-28900,0,0,28904,0,28906,0,0,0,0,28907,0,0,0,0,0,0,28908,0,0,0,28910,0,28914,0,0,
-0,0,0,0,0,28915,28916,28919,0,0,28920,0,28921,0,0,0,0,0,0,0,0,28924,0,0,0,0,
-28926,28929,0,0,0,28930,0,28936,0,28939,0,0,0,0,28942,0,0,0,0,0,0,28956,0,0,0,
-28966,0,0,0,0,28967,0,0,0,0,0,0,0,0,0,28968,0,28971,0,28975,28976,0,28982,28983,
-0,0,28984,28989,28996,28997,28998,0,0,0,0,0,0,28999,0,0,0,0,0,29000,0,29001,0,0,
-0,29009,0,0,29011,0,0,29021,0,0,0,0,29024,0,29025,0,0,0,0,0,29026,0,0,0,29036,0,
-0,0,29037,0,0,0,0,29038,0,29045,0,29047,0,0,0,0,0,0,0,0,0,29051,0,0,0,29054,
-29056,29062,0,29070,29082,0,0,0,29083,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29084,0,0,
-0,0,29085,29088,0,0,0,0,0,0,0,29090,29097,0,0,0,29103,0,0,0,0,0,0,0,0,29105,0,0,
-0,0,0,29107,0,29109,0,0,0,29115,0,0,29120,0,0,29138,29140,0,0,0,0,0,0,0,0,0,
-29152,0,29160,29174,0,29176,0,0,29180,0,29181,0,0,0,0,0,0,0,0,29228,0,0,29229,0,
-0,29230,0,0,0,0,0,0,0,0,0,0,29234,0,0,0,29241,0,29245,0,29248,0,29250,29256,
-29280,0,29282,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29285,0,0,29286,29291,29292,0,0,0,0,
-29294,0,29295,0,0,0,0,0,29296,29297,29298,29300,0,29302,0,0,29304,29307,0,29312,
-0,0,0,29322,0,0,29323,0,0,29324,29326,29328,0,29335,0,0,0,0,0,0,0,29338,29339,0,
-0,0,0,0,29341,29343,0,0,0,0,29344,0,0,0,0,0,29345,0,0,0,0,29346,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,29347,29348,29349,0,0,29354,0,0,29355,0,0,0,0,0,0,0,0,29357,0,0,
-0,0,29364,0,29365,0,0,0,0,0,0,0,29366,0,0,29368,0,0,0,0,0,0,0,0,29378,0,29381,0,
-0,0,0,0,0,0,0,29386,0,0,0,0,0,0,29389,0,0,0,29390,0,0,29391,29397,0,29398,29412,
-29414,29418,29419,0,0,0,0,0,0,0,29420,0,0,0,0,0,0,0,29423,0,0,0,29435,0,0,0,
-29437,0,0,29439,0,29441,0,0,0,0,29443,0,29446,29450,29452,0,0,0,0,0,29456,0,0,0,
-0,0,29461,0,0,0,29464,0,0,0,0,0,0,0,0,29468,0,29473,0,0,0,29486,0,0,0,29490,0,0,
-0,29491,29492,0,0,29497,0,0,0,29498,0,29499,0,29502,29505,0,29509,0,0,0,29510,0,
-0,0,29512,0,0,0,29516,0,0,0,0,0,0,0,0,29518,0,29519,0,0,0,0,0,29520,29521,29529,
-0,0,0,0,0,0,0,0,29530,0,0,29531,29538,0,29540,0,0,0,29542,0,29543,29544,29547,0,
-0,29548,0,0,0,29549,0,0,0,29550,0,0,29552,0,0,0,0,29558,29561,0,29562,29564,0,0,
-29565,0,0,29566,0,0,0,0,0,0,0,0,0,0,29578,29584,29586,29591,0,0,0,0,29593,29594,
-0,0,29597,0,0,29613,0,29614,0,29615,0,0,0,0,29616,29617,0,0,29625,0,0,0,29632,0,
-0,0,0,0,0,0,29633,0,0,0,0,0,29634,29635,29637,0,29638,0,29641,29643,0,0,0,0,0,0,
-29644,0,29645,0,29649,0,0,0,29650,0,29653,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29656,
-29659,0,0,29660,0,0,0,29661,0,0,0,0,0,29664,0,0,0,29671,29673,0,0,0,0,0,0,0,
-29675,0,29677,29679,0,0,29684,0,0,0,0,0,29685,0,0,0,29687,0,0,0,29688,0,29689,
-29690,29700,0,29701,0,0,0,29702,0,29706,0,0,0,0,0,0,0,29720,0,29721,0,29727,0,
-29733,29734,0,29750,29761,0,29763,0,0,0,0,0,29764,0,0,29765,0,0,0,29771,0,0,0,0,
-0,0,0,0,0,0,0,0,29772,0,0,0,29773,29774,29775,0,0,0,0,0,0,0,0,0,0,0,29822,0,0,0,
-29824,0,29825,0,0,0,0,0,29827,0,0,0,0,0,0,0,0,29829,0,29832,29834,0,0,29835,0,0,
-29837,29838,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29843,0,0,0,0,29844,29845,0,0,0,
-0,0,0,0,0,0,29849,0,0,29869,29872,29890,29905,0,0,0,0,0,29907,29921,0,29922,0,0,
-29923,29926,29944,29946,0,0,0,0,0,0,0,29947,29948,0,0,0,29951,0,0,0,0,0,29953,0,
-0,29956,0,29957,0,0,29962,0,0,0,0,29971,0,0,0,29972,0,0,0,0,0,29978,0,29979,
-29992,30007,30008,30010,0,0,0,30013,0,0,0,0,30014,30016,0,0,0,0,0,0,0,0,0,0,0,
-30017,0,0,0,0,0,30023,30031,0,0,30033,0,0,0,0,0,0,0,0,0,0,30034,0,30038,0,30039,
-0,30040,0,0,0,0,0,0,30067,30068,0,0,0,30069,0,30072,0,0,0,30073,0,0,0,0,30075,0,
-0,0,0,0,0,30079,0,0,30080,0,0,0,0,0,30082,0,0,0,0,0,0,0,0,0,0,0,30084,30090,0,0,
-30091,0,0,0,0,30098,30118,0,30119,0,30121,30130,0,0,0,0,0,0,0,0,0,0,0,0,0,30131,
-30132,30133,0,0,0,0,0,0,30135,0,0,0,0,0,0,0,0,0,0,0,30136,0,0,30137,30138,0,0,0,
-30139,30146,0,0,0,0,0,30147,0,0,30148,30151,0,0,0,30168,0,30172,30173,0,0,0,0,0,
-0,0,0,30180,30181,0,30192,0,0,0,0,0,0,0,30194,30196,0,0,30199,0,0,30202,0,0,0,0,
-30203,0,0,0,0,0,0,0,0,0,0,30213,0,0,0,30216,0,0,30217,0,0,0,30218,0,0,0,0,30219,
-0,30220,0,30222,30227,0,0,0,0,0,30231,0,0,30233,30235,0,0,0,0,30238,0,30240,
-30243,30245,0,30250,30252,0,0,0,30269,0,0,30271,30272,0,0,0,30278,30280,0,0,
-30282,0,30284,0,30294,0,0,0,0,30295,30296,0,0,0,0,0,30298,30299,30302,30304,
-30306,0,0,0,0,0,0,30316,30317,0,0,0,30318,0,0,0,30319,0,30320,30322,30326,0,0,0,
-0,0,30327,0,30332,30348,30349,0,0,30356,0,0,0,0,0,0,0,0,30357,0,30358,0,30359,
-30360,0,0,30365,30366,30378,0,0,0,0,30379,0,0,30381,0,30385,0,30388,30397,0,0,0,
-30401,0,0,0,0,30403,0,0,0,0,0,30404,0,0,30405,0,30406,30408,0,30409,0,30410,0,0,
-0,30417,0,0,30418,30419,0,30420,0,30424,0,0,0,30427,30430,30432,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,30433,0,0,0,0,0,0,0,30436,0,30437,30438,0,30441,30442,0,0,
-0,30445,0,0,0,0,30452,30456,30457,0,0,0,30458,0,30464,0,0,0,0,0,0,30467,0,30469,
-0,0,0,0,0,30477,0,0,30484,0,0,0,0,0,30485,0,0,0,0,0,30486,30487,30497,30498,0,0,
-0,0,0,0,0,0,0,0,30505,0,30508,0,0,0,30509,30510,0,30514,30516,0,0,0,0,0,0,0,0,0,
-0,0,30523,0,30524,0,30525,0,0,0,0,30537,0,0,30538,0,0,0,0,0,30553,0,0,30555,
-30556,30558,30559,30560,0,0,30561,0,30562,0,0,0,0,0,0,0,0,30563,30570,30571,0,
-30586,30587,0,0,30590,0,0,30594,0,0,0,0,30611,30612,30623,30634,0,0,30636,30640,
-30655,30656,0,30657,0,0,30658,30669,0,30670,0,30676,30678,0,0,0,0,0,0,0,30679,0,
-0,0,0,0,0,0,0,0,0,0,30695,0,0,30698,0,0,0,0,30700,0,0,0,0,30701,0,30702,30703,0,
-0,0,0,30707,0,0,0,30709,0,0,30710,30719,30729,0,0,0,0,0,0,0,0,0,30731,0,0,30733,
-0,0,0,30734,0,0,0,0,0,30736,30737,0,0,0,30740,0,0,0,30743,0,30746,0,30747,30748,
-0,0,30751,30752,30753,0,0,0,30754,0,0,30760,0,0,0,0,0,0,0,30763,0,30764,0,0,
-30766,0,30769,30770,30771,30774,30777,0,0,30779,30780,30781,0,0,0,0,30790,0,0,0,
-30792,0,0,0,0,30810,0,0,0,0,0,0,0,30812,30819,0,0,30823,30824,0,30825,0,30827,0,
-0,0,0,0,0,30828,0,0,30830,0,0,0,30834,0,30835,0,30837,30838,0,30845,0,0,0,0,0,
-30846,30847,0,0,30849,0,30851,0,0,0,0,0,30852,30858,0,0,30859,0,30865,0,0,30866,
-0,0,30868,0,0,30869,0,0,0,30881,30883,0,0,0,0,0,30889,0,30891,0,0,0,0,30894,0,
-30895,0,30897,0,30898,0,0,0,30904,30906,0,30909,0,0,0,0,0,0,30910,0,0,0,30915,
-30933,30942,0,0,0,0,30943,0,0,30945,0,0,0,0,0,0,30946,0,0,30947,0,0,30955,30956,
-0,0,30960,0,0,30961,30962,30966,0,0,30969,30974,0,0,0,30976,0,0,30977,0,30978,
-30982,0,0,0,0,0,0,0,30994,30995,30998,0,31000,0,0,31001,0,0,31003,31005,0,0,
-31006,31011,0,0,31014,0,31016,0,0,0,0,31018,0,0,31020,31023,31024,31025,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,31027,31028,31029,0,0,0,0,0,0,31032,0,0,0,0,0,0,0,0,0,0,0,
-31036,31037,31038,0,0,0,31041,31043,31045,0,31047,0,0,0,31048,0,31049,0,0,0,
-31053,31054,31055,0,0,31063,0,0,0,0,0,31066,0,31068,31071,0,0,0,31072,31073,0,0,
-0,0,31075,0,0,31076,0,0,0,31077,31079,0,31080,0,0,0,0,0,0,0,0,0,0,31087,0,31142,
-0,31144,0,0,31145,31146,31147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31149,0,31151,31152,0,
-0,0,0,0,0,0,31162,31171,31174,31175,0,0,0,31176,0,0,0,0,0,0,0,31179,0,0,0,31186,
-0,0,0,31192,31195,0,0,31196,0,0,0,0,0,0,0,0,31198,0,0,0,0,0,31199,0,0,0,31205,0,
-0,0,0,31211,31215,0,0,0,0,31231,0,31232,0,0,0,0,0,0,0,0,0,0,31233,31236,31253,0,
-31254,0,0,0,0,0,0,31255,0,0,31257,0,0,0,0,0,0,0,0,0,31258,31259,0,0,31260,0,
-31261,0,0,0,0,0,31262,31263,0,0,31264,0,31266,0,31267,0,0,0,0,0,31281,0,31282,0,
-31284,0,0,31285,31287,31288,0,0,31290,0,0,0,31292,31295,0,31299,0,31300,0,0,0,0,
-0,31302,0,0,0,0,31303,0,0,0,0,0,0,31304,0,0,0,0,0,31305,31308,31309,31315,0,
-31317,0,0,0,0,0,31323,0,31324,0,0,0,0,0,31325,31327,0,0,31331,0,0,0,0,0,31333,0,
-0,0,0,0,31336,0,0,31337,0,0,0,0,0,0,31338,0,0,0,0,0,0,0,0,0,0,0,0,31339,0,0,0,0,
-0,0,0,31342,0,0,0,0,31345,0,0,0,0,0,0,0,0,31347,0,0,0,0,0,0,31348,0,0,31350,
-31351,0,31352,0,0,31354,0,0,0,0,31355,0,0,31356,0,0,0,0,0,0,0,0,0,0,31363,0,
-31372,0,0,31373,0,0,0,0,0,0,0,0,0,31376,0,31388,0,31389,0,31392,0,31401,0,31405,
-31407,31408,0,31409,0,0,0,0,0,0,31413,31415,0,0,0,31416,31418,0,0,0,0,0,0,31422,
-31423,0,0,31424,0,31425,31432,0,0,0,0,0,0,0,0,0,31433,0,0,0,0,0,0,0,0,31434,0,0,
-0,0,0,0,31435,0,0,0,0,31438,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31442,0,31444,0,
-31448,0,0,31451,0,0,0,0,31452,0,31461,31465,0,0,31466,0,0,31467,0,0,31468,0,0,0,
-31469,31473,0,31476,0,0,0,0,31489,31490,0,0,0,0,0,0,0,31492,31493,31494,0,0,0,0,
-31501,31504,31505,0,0,0,0,0,0,0,0,0,31509,0,0,0,0,31510,0,0,31511,0,0,31513,0,0,
-0,0,0,0,0,0,0,31514,0,31522,31536,31539,31540,0,31541,0,0,0,0,0,0,31546,31553,
-31559,0,0,0,31560,31561,31562,0,0,31564,31567,0,31569,0,0,0,31570,0,0,0,0,31571,
-0,0,0,0,0,0,31572,31574,31580,31581,0,0,31582,31584,31585,31586,31595,0,31596,0,
-0,0,0,31597,0,31599,0,31600,31601,0,0,31603,31604,0,0,31608,31610,0,0,0,31611,0,
-31615,0,0,0,0,31616,0,0,0,0,0,0,31617,0,0,0,0,0,31618,0,0,0,0,0,0,31621,0,0,0,0,
-0,0,0,0,0,31622,31625,0,0,0,0,31627,0,31641,0,0,31642,0,0,31643,0,0,0,0,0,0,0,0,
-0,31644,0,31646,0,0,0,0,31648,0,0,0,31652,0,0,0,31657,0,0,31676,0,0,0,0,0,0,0,
-31689,31691,31692,0,31694,0,0,0,31696,0,31702,0,31703,0};
-
-static const DictWord kStaticDictionaryWords[31705] = {
-{0,0,0},{8,0,1002},{136,0,1015},{4,0,683},{4,10,325},{138,10,125},{7,11,572},{9,
-11,592},{11,11,680},{11,11,842},{11,11,924},{12,11,356},{12,11,550},{13,11,317},
-{13,11,370},{13,11,469},{13,11,471},{14,11,397},{18,11,69},{146,11,145},{134,0,
-1265},{136,11,534},{134,0,1431},{11,0,138},{140,0,40},{4,0,155},{7,0,1689},{4,10
-,718},{135,10,1216},{4,0,245},{5,0,151},{5,0,741},{6,0,1147},{7,0,498},{7,0,870}
-,{7,0,1542},{12,0,213},{14,0,36},{14,0,391},{17,0,111},{18,0,6},{18,0,46},{18,0,
-151},{19,0,36},{20,0,32},{20,0,56},{20,0,69},{20,0,102},{21,0,4},{22,0,8},{22,0,
-10},{22,0,14},{150,0,31},{4,0,624},{135,0,1752},{5,10,124},{5,10,144},{6,10,548}
-,{7,10,15},{7,10,153},{137,10,629},{6,0,503},{9,0,586},{13,0,468},{14,0,66},{16,
-0,58},{7,10,1531},{8,10,416},{9,10,275},{10,10,100},{11,10,658},{11,10,979},{12,
-10,86},{14,10,207},{15,10,20},{143,10,25},{5,0,603},{7,0,1212},{9,0,565},{14,0,
-301},{5,10,915},{6,10,1783},{7,10,211},{7,10,1353},{9,10,83},{10,10,376},{10,10,
-431},{11,10,543},{12,10,664},{13,10,280},{13,10,428},{14,10,128},{17,10,52},{145
-,10,81},{4,0,492},{133,0,451},{135,0,835},{141,0,70},{132,0,539},{7,11,748},{139
-,11,700},{7,11,1517},{11,11,597},{14,11,76},{14,11,335},{148,11,33},{6,0,113},{
-135,0,436},{4,10,338},{133,10,400},{136,0,718},{133,11,127},{133,11,418},{6,0,
-1505},{7,0,520},{6,11,198},{11,10,892},{140,11,83},{4,10,221},{5,10,659},{5,10,
-989},{7,10,697},{7,10,1211},{138,10,284},{135,0,1070},{5,11,276},{6,11,55},{135,
-11,1369},{134,0,1515},{6,11,1752},{136,11,726},{138,10,507},{15,0,78},{4,10,188}
-,{135,10,805},{5,10,884},{139,10,991},{133,11,764},{134,10,1653},{6,11,309},{7,
-11,331},{138,11,550},{135,11,1861},{132,11,348},{135,11,986},{135,11,1573},{12,0
-,610},{13,0,431},{144,0,59},{9,11,799},{140,10,166},{134,0,1530},{132,0,750},{
-132,0,307},{133,0,964},{6,11,194},{7,11,133},{10,11,493},{10,11,570},{139,11,664
-},{5,11,24},{5,11,569},{6,11,3},{6,11,119},{6,11,143},{6,11,440},{7,11,295},{7,
-11,599},{7,11,1686},{7,11,1854},{8,11,424},{9,11,43},{9,11,584},{9,11,760},{10,
-11,148},{10,11,328},{11,11,159},{11,11,253},{11,11,506},{12,11,487},{12,11,531},
-{144,11,33},{136,10,760},{5,11,14},{5,11,892},{6,11,283},{7,11,234},{136,11,537}
-,{135,11,1251},{4,11,126},{8,11,635},{147,11,34},{4,11,316},{135,11,1561},{6,0,
-999},{6,0,1310},{137,11,861},{4,11,64},{5,11,352},{5,11,720},{6,11,368},{139,11,
-359},{4,0,75},{5,0,180},{6,0,500},{7,0,58},{7,0,710},{10,0,645},{136,10,770},{
-133,0,649},{6,0,276},{7,0,282},{7,0,879},{7,0,924},{8,0,459},{9,0,599},{9,0,754}
-,{11,0,574},{12,0,128},{12,0,494},{13,0,52},{13,0,301},{15,0,30},{143,0,132},{
-132,0,200},{4,10,89},{5,10,489},{6,10,315},{7,10,553},{7,10,1745},{138,10,243},{
-135,11,1050},{7,0,1621},{6,10,1658},{9,10,3},{10,10,154},{11,10,641},{13,10,85},
-{13,10,201},{141,10,346},{6,11,175},{137,11,289},{5,11,432},{133,11,913},{6,0,
-225},{137,0,211},{7,0,718},{8,0,687},{139,0,374},{4,10,166},{133,10,505},{9,0,
-110},{134,10,1670},{8,0,58},{9,0,724},{11,0,809},{13,0,113},{145,0,72},{6,0,345}
-,{7,0,1247},{144,11,82},{5,11,931},{134,11,1698},{8,0,767},{8,0,803},{9,0,301},{
-137,0,903},{139,0,203},{134,0,1154},{7,0,1949},{136,0,674},{134,0,259},{135,0,
-1275},{5,11,774},{6,11,1637},{6,11,1686},{134,11,1751},{134,0,1231},{7,10,445},{
-8,10,307},{8,10,704},{10,10,41},{10,10,439},{11,10,237},{11,10,622},{140,10,201}
-,{136,0,254},{6,11,260},{135,11,1484},{139,0,277},{135,10,1977},{4,10,189},{5,10
-,713},{6,11,573},{136,10,57},{138,10,371},{132,10,552},{134,11,344},{133,0,248},
-{9,0,800},{10,0,693},{11,0,482},{11,0,734},{11,0,789},{134,11,240},{4,0,116},{5,
-0,95},{5,0,445},{7,0,1688},{8,0,29},{9,0,272},{11,0,509},{11,0,915},{4,11,292},{
-4,11,736},{5,11,871},{6,11,171},{6,11,1689},{7,11,1324},{7,11,1944},{9,11,415},{
-9,11,580},{14,11,230},{146,11,68},{7,0,490},{13,0,100},{143,0,75},{135,0,1641},{
-133,0,543},{7,11,209},{8,11,661},{10,11,42},{11,11,58},{12,11,58},{12,11,118},{
-141,11,32},{5,0,181},{8,0,41},{6,11,63},{135,11,920},{133,0,657},{133,11,793},{
-138,0,709},{7,0,25},{8,0,202},{138,0,536},{5,11,665},{135,10,1788},{145,10,49},{
-9,0,423},{140,0,89},{5,11,67},{6,11,62},{6,11,374},{135,11,1391},{8,0,113},{9,0,
-877},{10,0,554},{11,0,83},{12,0,136},{19,0,109},{9,11,790},{140,11,47},{138,10,
-661},{4,0,963},{10,0,927},{14,0,442},{135,10,1945},{133,0,976},{132,0,206},{4,11
-,391},{135,11,1169},{134,0,2002},{6,0,696},{134,0,1008},{134,0,1170},{132,11,271
-},{7,0,13},{8,0,226},{10,0,537},{11,0,570},{11,0,605},{11,0,799},{11,0,804},{12,
-0,85},{12,0,516},{12,0,623},{13,0,112},{13,0,361},{14,0,77},{14,0,78},{17,0,28},
-{19,0,110},{140,11,314},{132,0,769},{134,0,1544},{4,0,551},{137,0,678},{5,10,84}
-,{134,10,163},{9,0,57},{9,0,459},{10,0,425},{11,0,119},{12,0,184},{12,0,371},{13
-,0,358},{145,0,51},{5,0,188},{5,0,814},{8,0,10},{9,0,421},{9,0,729},{10,0,609},{
-11,0,689},{4,11,253},{5,10,410},{5,11,544},{7,11,300},{137,11,340},{134,0,624},{
-138,11,321},{135,0,1941},{18,0,130},{5,10,322},{8,10,186},{9,10,262},{10,10,187}
-,{142,10,208},{5,11,53},{5,11,541},{6,11,94},{6,11,499},{7,11,230},{139,11,321},
-{133,10,227},{4,0,378},{4,11,920},{5,11,25},{5,11,790},{6,11,457},{135,11,853},{
-137,0,269},{132,0,528},{134,0,1146},{7,10,1395},{8,10,486},{9,10,236},{9,10,878}
-,{10,10,218},{11,10,95},{19,10,17},{147,10,31},{7,10,2043},{8,10,672},{141,10,
-448},{134,0,1105},{134,0,1616},{134,11,1765},{140,11,163},{5,10,412},{133,11,822
-},{132,11,634},{6,0,656},{134,11,1730},{134,0,1940},{5,0,104},{6,0,173},{135,0,
-1631},{136,10,562},{6,11,36},{7,11,658},{8,11,454},{147,11,86},{5,0,457},{134,10
-,1771},{7,0,810},{8,0,138},{8,0,342},{9,0,84},{10,0,193},{11,0,883},{140,0,359},
-{9,0,620},{135,10,1190},{137,10,132},{7,11,975},{137,11,789},{6,0,95},{6,0,1934}
-,{136,0,967},{141,11,335},{6,0,406},{10,0,409},{10,0,447},{11,0,44},{140,0,100},
-{4,10,317},{135,10,1279},{132,0,477},{134,0,1268},{6,0,1941},{8,0,944},{5,10,63}
-,{133,10,509},{132,0,629},{132,11,104},{4,0,246},{133,0,375},{6,0,1636},{132,10,
-288},{135,11,1614},{9,0,49},{10,0,774},{8,10,89},{8,10,620},{11,10,628},{12,10,
-322},{143,10,124},{4,0,282},{7,0,1034},{11,0,398},{11,0,634},{12,0,1},{12,0,79},
-{12,0,544},{14,0,237},{17,0,10},{146,0,20},{132,0,824},{7,11,45},{9,11,542},{9,
-11,566},{138,11,728},{5,0,118},{5,0,499},{6,0,476},{6,0,665},{6,0,1176},{6,0,
-1196},{7,0,600},{7,0,888},{135,0,1096},{7,0,296},{7,0,596},{8,0,560},{8,0,586},{
-9,0,612},{11,0,304},{12,0,46},{13,0,89},{14,0,112},{145,0,122},{5,0,894},{6,0,
-1772},{9,0,1009},{138,10,120},{5,11,533},{7,11,755},{138,11,780},{151,10,1},{6,0
-,1474},{7,11,87},{142,11,288},{139,0,366},{137,10,461},{7,11,988},{7,11,1939},{9
-,11,64},{9,11,502},{12,11,7},{12,11,34},{13,11,12},{13,11,234},{147,11,77},{7,0,
-1599},{7,0,1723},{8,0,79},{8,0,106},{8,0,190},{8,0,302},{8,0,383},{8,0,713},{9,0
-,119},{9,0,233},{9,0,419},{9,0,471},{10,0,181},{10,0,406},{11,0,57},{11,0,85},{
-11,0,120},{11,0,177},{11,0,296},{11,0,382},{11,0,454},{11,0,758},{11,0,999},{12,
-0,27},{12,0,98},{12,0,131},{12,0,245},{12,0,312},{12,0,446},{12,0,454},{13,0,25}
-,{13,0,98},{13,0,426},{13,0,508},{14,0,70},{14,0,163},{14,0,272},{14,0,277},{14,
-0,370},{15,0,95},{15,0,138},{15,0,167},{17,0,38},{148,0,96},{135,10,1346},{10,0,
-200},{19,0,2},{151,0,22},{135,11,141},{134,10,85},{134,0,1759},{138,0,372},{145,
-0,16},{8,0,943},{132,11,619},{139,11,88},{5,11,246},{8,11,189},{9,11,355},{9,11,
-512},{10,11,124},{10,11,453},{11,11,143},{11,11,416},{11,11,859},{141,11,341},{5
-,0,258},{134,0,719},{6,0,1798},{6,0,1839},{8,0,900},{10,0,874},{10,0,886},{12,0,
-698},{12,0,732},{12,0,770},{16,0,106},{18,0,163},{18,0,170},{18,0,171},{152,0,20
-},{9,0,707},{11,0,326},{11,0,339},{12,0,423},{12,0,502},{20,0,62},{9,11,707},{11
-,11,326},{11,11,339},{12,11,423},{12,11,502},{148,11,62},{5,0,30},{7,0,495},{8,0
-,134},{9,0,788},{140,0,438},{133,11,678},{5,10,279},{6,10,235},{7,10,468},{8,10,
-446},{9,10,637},{10,10,717},{11,10,738},{140,10,514},{5,11,35},{6,11,287},{7,11,
-862},{7,11,1886},{138,11,179},{7,0,1948},{7,0,2004},{132,11,517},{5,10,17},{6,10
-,371},{137,10,528},{4,0,115},{5,0,669},{6,0,407},{8,0,311},{11,0,10},{141,0,5},{
-137,0,381},{5,0,50},{6,0,439},{7,0,780},{135,0,1040},{136,11,667},{11,11,403},{
-146,11,83},{5,0,1},{6,0,81},{138,0,520},{134,0,738},{5,0,482},{8,0,98},{9,0,172}
-,{10,0,360},{10,0,700},{10,0,822},{11,0,302},{11,0,778},{12,0,50},{12,0,127},{12
-,0,396},{13,0,62},{13,0,328},{14,0,122},{147,0,72},{9,11,157},{10,11,131},{140,
-11,72},{135,11,714},{135,11,539},{5,0,2},{6,0,512},{7,0,797},{7,0,1494},{8,0,253
-},{8,0,589},{9,0,77},{10,0,1},{10,0,129},{10,0,225},{11,0,118},{11,0,226},{11,0,
-251},{11,0,430},{11,0,701},{11,0,974},{11,0,982},{12,0,64},{12,0,260},{12,0,488}
-,{140,0,690},{5,11,394},{7,11,367},{7,11,487},{7,11,857},{7,11,1713},{8,11,246},
-{9,11,537},{10,11,165},{12,11,219},{140,11,561},{136,0,557},{5,10,779},{5,10,807
-},{6,10,1655},{134,10,1676},{4,10,196},{5,10,558},{133,10,949},{11,11,827},{12,
-11,56},{14,11,34},{143,11,148},{137,0,347},{133,0,572},{134,0,832},{4,0,12},{7,0
-,504},{7,0,522},{7,0,809},{8,0,797},{141,0,88},{4,10,752},{133,11,449},{7,11,86}
-,{8,11,103},{145,11,69},{7,11,2028},{138,11,641},{5,0,528},{6,11,1},{142,11,2},{
-134,0,861},{10,0,294},{4,10,227},{5,10,159},{5,10,409},{7,10,80},{10,10,479},{12
-,10,418},{14,10,50},{14,10,249},{142,10,295},{7,10,1470},{8,10,66},{8,10,137},{8
-,10,761},{9,10,638},{11,10,80},{11,10,212},{11,10,368},{11,10,418},{12,10,8},{13
-,10,15},{16,10,61},{17,10,59},{19,10,28},{148,10,84},{20,0,109},{135,11,1148},{6
-,11,277},{7,11,1274},{7,11,1386},{7,11,1392},{12,11,129},{146,11,87},{6,11,187},
-{7,11,39},{7,11,1203},{8,11,380},{8,11,542},{14,11,117},{149,11,28},{134,0,1187}
-,{5,0,266},{9,0,290},{9,0,364},{10,0,293},{11,0,606},{142,0,45},{6,11,297},{7,11
-,793},{139,11,938},{4,0,50},{6,0,594},{9,0,121},{10,0,49},{10,0,412},{139,0,834}
-,{136,0,748},{7,11,464},{8,11,438},{11,11,105},{11,11,363},{12,11,231},{14,11,
-386},{15,11,102},{148,11,75},{132,0,466},{13,0,399},{14,0,337},{6,10,38},{7,10,
-1220},{8,10,185},{8,10,256},{9,10,22},{9,10,331},{10,10,738},{11,10,205},{11,10,
-540},{11,10,746},{13,10,465},{142,10,194},{9,0,378},{141,0,162},{137,0,519},{4,
-10,159},{6,10,115},{7,10,252},{7,10,257},{7,10,1928},{8,10,69},{9,10,384},{10,10
-,91},{10,10,615},{12,10,375},{14,10,235},{18,10,117},{147,10,123},{5,11,604},{5,
-10,911},{136,10,278},{132,0,667},{8,0,351},{9,0,322},{4,10,151},{135,10,1567},{
-134,0,902},{133,10,990},{12,0,180},{5,10,194},{7,10,1662},{137,10,90},{4,0,869},
-{134,0,1996},{134,0,813},{133,10,425},{137,11,761},{132,0,260},{133,10,971},{5,
-11,20},{6,11,298},{7,11,659},{7,11,1366},{137,11,219},{4,0,39},{5,0,36},{7,0,
-1843},{8,0,407},{11,0,144},{140,0,523},{4,0,510},{10,0,587},{139,10,752},{7,0,29
-},{7,0,66},{7,0,1980},{10,0,487},{138,0,809},{13,0,260},{14,0,82},{18,0,63},{137
-,10,662},{5,10,72},{6,10,264},{7,10,21},{7,10,46},{7,10,2013},{8,10,215},{8,10,
-513},{10,10,266},{139,10,22},{134,0,570},{6,0,565},{7,0,1667},{4,11,439},{10,10,
-95},{11,10,603},{12,11,242},{13,10,443},{14,10,160},{143,10,4},{134,0,1464},{134
-,10,431},{9,0,372},{15,0,2},{19,0,10},{19,0,18},{5,10,874},{6,10,1677},{143,10,0
-},{132,0,787},{6,0,380},{12,0,399},{21,0,19},{7,10,939},{7,10,1172},{7,10,1671},
-{9,10,540},{10,10,696},{11,10,265},{11,10,732},{11,10,928},{11,10,937},{141,10,
-438},{137,0,200},{132,11,233},{132,0,516},{134,11,577},{132,0,844},{11,0,887},{
-14,0,365},{142,0,375},{132,11,482},{8,0,821},{140,0,44},{7,0,1655},{136,0,305},{
-5,10,682},{135,10,1887},{135,11,346},{132,10,696},{4,0,10},{7,0,917},{139,0,786}
-,{5,11,795},{6,11,1741},{8,11,417},{137,11,782},{4,0,1016},{134,0,2031},{5,0,684
-},{4,10,726},{133,10,630},{6,0,1021},{134,0,1480},{8,10,802},{136,10,838},{134,0
-,27},{134,0,395},{135,11,622},{7,11,625},{135,11,1750},{4,11,203},{135,11,1936},
-{6,10,118},{7,10,215},{7,10,1521},{140,10,11},{132,0,813},{136,0,511},{7,10,615}
-,{138,10,251},{135,10,1044},{145,0,56},{133,10,225},{6,0,342},{6,0,496},{8,0,275
-},{137,0,206},{4,0,909},{133,0,940},{132,0,891},{7,11,311},{9,11,308},{140,11,
-255},{4,10,370},{5,10,756},{135,10,1326},{4,0,687},{134,0,1596},{134,0,1342},{6,
-10,1662},{7,10,48},{8,10,771},{10,10,116},{13,10,104},{14,10,105},{14,10,184},{
-15,10,168},{19,10,92},{148,10,68},{138,10,209},{4,11,400},{5,11,267},{135,11,232
-},{151,11,12},{6,0,41},{141,0,160},{141,11,314},{134,0,1718},{136,0,778},{142,11
-,261},{134,0,1610},{133,0,115},{132,0,294},{14,0,314},{132,10,120},{132,0,983},{
-5,0,193},{140,0,178},{138,10,429},{5,10,820},{135,10,931},{6,0,994},{6,0,1051},{
-6,0,1439},{7,0,174},{133,11,732},{4,11,100},{7,11,679},{8,11,313},{138,10,199},{
-6,10,151},{6,10,1675},{7,10,383},{151,10,10},{6,0,1796},{8,0,848},{8,0,867},{8,0
-,907},{10,0,855},{140,0,703},{140,0,221},{4,0,122},{5,0,796},{5,0,952},{6,0,1660
-},{6,0,1671},{8,0,567},{9,0,687},{9,0,742},{10,0,686},{11,0,682},{11,0,909},{140
-,0,281},{5,11,362},{5,11,443},{6,11,318},{7,11,1019},{139,11,623},{5,11,463},{
-136,11,296},{11,0,583},{13,0,262},{6,10,1624},{12,10,422},{142,10,360},{5,0,179}
-,{7,0,1095},{135,0,1213},{4,10,43},{4,11,454},{5,10,344},{133,10,357},{4,0,66},{
-7,0,722},{135,0,904},{134,0,773},{7,0,352},{133,10,888},{5,11,48},{5,11,404},{6,
-11,557},{7,11,458},{8,11,597},{10,11,455},{10,11,606},{11,11,49},{11,11,548},{12
-,11,476},{13,11,18},{141,11,450},{134,11,418},{132,10,711},{5,11,442},{135,11,
-1984},{141,0,35},{137,0,152},{134,0,1197},{135,11,1093},{137,11,203},{137,10,440
-},{10,0,592},{10,0,753},{12,0,317},{12,0,355},{12,0,465},{12,0,469},{12,0,560},{
-12,0,578},{141,0,243},{133,0,564},{134,0,797},{5,10,958},{133,10,987},{5,11,55},
-{7,11,376},{140,11,161},{133,11,450},{134,0,556},{134,0,819},{11,10,276},{142,10
-,293},{7,0,544},{138,0,61},{8,0,719},{4,10,65},{5,10,479},{5,10,1004},{7,10,1913
-},{8,10,317},{9,10,302},{10,10,612},{141,10,22},{4,0,5},{5,0,498},{8,0,637},{9,0
-,521},{4,11,213},{4,10,261},{7,11,223},{7,10,510},{136,11,80},{5,0,927},{7,0,101
-},{4,10,291},{7,11,381},{7,11,806},{7,11,820},{8,11,354},{8,11,437},{8,11,787},{
-9,10,515},{9,11,657},{10,11,58},{10,11,339},{10,11,749},{11,11,914},{12,10,152},
-{12,11,162},{12,10,443},{13,11,75},{13,10,392},{14,11,106},{14,11,198},{14,11,
-320},{14,10,357},{14,11,413},{146,11,43},{6,0,1153},{7,0,1441},{136,11,747},{4,0
-,893},{5,0,780},{133,0,893},{138,11,654},{133,11,692},{133,0,238},{134,11,191},{
-4,10,130},{135,10,843},{6,0,1296},{5,10,42},{5,10,879},{7,10,245},{7,10,324},{7,
-10,1532},{11,10,463},{11,10,472},{13,10,363},{144,10,52},{134,0,1729},{6,0,1999}
-,{136,0,969},{4,10,134},{133,10,372},{4,0,60},{7,0,941},{7,0,1800},{8,0,314},{9,
-0,700},{139,0,487},{134,0,1144},{6,11,162},{7,11,1960},{136,11,831},{132,11,706}
-,{135,0,1147},{138,11,426},{138,11,89},{7,0,1853},{138,0,437},{136,0,419},{135,
-10,1634},{133,0,828},{5,0,806},{7,0,176},{7,0,178},{7,0,1240},{7,0,1976},{132,10
-,644},{135,11,1877},{5,11,420},{135,11,1449},{4,0,51},{5,0,39},{6,0,4},{7,0,591}
-,{7,0,849},{7,0,951},{7,0,1613},{7,0,1760},{7,0,1988},{9,0,434},{10,0,754},{11,0
-,25},{139,0,37},{10,11,57},{138,11,277},{135,10,540},{132,11,204},{135,0,159},{
-139,11,231},{133,0,902},{7,0,928},{7,11,366},{9,11,287},{12,11,199},{12,11,556},
-{140,11,577},{6,10,623},{136,10,789},{4,10,908},{5,10,359},{5,10,508},{6,10,1723
-},{7,10,343},{7,10,1996},{135,10,2026},{134,0,270},{4,10,341},{135,10,480},{5,11
-,356},{135,11,224},{11,11,588},{11,11,864},{11,11,968},{143,11,160},{132,0,556},
-{137,0,801},{132,0,416},{142,0,372},{5,0,152},{5,0,197},{7,0,340},{7,0,867},{10,
-0,548},{10,0,581},{11,0,6},{12,0,3},{12,0,19},{14,0,110},{142,0,289},{139,0,369}
-,{7,11,630},{9,11,567},{11,11,150},{11,11,444},{141,11,119},{134,11,539},{7,10,
-1995},{8,10,299},{11,10,890},{140,10,674},{7,0,34},{7,0,190},{8,0,28},{8,0,141},
-{8,0,444},{8,0,811},{9,0,468},{11,0,334},{12,0,24},{12,0,386},{140,0,576},{133,0
-,757},{7,0,1553},{136,0,898},{133,0,721},{136,0,1012},{4,0,789},{5,0,647},{135,0
-,1102},{132,0,898},{10,0,183},{4,10,238},{5,10,503},{6,10,179},{7,10,2003},{8,10
-,381},{8,10,473},{9,10,149},{10,10,788},{15,10,45},{15,10,86},{20,10,110},{150,
-10,57},{9,0,136},{19,0,107},{4,10,121},{5,10,156},{5,10,349},{10,10,605},{142,10
-,342},{4,11,235},{135,11,255},{4,11,194},{5,11,584},{6,11,384},{7,11,583},{10,11
-,761},{11,11,760},{139,11,851},{6,10,80},{6,10,1694},{7,10,173},{7,10,1974},{9,
-10,547},{10,10,730},{14,10,18},{150,10,39},{4,10,923},{134,10,1711},{5,0,277},{
-141,0,247},{132,0,435},{133,11,562},{134,0,1311},{5,11,191},{137,11,271},{132,10
-,595},{7,11,1537},{14,11,96},{143,11,73},{5,0,437},{7,0,502},{7,0,519},{7,0,1122
-},{7,0,1751},{14,0,211},{6,10,459},{7,10,1753},{7,10,1805},{8,10,658},{9,10,1},{
-11,10,959},{141,10,446},{6,0,814},{4,11,470},{5,11,473},{6,11,153},{7,11,1503},{
-7,11,1923},{10,11,701},{11,11,132},{11,11,168},{11,11,227},{11,11,320},{11,11,
-436},{11,11,525},{11,11,855},{12,11,41},{12,11,286},{13,11,103},{13,11,284},{14,
-11,255},{14,11,262},{15,11,117},{143,11,127},{5,0,265},{6,0,212},{135,0,28},{138
-,0,750},{133,11,327},{6,11,552},{7,11,1754},{137,11,604},{134,0,2012},{132,0,702
-},{5,11,80},{6,11,405},{7,11,403},{7,11,1502},{7,11,1626},{8,11,456},{9,11,487},
-{9,11,853},{9,11,889},{10,11,309},{11,11,721},{11,11,994},{12,11,430},{141,11,
-165},{5,0,808},{135,0,2045},{5,0,166},{8,0,739},{140,0,511},{134,10,490},{4,11,
-453},{5,11,887},{6,11,535},{8,11,6},{136,11,543},{4,0,119},{5,0,170},{5,0,447},{
-7,0,1708},{7,0,1889},{9,0,357},{9,0,719},{12,0,486},{140,0,596},{137,0,500},{7,
-10,250},{136,10,507},{132,10,158},{6,0,809},{134,0,1500},{9,0,327},{11,0,350},{
-11,0,831},{13,0,352},{4,10,140},{7,10,362},{8,10,209},{9,10,10},{9,10,503},{9,10
-,614},{10,10,689},{11,10,327},{11,10,725},{12,10,252},{12,10,583},{13,10,192},{
-14,10,269},{14,10,356},{148,10,50},{135,11,741},{4,0,450},{7,0,1158},{19,10,1},{
-19,10,26},{150,10,9},{6,0,597},{135,0,1318},{134,0,1602},{6,10,228},{7,10,1341},
-{9,10,408},{138,10,343},{7,0,1375},{7,0,1466},{138,0,331},{132,0,754},{132,10,
-557},{5,11,101},{6,11,88},{6,11,543},{7,11,1677},{9,11,100},{10,11,677},{14,11,
-169},{14,11,302},{14,11,313},{15,11,48},{143,11,84},{134,0,1368},{4,11,310},{9,
-11,795},{10,11,733},{11,11,451},{12,11,249},{14,11,115},{14,11,286},{143,11,100}
-,{132,10,548},{10,0,557},{7,10,197},{8,10,142},{8,10,325},{9,10,150},{9,10,596},
-{10,10,353},{11,10,74},{11,10,315},{12,10,662},{12,10,681},{14,10,423},{143,10,
-141},{133,11,587},{5,0,850},{136,0,799},{10,0,908},{12,0,701},{12,0,757},{142,0,
-466},{4,0,62},{5,0,275},{18,0,19},{6,10,399},{6,10,579},{7,10,692},{7,10,846},{7
-,10,1015},{7,10,1799},{8,10,403},{9,10,394},{10,10,133},{12,10,4},{12,10,297},{
-12,10,452},{16,10,81},{18,10,25},{21,10,14},{22,10,12},{151,10,18},{12,0,459},{7
-,10,1546},{11,10,299},{142,10,407},{132,10,177},{132,11,498},{7,11,217},{8,11,
-140},{138,11,610},{5,10,411},{135,10,653},{134,0,1802},{7,10,439},{10,10,727},{
-11,10,260},{139,10,684},{133,11,905},{11,11,580},{142,11,201},{134,0,1397},{5,10
-,208},{7,10,753},{135,10,1528},{7,0,238},{7,0,2033},{8,0,120},{8,0,188},{8,0,659
-},{9,0,598},{10,0,466},{12,0,342},{12,0,588},{13,0,503},{14,0,246},{143,0,92},{
-135,11,1041},{4,11,456},{7,11,105},{7,11,358},{7,11,1637},{8,11,643},{139,11,483
-},{6,0,1318},{134,0,1324},{4,0,201},{7,0,1744},{8,0,602},{11,0,247},{11,0,826},{
-17,0,65},{133,10,242},{8,0,164},{146,0,62},{133,10,953},{139,10,802},{133,0,615}
-,{7,11,1566},{8,11,269},{9,11,212},{9,11,718},{14,11,15},{14,11,132},{142,11,227
-},{133,10,290},{132,10,380},{5,10,52},{7,10,277},{9,10,368},{139,10,791},{135,0,
-1243},{133,11,539},{11,11,919},{141,11,409},{136,0,968},{133,11,470},{134,0,882}
-,{132,0,907},{5,0,100},{10,0,329},{12,0,416},{149,0,29},{10,10,138},{139,10,476}
-,{5,10,725},{5,10,727},{6,11,91},{7,11,435},{135,10,1811},{4,11,16},{5,11,316},{
-5,11,842},{6,11,370},{6,11,1778},{8,11,166},{11,11,812},{12,11,206},{12,11,351},
-{14,11,418},{16,11,15},{16,11,34},{18,11,3},{19,11,3},{19,11,7},{20,11,4},{149,
-11,21},{132,0,176},{5,0,636},{5,0,998},{7,0,9},{7,0,1508},{8,0,26},{9,0,317},{9,
-0,358},{10,0,210},{10,0,292},{10,0,533},{11,0,555},{12,0,526},{12,0,607},{13,0,
-263},{13,0,459},{142,0,271},{6,0,256},{8,0,265},{4,10,38},{7,10,307},{7,10,999},
-{7,10,1481},{7,10,1732},{7,10,1738},{9,10,414},{11,10,316},{12,10,52},{13,10,420
-},{147,10,100},{135,10,1296},{4,11,611},{133,11,606},{4,0,643},{142,11,21},{133,
-11,715},{133,10,723},{6,0,610},{135,11,597},{10,0,127},{141,0,27},{6,0,1995},{6,
-0,2001},{8,0,119},{136,0,973},{4,11,149},{138,11,368},{12,0,522},{4,11,154},{5,
-10,109},{6,10,1784},{7,11,1134},{7,10,1895},{8,11,105},{12,10,296},{140,10,302},
-{4,11,31},{6,11,429},{7,11,962},{9,11,458},{139,11,691},{10,0,553},{11,0,876},{
-13,0,193},{13,0,423},{14,0,166},{19,0,84},{4,11,312},{5,10,216},{7,10,1879},{9,
-10,141},{9,10,270},{9,10,679},{10,10,159},{11,10,197},{12,10,538},{12,10,559},{
-14,10,144},{14,10,167},{143,10,67},{134,0,1582},{7,0,1578},{135,11,1578},{137,10
-,81},{132,11,236},{134,10,391},{134,0,795},{7,10,322},{136,10,249},{5,11,836},{5
-,11,857},{6,11,1680},{7,11,59},{147,11,53},{135,0,432},{10,11,68},{139,11,494},{
-4,11,81},{139,11,867},{7,0,126},{136,0,84},{142,11,280},{5,11,282},{8,11,650},{9
-,11,295},{9,11,907},{138,11,443},{136,0,790},{5,10,632},{138,10,526},{6,0,64},{
-12,0,377},{13,0,309},{14,0,141},{14,0,429},{14,11,141},{142,11,429},{134,0,1529}
-,{6,0,321},{7,0,1857},{9,0,530},{19,0,99},{7,10,948},{7,10,1042},{8,10,235},{8,
-10,461},{9,10,453},{10,10,354},{145,10,77},{7,0,1104},{11,0,269},{11,0,539},{11,
-0,627},{11,0,706},{11,0,975},{12,0,248},{12,0,434},{12,0,600},{12,0,622},{13,0,
-297},{13,0,485},{14,0,69},{14,0,409},{143,0,108},{4,10,362},{7,10,52},{7,10,303}
-,{10,11,70},{12,11,26},{14,11,17},{14,11,178},{15,11,34},{149,11,12},{11,0,977},
-{141,0,507},{9,0,34},{139,0,484},{5,10,196},{6,10,486},{7,10,212},{8,10,309},{
-136,10,346},{6,0,1700},{7,0,26},{7,0,293},{7,0,382},{7,0,1026},{7,0,1087},{7,0,
-2027},{8,0,24},{8,0,114},{8,0,252},{8,0,727},{8,0,729},{9,0,30},{9,0,199},{9,0,
-231},{9,0,251},{9,0,334},{9,0,361},{9,0,712},{10,0,55},{10,0,60},{10,0,232},{10,
-0,332},{10,0,384},{10,0,396},{10,0,504},{10,0,542},{10,0,652},{11,0,20},{11,0,48
-},{11,0,207},{11,0,291},{11,0,298},{11,0,342},{11,0,365},{11,0,394},{11,0,620},{
-11,0,705},{11,0,1017},{12,0,123},{12,0,340},{12,0,406},{12,0,643},{13,0,61},{13,
-0,269},{13,0,311},{13,0,319},{13,0,486},{14,0,234},{15,0,62},{15,0,85},{16,0,71}
-,{18,0,119},{20,0,105},{135,10,1912},{4,11,71},{5,11,376},{7,11,119},{138,11,665
-},{10,0,918},{10,0,926},{4,10,686},{136,11,55},{138,10,625},{136,10,706},{132,11
-,479},{4,10,30},{133,10,43},{6,0,379},{7,0,270},{8,0,176},{8,0,183},{9,0,432},{9
-,0,661},{12,0,247},{12,0,617},{18,0,125},{7,11,607},{8,11,99},{152,11,4},{5,0,
-792},{133,0,900},{4,11,612},{133,11,561},{4,11,41},{4,10,220},{5,11,74},{7,10,
-1535},{7,11,1627},{11,11,871},{140,11,619},{135,0,1920},{7,11,94},{11,11,329},{
-11,11,965},{12,11,241},{14,11,354},{15,11,22},{148,11,63},{9,11,209},{137,11,300
-},{134,0,771},{135,0,1979},{4,0,901},{133,0,776},{142,0,254},{133,11,98},{9,11,
-16},{141,11,386},{133,11,984},{4,11,182},{6,11,205},{135,11,220},{7,10,1725},{7,
-10,1774},{138,10,393},{5,10,263},{134,10,414},{4,11,42},{9,11,205},{9,11,786},{
-138,11,659},{14,0,140},{148,0,41},{8,0,440},{10,0,359},{6,10,178},{6,11,289},{6,
-10,1750},{7,11,1670},{9,10,690},{10,10,155},{10,10,373},{11,10,698},{12,11,57},{
-13,10,155},{20,10,93},{151,11,4},{4,0,37},{5,0,334},{7,0,1253},{151,11,25},{4,0,
-508},{4,11,635},{5,10,97},{137,10,393},{139,11,533},{4,0,640},{133,0,513},{134,
-10,1639},{132,11,371},{4,11,272},{7,11,836},{7,11,1651},{145,11,89},{5,11,825},{
-6,11,444},{6,11,1640},{136,11,308},{4,10,191},{7,10,934},{8,10,647},{145,10,97},
-{12,0,246},{15,0,162},{19,0,64},{20,0,8},{20,0,95},{22,0,24},{152,0,17},{4,0,533
-},{5,10,165},{9,10,346},{138,10,655},{5,11,737},{139,10,885},{133,10,877},{8,10,
-128},{139,10,179},{137,11,307},{140,0,752},{133,0,920},{135,0,1048},{5,0,153},{6
-,0,580},{6,10,1663},{7,10,132},{7,10,1154},{7,10,1415},{7,10,1507},{12,10,493},{
-15,10,105},{151,10,15},{5,10,459},{7,10,1073},{8,10,241},{136,10,334},{138,0,391
-},{135,0,1952},{133,11,525},{8,11,641},{11,11,388},{140,11,580},{142,0,126},{134
-,0,640},{132,0,483},{7,0,1616},{9,0,69},{6,10,324},{6,10,520},{7,10,338},{7,10,
-1729},{8,10,228},{139,10,750},{5,11,493},{134,11,528},{135,0,734},{4,11,174},{
-135,11,911},{138,0,480},{9,0,495},{146,0,104},{135,10,705},{9,0,472},{4,10,73},{
-6,10,612},{7,10,927},{7,10,1330},{7,10,1822},{8,10,217},{9,10,765},{9,10,766},{
-10,10,408},{11,10,51},{11,10,793},{12,10,266},{15,10,158},{20,10,89},{150,10,32}
-,{7,11,548},{137,11,58},{4,11,32},{5,11,215},{6,11,269},{7,11,1782},{7,11,1892},
-{10,11,16},{11,11,822},{11,11,954},{141,11,481},{132,0,874},{9,0,229},{5,10,389}
-,{136,10,636},{7,11,1749},{136,11,477},{134,0,948},{5,11,308},{135,11,1088},{4,0
-,748},{139,0,1009},{136,10,21},{6,0,555},{135,0,485},{5,11,126},{8,11,297},{9,11
-,366},{9,11,445},{12,11,53},{12,11,374},{141,11,492},{7,11,1551},{139,11,361},{
-136,0,193},{136,0,472},{8,0,653},{13,0,93},{147,0,14},{132,0,984},{132,11,175},{
-5,0,172},{6,0,1971},{132,11,685},{149,11,8},{133,11,797},{13,0,83},{5,10,189},{7
-,10,442},{7,10,443},{8,10,281},{12,10,174},{141,10,261},{134,0,1568},{133,11,565
-},{139,0,384},{133,0,260},{7,0,758},{7,0,880},{7,0,1359},{9,0,164},{9,0,167},{10
-,0,156},{10,0,588},{12,0,101},{14,0,48},{15,0,70},{6,10,2},{7,10,1262},{7,10,
-1737},{8,10,22},{8,10,270},{8,10,612},{9,10,312},{9,10,436},{10,10,311},{10,10,
-623},{11,10,72},{11,10,330},{11,10,455},{12,10,321},{12,10,504},{12,10,530},{12,
-10,543},{13,10,17},{13,10,156},{13,10,334},{17,10,60},{148,10,64},{4,11,252},{7,
-11,1068},{10,11,434},{11,11,228},{11,11,426},{13,11,231},{18,11,106},{148,11,87}
-,{7,10,354},{10,10,410},{139,10,815},{6,0,367},{7,10,670},{7,10,1327},{8,10,411}
-,{8,10,435},{9,10,653},{9,10,740},{10,10,385},{11,10,222},{11,10,324},{11,10,829
-},{140,10,611},{7,0,1174},{6,10,166},{135,10,374},{146,0,121},{132,0,828},{5,11,
-231},{138,11,509},{7,11,601},{9,11,277},{9,11,674},{10,11,178},{10,11,257},{10,
-11,418},{11,11,531},{11,11,544},{11,11,585},{12,11,113},{12,11,475},{13,11,99},{
-142,11,428},{134,0,1541},{135,11,1779},{5,0,343},{134,10,398},{135,10,50},{135,
-11,1683},{4,0,440},{7,0,57},{8,0,167},{8,0,375},{9,0,82},{9,0,561},{9,0,744},{10
-,0,620},{137,11,744},{134,0,926},{6,10,517},{7,10,1159},{10,10,621},{139,10,192}
-,{137,0,827},{8,0,194},{136,0,756},{10,10,223},{139,10,645},{7,10,64},{136,10,
-245},{4,11,399},{5,11,119},{5,11,494},{7,11,751},{137,11,556},{132,0,808},{135,0
-,22},{7,10,1763},{140,10,310},{5,0,639},{7,0,1249},{11,0,896},{134,11,584},{134,
-0,1614},{135,0,860},{135,11,1121},{5,10,129},{6,10,61},{135,10,947},{4,0,102},{7
-,0,815},{7,0,1699},{139,0,964},{13,10,505},{141,10,506},{139,10,1000},{132,11,
-679},{132,0,899},{132,0,569},{5,11,694},{137,11,714},{136,0,795},{6,0,2045},{139
-,11,7},{6,0,52},{9,0,104},{9,0,559},{12,0,308},{147,0,87},{4,0,301},{132,0,604},
-{133,10,637},{136,0,779},{5,11,143},{5,11,769},{6,11,1760},{7,11,682},{7,11,1992
-},{136,11,736},{137,10,590},{147,0,32},{137,11,527},{5,10,280},{135,10,1226},{
-134,0,494},{6,0,677},{6,0,682},{134,0,1044},{133,10,281},{135,10,1064},{7,0,508}
-,{133,11,860},{6,11,422},{7,11,0},{7,11,1544},{9,11,577},{11,11,990},{12,11,141}
-,{12,11,453},{13,11,47},{141,11,266},{134,0,1014},{5,11,515},{137,11,131},{134,0
-,957},{132,11,646},{6,0,310},{7,0,1849},{8,0,72},{8,0,272},{8,0,431},{9,0,12},{9
-,0,376},{10,0,563},{10,0,630},{10,0,796},{10,0,810},{11,0,367},{11,0,599},{11,0,
-686},{140,0,672},{7,0,570},{4,11,396},{7,10,120},{7,11,728},{8,10,489},{9,11,117
-},{9,10,319},{10,10,820},{11,10,1004},{12,10,379},{12,10,679},{13,10,117},{13,11
-,202},{13,10,412},{14,10,25},{15,10,52},{15,10,161},{16,10,47},{20,11,51},{149,
-10,2},{6,11,121},{6,11,124},{6,11,357},{7,11,1138},{7,11,1295},{8,11,162},{139,
-11,655},{8,0,449},{4,10,937},{5,10,801},{136,11,449},{139,11,958},{6,0,181},{7,0
-,537},{8,0,64},{9,0,127},{10,0,496},{12,0,510},{141,0,384},{138,11,253},{4,0,244
-},{135,0,233},{133,11,237},{132,10,365},{6,0,1650},{10,0,702},{139,0,245},{5,10,
-7},{139,10,774},{13,0,463},{20,0,49},{13,11,463},{148,11,49},{4,10,734},{5,10,
-662},{134,10,430},{4,10,746},{135,10,1090},{5,10,360},{136,10,237},{137,0,338},{
-143,11,10},{7,11,571},{138,11,366},{134,0,1279},{9,11,513},{10,11,22},{10,11,39}
-,{12,11,122},{140,11,187},{133,0,896},{146,0,178},{134,0,695},{137,0,808},{134,
-11,587},{7,11,107},{7,11,838},{8,11,550},{138,11,401},{7,0,1117},{136,0,539},{4,
-10,277},{5,10,608},{6,10,493},{7,10,457},{140,10,384},{133,11,768},{12,0,257},{7
-,10,27},{135,10,316},{140,0,1003},{4,0,207},{5,0,586},{5,0,676},{6,0,448},{8,0,
-244},{11,0,1},{13,0,3},{16,0,54},{17,0,4},{18,0,13},{133,10,552},{4,10,401},{137
-,10,264},{5,0,516},{7,0,1883},{135,11,1883},{12,0,960},{132,11,894},{5,0,4},{5,0
-,810},{6,0,13},{6,0,538},{6,0,1690},{6,0,1726},{7,0,499},{7,0,1819},{8,0,148},{8
-,0,696},{8,0,791},{12,0,125},{143,0,9},{135,0,1268},{11,0,30},{14,0,315},{9,10,
-543},{10,10,524},{12,10,524},{16,10,18},{20,10,26},{148,10,65},{6,0,748},{4,10,
-205},{5,10,623},{7,10,104},{136,10,519},{11,0,542},{139,0,852},{140,0,6},{132,0,
-848},{7,0,1385},{11,0,582},{11,0,650},{11,0,901},{11,0,949},{12,0,232},{12,0,236
-},{13,0,413},{13,0,501},{18,0,116},{7,10,579},{9,10,41},{9,10,244},{9,10,669},{
-10,10,5},{11,10,861},{11,10,951},{139,10,980},{4,0,945},{6,0,1811},{6,0,1845},{6
-,0,1853},{6,0,1858},{8,0,862},{12,0,782},{12,0,788},{18,0,160},{148,0,117},{132,
-10,717},{4,0,925},{5,0,803},{8,0,698},{138,0,828},{134,0,1416},{132,0,610},{139,
-0,992},{6,0,878},{134,0,1477},{135,0,1847},{138,11,531},{137,11,539},{134,11,272
-},{133,0,383},{134,0,1404},{132,10,489},{4,11,9},{5,11,128},{7,11,368},{11,11,
-480},{148,11,3},{136,0,986},{9,0,660},{138,0,347},{135,10,892},{136,11,682},{7,0
-,572},{9,0,592},{11,0,680},{12,0,356},{140,0,550},{7,0,1411},{138,11,527},{4,11,
-2},{7,11,545},{135,11,894},{137,10,473},{11,0,64},{7,11,481},{7,10,819},{9,10,26
-},{9,10,392},{9,11,792},{10,10,152},{10,10,226},{12,10,276},{12,10,426},{12,10,
-589},{13,10,460},{15,10,97},{19,10,48},{148,10,104},{135,10,51},{136,11,445},{
-136,11,646},{135,0,606},{132,10,674},{6,0,1829},{134,0,1830},{132,10,770},{5,10,
-79},{7,10,1027},{7,10,1477},{139,10,52},{5,11,530},{142,11,113},{134,10,1666},{7
-,0,748},{139,0,700},{134,10,195},{133,10,789},{9,0,87},{10,0,365},{4,10,251},{4,
-10,688},{7,10,513},{135,10,1284},{136,11,111},{133,0,127},{6,0,198},{140,0,83},{
-133,11,556},{133,10,889},{4,10,160},{5,10,330},{7,10,1434},{136,10,174},{5,0,276
-},{6,0,55},{7,0,1369},{138,0,864},{8,11,16},{140,11,568},{6,0,1752},{136,0,726},
-{135,0,1066},{133,0,764},{6,11,186},{137,11,426},{11,0,683},{139,11,683},{6,0,
-309},{7,0,331},{138,0,550},{133,10,374},{6,0,1212},{6,0,1852},{7,0,1062},{8,0,
-874},{8,0,882},{138,0,936},{132,11,585},{134,0,1364},{7,0,986},{133,10,731},{6,0
-,723},{6,0,1408},{138,0,381},{135,0,1573},{134,0,1025},{4,10,626},{5,10,642},{6,
-10,425},{10,10,202},{139,10,141},{4,11,93},{5,11,252},{6,11,229},{7,11,291},{9,
-11,550},{139,11,644},{137,11,749},{137,11,162},{132,11,381},{135,0,1559},{6,0,
-194},{7,0,133},{10,0,493},{10,0,570},{139,0,664},{5,0,24},{5,0,569},{6,0,3},{6,0
-,119},{6,0,143},{6,0,440},{7,0,295},{7,0,599},{7,0,1686},{7,0,1854},{8,0,424},{9
-,0,43},{9,0,584},{9,0,760},{10,0,148},{10,0,328},{11,0,159},{11,0,253},{11,0,506
-},{12,0,487},{140,0,531},{6,0,661},{134,0,1517},{136,10,835},{151,10,17},{5,0,14
-},{5,0,892},{6,0,283},{7,0,234},{136,0,537},{139,0,541},{4,0,126},{8,0,635},{147
-,0,34},{4,0,316},{4,0,495},{135,0,1561},{4,11,187},{5,11,184},{5,11,690},{7,11,
-1869},{138,11,756},{139,11,783},{4,0,998},{137,0,861},{136,0,1009},{139,11,292},
-{5,11,21},{6,11,77},{6,11,157},{7,11,974},{7,11,1301},{7,11,1339},{7,11,1490},{7
-,11,1873},{137,11,628},{7,11,1283},{9,11,227},{9,11,499},{10,11,341},{11,11,325}
-,{11,11,408},{14,11,180},{15,11,144},{18,11,47},{147,11,49},{4,0,64},{5,0,352},{
-5,0,720},{6,0,368},{139,0,359},{5,10,384},{8,10,455},{140,10,48},{5,10,264},{134
-,10,184},{7,0,1577},{10,0,304},{10,0,549},{12,0,365},{13,0,220},{13,0,240},{142,
-0,33},{134,0,1107},{134,0,929},{135,0,1142},{6,0,175},{137,0,289},{5,0,432},{133
-,0,913},{6,0,279},{7,0,219},{5,10,633},{135,10,1323},{7,0,785},{7,10,359},{8,10,
-243},{140,10,175},{139,0,595},{132,10,105},{8,11,398},{9,11,681},{139,11,632},{
-140,0,80},{5,0,931},{134,0,1698},{142,11,241},{134,11,20},{134,0,1323},{11,0,526
-},{11,0,939},{141,0,290},{5,0,774},{6,0,780},{6,0,1637},{6,0,1686},{6,0,1751},{8
-,0,559},{141,0,109},{141,0,127},{7,0,1167},{11,0,934},{13,0,391},{17,0,76},{135,
-11,709},{135,0,963},{6,0,260},{135,0,1484},{134,0,573},{4,10,758},{139,11,941},{
-135,10,1649},{145,11,36},{4,0,292},{137,0,580},{4,0,736},{5,0,871},{6,0,1689},{
-135,0,1944},{7,11,945},{11,11,713},{139,11,744},{134,0,1164},{135,11,937},{6,0,
-1922},{9,0,982},{15,0,173},{15,0,178},{15,0,200},{18,0,189},{18,0,207},{21,0,47}
-,{135,11,1652},{7,0,1695},{139,10,128},{6,0,63},{135,0,920},{133,0,793},{143,11,
-134},{133,10,918},{5,0,67},{6,0,62},{6,0,374},{135,0,1391},{9,0,790},{12,0,47},{
-4,11,579},{5,11,226},{5,11,323},{135,11,960},{10,11,784},{141,11,191},{4,0,391},
-{135,0,1169},{137,0,443},{13,11,232},{146,11,35},{132,10,340},{132,0,271},{137,
-11,313},{5,11,973},{137,11,659},{134,0,1140},{6,11,135},{135,11,1176},{4,0,253},
-{5,0,544},{7,0,300},{137,0,340},{7,0,897},{5,10,985},{7,10,509},{145,10,96},{138
-,11,735},{135,10,1919},{138,0,890},{5,0,818},{134,0,1122},{5,0,53},{5,0,541},{6,
-0,94},{6,0,499},{7,0,230},{139,0,321},{4,0,920},{5,0,25},{5,0,790},{6,0,457},{7,
-0,853},{8,0,788},{142,11,31},{132,10,247},{135,11,314},{132,0,468},{7,0,243},{6,
-10,337},{7,10,494},{8,10,27},{8,10,599},{138,10,153},{4,10,184},{5,10,390},{7,10
-,618},{7,10,1456},{139,10,710},{134,0,870},{134,0,1238},{134,0,1765},{10,0,853},
-{10,0,943},{14,0,437},{14,0,439},{14,0,443},{14,0,446},{14,0,452},{14,0,469},{14
-,0,471},{14,0,473},{16,0,93},{16,0,102},{16,0,110},{148,0,121},{4,0,605},{7,0,
-518},{7,0,1282},{7,0,1918},{10,0,180},{139,0,218},{133,0,822},{4,0,634},{11,0,
-916},{142,0,419},{6,11,281},{7,11,6},{8,11,282},{8,11,480},{8,11,499},{9,11,198}
-,{10,11,143},{10,11,169},{10,11,211},{10,11,417},{10,11,574},{11,11,147},{11,11,
-395},{12,11,75},{12,11,407},{12,11,608},{13,11,500},{142,11,251},{134,0,898},{6,
-0,36},{7,0,658},{8,0,454},{150,11,48},{133,11,674},{135,11,1776},{4,11,419},{10,
-10,227},{11,10,497},{11,10,709},{140,10,415},{6,10,360},{7,10,1664},{136,10,478}
-,{137,0,806},{12,11,508},{14,11,102},{14,11,226},{144,11,57},{135,11,1123},{4,11
-,138},{7,11,1012},{7,11,1280},{137,11,76},{5,11,29},{140,11,638},{136,10,699},{
-134,0,1326},{132,0,104},{135,11,735},{132,10,739},{134,0,1331},{7,0,260},{135,11
-,260},{135,11,1063},{7,0,45},{9,0,542},{9,0,566},{10,0,728},{137,10,869},{4,10,
-67},{5,10,422},{7,10,1037},{7,10,1289},{7,10,1555},{9,10,741},{145,10,108},{139,
-0,263},{134,0,1516},{14,0,146},{15,0,42},{16,0,23},{17,0,86},{146,0,17},{138,0,
-468},{136,0,1005},{4,11,17},{5,11,23},{7,11,995},{11,11,383},{11,11,437},{12,11,
-460},{140,11,532},{7,0,87},{142,0,288},{138,10,96},{135,11,626},{144,10,26},{7,0
-,988},{7,0,1939},{9,0,64},{9,0,502},{12,0,22},{12,0,34},{13,0,12},{13,0,234},{
-147,0,77},{13,0,133},{8,10,203},{11,10,823},{11,10,846},{12,10,482},{13,10,277},
-{13,10,302},{13,10,464},{14,10,205},{142,10,221},{4,10,449},{133,10,718},{135,0,
-141},{6,0,1842},{136,0,872},{8,11,70},{12,11,171},{141,11,272},{4,10,355},{6,10,
-311},{9,10,256},{138,10,404},{132,0,619},{137,0,261},{10,11,233},{10,10,758},{
-139,11,76},{5,0,246},{8,0,189},{9,0,355},{9,0,512},{10,0,124},{10,0,453},{11,0,
-143},{11,0,416},{11,0,859},{141,0,341},{134,11,442},{133,10,827},{5,10,64},{140,
-10,581},{4,10,442},{7,10,1047},{7,10,1352},{135,10,1643},{134,11,1709},{5,0,678}
-,{6,0,305},{7,0,775},{7,0,1065},{133,10,977},{11,11,69},{12,11,105},{12,11,117},
-{13,11,213},{14,11,13},{14,11,62},{14,11,177},{14,11,421},{15,11,19},{146,11,141
-},{137,11,309},{5,0,35},{7,0,862},{7,0,1886},{138,0,179},{136,0,285},{132,0,517}
-,{7,11,976},{9,11,146},{10,11,206},{10,11,596},{13,11,218},{142,11,153},{132,10,
-254},{6,0,214},{12,0,540},{4,10,275},{7,10,1219},{140,10,376},{8,0,667},{11,0,
-403},{146,0,83},{12,0,74},{10,11,648},{11,11,671},{143,11,46},{135,0,125},{134,
-10,1753},{133,0,761},{6,0,912},{4,11,518},{6,10,369},{6,10,502},{7,10,1036},{7,
-11,1136},{8,10,348},{9,10,452},{10,10,26},{11,10,224},{11,10,387},{11,10,772},{
-12,10,95},{12,10,629},{13,10,195},{13,10,207},{13,10,241},{14,10,260},{14,10,270
-},{143,10,140},{10,0,131},{140,0,72},{132,10,269},{5,10,480},{7,10,532},{7,10,
-1197},{7,10,1358},{8,10,291},{11,10,349},{142,10,396},{8,11,689},{137,11,863},{8
-,0,333},{138,0,182},{4,11,18},{7,11,145},{7,11,444},{7,11,1278},{8,11,49},{8,11,
-400},{9,11,71},{9,11,250},{10,11,459},{12,11,160},{144,11,24},{14,11,35},{142,11
-,191},{135,11,1864},{135,0,1338},{148,10,15},{14,0,94},{15,0,65},{16,0,4},{16,0,
-77},{16,0,80},{145,0,5},{12,11,82},{143,11,36},{133,11,1010},{133,0,449},{133,0,
-646},{7,0,86},{8,0,103},{135,10,657},{7,0,2028},{138,0,641},{136,10,533},{134,0,
-1},{139,11,970},{5,11,87},{7,11,313},{7,11,1103},{10,11,112},{10,11,582},{11,11,
-389},{11,11,813},{12,11,385},{13,11,286},{14,11,124},{146,11,108},{6,0,869},{132
-,11,267},{6,0,277},{7,0,1274},{7,0,1386},{146,0,87},{6,0,187},{7,0,39},{7,0,1203
-},{8,0,380},{14,0,117},{149,0,28},{4,10,211},{4,10,332},{5,10,335},{6,10,238},{7
-,10,269},{7,10,811},{7,10,1797},{8,10,836},{9,10,507},{141,10,242},{4,0,785},{5,
-0,368},{6,0,297},{7,0,793},{139,0,938},{7,0,464},{8,0,558},{11,0,105},{12,0,231}
-,{14,0,386},{15,0,102},{148,0,75},{133,10,1009},{8,0,877},{140,0,731},{139,11,
-289},{10,11,249},{139,11,209},{132,11,561},{134,0,1608},{132,11,760},{134,0,1429
-},{9,11,154},{140,11,485},{5,10,228},{6,10,203},{7,10,156},{8,10,347},{137,10,
-265},{7,0,1010},{11,0,733},{11,0,759},{13,0,34},{14,0,427},{146,0,45},{7,10,1131
-},{135,10,1468},{136,11,255},{7,0,1656},{9,0,369},{10,0,338},{10,0,490},{11,0,
-154},{11,0,545},{11,0,775},{13,0,77},{141,0,274},{133,11,621},{134,0,1038},{4,11
-,368},{135,11,641},{6,0,2010},{8,0,979},{8,0,985},{10,0,951},{138,0,1011},{134,0
-,1005},{19,0,121},{5,10,291},{5,10,318},{7,10,765},{9,10,389},{140,10,548},{5,0,
-20},{6,0,298},{7,0,659},{137,0,219},{7,0,1440},{11,0,854},{11,0,872},{11,0,921},
-{12,0,551},{13,0,472},{142,0,367},{5,0,490},{6,0,615},{6,0,620},{135,0,683},{6,0
-,1070},{134,0,1597},{139,0,522},{132,0,439},{136,0,669},{6,0,766},{6,0,1143},{6,
-0,1245},{10,10,525},{139,10,82},{9,11,92},{147,11,91},{6,0,668},{134,0,1218},{6,
-11,525},{9,11,876},{140,11,284},{132,0,233},{136,0,547},{132,10,422},{5,10,355},
-{145,10,0},{6,11,300},{135,11,1515},{4,0,482},{137,10,905},{4,0,886},{7,0,346},{
-133,11,594},{133,10,865},{5,10,914},{134,10,1625},{135,0,334},{5,0,795},{6,0,
-1741},{133,10,234},{135,10,1383},{6,11,1641},{136,11,820},{135,0,371},{7,11,1313
-},{138,11,660},{135,10,1312},{135,0,622},{7,0,625},{135,0,1750},{135,0,339},{4,0
-,203},{135,0,1936},{15,0,29},{16,0,38},{15,11,29},{144,11,38},{5,0,338},{135,0,
-1256},{135,10,1493},{10,0,130},{6,10,421},{7,10,61},{7,10,1540},{138,10,501},{6,
-11,389},{7,11,149},{9,11,142},{138,11,94},{137,10,341},{11,0,678},{12,0,307},{
-142,10,98},{6,11,8},{7,11,1881},{136,11,91},{135,0,2044},{6,0,770},{6,0,802},{6,
-0,812},{7,0,311},{9,0,308},{12,0,255},{6,10,102},{7,10,72},{15,10,142},{147,10,
-67},{151,10,30},{135,10,823},{135,0,1266},{135,11,1746},{135,10,1870},{4,0,400},
-{5,0,267},{135,0,232},{7,11,24},{11,11,542},{139,11,852},{135,11,1739},{4,11,503
-},{135,11,1661},{5,11,130},{7,11,1314},{9,11,610},{10,11,718},{11,11,601},{11,11
-,819},{11,11,946},{140,11,536},{10,11,149},{11,11,280},{142,11,336},{7,0,739},{
-11,0,690},{7,11,1946},{8,10,48},{8,10,88},{8,10,582},{8,10,681},{9,10,373},{9,10
-,864},{11,10,157},{11,10,843},{148,10,27},{134,0,990},{4,10,88},{5,10,137},{5,10
-,174},{5,10,777},{6,10,1664},{6,10,1725},{7,10,77},{7,10,426},{7,10,1317},{7,10,
-1355},{8,10,126},{8,10,563},{9,10,523},{9,10,750},{10,10,310},{10,10,836},{11,10
-,42},{11,10,318},{11,10,731},{12,10,68},{12,10,92},{12,10,507},{12,10,692},{13,
-10,81},{13,10,238},{13,10,374},{14,10,436},{18,10,138},{19,10,78},{19,10,111},{
-20,10,55},{20,10,77},{148,10,92},{141,10,418},{7,0,1831},{132,10,938},{6,0,776},
-{134,0,915},{138,10,351},{5,11,348},{6,11,522},{6,10,1668},{7,10,1499},{8,10,117
-},{9,10,314},{138,10,174},{135,10,707},{132,0,613},{133,10,403},{132,11,392},{5,
-11,433},{9,11,633},{139,11,629},{133,0,763},{132,0,878},{132,0,977},{132,0,100},
-{6,0,463},{4,10,44},{5,10,311},{7,10,639},{7,10,762},{7,10,1827},{9,10,8},{9,10,
-462},{148,10,83},{134,11,234},{4,10,346},{7,10,115},{9,10,180},{9,10,456},{138,
-10,363},{5,0,362},{5,0,443},{6,0,318},{7,0,1019},{139,0,623},{5,0,463},{8,0,296}
-,{7,11,140},{7,11,1950},{8,11,680},{11,11,817},{147,11,88},{7,11,1222},{138,11,
-386},{142,0,137},{132,0,454},{7,0,1914},{6,11,5},{7,10,1051},{9,10,545},{11,11,
-249},{12,11,313},{16,11,66},{145,11,26},{135,0,1527},{145,0,58},{148,11,59},{5,0
-,48},{5,0,404},{6,0,557},{7,0,458},{8,0,597},{10,0,455},{10,0,606},{11,0,49},{11
-,0,548},{12,0,476},{13,0,18},{141,0,450},{5,11,963},{134,11,1773},{133,0,729},{
-138,11,586},{5,0,442},{135,0,1984},{134,0,449},{144,0,40},{4,0,853},{7,11,180},{
-8,11,509},{136,11,792},{6,10,185},{7,10,1899},{9,10,875},{139,10,673},{134,11,
-524},{12,0,227},{4,10,327},{5,10,478},{7,10,1332},{136,10,753},{6,0,1491},{5,10,
-1020},{133,10,1022},{4,10,103},{133,10,401},{132,11,931},{4,10,499},{135,10,1421
-},{5,0,55},{7,0,376},{140,0,161},{133,0,450},{6,0,1174},{134,0,1562},{10,0,62},{
-13,0,400},{135,11,1837},{140,0,207},{135,0,869},{4,11,773},{5,11,618},{137,11,
-756},{132,10,96},{4,0,213},{7,0,223},{8,0,80},{135,10,968},{4,11,90},{5,11,337},
-{5,11,545},{7,11,754},{9,11,186},{10,11,72},{10,11,782},{11,11,513},{11,11,577},
-{11,11,610},{11,11,889},{11,11,961},{12,11,354},{12,11,362},{12,11,461},{12,11,
-595},{13,11,79},{143,11,121},{7,0,381},{7,0,806},{7,0,820},{8,0,354},{8,0,437},{
-8,0,787},{9,0,657},{10,0,58},{10,0,339},{10,0,749},{11,0,914},{12,0,162},{13,0,
-75},{14,0,106},{14,0,198},{14,0,320},{14,0,413},{146,0,43},{136,0,747},{136,0,
-954},{134,0,1073},{135,0,556},{7,11,151},{9,11,329},{139,11,254},{5,0,692},{134,
-0,1395},{6,10,563},{137,10,224},{134,0,191},{132,0,804},{9,11,187},{10,11,36},{
-17,11,44},{146,11,64},{7,11,165},{7,11,919},{136,11,517},{4,11,506},{5,11,295},{
-7,11,1680},{15,11,14},{144,11,5},{4,0,706},{6,0,162},{7,0,1960},{136,0,831},{135
-,11,1376},{7,11,987},{9,11,688},{10,11,522},{11,11,788},{140,11,566},{150,0,35},
-{138,0,426},{135,0,1235},{135,11,1741},{7,11,389},{7,11,700},{7,11,940},{8,11,
-514},{9,11,116},{9,11,535},{10,11,118},{11,11,107},{11,11,148},{11,11,922},{12,
-11,254},{12,11,421},{142,11,238},{134,0,1234},{132,11,743},{4,10,910},{5,10,832}
-,{135,11,1335},{141,0,96},{135,11,185},{146,0,149},{4,0,204},{137,0,902},{4,11,
-784},{133,11,745},{136,0,833},{136,0,949},{7,0,366},{9,0,287},{12,0,199},{12,0,
-556},{12,0,577},{5,11,81},{7,11,146},{7,11,1342},{7,11,1446},{8,11,53},{8,11,561
-},{8,11,694},{8,11,754},{9,11,97},{9,11,115},{9,11,894},{10,11,462},{10,11,813},
-{11,11,230},{11,11,657},{11,11,699},{11,11,748},{12,11,119},{12,11,200},{12,11,
-283},{14,11,273},{145,11,15},{5,11,408},{137,11,747},{9,11,498},{140,11,181},{6,
-0,2020},{136,0,992},{5,0,356},{135,0,224},{134,0,784},{7,0,630},{9,0,567},{11,0,
-150},{11,0,444},{13,0,119},{8,10,528},{137,10,348},{134,0,539},{4,10,20},{133,10
-,616},{142,0,27},{7,11,30},{8,11,86},{8,11,315},{8,11,700},{9,11,576},{9,11,858}
-,{11,11,310},{11,11,888},{11,11,904},{12,11,361},{141,11,248},{138,11,839},{134,
-0,755},{134,0,1063},{7,10,1091},{135,10,1765},{134,11,428},{7,11,524},{8,11,169}
-,{8,11,234},{9,11,480},{138,11,646},{139,0,814},{7,11,1462},{139,11,659},{4,10,
-26},{5,10,429},{6,10,245},{7,10,704},{7,10,1379},{135,10,1474},{7,11,1205},{138,
-11,637},{139,11,803},{132,10,621},{136,0,987},{4,11,266},{8,11,4},{9,11,39},{10,
-11,166},{11,11,918},{12,11,635},{20,11,10},{22,11,27},{150,11,43},{4,0,235},{135
-,0,255},{4,0,194},{5,0,584},{6,0,384},{7,0,583},{10,0,761},{11,0,760},{139,0,851
-},{133,10,542},{134,0,1086},{133,10,868},{8,0,1016},{136,0,1018},{7,0,1396},{7,
-11,1396},{136,10,433},{135,10,1495},{138,10,215},{141,10,124},{7,11,157},{8,11,
-279},{9,11,759},{16,11,31},{16,11,39},{16,11,75},{18,11,24},{20,11,42},{152,11,1
-},{5,0,562},{134,11,604},{134,0,913},{5,0,191},{137,0,271},{4,0,470},{6,0,153},{
-7,0,1503},{7,0,1923},{10,0,701},{11,0,132},{11,0,227},{11,0,320},{11,0,436},{11,
-0,525},{11,0,855},{11,0,873},{12,0,41},{12,0,286},{13,0,103},{13,0,284},{14,0,
-255},{14,0,262},{15,0,117},{143,0,127},{7,0,475},{12,0,45},{147,10,112},{132,11,
-567},{137,11,859},{6,0,713},{6,0,969},{6,0,1290},{134,0,1551},{133,0,327},{6,0,
-552},{6,0,1292},{7,0,1754},{137,0,604},{4,0,223},{6,0,359},{11,0,3},{13,0,108},{
-14,0,89},{16,0,22},{5,11,762},{7,11,1880},{9,11,680},{139,11,798},{5,0,80},{6,0,
-405},{7,0,403},{7,0,1502},{8,0,456},{9,0,487},{9,0,853},{9,0,889},{10,0,309},{11
-,0,721},{11,0,994},{12,0,430},{141,0,165},{133,11,298},{132,10,647},{134,0,2016}
-,{18,10,10},{146,11,10},{4,0,453},{5,0,887},{6,0,535},{8,0,6},{8,0,543},{136,0,
-826},{136,0,975},{10,0,961},{138,0,962},{138,10,220},{6,0,1891},{6,0,1893},{9,0,
-916},{9,0,965},{9,0,972},{12,0,801},{12,0,859},{12,0,883},{15,0,226},{149,0,51},
-{132,10,109},{135,11,267},{7,11,92},{7,11,182},{8,11,453},{9,11,204},{11,11,950}
-,{12,11,94},{12,11,644},{16,11,20},{16,11,70},{16,11,90},{147,11,55},{134,10,
-1746},{6,11,71},{7,11,845},{7,11,1308},{8,11,160},{137,11,318},{5,0,101},{6,0,88
-},{7,0,263},{7,0,628},{7,0,1677},{8,0,349},{9,0,100},{10,0,677},{14,0,169},{14,0
-,302},{14,0,313},{15,0,48},{15,0,84},{7,11,237},{8,11,664},{9,11,42},{9,11,266},
-{9,11,380},{9,11,645},{10,11,177},{138,11,276},{138,11,69},{4,0,310},{7,0,708},{
-7,0,996},{9,0,795},{10,0,390},{10,0,733},{11,0,451},{12,0,249},{14,0,115},{14,0,
-286},{143,0,100},{5,0,587},{4,10,40},{10,10,67},{11,10,117},{11,10,768},{139,10,
-935},{6,0,1942},{7,0,512},{136,0,983},{7,10,992},{8,10,301},{9,10,722},{12,10,63
-},{13,10,29},{14,10,161},{143,10,18},{136,11,76},{139,10,923},{134,0,645},{134,0
-,851},{4,0,498},{132,11,293},{7,0,217},{8,0,140},{10,0,610},{14,11,352},{17,11,
-53},{18,11,146},{18,11,152},{19,11,11},{150,11,54},{134,0,1448},{138,11,841},{
-133,0,905},{4,11,605},{7,11,518},{7,11,1282},{7,11,1918},{10,11,180},{139,11,218
-},{139,11,917},{135,10,825},{140,10,328},{4,0,456},{7,0,105},{7,0,358},{7,0,1637
-},{8,0,643},{139,0,483},{134,0,792},{6,11,96},{135,11,1426},{137,11,691},{4,11,
-651},{133,11,289},{7,11,688},{8,11,35},{9,11,511},{10,11,767},{147,11,118},{150,
-0,56},{5,0,243},{5,0,535},{6,10,204},{10,10,320},{10,10,583},{13,10,502},{14,10,
-72},{14,10,274},{14,10,312},{14,10,344},{15,10,159},{16,10,62},{16,10,69},{17,10
-,30},{18,10,42},{18,10,53},{18,10,84},{18,10,140},{19,10,68},{19,10,85},{20,10,5
-},{20,10,45},{20,10,101},{22,10,7},{150,10,20},{4,10,558},{6,10,390},{7,10,162},
-{7,10,689},{9,10,360},{138,10,653},{146,11,23},{135,0,1748},{5,10,856},{6,10,
-1672},{6,10,1757},{134,10,1781},{5,0,539},{5,0,754},{6,0,876},{132,11,704},{135,
-11,1078},{5,10,92},{10,10,736},{140,10,102},{17,0,91},{5,10,590},{137,10,213},{
-134,0,1565},{6,0,91},{135,0,435},{4,0,939},{140,0,792},{134,0,1399},{4,0,16},{5,
-0,316},{5,0,842},{6,0,370},{6,0,1778},{8,0,166},{11,0,812},{12,0,206},{12,0,351}
-,{14,0,418},{16,0,15},{16,0,34},{18,0,3},{19,0,3},{19,0,7},{20,0,4},{21,0,21},{4
-,11,720},{133,11,306},{144,0,95},{133,11,431},{132,11,234},{135,0,551},{4,0,999}
-,{6,0,1966},{134,0,2042},{7,0,619},{10,0,547},{11,0,122},{12,0,601},{15,0,7},{
-148,0,20},{5,11,464},{6,11,236},{7,11,276},{7,11,696},{7,11,914},{7,11,1108},{7,
-11,1448},{9,11,15},{9,11,564},{10,11,14},{12,11,565},{13,11,449},{14,11,53},{15,
-11,13},{16,11,64},{145,11,41},{6,0,884},{6,0,1019},{134,0,1150},{6,11,1767},{12,
-11,194},{145,11,107},{136,10,503},{133,11,840},{7,0,671},{134,10,466},{132,0,888
-},{4,0,149},{138,0,368},{4,0,154},{7,0,1134},{136,0,105},{135,0,983},{9,11,642},
-{11,11,236},{142,11,193},{4,0,31},{6,0,429},{7,0,962},{9,0,458},{139,0,691},{6,0
-,643},{134,0,1102},{132,0,312},{4,11,68},{5,11,634},{6,11,386},{7,11,794},{8,11,
-273},{9,11,563},{10,11,105},{10,11,171},{11,11,94},{139,11,354},{133,0,740},{135
-,0,1642},{4,11,95},{7,11,416},{8,11,211},{139,11,830},{132,0,236},{138,10,241},{
-7,11,731},{13,11,20},{143,11,11},{5,0,836},{5,0,857},{6,0,1680},{135,0,59},{10,0
-,68},{11,0,494},{152,11,6},{4,0,81},{139,0,867},{135,0,795},{133,11,689},{4,0,
-1001},{5,0,282},{6,0,1932},{6,0,1977},{6,0,1987},{6,0,1992},{8,0,650},{8,0,919},
-{8,0,920},{8,0,923},{8,0,926},{8,0,927},{8,0,931},{8,0,939},{8,0,947},{8,0,956},
-{8,0,997},{9,0,907},{10,0,950},{10,0,953},{10,0,954},{10,0,956},{10,0,958},{10,0
-,959},{10,0,964},{10,0,970},{10,0,972},{10,0,973},{10,0,975},{10,0,976},{10,0,
-980},{10,0,981},{10,0,984},{10,0,988},{10,0,990},{10,0,995},{10,0,999},{10,0,
-1002},{10,0,1003},{10,0,1005},{10,0,1006},{10,0,1008},{10,0,1009},{10,0,1012},{
-10,0,1014},{10,0,1015},{10,0,1019},{10,0,1020},{10,0,1022},{12,0,959},{12,0,961}
-,{12,0,962},{12,0,963},{12,0,964},{12,0,965},{12,0,967},{12,0,968},{12,0,969},{
-12,0,970},{12,0,971},{12,0,972},{12,0,973},{12,0,974},{12,0,975},{12,0,976},{12,
-0,977},{12,0,979},{12,0,981},{12,0,982},{12,0,983},{12,0,984},{12,0,985},{12,0,
-986},{12,0,987},{12,0,989},{12,0,990},{12,0,992},{12,0,993},{12,0,995},{12,0,998
-},{12,0,999},{12,0,1000},{12,0,1001},{12,0,1002},{12,0,1004},{12,0,1005},{12,0,
-1006},{12,0,1007},{12,0,1008},{12,0,1009},{12,0,1010},{12,0,1011},{12,0,1012},{
-12,0,1014},{12,0,1015},{12,0,1016},{12,0,1017},{12,0,1018},{12,0,1019},{12,0,
-1022},{12,0,1023},{14,0,475},{14,0,477},{14,0,478},{14,0,479},{14,0,480},{14,0,
-482},{14,0,483},{14,0,484},{14,0,485},{14,0,486},{14,0,487},{14,0,488},{14,0,489
-},{14,0,490},{14,0,491},{14,0,492},{14,0,493},{14,0,494},{14,0,495},{14,0,496},{
-14,0,497},{14,0,498},{14,0,499},{14,0,500},{14,0,501},{14,0,502},{14,0,503},{14,
-0,504},{14,0,506},{14,0,507},{14,0,508},{14,0,509},{14,0,510},{14,0,511},{16,0,
-113},{16,0,114},{16,0,115},{16,0,117},{16,0,118},{16,0,119},{16,0,121},{16,0,122
-},{16,0,123},{16,0,124},{16,0,125},{16,0,126},{16,0,127},{18,0,242},{18,0,243},{
-18,0,244},{18,0,245},{18,0,248},{18,0,249},{18,0,250},{18,0,251},{18,0,252},{18,
-0,253},{18,0,254},{18,0,255},{20,0,125},{20,0,126},{148,0,127},{7,11,1717},{7,11
-,1769},{138,11,546},{7,11,1127},{7,11,1572},{10,11,297},{10,11,422},{11,11,764},
-{11,11,810},{12,11,264},{13,11,102},{13,11,300},{13,11,484},{14,11,147},{14,11,
-229},{17,11,71},{18,11,118},{147,11,120},{6,0,1148},{134,0,1586},{132,0,775},{
-135,10,954},{133,11,864},{133,11,928},{138,11,189},{135,10,1958},{6,10,549},{8,
-10,34},{8,10,283},{9,10,165},{138,10,475},{5,10,652},{5,10,701},{135,10,449},{
-135,11,695},{4,10,655},{7,10,850},{17,10,75},{146,10,137},{140,11,682},{133,11,
-523},{8,0,970},{136,10,670},{136,11,555},{7,11,76},{8,11,44},{9,11,884},{10,11,
-580},{11,11,399},{11,11,894},{15,11,122},{18,11,144},{147,11,61},{6,10,159},{6,
-10,364},{7,10,516},{7,10,1439},{137,10,518},{4,0,71},{5,0,376},{7,0,119},{138,0,
-665},{141,10,151},{11,0,827},{14,0,34},{143,0,148},{133,11,518},{4,0,479},{135,
-11,1787},{135,11,1852},{135,10,993},{7,0,607},{136,0,99},{134,0,1960},{132,0,793
-},{4,0,41},{5,0,74},{7,0,1627},{11,0,871},{140,0,619},{7,0,94},{11,0,329},{11,0,
-965},{12,0,241},{14,0,354},{15,0,22},{148,0,63},{7,10,501},{9,10,111},{10,10,141
-},{11,10,332},{13,10,43},{13,10,429},{14,10,130},{14,10,415},{145,10,102},{9,0,
-209},{137,0,300},{134,0,1497},{138,11,255},{4,11,934},{5,11,138},{136,11,610},{
-133,0,98},{6,0,1316},{10,11,804},{138,11,832},{8,11,96},{9,11,36},{10,11,607},{
-11,11,423},{11,11,442},{12,11,309},{14,11,199},{15,11,90},{145,11,110},{132,0,
-463},{5,10,149},{136,10,233},{133,10,935},{4,11,652},{8,11,320},{9,11,13},{9,11,
-398},{9,11,727},{10,11,75},{10,11,184},{10,11,230},{10,11,564},{10,11,569},{11,
-11,973},{12,11,70},{12,11,189},{13,11,57},{13,11,257},{22,11,6},{150,11,16},{142
-,0,291},{12,10,582},{146,10,131},{136,10,801},{133,0,984},{145,11,116},{4,11,692
-},{133,11,321},{4,0,182},{6,0,205},{135,0,220},{4,0,42},{9,0,205},{9,0,786},{138
-,0,659},{6,0,801},{11,11,130},{140,11,609},{132,0,635},{5,11,345},{135,11,1016},
-{139,0,533},{132,0,371},{4,0,272},{135,0,836},{6,0,1282},{135,11,1100},{5,0,825}
-,{134,0,1640},{135,11,1325},{133,11,673},{4,11,287},{133,11,1018},{135,0,357},{6
-,0,467},{137,0,879},{7,0,317},{135,0,569},{6,0,924},{134,0,1588},{5,11,34},{5,10
-,406},{10,11,724},{12,11,444},{13,11,354},{18,11,32},{23,11,24},{23,11,31},{152,
-11,5},{6,0,1795},{6,0,1835},{6,0,1836},{6,0,1856},{8,0,844},{8,0,849},{8,0,854},
-{8,0,870},{8,0,887},{10,0,852},{138,0,942},{6,10,69},{135,10,117},{137,0,307},{4
-,0,944},{6,0,1799},{6,0,1825},{10,0,848},{10,0,875},{10,0,895},{10,0,899},{10,0,
-902},{140,0,773},{11,0,43},{13,0,72},{141,0,142},{135,10,1830},{134,11,382},{4,
-10,432},{135,10,824},{132,11,329},{7,0,1820},{139,11,124},{133,10,826},{133,0,
-525},{132,11,906},{7,11,1940},{136,11,366},{138,11,10},{4,11,123},{4,11,649},{5,
-11,605},{7,11,1509},{136,11,36},{6,0,110},{135,0,1681},{133,0,493},{133,11,767},
-{4,0,174},{135,0,911},{138,11,786},{8,0,417},{137,0,782},{133,10,1000},{7,0,733}
-,{137,0,583},{4,10,297},{6,10,529},{7,10,152},{7,10,713},{7,10,1845},{8,10,710},
-{8,10,717},{12,10,639},{140,10,685},{4,0,32},{5,0,215},{6,0,269},{7,0,1782},{7,0
-,1892},{10,0,16},{11,0,822},{11,0,954},{141,0,481},{4,11,273},{5,11,658},{133,11
-,995},{136,0,477},{134,11,72},{135,11,1345},{5,0,308},{7,0,1088},{4,10,520},{135
-,10,575},{133,11,589},{5,0,126},{8,0,297},{9,0,366},{140,0,374},{7,0,1551},{139,
-0,361},{5,11,117},{6,11,514},{6,11,541},{7,11,1164},{7,11,1436},{8,11,220},{8,11
-,648},{10,11,688},{139,11,560},{133,11,686},{4,0,946},{6,0,1807},{8,0,871},{10,0
-,854},{10,0,870},{10,0,888},{10,0,897},{10,0,920},{12,0,722},{12,0,761},{12,0,
-763},{12,0,764},{14,0,454},{14,0,465},{16,0,107},{18,0,167},{18,0,168},{146,0,
-172},{132,0,175},{135,0,1307},{132,0,685},{135,11,1834},{133,0,797},{6,0,745},{6
-,0,858},{134,0,963},{133,0,565},{5,10,397},{6,10,154},{7,11,196},{7,10,676},{8,
-10,443},{8,10,609},{9,10,24},{9,10,325},{10,10,35},{10,11,765},{11,11,347},{11,
-10,535},{11,11,552},{11,11,576},{11,10,672},{11,11,790},{11,10,1018},{12,11,263}
-,{12,10,637},{13,11,246},{13,11,270},{13,11,395},{14,11,74},{14,11,176},{14,11,
-190},{14,11,398},{14,11,412},{15,11,32},{15,11,63},{16,10,30},{16,11,88},{147,11
-,105},{13,11,84},{141,11,122},{4,0,252},{7,0,1068},{10,0,434},{11,0,228},{11,0,
-426},{13,0,231},{18,0,106},{148,0,87},{137,0,826},{4,11,589},{139,11,282},{5,11,
-381},{135,11,1792},{132,0,791},{5,0,231},{10,0,509},{133,10,981},{7,0,601},{9,0,
-277},{9,0,674},{10,0,178},{10,0,418},{10,0,571},{11,0,531},{12,0,113},{12,0,475}
-,{13,0,99},{142,0,428},{4,10,56},{7,11,616},{7,10,1791},{8,10,607},{8,10,651},{
-10,11,413},{11,10,465},{11,10,835},{12,10,337},{141,10,480},{7,0,1591},{144,0,43
-},{9,10,158},{138,10,411},{135,0,1683},{8,0,289},{11,0,45},{12,0,278},{140,0,537
-},{6,11,120},{7,11,1188},{7,11,1710},{8,11,286},{9,11,667},{11,11,592},{139,11,
-730},{136,10,617},{135,0,1120},{135,11,1146},{139,10,563},{4,11,352},{4,10,369},
-{135,11,687},{143,11,38},{4,0,399},{5,0,119},{5,0,494},{7,0,751},{9,0,556},{14,
-11,179},{15,11,151},{150,11,11},{4,11,192},{5,11,49},{6,11,200},{6,11,293},{6,11
-,1696},{135,11,488},{4,0,398},{133,0,660},{7,0,1030},{134,10,622},{135,11,595},{
-141,0,168},{132,11,147},{7,0,973},{10,10,624},{142,10,279},{132,10,363},{132,0,
-642},{133,11,934},{134,0,1615},{7,11,505},{135,11,523},{7,0,594},{7,0,851},{7,0,
-1858},{9,0,411},{9,0,574},{9,0,666},{9,0,737},{10,0,346},{10,0,712},{11,0,246},{
-11,0,432},{11,0,517},{11,0,647},{11,0,679},{11,0,727},{12,0,304},{12,0,305},{12,
-0,323},{12,0,483},{12,0,572},{12,0,593},{12,0,602},{13,0,95},{13,0,101},{13,0,
-171},{13,0,315},{13,0,378},{13,0,425},{13,0,475},{14,0,63},{14,0,380},{14,0,384}
-,{15,0,133},{18,0,112},{148,0,72},{135,0,1093},{132,0,679},{8,0,913},{10,0,903},
-{10,0,915},{12,0,648},{12,0,649},{14,0,455},{16,0,112},{138,11,438},{137,0,203},
-{134,10,292},{134,0,1492},{7,0,1374},{8,0,540},{5,10,177},{6,10,616},{7,10,827},
-{9,10,525},{138,10,656},{135,0,1486},{9,0,714},{138,10,31},{136,0,825},{134,0,
-1511},{132,11,637},{134,0,952},{4,10,161},{133,10,631},{5,0,143},{5,0,769},{6,0,
-1760},{7,0,682},{7,0,1992},{136,0,736},{132,0,700},{134,0,1540},{132,11,777},{9,
-11,867},{138,11,837},{7,0,1557},{135,10,1684},{133,0,860},{6,0,422},{7,0,0},{7,0
-,1544},{9,0,605},{11,0,990},{12,0,235},{12,0,453},{13,0,47},{13,0,266},{9,10,469
-},{9,10,709},{12,10,512},{14,10,65},{145,10,12},{11,0,807},{10,10,229},{11,10,73
-},{139,10,376},{6,11,170},{7,11,1080},{8,11,395},{8,11,487},{11,11,125},{141,11,
-147},{5,0,515},{137,0,131},{7,0,1605},{11,0,962},{146,0,139},{132,0,646},{4,0,
-396},{7,0,728},{9,0,117},{13,0,202},{148,0,51},{6,0,121},{6,0,124},{6,0,357},{7,
-0,1138},{7,0,1295},{8,0,162},{8,0,508},{11,0,655},{4,11,535},{6,10,558},{7,10,
-651},{8,11,618},{9,10,0},{10,10,34},{139,10,1008},{135,11,1245},{138,0,357},{150
-,11,23},{133,0,237},{135,0,1784},{7,10,1832},{138,10,374},{132,0,713},{132,11,46
-},{6,0,1536},{10,0,348},{5,11,811},{6,11,1679},{6,11,1714},{135,11,2032},{11,11,
-182},{142,11,195},{6,0,523},{7,0,738},{7,10,771},{7,10,1731},{9,10,405},{138,10,
-421},{7,11,1458},{9,11,407},{139,11,15},{6,11,34},{7,11,69},{7,11,640},{7,11,
-1089},{8,11,708},{8,11,721},{9,11,363},{9,11,643},{10,11,628},{148,11,98},{133,0
-,434},{135,0,1877},{7,0,571},{138,0,366},{5,10,881},{133,10,885},{9,0,513},{10,0
-,25},{10,0,39},{12,0,122},{140,0,187},{132,0,580},{5,10,142},{134,10,546},{132,
-11,462},{137,0,873},{5,10,466},{11,10,571},{12,10,198},{13,10,283},{14,10,186},{
-15,10,21},{143,10,103},{7,0,171},{4,10,185},{5,10,257},{5,10,839},{5,10,936},{9,
-10,399},{10,10,258},{10,10,395},{10,10,734},{11,10,1014},{12,10,23},{13,10,350},
-{14,10,150},{147,10,6},{134,0,625},{7,0,107},{7,0,838},{8,0,550},{138,0,401},{5,
-11,73},{6,11,23},{134,11,338},{4,0,943},{6,0,1850},{12,0,713},{142,0,434},{11,0,
-588},{11,0,864},{11,0,936},{11,0,968},{12,0,73},{12,0,343},{12,0,394},{13,0,275}
-,{14,0,257},{15,0,160},{7,10,404},{7,10,1377},{7,10,1430},{7,10,2017},{8,10,149}
-,{8,10,239},{8,10,512},{8,10,793},{8,10,818},{9,10,474},{9,10,595},{10,10,122},{
-10,10,565},{10,10,649},{10,10,783},{11,10,239},{11,10,295},{11,10,447},{11,10,
-528},{11,10,639},{11,10,800},{12,10,25},{12,10,157},{12,10,316},{12,10,390},{12,
-10,391},{12,10,395},{12,10,478},{12,10,503},{12,10,592},{12,10,680},{13,10,50},{
-13,10,53},{13,10,132},{13,10,198},{13,10,322},{13,10,415},{13,10,511},{14,10,71}
-,{14,10,395},{15,10,71},{15,10,136},{17,10,123},{18,10,93},{147,10,58},{133,0,
-768},{11,0,103},{142,0,0},{136,10,712},{132,0,799},{132,0,894},{7,11,725},{8,11,
-498},{139,11,268},{135,11,1798},{135,11,773},{141,11,360},{4,10,377},{152,10,13}
-,{135,0,1673},{132,11,583},{134,0,1052},{133,11,220},{140,11,69},{132,11,544},{4
-,10,180},{135,10,1906},{134,0,272},{4,0,441},{134,0,1421},{4,0,9},{5,0,128},{7,0
-,368},{11,0,480},{148,0,3},{5,11,176},{6,11,437},{6,11,564},{11,11,181},{141,11,
-183},{132,10,491},{7,0,1182},{141,11,67},{6,0,1346},{4,10,171},{138,10,234},{4,
-10,586},{7,10,1186},{138,10,631},{136,0,682},{134,0,1004},{15,0,24},{143,11,24},
-{134,0,968},{4,0,2},{6,0,742},{6,0,793},{7,0,545},{7,0,894},{9,10,931},{10,10,
-334},{148,10,71},{136,11,600},{133,10,765},{9,0,769},{140,0,185},{4,11,790},{5,
-11,273},{134,11,394},{7,0,474},{137,0,578},{4,11,135},{6,11,127},{7,11,1185},{7,
-11,1511},{8,11,613},{11,11,5},{12,11,133},{12,11,495},{12,11,586},{14,11,385},{
-15,11,118},{17,11,20},{146,11,98},{133,10,424},{5,0,530},{142,0,113},{6,11,230},
-{7,11,961},{7,11,1085},{136,11,462},{7,11,1954},{137,11,636},{136,10,714},{149,
-11,6},{135,10,685},{9,10,420},{10,10,269},{10,10,285},{10,10,576},{11,10,397},{
-13,10,175},{145,10,90},{132,10,429},{5,0,556},{5,11,162},{136,11,68},{132,11,654
-},{4,11,156},{7,11,998},{7,11,1045},{7,11,1860},{9,11,48},{9,11,692},{11,11,419}
-,{139,11,602},{6,0,1317},{8,0,16},{9,0,825},{12,0,568},{7,11,1276},{8,11,474},{
-137,11,652},{18,0,97},{7,10,18},{7,10,699},{7,10,1966},{8,10,752},{9,10,273},{9,
-10,412},{9,10,703},{10,10,71},{10,10,427},{138,10,508},{10,0,703},{7,11,1454},{
-138,11,703},{4,10,53},{5,10,186},{135,10,752},{134,0,892},{134,0,1571},{8,10,575
-},{10,10,289},{139,10,319},{6,0,186},{137,0,426},{134,0,1101},{132,10,675},{132,
-0,585},{6,0,1870},{137,0,937},{152,11,10},{9,11,197},{10,11,300},{12,11,473},{13
-,11,90},{141,11,405},{4,0,93},{5,0,252},{6,0,229},{7,0,291},{9,0,550},{139,0,644
-},{137,0,749},{9,0,162},{6,10,209},{8,10,468},{9,10,210},{11,10,36},{12,10,28},{
-12,10,630},{13,10,21},{13,10,349},{14,10,7},{145,10,13},{132,0,381},{132,11,606}
-,{4,10,342},{135,10,1179},{7,11,1587},{7,11,1707},{10,11,528},{139,11,504},{12,
-11,39},{13,11,265},{141,11,439},{4,10,928},{133,10,910},{7,10,1838},{7,11,1978},
-{136,11,676},{6,0,762},{6,0,796},{134,0,956},{4,10,318},{4,10,496},{7,10,856},{
-139,10,654},{137,11,242},{4,11,361},{133,11,315},{132,11,461},{132,11,472},{132,
-0,857},{5,0,21},{6,0,77},{6,0,157},{7,0,974},{7,0,1301},{7,0,1339},{7,0,1490},{7
-,0,1873},{9,0,628},{7,10,915},{8,10,247},{147,10,0},{4,10,202},{5,10,382},{6,10,
-454},{7,10,936},{7,10,1803},{8,10,758},{9,10,375},{9,10,895},{10,10,743},{10,10,
-792},{11,10,978},{11,10,1012},{142,10,109},{7,11,617},{10,11,498},{11,11,501},{
-12,11,16},{140,11,150},{7,10,1150},{7,10,1425},{7,10,1453},{10,11,747},{140,10,
-513},{133,11,155},{11,0,919},{141,0,409},{138,10,791},{10,0,633},{139,11,729},{7
-,11,163},{8,11,319},{9,11,402},{10,11,24},{10,11,681},{11,11,200},{11,11,567},{
-12,11,253},{12,11,410},{142,11,219},{5,11,475},{7,11,1780},{9,11,230},{11,11,297
-},{11,11,558},{14,11,322},{147,11,76},{7,0,332},{6,10,445},{137,10,909},{135,11,
-1956},{136,11,274},{134,10,578},{135,0,1489},{135,11,1848},{5,11,944},{134,11,
-1769},{132,11,144},{136,10,766},{4,0,832},{135,10,541},{8,0,398},{9,0,681},{139,
-0,632},{136,0,645},{9,0,791},{10,0,93},{16,0,13},{17,0,23},{18,0,135},{19,0,12},
-{20,0,1},{20,0,12},{148,0,14},{6,11,247},{137,11,555},{134,0,20},{132,0,800},{
-135,0,1841},{139,10,983},{137,10,768},{132,10,584},{141,11,51},{6,0,1993},{4,11,
-620},{138,11,280},{136,0,769},{11,0,290},{11,0,665},{7,11,1810},{11,11,866},{12,
-11,103},{13,11,495},{17,11,67},{147,11,74},{134,0,1426},{139,0,60},{4,10,326},{
-135,10,1770},{7,0,1874},{9,0,641},{132,10,226},{6,0,644},{5,10,426},{8,10,30},{9
-,10,2},{11,10,549},{147,10,122},{5,11,428},{138,11,442},{135,11,1871},{135,0,
-1757},{147,10,117},{135,0,937},{135,0,1652},{6,0,654},{134,0,1476},{133,11,99},{
-135,0,527},{132,10,345},{4,10,385},{4,11,397},{7,10,265},{135,10,587},{4,0,579},
-{5,0,226},{5,0,323},{135,0,960},{134,0,1486},{8,11,502},{144,11,9},{4,10,347},{5
-,10,423},{5,10,996},{135,10,1329},{7,11,727},{146,11,73},{4,11,485},{7,11,353},{
-7,10,1259},{7,11,1523},{9,10,125},{139,10,65},{6,0,325},{5,10,136},{6,11,366},{7
-,11,1384},{7,11,1601},{136,10,644},{138,11,160},{6,0,1345},{137,11,282},{18,0,91
-},{147,0,70},{136,0,404},{4,11,157},{133,11,471},{133,0,973},{6,0,135},{135,0,
-1176},{8,11,116},{11,11,551},{142,11,159},{4,0,549},{4,10,433},{133,10,719},{136
-,0,976},{5,11,160},{7,11,363},{7,11,589},{10,11,170},{141,11,55},{144,0,21},{144
-,0,51},{135,0,314},{135,10,1363},{4,11,108},{7,11,405},{10,11,491},{139,11,498},
-{146,0,4},{4,10,555},{8,10,536},{10,10,288},{139,10,1005},{135,11,1005},{6,0,281
-},{7,0,6},{8,0,282},{8,0,480},{8,0,499},{9,0,198},{10,0,143},{10,0,169},{10,0,
-211},{10,0,417},{10,0,574},{11,0,147},{11,0,395},{12,0,75},{12,0,407},{12,0,608}
-,{13,0,500},{142,0,251},{6,0,1093},{6,0,1405},{9,10,370},{138,10,90},{4,11,926},
-{133,11,983},{135,0,1776},{134,0,1528},{132,0,419},{132,11,538},{6,11,294},{7,11
-,1267},{136,11,624},{135,11,1772},{138,11,301},{4,10,257},{135,10,2031},{4,0,138
-},{7,0,1012},{7,0,1280},{9,0,76},{135,10,1768},{132,11,757},{5,0,29},{140,0,638}
-,{7,11,655},{135,11,1844},{7,0,1418},{6,11,257},{135,11,1522},{8,11,469},{138,11
-,47},{142,11,278},{6,10,83},{6,10,1733},{135,10,1389},{11,11,204},{11,11,243},{
-140,11,293},{135,11,1875},{6,0,1710},{135,0,2038},{137,11,299},{4,0,17},{5,0,23}
-,{7,0,995},{11,0,383},{11,0,437},{12,0,460},{140,0,532},{133,0,862},{137,10,696}
-,{6,0,592},{138,0,946},{138,11,599},{7,10,1718},{9,10,95},{9,10,274},{10,10,279}
-,{10,10,317},{10,10,420},{11,10,303},{11,10,808},{12,10,134},{12,10,367},{13,10,
-149},{13,10,347},{14,10,349},{14,10,406},{18,10,22},{18,10,89},{18,10,122},{147,
-10,47},{8,0,70},{12,0,171},{141,0,272},{133,10,26},{132,10,550},{137,0,812},{10,
-0,233},{139,0,76},{134,0,988},{134,0,442},{136,10,822},{7,0,896},{4,10,902},{5,
-10,809},{134,10,122},{5,11,150},{7,11,106},{8,11,603},{9,11,593},{9,11,634},{10,
-11,44},{10,11,173},{11,11,462},{11,11,515},{13,11,216},{13,11,288},{142,11,400},
-{136,0,483},{135,10,262},{6,0,1709},{133,10,620},{4,10,34},{5,10,574},{7,10,279}
-,{7,10,1624},{136,10,601},{137,10,170},{147,0,119},{12,11,108},{141,11,291},{11,
-0,69},{12,0,105},{12,0,117},{13,0,213},{14,0,13},{14,0,62},{14,0,177},{14,0,421}
-,{15,0,19},{146,0,141},{137,0,309},{11,11,278},{142,11,73},{7,0,608},{7,0,976},{
-9,0,146},{10,0,206},{10,0,596},{13,0,218},{142,0,153},{133,10,332},{6,10,261},{8
-,10,182},{139,10,943},{4,11,493},{144,11,55},{134,10,1721},{132,0,768},{4,10,933
-},{133,10,880},{7,11,555},{7,11,1316},{7,11,1412},{7,11,1839},{9,11,192},{9,11,
-589},{11,11,241},{11,11,676},{11,11,811},{11,11,891},{12,11,140},{12,11,346},{12
-,11,479},{13,11,30},{13,11,49},{13,11,381},{14,11,188},{15,11,150},{16,11,76},{
-18,11,30},{148,11,52},{4,0,518},{135,0,1136},{6,11,568},{7,11,112},{7,11,1804},{
-8,11,362},{8,11,410},{8,11,830},{9,11,514},{11,11,649},{142,11,157},{135,11,673}
-,{8,0,689},{137,0,863},{4,0,18},{7,0,145},{7,0,444},{7,0,1278},{8,0,49},{8,0,400
-},{9,0,71},{9,0,250},{10,0,459},{12,0,160},{16,0,24},{132,11,625},{140,0,1020},{
-4,0,997},{6,0,1946},{6,0,1984},{134,0,1998},{6,11,16},{6,11,158},{7,11,43},{7,11
-,129},{7,11,181},{8,11,276},{8,11,377},{10,11,523},{11,11,816},{12,11,455},{13,
-11,303},{142,11,135},{133,10,812},{134,0,658},{4,11,1},{7,11,1143},{7,11,1463},{
-8,11,61},{9,11,207},{9,11,390},{9,11,467},{139,11,836},{150,11,26},{140,0,106},{
-6,0,1827},{10,0,931},{18,0,166},{20,0,114},{4,10,137},{7,10,1178},{7,11,1319},{
-135,10,1520},{133,0,1010},{4,11,723},{5,11,895},{7,11,1031},{8,11,199},{8,11,340
-},{9,11,153},{9,11,215},{10,11,21},{10,11,59},{10,11,80},{10,11,224},{11,11,229}
-,{11,11,652},{12,11,192},{13,11,146},{142,11,91},{132,11,295},{6,11,619},{7,11,
-898},{7,11,1092},{8,11,485},{18,11,28},{147,11,116},{137,11,51},{6,10,1661},{7,
-10,1975},{7,10,2009},{135,10,2011},{5,11,309},{140,11,211},{5,0,87},{7,0,313},{7
-,0,1103},{10,0,208},{10,0,582},{11,0,389},{11,0,813},{12,0,385},{13,0,286},{14,0
-,124},{146,0,108},{5,11,125},{8,11,77},{138,11,15},{132,0,267},{133,0,703},{137,
-11,155},{133,11,439},{11,11,164},{140,11,76},{9,0,496},{5,10,89},{7,10,1915},{9,
-10,185},{9,10,235},{10,10,64},{10,10,270},{10,10,403},{10,10,469},{10,10,529},{
-10,10,590},{11,10,140},{11,10,860},{13,10,1},{13,10,422},{14,10,341},{14,10,364}
-,{17,10,93},{18,10,113},{19,10,97},{147,10,113},{133,10,695},{135,0,1121},{5,10,
-6},{6,10,183},{7,10,680},{7,10,978},{7,10,1013},{7,10,1055},{12,10,230},{13,10,
-172},{146,10,29},{4,11,8},{7,11,1152},{7,11,1153},{7,11,1715},{9,11,374},{10,11,
-478},{139,11,648},{135,11,1099},{6,10,29},{139,10,63},{4,0,561},{10,0,249},{139,
-0,209},{132,0,760},{7,11,799},{138,11,511},{136,11,87},{9,0,154},{140,0,485},{
-136,0,255},{132,0,323},{140,0,419},{132,10,311},{134,10,1740},{4,0,368},{135,0,
-641},{7,10,170},{8,10,90},{8,10,177},{8,10,415},{11,10,714},{142,10,281},{4,11,
-69},{5,11,122},{9,11,656},{138,11,464},{5,11,849},{134,11,1633},{8,0,522},{142,0
-,328},{11,10,91},{13,10,129},{15,10,101},{145,10,125},{7,0,562},{8,0,551},{4,10,
-494},{6,10,74},{7,10,44},{11,11,499},{12,10,17},{15,10,5},{148,10,11},{4,10,276}
-,{133,10,296},{9,0,92},{147,0,91},{4,10,7},{5,10,90},{5,10,158},{6,10,542},{7,10
-,221},{7,10,1574},{9,10,490},{10,10,540},{11,10,443},{139,10,757},{6,0,525},{6,0
-,1976},{8,0,806},{9,0,876},{140,0,284},{5,11,859},{7,10,588},{7,11,1160},{8,11,
-107},{9,10,175},{9,11,291},{9,11,439},{10,10,530},{10,11,663},{11,11,609},{140,
-11,197},{7,11,168},{13,11,196},{141,11,237},{139,0,958},{133,0,594},{135,10,580}
-,{7,10,88},{136,10,627},{6,0,479},{6,0,562},{7,0,1060},{13,0,6},{5,10,872},{6,10
-,57},{7,10,471},{9,10,447},{137,10,454},{136,11,413},{145,11,19},{4,11,117},{6,
-11,372},{7,11,1905},{142,11,323},{4,11,722},{139,11,471},{17,0,61},{5,10,31},{
-134,10,614},{8,10,330},{140,10,477},{7,10,1200},{138,10,460},{6,10,424},{135,10,
-1866},{6,0,1641},{136,0,820},{6,0,1556},{134,0,1618},{9,11,5},{12,11,216},{12,11
-,294},{12,11,298},{12,11,400},{12,11,518},{13,11,229},{143,11,139},{15,11,155},{
-144,11,79},{4,0,302},{135,0,1766},{5,10,13},{134,10,142},{6,0,148},{7,0,1313},{7
-,10,116},{8,10,322},{8,10,755},{9,10,548},{10,10,714},{11,10,884},{141,10,324},{
-137,0,676},{9,11,88},{139,11,270},{5,11,12},{7,11,375},{137,11,438},{134,0,1674}
-,{7,10,1472},{135,10,1554},{11,0,178},{7,10,1071},{7,10,1541},{7,10,1767},{7,10,
-1806},{11,10,162},{11,10,242},{12,10,605},{15,10,26},{144,10,44},{6,0,389},{7,0,
-149},{9,0,142},{138,0,94},{140,11,71},{145,10,115},{6,0,8},{7,0,1881},{8,0,91},{
-11,11,966},{12,11,287},{13,11,342},{13,11,402},{15,11,110},{143,11,163},{4,11,
-258},{136,11,639},{6,11,22},{7,11,903},{138,11,577},{133,11,681},{135,10,1111},{
-135,11,1286},{9,0,112},{8,10,1},{138,10,326},{5,10,488},{6,10,527},{7,10,489},{7
-,10,1636},{8,10,121},{8,10,144},{8,10,359},{9,10,193},{9,10,241},{9,10,336},{9,
-10,882},{11,10,266},{11,10,372},{11,10,944},{12,10,401},{140,10,641},{4,11,664},
-{133,11,804},{6,0,747},{134,0,1015},{135,0,1746},{9,10,31},{10,10,244},{10,10,
-699},{12,10,149},{141,10,497},{133,10,377},{135,0,24},{6,0,1352},{5,11,32},{145,
-10,101},{7,0,1530},{10,0,158},{13,0,13},{13,0,137},{13,0,258},{14,0,111},{14,0,
-225},{14,0,253},{14,0,304},{14,0,339},{14,0,417},{146,0,33},{4,0,503},{135,0,
-1661},{5,0,130},{6,0,845},{7,0,1314},{9,0,610},{10,0,718},{11,0,601},{11,0,819},
-{11,0,946},{140,0,536},{10,0,149},{11,0,280},{142,0,336},{134,0,1401},{135,0,
-1946},{8,0,663},{144,0,8},{134,0,1607},{135,10,2023},{4,11,289},{7,11,629},{7,11
-,1698},{7,11,1711},{140,11,215},{6,11,450},{136,11,109},{10,0,882},{10,0,883},{
-10,0,914},{138,0,928},{133,10,843},{136,11,705},{132,10,554},{133,10,536},{5,0,
-417},{9,10,79},{11,10,625},{145,10,7},{7,11,1238},{142,11,37},{4,0,392},{135,0,
-1597},{5,0,433},{9,0,633},{11,0,629},{132,10,424},{7,10,336},{136,10,785},{134,
-11,355},{6,0,234},{7,0,769},{9,0,18},{138,0,358},{4,10,896},{134,10,1777},{138,
-11,323},{7,0,140},{7,0,1950},{8,0,680},{11,0,817},{147,0,88},{7,0,1222},{138,0,
-386},{139,11,908},{11,0,249},{12,0,313},{16,0,66},{145,0,26},{134,0,5},{7,10,750
-},{9,10,223},{11,10,27},{11,10,466},{12,10,624},{14,10,265},{146,10,61},{134,11,
-26},{134,0,1216},{5,0,963},{134,0,1773},{4,11,414},{5,11,467},{9,11,654},{10,11,
-451},{12,11,59},{141,11,375},{135,11,17},{4,10,603},{133,10,661},{4,10,11},{6,10
-,128},{7,10,231},{7,10,1533},{138,10,725},{135,11,955},{7,0,180},{8,0,509},{136,
-0,792},{132,10,476},{132,0,1002},{133,11,538},{135,10,1807},{132,0,931},{7,0,943
-},{11,0,614},{140,0,747},{135,0,1837},{9,10,20},{10,10,324},{10,10,807},{139,10,
-488},{134,0,641},{6,11,280},{10,11,502},{11,11,344},{140,11,38},{5,11,45},{7,11,
-1161},{11,11,448},{11,11,880},{13,11,139},{13,11,407},{15,11,16},{17,11,95},{18,
-11,66},{18,11,88},{18,11,123},{149,11,7},{9,0,280},{138,0,134},{22,0,22},{23,0,5
-},{151,0,29},{136,11,777},{4,0,90},{5,0,545},{7,0,754},{9,0,186},{10,0,72},{10,0
-,782},{11,0,577},{11,0,610},{11,0,960},{12,0,354},{12,0,362},{12,0,595},{4,11,
-410},{135,11,521},{135,11,1778},{5,10,112},{6,10,103},{134,10,150},{138,10,356},
-{132,0,742},{7,0,151},{9,0,329},{139,0,254},{8,0,853},{8,0,881},{8,0,911},{8,0,
-912},{10,0,872},{12,0,741},{12,0,742},{152,0,18},{4,11,573},{136,11,655},{6,0,
-921},{134,0,934},{9,0,187},{10,0,36},{11,0,1016},{17,0,44},{146,0,64},{7,0,833},
-{136,0,517},{4,0,506},{5,0,295},{135,0,1680},{4,10,708},{8,10,15},{9,10,50},{9,
-10,386},{11,10,18},{11,10,529},{140,10,228},{7,0,251},{7,0,1701},{8,0,436},{4,10
-,563},{7,10,592},{7,10,637},{7,10,770},{8,10,463},{9,10,60},{9,10,335},{9,10,904
-},{10,10,73},{11,10,434},{12,10,585},{13,10,331},{18,10,110},{148,10,60},{132,10
-,502},{136,0,584},{6,10,347},{138,10,161},{7,0,987},{9,0,688},{10,0,522},{11,0,
-788},{12,0,137},{12,0,566},{14,0,9},{14,0,24},{14,0,64},{7,11,899},{142,11,325},
-{4,0,214},{5,0,500},{5,10,102},{6,10,284},{7,10,1079},{7,10,1423},{7,10,1702},{8
-,10,470},{9,10,554},{9,10,723},{139,10,333},{7,10,246},{135,10,840},{6,10,10},{8
-,10,571},{9,10,739},{143,10,91},{133,10,626},{146,0,195},{134,0,1775},{7,0,389},
-{7,0,700},{7,0,940},{8,0,514},{9,0,116},{9,0,535},{10,0,118},{11,0,107},{11,0,
-148},{11,0,922},{12,0,254},{12,0,421},{142,0,238},{5,10,18},{6,10,526},{13,10,24
-},{13,10,110},{19,10,5},{147,10,44},{132,0,743},{11,0,292},{4,10,309},{5,10,462}
-,{7,10,970},{135,10,1097},{22,10,30},{150,10,33},{139,11,338},{135,11,1598},{7,0
-,1283},{9,0,227},{11,0,325},{11,0,408},{14,0,180},{146,0,47},{4,0,953},{6,0,1805
-},{6,0,1814},{6,0,1862},{140,0,774},{6,11,611},{135,11,1733},{135,11,1464},{5,0,
-81},{7,0,146},{7,0,1342},{8,0,53},{8,0,561},{8,0,694},{8,0,754},{9,0,115},{9,0,
-179},{9,0,894},{10,0,462},{10,0,813},{11,0,230},{11,0,657},{11,0,699},{11,0,748}
-,{12,0,119},{12,0,200},{12,0,283},{142,0,273},{5,0,408},{6,0,789},{6,0,877},{6,0
-,1253},{6,0,1413},{137,0,747},{134,10,1704},{135,11,663},{6,0,1910},{6,0,1915},{
-6,0,1923},{9,0,913},{9,0,928},{9,0,950},{9,0,954},{9,0,978},{9,0,993},{12,0,812}
-,{12,0,819},{12,0,831},{12,0,833},{12,0,838},{12,0,909},{12,0,928},{12,0,931},{
-12,0,950},{15,0,186},{15,0,187},{15,0,195},{15,0,196},{15,0,209},{15,0,215},{15,
-0,236},{15,0,241},{15,0,249},{15,0,253},{18,0,180},{18,0,221},{18,0,224},{18,0,
-227},{18,0,229},{149,0,60},{7,0,1826},{135,0,1938},{11,0,490},{18,0,143},{5,10,
-86},{7,10,743},{9,10,85},{10,10,281},{10,10,432},{12,10,251},{13,10,118},{142,10
-,378},{5,10,524},{133,10,744},{141,11,442},{10,10,107},{140,10,436},{135,11,503}
-,{134,0,1162},{132,10,927},{7,0,30},{8,0,86},{8,0,315},{8,0,700},{9,0,576},{9,0,
-858},{10,0,414},{11,0,310},{11,0,888},{11,0,904},{12,0,361},{13,0,248},{13,0,371
-},{14,0,142},{12,10,670},{146,10,94},{134,0,721},{4,11,113},{5,11,163},{5,11,735
-},{7,11,1009},{7,10,1149},{9,11,9},{9,10,156},{9,11,771},{12,11,90},{13,11,138},
-{13,11,410},{143,11,128},{138,0,839},{133,10,778},{137,0,617},{133,10,502},{8,10
-,196},{10,10,283},{139,10,406},{6,0,428},{7,0,524},{8,0,169},{8,0,234},{9,0,480}
-,{138,0,646},{133,10,855},{134,0,1648},{7,0,1205},{138,0,637},{7,0,1596},{4,11,
-935},{133,11,823},{5,11,269},{7,11,434},{7,11,891},{8,11,339},{9,11,702},{11,11,
-594},{11,11,718},{145,11,100},{7,11,878},{9,11,485},{141,11,264},{4,0,266},{8,0,
-4},{9,0,39},{10,0,166},{11,0,918},{12,0,635},{20,0,10},{22,0,27},{22,0,43},{22,0
-,52},{134,11,1713},{7,10,1400},{9,10,446},{138,10,45},{135,11,900},{132,0,862},{
-134,0,1554},{135,11,1033},{19,0,16},{147,11,16},{135,11,1208},{7,0,157},{136,0,
-279},{6,0,604},{136,0,391},{13,10,455},{15,10,99},{15,10,129},{144,10,68},{135,
-10,172},{7,0,945},{11,0,713},{139,0,744},{4,0,973},{10,0,877},{10,0,937},{10,0,
-938},{140,0,711},{139,0,1022},{132,10,568},{142,11,143},{4,0,567},{9,0,859},{132
-,10,732},{7,0,1846},{136,0,628},{136,10,733},{133,0,762},{4,10,428},{135,10,1789
-},{10,0,784},{13,0,191},{7,10,2015},{140,10,665},{133,0,298},{7,0,633},{7,0,905}
-,{7,0,909},{7,0,1538},{9,0,767},{140,0,636},{138,10,806},{132,0,795},{139,0,301}
-,{135,0,1970},{5,11,625},{135,11,1617},{135,11,275},{7,11,37},{8,11,425},{8,11,
-693},{9,11,720},{10,11,380},{10,11,638},{11,11,273},{11,11,307},{11,11,473},{12,
-11,61},{143,11,43},{135,11,198},{134,0,1236},{7,0,369},{12,0,644},{12,0,645},{
-144,0,90},{19,0,15},{149,0,27},{6,0,71},{7,0,845},{8,0,160},{9,0,318},{6,10,1623
-},{134,10,1681},{134,0,1447},{134,0,1255},{138,0,735},{8,0,76},{132,11,168},{6,
-10,1748},{8,10,715},{9,10,802},{10,10,46},{10,10,819},{13,10,308},{14,10,351},{
-14,10,363},{146,10,67},{135,11,91},{6,0,474},{4,10,63},{133,10,347},{133,10,749}
-,{138,0,841},{133,10,366},{6,0,836},{132,11,225},{135,0,1622},{135,10,89},{140,0
-,735},{134,0,1601},{138,11,145},{6,0,1390},{137,0,804},{142,0,394},{6,11,15},{7,
-11,70},{10,11,240},{147,11,93},{6,0,96},{135,0,1426},{4,0,651},{133,0,289},{7,11
-,956},{7,10,977},{7,11,1157},{7,11,1506},{7,11,1606},{7,11,1615},{7,11,1619},{7,
-11,1736},{7,11,1775},{8,11,590},{9,11,324},{9,11,736},{9,11,774},{9,11,776},{9,
-11,784},{10,11,567},{10,11,708},{11,11,518},{11,11,613},{11,11,695},{11,11,716},
-{11,11,739},{11,11,770},{11,11,771},{11,11,848},{11,11,857},{11,11,931},{11,11,
-947},{12,11,326},{12,11,387},{12,11,484},{12,11,528},{12,11,552},{12,11,613},{13
-,11,189},{13,11,256},{13,11,340},{13,11,432},{13,11,436},{13,11,440},{13,11,454}
-,{14,11,174},{14,11,220},{14,11,284},{14,11,390},{145,11,121},{7,0,688},{8,0,35}
-,{9,0,511},{10,0,767},{147,0,118},{134,0,667},{4,0,513},{5,10,824},{133,10,941},
-{7,10,440},{8,10,230},{139,10,106},{134,0,2034},{135,11,1399},{143,11,66},{135,
-11,1529},{4,11,145},{6,11,176},{7,11,395},{9,11,562},{144,11,28},{132,11,501},{
-132,0,704},{134,0,1524},{7,0,1078},{134,11,464},{6,11,509},{10,11,82},{20,11,91}
-,{151,11,13},{4,0,720},{133,0,306},{133,0,431},{7,0,1196},{4,10,914},{5,10,800},
-{133,10,852},{135,11,1189},{10,0,54},{141,10,115},{7,10,564},{142,10,168},{5,0,
-464},{6,0,236},{7,0,696},{7,0,914},{7,0,1108},{7,0,1448},{9,0,15},{9,0,564},{10,
-0,14},{12,0,565},{13,0,449},{14,0,53},{15,0,13},{16,0,64},{17,0,41},{4,10,918},{
-133,10,876},{6,0,1418},{134,10,1764},{4,10,92},{133,10,274},{134,0,907},{4,11,
-114},{8,10,501},{9,11,492},{13,11,462},{142,11,215},{4,11,77},{5,11,361},{6,11,
-139},{6,11,401},{6,11,404},{7,11,413},{7,11,715},{7,11,1716},{11,11,279},{12,11,
-179},{12,11,258},{13,11,244},{142,11,358},{6,0,1767},{12,0,194},{145,0,107},{134
-,11,1717},{5,10,743},{142,11,329},{4,10,49},{7,10,280},{135,10,1633},{5,0,840},{
-7,11,1061},{8,11,82},{11,11,250},{12,11,420},{141,11,184},{135,11,724},{134,0,
-900},{136,10,47},{134,0,1436},{144,11,0},{6,0,675},{7,0,1008},{7,0,1560},{9,0,
-642},{11,0,236},{14,0,193},{5,10,272},{5,10,908},{5,10,942},{8,10,197},{9,10,47}
-,{11,10,538},{139,10,742},{4,0,68},{5,0,628},{5,0,634},{6,0,386},{7,0,794},{8,0,
-273},{9,0,563},{10,0,105},{10,0,171},{11,0,94},{139,0,354},{135,10,1911},{137,10
-,891},{4,0,95},{6,0,1297},{6,0,1604},{7,0,416},{139,0,830},{6,11,513},{135,11,
-1052},{7,0,731},{13,0,20},{143,0,11},{137,11,899},{10,0,850},{140,0,697},{4,0,
-662},{7,11,1417},{12,11,382},{17,11,48},{152,11,12},{133,0,736},{132,0,861},{4,
-10,407},{132,10,560},{141,10,490},{6,11,545},{7,11,565},{7,11,1669},{10,11,114},
-{11,11,642},{140,11,618},{6,0,871},{134,0,1000},{5,0,864},{10,0,648},{11,0,671},
-{15,0,46},{133,11,5},{133,0,928},{11,0,90},{13,0,7},{4,10,475},{11,10,35},{13,10
-,71},{13,10,177},{142,10,422},{136,0,332},{135,11,192},{134,0,1055},{136,11,763}
-,{11,0,986},{140,0,682},{7,0,76},{8,0,44},{9,0,884},{10,0,580},{11,0,399},{11,0,
-894},{143,0,122},{135,11,1237},{135,10,636},{11,0,300},{6,10,222},{7,10,1620},{8
-,10,409},{137,10,693},{4,11,87},{5,11,250},{10,11,601},{13,11,298},{13,11,353},{
-141,11,376},{5,0,518},{10,0,340},{11,0,175},{149,0,16},{140,0,771},{6,0,1108},{
-137,0,831},{132,0,836},{135,0,1852},{4,0,957},{6,0,1804},{8,0,842},{8,0,843},{8,
-0,851},{8,0,855},{140,0,767},{135,11,814},{4,11,57},{7,11,1195},{7,11,1438},{7,
-11,1548},{7,11,1835},{7,11,1904},{9,11,757},{10,11,604},{139,11,519},{133,10,882
-},{138,0,246},{4,0,934},{5,0,202},{8,0,610},{7,11,1897},{12,11,290},{13,11,80},{
-13,11,437},{145,11,74},{8,0,96},{9,0,36},{10,0,607},{10,0,804},{10,0,832},{11,0,
-423},{11,0,442},{12,0,309},{14,0,199},{15,0,90},{145,0,110},{132,10,426},{7,0,
-654},{8,0,240},{6,10,58},{7,10,745},{7,10,1969},{8,10,675},{9,10,479},{9,10,731}
-,{10,10,330},{10,10,593},{10,10,817},{11,10,32},{11,10,133},{11,10,221},{145,10,
-68},{9,0,13},{9,0,398},{9,0,727},{10,0,75},{10,0,184},{10,0,230},{10,0,564},{10,
-0,569},{11,0,973},{12,0,70},{12,0,189},{13,0,57},{141,0,257},{4,11,209},{135,11,
-902},{7,0,391},{137,10,538},{134,0,403},{6,11,303},{7,11,335},{7,11,1437},{7,11,
-1668},{8,11,553},{8,11,652},{8,11,656},{9,11,558},{11,11,743},{149,11,18},{132,
-11,559},{11,0,75},{142,0,267},{6,0,815},{141,11,2},{141,0,366},{137,0,631},{133,
-11,1017},{5,0,345},{135,0,1016},{133,11,709},{134,11,1745},{133,10,566},{7,0,952
-},{6,10,48},{9,10,139},{10,10,399},{11,10,469},{12,10,634},{141,10,223},{133,0,
-673},{9,0,850},{7,11,8},{136,11,206},{6,0,662},{149,0,35},{4,0,287},{133,0,1018}
-,{6,10,114},{7,10,1224},{7,10,1556},{136,10,3},{8,10,576},{137,10,267},{4,0,884}
-,{5,0,34},{10,0,724},{12,0,444},{13,0,354},{18,0,32},{23,0,24},{23,0,31},{152,0,
-5},{133,10,933},{132,11,776},{138,0,151},{136,0,427},{134,0,382},{132,0,329},{9,
-0,846},{10,0,827},{138,11,33},{9,0,279},{10,0,407},{14,0,84},{22,0,18},{135,11,
-1297},{136,11,406},{132,0,906},{136,0,366},{134,0,843},{134,0,1443},{135,0,1372}
-,{138,0,992},{4,0,123},{5,0,605},{7,0,1509},{136,0,36},{132,0,649},{8,11,175},{
-10,11,168},{138,11,573},{133,0,767},{134,0,1018},{135,11,1305},{12,10,30},{13,10
-,148},{14,10,87},{14,10,182},{16,10,42},{148,10,70},{134,11,607},{4,0,273},{5,0,
-658},{133,0,995},{6,0,72},{139,11,174},{10,0,483},{12,0,368},{7,10,56},{7,10,
-1989},{8,10,337},{8,10,738},{9,10,600},{13,10,447},{142,10,92},{5,11,784},{138,
-10,666},{135,0,1345},{139,11,882},{134,0,1293},{133,0,589},{134,0,1988},{5,0,117
-},{6,0,514},{6,0,541},{7,0,1164},{7,0,1436},{8,0,220},{8,0,648},{10,0,688},{139,
-0,560},{136,0,379},{5,0,686},{7,10,866},{135,10,1163},{132,10,328},{9,11,14},{9,
-11,441},{10,11,306},{139,11,9},{4,10,101},{135,10,1171},{5,10,833},{136,10,744},
-{5,11,161},{7,11,839},{135,11,887},{7,0,196},{10,0,765},{11,0,347},{11,0,552},{
-11,0,790},{12,0,263},{13,0,246},{13,0,270},{13,0,395},{14,0,176},{14,0,190},{14,
-0,398},{14,0,412},{15,0,32},{15,0,63},{16,0,88},{147,0,105},{6,10,9},{6,10,397},
-{7,10,53},{7,10,1742},{10,10,632},{11,10,828},{140,10,146},{5,0,381},{135,0,1792
-},{134,0,1452},{135,11,429},{8,0,367},{10,0,760},{14,0,79},{20,0,17},{152,0,0},{
-7,0,616},{138,0,413},{11,10,417},{12,10,223},{140,10,265},{7,11,1611},{13,11,14}
-,{15,11,44},{19,11,13},{148,11,76},{135,0,1229},{6,0,120},{7,0,1188},{7,0,1710},
-{8,0,286},{9,0,667},{11,0,592},{139,0,730},{135,11,1814},{135,0,1146},{4,10,186}
-,{5,10,157},{8,10,168},{138,10,6},{4,0,352},{135,0,687},{4,0,192},{5,0,49},{6,0,
-200},{6,0,293},{6,0,1696},{135,0,1151},{133,10,875},{5,10,773},{5,10,991},{6,10,
-1635},{134,10,1788},{7,10,111},{136,10,581},{6,0,935},{134,0,1151},{134,0,1050},
-{132,0,650},{132,0,147},{11,0,194},{12,0,62},{12,0,88},{11,11,194},{12,11,62},{
-140,11,88},{6,0,339},{135,0,923},{134,10,1747},{7,11,643},{136,11,236},{133,0,
-934},{7,10,1364},{7,10,1907},{141,10,158},{132,10,659},{4,10,404},{135,10,675},{
-7,11,581},{9,11,644},{137,11,699},{13,0,211},{14,0,133},{14,0,204},{15,0,64},{15
-,0,69},{15,0,114},{16,0,10},{19,0,23},{19,0,35},{19,0,39},{19,0,51},{19,0,71},{
-19,0,75},{152,0,15},{133,10,391},{5,11,54},{135,11,1513},{7,0,222},{8,0,341},{5,
-10,540},{134,10,1697},{134,10,78},{132,11,744},{136,0,293},{137,11,701},{7,11,
-930},{10,11,402},{10,11,476},{13,11,452},{18,11,55},{147,11,104},{132,0,637},{
-133,10,460},{8,11,50},{137,11,624},{132,11,572},{134,0,1159},{4,10,199},{139,10,
-34},{134,0,847},{134,10,388},{6,11,43},{7,11,38},{8,11,248},{9,11,504},{138,11,
-513},{9,0,683},{4,10,511},{6,10,608},{9,10,333},{10,10,602},{11,10,441},{11,10,
-723},{11,10,976},{140,10,357},{9,0,867},{138,0,837},{6,0,944},{135,11,326},{135,
-0,1809},{5,10,938},{7,11,783},{136,10,707},{133,11,766},{133,11,363},{6,0,170},{
-7,0,1080},{8,0,395},{8,0,487},{141,0,147},{6,11,258},{140,11,409},{4,0,535},{8,0
-,618},{5,11,249},{148,11,82},{6,0,1379},{149,11,15},{135,0,1625},{150,0,23},{5,
-11,393},{6,11,378},{7,11,1981},{9,11,32},{9,11,591},{10,11,685},{10,11,741},{142
-,11,382},{133,11,788},{7,11,1968},{10,11,19},{139,11,911},{7,11,1401},{135,11,
-1476},{4,11,61},{5,11,58},{5,11,171},{5,11,635},{5,11,683},{5,11,700},{6,11,291}
-,{6,11,566},{7,11,1650},{11,11,523},{12,11,273},{12,11,303},{15,11,39},{143,11,
-111},{6,10,469},{7,10,1709},{138,10,515},{4,0,778},{134,11,589},{132,0,46},{5,0,
-811},{6,0,1679},{6,0,1714},{135,0,2032},{7,0,1458},{9,0,407},{11,0,15},{12,0,651
-},{149,0,37},{7,0,938},{132,10,500},{6,0,34},{7,0,69},{7,0,1089},{7,0,1281},{8,0
-,708},{8,0,721},{9,0,363},{148,0,98},{10,11,231},{147,11,124},{7,11,726},{152,11
-,9},{5,10,68},{134,10,383},{136,11,583},{4,11,917},{133,11,1005},{11,10,216},{
-139,10,340},{135,11,1675},{8,0,441},{10,0,314},{143,0,3},{132,11,919},{4,10,337}
-,{6,10,353},{7,10,1934},{8,10,488},{137,10,429},{7,0,889},{7,10,1795},{8,10,259}
-,{9,10,135},{9,10,177},{9,10,860},{10,10,825},{11,10,115},{11,10,370},{11,10,405
-},{11,10,604},{12,10,10},{12,10,667},{12,10,669},{13,10,76},{14,10,310},{15,10,
-76},{15,10,147},{148,10,23},{4,10,15},{4,11,255},{5,10,22},{5,11,302},{6,11,132}
-,{6,10,244},{7,10,40},{7,11,128},{7,10,200},{7,11,283},{7,10,906},{7,10,1199},{7
-,11,1299},{9,10,616},{10,11,52},{10,11,514},{10,10,716},{11,10,635},{11,10,801},
-{11,11,925},{12,10,458},{13,11,92},{142,11,309},{132,0,462},{137,11,173},{135,10
-,1735},{8,0,525},{5,10,598},{7,10,791},{8,10,108},{137,10,123},{5,0,73},{6,0,23}
-,{134,0,338},{132,0,676},{132,10,683},{7,0,725},{8,0,498},{139,0,268},{12,0,21},
-{151,0,7},{135,0,773},{4,10,155},{135,10,1689},{4,0,164},{5,0,730},{5,10,151},{5
-,10,741},{6,11,210},{7,10,498},{7,10,870},{7,10,1542},{12,10,213},{14,10,36},{14
-,10,391},{17,10,111},{18,10,6},{18,10,46},{18,10,151},{19,10,36},{20,10,32},{20,
-10,56},{20,10,69},{20,10,102},{21,10,4},{22,10,8},{22,10,10},{22,10,14},{150,10,
-31},{4,10,624},{135,10,1752},{4,0,583},{9,0,936},{15,0,214},{18,0,199},{24,0,26}
-,{134,11,588},{7,0,1462},{11,0,659},{4,11,284},{134,11,223},{133,0,220},{139,0,
-803},{132,0,544},{4,10,492},{133,10,451},{16,0,98},{148,0,119},{4,11,218},{7,11,
-526},{143,11,137},{135,10,835},{4,11,270},{5,11,192},{6,11,332},{7,11,1322},{13,
-11,9},{13,10,70},{14,11,104},{142,11,311},{132,10,539},{140,11,661},{5,0,176},{6
-,0,437},{6,0,564},{11,0,181},{141,0,183},{135,0,1192},{6,10,113},{135,10,436},{
-136,10,718},{135,10,520},{135,0,1878},{140,11,196},{7,11,379},{8,11,481},{137,11
-,377},{5,11,1003},{6,11,149},{137,11,746},{8,11,262},{9,11,627},{10,11,18},{11,
-11,214},{11,11,404},{11,11,457},{11,11,780},{11,11,849},{11,11,913},{13,11,330},
-{13,11,401},{142,11,200},{149,0,26},{136,11,304},{132,11,142},{135,0,944},{4,0,
-790},{5,0,273},{134,0,394},{134,0,855},{4,0,135},{6,0,127},{7,0,1185},{7,0,1511}
-,{8,0,613},{11,0,5},{12,0,336},{12,0,495},{12,0,586},{12,0,660},{12,0,668},{14,0
-,385},{15,0,118},{17,0,20},{146,0,98},{6,0,230},{9,0,752},{18,0,109},{12,10,610}
-,{13,10,431},{144,10,59},{7,0,1954},{135,11,925},{4,11,471},{5,11,51},{6,11,602}
-,{8,11,484},{10,11,195},{140,11,159},{132,10,307},{136,11,688},{132,11,697},{7,
-11,812},{7,11,1261},{7,11,1360},{9,11,632},{140,11,352},{5,0,162},{8,0,68},{133,
-10,964},{4,0,654},{136,11,212},{4,0,156},{7,0,998},{7,0,1045},{7,0,1860},{9,0,48
-},{9,0,692},{11,0,419},{139,0,602},{133,11,221},{4,11,373},{5,11,283},{6,11,480}
-,{135,11,609},{142,11,216},{132,0,240},{6,11,192},{9,11,793},{145,11,55},{4,10,
-75},{5,10,180},{6,10,500},{7,10,58},{7,10,710},{138,10,645},{4,11,132},{5,11,69}
-,{5,10,649},{135,11,1242},{6,10,276},{7,10,282},{7,10,879},{7,10,924},{8,10,459}
-,{9,10,599},{9,10,754},{11,10,574},{12,10,128},{12,10,494},{13,10,52},{13,10,301
-},{15,10,30},{143,10,132},{132,10,200},{4,11,111},{135,11,302},{9,0,197},{10,0,
-300},{12,0,473},{13,0,90},{141,0,405},{132,11,767},{6,11,42},{7,11,1416},{7,11,
-1590},{7,11,2005},{8,11,131},{8,11,466},{9,11,672},{13,11,252},{148,11,103},{8,0
-,958},{8,0,999},{10,0,963},{138,0,1001},{135,10,1621},{135,0,858},{4,0,606},{137
-,11,444},{6,11,44},{136,11,368},{139,11,172},{4,11,570},{133,11,120},{139,11,624
-},{7,0,1978},{8,0,676},{6,10,225},{137,10,211},{7,0,972},{11,0,102},{136,10,687}
-,{6,11,227},{135,11,1589},{8,10,58},{9,10,724},{11,10,809},{13,10,113},{145,10,
-72},{4,0,361},{133,0,315},{132,0,461},{6,10,345},{135,10,1247},{132,0,472},{8,10
-,767},{8,10,803},{9,10,301},{137,10,903},{135,11,1333},{135,11,477},{7,10,1949},
-{136,10,674},{6,0,905},{138,0,747},{133,0,155},{134,10,259},{7,0,163},{8,0,319},
-{9,0,402},{10,0,24},{10,0,681},{11,0,200},{12,0,253},{12,0,410},{142,0,219},{5,0
-,475},{7,0,1780},{9,0,230},{11,0,297},{11,0,558},{14,0,322},{19,0,76},{6,11,1667
-},{7,11,2036},{138,11,600},{136,10,254},{6,0,848},{135,0,1956},{6,11,511},{140,
-11,132},{5,11,568},{6,11,138},{135,11,1293},{6,0,631},{137,0,838},{149,0,36},{4,
-11,565},{8,11,23},{136,11,827},{5,0,944},{134,0,1769},{4,0,144},{6,0,842},{6,0,
-1400},{4,11,922},{133,11,1023},{133,10,248},{9,10,800},{10,10,693},{11,10,482},{
-11,10,734},{139,10,789},{7,11,1002},{139,11,145},{4,10,116},{5,10,95},{5,10,445}
-,{7,10,1688},{8,10,29},{9,10,272},{11,10,509},{139,10,915},{14,0,369},{146,0,72}
-,{135,10,1641},{132,11,740},{133,10,543},{140,11,116},{6,0,247},{9,0,555},{5,10,
-181},{136,10,41},{133,10,657},{136,0,996},{138,10,709},{7,0,189},{8,10,202},{138
-,10,536},{136,11,402},{4,11,716},{141,11,31},{10,0,280},{138,0,797},{9,10,423},{
-140,10,89},{8,10,113},{9,10,877},{10,10,554},{11,10,83},{12,10,136},{147,10,109}
-,{133,10,976},{7,0,746},{132,10,206},{136,0,526},{139,0,345},{136,0,1017},{8,11,
-152},{9,11,53},{9,11,268},{9,11,901},{10,11,518},{10,11,829},{11,11,188},{13,11,
-74},{14,11,46},{15,11,17},{15,11,33},{17,11,40},{18,11,36},{19,11,20},{22,11,1},
-{152,11,2},{133,11,736},{136,11,532},{5,0,428},{138,0,651},{135,11,681},{135,0,
-1162},{7,0,327},{13,0,230},{17,0,113},{8,10,226},{10,10,537},{11,10,570},{11,10,
-605},{11,10,799},{11,10,804},{12,10,85},{12,10,516},{12,10,623},{12,11,677},{13,
-10,361},{14,10,77},{14,10,78},{147,10,110},{4,0,792},{7,0,1717},{10,0,546},{132,
-10,769},{4,11,684},{136,11,384},{132,10,551},{134,0,1203},{9,10,57},{9,10,459},{
-10,10,425},{11,10,119},{12,10,184},{12,10,371},{13,10,358},{145,10,51},{5,0,672}
-,{5,10,814},{8,10,10},{9,10,421},{9,10,729},{10,10,609},{139,10,689},{138,0,189}
-,{134,10,624},{7,11,110},{7,11,188},{8,11,290},{8,11,591},{9,11,382},{9,11,649},
-{11,11,71},{11,11,155},{11,11,313},{12,11,5},{13,11,325},{142,11,287},{133,0,99}
-,{6,0,1053},{135,0,298},{7,11,360},{7,11,425},{9,11,66},{9,11,278},{138,11,644},
-{4,0,397},{136,0,555},{137,10,269},{132,10,528},{4,11,900},{133,11,861},{6,0,
-1157},{5,11,254},{7,11,985},{136,11,73},{7,11,1959},{136,11,683},{12,0,398},{20,
-0,39},{21,0,11},{150,0,41},{4,0,485},{7,0,353},{135,0,1523},{6,0,366},{7,0,1384}
-,{135,0,1601},{138,0,787},{137,0,282},{5,10,104},{6,10,173},{135,10,1631},{139,
-11,146},{4,0,157},{133,0,471},{134,0,941},{132,11,725},{7,0,1336},{8,10,138},{8,
-10,342},{9,10,84},{10,10,193},{11,10,883},{140,10,359},{134,11,196},{136,0,116},
-{133,11,831},{134,0,787},{134,10,95},{6,10,406},{10,10,409},{10,10,447},{11,10,
-44},{140,10,100},{5,0,160},{7,0,363},{7,0,589},{10,0,170},{141,0,55},{134,0,1815
-},{132,0,866},{6,0,889},{6,0,1067},{6,0,1183},{4,11,321},{134,11,569},{5,11,848}
-,{134,11,66},{4,11,36},{6,10,1636},{7,11,1387},{10,11,205},{11,11,755},{141,11,
-271},{132,0,689},{9,0,820},{4,10,282},{7,10,1034},{11,10,398},{11,10,634},{12,10
-,1},{12,10,79},{12,10,544},{14,10,237},{17,10,10},{146,10,20},{4,0,108},{7,0,804
-},{139,0,498},{132,11,887},{6,0,1119},{135,11,620},{6,11,165},{138,11,388},{5,0,
-244},{5,10,499},{6,10,476},{7,10,600},{7,10,888},{135,10,1096},{140,0,609},{135,
-0,1005},{4,0,412},{133,0,581},{4,11,719},{135,11,155},{7,10,296},{7,10,596},{8,
-10,560},{8,10,586},{9,10,612},{11,10,304},{12,10,46},{13,10,89},{14,10,112},{145
-,10,122},{4,0,895},{133,0,772},{142,11,307},{135,0,1898},{4,0,926},{133,0,983},{
-4,11,353},{6,11,146},{6,11,1789},{7,11,288},{7,11,990},{7,11,1348},{9,11,665},{9
-,11,898},{11,11,893},{142,11,212},{132,0,538},{133,11,532},{6,0,294},{7,0,1267},
-{8,0,624},{141,0,496},{7,0,1325},{4,11,45},{135,11,1257},{138,0,301},{9,0,298},{
-12,0,291},{13,0,276},{14,0,6},{17,0,18},{21,0,32},{7,10,1599},{7,10,1723},{8,10,
-79},{8,10,106},{8,10,190},{8,10,302},{8,10,383},{8,10,713},{9,10,119},{9,10,233}
-,{9,10,419},{9,10,471},{10,10,181},{10,10,406},{11,10,57},{11,10,85},{11,10,120}
-,{11,10,177},{11,10,296},{11,10,382},{11,10,454},{11,10,758},{11,10,999},{12,10,
-27},{12,10,131},{12,10,245},{12,10,312},{12,10,446},{12,10,454},{13,10,98},{13,
-10,426},{13,10,508},{14,10,163},{14,10,272},{14,10,277},{14,10,370},{15,10,95},{
-15,10,138},{15,10,167},{17,10,38},{148,10,96},{132,0,757},{134,0,1263},{4,0,820}
-,{134,10,1759},{133,0,722},{136,11,816},{138,10,372},{145,10,16},{134,0,1039},{4
-,0,991},{134,0,2028},{133,10,258},{7,0,1875},{139,0,124},{6,11,559},{6,11,1691},
-{135,11,586},{5,0,324},{7,0,881},{8,10,134},{9,10,788},{140,10,438},{7,11,1823},
-{139,11,693},{6,0,1348},{134,0,1545},{134,0,911},{132,0,954},{8,0,329},{8,0,414}
-,{7,10,1948},{135,10,2004},{5,0,517},{6,10,439},{7,10,780},{135,10,1040},{132,0,
-816},{5,10,1},{6,10,81},{138,10,520},{9,0,713},{10,0,222},{5,10,482},{8,10,98},{
-10,10,700},{10,10,822},{11,10,302},{11,10,778},{12,10,50},{12,10,127},{12,10,396
-},{13,10,62},{13,10,328},{14,10,122},{147,10,72},{137,0,33},{5,10,2},{7,10,1494}
-,{136,10,589},{6,10,512},{7,10,797},{8,10,253},{9,10,77},{10,10,1},{10,11,108},{
-10,10,129},{10,10,225},{11,11,116},{11,10,118},{11,10,226},{11,10,251},{11,10,
-430},{11,10,701},{11,10,974},{11,10,982},{12,10,64},{12,10,260},{12,10,488},{140
-,10,690},{134,11,456},{133,11,925},{5,0,150},{7,0,106},{7,0,774},{8,0,603},{9,0,
-593},{9,0,634},{10,0,44},{10,0,173},{11,0,462},{11,0,515},{13,0,216},{13,0,288},
-{142,0,400},{137,10,347},{5,0,748},{134,0,553},{12,0,108},{141,0,291},{7,0,420},
-{4,10,12},{7,10,522},{7,10,809},{8,10,797},{141,10,88},{6,11,193},{7,11,240},{7,
-11,1682},{10,11,51},{10,11,640},{11,11,410},{13,11,82},{14,11,247},{14,11,331},{
-142,11,377},{133,10,528},{135,0,1777},{4,0,493},{144,0,55},{136,11,633},{139,0,
-81},{6,0,980},{136,0,321},{148,10,109},{5,10,266},{9,10,290},{9,10,364},{10,10,
-293},{11,10,606},{142,10,45},{6,0,568},{7,0,112},{7,0,1804},{8,0,362},{8,0,410},
-{8,0,830},{9,0,514},{11,0,649},{142,0,157},{4,0,74},{6,0,510},{6,10,594},{9,10,
-121},{10,10,49},{10,10,412},{139,10,834},{134,0,838},{136,10,748},{132,10,466},{
-132,0,625},{135,11,1443},{4,11,237},{135,11,514},{9,10,378},{141,10,162},{6,0,16
-},{6,0,158},{7,0,43},{7,0,129},{7,0,181},{8,0,276},{8,0,377},{10,0,523},{11,0,
-816},{12,0,455},{13,0,303},{142,0,135},{135,0,281},{4,0,1},{7,0,1143},{7,0,1463}
-,{8,0,61},{9,0,207},{9,0,390},{9,0,467},{139,0,836},{6,11,392},{7,11,65},{135,11
-,2019},{132,10,667},{4,0,723},{5,0,895},{7,0,1031},{8,0,199},{8,0,340},{9,0,153}
-,{9,0,215},{10,0,21},{10,0,59},{10,0,80},{10,0,224},{10,0,838},{11,0,229},{11,0,
-652},{12,0,192},{13,0,146},{142,0,91},{132,0,295},{137,0,51},{9,11,222},{10,11,
-43},{139,11,900},{5,0,309},{140,0,211},{5,0,125},{8,0,77},{138,0,15},{136,11,604
-},{138,0,789},{5,0,173},{4,10,39},{7,10,1843},{8,10,407},{11,10,144},{140,10,523
-},{138,11,265},{133,0,439},{132,10,510},{7,0,648},{7,0,874},{11,0,164},{12,0,76}
-,{18,0,9},{7,10,1980},{10,10,487},{138,10,809},{12,0,111},{14,0,294},{19,0,45},{
-13,10,260},{146,10,63},{133,11,549},{134,10,570},{4,0,8},{7,0,1152},{7,0,1153},{
-7,0,1715},{9,0,374},{10,0,478},{139,0,648},{135,0,1099},{5,0,575},{6,0,354},{135
-,0,701},{7,11,36},{8,11,201},{136,11,605},{4,10,787},{136,11,156},{6,0,518},{149
-,11,13},{140,11,224},{134,0,702},{132,10,516},{5,11,724},{10,11,305},{11,11,151}
-,{12,11,33},{12,11,121},{12,11,381},{17,11,3},{17,11,27},{17,11,78},{18,11,18},{
-19,11,54},{149,11,5},{8,0,87},{4,11,523},{5,11,638},{11,10,887},{14,10,365},{142
-,10,375},{138,0,438},{136,10,821},{135,11,1908},{6,11,242},{7,11,227},{7,11,1581
-},{8,11,104},{9,11,113},{9,11,220},{9,11,427},{10,11,74},{10,11,239},{11,11,579}
-,{11,11,1023},{13,11,4},{13,11,204},{13,11,316},{18,11,95},{148,11,86},{4,0,69},
-{5,0,122},{5,0,849},{6,0,1633},{9,0,656},{138,0,464},{7,0,1802},{4,10,10},{139,
-10,786},{135,11,861},{139,0,499},{7,0,476},{7,0,1592},{138,0,87},{133,10,684},{4
-,0,840},{134,10,27},{142,0,283},{6,0,1620},{7,11,1328},{136,11,494},{5,0,859},{7
-,0,1160},{8,0,107},{9,0,291},{9,0,439},{10,0,663},{11,0,609},{140,0,197},{7,11,
-1306},{8,11,505},{9,11,482},{10,11,126},{11,11,225},{12,11,347},{12,11,449},{13,
-11,19},{142,11,218},{5,11,268},{10,11,764},{12,11,120},{13,11,39},{145,11,127},{
-145,10,56},{7,11,1672},{10,11,472},{11,11,189},{143,11,51},{6,10,342},{6,10,496}
-,{8,10,275},{137,10,206},{133,0,600},{4,0,117},{6,0,372},{7,0,1905},{142,0,323},
-{4,10,909},{5,10,940},{135,11,1471},{132,10,891},{4,0,722},{139,0,471},{4,11,384
-},{135,11,1022},{132,10,687},{9,0,5},{12,0,216},{12,0,294},{12,0,298},{12,0,400}
-,{12,0,518},{13,0,229},{143,0,139},{135,11,1703},{7,11,1602},{10,11,698},{12,11,
-212},{141,11,307},{6,10,41},{141,10,160},{135,11,1077},{9,11,159},{11,11,28},{
-140,11,603},{4,0,514},{7,0,1304},{138,0,477},{134,0,1774},{9,0,88},{139,0,270},{
-5,0,12},{7,0,375},{9,0,438},{134,10,1718},{132,11,515},{136,10,778},{8,11,632},{
-8,11,697},{137,11,854},{6,0,362},{6,0,997},{146,0,51},{7,0,816},{7,0,1241},{9,0,
-283},{9,0,520},{10,0,213},{10,0,307},{10,0,463},{10,0,671},{10,0,746},{11,0,401}
-,{11,0,794},{12,0,517},{18,0,107},{147,0,115},{133,10,115},{150,11,28},{4,11,136
-},{133,11,551},{142,10,314},{132,0,258},{6,0,22},{7,0,903},{7,0,1963},{8,0,639},
-{138,0,577},{5,0,681},{8,0,782},{13,0,130},{17,0,84},{5,10,193},{140,10,178},{9,
-11,17},{138,11,291},{7,11,1287},{9,11,44},{10,11,552},{10,11,642},{11,11,839},{
-12,11,274},{12,11,275},{12,11,372},{13,11,91},{142,11,125},{135,10,174},{4,0,664
-},{5,0,804},{139,0,1013},{134,0,942},{6,0,1349},{6,0,1353},{6,0,1450},{7,11,1518
-},{139,11,694},{11,0,356},{4,10,122},{5,10,796},{5,10,952},{6,10,1660},{6,10,
-1671},{8,10,567},{9,10,687},{9,10,742},{10,10,686},{11,10,682},{140,10,281},{5,0
-,32},{6,11,147},{7,11,886},{9,11,753},{138,11,268},{5,10,179},{7,10,1095},{135,
-10,1213},{4,10,66},{7,10,722},{135,10,904},{135,10,352},{9,11,245},{138,11,137},
-{4,0,289},{7,0,629},{7,0,1698},{7,0,1711},{12,0,215},{133,11,414},{6,0,1975},{
-135,11,1762},{6,0,450},{136,0,109},{141,10,35},{134,11,599},{136,0,705},{133,0,
-664},{134,11,1749},{11,11,402},{12,11,109},{12,11,431},{13,11,179},{13,11,206},{
-14,11,175},{14,11,217},{16,11,3},{148,11,53},{135,0,1238},{134,11,1627},{132,11,
-488},{13,0,318},{10,10,592},{10,10,753},{12,10,317},{12,10,355},{12,10,465},{12,
-10,469},{12,10,560},{140,10,578},{133,10,564},{132,11,83},{140,11,676},{6,0,1872
-},{6,0,1906},{6,0,1907},{9,0,934},{9,0,956},{9,0,960},{9,0,996},{12,0,794},{12,0
-,876},{12,0,880},{12,0,918},{15,0,230},{18,0,234},{18,0,238},{21,0,38},{149,0,62
-},{134,10,556},{134,11,278},{137,0,103},{7,10,544},{8,10,719},{138,10,61},{4,10,
-5},{5,10,498},{8,10,637},{137,10,521},{7,0,777},{12,0,229},{12,0,239},{15,0,12},
-{12,11,229},{12,11,239},{143,11,12},{6,0,26},{7,11,388},{7,11,644},{139,11,781},
-{7,11,229},{8,11,59},{9,11,190},{9,11,257},{10,11,378},{140,11,191},{133,10,927}
-,{135,10,1441},{4,10,893},{5,10,780},{133,10,893},{4,0,414},{5,0,467},{9,0,654},
-{10,0,451},{12,0,59},{141,0,375},{142,0,173},{135,0,17},{7,0,1350},{133,10,238},
-{135,0,955},{4,0,960},{10,0,887},{12,0,753},{18,0,161},{18,0,162},{152,0,19},{
-136,11,344},{6,10,1729},{137,11,288},{132,11,660},{4,0,217},{5,0,710},{7,0,760},
-{7,0,1926},{9,0,428},{9,0,708},{10,0,254},{10,0,296},{10,0,720},{11,0,109},{11,0
-,255},{12,0,165},{12,0,315},{13,0,107},{13,0,203},{14,0,54},{14,0,99},{14,0,114}
-,{14,0,388},{16,0,85},{17,0,9},{17,0,33},{20,0,25},{20,0,28},{20,0,29},{21,0,9},
-{21,0,10},{21,0,34},{22,0,17},{4,10,60},{7,10,1800},{8,10,314},{9,10,700},{139,
-10,487},{7,11,1035},{138,11,737},{7,11,690},{9,11,217},{9,11,587},{140,11,521},{
-6,0,919},{7,11,706},{7,11,1058},{138,11,538},{7,10,1853},{138,10,437},{136,10,
-419},{6,0,280},{10,0,502},{11,0,344},{140,0,38},{5,0,45},{7,0,1161},{11,0,448},{
-11,0,880},{13,0,139},{13,0,407},{15,0,16},{17,0,95},{18,0,66},{18,0,88},{18,0,
-123},{149,0,7},{11,11,92},{11,11,196},{11,11,409},{11,11,450},{11,11,666},{11,11
-,777},{12,11,262},{13,11,385},{13,11,393},{15,11,115},{16,11,45},{145,11,82},{
-136,0,777},{134,11,1744},{4,0,410},{7,0,521},{133,10,828},{134,0,673},{7,0,1110}
-,{7,0,1778},{7,10,176},{135,10,178},{5,10,806},{7,11,268},{7,10,1976},{136,11,
-569},{4,11,733},{9,11,194},{10,11,92},{11,11,198},{12,11,84},{12,11,87},{13,11,
-128},{144,11,74},{5,0,341},{7,0,1129},{11,0,414},{4,10,51},{6,10,4},{7,10,591},{
-7,10,849},{7,10,951},{7,10,1613},{7,10,1760},{7,10,1988},{9,10,434},{10,10,754},
-{11,10,25},{139,10,37},{133,10,902},{135,10,928},{135,0,787},{132,0,436},{134,10
-,270},{7,0,1587},{135,0,1707},{6,0,377},{7,0,1025},{9,0,613},{145,0,104},{7,11,
-982},{7,11,1361},{10,11,32},{143,11,56},{139,0,96},{132,0,451},{132,10,416},{142
-,10,372},{5,10,152},{5,10,197},{7,11,306},{7,10,340},{7,10,867},{10,10,548},{10,
-10,581},{11,10,6},{12,10,3},{12,10,19},{14,10,110},{142,10,289},{134,0,680},{134
-,11,609},{7,0,483},{7,10,190},{8,10,28},{8,10,141},{8,10,444},{8,10,811},{9,10,
-468},{11,10,334},{12,10,24},{12,10,386},{140,10,576},{10,0,916},{133,10,757},{5,
-10,721},{135,10,1553},{133,11,178},{134,0,937},{132,10,898},{133,0,739},{147,0,
-82},{135,0,663},{146,0,128},{5,10,277},{141,10,247},{134,0,1087},{132,10,435},{6
-,11,381},{7,11,645},{7,11,694},{136,11,546},{7,0,503},{135,0,1885},{6,0,1965},{8
-,0,925},{138,0,955},{4,0,113},{5,0,163},{5,0,735},{7,0,1009},{9,0,9},{9,0,771},{
-12,0,90},{13,0,138},{13,0,410},{143,0,128},{4,0,324},{138,0,104},{7,0,460},{5,10
-,265},{134,10,212},{133,11,105},{7,11,261},{7,11,1107},{7,11,1115},{7,11,1354},{
-7,11,1588},{7,11,1705},{7,11,1902},{9,11,465},{10,11,248},{10,11,349},{10,11,647
-},{11,11,527},{11,11,660},{11,11,669},{12,11,529},{141,11,305},{5,11,438},{9,11,
-694},{12,11,627},{141,11,210},{152,11,11},{4,0,935},{133,0,823},{132,10,702},{5,
-0,269},{7,0,434},{7,0,891},{8,0,339},{9,0,702},{11,0,594},{11,0,718},{17,0,100},
-{5,10,808},{135,10,2045},{7,0,1014},{9,0,485},{141,0,264},{134,0,1713},{7,0,1810
-},{11,0,866},{12,0,103},{13,0,495},{140,11,233},{4,0,423},{10,0,949},{138,0,1013
-},{135,0,900},{8,11,25},{138,11,826},{5,10,166},{8,10,739},{140,10,511},{134,0,
-2018},{7,11,1270},{139,11,612},{4,10,119},{5,10,170},{5,10,447},{7,10,1708},{7,
-10,1889},{9,10,357},{9,10,719},{12,10,486},{140,10,596},{12,0,574},{140,11,574},
-{132,11,308},{6,0,964},{6,0,1206},{134,0,1302},{4,10,450},{135,10,1158},{135,11,
-150},{136,11,649},{14,0,213},{148,0,38},{9,11,45},{9,11,311},{141,11,42},{134,11
-,521},{7,10,1375},{7,10,1466},{138,10,331},{132,10,754},{5,11,339},{7,11,1442},{
-14,11,3},{15,11,41},{147,11,66},{136,11,378},{134,0,1022},{5,10,850},{136,10,799
-},{142,0,143},{135,0,2029},{134,11,1628},{8,0,523},{150,0,34},{5,0,625},{135,0,
-1617},{7,0,275},{7,10,238},{7,10,2033},{8,10,120},{8,10,188},{8,10,659},{9,10,
-598},{10,10,466},{12,10,342},{12,10,588},{13,10,503},{14,10,246},{143,10,92},{7,
-0,37},{8,0,425},{8,0,693},{9,0,720},{10,0,380},{10,0,638},{11,0,273},{11,0,473},
-{12,0,61},{143,0,43},{135,11,829},{135,0,1943},{132,0,765},{5,11,486},{135,11,
-1349},{7,11,1635},{8,11,17},{10,11,217},{138,11,295},{4,10,201},{7,10,1744},{8,
-10,602},{11,10,247},{11,10,826},{145,10,65},{138,11,558},{11,0,551},{142,0,159},
-{8,10,164},{146,10,62},{139,11,176},{132,0,168},{136,0,1010},{134,0,1994},{135,0
-,91},{138,0,532},{135,10,1243},{135,0,1884},{132,10,907},{5,10,100},{10,10,329},
-{12,10,416},{149,10,29},{134,11,447},{132,10,176},{5,10,636},{5,10,998},{7,10,9}
-,{7,10,1508},{8,10,26},{9,10,317},{9,10,358},{10,10,210},{10,10,292},{10,10,533}
-,{11,10,555},{12,10,526},{12,10,607},{13,10,263},{13,10,459},{142,10,271},{4,11,
-609},{135,11,756},{6,0,15},{7,0,70},{10,0,240},{147,0,93},{4,11,930},{133,11,947
-},{134,0,1227},{134,0,1534},{133,11,939},{133,11,962},{5,11,651},{8,11,170},{9,
-11,61},{9,11,63},{10,11,23},{10,11,37},{10,11,834},{11,11,4},{11,11,187},{11,11,
-281},{11,11,503},{11,11,677},{12,11,96},{12,11,130},{12,11,244},{14,11,5},{14,11
-,40},{14,11,162},{14,11,202},{146,11,133},{4,11,406},{5,11,579},{12,11,492},{150
-,11,15},{139,0,392},{6,10,610},{10,10,127},{141,10,27},{7,0,655},{7,0,1844},{136
-,10,119},{4,0,145},{6,0,176},{7,0,395},{137,0,562},{132,0,501},{140,11,145},{136
-,0,1019},{134,0,509},{139,0,267},{6,11,17},{7,11,16},{7,11,1001},{7,11,1982},{9,
-11,886},{10,11,489},{10,11,800},{11,11,782},{12,11,320},{13,11,467},{14,11,145},
-{14,11,387},{143,11,119},{145,11,17},{6,0,1099},{133,11,458},{7,11,1983},{8,11,0
-},{8,11,171},{9,11,120},{9,11,732},{10,11,473},{11,11,656},{11,11,998},{18,11,0}
-,{18,11,2},{147,11,21},{12,11,427},{146,11,38},{10,0,948},{138,0,968},{7,10,126}
-,{136,10,84},{136,10,790},{4,0,114},{9,0,492},{13,0,462},{142,0,215},{6,10,64},{
-12,10,377},{141,10,309},{4,0,77},{5,0,361},{6,0,139},{6,0,401},{6,0,404},{7,0,
-413},{7,0,715},{7,0,1716},{11,0,279},{12,0,179},{12,0,258},{13,0,244},{142,0,358
-},{134,0,1717},{7,0,772},{7,0,1061},{7,0,1647},{8,0,82},{11,0,250},{11,0,607},{
-12,0,311},{12,0,420},{13,0,184},{13,0,367},{7,10,1104},{11,10,269},{11,10,539},{
-11,10,627},{11,10,706},{11,10,975},{12,10,248},{12,10,434},{12,10,600},{12,10,
-622},{13,10,297},{13,10,485},{14,10,69},{14,10,409},{143,10,108},{135,0,724},{4,
-11,512},{4,11,519},{133,11,342},{134,0,1133},{145,11,29},{11,10,977},{141,10,507
-},{6,0,841},{6,0,1042},{6,0,1194},{10,0,993},{140,0,1021},{6,11,31},{7,11,491},{
-7,11,530},{8,11,592},{9,10,34},{11,11,53},{11,10,484},{11,11,779},{12,11,167},{
-12,11,411},{14,11,14},{14,11,136},{15,11,72},{16,11,17},{144,11,72},{4,0,1021},{
-6,0,2037},{133,11,907},{7,0,373},{8,0,335},{8,0,596},{9,0,488},{6,10,1700},{7,10
-,293},{7,10,382},{7,10,1026},{7,10,1087},{7,10,2027},{8,10,252},{8,10,727},{8,10
-,729},{9,10,30},{9,10,199},{9,10,231},{9,10,251},{9,10,334},{9,10,361},{9,10,712
-},{10,10,55},{10,10,60},{10,10,232},{10,10,332},{10,10,384},{10,10,396},{10,10,
-504},{10,10,542},{10,10,652},{11,10,20},{11,10,48},{11,10,207},{11,10,291},{11,
-10,298},{11,10,342},{11,10,365},{11,10,394},{11,10,620},{11,10,705},{11,10,1017}
-,{12,10,123},{12,10,340},{12,10,406},{12,10,643},{13,10,61},{13,10,269},{13,10,
-311},{13,10,319},{13,10,486},{14,10,234},{15,10,62},{15,10,85},{16,10,71},{18,10
-,119},{148,10,105},{150,0,37},{4,11,208},{5,11,106},{6,11,531},{8,11,408},{9,11,
-188},{138,11,572},{132,0,564},{6,0,513},{135,0,1052},{132,0,825},{9,0,899},{140,
-11,441},{134,0,778},{133,11,379},{7,0,1417},{12,0,382},{17,0,48},{152,0,12},{132
-,11,241},{7,0,1116},{6,10,379},{7,10,270},{8,10,176},{8,10,183},{9,10,432},{9,10
-,661},{12,10,247},{12,10,617},{146,10,125},{5,10,792},{133,10,900},{6,0,545},{7,
-0,565},{7,0,1669},{10,0,114},{11,0,642},{140,0,618},{133,0,5},{138,11,7},{132,11
-,259},{135,0,192},{134,0,701},{136,0,763},{135,10,1979},{4,10,901},{133,10,776},
-{10,0,755},{147,0,29},{133,0,759},{4,11,173},{5,11,312},{5,11,512},{135,11,1285}
-,{7,11,1603},{7,11,1691},{9,11,464},{11,11,195},{12,11,279},{12,11,448},{14,11,
-11},{147,11,102},{7,0,370},{7,0,1007},{7,0,1177},{135,0,1565},{135,0,1237},{4,0,
-87},{5,0,250},{141,0,298},{4,11,452},{5,11,583},{5,11,817},{6,11,433},{7,11,593}
-,{7,11,720},{7,11,1378},{8,11,161},{9,11,284},{10,11,313},{139,11,886},{4,11,547
-},{135,11,1409},{136,11,722},{4,10,37},{5,10,334},{135,10,1253},{132,10,508},{12
-,0,107},{146,0,31},{8,11,420},{139,11,193},{135,0,814},{135,11,409},{140,0,991},
-{4,0,57},{7,0,1195},{7,0,1438},{7,0,1548},{7,0,1835},{7,0,1904},{9,0,757},{10,0,
-604},{139,0,519},{132,0,540},{138,11,308},{132,10,533},{136,0,608},{144,11,65},{
-4,0,1014},{134,0,2029},{4,0,209},{7,0,902},{5,11,1002},{136,11,745},{134,0,2030}
-,{6,0,303},{7,0,335},{7,0,1437},{7,0,1668},{8,0,553},{8,0,652},{8,0,656},{9,0,
-558},{11,0,743},{149,0,18},{5,11,575},{6,11,354},{135,11,701},{4,11,239},{6,11,
-477},{7,11,1607},{11,11,68},{139,11,617},{132,0,559},{8,0,527},{18,0,60},{147,0,
-24},{133,10,920},{138,0,511},{133,0,1017},{133,0,675},{138,10,391},{11,0,156},{
-135,10,1952},{138,11,369},{132,11,367},{133,0,709},{6,0,698},{134,0,887},{142,10
-,126},{134,0,1745},{132,10,483},{13,11,299},{142,11,75},{133,0,714},{7,0,8},{136
-,0,206},{138,10,480},{4,11,694},{9,10,495},{146,10,104},{7,11,1248},{11,11,621},
-{139,11,702},{140,11,687},{132,0,776},{139,10,1009},{135,0,1272},{134,0,1059},{8
-,10,653},{13,10,93},{147,10,14},{135,11,213},{136,0,406},{133,10,172},{132,0,947
-},{8,0,175},{10,0,168},{138,0,573},{132,0,870},{6,0,1567},{151,11,28},{134,11,
-472},{5,10,260},{136,11,132},{4,11,751},{11,11,390},{140,11,32},{4,11,409},{133,
-11,78},{12,0,554},{6,11,473},{145,11,105},{133,0,784},{8,0,908},{136,11,306},{
-139,0,882},{6,0,358},{7,0,1393},{8,0,396},{10,0,263},{14,0,154},{16,0,48},{17,0,
-8},{7,11,1759},{8,11,396},{10,11,263},{14,11,154},{16,11,48},{145,11,8},{13,11,
-163},{13,11,180},{18,11,78},{148,11,35},{14,0,32},{18,0,85},{20,0,2},{152,0,16},
-{7,0,228},{10,0,770},{8,10,167},{8,10,375},{9,10,82},{9,10,561},{138,10,620},{
-132,0,845},{9,0,14},{9,0,441},{10,0,306},{139,0,9},{11,0,966},{12,0,287},{13,0,
-342},{13,0,402},{15,0,110},{15,0,163},{8,10,194},{136,10,756},{134,0,1578},{4,0,
-967},{6,0,1820},{6,0,1847},{140,0,716},{136,0,594},{7,0,1428},{7,0,1640},{7,0,
-1867},{9,0,169},{9,0,182},{9,0,367},{9,0,478},{9,0,506},{9,0,551},{9,0,557},{9,0
-,648},{9,0,697},{9,0,705},{9,0,725},{9,0,787},{9,0,794},{10,0,198},{10,0,214},{
-10,0,267},{10,0,275},{10,0,456},{10,0,551},{10,0,561},{10,0,613},{10,0,627},{10,
-0,668},{10,0,675},{10,0,691},{10,0,695},{10,0,707},{10,0,715},{11,0,183},{11,0,
-201},{11,0,244},{11,0,262},{11,0,352},{11,0,439},{11,0,493},{11,0,572},{11,0,591
-},{11,0,608},{11,0,611},{11,0,646},{11,0,674},{11,0,711},{11,0,751},{11,0,761},{
-11,0,776},{11,0,785},{11,0,850},{11,0,853},{11,0,862},{11,0,865},{11,0,868},{11,
-0,875},{11,0,898},{11,0,902},{11,0,903},{11,0,910},{11,0,932},{11,0,942},{11,0,
-957},{11,0,967},{11,0,972},{12,0,148},{12,0,195},{12,0,220},{12,0,237},{12,0,318
-},{12,0,339},{12,0,393},{12,0,445},{12,0,450},{12,0,474},{12,0,505},{12,0,509},{
-12,0,533},{12,0,591},{12,0,594},{12,0,597},{12,0,621},{12,0,633},{12,0,642},{13,
-0,59},{13,0,60},{13,0,145},{13,0,239},{13,0,250},{13,0,329},{13,0,344},{13,0,365
-},{13,0,372},{13,0,387},{13,0,403},{13,0,414},{13,0,456},{13,0,470},{13,0,478},{
-13,0,483},{13,0,489},{14,0,55},{14,0,57},{14,0,81},{14,0,90},{14,0,148},{14,0,
-239},{14,0,266},{14,0,321},{14,0,326},{14,0,327},{14,0,330},{14,0,347},{14,0,355
-},{14,0,401},{14,0,404},{14,0,411},{14,0,414},{14,0,416},{14,0,420},{15,0,61},{
-15,0,74},{15,0,87},{15,0,88},{15,0,94},{15,0,96},{15,0,116},{15,0,149},{15,0,154
-},{16,0,50},{16,0,63},{16,0,73},{17,0,2},{17,0,66},{17,0,92},{17,0,103},{17,0,
-112},{17,0,120},{18,0,50},{18,0,54},{18,0,82},{18,0,86},{18,0,90},{18,0,111},{18
-,0,115},{18,0,156},{19,0,40},{19,0,79},{20,0,78},{21,0,22},{135,11,883},{5,0,161
-},{135,0,839},{4,0,782},{13,11,293},{142,11,56},{133,11,617},{139,11,50},{135,10
-,22},{145,0,64},{5,10,639},{7,10,1249},{139,10,896},{138,0,998},{135,11,2042},{4
-,11,546},{142,11,233},{6,0,1043},{134,0,1574},{134,0,1496},{4,10,102},{7,10,815}
-,{7,10,1699},{139,10,964},{12,0,781},{142,0,461},{4,11,313},{133,11,577},{6,0,
-639},{6,0,1114},{137,0,817},{8,11,184},{141,11,433},{7,0,1814},{135,11,935},{10,
-0,997},{140,0,958},{4,0,812},{137,11,625},{132,10,899},{136,10,795},{5,11,886},{
-6,11,46},{6,11,1790},{7,11,14},{7,11,732},{7,11,1654},{8,11,95},{8,11,327},{8,11
-,616},{10,11,598},{10,11,769},{11,11,134},{11,11,747},{12,11,378},{142,11,97},{
-136,0,139},{6,10,52},{9,10,104},{9,10,559},{12,10,308},{147,10,87},{133,11,1021}
-,{132,10,604},{132,10,301},{136,10,779},{7,0,643},{136,0,236},{132,11,153},{134,
-0,1172},{147,10,32},{133,11,798},{6,0,1338},{132,11,587},{6,11,598},{7,11,42},{8
-,11,695},{10,11,212},{11,11,158},{14,11,196},{145,11,85},{135,10,508},{5,11,957}
-,{5,11,1008},{135,11,249},{4,11,129},{135,11,465},{5,0,54},{7,11,470},{7,11,1057
-},{7,11,1201},{9,11,755},{11,11,906},{140,11,527},{7,11,908},{146,11,7},{5,11,
-148},{136,11,450},{144,11,1},{4,0,256},{135,0,1488},{9,0,351},{6,10,310},{7,10,
-1849},{8,10,72},{8,10,272},{8,10,431},{9,10,12},{10,10,563},{10,10,630},{10,10,
-796},{10,10,810},{11,10,367},{11,10,599},{11,10,686},{140,10,672},{6,0,1885},{6,
-0,1898},{6,0,1899},{140,0,955},{4,0,714},{133,0,469},{6,0,1270},{134,0,1456},{
-132,0,744},{6,0,313},{7,10,537},{8,10,64},{9,10,127},{10,10,496},{12,10,510},{
-141,10,384},{4,11,217},{4,10,244},{5,11,710},{7,10,233},{7,11,1926},{9,11,428},{
-9,11,708},{10,11,254},{10,11,296},{10,11,720},{11,11,109},{11,11,255},{12,11,165
-},{12,11,315},{13,11,107},{13,11,203},{14,11,54},{14,11,99},{14,11,114},{14,11,
-388},{16,11,85},{17,11,9},{17,11,33},{20,11,25},{20,11,28},{20,11,29},{21,11,9},
-{21,11,10},{21,11,34},{150,11,17},{138,0,402},{7,0,969},{146,0,55},{8,0,50},{137
-,0,624},{134,0,1355},{132,0,572},{134,10,1650},{10,10,702},{139,10,245},{10,0,
-847},{142,0,445},{6,0,43},{7,0,38},{8,0,248},{138,0,513},{133,0,369},{137,10,338
-},{133,0,766},{133,0,363},{133,10,896},{8,11,392},{11,11,54},{13,11,173},{13,11,
-294},{148,11,7},{134,0,678},{7,11,1230},{136,11,531},{6,0,258},{140,0,409},{5,0,
-249},{148,0,82},{7,10,1117},{136,10,539},{5,0,393},{6,0,378},{7,0,1981},{9,0,32}
-,{9,0,591},{10,0,685},{10,0,741},{142,0,382},{133,0,788},{134,0,1281},{134,0,
-1295},{7,0,1968},{141,0,509},{4,0,61},{5,0,58},{5,0,171},{5,0,683},{6,0,291},{6,
-0,566},{7,0,1650},{11,0,523},{12,0,273},{12,0,303},{15,0,39},{143,0,111},{6,0,
-706},{134,0,1283},{134,0,589},{135,11,1433},{133,11,435},{7,0,1059},{13,0,54},{5
-,10,4},{5,10,810},{6,10,13},{6,10,538},{6,10,1690},{6,10,1726},{7,10,1819},{8,10
-,148},{8,10,696},{8,10,791},{12,10,125},{143,10,9},{135,10,1268},{5,11,85},{6,11
-,419},{7,11,134},{7,11,305},{7,11,361},{7,11,1337},{8,11,71},{140,11,519},{137,0
-,824},{140,11,688},{5,11,691},{7,11,345},{7,10,1385},{9,11,94},{11,10,582},{11,
-10,650},{11,10,901},{11,10,949},{12,11,169},{12,10,232},{12,10,236},{13,10,413},
-{13,10,501},{146,10,116},{4,0,917},{133,0,1005},{7,0,1598},{5,11,183},{6,11,582}
-,{9,11,344},{10,11,679},{140,11,435},{4,10,925},{5,10,803},{8,10,698},{138,10,
-828},{132,0,919},{135,11,511},{139,10,992},{4,0,255},{5,0,302},{6,0,132},{7,0,
-128},{7,0,283},{7,0,1299},{10,0,52},{10,0,514},{11,0,925},{13,0,92},{142,0,309},
-{134,0,1369},{135,10,1847},{134,0,328},{7,11,1993},{136,11,684},{133,10,383},{
-137,0,173},{134,11,583},{134,0,1411},{19,0,65},{5,11,704},{8,11,357},{10,11,745}
-,{14,11,426},{17,11,94},{147,11,57},{9,10,660},{138,10,347},{4,11,179},{5,11,198
-},{133,11,697},{7,11,347},{7,11,971},{8,11,181},{138,11,711},{141,0,442},{11,0,
-842},{11,0,924},{13,0,317},{13,0,370},{13,0,469},{13,0,471},{14,0,397},{18,0,69}
-,{18,0,145},{7,10,572},{9,10,592},{11,10,680},{12,10,356},{140,10,550},{14,11,19
-},{14,11,28},{144,11,29},{136,0,534},{4,11,243},{5,11,203},{7,11,19},{7,11,71},{
-7,11,113},{10,11,405},{11,11,357},{142,11,240},{6,0,210},{10,0,845},{138,0,862},
-{7,11,1351},{9,11,581},{10,11,639},{11,11,453},{140,11,584},{7,11,1450},{139,11,
-99},{10,0,892},{12,0,719},{144,0,105},{4,0,284},{6,0,223},{134,11,492},{5,11,134
-},{6,11,408},{6,11,495},{135,11,1593},{136,0,529},{137,0,807},{4,0,218},{7,0,526
-},{143,0,137},{6,0,1444},{142,11,4},{132,11,665},{4,0,270},{5,0,192},{6,0,332},{
-7,0,1322},{4,11,248},{7,11,137},{137,11,349},{140,0,661},{7,0,1517},{11,0,597},{
-14,0,76},{14,0,335},{20,0,33},{7,10,748},{139,10,700},{5,11,371},{135,11,563},{
-146,11,57},{133,10,127},{133,0,418},{4,11,374},{7,11,547},{7,11,1700},{7,11,1833
-},{139,11,858},{6,10,198},{140,10,83},{7,11,1812},{13,11,259},{13,11,356},{14,11
-,242},{147,11,114},{7,0,379},{8,0,481},{9,0,377},{5,10,276},{6,10,55},{135,10,
-1369},{138,11,286},{5,0,1003},{6,0,149},{6,10,1752},{136,10,726},{8,0,262},{9,0,
-627},{10,0,18},{11,0,214},{11,0,404},{11,0,457},{11,0,780},{11,0,913},{13,0,401}
-,{14,0,200},{6,11,1647},{7,11,1552},{7,11,2010},{9,11,494},{137,11,509},{135,0,
-742},{136,0,304},{132,0,142},{133,10,764},{6,10,309},{7,10,331},{138,10,550},{
-135,10,1062},{6,11,123},{7,11,214},{7,10,986},{9,11,728},{10,11,157},{11,11,346}
-,{11,11,662},{143,11,106},{135,10,1573},{7,0,925},{137,0,799},{4,0,471},{5,0,51}
-,{6,0,602},{8,0,484},{138,0,195},{136,0,688},{132,0,697},{6,0,1169},{6,0,1241},{
-6,10,194},{7,10,133},{10,10,493},{10,10,570},{139,10,664},{140,0,751},{7,0,929},
-{10,0,452},{11,0,878},{16,0,33},{5,10,24},{5,10,569},{6,10,3},{6,10,119},{6,10,
-143},{6,10,440},{7,10,599},{7,10,1686},{7,10,1854},{8,10,424},{9,10,43},{9,10,
-584},{9,10,760},{10,10,328},{11,10,159},{11,10,253},{12,10,487},{140,10,531},{4,
-11,707},{13,11,106},{18,11,49},{147,11,41},{5,0,221},{5,11,588},{134,11,393},{
-134,0,1437},{6,11,211},{7,11,1690},{11,11,486},{140,11,369},{5,10,14},{5,10,892}
-,{6,10,283},{7,10,234},{136,10,537},{4,0,988},{136,0,955},{135,0,1251},{4,10,126
-},{8,10,635},{147,10,34},{4,10,316},{135,10,1561},{137,10,861},{4,10,64},{5,10,
-352},{5,10,720},{6,10,368},{139,10,359},{134,0,192},{4,0,132},{5,0,69},{135,0,
-1242},{7,10,1577},{10,10,304},{10,10,549},{12,10,365},{13,10,220},{13,10,240},{
-142,10,33},{4,0,111},{7,0,865},{134,11,219},{5,11,582},{6,11,1646},{7,11,99},{7,
-11,1962},{7,11,1986},{8,11,515},{8,11,773},{9,11,23},{9,11,491},{12,11,620},{14,
-11,52},{145,11,50},{132,0,767},{7,11,568},{148,11,21},{6,0,42},{7,0,1416},{7,0,
-2005},{8,0,131},{8,0,466},{9,0,672},{13,0,252},{20,0,103},{133,11,851},{135,0,
-1050},{6,10,175},{137,10,289},{5,10,432},{133,10,913},{6,0,44},{136,0,368},{135,
-11,784},{132,0,570},{133,0,120},{139,10,595},{140,0,29},{6,0,227},{135,0,1589},{
-4,11,98},{7,11,1365},{9,11,422},{9,11,670},{10,11,775},{11,11,210},{13,11,26},{
-13,11,457},{141,11,476},{140,10,80},{5,10,931},{134,10,1698},{133,0,522},{134,0,
-1120},{135,0,1529},{12,0,739},{14,0,448},{142,0,467},{11,10,526},{11,10,939},{
-141,10,290},{5,10,774},{6,10,1637},{6,10,1686},{134,10,1751},{6,0,1667},{135,0,
-2036},{7,10,1167},{11,10,934},{13,10,391},{145,10,76},{137,11,147},{6,10,260},{7
-,10,1484},{11,11,821},{12,11,110},{12,11,153},{18,11,41},{150,11,19},{6,0,511},{
-12,0,132},{134,10,573},{5,0,568},{6,0,138},{135,0,1293},{132,0,1020},{8,0,258},{
-9,0,208},{137,0,359},{4,0,565},{8,0,23},{136,0,827},{134,0,344},{4,0,922},{5,0,
-1023},{13,11,477},{14,11,120},{148,11,61},{134,0,240},{5,11,209},{6,11,30},{11,
-11,56},{139,11,305},{6,0,171},{7,0,1002},{7,0,1324},{9,0,415},{14,0,230},{18,0,
-68},{4,10,292},{4,10,736},{5,10,871},{6,10,1689},{7,10,1944},{137,10,580},{9,11,
-635},{139,11,559},{4,11,150},{5,11,303},{134,11,327},{6,10,63},{135,10,920},{133
-,10,793},{8,11,192},{10,11,78},{10,11,555},{11,11,308},{13,11,359},{147,11,95},{
-135,11,786},{135,11,1712},{136,0,402},{6,0,754},{6,11,1638},{7,11,79},{7,11,496}
-,{9,11,138},{10,11,336},{11,11,12},{12,11,412},{12,11,440},{142,11,305},{4,0,716
-},{141,0,31},{133,0,982},{8,0,691},{8,0,731},{5,10,67},{6,10,62},{6,10,374},{135
-,10,1391},{9,10,790},{140,10,47},{139,11,556},{151,11,1},{7,11,204},{7,11,415},{
-8,11,42},{10,11,85},{11,11,33},{11,11,564},{12,11,571},{149,11,1},{8,0,888},{7,
-11,610},{135,11,1501},{4,10,391},{135,10,1169},{5,0,847},{9,0,840},{138,0,803},{
-137,0,823},{134,0,785},{8,0,152},{9,0,53},{9,0,268},{9,0,901},{10,0,518},{10,0,
-829},{11,0,188},{13,0,74},{14,0,46},{15,0,17},{15,0,33},{17,0,40},{18,0,36},{19,
-0,20},{22,0,1},{152,0,2},{4,11,3},{5,11,247},{5,11,644},{7,11,744},{7,11,1207},{
-7,11,1225},{7,11,1909},{146,11,147},{136,0,532},{135,0,681},{132,10,271},{140,0,
-314},{140,0,677},{4,0,684},{136,0,384},{5,11,285},{9,11,67},{13,11,473},{143,11,
-82},{4,10,253},{5,10,544},{7,10,300},{137,10,340},{7,0,110},{7,0,447},{8,0,290},
-{8,0,591},{9,0,382},{9,0,649},{11,0,71},{11,0,155},{11,0,313},{12,0,5},{13,0,325
-},{142,0,287},{134,0,1818},{136,0,1007},{138,0,321},{7,0,360},{7,0,425},{9,0,66}
-,{9,0,278},{138,0,644},{133,10,818},{5,0,385},{5,10,541},{6,10,94},{6,10,499},{7
-,10,230},{139,10,321},{4,10,920},{5,10,25},{5,10,790},{6,10,457},{7,10,853},{136
-,10,788},{4,0,900},{133,0,861},{5,0,254},{7,0,985},{136,0,73},{7,0,1959},{136,0,
-683},{134,10,1765},{133,10,822},{132,10,634},{4,11,29},{6,11,532},{7,11,1628},{7
-,11,1648},{9,11,303},{9,11,350},{10,11,433},{11,11,97},{11,11,557},{11,11,745},{
-12,11,289},{12,11,335},{12,11,348},{12,11,606},{13,11,116},{13,11,233},{13,11,
-466},{14,11,181},{14,11,209},{14,11,232},{14,11,236},{14,11,300},{16,11,41},{148
-,11,97},{19,0,86},{6,10,36},{7,10,658},{136,10,454},{135,11,1692},{132,0,725},{5
-,11,501},{7,11,1704},{9,11,553},{11,11,520},{12,11,557},{141,11,249},{134,0,196}
-,{133,0,831},{136,0,723},{7,0,1897},{13,0,80},{13,0,437},{145,0,74},{4,0,992},{6
-,0,627},{136,0,994},{135,11,1294},{132,10,104},{5,0,848},{6,0,66},{136,0,764},{4
-,0,36},{7,0,1387},{10,0,205},{139,0,755},{6,0,1046},{134,0,1485},{134,0,950},{
-132,0,887},{14,0,450},{148,0,111},{7,0,620},{7,0,831},{9,10,542},{9,10,566},{138
-,10,728},{6,0,165},{138,0,388},{139,10,263},{4,0,719},{135,0,155},{138,10,468},{
-6,11,453},{144,11,36},{134,11,129},{5,0,533},{7,0,755},{138,0,780},{134,0,1465},
-{4,0,353},{6,0,146},{6,0,1789},{7,0,427},{7,0,990},{7,0,1348},{9,0,665},{9,0,898
-},{11,0,893},{142,0,212},{7,10,87},{142,10,288},{4,0,45},{135,0,1257},{12,0,7},{
-7,10,988},{7,10,1939},{9,10,64},{9,10,502},{12,10,34},{13,10,12},{13,10,234},{
-147,10,77},{4,0,607},{5,11,60},{6,11,504},{7,11,614},{7,11,1155},{140,11,0},{135
-,10,141},{8,11,198},{11,11,29},{140,11,534},{140,0,65},{136,0,816},{132,10,619},
-{139,0,88},{5,10,246},{8,10,189},{9,10,355},{9,10,512},{10,10,124},{10,10,453},{
-11,10,143},{11,10,416},{11,10,859},{141,10,341},{4,11,379},{135,11,1397},{4,0,
-600},{137,0,621},{133,0,367},{134,0,561},{6,0,559},{134,0,1691},{6,0,585},{134,
-11,585},{135,11,1228},{4,11,118},{5,10,678},{6,11,274},{6,11,361},{7,11,75},{141
-,11,441},{135,11,1818},{137,11,841},{5,0,573},{6,0,287},{7,10,862},{7,10,1886},{
-138,10,179},{132,10,517},{140,11,693},{5,11,314},{6,11,221},{7,11,419},{10,11,
-650},{11,11,396},{12,11,156},{13,11,369},{14,11,333},{145,11,47},{140,10,540},{
-136,10,667},{11,10,403},{146,10,83},{6,0,672},{133,10,761},{9,0,157},{10,10,131}
-,{140,10,72},{7,0,714},{134,11,460},{134,0,456},{133,0,925},{5,11,682},{135,11,
-1887},{136,11,510},{136,11,475},{133,11,1016},{9,0,19},{7,11,602},{8,11,179},{10
-,11,781},{140,11,126},{6,11,329},{138,11,111},{6,0,822},{134,0,1473},{144,11,86}
-,{11,0,113},{139,11,113},{5,11,821},{134,11,1687},{133,10,449},{7,0,463},{17,0,
-69},{136,10,103},{7,10,2028},{138,10,641},{6,0,193},{7,0,240},{7,0,1682},{10,0,
-51},{10,0,640},{11,0,410},{13,0,82},{14,0,247},{14,0,331},{142,0,377},{6,0,471},
-{11,0,411},{142,0,2},{5,11,71},{7,11,1407},{9,11,388},{9,11,704},{10,11,261},{10
-,11,619},{11,11,547},{11,11,619},{143,11,157},{136,0,633},{135,0,1148},{6,0,554}
-,{7,0,1392},{12,0,129},{7,10,1274},{7,10,1386},{7,11,2008},{9,11,337},{10,11,517
-},{146,10,87},{7,0,803},{8,0,542},{6,10,187},{7,10,1203},{8,10,380},{14,10,117},
-{149,10,28},{6,10,297},{7,10,793},{139,10,938},{8,0,438},{11,0,363},{7,10,464},{
-11,10,105},{12,10,231},{14,10,386},{15,10,102},{148,10,75},{5,11,16},{6,11,86},{
-6,11,603},{7,11,292},{7,11,561},{8,11,257},{8,11,382},{9,11,721},{9,11,778},{11,
-11,581},{140,11,466},{6,0,717},{4,11,486},{133,11,491},{132,0,875},{132,11,72},{
-6,11,265},{135,11,847},{4,0,237},{135,0,514},{6,0,392},{7,0,65},{135,0,2019},{
-140,11,261},{135,11,922},{137,11,404},{12,0,563},{14,0,101},{18,0,129},{7,10,
-1010},{11,10,733},{11,10,759},{13,10,34},{146,10,45},{7,10,1656},{9,10,369},{10,
-10,338},{10,10,490},{11,10,154},{11,10,545},{11,10,775},{13,10,77},{141,10,274},
-{4,0,444},{10,0,146},{140,0,9},{139,11,163},{7,0,1260},{135,0,1790},{9,0,222},{
-10,0,43},{139,0,900},{137,11,234},{138,0,971},{137,0,761},{134,0,699},{136,11,
-434},{6,0,1116},{7,0,1366},{5,10,20},{6,11,197},{6,10,298},{7,10,659},{8,11,205}
-,{137,10,219},{132,11,490},{11,11,820},{150,11,51},{7,10,1440},{11,10,854},{11,
-10,872},{11,10,921},{12,10,551},{13,10,472},{142,10,367},{140,11,13},{132,0,829}
-,{12,0,242},{132,10,439},{136,10,669},{6,0,593},{6,11,452},{7,11,312},{138,11,
-219},{4,11,333},{9,11,176},{12,11,353},{141,11,187},{7,0,36},{8,0,201},{136,0,
-605},{140,0,224},{132,10,233},{134,0,1430},{134,0,1806},{4,0,523},{133,0,638},{6
-,0,1889},{9,0,958},{9,0,971},{9,0,976},{12,0,796},{12,0,799},{12,0,808},{12,0,
-835},{12,0,836},{12,0,914},{12,0,946},{15,0,216},{15,0,232},{18,0,183},{18,0,187
-},{18,0,194},{18,0,212},{18,0,232},{149,0,49},{132,10,482},{6,0,827},{134,0,1434
-},{135,10,346},{134,0,2043},{6,0,242},{7,0,227},{7,0,1581},{8,0,104},{9,0,113},{
-9,0,220},{9,0,427},{10,0,136},{10,0,239},{11,0,579},{11,0,1023},{13,0,4},{13,0,
-204},{13,0,316},{148,0,86},{134,11,1685},{7,0,148},{8,0,284},{141,0,63},{142,0,
-10},{135,11,584},{134,0,1249},{7,0,861},{135,10,334},{5,10,795},{6,10,1741},{137
-,11,70},{132,0,807},{7,11,135},{8,11,7},{8,11,62},{9,11,243},{10,11,658},{10,11,
-697},{11,11,456},{139,11,756},{9,11,395},{138,11,79},{137,11,108},{147,0,94},{
-136,0,494},{135,11,631},{135,10,622},{7,0,1510},{135,10,1750},{4,10,203},{135,10
-,1936},{7,11,406},{7,11,459},{8,11,606},{139,11,726},{7,0,1306},{8,0,505},{9,0,
-482},{10,0,126},{11,0,225},{12,0,347},{12,0,449},{13,0,19},{14,0,218},{142,0,435
-},{5,0,268},{10,0,764},{12,0,120},{13,0,39},{145,0,127},{142,11,68},{11,10,678},
-{140,10,307},{12,11,268},{12,11,640},{142,11,119},{135,10,2044},{133,11,612},{4,
-11,372},{7,11,482},{8,11,158},{9,11,602},{9,11,615},{10,11,245},{10,11,678},{10,
-11,744},{11,11,248},{139,11,806},{7,10,311},{9,10,308},{140,10,255},{4,0,384},{
-135,0,1022},{5,11,854},{135,11,1991},{135,10,1266},{4,10,400},{5,10,267},{135,10
-,232},{135,0,1703},{9,0,159},{11,0,661},{140,0,603},{4,0,964},{14,0,438},{14,0,
-444},{14,0,456},{22,0,60},{22,0,63},{9,11,106},{9,11,163},{9,11,296},{10,11,167}
-,{10,11,172},{10,11,777},{139,11,16},{136,0,583},{132,0,515},{8,0,632},{8,0,697}
-,{137,0,854},{5,11,195},{135,11,1685},{6,0,1123},{134,0,1365},{134,11,328},{7,11
-,1997},{8,11,730},{139,11,1006},{4,0,136},{133,0,551},{134,0,1782},{7,0,1287},{9
-,0,44},{10,0,552},{10,0,642},{11,0,839},{12,0,274},{12,0,275},{12,0,372},{13,0,
-91},{142,0,125},{5,11,751},{11,11,797},{140,11,203},{133,0,732},{7,0,679},{8,0,
-313},{4,10,100},{135,11,821},{10,0,361},{142,0,316},{134,0,595},{6,0,147},{7,0,
-886},{9,0,753},{138,0,268},{5,10,362},{5,10,443},{6,10,318},{7,10,1019},{139,10,
-623},{5,10,463},{136,10,296},{4,10,454},{5,11,950},{5,11,994},{134,11,351},{138,
-0,137},{5,10,48},{5,10,404},{6,10,557},{7,10,458},{8,10,597},{10,10,455},{10,10,
-606},{11,10,49},{11,10,548},{12,10,476},{13,10,18},{141,10,450},{133,0,414},{135
-,0,1762},{5,11,421},{135,11,47},{5,10,442},{135,10,1984},{134,0,599},{134,0,1749
-},{134,0,1627},{4,0,488},{132,11,350},{137,11,751},{132,0,83},{140,0,676},{133,
-11,967},{7,0,1639},{5,10,55},{140,10,161},{4,11,473},{7,11,623},{8,11,808},{9,11
-,871},{9,11,893},{11,11,38},{11,11,431},{12,11,112},{12,11,217},{12,11,243},{12,
-11,562},{12,11,683},{13,11,141},{13,11,197},{13,11,227},{13,11,406},{13,11,487},
-{14,11,156},{14,11,203},{14,11,224},{14,11,256},{18,11,58},{150,11,0},{133,10,
-450},{7,11,736},{139,11,264},{134,0,278},{4,11,222},{7,11,286},{136,11,629},{135
-,10,869},{140,0,97},{144,0,14},{134,0,1085},{4,10,213},{7,10,223},{136,10,80},{7
-,0,388},{7,0,644},{139,0,781},{132,0,849},{7,0,229},{8,0,59},{9,0,190},{10,0,378
-},{140,0,191},{7,10,381},{7,10,806},{7,10,820},{8,10,354},{8,10,437},{8,10,787},
-{9,10,657},{10,10,58},{10,10,339},{10,10,749},{11,10,914},{12,10,162},{13,10,75}
-,{14,10,106},{14,10,198},{14,10,320},{14,10,413},{146,10,43},{141,11,306},{136,
-10,747},{134,0,1115},{16,0,94},{16,0,108},{136,11,146},{6,0,700},{6,0,817},{134,
-0,1002},{133,10,692},{4,11,465},{135,11,1663},{134,10,191},{6,0,1414},{135,11,
-913},{132,0,660},{7,0,1035},{138,0,737},{6,10,162},{7,10,1960},{136,10,831},{132
-,10,706},{7,0,690},{9,0,217},{9,0,587},{140,0,521},{138,10,426},{135,10,1235},{6
-,11,82},{7,11,138},{7,11,517},{9,11,673},{139,11,238},{138,0,272},{5,11,495},{7,
-11,834},{9,11,733},{139,11,378},{134,0,1744},{132,0,1011},{7,11,828},{142,11,116
-},{4,0,733},{9,0,194},{10,0,92},{11,0,198},{12,0,84},{13,0,128},{133,11,559},{10
-,0,57},{10,0,277},{6,11,21},{6,11,1737},{7,11,1444},{136,11,224},{4,10,204},{137
-,10,902},{136,10,833},{11,0,348},{12,0,99},{18,0,1},{18,0,11},{19,0,4},{7,10,366
-},{9,10,287},{12,10,199},{12,10,556},{140,10,577},{6,0,1981},{136,0,936},{21,0,
-33},{150,0,40},{5,11,519},{138,11,204},{5,10,356},{135,10,224},{134,0,775},{135,
-0,306},{7,10,630},{9,10,567},{11,10,150},{11,10,444},{141,10,119},{5,0,979},{134
-,10,539},{133,0,611},{4,11,402},{135,11,1679},{5,0,178},{7,11,2},{8,11,323},{136
-,11,479},{5,11,59},{135,11,672},{4,0,1010},{6,0,1969},{138,11,237},{133,11,412},
-{146,11,34},{7,11,1740},{146,11,48},{134,0,664},{139,10,814},{4,11,85},{135,11,
-549},{133,11,94},{133,11,457},{132,0,390},{134,0,1510},{4,10,235},{135,10,255},{
-4,10,194},{5,10,584},{6,11,11},{6,10,384},{7,11,187},{7,10,583},{10,10,761},{11,
-10,760},{139,10,851},{4,11,522},{139,11,802},{135,0,493},{10,11,776},{13,11,345}
-,{142,11,425},{146,0,37},{4,11,52},{135,11,661},{134,0,724},{134,0,829},{133,11,
-520},{133,10,562},{4,11,281},{5,11,38},{7,11,194},{7,11,668},{7,11,1893},{137,11
-,397},{5,10,191},{137,10,271},{7,0,1537},{14,0,96},{143,0,73},{5,0,473},{11,0,
-168},{4,10,470},{6,10,153},{7,10,1503},{7,10,1923},{10,10,701},{11,10,132},{11,
-10,227},{11,10,320},{11,10,436},{11,10,525},{11,10,855},{12,10,41},{12,10,286},{
-13,10,103},{13,10,284},{14,10,255},{14,10,262},{15,10,117},{143,10,127},{133,0,
-105},{5,0,438},{9,0,694},{12,0,627},{141,0,210},{133,10,327},{6,10,552},{7,10,
-1754},{137,10,604},{134,0,1256},{152,0,11},{5,11,448},{11,11,98},{139,11,524},{7
-,0,1626},{5,10,80},{6,10,405},{7,10,403},{7,10,1502},{8,10,456},{9,10,487},{9,10
-,853},{9,10,889},{10,10,309},{11,10,721},{11,10,994},{12,10,430},{13,10,165},{14
-,11,16},{146,11,44},{132,0,779},{8,0,25},{138,0,826},{4,10,453},{5,10,887},{6,10
-,535},{8,10,6},{8,10,543},{136,10,826},{137,11,461},{140,11,632},{132,0,308},{
-135,0,741},{132,0,671},{7,0,150},{8,0,649},{136,0,1020},{9,0,99},{6,11,336},{8,
-11,552},{9,11,285},{10,11,99},{139,11,568},{134,0,521},{5,0,339},{14,0,3},{15,0,
-41},{15,0,166},{147,0,66},{6,11,423},{7,11,665},{7,11,1210},{9,11,218},{141,11,
-222},{6,0,543},{5,10,101},{5,11,256},{6,10,88},{7,10,1677},{9,10,100},{10,10,677
-},{14,10,169},{14,10,302},{14,10,313},{15,10,48},{143,10,84},{4,10,310},{7,10,
-708},{7,10,996},{9,10,795},{10,10,390},{10,10,733},{11,10,451},{12,10,249},{14,
-10,115},{14,10,286},{143,10,100},{133,10,587},{13,11,417},{14,11,129},{143,11,15
-},{134,0,1358},{136,11,554},{132,10,498},{7,10,217},{8,10,140},{138,10,610},{135
-,11,989},{135,11,634},{6,0,155},{140,0,234},{135,11,462},{132,11,618},{134,0,
-1628},{132,0,766},{4,11,339},{5,10,905},{135,11,259},{135,0,829},{4,11,759},{141
-,11,169},{7,0,1445},{4,10,456},{7,10,358},{7,10,1637},{8,10,643},{139,10,483},{5
-,0,486},{135,0,1349},{5,11,688},{135,11,712},{7,0,1635},{8,0,17},{10,0,217},{10,
-0,295},{12,0,2},{140,11,2},{138,0,558},{150,10,56},{4,11,278},{5,11,465},{135,11
-,1367},{136,11,482},{133,10,535},{6,0,1362},{6,0,1461},{10,11,274},{10,11,625},{
-139,11,530},{5,0,599},{5,11,336},{6,11,341},{6,11,478},{6,11,1763},{136,11,386},
-{7,10,1748},{137,11,151},{134,0,1376},{133,10,539},{135,11,73},{135,11,1971},{
-139,11,283},{9,0,93},{139,0,474},{6,10,91},{135,10,435},{6,0,447},{5,11,396},{
-134,11,501},{4,10,16},{5,10,316},{5,10,842},{6,10,370},{6,10,1778},{8,10,166},{
-11,10,812},{12,10,206},{12,10,351},{14,10,418},{16,10,15},{16,10,34},{18,10,3},{
-19,10,3},{19,10,7},{20,10,4},{149,10,21},{7,0,577},{7,0,1432},{9,0,475},{9,0,505
-},{9,0,526},{9,0,609},{9,0,689},{9,0,726},{9,0,735},{9,0,738},{10,0,556},{10,0,
-674},{10,0,684},{11,0,89},{11,0,202},{11,0,272},{11,0,380},{11,0,415},{11,0,505}
-,{11,0,537},{11,0,550},{11,0,562},{11,0,640},{11,0,667},{11,0,688},{11,0,847},{
-11,0,927},{11,0,930},{11,0,940},{12,0,144},{12,0,325},{12,0,329},{12,0,389},{12,
-0,403},{12,0,451},{12,0,515},{12,0,604},{12,0,616},{12,0,626},{13,0,66},{13,0,
-131},{13,0,167},{13,0,236},{13,0,368},{13,0,411},{13,0,434},{13,0,453},{13,0,461
-},{13,0,474},{14,0,59},{14,0,60},{14,0,139},{14,0,152},{14,0,276},{14,0,353},{14
-,0,402},{15,0,28},{15,0,81},{15,0,123},{15,0,152},{18,0,136},{148,0,88},{4,11,
-929},{133,11,799},{136,11,46},{142,0,307},{4,0,609},{7,0,756},{9,0,544},{11,0,
-413},{144,0,25},{10,0,687},{7,10,619},{10,10,547},{11,10,122},{140,10,601},{4,0,
-930},{133,0,947},{133,0,939},{142,0,21},{4,11,892},{133,11,770},{133,0,962},{5,0
-,651},{8,0,170},{9,0,61},{9,0,63},{10,0,23},{10,0,37},{10,0,834},{11,0,4},{11,0,
-187},{11,0,281},{11,0,503},{11,0,677},{12,0,96},{12,0,130},{12,0,244},{14,0,5},{
-14,0,40},{14,0,162},{14,0,202},{146,0,133},{4,0,406},{5,0,579},{12,0,492},{150,0
-,15},{135,11,158},{135,0,597},{132,0,981},{132,10,888},{4,10,149},{138,10,368},{
-132,0,545},{4,10,154},{7,10,1134},{136,10,105},{135,11,2001},{134,0,1558},{4,10,
-31},{6,10,429},{7,10,962},{9,10,458},{139,10,691},{132,10,312},{135,10,1642},{6,
-0,17},{6,0,1304},{7,0,16},{7,0,1001},{9,0,886},{10,0,489},{10,0,800},{11,0,782},
-{12,0,320},{13,0,467},{14,0,145},{14,0,387},{143,0,119},{135,0,1982},{17,0,17},{
-7,11,1461},{140,11,91},{4,10,236},{132,11,602},{138,0,907},{136,0,110},{7,0,272}
-,{19,0,53},{5,10,836},{5,10,857},{134,10,1680},{5,0,458},{7,11,1218},{136,11,303
-},{7,0,1983},{8,0,0},{8,0,171},{9,0,120},{9,0,732},{10,0,473},{11,0,656},{11,0,
-998},{18,0,0},{18,0,2},{19,0,21},{10,10,68},{139,10,494},{137,11,662},{4,11,13},
-{5,11,567},{7,11,1498},{9,11,124},{11,11,521},{140,11,405},{4,10,81},{139,10,867
-},{135,11,1006},{7,11,800},{7,11,1783},{138,11,12},{9,0,295},{10,0,443},{5,10,
-282},{8,10,650},{137,10,907},{132,11,735},{4,11,170},{4,10,775},{135,11,323},{6,
-0,1844},{10,0,924},{11,11,844},{12,11,104},{140,11,625},{5,11,304},{7,11,1403},{
-140,11,498},{134,0,1232},{4,0,519},{10,0,70},{12,0,26},{14,0,17},{14,0,178},{15,
-0,34},{149,0,12},{132,0,993},{4,11,148},{133,11,742},{6,0,31},{7,0,491},{7,0,530
-},{8,0,592},{11,0,53},{11,0,779},{12,0,167},{12,0,411},{14,0,14},{14,0,136},{15,
-0,72},{16,0,17},{144,0,72},{133,0,907},{134,0,733},{133,11,111},{4,10,71},{5,10,
-376},{7,10,119},{138,10,665},{136,0,55},{8,0,430},{136,11,430},{4,0,208},{5,0,
-106},{6,0,531},{8,0,408},{9,0,188},{138,0,572},{12,0,56},{11,10,827},{14,10,34},
-{143,10,148},{134,0,1693},{133,11,444},{132,10,479},{140,0,441},{9,0,449},{10,0,
-192},{138,0,740},{134,0,928},{4,0,241},{7,10,607},{136,10,99},{8,11,123},{15,11,
-6},{144,11,7},{6,11,285},{8,11,654},{11,11,749},{12,11,190},{12,11,327},{13,11,
-120},{13,11,121},{13,11,327},{15,11,47},{146,11,40},{4,10,41},{5,10,74},{7,10,
-1627},{11,10,871},{140,10,619},{7,0,1525},{11,10,329},{11,10,965},{12,10,241},{
-14,10,354},{15,10,22},{148,10,63},{132,0,259},{135,11,183},{9,10,209},{137,10,
-300},{5,11,937},{135,11,100},{133,10,98},{4,0,173},{5,0,312},{5,0,512},{135,0,
-1285},{141,0,185},{7,0,1603},{7,0,1691},{9,0,464},{11,0,195},{12,0,279},{12,0,
-448},{14,0,11},{147,0,102},{135,0,1113},{133,10,984},{4,0,452},{5,0,583},{135,0,
-720},{4,0,547},{5,0,817},{6,0,433},{7,0,593},{7,0,1378},{8,0,161},{9,0,284},{10,
-0,313},{139,0,886},{8,0,722},{4,10,182},{6,10,205},{135,10,220},{150,0,13},{4,10
-,42},{9,10,205},{9,10,786},{138,10,659},{6,0,289},{7,0,1670},{12,0,57},{151,0,4}
-,{132,10,635},{14,0,43},{146,0,21},{139,10,533},{135,0,1694},{8,0,420},{139,0,
-193},{135,0,409},{132,10,371},{4,10,272},{135,10,836},{5,10,825},{134,10,1640},{
-5,11,251},{5,11,956},{8,11,268},{9,11,214},{146,11,142},{138,0,308},{6,0,1863},{
-141,11,37},{137,10,879},{7,10,317},{135,10,569},{132,11,294},{134,0,790},{5,0,
-1002},{136,0,745},{5,11,346},{5,11,711},{136,11,390},{135,0,289},{5,0,504},{11,0
-,68},{137,10,307},{4,0,239},{6,0,477},{7,0,1607},{139,0,617},{149,0,13},{133,0,
-609},{133,11,624},{5,11,783},{7,11,1998},{135,11,2047},{133,10,525},{132,0,367},
-{132,11,594},{6,0,528},{133,10,493},{4,10,174},{135,10,911},{8,10,417},{137,10,
-782},{132,0,694},{7,0,548},{137,0,58},{4,10,32},{5,10,215},{6,10,269},{7,10,1782
-},{7,10,1892},{10,10,16},{11,10,822},{11,10,954},{141,10,481},{140,0,687},{7,0,
-1749},{136,10,477},{132,11,569},{133,10,308},{135,10,1088},{4,0,661},{138,0,1004
-},{5,11,37},{6,11,39},{6,11,451},{7,11,218},{7,11,667},{7,11,1166},{7,11,1687},{
-8,11,662},{144,11,2},{9,0,445},{12,0,53},{13,0,492},{5,10,126},{8,10,297},{9,10,
-366},{140,10,374},{7,10,1551},{139,10,361},{148,0,74},{134,11,508},{135,0,213},{
-132,10,175},{132,10,685},{6,0,760},{6,0,834},{134,0,1248},{7,11,453},{7,11,635},
-{7,11,796},{8,11,331},{9,11,328},{9,11,330},{9,11,865},{10,11,119},{10,11,235},{
-11,11,111},{11,11,129},{11,11,240},{12,11,31},{12,11,66},{12,11,222},{12,11,269}
-,{12,11,599},{12,11,689},{13,11,186},{13,11,364},{142,11,345},{7,0,1672},{139,0,
-189},{133,10,797},{133,10,565},{6,0,1548},{6,11,98},{7,11,585},{135,11,702},{9,0
-,968},{15,0,192},{149,0,56},{4,10,252},{6,11,37},{7,11,299},{7,10,1068},{7,11,
-1666},{8,11,195},{8,11,316},{9,11,178},{9,11,276},{9,11,339},{9,11,536},{10,11,
-102},{10,11,362},{10,10,434},{10,11,785},{11,11,55},{11,11,149},{11,10,228},{11,
-10,426},{11,11,773},{13,10,231},{13,11,416},{13,11,419},{14,11,38},{14,11,41},{
-14,11,210},{18,10,106},{148,10,87},{4,0,751},{11,0,390},{140,0,32},{4,0,409},{
-133,0,78},{11,11,458},{12,11,15},{140,11,432},{7,0,1602},{10,0,257},{10,0,698},{
-11,0,544},{11,0,585},{12,0,212},{13,0,307},{5,10,231},{7,10,601},{9,10,277},{9,
-10,674},{10,10,178},{10,10,418},{10,10,509},{11,10,531},{12,10,113},{12,10,475},
-{13,10,99},{142,10,428},{6,0,473},{145,0,105},{6,0,1949},{15,0,156},{133,11,645}
-,{7,10,1591},{144,10,43},{135,0,1779},{135,10,1683},{4,11,290},{135,11,1356},{
-134,0,763},{6,11,70},{7,11,1292},{10,11,762},{139,11,288},{142,0,29},{140,11,428
-},{7,0,883},{7,11,131},{7,11,422},{8,11,210},{140,11,573},{134,0,488},{4,10,399}
-,{5,10,119},{5,10,494},{7,10,751},{137,10,556},{133,0,617},{132,11,936},{139,0,
-50},{7,0,1518},{139,0,694},{137,0,785},{4,0,546},{135,0,2042},{7,11,716},{13,11,
-97},{141,11,251},{132,11,653},{145,0,22},{134,0,1016},{4,0,313},{133,0,577},{136
-,11,657},{8,0,184},{141,0,433},{135,0,935},{6,0,720},{9,0,114},{146,11,80},{12,0
-,186},{12,0,292},{14,0,100},{18,0,70},{7,10,594},{7,10,851},{7,10,1858},{9,10,
-411},{9,10,574},{9,10,666},{9,10,737},{10,10,346},{10,10,712},{11,10,246},{11,10
-,432},{11,10,517},{11,10,647},{11,10,679},{11,10,727},{12,10,304},{12,10,305},{
-12,10,323},{12,10,483},{12,10,572},{12,10,593},{12,10,602},{13,10,95},{13,10,101
-},{13,10,171},{13,10,315},{13,10,378},{13,10,425},{13,10,475},{14,10,63},{14,10,
-380},{14,10,384},{15,10,133},{18,10,112},{148,10,72},{135,10,1093},{135,11,1836}
-,{132,10,679},{137,10,203},{11,0,402},{12,0,109},{12,0,431},{13,0,179},{13,0,206
-},{14,0,217},{16,0,3},{148,0,53},{7,11,1368},{8,11,232},{8,11,361},{10,11,682},{
-138,11,742},{137,10,714},{5,0,886},{6,0,46},{6,0,1790},{7,0,14},{7,0,732},{7,0,
-1654},{8,0,95},{8,0,327},{8,0,616},{9,0,892},{10,0,598},{10,0,769},{11,0,134},{
-11,0,747},{12,0,378},{14,0,97},{137,11,534},{4,0,969},{136,10,825},{137,11,27},{
-6,0,727},{142,11,12},{133,0,1021},{134,0,1190},{134,11,1657},{5,10,143},{5,10,
-769},{6,10,1760},{7,10,682},{7,10,1992},{136,10,736},{132,0,153},{135,11,127},{
-133,0,798},{132,0,587},{6,0,598},{7,0,42},{8,0,695},{10,0,212},{11,0,158},{14,0,
-196},{145,0,85},{133,10,860},{6,0,1929},{134,0,1933},{5,0,957},{5,0,1008},{9,0,
-577},{12,0,141},{6,10,422},{7,10,0},{7,10,1544},{8,11,364},{11,10,990},{12,10,
-453},{13,10,47},{141,10,266},{134,0,1319},{4,0,129},{135,0,465},{7,0,470},{7,0,
-1057},{7,0,1201},{9,0,755},{11,0,906},{140,0,527},{7,0,908},{146,0,7},{5,0,148},
-{136,0,450},{5,10,515},{137,10,131},{7,10,1605},{11,10,962},{146,10,139},{132,10
-,646},{134,0,1166},{4,10,396},{7,10,728},{9,10,117},{13,10,202},{148,10,51},{6,
-10,121},{6,10,124},{6,10,357},{7,10,1138},{7,10,1295},{8,10,162},{139,10,655},{
-14,0,374},{142,11,374},{138,0,253},{139,0,1003},{5,11,909},{9,11,849},{138,11,
-805},{133,10,237},{7,11,525},{7,11,1579},{8,11,497},{136,11,573},{137,0,46},{132
-,0,879},{134,0,806},{135,0,1868},{6,0,1837},{134,0,1846},{6,0,730},{134,0,881},{
-7,0,965},{7,0,1460},{7,0,1604},{7,11,193},{7,11,397},{7,11,1105},{8,11,124},{8,
-11,619},{9,11,305},{10,11,264},{11,11,40},{12,11,349},{13,11,134},{13,11,295},{
-14,11,155},{15,11,120},{146,11,105},{136,0,506},{143,0,10},{4,11,262},{7,11,342}
-,{7,10,571},{7,10,1877},{10,10,366},{141,11,23},{133,11,641},{10,0,22},{9,10,513
-},{10,10,39},{12,10,122},{140,10,187},{135,11,1431},{150,11,49},{4,11,99},{6,11,
-250},{6,11,346},{8,11,127},{138,11,81},{6,0,2014},{8,0,928},{10,0,960},{10,0,979
-},{140,0,996},{134,0,296},{132,11,915},{5,11,75},{9,11,517},{10,11,470},{12,11,
-155},{141,11,224},{137,10,873},{4,0,854},{140,11,18},{134,0,587},{7,10,107},{7,
-10,838},{8,10,550},{138,10,401},{11,0,636},{15,0,145},{17,0,34},{19,0,50},{23,0,
-20},{11,10,588},{11,10,864},{11,10,968},{143,10,160},{135,11,216},{7,0,982},{10,
-0,32},{143,0,56},{133,10,768},{133,11,954},{6,11,304},{7,11,1114},{8,11,418},{10
-,11,345},{11,11,341},{11,11,675},{141,11,40},{9,11,410},{139,11,425},{136,0,941}
-,{5,0,435},{132,10,894},{5,0,85},{6,0,419},{7,0,134},{7,0,305},{7,0,361},{7,0,
-1337},{8,0,71},{140,0,519},{140,0,688},{135,0,740},{5,0,691},{7,0,345},{9,0,94},
-{140,0,169},{5,0,183},{6,0,582},{10,0,679},{140,0,435},{134,11,14},{6,0,945},{
-135,0,511},{134,11,1708},{5,11,113},{6,11,243},{7,11,1865},{11,11,161},{16,11,37
-},{145,11,99},{132,11,274},{137,0,539},{7,0,1993},{8,0,684},{134,10,272},{6,0,
-659},{134,0,982},{4,10,9},{5,10,128},{7,10,368},{11,10,480},{148,10,3},{134,0,
-583},{132,0,803},{133,0,704},{4,0,179},{5,0,198},{133,0,697},{7,0,347},{7,0,971}
-,{8,0,181},{10,0,711},{135,11,166},{136,10,682},{4,10,2},{7,10,545},{7,10,894},{
-136,11,521},{135,0,481},{132,0,243},{5,0,203},{7,0,19},{7,0,71},{7,0,113},{10,0,
-405},{11,0,357},{142,0,240},{5,11,725},{5,11,727},{135,11,1811},{6,0,826},{137,
-11,304},{7,0,1450},{139,0,99},{133,11,654},{134,0,492},{5,0,134},{6,0,408},{6,0,
-495},{7,0,1593},{6,11,273},{10,11,188},{13,11,377},{146,11,77},{9,10,769},{140,
-10,185},{135,11,410},{142,0,4},{4,0,665},{134,11,1785},{4,0,248},{7,0,137},{137,
-0,349},{5,10,530},{142,10,113},{7,0,1270},{139,0,612},{132,11,780},{5,0,371},{
-135,0,563},{135,0,826},{6,0,1535},{23,0,21},{151,0,23},{4,0,374},{7,0,547},{7,0,
-1700},{7,0,1833},{139,0,858},{133,10,556},{7,11,612},{8,11,545},{8,11,568},{8,11
-,642},{9,11,717},{10,11,541},{10,11,763},{11,11,449},{12,11,489},{13,11,153},{13
-,11,296},{14,11,138},{14,11,392},{15,11,50},{16,11,6},{16,11,12},{148,11,9},{9,0
-,311},{141,0,42},{8,10,16},{140,10,568},{6,0,1968},{6,0,2027},{138,0,991},{6,0,
-1647},{7,0,1552},{7,0,2010},{9,0,494},{137,0,509},{133,11,948},{6,10,186},{137,
-10,426},{134,0,769},{134,0,642},{132,10,585},{6,0,123},{7,0,214},{9,0,728},{10,0
-,157},{11,0,346},{11,0,662},{143,0,106},{142,11,381},{135,0,1435},{4,11,532},{5,
-11,706},{135,11,662},{5,11,837},{134,11,1651},{4,10,93},{5,10,252},{6,10,229},{7
-,10,291},{9,10,550},{139,10,644},{148,0,79},{137,10,749},{134,0,1425},{137,10,
-162},{4,11,362},{7,11,52},{7,11,303},{140,11,166},{132,10,381},{4,11,330},{7,11,
-933},{7,11,2012},{136,11,292},{135,11,767},{4,0,707},{5,0,588},{6,0,393},{13,0,
-106},{18,0,49},{147,0,41},{6,0,211},{7,0,1690},{11,0,486},{140,0,369},{137,11,
-883},{4,11,703},{135,11,207},{4,0,187},{5,0,184},{5,0,690},{7,0,1869},{10,0,756}
-,{139,0,783},{132,11,571},{134,0,1382},{5,0,175},{6,10,77},{6,10,157},{7,10,974}
-,{7,10,1301},{7,10,1339},{7,10,1490},{7,10,1873},{137,10,628},{134,0,1493},{5,11
-,873},{133,11,960},{134,0,1007},{12,11,93},{12,11,501},{13,11,362},{14,11,151},{
-15,11,40},{15,11,59},{16,11,46},{17,11,25},{18,11,14},{18,11,134},{19,11,25},{19
-,11,69},{20,11,16},{20,11,19},{20,11,66},{21,11,23},{21,11,25},{150,11,42},{11,
-10,919},{141,10,409},{134,0,219},{5,0,582},{6,0,1646},{7,0,99},{7,0,1962},{7,0,
-1986},{8,0,515},{8,0,773},{9,0,23},{9,0,491},{12,0,620},{142,0,93},{133,0,851},{
-5,11,33},{134,11,470},{135,11,1291},{134,0,1278},{135,11,1882},{135,10,1489},{
-132,0,1000},{138,0,982},{8,0,762},{8,0,812},{137,0,910},{6,11,47},{7,11,90},{7,
-11,664},{7,11,830},{7,11,1380},{7,11,2025},{8,11,448},{136,11,828},{4,0,98},{4,0
-,940},{6,0,1819},{6,0,1834},{6,0,1841},{7,0,1365},{8,0,859},{8,0,897},{8,0,918},
-{9,0,422},{9,0,670},{10,0,775},{10,0,894},{10,0,909},{10,0,910},{10,0,935},{11,0
-,210},{12,0,750},{12,0,755},{13,0,26},{13,0,457},{13,0,476},{16,0,100},{16,0,109
-},{18,0,173},{18,0,175},{8,10,398},{9,10,681},{139,10,632},{9,11,417},{137,11,
-493},{136,10,645},{138,0,906},{134,0,1730},{134,10,20},{133,11,1019},{134,0,1185
-},{10,0,40},{136,10,769},{9,0,147},{134,11,208},{140,0,650},{5,0,209},{6,0,30},{
-11,0,56},{139,0,305},{132,0,553},{138,11,344},{6,11,68},{7,11,398},{7,11,448},{7
-,11,1629},{7,11,1813},{8,11,387},{8,11,442},{9,11,710},{10,11,282},{138,11,722},
-{5,0,597},{14,0,20},{142,11,20},{135,0,1614},{135,10,1757},{4,0,150},{5,0,303},{
-6,0,327},{135,10,937},{16,0,49},{7,10,1652},{144,11,49},{8,0,192},{10,0,78},{141
-,0,359},{135,0,786},{143,0,134},{6,0,1638},{7,0,79},{7,0,496},{9,0,138},{10,0,
-336},{11,0,12},{12,0,412},{12,0,440},{142,0,305},{136,11,491},{4,10,579},{5,10,
-226},{5,10,323},{135,10,960},{7,0,204},{7,0,415},{8,0,42},{10,0,85},{139,0,564},
-{132,0,614},{4,11,403},{5,11,441},{7,11,450},{11,11,101},{12,11,193},{141,11,430
-},{135,11,1927},{135,11,1330},{4,0,3},{5,0,247},{5,0,644},{7,0,744},{7,0,1207},{
-7,0,1225},{7,0,1909},{146,0,147},{136,0,942},{4,0,1019},{134,0,2023},{5,11,679},
-{133,10,973},{5,0,285},{9,0,67},{13,0,473},{143,0,82},{7,11,328},{137,11,326},{
-151,0,8},{6,10,135},{135,10,1176},{135,11,1128},{134,0,1309},{135,11,1796},{135,
-10,314},{4,11,574},{7,11,350},{7,11,1024},{8,11,338},{9,11,677},{10,11,808},{139
-,11,508},{7,11,818},{17,11,14},{17,11,45},{18,11,75},{148,11,18},{146,10,4},{135
-,11,1081},{4,0,29},{6,0,532},{7,0,1628},{7,0,1648},{9,0,350},{10,0,433},{11,0,97
-},{11,0,557},{11,0,745},{12,0,289},{12,0,335},{12,0,348},{12,0,606},{13,0,116},{
-13,0,233},{13,0,466},{14,0,181},{14,0,209},{14,0,232},{14,0,236},{14,0,300},{16,
-0,41},{148,0,97},{7,0,318},{6,10,281},{8,10,282},{8,10,480},{8,10,499},{9,10,198
-},{10,10,143},{10,10,169},{10,10,211},{10,10,417},{10,10,574},{11,10,147},{11,10
-,395},{12,10,75},{12,10,407},{12,10,608},{13,10,500},{142,10,251},{135,11,1676},
-{135,11,2037},{135,0,1692},{5,0,501},{7,0,1704},{9,0,553},{11,0,520},{12,0,557},
-{141,0,249},{6,0,1527},{14,0,324},{15,0,55},{15,0,80},{14,11,324},{15,11,55},{
-143,11,80},{135,10,1776},{8,0,988},{137,11,297},{132,10,419},{142,0,223},{139,11
-,234},{7,0,1123},{12,0,508},{14,0,102},{14,0,226},{144,0,57},{4,10,138},{7,10,
-1012},{7,10,1280},{137,10,76},{7,0,1764},{5,10,29},{140,10,638},{134,0,2015},{
-134,0,1599},{138,11,56},{6,11,306},{7,11,1140},{7,11,1340},{8,11,133},{138,11,
-449},{139,11,1011},{6,10,1710},{135,10,2038},{7,11,1763},{140,11,310},{6,0,129},
-{4,10,17},{5,10,23},{7,10,995},{11,10,383},{11,10,437},{12,10,460},{140,10,532},
-{5,11,329},{136,11,260},{133,10,862},{132,0,534},{6,0,811},{135,0,626},{132,11,
-657},{4,0,25},{5,0,60},{6,0,504},{7,0,614},{7,0,1155},{12,0,0},{152,11,7},{7,0,
-1248},{11,0,621},{139,0,702},{137,0,321},{8,10,70},{12,10,171},{141,10,272},{10,
-10,233},{139,10,76},{4,0,379},{7,0,1397},{134,10,442},{5,11,66},{7,11,1896},{136
-,11,288},{134,11,1643},{134,10,1709},{4,11,21},{5,11,91},{5,11,570},{5,11,648},{
-5,11,750},{5,11,781},{6,11,54},{6,11,112},{6,11,402},{6,11,1732},{7,11,315},{7,
-11,749},{7,11,1347},{7,11,1900},{9,11,78},{9,11,508},{10,11,611},{11,11,510},{11
-,11,728},{13,11,36},{14,11,39},{16,11,83},{17,11,124},{148,11,30},{4,0,118},{6,0
-,274},{6,0,361},{7,0,75},{141,0,441},{10,11,322},{10,11,719},{139,11,407},{147,
-10,119},{12,11,549},{14,11,67},{147,11,60},{11,10,69},{12,10,105},{12,10,117},{
-13,10,213},{14,10,13},{14,10,62},{14,10,177},{14,10,421},{15,10,19},{146,10,141}
-,{9,0,841},{137,10,309},{7,10,608},{7,10,976},{8,11,125},{8,11,369},{8,11,524},{
-9,10,146},{10,10,206},{10,11,486},{10,10,596},{11,11,13},{11,11,381},{11,11,736}
-,{11,11,766},{11,11,845},{13,11,114},{13,10,218},{13,11,292},{14,11,47},{142,10,
-153},{12,0,693},{135,11,759},{5,0,314},{6,0,221},{7,0,419},{10,0,650},{11,0,396}
-,{12,0,156},{13,0,369},{14,0,333},{145,0,47},{6,11,1684},{6,11,1731},{7,11,356},
-{7,11,1932},{8,11,54},{8,11,221},{9,11,225},{9,11,356},{10,11,77},{10,11,446},{
-10,11,731},{12,11,404},{141,11,491},{132,11,375},{4,10,518},{135,10,1136},{4,0,
-913},{4,11,411},{11,11,643},{140,11,115},{4,11,80},{133,11,44},{8,10,689},{137,
-10,863},{138,0,880},{4,10,18},{7,10,145},{7,10,444},{7,10,1278},{8,10,49},{8,10,
-400},{9,10,71},{9,10,250},{10,10,459},{12,10,160},{144,10,24},{136,0,475},{5,0,
-1016},{5,11,299},{135,11,1083},{7,0,602},{8,0,179},{10,0,781},{140,0,126},{6,0,
-329},{138,0,111},{135,0,1864},{4,11,219},{7,11,1761},{137,11,86},{6,0,1888},{6,0
-,1892},{6,0,1901},{6,0,1904},{9,0,953},{9,0,985},{9,0,991},{9,0,1001},{12,0,818}
-,{12,0,846},{12,0,847},{12,0,861},{12,0,862},{12,0,873},{12,0,875},{12,0,877},{
-12,0,879},{12,0,881},{12,0,884},{12,0,903},{12,0,915},{12,0,926},{12,0,939},{15,
-0,182},{15,0,219},{15,0,255},{18,0,191},{18,0,209},{18,0,211},{149,0,41},{5,11,
-328},{135,11,918},{137,0,780},{12,0,82},{143,0,36},{133,10,1010},{5,0,821},{134,
-0,1687},{133,11,514},{132,0,956},{134,0,1180},{10,0,112},{5,10,87},{7,10,313},{7
-,10,1103},{10,10,582},{11,10,389},{11,10,813},{12,10,385},{13,10,286},{14,10,124
-},{146,10,108},{5,0,71},{7,0,1407},{9,0,704},{10,0,261},{10,0,619},{11,0,547},{
-11,0,619},{143,0,157},{4,0,531},{5,0,455},{5,11,301},{6,11,571},{14,11,49},{146,
-11,102},{132,10,267},{6,0,385},{7,0,2008},{9,0,337},{138,0,517},{133,11,726},{
-133,11,364},{4,11,76},{7,11,1550},{9,11,306},{9,11,430},{9,11,663},{10,11,683},{
-11,11,427},{11,11,753},{12,11,334},{12,11,442},{14,11,258},{14,11,366},{143,11,
-131},{6,0,1865},{6,0,1879},{6,0,1881},{6,0,1894},{6,0,1908},{9,0,915},{9,0,926},
-{9,0,940},{9,0,943},{9,0,966},{9,0,980},{9,0,989},{9,0,1005},{9,0,1010},{12,0,
-813},{12,0,817},{12,0,840},{12,0,843},{12,0,855},{12,0,864},{12,0,871},{12,0,872
-},{12,0,899},{12,0,905},{12,0,924},{15,0,171},{15,0,181},{15,0,224},{15,0,235},{
-15,0,251},{146,0,184},{137,11,52},{5,0,16},{6,0,86},{6,0,603},{7,0,292},{7,0,561
-},{8,0,257},{8,0,382},{9,0,721},{9,0,778},{11,0,581},{140,0,466},{4,0,486},{5,0,
-491},{135,10,1121},{4,0,72},{6,0,265},{135,0,1300},{135,11,1183},{10,10,249},{
-139,10,209},{132,10,561},{137,11,519},{4,11,656},{4,10,760},{135,11,779},{9,10,
-154},{140,10,485},{135,11,1793},{135,11,144},{136,10,255},{133,0,621},{4,10,368}
-,{135,10,641},{135,11,1373},{7,11,554},{7,11,605},{141,11,10},{137,0,234},{5,0,
-815},{6,0,1688},{134,0,1755},{5,11,838},{5,11,841},{134,11,1649},{7,0,1987},{7,0
-,2040},{136,0,743},{133,11,1012},{6,0,197},{136,0,205},{6,0,314},{134,11,314},{
-144,11,53},{6,11,251},{7,11,365},{7,11,1357},{7,11,1497},{8,11,154},{141,11,281}
-,{133,11,340},{6,0,452},{7,0,312},{138,0,219},{138,0,589},{4,0,333},{9,0,176},{
-12,0,353},{141,0,187},{9,10,92},{147,10,91},{134,0,1110},{11,0,47},{139,11,495},
-{6,10,525},{8,10,806},{9,10,876},{140,10,284},{8,11,261},{9,11,144},{9,11,466},{
-10,11,370},{12,11,470},{13,11,144},{142,11,348},{137,11,897},{8,0,863},{8,0,864}
-,{8,0,868},{8,0,884},{10,0,866},{10,0,868},{10,0,873},{10,0,911},{10,0,912},{10,
-0,944},{12,0,727},{6,11,248},{9,11,546},{10,11,535},{11,11,681},{141,11,135},{6,
-0,300},{135,0,1515},{134,0,1237},{139,10,958},{133,10,594},{140,11,250},{134,0,
-1685},{134,11,567},{7,0,135},{8,0,7},{8,0,62},{9,0,243},{10,0,658},{10,0,697},{
-11,0,456},{139,0,756},{9,0,395},{138,0,79},{6,10,1641},{136,10,820},{4,10,302},{
-135,10,1766},{134,11,174},{135,10,1313},{135,0,631},{134,10,1674},{134,11,395},{
-138,0,835},{7,0,406},{7,0,459},{8,0,606},{139,0,726},{134,11,617},{134,0,979},{6
-,10,389},{7,10,149},{9,10,142},{138,10,94},{5,11,878},{133,11,972},{6,10,8},{7,
-10,1881},{8,10,91},{136,11,511},{133,0,612},{132,11,351},{4,0,372},{7,0,482},{8,
-0,158},{9,0,602},{9,0,615},{10,0,245},{10,0,678},{10,0,744},{11,0,248},{139,0,
-806},{5,0,854},{135,0,1991},{132,11,286},{135,11,344},{7,11,438},{7,11,627},{7,
-11,1516},{8,11,40},{9,11,56},{9,11,294},{10,11,30},{10,11,259},{11,11,969},{146,
-11,148},{135,0,1492},{5,11,259},{7,11,414},{7,11,854},{142,11,107},{135,10,1746}
-,{6,0,833},{134,0,998},{135,10,24},{6,0,750},{135,0,1739},{4,10,503},{135,10,
-1661},{5,10,130},{7,10,1314},{9,10,610},{10,10,718},{11,10,601},{11,10,819},{11,
-10,946},{140,10,536},{10,10,149},{11,10,280},{142,10,336},{132,11,738},{135,10,
-1946},{5,0,195},{135,0,1685},{7,0,1997},{8,0,730},{139,0,1006},{151,11,17},{133,
-11,866},{14,0,463},{14,0,470},{150,0,61},{5,0,751},{8,0,266},{11,0,578},{4,10,
-392},{135,10,1597},{5,10,433},{9,10,633},{139,10,629},{135,0,821},{6,0,715},{134
-,0,1325},{133,11,116},{6,0,868},{132,11,457},{134,0,959},{6,10,234},{138,11,199}
-,{7,0,1053},{7,10,1950},{8,10,680},{11,10,817},{147,10,88},{7,10,1222},{138,10,
-386},{5,0,950},{5,0,994},{6,0,351},{134,0,1124},{134,0,1081},{7,0,1595},{6,10,5}
-,{11,10,249},{12,10,313},{16,10,66},{145,10,26},{148,0,59},{5,11,527},{6,11,189}
-,{135,11,859},{5,10,963},{6,10,1773},{11,11,104},{11,11,554},{15,11,60},{143,11,
-125},{135,0,47},{137,0,684},{134,11,116},{134,0,1606},{134,0,777},{7,0,1020},{8,
-10,509},{136,10,792},{135,0,1094},{132,0,350},{133,11,487},{4,11,86},{5,11,667},
-{5,11,753},{6,11,316},{6,11,455},{135,11,946},{7,0,1812},{13,0,259},{13,0,356},{
-14,0,242},{147,0,114},{132,10,931},{133,0,967},{4,0,473},{7,0,623},{8,0,808},{9,
-0,871},{9,0,893},{11,0,38},{11,0,431},{12,0,112},{12,0,217},{12,0,243},{12,0,562
-},{12,0,663},{12,0,683},{13,0,141},{13,0,197},{13,0,227},{13,0,406},{13,0,487},{
-14,0,156},{14,0,203},{14,0,224},{14,0,256},{18,0,58},{150,0,0},{138,0,286},{7,10
-,943},{139,10,614},{135,10,1837},{150,11,45},{132,0,798},{4,0,222},{7,0,286},{
-136,0,629},{4,11,79},{7,11,1773},{10,11,450},{11,11,589},{13,11,332},{13,11,493}
-,{14,11,183},{14,11,334},{14,11,362},{14,11,368},{14,11,376},{14,11,379},{19,11,
-90},{19,11,103},{19,11,127},{148,11,90},{5,0,337},{11,0,513},{11,0,889},{11,0,
-961},{12,0,461},{13,0,79},{15,0,121},{4,10,90},{5,10,545},{7,10,754},{9,10,186},
-{10,10,72},{10,10,782},{11,10,577},{11,10,610},{12,10,354},{12,10,362},{140,10,
-595},{141,0,306},{136,0,146},{7,0,1646},{9,10,329},{11,10,254},{141,11,124},{4,0
-,465},{135,0,1663},{132,0,525},{133,11,663},{10,0,299},{18,0,74},{9,10,187},{11,
-10,1016},{145,10,44},{7,0,165},{7,0,919},{4,10,506},{136,10,517},{5,10,295},{135
-,10,1680},{133,11,846},{134,0,1064},{5,11,378},{7,11,1402},{7,11,1414},{8,11,465
-},{9,11,286},{10,11,185},{10,11,562},{10,11,635},{11,11,31},{11,11,393},{12,11,
-456},{13,11,312},{18,11,65},{18,11,96},{147,11,89},{132,0,596},{7,10,987},{9,10,
-688},{10,10,522},{11,10,788},{140,10,566},{6,0,82},{7,0,138},{7,0,517},{7,0,1741
-},{11,0,238},{4,11,648},{134,10,1775},{7,0,1233},{7,10,700},{7,10,940},{8,10,514
-},{9,10,116},{9,10,535},{10,10,118},{11,10,107},{11,10,148},{11,10,922},{12,10,
-254},{12,10,421},{142,10,238},{4,0,962},{6,0,1824},{8,0,894},{12,0,708},{12,0,
-725},{14,0,451},{20,0,94},{22,0,59},{150,0,62},{5,11,945},{6,11,1656},{6,11,1787
-},{7,11,167},{8,11,824},{9,11,391},{10,11,375},{139,11,185},{5,0,495},{7,0,834},
-{9,0,733},{139,0,378},{4,10,743},{135,11,1273},{6,0,1204},{7,11,1645},{8,11,352}
-,{137,11,249},{139,10,292},{133,0,559},{132,11,152},{9,0,499},{10,0,341},{15,0,
-144},{19,0,49},{7,10,1283},{9,10,227},{11,10,325},{11,10,408},{14,10,180},{146,
-10,47},{6,0,21},{6,0,1737},{7,0,1444},{136,0,224},{133,11,1006},{7,0,1446},{9,0,
-97},{17,0,15},{5,10,81},{7,10,146},{7,10,1342},{8,10,53},{8,10,561},{8,10,694},{
-8,10,754},{9,10,115},{9,10,894},{10,10,462},{10,10,813},{11,10,230},{11,10,657},
-{11,10,699},{11,10,748},{12,10,119},{12,10,200},{12,10,283},{142,10,273},{5,10,
-408},{137,10,747},{135,11,431},{135,11,832},{6,0,729},{134,0,953},{4,0,727},{8,0
-,565},{5,11,351},{7,11,264},{136,11,565},{134,0,1948},{5,0,519},{5,11,40},{7,11,
-598},{7,11,1638},{8,11,78},{9,11,166},{9,11,640},{9,11,685},{9,11,773},{11,11,
-215},{13,11,65},{14,11,172},{14,11,317},{145,11,6},{8,11,60},{9,11,343},{139,11,
-769},{137,11,455},{134,0,1193},{140,0,790},{7,11,1951},{8,11,765},{8,11,772},{
-140,11,671},{7,11,108},{8,11,219},{8,11,388},{9,11,639},{9,11,775},{11,11,275},{
-140,11,464},{132,11,468},{7,10,30},{8,10,86},{8,10,315},{8,10,700},{9,10,576},{9
-,10,858},{11,10,310},{11,10,888},{11,10,904},{12,10,361},{141,10,248},{5,11,15},
-{6,11,56},{7,11,1758},{8,11,500},{9,11,730},{11,11,331},{13,11,150},{142,11,282}
-,{4,0,402},{7,0,2},{8,0,323},{136,0,479},{138,10,839},{11,0,580},{142,0,201},{5,
-0,59},{135,0,672},{137,10,617},{146,0,34},{134,11,1886},{4,0,961},{136,0,896},{6
-,0,1285},{5,11,205},{6,11,438},{137,11,711},{134,10,428},{7,10,524},{8,10,169},{
-8,10,234},{9,10,480},{138,10,646},{148,0,46},{141,0,479},{133,11,534},{6,0,2019}
-,{134,10,1648},{4,0,85},{7,0,549},{7,10,1205},{138,10,637},{4,0,663},{5,0,94},{7
-,11,235},{7,11,1475},{15,11,68},{146,11,120},{6,11,443},{9,11,237},{9,11,571},{9
-,11,695},{10,11,139},{11,11,715},{12,11,417},{141,11,421},{132,0,783},{4,0,682},
-{8,0,65},{9,10,39},{10,10,166},{11,10,918},{12,10,635},{20,10,10},{22,10,27},{22
-,10,43},{150,10,52},{6,0,11},{135,0,187},{132,0,522},{4,0,52},{135,0,661},{4,0,
-383},{133,0,520},{135,11,546},{11,0,343},{142,0,127},{4,11,578},{7,10,157},{7,11
-,624},{7,11,916},{8,10,279},{10,11,256},{11,11,87},{139,11,703},{134,10,604},{4,
-0,281},{5,0,38},{7,0,194},{7,0,668},{7,0,1893},{137,0,397},{7,10,945},{11,10,713
-},{139,10,744},{139,10,1022},{9,0,635},{139,0,559},{5,11,923},{7,11,490},{12,11,
-553},{13,11,100},{14,11,118},{143,11,75},{132,0,975},{132,10,567},{137,10,859},{
-7,10,1846},{7,11,1846},{8,10,628},{136,11,628},{148,0,116},{138,11,750},{14,0,51
-},{14,11,51},{15,11,7},{148,11,20},{132,0,858},{134,0,1075},{4,11,924},{133,10,
-762},{136,0,535},{133,0,448},{10,10,784},{141,10,191},{133,10,298},{7,0,610},{
-135,0,1501},{7,10,633},{7,10,905},{7,10,909},{7,10,1538},{9,10,767},{140,10,636}
-,{4,11,265},{7,11,807},{135,11,950},{5,11,93},{12,11,267},{144,11,26},{136,0,191
-},{139,10,301},{135,10,1970},{135,0,267},{4,0,319},{5,0,699},{138,0,673},{6,0,
-336},{7,0,92},{7,0,182},{8,0,453},{8,0,552},{9,0,204},{9,0,285},{10,0,99},{11,0,
-568},{11,0,950},{12,0,94},{16,0,20},{16,0,70},{19,0,55},{12,10,644},{144,10,90},
-{6,0,551},{7,0,1308},{7,10,845},{7,11,994},{8,10,160},{137,10,318},{19,11,1},{19
-,11,26},{150,11,9},{7,0,1406},{9,0,218},{141,0,222},{5,0,256},{138,0,69},{5,11,
-233},{5,11,320},{6,11,140},{7,11,330},{136,11,295},{6,0,1980},{136,0,952},{4,0,
-833},{137,11,678},{133,11,978},{4,11,905},{6,11,1701},{137,11,843},{138,10,735},
-{136,10,76},{17,0,39},{148,0,36},{18,0,81},{146,11,81},{14,0,352},{17,0,53},{18,
-0,146},{18,0,152},{19,0,11},{150,0,54},{135,0,634},{138,10,841},{132,0,618},{4,0
-,339},{7,0,259},{17,0,73},{4,11,275},{140,11,376},{132,11,509},{7,11,273},{139,
-11,377},{4,0,759},{13,0,169},{137,10,804},{6,10,96},{135,10,1426},{4,10,651},{
-133,10,289},{7,0,1075},{8,10,35},{9,10,511},{10,10,767},{147,10,118},{6,0,649},{
-6,0,670},{136,0,482},{5,0,336},{6,0,341},{6,0,478},{6,0,1763},{136,0,386},{5,11,
-802},{7,11,2021},{8,11,805},{14,11,94},{15,11,65},{16,11,4},{16,11,77},{16,11,80
-},{145,11,5},{6,0,1035},{5,11,167},{5,11,899},{6,11,410},{137,11,777},{134,11,
-1705},{5,0,924},{133,0,969},{132,10,704},{135,0,73},{135,11,10},{135,10,1078},{5
-,11,11},{6,11,117},{6,11,485},{7,11,1133},{9,11,582},{9,11,594},{11,11,21},{11,
-11,818},{12,11,535},{141,11,86},{135,0,1971},{4,11,264},{7,11,1067},{8,11,204},{
-8,11,385},{139,11,953},{6,0,1458},{135,0,1344},{5,0,396},{134,0,501},{4,10,720},
-{133,10,306},{4,0,929},{5,0,799},{8,0,46},{8,0,740},{133,10,431},{7,11,646},{7,
-11,1730},{11,11,446},{141,11,178},{7,0,276},{5,10,464},{6,10,236},{7,10,696},{7,
-10,914},{7,10,1108},{7,10,1448},{9,10,15},{9,10,564},{10,10,14},{12,10,565},{13,
-10,449},{14,10,53},{15,10,13},{16,10,64},{145,10,41},{4,0,892},{133,0,770},{6,10
-,1767},{12,10,194},{145,10,107},{135,0,158},{5,10,840},{138,11,608},{134,0,1432}
-,{138,11,250},{8,11,794},{9,11,400},{10,11,298},{142,11,228},{151,0,25},{7,11,
-1131},{135,11,1468},{135,0,2001},{9,10,642},{11,10,236},{142,10,193},{4,10,68},{
-5,10,634},{6,10,386},{7,10,794},{8,10,273},{9,10,563},{10,10,105},{10,10,171},{
-11,10,94},{139,10,354},{136,11,724},{132,0,478},{11,11,512},{13,11,205},{19,11,
-30},{22,11,36},{151,11,19},{7,0,1461},{140,0,91},{6,11,190},{7,11,768},{135,11,
-1170},{4,0,602},{8,0,211},{4,10,95},{7,10,416},{139,10,830},{7,10,731},{13,10,20
-},{143,10,11},{6,0,1068},{135,0,1872},{4,0,13},{5,0,567},{7,0,1498},{9,0,124},{
-11,0,521},{12,0,405},{135,11,1023},{135,0,1006},{132,0,735},{138,0,812},{4,0,170
-},{135,0,323},{6,11,137},{9,11,75},{9,11,253},{10,11,194},{138,11,444},{5,0,304}
-,{7,0,1403},{5,10,864},{10,10,648},{11,10,671},{143,10,46},{135,11,1180},{133,10
-,928},{4,0,148},{133,0,742},{11,10,986},{140,10,682},{133,0,523},{135,11,1743},{
-7,0,730},{18,0,144},{19,0,61},{8,10,44},{9,10,884},{10,10,580},{11,10,399},{11,
-10,894},{143,10,122},{5,11,760},{7,11,542},{8,11,135},{136,11,496},{136,0,981},{
-133,0,111},{10,0,132},{11,0,191},{11,0,358},{139,0,460},{7,11,319},{7,11,355},{7
-,11,763},{10,11,389},{145,11,43},{134,0,890},{134,0,1420},{136,11,557},{133,10,
-518},{133,0,444},{135,0,1787},{135,10,1852},{8,0,123},{15,0,6},{144,0,7},{6,0,
-2041},{10,11,38},{139,11,784},{136,0,932},{5,0,937},{135,0,100},{6,0,995},{4,11,
-58},{5,11,286},{6,11,319},{7,11,402},{7,11,1254},{7,11,1903},{8,11,356},{140,11,
-408},{4,11,389},{9,11,181},{9,11,255},{10,11,8},{10,11,29},{10,11,816},{11,11,
-311},{11,11,561},{12,11,67},{141,11,181},{138,0,255},{5,0,138},{4,10,934},{136,
-10,610},{4,0,965},{10,0,863},{138,0,898},{10,10,804},{138,10,832},{12,0,631},{8,
-10,96},{9,10,36},{10,10,607},{11,10,423},{11,10,442},{12,10,309},{14,10,199},{15
-,10,90},{145,10,110},{134,0,1394},{4,0,652},{8,0,320},{22,0,6},{22,0,16},{9,10,
-13},{9,10,398},{9,10,727},{10,10,75},{10,10,184},{10,10,230},{10,10,564},{10,10,
-569},{11,10,973},{12,10,70},{12,10,189},{13,10,57},{141,10,257},{6,0,897},{134,0
-,1333},{4,0,692},{133,0,321},{133,11,373},{135,0,922},{5,0,619},{133,0,698},{137
-,10,631},{5,10,345},{135,10,1016},{9,0,957},{9,0,1018},{12,0,828},{12,0,844},{12
-,0,897},{12,0,901},{12,0,943},{15,0,180},{18,0,197},{18,0,200},{18,0,213},{18,0,
-214},{146,0,226},{5,0,917},{134,0,1659},{135,0,1100},{134,0,1173},{134,0,1930},{
-5,0,251},{5,0,956},{8,0,268},{9,0,214},{146,0,142},{133,10,673},{137,10,850},{4,
-10,287},{133,10,1018},{132,11,672},{5,0,346},{5,0,711},{8,0,390},{11,11,752},{
-139,11,885},{5,10,34},{10,10,724},{12,10,444},{13,10,354},{18,10,32},{23,10,24},
-{23,10,31},{152,10,5},{4,11,710},{134,11,606},{134,0,744},{134,10,382},{133,11,
-145},{4,10,329},{7,11,884},{140,11,124},{4,11,467},{5,11,405},{134,11,544},{9,10
-,846},{138,10,827},{133,0,624},{9,11,372},{15,11,2},{19,11,10},{147,11,18},{4,11
-,387},{135,11,1288},{5,0,783},{7,0,1998},{135,0,2047},{132,10,906},{136,10,366},
-{135,11,550},{4,10,123},{4,10,649},{5,10,605},{7,10,1509},{136,10,36},{134,0,
-1125},{132,0,594},{133,10,767},{135,11,1227},{136,11,467},{4,11,576},{135,11,
-1263},{4,0,268},{7,0,1534},{135,11,1534},{4,10,273},{5,10,658},{5,11,919},{5,10,
-995},{134,11,1673},{133,0,563},{134,10,72},{135,10,1345},{4,11,82},{5,11,333},{5
-,11,904},{6,11,207},{7,11,325},{7,11,1726},{8,11,101},{10,11,778},{139,11,220},{
-5,0,37},{6,0,39},{6,0,451},{7,0,218},{7,0,667},{7,0,1166},{7,0,1687},{8,0,662},{
-16,0,2},{133,10,589},{134,0,1332},{133,11,903},{134,0,508},{5,10,117},{6,10,514}
-,{6,10,541},{7,10,1164},{7,10,1436},{8,10,220},{8,10,648},{10,10,688},{11,10,560
-},{140,11,147},{6,11,555},{135,11,485},{133,10,686},{7,0,453},{7,0,635},{7,0,796
-},{8,0,331},{9,0,330},{9,0,865},{10,0,119},{10,0,235},{11,0,111},{11,0,129},{11,
-0,240},{12,0,31},{12,0,66},{12,0,222},{12,0,269},{12,0,599},{12,0,684},{12,0,689
-},{12,0,691},{142,0,345},{135,0,1834},{4,11,705},{7,11,615},{138,11,251},{136,11
-,345},{137,0,527},{6,0,98},{7,0,702},{135,0,991},{11,0,576},{14,0,74},{7,10,196}
-,{10,10,765},{11,10,347},{11,10,552},{11,10,790},{12,10,263},{13,10,246},{13,10,
-270},{13,10,395},{14,10,176},{14,10,190},{14,10,398},{14,10,412},{15,10,32},{15,
-10,63},{16,10,88},{147,10,105},{134,11,90},{13,0,84},{141,0,122},{6,0,37},{7,0,
-299},{7,0,1666},{8,0,195},{8,0,316},{9,0,178},{9,0,276},{9,0,339},{9,0,536},{10,
-0,102},{10,0,362},{10,0,785},{11,0,55},{11,0,149},{11,0,773},{13,0,416},{13,0,
-419},{14,0,38},{14,0,41},{142,0,210},{5,10,381},{135,10,1792},{7,11,813},{12,11,
-497},{141,11,56},{7,10,616},{138,10,413},{133,0,645},{6,11,125},{135,11,1277},{
-132,0,290},{6,0,70},{7,0,1292},{10,0,762},{139,0,288},{6,10,120},{7,10,1188},{7,
-10,1710},{8,10,286},{9,10,667},{11,10,592},{139,10,730},{135,11,1784},{7,0,1315}
-,{135,11,1315},{134,0,1955},{135,10,1146},{7,0,131},{7,0,422},{8,0,210},{140,0,
-573},{4,10,352},{135,10,687},{139,0,797},{143,0,38},{14,0,179},{15,0,151},{150,0
-,11},{7,0,488},{4,10,192},{5,10,49},{6,10,200},{6,10,293},{134,10,1696},{132,0,
-936},{135,11,703},{6,11,160},{7,11,1106},{9,11,770},{10,11,618},{11,11,112},{140
-,11,413},{5,0,453},{134,0,441},{135,0,595},{132,10,650},{132,10,147},{6,0,991},{
-6,0,1182},{12,11,271},{145,11,109},{133,10,934},{140,11,221},{132,0,653},{7,0,
-505},{135,0,523},{134,0,903},{135,11,479},{7,11,304},{9,11,646},{9,11,862},{10,
-11,262},{11,11,696},{12,11,208},{15,11,79},{147,11,108},{146,0,80},{135,11,981},
-{142,0,432},{132,0,314},{137,11,152},{7,0,1368},{8,0,232},{8,0,361},{10,0,682},{
-138,0,742},{135,11,1586},{9,0,534},{4,11,434},{11,11,663},{12,11,210},{13,11,166
-},{13,11,310},{14,11,373},{147,11,43},{7,11,1091},{135,11,1765},{6,11,550},{135,
-11,652},{137,0,27},{142,0,12},{4,10,637},{5,11,553},{7,11,766},{138,11,824},{7,
-11,737},{8,11,298},{136,11,452},{7,0,736},{139,0,264},{134,0,1657},{133,11,292},
-{138,11,135},{6,0,844},{134,0,1117},{135,0,127},{9,10,867},{138,10,837},{6,0,
-1184},{134,0,1208},{134,0,1294},{136,0,364},{6,0,1415},{7,0,1334},{11,0,125},{6,
-10,170},{7,11,393},{8,10,395},{8,10,487},{10,11,603},{11,11,206},{141,10,147},{
-137,11,748},{4,11,912},{137,11,232},{4,10,535},{136,10,618},{137,0,792},{7,11,
-1973},{136,11,716},{135,11,98},{5,0,909},{9,0,849},{138,0,805},{4,0,630},{132,0,
-699},{5,11,733},{14,11,103},{150,10,23},{12,11,158},{18,11,8},{19,11,62},{20,11,
-6},{22,11,4},{23,11,2},{151,11,9},{132,0,968},{132,10,778},{132,10,46},{5,10,811
-},{6,10,1679},{6,10,1714},{135,10,2032},{6,0,1446},{7,10,1458},{9,10,407},{139,
-10,15},{7,0,206},{7,0,397},{7,0,621},{7,0,640},{8,0,124},{8,0,619},{9,0,305},{9,
-0,643},{10,0,264},{10,0,628},{11,0,40},{12,0,349},{13,0,134},{13,0,295},{14,0,
-155},{15,0,120},{18,0,105},{6,10,34},{7,10,1089},{8,10,708},{8,10,721},{9,10,363
-},{148,10,98},{4,0,262},{5,0,641},{135,0,342},{137,11,72},{4,0,99},{6,0,250},{6,
-0,346},{8,0,127},{138,0,81},{132,0,915},{5,0,75},{9,0,517},{10,0,470},{12,0,155}
-,{141,0,224},{132,10,462},{11,11,600},{11,11,670},{141,11,245},{142,0,83},{5,10,
-73},{6,10,23},{134,10,338},{6,0,1031},{139,11,923},{7,11,164},{7,11,1571},{9,11,
-107},{140,11,225},{134,0,1470},{133,0,954},{6,0,304},{8,0,418},{10,0,345},{11,0,
-341},{139,0,675},{9,0,410},{139,0,425},{4,11,27},{5,11,484},{5,11,510},{6,11,434
-},{7,11,1000},{7,11,1098},{8,11,2},{136,11,200},{134,0,734},{140,11,257},{7,10,
-725},{8,10,498},{139,10,268},{134,0,1822},{135,0,1798},{135,10,773},{132,11,460}
-,{4,11,932},{133,11,891},{134,0,14},{132,10,583},{7,10,1462},{8,11,625},{139,10,
-659},{5,0,113},{6,0,243},{6,0,1708},{7,0,1865},{11,0,161},{16,0,37},{17,0,99},{
-133,10,220},{134,11,76},{5,11,461},{135,11,1925},{140,0,69},{8,11,92},{137,11,
-221},{139,10,803},{132,10,544},{4,0,274},{134,0,922},{132,0,541},{5,0,627},{6,10
-,437},{6,10,564},{11,10,181},{141,10,183},{135,10,1192},{7,0,166},{132,11,763},{
-133,11,253},{134,0,849},{9,11,73},{10,11,110},{14,11,185},{145,11,119},{5,11,212
-},{12,11,35},{141,11,382},{133,0,717},{137,0,304},{136,0,600},{133,0,654},{6,0,
-273},{10,0,188},{13,0,377},{146,0,77},{4,10,790},{5,10,273},{134,10,394},{132,0,
-543},{135,0,410},{11,0,98},{11,0,524},{141,0,87},{132,0,941},{135,11,1175},{4,0,
-250},{7,0,1612},{11,0,186},{12,0,133},{6,10,127},{7,10,1511},{8,10,613},{12,10,
-495},{12,10,586},{12,10,660},{12,10,668},{14,10,385},{15,10,118},{17,10,20},{146
-,10,98},{6,0,1785},{133,11,816},{134,0,1339},{7,0,961},{7,0,1085},{7,0,1727},{8,
-0,462},{6,10,230},{135,11,1727},{9,0,636},{135,10,1954},{132,0,780},{5,11,869},{
-5,11,968},{6,11,1626},{8,11,734},{136,11,784},{4,11,542},{6,11,1716},{6,11,1727}
-,{7,11,1082},{7,11,1545},{8,11,56},{8,11,118},{8,11,412},{8,11,564},{9,11,888},{
-9,11,908},{10,11,50},{10,11,423},{11,11,685},{11,11,697},{11,11,933},{12,11,299}
-,{13,11,126},{13,11,136},{13,11,170},{141,11,190},{134,11,226},{4,11,232},{9,11,
-202},{10,11,474},{140,11,433},{137,11,500},{5,0,529},{136,10,68},{132,10,654},{4
-,10,156},{7,10,998},{7,10,1045},{7,10,1860},{9,10,48},{9,10,692},{11,10,419},{
-139,10,602},{7,0,1276},{8,0,474},{9,0,652},{6,11,108},{7,11,1003},{7,11,1181},{
-136,11,343},{7,11,1264},{7,11,1678},{11,11,945},{12,11,341},{12,11,471},{140,11,
-569},{134,11,1712},{5,0,948},{12,0,468},{19,0,96},{148,0,24},{4,11,133},{7,11,
-711},{7,11,1298},{7,11,1585},{135,11,1929},{6,0,753},{140,0,657},{139,0,941},{6,
-11,99},{7,11,1808},{145,11,57},{6,11,574},{7,11,428},{7,11,1250},{10,11,669},{11
-,11,485},{11,11,840},{12,11,300},{142,11,250},{4,0,532},{5,0,706},{135,0,662},{5
-,0,837},{6,0,1651},{139,0,985},{7,0,1861},{9,10,197},{10,10,300},{12,10,473},{13
-,10,90},{141,10,405},{137,11,252},{6,11,323},{135,11,1564},{4,0,330},{4,0,863},{
-7,0,933},{7,0,2012},{8,0,292},{7,11,461},{8,11,775},{138,11,435},{132,10,606},{4
-,11,655},{7,11,850},{17,11,75},{146,11,137},{135,0,767},{7,10,1978},{136,10,676}
-,{132,0,641},{135,11,1559},{134,0,1233},{137,0,242},{17,0,114},{4,10,361},{133,
-10,315},{137,0,883},{132,10,461},{138,0,274},{134,0,2008},{134,0,1794},{4,0,703}
-,{135,0,207},{12,0,285},{132,10,472},{132,0,571},{5,0,873},{5,0,960},{8,0,823},{
-9,0,881},{136,11,577},{7,0,617},{10,0,498},{11,0,501},{12,0,16},{140,0,150},{138
-,10,747},{132,0,431},{133,10,155},{11,0,283},{11,0,567},{7,10,163},{8,10,319},{9
-,10,402},{10,10,24},{10,10,681},{11,10,200},{12,10,253},{12,10,410},{142,10,219}
-,{4,11,413},{5,11,677},{8,11,432},{140,11,280},{9,0,401},{5,10,475},{7,10,1780},
-{11,10,297},{11,10,558},{14,10,322},{147,10,76},{6,0,781},{9,0,134},{10,0,2},{10
-,0,27},{10,0,333},{11,0,722},{143,0,1},{5,0,33},{6,0,470},{139,0,424},{135,0,
-2006},{12,0,783},{135,10,1956},{136,0,274},{135,0,1882},{132,0,794},{135,0,1848}
-,{5,10,944},{134,10,1769},{6,0,47},{7,0,90},{7,0,664},{7,0,830},{7,0,1380},{7,0,
-2025},{8,0,448},{136,0,828},{132,10,144},{134,0,1199},{4,11,395},{139,11,762},{
-135,11,1504},{9,0,417},{137,0,493},{9,11,174},{10,11,164},{11,11,440},{11,11,841
-},{143,11,98},{134,11,426},{139,11,1002},{134,0,295},{134,0,816},{6,10,247},{137
-,10,555},{133,0,1019},{4,0,620},{5,11,476},{10,10,280},{138,10,797},{139,0,464},
-{5,11,76},{6,11,458},{6,11,497},{7,11,764},{7,11,868},{9,11,658},{10,11,594},{11
-,11,173},{11,11,566},{12,11,20},{12,11,338},{141,11,200},{134,0,208},{4,11,526},
-{7,11,1029},{135,11,1054},{132,11,636},{6,11,233},{7,11,660},{7,11,1124},{17,11,
-31},{19,11,22},{151,11,14},{10,0,442},{133,10,428},{10,0,930},{140,0,778},{6,0,
-68},{7,0,448},{7,0,1629},{7,0,1769},{7,0,1813},{8,0,442},{8,0,516},{9,0,710},{10
-,0,282},{10,0,722},{7,10,1717},{138,10,546},{134,0,1128},{11,0,844},{12,0,104},{
-140,0,625},{4,11,432},{135,11,824},{138,10,189},{133,0,787},{133,10,99},{4,11,
-279},{7,11,301},{137,11,362},{8,0,491},{4,10,397},{136,10,555},{4,11,178},{133,
-11,399},{134,0,711},{144,0,9},{4,0,403},{5,0,441},{7,0,450},{10,0,840},{11,0,101
-},{12,0,193},{141,0,430},{135,11,1246},{12,10,398},{20,10,39},{21,10,11},{150,10
-,41},{4,10,485},{7,10,353},{135,10,1523},{6,10,366},{7,10,1384},{7,10,1601},{135
-,11,1912},{7,0,396},{10,0,160},{135,11,396},{137,10,282},{134,11,1692},{4,10,157
-},{5,10,471},{6,11,202},{10,11,448},{11,11,208},{12,11,360},{17,11,117},{17,11,
-118},{18,11,27},{148,11,67},{133,0,679},{137,0,326},{136,10,116},{7,11,872},{10,
-11,516},{139,11,167},{132,11,224},{5,11,546},{7,11,35},{8,11,11},{8,11,12},{9,11
-,315},{9,11,533},{10,11,802},{11,11,166},{12,11,525},{142,11,243},{7,0,1128},{
-135,11,1920},{5,11,241},{8,11,242},{9,11,451},{10,11,667},{11,11,598},{140,11,
-429},{6,0,737},{5,10,160},{7,10,363},{7,10,589},{10,10,170},{141,10,55},{135,0,
-1796},{142,11,254},{4,0,574},{7,0,350},{7,0,1024},{8,0,338},{9,0,677},{138,0,808
-},{134,0,1096},{137,11,516},{7,0,405},{10,0,491},{4,10,108},{4,11,366},{139,10,
-498},{11,11,337},{142,11,303},{134,11,1736},{7,0,1081},{140,11,364},{7,10,1005},
-{140,10,609},{7,0,1676},{4,10,895},{133,10,772},{135,0,2037},{6,0,1207},{11,11,
-916},{142,11,419},{14,11,140},{148,11,41},{6,11,331},{136,11,623},{9,0,944},{9,0
-,969},{9,0,1022},{12,0,913},{12,0,936},{15,0,177},{15,0,193},{4,10,926},{133,10,
-983},{5,0,354},{135,11,506},{8,0,598},{9,0,664},{138,0,441},{4,11,640},{133,11,
-513},{137,0,297},{132,10,538},{6,10,294},{7,10,1267},{136,10,624},{7,0,1772},{7,
-11,1888},{8,11,289},{11,11,45},{12,11,278},{140,11,537},{135,10,1325},{138,0,751
-},{141,0,37},{134,0,1828},{132,10,757},{132,11,394},{6,0,257},{135,0,1522},{4,0,
-582},{9,0,191},{135,11,1931},{7,11,574},{7,11,1719},{137,11,145},{132,11,658},{
-10,0,790},{132,11,369},{9,11,781},{10,11,144},{11,11,385},{13,11,161},{13,11,228
-},{13,11,268},{148,11,107},{8,0,469},{10,0,47},{136,11,374},{6,0,306},{7,0,1140}
-,{7,0,1340},{8,0,133},{138,0,449},{139,0,1011},{7,10,1875},{139,10,124},{4,11,
-344},{6,11,498},{139,11,323},{137,0,299},{132,0,837},{133,11,906},{5,0,329},{8,0
-,260},{138,0,10},{134,0,1320},{4,0,657},{146,0,158},{135,0,1191},{152,0,7},{6,0,
-1939},{8,0,974},{138,0,996},{135,0,1665},{11,11,126},{139,11,287},{143,0,8},{14,
-11,149},{14,11,399},{143,11,57},{5,0,66},{7,0,1896},{136,0,288},{7,0,175},{10,0,
-494},{5,10,150},{8,10,603},{9,10,593},{9,10,634},{10,10,173},{11,10,462},{11,10,
-515},{13,10,216},{13,10,288},{142,10,400},{134,0,1643},{136,11,21},{4,0,21},{5,0
-,91},{5,0,648},{5,0,750},{5,0,781},{6,0,54},{6,0,112},{6,0,402},{6,0,1732},{7,0,
-315},{7,0,749},{7,0,1427},{7,0,1900},{9,0,78},{9,0,508},{10,0,611},{10,0,811},{
-11,0,510},{11,0,728},{13,0,36},{14,0,39},{16,0,83},{17,0,124},{148,0,30},{4,0,
-668},{136,0,570},{10,0,322},{10,0,719},{139,0,407},{135,11,1381},{136,11,193},{
-12,10,108},{141,10,291},{132,11,616},{136,11,692},{8,0,125},{8,0,369},{8,0,524},
-{10,0,486},{11,0,13},{11,0,381},{11,0,736},{11,0,766},{11,0,845},{13,0,114},{13,
-0,292},{142,0,47},{134,0,1247},{6,0,1684},{6,0,1731},{7,0,356},{8,0,54},{8,0,221
-},{9,0,225},{9,0,356},{10,0,77},{10,0,446},{10,0,731},{12,0,404},{141,0,491},{
-135,10,1777},{4,11,305},{4,10,493},{144,10,55},{4,0,951},{6,0,1809},{6,0,1849},{
-8,0,846},{8,0,866},{8,0,899},{10,0,896},{12,0,694},{142,0,468},{5,11,214},{7,11,
-603},{8,11,611},{9,11,686},{10,11,88},{11,11,459},{11,11,496},{12,11,463},{12,11
-,590},{13,11,0},{142,11,214},{132,0,411},{4,0,80},{133,0,44},{140,11,74},{143,0,
-31},{7,0,669},{6,10,568},{7,10,1804},{8,10,362},{8,10,410},{8,10,830},{9,10,514}
-,{11,10,649},{142,10,157},{7,0,673},{134,11,1703},{132,10,625},{134,0,1303},{5,0
-,299},{135,0,1083},{138,0,704},{6,0,275},{7,0,408},{6,10,158},{7,10,129},{7,10,
-181},{8,10,276},{8,10,377},{10,10,523},{11,10,816},{12,10,455},{13,10,303},{142,
-10,135},{4,0,219},{7,0,367},{7,0,1713},{7,0,1761},{9,0,86},{9,0,537},{10,0,165},
-{12,0,219},{140,0,561},{8,0,216},{4,10,1},{4,11,737},{6,11,317},{7,10,1143},{7,
-10,1463},{9,10,207},{9,10,390},{9,10,467},{10,11,98},{11,11,294},{11,10,836},{12
-,11,60},{12,11,437},{13,11,64},{13,11,380},{142,11,430},{6,11,1758},{8,11,520},{
-9,11,345},{9,11,403},{142,11,350},{5,11,47},{10,11,242},{138,11,579},{5,11,139},
-{7,11,1168},{138,11,539},{135,0,1319},{4,10,295},{4,10,723},{5,10,895},{7,10,
-1031},{8,10,199},{8,10,340},{9,10,153},{9,10,215},{10,10,21},{10,10,59},{10,10,
-80},{10,10,224},{10,10,838},{11,10,229},{11,10,652},{12,10,192},{13,10,146},{142
-,10,91},{140,0,428},{137,10,51},{133,0,514},{5,10,309},{140,10,211},{6,0,1010},{
-5,10,125},{8,10,77},{138,10,15},{4,0,55},{5,0,301},{6,0,571},{142,0,49},{146,0,
-102},{136,11,370},{4,11,107},{7,11,613},{8,11,358},{8,11,439},{8,11,504},{9,11,
-501},{10,11,383},{139,11,477},{132,11,229},{133,0,364},{133,10,439},{4,11,903},{
-135,11,1816},{11,0,379},{140,10,76},{4,0,76},{4,0,971},{7,0,1550},{9,0,306},{9,0
-,430},{9,0,663},{10,0,683},{10,0,921},{11,0,427},{11,0,753},{12,0,334},{12,0,442
-},{14,0,258},{14,0,366},{143,0,131},{137,0,52},{4,11,47},{6,11,373},{7,11,452},{
-7,11,543},{7,11,1714},{7,11,1856},{9,11,6},{11,11,257},{139,11,391},{4,10,8},{7,
-10,1152},{7,10,1153},{7,10,1715},{9,10,374},{10,10,478},{139,10,648},{4,11,785},
-{133,11,368},{135,10,1099},{135,11,860},{5,11,980},{134,11,1754},{134,0,1258},{6
-,0,1058},{6,0,1359},{7,11,536},{7,11,1331},{136,11,143},{4,0,656},{135,0,779},{
-136,10,87},{5,11,19},{6,11,533},{146,11,126},{7,0,144},{138,10,438},{5,11,395},{
-5,11,951},{134,11,1776},{135,0,1373},{7,0,554},{7,0,605},{141,0,10},{4,10,69},{5
-,10,122},{9,10,656},{138,10,464},{5,10,849},{134,10,1633},{5,0,838},{5,0,841},{
-134,0,1649},{133,0,1012},{139,10,499},{7,10,476},{7,10,1592},{138,10,87},{6,0,
-251},{7,0,365},{7,0,1357},{7,0,1497},{8,0,154},{141,0,281},{132,11,441},{132,11,
-695},{7,11,497},{9,11,387},{147,11,81},{133,0,340},{14,10,283},{142,11,283},{134
-,0,810},{135,11,1894},{139,0,495},{5,11,284},{6,11,49},{6,11,350},{7,11,1},{7,11
-,377},{7,11,1693},{8,11,18},{8,11,678},{9,11,161},{9,11,585},{9,11,671},{9,11,
-839},{11,11,912},{141,11,427},{5,10,859},{7,10,1160},{8,10,107},{9,10,291},{9,10
-,439},{10,10,663},{11,10,609},{140,10,197},{8,0,261},{9,0,144},{9,0,466},{10,0,
-370},{12,0,470},{13,0,144},{142,0,348},{137,0,897},{6,0,248},{9,0,546},{10,0,535
-},{11,0,681},{141,0,135},{4,0,358},{135,0,1496},{134,0,567},{136,0,445},{4,10,
-117},{6,10,372},{7,10,1905},{142,10,323},{4,10,722},{139,10,471},{6,0,697},{134,
-0,996},{7,11,2007},{9,11,101},{9,11,450},{10,11,66},{10,11,842},{11,11,536},{140
-,11,587},{132,0,577},{134,0,1336},{9,10,5},{12,10,216},{12,10,294},{12,10,298},{
-12,10,400},{12,10,518},{13,10,229},{143,10,139},{6,0,174},{138,0,917},{134,10,
-1774},{5,10,12},{7,10,375},{9,10,88},{9,10,438},{11,11,62},{139,10,270},{134,11,
-1766},{6,11,0},{7,11,84},{7,10,816},{7,10,1241},{9,10,283},{9,10,520},{10,10,213
-},{10,10,307},{10,10,463},{10,10,671},{10,10,746},{11,10,401},{11,10,794},{11,11
-,895},{12,10,517},{17,11,11},{18,10,107},{147,10,115},{5,0,878},{133,0,972},{6,
-11,1665},{7,11,256},{7,11,1388},{138,11,499},{4,10,258},{136,10,639},{4,11,22},{
-5,11,10},{6,10,22},{7,11,848},{7,10,903},{7,10,1963},{8,11,97},{138,10,577},{5,
-10,681},{136,10,782},{133,11,481},{132,0,351},{4,10,664},{5,10,804},{139,10,1013
-},{6,11,134},{7,11,437},{7,11,959},{9,11,37},{14,11,285},{14,11,371},{144,11,60}
-,{7,11,486},{8,11,155},{11,11,93},{140,11,164},{132,0,286},{7,0,438},{7,0,627},{
-7,0,1516},{8,0,40},{9,0,56},{9,0,294},{10,0,30},{11,0,969},{11,0,995},{146,0,148
-},{5,11,591},{135,11,337},{134,0,1950},{133,10,32},{138,11,500},{5,11,380},{5,11
-,650},{136,11,310},{4,11,364},{7,11,1156},{7,11,1187},{137,11,409},{4,0,738},{
-134,11,482},{4,11,781},{6,11,487},{7,11,926},{8,11,263},{139,11,500},{135,11,418
-},{6,0,2047},{10,0,969},{4,10,289},{7,10,629},{7,10,1698},{7,10,1711},{140,10,
-215},{6,10,450},{136,10,109},{134,0,818},{136,10,705},{133,0,866},{4,11,94},{135
-,11,1265},{132,11,417},{134,0,1467},{135,10,1238},{4,0,972},{6,0,1851},{134,0,
-1857},{134,0,355},{133,0,116},{132,0,457},{135,11,1411},{4,11,408},{4,11,741},{
-135,11,500},{134,10,26},{142,11,137},{5,0,527},{6,0,189},{7,0,859},{136,0,267},{
-11,0,104},{11,0,554},{15,0,60},{143,0,125},{134,0,1613},{4,10,414},{5,10,467},{9
-,10,654},{10,10,451},{12,10,59},{141,10,375},{135,10,17},{134,0,116},{135,11,541
-},{135,10,955},{6,11,73},{135,11,177},{133,11,576},{134,0,886},{133,0,487},{4,0,
-86},{5,0,667},{5,0,753},{6,0,316},{6,0,455},{135,0,946},{142,11,231},{150,0,45},
-{134,0,863},{134,0,1953},{6,10,280},{10,10,502},{11,10,344},{140,10,38},{4,0,79}
-,{7,0,1773},{10,0,450},{11,0,589},{13,0,332},{13,0,493},{14,0,183},{14,0,334},{
-14,0,362},{14,0,368},{14,0,376},{14,0,379},{19,0,90},{19,0,103},{19,0,127},{148,
-0,90},{5,10,45},{7,10,1161},{11,10,448},{11,10,880},{13,10,139},{13,10,407},{15,
-10,16},{17,10,95},{18,10,66},{18,10,88},{18,10,123},{149,10,7},{136,10,777},{4,
-10,410},{135,10,521},{135,10,1778},{135,11,538},{142,0,381},{133,11,413},{134,0,
-1142},{6,0,1189},{136,11,495},{5,0,663},{6,0,1962},{134,0,2003},{7,11,54},{8,11,
-312},{10,11,191},{10,11,614},{140,11,567},{132,10,436},{133,0,846},{10,0,528},{
-11,0,504},{7,10,1587},{135,10,1707},{5,0,378},{8,0,465},{9,0,286},{10,0,185},{10
-,0,562},{10,0,635},{11,0,31},{11,0,393},{13,0,312},{18,0,65},{18,0,96},{147,0,89
-},{7,0,899},{14,0,325},{6,11,468},{7,11,567},{7,11,1478},{8,11,530},{142,11,290}
-,{7,0,1880},{9,0,680},{139,0,798},{134,0,1770},{132,0,648},{150,11,35},{5,0,945}
-,{6,0,1656},{6,0,1787},{7,0,167},{8,0,824},{9,0,391},{10,0,375},{139,0,185},{6,
-11,484},{135,11,822},{134,0,2046},{7,0,1645},{8,0,352},{137,0,249},{132,0,152},{
-6,0,611},{135,0,1733},{6,11,1724},{135,11,2022},{133,0,1006},{141,11,96},{5,0,
-420},{135,0,1449},{146,11,149},{135,0,832},{135,10,663},{133,0,351},{5,0,40},{7,
-0,598},{7,0,1638},{8,0,78},{9,0,166},{9,0,640},{9,0,685},{9,0,773},{11,0,215},{
-13,0,65},{14,0,172},{14,0,317},{145,0,6},{8,0,60},{9,0,343},{139,0,769},{134,0,
-1354},{132,0,724},{137,0,745},{132,11,474},{7,0,1951},{8,0,765},{8,0,772},{140,0
-,671},{7,0,108},{8,0,219},{8,0,388},{9,0,775},{11,0,275},{140,0,464},{137,0,639}
-,{135,10,503},{133,11,366},{5,0,15},{6,0,56},{7,0,1758},{8,0,500},{9,0,730},{11,
-0,331},{13,0,150},{14,0,282},{5,11,305},{9,11,560},{141,11,208},{4,10,113},{5,10
-,163},{5,10,735},{7,10,1009},{9,10,9},{9,10,771},{12,10,90},{13,10,138},{13,10,
-410},{143,10,128},{4,10,324},{138,10,104},{135,11,466},{142,11,27},{134,0,1886},
-{5,0,205},{6,0,438},{9,0,711},{4,11,480},{6,11,167},{6,11,302},{6,11,1642},{7,11
-,130},{7,11,656},{7,11,837},{7,11,1547},{7,11,1657},{8,11,429},{9,11,228},{10,11
-,643},{13,11,289},{13,11,343},{147,11,101},{134,0,865},{6,0,2025},{136,0,965},{7
-,11,278},{10,11,739},{11,11,708},{141,11,348},{133,0,534},{135,11,1922},{137,0,
-691},{4,10,935},{133,10,823},{6,0,443},{9,0,237},{9,0,571},{9,0,695},{10,0,139},
-{11,0,715},{12,0,417},{141,0,421},{5,10,269},{7,10,434},{7,10,891},{8,10,339},{9
-,10,702},{11,10,594},{11,10,718},{145,10,100},{6,0,1555},{7,0,878},{9,10,485},{
-141,10,264},{134,10,1713},{7,10,1810},{11,10,866},{12,10,103},{141,10,495},{135,
-10,900},{6,0,1410},{9,11,316},{139,11,256},{4,0,995},{135,0,1033},{132,0,578},{
-10,0,881},{12,0,740},{12,0,743},{140,0,759},{132,0,822},{133,0,923},{142,10,143}
-,{135,11,1696},{6,11,363},{7,11,1955},{136,11,725},{132,0,924},{133,0,665},{135,
-10,2029},{135,0,1901},{4,0,265},{6,0,1092},{6,0,1417},{7,0,807},{135,0,950},{5,0
-,93},{12,0,267},{141,0,498},{135,0,1451},{5,11,813},{135,11,2046},{5,10,625},{
-135,10,1617},{135,0,747},{6,0,788},{137,0,828},{7,0,184},{11,0,307},{11,0,400},{
-15,0,130},{5,11,712},{7,11,1855},{8,10,425},{8,10,693},{9,10,720},{10,10,380},{
-10,10,638},{11,11,17},{11,10,473},{12,10,61},{13,11,321},{144,11,67},{135,0,198}
-,{6,11,320},{7,11,781},{7,11,1921},{9,11,55},{10,11,186},{10,11,273},{10,11,664}
-,{10,11,801},{11,11,996},{11,11,997},{13,11,157},{142,11,170},{136,11,271},{135,
-0,994},{7,11,103},{7,11,863},{11,11,184},{14,11,299},{145,11,62},{11,10,551},{
-142,10,159},{5,0,233},{5,0,320},{6,0,140},{8,0,295},{8,0,615},{136,11,615},{133,
-0,978},{4,0,905},{6,0,1701},{137,0,843},{132,10,168},{4,0,974},{8,0,850},{12,0,
-709},{12,0,768},{140,0,786},{135,10,91},{152,0,6},{138,10,532},{135,10,1884},{
-132,0,509},{6,0,1307},{135,0,273},{5,11,77},{7,11,1455},{10,11,843},{19,11,73},{
-150,11,5},{132,11,458},{135,11,1420},{6,11,109},{138,11,382},{6,0,201},{6,11,330
-},{7,10,70},{7,11,1084},{10,10,240},{11,11,142},{147,10,93},{7,0,1041},{140,11,
-328},{133,11,354},{134,0,1040},{133,0,693},{134,0,774},{139,0,234},{132,0,336},{
-7,0,1399},{139,10,392},{20,0,22},{148,11,22},{5,0,802},{7,0,2021},{136,0,805},{5
-,0,167},{5,0,899},{6,0,410},{137,0,777},{137,0,789},{134,0,1705},{7,10,655},{135
-,10,1844},{4,10,145},{6,10,176},{7,10,395},{137,10,562},{132,10,501},{135,0,10},
-{5,0,11},{6,0,117},{6,0,485},{7,0,1133},{9,0,582},{9,0,594},{10,0,82},{11,0,21},
-{11,0,818},{12,0,535},{13,0,86},{20,0,91},{23,0,13},{134,10,509},{4,0,264},{7,0,
-1067},{8,0,204},{8,0,385},{139,0,953},{139,11,737},{138,0,56},{134,0,1917},{133,
-0,470},{10,11,657},{14,11,297},{142,11,361},{135,11,412},{7,0,1198},{7,11,1198},
-{8,11,556},{14,11,123},{14,11,192},{143,11,27},{7,11,1985},{14,11,146},{15,11,42
-},{16,11,23},{17,11,86},{146,11,17},{11,0,1015},{136,11,122},{4,10,114},{9,10,
-492},{13,10,462},{142,10,215},{4,10,77},{5,10,361},{6,10,139},{6,10,401},{6,10,
-404},{7,10,413},{7,10,715},{7,10,1716},{11,10,279},{12,10,179},{12,10,258},{13,
-10,244},{142,10,358},{134,10,1717},{7,10,1061},{8,10,82},{11,10,250},{12,10,420}
-,{141,10,184},{133,0,715},{135,10,724},{9,0,919},{9,0,922},{9,0,927},{9,0,933},{
-9,0,962},{9,0,1000},{9,0,1002},{9,0,1021},{12,0,890},{12,0,907},{12,0,930},{15,0
-,207},{15,0,228},{15,0,238},{149,0,61},{8,0,794},{9,0,400},{10,0,298},{142,0,228
-},{5,11,430},{5,11,932},{6,11,131},{7,11,417},{9,11,522},{11,11,314},{141,11,390
-},{132,0,867},{8,0,724},{132,11,507},{137,11,261},{4,11,343},{133,11,511},{6,0,
-190},{7,0,768},{135,0,1170},{6,10,513},{135,10,1052},{7,11,455},{138,11,591},{
-134,0,1066},{137,10,899},{14,0,67},{147,0,60},{4,0,948},{18,0,174},{146,0,176},{
-135,0,1023},{7,10,1417},{12,10,382},{17,10,48},{152,10,12},{134,11,575},{132,0,
-764},{6,10,545},{7,10,565},{7,10,1669},{10,10,114},{11,10,642},{140,10,618},{6,0
-,137},{9,0,75},{9,0,253},{10,0,194},{138,0,444},{4,0,756},{133,10,5},{8,0,1008},
-{135,10,192},{132,0,842},{11,0,643},{12,0,115},{136,10,763},{139,0,67},{133,10,
-759},{4,0,821},{5,0,760},{7,0,542},{8,0,135},{8,0,496},{135,11,580},{7,10,370},{
-7,10,1007},{7,10,1177},{135,10,1565},{135,10,1237},{140,0,736},{7,0,319},{7,0,
-355},{7,0,763},{10,0,389},{145,0,43},{8,11,333},{138,11,182},{4,10,87},{5,10,250
-},{141,10,298},{138,0,786},{134,0,2044},{8,11,330},{140,11,477},{135,11,1338},{
-132,11,125},{134,0,1030},{134,0,1083},{132,11,721},{135,10,814},{7,11,776},{8,11
-,145},{147,11,56},{134,0,1226},{4,10,57},{7,10,1195},{7,10,1438},{7,10,1548},{7,
-10,1835},{7,10,1904},{9,10,757},{10,10,604},{139,10,519},{7,11,792},{8,11,147},{
-10,11,821},{139,11,1021},{137,11,797},{4,0,58},{5,0,286},{6,0,319},{7,0,402},{7,
-0,1254},{7,0,1903},{8,0,356},{140,0,408},{4,0,389},{4,0,815},{9,0,181},{9,0,255}
-,{10,0,8},{10,0,29},{10,0,816},{11,0,311},{11,0,561},{12,0,67},{141,0,181},{7,11
-,1472},{135,11,1554},{7,11,1071},{7,11,1541},{7,11,1767},{7,11,1806},{7,11,1999}
-,{9,11,248},{10,11,400},{11,11,162},{11,11,178},{11,11,242},{12,11,605},{15,11,
-26},{144,11,44},{5,11,168},{5,11,930},{8,11,74},{9,11,623},{12,11,500},{12,11,
-579},{13,11,41},{143,11,93},{6,11,220},{7,11,1101},{141,11,105},{5,0,474},{7,0,
-507},{4,10,209},{7,11,507},{135,10,902},{132,0,427},{6,0,413},{7,10,335},{7,10,
-1437},{7,10,1668},{8,10,553},{8,10,652},{8,10,656},{9,10,558},{11,10,743},{149,
-10,18},{132,0,730},{6,11,19},{7,11,1413},{139,11,428},{133,0,373},{132,10,559},{
-7,11,96},{8,11,401},{137,11,896},{7,0,799},{7,0,1972},{5,10,1017},{138,10,511},{
-135,0,1793},{7,11,1961},{7,11,1965},{8,11,702},{136,11,750},{8,11,150},{8,11,737
-},{140,11,366},{132,0,322},{133,10,709},{8,11,800},{9,11,148},{9,11,872},{9,11,
-890},{11,11,309},{11,11,1001},{13,11,267},{141,11,323},{134,10,1745},{7,0,290},{
-136,10,206},{7,0,1651},{145,0,89},{139,0,2},{132,0,672},{6,0,1860},{8,0,905},{10
-,0,844},{10,0,846},{10,0,858},{12,0,699},{12,0,746},{140,0,772},{135,11,424},{
-133,11,547},{133,0,737},{5,11,490},{6,11,615},{6,11,620},{135,11,683},{6,0,746},
-{134,0,1612},{132,10,776},{9,11,385},{149,11,17},{133,0,145},{135,10,1272},{7,0,
-884},{140,0,124},{4,0,387},{135,0,1288},{5,11,133},{136,10,406},{136,11,187},{6,
-0,679},{8,11,8},{138,11,0},{135,0,550},{135,11,798},{136,11,685},{7,11,1086},{
-145,11,46},{8,10,175},{10,10,168},{138,10,573},{135,0,1305},{4,0,576},{135,0,
-1263},{6,0,686},{134,0,1563},{134,0,607},{5,0,919},{134,0,1673},{148,0,37},{8,11
-,774},{10,11,670},{140,11,51},{133,10,784},{139,10,882},{4,0,82},{5,0,333},{5,0,
-904},{6,0,207},{7,0,325},{7,0,1726},{8,0,101},{10,0,778},{139,0,220},{135,11,371
-},{132,0,958},{133,0,903},{4,11,127},{5,11,350},{6,11,356},{8,11,426},{9,11,572}
-,{10,11,247},{139,11,312},{140,0,147},{6,11,59},{7,11,885},{9,11,603},{141,11,
-397},{10,0,367},{9,10,14},{9,10,441},{139,10,9},{11,10,966},{12,10,287},{13,10,
-342},{13,10,402},{15,10,110},{143,10,163},{134,0,690},{132,0,705},{9,0,651},{11,
-0,971},{13,0,273},{7,10,1428},{7,10,1640},{7,10,1867},{9,10,169},{9,10,182},{9,
-10,367},{9,10,478},{9,10,506},{9,10,551},{9,10,557},{9,10,648},{9,10,697},{9,10,
-705},{9,10,725},{9,10,787},{9,10,794},{10,10,198},{10,10,214},{10,10,267},{10,10
-,275},{10,10,456},{10,10,551},{10,10,561},{10,10,613},{10,10,627},{10,10,668},{
-10,10,675},{10,10,691},{10,10,695},{10,10,707},{10,10,715},{11,10,183},{11,10,
-201},{11,10,262},{11,10,352},{11,10,439},{11,10,493},{11,10,572},{11,10,591},{11
-,10,608},{11,10,611},{11,10,646},{11,10,674},{11,10,711},{11,10,751},{11,10,761}
-,{11,10,776},{11,10,785},{11,10,850},{11,10,853},{11,10,862},{11,10,865},{11,10,
-868},{11,10,875},{11,10,898},{11,10,902},{11,10,903},{11,10,910},{11,10,932},{11
-,10,942},{11,10,957},{11,10,967},{11,10,972},{12,10,148},{12,10,195},{12,10,220}
-,{12,10,237},{12,10,318},{12,10,339},{12,10,393},{12,10,445},{12,10,450},{12,10,
-474},{12,10,505},{12,10,509},{12,10,533},{12,10,591},{12,10,594},{12,10,597},{12
-,10,621},{12,10,633},{12,10,642},{13,10,59},{13,10,60},{13,10,145},{13,10,239},{
-13,10,250},{13,10,329},{13,10,344},{13,10,365},{13,10,372},{13,10,387},{13,10,
-403},{13,10,414},{13,10,456},{13,10,470},{13,10,478},{13,10,483},{13,10,489},{14
-,10,55},{14,10,57},{14,10,81},{14,10,90},{14,10,148},{14,10,239},{14,10,266},{14
-,10,321},{14,10,326},{14,10,327},{14,10,330},{14,10,347},{14,10,355},{14,10,401}
-,{14,10,404},{14,10,411},{14,10,414},{14,10,416},{14,10,420},{15,10,61},{15,10,
-74},{15,10,87},{15,10,88},{15,10,94},{15,10,96},{15,10,116},{15,10,149},{15,10,
-154},{16,10,50},{16,10,63},{16,10,73},{17,10,2},{17,10,66},{17,10,92},{17,10,103
-},{17,10,112},{17,10,120},{18,10,50},{18,10,54},{18,10,82},{18,10,86},{18,10,90}
-,{18,10,111},{18,10,115},{18,10,156},{19,10,40},{19,10,79},{20,10,78},{149,10,22
-},{7,0,887},{5,10,161},{135,10,839},{142,11,98},{134,0,90},{138,11,356},{135,11,
-441},{6,11,111},{7,11,4},{8,11,163},{8,11,776},{138,11,566},{134,0,908},{134,0,
-1261},{7,0,813},{12,0,497},{141,0,56},{134,0,1235},{135,0,429},{135,11,1994},{
-138,0,904},{6,0,125},{7,0,1277},{137,0,772},{151,0,12},{4,0,841},{5,0,386},{133,
-11,386},{5,11,297},{135,11,1038},{6,0,860},{6,0,1069},{135,11,309},{136,0,946},{
-135,10,1814},{141,11,418},{136,11,363},{10,0,768},{139,0,787},{22,11,30},{150,11
-,33},{6,0,160},{7,0,1106},{9,0,770},{11,0,112},{140,0,413},{11,11,216},{139,11,
-340},{136,10,139},{135,11,1390},{135,11,808},{132,11,280},{12,0,271},{17,0,109},
-{7,10,643},{136,10,236},{140,11,54},{4,11,421},{133,11,548},{11,0,719},{12,0,36}
-,{141,0,337},{7,0,581},{9,0,644},{137,0,699},{11,11,511},{13,11,394},{14,11,298}
-,{14,11,318},{146,11,103},{7,0,304},{9,0,646},{9,0,862},{11,0,696},{12,0,208},{
-15,0,79},{147,0,108},{4,0,631},{7,0,1126},{135,0,1536},{135,11,1527},{8,0,880},{
-10,0,869},{138,0,913},{7,0,1513},{5,10,54},{6,11,254},{9,11,109},{138,11,103},{
-135,0,981},{133,11,729},{132,10,744},{132,0,434},{134,0,550},{7,0,930},{10,0,476
-},{13,0,452},{19,0,104},{6,11,1630},{10,10,402},{146,10,55},{5,0,553},{138,0,824
-},{136,0,452},{8,0,151},{137,10,624},{132,10,572},{132,0,772},{133,11,671},{133,
-0,292},{138,0,135},{132,11,889},{140,11,207},{9,0,504},{6,10,43},{7,10,38},{8,10
-,248},{138,10,513},{6,0,1089},{135,11,1910},{4,11,627},{133,11,775},{135,0,783},
-{133,10,766},{133,10,363},{7,0,387},{135,11,387},{7,0,393},{10,0,603},{11,0,206}
-,{7,11,202},{11,11,362},{11,11,948},{140,11,388},{6,11,507},{7,11,451},{8,11,389
-},{12,11,490},{13,11,16},{13,11,215},{13,11,351},{18,11,132},{147,11,125},{4,0,
-912},{9,0,232},{135,11,841},{6,10,258},{140,10,409},{5,10,249},{148,10,82},{136,
-11,566},{6,0,977},{135,11,1214},{7,0,1973},{136,0,716},{135,0,98},{133,0,733},{5
-,11,912},{134,11,1695},{5,10,393},{6,10,378},{7,10,1981},{9,10,32},{9,10,591},{
-10,10,685},{10,10,741},{142,10,382},{133,10,788},{10,0,19},{11,0,911},{7,10,1968
-},{141,10,509},{5,0,668},{5,11,236},{6,11,572},{8,11,492},{11,11,618},{144,11,56
-},{135,11,1789},{4,0,360},{5,0,635},{5,0,700},{5,10,58},{5,10,171},{5,10,683},{6
-,10,291},{6,10,566},{7,10,1650},{11,10,523},{12,10,273},{12,10,303},{15,10,39},{
-143,10,111},{133,0,901},{134,10,589},{5,11,190},{136,11,318},{140,0,656},{7,0,
-726},{152,0,9},{4,10,917},{133,10,1005},{135,10,1598},{134,11,491},{4,10,919},{
-133,11,434},{137,0,72},{6,0,1269},{6,0,1566},{134,0,1621},{9,0,463},{10,0,595},{
-4,10,255},{5,10,302},{6,10,132},{7,10,128},{7,10,283},{7,10,1299},{10,10,52},{10
-,10,514},{11,10,925},{13,10,92},{142,10,309},{135,0,1454},{134,0,1287},{11,0,600
-},{13,0,245},{137,10,173},{136,0,989},{7,0,164},{7,0,1571},{9,0,107},{140,0,225}
-,{6,0,1061},{141,10,442},{4,0,27},{5,0,484},{5,0,510},{6,0,434},{7,0,1000},{7,0,
-1098},{136,0,2},{7,11,85},{7,11,247},{8,11,585},{10,11,163},{138,11,316},{11,11,
-103},{142,11,0},{134,0,1127},{4,0,460},{134,0,852},{134,10,210},{4,0,932},{133,0
-,891},{6,0,588},{147,11,83},{8,0,625},{4,10,284},{134,10,223},{134,0,76},{8,0,92
-},{137,0,221},{4,11,124},{10,11,457},{11,11,121},{11,11,169},{11,11,422},{11,11,
-870},{12,11,214},{13,11,389},{14,11,187},{143,11,77},{9,11,618},{138,11,482},{4,
-10,218},{7,10,526},{143,10,137},{13,0,9},{14,0,104},{14,0,311},{4,10,270},{5,10,
-192},{6,10,332},{135,10,1322},{140,10,661},{135,11,1193},{6,11,107},{7,11,638},{
-7,11,1632},{137,11,396},{132,0,763},{4,0,622},{5,11,370},{134,11,1756},{133,0,
-253},{135,0,546},{9,0,73},{10,0,110},{14,0,185},{17,0,119},{133,11,204},{7,0,624
-},{7,0,916},{10,0,256},{139,0,87},{7,10,379},{8,10,481},{137,10,377},{5,0,212},{
-12,0,35},{13,0,382},{5,11,970},{134,11,1706},{9,0,746},{5,10,1003},{134,10,149},
-{10,0,150},{11,0,849},{13,0,330},{8,10,262},{9,10,627},{11,10,214},{11,10,404},{
-11,10,457},{11,10,780},{11,10,913},{13,10,401},{142,10,200},{134,0,1466},{135,11
-,3},{6,0,1299},{4,11,35},{5,11,121},{5,11,483},{5,11,685},{6,11,489},{7,11,1204}
-,{136,11,394},{135,10,742},{4,10,142},{136,10,304},{4,11,921},{133,11,1007},{134
-,0,1518},{6,0,1229},{135,0,1175},{133,0,816},{12,0,159},{4,10,471},{4,11,712},{5
-,10,51},{6,10,602},{7,10,925},{8,10,484},{138,10,195},{134,11,1629},{5,0,869},{5
-,0,968},{6,0,1626},{8,0,734},{136,0,784},{4,0,542},{6,0,1716},{6,0,1727},{7,0,
-1082},{7,0,1545},{8,0,56},{8,0,118},{8,0,412},{8,0,564},{9,0,888},{9,0,908},{10,
-0,50},{10,0,423},{11,0,685},{11,0,697},{11,0,933},{12,0,299},{13,0,126},{13,0,
-136},{13,0,170},{13,0,190},{136,10,688},{132,10,697},{4,0,232},{9,0,202},{10,0,
-474},{140,0,433},{136,0,212},{6,0,108},{7,0,1003},{7,0,1181},{8,0,111},{136,0,
-343},{5,10,221},{135,11,1255},{133,11,485},{134,0,1712},{142,0,216},{5,0,643},{6
-,0,516},{4,11,285},{5,11,317},{6,11,301},{7,11,7},{8,11,153},{10,11,766},{11,11,
-468},{12,11,467},{141,11,143},{4,0,133},{7,0,711},{7,0,1298},{135,0,1585},{134,0
-,650},{135,11,512},{6,0,99},{7,0,1808},{145,0,57},{6,0,246},{6,0,574},{7,0,428},
-{9,0,793},{10,0,669},{11,0,485},{11,0,840},{12,0,300},{14,0,250},{145,0,55},{4,
-10,132},{5,10,69},{135,10,1242},{136,0,1023},{7,0,302},{132,10,111},{135,0,1871}
-,{132,0,728},{9,0,252},{132,10,767},{6,0,461},{7,0,1590},{7,10,1416},{7,10,2005}
-,{8,10,131},{8,10,466},{9,10,672},{13,10,252},{148,10,103},{6,0,323},{135,0,1564
-},{7,0,461},{136,0,775},{6,10,44},{136,10,368},{139,0,172},{132,0,464},{4,10,570
-},{133,10,120},{137,11,269},{6,10,227},{135,10,1589},{6,11,1719},{6,11,1735},{7,
-11,2016},{7,11,2020},{8,11,837},{137,11,852},{7,0,727},{146,0,73},{132,0,1023},{
-135,11,852},{135,10,1529},{136,0,577},{138,11,568},{134,0,1037},{8,11,67},{138,
-11,419},{4,0,413},{5,0,677},{8,0,432},{140,0,280},{10,0,600},{6,10,1667},{7,11,
-967},{7,10,2036},{141,11,11},{6,10,511},{140,10,132},{6,0,799},{5,10,568},{6,10,
-138},{135,10,1293},{8,0,159},{4,10,565},{136,10,827},{7,0,646},{7,0,1730},{11,0,
-446},{141,0,178},{4,10,922},{133,10,1023},{135,11,11},{132,0,395},{11,0,145},{
-135,10,1002},{9,0,174},{10,0,164},{11,0,440},{11,0,514},{11,0,841},{15,0,98},{
-149,0,20},{134,0,426},{10,0,608},{139,0,1002},{7,11,320},{8,11,51},{12,11,481},{
-12,11,570},{148,11,106},{9,0,977},{9,0,983},{132,11,445},{138,0,250},{139,0,100}
-,{6,0,1982},{136,10,402},{133,11,239},{4,10,716},{141,10,31},{5,0,476},{7,11,83}
-,{7,11,1990},{8,11,130},{139,11,720},{8,10,691},{136,10,731},{5,11,123},{6,11,
-530},{7,11,348},{135,11,1419},{5,0,76},{6,0,458},{6,0,497},{7,0,868},{9,0,658},{
-10,0,594},{11,0,173},{11,0,566},{12,0,20},{12,0,338},{141,0,200},{9,11,139},{10,
-11,399},{11,11,469},{12,11,634},{141,11,223},{9,10,840},{138,10,803},{133,10,847
-},{11,11,223},{140,11,168},{132,11,210},{8,0,447},{9,10,53},{9,10,268},{9,10,901
-},{10,10,518},{10,10,829},{11,10,188},{13,10,74},{14,10,46},{15,10,17},{15,10,33
-},{17,10,40},{18,10,36},{19,10,20},{22,10,1},{152,10,2},{4,0,526},{7,0,1029},{
-135,0,1054},{19,11,59},{150,11,2},{4,0,636},{6,0,1875},{6,0,1920},{9,0,999},{12,
-0,807},{12,0,825},{15,0,179},{15,0,190},{18,0,182},{136,10,532},{6,0,1699},{7,0,
-660},{7,0,1124},{17,0,31},{19,0,22},{151,0,14},{135,10,681},{132,11,430},{140,10
-,677},{4,10,684},{136,10,384},{132,11,756},{133,11,213},{7,0,188},{7,10,110},{8,
-10,290},{8,10,591},{9,10,382},{9,10,649},{11,10,71},{11,10,155},{11,10,313},{12,
-10,5},{13,10,325},{142,10,287},{7,10,360},{7,10,425},{9,10,66},{9,10,278},{138,
-10,644},{142,11,164},{4,0,279},{7,0,301},{137,0,362},{134,11,586},{135,0,1743},{
-4,0,178},{133,0,399},{4,10,900},{133,10,861},{5,10,254},{7,10,985},{136,10,73},{
-133,11,108},{7,10,1959},{136,10,683},{133,11,219},{4,11,193},{5,11,916},{7,11,
-364},{10,11,398},{10,11,726},{11,11,317},{11,11,626},{12,11,142},{12,11,288},{12
-,11,678},{13,11,313},{15,11,113},{18,11,114},{21,11,30},{150,11,53},{6,11,241},{
-7,11,907},{8,11,832},{9,11,342},{10,11,729},{11,11,284},{11,11,445},{11,11,651},
-{11,11,863},{13,11,398},{146,11,99},{132,0,872},{134,0,831},{134,0,1692},{6,0,
-202},{6,0,1006},{9,0,832},{10,0,636},{11,0,208},{12,0,360},{17,0,118},{18,0,27},
-{20,0,67},{137,11,734},{132,10,725},{7,11,993},{138,11,666},{134,0,1954},{134,10
-,196},{7,0,872},{10,0,516},{139,0,167},{133,10,831},{4,11,562},{9,11,254},{139,
-11,879},{137,0,313},{4,0,224},{132,11,786},{11,0,24},{12,0,170},{136,10,723},{5,
-0,546},{7,0,35},{8,0,11},{8,0,12},{9,0,315},{9,0,533},{10,0,802},{11,0,166},{12,
-0,525},{142,0,243},{7,0,1937},{13,10,80},{13,10,437},{145,10,74},{5,0,241},{8,0,
-242},{9,0,451},{10,0,667},{11,0,598},{140,0,429},{150,0,46},{6,0,1273},{137,0,
-830},{5,10,848},{6,10,66},{136,10,764},{6,0,825},{134,0,993},{4,0,1006},{10,0,
-327},{13,0,271},{4,10,36},{7,10,1387},{139,10,755},{134,0,1023},{135,0,1580},{4,
-0,366},{137,0,516},{132,10,887},{6,0,1736},{135,0,1891},{6,11,216},{7,11,901},{7
-,11,1343},{136,11,493},{6,10,165},{138,10,388},{7,11,341},{139,11,219},{4,10,719
-},{135,10,155},{134,0,1935},{132,0,826},{6,0,331},{6,0,1605},{8,0,623},{11,0,139
-},{139,0,171},{135,11,1734},{10,11,115},{11,11,420},{12,11,154},{13,11,404},{14,
-11,346},{15,11,54},{143,11,112},{7,0,288},{4,10,353},{6,10,146},{6,10,1789},{7,
-10,990},{7,10,1348},{9,10,665},{9,10,898},{11,10,893},{142,10,212},{6,0,916},{
-134,0,1592},{7,0,1888},{4,10,45},{135,10,1257},{5,11,1011},{136,11,701},{139,11,
-596},{4,11,54},{5,11,666},{7,11,1039},{7,11,1130},{9,11,195},{138,11,302},{134,0
-,1471},{134,0,1570},{132,0,394},{140,10,65},{136,10,816},{135,0,1931},{7,0,574},
-{135,0,1719},{134,11,467},{132,0,658},{9,0,781},{10,0,144},{11,0,385},{13,0,161}
-,{13,0,228},{13,0,268},{20,0,107},{134,11,1669},{136,0,374},{135,0,735},{4,0,344
-},{6,0,498},{139,0,323},{7,0,586},{7,0,1063},{6,10,559},{134,10,1691},{137,0,155
-},{133,0,906},{7,11,122},{9,11,259},{10,11,84},{11,11,470},{12,11,541},{141,11,
-379},{134,0,1139},{10,0,108},{139,0,116},{134,10,456},{133,10,925},{5,11,82},{5,
-11,131},{7,11,1755},{8,11,31},{9,11,168},{9,11,764},{139,11,869},{134,11,605},{5
-,11,278},{137,11,68},{4,11,163},{5,11,201},{5,11,307},{5,11,310},{6,11,335},{7,
-11,284},{136,11,165},{135,11,1660},{6,11,33},{135,11,1244},{4,0,616},{136,11,483
-},{8,0,857},{8,0,902},{8,0,910},{10,0,879},{12,0,726},{4,11,199},{139,11,34},{
-136,0,692},{6,10,193},{7,10,240},{7,10,1682},{10,10,51},{10,10,640},{11,10,410},
-{13,10,82},{14,10,247},{14,10,331},{142,10,377},{6,0,823},{134,0,983},{139,10,
-411},{132,0,305},{136,10,633},{138,11,203},{134,0,681},{6,11,326},{7,11,677},{
-137,11,425},{5,0,214},{7,0,603},{8,0,611},{9,0,686},{10,0,88},{11,0,459},{11,0,
-496},{12,0,463},{12,0,590},{141,0,0},{136,0,1004},{142,0,23},{134,0,1703},{147,
-11,8},{145,11,56},{135,0,1443},{4,10,237},{135,10,514},{6,0,714},{145,0,19},{5,
-11,358},{7,11,473},{7,11,1184},{10,11,662},{13,11,212},{13,11,304},{13,11,333},{
-145,11,98},{4,0,737},{10,0,98},{11,0,294},{12,0,60},{12,0,437},{13,0,64},{13,0,
-380},{142,0,430},{6,10,392},{7,10,65},{135,10,2019},{6,0,1758},{8,0,520},{9,0,
-345},{9,0,403},{142,0,350},{5,0,47},{10,0,242},{138,0,579},{5,0,139},{7,0,1168},
-{138,0,539},{134,0,1459},{13,0,388},{141,11,388},{134,0,253},{7,10,1260},{135,10
-,1790},{10,0,252},{9,10,222},{139,10,900},{140,0,745},{133,11,946},{4,0,107},{7,
-0,613},{8,0,439},{8,0,504},{9,0,501},{10,0,383},{139,0,477},{135,11,1485},{132,0
-,871},{7,11,411},{7,11,590},{8,11,631},{9,11,323},{10,11,355},{11,11,491},{12,11
-,143},{12,11,402},{13,11,73},{14,11,408},{15,11,107},{146,11,71},{132,0,229},{
-132,0,903},{140,0,71},{133,0,549},{4,0,47},{6,0,373},{7,0,452},{7,0,543},{7,0,
-1828},{7,0,1856},{9,0,6},{11,0,257},{139,0,391},{7,11,1467},{8,11,328},{10,11,
-544},{11,11,955},{13,11,320},{145,11,83},{5,0,980},{134,0,1754},{136,0,865},{5,0
-,705},{137,0,606},{7,0,161},{8,10,201},{136,10,605},{143,11,35},{5,11,835},{6,11
-,483},{140,10,224},{7,0,536},{7,0,1331},{136,0,143},{134,0,1388},{5,0,724},{10,0
-,305},{11,0,151},{12,0,33},{12,0,121},{12,0,381},{17,0,3},{17,0,27},{17,0,78},{
-18,0,18},{19,0,54},{149,0,5},{4,10,523},{133,10,638},{5,0,19},{134,0,533},{5,0,
-395},{5,0,951},{134,0,1776},{135,0,1908},{132,0,846},{10,0,74},{11,0,663},{12,0,
-210},{13,0,166},{13,0,310},{14,0,373},{18,0,95},{19,0,43},{6,10,242},{7,10,227},
-{7,10,1581},{8,10,104},{9,10,113},{9,10,220},{9,10,427},{10,10,239},{11,10,579},
-{11,10,1023},{13,10,4},{13,10,204},{13,10,316},{148,10,86},{9,11,716},{11,11,108
-},{13,11,123},{14,11,252},{19,11,38},{21,11,3},{151,11,11},{8,0,372},{9,0,122},{
-138,0,175},{132,11,677},{7,11,1374},{136,11,540},{135,10,861},{132,0,695},{7,0,
-497},{9,0,387},{147,0,81},{136,0,937},{134,0,718},{7,0,1328},{136,10,494},{132,
-11,331},{6,0,1581},{133,11,747},{5,0,284},{6,0,49},{6,0,350},{7,0,1},{7,0,377},{
-7,0,1693},{8,0,18},{8,0,678},{9,0,161},{9,0,585},{9,0,671},{9,0,839},{11,0,912},
-{141,0,427},{7,10,1306},{8,10,505},{9,10,482},{10,10,126},{11,10,225},{12,10,347
-},{12,10,449},{13,10,19},{14,10,218},{142,10,435},{10,10,764},{12,10,120},{13,10
-,39},{145,10,127},{4,0,597},{133,10,268},{134,0,1094},{4,0,1008},{134,0,1973},{
-132,0,811},{139,0,908},{135,0,1471},{133,11,326},{4,10,384},{135,10,1022},{7,0,
-1935},{8,0,324},{12,0,42},{4,11,691},{7,11,1935},{8,11,324},{9,11,35},{10,11,680
-},{11,11,364},{12,11,42},{13,11,357},{146,11,16},{135,0,2014},{7,0,2007},{9,0,
-101},{9,0,450},{10,0,66},{10,0,842},{11,0,536},{12,0,587},{6,11,32},{7,11,385},{
-7,11,757},{7,11,1916},{8,11,37},{8,11,94},{8,11,711},{9,11,541},{10,11,162},{10,
-11,795},{11,11,989},{11,11,1010},{12,11,14},{142,11,308},{139,0,586},{135,10,
-1703},{7,0,1077},{11,0,28},{9,10,159},{140,10,603},{6,0,1221},{136,10,583},{6,11
-,152},{6,11,349},{6,11,1682},{7,11,1252},{8,11,112},{9,11,435},{9,11,668},{10,11
-,290},{10,11,319},{10,11,815},{11,11,180},{11,11,837},{12,11,240},{13,11,152},{
-13,11,219},{142,11,158},{139,0,62},{132,10,515},{8,10,632},{8,10,697},{137,10,
-854},{134,0,1766},{132,11,581},{6,11,126},{7,11,573},{8,11,397},{142,11,44},{150
-,0,28},{11,0,670},{22,0,25},{4,10,136},{133,10,551},{6,0,1665},{7,0,256},{7,0,
-1388},{138,0,499},{4,0,22},{5,0,10},{7,0,1576},{136,0,97},{134,10,1782},{5,0,481
-},{7,10,1287},{9,10,44},{10,10,552},{10,10,642},{11,10,839},{12,10,274},{12,10,
-275},{12,10,372},{13,10,91},{142,10,125},{133,11,926},{7,11,1232},{137,11,531},{
-6,0,134},{7,0,437},{7,0,1824},{9,0,37},{14,0,285},{142,0,371},{7,0,486},{8,0,155
-},{11,0,93},{140,0,164},{6,0,1391},{134,0,1442},{133,11,670},{133,0,591},{6,10,
-147},{7,10,886},{7,11,1957},{9,10,753},{138,10,268},{5,0,380},{5,0,650},{7,0,
-1173},{136,0,310},{4,0,364},{7,0,1156},{7,0,1187},{137,0,409},{135,11,1621},{134
-,0,482},{133,11,506},{4,0,781},{6,0,487},{7,0,926},{8,0,263},{139,0,500},{138,10
-,137},{135,11,242},{139,11,96},{133,10,414},{135,10,1762},{134,0,804},{5,11,834}
-,{7,11,1202},{8,11,14},{9,11,481},{137,11,880},{134,10,599},{4,0,94},{135,0,1265
-},{4,0,415},{132,0,417},{5,0,348},{6,0,522},{6,10,1749},{7,11,1526},{138,11,465}
-,{134,10,1627},{132,0,1012},{132,10,488},{4,11,357},{6,11,172},{7,11,143},{137,
-11,413},{4,10,83},{4,11,590},{146,11,76},{140,10,676},{7,11,287},{8,11,355},{9,
-11,293},{137,11,743},{134,10,278},{6,0,1803},{18,0,165},{24,0,21},{5,11,169},{7,
-11,333},{136,11,45},{12,10,97},{140,11,97},{4,0,408},{4,0,741},{135,0,500},{132,
-11,198},{7,10,388},{7,10,644},{139,10,781},{4,11,24},{5,11,140},{5,11,185},{7,11
-,1500},{11,11,565},{139,11,838},{6,0,1321},{9,0,257},{7,10,229},{8,10,59},{9,10,
-190},{10,10,378},{140,10,191},{4,11,334},{133,11,593},{135,11,1885},{134,0,1138}
-,{4,0,249},{6,0,73},{135,0,177},{133,0,576},{142,0,231},{137,0,288},{132,10,660}
-,{7,10,1035},{138,10,737},{135,0,1487},{6,0,989},{9,0,433},{7,10,690},{9,10,587}
-,{140,10,521},{7,0,1264},{7,0,1678},{11,0,945},{12,0,341},{12,0,471},{140,0,569}
-,{132,11,709},{133,11,897},{5,11,224},{13,11,174},{146,11,52},{135,11,1840},{134
-,10,1744},{12,0,87},{16,0,74},{4,10,733},{9,10,194},{10,10,92},{11,10,198},{12,
-10,84},{141,10,128},{140,0,779},{135,0,538},{4,11,608},{133,11,497},{133,0,413},
-{7,11,1375},{7,11,1466},{138,11,331},{136,0,495},{6,11,540},{136,11,136},{7,0,54
-},{8,0,312},{10,0,191},{10,0,614},{140,0,567},{6,0,468},{7,0,567},{7,0,1478},{8,
-0,530},{14,0,290},{133,11,999},{4,11,299},{7,10,306},{135,11,1004},{142,11,296},
-{134,0,1484},{133,10,979},{6,0,609},{9,0,815},{12,11,137},{14,11,9},{14,11,24},{
-142,11,64},{133,11,456},{6,0,484},{135,0,822},{133,10,178},{136,11,180},{132,11,
-755},{137,0,900},{135,0,1335},{6,0,1724},{135,0,2022},{135,11,1139},{5,0,640},{
-132,10,390},{6,0,1831},{138,11,633},{135,11,566},{4,11,890},{5,11,805},{5,11,819
-},{5,11,961},{6,11,396},{6,11,1631},{6,11,1678},{7,11,1967},{7,11,2041},{9,11,
-630},{11,11,8},{11,11,1019},{12,11,176},{13,11,225},{14,11,292},{149,11,24},{132
-,0,474},{134,0,1103},{135,0,1504},{134,0,1576},{6,0,961},{6,0,1034},{140,0,655},
-{11,11,514},{149,11,20},{5,0,305},{135,11,1815},{7,11,1505},{10,11,190},{10,11,
-634},{11,11,792},{12,11,358},{140,11,447},{5,11,0},{6,11,536},{7,11,604},{13,11,
-445},{145,11,126},{7,0,1236},{133,10,105},{4,0,480},{6,0,217},{6,0,302},{6,0,
-1642},{7,0,130},{7,0,837},{7,0,1321},{7,0,1547},{7,0,1657},{8,0,429},{9,0,228},{
-13,0,289},{13,0,343},{19,0,101},{6,11,232},{6,11,412},{7,11,1074},{8,11,9},{8,11
-,157},{8,11,786},{9,11,196},{9,11,352},{9,11,457},{10,11,337},{11,11,232},{11,11
-,877},{12,11,480},{140,11,546},{5,10,438},{7,11,958},{9,10,694},{12,10,627},{13,
-11,38},{141,10,210},{4,11,382},{136,11,579},{7,0,278},{10,0,739},{11,0,708},{141
-,0,348},{4,11,212},{135,11,1206},{135,11,1898},{6,0,708},{6,0,1344},{152,10,11},
-{137,11,768},{134,0,1840},{140,0,233},{8,10,25},{138,10,826},{6,0,2017},{133,11,
-655},{6,0,1488},{139,11,290},{132,10,308},{134,0,1590},{134,0,1800},{134,0,1259}
-,{16,0,28},{6,11,231},{7,11,95},{136,11,423},{133,11,300},{135,10,150},{136,10,
-649},{7,11,1874},{137,11,641},{6,11,237},{7,11,611},{8,11,100},{9,11,416},{11,11
-,335},{12,11,173},{146,11,101},{137,0,45},{134,10,521},{17,0,36},{14,11,26},{146
-,11,150},{7,0,1442},{14,0,22},{5,10,339},{15,10,41},{15,10,166},{147,10,66},{8,0
-,378},{6,11,581},{135,11,1119},{134,0,1507},{147,11,117},{139,0,39},{134,0,1054}
-,{6,0,363},{7,0,1955},{136,0,725},{134,0,2036},{133,11,199},{6,0,1871},{9,0,935}
-,{9,0,961},{9,0,1004},{9,0,1016},{12,0,805},{12,0,852},{12,0,853},{12,0,869},{12
-,0,882},{12,0,896},{12,0,906},{12,0,917},{12,0,940},{15,0,170},{15,0,176},{15,0,
-188},{15,0,201},{15,0,205},{15,0,212},{15,0,234},{15,0,244},{18,0,181},{18,0,193
-},{18,0,196},{18,0,201},{18,0,202},{18,0,210},{18,0,217},{18,0,235},{18,0,236},{
-18,0,237},{21,0,54},{21,0,55},{21,0,58},{21,0,59},{152,0,22},{134,10,1628},{137,
-0,805},{5,0,813},{135,0,2046},{142,11,42},{5,0,712},{6,0,1240},{11,0,17},{13,0,
-321},{144,0,67},{132,0,617},{135,10,829},{6,0,320},{7,0,781},{7,0,1921},{9,0,55}
-,{10,0,186},{10,0,273},{10,0,664},{10,0,801},{11,0,996},{11,0,997},{13,0,157},{
-142,0,170},{136,0,271},{5,10,486},{135,10,1349},{18,11,91},{147,11,70},{10,0,445
-},{7,10,1635},{8,10,17},{138,10,295},{136,11,404},{7,0,103},{7,0,863},{11,0,184}
-,{145,0,62},{138,10,558},{137,0,659},{6,11,312},{6,11,1715},{10,11,584},{11,11,
-546},{11,11,692},{12,11,259},{12,11,295},{13,11,46},{141,11,154},{134,0,676},{
-132,11,588},{4,11,231},{5,11,61},{6,11,104},{7,11,729},{7,11,964},{7,11,1658},{
-140,11,414},{6,11,263},{138,11,757},{11,0,337},{142,0,303},{135,11,1363},{132,11
-,320},{140,0,506},{134,10,447},{5,0,77},{7,0,1455},{10,0,843},{147,0,73},{7,10,
-577},{7,10,1432},{9,10,475},{9,10,505},{9,10,526},{9,10,609},{9,10,689},{9,10,
-726},{9,10,735},{9,10,738},{10,10,556},{10,10,674},{10,10,684},{11,10,89},{11,10
-,202},{11,10,272},{11,10,380},{11,10,415},{11,10,505},{11,10,537},{11,10,550},{
-11,10,562},{11,10,640},{11,10,667},{11,10,688},{11,10,847},{11,10,927},{11,10,
-930},{11,10,940},{12,10,144},{12,10,325},{12,10,329},{12,10,389},{12,10,403},{12
-,10,451},{12,10,515},{12,10,604},{12,10,616},{12,10,626},{13,10,66},{13,10,131},
-{13,10,167},{13,10,236},{13,10,368},{13,10,411},{13,10,434},{13,10,453},{13,10,
-461},{13,10,474},{14,10,59},{14,10,60},{14,10,139},{14,10,152},{14,10,276},{14,
-10,353},{14,10,402},{15,10,28},{15,10,81},{15,10,123},{15,10,152},{18,10,136},{
-148,10,88},{132,0,458},{135,0,1420},{6,0,109},{10,0,382},{4,11,405},{4,10,609},{
-7,10,756},{7,11,817},{9,10,544},{11,10,413},{14,11,58},{14,10,307},{16,10,25},{
-17,11,37},{146,11,124},{6,0,330},{7,0,1084},{11,0,142},{133,11,974},{4,10,930},{
-133,10,947},{5,10,939},{142,11,394},{16,0,91},{145,0,87},{5,11,235},{5,10,962},{
-7,11,1239},{11,11,131},{140,11,370},{11,0,492},{5,10,651},{8,10,170},{9,10,61},{
-9,10,63},{10,10,23},{10,10,37},{10,10,834},{11,10,4},{11,10,281},{11,10,503},{11
-,10,677},{12,10,96},{12,10,130},{12,10,244},{14,10,5},{14,10,40},{14,10,162},{14
-,10,202},{146,10,133},{4,10,406},{5,10,579},{12,10,492},{150,10,15},{9,11,137},{
-138,11,221},{134,0,1239},{11,0,211},{140,0,145},{7,11,390},{138,11,140},{135,11,
-1418},{135,11,1144},{134,0,1049},{7,0,321},{6,10,17},{7,10,1001},{7,10,1982},{9,
-10,886},{10,10,489},{10,10,800},{11,10,782},{12,10,320},{13,10,467},{14,10,145},
-{14,10,387},{143,10,119},{145,10,17},{5,11,407},{11,11,489},{19,11,37},{20,11,73
-},{150,11,38},{133,10,458},{135,0,1985},{7,10,1983},{8,10,0},{8,10,171},{9,10,
-120},{9,10,732},{10,10,473},{11,10,656},{11,10,998},{18,10,0},{18,10,2},{147,10,
-21},{5,11,325},{7,11,1483},{8,11,5},{8,11,227},{9,11,105},{10,11,585},{140,11,
-614},{136,0,122},{132,0,234},{135,11,1196},{6,0,976},{6,0,1098},{134,0,1441},{7,
-0,253},{136,0,549},{6,11,621},{13,11,504},{144,11,19},{132,10,519},{5,0,430},{5,
-0,932},{6,0,131},{7,0,417},{9,0,522},{11,0,314},{141,0,390},{14,0,149},{14,0,399
-},{143,0,57},{5,10,907},{6,10,31},{6,11,218},{7,10,491},{7,10,530},{8,10,592},{
-11,10,53},{11,10,779},{12,10,167},{12,10,411},{14,10,14},{14,10,136},{15,10,72},
-{16,10,17},{144,10,72},{140,11,330},{7,11,454},{7,11,782},{136,11,768},{132,0,
-507},{10,11,676},{140,11,462},{6,0,630},{9,0,811},{4,10,208},{5,10,106},{6,10,
-531},{8,10,408},{9,10,188},{138,10,572},{4,0,343},{5,0,511},{134,10,1693},{134,
-11,164},{132,0,448},{7,0,455},{138,0,591},{135,0,1381},{12,10,441},{150,11,50},{
-9,10,449},{10,10,192},{138,10,740},{6,0,575},{132,10,241},{134,0,1175},{134,0,
-653},{134,0,1761},{134,0,1198},{132,10,259},{6,11,343},{7,11,195},{9,11,226},{10
-,11,197},{10,11,575},{11,11,502},{139,11,899},{7,0,1127},{7,0,1572},{10,0,297},{
-10,0,422},{11,0,764},{11,0,810},{12,0,264},{13,0,102},{13,0,300},{13,0,484},{14,
-0,147},{14,0,229},{17,0,71},{18,0,118},{147,0,120},{135,11,666},{132,0,678},{4,
-10,173},{5,10,312},{5,10,512},{135,10,1285},{7,10,1603},{7,10,1691},{9,10,464},{
-11,10,195},{12,10,279},{12,10,448},{14,10,11},{147,10,102},{16,0,99},{146,0,164}
-,{7,11,1125},{9,11,143},{11,11,61},{14,11,405},{150,11,21},{137,11,260},{4,10,
-452},{5,10,583},{5,10,817},{6,10,433},{7,10,593},{7,10,720},{7,10,1378},{8,10,
-161},{9,10,284},{10,10,313},{139,10,886},{132,10,547},{136,10,722},{14,0,35},{
-142,0,191},{141,0,45},{138,0,121},{132,0,125},{134,0,1622},{133,11,959},{8,10,
-420},{139,10,193},{132,0,721},{135,10,409},{136,0,145},{7,0,792},{8,0,147},{10,0
-,821},{11,0,970},{11,0,1021},{136,11,173},{134,11,266},{132,0,715},{7,0,1999},{
-138,10,308},{133,0,531},{5,0,168},{5,0,930},{8,0,74},{9,0,623},{12,0,500},{140,0
-,579},{144,0,65},{138,11,246},{6,0,220},{7,0,1101},{13,0,105},{142,11,314},{5,10
-,1002},{136,10,745},{134,0,960},{20,0,0},{148,11,0},{4,0,1005},{4,10,239},{6,10,
-477},{7,10,1607},{11,10,68},{139,10,617},{6,0,19},{7,0,1413},{139,0,428},{149,10
-,13},{7,0,96},{8,0,401},{8,0,703},{9,0,896},{136,11,300},{134,0,1595},{145,0,116
-},{136,0,1021},{7,0,1961},{7,0,1965},{7,0,2030},{8,0,150},{8,0,702},{8,0,737},{8
-,0,750},{140,0,366},{11,11,75},{142,11,267},{132,10,367},{8,0,800},{9,0,148},{9,
-0,872},{9,0,890},{11,0,309},{11,0,1001},{13,0,267},{13,0,323},{5,11,427},{5,11,
-734},{7,11,478},{136,11,52},{7,11,239},{11,11,217},{142,11,165},{132,11,323},{
-140,11,419},{13,0,299},{142,0,75},{6,11,87},{6,11,1734},{7,11,20},{7,11,1056},{8
-,11,732},{9,11,406},{9,11,911},{138,11,694},{134,0,1383},{132,10,694},{133,11,
-613},{137,0,779},{4,0,598},{140,10,687},{6,0,970},{135,0,424},{133,0,547},{7,11,
-32},{7,11,984},{8,11,85},{8,11,709},{9,11,579},{9,11,847},{9,11,856},{10,11,799}
-,{11,11,258},{11,11,1007},{12,11,331},{12,11,615},{13,11,188},{13,11,435},{14,11
-,8},{15,11,165},{16,11,27},{148,11,40},{6,0,1222},{134,0,1385},{132,0,876},{138,
-11,151},{135,10,213},{4,11,167},{135,11,82},{133,0,133},{6,11,24},{7,11,74},{7,
-11,678},{137,11,258},{5,11,62},{6,11,534},{7,11,684},{7,11,1043},{7,11,1072},{8,
-11,280},{8,11,541},{8,11,686},{10,11,519},{11,11,252},{140,11,282},{136,0,187},{
-8,0,8},{10,0,0},{10,0,818},{139,0,988},{132,11,359},{11,0,429},{15,0,51},{135,10
-,1672},{136,0,685},{5,11,211},{7,11,88},{136,11,627},{134,0,472},{136,0,132},{6,
-11,145},{141,11,336},{4,10,751},{11,10,390},{140,10,32},{6,0,938},{6,0,1060},{4,
-11,263},{4,10,409},{133,10,78},{137,0,874},{8,0,774},{10,0,670},{12,0,51},{4,11,
-916},{6,10,473},{7,10,1602},{10,10,698},{12,10,212},{13,10,307},{145,10,105},{
-146,0,92},{143,10,156},{132,0,830},{137,0,701},{4,11,599},{6,11,1634},{7,11,5},{
-7,11,55},{7,11,67},{7,11,97},{7,11,691},{7,11,979},{7,11,1697},{8,11,207},{8,11,
-214},{8,11,231},{8,11,294},{8,11,336},{8,11,428},{8,11,451},{8,11,460},{8,11,471
-},{8,11,622},{8,11,626},{8,11,679},{8,11,759},{8,11,829},{9,11,11},{9,11,246},{9
-,11,484},{9,11,573},{9,11,706},{9,11,762},{9,11,798},{9,11,855},{9,11,870},{9,11
-,912},{10,11,303},{10,11,335},{10,11,424},{10,11,461},{10,11,543},{10,11,759},{
-10,11,814},{11,11,59},{11,11,199},{11,11,235},{11,11,475},{11,11,590},{11,11,929
-},{11,11,963},{12,11,114},{12,11,182},{12,11,226},{12,11,332},{12,11,439},{12,11
-,575},{12,11,598},{13,11,8},{13,11,125},{13,11,194},{13,11,287},{14,11,197},{14,
-11,383},{15,11,53},{17,11,63},{19,11,46},{19,11,98},{19,11,106},{148,11,85},{4,0
-,127},{5,0,350},{6,0,356},{8,0,426},{9,0,572},{10,0,247},{139,0,312},{134,0,1215
-},{6,0,59},{9,0,603},{13,0,397},{7,11,1853},{138,11,437},{134,0,1762},{147,11,
-126},{135,10,883},{13,0,293},{142,0,56},{133,10,617},{139,10,50},{5,11,187},{7,
-10,1518},{139,10,694},{135,0,441},{6,0,111},{7,0,4},{8,0,163},{8,0,776},{138,0,
-566},{132,0,806},{4,11,215},{9,11,38},{10,11,3},{11,11,23},{11,11,127},{139,11,
-796},{14,0,233},{4,10,546},{135,10,2042},{135,0,1994},{134,0,1739},{135,11,1530}
-,{136,0,393},{5,0,297},{7,0,1038},{14,0,359},{19,0,52},{148,0,47},{135,0,309},{4
-,10,313},{133,10,577},{8,10,184},{141,10,433},{135,10,935},{12,10,186},{12,10,
-292},{14,10,100},{146,10,70},{136,0,363},{14,0,175},{11,10,402},{12,10,109},{12,
-10,431},{13,10,179},{13,10,206},{14,10,217},{16,10,3},{148,10,53},{5,10,886},{6,
-10,46},{6,10,1790},{7,10,14},{7,10,732},{7,10,1654},{8,10,95},{8,10,327},{8,10,
-616},{9,10,892},{10,10,598},{10,10,769},{11,10,134},{11,10,747},{12,10,378},{142
-,10,97},{136,0,666},{135,0,1675},{6,0,655},{134,0,1600},{135,0,808},{133,10,1021
-},{4,11,28},{5,11,440},{7,11,248},{11,11,833},{140,11,344},{134,11,1654},{132,0,
-280},{140,0,54},{4,0,421},{133,0,548},{132,10,153},{6,11,339},{135,11,923},{133,
-11,853},{133,10,798},{132,10,587},{6,11,249},{7,11,1234},{139,11,573},{6,10,598}
-,{7,10,42},{8,10,695},{10,10,212},{11,10,158},{14,10,196},{145,10,85},{7,0,249},
-{5,10,957},{133,10,1008},{4,10,129},{135,10,465},{6,0,254},{7,0,842},{7,0,1659},
-{9,0,109},{10,0,103},{7,10,908},{7,10,1201},{9,10,755},{11,10,906},{12,10,527},{
-146,10,7},{5,0,262},{136,10,450},{144,0,1},{10,11,201},{142,11,319},{7,11,49},{7
-,11,392},{8,11,20},{8,11,172},{8,11,690},{9,11,383},{9,11,845},{10,11,48},{11,11
-,293},{11,11,832},{11,11,920},{141,11,221},{5,11,858},{133,11,992},{134,0,805},{
-139,10,1003},{6,0,1630},{134,11,307},{7,11,1512},{135,11,1794},{6,11,268},{137,
-11,62},{135,10,1868},{133,0,671},{4,0,989},{8,0,972},{136,0,998},{132,11,423},{
-132,0,889},{135,0,1382},{135,0,1910},{7,10,965},{7,10,1460},{135,10,1604},{4,0,
-627},{5,0,775},{138,11,106},{134,11,348},{7,0,202},{11,0,362},{11,0,948},{140,0,
-388},{138,11,771},{6,11,613},{136,11,223},{6,0,560},{7,0,451},{8,0,389},{12,0,
-490},{13,0,16},{13,0,215},{13,0,351},{18,0,132},{147,0,125},{135,0,841},{136,0,
-566},{136,0,938},{132,11,670},{5,0,912},{6,0,1695},{140,11,55},{9,11,40},{139,11
-,136},{7,0,1361},{7,10,982},{10,10,32},{143,10,56},{11,11,259},{140,11,270},{5,0
-,236},{6,0,572},{8,0,492},{11,0,618},{144,0,56},{8,11,572},{9,11,310},{9,11,682}
-,{137,11,698},{134,0,1854},{5,0,190},{136,0,318},{133,10,435},{135,0,1376},{4,11
-,296},{6,11,352},{7,11,401},{7,11,1410},{7,11,1594},{7,11,1674},{8,11,63},{8,11,
-660},{137,11,74},{7,0,349},{5,10,85},{6,10,419},{7,10,305},{7,10,361},{7,10,1337
-},{8,10,71},{140,10,519},{4,11,139},{4,11,388},{140,11,188},{6,0,1972},{6,0,2013
-},{8,0,951},{10,0,947},{10,0,974},{10,0,1018},{142,0,476},{140,10,688},{135,10,
-740},{5,10,691},{7,10,345},{9,10,94},{140,10,169},{9,0,344},{5,10,183},{6,10,582
-},{10,10,679},{140,10,435},{135,10,511},{132,0,850},{8,11,441},{10,11,314},{143,
-11,3},{7,10,1993},{136,10,684},{4,11,747},{6,11,290},{6,10,583},{7,11,649},{7,11
-,1479},{135,11,1583},{133,11,232},{133,10,704},{134,0,910},{4,10,179},{5,10,198}
-,{133,10,697},{7,10,347},{7,10,971},{8,10,181},{138,10,711},{136,11,525},{14,0,
-19},{14,0,28},{144,0,29},{7,0,85},{7,0,247},{8,0,585},{138,0,163},{4,0,487},{7,
-11,472},{7,11,1801},{10,11,748},{141,11,458},{4,10,243},{5,10,203},{7,10,19},{7,
-10,71},{7,10,113},{10,10,405},{11,10,357},{142,10,240},{7,10,1450},{139,10,99},{
-132,11,425},{138,0,145},{147,0,83},{6,10,492},{137,11,247},{4,0,1013},{134,0,
-2033},{5,10,134},{6,10,408},{6,10,495},{135,10,1593},{135,0,1922},{134,11,1768},
-{4,0,124},{10,0,457},{11,0,121},{11,0,169},{11,0,870},{11,0,874},{12,0,214},{14,
-0,187},{143,0,77},{5,0,557},{135,0,1457},{139,0,66},{5,11,943},{6,11,1779},{142,
-10,4},{4,10,248},{4,10,665},{7,10,137},{137,10,349},{7,0,1193},{5,11,245},{6,11,
-576},{7,11,582},{136,11,225},{144,0,82},{7,10,1270},{139,10,612},{5,0,454},{10,0
-,352},{138,11,352},{18,0,57},{5,10,371},{135,10,563},{135,0,1333},{6,0,107},{7,0
-,638},{7,0,1632},{9,0,396},{134,11,610},{5,0,370},{134,0,1756},{4,10,374},{7,10,
-547},{7,10,1700},{7,10,1833},{139,10,858},{133,0,204},{6,0,1305},{9,10,311},{141
-,10,42},{5,0,970},{134,0,1706},{6,10,1647},{7,10,1552},{7,10,2010},{9,10,494},{
-137,10,509},{13,11,455},{15,11,99},{15,11,129},{144,11,68},{135,0,3},{4,0,35},{5
-,0,121},{5,0,483},{5,0,685},{6,0,489},{6,0,782},{6,0,1032},{7,0,1204},{136,0,394
-},{4,0,921},{133,0,1007},{8,11,360},{138,11,63},{135,0,1696},{134,0,1519},{132,
-11,443},{135,11,944},{6,10,123},{7,10,214},{9,10,728},{10,10,157},{11,10,346},{
-11,10,662},{143,10,106},{137,0,981},{135,10,1435},{134,0,1072},{132,0,712},{134,
-0,1629},{134,0,728},{4,11,298},{137,11,483},{6,0,1177},{6,0,1271},{5,11,164},{7,
-11,121},{142,11,189},{7,0,1608},{4,10,707},{5,10,588},{6,10,393},{13,10,106},{18
-,10,49},{147,10,41},{23,0,16},{151,11,16},{6,10,211},{7,10,1690},{11,10,486},{
-140,10,369},{133,0,485},{19,11,15},{149,11,27},{4,11,172},{9,11,611},{10,11,436}
-,{12,11,673},{141,11,255},{5,11,844},{10,11,484},{11,11,754},{12,11,457},{14,11,
-171},{14,11,389},{146,11,153},{4,0,285},{5,0,27},{5,0,317},{6,0,301},{7,0,7},{8,
-0,153},{10,0,766},{11,0,468},{12,0,467},{141,0,143},{134,0,1462},{9,11,263},{10,
-11,147},{138,11,492},{133,11,537},{6,0,1945},{6,0,1986},{6,0,1991},{134,0,2038},
-{134,10,219},{137,11,842},{14,0,52},{17,0,50},{5,10,582},{6,10,1646},{7,10,99},{
-7,10,1962},{7,10,1986},{8,10,515},{8,10,773},{9,10,23},{9,10,491},{12,10,620},{
-142,10,93},{138,11,97},{20,0,21},{20,0,44},{133,10,851},{136,0,819},{139,0,917},
-{5,11,230},{5,11,392},{6,11,420},{8,10,762},{8,10,812},{9,11,568},{9,10,910},{
-140,11,612},{135,0,784},{15,0,135},{143,11,135},{10,0,454},{140,0,324},{4,11,0},
-{5,11,41},{7,11,1459},{7,11,1469},{7,11,1618},{7,11,1859},{9,11,549},{139,11,905
-},{4,10,98},{7,10,1365},{9,10,422},{9,10,670},{10,10,775},{11,10,210},{13,10,26}
-,{13,10,457},{141,10,476},{6,0,1719},{6,0,1735},{7,0,2016},{7,0,2020},{8,0,837},
-{137,0,852},{133,11,696},{135,0,852},{132,0,952},{134,10,1730},{132,11,771},{138
-,0,568},{137,0,448},{139,0,146},{8,0,67},{138,0,419},{133,11,921},{137,10,147},{
-134,0,1826},{10,0,657},{14,0,297},{142,0,361},{6,0,666},{6,0,767},{134,0,1542},{
-139,0,729},{6,11,180},{7,11,1137},{8,11,751},{139,11,805},{4,11,183},{7,11,271},
-{11,11,824},{11,11,952},{13,11,278},{13,11,339},{13,11,482},{14,11,424},{148,11,
-99},{4,0,669},{5,11,477},{5,11,596},{6,11,505},{7,11,1221},{11,11,907},{12,11,
-209},{141,11,214},{135,11,1215},{5,0,402},{6,10,30},{11,10,56},{139,10,305},{7,
-11,564},{142,11,168},{139,0,152},{7,0,912},{135,10,1614},{4,10,150},{5,10,303},{
-134,10,327},{7,0,320},{8,0,51},{9,0,868},{10,0,833},{12,0,481},{12,0,570},{148,0
-,106},{132,0,445},{7,11,274},{11,11,263},{11,11,479},{11,11,507},{140,11,277},{
-10,0,555},{11,0,308},{19,0,95},{6,11,1645},{8,10,192},{10,10,78},{141,10,359},{
-135,10,786},{6,11,92},{6,11,188},{7,11,1269},{7,11,1524},{7,11,1876},{10,11,228}
-,{139,11,1020},{4,11,459},{133,11,966},{11,0,386},{6,10,1638},{7,10,79},{7,10,
-496},{9,10,138},{10,10,336},{12,10,412},{12,10,440},{142,10,305},{133,0,239},{7,
-0,83},{7,0,1990},{8,0,130},{139,0,720},{138,11,709},{4,0,143},{5,0,550},{133,0,
-752},{5,0,123},{6,0,530},{7,0,348},{135,0,1419},{135,0,2024},{6,11,18},{7,11,179
-},{7,11,721},{7,11,932},{8,11,548},{8,11,757},{9,11,54},{9,11,65},{9,11,532},{9,
-11,844},{10,11,113},{10,11,117},{10,11,236},{10,11,315},{10,11,430},{10,11,798},
-{11,11,153},{11,11,351},{11,11,375},{12,11,78},{12,11,151},{12,11,392},{14,11,
-248},{143,11,23},{7,10,204},{7,10,415},{8,10,42},{10,10,85},{139,10,564},{134,0,
-958},{133,11,965},{132,0,210},{135,11,1429},{138,11,480},{134,11,182},{139,11,
-345},{10,11,65},{10,11,488},{138,11,497},{4,10,3},{5,10,247},{5,10,644},{7,10,
-744},{7,10,1207},{7,10,1225},{7,10,1909},{146,10,147},{132,0,430},{5,10,285},{9,
-10,67},{13,10,473},{143,10,82},{144,11,16},{7,11,1162},{9,11,588},{10,11,260},{
-151,10,8},{133,0,213},{138,0,7},{135,0,801},{134,11,1786},{135,11,308},{6,0,936}
-,{134,0,1289},{133,0,108},{132,0,885},{133,0,219},{139,0,587},{4,0,193},{5,0,916
-},{6,0,1041},{7,0,364},{10,0,398},{10,0,726},{11,0,317},{11,0,626},{12,0,142},{
-12,0,288},{12,0,678},{13,0,313},{15,0,113},{146,0,114},{135,0,1165},{6,0,241},{9
-,0,342},{10,0,729},{11,0,284},{11,0,445},{11,0,651},{11,0,863},{13,0,398},{146,0
-,99},{7,0,907},{136,0,832},{9,0,303},{4,10,29},{6,10,532},{7,10,1628},{7,10,1648
-},{9,10,350},{10,10,433},{11,10,97},{11,10,557},{11,10,745},{12,10,289},{12,10,
-335},{12,10,348},{12,10,606},{13,10,116},{13,10,233},{13,10,466},{14,10,181},{14
-,10,209},{14,10,232},{14,10,236},{14,10,300},{16,10,41},{148,10,97},{7,11,423},{
-7,10,1692},{136,11,588},{6,0,931},{134,0,1454},{5,10,501},{7,10,1704},{9,10,553}
-,{11,10,520},{12,10,557},{141,10,249},{136,11,287},{4,0,562},{9,0,254},{139,0,
-879},{132,0,786},{14,11,32},{18,11,85},{20,11,2},{152,11,16},{135,0,1294},{7,11,
-723},{135,11,1135},{6,0,216},{7,0,901},{7,0,1343},{8,0,493},{134,11,403},{7,11,
-719},{8,11,809},{136,11,834},{5,11,210},{6,11,213},{7,11,60},{10,11,364},{139,11
-,135},{7,0,341},{11,0,219},{5,11,607},{8,11,326},{136,11,490},{4,11,701},{5,11,
-472},{5,11,639},{7,11,1249},{9,11,758},{139,11,896},{135,11,380},{135,11,1947},{
-139,0,130},{135,0,1734},{10,0,115},{11,0,420},{12,0,154},{13,0,404},{14,0,346},{
-143,0,54},{134,10,129},{4,11,386},{7,11,41},{8,11,405},{9,11,497},{11,11,110},{
-11,11,360},{15,11,37},{144,11,84},{141,11,282},{5,11,46},{7,11,1452},{7,11,1480}
-,{8,11,634},{140,11,472},{4,11,524},{136,11,810},{10,11,238},{141,11,33},{133,0,
-604},{5,0,1011},{136,0,701},{8,0,856},{8,0,858},{8,0,879},{12,0,702},{142,0,447}
-,{4,0,54},{5,0,666},{7,0,1039},{7,0,1130},{9,0,195},{138,0,302},{4,10,25},{5,10,
-60},{6,10,504},{7,10,614},{7,10,1155},{140,10,0},{7,10,1248},{11,10,621},{139,10
-,702},{133,11,997},{137,10,321},{134,0,1669},{134,0,1791},{4,10,379},{135,10,
-1397},{138,11,372},{5,11,782},{5,11,829},{134,11,1738},{135,0,1228},{4,10,118},{
-6,10,274},{6,10,361},{7,10,75},{141,10,441},{132,0,623},{9,11,279},{10,11,407},{
-14,11,84},{150,11,18},{137,10,841},{135,0,798},{140,10,693},{5,10,314},{6,10,221
-},{7,10,419},{10,10,650},{11,10,396},{12,10,156},{13,10,369},{14,10,333},{145,10
-,47},{135,11,1372},{7,0,122},{9,0,259},{10,0,84},{11,0,470},{12,0,541},{141,0,
-379},{134,0,837},{8,0,1013},{4,11,78},{5,11,96},{5,11,182},{7,11,1724},{7,11,
-1825},{10,11,394},{10,11,471},{11,11,532},{14,11,340},{145,11,88},{134,0,577},{
-135,11,1964},{132,10,913},{134,0,460},{8,0,891},{10,0,901},{10,0,919},{10,0,932}
-,{12,0,715},{12,0,728},{12,0,777},{14,0,457},{144,0,103},{5,0,82},{5,0,131},{7,0
-,1755},{8,0,31},{9,0,168},{9,0,764},{139,0,869},{136,10,475},{6,0,605},{5,10,
-1016},{9,11,601},{9,11,619},{10,11,505},{10,11,732},{11,11,355},{140,11,139},{7,
-10,602},{8,10,179},{10,10,781},{140,10,126},{134,0,1246},{6,10,329},{138,10,111}
-,{6,11,215},{7,11,1028},{7,11,1473},{7,11,1721},{9,11,424},{138,11,779},{5,0,278
-},{137,0,68},{6,0,932},{6,0,1084},{144,0,86},{4,0,163},{5,0,201},{5,0,307},{5,0,
-310},{6,0,335},{7,0,284},{7,0,1660},{136,0,165},{136,0,781},{134,0,707},{6,0,33}
-,{135,0,1244},{5,10,821},{6,11,67},{6,10,1687},{7,11,258},{7,11,1630},{9,11,354}
-,{9,11,675},{10,11,830},{14,11,80},{145,11,80},{6,11,141},{7,11,225},{9,11,59},{
-9,11,607},{10,11,312},{11,11,687},{12,11,555},{13,11,373},{13,11,494},{148,11,58
-},{134,0,1113},{9,0,388},{5,10,71},{7,10,1407},{9,10,704},{10,10,261},{10,10,619
-},{11,10,547},{11,10,619},{143,10,157},{7,0,1953},{136,0,720},{138,0,203},{7,10,
-2008},{9,10,337},{138,10,517},{6,0,326},{7,0,677},{137,0,425},{139,11,81},{7,0,
-1316},{7,0,1412},{7,0,1839},{9,0,589},{11,0,241},{11,0,676},{11,0,811},{11,0,891
-},{12,0,140},{12,0,346},{12,0,479},{13,0,140},{13,0,381},{14,0,188},{18,0,30},{
-148,0,108},{5,0,416},{6,10,86},{6,10,603},{7,10,292},{7,10,561},{8,10,257},{8,10
-,382},{9,10,721},{9,10,778},{11,10,581},{140,10,466},{4,10,486},{133,10,491},{
-134,0,1300},{132,10,72},{7,0,847},{6,10,265},{7,11,430},{139,11,46},{5,11,602},{
-6,11,106},{7,11,1786},{7,11,1821},{7,11,2018},{9,11,418},{137,11,763},{5,0,358},
-{7,0,535},{7,0,1184},{10,0,662},{13,0,212},{13,0,304},{13,0,333},{145,0,98},{5,
-11,65},{6,11,416},{7,11,1720},{7,11,1924},{8,11,677},{10,11,109},{11,11,14},{11,
-11,70},{11,11,569},{11,11,735},{15,11,153},{148,11,80},{6,0,1823},{8,0,839},{8,0
-,852},{8,0,903},{10,0,940},{12,0,707},{140,0,775},{135,11,1229},{6,0,1522},{140,
-0,654},{136,11,595},{139,0,163},{141,0,314},{132,0,978},{4,0,601},{6,0,2035},{
-137,10,234},{5,10,815},{6,10,1688},{134,10,1755},{133,0,946},{136,0,434},{6,10,
-197},{136,10,205},{7,0,411},{7,0,590},{8,0,631},{9,0,323},{10,0,355},{11,0,491},
-{12,0,143},{12,0,402},{13,0,73},{14,0,408},{15,0,107},{146,0,71},{7,0,1467},{8,0
-,328},{10,0,544},{11,0,955},{12,0,13},{13,0,320},{145,0,83},{142,0,410},{11,0,
-511},{13,0,394},{14,0,298},{14,0,318},{146,0,103},{6,10,452},{7,10,312},{138,10,
-219},{138,10,589},{4,10,333},{9,10,176},{12,10,353},{141,10,187},{135,11,329},{
-132,11,469},{5,0,835},{134,0,483},{134,11,1743},{5,11,929},{6,11,340},{8,11,376}
-,{136,11,807},{134,10,1685},{132,0,677},{5,11,218},{7,11,1610},{138,11,83},{5,11
-,571},{135,11,1842},{132,11,455},{137,0,70},{135,0,1405},{7,10,135},{8,10,7},{8,
-10,62},{9,10,243},{10,10,658},{10,10,697},{11,10,456},{139,10,756},{9,10,395},{
-138,10,79},{137,0,108},{6,11,161},{7,11,372},{137,11,597},{132,11,349},{132,0,
-777},{132,0,331},{135,10,631},{133,0,747},{6,11,432},{6,11,608},{139,11,322},{
-138,10,835},{5,11,468},{7,11,1809},{10,11,325},{11,11,856},{12,11,345},{143,11,
-104},{133,11,223},{7,10,406},{7,10,459},{8,10,606},{139,10,726},{132,11,566},{
-142,0,68},{4,11,59},{135,11,1394},{6,11,436},{139,11,481},{4,11,48},{5,11,271},{
-135,11,953},{139,11,170},{5,11,610},{136,11,457},{133,11,755},{135,11,1217},{133
-,10,612},{132,11,197},{132,0,505},{4,10,372},{7,10,482},{8,10,158},{9,10,602},{9
-,10,615},{10,10,245},{10,10,678},{10,10,744},{11,10,248},{139,10,806},{133,0,326
-},{5,10,854},{135,10,1991},{4,0,691},{146,0,16},{6,0,628},{9,0,35},{10,0,680},{
-10,0,793},{11,0,364},{13,0,357},{143,0,164},{138,0,654},{6,0,32},{7,0,385},{7,0,
-757},{7,0,1916},{8,0,37},{8,0,94},{8,0,711},{9,0,541},{10,0,162},{10,0,795},{11,
-0,989},{11,0,1010},{12,0,14},{142,0,308},{133,11,217},{6,0,152},{6,0,349},{6,0,
-1682},{7,0,1252},{8,0,112},{9,0,435},{9,0,668},{10,0,290},{10,0,319},{10,0,815},
-{11,0,180},{11,0,837},{12,0,240},{13,0,152},{13,0,219},{142,0,158},{4,0,581},{
-134,0,726},{5,10,195},{135,10,1685},{6,0,126},{7,0,573},{8,0,397},{142,0,44},{
-138,0,89},{7,10,1997},{8,10,730},{139,10,1006},{134,0,1531},{134,0,1167},{5,0,
-926},{12,0,203},{133,10,751},{4,11,165},{7,11,1398},{135,11,1829},{7,0,1232},{
-137,0,531},{135,10,821},{134,0,943},{133,0,670},{4,0,880},{139,0,231},{134,0,
-1617},{135,0,1957},{5,11,9},{7,11,297},{7,11,966},{140,11,306},{6,0,975},{134,0,
-985},{5,10,950},{5,10,994},{134,10,351},{12,11,21},{151,11,7},{5,11,146},{6,11,
-411},{138,11,721},{7,0,242},{135,0,1942},{6,11,177},{135,11,467},{5,0,421},{7,10
-,47},{137,10,684},{5,0,834},{7,0,1202},{8,0,14},{9,0,481},{137,0,880},{138,0,465
-},{6,0,688},{9,0,834},{132,10,350},{132,0,855},{4,0,357},{6,0,172},{7,0,143},{
-137,0,413},{133,11,200},{132,0,590},{7,10,1812},{13,10,259},{13,10,356},{14,10,
-242},{147,10,114},{133,10,967},{11,0,114},{4,10,473},{7,10,623},{8,10,808},{9,10
-,871},{9,10,893},{11,10,431},{12,10,112},{12,10,217},{12,10,243},{12,10,562},{12
-,10,663},{12,10,683},{13,10,141},{13,10,197},{13,10,227},{13,10,406},{13,10,487}
-,{14,10,156},{14,10,203},{14,10,224},{14,10,256},{18,10,58},{150,10,0},{138,10,
-286},{4,10,222},{7,10,286},{136,10,629},{5,0,169},{7,0,333},{136,0,45},{134,11,
-481},{132,0,198},{4,0,24},{5,0,140},{5,0,185},{7,0,1500},{11,0,565},{11,0,838},{
-4,11,84},{7,11,1482},{10,11,76},{138,11,142},{133,0,585},{141,10,306},{133,11,
-1015},{4,11,315},{5,11,507},{135,11,1370},{136,10,146},{6,0,691},{134,0,1503},{4
-,0,334},{133,0,593},{4,10,465},{135,10,1663},{142,11,173},{135,0,913},{12,0,116}
-,{134,11,1722},{134,0,1360},{132,0,802},{8,11,222},{8,11,476},{9,11,238},{11,11,
-516},{11,11,575},{15,11,109},{146,11,100},{6,0,308},{9,0,673},{7,10,138},{7,10,
-517},{139,10,238},{132,0,709},{6,0,1876},{6,0,1895},{9,0,994},{9,0,1006},{12,0,
-829},{12,0,888},{12,0,891},{146,0,185},{148,10,94},{4,0,228},{133,0,897},{7,0,
-1840},{5,10,495},{7,10,834},{9,10,733},{139,10,378},{133,10,559},{6,10,21},{6,10
-,1737},{7,10,1444},{136,10,224},{4,0,608},{133,0,497},{6,11,40},{135,11,1781},{
-134,0,1573},{135,0,2039},{6,0,540},{136,0,136},{4,0,897},{5,0,786},{133,10,519},
-{6,0,1878},{6,0,1884},{9,0,938},{9,0,948},{9,0,955},{9,0,973},{9,0,1012},{12,0,
-895},{12,0,927},{143,0,254},{134,0,1469},{133,0,999},{4,0,299},{135,0,1004},{4,0
-,745},{133,0,578},{136,11,574},{133,0,456},{134,0,1457},{7,0,1679},{132,10,402},
-{7,0,693},{8,0,180},{12,0,163},{8,10,323},{136,10,479},{11,10,580},{142,10,201},
-{5,10,59},{135,10,672},{132,11,354},{146,10,34},{4,0,755},{135,11,1558},{7,0,
-1740},{146,0,48},{4,10,85},{135,10,549},{139,0,338},{133,10,94},{134,0,1091},{
-135,11,469},{12,0,695},{12,0,704},{20,0,113},{5,11,830},{14,11,338},{148,11,81},
-{135,0,1464},{6,10,11},{135,10,187},{135,0,975},{13,0,335},{132,10,522},{134,0,
-1979},{5,11,496},{135,11,203},{4,10,52},{135,10,661},{7,0,1566},{8,0,269},{9,0,
-212},{9,0,718},{14,0,15},{14,0,132},{142,0,227},{4,0,890},{5,0,805},{5,0,819},{5
-,0,961},{6,0,396},{6,0,1631},{6,0,1678},{7,0,1967},{7,0,2041},{9,0,630},{11,0,8}
-,{11,0,1019},{12,0,176},{13,0,225},{14,0,292},{21,0,24},{4,10,383},{133,10,520},
-{134,11,547},{135,11,1748},{5,11,88},{137,11,239},{146,11,128},{7,11,650},{135,
-11,1310},{4,10,281},{5,10,38},{7,10,194},{7,10,668},{7,10,1893},{137,10,397},{
-135,0,1815},{9,10,635},{139,10,559},{7,0,1505},{10,0,190},{10,0,634},{11,0,792},
-{12,0,358},{140,0,447},{5,0,0},{6,0,536},{7,0,604},{13,0,445},{145,0,126},{7,11,
-1076},{9,11,80},{11,11,78},{11,11,421},{11,11,534},{140,11,545},{8,0,966},{10,0,
-1023},{14,11,369},{146,11,72},{135,11,1641},{6,0,232},{6,0,412},{7,0,1074},{8,0,
-9},{8,0,157},{8,0,786},{9,0,196},{9,0,352},{9,0,457},{10,0,337},{11,0,232},{11,0
-,877},{12,0,480},{140,0,546},{135,0,958},{4,0,382},{136,0,579},{4,0,212},{135,0,
-1206},{4,11,497},{5,11,657},{135,11,1584},{132,0,681},{8,0,971},{138,0,965},{5,
-10,448},{136,10,535},{14,0,16},{146,0,44},{11,0,584},{11,0,616},{14,0,275},{11,
-11,584},{11,11,616},{142,11,275},{136,11,13},{7,10,610},{135,10,1501},{7,11,642}
-,{8,11,250},{11,11,123},{11,11,137},{13,11,48},{142,11,95},{133,0,655},{17,0,67}
-,{147,0,74},{134,0,751},{134,0,1967},{6,0,231},{136,0,423},{5,0,300},{138,0,1016
-},{4,10,319},{5,10,699},{138,10,673},{6,0,237},{7,0,611},{8,0,100},{9,0,416},{11
-,0,335},{12,0,173},{18,0,101},{6,10,336},{8,10,552},{9,10,285},{10,10,99},{139,
-10,568},{134,0,1370},{7,10,1406},{9,10,218},{141,10,222},{133,10,256},{135,0,
-1208},{14,11,213},{148,11,38},{6,0,1219},{135,11,1642},{13,0,417},{14,0,129},{
-143,0,15},{10,11,545},{140,11,301},{17,10,39},{148,10,36},{133,0,199},{4,11,904}
-,{133,11,794},{12,0,427},{146,0,38},{134,0,949},{8,0,665},{135,10,634},{132,10,
-618},{135,10,259},{132,10,339},{133,11,761},{141,10,169},{132,10,759},{5,0,688},
-{7,0,539},{135,0,712},{7,11,386},{138,11,713},{134,0,1186},{6,11,7},{6,11,35},{7
-,11,147},{7,11,1069},{7,11,1568},{7,11,1575},{7,11,1917},{8,11,43},{8,11,208},{9
-,11,128},{9,11,866},{10,11,20},{11,11,981},{147,11,33},{7,11,893},{8,10,482},{
-141,11,424},{6,0,312},{6,0,1715},{10,0,584},{11,0,546},{11,0,692},{12,0,259},{12
-,0,295},{13,0,46},{141,0,154},{5,10,336},{6,10,341},{6,10,478},{6,10,1763},{136,
-10,386},{137,0,151},{132,0,588},{152,0,4},{6,11,322},{9,11,552},{11,11,274},{13,
-11,209},{13,11,499},{14,11,85},{15,11,126},{145,11,70},{135,10,73},{4,0,231},{5,
-0,61},{6,0,104},{7,0,729},{7,0,964},{7,0,1658},{140,0,414},{6,0,263},{138,0,757}
-,{135,10,1971},{4,0,612},{133,0,561},{132,0,320},{135,10,1344},{8,11,83},{8,11,
-817},{9,11,28},{9,11,29},{9,11,885},{10,11,387},{11,11,633},{11,11,740},{13,11,
-235},{13,11,254},{15,11,143},{143,11,146},{5,10,396},{134,10,501},{140,11,49},{
-132,0,225},{4,10,929},{5,10,799},{8,10,46},{136,10,740},{4,0,405},{7,0,817},{14,
-0,58},{17,0,37},{146,0,124},{133,0,974},{4,11,412},{133,11,581},{4,10,892},{133,
-10,770},{4,0,996},{134,0,2026},{4,0,527},{5,0,235},{7,0,1239},{11,0,131},{140,0,
-370},{9,0,16},{13,0,386},{135,11,421},{7,0,956},{7,0,1157},{7,0,1506},{7,0,1606}
-,{7,0,1615},{7,0,1619},{7,0,1736},{7,0,1775},{8,0,590},{9,0,324},{9,0,736},{9,0,
-774},{9,0,776},{9,0,784},{10,0,567},{10,0,708},{11,0,518},{11,0,613},{11,0,695},
-{11,0,716},{11,0,739},{11,0,770},{11,0,771},{11,0,848},{11,0,857},{11,0,931},{11
-,0,947},{12,0,326},{12,0,387},{12,0,484},{12,0,528},{12,0,552},{12,0,613},{13,0,
-189},{13,0,256},{13,0,340},{13,0,432},{13,0,436},{13,0,440},{13,0,454},{14,0,174
-},{14,0,220},{14,0,284},{14,0,390},{145,0,121},{135,10,158},{9,0,137},{138,0,221
-},{4,11,110},{10,11,415},{10,11,597},{142,11,206},{141,11,496},{135,11,205},{151
-,10,25},{135,11,778},{7,11,1656},{7,10,2001},{9,11,369},{10,11,338},{10,11,490},
-{11,11,154},{11,11,545},{11,11,775},{13,11,77},{141,11,274},{4,11,444},{10,11,
-146},{140,11,9},{7,0,390},{138,0,140},{135,0,1144},{134,0,464},{7,10,1461},{140,
-10,91},{132,10,602},{4,11,283},{135,11,1194},{5,0,407},{11,0,204},{11,0,243},{11
-,0,489},{12,0,293},{19,0,37},{20,0,73},{150,0,38},{7,0,1218},{136,0,303},{5,0,
-325},{8,0,5},{8,0,227},{9,0,105},{10,0,585},{12,0,614},{4,10,13},{5,10,567},{7,
-10,1498},{9,10,124},{11,10,521},{140,10,405},{135,10,1006},{7,0,800},{10,0,12},{
-134,11,1720},{135,0,1783},{132,10,735},{138,10,812},{4,10,170},{135,10,323},{6,0
-,621},{13,0,504},{144,0,89},{5,10,304},{135,10,1403},{137,11,216},{6,0,920},{6,0
-,1104},{9,11,183},{139,11,286},{4,0,376},{133,10,742},{134,0,218},{8,0,641},{11,
-0,388},{140,0,580},{7,0,454},{7,0,782},{8,0,768},{140,0,686},{137,11,33},{133,10
-,111},{144,0,0},{10,0,676},{140,0,462},{6,0,164},{136,11,735},{133,10,444},{150,
-0,50},{7,11,1862},{12,11,491},{12,11,520},{13,11,383},{14,11,244},{146,11,12},{5
-,11,132},{9,11,486},{9,11,715},{10,11,458},{11,11,373},{11,11,668},{11,11,795},{
-11,11,897},{12,11,272},{12,11,424},{12,11,539},{12,11,558},{14,11,245},{14,11,
-263},{14,11,264},{14,11,393},{142,11,403},{8,10,123},{15,10,6},{144,10,7},{6,0,
-285},{8,0,654},{11,0,749},{12,0,190},{12,0,327},{13,0,120},{13,0,121},{13,0,327}
-,{15,0,47},{146,0,40},{5,11,8},{6,11,89},{6,11,400},{7,11,1569},{7,11,1623},{7,
-11,1850},{8,11,218},{8,11,422},{9,11,570},{138,11,626},{6,11,387},{7,11,882},{
-141,11,111},{6,0,343},{7,0,195},{9,0,226},{10,0,197},{10,0,575},{11,0,502},{11,0
-,899},{6,11,224},{7,11,877},{137,11,647},{5,10,937},{135,10,100},{135,11,790},{
-150,0,29},{147,0,8},{134,0,1812},{149,0,8},{135,11,394},{7,0,1125},{9,0,143},{11
-,0,61},{14,0,405},{150,0,21},{10,11,755},{147,11,29},{9,11,378},{141,11,162},{
-135,10,922},{5,10,619},{133,10,698},{134,0,1327},{6,0,1598},{137,0,575},{9,11,
-569},{12,11,12},{12,11,81},{12,11,319},{13,11,69},{14,11,259},{16,11,87},{17,11,
-1},{17,11,21},{17,11,24},{18,11,15},{18,11,56},{18,11,59},{18,11,127},{18,11,154
-},{19,11,19},{148,11,31},{6,0,895},{135,11,1231},{5,0,959},{7,11,124},{136,11,38
-},{5,11,261},{7,11,78},{7,11,199},{8,11,815},{9,11,126},{138,11,342},{5,10,917},
-{134,10,1659},{7,0,1759},{5,11,595},{135,11,1863},{136,0,173},{134,0,266},{142,0
-,261},{132,11,628},{5,10,251},{5,10,956},{8,10,268},{9,10,214},{146,10,142},{7,
-11,266},{136,11,804},{135,11,208},{6,11,79},{7,11,1021},{135,11,1519},{11,11,704
-},{141,11,396},{5,10,346},{5,10,711},{136,10,390},{136,11,741},{134,11,376},{134
-,0,1427},{6,0,1033},{6,0,1217},{136,0,300},{133,10,624},{6,11,100},{7,11,244},{7
-,11,632},{7,11,1609},{8,11,178},{8,11,638},{141,11,58},{6,0,584},{5,10,783},{7,
-10,1998},{135,10,2047},{5,0,427},{5,0,734},{7,0,478},{136,0,52},{7,0,239},{11,0,
-217},{142,0,165},{134,0,1129},{6,0,168},{6,0,1734},{7,0,20},{7,0,1056},{8,0,732}
-,{9,0,406},{9,0,911},{138,0,694},{132,10,594},{133,11,791},{7,11,686},{8,11,33},
-{8,11,238},{10,11,616},{11,11,467},{11,11,881},{13,11,217},{13,11,253},{142,11,
-268},{137,11,476},{134,0,418},{133,0,613},{132,0,632},{132,11,447},{7,0,32},{7,0
-,984},{8,0,85},{8,0,709},{9,0,579},{9,0,847},{9,0,856},{10,0,799},{11,0,258},{11
-,0,1007},{12,0,331},{12,0,615},{13,0,188},{13,0,435},{14,0,8},{15,0,165},{16,0,
-27},{20,0,40},{144,11,35},{4,11,128},{5,11,415},{6,11,462},{7,11,294},{7,11,578}
-,{10,11,710},{139,11,86},{5,0,694},{136,0,909},{7,0,1109},{11,0,7},{5,10,37},{6,
-10,39},{6,10,451},{7,10,218},{7,10,1166},{7,10,1687},{8,10,662},{144,10,2},{136,
-11,587},{6,11,427},{7,11,1018},{138,11,692},{4,11,195},{6,10,508},{135,11,802},{
-4,0,167},{135,0,82},{5,0,62},{6,0,24},{6,0,534},{7,0,74},{7,0,678},{7,0,684},{7,
-0,1043},{7,0,1072},{8,0,280},{8,0,541},{8,0,686},{9,0,258},{10,0,519},{11,0,252}
-,{140,0,282},{138,0,33},{4,0,359},{133,11,738},{7,0,980},{9,0,328},{13,0,186},{
-13,0,364},{7,10,635},{7,10,796},{8,10,331},{9,10,330},{9,10,865},{10,10,119},{10
-,10,235},{11,10,111},{11,10,129},{11,10,240},{12,10,31},{12,10,66},{12,10,222},{
-12,10,269},{12,10,599},{12,10,684},{12,10,689},{12,10,691},{142,10,345},{137,10,
-527},{6,0,596},{7,0,585},{135,10,702},{134,11,1683},{133,0,211},{6,0,145},{141,0
-,336},{134,0,1130},{7,0,873},{6,10,37},{7,10,1666},{8,10,195},{8,10,316},{9,10,
-178},{9,10,276},{9,10,339},{9,10,536},{10,10,102},{10,10,362},{10,10,785},{11,10
-,55},{11,10,149},{11,10,773},{13,10,416},{13,10,419},{14,10,38},{14,10,41},{142,
-10,210},{8,0,840},{136,0,841},{132,0,263},{5,11,3},{8,11,578},{9,11,118},{10,11,
-705},{12,11,383},{141,11,279},{132,0,916},{133,11,229},{133,10,645},{15,0,155},{
-16,0,79},{8,11,102},{10,11,578},{10,11,672},{12,11,496},{13,11,408},{14,11,121},
-{145,11,106},{4,0,599},{5,0,592},{6,0,1634},{7,0,5},{7,0,55},{7,0,67},{7,0,97},{
-7,0,691},{7,0,979},{7,0,1600},{7,0,1697},{8,0,207},{8,0,214},{8,0,231},{8,0,294}
-,{8,0,336},{8,0,428},{8,0,471},{8,0,622},{8,0,626},{8,0,679},{8,0,759},{8,0,829}
-,{9,0,11},{9,0,246},{9,0,484},{9,0,573},{9,0,706},{9,0,762},{9,0,798},{9,0,855},
-{9,0,870},{9,0,912},{10,0,303},{10,0,335},{10,0,424},{10,0,461},{10,0,543},{10,0
-,759},{10,0,814},{11,0,59},{11,0,199},{11,0,235},{11,0,590},{11,0,631},{11,0,929
-},{11,0,963},{11,0,987},{12,0,114},{12,0,182},{12,0,226},{12,0,332},{12,0,439},{
-12,0,575},{12,0,598},{12,0,675},{13,0,8},{13,0,125},{13,0,194},{13,0,287},{14,0,
-197},{14,0,383},{15,0,53},{17,0,63},{19,0,46},{19,0,98},{19,0,106},{148,0,85},{7
-,0,1356},{132,10,290},{6,10,70},{7,10,1292},{10,10,762},{139,10,288},{150,11,55}
-,{4,0,593},{8,11,115},{8,11,350},{9,11,489},{10,11,128},{11,11,306},{12,11,373},
-{14,11,30},{17,11,79},{147,11,80},{135,11,1235},{134,0,1392},{4,11,230},{133,11,
-702},{147,0,126},{7,10,131},{7,10,422},{8,10,210},{140,10,573},{134,0,1179},{139
-,11,435},{139,10,797},{134,11,1728},{4,0,162},{18,11,26},{19,11,42},{20,11,43},{
-21,11,0},{23,11,27},{152,11,14},{132,10,936},{6,0,765},{5,10,453},{134,10,441},{
-133,0,187},{135,0,1286},{6,0,635},{6,0,904},{6,0,1210},{134,0,1489},{4,0,215},{8
-,0,890},{9,0,38},{10,0,923},{11,0,23},{11,0,127},{139,0,796},{6,0,1165},{134,0,
-1306},{7,0,716},{13,0,97},{141,0,251},{132,10,653},{136,0,657},{146,10,80},{5,11
-,622},{7,11,1032},{11,11,26},{11,11,213},{11,11,707},{12,11,380},{13,11,226},{
-141,11,355},{6,0,299},{5,11,70},{6,11,334},{9,11,171},{11,11,637},{12,11,202},{
-14,11,222},{145,11,42},{142,0,134},{4,11,23},{5,11,313},{5,11,1014},{6,11,50},{6
-,11,51},{7,11,142},{7,11,384},{9,11,783},{139,11,741},{4,11,141},{7,11,559},{8,
-11,640},{9,11,460},{12,11,183},{141,11,488},{136,11,614},{7,10,1368},{8,10,232},
-{8,10,361},{10,10,682},{138,10,742},{137,10,534},{6,0,1082},{140,0,658},{137,10,
-27},{135,0,2002},{142,10,12},{4,0,28},{5,0,440},{7,0,248},{11,0,833},{140,0,344}
-,{7,10,736},{139,10,264},{134,10,1657},{134,0,1654},{138,0,531},{5,11,222},{9,11
-,140},{138,11,534},{6,0,634},{6,0,798},{134,0,840},{138,11,503},{135,10,127},{
-133,0,853},{5,11,154},{7,11,1491},{10,11,379},{138,11,485},{6,0,249},{7,0,1234},
-{139,0,573},{133,11,716},{7,11,1570},{140,11,542},{136,10,364},{138,0,527},{4,11
-,91},{5,11,388},{5,11,845},{6,11,206},{6,11,252},{6,11,365},{7,11,136},{7,11,531
-},{8,11,264},{136,11,621},{134,0,1419},{135,11,1441},{7,0,49},{7,0,392},{8,0,20}
-,{8,0,172},{8,0,690},{9,0,383},{9,0,845},{10,0,48},{11,0,293},{11,0,832},{11,0,
-920},{11,0,984},{141,0,221},{5,0,858},{133,0,992},{5,0,728},{137,10,792},{5,10,
-909},{9,10,849},{138,10,805},{7,0,525},{7,0,1579},{8,0,497},{136,0,573},{6,0,268
-},{137,0,62},{135,11,576},{134,0,1201},{5,11,771},{5,11,863},{5,11,898},{6,11,
-1632},{6,11,1644},{134,11,1780},{133,11,331},{7,0,193},{7,0,1105},{10,0,495},{7,
-10,397},{8,10,124},{8,10,619},{9,10,305},{11,10,40},{12,10,349},{13,10,134},{13,
-10,295},{14,10,155},{15,10,120},{146,10,105},{138,0,106},{6,0,859},{5,11,107},{7
-,11,201},{136,11,518},{6,11,446},{135,11,1817},{13,0,23},{4,10,262},{135,10,342}
-,{133,10,641},{137,11,851},{6,0,925},{137,0,813},{132,11,504},{6,0,613},{136,0,
-223},{4,10,99},{6,10,250},{6,10,346},{8,10,127},{138,10,81},{136,0,953},{132,10,
-915},{139,11,892},{5,10,75},{9,10,517},{10,10,470},{12,10,155},{141,10,224},{4,0
-,666},{7,0,1017},{7,11,996},{138,11,390},{5,11,883},{133,11,975},{14,10,83},{142
-,11,83},{4,0,670},{5,11,922},{134,11,1707},{135,0,216},{9,0,40},{11,0,136},{135,
-11,787},{5,10,954},{5,11,993},{7,11,515},{137,11,91},{139,0,259},{7,0,1114},{9,0
-,310},{9,0,682},{10,0,440},{13,0,40},{6,10,304},{8,10,418},{11,10,341},{139,10,
-675},{14,0,296},{9,10,410},{139,10,425},{10,11,377},{12,11,363},{13,11,68},{13,
-11,94},{14,11,108},{142,11,306},{7,0,1401},{135,0,1476},{4,0,296},{6,0,475},{7,0
-,401},{7,0,1410},{7,0,1594},{7,0,1674},{8,0,63},{8,0,660},{137,0,74},{4,0,139},{
-4,0,388},{140,0,188},{132,0,797},{132,11,766},{5,11,103},{7,11,921},{8,11,580},{
-8,11,593},{8,11,630},{138,11,28},{4,11,911},{5,11,867},{133,11,1013},{134,10,14}
-,{134,0,1572},{134,10,1708},{21,0,39},{5,10,113},{6,10,243},{7,10,1865},{11,10,
-161},{16,10,37},{145,10,99},{7,11,1563},{141,11,182},{5,11,135},{6,11,519},{7,11
-,1722},{10,11,271},{11,11,261},{145,11,54},{132,10,274},{134,0,1594},{4,11,300},
-{5,11,436},{135,11,484},{4,0,747},{6,0,290},{7,0,649},{7,0,1479},{135,0,1583},{
-133,11,535},{147,11,82},{133,0,232},{137,0,887},{135,10,166},{136,0,521},{4,0,14
-},{7,0,472},{7,0,1801},{10,0,748},{141,0,458},{134,0,741},{134,0,992},{16,0,111}
-,{137,10,304},{4,0,425},{5,11,387},{7,11,557},{12,11,547},{142,11,86},{135,11,
-1747},{5,10,654},{135,11,1489},{7,0,789},{4,11,6},{5,11,708},{136,11,75},{6,10,
-273},{10,10,188},{13,10,377},{146,10,77},{6,0,1593},{4,11,303},{7,11,619},{10,11
-,547},{10,11,687},{11,11,122},{140,11,601},{134,0,1768},{135,10,410},{138,11,772
-},{11,0,233},{139,10,524},{5,0,943},{134,0,1779},{134,10,1785},{136,11,529},{132
-,0,955},{5,0,245},{6,0,576},{7,0,582},{136,0,225},{132,10,780},{142,0,241},{134,
-0,1943},{4,11,106},{7,11,310},{7,11,1785},{10,11,690},{139,11,717},{134,0,1284},
-{5,11,890},{133,11,988},{6,11,626},{142,11,431},{10,11,706},{145,11,32},{137,11,
-332},{132,11,698},{135,0,709},{5,10,948},{138,11,17},{136,0,554},{134,0,1564},{
-139,10,941},{132,0,443},{134,0,909},{134,11,84},{142,0,280},{4,10,532},{5,10,706
-},{135,10,662},{132,0,729},{5,10,837},{6,10,1651},{139,10,985},{135,10,1861},{4,
-0,348},{152,11,3},{5,11,986},{6,11,130},{7,11,1582},{8,11,458},{10,11,101},{10,
-11,318},{138,11,823},{134,0,758},{4,0,298},{137,0,848},{4,10,330},{7,10,933},{7,
-10,2012},{136,10,292},{7,11,1644},{137,11,129},{6,0,1422},{9,0,829},{135,10,767}
-,{5,0,164},{7,0,121},{142,0,189},{7,0,812},{7,0,1261},{7,0,1360},{9,0,632},{140,
-0,352},{135,11,1788},{139,0,556},{135,11,997},{145,10,114},{4,0,172},{9,0,611},{
-10,0,436},{12,0,673},{13,0,255},{137,10,883},{11,0,530},{138,10,274},{133,0,844}
-,{134,0,984},{13,0,232},{18,0,35},{4,10,703},{135,10,207},{132,10,571},{9,0,263}
-,{10,0,147},{138,0,492},{7,11,1756},{137,11,98},{5,10,873},{5,10,960},{8,10,823}
-,{137,10,881},{133,0,537},{132,0,859},{7,11,1046},{139,11,160},{137,0,842},{139,
-10,283},{5,10,33},{6,10,470},{139,10,424},{6,11,45},{7,11,433},{8,11,129},{9,11,
-21},{10,11,392},{11,11,79},{12,11,499},{13,11,199},{141,11,451},{135,0,1291},{
-135,10,1882},{7,11,558},{136,11,353},{134,0,1482},{5,0,230},{5,0,392},{6,0,420},
-{9,0,568},{140,0,612},{6,0,262},{7,10,90},{7,10,664},{7,10,830},{7,10,1380},{7,
-10,2025},{8,11,81},{8,10,448},{8,10,828},{9,11,189},{9,11,201},{11,11,478},{11,
-11,712},{141,11,338},{142,0,31},{5,11,353},{151,11,26},{132,0,753},{4,0,0},{5,0,
-41},{7,0,1459},{7,0,1469},{7,0,1859},{9,0,549},{139,0,905},{9,10,417},{137,10,
-493},{135,11,1113},{133,0,696},{141,11,448},{134,10,295},{132,0,834},{4,0,771},{
-5,10,1019},{6,11,25},{7,11,855},{7,11,1258},{144,11,32},{134,0,1076},{133,0,921}
-,{133,0,674},{4,11,4},{7,11,1118},{7,11,1320},{7,11,1706},{8,11,277},{9,11,622},
-{10,11,9},{11,11,724},{12,11,350},{12,11,397},{13,11,28},{13,11,159},{15,11,89},
-{18,11,5},{19,11,9},{20,11,34},{150,11,47},{134,10,208},{6,0,444},{136,0,308},{6
-,0,180},{7,0,1137},{8,0,751},{139,0,805},{4,0,183},{7,0,271},{11,0,824},{11,0,
-952},{13,0,278},{13,0,339},{13,0,482},{14,0,424},{148,0,99},{7,11,317},{135,11,
-569},{4,0,19},{5,0,477},{5,0,596},{6,0,505},{7,0,1221},{11,0,907},{12,0,209},{
-141,0,214},{135,0,1215},{6,0,271},{7,0,398},{8,0,387},{10,0,344},{7,10,448},{7,
-10,1629},{7,10,1813},{8,10,442},{9,10,710},{10,10,282},{138,10,722},{11,10,844},
-{12,10,104},{140,10,625},{134,11,255},{133,10,787},{134,0,1645},{11,11,956},{151
-,11,3},{6,0,92},{6,0,188},{7,0,209},{7,0,1269},{7,0,1524},{7,0,1876},{8,0,661},{
-10,0,42},{10,0,228},{11,0,58},{11,0,1020},{12,0,58},{12,0,118},{141,0,32},{4,0,
-459},{133,0,966},{4,11,536},{7,11,1141},{10,11,723},{139,11,371},{140,0,330},{
-134,0,1557},{7,11,285},{135,11,876},{136,10,491},{135,11,560},{6,0,18},{7,0,179}
-,{7,0,932},{8,0,548},{8,0,757},{9,0,54},{9,0,65},{9,0,532},{9,0,844},{10,0,113},
-{10,0,117},{10,0,315},{10,0,560},{10,0,622},{10,0,798},{11,0,153},{11,0,351},{11
-,0,375},{12,0,78},{12,0,151},{12,0,392},{12,0,666},{14,0,248},{143,0,23},{6,0,
-1742},{132,11,690},{4,10,403},{5,10,441},{7,10,450},{10,10,840},{11,10,101},{12,
-10,193},{141,10,430},{133,0,965},{134,0,182},{10,0,65},{10,0,488},{138,0,497},{
-135,11,1346},{6,0,973},{6,0,1158},{10,11,200},{19,11,2},{151,11,22},{4,11,190},{
-133,11,554},{133,10,679},{7,0,328},{137,10,326},{133,11,1001},{9,0,588},{138,0,
-260},{133,11,446},{135,10,1128},{135,10,1796},{147,11,119},{134,0,1786},{6,0,
-1328},{6,0,1985},{8,0,962},{138,0,1017},{135,0,308},{11,0,508},{4,10,574},{7,10,
-350},{7,10,1024},{8,10,338},{9,10,677},{138,10,808},{138,11,752},{135,10,1081},{
-137,11,96},{7,10,1676},{135,10,2037},{136,0,588},{132,11,304},{133,0,614},{140,0
-,793},{136,0,287},{137,10,297},{141,10,37},{6,11,53},{6,11,199},{7,11,1408},{8,
-11,32},{8,11,93},{9,11,437},{10,11,397},{10,11,629},{11,11,593},{11,11,763},{13,
-11,326},{145,11,35},{134,11,105},{9,11,320},{10,11,506},{138,11,794},{5,11,114},
-{5,11,255},{141,11,285},{140,0,290},{7,11,2035},{8,11,19},{9,11,89},{138,11,831}
-,{134,0,1136},{7,0,719},{8,0,796},{8,0,809},{8,0,834},{6,10,306},{7,10,1140},{7,
-10,1340},{8,10,133},{138,10,449},{139,10,1011},{5,0,210},{6,0,213},{7,0,60},{10,
-0,364},{139,0,135},{5,0,607},{8,0,326},{136,0,490},{138,11,176},{132,0,701},{5,0
-,472},{7,0,380},{137,0,758},{135,0,1947},{6,0,1079},{138,0,278},{138,11,391},{5,
-10,329},{8,10,260},{139,11,156},{4,0,386},{7,0,41},{8,0,405},{8,0,728},{9,0,497}
-,{11,0,110},{11,0,360},{15,0,37},{144,0,84},{5,0,46},{7,0,1452},{7,0,1480},{8,0,
-634},{140,0,472},{136,0,961},{4,0,524},{136,0,810},{10,0,238},{141,0,33},{132,10
-,657},{152,10,7},{133,0,532},{5,0,997},{135,10,1665},{7,11,594},{7,11,851},{7,11
-,1858},{9,11,411},{9,11,574},{9,11,666},{9,11,737},{10,11,346},{10,11,712},{11,
-11,246},{11,11,432},{11,11,517},{11,11,647},{11,11,679},{11,11,727},{12,11,304},
-{12,11,305},{12,11,323},{12,11,483},{12,11,572},{12,11,593},{12,11,602},{13,11,
-95},{13,11,101},{13,11,171},{13,11,315},{13,11,378},{13,11,425},{13,11,475},{14,
-11,63},{14,11,380},{14,11,384},{15,11,133},{18,11,112},{148,11,72},{5,11,955},{
-136,11,814},{134,0,1301},{5,10,66},{7,10,1896},{136,10,288},{133,11,56},{134,10,
-1643},{6,0,1298},{148,11,100},{5,0,782},{5,0,829},{6,0,671},{6,0,1156},{6,0,1738
-},{137,11,621},{4,0,306},{5,0,570},{7,0,1347},{5,10,91},{5,10,648},{5,10,750},{5
-,10,781},{6,10,54},{6,10,112},{6,10,402},{6,10,1732},{7,10,315},{7,10,749},{7,10
-,1900},{9,10,78},{9,10,508},{10,10,611},{10,10,811},{11,10,510},{11,10,728},{13,
-10,36},{14,10,39},{16,10,83},{17,10,124},{148,10,30},{8,10,570},{9,11,477},{141,
-11,78},{4,11,639},{10,11,4},{10,10,322},{10,10,719},{11,10,407},{11,11,638},{12,
-11,177},{148,11,57},{7,0,1823},{139,0,693},{7,0,759},{5,11,758},{8,10,125},{8,10
-,369},{8,10,524},{10,10,486},{11,10,13},{11,10,381},{11,10,736},{11,10,766},{11,
-10,845},{13,10,114},{13,10,292},{142,10,47},{7,0,1932},{6,10,1684},{6,10,1731},{
-7,10,356},{8,10,54},{8,10,221},{9,10,225},{9,10,356},{10,10,77},{10,10,446},{10,
-10,731},{12,10,404},{141,10,491},{135,11,552},{135,11,1112},{4,0,78},{5,0,96},{5
-,0,182},{6,0,1257},{7,0,1724},{7,0,1825},{10,0,394},{10,0,471},{11,0,532},{14,0,
-340},{145,0,88},{139,11,328},{135,0,1964},{132,10,411},{4,10,80},{5,10,44},{137,
-11,133},{5,11,110},{6,11,169},{6,11,1702},{7,11,400},{8,11,538},{9,11,184},{9,11
-,524},{140,11,218},{4,0,521},{5,10,299},{7,10,1083},{140,11,554},{6,11,133},{9,
-11,353},{12,11,628},{146,11,79},{6,0,215},{7,0,584},{7,0,1028},{7,0,1473},{7,0,
-1721},{9,0,424},{138,0,779},{7,0,857},{7,0,1209},{7,10,1713},{9,10,537},{10,10,
-165},{12,10,219},{140,10,561},{4,10,219},{6,11,93},{7,11,1422},{7,10,1761},{7,11
-,1851},{8,11,673},{9,10,86},{9,11,529},{140,11,43},{137,11,371},{136,0,671},{5,0
-,328},{135,0,918},{132,0,529},{9,11,25},{10,11,467},{138,11,559},{4,11,335},{135
-,11,942},{134,0,716},{134,0,1509},{6,0,67},{7,0,258},{7,0,1630},{9,0,354},{9,0,
-675},{10,0,830},{14,0,80},{17,0,80},{140,10,428},{134,0,1112},{6,0,141},{7,0,225
-},{9,0,59},{9,0,607},{10,0,312},{11,0,687},{12,0,555},{13,0,373},{13,0,494},{148
-,0,58},{133,10,514},{8,11,39},{10,11,773},{11,11,84},{12,11,205},{142,11,1},{8,0
-,783},{5,11,601},{133,11,870},{136,11,594},{4,10,55},{5,10,301},{6,10,571},{14,
-10,49},{146,10,102},{132,11,181},{134,11,1652},{133,10,364},{4,11,97},{5,11,147}
-,{6,11,286},{7,11,1362},{141,11,176},{4,10,76},{7,10,1550},{9,10,306},{9,10,430}
-,{9,10,663},{10,10,683},{11,10,427},{11,10,753},{12,10,334},{12,10,442},{14,10,
-258},{14,10,366},{143,10,131},{137,10,52},{6,0,955},{134,0,1498},{6,11,375},{7,
-11,169},{7,11,254},{136,11,780},{7,0,430},{11,0,46},{14,0,343},{142,11,343},{135
-,0,1183},{5,0,602},{7,0,2018},{9,0,418},{9,0,803},{135,11,1447},{8,0,677},{135,
-11,1044},{139,11,285},{4,10,656},{135,10,779},{135,10,144},{5,11,629},{135,11,
-1549},{135,10,1373},{138,11,209},{7,10,554},{7,10,605},{141,10,10},{5,10,838},{5
-,10,841},{134,10,1649},{133,10,1012},{6,0,1357},{134,0,1380},{144,0,53},{6,0,590
-},{7,10,365},{7,10,1357},{7,10,1497},{8,10,154},{141,10,281},{133,10,340},{132,
-11,420},{135,0,329},{147,11,32},{4,0,469},{10,11,429},{139,10,495},{8,10,261},{9
-,10,144},{9,10,466},{10,10,370},{12,10,470},{13,10,144},{142,10,348},{142,0,460}
-,{4,11,325},{9,10,897},{138,11,125},{6,0,1743},{6,10,248},{9,10,546},{10,10,535}
-,{11,10,681},{141,10,135},{4,0,990},{5,0,929},{6,0,340},{8,0,376},{8,0,807},{8,0
-,963},{8,0,980},{138,0,1007},{134,0,1603},{140,0,250},{4,11,714},{133,11,469},{
-134,10,567},{136,10,445},{5,0,218},{7,0,1610},{8,0,646},{10,0,83},{11,11,138},{
-140,11,40},{7,0,1512},{135,0,1794},{135,11,1216},{11,0,0},{16,0,78},{132,11,718}
-,{133,0,571},{132,0,455},{134,0,1012},{5,11,124},{5,11,144},{6,11,548},{7,11,15}
-,{7,11,153},{137,11,629},{142,11,10},{6,11,75},{7,11,1531},{8,11,416},{9,11,240}
-,{9,11,275},{10,11,100},{11,11,658},{11,11,979},{12,11,86},{13,11,468},{14,11,66
-},{14,11,207},{15,11,20},{15,11,25},{144,11,58},{132,10,577},{5,11,141},{5,11,
-915},{6,11,1783},{7,11,211},{7,11,698},{7,11,1353},{9,11,83},{9,11,281},{10,11,
-376},{10,11,431},{11,11,543},{12,11,664},{13,11,280},{13,11,428},{14,11,61},{14,
-11,128},{17,11,52},{145,11,81},{6,0,161},{7,0,372},{137,0,597},{132,0,349},{10,
-11,702},{139,11,245},{134,0,524},{134,10,174},{6,0,432},{9,0,751},{139,0,322},{
-147,11,94},{4,11,338},{133,11,400},{5,0,468},{10,0,325},{11,0,856},{12,0,345},{
-143,0,104},{133,0,223},{132,0,566},{4,11,221},{5,11,659},{5,11,989},{7,11,697},{
-7,11,1211},{138,11,284},{135,11,1070},{4,0,59},{135,0,1394},{6,0,436},{11,0,481}
-,{5,10,878},{133,10,972},{4,0,48},{5,0,271},{135,0,953},{5,0,610},{136,0,457},{4
-,0,773},{5,0,618},{137,0,756},{133,0,755},{135,0,1217},{138,11,507},{132,10,351}
-,{132,0,197},{143,11,78},{4,11,188},{7,11,805},{11,11,276},{142,11,293},{5,11,
-884},{139,11,991},{132,10,286},{10,0,259},{10,0,428},{7,10,438},{7,10,627},{7,10
-,1516},{8,10,40},{9,10,56},{9,10,294},{11,10,969},{11,10,995},{146,10,148},{4,0,
-356},{5,0,217},{5,0,492},{5,0,656},{8,0,544},{136,11,544},{5,0,259},{6,0,1230},{
-7,0,414},{7,0,854},{142,0,107},{132,0,1007},{15,0,14},{144,0,5},{6,0,1580},{132,
-10,738},{132,11,596},{132,0,673},{133,10,866},{6,0,1843},{135,11,1847},{4,0,165}
-,{7,0,1398},{135,0,1829},{135,11,1634},{147,11,65},{6,0,885},{6,0,1009},{137,0,
-809},{133,10,116},{132,10,457},{136,11,770},{9,0,498},{12,0,181},{10,11,361},{
-142,11,316},{134,11,595},{5,0,9},{7,0,297},{7,0,966},{140,0,306},{4,11,89},{5,11
-,489},{6,11,315},{7,11,553},{7,11,1745},{138,11,243},{134,0,1487},{132,0,437},{5
-,0,146},{6,0,411},{138,0,721},{5,10,527},{6,10,189},{135,10,859},{11,10,104},{11
-,10,554},{15,10,60},{143,10,125},{6,11,1658},{9,11,3},{10,11,154},{11,11,641},{
-13,11,85},{13,11,201},{141,11,346},{6,0,177},{135,0,467},{134,0,1377},{134,10,
-116},{136,11,645},{4,11,166},{5,11,505},{6,11,1670},{137,11,110},{133,10,487},{4
-,10,86},{5,10,667},{5,10,753},{6,10,316},{6,10,455},{135,10,946},{133,0,200},{
-132,0,959},{6,0,1928},{134,0,1957},{139,11,203},{150,10,45},{4,10,79},{7,10,1773
-},{10,10,450},{11,10,589},{13,10,332},{13,10,493},{14,10,183},{14,10,334},{14,10
-,362},{14,10,368},{14,10,376},{14,10,379},{19,10,90},{19,10,103},{19,10,127},{
-148,10,90},{6,0,1435},{135,11,1275},{134,0,481},{7,11,445},{8,11,307},{8,11,704}
-,{10,11,41},{10,11,439},{11,11,237},{11,11,622},{140,11,201},{135,11,869},{4,0,
-84},{7,0,1482},{10,0,76},{138,0,142},{11,11,277},{144,11,14},{135,11,1977},{4,11
-,189},{5,11,713},{136,11,57},{133,0,1015},{138,11,371},{4,0,315},{5,0,507},{135,
-0,1370},{4,11,552},{142,10,381},{9,0,759},{16,0,31},{16,0,39},{16,0,75},{18,0,24
-},{20,0,42},{152,0,1},{134,0,712},{134,0,1722},{133,10,663},{133,10,846},{8,0,
-222},{8,0,476},{9,0,238},{11,0,516},{11,0,575},{15,0,109},{146,0,100},{7,0,1402}
-,{7,0,1414},{12,0,456},{5,10,378},{8,10,465},{9,10,286},{10,10,185},{10,10,562},
-{10,10,635},{11,10,31},{11,10,393},{13,10,312},{18,10,65},{18,10,96},{147,10,89}
-,{4,0,986},{6,0,1958},{6,0,2032},{8,0,934},{138,0,985},{7,10,1880},{9,10,680},{
-139,10,798},{134,10,1770},{145,11,49},{132,11,614},{132,10,648},{5,10,945},{6,10
-,1656},{6,10,1787},{7,10,167},{8,10,824},{9,10,391},{10,10,375},{139,10,185},{
-138,11,661},{7,0,1273},{135,11,1945},{7,0,706},{7,0,1058},{138,0,538},{7,10,1645
-},{8,10,352},{137,10,249},{132,10,152},{11,0,92},{11,0,196},{11,0,409},{11,0,450
-},{11,0,666},{11,0,777},{12,0,262},{13,0,385},{13,0,393},{15,0,115},{16,0,45},{
-145,0,82},{133,10,1006},{6,0,40},{135,0,1781},{9,11,614},{139,11,327},{5,10,420}
-,{135,10,1449},{135,0,431},{10,0,97},{135,10,832},{6,0,423},{7,0,665},{135,0,
-1210},{7,0,237},{8,0,664},{9,0,42},{9,0,266},{9,0,380},{9,0,645},{10,0,177},{138
-,0,276},{7,0,264},{133,10,351},{8,0,213},{5,10,40},{7,10,598},{7,10,1638},{9,10,
-166},{9,10,640},{9,10,685},{9,10,773},{11,10,215},{13,10,65},{14,10,172},{14,10,
-317},{145,10,6},{5,11,84},{134,11,163},{8,10,60},{9,10,343},{139,10,769},{137,0,
-455},{133,11,410},{8,0,906},{12,0,700},{12,0,706},{140,0,729},{21,11,33},{150,11
-,40},{7,10,1951},{8,10,765},{8,10,772},{140,10,671},{7,10,108},{8,10,219},{8,10,
-388},{9,10,639},{9,10,775},{11,10,275},{140,10,464},{5,11,322},{7,11,1941},{8,11
-,186},{9,11,262},{10,11,187},{14,11,208},{146,11,130},{139,0,624},{8,0,574},{5,
-11,227},{140,11,29},{7,11,1546},{11,11,299},{142,11,407},{5,10,15},{6,10,56},{7,
-10,1758},{8,10,500},{9,10,730},{11,10,331},{13,10,150},{142,10,282},{7,11,1395},
-{8,11,486},{9,11,236},{9,11,878},{10,11,218},{11,11,95},{19,11,17},{147,11,31},{
-135,11,2043},{4,0,354},{146,11,4},{140,11,80},{135,0,1558},{134,10,1886},{5,10,
-205},{6,10,438},{137,10,711},{133,11,522},{133,10,534},{7,0,235},{7,0,1475},{15,
-0,68},{146,0,120},{137,10,691},{4,0,942},{6,0,1813},{8,0,917},{10,0,884},{12,0,
-696},{12,0,717},{12,0,723},{12,0,738},{12,0,749},{12,0,780},{16,0,97},{146,0,169
-},{6,10,443},{8,11,562},{9,10,237},{9,10,571},{9,10,695},{10,10,139},{11,10,715}
-,{12,10,417},{141,10,421},{135,0,957},{133,0,830},{134,11,1771},{146,0,23},{5,0,
-496},{6,0,694},{7,0,203},{7,11,1190},{137,11,620},{137,11,132},{6,0,547},{134,0,
-1549},{8,11,258},{9,11,208},{137,11,359},{4,0,864},{5,0,88},{137,0,239},{135,11,
-493},{4,11,317},{135,11,1279},{132,11,477},{4,10,578},{5,11,63},{133,11,509},{7,
-0,650},{135,0,1310},{7,0,1076},{9,0,80},{11,0,78},{11,0,421},{11,0,534},{140,0,
-545},{132,11,288},{12,0,553},{14,0,118},{133,10,923},{7,0,274},{11,0,479},{139,0
-,507},{8,11,89},{8,11,620},{9,11,49},{10,11,774},{11,11,628},{12,11,322},{143,11
-,124},{4,0,497},{135,0,1584},{7,0,261},{7,0,1115},{7,0,1354},{7,0,1404},{7,0,
-1588},{7,0,1705},{7,0,1902},{9,0,465},{10,0,248},{10,0,349},{10,0,647},{11,0,527
-},{11,0,660},{11,0,669},{12,0,529},{13,0,305},{132,10,924},{133,10,665},{136,0,
-13},{6,0,791},{138,11,120},{7,0,642},{8,0,250},{11,0,123},{11,0,137},{13,0,48},{
-142,0,95},{4,10,265},{7,10,807},{135,10,950},{5,10,93},{140,10,267},{135,0,1429}
-,{4,0,949},{10,0,885},{10,0,891},{10,0,900},{10,0,939},{12,0,760},{142,0,449},{
-139,11,366},{132,0,818},{134,11,85},{135,10,994},{7,0,330},{5,10,233},{5,10,320}
-,{6,10,140},{136,10,295},{4,0,1004},{8,0,982},{136,0,993},{133,10,978},{4,10,905
-},{6,10,1701},{137,10,843},{10,0,545},{140,0,301},{6,0,947},{134,0,1062},{134,0,
-1188},{4,0,904},{5,0,794},{152,10,6},{134,0,1372},{135,11,608},{5,11,279},{6,11,
-235},{7,11,468},{8,11,446},{9,11,637},{10,11,717},{11,11,738},{140,11,514},{132,
-10,509},{5,11,17},{6,11,371},{137,11,528},{132,0,693},{4,11,115},{5,11,669},{6,
-11,407},{8,11,311},{11,11,10},{141,11,5},{11,0,377},{7,10,273},{137,11,381},{135
-,0,695},{7,0,386},{138,0,713},{135,10,1041},{134,0,1291},{6,0,7},{6,0,35},{7,0,
-147},{7,0,1069},{7,0,1568},{7,0,1575},{7,0,1917},{8,0,43},{8,0,208},{9,0,128},{9
-,0,866},{10,0,20},{11,0,981},{147,0,33},{7,0,893},{141,0,424},{139,10,234},{150,
-11,56},{5,11,779},{5,11,807},{6,11,1655},{134,11,1676},{5,10,802},{7,10,2021},{
-136,10,805},{4,11,196},{5,10,167},{5,11,558},{5,10,899},{5,11,949},{6,10,410},{
-137,10,777},{137,10,789},{134,10,1705},{8,0,904},{140,0,787},{6,0,322},{9,0,552}
-,{11,0,274},{13,0,209},{13,0,499},{14,0,85},{15,0,126},{145,0,70},{135,10,10},{5
-,10,11},{6,10,117},{6,10,485},{7,10,1133},{9,10,582},{9,10,594},{11,10,21},{11,
-10,818},{12,10,535},{141,10,86},{4,10,264},{7,10,1067},{8,10,204},{8,10,385},{
-139,10,953},{132,11,752},{138,10,56},{133,10,470},{6,0,1808},{8,0,83},{8,0,742},
-{8,0,817},{9,0,28},{9,0,29},{9,0,885},{10,0,387},{11,0,633},{11,0,740},{13,0,235
-},{13,0,254},{15,0,143},{143,0,146},{140,0,49},{134,0,1832},{4,11,227},{5,11,159
-},{5,11,409},{7,11,80},{10,11,294},{10,11,479},{12,11,418},{14,11,50},{14,11,249
-},{142,11,295},{7,11,1470},{8,11,66},{8,11,137},{8,11,761},{9,11,638},{11,11,80}
-,{11,11,212},{11,11,368},{11,11,418},{12,11,8},{13,11,15},{16,11,61},{17,11,59},
-{19,11,28},{148,11,84},{139,10,1015},{138,11,468},{135,0,421},{6,0,415},{7,0,
-1049},{137,0,442},{6,11,38},{7,11,1220},{8,11,185},{8,11,256},{9,11,22},{9,11,
-331},{10,11,738},{11,11,205},{11,11,540},{11,11,746},{13,11,399},{13,11,465},{14
-,11,88},{142,11,194},{139,0,289},{133,10,715},{4,0,110},{10,0,415},{10,0,597},{
-142,0,206},{4,11,159},{6,11,115},{7,11,252},{7,11,257},{7,11,1928},{8,11,69},{9,
-11,384},{10,11,91},{10,11,615},{12,11,375},{14,11,235},{18,11,117},{147,11,123},
-{5,11,911},{136,11,278},{7,0,205},{7,0,2000},{8,10,794},{9,10,400},{10,10,298},{
-142,10,228},{135,11,1774},{4,11,151},{7,11,1567},{8,11,351},{137,11,322},{136,10
-,724},{133,11,990},{7,0,1539},{11,0,512},{13,0,205},{19,0,30},{22,0,36},{23,0,19
-},{135,11,1539},{5,11,194},{7,11,1662},{9,11,90},{140,11,180},{6,10,190},{7,10,
-768},{135,10,1170},{134,0,1340},{4,0,283},{135,0,1194},{133,11,425},{133,11,971}
-,{12,0,549},{14,10,67},{147,10,60},{135,10,1023},{134,0,1720},{138,11,587},{5,11
-,72},{6,11,264},{7,11,21},{7,11,46},{7,11,2013},{8,11,215},{8,11,513},{10,11,266
-},{139,11,22},{5,0,319},{135,0,534},{6,10,137},{9,10,75},{9,10,253},{10,10,194},
-{138,10,444},{7,0,1180},{20,0,112},{6,11,239},{7,11,118},{10,11,95},{11,11,603},
-{13,11,443},{14,11,160},{143,11,4},{134,11,431},{5,11,874},{6,11,1677},{11,10,
-643},{12,10,115},{143,11,0},{134,0,967},{6,11,65},{7,11,939},{7,11,1172},{7,11,
-1671},{9,11,540},{10,11,696},{11,11,265},{11,11,732},{11,11,928},{11,11,937},{12
-,11,399},{13,11,438},{149,11,19},{137,11,200},{135,0,1940},{5,10,760},{7,10,542}
-,{8,10,135},{136,10,496},{140,11,44},{7,11,1655},{136,11,305},{7,10,319},{7,10,
-355},{7,10,763},{10,10,389},{145,10,43},{136,0,735},{138,10,786},{137,11,19},{
-132,11,696},{5,0,132},{9,0,486},{9,0,715},{10,0,458},{11,0,373},{11,0,668},{11,0
-,795},{11,0,897},{12,0,272},{12,0,424},{12,0,539},{12,0,558},{14,0,245},{14,0,
-263},{14,0,264},{14,0,393},{142,0,403},{10,0,38},{139,0,784},{132,0,838},{4,11,
-302},{135,11,1766},{133,0,379},{5,0,8},{6,0,89},{6,0,400},{7,0,1569},{7,0,1623},
-{7,0,1850},{8,0,218},{8,0,422},{9,0,570},{10,0,626},{4,11,726},{133,11,630},{4,0
-,1017},{138,0,660},{6,0,387},{7,0,882},{141,0,111},{6,0,224},{7,0,877},{137,0,
-647},{4,10,58},{5,10,286},{6,10,319},{7,10,402},{7,10,1254},{7,10,1903},{8,10,
-356},{140,10,408},{135,0,790},{9,0,510},{10,0,53},{4,10,389},{9,10,181},{10,10,
-29},{10,10,816},{11,10,311},{11,10,561},{12,10,67},{141,10,181},{142,0,458},{6,
-11,118},{7,11,215},{7,11,1521},{140,11,11},{134,0,954},{135,0,394},{134,0,1367},
-{5,11,225},{133,10,373},{132,0,882},{7,0,1409},{135,10,1972},{135,10,1793},{4,11
-,370},{5,11,756},{135,11,1326},{150,11,13},{7,11,354},{10,11,410},{139,11,815},{
-6,11,1662},{7,11,48},{8,11,771},{10,11,116},{13,11,104},{14,11,105},{14,11,184},
-{15,11,168},{19,11,92},{148,11,68},{7,0,124},{136,0,38},{5,0,261},{7,0,78},{7,0,
-199},{8,0,815},{9,0,126},{10,0,342},{140,0,647},{4,0,628},{140,0,724},{7,0,266},
-{8,0,804},{7,10,1651},{145,10,89},{135,0,208},{134,0,1178},{6,0,79},{135,0,1519}
-,{132,10,672},{133,10,737},{136,0,741},{132,11,120},{4,0,710},{6,0,376},{134,0,
-606},{134,0,1347},{134,0,1494},{6,0,850},{6,0,1553},{137,0,821},{5,10,145},{134,
-11,593},{7,0,1311},{140,0,135},{4,0,467},{5,0,405},{134,0,544},{5,11,820},{135,
-11,931},{6,0,100},{7,0,244},{7,0,632},{7,0,1609},{8,0,178},{8,0,638},{141,0,58},
-{4,10,387},{135,10,1288},{6,11,151},{6,11,1675},{7,11,383},{151,11,10},{132,0,
-481},{135,10,550},{134,0,1378},{6,11,1624},{11,11,11},{12,11,422},{13,11,262},{
-142,11,360},{133,0,791},{4,11,43},{5,11,344},{133,11,357},{7,0,1227},{140,0,978}
-,{7,0,686},{8,0,33},{8,0,238},{10,0,616},{11,0,467},{11,0,881},{13,0,217},{13,0,
-253},{142,0,268},{137,0,857},{8,0,467},{8,0,1006},{7,11,148},{8,11,284},{141,11,
-63},{4,10,576},{135,10,1263},{133,11,888},{5,10,919},{134,10,1673},{20,10,37},{
-148,11,37},{132,0,447},{132,11,711},{4,0,128},{5,0,415},{6,0,462},{7,0,294},{7,0
-,578},{10,0,710},{139,0,86},{4,10,82},{5,10,333},{5,10,904},{6,10,207},{7,10,325
-},{7,10,1726},{8,10,101},{10,10,778},{139,10,220},{136,0,587},{137,11,440},{133,
-10,903},{6,0,427},{7,0,1018},{138,0,692},{4,0,195},{135,0,802},{140,10,147},{134
-,0,1546},{134,0,684},{132,10,705},{136,0,345},{11,11,678},{140,11,307},{133,0,
-365},{134,0,1683},{4,11,65},{5,11,479},{5,11,1004},{7,11,1913},{8,11,317},{9,11,
-302},{10,11,612},{141,11,22},{138,0,472},{4,11,261},{135,11,510},{134,10,90},{
-142,0,433},{151,0,28},{4,11,291},{7,11,101},{9,11,515},{12,11,152},{12,11,443},{
-13,11,392},{142,11,357},{140,0,997},{5,0,3},{8,0,578},{9,0,118},{10,0,705},{141,
-0,279},{135,11,1266},{7,10,813},{12,10,497},{141,10,56},{133,0,229},{6,10,125},{
-135,10,1277},{8,0,102},{10,0,578},{10,0,672},{12,0,496},{13,0,408},{14,0,121},{
-17,0,106},{151,10,12},{6,0,866},{134,0,1080},{136,0,1022},{4,11,130},{135,11,843
-},{5,11,42},{5,11,879},{7,11,245},{7,11,324},{7,11,1532},{11,11,463},{11,11,472}
-,{13,11,363},{144,11,52},{150,0,55},{8,0,115},{8,0,350},{9,0,489},{10,0,128},{11
-,0,306},{12,0,373},{14,0,30},{17,0,79},{19,0,80},{4,11,134},{133,11,372},{134,0,
-657},{134,0,933},{135,11,1147},{4,0,230},{133,0,702},{134,0,1728},{4,0,484},{18,
-0,26},{19,0,42},{20,0,43},{21,0,0},{23,0,27},{152,0,14},{7,0,185},{135,0,703},{6
-,0,417},{10,0,618},{7,10,1106},{9,10,770},{11,10,112},{140,10,413},{134,0,803},{
-132,11,644},{134,0,1262},{7,11,540},{12,10,271},{145,10,109},{135,11,123},{132,0
-,633},{134,11,623},{4,11,908},{5,11,359},{5,11,508},{6,11,1723},{7,11,343},{7,11
-,1996},{135,11,2026},{135,0,479},{10,0,262},{7,10,304},{9,10,646},{9,10,862},{11
-,10,696},{12,10,208},{15,10,79},{147,10,108},{4,11,341},{135,11,480},{134,0,830}
-,{5,0,70},{5,0,622},{6,0,334},{7,0,1032},{9,0,171},{11,0,26},{11,0,213},{11,0,
-637},{11,0,707},{12,0,202},{12,0,380},{13,0,226},{13,0,355},{14,0,222},{145,0,42
-},{135,10,981},{143,0,217},{137,11,114},{4,0,23},{4,0,141},{5,0,313},{5,0,1014},
-{6,0,50},{6,0,51},{7,0,142},{7,0,384},{7,0,559},{8,0,640},{9,0,460},{9,0,783},{
-11,0,741},{12,0,183},{141,0,488},{141,0,360},{7,0,1586},{7,11,1995},{8,11,299},{
-11,11,890},{140,11,674},{132,10,434},{7,0,652},{134,10,550},{7,0,766},{5,10,553}
-,{138,10,824},{7,0,737},{8,0,298},{136,10,452},{4,11,238},{5,11,503},{6,11,179},
-{7,11,2003},{8,11,381},{8,11,473},{9,11,149},{10,11,183},{15,11,45},{143,11,86},
-{133,10,292},{5,0,222},{9,0,655},{138,0,534},{138,10,135},{4,11,121},{5,11,156},
-{5,11,349},{9,11,136},{10,11,605},{14,11,342},{147,11,107},{137,0,906},{6,0,1013
-},{134,0,1250},{6,0,1956},{6,0,2009},{8,0,991},{144,0,120},{135,11,1192},{138,0,
-503},{5,0,154},{7,0,1491},{10,0,379},{138,0,485},{6,0,1867},{6,0,1914},{6,0,1925
-},{9,0,917},{9,0,925},{9,0,932},{9,0,951},{9,0,1007},{9,0,1013},{12,0,806},{12,0
-,810},{12,0,814},{12,0,816},{12,0,824},{12,0,832},{12,0,837},{12,0,863},{12,0,
-868},{12,0,870},{12,0,889},{12,0,892},{12,0,900},{12,0,902},{12,0,908},{12,0,933
-},{12,0,942},{12,0,949},{12,0,954},{15,0,175},{15,0,203},{15,0,213},{15,0,218},{
-15,0,225},{15,0,231},{15,0,239},{15,0,248},{15,0,252},{18,0,190},{18,0,204},{18,
-0,215},{18,0,216},{18,0,222},{18,0,225},{18,0,230},{18,0,239},{18,0,241},{21,0,
-42},{21,0,43},{21,0,44},{21,0,45},{21,0,46},{21,0,53},{24,0,27},{152,0,31},{133,
-0,716},{135,0,844},{4,0,91},{5,0,388},{5,0,845},{6,0,206},{6,0,252},{6,0,365},{7
-,0,136},{7,0,531},{136,0,621},{7,10,393},{10,10,603},{139,10,206},{6,11,80},{6,
-11,1694},{7,11,173},{7,11,1974},{9,11,547},{10,11,730},{14,11,18},{150,11,39},{
-137,0,748},{4,11,923},{134,11,1711},{4,10,912},{137,10,232},{7,10,98},{7,10,1973
-},{136,10,716},{14,0,103},{133,10,733},{132,11,595},{12,0,158},{18,0,8},{19,0,62
-},{20,0,6},{22,0,4},{23,0,2},{23,0,9},{5,11,240},{6,11,459},{7,11,12},{7,11,114}
-,{7,11,502},{7,11,1751},{7,11,1753},{7,11,1805},{8,11,658},{9,11,1},{11,11,959},
-{13,11,446},{142,11,211},{135,0,576},{5,0,771},{5,0,863},{5,0,898},{6,0,648},{6,
-0,1632},{6,0,1644},{134,0,1780},{133,0,331},{7,11,633},{7,11,905},{7,11,909},{7,
-11,1538},{9,11,767},{140,11,636},{140,0,632},{5,0,107},{7,0,201},{136,0,518},{6,
-0,446},{7,0,1817},{134,11,490},{9,0,851},{141,0,510},{7,11,250},{8,11,506},{136,
-11,507},{4,0,504},{137,10,72},{132,11,158},{4,11,140},{7,11,362},{8,11,209},{9,
-11,10},{9,11,160},{9,11,503},{10,11,689},{11,11,350},{11,11,553},{11,11,725},{12
-,11,252},{12,11,583},{13,11,192},{13,11,352},{14,11,269},{14,11,356},{148,11,50}
-,{6,11,597},{135,11,1318},{135,10,1454},{5,0,883},{5,0,975},{8,0,392},{148,0,7},
-{6,11,228},{7,11,1341},{9,11,408},{138,11,343},{11,11,348},{11,10,600},{12,11,99
-},{13,10,245},{18,11,1},{18,11,11},{147,11,4},{134,11,296},{5,0,922},{134,0,1707
-},{132,11,557},{4,11,548},{7,10,164},{7,10,1571},{9,10,107},{140,10,225},{7,11,
-197},{8,11,142},{8,11,325},{9,11,150},{9,11,596},{10,11,350},{10,11,353},{11,11,
-74},{11,11,315},{14,11,423},{143,11,141},{5,0,993},{7,0,515},{137,0,91},{4,0,131
-},{8,0,200},{5,10,484},{5,10,510},{6,10,434},{7,10,1000},{7,10,1098},{136,10,2},
-{152,0,10},{4,11,62},{5,11,83},{6,11,399},{6,11,579},{7,11,692},{7,11,846},{7,11
-,1015},{7,11,1799},{8,11,403},{9,11,394},{10,11,133},{12,11,4},{12,11,297},{12,
-11,452},{16,11,81},{18,11,19},{18,11,25},{21,11,14},{22,11,12},{151,11,18},{140,
-11,459},{132,11,177},{7,0,1433},{9,0,365},{137,11,365},{132,10,460},{5,0,103},{6
-,0,2004},{7,0,921},{8,0,580},{8,0,593},{8,0,630},{10,0,28},{5,11,411},{135,11,
-653},{4,10,932},{133,10,891},{4,0,911},{5,0,867},{5,0,1013},{7,0,2034},{8,0,798}
-,{136,0,813},{7,11,439},{10,11,727},{11,11,260},{139,11,684},{136,10,625},{5,11,
-208},{7,11,753},{135,11,1528},{5,0,461},{7,0,1925},{12,0,39},{13,0,265},{13,0,
-439},{134,10,76},{6,0,853},{8,10,92},{137,10,221},{5,0,135},{6,0,519},{7,0,1722}
-,{10,0,271},{11,0,261},{145,0,54},{139,11,814},{14,0,338},{148,0,81},{4,0,300},{
-133,0,436},{5,0,419},{5,0,687},{7,0,864},{9,0,470},{135,11,864},{9,0,836},{133,
-11,242},{134,0,1937},{4,10,763},{133,11,953},{132,10,622},{132,0,393},{133,10,
-253},{8,0,357},{10,0,745},{14,0,426},{17,0,94},{19,0,57},{135,10,546},{5,11,615}
-,{146,11,37},{9,10,73},{10,10,110},{14,10,185},{145,10,119},{11,0,703},{7,10,624
-},{7,10,916},{10,10,256},{139,10,87},{133,11,290},{5,10,212},{12,10,35},{141,10,
-382},{132,11,380},{5,11,52},{7,11,277},{9,11,368},{139,11,791},{133,0,387},{10,
-11,138},{139,11,476},{4,0,6},{5,0,708},{136,0,75},{7,0,1351},{9,0,581},{10,0,639
-},{11,0,453},{140,0,584},{132,0,303},{138,0,772},{135,10,1175},{4,0,749},{5,10,
-816},{6,11,256},{7,11,307},{7,11,999},{7,11,1481},{7,11,1732},{7,11,1738},{8,11,
-265},{9,11,414},{11,11,316},{12,11,52},{13,11,420},{147,11,100},{135,11,1296},{6
-,0,1065},{5,10,869},{5,10,968},{6,10,1626},{8,10,734},{136,10,784},{4,10,542},{6
-,10,1716},{6,10,1727},{7,10,1082},{7,10,1545},{8,10,56},{8,10,118},{8,10,412},{8
-,10,564},{9,10,888},{9,10,908},{10,10,50},{10,10,423},{11,10,685},{11,10,697},{
-11,10,933},{12,10,299},{13,10,126},{13,10,136},{13,10,170},{141,10,190},{134,0,
-226},{4,0,106},{7,0,310},{11,0,717},{133,11,723},{5,0,890},{5,0,988},{4,10,232},
-{9,10,202},{10,10,474},{140,10,433},{6,0,626},{142,0,431},{10,0,706},{150,0,44},
-{13,0,51},{6,10,108},{7,10,1003},{7,10,1181},{8,10,111},{136,10,343},{132,0,698}
-,{5,11,109},{6,11,1784},{7,11,1895},{12,11,296},{140,11,302},{134,0,828},{134,10
-,1712},{138,0,17},{7,0,1929},{4,10,133},{5,11,216},{7,10,711},{7,10,1298},{7,10,
-1585},{7,11,1879},{9,11,141},{9,11,270},{9,11,679},{10,11,159},{10,11,553},{11,
-11,197},{11,11,438},{12,11,538},{12,11,559},{13,11,193},{13,11,423},{14,11,144},
-{14,11,166},{14,11,167},{15,11,67},{147,11,84},{141,11,127},{7,11,1872},{137,11,
-81},{6,10,99},{7,10,1808},{145,10,57},{134,11,391},{5,0,689},{6,0,84},{7,0,1250}
-,{6,10,574},{7,10,428},{10,10,669},{11,10,485},{11,10,840},{12,10,300},{142,10,
-250},{7,11,322},{136,11,249},{7,11,432},{135,11,1649},{135,10,1871},{137,10,252}
-,{6,11,155},{140,11,234},{7,0,871},{19,0,27},{147,11,27},{140,0,498},{5,0,986},{
-6,0,130},{138,0,823},{6,0,1793},{7,0,1582},{8,0,458},{10,0,101},{10,0,318},{10,0
-,945},{12,0,734},{16,0,104},{18,0,177},{6,10,323},{135,10,1564},{5,11,632},{138,
-11,526},{10,0,435},{7,10,461},{136,10,775},{6,11,144},{7,11,948},{7,11,1042},{7,
-11,1857},{8,11,235},{8,11,461},{9,11,453},{9,11,530},{10,11,354},{17,11,77},{19,
-11,99},{148,11,79},{138,0,966},{7,0,1644},{137,0,129},{135,0,997},{136,0,502},{5
-,11,196},{6,11,486},{7,11,212},{8,11,309},{136,11,346},{7,10,727},{146,10,73},{
-132,0,823},{132,11,686},{135,0,1927},{4,0,762},{7,0,1756},{137,0,98},{136,10,577
-},{24,0,8},{4,11,30},{5,11,43},{152,11,8},{7,0,1046},{139,0,160},{7,0,492},{4,10
-,413},{5,10,677},{7,11,492},{8,10,432},{140,10,280},{6,0,45},{7,0,433},{8,0,129}
-,{9,0,21},{10,0,392},{11,0,79},{12,0,499},{13,0,199},{141,0,451},{7,0,558},{136,
-0,353},{4,11,220},{7,11,1535},{9,11,93},{139,11,474},{7,10,646},{7,10,1730},{11,
-10,446},{141,10,178},{133,0,785},{134,0,1145},{8,0,81},{9,0,189},{9,0,201},{11,0
-,478},{11,0,712},{141,0,338},{5,0,353},{151,0,26},{11,0,762},{132,10,395},{134,0
-,2024},{4,0,611},{133,0,606},{9,10,174},{10,10,164},{11,10,440},{11,10,841},{143
-,10,98},{134,10,426},{10,10,608},{139,10,1002},{138,10,250},{6,0,25},{7,0,855},{
-7,0,1258},{144,0,32},{7,11,1725},{138,11,393},{5,11,263},{134,11,414},{6,0,2011}
-,{133,10,476},{4,0,4},{7,0,1118},{7,0,1320},{7,0,1706},{8,0,277},{9,0,622},{10,0
-,9},{11,0,724},{12,0,350},{12,0,397},{13,0,28},{13,0,159},{15,0,89},{18,0,5},{19
-,0,9},{20,0,34},{22,0,47},{6,11,178},{6,11,1750},{8,11,251},{9,11,690},{10,11,
-155},{10,11,196},{10,11,373},{11,11,698},{13,11,155},{148,11,93},{5,11,97},{137,
-11,393},{7,0,764},{11,0,461},{12,0,172},{5,10,76},{6,10,458},{6,10,497},{7,10,
-868},{9,10,658},{10,10,594},{11,10,566},{12,10,338},{141,10,200},{134,0,1449},{
-138,11,40},{134,11,1639},{134,0,1445},{6,0,1168},{4,10,526},{7,10,1029},{135,10,
-1054},{4,11,191},{7,11,934},{8,11,647},{145,11,97},{132,10,636},{6,0,233},{7,10,
-660},{7,10,1124},{17,10,31},{19,10,22},{151,10,14},{6,10,1699},{136,11,110},{12,
-11,246},{15,11,162},{19,11,64},{20,11,8},{20,11,95},{22,11,24},{152,11,17},{5,11
-,165},{9,11,346},{138,11,655},{5,11,319},{135,11,534},{134,0,255},{9,0,216},{8,
-11,128},{139,11,179},{9,0,183},{139,0,286},{11,0,956},{151,0,3},{4,0,536},{7,0,
-1141},{10,0,723},{139,0,371},{4,10,279},{7,10,301},{137,10,362},{7,0,285},{5,11,
-57},{6,11,101},{6,11,1663},{7,11,132},{7,11,1048},{7,11,1154},{7,11,1415},{7,11,
-1507},{12,11,493},{15,11,105},{151,11,15},{5,11,459},{7,11,1073},{7,10,1743},{8,
-11,241},{136,11,334},{4,10,178},{133,10,399},{135,0,560},{132,0,690},{135,0,1246
-},{18,0,157},{147,0,63},{10,0,599},{11,0,33},{12,0,571},{149,0,1},{6,11,324},{6,
-11,520},{7,11,338},{7,11,1616},{7,11,1729},{8,11,228},{9,11,69},{139,11,750},{7,
-0,1862},{12,0,491},{12,0,520},{13,0,383},{142,0,244},{135,11,734},{134,10,1692},
-{10,0,448},{11,0,630},{17,0,117},{6,10,202},{7,11,705},{12,10,360},{17,10,118},{
-18,10,27},{148,10,67},{4,11,73},{6,11,612},{7,11,927},{7,11,1822},{8,11,217},{9,
-11,472},{9,11,765},{9,11,766},{10,11,408},{11,11,51},{11,11,793},{12,11,266},{15
-,11,158},{20,11,89},{150,11,32},{4,0,190},{133,0,554},{133,0,1001},{5,11,389},{8
-,11,636},{137,11,229},{5,0,446},{7,10,872},{10,10,516},{139,10,167},{137,10,313}
-,{132,10,224},{134,0,1313},{5,10,546},{7,10,35},{8,10,11},{8,10,12},{9,10,315},{
-9,10,533},{10,10,802},{11,10,166},{12,10,525},{142,10,243},{6,0,636},{137,0,837}
-,{5,10,241},{8,10,242},{9,10,451},{10,10,667},{11,10,598},{140,10,429},{22,10,46
-},{150,11,46},{136,11,472},{11,0,278},{142,0,73},{141,11,185},{132,0,868},{134,0
-,972},{4,10,366},{137,10,516},{138,0,1010},{5,11,189},{6,10,1736},{7,11,442},{7,
-11,443},{8,11,281},{12,11,174},{13,11,83},{141,11,261},{139,11,384},{6,11,2},{7,
-11,191},{7,11,446},{7,11,758},{7,11,1262},{7,11,1737},{8,11,22},{8,11,270},{8,11
-,612},{9,11,4},{9,11,167},{9,11,312},{9,11,436},{10,11,156},{10,11,216},{10,11,
-311},{10,11,623},{11,11,72},{11,11,330},{11,11,455},{12,11,101},{12,11,321},{12,
-11,504},{12,11,530},{12,11,543},{13,11,17},{13,11,156},{13,11,334},{14,11,48},{
-15,11,70},{17,11,60},{148,11,64},{6,10,331},{136,10,623},{135,0,1231},{132,0,304
-},{6,11,60},{7,11,670},{7,11,1327},{8,11,411},{8,11,435},{9,11,653},{9,11,740},{
-10,11,385},{11,11,222},{11,11,324},{11,11,829},{140,11,611},{7,0,506},{6,11,166}
-,{7,11,374},{135,11,1174},{14,11,43},{146,11,21},{135,11,1694},{135,10,1888},{5,
-11,206},{134,11,398},{135,11,50},{150,0,26},{6,0,53},{6,0,199},{7,0,1408},{8,0,
-32},{8,0,93},{10,0,397},{10,0,629},{11,0,593},{11,0,763},{13,0,326},{145,0,35},{
-134,0,105},{132,10,394},{4,0,843},{138,0,794},{11,0,704},{141,0,396},{5,0,114},{
-5,0,255},{141,0,285},{6,0,619},{7,0,898},{7,0,1092},{8,0,485},{18,0,28},{19,0,
-116},{135,10,1931},{9,0,145},{7,10,574},{135,10,1719},{7,0,2035},{8,0,19},{9,0,
-89},{138,0,831},{132,10,658},{6,11,517},{7,11,1159},{10,11,621},{139,11,192},{7,
-0,1933},{7,11,1933},{9,10,781},{10,10,144},{11,10,385},{13,10,161},{13,10,228},{
-13,10,268},{148,10,107},{136,10,374},{10,11,223},{139,11,645},{135,0,1728},{7,11
-,64},{7,11,289},{136,11,245},{4,10,344},{6,10,498},{139,10,323},{136,0,746},{135
-,10,1063},{137,10,155},{4,0,987},{6,0,1964},{6,0,1974},{6,0,1990},{136,0,995},{
-133,11,609},{133,10,906},{134,0,1550},{134,0,874},{5,11,129},{6,11,61},{135,11,
-947},{4,0,1018},{6,0,1938},{6,0,2021},{134,0,2039},{132,0,814},{11,0,126},{139,0
-,287},{134,0,1264},{5,0,955},{136,0,814},{141,11,506},{132,11,314},{6,0,981},{
-139,11,1000},{5,0,56},{8,0,892},{8,0,915},{140,0,776},{148,0,100},{10,0,4},{10,0
-,13},{11,0,638},{148,0,57},{148,11,74},{5,0,738},{132,10,616},{133,11,637},{136,
-10,692},{133,0,758},{132,10,305},{137,11,590},{5,11,280},{135,11,1226},{134,11,
-494},{135,0,1112},{133,11,281},{13,0,44},{14,0,214},{5,10,214},{7,10,603},{8,10,
-611},{9,10,686},{10,10,88},{11,10,459},{11,10,496},{12,10,463},{140,10,590},{139
-,0,328},{135,11,1064},{137,0,133},{7,0,168},{13,0,196},{141,0,237},{134,10,1703}
-,{134,0,1152},{135,0,1245},{5,0,110},{6,0,169},{6,0,1702},{7,0,400},{8,0,538},{9
-,0,184},{9,0,524},{140,0,218},{6,0,1816},{10,0,871},{12,0,769},{140,0,785},{132,
-11,630},{7,11,33},{7,11,120},{8,11,489},{9,11,319},{10,11,820},{11,11,1004},{12,
-11,379},{13,11,117},{13,11,412},{14,11,25},{15,11,52},{15,11,161},{16,11,47},{
-149,11,2},{6,0,133},{8,0,413},{9,0,353},{139,0,993},{145,10,19},{4,11,937},{133,
-11,801},{134,0,978},{6,0,93},{6,0,1508},{7,0,1422},{7,0,1851},{8,0,673},{9,0,529
-},{140,0,43},{6,0,317},{10,0,512},{4,10,737},{11,10,294},{12,10,60},{12,10,437},
-{13,10,64},{13,10,380},{142,10,430},{9,0,371},{7,11,1591},{144,11,43},{6,10,1758
-},{8,10,520},{9,10,345},{9,10,403},{142,10,350},{5,0,526},{10,10,242},{138,10,
-579},{9,0,25},{10,0,467},{138,0,559},{5,10,139},{7,10,1168},{138,10,539},{4,0,
-335},{135,0,942},{140,0,754},{132,11,365},{11,0,182},{142,0,195},{142,11,29},{5,
-11,7},{139,11,774},{4,11,746},{135,11,1090},{8,0,39},{10,0,773},{11,0,84},{12,0,
-205},{142,0,1},{5,0,601},{5,0,870},{5,11,360},{136,11,237},{132,0,181},{136,0,
-370},{134,0,1652},{8,0,358},{4,10,107},{7,10,613},{8,10,439},{8,10,504},{9,10,
-501},{10,10,383},{139,10,477},{132,10,229},{137,11,785},{4,0,97},{5,0,147},{6,0,
-286},{7,0,1362},{141,0,176},{6,0,537},{7,0,788},{7,0,1816},{132,10,903},{140,10,
-71},{6,0,743},{134,0,1223},{6,0,375},{7,0,169},{7,0,254},{8,0,780},{135,11,1493}
-,{7,0,1714},{4,10,47},{6,10,373},{7,10,452},{7,10,543},{7,10,1856},{9,10,6},{11,
-10,257},{139,10,391},{6,0,896},{136,0,1003},{135,0,1447},{137,11,341},{5,10,980}
-,{134,10,1754},{145,11,22},{4,11,277},{5,11,608},{6,11,493},{7,11,457},{140,11,
-384},{7,10,536},{7,10,1331},{136,10,143},{140,0,744},{7,11,27},{135,11,316},{18,
-0,126},{5,10,19},{134,10,533},{4,0,788},{11,0,41},{5,11,552},{5,11,586},{5,11,
-676},{6,11,448},{8,11,244},{11,11,1},{11,11,41},{13,11,3},{16,11,54},{17,11,4},{
-146,11,13},{4,0,985},{6,0,1801},{4,11,401},{137,11,264},{5,10,395},{5,10,951},{
-134,10,1776},{5,0,629},{135,0,1549},{11,10,663},{12,10,210},{13,10,166},{13,10,
-310},{14,10,373},{147,10,43},{9,11,543},{10,11,524},{11,11,30},{12,11,524},{14,
-11,315},{16,11,18},{20,11,26},{148,11,65},{4,11,205},{5,11,623},{7,11,104},{136,
-11,519},{5,0,293},{134,0,601},{7,11,579},{9,11,41},{9,11,244},{9,11,669},{10,11,
-5},{11,11,861},{11,11,951},{139,11,980},{132,11,717},{132,10,695},{7,10,497},{9,
-10,387},{147,10,81},{132,0,420},{142,0,37},{6,0,1134},{6,0,1900},{12,0,830},{12,
-0,878},{12,0,894},{15,0,221},{143,0,245},{132,11,489},{7,0,1570},{140,0,542},{8,
-0,933},{136,0,957},{6,0,1371},{7,0,31},{8,0,373},{5,10,284},{6,10,49},{6,10,350}
-,{7,10,377},{7,10,1693},{8,10,678},{9,10,161},{9,10,585},{9,10,671},{9,10,839},{
-11,10,912},{141,10,427},{135,11,892},{4,0,325},{138,0,125},{139,11,47},{132,10,
-597},{138,0,323},{6,0,1547},{7,11,1605},{9,11,473},{11,11,962},{146,11,139},{139
-,10,908},{7,11,819},{9,11,26},{9,11,392},{10,11,152},{10,11,226},{11,11,19},{12,
-11,276},{12,11,426},{12,11,589},{13,11,460},{15,11,97},{19,11,48},{148,11,104},{
-135,11,51},{4,0,718},{135,0,1216},{6,0,1896},{6,0,1905},{6,0,1912},{9,0,947},{9,
-0,974},{12,0,809},{12,0,850},{12,0,858},{12,0,874},{12,0,887},{12,0,904},{12,0,
-929},{12,0,948},{12,0,952},{15,0,198},{15,0,206},{15,0,220},{15,0,227},{15,0,247
-},{18,0,188},{21,0,48},{21,0,50},{24,0,25},{24,0,29},{7,11,761},{7,11,1051},{137
-,11,545},{5,0,124},{5,0,144},{6,0,548},{7,0,15},{7,0,153},{137,0,629},{135,11,
-606},{135,10,2014},{7,10,2007},{9,11,46},{9,10,101},{9,10,450},{10,10,66},{10,10
-,842},{11,10,536},{140,10,587},{6,0,75},{7,0,1531},{8,0,416},{9,0,240},{9,0,275}
-,{10,0,100},{11,0,658},{11,0,979},{12,0,86},{14,0,207},{15,0,20},{143,0,25},{5,0
-,141},{5,0,915},{6,0,1783},{7,0,211},{7,0,698},{7,0,1353},{9,0,83},{9,0,281},{10
-,0,376},{10,0,431},{11,0,543},{12,0,664},{13,0,280},{13,0,428},{14,0,61},{14,0,
-128},{17,0,52},{145,0,81},{132,11,674},{135,0,533},{149,0,6},{132,11,770},{133,0
-,538},{5,11,79},{7,11,1027},{7,11,1477},{139,11,52},{139,10,62},{4,0,338},{133,0
-,400},{5,11,789},{134,11,195},{4,11,251},{4,11,688},{7,11,513},{7,11,1284},{9,11
-,87},{138,11,365},{134,10,1766},{6,0,0},{7,0,84},{11,0,895},{145,0,11},{139,0,
-892},{4,0,221},{5,0,659},{7,0,697},{7,0,1211},{138,0,284},{133,0,989},{133,11,
-889},{4,11,160},{5,11,330},{7,11,1434},{136,11,174},{6,10,1665},{7,10,256},{7,10
-,1388},{10,10,499},{139,10,670},{7,0,848},{4,10,22},{5,10,10},{136,10,97},{138,0
-,507},{133,10,481},{4,0,188},{135,0,805},{5,0,884},{6,0,732},{139,0,991},{135,11
-,968},{11,11,636},{15,11,145},{17,11,34},{19,11,50},{151,11,20},{7,0,959},{16,0,
-60},{6,10,134},{7,10,437},{9,10,37},{14,10,285},{142,10,371},{7,10,486},{8,10,
-155},{11,10,93},{140,10,164},{134,0,1653},{7,0,337},{133,10,591},{6,0,1989},{8,0
-,922},{8,0,978},{133,11,374},{132,0,638},{138,0,500},{133,11,731},{5,10,380},{5,
-10,650},{136,10,310},{138,11,381},{4,10,364},{7,10,1156},{7,10,1187},{137,10,409
-},{137,11,224},{140,0,166},{134,10,482},{4,11,626},{5,11,642},{6,11,425},{10,11,
-202},{139,11,141},{4,10,781},{6,10,487},{7,10,926},{8,10,263},{139,10,500},{135,
-0,418},{4,10,94},{135,10,1265},{136,0,760},{132,10,417},{136,11,835},{5,10,348},
-{134,10,522},{6,0,1277},{134,0,1538},{139,11,541},{135,11,1597},{5,11,384},{8,11
-,455},{140,11,48},{136,0,770},{5,11,264},{134,11,184},{4,0,89},{5,0,489},{6,0,
-315},{7,0,553},{7,0,1745},{138,0,243},{4,10,408},{4,10,741},{135,10,500},{134,0,
-1396},{133,0,560},{6,0,1658},{9,0,3},{10,0,154},{11,0,641},{13,0,85},{13,0,201},
-{141,0,346},{135,11,1595},{5,11,633},{6,11,28},{7,11,219},{135,11,1323},{9,11,
-769},{140,11,185},{135,11,785},{7,11,359},{8,11,243},{140,11,175},{138,0,586},{7
-,0,1271},{134,10,73},{132,11,105},{4,0,166},{5,0,505},{134,0,1670},{133,10,576},
-{4,11,324},{138,11,104},{142,10,231},{6,0,637},{7,10,1264},{7,10,1678},{11,10,
-945},{12,10,341},{12,10,471},{12,10,569},{23,11,21},{151,11,23},{8,11,559},{141,
-11,109},{134,0,1947},{7,0,445},{8,0,307},{8,0,704},{10,0,41},{10,0,439},{11,0,
-237},{11,0,622},{140,0,201},{135,11,963},{135,0,1977},{4,0,189},{5,0,713},{136,0
-,57},{138,0,371},{135,10,538},{132,0,552},{6,0,883},{133,10,413},{6,0,923},{132,
-11,758},{138,11,215},{136,10,495},{7,10,54},{8,10,312},{10,10,191},{10,10,614},{
-140,10,567},{7,11,351},{139,11,128},{7,0,875},{6,10,468},{7,10,1478},{8,10,530},
-{142,10,290},{135,0,1788},{17,0,49},{133,11,918},{12,11,398},{20,11,39},{21,11,
-11},{150,11,41},{10,0,661},{6,10,484},{135,10,822},{135,0,1945},{134,0,794},{137
-,10,900},{135,10,1335},{6,10,1724},{135,10,2022},{132,11,340},{134,0,1135},{4,0,
-784},{133,0,745},{5,0,84},{134,0,163},{133,0,410},{4,0,976},{5,11,985},{7,11,509
-},{7,11,529},{145,11,96},{132,10,474},{134,0,703},{135,11,1919},{5,0,322},{8,0,
-186},{9,0,262},{10,0,187},{142,0,208},{135,10,1504},{133,0,227},{9,0,560},{13,0,
-208},{133,10,305},{132,11,247},{7,0,1395},{8,0,486},{9,0,236},{9,0,878},{10,0,
-218},{11,0,95},{19,0,17},{147,0,31},{7,0,2043},{8,0,672},{141,0,448},{4,11,184},
-{5,11,390},{6,11,337},{7,11,23},{7,11,494},{7,11,618},{7,11,1456},{8,11,27},{8,
-11,599},{10,11,153},{139,11,710},{135,0,466},{135,10,1236},{6,0,167},{7,0,186},{
-7,0,656},{10,0,643},{4,10,480},{6,10,302},{6,10,1642},{7,10,837},{7,10,1547},{7,
-10,1657},{8,10,429},{9,10,228},{13,10,289},{13,10,343},{147,10,101},{134,0,1428}
-,{134,0,1440},{5,0,412},{7,10,278},{10,10,739},{11,10,708},{141,10,348},{134,0,
-1118},{136,0,562},{148,11,46},{9,0,316},{139,0,256},{134,0,1771},{135,0,1190},{
-137,0,132},{10,11,227},{11,11,497},{11,11,709},{140,11,415},{143,0,66},{6,11,360
-},{7,11,1664},{136,11,478},{144,10,28},{4,0,317},{135,0,1279},{5,0,63},{133,0,
-509},{136,11,699},{145,10,36},{134,0,1475},{11,11,343},{142,11,127},{132,11,739}
-,{132,0,288},{135,11,1757},{8,0,89},{8,0,620},{9,0,608},{11,0,628},{12,0,322},{
-143,0,124},{134,0,1225},{7,0,1189},{4,11,67},{5,11,422},{6,10,363},{7,11,1037},{
-7,11,1289},{7,11,1555},{7,10,1955},{8,10,725},{9,11,741},{145,11,108},{134,0,
-1468},{6,0,689},{134,0,1451},{138,0,120},{151,0,1},{137,10,805},{142,0,329},{5,
-10,813},{135,10,2046},{135,0,226},{138,11,96},{7,0,1855},{5,10,712},{11,10,17},{
-13,10,321},{144,10,67},{9,0,461},{6,10,320},{7,10,781},{7,10,1921},{9,10,55},{10
-,10,186},{10,10,273},{10,10,664},{10,10,801},{11,10,996},{11,10,997},{13,10,157}
-,{142,10,170},{8,11,203},{8,10,271},{11,11,823},{11,11,846},{12,11,482},{13,11,
-133},{13,11,277},{13,11,302},{13,11,464},{14,11,205},{142,11,221},{135,0,1346},{
-4,11,449},{133,11,718},{134,0,85},{14,0,299},{7,10,103},{7,10,863},{11,10,184},{
-145,10,62},{4,11,355},{6,11,311},{9,11,256},{138,11,404},{137,10,659},{138,11,
-758},{133,11,827},{5,11,64},{140,11,581},{134,0,1171},{4,11,442},{7,11,1047},{7,
-11,1352},{135,11,1643},{132,0,980},{5,11,977},{6,11,288},{7,11,528},{135,11,1065
-},{5,0,279},{6,0,235},{7,0,468},{8,0,446},{9,0,637},{10,0,717},{11,0,738},{140,0
-,514},{132,0,293},{11,10,337},{142,10,303},{136,11,285},{5,0,17},{6,0,371},{9,0,
-528},{12,0,364},{132,11,254},{5,10,77},{7,10,1455},{10,10,843},{147,10,73},{150,
-0,5},{132,10,458},{6,11,12},{7,11,1219},{145,11,73},{135,10,1420},{6,10,109},{
-138,10,382},{135,11,125},{6,10,330},{7,10,1084},{139,10,142},{6,11,369},{6,11,
-502},{7,11,1036},{8,11,348},{9,11,452},{10,11,26},{11,11,224},{11,11,387},{11,11
-,772},{12,11,95},{12,11,629},{13,11,195},{13,11,207},{13,11,241},{14,11,260},{14
-,11,270},{143,11,140},{132,11,269},{5,11,480},{7,11,532},{7,11,1197},{7,11,1358}
-,{8,11,291},{11,11,349},{142,11,396},{150,0,48},{10,0,601},{13,0,353},{141,0,376
-},{5,0,779},{5,0,807},{6,0,1655},{134,0,1676},{142,11,223},{4,0,196},{5,0,558},{
-133,0,949},{148,11,15},{135,11,1764},{134,0,1322},{132,0,752},{139,0,737},{135,
-11,657},{136,11,533},{135,0,412},{4,0,227},{5,0,159},{5,0,409},{7,0,80},{8,0,556
-},{10,0,479},{12,0,418},{14,0,50},{14,0,123},{14,0,192},{14,0,249},{14,0,295},{
-143,0,27},{7,0,1470},{8,0,66},{8,0,137},{8,0,761},{9,0,638},{11,0,80},{11,0,212}
-,{11,0,368},{11,0,418},{12,0,8},{13,0,15},{16,0,61},{17,0,59},{19,0,28},{148,0,
-84},{135,10,1985},{4,11,211},{4,11,332},{5,11,335},{6,11,238},{7,11,269},{7,11,
-811},{7,11,1797},{8,10,122},{8,11,836},{9,11,507},{141,11,242},{6,0,683},{134,0,
-1252},{4,0,873},{132,10,234},{134,0,835},{6,0,38},{7,0,1220},{8,0,185},{8,0,256}
-,{9,0,22},{9,0,331},{10,0,738},{11,0,205},{11,0,540},{11,0,746},{13,0,465},{14,0
-,88},{142,0,194},{138,0,986},{5,11,1009},{12,11,582},{146,11,131},{4,0,159},{6,0
-,115},{7,0,252},{7,0,257},{7,0,1928},{8,0,69},{9,0,384},{10,0,91},{10,0,615},{12
-,0,375},{14,0,235},{18,0,117},{147,0,123},{133,0,911},{136,0,278},{5,10,430},{5,
-10,932},{6,10,131},{7,10,417},{9,10,522},{11,10,314},{141,10,390},{14,10,149},{
-14,10,399},{143,10,57},{4,0,151},{7,0,1567},{136,0,749},{5,11,228},{6,11,203},{7
-,11,156},{8,11,347},{137,11,265},{132,10,507},{10,0,989},{140,0,956},{133,0,990}
-,{5,0,194},{6,0,927},{7,0,1662},{9,0,90},{140,0,564},{4,10,343},{133,10,511},{
-133,0,425},{7,10,455},{138,10,591},{4,0,774},{7,11,476},{7,11,1592},{138,11,87},
-{5,0,971},{135,10,1381},{5,11,318},{147,11,121},{5,11,291},{7,11,765},{9,11,389}
-,{140,11,548},{134,10,575},{4,0,827},{12,0,646},{12,0,705},{12,0,712},{140,0,714
-},{139,0,752},{137,0,662},{5,0,72},{6,0,264},{7,0,21},{7,0,46},{7,0,2013},{8,0,
-215},{8,0,513},{10,0,266},{139,0,22},{139,11,522},{6,0,239},{7,0,118},{10,0,95},
-{11,0,603},{13,0,443},{14,0,160},{143,0,4},{6,0,431},{134,0,669},{7,10,1127},{7,
-10,1572},{10,10,297},{10,10,422},{11,10,764},{11,10,810},{12,10,264},{13,10,102}
-,{13,10,300},{13,10,484},{14,10,147},{14,10,229},{17,10,71},{18,10,118},{147,10,
-120},{5,0,874},{6,0,1677},{15,0,0},{10,11,525},{139,11,82},{6,0,65},{7,0,939},{7
-,0,1172},{7,0,1671},{9,0,540},{10,0,696},{11,0,265},{11,0,732},{11,0,928},{11,0,
-937},{141,0,438},{134,0,1350},{136,11,547},{132,11,422},{5,11,355},{145,11,0},{
-137,11,905},{5,0,682},{135,0,1887},{132,0,809},{4,0,696},{133,11,865},{6,0,1074}
-,{6,0,1472},{14,10,35},{142,10,191},{5,11,914},{134,11,1625},{133,11,234},{135,
-11,1383},{137,11,780},{132,10,125},{4,0,726},{133,0,630},{8,0,802},{136,0,838},{
-132,10,721},{6,0,1337},{7,0,776},{19,0,56},{136,10,145},{132,0,970},{7,10,792},{
-8,10,147},{10,10,821},{139,10,1021},{139,10,970},{8,0,940},{137,0,797},{135,11,
-1312},{9,0,248},{10,0,400},{7,11,816},{7,11,1241},{7,10,1999},{9,11,283},{9,11,
-520},{10,11,213},{10,11,307},{10,11,463},{10,11,671},{10,11,746},{11,11,401},{11
-,11,794},{12,11,517},{18,11,107},{147,11,115},{6,0,1951},{134,0,2040},{135,11,
-339},{13,0,41},{15,0,93},{5,10,168},{5,10,930},{8,10,74},{9,10,623},{12,10,500},
-{140,10,579},{6,0,118},{7,0,215},{7,0,1521},{140,0,11},{6,10,220},{7,10,1101},{
-141,10,105},{6,11,421},{7,11,61},{7,11,1540},{10,11,11},{138,11,501},{7,0,615},{
-138,0,251},{140,11,631},{135,0,1044},{6,10,19},{7,10,1413},{139,10,428},{133,0,
-225},{7,10,96},{8,10,401},{8,10,703},{137,10,896},{145,10,116},{6,11,102},{7,11,
-72},{15,11,142},{147,11,67},{7,10,1961},{7,10,1965},{8,10,702},{136,10,750},{7,
-10,2030},{8,10,150},{8,10,737},{12,10,366},{151,11,30},{4,0,370},{5,0,756},{7,0,
-1326},{135,11,823},{8,10,800},{9,10,148},{9,10,872},{9,10,890},{11,10,309},{11,
-10,1001},{13,10,267},{141,10,323},{6,0,1662},{7,0,48},{8,0,771},{10,0,116},{13,0
-,104},{14,0,105},{14,0,184},{15,0,168},{19,0,92},{148,0,68},{10,0,209},{135,11,
-1870},{7,11,68},{8,11,48},{8,11,88},{8,11,582},{8,11,681},{9,11,373},{9,11,864},
-{11,11,157},{11,11,336},{11,11,843},{148,11,27},{134,0,930},{4,11,88},{5,11,137}
-,{5,11,174},{5,11,777},{6,11,1664},{6,11,1725},{7,11,77},{7,11,426},{7,11,1317},
-{7,11,1355},{8,11,126},{8,11,563},{9,11,523},{9,11,750},{10,11,310},{10,11,836},
-{11,11,42},{11,11,318},{11,11,731},{12,11,68},{12,11,92},{12,11,507},{12,11,692}
-,{13,11,81},{13,11,238},{13,11,374},{18,11,138},{19,11,78},{19,11,111},{20,11,55
-},{20,11,77},{148,11,92},{4,11,938},{135,11,1831},{5,10,547},{7,10,424},{8,11,
-617},{138,11,351},{6,0,1286},{6,11,1668},{7,11,1499},{8,11,117},{9,11,314},{138,
-11,174},{6,0,759},{6,0,894},{7,11,707},{139,11,563},{4,0,120},{135,0,1894},{9,0,
-385},{149,0,17},{138,0,429},{133,11,403},{5,0,820},{135,0,931},{10,0,199},{133,
-10,133},{6,0,151},{6,0,1675},{7,0,383},{151,0,10},{6,0,761},{136,10,187},{8,0,
-365},{10,10,0},{10,10,818},{139,10,988},{4,11,44},{5,11,311},{6,11,156},{7,11,
-639},{7,11,762},{7,11,1827},{9,11,8},{9,11,462},{148,11,83},{4,11,346},{7,11,115
-},{9,11,180},{9,11,456},{138,11,363},{136,10,685},{7,0,1086},{145,0,46},{6,0,
-1624},{11,0,11},{12,0,422},{13,0,444},{142,0,360},{6,0,1020},{6,0,1260},{134,0,
-1589},{4,0,43},{5,0,344},{5,0,357},{14,0,472},{150,0,58},{6,0,1864},{6,0,1866},{
-6,0,1868},{6,0,1869},{6,0,1874},{6,0,1877},{6,0,1903},{6,0,1911},{9,0,920},{9,0,
-921},{9,0,924},{9,0,946},{9,0,959},{9,0,963},{9,0,970},{9,0,997},{9,0,1008},{9,0
-,1017},{12,0,795},{12,0,797},{12,0,798},{12,0,800},{12,0,803},{12,0,811},{12,0,
-820},{12,0,821},{12,0,839},{12,0,841},{12,0,848},{12,0,911},{12,0,921},{12,0,922
-},{12,0,925},{12,0,937},{12,0,944},{12,0,945},{12,0,953},{15,0,184},{15,0,191},{
-15,0,199},{15,0,237},{15,0,240},{15,0,243},{15,0,246},{18,0,203},{21,0,40},{21,0
-,52},{21,0,57},{24,0,23},{24,0,28},{152,0,30},{134,0,725},{145,11,58},{133,0,888
-},{137,10,874},{4,0,711},{8,10,774},{10,10,670},{140,10,51},{144,11,40},{6,11,
-185},{7,11,1899},{139,11,673},{137,10,701},{137,0,440},{4,11,327},{5,11,478},{7,
-11,1332},{8,11,753},{140,11,227},{4,10,127},{5,10,350},{6,10,356},{8,10,426},{9,
-10,572},{10,10,247},{139,10,312},{5,11,1020},{133,11,1022},{4,11,103},{133,11,
-401},{6,0,1913},{6,0,1926},{6,0,1959},{9,0,914},{9,0,939},{9,0,952},{9,0,979},{9
-,0,990},{9,0,998},{9,0,1003},{9,0,1023},{12,0,827},{12,0,834},{12,0,845},{12,0,
-912},{12,0,935},{12,0,951},{15,0,172},{15,0,174},{18,0,198},{149,0,63},{5,0,958}
-,{5,0,987},{4,11,499},{135,11,1421},{7,0,885},{6,10,59},{6,10,1762},{9,10,603},{
-141,10,397},{10,11,62},{141,11,164},{4,0,847},{135,0,326},{11,0,276},{142,0,293}
-,{4,0,65},{5,0,479},{5,0,1004},{7,0,1913},{8,0,317},{9,0,302},{10,0,612},{13,0,
-22},{132,11,96},{4,0,261},{135,0,510},{135,0,1514},{6,10,111},{7,10,4},{8,10,163
-},{8,10,776},{138,10,566},{4,0,291},{9,0,515},{12,0,152},{12,0,443},{13,0,392},{
-142,0,357},{7,11,399},{135,11,1492},{4,0,589},{139,0,282},{6,11,563},{135,10,
-1994},{5,10,297},{135,10,1038},{4,0,130},{7,0,843},{135,0,1562},{5,0,42},{5,0,
-879},{7,0,245},{7,0,324},{7,0,1532},{11,0,463},{11,0,472},{13,0,363},{144,0,52},
-{4,0,134},{133,0,372},{133,0,680},{136,10,363},{6,0,1997},{8,0,935},{136,0,977},
-{4,0,810},{135,0,1634},{135,10,1675},{7,0,1390},{4,11,910},{133,11,832},{7,10,
-808},{8,11,266},{139,11,578},{132,0,644},{4,0,982},{138,0,867},{132,10,280},{135
-,0,540},{140,10,54},{135,0,123},{134,0,1978},{4,10,421},{133,10,548},{6,0,623},{
-136,0,789},{4,0,908},{5,0,359},{5,0,508},{6,0,1723},{7,0,343},{7,0,1996},{135,0,
-2026},{134,0,1220},{4,0,341},{135,0,480},{6,10,254},{9,10,109},{138,10,103},{134
-,0,888},{8,11,528},{137,11,348},{7,0,1995},{8,0,299},{11,0,890},{12,0,674},{4,11
-,20},{133,11,616},{135,11,1094},{134,10,1630},{4,0,238},{5,0,503},{6,0,179},{7,0
-,2003},{8,0,381},{8,0,473},{9,0,149},{10,0,788},{15,0,45},{15,0,86},{20,0,110},{
-150,0,57},{133,10,671},{4,11,26},{5,11,429},{6,11,245},{7,11,704},{7,11,1379},{
-135,11,1474},{4,0,121},{5,0,156},{5,0,349},{9,0,431},{10,0,605},{142,0,342},{7,
-11,943},{139,11,614},{132,10,889},{132,11,621},{7,10,1382},{7,11,1382},{135,10,
-1910},{132,10,627},{133,10,775},{133,11,542},{133,11,868},{136,11,433},{6,0,1373
-},{7,0,1011},{11,10,362},{11,10,948},{140,10,388},{6,0,80},{7,0,173},{9,0,547},{
-10,0,730},{14,0,18},{22,0,39},{135,11,1495},{6,0,1694},{135,0,1974},{140,0,196},
-{4,0,923},{6,0,507},{6,0,1711},{7,10,451},{8,10,389},{12,10,490},{13,10,16},{13,
-10,215},{13,10,351},{18,10,132},{147,10,125},{6,0,646},{134,0,1047},{135,10,841}
-,{136,10,566},{6,0,1611},{135,0,1214},{139,0,926},{132,11,525},{132,0,595},{5,0,
-240},{6,0,459},{7,0,12},{7,0,114},{7,0,949},{7,0,1753},{7,0,1805},{8,0,658},{9,0
-,1},{11,0,959},{141,0,446},{5,10,912},{134,10,1695},{132,0,446},{7,11,62},{12,11
-,45},{147,11,112},{5,10,236},{6,10,572},{8,10,492},{11,10,618},{144,10,56},{5,10
-,190},{136,10,318},{135,10,1376},{4,11,223},{6,11,359},{11,11,3},{13,11,108},{14
-,11,89},{144,11,22},{132,11,647},{134,0,490},{134,0,491},{134,0,1584},{135,11,
-685},{138,11,220},{7,0,250},{136,0,507},{132,0,158},{4,0,140},{7,0,362},{8,0,209
-},{9,0,10},{9,0,160},{9,0,503},{9,0,614},{10,0,689},{11,0,327},{11,0,553},{11,0,
-725},{11,0,767},{12,0,252},{12,0,583},{13,0,192},{14,0,269},{14,0,356},{148,0,50
-},{19,0,1},{19,0,26},{150,0,9},{132,11,109},{6,0,228},{7,0,1341},{9,0,408},{138,
-0,343},{4,0,373},{5,0,283},{6,0,480},{7,0,609},{10,0,860},{138,0,878},{6,0,779},
-{134,0,1209},{4,0,557},{7,11,263},{7,11,628},{136,11,349},{132,0,548},{7,0,197},
-{8,0,142},{8,0,325},{9,0,150},{9,0,596},{10,0,350},{10,0,353},{11,0,74},{11,0,
-315},{12,0,662},{12,0,681},{14,0,423},{143,0,141},{4,11,40},{10,11,67},{11,11,
-117},{11,11,768},{139,11,935},{7,11,992},{8,11,301},{9,11,722},{12,11,63},{13,11
-,29},{14,11,161},{143,11,18},{6,0,1490},{138,11,532},{5,0,580},{7,0,378},{7,0,
-674},{7,0,1424},{15,0,83},{16,0,11},{15,11,83},{144,11,11},{6,0,1057},{6,0,1335}
-,{10,0,316},{7,10,85},{7,10,247},{8,10,585},{138,10,163},{4,0,169},{5,0,83},{6,0
-,399},{6,0,579},{6,0,1513},{7,0,692},{7,0,846},{7,0,1015},{7,0,1799},{8,0,403},{
-9,0,394},{10,0,133},{12,0,4},{12,0,297},{12,0,452},{16,0,81},{18,0,25},{21,0,14}
-,{22,0,12},{151,0,18},{134,0,1106},{7,0,1546},{11,0,299},{142,0,407},{134,0,1192
-},{132,0,177},{5,0,411},{135,0,653},{7,0,439},{10,0,727},{11,0,260},{139,0,684},
-{138,10,145},{147,10,83},{5,0,208},{7,0,753},{135,0,1528},{137,11,617},{135,10,
-1922},{135,11,825},{11,0,422},{13,0,389},{4,10,124},{10,10,457},{11,10,121},{11,
-10,169},{11,10,870},{12,10,214},{14,10,187},{143,10,77},{11,0,615},{15,0,58},{11
-,11,615},{143,11,58},{9,0,618},{138,0,482},{6,0,1952},{6,0,1970},{142,0,505},{7,
-10,1193},{135,11,1838},{133,0,242},{135,10,1333},{6,10,107},{7,10,638},{7,10,
-1632},{137,10,396},{133,0,953},{5,10,370},{134,10,1756},{5,11,28},{6,11,204},{10
-,11,320},{10,11,583},{13,11,502},{14,11,72},{14,11,274},{14,11,312},{14,11,344},
-{15,11,159},{16,11,62},{16,11,69},{17,11,30},{18,11,42},{18,11,53},{18,11,84},{
-18,11,140},{19,11,68},{19,11,85},{20,11,5},{20,11,45},{20,11,101},{22,11,7},{150
-,11,20},{4,11,558},{6,11,390},{7,11,162},{7,11,689},{9,11,360},{138,11,653},{11,
-0,802},{141,0,67},{133,10,204},{133,0,290},{5,10,970},{134,10,1706},{132,0,380},
-{5,0,52},{7,0,277},{9,0,368},{139,0,791},{5,11,856},{6,11,1672},{6,11,1757},{6,
-11,1781},{7,11,1150},{7,11,1425},{7,11,1453},{140,11,513},{5,11,92},{7,10,3},{10
-,11,736},{140,11,102},{4,0,112},{5,0,653},{5,10,483},{5,10,685},{6,10,489},{7,10
-,1204},{136,10,394},{132,10,921},{6,0,1028},{133,10,1007},{5,11,590},{9,11,213},
-{145,11,91},{135,10,1696},{10,0,138},{139,0,476},{5,0,725},{5,0,727},{135,0,1811
-},{4,0,979},{6,0,1821},{6,0,1838},{8,0,876},{8,0,883},{8,0,889},{8,0,893},{8,0,
-895},{10,0,934},{12,0,720},{14,0,459},{148,0,123},{135,11,551},{4,0,38},{6,0,435
-},{7,0,307},{7,0,999},{7,0,1481},{7,0,1732},{7,0,1738},{8,0,371},{9,0,414},{11,0
-,316},{12,0,52},{13,0,420},{147,0,100},{135,0,1296},{132,10,712},{134,10,1629},{
-133,0,723},{134,0,651},{136,11,191},{9,11,791},{10,11,93},{11,11,301},{16,11,13}
-,{17,11,23},{18,11,135},{19,11,12},{20,11,1},{20,11,12},{148,11,14},{136,11,503}
-,{6,11,466},{135,11,671},{6,0,1200},{134,0,1330},{135,0,1255},{134,0,986},{5,0,
-109},{6,0,1784},{7,0,1895},{12,0,296},{140,0,302},{135,11,983},{133,10,485},{134
-,0,660},{134,0,800},{5,0,216},{5,0,294},{6,0,591},{7,0,1879},{9,0,141},{9,0,270}
-,{9,0,679},{10,0,159},{11,0,197},{11,0,438},{12,0,538},{12,0,559},{14,0,144},{14
-,0,167},{15,0,67},{4,10,285},{5,10,317},{6,10,301},{7,10,7},{8,10,153},{10,10,
-766},{11,10,468},{12,10,467},{141,10,143},{136,0,945},{134,0,1090},{137,0,81},{
-12,11,468},{19,11,96},{148,11,24},{134,0,391},{138,11,241},{7,0,322},{136,0,249}
-,{134,0,1412},{135,11,795},{5,0,632},{138,0,526},{136,10,819},{6,0,144},{7,0,948
-},{7,0,1042},{8,0,235},{8,0,461},{9,0,453},{9,0,796},{10,0,354},{17,0,77},{135,
-11,954},{139,10,917},{6,0,940},{134,0,1228},{4,0,362},{7,0,52},{135,0,303},{6,11
-,549},{8,11,34},{8,11,283},{9,11,165},{138,11,475},{7,11,370},{7,11,1007},{7,11,
-1177},{135,11,1565},{5,11,652},{5,11,701},{135,11,449},{5,0,196},{6,0,486},{7,0,
-212},{8,0,309},{136,0,346},{6,10,1719},{6,10,1735},{7,10,2016},{7,10,2020},{8,10
-,837},{137,10,852},{6,11,159},{6,11,364},{7,11,516},{7,11,1439},{137,11,518},{
-135,0,1912},{135,0,1290},{132,0,686},{141,11,151},{138,0,625},{136,0,706},{138,
-10,568},{139,0,412},{4,0,30},{133,0,43},{8,10,67},{138,10,419},{7,0,967},{141,0,
-11},{12,0,758},{14,0,441},{142,0,462},{10,10,657},{14,10,297},{142,10,361},{139,
-10,729},{4,0,220},{135,0,1535},{7,11,501},{9,11,111},{10,11,141},{11,11,332},{13
-,11,43},{13,11,429},{14,11,130},{14,11,415},{145,11,102},{4,0,950},{6,0,1859},{7
-,0,11},{8,0,873},{12,0,710},{12,0,718},{12,0,748},{12,0,765},{148,0,124},{5,11,
-149},{5,11,935},{136,11,233},{142,11,291},{134,0,1579},{7,0,890},{8,10,51},{9,10
-,868},{10,10,833},{12,10,481},{12,10,570},{148,10,106},{141,0,2},{132,10,445},{
-136,11,801},{135,0,1774},{7,0,1725},{138,0,393},{5,0,263},{134,0,414},{132,11,
-322},{133,10,239},{7,0,456},{7,10,1990},{8,10,130},{139,10,720},{137,0,818},{5,
-10,123},{6,10,530},{7,10,348},{135,10,1419},{135,10,2024},{6,0,178},{6,0,1750},{
-8,0,251},{9,0,690},{10,0,155},{10,0,196},{10,0,373},{11,0,698},{13,0,155},{148,0
-,93},{5,0,97},{137,0,393},{134,0,674},{11,0,223},{140,0,168},{132,10,210},{139,
-11,464},{6,0,1639},{146,0,159},{139,11,2},{7,0,934},{8,0,647},{17,0,97},{19,0,59
-},{150,0,2},{132,0,191},{5,0,165},{9,0,346},{10,0,655},{11,0,885},{4,10,430},{
-135,11,357},{133,0,877},{5,10,213},{133,11,406},{8,0,128},{139,0,179},{6,11,69},
-{135,11,117},{135,0,1297},{11,11,43},{13,11,72},{141,11,142},{135,11,1830},{142,
-0,164},{5,0,57},{6,0,101},{6,0,586},{6,0,1663},{7,0,132},{7,0,1154},{7,0,1415},{
-7,0,1507},{12,0,493},{15,0,105},{151,0,15},{5,0,459},{7,0,1073},{8,0,241},{136,0
-,334},{133,11,826},{133,10,108},{5,10,219},{10,11,132},{11,11,191},{11,11,358},{
-139,11,460},{6,0,324},{6,0,520},{7,0,338},{7,0,1729},{8,0,228},{139,0,750},{21,0
-,30},{22,0,53},{4,10,193},{5,10,916},{7,10,364},{10,10,398},{10,10,726},{11,10,
-317},{11,10,626},{12,10,142},{12,10,288},{12,10,678},{13,10,313},{15,10,113},{
-146,10,114},{6,11,110},{135,11,1681},{135,0,910},{6,10,241},{7,10,907},{8,10,832
-},{9,10,342},{10,10,729},{11,10,284},{11,10,445},{11,10,651},{11,10,863},{13,10,
-398},{146,10,99},{7,0,705},{9,0,734},{5,11,1000},{7,11,733},{137,11,583},{4,0,73
-},{6,0,612},{7,0,927},{7,0,1822},{8,0,217},{9,0,765},{9,0,766},{10,0,408},{11,0,
-51},{11,0,793},{12,0,266},{15,0,158},{20,0,89},{150,0,32},{7,0,1330},{4,11,297},
-{6,11,529},{7,11,152},{7,11,713},{7,11,1845},{8,11,710},{8,11,717},{140,11,639},
-{5,0,389},{136,0,636},{134,0,1409},{4,10,562},{9,10,254},{139,10,879},{134,0,893
-},{132,10,786},{4,11,520},{135,11,575},{136,0,21},{140,0,721},{136,0,959},{7,11,
-1428},{7,11,1640},{9,11,169},{9,11,182},{9,11,367},{9,11,478},{9,11,506},{9,11,
-551},{9,11,648},{9,11,651},{9,11,697},{9,11,705},{9,11,725},{9,11,787},{9,11,794
-},{10,11,198},{10,11,214},{10,11,267},{10,11,275},{10,11,456},{10,11,551},{10,11
-,561},{10,11,613},{10,11,627},{10,11,668},{10,11,675},{10,11,691},{10,11,695},{
-10,11,707},{10,11,715},{11,11,183},{11,11,201},{11,11,244},{11,11,262},{11,11,
-352},{11,11,439},{11,11,493},{11,11,572},{11,11,591},{11,11,608},{11,11,611},{11
-,11,646},{11,11,674},{11,11,711},{11,11,751},{11,11,761},{11,11,776},{11,11,785}
-,{11,11,850},{11,11,853},{11,11,862},{11,11,865},{11,11,868},{11,11,898},{11,11,
-902},{11,11,903},{11,11,910},{11,11,932},{11,11,942},{11,11,957},{11,11,967},{11
-,11,972},{12,11,148},{12,11,195},{12,11,220},{12,11,237},{12,11,318},{12,11,339}
-,{12,11,393},{12,11,445},{12,11,450},{12,11,474},{12,11,509},{12,11,533},{12,11,
-591},{12,11,594},{12,11,597},{12,11,621},{12,11,633},{12,11,642},{13,11,59},{13,
-11,60},{13,11,145},{13,11,239},{13,11,250},{13,11,273},{13,11,329},{13,11,344},{
-13,11,365},{13,11,372},{13,11,387},{13,11,403},{13,11,414},{13,11,456},{13,11,
-478},{13,11,483},{13,11,489},{14,11,55},{14,11,57},{14,11,81},{14,11,90},{14,11,
-148},{14,11,239},{14,11,266},{14,11,321},{14,11,326},{14,11,327},{14,11,330},{14
-,11,347},{14,11,355},{14,11,401},{14,11,411},{14,11,414},{14,11,416},{14,11,420}
-,{15,11,61},{15,11,74},{15,11,87},{15,11,88},{15,11,94},{15,11,96},{15,11,116},{
-15,11,149},{15,11,154},{16,11,50},{16,11,63},{16,11,73},{17,11,2},{17,11,66},{17
-,11,92},{17,11,103},{17,11,112},{18,11,50},{18,11,54},{18,11,82},{18,11,86},{18,
-11,90},{18,11,111},{18,11,115},{18,11,156},{19,11,40},{19,11,79},{20,11,78},{149
-,11,22},{137,11,170},{134,0,1433},{135,11,1307},{139,11,411},{5,0,189},{7,0,442}
-,{7,0,443},{8,0,281},{12,0,174},{141,0,261},{6,10,216},{7,10,901},{7,10,1343},{
-136,10,493},{5,11,397},{6,11,154},{7,10,341},{7,11,676},{8,11,443},{8,11,609},{9
-,11,24},{9,11,325},{10,11,35},{11,10,219},{11,11,535},{11,11,672},{11,11,1018},{
-12,11,637},{144,11,30},{6,0,2},{7,0,191},{7,0,446},{7,0,1262},{7,0,1737},{8,0,22
-},{8,0,270},{8,0,612},{9,0,4},{9,0,312},{9,0,436},{9,0,626},{10,0,216},{10,0,311
-},{10,0,521},{10,0,623},{11,0,72},{11,0,330},{11,0,455},{12,0,321},{12,0,504},{
-12,0,530},{12,0,543},{13,0,17},{13,0,156},{13,0,334},{14,0,131},{17,0,60},{148,0
-,64},{7,0,354},{10,0,410},{139,0,815},{139,10,130},{7,10,1734},{137,11,631},{12,
-0,425},{15,0,112},{10,10,115},{11,10,420},{13,10,404},{14,10,346},{143,10,54},{6
-,0,60},{6,0,166},{7,0,374},{7,0,670},{7,0,1327},{8,0,411},{8,0,435},{9,0,653},{9
-,0,740},{10,0,385},{11,0,222},{11,0,324},{11,0,829},{140,0,611},{7,0,1611},{13,0
-,14},{15,0,44},{19,0,13},{148,0,76},{133,11,981},{4,11,56},{7,11,1791},{8,11,607
-},{8,11,651},{11,11,465},{11,11,835},{12,11,337},{141,11,480},{6,0,1478},{5,10,
-1011},{136,10,701},{139,0,596},{5,0,206},{134,0,398},{4,10,54},{5,10,666},{7,10,
-1039},{7,10,1130},{9,10,195},{138,10,302},{7,0,50},{9,11,158},{138,11,411},{135,
-11,1120},{6,0,517},{7,0,1159},{10,0,621},{11,0,192},{134,10,1669},{4,0,592},{6,0
-,600},{135,0,1653},{10,0,223},{139,0,645},{136,11,139},{7,0,64},{136,0,245},{142
-,0,278},{6,11,622},{135,11,1030},{136,0,604},{134,0,1502},{138,0,265},{141,11,
-168},{7,0,1763},{140,0,310},{7,10,798},{139,11,719},{7,11,160},{10,11,624},{142,
-11,279},{132,11,363},{7,10,122},{9,10,259},{10,10,84},{11,10,470},{12,10,541},{
-141,10,379},{5,0,129},{6,0,61},{135,0,947},{134,0,1356},{135,11,1191},{13,0,505}
-,{141,0,506},{11,0,1000},{5,10,82},{5,10,131},{7,10,1755},{8,10,31},{9,10,168},{
-9,10,764},{139,10,869},{134,0,966},{134,10,605},{134,11,292},{5,11,177},{6,11,
-616},{7,11,827},{9,11,525},{138,11,656},{135,11,1486},{138,11,31},{5,10,278},{
-137,10,68},{4,10,163},{5,10,201},{5,10,307},{5,10,310},{6,10,335},{7,10,284},{
-136,10,165},{6,0,839},{135,10,1660},{136,10,781},{6,10,33},{135,10,1244},{133,0,
-637},{4,11,161},{133,11,631},{137,0,590},{7,10,1953},{136,10,720},{5,0,280},{7,0
-,1226},{138,10,203},{134,0,1386},{5,0,281},{6,0,1026},{6,10,326},{7,10,677},{137
-,10,425},{7,11,1557},{135,11,1684},{135,0,1064},{9,11,469},{9,11,709},{12,11,512
-},{14,11,65},{145,11,12},{134,0,917},{10,11,229},{11,11,73},{11,11,376},{139,11,
-433},{7,0,555},{9,0,192},{13,0,30},{13,0,49},{15,0,150},{16,0,76},{20,0,52},{7,
-10,1316},{7,10,1412},{7,10,1839},{9,10,589},{11,10,241},{11,10,676},{11,10,811},
-{11,10,891},{12,10,140},{12,10,346},{12,10,479},{13,10,381},{14,10,188},{146,10,
-30},{149,0,15},{6,0,1882},{6,0,1883},{6,0,1897},{9,0,945},{9,0,1014},{9,0,1020},
-{12,0,823},{12,0,842},{12,0,866},{12,0,934},{15,0,242},{146,0,208},{6,0,965},{
-134,0,1499},{7,0,33},{7,0,120},{8,0,489},{9,0,319},{10,0,820},{11,0,1004},{12,0,
-379},{12,0,679},{13,0,117},{13,0,412},{14,0,25},{15,0,52},{15,0,161},{16,0,47},{
-149,0,2},{6,11,558},{7,11,651},{8,11,421},{9,11,0},{138,11,34},{4,0,937},{5,0,
-801},{7,0,473},{5,10,358},{7,10,1184},{10,10,662},{13,10,212},{13,10,304},{13,10
-,333},{145,10,98},{132,0,877},{6,0,693},{134,0,824},{132,0,365},{7,11,1832},{138
-,11,374},{5,0,7},{139,0,774},{4,0,734},{5,0,662},{134,0,430},{4,0,746},{135,0,
-1090},{5,0,360},{8,0,237},{10,0,231},{147,0,124},{138,11,348},{6,11,6},{7,11,81}
-,{7,11,771},{7,11,1731},{9,11,405},{138,11,421},{6,0,740},{137,0,822},{133,10,
-946},{7,0,1485},{136,0,929},{7,10,411},{8,10,631},{9,10,323},{10,10,355},{11,10,
-491},{12,10,143},{12,10,402},{13,10,73},{14,10,408},{15,10,107},{146,10,71},{135
-,10,590},{5,11,881},{133,11,885},{150,11,25},{4,0,852},{5,11,142},{134,11,546},{
-7,10,1467},{8,10,328},{10,10,544},{11,10,955},{13,10,320},{145,10,83},{9,0,17},{
-10,0,291},{11,10,511},{13,10,394},{14,10,298},{14,10,318},{146,10,103},{5,11,466
-},{11,11,571},{12,11,198},{13,11,283},{14,11,186},{15,11,21},{143,11,103},{134,0
-,1001},{4,11,185},{5,11,257},{5,11,839},{5,11,936},{7,11,171},{9,11,399},{10,11,
-258},{10,11,395},{10,11,734},{11,11,1014},{12,11,23},{13,11,350},{14,11,150},{
-147,11,6},{143,0,35},{132,0,831},{5,10,835},{134,10,483},{4,0,277},{5,0,608},{6,
-0,493},{7,0,457},{12,0,384},{7,11,404},{7,11,1377},{7,11,1430},{7,11,2017},{8,11
-,149},{8,11,239},{8,11,512},{8,11,793},{8,11,818},{9,11,474},{9,11,595},{10,11,
-122},{10,11,565},{10,11,649},{10,11,783},{11,11,239},{11,11,295},{11,11,447},{11
-,11,528},{11,11,639},{11,11,800},{11,11,936},{12,11,25},{12,11,73},{12,11,77},{
-12,11,157},{12,11,316},{12,11,390},{12,11,391},{12,11,394},{12,11,395},{12,11,
-478},{12,11,503},{12,11,592},{12,11,680},{13,11,50},{13,11,53},{13,11,132},{13,
-11,198},{13,11,275},{13,11,322},{13,11,415},{14,11,71},{14,11,257},{14,11,395},{
-15,11,71},{15,11,136},{17,11,123},{18,11,93},{147,11,58},{134,0,1351},{7,0,27},{
-135,0,316},{136,11,712},{136,0,984},{133,0,552},{137,0,264},{132,0,401},{6,0,710
-},{6,0,1111},{134,0,1343},{134,0,1211},{9,0,543},{10,0,524},{11,0,108},{11,0,653
-},{12,0,524},{13,0,123},{14,0,252},{16,0,18},{19,0,38},{20,0,26},{20,0,65},{21,0
-,3},{151,0,11},{4,0,205},{5,0,623},{7,0,104},{8,0,519},{137,0,716},{132,10,677},
-{4,11,377},{152,11,13},{135,11,1673},{7,0,579},{9,0,41},{9,0,244},{9,0,669},{10,
-0,5},{11,0,861},{11,0,951},{139,0,980},{132,0,717},{136,0,1011},{132,0,805},{4,
-11,180},{135,11,1906},{132,10,777},{132,10,331},{132,0,489},{6,0,1024},{4,11,491
-},{133,10,747},{135,11,1182},{4,11,171},{138,11,234},{4,11,586},{7,11,1186},{138
-,11,631},{135,0,892},{135,11,336},{9,11,931},{10,11,334},{148,11,71},{137,0,473}
-,{6,0,864},{12,0,659},{139,11,926},{7,0,819},{9,0,26},{9,0,392},{10,0,152},{10,0
-,226},{11,0,19},{12,0,276},{12,0,426},{12,0,589},{13,0,460},{15,0,97},{19,0,48},
-{148,0,104},{135,0,51},{133,10,326},{4,10,691},{146,10,16},{9,0,130},{11,0,765},
-{10,10,680},{10,10,793},{141,10,357},{133,11,765},{8,0,229},{6,10,32},{7,10,385}
-,{7,10,757},{7,10,1916},{8,10,94},{8,10,711},{9,10,541},{10,10,162},{10,10,795},
-{11,10,989},{11,10,1010},{12,10,14},{142,10,308},{7,11,474},{137,11,578},{132,0,
-674},{132,0,770},{5,0,79},{7,0,1027},{7,0,1477},{139,0,52},{133,11,424},{134,0,
-1666},{6,0,409},{6,10,349},{6,10,1682},{7,10,1252},{8,10,112},{8,11,714},{9,10,
-435},{9,10,668},{10,10,290},{10,10,319},{10,10,815},{11,10,180},{11,10,837},{12,
-10,240},{13,10,152},{13,10,219},{142,10,158},{5,0,789},{134,0,195},{4,0,251},{4,
-0,688},{7,0,513},{135,0,1284},{132,10,581},{9,11,420},{10,11,269},{10,11,285},{
-10,11,576},{11,11,397},{13,11,175},{145,11,90},{6,10,126},{7,10,573},{8,10,397},
-{142,10,44},{132,11,429},{133,0,889},{4,0,160},{5,0,330},{7,0,1434},{136,0,174},
-{7,11,18},{7,11,699},{7,11,1966},{8,11,752},{9,11,273},{9,11,412},{9,11,703},{10
-,11,71},{10,11,427},{10,11,508},{146,11,97},{6,0,872},{134,0,899},{133,10,926},{
-134,0,1126},{134,0,918},{4,11,53},{5,11,186},{135,11,752},{7,0,268},{136,0,569},
-{134,0,1224},{6,0,1361},{7,10,1232},{137,10,531},{8,11,575},{10,11,289},{139,11,
-319},{133,10,670},{132,11,675},{133,0,374},{135,10,1957},{133,0,731},{11,0,190},
-{15,0,49},{11,11,190},{143,11,49},{4,0,626},{5,0,506},{5,0,642},{6,0,425},{10,0,
-202},{139,0,141},{137,0,444},{7,10,242},{135,10,1942},{6,11,209},{8,11,468},{9,
-11,210},{11,11,36},{12,11,28},{12,11,630},{13,11,21},{13,11,349},{14,11,7},{145,
-11,13},{4,11,342},{135,11,1179},{5,10,834},{7,10,1202},{8,10,14},{9,10,481},{137
-,10,880},{4,11,928},{133,11,910},{4,11,318},{4,11,496},{7,11,856},{139,11,654},{
-136,0,835},{7,0,1526},{138,10,465},{151,0,17},{135,0,477},{4,10,357},{6,10,172},
-{7,10,143},{137,10,413},{6,0,1374},{138,0,994},{18,0,76},{132,10,590},{7,0,287},
-{8,0,355},{9,0,293},{137,0,743},{134,0,1389},{7,11,915},{8,11,247},{147,11,0},{4
-,11,202},{5,11,382},{6,11,454},{7,11,936},{7,11,1803},{8,11,758},{9,11,375},{9,
-11,895},{10,11,743},{10,11,792},{11,11,978},{11,11,1012},{142,11,109},{5,0,384},
-{8,0,455},{140,0,48},{132,11,390},{5,10,169},{7,10,333},{136,10,45},{5,0,264},{
-134,0,184},{138,11,791},{133,11,717},{132,10,198},{6,11,445},{7,11,332},{137,11,
-909},{136,0,1001},{4,10,24},{5,10,140},{5,10,185},{7,10,1500},{11,10,565},{139,
-10,838},{134,11,578},{5,0,633},{6,0,28},{135,0,1323},{132,0,851},{136,11,267},{7
-,0,359},{8,0,243},{140,0,175},{4,10,334},{133,10,593},{141,11,87},{136,11,766},{
-10,0,287},{12,0,138},{10,11,287},{140,11,138},{4,0,105},{132,0,740},{140,10,116}
-,{134,0,857},{135,11,1841},{6,0,1402},{137,0,819},{132,11,584},{132,10,709},{133
-,10,897},{5,0,224},{13,0,174},{146,0,52},{135,10,1840},{4,10,608},{133,10,497},{
-139,11,60},{4,0,758},{135,0,1649},{4,11,226},{4,11,326},{135,11,1770},{5,11,426}
-,{8,11,30},{9,11,2},{11,11,549},{147,11,122},{135,10,2039},{6,10,540},{136,10,
-136},{4,0,573},{8,0,655},{4,10,897},{133,10,786},{7,0,351},{139,0,128},{133,10,
-999},{4,10,299},{135,10,1004},{133,0,918},{132,11,345},{4,11,385},{7,11,265},{
-135,11,587},{133,10,456},{136,10,180},{6,0,687},{134,0,1537},{4,11,347},{5,11,
-423},{5,11,996},{135,11,1329},{132,10,755},{7,11,1259},{9,11,125},{11,11,65},{
-140,11,285},{5,11,136},{6,11,136},{136,11,644},{134,0,1525},{4,0,1009},{135,0,
-1139},{139,10,338},{132,0,340},{135,10,1464},{8,0,847},{10,0,861},{10,0,876},{10
-,0,889},{10,0,922},{10,0,929},{10,0,933},{12,0,784},{140,0,791},{139,0,176},{9,
-11,134},{10,11,2},{10,11,27},{10,11,333},{11,11,722},{143,11,1},{4,11,433},{133,
-11,719},{5,0,985},{7,0,509},{7,0,529},{145,0,96},{132,0,615},{4,10,890},{5,10,
-805},{5,10,819},{5,10,961},{6,10,396},{6,10,1631},{6,10,1678},{7,10,1967},{7,10,
-2041},{9,10,630},{11,10,8},{11,10,1019},{12,10,176},{13,10,225},{14,10,292},{149
-,10,24},{135,0,1919},{134,0,1131},{144,11,21},{144,11,51},{135,10,1815},{4,0,247
-},{7,10,1505},{10,10,190},{10,10,634},{11,10,792},{12,10,358},{140,10,447},{5,10
-,0},{6,10,536},{7,10,604},{13,10,445},{145,10,126},{4,0,184},{5,0,390},{6,0,337}
-,{7,0,23},{7,0,494},{7,0,618},{7,0,1456},{8,0,27},{8,0,599},{10,0,153},{139,0,
-710},{6,10,232},{6,10,412},{7,10,1074},{8,10,9},{8,10,157},{8,10,786},{9,10,196}
-,{9,10,352},{9,10,457},{10,10,337},{11,10,232},{11,10,877},{12,10,480},{140,10,
-546},{13,0,38},{135,10,958},{4,10,382},{136,10,579},{4,10,212},{135,10,1206},{4,
-11,555},{8,11,536},{138,11,288},{11,11,139},{139,11,171},{9,11,370},{138,11,90},
-{132,0,1015},{134,0,1088},{5,10,655},{135,11,977},{134,0,1585},{17,10,67},{147,
-10,74},{10,0,227},{11,0,497},{11,0,709},{140,0,415},{6,0,360},{7,0,1664},{136,0,
-478},{7,0,95},{6,10,231},{136,10,423},{140,11,65},{4,11,257},{135,11,2031},{135,
-11,1768},{133,10,300},{139,11,211},{136,0,699},{6,10,237},{7,10,611},{8,10,100},
-{9,10,416},{11,10,335},{12,10,173},{146,10,101},{14,0,26},{146,0,150},{6,0,581},
-{135,0,1119},{135,10,1208},{132,0,739},{6,11,83},{6,11,1733},{135,11,1389},{137,
-0,869},{4,0,67},{5,0,422},{7,0,1037},{7,0,1289},{7,0,1555},{9,0,741},{145,0,108}
-,{133,10,199},{12,10,427},{146,10,38},{136,0,464},{142,0,42},{10,0,96},{8,11,501
-},{137,11,696},{134,11,592},{4,0,512},{4,0,966},{5,0,342},{6,0,1855},{8,0,869},{
-8,0,875},{8,0,901},{144,0,26},{8,0,203},{11,0,823},{11,0,846},{12,0,482},{13,0,
-277},{13,0,302},{13,0,464},{14,0,205},{142,0,221},{4,0,449},{133,0,718},{7,11,
-1718},{9,11,95},{9,11,274},{10,11,279},{10,11,317},{10,11,420},{11,11,303},{11,
-11,808},{12,11,134},{12,11,367},{13,11,149},{13,11,347},{14,11,349},{14,11,406},
-{18,11,22},{18,11,89},{18,11,122},{147,11,47},{133,11,26},{4,0,355},{6,0,311},{9
-,0,256},{138,0,404},{132,11,550},{10,0,758},{6,10,312},{6,10,1715},{10,10,584},{
-11,10,546},{11,10,692},{12,10,259},{12,10,295},{13,10,46},{141,10,154},{136,11,
-822},{5,0,827},{4,11,902},{5,11,809},{6,11,122},{135,11,896},{5,0,64},{140,0,581
-},{4,0,442},{6,0,739},{7,0,1047},{7,0,1352},{7,0,1643},{7,11,1911},{9,11,449},{
-10,11,192},{138,11,740},{135,11,262},{132,10,588},{133,11,620},{5,0,977},{6,0,
-288},{7,0,528},{4,11,34},{5,11,574},{7,11,279},{7,11,1624},{136,11,601},{6,0,
-1375},{4,10,231},{5,10,61},{6,10,104},{7,10,729},{7,10,964},{7,10,1658},{140,10,
-414},{6,10,263},{138,10,757},{132,10,320},{4,0,254},{7,0,1309},{5,11,332},{135,
-11,1309},{6,11,261},{8,11,182},{139,11,943},{132,10,225},{6,0,12},{135,0,1219},{
-4,0,275},{12,0,376},{6,11,1721},{141,11,490},{4,11,933},{133,11,880},{6,0,951},{
-6,0,1109},{6,0,1181},{7,0,154},{4,10,405},{7,10,817},{14,10,58},{17,10,37},{146,
-10,124},{6,0,1520},{133,10,974},{134,0,1753},{6,0,369},{6,0,502},{7,0,1036},{8,0
-,348},{9,0,452},{10,0,26},{11,0,224},{11,0,387},{11,0,772},{12,0,95},{12,0,629},
-{13,0,195},{13,0,207},{13,0,241},{14,0,260},{14,0,270},{143,0,140},{132,0,269},{
-5,0,480},{7,0,532},{7,0,1197},{7,0,1358},{8,0,291},{11,0,349},{142,0,396},{5,10,
-235},{7,10,1239},{11,10,131},{140,10,370},{7,10,956},{7,10,1157},{7,10,1506},{7,
-10,1606},{7,10,1615},{7,10,1619},{7,10,1736},{7,10,1775},{8,10,590},{9,10,324},{
-9,10,736},{9,10,774},{9,10,776},{9,10,784},{10,10,567},{10,10,708},{11,10,518},{
-11,10,613},{11,10,695},{11,10,716},{11,10,739},{11,10,770},{11,10,771},{11,10,
-848},{11,10,857},{11,10,931},{11,10,947},{12,10,326},{12,10,387},{12,10,484},{12
-,10,528},{12,10,552},{12,10,613},{13,10,189},{13,10,256},{13,10,340},{13,10,432}
-,{13,10,436},{13,10,440},{13,10,454},{14,10,174},{14,10,220},{14,10,284},{14,10,
-390},{145,10,121},{8,11,598},{9,11,664},{138,11,441},{9,10,137},{138,10,221},{
-133,11,812},{148,0,15},{134,0,1341},{6,0,1017},{4,11,137},{7,11,1178},{135,11,
-1520},{7,10,390},{138,10,140},{7,11,1260},{135,11,1790},{137,11,191},{135,10,
-1144},{6,0,1810},{7,0,657},{8,0,886},{10,0,857},{14,0,440},{144,0,96},{8,0,533},
-{6,11,1661},{7,11,1975},{7,11,2009},{135,11,2011},{6,0,1453},{134,10,464},{132,
-11,715},{5,10,407},{11,10,204},{11,10,243},{11,10,489},{12,10,293},{19,10,37},{
-20,10,73},{150,10,38},{133,11,703},{4,0,211},{7,0,1483},{5,10,325},{8,10,5},{8,
-10,227},{9,10,105},{10,10,585},{140,10,614},{4,0,332},{5,0,335},{6,0,238},{7,0,
-269},{7,0,811},{7,0,1797},{8,0,836},{9,0,507},{141,0,242},{5,11,89},{7,11,1915},
-{9,11,185},{9,11,235},{9,11,496},{10,11,64},{10,11,270},{10,11,403},{10,11,469},
-{10,11,529},{10,11,590},{11,11,140},{11,11,860},{13,11,1},{13,11,422},{14,11,341
-},{14,11,364},{17,11,93},{18,11,113},{19,11,97},{147,11,113},{133,11,695},{16,0,
-19},{5,11,6},{6,11,183},{6,10,621},{7,11,680},{7,11,978},{7,11,1013},{7,11,1055}
-,{12,11,230},{13,11,172},{13,10,504},{146,11,29},{136,0,156},{133,0,1009},{6,11,
-29},{139,11,63},{134,0,820},{134,10,218},{7,10,454},{7,10,782},{8,10,768},{140,
-10,686},{5,0,228},{6,0,203},{7,0,156},{8,0,347},{9,0,265},{18,0,39},{20,0,54},{
-21,0,31},{22,0,3},{23,0,0},{15,11,8},{18,11,39},{20,11,54},{21,11,31},{22,11,3},
-{151,11,0},{7,0,1131},{135,0,1468},{144,10,0},{134,0,1276},{10,10,676},{140,10,
-462},{132,11,311},{134,11,1740},{7,11,170},{8,11,90},{8,11,177},{8,11,415},{11,
-11,714},{142,11,281},{134,10,164},{6,0,1792},{138,0,849},{150,10,50},{5,0,291},{
-5,0,318},{7,0,765},{9,0,389},{12,0,548},{8,11,522},{142,11,328},{11,11,91},{13,
-11,129},{15,11,101},{145,11,125},{4,11,494},{6,11,74},{7,11,44},{7,11,407},{8,11
-,551},{12,11,17},{15,11,5},{148,11,11},{4,11,276},{133,11,296},{6,10,343},{7,10,
-195},{7,11,1777},{9,10,226},{10,10,197},{10,10,575},{11,10,502},{139,10,899},{10
-,0,525},{139,0,82},{14,0,453},{4,11,7},{5,11,90},{5,11,158},{6,11,542},{7,11,221
-},{7,11,1574},{9,11,490},{10,11,540},{11,11,443},{139,11,757},{135,0,666},{22,10
-,29},{150,11,29},{4,0,422},{147,10,8},{5,0,355},{145,0,0},{6,0,1873},{9,0,918},{
-7,11,588},{9,11,175},{138,11,530},{143,11,31},{11,0,165},{7,10,1125},{9,10,143},
-{14,10,405},{150,10,21},{9,0,260},{137,0,905},{5,11,872},{6,11,57},{6,11,479},{6
-,11,562},{7,11,471},{7,11,1060},{9,11,447},{9,11,454},{141,11,6},{138,11,704},{
-133,0,865},{5,0,914},{134,0,1625},{133,0,234},{7,0,1383},{5,11,31},{6,11,614},{
-145,11,61},{7,11,1200},{138,11,460},{6,11,424},{135,11,1866},{136,0,306},{5,10,
-959},{12,11,30},{13,11,148},{14,11,87},{14,11,182},{16,11,42},{18,11,92},{148,11
-,70},{6,0,1919},{6,0,1921},{9,0,923},{9,0,930},{9,0,941},{9,0,949},{9,0,987},{9,
-0,988},{9,0,992},{12,0,802},{12,0,815},{12,0,856},{12,0,885},{12,0,893},{12,0,
-898},{12,0,919},{12,0,920},{12,0,941},{12,0,947},{15,0,183},{15,0,185},{15,0,189
-},{15,0,197},{15,0,202},{15,0,233},{18,0,218},{18,0,219},{18,0,233},{143,11,156}
-,{135,10,1759},{136,10,173},{13,0,163},{13,0,180},{18,0,78},{20,0,35},{5,11,13},
-{134,11,142},{134,10,266},{6,11,97},{7,11,116},{8,11,322},{8,11,755},{9,11,548},
-{10,11,714},{11,11,884},{141,11,324},{135,0,1312},{9,0,814},{137,11,676},{133,0,
-707},{135,0,1493},{6,0,421},{7,0,61},{7,0,1540},{10,0,11},{138,0,501},{12,0,733}
-,{12,0,766},{7,11,866},{135,11,1163},{137,0,341},{142,0,98},{145,11,115},{135,11
-,1111},{136,10,300},{136,0,1014},{8,11,1},{9,11,112},{138,11,326},{132,11,730},{
-5,11,488},{6,11,527},{7,11,489},{7,11,1636},{8,11,121},{8,11,144},{8,11,359},{9,
-11,193},{9,11,241},{9,11,336},{9,11,882},{11,11,266},{11,11,372},{11,11,944},{12
-,11,401},{140,11,641},{6,0,971},{134,0,1121},{6,0,102},{7,0,72},{15,0,142},{147,
-0,67},{151,0,30},{135,0,823},{134,0,1045},{5,10,427},{5,10,734},{7,10,478},{136,
-10,52},{7,0,1930},{11,10,217},{142,10,165},{6,0,1512},{135,0,1870},{9,11,31},{10
-,11,244},{10,11,699},{12,11,149},{141,11,497},{133,11,377},{145,11,101},{10,11,
-158},{13,11,13},{13,11,137},{13,11,258},{14,11,111},{14,11,225},{14,11,253},{14,
-11,304},{14,11,339},{14,11,417},{146,11,33},{6,0,87},{6,10,1734},{7,10,20},{7,10
-,1056},{8,10,732},{9,10,406},{9,10,911},{138,10,694},{134,0,1243},{137,0,245},{7
-,0,68},{8,0,48},{8,0,88},{8,0,582},{8,0,681},{9,0,373},{9,0,864},{11,0,157},{11,
-0,336},{11,0,843},{148,0,27},{8,11,663},{144,11,8},{133,10,613},{4,0,88},{5,0,
-137},{5,0,174},{5,0,777},{6,0,1664},{6,0,1725},{7,0,77},{7,0,426},{7,0,1317},{7,
-0,1355},{8,0,126},{8,0,563},{9,0,523},{9,0,750},{10,0,310},{10,0,836},{11,0,42},
-{11,0,318},{11,0,731},{12,0,68},{12,0,92},{12,0,507},{12,0,692},{13,0,81},{13,0,
-238},{13,0,374},{14,0,436},{18,0,138},{19,0,78},{19,0,111},{20,0,55},{20,0,77},{
-148,0,92},{141,0,418},{4,0,938},{137,0,625},{138,0,351},{5,11,843},{7,10,32},{7,
-10,984},{8,10,85},{8,10,709},{9,10,579},{9,10,847},{9,10,856},{10,10,799},{11,10
-,258},{11,10,1007},{12,10,331},{12,10,615},{13,10,188},{13,10,435},{14,10,8},{15
-,10,165},{16,10,27},{148,10,40},{6,0,1668},{7,0,1499},{8,0,117},{9,0,314},{138,0
-,174},{135,0,707},{132,11,554},{133,11,536},{5,0,403},{5,11,207},{9,11,79},{11,
-11,625},{145,11,7},{132,11,424},{136,11,785},{4,10,167},{135,10,82},{9,0,7},{23,
-0,6},{9,11,7},{151,11,6},{6,0,282},{5,10,62},{6,10,534},{7,10,74},{7,10,678},{7,
-10,684},{7,10,1043},{7,10,1072},{8,10,280},{8,10,541},{8,10,686},{9,10,258},{10,
-10,519},{11,10,252},{140,10,282},{138,10,33},{132,10,359},{4,0,44},{5,0,311},{6,
-0,156},{7,0,639},{7,0,762},{7,0,1827},{9,0,8},{9,0,462},{148,0,83},{7,11,769},{9
-,11,18},{138,11,358},{4,0,346},{7,0,115},{9,0,180},{9,0,456},{10,0,363},{4,11,
-896},{134,11,1777},{133,10,211},{7,0,761},{7,0,1051},{137,0,545},{6,10,145},{141
-,10,336},{7,11,750},{9,11,223},{11,11,27},{11,11,466},{12,11,624},{14,11,265},{
-146,11,61},{6,0,752},{6,0,768},{6,0,1195},{6,0,1254},{6,0,1619},{137,0,835},{6,0
-,1936},{8,0,930},{136,0,960},{132,10,263},{132,11,249},{12,0,653},{132,10,916},{
-4,11,603},{133,11,661},{8,0,344},{4,11,11},{6,11,128},{7,11,231},{7,11,1533},{
-138,11,725},{134,0,1483},{134,0,875},{6,0,185},{7,0,1899},{9,0,875},{139,0,673},
-{15,10,155},{144,10,79},{7,0,93},{7,0,210},{7,0,1223},{8,0,451},{8,0,460},{11,0,
-353},{11,0,475},{4,10,599},{6,10,1634},{7,10,67},{7,10,691},{7,10,979},{7,10,
-1697},{8,10,207},{8,10,214},{8,10,231},{8,10,294},{8,10,336},{8,10,428},{8,10,
-471},{8,10,622},{8,10,626},{8,10,679},{8,10,759},{8,10,829},{9,10,11},{9,10,246}
-,{9,10,484},{9,10,573},{9,10,706},{9,10,762},{9,10,798},{9,10,855},{9,10,870},{9
-,10,912},{10,10,303},{10,10,335},{10,10,424},{10,10,461},{10,10,543},{10,10,759}
-,{10,10,814},{11,10,59},{11,10,235},{11,10,590},{11,10,929},{11,10,963},{11,10,
-987},{12,10,114},{12,10,182},{12,10,226},{12,10,332},{12,10,439},{12,10,575},{12
-,10,598},{12,10,675},{13,10,8},{13,10,125},{13,10,194},{13,10,287},{14,10,197},{
-14,10,383},{15,10,53},{17,10,63},{19,10,46},{19,10,98},{19,10,106},{148,10,85},{
-132,11,476},{4,0,327},{5,0,478},{7,0,1332},{136,0,753},{5,0,1020},{133,0,1022},{
-135,11,1807},{4,0,103},{133,0,401},{4,0,499},{135,0,1421},{10,0,207},{13,0,164},
-{147,10,126},{9,11,20},{10,11,324},{139,11,488},{132,0,96},{9,11,280},{138,11,
-134},{135,0,968},{133,10,187},{135,10,1286},{5,11,112},{6,11,103},{134,11,150},{
-8,0,914},{10,0,3},{4,10,215},{9,10,38},{11,10,23},{11,10,127},{139,10,796},{135,
-0,399},{6,0,563},{137,0,224},{6,0,704},{134,0,1214},{4,11,708},{8,11,15},{9,11,
-50},{9,11,386},{11,11,18},{11,11,529},{140,11,228},{4,11,563},{7,11,109},{7,11,
-592},{7,11,637},{7,11,770},{7,11,1701},{8,11,436},{8,11,463},{9,11,60},{9,11,335
-},{9,11,904},{10,11,73},{11,11,434},{12,11,585},{13,11,331},{18,11,110},{148,11,
-60},{134,0,1559},{132,11,502},{6,11,347},{138,11,161},{4,11,33},{5,11,102},{5,11
-,500},{6,11,284},{7,11,1079},{7,11,1423},{7,11,1702},{8,11,470},{9,11,554},{9,11
-,723},{139,11,333},{7,11,246},{135,11,840},{6,11,10},{8,11,571},{9,11,739},{143,
-11,91},{8,0,861},{10,0,905},{12,0,730},{12,0,789},{133,11,626},{134,0,946},{5,0,
-746},{12,0,333},{14,0,332},{12,11,333},{142,11,332},{5,11,18},{6,11,526},{13,11,
-24},{13,11,110},{19,11,5},{147,11,44},{4,0,910},{5,0,832},{135,10,2002},{10,11,
-768},{139,11,787},{4,11,309},{5,11,462},{7,11,970},{135,11,1097},{4,10,28},{5,10
-,440},{7,10,248},{11,10,833},{140,10,344},{134,10,1654},{6,0,632},{6,0,652},{6,0
-,1272},{6,0,1384},{134,0,1560},{134,11,1704},{6,0,1393},{133,10,853},{6,10,249},
-{7,10,1234},{139,10,573},{5,11,86},{7,11,743},{9,11,85},{10,11,281},{10,11,432},
-{11,11,490},{12,11,251},{13,11,118},{14,11,378},{146,11,143},{5,11,524},{133,11,
-744},{134,0,1514},{10,0,201},{142,0,319},{7,0,717},{10,0,510},{7,10,392},{8,10,
-20},{8,10,172},{8,10,690},{9,10,383},{9,10,845},{11,10,293},{11,10,832},{11,10,
-920},{11,10,984},{141,10,221},{134,0,1381},{5,10,858},{133,10,992},{8,0,528},{
-137,0,348},{10,11,107},{140,11,436},{4,0,20},{133,0,616},{134,0,1251},{132,11,
-927},{10,11,123},{12,11,670},{13,11,371},{14,11,142},{146,11,94},{134,0,1163},{7
-,11,1149},{137,11,156},{134,0,307},{133,11,778},{7,0,1091},{135,0,1765},{5,11,
-502},{6,10,268},{137,10,62},{8,11,196},{10,11,283},{139,11,406},{4,0,26},{5,0,
-429},{6,0,245},{7,0,704},{7,0,1379},{135,0,1474},{133,11,855},{132,0,881},{4,0,
-621},{135,11,1596},{7,11,1400},{9,11,446},{138,11,45},{6,0,736},{138,10,106},{
-133,0,542},{134,0,348},{133,0,868},{136,0,433},{135,0,1495},{138,0,771},{6,10,
-613},{136,10,223},{138,0,215},{141,0,124},{136,11,391},{135,11,172},{132,10,670}
-,{140,0,55},{9,10,40},{139,10,136},{7,0,62},{147,0,112},{132,0,856},{132,11,568}
-,{12,0,270},{139,10,259},{8,0,572},{137,0,698},{4,11,732},{9,10,310},{137,10,682
-},{142,10,296},{134,0,939},{136,11,733},{135,11,1435},{7,10,1401},{135,10,1476},
-{6,0,352},{4,10,296},{7,10,401},{7,10,1410},{7,10,1594},{7,10,1674},{8,10,63},{8
-,10,660},{137,10,74},{4,11,428},{133,11,668},{4,10,139},{4,10,388},{140,10,188},
-{7,11,2015},{140,11,665},{132,0,647},{146,0,10},{138,0,220},{142,0,464},{132,0,
-109},{134,0,1746},{6,0,515},{4,10,747},{6,11,1623},{6,11,1681},{7,10,649},{7,10,
-1479},{135,10,1583},{133,10,232},{135,0,566},{137,10,887},{4,0,40},{10,0,67},{11
-,0,117},{11,0,768},{139,0,935},{132,0,801},{7,0,992},{8,0,301},{9,0,722},{12,0,
-63},{13,0,29},{14,0,161},{143,0,18},{139,0,923},{6,11,1748},{8,11,715},{9,11,802
-},{10,11,46},{10,11,819},{13,11,308},{14,11,351},{14,11,363},{146,11,67},{137,11
-,745},{7,0,1145},{4,10,14},{7,10,1801},{10,10,748},{141,10,458},{4,11,63},{5,11,
-347},{134,11,474},{135,0,568},{4,10,425},{7,11,577},{7,11,1432},{9,11,475},{9,11
-,505},{9,11,526},{9,11,609},{9,11,689},{9,11,726},{9,11,735},{9,11,738},{10,11,
-556},{10,11,674},{10,11,684},{11,11,89},{11,11,202},{11,11,272},{11,11,380},{11,
-11,415},{11,11,505},{11,11,537},{11,11,550},{11,11,562},{11,11,640},{11,11,667},
-{11,11,688},{11,11,847},{11,11,927},{11,11,930},{11,11,940},{12,11,144},{12,11,
-325},{12,11,329},{12,11,389},{12,11,403},{12,11,451},{12,11,515},{12,11,604},{12
-,11,616},{12,11,626},{13,11,66},{13,11,131},{13,11,167},{13,11,236},{13,11,368},
-{13,11,411},{13,11,434},{13,11,453},{13,11,461},{13,11,474},{14,11,59},{14,11,60
-},{14,11,139},{14,11,152},{14,11,276},{14,11,353},{14,11,402},{15,11,28},{15,11,
-81},{15,11,123},{15,11,152},{18,11,136},{148,11,88},{137,0,247},{135,11,1622},{9
-,11,544},{11,11,413},{144,11,25},{4,0,645},{7,0,825},{6,10,1768},{135,11,89},{
-140,0,328},{5,10,943},{134,10,1779},{134,0,1363},{5,10,245},{6,10,576},{7,10,582
-},{136,10,225},{134,0,1280},{5,11,824},{133,11,941},{7,11,440},{8,11,230},{139,
-11,106},{5,0,28},{6,0,204},{10,0,320},{10,0,583},{13,0,502},{14,0,72},{14,0,274}
-,{14,0,312},{14,0,344},{15,0,159},{16,0,62},{16,0,69},{17,0,30},{18,0,42},{18,0,
-53},{18,0,84},{18,0,140},{19,0,68},{19,0,85},{20,0,5},{20,0,45},{20,0,101},{22,0
-,7},{150,0,20},{4,0,558},{6,0,390},{7,0,162},{7,0,689},{9,0,360},{138,0,653},{
-134,0,764},{6,0,862},{137,0,833},{5,0,856},{6,0,1672},{6,0,1757},{134,0,1781},{5
-,0,92},{10,0,736},{140,0,102},{6,0,1927},{6,0,1944},{8,0,924},{8,0,948},{10,0,
-967},{138,0,978},{134,0,1479},{5,0,590},{8,0,360},{9,0,213},{138,0,63},{134,0,
-1521},{6,0,709},{134,0,891},{132,10,443},{13,0,477},{14,0,120},{148,0,61},{4,11,
-914},{5,11,800},{133,11,852},{10,11,54},{141,11,115},{4,11,918},{133,11,876},{
-139,11,152},{4,11,92},{133,11,274},{135,11,1901},{9,11,800},{10,11,693},{11,11,
-482},{11,11,734},{139,11,789},{9,0,483},{132,10,298},{6,0,1213},{141,11,498},{
-135,11,1451},{133,11,743},{4,0,1022},{10,0,1000},{12,0,957},{12,0,980},{12,0,
-1013},{14,0,481},{144,0,116},{8,0,503},{17,0,29},{4,11,49},{7,11,280},{135,11,
-1633},{135,0,1712},{134,0,466},{136,11,47},{5,10,164},{7,10,121},{142,10,189},{7
-,10,812},{7,10,1261},{7,10,1360},{9,10,632},{140,10,352},{139,10,556},{132,0,731
-},{5,11,272},{5,11,908},{5,11,942},{7,11,1008},{7,11,1560},{8,11,197},{9,11,47},
-{11,11,538},{139,11,742},{4,10,172},{9,10,611},{10,10,436},{12,10,673},{141,10,
-255},{133,10,844},{10,0,484},{11,0,754},{12,0,457},{14,0,171},{14,0,389},{146,0,
-153},{9,10,263},{10,10,147},{138,10,492},{137,11,891},{138,0,241},{133,10,537},{
-6,0,2005},{136,0,964},{137,10,842},{151,11,8},{4,11,407},{132,11,560},{135,11,
-1884},{6,0,1100},{134,0,1242},{135,0,954},{5,10,230},{5,10,392},{6,10,420},{9,10
-,568},{140,10,612},{4,11,475},{11,11,35},{11,11,90},{13,11,7},{13,11,71},{13,11,
-177},{142,11,422},{136,11,332},{135,0,1958},{6,0,549},{8,0,34},{8,0,283},{9,0,
-165},{138,0,475},{10,0,952},{12,0,966},{140,0,994},{5,0,652},{5,0,701},{135,0,
-449},{4,0,655},{7,0,850},{17,0,75},{146,0,137},{4,0,146},{7,0,1618},{8,0,670},{5
-,10,41},{7,10,1459},{7,10,1469},{7,10,1859},{9,10,549},{139,10,905},{133,10,696}
-,{6,0,159},{6,0,364},{7,0,516},{137,0,518},{135,0,1439},{6,11,222},{7,11,636},{7
-,11,1620},{8,11,409},{9,11,693},{139,11,77},{13,0,151},{141,11,45},{6,0,1027},{4
-,11,336},{132,10,771},{139,11,392},{10,11,121},{11,11,175},{149,11,16},{8,0,950}
-,{138,0,983},{133,10,921},{135,0,993},{6,10,180},{7,10,1137},{8,10,751},{139,10,
-805},{7,0,501},{9,0,111},{10,0,141},{11,0,332},{13,0,43},{13,0,429},{14,0,130},{
-14,0,415},{145,0,102},{4,10,183},{5,11,882},{7,10,271},{11,10,824},{11,10,952},{
-13,10,278},{13,10,339},{13,10,482},{14,10,424},{148,10,99},{4,10,19},{5,10,477},
-{5,10,596},{6,10,505},{7,10,1221},{11,10,907},{12,10,209},{141,10,214},{135,10,
-1215},{133,0,452},{132,11,426},{5,0,149},{136,0,233},{133,0,935},{6,11,58},{7,11
-,654},{7,11,745},{7,11,1969},{8,11,240},{8,11,675},{9,11,479},{9,11,731},{10,11,
-330},{10,11,593},{10,11,817},{11,11,32},{11,11,133},{11,11,221},{145,11,68},{12,
-0,582},{18,0,131},{7,11,102},{137,11,538},{136,0,801},{134,10,1645},{132,0,70},{
-6,10,92},{6,10,188},{7,10,1269},{7,10,1524},{7,10,1876},{10,10,228},{139,10,1020
-},{4,10,459},{133,10,966},{138,0,369},{16,0,36},{140,10,330},{141,11,366},{7,0,
-721},{10,0,236},{12,0,204},{6,10,18},{7,10,932},{8,10,757},{9,10,54},{9,10,65},{
-9,10,844},{10,10,113},{10,10,315},{10,10,798},{11,10,153},{12,10,151},{12,10,392
-},{12,10,666},{142,10,248},{7,0,241},{10,0,430},{8,10,548},{9,10,532},{10,10,117
-},{11,10,351},{11,10,375},{143,10,23},{134,10,1742},{133,10,965},{133,11,566},{6
-,11,48},{135,11,63},{134,10,182},{10,10,65},{10,10,488},{138,10,497},{6,11,114},
-{7,11,1224},{7,11,1556},{136,11,3},{134,0,1817},{8,11,576},{137,11,267},{6,0,
-1078},{144,0,16},{9,10,588},{138,10,260},{138,0,1021},{5,0,406},{134,0,2022},{
-133,11,933},{6,0,69},{135,0,117},{7,0,1830},{136,11,427},{4,0,432},{135,0,824},{
-134,10,1786},{133,0,826},{139,11,67},{133,11,759},{135,10,308},{137,0,816},{133,
-0,1000},{4,0,297},{6,0,529},{7,0,152},{7,0,713},{7,0,1845},{8,0,710},{8,0,717},{
-12,0,639},{140,0,685},{7,0,423},{136,10,588},{136,10,287},{136,0,510},{134,0,
-1048},{6,0,618},{7,11,56},{7,11,1989},{8,11,337},{8,11,738},{9,11,600},{10,11,
-483},{12,11,37},{13,11,447},{142,11,92},{4,0,520},{135,0,575},{8,0,990},{138,0,
-977},{135,11,774},{9,11,347},{11,11,24},{140,11,170},{136,11,379},{140,10,290},{
-132,11,328},{4,0,321},{134,0,569},{4,11,101},{135,11,1171},{7,0,723},{7,0,1135},
-{5,11,833},{136,11,744},{7,10,719},{8,10,809},{136,10,834},{8,0,921},{136,10,796
-},{5,10,210},{6,10,213},{7,10,60},{10,10,364},{139,10,135},{5,0,397},{6,0,154},{
-7,0,676},{8,0,443},{8,0,609},{9,0,24},{9,0,325},{10,0,35},{11,0,535},{11,0,672},
-{11,0,1018},{12,0,637},{16,0,30},{5,10,607},{8,10,326},{136,10,490},{4,10,701},{
-5,10,472},{6,11,9},{6,11,397},{7,11,53},{7,11,1742},{9,10,758},{10,11,632},{11,
-11,828},{140,11,146},{135,10,380},{135,10,1947},{148,11,109},{10,10,278},{138,11
-,278},{134,0,856},{7,0,139},{4,10,386},{8,10,405},{8,10,728},{9,10,497},{11,10,
-110},{11,10,360},{15,10,37},{144,10,84},{141,0,282},{133,0,981},{5,0,288},{7,10,
-1452},{7,10,1480},{8,10,634},{140,10,472},{7,0,1890},{8,11,367},{10,11,760},{14,
-11,79},{20,11,17},{152,11,0},{4,10,524},{136,10,810},{4,0,56},{7,0,1791},{8,0,
-607},{8,0,651},{11,0,465},{11,0,835},{12,0,337},{141,0,480},{10,10,238},{141,10,
-33},{11,11,417},{12,11,223},{140,11,265},{9,0,158},{10,0,411},{140,0,261},{133,
-10,532},{133,10,997},{12,11,186},{12,11,292},{14,11,100},{146,11,70},{6,0,1403},
-{136,0,617},{134,0,1205},{139,0,563},{4,0,242},{134,0,333},{4,11,186},{5,11,157}
-,{8,11,168},{138,11,6},{132,0,369},{133,11,875},{5,10,782},{5,10,829},{134,10,
-1738},{134,0,622},{135,11,1272},{6,0,1407},{7,11,111},{136,11,581},{7,10,1823},{
-139,10,693},{7,0,160},{10,0,624},{142,0,279},{132,0,363},{10,11,589},{12,11,111}
-,{13,11,260},{14,11,82},{18,11,63},{147,11,45},{7,11,1364},{7,11,1907},{141,11,
-158},{4,11,404},{4,11,659},{135,11,675},{13,11,211},{14,11,133},{14,11,204},{15,
-11,64},{15,11,69},{15,11,114},{16,11,10},{19,11,23},{19,11,35},{19,11,39},{19,11
-,51},{19,11,71},{19,11,75},{152,11,15},{4,10,78},{5,10,96},{5,10,182},{7,10,1724
-},{7,10,1825},{10,10,394},{10,10,471},{11,10,532},{14,10,340},{145,10,88},{135,
-10,1964},{133,11,391},{11,11,887},{14,11,365},{142,11,375},{5,11,540},{6,11,1697
-},{7,11,222},{136,11,341},{134,11,78},{9,0,601},{9,0,619},{10,0,505},{10,0,732},
-{11,0,355},{140,0,139},{134,0,292},{139,0,174},{5,0,177},{6,0,616},{7,0,827},{9,
-0,525},{138,0,656},{10,0,31},{6,10,215},{7,10,1028},{7,10,1473},{7,10,1721},{9,
-10,424},{138,10,779},{135,10,584},{136,11,293},{134,0,685},{135,11,1868},{133,11
-,460},{7,0,647},{6,10,67},{7,10,1630},{9,10,354},{9,10,675},{10,10,830},{14,10,
-80},{145,10,80},{4,0,161},{133,0,631},{6,10,141},{7,10,225},{9,10,59},{9,10,607}
-,{10,10,312},{11,10,687},{12,10,555},{13,10,373},{13,10,494},{148,10,58},{7,11,
-965},{7,11,1460},{135,11,1604},{136,10,783},{134,11,388},{6,0,722},{6,0,1267},{4
-,11,511},{9,11,333},{9,11,379},{10,11,602},{11,11,441},{11,11,723},{11,11,976},{
-140,11,357},{134,0,1797},{135,0,1684},{9,0,469},{9,0,709},{12,0,512},{14,0,65},{
-17,0,12},{5,11,938},{136,11,707},{7,0,1230},{136,0,531},{10,0,229},{11,0,73},{11
-,0,376},{139,0,433},{12,0,268},{12,0,640},{142,0,119},{7,10,430},{139,10,46},{6,
-0,558},{7,0,651},{8,0,421},{9,0,0},{10,0,34},{139,0,1008},{6,0,106},{7,0,1786},{
-7,0,1821},{9,0,102},{9,0,763},{5,10,602},{7,10,2018},{137,10,418},{5,0,65},{6,0,
-416},{7,0,1720},{7,0,1924},{10,0,109},{11,0,14},{11,0,70},{11,0,569},{11,0,735},
-{15,0,153},{20,0,80},{136,10,677},{135,11,1625},{137,11,772},{136,0,595},{6,11,
-469},{7,11,1709},{138,11,515},{7,0,1832},{138,0,374},{9,0,106},{9,0,163},{9,0,
-296},{10,0,167},{10,0,172},{10,0,777},{139,0,16},{6,0,6},{7,0,81},{7,0,771},{7,0
-,1731},{9,0,405},{138,0,421},{4,11,500},{135,11,938},{5,11,68},{134,11,383},{5,0
-,881},{133,0,885},{6,0,854},{6,0,1132},{6,0,1495},{6,0,1526},{6,0,1533},{134,0,
-1577},{4,11,337},{6,11,353},{7,11,1934},{8,11,488},{137,11,429},{7,11,236},{7,11
-,1795},{8,11,259},{9,11,135},{9,11,177},{10,11,825},{11,11,115},{11,11,370},{11,
-11,405},{11,11,604},{12,11,10},{12,11,667},{12,11,669},{13,11,76},{14,11,310},{
-15,11,76},{15,11,147},{148,11,23},{5,0,142},{134,0,546},{4,11,15},{5,11,22},{6,
-11,244},{7,11,40},{7,11,200},{7,11,906},{7,11,1199},{9,11,616},{10,11,716},{11,
-11,635},{11,11,801},{140,11,458},{5,0,466},{11,0,571},{12,0,198},{13,0,283},{14,
-0,186},{15,0,21},{15,0,103},{135,10,329},{4,0,185},{5,0,257},{5,0,839},{5,0,936}
-,{9,0,399},{10,0,258},{10,0,395},{10,0,734},{11,0,1014},{12,0,23},{13,0,350},{14
-,0,150},{19,0,6},{135,11,1735},{12,11,36},{141,11,337},{5,11,598},{7,11,791},{8,
-11,108},{137,11,123},{132,10,469},{7,0,404},{7,0,1377},{7,0,1430},{7,0,2017},{8,
-0,149},{8,0,239},{8,0,512},{8,0,793},{8,0,818},{9,0,474},{9,0,595},{10,0,122},{
-10,0,565},{10,0,649},{10,0,783},{11,0,239},{11,0,295},{11,0,447},{11,0,528},{11,
-0,639},{11,0,800},{12,0,25},{12,0,77},{12,0,157},{12,0,256},{12,0,316},{12,0,390
-},{12,0,391},{12,0,395},{12,0,478},{12,0,503},{12,0,592},{12,0,680},{13,0,50},{
-13,0,53},{13,0,132},{13,0,198},{13,0,322},{13,0,415},{13,0,511},{14,0,71},{14,0,
-395},{15,0,71},{15,0,136},{17,0,123},{18,0,93},{147,0,58},{136,0,712},{134,10,
-1743},{5,10,929},{6,10,340},{8,10,376},{136,10,807},{6,0,1848},{8,0,860},{10,0,
-856},{10,0,859},{10,0,925},{10,0,941},{140,0,762},{6,0,629},{6,0,906},{9,0,810},
-{140,0,652},{5,10,218},{7,10,1610},{138,10,83},{7,10,1512},{135,10,1794},{4,0,
-377},{24,0,13},{4,11,155},{7,11,1689},{11,10,0},{144,10,78},{4,11,164},{5,11,151
-},{5,11,730},{5,11,741},{7,11,498},{7,11,870},{7,11,1542},{12,11,213},{14,11,36}
-,{14,11,391},{17,11,111},{18,11,6},{18,11,46},{18,11,151},{19,11,36},{20,11,32},
-{20,11,56},{20,11,69},{20,11,102},{21,11,4},{22,11,8},{22,11,10},{22,11,14},{150
-,11,31},{7,0,1842},{133,10,571},{4,10,455},{4,11,624},{135,11,1752},{134,0,1501}
-,{4,11,492},{5,11,451},{6,10,161},{7,10,372},{137,10,597},{132,10,349},{4,0,180}
-,{135,0,1906},{135,11,835},{141,11,70},{132,0,491},{137,10,751},{6,10,432},{139,
-10,322},{4,0,171},{138,0,234},{6,11,113},{135,11,436},{4,0,586},{7,0,1186},{138,
-0,631},{5,10,468},{10,10,325},{11,10,856},{12,10,345},{143,10,104},{5,10,223},{
-10,11,592},{10,11,753},{12,11,317},{12,11,355},{12,11,465},{12,11,469},{12,11,
-560},{12,11,578},{141,11,243},{132,10,566},{135,11,520},{4,10,59},{135,10,1394},
-{6,10,436},{139,10,481},{9,0,931},{10,0,334},{20,0,71},{4,10,48},{5,10,271},{7,
-10,953},{135,11,1878},{11,0,170},{5,10,610},{136,10,457},{133,10,755},{6,0,1587}
-,{135,10,1217},{4,10,197},{149,11,26},{133,11,585},{137,11,521},{133,0,765},{133
-,10,217},{139,11,586},{133,0,424},{9,11,752},{12,11,610},{13,11,431},{16,11,59},
-{146,11,109},{136,0,714},{7,0,685},{132,11,307},{9,0,420},{10,0,269},{10,0,285},
-{10,0,576},{11,0,397},{13,0,175},{145,0,90},{132,0,429},{133,11,964},{9,11,463},
-{138,11,595},{7,0,18},{7,0,699},{7,0,1966},{8,0,752},{9,0,273},{9,0,412},{9,0,
-703},{10,0,71},{10,0,427},{138,0,508},{4,10,165},{7,10,1398},{135,10,1829},{4,0,
-53},{5,0,186},{7,0,752},{7,0,828},{142,0,116},{8,0,575},{10,0,289},{139,0,319},{
-132,0,675},{134,0,1424},{4,11,75},{5,11,180},{6,11,500},{7,11,58},{7,11,710},{
-138,11,645},{133,11,649},{6,11,276},{7,11,282},{7,11,879},{7,11,924},{8,11,459},
-{9,11,599},{9,11,754},{11,11,574},{12,11,128},{12,11,494},{13,11,52},{13,11,301}
-,{15,11,30},{143,11,132},{6,0,647},{134,0,1095},{5,10,9},{7,10,297},{7,10,966},{
-140,10,306},{132,11,200},{134,0,1334},{5,10,146},{6,10,411},{138,10,721},{6,0,
-209},{6,0,1141},{6,0,1288},{8,0,468},{9,0,210},{11,0,36},{12,0,28},{12,0,630},{
-13,0,21},{13,0,349},{14,0,7},{145,0,13},{6,10,177},{135,10,467},{4,0,342},{135,0
-,1179},{10,11,454},{140,11,324},{4,0,928},{133,0,910},{7,0,1838},{6,11,225},{137
-,11,211},{16,0,101},{20,0,115},{20,0,118},{148,0,122},{4,0,496},{135,0,856},{4,0
-,318},{11,0,654},{7,11,718},{139,11,102},{8,11,58},{9,11,724},{11,11,809},{13,11
-,113},{145,11,72},{5,10,200},{6,11,345},{135,11,1247},{8,11,767},{8,11,803},{9,
-11,301},{137,11,903},{7,0,915},{8,0,247},{19,0,0},{7,11,1949},{136,11,674},{4,0,
-202},{5,0,382},{6,0,454},{7,0,936},{7,0,1803},{8,0,758},{9,0,375},{9,0,895},{10,
-0,743},{10,0,792},{11,0,978},{11,0,1012},{142,0,109},{7,0,1150},{7,0,1425},{7,0,
-1453},{140,0,513},{134,11,259},{138,0,791},{11,0,821},{12,0,110},{12,0,153},{18,
-0,41},{150,0,19},{134,10,481},{132,0,796},{6,0,445},{9,0,909},{136,11,254},{10,0
-,776},{13,0,345},{142,0,425},{4,10,84},{7,10,1482},{10,10,76},{138,10,142},{135,
-11,742},{6,0,578},{133,10,1015},{6,0,1387},{4,10,315},{5,10,507},{135,10,1370},{
-4,0,438},{133,0,555},{136,0,766},{133,11,248},{134,10,1722},{4,11,116},{5,11,95}
-,{5,11,445},{7,11,1688},{8,11,29},{9,11,272},{11,11,509},{139,11,915},{135,0,541
-},{133,11,543},{8,10,222},{8,10,476},{9,10,238},{11,10,516},{11,10,575},{15,10,
-109},{146,10,100},{6,0,880},{134,0,1191},{5,11,181},{136,11,41},{134,0,1506},{
-132,11,681},{7,11,25},{8,11,202},{138,11,536},{139,0,983},{137,0,768},{132,0,584
-},{9,11,423},{140,11,89},{8,11,113},{9,11,877},{10,11,554},{11,11,83},{12,11,136
-},{147,11,109},{7,10,706},{7,10,1058},{138,10,538},{133,11,976},{4,11,206},{135,
-11,746},{136,11,526},{140,0,737},{11,10,92},{11,10,196},{11,10,409},{11,10,450},
-{11,10,666},{11,10,777},{12,10,262},{13,10,385},{13,10,393},{15,10,115},{16,10,
-45},{145,10,82},{4,0,226},{4,0,326},{7,0,1770},{4,11,319},{5,11,699},{138,11,673
-},{6,10,40},{135,10,1781},{5,0,426},{8,0,30},{9,0,2},{11,0,549},{147,0,122},{6,0
-,1161},{134,0,1329},{138,10,97},{6,10,423},{7,10,665},{135,10,1210},{7,11,13},{8
-,11,226},{10,11,537},{11,11,570},{11,11,605},{11,11,799},{11,11,804},{12,11,85},
-{12,11,516},{12,11,623},{13,11,112},{13,11,361},{14,11,77},{14,11,78},{17,11,28}
-,{147,11,110},{132,11,769},{132,11,551},{132,11,728},{147,0,117},{9,11,57},{9,11
-,459},{10,11,425},{11,11,119},{12,11,184},{12,11,371},{13,11,358},{145,11,51},{5
-,11,188},{5,11,814},{8,11,10},{9,11,421},{9,11,729},{10,11,609},{139,11,689},{
-134,11,624},{135,11,298},{135,0,462},{4,0,345},{139,10,624},{136,10,574},{4,0,
-385},{7,0,265},{135,0,587},{6,0,808},{132,11,528},{133,0,398},{132,10,354},{4,0,
-347},{5,0,423},{5,0,996},{135,0,1329},{135,10,1558},{7,0,1259},{9,0,125},{139,0,
-65},{5,0,136},{6,0,136},{136,0,644},{5,11,104},{6,11,173},{135,11,1631},{135,0,
-469},{133,10,830},{4,0,278},{5,0,465},{135,0,1367},{7,11,810},{8,11,138},{8,11,
-342},{9,11,84},{10,11,193},{11,11,883},{140,11,359},{5,10,496},{135,10,203},{4,0
-,433},{133,0,719},{6,11,95},{134,10,547},{5,10,88},{137,10,239},{6,11,406},{10,
-11,409},{10,11,447},{11,11,44},{140,11,100},{134,0,1423},{7,10,650},{135,10,1310
-},{134,0,749},{135,11,1243},{135,0,1363},{6,0,381},{7,0,645},{7,0,694},{8,0,546}
-,{7,10,1076},{9,10,80},{11,10,78},{11,10,421},{11,10,534},{140,10,545},{134,11,
-1636},{135,11,1344},{12,0,277},{7,10,274},{11,10,479},{139,10,507},{6,0,705},{6,
-0,783},{6,0,1275},{6,0,1481},{4,11,282},{7,11,1034},{11,11,398},{11,11,634},{12,
-11,1},{12,11,79},{12,11,544},{14,11,237},{17,11,10},{146,11,20},{134,0,453},{4,0
-,555},{8,0,536},{10,0,288},{11,0,1005},{4,10,497},{135,10,1584},{5,11,118},{5,11
-,499},{6,11,476},{7,11,600},{7,11,888},{135,11,1096},{138,0,987},{7,0,1107},{7,
-10,261},{7,10,1115},{7,10,1354},{7,10,1588},{7,10,1705},{7,10,1902},{9,10,465},{
-10,10,248},{10,10,349},{10,10,647},{11,10,527},{11,10,660},{11,10,669},{12,10,
-529},{141,10,305},{7,11,296},{7,11,596},{8,11,560},{8,11,586},{9,11,612},{11,11,
-100},{11,11,304},{12,11,46},{13,11,89},{14,11,112},{145,11,122},{9,0,370},{138,0
-,90},{136,10,13},{132,0,860},{7,10,642},{8,10,250},{11,10,123},{11,10,137},{13,
-10,48},{142,10,95},{135,10,1429},{137,11,321},{132,0,257},{135,0,2031},{7,0,1768
-},{7,11,1599},{7,11,1723},{8,11,79},{8,11,106},{8,11,190},{8,11,302},{8,11,383},
-{9,11,119},{9,11,233},{9,11,298},{9,11,419},{9,11,471},{10,11,181},{10,11,406},{
-11,11,57},{11,11,85},{11,11,120},{11,11,177},{11,11,296},{11,11,382},{11,11,454}
-,{11,11,758},{11,11,999},{12,11,27},{12,11,98},{12,11,131},{12,11,245},{12,11,
-312},{12,11,446},{12,11,454},{13,11,25},{13,11,98},{13,11,426},{13,11,508},{14,
-11,6},{14,11,163},{14,11,272},{14,11,277},{14,11,370},{15,11,95},{15,11,138},{15
-,11,167},{17,11,18},{17,11,38},{20,11,96},{149,11,32},{5,11,722},{134,11,1759},{
-145,11,16},{6,0,1071},{134,0,1561},{10,10,545},{140,10,301},{6,0,83},{6,0,1733},
-{135,0,1389},{4,0,835},{135,0,1818},{133,11,258},{4,10,904},{133,10,794},{134,0,
-2006},{5,11,30},{7,11,495},{8,11,134},{9,11,788},{140,11,438},{135,11,2004},{137
-,0,696},{5,11,50},{6,11,439},{7,11,780},{135,11,1040},{7,11,772},{7,11,1104},{7,
-11,1647},{11,11,269},{11,11,539},{11,11,607},{11,11,627},{11,11,706},{11,11,975}
-,{12,11,248},{12,11,311},{12,11,434},{12,11,600},{12,11,622},{13,11,297},{13,11,
-367},{13,11,485},{14,11,69},{14,11,409},{143,11,108},{5,11,1},{6,11,81},{138,11,
-520},{7,0,1718},{9,0,95},{9,0,274},{10,0,279},{10,0,317},{10,0,420},{11,0,303},{
-11,0,808},{12,0,134},{12,0,367},{13,0,149},{13,0,347},{14,0,349},{14,0,406},{18,
-0,22},{18,0,89},{18,0,122},{147,0,47},{5,11,482},{8,11,98},{9,11,172},{10,11,222
-},{10,11,700},{10,11,822},{11,11,302},{11,11,778},{12,11,50},{12,11,127},{12,11,
-396},{13,11,62},{13,11,328},{14,11,122},{147,11,72},{7,10,386},{138,10,713},{6,
-10,7},{6,10,35},{7,10,147},{7,10,1069},{7,10,1568},{7,10,1575},{7,10,1917},{8,10
-,43},{8,10,208},{9,10,128},{9,10,866},{10,10,20},{11,10,981},{147,10,33},{133,0,
-26},{132,0,550},{5,11,2},{7,11,1494},{136,11,589},{6,11,512},{7,11,797},{8,11,
-253},{9,11,77},{10,11,1},{10,11,129},{10,11,225},{11,11,118},{11,11,226},{11,11,
-251},{11,11,430},{11,11,701},{11,11,974},{11,11,982},{12,11,64},{12,11,260},{12,
-11,488},{140,11,690},{7,10,893},{141,10,424},{134,0,901},{136,0,822},{4,0,902},{
-5,0,809},{134,0,122},{6,0,807},{134,0,1366},{7,0,262},{5,11,748},{134,11,553},{
-133,0,620},{4,0,34},{5,0,574},{7,0,279},{7,0,1624},{136,0,601},{9,0,170},{6,10,
-322},{9,10,552},{11,10,274},{13,10,209},{13,10,499},{14,10,85},{15,10,126},{145,
-10,70},{132,0,537},{4,11,12},{7,11,420},{7,11,522},{7,11,809},{8,11,797},{141,11
-,88},{133,0,332},{8,10,83},{8,10,742},{8,10,817},{9,10,28},{9,10,29},{9,10,885},
-{10,10,387},{11,10,633},{11,10,740},{13,10,235},{13,10,254},{15,10,143},{143,10,
-146},{6,0,1909},{9,0,964},{12,0,822},{12,0,854},{12,0,865},{12,0,910},{12,0,938}
-,{15,0,169},{15,0,208},{15,0,211},{18,0,205},{18,0,206},{18,0,220},{18,0,223},{
-152,0,24},{140,10,49},{5,11,528},{135,11,1580},{6,0,261},{8,0,182},{139,0,943},{
-134,0,1721},{4,0,933},{133,0,880},{136,11,321},{5,11,266},{9,11,290},{9,11,364},
-{10,11,293},{11,11,606},{142,11,45},{6,0,1609},{4,11,50},{6,11,510},{6,11,594},{
-9,11,121},{10,11,49},{10,11,412},{139,11,834},{7,0,895},{136,11,748},{132,11,466
-},{4,10,110},{10,10,415},{10,10,597},{142,10,206},{133,0,812},{135,11,281},{6,0,
-1890},{6,0,1902},{6,0,1916},{9,0,929},{9,0,942},{9,0,975},{9,0,984},{9,0,986},{9
-,0,1011},{9,0,1019},{12,0,804},{12,0,851},{12,0,867},{12,0,916},{12,0,923},{15,0
-,194},{15,0,204},{15,0,210},{15,0,222},{15,0,223},{15,0,229},{15,0,250},{18,0,
-179},{18,0,186},{18,0,192},{7,10,205},{135,10,2000},{132,11,667},{135,0,778},{4,
-0,137},{7,0,1178},{135,0,1520},{134,0,1314},{4,11,242},{134,11,333},{6,0,1661},{
-7,0,1975},{7,0,2009},{135,0,2011},{134,0,1591},{4,10,283},{135,10,1194},{11,0,
-820},{150,0,51},{4,11,39},{5,11,36},{7,11,1843},{8,11,407},{11,11,144},{140,11,
-523},{134,10,1720},{4,11,510},{7,11,29},{7,11,66},{7,11,1980},{10,11,487},{10,11
-,809},{146,11,9},{5,0,89},{7,0,1915},{9,0,185},{9,0,235},{10,0,64},{10,0,270},{
-10,0,403},{10,0,469},{10,0,529},{10,0,590},{11,0,140},{11,0,860},{13,0,1},{13,0,
-422},{14,0,341},{14,0,364},{17,0,93},{18,0,113},{19,0,97},{147,0,113},{133,0,695
-},{6,0,987},{134,0,1160},{5,0,6},{6,0,183},{7,0,680},{7,0,978},{7,0,1013},{7,0,
-1055},{12,0,230},{13,0,172},{146,0,29},{134,11,570},{132,11,787},{134,11,518},{6
-,0,29},{139,0,63},{132,11,516},{136,11,821},{132,0,311},{134,0,1740},{7,0,170},{
-8,0,90},{8,0,177},{8,0,415},{11,0,714},{14,0,281},{136,10,735},{134,0,1961},{135
-,11,1405},{4,11,10},{7,11,917},{139,11,786},{5,10,132},{9,10,486},{9,10,715},{10
-,10,458},{11,10,373},{11,10,668},{11,10,795},{11,10,897},{12,10,272},{12,10,424}
-,{12,10,539},{12,10,558},{14,10,245},{14,10,263},{14,10,264},{14,10,393},{142,10
-,403},{11,0,91},{13,0,129},{15,0,101},{145,0,125},{135,0,1132},{4,0,494},{6,0,74
-},{7,0,44},{7,0,407},{12,0,17},{15,0,5},{148,0,11},{133,10,379},{5,0,270},{5,11,
-684},{6,10,89},{6,10,400},{7,10,1569},{7,10,1623},{7,10,1850},{8,10,218},{8,10,
-422},{9,10,570},{138,10,626},{4,0,276},{133,0,296},{6,0,1523},{134,11,27},{6,10,
-387},{7,10,882},{141,10,111},{6,10,224},{7,10,877},{137,10,647},{135,10,790},{4,
-0,7},{5,0,90},{5,0,158},{6,0,542},{7,0,221},{7,0,1574},{9,0,490},{10,0,540},{11,
-0,443},{139,0,757},{7,0,588},{9,0,175},{138,0,530},{135,10,394},{142,11,23},{134
-,0,786},{135,0,580},{7,0,88},{136,0,627},{5,0,872},{6,0,57},{7,0,471},{9,0,447},
-{137,0,454},{6,11,342},{6,11,496},{8,11,275},{137,11,206},{4,11,909},{133,11,940
-},{6,0,735},{132,11,891},{8,0,845},{8,0,916},{135,10,1409},{5,0,31},{134,0,614},
-{11,0,458},{12,0,15},{140,0,432},{8,0,330},{140,0,477},{4,0,530},{5,0,521},{7,0,
-1200},{10,0,460},{132,11,687},{6,0,424},{135,0,1866},{9,0,569},{12,0,12},{12,0,
-81},{12,0,319},{13,0,69},{14,0,259},{16,0,87},{17,0,1},{17,0,21},{17,0,24},{18,0
-,15},{18,0,56},{18,0,59},{18,0,127},{18,0,154},{19,0,19},{148,0,31},{7,0,1302},{
-136,10,38},{134,11,253},{5,10,261},{7,10,78},{7,10,199},{8,10,815},{9,10,126},{
-138,10,342},{5,0,595},{135,0,1863},{6,11,41},{141,11,160},{5,0,13},{134,0,142},{
-6,0,97},{7,0,116},{8,0,322},{8,0,755},{9,0,548},{10,0,714},{11,0,884},{13,0,324}
-,{7,11,1304},{138,11,477},{132,10,628},{134,11,1718},{7,10,266},{136,10,804},{
-135,10,208},{7,0,1021},{6,10,79},{135,10,1519},{7,0,1472},{135,0,1554},{6,11,362
-},{146,11,51},{7,0,1071},{7,0,1541},{7,0,1767},{7,0,1806},{11,0,162},{11,0,242},
-{11,0,452},{12,0,605},{15,0,26},{144,0,44},{136,10,741},{133,11,115},{145,0,115}
-,{134,10,376},{6,0,1406},{134,0,1543},{5,11,193},{12,11,178},{13,11,130},{145,11
-,84},{135,0,1111},{8,0,1},{9,0,650},{10,0,326},{5,11,705},{137,11,606},{5,0,488}
-,{6,0,527},{7,0,489},{7,0,1636},{8,0,121},{8,0,144},{8,0,359},{9,0,193},{9,0,241
-},{9,0,336},{9,0,882},{11,0,266},{11,0,372},{11,0,944},{12,0,401},{140,0,641},{
-135,11,174},{6,0,267},{7,10,244},{7,10,632},{7,10,1609},{8,10,178},{8,10,638},{
-141,10,58},{134,0,1983},{134,0,1155},{134,0,1575},{134,0,1438},{9,0,31},{10,0,
-244},{10,0,699},{12,0,149},{141,0,497},{133,0,377},{4,11,122},{5,11,796},{5,11,
-952},{6,11,1660},{6,11,1671},{8,11,567},{9,11,687},{9,11,742},{10,11,686},{11,11
-,356},{11,11,682},{140,11,281},{145,0,101},{11,11,0},{144,11,78},{5,11,179},{5,
-10,791},{7,11,1095},{135,11,1213},{8,11,372},{9,11,122},{138,11,175},{7,10,686},
-{8,10,33},{8,10,238},{10,10,616},{11,10,467},{11,10,881},{13,10,217},{13,10,253}
-,{142,10,268},{9,0,476},{4,11,66},{7,11,722},{135,11,904},{7,11,352},{137,11,684
-},{135,0,2023},{135,0,1836},{132,10,447},{5,0,843},{144,0,35},{137,11,779},{141,
-11,35},{4,10,128},{5,10,415},{6,10,462},{7,10,294},{7,10,578},{10,10,710},{139,
-10,86},{132,0,554},{133,0,536},{136,10,587},{5,0,207},{9,0,79},{11,0,625},{145,0
-,7},{7,0,1371},{6,10,427},{138,10,692},{4,0,424},{4,10,195},{135,10,802},{8,0,
-785},{133,11,564},{135,0,336},{4,0,896},{6,0,1777},{134,11,556},{137,11,103},{
-134,10,1683},{7,11,544},{8,11,719},{138,11,61},{138,10,472},{4,11,5},{5,11,498},
-{136,11,637},{7,0,750},{9,0,223},{11,0,27},{11,0,466},{12,0,624},{14,0,265},{146
-,0,61},{12,0,238},{18,0,155},{12,11,238},{146,11,155},{151,10,28},{133,11,927},{
-12,0,383},{5,10,3},{8,10,578},{9,10,118},{10,10,705},{141,10,279},{4,11,893},{5,
-11,780},{133,11,893},{4,0,603},{133,0,661},{4,0,11},{6,0,128},{7,0,231},{7,0,
-1533},{10,0,725},{5,10,229},{5,11,238},{135,11,1350},{8,10,102},{10,10,578},{10,
-10,672},{12,10,496},{13,10,408},{14,10,121},{145,10,106},{132,0,476},{134,0,1552
-},{134,11,1729},{8,10,115},{8,10,350},{9,10,489},{10,10,128},{11,10,306},{12,10,
-373},{14,10,30},{17,10,79},{19,10,80},{150,10,55},{135,0,1807},{4,0,680},{4,11,
-60},{7,11,760},{7,11,1800},{8,11,314},{9,11,700},{139,11,487},{4,10,230},{5,10,
-702},{148,11,94},{132,11,228},{139,0,435},{9,0,20},{10,0,324},{10,0,807},{139,0,
-488},{6,10,1728},{136,11,419},{4,10,484},{18,10,26},{19,10,42},{20,10,43},{21,10
-,0},{23,10,27},{152,10,14},{135,0,1431},{133,11,828},{5,0,112},{6,0,103},{6,0,
-150},{7,0,1303},{9,0,292},{10,0,481},{20,0,13},{7,11,176},{7,11,178},{7,11,1110}
-,{10,11,481},{148,11,13},{138,0,356},{4,11,51},{5,11,39},{6,11,4},{7,11,591},{7,
-11,849},{7,11,951},{7,11,1129},{7,11,1613},{7,11,1760},{7,11,1988},{9,11,434},{
-10,11,754},{11,11,25},{11,11,37},{139,11,414},{6,0,1963},{134,0,2000},{132,10,
-633},{6,0,1244},{133,11,902},{135,11,928},{140,0,18},{138,0,204},{135,11,1173},{
-134,0,867},{4,0,708},{8,0,15},{9,0,50},{9,0,386},{11,0,18},{11,0,529},{140,0,228
-},{134,11,270},{4,0,563},{7,0,109},{7,0,592},{7,0,637},{7,0,770},{8,0,463},{9,0,
-60},{9,0,335},{9,0,904},{10,0,73},{11,0,434},{12,0,585},{13,0,331},{18,0,110},{
-148,0,60},{132,0,502},{14,11,359},{19,11,52},{148,11,47},{6,11,377},{7,11,1025},
-{9,11,613},{145,11,104},{6,0,347},{10,0,161},{5,10,70},{5,10,622},{6,10,334},{7,
-10,1032},{9,10,171},{11,10,26},{11,10,213},{11,10,637},{11,10,707},{12,10,202},{
-12,10,380},{13,10,226},{13,10,355},{14,10,222},{145,10,42},{132,11,416},{4,0,33}
-,{5,0,102},{6,0,284},{7,0,1079},{7,0,1423},{7,0,1702},{8,0,470},{9,0,554},{9,0,
-723},{11,0,333},{142,11,372},{5,11,152},{5,11,197},{7,11,340},{7,11,867},{10,11,
-548},{10,11,581},{11,11,6},{12,11,3},{12,11,19},{14,11,110},{142,11,289},{7,0,
-246},{135,0,840},{6,0,10},{8,0,571},{9,0,739},{143,0,91},{6,0,465},{7,0,1465},{4
-,10,23},{4,10,141},{5,10,313},{5,10,1014},{6,10,50},{7,10,142},{7,10,559},{8,10,
-640},{9,10,460},{9,10,783},{11,10,741},{12,10,183},{141,10,488},{133,0,626},{136
-,0,614},{138,0,237},{7,11,34},{7,11,190},{8,11,28},{8,11,141},{8,11,444},{8,11,
-811},{9,11,468},{11,11,334},{12,11,24},{12,11,386},{140,11,576},{133,11,757},{5,
-0,18},{6,0,526},{13,0,24},{13,0,110},{19,0,5},{147,0,44},{6,0,506},{134,11,506},
-{135,11,1553},{4,0,309},{5,0,462},{7,0,970},{7,0,1097},{22,0,30},{22,0,33},{7,11
-,1385},{11,11,582},{11,11,650},{11,11,901},{11,11,949},{12,11,232},{12,11,236},{
-13,11,413},{13,11,501},{146,11,116},{9,0,140},{5,10,222},{138,10,534},{6,0,1056}
-,{137,10,906},{134,0,1704},{138,10,503},{134,0,1036},{5,10,154},{7,10,1491},{10,
-10,379},{138,10,485},{4,11,383},{133,10,716},{134,0,1315},{5,0,86},{7,0,743},{9,
-0,85},{10,0,281},{10,0,432},{11,0,825},{12,0,251},{13,0,118},{142,0,378},{8,0,
-264},{4,10,91},{5,10,388},{5,10,845},{6,10,206},{6,10,252},{6,10,365},{7,10,136}
-,{7,10,531},{136,10,621},{5,0,524},{133,0,744},{5,11,277},{141,11,247},{132,11,
-435},{10,0,107},{140,0,436},{132,0,927},{10,0,123},{12,0,670},{146,0,94},{7,0,
-1149},{9,0,156},{138,0,957},{5,11,265},{6,11,212},{135,11,28},{133,0,778},{133,0
-,502},{8,0,196},{10,0,283},{139,0,406},{135,10,576},{136,11,535},{134,0,1312},{5
-,10,771},{5,10,863},{5,10,898},{6,10,1632},{6,10,1644},{134,10,1780},{5,0,855},{
-5,10,331},{135,11,1487},{132,11,702},{5,11,808},{135,11,2045},{7,0,1400},{9,0,
-446},{138,0,45},{140,10,632},{132,0,1003},{5,11,166},{8,11,739},{140,11,511},{5,
-10,107},{7,10,201},{136,10,518},{6,10,446},{135,10,1817},{134,0,1532},{134,0,
-1097},{4,11,119},{5,11,170},{5,11,447},{7,11,1708},{7,11,1889},{9,11,357},{9,11,
-719},{12,11,486},{140,11,596},{9,10,851},{141,10,510},{7,0,612},{8,0,545},{8,0,
-568},{8,0,642},{9,0,717},{10,0,541},{10,0,763},{11,0,449},{12,0,489},{13,0,153},
-{13,0,296},{14,0,138},{14,0,392},{15,0,50},{16,0,6},{16,0,12},{20,0,9},{132,10,
-504},{4,11,450},{135,11,1158},{11,0,54},{13,0,173},{13,0,294},{5,10,883},{5,10,
-975},{8,10,392},{148,10,7},{13,0,455},{15,0,99},{15,0,129},{144,0,68},{135,0,172
-},{132,11,754},{5,10,922},{134,10,1707},{134,0,1029},{17,11,39},{148,11,36},{4,0
-,568},{5,10,993},{7,10,515},{137,10,91},{132,0,732},{10,0,617},{138,11,617},{134
-,0,974},{7,0,989},{10,0,377},{12,0,363},{13,0,68},{13,0,94},{14,0,108},{142,0,
-306},{136,0,733},{132,0,428},{7,0,1789},{135,11,1062},{7,0,2015},{140,0,665},{
-135,10,1433},{5,0,287},{7,10,921},{8,10,580},{8,10,593},{8,10,630},{138,10,28},{
-138,0,806},{4,10,911},{5,10,867},{5,10,1013},{7,10,2034},{8,10,798},{136,10,813}
-,{134,0,1539},{8,11,523},{150,11,34},{135,11,740},{7,11,238},{7,11,2033},{8,11,
-120},{8,11,188},{8,11,659},{9,11,598},{10,11,466},{12,11,342},{12,11,588},{13,11
-,503},{14,11,246},{143,11,92},{7,0,1563},{141,0,182},{5,10,135},{6,10,519},{7,10
-,1722},{10,10,271},{11,10,261},{145,10,54},{14,10,338},{148,10,81},{7,0,484},{4,
-10,300},{133,10,436},{145,11,114},{6,0,1623},{134,0,1681},{133,11,640},{4,11,201
-},{7,11,1744},{8,11,602},{11,11,247},{11,11,826},{145,11,65},{8,11,164},{146,11,
-62},{6,0,1833},{6,0,1861},{136,0,878},{134,0,1569},{8,10,357},{10,10,745},{14,10
-,426},{17,10,94},{147,10,57},{12,0,93},{12,0,501},{13,0,362},{14,0,151},{15,0,40
-},{15,0,59},{16,0,46},{17,0,25},{18,0,14},{18,0,134},{19,0,25},{19,0,69},{20,0,
-16},{20,0,19},{20,0,66},{21,0,23},{21,0,25},{150,0,42},{6,0,1748},{8,0,715},{9,0
-,802},{10,0,46},{10,0,819},{13,0,308},{14,0,351},{14,0,363},{146,0,67},{132,0,
-994},{4,0,63},{133,0,347},{132,0,591},{133,0,749},{7,11,1577},{10,11,304},{10,11
-,549},{11,11,424},{12,11,365},{13,11,220},{13,11,240},{142,11,33},{133,0,366},{7
-,0,557},{12,0,547},{14,0,86},{133,10,387},{135,0,1747},{132,11,907},{5,11,100},{
-10,11,329},{12,11,416},{149,11,29},{4,10,6},{5,10,708},{136,10,75},{7,10,1351},{
-9,10,581},{10,10,639},{11,10,453},{140,10,584},{7,0,89},{132,10,303},{138,10,772
-},{132,11,176},{5,11,636},{5,11,998},{8,11,26},{137,11,358},{7,11,9},{7,11,1508}
-,{9,11,317},{10,11,210},{10,11,292},{10,11,533},{11,11,555},{12,11,526},{12,11,
-607},{13,11,263},{13,11,459},{142,11,271},{134,0,1463},{6,0,772},{6,0,1137},{139
-,11,595},{7,0,977},{139,11,66},{138,0,893},{20,0,48},{148,11,48},{5,0,824},{133,
-0,941},{134,11,295},{7,0,1543},{7,0,1785},{10,0,690},{4,10,106},{139,10,717},{7,
-0,440},{8,0,230},{139,0,106},{5,10,890},{133,10,988},{6,10,626},{142,10,431},{10
-,11,127},{141,11,27},{17,0,32},{10,10,706},{150,10,44},{132,0,216},{137,0,332},{
-4,10,698},{136,11,119},{139,11,267},{138,10,17},{11,11,526},{11,11,939},{141,11,
-290},{7,11,1167},{11,11,934},{13,11,391},{145,11,76},{139,11,39},{134,10,84},{4,
-0,914},{5,0,800},{133,0,852},{10,0,416},{141,0,115},{7,0,564},{142,0,168},{4,0,
-918},{133,0,876},{134,0,1764},{152,0,3},{4,0,92},{5,0,274},{7,11,126},{136,11,84
-},{140,10,498},{136,11,790},{8,0,501},{5,10,986},{6,10,130},{7,10,1582},{8,10,
-458},{10,10,101},{10,10,318},{138,10,823},{6,11,64},{12,11,377},{141,11,309},{5,
-0,743},{138,0,851},{4,0,49},{7,0,280},{135,0,1633},{134,0,879},{136,0,47},{7,10,
-1644},{137,10,129},{132,0,865},{134,0,1202},{9,11,34},{139,11,484},{135,10,997},
-{5,0,272},{5,0,908},{5,0,942},{8,0,197},{9,0,47},{11,0,538},{139,0,742},{6,11,
-1700},{7,11,26},{7,11,293},{7,11,382},{7,11,1026},{7,11,1087},{7,11,2027},{8,11,
-24},{8,11,114},{8,11,252},{8,11,727},{8,11,729},{9,11,30},{9,11,199},{9,11,231},
-{9,11,251},{9,11,334},{9,11,361},{9,11,488},{9,11,712},{10,11,55},{10,11,60},{10
-,11,232},{10,11,332},{10,11,384},{10,11,396},{10,11,504},{10,11,542},{10,11,652}
-,{11,11,20},{11,11,48},{11,11,207},{11,11,291},{11,11,298},{11,11,342},{11,11,
-365},{11,11,394},{11,11,620},{11,11,705},{11,11,1017},{12,11,123},{12,11,340},{
-12,11,406},{12,11,643},{13,11,61},{13,11,269},{13,11,311},{13,11,319},{13,11,486
-},{14,11,234},{15,11,62},{15,11,85},{16,11,71},{18,11,119},{148,11,105},{6,0,
-1455},{150,11,37},{135,10,1927},{135,0,1911},{137,0,891},{7,10,1756},{137,10,98}
-,{7,10,1046},{139,10,160},{132,0,761},{6,11,379},{7,11,270},{7,11,1116},{8,11,
-176},{8,11,183},{9,11,432},{9,11,661},{12,11,247},{12,11,617},{146,11,125},{6,10
-,45},{7,10,433},{8,10,129},{9,10,21},{10,10,392},{11,10,79},{12,10,499},{13,10,
-199},{141,10,451},{4,0,407},{5,11,792},{133,11,900},{132,0,560},{135,0,183},{13,
-0,490},{7,10,558},{136,10,353},{4,0,475},{6,0,731},{11,0,35},{13,0,71},{13,0,177
-},{14,0,422},{133,10,785},{8,10,81},{9,10,189},{9,10,201},{11,10,478},{11,10,712
-},{141,10,338},{4,0,418},{4,0,819},{133,10,353},{151,10,26},{4,11,901},{133,11,
-776},{132,0,575},{7,0,818},{16,0,92},{17,0,14},{17,0,45},{18,0,75},{148,0,18},{6
-,0,222},{7,0,636},{7,0,1620},{8,0,409},{9,0,693},{139,0,77},{6,10,25},{7,10,855}
-,{7,10,1258},{144,10,32},{6,0,1880},{6,0,1887},{6,0,1918},{6,0,1924},{9,0,967},{
-9,0,995},{9,0,1015},{12,0,826},{12,0,849},{12,0,857},{12,0,860},{12,0,886},{12,0
-,932},{18,0,228},{18,0,231},{146,0,240},{134,0,633},{134,0,1308},{4,11,37},{5,11
-,334},{135,11,1253},{10,0,86},{4,10,4},{7,10,1118},{7,10,1320},{7,10,1706},{8,10
-,277},{9,10,622},{11,10,724},{12,10,350},{12,10,397},{13,10,28},{13,10,159},{15,
-10,89},{18,10,5},{19,10,9},{20,10,34},{150,10,47},{132,11,508},{137,11,448},{12,
-11,107},{146,11,31},{132,0,817},{134,0,663},{133,0,882},{134,0,914},{132,11,540}
-,{132,11,533},{136,11,608},{8,0,885},{138,0,865},{132,0,426},{6,0,58},{7,0,745},
-{7,0,1969},{8,0,399},{8,0,675},{9,0,479},{9,0,731},{10,0,330},{10,0,593},{10,0,
-817},{11,0,32},{11,0,133},{11,0,221},{145,0,68},{134,10,255},{7,0,102},{137,0,
-538},{137,10,216},{7,11,253},{136,11,549},{135,11,912},{9,10,183},{139,10,286},{
-11,10,956},{151,10,3},{8,11,527},{18,11,60},{147,11,24},{4,10,536},{7,10,1141},{
-10,10,723},{139,10,371},{133,11,920},{7,0,876},{135,10,285},{135,10,560},{132,10
-,690},{142,11,126},{11,10,33},{12,10,571},{149,10,1},{133,0,566},{9,0,139},{10,0
-,399},{11,0,469},{12,0,634},{13,0,223},{132,11,483},{6,0,48},{135,0,63},{18,0,12
-},{7,10,1862},{12,10,491},{12,10,520},{13,10,383},{142,10,244},{135,11,1665},{
-132,11,448},{9,11,495},{146,11,104},{6,0,114},{7,0,1224},{7,0,1556},{136,0,3},{4
-,10,190},{133,10,554},{8,0,576},{9,0,267},{133,10,1001},{133,10,446},{133,0,933}
-,{139,11,1009},{8,11,653},{13,11,93},{147,11,14},{6,0,692},{6,0,821},{134,0,1077
-},{5,11,172},{135,11,801},{138,0,752},{4,0,375},{134,0,638},{134,0,1011},{140,11
-,540},{9,0,96},{133,11,260},{139,11,587},{135,10,1231},{12,0,30},{13,0,148},{14,
-0,87},{14,0,182},{16,0,42},{20,0,70},{132,10,304},{6,0,1398},{7,0,56},{7,0,1989}
-,{8,0,337},{8,0,738},{9,0,600},{12,0,37},{13,0,447},{142,0,92},{138,0,666},{5,0,
-394},{7,0,487},{136,0,246},{9,0,437},{6,10,53},{6,10,199},{7,10,1408},{8,10,32},
-{8,10,93},{10,10,397},{10,10,629},{11,10,593},{11,10,763},{13,10,326},{145,10,35
-},{134,10,105},{9,0,320},{10,0,506},{138,10,794},{7,11,57},{8,11,167},{8,11,375}
-,{9,11,82},{9,11,561},{10,11,620},{10,11,770},{11,10,704},{141,10,396},{6,0,1003
-},{5,10,114},{5,10,255},{141,10,285},{7,0,866},{135,0,1163},{133,11,531},{132,0,
-328},{7,10,2035},{8,10,19},{9,10,89},{138,10,831},{8,11,194},{136,11,756},{136,0
-,1000},{5,11,453},{134,11,441},{4,0,101},{5,0,833},{7,0,1171},{136,0,744},{133,0
-,726},{136,10,746},{138,0,176},{6,0,9},{6,0,397},{7,0,53},{7,0,1742},{10,0,632},
-{11,0,828},{140,0,146},{135,11,22},{145,11,64},{132,0,839},{11,0,417},{12,0,223}
-,{140,0,265},{4,11,102},{7,11,815},{7,11,1699},{139,11,964},{5,10,955},{136,10,
-814},{6,0,1931},{6,0,2007},{18,0,246},{146,0,247},{8,0,198},{11,0,29},{140,0,534
-},{135,0,1771},{6,0,846},{7,11,1010},{11,11,733},{11,11,759},{12,11,563},{13,11,
-34},{14,11,101},{18,11,45},{146,11,129},{4,0,186},{5,0,157},{8,0,168},{138,0,6},
-{132,11,899},{133,10,56},{148,10,100},{133,0,875},{5,0,773},{5,0,991},{6,0,1635}
-,{134,0,1788},{6,0,1274},{9,0,477},{141,0,78},{4,0,639},{7,0,111},{8,0,581},{12,
-0,177},{6,11,52},{9,11,104},{9,11,559},{10,10,4},{10,10,13},{11,10,638},{12,11,
-308},{19,11,87},{148,10,57},{132,11,604},{4,11,301},{133,10,738},{133,10,758},{
-134,0,1747},{7,11,1440},{11,11,854},{11,11,872},{11,11,921},{12,11,551},{13,11,
-472},{142,11,367},{7,0,1364},{7,0,1907},{141,0,158},{134,0,873},{4,0,404},{4,0,
-659},{7,0,552},{135,0,675},{135,10,1112},{139,10,328},{7,11,508},{137,10,133},{
-133,0,391},{5,10,110},{6,10,169},{6,10,1702},{7,10,400},{8,10,538},{9,10,184},{9
-,10,524},{140,10,218},{6,11,310},{7,11,1849},{8,11,72},{8,11,272},{8,11,431},{9,
-11,12},{9,11,351},{10,11,563},{10,11,630},{10,11,810},{11,11,367},{11,11,599},{
-11,11,686},{140,11,672},{5,0,540},{6,0,1697},{136,0,668},{132,0,883},{134,0,78},
-{12,0,628},{18,0,79},{6,10,133},{9,10,353},{139,10,993},{6,11,181},{7,11,537},{8
-,11,64},{9,11,127},{10,11,496},{12,11,510},{141,11,384},{6,10,93},{7,10,1422},{7
-,10,1851},{8,10,673},{9,10,529},{140,10,43},{137,10,371},{134,0,1460},{134,0,962
-},{4,11,244},{135,11,233},{9,10,25},{10,10,467},{138,10,559},{4,10,335},{135,10,
-942},{133,0,460},{135,11,334},{134,11,1650},{4,0,199},{139,0,34},{5,10,601},{8,
-10,39},{10,10,773},{11,10,84},{12,10,205},{142,10,1},{133,10,870},{134,0,388},{
-14,0,474},{148,0,120},{133,11,369},{139,0,271},{4,0,511},{9,0,333},{9,0,379},{10
-,0,602},{11,0,441},{11,0,723},{11,0,976},{12,0,357},{132,10,181},{134,0,608},{
-134,10,1652},{22,0,49},{137,11,338},{140,0,988},{134,0,617},{5,0,938},{136,0,707
-},{132,10,97},{5,10,147},{6,10,286},{7,10,1362},{141,10,176},{6,0,756},{134,0,
-1149},{133,11,896},{6,10,375},{7,10,169},{7,10,254},{136,10,780},{134,0,1583},{
-135,10,1447},{139,0,285},{7,11,1117},{8,11,393},{136,11,539},{135,0,344},{6,0,
-469},{7,0,1709},{138,0,515},{5,10,629},{135,10,1549},{5,11,4},{5,11,810},{6,11,
-13},{6,11,538},{6,11,1690},{6,11,1726},{7,11,499},{7,11,1819},{8,11,148},{8,11,
-696},{8,11,791},{12,11,125},{13,11,54},{143,11,9},{135,11,1268},{137,0,404},{132
-,0,500},{5,0,68},{134,0,383},{11,0,216},{139,0,340},{4,11,925},{5,11,803},{8,11,
-698},{138,11,828},{4,0,337},{6,0,353},{7,0,1934},{8,0,488},{137,0,429},{7,0,236}
-,{7,0,1795},{8,0,259},{9,0,135},{9,0,177},{9,0,860},{10,0,825},{11,0,115},{11,0,
-370},{11,0,405},{11,0,604},{12,0,10},{12,0,667},{12,0,669},{13,0,76},{14,0,310},
-{15,0,76},{15,0,147},{148,0,23},{4,0,15},{4,0,490},{5,0,22},{6,0,244},{7,0,40},{
-7,0,200},{7,0,906},{7,0,1199},{9,0,616},{10,0,716},{11,0,635},{11,0,801},{140,0,
-458},{12,0,756},{132,10,420},{134,0,1504},{6,0,757},{133,11,383},{6,0,1266},{135
-,0,1735},{5,0,598},{7,0,791},{8,0,108},{9,0,123},{7,10,1570},{140,10,542},{142,
-11,410},{9,11,660},{138,11,347}
-};
-/* GENERATED CODE END */
-
-}
-
-#endif  /* BROTLI_ENC_STATIC_DICT_LUT_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/utf8_util.cpp b/src/duckdb/third_party/brotli/enc/utf8_util.cpp
deleted file mode 100644
index ab4079f43..000000000
--- a/src/duckdb/third_party/brotli/enc/utf8_util.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Heuristics for deciding about the UTF8-ness of strings. */
-
-#include "utf8_util.h"
-
-#include <brotli/types.h>
-
-using namespace duckdb_brotli;
-
-static size_t BrotliParseAsUTF8(
-    int* symbol, const uint8_t* input, size_t size) {
-  /* ASCII */
-  if ((input[0] & 0x80) == 0) {
-    *symbol = input[0];
-    if (*symbol > 0) {
-      return 1;
-    }
-  }
-  /* 2-byte UTF8 */
-  if (size > 1u &&
-      (input[0] & 0xE0) == 0xC0 &&
-      (input[1] & 0xC0) == 0x80) {
-    *symbol = (((input[0] & 0x1F) << 6) |
-               (input[1] & 0x3F));
-    if (*symbol > 0x7F) {
-      return 2;
-    }
-  }
-  /* 3-byte UFT8 */
-  if (size > 2u &&
-      (input[0] & 0xF0) == 0xE0 &&
-      (input[1] & 0xC0) == 0x80 &&
-      (input[2] & 0xC0) == 0x80) {
-    *symbol = (((input[0] & 0x0F) << 12) |
-               ((input[1] & 0x3F) << 6) |
-               (input[2] & 0x3F));
-    if (*symbol > 0x7FF) {
-      return 3;
-    }
-  }
-  /* 4-byte UFT8 */
-  if (size > 3u &&
-      (input[0] & 0xF8) == 0xF0 &&
-      (input[1] & 0xC0) == 0x80 &&
-      (input[2] & 0xC0) == 0x80 &&
-      (input[3] & 0xC0) == 0x80) {
-    *symbol = (((input[0] & 0x07) << 18) |
-               ((input[1] & 0x3F) << 12) |
-               ((input[2] & 0x3F) << 6) |
-               (input[3] & 0x3F));
-    if (*symbol > 0xFFFF && *symbol <= 0x10FFFF) {
-      return 4;
-    }
-  }
-  /* Not UTF8, emit a special symbol above the UTF8-code space */
-  *symbol = 0x110000 | input[0];
-  return 1;
-}
-
-/* Returns 1 if at least min_fraction of the data is UTF8-encoded.*/
-BROTLI_BOOL duckdb_brotli::BrotliIsMostlyUTF8(
-    const uint8_t* data, const size_t pos, const size_t mask,
-    const size_t length, const double min_fraction) {
-  size_t size_utf8 = 0;
-  size_t i = 0;
-  while (i < length) {
-    int symbol;
-    size_t bytes_read =
-        BrotliParseAsUTF8(&symbol, &data[(pos + i) & mask], length - i);
-    i += bytes_read;
-    if (symbol < 0x110000) size_utf8 += bytes_read;
-  }
-  return TO_BROTLI_BOOL((double)size_utf8 > min_fraction * (double)length);
-}
-
-
diff --git a/src/duckdb/third_party/brotli/enc/utf8_util.h b/src/duckdb/third_party/brotli/enc/utf8_util.h
deleted file mode 100644
index 3f0315c2c..000000000
--- a/src/duckdb/third_party/brotli/enc/utf8_util.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Heuristics for deciding about the UTF8-ness of strings. */
-
-#ifndef BROTLI_ENC_UTF8_UTIL_H_
-#define BROTLI_ENC_UTF8_UTIL_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-static const double kMinUTF8Ratio = 0.75;
-
-/* Returns 1 if at least min_fraction of the bytes between pos and
-   pos + length in the (data, mask) ring-buffer is UTF8-encoded, otherwise
-   returns 0. */
-BROTLI_INTERNAL BROTLI_BOOL BrotliIsMostlyUTF8(
-    const uint8_t* data, const size_t pos, const size_t mask,
-    const size_t length, const double min_fraction);
-
-}
-
-#endif  /* BROTLI_ENC_UTF8_UTIL_H_ */
diff --git a/src/duckdb/third_party/brotli/enc/write_bits.h b/src/duckdb/third_party/brotli/enc/write_bits.h
deleted file mode 100644
index 5f46afa44..000000000
--- a/src/duckdb/third_party/brotli/enc/write_bits.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/* Copyright 2010 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Write bits into a byte array. */
-
-#ifndef BROTLI_ENC_WRITE_BITS_H_
-#define BROTLI_ENC_WRITE_BITS_H_
-
-#include <brotli/types.h>
-
-#include "../common/brotli_platform.h"
-
-namespace duckdb_brotli {
-
-/* This function writes bits into bytes in increasing addresses, and within
-   a byte least-significant-bit first.
-
-   The function can write up to 56 bits in one go with WriteBits
-   Example: let's assume that 3 bits (Rs below) have been written already:
-
-   BYTE-0     BYTE+1       BYTE+2
-
-   0000 0RRR    0000 0000    0000 0000
-
-   Now, we could write 5 or less bits in MSB by just shifting by 3
-   and OR'ing to BYTE-0.
-
-   For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
-   and locate the rest in BYTE+1, BYTE+2, etc. */
-static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
-                                          uint64_t bits,
-                                          size_t* BROTLI_RESTRICT pos,
-                                          uint8_t* BROTLI_RESTRICT array) {
-  BROTLI_LOG(("WriteBits  %2d  0x%08x%08x  %10d\n", (int)n_bits,
-      (uint32_t)(bits >> 32), (uint32_t)(bits & 0xFFFFFFFF),
-      (int)*pos));
-  BROTLI_DCHECK((bits >> n_bits) == 0);
-  BROTLI_DCHECK(n_bits <= 56);
-#if defined(BROTLI_LITTLE_ENDIAN)
-  /* This branch of the code can write up to 56 bits at a time,
-     7 bits are lost by being perhaps already in *p and at least
-     1 bit is needed to initialize the bit-stream ahead (i.e. if 7
-     bits are in *p and we write 57 bits, then the next write will
-     access a byte that was never initialized). */
-  {
-    uint8_t* p = &array[*pos >> 3];
-    uint64_t v = (uint64_t)(*p);  /* Zero-extend 8 to 64 bits. */
-    v |= bits << (*pos & 7);
-    BROTLI_UNALIGNED_STORE64LE(p, v);  /* Set some bits. */
-    *pos += n_bits;
-  }
-#else
-  /* implicit & 0xFF is assumed for uint8_t arithmetics */
-  {
-    uint8_t* array_pos = &array[*pos >> 3];
-    const size_t bits_reserved_in_first_byte = (*pos & 7);
-    size_t bits_left_to_write;
-    bits <<= bits_reserved_in_first_byte;
-    *array_pos++ |= (uint8_t)bits;
-    for (bits_left_to_write = n_bits + bits_reserved_in_first_byte;
-         bits_left_to_write >= 9;
-         bits_left_to_write -= 8) {
-      bits >>= 8;
-      *array_pos++ = (uint8_t)bits;
-    }
-    *array_pos = 0;
-    *pos += n_bits;
-  }
-#endif
-}
-
-static BROTLI_INLINE void BrotliWriteBitsPrepareStorage(
-    size_t pos, uint8_t* array) {
-  BROTLI_LOG(("WriteBitsPrepareStorage            %10d\n", (int)pos));
-  BROTLI_DCHECK((pos & 7) == 0);
-  array[pos >> 3] = 0;
-}
-
-}
-
-#endif  /* BROTLI_ENC_WRITE_BITS_H_ */
diff --git a/src/duckdb/third_party/brotli/include/brotli/decode.h b/src/duckdb/third_party/brotli/include/brotli/decode.h
deleted file mode 100644
index 2288009cf..000000000
--- a/src/duckdb/third_party/brotli/include/brotli/decode.h
+++ /dev/null
@@ -1,405 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/**
- * @file
- * API for Brotli decompression.
- */
-
-#ifndef BROTLI_DEC_DECODE_H_
-#define BROTLI_DEC_DECODE_H_
-
-#include <brotli/port.h>
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-/**
- * Opaque structure that holds decoder state.
- *
- * Allocated and initialized with ::BrotliDecoderCreateInstance.
- * Cleaned up and deallocated with ::BrotliDecoderDestroyInstance.
- */
-typedef struct BrotliDecoderStateStruct BrotliDecoderState;
-
-/**
- * Result type for ::BrotliDecoderDecompress and
- * ::BrotliDecoderDecompressStream functions.
- */
-typedef enum {
-  /** Decoding error, e.g. corrupted input or memory allocation problem. */
-  BROTLI_DECODER_RESULT_ERROR = 0,
-  /** Decoding successfully completed. */
-  BROTLI_DECODER_RESULT_SUCCESS = 1,
-  /** Partially done; should be called again with more input. */
-  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2,
-  /** Partially done; should be called again with more output. */
-  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3
-} BrotliDecoderResult;
-
-/**
- * Template that evaluates items of ::BrotliDecoderErrorCode.
- *
- * Example: @code {.cpp}
- * // Log Brotli error code.
- * switch (brotliDecoderErrorCode) {
- * #define CASE_(PREFIX, NAME, CODE) \
- *   case BROTLI_DECODER ## PREFIX ## NAME: \
- *     LOG(INFO) << "error code:" << #NAME; \
- *     break;
- * #define NEWLINE_
- * BROTLI_DECODER_ERROR_CODES_LIST(CASE_, NEWLINE_)
- * #undef CASE_
- * #undef NEWLINE_
- *   default: LOG(FATAL) << "unknown brotli error code";
- * }
- * @endcode
- */
-#define BROTLI_DECODER_ERROR_CODES_LIST(BROTLI_ERROR_CODE, SEPARATOR)      \
-  BROTLI_ERROR_CODE(_, NO_ERROR, 0) SEPARATOR                              \
-  /* Same as BrotliDecoderResult values */                                 \
-  BROTLI_ERROR_CODE(_, SUCCESS, 1) SEPARATOR                               \
-  BROTLI_ERROR_CODE(_, NEEDS_MORE_INPUT, 2) SEPARATOR                      \
-  BROTLI_ERROR_CODE(_, NEEDS_MORE_OUTPUT, 3) SEPARATOR                     \
-                                                                           \
-  /* Errors caused by invalid input */                                     \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_NIBBLE, -1) SEPARATOR        \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, RESERVED, -2) SEPARATOR                \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_META_NIBBLE, -3) SEPARATOR   \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_ALPHABET, -4) SEPARATOR \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_SAME, -5) SEPARATOR     \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, CL_SPACE, -6) SEPARATOR                \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, HUFFMAN_SPACE, -7) SEPARATOR           \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, CONTEXT_MAP_REPEAT, -8) SEPARATOR      \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_1, -9) SEPARATOR          \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_2, -10) SEPARATOR         \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, TRANSFORM, -11) SEPARATOR              \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, DICTIONARY, -12) SEPARATOR             \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, WINDOW_BITS, -13) SEPARATOR            \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR              \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR              \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, DISTANCE, -16) SEPARATOR               \
-                                                                           \
-  /* -17 code is reserved */                                               \
-                                                                           \
-  BROTLI_ERROR_CODE(_ERROR_, COMPOUND_DICTIONARY, -18) SEPARATOR           \
-  BROTLI_ERROR_CODE(_ERROR_, DICTIONARY_NOT_SET, -19) SEPARATOR            \
-  BROTLI_ERROR_CODE(_ERROR_, INVALID_ARGUMENTS, -20) SEPARATOR             \
-                                                                           \
-  /* Memory allocation problems */                                         \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MODES, -21) SEPARATOR           \
-  /* Literal, insert and distance trees together */                        \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, TREE_GROUPS, -22) SEPARATOR             \
-  /* -23..-24 codes are reserved for distinct tree groups */               \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MAP, -25) SEPARATOR             \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_1, -26) SEPARATOR           \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_2, -27) SEPARATOR           \
-  /* -28..-29 codes are reserved for dynamic ring-buffer allocation */     \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, BLOCK_TYPE_TREES, -30) SEPARATOR        \
-                                                                           \
-  /* "Impossible" states */                                                \
-  BROTLI_ERROR_CODE(_ERROR_, UNREACHABLE, -31)
-
-/**
- * Error code for detailed logging / production debugging.
- *
- * See ::BrotliDecoderGetErrorCode and ::BROTLI_LAST_ERROR_CODE.
- */
-typedef enum {
-#define BROTLI_COMMA_ ,
-#define BROTLI_ERROR_CODE_ENUM_ITEM_(PREFIX, NAME, CODE) \
-    BROTLI_DECODER ## PREFIX ## NAME = CODE
-  BROTLI_DECODER_ERROR_CODES_LIST(BROTLI_ERROR_CODE_ENUM_ITEM_, BROTLI_COMMA_)
-} BrotliDecoderErrorCode;
-#undef BROTLI_ERROR_CODE_ENUM_ITEM_
-#undef BROTLI_COMMA_
-
-/**
- * The value of the last error code, negative integer.
- *
- * All other error code values are in the range from ::BROTLI_LAST_ERROR_CODE
- * to @c -1. There are also 4 other possible non-error codes @c 0 .. @c 3 in
- * ::BrotliDecoderErrorCode enumeration.
- */
-#define BROTLI_LAST_ERROR_CODE BROTLI_DECODER_ERROR_UNREACHABLE
-
-/** Options to be used with ::BrotliDecoderSetParameter. */
-typedef enum BrotliDecoderParameter {
-  /**
-   * Disable "canny" ring buffer allocation strategy.
-   *
-   * Ring buffer is allocated according to window size, despite the real size of
-   * the content.
-   */
-  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0,
-  /**
-   * Flag that determines if "Large Window Brotli" is used.
-   */
-  BROTLI_DECODER_PARAM_LARGE_WINDOW = 1
-} BrotliDecoderParameter;
-
-/**
- * Sets the specified parameter to the given decoder instance.
- *
- * @param state decoder instance
- * @param param parameter to set
- * @param value new parameter value
- * @returns ::BROTLI_FALSE if parameter is unrecognized, or value is invalid
- * @returns ::BROTLI_TRUE if value is accepted
- */
-BROTLI_DEC_API BROTLI_BOOL BrotliDecoderSetParameter(
-    BrotliDecoderState* state, BrotliDecoderParameter param, uint32_t value);
-
-/**
- * Adds LZ77 prefix dictionary, adds or replaces built-in static dictionary and
- * transforms.
- *
- * Attached dictionary ownership is not transferred.
- * Data provided to this method should be kept accessible until
- * decoding is finished and decoder instance is destroyed.
- *
- * @note Dictionaries can NOT be attached after actual decoding is started.
- *
- * @param state decoder instance
- * @param type dictionary data format
- * @param data_size length of memory region pointed by @p data
- * @param data dictionary data in format corresponding to @p type
- * @returns ::BROTLI_FALSE if dictionary is corrupted,
- *          or dictionary count limit is reached
- * @returns ::BROTLI_TRUE if dictionary is accepted / attached
- */
-BROTLI_DEC_API BROTLI_BOOL BrotliDecoderAttachDictionary(
-    BrotliDecoderState* state, BrotliSharedDictionaryType type,
-    size_t data_size, const uint8_t data[BROTLI_ARRAY_PARAM(data_size)]);
-
-/**
- * Creates an instance of ::BrotliDecoderState and initializes it.
- *
- * The instance can be used once for decoding and should then be destroyed with
- * ::BrotliDecoderDestroyInstance, it cannot be reused for a new decoding
- * session.
- *
- * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the
- * case they are both zero, default memory allocators are used. @p opaque is
- * passed to @p alloc_func and @p free_func when they are called. @p free_func
- * has to return without doing anything when asked to free a NULL pointer.
- *
- * @param alloc_func custom memory allocation function
- * @param free_func custom memory free function
- * @param opaque custom memory manager handle
- * @returns @c 0 if instance can not be allocated or initialized
- * @returns pointer to initialized ::BrotliDecoderState otherwise
- */
-BROTLI_DEC_API BrotliDecoderState* BrotliDecoderCreateInstance(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
-
-/**
- * Deinitializes and frees ::BrotliDecoderState instance.
- *
- * @param state decoder instance to be cleaned up and deallocated
- */
-BROTLI_DEC_API void BrotliDecoderDestroyInstance(BrotliDecoderState* state);
-
-/**
- * Performs one-shot memory-to-memory decompression.
- *
- * Decompresses the data in @p encoded_buffer into @p decoded_buffer, and sets
- * @p *decoded_size to the decompressed length.
- *
- * @param encoded_size size of @p encoded_buffer
- * @param encoded_buffer compressed data buffer with at least @p encoded_size
- *        addressable bytes
- * @param[in, out] decoded_size @b in: size of @p decoded_buffer; \n
- *                 @b out: length of decompressed data written to
- *                 @p decoded_buffer
- * @param decoded_buffer decompressed data destination buffer
- * @returns ::BROTLI_DECODER_RESULT_ERROR if input is corrupted, memory
- *          allocation failed, or @p decoded_buffer is not large enough;
- * @returns ::BROTLI_DECODER_RESULT_SUCCESS otherwise
- */
-BROTLI_DEC_API BrotliDecoderResult BrotliDecoderDecompress(
-    size_t encoded_size,
-    const uint8_t encoded_buffer[BROTLI_ARRAY_PARAM(encoded_size)],
-    size_t* decoded_size,
-    uint8_t decoded_buffer[BROTLI_ARRAY_PARAM(*decoded_size)]);
-
-/**
- * Decompresses the input stream to the output stream.
- *
- * The values @p *available_in and @p *available_out must specify the number of
- * bytes addressable at @p *next_in and @p *next_out respectively.
- * When @p *available_out is @c 0, @p next_out is allowed to be @c NULL.
- *
- * After each call, @p *available_in will be decremented by the amount of input
- * bytes consumed, and the @p *next_in pointer will be incremented by that
- * amount. Similarly, @p *available_out will be decremented by the amount of
- * output bytes written, and the @p *next_out pointer will be incremented by
- * that amount.
- *
- * @p total_out, if it is not a null-pointer, will be set to the number
- * of bytes decompressed since the last @p state initialization.
- *
- * @note Input is never overconsumed, so @p next_in and @p available_in could be
- * passed to the next consumer after decoding is complete.
- *
- * @param state decoder instance
- * @param[in, out] available_in @b in: amount of available input; \n
- *                 @b out: amount of unused input
- * @param[in, out] next_in pointer to the next compressed byte
- * @param[in, out] available_out @b in: length of output buffer; \n
- *                 @b out: remaining size of output buffer
- * @param[in, out] next_out output buffer cursor;
- *                 can be @c NULL if @p available_out is @c 0
- * @param[out] total_out number of bytes decompressed so far; can be @c NULL
- * @returns ::BROTLI_DECODER_RESULT_ERROR if input is corrupted, memory
- *          allocation failed, arguments were invalid, etc.;
- *          use ::BrotliDecoderGetErrorCode to get detailed error code
- * @returns ::BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT decoding is blocked until
- *          more input data is provided
- * @returns ::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT decoding is blocked until
- *          more output space is provided
- * @returns ::BROTLI_DECODER_RESULT_SUCCESS decoding is finished, no more
- *          input might be consumed and no more output will be produced
- */
-BROTLI_DEC_API BrotliDecoderResult BrotliDecoderDecompressStream(
-  BrotliDecoderState* state, size_t* available_in, const uint8_t** next_in,
-  size_t* available_out, uint8_t** next_out, size_t* total_out);
-
-/**
- * Checks if decoder has more output.
- *
- * @param state decoder instance
- * @returns ::BROTLI_TRUE, if decoder has some unconsumed output
- * @returns ::BROTLI_FALSE otherwise
- */
-BROTLI_DEC_API BROTLI_BOOL BrotliDecoderHasMoreOutput(
-    const BrotliDecoderState* state);
-
-/**
- * Acquires pointer to internal output buffer.
- *
- * This method is used to make language bindings easier and more efficient:
- *  -# push data to ::BrotliDecoderDecompressStream,
- *     until ::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT is reported
- *  -# use ::BrotliDecoderTakeOutput to peek bytes and copy to language-specific
- *     entity
- *
- * Also this could be useful if there is an output stream that is able to
- * consume all the provided data (e.g. when data is saved to file system).
- *
- * @attention After every call to ::BrotliDecoderTakeOutput @p *size bytes of
- *            output are considered consumed for all consecutive calls to the
- *            instance methods; returned pointer becomes invalidated as well.
- *
- * @note Decoder output is not guaranteed to be contiguous. This means that
- *       after the size-unrestricted call to ::BrotliDecoderTakeOutput,
- *       immediate next call to ::BrotliDecoderTakeOutput may return more data.
- *
- * @param state decoder instance
- * @param[in, out] size @b in: number of bytes caller is ready to take, @c 0 if
- *                 any amount could be handled; \n
- *                 @b out: amount of data pointed by returned pointer and
- *                 considered consumed; \n
- *                 out value is never greater than in value, unless it is @c 0
- * @returns pointer to output data
- */
-BROTLI_DEC_API const uint8_t* BrotliDecoderTakeOutput(
-    BrotliDecoderState* state, size_t* size);
-
-/**
- * Checks if instance has already consumed input.
- *
- * Instance that returns ::BROTLI_FALSE is considered "fresh" and could be
- * reused.
- *
- * @param state decoder instance
- * @returns ::BROTLI_TRUE if decoder has already used some input bytes
- * @returns ::BROTLI_FALSE otherwise
- */
-BROTLI_DEC_API BROTLI_BOOL BrotliDecoderIsUsed(const BrotliDecoderState* state);
-
-/**
- * Checks if decoder instance reached the final state.
- *
- * @param state decoder instance
- * @returns ::BROTLI_TRUE if decoder is in a state where it reached the end of
- *          the input and produced all of the output
- * @returns ::BROTLI_FALSE otherwise
- */
-BROTLI_DEC_API BROTLI_BOOL BrotliDecoderIsFinished(
-    const BrotliDecoderState* state);
-
-/**
- * Acquires a detailed error code.
- *
- * Should be used only after ::BrotliDecoderDecompressStream returns
- * ::BROTLI_DECODER_RESULT_ERROR.
- *
- * See also ::BrotliDecoderErrorString
- *
- * @param state decoder instance
- * @returns last saved error code
- */
-BROTLI_DEC_API BrotliDecoderErrorCode BrotliDecoderGetErrorCode(
-    const BrotliDecoderState* state);
-
-/**
- * Converts error code to a c-string.
- */
-BROTLI_DEC_API const char* BrotliDecoderErrorString(BrotliDecoderErrorCode c);
-
-/**
- * Gets a decoder library version.
- *
- * Look at BROTLI_MAKE_HEX_VERSION for more information.
- */
-BROTLI_DEC_API uint32_t BrotliDecoderVersion(void);
-
-/**
- * Callback to fire on metadata block start.
- *
- * After this callback is fired, if @p size is not @c 0, it is followed by
- * ::brotli_decoder_metadata_chunk_func as more metadata block contents become
- * accessible.
- *
- * @param opaque callback handle
- * @param size size of metadata block
- */
-typedef void (*brotli_decoder_metadata_start_func)(void* opaque, size_t size);
-
-/**
- * Callback to fire on metadata block chunk becomes available.
- *
- * This function can be invoked multiple times per metadata block; block should
- * be considered finished when sum of @p size matches the announced metadata
- * block size. Chunks contents pointed by @p data are transient and shouln not
- * be accessed after leaving the callback.
- *
- * @param opaque callback handle
- * @param data pointer to metadata contents
- * @param size size of metadata block chunk, at least @c 1
- */
-typedef void (*brotli_decoder_metadata_chunk_func)(void* opaque,
-                                                   const uint8_t* data,
-                                                   size_t size);
-
-/**
- * Sets callback for receiving metadata blocks.
- *
- * @param state decoder instance
- * @param start_func callback on metadata block start
- * @param chunk_func callback on metadata block chunk
- * @param opaque callback handle
- */
-BROTLI_DEC_API void BrotliDecoderSetMetadataCallbacks(
-    BrotliDecoderState* state,
-    brotli_decoder_metadata_start_func start_func,
-    brotli_decoder_metadata_chunk_func chunk_func, void* opaque);
-
-}
-
-#endif  /* BROTLI_DEC_DECODE_H_ */
diff --git a/src/duckdb/third_party/brotli/include/brotli/encode.h b/src/duckdb/third_party/brotli/include/brotli/encode.h
deleted file mode 100644
index e3c3f55ed..000000000
--- a/src/duckdb/third_party/brotli/include/brotli/encode.h
+++ /dev/null
@@ -1,489 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/**
- * @file
- * API for Brotli compression.
- */
-
-#ifndef BROTLI_ENC_ENCODE_H_
-#define BROTLI_ENC_ENCODE_H_
-
-#include <brotli/port.h>
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-
-/** Minimal value for ::BROTLI_PARAM_LGWIN parameter. */
-#define BROTLI_MIN_WINDOW_BITS 10
-/**
- * Maximal value for ::BROTLI_PARAM_LGWIN parameter.
- *
- * @note equal to @c BROTLI_MAX_DISTANCE_BITS constant.
- */
-#define BROTLI_MAX_WINDOW_BITS 24
-/**
- * Maximal value for ::BROTLI_PARAM_LGWIN parameter
- * in "Large Window Brotli" (32-bit).
- */
-#define BROTLI_LARGE_MAX_WINDOW_BITS 30
-/** Minimal value for ::BROTLI_PARAM_LGBLOCK parameter. */
-#define BROTLI_MIN_INPUT_BLOCK_BITS 16
-/** Maximal value for ::BROTLI_PARAM_LGBLOCK parameter. */
-#define BROTLI_MAX_INPUT_BLOCK_BITS 24
-/** Minimal value for ::BROTLI_PARAM_QUALITY parameter. */
-#define BROTLI_MIN_QUALITY 0
-/** Maximal value for ::BROTLI_PARAM_QUALITY parameter. */
-#define BROTLI_MAX_QUALITY 11
-
-/** Options for ::BROTLI_PARAM_MODE parameter. */
-typedef enum BrotliEncoderMode {
-	/**
-   * Default compression mode.
-   *
-   * In this mode compressor does not know anything in advance about the
-   * properties of the input.
-	 */
-	BROTLI_MODE_GENERIC = 0,
-	/** Compression mode for UTF-8 formatted text input. */
-	BROTLI_MODE_TEXT = 1,
-	/** Compression mode used in WOFF 2.0. */
-	BROTLI_MODE_FONT = 2
-} BrotliEncoderMode;
-
-namespace duckdb_brotli {
-
-
-/** Default value for ::BROTLI_PARAM_QUALITY parameter. */
-#define BROTLI_DEFAULT_QUALITY 11
-/** Default value for ::BROTLI_PARAM_LGWIN parameter. */
-#define BROTLI_DEFAULT_WINDOW 22
-/** Default value for ::BROTLI_PARAM_MODE parameter. */
-#define BROTLI_DEFAULT_MODE BROTLI_MODE_GENERIC
-
-/** Operations that can be performed by streaming encoder. */
-typedef enum BrotliEncoderOperation {
-	/**
-   * Process input.
-   *
-   * Encoder may postpone producing output, until it has processed enough input.
-	 */
-	BROTLI_OPERATION_PROCESS = 0,
-	/**
-   * Produce output for all processed input.
-   *
-   * Actual flush is performed when input stream is depleted and there is enough
-   * space in output stream. This means that client should repeat
-   * ::BROTLI_OPERATION_FLUSH operation until @p available_in becomes @c 0, and
-   * ::BrotliEncoderHasMoreOutput returns ::BROTLI_FALSE. If output is acquired
-   * via ::BrotliEncoderTakeOutput, then operation should be repeated after
-   * output buffer is drained.
-   *
-   * @warning Until flush is complete, client @b SHOULD @b NOT swap,
-   *          reduce or extend input stream.
-   *
-   * When flush is complete, output data will be sufficient for decoder to
-   * reproduce all the given input.
-	 */
-	BROTLI_OPERATION_FLUSH = 1,
-	/**
-   * Finalize the stream.
-   *
-   * Actual finalization is performed when input stream is depleted and there is
-   * enough space in output stream. This means that client should repeat
-   * ::BROTLI_OPERATION_FINISH operation until @p available_in becomes @c 0, and
-   * ::BrotliEncoderHasMoreOutput returns ::BROTLI_FALSE. If output is acquired
-   * via ::BrotliEncoderTakeOutput, then operation should be repeated after
-   * output buffer is drained.
-   *
-   * @warning Until finalization is complete, client @b SHOULD @b NOT swap,
-   *          reduce or extend input stream.
-   *
-   * Helper function ::BrotliEncoderIsFinished checks if stream is finalized and
-   * output fully dumped.
-   *
-   * Adding more input data to finalized stream is impossible.
-	 */
-	BROTLI_OPERATION_FINISH = 2,
-	/**
-   * Emit metadata block to stream.
-   *
-   * Metadata is opaque to Brotli: neither encoder, nor decoder processes this
-   * data or relies on it. It may be used to pass some extra information from
-   * encoder client to decoder client without interfering with main data stream.
-   *
-   * @note Encoder may emit empty metadata blocks internally, to pad encoded
-   *       stream to byte boundary.
-   *
-   * @warning Until emitting metadata is complete client @b SHOULD @b NOT swap,
-   *          reduce or extend input stream.
-   *
-   * @warning The whole content of input buffer is considered to be the content
-   *          of metadata block. Do @b NOT @e append metadata to input stream,
-   *          before it is depleted with other operations.
-   *
-   * Stream is soft-flushed before metadata block is emitted. Metadata block
-   * @b MUST be no longer than than 16MiB.
-	 */
-	BROTLI_OPERATION_EMIT_METADATA = 3
-} BrotliEncoderOperation;
-
-/** Options to be used with ::BrotliEncoderSetParameter. */
-typedef enum BrotliEncoderParameter {
-	/**
-   * Tune encoder for specific input.
-   *
-   * ::BrotliEncoderMode enumerates all available values.
-	 */
-	BROTLI_PARAM_MODE = 0,
-	/**
-   * The main compression speed-density lever.
-   *
-   * The higher the quality, the slower the compression. Range is
-   * from ::BROTLI_MIN_QUALITY to ::BROTLI_MAX_QUALITY.
-	 */
-	BROTLI_PARAM_QUALITY = 1,
-	/**
-   * Recommended sliding LZ77 window size.
-   *
-   * Encoder may reduce this value, e.g. if input is much smaller than
-   * window size.
-   *
-   * Window size is `(1 << value) - 16`.
-   *
-   * Range is from ::BROTLI_MIN_WINDOW_BITS to ::BROTLI_MAX_WINDOW_BITS.
-	 */
-	BROTLI_PARAM_LGWIN = 2,
-	/**
-   * Recommended input block size.
-   *
-   * Encoder may reduce this value, e.g. if input is much smaller than input
-   * block size.
-   *
-   * Range is from ::BROTLI_MIN_INPUT_BLOCK_BITS to
-   * ::BROTLI_MAX_INPUT_BLOCK_BITS.
-   *
-   * @note Bigger input block size allows better compression, but consumes more
-   *       memory. \n The rough formula of memory used for temporary input
-   *       storage is `3 << lgBlock`.
-	 */
-	BROTLI_PARAM_LGBLOCK = 3,
-	/**
-   * Flag that affects usage of "literal context modeling" format feature.
-   *
-   * This flag is a "decoding-speed vs compression ratio" trade-off.
-	 */
-	BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING = 4,
-	/**
-   * Estimated total input size for all ::BrotliEncoderCompressStream calls.
-   *
-   * The default value is 0, which means that the total input size is unknown.
-	 */
-	BROTLI_PARAM_SIZE_HINT = 5,
-	/**
-   * Flag that determines if "Large Window Brotli" is used.
-	 */
-	BROTLI_PARAM_LARGE_WINDOW = 6,
-	/**
-   * Recommended number of postfix bits (NPOSTFIX).
-   *
-   * Encoder may change this value.
-   *
-   * Range is from 0 to ::BROTLI_MAX_NPOSTFIX.
-	 */
-	BROTLI_PARAM_NPOSTFIX = 7,
-	/**
-   * Recommended number of direct distance codes (NDIRECT).
-   *
-   * Encoder may change this value.
-   *
-   * Range is from 0 to (15 << NPOSTFIX) in steps of (1 << NPOSTFIX).
-	 */
-	BROTLI_PARAM_NDIRECT = 8,
-	/**
-   * Number of bytes of input stream already processed by a different instance.
-   *
-   * @note It is important to configure all the encoder instances with same
-   *       parameters (except this one) in order to allow all the encoded parts
-   *       obey the same restrictions implied by header.
-   *
-   * If offset is not 0, then stream header is omitted.
-   * In any case output start is byte aligned, so for proper streams stitching
-   * "predecessor" stream must be flushed.
-   *
-   * Range is not artificially limited, but all the values greater or equal to
-   * maximal window size have the same effect. Values greater than 2**30 are not
-   * allowed.
-	 */
-	BROTLI_PARAM_STREAM_OFFSET = 9
-} BrotliEncoderParameter;
-
-/**
- * Opaque structure that holds encoder state.
- *
- * Allocated and initialized with ::BrotliEncoderCreateInstance.
- * Cleaned up and deallocated with ::BrotliEncoderDestroyInstance.
- */
-typedef struct BrotliEncoderStateStruct BrotliEncoderState;
-
-/**
- * Sets the specified parameter to the given encoder instance.
- *
- * @param state encoder instance
- * @param param parameter to set
- * @param value new parameter value
- * @returns ::BROTLI_FALSE if parameter is unrecognized, or value is invalid
- * @returns ::BROTLI_FALSE if value of parameter can not be changed at current
- *          encoder state (e.g. when encoding is started, window size might be
- *          already encoded and therefore it is impossible to change it)
- * @returns ::BROTLI_TRUE if value is accepted
- * @warning invalid values might be accepted in case they would not break
- *          encoding process.
- */
-BROTLI_ENC_API BROTLI_BOOL BrotliEncoderSetParameter(BrotliEncoderState *state, BrotliEncoderParameter param,
-                                                     uint32_t value);
-
-/**
- * Creates an instance of ::BrotliEncoderState and initializes it.
- *
- * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the
- * case they are both zero, default memory allocators are used. @p opaque is
- * passed to @p alloc_func and @p free_func when they are called. @p free_func
- * has to return without doing anything when asked to free a NULL pointer.
- *
- * @param alloc_func custom memory allocation function
- * @param free_func custom memory free function
- * @param opaque custom memory manager handle
- * @returns @c 0 if instance can not be allocated or initialized
- * @returns pointer to initialized ::BrotliEncoderState otherwise
- */
-BROTLI_ENC_API BrotliEncoderState *BrotliEncoderCreateInstance(brotli_alloc_func alloc_func, brotli_free_func free_func,
-                                                               void *opaque);
-
-/**
- * Deinitializes and frees ::BrotliEncoderState instance.
- *
- * @param state decoder instance to be cleaned up and deallocated
- */
-BROTLI_ENC_API void BrotliEncoderDestroyInstance(BrotliEncoderState *state);
-
-/* Opaque type for pointer to different possible internal structures containing
-   dictionary prepared for the encoder */
-typedef struct BrotliEncoderPreparedDictionaryStruct BrotliEncoderPreparedDictionary;
-
-/**
- * Prepares a shared dictionary from the given file format for the encoder.
- *
- * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the
- * case they are both zero, default memory allocators are used. @p opaque is
- * passed to @p alloc_func and @p free_func when they are called. @p free_func
- * has to return without doing anything when asked to free a NULL pointer.
- *
- * @param type type of dictionary stored in data
- * @param data_size size of @p data buffer
- * @param data pointer to the dictionary data
- * @param quality the maximum Brotli quality to prepare the dictionary for,
- *        use BROTLI_MAX_QUALITY by default
- * @param alloc_func custom memory allocation function
- * @param free_func custom memory free function
- * @param opaque custom memory manager handle
- */
-BROTLI_ENC_API BrotliEncoderPreparedDictionary *
-BrotliEncoderPrepareDictionary(BrotliSharedDictionaryType type, size_t data_size,
-                               const uint8_t data[BROTLI_ARRAY_PARAM(data_size)], int quality,
-                               brotli_alloc_func alloc_func, brotli_free_func free_func, void *opaque);
-
-BROTLI_ENC_API void BrotliEncoderDestroyPreparedDictionary(BrotliEncoderPreparedDictionary *dictionary);
-
-/**
- * Attaches a prepared dictionary of any type to the encoder. Can be used
- * multiple times to attach multiple dictionaries. The dictionary type was
- * determined by BrotliEncoderPrepareDictionary. Multiple raw prefix
- * dictionaries and/or max 1 serialized dictionary with custom words can be
- * attached.
- *
- * @returns ::BROTLI_FALSE in case of error
- * @returns ::BROTLI_TRUE otherwise
- */
-BROTLI_ENC_API BROTLI_BOOL BrotliEncoderAttachPreparedDictionary(BrotliEncoderState *state,
-                                                                 const BrotliEncoderPreparedDictionary *dictionary);
-
-/**
- * Calculates the output size bound for the given @p input_size.
- *
- * @warning Result is only valid if quality is at least @c 2 and, in
- *          case ::BrotliEncoderCompressStream was used, no flushes
- *          (::BROTLI_OPERATION_FLUSH) were performed.
- *
- * @param input_size size of projected input
- * @returns @c 0 if result does not fit @c size_t
- */
-BROTLI_ENC_API size_t BrotliEncoderMaxCompressedSize(size_t input_size);
-
-/**
- * Performs one-shot memory-to-memory compression.
- *
- * Compresses the data in @p input_buffer into @p encoded_buffer, and sets
- * @p *encoded_size to the compressed length.
- *
- * @note If ::BrotliEncoderMaxCompressedSize(@p input_size) returns non-zero
- *       value, then output is guaranteed to be no longer than that.
- *
- * @note If @p lgwin is greater than ::BROTLI_MAX_WINDOW_BITS then resulting
- *       stream might be incompatible with RFC 7932; to decode such streams,
- *       decoder should be configured with
- *       ::BROTLI_DECODER_PARAM_LARGE_WINDOW = @c 1
- *
- * @param quality quality parameter value, e.g. ::BROTLI_DEFAULT_QUALITY
- * @param lgwin lgwin parameter value, e.g. ::BROTLI_DEFAULT_WINDOW
- * @param mode mode parameter value, e.g. ::BROTLI_DEFAULT_MODE
- * @param input_size size of @p input_buffer
- * @param input_buffer input data buffer with at least @p input_size
- *        addressable bytes
- * @param[in, out] encoded_size @b in: size of @p encoded_buffer; \n
- *                 @b out: length of compressed data written to
- *                 @p encoded_buffer, or @c 0 if compression fails
- * @param encoded_buffer compressed data destination buffer
- * @returns ::BROTLI_FALSE in case of compression error
- * @returns ::BROTLI_FALSE if output buffer is too small
- * @returns ::BROTLI_TRUE otherwise
- */
-BROTLI_ENC_API BROTLI_BOOL BrotliEncoderCompress(int quality, int lgwin, BrotliEncoderMode mode, size_t input_size,
-                                                 const uint8_t input_buffer[BROTLI_ARRAY_PARAM(input_size)],
-                                                 size_t *encoded_size,
-                                                 uint8_t encoded_buffer[BROTLI_ARRAY_PARAM(*encoded_size)]);
-
-/**
- * Compresses input stream to output stream.
- *
- * The values @p *available_in and @p *available_out must specify the number of
- * bytes addressable at @p *next_in and @p *next_out respectively.
- * When @p *available_out is @c 0, @p next_out is allowed to be @c NULL.
- *
- * After each call, @p *available_in will be decremented by the amount of input
- * bytes consumed, and the @p *next_in pointer will be incremented by that
- * amount. Similarly, @p *available_out will be decremented by the amount of
- * output bytes written, and the @p *next_out pointer will be incremented by
- * that amount.
- *
- * @p total_out, if it is not a null-pointer, will be set to the number
- * of bytes compressed since the last @p state initialization.
- *
- *
- *
- * Internally workflow consists of 3 tasks:
- *  -# (optionally) copy input data to internal buffer
- *  -# actually compress data and (optionally) store it to internal buffer
- *  -# (optionally) copy compressed bytes from internal buffer to output stream
- *
- * Whenever all 3 tasks can't move forward anymore, or error occurs, this
- * method returns the control flow to caller.
- *
- * @p op is used to perform flush, finish the stream, or inject metadata block.
- * See ::BrotliEncoderOperation for more information.
- *
- * Flushing the stream means forcing encoding of all input passed to encoder and
- * completing the current output block, so it could be fully decoded by stream
- * decoder. To perform flush set @p op to ::BROTLI_OPERATION_FLUSH.
- * Under some circumstances (e.g. lack of output stream capacity) this operation
- * would require several calls to ::BrotliEncoderCompressStream. The method must
- * be called again until both input stream is depleted and encoder has no more
- * output (see ::BrotliEncoderHasMoreOutput) after the method is called.
- *
- * Finishing the stream means encoding of all input passed to encoder and
- * adding specific "final" marks, so stream decoder could determine that stream
- * is complete. To perform finish set @p op to ::BROTLI_OPERATION_FINISH.
- * Under some circumstances (e.g. lack of output stream capacity) this operation
- * would require several calls to ::BrotliEncoderCompressStream. The method must
- * be called again until both input stream is depleted and encoder has no more
- * output (see ::BrotliEncoderHasMoreOutput) after the method is called.
- *
- * @warning When flushing and finishing, @p op should not change until operation
- *          is complete; input stream should not be swapped, reduced or
- *          extended as well.
- *
- * @param state encoder instance
- * @param op requested operation
- * @param[in, out] available_in @b in: amount of available input; \n
- *                 @b out: amount of unused input
- * @param[in, out] next_in pointer to the next input byte
- * @param[in, out] available_out @b in: length of output buffer; \n
- *                 @b out: remaining size of output buffer
- * @param[in, out] next_out compressed output buffer cursor;
- *                 can be @c NULL if @p available_out is @c 0
- * @param[out] total_out number of bytes produced so far; can be @c NULL
- * @returns ::BROTLI_FALSE if there was an error
- * @returns ::BROTLI_TRUE otherwise
- */
-BROTLI_ENC_API BROTLI_BOOL BrotliEncoderCompressStream(BrotliEncoderState *state, BrotliEncoderOperation op,
-                                                       size_t *available_in, const uint8_t **next_in,
-                                                       size_t *available_out, uint8_t **next_out, size_t *total_out);
-
-/**
- * Checks if encoder instance reached the final state.
- *
- * @param state encoder instance
- * @returns ::BROTLI_TRUE if encoder is in a state where it reached the end of
- *          the input and produced all of the output
- * @returns ::BROTLI_FALSE otherwise
- */
-BROTLI_ENC_API BROTLI_BOOL BrotliEncoderIsFinished(BrotliEncoderState *state);
-
-/**
- * Checks if encoder has more output.
- *
- * @param state encoder instance
- * @returns ::BROTLI_TRUE, if encoder has some unconsumed output
- * @returns ::BROTLI_FALSE otherwise
- */
-BROTLI_ENC_API BROTLI_BOOL BrotliEncoderHasMoreOutput(BrotliEncoderState *state);
-
-/**
- * Acquires pointer to internal output buffer.
- *
- * This method is used to make language bindings easier and more efficient:
- *  -# push data to ::BrotliEncoderCompressStream,
- *     until ::BrotliEncoderHasMoreOutput returns BROTLI_TRUE
- *  -# use ::BrotliEncoderTakeOutput to peek bytes and copy to language-specific
- *     entity
- *
- * Also this could be useful if there is an output stream that is able to
- * consume all the provided data (e.g. when data is saved to file system).
- *
- * @attention After every call to ::BrotliEncoderTakeOutput @p *size bytes of
- *            output are considered consumed for all consecutive calls to the
- *            instance methods; returned pointer becomes invalidated as well.
- *
- * @note Encoder output is not guaranteed to be contiguous. This means that
- *       after the size-unrestricted call to ::BrotliEncoderTakeOutput,
- *       immediate next call to ::BrotliEncoderTakeOutput may return more data.
- *
- * @param state encoder instance
- * @param[in, out] size @b in: number of bytes caller is ready to take, @c 0 if
- *                 any amount could be handled; \n
- *                 @b out: amount of data pointed by returned pointer and
- *                 considered consumed; \n
- *                 out value is never greater than in value, unless it is @c 0
- * @returns pointer to output data
- */
-BROTLI_ENC_API const uint8_t *BrotliEncoderTakeOutput(BrotliEncoderState *state, size_t *size);
-
-/* Returns the estimated peak memory usage (in bytes) of the BrotliCompress()
-   function, not counting the memory needed for the input and output. */
-BROTLI_ENC_EXTRA_API size_t BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin, size_t input_size);
-/* Returns 0 if dictionary is not valid; otherwise returns allocation size. */
-BROTLI_ENC_EXTRA_API size_t BrotliEncoderGetPreparedDictionarySize(const BrotliEncoderPreparedDictionary *dictionary);
-
-/**
- * Gets an encoder library version.
- *
- * Look at BROTLI_MAKE_HEX_VERSION for more information.
- */
-BROTLI_ENC_API uint32_t BrotliEncoderVersion(void);
-
-}
-
-#endif  /* BROTLI_ENC_ENCODE_H_ */
diff --git a/src/duckdb/third_party/brotli/include/brotli/port.h b/src/duckdb/third_party/brotli/include/brotli/port.h
deleted file mode 100644
index d92fcd4c6..000000000
--- a/src/duckdb/third_party/brotli/include/brotli/port.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Macros for compiler / platform specific API declarations. */
-
-#ifndef BROTLI_COMMON_PORT_H_
-#define BROTLI_COMMON_PORT_H_
-
-/* The following macros were borrowed from https://github.com/nemequ/hedley
- * with permission of original author - Evan Nemerson <evan@nemerson.com> */
-
-/* >>> >>> >>> hedley macros */
-
-#define BROTLI_MAKE_VERSION(major, minor, revision) \
-  (((major) * 1000000) + ((minor) * 1000) + (revision))
-
-#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
-#define BROTLI_GNUC_VERSION \
-  BROTLI_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#elif defined(__GNUC__)
-#define BROTLI_GNUC_VERSION BROTLI_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, 0)
-#endif
-
-#if defined(BROTLI_GNUC_VERSION)
-#define BROTLI_GNUC_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_GNUC_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_GNUC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
-#define BROTLI_MSVC_VERSION                                \
-  BROTLI_MAKE_VERSION((_MSC_FULL_VER / 10000000),          \
-                      (_MSC_FULL_VER % 10000000) / 100000, \
-                      (_MSC_FULL_VER % 100000) / 100)
-#elif defined(_MSC_FULL_VER)
-#define BROTLI_MSVC_VERSION                              \
-  BROTLI_MAKE_VERSION((_MSC_FULL_VER / 1000000),         \
-                      (_MSC_FULL_VER % 1000000) / 10000, \
-                      (_MSC_FULL_VER % 10000) / 10)
-#elif defined(_MSC_VER)
-#define BROTLI_MSVC_VERSION \
-  BROTLI_MAKE_VERSION(_MSC_VER / 100, _MSC_VER % 100, 0)
-#endif
-
-#if !defined(_MSC_VER)
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) (0)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
-  (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
-#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
-  (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
-#else
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
-  (_MSC_VER >= ((major * 100) + (minor)))
-#endif
-
-#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
-#define BROTLI_INTEL_VERSION                   \
-  BROTLI_MAKE_VERSION(__INTEL_COMPILER / 100,  \
-                      __INTEL_COMPILER % 100,  \
-                      __INTEL_COMPILER_UPDATE)
-#elif defined(__INTEL_COMPILER)
-#define BROTLI_INTEL_VERSION \
-  BROTLI_MAKE_VERSION(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
-#endif
-
-#if defined(BROTLI_INTEL_VERSION)
-#define BROTLI_INTEL_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_INTEL_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_INTEL_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__PGI) && \
-    defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
-#define BROTLI_PGI_VERSION \
-  BROTLI_MAKE_VERSION(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
-#endif
-
-#if defined(BROTLI_PGI_VERSION)
-#define BROTLI_PGI_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_PGI_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_PGI_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
-#define BROTLI_SUNPRO_VERSION                                       \
-  BROTLI_MAKE_VERSION(                                              \
-    (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \
-    (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf),   \
-    (__SUNPRO_C & 0xf) * 10)
-#elif defined(__SUNPRO_C)
-#define BROTLI_SUNPRO_VERSION                  \
-  BROTLI_MAKE_VERSION((__SUNPRO_C >> 8) & 0xf, \
-                      (__SUNPRO_C >> 4) & 0xf, \
-                      (__SUNPRO_C) & 0xf)
-#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
-#define BROTLI_SUNPRO_VERSION                                         \
-  BROTLI_MAKE_VERSION(                                                \
-    (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \
-    (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf),   \
-    (__SUNPRO_CC & 0xf) * 10)
-#elif defined(__SUNPRO_CC)
-#define BROTLI_SUNPRO_VERSION                   \
-  BROTLI_MAKE_VERSION((__SUNPRO_CC >> 8) & 0xf, \
-                      (__SUNPRO_CC >> 4) & 0xf, \
-                      (__SUNPRO_CC) & 0xf)
-#endif
-
-#if defined(BROTLI_SUNPRO_VERSION)
-#define BROTLI_SUNPRO_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_SUNPRO_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_SUNPRO_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
-#define BROTLI_ARM_VERSION                                       \
-  BROTLI_MAKE_VERSION((__ARMCOMPILER_VERSION / 1000000),         \
-                      (__ARMCOMPILER_VERSION % 1000000) / 10000, \
-                      (__ARMCOMPILER_VERSION % 10000) / 100)
-#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
-#define BROTLI_ARM_VERSION                                 \
-  BROTLI_MAKE_VERSION((__ARMCC_VERSION / 1000000),         \
-                      (__ARMCC_VERSION % 1000000) / 10000, \
-                      (__ARMCC_VERSION % 10000) / 100)
-#endif
-
-#if defined(BROTLI_ARM_VERSION)
-#define BROTLI_ARM_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_ARM_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_ARM_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__ibmxl__)
-#define BROTLI_IBM_VERSION                    \
-  BROTLI_MAKE_VERSION(__ibmxl_version__,      \
-                      __ibmxl_release__,      \
-                      __ibmxl_modification__)
-#elif defined(__xlC__) && defined(__xlC_ver__)
-#define BROTLI_IBM_VERSION \
-  BROTLI_MAKE_VERSION(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
-#elif defined(__xlC__)
-#define BROTLI_IBM_VERSION BROTLI_MAKE_VERSION(__xlC__ >> 8, __xlC__ & 0xff, 0)
-#endif
-
-#if defined(BROTLI_IBM_VERSION)
-#define BROTLI_IBM_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_IBM_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_IBM_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__TI_COMPILER_VERSION__)
-#define BROTLI_TI_VERSION                                         \
-  BROTLI_MAKE_VERSION((__TI_COMPILER_VERSION__ / 1000000),        \
-                      (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
-                      (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(BROTLI_TI_VERSION)
-#define BROTLI_TI_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_TI_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_TI_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__IAR_SYSTEMS_ICC__)
-#if __VER__ > 1000
-#define BROTLI_IAR_VERSION                     \
-  BROTLI_MAKE_VERSION((__VER__ / 1000000),     \
-                      (__VER__ / 1000) % 1000, \
-                      (__VER__ % 1000))
-#else
-#define BROTLI_IAR_VERSION BROTLI_MAKE_VERSION(VER / 100, __VER__ % 100, 0)
-#endif
-#endif
-
-#if defined(BROTLI_IAR_VERSION)
-#define BROTLI_IAR_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_IAR_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_IAR_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__TINYC__)
-#define BROTLI_TINYC_VERSION \
-  BROTLI_MAKE_VERSION(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
-#endif
-
-#if defined(BROTLI_TINYC_VERSION)
-#define BROTLI_TINYC_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_TINYC_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_TINYC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__has_attribute)
-#define BROTLI_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
-  __has_attribute(attribute)
-#else
-#define BROTLI_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
-  BROTLI_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(__has_builtin)
-#define BROTLI_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
-  __has_builtin(builtin)
-#else
-#define BROTLI_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
-  BROTLI_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(__has_feature)
-#define BROTLI_HAS_FEATURE(feature) __has_feature(feature)
-#else
-#define BROTLI_HAS_FEATURE(feature) (0)
-#endif
-
-
-
-#define BROTLI_PUBLIC
-#define BROTLI_INTERNAL
-#define BROTLI_ARRAY_PARAM(name)
-#define BROTLI_COMMON_API
-#define BROTLI_DEC_API
-#define BROTLI_ENC_API
-#define BROTLI_ENC_EXTRA_API BROTLI_INTERNAL
-
-
-#endif  /* BROTLI_COMMON_PORT_H_ */
diff --git a/src/duckdb/third_party/brotli/include/brotli/shared_dictionary.h b/src/duckdb/third_party/brotli/include/brotli/shared_dictionary.h
deleted file mode 100644
index 19267536e..000000000
--- a/src/duckdb/third_party/brotli/include/brotli/shared_dictionary.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Copyright 2017 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* (Opaque) Shared Dictionary definition and utilities. */
-
-#ifndef BROTLI_COMMON_SHARED_DICTIONARY_H_
-#define BROTLI_COMMON_SHARED_DICTIONARY_H_
-
-#include <brotli/port.h>
-#include <brotli/types.h>
-
-namespace duckdb_brotli {
-
-#define SHARED_BROTLI_MIN_DICTIONARY_WORD_LENGTH 4
-#define SHARED_BROTLI_MAX_DICTIONARY_WORD_LENGTH 31
-#define SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS 64
-#define SHARED_BROTLI_MAX_COMPOUND_DICTS 15
-
-/**
- * Opaque structure that holds shared dictionary data.
- *
- * Allocated and initialized with ::BrotliSharedDictionaryCreateInstance.
- * Cleaned up and deallocated with ::BrotliSharedDictionaryDestroyInstance.
- */
-typedef struct BrotliSharedDictionaryStruct BrotliSharedDictionary;
-
-/**
- * Input data type for ::BrotliSharedDictionaryAttach.
- */
-typedef enum BrotliSharedDictionaryType {
-  /** Raw LZ77 prefix dictionary. */
-  BROTLI_SHARED_DICTIONARY_RAW = 0,
-  /** Serialized shared dictionary.
-   *
-   * DO NOT USE: methods accepting this value will fail.
-   */
-  BROTLI_SHARED_DICTIONARY_SERIALIZED = 1
-} BrotliSharedDictionaryType;
-
-/**
- * Creates an instance of ::BrotliSharedDictionary.
- *
- * Fresh instance has default word dictionary and transforms
- * and no LZ77 prefix dictionary.
- *
- * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the
- * case they are both zero, default memory allocators are used. @p opaque is
- * passed to @p alloc_func and @p free_func when they are called. @p free_func
- * has to return without doing anything when asked to free a NULL pointer.
- *
- * @param alloc_func custom memory allocation function
- * @param free_func custom memory free function
- * @param opaque custom memory manager handle
- * @returns @c 0 if instance can not be allocated or initialized
- * @returns pointer to initialized ::BrotliSharedDictionary otherwise
- */
-BROTLI_COMMON_API BrotliSharedDictionary* BrotliSharedDictionaryCreateInstance(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
-
-/**
- * Deinitializes and frees ::BrotliSharedDictionary instance.
- *
- * @param dict shared dictionary instance to be cleaned up and deallocated
- */
-BROTLI_COMMON_API void BrotliSharedDictionaryDestroyInstance(
-    BrotliSharedDictionary* dict);
-
-/**
- * Attaches dictionary to a given instance of ::BrotliSharedDictionary.
- *
- * Dictionary to be attached is represented in a serialized format as a region
- * of memory.
- *
- * Provided data it partially referenced by a resulting (compound) dictionary,
- * and should be kept untouched, while at least one compound dictionary uses it.
- * This way memory overhead is kept minimal by the cost of additional resource
- * management.
- *
- * @param dict dictionary to extend
- * @param type type of dictionary to attach
- * @param data_size size of @p data
- * @param data serialized dictionary of type @p type, with at least @p data_size
- *        addressable bytes
- * @returns ::BROTLI_TRUE if provided dictionary is successfully attached
- * @returns ::BROTLI_FALSE otherwise
- */
-BROTLI_COMMON_API BROTLI_BOOL BrotliSharedDictionaryAttach(
-    BrotliSharedDictionary* dict, BrotliSharedDictionaryType type,
-    size_t data_size, const uint8_t data[BROTLI_ARRAY_PARAM(data_size)]);
-
-}
-
-#endif  /* BROTLI_COMMON_SHARED_DICTIONARY_H_ */
diff --git a/src/duckdb/third_party/brotli/include/brotli/types.h b/src/duckdb/third_party/brotli/include/brotli/types.h
deleted file mode 100644
index eff1a3cd0..000000000
--- a/src/duckdb/third_party/brotli/include/brotli/types.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/**
- * @file
- * Common types used in decoder and encoder API.
- */
-
-#ifndef BROTLI_COMMON_TYPES_H_
-#define BROTLI_COMMON_TYPES_H_
-
-#include <stddef.h>  /* for size_t */
-
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64 int64_t;
-#else
-#include <stdint.h>
-#endif  /* defined(_MSC_VER) && (_MSC_VER < 1600) */
-
-/**
- * A portable @c bool replacement.
- *
- * ::BROTLI_BOOL is a "documentation" type: actually it is @c int, but in API it
- * denotes a type, whose only values are ::BROTLI_TRUE and ::BROTLI_FALSE.
- *
- * ::BROTLI_BOOL values passed to Brotli should either be ::BROTLI_TRUE or
- * ::BROTLI_FALSE, or be a result of ::TO_BROTLI_BOOL macros.
- *
- * ::BROTLI_BOOL values returned by Brotli should not be tested for equality
- * with @c true, @c false, ::BROTLI_TRUE, ::BROTLI_FALSE, but rather should be
- * evaluated, for example: @code{.cpp}
- * if (SomeBrotliFunction(encoder, BROTLI_TRUE) &&
- *     !OtherBrotliFunction(decoder, BROTLI_FALSE)) {
- *   bool x = !!YetAnotherBrotliFunction(encoder, TO_BROLTI_BOOL(2 * 2 == 4));
- *   DoSomething(x);
- * }
- * @endcode
- */
-#define BROTLI_BOOL int
-/** Portable @c true replacement. */
-#define BROTLI_TRUE 1
-/** Portable @c false replacement. */
-#define BROTLI_FALSE 0
-/** @c bool to ::BROTLI_BOOL conversion macros. */
-#define TO_BROTLI_BOOL(X) (!!(X) ? BROTLI_TRUE : BROTLI_FALSE)
-
-#define BROTLI_MAKE_UINT64_T(high, low) ((((uint64_t)(high)) << 32) | low)
-
-#define BROTLI_UINT32_MAX (~((uint32_t)0))
-#define BROTLI_SIZE_MAX (~((size_t)0))
-
-/**
- * Allocating function pointer type.
- *
- * @param opaque custom memory manager handle provided by client
- * @param size requested memory region size; can not be @c 0
- * @returns @c 0 in the case of failure
- * @returns a valid pointer to a memory region of at least @p size bytes
- *          long otherwise
- */
-typedef void* (*brotli_alloc_func)(void* opaque, size_t size);
-
-/**
- * Deallocating function pointer type.
- *
- * This function @b SHOULD do nothing if @p address is @c 0.
- *
- * @param opaque custom memory manager handle provided by client
- * @param address memory region pointer returned by ::brotli_alloc_func, or @c 0
- */
-typedef void (*brotli_free_func)(void* opaque, void* address);
-
-#endif  /* BROTLI_COMMON_TYPES_H_ */
diff --git a/src/duckdb/third_party/concurrentqueue/blockingconcurrentqueue.h b/src/duckdb/third_party/concurrentqueue/blockingconcurrentqueue.h
deleted file mode 100644
index 916a5a277..000000000
--- a/src/duckdb/third_party/concurrentqueue/blockingconcurrentqueue.h
+++ /dev/null
@@ -1,588 +0,0 @@
-// Provides an efficient blocking version of moodycamel::ConcurrentQueue.
-// ©2015-2016 Cameron Desrochers. Distributed under the terms of the simplified
-// BSD license, available at the top of concurrentqueue.h.
-// Uses Jeff Preshing's semaphore implementation (under the terms of its
-// separate zlib license, embedded below).
-
-#pragma once
-
-#include "concurrentqueue.h"
-#include "lightweightsemaphore.h"
-
-#include <type_traits>
-#include <cerrno>
-#include <memory>
-#include <chrono>
-#include <ctime>
-
-namespace duckdb_moodycamel
-{
-// This is a blocking version of the queue. It has an almost identical interface to
-// the normal non-blocking version, with the addition of various wait_dequeue() methods
-// and the removal of producer-specific dequeue methods.
-template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
-class BlockingConcurrentQueue
-{
-private:
-	typedef ::duckdb_moodycamel::ConcurrentQueue<T, Traits> ConcurrentQueue;
-	typedef ::duckdb_moodycamel::LightweightSemaphore LightweightSemaphore;
-
-public:
-	typedef typename ConcurrentQueue::producer_token_t producer_token_t;
-	typedef typename ConcurrentQueue::consumer_token_t consumer_token_t;
-	
-	typedef typename ConcurrentQueue::index_t index_t;
-	typedef typename ConcurrentQueue::size_t size_t;
-	typedef typename std::make_signed<size_t>::type ssize_t;
-	
-	static const size_t BLOCK_SIZE = ConcurrentQueue::BLOCK_SIZE;
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = ConcurrentQueue::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD;
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = ConcurrentQueue::EXPLICIT_INITIAL_INDEX_SIZE;
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = ConcurrentQueue::IMPLICIT_INITIAL_INDEX_SIZE;
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = ConcurrentQueue::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = ConcurrentQueue::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE;
-	static const size_t MAX_SUBQUEUE_SIZE = ConcurrentQueue::MAX_SUBQUEUE_SIZE;
-	
-public:
-	// Creates a queue with at least `capacity` element slots; note that the
-	// actual number of elements that can be inserted without additional memory
-	// allocation depends on the number of producers and the block size (e.g. if
-	// the block size is equal to `capacity`, only a single block will be allocated
-	// up-front, which means only a single producer will be able to enqueue elements
-	// without an extra allocation -- blocks aren't shared between producers).
-	// This method is not thread safe -- it is up to the user to ensure that the
-	// queue is fully constructed before it starts being used by other threads (this
-	// includes making the memory effects of construction visible, possibly with a
-	// memory barrier).
-	explicit BlockingConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
-		: inner(capacity), sema(create<LightweightSemaphore>(), &BlockingConcurrentQueue::template destroy<LightweightSemaphore>)
-	{
-		assert(reinterpret_cast<ConcurrentQueue*>((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member");
-		if (!sema) {
-			MOODYCAMEL_THROW(std::bad_alloc());
-		}
-	}
-	
-	BlockingConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
-		: inner(minCapacity, maxExplicitProducers, maxImplicitProducers), sema(create<LightweightSemaphore>(), &BlockingConcurrentQueue::template destroy<LightweightSemaphore>)
-	{
-		assert(reinterpret_cast<ConcurrentQueue*>((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member");
-		if (!sema) {
-			MOODYCAMEL_THROW(std::bad_alloc());
-		}
-	}
-	
-	// Disable copying and copy assignment
-	BlockingConcurrentQueue(BlockingConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	BlockingConcurrentQueue& operator=(BlockingConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	
-	// Moving is supported, but note that it is *not* a thread-safe operation.
-	// Nobody can use the queue while it's being moved, and the memory effects
-	// of that move must be propagated to other threads before they can use it.
-	// Note: When a queue is moved, its tokens are still valid but can only be
-	// used with the destination queue (i.e. semantically they are moved along
-	// with the queue itself).
-	BlockingConcurrentQueue(BlockingConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-		: inner(std::move(other.inner)), sema(std::move(other.sema))
-	{ }
-	
-	inline BlockingConcurrentQueue& operator=(BlockingConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-	{
-		return swap_internal(other);
-	}
-	
-	// Swaps this queue's state with the other's. Not thread-safe.
-	// Swapping two queues does not invalidate their tokens, however
-	// the tokens that were created for one queue must be used with
-	// only the swapped queue (i.e. the tokens are tied to the
-	// queue's movable state, not the object itself).
-	inline void swap(BlockingConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap_internal(other);
-	}
-	
-private:
-	BlockingConcurrentQueue& swap_internal(BlockingConcurrentQueue& other)
-	{
-		if (this == &other) {
-			return *this;
-		}
-		
-		inner.swap(other.inner);
-		sema.swap(other.sema);
-		return *this;
-	}
-	
-public:
-	// Enqueues a single item (by copying it).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T const& item)
-	{
-		if ((details::likely)(inner.enqueue(item))) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by moving it, if possible).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T&& item)
-	{
-		if ((details::likely)(inner.enqueue(std::move(item)))) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T const& item)
-	{
-		if ((details::likely)(inner.enqueue(token, item))) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T&& item)
-	{
-		if ((details::likely)(inner.enqueue(token, std::move(item)))) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues several items.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
-	// Thread-safe.
-	template<typename It>
-	inline bool enqueue_bulk(It itemFirst, size_t count)
-	{
-		if ((details::likely)(inner.enqueue_bulk(std::forward<It>(itemFirst), count))) {
-			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues several items using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails
-	// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	inline bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		if ((details::likely)(inner.enqueue_bulk(token, std::forward<It>(itemFirst), count))) {
-			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by copying it).
-	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T const& item)
-	{
-		if (inner.try_enqueue(item)) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by moving it, if possible).
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T&& item)
-	{
-		if (inner.try_enqueue(std::move(item))) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T const& item)
-	{
-		if (inner.try_enqueue(token, item)) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T&& item)
-	{
-		if (inner.try_enqueue(token, std::move(item))) {
-			sema->signal();
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues several items.
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	inline bool try_enqueue_bulk(It itemFirst, size_t count)
-	{
-		if (inner.try_enqueue_bulk(std::forward<It>(itemFirst), count)) {
-			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
-			return true;
-		}
-		return false;
-	}
-	
-	// Enqueues several items using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	inline bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		if (inner.try_enqueue_bulk(token, std::forward<It>(itemFirst), count)) {
-			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
-			return true;
-		}
-		return false;
-	}
-	
-	
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool try_dequeue(U& item)
-	{
-		if (sema->tryWait()) {
-			while (!inner.try_dequeue(item)) {
-				continue;
-			}
-			return true;
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue from the queue using an explicit consumer token.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool try_dequeue(consumer_token_t& token, U& item)
-	{
-		if (sema->tryWait()) {
-			while (!inner.try_dequeue(token, item)) {
-				continue;
-			}
-			return true;
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t try_dequeue_bulk(It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
-		while (count != max) {
-			count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
-		}
-		return count;
-	}
-	
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
-		while (count != max) {
-			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
-		}
-		return count;
-	}
-	
-	
-	
-	// Blocks the current thread until there's something to dequeue, then
-	// dequeues it.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline void wait_dequeue(U& item)
-	{
-		while (!sema->wait()) {
-			continue;
-		}
-		while (!inner.try_dequeue(item)) {
-			continue;
-		}
-	}
-
-	// Blocks the current thread until either there's something to dequeue
-	// or the timeout (specified in microseconds) expires. Returns false
-	// without setting `item` if the timeout expires, otherwise assigns
-	// to `item` and returns true.
-	// Using a negative timeout indicates an indefinite timeout,
-	// and is thus functionally equivalent to calling wait_dequeue.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool wait_dequeue_timed(U& item, std::int64_t timeout_usecs)
-	{
-		if (!sema->wait(timeout_usecs)) {
-			return false;
-		}
-		while (!inner.try_dequeue(item)) {
-			continue;
-		}
-		return true;
-	}
-    
-    // Blocks the current thread until either there's something to dequeue
-	// or the timeout expires. Returns false without setting `item` if the
-    // timeout expires, otherwise assigns to `item` and returns true.
-	// Never allocates. Thread-safe.
-	template<typename U, typename Rep, typename Period>
-	inline bool wait_dequeue_timed(U& item, std::chrono::duration<Rep, Period> const& timeout)
-    {
-        return wait_dequeue_timed(item, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
-    }
-	
-	// Blocks the current thread until there's something to dequeue, then
-	// dequeues it using an explicit consumer token.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline void wait_dequeue(consumer_token_t& token, U& item)
-	{
-		while (!sema->wait()) {
-			continue;
-		}
-		while (!inner.try_dequeue(token, item)) {
-			continue;
-		}
-	}
-	
-	// Blocks the current thread until either there's something to dequeue
-	// or the timeout (specified in microseconds) expires. Returns false
-	// without setting `item` if the timeout expires, otherwise assigns
-	// to `item` and returns true.
-	// Using a negative timeout indicates an indefinite timeout,
-	// and is thus functionally equivalent to calling wait_dequeue.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool wait_dequeue_timed(consumer_token_t& token, U& item, std::int64_t timeout_usecs)
-	{
-		if (!sema->wait(timeout_usecs)) {
-			return false;
-		}
-		while (!inner.try_dequeue(token, item)) {
-			continue;
-		}
-		return true;
-	}
-    
-    // Blocks the current thread until either there's something to dequeue
-	// or the timeout expires. Returns false without setting `item` if the
-    // timeout expires, otherwise assigns to `item` and returns true.
-	// Never allocates. Thread-safe.
-	template<typename U, typename Rep, typename Period>
-	inline bool wait_dequeue_timed(consumer_token_t& token, U& item, std::chrono::duration<Rep, Period> const& timeout)
-    {
-        return wait_dequeue_timed(token, item, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
-    }
-	
-	// Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued, which will
-	// always be at least one (this method blocks until the queue
-	// is non-empty) and at most max.
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t wait_dequeue_bulk(It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
-		while (count != max) {
-			count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
-		}
-		return count;
-	}
-	
-	// Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued, which can
-	// be 0 if the timeout expires while waiting for elements,
-	// and at most max.
-	// Using a negative timeout indicates an indefinite timeout,
-	// and is thus functionally equivalent to calling wait_dequeue_bulk.
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::int64_t timeout_usecs)
-	{
-		size_t count = 0;
-		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
-		while (count != max) {
-			count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
-		}
-		return count;
-	}
-    
-    // Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued, which can
-	// be 0 if the timeout expires while waiting for elements,
-	// and at most max.
-	// Never allocates. Thread-safe.
-	template<typename It, typename Rep, typename Period>
-	inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::chrono::duration<Rep, Period> const& timeout)
-    {
-        return wait_dequeue_bulk_timed<It&>(itemFirst, max, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
-    }
-	
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued, which will
-	// always be at least one (this method blocks until the queue
-	// is non-empty) and at most max.
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t wait_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
-		while (count != max) {
-			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
-		}
-		return count;
-	}
-	
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued, which can
-	// be 0 if the timeout expires while waiting for elements,
-	// and at most max.
-	// Using a negative timeout indicates an indefinite timeout,
-	// and is thus functionally equivalent to calling wait_dequeue_bulk.
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::int64_t timeout_usecs)
-	{
-		size_t count = 0;
-		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
-		while (count != max) {
-			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
-		}
-		return count;
-	}
-	
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued, which can
-	// be 0 if the timeout expires while waiting for elements,
-	// and at most max.
-	// Never allocates. Thread-safe.
-	template<typename It, typename Rep, typename Period>
-	inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::chrono::duration<Rep, Period> const& timeout)
-    {
-        return wait_dequeue_bulk_timed<It&>(token, itemFirst, max, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
-    }
-	
-	
-	// Returns an estimate of the total number of elements currently in the queue. This
-	// estimate is only accurate if the queue has completely stabilized before it is called
-	// (i.e. all enqueue and dequeue operations have completed and their memory effects are
-	// visible on the calling thread, and no further operations start while this method is
-	// being called).
-	// Thread-safe.
-	inline size_t size_approx() const
-	{
-		return (size_t)sema->availableApprox();
-	}
-	
-	
-	// Returns true if the underlying atomic variables used by
-	// the queue are lock-free (they should be on most platforms).
-	// Thread-safe.
-	static bool is_lock_free()
-	{
-		return ConcurrentQueue::is_lock_free();
-	}
-	
-
-private:
-	template<typename U>
-	static inline U* create()
-	{
-		auto p = (Traits::malloc)(sizeof(U));
-		return p != nullptr ? new (p) U : nullptr;
-	}
-	
-	template<typename U, typename A1>
-	static inline U* create(A1&& a1)
-	{
-		auto p = (Traits::malloc)(sizeof(U));
-		return p != nullptr ? new (p) U(std::forward<A1>(a1)) : nullptr;
-	}
-	
-	template<typename U>
-	static inline void destroy(U* p)
-	{
-		if (p != nullptr) {
-			p->~U();
-		}
-		(Traits::free)(p);
-	}
-	
-private:
-	ConcurrentQueue inner;
-	std::unique_ptr<LightweightSemaphore, void (*)(LightweightSemaphore*)> sema;
-};
-
-
-template<typename T, typename Traits>
-inline void swap(BlockingConcurrentQueue<T, Traits>& a, BlockingConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-}	// end namespace moodycamel
diff --git a/src/duckdb/third_party/concurrentqueue/concurrentqueue.h b/src/duckdb/third_party/concurrentqueue/concurrentqueue.h
deleted file mode 100644
index 0f5ad0a4d..000000000
--- a/src/duckdb/third_party/concurrentqueue/concurrentqueue.h
+++ /dev/null
@@ -1,3667 +0,0 @@
-// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.
-// An overview, including benchmark results, is provided here:
-//     http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++
-// The full design is also described in excruciating detail at:
-//    http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue
-
-// Simplified BSD license:
-// Copyright (c) 2013-2016, Cameron Desrochers.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// - Redistributions of source code must retain the above copyright notice, this list of
-// conditions and the following disclaimer.
-// - Redistributions in binary form must reproduce the above copyright notice, this list of
-// conditions and the following disclaimer in the documentation and/or other materials
-// provided with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
-// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 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.
-
-
-#pragma once
-
-#if defined(__GNUC__)
-// Disable -Wconversion warnings (spuriously triggered when Traits::size_t and
-// Traits::index_t are set to < 32 bits, causing integer promotion, causing warnings
-// upon assigning any computed values)
-
-#endif
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-#include <atomic>		// Requires C++11. Sorry VS2010.
-#include <cassert>
-#include <cstddef>              // for max_align_t
-#include <cstdint>
-#include <cstdlib>
-#include <type_traits>
-#include <algorithm>
-#include <utility>
-#include <limits>
-#include <climits>		// for CHAR_BIT
-#include <array>
-#include <thread>		// partly for __WINPTHREADS_VERSION if on MinGW-w64 w/ POSIX threading
-
-// Platform-specific definitions of a numeric thread ID type and an invalid value
-namespace duckdb_moodycamel { namespace details {
-	template<typename thread_id_t> struct thread_id_converter {
-		typedef thread_id_t thread_id_numeric_size_t;
-		typedef thread_id_t thread_id_hash_t;
-		static thread_id_hash_t prehash(thread_id_t const& x) { return x; }
-	};
-} }
-#if defined(MCDBGQ_USE_RELACY)
-namespace duckdb_moodycamel { namespace details {
-	typedef std::uint32_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0xFFFFFFFFU;
-	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFEU;
-	static inline thread_id_t thread_id() { return rl::thread_index(); }
-} }
-#elif defined(_WIN32) || defined(__WINDOWS__) || defined(__WIN32__)
-// No sense pulling in windows.h in a header, we'll manually declare the function
-// we use and rely on backwards-compatibility for this not to break
-extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId(void);
-namespace duckdb_moodycamel { namespace details {
-	static_assert(sizeof(unsigned long) == sizeof(std::uint32_t), "Expected size of unsigned long to be 32 bits on Windows");
-	typedef std::uint32_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0;			// See http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx
-	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFFU;	// Not technically guaranteed to be invalid, but is never used in practice. Note that all Win32 thread IDs are presently multiples of 4.
-	static inline thread_id_t thread_id() { return static_cast<thread_id_t>(::GetCurrentThreadId()); }
-} }
-#elif defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || (defined(__APPLE__) && TARGET_OS_IPHONE) || defined(__MVS__)
-namespace duckdb_moodycamel { namespace details {
-	static_assert(sizeof(std::thread::id) == 4 || sizeof(std::thread::id) == 8, "std::thread::id is expected to be either 4 or 8 bytes");
-	
-	typedef std::thread::id thread_id_t;
-	static const thread_id_t invalid_thread_id;         // Default ctor creates invalid ID
-
-	// Note we don't define a invalid_thread_id2 since std::thread::id doesn't have one; it's
-	// only used if MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is defined anyway, which it won't
-	// be.
-	static inline thread_id_t thread_id() { return std::this_thread::get_id(); }
-
-	template<std::size_t> struct thread_id_size { };
-	template<> struct thread_id_size<4> { typedef std::uint32_t numeric_t; };
-	template<> struct thread_id_size<8> { typedef std::uint64_t numeric_t; };
-
-	template<> struct thread_id_converter<thread_id_t> {
-		typedef thread_id_size<sizeof(thread_id_t)>::numeric_t thread_id_numeric_size_t;
-#ifndef __APPLE__
-		typedef std::size_t thread_id_hash_t;
-#else
-		typedef thread_id_numeric_size_t thread_id_hash_t;
-#endif
-
-		static thread_id_hash_t prehash(thread_id_t const& x)
-		{
-#ifndef __APPLE__
-			return std::hash<std::thread::id>()(x);
-#else
-			return *reinterpret_cast<thread_id_hash_t const*>(&x);
-#endif
-		}
-	};
-} }
-#else
-// Use a nice trick from this answer: http://stackoverflow.com/a/8438730/21475
-// In order to get a numeric thread ID in a platform-independent way, we use a thread-local
-// static variable's address as a thread identifier :-)
-#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-#define MOODYCAMEL_THREADLOCAL __thread
-#elif defined(_MSC_VER)
-#define MOODYCAMEL_THREADLOCAL __declspec(thread)
-#else
-// Assume C++11 compliant compiler
-#define MOODYCAMEL_THREADLOCAL thread_local
-#endif
-namespace duckdb_moodycamel { namespace details {
-	typedef std::uintptr_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0;		// Address can't be nullptr
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	static const thread_id_t invalid_thread_id2 = 1;		// Member accesses off a null pointer are also generally invalid. Plus it's not aligned.
-#endif
-	inline thread_id_t thread_id() { static MOODYCAMEL_THREADLOCAL int x; return reinterpret_cast<thread_id_t>(&x); }
-} }
-#endif
-
-// Constexpr if
-#ifndef MOODYCAMEL_CONSTEXPR_IF
-#if (defined(_MSC_VER) && defined(_HAS_CXX17) && _HAS_CXX17) || __cplusplus > 201402L
-#define MOODYCAMEL_CONSTEXPR_IF if constexpr
-#define MOODYCAMEL_MAYBE_UNUSED [[maybe_unused]]
-#else
-#define MOODYCAMEL_CONSTEXPR_IF if
-#define MOODYCAMEL_MAYBE_UNUSED
-#endif
-#endif
-
-// Exceptions
-#ifndef MOODYCAMEL_EXCEPTIONS_ENABLED
-#if (defined(_MSC_VER) && defined(_CPPUNWIND)) || (defined(__GNUC__) && defined(__EXCEPTIONS)) || (!defined(_MSC_VER) && !defined(__GNUC__))
-#define MOODYCAMEL_EXCEPTIONS_ENABLED
-#endif
-#endif
-#ifdef MOODYCAMEL_EXCEPTIONS_ENABLED
-#define MOODYCAMEL_TRY try
-#define MOODYCAMEL_CATCH(...) catch(__VA_ARGS__)
-#define MOODYCAMEL_RETHROW throw
-#define MOODYCAMEL_THROW(expr) throw (expr)
-#else
-#define MOODYCAMEL_TRY MOODYCAMEL_CONSTEXPR_IF (true)
-#define MOODYCAMEL_CATCH(...) else MOODYCAMEL_CONSTEXPR_IF (false)
-#define MOODYCAMEL_RETHROW
-#define MOODYCAMEL_THROW(expr)
-#endif
-
-#ifndef MOODYCAMEL_NOEXCEPT
-#if !defined(MOODYCAMEL_EXCEPTIONS_ENABLED)
-#define MOODYCAMEL_NOEXCEPT
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) true
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) true
-#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1800
-// VS2012's std::is_nothrow_[move_]constructible is broken and returns true when it shouldn't :-(
-// We have to assume *all* non-trivial constructors may throw on VS2012!
-#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value)
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
-#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1900
-#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value || std::is_nothrow_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value || std::is_nothrow_copy_constructible<type>::value)
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
-#else
-#define MOODYCAMEL_NOEXCEPT noexcept
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) noexcept(expr)
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) noexcept(expr)
-#endif
-#endif
-
-#ifndef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-#ifdef MCDBGQ_USE_RELACY
-#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-#else
-// VS2013 doesn't support `thread_local`, and MinGW-w64 w/ POSIX threading has a crippling bug: http://sourceforge.net/p/mingw-w64/bugs/445
-// g++ <=4.7 doesn't support thread_local either.
-// Finally, iOS/ARM doesn't have support for it either, and g++/ARM allows it to compile but it's unconfirmed to actually work
-#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && (!defined(__MINGW32__) && !defined(__MINGW64__) || !defined(__WINPTHREADS_VERSION)) && (!defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) && (!defined(__APPLE__) || !TARGET_OS_IPHONE) && !defined(__arm__) && !defined(_M_ARM) && !defined(__aarch64__) && !defined(__MVS__)
-// Assume `thread_local` is fully supported in all other C++11 compilers/platforms
-//#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED    // always disabled for now since several users report having problems with it on
-#endif
-#endif
-#endif
-
-// VS2012 doesn't support deleted functions. 
-// In this case, we declare the function normally but don't define it. A link error will be generated if the function is called.
-#ifndef MOODYCAMEL_DELETE_FUNCTION
-#if defined(_MSC_VER) && _MSC_VER < 1800
-#define MOODYCAMEL_DELETE_FUNCTION
-#else
-#define MOODYCAMEL_DELETE_FUNCTION = delete
-#endif
-#endif
-
-#ifndef MOODYCAMEL_ALIGNAS
-// VS2013 doesn't support alignas or alignof
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-#define MOODYCAMEL_ALIGNAS(alignment) __declspec(align(alignment))
-#define MOODYCAMEL_ALIGNOF(obj) __alignof(obj)
-#else
-#define MOODYCAMEL_ALIGNAS(alignment) alignas(alignment)
-#define MOODYCAMEL_ALIGNOF(obj) alignof(obj)
-#endif
-#endif
-
-
-
-// Compiler-specific likely/unlikely hints
-namespace duckdb_moodycamel { namespace details {
-
-#if defined(__GNUC__)
-	static inline bool (likely)(bool x) { return __builtin_expect((x), true); }
-//	static inline bool (unlikely)(bool x) { return __builtin_expect((x), false); }
-#else
-	static inline bool (likely)(bool x) { return x; }
-//	static inline bool (unlikely)(bool x) { return x; }
-#endif
-} }
-
-namespace duckdb_moodycamel {
-namespace details {
-	template<typename T>
-	struct const_numeric_max {
-		static_assert(std::is_integral<T>::value, "const_numeric_max can only be used with integers");
-		static const T value = std::numeric_limits<T>::is_signed
-			? (static_cast<T>(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast<T>(1)
-			: static_cast<T>(-1);
-	};
-
-#if defined(__GLIBCXX__)
-	typedef ::max_align_t std_max_align_t;      // libstdc++ forgot to add it to std:: for a while
-#else
-	typedef std::max_align_t std_max_align_t;   // Others (e.g. MSVC) insist it can *only* be accessed via std::
-#endif
-
-	// Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting
-	// 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64.
-	typedef union {
-		std_max_align_t x;
-		long long y;
-		void* z;
-	} max_align_t;
-}
-
-// Default traits for the ConcurrentQueue. To change some of the
-// traits without re-implementing all of them, inherit from this
-// struct and shadow the declarations you wish to be different;
-// since the traits are used as a template type parameter, the
-// shadowed declarations will be used where defined, and the defaults
-// otherwise.
-struct ConcurrentQueueDefaultTraits
-{
-	// General-purpose size type. std::size_t is strongly recommended.
-	typedef std::size_t size_t;
-	
-	// The type used for the enqueue and dequeue indices. Must be at least as
-	// large as size_t. Should be significantly larger than the number of elements
-	// you expect to hold at once, especially if you have a high turnover rate;
-	// for example, on 32-bit x86, if you expect to have over a hundred million
-	// elements or pump several million elements through your queue in a very
-	// short space of time, using a 32-bit type *may* trigger a race condition.
-	// A 64-bit int type is recommended in that case, and in practice will
-	// prevent a race condition no matter the usage of the queue. Note that
-	// whether the queue is lock-free with a 64-int type depends on the whether
-	// std::atomic<std::uint64_t> is lock-free, which is platform-specific.
-	typedef std::size_t index_t;
-	
-	// Internally, all elements are enqueued and dequeued from multi-element
-	// blocks; this is the smallest controllable unit. If you expect few elements
-	// but many producers, a smaller block size should be favoured. For few producers
-	// and/or many elements, a larger block size is preferred. A sane default
-	// is provided. Must be a power of 2.
-	static const size_t BLOCK_SIZE = 32;
-	
-	// For explicit producers (i.e. when using a producer token), the block is
-	// checked for being empty by iterating through a list of flags, one per element.
-	// For large block sizes, this is too inefficient, and switching to an atomic
-	// counter-based approach is faster. The switch is made for block sizes strictly
-	// larger than this threshold.
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32;
-	
-	// How many full blocks can be expected for a single explicit producer? This should
-	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32;
-	
-	// How many full blocks can be expected for a single implicit producer? This should
-	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
-	
-	// The initial size of the hash table mapping thread IDs to implicit producers.
-	// Note that the hash is resized every time it becomes half full.
-	// Must be a power of two, and either 0 or at least 1. If 0, implicit production
-	// (using the enqueue methods without an explicit producer token) is disabled.
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 32;
-	
-	// Controls the number of items that an explicit consumer (i.e. one with a token)
-	// must consume before it causes all consumers to rotate and move on to the next
-	// internal queue.
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
-	
-	// The maximum number of elements (inclusive) that can be enqueued to a sub-queue.
-	// Enqueue operations that would cause this limit to be surpassed will fail. Note
-	// that this limit is enforced at the block level (for performance reasons), i.e.
-	// it's rounded up to the nearest block size.
-	static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max<size_t>::value;
-	
-	
-#ifndef MCDBGQ_USE_RELACY
-	// Memory allocation can be customized if needed.
-	// malloc should return nullptr on failure, and handle alignment like std::malloc.
-#if defined(malloc) || defined(free)
-	// Gah, this is 2015, stop defining macros that break standard code already!
-	// Work around malloc/free being special macros:
-	static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); }
-	static inline void WORKAROUND_free(void* ptr) { return free(ptr); }
-	static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); }
-	static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); }
-#else
-	static inline void* malloc(size_t size) { return std::malloc(size); }
-	static inline void free(void* ptr) { return std::free(ptr); }
-#endif
-#else
-	// Debug versions when running under the Relacy race detector (ignore
-	// these in user code)
-	static inline void* malloc(size_t size) { return rl::rl_malloc(size, $); }
-	static inline void free(void* ptr) { return rl::rl_free(ptr, $); }
-#endif
-};
-
-
-// When producing or consuming many elements, the most efficient way is to:
-//    1) Use one of the bulk-operation methods of the queue with a token
-//    2) Failing that, use the bulk-operation methods without a token
-//    3) Failing that, create a token and use that with the single-item methods
-//    4) Failing that, use the single-parameter methods of the queue
-// Having said that, don't create tokens willy-nilly -- ideally there should be
-// a maximum of one token per thread (of each kind).
-struct ProducerToken;
-struct ConsumerToken;
-
-template<typename T, typename Traits> class ConcurrentQueue;
-template<typename T, typename Traits> class BlockingConcurrentQueue;
-class ConcurrentQueueTests;
-
-
-namespace details
-{
-	struct ConcurrentQueueProducerTypelessBase
-	{
-		ConcurrentQueueProducerTypelessBase* next;
-		std::atomic<bool> inactive;
-		ProducerToken* token;
-		
-		ConcurrentQueueProducerTypelessBase()
-			: next(nullptr), inactive(false), token(nullptr)
-		{
-		}
-	};
-	
-	template<bool use32> struct _hash_32_or_64 {
-		static inline std::uint32_t hash(std::uint32_t h)
-		{
-			// MurmurHash3 finalizer -- see https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
-			// Since the thread ID is already unique, all we really want to do is propagate that
-			// uniqueness evenly across all the bits, so that we can use a subset of the bits while
-			// reducing collisions significantly
-			h ^= h >> 16;
-			h *= 0x85ebca6b;
-			h ^= h >> 13;
-			h *= 0xc2b2ae35;
-			return h ^ (h >> 16);
-		}
-	};
-	template<> struct _hash_32_or_64<1> {
-		static inline std::uint64_t hash(std::uint64_t h)
-		{
-			h ^= h >> 33;
-			h *= 0xff51afd7ed558ccd;
-			h ^= h >> 33;
-			h *= 0xc4ceb9fe1a85ec53;
-			return h ^ (h >> 33);
-		}
-	};
-	template<std::size_t size> struct hash_32_or_64 : public _hash_32_or_64<(size > 4)> {  };
-	
-	static inline size_t hash_thread_id(thread_id_t id)
-	{
-		static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values");
-		return static_cast<size_t>(hash_32_or_64<sizeof(thread_id_converter<thread_id_t>::thread_id_hash_t)>::hash(
-			thread_id_converter<thread_id_t>::prehash(id)));
-	}
-	
-	template<typename T>
-	static inline bool circular_less_than(T a, T b)
-	{
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4554)
-#endif
-		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "circular_less_than is intended to be used only with unsigned integer types");
-		return static_cast<T>(a - b) > static_cast<T>(static_cast<T>(1) << static_cast<T>(sizeof(T) * CHAR_BIT - 1));
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-	}
-	
-	template<typename U>
-	static inline char* align_for(char* ptr)
-	{
-		const std::size_t alignment = std::alignment_of<U>::value;
-		return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
-	}
-
-	template<typename T>
-	static inline T ceil_to_pow_2(T x)
-	{
-		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");
-
-		// Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-		--x;
-		x |= x >> 1;
-		x |= x >> 2;
-		x |= x >> 4;
-		for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
-			x |= x >> (i << 3);
-		}
-		++x;
-		return x;
-	}
-	
-	template<typename T>
-	static inline void swap_relaxed(std::atomic<T>& left, std::atomic<T>& right)
-	{
-		T temp = std::move(left.load(std::memory_order_relaxed));
-		left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed);
-		right.store(std::move(temp), std::memory_order_relaxed);
-	}
-	
-	template<typename T>
-	static inline T const& nomove(T const& x)
-	{
-		return x;
-	}
-	
-	template<bool Enable>
-	struct nomove_if
-	{
-		template<typename T>
-		static inline T const& eval(T const& x)
-		{
-			return x;
-		}
-	};
-	
-	template<>
-	struct nomove_if<false>
-	{
-		template<typename U>
-		static inline auto eval(U&& x)
-			-> decltype(std::forward<U>(x))
-		{
-			return std::forward<U>(x);
-		}
-	};
-	
-	template<typename It>
-	static inline auto deref_noexcept(It& it) MOODYCAMEL_NOEXCEPT -> decltype(*it)
-	{
-		return *it;
-	}
-	
-#if defined(__clang__) || !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-	template<typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> { };
-#else
-	template<typename T> struct is_trivially_destructible : std::has_trivial_destructor<T> { };
-#endif
-	
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-#ifdef MCDBGQ_USE_RELACY
-	typedef RelacyThreadExitListener ThreadExitListener;
-	typedef RelacyThreadExitNotifier ThreadExitNotifier;
-#else
-	struct ThreadExitListener
-	{
-		typedef void (*callback_t)(void*);
-		callback_t callback;
-		void* userData;
-		
-		ThreadExitListener* next;		// reserved for use by the ThreadExitNotifier
-	};
-	
-	
-	class ThreadExitNotifier
-	{
-	public:
-		static void subscribe(ThreadExitListener* listener)
-		{
-			auto& tlsInst = instance();
-			listener->next = tlsInst.tail;
-			tlsInst.tail = listener;
-		}
-		
-		static void unsubscribe(ThreadExitListener* listener)
-		{
-			auto& tlsInst = instance();
-			ThreadExitListener** prev = &tlsInst.tail;
-			for (auto ptr = tlsInst.tail; ptr != nullptr; ptr = ptr->next) {
-				if (ptr == listener) {
-					*prev = ptr->next;
-					break;
-				}
-				prev = &ptr->next;
-			}
-		}
-		
-	private:
-		ThreadExitNotifier() : tail(nullptr) { }
-		ThreadExitNotifier(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
-		ThreadExitNotifier& operator=(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
-		
-		~ThreadExitNotifier()
-		{
-			// This thread is about to exit, let everyone know!
-			assert(this == &instance() && "If this assert fails, you likely have a buggy compiler! Change the preprocessor conditions such that MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is no longer defined.");
-			for (auto ptr = tail; ptr != nullptr; ptr = ptr->next) {
-				ptr->callback(ptr->userData);
-			}
-		}
-		
-		// Thread-local
-		static inline ThreadExitNotifier& instance()
-		{
-			static thread_local ThreadExitNotifier notifier;
-			return notifier;
-		}
-		
-	private:
-		ThreadExitListener* tail;
-	};
-#endif
-#endif
-	
-	template<typename T> struct static_is_lock_free_num { enum { value = 0 }; };
-	template<> struct static_is_lock_free_num<signed char> { enum { value = ATOMIC_CHAR_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<short> { enum { value = ATOMIC_SHORT_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<int> { enum { value = ATOMIC_INT_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<long> { enum { value = ATOMIC_LONG_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<long long> { enum { value = ATOMIC_LLONG_LOCK_FREE }; };
-	template<typename T> struct static_is_lock_free : static_is_lock_free_num<typename std::make_signed<T>::type> {  };
-	template<> struct static_is_lock_free<bool> { enum { value = ATOMIC_BOOL_LOCK_FREE }; };
-	template<typename U> struct static_is_lock_free<U*> { enum { value = ATOMIC_POINTER_LOCK_FREE }; };
-}
-
-
-struct ProducerToken
-{
-	template<typename T, typename Traits>
-	explicit ProducerToken(ConcurrentQueue<T, Traits>& queue);
-	
-	template<typename T, typename Traits>
-	explicit ProducerToken(BlockingConcurrentQueue<T, Traits>& queue);
-	
-	ProducerToken(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
-		: producer(other.producer)
-	{
-		other.producer = nullptr;
-		if (producer != nullptr) {
-			producer->token = this;
-		}
-	}
-	
-	inline ProducerToken& operator=(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap(other);
-		return *this;
-	}
-	
-	void swap(ProducerToken& other) MOODYCAMEL_NOEXCEPT
-	{
-		std::swap(producer, other.producer);
-		if (producer != nullptr) {
-			producer->token = this;
-		}
-		if (other.producer != nullptr) {
-			other.producer->token = &other;
-		}
-	}
-	
-	// A token is always valid unless:
-	//     1) Memory allocation failed during construction
-	//     2) It was moved via the move constructor
-	//        (Note: assignment does a swap, leaving both potentially valid)
-	//     3) The associated queue was destroyed
-	// Note that if valid() returns true, that only indicates
-	// that the token is valid for use with a specific queue,
-	// but not which one; that's up to the user to track.
-	inline bool valid() const { return producer != nullptr; }
-	
-	~ProducerToken()
-	{
-		if (producer != nullptr) {
-			producer->token = nullptr;
-			producer->inactive.store(true, std::memory_order_release);
-		}
-	}
-	
-	// Disable copying and assignment
-	ProducerToken(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	ProducerToken& operator=(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	
-private:
-	template<typename T, typename Traits> friend class ConcurrentQueue;
-	friend class ConcurrentQueueTests;
-	
-protected:
-	details::ConcurrentQueueProducerTypelessBase* producer;
-};
-
-
-struct ConsumerToken
-{
-	template<typename T, typename Traits>
-	explicit ConsumerToken(ConcurrentQueue<T, Traits>& q);
-	
-	template<typename T, typename Traits>
-	explicit ConsumerToken(BlockingConcurrentQueue<T, Traits>& q);
-	
-	ConsumerToken(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
-		: initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer)
-	{
-	}
-	
-	inline ConsumerToken& operator=(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap(other);
-		return *this;
-	}
-	
-	void swap(ConsumerToken& other) MOODYCAMEL_NOEXCEPT
-	{
-		std::swap(initialOffset, other.initialOffset);
-		std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset);
-		std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent);
-		std::swap(currentProducer, other.currentProducer);
-		std::swap(desiredProducer, other.desiredProducer);
-	}
-	
-	// Disable copying and assignment
-	ConsumerToken(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	ConsumerToken& operator=(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-
-private:
-	template<typename T, typename Traits> friend class ConcurrentQueue;
-	friend class ConcurrentQueueTests;
-	
-private: // but shared with ConcurrentQueue
-	std::uint32_t initialOffset;
-	std::uint32_t lastKnownGlobalOffset;
-	std::uint32_t itemsConsumedFromCurrent;
-	details::ConcurrentQueueProducerTypelessBase* currentProducer;
-	details::ConcurrentQueueProducerTypelessBase* desiredProducer;
-};
-
-// Need to forward-declare this swap because it's in a namespace.
-// See http://stackoverflow.com/questions/4492062/why-does-a-c-friend-class-need-a-forward-declaration-only-in-other-namespaces
-template<typename T, typename Traits>
-inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT;
-
-
-template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
-class ConcurrentQueue
-{
-public:
-	typedef ::duckdb_moodycamel::ProducerToken producer_token_t;
-	typedef ::duckdb_moodycamel::ConsumerToken consumer_token_t;
-	
-	typedef typename Traits::index_t index_t;
-	typedef typename Traits::size_t size_t;
-	
-	static const size_t BLOCK_SIZE = static_cast<size_t>(Traits::BLOCK_SIZE);
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast<size_t>(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD);
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::EXPLICIT_INITIAL_INDEX_SIZE);
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::IMPLICIT_INITIAL_INDEX_SIZE);
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = static_cast<size_t>(Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE);
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast<std::uint32_t>(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE);
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4307)		// + integral constant overflow (that's what the ternary expression is for!)
-#pragma warning(disable: 4309)		// static_cast: Truncation of constant value
-#endif
-	static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max<size_t>::value - static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max<size_t>::value : ((static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-	static_assert(!std::numeric_limits<size_t>::is_signed && std::is_integral<size_t>::value, "Traits::size_t must be an unsigned integral type");
-	static_assert(!std::numeric_limits<index_t>::is_signed && std::is_integral<index_t>::value, "Traits::index_t must be an unsigned integral type");
-	static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t");
-	static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)");
-	static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)");
-	static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
-	static_assert((IMPLICIT_INITIAL_INDEX_SIZE > 1) && !(IMPLICIT_INITIAL_INDEX_SIZE & (IMPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::IMPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
-	static_assert((INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) || !(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE & (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE - 1)), "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be a power of 2");
-	static_assert(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0 || INITIAL_IMPLICIT_PRODUCER_HASH_SIZE >= 1, "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be at least 1 (or 0 to disable implicit enqueueing)");
-
-public:
-	// Creates a queue with at least `capacity` element slots; note that the
-	// actual number of elements that can be inserted without additional memory
-	// allocation depends on the number of producers and the block size (e.g. if
-	// the block size is equal to `capacity`, only a single block will be allocated
-	// up-front, which means only a single producer will be able to enqueue elements
-	// without an extra allocation -- blocks aren't shared between producers).
-	// This method is not thread safe -- it is up to the user to ensure that the
-	// queue is fully constructed before it starts being used by other threads (this
-	// includes making the memory effects of construction visible, possibly with a
-	// memory barrier).
-	explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
-		: producerListTail(nullptr),
-		producerCount(0),
-		initialBlockPoolIndex(0),
-		nextExplicitConsumerId(0),
-		globalExplicitConsumerOffset(0)
-	{
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		// Track all the producers using a fully-resolved typed list for
-		// each kind; this makes it possible to debug them starting from
-		// the root queue object (otherwise wacky casts are needed that
-		// don't compile in the debugger's expression evaluator).
-		explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-	}
-	
-	// Computes the correct amount of pre-allocated blocks for you based
-	// on the minimum number of elements you want available at any given
-	// time, and the maximum concurrent number of each type of producer.
-	ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
-		: producerListTail(nullptr),
-		producerCount(0),
-		initialBlockPoolIndex(0),
-		nextExplicitConsumerId(0),
-		globalExplicitConsumerOffset(0)
-	{
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
-		populate_initial_block_list(blocks);
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-	}
-	
-	// Note: The queue should not be accessed concurrently while it's
-	// being deleted. It's up to the user to synchronize this.
-	// This method is not thread safe.
-	~ConcurrentQueue()
-	{
-		// Destroy producers
-		auto ptr = producerListTail.load(std::memory_order_relaxed);
-		while (ptr != nullptr) {
-			auto next = ptr->next_prod();
-			if (ptr->token != nullptr) {
-				ptr->token->producer = nullptr;
-			}
-			destroy(ptr);
-			ptr = next;
-		}
-		
-		// Destroy implicit producer hash tables
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
-			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
-			while (hash != nullptr) {
-				auto prev = hash->prev;
-				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
-					for (size_t i = 0; i != hash->capacity; ++i) {
-						hash->entries[i].~ImplicitProducerKVP();
-					}
-					hash->~ImplicitProducerHash();
-					(Traits::free)(hash);
-				}
-				hash = prev;
-			}
-		}
-		
-		// Destroy global free list
-		auto block = freeList.head_unsafe();
-		while (block != nullptr) {
-			auto next = block->freeListNext.load(std::memory_order_relaxed);
-			if (block->dynamicallyAllocated) {
-				destroy(block);
-			}
-			block = next;
-		}
-		
-		// Destroy initial free list
-		destroy_array(initialBlockPool, initialBlockPoolSize);
-	}
-
-	// Disable copying and copy assignment
-	ConcurrentQueue(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	ConcurrentQueue& operator=(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	
-	// Moving is supported, but note that it is *not* a thread-safe operation.
-	// Nobody can use the queue while it's being moved, and the memory effects
-	// of that move must be propagated to other threads before they can use it.
-	// Note: When a queue is moved, its tokens are still valid but can only be
-	// used with the destination queue (i.e. semantically they are moved along
-	// with the queue itself).
-	ConcurrentQueue(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-		: producerListTail(other.producerListTail.load(std::memory_order_relaxed)),
-		producerCount(other.producerCount.load(std::memory_order_relaxed)),
-		initialBlockPoolIndex(other.initialBlockPoolIndex.load(std::memory_order_relaxed)),
-		initialBlockPool(other.initialBlockPool),
-		initialBlockPoolSize(other.initialBlockPoolSize),
-		freeList(std::move(other.freeList)),
-		nextExplicitConsumerId(other.nextExplicitConsumerId.load(std::memory_order_relaxed)),
-		globalExplicitConsumerOffset(other.globalExplicitConsumerOffset.load(std::memory_order_relaxed))
-	{
-		// Move the other one into this, and leave the other one as an empty queue
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		swap_implicit_producer_hashes(other);
-		
-		other.producerListTail.store(nullptr, std::memory_order_relaxed);
-		other.producerCount.store(0, std::memory_order_relaxed);
-		other.nextExplicitConsumerId.store(0, std::memory_order_relaxed);
-		other.globalExplicitConsumerOffset.store(0, std::memory_order_relaxed);
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		explicitProducers.store(other.explicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
-		other.explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(other.implicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
-		other.implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-		
-		other.initialBlockPoolIndex.store(0, std::memory_order_relaxed);
-		other.initialBlockPoolSize = 0;
-		other.initialBlockPool = nullptr;
-		
-		reown_producers();
-	}
-	
-	inline ConcurrentQueue& operator=(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-	{
-		return swap_internal(other);
-	}
-	
-	// Swaps this queue's state with the other's. Not thread-safe.
-	// Swapping two queues does not invalidate their tokens, however
-	// the tokens that were created for one queue must be used with
-	// only the swapped queue (i.e. the tokens are tied to the
-	// queue's movable state, not the object itself).
-	inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap_internal(other);
-	}
-	
-private:
-	ConcurrentQueue& swap_internal(ConcurrentQueue& other)
-	{
-		if (this == &other) {
-			return *this;
-		}
-		
-		details::swap_relaxed(producerListTail, other.producerListTail);
-		details::swap_relaxed(producerCount, other.producerCount);
-		details::swap_relaxed(initialBlockPoolIndex, other.initialBlockPoolIndex);
-		std::swap(initialBlockPool, other.initialBlockPool);
-		std::swap(initialBlockPoolSize, other.initialBlockPoolSize);
-		freeList.swap(other.freeList);
-		details::swap_relaxed(nextExplicitConsumerId, other.nextExplicitConsumerId);
-		details::swap_relaxed(globalExplicitConsumerOffset, other.globalExplicitConsumerOffset);
-		
-		swap_implicit_producer_hashes(other);
-		
-		reown_producers();
-		other.reown_producers();
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		details::swap_relaxed(explicitProducers, other.explicitProducers);
-		details::swap_relaxed(implicitProducers, other.implicitProducers);
-#endif
-		
-		return *this;
-	}
-	
-public:
-	// Enqueues a single item (by copying it).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T const& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CanAlloc>(item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T&& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CanAlloc>(std::move(item));
-	}
-	
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T const& item)
-	{
-		return inner_enqueue<CanAlloc>(token, item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T&& item)
-	{
-		return inner_enqueue<CanAlloc>(token, std::move(item));
-	}
-	
-	// Enqueues several items.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool enqueue_bulk(It itemFirst, size_t count)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue_bulk<CanAlloc>(itemFirst, count);
-	}
-	
-	// Enqueues several items using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails
-	// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return inner_enqueue_bulk<CanAlloc>(token, itemFirst, count);
-	}
-	
-	// Enqueues a single item (by copying it).
-	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T const& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CannotAlloc>(item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible).
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T&& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CannotAlloc>(std::move(item));
-	}
-	
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T const& item)
-	{
-		return inner_enqueue<CannotAlloc>(token, item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T&& item)
-	{
-		return inner_enqueue<CannotAlloc>(token, std::move(item));
-	}
-	
-	// Enqueues several items.
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool try_enqueue_bulk(It itemFirst, size_t count)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue_bulk<CannotAlloc>(itemFirst, count);
-	}
-	
-	// Enqueues several items using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return inner_enqueue_bulk<CannotAlloc>(token, itemFirst, count);
-	}
-	
-	
-	
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue(U& item)
-	{
-		// Instead of simply trying each producer in turn (which could cause needless contention on the first
-		// producer), we score them heuristically.
-		size_t nonEmptyCount = 0;
-		ProducerBase* best = nullptr;
-		size_t bestSize = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); nonEmptyCount < 3 && ptr != nullptr; ptr = ptr->next_prod()) {
-			auto size = ptr->size_approx();
-			if (size > 0) {
-				if (size > bestSize) {
-					bestSize = size;
-					best = ptr;
-				}
-				++nonEmptyCount;
-			}
-		}
-		
-		// If there was at least one non-empty queue but it appears empty at the time
-		// we try to dequeue from it, we need to make sure every queue's been tried
-		if (nonEmptyCount > 0) {
-			if ((details::likely)(best->dequeue(item))) {
-				return true;
-			}
-			for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-				if (ptr != best && ptr->dequeue(item)) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// This differs from the try_dequeue(item) method in that this one does
-	// not attempt to reduce contention by interleaving the order that producer
-	// streams are dequeued from. So, using this method can reduce overall throughput
-	// under contention, but will give more predictable results in single-threaded
-	// consumer scenarios. This is mostly only useful for internal unit tests.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue_non_interleaved(U& item)
-	{
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			if (ptr->dequeue(item)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue from the queue using an explicit consumer token.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue(consumer_token_t& token, U& item)
-	{
-		// The idea is roughly as follows:
-		// Every 256 items from one producer, make everyone rotate (increase the global offset) -> this means the highest efficiency consumer dictates the rotation speed of everyone else, more or less
-		// If you see that the global offset has changed, you must reset your consumption counter and move to your designated place
-		// If there's no items where you're supposed to be, keep moving until you find a producer with some items
-		// If the global offset has not changed but you've run out of items to consume, move over from your current position until you find an producer with something in it
-		
-		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
-			if (!update_current_producer_after_rotation(token)) {
-				return false;
-			}
-		}
-		
-		// If there was at least one non-empty queue but it appears empty at the time
-		// we try to dequeue from it, we need to make sure every queue's been tried
-		if (static_cast<ProducerBase*>(token.currentProducer)->dequeue(item)) {
-			if (++token.itemsConsumedFromCurrent == EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
-				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
-			}
-			return true;
-		}
-		
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
-		if (ptr == nullptr) {
-			ptr = tail;
-		}
-		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
-			if (ptr->dequeue(item)) {
-				token.currentProducer = ptr;
-				token.itemsConsumedFromCurrent = 1;
-				return true;
-			}
-			ptr = ptr->next_prod();
-			if (ptr == nullptr) {
-				ptr = tail;
-			}
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	size_t try_dequeue_bulk(It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			count += ptr->dequeue_bulk(itemFirst, max - count);
-			if (count == max) {
-				break;
-			}
-		}
-		return count;
-	}
-	
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
-	{
-		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
-			if (!update_current_producer_after_rotation(token)) {
-				return 0;
-			}
-		}
-		
-		size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
-		if (count == max) {
-			if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
-				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
-			}
-			return max;
-		}
-		token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
-		max -= count;
-		
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
-		if (ptr == nullptr) {
-			ptr = tail;
-		}
-		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
-			auto dequeued = ptr->dequeue_bulk(itemFirst, max);
-			count += dequeued;
-			if (dequeued != 0) {
-				token.currentProducer = ptr;
-				token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
-			}
-			if (dequeued == max) {
-				break;
-			}
-			max -= dequeued;
-			ptr = ptr->next_prod();
-			if (ptr == nullptr) {
-				ptr = tail;
-			}
-		}
-		return count;
-	}
-	
-	
-	
-	// Attempts to dequeue from a specific producer's inner queue.
-	// If you happen to know which producer you want to dequeue from, this
-	// is significantly faster than using the general-case try_dequeue methods.
-	// Returns false if the producer's queue appeared empty at the time it
-	// was checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool try_dequeue_from_producer(producer_token_t const& producer, U& item)
-	{
-		return static_cast<ExplicitProducer*>(producer.producer)->dequeue(item);
-	}
-	
-	// Attempts to dequeue several elements from a specific producer's inner queue.
-	// Returns the number of items actually dequeued.
-	// If you happen to know which producer you want to dequeue from, this
-	// is significantly faster than using the general-case try_dequeue methods.
-	// Returns 0 if the producer's queue appeared empty at the time it
-	// was checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t try_dequeue_bulk_from_producer(producer_token_t const& producer, It itemFirst, size_t max)
-	{
-		return static_cast<ExplicitProducer*>(producer.producer)->dequeue_bulk(itemFirst, max);
-	}
-	
-	
-	// Returns an estimate of the total number of elements currently in the queue. This
-	// estimate is only accurate if the queue has completely stabilized before it is called
-	// (i.e. all enqueue and dequeue operations have completed and their memory effects are
-	// visible on the calling thread, and no further operations start while this method is
-	// being called).
-	// Thread-safe.
-	size_t size_approx() const
-	{
-		size_t size = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			size += ptr->size_approx();
-		}
-		return size;
-	}
-	
-	
-	// Returns true if the underlying atomic variables used by
-	// the queue are lock-free (they should be on most platforms).
-	// Thread-safe.
-	static bool is_lock_free()
-	{
-		return
-			details::static_is_lock_free<bool>::value == 2 &&
-			details::static_is_lock_free<size_t>::value == 2 &&
-			details::static_is_lock_free<std::uint32_t>::value == 2 &&
-			details::static_is_lock_free<index_t>::value == 2 &&
-			details::static_is_lock_free<void*>::value == 2 &&
-			details::static_is_lock_free<typename details::thread_id_converter<details::thread_id_t>::thread_id_numeric_size_t>::value == 2;
-	}
-
-
-private:
-	friend struct ProducerToken;
-	friend struct ConsumerToken;
-	struct ExplicitProducer;
-	friend struct ExplicitProducer;
-	struct ImplicitProducer;
-	friend struct ImplicitProducer;
-	friend class ConcurrentQueueTests;
-		
-	enum AllocationMode { CanAlloc, CannotAlloc };
-	
-	
-	///////////////////////////////
-	// Queue methods
-	///////////////////////////////
-	
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(producer_token_t const& token, U&& element)
-	{
-		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
-	}
-	
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(U&& element)
-	{
-		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
-	}
-	
-	template<AllocationMode canAlloc, typename It>
-	inline bool inner_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
-	}
-	
-	template<AllocationMode canAlloc, typename It>
-	inline bool inner_enqueue_bulk(It itemFirst, size_t count)
-	{
-		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
-	}
-	
-	inline bool update_current_producer_after_rotation(consumer_token_t& token)
-	{
-		// Ah, there's been a rotation, figure out where we should be!
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		if (token.desiredProducer == nullptr && tail == nullptr) {
-			return false;
-		}
-		auto prodCount = producerCount.load(std::memory_order_relaxed);
-		auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed);
-		if (token.desiredProducer == nullptr) {
-			// Aha, first time we're dequeueing anything.
-			// Figure out our local position
-			// Note: offset is from start, not end, but we're traversing from end -- subtract from count first
-			std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount);
-			token.desiredProducer = tail;
-			for (std::uint32_t i = 0; i != offset; ++i) {
-				token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
-				if (token.desiredProducer == nullptr) {
-					token.desiredProducer = tail;
-				}
-			}
-		}
-		
-		std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset;
-		if (delta >= prodCount) {
-			delta = delta % prodCount;
-		}
-		for (std::uint32_t i = 0; i != delta; ++i) {
-			token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
-			if (token.desiredProducer == nullptr) {
-				token.desiredProducer = tail;
-			}
-		}
-		
-		token.lastKnownGlobalOffset = globalOffset;
-		token.currentProducer = token.desiredProducer;
-		token.itemsConsumedFromCurrent = 0;
-		return true;
-	}
-	
-	
-	///////////////////////////
-	// Free list
-	///////////////////////////
-	
-	template <typename N>
-	struct FreeListNode
-	{
-		FreeListNode() : freeListRefs(0), freeListNext(nullptr) { }
-		
-		std::atomic<std::uint32_t> freeListRefs;
-		std::atomic<N*> freeListNext;
-	};
-	
-	// A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but
-	// simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly
-	// speedy under low contention.
-	template<typename N>		// N must inherit FreeListNode or have the same fields (and initialization of them)
-	struct FreeList
-	{
-		FreeList() : freeListHead(nullptr) { }
-		FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); }
-		void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); }
-		
-		FreeList(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
-		FreeList& operator=(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
-		
-		inline void add(N* node)
-		{
-#ifdef MCDBGQ_NOLOCKFREE_FREELIST
-			debug::DebugLock lock(mutex);
-#endif		
-			// We know that the should-be-on-freelist bit is 0 at this point, so it's safe to
-			// set it using a fetch_add
-			if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) {
-				// Oh look! We were the last ones referencing this node, and we know
-				// we want to add it to the free list, so let's do it!
-		 		add_knowing_refcount_is_zero(node);
-			}
-		}
-		
-		inline N* try_get()
-		{
-#ifdef MCDBGQ_NOLOCKFREE_FREELIST
-			debug::DebugLock lock(mutex);
-#endif		
-			auto head = freeListHead.load(std::memory_order_acquire);
-			while (head != nullptr) {
-				auto prevHead = head;
-				auto refs = head->freeListRefs.load(std::memory_order_relaxed);
-				if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
-					head = freeListHead.load(std::memory_order_acquire);
-					continue;
-				}
-				
-				// Good, reference count has been incremented (it wasn't at zero), which means we can read the
-				// next and not worry about it changing between now and the time we do the CAS
-				auto next = head->freeListNext.load(std::memory_order_relaxed);
-				if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
-					// Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
-					// matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
-					assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
-					
-					// Decrease refcount twice, once for our ref, and once for the list's ref
-					head->freeListRefs.fetch_sub(2, std::memory_order_release);
-					return head;
-				}
-				
-				// OK, the head must have changed on us, but we still need to decrease the refcount we increased.
-				// Note that we don't need to release any memory effects, but we do need to ensure that the reference
-				// count decrement happens-after the CAS on the head.
-				refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
-				if (refs == SHOULD_BE_ON_FREELIST + 1) {
-					add_knowing_refcount_is_zero(prevHead);
-				}
-			}
-			
-			return nullptr;
-		}
-		
-		// Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes)
-		N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); }
-		
-	private:
-		inline void add_knowing_refcount_is_zero(N* node)
-		{
-			// Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run
-			// only one copy of this method per node at a time, i.e. the single thread case), then we know
-			// we can safely change the next pointer of the node; however, once the refcount is back above
-			// zero, then other threads could increase it (happens under heavy contention, when the refcount
-			// goes to zero in between a load and a refcount increment of a node in try_get, then back up to
-			// something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS
-			// to add the node to the actual list fails, decrease the refcount and leave the add operation to
-			// the next thread who puts the refcount back at zero (which could be us, hence the loop).
-			auto head = freeListHead.load(std::memory_order_relaxed);
-			while (true) {
-				node->freeListNext.store(head, std::memory_order_relaxed);
-				node->freeListRefs.store(1, std::memory_order_release);
-				if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) {
-					// Hmm, the add failed, but we can only try again when the refcount goes back to zero
-					if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) {
-						continue;
-					}
-				}
-				return;
-			}
-		}
-		
-	private:
-		// Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention)
-		std::atomic<N*> freeListHead;
-	
-	static const std::uint32_t REFS_MASK = 0x7FFFFFFF;
-	static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000;
-		
-#ifdef MCDBGQ_NOLOCKFREE_FREELIST
-		debug::DebugMutex mutex;
-#endif
-	};
-	
-	
-	///////////////////////////
-	// Block
-	///////////////////////////
-	
-	enum InnerQueueContext { implicit_context = 0, explicit_context = 1 };
-	
-	struct Block
-	{
-		Block()
-			: next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), shouldBeOnFreeList(false), dynamicallyAllocated(true)
-		{
-#ifdef MCDBGQ_TRACKMEM
-			owner = nullptr;
-#endif
-		}
-		
-		template<InnerQueueContext context>
-		inline bool is_empty() const
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Check flags
-				for (size_t i = 0; i < BLOCK_SIZE; ++i) {
-					if (!emptyFlags[i].load(std::memory_order_relaxed)) {
-						return false;
-					}
-				}
-				
-				// Aha, empty; make sure we have all other memory effects that happened before the empty flags were set
-				std::atomic_thread_fence(std::memory_order_acquire);
-				return true;
-			}
-			else {
-				// Check counter
-				if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) {
-					std::atomic_thread_fence(std::memory_order_acquire);
-					return true;
-				}
-				assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE);
-				return false;
-			}
-		}
-		
-		// Returns true if the block is now empty (does not apply in explicit context)
-		template<InnerQueueContext context>
-		inline bool set_empty(MOODYCAMEL_MAYBE_UNUSED index_t i)
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set flag
-				assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].load(std::memory_order_relaxed));
-				emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].store(true, std::memory_order_release);
-				return false;
-			}
-			else {
-				// Increment counter
-				auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release);
-				assert(prevVal < BLOCK_SIZE);
-				return prevVal == BLOCK_SIZE - 1;
-			}
-		}
-		
-		// Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0).
-		// Returns true if the block is now empty (does not apply in explicit context).
-		template<InnerQueueContext context>
-		inline bool set_many_empty(MOODYCAMEL_MAYBE_UNUSED index_t i, size_t count)
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set flags
-				std::atomic_thread_fence(std::memory_order_release);
-				i = BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1)) - count + 1;
-				for (size_t j = 0; j != count; ++j) {
-					assert(!emptyFlags[i + j].load(std::memory_order_relaxed));
-					emptyFlags[i + j].store(true, std::memory_order_relaxed);
-				}
-				return false;
-			}
-			else {
-				// Increment counter
-				auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release);
-				assert(prevVal + count <= BLOCK_SIZE);
-				return prevVal + count == BLOCK_SIZE;
-			}
-		}
-		
-		template<InnerQueueContext context>
-		inline void set_all_empty()
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set all flags
-				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
-					emptyFlags[i].store(true, std::memory_order_relaxed);
-				}
-			}
-			else {
-				// Reset counter
-				elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed);
-			}
-		}
-		
-		template<InnerQueueContext context>
-		inline void reset_empty()
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Reset flags
-				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
-					emptyFlags[i].store(false, std::memory_order_relaxed);
-				}
-			}
-			else {
-				// Reset counter
-				elementsCompletelyDequeued.store(0, std::memory_order_relaxed);
-			}
-		}
-		
-		inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_cast<T*>(static_cast<void*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
-		inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { return static_cast<T const*>(static_cast<void const*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
-		
-	private:
-		static_assert(std::alignment_of<T>::value <= sizeof(T), "The queue does not support types with an alignment greater than their size at this time");
-		MOODYCAMEL_ALIGNAS(MOODYCAMEL_ALIGNOF(T)) char elements[sizeof(T) * BLOCK_SIZE];
-	public:
-		Block* next;
-		std::atomic<size_t> elementsCompletelyDequeued;
-		std::atomic<bool> emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1];
-	public:
-		std::atomic<std::uint32_t> freeListRefs;
-		std::atomic<Block*> freeListNext;
-		std::atomic<bool> shouldBeOnFreeList;
-		bool dynamicallyAllocated;		// Perhaps a better name for this would be 'isNotPartOfInitialBlockPool'
-		
-#ifdef MCDBGQ_TRACKMEM
-		void* owner;
-#endif
-	};
-	static_assert(std::alignment_of<Block>::value >= std::alignment_of<T>::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping");
-
-
-#ifdef MCDBGQ_TRACKMEM
-public:
-	struct MemStats;
-private:
-#endif
-	
-	///////////////////////////
-	// Producer base
-	///////////////////////////
-	
-	struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase
-	{
-		ProducerBase(ConcurrentQueue* parent_, bool isExplicit_) :
-			tailIndex(0),
-			headIndex(0),
-			dequeueOptimisticCount(0),
-			dequeueOvercommit(0),
-			tailBlock(nullptr),
-			isExplicit(isExplicit_),
-			parent(parent_)
-		{
-		}
-		
-		virtual ~ProducerBase() { };
-		
-		template<typename U>
-		inline bool dequeue(U& element)
-		{
-			if (isExplicit) {
-				return static_cast<ExplicitProducer*>(this)->dequeue(element);
-			}
-			else {
-				return static_cast<ImplicitProducer*>(this)->dequeue(element);
-			}
-		}
-		
-		template<typename It>
-		inline size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			if (isExplicit) {
-				return static_cast<ExplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
-			}
-			else {
-				return static_cast<ImplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
-			}
-		}
-		
-		inline ProducerBase* next_prod() const { return static_cast<ProducerBase*>(next); }
-		
-		inline size_t size_approx() const
-		{
-			auto tail = tailIndex.load(std::memory_order_relaxed);
-			auto head = headIndex.load(std::memory_order_relaxed);
-			return details::circular_less_than(head, tail) ? static_cast<size_t>(tail - head) : 0;
-		}
-		
-		inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); }
-	protected:
-		std::atomic<index_t> tailIndex;		// Where to enqueue to next
-		std::atomic<index_t> headIndex;		// Where to dequeue from next
-		
-		std::atomic<index_t> dequeueOptimisticCount;
-		std::atomic<index_t> dequeueOvercommit;
-		
-		Block* tailBlock;
-		
-	public:
-		bool isExplicit;
-		ConcurrentQueue* parent;
-		
-	protected:
-#ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-	
-	
-	///////////////////////////
-	// Explicit queue
-	///////////////////////////
-		
-	struct ExplicitProducer : public ProducerBase
-	{
-		explicit ExplicitProducer(ConcurrentQueue* parent_) :
-			ProducerBase(parent_, true),
-			blockIndex(nullptr),
-			pr_blockIndexSlotsUsed(0),
-			pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
-			pr_blockIndexFront(0),
-			pr_blockIndexEntries(nullptr),
-			pr_blockIndexRaw(nullptr)
-		{
-			size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
-			if (poolBasedIndexSize > pr_blockIndexSize) {
-				pr_blockIndexSize = poolBasedIndexSize;
-			}
-			
-			new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
-		}
-		
-		~ExplicitProducer()
-		{
-			// Destruct any elements not yet dequeued.
-			// Since we're in the destructor, we can assume all elements
-			// are either completely dequeued or completely not (no halfways).
-			if (this->tailBlock != nullptr) {		// Note this means there must be a block index too
-				// First find the block that's partially dequeued, if any
-				Block* halfDequeuedBlock = nullptr;
-				if ((this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) != 0) {
-					// The head's not on a block boundary, meaning a block somewhere is partially dequeued
-					// (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary)
-					size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1);
-					while (details::circular_less_than<index_t>(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) {
-						i = (i + 1) & (pr_blockIndexSize - 1);
-					}
-					assert(details::circular_less_than<index_t>(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed)));
-					halfDequeuedBlock = pr_blockIndexEntries[i].block;
-				}
-				
-				// Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration)
-				auto block = this->tailBlock;
-				do {
-					block = block->next;
-					if (block->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-						continue;
-					}
-					
-					size_t i = 0;	// Offset into block
-					if (block == halfDequeuedBlock) {
-						i = static_cast<size_t>(this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
-					}
-					
-					// Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index
-					auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast<size_t>(this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
-					while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) {
-						(*block)[i++]->~T();
-					}
-				} while (block != this->tailBlock);
-			}
-			
-			// Destroy all blocks that we own
-			if (this->tailBlock != nullptr) {
-				auto block = this->tailBlock;
-				do {
-					auto nextBlock = block->next;
-					if (block->dynamicallyAllocated) {
-						destroy(block);
-					}
-					else {
-						this->parent->add_block_to_free_list(block);
-					}
-					block = nextBlock;
-				} while (block != this->tailBlock);
-			}
-			
-			// Destroy the block indices
-			auto header = static_cast<BlockIndexHeader*>(pr_blockIndexRaw);
-			while (header != nullptr) {
-				auto prev = static_cast<BlockIndexHeader*>(header->prev);
-				header->~BlockIndexHeader();
-				(Traits::free)(header);
-				header = prev;
-			}
-		}
-		
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
-		{
-			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			index_t newTailIndex = 1 + currentTailIndex;
-			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-				// We reached the end of a block, start a new one
-				auto startBlock = this->tailBlock;
-				auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
-				if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-					// We can re-use the block ahead of us, it's empty!					
-					this->tailBlock = this->tailBlock->next;
-					this->tailBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					
-					// We'll put the block on the block index (guaranteed to be room since we're conceptually removing the
-					// last block from it first -- except instead of removing then adding, we can just overwrite).
-					// Note that there must be a valid block index here, since even if allocation failed in the ctor,
-					// it would have been re-attempted when adding the first block to the queue; since there is such
-					// a block, a block index must have been successfully allocated.
-				}
-				else {
-					// Whatever head value we see here is >= the last value we saw here (relatively),
-					// and <= its current value. Since we have the most recent tail, the head must be
-					// <= to it.
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE)
-						|| (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
-						// We can't enqueue in another block because there's not enough leeway -- the
-						// tail could surpass the head by the time the block fills up! (Or we'll exceed
-						// the size limit, if the second part of the condition was true.)
-						return false;
-					}
-					// We're going to need a new block; check that the block index has room
-					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) {
-						// Hmm, the circular block index is already full -- we'll need
-						// to allocate a new index. Note pr_blockIndexRaw can only be nullptr if
-						// the initial allocation failed in the constructor.
-						
-						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-							return false;
-						}
-						else if (!new_block_index(pr_blockIndexSlotsUsed)) {
-							return false;
-						}
-					}
-					
-					// Insert a new block in the circular linked list
-					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-					if (newBlock == nullptr) {
-						return false;
-					}
-#ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					if (this->tailBlock == nullptr) {
-						newBlock->next = newBlock;
-					}
-					else {
-						newBlock->next = this->tailBlock->next;
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					++pr_blockIndexSlotsUsed;
-				}
-
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					// The constructor may throw. We want the element not to appear in the queue in
-					// that case (without corrupting the queue):
-					MOODYCAMEL_TRY {
-						new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-					}
-					MOODYCAMEL_CATCH (...) {
-						// Revert change to the current block, but leave the new block available
-						// for next time
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? this->tailBlock : startBlock;
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				else {
-					(void)startBlock;
-					(void)originalBlockIndexSlotsUsed;
-				}
-				
-				// Add block to block index
-				auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-				entry.base = currentTailIndex;
-				entry.block = this->tailBlock;
-				blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
-				pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					this->tailIndex.store(newTailIndex, std::memory_order_release);
-					return true;
-				}
-			}
-			
-			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-			
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename U>
-		bool dequeue(U& element)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
-				// Might be something to dequeue, let's give it a try
-				
-				// Note that this if is purely for performance purposes in the common case when the queue is
-				// empty and the values are eventually consistent -- we may enter here spuriously.
-				
-				// Note that whatever the values of overcommit and tail are, they are not going to change (unless we
-				// change them) and must be the same value at this point (inside the if) as when the if condition was
-				// evaluated.
-
-				// We insert an acquire fence here to synchronize-with the release upon incrementing dequeueOvercommit below.
-				// This ensures that whatever the value we got loaded into overcommit, the load of dequeueOptisticCount in
-				// the fetch_add below will result in a value at least as recent as that (and therefore at least as large).
-				// Note that I believe a compiler (signal) fence here would be sufficient due to the nature of fetch_add (all
-				// read-modify-write operations are guaranteed to work on the latest value in the modification order), but
-				// unfortunately that can't be shown to be correct using only the C++11 standard.
-				// See http://stackoverflow.com/questions/18223161/what-are-the-c11-memory-ordering-guarantees-in-this-corner-case
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				// Increment optimistic counter, then check if it went over the boundary
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
-				
-				// Note that since dequeueOvercommit must be <= dequeueOptimisticCount (because dequeueOvercommit is only ever
-				// incremented after dequeueOptimisticCount -- this is enforced in the `else` block below), and since we now
-				// have a version of dequeueOptimisticCount that is at least as recent as overcommit (due to the release upon
-				// incrementing dequeueOvercommit and the acquire above that synchronizes with it), overcommit <= myDequeueCount.
-				// However, we can't assert this since both dequeueOptimisticCount and dequeueOvercommit may (independently)
-				// overflow; in such a case, though, the logic still holds since the difference between the two is maintained.
-				
-				// Note that we reload tail here in case it changed; it will be the same value as before or greater, since
-				// this load is sequenced after (happens after) the earlier load above. This is supported by read-read
-				// coherency (as defined in the standard), explained here: http://en.cppreference.com/w/cpp/atomic/memory_order
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
-					// Guaranteed to be at least one element to dequeue!
-					
-					// Get the index. Note that since there's guaranteed to be at least one element, this
-					// will never exceed tail. We need to do an acquire-release fence here since it's possible
-					// that whatever condition got us to this point was for an earlier enqueued element (that
-					// we already see the memory effects for), but that by the time we increment somebody else
-					// has incremented it, and we need to see the memory effects for *that* element, which is
-					// in such a case is necessarily visible on the thread that incremented it in the first
-					// place with the more current condition (they must have acquired a tail that is at least
-					// as recent).
-					auto index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
-					
-					
-					// Determine which block the element is in
-					
-					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
-					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
-					
-					// We need to be careful here about subtracting and dividing because of index wrap-around.
-					// When an index wraps, we need to preserve the sign of the offset when dividing it by the
-					// block size (in order to get a correct signed block count offset in all cases):
-					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
-					auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
-					auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
-					
-					// Dequeue
-					auto& el = *((*block)[index]);
-					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
-						// Make sure the element is still fully dequeued and destroyed even if the assignment
-						// throws
-						struct Guard {
-							Block* block;
-							index_t index;
-							
-							~Guard()
-							{
-								(*block)[index]->~T();
-								block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
-							}
-						} guard = { block, index };
-
-						element = std::move(el); // NOLINT
-					}
-					else {
-						element = std::move(el); // NOLINT
-						el.~T(); // NOLINT
-						block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
-					}
-					
-					return true;
-				}
-				else {
-					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
-					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);		// Release so that the fetch_add on dequeueOptimisticCount is guaranteed to happen before this write
-				}
-			}
-		
-			return false;
-		}
-		
-		template<AllocationMode allocMode, typename It>
-		bool enqueue_bulk(It itemFirst, size_t count)
-		{
-			// First, we need to make sure we have enough room to enqueue all of the elements;
-			// this means pre-allocating blocks and putting them in the block index (but only if
-			// all the allocations succeeded).
-			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			auto startBlock = this->tailBlock;
-			auto originalBlockIndexFront = pr_blockIndexFront;
-			auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
-			
-			Block* firstAllocatedBlock = nullptr;
-			
-			// Figure out how many blocks we'll need to allocate, and do so
-			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
-			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-			if (blockBaseDiff > 0) {
-				// Allocate as many blocks as possible from ahead
-				while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-					
-					this->tailBlock = this->tailBlock->next;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
-					
-					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-					entry.base = currentTailIndex;
-					entry.block = this->tailBlock;
-					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				}
-				
-				// Now allocate as many blocks as necessary from the block pool
-				while (blockBaseDiff > 0) {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-					
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
-					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
-						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-							// Failed to allocate, undo changes (but keep injected blocks)
-							pr_blockIndexFront = originalBlockIndexFront;
-							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-							return false;
-						}
-						else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
-							// Failed to allocate, undo changes (but keep injected blocks)
-							pr_blockIndexFront = originalBlockIndexFront;
-							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-							return false;
-						}
-						
-						// pr_blockIndexFront is updated inside new_block_index, so we need to
-						// update our fallback value too (since we keep the new index even if we
-						// later fail)
-						originalBlockIndexFront = originalBlockIndexSlotsUsed;
-					}
-					
-					// Insert a new block in the circular linked list
-					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-					if (newBlock == nullptr) {
-						pr_blockIndexFront = originalBlockIndexFront;
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-						return false;
-					}
-					
-#ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
-					if (this->tailBlock == nullptr) {
-						newBlock->next = newBlock;
-					}
-					else {
-						newBlock->next = this->tailBlock->next;
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
-					
-					++pr_blockIndexSlotsUsed;
-					
-					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-					entry.base = currentTailIndex;
-					entry.block = this->tailBlock;
-					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				}
-				
-				// Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
-				// publish the new block index front
-				auto block = firstAllocatedBlock;
-				while (true) {
-					block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					if (block == this->tailBlock) {
-						break;
-					}
-					block = block->next;
-				}
-				
-				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
-					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
-				}
-			}
-			
-			// Enqueue, one block at a time
-			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
-			currentTailIndex = startTailIndex;
-			auto endBlock = this->tailBlock;
-			this->tailBlock = startBlock;
-			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
-			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
-				this->tailBlock = firstAllocatedBlock;
-			}
-			while (true) {
-				auto stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
-					stopIndex = newTailIndex;
-				}
-				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
-					while (currentTailIndex != stopIndex) {
-						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
-					}
-				}
-				else {
-					MOODYCAMEL_TRY {
-						while (currentTailIndex != stopIndex) {
-							// Must use copy constructor even if move constructor is available
-							// because we may have to revert if there's an exception.
-							// Sorry about the horrible templated next line, but it was the only way
-							// to disable moving *at compile time*, which is important because a type
-							// may only define a (noexcept) move constructor, and so calls to the
-							// cctor will not compile, even if they are in an if branch that will never
-							// be executed
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
-							++currentTailIndex;
-							++itemFirst;
-						}
-					}
-					MOODYCAMEL_CATCH (...) {
-						// Oh dear, an exception's been thrown -- destroy the elements that
-						// were enqueued so far and revert the entire bulk operation (we'll keep
-						// any allocated blocks in our linked list for later, though).
-						auto constructedStopIndex = currentTailIndex;
-						auto lastBlockEnqueued = this->tailBlock;
-						
-						pr_blockIndexFront = originalBlockIndexFront;
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-						
-						if (!details::is_trivially_destructible<T>::value) {
-							auto block = startBlock;
-							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-								block = firstAllocatedBlock;
-							}
-							currentTailIndex = startTailIndex;
-							while (true) {
-								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
-									stopIndex = constructedStopIndex;
-								}
-								while (currentTailIndex != stopIndex) {
-									(*block)[currentTailIndex++]->~T();
-								}
-								if (block == lastBlockEnqueued) {
-									break;
-								}
-								block = block->next;
-							}
-						}
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				
-				if (this->tailBlock == endBlock) {
-					assert(currentTailIndex == newTailIndex);
-					break;
-				}
-				this->tailBlock = this->tailBlock->next;
-			}
-			
-			if (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst))) && firstAllocatedBlock != nullptr) {
-				blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
-			}
-			
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename It>
-		size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
-			if (details::circular_less_than<size_t>(0, desiredCount)) {
-				desiredCount = desiredCount < max ? desiredCount : max;
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);;
-				
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
-				if (details::circular_less_than<size_t>(0, actualCount)) {
-					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
-					if (actualCount < desiredCount) {
-						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
-					}
-					
-					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
-					// will never exceed tail.
-					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
-					
-					// Determine which block the first element is in
-					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
-					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
-					
-					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
-					auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
-					auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
-					
-					// Iterate the blocks and dequeue
-					auto index = firstIndex;
-					do {
-						auto firstIndexInBlock = index;
-						auto endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-						auto block = localBlockIndex->entries[indexIndex].block;
-						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
-							while (index != endIndex) {
-								auto& el = *((*block)[index]);
-								*itemFirst++ = std::move(el);
-								el.~T();
-								++index;
-							}
-						}
-						else {
-							MOODYCAMEL_TRY {
-								while (index != endIndex) {
-									auto& el = *((*block)[index]);
-									*itemFirst = std::move(el);
-									++itemFirst;
-									el.~T();
-									++index;
-								}
-							}
-							MOODYCAMEL_CATCH (...) {
-								// It's too late to revert the dequeue, but we can make sure that all
-								// the dequeued objects are properly destroyed and the block index
-								// (and empty count) are properly updated before we propagate the exception
-								do {
-									block = localBlockIndex->entries[indexIndex].block;
-									while (index != endIndex) {
-										(*block)[index++]->~T();
-									}
-									block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
-									indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
-									
-									firstIndexInBlock = index;
-									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-								} while (index != firstIndex + actualCount);
-								
-								MOODYCAMEL_RETHROW;
-							}
-						}
-						block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
-						indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
-					} while (index != firstIndex + actualCount);
-					
-					return actualCount;
-				}
-				else {
-					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
-					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
-				}
-			}
-			
-			return 0;
-		}
-		
-	private:
-		struct BlockIndexEntry
-		{
-			index_t base;
-			Block* block;
-		};
-		
-		struct BlockIndexHeader
-		{
-			size_t size;
-			std::atomic<size_t> front;		// Current slot (not next, like pr_blockIndexFront)
-			BlockIndexEntry* entries;
-			void* prev;
-		};
-		
-		
-		bool new_block_index(size_t numberOfFilledSlotsToExpose)
-		{
-			auto prevBlockSizeMask = pr_blockIndexSize - 1;
-			
-			// Create the new block
-			pr_blockIndexSize <<= 1;
-			auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
-			if (newRawPtr == nullptr) {
-				pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
-				return false;
-			}
-			
-			auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
-			
-			// Copy in all the old indices, if any
-			size_t j = 0;
-			if (pr_blockIndexSlotsUsed != 0) {
-				auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
-				do {
-					newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
-					i = (i + 1) & prevBlockSizeMask;
-				} while (i != pr_blockIndexFront);
-			}
-			
-			// Update everything
-			auto header = new (newRawPtr) BlockIndexHeader;
-			header->size = pr_blockIndexSize;
-			header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
-			header->entries = newBlockIndexEntries;
-			header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
-			
-			pr_blockIndexFront = j;
-			pr_blockIndexEntries = newBlockIndexEntries;
-			pr_blockIndexRaw = newRawPtr;
-			blockIndex.store(header, std::memory_order_release);
-			
-			return true;
-		}
-		
-	private:
-		std::atomic<BlockIndexHeader*> blockIndex;
-		
-		// To be used by producer only -- consumer must use the ones in referenced by blockIndex
-		size_t pr_blockIndexSlotsUsed;
-		size_t pr_blockIndexSize;
-		size_t pr_blockIndexFront;		// Next slot (not current)
-		BlockIndexEntry* pr_blockIndexEntries;
-		void* pr_blockIndexRaw;
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	public:
-		ExplicitProducer* nextExplicitProducer;
-	private:
-#endif
-		
-#ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-	
-	
-	//////////////////////////////////
-	// Implicit queue
-	//////////////////////////////////
-	
-	struct ImplicitProducer : public ProducerBase
-	{			
-		ImplicitProducer(ConcurrentQueue* parent_) :
-			ProducerBase(parent_, false),
-			nextBlockIndexCapacity(IMPLICIT_INITIAL_INDEX_SIZE),
-			blockIndex(nullptr)
-		{
-			new_block_index();
-		}
-		
-		~ImplicitProducer()
-		{
-			// Note that since we're in the destructor we can assume that all enqueue/dequeue operations
-			// completed already; this means that all undequeued elements are placed contiguously across
-			// contiguous blocks, and that only the first and last remaining blocks can be only partially
-			// empty (all other remaining blocks must be completely full).
-			
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-			// Unregister ourselves for thread termination notification
-			if (!this->inactive.load(std::memory_order_relaxed)) {
-				details::ThreadExitNotifier::unsubscribe(&threadExitListener);
-			}
-#endif
-			
-			// Destroy all remaining elements!
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto index = this->headIndex.load(std::memory_order_relaxed);
-			Block* block = nullptr;
-			assert(index == tail || details::circular_less_than(index, tail));
-			bool forceFreeLastBlock = index != tail;		// If we enter the loop, then the last (tail) block will not be freed
-			while (index != tail) {
-				if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
-					if (block != nullptr) {
-						// Free the old block
-						this->parent->add_block_to_free_list(block);
-					}
-					
-					block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
-				}
-				
-				((*block)[index])->~T();
-				++index;
-			}
-			// Even if the queue is empty, there's still one block that's not on the free list
-			// (unless the head index reached the end of it, in which case the tail will be poised
-			// to create a new block).
-			if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
-				this->parent->add_block_to_free_list(this->tailBlock);
-			}
-			
-			// Destroy block index
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			if (localBlockIndex != nullptr) {
-				for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
-					localBlockIndex->index[i]->~BlockIndexEntry();
-				}
-				do {
-					auto prev = localBlockIndex->prev;
-					localBlockIndex->~BlockIndexHeader();
-					(Traits::free)(localBlockIndex);
-					localBlockIndex = prev;
-				} while (localBlockIndex != nullptr);
-			}
-		}
-		
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
-		{
-			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			index_t newTailIndex = 1 + currentTailIndex;
-			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-				// We reached the end of a block, start a new one
-				auto head = this->headIndex.load(std::memory_order_relaxed);
-				assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-				if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
-					return false;
-				}
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-				debug::DebugLock lock(mutex);
-#endif
-				// Find out where we'll be inserting this block in the block index
-				BlockIndexEntry* idxEntry;
-				if (!insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) {
-					return false;
-				}
-				
-				// Get ahold of a new block
-				auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-				if (newBlock == nullptr) {
-					rewind_block_index_tail();
-					idxEntry->value.store(nullptr, std::memory_order_relaxed);
-					return false;
-				}
-#ifdef MCDBGQ_TRACKMEM
-				newBlock->owner = this;
-#endif
-				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
-				
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					// May throw, try to insert now before we publish the fact that we have this new block
-					MOODYCAMEL_TRY {
-						new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
-					}
-					MOODYCAMEL_CATCH (...) {
-						rewind_block_index_tail();
-						idxEntry->value.store(nullptr, std::memory_order_relaxed);
-						this->parent->add_block_to_free_list(newBlock);
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				
-				// Insert the new block into the index
-				idxEntry->value.store(newBlock, std::memory_order_relaxed);
-				
-				this->tailBlock = newBlock;
-				
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					this->tailIndex.store(newTailIndex, std::memory_order_release);
-					return true;
-				}
-			}
-			
-			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-			
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename U>
-		bool dequeue(U& element)
-		{
-			// See ExplicitProducer::dequeue for rationale and explanation
-			index_t tail = this->tailIndex.load(std::memory_order_relaxed);
-			index_t overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				index_t myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
-					index_t index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
-					
-					// Determine which block the element is in
-					auto entry = get_block_index_entry_for_index(index);
-					
-					// Dequeue
-					auto block = entry->value.load(std::memory_order_relaxed);
-					auto& el = *((*block)[index]);
-					
-					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-						// Note: Acquiring the mutex with every dequeue instead of only when a block
-						// is released is very sub-optimal, but it is, after all, purely debug code.
-						debug::DebugLock lock(producer->mutex);
-#endif
-						struct Guard {
-							Block* block;
-							index_t index;
-							BlockIndexEntry* entry;
-							ConcurrentQueue* parent;
-							
-							~Guard()
-							{
-								(*block)[index]->~T();
-								if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
-									entry->value.store(nullptr, std::memory_order_relaxed);
-									parent->add_block_to_free_list(block);
-								}
-							}
-						} guard = { block, index, entry, this->parent };
-
-						element = std::move(el); // NOLINT
-					}
-					else {
-						element = std::move(el); // NOLINT
-						el.~T(); // NOLINT
-
-						if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
-							{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-								debug::DebugLock lock(mutex);
-#endif
-								// Add the block back into the global free pool (and remove from block index)
-								entry->value.store(nullptr, std::memory_order_relaxed);
-							}
-							this->parent->add_block_to_free_list(block);		// releases the above store
-						}
-					}
-					
-					return true;
-				}
-				else {
-					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);
-				}
-			}
-		
-			return false;
-		}
-		
-		template<AllocationMode allocMode, typename It>
-		bool enqueue_bulk(It itemFirst, size_t count)
-		{
-			// First, we need to make sure we have enough room to enqueue all of the elements;
-			// this means pre-allocating blocks and putting them in the block index (but only if
-			// all the allocations succeeded).
-			
-			// Note that the tailBlock we start off with may not be owned by us any more;
-			// this happens if it was filled up exactly to the top (setting tailIndex to
-			// the first index of the next block which is not yet allocated), then dequeued
-			// completely (putting it on the free list) before we enqueue again.
-			
-			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			auto startBlock = this->tailBlock;
-			Block* firstAllocatedBlock = nullptr;
-			auto endBlock = this->tailBlock;
-			
-			// Figure out how many blocks we'll need to allocate, and do so
-			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
-			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-			if (blockBaseDiff > 0) {
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-				debug::DebugLock lock(mutex);
-#endif
-				do {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-					
-					// Find out where we'll be inserting this block in the block index
-					BlockIndexEntry* idxEntry = nullptr;  // initialization here unnecessary but compiler can't always tell
-					Block* newBlock;
-					bool indexInserted = false;
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
-					if (full || !(indexInserted = insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) || (newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>()) == nullptr) {
-						// Index allocation or block allocation failed; revert any other allocations
-						// and index insertions done so far for this operation
-						if (indexInserted) {
-							rewind_block_index_tail();
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-						}
-						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
-							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-							idxEntry = get_block_index_entry_for_index(currentTailIndex);
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-							rewind_block_index_tail();
-						}
-						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
-						this->tailBlock = startBlock;
-						
-						return false;
-					}
-					
-#ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
-					newBlock->next = nullptr;
-					
-					// Insert the new block into the index
-					idxEntry->value.store(newBlock, std::memory_order_relaxed);
-					
-					// Store the chain of blocks so that we can undo if later allocations fail,
-					// and so that we can find the blocks when we do the actual enqueueing
-					if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr) {
-						assert(this->tailBlock != nullptr);
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					endBlock = newBlock;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? newBlock : firstAllocatedBlock;
-				} while (blockBaseDiff > 0);
-			}
-			
-			// Enqueue, one block at a time
-			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
-			currentTailIndex = startTailIndex;
-			this->tailBlock = startBlock;
-			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
-			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
-				this->tailBlock = firstAllocatedBlock;
-			}
-			while (true) {
-				auto stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
-					stopIndex = newTailIndex;
-				}
-				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
-					while (currentTailIndex != stopIndex) {
-						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
-					}
-				}
-				else {
-					MOODYCAMEL_TRY {
-						while (currentTailIndex != stopIndex) {
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
-							++currentTailIndex;
-							++itemFirst;
-						}
-					}
-					MOODYCAMEL_CATCH (...) {
-						auto constructedStopIndex = currentTailIndex;
-						auto lastBlockEnqueued = this->tailBlock;
-						
-						if (!details::is_trivially_destructible<T>::value) {
-							auto block = startBlock;
-							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-								block = firstAllocatedBlock;
-							}
-							currentTailIndex = startTailIndex;
-							while (true) {
-								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
-									stopIndex = constructedStopIndex;
-								}
-								while (currentTailIndex != stopIndex) {
-									(*block)[currentTailIndex++]->~T();
-								}
-								if (block == lastBlockEnqueued) {
-									break;
-								}
-								block = block->next;
-							}
-						}
-						
-						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
-							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-							auto idxEntry = get_block_index_entry_for_index(currentTailIndex);
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-							rewind_block_index_tail();
-						}
-						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
-						this->tailBlock = startBlock;
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				
-				if (this->tailBlock == endBlock) {
-					assert(currentTailIndex == newTailIndex);
-					break;
-				}
-				this->tailBlock = this->tailBlock->next;
-			}
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename It>
-		size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
-			if (details::circular_less_than<size_t>(0, desiredCount)) {
-				desiredCount = desiredCount < max ? desiredCount : max;
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
-				
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
-				if (details::circular_less_than<size_t>(0, actualCount)) {
-					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
-					if (actualCount < desiredCount) {
-						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
-					}
-					
-					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
-					// will never exceed tail.
-					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
-					
-					// Iterate the blocks and dequeue
-					auto index = firstIndex;
-					BlockIndexHeader* localBlockIndex;
-					auto indexIndex = get_block_index_index_for_index(index, localBlockIndex);
-					do {
-						auto blockStartIndex = index;
-						auto endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-						
-						auto entry = localBlockIndex->index[indexIndex];
-						auto block = entry->value.load(std::memory_order_relaxed);
-						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
-							while (index != endIndex) {
-								auto& el = *((*block)[index]);
-								*itemFirst++ = std::move(el);
-								el.~T();
-								++index;
-							}
-						}
-						else {
-							MOODYCAMEL_TRY {
-								while (index != endIndex) {
-									auto& el = *((*block)[index]);
-									*itemFirst = std::move(el);
-									++itemFirst;
-									el.~T();
-									++index;
-								}
-							}
-							MOODYCAMEL_CATCH (...) {
-								do {
-									entry = localBlockIndex->index[indexIndex];
-									block = entry->value.load(std::memory_order_relaxed);
-									while (index != endIndex) {
-										(*block)[index++]->~T();
-									}
-									
-									if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-										debug::DebugLock lock(mutex);
-#endif
-										entry->value.store(nullptr, std::memory_order_relaxed);
-										this->parent->add_block_to_free_list(block);
-									}
-									indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
-									
-									blockStartIndex = index;
-									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-								} while (index != firstIndex + actualCount);
-								
-								MOODYCAMEL_RETHROW;
-							}
-						}
-						if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
-							{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-								debug::DebugLock lock(mutex);
-#endif
-								// Note that the set_many_empty above did a release, meaning that anybody who acquires the block
-								// we're about to free can use it safely since our writes (and reads!) will have happened-before then.
-								entry->value.store(nullptr, std::memory_order_relaxed);
-							}
-							this->parent->add_block_to_free_list(block);		// releases the above store
-						}
-						indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
-					} while (index != firstIndex + actualCount);
-					
-					return actualCount;
-				}
-				else {
-					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
-				}
-			}
-			
-			return 0;
-		}
-		
-	private:
-		// The block size must be > 1, so any number with the low bit set is an invalid block base index
-		static const index_t INVALID_BLOCK_BASE = 1;
-		
-		struct BlockIndexEntry
-		{
-			std::atomic<index_t> key;
-			std::atomic<Block*> value;
-		};
-		
-		struct BlockIndexHeader
-		{
-			size_t capacity;
-			std::atomic<size_t> tail;
-			BlockIndexEntry* entries;
-			BlockIndexEntry** index;
-			BlockIndexHeader* prev;
-		};
-		
-		template<AllocationMode allocMode>
-		inline bool insert_block_index_entry(BlockIndexEntry*& idxEntry, index_t blockStartIndex)
-		{
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);		// We're the only writer thread, relaxed is OK
-			if (localBlockIndex == nullptr) {
-				return false;  // this can happen if new_block_index failed in the constructor
-			}
-			auto newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
-			idxEntry = localBlockIndex->index[newTail];
-			if (idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE ||
-				idxEntry->value.load(std::memory_order_relaxed) == nullptr) {
-				
-				idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
-				localBlockIndex->tail.store(newTail, std::memory_order_release);
-				return true;
-			}
-			
-			// No room in the old block index, try to allocate another one!
-			MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-				return false;
-			}
-			else if (!new_block_index()) {
-				return false;
-			}
-			localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
-			idxEntry = localBlockIndex->index[newTail];
-			assert(idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE);
-			idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
-			localBlockIndex->tail.store(newTail, std::memory_order_release);
-			return true;
-		}
-		
-		inline void rewind_block_index_tail()
-		{
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			localBlockIndex->tail.store((localBlockIndex->tail.load(std::memory_order_relaxed) - 1) & (localBlockIndex->capacity - 1), std::memory_order_relaxed);
-		}
-		
-		inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) const
-		{
-			BlockIndexHeader* localBlockIndex;
-			auto idx = get_block_index_index_for_index(index, localBlockIndex);
-			return localBlockIndex->index[idx];
-		}
-		
-		inline size_t get_block_index_index_for_index(index_t index, BlockIndexHeader*& localBlockIndex) const
-		{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-			debug::DebugLock lock(mutex);
-#endif
-			index &= ~static_cast<index_t>(BLOCK_SIZE - 1);
-			localBlockIndex = blockIndex.load(std::memory_order_acquire);
-			auto tail = localBlockIndex->tail.load(std::memory_order_acquire);
-			auto tailBase = localBlockIndex->index[tail]->key.load(std::memory_order_relaxed);
-			assert(tailBase != INVALID_BLOCK_BASE);
-			// Note: Must use division instead of shift because the index may wrap around, causing a negative
-			// offset, whose negativity we want to preserve
-			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
-			size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
-			assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
-			return idx;
-		}
-		
-		bool new_block_index()
-		{
-			auto prev = blockIndex.load(std::memory_order_relaxed);
-			size_t prevCapacity = prev == nullptr ? 0 : prev->capacity;
-			auto entryCount = prev == nullptr ? nextBlockIndexCapacity : prevCapacity;
-			auto raw = static_cast<char*>((Traits::malloc)(
-				sizeof(BlockIndexHeader) +
-				std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * entryCount +
-				std::alignment_of<BlockIndexEntry*>::value - 1 + sizeof(BlockIndexEntry*) * nextBlockIndexCapacity));
-			if (raw == nullptr) {
-				return false;
-			}
-			
-			auto header = new (raw) BlockIndexHeader;
-			auto entries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(raw + sizeof(BlockIndexHeader)));
-			auto index = reinterpret_cast<BlockIndexEntry**>(details::align_for<BlockIndexEntry*>(reinterpret_cast<char*>(entries) + sizeof(BlockIndexEntry) * entryCount));
-			if (prev != nullptr) {
-				auto prevTail = prev->tail.load(std::memory_order_relaxed);
-				auto prevPos = prevTail;
-				size_t i = 0;
-				do {
-					prevPos = (prevPos + 1) & (prev->capacity - 1);
-					index[i++] = prev->index[prevPos];
-				} while (prevPos != prevTail);
-				assert(i == prevCapacity);
-			}
-			for (size_t i = 0; i != entryCount; ++i) {
-				new (entries + i) BlockIndexEntry;
-				entries[i].key.store(INVALID_BLOCK_BASE, std::memory_order_relaxed);
-				index[prevCapacity + i] = entries + i;
-			}
-			header->prev = prev;
-			header->entries = entries;
-			header->index = index;
-			header->capacity = nextBlockIndexCapacity;
-			header->tail.store((prevCapacity - 1) & (nextBlockIndexCapacity - 1), std::memory_order_relaxed);
-			
-			blockIndex.store(header, std::memory_order_release);
-			
-			nextBlockIndexCapacity <<= 1;
-			
-			return true;
-		}
-		
-	private:
-		size_t nextBlockIndexCapacity;
-		std::atomic<BlockIndexHeader*> blockIndex;
-
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	public:
-		details::ThreadExitListener threadExitListener;
-	private:
-#endif
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	public:
-		ImplicitProducer* nextImplicitProducer;
-	private:
-#endif
-
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-		mutable debug::DebugMutex mutex;
-#endif
-#ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-	
-	
-	//////////////////////////////////
-	// Block pool manipulation
-	//////////////////////////////////
-	
-	void populate_initial_block_list(size_t blockCount)
-	{
-		initialBlockPoolSize = blockCount;
-		if (initialBlockPoolSize == 0) {
-			initialBlockPool = nullptr;
-			return;
-		}
-		
-		initialBlockPool = create_array<Block>(blockCount);
-		if (initialBlockPool == nullptr) {
-			initialBlockPoolSize = 0;
-		}
-		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
-			initialBlockPool[i].dynamicallyAllocated = false;
-		}
-	}
-	
-	inline Block* try_get_block_from_initial_pool()
-	{
-		if (initialBlockPoolIndex.load(std::memory_order_relaxed) >= initialBlockPoolSize) {
-			return nullptr;
-		}
-		
-		auto index = initialBlockPoolIndex.fetch_add(1, std::memory_order_relaxed);
-		
-		return index < initialBlockPoolSize ? (initialBlockPool + index) : nullptr;
-	}
-	
-	inline void add_block_to_free_list(Block* block)
-	{
-#ifdef MCDBGQ_TRACKMEM
-		block->owner = nullptr;
-#endif
-		freeList.add(block);
-	}
-	
-	inline void add_blocks_to_free_list(Block* block)
-	{
-		while (block != nullptr) {
-			auto next = block->next;
-			add_block_to_free_list(block);
-			block = next;
-		}
-	}
-	
-	inline Block* try_get_block_from_free_list()
-	{
-		return freeList.try_get();
-	}
-	
-	// Gets a free block from one of the memory pools, or allocates a new one (if applicable)
-	template<AllocationMode canAlloc>
-	Block* requisition_block()
-	{
-		auto block = try_get_block_from_initial_pool();
-		if (block != nullptr) {
-			return block;
-		}
-		
-		block = try_get_block_from_free_list();
-		if (block != nullptr) {
-			return block;
-		}
-		
-		MOODYCAMEL_CONSTEXPR_IF (canAlloc == CanAlloc) {
-			return create<Block>();
-		}
-		else {
-			return nullptr;
-		}
-	}
-	
-
-#ifdef MCDBGQ_TRACKMEM
-	public:
-		struct MemStats {
-			size_t allocatedBlocks;
-			size_t usedBlocks;
-			size_t freeBlocks;
-			size_t ownedBlocksExplicit;
-			size_t ownedBlocksImplicit;
-			size_t implicitProducers;
-			size_t explicitProducers;
-			size_t elementsEnqueued;
-			size_t blockClassBytes;
-			size_t queueClassBytes;
-			size_t implicitBlockIndexBytes;
-			size_t explicitBlockIndexBytes;
-			
-			friend class ConcurrentQueue;
-			
-		private:
-			static MemStats getFor(ConcurrentQueue* q)
-			{
-				MemStats stats = { 0 };
-				
-				stats.elementsEnqueued = q->size_approx();
-			
-				auto block = q->freeList.head_unsafe();
-				while (block != nullptr) {
-					++stats.allocatedBlocks;
-					++stats.freeBlocks;
-					block = block->freeListNext.load(std::memory_order_relaxed);
-				}
-				
-				for (auto ptr = q->producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-					bool implicit = dynamic_cast<ImplicitProducer*>(ptr) != nullptr;
-					stats.implicitProducers += implicit ? 1 : 0;
-					stats.explicitProducers += implicit ? 0 : 1;
-					
-					if (implicit) {
-						auto prod = static_cast<ImplicitProducer*>(ptr);
-						stats.queueClassBytes += sizeof(ImplicitProducer);
-						auto head = prod->headIndex.load(std::memory_order_relaxed);
-						auto tail = prod->tailIndex.load(std::memory_order_relaxed);
-						auto hash = prod->blockIndex.load(std::memory_order_relaxed);
-						if (hash != nullptr) {
-							for (size_t i = 0; i != hash->capacity; ++i) {
-								if (hash->index[i]->key.load(std::memory_order_relaxed) != ImplicitProducer::INVALID_BLOCK_BASE && hash->index[i]->value.load(std::memory_order_relaxed) != nullptr) {
-									++stats.allocatedBlocks;
-									++stats.ownedBlocksImplicit;
-								}
-							}
-							stats.implicitBlockIndexBytes += hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry);
-							for (; hash != nullptr; hash = hash->prev) {
-								stats.implicitBlockIndexBytes += sizeof(typename ImplicitProducer::BlockIndexHeader) + hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry*);
-							}
-						}
-						for (; details::circular_less_than<index_t>(head, tail); head += BLOCK_SIZE) {
-							//auto block = prod->get_block_index_entry_for_index(head);
-							++stats.usedBlocks;
-						}
-					}
-					else {
-						auto prod = static_cast<ExplicitProducer*>(ptr);
-						stats.queueClassBytes += sizeof(ExplicitProducer);
-						auto tailBlock = prod->tailBlock;
-						bool wasNonEmpty = false;
-						if (tailBlock != nullptr) {
-							auto block = tailBlock;
-							do {
-								++stats.allocatedBlocks;
-								if (!block->ConcurrentQueue::Block::template is_empty<explicit_context>() || wasNonEmpty) {
-									++stats.usedBlocks;
-									wasNonEmpty = wasNonEmpty || block != tailBlock;
-								}
-								++stats.ownedBlocksExplicit;
-								block = block->next;
-							} while (block != tailBlock);
-						}
-						auto index = prod->blockIndex.load(std::memory_order_relaxed);
-						while (index != nullptr) {
-							stats.explicitBlockIndexBytes += sizeof(typename ExplicitProducer::BlockIndexHeader) + index->size * sizeof(typename ExplicitProducer::BlockIndexEntry);
-							index = static_cast<typename ExplicitProducer::BlockIndexHeader*>(index->prev);
-						}
-					}
-				}
-				
-				auto freeOnInitialPool = q->initialBlockPoolIndex.load(std::memory_order_relaxed) >= q->initialBlockPoolSize ? 0 : q->initialBlockPoolSize - q->initialBlockPoolIndex.load(std::memory_order_relaxed);
-				stats.allocatedBlocks += freeOnInitialPool;
-				stats.freeBlocks += freeOnInitialPool;
-				
-				stats.blockClassBytes = sizeof(Block) * stats.allocatedBlocks;
-				stats.queueClassBytes += sizeof(ConcurrentQueue);
-				
-				return stats;
-			}
-		};
-		
-		// For debugging only. Not thread-safe.
-		MemStats getMemStats()
-		{
-			return MemStats::getFor(this);
-		}
-	private:
-		friend struct MemStats;
-#endif
-	
-	
-	//////////////////////////////////
-	// Producer list manipulation
-	//////////////////////////////////	
-	
-	ProducerBase* recycle_or_create_producer(bool isExplicit)
-	{
-		bool recycled;
-		return recycle_or_create_producer(isExplicit, recycled);
-	}
-	
-	ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
-	{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		// Try to re-use one first
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
-				bool expected = true;
-				if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
-					// We caught one! It's been marked as activated, the caller can have it
-					recycled = true;
-					return ptr;
-				}
-			}
-		}
-		
-		recycled = false;
-		return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
-	}
-	
-	ProducerBase* add_producer(ProducerBase* producer)
-	{
-		// Handle failed memory allocation
-		if (producer == nullptr) {
-			return nullptr;
-		}
-		
-		producerCount.fetch_add(1, std::memory_order_relaxed);
-		
-		// Add it to the lock-free list
-		auto prevTail = producerListTail.load(std::memory_order_relaxed);
-		do {
-			producer->next = prevTail;
-		} while (!producerListTail.compare_exchange_weak(prevTail, producer, std::memory_order_release, std::memory_order_relaxed));
-		
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		if (producer->isExplicit) {
-			auto prevTailExplicit = explicitProducers.load(std::memory_order_relaxed);
-			do {
-				static_cast<ExplicitProducer*>(producer)->nextExplicitProducer = prevTailExplicit;
-			} while (!explicitProducers.compare_exchange_weak(prevTailExplicit, static_cast<ExplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
-		}
-		else {
-			auto prevTailImplicit = implicitProducers.load(std::memory_order_relaxed);
-			do {
-				static_cast<ImplicitProducer*>(producer)->nextImplicitProducer = prevTailImplicit;
-			} while (!implicitProducers.compare_exchange_weak(prevTailImplicit, static_cast<ImplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
-		}
-#endif
-		
-		return producer;
-	}
-	
-	void reown_producers()
-	{
-		// After another instance is moved-into/swapped-with this one, all the
-		// producers we stole still think their parents are the other queue.
-		// So fix them up!
-		for (auto ptr = producerListTail.load(std::memory_order_relaxed); ptr != nullptr; ptr = ptr->next_prod()) {
-			ptr->parent = this;
-		}
-	}
-	
-	
-	//////////////////////////////////
-	// Implicit producer hash
-	//////////////////////////////////
-	
-	struct ImplicitProducerKVP
-	{
-		std::atomic<details::thread_id_t> key;
-		ImplicitProducer* value;		// No need for atomicity since it's only read by the thread that sets it in the first place
-		
-		ImplicitProducerKVP() : value(nullptr) { }
-		
-		ImplicitProducerKVP(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
-		{
-			key.store(other.key.load(std::memory_order_relaxed), std::memory_order_relaxed);
-			value = other.value;
-		}
-		
-		inline ImplicitProducerKVP& operator=(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
-		{
-			swap(other);
-			return *this;
-		}
-		
-		inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
-		{
-			if (this != &other) {
-				details::swap_relaxed(key, other.key);
-				std::swap(value, other.value);
-			}
-		}
-	};
-	
-	template<typename XT, typename XTraits>
-	friend void duckdb_moodycamel::swap(typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&, typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&) MOODYCAMEL_NOEXCEPT;
-	
-	struct ImplicitProducerHash
-	{
-		size_t capacity;
-		ImplicitProducerKVP* entries;
-		ImplicitProducerHash* prev;
-	};
-	
-	inline void populate_initial_implicit_producer_hash()
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
-			return;
-		}
-		else {
-			implicitProducerHashCount.store(0, std::memory_order_relaxed);
-			auto hash = &initialImplicitProducerHash;
-			hash->capacity = INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
-			hash->entries = &initialImplicitProducerHashEntries[0];
-			for (size_t i = 0; i != INITIAL_IMPLICIT_PRODUCER_HASH_SIZE; ++i) {
-				initialImplicitProducerHashEntries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
-			}
-			hash->prev = nullptr;
-			implicitProducerHash.store(hash, std::memory_order_relaxed);
-		}
-	}
-	
-	void swap_implicit_producer_hashes(ConcurrentQueue& other)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
-			return;
-		}
-		else {
-			// Swap (assumes our implicit producer hash is initialized)
-			initialImplicitProducerHashEntries.swap(other.initialImplicitProducerHashEntries);
-			initialImplicitProducerHash.entries = &initialImplicitProducerHashEntries[0];
-			other.initialImplicitProducerHash.entries = &other.initialImplicitProducerHashEntries[0];
-			
-			details::swap_relaxed(implicitProducerHashCount, other.implicitProducerHashCount);
-			
-			details::swap_relaxed(implicitProducerHash, other.implicitProducerHash);
-			if (implicitProducerHash.load(std::memory_order_relaxed) == &other.initialImplicitProducerHash) {
-				implicitProducerHash.store(&initialImplicitProducerHash, std::memory_order_relaxed);
-			}
-			else {
-				ImplicitProducerHash* hash;
-				for (hash = implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &other.initialImplicitProducerHash; hash = hash->prev) {
-					continue;
-				}
-				hash->prev = &initialImplicitProducerHash;
-			}
-			if (other.implicitProducerHash.load(std::memory_order_relaxed) == &initialImplicitProducerHash) {
-				other.implicitProducerHash.store(&other.initialImplicitProducerHash, std::memory_order_relaxed);
-			}
-			else {
-				ImplicitProducerHash* hash;
-				for (hash = other.implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &initialImplicitProducerHash; hash = hash->prev) {
-					continue;
-				}
-				hash->prev = &other.initialImplicitProducerHash;
-			}
-		}
-	}
-	
-	// Only fails (returns nullptr) if memory allocation fails
-	ImplicitProducer* get_or_add_implicit_producer()
-	{
-		// Note that since the data is essentially thread-local (key is thread ID),
-		// there's a reduced need for fences (memory ordering is already consistent
-		// for any individual thread), except for the current table itself.
-		
-		// Start by looking for the thread ID in the current and all previous hash tables.
-		// If it's not found, it must not be in there yet, since this same thread would
-		// have added it previously to one of the tables that we traversed.
-		
-		// Code and algorithm adapted from http://preshing.com/20130605/the-worlds-simplest-lock-free-hash-table
-		
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		
-		auto id = details::thread_id();
-		auto hashedId = details::hash_thread_id(id);
-		
-		auto mainHash = implicitProducerHash.load(std::memory_order_acquire);
-		assert(mainHash != nullptr);  // silence clang-tidy and MSVC warnings (hash cannot be null)
-		for (auto hash = mainHash; hash != nullptr; hash = hash->prev) {
-			// Look for the id in this hash
-			auto index = hashedId;
-			while (true) {		// Not an infinite loop because at least one slot is free in the hash table
-				index &= hash->capacity - 1;
-				
-				auto probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
-				if (probedKey == id) {
-					// Found it! If we had to search several hashes deep, though, we should lazily add it
-					// to the current main hash table to avoid the extended search next time.
-					// Note there's guaranteed to be room in the current hash table since every subsequent
-					// table implicitly reserves space for all previous tables (there's only one
-					// implicitProducerHashCount).
-					auto value = hash->entries[index].value;
-					if (hash != mainHash) {
-						index = hashedId;
-						while (true) {
-							index &= mainHash->capacity - 1;
-							probedKey = mainHash->entries[index].key.load(std::memory_order_relaxed);
-							auto empty = details::invalid_thread_id;
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-							auto reusable = details::invalid_thread_id2;
-							if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed)) ||
-								(probedKey == reusable && mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_acquire, std::memory_order_acquire))) {
-#else
-							if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed))) {
-#endif
-								mainHash->entries[index].value = value;
-								break;
-							}
-							++index;
-						}
-					}
-					
-					return value;
-				}
-				if (probedKey == details::invalid_thread_id) {
-					break;		// Not in this hash table
-				}
-				++index;
-			}
-		}
-		
-		// Insert!
-		auto newCount = 1 + implicitProducerHashCount.fetch_add(1, std::memory_order_relaxed);
-		while (true) {
-			// NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
-			if (newCount >= (mainHash->capacity >> 1) && !implicitProducerHashResizeInProgress.test_and_set(std::memory_order_acquire)) {
-				// We've acquired the resize lock, try to allocate a bigger hash table.
-				// Note the acquire fence synchronizes with the release fence at the end of this block, and hence when
-				// we reload implicitProducerHash it must be the most recent version (it only gets changed within this
-				// locked block).
-				mainHash = implicitProducerHash.load(std::memory_order_acquire);
-				if (newCount >= (mainHash->capacity >> 1)) {
-					auto newCapacity = mainHash->capacity << 1;
-					while (newCount >= (newCapacity >> 1)) {
-						newCapacity <<= 1;
-					}
-					auto raw = static_cast<char*>((Traits::malloc)(sizeof(ImplicitProducerHash) + std::alignment_of<ImplicitProducerKVP>::value - 1 + sizeof(ImplicitProducerKVP) * newCapacity));
-					if (raw == nullptr) {
-						// Allocation failed
-						implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-						implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-						return nullptr;
-					}
-					
-					auto newHash = new (raw) ImplicitProducerHash;
-					newHash->capacity = newCapacity;
-					newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));
-					for (size_t i = 0; i != newCapacity; ++i) {
-						new (newHash->entries + i) ImplicitProducerKVP;
-						newHash->entries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
-					}
-					newHash->prev = mainHash;
-					implicitProducerHash.store(newHash, std::memory_order_release);
-					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
-					mainHash = newHash;
-				}
-				else {
-					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
-				}
-			}
-			
-			// If it's < three-quarters full, add to the old one anyway so that we don't have to wait for the next table
-			// to finish being allocated by another thread (and if we just finished allocating above, the condition will
-			// always be true)
-			if (newCount < (mainHash->capacity >> 1) + (mainHash->capacity >> 2)) {
-				bool recycled;
-				auto producer = static_cast<ImplicitProducer*>(recycle_or_create_producer(false, recycled));
-				if (producer == nullptr) {
-					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-					return nullptr;
-				}
-				if (recycled) {
-					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-				}
-				
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-				producer->threadExitListener.callback = &ConcurrentQueue::implicit_producer_thread_exited_callback;
-				producer->threadExitListener.userData = producer;
-				details::ThreadExitNotifier::subscribe(&producer->threadExitListener);
-#endif
-				
-				auto index = hashedId;
-				while (true) {
-					index &= mainHash->capacity - 1;
-					auto probedKey = mainHash->entries[index].key.load(std::memory_order_relaxed);
-					
-					auto empty = details::invalid_thread_id;
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-					auto reusable = details::invalid_thread_id2;
-					if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed)) ||
-						(probedKey == reusable && mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_acquire, std::memory_order_acquire))) {
-#else
-					if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed))) {
-#endif
-						mainHash->entries[index].value = producer;
-						break;
-					}
-					++index;
-				}
-				return producer;
-			}
-			
-			// Hmm, the old hash is quite full and somebody else is busy allocating a new one.
-			// We need to wait for the allocating thread to finish (if it succeeds, we add, if not,
-			// we try to allocate ourselves).
-			mainHash = implicitProducerHash.load(std::memory_order_acquire);
-		}
-	}
-	
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	void implicit_producer_thread_exited(ImplicitProducer* producer)
-	{
-		// Remove from thread exit listeners
-		details::ThreadExitNotifier::unsubscribe(&producer->threadExitListener);
-		
-		// Remove from hash
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		auto hash = implicitProducerHash.load(std::memory_order_acquire);
-		assert(hash != nullptr);		// The thread exit listener is only registered if we were added to a hash in the first place
-		auto id = details::thread_id();
-		auto hashedId = details::hash_thread_id(id);
-		details::thread_id_t probedKey;
-		
-		// We need to traverse all the hashes just in case other threads aren't on the current one yet and are
-		// trying to add an entry thinking there's a free slot (because they reused a producer)
-		for (; hash != nullptr; hash = hash->prev) {
-			auto index = hashedId;
-			do {
-				index &= hash->capacity - 1;
-				probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
-				if (probedKey == id) {
-					hash->entries[index].key.store(details::invalid_thread_id2, std::memory_order_release);
-					break;
-				}
-				++index;
-			} while (probedKey != details::invalid_thread_id);		// Can happen if the hash has changed but we weren't put back in it yet, or if we weren't added to this hash in the first place
-		}
-		
-		// Mark the queue as being recyclable
-		producer->inactive.store(true, std::memory_order_release);
-	}
-	
-	static void implicit_producer_thread_exited_callback(void* userData)
-	{
-		auto producer = static_cast<ImplicitProducer*>(userData);
-		auto queue = producer->parent;
-		queue->implicit_producer_thread_exited(producer);
-	}
-#endif
-	
-	//////////////////////////////////
-	// Utility functions
-	//////////////////////////////////
-
-	template<typename TAlign>
-	static inline void* aligned_malloc(size_t size)
-	{
-		if (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
-			return (Traits::malloc)(size);
-		size_t alignment = std::alignment_of<TAlign>::value;
-		void* raw = (Traits::malloc)(size + alignment - 1 + sizeof(void*));
-		if (!raw)
-			return nullptr;
-		char* ptr = details::align_for<TAlign>(reinterpret_cast<char*>(raw) + sizeof(void*));
-		*(reinterpret_cast<void**>(ptr) - 1) = raw;
-		return ptr;
-	}
-
-	template<typename TAlign>
-	static inline void aligned_free(void* ptr)
-	{
-		if (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
-			return (Traits::free)(ptr);
-		(Traits::free)(ptr ? *(reinterpret_cast<void**>(ptr) - 1) : nullptr);
-	}
-
-	template<typename U>
-	static inline U* create_array(size_t count)
-	{
-		assert(count > 0);
-		U* p = static_cast<U*>(aligned_malloc<U>(sizeof(U) * count));
-		if (p == nullptr)
-			return nullptr;
-
-		for (size_t i = 0; i != count; ++i)
-			new (p + i) U();
-		return p;
-	}
-
-	template<typename U>
-	static inline void destroy_array(U* p, size_t count)
-	{
-		if (p != nullptr) {
-			assert(count > 0);
-			for (size_t i = count; i != 0; )
-				(p + --i)->~U();
-		}
-		aligned_free<U>(p);
-	}
-
-	template<typename U>
-	static inline U* create()
-	{
-		void* p = aligned_malloc<U>(sizeof(U));
-		return p != nullptr ? new (p) U : nullptr;
-	}
-
-	template<typename U, typename A1>
-	static inline U* create(A1&& a1)
-	{
-		void* p = aligned_malloc<U>(sizeof(U));
-		return p != nullptr ? new (p) U(std::forward<A1>(a1)) : nullptr;
-	}
-
-	template<typename U>
-	static inline void destroy(U* p)
-	{
-		if (p != nullptr)
-			p->~U();
-		aligned_free<U>(p);
-	}
-
-private:
-	std::atomic<ProducerBase*> producerListTail;
-	std::atomic<std::uint32_t> producerCount;
-	
-	std::atomic<size_t> initialBlockPoolIndex;
-	Block* initialBlockPool;
-	size_t initialBlockPoolSize;
-	
-#ifndef MCDBGQ_USEDEBUGFREELIST
-	FreeList<Block> freeList;
-#else
-	debug::DebugFreeList<Block> freeList;
-#endif
-	
-	std::atomic<ImplicitProducerHash*> implicitProducerHash;
-	std::atomic<size_t> implicitProducerHashCount;		// Number of slots logically used
-	ImplicitProducerHash initialImplicitProducerHash;
-	std::array<ImplicitProducerKVP, INITIAL_IMPLICIT_PRODUCER_HASH_SIZE> initialImplicitProducerHashEntries;
-	std::atomic_flag implicitProducerHashResizeInProgress;
-	
-	std::atomic<std::uint32_t> nextExplicitConsumerId;
-	std::atomic<std::uint32_t> globalExplicitConsumerOffset;
-	
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-	debug::DebugMutex implicitProdMutex;
-#endif
-	
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	std::atomic<ExplicitProducer*> explicitProducers;
-	std::atomic<ImplicitProducer*> implicitProducers;
-#endif
-};
-
-
-template<typename T, typename Traits>
-ProducerToken::ProducerToken(ConcurrentQueue<T, Traits>& queue)
-	: producer(queue.recycle_or_create_producer(true))
-{
-	if (producer != nullptr) {
-		producer->token = this;
-	}
-}
-
-template<typename T, typename Traits>
-ProducerToken::ProducerToken(BlockingConcurrentQueue<T, Traits>& queue)
-	: producer(reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->recycle_or_create_producer(true))
-{
-	if (producer != nullptr) {
-		producer->token = this;
-	}
-}
-
-template<typename T, typename Traits>
-ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)
-	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
-{
-	initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = uint32_t(-1);
-}
-
-template<typename T, typename Traits>
-ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)
-	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
-{
-	initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = uint32_t(-1);
-}
-
-template<typename T, typename Traits>
-inline void swap(ConcurrentQueue<T, Traits>& a, ConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-template<typename T, typename Traits>
-inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-}
-
diff --git a/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h b/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h
deleted file mode 100644
index 904275dfa..000000000
--- a/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h
+++ /dev/null
@@ -1,432 +0,0 @@
-// Provides an efficient implementation of a semaphore (LightweightSemaphore).
-// This is an extension of Jeff Preshing's sempahore implementation (licensed
-// under the terms of its separate zlib license) that has been adapted and
-// extended by Cameron Desrochers.
-
-#pragma once
-
-#include <cstddef> // For std::size_t
-#include <atomic>
-#include <type_traits> // For std::make_signed<T>
-
-#if defined(_WIN32)
-// Avoid including windows.h in a header; we only need a handful of
-// items, so we'll redeclare them here (this is relatively safe since
-// the API generally has to remain stable between Windows versions).
-// I know this is an ugly hack but it still beats polluting the global
-// namespace with thousands of generic names or adding a .cpp for nothing.
-extern "C" {
-	struct _SECURITY_ATTRIBUTES;
-	__declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES* lpSemaphoreAttributes, long lInitialCount, long lMaximumCount, const wchar_t* lpName);
-	__declspec(dllimport) int __stdcall CloseHandle(void* hObject);
-	__declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void* hHandle, unsigned long dwMilliseconds);
-	__declspec(dllimport) int __stdcall ReleaseSemaphore(void* hSemaphore, long lReleaseCount, long* lpPreviousCount);
-}
-#elif defined(__MACH__)
-#include <mach/mach.h>
-#elif defined(__unix__)
-#include <semaphore.h>
-#include <chrono>
-#elif defined(__MVS__)
-#include <zos-semaphore.h>
-#include <chrono>
-#endif
-
-namespace duckdb_moodycamel
-{
-namespace details
-{
-
-// Code in the mpmc_sema namespace below is an adaptation of Jeff Preshing's
-// portable + lightweight semaphore implementations, originally from
-// https://github.com/preshing/cpp11-on-multicore/blob/master/common/sema.h
-// LICENSE:
-// Copyright (c) 2015 Jeff Preshing
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//	claim that you wrote the original software. If you use this software
-//	in a product, an acknowledgement in the product documentation would be
-//	appreciated but is not required.
-// 2. Altered source versions must be plainly marked as such, and must not be
-//	misrepresented as being the original software.
-// 3. This notice may not be removed or altered from any source distribution.
-#if defined(_WIN32)
-class Semaphore
-{
-private:
-	void* m_hSema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		const long maxLong = 0x7fffffff;
-		m_hSema = CreateSemaphoreW(nullptr, initialCount, maxLong, nullptr);
-		assert(m_hSema);
-	}
-
-	~Semaphore()
-	{
-		CloseHandle(m_hSema);
-	}
-
-	bool wait()
-	{
-		const unsigned long infinite = 0xffffffff;
-		return WaitForSingleObject(m_hSema, infinite) == 0;
-	}
-
-	bool try_wait()
-	{
-		return WaitForSingleObject(m_hSema, 0) == 0;
-	}
-
-	bool timed_wait(std::uint64_t usecs)
-	{
-		return WaitForSingleObject(m_hSema, (unsigned long)(usecs / 1000)) == 0;
-	}
-
-	void signal(int count = 1)
-	{
-		while (!ReleaseSemaphore(m_hSema, count, nullptr));
-	}
-};
-#elif defined(__MACH__)
-//---------------------------------------------------------
-// Semaphore (Apple iOS and OSX)
-// Can't use POSIX semaphores due to http://lists.apple.com/archives/darwin-kernel/2009/Apr/msg00010.html
-//---------------------------------------------------------
-class Semaphore
-{
-private:
-	semaphore_t m_sema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		kern_return_t rc = semaphore_create(mach_task_self(), &m_sema, SYNC_POLICY_FIFO, initialCount);
-		assert(rc == KERN_SUCCESS);
-		(void)rc;
-	}
-
-	~Semaphore()
-	{
-		semaphore_destroy(mach_task_self(), m_sema);
-	}
-
-	bool wait()
-	{
-		return semaphore_wait(m_sema) == KERN_SUCCESS;
-	}
-
-	bool try_wait()
-	{
-		return timed_wait(0);
-	}
-
-	bool timed_wait(std::uint64_t timeout_usecs)
-	{
-		mach_timespec_t ts;
-		ts.tv_sec = static_cast<unsigned int>(timeout_usecs / 1000000);
-		ts.tv_nsec = (timeout_usecs % 1000000) * 1000;
-
-		// added in OSX 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/modules/Darwin.html
-		kern_return_t rc = semaphore_timedwait(m_sema, ts);
-		return rc == KERN_SUCCESS;
-	}
-
-	void signal()
-	{
-		while (semaphore_signal(m_sema) != KERN_SUCCESS);
-	}
-
-	void signal(int count)
-	{
-		while (count-- > 0)
-		{
-			while (semaphore_signal(m_sema) != KERN_SUCCESS);
-		}
-	}
-};
-#elif defined(__unix__) || defined(__MVS__)
-//---------------------------------------------------------
-// Semaphore (POSIX, Linux, zOS aka MVS)
-//---------------------------------------------------------
-class Semaphore
-{
-private:
-	sem_t m_sema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		int rc = sem_init(&m_sema, 0, initialCount);
-		assert(rc == 0);
-		(void)rc;
-	}
-
-	~Semaphore()
-	{
-		sem_destroy(&m_sema);
-	}
-
-	bool wait()
-	{
-		// http://stackoverflow.com/questions/2013181/gdb-causes-sem-wait-to-fail-with-eintr-error
-		int rc;
-		do {
-			rc = sem_wait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool try_wait()
-	{
-		int rc;
-		do {
-			rc = sem_trywait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool timed_wait(std::uint64_t usecs)
-	{
-		struct timespec ts;
-		const int usecs_in_1_sec = 1000000;
-		const int nsecs_in_1_sec = 1000000000;
-
-		// sem_timedwait needs an absolute time
-		// hence we need to first obtain the current time
-		// and then add the maximum time we want to wait
-		// we want to avoid clock_gettime because of linking issues
-		// chrono -> timespec conversion from here: https://embeddedartistry.com/blog/2019/01/31/converting-between-timespec-stdchrono/
-		auto current_time = std::chrono::system_clock::now();
-		auto secs =  std::chrono::time_point_cast<std::chrono::seconds>(current_time);
-		auto ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(current_time) - std::chrono::time_point_cast<std::chrono::nanoseconds>(secs);
-
-		ts.tv_sec = secs.time_since_epoch().count();
-		ts.tv_nsec = ns.count();
-
-		// now add the time we want to wait
-		ts.tv_sec += usecs / usecs_in_1_sec;
-		ts.tv_nsec += (usecs % usecs_in_1_sec) * 1000;
-
-		// sem_timedwait bombs if you have more than 1e9 in tv_nsec
-		// so we have to clean things up before passing it in
-		if (ts.tv_nsec >= nsecs_in_1_sec) {
-			ts.tv_nsec -= nsecs_in_1_sec;
-			++ts.tv_sec;
-		}
-
-		int rc;
-		do {
-			rc = sem_timedwait(&m_sema, &ts);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	void signal()
-	{
-		while (sem_post(&m_sema) == -1);
-	}
-
-	void signal(int count)
-	{
-		while (count-- > 0)
-		{
-			while (sem_post(&m_sema) == -1);
-		}
-	}
-};
-#else
-#error Unsupported platform! (No semaphore wrapper available)
-#endif
-
-}	// end namespace details
-
-
-//---------------------------------------------------------
-// LightweightSemaphore
-//---------------------------------------------------------
-class LightweightSemaphore
-{
-public:
-	typedef std::make_signed<std::size_t>::type ssize_t;
-
-private:
-	std::atomic<ssize_t> m_count;
-	details::Semaphore m_sema;
-
-	bool waitWithPartialSpinning(std::int64_t timeout_usecs = -1)
-	{
-		ssize_t oldCount;
-		// Is there a better way to set the initial spin count?
-		// If we lower it to 1000, testBenaphore becomes 15x slower on my Core i7-5930K Windows PC,
-		// as threads start hitting the kernel semaphore.
-		int spin = 10000;
-		while (--spin >= 0)
-		{
-			oldCount = m_count.load(std::memory_order_relaxed);
-			if ((oldCount > 0) && m_count.compare_exchange_strong(oldCount, oldCount - 1, std::memory_order_acquire, std::memory_order_relaxed))
-				return true;
-			std::atomic_signal_fence(std::memory_order_acquire);	 // Prevent the compiler from collapsing the loop.
-		}
-		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
-		if (oldCount > 0)
-			return true;
-		if (timeout_usecs < 0)
-			return m_sema.wait();
-		if (m_sema.timed_wait((std::uint64_t)timeout_usecs))
-			return true;
-		// At this point, we've timed out waiting for the semaphore, but the
-		// count is still decremented indicating we may still be waiting on
-		// it. So we have to re-adjust the count, but only if the semaphore
-		// wasn't signaled enough times for us too since then. If it was, we
-		// need to release the semaphore too.
-		while (true)
-		{
-			oldCount = m_count.load(std::memory_order_acquire);
-			if (oldCount >= 0 && m_sema.try_wait())
-				return true;
-			if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
-				return false;
-		}
-	}
-
-	ssize_t waitManyWithPartialSpinning(ssize_t max, std::int64_t timeout_usecs = -1)
-	{
-		assert(max > 0);
-		ssize_t oldCount;
-		int spin = 10000;
-		while (--spin >= 0)
-		{
-			oldCount = m_count.load(std::memory_order_relaxed);
-			if (oldCount > 0)
-			{
-				ssize_t newCount = oldCount > max ? oldCount - max : 0;
-				if (m_count.compare_exchange_strong(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
-					return oldCount - newCount;
-			}
-			std::atomic_signal_fence(std::memory_order_acquire);
-		}
-		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
-		if (oldCount <= 0)
-		{
-			if (timeout_usecs < 0)
-			{
-				if (!m_sema.wait())
-					return 0;
-			}
-			else if (!m_sema.timed_wait((std::uint64_t)timeout_usecs))
-			{
-				while (true)
-				{
-					oldCount = m_count.load(std::memory_order_acquire);
-					if (oldCount >= 0 && m_sema.try_wait())
-						break;
-					if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
-						return 0;
-				}
-			}
-		}
-		if (max > 1)
-			return 1 + tryWaitMany(max - 1);
-		return 1;
-	}
-
-public:
-	LightweightSemaphore(ssize_t initialCount = 0) : m_count(initialCount)
-	{
-		assert(initialCount >= 0);
-	}
-
-	bool tryWait()
-	{
-		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
-		while (oldCount > 0)
-		{
-			if (m_count.compare_exchange_weak(oldCount, oldCount - 1, std::memory_order_acquire, std::memory_order_relaxed))
-				return true;
-		}
-		return false;
-	}
-
-	bool wait()
-	{
-		return tryWait() || waitWithPartialSpinning();
-	}
-
-	bool wait(std::int64_t timeout_usecs)
-	{
-		return tryWait() || waitWithPartialSpinning(timeout_usecs);
-	}
-
-	// Acquires between 0 and (greedily) max, inclusive
-	ssize_t tryWaitMany(ssize_t max)
-	{
-		assert(max >= 0);
-		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
-		while (oldCount > 0)
-		{
-			ssize_t newCount = oldCount > max ? oldCount - max : 0;
-			if (m_count.compare_exchange_weak(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
-				return oldCount - newCount;
-		}
-		return 0;
-	}
-
-	// Acquires at least one, and (greedily) at most max
-	ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
-	{
-		assert(max >= 0);
-		ssize_t result = tryWaitMany(max);
-		if (result == 0 && max > 0)
-			result = waitManyWithPartialSpinning(max, timeout_usecs);
-		return result;
-	}
-
-	ssize_t waitMany(ssize_t max)
-	{
-		ssize_t result = waitMany(max, -1);
-		assert(result > 0);
-		return result;
-	}
-
-	void signal(ssize_t count = 1)
-	{
-		assert(count >= 0);
-		ssize_t oldCount = m_count.fetch_add(count, std::memory_order_release);
-		ssize_t toRelease = -oldCount < count ? -oldCount : count;
-		if (toRelease > 0)
-		{
-			m_sema.signal((int)toRelease);
-		}
-	}
-
-	ssize_t availableApprox() const
-	{
-		ssize_t count = m_count.load(std::memory_order_relaxed);
-		return count > 0 ? count : 0;
-	}
-};
-
-}   // end namespace duckdb_moodycamel
diff --git a/src/duckdb/third_party/fast_float/fast_float/fast_float.h b/src/duckdb/third_party/fast_float/fast_float/fast_float.h
deleted file mode 100644
index 0ce7d21ad..000000000
--- a/src/duckdb/third_party/fast_float/fast_float/fast_float.h
+++ /dev/null
@@ -1,2505 +0,0 @@
-// duckdb_fast_float by Daniel Lemire
-// duckdb_fast_float by João Paulo Magalhaes
-
-
-// with contributions from Eugene Golushkov
-// with contributions from Maksim Kita
-// with contributions from Marcin Wojdyr
-// with contributions from Neal Richardson
-// with contributions from Tim Paine
-// with contributions from Fabio Pellacini
-
-
-// Permission is hereby granted, free of charge, to any
-// person obtaining a copy of this software and associated
-// documentation files (the "Software"), to deal in the
-// Software without restriction, including without
-// limitation the rights to use, copy, modify, merge,
-// publish, distribute, sublicense, and/or sell copies of
-// the Software, and to permit persons to whom the Software
-// is furnished to do so, subject to the following
-// conditions:
-// 
-// The above copyright notice and this permission notice
-// shall be included in all copies or substantial portions
-// of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-
-#ifndef FASTFLOAT_FAST_FLOAT_H
-#define FASTFLOAT_FAST_FLOAT_H
-
-#include <system_error>
-
-namespace duckdb_fast_float {
-enum chars_format {
-    scientific = 1<<0,
-    fixed = 1<<2,
-    hex = 1<<3,
-    general = fixed | scientific
-};
-
-
-struct from_chars_result {
-  const char *ptr;
-  std::errc ec;
-};
-
-/**
- * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
- * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
- * The resulting floating-point value is the closest floating-point values (using either float or double),
- * using the "round to even" convention for values that would otherwise fall right in-between two values.
- * That is, we provide exact parsing according to the IEEE standard.
- *
- * Given a successful parse, the pointer (`ptr`) in the returned value is set to point right after the
- * parsed number, and the `value` referenced is set to the parsed value. In case of error, the returned
- * `ec` contains a representative error, otherwise the default (`std::errc()`) value is stored.
- *
- * The implementation does not throw and does not allocate memory (e.g., with `new` or `malloc`).
- *
- * Like the C++17 standard, the `duckdb_fast_float::from_chars` functions take an optional last argument of
- * the type `duckdb_fast_float::chars_format`. It is a bitset value: we check whether
- * `fmt & duckdb_fast_float::chars_format::fixed` and `fmt & duckdb_fast_float::chars_format::scientific` are set
- * to determine whether we allowe the fixed point and scientific notation respectively.
- * The default is  `duckdb_fast_float::chars_format::general` which allows both `fixed` and `scientific`.
- */
-template<typename T>
-from_chars_result from_chars(const char *first, const char *last,
-                             T &value, bool strict=false,
-                             const char decimal_separator = '.',
-                             chars_format fmt = chars_format::general)  noexcept;
-
-}
-#endif // FASTFLOAT_FAST_FLOAT_H
-
-#ifndef FASTFLOAT_FLOAT_COMMON_H
-#define FASTFLOAT_FLOAT_COMMON_H
-
-#include <cfloat>
-#include <cstdint>
-#include <cassert>
-
-#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)   \
-       || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
-       || defined(__MINGW64__)                                          \
-       || defined(__s390x__)                                            \
-       || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) \
-       || defined(__EMSCRIPTEN__))
-#define FASTFLOAT_64BIT
-#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86)   \
-     || defined(__arm__) || defined(_M_ARM)                   \
-     || defined(__MINGW32__))
-#define FASTFLOAT_32BIT
-#else
-  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
-  // We can never tell the register width, but the SIZE_MAX is a good approximation.
-  // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability.
-  #if SIZE_MAX == 0xffff
-    #error Unknown platform (16-bit, unsupported)
-  #elif SIZE_MAX == 0xffffffff
-    #define FASTFLOAT_32BIT
-  #elif SIZE_MAX == 0xffffffffffffffff
-    #define FASTFLOAT_64BIT
-  #else
-    #error Unknown platform (not 32-bit, not 64-bit?)
-  #endif
-#endif
-
-#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__))
-#include <intrin.h>
-#endif
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define FASTFLOAT_VISUAL_STUDIO 1
-#endif
-
-#ifdef _WIN32
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <machine/endian.h>
-#elif defined(sun) || defined(__sun)
-#include <sys/byteorder.h>
-#elif defined(__MVS__)
-#include <sys/endian.h>
-#else
-#include <endian.h>
-#endif
-#
-#ifndef __BYTE_ORDER__
-// safe choice
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#endif
-#
-#ifndef __ORDER_LITTLE_ENDIAN__
-// safe choice
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#endif
-#
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#else
-#define FASTFLOAT_IS_BIG_ENDIAN 1
-#endif
-#endif
-
-#ifdef FASTFLOAT_VISUAL_STUDIO
-#define fastfloat_really_inline __forceinline
-#else
-#define fastfloat_really_inline inline __attribute__((always_inline))
-#endif
-
-namespace duckdb_fast_float {
-
-// Compares two ASCII strings in a case insensitive manner.
-inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
-                                  size_t length) {
-  char running_diff{0};
-  for (size_t i = 0; i < length; i++) {
-    running_diff |= (input1[i] ^ input2[i]);
-  }
-  return (running_diff == 0) || (running_diff == 32);
-}
-
-#ifndef FLT_EVAL_METHOD
-#error "FLT_EVAL_METHOD should be defined, please include cfloat."
-#endif
-
-namespace {
-constexpr uint32_t max_digits = 768;
-constexpr uint32_t max_digit_without_overflow = 19;
-constexpr int32_t decimal_point_range = 2047;
-} // namespace
-
-struct value128 {
-  uint64_t low;
-  uint64_t high;
-  value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
-  value128() : low(0), high(0) {}
-};
-
-/* result might be undefined when input_num is zero */
-fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
-  assert(input_num > 0);
-#ifdef FASTFLOAT_VISUAL_STUDIO
-  #if defined(_M_X64) || defined(_M_ARM64)
-  unsigned long leading_zero = 0;
-  // Search the mask data from most significant bit (MSB)
-  // to least significant bit (LSB) for a set bit (1).
-  _BitScanReverse64(&leading_zero, input_num);
-  return (int)(63 - leading_zero);
-  #else
-  int last_bit = 0;
-  if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
-  if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, last_bit |= 16;
-  if(input_num & uint64_t(            0xff00)) input_num >>=  8, last_bit |=  8;
-  if(input_num & uint64_t(              0xf0)) input_num >>=  4, last_bit |=  4;
-  if(input_num & uint64_t(               0xc)) input_num >>=  2, last_bit |=  2;
-  if(input_num & uint64_t(               0x2)) input_num >>=  1, last_bit |=  1;
-  return 63 - last_bit;
-  #endif
-#else
-  return __builtin_clzll(input_num);
-#endif
-}
-
-#ifdef FASTFLOAT_32BIT
-
-// slow emulation routine for 32-bit
-fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
-    return x * (uint64_t)y;
-}
-
-// slow emulation routine for 32-bit
-#if !defined(__MINGW64__)
-fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
-                                          uint64_t *hi) {
-  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
-  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
-  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
-  uint64_t adbc_carry = !!(adbc < ad);
-  uint64_t lo = bd + (adbc << 32);
-  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
-        (adbc_carry << 32) + !!(lo < bd);
-  return lo;
-}
-#endif // !__MINGW64__
-
-#endif // FASTFLOAT_32BIT
-
-
-// compute 64-bit a*b
-fastfloat_really_inline value128 full_multiplication(uint64_t a,
-                                                     uint64_t b) {
-  value128 answer;
-#if defined(FASTFLOAT_VISUAL_STUDIO) && defined(_M_ARM64)
-  // ARM64 has native support for 64-bit multiplications, no need to emulate
-  answer.high = __umulh(a, b);
-  answer.low = a * b;
-#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__))
-  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
-#elif defined(FASTFLOAT_64BIT)
-  __uint128_t r = ((__uint128_t)a) * b;
-  answer.low = uint64_t(r);
-  answer.high = uint64_t(r >> 64);
-#else
-  #error Not implemented
-#endif
-  return answer;
-}
-
-
-struct adjusted_mantissa {
-  uint64_t mantissa{0};
-  int power2{0}; // a negative value indicates an invalid result
-  adjusted_mantissa() = default;
-  bool operator==(const adjusted_mantissa &o) const {
-    return mantissa == o.mantissa && power2 == o.power2;
-  }
-  bool operator!=(const adjusted_mantissa &o) const {
-    return mantissa != o.mantissa || power2 != o.power2;
-  }
-};
-
-struct decimal {
-  uint32_t num_digits{0};
-  int32_t decimal_point{0};
-  bool negative{false};
-  bool truncated{false};
-  uint8_t digits[max_digits];
-  decimal() = default;
-  // Copies are not allowed since this is a fat object.
-  decimal(const decimal &) = delete;
-  // Copies are not allowed since this is a fat object.
-  decimal &operator=(const decimal &) = delete;
-  // Moves are allowed:
-  decimal(decimal &&) = default;
-  decimal &operator=(decimal &&other) = default;
-};
-
-constexpr static double powers_of_ten_double[] = {
-    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
-    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-constexpr static float powers_of_ten_float[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
-                                                1e6, 1e7, 1e8, 1e9, 1e10};
-
-template <typename T> struct binary_format {
-  static inline constexpr int mantissa_explicit_bits();
-  static inline constexpr int minimum_exponent();
-  static inline constexpr int infinite_power();
-  static inline constexpr int sign_index();
-  static inline constexpr int min_exponent_fast_path();
-  static inline constexpr int max_exponent_fast_path();
-  static inline constexpr int max_exponent_round_to_even();
-  static inline constexpr int min_exponent_round_to_even();
-  static inline constexpr uint64_t max_mantissa_fast_path();
-  static inline constexpr int largest_power_of_ten();
-  static inline constexpr int smallest_power_of_ten();
-  static inline constexpr T exact_power_of_ten(int64_t power);
-};
-
-template <> inline constexpr int binary_format<double>::mantissa_explicit_bits() {
-  return 52;
-}
-template <> inline constexpr int binary_format<float>::mantissa_explicit_bits() {
-  return 23;
-}
-
-template <> inline constexpr int binary_format<double>::max_exponent_round_to_even() {
-  return 23;
-}
-
-template <> inline constexpr int binary_format<float>::max_exponent_round_to_even() {
-  return 10;
-}
-
-template <> inline constexpr int binary_format<double>::min_exponent_round_to_even() {
-  return -4;
-}
-
-template <> inline constexpr int binary_format<float>::min_exponent_round_to_even() {
-  return -17;
-}
-
-template <> inline constexpr int binary_format<double>::minimum_exponent() {
-  return -1023;
-}
-template <> inline constexpr int binary_format<float>::minimum_exponent() {
-  return -127;
-}
-
-template <> inline constexpr int binary_format<double>::infinite_power() {
-  return 0x7FF;
-}
-template <> inline constexpr int binary_format<float>::infinite_power() {
-  return 0xFF;
-}
-
-template <> inline constexpr int binary_format<double>::sign_index() { return 63; }
-template <> inline constexpr int binary_format<float>::sign_index() { return 31; }
-
-template <> inline constexpr int binary_format<double>::min_exponent_fast_path() {
-#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
-  return 0;
-#else
-  return -22;
-#endif
-}
-template <> inline constexpr int binary_format<float>::min_exponent_fast_path() {
-#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
-  return 0;
-#else
-  return -10;
-#endif
-}
-
-template <> inline constexpr int binary_format<double>::max_exponent_fast_path() {
-  return 22;
-}
-template <> inline constexpr int binary_format<float>::max_exponent_fast_path() {
-  return 10;
-}
-
-template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
-  return uint64_t(2) << mantissa_explicit_bits();
-}
-template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
-  return uint64_t(2) << mantissa_explicit_bits();
-}
-
-template <>
-inline constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
-  return powers_of_ten_double[power];
-}
-template <>
-inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
-
-  return powers_of_ten_float[power];
-}
-
-
-template <>
-inline constexpr int binary_format<double>::largest_power_of_ten() {
-  return 308;
-}
-template <>
-inline constexpr int binary_format<float>::largest_power_of_ten() {
-  return 38;
-}
-
-template <>
-inline constexpr int binary_format<double>::smallest_power_of_ten() {
-  return -342;
-}
-template <>
-inline constexpr int binary_format<float>::smallest_power_of_ten() {
-  return -65;
-}
-
-} // namespace duckdb_fast_float
-
-// for convenience:
-template<class OStream>
-inline OStream& operator<<(OStream &out, const duckdb_fast_float::decimal &d) {
-  out << "0.";
-  for (size_t i = 0; i < d.num_digits; i++) {
-    out << int32_t(d.digits[i]);
-  }
-  out << " * 10 ** " << d.decimal_point;
-  return out;
-}
-
-#endif
-
-
-#ifndef FASTFLOAT_ASCII_NUMBER_H
-#define FASTFLOAT_ASCII_NUMBER_H
-
-#include <cstdio>
-#include <cctype>
-#include <cstdint>
-#include <cstring>
-
-
-namespace duckdb_fast_float {
-
-// Next function can be micro-optimized, but compilers are entirely
-// able to optimize it well.
-fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
-
-fastfloat_really_inline uint64_t byteswap(uint64_t val) {
-  return (val & 0xFF00000000000000) >> 56
-    | (val & 0x00FF000000000000) >> 40
-    | (val & 0x0000FF0000000000) >> 24
-    | (val & 0x000000FF00000000) >> 8
-    | (val & 0x00000000FF000000) << 8
-    | (val & 0x0000000000FF0000) << 24
-    | (val & 0x000000000000FF00) << 40
-    | (val & 0x00000000000000FF) << 56;
-}
-
-fastfloat_really_inline uint64_t read_u64(const char *chars) {
-  uint64_t val;
-  ::memcpy(&val, chars, sizeof(uint64_t));
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  return val;
-}
-
-fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  ::memcpy(chars, &val, sizeof(uint64_t));
-}
-
-// credit  @aqrit
-fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
-  const uint64_t mask = 0x000000FF000000FF;
-  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
-  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
-  val -= 0x3030303030303030;
-  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
-  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
-  return uint32_t(val);
-}
-
-fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
-  return parse_eight_digits_unrolled(read_u64(chars));
-}
-
-// credit @aqrit
-fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
-  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
-     0x8080808080808080));
-}
-
-fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
-  return is_made_of_eight_digits_fast(read_u64(chars));
-}
-
-struct parsed_number_string {
-  int64_t exponent;
-  uint64_t mantissa;
-  const char *lastmatch;
-  bool negative;
-  bool valid;
-  bool too_many_digits;
-};
-
-
-// Assuming that you use no more than 19 digits, this will
-// parse an ASCII string.
-fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, const char decimal_separator, chars_format fmt, bool strict) noexcept {
-  parsed_number_string answer;
-  answer.valid = false;
-  answer.too_many_digits = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-    if (p == pend) {
-      return answer;
-    }
-    if (!is_integer(*p) && (*p != decimal_separator)) { // a  sign must be followed by an integer or the dot
-      return answer;
-    }
-  }
-  const char *const start_digits = p;
-
-  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
-
-  while ((p != pend)) {
-    if(is_integer(*p)) {
-      // a multiplication by 10 is cheaper than an arbitrary integer
-      // multiplication
-      i = 10 * i +
-          uint64_t(*p - '0'); // might overflow, we will handle the overflow later
-      ++p;
-	  if(p != pend && *p == '_') {
-	    if (strict) {
-	      answer.valid = false;
-	      return answer;
-	    }
-		  // skip 1 underscore if it is not the last character and followed by a digit
-		  ++p;
-		  if(p == pend || !is_integer(*p)) {
-			  return answer;
-		  }
-	  }
-    }
-    else {
-      break;
-    }
-  }
-  const char *const end_of_integer_part = p;
-  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
-  int64_t exponent = 0;
-  if ((p != pend) && (*p == decimal_separator)) {
-    ++p;
-
-    // Fast approach only tested under little endian systems
-    if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-      p += 8;
-      if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-        i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-        p += 8;
-      }
-    }
-
-    int64_t skipped_underscores = 0;
-    while ((p != pend)) {
-      if(is_integer(*p)) {
-        uint8_t digit = uint8_t(*p - '0');
-        ++p;
-        i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
-
-		if(p != pend && *p == '_') {
-		  if (strict) {
-	      answer.valid = false;
-	      return answer;
-	    }
-		  // skip 1 underscore if it is not the last character and followed by a digit
-		  ++p;
-		  ++skipped_underscores;
-		  if(p == pend || !is_integer(*p)) {
-			  return answer;
-		  }
-		}
-      } else {
-		break;
-	  }
-    }
-    exponent = end_of_integer_part + 1 - p + skipped_underscores;
-    digit_count -= exponent;
-  }
-  // we must have encountered at least one integer!
-  if (digit_count == 0) {
-    return answer;
-  }
-  int64_t exp_number = 0;            // explicit exponential part
-  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
-    const char * location_of_e = p;
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    if ((p == pend) || !is_integer(*p)) {
-      if(!(fmt & chars_format::fixed)) {
-        // We are in error.
-        return answer;
-      }
-      // Otherwise, we will be ignoring the 'e'.
-      p = location_of_e;
-    } else {
-      while ((p != pend)) {
-        if(is_integer(*p)) {
-          uint8_t digit = uint8_t(*p - '0');
-          if (exp_number < 0x10000) {
-            exp_number = 10 * exp_number + digit;
-          }
-          ++p;
-
-		  if(p != pend && *p == '_') {
-		    if (strict) {
-	      answer.valid = false;
-	      return answer;
-	    }
-			// skip 1 underscore if it is not the last character and followed by a digit
-			++p;
-			if(p == pend || !is_integer(*p)) {
-				return answer;
-			}
-		  }
-        }
-        else {
-          break;
-        }
-      }
-      if(neg_exp) { exp_number = - exp_number; }
-      exponent += exp_number;
-    }
-  } else {
-    // If it scientific and not fixed, we have to bail out.
-    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
-  }
-  answer.lastmatch = p;
-  answer.valid = true;
-
-  // If we frequently had to deal with long strings of digits,
-  // we could extend our code by using a 128-bit integer instead
-  // of a 64-bit integer. However, this is uncommon.
-  //
-  // We can deal with up to 19 digits.
-  if (digit_count > 19) { // this is uncommon
-    // It is possible that the integer had an overflow.
-    // We have to handle the case where we have 0.0000somenumber.
-    // We need to be mindful of the case where we only have zeroes...
-    // E.g., 0.000000000...000.
-    const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == decimal_separator)) {
-      if(*start == '0') { digit_count --; }
-      start++;
-    }
-    if (digit_count > 19) {
-      answer.too_many_digits = true;
-      // Let us start again, this time, avoiding overflows.
-      i = 0;
-      p = start_digits;
-      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
-      while((i < minimal_nineteen_digit_integer) && (p != pend)) {
-        if (is_integer(*p)){ 
-          i = i * 10 + uint64_t(*p - '0');
-          ++p;
-
-		  if(p != pend && *p == '_') {
-		    if (strict) {
-	      answer.valid = false;
-	      return answer;
-	    }
-			// skip 1 underscore if it is not the last character and followed by a digit
-			++p;
-			if(p == pend || !is_integer(*p)) {
-				answer.valid = false;
-				return answer;
-			}
-		  }
-        }
-		else {
-          break;
-        }
-      }
-      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
-        exponent = end_of_integer_part - p + exp_number;
-      } else { // We have a value with a fractional component.
-          p++; // skip the decimal_separator
-          const char *first_after_period = p;
-          int64_t skipped_underscores = 0;
-          while((i < minimal_nineteen_digit_integer) && (p != pend)) {
-            if(is_integer(*p)) {
-              i = i * 10 + uint64_t(*p - '0');
-              ++p;
-
-			  if(p != pend && *p == '_') {
-				// skip 1 underscore if it is not the last character and followed by a digit
-				++p;
-				++skipped_underscores;
-				if(p == pend || !is_integer(*p)) {
-					answer.valid = false;
-					return answer;
-				}
-			  }
-			}
-            else {
-              break;
-            }
-          }
-          exponent = first_after_period - p + exp_number + skipped_underscores;
-      }
-      // We have now corrected both exponent and i, to a truncated value
-    }
-  }
-  answer.exponent = exponent;
-  answer.mantissa = i;
-  return answer;
-}
-
-
-// This should always succeed since it follows a call to parse_number_string
-// This function could be optimized. In particular, we could stop after 19 digits
-// and try to bail out. Furthermore, we should be able to recover the computed
-// exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend, const char decimal_separator = '.') noexcept {
-  decimal answer;
-  answer.num_digits = 0;
-  answer.decimal_point = 0;
-  answer.truncated = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-  }
-  // skip leading zeroes
-  while ((p != pend) && (*p == '0')) {
-    ++p;
-  }
-  while ((p != pend) && is_integer(*p)) {
-    if (answer.num_digits < max_digits) {
-      answer.digits[answer.num_digits] = uint8_t(*p - '0');
-    }
-    answer.num_digits++;
-    ++p;
-  }
-  if ((p != pend) && (*p == decimal_separator)) {
-    ++p;
-    const char *first_after_period = p;
-    // if we have not yet encountered a zero, we have to skip it as well
-    if(answer.num_digits == 0) {
-      // skip zeros
-      while ((p != pend) && (*p == '0')) {
-       ++p;
-      }
-    }
-    // We expect that this loop will often take the bulk of the running time
-    // because when a value has lots of digits, these digits often
-    while ((p + 8 <= pend) && (answer.num_digits + 8 < max_digits)) {
-      uint64_t val = read_u64(p);
-      if(! is_made_of_eight_digits_fast(val)) { break; }
-      // We have eight digits, process them in one go!
-      val -= 0x3030303030303030;
-      write_u64(answer.digits + answer.num_digits, val);
-      answer.num_digits += 8;
-      p += 8;
-    }
-    while ((p != pend) && is_integer(*p)) {
-      if (answer.num_digits < max_digits) {
-        answer.digits[answer.num_digits] = uint8_t(*p - '0');
-      }
-      answer.num_digits++;
-      ++p;
-    }
-    answer.decimal_point = int32_t(first_after_period - p);
-  }
-  // We want num_digits to be the number of significant digits, excluding
-  // leading *and* trailing zeros! Otherwise the truncated flag later is
-  // going to be misleading.
-  if(answer.num_digits > 0) {
-    // We potentially need the answer.num_digits > 0 guard because we
-    // prune leading zeros. So with answer.num_digits > 0, we know that
-    // we have at least one non-zero digit.
-    const char *preverse = p - 1;
-    int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == decimal_separator)) {
-      if(*preverse == '0') { trailing_zeros++; };
-      --preverse;
-    }
-    answer.decimal_point += int32_t(answer.num_digits);
-    answer.num_digits -= uint32_t(trailing_zeros);
-  }
-  if(answer.num_digits > max_digits) {
-    answer.truncated = true;
-    answer.num_digits = max_digits;
-  }
-  if ((p != pend) && (('e' == *p) || ('E' == *p))) {
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    int32_t exp_number = 0; // exponential part
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      if (exp_number < 0x10000) {
-        exp_number = 10 * exp_number + digit;
-      }
-      ++p;
-    }
-    answer.decimal_point += (neg_exp ? -exp_number : exp_number);
-  }
-  // In very rare cases, we may have fewer than 19 digits, we want to be able to reliably
-  // assume that all digits up to max_digit_without_overflow have been initialized.
-  for(uint32_t i = answer.num_digits; i < max_digit_without_overflow; i++) { answer.digits[i] = 0; }
-
-  return answer;
-}
-} // namespace duckdb_fast_float
-
-#endif
-
-
-#ifndef FASTFLOAT_FAST_TABLE_H
-#define FASTFLOAT_FAST_TABLE_H
-#include <cstdint>
-
-namespace duckdb_fast_float {
-
-/**
- * When mapping numbers from decimal to binary,
- * we go from w * 10^q to m * 2^p but we have
- * 10^q = 5^q * 2^q, so effectively
- * we are trying to match
- * w * 2^q * 5^q to m * 2^p. Thus the powers of two
- * are not a concern since they can be represented
- * exactly using the binary notation, only the powers of five
- * affect the binary significand.
- */
-
-/**
- * The smallest non-zero float (binary64) is 2^−1074.
- * We take as input numbers of the form w x 10^q where w < 2^64.
- * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
- * However, we have that
- * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^−1074.
- * Thus it is possible for a number of the form w * 10^-342 where
- * w is a 64-bit value to be a non-zero floating-point number.
- *********
- * Any number of form w * 10^309 where w>= 1 is going to be
- * infinite in binary64 so we never need to worry about powers
- * of 5 greater than 308.
- */
-template <class unused = void>
-struct powers_template {
-
-constexpr static int smallest_power_of_five = binary_format<double>::smallest_power_of_ten();
-constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
-constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
-// Powers of five from 5^-342 all the way to 5^308 rounded toward one.
-static const uint64_t power_of_five_128[number_of_entries];
-};
-
-template <class unused>
-const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
-        0xeef453d6923bd65a,0x113faa2906a13b3f,
-        0x9558b4661b6565f8,0x4ac7ca59a424c507,
-        0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
-        0xe95a99df8ace6f53,0xf4d82c2c107973dc,
-        0x91d8a02bb6c10594,0x79071b9b8a4be869,
-        0xb64ec836a47146f9,0x9748e2826cdee284,
-        0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
-        0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
-        0xb208ef855c969f4f,0xbdbd2d335e51a935,
-        0xde8b2b66b3bc4723,0xad2c788035e61382,
-        0x8b16fb203055ac76,0x4c3bcb5021afcc31,
-        0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
-        0xd953e8624b85dd78,0xd71d6dad34a2af0d,
-        0x87d4713d6f33aa6b,0x8672648c40e5ad68,
-        0xa9c98d8ccb009506,0x680efdaf511f18c2,
-        0xd43bf0effdc0ba48,0x212bd1b2566def2,
-        0x84a57695fe98746d,0x14bb630f7604b57,
-        0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
-        0xcf42894a5dce35ea,0x52064cac828675b9,
-        0x818995ce7aa0e1b2,0x7343efebd1940993,
-        0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
-        0xca66fa129f9b60a6,0xd41a26e077774ef6,
-        0xfd00b897478238d0,0x8920b098955522b4,
-        0x9e20735e8cb16382,0x55b46e5f5d5535b0,
-        0xc5a890362fddbc62,0xeb2189f734aa831d,
-        0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
-        0x9a6bb0aa55653b2d,0x47b233c92125366e,
-        0xc1069cd4eabe89f8,0x999ec0bb696e840a,
-        0xf148440a256e2c76,0xc00670ea43ca250d,
-        0x96cd2a865764dbca,0x380406926a5e5728,
-        0xbc807527ed3e12bc,0xc605083704f5ecf2,
-        0xeba09271e88d976b,0xf7864a44c633682e,
-        0x93445b8731587ea3,0x7ab3ee6afbe0211d,
-        0xb8157268fdae9e4c,0x5960ea05bad82964,
-        0xe61acf033d1a45df,0x6fb92487298e33bd,
-        0x8fd0c16206306bab,0xa5d3b6d479f8e056,
-        0xb3c4f1ba87bc8696,0x8f48a4899877186c,
-        0xe0b62e2929aba83c,0x331acdabfe94de87,
-        0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
-        0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
-        0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
-        0x892731ac9faf056e,0xbe311c083a225cd2,
-        0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
-        0xd64d3d9db981787d,0x92cbbccdad5b108,
-        0x85f0468293f0eb4e,0x25bbf56008c58ea5,
-        0xa76c582338ed2621,0xaf2af2b80af6f24e,
-        0xd1476e2c07286faa,0x1af5af660db4aee1,
-        0x82cca4db847945ca,0x50d98d9fc890ed4d,
-        0xa37fce126597973c,0xe50ff107bab528a0,
-        0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
-        0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
-        0x9faacf3df73609b1,0x77b191618c54e9ac,
-        0xc795830d75038c1d,0xd59df5b9ef6a2417,
-        0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
-        0x9becce62836ac577,0x4ee367f9430aec32,
-        0xc2e801fb244576d5,0x229c41f793cda73f,
-        0xf3a20279ed56d48a,0x6b43527578c1110f,
-        0x9845418c345644d6,0x830a13896b78aaa9,
-        0xbe5691ef416bd60c,0x23cc986bc656d553,
-        0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
-        0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
-        0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
-        0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
-        0x91376c36d99995be,0x23100809b9c21fa1,
-        0xb58547448ffffb2d,0xabd40a0c2832a78a,
-        0xe2e69915b3fff9f9,0x16c90c8f323f516c,
-        0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
-        0xb1442798f49ffb4a,0x99cd11cfdf41779c,
-        0xdd95317f31c7fa1d,0x40405643d711d583,
-        0x8a7d3eef7f1cfc52,0x482835ea666b2572,
-        0xad1c8eab5ee43b66,0xda3243650005eecf,
-        0xd863b256369d4a40,0x90bed43e40076a82,
-        0x873e4f75e2224e68,0x5a7744a6e804a291,
-        0xa90de3535aaae202,0x711515d0a205cb36,
-        0xd3515c2831559a83,0xd5a5b44ca873e03,
-        0x8412d9991ed58091,0xe858790afe9486c2,
-        0xa5178fff668ae0b6,0x626e974dbe39a872,
-        0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
-        0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
-        0xa139029f6a239f72,0x1c1fffc1ebc44e80,
-        0xc987434744ac874e,0xa327ffb266b56220,
-        0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
-        0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
-        0xc4ce17b399107c22,0xcb550fb4384d21d3,
-        0xf6019da07f549b2b,0x7e2a53a146606a48,
-        0x99c102844f94e0fb,0x2eda7444cbfc426d,
-        0xc0314325637a1939,0xfa911155fefb5308,
-        0xf03d93eebc589f88,0x793555ab7eba27ca,
-        0x96267c7535b763b5,0x4bc1558b2f3458de,
-        0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
-        0xea9c227723ee8bcb,0x465e15a979c1cadc,
-        0x92a1958a7675175f,0xbfacd89ec191ec9,
-        0xb749faed14125d36,0xcef980ec671f667b,
-        0xe51c79a85916f484,0x82b7e12780e7401a,
-        0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
-        0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
-        0xdfbdcece67006ac9,0x67a791e093e1d49a,
-        0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
-        0xaecc49914078536d,0x58fae9f773886e18,
-        0xda7f5bf590966848,0xaf39a475506a899e,
-        0x888f99797a5e012d,0x6d8406c952429603,
-        0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
-        0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
-        0x855c3be0a17fcd26,0x5cf2eea09a55067f,
-        0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
-        0xd0601d8efc57b08b,0xf13b94daf124da26,
-        0x823c12795db6ce57,0x76c53d08d6b70858,
-        0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
-        0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
-        0xfe5d54150b090b02,0xd3f93b35435d7c4c,
-        0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
-        0xc6b8e9b0709f109a,0x359ab6419ca1091b,
-        0xf867241c8cc6d4c0,0xc30163d203c94b62,
-        0x9b407691d7fc44f8,0x79e0de63425dcf1d,
-        0xc21094364dfb5636,0x985915fc12f542e4,
-        0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
-        0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
-        0xbd8430bd08277231,0x50c6ff782a838353,
-        0xece53cec4a314ebd,0xa4f8bf5635246428,
-        0x940f4613ae5ed136,0x871b7795e136be99,
-        0xb913179899f68584,0x28e2557b59846e3f,
-        0xe757dd7ec07426e5,0x331aeada2fe589cf,
-        0x9096ea6f3848984f,0x3ff0d2c85def7621,
-        0xb4bca50b065abe63,0xfed077a756b53a9,
-        0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
-        0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
-        0xb080392cc4349dec,0xbd8d794d96aacfb3,
-        0xdca04777f541c567,0xecf0d7a0fc5583a0,
-        0x89e42caaf9491b60,0xf41686c49db57244,
-        0xac5d37d5b79b6239,0x311c2875c522ced5,
-        0xd77485cb25823ac7,0x7d633293366b828b,
-        0x86a8d39ef77164bc,0xae5dff9c02033197,
-        0xa8530886b54dbdeb,0xd9f57f830283fdfc,
-        0xd267caa862a12d66,0xd072df63c324fd7b,
-        0x8380dea93da4bc60,0x4247cb9e59f71e6d,
-        0xa46116538d0deb78,0x52d9be85f074e608,
-        0xcd795be870516656,0x67902e276c921f8b,
-        0x806bd9714632dff6,0xba1cd8a3db53b6,
-        0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
-        0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
-        0xfad2a4b13d1b5d6c,0x796b805720085f81,
-        0x9cc3a6eec6311a63,0xcbe3303674053bb0,
-        0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
-        0xf4f1b4d515acb93b,0xee92fb5515482d44,
-        0x991711052d8bf3c5,0x751bdd152d4d1c4a,
-        0xbf5cd54678eef0b6,0xd262d45a78a0635d,
-        0xef340a98172aace4,0x86fb897116c87c34,
-        0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
-        0xbae0a846d2195712,0x8974836059cca109,
-        0xe998d258869facd7,0x2bd1a438703fc94b,
-        0x91ff83775423cc06,0x7b6306a34627ddcf,
-        0xb67f6455292cbf08,0x1a3bc84c17b1d542,
-        0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
-        0x8e938662882af53e,0x547eb47b7282ee9c,
-        0xb23867fb2a35b28d,0xe99e619a4f23aa43,
-        0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
-        0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
-        0xae0b158b4738705e,0x9624ab50b148d445,
-        0xd98ddaee19068c76,0x3badd624dd9b0957,
-        0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
-        0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
-        0xd47487cc8470652b,0x7647c3200069671f,
-        0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
-        0xa5fb0a17c777cf09,0xf468107100525890,
-        0xcf79cc9db955c2cc,0x7182148d4066eeb4,
-        0x81ac1fe293d599bf,0xc6f14cd848405530,
-        0xa21727db38cb002f,0xb8ada00e5a506a7c,
-        0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
-        0xfd442e4688bd304a,0x908f4a166d1da663,
-        0x9e4a9cec15763e2e,0x9a598e4e043287fe,
-        0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
-        0xf7549530e188c128,0xd12bee59e68ef47c,
-        0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
-        0xc13a148e3032d6e7,0xe36a52363c1faf01,
-        0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
-        0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
-        0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
-        0xebdf661791d60f56,0x111b495b3464ad21,
-        0x936b9fcebb25c995,0xcab10dd900beec34,
-        0xb84687c269ef3bfb,0x3d5d514f40eea742,
-        0xe65829b3046b0afa,0xcb4a5a3112a5112,
-        0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
-        0xb3f4e093db73a093,0x59ed216765690f56,
-        0xe0f218b8d25088b8,0x306869c13ec3532c,
-        0x8c974f7383725573,0x1e414218c73a13fb,
-        0xafbd2350644eeacf,0xe5d1929ef90898fa,
-        0xdbac6c247d62a583,0xdf45f746b74abf39,
-        0x894bc396ce5da772,0x6b8bba8c328eb783,
-        0xab9eb47c81f5114f,0x66ea92f3f326564,
-        0xd686619ba27255a2,0xc80a537b0efefebd,
-        0x8613fd0145877585,0xbd06742ce95f5f36,
-        0xa798fc4196e952e7,0x2c48113823b73704,
-        0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
-        0x82ef85133de648c4,0x9a984d73dbe722fb,
-        0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
-        0xcc963fee10b7d1b3,0x318df905079926a8,
-        0xffbbcfe994e5c61f,0xfdf17746497f7052,
-        0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
-        0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
-        0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
-        0x9c1661a651213e2d,0x6bea10ca65c084e,
-        0xc31bfa0fe5698db8,0x486e494fcff30a62,
-        0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
-        0x986ddb5c6b3a76b7,0xf89629465a75e01c,
-        0xbe89523386091465,0xf6bbb397f1135823,
-        0xee2ba6c0678b597f,0x746aa07ded582e2c,
-        0x94db483840b717ef,0xa8c2a44eb4571cdc,
-        0xba121a4650e4ddeb,0x92f34d62616ce413,
-        0xe896a0d7e51e1566,0x77b020baf9c81d17,
-        0x915e2486ef32cd60,0xace1474dc1d122e,
-        0xb5b5ada8aaff80b8,0xd819992132456ba,
-        0xe3231912d5bf60e6,0x10e1fff697ed6c69,
-        0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
-        0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
-        0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
-        0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
-        0xad4ab7112eb3929d,0x86c16c98d2c953c6,
-        0xd89d64d57a607744,0xe871c7bf077ba8b7,
-        0x87625f056c7c4a8b,0x11471cd764ad4972,
-        0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
-        0xd389b47879823479,0x4aff1d108d4ec2c3,
-        0x843610cb4bf160cb,0xcedf722a585139ba,
-        0xa54394fe1eedb8fe,0xc2974eb4ee658828,
-        0xce947a3da6a9273e,0x733d226229feea32,
-        0x811ccc668829b887,0x806357d5a3f525f,
-        0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
-        0xc9bcff6034c13052,0xfc89b393dd02f0b5,
-        0xfc2c3f3841f17c67,0xbbac2078d443ace2,
-        0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
-        0xc5029163f384a931,0xa9e795e65d4df11,
-        0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
-        0x99ea0196163fa42e,0x504bced1bf8e4e45,
-        0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
-        0xf07da27a82c37088,0x5d767327bb4e5a4c,
-        0x964e858c91ba2655,0x3a6a07f8d510f86f,
-        0xbbe226efb628afea,0x890489f70a55368b,
-        0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
-        0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
-        0xb77ada0617e3bbcb,0x9ce6ebb40173744,
-        0xe55990879ddcaabd,0xcc420a6a101d0515,
-        0x8f57fa54c2a9eab6,0x9fa946824a12232d,
-        0xb32df8e9f3546564,0x47939822dc96abf9,
-        0xdff9772470297ebd,0x59787e2b93bc56f7,
-        0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
-        0xaefae51477a06b03,0xede622920b6b23f1,
-        0xdab99e59958885c4,0xe95fab368e45eced,
-        0x88b402f7fd75539b,0x11dbcb0218ebb414,
-        0xaae103b5fcd2a881,0xd652bdc29f26a119,
-        0xd59944a37c0752a2,0x4be76d3346f0495f,
-        0x857fcae62d8493a5,0x6f70a4400c562ddb,
-        0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
-        0xd097ad07a71f26b2,0x7e2000a41346a7a7,
-        0x825ecc24c873782f,0x8ed400668c0c28c8,
-        0xa2f67f2dfa90563b,0x728900802f0f32fa,
-        0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
-        0xfea126b7d78186bc,0xe2f610c84987bfa8,
-        0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
-        0xc6ede63fa05d3143,0x91503d1c79720dbb,
-        0xf8a95fcf88747d94,0x75a44c6397ce912a,
-        0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
-        0xc24452da229b021b,0xfbe85badce996168,
-        0xf2d56790ab41c2a2,0xfae27299423fb9c3,
-        0x97c560ba6b0919a5,0xdccd879fc967d41a,
-        0xbdb6b8e905cb600f,0x5400e987bbc1c920,
-        0xed246723473e3813,0x290123e9aab23b68,
-        0x9436c0760c86e30b,0xf9a0b6720aaf6521,
-        0xb94470938fa89bce,0xf808e40e8d5b3e69,
-        0xe7958cb87392c2c2,0xb60b1d1230b20e04,
-        0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
-        0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
-        0xe2280b6c20dd5232,0x25c6da63c38de1b0,
-        0x8d590723948a535f,0x579c487e5a38ad0e,
-        0xb0af48ec79ace837,0x2d835a9df0c6d851,
-        0xdcdb1b2798182244,0xf8e431456cf88e65,
-        0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
-        0xac8b2d36eed2dac5,0xe272467e3d222f3f,
-        0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
-        0x86ccbb52ea94baea,0x98e947129fc2b4e9,
-        0xa87fea27a539e9a5,0x3f2398d747b36224,
-        0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
-        0x83a3eeeef9153e89,0x1953cf68300424ac,
-        0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
-        0xcdb02555653131b6,0x3792f412cb06794d,
-        0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
-        0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
-        0xc8de047564d20a8b,0xf245825a5a445275,
-        0xfb158592be068d2e,0xeed6e2f0f0d56712,
-        0x9ced737bb6c4183d,0x55464dd69685606b,
-        0xc428d05aa4751e4c,0xaa97e14c3c26b886,
-        0xf53304714d9265df,0xd53dd99f4b3066a8,
-        0x993fe2c6d07b7fab,0xe546a8038efe4029,
-        0xbf8fdb78849a5f96,0xde98520472bdd033,
-        0xef73d256a5c0f77c,0x963e66858f6d4440,
-        0x95a8637627989aad,0xdde7001379a44aa8,
-        0xbb127c53b17ec159,0x5560c018580d5d52,
-        0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
-        0x9226712162ab070d,0xcab3961304ca70e8,
-        0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
-        0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
-        0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
-        0xb267ed1940f1c61c,0x55f038b237591ed3,
-        0xdf01e85f912e37a3,0x6b6c46dec52f6688,
-        0x8b61313bbabce2c6,0x2323ac4b3b3da015,
-        0xae397d8aa96c1b77,0xabec975e0a0d081a,
-        0xd9c7dced53c72255,0x96e7bd358c904a21,
-        0x881cea14545c7575,0x7e50d64177da2e54,
-        0xaa242499697392d2,0xdde50bd1d5d0b9e9,
-        0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
-        0x84ec3c97da624ab4,0xbd5af13bef0b113e,
-        0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
-        0xcfb11ead453994ba,0x67de18eda5814af2,
-        0x81ceb32c4b43fcf4,0x80eacf948770ced7,
-        0xa2425ff75e14fc31,0xa1258379a94d028d,
-        0xcad2f7f5359a3b3e,0x96ee45813a04330,
-        0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
-        0x9e74d1b791e07e48,0x775ea264cf55347e,
-        0xc612062576589dda,0x95364afe032a819e,
-        0xf79687aed3eec551,0x3a83ddbd83f52205,
-        0x9abe14cd44753b52,0xc4926a9672793543,
-        0xc16d9a0095928a27,0x75b7053c0f178294,
-        0xf1c90080baf72cb1,0x5324c68b12dd6339,
-        0x971da05074da7bee,0xd3f6fc16ebca5e04,
-        0xbce5086492111aea,0x88f4bb1ca6bcf585,
-        0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
-        0x9392ee8e921d5d07,0x3aff322e62439fd0,
-        0xb877aa3236a4b449,0x9befeb9fad487c3,
-        0xe69594bec44de15b,0x4c2ebe687989a9b4,
-        0x901d7cf73ab0acd9,0xf9d37014bf60a11,
-        0xb424dc35095cd80f,0x538484c19ef38c95,
-        0xe12e13424bb40e13,0x2865a5f206b06fba,
-        0x8cbccc096f5088cb,0xf93f87b7442e45d4,
-        0xafebff0bcb24aafe,0xf78f69a51539d749,
-        0xdbe6fecebdedd5be,0xb573440e5a884d1c,
-        0x89705f4136b4a597,0x31680a88f8953031,
-        0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
-        0xd6bf94d5e57a42bc,0x3d32907604691b4d,
-        0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
-        0xa7c5ac471b478423,0xfcf80dc33721d54,
-        0xd1b71758e219652b,0xd3c36113404ea4a9,
-        0x83126e978d4fdf3b,0x645a1cac083126ea,
-        0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
-        0xcccccccccccccccc,0xcccccccccccccccd,
-        0x8000000000000000,0x0,
-        0xa000000000000000,0x0,
-        0xc800000000000000,0x0,
-        0xfa00000000000000,0x0,
-        0x9c40000000000000,0x0,
-        0xc350000000000000,0x0,
-        0xf424000000000000,0x0,
-        0x9896800000000000,0x0,
-        0xbebc200000000000,0x0,
-        0xee6b280000000000,0x0,
-        0x9502f90000000000,0x0,
-        0xba43b74000000000,0x0,
-        0xe8d4a51000000000,0x0,
-        0x9184e72a00000000,0x0,
-        0xb5e620f480000000,0x0,
-        0xe35fa931a0000000,0x0,
-        0x8e1bc9bf04000000,0x0,
-        0xb1a2bc2ec5000000,0x0,
-        0xde0b6b3a76400000,0x0,
-        0x8ac7230489e80000,0x0,
-        0xad78ebc5ac620000,0x0,
-        0xd8d726b7177a8000,0x0,
-        0x878678326eac9000,0x0,
-        0xa968163f0a57b400,0x0,
-        0xd3c21bcecceda100,0x0,
-        0x84595161401484a0,0x0,
-        0xa56fa5b99019a5c8,0x0,
-        0xcecb8f27f4200f3a,0x0,
-        0x813f3978f8940984,0x4000000000000000,
-        0xa18f07d736b90be5,0x5000000000000000,
-        0xc9f2c9cd04674ede,0xa400000000000000,
-        0xfc6f7c4045812296,0x4d00000000000000,
-        0x9dc5ada82b70b59d,0xf020000000000000,
-        0xc5371912364ce305,0x6c28000000000000,
-        0xf684df56c3e01bc6,0xc732000000000000,
-        0x9a130b963a6c115c,0x3c7f400000000000,
-        0xc097ce7bc90715b3,0x4b9f100000000000,
-        0xf0bdc21abb48db20,0x1e86d40000000000,
-        0x96769950b50d88f4,0x1314448000000000,
-        0xbc143fa4e250eb31,0x17d955a000000000,
-        0xeb194f8e1ae525fd,0x5dcfab0800000000,
-        0x92efd1b8d0cf37be,0x5aa1cae500000000,
-        0xb7abc627050305ad,0xf14a3d9e40000000,
-        0xe596b7b0c643c719,0x6d9ccd05d0000000,
-        0x8f7e32ce7bea5c6f,0xe4820023a2000000,
-        0xb35dbf821ae4f38b,0xdda2802c8a800000,
-        0xe0352f62a19e306e,0xd50b2037ad200000,
-        0x8c213d9da502de45,0x4526f422cc340000,
-        0xaf298d050e4395d6,0x9670b12b7f410000,
-        0xdaf3f04651d47b4c,0x3c0cdd765f114000,
-        0x88d8762bf324cd0f,0xa5880a69fb6ac800,
-        0xab0e93b6efee0053,0x8eea0d047a457a00,
-        0xd5d238a4abe98068,0x72a4904598d6d880,
-        0x85a36366eb71f041,0x47a6da2b7f864750,
-        0xa70c3c40a64e6c51,0x999090b65f67d924,
-        0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
-        0x82818f1281ed449f,0xbff8f10e7a8921a4,
-        0xa321f2d7226895c7,0xaff72d52192b6a0d,
-        0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
-        0xfee50b7025c36a08,0x2f236d04753d5b4,
-        0x9f4f2726179a2245,0x1d762422c946590,
-        0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
-        0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
-        0x9b934c3b330c8577,0x63cc55f49f88eb2f,
-        0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
-        0xf316271c7fc3908a,0x8bef464e3945ef7a,
-        0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
-        0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
-        0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
-        0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
-        0xb975d6b6ee39e436,0xb3e2fd538e122b44,
-        0xe7d34c64a9c85d44,0x60dbbca87196b616,
-        0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
-        0xb51d13aea4a488dd,0x6babab6398bdbe41,
-        0xe264589a4dcdab14,0xc696963c7eed2dd1,
-        0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
-        0xb0de65388cc8ada8,0x3b25a55f43294bcb,
-        0xdd15fe86affad912,0x49ef0eb713f39ebe,
-        0x8a2dbf142dfcc7ab,0x6e3569326c784337,
-        0xacb92ed9397bf996,0x49c2c37f07965404,
-        0xd7e77a8f87daf7fb,0xdc33745ec97be906,
-        0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
-        0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
-        0xd2d80db02aabd62b,0xf50a3fa490c30190,
-        0x83c7088e1aab65db,0x792667c6da79e0fa,
-        0xa4b8cab1a1563f52,0x577001b891185938,
-        0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
-        0x80b05e5ac60b6178,0x544f8158315b05b4,
-        0xa0dc75f1778e39d6,0x696361ae3db1c721,
-        0xc913936dd571c84c,0x3bc3a19cd1e38e9,
-        0xfb5878494ace3a5f,0x4ab48a04065c723,
-        0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
-        0xc45d1df942711d9a,0x3ba5d0bd324f8394,
-        0xf5746577930d6500,0xca8f44ec7ee36479,
-        0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
-        0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
-        0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
-        0x95d04aee3b80ece5,0xbba1f1d158724a12,
-        0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
-        0xea1575143cf97226,0xf52d09d71a3293bd,
-        0x924d692ca61be758,0x593c2626705f9c56,
-        0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
-        0xe498f455c38b997a,0xb6dfb9c0f956447,
-        0x8edf98b59a373fec,0x4724bd4189bd5eac,
-        0xb2977ee300c50fe7,0x58edec91ec2cb657,
-        0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
-        0x8b865b215899f46c,0xbd79e0d20082ee74,
-        0xae67f1e9aec07187,0xecd8590680a3aa11,
-        0xda01ee641a708de9,0xe80e6f4820cc9495,
-        0x884134fe908658b2,0x3109058d147fdcdd,
-        0xaa51823e34a7eede,0xbd4b46f0599fd415,
-        0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
-        0x850fadc09923329e,0x3e2cf6bc604ddb0,
-        0xa6539930bf6bff45,0x84db8346b786151c,
-        0xcfe87f7cef46ff16,0xe612641865679a63,
-        0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
-        0xa26da3999aef7749,0xe3be5e330f38f09d,
-        0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
-        0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
-        0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
-        0xc646d63501a1511d,0xb281e1fd541501b8,
-        0xf7d88bc24209a565,0x1f225a7ca91a4226,
-        0x9ae757596946075f,0x3375788de9b06958,
-        0xc1a12d2fc3978937,0x52d6b1641c83ae,
-        0xf209787bb47d6b84,0xc0678c5dbd23a49a,
-        0x9745eb4d50ce6332,0xf840b7ba963646e0,
-        0xbd176620a501fbff,0xb650e5a93bc3d898,
-        0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
-        0x93ba47c980e98cdf,0xc66f336c36b10137,
-        0xb8a8d9bbe123f017,0xb80b0047445d4184,
-        0xe6d3102ad96cec1d,0xa60dc059157491e5,
-        0x9043ea1ac7e41392,0x87c89837ad68db2f,
-        0xb454e4a179dd1877,0x29babe4598c311fb,
-        0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
-        0x8ce2529e2734bb1d,0x1899e4a65f58660c,
-        0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
-        0xdc21a1171d42645d,0x76707543f4fa1f73,
-        0x899504ae72497eba,0x6a06494a791c53a8,
-        0xabfa45da0edbde69,0x487db9d17636892,
-        0xd6f8d7509292d603,0x45a9d2845d3c42b6,
-        0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
-        0xa7f26836f282b732,0x8e6cac7768d7141e,
-        0xd1ef0244af2364ff,0x3207d795430cd926,
-        0x8335616aed761f1f,0x7f44e6bd49e807b8,
-        0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
-        0xcd036837130890a1,0x36dba887c37a8c0f,
-        0x802221226be55a64,0xc2494954da2c9789,
-        0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
-        0xc83553c5c8965d3d,0x6f92829494e5acc7,
-        0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
-        0x9c69a97284b578d7,0xff2a760414536efb,
-        0xc38413cf25e2d70d,0xfef5138519684aba,
-        0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
-        0x98bf2f79d5993802,0xef2f773ffbd97a61,
-        0xbeeefb584aff8603,0xaafb550ffacfd8fa,
-        0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
-        0x952ab45cfa97a0b2,0xdd945a747bf26183,
-        0xba756174393d88df,0x94f971119aeef9e4,
-        0xe912b9d1478ceb17,0x7a37cd5601aab85d,
-        0x91abb422ccb812ee,0xac62e055c10ab33a,
-        0xb616a12b7fe617aa,0x577b986b314d6009,
-        0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
-        0x8e41ade9fbebc27d,0x14588f13be847307,
-        0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
-        0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
-        0x8aec23d680043bee,0x25de7bb9480d5854,
-        0xada72ccc20054ae9,0xaf561aa79a10ae6a,
-        0xd910f7ff28069da4,0x1b2ba1518094da04,
-        0x87aa9aff79042286,0x90fb44d2f05d0842,
-        0xa99541bf57452b28,0x353a1607ac744a53,
-        0xd3fa922f2d1675f2,0x42889b8997915ce8,
-        0x847c9b5d7c2e09b7,0x69956135febada11,
-        0xa59bc234db398c25,0x43fab9837e699095,
-        0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
-        0x8161afb94b44f57d,0x1d1be0eebac278f5,
-        0xa1ba1ba79e1632dc,0x6462d92a69731732,
-        0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
-        0xfcb2cb35e702af78,0x5cda735244c3d43e,
-        0x9defbf01b061adab,0x3a0888136afa64a7,
-        0xc56baec21c7a1916,0x88aaa1845b8fdd0,
-        0xf6c69a72a3989f5b,0x8aad549e57273d45,
-        0x9a3c2087a63f6399,0x36ac54e2f678864b,
-        0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
-        0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
-        0x969eb7c47859e743,0x9f644ae5a4b1b325,
-        0xbc4665b596706114,0x873d5d9f0dde1fee,
-        0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
-        0x9316ff75dd87cbd8,0x9a7f12442d588f2,
-        0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
-        0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
-        0x8fa475791a569d10,0xf96e017d694487bc,
-        0xb38d92d760ec4455,0x37c981dcc395a9ac,
-        0xe070f78d3927556a,0x85bbe253f47b1417,
-        0x8c469ab843b89562,0x93956d7478ccec8e,
-        0xaf58416654a6babb,0x387ac8d1970027b2,
-        0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
-        0x88fcf317f22241e2,0x441fece3bdf81f03,
-        0xab3c2fddeeaad25a,0xd527e81cad7626c3,
-        0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
-        0x85c7056562757456,0xf6872d5667844e49,
-        0xa738c6bebb12d16c,0xb428f8ac016561db,
-        0xd106f86e69d785c7,0xe13336d701beba52,
-        0x82a45b450226b39c,0xecc0024661173473,
-        0xa34d721642b06084,0x27f002d7f95d0190,
-        0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
-        0xff290242c83396ce,0x7e67047175a15271,
-        0x9f79a169bd203e41,0xf0062c6e984d386,
-        0xc75809c42c684dd1,0x52c07b78a3e60868,
-        0xf92e0c3537826145,0xa7709a56ccdf8a82,
-        0x9bbcc7a142b17ccb,0x88a66076400bb691,
-        0xc2abf989935ddbfe,0x6acff893d00ea435,
-        0xf356f7ebf83552fe,0x583f6b8c4124d43,
-        0x98165af37b2153de,0xc3727a337a8b704a,
-        0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
-        0xeda2ee1c7064130c,0x1162def06f79df73,
-        0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
-        0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
-        0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
-        0x910ab1d4db9914a0,0x1d9c9892400a22a2,
-        0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
-        0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
-        0x8da471a9de737e24,0x5ceaecfed289e5d2,
-        0xb10d8e1456105dad,0x7425a83e872c5f47,
-        0xdd50f1996b947518,0xd12f124e28f77719,
-        0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
-        0xace73cbfdc0bfb7b,0x636cc64d1001550b,
-        0xd8210befd30efa5a,0x3c47f7e05401aa4e,
-        0x8714a775e3e95c78,0x65acfaec34810a71,
-        0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
-        0xd31045a8341ca07c,0x1ede48111209a050,
-        0x83ea2b892091e44d,0x934aed0aab460432,
-        0xa4e4b66b68b65d60,0xf81da84d5617853f,
-        0xce1de40642e3f4b9,0x36251260ab9d668e,
-        0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
-        0xa1075a24e4421730,0xb24cf65b8612f81f,
-        0xc94930ae1d529cfc,0xdee033f26797b627,
-        0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
-        0x9d412e0806e88aa5,0x8e1f289560ee864e,
-        0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
-        0xf5b5d7ec8acb58a2,0xae10af696774b1db,
-        0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
-        0xbff610b0cc6edd3f,0x17fd090a58d32af3,
-        0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
-        0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
-        0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
-        0xea53df5fd18d5513,0x84c86189216dc5ed,
-        0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
-        0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
-        0xe4d5e82392a40515,0xfabaf3feaa5334a,
-        0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
-        0xb2c71d5bca9023f8,0x743e20e9ef511012,
-        0xdf78e4b2bd342cf6,0x914da9246b255416,
-        0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
-        0xae9672aba3d0c320,0xa184ac2473b529b1,
-        0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
-        0x8865899617fb1871,0x7e2fa67c7a658892,
-        0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
-        0xd51ea6fa85785631,0x552a74227f3ea565,
-        0x8533285c936b35de,0xd53a88958f87275f,
-        0xa67ff273b8460356,0x8a892abaf368f137,
-        0xd01fef10a657842c,0x2d2b7569b0432d85,
-        0x8213f56a67f6b29b,0x9c3b29620e29fc73,
-        0xa298f2c501f45f42,0x8349f3ba91b47b8f,
-        0xcb3f2f7642717713,0x241c70a936219a73,
-        0xfe0efb53d30dd4d7,0xed238cd383aa0110,
-        0x9ec95d1463e8a506,0xf4363804324a40aa,
-        0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
-        0xf81aa16fdc1b81da,0xdd94b7868e94050a,
-        0x9b10a4e5e9913128,0xca7cf2b4191c8326,
-        0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
-        0xf24a01a73cf2dccf,0xbc633b39673c8cec,
-        0x976e41088617ca01,0xd5be0503e085d813,
-        0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
-        0xec9c459d51852ba2,0xddf8e7d60ed1219e,
-        0x93e1ab8252f33b45,0xcabb90e5c942b503,
-        0xb8da1662e7b00a17,0x3d6a751f3b936243,
-        0xe7109bfba19c0c9d,0xcc512670a783ad4,
-        0x906a617d450187e2,0x27fb2b80668b24c5,
-        0xb484f9dc9641e9da,0xb1f9f660802dedf6,
-        0xe1a63853bbd26451,0x5e7873f8a0396973,
-        0x8d07e33455637eb2,0xdb0b487b6423e1e8,
-        0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
-        0xdc5c5301c56b75f7,0x7641a140cc7810fb,
-        0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
-        0xac2820d9623bf429,0x546345fa9fbdcd44,
-        0xd732290fbacaf133,0xa97c177947ad4095,
-        0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
-        0xa81f301449ee8c70,0x5c68f256bfff5a74,
-        0xd226fc195c6a2f8c,0x73832eec6fff3111,
-        0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
-        0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
-        0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
-        0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
-        0xa0555e361951c366,0xd7e105bcc332621f,
-        0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
-        0xfa856334878fc150,0xb14f98f6f0feb951,
-        0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
-        0xc3b8358109e84f07,0xa862f80ec4700c8,
-        0xf4a642e14c6262c8,0xcd27bb612758c0fa,
-        0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
-        0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
-        0xeeea5d5004981478,0x1858ccfce06cac74,
-        0x95527a5202df0ccb,0xf37801e0c43ebc8,
-        0xbaa718e68396cffd,0xd30560258f54e6ba,
-        0xe950df20247c83fd,0x47c6b82ef32a2069,
-        0x91d28b7416cdd27e,0x4cdc331d57fa5441,
-        0xb6472e511c81471d,0xe0133fe4adf8e952,
-        0xe3d8f9e563a198e5,0x58180fddd97723a6,
-        0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
-using powers = powers_template<>;
-
-}
-
-#endif
-
-#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
-#define FASTFLOAT_DECIMAL_TO_BINARY_H
-
-#include <cfloat>
-#include <cinttypes>
-#include <cmath>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
-namespace duckdb_fast_float {
-
-// This will compute or rather approximate w * 5**q and return a pair of 64-bit words approximating
-// the result, with the "high" part corresponding to the most significant bits and the
-// low part corresponding to the least significant bits.
-//
-template <int bit_precision>
-fastfloat_really_inline
-value128 compute_product_approximation(int64_t q, uint64_t w) {
-  const int index = 2 * int(q - powers::smallest_power_of_five);
-  // For small values of q, e.g., q in [0,27], the answer is always exact because
-  // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
-  // gives the exact answer.
-  value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
-  static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should  be in (0,64]");
-  constexpr uint64_t precision_mask = (bit_precision < 64) ?
-               (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
-               : uint64_t(0xFFFFFFFFFFFFFFFF);
-  if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with  (lower + w < lower)
-    // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
-    value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
-    firstproduct.low += secondproduct.high;
-    if(secondproduct.high > firstproduct.low) {
-      firstproduct.high++;
-    }
-  }
-  return firstproduct;
-}
-
-namespace detail {
-/**
- * For q in (0,350), we have that
- *  f = (((152170 + 65536) * q ) >> 16);
- * is equal to
- *   floor(p) + q
- * where
- *   p = log(5**q)/log(2) = q * log(5)/log(2)
- *
- * For negative values of q in (-400,0), we have that 
- *  f = (((152170 + 65536) * q ) >> 16);
- * is equal to 
- *   -ceil(p) + q
- * where
- *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
- */
-  fastfloat_really_inline int power(int q)  noexcept  {
-    return (((152170 + 65536) * q) >> 16) + 63;
-  }
-} // namespace detail
-
-
-// w * 10 ** q
-// The returned value should be a valid ieee64 number that simply need to be packed.
-// However, in some very rare cases, the computation will fail. In such cases, we
-// return an adjusted_mantissa with a negative power of 2: the caller should recompute
-// in such cases.
-template <typename binary>
-fastfloat_really_inline
-adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
-  adjusted_mantissa answer;
-  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
-    answer.power2 = 0;
-    answer.mantissa = 0;
-    // result should be zero
-    return answer;
-  }
-  if (q > binary::largest_power_of_ten()) {
-    // we want to get infinity:
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-    return answer;
-  }
-  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
-
-  // We want the most significant bit of i to be 1. Shift if needed.
-  int lz = leading_zeroes(w);
-  w <<= lz;
-
-  // The required precision is binary::mantissa_explicit_bits() + 3 because
-  // 1. We need the implicit bit
-  // 2. We need an extra bit for rounding purposes
-  // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
-
-  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
-  if(product.low == 0xFFFFFFFFFFFFFFFF) { //  could guard it further
-    // In some very rare cases, this could happen, in which case we might need a more accurate
-    // computation that what we can provide cheaply. This is very, very unlikely.
-    //
-    const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0, 
-    // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
-    if(!inside_safe_exponent) {
-      answer.power2 = -1; // This (a negative value) indicates an error condition.
-      return answer;
-    }
-  }
-  // The "compute_product_approximation" function can be slightly slower than a branchless approach:
-  // value128 product = compute_product(q, w);
-  // but in practice, we can win big with the compute_product_approximation if its additional branch
-  // is easily predicted. Which is best is data specific.
-  int upperbit = int(product.high >> 63);
-
-  answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
-
-  answer.power2 = int(detail::power(int(q)) + upperbit - lz - binary::minimum_exponent());
-  if (answer.power2 <= 0) { // we have a subnormal?
-    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
-    if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
-      answer.power2 = 0;
-      answer.mantissa = 0;
-      // result should be zero
-      return answer;
-    }
-    // next line is safe because -answer.power2 + 1 < 64
-    answer.mantissa >>= -answer.power2 + 1;
-    // Thankfully, we can't have both "round-to-even" and subnormals because
-    // "round-to-even" only occurs for powers close to 0.
-    answer.mantissa += (answer.mantissa & 1); // round up
-    answer.mantissa >>= 1;
-    // There is a weird scenario where we don't have a subnormal but just.
-    // Suppose we start with 2.2250738585072013e-308, we end up
-    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
-    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
-    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
-    // subnormal, but we can only know this after rounding.
-    // So we only declare a subnormal if we are smaller than the threshold.
-    answer.power2 = (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ? 0 : 1;
-    return answer;
-  }
-
-  // usually, we round *up*, but if we fall right in between and and we have an
-  // even basis, we need to round down
-  // We are only concerned with the cases where 5**q fits in single 64-bit word.
-  if ((product.low <= 1) &&  (q >= binary::min_exponent_round_to_even()) && (q <= binary::max_exponent_round_to_even()) &&
-      ((answer.mantissa & 3) == 1) ) { // we may fall between two floats!
-    // To be in-between two floats we need that in doing
-    //   answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
-    // ... we dropped out only zeroes. But if this happened, then we can go back!!!
-    if((answer.mantissa  << (upperbit + 64 - binary::mantissa_explicit_bits() - 3)) ==  product.high) {
-      answer.mantissa &= ~uint64_t(1);          // flip it so that we do not round up
-    }
-  }
-
-  answer.mantissa += (answer.mantissa & 1); // round up
-  answer.mantissa >>= 1;
-  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
-    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
-    answer.power2++; // undo previous addition
-  }
-
-  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
-  if (answer.power2 >= binary::infinite_power()) { // infinity
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-  }
-  return answer;
-}
-
-
-} // namespace duckdb_fast_float
-
-#endif
-
-
-#ifndef FASTFLOAT_ASCII_NUMBER_H
-#define FASTFLOAT_ASCII_NUMBER_H
-
-#include <cstdio>
-#include <cctype>
-#include <cstdint>
-#include <cstring>
-
-
-namespace duckdb_fast_float {
-
-// Next function can be micro-optimized, but compilers are entirely
-// able to optimize it well.
-fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
-
-fastfloat_really_inline uint64_t byteswap(uint64_t val) {
-  return (val & 0xFF00000000000000) >> 56
-    | (val & 0x00FF000000000000) >> 40
-    | (val & 0x0000FF0000000000) >> 24
-    | (val & 0x000000FF00000000) >> 8
-    | (val & 0x00000000FF000000) << 8
-    | (val & 0x0000000000FF0000) << 24
-    | (val & 0x000000000000FF00) << 40
-    | (val & 0x00000000000000FF) << 56;
-}
-
-fastfloat_really_inline uint64_t read_u64(const char *chars) {
-  uint64_t val;
-  ::memcpy(&val, chars, sizeof(uint64_t));
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  return val;
-}
-
-fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  ::memcpy(chars, &val, sizeof(uint64_t));
-}
-
-// credit  @aqrit
-fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
-  const uint64_t mask = 0x000000FF000000FF;
-  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
-  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
-  val -= 0x3030303030303030;
-  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
-  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
-  return uint32_t(val);
-}
-
-fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
-  return parse_eight_digits_unrolled(read_u64(chars));
-}
-
-// credit @aqrit
-fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
-  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
-     0x8080808080808080));
-}
-
-fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
-  return is_made_of_eight_digits_fast(read_u64(chars));
-}
-
-struct parsed_number_string {
-  int64_t exponent;
-  uint64_t mantissa;
-  const char *lastmatch;
-  bool negative;
-  bool valid;
-  bool too_many_digits;
-};
-
-
-// Assuming that you use no more than 19 digits, this will
-// parse an ASCII string.
-fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, const char decimal_separator, chars_format fmt) noexcept {
-  parsed_number_string answer;
-  answer.valid = false;
-  answer.too_many_digits = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-    if (p == pend) {
-      return answer;
-    }
-    if (!is_integer(*p) && (*p != decimal_separator)) { // a  sign must be followed by an integer or the dot
-      return answer;
-    }
-  }
-  const char *const start_digits = p;
-
-  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
-
-  while ((p != pend) && is_integer(*p)) {
-    // a multiplication by 10 is cheaper than an arbitrary integer
-    // multiplication
-    i = 10 * i +
-        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
-    ++p;
-  }
-  const char *const end_of_integer_part = p;
-  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
-  int64_t exponent = 0;
-  if ((p != pend) && (*p == decimal_separator)) {
-    ++p;
-  // Fast approach only tested under little endian systems
-  if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-    p += 8;
-    if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-      p += 8;
-    }
-  }
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      ++p;
-      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
-    }
-    exponent = end_of_integer_part + 1 - p;
-    digit_count -= exponent;
-  }
-  // we must have encountered at least one integer!
-  if (digit_count == 0) {
-    return answer;
-  }
-  int64_t exp_number = 0;            // explicit exponential part
-  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
-    const char * location_of_e = p;
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    if ((p == pend) || !is_integer(*p)) {
-      if(!(fmt & chars_format::fixed)) {
-        // We are in error.
-        return answer;
-      }
-      // Otherwise, we will be ignoring the 'e'.
-      p = location_of_e;
-    } else {
-      while ((p != pend) && is_integer(*p)) {
-        uint8_t digit = uint8_t(*p - '0');
-        if (exp_number < 0x10000) {
-          exp_number = 10 * exp_number + digit;
-        }
-        ++p;
-      }
-      if(neg_exp) { exp_number = - exp_number; }
-      exponent += exp_number;
-    }
-  } else {
-    // If it scientific and not fixed, we have to bail out.
-    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
-  }
-  answer.lastmatch = p;
-  answer.valid = true;
-
-  // If we frequently had to deal with long strings of digits,
-  // we could extend our code by using a 128-bit integer instead
-  // of a 64-bit integer. However, this is uncommon.
-  //
-  // We can deal with up to 19 digits.
-  if (digit_count > 19) { // this is uncommon
-    // It is possible that the integer had an overflow.
-    // We have to handle the case where we have 0.0000somenumber.
-    // We need to be mindful of the case where we only have zeroes...
-    // E.g., 0.000000000...000.
-    const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == decimal_separator)) {
-      if(*start == '0') { digit_count --; }
-      start++;
-    }
-    if (digit_count > 19) {
-      answer.too_many_digits = true;
-      // Let us start again, this time, avoiding overflows.
-      i = 0;
-      p = start_digits;
-      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
-      while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
-        i = i * 10 + uint64_t(*p - '0');
-        ++p;
-      }
-      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
-        exponent = end_of_integer_part - p + exp_number;
-      } else { // We have a value with a fractional component.
-          p++; // skip the decimal_separator
-          const char *first_after_period = p;
-          while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
-            i = i * 10 + uint64_t(*p - '0');
-            ++p;
-          }
-          exponent = first_after_period - p + exp_number;
-      }
-      // We have now corrected both exponent and i, to a truncated value
-    }
-  }
-  answer.exponent = exponent;
-  answer.mantissa = i;
-  return answer;
-}
-
-
-// This should always succeed since it follows a call to parse_number_string
-// This function could be optimized. In particular, we could stop after 19 digits
-// and try to bail out. Furthermore, we should be able to recover the computed
-// exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend, const char decimal_separator) noexcept {
-  decimal answer;
-  answer.num_digits = 0;
-  answer.decimal_point = 0;
-  answer.truncated = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-  }
-  // skip leading zeroes
-  while ((p != pend) && (*p == '0')) {
-    ++p;
-  }
-  while ((p != pend) && is_integer(*p)) {
-    if (answer.num_digits < max_digits) {
-      answer.digits[answer.num_digits] = uint8_t(*p - '0');
-    }
-    answer.num_digits++;
-    ++p;
-  }
-  if ((p != pend) && (*p == decimal_separator)) {
-    ++p;
-    const char *first_after_period = p;
-    // if we have not yet encountered a zero, we have to skip it as well
-    if(answer.num_digits == 0) {
-      // skip zeros
-      while ((p != pend) && (*p == '0')) {
-       ++p;
-      }
-    }
-    // We expect that this loop will often take the bulk of the running time
-    // because when a value has lots of digits, these digits often
-    while ((p + 8 <= pend) && (answer.num_digits + 8 < max_digits)) {
-      uint64_t val = read_u64(p);
-      if(! is_made_of_eight_digits_fast(val)) { break; }
-      // We have eight digits, process them in one go!
-      val -= 0x3030303030303030;
-      write_u64(answer.digits + answer.num_digits, val);
-      answer.num_digits += 8;
-      p += 8;
-    }
-    while ((p != pend) && is_integer(*p)) {
-      if (answer.num_digits < max_digits) {
-        answer.digits[answer.num_digits] = uint8_t(*p - '0');
-      }
-      answer.num_digits++;
-      ++p;
-    }
-    answer.decimal_point = int32_t(first_after_period - p);
-  }
-  // We want num_digits to be the number of significant digits, excluding
-  // leading *and* trailing zeros! Otherwise the truncated flag later is
-  // going to be misleading.
-  if(answer.num_digits > 0) {
-    // We potentially need the answer.num_digits > 0 guard because we
-    // prune leading zeros. So with answer.num_digits > 0, we know that
-    // we have at least one non-zero digit.
-    const char *preverse = p - 1;
-    int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == decimal_separator)) {
-      if(*preverse == '0') { trailing_zeros++; };
-      --preverse;
-    }
-    answer.decimal_point += int32_t(answer.num_digits);
-    answer.num_digits -= uint32_t(trailing_zeros);
-  }
-  if(answer.num_digits > max_digits) {
-    answer.truncated = true;
-    answer.num_digits = max_digits;
-  }
-  if ((p != pend) && (('e' == *p) || ('E' == *p))) {
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    int32_t exp_number = 0; // exponential part
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      if (exp_number < 0x10000) {
-        exp_number = 10 * exp_number + digit;
-      }
-      ++p;
-    }
-    answer.decimal_point += (neg_exp ? -exp_number : exp_number);
-  }
-  // In very rare cases, we may have fewer than 19 digits, we want to be able to reliably
-  // assume that all digits up to max_digit_without_overflow have been initialized.
-  for(uint32_t i = answer.num_digits; i < max_digit_without_overflow; i++) { answer.digits[i] = 0; }
-
-  return answer;
-}
-} // namespace duckdb_fast_float
-
-#endif
-
-
-#ifndef FASTFLOAT_GENERIC_DECIMAL_TO_BINARY_H
-#define FASTFLOAT_GENERIC_DECIMAL_TO_BINARY_H
-
-/**
- * This code is meant to handle the case where we have more than 19 digits.
- *
- * It is based on work by Nigel Tao (at https://github.com/google/wuffs/)
- * who credits Ken Thompson for the design (via a reference to the Go source
- * code).
- *
- * Rob Pike suggested that this algorithm be called "Simple Decimal Conversion".
- *
- * It is probably not very fast but it is a fallback that should almost never
- * be used in real life. Though it is not fast, it is "easily" understood and debugged.
- **/
-#include <cstdint>
-
-namespace duckdb_fast_float {
-
-namespace detail {
-
-// remove all final zeroes
-inline void trim(decimal &h) {
-  while ((h.num_digits > 0) && (h.digits[h.num_digits - 1] == 0)) {
-    h.num_digits--;
-  }
-}
-
-
-
-inline uint32_t number_of_digits_decimal_left_shift(const decimal &h, uint32_t shift) {
-  shift &= 63;
-  const static uint16_t number_of_digits_decimal_left_shift_table[65] = {
-    0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817,
-    0x181D, 0x2024, 0x202B, 0x2033, 0x203C, 0x2846, 0x2850, 0x285B, 0x3067,
-    0x3073, 0x3080, 0x388E, 0x389C, 0x38AB, 0x38BB, 0x40CC, 0x40DD, 0x40EF,
-    0x4902, 0x4915, 0x4929, 0x513E, 0x5153, 0x5169, 0x5180, 0x5998, 0x59B0,
-    0x59C9, 0x61E3, 0x61FD, 0x6218, 0x6A34, 0x6A50, 0x6A6D, 0x6A8B, 0x72AA,
-    0x72C9, 0x72E9, 0x7B0A, 0x7B2B, 0x7B4D, 0x8370, 0x8393, 0x83B7, 0x83DC,
-    0x8C02, 0x8C28, 0x8C4F, 0x9477, 0x949F, 0x94C8, 0x9CF2, 0x051C, 0x051C,
-    0x051C, 0x051C,
-  };
-  uint32_t x_a = number_of_digits_decimal_left_shift_table[shift];
-  uint32_t x_b = number_of_digits_decimal_left_shift_table[shift + 1];
-  uint32_t num_new_digits = x_a >> 11;
-  uint32_t pow5_a = 0x7FF & x_a;
-  uint32_t pow5_b = 0x7FF & x_b;
-  const static uint8_t
-    number_of_digits_decimal_left_shift_table_powers_of_5[0x051C] = {
-        5, 2, 5, 1, 2, 5, 6, 2, 5, 3, 1, 2, 5, 1, 5, 6, 2, 5, 7, 8, 1, 2, 5, 3,
-        9, 0, 6, 2, 5, 1, 9, 5, 3, 1, 2, 5, 9, 7, 6, 5, 6, 2, 5, 4, 8, 8, 2, 8,
-        1, 2, 5, 2, 4, 4, 1, 4, 0, 6, 2, 5, 1, 2, 2, 0, 7, 0, 3, 1, 2, 5, 6, 1,
-        0, 3, 5, 1, 5, 6, 2, 5, 3, 0, 5, 1, 7, 5, 7, 8, 1, 2, 5, 1, 5, 2, 5, 8,
-        7, 8, 9, 0, 6, 2, 5, 7, 6, 2, 9, 3, 9, 4, 5, 3, 1, 2, 5, 3, 8, 1, 4, 6,
-        9, 7, 2, 6, 5, 6, 2, 5, 1, 9, 0, 7, 3, 4, 8, 6, 3, 2, 8, 1, 2, 5, 9, 5,
-        3, 6, 7, 4, 3, 1, 6, 4, 0, 6, 2, 5, 4, 7, 6, 8, 3, 7, 1, 5, 8, 2, 0, 3,
-        1, 2, 5, 2, 3, 8, 4, 1, 8, 5, 7, 9, 1, 0, 1, 5, 6, 2, 5, 1, 1, 9, 2, 0,
-        9, 2, 8, 9, 5, 5, 0, 7, 8, 1, 2, 5, 5, 9, 6, 0, 4, 6, 4, 4, 7, 7, 5, 3,
-        9, 0, 6, 2, 5, 2, 9, 8, 0, 2, 3, 2, 2, 3, 8, 7, 6, 9, 5, 3, 1, 2, 5, 1,
-        4, 9, 0, 1, 1, 6, 1, 1, 9, 3, 8, 4, 7, 6, 5, 6, 2, 5, 7, 4, 5, 0, 5, 8,
-        0, 5, 9, 6, 9, 2, 3, 8, 2, 8, 1, 2, 5, 3, 7, 2, 5, 2, 9, 0, 2, 9, 8, 4,
-        6, 1, 9, 1, 4, 0, 6, 2, 5, 1, 8, 6, 2, 6, 4, 5, 1, 4, 9, 2, 3, 0, 9, 5,
-        7, 0, 3, 1, 2, 5, 9, 3, 1, 3, 2, 2, 5, 7, 4, 6, 1, 5, 4, 7, 8, 5, 1, 5,
-        6, 2, 5, 4, 6, 5, 6, 6, 1, 2, 8, 7, 3, 0, 7, 7, 3, 9, 2, 5, 7, 8, 1, 2,
-        5, 2, 3, 2, 8, 3, 0, 6, 4, 3, 6, 5, 3, 8, 6, 9, 6, 2, 8, 9, 0, 6, 2, 5,
-        1, 1, 6, 4, 1, 5, 3, 2, 1, 8, 2, 6, 9, 3, 4, 8, 1, 4, 4, 5, 3, 1, 2, 5,
-        5, 8, 2, 0, 7, 6, 6, 0, 9, 1, 3, 4, 6, 7, 4, 0, 7, 2, 2, 6, 5, 6, 2, 5,
-        2, 9, 1, 0, 3, 8, 3, 0, 4, 5, 6, 7, 3, 3, 7, 0, 3, 6, 1, 3, 2, 8, 1, 2,
-        5, 1, 4, 5, 5, 1, 9, 1, 5, 2, 2, 8, 3, 6, 6, 8, 5, 1, 8, 0, 6, 6, 4, 0,
-        6, 2, 5, 7, 2, 7, 5, 9, 5, 7, 6, 1, 4, 1, 8, 3, 4, 2, 5, 9, 0, 3, 3, 2,
-        0, 3, 1, 2, 5, 3, 6, 3, 7, 9, 7, 8, 8, 0, 7, 0, 9, 1, 7, 1, 2, 9, 5, 1,
-        6, 6, 0, 1, 5, 6, 2, 5, 1, 8, 1, 8, 9, 8, 9, 4, 0, 3, 5, 4, 5, 8, 5, 6,
-        4, 7, 5, 8, 3, 0, 0, 7, 8, 1, 2, 5, 9, 0, 9, 4, 9, 4, 7, 0, 1, 7, 7, 2,
-        9, 2, 8, 2, 3, 7, 9, 1, 5, 0, 3, 9, 0, 6, 2, 5, 4, 5, 4, 7, 4, 7, 3, 5,
-        0, 8, 8, 6, 4, 6, 4, 1, 1, 8, 9, 5, 7, 5, 1, 9, 5, 3, 1, 2, 5, 2, 2, 7,
-        3, 7, 3, 6, 7, 5, 4, 4, 3, 2, 3, 2, 0, 5, 9, 4, 7, 8, 7, 5, 9, 7, 6, 5,
-        6, 2, 5, 1, 1, 3, 6, 8, 6, 8, 3, 7, 7, 2, 1, 6, 1, 6, 0, 2, 9, 7, 3, 9,
-        3, 7, 9, 8, 8, 2, 8, 1, 2, 5, 5, 6, 8, 4, 3, 4, 1, 8, 8, 6, 0, 8, 0, 8,
-        0, 1, 4, 8, 6, 9, 6, 8, 9, 9, 4, 1, 4, 0, 6, 2, 5, 2, 8, 4, 2, 1, 7, 0,
-        9, 4, 3, 0, 4, 0, 4, 0, 0, 7, 4, 3, 4, 8, 4, 4, 9, 7, 0, 7, 0, 3, 1, 2,
-        5, 1, 4, 2, 1, 0, 8, 5, 4, 7, 1, 5, 2, 0, 2, 0, 0, 3, 7, 1, 7, 4, 2, 2,
-        4, 8, 5, 3, 5, 1, 5, 6, 2, 5, 7, 1, 0, 5, 4, 2, 7, 3, 5, 7, 6, 0, 1, 0,
-        0, 1, 8, 5, 8, 7, 1, 1, 2, 4, 2, 6, 7, 5, 7, 8, 1, 2, 5, 3, 5, 5, 2, 7,
-        1, 3, 6, 7, 8, 8, 0, 0, 5, 0, 0, 9, 2, 9, 3, 5, 5, 6, 2, 1, 3, 3, 7, 8,
-        9, 0, 6, 2, 5, 1, 7, 7, 6, 3, 5, 6, 8, 3, 9, 4, 0, 0, 2, 5, 0, 4, 6, 4,
-        6, 7, 7, 8, 1, 0, 6, 6, 8, 9, 4, 5, 3, 1, 2, 5, 8, 8, 8, 1, 7, 8, 4, 1,
-        9, 7, 0, 0, 1, 2, 5, 2, 3, 2, 3, 3, 8, 9, 0, 5, 3, 3, 4, 4, 7, 2, 6, 5,
-        6, 2, 5, 4, 4, 4, 0, 8, 9, 2, 0, 9, 8, 5, 0, 0, 6, 2, 6, 1, 6, 1, 6, 9,
-        4, 5, 2, 6, 6, 7, 2, 3, 6, 3, 2, 8, 1, 2, 5, 2, 2, 2, 0, 4, 4, 6, 0, 4,
-        9, 2, 5, 0, 3, 1, 3, 0, 8, 0, 8, 4, 7, 2, 6, 3, 3, 3, 6, 1, 8, 1, 6, 4,
-        0, 6, 2, 5, 1, 1, 1, 0, 2, 2, 3, 0, 2, 4, 6, 2, 5, 1, 5, 6, 5, 4, 0, 4,
-        2, 3, 6, 3, 1, 6, 6, 8, 0, 9, 0, 8, 2, 0, 3, 1, 2, 5, 5, 5, 5, 1, 1, 1,
-        5, 1, 2, 3, 1, 2, 5, 7, 8, 2, 7, 0, 2, 1, 1, 8, 1, 5, 8, 3, 4, 0, 4, 5,
-        4, 1, 0, 1, 5, 6, 2, 5, 2, 7, 7, 5, 5, 5, 7, 5, 6, 1, 5, 6, 2, 8, 9, 1,
-        3, 5, 1, 0, 5, 9, 0, 7, 9, 1, 7, 0, 2, 2, 7, 0, 5, 0, 7, 8, 1, 2, 5, 1,
-        3, 8, 7, 7, 7, 8, 7, 8, 0, 7, 8, 1, 4, 4, 5, 6, 7, 5, 5, 2, 9, 5, 3, 9,
-        5, 8, 5, 1, 1, 3, 5, 2, 5, 3, 9, 0, 6, 2, 5, 6, 9, 3, 8, 8, 9, 3, 9, 0,
-        3, 9, 0, 7, 2, 2, 8, 3, 7, 7, 6, 4, 7, 6, 9, 7, 9, 2, 5, 5, 6, 7, 6, 2,
-        6, 9, 5, 3, 1, 2, 5, 3, 4, 6, 9, 4, 4, 6, 9, 5, 1, 9, 5, 3, 6, 1, 4, 1,
-        8, 8, 8, 2, 3, 8, 4, 8, 9, 6, 2, 7, 8, 3, 8, 1, 3, 4, 7, 6, 5, 6, 2, 5,
-        1, 7, 3, 4, 7, 2, 3, 4, 7, 5, 9, 7, 6, 8, 0, 7, 0, 9, 4, 4, 1, 1, 9, 2,
-        4, 4, 8, 1, 3, 9, 1, 9, 0, 6, 7, 3, 8, 2, 8, 1, 2, 5, 8, 6, 7, 3, 6, 1,
-        7, 3, 7, 9, 8, 8, 4, 0, 3, 5, 4, 7, 2, 0, 5, 9, 6, 2, 2, 4, 0, 6, 9, 5,
-        9, 5, 3, 3, 6, 9, 1, 4, 0, 6, 2, 5,
-  };
-  const uint8_t *pow5 =
-      &number_of_digits_decimal_left_shift_table_powers_of_5[pow5_a];
-  uint32_t i = 0;
-  uint32_t n = pow5_b - pow5_a;
-  for (; i < n; i++) {
-    if (i >= h.num_digits) {
-      return num_new_digits - 1;
-    } else if (h.digits[i] == pow5[i]) {
-      continue;
-    } else if (h.digits[i] < pow5[i]) {
-      return num_new_digits - 1;
-    } else {
-      return num_new_digits;
-    }
-  }
-  return num_new_digits;
-}
-
-inline uint64_t round(decimal &h) {
-  if ((h.num_digits == 0) || (h.decimal_point < 0)) {
-    return 0;
-  } else if (h.decimal_point > 18) {
-    return UINT64_MAX;
-  }
-  // at this point, we know that h.decimal_point >= 0
-  uint32_t dp = uint32_t(h.decimal_point);
-  uint64_t n = 0;
-  for (uint32_t i = 0; i < dp; i++) {
-    n = (10 * n) + ((i < h.num_digits) ? h.digits[i] : 0);
-  }
-  bool round_up = false;
-  if (dp < h.num_digits) {
-    round_up = h.digits[dp] >= 5; // normally, we round up  
-    // but we may need to round to even!
-    if ((h.digits[dp] == 5) && (dp + 1 == h.num_digits)) {
-      round_up = h.truncated || ((dp > 0) && (1 & h.digits[dp - 1]));
-    }
-  }
-  if (round_up) {
-    n++;
-  }
-  return n;
-}
-
-// computes h * 2^-shift
-inline void decimal_left_shift(decimal &h, uint32_t shift) {
-  if (h.num_digits == 0) {
-    return;
-  }
-  uint32_t num_new_digits = number_of_digits_decimal_left_shift(h, shift);
-  int32_t read_index = int32_t(h.num_digits - 1);
-  uint32_t write_index = h.num_digits - 1 + num_new_digits;
-  uint64_t n = 0;
-
-  while (read_index >= 0) {
-    n += uint64_t(h.digits[read_index]) << shift;
-    uint64_t quotient = n / 10;
-    uint64_t remainder = n - (10 * quotient);
-    if (write_index < max_digits) {
-      h.digits[write_index] = uint8_t(remainder);
-    } else if (remainder > 0) {
-      h.truncated = true;
-    }
-    n = quotient;
-    write_index--;
-    read_index--;
-  }
-  while (n > 0) {
-    uint64_t quotient = n / 10;
-    uint64_t remainder = n - (10 * quotient);
-    if (write_index < max_digits) {
-      h.digits[write_index] = uint8_t(remainder);
-    } else if (remainder > 0) {
-      h.truncated = true;
-    }
-    n = quotient;
-    write_index--;
-  }
-  h.num_digits += num_new_digits;
-  if (h.num_digits > max_digits) {
-    h.num_digits = max_digits;
-  }
-  h.decimal_point += int32_t(num_new_digits);
-  trim(h);
-}
-
-// computes h * 2^shift
-inline void decimal_right_shift(decimal &h, uint32_t shift) {
-  uint32_t read_index = 0;
-  uint32_t write_index = 0;
-
-  uint64_t n = 0;
-
-  while ((n >> shift) == 0) {
-    if (read_index < h.num_digits) {
-      n = (10 * n) + h.digits[read_index++];
-    } else if (n == 0) {
-      return;
-    } else {
-      while ((n >> shift) == 0) {
-        n = 10 * n;
-        read_index++;
-      }
-      break;
-    }
-  }
-  h.decimal_point -= int32_t(read_index - 1);
-  if (h.decimal_point < -decimal_point_range) { // it is zero
-    h.num_digits = 0;
-    h.decimal_point = 0;
-    h.negative = false;
-    h.truncated = false;
-    return;
-  }
-  uint64_t mask = (uint64_t(1) << shift) - 1;
-  while (read_index < h.num_digits) {
-    uint8_t new_digit = uint8_t(n >> shift);
-    n = (10 * (n & mask)) + h.digits[read_index++];
-    h.digits[write_index++] = new_digit;
-  }
-  while (n > 0) {
-    uint8_t new_digit = uint8_t(n >> shift);
-    n = 10 * (n & mask);
-    if (write_index < max_digits) {
-      h.digits[write_index++] = new_digit;
-    } else if (new_digit > 0) {
-      h.truncated = true;
-    }
-  }
-  h.num_digits = write_index;
-  trim(h);
-}
-
-} // namespace detail
-
-template <typename binary>
-adjusted_mantissa compute_float(decimal &d) {
-  adjusted_mantissa answer;
-  if (d.num_digits == 0) {
-    // should be zero
-    answer.power2 = 0;
-    answer.mantissa = 0;
-    return answer;
-  }
-  // At this point, going further, we can assume that d.num_digits > 0.
-  //
-  // We want to guard against excessive decimal point values because
-  // they can result in long running times. Indeed, we do
-  // shifts by at most 60 bits. We have that log(10**400)/log(2**60) ~= 22
-  // which is fine, but log(10**299995)/log(2**60) ~= 16609 which is not
-  // fine (runs for a long time).
-  //
-  if(d.decimal_point < -324) {
-    // We have something smaller than 1e-324 which is always zero
-    // in binary64 and binary32.
-    // It should be zero.
-    answer.power2 = 0;
-    answer.mantissa = 0;
-    return answer;
-  } else if(d.decimal_point >= 310) {
-    // We have something at least as large as 0.1e310 which is
-    // always infinite.  
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-    return answer;
-  }
-  static const uint32_t max_shift = 60;
-  static const uint32_t num_powers = 19;
-  static const uint8_t decimal_powers[19] = {
-      0,  3,  6,  9,  13, 16, 19, 23, 26, 29, //
-      33, 36, 39, 43, 46, 49, 53, 56, 59,     //
-  };
-  int32_t exp2 = 0;
-  while (d.decimal_point > 0) {
-    uint32_t n = uint32_t(d.decimal_point);
-    uint32_t shift = (n < num_powers) ? decimal_powers[n] : max_shift;
-    detail::decimal_right_shift(d, shift);
-    if (d.decimal_point < -decimal_point_range) {
-      // should be zero
-      answer.power2 = 0;
-      answer.mantissa = 0;
-      return answer;
-    }
-    exp2 += int32_t(shift);
-  }
-  // We shift left toward [1/2 ... 1].
-  while (d.decimal_point <= 0) {
-    uint32_t shift;
-    if (d.decimal_point == 0) {
-      if (d.digits[0] >= 5) {
-        break;
-      }
-      shift = (d.digits[0] < 2) ? 2 : 1;
-    } else {
-      uint32_t n = uint32_t(-d.decimal_point);
-      shift = (n < num_powers) ? decimal_powers[n] : max_shift;
-    }
-    detail::decimal_left_shift(d, shift);
-    if (d.decimal_point > decimal_point_range) {
-      // we want to get infinity:
-      answer.power2 = binary::infinite_power();
-      answer.mantissa = 0;
-      return answer;
-    }
-    exp2 -= int32_t(shift);
-  }
-  // We are now in the range [1/2 ... 1] but the binary format uses [1 ... 2].
-  exp2--;
-  constexpr int32_t minimum_exponent = binary::minimum_exponent();
-  while ((minimum_exponent + 1) > exp2) {
-    uint32_t n = uint32_t((minimum_exponent + 1) - exp2);
-    if (n > max_shift) {
-      n = max_shift;
-    }
-    detail::decimal_right_shift(d, n);
-    exp2 += int32_t(n);
-  }
-  if ((exp2 - minimum_exponent) >= binary::infinite_power()) {
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-    return answer;
-  }
-
-  const int mantissa_size_in_bits = binary::mantissa_explicit_bits() + 1;
-  detail::decimal_left_shift(d, mantissa_size_in_bits);
-
-  uint64_t mantissa = detail::round(d);
-  // It is possible that we have an overflow, in which case we need
-  // to shift back.
-  if(mantissa >= (uint64_t(1) << mantissa_size_in_bits)) {
-    detail::decimal_right_shift(d, 1);
-    exp2 += 1;
-    mantissa = detail::round(d);
-    if ((exp2 - minimum_exponent) >= binary::infinite_power()) {
-      answer.power2 = binary::infinite_power();
-      answer.mantissa = 0;
-      return answer;
-    }
-  }
-  answer.power2 = exp2  - binary::minimum_exponent();
-  if(mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) { answer.power2--; }
-  answer.mantissa = mantissa & ((uint64_t(1) << binary::mantissa_explicit_bits()) - 1);
-  return answer;
-}
-
-template <typename binary>
-adjusted_mantissa parse_long_mantissa(const char *first, const char* last) {
-    decimal d = parse_decimal(first, last);
-    return compute_float<binary>(d);
-}
-
-} // namespace duckdb_fast_float
-#endif
-
-
-#ifndef FASTFLOAT_PARSE_NUMBER_H
-#define FASTFLOAT_PARSE_NUMBER_H
-
-#include <cassert>
-#include <cmath>
-#include <cstring>
-#include <limits>
-#include <system_error>
-
-namespace duckdb_fast_float {
-
-
-namespace detail {
-/**
- * Special case +inf, -inf, nan, infinity, -infinity.
- * The case comparisons could be made much faster given that we know that the
- * strings a null-free and fixed.
- **/
-template <typename T>
-from_chars_result parse_infnan(const char *first, const char *last, T &value)  noexcept  {
-  from_chars_result answer;
-  answer.ptr = first;
-  answer.ec = std::errc(); // be optimistic
-  bool minusSign = false;
-  if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
-      minusSign = true;
-      ++first;
-  }
-  if (last - first >= 3) {
-    if (fastfloat_strncasecmp(first, "nan", 3)) {
-      answer.ptr = (first += 3);
-      value = minusSign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
-      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
-      if(first != last && *first == '(') {
-        for(const char* ptr = first + 1; ptr != last; ++ptr) {
-          if (*ptr == ')') {
-            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
-            break;
-          }
-          else if(!(('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z') || ('0' <= *ptr && *ptr <= '9') || *ptr == '_'))
-            break; // forbidden char, not nan(n-char-seq-opt)
-        }
-      }
-      return answer;
-    }
-    if (fastfloat_strncasecmp(first, "inf", 3)) {
-      if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) {
-        answer.ptr = first + 8;
-      } else {
-        answer.ptr = first + 3;
-      }
-      value = minusSign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
-      return answer;
-    }
-  }
-  answer.ec = std::errc::invalid_argument;
-  return answer;
-}
-
-template<typename T>
-fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
-  uint64_t word = am.mantissa;
-  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
-  word = negative
-  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-   if (std::is_same<T, float>::value) {
-     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
-   } else {
-     ::memcpy(&value, &word, sizeof(T));
-   }
-#else
-   // For little-endian systems:
-   ::memcpy(&value, &word, sizeof(T));
-#endif
-}
-
-} // namespace detail
-
-
-
-template<typename T>
-from_chars_result from_chars(const char *first, const char *last,
-                             T &value, bool strict, const char decimal_separator, chars_format fmt
-                              /*= chars_format::general*/)  noexcept  {
-  static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
-
-
-  from_chars_result answer;
-  if (first == last) {
-    answer.ec = std::errc::invalid_argument;
-    answer.ptr = first;
-    return answer;
-  }
-  parsed_number_string pns = parse_number_string(first, last, decimal_separator, fmt, strict);
-  if (!pns.valid) {
-    return detail::parse_infnan(first, last, value);
-  }
-  answer.ec = std::errc(); // be optimistic
-  answer.ptr = pns.lastmatch;
-  // Next is Clinger's fast path.
-  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format<T>::max_exponent_fast_path() && pns.mantissa <=binary_format<T>::max_mantissa_fast_path() && !pns.too_many_digits) {
-    value = T(pns.mantissa);
-    if (pns.exponent < 0) { value = value / binary_format<T>::exact_power_of_ten(-pns.exponent); }
-    else { value = value * binary_format<T>::exact_power_of_ten(pns.exponent); }
-    if (pns.negative) { value = -value; }
-    return answer;
-  }
-  adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
-  if(pns.too_many_digits) {
-    if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
-      am.power2 = -1; // value is invalid.
-    }
-  }
-  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
-  // then we need to go the long way around again. This is very uncommon.
-  if(am.power2 < 0) { am = parse_long_mantissa<binary_format<T>>(first,last); }
-  detail::to_float(pns.negative, am, value);
-  return answer;
-}
-
-} // namespace duckdb_fast_float
-
-#endif
-
diff --git a/src/duckdb/third_party/fastpforlib/bitpacking.cpp b/src/duckdb/third_party/fastpforlib/bitpacking.cpp
deleted file mode 100644
index 91388868e..000000000
--- a/src/duckdb/third_party/fastpforlib/bitpacking.cpp
+++ /dev/null
@@ -1,1284 +0,0 @@
-#include "bitpacking.h"
-
-#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
diff --git a/src/duckdb/third_party/fastpforlib/bitpacking.h b/src/duckdb/third_party/fastpforlib/bitpacking.h
deleted file mode 100644
index ffe700e30..000000000
--- a/src/duckdb/third_party/fastpforlib/bitpacking.h
+++ /dev/null
@@ -1,278 +0,0 @@
-/**
- * This code is released under the
- * Apache License Version 2.0 http://www.apache.org/licenses/.
- *
- * (c) Daniel Lemire, http://fastpforlib.me/en/
- */
-#pragma once
-#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
diff --git a/src/duckdb/third_party/fastpforlib/bitpackinghelpers.h b/src/duckdb/third_party/fastpforlib/bitpackinghelpers.h
deleted file mode 100644
index 3d3a09256..000000000
--- a/src/duckdb/third_party/fastpforlib/bitpackinghelpers.h
+++ /dev/null
@@ -1,869 +0,0 @@
-/**
-* This code is released under the
-* Apache License Version 2.0 http://www.apache.org/licenses/.
-*
-* (c) Daniel Lemire, http://lemire.me/en/
-*/
-#pragma once
-#include "bitpacking.h"
-
-
-#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");
-	}
-}
-
-// 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");
-	}
-}
-
-// 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");
-	}
-}
-
-// 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");
-	}
-}
-}
-
-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);
-	}
-}
-
-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);
-}
-
-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
diff --git a/src/duckdb/third_party/fmt/format.cc b/src/duckdb/third_party/fmt/format.cc
deleted file mode 100644
index a8d34d5aa..000000000
--- a/src/duckdb/third_party/fmt/format.cc
+++ /dev/null
@@ -1,171 +0,0 @@
-// Formatting library for C++
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "fmt/format-inl.h"
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-template <typename T>
-int format_float(char* buf, std::size_t size, const char* format, int precision,
-                 T value) {
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (precision > 100000)
-    throw std::runtime_error(
-        "fuzz mode - avoid large allocation inside snprintf");
-#endif
-  // Suppress the warning about nonliteral format string.
-  auto snprintf_ptr = FMT_SNPRINTF;
-  return precision < 0 ? snprintf_ptr(buf, size, format, value)
-                       : snprintf_ptr(buf, size, format, precision, value);
-}
-struct sprintf_specs {
-  int precision;
-  char type;
-  bool alt : 1;
-
-  template <typename Char>
-  constexpr sprintf_specs(basic_format_specs<Char> specs)
-      : precision(specs.precision), type(specs.type), alt(specs.alt) {}
-
-  constexpr bool has_precision() const { return precision >= 0; }
-};
-
-// This is deprecated and is kept only to preserve ABI compatibility.
-template <typename Double>
-char* sprintf_format(Double value, internal::buffer<char>& buf,
-                     sprintf_specs specs) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() != 0, "empty buffer");
-
-  // Build format string.
-  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.alt || !specs.type) *format_ptr++ = '#';
-  if (specs.precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
-
-  char type = specs.type;
-
-  if (type == '%')
-    type = 'f';
-  else if (type == 0 || type == 'n')
-    type = 'g';
-#if FMT_MSC_VER
-  if (type == 'F') {
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
-  }
-#endif
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  char* start = nullptr;
-  char* decimal_point_pos = nullptr;
-  for (;;) {
-    std::size_t buffer_size = buf.capacity();
-    start = &buf[0];
-    int result =
-        format_float(start, buffer_size, format, specs.precision, value);
-    if (result >= 0) {
-      unsigned n = internal::to_unsigned(result);
-      if (n < buf.capacity()) {
-        // Find the decimal point.
-        auto p = buf.data(), end = p + n;
-        if (*p == '+' || *p == '-') ++p;
-        if (specs.type != 'a' && specs.type != 'A') {
-          while (p < end && *p >= '0' && *p <= '9') ++p;
-          if (p < end && *p != 'e' && *p != 'E') {
-            decimal_point_pos = p;
-            if (!specs.type) {
-              // Keep only one trailing zero after the decimal point.
-              ++p;
-              if (*p == '0') ++p;
-              while (p != end && *p >= '1' && *p <= '9') ++p;
-              char* where = p;
-              while (p != end && *p == '0') ++p;
-              if (p == end || *p < '0' || *p > '9') {
-                if (p != end) std::memmove(where, p, to_unsigned(end - p));
-                n -= static_cast<unsigned>(p - where);
-              }
-            }
-          }
-        }
-        buf.resize(n);
-        break;  // The buffer is large enough - continue with formatting.
-      }
-      buf.reserve(n + 1);
-    } else {
-      // If result is negative we ask to increase the capacity by at least 1,
-      // but as std::vector, the buffer grows exponentially.
-      buf.reserve(buf.capacity() + 1);
-    }
-  }
-  return decimal_point_pos;
-}
-}  // namespace internal
-
-template FMT_API char* internal::sprintf_format(double, internal::buffer<char>&,
-                                                sprintf_specs);
-template FMT_API char* internal::sprintf_format(long double,
-                                                internal::buffer<char>&,
-                                                sprintf_specs);
-
-template struct FMT_API internal::basic_data<void>;
-
-// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
-int (*instantiate_format_float)(double, int, internal::float_specs,
-                                internal::buffer<char>&) =
-    internal::format_float;
-
-// Explicit instantiations for char.
-
-template FMT_API std::string internal::grouping_impl<char>(locale_ref);
-template FMT_API char internal::thousands_sep_impl(locale_ref);
-template FMT_API char internal::decimal_point_impl(locale_ref);
-
-template FMT_API void internal::buffer<char>::append(const char*, const char*);
-
-template FMT_API void internal::arg_map<format_context>::init(
-    const basic_format_args<format_context>& args);
-
-template FMT_API std::string internal::vformat<char>(
-    string_view, basic_format_args<format_context>);
-
-template FMT_API format_context::iterator internal::vformat_to(
-    internal::buffer<char>&, string_view, basic_format_args<format_context>);
-
-template FMT_API int internal::snprintf_float(double, int,
-                                              internal::float_specs,
-                                              internal::buffer<char>&);
-template FMT_API int internal::snprintf_float(long double, int,
-                                              internal::float_specs,
-                                              internal::buffer<char>&);
-template FMT_API int internal::format_float(double, int, internal::float_specs,
-                                            internal::buffer<char>&);
-template FMT_API int internal::format_float(long double, int,
-                                            internal::float_specs,
-                                            internal::buffer<char>&);
-
-// Explicit instantiations for wchar_t.
-
-template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
-template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
-template FMT_API wchar_t internal::decimal_point_impl(locale_ref);
-
-template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*,
-                                                        const wchar_t*);
-
-template FMT_API std::wstring internal::vformat<wchar_t>(
-    wstring_view, basic_format_args<wformat_context>);
-FMT_END_NAMESPACE
diff --git a/src/duckdb/third_party/fmt/include/fmt/core.h b/src/duckdb/third_party/fmt/include/fmt/core.h
deleted file mode 100644
index fe95196b3..000000000
--- a/src/duckdb/third_party/fmt/include/fmt/core.h
+++ /dev/null
@@ -1,1468 +0,0 @@
-// Formatting library for C++ - the core API
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_CORE_H_
-#define FMT_CORE_H_
-
-#include <cstdio>  // std::FILE
-#include <cstring>
-#include <iterator>
-#include <string>
-#include <type_traits>
-
-// The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 60102
-
-#ifdef __has_feature
-#  define FMT_HAS_FEATURE(x) __has_feature(x)
-#else
-#  define FMT_HAS_FEATURE(x) 0
-#endif
-
-#if defined(__has_include) && !defined(__INTELLISENSE__) && \
-    !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
-#  define FMT_HAS_INCLUDE(x) __has_include(x)
-#else
-#  define FMT_HAS_INCLUDE(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__)
-#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#else
-#  define FMT_GCC_VERSION 0
-#endif
-
-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
-#else
-#  define FMT_HAS_GXX_CXX11 0
-#endif
-
-#ifdef __NVCC__
-#  define FMT_NVCC __NVCC__
-#else
-#  define FMT_NVCC 0
-#endif
-
-#ifdef _MSC_VER
-#  define FMT_MSC_VER _MSC_VER
-#else
-#  define FMT_MSC_VER 0
-#endif
-
-// Check if relaxed C++14 constexpr is supported.
-// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
-#if FMT_USE_CONSTEXPR
-#  define FMT_CONSTEXPR inline
-#  define FMT_CONSTEXPR_DECL
-#else
-#  define FMT_CONSTEXPR inline
-#  define FMT_CONSTEXPR_DECL
-#endif
-
-#ifndef FMT_OVERRIDE
-#  if FMT_HAS_FEATURE(cxx_override) || \
-      (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
-#    define FMT_OVERRIDE override
-#  else
-#    define FMT_OVERRIDE
-#  endif
-#endif
-
-// Check if exceptions are disabled.
-#ifndef FMT_EXCEPTIONS
-#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
-      FMT_MSC_VER && !_HAS_EXCEPTIONS
-#    define FMT_EXCEPTIONS 0
-#  else
-#    define FMT_EXCEPTIONS 1
-#  endif
-#endif
-
-// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
-#ifndef FMT_USE_NOEXCEPT
-#  define FMT_USE_NOEXCEPT 0
-#endif
-
-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
-#  define FMT_DETECTED_NOEXCEPT noexcept
-#  define FMT_HAS_CXX11_NOEXCEPT 1
-#else
-#  define FMT_DETECTED_NOEXCEPT throw()
-#  define FMT_HAS_CXX11_NOEXCEPT 0
-#endif
-
-#ifndef FMT_NOEXCEPT
-#  if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
-#    define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
-#  else
-#    define FMT_NOEXCEPT
-#  endif
-#endif
-
-// [[noreturn]] is disabled on MSVC because of bogus unreachable code warnings.
-#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER
-#  define FMT_NORETURN [[noreturn]]
-#else
-#  define FMT_NORETURN
-#endif
-
-#ifndef FMT_DEPRECATED
-#  if (FMT_HAS_CPP_ATTRIBUTE(deprecated) && __cplusplus >= 201402L) || \
-      FMT_MSC_VER >= 1900
-#    define FMT_DEPRECATED [[deprecated]]
-#  else
-#    if defined(__GNUC__) || defined(__clang__)
-#      define FMT_DEPRECATED __attribute__((deprecated))
-#    elif FMT_MSC_VER
-#      define FMT_DEPRECATED __declspec(deprecated)
-#    else
-#      define FMT_DEPRECATED /* deprecated */
-#    endif
-#  endif
-#endif
-
-// Workaround broken [[deprecated]] in the Intel compiler and NVCC.
-#if defined(__INTEL_COMPILER) || FMT_NVCC
-#  define FMT_DEPRECATED_ALIAS
-#else
-#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
-#endif
-
-#ifndef FMT_BEGIN_NAMESPACE
-#  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
-      FMT_MSC_VER >= 1900
-#    define FMT_INLINE_NAMESPACE inline namespace
-#    define FMT_END_NAMESPACE \
-      }                       \
-      }
-#  else
-#    define FMT_INLINE_NAMESPACE namespace
-#    define FMT_END_NAMESPACE \
-      }                       \
-      using namespace v6;     \
-      }
-#  endif
-#  define FMT_BEGIN_NAMESPACE \
-    namespace duckdb_fmt {           \
-    FMT_INLINE_NAMESPACE v6 {
-#endif
-
-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-#  ifdef FMT_EXPORT
-#    define FMT_API __declspec(dllexport)
-#  elif defined(FMT_SHARED)
-#    define FMT_API __declspec(dllimport)
-#    define FMT_EXTERN_TEMPLATE_API FMT_API
-#  endif
-#endif
-#ifndef FMT_API
-#  define FMT_API
-#endif
-#ifndef FMT_EXTERN_TEMPLATE_API
-#  define FMT_EXTERN_TEMPLATE_API
-#endif
-
-#ifndef FMT_HEADER_ONLY
-#  define FMT_EXTERN extern
-#else
-#  define FMT_EXTERN
-#endif
-
-// libc++ supports string_view in pre-c++17.
-#if (FMT_HAS_INCLUDE(<string_view>) &&                       \
-     (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
-#  include <string_view>
-#  define FMT_USE_STRING_VIEW
-#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
-#  include <experimental/string_view>
-#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
-#endif
-
-FMT_BEGIN_NAMESPACE
-
-// Implementations of enable_if_t and other types for pre-C++14 systems.
-template <bool B, class T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, class T, class F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-template <bool B> using bool_constant = std::integral_constant<bool, B>;
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-template <typename T>
-using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
-
-struct monostate {};
-
-// An enable_if helper to be used in template parameters which results in much
-// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
-// to workaround a bug in MSVC 2019 (see #1140 and #1186).
-#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
-
-namespace internal {
-
-// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
-template <typename... Ts> struct void_t_impl { using type = void; };
-
-#ifndef FMT_ASSERT
-#define FMT_ASSERT(condition, message)
-#endif
-
-#if defined(FMT_USE_STRING_VIEW)
-template <typename Char> using std_string_view = std::basic_string_view<Char>;
-#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
-template <typename Char>
-using std_string_view = std::experimental::basic_string_view<Char>;
-#else
-template <typename T> struct std_string_view {};
-#endif
-
-#ifdef FMT_USE_INT128
-// Do nothing.
-#elif defined(__SIZEOF_INT128__)
-#  define FMT_USE_INT128 1
-using int128_t = __int128_t;
-using uint128_t = __uint128_t;
-#else
-#  define FMT_USE_INT128 0
-#endif
-#if !FMT_USE_INT128
-struct int128_t {};
-struct uint128_t {};
-#endif
-
-// Casts a nonnegative integer to unsigned.
-template <typename Int>
-FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
-  FMT_ASSERT(value >= 0, "negative value");
-  return static_cast<typename std::make_unsigned<Int>::type>(value);
-}
-}  // namespace internal
-
-template <typename... Ts>
-using void_t = typename internal::void_t_impl<Ts...>::type;
-
-/**
-  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
-  subset of the API. ``fmt::basic_string_view`` is used for format strings even
-  if ``std::string_view`` is available to prevent issues when a library is
-  compiled with a different ``-std`` option than the client code (which is not
-  recommended).
- */
-template <typename Char> class basic_string_view {
- private:
-  const Char* data_;
-  size_t size_;
-
- public:
-  using char_type = Char;
-  using iterator = const Char*;
-
-  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
-
-  /** Constructs a string reference object from a C string and a size. */
-  FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
-      : data_(s),
-        size_(count) {}
-
-  /**
-    \rst
-    Constructs a string reference object from a C string computing
-    the size with ``std::char_traits<Char>::length``.
-    \endrst
-   */
-  basic_string_view(const Char* s)
-      : data_(s), size_(std::char_traits<Char>::length(s)) {}
-
-  /** Constructs a string reference from a ``std::basic_string`` object. */
-  template <typename Traits, typename Alloc>
-  FMT_CONSTEXPR basic_string_view(
-      const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
-      : data_(s.data()),
-        size_(s.size()) {}
-
-  template <
-      typename S,
-      FMT_ENABLE_IF(std::is_same<S, internal::std_string_view<Char>>::value)>
-  FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
-                                                      size_(s.size()) {}
-
-  /** Returns a pointer to the string data. */
-  FMT_CONSTEXPR const Char* data() const { return data_; }
-
-  /** Returns the string size. */
-  FMT_CONSTEXPR size_t size() const { return size_; }
-
-  FMT_CONSTEXPR iterator begin() const { return data_; }
-  FMT_CONSTEXPR iterator end() const { return data_ + size_; }
-
-  FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[pos]; }
-
-  FMT_CONSTEXPR void remove_prefix(size_t n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  std::string to_string() {
-	  return std::string((char *) data(), size());
-  }
-
-  // Lexicographically compare this string reference to other.
-  int compare(basic_string_view other) const {
-    size_t str_size = size_ < other.size_ ? size_ : other.size_;
-    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
-    if (result == 0)
-      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-    return result;
-  }
-
-  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) == 0;
-  }
-  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) != 0;
-  }
-  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) < 0;
-  }
-  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) <= 0;
-  }
-  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) > 0;
-  }
-  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) >= 0;
-  }
-};
-
-using string_view = basic_string_view<char>;
-using wstring_view = basic_string_view<wchar_t>;
-
-typedef char fmt_char8_t;
-
-/** Specifies if ``T`` is a character type. Can be specialized by users. */
-template <typename T> struct is_char : std::false_type {};
-template <> struct is_char<wchar_t> : std::true_type {};
-template <> struct is_char<fmt_char8_t> : std::true_type {};
-template <> struct is_char<char16_t> : std::true_type {};
-template <> struct is_char<char32_t> : std::true_type {};
-
-/**
-  \rst
-  Returns a string view of `s`. In order to add custom string type support to
-  {fmt} provide an overload of `to_string_view` for it in the same namespace as
-  the type for the argument-dependent lookup to work.
-
-  **Example**::
-
-    namespace my_ns {
-    inline string_view to_string_view(const my_string& s) {
-      return {s.data(), s.length()};
-    }
-    }
-    std::string message = fmt::format(my_string("The answer is {}"), 42);
-  \endrst
- */
-template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
-inline basic_string_view<Char> to_string_view(const Char* s) {
-  return s;
-}
-
-template <typename Char, typename Traits, typename Alloc>
-inline basic_string_view<Char> to_string_view(
-    const std::basic_string<Char, Traits, Alloc>& s) {
-  return s;
-}
-
-template <typename Char>
-inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
-  return s;
-}
-
-template <typename Char,
-          FMT_ENABLE_IF(!std::is_empty<internal::std_string_view<Char>>::value)>
-inline basic_string_view<Char> to_string_view(
-    internal::std_string_view<Char> s) {
-  return s;
-}
-
-// A base class for compile-time strings. It is defined in the fmt namespace to
-// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42).
-struct compile_string {};
-
-template <typename S>
-struct is_compile_string : std::is_base_of<compile_string, S> {};
-
-template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-FMT_CONSTEXPR basic_string_view<typename S::char_type> to_string_view(const S& s) {
-  return s;
-}
-
-namespace internal {
-void to_string_view(...);
-using duckdb_fmt::v6::to_string_view;
-
-// Specifies whether S is a string type convertible to fmt::basic_string_view.
-// It should be a constexpr function but MSVC 2017 fails to compile it in
-// enable_if and MSVC 2015 fails to compile it as an alias template.
-template <typename S>
-struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
-};
-
-template <typename S, typename = void> struct char_t_impl {};
-template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
-  using result = decltype(to_string_view(std::declval<S>()));
-  using type = typename result::char_type;
-};
-
-struct error_handler {
-  FMT_CONSTEXPR error_handler() = default;
-  FMT_CONSTEXPR error_handler(const error_handler&) = default;
-
-  // This function is intentionally not constexpr to give a compile-time error.
-  FMT_NORETURN FMT_API void on_error(std::string message);
-};
-}  // namespace internal
-
-/** String's character type. */
-template <typename S> using char_t = typename internal::char_t_impl<S>::type;
-
-/**
-  \rst
-  Parsing context consisting of a format string range being parsed and an
-  argument counter for automatic indexing.
-
-  You can use one of the following type aliases for common character types:
-
-  +-----------------------+-------------------------------------+
-  | Type                  | Definition                          |
-  +=======================+=====================================+
-  | format_parse_context  | basic_format_parse_context<char>    |
-  +-----------------------+-------------------------------------+
-  | wformat_parse_context | basic_format_parse_context<wchar_t> |
-  +-----------------------+-------------------------------------+
-  \endrst
- */
-template <typename Char, typename ErrorHandler = internal::error_handler>
-class basic_format_parse_context : private ErrorHandler {
- private:
-  basic_string_view<Char> format_str_;
-  int next_arg_id_;
-
- public:
-  using char_type = Char;
-  using iterator = typename basic_string_view<Char>::iterator;
-
-  explicit FMT_CONSTEXPR basic_format_parse_context(
-      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
-      : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
-
-  /**
-    Returns an iterator to the beginning of the format string range being
-    parsed.
-   */
-  FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
-    return format_str_.begin();
-  }
-
-  /**
-    Returns an iterator past the end of the format string range being parsed.
-   */
-  FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
-
-  /** Advances the begin iterator to ``it``. */
-  FMT_CONSTEXPR void advance_to(iterator it) {
-    format_str_.remove_prefix(internal::to_unsigned(it - begin()));
-  }
-
-  /**
-    Reports an error if using the manual argument indexing; otherwise returns
-    the next argument index and switches to the automatic indexing.
-   */
-  FMT_CONSTEXPR int next_arg_id() {
-    if (next_arg_id_ >= 0) return next_arg_id_++;
-    on_error("cannot switch from manual to automatic argument indexing");
-    return 0;
-  }
-
-  /**
-    Reports an error if using the automatic argument indexing; otherwise
-    switches to the manual indexing.
-   */
-  FMT_CONSTEXPR void check_arg_id(int) {
-    if (next_arg_id_ > 0)
-      on_error("cannot switch from automatic to manual argument indexing");
-    else
-      next_arg_id_ = -1;
-  }
-
-  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
-
-  FMT_CONSTEXPR void on_error(std::string message) {
-    ErrorHandler::on_error(message);
-  }
-
-  FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
-};
-
-using format_parse_context = basic_format_parse_context<char>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
-
-template <typename Char, typename ErrorHandler = internal::error_handler>
-using basic_parse_context FMT_DEPRECATED_ALIAS =
-    basic_format_parse_context<Char, ErrorHandler>;
-using parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<char>;
-using wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<wchar_t>;
-
-template <typename Context> class basic_format_arg;
-template <typename Context> class basic_format_args;
-
-// A formatter for objects of type T.
-template <typename T, typename Char = char, typename Enable = void>
-struct formatter {
-  // A deleted default constructor indicates a disabled formatter.
-  formatter() = delete;
-};
-
-template <typename T, typename Char, typename Enable = void>
-struct FMT_DEPRECATED convert_to_int
-    : bool_constant<!std::is_arithmetic<T>::value &&
-                    std::is_convertible<T, int>::value> {};
-
-// Specifies if T has an enabled formatter specialization. A type can be
-// formattable even if it doesn't have a formatter e.g. via a conversion.
-template <typename T, typename Context>
-using has_formatter =
-    std::is_constructible<typename Context::template formatter_type<T>>;
-
-namespace internal {
-
-/** A contiguous memory buffer with an optional growing ability. */
-template <typename T> class buffer {
- private:
-  T* ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
-
- protected:
-  // Don't initialize ptr_ since it is not accessed to save a few cycles.
-  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
-
-  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
-      : ptr_(p),
-        size_(sz),
-        capacity_(cap) {}
-
-  /** Sets the buffer data and capacity. */
-  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
-    ptr_ = buf_data;
-    capacity_ = buf_capacity;
-  }
-
-  /** Increases the buffer capacity to hold at least *capacity* elements. */
-  virtual void grow(std::size_t capacity) = 0;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  buffer(const buffer&) = delete;
-  void operator=(const buffer&) = delete;
-  virtual ~buffer() = default;
-
-  T* begin() FMT_NOEXCEPT { return ptr_; }
-  T* end() FMT_NOEXCEPT { return ptr_ + size_; }
-
-  /** Returns the size of this buffer. */
-  std::size_t size() const FMT_NOEXCEPT { return size_; }
-
-  /** Returns the capacity of this buffer. */
-  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
-
-  /** Returns a pointer to the buffer data. */
-  T* data() FMT_NOEXCEPT { return ptr_; }
-
-  /** Returns a pointer to the buffer data. */
-  const T* data() const FMT_NOEXCEPT { return ptr_; }
-
-  /**
-    Resizes the buffer. If T is a POD type new elements may not be initialized.
-   */
-  void resize(std::size_t new_size) {
-    reserve(new_size);
-    size_ = new_size;
-  }
-
-  /** Clears this buffer. */
-  void clear() { size_ = 0; }
-
-  /** Reserves space to store at least *capacity* elements. */
-  void reserve(std::size_t new_capacity) {
-    if (new_capacity > capacity_) grow(new_capacity);
-  }
-
-  void push_back(const T& value) {
-    reserve(size_ + 1);
-    ptr_[size_++] = value;
-  }
-
-  /** Appends data to the end of the buffer. */
-  template <typename U> void append(const U* begin, const U* end);
-
-  T& operator[](std::size_t index) { return ptr_[index]; }
-  const T& operator[](std::size_t index) const { return ptr_[index]; }
-};
-
-// A container-backed buffer.
-template <typename Container>
-class container_buffer : public buffer<typename Container::value_type> {
- private:
-  Container& container_;
-
- protected:
-  void grow(std::size_t capacity) FMT_OVERRIDE {
-    container_.resize(capacity);
-    this->set(&container_[0], capacity);
-  }
-
- public:
-  explicit container_buffer(Container& c)
-      : buffer<typename Container::value_type>(c.size()), container_(c) {}
-};
-
-// Extracts a reference to the container from back_insert_iterator.
-template <typename Container>
-inline Container& get_container(std::back_insert_iterator<Container> it) {
-  using bi_iterator = std::back_insert_iterator<Container>;
-  struct accessor : bi_iterator {
-    accessor(bi_iterator iter) : bi_iterator(iter) {}
-    using bi_iterator::container;
-  };
-  return *accessor(it).container;
-}
-
-template <typename T, typename Char = char, typename Enable = void>
-struct fallback_formatter {
-  fallback_formatter() = delete;
-};
-
-// Specifies if T has an enabled fallback_formatter specialization.
-template <typename T, typename Context>
-using has_fallback_formatter =
-    std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
-
-template <typename Char> struct named_arg_base;
-template <typename T, typename Char> struct named_arg;
-
-enum type {
-  none_type,
-  named_arg_type,
-  // Integer types should go first,
-  int_type,
-  uint_type,
-  long_long_type,
-  ulong_long_type,
-  int128_type,
-  uint128_type,
-  bool_type,
-  char_type,
-  last_integer_type = char_type,
-  // followed by floating-point types.
-  float_type,
-  double_type,
-  long_double_type,
-  last_numeric_type = long_double_type,
-  cstring_type,
-  string_type,
-  pointer_type,
-  custom_type
-};
-
-// Maps core type T to the corresponding type enum constant.
-template <typename T, typename Char>
-struct type_constant : std::integral_constant<type, custom_type> {};
-
-#define FMT_TYPE_CONSTANT(Type, constant) \
-  template <typename Char>                \
-  struct type_constant<Type, Char> : std::integral_constant<type, constant> {}
-
-FMT_TYPE_CONSTANT(const named_arg_base<Char>&, named_arg_type);
-FMT_TYPE_CONSTANT(int, int_type);
-FMT_TYPE_CONSTANT(unsigned, uint_type);
-FMT_TYPE_CONSTANT(long long, long_long_type);
-FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
-FMT_TYPE_CONSTANT(int128_t, int128_type);
-FMT_TYPE_CONSTANT(uint128_t, uint128_type);
-FMT_TYPE_CONSTANT(bool, bool_type);
-FMT_TYPE_CONSTANT(Char, char_type);
-FMT_TYPE_CONSTANT(float, float_type);
-FMT_TYPE_CONSTANT(double, double_type);
-FMT_TYPE_CONSTANT(long double, long_double_type);
-FMT_TYPE_CONSTANT(const Char*, cstring_type);
-FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
-FMT_TYPE_CONSTANT(const void*, pointer_type);
-
-FMT_CONSTEXPR bool is_integral_type(type t) {
-  FMT_ASSERT(t != named_arg_type, "invalid argument type");
-  return t > none_type && t <= last_integer_type;
-}
-
-FMT_CONSTEXPR bool is_arithmetic_type(type t) {
-  FMT_ASSERT(t != named_arg_type, "invalid argument type");
-  return t > none_type && t <= last_numeric_type;
-}
-
-template <typename Char> struct string_value {
-  const Char* data;
-  std::size_t size;
-};
-
-template <typename Context> struct custom_value {
-  using parse_context = basic_format_parse_context<typename Context::char_type>;
-  const void* value;
-  void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
-};
-
-// A formatting argument value.
-template <typename Context> class value {
- public:
-  using char_type = typename Context::char_type;
-
-  union {
-    int int_value;
-    unsigned uint_value;
-    long long long_long_value;
-    unsigned long long ulong_long_value;
-    int128_t int128_value;
-    uint128_t uint128_value;
-    bool bool_value;
-    char_type char_value;
-    float float_value;
-    double double_value;
-    long double long_double_value;
-    const void* pointer;
-    string_value<char_type> string;
-    custom_value<Context> custom;
-    const named_arg_base<char_type>* named_arg;
-  };
-
-  FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
-  FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
-  value(long long val) : long_long_value(val) {}
-  value(unsigned long long val) : ulong_long_value(val) {}
-  value(int128_t val) : int128_value(val) {}
-  value(uint128_t val) : uint128_value(val) {}
-  value(float val) : float_value(val) {}
-  value(double val) : double_value(val) {}
-  value(long double val) : long_double_value(val) {}
-  value(bool val) : bool_value(val) {}
-  value(char_type val) : char_value(val) {}
-  value(const char_type* val) { string.data = val; }
-  value(basic_string_view<char_type> val) {
-    string.data = val.data();
-    string.size = val.size();
-  }
-  value(const void* val) : pointer(val) {}
-
-  template <typename T> value(const T& val) {
-    custom.value = &val;
-    // Get the formatter type through the context to allow different contexts
-    // have different extension points, e.g. `formatter<T>` for `format` and
-    // `printf_formatter<T>` for `printf`.
-    custom.format = format_custom_arg<
-        T, conditional_t<has_formatter<T, Context>::value,
-                         typename Context::template formatter_type<T>,
-                         fallback_formatter<T, char_type>>>;
-  }
-
-  value(const named_arg_base<char_type>& val) { named_arg = &val; }
-
- private:
-  // Formats an argument of a custom type, such as a user-defined class.
-  template <typename T, typename Formatter>
-  static void format_custom_arg(
-      const void* arg, basic_format_parse_context<char_type>& parse_ctx,
-      Context& ctx) {
-    Formatter f;
-    parse_ctx.advance_to(f.parse(parse_ctx));
-    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
-  }
-};
-
-template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);
-
-// To minimize the number of types we need to deal with, long is translated
-// either to int or to long long depending on its size.
-enum { long_short = sizeof(long) == sizeof(int) };
-using long_type = conditional_t<long_short, int, long long>;
-using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
-
-// Maps formatting arguments to core types.
-template <typename Context> struct arg_mapper {
-  using char_type = typename Context::char_type;
-
-  FMT_CONSTEXPR int map(signed char val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
-  FMT_CONSTEXPR int map(short val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
-  FMT_CONSTEXPR int map(int val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
-  FMT_CONSTEXPR long_type map(long val) { return val; }
-  FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
-  FMT_CONSTEXPR long long map(long long val) { return val; }
-  FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
-  FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
-  FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
-  FMT_CONSTEXPR bool map(bool val) { return val; }
-
-  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
-  FMT_CONSTEXPR char_type map(T val) {
-    static_assert(
-        std::is_same<T, char>::value || std::is_same<T, char_type>::value,
-        "mixing character types is disallowed");
-    return val;
-  }
-
-  FMT_CONSTEXPR float map(float val) { return val; }
-  FMT_CONSTEXPR double map(double val) { return val; }
-  FMT_CONSTEXPR long double map(long double val) { return val; }
-
-  FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
-  FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
-  template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    static_assert(std::is_same<char_type, char_t<T>>::value,
-                  "mixing character types is disallowed");
-    return to_string_view(val);
-  }
-  template <typename T,
-            FMT_ENABLE_IF(
-                std::is_constructible<basic_string_view<char_type>, T>::value &&
-                !is_string<T>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    return basic_string_view<char_type>(val);
-  }
-  template <
-      typename T,
-      FMT_ENABLE_IF(
-          std::is_constructible<std_string_view<char_type>, T>::value &&
-          !std::is_constructible<basic_string_view<char_type>, T>::value &&
-          !is_string<T>::value && !has_formatter<T, Context>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    return std_string_view<char_type>(val);
-  }
-  FMT_CONSTEXPR const char* map(const signed char* val) {
-    static_assert(std::is_same<char_type, char>::value, "invalid string type");
-    return reinterpret_cast<const char*>(val);
-  }
-  FMT_CONSTEXPR const char* map(const unsigned char* val) {
-    static_assert(std::is_same<char_type, char>::value, "invalid string type");
-    return reinterpret_cast<const char*>(val);
-  }
-
-  FMT_CONSTEXPR const void* map(void* val) { return val; }
-  FMT_CONSTEXPR const void* map(const void* val) { return val; }
-  FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
-  template <typename T> FMT_CONSTEXPR int map(const T*) {
-    // Formatting of arbitrary pointers is disallowed. If you want to output
-    // a pointer cast it to "void *" or "const void *". In particular, this
-    // forbids formatting of "[const] volatile char *" which is printed as bool
-    // by iostreams.
-    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
-    return 0;
-  }
-
-  template <typename T,
-            FMT_ENABLE_IF(std::is_enum<T>::value &&
-                          !has_formatter<T, Context>::value &&
-                          !has_fallback_formatter<T, Context>::value)>
-  FMT_CONSTEXPR auto map(const T& val) -> decltype(
-      map(static_cast<typename std::underlying_type<T>::type>(val))) {
-    return map(static_cast<typename std::underlying_type<T>::type>(val));
-  }
-  template <
-      typename T,
-      FMT_ENABLE_IF(
-          !is_string<T>::value && !is_char<T>::value &&
-          !std::is_constructible<basic_string_view<char_type>, T>::value &&
-          (has_formatter<T, Context>::value ||
-           (has_fallback_formatter<T, Context>::value &&
-            !std::is_constructible<std_string_view<char_type>, T>::value)))>
-  FMT_CONSTEXPR const T& map(const T& val) {
-    return val;
-  }
-
-  template <typename T>
-  FMT_CONSTEXPR const named_arg_base<char_type>& map(
-      const named_arg<T, char_type>& val) {
-    auto arg = make_arg<Context>(val.value);
-    std::memcpy(val.data, &arg, sizeof(arg));
-    return val;
-  }
-};
-
-// A type constant after applying arg_mapper<Context>.
-template <typename T, typename Context>
-using mapped_type_constant =
-    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
-                  typename Context::char_type>;
-
-enum { packed_arg_bits = 5 };
-// Maximum number of arguments with packed types.
-enum { max_packed_args = 63 / packed_arg_bits };
-enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
-
-template <typename Context> class arg_map;
-}  // namespace internal
-
-// A formatting argument. It is a trivially copyable/constructible type to
-// allow storage in basic_memory_buffer.
-template <typename Context> class basic_format_arg {
- private:
-  internal::value<Context> value_;
-  internal::type type_;
-
-  template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
-      const T& value);
-
-  template <typename Visitor, typename Ctx>
-  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-                                             const basic_format_arg<Ctx>& arg)
-      -> decltype(vis(0));
-
-  friend class basic_format_args<Context>;
-  friend class internal::arg_map<Context>;
-
-  using char_type = typename Context::char_type;
-
- public:
-  class handle {
-   public:
-    explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}
-
-    void format(basic_format_parse_context<char_type>& parse_ctx,
-                Context& ctx) const {
-      custom_.format(custom_.value, parse_ctx, ctx);
-    }
-
-   private:
-    internal::custom_value<Context> custom_;
-  };
-
-  FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {}
-
-  FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT {
-    return type_ != internal::none_type;
-  }
-
-  internal::type type() const { return type_; }
-
-  bool is_integral() const { return internal::is_integral_type(type_); }
-  bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
-};
-
-/**
-  \rst
-  Visits an argument dispatching to the appropriate visit method based on
-  the argument type. For example, if the argument type is ``double`` then
-  ``vis(value)`` will be called with the value of type ``double``.
-  \endrst
- */
-template <typename Visitor, typename Context>
-FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-                                    const basic_format_arg<Context>& arg)
-    -> decltype(vis(0)) {
-  using char_type = typename Context::char_type;
-  switch (arg.type_) {
-  case internal::none_type:
-    break;
-  case internal::named_arg_type:
-    FMT_ASSERT(false, "invalid argument type");
-    break;
-  case internal::int_type:
-    return vis(arg.value_.int_value);
-  case internal::uint_type:
-    return vis(arg.value_.uint_value);
-  case internal::long_long_type:
-    return vis(arg.value_.long_long_value);
-  case internal::ulong_long_type:
-    return vis(arg.value_.ulong_long_value);
-#if FMT_USE_INT128
-  case internal::int128_type:
-    return vis(arg.value_.int128_value);
-  case internal::uint128_type:
-    return vis(arg.value_.uint128_value);
-#else
-  case internal::int128_type:
-  case internal::uint128_type:
-    break;
-#endif
-  case internal::bool_type:
-    return vis(arg.value_.bool_value);
-  case internal::char_type:
-    return vis(arg.value_.char_value);
-  case internal::float_type:
-    return vis(arg.value_.float_value);
-  case internal::double_type:
-    return vis(arg.value_.double_value);
-  case internal::long_double_type:
-    return vis(arg.value_.long_double_value);
-  case internal::cstring_type:
-    return vis(arg.value_.string.data);
-  case internal::string_type:
-    return vis(basic_string_view<char_type>(arg.value_.string.data,
-                                            arg.value_.string.size));
-  case internal::pointer_type:
-    return vis(arg.value_.pointer);
-  case internal::custom_type:
-    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-  }
-  return vis(monostate());
-}
-
-namespace internal {
-// A map from argument names to their values for named arguments.
-template <typename Context> class arg_map {
- private:
-  using char_type = typename Context::char_type;
-
-  struct entry {
-    basic_string_view<char_type> name;
-    basic_format_arg<Context> arg;
-  };
-
-  entry* map_;
-  unsigned size_;
-
-  void push_back(value<Context> val) {
-    const auto& named = *val.named_arg;
-    map_[size_] = {named.name, named.template deserialize<Context>()};
-    ++size_;
-  }
-
- public:
-  arg_map(const arg_map&) = delete;
-  void operator=(const arg_map&) = delete;
-  arg_map() : map_(nullptr), size_(0) {}
-  void init(const basic_format_args<Context>& args);
-  ~arg_map() { delete[] map_; }
-
-  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
-    // The list is unsorted, so just return the first matching name.
-    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
-      if (it->name == name) return it->arg;
-    }
-    return {};
-  }
-};
-
-// A type-erased reference to an std::locale to avoid heavy <locale> include.
-class locale_ref {
- private:
-  const void* locale_;  // A type-erased pointer to std::locale.
-
- public:
-  locale_ref() : locale_(nullptr) {}
-  template <typename Locale> explicit locale_ref(const Locale& loc);
-
-  explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
-
-  template <typename Locale> Locale get() const;
-};
-
-template <typename> constexpr unsigned long long encode_types() { return 0; }
-
-template <typename Context, typename Arg, typename... Args>
-constexpr unsigned long long encode_types() {
-  return mapped_type_constant<Arg, Context>::value |
-         (encode_types<Context, Args...>() << packed_arg_bits);
-}
-
-template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
-  basic_format_arg<Context> arg;
-  arg.type_ = mapped_type_constant<T, Context>::value;
-  arg.value_ = arg_mapper<Context>().map(value);
-  return arg;
-}
-
-template <bool IS_PACKED, typename Context, typename T,
-          FMT_ENABLE_IF(IS_PACKED)>
-inline value<Context> make_arg(const T& val) {
-  return arg_mapper<Context>().map(val);
-}
-
-template <bool IS_PACKED, typename Context, typename T,
-          FMT_ENABLE_IF(!IS_PACKED)>
-inline basic_format_arg<Context> make_arg(const T& value) {
-  return make_arg<Context>(value);
-}
-}  // namespace internal
-
-// Formatting context.
-template <typename OutputIt, typename Char> class basic_format_context {
- public:
-  /** The character type for the output. */
-  using char_type = Char;
-
- private:
-  OutputIt out_;
-  basic_format_args<basic_format_context> args_;
-  internal::arg_map<basic_format_context> map_;
-  internal::locale_ref loc_;
-
- public:
-  using iterator = OutputIt;
-  using format_arg = basic_format_arg<basic_format_context>;
-  template <typename T> using formatter_type = formatter<T, char_type>;
-
-  basic_format_context(const basic_format_context&) = delete;
-  void operator=(const basic_format_context&) = delete;
-  /**
-   Constructs a ``basic_format_context`` object. References to the arguments are
-   stored in the object so make sure they have appropriate lifetimes.
-   */
-  basic_format_context(OutputIt out,
-                       basic_format_args<basic_format_context> ctx_args,
-                       internal::locale_ref loc = internal::locale_ref())
-      : out_(out), args_(ctx_args), loc_(loc) {}
-
-  format_arg arg(int id) const { return args_.get(id); }
-
-  // Checks if manual indexing is used and returns the argument with the
-  // specified name.
-  format_arg arg(basic_string_view<char_type> name);
-
-  internal::error_handler error_handler() { return {}; }
-  void on_error(std::string message) { error_handler().on_error(message); }
-
-  // Returns an iterator to the beginning of the output range.
-  iterator out() { return out_; }
-
-  // Advances the begin iterator to ``it``.
-  void advance_to(iterator it) { out_ = it; }
-
-  internal::locale_ref locale() { return loc_; }
-};
-
-template <typename Char>
-using buffer_context =
-    basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
-                         Char>;
-using format_context = buffer_context<char>;
-using wformat_context = buffer_context<wchar_t>;
-
-/**
-  \rst
-  An array of references to arguments. It can be implicitly converted into
-  `~fmt::basic_format_args` for passing into type-erased formatting functions
-  such as `~fmt::vformat`.
-  \endrst
- */
-template <typename Context, typename... Args> class format_arg_store {
- private:
-  static const size_t num_args = sizeof...(Args);
-  static const bool is_packed = num_args < internal::max_packed_args;
-
-  using value_type = conditional_t<is_packed, internal::value<Context>,
-                                   basic_format_arg<Context>>;
-
-  // If the arguments are not packed, add one more element to mark the end.
-  value_type data_[num_args + (num_args == 0 ? 1 : 0)];
-
-  friend class basic_format_args<Context>;
-
- public:
-  static constexpr unsigned long long types =
-      is_packed ? internal::encode_types<Context, Args...>()
-                : internal::is_unpacked_bit | num_args;
-
-  format_arg_store(const Args&... args)
-      : data_{internal::make_arg<is_packed, Context>(args)...} {}
-};
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
-  can be omitted in which case it defaults to `~fmt::context`.
-  See `~fmt::arg` for lifetime considerations.
-  \endrst
- */
-template <typename Context = format_context, typename... Args>
-inline format_arg_store<Context, Args...> make_format_args(
-    const Args&... args) {
-  return {args...};
-}
-
-/** Formatting arguments. */
-template <typename Context> class basic_format_args {
- public:
-  using size_type = int;
-  using format_arg = basic_format_arg<Context>;
-
- private:
-  // To reduce compiled code size per formatting function call, types of first
-  // max_packed_args arguments are passed in the types_ field.
-  unsigned long long types_;
-  union {
-    // If the number of arguments is less than max_packed_args, the argument
-    // values are stored in values_, otherwise they are stored in args_.
-    // This is done to reduce compiled code size as storing larger objects
-    // may require more code (at least on x86-64) even if the same amount of
-    // data is actually copied to stack. It saves ~10% on the bloat test.
-    const internal::value<Context>* values_;
-    const format_arg* args_;
-  };
-
-  bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; }
-
-  internal::type type(int index) const {
-    int shift = index * internal::packed_arg_bits;
-    unsigned int mask = (1 << internal::packed_arg_bits) - 1;
-    return static_cast<internal::type>((types_ >> shift) & mask);
-  }
-
-  friend class internal::arg_map<Context>;
-
-  void set_data(const internal::value<Context>* values) { values_ = values; }
-  void set_data(const format_arg* args) { args_ = args; }
-
-  format_arg do_get(int index) const {
-    format_arg arg;
-    if (!is_packed()) {
-      auto num_args = max_size();
-      if (index < num_args) arg = args_[index];
-      return arg;
-    }
-    if (index > internal::max_packed_args) return arg;
-    arg.type_ = type(index);
-    if (arg.type_ == internal::none_type) return arg;
-    internal::value<Context>& val = arg.value_;
-    val = values_[index];
-    return arg;
-  }
-
- public:
-  basic_format_args() : types_(0) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
-   \endrst
-   */
-  template <typename... Args>
-  basic_format_args(const format_arg_store<Context, Args...>& store)
-      : types_(store.types) {
-    set_data(store.data_);
-  }
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from a dynamic set of arguments.
-   \endrst
-   */
-  basic_format_args(const format_arg* args, int count)
-      : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) {
-    set_data(args);
-  }
-
-  /** Returns the argument at specified index. */
-  format_arg get(int index) const {
-    format_arg arg = do_get(index);
-    if (arg.type_ == internal::named_arg_type)
-      arg = arg.value_.named_arg->template deserialize<Context>();
-    return arg;
-  }
-
-  int max_size() const {
-    unsigned long long max_packed = internal::max_packed_args;
-    return static_cast<int>(is_packed() ? max_packed
-                                        : types_ & ~internal::is_unpacked_bit);
-  }
-};
-
-/** An alias to ``basic_format_args<context>``. */
-// It is a separate type rather than an alias to make symbols readable.
-struct format_args : basic_format_args<format_context> {
-  template <typename... Args>
-  format_args(Args&&... args)
-      : basic_format_args<format_context>(std::forward<Args>(args)...) {}
-};
-struct wformat_args : basic_format_args<wformat_context> {
-  template <typename... Args>
-  wformat_args(Args&&... args)
-      : basic_format_args<wformat_context>(std::forward<Args>(args)...) {}
-};
-
-template <typename Container> struct is_contiguous : std::false_type {};
-
-template <typename Char>
-struct is_contiguous<std::basic_string<Char>> : std::true_type {};
-
-template <typename Char>
-struct is_contiguous<internal::buffer<Char>> : std::true_type {};
-
-namespace internal {
-
-template <typename OutputIt>
-struct is_contiguous_back_insert_iterator : std::false_type {};
-template <typename Container>
-struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
-    : is_contiguous<Container> {};
-
-template <typename Char> struct named_arg_base {
-  basic_string_view<Char> name;
-
-  // Serialized value<context>.
-  mutable char data[sizeof(basic_format_arg<buffer_context<Char>>)];
-
-  named_arg_base(basic_string_view<Char> nm) : name(nm) {}
-
-  template <typename Context> basic_format_arg<Context> deserialize() const {
-    basic_format_arg<Context> arg;
-    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
-    return arg;
-  }
-};
-
-template <typename T, typename Char> struct named_arg : named_arg_base<Char> {
-  const T& value;
-
-  named_arg(basic_string_view<Char> name, const T& val)
-      : named_arg_base<Char>(name), value(val) {}
-};
-
-template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
-inline void check_format_string(const S&) {
-#if defined(FMT_ENFORCE_COMPILE_STRING)
-  static_assert(is_compile_string<S>::value,
-                "FMT_ENFORCE_COMPILE_STRING requires all format strings to "
-                "utilize FMT_STRING() or fmt().");
-#endif
-}
-template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-void check_format_string(S);
-
-struct view {};
-template <bool...> struct bool_pack;
-template <bool... Args>
-using all_true =
-    std::is_same<bool_pack<Args..., true>, bool_pack<true, Args...>>;
-
-template <typename... Args, typename S, typename Char = char_t<S>>
-inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
-make_args_checked(const S& format_str,
-                  const remove_reference_t<Args>&... args) {
-  static_assert(all_true<(!std::is_base_of<view, remove_reference_t<Args>>() ||
-                          !std::is_reference<Args>())...>::value,
-                "passing views as lvalues is disallowed");
-  check_format_string<remove_const_t<remove_reference_t<Args>>...>(format_str);
-  return {args...};
-}
-
-template <typename Char>
-std::basic_string<Char> vformat(basic_string_view<Char> format_str,
-                                basic_format_args<buffer_context<Char>> args);
-
-template <typename Char>
-typename buffer_context<Char>::iterator vformat_to(
-    buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args);
-}  // namespace internal
-
-/**
-  \rst
-  Returns a named argument to be used in a formatting function.
-
-  The named argument holds a reference and does not extend the lifetime
-  of its arguments.
-  Consequently, a dangling reference can accidentally be created.
-  The user should take care to only pass this function temporaries when
-  the named argument is itself a temporary, as per the following example.
-
-  **Example**::
-
-    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
-  \endrst
- */
-template <typename S, typename T, typename Char = char_t<S>>
-inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
-  static_assert(internal::is_string<S>::value, "");
-  return {name, arg};
-}
-
-// Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``.
-template <typename S, typename T, typename Char>
-void arg(S, internal::named_arg<T, Char>) = delete;
-
-/** Formats a string and writes the output to ``out``. */
-// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
-// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
-template <typename OutputIt, typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(
-              internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
-OutputIt vformat_to(OutputIt out, const S& format_str,
-                    basic_format_args<buffer_context<Char>> args) {
-  using container = remove_reference_t<decltype(internal::get_container(out))>;
-  internal::container_buffer<container> buf((internal::get_container(out)));
-  internal::vformat_to(buf, to_string_view(format_str), args);
-  return out;
-}
-
-template <typename Container, typename S, typename... Args,
-          FMT_ENABLE_IF(
-              is_contiguous<Container>::value&& internal::is_string<S>::value)>
-inline std::back_insert_iterator<Container> format_to(
-    std::back_insert_iterator<Container> out, const S& format_str,
-    Args&&... args) {
-  return vformat_to(
-      out, to_string_view(format_str),
-      {internal::make_args_checked<Args...>(format_str, args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vformat(
-    const S& format_str, basic_format_args<buffer_context<Char>> args) {
-  return internal::vformat(to_string_view(format_str), args);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    #include <fmt/core.h>
-    std::string message = fmt::format("The answer is {}", 42);
-  \endrst
-*/
-// Pass char_t as a default template parameter instead of using
-// std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline std::basic_string<Char> format(const S& format_str, Args&&... args) {
-  return internal::vformat(
-      to_string_view(format_str),
-      {internal::make_args_checked<Args...>(format_str, args...)});
-}
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_CORE_H_
diff --git a/src/duckdb/third_party/fmt/include/fmt/format-inl.h b/src/duckdb/third_party/fmt/include/fmt/format-inl.h
deleted file mode 100644
index 1755025ae..000000000
--- a/src/duckdb/third_party/fmt/include/fmt/format-inl.h
+++ /dev/null
@@ -1,1185 +0,0 @@
-// Formatting library for C++ - implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_FORMAT_INL_H_
-#define FMT_FORMAT_INL_H_
-
-#include "fmt/format.h"
-
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstring>  // for std::memmove
-#include <cwchar>
-#if FMT_EXCEPTIONS
-#  define FMT_TRY try
-#  define FMT_CATCH(x) catch (x)
-#else
-#  define FMT_TRY if (true)
-#  define FMT_CATCH(x) if (false)
-#endif
-
-#ifdef _MSC_VER
-#  pragma warning(push)
-#  pragma warning(disable : 4702)  // unreachable code
-#endif
-
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-inline duckdb_fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
-inline duckdb_fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-#ifndef _MSC_VER
-#  define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-#  define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-using format_func = void (*)(internal::buffer<char>&, int, string_view);
-
-// A portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-FMT_FUNC int safe_strerror(int error_code, char*& buffer,
-                           std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
-
-  class dispatcher {
-   private:
-    int error_code_;
-    char*& buffer_;
-    std::size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher&) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    int handle(char* message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
-
-    // Handle the case when strerror_r is not available.
-    int handle(internal::null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
-
-    // Fallback to strerror_s when strerror_r is not available.
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
-                                                                : result;
-    }
-
-#if !FMT_MSC_VER
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(internal::null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
-#endif
-
-   public:
-    dispatcher(int err_code, char*& buf, std::size_t buf_size)
-        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
-}
-
-FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
-                                string_view message) FMT_NOEXCEPT {
-  // Report error code making sure that the output fits into
-  // inline_buffer_size to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.resize(0);
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
-  }
-  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
-  internal::writer w(out);
-  if (message.size() <= inline_buffer_size - error_code_size) {
-    w.write(message);
-    w.write(SEP);
-  }
-  w.write(ERROR_STR);
-  w.write(error_code);
-  assert(out.size() <= inline_buffer_size);
-}
-
-FMT_FUNC void report_error(format_func func, int error_code,
-                           string_view message) FMT_NOEXCEPT {
-  memory_buffer full_message;
-  func(full_message, error_code, message);
-  /*// R does not allow us to have a reference to stderr even if we are not using it
-  // Don't use fwrite_fully because the latter may throw.
-  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
-  */
-}
-}  // namespace internal
-
-template <typename Char>
-FMT_FUNC std::string internal::grouping_impl(locale_ref) {
-  return "\03";
-}
-template <typename Char>
-FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
-  return ',';
-}
-template <typename Char>
-FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
-  return '.';
-}
-
-namespace internal {
-
-template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
-  // fallback_uintptr is always stored in little endian.
-  int i = static_cast<int>(sizeof(void*)) - 1;
-  while (i > 0 && n.value[i] == 0) --i;
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
-}
-
-template <typename T>
-const char basic_data<T>::digits[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-template <typename T>
-const char basic_data<T>::hex_digits[] = "0123456789abcdef";
-
-#define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
-      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
-      (factor)*1000000000
-
-template <typename T>
-const uint64_t basic_data<T>::powers_of_10_64[] = {
-    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-template <typename T>
-const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
-                                                           FMT_POWERS_OF_10(1)};
-
-template <typename T>
-const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
-    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-// These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::pow10_significands[] = {
-    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-};
-
-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-// to significands above.
-template <typename T>
-const int16_t basic_data<T>::pow10_exponents[] = {
-    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
-    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
-    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
-    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-
-template <typename T>
-const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
-template <typename T>
-const char basic_data<T>::background_color[] = "\x1b[48;2;";
-template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
-template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};
-
-template <typename T> struct bits {
-  static FMT_CONSTEXPR_DECL const int value =
-      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
-};
-
-class fp;
-template <int SHIFT = 0> fp normalize(fp value);
-
-// Lower (upper) boundary is a value half way between a floating-point value
-// and its predecessor (successor). Boundaries have the same exponent as the
-// value so only significands are stored.
-struct boundaries {
-  uint64_t lower;
-  uint64_t upper;
-};
-
-// A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  using significand_type = uint64_t;
-
-  // All sizes are in bits.
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-      std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-      1ULL << double_significand_size;
-
- public:
-  significand_type f;
-  int e;
-
-  static FMT_CONSTEXPR_DECL const int significand_size =
-      bits<significand_type>::value;
-
-  fp() : f(0), e(0) {}
-  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double> explicit fp(Double d) { assign(d); }
-
-  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-  template <int SHIFT> friend fp normalize(fp value) {
-    // Handle subnormals.
-    const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
-    while ((value.f & shifted_implicit_bit) == 0) {
-      value.f <<= 1;
-      --value.e;
-    }
-    // Subtract 1 to account for hidden bit.
-    const auto offset =
-        fp::significand_size - fp::double_significand_size - SHIFT - 1;
-    value.f <<= offset;
-    value.e -= offset;
-    return value;
-  }
-
-  // Assigns d to this and return true iff predecessor is closer than successor.
-  template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
-  bool assign(Double d) {
-    // Assume double is in the format [sign][exponent][significand].
-    using limits = std::numeric_limits<Double>;
-    const int exponent_size =
-        bits<Double>::value - double_significand_size - 1;  // -1 for sign
-    const uint64_t significand_mask = implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-    auto u = bit_cast<uint64_t>(d);
-    f = u & significand_mask;
-    auto biased_e = (u & exponent_mask) >> double_significand_size;
-    // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
-    // the smallest normalized number (biased_e > 1).
-    bool is_predecessor_closer = f == 0 && biased_e > 1;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-    return is_predecessor_closer;
-  }
-
-  template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
-  bool assign(Double) {
-    *this = fp();
-    return false;
-  }
-
-  // Assigns d to this together with computing lower and upper boundaries,
-  // where a boundary is a value half way between the number and its predecessor
-  // (lower) or successor (upper). The upper boundary is normalized and lower
-  // has the same exponent but may be not normalized.
-  template <typename Double> boundaries assign_with_boundaries(Double d) {
-    bool is_lower_closer = assign(d);
-    fp lower =
-        is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
-    // 1 in normalize accounts for the exponent shift above.
-    fp upper = normalize<1>(fp((f << 1) + 1, e - 1));
-    lower.f <<= lower.e - upper.e;
-    return boundaries{lower.f, upper.f};
-  }
-
-  template <typename Double> boundaries assign_float_with_boundaries(Double d) {
-    assign(d);
-    constexpr int min_normal_e = std::numeric_limits<float>::min_exponent -
-                                 std::numeric_limits<double>::digits;
-    significand_type half_ulp = 1 << (std::numeric_limits<double>::digits -
-                                      std::numeric_limits<float>::digits - 1);
-    if (min_normal_e > e) half_ulp <<= min_normal_e - e;
-    fp upper = normalize<0>(fp(f + half_ulp, e));
-    fp lower = fp(
-        f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
-    lower.f <<= lower.e - upper.e;
-    return boundaries{lower.f, upper.f};
-  }
-};
-
-inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
-
-// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
-#if FMT_USE_INT128
-  auto product = static_cast<__uint128_t>(lhs) * rhs;
-  auto f = static_cast<uint64_t>(product >> 64);
-  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
-#else
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = lhs >> 32, b = lhs & mask;
-  uint64_t c = rhs >> 32, d = rhs & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
-#endif
-}
-
-inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }
-
-// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
-// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
-FMT_FUNC fp get_cached_power(int min_exponent, int& pow10_exponent) {
-  const uint64_t one_over_log2_10 = 0x4d104d42;  // round(pow(2, 32) / log2(10))
-  int index = static_cast<int>(
-      static_cast<int64_t>(
-          (min_exponent + fp::significand_size - 1) * one_over_log2_10 +
-          ((uint64_t(1) << 32) - 1)  // ceil
-          ) >>
-      32  // arithmetic shift
-  );
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between 2 consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return {data::pow10_significands[index], data::pow10_exponents[index]};
-}
-
-// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
-// is not available.
-struct accumulator {
-  uint64_t lower;
-  uint64_t upper;
-
-  accumulator() : lower(0), upper(0) {}
-  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
-
-  void operator+=(uint64_t n) {
-    lower += n;
-    if (lower < n) ++upper;
-  }
-  void operator>>=(int shift) {
-    assert(shift == 32);
-    (void)shift;
-    lower = (upper << 32) | (lower >> 32);
-    upper >>= 32;
-  }
-};
-
-class bigint {
- private:
-  // A bigint is stored as an array of bigits (big digits), with bigit at index
-  // 0 being the least significant one.
-  using bigit = uint32_t;
-  using double_bigit = uint64_t;
-  enum { bigits_capacity = 32 };
-  basic_memory_buffer<bigit, bigits_capacity> bigits_;
-  int exp_;
-
-  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
-
-  friend struct formatter<bigint>;
-
-  void subtract_bigits(int index, bigit other, bigit& borrow) {
-    auto result = static_cast<double_bigit>(bigits_[index]) - other - borrow;
-    bigits_[index] = static_cast<bigit>(result);
-    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
-  }
-
-  void remove_leading_zeros() {
-    int num_bigits = static_cast<int>(bigits_.size()) - 1;
-    while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;
-    bigits_.resize(num_bigits + 1);
-  }
-
-  // Computes *this -= other assuming aligned bigints and *this >= other.
-  void subtract_aligned(const bigint& other) {
-    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
-    FMT_ASSERT(compare(*this, other) >= 0, "");
-    bigit borrow = 0;
-    int i = other.exp_ - exp_;
-    for (int j = 0, n = static_cast<int>(other.bigits_.size()); j != n;
-         ++i, ++j) {
-      subtract_bigits(i, other.bigits_[j], borrow);
-    }
-    while (borrow > 0) subtract_bigits(i, 0, borrow);
-    remove_leading_zeros();
-  }
-
-  void multiply(uint32_t value) {
-    const double_bigit wide_value = value;
-    bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      double_bigit result = bigits_[i] * wide_value + carry;
-      bigits_[i] = static_cast<bigit>(result);
-      carry = static_cast<bigit>(result >> bigit_bits);
-    }
-    if (carry != 0) bigits_.push_back(carry);
-  }
-
-  void multiply(uint64_t value) {
-    const bigit mask = ~bigit(0);
-    const double_bigit lower = value & mask;
-    const double_bigit upper = value >> bigit_bits;
-    double_bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      double_bigit result = bigits_[i] * lower + (carry & mask);
-      carry =
-          bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
-      bigits_[i] = static_cast<bigit>(result);
-    }
-    while (carry != 0) {
-      bigits_.push_back(carry & mask);
-      carry >>= bigit_bits;
-    }
-  }
-
- public:
-  bigint() : exp_(0) {}
-  explicit bigint(uint64_t n) { assign(n); }
-  ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
-
-  bigint(const bigint&) = delete;
-  void operator=(const bigint&) = delete;
-
-  void assign(const bigint& other) {
-    bigits_.resize(other.bigits_.size());
-    auto data = other.bigits_.data();
-    std::copy(data, data + other.bigits_.size(), bigits_.data());
-    exp_ = other.exp_;
-  }
-
-  void assign(uint64_t n) {
-    int num_bigits = 0;
-    do {
-      bigits_[num_bigits++] = n & ~bigit(0);
-      n >>= bigit_bits;
-    } while (n != 0);
-    bigits_.resize(num_bigits);
-    exp_ = 0;
-  }
-
-  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
-
-  bigint& operator<<=(int shift) {
-    assert(shift >= 0);
-    exp_ += shift / bigit_bits;
-    shift %= bigit_bits;
-    if (shift == 0) return *this;
-    bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      bigit c = bigits_[i] >> (bigit_bits - shift);
-      bigits_[i] = (bigits_[i] << shift) + carry;
-      carry = c;
-    }
-    if (carry != 0) bigits_.push_back(carry);
-    return *this;
-  }
-
-  template <typename Int> bigint& operator*=(Int value) {
-    FMT_ASSERT(value > 0, "");
-    multiply(uint32_or_64_or_128_t<Int>(value));
-    return *this;
-  }
-
-  friend int compare(const bigint& lhs, const bigint& rhs) {
-    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
-    if (num_lhs_bigits != num_rhs_bigits)
-      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
-    int i = static_cast<int>(lhs.bigits_.size()) - 1;
-    int j = static_cast<int>(rhs.bigits_.size()) - 1;
-    int end = i - j;
-    if (end < 0) end = 0;
-    for (; i >= end; --i, --j) {
-      bigit lhs_bigit = lhs.bigits_[i], rhs_bigit = rhs.bigits_[j];
-      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
-    }
-    if (i != j) return i > j ? 1 : -1;
-    return 0;
-  }
-
-  // Returns compare(lhs1 + lhs2, rhs).
-  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
-                         const bigint& rhs) {
-    int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
-    int num_rhs_bigits = rhs.num_bigits();
-    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
-    if (max_lhs_bigits > num_rhs_bigits) return 1;
-    auto get_bigit = [](const bigint& n, int i) -> bigit {
-      return i >= n.exp_ && i < n.num_bigits() ? n.bigits_[i - n.exp_] : 0;
-    };
-    double_bigit borrow = 0;
-    int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
-    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
-      double_bigit sum =
-          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
-      bigit rhs_bigit = get_bigit(rhs, i);
-      if (sum > rhs_bigit + borrow) return 1;
-      borrow = rhs_bigit + borrow - sum;
-      if (borrow > 1) return -1;
-      borrow <<= bigit_bits;
-    }
-    return borrow != 0 ? -1 : 0;
-  }
-
-  // Assigns pow(10, exp) to this bigint.
-  void assign_pow10(int exp) {
-    assert(exp >= 0);
-    if (exp == 0) return assign(1);
-    // Find the top bit.
-    int bitmask = 1;
-    while (exp >= bitmask) bitmask <<= 1;
-    bitmask >>= 1;
-    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
-    // repeated squaring and multiplication.
-    assign(5);
-    bitmask >>= 1;
-    while (bitmask != 0) {
-      square();
-      if ((exp & bitmask) != 0) *this *= 5;
-      bitmask >>= 1;
-    }
-    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
-  }
-
-  void square() {
-    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
-    int num_bigits = static_cast<int>(bigits_.size());
-    int num_result_bigits = 2 * num_bigits;
-    bigits_.resize(num_result_bigits);
-    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
-    auto sum = accumulator_t();
-    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
-      // Compute bigit at position bigit_index of the result by adding
-      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
-      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
-        // Most terms are multiplied twice which can be optimized in the future.
-        sum += static_cast<double_bigit>(n[i]) * n[j];
-      }
-      bigits_[bigit_index] = static_cast<bigit>(sum);
-      sum >>= bits<bigit>::value;  // Compute the carry.
-    }
-    // Do the same for the top half.
-    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
-         ++bigit_index) {
-      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
-        sum += static_cast<double_bigit>(n[i++]) * n[j--];
-      bigits_[bigit_index] = static_cast<bigit>(sum);
-      sum >>= bits<bigit>::value;
-    }
-    --num_result_bigits;
-    remove_leading_zeros();
-    exp_ *= 2;
-  }
-
-  // Divides this bignum by divisor, assigning the remainder to this and
-  // returning the quotient.
-  int divmod_assign(const bigint& divisor) {
-    FMT_ASSERT(this != &divisor, "");
-    if (compare(*this, divisor) < 0) return 0;
-    int num_bigits = static_cast<int>(bigits_.size());
-    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1] != 0, "");
-    int exp_difference = exp_ - divisor.exp_;
-    if (exp_difference > 0) {
-      // Align bigints by adding trailing zeros to simplify subtraction.
-      bigits_.resize(num_bigits + exp_difference);
-      for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
-        bigits_[j] = bigits_[i];
-      std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
-      exp_ -= exp_difference;
-    }
-    int quotient = 0;
-    do {
-      subtract_aligned(divisor);
-      ++quotient;
-    } while (compare(*this, divisor) >= 0);
-    return quotient;
-  }
-};
-
-enum round_direction { unknown, up, down };
-
-// Given the divisor (normally a power of 10), the remainder = v % divisor for
-// some number v and the error, returns whether v should be rounded up, down, or
-// whether the rounding direction can't be determined due to error.
-// error should be less than divisor / 2.
-inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
-                                           uint64_t error) {
-  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
-  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
-  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
-  // Round down if (remainder + error) * 2 <= divisor.
-  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
-    return down;
-  // Round up if (remainder - error) * 2 >= divisor.
-  if (remainder >= error &&
-      remainder - error >= divisor - (remainder - error)) {
-    return up;
-  }
-  return unknown;
-}
-
-namespace digits {
-enum result {
-  more,  // Generate more digits.
-  done,  // Done generating digits.
-  error  // Digit generation cancelled due to an error.
-};
-}
-
-// Generates output using the Grisu digit-gen algorithm.
-// error: the size of the region (lower, upper) outside of which numbers
-// definitely do not round to value (Delta in Grisu3).
-template <typename Handler>
-FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
-                                                  int& exp, Handler& handler) {
-  const fp one(1ULL << -value.e, value.e);
-  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
-  // zero because it contains a product of two 64-bit numbers with MSB set (due
-  // to normalization) - 1, shifted right by at most 60 bits.
-  auto integral = static_cast<uint32_t>(value.f >> -one.e);
-  FMT_ASSERT(integral != 0, "");
-  FMT_ASSERT(integral == value.f >> -one.e, "");
-  // The fractional part of scaled value (p2 in Grisu) c = value % one.
-  uint64_t fractional = value.f & (one.f - 1);
-  exp = count_digits(integral);  // kappa in Grisu.
-  // Divide by 10 to prevent overflow.
-  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
-                                 value.f / 10, error * 10, exp);
-  if (result != digits::more) return result;
-  // Generate digits for the integral part. This can produce up to 10 digits.
-  do {
-    uint32_t digit = 0;
-    auto divmod_integral = [&](uint32_t divisor) {
-      digit = integral / divisor;
-      integral %= divisor;
-    };
-    // This optimization by Milo Yip reduces the number of integer divisions by
-    // one per iteration.
-    switch (exp) {
-    case 10:
-      divmod_integral(1000000000);
-      break;
-    case 9:
-      divmod_integral(100000000);
-      break;
-    case 8:
-      divmod_integral(10000000);
-      break;
-    case 7:
-      divmod_integral(1000000);
-      break;
-    case 6:
-      divmod_integral(100000);
-      break;
-    case 5:
-      divmod_integral(10000);
-      break;
-    case 4:
-      divmod_integral(1000);
-      break;
-    case 3:
-      divmod_integral(100);
-      break;
-    case 2:
-      divmod_integral(10);
-      break;
-    case 1:
-      digit = integral;
-      integral = 0;
-      break;
-    default:
-      FMT_ASSERT(false, "invalid number of digits");
-    }
-    --exp;
-    uint64_t remainder =
-        (static_cast<uint64_t>(integral) << -one.e) + fractional;
-    result = handler.on_digit(static_cast<char>('0' + digit),
-                              data::powers_of_10_64[exp] << -one.e, remainder,
-                              error, exp, true);
-    if (result != digits::more) return result;
-  } while (exp > 0);
-  // Generate digits for the fractional part.
-  for (;;) {
-    fractional *= 10;
-    error *= 10;
-    char digit =
-        static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
-    fractional &= one.f - 1;
-    --exp;
-    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
-    if (result != digits::more) return result;
-  }
-}
-
-// The fixed precision digit handler.
-struct fixed_handler {
-  char* buf;
-  int size;
-  int precision;
-  int exp10;
-  bool fixed;
-
-  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
-                          int& exp) {
-    // Non-fixed formats require at least one digit and no precision adjustment.
-    if (!fixed) return digits::more;
-    // Adjust fixed precision by exponent because it is relative to decimal
-    // point.
-    precision += exp + exp10;
-    // Check if precision is satisfied just by leading zeros, e.g.
-    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
-    if (precision > 0) return digits::more;
-    if (precision < 0) return digits::done;
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir == unknown) return digits::error;
-    buf[size++] = dir == up ? '1' : '0';
-    return digits::done;
-  }
-
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int, bool integral) {
-    FMT_ASSERT(remainder < divisor, "");
-    buf[size++] = digit;
-    if (size < precision) return digits::more;
-    if (!integral) {
-      // Check if error * 2 < divisor with overflow prevention.
-      // The check is not needed for the integral part because error = 1
-      // and divisor > (1 << 32) there.
-      if (error >= divisor || error >= divisor - error) return digits::error;
-    } else {
-      FMT_ASSERT(error == 1 && divisor > 2, "");
-    }
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir != up) return dir == down ? digits::done : digits::error;
-    ++buf[size - 1];
-    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
-      buf[i] = '0';
-      ++buf[i - 1];
-    }
-    if (buf[0] > '9') {
-      buf[0] = '1';
-      buf[size++] = '0';
-    }
-    return digits::done;
-  }
-};
-
-// The shortest representation digit handler.
-struct grisu_shortest_handler {
-  char* buf;
-  int size;
-  // Distance between scaled value and upper bound (wp_W in Grisu3).
-  uint64_t diff;
-
-  digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
-    return digits::more;
-  }
-
-  // Decrement the generated number approaching value from above.
-  void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
-             uint64_t error) {
-    while (
-        remainder < d && error - remainder >= divisor &&
-        (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
-      --buf[size - 1];
-      remainder += divisor;
-    }
-  }
-
-  // Implements Grisu's round_weed.
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int exp, bool integral) {
-    buf[size++] = digit;
-    if (remainder >= error) return digits::more;
-    uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
-    uint64_t up = (diff - 1) * unit;  // wp_Wup
-    round(up, divisor, remainder, error);
-    uint64_t down = (diff + 1) * unit;  // wp_Wdown
-    if (remainder < down && error - remainder >= divisor &&
-        (remainder + divisor < down ||
-         down - remainder > remainder + divisor - down)) {
-      return digits::error;
-    }
-    return 2 * unit <= remainder && remainder <= error - 4 * unit
-               ? digits::done
-               : digits::error;
-  }
-};
-
-// Formats value using a variation of the Fixed-Precision Positive
-// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
-// https://fmt.dev/p372-steele.pdf.
-template <typename Double>
-void fallback_format(Double d, buffer<char>& buf, int& exp10) {
-  bigint numerator;    // 2 * R in (FPP)^2.
-  bigint denominator;  // 2 * S in (FPP)^2.
-  // lower and upper are differences between value and corresponding boundaries.
-  bigint lower;             // (M^- in (FPP)^2).
-  bigint upper_store;       // upper's value if different from lower.
-  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
-  fp value;
-  // Shift numerator and denominator by an extra bit or two (if lower boundary
-  // is closer) to make lower and upper integers. This eliminates multiplication
-  // by 2 during later computations.
-  // TODO: handle float
-  int shift = value.assign(d) ? 2 : 1;
-  uint64_t significand = value.f << shift;
-  if (value.e >= 0) {
-    numerator.assign(significand);
-    numerator <<= value.e;
-    lower.assign(1);
-    lower <<= value.e;
-    if (shift != 1) {
-      upper_store.assign(1);
-      upper_store <<= value.e + 1;
-      upper = &upper_store;
-    }
-    denominator.assign_pow10(exp10);
-    denominator <<= 1;
-  } else if (exp10 < 0) {
-    numerator.assign_pow10(-exp10);
-    lower.assign(numerator);
-    if (shift != 1) {
-      upper_store.assign(numerator);
-      upper_store <<= 1;
-      upper = &upper_store;
-    }
-    numerator *= significand;
-    denominator.assign(1);
-    denominator <<= shift - value.e;
-  } else {
-    numerator.assign(significand);
-    denominator.assign_pow10(exp10);
-    denominator <<= shift - value.e;
-    lower.assign(1);
-    if (shift != 1) {
-      upper_store.assign(1ULL << 1);
-      upper = &upper_store;
-    }
-  }
-  if (!upper) upper = &lower;
-  // Invariant: value == (numerator / denominator) * pow(10, exp10).
-  bool even = (value.f & 1) == 0;
-  int num_digits = 0;
-  char* data = buf.data();
-  for (;;) {
-    int digit = numerator.divmod_assign(denominator);
-    bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
-    // numerator + upper >[=] pow10:
-    bool high = add_compare(numerator, *upper, denominator) + even > 0;
-    data[num_digits++] = static_cast<char>('0' + digit);
-    if (low || high) {
-      if (!low) {
-        ++data[num_digits - 1];
-      } else if (high) {
-        int result = add_compare(numerator, numerator, denominator);
-        // Round half to even.
-        if (result > 0 || (result == 0 && (digit % 2) != 0))
-          ++data[num_digits - 1];
-      }
-      buf.resize(num_digits);
-      exp10 -= num_digits - 1;
-      return;
-    }
-    numerator *= 10;
-    lower *= 10;
-    if (upper != &lower) *upper *= 10;
-  }
-}
-
-// Formats value using the Grisu algorithm
-// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)
-// if T is a IEEE754 binary32 or binary64 and snprintf otherwise.
-template <typename T>
-int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
-  static_assert(!std::is_same<T, float>(), "");
-  FMT_ASSERT(value >= 0, "value is negative");
-
-  const bool fixed = specs.format == float_format::fixed;
-  if (value <= 0) {  // <= instead of == to silence a warning.
-    if (precision <= 0 || !fixed) {
-      buf.push_back('0');
-      return 0;
-    }
-    buf.resize(to_unsigned(precision));
-    std::uninitialized_fill_n(buf.data(), precision, '0');
-    return -precision;
-  }
-
-  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);
-
-  int exp = 0;
-  const int min_exp = -60;  // alpha in Grisu.
-  int cached_exp10 = 0;     // K in Grisu.
-  if (precision != -1) {
-    if (precision > 17) return snprintf_float(value, precision, specs, buf);
-    fp normalized = normalize(fp(value));
-    const auto cached_pow = get_cached_power(
-        min_exp - (normalized.e + fp::significand_size), cached_exp10);
-    normalized = normalized * cached_pow;
-    fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
-    if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
-      return snprintf_float(value, precision, specs, buf);
-    int num_digits = handler.size;
-    if (!fixed) {
-      // Remove trailing zeros.
-      while (num_digits > 0 && buf[num_digits - 1] == '0') {
-        --num_digits;
-        ++exp;
-      }
-    }
-    buf.resize(to_unsigned(num_digits));
-  } else {
-    fp fp_value;
-    auto boundaries = specs.binary32
-                          ? fp_value.assign_float_with_boundaries(value)
-                          : fp_value.assign_with_boundaries(value);
-    fp_value = normalize(fp_value);
-    // Find a cached power of 10 such that multiplying value by it will bring
-    // the exponent in the range [min_exp, -32].
-    const fp cached_pow = get_cached_power(
-        min_exp - (fp_value.e + fp::significand_size), cached_exp10);
-    // Multiply value and boundaries by the cached power of 10.
-    fp_value = fp_value * cached_pow;
-    boundaries.lower = multiply(boundaries.lower, cached_pow.f);
-    boundaries.upper = multiply(boundaries.upper, cached_pow.f);
-    assert(min_exp <= fp_value.e && fp_value.e <= -32);
-    --boundaries.lower;  // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
-    ++boundaries.upper;  // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
-    // Numbers outside of (lower, upper) definitely do not round to value.
-    grisu_shortest_handler handler{buf.data(), 0,
-                                   boundaries.upper - fp_value.f};
-    auto result =
-        grisu_gen_digits(fp(boundaries.upper, fp_value.e),
-                         boundaries.upper - boundaries.lower, exp, handler);
-    if (result == digits::error) {
-      exp += handler.size - cached_exp10 - 1;
-      fallback_format(value, buf, exp);
-      return exp;
-    }
-    buf.resize(to_unsigned(handler.size));
-  }
-  return exp - cached_exp10;
-}
-
-template <typename T>
-int snprintf_float(T value, int precision, float_specs specs,
-                   buffer<char>& buf) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
-  static_assert(!std::is_same<T, float>(), "");
-
-  // Subtract 1 to account for the difference in precision since we use %e for
-  // both general and exponent format.
-  if (specs.format == float_format::general ||
-      specs.format == float_format::exp)
-    precision = (precision >= 0 ? precision : 6) - 1;
-
-  // Build the format string.
-  enum { max_format_size = 7 };  // Ths longest format is "%#.*Le".
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.trailing_zeros) *format_ptr++ = '#';
-  if (precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
-  *format_ptr++ = specs.format != float_format::hex
-                      ? (specs.format == float_format::fixed ? 'f' : 'e')
-                      : (specs.upper ? 'A' : 'a');
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  auto offset = buf.size();
-  for (;;) {
-    auto begin = buf.data() + offset;
-    auto capacity = buf.capacity() - offset;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    if (precision > 100000)
-      throw std::runtime_error(
-          "fuzz mode - avoid large allocation inside snprintf");
-#endif
-    // Suppress the warning about a nonliteral format string.
-    auto snprintf_ptr = FMT_SNPRINTF;
-    int result = precision >= 0
-                     ? snprintf_ptr(begin, capacity, format, precision, value)
-                     : snprintf_ptr(begin, capacity, format, value);
-    if (result < 0) {
-      buf.reserve(buf.capacity() + 1);  // The buffer will grow exponentially.
-      continue;
-    }
-    unsigned size = to_unsigned(result);
-    // Size equal to capacity means that the last character was truncated.
-    if (size >= capacity) {
-      buf.reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
-      continue;
-    }
-    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
-    if (specs.format == float_format::fixed) {
-      if (precision == 0) {
-        buf.resize(size);
-        return 0;
-      }
-      // Find and remove the decimal point.
-      auto end = begin + size, p = end;
-      do {
-        --p;
-      } while (is_digit(*p));
-      int fraction_size = static_cast<int>(end - p - 1);
-      std::memmove(p, p + 1, fraction_size);
-      buf.resize(size - 1);
-      return -fraction_size;
-    }
-    if (specs.format == float_format::hex) {
-      buf.resize(size + offset);
-      return 0;
-    }
-    // Find and parse the exponent.
-    auto end = begin + size, exp_pos = end;
-    do {
-      --exp_pos;
-    } while (*exp_pos != 'e');
-    char sign = exp_pos[1];
-    assert(sign == '+' || sign == '-');
-    int exp = 0;
-    auto p = exp_pos + 2;  // Skip 'e' and sign.
-    do {
-      assert(is_digit(*p));
-      exp = exp * 10 + (*p++ - '0');
-    } while (p != end);
-    if (sign == '-') exp = -exp;
-    int fraction_size = 0;
-    if (exp_pos != begin + 1) {
-      // Remove trailing zeros.
-      auto fraction_end = exp_pos - 1;
-      while (*fraction_end == '0') --fraction_end;
-      // Move the fractional part left to get rid of the decimal point.
-      fraction_size = static_cast<int>(fraction_end - begin - 1);
-      std::memmove(begin + 1, begin + 2, fraction_size);
-    }
-    buf.resize(fraction_size + offset + 1);
-    return exp - fraction_size;
-  }
-}
-}  // namespace internal
-
-template <> struct formatter<internal::bigint> {
-  format_parse_context::iterator parse(format_parse_context& ctx) {
-    return ctx.begin();
-  }
-
-  format_context::iterator format(const internal::bigint& n,
-                                  format_context& ctx) {
-    auto out = ctx.out();
-    bool first = true;
-    for (auto i = n.bigits_.size(); i > 0; --i) {
-      auto value = n.bigits_[i - 1];
-      if (first) {
-        out = format_to(out, "{:x}", value);
-        first = false;
-        continue;
-      }
-      out = format_to(out, "{:08x}", value);
-    }
-    if (n.exp_ > 0)
-      out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
-    return out;
-  }
-};
-
-FMT_FUNC void internal::error_handler::on_error(std::string message) {
-  FMT_THROW(duckdb::InvalidInputException(message));
-}
-
-FMT_END_NAMESPACE
-
-#ifdef _MSC_VER
-#  pragma warning(pop)
-#endif
-
-#endif  // FMT_FORMAT_INL_H_
diff --git a/src/duckdb/third_party/fmt/include/fmt/format.h b/src/duckdb/third_party/fmt/include/fmt/format.h
deleted file mode 100644
index ad4fe83ab..000000000
--- a/src/duckdb/third_party/fmt/include/fmt/format.h
+++ /dev/null
@@ -1,3416 +0,0 @@
-/*
- Formatting library for C++
-
- Copyright (c) 2012 - present, Victor Zverovich
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
- --- Optional exception to the license ---
-
- As an exception, if, as a result of your compiling your source code, portions
- of this Software are embedded into a machine-executable object form of such
- source code, you may redistribute such embedded portions in such object form
- without including the above copyright and permission notices.
- */
-
-#ifndef FMT_FORMAT_H_
-#define FMT_FORMAT_H_
-
-#include "duckdb/common/exception.hpp"
-#include "fmt/core.h"
-
-#include <algorithm>
-#include <cerrno>
-#include <cmath>
-#include <cstdint>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-
-#ifdef __clang__
-#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
-#else
-#  define FMT_CLANG_VERSION 0
-#endif
-
-#ifdef __INTEL_COMPILER
-#  define FMT_ICC_VERSION __INTEL_COMPILER
-#elif defined(__ICL)
-#  define FMT_ICC_VERSION __ICL
-#else
-#  define FMT_ICC_VERSION 0
-#endif
-
-#ifdef __NVCC__
-#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
-#else
-#  define FMT_CUDA_VERSION 0
-#endif
-
-#ifdef __has_builtin
-#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
-#else
-#  define FMT_HAS_BUILTIN(x) 0
-#endif
-
-#if FMT_HAS_CPP_ATTRIBUTE(fallthrough) && \
-    (__cplusplus >= 201703 || FMT_GCC_VERSION != 0)
-#  define FMT_FALLTHROUGH [[fallthrough]]
-#elif defined(DUCKDB_EXPLICIT_FALLTHROUGH)
-#  define FMT_FALLTHROUGH DUCKDB_EXPLICIT_FALLTHROUGH
-#else
-#  define FMT_FALLTHROUGH
-#endif
-
-#ifndef FMT_THROW
-#  if FMT_EXCEPTIONS
-#    if FMT_MSC_VER
-FMT_BEGIN_NAMESPACE
-namespace internal {
-template <typename Exception> inline void do_throw(const Exception& x) {
-  // Silence unreachable code warnings in MSVC because these are nearly
-  // impossible to fix in a generic code.
-  volatile bool b = true;
-  if (b) throw x;
-}
-}  // namespace internal
-FMT_END_NAMESPACE
-#      define FMT_THROW(x) internal::do_throw(x)
-#    else
-#      define FMT_THROW(x) throw x
-#    endif
-#  else
-#    define FMT_THROW(x)              \
-      do {                            \
-        static_cast<void>(sizeof(x)); \
-        FMT_ASSERT(false, "");        \
-      } while (false)
-#  endif
-#endif
-
-#ifndef FMT_USE_USER_DEFINED_LITERALS
-// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
-#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 ||      \
-       FMT_MSC_VER >= 1900) &&                                              \
-      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
-       FMT_CUDA_VERSION >= 700)
-#    define FMT_USE_USER_DEFINED_LITERALS 1
-#  else
-#    define FMT_USE_USER_DEFINED_LITERALS 0
-#  endif
-#endif
-
-#ifndef FMT_USE_UDL_TEMPLATE
-#define FMT_USE_UDL_TEMPLATE 0
-#endif
-
-// __builtin_clz is broken in clang with Microsoft CodeGen:
-// https://github.com/fmtlib/fmt/issues/519
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
-#endif
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#endif
-
-// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
-// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
-// MSVC intrinsics if the clz and clzll builtins are not available.
-#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
-#  include <intrin.h>  // _BitScanReverse, _BitScanReverse64
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#  ifndef __clang__
-#    pragma intrinsic(_BitScanReverse)
-#  endif
-inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
-
-  FMT_ASSERT(x != 0, "");
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 31 - r;
-}
-#  define FMT_BUILTIN_CLZ(n) internal::clz(n)
-
-#  if defined(_WIN64) && !defined(__clang__)
-#    pragma intrinsic(_BitScanReverse64)
-#  endif
-
-inline uint32_t clzll(uint64_t x) {
-  unsigned long r = 0;
-#  ifdef _WIN64
-  _BitScanReverse64(&r, x);
-#  else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);
-
-  // Scan the low 32 bits.
-  _BitScanReverse(&r, static_cast<uint32_t>(x));
-#  endif
-
-  FMT_ASSERT(x != 0, "");
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 63 - r;
-}
-#  define FMT_BUILTIN_CLZLL(n) internal::clzll(n)
-}  // namespace internal
-FMT_END_NAMESPACE
-#endif
-
-// Enable the deprecated numeric alignment.
-#ifndef FMT_NUMERIC_ALIGN
-#  define FMT_NUMERIC_ALIGN 1
-#endif
-
-// Enable the deprecated percent specifier.
-#ifndef FMT_DEPRECATED_PERCENT
-#  define FMT_DEPRECATED_PERCENT 0
-#endif
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T> inline T const_check(T value) { return value; }
-
-// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
-// undefined behavior (e.g. due to type aliasing).
-// Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template <typename Dest, typename Source>
-inline Dest bit_cast(const Source& source) {
-  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-  Dest dest;
-  std::memcpy(&dest, &source, sizeof(dest));
-  return dest;
-}
-
-inline bool is_big_endian() {
-  auto u = 1u;
-  struct bytes {
-    char data[sizeof(u)];
-  };
-  return bit_cast<bytes>(u).data[0] == 0;
-}
-
-// A fallback implementation of uintptr_t for systems that lack it.
-struct fallback_uintptr {
-  unsigned char value[sizeof(void*)];
-
-  fallback_uintptr() = default;
-  explicit fallback_uintptr(const void* p) {
-    *this = bit_cast<fallback_uintptr>(p);
-    if (is_big_endian()) {
-      for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
-        std::swap(value[i], value[j]);
-    }
-  }
-};
-#ifdef UINTPTR_MAX
-using uintptr_t = ::uintptr_t;
-inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
-#else
-using uintptr_t = fallback_uintptr;
-inline fallback_uintptr to_uintptr(const void* p) {
-  return fallback_uintptr(p);
-}
-#endif
-
-// Returns the largest possible value for type T. Same as
-// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
-template <typename T> constexpr T max_value() {
-  return (std::numeric_limits<T>::max)();
-}
-template <typename T> constexpr int num_bits() {
-  return std::numeric_limits<T>::digits;
-}
-template <> constexpr int num_bits<fallback_uintptr>() {
-  return static_cast<int>(sizeof(void*) *
-                          std::numeric_limits<unsigned char>::digits);
-}
-
-// An approximation of iterator_t for pre-C++20 systems.
-template <typename T>
-using iterator_t = decltype(std::begin(std::declval<T&>()));
-
-// Detect the iterator category of *any* given type in a SFINAE-friendly way.
-// Unfortunately, older implementations of std::iterator_traits are not safe
-// for use in a SFINAE-context.
-template <typename It, typename Enable = void>
-struct iterator_category : std::false_type {};
-
-template <typename T> struct iterator_category<T*> {
-  using type = std::random_access_iterator_tag;
-};
-
-template <typename It>
-struct iterator_category<It, void_t<typename It::iterator_category>> {
-  using type = typename It::iterator_category;
-};
-
-// Detect if *any* given type models the OutputIterator concept.
-template <typename It> class is_output_iterator {
-  // Check for mutability because all iterator categories derived from
-  // std::input_iterator_tag *may* also meet the requirements of an
-  // OutputIterator, thereby falling into the category of 'mutable iterators'
-  // [iterator.requirements.general] clause 4. The compiler reveals this
-  // property only at the point of *actually dereferencing* the iterator!
-  template <typename U>
-  static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
-  template <typename U> static char& test(std::output_iterator_tag);
-  template <typename U> static const char& test(...);
-
-  using type = decltype(test<It>(typename iterator_category<It>::type{}));
-
- public:
-  static const bool value = !std::is_const<remove_reference_t<type>>::value;
-};
-
-// A workaround for std::string not having mutable data() until C++17.
-template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
-  return &s[0];
-}
-template <typename Container>
-inline typename Container::value_type* get_data(Container& c) {
-  return c.data();
-}
-
-#ifdef _SECURE_SCL
-// Make a checked iterator to avoid MSVC warnings.
-template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
-template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
-  return {p, size};
-}
-#else
-template <typename T> using checked_ptr = T*;
-template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
-#endif
-
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline checked_ptr<typename Container::value_type> reserve(
-    std::back_insert_iterator<Container>& it, std::size_t n) {
-  Container& c = get_container(it);
-  std::size_t size = c.size();
-  c.resize(size + n);
-  return make_checked(get_data(c) + size, n);
-}
-
-template <typename Iterator>
-inline Iterator& reserve(Iterator& it, std::size_t) {
-  return it;
-}
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-class counting_iterator {
- private:
-  std::size_t count_;
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
-
-  struct value_type {
-    template <typename T> void operator=(const T&) {}
-  };
-
-  counting_iterator() : count_(0) {}
-
-  std::size_t count() const { return count_; }
-
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
-
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  value_type operator*() const { return {}; }
-};
-
-template <typename OutputIt> class truncating_iterator_base {
- protected:
-  OutputIt out_;
-  std::size_t limit_;
-  std::size_t count_;
-
-  truncating_iterator_base(OutputIt out, std::size_t limit)
-      : out_(out), limit_(limit), count_(0) {}
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = void;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
-
-  OutputIt base() const { return out_; }
-  std::size_t count() const { return count_; }
-};
-
-// An output iterator that truncates the output and counts the number of objects
-// written to it.
-template <typename OutputIt,
-          typename Enable = typename std::is_void<
-              typename std::iterator_traits<OutputIt>::value_type>::type>
-class truncating_iterator;
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::false_type>
-    : public truncating_iterator_base<OutputIt> {
-  using traits = std::iterator_traits<OutputIt>;
-
-  mutable typename traits::value_type blackhole_;
-
- public:
-  using value_type = typename traits::value_type;
-
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  truncating_iterator& operator++() {
-    if (this->count_++ < this->limit_) ++this->out_;
-    return *this;
-  }
-
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  value_type& operator*() const {
-    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
-  }
-};
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::true_type>
-    : public truncating_iterator_base<OutputIt> {
- public:
-  using value_type = typename OutputIt::container_type::value_type;
-
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  truncating_iterator& operator=(value_type val) {
-    if (this->count_++ < this->limit_) this->out_ = val;
-    return *this;
-  }
-
-  truncating_iterator& operator++() { return *this; }
-  truncating_iterator& operator++(int) { return *this; }
-  truncating_iterator& operator*() { return *this; }
-};
-
-// A range with the specified output iterator and value type.
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
-  OutputIt it_;
-
- public:
-  using value_type = T;
-  using iterator = OutputIt;
-  struct sentinel {};
-
-  explicit output_range(OutputIt it) : it_(it) {}
-  OutputIt begin() const { return it_; }
-  sentinel end() const { return {}; }  // Sentinel is not used yet.
-};
-
-template <typename Char>
-inline size_t count_code_points(basic_string_view<Char> s) {
-  return s.size();
-}
-
-// Counts the number of code points in a UTF-8 string.
-inline size_t count_code_points(basic_string_view<fmt_char8_t> s) {
-  const fmt_char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
-  }
-  return num_code_points;
-}
-
-template <typename Char>
-inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
-  size_t size = s.size();
-  return n < size ? n : size;
-}
-
-// Calculates the index of the nth code point in a UTF-8 string.
-inline size_t code_point_index(basic_string_view<fmt_char8_t> s, size_t n) {
-  const fmt_char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
-      return i;
-    }
-  }
-  return s.size();
-}
-
-inline fmt_char8_t to_fmt_char8_t(char c) { return static_cast<fmt_char8_t>(c); }
-
-template <typename InputIt, typename OutChar>
-using needs_conversion = bool_constant<
-    std::is_same<typename std::iterator_traits<InputIt>::value_type,
-                 char>::value &&
-    std::is_same<OutChar, fmt_char8_t>::value>;
-
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::copy(begin, end, it);
-}
-
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::transform(begin, end, it, to_fmt_char8_t);
-}
-
-#ifndef FMT_USE_GRISU
-#  define FMT_USE_GRISU 1
-#endif
-
-template <typename T> constexpr bool use_grisu() {
-  return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
-         sizeof(T) <= sizeof(double);
-}
-
-template <typename T>
-template <typename U>
-void buffer<T>::append(const U* begin, const U* end) {
-  std::size_t new_size = size_ + to_unsigned(end - begin);
-  reserve(new_size);
-  std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
-  size_ = new_size;
-}
-}  // namespace internal
-
-// A range with an iterator appending to a buffer.
-template <typename T>
-class buffer_range : public internal::output_range<
-                         std::back_insert_iterator<internal::buffer<T>>, T> {
- public:
-  using iterator = std::back_insert_iterator<internal::buffer<T>>;
-  using internal::output_range<iterator, T>::output_range;
-  buffer_range(internal::buffer<T>& buf)
-      : internal::output_range<iterator, T>(std::back_inserter(buf)) {}
-};
-
-// A UTF-8 string view.
-class u8string_view : public basic_string_view<fmt_char8_t> {
- public:
-  u8string_view(const char* s)
-      : basic_string_view<fmt_char8_t>(reinterpret_cast<const fmt_char8_t*>(s)) {}
-  u8string_view(const char* s, size_t count) FMT_NOEXCEPT
-      : basic_string_view<fmt_char8_t>(reinterpret_cast<const fmt_char8_t*>(s), count) {
-  }
-};
-
-#if FMT_USE_USER_DEFINED_LITERALS
-inline namespace literals {
-inline u8string_view operator"" _u(const char* s, std::size_t n) {
-  return {s, n};
-}
-}  // namespace literals
-#endif
-
-// The number of characters to store in the basic_memory_buffer object itself
-// to avoid dynamic memory allocation.
-enum { inline_buffer_size = 500 };
-
-/**
-  \rst
-  A dynamically growing memory buffer for trivially copyable/constructible types
-  with the first ``SIZE`` elements stored in the object itself.
-
-  You can use one of the following type aliases for common character types:
-
-  +----------------+------------------------------+
-  | Type           | Definition                   |
-  +================+==============================+
-  | memory_buffer  | basic_memory_buffer<char>    |
-  +----------------+------------------------------+
-  | wmemory_buffer | basic_memory_buffer<wchar_t> |
-  +----------------+------------------------------+
-
-  **Example**::
-
-     fmt::memory_buffer out;
-     format_to(out, "The answer is {}.", 42);
-
-  This will append the following output to the ``out`` object:
-
-  .. code-block:: none
-
-     The answer is 42.
-
-  The output can be converted to an ``std::string`` with ``to_string(out)``.
-  \endrst
- */
-template <typename T, std::size_t SIZE = inline_buffer_size,
-          typename Allocator = std::allocator<T>>
-class basic_memory_buffer : private Allocator, public internal::buffer<T> {
- private:
-  T store_[SIZE];
-
-  // Deallocate memory allocated by the buffer.
-  void deallocate() {
-    T* data = this->data();
-    if (data != store_) Allocator::deallocate(data, this->capacity());
-  }
-
- protected:
-  void grow(std::size_t size) FMT_OVERRIDE;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
-      : Allocator(alloc) {
-    this->set(store_, SIZE);
-  }
-  ~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }
-
- private:
-  // Move data from other to this buffer.
-  void move(basic_memory_buffer& other) {
-    Allocator &this_alloc = *this, &other_alloc = other;
-    this_alloc = std::move(other_alloc);
-    T* data = other.data();
-    std::size_t size = other.size(), capacity = other.capacity();
-    if (data == other.store_) {
-      this->set(store_, capacity);
-      std::uninitialized_copy(other.store_, other.store_ + size,
-                              internal::make_checked(store_, capacity));
-    } else {
-      this->set(data, capacity);
-      // Set pointer to the inline array so that delete is not called
-      // when deallocating.
-      other.set(other.store_, 0);
-    }
-    this->resize(size);
-  }
-
- public:
-  /**
-    \rst
-    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
-    of the other object to it.
-    \endrst
-   */
-  basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }
-
-  /**
-    \rst
-    Moves the content of the other ``basic_memory_buffer`` object to this one.
-    \endrst
-   */
-  basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {
-    FMT_ASSERT(this != &other, "");
-    deallocate();
-    move(other);
-    return *this;
-  }
-
-  // Returns a copy of the allocator associated with this buffer.
-  Allocator get_allocator() const { return *this; }
-};
-
-template <typename T, std::size_t SIZE, typename Allocator>
-void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
-#endif
-  std::size_t old_capacity = this->capacity();
-  std::size_t new_capacity = old_capacity + old_capacity / 2;
-  if (size > new_capacity) new_capacity = size;
-  T* old_data = this->data();
-  T* new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
-  // The following code doesn't throw, so the raw pointer above doesn't leak.
-  std::uninitialized_copy(old_data, old_data + this->size(),
-                          internal::make_checked(new_data, new_capacity));
-  this->set(new_data, new_capacity);
-  // deallocate must not throw according to the standard, but even if it does,
-  // the buffer already uses the new storage and will deallocate it in
-  // destructor.
-  if (old_data != store_) Allocator::deallocate(old_data, old_capacity);
-}
-
-using memory_buffer = basic_memory_buffer<char>;
-using wmemory_buffer = basic_memory_buffer<wchar_t>;
-
-namespace internal {
-
-// Returns true if value is negative, false otherwise.
-// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
-template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T value) {
-  return value < 0;
-}
-template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T) {
-  return false;
-}
-
-// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
-// represent all values of T.
-template <typename T>
-using uint32_or_64_or_128_t = conditional_t<
-    std::numeric_limits<T>::digits <= 32, uint32_t,
-    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
-
-// Static data is placed in this class template for the header-only config.
-template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
-  static const uint64_t powers_of_10_64[];
-  static const uint32_t zero_or_powers_of_10_32[];
-  static const uint64_t zero_or_powers_of_10_64[];
-  static const uint64_t pow10_significands[];
-  static const int16_t pow10_exponents[];
-  static const char digits[];
-  static const char hex_digits[];
-  static const char foreground_color[];
-  static const char background_color[];
-  static const char reset_color[5];
-  static const wchar_t wreset_color[5];
-  static const char signs[];
-};
-
-FMT_EXTERN template struct basic_data<void>;
-
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
-
-#ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline int count_digits(uint64_t n) {
-  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
-}
-#else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline int count_digits(uint64_t n) {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000u;
-    count += 4;
-  }
-}
-#endif
-
-#if FMT_USE_INT128
-inline int count_digits(uint128_t n) {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000U;
-    count += 4;
-  }
-}
-#endif
-
-// Counts the number of digits in n. BITS = log2(radix).
-template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
-  int num_digits = 0;
-  do {
-    ++num_digits;
-  } while ((n >>= BITS) != 0);
-  return num_digits;
-}
-
-template <> int count_digits<4>(internal::fallback_uintptr n);
-
-#if FMT_GCC_VERSION || FMT_CLANG_VERSION
-#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
-#else
-#  define FMT_ALWAYS_INLINE
-#endif
-
-#ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline int count_digits(uint32_t n) {
-  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
-}
-#endif
-
-template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);
-template <typename Char> inline std::string grouping(locale_ref loc) {
-  return grouping_impl<char>(loc);
-}
-template <> inline std::string grouping<wchar_t>(locale_ref loc) {
-  return grouping_impl<wchar_t>(loc);
-}
-
-template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
-template <typename Char> inline Char thousands_sep(locale_ref loc) {
-  return Char(thousands_sep_impl<char>(loc));
-}
-template <> inline wchar_t thousands_sep(locale_ref loc) {
-  return thousands_sep_impl<wchar_t>(loc);
-}
-
-template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
-template <typename Char> inline Char decimal_point(locale_ref loc) {
-  return Char(decimal_point_impl<char>(loc));
-}
-template <> inline wchar_t decimal_point(locale_ref loc) {
-  return decimal_point_impl<wchar_t>(loc);
-}
-
-// Formats a decimal unsigned integer value writing into buffer.
-// add_thousands_sep is called after writing each char to add a thousands
-// separator if necessary.
-template <typename UInt, typename Char, typename F>
-inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
-                            F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  buffer += num_digits;
-  Char* end = buffer;
-  while (value >= 100) {
-    // Integer division is slow so do it for a group of two digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    auto index = static_cast<unsigned>((value % 100) * 2);
-    value /= 100;
-    *--buffer = static_cast<Char>(data::digits[index + 1]);
-    add_thousands_sep(buffer);
-    *--buffer = static_cast<Char>(data::digits[index]);
-    add_thousands_sep(buffer);
-  }
-  if (value < 10) {
-    *--buffer = static_cast<Char>('0' + value);
-    return end;
-  }
-  auto index = static_cast<unsigned>(value * 2);
-  *--buffer = static_cast<Char>(data::digits[index + 1]);
-  add_thousands_sep(buffer);
-  *--buffer = static_cast<Char>(data::digits[index]);
-  return end;
-}
-
-template <typename Int> constexpr int digits10() noexcept {
-  return std::numeric_limits<Int>::digits10;
-}
-template <> constexpr int digits10<int128_t>() noexcept { return 38; }
-template <> constexpr int digits10<uint128_t>() noexcept { return 38; }
-
-template <typename Char, typename UInt, typename Iterator, typename F>
-inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
-                               F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  // Buffer should be large enough to hold all digits (<= digits10 + 1).
-  enum { max_size = digits10<UInt>() + 1 };
-  Char buffer[2 * max_size];
-  auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
-  return internal::copy_str<Char>(buffer, end, out);
-}
-
-template <typename Char, typename It, typename UInt>
-inline It format_decimal(It out, UInt value, int num_digits) {
-  return format_decimal<Char>(out, value, num_digits, [](Char*) {});
-}
-
-template <unsigned BASE_BITS, typename Char, typename UInt>
-inline Char* format_uint(Char* buffer, UInt value, int num_digits,
-                         bool upper = false) {
-  buffer += num_digits;
-  Char* end = buffer;
-  do {
-    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
-    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
-                                                : digits[digit]);
-  } while ((value >>= BASE_BITS) != 0);
-  return end;
-}
-
-template <unsigned BASE_BITS, typename Char>
-Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,
-                  bool = false) {
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  int start = (num_digits + char_digits - 1) / char_digits - 1;
-  if (int start_digits = num_digits % char_digits) {
-    unsigned value = n.value[start--];
-    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
-  }
-  for (; start >= 0; --start) {
-    unsigned value = n.value[start];
-    buffer += char_digits;
-    auto p = buffer;
-    for (int i = 0; i < char_digits; ++i) {
-      unsigned digit = (value & ((1 << BASE_BITS) - 1));
-      *--p = static_cast<Char>(data::hex_digits[digit]);
-      value >>= BASE_BITS;
-    }
-  }
-  return buffer;
-}
-
-template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
-inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
-  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[num_bits<UInt>() / BASE_BITS + 1];
-  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return internal::copy_str<Char>(buffer, buffer + num_digits, out);
-}
-
-template <typename T = void> struct null {};
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  Char data_[6];
-
- public:
-  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
-  FMT_CONSTEXPR const Char& operator[](size_t index) const {
-    return data_[index];
-  }
-
-  static FMT_CONSTEXPR fill_t<Char> make() {
-    auto fill = fill_t<Char>();
-    fill[0] = Char(' ');
-    return fill;
-  }
-};
-}  // namespace internal
-
-// We cannot use enum classes as bit fields because of a gcc bug
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
-namespace align {
-enum type { none, left, right, center, numeric };
-}
-using align_t = align::type;
-
-namespace sign {
-enum type { none, minus, plus, space };
-}
-using sign_t = sign::type;
-
-// Format specifiers for built-in and string types.
-template <typename Char> struct basic_format_specs {
-  int width;
-  int precision;
-  char type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
-  internal::fill_t<Char> fill;
-  char thousands;
-
-  constexpr basic_format_specs()
-      : width(0),
-        precision(-1),
-        type(0),
-        align(align::none),
-        sign(sign::none),
-        alt(false),
-        fill(internal::fill_t<Char>::make()),
-        thousands('\0'){}
-};
-
-using format_specs = basic_format_specs<char>;
-
-namespace internal {
-
-// A floating-point presentation format.
-enum class float_format : unsigned char {
-  general,  // General: exponent notation or fixed point based on magnitude.
-  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
-  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
-  hex
-};
-
-struct float_specs {
-  int precision;
-  float_format format : 8;
-  sign_t sign : 8;
-  char thousand_sep : 8;
-  bool upper : 1;
-  bool locale : 1;
-  bool percent : 1;
-  bool binary32 : 1;
-  bool use_grisu : 1;
-  bool trailing_zeros : 1;
-};
-
-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Char, typename It> It write_exponent(int exp, It it) {
-  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
-  if (exp < 0) {
-    *it++ = static_cast<Char>('-');
-    exp = -exp;
-  } else {
-    *it++ = static_cast<Char>('+');
-  }
-  if (exp >= 100) {
-    const char* top = data::digits + (exp / 100) * 2;
-    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
-    *it++ = static_cast<Char>(top[1]);
-    exp %= 100;
-  }
-  const char* d = data::digits + exp * 2;
-  *it++ = static_cast<Char>(d[0]);
-  *it++ = static_cast<Char>(d[1]);
-  return it;
-}
-
-template <typename Char> class float_writer {
- private:
-  // The number is given as v = digits_ * pow(10, exp_).
-  const char* digits_;
-  int num_digits_;
-  int exp_;
-  size_t size_;
-  float_specs specs_;
-  Char decimal_point_;
-
-  template <typename It> It prettify(It it) const {
-    // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
-    int full_exp = num_digits_ + exp_;
-    if (specs_.format == float_format::exp) {
-      // Insert a decimal point after the first digit and add an exponent.
-      *it++ = static_cast<Char>(*digits_);
-      int num_zeros = specs_.precision - num_digits_;
-      bool trailing_zeros = num_zeros > 0 && specs_.trailing_zeros;
-      if (num_digits_ > 1 || trailing_zeros) *it++ = decimal_point_;
-      it = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
-      if (trailing_zeros)
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      *it++ = static_cast<Char>(specs_.upper ? 'E' : 'e');
-      return write_exponent<Char>(full_exp - 1, it);
-    }
-    if (num_digits_ <= full_exp) {
-      // 1234e7 -> 12340000000[.0+]
-      if (specs_.thousand_sep != '\0' && full_exp > 3) {
-        // thousand separator
-        // we need to print the thousand separator every 3 digits
-        // the loop is essentially write 3 digits, write the thousand separator
-        // the exception is the first batch of digits which are 1-3 digits
-        int digit_count = full_exp % 3 == 0 ? 3 : full_exp % 3;
-        for(int i = 0; i < full_exp; i += digit_count, digit_count = 3) {
-          if (i > 0) {
-            *it++ = specs_.thousand_sep;
-          }
-          if (i < num_digits_) {
-            // we still need to write digits
-            int write_count = std::min<int>(num_digits_ - i, digit_count);
-            it = copy_str<Char>(digits_ + i, digits_ + i + write_count, it);
-            if (write_count < digit_count) {
-              // write any trailing zeros that belong to this batch
-              it = std::fill_n(it, digit_count - write_count, static_cast<Char>('0'));
-            }
-          } else {
-            // we only need to write trailing zeros
-            it = std::fill_n(it, digit_count, static_cast<Char>('0'));
-          }
-        }
-      } else {
-        it = copy_str<Char>(digits_, digits_ + num_digits_, it);
-        it = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
-      }
-      if (specs_.trailing_zeros) {
-        *it++ = decimal_point_;
-        int num_zeros = specs_.precision - full_exp;
-        if (num_zeros <= 0) {
-          if (specs_.format != float_format::fixed)
-            *it++ = static_cast<Char>('0');
-          return it;
-        }
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-        if (num_zeros > 1000)
-          throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
-#endif
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      }
-    } else if (full_exp > 0) {
-      // 1234e-2 -> 12.34[0+]
-      if (specs_.thousand_sep != '\0' && full_exp > 3) {
-        // thousand separator
-        // we need to print the thousand separator every 3 digits
-        // the loop is essentially write 3 digits, write the thousand separator
-        // the exception is the first batch of digits which are 1-3 digits
-        int digit_count = full_exp % 3 == 0 ? 3 : full_exp % 3;
-        for(int i = 0; i < full_exp; i += digit_count, digit_count = 3) {
-          if (i > 0) {
-            *it++ = specs_.thousand_sep;
-          }
-          it = copy_str<Char>(digits_ + i, digits_ + i + digit_count, it);
-        }
-      } else {
-        it = copy_str<Char>(digits_, digits_ + full_exp, it);
-      }
-      if (!specs_.trailing_zeros) {
-        // Remove trailing zeros.
-        int num_digits = num_digits_;
-        while (num_digits > full_exp && digits_[num_digits - 1] == '0')
-          --num_digits;
-        if (num_digits != full_exp) *it++ = decimal_point_;
-        return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
-      }
-      *it++ = decimal_point_;
-      it = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
-      if (specs_.precision > num_digits_) {
-        // Add trailing zeros.
-        int num_zeros = specs_.precision - num_digits_;
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      }
-    } else {
-      // 1234e-6 -> 0.001234
-      *it++ = static_cast<Char>('0');
-      int num_zeros = -full_exp;
-      if (num_digits_ == 0 && specs_.precision >= 0 && specs_.precision < num_zeros)
-        num_zeros = specs_.precision;
-      int num_digits = num_digits_;
-      if (!specs_.trailing_zeros)
-        while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;
-      if (num_zeros != 0 || num_digits != 0) {
-        *it++ = decimal_point_;
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-        it = copy_str<Char>(digits_, digits_ + num_digits, it);
-      }
-    }
-    return it;
-  }
-
- public:
-  float_writer(const char* digits, int num_digits, int exp, float_specs specs,
-               Char decimal_point)
-      : digits_(digits),
-        num_digits_(num_digits),
-        exp_(exp),
-        specs_(specs),
-        decimal_point_(decimal_point) {
-    int full_exp = num_digits + exp - 1;
-    int precision = specs.precision > 0 ? specs.precision : 16;
-    if (specs_.format == float_format::general &&
-        !(full_exp >= -4 && full_exp < precision)) {
-      specs_.format = float_format::exp;
-    }
-    size_ = prettify(counting_iterator()).count();
-    size_ += specs.sign ? 1 : 0;
-  }
-
-  size_t size() const { return size_; }
-  size_t width() const { return size(); }
-
-  template <typename It> void operator()(It&& it) {
-    if (specs_.sign) *it++ = static_cast<Char>(data::signs[specs_.sign]);
-    it = prettify(it);
-  }
-};
-
-template <typename T>
-int format_float(T value, int precision, float_specs specs, buffer<char>& buf);
-
-// Formats a floating-point number with snprintf.
-template <typename T>
-int snprintf_float(T value, int precision, float_specs specs,
-                   buffer<char>& buf);
-
-template <typename T> T promote_float(T value) { return value; }
-inline double promote_float(float value) { return value; }
-
-template <typename Spec, typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(const Spec& specs, Handler&& handler) {
-  if (specs.thousands != '\0') {
-    handler.on_num();
-    return;
-  }
-  switch (specs.type) {
-  case 0:
-  case 'd':
-    handler.on_dec();
-    break;
-  case 'x':
-  case 'X':
-    handler.on_hex();
-    break;
-  case 'b':
-  case 'B':
-    handler.on_bin();
-    break;
-  case 'o':
-    handler.on_oct();
-    break;
-  case 'n':
-  case 'l':
-  case 'L':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error("Invalid type specifier \"" + std::string(1, specs.type) + "\" for formatting a value of type int");
-  }
-}
-
-template <typename ErrorHandler = error_handler, typename Char>
-FMT_CONSTEXPR float_specs parse_float_type_spec(
-    const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
-
-  auto result = float_specs();
-  result.thousand_sep = specs.thousands;
-  result.trailing_zeros = specs.alt;
-  switch (specs.type) {
-  case 0:
-    result.format = float_format::general;
-    result.trailing_zeros |= specs.precision != 0;
-    break;
-  case 'G':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'g':
-    result.format = float_format::general;
-    break;
-  case 'E':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'e':
-    result.format = float_format::exp;
-    result.trailing_zeros |= specs.precision != 0;
-    break;
-  case 'F':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'f':
-    result.format = float_format::fixed;
-    result.trailing_zeros |= specs.precision != 0;
-    break;
-#if FMT_DEPRECATED_PERCENT
-  case '%':
-    result.format = float_format::fixed;
-    result.percent = true;
-    break;
-#endif
-  case 'A':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'a':
-    result.format = float_format::hex;
-    break;
-  case 'n':
-  case 'l':
-  case 'L':
-    result.locale = true;
-    break;
-  default:
-    eh.on_error("Invalid type specifier \"" + std::string(1, specs.type) + "\" for formatting a value of type float");
-    break;
-  }
-  return result;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
-                                     Handler&& handler) {
-  if (!specs) return handler.on_char();
-  if (specs->type && specs->type != 'c') return handler.on_int();
-  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
-    handler.on_error("invalid format specifier for char");
-  handler.on_char();
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
-  if (spec == 0 || spec == 's')
-    handler.on_string();
-  else if (spec == 'p')
-    handler.on_pointer();
-  else
-    handler.on_error("Invalid type specifier \"" + std::string(1, spec) + "\" for formatting a value of type string");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 's') eh.on_error("Invalid type specifier \"" + std::string(1, spec) + "\" for formatting a value of type string");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 'p') eh.on_error("Invalid type specifier \"" + std::string(1, spec) + "\" for formatting a value of type pointer");
-}
-
-template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_dec() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_bin() {}
-  FMT_CONSTEXPR void on_oct() {}
-  FMT_CONSTEXPR void on_num() {}
-
-  FMT_CONSTEXPR void on_error(std::string error) {
-    ErrorHandler::on_error(error);
-  }
-};
-
-template <typename ErrorHandler>
-class char_specs_checker : public ErrorHandler {
- private:
-  char type_;
-
- public:
-  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
-      : ErrorHandler(eh), type_(type) {}
-
-  FMT_CONSTEXPR void on_int() {
-    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
-  }
-  FMT_CONSTEXPR void on_char() {}
-};
-
-template <typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_string() {}
-  FMT_CONSTEXPR void on_pointer() {}
-};
-
-template <typename Context>
-void arg_map<Context>::init(const basic_format_args<Context>& args) {
-  if (map_) return;
-  map_ = new entry[internal::to_unsigned(args.max_size())];
-  if (args.is_packed()) {
-    for (int i = 0;; ++i) {
-      internal::type arg_type = args.type(i);
-      if (arg_type == internal::none_type) return;
-      if (arg_type == internal::named_arg_type) push_back(args.values_[i]);
-    }
-  }
-  for (int i = 0, n = args.max_size(); i < n; ++i) {
-    auto type = args.args_[i].type_;
-    if (type == internal::named_arg_type) push_back(args.args_[i].value_);
-  }
-}
-
-template <typename Char> struct nonfinite_writer {
-  sign_t sign;
-  const char* str;
-  static constexpr size_t str_size = 3;
-
-  size_t size() const { return str_size + (sign ? 1 : 0); }
-  size_t width() const { return size(); }
-
-  template <typename It> void operator()(It&& it) const {
-    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
-    it = copy_str<Char>(str, str + str_size, it);
-  }
-};
-
-// This template provides operations for formatting and writing data into a
-// character range.
-template <typename Range> class basic_writer {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
-
- private:
-  iterator out_;  // Output iterator.
-  locale_ref locale_;
-
-  // Attempts to reserve space for n extra characters in the output range.
-  // Returns a pointer to the reserved range or a reference to out_.
-  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
-    return internal::reserve(out_, n);
-  }
-
-  template <typename F> struct padded_int_writer {
-    size_t size_;
-    string_view prefix;
-    char_type fill;
-    std::size_t padding;
-    F f;
-
-    size_t size() const { return size_; }
-    size_t width() const { return size_; }
-
-    template <typename It> void operator()(It&& it) const {
-      if (prefix.size() != 0)
-        it = copy_str<char_type>(prefix.begin(), prefix.end(), it);
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    }
-  };
-
-  // Writes an integer in the format
-  //   <left-padding><prefix><numeric-padding><digits><right-padding>
-  // where <digits> are written by f(it).
-  template <typename F>
-  void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
-    std::size_t size = prefix.size() + to_unsigned(num_digits);
-    char_type fill = specs.fill[0];
-    std::size_t padding = 0;
-    if (specs.align == align::numeric) {
-      auto unsiged_width = to_unsigned(specs.width);
-      if (unsiged_width > size) {
-        padding = unsiged_width - size;
-        size = unsiged_width;
-      }
-    } else if (specs.precision > num_digits) {
-      size = prefix.size() + to_unsigned(specs.precision);
-      padding = to_unsigned(specs.precision - num_digits);
-      fill = static_cast<char_type>('0');
-    }
-    if (specs.align == align::none) specs.align = align::right;
-    write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
-  }
-
-  // Writes a decimal integer.
-  template <typename Int> void write_decimal(Int value) {
-    auto abs_value = static_cast<uint32_or_64_or_128_t<Int>>(value);
-    bool negative = is_negative(value);
-    // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
-    if (negative) abs_value = ~abs_value + 1;
-    int num_digits = count_digits(abs_value);
-    auto&& it = reserve((negative ? 1 : 0) + static_cast<size_t>(num_digits));
-    if (negative) *it++ = static_cast<char_type>('-');
-    it = format_decimal<char_type>(it, abs_value, num_digits);
-  }
-
-  // The handle_int_type_spec handler that writes an integer.
-  template <typename Int, typename Specs> struct int_writer {
-    using unsigned_type = uint32_or_64_or_128_t<Int>;
-
-    basic_writer<Range>& writer;
-    const Specs& specs;
-    unsigned_type abs_value;
-    char prefix[4];
-    unsigned prefix_size;
-
-    string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
-    int_writer(basic_writer<Range>& w, Int value, const Specs& s)
-        : writer(w),
-          specs(s),
-          abs_value(static_cast<unsigned_type>(value)),
-          prefix_size(0) {
-      if (is_negative(value)) {
-        prefix[0] = '-';
-        ++prefix_size;
-        abs_value = 0 - abs_value;
-      } else if (specs.sign != sign::none && specs.sign != sign::minus) {
-        prefix[0] = specs.sign == sign::plus ? '+' : ' ';
-        ++prefix_size;
-      }
-    }
-
-    struct dec_writer {
-      unsigned_type abs_value;
-      int num_digits;
-
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_decimal<char_type>(it, abs_value, num_digits);
-      }
-    };
-
-    void on_dec() {
-      int num_digits = count_digits(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       dec_writer{abs_value, num_digits});
-    }
-
-    struct hex_writer {
-      int_writer& self;
-      int num_digits;
-
-      template <typename It> void operator()(It&& it) const {
-        it = format_uint<4, char_type>(it, self.abs_value, num_digits,
-                                       self.specs.type != 'x');
-      }
-    };
-
-    void on_hex() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = specs.type;
-      }
-      int num_digits = count_digits<4>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       hex_writer{*this, num_digits});
-    }
-
-    template <int BITS> struct bin_writer {
-      unsigned_type abs_value;
-      int num_digits;
-
-      template <typename It> void operator()(It&& it) const {
-        it = format_uint<BITS, char_type>(it, abs_value, num_digits);
-      }
-    };
-
-    void on_bin() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = static_cast<char>(specs.type);
-      }
-      int num_digits = count_digits<1>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<1>{abs_value, num_digits});
-    }
-
-    void on_oct() {
-      int num_digits = count_digits<3>(abs_value);
-      if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
-        // Octal prefix '0' is counted as a digit, so only add it if precision
-        // is not greater than the number of digits.
-        prefix[prefix_size++] = '0';
-      }
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<3>{abs_value, num_digits});
-    }
-
-    enum { sep_size = 1 };
-
-    struct num_writer {
-      unsigned_type abs_value;
-      int size;
-      const std::string& groups;
-      char_type sep;
-
-      template <typename It> void operator()(It&& it) const {
-        basic_string_view<char_type> s(&sep, sep_size);
-        // Index of a decimal digit with the least significant digit having
-        // index 0.
-        int digit_index = 0;
-        std::string::const_iterator group = groups.cbegin();
-        it = format_decimal<char_type>(
-            it, abs_value, size,
-            [this, s, &group, &digit_index](char_type*& buffer) {
-              if (*group <= 0 || ++digit_index % *group != 0 ||
-                  *group == max_value<char>())
-                return;
-              if (group + 1 != groups.cend()) {
-                digit_index = 0;
-                ++group;
-              }
-              buffer -= s.size();
-              std::uninitialized_copy(s.data(), s.data() + s.size(),
-                                      make_checked(buffer, s.size()));
-            });
-      }
-    };
-
-    void on_num() {
-      std::string groups = grouping<char_type>(writer.locale_);
-      if (groups.empty()) return on_dec();
-      auto sep = specs.thousands;
-      if (!sep) return on_dec();
-      int num_digits = count_digits(abs_value);
-      int size = num_digits;
-      std::string::const_iterator group = groups.cbegin();
-      while (group != groups.cend() && num_digits > *group && *group > 0 &&
-             *group != max_value<char>()) {
-        size += sep_size;
-        num_digits -= *group;
-        ++group;
-      }
-      if (group == groups.cend())
-        size += sep_size * ((num_digits - 1) / groups.back());
-      writer.write_int(size, get_prefix(), specs,
-                       num_writer{abs_value, size, groups, static_cast<char_type>(sep)});
-    }
-
-    FMT_NORETURN void on_error(std::string error) {
-      FMT_THROW(duckdb::InvalidInputException(error));
-    }
-  };
-
-  template <typename Char> struct str_writer {
-    const Char* s;
-    size_t size_;
-
-    size_t size() const { return size_; }
-    size_t width() const {
-      return count_code_points(basic_string_view<Char>(s, size_));
-    }
-
-    template <typename It> void operator()(It&& it) const {
-      it = copy_str<char_type>(s, s + size_, it);
-    }
-  };
-
-  template <typename UIntPtr> struct pointer_writer {
-    UIntPtr value;
-    int num_digits;
-
-    size_t size() const { return to_unsigned(num_digits) + 2; }
-    size_t width() const { return size(); }
-
-    template <typename It> void operator()(It&& it) const {
-      *it++ = static_cast<char_type>('0');
-      *it++ = static_cast<char_type>('x');
-      it = format_uint<4, char_type>(it, value, num_digits);
-    }
-  };
-
- public:
-  explicit basic_writer(Range out, locale_ref loc = locale_ref())
-      : out_(out.begin()), locale_(loc) {}
-
-  iterator out() const { return out_; }
-
-  // Writes a value in the format
-  //   <left-padding><value><right-padding>
-  // where <value> is written by f(it).
-  template <typename F> void write_padded(const format_specs& specs, F&& f) {
-    // User-perceived width (in code points).
-    unsigned width = to_unsigned(specs.width);
-    size_t size = f.size();  // The number of code units.
-    size_t num_code_points = width != 0 ? f.width() : size;
-    if (width <= num_code_points) return f(reserve(size));
-    auto&& it = reserve(width + (size - num_code_points));
-    char_type fill = specs.fill[0];
-    std::size_t padding = width - num_code_points;
-    if (specs.align == align::right) {
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    } else if (specs.align == align::center) {
-      std::size_t left_padding = padding / 2;
-      it = std::fill_n(it, left_padding, fill);
-      f(it);
-      it = std::fill_n(it, padding - left_padding, fill);
-    } else {
-      f(it);
-      it = std::fill_n(it, padding, fill);
-    }
-  }
-
-  void write(int value) { write_decimal(value); }
-  void write(long value) { write_decimal(value); }
-  void write(long long value) { write_decimal(value); }
-
-  void write(unsigned value) { write_decimal(value); }
-  void write(unsigned long value) { write_decimal(value); }
-  void write(unsigned long long value) { write_decimal(value); }
-
-#if FMT_USE_INT128
-  void write(int128_t value) { write_decimal(value); }
-  void write(uint128_t value) { write_decimal(value); }
-#endif
-
-  template <typename T, typename Spec>
-  void write_int(T value, const Spec& spec) {
-    handle_int_type_spec(spec, int_writer<T, Spec>(*this, value, spec));
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  void write(T value, format_specs specs = {}) {
-    float_specs fspecs = parse_float_type_spec(specs);
-    fspecs.sign = specs.sign;
-    if (std::signbit(value)) {  // value < 0 is false for NaN so use signbit.
-      fspecs.sign = sign::minus;
-      value = -value;
-    } else if (fspecs.sign == sign::minus) {
-      fspecs.sign = sign::none;
-    }
-
-    if (!std::isfinite(value)) {
-      auto str = std::isinf(value) ? (fspecs.upper ? "INF" : "inf")
-                                   : (fspecs.upper ? "NAN" : "nan");
-      return write_padded(specs, nonfinite_writer<char_type>{fspecs.sign, str});
-    }
-
-    if (specs.align == align::none) {
-      specs.align = align::right;
-    } else if (specs.align == align::numeric) {
-      if (fspecs.sign) {
-        auto&& it = reserve(1);
-        *it++ = static_cast<char_type>(data::signs[fspecs.sign]);
-        fspecs.sign = sign::none;
-        if (specs.width != 0) --specs.width;
-      }
-      specs.align = align::right;
-    }
-
-    memory_buffer buffer;
-    if (fspecs.format == float_format::hex) {
-      if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
-      snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
-      write_padded(specs, str_writer<char>{buffer.data(), buffer.size()});
-      return;
-    }
-    int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
-    if (fspecs.format == float_format::exp) ++precision;
-    if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
-    fspecs.use_grisu = use_grisu<T>();
-    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) value *= 100;
-    int exp = format_float(promote_float(value), precision, fspecs, buffer);
-    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) {
-      buffer.push_back('%');
-      --exp;  // Adjust decimal place position.
-    }
-    fspecs.precision = precision;
-    char_type point;
-    if (fspecs.locale) {
-      point = decimal_point<char_type>(locale_);
-    } else if (fspecs.thousand_sep == '.') {
-      // if the thousand separator is a point, we automatically switch the decimal separator to comma
-      point =static_cast<char_type>(',');
-    } else {
-      point = static_cast<char_type>('.');
-    }
-    write_padded(specs, float_writer<char_type>(buffer.data(),
-                                                static_cast<int>(buffer.size()),
-                                                exp, fspecs, point));
-  }
-
-  void write(char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
-
-  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
-  void write(Char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
-
-  void write(string_view value) {
-    auto&& it = reserve(value.size());
-    it = copy_str<char_type>(value.begin(), value.end(), it);
-  }
-  void write(wstring_view value) {
-    static_assert(std::is_same<char_type, wchar_t>::value, "");
-    auto&& it = reserve(value.size());
-    it = std::copy(value.begin(), value.end(), it);
-  }
-
-  template <typename Char>
-  void write(const Char* s, std::size_t size, const format_specs& specs) {
-    write_padded(specs, str_writer<Char>{s, size});
-  }
-
-  template <typename Char>
-  void write(basic_string_view<Char> s, const format_specs& specs = {}) {
-    const Char* data = s.data();
-    std::size_t size = s.size();
-    if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
-      size = code_point_index(s, to_unsigned(specs.precision));
-    write(data, size, specs);
-  }
-
-  template <typename UIntPtr>
-  void write_pointer(UIntPtr value, const format_specs* specs) {
-    int num_digits = count_digits<4>(value);
-    auto pw = pointer_writer<UIntPtr>{value, num_digits};
-    if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
-    format_specs specs_copy = *specs;
-    if (specs_copy.align == align::none) specs_copy.align = align::right;
-    write_padded(specs_copy, pw);
-  }
-};
-
-using writer = basic_writer<buffer_range<char>>;
-
-template <typename T> struct is_integral : std::is_integral<T> {};
-template <> struct is_integral<int128_t> : std::true_type {};
-template <> struct is_integral<uint128_t> : std::true_type {};
-
-template <typename Range, typename ErrorHandler = internal::error_handler>
-class arg_formatter_base {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
-
- private:
-  using writer_type = basic_writer<Range>;
-  writer_type writer_;
-  format_specs* specs_;
-
-  struct char_writer {
-    char_type value;
-
-    size_t size() const { return 1; }
-    size_t width() const { return 1; }
-
-    template <typename It> void operator()(It&& it) const { *it++ = value; }
-  };
-
-  void write_char(char_type value) {
-    if (specs_)
-      writer_.write_padded(*specs_, char_writer{value});
-    else
-      writer_.write(value);
-  }
-
-  void write_pointer(const void* p) {
-    writer_.write_pointer(internal::to_uintptr(p), specs_);
-  }
-
- protected:
-  writer_type& writer() { return writer_; }
-  FMT_DEPRECATED format_specs* spec() { return specs_; }
-  format_specs* specs() { return specs_; }
-  iterator out() { return writer_.out(); }
-
-  void write(bool value) {
-    string_view sv(value ? "true" : "false");
-    specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-  }
-
-  void write(const char_type* value) {
-    if (!value) {
-      FMT_THROW(duckdb::InternalException("string pointer is null"));
-    } else {
-      auto length = std::char_traits<char_type>::length(value);
-      basic_string_view<char_type> sv(value, length);
-      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-    }
-  }
-
- public:
-  arg_formatter_base(Range r, format_specs* s, locale_ref loc)
-      : writer_(r, loc), specs_(s) {}
-
-  iterator operator()(monostate) {
-    FMT_ASSERT(false, "invalid argument type");
-    return out();
-  }
-
-  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
-  iterator operator()(T value) {
-    if (specs_)
-      writer_.write_int(value, *specs_);
-    else
-      writer_.write(value);
-    return out();
-  }
-
-  iterator operator()(char_type value) {
-    internal::handle_char_specs(
-        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
-    return out();
-  }
-
-  iterator operator()(bool value) {
-    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
-    write(value != 0);
-    return out();
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    writer_.write(value, specs_ ? *specs_ : format_specs());
-    return out();
-  }
-
-  struct char_spec_handler : ErrorHandler {
-    arg_formatter_base& formatter;
-    char_type value;
-
-    char_spec_handler(arg_formatter_base& f, char_type val)
-        : formatter(f), value(val) {}
-
-    void on_int() {
-      if (formatter.specs_)
-        formatter.writer_.write_int(value, *formatter.specs_);
-      else
-        formatter.writer_.write(value);
-    }
-    void on_char() { formatter.write_char(value); }
-  };
-
-  struct cstring_spec_handler : internal::error_handler {
-    arg_formatter_base& formatter;
-    const char_type* value;
-
-    cstring_spec_handler(arg_formatter_base& f, const char_type* val)
-        : formatter(f), value(val) {}
-
-    void on_string() { formatter.write(value); }
-    void on_pointer() { formatter.write_pointer(value); }
-  };
-
-  iterator operator()(const char_type* value) {
-    if (!specs_) return write(value), out();
-    internal::handle_cstring_type_spec(specs_->type,
-                                       cstring_spec_handler(*this, value));
-    return out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    if (specs_) {
-      internal::check_string_type_spec(specs_->type, internal::error_handler());
-      writer_.write(value, *specs_);
-    } else {
-      writer_.write(value);
-    }
-    return out();
-  }
-
-  iterator operator()(const void* value) {
-    if (specs_)
-      check_pointer_type_spec(specs_->type, internal::error_handler());
-    write_pointer(value);
-    return out();
-  }
-};
-
-template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
-
-// Parses the range [begin, end) as an unsigned integer. This function assumes
-// that the range is non-empty and the first character is a digit.
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
-                                        ErrorHandler&& eh) {
-  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
-  if (*begin == '0') {
-    ++begin;
-    return 0;
-  }
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  constexpr unsigned max_int = max_value<int>();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
-    }
-    value = value * 10 + unsigned(*begin - '0');
-    ++begin;
-  } while (begin != end && '0' <= *begin && *begin <= '9');
-  if (value > max_int) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
-
-template <typename Context> class custom_formatter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_parse_context<char_type>& parse_ctx_;
-  Context& ctx_;
-
- public:
-  explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
-                            Context& ctx)
-      : parse_ctx_(parse_ctx), ctx_(ctx) {}
-
-  bool operator()(typename basic_format_arg<Context>::handle h) const {
-    h.format(parse_ctx_, ctx_);
-    return true;
-  }
-
-  template <typename T> bool operator()(T) const { return false; }
-};
-
-template <typename T>
-using is_integer =
-    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
-                  !std::is_same<T, char>::value &&
-                  !std::is_same<T, wchar_t>::value>;
-
-template <typename ErrorHandler> class width_checker {
- public:
-  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
-
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative width");
-    return static_cast<unsigned long long>(value);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("width is not integer");
-    return 0;
-  }
-
- private:
-  ErrorHandler& handler_;
-};
-
-template <typename ErrorHandler> class precision_checker {
- public:
-  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
-
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative precision");
-    return static_cast<unsigned long long>(value);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("precision is not integer");
-    return 0;
-  }
-
- private:
-  ErrorHandler& handler_;
-};
-
-// A format specifier handler that sets fields in basic_format_specs.
-template <typename Char> class specs_setter {
- public:
-  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
-      : specs_(specs) {}
-
-  FMT_CONSTEXPR specs_setter(const specs_setter& other)
-      : specs_(other.specs_) {}
-
-  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
-  FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; }
-  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
-  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
-  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
-  FMT_CONSTEXPR void on_comma() { specs_.thousands = ','; }
-  FMT_CONSTEXPR void on_underscore() { specs_.thousands = '_'; }
-  FMT_CONSTEXPR void on_single_quote() { specs_.thousands = '\''; }
-  FMT_CONSTEXPR void on_thousands(char sep) { specs_.thousands = sep; }
-  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
-
-  FMT_CONSTEXPR void on_zero() {
-    specs_.align = align::numeric;
-    specs_.fill[0] = Char('0');
-  }
-
-  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
-  FMT_CONSTEXPR void on_precision(int precision) {
-    specs_.precision = precision;
-  }
-  FMT_CONSTEXPR void end_precision() {}
-
-  FMT_CONSTEXPR void on_type(Char type) {
-    specs_.type = static_cast<char>(type);
-  }
-
- protected:
-  basic_format_specs<Char>& specs_;
-};
-
-template <typename ErrorHandler> class numeric_specs_checker {
- public:
-  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
-      : error_handler_(eh), arg_type_(arg_type) {}
-
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic_type(arg_type_))
-      error_handler_.on_error("format specifier requires numeric argument");
-  }
-
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral_type(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
-      error_handler_.on_error("format specifier requires signed argument");
-    }
-  }
-
-  FMT_CONSTEXPR void check_precision() {
-    if (is_integral_type(arg_type_) || arg_type_ == internal::pointer_type)
-      error_handler_.on_error("precision not allowed for this argument type");
-  }
-
- private:
-  ErrorHandler& error_handler_;
-  internal::type arg_type_;
-};
-
-// A format specifier handler that checks if specifiers are consistent with the
-// argument type.
-template <typename Handler> class specs_checker : public Handler {
- public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
-      : Handler(handler), checker_(*this, arg_type) {}
-
-  FMT_CONSTEXPR specs_checker(const specs_checker& other)
-      : Handler(other), checker_(*this, other.arg_type_) {}
-
-  FMT_CONSTEXPR void on_align(align_t align) {
-    if (align == align::numeric) checker_.require_numeric_argument();
-    Handler::on_align(align);
-  }
-
-  FMT_CONSTEXPR void on_plus() {
-    checker_.check_sign();
-    Handler::on_plus();
-  }
-
-  FMT_CONSTEXPR void on_minus() {
-    checker_.check_sign();
-    Handler::on_minus();
-  }
-
-  FMT_CONSTEXPR void on_space() {
-    checker_.check_sign();
-    Handler::on_space();
-  }
-
-  FMT_CONSTEXPR void on_hash() {
-    checker_.require_numeric_argument();
-    Handler::on_hash();
-  }
-
-  FMT_CONSTEXPR void on_zero() {
-    checker_.require_numeric_argument();
-    Handler::on_zero();
-  }
-
-  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
-
- private:
-  numeric_specs_checker<Handler> checker_;
-};
-
-template <template <typename> class Handler, typename FormatArg,
-          typename ErrorHandler>
-FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
-  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
-  if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
-
-struct auto_id {};
-
-template <typename Context>
-FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
-  auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("Argument index \"" + std::to_string(id) + "\" out of range");
-  return arg;
-}
-
-// The standard format specifier handler with checking.
-template <typename ParseContext, typename Context>
-class specs_handler : public specs_setter<typename Context::char_type> {
- public:
-  using char_type = typename Context::char_type;
-
-  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
-                              ParseContext& parse_ctx, Context& ctx)
-      : specs_setter<char_type>(specs),
-        parse_context_(parse_ctx),
-        context_(ctx) {}
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    this->specs_.width = get_dynamic_spec<width_checker>(
-        get_arg(arg_id), context_.error_handler());
-  }
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    this->specs_.precision = get_dynamic_spec<precision_checker>(
-        get_arg(arg_id), context_.error_handler());
-  }
-
-  void on_error(std::string message) { context_.on_error(message); }
-
- private:
-  // This is only needed for compatibility with gcc 4.4.
-  using format_arg = typename Context::format_arg;
-
-  FMT_CONSTEXPR format_arg get_arg(auto_id) {
-    return internal::get_arg(context_, parse_context_.next_arg_id());
-  }
-
-  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return internal::get_arg(context_, arg_id);
-  }
-
-  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return context_.arg(arg_id);
-  }
-
-  ParseContext& parse_context_;
-  Context& context_;
-};
-
-enum class arg_id_kind { none, index, name };
-
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-  FMT_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
-      : kind(arg_id_kind::name), val(name) {}
-
-  FMT_CONSTEXPR arg_ref& operator=(int idx) {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
-
-  arg_id_kind kind;
-  union value {
-    FMT_CONSTEXPR value(int id = 0) : index{id} {}
-    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
-
-    int index;
-    basic_string_view<Char> name;
-  } val;
-};
-
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow re-using the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char>
-struct dynamic_format_specs : basic_format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
-
-// Format spec handler that saves references to arguments representing dynamic
-// width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler
-    : public specs_setter<typename ParseContext::char_type> {
- public:
-  using char_type = typename ParseContext::char_type;
-
-  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
-                                      ParseContext& ctx)
-      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
-
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
-      : specs_setter<char_type>(other),
-        specs_(other.specs_),
-        context_(other.context_) {}
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    specs_.width_ref = make_arg_ref(arg_id);
-  }
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    specs_.precision_ref = make_arg_ref(arg_id);
-  }
-
-  FMT_CONSTEXPR void on_error(std::string message) {
-    context_.on_error(message);
-  }
-
- private:
-  using arg_ref_type = arg_ref<char_type>;
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
-  }
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
-    return arg_ref_type(context_.next_arg_id());
-  }
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
-    context_.check_arg_id(arg_id);
-    basic_string_view<char_type> format_str(
-        context_.begin(), to_unsigned(context_.end() - context_.begin()));
-    return arg_ref_type(arg_id);
-  }
-
-  dynamic_format_specs<char_type>& specs_;
-  ParseContext& context_;
-};
-
-template <typename Char, typename IDHandler>
-FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
-                                       IDHandler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  Char c = *begin;
-  if (c == '}' || c == ':') {
-    handler();
-    return begin;
-  }
-  if (c >= '0' && c <= '9') {
-    int index = parse_nonnegative_int(begin, end, handler);
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      handler.on_error("invalid format string");
-    else
-      handler(index);
-    return begin;
-  }
-  if (!is_name_start(c)) {
-    handler.on_error("invalid format string");
-    return begin;
-  }
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
-  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
-  return it;
-}
-
-// Adapts SpecHandler to IDHandler API for dynamic width.
-template <typename SpecHandler, typename Char> struct width_adapter {
-  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
-
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_width(id);
-  }
-
-  FMT_CONSTEXPR void on_error(std::string message) {
-    handler.on_error(message);
-  }
-
-  SpecHandler& handler;
-};
-
-// Adapts SpecHandler to IDHandler API for dynamic precision.
-template <typename SpecHandler, typename Char> struct precision_adapter {
-  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
-
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_precision(id);
-  }
-
-  FMT_CONSTEXPR void on_error(std::string message) {
-    handler.on_error(message);
-  }
-
-  SpecHandler& handler;
-};
-
-// Parses fill and alignment.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  auto align = align::none;
-  int i = 0;
-  if (begin + 1 != end) ++i;
-  do {
-    switch (static_cast<char>(begin[i])) {
-    case '<':
-      align = align::left;
-      break;
-    case '>':
-      align = align::right;
-      break;
-#if FMT_NUMERIC_ALIGN
-    case '=':
-      align = align::numeric;
-      break;
-#endif
-    case '^':
-      align = align::center;
-      break;
-    }
-    if (align != align::none) {
-      if (i > 0) {
-        auto c = *begin;
-        if (c == '{')
-          return handler.on_error("invalid fill character '{'"), begin;
-        begin += 2;
-        handler.on_fill(c);
-      } else
-        ++begin;
-      handler.on_align(align);
-      break;
-    }
-  } while (i-- > 0);
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    handler.on_width(parse_nonnegative_int(begin, end, handler));
-  } else if (*begin == '{') {
-    ++begin;
-    if (begin != end)
-      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
-    if (begin == end || *begin != '}')
-      return handler.on_error("invalid format string"), begin;
-    ++begin;
-  }
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
-                                          Handler&& handler) {
-  ++begin;
-  auto c = begin != end ? *begin : Char();
-  if ('0' <= c && c <= '9') {
-    handler.on_precision(parse_nonnegative_int(begin, end, handler));
-  } else if (c == '{') {
-    ++begin;
-    if (begin != end) {
-      begin =
-          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
-    }
-    if (begin == end || *begin++ != '}')
-      return handler.on_error("invalid format string"), begin;
-  } else {
-    return handler.on_error("missing precision specifier"), begin;
-  }
-  handler.end_precision();
-  return begin;
-}
-
-// Parses standard format specifiers and sends notifications about parsed
-// components to handler.
-template <typename Char, typename SpecHandler>
-FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
-                                             SpecHandler&& handler) {
-  if (begin == end || *begin == '}') return begin;
-
-  begin = parse_align(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse sign.
-  switch (static_cast<char>(*begin)) {
-  case '+':
-    handler.on_plus();
-    ++begin;
-    break;
-  case '-':
-    handler.on_minus();
-    ++begin;
-    break;
-  case ' ':
-    handler.on_space();
-    ++begin;
-    break;
-  case ',':
-    handler.on_comma();
-    ++begin;
-    break;
-  case '_':
-    handler.on_underscore();
-    ++begin;
-    break;
-  case '\'':
-    handler.on_single_quote();
-    ++begin;
-    break;
-  case 't':
-    ++begin;
-    if (begin == end) return begin;
-    handler.on_thousands(*begin);
-    ++begin;
-    break;
-  }
-  if (begin == end) return begin;
-
-  if (*begin == '#') {
-    handler.on_hash();
-    if (++begin == end) return begin;
-  }
-
-  // Parse zero flag.
-  if (*begin == '0') {
-    handler.on_zero();
-    if (++begin == end) return begin;
-  }
-
-  begin = parse_width(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse precision.
-  if (*begin == '.') {
-    begin = parse_precision(begin, end, handler);
-  }
-
-  // Parse type.
-  if (begin != end && *begin != '}') handler.on_type(*begin++);
-  return begin;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline bool find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) {
-  out = static_cast<const char*>(
-      std::memchr(first, value, internal::to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-template <typename Handler, typename Char> struct id_adapter {
-  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_arg_id(id);
-  }
-  FMT_CONSTEXPR void on_error(std::string message) {
-    handler.on_error(message);
-  }
-  Handler& handler;
-};
-
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
-                                       Handler&& handler) {
-  struct pfs_writer {
-    FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
-      if (begin == end) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(begin, end, '}', p))
-          return handler_.on_text(begin, end);
-        ++p;
-        if (p == end || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(begin, p);
-        begin = p + 1;
-      }
-    }
-    Handler& handler_;
-  } write{handler};
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
-      return write(begin, end);
-    write(begin, p);
-    ++p;
-    if (p == end) return handler.on_error("invalid format string");
-    if (static_cast<char>(*p) == '}') {
-      handler.on_arg_id();
-      handler.on_replacement_field(p);
-    } else if (*p == '{') {
-      handler.on_text(p, p + 1);
-    } else {
-      p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
-      Char c = p != end ? *p : Char();
-      if (c == '}') {
-        handler.on_replacement_field(p);
-      } else if (c == ':') {
-        p = handler.on_format_specs(p + 1, end);
-        if (p == end || *p != '}')
-          return handler.on_error("unknown format specifier");
-      } else {
-        return handler.on_error("missing '}' in format string");
-      }
-    }
-    begin = p + 1;
-  }
-}
-
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
-    ParseContext& ctx) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type =
-      conditional_t<internal::mapped_type_constant<T, context>::value !=
-                        internal::custom_type,
-                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
-  auto f = conditional_t<has_formatter<mapped_type, context>::value,
-                         formatter<mapped_type, char_type>,
-                         internal::fallback_formatter<T, char_type>>();
-  return f.parse(ctx);
-}
-
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
-  explicit FMT_CONSTEXPR format_string_checker(
-      basic_string_view<Char> format_str, ErrorHandler eh)
-      : arg_id_(-1),
-        context_(format_str, eh),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
-
-  FMT_CONSTEXPR void on_arg_id() {
-    arg_id_ = context_.next_arg_id();
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(int id) {
-    arg_id_ = id;
-    context_.check_arg_id(id);
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
-    on_error("compile-time checks don't support named arguments");
-  }
-
-  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
-
-  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
-    advance_to(context_, begin);
-    return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
-  }
-
-  FMT_CONSTEXPR void on_error(std::string message) {
-    context_.on_error(message);
-  }
-
- private:
-  using parse_context_type = basic_format_parse_context<Char, ErrorHandler>;
-  enum { num_args = sizeof...(Args) };
-
-  FMT_CONSTEXPR void check_arg_id() {
-    if (arg_id_ >= num_args) context_.on_error("argument index out of range");
-  }
-
-  // Format specifier parsing function.
-  using parse_func = const Char* (*)(parse_context_type&);
-
-  int arg_id_;
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
-};
-
-template <typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
-                                          ErrorHandler eh = ErrorHandler()) {
-  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
-  parse_format_string<true>(s, checker);
-  return true;
-}
-
-template <typename... Args, typename S,
-          enable_if_t<(is_compile_string<S>::value), int>>
-void check_format_string(S format_str) {
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      internal::do_check_format_string<typename S::char_type,
-                                       internal::error_handler, Args...>(
-          to_string_view(format_str));
-  (void)invalid_format;
-}
-
-template <template <typename> class Handler, typename Context>
-void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
-                         Context& ctx) {
-  switch (ref.kind) {
-  case arg_id_kind::none:
-    break;
-  case arg_id_kind::index:
-    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
-                                                ctx.error_handler());
-    break;
-  case arg_id_kind::name:
-    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
-                                                ctx.error_handler());
-    break;
-  }
-}
-}  // namespace internal
-
-template <typename Range>
-using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
-using writer FMT_DEPRECATED_ALIAS = internal::writer;
-using wwriter FMT_DEPRECATED_ALIAS =
-    internal::basic_writer<buffer_range<wchar_t>>;
-
-/** The default argument formatter. */
-template <typename Range>
-class arg_formatter : public internal::arg_formatter_base<Range> {
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
-  using context_type = basic_format_context<typename base::iterator, char_type>;
-
-  context_type& ctx_;
-  basic_format_parse_context<char_type>* parse_ctx_;
-
- public:
-  using range = Range;
-  using iterator = typename base::iterator;
-  using format_specs = typename base::format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *ctx* is a reference to the formatting context,
-    *specs* contains format specifier information for standard argument types.
-    \endrst
-   */
-  explicit arg_formatter(
-      context_type& ctx,
-      basic_format_parse_context<char_type>* parse_ctx = nullptr,
-      format_specs* specs = nullptr)
-      : base(Range(ctx.out()), specs, ctx.locale()),
-        ctx_(ctx),
-        parse_ctx_(parse_ctx) {}
-
-  using base::operator();
-
-  /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(*parse_ctx_, ctx_);
-    return ctx_.out();
-  }
-};
-
-/** Fast integer formatter. */
-class format_int {
- private:
-  // Buffer should be large enough to hold all digits (digits10 + 1),
-  // a sign and a null character.
-  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
-  mutable char buffer_[buffer_size];
-  char* str_;
-
-  // Formats value in reverse and returns a pointer to the beginning.
-  char* format_decimal(unsigned long long value) {
-    char* ptr = buffer_ + (buffer_size - 1);  // Parens to workaround MSVC bug.
-    while (value >= 100) {
-      // Integer division is slow so do it for a group of two digits instead
-      // of for every digit. The idea comes from the talk by Alexandrescu
-      // "Three Optimization Tips for C++". See speed-test for a comparison.
-      auto index = static_cast<unsigned>((value % 100) * 2);
-      value /= 100;
-      *--ptr = internal::data::digits[index + 1];
-      *--ptr = internal::data::digits[index];
-    }
-    if (value < 10) {
-      *--ptr = static_cast<char>('0' + value);
-      return ptr;
-    }
-    auto index = static_cast<unsigned>(value * 2);
-    *--ptr = internal::data::digits[index + 1];
-    *--ptr = internal::data::digits[index];
-    return ptr;
-  }
-
-  void format_signed(long long value) {
-    auto abs_value = static_cast<unsigned long long>(value);
-    bool negative = value < 0;
-    if (negative) abs_value = 0 - abs_value;
-    str_ = format_decimal(abs_value);
-    if (negative) *--str_ = '-';
-  }
-
- public:
-  explicit format_int(int value) { format_signed(value); }
-  explicit format_int(long value) { format_signed(value); }
-  explicit format_int(long long value) { format_signed(value); }
-  explicit format_int(unsigned value) : str_(format_decimal(value)) {}
-  explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
-  explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
-
-  /** Returns the number of characters written to the output buffer. */
-  std::size_t size() const {
-    return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
-  }
-
-  /**
-    Returns a pointer to the output buffer content. No terminating null
-    character is appended.
-   */
-  const char* data() const { return str_; }
-
-  /**
-    Returns a pointer to the output buffer content with terminating null
-    character appended.
-   */
-  const char* c_str() const {
-    buffer_[buffer_size - 1] = '\0';
-    return str_;
-  }
-
-  /**
-    \rst
-    Returns the content of the output buffer as an ``std::string``.
-    \endrst
-   */
-  std::string str() const { return std::string(str_, size()); }
-};
-
-// A formatter specialization for the core types corresponding to internal::type
-// constants.
-template <typename T, typename Char>
-struct formatter<T, Char,
-                 enable_if_t<internal::type_constant<T, Char>::value !=
-                             internal::custom_type>> {
-  FMT_CONSTEXPR formatter() = default;
-
-  // Parses format specifiers stopping either at the end of the range or at the
-  // terminating '}'.
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    using handler_type = internal::dynamic_specs_handler<ParseContext>;
-    auto type = internal::type_constant<T, Char>::value;
-    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
-                                                  type);
-    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
-    auto eh = ctx.error_handler();
-    switch (type) {
-    case internal::none_type:
-    case internal::named_arg_type:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
-    case internal::int_type:
-    case internal::uint_type:
-    case internal::long_long_type:
-    case internal::ulong_long_type:
-    case internal::int128_type:
-    case internal::uint128_type:
-    case internal::bool_type:
-      handle_int_type_spec(specs_.type,
-                           internal::int_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::char_type:
-      handle_char_specs(
-          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
-      break;
-    case internal::float_type:
-    case internal::double_type:
-    case internal::long_double_type:
-      internal::parse_float_type_spec(specs_, eh);
-      break;
-    case internal::cstring_type:
-      internal::handle_cstring_type_spec(
-          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::string_type:
-      internal::check_string_type_spec(specs_.type, eh);
-      break;
-    case internal::pointer_type:
-      internal::check_pointer_type_spec(specs_.type, eh);
-      break;
-    case internal::custom_type:
-      // Custom format specifiers should be checked in parse functions of
-      // formatter specializations.
-      break;
-    }
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-    using range_type =
-        internal::output_range<typename FormatContext::iterator,
-                               typename FormatContext::char_type>;
-    return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
-                            internal::make_arg<FormatContext>(val));
-  }
-
- private:
-  internal::dynamic_format_specs<Char> specs_;
-};
-
-#define FMT_FORMAT_AS(Type, Base)                                             \
-  template <typename Char>                                                    \
-  struct formatter<Type, Char> : formatter<Base, Char> {                      \
-    template <typename FormatContext>                                         \
-    auto format(const Type& val, FormatContext& ctx) -> decltype(ctx.out()) { \
-      return formatter<Base, Char>::format(val, ctx);                         \
-    }                                                                         \
-  }
-
-FMT_FORMAT_AS(signed char, int);
-FMT_FORMAT_AS(unsigned char, unsigned);
-FMT_FORMAT_AS(short, int);
-FMT_FORMAT_AS(unsigned short, unsigned);
-FMT_FORMAT_AS(long, long long);
-FMT_FORMAT_AS(unsigned long, unsigned long long);
-FMT_FORMAT_AS(Char*, const Char*);
-FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
-FMT_FORMAT_AS(std::nullptr_t, const void*);
-FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);
-
-template <typename Char>
-struct formatter<void*, Char> : formatter<const void*, Char> {
-  template <typename FormatContext>
-  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
-    return formatter<const void*, Char>::format(val, ctx);
-  }
-};
-
-template <typename Char, size_t N>
-struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
-  template <typename FormatContext>
-  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
-    return formatter<basic_string_view<Char>, Char>::format(val, ctx);
-  }
-};
-
-// A formatter for types known only at run time such as variant alternatives.
-//
-// Usage:
-//   using variant = std::variant<int, std::string>;
-//   template <>
-//   struct formatter<variant>: dynamic_formatter<> {
-//     void format(buffer &buf, const variant &v, context &ctx) {
-//       visit([&](const auto &val) { format(buf, val, ctx); }, v);
-//     }
-//   };
-template <typename Char = char> class dynamic_formatter {
- private:
-  struct null_handler : internal::error_handler {
-    void on_align(align_t) {}
-    void on_plus() {}
-    void on_minus() {}
-    void on_space() {}
-    void on_hash() {}
-  };
-
- public:
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    format_str_ = ctx.begin();
-    // Checks are deferred to formatting time when the argument type is known.
-    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
-    return parse_format_specs(ctx.begin(), ctx.end(), handler);
-  }
-
-  template <typename T, typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
-    handle_specs(ctx);
-    internal::specs_checker<null_handler> checker(
-        null_handler(),
-        internal::mapped_type_constant<T, FormatContext>::value);
-    checker.on_align(specs_.align);
-    switch (specs_.sign) {
-    case sign::none:
-      break;
-    case sign::plus:
-      checker.on_plus();
-      break;
-    case sign::minus:
-      checker.on_minus();
-      break;
-    case sign::space:
-      checker.on_space();
-      break;
-    }
-    if (specs_.alt) checker.on_hash();
-    if (specs_.precision >= 0) checker.end_precision();
-    using range = internal::output_range<typename FormatContext::iterator,
-                                         typename FormatContext::char_type>;
-    visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
-                     internal::make_arg<FormatContext>(val));
-    return ctx.out();
-  }
-
- private:
-  template <typename Context> void handle_specs(Context& ctx) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-  }
-
-  internal::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
-};
-
-template <typename Range, typename Char>
-typename basic_format_context<Range, Char>::format_arg
-basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
-  map_.init(args_);
-  format_arg arg = map_.find(name);
-  if (arg.type() == internal::none_type) this->on_error("Argument with name \"" + name.to_string() + "\" not found, did you mean to use it as a format specifier (e.g. {:" + name.to_string() + "}");
-  return arg;
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void advance_to(
-    basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
-  ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
-}
-
-template <typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler {
-  using range = typename ArgFormatter::range;
-
-  format_handler(range r, basic_string_view<Char> str,
-                 basic_format_args<Context> format_args,
-                 internal::locale_ref loc)
-      : parse_context(str), context(r.begin(), format_args, loc) {}
-
-  void on_text(const Char* begin, const Char* end) {
-    auto size = internal::to_unsigned(end - begin);
-    auto out = context.out();
-    auto&& it = internal::reserve(out, size);
-    it = std::copy_n(begin, size, it);
-    context.advance_to(out);
-  }
-
-  void get_arg(int id) { arg = internal::get_arg(context, id); }
-
-  void on_arg_id() { get_arg(parse_context.next_arg_id()); }
-  void on_arg_id(int id) {
-    parse_context.check_arg_id(id);
-    get_arg(id);
-  }
-  void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
-
-  void on_replacement_field(const Char* p) {
-    advance_to(parse_context, p);
-    context.advance_to(
-        visit_format_arg(ArgFormatter(context, &parse_context), arg));
-  }
-
-  const Char* on_format_specs(const Char* begin, const Char* end) {
-    advance_to(parse_context, begin);
-    internal::custom_formatter<Context> f(parse_context, context);
-    if (visit_format_arg(f, arg)) return parse_context.begin();
-    basic_format_specs<Char> specs;
-    using internal::specs_handler;
-    using parse_context_t = basic_format_parse_context<Char>;
-    internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
-        specs_handler<parse_context_t, Context>(specs, parse_context, context),
-        arg.type());
-    begin = parse_format_specs(begin, end, handler);
-    if (begin == end || *begin != '}') on_error("missing '}' in format string");
-    advance_to(parse_context, begin);
-    context.advance_to(
-        visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
-    return begin;
-  }
-
-  basic_format_parse_context<Char> parse_context;
-  Context context;
-  basic_format_arg<Context> arg;
-};
-
-/** Formats arguments and writes the output to the range. */
-template <typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator vformat_to(
-    typename ArgFormatter::range out, basic_string_view<Char> format_str,
-    basic_format_args<Context> args,
-    internal::locale_ref loc = internal::locale_ref()) {
-  format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
-  internal::parse_format_string<false>(format_str, h);
-  return h.context.out();
-}
-
-// Casts ``p`` to ``const void*`` for pointer formatting.
-// Example:
-//   auto s = format("{}", ptr(p));
-template <typename T> inline const void* ptr(const T* p) { return p; }
-template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
-  return p.get();
-}
-template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
-  return p.get();
-}
-
-template <typename It, typename Char> struct arg_join : internal::view {
-  It begin;
-  It end;
-  basic_string_view<Char> sep;
-
-  arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
-};
-
-template <typename It, typename Char>
-struct formatter<arg_join<It, Char>, Char>
-    : formatter<typename std::iterator_traits<It>::value_type, Char> {
-  template <typename FormatContext>
-  auto format(const arg_join<It, Char>& value, FormatContext& ctx)
-      -> decltype(ctx.out()) {
-    using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
-    auto it = value.begin;
-    auto out = ctx.out();
-    if (it != value.end) {
-      out = base::format(*it++, ctx);
-      while (it != value.end) {
-        out = std::copy(value.sep.begin(), value.sep.end(), out);
-        ctx.advance_to(out);
-        out = base::format(*it++, ctx);
-      }
-    }
-    return out;
-  }
-};
-
-/**
-  Returns an object that formats the iterator range `[begin, end)` with elements
-  separated by `sep`.
- */
-template <typename It>
-arg_join<It, char> join(It begin, It end, string_view sep) {
-  return {begin, end, sep};
-}
-
-template <typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
-  return {begin, end, sep};
-}
-
-/**
-  \rst
-  Returns an object that formats `range` with elements separated by `sep`.
-
-  **Example**::
-
-    std::vector<int> v = {1, 2, 3};
-    fmt::print("{}", fmt::join(v, ", "));
-    // Output: "1, 2, 3"
-  \endrst
- */
-template <typename Range>
-arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
-                                                       string_view sep) {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-template <typename Range>
-arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
-                                                          wstring_view sep) {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-/**
-  \rst
-  Converts *value* to ``std::string`` using the default format for type *T*.
-  It doesn't support user-defined types with custom formatters.
-
-  **Example**::
-
-    #include <fmt/format.h>
-
-    std::string answer = fmt::to_string(42);
-  \endrst
- */
-template <typename T> inline std::string to_string(const T& value) {
-  return format("{}", value);
-}
-
-/**
-  Converts *value* to ``std::wstring`` using the default format for type *T*.
- */
-template <typename T> inline std::wstring to_wstring(const T& value) {
-  return format(L"{}", value);
-}
-
-template <typename Char, std::size_t SIZE>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
-  return std::basic_string<Char>(buf.data(), buf.size());
-}
-
-template <typename Char>
-typename buffer_context<Char>::iterator internal::vformat_to(
-    internal::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
-  using range = buffer_range<Char>;
-  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
-                                          args);
-}
-
-template <typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline typename buffer_context<Char>::iterator vformat_to(
-    internal::buffer<Char>& buf, const S& format_str,
-    basic_format_args<buffer_context<Char>> args) {
-  return internal::vformat_to(buf, to_string_view(format_str), args);
-}
-
-template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline typename buffer_context<Char>::iterator format_to(
-    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
-  internal::check_format_string<Args...>(format_str);
-  using context = buffer_context<Char>;
-  return internal::vformat_to(buf, to_string_view(format_str),
-                              {make_format_args<context>(args...)});
-}
-
-template <typename OutputIt, typename Char = char>
-using format_context_t = basic_format_context<OutputIt, Char>;
-
-template <typename OutputIt, typename Char = char>
-using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-
-template <typename S, typename OutputIt, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
-inline OutputIt vformat_to(OutputIt out, const S& format_str,
-                           format_args_t<OutputIt, char_t<S>> args) {
-  using range = internal::output_range<OutputIt, char_t<S>>;
-  return vformat_to<arg_formatter<range>>(range(out),
-                                          to_string_view(format_str), args);
-}
-
-/**
- \rst
- Formats arguments, writes the result to the output iterator ``out`` and returns
- the iterator past the end of the output range.
-
- **Example**::
-
-   std::vector<char> out;
-   fmt::format_to(std::back_inserter(out), "{}", 42);
- \endrst
- */
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
-              internal::is_string<S>::value)>
-inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
-  internal::check_format_string<Args...>(format_str);
-  using context = format_context_t<OutputIt, char_t<S>>;
-  return vformat_to(out, to_string_view(format_str),
-                    {make_format_args<context>(args...)});
-}
-
-template <typename OutputIt> struct format_to_n_result {
-  /** Iterator past the end of the output range. */
-  OutputIt out;
-  /** Total (not truncated) output size. */
-  std::size_t size;
-};
-
-template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_context =
-    format_context_t<internal::truncating_iterator<OutputIt>, Char>;
-
-template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
-
-template <typename OutputIt, typename Char, typename... Args>
-inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
-make_format_to_n_args(const Args&... args) {
-  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
-      args...);
-}
-
-template <typename OutputIt, typename Char, typename... Args,
-          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> vformat_to_n(
-    OutputIt out, std::size_t n, basic_string_view<Char> format_str,
-    format_to_n_args<OutputIt, Char> args) {
-  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
-                       format_str, args);
-  return {it.base(), it.count()};
-}
-
-/**
- \rst
- Formats arguments, writes up to ``n`` characters of the result to the output
- iterator ``out`` and returns the total output size and the iterator past the
- end of the output range.
- \endrst
- */
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value&&
-                            internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
-                                                const S& format_str,
-                                                const Args&... args) {
-  internal::check_format_string<Args...>(format_str);
-  using context = format_to_n_context<OutputIt, char_t<S>>;
-  return vformat_to_n(out, n, to_string_view(format_str),
-                      {make_format_args<context>(args...)});
-}
-
-template <typename Char>
-inline std::basic_string<Char> internal::vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  internal::vformat_to(buffer, format_str, args);
-  return to_string(buffer);
-}
-
-/**
-  Returns the number of characters in the output of
-  ``format(format_str, args...)``.
- */
-template <typename... Args>
-inline std::size_t formatted_size(string_view format_str, const Args&... args) {
-  return format_to(internal::counting_iterator(), format_str, args...).count();
-}
-
-#if FMT_USE_USER_DEFINED_LITERALS
-namespace internal {
-
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS> class udl_formatter {
- public:
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-    FMT_CONSTEXPR_DECL bool invalid_format =
-        do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
-            basic_string_view<Char>(s, sizeof...(CHARS)));
-    (void)invalid_format;
-    return format(s, std::forward<Args>(args)...);
-  }
-};
-#  else
-template <typename Char> struct udl_formatter {
-  basic_string_view<Char> str;
-
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    return format(str, std::forward<Args>(args)...);
-  }
-};
-#  endif  // FMT_USE_UDL_TEMPLATE
-
-template <typename Char> struct udl_arg {
-  basic_string_view<Char> str;
-
-  template <typename T> named_arg<T, Char> operator=(T&& value) const {
-    return {str, std::forward<T>(value)};
-  }
-};
-
-}  // namespace internal
-
-inline namespace literals {
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
-  return {};
-}
-#  else
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::format`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    std::string message = "The answer is {}"_format(42);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
-                                                               std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
-    const wchar_t* s, std::size_t n) {
-  return {{s, n}};
-}
-#  endif  // FMT_USE_UDL_TEMPLATE
-
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::arg`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
-                                                    std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
-                                                       std::size_t n) {
-  return {{s, n}};
-}
-}  // namespace literals
-#endif  // FMT_USE_USER_DEFINED_LITERALS
-FMT_END_NAMESPACE
-
-#define FMT_STRING_IMPL(s, ...)                                         \
-  [] {                                                                  \
-    struct str : duckdb_fmt::compile_string {                                  \
-      using char_type = typename std::remove_cv<std::remove_pointer<    \
-          typename std::decay<decltype(s)>::type>::type>::type;         \
-      __VA_ARGS__ FMT_CONSTEXPR                                         \
-      operator duckdb_fmt::basic_string_view<char_type>() const {              \
-        return {s, sizeof(s) / sizeof(char_type) - 1};                  \
-      }                                                                 \
-    } result;                                                           \
-    /* Suppress Qt Creator warning about unused operator. */            \
-    (void)static_cast<duckdb_fmt::basic_string_view<typename str::char_type>>( \
-        result);                                                        \
-    return result;                                                      \
-  }()
-
-/**
-  \rst
-  Constructs a compile-time format string.
-
-  **Example**::
-
-    // A compile-time error because 'd' is an invalid specifier for strings.
-    std::string s = format(FMT_STRING("{:d}"), "foo");
-  \endrst
- */
-#define FMT_STRING(s) FMT_STRING_IMPL(s, )
-
-#if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
-#  define fmt(s) FMT_STRING_IMPL(s, [[deprecated]])
-#endif
-
-#ifdef FMT_HEADER_ONLY
-#  define FMT_FUNC inline
-// #  include "format-inl.h"
-#else
-#  define FMT_FUNC
-#endif
-
-#endif  // FMT_FORMAT_H_
diff --git a/src/duckdb/third_party/fmt/include/fmt/ostream.h b/src/duckdb/third_party/fmt/include/fmt/ostream.h
deleted file mode 100644
index 93ba11729..000000000
--- a/src/duckdb/third_party/fmt/include/fmt/ostream.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Formatting library for C++ - std::ostream support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-#include <ostream>
-#include "fmt/format.h"
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-template <class Char> class formatbuf : public std::basic_streambuf<Char> {
- private:
-  using int_type = typename std::basic_streambuf<Char>::int_type;
-  using traits_type = typename std::basic_streambuf<Char>::traits_type;
-
-  buffer<Char>& buffer_;
-
- public:
-  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
-
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
-  }
-
-  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
-template <typename Char> struct test_stream : std::basic_ostream<Char> {
- private:
-  // Hide all operator<< from std::basic_ostream<Char>.
-  void_t<> operator<<(null<>);
-  void_t<> operator<<(const Char*);
-
-  template <typename T, FMT_ENABLE_IF(std::is_convertible<T, int>::value &&
-                                      !std::is_enum<T>::value)>
-  void_t<> operator<<(T);
-};
-
-// Checks if T has a user-defined operator<< (e.g. not a member of
-// std::ostream).
-template <typename T, typename Char> class is_streamable {
- private:
-  template <typename U>
-  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
-                                              << std::declval<U>()),
-                                     void_t<>>::value>
-  test(int);
-
-  template <typename> static std::false_type test(...);
-
-  using result = decltype(test<T>(0));
-
- public:
-  static const bool value = result::value;
-};
-
-// Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char>& os, buffer<Char>& buf) {
-  const Char* buf_data = buf.data();
-  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
-  unsigned_streamsize size = buf.size();
-  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
-  do {
-    unsigned_streamsize n = size <= max_size ? size : max_size;
-    os.write(buf_data, static_cast<std::streamsize>(n));
-    buf_data += n;
-    size -= n;
-  } while (size != 0);
-}
-
-template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value,
-                  locale_ref loc = locale_ref()) {
-  formatbuf<Char> format_buf(buf);
-  std::basic_ostream<Char> output(&format_buf);
-  if (loc) output.imbue(loc.get<std::locale>());
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  output << value;
-  buf.resize(buf.size());
-}
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
-    : formatter<basic_string_view<Char>, Char> {
-  template <typename Context>
-  auto format(const T& value, Context& ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buffer;
-    format_value(buffer, value, ctx.locale());
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-  }
-};
-}  // namespace internal
-
-template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
-            basic_format_args<buffer_context<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  internal::vformat_to(buffer, format_str, args);
-  internal::write(os, buffer);
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
-  vprint(os, to_string_view(format_str),
-         {internal::make_args_checked<Args...>(format_str, args...)});
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_OSTREAM_H_
diff --git a/src/duckdb/third_party/fmt/include/fmt/printf.h b/src/duckdb/third_party/fmt/include/fmt/printf.h
deleted file mode 100644
index 6617d9d49..000000000
--- a/src/duckdb/third_party/fmt/include/fmt/printf.h
+++ /dev/null
@@ -1,729 +0,0 @@
-// Formatting library for C++ - legacy printf implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_PRINTF_H_
-#define FMT_PRINTF_H_
-
-#include <algorithm>  // std::max
-#include <limits>     // std::numeric_limits
-
-#include "fmt/ostream.h"
-
-#ifdef min
-#undef min
-#endif
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned> struct int_checker {
-  template <typename T> static bool fits_in_int(T value) {
-    unsigned max = max_value<int>();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
-};
-
-template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
-    return value >= std::numeric_limits<int>::min() &&
-           value <= max_value<int>();
-  }
-  static bool fits_in_int(int) { return true; }
-};
-
-class printf_precision_handler {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(duckdb::InvalidInputException("number is too big"));
-    return (std::max)(static_cast<int>(value), 0);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  int operator()(T) {
-    FMT_THROW(duckdb::InvalidInputException("precision is not integer"));
-    return 0;
-  }
-};
-
-// An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
-    return value == 0;
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
-    return false;
-  }
-};
-
-template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
-
-template <> struct make_unsigned_or_bool<bool> { using type = bool; };
-
-template <typename T, typename Context> class arg_converter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_arg<Context>& arg_;
-  char_type type_;
-
- public:
-  arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
-
-  void operator()(bool value) {
-    if (type_ != 's') operator()<bool>(value);
-  }
-
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
-    if (const_check(sizeof(target_type) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-            static_cast<int>(static_cast<target_type>(value)));
-      } else {
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        arg_ = internal::make_arg<Context>(
-            static_cast<unsigned>(static_cast<unsigned_type>(value)));
-      }
-    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
-      } else {
-        arg_ = internal::make_arg<Context>(
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
-      }
-    }
-  }
-
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
-};
-
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
-}
-
-// Converts an integer argument to char for printf.
-template <typename Context> class char_converter {
- private:
-  basic_format_arg<Context>& arg_;
-
- public:
-  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
-
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  void operator()(T value) {
-    arg_ = internal::make_arg<Context>(
-        static_cast<typename Context::char_type>(value));
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  void operator()(T) {}  // No conversion needed for non-integral types.
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-template <typename Char> class printf_width_handler {
- private:
-  using format_specs = basic_format_specs<Char>;
-
-  format_specs& specs_;
-
- public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
-
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(T value) {
-    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
-    if (internal::is_negative(value)) {
-      specs_.align = align::left;
-      width = 0 - width;
-    }
-    unsigned int_max = max_value<int>();
-    if (width > int_max) FMT_THROW(duckdb::InvalidInputException("number is too big"));
-    return static_cast<unsigned>(width);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  unsigned operator()(T) {
-    FMT_THROW(duckdb::InvalidInputException("width is not integer"));
-    return 0;
-  }
-};
-
-template <typename Char, typename Context>
-void printf(buffer<Char>& buf, basic_string_view<Char> format,
-            basic_format_args<Context> args) {
-  Context(std::back_inserter(buf), format, args).format();
-}
-
-template <typename OutputIt, typename Char, typename Context>
-internal::truncating_iterator<OutputIt> printf(
-    internal::truncating_iterator<OutputIt> it, basic_string_view<Char> format,
-    basic_format_args<Context> args) {
-  return Context(it, format, args).format();
-}
-}  // namespace internal
-
-using internal::printf;  // For printing into memory_buffer.
-
-template <typename Range> class printf_arg_formatter;
-
-template <typename OutputIt, typename Char> class basic_printf_context;
-
-/**
-  \rst
-  The ``printf`` argument formatter.
-  \endrst
- */
-template <typename Range>
-class printf_arg_formatter : public internal::arg_formatter_base<Range> {
- public:
-  using iterator = typename Range::iterator;
-
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
-  using context_type = basic_printf_context<iterator, char_type>;
-
-  context_type& context_;
-
-  void write_null_pointer(char) {
-    this->specs()->type = 0;
-    this->write("(nil)");
-  }
-
-  void write_null_pointer(wchar_t) {
-    this->specs()->type = 0;
-    this->write(L"(nil)");
-  }
-
- public:
-  using format_specs = typename base::format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *buffer* is a reference to the output buffer and *specs* contains format
-    specifier information for standard argument types.
-    \endrst
-   */
-  printf_arg_formatter(iterator iter, format_specs& specs, context_type& ctx)
-      : base(Range(iter), &specs, internal::locale_ref()), context_(ctx) {}
-
-  template <typename T, FMT_ENABLE_IF(duckdb_fmt::internal::is_integral<T>::value)>
-  iterator operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and char_type so
-    // use std::is_same instead.
-    if (std::is_same<T, bool>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
-      fmt_specs.type = 0;
-      this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type && fmt_specs.type != 'c')
-        return (*this)(static_cast<int>(value));
-      fmt_specs.sign = sign::none;
-      fmt_specs.alt = false;
-      fmt_specs.align = align::right;
-      return base::operator()(value);
-    } else {
-      return base::operator()(value);
-    }
-    return this->out();
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    return base::operator()(value);
-  }
-
-  /** Formats a null-terminated C string. */
-  iterator operator()(const char* value) {
-    if (value)
-      base::operator()(value);
-    else if (this->specs()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write("(null)");
-    return this->out();
-  }
-
-  /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t* value) {
-    if (value)
-      base::operator()(value);
-    else if (this->specs()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write(L"(null)");
-    return this->out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    return base::operator()(value);
-  }
-
-  iterator operator()(monostate value) { return base::operator()(value); }
-
-  /** Formats a pointer. */
-  iterator operator()(const void* value) {
-    if (value) return base::operator()(value);
-    this->specs()->type = 0;
-    write_null_pointer(char_type());
-    return this->out();
-  }
-
-  /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(context_.parse_context(), context_);
-    return this->out();
-  }
-};
-
-template <typename T> struct printf_formatter {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
-    internal::format_value(internal::get_container(ctx.out()), value);
-    return ctx.out();
-  }
-};
-
-/** This template formats data and writes the output to a writer. */
-template <typename OutputIt, typename Char> class basic_printf_context {
- public:
-  /** The character type for the output. */
-  using char_type = Char;
-  using format_arg = basic_format_arg<basic_printf_context>;
-  template <typename T> using formatter_type = printf_formatter<T>;
-
- private:
-  using format_specs = basic_format_specs<char_type>;
-
-  OutputIt out_;
-  basic_format_args<basic_printf_context> args_;
-  basic_format_parse_context<Char> parse_ctx_;
-
-  static void parse_flags(format_specs& specs, const Char*& it,
-                          const Char* end);
-
-  // Returns the argument with specified index or, if arg_index is -1, the next
-  // argument.
-  format_arg get_arg(int arg_index = -1);
-
-  // Parses argument index, flags and width and returns the argument index.
-  int parse_header(const Char*& it, const Char* end, format_specs& specs);
-
- public:
-  /**
-   \rst
-   Constructs a ``printf_context`` object. References to the arguments and
-   the writer are stored in the context object so make sure they have
-   appropriate lifetimes.
-   \endrst
-   */
-  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
-                       basic_format_args<basic_printf_context> args)
-      : out_(out), args_(args), parse_ctx_(format_str) {}
-
-  OutputIt out() { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
-
-  format_arg arg(int id) const { return args_.get(id); }
-
-  basic_format_parse_context<Char>& parse_context() { return parse_ctx_; }
-
-  FMT_CONSTEXPR void on_error(std::string message) {
-    parse_ctx_.on_error(message);
-  }
-
-  /** Formats stored arguments and writes the output to the range. */
-  template <typename ArgFormatter = printf_arg_formatter<buffer_range<Char>>>
-  OutputIt format();
-};
-
-template <typename OutputIt, typename Char>
-void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
-                                                       const Char*& it,
-                                                       const Char* end) {
-  for (; it != end; ++it) {
-    switch (*it) {
-    case '-':
-      specs.align = align::left;
-      break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill[0] = '0';
-      break;
-    case ' ':
-      specs.sign = sign::space;
-      break;
-    case '#':
-      specs.alt = true;
-      break;
-    case ',':
-      specs.thousands = ',';
-      break;
-    case '\'':
-      specs.thousands = '\'';
-      break;
-    case '_':
-      specs.thousands = '_';
-      break;
-    default:
-      return;
-    }
-  }
-}
-
-template <typename OutputIt, typename Char>
-typename basic_printf_context<OutputIt, Char>::format_arg
-basic_printf_context<OutputIt, Char>::get_arg(int arg_index) {
-  if (arg_index < 0)
-    arg_index = parse_ctx_.next_arg_id();
-  else
-    parse_ctx_.check_arg_id(--arg_index);
-  return internal::get_arg(*this, arg_index);
-}
-
-template <typename OutputIt, typename Char>
-int basic_printf_context<OutputIt, Char>::parse_header(
-    const Char*& it, const Char* end, format_specs& specs) {
-  int arg_index = -1;
-  char_type c = *it;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    internal::error_handler eh;
-    int value = parse_nonnegative_int(it, end, eh);
-    if (it != end && *it == '$') {  // value is an argument index
-      ++it;
-      arg_index = value;
-    } else {
-      if (c == '0') specs.fill[0] = '0';
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        specs.width = value;
-        return arg_index;
-      }
-    }
-  }
-  parse_flags(specs, it, end);
-  // Parse width.
-  if (it != end) {
-    if (*it >= '0' && *it <= '9') {
-      internal::error_handler eh;
-      specs.width = parse_nonnegative_int(it, end, eh);
-    } else if (*it == '*') {
-      ++it;
-      specs.width = static_cast<int>(visit_format_arg(
-          internal::printf_width_handler<char_type>(specs), get_arg()));
-    }
-  }
-  return arg_index;
-}
-
-template <typename OutputIt, typename Char>
-template <typename ArgFormatter>
-OutputIt basic_printf_context<OutputIt, Char>::format() {
-  auto out = this->out();
-  const Char* start = parse_ctx_.begin();
-  const Char* end = parse_ctx_.end();
-  auto it = start;
-  while (it != end) {
-    char_type c = *it++;
-    if (c != '%') continue;
-    if (it != end && *it == c) {
-      out = std::copy(start, it, out);
-      start = ++it;
-      continue;
-    }
-    out = std::copy(start, it - 1, out);
-
-    format_specs specs;
-    specs.align = align::right;
-
-    // Parse argument index, flags and width.
-    int arg_index = parse_header(it, end, specs);
-    if (arg_index == 0) on_error("argument index out of range");
-
-    // Parse precision.
-	bool empty_precision = false;
-    if (it != end && *it == '.') {
-      ++it;
-      c = it != end ? *it : 0;
-      if ('0' <= c && c <= '9') {
-        internal::error_handler eh;
-        specs.precision = parse_nonnegative_int(it, end, eh);
-      } else if (c == '*') {
-        ++it;
-        specs.precision =
-            static_cast<int>(visit_format_arg(internal::printf_precision_handler(), get_arg()));
-      } else {
-        specs.precision = 0;
-		empty_precision = true;
-      }
-    }
-
-    format_arg arg = get_arg(arg_index);
-    if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
-      specs.alt = false;
-    if (specs.fill[0] == '0') {
-      if (arg.is_arithmetic())
-        specs.align = align::numeric;
-      else
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types.
-    }
-
-    // Parse length and convert the argument to the required type.
-    c = it != end ? *it++ : 0;
-    char_type t = it != end ? *it : 0;
-    using internal::convert_arg;
-    switch (c) {
-    case 'h':
-      if (t == 'h') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<signed char>(arg, t);
-      } else {
-        convert_arg<short>(arg, t);
-      }
-      break;
-    case 'l':
-      if (t == 'l') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<long long>(arg, t);
-      } else {
-        convert_arg<long>(arg, t);
-      }
-      break;
-    case 'j':
-      convert_arg<intmax_t>(arg, t);
-      break;
-    case 'z':
-      convert_arg<std::size_t>(arg, t);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(arg, t);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --it;
-      convert_arg<void>(arg, c);
-    }
-
-    // Parse type.
-    if (it == end) FMT_THROW(duckdb::InvalidInputException("invalid format string"));
-    specs.type = static_cast<char>(*it++);
-    if (arg.is_integral()) {
-      // Normalize type.
-      switch (specs.type) {
-      case 'i':
-      case 'u':
-        specs.type = 'd';
-        break;
-      case 'c':
-        visit_format_arg(internal::char_converter<basic_printf_context>(arg),
-                         arg);
-        break;
-      }
-    }
-	if (specs.type == 'd' && empty_precision) {
-		specs.thousands = '.';
-	}
-
-    start = it;
-
-    // Format argument.
-    visit_format_arg(ArgFormatter(out, specs, *this), arg);
-  }
-  return std::copy(start, it, out);
-}
-
-template <typename Char>
-using basic_printf_context_t =
-    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>,
-                         Char>;
-
-using printf_context = basic_printf_context_t<char>;
-using wprintf_context = basic_printf_context_t<wchar_t>;
-
-using printf_args = basic_format_args<printf_context>;
-using wprintf_args = basic_format_args<wprintf_context>;
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::printf_args`.
-  \endrst
- */
-template <typename... Args>
-inline format_arg_store<printf_context, Args...> make_printf_args(
-    const Args&... args) {
-  return {args...};
-}
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::wprintf_args`.
-  \endrst
- */
-template <typename... Args>
-inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
-    const Args&... args) {
-  return {args...};
-}
-
-template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vsprintf(
-    const S& format, basic_format_args<basic_printf_context_t<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  return to_string(buffer);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
-*/
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vsprintf(to_string_view(format), {make_format_args<context>(args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::FILE* f, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  std::size_t size = buffer.size();
-  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
-             ? -1
-             : static_cast<int>(size);
-}
-
-/**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    fmt::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(format),
-                  {make_format_args<context>(args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline int vprintf(const S& format,
-                   basic_format_args<basic_printf_context_t<Char>> args) {
-  return vfprintf(stdout, to_string_view(format), args);
-}
-
-/**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
- */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline int printf(const S& format_str, const Args&... args) {
-  using context = basic_printf_context_t<char_t<S>>;
-  return vprintf(to_string_view(format_str),
-                 {make_format_args<context>(args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::basic_ostream<Char>& os, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  internal::write(os, buffer);
-  return static_cast<int>(buffer.size());
-}
-
-/** Formats arguments and writes the output to the range. */
-template <typename ArgFormatter, typename Char,
-          typename Context =
-              basic_printf_context<typename ArgFormatter::iterator, Char>>
-typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
-                                        basic_string_view<Char> format_str,
-                                        basic_format_args<Context> args) {
-  typename ArgFormatter::iterator iter(out);
-  Context(iter, format_str, args).template format<ArgFormatter>();
-  return iter;
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
-                   const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vfprintf(os, to_string_view(format_str),
-                  {make_format_args<context>(args...)});
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_PRINTF_H_
diff --git a/src/duckdb/third_party/fsst/fsst.h b/src/duckdb/third_party/fsst/fsst.h
deleted file mode 100644
index 04214d13a..000000000
--- a/src/duckdb/third_party/fsst/fsst.h
+++ /dev/null
@@ -1,246 +0,0 @@
-/* 
- * the API for FSST compression -- (c) Peter Boncz, Viktor Leis and Thomas Neumann (CWI, TU Munich), 2018-2019
- *
- * ===================================================================================================================================
- * this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
- *
- * Copyright 2018-2020, CWI, TU Munich, FSU Jena
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files 
- * (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, 
- * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is 
- * furnished to do so, subject to the following conditions:
- *
- * - The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 
- * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
- * ===================================================================================================================================
- *
- * FSST: Fast Static Symbol Table compression 
- * see the paper https://github.com/cwida/fsst/raw/master/fsstcompression.pdf
- *
- * FSST is a compression scheme focused on string/text data: it can compress strings from distributions with many different values (i.e.
- * where dictionary compression will not work well). It allows *random-access* to compressed data: it is not block-based, so individual
- * strings can be decompressed without touching the surrounding data in a compressed block. When compared to e.g. lz4 (which is 
- * block-based), FSST achieves similar decompression speed, (2x) better compression speed and 30% better compression ratio on text.
- *
- * FSST encodes strings also using a symbol table -- but it works on pieces of the string, as it maps "symbols" (1-8 byte sequences) 
- * onto "codes" (single-bytes). FSST can also represent a byte as an exception (255 followed by the original byte). Hence, compression 
- * transforms a sequence of bytes into a (supposedly shorter) sequence of codes or escaped bytes. These shorter byte-sequences could 
- * be seen as strings again and fit in whatever your program is that manipulates strings.
- *
- * useful property: FSST ensures that strings that are equal, are also equal in their compressed form.
- * 
- * In this API, strings are considered byte-arrays (byte = unsigned char) and a batch of strings is represented as an array of 
- * unsigned char* pointers to their starts. A seperate length array (of unsigned int) denotes how many bytes each string consists of. 
- *
- * This representation as unsigned char* pointers tries to assume as little as possible on the memory management of the program
- * that calls this API, and is also intended to allow passing strings into this API without copying (even if you use C++ strings).
- *
- * We optionally support C-style zero-terminated strings (zero appearing only at the end). In this case, the compressed strings are 
- * also zero-terminated strings. In zero-terminated mode, the zero-byte at the end *is* counted in the string byte-length.
- */
-#ifndef FSST_INCLUDED_H
-#define FSST_INCLUDED_H
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define __restrict__ 
-#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
-#define __ORDER_LITTLE_ENDIAN__ 2
-#include <intrin.h>
-static inline int __builtin_ctzll(unsigned long long x) {
-#  ifdef _WIN64
-	unsigned long ret;
-    _BitScanForward64(&ret, x);
-	return (int)ret;
-#  else
-	unsigned long low, high;
-	bool low_set = _BitScanForward(&low, (unsigned __int32)(x)) != 0;
-	_BitScanForward(&high, (unsigned __int32)(x >> 32));
-	high += 32;
-	return low_set ? low : high;
-#  endif
-}
-#endif
-
-#ifdef __cplusplus
-#define FSST_FALLTHROUGH [[fallthrough]]
-#include <cstring>
-extern "C" {
-#else
-#define FSST_FALLTHROUGH 
-#endif
-
-#ifndef __has_cpp_attribute // For backwards compatibility
-#define __has_cpp_attribute(x) 0
-#endif
-#if __has_cpp_attribute(clang::fallthrough)
-#define DUCKDB_FSST_EXPLICIT_FALLTHROUGH [[clang::fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define DUCKDB_FSST_EXPLICIT_FALLTHROUGH [[gnu::fallthrough]]
-#else
-#define DUCKDB_FSST_EXPLICIT_FALLTHROUGH
-#endif
-
-#include <stddef.h>
-
-/* A compressed string is simply a string of 1-byte codes; except for code 255, which is followed by an uncompressed byte. */
-#define FSST_ESC 255
-
-/* Data structure needed for compressing strings - use duckdb_fsst_duplicate() to create thread-local copies. Use duckdb_fsst_destroy() to free. */
-typedef void* duckdb_fsst_encoder_t; /* opaque type - it wraps around a rather large (~900KB) C++ object */
-
-/* Data structure needed for decompressing strings - read-only and thus can be shared between multiple decompressing threads. */
-typedef struct {
-   unsigned long long version;     /* version id */
-   unsigned char zeroTerminated;   /* terminator is a single-byte code that does not appear in longer symbols */
-   unsigned char len[255];         /* len[x] is the byte-length of the symbol x (1 < len[x] <= 8). */
-   unsigned long long symbol[255]; /* symbol[x] contains in LITTLE_ENDIAN the bytesequence that code x represents (0 <= x < 255). */ 
-} duckdb_fsst_decoder_t;
-
-/* Calibrate a FSST symboltable from a batch of strings (it is best to provide at least 16KB of data). */
-duckdb_fsst_encoder_t*
-duckdb_fsst_create(
-   size_t n,         /* IN: number of strings in batch to sample from. */
-   size_t lenIn[],   /* IN: byte-lengths of the inputs */
-   unsigned char *strIn[],  /* IN: string start pointers. */
-   int zeroTerminated       /* IN: whether input strings are zero-terminated. If so, encoded strings are as well (i.e. symbol[0]=""). */
-);
-
-/* Create another encoder instance, necessary to do multi-threaded encoding using the same symbol table. */ 
-duckdb_fsst_encoder_t*
-duckdb_fsst_duplicate(
-   duckdb_fsst_encoder_t *encoder  /* IN: the symbol table to duplicate. */
-);
-
-#define FSST_MAXHEADER (8+1+8+2048+1) /* maxlen of deserialized fsst header, produced/consumed by duckdb_fsst_export() resp. duckdb_fsst_import() */
-
-/* Space-efficient symbol table serialization (smaller than sizeof(duckdb_fsst_decoder_t) - by saving on the unused bytes in symbols of len < 8). */
-unsigned int                /* OUT: number of bytes written in buf, at most sizeof(duckdb_fsst_decoder_t) */
-duckdb_fsst_export(
-   duckdb_fsst_encoder_t *encoder, /* IN: the symbol table to dump. */
-   unsigned char *buf       /* OUT: pointer to a byte-buffer where to serialize this symbol table. */
-); 
-
-/* Deallocate encoder. */
-void
-duckdb_fsst_destroy(duckdb_fsst_encoder_t*);
-
-/* Return a decoder structure from serialized format (typically used in a block-, file- or row-group header). */
-unsigned int                /* OUT: number of bytes consumed in buf (0 on failure). */
-duckdb_fsst_import(
-   duckdb_fsst_decoder_t *decoder, /* IN: this symbol table will be overwritten. */
-   unsigned char *buf       /* OUT: pointer to a byte-buffer where duckdb_fsst_export() serialized this symbol table. */
-); 
-
-/* Return a decoder structure from an encoder. */
-duckdb_fsst_decoder_t
-duckdb_fsst_decoder(
-   duckdb_fsst_encoder_t *encoder
-);
-
-/* Compress a batch of strings (on AVX512 machines best performance is obtained by compressing more than 32KB of string volume). */
-/* The output buffer must be large; at least "conservative space" (7+2*inputlength) for the first string for something to happen. */
-size_t                      /* OUT: the number of compressed strings (<=n) that fit the output buffer. */ 
-duckdb_fsst_compress(
-   duckdb_fsst_encoder_t *encoder, /* IN: encoder obtained from duckdb_fsst_create(). */
-   size_t nstrings,         /* IN: number of strings in batch to compress. */
-   size_t lenIn[],          /* IN: byte-lengths of the inputs */
-   unsigned char *strIn[],  /* IN: input string start pointers. */
-   size_t outsize,          /* IN: byte-length of output buffer. */
-   unsigned char *output,   /* OUT: memory buffer to put the compressed strings in (one after the other). */
-   size_t lenOut[],         /* OUT: byte-lengths of the compressed strings. */
-   unsigned char *strOut[]  /* OUT: output string start pointers. Will all point into [output,output+size). */
-);
-
-/* Decompress a single string, inlined for speed. */
-inline size_t /* OUT: bytesize of the decompressed string. If > size, the decoded output is truncated to size. */
-duckdb_fsst_decompress(
-   duckdb_fsst_decoder_t *decoder,  /* IN: use this symbol table for compression. */
-   size_t lenIn,             /* IN: byte-length of compressed string. */
-   unsigned char *strIn,     /* IN: compressed string. */
-   size_t size,              /* IN: byte-length of output buffer. */
-   unsigned char *output     /* OUT: memory buffer to put the decompressed string in. */
-) {
-   unsigned char*__restrict__ len = (unsigned char* __restrict__) decoder->len;
-   unsigned char*__restrict__ strOut = (unsigned char* __restrict__) output;
-   unsigned long long*__restrict__ symbol = (unsigned long long* __restrict__) decoder->symbol; 
-   size_t code, posOut = 0, posIn = 0;
-#ifndef FSST_MUST_ALIGN /* defining on platforms that require aligned memory access may help their performance */
-#define FSST_UNALIGNED_STORE(dst,src) memcpy((unsigned long long*) (dst), &(src), sizeof(unsigned long long))
-#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-   while (posOut+32 <= size && posIn+4 <= lenIn) {
-      unsigned int nextBlock, escapeMask;
-      memcpy(&nextBlock, strIn+posIn, sizeof(unsigned int));
-      escapeMask = (nextBlock&0x80808080u)&((((~nextBlock)&0x7F7F7F7Fu)+0x7F7F7F7Fu)^0x80808080u);
-      if (escapeMask == 0) {
-         code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
-         code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
-         code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
-         code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
-     } else { 
-         unsigned long firstEscapePos=static_cast<unsigned long>(__builtin_ctzll((unsigned long long) escapeMask)>>3);
-         switch(firstEscapePos) { /* Duff's device */
-         case 3: code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code];
-			 DUCKDB_FSST_EXPLICIT_FALLTHROUGH;
-         case 2: code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code];
-			 DUCKDB_FSST_EXPLICIT_FALLTHROUGH;
-         case 1: code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code];
-			 DUCKDB_FSST_EXPLICIT_FALLTHROUGH;
-         case 0: posIn+=2; strOut[posOut++] = strIn[posIn-1]; /* decompress an escaped byte */
-         }
-      }
-   }
-   if (posOut+24 <= size) { // handle the possibly 3 last bytes without a loop
-      if (posIn+2 <= lenIn) { 
-	 strOut[posOut] = strIn[posIn+1]; 
-         if (strIn[posIn] != FSST_ESC) {
-            code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
-            if (strIn[posIn] != FSST_ESC) {
-               code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
-            } else { 
-               posIn += 2; strOut[posOut++] = strIn[posIn-1]; 
-            }
-         } else {
-            posIn += 2; posOut++; 
-         } 
-      }
-      if (posIn < lenIn) { // last code cannot be an escape
-         code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code];
-      }
-   }
-#else
-   while (posOut+8 <= size && posIn < lenIn)
-      if ((code = strIn[posIn++]) < FSST_ESC) { /* symbol compressed as code? */
-         FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); /* unaligned memory write */
-         posOut += len[code];
-      } else { 
-         strOut[posOut] = strIn[posIn]; /* decompress an escaped byte */
-         posIn++; posOut++; 
-      }
-#endif
-#endif
-   while (posIn < lenIn)
-      if ((code = strIn[posIn++]) < FSST_ESC) {
-         size_t posWrite = posOut, endWrite = posOut + len[code];
-         unsigned char* __restrict__ symbolPointer = ((unsigned char* __restrict__) &symbol[code]) - posWrite;
-         if ((posOut = endWrite) > size) endWrite = size;
-         for(; posWrite < endWrite; posWrite++)  /* only write if there is room */
-            strOut[posWrite] = symbolPointer[posWrite];
-      } else {
-         if (posOut < size) strOut[posOut] = strIn[posIn]; /* idem */
-         posIn++; posOut++; 
-      } 
-   if (posOut >= size && (decoder->zeroTerminated&1)) strOut[size-1] = 0;
-   return posOut; /* full size of decompressed string (could be >size, then the actually decompressed part) */
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* FSST_INCLUDED_H */
diff --git a/src/duckdb/third_party/fsst/libfsst.cpp b/src/duckdb/third_party/fsst/libfsst.cpp
deleted file mode 100644
index 802aff55d..000000000
--- a/src/duckdb/third_party/fsst/libfsst.cpp
+++ /dev/null
@@ -1,506 +0,0 @@
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-//
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
-// (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
-// merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// - The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
-#include "libfsst.hpp"
-
-Symbol concat(Symbol a, Symbol b) {
-	Symbol s;
-	u32 length = a.length()+b.length();
-	if (length > Symbol::maxLength) length = Symbol::maxLength;
-	s.set_code_len(FSST_CODE_MASK, length);
-	s.val.num = (b.val.num << (8*a.length())) | a.val.num;
-	return s;
-}
-
-namespace std {
-template <>
-class hash<QSymbol> {
-public:
-	size_t operator()(const QSymbol& q) const {
-		uint64_t k = q.symbol.val.num;
-		const uint64_t m = 0xc6a4a7935bd1e995;
-		const int r = 47;
-		uint64_t h = 0x8445d61a4e774912 ^ (8*m);
-		k *= m;
-		k ^= k >> r;
-		k *= m;
-		h ^= k;
-		h *= m;
-		h ^= h >> r;
-		h *= m;
-		h ^= h >> r;
-		return h;
-	}
-};
-}
-
-bool isEscapeCode(u16 pos) { return pos < FSST_CODE_BASE; }
-
-std::ostream& operator<<(std::ostream& out, const Symbol& s) {
-	for (u32 i=0; i<s.length(); i++)
-		out << s.val.str[i];
-	return out;
-}
-
-SymbolTable *buildSymbolTable(Counters& counters, vector<u8*> line, size_t len[], bool zeroTerminated=false) {
-	SymbolTable *st = new SymbolTable(), *bestTable = new SymbolTable();
-	int bestGain = (int) -FSST_SAMPLEMAXSZ; // worst case (everything exception)
-	size_t sampleFrac = 128;
-
-	// start by determining the terminator. We use the (lowest) most infrequent byte as terminator
-	st->zeroTerminated = zeroTerminated;
-	if (zeroTerminated) {
-		st->terminator = 0; // except in case of zeroTerminated mode, then byte 0 is terminator regardless frequency
-	} else {
-		u16 byteHisto[256];
-		memset(byteHisto, 0, sizeof(byteHisto));
-		for(size_t i=0; i<line.size(); i++) {
-			u8* cur = line[i];
-			u8* end = cur + len[i];
-			while(cur < end) byteHisto[*cur++]++;
-		}
-		u32 minSize = FSST_SAMPLEMAXSZ, i = st->terminator = 256;
-		while(i-- > 0) {
-			if (byteHisto[i] > minSize) continue;
-			st->terminator = i;
-			minSize = byteHisto[i];
-		}
-	}
-	assert(st->terminator != 256);
-
-	// a random number between 0 and 128
-	auto rnd128 = [&](size_t i) { return 1 + (FSST_HASH((i+1UL)*sampleFrac)&127); };
-
-	// compress sample, and compute (pair-)frequencies
-	auto compressCount = [&](SymbolTable *st, Counters &counters) { // returns gain
-		int gain = 0;
-
-		for(size_t i=0; i<line.size(); i++) {
-			u8* cur = line[i];
-			u8* end = cur + len[i];
-
-			if (sampleFrac < 128) {
-				// in earlier rounds (sampleFrac < 128) we skip data in the sample (reduces overall work ~2x)
-				if (rnd128(i) > sampleFrac) continue;
-			}
-			if (cur < end) {
-				u8* start = cur;
-				u16 code2 = 255, code1 = st->findLongestSymbol(cur, end);
-				cur += st->symbols[code1].length();
-				gain += (int) (st->symbols[code1].length()-(1+isEscapeCode(code1)));
-				while (true) {
-					// count single symbol (i.e. an option is not extending it)
-					counters.count1Inc(code1);
-
-					// as an alternative, consider just using the next byte..
-					if (st->symbols[code1].length() != 1) // .. but do not count single byte symbols doubly
-						counters.count1Inc(*start);
-
-					if (cur==end) {
-						break;
-					}
-
-					// now match a new symbol
-					start = cur;
-					if (cur<end-7) {
-						u64 word = fsst_unaligned_load(cur);
-						size_t code = word & 0xFFFFFF;
-						size_t idx = FSST_HASH(code)&(st->hashTabSize-1);
-						Symbol s = st->hashTab[idx];
-						code2 = st->shortCodes[word & 0xFFFF] & FSST_CODE_MASK;
-						word &= (0xFFFFFFFFFFFFFFFF >> (u8) s.icl);
-						if ((s.icl < FSST_ICL_FREE) & (s.val.num == word)) {
-							code2 = s.code();
-							cur += s.length();
-						} else if (code2 >= FSST_CODE_BASE) {
-							cur += 2;
-						} else {
-							code2 = st->byteCodes[word & 0xFF] & FSST_CODE_MASK;
-							cur += 1;
-						}
-					} else {
-						code2 = st->findLongestSymbol(cur, end);
-						cur += st->symbols[code2].length();
-					}
-
-					// compute compressed output size
-					gain += ((int) (cur-start))-(1+isEscapeCode(code2));
-
-					// now count the subsequent two symbols we encode as an extension codesibility
-					if (sampleFrac < 128) { // no need to count pairs in final round
-						                    // consider the symbol that is the concatenation of the two last symbols
-						counters.count2Inc(code1, code2);
-
-						// as an alternative, consider just extending with the next byte..
-						if ((cur-start) > 1)  // ..but do not count single byte extensions doubly
-							counters.count2Inc(code1, *start);
-					}
-					code1 = code2;
-				}
-			}
-		}
-		return gain;
-	};
-
-	auto makeTable = [&](SymbolTable *st, Counters &counters) {
-		// hashmap of c (needed because we can generate duplicate candidates)
-		unordered_set<QSymbol> cands;
-
-		// artificially make terminater the most frequent symbol so it gets included
-		u16 terminator = st->nSymbols?FSST_CODE_BASE:st->terminator;
-		counters.count1Set(terminator,65535);
-
-		auto addOrInc = [&](unordered_set<QSymbol> &cands, Symbol s, u64 count) {
-			if (count < (5*sampleFrac)/128) return; // improves both compression speed (less candidates), but also quality!!
-			QSymbol q;
-			q.symbol = s;
-			q.gain = count * s.length();
-			auto it = cands.find(q);
-			if (it != cands.end()) {
-				q.gain += (*it).gain;
-				cands.erase(*it);
-			}
-			cands.insert(q);
-		};
-
-		// add candidate symbols based on counted frequency
-		for (u32 pos1=0; pos1<FSST_CODE_BASE+(size_t) st->nSymbols; pos1++) {
-			u32 cnt1 = counters.count1GetNext(pos1); // may advance pos1!!
-			if (!cnt1) continue;
-
-			// heuristic: promoting single-byte symbols (*8) helps reduce exception rates and increases [de]compression speed
-			Symbol s1 = st->symbols[pos1];
-			addOrInc(cands, s1, ((s1.length()==1)?8LL:1LL)*cnt1);
-
-			if (sampleFrac >= 128 || // last round we do not create new (combined) symbols
-			    s1.length() == Symbol::maxLength || // symbol cannot be extended
-			    s1.val.str[0] == st->terminator) { // multi-byte symbols cannot contain the terminator byte
-				continue;
-			}
-			for (u32 pos2=0; pos2<FSST_CODE_BASE+(size_t)st->nSymbols; pos2++) {
-				u32 cnt2 = counters.count2GetNext(pos1, pos2); // may advance pos2!!
-				if (!cnt2) continue;
-
-				// create a new symbol
-				Symbol s2 = st->symbols[pos2];
-				Symbol s3 = concat(s1, s2);
-				if (s2.val.str[0] != st->terminator) // multi-byte symbols cannot contain the terminator byte
-					addOrInc(cands, s3, cnt2);
-			}
-		}
-
-		// insert candidates into priority queue (by gain)
-		auto cmpGn = [](const QSymbol& q1, const QSymbol& q2) { return (q1.gain < q2.gain) || (q1.gain == q2.gain && q1.symbol.val.num > q2.symbol.val.num); };
-		priority_queue<QSymbol,vector<QSymbol>,decltype(cmpGn)> pq(cmpGn);
-		for (auto& q : cands)
-			pq.push(q);
-
-		// Create new symbol map using best candidates
-		st->clear();
-		while (st->nSymbols < 255 && !pq.empty()) {
-			QSymbol q = pq.top();
-			pq.pop();
-			st->add(q.symbol);
-		}
-	};
-
-	u8 bestCounters[512*sizeof(u16)];
-#ifdef NONOPT_FSST
-	for(size_t frac : {127, 127, 127, 127, 127, 127, 127, 127, 127, 128}) {
-		sampleFrac = frac;
-#else
-	for(sampleFrac=8; true; sampleFrac += 30) {
-#endif
-		memset(&counters, 0, sizeof(Counters));
-		long gain = compressCount(st, counters);
-		if (gain >= bestGain) { // a new best solution!
-			counters.backup1(bestCounters);
-			*bestTable = *st; bestGain = gain;
-		}
-		if (sampleFrac >= 128) break; // we do 5 rounds (sampleFrac=8,38,68,98,128)
-		makeTable(st, counters);
-	}
-	delete st;
-	counters.restore1(bestCounters);
-	makeTable(bestTable, counters);
-	bestTable->finalize(zeroTerminated); // renumber codes for more efficient compression
-	return bestTable;
-}
-
-// optimized adaptive *scalar* compression method
-static inline size_t compressBulk(SymbolTable &symbolTable, size_t nlines, size_t lenIn[], u8* strIn[], size_t size, u8* out, size_t lenOut[], u8* strOut[], bool noSuffixOpt, bool avoidBranch) {
-	u8 *cur = NULL, *end =  NULL, *lim = out + size;
-	size_t curLine, suffixLim = symbolTable.suffixLim;
-	u8 byteLim = symbolTable.nSymbols + symbolTable.zeroTerminated - symbolTable.lenHisto[0];
-
-	u8 buf[512+7] = {}; /* +7 sentinel is to avoid 8-byte unaligned-loads going beyond 511 out-of-bounds */
-
-	// three variants are possible. dead code falls away since the bool arguments are constants
-	auto compressVariant = [&](bool noSuffixOpt, bool avoidBranch) {
-		while (cur < end) {
-			u64 word = fsst_unaligned_load(cur);
-			size_t code = symbolTable.shortCodes[word & 0xFFFF];
-			if (noSuffixOpt && ((u8) code) < suffixLim) {
-				// 2 byte code without having to worry about longer matches
-				*out++ = (u8) code; cur += 2;
-			} else {
-				size_t pos = word & 0xFFFFFF;
-				size_t idx = FSST_HASH(pos)&(symbolTable.hashTabSize-1);
-				Symbol s = symbolTable.hashTab[idx];
-				out[1] = (u8) word; // speculatively write out escaped byte
-				word &= (0xFFFFFFFFFFFFFFFF >> (u8) s.icl);
-				if ((s.icl < FSST_ICL_FREE) && s.val.num == word) {
-					*out++ = (u8) s.code(); cur += s.length();
-				} else if (avoidBranch) {
-					// could be a 2-byte or 1-byte code, or miss
-					// handle everything with predication
-					*out = (u8) code;
-					out += 1+((code&FSST_CODE_BASE)>>8);
-					cur += (code>>FSST_LEN_BITS);
-				} else if ((u8) code < byteLim) {
-					// 2 byte code after checking there is no longer pattern
-					*out++ = (u8) code; cur += 2;
-				} else {
-					// 1 byte code or miss.
-					*out = (u8) code;
-					out += 1+((code&FSST_CODE_BASE)>>8); // predicated - tested with a branch, that was always worse
-					cur++;
-				}
-			}
-		}
-	};
-
-	for(curLine=0; curLine<nlines; curLine++) {
-		size_t chunk, curOff = 0;
-		strOut[curLine] = out;
-		do {
-			cur = strIn[curLine] + curOff;
-			chunk = lenIn[curLine] - curOff;
-			if (chunk > 511) {
-				chunk = 511; // we need to compress in chunks of 511 in order to be byte-compatible with simd-compressed FSST
-			}
-			if ((2*chunk+7) > (size_t) (lim-out)) {
-				return curLine; // out of memory
-			}
-			// copy the string to the 511-byte buffer
-			memcpy(buf, cur, chunk);
-			buf[chunk] = (u8) symbolTable.terminator;
-			cur = buf;
-			end = cur + chunk;
-
-			// based on symboltable stats, choose a variant that is nice to the branch predictor
-			if (noSuffixOpt) {
-				compressVariant(true,false);
-			} else if (avoidBranch) {
-				compressVariant(false,true);
-			} else {
-				compressVariant(false, false);
-			}
-		} while((curOff += chunk) < lenIn[curLine]);
-		lenOut[curLine] = (size_t) (out - strOut[curLine]);
-	}
-	return curLine;
-}
-
-#define FSST_SAMPLELINE ((size_t) 512)
-
-// quickly select a uniformly random set of lines such that we have between [FSST_SAMPLETARGET,FSST_SAMPLEMAXSZ) string bytes
-vector<u8*> makeSample(u8* sampleBuf, u8* strIn[], size_t *lenIn, size_t nlines,
-                                                    unique_ptr<vector<size_t>>& sample_len_out) {
-	size_t totSize = 0;
-	vector<u8*> sample;
-
-	for(size_t i=0; i<nlines; i++)
-		totSize += lenIn[i];
-	if (totSize < FSST_SAMPLETARGET) {
-		for(size_t i=0; i<nlines; i++)
-			sample.push_back(strIn[i]);
-	} else {
-		size_t sampleRnd = FSST_HASH(4637947);
-		u8* sampleLim = sampleBuf + FSST_SAMPLETARGET;
-
-		sample_len_out = unique_ptr<vector<size_t>>(new vector<size_t>());
-		sample_len_out->reserve(nlines + FSST_SAMPLEMAXSZ/FSST_SAMPLELINE);
-
-		// This fails if we have a lot of small strings and a few big ones?
-		while(sampleBuf < sampleLim) {
-			// choose a non-empty line
-			sampleRnd = FSST_HASH(sampleRnd);
-			size_t linenr = sampleRnd % nlines;
-			while (lenIn[linenr] == 0)
-				if (++linenr == nlines) linenr = 0;
-
-			// choose a chunk
-			size_t chunks = 1 + ((lenIn[linenr]-1) / FSST_SAMPLELINE);
-			sampleRnd = FSST_HASH(sampleRnd);
-			size_t chunk = FSST_SAMPLELINE*(sampleRnd % chunks);
-
-			// add the chunk to the sample
-			size_t len = min(lenIn[linenr]-chunk,FSST_SAMPLELINE);
-			memcpy(sampleBuf, strIn[linenr]+chunk, len);
-			sample.push_back(sampleBuf);
-
-			sample_len_out->push_back(len);
-			sampleBuf += len;
-		}
-	}
-	return sample;
-}
-
-extern "C" duckdb_fsst_encoder_t* duckdb_fsst_create(size_t n, size_t lenIn[], u8 *strIn[], int zeroTerminated) {
-	u8* sampleBuf = new u8[FSST_SAMPLEMAXSZ];
-	unique_ptr<vector<size_t>> sample_sizes;
-	vector<u8*> sample = makeSample(sampleBuf, strIn, lenIn, n?n:1, sample_sizes); // careful handling of input to get a right-size and representative sample
-	Encoder *encoder = new Encoder();
-	size_t* sampleLen = sample_sizes ? sample_sizes->data() : &lenIn[0];
-	encoder->symbolTable = shared_ptr<SymbolTable>(buildSymbolTable(encoder->counters, sample, sampleLen, zeroTerminated));
-	delete[] sampleBuf;
-	return (duckdb_fsst_encoder_t*) encoder;
-}
-
-/* create another encoder instance, necessary to do multi-threaded encoding using the same symbol table */
-extern "C" duckdb_fsst_encoder_t* duckdb_fsst_duplicate(duckdb_fsst_encoder_t *encoder) {
-	Encoder *e = new Encoder();
-	e->symbolTable = ((Encoder*)encoder)->symbolTable; // it is a shared_ptr
-	return (duckdb_fsst_encoder_t*) e;
-}
-
-// export a symbol table in compact format.
-extern "C" u32 duckdb_fsst_export(duckdb_fsst_encoder_t *encoder, u8 *buf) {
-	Encoder *e = (Encoder*) encoder;
-	// In ->version there is a versionnr, but we hide also suffixLim/terminator/nSymbols there.
-	// This is sufficient in principle to *reconstruct* a duckdb_fsst_encoder_t from a duckdb_fsst_decoder_t
-	// (such functionality could be useful to append compressed data to an existing block).
-	//
-	// However, the hash function in the encoder hash table is endian-sensitive, and given its
-	// 'lossy perfect' hashing scheme is *unable* to contain other-endian-produced symbol tables.
-	// Doing a endian-conversion during hashing will be slow and self-defeating.
-	//
-	// Overall, we could support reconstructing an encoder for incremental compression, but
-	// should enforce equal-endianness. Bit of a bummer. Not going there now.
-	//
-	// The version field is now there just for future-proofness, but not used yet
-
-	// version allows keeping track of fsst versions, track endianness, and encoder reconstruction
-	u64 version = (FSST_VERSION << 32) |  // version is 24 bits, most significant byte is 0
-	              (((u64) e->symbolTable->suffixLim) << 24) |
-	              (((u64) e->symbolTable->terminator) << 16) |
-	              (((u64) e->symbolTable->nSymbols) << 8) |
-	              FSST_ENDIAN_MARKER; // least significant byte is nonzero
-
-	/* do not assume unaligned reads here */
-	memcpy(buf, &version, 8);
-	buf[8] = e->symbolTable->zeroTerminated;
-	for(u32 i=0; i<8; i++)
-		buf[9+i] = (u8) e->symbolTable->lenHisto[i];
-	u32 pos = 17;
-
-	// emit only the used bytes of the symbols
-	for(u32 i = e->symbolTable->zeroTerminated; i < e->symbolTable->nSymbols; i++)
-		for(u32 j = 0; j < e->symbolTable->symbols[i].length(); j++)
-			buf[pos++] = e->symbolTable->symbols[i].val.str[j]; // serialize used symbol bytes
-
-	return pos; // length of what was serialized
-}
-
-#define FSST_CORRUPT 32774747032022883 /* 7-byte number in little endian containing "corrupt" */
-
-extern "C" u32 duckdb_fsst_import(duckdb_fsst_decoder_t *decoder, u8 *buf) {
-	u64 version = 0;
-	u32 code, pos = 17;
-	u8 lenHisto[8];
-
-	// version field (first 8 bytes) is now there just for future-proofness, unused still (skipped)
-	memcpy(&version, buf, 8);
-	if ((version>>32) != FSST_VERSION) return 0;
-	decoder->zeroTerminated = buf[8]&1;
-	memcpy(lenHisto, buf+9, 8);
-
-	// in case of zero-terminated, first symbol is "" (zero always, may be overwritten)
-	decoder->len[0] = 1;
-	decoder->symbol[0] = 0;
-
-	// we use lenHisto[0] as 1-byte symbol run length (at the end)
-	code = decoder->zeroTerminated;
-	if (decoder->zeroTerminated) lenHisto[0]--; // if zeroTerminated, then symbol "" aka 1-byte code=0, is not stored at the end
-
-	// now get all symbols from the buffer
-	for(u32 l=1; l<=8; l++) { /* l = 1,2,3,4,5,6,7,8 */
-		for(u32 i=0; i < lenHisto[(l&7) /* 1,2,3,4,5,6,7,0 */]; i++, code++)  {
-			decoder->len[code] = (l&7)+1; /* len = 2,3,4,5,6,7,8,1  */
-			decoder->symbol[code] = 0;
-			for(u32 j=0; j<decoder->len[code]; j++)
-				((u8*) &decoder->symbol[code])[j] = buf[pos++]; // note this enforces 'little endian' symbols
-		}
-	}
-	if (decoder->zeroTerminated) lenHisto[0]++;
-
-	// fill unused symbols with text "corrupt". Gives a chance to detect corrupted code sequences (if there are unused symbols).
-	while(code<255) {
-		decoder->symbol[code] = FSST_CORRUPT;
-		decoder->len[code++] = 8;
-	}
-	return pos;
-}
-
-// runtime check for simd
-inline size_t _compressImpl(Encoder *e, size_t nlines, size_t lenIn[], u8 *strIn[], size_t size, u8 *output, size_t *lenOut, u8 *strOut[], bool noSuffixOpt, bool avoidBranch, int) {
-	return compressBulk(*e->symbolTable, nlines, lenIn, strIn, size, output, lenOut, strOut, noSuffixOpt, avoidBranch);
-}
-size_t compressImpl(Encoder *e, size_t nlines, size_t lenIn[], u8 *strIn[], size_t size, u8 *output, size_t *lenOut, u8 *strOut[], bool noSuffixOpt, bool avoidBranch, int simd) {
-	return _compressImpl(e, nlines, lenIn, strIn, size, output, lenOut, strOut, noSuffixOpt, avoidBranch, simd);
-}
-
-// adaptive choosing of scalar compression method based on symbol length histogram
-inline size_t _compressAuto(Encoder *e, size_t nlines, size_t lenIn[], u8 *strIn[], size_t size, u8 *output, size_t *lenOut, u8 *strOut[], int simd) {
-	bool avoidBranch = false, noSuffixOpt = false;
-	if (100*e->symbolTable->lenHisto[1] > 65*e->symbolTable->nSymbols && 100*e->symbolTable->suffixLim > 95*e->symbolTable->lenHisto[1]) {
-		noSuffixOpt = true;
-	} else if ((e->symbolTable->lenHisto[0] > 24 && e->symbolTable->lenHisto[0] < 92) &&
-	           (e->symbolTable->lenHisto[0] < 43 || e->symbolTable->lenHisto[6] + e->symbolTable->lenHisto[7] < 29) &&
-	           (e->symbolTable->lenHisto[0] < 72 || e->symbolTable->lenHisto[2] < 72)) {
-		avoidBranch = true;
-	}
-	return _compressImpl(e, nlines, lenIn, strIn, size, output, lenOut, strOut, noSuffixOpt, avoidBranch, simd);
-}
-size_t compressAuto(Encoder *e, size_t nlines, size_t lenIn[], u8 *strIn[], size_t size, u8 *output, size_t *lenOut, u8 *strOut[], int simd) {
-	return _compressAuto(e, nlines, lenIn, strIn, size, output, lenOut, strOut, simd);
-}
-
-// the main compression function (everything automatic)
-extern "C" size_t duckdb_fsst_compress(duckdb_fsst_encoder_t *encoder, size_t nlines, size_t lenIn[], u8 *strIn[], size_t size, u8 *output, size_t *lenOut, u8 *strOut[]) {
-	// to be faster than scalar, simd needs 64 lines or more of length >=12; or fewer lines, but big ones (totLen > 32KB)
-	size_t totLen = accumulate(lenIn, lenIn+nlines, 0);
-	int simd = totLen > nlines*12 && (nlines > 64 || totLen > (size_t) 1<<15);
-	return _compressAuto((Encoder*) encoder, nlines, lenIn, strIn, size, output, lenOut, strOut, 3*simd);
-}
-
-/* deallocate encoder */
-extern "C" void duckdb_fsst_destroy(duckdb_fsst_encoder_t* encoder) {
-	Encoder *e = (Encoder*) encoder;
-	delete e;
-}
-
-/* very lazy implementation relying on export and import */
-extern "C" duckdb_fsst_decoder_t duckdb_fsst_decoder(duckdb_fsst_encoder_t *encoder) {
-	u8 buf[sizeof(duckdb_fsst_decoder_t)];
-	u32 cnt1 = duckdb_fsst_export(encoder, buf);
-	duckdb_fsst_decoder_t decoder;
-	u32 cnt2 = duckdb_fsst_import(&decoder, buf);
-	assert(cnt1 == cnt2); (void) cnt1; (void) cnt2;
-	return decoder;
-}
diff --git a/src/duckdb/third_party/fsst/libfsst.hpp b/src/duckdb/third_party/fsst/libfsst.hpp
deleted file mode 100644
index 0d556386a..000000000
--- a/src/duckdb/third_party/fsst/libfsst.hpp
+++ /dev/null
@@ -1,438 +0,0 @@
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-// 
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files   
-// (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,   
-// merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is   
-// furnished to do so, subject to the following conditions:
-// 
-// - The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 
-// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
-//                 
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst 
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <numeric>
-#include <memory>
-#include <queue>
-#include <string>
-#include <unordered_set>
-#include <vector>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stddef.h>
-
-using namespace std;
-
-#include "fsst.h" // the official FSST API -- also usable by C mortals
-
-/* unsigned integers */
-typedef uint8_t u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
-
-inline uint64_t fsst_unaligned_load(u8 const* V) {
-	uint64_t Ret;
-	memcpy(&Ret, V, sizeof(uint64_t)); // compiler will generate efficient code (unaligned load, where possible)
-	return Ret;
-}
-
-#define FSST_ENDIAN_MARKER ((u64) 1)
-#define FSST_VERSION_20190218 20190218
-#define FSST_VERSION ((u64) FSST_VERSION_20190218)
-
-// "symbols" are character sequences (up to 8 bytes)
-// A symbol is compressed into a "code" of, in principle, one byte. But, we added an exception mechanism:
-// byte 255 followed by byte X represents the single-byte symbol X. Its code is 256+X.
-
-// we represent codes in u16 (not u8). 12 bits code (of which 10 are used), 4 bits length
-#define FSST_LEN_BITS       12
-#define FSST_CODE_BITS      9 
-#define FSST_CODE_BASE      256UL /* first 256 codes [0,255] are pseudo codes: escaped bytes */
-#define FSST_CODE_MAX       (1UL<<FSST_CODE_BITS) /* all bits set: indicating a symbol that has not been assigned a code yet */
-#define FSST_CODE_MASK      (FSST_CODE_MAX-1UL)   /* all bits set: indicating a symbol that has not been assigned a code yet */
-
-struct Symbol {
-   static const unsigned maxLength = 8;
-
-   // the byte sequence that this symbol stands for
-   union { char str[maxLength]; u64 num; } val; // usually we process it as a num(ber), as this is fast
-
-   // icl = u64 ignoredBits:16,code:12,length:4,unused:32 -- but we avoid exposing this bit-field notation
-   u64 icl;  // use a single u64 to be sure "code" is accessed with one load and can be compared with one comparison
-
-   Symbol() : icl(0) { val.num = 0; }
-
-   explicit Symbol(u8 c, u16 code) : icl((1<<28)|(code<<16)|56) { val.num = c; } // single-char symbol
-   explicit Symbol(const char* begin, const char* end) : Symbol(begin, (u32) (end-begin)) {}
-   explicit Symbol(u8* begin, u8* end) : Symbol((const char*)begin, (u32) (end-begin)) {}
-   explicit Symbol(const char* input, u32 len) {
-      val.num = 0;
-      if (len>=8) {
-          len = 8;
-          memcpy(val.str, input, 8);
-      } else {
-          memcpy(val.str, input, len);
-      }
-      set_code_len(FSST_CODE_MAX, len);
-   }
-   void set_code_len(u32 code, u32 len) { icl = (len<<28)|(code<<16)|((8-len)*8); }
-
-   u32 length() const { return (u32) (icl >> 28); }
-   u16 code() const { return (icl >> 16) & FSST_CODE_MASK; }
-   u32 ignoredBits() const { return (u32) icl; }
-
-   u8 first() const { assert( length() >= 1); return 0xFF & val.num; }
-   u16 first2() const { assert( length() >= 2); return 0xFFFF & val.num; }
-
-#define FSST_HASH_LOG2SIZE 10 
-#define FSST_HASH_PRIME 2971215073LL
-#define FSST_SHIFT 15
-#define FSST_HASH(w) (((w)*FSST_HASH_PRIME)^(((w)*FSST_HASH_PRIME)>>FSST_SHIFT))
-   size_t hash() const { size_t v = 0xFFFFFF & val.num; return FSST_HASH(v); } // hash on the next 3 bytes
-};
-
-// Symbol that can be put in a queue, ordered on gain
-struct QSymbol{
-   Symbol symbol;
-   mutable u32 gain; // mutable because gain value should be ignored in find() on unordered_set of QSymbols
-   bool operator==(const QSymbol& other) const { return symbol.val.num == other.symbol.val.num && symbol.length() == other.symbol.length(); }
-};
-
-// we construct FSST symbol tables using a random sample of about 16KB (1<<14) 
-#define FSST_SAMPLETARGET (1<<14)
-#define FSST_SAMPLEMAXSZ ((long) 2*FSST_SAMPLETARGET)
-
-// two phases of compression, before and after optimize():
-//
-// (1) to encode values we probe (and maintain) three datastructures:
-// - u16 byteCodes[65536] array at the position of the next byte  (s.length==1)
-// - u16 shortCodes[65536] array at the position of the next twobyte pattern (s.length==2)
-// - Symbol hashtable[1024] (keyed by the next three bytes, ie for s.length>2), 
-// this search will yield a u16 code, it points into Symbol symbols[]. You always find a hit, because the first 256 codes are 
-// pseudo codes representing a single byte these will become escapes)
-//
-// (2) when we finished looking for the best symbol table we call optimize() to reshape it:
-// - it renumbers the codes by length (first symbols of length 2,3,4,5,6,7,8; then 1 (starting from byteLim are symbols of length 1)
-//   length 2 codes for which no longer suffix symbol exists (< suffixLim) come first among the 2-byte codes 
-//   (allows shortcut during compression)
-// - for each two-byte combination, in all unused slots of shortCodes[], it enters the byteCode[] of the symbol corresponding 
-//   to the first byte (if such a single-byte symbol exists). This allows us to just probe the next two bytes (if there is only one
-//   byte left in the string, there is still a terminator-byte added during compression) in shortCodes[]. That is, byteCodes[]
-//   and its codepath is no longer required. This makes compression faster. The reason we use byteCodes[] during symbolTable construction
-//   is that adding a new code/symbol is expensive (you have to touch shortCodes[] in 256 places). This optimization was
-//   hence added to make symbolTable construction faster.
-//
-// this final layout allows for the fastest compression code, only currently present in compressBulk
-
-// in the hash table, the icl field contains (low-to-high) ignoredBits:16,code:12,length:4
-#define FSST_ICL_FREE ((15<<28)|(((u32)FSST_CODE_MASK)<<16)) // high bits of icl (len=8,code=FSST_CODE_MASK) indicates free bucket
-
-// ignoredBits is (8-length)*8, which is the amount of high bits to zero in the input word before comparing with the hashtable key
-//             ..it could of course be computed from len during lookup, but storing it precomputed in some loose bits is faster
-//
-// the gain field is only used in the symbol queue that sorts symbols on gain
-
-struct SymbolTable {
-   static const u32 hashTabSize = 1<<FSST_HASH_LOG2SIZE; // smallest size that incurs no precision loss
-
-   // lookup table using the next two bytes (65536 codes), or just the next single byte
-   u16 shortCodes[65536]; // contains code for 2-byte symbol, otherwise code for pseudo byte (escaped byte)
-
-   // lookup table (only used during symbolTable construction, not during normal text compression)
-   u16 byteCodes[256]; // contains code for every 1-byte symbol, otherwise code for pseudo byte (escaped byte)
-
-   // 'symbols' is the current symbol  table symbol[code].symbol is the max 8-byte 'symbol' for single-byte 'code'
-   Symbol symbols[FSST_CODE_MAX]; // x in [0,255]: pseudo symbols representing escaped byte x; x in [FSST_CODE_BASE=256,256+nSymbols]: real symbols   
-
-   // replicate long symbols in hashTab (avoid indirection). 
-   Symbol hashTab[hashTabSize]; // used for all symbols of 3 and more bytes
-
-   u16 nSymbols;          // amount of symbols in the map (max 255)
-   u16 suffixLim;         // codes higher than this do not have a longer suffix
-   u16 terminator;        // code of 1-byte symbol, that can be used as a terminator during compression
-   bool zeroTerminated;   // whether we are expecting zero-terminated strings (we then also produce zero-terminated compressed strings)
-   u16 lenHisto[FSST_CODE_BITS]; // lenHisto[x] is the amount of symbols of byte-length (x+1) in this SymbolTable
-
-   SymbolTable() : nSymbols(0), suffixLim(FSST_CODE_MAX), terminator(0), zeroTerminated(false) {
-      // stuff done once at startup
-      for (u32 i=0; i<256; i++) {
-         symbols[i] = Symbol(i,i|(1<<FSST_LEN_BITS)); // pseudo symbols
-      }
-      Symbol unused = Symbol((u8) 0,FSST_CODE_MASK); // single-char symbol, exception code
-      for (u32 i=256; i<FSST_CODE_MAX; i++) {
-         symbols[i] = unused; // we start with all symbols unused
-      }
-      // empty hash table
-      Symbol s;
-      s.val.num = 0;
-      s.icl = FSST_ICL_FREE; //marks empty in hashtab
-      for(u32 i=0; i<hashTabSize; i++)
-         hashTab[i] = s;
-
-      // fill byteCodes[] with the pseudo code all bytes (escaped bytes)
-      for(u32 i=0; i<256; i++)
-         byteCodes[i] = (1<<FSST_LEN_BITS) | i;
-
-      // fill shortCodes[] with the pseudo code for the first byte of each two-byte pattern
-      for(u32 i=0; i<65536; i++)
-         shortCodes[i] = (1<<FSST_LEN_BITS) | (i&255);
-
-      memset(lenHisto, 0, sizeof(lenHisto)); // all unused
-   }
-
-   void clear() {
-      // clear a symbolTable with minimal effort (only erase the used positions in it)
-      memset(lenHisto, 0, sizeof(lenHisto)); // all unused
-      for(u32 i=FSST_CODE_BASE; i<FSST_CODE_BASE+nSymbols; i++) {
-          if (symbols[i].length() == 1) {
-              u16 val = symbols[i].first();
-              byteCodes[val] = (1<<FSST_LEN_BITS) | val;
-          } else if (symbols[i].length() == 2) {
-              u16 val = symbols[i].first2();
-              shortCodes[val] = (1<<FSST_LEN_BITS) | (val&255);
-          } else {
-              u32 idx = symbols[i].hash() & (hashTabSize-1);
-              hashTab[idx].val.num = 0;
-              hashTab[idx].icl = FSST_ICL_FREE; //marks empty in hashtab
-          }           
-      } 
-      nSymbols = 0; // no need to clean symbols[] as no symbols are used
-   }
-   bool hashInsert(Symbol s) {
-      u32 idx = s.hash() & (hashTabSize-1);
-      bool taken = (hashTab[idx].icl < FSST_ICL_FREE);
-      if (taken) return false; // collision in hash table
-      hashTab[idx].icl = s.icl;
-      hashTab[idx].val.num = s.val.num & (0xFFFFFFFFFFFFFFFF >> (u8) s.icl);
-      return true;
-   }
-   bool add(Symbol s) {
-      assert(FSST_CODE_BASE + nSymbols < FSST_CODE_MAX);
-      u32 len = s.length();
-      s.set_code_len(FSST_CODE_BASE + nSymbols, len);
-      if (len == 1) {
-         byteCodes[s.first()] = FSST_CODE_BASE + nSymbols + (1<<FSST_LEN_BITS); // len=1 (<<FSST_LEN_BITS)
-      } else if (len == 2) {
-         shortCodes[s.first2()] = FSST_CODE_BASE + nSymbols + (2<<FSST_LEN_BITS); // len=2 (<<FSST_LEN_BITS)
-      } else if (!hashInsert(s)) {
-         return false;
-      }
-      symbols[FSST_CODE_BASE + nSymbols++] = s;
-      lenHisto[len-1]++;
-      return true;
-   }
-   /// Find longest expansion, return code (= position in symbol table)
-   u16 findLongestSymbol(Symbol s) const {
-      size_t idx = s.hash() & (hashTabSize-1);
-      if (hashTab[idx].icl <= s.icl && hashTab[idx].val.num == (s.val.num & (0xFFFFFFFFFFFFFFFF >> ((u8) hashTab[idx].icl)))) {
-         return (hashTab[idx].icl>>16) & FSST_CODE_MASK; // matched a long symbol 
-      }
-      if (s.length() >= 2) {
-         u16 code =  shortCodes[s.first2()] & FSST_CODE_MASK;
-         if (code >= FSST_CODE_BASE) return code; 
-      }
-      return byteCodes[s.first()] & FSST_CODE_MASK;
-   }
-   u16 findLongestSymbol(u8* cur, u8* end) const {
-      return findLongestSymbol(Symbol(cur,end)); // represent the string as a temporary symbol
-   }
-
-   // rationale for finalize:
-   // - during symbol table construction, we may create more than 256 codes, but bring it down to max 255 in the last makeTable()
-   //   consequently we needed more than 8 bits during symbol table contruction, but can simplify the codes to single bytes in finalize()
-   //   (this feature is in fact lo longer used, but could still be exploited: symbol construction creates no more than 255 symbols in each pass)
-   // - we not only reduce the amount of codes to <255, but also *reorder* the symbols and renumber their codes, for higher compression perf.
-   //   we renumber codes so they are grouped by length, to allow optimized scalar string compression (byteLim and suffixLim optimizations). 
-   // - we make the use of byteCode[] no longer necessary by inserting single-byte codes in the free spots of shortCodes[]
-   //   Using shortCodes[] only makes compression faster. When creating the symbolTable, however, using shortCodes[] for the single-byte
-   //   symbols is slow, as each insert touches 256 positions in it. This optimization was added when optimizing symbolTable construction time.
-   //
-   // In all, we change the layout and coding, as follows..
-   //
-   // before finalize(): 
-   // - The real symbols are symbols[256..256+nSymbols>. As we may have nSymbols > 255
-   // - The first 256 codes are pseudo symbols (all escaped bytes)
-   //
-   // after finalize(): 
-   // - table layout is symbols[0..nSymbols>, with nSymbols < 256. 
-   // - Real codes are [0,nSymbols>. 8-th bit not set. 
-   // - Escapes in shortCodes have the 8th bit set (value: 256+255=511). 255 because the code to be emitted is the escape byte 255
-   // - symbols are grouped by length: 2,3,4,5,6,7,8, then 1 (single-byte codes last)
-   // the two-byte codes are split in two sections: 
-   // - first section contains codes for symbols for which there is no longer symbol (no suffix). It allows an early-out during compression
-   //
-   // finally, shortCodes[] is modified to also encode all single-byte symbols (hence byteCodes[] is not required on a critical path anymore).
-   //
-   void finalize(u8 zeroTerminated) {
-       assert(nSymbols <= 255);
-       u8 newCode[256], rsum[8], byteLim = nSymbols - (lenHisto[0] - zeroTerminated);
-
-       // compute running sum of code lengths (starting offsets for each length) 
-       rsum[0] = byteLim; // 1-byte codes are highest
-       rsum[1] = zeroTerminated;
-       for(u32 i=1; i<7; i++)
-          rsum[i+1] = rsum[i] + lenHisto[i];
-
-       // determine the new code for each symbol, ordered by length (and splitting 2byte symbols into two classes around suffixLim)
-       suffixLim = rsum[1];
-       symbols[newCode[0] = 0] = symbols[256]; // keep symbol 0 in place (for zeroTerminated cases only)
-
-       for(u32 i=zeroTerminated, j=rsum[2]; i<nSymbols; i++) {  
-          Symbol s1 = symbols[FSST_CODE_BASE+i];
-          u32 len = s1.length(), opt = (len == 2)*nSymbols;
-          if (opt) {
-              u16 first2 = s1.first2();
-              for(u32 k=0; k<opt; k++) {  
-                 Symbol s2 = symbols[FSST_CODE_BASE+k];
-                 if (k != i && s2.length() > 1 && first2 == s2.first2()) // test if symbol k is a suffix of s
-                    opt = 0;
-              }
-              newCode[i] = opt?suffixLim++:--j; // symbols without a larger suffix have a code < suffixLim 
-          } else 
-              newCode[i] = rsum[len-1]++;
-          s1.set_code_len(newCode[i],len);
-          symbols[newCode[i]] = s1; 
-       }
-       // renumber the codes in byteCodes[] 
-       for(u32 i=0; i<256; i++) 
-          if ((byteCodes[i] & FSST_CODE_MASK) >= FSST_CODE_BASE)
-             byteCodes[i] = newCode[(u8) byteCodes[i]] + (1 << FSST_LEN_BITS);
-          else 
-             byteCodes[i] = 511 + (1 << FSST_LEN_BITS);
-       
-       // renumber the codes in shortCodes[] 
-       for(u32 i=0; i<65536; i++)
-          if ((shortCodes[i] & FSST_CODE_MASK) >= FSST_CODE_BASE)
-             shortCodes[i] = newCode[(u8) shortCodes[i]] + (shortCodes[i] & (15 << FSST_LEN_BITS));
-          else 
-             shortCodes[i] = byteCodes[i&0xFF];
-
-       // replace the symbols in the hash table
-       for(u32 i=0; i<hashTabSize; i++)
-          if (hashTab[i].icl < FSST_ICL_FREE)
-             hashTab[i] = symbols[newCode[(u8) hashTab[i].code()]];
-   }
-};
-
-#ifdef NONOPT_FSST
-struct Counters {
-   u16 count1[FSST_CODE_MAX];   // array to count frequency of symbols as they occur in the sample 
-   u16 count2[FSST_CODE_MAX][FSST_CODE_MAX]; // array to count subsequent combinations of two symbols in the sample 
-
-   void count1Set(u32 pos1, u16 val) { 
-      count1[pos1] = val;
-   }
-   void count1Inc(u32 pos1) { 
-      count1[pos1]++;
-   }
-   void count2Inc(u32 pos1, u32 pos2) {  
-      count2[pos1][pos2]++;
-   }
-   u32 count1GetNext(u32 &pos1) { 
-      return count1[pos1];
-   }
-   u32 count2GetNext(u32 pos1, u32 &pos2) { 
-      return count2[pos1][pos2];
-   }
-   void backup1(u8 *buf) {
-      memcpy(buf, count1, FSST_CODE_MAX*sizeof(u16));
-   }
-   void restore1(u8 *buf) {
-      memcpy(count1, buf, FSST_CODE_MAX*sizeof(u16));
-   }
-};
-#else
-// we keep two counters count1[pos] and count2[pos1][pos2] of resp 16 and 12-bits. Both are split into two columns for performance reasons
-// first reason is to make the column we update the most during symbolTable construction (the low bits) thinner, thus reducing CPU cache pressure.
-// second reason is that when scanning the array, after seeing a 64-bits 0 in the high bits column, we can quickly skip over many codes (15 or 7)
-struct Counters {
-   // high arrays come before low arrays, because our GetNext() methods may overrun their 64-bits reads a few bytes
-   u8 count1High[FSST_CODE_MAX];   // array to count frequency of symbols as they occur in the sample (16-bits)
-   u8 count1Low[FSST_CODE_MAX];    // it is split in a low and high byte: cnt = count1High*256 + count1Low
-   u8 count2High[FSST_CODE_MAX][FSST_CODE_MAX/2]; // array to count subsequent combinations of two symbols in the sample (12-bits: 8-bits low, 4-bits high)
-   u8 count2Low[FSST_CODE_MAX][FSST_CODE_MAX];    // its value is (count2High*256+count2Low) -- but high is 4-bits (we put two numbers in one, hence /2)
-   // 385KB  -- but hot area likely just 10 + 30*4 = 130 cache lines (=8KB)
-   
-   void count1Set(u32 pos1, u16 val) { 
-      count1Low[pos1] = val&255;
-      count1High[pos1] = val>>8;
-   }
-   void count1Inc(u32 pos1) { 
-      if (!count1Low[pos1]++) // increment high early (when low==0, not when low==255). This means (high > 0) <=> (cnt > 0)
-         count1High[pos1]++; //(0,0)->(1,1)->..->(255,1)->(0,1)->(1,2)->(2,2)->(3,2)..(255,2)->(0,2)->(1,3)->(2,3)...
-   }
-   void count2Inc(u32 pos1, u32 pos2) {  
-       if (!count2Low[pos1][pos2]++) // increment high early (when low==0, not when low==255). This means (high > 0) <=> (cnt > 0)
-          // inc 4-bits high counter with 1<<0 (1) or 1<<4 (16) -- depending on whether pos2 is even or odd, repectively
-          count2High[pos1][(pos2)>>1] += 1 << (((pos2)&1)<<2); // we take our chances with overflow.. (4K maxval, on a 8K sample)
-   }
-   u32 count1GetNext(u32 &pos1) { // note: we will advance pos1 to the next nonzero counter in register range
-      // read 16-bits single symbol counter, split into two 8-bits numbers (count1Low, count1High), while skipping over zeros
-	   u64 high = fsst_unaligned_load(&count1High[pos1]);
-
-      u32 zero = high?(__builtin_ctzll(high)>>3):7UL; // number of zero bytes
-      high = (high >> (zero << 3)) & 255; // advance to nonzero counter
-      if (((pos1 += zero) >= FSST_CODE_MAX) || !high) // SKIP! advance pos2
-         return 0; // all zero
-
-      u32 low = count1Low[pos1];
-      if (low) high--; // high is incremented early and low late, so decrement high (unless low==0)
-      return (u32) ((high << 8) + low);
-   }
-   u32 count2GetNext(u32 pos1, u32 &pos2) { // note: we will advance pos2 to the next nonzero counter in register range
-      // read 12-bits pairwise symbol counter, split into low 8-bits and high 4-bits number while skipping over zeros
-	  u64 high = fsst_unaligned_load(&count2High[pos1][pos2>>1]);
-      high >>= ((pos2&1) << 2); // odd pos2: ignore the lowest 4 bits & we see only 15 counters
-
-      u32 zero = high?(__builtin_ctzll(high)>>2):(15UL-(pos2&1UL)); // number of zero 4-bits counters
-      high = (high >> (zero << 2)) & 15;  // advance to nonzero counter
-      if (((pos2 += zero) >= FSST_CODE_MAX) || !high) // SKIP! advance pos2
-         return 0UL; // all zero
-
-      u32 low = count2Low[pos1][pos2];
-      if (low) high--; // high is incremented early and low late, so decrement high (unless low==0)
-      return (u32) ((high << 8) + low);
-   }
-   void backup1(u8 *buf) {
-      memcpy(buf, count1High, FSST_CODE_MAX);
-      memcpy(buf+FSST_CODE_MAX, count1Low, FSST_CODE_MAX);
-   }
-   void restore1(u8 *buf) {
-      memcpy(count1High, buf, FSST_CODE_MAX);
-      memcpy(count1Low, buf+FSST_CODE_MAX, FSST_CODE_MAX);
-   }
-}; 
-#endif
-
-
-#define FSST_BUFSZ (3<<19) // 768KB
-
-// an encoder is a symbolmap plus some bufferspace, needed during map construction as well as compression 
-struct Encoder {
-   shared_ptr<SymbolTable> symbolTable; // symbols, plus metadata and data structures for quick compression (shortCode,hashTab, etc)
-   union {
-      Counters counters;     // for counting symbol occurences during map construction
-      u8 simdbuf[FSST_BUFSZ]; // for compression: SIMD string staging area 768KB = 256KB in + 512KB out (worst case for 256KB in) 
-   };
-};
-
-// job control integer representable in one 64bits SIMD lane: cur/end=input, out=output, pos=which string (2^9=512 per call)
-struct SIMDjob {
-   u64 out:19,pos:9,end:18,cur:18; // cur/end is input offsets (2^18=256KB), out is output offset (2^19=512KB)  
-};
-
-// C++ fsst-compress function with some more control of how the compression happens (algorithm flavor, simd unroll degree)
-size_t compressImpl(Encoder *encoder, size_t n, size_t lenIn[], u8 *strIn[], size_t size, u8 * output, size_t *lenOut, u8 *strOut[], bool noSuffixOpt, bool avoidBranch, int simd);
-size_t compressAuto(Encoder *encoder, size_t n, size_t lenIn[], u8 *strIn[], size_t size, u8 * output, size_t *lenOut, u8 *strOut[], int simd);
diff --git a/src/duckdb/third_party/httplib/httplib.hpp b/src/duckdb/third_party/httplib/httplib.hpp
deleted file mode 100644
index 6432d5d1a..000000000
--- a/src/duckdb/third_party/httplib/httplib.hpp
+++ /dev/null
@@ -1,9379 +0,0 @@
-// taken from: https://github.com/yhirose/cpp-httplib/blob/v0.14.3/httplib.h
-// Note: some modifications are made to file (replace std::regex with RE2)
-
-//
-//  httplib.h
-//
-//  Copyright (c) 2023 Yuji Hirose. All rights reserved.
-//  MIT License
-//
-
-#ifndef CPPHTTPLIB_HTTPLIB_H
-#define CPPHTTPLIB_HTTPLIB_H
-
-#define CPPHTTPLIB_VERSION "0.14.3"
-
-/*
- * Configuration
- */
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-#define CPPHTTPLIB_NAMESPACE duckdb_httplib_openssl
-#else
-#define CPPHTTPLIB_NAMESPACE duckdb_httplib
-#endif
-
-#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND
-#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_KEEPALIVE_MAX_COUNT
-#define CPPHTTPLIB_KEEPALIVE_MAX_COUNT 5
-#endif
-
-#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND
-#define CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND 300
-#endif
-
-#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND
-#define CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_READ_TIMEOUT_SECOND
-#define CPPHTTPLIB_READ_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_READ_TIMEOUT_USECOND
-#define CPPHTTPLIB_READ_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_WRITE_TIMEOUT_SECOND
-#define CPPHTTPLIB_WRITE_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_WRITE_TIMEOUT_USECOND
-#define CPPHTTPLIB_WRITE_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_IDLE_INTERVAL_SECOND
-#define CPPHTTPLIB_IDLE_INTERVAL_SECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_IDLE_INTERVAL_USECOND
-#ifdef _WIN32
-#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 10000
-#else
-#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 0
-#endif
-#endif
-
-#ifndef CPPHTTPLIB_REQUEST_URI_MAX_LENGTH
-#define CPPHTTPLIB_REQUEST_URI_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_USE_POLL
-#define CPPHTTPLIB_USE_POLL
-#endif
-
-#ifndef CPPHTTPLIB_HEADER_MAX_LENGTH
-#define CPPHTTPLIB_HEADER_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_REDIRECT_MAX_COUNT
-#define CPPHTTPLIB_REDIRECT_MAX_COUNT 20
-#endif
-
-#ifndef CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT
-#define CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT 1024
-#endif
-
-#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH
-#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH ((std::numeric_limits<size_t>::max)())
-#endif
-
-#ifndef CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH
-#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_TCP_NODELAY
-#define CPPHTTPLIB_TCP_NODELAY false
-#endif
-
-#ifndef CPPHTTPLIB_RECV_BUFSIZ
-#define CPPHTTPLIB_RECV_BUFSIZ size_t(4096u)
-#endif
-
-#ifndef CPPHTTPLIB_COMPRESSION_BUFSIZ
-#define CPPHTTPLIB_COMPRESSION_BUFSIZ size_t(16384u)
-#endif
-
-#ifndef CPPHTTPLIB_THREAD_POOL_COUNT
-#define CPPHTTPLIB_THREAD_POOL_COUNT                                           \
-  ((std::max)(8u, std::thread::hardware_concurrency() > 0                      \
-                      ? std::thread::hardware_concurrency() - 1                \
-                      : 0))
-#endif
-
-#ifndef CPPHTTPLIB_RECV_FLAGS
-#define CPPHTTPLIB_RECV_FLAGS 0
-#endif
-
-#ifndef MSG_NOSIGNAL
-#define CPPHTTPLIB_SEND_FLAGS 0
-#else
-#define CPPHTTPLIB_SEND_FLAGS MSG_NOSIGNAL
-#endif
-
-#ifndef CPPHTTPLIB_LISTEN_BACKLOG
-#define CPPHTTPLIB_LISTEN_BACKLOG 5
-#endif
-
-/*
- * Headers
- */
-
-#ifdef _WIN32
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif //_CRT_SECURE_NO_WARNINGS
-
-#ifndef _CRT_NONSTDC_NO_DEPRECATE
-#define _CRT_NONSTDC_NO_DEPRECATE
-#endif //_CRT_NONSTDC_NO_DEPRECATE
-
-#if defined(_MSC_VER)
-#if _MSC_VER < 1900
-#error Sorry, Visual Studio versions prior to 2015 are not supported
-#endif
-
-#pragma comment(lib, "ws2_32.lib")
-
-#ifdef _WIN64
-using ssize_t = __int64;
-#else
-using ssize_t = long;
-#endif
-#endif // _MSC_VER
-
-#ifndef S_ISREG
-#define S_ISREG(m) (((m) & S_IFREG) == S_IFREG)
-#endif // S_ISREG
-
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m) & S_IFDIR) == S_IFDIR)
-#endif // S_ISDIR
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif // NOMINMAX
-
-#include <io.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#ifndef WSA_FLAG_NO_HANDLE_INHERIT
-#define WSA_FLAG_NO_HANDLE_INHERIT 0x80
-#endif
-
-#ifndef strcasecmp
-#define strcasecmp _stricmp
-#endif // strcasecmp
-
-using socket_t = SOCKET;
-#ifdef CPPHTTPLIB_USE_POLL
-#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout)
-#endif
-
-#else // not _WIN32
-
-#include <arpa/inet.h>
-#if !defined(_AIX) && !defined(__MVS__)
-#include <ifaddrs.h>
-#endif
-#ifdef __MVS__
-#include <strings.h>
-#ifndef NI_MAXHOST
-#define NI_MAXHOST 1025
-#endif
-#endif
-#include <net/if.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#ifdef __linux__
-#include <resolv.h>
-#endif
-#include <netinet/tcp.h>
-#ifdef CPPHTTPLIB_USE_POLL
-#include <poll.h>
-#endif
-#include <csignal>
-#include <pthread.h>
-#include <sys/mman.h>
-#include <sys/select.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-using socket_t = int;
-#ifndef INVALID_SOCKET
-#define INVALID_SOCKET (-1)
-#endif
-#endif //_WIN32
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <condition_variable>
-#include <cstring>
-#include <errno.h>
-#include <fcntl.h>
-#include <fstream>
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <list>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <regex>
-#include <set>
-#include <sstream>
-#include <string>
-#include <sys/stat.h>
-#include <thread>
-#include <unordered_map>
-#include <unordered_set>
-#include "duckdb/common/re2_regex.hpp"
-#include "duckdb/common/random_engine.hpp"
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-#ifdef _WIN32
-#include <wincrypt.h>
-
-// these are defined in wincrypt.h and it breaks compilation if BoringSSL is
-// used
-#undef X509_NAME
-#undef X509_CERT_PAIR
-#undef X509_EXTENSIONS
-#undef PKCS7_SIGNER_INFO
-
-#ifdef _MSC_VER
-#pragma comment(lib, "crypt32.lib")
-#endif
-#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)
-#include <TargetConditionals.h>
-#if TARGET_OS_OSX
-#include <CoreFoundation/CoreFoundation.h>
-#include <Security/Security.h>
-#endif // TARGET_OS_OSX
-#endif // _WIN32
-
-#include <openssl/err.h>
-#include <openssl/evp.h>
-#include <openssl/ssl.h>
-#include <openssl/x509v3.h>
-#include <openssl/rand.h>
-
-#if defined(_WIN32) && defined(OPENSSL_USE_APPLINK)
-#include <openssl/applink.c>
-#endif
-
-#include <iostream>
-#include <sstream>
-
-// Disabled OpenSSL version check for CI
-//#if OPENSSL_VERSION_NUMBER < 0x1010100fL
-//#error Sorry, OpenSSL versions prior to 1.1.1 are not supported
-#if OPENSSL_VERSION_NUMBER < 0x30000000L
-#define SSL_get1_peer_certificate SSL_get_peer_certificate
-#endif
-
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-#include <zlib.h>
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-#include <brotli/decode.h>
-#include <brotli/encode.h>
-#endif
-
-/*
- * Declaration
- */
-namespace CPPHTTPLIB_NAMESPACE {
-
-namespace detail {
-
-/*
- * Backport std::make_unique from C++14.
- *
- * NOTE: This code came up with the following stackoverflow post:
- * https://stackoverflow.com/questions/10149840/c-arrays-and-make-unique
- *
- */
-
-template <class T, class... Args>
-typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(Args &&...args) {
-  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-template <class T>
-typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(std::size_t n) {
-  typedef typename std::remove_extent<T>::type RT;
-  return std::unique_ptr<T>(new RT[n]);
-}
-
-struct ci {
-  bool operator()(const std::string &s1, const std::string &s2) const {
-    return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(),
-                                        s2.end(),
-                                        [](unsigned char c1, unsigned char c2) {
-                                          return ::tolower(c1) < ::tolower(c2);
-                                        });
-  }
-};
-
-// This is based on
-// "http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4189".
-
-struct scope_exit {
-  explicit scope_exit(std::function<void(void)> &&f)
-      : exit_function(std::move(f)), execute_on_destruction{true} {}
-
-  scope_exit(scope_exit &&rhs) noexcept
-      : exit_function(std::move(rhs.exit_function)),
-        execute_on_destruction{rhs.execute_on_destruction} {
-    rhs.release();
-  }
-
-  ~scope_exit() {
-    if (execute_on_destruction) { this->exit_function(); }
-  }
-
-  void release() { this->execute_on_destruction = false; }
-
-private:
-  scope_exit(const scope_exit &) = delete;
-  void operator=(const scope_exit &) = delete;
-  scope_exit &operator=(scope_exit &&) = delete;
-
-  std::function<void(void)> exit_function;
-  bool execute_on_destruction;
-};
-
-} // namespace detail
-
-enum StatusCode {
-  // Information responses
-  Continue_100 = 100,
-  SwitchingProtocol_101 = 101,
-  Processing_102 = 102,
-  EarlyHints_103 = 103,
-
-  // Successful responses
-  OK_200 = 200,
-  Created_201 = 201,
-  Accepted_202 = 202,
-  NonAuthoritativeInformation_203 = 203,
-  NoContent_204 = 204,
-  ResetContent_205 = 205,
-  PartialContent_206 = 206,
-  MultiStatus_207 = 207,
-  AlreadyReported_208 = 208,
-  IMUsed_226 = 226,
-
-  // Redirection messages
-  MultipleChoices_300 = 300,
-  MovedPermanently_301 = 301,
-  Found_302 = 302,
-  SeeOther_303 = 303,
-  NotModified_304 = 304,
-  UseProxy_305 = 305,
-  unused_306 = 306,
-  TemporaryRedirect_307 = 307,
-  PermanentRedirect_308 = 308,
-
-  // Client error responses
-  BadRequest_400 = 400,
-  Unauthorized_401 = 401,
-  PaymentRequired_402 = 402,
-  Forbidden_403 = 403,
-  NotFound_404 = 404,
-  MethodNotAllowed_405 = 405,
-  NotAcceptable_406 = 406,
-  ProxyAuthenticationRequired_407 = 407,
-  RequestTimeout_408 = 408,
-  Conflict_409 = 409,
-  Gone_410 = 410,
-  LengthRequired_411 = 411,
-  PreconditionFailed_412 = 412,
-  PayloadTooLarge_413 = 413,
-  UriTooLong_414 = 414,
-  UnsupportedMediaType_415 = 415,
-  RangeNotSatisfiable_416 = 416,
-  ExpectationFailed_417 = 417,
-  ImATeapot_418 = 418,
-  MisdirectedRequest_421 = 421,
-  UnprocessableContent_422 = 422,
-  Locked_423 = 423,
-  FailedDependency_424 = 424,
-  TooEarly_425 = 425,
-  UpgradeRequired_426 = 426,
-  PreconditionRequired_428 = 428,
-  TooManyRequests_429 = 429,
-  RequestHeaderFieldsTooLarge_431 = 431,
-  UnavailableForLegalReasons_451 = 451,
-
-  // Server error responses
-  InternalServerError_500 = 500,
-  NotImplemented_501 = 501,
-  BadGateway_502 = 502,
-  ServiceUnavailable_503 = 503,
-  GatewayTimeout_504 = 504,
-  HttpVersionNotSupported_505 = 505,
-  VariantAlsoNegotiates_506 = 506,
-  InsufficientStorage_507 = 507,
-  LoopDetected_508 = 508,
-  NotExtended_510 = 510,
-  NetworkAuthenticationRequired_511 = 511,
-};
-
-using Headers = std::multimap<std::string, std::string, detail::ci>;
-
-using Params = std::multimap<std::string, std::string>;
-using Match = duckdb_re2::Match;
-using Regex = duckdb_re2::Regex;
-
-using Progress = std::function<bool(uint64_t current, uint64_t total)>;
-
-struct Response;
-using ResponseHandler = std::function<bool(const Response &response)>;
-
-struct MultipartFormData {
-  std::string name;
-  std::string content;
-  std::string filename;
-  std::string content_type;
-};
-using MultipartFormDataItems = std::vector<MultipartFormData>;
-using MultipartFormDataMap = std::multimap<std::string, MultipartFormData>;
-
-class DataSink {
-public:
-  DataSink() : os(&sb_), sb_(*this) {}
-
-  DataSink(const DataSink &) = delete;
-  DataSink &operator=(const DataSink &) = delete;
-  DataSink(DataSink &&) = delete;
-  DataSink &operator=(DataSink &&) = delete;
-
-  std::function<bool(const char *data, size_t data_len)> write;
-  std::function<bool()> is_writable;
-  std::function<void()> done;
-  std::function<void(const Headers &trailer)> done_with_trailer;
-  std::ostream os;
-
-private:
-  class data_sink_streambuf : public std::streambuf {
-  public:
-    explicit data_sink_streambuf(DataSink &sink) : sink_(sink) {}
-
-  protected:
-    std::streamsize xsputn(const char *s, std::streamsize n) override {
-      sink_.write(s, static_cast<size_t>(n));
-      return n;
-    }
-
-  private:
-    DataSink &sink_;
-  };
-
-  data_sink_streambuf sb_;
-};
-
-using ContentProvider =
-    std::function<bool(size_t offset, size_t length, DataSink &sink)>;
-
-using ContentProviderWithoutLength =
-    std::function<bool(size_t offset, DataSink &sink)>;
-
-using ContentProviderResourceReleaser = std::function<void(bool success)>;
-
-struct MultipartFormDataProvider {
-  std::string name;
-  ContentProviderWithoutLength provider;
-  std::string filename;
-  std::string content_type;
-};
-using MultipartFormDataProviderItems = std::vector<MultipartFormDataProvider>;
-
-using ContentReceiverWithProgress =
-    std::function<bool(const char *data, size_t data_length, uint64_t offset,
-                       uint64_t total_length)>;
-
-using ContentReceiver =
-    std::function<bool(const char *data, size_t data_length)>;
-
-using MultipartContentHeader =
-    std::function<bool(const MultipartFormData &file)>;
-
-class ContentReader {
-public:
-  using Reader = std::function<bool(ContentReceiver receiver)>;
-  using MultipartReader = std::function<bool(MultipartContentHeader header,
-                                             ContentReceiver receiver)>;
-
-  ContentReader(Reader reader, MultipartReader multipart_reader)
-      : reader_(std::move(reader)),
-        multipart_reader_(std::move(multipart_reader)) {}
-
-  bool operator()(MultipartContentHeader header,
-                  ContentReceiver receiver) const {
-    return multipart_reader_(std::move(header), std::move(receiver));
-  }
-
-  bool operator()(ContentReceiver receiver) const {
-    return reader_(std::move(receiver));
-  }
-
-  Reader reader_;
-  MultipartReader multipart_reader_;
-};
-
-using Range = std::pair<ssize_t, ssize_t>;
-using Ranges = std::vector<Range>;
-
-struct Request {
-  std::string method;
-  std::string path;
-  Headers headers;
-  std::string body;
-
-  std::string remote_addr;
-  int remote_port = -1;
-  std::string local_addr;
-  int local_port = -1;
-
-  // for server
-  std::string version;
-  std::string target;
-  Params params;
-  MultipartFormDataMap files;
-  Ranges ranges;
-  Match matches;
-  std::unordered_map<std::string, std::string> path_params;
-
-  // for client
-  ResponseHandler response_handler;
-  ContentReceiverWithProgress content_receiver;
-  Progress progress;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  const SSL *ssl = nullptr;
-#endif
-
-  bool has_header(const std::string &key) const;
-  std::string get_header_value(const std::string &key, size_t id = 0) const;
-  uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const;
-  size_t get_header_value_count(const std::string &key) const;
-  void set_header(const std::string &key, const std::string &val);
-
-  bool has_param(const std::string &key) const;
-  std::string get_param_value(const std::string &key, size_t id = 0) const;
-  size_t get_param_value_count(const std::string &key) const;
-
-  bool is_multipart_form_data() const;
-
-  bool has_file(const std::string &key) const;
-  MultipartFormData get_file_value(const std::string &key) const;
-  std::vector<MultipartFormData> get_file_values(const std::string &key) const;
-
-  // private members...
-  size_t redirect_count_ = CPPHTTPLIB_REDIRECT_MAX_COUNT;
-  size_t content_length_ = 0;
-  ContentProvider content_provider_;
-  bool is_chunked_content_provider_ = false;
-  size_t authorization_count_ = 0;
-};
-
-struct Response {
-  std::string version;
-  int status = -1;
-  std::string reason;
-  Headers headers;
-  std::string body;
-  std::string location; // Redirect location
-
-  bool has_header(const std::string &key) const;
-  std::string get_header_value(const std::string &key, size_t id = 0) const;
-  uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const;
-  size_t get_header_value_count(const std::string &key) const;
-  void set_header(const std::string &key, const std::string &val);
-
-  void set_redirect(const std::string &url, int status = StatusCode::Found_302);
-  void set_content(const char *s, size_t n, const std::string &content_type);
-  void set_content(const std::string &s, const std::string &content_type);
-
-  void set_content_provider(
-      size_t length, const std::string &content_type, ContentProvider provider,
-      ContentProviderResourceReleaser resource_releaser = nullptr);
-
-  void set_content_provider(
-      const std::string &content_type, ContentProviderWithoutLength provider,
-      ContentProviderResourceReleaser resource_releaser = nullptr);
-
-  void set_chunked_content_provider(
-      const std::string &content_type, ContentProviderWithoutLength provider,
-      ContentProviderResourceReleaser resource_releaser = nullptr);
-
-  Response() = default;
-  Response(const Response &) = default;
-  Response &operator=(const Response &) = default;
-  Response(Response &&) = default;
-  Response &operator=(Response &&) = default;
-  ~Response() {
-    if (content_provider_resource_releaser_) {
-      content_provider_resource_releaser_(content_provider_success_);
-    }
-  }
-
-  // private members...
-  size_t content_length_ = 0;
-  ContentProvider content_provider_;
-  ContentProviderResourceReleaser content_provider_resource_releaser_;
-  bool is_chunked_content_provider_ = false;
-  bool content_provider_success_ = false;
-};
-
-class Stream {
-public:
-  virtual ~Stream() = default;
-
-  virtual bool is_readable() const = 0;
-  virtual bool is_writable() const = 0;
-
-  virtual ssize_t read(char *ptr, size_t size) = 0;
-  virtual ssize_t write(const char *ptr, size_t size) = 0;
-  virtual void get_remote_ip_and_port(std::string &ip, int &port) const = 0;
-  virtual void get_local_ip_and_port(std::string &ip, int &port) const = 0;
-  virtual socket_t socket() const = 0;
-
-  template <typename... Args>
-  ssize_t write_format(const char *fmt, const Args &...args);
-  ssize_t write(const char *ptr);
-  ssize_t write(const std::string &s);
-};
-
-class TaskQueue {
-public:
-  TaskQueue() = default;
-  virtual ~TaskQueue() = default;
-
-  virtual void enqueue(std::function<void()> fn) = 0;
-  virtual void shutdown() = 0;
-
-  virtual void on_idle() {}
-};
-
-class ThreadPool : public TaskQueue {
-public:
-  explicit ThreadPool(size_t n) : shutdown_(false) {
-    while (n) {
-      threads_.emplace_back(worker(*this));
-      n--;
-    }
-  }
-
-  ThreadPool(const ThreadPool &) = delete;
-  ~ThreadPool() override = default;
-
-  void enqueue(std::function<void()> fn) override {
-    {
-      std::unique_lock<std::mutex> lock(mutex_);
-      jobs_.push_back(std::move(fn));
-    }
-
-    cond_.notify_one();
-  }
-
-  void shutdown() override {
-    // Stop all worker threads...
-    {
-      std::unique_lock<std::mutex> lock(mutex_);
-      shutdown_ = true;
-    }
-
-    cond_.notify_all();
-
-    // Join...
-    for (auto &t : threads_) {
-      t.join();
-    }
-  }
-
-private:
-  struct worker {
-    explicit worker(ThreadPool &pool) : pool_(pool) {}
-
-    void operator()() {
-      for (;;) {
-        std::function<void()> fn;
-        {
-          std::unique_lock<std::mutex> lock(pool_.mutex_);
-
-          pool_.cond_.wait(
-              lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; });
-
-          if (pool_.shutdown_ && pool_.jobs_.empty()) { break; }
-
-          fn = std::move(pool_.jobs_.front());
-          pool_.jobs_.pop_front();
-        }
-
-        assert(true == static_cast<bool>(fn));
-        fn();
-      }
-    }
-
-    ThreadPool &pool_;
-  };
-  friend struct worker;
-
-  std::vector<std::thread> threads_;
-  std::list<std::function<void()>> jobs_;
-
-  bool shutdown_;
-
-  std::condition_variable cond_;
-  std::mutex mutex_;
-};
-
-using Logger = std::function<void(const Request &, const Response &)>;
-
-using SocketOptions = std::function<void(socket_t sock)>;
-
-void default_socket_options(socket_t sock);
-
-const char *status_message(int status);
-
-namespace detail {
-
-class MatcherBase {
-public:
-  virtual ~MatcherBase() = default;
-
-  // Match request path and populate its matches and
-  virtual bool match(Request &request) const = 0;
-};
-
-/**
- * Captures parameters in request path and stores them in Request::path_params
- *
- * Capture name is a substring of a pattern from : to /.
- * The rest of the pattern is matched agains the request path directly
- * Parameters are captured starting from the next character after
- * the end of the last matched static pattern fragment until the next /.
- *
- * Example pattern:
- * "/path/fragments/:capture/more/fragments/:second_capture"
- * Static fragments:
- * "/path/fragments/", "more/fragments/"
- *
- * Given the following request path:
- * "/path/fragments/:1/more/fragments/:2"
- * the resulting capture will be
- * {{"capture", "1"}, {"second_capture", "2"}}
- */
-class PathParamsMatcher : public MatcherBase {
-public:
-  PathParamsMatcher(const std::string &pattern);
-
-  bool match(Request &request) const override;
-
-private:
-  static constexpr char marker = ':';
-  // Treat segment separators as the end of path parameter capture
-  // Does not need to handle query parameters as they are parsed before path
-  // matching
-  static constexpr char separator = '/';
-
-  // Contains static path fragments to match against, excluding the '/' after
-  // path params
-  // Fragments are separated by path params
-  std::vector<std::string> static_fragments_;
-  // Stores the names of the path parameters to be used as keys in the
-  // Request::path_params map
-  std::vector<std::string> param_names_;
-};
-
-/**
- * Performs RegexMatch on request path
- * and stores the result in Request::matches
- *
- * Note that regex match is performed directly on the whole request.
- * This means that wildcard patterns may match multiple path segments with /:
- * "/begin/(.*)/end" will match both "/begin/middle/end" and "/begin/1/2/end".
- */
-class RegexMatcher : public MatcherBase {
-public:
-  RegexMatcher(const std::string &pattern) : regex_(pattern) {}
-
-  bool match(Request &request) const override;
-
-private:
-  Regex regex_;
-};
-
-ssize_t write_headers(Stream &strm, const Headers &headers);
-
-} // namespace detail
-
-class Server {
-public:
-  using Handler = std::function<void(const Request &, Response &)>;
-
-  using ExceptionHandler =
-      std::function<void(const Request &, Response &, std::exception_ptr ep)>;
-
-  enum class HandlerResponse {
-    Handled,
-    Unhandled,
-  };
-  using HandlerWithResponse =
-      std::function<HandlerResponse(const Request &, Response &)>;
-
-  using HandlerWithContentReader = std::function<void(
-      const Request &, Response &, const ContentReader &content_reader)>;
-
-  using Expect100ContinueHandler =
-      std::function<int(const Request &, Response &)>;
-
-  Server();
-
-  virtual ~Server();
-
-  virtual bool is_valid() const;
-
-  Server &Get(const std::string &pattern, Handler handler);
-  Server &Post(const std::string &pattern, Handler handler);
-  Server &Post(const std::string &pattern, HandlerWithContentReader handler);
-  Server &Put(const std::string &pattern, Handler handler);
-  Server &Put(const std::string &pattern, HandlerWithContentReader handler);
-  Server &Patch(const std::string &pattern, Handler handler);
-  Server &Patch(const std::string &pattern, HandlerWithContentReader handler);
-  Server &Delete(const std::string &pattern, Handler handler);
-  Server &Delete(const std::string &pattern, HandlerWithContentReader handler);
-  Server &Options(const std::string &pattern, Handler handler);
-
-  bool set_base_dir(const std::string &dir,
-                    const std::string &mount_point = std::string());
-  bool set_mount_point(const std::string &mount_point, const std::string &dir,
-                       Headers headers = Headers());
-  bool remove_mount_point(const std::string &mount_point);
-  Server &set_file_extension_and_mimetype_mapping(const std::string &ext,
-                                                  const std::string &mime);
-  Server &set_default_file_mimetype(const std::string &mime);
-  Server &set_file_request_handler(Handler handler);
-
-  Server &set_error_handler(HandlerWithResponse handler);
-  Server &set_error_handler(Handler handler);
-  Server &set_exception_handler(ExceptionHandler handler);
-  Server &set_pre_routing_handler(HandlerWithResponse handler);
-  Server &set_post_routing_handler(Handler handler);
-
-  Server &set_expect_100_continue_handler(Expect100ContinueHandler handler);
-  Server &set_logger(Logger logger);
-
-  Server &set_address_family(int family);
-  Server &set_tcp_nodelay(bool on);
-  Server &set_socket_options(SocketOptions socket_options);
-
-  Server &set_default_headers(Headers headers);
-  Server &
-  set_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);
-
-  Server &set_keep_alive_max_count(size_t count);
-  Server &set_keep_alive_timeout(time_t sec);
-
-  Server &set_read_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  Server &set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  Server &set_write_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  Server &set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  Server &set_idle_interval(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  Server &set_idle_interval(const std::chrono::duration<Rep, Period> &duration);
-
-  Server &set_payload_max_length(size_t length);
-
-  bool bind_to_port(const std::string &host, int port, int socket_flags = 0);
-  int bind_to_any_port(const std::string &host, int socket_flags = 0);
-  bool listen_after_bind();
-
-  bool listen(const std::string &host, int port, int socket_flags = 0);
-
-  bool is_running() const;
-  void wait_until_ready() const;
-  void stop();
-
-  std::function<TaskQueue *(void)> new_task_queue;
-
-protected:
-  bool process_request(Stream &strm, bool close_connection,
-                       bool &connection_closed,
-                       const std::function<void(Request &)> &setup_request);
-
-  std::atomic<socket_t> svr_sock_{INVALID_SOCKET};
-  size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT;
-  time_t keep_alive_timeout_sec_ = CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND;
-  time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
-  time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
-  time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;
-  time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;
-  time_t idle_interval_sec_ = CPPHTTPLIB_IDLE_INTERVAL_SECOND;
-  time_t idle_interval_usec_ = CPPHTTPLIB_IDLE_INTERVAL_USECOND;
-  size_t payload_max_length_ = CPPHTTPLIB_PAYLOAD_MAX_LENGTH;
-
-private:
-  using Handlers = std::vector<std::pair<Regex, Handler>>;
-  using HandlersForContentReader =
-      std::vector<std::pair<Regex, HandlerWithContentReader>>;
-
-  static std::unique_ptr<detail::MatcherBase>
-  make_matcher(const std::string &pattern);
-
-  socket_t create_server_socket(const std::string &host, int port,
-                                int socket_flags,
-                                SocketOptions socket_options) const;
-  int bind_internal(const std::string &host, int port, int socket_flags);
-  bool listen_internal();
-
-  bool routing(Request &req, Response &res, Stream &strm);
-  bool handle_file_request(const Request &req, Response &res,
-                           bool head = false);
-  bool dispatch_request(Request &req, Response &res,
-                        const Handlers &handlers) const;
-  bool dispatch_request_for_content_reader(
-      Request &req, Response &res, ContentReader content_reader,
-      const HandlersForContentReader &handlers) const;
-
-  bool parse_request_line(const char *s, Request &req) const;
-  void apply_ranges(const Request &req, Response &res,
-                    std::string &content_type, std::string &boundary) const;
-  bool write_response(Stream &strm, bool close_connection, const Request &req,
-                      Response &res);
-  bool write_response_with_content(Stream &strm, bool close_connection,
-                                   const Request &req, Response &res);
-  bool write_response_core(Stream &strm, bool close_connection,
-                           const Request &req, Response &res,
-                           bool need_apply_ranges);
-  bool write_content_with_provider(Stream &strm, const Request &req,
-                                   Response &res, const std::string &boundary,
-                                   const std::string &content_type);
-  bool read_content(Stream &strm, Request &req, Response &res);
-  bool
-  read_content_with_content_receiver(Stream &strm, Request &req, Response &res,
-                                     ContentReceiver receiver,
-                                     MultipartContentHeader multipart_header,
-                                     ContentReceiver multipart_receiver);
-  bool read_content_core(Stream &strm, Request &req, Response &res,
-                         ContentReceiver receiver,
-                         MultipartContentHeader multipart_header,
-                         ContentReceiver multipart_receiver) const;
-
-  virtual bool process_and_close_socket(socket_t sock);
-
-  std::atomic<bool> is_running_{false};
-  std::atomic<bool> done_{false};
-
-  struct MountPointEntry {
-    std::string mount_point;
-    std::string base_dir;
-    Headers headers;
-  };
-  std::vector<MountPointEntry> base_dirs_;
-  std::map<std::string, std::string> file_extension_and_mimetype_map_;
-  std::string default_file_mimetype_ = "application/octet-stream";
-  Handler file_request_handler_;
-
-  Handlers get_handlers_;
-  Handlers post_handlers_;
-  HandlersForContentReader post_handlers_for_content_reader_;
-  Handlers put_handlers_;
-  HandlersForContentReader put_handlers_for_content_reader_;
-  Handlers patch_handlers_;
-  HandlersForContentReader patch_handlers_for_content_reader_;
-  Handlers delete_handlers_;
-  HandlersForContentReader delete_handlers_for_content_reader_;
-  Handlers options_handlers_;
-
-  HandlerWithResponse error_handler_;
-  ExceptionHandler exception_handler_;
-  HandlerWithResponse pre_routing_handler_;
-  Handler post_routing_handler_;
-  Expect100ContinueHandler expect_100_continue_handler_;
-
-  Logger logger_;
-
-  int address_family_ = AF_UNSPEC;
-  bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;
-  SocketOptions socket_options_ = default_socket_options;
-
-  Headers default_headers_;
-  std::function<ssize_t(Stream &, Headers &)> header_writer_ =
-      detail::write_headers;
-};
-
-enum class Error {
-  Success = 0,
-  Unknown,
-  Connection,
-  BindIPAddress,
-  Read,
-  Write,
-  ExceedRedirectCount,
-  Canceled,
-  SSLConnection,
-  SSLLoadingCerts,
-  SSLServerVerification,
-  UnsupportedMultipartBoundaryChars,
-  Compression,
-  ConnectionTimeout,
-  ProxyConnection,
-
-  // For internal use only
-  SSLPeerCouldBeClosed_,
-};
-
-std::string to_string(Error error);
-
-std::ostream &operator<<(std::ostream &os, const Error &obj);
-
-class Result {
-public:
-  Result() = default;
-  Result(std::unique_ptr<Response> &&res, Error err,
-         Headers &&request_headers = Headers{})
-      : res_(std::move(res)), err_(err),
-        request_headers_(std::move(request_headers)) {}
-  // Response
-  operator bool() const { return res_ != nullptr; }
-  bool operator==(std::nullptr_t) const { return res_ == nullptr; }
-  bool operator!=(std::nullptr_t) const { return res_ != nullptr; }
-  const Response &value() const { return *res_; }
-  Response &value() { return *res_; }
-  const Response &operator*() const { return *res_; }
-  Response &operator*() { return *res_; }
-  const Response *operator->() const { return res_.get(); }
-  Response *operator->() { return res_.get(); }
-
-  // Error
-  Error error() const { return err_; }
-
-  // Request Headers
-  bool has_request_header(const std::string &key) const;
-  std::string get_request_header_value(const std::string &key,
-                                       size_t id = 0) const;
-  uint64_t get_request_header_value_u64(const std::string &key,
-                                        size_t id = 0) const;
-  size_t get_request_header_value_count(const std::string &key) const;
-
-private:
-  std::unique_ptr<Response> res_;
-  Error err_ = Error::Unknown;
-  Headers request_headers_;
-};
-
-class ClientImpl {
-public:
-  explicit ClientImpl(const std::string &host);
-
-  explicit ClientImpl(const std::string &host, int port);
-
-  explicit ClientImpl(const std::string &host, int port,
-                      const std::string &client_cert_path,
-                      const std::string &client_key_path);
-
-  virtual ~ClientImpl();
-
-  virtual bool is_valid() const;
-
-  Result Get(const std::string &path);
-  Result Get(const std::string &path, const Headers &headers);
-  Result Get(const std::string &path, Progress progress);
-  Result Get(const std::string &path, const Headers &headers,
-             Progress progress);
-  Result Get(const std::string &path, ContentReceiver content_receiver);
-  Result Get(const std::string &path, const Headers &headers,
-             ContentReceiver content_receiver);
-  Result Get(const std::string &path, ContentReceiver content_receiver,
-             Progress progress);
-  Result Get(const std::string &path, const Headers &headers,
-             ContentReceiver content_receiver, Progress progress);
-  Result Get(const std::string &path, ResponseHandler response_handler,
-             ContentReceiver content_receiver);
-  Result Get(const std::string &path, const Headers &headers,
-             ResponseHandler response_handler,
-             ContentReceiver content_receiver);
-  Result Get(const std::string &path, ResponseHandler response_handler,
-             ContentReceiver content_receiver, Progress progress);
-  Result Get(const std::string &path, const Headers &headers,
-             ResponseHandler response_handler, ContentReceiver content_receiver,
-             Progress progress);
-
-  Result Get(const std::string &path, const Params &params,
-             const Headers &headers, Progress progress = nullptr);
-  Result Get(const std::string &path, const Params &params,
-             const Headers &headers, ContentReceiver content_receiver,
-             Progress progress = nullptr);
-  Result Get(const std::string &path, const Params &params,
-             const Headers &headers, ResponseHandler response_handler,
-             ContentReceiver content_receiver, Progress progress = nullptr);
-
-  Result Head(const std::string &path);
-  Result Head(const std::string &path, const Headers &headers);
-
-  Result Post(const std::string &path);
-  Result Post(const std::string &path, const Headers &headers);
-  Result Post(const std::string &path, const char *body, size_t content_length,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers, const char *body,
-              size_t content_length, const std::string &content_type);
-  Result Post(const std::string &path, const std::string &body,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers,
-              const std::string &body, const std::string &content_type);
-  Result Post(const std::string &path, size_t content_length,
-              ContentProvider content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path,
-              ContentProviderWithoutLength content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers,
-              size_t content_length, ContentProvider content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers,
-              ContentProviderWithoutLength content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Params &params);
-  Result Post(const std::string &path, const Headers &headers,
-              const Params &params);
-  Result Post(const std::string &path, const MultipartFormDataItems &items);
-  Result Post(const std::string &path, const Headers &headers,
-              const MultipartFormDataItems &items);
-  Result Post(const std::string &path, const Headers &headers,
-              const MultipartFormDataItems &items, const std::string &boundary);
-  Result Post(const std::string &path, const Headers &headers,
-              const MultipartFormDataItems &items,
-              const MultipartFormDataProviderItems &provider_items);
-
-  Result Put(const std::string &path);
-  Result Put(const std::string &path, const char *body, size_t content_length,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers, const char *body,
-             size_t content_length, const std::string &content_type);
-  Result Put(const std::string &path, const std::string &body,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers,
-             const std::string &body, const std::string &content_type);
-  Result Put(const std::string &path, size_t content_length,
-             ContentProvider content_provider, const std::string &content_type);
-  Result Put(const std::string &path,
-             ContentProviderWithoutLength content_provider,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers,
-             size_t content_length, ContentProvider content_provider,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers,
-             ContentProviderWithoutLength content_provider,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Params &params);
-  Result Put(const std::string &path, const Headers &headers,
-             const Params &params);
-  Result Put(const std::string &path, const MultipartFormDataItems &items);
-  Result Put(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items);
-  Result Put(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items, const std::string &boundary);
-  Result Put(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items,
-             const MultipartFormDataProviderItems &provider_items);
-
-  Result Patch(const std::string &path);
-  Result Patch(const std::string &path, const char *body, size_t content_length,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               const char *body, size_t content_length,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const std::string &body,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               const std::string &body, const std::string &content_type);
-  Result Patch(const std::string &path, size_t content_length,
-               ContentProvider content_provider,
-               const std::string &content_type);
-  Result Patch(const std::string &path,
-               ContentProviderWithoutLength content_provider,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               size_t content_length, ContentProvider content_provider,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               ContentProviderWithoutLength content_provider,
-               const std::string &content_type);
-
-  Result Delete(const std::string &path);
-  Result Delete(const std::string &path, const Headers &headers);
-  Result Delete(const std::string &path, const char *body,
-                size_t content_length, const std::string &content_type);
-  Result Delete(const std::string &path, const Headers &headers,
-                const char *body, size_t content_length,
-                const std::string &content_type);
-  Result Delete(const std::string &path, const std::string &body,
-                const std::string &content_type);
-  Result Delete(const std::string &path, const Headers &headers,
-                const std::string &body, const std::string &content_type);
-
-  Result Options(const std::string &path);
-  Result Options(const std::string &path, const Headers &headers);
-
-  bool send(Request &req, Response &res, Error &error);
-  Result send(const Request &req);
-
-  void stop();
-
-  std::string host() const;
-  int port() const;
-
-  size_t is_socket_open() const;
-  socket_t socket() const;
-
-  void set_hostname_addr_map(std::map<std::string, std::string> addr_map);
-
-  void set_default_headers(Headers headers);
-
-  void
-  set_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);
-
-  void set_address_family(int family);
-  void set_tcp_nodelay(bool on);
-  void set_socket_options(SocketOptions socket_options);
-
-  void set_connection_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  void
-  set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  void set_read_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  void set_write_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  void set_basic_auth(const std::string &username, const std::string &password);
-  void set_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void set_digest_auth(const std::string &username,
-                       const std::string &password);
-#endif
-
-  void set_keep_alive(bool on);
-  void set_follow_location(bool on);
-
-  void set_url_encode(bool on);
-
-  void set_compress(bool on);
-
-  void set_decompress(bool on);
-
-  void set_interface(const std::string &intf);
-
-  void set_proxy(const std::string &host, int port);
-  void set_proxy_basic_auth(const std::string &username,
-                            const std::string &password);
-  void set_proxy_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void set_proxy_digest_auth(const std::string &username,
-                             const std::string &password);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void set_ca_cert_path(const std::string &ca_cert_file_path,
-                        const std::string &ca_cert_dir_path = std::string());
-  void set_ca_cert_store(X509_STORE *ca_cert_store);
-  X509_STORE *create_ca_cert_store(const char *ca_cert, std::size_t size) const;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void enable_server_certificate_verification(bool enabled);
-#endif
-
-  void set_logger(Logger logger);
-
-protected:
-  struct Socket {
-    socket_t sock = INVALID_SOCKET;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-    SSL *ssl = nullptr;
-#endif
-
-    bool is_open() const { return sock != INVALID_SOCKET; }
-  };
-
-  virtual bool create_and_connect_socket(Socket &socket, Error &error);
-
-  // All of:
-  //   shutdown_ssl
-  //   shutdown_socket
-  //   close_socket
-  // should ONLY be called when socket_mutex_ is locked.
-  // Also, shutdown_ssl and close_socket should also NOT be called concurrently
-  // with a DIFFERENT thread sending requests using that socket.
-  virtual void shutdown_ssl(Socket &socket, bool shutdown_gracefully);
-  void shutdown_socket(Socket &socket) const;
-  void close_socket(Socket &socket);
-
-  bool process_request(Stream &strm, Request &req, Response &res,
-                       bool close_connection, Error &error);
-
-  bool write_content_with_provider(Stream &strm, const Request &req,
-                                   Error &error) const;
-
-  void copy_settings(const ClientImpl &rhs);
-
-  // Socket endpoint information
-  const std::string host_;
-  const int port_;
-  const std::string host_and_port_;
-
-  // Current open socket
-  Socket socket_;
-  mutable std::mutex socket_mutex_;
-  std::recursive_mutex request_mutex_;
-
-  // These are all protected under socket_mutex
-  size_t socket_requests_in_flight_ = 0;
-  std::thread::id socket_requests_are_from_thread_ = std::thread::id();
-  bool socket_should_be_closed_when_request_is_done_ = false;
-
-  // Hostname-IP map
-  std::map<std::string, std::string> addr_map_;
-
-  // Default headers
-  Headers default_headers_;
-
-  // Header writer
-  std::function<ssize_t(Stream &, Headers &)> header_writer_ =
-      detail::write_headers;
-
-  // Settings
-  std::string client_cert_path_;
-  std::string client_key_path_;
-
-  time_t connection_timeout_sec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND;
-  time_t connection_timeout_usec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND;
-  time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
-  time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
-  time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;
-  time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;
-
-  std::string basic_auth_username_;
-  std::string basic_auth_password_;
-  std::string bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  std::string digest_auth_username_;
-  std::string digest_auth_password_;
-#endif
-
-  bool keep_alive_ = false;
-  bool follow_location_ = false;
-
-  bool url_encode_ = true;
-
-  int address_family_ = AF_UNSPEC;
-  bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;
-  SocketOptions socket_options_ = nullptr;
-
-  bool compress_ = false;
-  bool decompress_ = true;
-
-  std::string interface_;
-
-  std::string proxy_host_;
-  int proxy_port_ = -1;
-
-  std::string proxy_basic_auth_username_;
-  std::string proxy_basic_auth_password_;
-  std::string proxy_bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  std::string proxy_digest_auth_username_;
-  std::string proxy_digest_auth_password_;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  std::string ca_cert_file_path_;
-  std::string ca_cert_dir_path_;
-
-  X509_STORE *ca_cert_store_ = nullptr;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  bool server_certificate_verification_ = true;
-#endif
-
-  Logger logger_;
-
-private:
-  bool send_(Request &req, Response &res, Error &error);
-  Result send_(Request &&req);
-
-  socket_t create_client_socket(Error &error) const;
-  bool read_response_line(Stream &strm, const Request &req,
-                          Response &res) const;
-  bool write_request(Stream &strm, Request &req, bool close_connection,
-                     Error &error);
-  bool redirect(Request &req, Response &res, Error &error);
-  bool handle_request(Stream &strm, Request &req, Response &res,
-                      bool close_connection, Error &error);
-  std::unique_ptr<Response> send_with_content_provider(
-      Request &req, const char *body, size_t content_length,
-      ContentProvider content_provider,
-      ContentProviderWithoutLength content_provider_without_length,
-      const std::string &content_type, Error &error);
-  Result send_with_content_provider(
-      const std::string &method, const std::string &path,
-      const Headers &headers, const char *body, size_t content_length,
-      ContentProvider content_provider,
-      ContentProviderWithoutLength content_provider_without_length,
-      const std::string &content_type);
-  ContentProviderWithoutLength get_multipart_content_provider(
-      const std::string &boundary, const MultipartFormDataItems &items,
-      const MultipartFormDataProviderItems &provider_items) const;
-
-  std::string adjust_host_string(const std::string &host) const;
-
-  virtual bool process_socket(const Socket &socket,
-                              std::function<bool(Stream &strm)> callback);
-  virtual bool is_ssl() const;
-};
-
-class Client {
-public:
-  // Universal interface
-  explicit Client(const std::string &scheme_host_port);
-
-  explicit Client(const std::string &scheme_host_port,
-                  const std::string &client_cert_path,
-                  const std::string &client_key_path);
-
-  // HTTP only interface
-  explicit Client(const std::string &host, int port);
-
-  explicit Client(const std::string &host, int port,
-                  const std::string &client_cert_path,
-                  const std::string &client_key_path);
-
-  Client(Client &&) = default;
-
-  ~Client();
-
-  bool is_valid() const;
-
-  Result Get(const std::string &path);
-  Result Get(const std::string &path, const Headers &headers);
-  Result Get(const std::string &path, Progress progress);
-  Result Get(const std::string &path, const Headers &headers,
-             Progress progress);
-  Result Get(const std::string &path, ContentReceiver content_receiver);
-  Result Get(const std::string &path, const Headers &headers,
-             ContentReceiver content_receiver);
-  Result Get(const std::string &path, ContentReceiver content_receiver,
-             Progress progress);
-  Result Get(const std::string &path, const Headers &headers,
-             ContentReceiver content_receiver, Progress progress);
-  Result Get(const std::string &path, ResponseHandler response_handler,
-             ContentReceiver content_receiver);
-  Result Get(const std::string &path, const Headers &headers,
-             ResponseHandler response_handler,
-             ContentReceiver content_receiver);
-  Result Get(const std::string &path, const Headers &headers,
-             ResponseHandler response_handler, ContentReceiver content_receiver,
-             Progress progress);
-  Result Get(const std::string &path, ResponseHandler response_handler,
-             ContentReceiver content_receiver, Progress progress);
-
-  Result Get(const std::string &path, const Params &params,
-             const Headers &headers, Progress progress = nullptr);
-  Result Get(const std::string &path, const Params &params,
-             const Headers &headers, ContentReceiver content_receiver,
-             Progress progress = nullptr);
-  Result Get(const std::string &path, const Params &params,
-             const Headers &headers, ResponseHandler response_handler,
-             ContentReceiver content_receiver, Progress progress = nullptr);
-
-  Result Head(const std::string &path);
-  Result Head(const std::string &path, const Headers &headers);
-
-  Result Post(const std::string &path);
-  Result Post(const std::string &path, const Headers &headers);
-  Result Post(const std::string &path, const char *body, size_t content_length,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers, const char *body,
-              size_t content_length, const std::string &content_type);
-  Result Post(const std::string &path, const std::string &body,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers,
-              const std::string &body, const std::string &content_type);
-  Result Post(const std::string &path, size_t content_length,
-              ContentProvider content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path,
-              ContentProviderWithoutLength content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers,
-              size_t content_length, ContentProvider content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Headers &headers,
-              ContentProviderWithoutLength content_provider,
-              const std::string &content_type);
-  Result Post(const std::string &path, const Params &params);
-  Result Post(const std::string &path, const Headers &headers,
-              const Params &params);
-  Result Post(const std::string &path, const MultipartFormDataItems &items);
-  Result Post(const std::string &path, const Headers &headers,
-              const MultipartFormDataItems &items);
-  Result Post(const std::string &path, const Headers &headers,
-              const MultipartFormDataItems &items, const std::string &boundary);
-  Result Post(const std::string &path, const Headers &headers,
-              const MultipartFormDataItems &items,
-              const MultipartFormDataProviderItems &provider_items);
-
-  Result Put(const std::string &path);
-  Result Put(const std::string &path, const char *body, size_t content_length,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers, const char *body,
-             size_t content_length, const std::string &content_type);
-  Result Put(const std::string &path, const std::string &body,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers,
-             const std::string &body, const std::string &content_type);
-  Result Put(const std::string &path, size_t content_length,
-             ContentProvider content_provider, const std::string &content_type);
-  Result Put(const std::string &path,
-             ContentProviderWithoutLength content_provider,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers,
-             size_t content_length, ContentProvider content_provider,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Headers &headers,
-             ContentProviderWithoutLength content_provider,
-             const std::string &content_type);
-  Result Put(const std::string &path, const Params &params);
-  Result Put(const std::string &path, const Headers &headers,
-             const Params &params);
-  Result Put(const std::string &path, const MultipartFormDataItems &items);
-  Result Put(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items);
-  Result Put(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items, const std::string &boundary);
-  Result Put(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items,
-             const MultipartFormDataProviderItems &provider_items);
-
-  Result Patch(const std::string &path);
-  Result Patch(const std::string &path, const char *body, size_t content_length,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               const char *body, size_t content_length,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const std::string &body,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               const std::string &body, const std::string &content_type);
-  Result Patch(const std::string &path, size_t content_length,
-               ContentProvider content_provider,
-               const std::string &content_type);
-  Result Patch(const std::string &path,
-               ContentProviderWithoutLength content_provider,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               size_t content_length, ContentProvider content_provider,
-               const std::string &content_type);
-  Result Patch(const std::string &path, const Headers &headers,
-               ContentProviderWithoutLength content_provider,
-               const std::string &content_type);
-
-  Result Delete(const std::string &path);
-  Result Delete(const std::string &path, const Headers &headers);
-  Result Delete(const std::string &path, const char *body,
-                size_t content_length, const std::string &content_type);
-  Result Delete(const std::string &path, const Headers &headers,
-                const char *body, size_t content_length,
-                const std::string &content_type);
-  Result Delete(const std::string &path, const std::string &body,
-                const std::string &content_type);
-  Result Delete(const std::string &path, const Headers &headers,
-                const std::string &body, const std::string &content_type);
-
-  Result Options(const std::string &path);
-  Result Options(const std::string &path, const Headers &headers);
-
-  bool send(Request &req, Response &res, Error &error);
-  Result send(const Request &req);
-
-  void stop();
-
-  std::string host() const;
-  int port() const;
-
-  size_t is_socket_open() const;
-  socket_t socket() const;
-
-  void set_hostname_addr_map(std::map<std::string, std::string> addr_map);
-
-  void set_default_headers(Headers headers);
-
-  void
-  set_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);
-
-  void set_address_family(int family);
-  void set_tcp_nodelay(bool on);
-  void set_socket_options(SocketOptions socket_options);
-
-  void set_connection_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  void
-  set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  void set_read_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  void set_write_timeout(time_t sec, time_t usec = 0);
-  template <class Rep, class Period>
-  void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-  void set_basic_auth(const std::string &username, const std::string &password);
-  void set_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void set_digest_auth(const std::string &username,
-                       const std::string &password);
-#endif
-
-  void set_keep_alive(bool on);
-  void set_follow_location(bool on);
-
-  void set_url_encode(bool on);
-
-  void set_compress(bool on);
-
-  void set_decompress(bool on);
-
-  void set_interface(const std::string &intf);
-
-  void set_proxy(const std::string &host, int port);
-  void set_proxy_basic_auth(const std::string &username,
-                            const std::string &password);
-  void set_proxy_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void set_proxy_digest_auth(const std::string &username,
-                             const std::string &password);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void enable_server_certificate_verification(bool enabled);
-#endif
-
-  void set_logger(Logger logger);
-
-  // SSL
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  void set_ca_cert_path(const std::string &ca_cert_file_path,
-                        const std::string &ca_cert_dir_path = std::string());
-
-  void set_ca_cert_store(X509_STORE *ca_cert_store);
-  void load_ca_cert_store(const char *ca_cert, std::size_t size);
-
-  long get_openssl_verify_result() const;
-
-  SSL_CTX *ssl_context() const;
-#endif
-
-private:
-  std::unique_ptr<ClientImpl> cli_;
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  bool is_ssl_ = false;
-#endif
-};
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLServer : public Server {
-public:
-  SSLServer(const char *cert_path, const char *private_key_path,
-            const char *client_ca_cert_file_path = nullptr,
-            const char *client_ca_cert_dir_path = nullptr,
-            const char *private_key_password = nullptr);
-
-  SSLServer(X509 *cert, EVP_PKEY *private_key,
-            X509_STORE *client_ca_cert_store = nullptr);
-
-  SSLServer(
-      const std::function<bool(SSL_CTX &ssl_ctx)> &setup_ssl_ctx_callback);
-
-  ~SSLServer() override;
-
-  bool is_valid() const override;
-
-  SSL_CTX *ssl_context() const;
-
-private:
-  bool process_and_close_socket(socket_t sock) override;
-
-  SSL_CTX *ctx_;
-  std::mutex ctx_mutex_;
-};
-
-class SSLClient : public ClientImpl {
-public:
-  explicit SSLClient(const std::string &host);
-
-  explicit SSLClient(const std::string &host, int port);
-
-  explicit SSLClient(const std::string &host, int port,
-                     const std::string &client_cert_path,
-                     const std::string &client_key_path);
-
-  explicit SSLClient(const std::string &host, int port, X509 *client_cert,
-                     EVP_PKEY *client_key);
-
-  ~SSLClient() override;
-
-  bool is_valid() const override;
-
-  void set_ca_cert_store(X509_STORE *ca_cert_store);
-  void load_ca_cert_store(const char *ca_cert, std::size_t size);
-
-  long get_openssl_verify_result() const;
-
-  SSL_CTX *ssl_context() const;
-
-private:
-  bool create_and_connect_socket(Socket &socket, Error &error) override;
-  void shutdown_ssl(Socket &socket, bool shutdown_gracefully) override;
-  void shutdown_ssl_impl(Socket &socket, bool shutdown_gracefully);
-
-  bool process_socket(const Socket &socket,
-                      std::function<bool(Stream &strm)> callback) override;
-  bool is_ssl() const override;
-
-  bool connect_with_proxy(Socket &sock, Response &res, bool &success,
-                          Error &error);
-  bool initialize_ssl(Socket &socket, Error &error);
-
-  bool load_certs();
-
-  bool verify_host(X509 *server_cert) const;
-  bool verify_host_with_subject_alt_name(X509 *server_cert) const;
-  bool verify_host_with_common_name(X509 *server_cert) const;
-  bool check_host_name(const char *pattern, size_t pattern_len) const;
-
-  SSL_CTX *ctx_;
-  std::mutex ctx_mutex_;
-  std::once_flag initialize_cert_;
-
-  std::vector<std::string> host_components_;
-
-  long verify_result_ = 0;
-
-  friend class ClientImpl;
-};
-#endif
-
-/*
- * Implementation of template methods.
- */
-
-namespace detail {
-
-template <typename T, typename U>
-inline void duration_to_sec_and_usec(const T &duration, U callback) {
-  auto sec = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-  auto usec = std::chrono::duration_cast<std::chrono::microseconds>(
-                  duration - std::chrono::seconds(sec))
-                  .count();
-  callback(static_cast<time_t>(sec), static_cast<time_t>(usec));
-}
-
-inline uint64_t get_header_value_u64(const Headers &headers,
-                                     const std::string &key, size_t id,
-                                     uint64_t def) {
-  auto rng = headers.equal_range(key);
-  auto it = rng.first;
-  std::advance(it, static_cast<ssize_t>(id));
-  if (it != rng.second) {
-    return std::strtoull(it->second.data(), nullptr, 10);
-  }
-  return def;
-}
-
-} // namespace detail
-
-inline uint64_t Request::get_header_value_u64(const std::string &key,
-                                              size_t id) const {
-  return detail::get_header_value_u64(headers, key, id, 0);
-}
-
-inline uint64_t Response::get_header_value_u64(const std::string &key,
-                                               size_t id) const {
-  return detail::get_header_value_u64(headers, key, id, 0);
-}
-
-template <typename... Args>
-inline ssize_t Stream::write_format(const char *fmt, const Args &...args) {
-  const auto bufsiz = 2048;
-  std::array<char, bufsiz> buf{};
-
-  auto sn = snprintf(buf.data(), buf.size() - 1, fmt, args...);
-  if (sn <= 0) { return sn; }
-
-  auto n = static_cast<size_t>(sn);
-
-  if (n >= buf.size() - 1) {
-    std::vector<char> glowable_buf(buf.size());
-
-    while (n >= glowable_buf.size() - 1) {
-      glowable_buf.resize(glowable_buf.size() * 2);
-      n = static_cast<size_t>(
-          snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...));
-    }
-    return write(&glowable_buf[0], n);
-  } else {
-    return write(buf.data(), n);
-  }
-}
-
-inline void default_socket_options(socket_t sock) {
-  int yes = 1;
-#ifdef _WIN32
-  setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
-             reinterpret_cast<const char *>(&yes), sizeof(yes));
-  setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
-             reinterpret_cast<const char *>(&yes), sizeof(yes));
-#else
-#ifdef SO_REUSEPORT
-  setsockopt(sock, SOL_SOCKET, SO_REUSEPORT,
-             reinterpret_cast<const void *>(&yes), sizeof(yes));
-#else
-  setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
-             reinterpret_cast<const void *>(&yes), sizeof(yes));
-#endif
-#endif
-}
-
-inline const char *status_message(int status) {
-  switch (status) {
-  case StatusCode::Continue_100: return "Continue";
-  case StatusCode::SwitchingProtocol_101: return "Switching Protocol";
-  case StatusCode::Processing_102: return "Processing";
-  case StatusCode::EarlyHints_103: return "Early Hints";
-  case StatusCode::OK_200: return "OK";
-  case StatusCode::Created_201: return "Created";
-  case StatusCode::Accepted_202: return "Accepted";
-  case StatusCode::NonAuthoritativeInformation_203:
-    return "Non-Authoritative Information";
-  case StatusCode::NoContent_204: return "No Content";
-  case StatusCode::ResetContent_205: return "Reset Content";
-  case StatusCode::PartialContent_206: return "Partial Content";
-  case StatusCode::MultiStatus_207: return "Multi-Status";
-  case StatusCode::AlreadyReported_208: return "Already Reported";
-  case StatusCode::IMUsed_226: return "IM Used";
-  case StatusCode::MultipleChoices_300: return "Multiple Choices";
-  case StatusCode::MovedPermanently_301: return "Moved Permanently";
-  case StatusCode::Found_302: return "Found";
-  case StatusCode::SeeOther_303: return "See Other";
-  case StatusCode::NotModified_304: return "Not Modified";
-  case StatusCode::UseProxy_305: return "Use Proxy";
-  case StatusCode::unused_306: return "unused";
-  case StatusCode::TemporaryRedirect_307: return "Temporary Redirect";
-  case StatusCode::PermanentRedirect_308: return "Permanent Redirect";
-  case StatusCode::BadRequest_400: return "Bad Request";
-  case StatusCode::Unauthorized_401: return "Unauthorized";
-  case StatusCode::PaymentRequired_402: return "Payment Required";
-  case StatusCode::Forbidden_403: return "Forbidden";
-  case StatusCode::NotFound_404: return "Not Found";
-  case StatusCode::MethodNotAllowed_405: return "Method Not Allowed";
-  case StatusCode::NotAcceptable_406: return "Not Acceptable";
-  case StatusCode::ProxyAuthenticationRequired_407:
-    return "Proxy Authentication Required";
-  case StatusCode::RequestTimeout_408: return "Request Timeout";
-  case StatusCode::Conflict_409: return "Conflict";
-  case StatusCode::Gone_410: return "Gone";
-  case StatusCode::LengthRequired_411: return "Length Required";
-  case StatusCode::PreconditionFailed_412: return "Precondition Failed";
-  case StatusCode::PayloadTooLarge_413: return "Payload Too Large";
-  case StatusCode::UriTooLong_414: return "URI Too Long";
-  case StatusCode::UnsupportedMediaType_415: return "Unsupported Media Type";
-  case StatusCode::RangeNotSatisfiable_416: return "Range Not Satisfiable";
-  case StatusCode::ExpectationFailed_417: return "Expectation Failed";
-  case StatusCode::ImATeapot_418: return "I'm a teapot";
-  case StatusCode::MisdirectedRequest_421: return "Misdirected Request";
-  case StatusCode::UnprocessableContent_422: return "Unprocessable Content";
-  case StatusCode::Locked_423: return "Locked";
-  case StatusCode::FailedDependency_424: return "Failed Dependency";
-  case StatusCode::TooEarly_425: return "Too Early";
-  case StatusCode::UpgradeRequired_426: return "Upgrade Required";
-  case StatusCode::PreconditionRequired_428: return "Precondition Required";
-  case StatusCode::TooManyRequests_429: return "Too Many Requests";
-  case StatusCode::RequestHeaderFieldsTooLarge_431:
-    return "Request Header Fields Too Large";
-  case StatusCode::UnavailableForLegalReasons_451:
-    return "Unavailable For Legal Reasons";
-  case StatusCode::NotImplemented_501: return "Not Implemented";
-  case StatusCode::BadGateway_502: return "Bad Gateway";
-  case StatusCode::ServiceUnavailable_503: return "Service Unavailable";
-  case StatusCode::GatewayTimeout_504: return "Gateway Timeout";
-  case StatusCode::HttpVersionNotSupported_505:
-    return "HTTP Version Not Supported";
-  case StatusCode::VariantAlsoNegotiates_506: return "Variant Also Negotiates";
-  case StatusCode::InsufficientStorage_507: return "Insufficient Storage";
-  case StatusCode::LoopDetected_508: return "Loop Detected";
-  case StatusCode::NotExtended_510: return "Not Extended";
-  case StatusCode::NetworkAuthenticationRequired_511:
-    return "Network Authentication Required";
-
-  default:
-  case StatusCode::InternalServerError_500: return "Internal Server Error";
-  }
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {
-  detail::duration_to_sec_and_usec(
-      duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });
-  return *this;
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_write_timeout(const std::chrono::duration<Rep, Period> &duration) {
-  detail::duration_to_sec_and_usec(
-      duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); });
-  return *this;
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_idle_interval(const std::chrono::duration<Rep, Period> &duration) {
-  detail::duration_to_sec_and_usec(
-      duration, [&](time_t sec, time_t usec) { set_idle_interval(sec, usec); });
-  return *this;
-}
-
-inline std::string to_string(const Error error) {
-  switch (error) {
-  case Error::Success: return "Success (no error)";
-  case Error::Connection: return "Could not establish connection";
-  case Error::BindIPAddress: return "Failed to bind IP address";
-  case Error::Read: return "Failed to read connection";
-  case Error::Write: return "Failed to write connection";
-  case Error::ExceedRedirectCount: return "Maximum redirect count exceeded";
-  case Error::Canceled: return "Connection handling canceled";
-  case Error::SSLConnection: return "SSL connection failed";
-  case Error::SSLLoadingCerts: return "SSL certificate loading failed";
-  case Error::SSLServerVerification: return "SSL server verification failed";
-  case Error::UnsupportedMultipartBoundaryChars:
-    return "Unsupported HTTP multipart boundary characters";
-  case Error::Compression: return "Compression failed";
-  case Error::ConnectionTimeout: return "Connection timed out";
-  case Error::ProxyConnection: return "Proxy connection failed";
-  case Error::Unknown: return "Unknown";
-  default: break;
-  }
-
-  return "Invalid";
-}
-
-inline std::ostream &operator<<(std::ostream &os, const Error &obj) {
-  os << to_string(obj);
-  os << " (" << static_cast<std::underlying_type<Error>::type>(obj) << ')';
-  return os;
-}
-
-inline uint64_t Result::get_request_header_value_u64(const std::string &key,
-                                                     size_t id) const {
-  return detail::get_header_value_u64(request_headers_, key, id, 0);
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_connection_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-  detail::duration_to_sec_and_usec(duration, [&](time_t sec, time_t usec) {
-    set_connection_timeout(sec, usec);
-  });
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_read_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-  detail::duration_to_sec_and_usec(
-      duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_write_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-  detail::duration_to_sec_and_usec(
-      duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); });
-}
-
-template <class Rep, class Period>
-inline void Client::set_connection_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-  cli_->set_connection_timeout(duration);
-}
-
-template <class Rep, class Period>
-inline void
-Client::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {
-  cli_->set_read_timeout(duration);
-}
-
-template <class Rep, class Period>
-inline void
-Client::set_write_timeout(const std::chrono::duration<Rep, Period> &duration) {
-  cli_->set_write_timeout(duration);
-}
-
-/*
- * Forward declarations and types that will be part of the .h file if split into
- * .h + .cc.
- */
-
-std::string hosted_at(const std::string &hostname);
-
-void hosted_at(const std::string &hostname, std::vector<std::string> &addrs);
-
-std::string append_query_params(const std::string &path, const Params &params);
-
-std::pair<std::string, std::string> make_range_header(Ranges ranges);
-
-std::pair<std::string, std::string>
-make_basic_authentication_header(const std::string &username,
-                                 const std::string &password,
-                                 bool is_proxy = false);
-
-namespace detail {
-
-std::string encode_query_param(const std::string &value);
-
-std::string decode_url(const std::string &s, bool convert_plus_to_space, const std::set<char> &exclude = {});
-void read_file(const std::string &path, std::string &out);
-
-std::string trim_copy(const std::string &s);
-
-void split(const char *b, const char *e, char d,
-           std::function<void(const char *, const char *)> fn);
-
-void split(const char *b, const char *e, char d, size_t m,
-           std::function<void(const char *, const char *)> fn);
-
-bool process_client_socket(socket_t sock, time_t read_timeout_sec,
-                           time_t read_timeout_usec, time_t write_timeout_sec,
-                           time_t write_timeout_usec,
-                           std::function<bool(Stream &)> callback);
-
-socket_t create_client_socket(
-    const std::string &host, const std::string &ip, int port,
-    int address_family, bool tcp_nodelay, SocketOptions socket_options,
-    time_t connection_timeout_sec, time_t connection_timeout_usec,
-    time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
-    time_t write_timeout_usec, const std::string &intf, Error &error);
-
-const char *get_header_value(const Headers &headers, const std::string &key,
-                             size_t id = 0, const char *def = nullptr);
-
-std::string params_to_query_str(const Params &params);
-
-void parse_query_text(const std::string &s, Params &params);
-
-bool parse_multipart_boundary(const std::string &content_type,
-                              std::string &boundary);
-
-bool parse_range_header(const std::string &s, Ranges &ranges);
-
-int close_socket(socket_t sock);
-
-ssize_t send_socket(socket_t sock, const void *ptr, size_t size, int flags);
-
-ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags);
-
-enum class EncodingType { None = 0, Gzip, Brotli };
-
-EncodingType encoding_type(const Request &req, const Response &res);
-
-class BufferStream : public Stream {
-public:
-  BufferStream() = default;
-  ~BufferStream() override = default;
-
-  bool is_readable() const override;
-  bool is_writable() const override;
-  ssize_t read(char *ptr, size_t size) override;
-  ssize_t write(const char *ptr, size_t size) override;
-  void get_remote_ip_and_port(std::string &ip, int &port) const override;
-  void get_local_ip_and_port(std::string &ip, int &port) const override;
-  socket_t socket() const override;
-
-  const std::string &get_buffer() const;
-
-private:
-  std::string buffer;
-  size_t position = 0;
-};
-
-class compressor {
-public:
-  virtual ~compressor() = default;
-
-  typedef std::function<bool(const char *data, size_t data_len)> Callback;
-  virtual bool compress(const char *data, size_t data_length, bool last,
-                        Callback callback) = 0;
-};
-
-class decompressor {
-public:
-  virtual ~decompressor() = default;
-
-  virtual bool is_valid() const = 0;
-
-  typedef std::function<bool(const char *data, size_t data_len)> Callback;
-  virtual bool decompress(const char *data, size_t data_length,
-                          Callback callback) = 0;
-};
-
-class nocompressor : public compressor {
-public:
-  ~nocompressor() override = default;
-
-  bool compress(const char *data, size_t data_length, bool /*last*/,
-                Callback callback) override;
-};
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-class gzip_compressor : public compressor {
-public:
-  gzip_compressor();
-  ~gzip_compressor() override;
-
-  bool compress(const char *data, size_t data_length, bool last,
-                Callback callback) override;
-
-private:
-  bool is_valid_ = false;
-  z_stream strm_;
-};
-
-class gzip_decompressor : public decompressor {
-public:
-  gzip_decompressor();
-  ~gzip_decompressor() override;
-
-  bool is_valid() const override;
-
-  bool decompress(const char *data, size_t data_length,
-                  Callback callback) override;
-
-private:
-  bool is_valid_ = false;
-  z_stream strm_;
-};
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-class brotli_compressor : public compressor {
-public:
-  brotli_compressor();
-  ~brotli_compressor();
-
-  bool compress(const char *data, size_t data_length, bool last,
-                Callback callback) override;
-
-private:
-  BrotliEncoderState *state_ = nullptr;
-};
-
-class brotli_decompressor : public decompressor {
-public:
-  brotli_decompressor();
-  ~brotli_decompressor();
-
-  bool is_valid() const override;
-
-  bool decompress(const char *data, size_t data_length,
-                  Callback callback) override;
-
-private:
-  BrotliDecoderResult decoder_r;
-  BrotliDecoderState *decoder_s = nullptr;
-};
-#endif
-
-// NOTE: until the read size reaches `fixed_buffer_size`, use `fixed_buffer`
-// to store data. The call can set memory on stack for performance.
-class stream_line_reader {
-public:
-  stream_line_reader(Stream &strm, char *fixed_buffer,
-                     size_t fixed_buffer_size);
-  const char *ptr() const;
-  size_t size() const;
-  bool end_with_crlf() const;
-  bool getline();
-
-private:
-  void append(char c);
-
-  Stream &strm_;
-  char *fixed_buffer_;
-  const size_t fixed_buffer_size_;
-  size_t fixed_buffer_used_size_ = 0;
-  std::string glowable_buffer_;
-};
-
-class mmap {
-public:
-  mmap(const char *path);
-  ~mmap();
-
-  bool open(const char *path);
-  void close();
-
-  bool is_open() const;
-  size_t size() const;
-  const char *data() const;
-
-private:
-#if defined(_WIN32)
-  HANDLE hFile_;
-  HANDLE hMapping_;
-#else
-  int fd_;
-#endif
-  size_t size_;
-  void *addr_;
-};
-
-} // namespace detail
-
-// ----------------------------------------------------------------------------
-
-/*
- * Implementation that will be part of the .cc file if split into .h + .cc.
- */
-
-namespace detail {
-
-inline bool is_hex(char c, int &v) {
-  if (0x20 <= c && isdigit(c)) {
-    v = c - '0';
-    return true;
-  } else if ('A' <= c && c <= 'F') {
-    v = c - 'A' + 10;
-    return true;
-  } else if ('a' <= c && c <= 'f') {
-    v = c - 'a' + 10;
-    return true;
-  }
-  return false;
-}
-
-inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt,
-                          int &val) {
-  if (i >= s.size()) { return false; }
-
-  val = 0;
-  for (; cnt; i++, cnt--) {
-    if (!s[i]) { return false; }
-    auto v = 0;
-    if (is_hex(s[i], v)) {
-      val = val * 16 + v;
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-inline std::string from_i_to_hex(size_t n) {
-  static const auto charset = "0123456789abcdef";
-  std::string ret;
-  do {
-    ret = charset[n & 15] + ret;
-    n >>= 4;
-  } while (n > 0);
-  return ret;
-}
-
-inline size_t to_utf8(int code, char *buff) {
-  if (code < 0x0080) {
-    buff[0] = static_cast<char>(code & 0x7F);
-    return 1;
-  } else if (code < 0x0800) {
-    buff[0] = static_cast<char>(0xC0 | ((code >> 6) & 0x1F));
-    buff[1] = static_cast<char>(0x80 | (code & 0x3F));
-    return 2;
-  } else if (code < 0xD800) {
-    buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
-    buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
-    buff[2] = static_cast<char>(0x80 | (code & 0x3F));
-    return 3;
-  } else if (code < 0xE000) { // D800 - DFFF is invalid...
-    return 0;
-  } else if (code < 0x10000) {
-    buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
-    buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
-    buff[2] = static_cast<char>(0x80 | (code & 0x3F));
-    return 3;
-  } else if (code < 0x110000) {
-    buff[0] = static_cast<char>(0xF0 | ((code >> 18) & 0x7));
-    buff[1] = static_cast<char>(0x80 | ((code >> 12) & 0x3F));
-    buff[2] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
-    buff[3] = static_cast<char>(0x80 | (code & 0x3F));
-    return 4;
-  }
-
-  // NOTREACHED
-  return 0;
-}
-
-// NOTE: This code came up with the following stackoverflow post:
-// https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c
-inline std::string base64_encode(const std::string &in) {
-  static const auto lookup =
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-  std::string out;
-  out.reserve(in.size());
-
-  unsigned int val = 0;
-  int valb = -6;
-
-  for (auto c : in) {
-    val = (val << 8) + static_cast<uint8_t>(c);
-    valb += 8;
-    while (valb >= 0) {
-      out.push_back(lookup[(val >> valb) & 0x3F]);
-      valb -= 6;
-    }
-  }
-
-  if (valb > -6) { out.push_back(lookup[((val << 8) >> (valb + 8)) & 0x3F]); }
-
-  while (out.size() % 4) {
-    out.push_back('=');
-  }
-
-  return out;
-}
-
-inline bool is_file(const std::string &path) {
-#ifdef _WIN32
-  return _access_s(path.c_str(), 0) == 0;
-#else
-  struct stat st;
-  return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode);
-#endif
-}
-
-inline bool is_dir(const std::string &path) {
-  struct stat st;
-  return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode);
-}
-
-inline bool is_valid_path(const std::string &path) {
-  size_t level = 0;
-  size_t i = 0;
-
-  // Skip slash
-  while (i < path.size() && path[i] == '/') {
-    i++;
-  }
-
-  while (i < path.size()) {
-    // Read component
-    auto beg = i;
-    while (i < path.size() && path[i] != '/') {
-      i++;
-    }
-
-    auto len = i - beg;
-    assert(len > 0);
-
-    if (!path.compare(beg, len, ".")) {
-      ;
-    } else if (!path.compare(beg, len, "..")) {
-      if (level == 0) { return false; }
-      level--;
-    } else {
-      level++;
-    }
-
-    // Skip slash
-    while (i < path.size() && path[i] == '/') {
-      i++;
-    }
-  }
-
-  return true;
-}
-
-inline std::string encode_query_param(const std::string &value) {
-  std::ostringstream escaped;
-  escaped.fill('0');
-  escaped << std::hex;
-
-  for (auto c : value) {
-    if (std::isalnum(static_cast<uint8_t>(c)) || c == '-' || c == '_' ||
-        c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' ||
-        c == ')') {
-      escaped << c;
-    } else {
-      escaped << std::uppercase;
-      escaped << '%' << std::setw(2)
-              << static_cast<int>(static_cast<unsigned char>(c));
-      escaped << std::nouppercase;
-    }
-  }
-
-  return escaped.str();
-}
-
-inline std::string encode_url(const std::string &s) {
-  std::string result;
-  result.reserve(s.size());
-
-  for (size_t i = 0; s[i]; i++) {
-    switch (s[i]) {
-    case ' ': result += "%20"; break;
-    case '+': result += "%2B"; break;
-    case '\r': result += "%0D"; break;
-    case '\n': result += "%0A"; break;
-    case '\'': result += "%27"; break;
-    case ',': result += "%2C"; break;
-    // case ':': result += "%3A"; break; // ok? probably...
-    case ';': result += "%3B"; break;
-    default:
-      auto c = static_cast<uint8_t>(s[i]);
-      if (c >= 0x80) {
-        result += '%';
-        char hex[4];
-        auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c);
-        assert(len == 2);
-        result.append(hex, static_cast<size_t>(len));
-      } else {
-        result += s[i];
-      }
-      break;
-    }
-  }
-
-  return result;
-}
-
-inline std::string decode_url(const std::string &s,
-                              bool convert_plus_to_space,
-                              const std::set<char> &exclude) {
-  std::string result;
-
-  for (size_t i = 0; i < s.size(); i++) {
-    if (s[i] == '%' && i + 1 < s.size()) {
-      if (s[i + 1] == 'u') {
-        auto val = 0;
-        if (from_hex_to_i(s, i + 2, 4, val)) {
-          // 4 digits Unicode codes
-          char buff[4];
-          size_t len = to_utf8(val, buff);
-          if (len > 0) { result.append(buff, len); }
-          i += 5; // 'u0000'
-        } else {
-          result += s[i];
-        }
-      } else {
-        auto val = 0;
-        if (from_hex_to_i(s, i + 1, 2, val)) {
-          const auto converted = static_cast<char>(val);
-          if (exclude.count(converted) == 0) {
-            result += converted;
-          } else {
-            result.append(s, i, 3);
-          }
-          i += 2; // '00'
-        } else {
-          result += s[i];
-        }
-      }
-    } else if (convert_plus_to_space && s[i] == '+') {
-      result += ' ';
-    } else {
-      result += s[i];
-    }
-  }
-
-  return result;
-}
-
-inline void read_file(const std::string &path, std::string &out) {
-  std::ifstream fs(path, std::ios_base::binary);
-  fs.seekg(0, std::ios_base::end);
-  auto size = fs.tellg();
-  fs.seekg(0);
-  out.resize(static_cast<size_t>(size));
-  fs.read(&out[0], static_cast<std::streamsize>(size));
-}
-
-inline std::string file_extension(const std::string &path) {
-  Match m;
-  static auto re = Regex("\\.([a-zA-Z0-9]+)$");
-  if (duckdb_re2::RegexSearch(path, m, re)) { return m[1].str(); }
-  return std::string();
-}
-
-inline bool is_space_or_tab(char c) { return c == ' ' || c == '\t'; }
-
-inline std::pair<size_t, size_t> trim(const char *b, const char *e, size_t left,
-                                      size_t right) {
-  while (b + left < e && is_space_or_tab(b[left])) {
-    left++;
-  }
-  while (right > 0 && is_space_or_tab(b[right - 1])) {
-    right--;
-  }
-  return std::make_pair(left, right);
-}
-
-inline std::string trim_copy(const std::string &s) {
-  auto r = trim(s.data(), s.data() + s.size(), 0, s.size());
-  return s.substr(r.first, r.second - r.first);
-}
-
-inline std::string trim_double_quotes_copy(const std::string &s) {
-  if (s.length() >= 2 && s.front() == '"' && s.back() == '"') {
-    return s.substr(1, s.size() - 2);
-  }
-  return s;
-}
-
-inline void split(const char *b, const char *e, char d,
-                  std::function<void(const char *, const char *)> fn) {
-  return split(b, e, d, std::numeric_limits<size_t>::max(), fn);
-}
-
-inline void split(const char *b, const char *e, char d, size_t m,
-                  std::function<void(const char *, const char *)> fn) {
-  size_t i = 0;
-  size_t beg = 0;
-  size_t count = 1;
-
-  while (e ? (b + i < e) : (b[i] != '\0')) {
-    if (b[i] == d && count < m) {
-      auto r = trim(b, e, beg, i);
-      if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
-      beg = i + 1;
-      count++;
-    }
-    i++;
-  }
-
-  if (i) {
-    auto r = trim(b, e, beg, i);
-    if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
-  }
-}
-
-inline stream_line_reader::stream_line_reader(Stream &strm, char *fixed_buffer,
-                                              size_t fixed_buffer_size)
-    : strm_(strm), fixed_buffer_(fixed_buffer),
-      fixed_buffer_size_(fixed_buffer_size) {}
-
-inline const char *stream_line_reader::ptr() const {
-  if (glowable_buffer_.empty()) {
-    return fixed_buffer_;
-  } else {
-    return glowable_buffer_.data();
-  }
-}
-
-inline size_t stream_line_reader::size() const {
-  if (glowable_buffer_.empty()) {
-    return fixed_buffer_used_size_;
-  } else {
-    return glowable_buffer_.size();
-  }
-}
-
-inline bool stream_line_reader::end_with_crlf() const {
-  auto end = ptr() + size();
-  return size() >= 2 && end[-2] == '\r' && end[-1] == '\n';
-}
-
-inline bool stream_line_reader::getline() {
-  fixed_buffer_used_size_ = 0;
-  glowable_buffer_.clear();
-
-  for (size_t i = 0;; i++) {
-    char byte;
-    auto n = strm_.read(&byte, 1);
-
-    if (n < 0) {
-      return false;
-    } else if (n == 0) {
-      if (i == 0) {
-        return false;
-      } else {
-        break;
-      }
-    }
-
-    append(byte);
-
-    if (byte == '\n') { break; }
-  }
-
-  return true;
-}
-
-inline void stream_line_reader::append(char c) {
-  if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) {
-    fixed_buffer_[fixed_buffer_used_size_++] = c;
-    fixed_buffer_[fixed_buffer_used_size_] = '\0';
-  } else {
-    if (glowable_buffer_.empty()) {
-      assert(fixed_buffer_[fixed_buffer_used_size_] == '\0');
-      glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_);
-    }
-    glowable_buffer_ += c;
-  }
-}
-
-inline mmap::mmap(const char *path)
-#if defined(_WIN32)
-    : hFile_(NULL), hMapping_(NULL)
-#else
-    : fd_(-1)
-#endif
-      ,
-      size_(0), addr_(nullptr) {
-  open(path);
-}
-
-inline mmap::~mmap() { close(); }
-
-inline bool mmap::open(const char *path) {
-  close();
-
-#if defined(_WIN32)
-  hFile_ = ::CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL,
-                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
-  if (hFile_ == INVALID_HANDLE_VALUE) { return false; }
-
-  size_ = ::GetFileSize(hFile_, NULL);
-
-  hMapping_ = ::CreateFileMapping(hFile_, NULL, PAGE_READONLY, 0, 0, NULL);
-
-  if (hMapping_ == NULL) {
-    close();
-    return false;
-  }
-
-  addr_ = ::MapViewOfFile(hMapping_, FILE_MAP_READ, 0, 0, 0);
-#else
-  fd_ = ::open(path, O_RDONLY);
-  if (fd_ == -1) { return false; }
-
-  struct stat sb;
-  if (fstat(fd_, &sb) == -1) {
-    close();
-    return false;
-  }
-  size_ = static_cast<size_t>(sb.st_size);
-
-  addr_ = ::mmap(NULL, size_, PROT_READ, MAP_PRIVATE, fd_, 0);
-#endif
-
-  if (addr_ == nullptr) {
-    close();
-    return false;
-  }
-
-  return true;
-}
-
-inline bool mmap::is_open() const { return addr_ != nullptr; }
-
-inline size_t mmap::size() const { return size_; }
-
-inline const char *mmap::data() const { return (const char *)addr_; }
-
-inline void mmap::close() {
-#if defined(_WIN32)
-  if (addr_) {
-    ::UnmapViewOfFile(addr_);
-    addr_ = nullptr;
-  }
-
-  if (hMapping_) {
-    ::CloseHandle(hMapping_);
-    hMapping_ = NULL;
-  }
-
-  if (hFile_ != INVALID_HANDLE_VALUE) {
-    ::CloseHandle(hFile_);
-    hFile_ = INVALID_HANDLE_VALUE;
-  }
-#else
-  if (addr_ != nullptr) {
-    munmap(addr_, size_);
-    addr_ = nullptr;
-  }
-
-  if (fd_ != -1) {
-    ::close(fd_);
-    fd_ = -1;
-  }
-#endif
-  size_ = 0;
-}
-inline int close_socket(socket_t sock) {
-#ifdef _WIN32
-  return closesocket(sock);
-#else
-  return close(sock);
-#endif
-}
-
-template <typename T> inline ssize_t handle_EINTR(T fn) {
-  ssize_t res = 0;
-  while (true) {
-    res = fn();
-    if (res < 0 && errno == EINTR) { continue; }
-    break;
-  }
-  return res;
-}
-
-inline ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags) {
-  return handle_EINTR([&]() {
-    return recv(sock,
-#ifdef _WIN32
-                static_cast<char *>(ptr), static_cast<int>(size),
-#else
-                ptr, size,
-#endif
-                flags);
-  });
-}
-
-inline ssize_t send_socket(socket_t sock, const void *ptr, size_t size,
-                           int flags) {
-  return handle_EINTR([&]() {
-    return send(sock,
-#ifdef _WIN32
-                static_cast<const char *>(ptr), static_cast<int>(size),
-#else
-                ptr, size,
-#endif
-                flags);
-  });
-}
-
-inline ssize_t select_read(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
-  struct pollfd pfd_read;
-  pfd_read.fd = sock;
-  pfd_read.events = POLLIN;
-
-  auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
-  return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-#else
-#ifndef _WIN32
-  if (sock >= FD_SETSIZE) { return 1; }
-#endif
-
-  fd_set fds;
-  FD_ZERO(&fds);
-  FD_SET(sock, &fds);
-
-  timeval tv;
-  tv.tv_sec = static_cast<long>(sec);
-  tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
-  return handle_EINTR([&]() {
-    return select(static_cast<int>(sock + 1), &fds, nullptr, nullptr, &tv);
-  });
-#endif
-}
-
-inline ssize_t select_write(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
-  struct pollfd pfd_read;
-  pfd_read.fd = sock;
-  pfd_read.events = POLLOUT;
-
-  auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
-  return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-#else
-#ifndef _WIN32
-  if (sock >= FD_SETSIZE) { return 1; }
-#endif
-
-  fd_set fds;
-  FD_ZERO(&fds);
-  FD_SET(sock, &fds);
-
-  timeval tv;
-  tv.tv_sec = static_cast<long>(sec);
-  tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
-  return handle_EINTR([&]() {
-    return select(static_cast<int>(sock + 1), nullptr, &fds, nullptr, &tv);
-  });
-#endif
-}
-
-inline Error wait_until_socket_is_ready(socket_t sock, time_t sec,
-                                        time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
-  struct pollfd pfd_read;
-  pfd_read.fd = sock;
-  pfd_read.events = POLLIN | POLLOUT;
-
-  auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
-  auto poll_res = handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-
-  if (poll_res == 0) { return Error::ConnectionTimeout; }
-
-  if (poll_res > 0 && pfd_read.revents & (POLLIN | POLLOUT)) {
-    auto error = 0;
-    socklen_t len = sizeof(error);
-    auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR,
-                          reinterpret_cast<char *>(&error), &len);
-    auto successful = res >= 0 && !error;
-    return successful ? Error::Success : Error::Connection;
-  }
-
-  return Error::Connection;
-#else
-#ifndef _WIN32
-  if (sock >= FD_SETSIZE) { return Error::Connection; }
-#endif
-
-  fd_set fdsr;
-  FD_ZERO(&fdsr);
-  FD_SET(sock, &fdsr);
-
-  auto fdsw = fdsr;
-  auto fdse = fdsr;
-
-  timeval tv;
-  tv.tv_sec = static_cast<long>(sec);
-  tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
-  auto ret = handle_EINTR([&]() {
-    return select(static_cast<int>(sock + 1), &fdsr, &fdsw, &fdse, &tv);
-  });
-
-  if (ret == 0) { return Error::ConnectionTimeout; }
-
-  if (ret > 0 && (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) {
-    auto error = 0;
-    socklen_t len = sizeof(error);
-    auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR,
-                          reinterpret_cast<char *>(&error), &len);
-    auto successful = res >= 0 && !error;
-    return successful ? Error::Success : Error::Connection;
-  }
-  return Error::Connection;
-#endif
-}
-
-inline bool is_socket_alive(socket_t sock) {
-  const auto val = detail::select_read(sock, 0, 0);
-  if (val == 0) {
-    return true;
-  } else if (val < 0 && errno == EBADF) {
-    return false;
-  }
-  char buf[1];
-  return detail::read_socket(sock, &buf[0], sizeof(buf), MSG_PEEK) > 0;
-}
-
-class SocketStream : public Stream {
-public:
-  SocketStream(socket_t sock, time_t read_timeout_sec, time_t read_timeout_usec,
-               time_t write_timeout_sec, time_t write_timeout_usec);
-  ~SocketStream() override;
-
-  bool is_readable() const override;
-  bool is_writable() const override;
-  ssize_t read(char *ptr, size_t size) override;
-  ssize_t write(const char *ptr, size_t size) override;
-  void get_remote_ip_and_port(std::string &ip, int &port) const override;
-  void get_local_ip_and_port(std::string &ip, int &port) const override;
-  socket_t socket() const override;
-
-private:
-  socket_t sock_;
-  time_t read_timeout_sec_;
-  time_t read_timeout_usec_;
-  time_t write_timeout_sec_;
-  time_t write_timeout_usec_;
-
-  std::vector<char> read_buff_;
-  size_t read_buff_off_ = 0;
-  size_t read_buff_content_size_ = 0;
-
-  static const size_t read_buff_size_ = 1024l * 4;
-};
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLSocketStream : public Stream {
-public:
-  SSLSocketStream(socket_t sock, SSL *ssl, time_t read_timeout_sec,
-                  time_t read_timeout_usec, time_t write_timeout_sec,
-                  time_t write_timeout_usec);
-  ~SSLSocketStream() override;
-
-  bool is_readable() const override;
-  bool is_writable() const override;
-  ssize_t read(char *ptr, size_t size) override;
-  ssize_t write(const char *ptr, size_t size) override;
-  void get_remote_ip_and_port(std::string &ip, int &port) const override;
-  void get_local_ip_and_port(std::string &ip, int &port) const override;
-  socket_t socket() const override;
-
-private:
-  socket_t sock_;
-  SSL *ssl_;
-  time_t read_timeout_sec_;
-  time_t read_timeout_usec_;
-  time_t write_timeout_sec_;
-  time_t write_timeout_usec_;
-};
-#endif
-
-inline bool keep_alive(socket_t sock, time_t keep_alive_timeout_sec) {
-  using namespace std::chrono;
-  auto start = steady_clock::now();
-  while (true) {
-    auto val = select_read(sock, 0, 10000);
-    if (val < 0) {
-      return false;
-    } else if (val == 0) {
-      auto current = steady_clock::now();
-      auto duration = duration_cast<milliseconds>(current - start);
-      auto timeout = keep_alive_timeout_sec * 1000;
-      if (duration.count() > timeout) { return false; }
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    } else {
-      return true;
-    }
-  }
-}
-
-template <typename T>
-inline bool
-process_server_socket_core(const std::atomic<socket_t> &svr_sock, socket_t sock,
-                           size_t keep_alive_max_count,
-                           time_t keep_alive_timeout_sec, T callback) {
-  assert(keep_alive_max_count > 0);
-  auto ret = false;
-  auto count = keep_alive_max_count;
-  while (svr_sock != INVALID_SOCKET && count > 0 &&
-         keep_alive(sock, keep_alive_timeout_sec)) {
-    auto close_connection = count == 1;
-    auto connection_closed = false;
-    ret = callback(close_connection, connection_closed);
-    if (!ret || connection_closed) { break; }
-    count--;
-  }
-  return ret;
-}
-
-template <typename T>
-inline bool
-process_server_socket(const std::atomic<socket_t> &svr_sock, socket_t sock,
-                      size_t keep_alive_max_count,
-                      time_t keep_alive_timeout_sec, time_t read_timeout_sec,
-                      time_t read_timeout_usec, time_t write_timeout_sec,
-                      time_t write_timeout_usec, T callback) {
-  return process_server_socket_core(
-      svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec,
-      [&](bool close_connection, bool &connection_closed) {
-        SocketStream strm(sock, read_timeout_sec, read_timeout_usec,
-                          write_timeout_sec, write_timeout_usec);
-        return callback(strm, close_connection, connection_closed);
-      });
-}
-
-inline bool process_client_socket(socket_t sock, time_t read_timeout_sec,
-                                  time_t read_timeout_usec,
-                                  time_t write_timeout_sec,
-                                  time_t write_timeout_usec,
-                                  std::function<bool(Stream &)> callback) {
-  SocketStream strm(sock, read_timeout_sec, read_timeout_usec,
-                    write_timeout_sec, write_timeout_usec);
-  return callback(strm);
-}
-
-inline int shutdown_socket(socket_t sock) {
-#ifdef _WIN32
-  return shutdown(sock, SD_BOTH);
-#else
-  return shutdown(sock, SHUT_RDWR);
-#endif
-}
-
-template <typename BindOrConnect>
-socket_t create_socket(const std::string &host, const std::string &ip, int port,
-                       int address_family, int socket_flags, bool tcp_nodelay,
-                       SocketOptions socket_options,
-                       BindOrConnect bind_or_connect) {
-  // Get address info
-  const char *node = nullptr;
-  struct addrinfo hints;
-  struct addrinfo *result;
-
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = 0;
-
-  if (!ip.empty()) {
-    node = ip.c_str();
-    // Ask getaddrinfo to convert IP in c-string to address
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_flags = AI_NUMERICHOST;
-  } else {
-    if (!host.empty()) { node = host.c_str(); }
-    hints.ai_family = address_family;
-    hints.ai_flags = socket_flags;
-  }
-
-#ifndef _WIN32
-  if (hints.ai_family == AF_UNIX) {
-    const auto addrlen = host.length();
-    if (addrlen > sizeof(sockaddr_un::sun_path)) { return INVALID_SOCKET; }
-
-    auto sock = socket(hints.ai_family, hints.ai_socktype, hints.ai_protocol);
-    if (sock != INVALID_SOCKET) {
-      sockaddr_un addr{};
-      addr.sun_family = AF_UNIX;
-      std::copy(host.begin(), host.end(), addr.sun_path);
-
-      hints.ai_addr = reinterpret_cast<sockaddr *>(&addr);
-      hints.ai_addrlen = static_cast<socklen_t>(
-          sizeof(addr) - sizeof(addr.sun_path) + addrlen);
-
-      fcntl(sock, F_SETFD, FD_CLOEXEC);
-      if (socket_options) { socket_options(sock); }
-
-      if (!bind_or_connect(sock, hints)) {
-        close_socket(sock);
-        sock = INVALID_SOCKET;
-      }
-    }
-    return sock;
-  }
-#endif
-
-  auto service = std::to_string(port);
-
-  if (getaddrinfo(node, service.c_str(), &hints, &result)) {
-#if defined __linux__ && !defined __ANDROID__
-    res_init();
-#endif
-    return INVALID_SOCKET;
-  }
-
-  for (auto rp = result; rp; rp = rp->ai_next) {
-    // Create a socket
-#ifdef _WIN32
-    auto sock =
-        WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, nullptr, 0,
-                   WSA_FLAG_NO_HANDLE_INHERIT | WSA_FLAG_OVERLAPPED);
-    /**
-     * Since the WSA_FLAG_NO_HANDLE_INHERIT is only supported on Windows 7 SP1
-     * and above the socket creation fails on older Windows Systems.
-     *
-     * Let's try to create a socket the old way in this case.
-     *
-     * Reference:
-     * https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketa
-     *
-     * WSA_FLAG_NO_HANDLE_INHERIT:
-     * This flag is supported on Windows 7 with SP1, Windows Server 2008 R2 with
-     * SP1, and later
-     *
-     */
-    if (sock == INVALID_SOCKET) {
-      sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    }
-#else
-    auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-#endif
-    if (sock == INVALID_SOCKET) { continue; }
-
-#ifndef _WIN32
-    if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) {
-      close_socket(sock);
-      continue;
-    }
-#endif
-
-    if (tcp_nodelay) {
-      auto yes = 1;
-#ifdef _WIN32
-      setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
-                 reinterpret_cast<const char *>(&yes), sizeof(yes));
-#else
-      setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
-                 reinterpret_cast<const void *>(&yes), sizeof(yes));
-#endif
-    }
-
-    if (socket_options) { socket_options(sock); }
-
-    if (rp->ai_family == AF_INET6) {
-      auto no = 0;
-#ifdef _WIN32
-      setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
-                 reinterpret_cast<const char *>(&no), sizeof(no));
-#else
-      setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
-                 reinterpret_cast<const void *>(&no), sizeof(no));
-#endif
-    }
-
-    // bind or connect
-    if (bind_or_connect(sock, *rp)) {
-      freeaddrinfo(result);
-      return sock;
-    }
-
-    close_socket(sock);
-  }
-
-  freeaddrinfo(result);
-  return INVALID_SOCKET;
-}
-
-inline void set_nonblocking(socket_t sock, bool nonblocking) {
-#ifdef _WIN32
-  auto flags = nonblocking ? 1UL : 0UL;
-  ioctlsocket(sock, FIONBIO, &flags);
-#else
-  auto flags = fcntl(sock, F_GETFL, 0);
-  fcntl(sock, F_SETFL,
-        nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK)));
-#endif
-}
-
-inline bool is_connection_error() {
-#ifdef _WIN32
-  return WSAGetLastError() != WSAEWOULDBLOCK;
-#else
-  return errno != EINPROGRESS;
-#endif
-}
-
-inline bool bind_ip_address(socket_t sock, const std::string &host) {
-  struct addrinfo hints;
-  struct addrinfo *result;
-
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = 0;
-
-  if (getaddrinfo(host.c_str(), "0", &hints, &result)) { return false; }
-
-  auto ret = false;
-  for (auto rp = result; rp; rp = rp->ai_next) {
-    const auto &ai = *rp;
-    if (!::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
-      ret = true;
-      break;
-    }
-  }
-
-  freeaddrinfo(result);
-  return ret;
-}
-
-#if !defined _WIN32 && !defined ANDROID && !defined _AIX && !defined __MVS__
-#define USE_IF2IP
-#endif
-
-#ifdef USE_IF2IP
-inline std::string if2ip(int address_family, const std::string &ifn) {
-  struct ifaddrs *ifap;
-  getifaddrs(&ifap);
-  std::string addr_candidate;
-  for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) {
-    if (ifa->ifa_addr && ifn == ifa->ifa_name &&
-        (AF_UNSPEC == address_family ||
-         ifa->ifa_addr->sa_family == address_family)) {
-      if (ifa->ifa_addr->sa_family == AF_INET) {
-        auto sa = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
-        char buf[INET_ADDRSTRLEN];
-        if (inet_ntop(AF_INET, &sa->sin_addr, buf, INET_ADDRSTRLEN)) {
-          freeifaddrs(ifap);
-          return std::string(buf, INET_ADDRSTRLEN);
-        }
-      } else if (ifa->ifa_addr->sa_family == AF_INET6) {
-        auto sa = reinterpret_cast<struct sockaddr_in6 *>(ifa->ifa_addr);
-        if (!IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr)) {
-          char buf[INET6_ADDRSTRLEN] = {};
-          if (inet_ntop(AF_INET6, &sa->sin6_addr, buf, INET6_ADDRSTRLEN)) {
-            // equivalent to mac's IN6_IS_ADDR_UNIQUE_LOCAL
-            auto s6_addr_head = sa->sin6_addr.s6_addr[0];
-            if (s6_addr_head == 0xfc || s6_addr_head == 0xfd) {
-              addr_candidate = std::string(buf, INET6_ADDRSTRLEN);
-            } else {
-              freeifaddrs(ifap);
-              return std::string(buf, INET6_ADDRSTRLEN);
-            }
-          }
-        }
-      }
-    }
-  }
-  freeifaddrs(ifap);
-  return addr_candidate;
-}
-#endif
-
-inline socket_t create_client_socket(
-    const std::string &host, const std::string &ip, int port,
-    int address_family, bool tcp_nodelay, SocketOptions socket_options,
-    time_t connection_timeout_sec, time_t connection_timeout_usec,
-    time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
-    time_t write_timeout_usec, const std::string &intf, Error &error) {
-  auto sock = create_socket(
-      host, ip, port, address_family, 0, tcp_nodelay, std::move(socket_options),
-      [&](socket_t sock2, struct addrinfo &ai) -> bool {
-        if (!intf.empty()) {
-#ifdef USE_IF2IP
-          auto ip_from_if = if2ip(address_family, intf);
-          if (ip_from_if.empty()) { ip_from_if = intf; }
-          if (!bind_ip_address(sock2, ip_from_if)) {
-            error = Error::BindIPAddress;
-            return false;
-          }
-#endif
-        }
-
-        set_nonblocking(sock2, true);
-
-        auto ret =
-            ::connect(sock2, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen));
-
-        if (ret < 0) {
-          if (is_connection_error()) {
-            error = Error::Connection;
-            return false;
-          }
-          error = wait_until_socket_is_ready(sock2, connection_timeout_sec,
-                                             connection_timeout_usec);
-          if (error != Error::Success) { return false; }
-        }
-
-        set_nonblocking(sock2, false);
-
-        {
-#ifdef _WIN32
-          auto timeout = static_cast<uint32_t>(read_timeout_sec * 1000 +
-                                               read_timeout_usec / 1000);
-          setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO,
-                     reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
-          timeval tv;
-          tv.tv_sec = static_cast<long>(read_timeout_sec);
-          tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec);
-          setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO,
-                     reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
-        }
-        {
-
-#ifdef _WIN32
-          auto timeout = static_cast<uint32_t>(write_timeout_sec * 1000 +
-                                               write_timeout_usec / 1000);
-          setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO,
-                     reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
-          timeval tv;
-          tv.tv_sec = static_cast<long>(write_timeout_sec);
-          tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec);
-          setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO,
-                     reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
-        }
-
-        error = Error::Success;
-        return true;
-      });
-
-  if (sock != INVALID_SOCKET) {
-    error = Error::Success;
-  } else {
-    if (error == Error::Success) { error = Error::Connection; }
-  }
-
-  return sock;
-}
-
-inline bool get_ip_and_port(const struct sockaddr_storage &addr,
-                            socklen_t addr_len, std::string &ip, int &port) {
-  if (addr.ss_family == AF_INET) {
-    port = ntohs(reinterpret_cast<const struct sockaddr_in *>(&addr)->sin_port);
-  } else if (addr.ss_family == AF_INET6) {
-    port =
-        ntohs(reinterpret_cast<const struct sockaddr_in6 *>(&addr)->sin6_port);
-  } else {
-    return false;
-  }
-
-  std::array<char, NI_MAXHOST> ipstr{};
-  if (getnameinfo(reinterpret_cast<const struct sockaddr *>(&addr), addr_len,
-                  ipstr.data(), static_cast<socklen_t>(ipstr.size()), nullptr,
-                  0, NI_NUMERICHOST)) {
-    return false;
-  }
-
-  ip = ipstr.data();
-  return true;
-}
-
-inline void get_local_ip_and_port(socket_t sock, std::string &ip, int &port) {
-  struct sockaddr_storage addr;
-  socklen_t addr_len = sizeof(addr);
-  if (!getsockname(sock, reinterpret_cast<struct sockaddr *>(&addr),
-                   &addr_len)) {
-    get_ip_and_port(addr, addr_len, ip, port);
-  }
-}
-
-inline void get_remote_ip_and_port(socket_t sock, std::string &ip, int &port) {
-  struct sockaddr_storage addr;
-  socklen_t addr_len = sizeof(addr);
-
-  if (!getpeername(sock, reinterpret_cast<struct sockaddr *>(&addr),
-                   &addr_len)) {
-#ifndef _WIN32
-    if (addr.ss_family == AF_UNIX) {
-#if defined(__linux__)
-      struct ucred ucred;
-      socklen_t len = sizeof(ucred);
-      if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) {
-        port = ucred.pid;
-      }
-#elif defined(SOL_LOCAL) && defined(SO_PEERPID) // __APPLE__
-      pid_t pid;
-      socklen_t len = sizeof(pid);
-      if (getsockopt(sock, SOL_LOCAL, SO_PEERPID, &pid, &len) == 0) {
-        port = pid;
-      }
-#endif
-      return;
-    }
-#endif
-    get_ip_and_port(addr, addr_len, ip, port);
-  }
-}
-
-inline constexpr unsigned int str2tag_core(const char *s, size_t l,
-                                           unsigned int h) {
-  return (l == 0)
-             ? h
-             : str2tag_core(
-                   s + 1, l - 1,
-                   // Unsets the 6 high bits of h, therefore no overflow happens
-                   (((std::numeric_limits<unsigned int>::max)() >> 6) &
-                    h * 33) ^
-                       static_cast<unsigned char>(*s));
-}
-
-inline unsigned int str2tag(const std::string &s) {
-  return str2tag_core(s.data(), s.size(), 0);
-}
-
-namespace udl {
-
-inline constexpr unsigned int operator "" _t(const char *s, size_t l) {
-  return str2tag_core(s, l, 0);
-}
-
-} // namespace udl
-
-inline std::string
-find_content_type(const std::string &path,
-                  const std::map<std::string, std::string> &user_data,
-                  const std::string &default_content_type) {
-  auto ext = file_extension(path);
-
-  auto it = user_data.find(ext);
-  if (it != user_data.end()) { return it->second; }
-
-  using udl::operator "" _t;
-
-  switch (str2tag(ext)) {
-  default: return default_content_type;
-
-  case "css"_t: return "text/css";
-  case "csv"_t: return "text/csv";
-  case "htm"_t:
-  case "html"_t: return "text/html";
-  case "js"_t:
-  case "mjs"_t: return "text/javascript";
-  case "txt"_t: return "text/plain";
-  case "vtt"_t: return "text/vtt";
-
-  case "apng"_t: return "image/apng";
-  case "avif"_t: return "image/avif";
-  case "bmp"_t: return "image/bmp";
-  case "gif"_t: return "image/gif";
-  case "png"_t: return "image/png";
-  case "svg"_t: return "image/svg+xml";
-  case "webp"_t: return "image/webp";
-  case "ico"_t: return "image/x-icon";
-  case "tif"_t: return "image/tiff";
-  case "tiff"_t: return "image/tiff";
-  case "jpg"_t:
-  case "jpeg"_t: return "image/jpeg";
-
-  case "mp4"_t: return "video/mp4";
-  case "mpeg"_t: return "video/mpeg";
-  case "webm"_t: return "video/webm";
-
-  case "mp3"_t: return "audio/mp3";
-  case "mpga"_t: return "audio/mpeg";
-  case "weba"_t: return "audio/webm";
-  case "wav"_t: return "audio/wave";
-
-  case "otf"_t: return "font/otf";
-  case "ttf"_t: return "font/ttf";
-  case "woff"_t: return "font/woff";
-  case "woff2"_t: return "font/woff2";
-
-  case "7z"_t: return "application/x-7z-compressed";
-  case "atom"_t: return "application/atom+xml";
-  case "pdf"_t: return "application/pdf";
-  case "json"_t: return "application/json";
-  case "rss"_t: return "application/rss+xml";
-  case "tar"_t: return "application/x-tar";
-  case "xht"_t:
-  case "xhtml"_t: return "application/xhtml+xml";
-  case "xslt"_t: return "application/xslt+xml";
-  case "xml"_t: return "application/xml";
-  case "gz"_t: return "application/gzip";
-  case "zip"_t: return "application/zip";
-  case "wasm"_t: return "application/wasm";
-  }
-}
-
-inline bool can_compress_content_type(const std::string &content_type) {
-  using udl::operator "" _t;
-
-  auto tag = str2tag(content_type);
-
-  switch (tag) {
-  case "image/svg+xml"_t:
-  case "application/javascript"_t:
-  case "application/json"_t:
-  case "application/xml"_t:
-  case "application/protobuf"_t:
-  case "application/xhtml+xml"_t: return true;
-
-  default:
-    return !content_type.rfind("text/", 0) && tag != "text/event-stream"_t;
-  }
-}
-
-inline EncodingType encoding_type(const Request &req, const Response &res) {
-  auto ret =
-      detail::can_compress_content_type(res.get_header_value("Content-Type"));
-  if (!ret) { return EncodingType::None; }
-
-  const auto &s = req.get_header_value("Accept-Encoding");
-  (void)(s);
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-  // TODO: 'Accept-Encoding' has br, not br;q=0
-  ret = s.find("br") != std::string::npos;
-  if (ret) { return EncodingType::Brotli; }
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-  // TODO: 'Accept-Encoding' has gzip, not gzip;q=0
-  ret = s.find("gzip") != std::string::npos;
-  if (ret) { return EncodingType::Gzip; }
-#endif
-
-  return EncodingType::None;
-}
-
-inline bool nocompressor::compress(const char *data, size_t data_length,
-                                   bool /*last*/, Callback callback) {
-  if (!data_length) { return true; }
-  return callback(data, data_length);
-}
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-inline gzip_compressor::gzip_compressor() {
-  std::memset(&strm_, 0, sizeof(strm_));
-  strm_.zalloc = Z_NULL;
-  strm_.zfree = Z_NULL;
-  strm_.opaque = Z_NULL;
-
-  is_valid_ = deflateInit2(&strm_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8,
-                           Z_DEFAULT_STRATEGY) == Z_OK;
-}
-
-inline gzip_compressor::~gzip_compressor() { deflateEnd(&strm_); }
-
-inline bool gzip_compressor::compress(const char *data, size_t data_length,
-                                      bool last, Callback callback) {
-  assert(is_valid_);
-
-  do {
-    constexpr size_t max_avail_in =
-        (std::numeric_limits<decltype(strm_.avail_in)>::max)();
-
-    strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
-        (std::min)(data_length, max_avail_in));
-    strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
-
-    data_length -= strm_.avail_in;
-    data += strm_.avail_in;
-
-    auto flush = (last && data_length == 0) ? Z_FINISH : Z_NO_FLUSH;
-    auto ret = Z_OK;
-
-    std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-    do {
-      strm_.avail_out = static_cast<uInt>(buff.size());
-      strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
-
-      ret = deflate(&strm_, flush);
-      if (ret == Z_STREAM_ERROR) { return false; }
-
-      if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
-        return false;
-      }
-    } while (strm_.avail_out == 0);
-
-    assert((flush == Z_FINISH && ret == Z_STREAM_END) ||
-           (flush == Z_NO_FLUSH && ret == Z_OK));
-    assert(strm_.avail_in == 0);
-  } while (data_length > 0);
-
-  return true;
-}
-
-inline gzip_decompressor::gzip_decompressor() {
-  std::memset(&strm_, 0, sizeof(strm_));
-  strm_.zalloc = Z_NULL;
-  strm_.zfree = Z_NULL;
-  strm_.opaque = Z_NULL;
-
-  // 15 is the value of wbits, which should be at the maximum possible value
-  // to ensure that any gzip stream can be decoded. The offset of 32 specifies
-  // that the stream type should be automatically detected either gzip or
-  // deflate.
-  is_valid_ = inflateInit2(&strm_, 32 + 15) == Z_OK;
-}
-
-inline gzip_decompressor::~gzip_decompressor() { inflateEnd(&strm_); }
-
-inline bool gzip_decompressor::is_valid() const { return is_valid_; }
-
-inline bool gzip_decompressor::decompress(const char *data, size_t data_length,
-                                          Callback callback) {
-  assert(is_valid_);
-
-  auto ret = Z_OK;
-
-  do {
-    constexpr size_t max_avail_in =
-        (std::numeric_limits<decltype(strm_.avail_in)>::max)();
-
-    strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
-        (std::min)(data_length, max_avail_in));
-    strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
-
-    data_length -= strm_.avail_in;
-    data += strm_.avail_in;
-
-    std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-    while (strm_.avail_in > 0 && ret == Z_OK) {
-      strm_.avail_out = static_cast<uInt>(buff.size());
-      strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
-
-      ret = inflate(&strm_, Z_NO_FLUSH);
-
-      assert(ret != Z_STREAM_ERROR);
-      switch (ret) {
-      case Z_NEED_DICT:
-      case Z_DATA_ERROR:
-      case Z_MEM_ERROR: inflateEnd(&strm_); return false;
-      }
-
-      if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
-        return false;
-      }
-    }
-
-    if (ret != Z_OK && ret != Z_STREAM_END) { return false; }
-
-  } while (data_length > 0);
-
-  return true;
-}
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-inline brotli_compressor::brotli_compressor() {
-  state_ = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
-}
-
-inline brotli_compressor::~brotli_compressor() {
-  BrotliEncoderDestroyInstance(state_);
-}
-
-inline bool brotli_compressor::compress(const char *data, size_t data_length,
-                                        bool last, Callback callback) {
-  std::array<uint8_t, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-
-  auto operation = last ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS;
-  auto available_in = data_length;
-  auto next_in = reinterpret_cast<const uint8_t *>(data);
-
-  for (;;) {
-    if (last) {
-      if (BrotliEncoderIsFinished(state_)) { break; }
-    } else {
-      if (!available_in) { break; }
-    }
-
-    auto available_out = buff.size();
-    auto next_out = buff.data();
-
-    if (!BrotliEncoderCompressStream(state_, operation, &available_in, &next_in,
-                                     &available_out, &next_out, nullptr)) {
-      return false;
-    }
-
-    auto output_bytes = buff.size() - available_out;
-    if (output_bytes) {
-      callback(reinterpret_cast<const char *>(buff.data()), output_bytes);
-    }
-  }
-
-  return true;
-}
-
-inline brotli_decompressor::brotli_decompressor() {
-  decoder_s = BrotliDecoderCreateInstance(0, 0, 0);
-  decoder_r = decoder_s ? BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT
-                        : BROTLI_DECODER_RESULT_ERROR;
-}
-
-inline brotli_decompressor::~brotli_decompressor() {
-  if (decoder_s) { BrotliDecoderDestroyInstance(decoder_s); }
-}
-
-inline bool brotli_decompressor::is_valid() const { return decoder_s; }
-
-inline bool brotli_decompressor::decompress(const char *data,
-                                            size_t data_length,
-                                            Callback callback) {
-  if (decoder_r == BROTLI_DECODER_RESULT_SUCCESS ||
-      decoder_r == BROTLI_DECODER_RESULT_ERROR) {
-    return 0;
-  }
-
-  auto next_in = reinterpret_cast<const uint8_t *>(data);
-  size_t avail_in = data_length;
-  size_t total_out;
-
-  decoder_r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT;
-
-  std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-  while (decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
-    char *next_out = buff.data();
-    size_t avail_out = buff.size();
-
-    decoder_r = BrotliDecoderDecompressStream(
-        decoder_s, &avail_in, &next_in, &avail_out,
-        reinterpret_cast<uint8_t **>(&next_out), &total_out);
-
-    if (decoder_r == BROTLI_DECODER_RESULT_ERROR) { return false; }
-
-    if (!callback(buff.data(), buff.size() - avail_out)) { return false; }
-  }
-
-  return decoder_r == BROTLI_DECODER_RESULT_SUCCESS ||
-         decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
-}
-#endif
-
-inline bool has_header(const Headers &headers, const std::string &key) {
-  return headers.find(key) != headers.end();
-}
-
-inline const char *get_header_value(const Headers &headers,
-                                    const std::string &key, size_t id,
-                                    const char *def) {
-  auto rng = headers.equal_range(key);
-  auto it = rng.first;
-  std::advance(it, static_cast<ssize_t>(id));
-  if (it != rng.second) { return it->second.c_str(); }
-  return def;
-}
-
-inline bool compare_case_ignore(const std::string &a, const std::string &b) {
-  if (a.size() != b.size()) { return false; }
-  for (size_t i = 0; i < b.size(); i++) {
-    if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
-  }
-  return true;
-}
-
-template <typename T>
-inline bool parse_header(const char *beg, const char *end, T fn) {
-  // Skip trailing spaces and tabs.
-  while (beg < end && is_space_or_tab(end[-1])) {
-    end--;
-  }
-
-  auto p = beg;
-  while (p < end && *p != ':') {
-    p++;
-  }
-
-  if (p == end) { return false; }
-
-  auto key_end = p;
-
-  if (*p++ != ':') { return false; }
-
-  while (p < end && is_space_or_tab(*p)) {
-    p++;
-  }
-
-  if (p < end) {
-    auto key_len = key_end - beg;
-    if (!key_len) { return false; }
-
-    auto key = std::string(beg, key_end);
-    auto val = compare_case_ignore(key, "Location") || compare_case_ignore(key, "Link")
-                   ? std::string(p, end)
-                   : decode_url(std::string(p, end), false);
-    fn(std::move(key), std::move(val));
-    return true;
-  }
-
-  return false;
-}
-
-inline bool read_headers(Stream &strm, Headers &headers) {
-  const auto bufsiz = 2048;
-  char buf[bufsiz];
-  stream_line_reader line_reader(strm, buf, bufsiz);
-
-  for (;;) {
-    if (!line_reader.getline()) { return false; }
-
-    // Check if the line ends with CRLF.
-    auto line_terminator_len = 2;
-    if (line_reader.end_with_crlf()) {
-      // Blank line indicates end of headers.
-      if (line_reader.size() == 2) { break; }
-#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
-    } else {
-      // Blank line indicates end of headers.
-      if (line_reader.size() == 1) { break; }
-      line_terminator_len = 1;
-    }
-#else
-    } else {
-      continue; // Skip invalid line.
-    }
-#endif
-
-    if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-
-    // Exclude line terminator
-    auto end = line_reader.ptr() + line_reader.size() - line_terminator_len;
-
-    parse_header(line_reader.ptr(), end,
-                 [&](std::string &&key, std::string &&val) {
-                   headers.emplace(std::move(key), std::move(val));
-                 });
-  }
-
-  return true;
-}
-
-inline bool read_content_with_length(Stream &strm, uint64_t len,
-                                     Progress progress,
-                                     ContentReceiverWithProgress out) {
-  char buf[CPPHTTPLIB_RECV_BUFSIZ];
-
-  uint64_t r = 0;
-  while (r < len) {
-    auto read_len = static_cast<size_t>(len - r);
-    auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
-    if (n <= 0) { return false; }
-
-    if (!out(buf, static_cast<size_t>(n), r, len)) { return false; }
-    r += static_cast<uint64_t>(n);
-
-    if (progress) {
-      if (!progress(r, len)) { return false; }
-    }
-  }
-
-  return true;
-}
-
-inline void skip_content_with_length(Stream &strm, uint64_t len) {
-  char buf[CPPHTTPLIB_RECV_BUFSIZ];
-  uint64_t r = 0;
-  while (r < len) {
-    auto read_len = static_cast<size_t>(len - r);
-    auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
-    if (n <= 0) { return; }
-    r += static_cast<uint64_t>(n);
-  }
-}
-
-inline bool read_content_without_length(Stream &strm,
-                                        ContentReceiverWithProgress out) {
-  char buf[CPPHTTPLIB_RECV_BUFSIZ];
-  uint64_t r = 0;
-  for (;;) {
-    auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ);
-    if (n <= 0) { return true; }
-
-    if (!out(buf, static_cast<size_t>(n), r, 0)) { return false; }
-    r += static_cast<uint64_t>(n);
-  }
-
-  return true;
-}
-
-template <typename T>
-inline bool read_content_chunked(Stream &strm, T &x,
-                                 ContentReceiverWithProgress out) {
-  const auto bufsiz = 16;
-  char buf[bufsiz];
-
-  stream_line_reader line_reader(strm, buf, bufsiz);
-
-  if (!line_reader.getline()) { return false; }
-
-  unsigned long chunk_len;
-  while (true) {
-    char *end_ptr;
-
-    chunk_len = std::strtoul(line_reader.ptr(), &end_ptr, 16);
-
-    if (end_ptr == line_reader.ptr()) { return false; }
-    if (chunk_len == ULONG_MAX) { return false; }
-
-    if (chunk_len == 0) { break; }
-
-    if (!read_content_with_length(strm, chunk_len, nullptr, out)) {
-      return false;
-    }
-
-    if (!line_reader.getline()) { return false; }
-
-    if (strcmp(line_reader.ptr(), "\r\n") != 0) { return false; }
-
-    if (!line_reader.getline()) { return false; }
-  }
-
-  assert(chunk_len == 0);
-
-  // Trailer
-  if (!line_reader.getline()) { return false; }
-
-  while (strcmp(line_reader.ptr(), "\r\n") != 0) {
-    if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-
-    // Exclude line terminator
-    constexpr auto line_terminator_len = 2;
-    auto end = line_reader.ptr() + line_reader.size() - line_terminator_len;
-
-    parse_header(line_reader.ptr(), end,
-                 [&](std::string &&key, std::string &&val) {
-                   x.headers.emplace(std::move(key), std::move(val));
-                 });
-
-    if (!line_reader.getline()) { return false; }
-  }
-
-  return true;
-}
-
-inline bool is_chunked_transfer_encoding(const Headers &headers) {
-  return !strcasecmp(get_header_value(headers, "Transfer-Encoding", 0, ""),
-                     "chunked");
-}
-
-template <typename T, typename U>
-bool prepare_content_receiver(T &x, int &status,
-                              ContentReceiverWithProgress receiver,
-                              bool decompress, U callback) {
-  if (decompress) {
-    std::string encoding = x.get_header_value("Content-Encoding");
-    std::unique_ptr<decompressor> decompressor;
-
-    if (encoding == "gzip" || encoding == "deflate") {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-      decompressor = detail::make_unique<gzip_decompressor>();
-#else
-      status = StatusCode::UnsupportedMediaType_415;
-      return false;
-#endif
-    } else if (encoding.find("br") != std::string::npos) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-      decompressor = detail::make_unique<brotli_decompressor>();
-#else
-      status = StatusCode::UnsupportedMediaType_415;
-      return false;
-#endif
-    }
-
-    if (decompressor) {
-      if (decompressor->is_valid()) {
-        ContentReceiverWithProgress out = [&](const char *buf, size_t n,
-                                              uint64_t off, uint64_t len) {
-          return decompressor->decompress(buf, n,
-                                          [&](const char *buf2, size_t n2) {
-                                            return receiver(buf2, n2, off, len);
-                                          });
-        };
-        return callback(std::move(out));
-      } else {
-        status = StatusCode::InternalServerError_500;
-        return false;
-      }
-    }
-  }
-
-  ContentReceiverWithProgress out = [&](const char *buf, size_t n, uint64_t off,
-                                        uint64_t len) {
-    return receiver(buf, n, off, len);
-  };
-  return callback(std::move(out));
-}
-
-template <typename T>
-bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
-                  Progress progress, ContentReceiverWithProgress receiver,
-                  bool decompress) {
-  return prepare_content_receiver(
-      x, status, std::move(receiver), decompress,
-      [&](const ContentReceiverWithProgress &out) {
-        auto ret = true;
-        auto exceed_payload_max_length = false;
-
-        if (is_chunked_transfer_encoding(x.headers)) {
-          ret = read_content_chunked(strm, x, out);
-        } else if (!has_header(x.headers, "Content-Length")) {
-          ret = read_content_without_length(strm, out);
-        } else {
-          auto len = get_header_value_u64(x.headers, "Content-Length", 0, 0);
-          if (len > payload_max_length) {
-            exceed_payload_max_length = true;
-            skip_content_with_length(strm, len);
-            ret = false;
-          } else if (len > 0) {
-            ret = read_content_with_length(strm, len, std::move(progress), out);
-          }
-        }
-
-        if (!ret) {
-          status = exceed_payload_max_length ? StatusCode::PayloadTooLarge_413
-                                             : StatusCode::BadRequest_400;
-        }
-        return ret;
-      });
-} // namespace detail
-
-inline ssize_t write_headers(Stream &strm, const Headers &headers) {
-  ssize_t write_len = 0;
-  for (const auto &x : headers) {
-    auto len =
-        strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str());
-    if (len < 0) { return len; }
-    write_len += len;
-  }
-  auto len = strm.write("\r\n");
-  if (len < 0) { return len; }
-  write_len += len;
-  return write_len;
-}
-
-inline bool write_data(Stream &strm, const char *d, size_t l) {
-  size_t offset = 0;
-  while (offset < l) {
-    auto length = strm.write(d + offset, l - offset);
-    if (length < 0) { return false; }
-    offset += static_cast<size_t>(length);
-  }
-  return true;
-}
-
-template <typename T>
-inline bool write_content(Stream &strm, const ContentProvider &content_provider,
-                          size_t offset, size_t length, T is_shutting_down,
-                          Error &error) {
-  size_t end_offset = offset + length;
-  auto ok = true;
-  DataSink data_sink;
-
-  data_sink.write = [&](const char *d, size_t l) -> bool {
-    if (ok) {
-      if (strm.is_writable() && write_data(strm, d, l)) {
-        offset += l;
-      } else {
-        ok = false;
-      }
-    }
-    return ok;
-  };
-
-  data_sink.is_writable = [&]() -> bool { return strm.is_writable(); };
-
-  while (offset < end_offset && !is_shutting_down()) {
-    if (!strm.is_writable()) {
-      error = Error::Write;
-      return false;
-    } else if (!content_provider(offset, end_offset - offset, data_sink)) {
-      error = Error::Canceled;
-      return false;
-    } else if (!ok) {
-      error = Error::Write;
-      return false;
-    }
-  }
-
-  error = Error::Success;
-  return true;
-}
-
-template <typename T>
-inline bool write_content(Stream &strm, const ContentProvider &content_provider,
-                          size_t offset, size_t length,
-                          const T &is_shutting_down) {
-  auto error = Error::Success;
-  return write_content(strm, content_provider, offset, length, is_shutting_down,
-                       error);
-}
-
-template <typename T>
-inline bool
-write_content_without_length(Stream &strm,
-                             const ContentProvider &content_provider,
-                             const T &is_shutting_down) {
-  size_t offset = 0;
-  auto data_available = true;
-  auto ok = true;
-  DataSink data_sink;
-
-  data_sink.write = [&](const char *d, size_t l) -> bool {
-    if (ok) {
-      offset += l;
-      if (!strm.is_writable() || !write_data(strm, d, l)) { ok = false; }
-    }
-    return ok;
-  };
-
-  data_sink.is_writable = [&]() -> bool { return strm.is_writable(); };
-
-  data_sink.done = [&](void) { data_available = false; };
-
-  while (data_available && !is_shutting_down()) {
-    if (!strm.is_writable()) {
-      return false;
-    } else if (!content_provider(offset, 0, data_sink)) {
-      return false;
-    } else if (!ok) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <typename T, typename U>
-inline bool
-write_content_chunked(Stream &strm, const ContentProvider &content_provider,
-                      const T &is_shutting_down, U &compressor, Error &error) {
-  size_t offset = 0;
-  auto data_available = true;
-  auto ok = true;
-  DataSink data_sink;
-
-  data_sink.write = [&](const char *d, size_t l) -> bool {
-    if (ok) {
-      data_available = l > 0;
-      offset += l;
-
-      std::string payload;
-      if (compressor.compress(d, l, false,
-                              [&](const char *data, size_t data_len) {
-                                payload.append(data, data_len);
-                                return true;
-                              })) {
-        if (!payload.empty()) {
-          // Emit chunked response header and footer for each chunk
-          auto chunk =
-              from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n";
-          if (!strm.is_writable() ||
-              !write_data(strm, chunk.data(), chunk.size())) {
-            ok = false;
-          }
-        }
-      } else {
-        ok = false;
-      }
-    }
-    return ok;
-  };
-
-  data_sink.is_writable = [&]() -> bool { return strm.is_writable(); };
-
-  auto done_with_trailer = [&](const Headers *trailer) {
-    if (!ok) { return; }
-
-    data_available = false;
-
-    std::string payload;
-    if (!compressor.compress(nullptr, 0, true,
-                             [&](const char *data, size_t data_len) {
-                               payload.append(data, data_len);
-                               return true;
-                             })) {
-      ok = false;
-      return;
-    }
-
-    if (!payload.empty()) {
-      // Emit chunked response header and footer for each chunk
-      auto chunk = from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n";
-      if (!strm.is_writable() ||
-          !write_data(strm, chunk.data(), chunk.size())) {
-        ok = false;
-        return;
-      }
-    }
-
-    static const std::string done_marker("0\r\n");
-    if (!write_data(strm, done_marker.data(), done_marker.size())) {
-      ok = false;
-    }
-
-    // Trailer
-    if (trailer) {
-      for (const auto &kv : *trailer) {
-        std::string field_line = kv.first + ": " + kv.second + "\r\n";
-        if (!write_data(strm, field_line.data(), field_line.size())) {
-          ok = false;
-        }
-      }
-    }
-
-    static const std::string crlf("\r\n");
-    if (!write_data(strm, crlf.data(), crlf.size())) { ok = false; }
-  };
-
-  data_sink.done = [&](void) { done_with_trailer(nullptr); };
-
-  data_sink.done_with_trailer = [&](const Headers &trailer) {
-    done_with_trailer(&trailer);
-  };
-
-  while (data_available && !is_shutting_down()) {
-    if (!strm.is_writable()) {
-      error = Error::Write;
-      return false;
-    } else if (!content_provider(offset, 0, data_sink)) {
-      error = Error::Canceled;
-      return false;
-    } else if (!ok) {
-      error = Error::Write;
-      return false;
-    }
-  }
-
-  error = Error::Success;
-  return true;
-}
-
-template <typename T, typename U>
-inline bool write_content_chunked(Stream &strm,
-                                  const ContentProvider &content_provider,
-                                  const T &is_shutting_down, U &compressor) {
-  auto error = Error::Success;
-  return write_content_chunked(strm, content_provider, is_shutting_down,
-                               compressor, error);
-}
-
-template <typename T>
-inline bool redirect(T &cli, Request &req, Response &res,
-                     const std::string &path, const std::string &location,
-                     Error &error) {
-  Request new_req = req;
-  new_req.path = path;
-  new_req.redirect_count_ -= 1;
-
-  if (res.status == StatusCode::SeeOther_303 &&
-      (req.method != "GET" && req.method != "HEAD")) {
-    new_req.method = "GET";
-    new_req.body.clear();
-    new_req.headers.clear();
-  }
-
-  Response new_res;
-
-  auto ret = cli.send(new_req, new_res, error);
-  if (ret) {
-    req = new_req;
-    res = new_res;
-
-    if (res.location.empty()) { res.location = location; }
-  }
-  return ret;
-}
-
-inline std::string params_to_query_str(const Params &params) {
-  std::string query;
-
-  for (auto it = params.begin(); it != params.end(); ++it) {
-    if (it != params.begin()) { query += "&"; }
-    query += it->first;
-    query += "=";
-    query += encode_query_param(it->second);
-  }
-  return query;
-}
-
-inline void parse_query_text(const std::string &s, Params &params) {
-  std::set<std::string> cache;
-  split(s.data(), s.data() + s.size(), '&', [&](const char *b, const char *e) {
-    std::string kv(b, e);
-    if (cache.find(kv) != cache.end()) { return; }
-    cache.insert(kv);
-
-    std::string key;
-    std::string val;
-    split(b, e, '=', [&](const char *b2, const char *e2) {
-      if (key.empty()) {
-        key.assign(b2, e2);
-      } else {
-        val.assign(b2, e2);
-      }
-    });
-
-    if (!key.empty()) {
-      params.emplace(decode_url(key, true), decode_url(val, true));
-    }
-  });
-}
-
-inline bool parse_multipart_boundary(const std::string &content_type,
-                                     std::string &boundary) {
-  auto boundary_keyword = "boundary=";
-  auto pos = content_type.find(boundary_keyword);
-  if (pos == std::string::npos) { return false; }
-  auto end = content_type.find(';', pos);
-  auto beg = pos + strlen(boundary_keyword);
-  boundary = trim_double_quotes_copy(content_type.substr(beg, end - beg));
-  return !boundary.empty();
-}
-
-inline void parse_disposition_params(const std::string &s, Params &params) {
-  std::set<std::string> cache;
-  split(s.data(), s.data() + s.size(), ';', [&](const char *b, const char *e) {
-    std::string kv(b, e);
-    if (cache.find(kv) != cache.end()) { return; }
-    cache.insert(kv);
-
-    std::string key;
-    std::string val;
-    split(b, e, '=', [&](const char *b2, const char *e2) {
-      if (key.empty()) {
-        key.assign(b2, e2);
-      } else {
-        val.assign(b2, e2);
-      }
-    });
-
-    if (!key.empty()) {
-      params.emplace(trim_double_quotes_copy((key)),
-                     trim_double_quotes_copy((val)));
-    }
-  });
-}
-
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-inline bool parse_range_header(const std::string &s, Ranges &ranges) {
-#else
-inline bool parse_range_header(const std::string &s, Ranges &ranges) try {
-#endif
-  static auto re_first_range = Regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))");
-  Match m;
-  if (RegexMatch(s, m, re_first_range)) {
-    auto pos = static_cast<size_t>(m.position(1));
-    auto len = static_cast<size_t>(m.length(1));
-    auto all_valid_ranges = true;
-    split(&s[pos], &s[pos + len], ',', [&](const char *b, const char *e) {
-      if (!all_valid_ranges) { return; }
-      static auto re_another_range = Regex(R"(\s*(\d*)-(\d*))");
-      Match cm;
-      if (RegexMatch(b, e, cm, re_another_range)) {
-        ssize_t first = -1;
-        if (!cm.str(1).empty()) {
-          first = static_cast<ssize_t>(std::stoll(cm.str(1)));
-        }
-
-        ssize_t last = -1;
-        if (!cm.str(2).empty()) {
-          last = static_cast<ssize_t>(std::stoll(cm.str(2)));
-        }
-
-        if (first != -1 && last != -1 && first > last) {
-          all_valid_ranges = false;
-          return;
-        }
-        ranges.emplace_back(std::make_pair(first, last));
-      }
-    });
-    return all_valid_ranges;
-  }
-  return false;
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-}
-#else
-} catch (...) { return false; }
-#endif
-
-class MultipartFormDataParser {
-public:
-  MultipartFormDataParser() = default;
-
-  void set_boundary(std::string &&boundary) {
-    boundary_ = boundary;
-    dash_boundary_crlf_ = dash_ + boundary_ + crlf_;
-    crlf_dash_boundary_ = crlf_ + dash_ + boundary_;
-  }
-
-  bool is_valid() const { return is_valid_; }
-
-  bool parse(const char *buf, size_t n, const ContentReceiver &content_callback,
-             const MultipartContentHeader &header_callback) {
-
-    buf_append(buf, n);
-
-    while (buf_size() > 0) {
-      switch (state_) {
-      case 0: { // Initial boundary
-        buf_erase(buf_find(dash_boundary_crlf_));
-        if (dash_boundary_crlf_.size() > buf_size()) { return true; }
-        if (!buf_start_with(dash_boundary_crlf_)) { return false; }
-        buf_erase(dash_boundary_crlf_.size());
-        state_ = 1;
-        break;
-      }
-      case 1: { // New entry
-        clear_file_info();
-        state_ = 2;
-        break;
-      }
-      case 2: { // Headers
-        auto pos = buf_find(crlf_);
-        if (pos > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-        while (pos < buf_size()) {
-          // Empty line
-          if (pos == 0) {
-            if (!header_callback(file_)) {
-              is_valid_ = false;
-              return false;
-            }
-            buf_erase(crlf_.size());
-            state_ = 3;
-            break;
-          }
-
-          const auto header = buf_head(pos);
-
-          if (!parse_header(header.data(), header.data() + header.size(),
-                            [&](std::string &&, std::string &&) {})) {
-            is_valid_ = false;
-            return false;
-          }
-
-          static const std::string header_content_type = "Content-Type:";
-
-          if (start_with_case_ignore(header, header_content_type)) {
-            file_.content_type =
-                trim_copy(header.substr(header_content_type.size()));
-          } else {
-            static const Regex re_content_disposition(
-                R"~(^Content-Disposition:\s*form-data;\s*(.*)$)~",
-                duckdb_re2::RegexOptions::CASE_INSENSITIVE);
-
-            Match m;
-            if (RegexMatch(header, m, re_content_disposition)) {
-              Params params;
-              parse_disposition_params(m[1], params);
-
-              auto it = params.find("name");
-              if (it != params.end()) {
-                file_.name = it->second;
-              } else {
-                is_valid_ = false;
-                return false;
-              }
-
-              it = params.find("filename");
-              if (it != params.end()) { file_.filename = it->second; }
-
-              it = params.find("filename*");
-              if (it != params.end()) {
-                // Only allow UTF-8 enconnding...
-                static const Regex re_rfc5987_encoding(
-                    R"~(^UTF-8''(.+?)$)~", duckdb_re2::RegexOptions::CASE_INSENSITIVE);
-
-                Match m2;
-                if (RegexMatch(it->second, m2, re_rfc5987_encoding)) {
-                  file_.filename = decode_url(m2[1], false); // override...
-                } else {
-                  is_valid_ = false;
-                  return false;
-                }
-              }
-            }
-          }
-          buf_erase(pos + crlf_.size());
-          pos = buf_find(crlf_);
-        }
-        if (state_ != 3) { return true; }
-        break;
-      }
-      case 3: { // Body
-        if (crlf_dash_boundary_.size() > buf_size()) { return true; }
-        auto pos = buf_find(crlf_dash_boundary_);
-        if (pos < buf_size()) {
-          if (!content_callback(buf_data(), pos)) {
-            is_valid_ = false;
-            return false;
-          }
-          buf_erase(pos + crlf_dash_boundary_.size());
-          state_ = 4;
-        } else {
-          auto len = buf_size() - crlf_dash_boundary_.size();
-          if (len > 0) {
-            if (!content_callback(buf_data(), len)) {
-              is_valid_ = false;
-              return false;
-            }
-            buf_erase(len);
-          }
-          return true;
-        }
-        break;
-      }
-      case 4: { // Boundary
-        if (crlf_.size() > buf_size()) { return true; }
-        if (buf_start_with(crlf_)) {
-          buf_erase(crlf_.size());
-          state_ = 1;
-        } else {
-          if (dash_.size() > buf_size()) { return true; }
-          if (buf_start_with(dash_)) {
-            buf_erase(dash_.size());
-            is_valid_ = true;
-            buf_erase(buf_size()); // Remove epilogue
-          } else {
-            return true;
-          }
-        }
-        break;
-      }
-      }
-    }
-
-    return true;
-  }
-
-private:
-  void clear_file_info() {
-    file_.name.clear();
-    file_.filename.clear();
-    file_.content_type.clear();
-  }
-
-  bool start_with_case_ignore(const std::string &a,
-                              const std::string &b) const {
-    if (a.size() < b.size()) { return false; }
-    for (size_t i = 0; i < b.size(); i++) {
-      if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
-    }
-    return true;
-  }
-
-  const std::string dash_ = "--";
-  const std::string crlf_ = "\r\n";
-  std::string boundary_;
-  std::string dash_boundary_crlf_;
-  std::string crlf_dash_boundary_;
-
-  size_t state_ = 0;
-  bool is_valid_ = false;
-  MultipartFormData file_;
-
-  // Buffer
-  bool start_with(const std::string &a, size_t spos, size_t epos,
-                  const std::string &b) const {
-    if (epos - spos < b.size()) { return false; }
-    for (size_t i = 0; i < b.size(); i++) {
-      if (a[i + spos] != b[i]) { return false; }
-    }
-    return true;
-  }
-
-  size_t buf_size() const { return buf_epos_ - buf_spos_; }
-
-  const char *buf_data() const { return &buf_[buf_spos_]; }
-
-  std::string buf_head(size_t l) const { return buf_.substr(buf_spos_, l); }
-
-  bool buf_start_with(const std::string &s) const {
-    return start_with(buf_, buf_spos_, buf_epos_, s);
-  }
-
-  size_t buf_find(const std::string &s) const {
-    auto c = s.front();
-
-    size_t off = buf_spos_;
-    while (off < buf_epos_) {
-      auto pos = off;
-      while (true) {
-        if (pos == buf_epos_) { return buf_size(); }
-        if (buf_[pos] == c) { break; }
-        pos++;
-      }
-
-      auto remaining_size = buf_epos_ - pos;
-      if (s.size() > remaining_size) { return buf_size(); }
-
-      if (start_with(buf_, pos, buf_epos_, s)) { return pos - buf_spos_; }
-
-      off = pos + 1;
-    }
-
-    return buf_size();
-  }
-
-  void buf_append(const char *data, size_t n) {
-    auto remaining_size = buf_size();
-    if (remaining_size > 0 && buf_spos_ > 0) {
-      for (size_t i = 0; i < remaining_size; i++) {
-        buf_[i] = buf_[buf_spos_ + i];
-      }
-    }
-    buf_spos_ = 0;
-    buf_epos_ = remaining_size;
-
-    if (remaining_size + n > buf_.size()) { buf_.resize(remaining_size + n); }
-
-    for (size_t i = 0; i < n; i++) {
-      buf_[buf_epos_ + i] = data[i];
-    }
-    buf_epos_ += n;
-  }
-
-  void buf_erase(size_t size) { buf_spos_ += size; }
-
-  std::string buf_;
-  size_t buf_spos_ = 0;
-  size_t buf_epos_ = 0;
-};
-
-inline std::string to_lower(const char *beg, const char *end) {
-  std::string out;
-  auto it = beg;
-  while (it != end) {
-    out += static_cast<char>(::tolower(*it));
-    it++;
-  }
-  return out;
-}
-
-inline std::string make_multipart_data_boundary() {
-  static const char data[] =
-      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-  std::string result = "--cpp-httplib-multipart-data-";
-  duckdb::RandomEngine engine;
-  for (auto i = 0; i < 16; i++) {
-    result += data[engine.NextRandomInteger32(0,sizeof(data) - 1)];
-  }
-
-  return result;
-}
-
-inline bool is_multipart_boundary_chars_valid(const std::string &boundary) {
-  auto valid = true;
-  for (size_t i = 0; i < boundary.size(); i++) {
-    auto c = boundary[i];
-    if (!std::isalnum(c) && c != '-' && c != '_') {
-      valid = false;
-      break;
-    }
-  }
-  return valid;
-}
-
-template <typename T>
-inline std::string
-serialize_multipart_formdata_item_begin(const T &item,
-                                        const std::string &boundary) {
-  std::string body = "--" + boundary + "\r\n";
-  body += "Content-Disposition: form-data; name=\"" + item.name + "\"";
-  if (!item.filename.empty()) {
-    body += "; filename=\"" + item.filename + "\"";
-  }
-  body += "\r\n";
-  if (!item.content_type.empty()) {
-    body += "Content-Type: " + item.content_type + "\r\n";
-  }
-  body += "\r\n";
-
-  return body;
-}
-
-inline std::string serialize_multipart_formdata_item_end() { return "\r\n"; }
-
-inline std::string
-serialize_multipart_formdata_finish(const std::string &boundary) {
-  return "--" + boundary + "--\r\n";
-}
-
-inline std::string
-serialize_multipart_formdata_get_content_type(const std::string &boundary) {
-  return "multipart/form-data; boundary=" + boundary;
-}
-
-inline std::string
-serialize_multipart_formdata(const MultipartFormDataItems &items,
-                             const std::string &boundary, bool finish = true) {
-  std::string body;
-
-  for (const auto &item : items) {
-    body += serialize_multipart_formdata_item_begin(item, boundary);
-    body += item.content + serialize_multipart_formdata_item_end();
-  }
-
-  if (finish) { body += serialize_multipart_formdata_finish(boundary); }
-
-  return body;
-}
-
-inline std::pair<size_t, size_t>
-get_range_offset_and_length(const Request &req, size_t content_length,
-                            size_t index) {
-  auto r = req.ranges[index];
-
-  if (r.first == -1 && r.second == -1) {
-    return std::make_pair(0, content_length);
-  }
-
-  auto slen = static_cast<ssize_t>(content_length);
-
-  if (r.first == -1) {
-    r.first = (std::max)(static_cast<ssize_t>(0), slen - r.second);
-    r.second = slen - 1;
-  }
-
-  if (r.second == -1) { r.second = slen - 1; }
-  return std::make_pair(r.first, static_cast<size_t>(r.second - r.first) + 1);
-}
-
-inline std::string
-make_content_range_header_field(const std::pair<ssize_t, ssize_t> &range,
-                                size_t content_length) {
-  std::string field = "bytes ";
-  if (range.first != -1) { field += std::to_string(range.first); }
-  field += "-";
-  if (range.second != -1) { field += std::to_string(range.second); }
-  field += "/";
-  field += std::to_string(content_length);
-  return field;
-}
-
-template <typename SToken, typename CToken, typename Content>
-bool process_multipart_ranges_data(const Request &req, Response &res,
-                                   const std::string &boundary,
-                                   const std::string &content_type,
-                                   SToken stoken, CToken ctoken,
-                                   Content content) {
-  for (size_t i = 0; i < req.ranges.size(); i++) {
-    ctoken("--");
-    stoken(boundary);
-    ctoken("\r\n");
-    if (!content_type.empty()) {
-      ctoken("Content-Type: ");
-      stoken(content_type);
-      ctoken("\r\n");
-    }
-
-    ctoken("Content-Range: ");
-    const auto &range = req.ranges[i];
-    stoken(make_content_range_header_field(range, res.content_length_));
-    ctoken("\r\n");
-    ctoken("\r\n");
-
-    auto offsets = get_range_offset_and_length(req, res.content_length_, i);
-    auto offset = offsets.first;
-    auto length = offsets.second;
-    if (!content(offset, length)) { return false; }
-    ctoken("\r\n");
-  }
-
-  ctoken("--");
-  stoken(boundary);
-  ctoken("--");
-
-  return true;
-}
-
-inline bool make_multipart_ranges_data(const Request &req, Response &res,
-                                       const std::string &boundary,
-                                       const std::string &content_type,
-                                       std::string &data) {
-  return process_multipart_ranges_data(
-      req, res, boundary, content_type,
-      [&](const std::string &token) { data += token; },
-      [&](const std::string &token) { data += token; },
-      [&](size_t offset, size_t length) {
-        if (offset < res.body.size()) {
-          data += res.body.substr(offset, length);
-          return true;
-        }
-        return false;
-      });
-}
-
-inline size_t
-get_multipart_ranges_data_length(const Request &req, Response &res,
-                                 const std::string &boundary,
-                                 const std::string &content_type) {
-  size_t data_length = 0;
-
-  process_multipart_ranges_data(
-      req, res, boundary, content_type,
-      [&](const std::string &token) { data_length += token.size(); },
-      [&](const std::string &token) { data_length += token.size(); },
-      [&](size_t /*offset*/, size_t length) {
-        data_length += length;
-        return true;
-      });
-
-  return data_length;
-}
-
-template <typename T>
-inline bool write_multipart_ranges_data(Stream &strm, const Request &req,
-                                        Response &res,
-                                        const std::string &boundary,
-                                        const std::string &content_type,
-                                        const T &is_shutting_down) {
-  return process_multipart_ranges_data(
-      req, res, boundary, content_type,
-      [&](const std::string &token) { strm.write(token); },
-      [&](const std::string &token) { strm.write(token); },
-      [&](size_t offset, size_t length) {
-        return write_content(strm, res.content_provider_, offset, length,
-                             is_shutting_down);
-      });
-}
-
-inline std::pair<size_t, size_t>
-get_range_offset_and_length(const Request &req, const Response &res,
-                            size_t index) {
-  auto r = req.ranges[index];
-
-  if (r.second == -1) {
-    r.second = static_cast<ssize_t>(res.content_length_) - 1;
-  }
-
-  return std::make_pair(r.first, r.second - r.first + 1);
-}
-
-inline bool expect_content(const Request &req) {
-  if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" ||
-      req.method == "PRI" || req.method == "DELETE") {
-    return true;
-  }
-  // TODO: check if Content-Length is set
-  return false;
-}
-
-inline bool has_crlf(const std::string &s) {
-  auto p = s.c_str();
-  while (*p) {
-    if (*p == '\r' || *p == '\n') { return true; }
-    p++;
-  }
-  return false;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline std::string message_digest(const std::string &s, const EVP_MD *algo) {
-  auto context = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(
-      EVP_MD_CTX_new(), EVP_MD_CTX_free);
-
-  unsigned int hash_length = 0;
-  unsigned char hash[EVP_MAX_MD_SIZE];
-
-  EVP_DigestInit_ex(context.get(), algo, nullptr);
-  EVP_DigestUpdate(context.get(), s.c_str(), s.size());
-  EVP_DigestFinal_ex(context.get(), hash, &hash_length);
-
-  std::stringstream ss;
-  for (auto i = 0u; i < hash_length; ++i) {
-    ss << std::hex << std::setw(2) << std::setfill('0')
-       << static_cast<unsigned int>(hash[i]);
-  }
-
-  return ss.str();
-}
-
-inline std::string MD5(const std::string &s) {
-  return message_digest(s, EVP_md5());
-}
-
-inline std::string SHA_256(const std::string &s) {
-  return message_digest(s, EVP_sha256());
-}
-
-inline std::string SHA_512(const std::string &s) {
-  return message_digest(s, EVP_sha512());
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-#ifdef _WIN32
-// NOTE: This code came up with the following stackoverflow post:
-// https://stackoverflow.com/questions/9507184/can-openssl-on-windows-use-the-system-certificate-store
-inline bool load_system_certs_on_windows(X509_STORE *store) {
-  auto hStore = CertOpenSystemStoreW((HCRYPTPROV_LEGACY)NULL, L"ROOT");
-  if (!hStore) { return false; }
-
-  auto result = false;
-  PCCERT_CONTEXT pContext = NULL;
-  while ((pContext = CertEnumCertificatesInStore(hStore, pContext)) !=
-         nullptr) {
-    auto encoded_cert =
-        static_cast<const unsigned char *>(pContext->pbCertEncoded);
-
-    auto x509 = d2i_X509(NULL, &encoded_cert, pContext->cbCertEncoded);
-    if (x509) {
-      X509_STORE_add_cert(store, x509);
-      X509_free(x509);
-      result = true;
-    }
-  }
-
-  CertFreeCertificateContext(pContext);
-  CertCloseStore(hStore, 0);
-
-  return result;
-}
-#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)
-#if TARGET_OS_OSX
-template <typename T>
-using CFObjectPtr =
-    std::unique_ptr<typename std::remove_pointer<T>::type, void (*)(CFTypeRef)>;
-
-inline void cf_object_ptr_deleter(CFTypeRef obj) {
-  if (obj) { CFRelease(obj); }
-}
-
-inline bool retrieve_certs_from_keychain(CFObjectPtr<CFArrayRef> &certs) {
-  CFStringRef keys[] = {kSecClass, kSecMatchLimit, kSecReturnRef};
-  CFTypeRef values[] = {kSecClassCertificate, kSecMatchLimitAll,
-                        kCFBooleanTrue};
-
-  CFObjectPtr<CFDictionaryRef> query(
-      CFDictionaryCreate(nullptr, reinterpret_cast<const void **>(keys), values,
-                         sizeof(keys) / sizeof(keys[0]),
-                         &kCFTypeDictionaryKeyCallBacks,
-                         &kCFTypeDictionaryValueCallBacks),
-      cf_object_ptr_deleter);
-
-  if (!query) { return false; }
-
-  CFTypeRef security_items = nullptr;
-  if (SecItemCopyMatching(query.get(), &security_items) != errSecSuccess ||
-      CFArrayGetTypeID() != CFGetTypeID(security_items)) {
-    return false;
-  }
-
-  certs.reset(reinterpret_cast<CFArrayRef>(security_items));
-  return true;
-}
-
-inline bool retrieve_root_certs_from_keychain(CFObjectPtr<CFArrayRef> &certs) {
-  CFArrayRef root_security_items = nullptr;
-  if (SecTrustCopyAnchorCertificates(&root_security_items) != errSecSuccess) {
-    return false;
-  }
-
-  certs.reset(root_security_items);
-  return true;
-}
-
-inline bool add_certs_to_x509_store(CFArrayRef certs, X509_STORE *store) {
-  auto result = false;
-  for (auto i = 0; i < CFArrayGetCount(certs); ++i) {
-    const auto cert = reinterpret_cast<const __SecCertificate *>(
-        CFArrayGetValueAtIndex(certs, i));
-
-    if (SecCertificateGetTypeID() != CFGetTypeID(cert)) { continue; }
-
-    CFDataRef cert_data = nullptr;
-    if (SecItemExport(cert, kSecFormatX509Cert, 0, nullptr, &cert_data) !=
-        errSecSuccess) {
-      continue;
-    }
-
-    CFObjectPtr<CFDataRef> cert_data_ptr(cert_data, cf_object_ptr_deleter);
-
-    auto encoded_cert = static_cast<const unsigned char *>(
-        CFDataGetBytePtr(cert_data_ptr.get()));
-
-    auto x509 =
-        d2i_X509(NULL, &encoded_cert, CFDataGetLength(cert_data_ptr.get()));
-
-    if (x509) {
-      X509_STORE_add_cert(store, x509);
-      X509_free(x509);
-      result = true;
-    }
-  }
-
-  return result;
-}
-
-inline bool load_system_certs_on_macos(X509_STORE *store) {
-  auto result = false;
-  CFObjectPtr<CFArrayRef> certs(nullptr, cf_object_ptr_deleter);
-  if (retrieve_certs_from_keychain(certs) && certs) {
-    result = add_certs_to_x509_store(certs.get(), store);
-  }
-
-  if (retrieve_root_certs_from_keychain(certs) && certs) {
-    result = add_certs_to_x509_store(certs.get(), store) || result;
-  }
-
-  return result;
-}
-#endif // TARGET_OS_OSX
-#endif // _WIN32
-#endif // CPPHTTPLIB_OPENSSL_SUPPORT
-
-#ifdef _WIN32
-class WSInit {
-public:
-  WSInit() {
-    WSADATA wsaData;
-    if (WSAStartup(0x0002, &wsaData) == 0) is_valid_ = true;
-  }
-
-  ~WSInit() {
-    if (is_valid_) WSACleanup();
-  }
-
-  bool is_valid_ = false;
-};
-
-static WSInit wsinit_;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline std::pair<std::string, std::string> make_digest_authentication_header(
-    const Request &req, const std::map<std::string, std::string> &auth,
-    size_t cnonce_count, const std::string &cnonce, const std::string &username,
-    const std::string &password, bool is_proxy = false) {
-  std::string nc;
-  {
-    std::stringstream ss;
-    ss << std::setfill('0') << std::setw(8) << std::hex << cnonce_count;
-    nc = ss.str();
-  }
-
-  std::string qop;
-  if (auth.find("qop") != auth.end()) {
-    qop = auth.at("qop");
-    if (qop.find("auth-int") != std::string::npos) {
-      qop = "auth-int";
-    } else if (qop.find("auth") != std::string::npos) {
-      qop = "auth";
-    } else {
-      qop.clear();
-    }
-  }
-
-  std::string algo = "MD5";
-  if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); }
-
-  std::string response;
-  {
-    auto H = algo == "SHA-256"   ? detail::SHA_256
-             : algo == "SHA-512" ? detail::SHA_512
-                                 : detail::MD5;
-
-    auto A1 = username + ":" + auth.at("realm") + ":" + password;
-
-    auto A2 = req.method + ":" + req.path;
-    if (qop == "auth-int") { A2 += ":" + H(req.body); }
-
-    if (qop.empty()) {
-      response = H(H(A1) + ":" + auth.at("nonce") + ":" + H(A2));
-    } else {
-      response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce +
-                   ":" + qop + ":" + H(A2));
-    }
-  }
-
-  auto opaque = (auth.find("opaque") != auth.end()) ? auth.at("opaque") : "";
-
-  auto field = "Digest username=\"" + username + "\", realm=\"" +
-               auth.at("realm") + "\", nonce=\"" + auth.at("nonce") +
-               "\", uri=\"" + req.path + "\", algorithm=" + algo +
-               (qop.empty() ? ", response=\""
-                            : ", qop=" + qop + ", nc=" + nc + ", cnonce=\"" +
-                                  cnonce + "\", response=\"") +
-               response + "\"" +
-               (opaque.empty() ? "" : ", opaque=\"" + opaque + "\"");
-
-  auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-  return std::make_pair(key, field);
-}
-#endif
-
-inline bool parse_www_authenticate(const Response &res,
-                                   std::map<std::string, std::string> &auth,
-                                   bool is_proxy) {
-  auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate";
-  if (res.has_header(auth_key)) {
-    static auto re = Regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~");
-    auto s = res.get_header_value(auth_key);
-    auto pos = s.find(' ');
-    if (pos != std::string::npos) {
-      auto type = s.substr(0, pos);
-      if (type == "Basic") {
-        return false;
-      } else if (type == "Digest") {
-        s = s.substr(pos + 1);
-        auto matches = duckdb_re2::RegexFindAll(s, re);
-        for (auto &m : matches) {
-          auto key = s.substr(static_cast<size_t>(m.position(1)),
-                              static_cast<size_t>(m.length(1)));
-          auto val = m.length(2) > 0
-                         ? s.substr(static_cast<size_t>(m.position(2)),
-                                    static_cast<size_t>(m.length(2)))
-                         : s.substr(static_cast<size_t>(m.position(3)),
-                                    static_cast<size_t>(m.length(3)));
-          auth[key] = val;
-        }
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-// https://stackoverflow.com/questions/440133/how-do-i-create-a-random-alpha-numeric-string-in-c/440240#answer-440240
-inline std::string random_string(size_t length) {
-  auto randchar = []() -> char {
-    const char charset[] = "0123456789"
-                           "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                           "abcdefghijklmnopqrstuvwxyz";
-    const size_t max_index = (sizeof(charset) - 1);
-    return charset[static_cast<size_t>(std::rand()) % max_index];
-  };
-  std::string str(length, 0);
-  std::generate_n(str.begin(), length, randchar);
-  return str;
-}
-
-class ContentProviderAdapter {
-public:
-  explicit ContentProviderAdapter(
-      ContentProviderWithoutLength &&content_provider)
-      : content_provider_(content_provider) {}
-
-  bool operator()(size_t offset, size_t, DataSink &sink) {
-    return content_provider_(offset, sink);
-  }
-
-private:
-  ContentProviderWithoutLength content_provider_;
-};
-
-} // namespace detail
-
-inline std::string hosted_at(const std::string &hostname) {
-  std::vector<std::string> addrs;
-  hosted_at(hostname, addrs);
-  if (addrs.empty()) { return std::string(); }
-  return addrs[0];
-}
-
-inline void hosted_at(const std::string &hostname,
-                      std::vector<std::string> &addrs) {
-  struct addrinfo hints;
-  struct addrinfo *result;
-
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = 0;
-
-  if (getaddrinfo(hostname.c_str(), nullptr, &hints, &result)) {
-#if defined __linux__ && !defined __ANDROID__
-    res_init();
-#endif
-    return;
-  }
-
-  for (auto rp = result; rp; rp = rp->ai_next) {
-    const auto &addr =
-        *reinterpret_cast<struct sockaddr_storage *>(rp->ai_addr);
-    std::string ip;
-    auto dummy = -1;
-    if (detail::get_ip_and_port(addr, sizeof(struct sockaddr_storage), ip,
-                                dummy)) {
-      addrs.push_back(ip);
-    }
-  }
-
-  freeaddrinfo(result);
-}
-
-inline std::string append_query_params(const std::string &path,
-                                       const Params &params) {
-  std::string path_with_query = path;
-  const static Regex re("[^?]+\\?.*");
-  auto delm = RegexMatch(path, re) ? '&' : '?';
-  path_with_query += delm + detail::params_to_query_str(params);
-  return path_with_query;
-}
-
-// Header utilities
-inline std::pair<std::string, std::string> make_range_header(Ranges ranges) {
-  std::string field = "bytes=";
-  auto i = 0;
-  for (auto r : ranges) {
-    if (i != 0) { field += ", "; }
-    if (r.first != -1) { field += std::to_string(r.first); }
-    field += '-';
-    if (r.second != -1) { field += std::to_string(r.second); }
-    i++;
-  }
-  return std::make_pair("Range", std::move(field));
-}
-
-inline std::pair<std::string, std::string>
-make_basic_authentication_header(const std::string &username,
-                                 const std::string &password, bool is_proxy) {
-  auto field = "Basic " + detail::base64_encode(username + ":" + password);
-  auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-  return std::make_pair(key, std::move(field));
-}
-
-inline std::pair<std::string, std::string>
-make_bearer_token_authentication_header(const std::string &token,
-                                        bool is_proxy = false) {
-  auto field = "Bearer " + token;
-  auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-  return std::make_pair(key, std::move(field));
-}
-
-// Request implementation
-inline bool Request::has_header(const std::string &key) const {
-  return detail::has_header(headers, key);
-}
-
-inline std::string Request::get_header_value(const std::string &key,
-                                             size_t id) const {
-  return detail::get_header_value(headers, key, id, "");
-}
-
-inline size_t Request::get_header_value_count(const std::string &key) const {
-  auto r = headers.equal_range(key);
-  return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline void Request::set_header(const std::string &key,
-                                const std::string &val) {
-  if (!detail::has_crlf(key) && !detail::has_crlf(val)) {
-    headers.emplace(key, val);
-  }
-}
-
-inline bool Request::has_param(const std::string &key) const {
-  return params.find(key) != params.end();
-}
-
-inline std::string Request::get_param_value(const std::string &key,
-                                            size_t id) const {
-  auto rng = params.equal_range(key);
-  auto it = rng.first;
-  std::advance(it, static_cast<ssize_t>(id));
-  if (it != rng.second) { return it->second; }
-  return std::string();
-}
-
-inline size_t Request::get_param_value_count(const std::string &key) const {
-  auto r = params.equal_range(key);
-  return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline bool Request::is_multipart_form_data() const {
-  const auto &content_type = get_header_value("Content-Type");
-  return !content_type.rfind("multipart/form-data", 0);
-}
-
-inline bool Request::has_file(const std::string &key) const {
-  return files.find(key) != files.end();
-}
-
-inline MultipartFormData Request::get_file_value(const std::string &key) const {
-  auto it = files.find(key);
-  if (it != files.end()) { return it->second; }
-  return MultipartFormData();
-}
-
-inline std::vector<MultipartFormData>
-Request::get_file_values(const std::string &key) const {
-  std::vector<MultipartFormData> values;
-  auto rng = files.equal_range(key);
-  for (auto it = rng.first; it != rng.second; it++) {
-    values.push_back(it->second);
-  }
-  return values;
-}
-
-// Response implementation
-inline bool Response::has_header(const std::string &key) const {
-  return headers.find(key) != headers.end();
-}
-
-inline std::string Response::get_header_value(const std::string &key,
-                                              size_t id) const {
-  return detail::get_header_value(headers, key, id, "");
-}
-
-inline size_t Response::get_header_value_count(const std::string &key) const {
-  auto r = headers.equal_range(key);
-  return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline void Response::set_header(const std::string &key,
-                                 const std::string &val) {
-  if (!detail::has_crlf(key) && !detail::has_crlf(val)) {
-    headers.emplace(key, val);
-  }
-}
-
-inline void Response::set_redirect(const std::string &url, int stat) {
-  if (!detail::has_crlf(url)) {
-    set_header("Location", url);
-    if (300 <= stat && stat < 400) {
-      this->status = stat;
-    } else {
-      this->status = StatusCode::Found_302;
-    }
-  }
-}
-
-inline void Response::set_content(const char *s, size_t n,
-                                  const std::string &content_type) {
-  body.assign(s, n);
-
-  auto rng = headers.equal_range("Content-Type");
-  headers.erase(rng.first, rng.second);
-  set_header("Content-Type", content_type);
-}
-
-inline void Response::set_content(const std::string &s,
-                                  const std::string &content_type) {
-  set_content(s.data(), s.size(), content_type);
-}
-
-inline void Response::set_content_provider(
-    size_t in_length, const std::string &content_type, ContentProvider provider,
-    ContentProviderResourceReleaser resource_releaser) {
-  set_header("Content-Type", content_type);
-  content_length_ = in_length;
-  if (in_length > 0) { content_provider_ = std::move(provider); }
-  content_provider_resource_releaser_ = resource_releaser;
-  is_chunked_content_provider_ = false;
-}
-
-inline void Response::set_content_provider(
-    const std::string &content_type, ContentProviderWithoutLength provider,
-    ContentProviderResourceReleaser resource_releaser) {
-  set_header("Content-Type", content_type);
-  content_length_ = 0;
-  content_provider_ = detail::ContentProviderAdapter(std::move(provider));
-  content_provider_resource_releaser_ = resource_releaser;
-  is_chunked_content_provider_ = false;
-}
-
-inline void Response::set_chunked_content_provider(
-    const std::string &content_type, ContentProviderWithoutLength provider,
-    ContentProviderResourceReleaser resource_releaser) {
-  set_header("Content-Type", content_type);
-  content_length_ = 0;
-  content_provider_ = detail::ContentProviderAdapter(std::move(provider));
-  content_provider_resource_releaser_ = resource_releaser;
-  is_chunked_content_provider_ = true;
-}
-
-// Result implementation
-inline bool Result::has_request_header(const std::string &key) const {
-  return request_headers_.find(key) != request_headers_.end();
-}
-
-inline std::string Result::get_request_header_value(const std::string &key,
-                                                    size_t id) const {
-  return detail::get_header_value(request_headers_, key, id, "");
-}
-
-inline size_t
-Result::get_request_header_value_count(const std::string &key) const {
-  auto r = request_headers_.equal_range(key);
-  return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-// Stream implementation
-inline ssize_t Stream::write(const char *ptr) {
-  return write(ptr, strlen(ptr));
-}
-
-inline ssize_t Stream::write(const std::string &s) {
-  return write(s.data(), s.size());
-}
-
-namespace detail {
-
-// Socket stream implementation
-inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec,
-                                  time_t read_timeout_usec,
-                                  time_t write_timeout_sec,
-                                  time_t write_timeout_usec)
-    : sock_(sock), read_timeout_sec_(read_timeout_sec),
-      read_timeout_usec_(read_timeout_usec),
-      write_timeout_sec_(write_timeout_sec),
-      write_timeout_usec_(write_timeout_usec), read_buff_(read_buff_size_, 0) {}
-
-inline SocketStream::~SocketStream() = default;
-
-inline bool SocketStream::is_readable() const {
-  return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
-}
-
-inline bool SocketStream::is_writable() const {
-  return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 &&
-         is_socket_alive(sock_);
-}
-
-inline ssize_t SocketStream::read(char *ptr, size_t size) {
-#ifdef _WIN32
-  size =
-      (std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
-#else
-  size = (std::min)(size,
-                    static_cast<size_t>((std::numeric_limits<ssize_t>::max)()));
-#endif
-
-  if (read_buff_off_ < read_buff_content_size_) {
-    auto remaining_size = read_buff_content_size_ - read_buff_off_;
-    if (size <= remaining_size) {
-      memcpy(ptr, read_buff_.data() + read_buff_off_, size);
-      read_buff_off_ += size;
-      return static_cast<ssize_t>(size);
-    } else {
-      memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size);
-      read_buff_off_ += remaining_size;
-      return static_cast<ssize_t>(remaining_size);
-    }
-  }
-
-  if (!is_readable()) { return -1; }
-
-  read_buff_off_ = 0;
-  read_buff_content_size_ = 0;
-
-  if (size < read_buff_size_) {
-    auto n = read_socket(sock_, read_buff_.data(), read_buff_size_,
-                         CPPHTTPLIB_RECV_FLAGS);
-    if (n <= 0) {
-      return n;
-    } else if (n <= static_cast<ssize_t>(size)) {
-      memcpy(ptr, read_buff_.data(), static_cast<size_t>(n));
-      return n;
-    } else {
-      memcpy(ptr, read_buff_.data(), size);
-      read_buff_off_ = size;
-      read_buff_content_size_ = static_cast<size_t>(n);
-      return static_cast<ssize_t>(size);
-    }
-  } else {
-    return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS);
-  }
-}
-
-inline ssize_t SocketStream::write(const char *ptr, size_t size) {
-  if (!is_writable()) { return -1; }
-
-#if defined(_WIN32) && !defined(_WIN64)
-  size =
-      (std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
-#endif
-
-  return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
-}
-
-inline void SocketStream::get_remote_ip_and_port(std::string &ip,
-                                                 int &port) const {
-  return detail::get_remote_ip_and_port(sock_, ip, port);
-}
-
-inline void SocketStream::get_local_ip_and_port(std::string &ip,
-                                                int &port) const {
-  return detail::get_local_ip_and_port(sock_, ip, port);
-}
-
-inline socket_t SocketStream::socket() const { return sock_; }
-
-// Buffer stream implementation
-inline bool BufferStream::is_readable() const { return true; }
-
-inline bool BufferStream::is_writable() const { return true; }
-
-inline ssize_t BufferStream::read(char *ptr, size_t size) {
-#if defined(_MSC_VER) && _MSC_VER < 1910
-  auto len_read = buffer._Copy_s(ptr, size, size, position);
-#else
-  auto len_read = buffer.copy(ptr, size, position);
-#endif
-  position += static_cast<size_t>(len_read);
-  return static_cast<ssize_t>(len_read);
-}
-
-inline ssize_t BufferStream::write(const char *ptr, size_t size) {
-  buffer.append(ptr, size);
-  return static_cast<ssize_t>(size);
-}
-
-inline void BufferStream::get_remote_ip_and_port(std::string & /*ip*/,
-                                                 int & /*port*/) const {}
-
-inline void BufferStream::get_local_ip_and_port(std::string & /*ip*/,
-                                                int & /*port*/) const {}
-
-inline socket_t BufferStream::socket() const { return 0; }
-
-inline const std::string &BufferStream::get_buffer() const { return buffer; }
-
-inline PathParamsMatcher::PathParamsMatcher(const std::string &pattern) {
-  // One past the last ending position of a path param substring
-  std::size_t last_param_end = 0;
-
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
-  // Needed to ensure that parameter names are unique during matcher
-  // construction
-  // If exceptions are disabled, only last duplicate path
-  // parameter will be set
-  std::unordered_set<std::string> param_name_set;
-#endif
-
-  while (true) {
-    const auto marker_pos = pattern.find(marker, last_param_end);
-    if (marker_pos == std::string::npos) { break; }
-
-    static_fragments_.push_back(
-        pattern.substr(last_param_end, marker_pos - last_param_end));
-
-    const auto param_name_start = marker_pos + 1;
-
-    auto sep_pos = pattern.find(separator, param_name_start);
-    if (sep_pos == std::string::npos) { sep_pos = pattern.length(); }
-
-    auto param_name =
-        pattern.substr(param_name_start, sep_pos - param_name_start);
-
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
-    if (param_name_set.find(param_name) != param_name_set.cend()) {
-      std::string msg = "Encountered path parameter '" + param_name +
-                        "' multiple times in route pattern '" + pattern + "'.";
-      throw std::invalid_argument(msg);
-    }
-#endif
-
-    param_names_.push_back(std::move(param_name));
-
-    last_param_end = sep_pos + 1;
-  }
-
-  if (last_param_end < pattern.length()) {
-    static_fragments_.push_back(pattern.substr(last_param_end));
-  }
-}
-
-inline bool PathParamsMatcher::match(Request &request) const {
-  request.matches = Match();
-  request.path_params.clear();
-  request.path_params.reserve(param_names_.size());
-
-  // One past the position at which the path matched the pattern last time
-  std::size_t starting_pos = 0;
-  for (size_t i = 0; i < static_fragments_.size(); ++i) {
-    const auto &fragment = static_fragments_[i];
-
-    if (starting_pos + fragment.length() > request.path.length()) {
-      return false;
-    }
-
-    // Avoid unnecessary allocation by using strncmp instead of substr +
-    // comparison
-    if (std::strncmp(request.path.c_str() + starting_pos, fragment.c_str(),
-                     fragment.length()) != 0) {
-      return false;
-    }
-
-    starting_pos += fragment.length();
-
-    // Should only happen when we have a static fragment after a param
-    // Example: '/users/:id/subscriptions'
-    // The 'subscriptions' fragment here does not have a corresponding param
-    if (i >= param_names_.size()) { continue; }
-
-    auto sep_pos = request.path.find(separator, starting_pos);
-    if (sep_pos == std::string::npos) { sep_pos = request.path.length(); }
-
-    const auto &param_name = param_names_[i];
-
-    request.path_params.emplace(
-        param_name, request.path.substr(starting_pos, sep_pos - starting_pos));
-
-    // Mark everythin up to '/' as matched
-    starting_pos = sep_pos + 1;
-  }
-  // Returns false if the path is longer than the pattern
-  return starting_pos >= request.path.length();
-}
-
-inline bool RegexMatcher::match(Request &request) const {
-  request.path_params.clear();
-  return RegexMatch(request.path, request.matches, regex_);
-}
-
-} // namespace detail
-
-// HTTP server implementation
-inline Server::Server()
-    : new_task_queue(
-          [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); }) {
-#ifndef _WIN32
-  signal(SIGPIPE, SIG_IGN);
-#endif
-}
-
-inline Server::~Server() = default;
-
-inline std::unique_ptr<detail::MatcherBase>
-Server::make_matcher(const std::string &pattern) {
-  if (pattern.find("/:") != std::string::npos) {
-    return detail::make_unique<detail::PathParamsMatcher>(pattern);
-  } else {
-    return detail::make_unique<detail::RegexMatcher>(pattern);
-  }
-}
-
-inline Server &Server::Get(const std::string &pattern, Handler handler) {
-  get_handlers_.emplace_back(Regex(pattern), std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Post(const std::string &pattern, Handler handler) {
-  post_handlers_.emplace_back(Regex(pattern), std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Post(const std::string &pattern,
-                            HandlerWithContentReader handler) {
-  post_handlers_for_content_reader_.emplace_back(Regex(pattern),
-                                                 std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Put(const std::string &pattern, Handler handler) {
-  put_handlers_.emplace_back(Regex(pattern), std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Put(const std::string &pattern,
-                           HandlerWithContentReader handler) {
-  put_handlers_for_content_reader_.emplace_back(Regex(pattern),
-                                                std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Patch(const std::string &pattern, Handler handler) {
-  patch_handlers_.emplace_back(Regex(pattern), std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Patch(const std::string &pattern,
-                             HandlerWithContentReader handler) {
-  patch_handlers_for_content_reader_.emplace_back(Regex(pattern),
-                                                  std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Delete(const std::string &pattern, Handler handler) {
-  delete_handlers_.emplace_back(Regex(pattern), std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Delete(const std::string &pattern,
-                              HandlerWithContentReader handler) {
-  delete_handlers_for_content_reader_.emplace_back(Regex(pattern),
-                                                   std::move(handler));
-  return *this;
-}
-
-inline Server &Server::Options(const std::string &pattern, Handler handler) {
-  options_handlers_.emplace_back(Regex(pattern), std::move(handler));
-  return *this;
-}
-
-inline bool Server::set_base_dir(const std::string &dir,
-                                 const std::string &mount_point) {
-  return set_mount_point(mount_point, dir);
-}
-
-inline bool Server::set_mount_point(const std::string &mount_point,
-                                    const std::string &dir, Headers headers) {
-  if (detail::is_dir(dir)) {
-    std::string mnt = !mount_point.empty() ? mount_point : "/";
-    if (!mnt.empty() && mnt[0] == '/') {
-      base_dirs_.push_back({mnt, dir, std::move(headers)});
-      return true;
-    }
-  }
-  return false;
-}
-
-inline bool Server::remove_mount_point(const std::string &mount_point) {
-  for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) {
-    if (it->mount_point == mount_point) {
-      base_dirs_.erase(it);
-      return true;
-    }
-  }
-  return false;
-}
-
-inline Server &
-Server::set_file_extension_and_mimetype_mapping(const std::string &ext,
-                                                const std::string &mime) {
-  file_extension_and_mimetype_map_[ext] = mime;
-  return *this;
-}
-
-inline Server &Server::set_default_file_mimetype(const std::string &mime) {
-  default_file_mimetype_ = mime;
-  return *this;
-}
-
-inline Server &Server::set_file_request_handler(Handler handler) {
-  file_request_handler_ = std::move(handler);
-  return *this;
-}
-
-inline Server &Server::set_error_handler(HandlerWithResponse handler) {
-  error_handler_ = std::move(handler);
-  return *this;
-}
-
-inline Server &Server::set_error_handler(Handler handler) {
-  error_handler_ = [handler](const Request &req, Response &res) {
-    handler(req, res);
-    return HandlerResponse::Handled;
-  };
-  return *this;
-}
-
-inline Server &Server::set_exception_handler(ExceptionHandler handler) {
-  exception_handler_ = std::move(handler);
-  return *this;
-}
-
-inline Server &Server::set_pre_routing_handler(HandlerWithResponse handler) {
-  pre_routing_handler_ = std::move(handler);
-  return *this;
-}
-
-inline Server &Server::set_post_routing_handler(Handler handler) {
-  post_routing_handler_ = std::move(handler);
-  return *this;
-}
-
-inline Server &Server::set_logger(Logger logger) {
-  logger_ = std::move(logger);
-  return *this;
-}
-
-inline Server &
-Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) {
-  expect_100_continue_handler_ = std::move(handler);
-  return *this;
-}
-
-inline Server &Server::set_address_family(int family) {
-  address_family_ = family;
-  return *this;
-}
-
-inline Server &Server::set_tcp_nodelay(bool on) {
-  tcp_nodelay_ = on;
-  return *this;
-}
-
-inline Server &Server::set_socket_options(SocketOptions socket_options) {
-  socket_options_ = std::move(socket_options);
-  return *this;
-}
-
-inline Server &Server::set_default_headers(Headers headers) {
-  default_headers_ = std::move(headers);
-  return *this;
-}
-
-inline Server &Server::set_header_writer(
-    std::function<ssize_t(Stream &, Headers &)> const &writer) {
-  header_writer_ = writer;
-  return *this;
-}
-
-inline Server &Server::set_keep_alive_max_count(size_t count) {
-  keep_alive_max_count_ = count;
-  return *this;
-}
-
-inline Server &Server::set_keep_alive_timeout(time_t sec) {
-  keep_alive_timeout_sec_ = sec;
-  return *this;
-}
-
-inline Server &Server::set_read_timeout(time_t sec, time_t usec) {
-  read_timeout_sec_ = sec;
-  read_timeout_usec_ = usec;
-  return *this;
-}
-
-inline Server &Server::set_write_timeout(time_t sec, time_t usec) {
-  write_timeout_sec_ = sec;
-  write_timeout_usec_ = usec;
-  return *this;
-}
-
-inline Server &Server::set_idle_interval(time_t sec, time_t usec) {
-  idle_interval_sec_ = sec;
-  idle_interval_usec_ = usec;
-  return *this;
-}
-
-inline Server &Server::set_payload_max_length(size_t length) {
-  payload_max_length_ = length;
-  return *this;
-}
-
-inline bool Server::bind_to_port(const std::string &host, int port,
-                                 int socket_flags) {
-  return bind_internal(host, port, socket_flags) >= 0;
-}
-inline int Server::bind_to_any_port(const std::string &host, int socket_flags) {
-  return bind_internal(host, 0, socket_flags);
-}
-
-inline bool Server::listen_after_bind() {
-  auto se = detail::scope_exit([&]() { done_ = true; });
-  return listen_internal();
-}
-
-inline bool Server::listen(const std::string &host, int port,
-                           int socket_flags) {
-  auto se = detail::scope_exit([&]() { done_ = true; });
-  return bind_to_port(host, port, socket_flags) && listen_internal();
-}
-
-inline bool Server::is_running() const { return is_running_; }
-
-inline void Server::wait_until_ready() const {
-  while (!is_running() && !done_) {
-    std::this_thread::sleep_for(std::chrono::milliseconds{1});
-  }
-}
-
-inline void Server::stop() {
-  if (is_running_) {
-    assert(svr_sock_ != INVALID_SOCKET);
-    std::atomic<socket_t> sock(svr_sock_.exchange(INVALID_SOCKET));
-    detail::shutdown_socket(sock);
-    detail::close_socket(sock);
-  }
-}
-
-inline bool Server::parse_request_line(const char *s, Request &req) const {
-  auto len = strlen(s);
-  if (len < 2 || s[len - 2] != '\r' || s[len - 1] != '\n') { return false; }
-  len -= 2;
-
-  {
-    size_t count = 0;
-
-    detail::split(s, s + len, ' ', [&](const char *b, const char *e) {
-      switch (count) {
-      case 0: req.method = std::string(b, e); break;
-      case 1: req.target = std::string(b, e); break;
-      case 2: req.version = std::string(b, e); break;
-      default: break;
-      }
-      count++;
-    });
-
-    if (count != 3) { return false; }
-  }
-
-  static const std::set<std::string> methods{
-      "GET",     "HEAD",    "POST",  "PUT",   "DELETE",
-      "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"};
-
-  if (methods.find(req.method) == methods.end()) { return false; }
-
-  if (req.version != "HTTP/1.1" && req.version != "HTTP/1.0") { return false; }
-
-  {
-    // Skip URL fragment
-    for (size_t i = 0; i < req.target.size(); i++) {
-      if (req.target[i] == '#') {
-        req.target.erase(i);
-        break;
-      }
-    }
-
-    size_t count = 0;
-
-    detail::split(req.target.data(), req.target.data() + req.target.size(), '?',
-                  2, [&](const char *b, const char *e) {
-                    switch (count) {
-                    case 0:
-                      req.path = detail::decode_url(std::string(b, e), false);
-                      break;
-                    case 1: {
-                      if (e - b > 0) {
-                        detail::parse_query_text(std::string(b, e), req.params);
-                      }
-                      break;
-                    }
-                    default: break;
-                    }
-                    count++;
-                  });
-
-    if (count > 2) { return false; }
-  }
-
-  return true;
-}
-
-inline bool Server::write_response(Stream &strm, bool close_connection,
-                                   const Request &req, Response &res) {
-  return write_response_core(strm, close_connection, req, res, false);
-}
-
-inline bool Server::write_response_with_content(Stream &strm,
-                                                bool close_connection,
-                                                const Request &req,
-                                                Response &res) {
-  return write_response_core(strm, close_connection, req, res, true);
-}
-
-inline bool Server::write_response_core(Stream &strm, bool close_connection,
-                                        const Request &req, Response &res,
-                                        bool need_apply_ranges) {
-  assert(res.status != -1);
-
-  if (400 <= res.status && error_handler_ &&
-      error_handler_(req, res) == HandlerResponse::Handled) {
-    need_apply_ranges = true;
-  }
-
-  std::string content_type;
-  std::string boundary;
-  if (need_apply_ranges) { apply_ranges(req, res, content_type, boundary); }
-
-  // Prepare additional headers
-  if (close_connection || req.get_header_value("Connection") == "close") {
-    res.set_header("Connection", "close");
-  } else {
-    std::stringstream ss;
-    ss << "timeout=" << keep_alive_timeout_sec_
-       << ", max=" << keep_alive_max_count_;
-    res.set_header("Keep-Alive", ss.str());
-  }
-
-  if (!res.has_header("Content-Type") &&
-      (!res.body.empty() || res.content_length_ > 0 || res.content_provider_)) {
-    res.set_header("Content-Type", "text/plain");
-  }
-
-  if (!res.has_header("Content-Length") && res.body.empty() &&
-      !res.content_length_ && !res.content_provider_) {
-    res.set_header("Content-Length", "0");
-  }
-
-  if (!res.has_header("Accept-Ranges") && req.method == "HEAD") {
-    res.set_header("Accept-Ranges", "bytes");
-  }
-
-  if (post_routing_handler_) { post_routing_handler_(req, res); }
-
-  // Response line and headers
-  {
-    detail::BufferStream bstrm;
-
-    if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status,
-                            status_message(res.status))) {
-      return false;
-    }
-
-    if (!header_writer_(bstrm, res.headers)) { return false; }
-
-    // Flush buffer
-    auto &data = bstrm.get_buffer();
-    detail::write_data(strm, data.data(), data.size());
-  }
-
-  // Body
-  auto ret = true;
-  if (req.method != "HEAD") {
-    if (!res.body.empty()) {
-      if (!detail::write_data(strm, res.body.data(), res.body.size())) {
-        ret = false;
-      }
-    } else if (res.content_provider_) {
-      if (write_content_with_provider(strm, req, res, boundary, content_type)) {
-        res.content_provider_success_ = true;
-      } else {
-        res.content_provider_success_ = false;
-        ret = false;
-      }
-    }
-  }
-
-  // Log
-  if (logger_) { logger_(req, res); }
-
-  return ret;
-}
-
-inline bool
-Server::write_content_with_provider(Stream &strm, const Request &req,
-                                    Response &res, const std::string &boundary,
-                                    const std::string &content_type) {
-  auto is_shutting_down = [this]() {
-    return this->svr_sock_ == INVALID_SOCKET;
-  };
-
-  if (res.content_length_ > 0) {
-    if (req.ranges.empty()) {
-      return detail::write_content(strm, res.content_provider_, 0,
-                                   res.content_length_, is_shutting_down);
-    } else if (req.ranges.size() == 1) {
-      auto offsets =
-          detail::get_range_offset_and_length(req, res.content_length_, 0);
-      auto offset = offsets.first;
-      auto length = offsets.second;
-      return detail::write_content(strm, res.content_provider_, offset, length,
-                                   is_shutting_down);
-    } else {
-      return detail::write_multipart_ranges_data(
-          strm, req, res, boundary, content_type, is_shutting_down);
-    }
-  } else {
-    if (res.is_chunked_content_provider_) {
-      auto type = detail::encoding_type(req, res);
-
-      std::unique_ptr<detail::compressor> compressor;
-      if (type == detail::EncodingType::Gzip) {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-        compressor = detail::make_unique<detail::gzip_compressor>();
-#endif
-      } else if (type == detail::EncodingType::Brotli) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-        compressor = detail::make_unique<detail::brotli_compressor>();
-#endif
-      } else {
-        compressor = detail::make_unique<detail::nocompressor>();
-      }
-      assert(compressor != nullptr);
-
-      return detail::write_content_chunked(strm, res.content_provider_,
-                                           is_shutting_down, *compressor);
-    } else {
-      return detail::write_content_without_length(strm, res.content_provider_,
-                                                  is_shutting_down);
-    }
-  }
-}
-
-inline bool Server::read_content(Stream &strm, Request &req, Response &res) {
-  MultipartFormDataMap::iterator cur;
-  auto file_count = 0;
-  if (read_content_core(
-          strm, req, res,
-          // Regular
-          [&](const char *buf, size_t n) {
-            if (req.body.size() + n > req.body.max_size()) { return false; }
-            req.body.append(buf, n);
-            return true;
-          },
-          // Multipart
-          [&](const MultipartFormData &file) {
-            if (file_count++ == CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT) {
-              return false;
-            }
-            cur = req.files.emplace(file.name, file);
-            return true;
-          },
-          [&](const char *buf, size_t n) {
-            auto &content = cur->second.content;
-            if (content.size() + n > content.max_size()) { return false; }
-            content.append(buf, n);
-            return true;
-          })) {
-    const auto &content_type = req.get_header_value("Content-Type");
-    if (!content_type.find("application/x-www-form-urlencoded")) {
-      if (req.body.size() > CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH) {
-        res.status = StatusCode::PayloadTooLarge_413; // NOTE: should be 414?
-        return false;
-      }
-      detail::parse_query_text(req.body, req.params);
-    }
-    return true;
-  }
-  return false;
-}
-
-inline bool Server::read_content_with_content_receiver(
-    Stream &strm, Request &req, Response &res, ContentReceiver receiver,
-    MultipartContentHeader multipart_header,
-    ContentReceiver multipart_receiver) {
-  return read_content_core(strm, req, res, std::move(receiver),
-                           std::move(multipart_header),
-                           std::move(multipart_receiver));
-}
-
-inline bool
-Server::read_content_core(Stream &strm, Request &req, Response &res,
-                          ContentReceiver receiver,
-                          MultipartContentHeader multipart_header,
-                          ContentReceiver multipart_receiver) const {
-  detail::MultipartFormDataParser multipart_form_data_parser;
-  ContentReceiverWithProgress out;
-
-  if (req.is_multipart_form_data()) {
-    const auto &content_type = req.get_header_value("Content-Type");
-    std::string boundary;
-    if (!detail::parse_multipart_boundary(content_type, boundary)) {
-      res.status = StatusCode::BadRequest_400;
-      return false;
-    }
-
-    multipart_form_data_parser.set_boundary(std::move(boundary));
-    out = [&](const char *buf, size_t n, uint64_t /*off*/, uint64_t /*len*/) {
-      /* For debug
-      size_t pos = 0;
-      while (pos < n) {
-        auto read_size = (std::min)<size_t>(1, n - pos);
-        auto ret = multipart_form_data_parser.parse(
-            buf + pos, read_size, multipart_receiver, multipart_header);
-        if (!ret) { return false; }
-        pos += read_size;
-      }
-      return true;
-      */
-      return multipart_form_data_parser.parse(buf, n, multipart_receiver,
-                                              multipart_header);
-    };
-  } else {
-    out = [receiver](const char *buf, size_t n, uint64_t /*off*/,
-                     uint64_t /*len*/) { return receiver(buf, n); };
-  }
-
-  if (req.method == "DELETE" && !req.has_header("Content-Length")) {
-    return true;
-  }
-
-  if (!detail::read_content(strm, req, payload_max_length_, res.status, nullptr,
-                            out, true)) {
-    return false;
-  }
-
-  if (req.is_multipart_form_data()) {
-    if (!multipart_form_data_parser.is_valid()) {
-      res.status = StatusCode::BadRequest_400;
-      return false;
-    }
-  }
-
-  return true;
-}
-
-inline bool Server::handle_file_request(const Request &req, Response &res,
-                                        bool head) {
-  for (const auto &entry : base_dirs_) {
-    // Prefix match
-    if (!req.path.compare(0, entry.mount_point.size(), entry.mount_point)) {
-      std::string sub_path = "/" + req.path.substr(entry.mount_point.size());
-      if (detail::is_valid_path(sub_path)) {
-        auto path = entry.base_dir + sub_path;
-        if (path.back() == '/') { path += "index.html"; }
-
-        if (detail::is_file(path)) {
-          for (const auto &kv : entry.headers) {
-            res.set_header(kv.first, kv.second);
-          }
-
-          auto mm = std::make_shared<detail::mmap>(path.c_str());
-          if (!mm->is_open()) { return false; }
-
-          res.set_content_provider(
-              mm->size(),
-              detail::find_content_type(path, file_extension_and_mimetype_map_,
-                                        default_file_mimetype_),
-              [mm](size_t offset, size_t length, DataSink &sink) -> bool {
-                sink.write(mm->data() + offset, length);
-                return true;
-              });
-
-          if (!head && file_request_handler_) {
-            file_request_handler_(req, res);
-          }
-
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-
-inline socket_t
-Server::create_server_socket(const std::string &host, int port,
-                             int socket_flags,
-                             SocketOptions socket_options) const {
-  return detail::create_socket(
-      host, std::string(), port, address_family_, socket_flags, tcp_nodelay_,
-      std::move(socket_options),
-      [](socket_t sock, struct addrinfo &ai) -> bool {
-        if (::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
-          return false;
-        }
-        if (::listen(sock, CPPHTTPLIB_LISTEN_BACKLOG)) { return false; }
-        return true;
-      });
-}
-
-inline int Server::bind_internal(const std::string &host, int port,
-                                 int socket_flags) {
-  if (!is_valid()) { return -1; }
-
-  svr_sock_ = create_server_socket(host, port, socket_flags, socket_options_);
-  if (svr_sock_ == INVALID_SOCKET) { return -1; }
-
-  if (port == 0) {
-    struct sockaddr_storage addr;
-    socklen_t addr_len = sizeof(addr);
-    if (getsockname(svr_sock_, reinterpret_cast<struct sockaddr *>(&addr),
-                    &addr_len) == -1) {
-      return -1;
-    }
-    if (addr.ss_family == AF_INET) {
-      return ntohs(reinterpret_cast<struct sockaddr_in *>(&addr)->sin_port);
-    } else if (addr.ss_family == AF_INET6) {
-      return ntohs(reinterpret_cast<struct sockaddr_in6 *>(&addr)->sin6_port);
-    } else {
-      return -1;
-    }
-  } else {
-    return port;
-  }
-}
-
-inline bool Server::listen_internal() {
-  auto ret = true;
-  is_running_ = true;
-  auto se = detail::scope_exit([&]() { is_running_ = false; });
-
-  {
-    std::unique_ptr<TaskQueue> task_queue(new_task_queue());
-
-    while (svr_sock_ != INVALID_SOCKET) {
-#ifndef _WIN32
-      if (idle_interval_sec_ > 0 || idle_interval_usec_ > 0) {
-#endif
-        auto val = detail::select_read(svr_sock_, idle_interval_sec_,
-                                       idle_interval_usec_);
-        if (val == 0) { // Timeout
-          task_queue->on_idle();
-          continue;
-        }
-#ifndef _WIN32
-      }
-#endif
-      socket_t sock = accept(svr_sock_, nullptr, nullptr);
-
-      if (sock == INVALID_SOCKET) {
-        if (errno == EMFILE) {
-          // The per-process limit of open file descriptors has been reached.
-          // Try to accept new connections after a short sleep.
-          std::this_thread::sleep_for(std::chrono::milliseconds(1));
-          continue;
-        } else if (errno == EINTR || errno == EAGAIN) {
-          continue;
-        }
-        if (svr_sock_ != INVALID_SOCKET) {
-          detail::close_socket(svr_sock_);
-          ret = false;
-        } else {
-          ; // The server socket was closed by user.
-        }
-        break;
-      }
-
-      {
-#ifdef _WIN32
-        auto timeout = static_cast<uint32_t>(read_timeout_sec_ * 1000 +
-                                             read_timeout_usec_ / 1000);
-        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
-                   reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
-        timeval tv;
-        tv.tv_sec = static_cast<long>(read_timeout_sec_);
-        tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec_);
-        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
-                   reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
-      }
-      {
-
-#ifdef _WIN32
-        auto timeout = static_cast<uint32_t>(write_timeout_sec_ * 1000 +
-                                             write_timeout_usec_ / 1000);
-        setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
-                   reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
-        timeval tv;
-        tv.tv_sec = static_cast<long>(write_timeout_sec_);
-        tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec_);
-        setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
-                   reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
-      }
-
-      task_queue->enqueue([this, sock]() { process_and_close_socket(sock); });
-    }
-
-    task_queue->shutdown();
-  }
-
-  return ret;
-}
-
-inline bool Server::routing(Request &req, Response &res, Stream &strm) {
-  if (pre_routing_handler_ &&
-      pre_routing_handler_(req, res) == HandlerResponse::Handled) {
-    return true;
-  }
-
-  // File handler
-  auto is_head_request = req.method == "HEAD";
-  if ((req.method == "GET" || is_head_request) &&
-      handle_file_request(req, res, is_head_request)) {
-    return true;
-  }
-
-  if (detail::expect_content(req)) {
-    // Content reader handler
-    {
-      ContentReader reader(
-          [&](ContentReceiver receiver) {
-            return read_content_with_content_receiver(
-                strm, req, res, std::move(receiver), nullptr, nullptr);
-          },
-          [&](MultipartContentHeader header, ContentReceiver receiver) {
-            return read_content_with_content_receiver(strm, req, res, nullptr,
-                                                      std::move(header),
-                                                      std::move(receiver));
-          });
-
-      if (req.method == "POST") {
-        if (dispatch_request_for_content_reader(
-                req, res, std::move(reader),
-                post_handlers_for_content_reader_)) {
-          return true;
-        }
-      } else if (req.method == "PUT") {
-        if (dispatch_request_for_content_reader(
-                req, res, std::move(reader),
-                put_handlers_for_content_reader_)) {
-          return true;
-        }
-      } else if (req.method == "PATCH") {
-        if (dispatch_request_for_content_reader(
-                req, res, std::move(reader),
-                patch_handlers_for_content_reader_)) {
-          return true;
-        }
-      } else if (req.method == "DELETE") {
-        if (dispatch_request_for_content_reader(
-                req, res, std::move(reader),
-                delete_handlers_for_content_reader_)) {
-          return true;
-        }
-      }
-    }
-
-    // Read content into `req.body`
-    if (!read_content(strm, req, res)) { return false; }
-  }
-
-  // Regular handler
-  if (req.method == "GET" || req.method == "HEAD") {
-    return dispatch_request(req, res, get_handlers_);
-  } else if (req.method == "POST") {
-    return dispatch_request(req, res, post_handlers_);
-  } else if (req.method == "PUT") {
-    return dispatch_request(req, res, put_handlers_);
-  } else if (req.method == "DELETE") {
-    return dispatch_request(req, res, delete_handlers_);
-  } else if (req.method == "OPTIONS") {
-    return dispatch_request(req, res, options_handlers_);
-  } else if (req.method == "PATCH") {
-    return dispatch_request(req, res, patch_handlers_);
-  }
-
-  res.status = StatusCode::BadRequest_400;
-  return false;
-}
-
-inline bool Server::dispatch_request(Request &req, Response &res,
-                                     const Handlers &handlers) const {
-  for (const auto &x : handlers) {
-    const auto &pattern = x.first;
-    const auto &handler = x.second;
-
-    if (duckdb_re2::RegexMatch(req.path, req.matches, pattern)) {
-      handler(req, res);
-      return true;
-    }
-  }
-  return false;
-}
-
-inline void Server::apply_ranges(const Request &req, Response &res,
-                                 std::string &content_type,
-                                 std::string &boundary) const {
-  if (req.ranges.size() > 1) {
-    boundary = detail::make_multipart_data_boundary();
-
-    auto it = res.headers.find("Content-Type");
-    if (it != res.headers.end()) {
-      content_type = it->second;
-      res.headers.erase(it);
-    }
-
-    res.set_header("Content-Type",
-                   "multipart/byteranges; boundary=" + boundary);
-  }
-
-  auto type = detail::encoding_type(req, res);
-
-  if (res.body.empty()) {
-    if (res.content_length_ > 0) {
-      size_t length = 0;
-      if (req.ranges.empty()) {
-        length = res.content_length_;
-      } else if (req.ranges.size() == 1) {
-        auto offsets =
-            detail::get_range_offset_and_length(req, res.content_length_, 0);
-        length = offsets.second;
-
-        auto content_range = detail::make_content_range_header_field(
-            req.ranges[0], res.content_length_);
-        res.set_header("Content-Range", content_range);
-      } else {
-        length = detail::get_multipart_ranges_data_length(req, res, boundary,
-                                                          content_type);
-      }
-      res.set_header("Content-Length", std::to_string(length));
-    } else {
-      if (res.content_provider_) {
-        if (res.is_chunked_content_provider_) {
-          res.set_header("Transfer-Encoding", "chunked");
-          if (type == detail::EncodingType::Gzip) {
-            res.set_header("Content-Encoding", "gzip");
-          } else if (type == detail::EncodingType::Brotli) {
-            res.set_header("Content-Encoding", "br");
-          }
-        }
-      }
-    }
-  } else {
-    if (req.ranges.empty()) {
-      ;
-    } else if (req.ranges.size() == 1) {
-      auto content_range = detail::make_content_range_header_field(
-          req.ranges[0], res.body.size());
-      res.set_header("Content-Range", content_range);
-
-      auto offsets =
-          detail::get_range_offset_and_length(req, res.body.size(), 0);
-      auto offset = offsets.first;
-      auto length = offsets.second;
-
-      if (offset < res.body.size()) {
-        res.body = res.body.substr(offset, length);
-      } else {
-        res.body.clear();
-        res.status = StatusCode::RangeNotSatisfiable_416;
-      }
-    } else {
-      std::string data;
-      if (detail::make_multipart_ranges_data(req, res, boundary, content_type,
-                                             data)) {
-        res.body.swap(data);
-      } else {
-        res.body.clear();
-        res.status = StatusCode::RangeNotSatisfiable_416;
-      }
-    }
-
-    if (type != detail::EncodingType::None) {
-      std::unique_ptr<detail::compressor> compressor;
-      std::string content_encoding;
-
-      if (type == detail::EncodingType::Gzip) {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-        compressor = detail::make_unique<detail::gzip_compressor>();
-        content_encoding = "gzip";
-#endif
-      } else if (type == detail::EncodingType::Brotli) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-        compressor = detail::make_unique<detail::brotli_compressor>();
-        content_encoding = "br";
-#endif
-      }
-
-      if (compressor) {
-        std::string compressed;
-        if (compressor->compress(res.body.data(), res.body.size(), true,
-                                 [&](const char *data, size_t data_len) {
-                                   compressed.append(data, data_len);
-                                   return true;
-                                 })) {
-          res.body.swap(compressed);
-          res.set_header("Content-Encoding", content_encoding);
-        }
-      }
-    }
-
-    auto length = std::to_string(res.body.size());
-    res.set_header("Content-Length", length);
-  }
-}
-
-inline bool Server::dispatch_request_for_content_reader(
-    Request &req, Response &res, ContentReader content_reader,
-    const HandlersForContentReader &handlers) const {
-  for (const auto &x : handlers) {
-    const auto &pattern = x.first;
-    const auto &handler = x.second;
-
-    if (duckdb_re2::RegexMatch(req.path, req.matches, pattern)) {
-      handler(req, res, content_reader);
-      return true;
-    }
-  }
-  return false;
-}
-
-inline bool
-Server::process_request(Stream &strm, bool close_connection,
-                        bool &connection_closed,
-                        const std::function<void(Request &)> &setup_request) {
-  std::array<char, 2048> buf{};
-
-  detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
-
-  // Connection has been closed on client
-  if (!line_reader.getline()) { return false; }
-
-  Request req;
-
-  Response res;
-  res.version = "HTTP/1.1";
-  res.headers = default_headers_;
-
-#ifdef _WIN32
-  // TODO: Increase FD_SETSIZE statically (libzmq), dynamically (MySQL).
-#else
-#ifndef CPPHTTPLIB_USE_POLL
-  // Socket file descriptor exceeded FD_SETSIZE...
-  if (strm.socket() >= FD_SETSIZE) {
-    Headers dummy;
-    detail::read_headers(strm, dummy);
-    res.status = StatusCode::InternalServerError_500;
-    return write_response(strm, close_connection, req, res);
-  }
-#endif
-#endif
-
-  // Check if the request URI doesn't exceed the limit
-  if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) {
-    Headers dummy;
-    detail::read_headers(strm, dummy);
-    res.status = StatusCode::UriTooLong_414;
-    return write_response(strm, close_connection, req, res);
-  }
-
-  // Request line and headers
-  if (!parse_request_line(line_reader.ptr(), req) ||
-      !detail::read_headers(strm, req.headers)) {
-    res.status = StatusCode::BadRequest_400;
-    return write_response(strm, close_connection, req, res);
-  }
-
-  if (req.get_header_value("Connection") == "close") {
-    connection_closed = true;
-  }
-
-  if (req.version == "HTTP/1.0" &&
-      req.get_header_value("Connection") != "Keep-Alive") {
-    connection_closed = true;
-  }
-
-  strm.get_remote_ip_and_port(req.remote_addr, req.remote_port);
-  req.set_header("REMOTE_ADDR", req.remote_addr);
-  req.set_header("REMOTE_PORT", std::to_string(req.remote_port));
-
-  strm.get_local_ip_and_port(req.local_addr, req.local_port);
-  req.set_header("LOCAL_ADDR", req.local_addr);
-  req.set_header("LOCAL_PORT", std::to_string(req.local_port));
-
-  if (req.has_header("Range")) {
-    const auto &range_header_value = req.get_header_value("Range");
-    if (!detail::parse_range_header(range_header_value, req.ranges)) {
-      res.status = StatusCode::RangeNotSatisfiable_416;
-      return write_response(strm, close_connection, req, res);
-    }
-  }
-
-  if (setup_request) { setup_request(req); }
-
-  if (req.get_header_value("Expect") == "100-continue") {
-    int status = StatusCode::Continue_100;
-    if (expect_100_continue_handler_) {
-      status = expect_100_continue_handler_(req, res);
-    }
-    switch (status) {
-    case StatusCode::Continue_100:
-    case StatusCode::ExpectationFailed_417:
-      strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status,
-                        status_message(status));
-      break;
-    default: return write_response(strm, close_connection, req, res);
-    }
-  }
-
-  // Rounting
-  auto routed = false;
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-  routed = routing(req, res, strm);
-#else
-  try {
-    routed = routing(req, res, strm);
-  } catch (std::exception &e) {
-    if (exception_handler_) {
-      auto ep = std::current_exception();
-      exception_handler_(req, res, ep);
-      routed = true;
-    } else {
-      res.status = StatusCode::InternalServerError_500;
-      std::string val;
-      auto s = e.what();
-      for (size_t i = 0; s[i]; i++) {
-        switch (s[i]) {
-        case '\r': val += "\\r"; break;
-        case '\n': val += "\\n"; break;
-        default: val += s[i]; break;
-        }
-      }
-      res.set_header("EXCEPTION_WHAT", val);
-    }
-  } catch (...) {
-    if (exception_handler_) {
-      auto ep = std::current_exception();
-      exception_handler_(req, res, ep);
-      routed = true;
-    } else {
-      res.status = StatusCode::InternalServerError_500;
-      res.set_header("EXCEPTION_WHAT", "UNKNOWN");
-    }
-  }
-#endif
-
-  if (routed) {
-    if (res.status == -1) {
-      res.status = req.ranges.empty() ? StatusCode::OK_200
-                                      : StatusCode::PartialContent_206;
-    }
-    return write_response_with_content(strm, close_connection, req, res);
-  } else {
-    if (res.status == -1) { res.status = StatusCode::NotFound_404; }
-    return write_response(strm, close_connection, req, res);
-  }
-}
-
-inline bool Server::is_valid() const { return true; }
-
-inline bool Server::process_and_close_socket(socket_t sock) {
-  auto ret = detail::process_server_socket(
-      svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
-      read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-      write_timeout_usec_,
-      [this](Stream &strm, bool close_connection, bool &connection_closed) {
-        return process_request(strm, close_connection, connection_closed,
-                               nullptr);
-      });
-
-  detail::shutdown_socket(sock);
-  detail::close_socket(sock);
-  return ret;
-}
-
-// HTTP client implementation
-inline ClientImpl::ClientImpl(const std::string &host)
-    : ClientImpl(host, 80, std::string(), std::string()) {}
-
-inline ClientImpl::ClientImpl(const std::string &host, int port)
-    : ClientImpl(host, port, std::string(), std::string()) {}
-
-inline ClientImpl::ClientImpl(const std::string &host, int port,
-                              const std::string &client_cert_path,
-                              const std::string &client_key_path)
-    : host_(host), port_(port),
-      host_and_port_(adjust_host_string(host) + ":" + std::to_string(port)),
-      client_cert_path_(client_cert_path), client_key_path_(client_key_path) {}
-
-inline ClientImpl::~ClientImpl() {
-  std::lock_guard<std::mutex> guard(socket_mutex_);
-  shutdown_socket(socket_);
-  close_socket(socket_);
-}
-
-inline bool ClientImpl::is_valid() const { return true; }
-
-inline void ClientImpl::copy_settings(const ClientImpl &rhs) {
-  client_cert_path_ = rhs.client_cert_path_;
-  client_key_path_ = rhs.client_key_path_;
-  connection_timeout_sec_ = rhs.connection_timeout_sec_;
-  read_timeout_sec_ = rhs.read_timeout_sec_;
-  read_timeout_usec_ = rhs.read_timeout_usec_;
-  write_timeout_sec_ = rhs.write_timeout_sec_;
-  write_timeout_usec_ = rhs.write_timeout_usec_;
-  basic_auth_username_ = rhs.basic_auth_username_;
-  basic_auth_password_ = rhs.basic_auth_password_;
-  bearer_token_auth_token_ = rhs.bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  digest_auth_username_ = rhs.digest_auth_username_;
-  digest_auth_password_ = rhs.digest_auth_password_;
-#endif
-  keep_alive_ = rhs.keep_alive_;
-  follow_location_ = rhs.follow_location_;
-  url_encode_ = rhs.url_encode_;
-  address_family_ = rhs.address_family_;
-  tcp_nodelay_ = rhs.tcp_nodelay_;
-  socket_options_ = rhs.socket_options_;
-  compress_ = rhs.compress_;
-  decompress_ = rhs.decompress_;
-  interface_ = rhs.interface_;
-  proxy_host_ = rhs.proxy_host_;
-  proxy_port_ = rhs.proxy_port_;
-  proxy_basic_auth_username_ = rhs.proxy_basic_auth_username_;
-  proxy_basic_auth_password_ = rhs.proxy_basic_auth_password_;
-  proxy_bearer_token_auth_token_ = rhs.proxy_bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_;
-  proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_;
-#endif
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  ca_cert_file_path_ = rhs.ca_cert_file_path_;
-  ca_cert_dir_path_ = rhs.ca_cert_dir_path_;
-  ca_cert_store_ = rhs.ca_cert_store_;
-#endif
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  server_certificate_verification_ = rhs.server_certificate_verification_;
-#endif
-  logger_ = rhs.logger_;
-}
-
-inline socket_t ClientImpl::create_client_socket(Error &error) const {
-  if (!proxy_host_.empty() && proxy_port_ != -1) {
-    return detail::create_client_socket(
-        proxy_host_, std::string(), proxy_port_, address_family_, tcp_nodelay_,
-        socket_options_, connection_timeout_sec_, connection_timeout_usec_,
-        read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-        write_timeout_usec_, interface_, error);
-  }
-
-  // Check is custom IP specified for host_
-  std::string ip;
-  auto it = addr_map_.find(host_);
-  if (it != addr_map_.end()) { ip = it->second; }
-
-  return detail::create_client_socket(
-      host_, ip, port_, address_family_, tcp_nodelay_, socket_options_,
-      connection_timeout_sec_, connection_timeout_usec_, read_timeout_sec_,
-      read_timeout_usec_, write_timeout_sec_, write_timeout_usec_, interface_,
-      error);
-}
-
-inline bool ClientImpl::create_and_connect_socket(Socket &socket,
-                                                  Error &error) {
-  auto sock = create_client_socket(error);
-  if (sock == INVALID_SOCKET) { return false; }
-  socket.sock = sock;
-  return true;
-}
-
-inline void ClientImpl::shutdown_ssl(Socket & /*socket*/,
-                                     bool /*shutdown_gracefully*/) {
-  // If there are any requests in flight from threads other than us, then it's
-  // a thread-unsafe race because individual ssl* objects are not thread-safe.
-  assert(socket_requests_in_flight_ == 0 ||
-         socket_requests_are_from_thread_ == std::this_thread::get_id());
-}
-
-inline void ClientImpl::shutdown_socket(Socket &socket) const {
-  if (socket.sock == INVALID_SOCKET) { return; }
-  detail::shutdown_socket(socket.sock);
-}
-
-inline void ClientImpl::close_socket(Socket &socket) {
-  // If there are requests in flight in another thread, usually closing
-  // the socket will be fine and they will simply receive an error when
-  // using the closed socket, but it is still a bug since rarely the OS
-  // may reassign the socket id to be used for a new socket, and then
-  // suddenly they will be operating on a live socket that is different
-  // than the one they intended!
-  assert(socket_requests_in_flight_ == 0 ||
-         socket_requests_are_from_thread_ == std::this_thread::get_id());
-
-  // It is also a bug if this happens while SSL is still active
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  assert(socket.ssl == nullptr);
-#endif
-  if (socket.sock == INVALID_SOCKET) { return; }
-  detail::close_socket(socket.sock);
-  socket.sock = INVALID_SOCKET;
-}
-
-inline bool ClientImpl::read_response_line(Stream &strm, const Request &req,
-                                           Response &res) const {
-  std::array<char, 2048> buf{};
-
-  detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
-
-  if (!line_reader.getline()) { return false; }
-
-#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
-  const static Regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r?\n");
-#else
-  const static Regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r\n");
-#endif
-
-  Match m;
-  if (!RegexMatch(line_reader.ptr(), m, re)) {
-    return req.method == "CONNECT";
-  }
-  res.version = std::string(m[1]);
-  res.status = std::stoi(std::string(m[2]));
-  res.reason = std::string(m[3]);
-
-  // Ignore '100 Continue'
-  while (res.status == StatusCode::Continue_100) {
-    if (!line_reader.getline()) { return false; } // CRLF
-    if (!line_reader.getline()) { return false; } // next response line
-
-    if (!RegexMatch(line_reader.ptr(), m, re)) { return false; }
-    res.version = std::string(m[1]);
-    res.status = std::stoi(std::string(m[2]));
-    res.reason = std::string(m[3]);
-  }
-
-  return true;
-}
-
-inline bool ClientImpl::send(Request &req, Response &res, Error &error) {
-  std::lock_guard<std::recursive_mutex> request_mutex_guard(request_mutex_);
-  auto ret = send_(req, res, error);
-  if (error == Error::SSLPeerCouldBeClosed_) {
-    assert(!ret);
-    ret = send_(req, res, error);
-  }
-  return ret;
-}
-
-inline bool ClientImpl::send_(Request &req, Response &res, Error &error) {
-  {
-    std::lock_guard<std::mutex> guard(socket_mutex_);
-
-    // Set this to false immediately - if it ever gets set to true by the end of
-    // the request, we know another thread instructed us to close the socket.
-    socket_should_be_closed_when_request_is_done_ = false;
-
-    auto is_alive = false;
-    if (socket_.is_open()) {
-      is_alive = detail::is_socket_alive(socket_.sock);
-      if (!is_alive) {
-        // Attempt to avoid sigpipe by shutting down nongracefully if it seems
-        // like the other side has already closed the connection Also, there
-        // cannot be any requests in flight from other threads since we locked
-        // request_mutex_, so safe to close everything immediately
-        const bool shutdown_gracefully = false;
-        shutdown_ssl(socket_, shutdown_gracefully);
-        shutdown_socket(socket_);
-        close_socket(socket_);
-      }
-    }
-
-    if (!is_alive) {
-      if (!create_and_connect_socket(socket_, error)) { return false; }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-      // TODO: refactoring
-      if (is_ssl()) {
-        auto &scli = static_cast<SSLClient &>(*this);
-        if (!proxy_host_.empty() && proxy_port_ != -1) {
-          auto success = false;
-          if (!scli.connect_with_proxy(socket_, res, success, error)) {
-            return success;
-          }
-        }
-
-        if (!scli.initialize_ssl(socket_, error)) { return false; }
-      }
-#endif
-    }
-
-    // Mark the current socket as being in use so that it cannot be closed by
-    // anyone else while this request is ongoing, even though we will be
-    // releasing the mutex.
-    if (socket_requests_in_flight_ > 1) {
-      assert(socket_requests_are_from_thread_ == std::this_thread::get_id());
-    }
-    socket_requests_in_flight_ += 1;
-    socket_requests_are_from_thread_ = std::this_thread::get_id();
-  }
-
-  for (const auto &header : default_headers_) {
-    if (req.headers.find(header.first) == req.headers.end()) {
-      req.headers.insert(header);
-    }
-  }
-
-  auto ret = false;
-  auto close_connection = !keep_alive_;
-
-  auto se = detail::scope_exit([&]() {
-    // Briefly lock mutex in order to mark that a request is no longer ongoing
-    std::lock_guard<std::mutex> guard(socket_mutex_);
-    socket_requests_in_flight_ -= 1;
-    if (socket_requests_in_flight_ <= 0) {
-      assert(socket_requests_in_flight_ == 0);
-      socket_requests_are_from_thread_ = std::thread::id();
-    }
-
-    if (socket_should_be_closed_when_request_is_done_ || close_connection ||
-        !ret) {
-      shutdown_ssl(socket_, true);
-      shutdown_socket(socket_);
-      close_socket(socket_);
-    }
-  });
-
-  ret = process_socket(socket_, [&](Stream &strm) {
-    return handle_request(strm, req, res, close_connection, error);
-  });
-
-  if (!ret) {
-    if (error == Error::Success) { error = Error::Unknown; }
-  }
-
-  return ret;
-}
-
-inline Result ClientImpl::send(const Request &req) {
-  auto req2 = req;
-  return send_(std::move(req2));
-}
-
-inline Result ClientImpl::send_(Request &&req) {
-  auto res = detail::make_unique<Response>();
-  auto error = Error::Success;
-  auto ret = send(req, *res, error);
-  return Result{ret ? std::move(res) : nullptr, error, std::move(req.headers)};
-}
-
-inline bool ClientImpl::handle_request(Stream &strm, Request &req,
-                                       Response &res, bool close_connection,
-                                       Error &error) {
-  if (req.path.empty()) {
-    error = Error::Connection;
-    return false;
-  }
-
-  auto req_save = req;
-
-  bool ret;
-
-  if (!is_ssl() && !proxy_host_.empty() && proxy_port_ != -1) {
-    auto req2 = req;
-    req2.path = "http://" + host_and_port_ + req.path;
-    ret = process_request(strm, req2, res, close_connection, error);
-    req = req2;
-    req.path = req_save.path;
-  } else {
-    ret = process_request(strm, req, res, close_connection, error);
-  }
-
-  if (!ret) { return false; }
-
-  if (res.get_header_value("Connection") == "close" ||
-      (res.version == "HTTP/1.0" && res.reason != "Connection established")) {
-    // TODO this requires a not-entirely-obvious chain of calls to be correct
-    // for this to be safe.
-
-    // This is safe to call because handle_request is only called by send_
-    // which locks the request mutex during the process. It would be a bug
-    // to call it from a different thread since it's a thread-safety issue
-    // to do these things to the socket if another thread is using the socket.
-    std::lock_guard<std::mutex> guard(socket_mutex_);
-    shutdown_ssl(socket_, true);
-    shutdown_socket(socket_);
-    close_socket(socket_);
-  }
-
-  if (300 < res.status && res.status < 400 && follow_location_) {
-    req = req_save;
-    ret = redirect(req, res, error);
-  }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  if ((res.status == StatusCode::Unauthorized_401 ||
-       res.status == StatusCode::ProxyAuthenticationRequired_407) &&
-      req.authorization_count_ < 5) {
-    auto is_proxy = res.status == StatusCode::ProxyAuthenticationRequired_407;
-    const auto &username =
-        is_proxy ? proxy_digest_auth_username_ : digest_auth_username_;
-    const auto &password =
-        is_proxy ? proxy_digest_auth_password_ : digest_auth_password_;
-
-    if (!username.empty() && !password.empty()) {
-      std::map<std::string, std::string> auth;
-      if (detail::parse_www_authenticate(res, auth, is_proxy)) {
-        Request new_req = req;
-        new_req.authorization_count_ += 1;
-        new_req.headers.erase(is_proxy ? "Proxy-Authorization"
-                                       : "Authorization");
-        new_req.headers.insert(detail::make_digest_authentication_header(
-            req, auth, new_req.authorization_count_, detail::random_string(10),
-            username, password, is_proxy));
-
-        Response new_res;
-
-        ret = send(new_req, new_res, error);
-        if (ret) { res = new_res; }
-      }
-    }
-  }
-#endif
-
-  return ret;
-}
-
-inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) {
-  if (req.redirect_count_ == 0) {
-    error = Error::ExceedRedirectCount;
-    return false;
-  }
-
-  auto location = res.get_header_value("location");
-  if (location.empty()) { return false; }
-
-  const static Regex re(
-      R"((?:(https?):)?(?://(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)?([^?#]*)(\?[^#]*)?(?:#.*)?)");
-
-  Match m;
-  if (!RegexMatch(location, m, re)) { return false; }
-
-  auto scheme = is_ssl() ? "https" : "http";
-
-  auto next_scheme = m[1].str();
-  auto next_host = m[2].str();
-  if (next_host.empty()) { next_host = m[3].str(); }
-  auto port_str = m[4].str();
-  auto next_path = m[5].str();
-  auto next_query = m[6].str();
-
-  auto next_port = port_;
-  if (!port_str.empty()) {
-    next_port = std::stoi(port_str);
-  } else if (!next_scheme.empty()) {
-    next_port = next_scheme == "https" ? 443 : 80;
-  }
-
-  if (next_scheme.empty()) { next_scheme = scheme; }
-  if (next_host.empty()) { next_host = host_; }
-  if (next_path.empty()) { next_path = "/"; }
-  
-  auto path = detail::decode_url(next_path, true, std::set<char> {'/'}) + next_query;
-	
-  if (next_scheme == scheme && next_host == host_ && next_port == port_) {
-    return detail::redirect(*this, req, res, path, location, error);
-  } else {
-    if (next_scheme == "https") {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-      SSLClient cli(next_host, next_port);
-      cli.copy_settings(*this);
-      if (ca_cert_store_) { cli.set_ca_cert_store(ca_cert_store_); }
-      return detail::redirect(cli, req, res, path, location, error);
-#else
-      return false;
-#endif
-    } else {
-      ClientImpl cli(next_host, next_port);
-      cli.copy_settings(*this);
-      return detail::redirect(cli, req, res, path, location, error);
-    }
-  }
-}
-
-inline bool ClientImpl::write_content_with_provider(Stream &strm,
-                                                    const Request &req,
-                                                    Error &error) const {
-  auto is_shutting_down = []() { return false; };
-
-  if (req.is_chunked_content_provider_) {
-    // TODO: Brotli support
-    std::unique_ptr<detail::compressor> compressor;
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-    if (compress_) {
-      compressor = detail::make_unique<detail::gzip_compressor>();
-    } else
-#endif
-    {
-      compressor = detail::make_unique<detail::nocompressor>();
-    }
-
-    return detail::write_content_chunked(strm, req.content_provider_,
-                                         is_shutting_down, *compressor, error);
-  } else {
-    return detail::write_content(strm, req.content_provider_, 0,
-                                 req.content_length_, is_shutting_down, error);
-  }
-}
-
-inline bool ClientImpl::write_request(Stream &strm, Request &req,
-                                      bool close_connection, Error &error) {
-  // Prepare additional headers
-  if (close_connection) {
-    if (!req.has_header("Connection")) {
-      req.set_header("Connection", "close");
-    }
-  }
-
-  if (!req.has_header("Host")) {
-    if (is_ssl()) {
-      if (port_ == 443) {
-        req.set_header("Host", host_);
-      } else {
-        req.set_header("Host", host_and_port_);
-      }
-    } else {
-      if (port_ == 80) {
-        req.set_header("Host", host_);
-      } else {
-        req.set_header("Host", host_and_port_);
-      }
-    }
-  }
-
-  if (!req.has_header("Accept")) { req.set_header("Accept", "*/*"); }
-
-#ifndef CPPHTTPLIB_NO_DEFAULT_USER_AGENT
-  if (!req.has_header("User-Agent")) {
-    auto agent = std::string("cpp-httplib/") + CPPHTTPLIB_VERSION;
-    req.set_header("User-Agent", agent);
-  }
-#endif
-
-  if (req.body.empty()) {
-    if (req.content_provider_) {
-      if (!req.is_chunked_content_provider_) {
-        if (!req.has_header("Content-Length")) {
-          auto length = std::to_string(req.content_length_);
-          req.set_header("Content-Length", length);
-        }
-      }
-    } else {
-      if (req.method == "POST" || req.method == "PUT" ||
-          req.method == "PATCH") {
-        req.set_header("Content-Length", "0");
-      }
-    }
-  } else {
-    if (!req.has_header("Content-Type")) {
-      req.set_header("Content-Type", "text/plain");
-    }
-
-    if (!req.has_header("Content-Length")) {
-      auto length = std::to_string(req.body.size());
-      req.set_header("Content-Length", length);
-    }
-  }
-
-  if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) {
-    if (!req.has_header("Authorization")) {
-      req.headers.insert(make_basic_authentication_header(
-          basic_auth_username_, basic_auth_password_, false));
-    }
-  }
-
-  if (!proxy_basic_auth_username_.empty() &&
-      !proxy_basic_auth_password_.empty()) {
-    if (!req.has_header("Proxy-Authorization")) {
-      req.headers.insert(make_basic_authentication_header(
-          proxy_basic_auth_username_, proxy_basic_auth_password_, true));
-    }
-  }
-
-  if (!bearer_token_auth_token_.empty()) {
-    if (!req.has_header("Authorization")) {
-      req.headers.insert(make_bearer_token_authentication_header(
-          bearer_token_auth_token_, false));
-    }
-  }
-
-  if (!proxy_bearer_token_auth_token_.empty()) {
-    if (!req.has_header("Proxy-Authorization")) {
-      req.headers.insert(make_bearer_token_authentication_header(
-          proxy_bearer_token_auth_token_, true));
-    }
-  }
-
-  // Request line and headers
-  {
-    detail::BufferStream bstrm;
-
-    const auto &path = url_encode_ ? detail::encode_url(req.path) : req.path;
-    bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str());
-
-    header_writer_(bstrm, req.headers);
-
-    // Flush buffer
-    auto &data = bstrm.get_buffer();
-    if (!detail::write_data(strm, data.data(), data.size())) {
-      error = Error::Write;
-      return false;
-    }
-  }
-
-  // Body
-  if (req.body.empty()) {
-    return write_content_with_provider(strm, req, error);
-  }
-
-  if (!detail::write_data(strm, req.body.data(), req.body.size())) {
-    error = Error::Write;
-    return false;
-  }
-
-  return true;
-}
-
-inline std::unique_ptr<Response> ClientImpl::send_with_content_provider(
-    Request &req, const char *body, size_t content_length,
-    ContentProvider content_provider,
-    ContentProviderWithoutLength content_provider_without_length,
-    const std::string &content_type, Error &error) {
-  if (!content_type.empty()) { req.set_header("Content-Type", content_type); }
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-  if (compress_) { req.set_header("Content-Encoding", "gzip"); }
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-  if (compress_ && !content_provider_without_length) {
-    // TODO: Brotli support
-    detail::gzip_compressor compressor;
-
-    if (content_provider) {
-      auto ok = true;
-      size_t offset = 0;
-      DataSink data_sink;
-
-      data_sink.write = [&](const char *data, size_t data_len) -> bool {
-        if (ok) {
-          auto last = offset + data_len == content_length;
-
-          auto ret = compressor.compress(
-              data, data_len, last,
-              [&](const char *compressed_data, size_t compressed_data_len) {
-                req.body.append(compressed_data, compressed_data_len);
-                return true;
-              });
-
-          if (ret) {
-            offset += data_len;
-          } else {
-            ok = false;
-          }
-        }
-        return ok;
-      };
-
-      while (ok && offset < content_length) {
-        if (!content_provider(offset, content_length - offset, data_sink)) {
-          error = Error::Canceled;
-          return nullptr;
-        }
-      }
-    } else {
-      if (!compressor.compress(body, content_length, true,
-                               [&](const char *data, size_t data_len) {
-                                 req.body.append(data, data_len);
-                                 return true;
-                               })) {
-        error = Error::Compression;
-        return nullptr;
-      }
-    }
-  } else
-#endif
-  {
-    if (content_provider) {
-      req.content_length_ = content_length;
-      req.content_provider_ = std::move(content_provider);
-      req.is_chunked_content_provider_ = false;
-    } else if (content_provider_without_length) {
-      req.content_length_ = 0;
-      req.content_provider_ = detail::ContentProviderAdapter(
-          std::move(content_provider_without_length));
-      req.is_chunked_content_provider_ = true;
-      req.set_header("Transfer-Encoding", "chunked");
-    } else {
-      req.body.assign(body, content_length);
-    }
-  }
-
-  auto res = detail::make_unique<Response>();
-  return send(req, *res, error) ? std::move(res) : nullptr;
-}
-
-inline Result ClientImpl::send_with_content_provider(
-    const std::string &method, const std::string &path, const Headers &headers,
-    const char *body, size_t content_length, ContentProvider content_provider,
-    ContentProviderWithoutLength content_provider_without_length,
-    const std::string &content_type) {
-  Request req;
-  req.method = method;
-  req.headers = headers;
-  req.path = path;
-
-  auto error = Error::Success;
-
-  auto res = send_with_content_provider(
-      req, body, content_length, std::move(content_provider),
-      std::move(content_provider_without_length), content_type, error);
-
-  return Result{std::move(res), error, std::move(req.headers)};
-}
-
-inline std::string
-ClientImpl::adjust_host_string(const std::string &host) const {
-  if (host.find(':') != std::string::npos) { return "[" + host + "]"; }
-  return host;
-}
-
-inline bool ClientImpl::process_request(Stream &strm, Request &req,
-                                        Response &res, bool close_connection,
-                                        Error &error) {
-  // Send request
-  if (!write_request(strm, req, close_connection, error)) { return false; }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  if (is_ssl()) {
-    auto is_proxy_enabled = !proxy_host_.empty() && proxy_port_ != -1;
-    if (!is_proxy_enabled) {
-      char buf[1];
-      if (SSL_peek(socket_.ssl, buf, 1) == 0 &&
-          SSL_get_error(socket_.ssl, 0) == SSL_ERROR_ZERO_RETURN) {
-        error = Error::SSLPeerCouldBeClosed_;
-        return false;
-      }
-    }
-  }
-#endif
-
-  // Receive response and headers
-  if (!read_response_line(strm, req, res) ||
-      !detail::read_headers(strm, res.headers)) {
-    error = Error::Read;
-    return false;
-  }
-
-  // Body
-  if ((res.status != StatusCode::NoContent_204) && req.method != "HEAD" &&
-      req.method != "CONNECT") {
-    auto redirect = 300 < res.status && res.status < 400 && follow_location_;
-
-    if (req.response_handler && !redirect) {
-      if (!req.response_handler(res)) {
-        error = Error::Canceled;
-        return false;
-      }
-    }
-
-    auto out =
-        req.content_receiver
-            ? static_cast<ContentReceiverWithProgress>(
-                  [&](const char *buf, size_t n, uint64_t off, uint64_t len) {
-                    if (redirect) { return true; }
-                    auto ret = req.content_receiver(buf, n, off, len);
-                    if (!ret) { error = Error::Canceled; }
-                    return ret;
-                  })
-            : static_cast<ContentReceiverWithProgress>(
-                  [&](const char *buf, size_t n, uint64_t /*off*/,
-                      uint64_t /*len*/) {
-                    if (res.body.size() + n > res.body.max_size()) {
-                      return false;
-                    }
-                    res.body.append(buf, n);
-                    return true;
-                  });
-
-    auto progress = [&](uint64_t current, uint64_t total) {
-      if (!req.progress || redirect) { return true; }
-      auto ret = req.progress(current, total);
-      if (!ret) { error = Error::Canceled; }
-      return ret;
-    };
-
-    int dummy_status;
-    if (!detail::read_content(strm, res, (std::numeric_limits<size_t>::max)(),
-                              dummy_status, std::move(progress), std::move(out),
-                              decompress_)) {
-      if (error != Error::Canceled) { error = Error::Read; }
-      return false;
-    }
-  }
-
-  // Log
-  if (logger_) { logger_(req, res); }
-
-  return true;
-}
-
-inline ContentProviderWithoutLength ClientImpl::get_multipart_content_provider(
-    const std::string &boundary, const MultipartFormDataItems &items,
-    const MultipartFormDataProviderItems &provider_items) const {
-  size_t cur_item = 0;
-  size_t cur_start = 0;
-  // cur_item and cur_start are copied to within the std::function and maintain
-  // state between successive calls
-  return [&, cur_item, cur_start](size_t offset,
-                                  DataSink &sink) mutable -> bool {
-    if (!offset && !items.empty()) {
-      sink.os << detail::serialize_multipart_formdata(items, boundary, false);
-      return true;
-    } else if (cur_item < provider_items.size()) {
-      if (!cur_start) {
-        const auto &begin = detail::serialize_multipart_formdata_item_begin(
-            provider_items[cur_item], boundary);
-        offset += begin.size();
-        cur_start = offset;
-        sink.os << begin;
-      }
-
-      DataSink cur_sink;
-      auto has_data = true;
-      cur_sink.write = sink.write;
-      cur_sink.done = [&]() { has_data = false; };
-
-      if (!provider_items[cur_item].provider(offset - cur_start, cur_sink)) {
-        return false;
-      }
-
-      if (!has_data) {
-        sink.os << detail::serialize_multipart_formdata_item_end();
-        cur_item++;
-        cur_start = 0;
-      }
-      return true;
-    } else {
-      sink.os << detail::serialize_multipart_formdata_finish(boundary);
-      sink.done();
-      return true;
-    }
-  };
-}
-
-inline bool
-ClientImpl::process_socket(const Socket &socket,
-                           std::function<bool(Stream &strm)> callback) {
-  return detail::process_client_socket(
-      socket.sock, read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-      write_timeout_usec_, std::move(callback));
-}
-
-inline bool ClientImpl::is_ssl() const { return false; }
-
-inline Result ClientImpl::Get(const std::string &path) {
-  return Get(path, Headers(), Progress());
-}
-
-inline Result ClientImpl::Get(const std::string &path, Progress progress) {
-  return Get(path, Headers(), std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers) {
-  return Get(path, headers, Progress());
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
-                              Progress progress) {
-  Request req;
-  req.method = "GET";
-  req.path = path;
-  req.headers = headers;
-  req.progress = std::move(progress);
-
-  return send_(std::move(req));
-}
-
-inline Result ClientImpl::Get(const std::string &path,
-                              ContentReceiver content_receiver) {
-  return Get(path, Headers(), nullptr, std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-  return Get(path, Headers(), nullptr, std::move(content_receiver),
-             std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
-                              ContentReceiver content_receiver) {
-  return Get(path, headers, nullptr, std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-  return Get(path, headers, nullptr, std::move(content_receiver),
-             std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver) {
-  return Get(path, Headers(), std::move(response_handler),
-             std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver) {
-  return Get(path, headers, std::move(response_handler),
-             std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-  return Get(path, Headers(), std::move(response_handler),
-             std::move(content_receiver), std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-  Request req;
-  req.method = "GET";
-  req.path = path;
-  req.headers = headers;
-  req.response_handler = std::move(response_handler);
-  req.content_receiver =
-      [content_receiver](const char *data, size_t data_length,
-                         uint64_t /*offset*/, uint64_t /*total_length*/) {
-        return content_receiver(data, data_length);
-      };
-  req.progress = std::move(progress);
-
-  return send_(std::move(req));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Params &params,
-                              const Headers &headers, Progress progress) {
-  if (params.empty()) { return Get(path, headers); }
-
-  std::string path_with_query = append_query_params(path, params);
-  return Get(path_with_query, headers, progress);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Params &params,
-                              const Headers &headers,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-  return Get(path, params, headers, nullptr, content_receiver, progress);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Params &params,
-                              const Headers &headers,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-  if (params.empty()) {
-    return Get(path, headers, response_handler, content_receiver, progress);
-  }
-
-  std::string path_with_query = append_query_params(path, params);
-  return Get(path_with_query, headers, response_handler, content_receiver,
-             progress);
-}
-
-inline Result ClientImpl::Head(const std::string &path) {
-  return Head(path, Headers());
-}
-
-inline Result ClientImpl::Head(const std::string &path,
-                               const Headers &headers) {
-  Request req;
-  req.method = "HEAD";
-  req.headers = headers;
-  req.path = path;
-
-  return send_(std::move(req));
-}
-
-inline Result ClientImpl::Post(const std::string &path) {
-  return Post(path, std::string(), std::string());
-}
-
-inline Result ClientImpl::Post(const std::string &path,
-                               const Headers &headers) {
-  return Post(path, headers, nullptr, 0, std::string());
-}
-
-inline Result ClientImpl::Post(const std::string &path, const char *body,
-                               size_t content_length,
-                               const std::string &content_type) {
-  return Post(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               const char *body, size_t content_length,
-                               const std::string &content_type) {
-  return send_with_content_provider("POST", path, headers, body, content_length,
-                                    nullptr, nullptr, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const std::string &body,
-                               const std::string &content_type) {
-  return Post(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               const std::string &body,
-                               const std::string &content_type) {
-  return send_with_content_provider("POST", path, headers, body.data(),
-                                    body.size(), nullptr, nullptr,
-                                    content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Params &params) {
-  return Post(path, Headers(), params);
-}
-
-inline Result ClientImpl::Post(const std::string &path, size_t content_length,
-                               ContentProvider content_provider,
-                               const std::string &content_type) {
-  return Post(path, Headers(), content_length, std::move(content_provider),
-              content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path,
-                               ContentProviderWithoutLength content_provider,
-                               const std::string &content_type) {
-  return Post(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               size_t content_length,
-                               ContentProvider content_provider,
-                               const std::string &content_type) {
-  return send_with_content_provider("POST", path, headers, nullptr,
-                                    content_length, std::move(content_provider),
-                                    nullptr, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               ContentProviderWithoutLength content_provider,
-                               const std::string &content_type) {
-  return send_with_content_provider("POST", path, headers, nullptr, 0, nullptr,
-                                    std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               const Params &params) {
-  auto query = detail::params_to_query_str(params);
-  return Post(path, headers, query, "application/x-www-form-urlencoded");
-}
-
-inline Result ClientImpl::Post(const std::string &path,
-                               const MultipartFormDataItems &items) {
-  return Post(path, Headers(), items);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               const MultipartFormDataItems &items) {
-  const auto &boundary = detail::make_multipart_data_boundary();
-  const auto &content_type =
-      detail::serialize_multipart_formdata_get_content_type(boundary);
-  const auto &body = detail::serialize_multipart_formdata(items, boundary);
-  return Post(path, headers, body, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
-                               const MultipartFormDataItems &items,
-                               const std::string &boundary) {
-  if (!detail::is_multipart_boundary_chars_valid(boundary)) {
-    return Result{nullptr, Error::UnsupportedMultipartBoundaryChars};
-  }
-
-  const auto &content_type =
-      detail::serialize_multipart_formdata_get_content_type(boundary);
-  const auto &body = detail::serialize_multipart_formdata(items, boundary);
-  return Post(path, headers, body, content_type);
-}
-
-inline Result
-ClientImpl::Post(const std::string &path, const Headers &headers,
-                 const MultipartFormDataItems &items,
-                 const MultipartFormDataProviderItems &provider_items) {
-  const auto &boundary = detail::make_multipart_data_boundary();
-  const auto &content_type =
-      detail::serialize_multipart_formdata_get_content_type(boundary);
-  return send_with_content_provider(
-      "POST", path, headers, nullptr, 0, nullptr,
-      get_multipart_content_provider(boundary, items, provider_items),
-      content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path) {
-  return Put(path, std::string(), std::string());
-}
-
-inline Result ClientImpl::Put(const std::string &path, const char *body,
-                              size_t content_length,
-                              const std::string &content_type) {
-  return Put(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              const char *body, size_t content_length,
-                              const std::string &content_type) {
-  return send_with_content_provider("PUT", path, headers, body, content_length,
-                                    nullptr, nullptr, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const std::string &body,
-                              const std::string &content_type) {
-  return Put(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              const std::string &body,
-                              const std::string &content_type) {
-  return send_with_content_provider("PUT", path, headers, body.data(),
-                                    body.size(), nullptr, nullptr,
-                                    content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, size_t content_length,
-                              ContentProvider content_provider,
-                              const std::string &content_type) {
-  return Put(path, Headers(), content_length, std::move(content_provider),
-             content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path,
-                              ContentProviderWithoutLength content_provider,
-                              const std::string &content_type) {
-  return Put(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              size_t content_length,
-                              ContentProvider content_provider,
-                              const std::string &content_type) {
-  return send_with_content_provider("PUT", path, headers, nullptr,
-                                    content_length, std::move(content_provider),
-                                    nullptr, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              ContentProviderWithoutLength content_provider,
-                              const std::string &content_type) {
-  return send_with_content_provider("PUT", path, headers, nullptr, 0, nullptr,
-                                    std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Params &params) {
-  return Put(path, Headers(), params);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              const Params &params) {
-  auto query = detail::params_to_query_str(params);
-  return Put(path, headers, query, "application/x-www-form-urlencoded");
-}
-
-inline Result ClientImpl::Put(const std::string &path,
-                              const MultipartFormDataItems &items) {
-  return Put(path, Headers(), items);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              const MultipartFormDataItems &items) {
-  const auto &boundary = detail::make_multipart_data_boundary();
-  const auto &content_type =
-      detail::serialize_multipart_formdata_get_content_type(boundary);
-  const auto &body = detail::serialize_multipart_formdata(items, boundary);
-  return Put(path, headers, body, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
-                              const MultipartFormDataItems &items,
-                              const std::string &boundary) {
-  if (!detail::is_multipart_boundary_chars_valid(boundary)) {
-    return Result{nullptr, Error::UnsupportedMultipartBoundaryChars};
-  }
-
-  const auto &content_type =
-      detail::serialize_multipart_formdata_get_content_type(boundary);
-  const auto &body = detail::serialize_multipart_formdata(items, boundary);
-  return Put(path, headers, body, content_type);
-}
-
-inline Result
-ClientImpl::Put(const std::string &path, const Headers &headers,
-                const MultipartFormDataItems &items,
-                const MultipartFormDataProviderItems &provider_items) {
-  const auto &boundary = detail::make_multipart_data_boundary();
-  const auto &content_type =
-      detail::serialize_multipart_formdata_get_content_type(boundary);
-  return send_with_content_provider(
-      "PUT", path, headers, nullptr, 0, nullptr,
-      get_multipart_content_provider(boundary, items, provider_items),
-      content_type);
-}
-inline Result ClientImpl::Patch(const std::string &path) {
-  return Patch(path, std::string(), std::string());
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const char *body,
-                                size_t content_length,
-                                const std::string &content_type) {
-  return Patch(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
-                                const char *body, size_t content_length,
-                                const std::string &content_type) {
-  return send_with_content_provider("PATCH", path, headers, body,
-                                    content_length, nullptr, nullptr,
-                                    content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path,
-                                const std::string &body,
-                                const std::string &content_type) {
-  return Patch(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
-                                const std::string &body,
-                                const std::string &content_type) {
-  return send_with_content_provider("PATCH", path, headers, body.data(),
-                                    body.size(), nullptr, nullptr,
-                                    content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, size_t content_length,
-                                ContentProvider content_provider,
-                                const std::string &content_type) {
-  return Patch(path, Headers(), content_length, std::move(content_provider),
-               content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path,
-                                ContentProviderWithoutLength content_provider,
-                                const std::string &content_type) {
-  return Patch(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
-                                size_t content_length,
-                                ContentProvider content_provider,
-                                const std::string &content_type) {
-  return send_with_content_provider("PATCH", path, headers, nullptr,
-                                    content_length, std::move(content_provider),
-                                    nullptr, content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
-                                ContentProviderWithoutLength content_provider,
-                                const std::string &content_type) {
-  return send_with_content_provider("PATCH", path, headers, nullptr, 0, nullptr,
-                                    std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Delete(const std::string &path) {
-  return Delete(path, Headers(), std::string(), std::string());
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
-                                 const Headers &headers) {
-  return Delete(path, headers, std::string(), std::string());
-}
-
-inline Result ClientImpl::Delete(const std::string &path, const char *body,
-                                 size_t content_length,
-                                 const std::string &content_type) {
-  return Delete(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
-                                 const Headers &headers, const char *body,
-                                 size_t content_length,
-                                 const std::string &content_type) {
-  Request req;
-  req.method = "DELETE";
-  req.headers = headers;
-  req.path = path;
-
-  if (!content_type.empty()) { req.set_header("Content-Type", content_type); }
-  req.body.assign(body, content_length);
-
-  return send_(std::move(req));
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
-                                 const std::string &body,
-                                 const std::string &content_type) {
-  return Delete(path, Headers(), body.data(), body.size(), content_type);
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
-                                 const Headers &headers,
-                                 const std::string &body,
-                                 const std::string &content_type) {
-  return Delete(path, headers, body.data(), body.size(), content_type);
-}
-
-inline Result ClientImpl::Options(const std::string &path) {
-  return Options(path, Headers());
-}
-
-inline Result ClientImpl::Options(const std::string &path,
-                                  const Headers &headers) {
-  Request req;
-  req.method = "OPTIONS";
-  req.headers = headers;
-  req.path = path;
-
-  return send_(std::move(req));
-}
-
-inline void ClientImpl::stop() {
-  std::lock_guard<std::mutex> guard(socket_mutex_);
-
-  // If there is anything ongoing right now, the ONLY thread-safe thing we can
-  // do is to shutdown_socket, so that threads using this socket suddenly
-  // discover they can't read/write any more and error out. Everything else
-  // (closing the socket, shutting ssl down) is unsafe because these actions are
-  // not thread-safe.
-  if (socket_requests_in_flight_ > 0) {
-    shutdown_socket(socket_);
-
-    // Aside from that, we set a flag for the socket to be closed when we're
-    // done.
-    socket_should_be_closed_when_request_is_done_ = true;
-    return;
-  }
-
-  // Otherwise, still holding the mutex, we can shut everything down ourselves
-  shutdown_ssl(socket_, true);
-  shutdown_socket(socket_);
-  close_socket(socket_);
-}
-
-inline std::string ClientImpl::host() const { return host_; }
-
-inline int ClientImpl::port() const { return port_; }
-
-inline size_t ClientImpl::is_socket_open() const {
-  std::lock_guard<std::mutex> guard(socket_mutex_);
-  return socket_.is_open();
-}
-
-inline socket_t ClientImpl::socket() const { return socket_.sock; }
-
-inline void ClientImpl::set_connection_timeout(time_t sec, time_t usec) {
-  connection_timeout_sec_ = sec;
-  connection_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_read_timeout(time_t sec, time_t usec) {
-  read_timeout_sec_ = sec;
-  read_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_write_timeout(time_t sec, time_t usec) {
-  write_timeout_sec_ = sec;
-  write_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_basic_auth(const std::string &username,
-                                       const std::string &password) {
-  basic_auth_username_ = username;
-  basic_auth_password_ = password;
-}
-
-inline void ClientImpl::set_bearer_token_auth(const std::string &token) {
-  bearer_token_auth_token_ = token;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_digest_auth(const std::string &username,
-                                        const std::string &password) {
-  digest_auth_username_ = username;
-  digest_auth_password_ = password;
-}
-#endif
-
-inline void ClientImpl::set_keep_alive(bool on) { keep_alive_ = on; }
-
-inline void ClientImpl::set_follow_location(bool on) { follow_location_ = on; }
-
-inline void ClientImpl::set_url_encode(bool on) { url_encode_ = on; }
-
-inline void
-ClientImpl::set_hostname_addr_map(std::map<std::string, std::string> addr_map) {
-  addr_map_ = std::move(addr_map);
-}
-
-inline void ClientImpl::set_default_headers(Headers headers) {
-  default_headers_ = std::move(headers);
-}
-
-inline void ClientImpl::set_header_writer(
-    std::function<ssize_t(Stream &, Headers &)> const &writer) {
-  header_writer_ = writer;
-}
-
-inline void ClientImpl::set_address_family(int family) {
-  address_family_ = family;
-}
-
-inline void ClientImpl::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; }
-
-inline void ClientImpl::set_socket_options(SocketOptions socket_options) {
-  socket_options_ = std::move(socket_options);
-}
-
-inline void ClientImpl::set_compress(bool on) { compress_ = on; }
-
-inline void ClientImpl::set_decompress(bool on) { decompress_ = on; }
-
-inline void ClientImpl::set_interface(const std::string &intf) {
-  interface_ = intf;
-}
-
-inline void ClientImpl::set_proxy(const std::string &host, int port) {
-  proxy_host_ = host;
-  proxy_port_ = port;
-}
-
-inline void ClientImpl::set_proxy_basic_auth(const std::string &username,
-                                             const std::string &password) {
-  proxy_basic_auth_username_ = username;
-  proxy_basic_auth_password_ = password;
-}
-
-inline void ClientImpl::set_proxy_bearer_token_auth(const std::string &token) {
-  proxy_bearer_token_auth_token_ = token;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_proxy_digest_auth(const std::string &username,
-                                              const std::string &password) {
-  proxy_digest_auth_username_ = username;
-  proxy_digest_auth_password_ = password;
-}
-
-inline void ClientImpl::set_ca_cert_path(const std::string &ca_cert_file_path,
-                                         const std::string &ca_cert_dir_path) {
-  ca_cert_file_path_ = ca_cert_file_path;
-  ca_cert_dir_path_ = ca_cert_dir_path;
-}
-
-inline void ClientImpl::set_ca_cert_store(X509_STORE *ca_cert_store) {
-  if (ca_cert_store && ca_cert_store != ca_cert_store_) {
-    ca_cert_store_ = ca_cert_store;
-  }
-}
-
-inline X509_STORE *ClientImpl::create_ca_cert_store(const char *ca_cert,
-                                                    std::size_t size) const {
-  auto mem = BIO_new_mem_buf(ca_cert, static_cast<int>(size));
-  if (!mem) { return nullptr; }
-
-  auto inf = PEM_X509_INFO_read_bio(mem, nullptr, nullptr, nullptr);
-  if (!inf) {
-    BIO_free_all(mem);
-    return nullptr;
-  }
-
-  auto cts = X509_STORE_new();
-  if (cts) {
-    for (auto i = 0; i < static_cast<int>(sk_X509_INFO_num(inf)); i++) {
-      auto itmp = sk_X509_INFO_value(inf, i);
-      if (!itmp) { continue; }
-
-      if (itmp->x509) { X509_STORE_add_cert(cts, itmp->x509); }
-      if (itmp->crl) { X509_STORE_add_crl(cts, itmp->crl); }
-    }
-  }
-
-  sk_X509_INFO_pop_free(inf, X509_INFO_free);
-  BIO_free_all(mem);
-  return cts;
-}
-
-inline void ClientImpl::enable_server_certificate_verification(bool enabled) {
-  server_certificate_verification_ = enabled;
-}
-#endif
-
-inline void ClientImpl::set_logger(Logger logger) {
-  logger_ = std::move(logger);
-}
-
-/*
- * SSL Implementation
- */
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-namespace detail {
-
-template <typename U, typename V>
-inline SSL *ssl_new(socket_t sock, SSL_CTX *ctx, std::mutex &ctx_mutex,
-                    U SSL_connect_or_accept, V setup) {
-  SSL *ssl = nullptr;
-  {
-    std::lock_guard<std::mutex> guard(ctx_mutex);
-    ssl = SSL_new(ctx);
-  }
-
-  if (ssl) {
-    set_nonblocking(sock, true);
-    auto bio = BIO_new_socket(static_cast<int>(sock), BIO_NOCLOSE);
-    BIO_set_nbio(bio, 1);
-    SSL_set_bio(ssl, bio, bio);
-
-    if (!setup(ssl) || SSL_connect_or_accept(ssl) != 1) {
-      SSL_shutdown(ssl);
-      {
-        std::lock_guard<std::mutex> guard(ctx_mutex);
-        SSL_free(ssl);
-      }
-      set_nonblocking(sock, false);
-      return nullptr;
-    }
-    BIO_set_nbio(bio, 0);
-    set_nonblocking(sock, false);
-  }
-
-  return ssl;
-}
-
-inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl,
-                       bool shutdown_gracefully) {
-  // sometimes we may want to skip this to try to avoid SIGPIPE if we know
-  // the remote has closed the network connection
-  // Note that it is not always possible to avoid SIGPIPE, this is merely a
-  // best-efforts.
-  if (shutdown_gracefully) { SSL_shutdown(ssl); }
-
-  std::lock_guard<std::mutex> guard(ctx_mutex);
-  SSL_free(ssl);
-}
-
-template <typename U>
-bool ssl_connect_or_accept_nonblocking(socket_t sock, SSL *ssl,
-                                       U ssl_connect_or_accept,
-                                       time_t timeout_sec,
-                                       time_t timeout_usec) {
-  auto res = 0;
-  while ((res = ssl_connect_or_accept(ssl)) != 1) {
-    auto err = SSL_get_error(ssl, res);
-    switch (err) {
-    case SSL_ERROR_WANT_READ:
-      if (select_read(sock, timeout_sec, timeout_usec) > 0) { continue; }
-      break;
-    case SSL_ERROR_WANT_WRITE:
-      if (select_write(sock, timeout_sec, timeout_usec) > 0) { continue; }
-      break;
-    default: break;
-    }
-    return false;
-  }
-  return true;
-}
-
-template <typename T>
-inline bool process_server_socket_ssl(
-    const std::atomic<socket_t> &svr_sock, SSL *ssl, socket_t sock,
-    size_t keep_alive_max_count, time_t keep_alive_timeout_sec,
-    time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
-    time_t write_timeout_usec, T callback) {
-  return process_server_socket_core(
-      svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec,
-      [&](bool close_connection, bool &connection_closed) {
-        SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec,
-                             write_timeout_sec, write_timeout_usec);
-        return callback(strm, close_connection, connection_closed);
-      });
-}
-
-template <typename T>
-inline bool
-process_client_socket_ssl(SSL *ssl, socket_t sock, time_t read_timeout_sec,
-                          time_t read_timeout_usec, time_t write_timeout_sec,
-                          time_t write_timeout_usec, T callback) {
-  SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec,
-                       write_timeout_sec, write_timeout_usec);
-  return callback(strm);
-}
-
-class SSLInit {
-public:
-  SSLInit() {
-    OPENSSL_init_ssl(
-        OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL);
-  }
-};
-
-// SSL socket stream implementation
-inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl,
-                                        time_t read_timeout_sec,
-                                        time_t read_timeout_usec,
-                                        time_t write_timeout_sec,
-                                        time_t write_timeout_usec)
-    : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec),
-      read_timeout_usec_(read_timeout_usec),
-      write_timeout_sec_(write_timeout_sec),
-      write_timeout_usec_(write_timeout_usec) {
-  SSL_clear_mode(ssl, SSL_MODE_AUTO_RETRY);
-}
-
-inline SSLSocketStream::~SSLSocketStream() = default;
-
-inline bool SSLSocketStream::is_readable() const {
-  return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
-}
-
-inline bool SSLSocketStream::is_writable() const {
-  return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 &&
-         is_socket_alive(sock_);
-}
-
-inline ssize_t SSLSocketStream::read(char *ptr, size_t size) {
-  if (SSL_pending(ssl_) > 0) {
-    return SSL_read(ssl_, ptr, static_cast<int>(size));
-  } else if (is_readable()) {
-    auto ret = SSL_read(ssl_, ptr, static_cast<int>(size));
-    if (ret < 0) {
-      auto err = SSL_get_error(ssl_, ret);
-      auto n = 1000;
-#ifdef _WIN32
-      while (--n >= 0 && (err == SSL_ERROR_WANT_READ ||
-                          (err == SSL_ERROR_SYSCALL &&
-                           WSAGetLastError() == WSAETIMEDOUT))) {
-#else
-      while (--n >= 0 && err == SSL_ERROR_WANT_READ) {
-#endif
-        if (SSL_pending(ssl_) > 0) {
-          return SSL_read(ssl_, ptr, static_cast<int>(size));
-        } else if (is_readable()) {
-          std::this_thread::sleep_for(std::chrono::milliseconds(1));
-          ret = SSL_read(ssl_, ptr, static_cast<int>(size));
-          if (ret >= 0) { return ret; }
-          err = SSL_get_error(ssl_, ret);
-        } else {
-          return -1;
-        }
-      }
-    }
-    return ret;
-  }
-  return -1;
-}
-
-inline ssize_t SSLSocketStream::write(const char *ptr, size_t size) {
-  if (is_writable()) {
-    auto handle_size = static_cast<int>(
-        std::min<size_t>(size, (std::numeric_limits<int>::max)()));
-
-    auto ret = SSL_write(ssl_, ptr, static_cast<int>(handle_size));
-    if (ret < 0) {
-      auto err = SSL_get_error(ssl_, ret);
-      auto n = 1000;
-#ifdef _WIN32
-      while (--n >= 0 && (err == SSL_ERROR_WANT_WRITE ||
-                          (err == SSL_ERROR_SYSCALL &&
-                           WSAGetLastError() == WSAETIMEDOUT))) {
-#else
-      while (--n >= 0 && err == SSL_ERROR_WANT_WRITE) {
-#endif
-        if (is_writable()) {
-          std::this_thread::sleep_for(std::chrono::milliseconds(1));
-          ret = SSL_write(ssl_, ptr, static_cast<int>(handle_size));
-          if (ret >= 0) { return ret; }
-          err = SSL_get_error(ssl_, ret);
-        } else {
-          return -1;
-        }
-      }
-    }
-    return ret;
-  }
-  return -1;
-}
-
-inline void SSLSocketStream::get_remote_ip_and_port(std::string &ip,
-                                                    int &port) const {
-  detail::get_remote_ip_and_port(sock_, ip, port);
-}
-
-inline void SSLSocketStream::get_local_ip_and_port(std::string &ip,
-                                                   int &port) const {
-  detail::get_local_ip_and_port(sock_, ip, port);
-}
-
-inline socket_t SSLSocketStream::socket() const { return sock_; }
-
-static SSLInit sslinit_;
-
-} // namespace detail
-
-// SSL HTTP server implementation
-inline SSLServer::SSLServer(const char *cert_path, const char *private_key_path,
-                            const char *client_ca_cert_file_path,
-                            const char *client_ca_cert_dir_path,
-                            const char *private_key_password) {
-  ctx_ = SSL_CTX_new(TLS_server_method());
-
-  if (ctx_) {
-    SSL_CTX_set_options(ctx_,
-                        SSL_OP_NO_COMPRESSION |
-                            SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-
-    SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION);
-
-    // add default password callback before opening encrypted private key
-    if (private_key_password != nullptr && (private_key_password[0] != '\0')) {
-      SSL_CTX_set_default_passwd_cb_userdata(
-          ctx_,
-          reinterpret_cast<void *>(const_cast<char *>(private_key_password)));
-    }
-
-    if (SSL_CTX_use_certificate_chain_file(ctx_, cert_path) != 1 ||
-        SSL_CTX_use_PrivateKey_file(ctx_, private_key_path, SSL_FILETYPE_PEM) !=
-            1) {
-      SSL_CTX_free(ctx_);
-      ctx_ = nullptr;
-    } else if (client_ca_cert_file_path || client_ca_cert_dir_path) {
-      SSL_CTX_load_verify_locations(ctx_, client_ca_cert_file_path,
-                                    client_ca_cert_dir_path);
-
-      SSL_CTX_set_verify(
-          ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
-    }
-  }
-}
-
-inline SSLServer::SSLServer(X509 *cert, EVP_PKEY *private_key,
-                            X509_STORE *client_ca_cert_store) {
-  ctx_ = SSL_CTX_new(TLS_server_method());
-
-  if (ctx_) {
-    SSL_CTX_set_options(ctx_,
-                        SSL_OP_NO_COMPRESSION |
-                            SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-
-    SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION);
-
-    if (SSL_CTX_use_certificate(ctx_, cert) != 1 ||
-        SSL_CTX_use_PrivateKey(ctx_, private_key) != 1) {
-      SSL_CTX_free(ctx_);
-      ctx_ = nullptr;
-    } else if (client_ca_cert_store) {
-      SSL_CTX_set_cert_store(ctx_, client_ca_cert_store);
-
-      SSL_CTX_set_verify(
-          ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
-    }
-  }
-}
-
-inline SSLServer::SSLServer(
-    const std::function<bool(SSL_CTX &ssl_ctx)> &setup_ssl_ctx_callback) {
-  ctx_ = SSL_CTX_new(TLS_method());
-  if (ctx_) {
-    if (!setup_ssl_ctx_callback(*ctx_)) {
-      SSL_CTX_free(ctx_);
-      ctx_ = nullptr;
-    }
-  }
-}
-
-inline SSLServer::~SSLServer() {
-  if (ctx_) { SSL_CTX_free(ctx_); }
-}
-
-inline bool SSLServer::is_valid() const { return ctx_; }
-
-inline SSL_CTX *SSLServer::ssl_context() const { return ctx_; }
-
-inline bool SSLServer::process_and_close_socket(socket_t sock) {
-  auto ssl = detail::ssl_new(
-      sock, ctx_, ctx_mutex_,
-      [&](SSL *ssl2) {
-        return detail::ssl_connect_or_accept_nonblocking(
-            sock, ssl2, SSL_accept, read_timeout_sec_, read_timeout_usec_);
-      },
-      [](SSL * /*ssl2*/) { return true; });
-
-  auto ret = false;
-  if (ssl) {
-    ret = detail::process_server_socket_ssl(
-        svr_sock_, ssl, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
-        read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-        write_timeout_usec_,
-        [this, ssl](Stream &strm, bool close_connection,
-                    bool &connection_closed) {
-          return process_request(strm, close_connection, connection_closed,
-                                 [&](Request &req) { req.ssl = ssl; });
-        });
-
-    // Shutdown gracefully if the result seemed successful, non-gracefully if
-    // the connection appeared to be closed.
-    const bool shutdown_gracefully = ret;
-    detail::ssl_delete(ctx_mutex_, ssl, shutdown_gracefully);
-  }
-
-  detail::shutdown_socket(sock);
-  detail::close_socket(sock);
-  return ret;
-}
-
-// SSL HTTP client implementation
-inline SSLClient::SSLClient(const std::string &host)
-    : SSLClient(host, 443, std::string(), std::string()) {}
-
-inline SSLClient::SSLClient(const std::string &host, int port)
-    : SSLClient(host, port, std::string(), std::string()) {}
-
-inline SSLClient::SSLClient(const std::string &host, int port,
-                            const std::string &client_cert_path,
-                            const std::string &client_key_path)
-    : ClientImpl(host, port, client_cert_path, client_key_path) {
-  ctx_ = SSL_CTX_new(TLS_client_method());
-
-  detail::split(&host_[0], &host_[host_.size()], '.',
-                [&](const char *b, const char *e) {
-                  host_components_.emplace_back(b, e);
-                });
-
-  if (!client_cert_path.empty() && !client_key_path.empty()) {
-    if (SSL_CTX_use_certificate_file(ctx_, client_cert_path.c_str(),
-                                     SSL_FILETYPE_PEM) != 1 ||
-        SSL_CTX_use_PrivateKey_file(ctx_, client_key_path.c_str(),
-                                    SSL_FILETYPE_PEM) != 1) {
-      SSL_CTX_free(ctx_);
-      ctx_ = nullptr;
-    }
-  }
-}
-
-inline SSLClient::SSLClient(const std::string &host, int port,
-                            X509 *client_cert, EVP_PKEY *client_key)
-    : ClientImpl(host, port) {
-  ctx_ = SSL_CTX_new(TLS_client_method());
-
-  detail::split(&host_[0], &host_[host_.size()], '.',
-                [&](const char *b, const char *e) {
-                  host_components_.emplace_back(b, e);
-                });
-
-  if (client_cert != nullptr && client_key != nullptr) {
-    if (SSL_CTX_use_certificate(ctx_, client_cert) != 1 ||
-        SSL_CTX_use_PrivateKey(ctx_, client_key) != 1) {
-      SSL_CTX_free(ctx_);
-      ctx_ = nullptr;
-    }
-  }
-}
-
-inline SSLClient::~SSLClient() {
-  if (ctx_) { SSL_CTX_free(ctx_); }
-  // Make sure to shut down SSL since shutdown_ssl will resolve to the
-  // base function rather than the derived function once we get to the
-  // base class destructor, and won't free the SSL (causing a leak).
-  shutdown_ssl_impl(socket_, true);
-}
-
-inline bool SSLClient::is_valid() const { return ctx_; }
-
-inline void SSLClient::set_ca_cert_store(X509_STORE *ca_cert_store) {
-  if (ca_cert_store) {
-    if (ctx_) {
-      if (SSL_CTX_get_cert_store(ctx_) != ca_cert_store) {
-        // Free memory allocated for old cert and use new store `ca_cert_store`
-        SSL_CTX_set_cert_store(ctx_, ca_cert_store);
-      }
-    } else {
-      X509_STORE_free(ca_cert_store);
-    }
-  }
-}
-
-inline void SSLClient::load_ca_cert_store(const char *ca_cert,
-                                          std::size_t size) {
-  set_ca_cert_store(ClientImpl::create_ca_cert_store(ca_cert, size));
-}
-
-inline long SSLClient::get_openssl_verify_result() const {
-  return verify_result_;
-}
-
-inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; }
-
-inline bool SSLClient::create_and_connect_socket(Socket &socket, Error &error) {
-  return is_valid() && ClientImpl::create_and_connect_socket(socket, error);
-}
-
-// Assumes that socket_mutex_ is locked and that there are no requests in flight
-inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res,
-                                          bool &success, Error &error) {
-  success = true;
-  Response proxy_res;
-  if (!detail::process_client_socket(
-          socket.sock, read_timeout_sec_, read_timeout_usec_,
-          write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
-            Request req2;
-            req2.method = "CONNECT";
-            req2.path = host_and_port_;
-            return process_request(strm, req2, proxy_res, false, error);
-          })) {
-    // Thread-safe to close everything because we are assuming there are no
-    // requests in flight
-    shutdown_ssl(socket, true);
-    shutdown_socket(socket);
-    close_socket(socket);
-    success = false;
-    return false;
-  }
-
-  if (proxy_res.status == StatusCode::ProxyAuthenticationRequired_407) {
-    if (!proxy_digest_auth_username_.empty() &&
-        !proxy_digest_auth_password_.empty()) {
-      std::map<std::string, std::string> auth;
-      if (detail::parse_www_authenticate(proxy_res, auth, true)) {
-        proxy_res = Response();
-        if (!detail::process_client_socket(
-                socket.sock, read_timeout_sec_, read_timeout_usec_,
-                write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
-                  Request req3;
-                  req3.method = "CONNECT";
-                  req3.path = host_and_port_;
-                  req3.headers.insert(detail::make_digest_authentication_header(
-                      req3, auth, 1, detail::random_string(10),
-                      proxy_digest_auth_username_, proxy_digest_auth_password_,
-                      true));
-                  return process_request(strm, req3, proxy_res, false, error);
-                })) {
-          // Thread-safe to close everything because we are assuming there are
-          // no requests in flight
-          shutdown_ssl(socket, true);
-          shutdown_socket(socket);
-          close_socket(socket);
-          success = false;
-          return false;
-        }
-      }
-    }
-  }
-
-  // If status code is not 200, proxy request is failed.
-  // Set error to ProxyConnection and return proxy response
-  // as the response of the request
-  if (proxy_res.status != StatusCode::OK_200) {
-    error = Error::ProxyConnection;
-    res = std::move(proxy_res);
-    // Thread-safe to close everything because we are assuming there are
-    // no requests in flight
-    shutdown_ssl(socket, true);
-    shutdown_socket(socket);
-    close_socket(socket);
-    return false;
-  }
-
-  return true;
-}
-
-inline bool SSLClient::load_certs() {
-  auto ret = true;
-
-  std::call_once(initialize_cert_, [&]() {
-    std::lock_guard<std::mutex> guard(ctx_mutex_);
-    if (!ca_cert_file_path_.empty()) {
-      if (!SSL_CTX_load_verify_locations(ctx_, ca_cert_file_path_.c_str(),
-                                         nullptr)) {
-        ret = false;
-      }
-    } else if (!ca_cert_dir_path_.empty()) {
-      if (!SSL_CTX_load_verify_locations(ctx_, nullptr,
-                                         ca_cert_dir_path_.c_str())) {
-        ret = false;
-      }
-    } else {
-      auto loaded = false;
-#ifdef _WIN32
-      loaded =
-          detail::load_system_certs_on_windows(SSL_CTX_get_cert_store(ctx_));
-#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)
-#if TARGET_OS_OSX
-      loaded = detail::load_system_certs_on_macos(SSL_CTX_get_cert_store(ctx_));
-#endif // TARGET_OS_OSX
-#endif // _WIN32
-      if (!loaded) { SSL_CTX_set_default_verify_paths(ctx_); }
-    }
-  });
-
-  return ret;
-}
-
-inline bool SSLClient::initialize_ssl(Socket &socket, Error &error) {
-  auto ssl = detail::ssl_new(
-      socket.sock, ctx_, ctx_mutex_,
-      [&](SSL *ssl2) {
-        if (server_certificate_verification_) {
-          if (!load_certs()) {
-            error = Error::SSLLoadingCerts;
-            return false;
-          }
-          SSL_set_verify(ssl2, SSL_VERIFY_NONE, nullptr);
-        }
-
-        if (!detail::ssl_connect_or_accept_nonblocking(
-                socket.sock, ssl2, SSL_connect, connection_timeout_sec_,
-                connection_timeout_usec_)) {
-          error = Error::SSLConnection;
-          return false;
-        }
-
-        if (server_certificate_verification_) {
-          verify_result_ = SSL_get_verify_result(ssl2);
-
-          if (verify_result_ != X509_V_OK) {
-            error = Error::SSLServerVerification;
-            return false;
-          }
-
-          auto server_cert = SSL_get1_peer_certificate(ssl2);
-
-          if (server_cert == nullptr) {
-            error = Error::SSLServerVerification;
-            return false;
-          }
-
-          if (!verify_host(server_cert)) {
-            X509_free(server_cert);
-            error = Error::SSLServerVerification;
-            return false;
-          }
-          X509_free(server_cert);
-        }
-
-        return true;
-      },
-      [&](SSL *ssl2) {
-        // NOTE: With -Wold-style-cast, this can produce a warning, since
-        //  SSL_set_tlsext_host_name is a macro (in OpenSSL), which contains
-        //  an old style cast. Short of doing compiler specific pragma's
-        //  here, we can't get rid of this warning. :'(
-        SSL_set_tlsext_host_name(ssl2, host_.c_str());
-        return true;
-      });
-
-  if (ssl) {
-    socket.ssl = ssl;
-    return true;
-  }
-
-  shutdown_socket(socket);
-  close_socket(socket);
-  return false;
-}
-
-inline void SSLClient::shutdown_ssl(Socket &socket, bool shutdown_gracefully) {
-  shutdown_ssl_impl(socket, shutdown_gracefully);
-}
-
-inline void SSLClient::shutdown_ssl_impl(Socket &socket,
-                                         bool shutdown_gracefully) {
-  if (socket.sock == INVALID_SOCKET) {
-    assert(socket.ssl == nullptr);
-    return;
-  }
-  if (socket.ssl) {
-    detail::ssl_delete(ctx_mutex_, socket.ssl, shutdown_gracefully);
-    socket.ssl = nullptr;
-  }
-  assert(socket.ssl == nullptr);
-}
-
-inline bool
-SSLClient::process_socket(const Socket &socket,
-                          std::function<bool(Stream &strm)> callback) {
-  assert(socket.ssl);
-  return detail::process_client_socket_ssl(
-      socket.ssl, socket.sock, read_timeout_sec_, read_timeout_usec_,
-      write_timeout_sec_, write_timeout_usec_, std::move(callback));
-}
-
-inline bool SSLClient::is_ssl() const { return true; }
-
-inline bool SSLClient::verify_host(X509 *server_cert) const {
-  /* Quote from RFC2818 section 3.1 "Server Identity"
-
-     If a subjectAltName extension of type dNSName is present, that MUST
-     be used as the identity. Otherwise, the (most specific) Common Name
-     field in the Subject field of the certificate MUST be used. Although
-     the use of the Common Name is existing practice, it is deprecated and
-     Certification Authorities are encouraged to use the dNSName instead.
-
-     Matching is performed using the matching rules specified by
-     [RFC2459].  If more than one identity of a given type is present in
-     the certificate (e.g., more than one dNSName name, a match in any one
-     of the set is considered acceptable.) Names may contain the wildcard
-     character * which is considered to match any single domain name
-     component or component fragment. E.g., *.a.com matches foo.a.com but
-     not bar.foo.a.com. f*.com matches foo.com but not bar.com.
-
-     In some cases, the URI is specified as an IP address rather than a
-     hostname. In this case, the iPAddress subjectAltName must be present
-     in the certificate and must exactly match the IP in the URI.
-
-  */
-  return verify_host_with_subject_alt_name(server_cert) ||
-         verify_host_with_common_name(server_cert);
-}
-
-inline bool
-SSLClient::verify_host_with_subject_alt_name(X509 *server_cert) const {
-  auto ret = false;
-
-  auto type = GEN_DNS;
-
-  struct in6_addr addr6 {};
-  struct in_addr addr {};
-  size_t addr_len = 0;
-
-#ifndef __MINGW32__
-  if (inet_pton(AF_INET6, host_.c_str(), &addr6)) {
-    type = GEN_IPADD;
-    addr_len = sizeof(struct in6_addr);
-  } else if (inet_pton(AF_INET, host_.c_str(), &addr)) {
-    type = GEN_IPADD;
-    addr_len = sizeof(struct in_addr);
-  }
-#endif
-
-  auto alt_names = static_cast<const struct stack_st_GENERAL_NAME *>(
-      X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr));
-
-  if (alt_names) {
-    auto dsn_matched = false;
-    auto ip_matched = false;
-
-    auto count = sk_GENERAL_NAME_num(alt_names);
-
-    for (decltype(count) i = 0; i < count && !dsn_matched; i++) {
-      auto val = sk_GENERAL_NAME_value(alt_names, i);
-      if (val->type == type) {
-        auto name =
-            reinterpret_cast<const char *>(ASN1_STRING_get0_data(val->d.ia5));
-        auto name_len = static_cast<size_t>(ASN1_STRING_length(val->d.ia5));
-
-        switch (type) {
-        case GEN_DNS: dsn_matched = check_host_name(name, name_len); break;
-
-        case GEN_IPADD:
-          if (!memcmp(&addr6, name, addr_len) ||
-              !memcmp(&addr, name, addr_len)) {
-            ip_matched = true;
-          }
-          break;
-        }
-      }
-    }
-
-    if (dsn_matched || ip_matched) { ret = true; }
-  }
-
-  GENERAL_NAMES_free(const_cast<STACK_OF(GENERAL_NAME) *>(
-      reinterpret_cast<const STACK_OF(GENERAL_NAME) *>(alt_names)));
-  return ret;
-}
-
-inline bool SSLClient::verify_host_with_common_name(X509 *server_cert) const {
-  const auto subject_name = X509_get_subject_name(server_cert);
-
-  if (subject_name != nullptr) {
-    char name[BUFSIZ];
-    auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName,
-                                              name, sizeof(name));
-
-    if (name_len != -1) {
-      return check_host_name(name, static_cast<size_t>(name_len));
-    }
-  }
-
-  return false;
-}
-
-inline bool SSLClient::check_host_name(const char *pattern,
-                                       size_t pattern_len) const {
-  if (host_.size() == pattern_len && host_ == pattern) { return true; }
-
-  // Wildcard match
-  // https://bugs.launchpad.net/ubuntu/+source/firefox-3.0/+bug/376484
-  std::vector<std::string> pattern_components;
-  detail::split(&pattern[0], &pattern[pattern_len], '.',
-                [&](const char *b, const char *e) {
-                  pattern_components.emplace_back(b, e);
-                });
-
-  if (host_components_.size() != pattern_components.size()) { return false; }
-
-  auto itr = pattern_components.begin();
-  for (const auto &h : host_components_) {
-    auto &p = *itr;
-    if (p != h && p != "*") {
-      auto partial_match = (p.size() > 0 && p[p.size() - 1] == '*' &&
-                            !p.compare(0, p.size() - 1, h));
-      if (!partial_match) { return false; }
-    }
-    ++itr;
-  }
-
-  return true;
-}
-#endif
-
-// Universal client implementation
-inline Client::Client(const std::string &scheme_host_port)
-    : Client(scheme_host_port, std::string(), std::string()) {}
-
-inline Client::Client(const std::string &scheme_host_port,
-                      const std::string &client_cert_path,
-                      const std::string &client_key_path) {
-  const static Regex re(
-      R"((?:([a-z]+):\/\/)?(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)");
-
-  Match m;
-  if (RegexMatch(scheme_host_port, m, re)) {
-    auto scheme = m[1].str();
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-    if (!scheme.empty() && (scheme != "http" && scheme != "https")) {
-#else
-    if (!scheme.empty() && scheme != "http") {
-#endif
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
-      std::string msg = "'" + scheme + "' scheme is not supported.";
-      throw std::invalid_argument(msg);
-#endif
-      return;
-    }
-
-    auto is_ssl = scheme == "https";
-
-    auto host = m[2].str();
-    if (host.empty()) { host = m[3].str(); }
-
-    auto port_str = m[4].str();
-    auto port = !port_str.empty() ? std::stoi(port_str) : (is_ssl ? 443 : 80);
-
-    if (is_ssl) {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-      cli_ = detail::make_unique<SSLClient>(host, port, client_cert_path,
-                                            client_key_path);
-      is_ssl_ = is_ssl;
-#endif
-    } else {
-      cli_ = detail::make_unique<ClientImpl>(host, port, client_cert_path,
-                                             client_key_path);
-    }
-  } else {
-    cli_ = detail::make_unique<ClientImpl>(scheme_host_port, 80,
-                                           client_cert_path, client_key_path);
-  }
-}
-
-inline Client::Client(const std::string &host, int port)
-    : cli_(detail::make_unique<ClientImpl>(host, port)) {}
-
-inline Client::Client(const std::string &host, int port,
-                      const std::string &client_cert_path,
-                      const std::string &client_key_path)
-    : cli_(detail::make_unique<ClientImpl>(host, port, client_cert_path,
-                                           client_key_path)) {}
-
-inline Client::~Client() = default;
-
-inline bool Client::is_valid() const {
-  return cli_ != nullptr && cli_->is_valid();
-}
-
-inline Result Client::Get(const std::string &path) { return cli_->Get(path); }
-inline Result Client::Get(const std::string &path, const Headers &headers) {
-  return cli_->Get(path, headers);
-}
-inline Result Client::Get(const std::string &path, Progress progress) {
-  return cli_->Get(path, std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
-                          Progress progress) {
-  return cli_->Get(path, headers, std::move(progress));
-}
-inline Result Client::Get(const std::string &path,
-                          ContentReceiver content_receiver) {
-  return cli_->Get(path, std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
-                          ContentReceiver content_receiver) {
-  return cli_->Get(path, headers, std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path,
-                          ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
-                          ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, headers, std::move(content_receiver),
-                   std::move(progress));
-}
-inline Result Client::Get(const std::string &path,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver) {
-  return cli_->Get(path, std::move(response_handler),
-                   std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver) {
-  return cli_->Get(path, headers, std::move(response_handler),
-                   std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, std::move(response_handler),
-                   std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, headers, std::move(response_handler),
-                   std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Params &params,
-                          const Headers &headers, Progress progress) {
-  return cli_->Get(path, params, headers, progress);
-}
-inline Result Client::Get(const std::string &path, const Params &params,
-                          const Headers &headers,
-                          ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, params, headers, content_receiver, progress);
-}
-inline Result Client::Get(const std::string &path, const Params &params,
-                          const Headers &headers,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, params, headers, response_handler, content_receiver,
-                   progress);
-}
-
-inline Result Client::Head(const std::string &path) { return cli_->Head(path); }
-inline Result Client::Head(const std::string &path, const Headers &headers) {
-  return cli_->Head(path, headers);
-}
-
-inline Result Client::Post(const std::string &path) { return cli_->Post(path); }
-inline Result Client::Post(const std::string &path, const Headers &headers) {
-  return cli_->Post(path, headers);
-}
-inline Result Client::Post(const std::string &path, const char *body,
-                           size_t content_length,
-                           const std::string &content_type) {
-  return cli_->Post(path, body, content_length, content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           const char *body, size_t content_length,
-                           const std::string &content_type) {
-  return cli_->Post(path, headers, body, content_length, content_type);
-}
-inline Result Client::Post(const std::string &path, const std::string &body,
-                           const std::string &content_type) {
-  return cli_->Post(path, body, content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           const std::string &body,
-                           const std::string &content_type) {
-  return cli_->Post(path, headers, body, content_type);
-}
-inline Result Client::Post(const std::string &path, size_t content_length,
-                           ContentProvider content_provider,
-                           const std::string &content_type) {
-  return cli_->Post(path, content_length, std::move(content_provider),
-                    content_type);
-}
-inline Result Client::Post(const std::string &path,
-                           ContentProviderWithoutLength content_provider,
-                           const std::string &content_type) {
-  return cli_->Post(path, std::move(content_provider), content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           size_t content_length,
-                           ContentProvider content_provider,
-                           const std::string &content_type) {
-  return cli_->Post(path, headers, content_length, std::move(content_provider),
-                    content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           ContentProviderWithoutLength content_provider,
-                           const std::string &content_type) {
-  return cli_->Post(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Post(const std::string &path, const Params &params) {
-  return cli_->Post(path, params);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           const Params &params) {
-  return cli_->Post(path, headers, params);
-}
-inline Result Client::Post(const std::string &path,
-                           const MultipartFormDataItems &items) {
-  return cli_->Post(path, items);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           const MultipartFormDataItems &items) {
-  return cli_->Post(path, headers, items);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
-                           const MultipartFormDataItems &items,
-                           const std::string &boundary) {
-  return cli_->Post(path, headers, items, boundary);
-}
-inline Result
-Client::Post(const std::string &path, const Headers &headers,
-             const MultipartFormDataItems &items,
-             const MultipartFormDataProviderItems &provider_items) {
-  return cli_->Post(path, headers, items, provider_items);
-}
-inline Result Client::Put(const std::string &path) { return cli_->Put(path); }
-inline Result Client::Put(const std::string &path, const char *body,
-                          size_t content_length,
-                          const std::string &content_type) {
-  return cli_->Put(path, body, content_length, content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          const char *body, size_t content_length,
-                          const std::string &content_type) {
-  return cli_->Put(path, headers, body, content_length, content_type);
-}
-inline Result Client::Put(const std::string &path, const std::string &body,
-                          const std::string &content_type) {
-  return cli_->Put(path, body, content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          const std::string &body,
-                          const std::string &content_type) {
-  return cli_->Put(path, headers, body, content_type);
-}
-inline Result Client::Put(const std::string &path, size_t content_length,
-                          ContentProvider content_provider,
-                          const std::string &content_type) {
-  return cli_->Put(path, content_length, std::move(content_provider),
-                   content_type);
-}
-inline Result Client::Put(const std::string &path,
-                          ContentProviderWithoutLength content_provider,
-                          const std::string &content_type) {
-  return cli_->Put(path, std::move(content_provider), content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          size_t content_length,
-                          ContentProvider content_provider,
-                          const std::string &content_type) {
-  return cli_->Put(path, headers, content_length, std::move(content_provider),
-                   content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          ContentProviderWithoutLength content_provider,
-                          const std::string &content_type) {
-  return cli_->Put(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Put(const std::string &path, const Params &params) {
-  return cli_->Put(path, params);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          const Params &params) {
-  return cli_->Put(path, headers, params);
-}
-inline Result Client::Put(const std::string &path,
-                          const MultipartFormDataItems &items) {
-  return cli_->Put(path, items);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          const MultipartFormDataItems &items) {
-  return cli_->Put(path, headers, items);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
-                          const MultipartFormDataItems &items,
-                          const std::string &boundary) {
-  return cli_->Put(path, headers, items, boundary);
-}
-inline Result
-Client::Put(const std::string &path, const Headers &headers,
-            const MultipartFormDataItems &items,
-            const MultipartFormDataProviderItems &provider_items) {
-  return cli_->Put(path, headers, items, provider_items);
-}
-inline Result Client::Patch(const std::string &path) {
-  return cli_->Patch(path);
-}
-inline Result Client::Patch(const std::string &path, const char *body,
-                            size_t content_length,
-                            const std::string &content_type) {
-  return cli_->Patch(path, body, content_length, content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
-                            const char *body, size_t content_length,
-                            const std::string &content_type) {
-  return cli_->Patch(path, headers, body, content_length, content_type);
-}
-inline Result Client::Patch(const std::string &path, const std::string &body,
-                            const std::string &content_type) {
-  return cli_->Patch(path, body, content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
-                            const std::string &body,
-                            const std::string &content_type) {
-  return cli_->Patch(path, headers, body, content_type);
-}
-inline Result Client::Patch(const std::string &path, size_t content_length,
-                            ContentProvider content_provider,
-                            const std::string &content_type) {
-  return cli_->Patch(path, content_length, std::move(content_provider),
-                     content_type);
-}
-inline Result Client::Patch(const std::string &path,
-                            ContentProviderWithoutLength content_provider,
-                            const std::string &content_type) {
-  return cli_->Patch(path, std::move(content_provider), content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
-                            size_t content_length,
-                            ContentProvider content_provider,
-                            const std::string &content_type) {
-  return cli_->Patch(path, headers, content_length, std::move(content_provider),
-                     content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
-                            ContentProviderWithoutLength content_provider,
-                            const std::string &content_type) {
-  return cli_->Patch(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Delete(const std::string &path) {
-  return cli_->Delete(path);
-}
-inline Result Client::Delete(const std::string &path, const Headers &headers) {
-  return cli_->Delete(path, headers);
-}
-inline Result Client::Delete(const std::string &path, const char *body,
-                             size_t content_length,
-                             const std::string &content_type) {
-  return cli_->Delete(path, body, content_length, content_type);
-}
-inline Result Client::Delete(const std::string &path, const Headers &headers,
-                             const char *body, size_t content_length,
-                             const std::string &content_type) {
-  return cli_->Delete(path, headers, body, content_length, content_type);
-}
-inline Result Client::Delete(const std::string &path, const std::string &body,
-                             const std::string &content_type) {
-  return cli_->Delete(path, body, content_type);
-}
-inline Result Client::Delete(const std::string &path, const Headers &headers,
-                             const std::string &body,
-                             const std::string &content_type) {
-  return cli_->Delete(path, headers, body, content_type);
-}
-inline Result Client::Options(const std::string &path) {
-  return cli_->Options(path);
-}
-inline Result Client::Options(const std::string &path, const Headers &headers) {
-  return cli_->Options(path, headers);
-}
-
-inline bool Client::send(Request &req, Response &res, Error &error) {
-  return cli_->send(req, res, error);
-}
-
-inline Result Client::send(const Request &req) { return cli_->send(req); }
-
-inline void Client::stop() { cli_->stop(); }
-
-inline std::string Client::host() const { return cli_->host(); }
-
-inline int Client::port() const { return cli_->port(); }
-
-inline size_t Client::is_socket_open() const { return cli_->is_socket_open(); }
-
-inline socket_t Client::socket() const { return cli_->socket(); }
-
-inline void
-Client::set_hostname_addr_map(std::map<std::string, std::string> addr_map) {
-  cli_->set_hostname_addr_map(std::move(addr_map));
-}
-
-inline void Client::set_default_headers(Headers headers) {
-  cli_->set_default_headers(std::move(headers));
-}
-
-inline void Client::set_header_writer(
-    std::function<ssize_t(Stream &, Headers &)> const &writer) {
-  cli_->set_header_writer(writer);
-}
-
-inline void Client::set_address_family(int family) {
-  cli_->set_address_family(family);
-}
-
-inline void Client::set_tcp_nodelay(bool on) { cli_->set_tcp_nodelay(on); }
-
-inline void Client::set_socket_options(SocketOptions socket_options) {
-  cli_->set_socket_options(std::move(socket_options));
-}
-
-inline void Client::set_connection_timeout(time_t sec, time_t usec) {
-  cli_->set_connection_timeout(sec, usec);
-}
-
-inline void Client::set_read_timeout(time_t sec, time_t usec) {
-  cli_->set_read_timeout(sec, usec);
-}
-
-inline void Client::set_write_timeout(time_t sec, time_t usec) {
-  cli_->set_write_timeout(sec, usec);
-}
-
-inline void Client::set_basic_auth(const std::string &username,
-                                   const std::string &password) {
-  cli_->set_basic_auth(username, password);
-}
-inline void Client::set_bearer_token_auth(const std::string &token) {
-  cli_->set_bearer_token_auth(token);
-}
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_digest_auth(const std::string &username,
-                                    const std::string &password) {
-  cli_->set_digest_auth(username, password);
-}
-#endif
-
-inline void Client::set_keep_alive(bool on) { cli_->set_keep_alive(on); }
-inline void Client::set_follow_location(bool on) {
-  cli_->set_follow_location(on);
-}
-
-inline void Client::set_url_encode(bool on) { cli_->set_url_encode(on); }
-
-inline void Client::set_compress(bool on) { cli_->set_compress(on); }
-
-inline void Client::set_decompress(bool on) { cli_->set_decompress(on); }
-
-inline void Client::set_interface(const std::string &intf) {
-  cli_->set_interface(intf);
-}
-
-inline void Client::set_proxy(const std::string &host, int port) {
-  cli_->set_proxy(host, port);
-}
-inline void Client::set_proxy_basic_auth(const std::string &username,
-                                         const std::string &password) {
-  cli_->set_proxy_basic_auth(username, password);
-}
-inline void Client::set_proxy_bearer_token_auth(const std::string &token) {
-  cli_->set_proxy_bearer_token_auth(token);
-}
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_proxy_digest_auth(const std::string &username,
-                                          const std::string &password) {
-  cli_->set_proxy_digest_auth(username, password);
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::enable_server_certificate_verification(bool enabled) {
-  cli_->enable_server_certificate_verification(enabled);
-}
-#endif
-
-inline void Client::set_logger(Logger logger) {
-  cli_->set_logger(std::move(logger));
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_ca_cert_path(const std::string &ca_cert_file_path,
-                                     const std::string &ca_cert_dir_path) {
-  cli_->set_ca_cert_path(ca_cert_file_path, ca_cert_dir_path);
-}
-
-inline void Client::set_ca_cert_store(X509_STORE *ca_cert_store) {
-  if (is_ssl_) {
-    static_cast<SSLClient &>(*cli_).set_ca_cert_store(ca_cert_store);
-  } else {
-    cli_->set_ca_cert_store(ca_cert_store);
-  }
-}
-
-inline void Client::load_ca_cert_store(const char *ca_cert, std::size_t size) {
-  set_ca_cert_store(cli_->create_ca_cert_store(ca_cert, size));
-}
-
-inline long Client::get_openssl_verify_result() const {
-  if (is_ssl_) {
-    return static_cast<SSLClient &>(*cli_).get_openssl_verify_result();
-  }
-  return -1; // NOTE: -1 doesn't match any of X509_V_ERR_???
-}
-
-inline SSL_CTX *Client::ssl_context() const {
-  if (is_ssl_) { return static_cast<SSLClient &>(*cli_).ssl_context(); }
-  return nullptr;
-}
-#endif
-
-// ----------------------------------------------------------------------------
-
-} // namespace CPPHTTPLIB_NAMESPACE
-
-#if defined(_WIN32) && defined(CPPHTTPLIB_USE_POLL)
-#undef poll
-#endif
-
-#endif // CPPHTTPLIB_HTTPLIB_H
diff --git a/src/duckdb/third_party/hyperloglog/hyperloglog.cpp b/src/duckdb/third_party/hyperloglog/hyperloglog.cpp
deleted file mode 100644
index b23076338..000000000
--- a/src/duckdb/third_party/hyperloglog/hyperloglog.cpp
+++ /dev/null
@@ -1,1270 +0,0 @@
-/* hyperloglog.c - Redis HyperLogLog probabilistic cardinality approximation.
- * This file implements the algorithm and the exported Redis commands.
- *
- * Copyright (c) 2014, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * 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.
- */
-
-#include "duckdb/common/vector.hpp"
-#include "duckdb/common/types/hyperloglog.hpp"
-
-#include "hyperloglog.hpp"
-#include "sds.hpp"
-
-#include <assert.h>
-#include <stdint.h>
-#include <math.h>
-#include <stddef.h>
-#include <string.h>
-#include <stdlib.h>
-
-
-
-namespace duckdb_hll {
-
-#define HLL_SPARSE_MAX_BYTES 3000
-
-/* The Redis HyperLogLog implementation is based on the following ideas:
- *
- * * The use of a 64 bit hash function as proposed in [1], in order to don't
- *   limited to cardinalities up to 10^9, at the cost of just 1 additional
- *   bit per register.
- * * The use of 16384 6-bit registers for a great level of accuracy, using
- *   a total of 12k per key.
- * * The use of the Redis string data type. No new type is introduced.
- * * No attempt is made to compress the data structure as in [1]. Also the
- *   algorithm used is the original HyperLogLog Algorithm as in [2], with
- *   the only difference that a 64 bit hash function is used, so no correction
- *   is performed for values near 2^32 as in [1].
- *
- * [1] Heule, Nunkesser, Hall: HyperLogLog in Practice: Algorithmic
- *     Engineering of a State of The Art Cardinality Estimation Algorithm.
- *
- * [2] P. Flajolet, Éric Fusy, O. Gandouet, and F. Meunier. Hyperloglog: The
- *     analysis of a near-optimal cardinality estimation algorithm.
- *
- * Redis uses two representations:
- *
- * 1) A "dense" representation where every entry is represented by
- *    a 6-bit integer.
- * 2) A "sparse" representation using run length compression suitable
- *    for representing HyperLogLogs with many registers set to 0 in
- *    a memory efficient way.
- *
- *
- * HLL header
- * ===
- *
- * Both the dense and sparse representation have a 16 byte header as follows:
- *
- * +------+---+-----+----------+
- * | HYLL | E | N/U | Cardin.  |
- * +------+---+-----+----------+
- *
- * The first 4 bytes are a magic string set to the bytes "HYLL".
- * "E" is one byte encoding, currently set to HLL_DENSE or
- * HLL_SPARSE. N/U are three not used bytes.
- *
- * The "Cardin." field is a 64 bit integer stored in little endian format
- * with the latest cardinality computed that can be reused if the data
- * structure was not modified since the last computation (this is useful
- * because there are high probabilities that HLLADD operations don't
- * modify the actual data structure and hence the approximated cardinality).
- *
- * When the most significant bit in the most significant byte of the cached
- * cardinality is set, it means that the data structure was modified and
- * we can't reuse the cached value that must be recomputed.
- *
- * Dense representation
- * ===
- *
- * The dense representation used by Redis is the following:
- *
- * +--------+--------+--------+------//      //--+
- * |11000000|22221111|33333322|55444444 ....     |
- * +--------+--------+--------+------//      //--+
- *
- * The 6 bits counters are encoded one after the other starting from the
- * LSB to the MSB, and using the next bytes as needed.
- *
- * Sparse representation
- * ===
- *
- * The sparse representation encodes registers using a run length
- * encoding composed of three opcodes, two using one byte, and one using
- * of two bytes. The opcodes are called ZERO, XZERO and VAL.
- *
- * ZERO opcode is represented as 00xxxxxx. The 6-bit integer represented
- * by the six bits 'xxxxxx', plus 1, means that there are N registers set
- * to 0. This opcode can represent from 1 to 64 contiguous registers set
- * to the value of 0.
- *
- * XZERO opcode is represented by two bytes 01xxxxxx yyyyyyyy. The 14-bit
- * integer represented by the bits 'xxxxxx' as most significant bits and
- * 'yyyyyyyy' as least significant bits, plus 1, means that there are N
- * registers set to 0. This opcode can represent from 0 to 16384 contiguous
- * registers set to the value of 0.
- *
- * VAL opcode is represented as 1vvvvvxx. It contains a 5-bit integer
- * representing the value of a register, and a 2-bit integer representing
- * the number of contiguous registers set to that value 'vvvvv'.
- * To obtain the value and run length, the integers vvvvv and xx must be
- * incremented by one. This opcode can represent values from 1 to 32,
- * repeated from 1 to 4 times.
- *
- * The sparse representation can't represent registers with a value greater
- * than 32, however it is very unlikely that we find such a register in an
- * HLL with a cardinality where the sparse representation is still more
- * memory efficient than the dense representation. When this happens the
- * HLL is converted to the dense representation.
- *
- * The sparse representation is purely positional. For example a sparse
- * representation of an empty HLL is just: XZERO:16384.
- *
- * An HLL having only 3 non-zero registers at position 1000, 1020, 1021
- * respectively set to 2, 3, 3, is represented by the following three
- * opcodes:
- *
- * XZERO:1000 (Registers 0-999 are set to 0)
- * VAL:2,1    (1 register set to value 2, that is register 1000)
- * ZERO:19    (Registers 1001-1019 set to 0)
- * VAL:3,2    (2 registers set to value 3, that is registers 1020,1021)
- * XZERO:15362 (Registers 1022-16383 set to 0)
- *
- * In the example the sparse representation used just 7 bytes instead
- * of 12k in order to represent the HLL registers. In general for low
- * cardinality there is a big win in terms of space efficiency, traded
- * with CPU time since the sparse representation is slower to access:
- *
- * The following table shows average cardinality vs bytes used, 100
- * samples per cardinality (when the set was not representable because
- * of registers with too big value, the dense representation size was used
- * as a sample).
- *
- * 100 267
- * 200 485
- * 300 678
- * 400 859
- * 500 1033
- * 600 1205
- * 700 1375
- * 800 1544
- * 900 1713
- * 1000 1882
- * 2000 3480
- * 3000 4879
- * 4000 6089
- * 5000 7138
- * 6000 8042
- * 7000 8823
- * 8000 9500
- * 9000 10088
- * 10000 10591
- *
- * The dense representation uses 12288 bytes, so there is a big win up to
- * a cardinality of ~2000-3000. For bigger cardinalities the constant times
- * involved in updating the sparse representation is not justified by the
- * memory savings. The exact maximum length of the sparse representation
- * when this implementation switches to the dense representation is
- * configured via the define server.hll_sparse_max_bytes.
- */
-
-struct hllhdr {
-    char magic[4];      /* "HYLL" */
-    uint8_t encoding;   /* HLL_DENSE or HLL_SPARSE. */
-    uint8_t notused[3]; /* Reserved for future use, must be zero. */
-    uint8_t card[8];    /* Cached cardinality, little endian. */
-    uint8_t registers[1]; /* Data bytes. */
-};
-
-/* The cached cardinality MSB is used to signal validity of the cached value. */
-#define HLL_INVALIDATE_CACHE(hdr) (hdr)->card[7] |= (1<<7)
-#define HLL_VALID_CACHE(hdr) (((hdr)->card[7] & (1<<7)) == 0)
-
-#define HLL_P 12 /* The greater is P, the smaller the error. */
-#define HLL_Q (64-HLL_P) /* The number of bits of the hash value used for
-                            determining the number of leading zeros. */
-#define HLL_REGISTERS (1<<HLL_P) /* With P=14, 16384 registers. */
-#define HLL_P_MASK (HLL_REGISTERS-1) /* Mask to index register. */
-#define HLL_BITS 6 /* Enough to count up to 63 leading zeroes. */
-#define HLL_REGISTER_MAX ((1<<HLL_BITS)-1)
-#define HLL_HDR_SIZE sizeof(struct hllhdr)
-#define HLL_DENSE_SIZE (HLL_HDR_SIZE+((HLL_REGISTERS*HLL_BITS+7)/8))
-#define HLL_DENSE 0 /* Dense encoding. */
-#define HLL_SPARSE 1 /* Sparse encoding. */
-#define HLL_RAW 255 /* Only used internally, never exposed. */
-#define HLL_MAX_ENCODING 1
-
-/* =========================== Low level bit macros ========================= */
-
-/* Macros to access the dense representation.
- *
- * We need to get and set 6 bit counters in an array of 8 bit bytes.
- * We use macros to make sure the code is inlined since speed is critical
- * especially in order to compute the approximated cardinality in
- * HLLCOUNT where we need to access all the registers at once.
- * For the same reason we also want to avoid conditionals in this code path.
- *
- * +--------+--------+--------+------//
- * |11000000|22221111|33333322|55444444
- * +--------+--------+--------+------//
- *
- * Note: in the above representation the most significant bit (MSB)
- * of every byte is on the left. We start using bits from the LSB to MSB,
- * and so forth passing to the next byte.
- *
- * Example, we want to access to counter at pos = 1 ("111111" in the
- * illustration above).
- *
- * The index of the first byte b0 containing our data is:
- *
- *  b0 = 6 * pos / 8 = 0
- *
- *   +--------+
- *   |11000000|  <- Our byte at b0
- *   +--------+
- *
- * The position of the first bit (counting from the LSB = 0) in the byte
- * is given by:
- *
- *  fb = 6 * pos % 8 -> 6
- *
- * Right shift b0 of 'fb' bits.
- *
- *   +--------+
- *   |11000000|  <- Initial value of b0
- *   |00000011|  <- After right shift of 6 pos.
- *   +--------+
- *
- * Left shift b1 of bits 8-fb bits (2 bits)
- *
- *   +--------+
- *   |22221111|  <- Initial value of b1
- *   |22111100|  <- After left shift of 2 bits.
- *   +--------+
- *
- * OR the two bits, and finally AND with 111111 (63 in decimal) to
- * clean the higher order bits we are not interested in:
- *
- *   +--------+
- *   |00000011|  <- b0 right shifted
- *   |22111100|  <- b1 left shifted
- *   |22111111|  <- b0 OR b1
- *   |  111111|  <- (b0 OR b1) AND 63, our value.
- *   +--------+
- *
- * We can try with a different example, like pos = 0. In this case
- * the 6-bit counter is actually contained in a single byte.
- *
- *  b0 = 6 * pos / 8 = 0
- *
- *   +--------+
- *   |11000000|  <- Our byte at b0
- *   +--------+
- *
- *  fb = 6 * pos % 8 = 0
- *
- *  So we right shift of 0 bits (no shift in practice) and
- *  left shift the next byte of 8 bits, even if we don't use it,
- *  but this has the effect of clearing the bits so the result
- *  will not be affacted after the OR.
- *
- * -------------------------------------------------------------------------
- *
- * Setting the register is a bit more complex, let's assume that 'val'
- * is the value we want to set, already in the right range.
- *
- * We need two steps, in one we need to clear the bits, and in the other
- * we need to bitwise-OR the new bits.
- *
- * Let's try with 'pos' = 1, so our first byte at 'b' is 0,
- *
- * "fb" is 6 in this case.
- *
- *   +--------+
- *   |11000000|  <- Our byte at b0
- *   +--------+
- *
- * To create a AND-mask to clear the bits about this position, we just
- * initialize the mask with the value 63, left shift it of "fs" bits,
- * and finally invert the result.
- *
- *   +--------+
- *   |00111111|  <- "mask" starts at 63
- *   |11000000|  <- "mask" after left shift of "ls" bits.
- *   |00111111|  <- "mask" after invert.
- *   +--------+
- *
- * Now we can bitwise-AND the byte at "b" with the mask, and bitwise-OR
- * it with "val" left-shifted of "ls" bits to set the new bits.
- *
- * Now let's focus on the next byte b1:
- *
- *   +--------+
- *   |22221111|  <- Initial value of b1
- *   +--------+
- *
- * To build the AND mask we start again with the 63 value, right shift
- * it by 8-fb bits, and invert it.
- *
- *   +--------+
- *   |00111111|  <- "mask" set at 2&6-1
- *   |00001111|  <- "mask" after the right shift by 8-fb = 2 bits
- *   |11110000|  <- "mask" after bitwise not.
- *   +--------+
- *
- * Now we can mask it with b+1 to clear the old bits, and bitwise-OR
- * with "val" left-shifted by "rs" bits to set the new value.
- */
-
-/* Note: if we access the last counter, we will also access the b+1 byte
- * that is out of the array, but sds strings always have an implicit null
- * term, so the byte exists, and we can skip the conditional (or the need
- * to allocate 1 byte more explicitly). */
-
-/* Store the value of the register at position 'regnum' into variable 'target'.
- * 'p' is an array of unsigned bytes. */
-#define HLL_DENSE_GET_REGISTER(target,p,regnum) do { \
-    uint8_t *_p = (uint8_t*) p; \
-    unsigned long _byte = regnum*HLL_BITS/8; \
-    unsigned long _fb = regnum*HLL_BITS&7; \
-    unsigned long _fb8 = 8 - _fb; \
-    unsigned long b0 = _p[_byte]; \
-    unsigned long b1 = _p[_byte+1]; \
-    target = ((b0 >> _fb) | (b1 << _fb8)) & HLL_REGISTER_MAX; \
-} while(0)
-
-/* Set the value of the register at position 'regnum' to 'val'.
- * 'p' is an array of unsigned bytes. */
-#define HLL_DENSE_SET_REGISTER(p,regnum,val) do { \
-    uint8_t *_p = (uint8_t*) p; \
-    unsigned long _byte = regnum*HLL_BITS/8; \
-    unsigned long _fb = regnum*HLL_BITS&7; \
-    unsigned long _fb8 = 8 - _fb; \
-    unsigned long _v = val; \
-    _p[_byte] &= ~(HLL_REGISTER_MAX << _fb); \
-    _p[_byte] |= _v << _fb; \
-    _p[_byte+1] &= ~(HLL_REGISTER_MAX >> _fb8); \
-    _p[_byte+1] |= _v >> _fb8; \
-} while(0)
-
-/* Macros to access the sparse representation.
- * The macros parameter is expected to be an uint8_t pointer. */
-#define HLL_SPARSE_XZERO_BIT 0x40 /* 01xxxxxx */
-#define HLL_SPARSE_VAL_BIT 0x80 /* 1vvvvvxx */
-#define HLL_SPARSE_IS_ZERO(p) (((*(p)) & 0xc0) == 0) /* 00xxxxxx */
-#define HLL_SPARSE_IS_XZERO(p) (((*(p)) & 0xc0) == HLL_SPARSE_XZERO_BIT)
-#define HLL_SPARSE_IS_VAL(p) ((*(p)) & HLL_SPARSE_VAL_BIT)
-#define HLL_SPARSE_ZERO_LEN(p) (((*(p)) & 0x3f)+1)
-#define HLL_SPARSE_XZERO_LEN(p) (((((*(p)) & 0x3f) << 8) | (*((p)+1)))+1)
-#define HLL_SPARSE_VAL_VALUE(p) ((((*(p)) >> 2) & 0x1f)+1)
-#define HLL_SPARSE_VAL_LEN(p) (((*(p)) & 0x3)+1)
-#define HLL_SPARSE_VAL_MAX_VALUE 32
-#define HLL_SPARSE_VAL_MAX_LEN 4
-#define HLL_SPARSE_ZERO_MAX_LEN 64
-#define HLL_SPARSE_XZERO_MAX_LEN 16384
-#define HLL_SPARSE_VAL_SET(p,val,len) do { \
-    *(p) = (((val)-1)<<2|((len)-1))|HLL_SPARSE_VAL_BIT; \
-} while(0)
-#define HLL_SPARSE_ZERO_SET(p,len) do { \
-    *(p) = (len)-1; \
-} while(0)
-#define HLL_SPARSE_XZERO_SET(p,len) do { \
-    int _l = (len)-1; \
-    *(p) = (_l>>8) | HLL_SPARSE_XZERO_BIT; \
-    *((p)+1) = (_l&0xff); \
-} while(0)
-#define HLL_ALPHA_INF 0.721347520444481703680 /* constant for 0.5/ln(2) */
-
-/* ========================= HyperLogLog algorithm  ========================= */
-
-/* Our hash function is MurmurHash2, 64 bit version.
- * It was modified for Redis in order to provide the same result in
- * big and little endian archs (endian neutral). */
-uint64_t MurmurHash64A (const void * key, int len, unsigned int seed) {
-    const uint64_t m = 0xc6a4a7935bd1e995;
-    const int r = 47;
-    uint64_t h = seed ^ (len * m);
-    const uint8_t *data = (const uint8_t *)key;
-    const uint8_t *end = data + (len-(len&7));
-
-    while(data != end) {
-        uint64_t k;
-
-#if (BYTE_ORDER == LITTLE_ENDIAN)
-    #ifdef USE_ALIGNED_ACCESS
-        memcpy(&k,data,sizeof(uint64_t));
-    #else
-        k = *((uint64_t*)data);
-    #endif
-#else
-        k = (uint64_t) data[0];
-        k |= (uint64_t) data[1] << 8;
-        k |= (uint64_t) data[2] << 16;
-        k |= (uint64_t) data[3] << 24;
-        k |= (uint64_t) data[4] << 32;
-        k |= (uint64_t) data[5] << 40;
-        k |= (uint64_t) data[6] << 48;
-        k |= (uint64_t) data[7] << 56;
-#endif
-
-        k *= m;
-        k ^= k >> r;
-        k *= m;
-        h ^= k;
-        h *= m;
-        data += 8;
-    }
-
-    switch(len & 7) {
-    case 7: h ^= (uint64_t)data[6] << 48; /* fall-thru */
-    case 6: h ^= (uint64_t)data[5] << 40; /* fall-thru */
-    case 5: h ^= (uint64_t)data[4] << 32; /* fall-thru */
-    case 4: h ^= (uint64_t)data[3] << 24; /* fall-thru */
-    case 3: h ^= (uint64_t)data[2] << 16; /* fall-thru */
-    case 2: h ^= (uint64_t)data[1] << 8; /* fall-thru */
-    case 1: h ^= (uint64_t)data[0];
-            h *= m; /* fall-thru */
-    };
-
-    h ^= h >> r;
-    h *= m;
-    h ^= h >> r;
-    return h;
-}
-
-/* Given a string element to add to the HyperLogLog, returns the length
- * of the pattern 000..1 of the element hash. As a side effect 'regp' is
- * set to the register index this element hashes to. */
-int hllPatLen(unsigned char *ele, size_t elesize, long *regp) {
-    uint64_t hash, bit, index;
-    int count;
-
-    /* Count the number of zeroes starting from bit HLL_REGISTERS
-     * (that is a power of two corresponding to the first bit we don't use
-     * as index). The max run can be 64-P+1 = Q+1 bits.
-     *
-     * Note that the final "1" ending the sequence of zeroes must be
-     * included in the count, so if we find "001" the count is 3, and
-     * the smallest count possible is no zeroes at all, just a 1 bit
-     * at the first position, that is a count of 1.
-     *
-     * This may sound like inefficient, but actually in the average case
-     * there are high probabilities to find a 1 after a few iterations. */
-    hash = MurmurHash64A(ele,elesize,0xadc83b19ULL);
-    index = hash & HLL_P_MASK; /* Register index. */
-    hash >>= HLL_P; /* Remove bits used to address the register. */
-    hash |= ((uint64_t)1<<HLL_Q); /* Make sure the loop terminates
-                                     and count will be <= Q+1. */
-    bit = 1;
-    count = 1; /* Initialized to 1 since we count the "00000...1" pattern. */
-    while((hash & bit) == 0) {
-        count++;
-        bit <<= 1;
-    }
-    *regp = (int) index;
-    return count;
-}
-
-/* ================== Dense representation implementation  ================== */
-
-/* Low level function to set the dense HLL register at 'index' to the
- * specified value if the current value is smaller than 'count'.
- *
- * 'registers' is expected to have room for HLL_REGISTERS plus an
- * additional byte on the right. This requirement is met by sds strings
- * automatically since they are implicitly null terminated.
- *
- * The function always succeed, however if as a result of the operation
- * the approximated cardinality changed, 1 is returned. Otherwise 0
- * is returned. */
-static inline int hllDenseSet(uint8_t *registers, long index, uint8_t count) {
-    uint8_t oldcount;
-
-    HLL_DENSE_GET_REGISTER(oldcount,registers,index);
-    if (count > oldcount) {
-        HLL_DENSE_SET_REGISTER(registers,index,count);
-        return 1;
-    } else {
-        return 0;
-    }
-}
-
-/* "Add" the element in the dense hyperloglog data structure.
- * Actually nothing is added, but the max 0 pattern counter of the subset
- * the element belongs to is incremented if needed.
- *
- * This is just a wrapper to hllDenseSet(), performing the hashing of the
- * element in order to retrieve the index and zero-run count. */
-int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
-    long index;
-    uint8_t count = hllPatLen(ele,elesize,&index);
-    /* Update the register if this element produced a longer run of zeroes. */
-    return hllDenseSet(registers,index,count);
-}
-
-/* Compute the register histogram in the dense representation. */
-void hllDenseRegHisto(uint8_t *registers, int* reghisto) {
-    int j;
-
-    /* Redis default is to use 16384 registers 6 bits each. The code works
-     * with other values by modifying the defines, but for our target value
-     * we take a faster path with unrolled loops. */
-    if (HLL_REGISTERS == 16384 && HLL_BITS == 6) {
-        uint8_t *r = registers;
-        unsigned long r0, r1, r2, r3, r4, r5, r6, r7, r8, r9,
-                      r10, r11, r12, r13, r14, r15;
-        for (j = 0; j < 1024; j++) {
-            /* Handle 16 registers per iteration. */
-            r0 = r[0] & 63;
-            r1 = (r[0] >> 6 | r[1] << 2) & 63;
-            r2 = (r[1] >> 4 | r[2] << 4) & 63;
-            r3 = (r[2] >> 2) & 63;
-            r4 = r[3] & 63;
-            r5 = (r[3] >> 6 | r[4] << 2) & 63;
-            r6 = (r[4] >> 4 | r[5] << 4) & 63;
-            r7 = (r[5] >> 2) & 63;
-            r8 = r[6] & 63;
-            r9 = (r[6] >> 6 | r[7] << 2) & 63;
-            r10 = (r[7] >> 4 | r[8] << 4) & 63;
-            r11 = (r[8] >> 2) & 63;
-            r12 = r[9] & 63;
-            r13 = (r[9] >> 6 | r[10] << 2) & 63;
-            r14 = (r[10] >> 4 | r[11] << 4) & 63;
-            r15 = (r[11] >> 2) & 63;
-
-            reghisto[r0]++;
-            reghisto[r1]++;
-            reghisto[r2]++;
-            reghisto[r3]++;
-            reghisto[r4]++;
-            reghisto[r5]++;
-            reghisto[r6]++;
-            reghisto[r7]++;
-            reghisto[r8]++;
-            reghisto[r9]++;
-            reghisto[r10]++;
-            reghisto[r11]++;
-            reghisto[r12]++;
-            reghisto[r13]++;
-            reghisto[r14]++;
-            reghisto[r15]++;
-
-            r += 12;
-        }
-    } else {
-        for(j = 0; j < HLL_REGISTERS; j++) {
-            unsigned long reg;
-            HLL_DENSE_GET_REGISTER(reg,registers,j);
-            reghisto[reg]++;
-        }
-    }
-}
-
-/* ================== Sparse representation implementation  ================= */
-
-/* Convert the HLL with sparse representation given as input in its dense
- * representation. Both representations are represented by SDS strings, and
- * the input representation is freed as a side effect.
- *
- * The function returns C_OK if the sparse representation was valid,
- * otherwise C_ERR is returned if the representation was corrupted. */
-int hllSparseToDense(robj *o) {
-    sds sparse = (sds) o->ptr, dense;
-    struct hllhdr *hdr, *oldhdr = (struct hllhdr*)sparse;
-    int idx = 0, runlen, regval;
-    uint8_t *p = (uint8_t*)sparse, *end = p+sdslen(sparse);
-
-    /* If the representation is already the right one return ASAP. */
-    hdr = (struct hllhdr*) sparse;
-    if (hdr->encoding == HLL_DENSE) return HLL_C_OK;
-
-    /* Create a string of the right size filled with zero bytes.
-     * Note that the cached cardinality is set to 0 as a side effect
-     * that is exactly the cardinality of an empty HLL. */
-    dense = sdsnewlen(NULL,HLL_DENSE_SIZE);
-    hdr = (struct hllhdr*) dense;
-    *hdr = *oldhdr; /* This will copy the magic and cached cardinality. */
-    hdr->encoding = HLL_DENSE;
-
-    /* Now read the sparse representation and set non-zero registers
-     * accordingly. */
-    p += HLL_HDR_SIZE;
-    while(p < end) {
-        if (HLL_SPARSE_IS_ZERO(p)) {
-            runlen = HLL_SPARSE_ZERO_LEN(p);
-            idx += runlen;
-            p++;
-        } else if (HLL_SPARSE_IS_XZERO(p)) {
-            runlen = HLL_SPARSE_XZERO_LEN(p);
-            idx += runlen;
-            p += 2;
-        } else {
-            runlen = HLL_SPARSE_VAL_LEN(p);
-            regval = HLL_SPARSE_VAL_VALUE(p);
-            while(runlen--) {
-                HLL_DENSE_SET_REGISTER(hdr->registers + 1,idx,regval);
-                idx++;
-            }
-            p++;
-        }
-    }
-
-    /* If the sparse representation was valid, we expect to find idx
-     * set to HLL_REGISTERS. */
-    if (idx != HLL_REGISTERS) {
-        sdsfree(dense);
-        return HLL_C_ERR;
-    }
-
-    /* Free the old representation and set the new one. */
-    sdsfree((sds) o->ptr);
-    o->ptr = dense;
-    return HLL_C_OK;
-}
-
-/* Low level function to set the sparse HLL register at 'index' to the
- * specified value if the current value is smaller than 'count'.
- *
- * The object 'o' is the String object holding the HLL. The function requires
- * a reference to the object in order to be able to enlarge the string if
- * needed.
- *
- * On success, the function returns 1 if the cardinality changed, or 0
- * if the register for this element was not updated.
- * On error (if the representation is invalid) -1 is returned.
- *
- * As a side effect the function may promote the HLL representation from
- * sparse to dense: this happens when a register requires to be set to a value
- * not representable with the sparse representation, or when the resulting
- * size would be greater than server.hll_sparse_max_bytes. */
-int hllSparseSet(robj *o, long index, uint8_t count) {
-    struct hllhdr *hdr;
-    uint8_t oldcount, *sparse, *end, *p, *prev, *next;
-    long first, span;
-    long is_zero = 0, is_xzero = 0, is_val = 0, runlen = 0;
-    uint8_t seq[5], *n;
-    int last;
-    int len;
-    int seqlen;
-    int oldlen;
-    int deltalen;
-
-    /* If the count is too big to be representable by the sparse representation
-     * switch to dense representation. */
-    if (count > HLL_SPARSE_VAL_MAX_VALUE) goto promote;
-
-    /* When updating a sparse representation, sometimes we may need to
-     * enlarge the buffer for up to 3 bytes in the worst case (XZERO split
-     * into XZERO-VAL-XZERO). Make sure there is enough space right now
-     * so that the pointers we take during the execution of the function
-     * will be valid all the time. */
-    o->ptr = (sds) sdsMakeRoomFor((sds) o->ptr,3);
-
-    /* Step 1: we need to locate the opcode we need to modify to check
-     * if a value update is actually needed. */
-    sparse = p = ((uint8_t*)o->ptr) + HLL_HDR_SIZE;
-    end = p + sdslen((sds) o->ptr) - HLL_HDR_SIZE;
-
-    first = 0;
-    prev = NULL; /* Points to previous opcode at the end of the loop. */
-    next = NULL; /* Points to the next opcode at the end of the loop. */
-    span = 0;
-    while(p < end) {
-        long oplen;
-
-        /* Set span to the number of registers covered by this opcode.
-         *
-         * This is the most performance critical loop of the sparse
-         * representation. Sorting the conditionals from the most to the
-         * least frequent opcode in many-bytes sparse HLLs is faster. */
-        oplen = 1;
-        if (HLL_SPARSE_IS_ZERO(p)) {
-            span = HLL_SPARSE_ZERO_LEN(p);
-        } else if (HLL_SPARSE_IS_VAL(p)) {
-            span = HLL_SPARSE_VAL_LEN(p);
-        } else { /* XZERO. */
-            span = HLL_SPARSE_XZERO_LEN(p);
-            oplen = 2;
-        }
-        /* Break if this opcode covers the register as 'index'. */
-        if (index <= first+span-1) break;
-        prev = p;
-        p += oplen;
-        first += span;
-    }
-    if (span == 0) return -1; /* Invalid format. */
-
-    next = HLL_SPARSE_IS_XZERO(p) ? p+2 : p+1;
-    if (next >= end) next = NULL;
-
-    /* Cache current opcode type to avoid using the macro again and
-     * again for something that will not change.
-     * Also cache the run-length of the opcode. */
-    if (HLL_SPARSE_IS_ZERO(p)) {
-        is_zero = 1;
-        runlen = HLL_SPARSE_ZERO_LEN(p);
-    } else if (HLL_SPARSE_IS_XZERO(p)) {
-        is_xzero = 1;
-        runlen = HLL_SPARSE_XZERO_LEN(p);
-    } else {
-        is_val = 1;
-        runlen = HLL_SPARSE_VAL_LEN(p);
-    }
-
-    /* Step 2: After the loop:
-     *
-     * 'first' stores to the index of the first register covered
-     *  by the current opcode, which is pointed by 'p'.
-     *
-     * 'next' ad 'prev' store respectively the next and previous opcode,
-     *  or NULL if the opcode at 'p' is respectively the last or first.
-     *
-     * 'span' is set to the number of registers covered by the current
-     *  opcode.
-     *
-     * There are different cases in order to update the data structure
-     * in place without generating it from scratch:
-     *
-     * A) If it is a VAL opcode already set to a value >= our 'count'
-     *    no update is needed, regardless of the VAL run-length field.
-     *    In this case PFADD returns 0 since no changes are performed.
-     *
-     * B) If it is a VAL opcode with len = 1 (representing only our
-     *    register) and the value is less than 'count', we just update it
-     *    since this is a trivial case. */
-    if (is_val) {
-        oldcount = HLL_SPARSE_VAL_VALUE(p);
-        /* Case A. */
-        if (oldcount >= count) return 0;
-
-        /* Case B. */
-        if (runlen == 1) {
-            HLL_SPARSE_VAL_SET(p,count,1);
-            goto updated;
-        }
-    }
-
-    /* C) Another trivial to handle case is a ZERO opcode with a len of 1.
-     * We can just replace it with a VAL opcode with our value and len of 1. */
-    if (is_zero && runlen == 1) {
-        HLL_SPARSE_VAL_SET(p,count,1);
-        goto updated;
-    }
-
-    /* D) General case.
-     *
-     * The other cases are more complex: our register requires to be updated
-     * and is either currently represented by a VAL opcode with len > 1,
-     * by a ZERO opcode with len > 1, or by an XZERO opcode.
-     *
-     * In those cases the original opcode must be split into multiple
-     * opcodes. The worst case is an XZERO split in the middle resuling into
-     * XZERO - VAL - XZERO, so the resulting sequence max length is
-     * 5 bytes.
-     *
-     * We perform the split writing the new sequence into the 'new' buffer
-     * with 'newlen' as length. Later the new sequence is inserted in place
-     * of the old one, possibly moving what is on the right a few bytes
-     * if the new sequence is longer than the older one. */
-    n = seq;
-    last = first+span-1; /* Last register covered by the sequence. */
-
-    if (is_zero || is_xzero) {
-        /* Handle splitting of ZERO / XZERO. */
-        if (index != first) {
-            len = index-first;
-            if (len > HLL_SPARSE_ZERO_MAX_LEN) {
-                HLL_SPARSE_XZERO_SET(n,len);
-                n += 2;
-            } else {
-                HLL_SPARSE_ZERO_SET(n,len);
-                n++;
-            }
-        }
-        HLL_SPARSE_VAL_SET(n,count,1);
-        n++;
-        if (index != last) {
-            len = last-index;
-            if (len > HLL_SPARSE_ZERO_MAX_LEN) {
-                HLL_SPARSE_XZERO_SET(n,len);
-                n += 2;
-            } else {
-                HLL_SPARSE_ZERO_SET(n,len);
-                n++;
-            }
-        }
-    } else {
-        /* Handle splitting of VAL. */
-        int curval = HLL_SPARSE_VAL_VALUE(p);
-
-        if (index != first) {
-            len = index-first;
-            HLL_SPARSE_VAL_SET(n,curval,len);
-            n++;
-        }
-        HLL_SPARSE_VAL_SET(n,count,1);
-        n++;
-        if (index != last) {
-            len = last-index;
-            HLL_SPARSE_VAL_SET(n,curval,len);
-            n++;
-        }
-    }
-
-    /* Step 3: substitute the new sequence with the old one.
-     *
-     * Note that we already allocated space on the sds string
-     * calling sdsMakeRoomFor(). */
-     seqlen = n-seq;
-     oldlen = is_xzero ? 2 : 1;
-     deltalen = seqlen-oldlen;
-
-     if (deltalen > 0 &&
-         sdslen((sds) o->ptr)+deltalen > HLL_SPARSE_MAX_BYTES) goto promote;
-     if (deltalen && next) memmove(next+deltalen,next,end-next);
-     sdsIncrLen((sds) o->ptr,deltalen);
-     memcpy(p,seq,seqlen);
-     end += deltalen;
-
-updated: {
-    /* Step 4: Merge adjacent values if possible.
-     *
-     * The representation was updated, however the resulting representation
-     * may not be optimal: adjacent VAL opcodes can sometimes be merged into
-     * a single one. */
-    p = prev ? prev : sparse;
-    int scanlen = 5; /* Scan up to 5 upcodes starting from prev. */
-    while (p < end && scanlen--) {
-        if (HLL_SPARSE_IS_XZERO(p)) {
-            p += 2;
-            continue;
-        } else if (HLL_SPARSE_IS_ZERO(p)) {
-            p++;
-            continue;
-        }
-        /* We need two adjacent VAL opcodes to try a merge, having
-         * the same value, and a len that fits the VAL opcode max len. */
-        if (p+1 < end && HLL_SPARSE_IS_VAL(p+1)) {
-            int v1 = HLL_SPARSE_VAL_VALUE(p);
-            int v2 = HLL_SPARSE_VAL_VALUE(p+1);
-            if (v1 == v2) {
-                int len = HLL_SPARSE_VAL_LEN(p)+HLL_SPARSE_VAL_LEN(p+1);
-                if (len <= HLL_SPARSE_VAL_MAX_LEN) {
-                    HLL_SPARSE_VAL_SET(p+1,v1,len);
-                    memmove(p,p+1,end-p);
-                    sdsIncrLen((sds) o->ptr,-1);
-                    end--;
-                    /* After a merge we reiterate without incrementing 'p'
-                     * in order to try to merge the just merged value with
-                     * a value on its right. */
-                    continue;
-                }
-            }
-        }
-        p++;
-    }
-
-    /* Invalidate the cached cardinality. */
-    hdr = (struct hllhdr *) o->ptr;
-    HLL_INVALIDATE_CACHE(hdr);
-    return 1;
-}
-promote: /* Promote to dense representation. */
-    if (hllSparseToDense(o) == HLL_C_ERR) return -1; /* Corrupted HLL. */
-    hdr = (struct hllhdr *) o->ptr;
-
-    /* We need to call hllDenseAdd() to perform the operation after the
-     * conversion. However the result must be 1, since if we need to
-     * convert from sparse to dense a register requires to be updated.
-     *
-     * Note that this in turn means that PFADD will make sure the command
-     * is propagated to slaves / AOF, so if there is a sparse -> dense
-     * conversion, it will be performed in all the slaves as well. */
-    int dense_retval = hllDenseSet(hdr->registers + 1,index,count);
-    assert(dense_retval == 1);
-    return dense_retval;
-}
-
-/* "Add" the element in the sparse hyperloglog data structure.
- * Actually nothing is added, but the max 0 pattern counter of the subset
- * the element belongs to is incremented if needed.
- *
- * This function is actually a wrapper for hllSparseSet(), it only performs
- * the hashshing of the elmenet to obtain the index and zeros run length. */
-int hllSparseAdd(robj *o, unsigned char *ele, size_t elesize) {
-    long index;
-    uint8_t count = hllPatLen(ele,elesize,&index);
-    /* Update the register if this element produced a longer run of zeroes. */
-    return hllSparseSet(o,index,count);
-}
-
-/* Compute the register histogram in the sparse representation. */
-void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* reghisto) {
-    int idx = 0, runlen, regval;
-    uint8_t *end = sparse+sparselen, *p = sparse;
-
-    while(p < end) {
-        if (HLL_SPARSE_IS_ZERO(p)) {
-            runlen = HLL_SPARSE_ZERO_LEN(p);
-            idx += runlen;
-            reghisto[0] += runlen;
-            p++;
-        } else if (HLL_SPARSE_IS_XZERO(p)) {
-            runlen = HLL_SPARSE_XZERO_LEN(p);
-            idx += runlen;
-            reghisto[0] += runlen;
-            p += 2;
-        } else {
-            runlen = HLL_SPARSE_VAL_LEN(p);
-            regval = HLL_SPARSE_VAL_VALUE(p);
-            idx += runlen;
-            reghisto[regval] += runlen;
-            p++;
-        }
-    }
-    if (idx != HLL_REGISTERS && invalid) *invalid = 1;
-}
-
-/* ========================= HyperLogLog Count ==============================
- * This is the core of the algorithm where the approximated count is computed.
- * The function uses the lower level hllDenseRegHisto() and hllSparseRegHisto()
- * functions as helpers to compute histogram of register values part of the
- * computation, which is representation-specific, while all the rest is common. */
-
-/* Implements the register histogram calculation for uint8_t data type
- * which is only used internally as speedup for PFCOUNT with multiple keys. */
-void hllRawRegHisto(uint8_t *registers, int* reghisto) {
-    uint64_t *word = (uint64_t*) registers;
-    uint8_t *bytes;
-    int j;
-
-    for (j = 0; j < HLL_REGISTERS/8; j++) {
-        if (*word == 0) {
-            reghisto[0] += 8;
-        } else {
-            bytes = (uint8_t*) word;
-            reghisto[bytes[0]]++;
-            reghisto[bytes[1]]++;
-            reghisto[bytes[2]]++;
-            reghisto[bytes[3]]++;
-            reghisto[bytes[4]]++;
-            reghisto[bytes[5]]++;
-            reghisto[bytes[6]]++;
-            reghisto[bytes[7]]++;
-        }
-        word++;
-    }
-}
-
-// somehow this is missing on some platforms
-#ifndef INFINITY
-// from math.h
-#define INFINITY 1e50f
-#endif
-
-
-/* Helper function sigma as defined in
- * "New cardinality estimation algorithms for HyperLogLog sketches"
- * Otmar Ertl, arXiv:1702.01284 */
-double hllSigma(double x) {
-    if (x == 1.) return INFINITY;
-    double zPrime;
-    double y = 1;
-    double z = x;
-    do {
-        x *= x;
-        zPrime = z;
-        z += x * y;
-        y += y;
-    } while(zPrime != z);
-    return z;
-}
-
-/* Helper function tau as defined in
- * "New cardinality estimation algorithms for HyperLogLog sketches"
- * Otmar Ertl, arXiv:1702.01284 */
-double hllTau(double x) {
-    if (x == 0. || x == 1.) return 0.;
-    double zPrime;
-    double y = 1.0;
-    double z = 1 - x;
-    do {
-        x = sqrt(x);
-        zPrime = z;
-        y *= 0.5;
-        z -= pow(1 - x, 2)*y;
-    } while(zPrime != z);
-    return z / 3;
-}
-
-/* Return the approximated cardinality of the set based on the harmonic
- * mean of the registers values. 'hdr' points to the start of the SDS
- * representing the String object holding the HLL representation.
- *
- * If the sparse representation of the HLL object is not valid, the integer
- * pointed by 'invalid' is set to non-zero, otherwise it is left untouched.
- *
- * hllCount() supports a special internal-only encoding of HLL_RAW, that
- * is, hdr->registers will point to an uint8_t array of HLL_REGISTERS element.
- * This is useful in order to speedup PFCOUNT when called against multiple
- * keys (no need to work with 6-bit integers encoding). */
-uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
-    double m = HLL_REGISTERS;
-    double E;
-    int j;
-    int reghisto[HLL_Q+2] = {0};
-
-    /* Compute register histogram */
-    if (hdr->encoding == HLL_DENSE) {
-        hllDenseRegHisto(hdr->registers + 1,reghisto);
-    } else if (hdr->encoding == HLL_SPARSE) {
-        hllSparseRegHisto(hdr->registers + 1,
-                         sdslen((sds)hdr)-HLL_HDR_SIZE,invalid,reghisto);
-    } else if (hdr->encoding == HLL_RAW) {
-        hllRawRegHisto(hdr->registers + 1,reghisto);
-    } else {
-		*invalid = 1;
-		return 0;
-        //serverPanic("Unknown HyperLogLog encoding in hllCount()");
-    }
-
-    /* Estimate cardinality form register histogram. See:
-     * "New cardinality estimation algorithms for HyperLogLog sketches"
-     * Otmar Ertl, arXiv:1702.01284 */
-    double z = m * hllTau((m-reghisto[HLL_Q+1])/(double)m);
-    for (j = HLL_Q; j >= 1; --j) {
-        z += reghisto[j];
-        z *= 0.5;
-    }
-    z += m * hllSigma(reghisto[0]/(double)m);
-    E = llroundl(HLL_ALPHA_INF*m*m/z);
-
-    return (uint64_t) E;
-}
-
-/* Call hllDenseAdd() or hllSparseAdd() according to the HLL encoding. */
-int hll_add(robj *o, unsigned char *ele, size_t elesize) {
-    struct hllhdr *hdr = (struct hllhdr *) o->ptr;
-    switch(hdr->encoding) {
-    case HLL_DENSE: return hllDenseAdd(hdr->registers + 1,ele,elesize);
-    case HLL_SPARSE: return hllSparseAdd(o,ele,elesize);
-    default: return -1; /* Invalid representation. */
-    }
-}
-
-/* Merge by computing MAX(registers[i],hll[i]) the HyperLogLog 'hll'
- * with an array of uint8_t HLL_REGISTERS registers pointed by 'max'.
- *
- * The hll object must be already validated via isHLLObjectOrReply()
- * or in some other way.
- *
- * If the HyperLogLog is sparse and is found to be invalid, C_ERR
- * is returned, otherwise the function always succeeds. */
-int hllMerge(uint8_t *max, robj *hll) {
-    struct hllhdr *hdr = (struct hllhdr *) hll->ptr;
-    int i;
-
-    if (hdr->encoding == HLL_DENSE) {
-        uint8_t val;
-
-        for (i = 0; i < HLL_REGISTERS; i++) {
-            HLL_DENSE_GET_REGISTER(val,hdr->registers + 1,i);
-            if (val > max[i]) max[i] = val;
-        }
-    } else {
-        uint8_t *p = (uint8_t *) hll->ptr, *end = p + sdslen((sds) hll->ptr);
-        long runlen, regval;
-
-        p += HLL_HDR_SIZE;
-        i = 0;
-        while(p < end) {
-            if (HLL_SPARSE_IS_ZERO(p)) {
-                runlen = HLL_SPARSE_ZERO_LEN(p);
-                i += runlen;
-                p++;
-            } else if (HLL_SPARSE_IS_XZERO(p)) {
-                runlen = HLL_SPARSE_XZERO_LEN(p);
-                i += runlen;
-                p += 2;
-            } else {
-                runlen = HLL_SPARSE_VAL_LEN(p);
-                regval = HLL_SPARSE_VAL_VALUE(p);
-                while(runlen--) {
-                    if (regval > max[i]) max[i] = regval;
-                    i++;
-                }
-                p++;
-            }
-        }
-        if (i != HLL_REGISTERS) return HLL_C_ERR;
-    }
-    return HLL_C_OK;
-}
-
-/* ========================== robj creation ========================== */
-robj *createObject(void *ptr) {
-	robj *result = (robj*) malloc(sizeof(robj));
-	result->ptr = ptr;
-	return result;
-}
-
-void destroyObject(robj *obj) {
-	free(obj);
-}
-
-/* ========================== HyperLogLog commands ========================== */
-
-/* Create an HLL object. We always create the HLL using sparse encoding.
- * This will be upgraded to the dense representation as needed. */
-robj *hll_create(void) {
-    robj *o;
-    struct hllhdr *hdr;
-    sds s;
-    uint8_t *p;
-    int sparselen = HLL_HDR_SIZE +
-                    (((HLL_REGISTERS+(HLL_SPARSE_XZERO_MAX_LEN-1)) /
-                     HLL_SPARSE_XZERO_MAX_LEN)*2);
-    int aux;
-
-    /* Populate the sparse representation with as many XZERO opcodes as
-     * needed to represent all the registers. */
-    aux = HLL_REGISTERS;
-    s = sdsnewlen(NULL,sparselen);
-    p = (uint8_t*)s + HLL_HDR_SIZE;
-    while(aux) {
-        int xzero = HLL_SPARSE_XZERO_MAX_LEN;
-        if (xzero > aux) xzero = aux;
-        HLL_SPARSE_XZERO_SET(p,xzero);
-        p += 2;
-        aux -= xzero;
-    }
-    assert((p-(uint8_t*)s) == sparselen);
-
-    /* Create the actual object. */
-    o = createObject(s);
-    hdr = (struct hllhdr *) o->ptr;
-    memcpy(hdr->magic,"HYLL",4);
-    hdr->encoding = HLL_SPARSE;
-    return o;
-}
-
-void hll_destroy(robj *obj) {
-	if (!obj) {
-		return;
-	}
-	sdsfree((sds) obj->ptr);
-	destroyObject(obj);
-}
-
-
-
-int hll_count(robj *o, size_t *result) {
-	int invalid = 0;
-	*result = hllCount((struct hllhdr*) o->ptr, &invalid);
-	return invalid == 0 ? HLL_C_OK : HLL_C_ERR;
-}
-
-robj *hll_merge(robj **hlls, size_t hll_count) {
-    uint8_t max[HLL_REGISTERS];
-    struct hllhdr *hdr;
-    size_t j;
-	 /* Use dense representation as target? */
-    int use_dense = 0;
-
-    /* Compute an HLL with M[i] = MAX(M[i]_j).
-     * We store the maximum into the max array of registers. We'll write
-     * it to the target variable later. */
-    memset(max, 0, sizeof(max));
-    for (j = 0; j < hll_count; j++) {
-        /* Check type and size. */
-        robj *o = hlls[j];
-        if (o == NULL) continue; /* Assume empty HLL for non existing var. */
-
-        /* If at least one involved HLL is dense, use the dense representation
-         * as target ASAP to save time and avoid the conversion step. */
-        hdr = (struct hllhdr *) o->ptr;
-        if (hdr->encoding == HLL_DENSE) use_dense = 1;
-
-        /* Merge with this HLL with our 'max' HHL by setting max[i]
-         * to MAX(max[i],hll[i]). */
-        if (hllMerge(max, o) == HLL_C_ERR) {
-            return NULL;
-        }
-    }
-
-    /* Create the destination key's value. */
-    robj *result = hll_create();
-	if (!result) {
-		return NULL;
-	}
-
-    /* Convert the destination object to dense representation if at least
-     * one of the inputs was dense. */
-    if (use_dense && hllSparseToDense(result) == HLL_C_ERR) {
-		hll_destroy(result);
-        return NULL;
-    }
-
-    /* Write the resulting HLL to the destination HLL registers and
-     * invalidate the cached value. */
-    for (j = 0; j < HLL_REGISTERS; j++) {
-        if (max[j] == 0) continue;
-        hdr = (struct hllhdr *) result->ptr;
-        switch(hdr->encoding) {
-        case HLL_DENSE: hllDenseSet(hdr->registers + 1,j,max[j]); break;
-        case HLL_SPARSE: hllSparseSet(result,j,max[j]); break;
-        }
-    }
-	return result;
-}
-
-uint64_t get_size() {
-	return HLL_DENSE_SIZE;
-}
-
-uint64_t num_registers() {
-	return HLL_REGISTERS;
-}
-
-uint8_t maximum_zeros() {
-	return HLL_Q;
-}
-
-uint8_t get_register(robj *o, size_t index) {
-	struct hllhdr *hdr = (struct hllhdr *) o->ptr;
-	uint8_t result;
-	HLL_DENSE_GET_REGISTER(result, hdr->registers + 1, index);
-	return result;
-}
-
-void set_register(robj *o, size_t index, uint8_t count) {
-	struct hllhdr *hdr = (struct hllhdr *) o->ptr;
-	HLL_DENSE_SET_REGISTER(hdr->registers + 1, index, count);
-}
-
-}
diff --git a/src/duckdb/third_party/hyperloglog/hyperloglog.hpp b/src/duckdb/third_party/hyperloglog/hyperloglog.hpp
deleted file mode 100644
index cda167678..000000000
--- a/src/duckdb/third_party/hyperloglog/hyperloglog.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// third_party/hyperloglog/hyperloglog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <stdint.h>
-#include <string.h>
-
-namespace duckdb_hll {
-
-// NOLINTBEGIN
-
-/* Error codes */
-#define HLL_C_OK  0
-#define HLL_C_ERR -1
-
-struct robj {
-	void *ptr;
-};
-
-//! Create a new empty HyperLogLog object
-robj *hll_create(void);
-//! Convert hll from sparse to dense
-int hllSparseToDense(robj *o);
-//! Destroy the specified HyperLogLog object
-void hll_destroy(robj *obj);
-//! Add an element with the specified amount of bytes to the HyperLogLog. Returns C_ERR on failure, otherwise returns 0
-//! if the cardinality did not change, and 1 otherwise.
-int hll_add(robj *o, unsigned char *ele, size_t elesize);
-//! Returns the estimated amount of unique elements seen by the HyperLogLog. Returns C_OK on success, or C_ERR on
-//! failure.
-int hll_count(robj *o, size_t *result);
-//! Merge hll_count HyperLogLog objects into a single one. Returns NULL on failure, or the new HLL object on success.
-robj *hll_merge(robj **hlls, size_t hll_count);
-//! Get size (in bytes) of the HLL
-uint64_t get_size();
-//! Get the number of registers
-uint64_t num_registers();
-//! The maximum number of trailing zeros
-uint8_t maximum_zeros();
-//! Get the count of the register
-uint8_t get_register(robj *o, size_t index);
-//! Set the count of the register
-void set_register(robj *o, size_t index, uint8_t count);
-
-// NOLINTEND
-
-} // namespace duckdb_hll
-
-namespace duckdb {
-
-void AddToLogsInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
-                       const SelectionVector *log_sel);
-
-void AddToSingleLogInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log);
-
-} // namespace duckdb
diff --git a/src/duckdb/third_party/hyperloglog/sds.cpp b/src/duckdb/third_party/hyperloglog/sds.cpp
deleted file mode 100644
index 4bb827ea8..000000000
--- a/src/duckdb/third_party/hyperloglog/sds.cpp
+++ /dev/null
@@ -1,1115 +0,0 @@
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Oran Agra
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * 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.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <assert.h>
-#include <limits.h>
-#include "sds.hpp"
-
-namespace duckdb_hll {
-
-static inline int sdsHdrSize(char type) {
-    switch(type&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return sizeof(struct sdshdr5);
-        case SDS_TYPE_8:
-            return sizeof(struct sdshdr8);
-        case SDS_TYPE_16:
-            return sizeof(struct sdshdr16);
-        case SDS_TYPE_32:
-            return sizeof(struct sdshdr32);
-        case SDS_TYPE_64:
-            return sizeof(struct sdshdr64);
-    }
-    return 0;
-}
-
-static inline char sdsReqType(size_t string_size) {
-    if (string_size < 1<<5)
-        return SDS_TYPE_5;
-    if (string_size < 1<<8)
-        return SDS_TYPE_8;
-    if (string_size < 1<<16)
-        return SDS_TYPE_16;
-#if (LONG_MAX == LLONG_MAX)
-    if (string_size < 1ll<<32)
-        return SDS_TYPE_32;
-    return SDS_TYPE_64;
-#else
-    return SDS_TYPE_32;
-#endif
-}
-
-/* Create a new sds string with the content specified by the 'init' pointer
- * and 'initlen'.
- * If NULL is used for 'init' the string is initialized with zero bytes.
- * If SDS_NOINIT is used, the buffer is left uninitialized;
- *
- * The string is always null-termined (all the sds strings are, always) so
- * even if you create an sds string with:
- *
- * mystring = sdsnewlen("abc",3);
- *
- * You can print the string with printf() as there is an implicit \0 at the
- * end of the string. However the string is binary safe and can contain
- * \0 characters in the middle, as the length is stored in the sds header. */
-sds sdsnewlen(const void *init, size_t initlen) {
-    void *sh;
-    sds s;
-    char type = sdsReqType(initlen);
-    /* Empty strings are usually created in order to append. Use type 8
-     * since type 5 is not good at this. */
-    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
-    int hdrlen = sdsHdrSize(type);
-    unsigned char *fp; /* flags pointer. */
-
-    sh = malloc(hdrlen+initlen+1);
-    if (!init)
-        memset(sh, 0, hdrlen+initlen+1);
-    if (sh == NULL) return NULL;
-    s = (char*)sh+hdrlen;
-    fp = ((unsigned char*)s)-1;
-    switch(type) {
-        case SDS_TYPE_5: {
-            *fp = type | (initlen << SDS_TYPE_BITS);
-            break;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-    }
-    if (initlen && init)
-        memcpy(s, init, initlen);
-    s[initlen] = '\0';
-    return s;
-}
-
-/* Create an empty (zero length) sds string. Even in this case the string
- * always has an implicit null term. */
-sds sdsempty(void) {
-    return sdsnewlen("",0);
-}
-
-/* Create a new sds string starting from a null terminated C string. */
-sds sdsnew(const char *init) {
-    size_t initlen = (init == NULL) ? 0 : strlen(init);
-    return sdsnewlen(init, initlen);
-}
-
-/* Duplicate an sds string. */
-sds sdsdup(const sds s) {
-    return sdsnewlen(s, sdslen(s));
-}
-
-/* Free an sds string. No operation is performed if 's' is NULL. */
-void sdsfree(sds s) {
-    if (s == NULL) return;
-    free((char*)s-sdsHdrSize(s[-1]));
-}
-
-/* Set the sds string length to the length as obtained with strlen(), so
- * considering as content only up to the first null term character.
- *
- * This function is useful when the sds string is hacked manually in some
- * way, like in the following example:
- *
- * s = sdsnew("foobar");
- * s[2] = '\0';
- * sdsupdatelen(s);
- * printf("%d\n", sdslen(s));
- *
- * The output will be "2", but if we comment out the call to sdsupdatelen()
- * the output will be "6" as the string was modified but the logical length
- * remains 6 bytes. */
-void sdsupdatelen(sds s) {
-    size_t reallen = strlen(s);
-    sdssetlen(s, reallen);
-}
-
-/* Modify an sds string in-place to make it empty (zero length).
- * However all the existing buffer is not discarded but set as free space
- * so that next append operations will not require allocations up to the
- * number of bytes previously available. */
-void sdsclear(sds s) {
-    sdssetlen(s, 0);
-    s[0] = '\0';
-}
-
-/* Enlarge the free space at the end of the sds string so that the caller
- * is sure that after calling this function can overwrite up to addlen
- * bytes after the end of the string, plus one more byte for nul term.
- *
- * Note: this does not change the *length* of the sds string as returned
- * by sdslen(), but only the free buffer space we have. */
-sds sdsMakeRoomFor(sds s, size_t addlen) {
-    void *sh, *newsh;
-    size_t avail = sdsavail(s);
-    size_t len, newlen;
-    char type, oldtype = s[-1] & SDS_TYPE_MASK;
-    int hdrlen;
-
-    /* Return ASAP if there is enough space left. */
-    if (avail >= addlen) return s;
-
-    len = sdslen(s);
-    sh = (char*)s-sdsHdrSize(oldtype);
-    newlen = (len+addlen);
-    if (newlen < SDS_MAX_PREALLOC)
-        newlen *= 2;
-    else
-        newlen += SDS_MAX_PREALLOC;
-
-    type = sdsReqType(newlen);
-
-    /* Don't use type 5: the user is appending to the string and type 5 is
-     * not able to remember empty space, so sdsMakeRoomFor() must be called
-     * at every appending operation. */
-    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
-
-    hdrlen = sdsHdrSize(type);
-    if (oldtype==type) {
-        newsh = realloc(sh, hdrlen+newlen+1);
-        if (newsh == NULL) return NULL;
-        s = (char*)newsh+hdrlen;
-    } else {
-        /* Since the header size changes, need to move the string forward,
-         * and can't use realloc */
-        newsh = malloc(hdrlen+newlen+1);
-        if (newsh == NULL) return NULL;
-        memcpy((char*)newsh+hdrlen, s, len+1);
-        free(sh);
-        s = (char*)newsh+hdrlen;
-        s[-1] = type;
-        sdssetlen(s, len);
-    }
-    sdssetalloc(s, newlen);
-    return s;
-}
-
-/* Reallocate the sds string so that it has no free space at the end. The
- * contained string remains not altered, but next concatenation operations
- * will require a reallocation.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdsRemoveFreeSpace(sds s) {
-    void *sh, *newsh;
-    char type, oldtype = s[-1] & SDS_TYPE_MASK;
-    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
-    size_t len = sdslen(s);
-    sh = (char*)s-oldhdrlen;
-
-    /* Check what would be the minimum SDS header that is just good enough to
-     * fit this string. */
-    type = sdsReqType(len);
-    hdrlen = sdsHdrSize(type);
-
-    /* If the type is the same, or at least a large enough type is still
-     * required, we just realloc(), letting the allocator to do the copy
-     * only if really needed. Otherwise if the change is huge, we manually
-     * reallocate the string to use the different header type. */
-    if (oldtype==type || type > SDS_TYPE_8) {
-        newsh = realloc(sh, oldhdrlen+len+1);
-        if (newsh == NULL) return NULL;
-        s = (char*)newsh+oldhdrlen;
-    } else {
-        newsh = malloc(hdrlen+len+1);
-        if (newsh == NULL) return NULL;
-        memcpy((char*)newsh+hdrlen, s, len+1);
-        free(sh);
-        s = (char*)newsh+hdrlen;
-        s[-1] = type;
-        sdssetlen(s, len);
-    }
-    sdssetalloc(s, len);
-    return s;
-}
-
-/* Return the total size of the allocation of the specified sds string,
- * including:
- * 1) The sds header before the pointer.
- * 2) The string.
- * 3) The free buffer at the end if any.
- * 4) The implicit null term.
- */
-size_t sdsAllocSize(sds s) {
-    size_t alloc = sdsalloc(s);
-    return sdsHdrSize(s[-1])+alloc+1;
-}
-
-/* Return the pointer of the actual SDS allocation (normally SDS strings
- * are referenced by the start of the string buffer). */
-void *sdsAllocPtr(sds s) {
-    return (void*) (s-sdsHdrSize(s[-1]));
-}
-
-/* Increment the sds length and decrements the left free space at the
- * end of the string according to 'incr'. Also set the null term
- * in the new end of the string.
- *
- * This function is used in order to fix the string length after the
- * user calls sdsMakeRoomFor(), writes something after the end of
- * the current string, and finally needs to set the new length.
- *
- * Note: it is possible to use a negative increment in order to
- * right-trim the string.
- *
- * Usage example:
- *
- * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the
- * following schema, to cat bytes coming from the kernel to the end of an
- * sds string without copying into an intermediate buffer:
- *
- * oldlen = sdslen(s);
- * s = sdsMakeRoomFor(s, BUFFER_SIZE);
- * nread = read(fd, s+oldlen, BUFFER_SIZE);
- * ... check for nread <= 0 and handle it ...
- * sdsIncrLen(s, nread);
- */
-void sdsIncrLen(sds s, ssize_t incr) {
-    unsigned char flags = s[-1];
-    size_t len;
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5: {
-            unsigned char *fp = ((unsigned char*)s)-1;
-            unsigned char oldlen = SDS_TYPE_5_LEN(flags);
-            assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));
-            *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS);
-            len = oldlen+incr;
-            break;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        default: len = 0; /* Just to avoid compilation warnings. */
-    }
-    s[len] = '\0';
-}
-
-/* Grow the sds to have the specified length. Bytes that were not part of
- * the original length of the sds will be set to zero.
- *
- * if the specified length is smaller than the current length, no operation
- * is performed. */
-sds sdsgrowzero(sds s, size_t len) {
-    size_t curlen = sdslen(s);
-
-    if (len <= curlen) return s;
-    s = sdsMakeRoomFor(s,len-curlen);
-    if (s == NULL) return NULL;
-
-    /* Make sure added region doesn't contain garbage */
-    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
-    sdssetlen(s, len);
-    return s;
-}
-
-/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
- * end of the specified sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatlen(sds s, const void *t, size_t len) {
-    size_t curlen = sdslen(s);
-
-    s = sdsMakeRoomFor(s,len);
-    if (s == NULL) return NULL;
-    memcpy(s+curlen, t, len);
-    sdssetlen(s, curlen+len);
-    s[curlen+len] = '\0';
-    return s;
-}
-
-/* Append the specified null termianted C string to the sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscat(sds s, const char *t) {
-    return sdscatlen(s, t, strlen(t));
-}
-
-/* Append the specified sds 't' to the existing sds 's'.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatsds(sds s, const sds t) {
-    return sdscatlen(s, t, sdslen(t));
-}
-
-/* Destructively modify the sds string 's' to hold the specified binary
- * safe string pointed by 't' of length 'len' bytes. */
-sds sdscpylen(sds s, const char *t, size_t len) {
-    if (sdsalloc(s) < len) {
-        s = sdsMakeRoomFor(s,len-sdslen(s));
-        if (s == NULL) return NULL;
-    }
-    memcpy(s, t, len);
-    s[len] = '\0';
-    sdssetlen(s, len);
-    return s;
-}
-
-/* Like sdscpylen() but 't' must be a null-termined string so that the length
- * of the string is obtained with strlen(). */
-sds sdscpy(sds s, const char *t) {
-    return sdscpylen(s, t, strlen(t));
-}
-
-/* Helper for sdscatlonglong() doing the actual number -> string
- * conversion. 's' must point to a string with room for at least
- * SDS_LLSTR_SIZE bytes.
- *
- * The function returns the length of the null-terminated string
- * representation stored at 's'. */
-#define SDS_LLSTR_SIZE 21
-int sdsll2str(char *s, long long value) {
-    char *p, aux;
-    unsigned long long v;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    v = (value < 0) ? -value : value;
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-    if (value < 0) *p++ = '-';
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Identical sdsll2str(), but for unsigned long long type. */
-int sdsull2str(char *s, unsigned long long v) {
-    char *p, aux;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Create an sds string from a long long value. It is much faster than:
- *
- * sdscatprintf(sdsempty(),"%lld\n", value);
- */
-sds sdsfromlonglong(long long value) {
-    char buf[SDS_LLSTR_SIZE];
-    int len = sdsll2str(buf,value);
-
-    return sdsnewlen(buf,len);
-}
-
-/* Like sdscatprintf() but gets va_list instead of being variadic. */
-sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
-    va_list cpy;
-    char staticbuf[1024], *buf = staticbuf, *t;
-    size_t buflen = strlen(fmt)*2;
-
-    /* We try to start using a static buffer for speed.
-     * If not possible we revert to heap allocation. */
-    if (buflen > sizeof(staticbuf)) {
-        buf = (char*) malloc(buflen);
-        if (buf == NULL) return NULL;
-    } else {
-        buflen = sizeof(staticbuf);
-    }
-
-    /* Try with buffers two times bigger every time we fail to
-     * fit the string in the current buffer size. */
-    while(1) {
-        buf[buflen-2] = '\0';
-        va_copy(cpy,ap);
-        vsnprintf(buf, buflen, fmt, cpy);
-        va_end(cpy);
-        if (buf[buflen-2] != '\0') {
-            if (buf != staticbuf) free(buf);
-            buflen *= 2;
-            buf = (char*) malloc(buflen);
-            if (buf == NULL) return NULL;
-            continue;
-        }
-        break;
-    }
-
-    /* Finally concat the obtained string to the SDS string and return it. */
-    t = sdscat(s, buf);
-    if (buf != staticbuf) free(buf);
-    return t;
-}
-
-/* Append to the sds string 's' a string obtained using printf-alike format
- * specifier.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("Sum is: ");
- * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
- *
- * Often you need to create a string from scratch with the printf-alike
- * format. When this is the need, just use sdsempty() as the target string:
- *
- * s = sdscatprintf(sdsempty(), "... your format ...", args);
- */
-sds sdscatprintf(sds s, const char *fmt, ...) {
-    va_list ap;
-    char *t;
-    va_start(ap, fmt);
-    t = sdscatvprintf(s,fmt,ap);
-    va_end(ap);
-    return t;
-}
-
-/* This function is similar to sdscatprintf, but much faster as it does
- * not rely on sprintf() family functions implemented by the libc that
- * are often very slow. Moreover directly handling the sds string as
- * new data is concatenated provides a performance improvement.
- *
- * However this function only handles an incompatible subset of printf-alike
- * format specifiers:
- *
- * %s - C String
- * %S - SDS string
- * %i - signed int
- * %I - 64 bit signed integer (long long, int64_t)
- * %u - unsigned int
- * %U - 64 bit unsigned integer (unsigned long long, uint64_t)
- * %% - Verbatim "%" character.
- */
-sds sdscatfmt(sds s, char const *fmt, ...) {
-    size_t initlen = sdslen(s);
-    const char *f = fmt;
-    long i;
-    va_list ap;
-
-    va_start(ap,fmt);
-    f = fmt;    /* Next format specifier byte to process. */
-    i = initlen; /* Position of the next byte to write to dest str. */
-    while(*f) {
-        char next, *str;
-        size_t l;
-        long long num;
-        unsigned long long unum;
-
-        /* Make sure there is always space for at least 1 char. */
-        if (sdsavail(s)==0) {
-            s = sdsMakeRoomFor(s,1);
-        }
-
-        switch(*f) {
-        case '%':
-            next = *(f+1);
-            f++;
-            switch(next) {
-            case 's':
-            case 'S':
-                str = va_arg(ap,char*);
-                l = (next == 's') ? strlen(str) : sdslen(str);
-                if (sdsavail(s) < l) {
-                    s = sdsMakeRoomFor(s,l);
-                }
-                memcpy(s+i,str,l);
-                sdsinclen(s,l);
-                i += l;
-                break;
-            case 'i':
-            case 'I':
-                if (next == 'i')
-                    num = va_arg(ap,int);
-                else
-                    num = va_arg(ap,long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsll2str(buf,num);
-                    if (sdsavail(s) < l) {
-                        s = sdsMakeRoomFor(s,l);
-                    }
-                    memcpy(s+i,buf,l);
-                    sdsinclen(s,l);
-                    i += l;
-                }
-                break;
-            case 'u':
-            case 'U':
-                if (next == 'u')
-                    unum = va_arg(ap,unsigned int);
-                else
-                    unum = va_arg(ap,unsigned long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsull2str(buf,unum);
-                    if (sdsavail(s) < l) {
-                        s = sdsMakeRoomFor(s,l);
-                    }
-                    memcpy(s+i,buf,l);
-                    sdsinclen(s,l);
-                    i += l;
-                }
-                break;
-            default: /* Handle %% and generally %<unknown>. */
-                s[i++] = next;
-                sdsinclen(s,1);
-                break;
-            }
-            break;
-        default:
-            s[i++] = *f;
-            sdsinclen(s,1);
-            break;
-        }
-        f++;
-    }
-    va_end(ap);
-
-    /* Add null-term */
-    s[i] = '\0';
-    return s;
-}
-
-/* Remove the part of the string from left and from right composed just of
- * contiguous characters found in 'cset', that is a null terminted C string.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("AA...AA.a.aa.aHelloWorld     :::");
- * s = sdstrim(s,"Aa. :");
- * printf("%s\n", s);
- *
- * Output will be just "Hello World".
- */
-sds sdstrim(sds s, const char *cset) {
-    char *start, *end, *sp, *ep;
-    size_t len;
-
-    sp = start = s;
-    ep = end = s+sdslen(s)-1;
-    while(sp <= end && strchr(cset, *sp)) sp++;
-    while(ep > sp && strchr(cset, *ep)) ep--;
-    len = (sp > ep) ? 0 : ((ep-sp)+1);
-    if (s != sp) memmove(s, sp, len);
-    s[len] = '\0';
-    sdssetlen(s,len);
-    return s;
-}
-
-/* Turn the string into a smaller (or equal) string containing only the
- * substring specified by the 'start' and 'end' indexes.
- *
- * start and end can be negative, where -1 means the last character of the
- * string, -2 the penultimate character, and so forth.
- *
- * The interval is inclusive, so the start and end characters will be part
- * of the resulting string.
- *
- * The string is modified in-place.
- *
- * Example:
- *
- * s = sdsnew("Hello World");
- * sdsrange(s,1,-1); => "ello World"
- */
-void sdsrange(sds s, ssize_t start, ssize_t end) {
-    size_t newlen, len = sdslen(s);
-
-    if (len == 0) return;
-    if (start < 0) {
-        start = len+start;
-        if (start < 0) start = 0;
-    }
-    if (end < 0) {
-        end = len+end;
-        if (end < 0) end = 0;
-    }
-    newlen = (start > end) ? 0 : (end-start)+1;
-    if (newlen != 0) {
-        if (start >= (ssize_t)len) {
-            newlen = 0;
-        } else if (end >= (ssize_t)len) {
-            end = len-1;
-            newlen = (start > end) ? 0 : (end-start)+1;
-        }
-    } else {
-        start = 0;
-    }
-    if (start && newlen) memmove(s, s+start, newlen);
-    s[newlen] = 0;
-    sdssetlen(s,newlen);
-}
-
-/* Apply tolower() to every character of the sds string 's'. */
-void sdstolower(sds s) {
-    size_t len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = tolower(s[j]);
-}
-
-/* Apply toupper() to every character of the sds string 's'. */
-void sdstoupper(sds s) {
-    size_t len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = toupper(s[j]);
-}
-
-/* Compare two sds strings s1 and s2 with memcmp().
- *
- * Return value:
- *
- *     positive if s1 > s2.
- *     negative if s1 < s2.
- *     0 if s1 and s2 are exactly the same binary string.
- *
- * If two strings share exactly the same prefix, but one of the two has
- * additional characters, the longer string is considered to be greater than
- * the smaller one. */
-int sdscmp(const sds s1, const sds s2) {
-    size_t l1, l2, minlen;
-    int cmp;
-
-    l1 = sdslen(s1);
-    l2 = sdslen(s2);
-    minlen = (l1 < l2) ? l1 : l2;
-    cmp = memcmp(s1,s2,minlen);
-    if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
-    return cmp;
-}
-
-/* Split 's' with separator in 'sep'. An array
- * of sds strings is returned. *count will be set
- * by reference to the number of tokens returned.
- *
- * On out of memory, zero length string, zero length
- * separator, NULL is returned.
- *
- * Note that 'sep' is able to split a string using
- * a multi-character separator. For example
- * sdssplit("foo_-_bar","_-_"); will return two
- * elements "foo" and "bar".
- *
- * This version of the function is binary-safe but
- * requires length arguments. sdssplit() is just the
- * same function but for zero-terminated strings.
- */
-sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count) {
-    int elements = 0, slots = 5;
-    long start = 0, j;
-    sds *tokens;
-
-    if (seplen < 1 || len < 0) return NULL;
-
-    tokens = (sds*) malloc(sizeof(sds)*slots);
-    if (tokens == NULL) return NULL;
-
-    if (len == 0) {
-        *count = 0;
-        return tokens;
-    }
-    for (j = 0; j < (len-(seplen-1)); j++) {
-        /* make sure there is room for the next element and the final one */
-        if (slots < elements+2) {
-            sds *newtokens;
-
-            slots *= 2;
-            newtokens = (sds*) realloc(tokens,sizeof(sds)*slots);
-            if (newtokens == NULL) goto cleanup;
-            tokens = newtokens;
-        }
-        /* search the separator */
-        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
-            tokens[elements] = sdsnewlen(s+start,j-start);
-            if (tokens[elements] == NULL) goto cleanup;
-            elements++;
-            start = j+seplen;
-            j = j+seplen-1; /* skip the separator */
-        }
-    }
-    /* Add the final element. We are sure there is room in the tokens array. */
-    tokens[elements] = sdsnewlen(s+start,len-start);
-    if (tokens[elements] == NULL) goto cleanup;
-    elements++;
-    *count = elements;
-    return tokens;
-
-cleanup:
-    {
-        int i;
-        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
-        free(tokens);
-        *count = 0;
-        return NULL;
-    }
-}
-
-/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
-void sdsfreesplitres(sds *tokens, int count) {
-    if (!tokens) return;
-    while(count--)
-        sdsfree(tokens[count]);
-    free(tokens);
-}
-
-/* Append to the sds string "s" an escaped string representation where
- * all the non-printable characters (tested with isprint()) are turned into
- * escapes in the form "\n\r\a...." or "\x<hex-number>".
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatrepr(sds s, const char *p, size_t len) {
-    s = sdscatlen(s,"\"",1);
-    while(len--) {
-        switch(*p) {
-        case '\\':
-        case '"':
-            s = sdscatprintf(s,"\\%c",*p);
-            break;
-        case '\n': s = sdscatlen(s,"\\n",2); break;
-        case '\r': s = sdscatlen(s,"\\r",2); break;
-        case '\t': s = sdscatlen(s,"\\t",2); break;
-        case '\a': s = sdscatlen(s,"\\a",2); break;
-        case '\b': s = sdscatlen(s,"\\b",2); break;
-        default:
-            if (isprint(*p))
-                s = sdscatprintf(s,"%c",*p);
-            else
-                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
-            break;
-        }
-        p++;
-    }
-    return sdscatlen(s,"\"",1);
-}
-
-/* Helper function for sdssplitargs() that returns non zero if 'c'
- * is a valid hex digit. */
-int is_hex_digit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
-           (c >= 'A' && c <= 'F');
-}
-
-/* Helper function for sdssplitargs() that converts a hex digit into an
- * integer from 0 to 15 */
-int hex_digit_to_int(char c) {
-    switch(c) {
-    case '0': return 0;
-    case '1': return 1;
-    case '2': return 2;
-    case '3': return 3;
-    case '4': return 4;
-    case '5': return 5;
-    case '6': return 6;
-    case '7': return 7;
-    case '8': return 8;
-    case '9': return 9;
-    case 'a': case 'A': return 10;
-    case 'b': case 'B': return 11;
-    case 'c': case 'C': return 12;
-    case 'd': case 'D': return 13;
-    case 'e': case 'E': return 14;
-    case 'f': case 'F': return 15;
-    default: return 0;
-    }
-}
-
-/* Split a line into arguments, where every argument can be in the
- * following programming-language REPL-alike form:
- *
- * foo bar "newline are supported\n" and "\xff\x00otherstuff"
- *
- * The number of arguments is stored into *argc, and an array
- * of sds is returned.
- *
- * The caller should free the resulting array of sds strings with
- * sdsfreesplitres().
- *
- * Note that sdscatrepr() is able to convert back a string into
- * a quoted string in the same format sdssplitargs() is able to parse.
- *
- * The function returns the allocated tokens on success, even when the
- * input string is empty, or NULL if the input contains unbalanced
- * quotes or closed quotes followed by non space characters
- * as in: "foo"bar or "foo'
- */
-sds *sdssplitargs(const char *line, int *argc) {
-    const char *p = line;
-    char *current = NULL;
-    char **vector = NULL;
-
-    *argc = 0;
-    while(1) {
-        /* skip blanks */
-        while(*p && isspace(*p)) p++;
-        if (*p) {
-            /* get a token */
-            int inq=0;  /* set to 1 if we are in "quotes" */
-            int insq=0; /* set to 1 if we are in 'single quotes' */
-            int done=0;
-
-            if (current == NULL) current = sdsempty();
-            while(!done) {
-                if (inq) {
-                    if (*p == '\\' && *(p+1) == 'x' &&
-                                             is_hex_digit(*(p+2)) &&
-                                             is_hex_digit(*(p+3)))
-                    {
-                        unsigned char byte;
-
-                        byte = (hex_digit_to_int(*(p+2))*16)+
-                                hex_digit_to_int(*(p+3));
-                        current = sdscatlen(current,(char*)&byte,1);
-                        p += 3;
-                    } else if (*p == '\\' && *(p+1)) {
-                        char c;
-
-                        p++;
-                        switch(*p) {
-                        case 'n': c = '\n'; break;
-                        case 'r': c = '\r'; break;
-                        case 't': c = '\t'; break;
-                        case 'b': c = '\b'; break;
-                        case 'a': c = '\a'; break;
-                        default: c = *p; break;
-                        }
-                        current = sdscatlen(current,&c,1);
-                    } else if (*p == '"') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else if (insq) {
-                    if (*p == '\\' && *(p+1) == '\'') {
-                        p++;
-                        current = sdscatlen(current,"'",1);
-                    } else if (*p == '\'') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else {
-                    switch(*p) {
-                    case ' ':
-                    case '\n':
-                    case '\r':
-                    case '\t':
-                    case '\0':
-                        done=1;
-                        break;
-                    case '"':
-                        inq=1;
-                        break;
-                    case '\'':
-                        insq=1;
-                        break;
-                    default:
-                        current = sdscatlen(current,p,1);
-                        break;
-                    }
-                }
-                if (*p) p++;
-            }
-            /* add the token to the vector */
-            vector = (char**) realloc(vector,((*argc)+1)*sizeof(char*));
-            vector[*argc] = current;
-            (*argc)++;
-            current = NULL;
-        } else {
-            /* Even on empty input string return something not NULL. */
-            if (vector == NULL) vector = (char**) malloc(sizeof(void*));
-            return vector;
-        }
-    }
-
-err:
-    while((*argc)--)
-        sdsfree(vector[*argc]);
-    free(vector);
-    if (current) sdsfree(current);
-    *argc = 0;
-    return NULL;
-}
-
-/* Modify the string substituting all the occurrences of the set of
- * characters specified in the 'from' string to the corresponding character
- * in the 'to' array.
- *
- * For instance: sdsmapchars(mystring, "ho", "01", 2)
- * will have the effect of turning the string "hello" into "0ell1".
- *
- * The function returns the sds string pointer, that is always the same
- * as the input pointer since no resize is needed. */
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
-    size_t j, i, l = sdslen(s);
-
-    for (j = 0; j < l; j++) {
-        for (i = 0; i < setlen; i++) {
-            if (s[j] == from[i]) {
-                s[j] = to[i];
-                break;
-            }
-        }
-    }
-    return s;
-}
-
-/* Join an array of C strings using the specified separator (also a C string).
- * Returns the result as an sds string. */
-sds sdsjoin(char **argv, int argc, char *sep) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscat(join, argv[j]);
-        if (j != argc-1) join = sdscat(join,sep);
-    }
-    return join;
-}
-
-/* Like sdsjoin, but joins an array of SDS strings. */
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscatsds(join, argv[j]);
-        if (j != argc-1) join = sdscatlen(join,sep,seplen);
-    }
-    return join;
-}
-
-/* Wrappers to the allocators used by SDS. Note that SDS will actually
- * just use the macros defined into sdsalloc.h in order to avoid to pay
- * the overhead of function calls. Here we define these wrappers only for
- * the programs SDS is linked to, if they want to touch the SDS internals
- * even if they use a different allocator. */
-void *sdmalloc(size_t size) { return malloc(size); }
-void *sdrealloc(void *ptr, size_t size) { return realloc(ptr,size); }
-void sdfree(void *ptr) { free(ptr); }
-
-}
diff --git a/src/duckdb/third_party/hyperloglog/sds.hpp b/src/duckdb/third_party/hyperloglog/sds.hpp
deleted file mode 100644
index 69d6be7a3..000000000
--- a/src/duckdb/third_party/hyperloglog/sds.hpp
+++ /dev/null
@@ -1,284 +0,0 @@
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Oran Agra
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * 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.
- */
-
-#ifndef __SDS_H
-#define __SDS_H
-
-
-#ifdef _MSC_VER
-#define __attribute__(A)
-#define ssize_t int64_t
-#endif
-
-#define SDS_MAX_PREALLOC (1024*1024)
-
-#include <sys/types.h>
-#include <stdarg.h>
-#include <stdint.h>
-
-namespace duckdb_hll {
-
-
-typedef char *sds;
-
-/* Note: sdshdr5 is never used, we just access the flags byte directly.
- * However is here to document the layout of type 5 SDS strings. */
-struct __attribute__ ((__packed__)) sdshdr5 {
-    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr8 {
-    uint8_t len; /* used */
-    uint8_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr16 {
-    uint16_t len; /* used */
-    uint16_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr32 {
-    uint32_t len; /* used */
-    uint32_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr64 {
-    uint64_t len; /* used */
-    uint64_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-
-#define SDS_TYPE_5  0
-#define SDS_TYPE_8  1
-#define SDS_TYPE_16 2
-#define SDS_TYPE_32 3
-#define SDS_TYPE_64 4
-#define SDS_TYPE_MASK 7
-#define SDS_TYPE_BITS 3
-#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T)));
-#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
-#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
-
-static inline size_t sdslen(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return SDS_TYPE_5_LEN(flags);
-        case SDS_TYPE_8:
-            return SDS_HDR(8,s)->len;
-        case SDS_TYPE_16:
-            return SDS_HDR(16,s)->len;
-        case SDS_TYPE_32:
-            return SDS_HDR(32,s)->len;
-        case SDS_TYPE_64:
-            return SDS_HDR(64,s)->len;
-    }
-    return 0;
-}
-
-static inline size_t sdsavail(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5: {
-            return 0;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            return sh->alloc - sh->len;
-        }
-    }
-    return 0;
-}
-
-static inline void sdssetlen(sds s, size_t newlen) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            {
-                unsigned char *fp = ((unsigned char*)s)-1;
-                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
-            }
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len = newlen;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len = newlen;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len = newlen;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len = newlen;
-            break;
-    }
-}
-
-static inline void sdsinclen(sds s, size_t inc) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            {
-                unsigned char *fp = ((unsigned char*)s)-1;
-                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
-                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
-            }
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len += inc;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len += inc;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len += inc;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len += inc;
-            break;
-    }
-}
-
-/* sdsalloc() = sdsavail() + sdslen() */
-static inline size_t sdsalloc(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return SDS_TYPE_5_LEN(flags);
-        case SDS_TYPE_8:
-            return SDS_HDR(8,s)->alloc;
-        case SDS_TYPE_16:
-            return SDS_HDR(16,s)->alloc;
-        case SDS_TYPE_32:
-            return SDS_HDR(32,s)->alloc;
-        case SDS_TYPE_64:
-            return SDS_HDR(64,s)->alloc;
-    }
-    return 0;
-}
-
-static inline void sdssetalloc(sds s, size_t newlen) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            /* Nothing to do, this type has no total allocation info. */
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->alloc = newlen;
-            break;
-    }
-}
-
-sds sdsnewlen(const void *init, size_t initlen);
-sds sdsnew(const char *init);
-sds sdsempty(void);
-sds sdsdup(const sds s);
-void sdsfree(sds s);
-sds sdsgrowzero(sds s, size_t len);
-sds sdscatlen(sds s, const void *t, size_t len);
-sds sdscat(sds s, const char *t);
-sds sdscatsds(sds s, const sds t);
-sds sdscpylen(sds s, const char *t, size_t len);
-sds sdscpy(sds s, const char *t);
-
-sds sdscatvprintf(sds s, const char *fmt, va_list ap);
-#ifdef __GNUC__
-sds sdscatprintf(sds s, const char *fmt, ...)
-    __attribute__((format(printf, 2, 3)));
-#else
-sds sdscatprintf(sds s, const char *fmt, ...);
-#endif
-
-sds sdscatfmt(sds s, char const *fmt, ...);
-sds sdstrim(sds s, const char *cset);
-void sdsrange(sds s, ssize_t start, ssize_t end);
-void sdsupdatelen(sds s);
-void sdsclear(sds s);
-int sdscmp(const sds s1, const sds s2);
-sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
-void sdsfreesplitres(sds *tokens, int count);
-void sdstolower(sds s);
-void sdstoupper(sds s);
-sds sdsfromlonglong(long long value);
-sds sdscatrepr(sds s, const char *p, size_t len);
-sds *sdssplitargs(const char *line, int *argc);
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
-sds sdsjoin(char **argv, int argc, char *sep);
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
-
-/* Low level functions exposed to the user API */
-sds sdsMakeRoomFor(sds s, size_t addlen);
-void sdsIncrLen(sds s, ssize_t incr);
-sds sdsRemoveFreeSpace(sds s);
-size_t sdsAllocSize(sds s);
-void *sdsAllocPtr(sds s);
-
-/* Export the allocator used by SDS to the program using SDS.
- * Sometimes the program SDS is linked to, may use a different set of
- * allocators, but may want to allocate or free things that SDS will
- * respectively free or allocate. */
-void *sds_malloc(size_t size);
-void *sds_realloc(void *ptr, size_t size);
-void sds_free(void *ptr);
-
-#ifdef REDIS_TEST
-int sdsTest(int argc, char *argv[]);
-#endif
-}
-
-
-#endif
diff --git a/src/duckdb/third_party/jaro_winkler/details/common.hpp b/src/duckdb/third_party/jaro_winkler/details/common.hpp
deleted file mode 100644
index 6855ce60a..000000000
--- a/src/duckdb/third_party/jaro_winkler/details/common.hpp
+++ /dev/null
@@ -1,270 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/* Copyright © 2022 Max Bachmann */
-
-#pragma once
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-#include <type_traits>
-#include <vector>
-
-namespace duckdb_jaro_winkler {
-
-namespace common {
-
-/**
- * @defgroup Common Common
- * Common utilities shared among multiple functions
- * @{
- */
-
-/* taken from https://stackoverflow.com/a/30766365/11335032 */
-template <typename T>
-struct is_iterator {
-    static char test(...);
-
-    template <typename U, typename = typename std::iterator_traits<U>::difference_type,
-              typename = typename std::iterator_traits<U>::pointer,
-              typename = typename std::iterator_traits<U>::reference,
-              typename = typename std::iterator_traits<U>::value_type,
-              typename = typename std::iterator_traits<U>::iterator_category>
-    static long test(U&&);
-
-    constexpr static bool value = std::is_same<decltype(test(std::declval<T>())), long>::value;
-};
-
-constexpr double result_cutoff(double result, double score_cutoff)
-{
-    return (result >= score_cutoff) ? result : 0;
-}
-
-template <typename T, typename U>
-T ceildiv(T a, U divisor)
-{
-    return static_cast<T>(a / divisor) + static_cast<T>((a % divisor) != 0);
-}
-
-/**
- * Removes common prefix of two string views // todo
- */
-template <typename InputIt1, typename InputIt2>
-int64_t remove_common_prefix(InputIt1& first1, InputIt1 last1, InputIt2& first2, InputIt2 last2)
-{
-	// DuckDB passes a raw pointer, but this gives compile errors for std::
-	int64_t len1 = std::distance(first1, last1);
-	int64_t len2 = std::distance(first2, last2);
-	const int64_t max_comparisons = std::min<int64_t>(len1, len2);
-	int64_t prefix;
-	for (prefix = 0; prefix < max_comparisons; prefix++) {
-		if (first1[prefix] != first2[prefix]) {
-			break;
-		}
-	}
-
-//    int64_t prefix = static_cast<int64_t>(
-//        std::distance(first1, std::mismatch(first1, last1, first2, last2).first));
-    first1 += prefix;
-    first2 += prefix;
-    return prefix;
-}
-
-struct BitvectorHashmap {
-    struct MapElem {
-        uint64_t key = 0;
-        uint64_t value = 0;
-    };
-
-    BitvectorHashmap() : m_map()
-    {}
-
-    template <typename CharT>
-    void insert(CharT key, int64_t pos)
-    {
-        insert_mask(key, 1ull << pos);
-    }
-
-    template <typename CharT>
-    void insert_mask(CharT key, uint64_t mask)
-    {
-        uint64_t i = lookup(static_cast<uint64_t>(key));
-        m_map[i].key = static_cast<uint64_t>(key);
-        m_map[i].value |= mask;
-    }
-
-    template <typename CharT>
-    uint64_t get(CharT key) const
-    {
-        return m_map[lookup(static_cast<uint64_t>(key))].value;
-    }
-
-private:
-    /**
-     * lookup key inside the hashmap using a similar collision resolution
-     * strategy to CPython and Ruby
-     */
-    uint64_t lookup(uint64_t key) const
-    {
-        uint64_t i = key % 128;
-
-        if (!m_map[i].value || m_map[i].key == key) {
-            return i;
-        }
-
-        uint64_t perturb = key;
-        while (true) {
-            i = ((i * 5) + perturb + 1) % 128;
-            if (!m_map[i].value || m_map[i].key == key) {
-                return i;
-            }
-
-            perturb >>= 5;
-        }
-    }
-
-    std::array<MapElem, 128> m_map;
-};
-
-struct PatternMatchVector {
-    struct MapElem {
-        uint64_t key = 0;
-        uint64_t value = 0;
-    };
-
-    PatternMatchVector() : m_map(), m_extendedAscii()
-    {}
-
-    template <typename InputIt1>
-    PatternMatchVector(InputIt1 first, InputIt1 last) : m_map(), m_extendedAscii()
-    {
-        insert(first, last);
-    }
-
-    template <typename InputIt1>
-    void insert(InputIt1 first, InputIt1 last)
-    {
-        uint64_t mask = 1;
-        for (int64_t i = 0; i < std::distance(first, last); ++i) {
-            auto key = first[i];
-            if (key >= 0 && key <= 255) {
-                m_extendedAscii[static_cast<size_t>(key)] |= mask;
-            }
-            else {
-                m_map.insert_mask(key, mask);
-            }
-            mask <<= 1;
-        }
-    }
-
-    template <typename CharT>
-    void insert(CharT key, int64_t pos)
-    {
-        uint64_t mask = 1ull << pos;
-        if (key >= 0 && key <= 255) {
-            m_extendedAscii[key] |= mask;
-        }
-        else {
-            m_map.insert_mask(key, mask);
-        }
-    }
-
-    template <typename CharT>
-    uint64_t get(CharT key) const
-    {
-        if (key >= 0 && key <= 255) {
-            return m_extendedAscii[static_cast<size_t>(key)];
-        }
-        else {
-            return m_map.get(key);
-        }
-    }
-
-    /**
-     * combat func for BlockPatternMatchVector
-     */
-    template <typename CharT>
-    uint64_t get(int64_t block, CharT key) const
-    {
-        (void)block;
-        assert(block == 0);
-        return get(key);
-    }
-
-private:
-    BitvectorHashmap m_map;
-    std::array<uint64_t, 256> m_extendedAscii;
-};
-
-struct BlockPatternMatchVector {
-    BlockPatternMatchVector() : m_block_count(0)
-    {}
-
-    template <typename InputIt1>
-    BlockPatternMatchVector(InputIt1 first, InputIt1 last) : m_block_count(0)
-    {
-        insert(first, last);
-    }
-
-    template <typename CharT>
-    void insert(int64_t block, CharT key, int pos)
-    {
-        uint64_t mask = 1ull << pos;
-
-        assert(block < m_block_count);
-        if (key >= 0 && key <= 255) {
-            m_extendedAscii[static_cast<size_t>(key * m_block_count + block)] |= mask;
-        }
-        else {
-            m_map[static_cast<size_t>(block)].insert_mask(key, mask);
-        }
-    }
-
-    template <typename InputIt1>
-    void insert(InputIt1 first, InputIt1 last)
-    {
-        int64_t len = std::distance(first, last);
-        m_block_count = ceildiv(len, 64);
-        m_map.resize(static_cast<size_t>(m_block_count));
-        m_extendedAscii.resize(static_cast<size_t>(m_block_count * 256));
-
-        for (int64_t i = 0; i < len; ++i) {
-            int64_t block = i / 64;
-            int64_t pos = i % 64;
-            insert(block, first[i], static_cast<int>(pos));
-        }
-    }
-
-    /**
-     * combat func for PatternMatchVector
-     */
-    template <typename CharT>
-    uint64_t get(CharT key) const
-    {
-        return get(0, key);
-    }
-
-    template <typename CharT>
-    uint64_t get(int64_t block, CharT key) const
-    {
-        assert(block < m_block_count);
-        if (key >= 0 && key <= 255) {
-            return m_extendedAscii[static_cast<size_t>(key * m_block_count + block)];
-        }
-        else {
-            return m_map[static_cast<size_t>(block)].get(key);
-        }
-    }
-
-private:
-    std::vector<BitvectorHashmap> m_map;
-    std::vector<uint64_t> m_extendedAscii;
-    int64_t m_block_count;
-};
-
-/**@}*/
-
-} // namespace common
-} // namespace duckdb_jaro_winkler
diff --git a/src/duckdb/third_party/jaro_winkler/details/intrinsics.hpp b/src/duckdb/third_party/jaro_winkler/details/intrinsics.hpp
deleted file mode 100644
index 45f07c407..000000000
--- a/src/duckdb/third_party/jaro_winkler/details/intrinsics.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/* Copyright © 2022 Max Bachmann */
-
-#pragma once
-
-#include <cstdint>
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#    include <intrin.h>
-#endif
-
-namespace duckdb_jaro_winkler {
-namespace intrinsics {
-
-template <typename T>
-T bit_mask_lsb(int n)
-{
-    T mask = static_cast<T>(-1);
-    if (n < static_cast<int>(sizeof(T) * 8)) {
-        mask += static_cast<T>(1) << n;
-    }
-    return mask;
-}
-
-template <typename T>
-bool bittest(T a, int bit)
-{
-    return (a >> bit) & 1;
-}
-
-static inline int64_t popcount(uint64_t x)
-{
-    const uint64_t m1 = 0x5555555555555555;
-    const uint64_t m2 = 0x3333333333333333;
-    const uint64_t m4 = 0x0f0f0f0f0f0f0f0f;
-    const uint64_t h01 = 0x0101010101010101;
-
-    x -= (x >> 1) & m1;
-    x = (x & m2) + ((x >> 2) & m2);
-    x = (x + (x >> 4)) & m4;
-    return static_cast<int64_t>((x * h01) >> 56);
-}
-
-/**
- * Extract the lowest set bit from a. If no bits are set in a returns 0.
- */
-template <typename T>
-T blsi(T a)
-{
-#if _MSC_VER && !defined(__clang__)
-#  pragma warning(push)
-/* unary minus operator applied to unsigned type, result still unsigned */
-#  pragma warning(disable: 4146)
-#endif
-    return a & -a;
-#if _MSC_VER && !defined(__clang__)
-#  pragma warning(pop)
-#endif
-}
-
-/**
- * Clear the lowest set bit in a.
- */
-template <typename T>
-T blsr(T x)
-{
-    return x & (x - 1);
-}
-
-#if defined(_MSC_VER) && !defined(__clang__)
-static inline int tzcnt(uint32_t x)
-{
-    unsigned long trailing_zero = 0;
-    _BitScanForward(&trailing_zero, x);
-    return trailing_zero;
-}
-
-#    if defined(_M_ARM) || defined(_M_X64)
-static inline int tzcnt(uint64_t x)
-{
-    unsigned long trailing_zero = 0;
-    _BitScanForward64(&trailing_zero, x);
-    return trailing_zero;
-}
-#    else
-static inline int tzcnt(uint64_t x)
-{
-    uint32_t msh = (uint32_t)(x >> 32);
-    uint32_t lsh = (uint32_t)(x & 0xFFFFFFFF);
-    if (lsh != 0) {
-        return tzcnt(lsh);
-    }
-    return 32 + tzcnt(msh);
-}
-#    endif
-
-#else /*  gcc / clang */
-//static inline int tzcnt(uint32_t x)
-//{
-//    return __builtin_ctz(x);
-//}
-
-static inline int tzcnt(uint64_t x)
-{
-    return __builtin_ctzll(x);
-}
-#endif
-
-} // namespace intrinsics
-} // namespace duckdb_jaro_winkler
diff --git a/src/duckdb/third_party/jaro_winkler/details/jaro_impl.hpp b/src/duckdb/third_party/jaro_winkler/details/jaro_impl.hpp
deleted file mode 100644
index 47e6fa506..000000000
--- a/src/duckdb/third_party/jaro_winkler/details/jaro_impl.hpp
+++ /dev/null
@@ -1,509 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/* Copyright © 2022 Max Bachmann */
-
-#pragma once
-
-#include "common.hpp"
-#include "intrinsics.hpp"
-
-namespace duckdb_jaro_winkler {
-namespace detail {
-
-struct FlaggedCharsWord {
-    uint64_t P_flag;
-    uint64_t T_flag;
-};
-
-struct FlaggedCharsMultiword {
-    std::vector<uint64_t> P_flag;
-    std::vector<uint64_t> T_flag;
-};
-
-struct SearchBoundMask {
-    int64_t words = 0;
-    int64_t empty_words = 0;
-    uint64_t last_mask = 0;
-    uint64_t first_mask = 0;
-};
-
-struct TextPosition {
-    TextPosition(int64_t Word_, int64_t WordPos_) : Word(Word_), WordPos(WordPos_)
-    {}
-    int64_t Word;
-    int64_t WordPos;
-};
-
-static inline double jaro_calculate_similarity(int64_t P_len, int64_t T_len, int64_t CommonChars,
-                                               int64_t Transpositions)
-{
-    Transpositions /= 2;
-    double Sim = 0;
-    Sim += static_cast<double>(CommonChars) / static_cast<double>(P_len);
-    Sim += static_cast<double>(CommonChars) / static_cast<double>(T_len);
-    Sim += (static_cast<double>(CommonChars) - static_cast<double>(Transpositions)) / static_cast<double>(CommonChars);
-    return Sim / 3.0;
-}
-
-/**
- * @brief filter matches below score_cutoff based on string lengths
- */
-static inline bool jaro_length_filter(int64_t P_len, int64_t T_len, double score_cutoff)
-{
-    if (!T_len || !P_len) return false;
-
-    double min_len = static_cast<double>(std::min(P_len, T_len));
-    double Sim = min_len / static_cast<double>(P_len) + min_len / static_cast<double>(T_len) + 1.0;
-    Sim /= 3.0;
-    return Sim >= score_cutoff;
-}
-
-/**
- * @brief filter matches below score_cutoff based on string lengths and common characters
- */
-static inline bool jaro_common_char_filter(int64_t P_len, int64_t T_len, int64_t CommonChars,
-                                           double score_cutoff)
-{
-    if (!CommonChars) return false;
-
-    double Sim = 0;
-    Sim += static_cast<double>(CommonChars) / static_cast<double>(P_len);
-    Sim += static_cast<double>(CommonChars) / static_cast<double>(T_len);
-    Sim += 1.0;
-    Sim /= 3.0;
-    return Sim >= score_cutoff;
-}
-
-static inline int64_t count_common_chars(const FlaggedCharsWord& flagged)
-{
-    return intrinsics::popcount(flagged.P_flag);
-}
-
-static inline int64_t count_common_chars(const FlaggedCharsMultiword& flagged)
-{
-    int64_t CommonChars = 0;
-    if (flagged.P_flag.size() < flagged.T_flag.size()) {
-        for (uint64_t flag : flagged.P_flag) {
-            CommonChars += intrinsics::popcount(flag);
-        }
-    }
-    else {
-        for (uint64_t flag : flagged.T_flag) {
-            CommonChars += intrinsics::popcount(flag);
-        }
-    }
-    return CommonChars;
-}
-
-template <typename PM_Vec, typename InputIt1, typename InputIt2>
-static inline FlaggedCharsWord
-flag_similar_characters_word(const PM_Vec& PM, InputIt1 P_first,
-                             InputIt1 P_last, InputIt2 T_first, InputIt2 T_last, int Bound)
-{
-    using namespace intrinsics;
-    int64_t P_len = std::distance(P_first, P_last);
-    (void)P_len;
-    int64_t T_len = std::distance(T_first, T_last);
-    assert(P_len <= 64);
-    assert(T_len <= 64);
-    assert(Bound > P_len || P_len - Bound <= T_len);
-
-    FlaggedCharsWord flagged = {0, 0};
-
-    uint64_t BoundMask = bit_mask_lsb<uint64_t>(Bound + 1);
-
-    int64_t j = 0;
-    for (; j < std::min(static_cast<int64_t>(Bound), T_len); ++j) {
-        uint64_t PM_j = PM.get(T_first[j]) & BoundMask & (~flagged.P_flag);
-
-        flagged.P_flag |= blsi(PM_j);
-        flagged.T_flag |= static_cast<uint64_t>(PM_j != 0) << j;
-
-        BoundMask = (BoundMask << 1) | 1;
-    }
-
-    for (; j < T_len; ++j) {
-        uint64_t PM_j = PM.get(T_first[j]) & BoundMask & (~flagged.P_flag);
-
-        flagged.P_flag |= blsi(PM_j);
-        flagged.T_flag |= static_cast<uint64_t>(PM_j != 0) << j;
-
-        BoundMask <<= 1;
-    }
-
-    return flagged;
-}
-
-template <typename CharT>
-static inline void flag_similar_characters_step(const common::BlockPatternMatchVector& PM,
-                                                CharT T_j, FlaggedCharsMultiword& flagged,
-                                                int64_t j, SearchBoundMask BoundMask)
-{
-    using namespace intrinsics;
-
-    int64_t j_word = j / 64;
-    int64_t j_pos = j % 64;
-    int64_t word = BoundMask.empty_words;
-    int64_t last_word = word + BoundMask.words;
-
-    if (BoundMask.words == 1) {
-        uint64_t PM_j = PM.get(word, T_j) & BoundMask.last_mask & BoundMask.first_mask &
-                        (~flagged.P_flag[static_cast<size_t>(word)]);
-
-        flagged.P_flag[static_cast<size_t>(word)] |= blsi(PM_j);
-        flagged.T_flag[static_cast<size_t>(j_word)] |= static_cast<uint64_t>(PM_j != 0) << j_pos;
-        return;
-    }
-
-    if (BoundMask.first_mask) {
-        uint64_t PM_j = PM.get(word, T_j) & BoundMask.first_mask & (~flagged.P_flag[static_cast<size_t>(word)]);
-
-        if (PM_j) {
-            flagged.P_flag[static_cast<size_t>(word)] |= blsi(PM_j);
-            flagged.T_flag[static_cast<size_t>(j_word)] |= 1ull << j_pos;
-            return;
-        }
-        word++;
-    }
-
-    for (; word < last_word - 1; ++word) {
-        uint64_t PM_j = PM.get(word, T_j) & (~flagged.P_flag[static_cast<size_t>(word)]);
-
-        if (PM_j) {
-            flagged.P_flag[static_cast<size_t>(word)] |= blsi(PM_j);
-            flagged.T_flag[static_cast<size_t>(j_word)] |= 1ull << j_pos;
-            return;
-        }
-    }
-
-    if (BoundMask.last_mask) {
-        uint64_t PM_j = PM.get(word, T_j) & BoundMask.last_mask & (~flagged.P_flag[static_cast<size_t>(word)]);
-
-        flagged.P_flag[static_cast<size_t>(word)] |= blsi(PM_j);
-        flagged.T_flag[static_cast<size_t>(j_word)] |= static_cast<uint64_t>(PM_j != 0) << j_pos;
-    }
-}
-
-template <typename InputIt1, typename InputIt2>
-static inline FlaggedCharsMultiword
-flag_similar_characters_block(const common::BlockPatternMatchVector& PM, InputIt1 P_first,
-                              InputIt1 P_last, InputIt2 T_first, InputIt2 T_last, int64_t Bound)
-{
-    using namespace intrinsics;
-    int64_t P_len = std::distance(P_first, P_last);
-    int64_t T_len = std::distance(T_first, T_last);
-    assert(P_len > 64 || T_len > 64);
-    assert(Bound > P_len || P_len - Bound <= T_len);
-    assert(Bound >= 31);
-
-    int64_t TextWords = common::ceildiv(T_len, 64);
-    int64_t PatternWords = common::ceildiv(P_len, 64);
-
-    FlaggedCharsMultiword flagged;
-    flagged.T_flag.resize(static_cast<size_t>(TextWords));
-    flagged.P_flag.resize(static_cast<size_t>(PatternWords));
-
-    SearchBoundMask BoundMask;
-    int64_t start_range = std::min(Bound + 1, P_len);
-    BoundMask.words = 1 + start_range / 64;
-    BoundMask.empty_words = 0;
-    BoundMask.last_mask = (1ull << (start_range % 64)) - 1;
-    BoundMask.first_mask = ~UINT64_C(0);
-
-    for (int64_t j = 0; j < T_len; ++j) {
-        flag_similar_characters_step(PM, T_first[j], flagged, j, BoundMask);
-
-        if (j + Bound + 1 < P_len) {
-            BoundMask.last_mask = (BoundMask.last_mask << 1) | 1;
-            if (j + Bound + 2 < P_len && BoundMask.last_mask == ~UINT64_C(0)) {
-                BoundMask.last_mask = 0;
-                BoundMask.words++;
-            }
-        }
-
-        if (j >= Bound) {
-            BoundMask.first_mask <<= 1;
-            if (BoundMask.first_mask == 0) {
-                BoundMask.first_mask = ~UINT64_C(0);
-                BoundMask.words--;
-                BoundMask.empty_words++;
-            }
-        }
-    }
-
-    return flagged;
-}
-
-template <typename PM_Vec, typename InputIt1>
-static inline int64_t count_transpositions_word(const PM_Vec& PM,
-                                                InputIt1 T_first, InputIt1,
-                                                const FlaggedCharsWord& flagged)
-{
-    using namespace intrinsics;
-    uint64_t P_flag = flagged.P_flag;
-    uint64_t T_flag = flagged.T_flag;
-    int64_t Transpositions = 0;
-    while (T_flag) {
-        uint64_t PatternFlagMask = blsi(P_flag);
-
-        Transpositions += !(PM.get(T_first[tzcnt(T_flag)]) & PatternFlagMask);
-
-        T_flag = blsr(T_flag);
-        P_flag ^= PatternFlagMask;
-    }
-
-    return Transpositions;
-}
-
-template <typename InputIt1>
-static inline int64_t
-count_transpositions_block(const common::BlockPatternMatchVector& PM, InputIt1 T_first, InputIt1,
-                           const FlaggedCharsMultiword& flagged, int64_t FlaggedChars)
-{
-    using namespace intrinsics;
-    int64_t TextWord = 0;
-    int64_t PatternWord = 0;
-    uint64_t T_flag = flagged.T_flag[static_cast<size_t>(TextWord)];
-    uint64_t P_flag = flagged.P_flag[static_cast<size_t>(PatternWord)];
-
-    int64_t Transpositions = 0;
-    while (FlaggedChars) {
-        while (!T_flag) {
-            TextWord++;
-            T_first += 64;
-            T_flag = flagged.T_flag[static_cast<size_t>(TextWord)];
-        }
-
-        while (T_flag) {
-            while (!P_flag) {
-                PatternWord++;
-                P_flag = flagged.P_flag[static_cast<size_t>(PatternWord)];
-            }
-
-            uint64_t PatternFlagMask = blsi(P_flag);
-
-            Transpositions += !(PM.get(PatternWord, T_first[tzcnt(T_flag)]) & PatternFlagMask);
-
-            T_flag = blsr(T_flag);
-            P_flag ^= PatternFlagMask;
-
-            FlaggedChars--;
-        }
-    }
-
-    return Transpositions;
-}
-
-/**
- * @brief find bounds and skip out of bound parts of the sequences
- *
- */
-template <typename InputIt1, typename InputIt2>
-int64_t jaro_bounds(InputIt1 P_first, InputIt1& P_last, InputIt2 T_first, InputIt2& T_last)
-{
-    int64_t P_len = std::distance(P_first, P_last);
-    int64_t T_len = std::distance(T_first, T_last);
-
-    /* since jaro uses a sliding window some parts of T/P might never be in
-     * range an can be removed ahead of time
-     */
-    int64_t Bound = 0;
-    if (T_len > P_len) {
-        Bound = T_len / 2 - 1;
-        if (T_len > P_len + Bound) {
-            T_last = T_first + P_len + Bound;
-        }
-    }
-    else {
-        Bound = P_len / 2 - 1;
-        if (P_len > T_len + Bound) {
-            P_last = P_first + T_len + Bound;
-        }
-    }
-    return Bound;
-}
-
-template <typename InputIt1, typename InputIt2>
-double jaro_similarity(InputIt1 P_first, InputIt1 P_last, InputIt2 T_first, InputIt2 T_last,
-                       double score_cutoff)
-{
-    int64_t P_len = std::distance(P_first, P_last);
-    int64_t T_len = std::distance(T_first, T_last);
-
-    /* filter out based on the length difference between the two strings */
-    if (!jaro_length_filter(P_len, T_len, score_cutoff)) {
-        return 0.0;
-    }
-
-    if (P_len == 1 && T_len == 1) {
-        return static_cast<double>(P_first[0] == T_first[0]);
-    }
-
-    int64_t Bound = jaro_bounds(P_first, P_last, T_first, T_last);
-
-    /* common prefix never includes Transpositions */
-    int64_t CommonChars = common::remove_common_prefix(P_first, P_last, T_first, T_last);
-    int64_t Transpositions = 0;
-    int64_t P_view_len = std::distance(P_first, P_last);
-    int64_t T_view_len = std::distance(T_first, T_last);
-
-    if (!P_view_len || !T_view_len) {
-        /* already has correct number of common chars and transpositions */
-    }
-    else if (P_view_len <= 64 && T_view_len <= 64) {
-        common::PatternMatchVector PM(P_first, P_last);
-        auto flagged = flag_similar_characters_word(PM, P_first, P_last, T_first, T_last, static_cast<int>(Bound));
-        CommonChars += count_common_chars(flagged);
-
-        if (!jaro_common_char_filter(P_len, T_len, CommonChars, score_cutoff)) {
-            return 0.0;
-        }
-
-        Transpositions = count_transpositions_word(PM, T_first, T_last, flagged);
-    }
-    else {
-        common::BlockPatternMatchVector PM(P_first, P_last);
-        auto flagged = flag_similar_characters_block(PM, P_first, P_last, T_first, T_last, Bound);
-        int64_t FlaggedChars = count_common_chars(flagged);
-        CommonChars += FlaggedChars;
-
-        if (!jaro_common_char_filter(P_len, T_len, CommonChars, score_cutoff)) {
-            return 0.0;
-        }
-
-        Transpositions = count_transpositions_block(PM, T_first, T_last, flagged, FlaggedChars);
-    }
-
-    double Sim = jaro_calculate_similarity(P_len, T_len, CommonChars, Transpositions);
-    return common::result_cutoff(Sim, score_cutoff);
-}
-
-template <typename InputIt1, typename InputIt2>
-double jaro_similarity(const common::BlockPatternMatchVector& PM, InputIt1 P_first, InputIt1 P_last,
-                       InputIt2 T_first, InputIt2 T_last, double score_cutoff)
-{
-    int64_t P_len = std::distance(P_first, P_last);
-    int64_t T_len = std::distance(T_first, T_last);
-
-    /* filter out based on the length difference between the two strings */
-    if (!jaro_length_filter(P_len, T_len, score_cutoff)) {
-        return 0.0;
-    }
-
-    if (P_len == 1 && T_len == 1) {
-        return static_cast<double>(P_first[0] == T_first[0]);
-    }
-
-    int64_t Bound = jaro_bounds(P_first, P_last, T_first, T_last);
-
-    /* common prefix never includes Transpositions */
-    int64_t CommonChars = 0;
-    int64_t Transpositions = 0;
-    int64_t P_view_len = std::distance(P_first, P_last);
-    int64_t T_view_len = std::distance(T_first, T_last);
-
-    if (!P_view_len || !T_view_len) {
-        /* already has correct number of common chars and transpositions */
-    }
-    else if (P_view_len <= 64 && T_view_len <= 64) {
-        auto flagged = flag_similar_characters_word(PM, P_first, P_last, T_first, T_last, static_cast<int>(Bound));
-        CommonChars += count_common_chars(flagged);
-
-        if (!jaro_common_char_filter(P_len, T_len, CommonChars, score_cutoff)) {
-            return 0.0;
-        }
-
-        Transpositions = count_transpositions_word(PM, T_first, T_last, flagged);
-    }
-    else {
-        auto flagged = flag_similar_characters_block(PM, P_first, P_last, T_first, T_last, Bound);
-        int64_t FlaggedChars = count_common_chars(flagged);
-        CommonChars += FlaggedChars;
-
-        if (!jaro_common_char_filter(P_len, T_len, CommonChars, score_cutoff)) {
-            return 0.0;
-        }
-
-        Transpositions = count_transpositions_block(PM, T_first, T_last, flagged, FlaggedChars);
-    }
-
-    double Sim = jaro_calculate_similarity(P_len, T_len, CommonChars, Transpositions);
-    return common::result_cutoff(Sim, score_cutoff);
-}
-
-template <typename InputIt1, typename InputIt2>
-double jaro_winkler_similarity(InputIt1 P_first, InputIt1 P_last, InputIt2 T_first, InputIt2 T_last,
-                               double prefix_weight, double score_cutoff)
-{
-    int64_t P_len = std::distance(P_first, P_last);
-    int64_t T_len = std::distance(T_first, T_last);
-    int64_t min_len = std::min(P_len, T_len);
-    int64_t prefix = 0;
-    int64_t max_prefix = std::min<int64_t>(min_len, 4);
-
-    for (; prefix < max_prefix; ++prefix) {
-        if (T_first[prefix] != P_first[prefix]) {
-            break;
-        }
-    }
-
-    double jaro_score_cutoff = score_cutoff;
-    if (jaro_score_cutoff > 0.7) {
-        double prefix_sim = prefix * prefix_weight;
-
-        if (prefix_sim >= 1.0) {
-            jaro_score_cutoff = 0.7;
-        }
-        else {
-            jaro_score_cutoff =
-                std::max(0.7, (prefix_sim - jaro_score_cutoff) / (prefix_sim - 1.0));
-        }
-    }
-
-    double Sim = jaro_similarity(P_first, P_last, T_first, T_last, jaro_score_cutoff);
-    if (Sim > 0.7) {
-        Sim += prefix * prefix_weight * (1.0 - Sim);
-    }
-
-    return common::result_cutoff(Sim, score_cutoff);
-}
-
-template <typename InputIt1, typename InputIt2>
-double jaro_winkler_similarity(const common::BlockPatternMatchVector& PM, InputIt1 P_first,
-                               InputIt1 P_last, InputIt2 T_first, InputIt2 T_last,
-                               double prefix_weight, double score_cutoff)
-{
-    int64_t P_len = std::distance(P_first, P_last);
-    int64_t T_len = std::distance(T_first, T_last);
-    int64_t min_len = std::min(P_len, T_len);
-    int64_t prefix = 0;
-    int64_t max_prefix = std::min<int64_t>(min_len, 4);
-
-    for (; prefix < max_prefix; ++prefix) {
-        if (T_first[prefix] != P_first[prefix]) {
-            break;
-        }
-    }
-
-    double jaro_score_cutoff = score_cutoff;
-    if (jaro_score_cutoff > 0.7) {
-        double prefix_sim = prefix * prefix_weight;
-
-        if (prefix_sim >= 1.0) {
-            jaro_score_cutoff = 0.7;
-        }
-        else {
-            jaro_score_cutoff =
-                std::max(0.7, (prefix_sim - jaro_score_cutoff) / (prefix_sim - 1.0));
-        }
-    }
-
-    double Sim = jaro_similarity(PM, P_first, P_last, T_first, T_last, jaro_score_cutoff);
-    if (Sim > 0.7) {
-        Sim += prefix * prefix_weight * (1.0 - Sim);
-    }
-
-    return common::result_cutoff(Sim, score_cutoff);
-}
-
-} // namespace detail
-} // namespace duckdb_jaro_winkler
diff --git a/src/duckdb/third_party/jaro_winkler/jaro_winkler.hpp b/src/duckdb/third_party/jaro_winkler/jaro_winkler.hpp
deleted file mode 100644
index 5d376c0fa..000000000
--- a/src/duckdb/third_party/jaro_winkler/jaro_winkler.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/* Copyright © 2022 Max Bachmann */
-
-#pragma once
-#include "details/common.hpp"
-#include "details/jaro_impl.hpp"
-
-#include <stdexcept>
-
-namespace duckdb_jaro_winkler {
-
-/**
- * @defgroup jaro_winkler jaro_winkler
- * @{
- */
-
-/**
- * @brief Calculates the jaro winkler similarity
- *
- * @tparam Sentence1 This is a string that can be converted to
- * basic_string_view<char_type>
- * @tparam Sentence2 This is a string that can be converted to
- * basic_string_view<char_type>
- *
- * @param s1
- *   string to compare with s2 (for type info check Template parameters above)
- * @param s2
- *   string to compare with s1 (for type info check Template parameters above)
- * @param prefix_weight
- *   Weight used for the common prefix of the two strings.
- *   Has to be between 0 and 0.25. Default is 0.1.
- * @param score_cutoff
- *   Optional argument for a score threshold as a float between 0 and 100.
- *   For similarity < score_cutoff 0 is returned instead. Default is 0,
- *   which deactivates this behaviour.
- *
- * @return jaro winkler similarity between s1 and s2
- *   as a float between 0 and 100
- */
-template <typename InputIt1, typename InputIt2>
-typename std::enable_if<
-    common::is_iterator<InputIt1>::value && common::is_iterator<InputIt2>::value, double>::type
-jaro_winkler_similarity(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
-                        double prefix_weight = 0.1, double score_cutoff = 0.0)
-{
-    if (prefix_weight < 0.0 || prefix_weight > 0.25) {
-        throw std::invalid_argument("prefix_weight has to be between 0.0 and 0.25");
-    }
-
-    return detail::jaro_winkler_similarity(first1, last1, first2, last2, prefix_weight,
-                                           score_cutoff);
-}
-
-template <typename S1, typename S2>
-double jaro_winkler_similarity(const S1& s1, const S2& s2, double prefix_weight = 0.1,
-                               double score_cutoff = 0.0)
-{
-    return jaro_winkler_similarity(std::begin(s1), std::end(s1), std::begin(s2), std::end(s2),
-                                   prefix_weight, score_cutoff);
-}
-
-template <typename CharT1>
-struct CachedJaroWinklerSimilarity {
-    template <typename InputIt1>
-    CachedJaroWinklerSimilarity(InputIt1 first1, InputIt1 last1, double prefix_weight_ = 0.1)
-        : s1(first1, last1), PM(first1, last1), prefix_weight(prefix_weight_)
-    {
-        if (prefix_weight < 0.0 || prefix_weight > 0.25) {
-            throw std::invalid_argument("prefix_weight has to be between 0.0 and 0.25");
-        }
-    }
-
-    template <typename S1>
-    CachedJaroWinklerSimilarity(const S1& s1_, double prefix_weight_ = 0.1)
-        : CachedJaroWinklerSimilarity(std::begin(s1_), std::end(s1_), prefix_weight_)
-    {}
-
-    template <typename InputIt2>
-    double similarity(InputIt2 first2, InputIt2 last2, double score_cutoff = 0) const
-    {
-        return detail::jaro_winkler_similarity(PM, std::begin(s1), std::end(s1), first2, last2,
-                                               prefix_weight, score_cutoff);
-    }
-
-    template <typename S2>
-    double similarity(const S2& s2, double score_cutoff = 0) const
-    {
-        return similarity(std::begin(s2), std::end(s2), score_cutoff);
-    }
-
-    template <typename InputIt2>
-    double normalized_similarity(InputIt2 first2, InputIt2 last2, double score_cutoff = 0) const
-    {
-        return similarity(first2, last2, score_cutoff);
-    }
-
-    template <typename S2>
-    double normalized_similarity(const S2& s2, double score_cutoff = 0) const
-    {
-        return similarity(s2, score_cutoff);
-    }
-
-private:
-    std::basic_string<CharT1> s1;
-    common::BlockPatternMatchVector PM;
-
-    double prefix_weight;
-};
-
-/**
- * @brief Calculates the jaro similarity
- *
- * @tparam Sentence1 This is a string that can be converted to
- * basic_string_view<char_type>
- * @tparam Sentence2 This is a string that can be converted to
- * basic_string_view<char_type>
- *
- * @param s1
- *   string to compare with s2 (for type info check Template parameters above)
- * @param s2
- *   string to compare with s1 (for type info check Template parameters above)
- * @param score_cutoff
- *   Optional argument for a score threshold as a float between 0 and 100.
- *   For similarity < score_cutoff 0 is returned instead. Default is 0,
- *   which deactivates this behaviour.
- *
- * @return jaro similarity between s1 and s2
- *   as a float between 0 and 100
- */
-template <typename InputIt1, typename InputIt2>
-double jaro_similarity(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
-                       double score_cutoff = 0.0)
-{
-    return detail::jaro_similarity(first1, last1, first2, last2, score_cutoff);
-}
-
-template <typename S1, typename S2>
-double jaro_similarity(const S1& s1, const S2& s2, double score_cutoff = 0.0)
-{
-    return jaro_similarity(std::begin(s1), std::end(s1), std::begin(s2), std::end(s2),
-                           score_cutoff);
-}
-
-template <typename CharT1>
-struct CachedJaroSimilarity {
-    template <typename InputIt1>
-    CachedJaroSimilarity(InputIt1 first1, InputIt1 last1) : s1(first1, last1), PM(first1, last1)
-    {}
-
-    template <typename S1>
-    CachedJaroSimilarity(const S1& s1_) : CachedJaroSimilarity(std::begin(s1_), std::end(s1_))
-    {}
-
-    template <typename InputIt2>
-    double similarity(InputIt2 first2, InputIt2 last2, double score_cutoff = 0) const
-    {
-        return detail::jaro_similarity(PM, std::begin(s1), std::end(s1), first2, last2,
-                                       score_cutoff);
-    }
-
-    template <typename S2>
-    double similarity(const S2& s2, double score_cutoff = 0) const
-    {
-        return similarity(std::begin(s2), std::end(s2), score_cutoff);
-    }
-
-    template <typename InputIt2>
-    double normalized_similarity(InputIt2 first2, InputIt2 last2, double score_cutoff = 0) const
-    {
-        return similarity(first2, last2, score_cutoff);
-    }
-
-    template <typename S2>
-    double normalized_similarity(const S2& s2, double score_cutoff = 0) const
-    {
-        return similarity(s2, score_cutoff);
-    }
-
-private:
-    std::basic_string<CharT1> s1;
-    common::BlockPatternMatchVector PM;
-};
-
-/**@}*/
-
-} // namespace duckdb_jaro_winkler
diff --git a/src/duckdb/third_party/libpg_query/include/access/attnum.hpp b/src/duckdb/third_party/libpg_query/include/access/attnum.hpp
deleted file mode 100644
index 5e2056395..000000000
--- a/src/duckdb/third_party/libpg_query/include/access/attnum.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * attnum.h
- *	  POSTGRES attribute number definitions.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/attnum.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include <cstdint>
-
-/*
- * user defined attribute numbers start at 1.   -ay 2/95
- */
-typedef int16_t PGAttrNumber;
-
-#define InvalidAttrNumber		0
-#define MaxAttrNumber			32767
-
-/* ----------------
- *		support macros
- * ----------------
- */
-/*
- * AttributeNumberIsValid
- *		True iff the attribute number is valid.
- */
-#define AttributeNumberIsValid(attributeNumber) \
-	((bool) ((attributeNumber) != InvalidAttrNumber))
-
-/*
- * AttrNumberIsForUserDefinedAttr
- *		True iff the attribute number corresponds to an user defined attribute.
- */
-#define AttrNumberIsForUserDefinedAttr(attributeNumber) \
-	((bool) ((attributeNumber) > 0))
-
-/*
- * AttrNumberGetAttrOffset
- *		Returns the attribute offset for an attribute number.
- *
- * Note:
- *		Assumes the attribute number is for a user defined attribute.
- */
-#define AttrNumberGetAttrOffset(attNum) \
-( \
-	AssertMacro(AttrNumberIsForUserDefinedAttr(attNum)), \
-	((attNum) - 1) \
-)
-
-/*
- * AttributeOffsetGetAttributeNumber
- *		Returns the attribute number for an attribute offset.
- */
-#define AttrOffsetGetAttrNumber(attributeOffset) \
-	 ((PGAttrNumber) (1 + (attributeOffset)))
diff --git a/src/duckdb/third_party/libpg_query/include/catalog/genbki.hpp b/src/duckdb/third_party/libpg_query/include/catalog/genbki.hpp
deleted file mode 100644
index 865262353..000000000
--- a/src/duckdb/third_party/libpg_query/include/catalog/genbki.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * genbki.h
- *	  Required include file for all POSTGRES catalog header files
- *
- * genbki.h defines CATALOG(), DATA(), BKI_BOOTSTRAP and related macros
- * so that the catalog header files can be read by the C compiler.
- * (These same words are recognized by genbki.pl to build the BKI
- * bootstrap file from these header files.)
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/catalog/genbki.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-/* Introduces a catalog's structure definition */
-#define CATALOG(name,oid)	typedef struct CppConcat(FormData_,name)
-
-/* Options that may appear after CATALOG (on the same line) */
-#define BKI_BOOTSTRAP
-#define BKI_SHARED_RELATION
-#define BKI_WITHOUT_OIDS
-#define BKI_ROWTYPE_OID(oid)
-#define BKI_SCHEMA_MACRO
-#define BKI_FORCE_NULL
-#define BKI_FORCE_NOT_NULL
-
-/*
- * This is never defined; it's here only for documentation.
- *
- * Variable-length catalog fields (except possibly the first not nullable one)
- * should not be visible in C structures, so they are made invisible by #ifdefs
- * of an undefined symbol.  See also MARKNOTNULL in bootstrap.c for how this is
- * handled.
- */
-#undef CATALOG_VARLEN
-
-/* Declarations that provide the initial content of a catalog */
-/* In C, these need to expand into some harmless, repeatable declaration */
-#define DATA(x)  int no_such_variable
-#define DESCR(x) int no_such_variable
-#define SHDESCR(x) int no_such_variable
diff --git a/src/duckdb/third_party/libpg_query/include/common/keywords.hpp b/src/duckdb/third_party/libpg_query/include/common/keywords.hpp
deleted file mode 100644
index bfd13c5b1..000000000
--- a/src/duckdb/third_party/libpg_query/include/common/keywords.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * keywords.h
- *	  lexical token lookup for key words in PostgreSQL
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/common/keywords.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include <cstdint>
-#include "pg_simplified_token.hpp"
-
-/* Keyword categories --- should match lists in gram.y */
-#define UNRESERVED_KEYWORD		0
-#define COL_NAME_KEYWORD		1
-#define TYPE_FUNC_NAME_KEYWORD	2
-#define RESERVED_KEYWORD		3
-
-namespace duckdb_libpgquery {
-
-typedef struct PGScanKeyword {
-	const char *name; /* in lower case */
-	int16_t value;    /* grammar's token code */
-	int16_t category; /* see codes above */
-} PGScanKeyword;
-
-const PGScanKeyword *ScanKeywordLookup(const char *text, const PGScanKeyword *keywords, int num_keywords);
-}
diff --git a/src/duckdb/third_party/libpg_query/include/datatype/timestamp.hpp b/src/duckdb/third_party/libpg_query/include/datatype/timestamp.hpp
deleted file mode 100644
index f05071b06..000000000
--- a/src/duckdb/third_party/libpg_query/include/datatype/timestamp.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * timestamp.h
- *	  PGTimestamp and PGInterval typedefs and related macros.
- *
- * Note: this file must be includable in both frontend and backend contexts.
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/datatype/timestamp.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include <cstdint>
-
-/*
- * PGTimestamp represents absolute time.
- *
- * PGInterval represents delta time. Keep track of months (and years), days,
- * and hours/minutes/seconds separately since the elapsed time spanned is
- * unknown until instantiated relative to an absolute time.
- *
- * Note that Postgres uses "time interval" to mean a bounded interval,
- * consisting of a beginning and ending time, not a time span - thomas 97/03/20
- *
- * Timestamps, as well as the h/m/s fields of intervals, are stored as
- * int64_t values with units of microseconds.  (Once upon a time they were
- * double values with units of seconds.)
- *
- * PGTimeOffset and pg_fsec_t are convenience typedefs for temporary variables.
- * Do not use pg_fsec_t in values stored on-disk.
- * Also, pg_fsec_t is only meant for *fractional* seconds; beware of overflow
- * if the value you need to store could be many seconds.
- */
-namespace duckdb_libpgquery {
-
-typedef int64_t PGTimestamp;
-typedef int64_t PGTimestampTz;
-typedef int64_t PGTimeOffset;
-typedef int32_t pg_fsec_t; /* fractional seconds (in microseconds) */
-
-typedef struct {
-	PGTimeOffset time; /* all time units other than days, months and
-								 * years */
-	int32_t day;       /* days, after time for alignment */
-	int32_t month;     /* months and years, after time for alignment */
-} PGInterval;
-}
diff --git a/src/duckdb/third_party/libpg_query/include/fmgr.hpp b/src/duckdb/third_party/libpg_query/include/fmgr.hpp
deleted file mode 100644
index 69b701020..000000000
--- a/src/duckdb/third_party/libpg_query/include/fmgr.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * fmgr.h
- *	  Definitions for the Postgres function manager and function-call
- *	  interface.
- *
- * This file must be included by all Postgres modules that either define
- * or call fmgr-callable functions.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/fmgr.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "pg_definitions.hpp"
-
-typedef struct PGFunctionCallInfoData *PGFunctionCallInfo;
-
-/* Standard parameter list for fmgr-compatible functions */
-#define PG_FUNCTION_ARGS	PGFunctionCallInfo fcinfo
diff --git a/src/duckdb/third_party/libpg_query/include/mb/pg_wchar.hpp b/src/duckdb/third_party/libpg_query/include/mb/pg_wchar.hpp
deleted file mode 100644
index 8110dd7f1..000000000
--- a/src/duckdb/third_party/libpg_query/include/mb/pg_wchar.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_wchar.h
- *	  multibyte-character support
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/mb/pg_wchar.h
- *
- *	NOTES
- *		This is used both by the backend and by libpq, but should not be
- *		included by libpq client programs.  In particular, a libpq client
- *		should not assume that the encoding IDs used by the version of libpq
- *		it's linked to match up with the IDs declared here.
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include <cstdint>
-
-/*
- * The pg_wchar type
- */
-namespace duckdb_libpgquery {
-typedef unsigned int pg_wchar;
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/bitmapset.hpp b/src/duckdb/third_party/libpg_query/include/nodes/bitmapset.hpp
deleted file mode 100644
index 109171bcf..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/bitmapset.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * bitmapset.h
- *	  PostgreSQL generic bitmap set package
- *
- * A bitmap set can represent any set of nonnegative integers, although
- * it is mainly intended for sets where the maximum value is not large,
- * say at most a few hundred.  By convention, a NULL pointer is always
- * accepted by all operations to represent the empty set.  (But beware
- * that this is not the only representation of the empty set.  Use
- * bms_is_empty() in preference to testing for NULL.)
- *
- *
- * Copyright (c) 2003-2017, PostgreSQL Global Development PGGroup
- *
- * src/include/nodes/bitmapset.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include <cstdint>
-
-namespace duckdb_libpgquery {
-
-/*
- * Forward decl to save including pg_list.h
- */
-struct PGList;
-
-/*
- * Data representation
- */
-
-/* The unit size can be adjusted by changing these three declarations: */
-#define BITS_PER_BITMAPWORD 32
-typedef uint32_t bitmapword;      /* must be an unsigned type */
-typedef int32_t signedbitmapword; /* must be the matching signed type */
-
-typedef struct PGBitmapset {
-	int nwords;          /* number of words in array */
-	bitmapword words[1]; /* really [nwords] */
-} PGBitmapset;
-
-/* result of bms_subset_compare */
-typedef enum PG_BMS_Comparison {
-	PG_BMS_EQUAL,   /* sets are equal */
-	PG_BMS_SUBSET1, /* first set is a subset of the second */
-	PG_BMS_SUBSET2, /* second set is a subset of the first */
-	BMS_DIFFERENT   /* neither set is a subset of the other */
-} PG_BMS_Comparison;
-
-/* result of bms_membership */
-typedef enum PG_BMS_Membership {
-	PG_BMS_EMPTY_SET, /* 0 members */
-	PG_BMS_SINGLETON, /* 1 member */
-	BMS_MULTIPLE      /* >1 member */
-} PG_BMS_Membership;
-
-/*
- * function prototypes in nodes/bitmapset.c
- */
-
-PGBitmapset *bms_copy(const PGBitmapset *a);
-bool bms_equal(const PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_make_singleton(int x);
-void bms_free(PGBitmapset *a);
-
-PGBitmapset *bms_union(const PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_intersect(const PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_difference(const PGBitmapset *a, const PGBitmapset *b);
-bool bms_is_subset(const PGBitmapset *a, const PGBitmapset *b);
-PG_BMS_Comparison bms_subset_compare(const PGBitmapset *a, const PGBitmapset *b);
-bool bms_is_member(int x, const PGBitmapset *a);
-bool bms_overlap(const PGBitmapset *a, const PGBitmapset *b);
-bool bms_overlap_list(const PGBitmapset *a, const struct PGList *b);
-bool bms_nonempty_difference(const PGBitmapset *a, const PGBitmapset *b);
-int bms_singleton_member(const PGBitmapset *a);
-bool bms_get_singleton_member(const PGBitmapset *a, int *member);
-int bms_num_members(const PGBitmapset *a);
-
-/* optimized tests when we don't need to know exact membership count: */
-PG_BMS_Membership bms_membership(const PGBitmapset *a);
-bool bms_is_empty(const PGBitmapset *a);
-
-/* these routines recycle (modify or free) their non-const inputs: */
-
-PGBitmapset *bms_add_member(PGBitmapset *a, int x);
-PGBitmapset *bms_del_member(PGBitmapset *a, int x);
-PGBitmapset *bms_add_members(PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_int_members(PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_del_members(PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_join(PGBitmapset *a, PGBitmapset *b);
-
-/* support for iterating through the integer elements of a set: */
-int bms_first_member(PGBitmapset *a);
-int bms_next_member(const PGBitmapset *a, int prevbit);
-
-/* support for hashtables using Bitmapsets as keys: */
-uint32_t bms_hash_value(const PGBitmapset *a);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/lockoptions.hpp b/src/duckdb/third_party/libpg_query/include/nodes/lockoptions.hpp
deleted file mode 100644
index 2058e94d9..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/lockoptions.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * lockoptions.h
- *	  Common header for some locking-related declarations.
- *
- *
- * Copyright (c) 2014-2017, PostgreSQL Global Development PGGroup
- *
- * src/include/nodes/lockoptions.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-namespace duckdb_libpgquery {
-
-/*
- * This enum represents the different strengths of FOR UPDATE/SHARE clauses.
- * The ordering here is important, because the highest numerical value takes
- * precedence when a RTE is specified multiple ways.  See applyLockingClause.
- */
-typedef enum PGLockClauseStrength {
-	PG_LCS_NONE,           /* no such clause - only used in PGPlanRowMark */
-	PG_LCS_FORKEYSHARE,    /* FOR KEY SHARE */
-	PG_LCS_FORSHARE,       /* FOR SHARE */
-	PG_LCS_FORNOKEYUPDATE, /* FOR NO KEY UPDATE */
-	LCS_FORUPDATE          /* FOR UPDATE */
-} PGLockClauseStrength;
-
-/*
- * This enum controls how to deal with rows being locked by FOR UPDATE/SHARE
- * clauses (i.e., it represents the NOWAIT and SKIP LOCKED options).
- * The ordering here is important, because the highest numerical value takes
- * precedence when a RTE is specified multiple ways.  See applyLockingClause.
- */
-typedef enum PGLockWaitPolicy {
-	/* Wait for the lock to become available (default behavior) */
-	PGLockWaitBlock,
-	/* Skip rows that can't be locked (SKIP LOCKED) */
-	PGLockWaitSkip,
-	/* Raise an error if a row cannot be locked (NOWAIT) */
-	LockWaitError
-} PGLockWaitPolicy;
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/makefuncs.hpp b/src/duckdb/third_party/libpg_query/include/nodes/makefuncs.hpp
deleted file mode 100644
index b2aeeebf3..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/makefuncs.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * makefuncs.h
- *	  prototypes for the creator functions (for primitive nodes)
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/makefuncs.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "nodes/parsenodes.hpp"
-
-namespace duckdb_libpgquery {
-
-PGAExpr *makeAExpr(PGAExpr_Kind kind, PGList *name, PGNode *lexpr, PGNode *rexpr, int location);
-
-PGAExpr *makeSimpleAExpr(PGAExpr_Kind kind, const char *name, PGNode *lexpr, PGNode *rexpr, int location);
-
-PGVar *makeVar(PGIndex varno, PGAttrNumber varattno, PGOid vartype, int32_t vartypmod, PGOid varcollid,
-               PGIndex varlevelsup);
-
-PGVar *makeVarFromTargetEntry(PGIndex varno, PGTargetEntry *tle);
-
-PGVar *makeWholeRowVar(PGRangeTblEntry *rte, PGIndex varno, PGIndex varlevelsup, bool allowScalar);
-
-PGTargetEntry *makeTargetEntry(PGExpr *expr, PGAttrNumber resno, char *resname, bool resjunk);
-
-PGTargetEntry *flatCopyTargetEntry(PGTargetEntry *src_tle);
-
-PGFromExpr *makeFromExpr(PGList *fromlist, PGNode *quals);
-
-PGConst *makeConst(PGOid consttype, int32_t consttypmod, PGOid constcollid, int constlen, PGDatum constvalue,
-                   bool constisnull, bool constbyval);
-
-PGConst *makeNullConst(PGOid consttype, int32_t consttypmod, PGOid constcollid);
-
-PGNode *makeBoolConst(bool value, bool isnull);
-
-PGExpr *makeBoolExpr(PGBoolExprType boolop, PGList *args, int location);
-
-PGAlias *makeAlias(const char *aliasname, PGList *colnames);
-
-PGRelabelType *makeRelabelType(PGExpr *arg, PGOid rtype, int32_t rtypmod, PGOid rcollid, PGCoercionForm rformat);
-
-PGRangeVar *makeRangeVar(char *schemaname, char *relname, int location);
-
-PGTypeName *makeTypeName(char *typnam);
-PGTypeName *makeTypeNameFromNameList(PGList *names);
-PGTypeName *makeTypeNameFromOid(PGOid typeOid, int32_t typmod);
-
-PGColumnDef *makeColumnDef(const char *colname, PGOid typeOid, int32_t typmod, PGOid collOid);
-
-PGFuncExpr *makeFuncExpr(PGOid funcid, PGOid rettype, PGList *args, PGOid funccollid, PGOid inputcollid,
-                         PGCoercionForm fformat);
-
-PGFuncCall *makeFuncCall(PGList *name, PGList *args, int location);
-
-PGDefElem *makeDefElem(const char *name, PGNode *arg, int location);
-PGDefElem *makeDefElemExtended(const char *nameSpace, const char *name, PGNode *arg, PGDefElemAction defaction,
-                               int location);
-
-PGGroupingSet *makeGroupingSet(GroupingSetKind kind, PGList *content, int location);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/nodeFuncs.hpp b/src/duckdb/third_party/libpg_query/include/nodes/nodeFuncs.hpp
deleted file mode 100644
index 8b83c1982..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/nodeFuncs.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * nodeFuncs.h
- *		Various general-purpose manipulations of PGNode trees
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/nodeFuncs.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "nodes/parsenodes.hpp"
-
-namespace duckdb_libpgquery {
-
-/* flags bits for query_tree_walker and query_tree_mutator */
-#define QTW_IGNORE_RT_SUBQUERIES 0x01 /* subqueries in rtable */
-#define QTW_IGNORE_CTE_SUBQUERIES 0x02 /* subqueries in cteList */
-#define QTW_IGNORE_RC_SUBQUERIES 0x03 /* both of above */
-#define QTW_IGNORE_JOINALIASES 0x04 /* JOIN alias var lists */
-#define QTW_IGNORE_RANGE_TABLE 0x08 /* skip rangetable entirely */
-#define QTW_EXAMINE_RTES 0x10 /* examine RTEs */
-#define QTW_DONT_COPY_QUERY 0x20 /* do not copy top PGQuery */
-
-/* callback function for check_functions_in_node */
-typedef bool (*check_function_callback)(PGOid func_id, void *context);
-
-PGOid exprType(const PGNode *expr);
-int32_t exprTypmod(const PGNode *expr);
-bool exprIsLengthCoercion(const PGNode *expr, int32_t *coercedTypmod);
-PGNode *relabel_to_typmod(PGNode *expr, int32_t typmod);
-PGNode *strip_implicit_coercions(PGNode *node);
-bool expression_returns_set(PGNode *clause);
-
-PGOid exprCollation(const PGNode *expr);
-PGOid exprInputCollation(const PGNode *expr);
-void exprSetCollation(PGNode *expr, PGOid collation);
-void exprSetInputCollation(PGNode *expr, PGOid inputcollation);
-
-int exprLocation(const PGNode *expr);
-
-void fix_opfuncids(PGNode *node);
-void set_opfuncid(PGOpExpr *opexpr);
-void set_sa_opfuncid(PGScalarArrayOpExpr *opexpr);
-
-bool check_functions_in_node(PGNode *node, check_function_callback checker, void *context);
-
-bool expression_tree_walker(PGNode *node, bool (*walker)(), void *context);
-PGNode *expression_tree_mutator(PGNode *node, PGNode *(*mutator)(), void *context);
-
-bool query_tree_walker(PGQuery *query, bool (*walker)(), void *context, int flags);
-PGQuery *query_tree_mutator(PGQuery *query, PGNode *(*mutator)(), void *context, int flags);
-
-bool range_table_walker(PGList *rtable, bool (*walker)(), void *context, int flags);
-PGList *range_table_mutator(PGList *rtable, PGNode *(*mutator)(), void *context, int flags);
-
-bool query_or_expression_tree_walker(PGNode *node, bool (*walker)(), void *context, int flags);
-PGNode *query_or_expression_tree_mutator(PGNode *node, PGNode *(*mutator)(), void *context, int flags);
-
-bool raw_expression_tree_walker(PGNode *node, bool (*walker)(), void *context);
-
-struct PlanState;
-bool planstate_tree_walker(struct PlanState *planstate, bool (*walker)(), void *context);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp b/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp
deleted file mode 100644
index d12e34c2e..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp
+++ /dev/null
@@ -1,831 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * nodes.h
- *	  Definitions for tagged nodes.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/nodes.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "pg_definitions.hpp"
-
-namespace duckdb_libpgquery {
-
-/*
- * The first field of every node is NodeTag. Each node created (with makeNode)
- * will have one of the following tags as the value of its first field.
- *
- * Note that inserting or deleting node types changes the numbers of other
- * node types later in the list.  This is no problem during development, since
- * the node numbers are never stored on disk.  But don't do it in a released
- * branch, because that would represent an ABI break for extensions.
- */
-typedef enum PGNodeTag {
-	T_PGInvalid = 0,
-
-	/*
-	 * TAGS FOR EXECUTOR NODES (execnodes.h)
-	 */
-	T_PGIndexInfo,
-	T_PGExprContext,
-	T_PGProjectionInfo,
-	T_PGJunkFilter,
-	T_PGResultRelInfo,
-	T_PGEState,
-	T_PGTupleTableSlot,
-
-	/*
-	 * TAGS FOR PLAN NODES (plannodes.h)
-	 */
-	T_PGPlan,
-	T_PGResult,
-	T_PGProjectSet,
-	T_PGModifyTable,
-	T_PGAppend,
-	T_PGMergeAppend,
-	T_PGRecursiveUnion,
-	T_PGBitmapAnd,
-	T_PGBitmapOr,
-	T_PGScan,
-	T_PGSeqScan,
-	T_PGSampleScan,
-	T_PGIndexScan,
-	T_PGIndexOnlyScan,
-	T_PGBitmapIndexScan,
-	T_PGBitmapHeapScan,
-	T_PGTidScan,
-	T_PGSubqueryScan,
-	T_PGFunctionScan,
-	T_PGValuesScan,
-	T_PGTableFuncScan,
-	T_PGCteScan,
-	T_PGNamedTuplestoreScan,
-	T_PGWorkTableScan,
-	T_PGForeignScan,
-	T_PGCustomScan,
-	T_PGJoin,
-	T_PGNestLoop,
-	T_PGMergeJoin,
-	T_PGHashJoin,
-	T_PGMaterial,
-	T_PGSort,
-	T_PGGroup,
-	T_PGAgg,
-	T_PGWindowAgg,
-	T_PGUnique,
-	T_PGGather,
-	T_PGGatherMerge,
-	T_PGHash,
-	T_PGSetOp,
-	T_PGLockRows,
-	T_PGLimit,
-	/* these aren't subclasses of PGPlan: */
-	T_PGNestLoopParam,
-	T_PGPlanRowMark,
-	T_PGPlanInvalItem,
-
-	/*
-	 * TAGS FOR PLAN STATE NODES (execnodes.h)
-	 *
-	 * These should correspond one-to-one with PGPlan node types.
-	 */
-	T_PGPlanState,
-	T_PGResultState,
-	T_PGProjectSetState,
-	T_PGModifyTableState,
-	T_PGAppendState,
-	T_PGMergeAppendState,
-	T_PGRecursiveUnionState,
-	T_PGBitmapAndState,
-	T_PGBitmapOrState,
-	T_PGScanState,
-	T_PGSeqScanState,
-	T_PGSampleScanState,
-	T_PGIndexScanState,
-	T_PGIndexOnlyScanState,
-	T_PGBitmapIndexScanState,
-	T_PGBitmapHeapScanState,
-	T_PGTidScanState,
-	T_PGSubqueryScanState,
-	T_PGFunctionScanState,
-	T_PGTableFuncScanState,
-	T_PGValuesScanState,
-	T_PGCteScanState,
-	T_PGNamedTuplestoreScanState,
-	T_PGWorkTableScanState,
-	T_PGForeignScanState,
-	T_PGCustomScanState,
-	T_PGJoinState,
-	T_PGNestLoopState,
-	T_PGMergeJoinState,
-	T_PGHashJoinState,
-	T_PGMaterialState,
-	T_PGSortState,
-	T_PGGroupState,
-	T_PGAggState,
-	T_PGWindowAggState,
-	T_PGUniqueState,
-	T_PGGatherState,
-	T_PGGatherMergeState,
-	T_PGHashState,
-	T_PGSetOpState,
-	T_PGLockRowsState,
-	T_PGLimitState,
-
-	/*
-	 * TAGS FOR PRIMITIVE NODES (primnodes.h)
-	 */
-	T_PGAlias,
-	T_PGRangeVar,
-	T_PGTableFunc,
-	T_PGExpr,
-	T_PGVar,
-	T_PGConst,
-	T_PGParam,
-	T_PGAggref,
-	T_PGGroupingFunc,
-	T_PGWindowFunc,
-	T_PGArrayRef,
-	T_PGFuncExpr,
-	T_PGNamedArgExpr,
-	T_PGOpExpr,
-	T_PGDistinctExpr,
-	T_PGNullIfExpr,
-	T_PGScalarArrayOpExpr,
-	T_PGBoolExpr,
-	T_PGSubLink,
-	T_PGSubPlan,
-	T_PGAlternativeSubPlan,
-	T_PGFieldSelect,
-	T_PGFieldStore,
-	T_PGRelabelType,
-	T_PGCoerceViaIO,
-	T_PGArrayCoerceExpr,
-	T_PGConvertRowtypeExpr,
-	T_PGCollateExpr,
-	T_PGCaseExpr,
-	T_PGCaseWhen,
-	T_PGCaseTestExpr,
-	T_PGArrayExpr,
-	T_PGRowExpr,
-	T_PGRowCompareExpr,
-	T_PGCoalesceExpr,
-	T_PGMinMaxExpr,
-	T_PGSQLValueFunction,
-	T_PGXmlExpr,
-	T_PGNullTest,
-	T_PGBooleanTest,
-	T_PGCoerceToDomain,
-	T_PGCoerceToDomainValue,
-	T_PGSetToDefault,
-	T_PGCurrentOfExpr,
-	T_PGNextValueExpr,
-	T_PGInferenceElem,
-	T_PGTargetEntry,
-	T_PGRangeTblRef,
-	T_PGJoinExpr,
-	T_PGFromExpr,
-	T_PGOnConflictExpr,
-	T_PGIntoClause,
-	T_PGLambdaFunction,
-	T_PGPivotExpr,
-	T_PGPivot,
-	T_PGPivotStmt,
-
-	/*
-	 * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
-	 *
-	 * ExprState represents the evaluation state for a whole expression tree.
-	 * Most Expr-based plan nodes do not have a corresponding expression state
-	 * node, they're fully handled within execExpr* - but sometimes the state
-	 * needs to be shared with other parts of the executor, as for example
-	 * with AggrefExprState, which nodeAgg.c has to modify.
-	 */
-	T_PGExprState,
-	T_PGAggrefExprState,
-	T_PGWindowFuncExprState,
-	T_PGSetExprState,
-	T_PGSubPlanState,
-	T_PGAlternativeSubPlanState,
-	T_PGDomainConstraintState,
-
-	/*
-	 * TAGS FOR PLANNER NODES (relation.h)
-	 */
-	T_PGPlannerInfo,
-	T_PGPlannerGlobal,
-	T_PGRelOptInfo,
-	T_PGIndexOptInfo,
-	T_PGForeignKeyOptInfo,
-	T_PGParamPathInfo,
-	T_PGPath,
-	T_PGIndexPath,
-	T_PGBitmapHeapPath,
-	T_PGBitmapAndPath,
-	T_PGBitmapOrPath,
-	T_PGTidPath,
-	T_PGSubqueryScanPath,
-	T_PGForeignPath,
-	T_PGCustomPath,
-	T_PGNestPath,
-	T_PGMergePath,
-	T_PGHashPath,
-	T_PGAppendPath,
-	T_PGMergeAppendPath,
-	T_PGResultPath,
-	T_PGMaterialPath,
-	T_PGUniquePath,
-	T_PGGatherPath,
-	T_PGGatherMergePath,
-	T_PGProjectionPath,
-	T_PGProjectSetPath,
-	T_PGSortPath,
-	T_PGGroupPath,
-	T_PGUpperUniquePath,
-	T_PGAggPath,
-	T_PGGroupingSetsPath,
-	T_PGMinMaxAggPath,
-	T_PGWindowAggPath,
-	T_PGSetOpPath,
-	T_PGRecursiveUnionPath,
-	T_PGLockRowsPath,
-	T_PGModifyTablePath,
-	T_PGLimitPath,
-	/* these aren't subclasses of Path: */
-	T_PGEquivalenceClass,
-	T_PGEquivalenceMember,
-	T_PGPathKey,
-	T_PGPathTarget,
-	T_PGRestrictInfo,
-	T_PGPlaceHolderVar,
-	T_PGSpecialJoinInfo,
-	T_PGAppendRelInfo,
-	T_PGPartitionedChildRelInfo,
-	T_PGPlaceHolderInfo,
-	T_PGMinMaxAggInfo,
-	T_PGPlannerParamItem,
-	T_PGRollupData,
-	T_PGGroupingSetData,
-	T_PGStatisticExtInfo,
-
-	/*
-	 * TAGS FOR MEMORY NODES (memnodes.h)
-	 */
-	T_PGMemoryContext,
-	T_PGAllocSetContext,
-	T_PGSlabContext,
-
-	/*
-	 * TAGS FOR VALUE NODES (value.h)
-	 */
-	T_PGValue,
-	T_PGInteger,
-	T_PGFloat,
-	T_PGString,
-	T_PGBitString,
-	T_PGNull,
-
-	/*
-	 * TAGS FOR LIST NODES (pg_list.h)
-	 */
-	T_PGList,
-	T_PGIntList,
-	T_PGOidList,
-
-	/*
-	 * TAGS FOR EXTENSIBLE NODES (extensible.h)
-	 */
-	T_PGExtensibleNode,
-
-	/*
-	 * TAGS FOR STATEMENT NODES (mostly in parsenodes.h)
-	 */
-	T_PGRawStmt,
-	T_PGQuery,
-	T_PGPlannedStmt,
-	T_PGInsertStmt,
-	T_PGDeleteStmt,
-	T_PGUpdateStmt,
-	T_PGUpdateExtensionsStmt,
-	T_PGSelectStmt,
-	T_PGAlterTableStmt,
-	T_PGAlterTableCmd,
-	T_PGAlterDomainStmt,
-	T_PGSetOperationStmt,
-	T_PGGrantStmt,
-	T_PGGrantRoleStmt,
-	T_PGAlterDefaultPrivilegesStmt,
-	T_PGClosePortalStmt,
-	T_PGClusterStmt,
-	T_PGCopyStmt,
-	T_PGCopyDatabaseStmt,
-	T_PGCreateStmt,
-	T_PGDefineStmt,
-	T_PGDropStmt,
-	T_PGTruncateStmt,
-	T_PGCommentStmt,
-	T_PGCommentOnStmt,
-	T_PGFetchStmt,
-	T_PGIndexStmt,
-	T_PGFunctionDefinition,
-	T_PGCreateFunctionStmt,
-	T_PGAlterFunctionStmt,
-	T_PGDoStmt,
-	T_PGRenameStmt,
-	T_PGRuleStmt,
-	T_PGNotifyStmt,
-	T_PGListenStmt,
-	T_PGUnlistenStmt,
-	T_PGTransactionStmt,
-	T_PGViewStmt,
-	T_PGLoadStmt,
-	T_PGCreateDomainStmt,
-	T_PGCreatedbStmt,
-	T_PGDropdbStmt,
-	T_PGVacuumStmt,
-	T_PGExplainStmt,
-	T_PGCreateTableAsStmt,
-	T_PGCreateSeqStmt,
-	T_PGAlterSeqStmt,
-	T_PGVariableSetStmt,
-	T_PGVariableShowStmt,
-	T_PGVariableShowSelectStmt,
-	T_PGDiscardStmt,
-	T_PGCreateTrigStmt,
-	T_PGCreatePLangStmt,
-	T_PGCreateRoleStmt,
-	T_PGAlterRoleStmt,
-	T_PGDropRoleStmt,
-	T_PGLockStmt,
-	T_PGConstraintsSetStmt,
-	T_PGReindexStmt,
-	T_PGCheckPointStmt,
-	T_PGCreateSchemaStmt,
-	T_PGCreateSecretStmt,
-	T_PGAlterDatabaseStmt,
-	T_PGAlterDatabaseSetStmt,
-	T_PGAlterRoleSetStmt,
-	T_PGCreateConversionStmt,
-	T_PGCreateCastStmt,
-	T_PGCreateOpClassStmt,
-	T_PGCreateOpFamilyStmt,
-	T_PGAlterOpFamilyStmt,
-	T_PGPrepareStmt,
-	T_PGExecuteStmt,
-	T_PGCallStmt,
-	T_PGDeallocateStmt,
-	T_PGDeclareCursorStmt,
-	T_PGCreateTableSpaceStmt,
-	T_PGDropSecretStmt,
-	T_PGDropTableSpaceStmt,
-	T_PGAlterObjectDependsStmt,
-	T_PGAlterObjectSchemaStmt,
-	T_PGAlterOwnerStmt,
-	T_PGAlterOperatorStmt,
-	T_PGDropOwnedStmt,
-	T_PGReassignOwnedStmt,
-	T_PGCompositeTypeStmt,
-	T_PGCreateTypeStmt,
-	T_PGCreateRangeStmt,
-	T_PGAlterEnumStmt,
-	T_PGAlterTSDictionaryStmt,
-	T_PGAlterTSConfigurationStmt,
-	T_PGCreateFdwStmt,
-	T_PGAlterFdwStmt,
-	T_PGCreateForeignServerStmt,
-	T_PGAlterForeignServerStmt,
-	T_PGCreateUserMappingStmt,
-	T_PGAlterUserMappingStmt,
-	T_PGDropUserMappingStmt,
-	T_PGAlterTableSpaceOptionsStmt,
-	T_PGAlterTableMoveAllStmt,
-	T_PGSecLabelStmt,
-	T_PGCreateForeignTableStmt,
-	T_PGImportForeignSchemaStmt,
-	T_PGCreateExtensionStmt,
-	T_PGAlterExtensionStmt,
-	T_PGAlterExtensionContentsStmt,
-	T_PGCreateEventTrigStmt,
-	T_PGAlterEventTrigStmt,
-	T_PGRefreshMatViewStmt,
-	T_PGReplicaIdentityStmt,
-	T_PGAlterSystemStmt,
-	T_PGCreatePolicyStmt,
-	T_PGAlterPolicyStmt,
-	T_PGCreateTransformStmt,
-	T_PGCreateAmStmt,
-	T_PGCreatePublicationStmt,
-	T_PGAlterPublicationStmt,
-	T_PGCreateSubscriptionStmt,
-	T_PGAlterSubscriptionStmt,
-	T_PGDropSubscriptionStmt,
-	T_PGCreateStatsStmt,
-	T_PGAlterCollationStmt,
-	T_PGPragmaStmt,
-	T_PGExportStmt,
-	T_PGImportStmt,
-	T_PGAttachStmt,
-	T_PGDetachStmt,
-	T_PGUseStmt,
-
-	/*
-	 * TAGS FOR PARSE TREE NODES (parsenodes.h)
-	 */
-	T_PGAExpr,
-	T_PGColumnRef,
-	T_PGParamRef,
-	T_PGAConst,
-	T_PGFuncCall,
-	T_PGAStar,
-	T_PGAIndices,
-	T_PGAIndirection,
-	T_PGAArrayExpr,
-	T_PGResTarget,
-	T_PGMultiAssignRef,
-	T_PGTypeCast,
-	T_PGCollateClause,
-	T_PGSortBy,
-	T_PGWindowDef,
-	T_PGRangeSubselect,
-	T_PGRangeFunction,
-	T_PGRangeTableSample,
-	T_PGRangeTableFunc,
-	T_PGRangeTableFuncCol,
-	T_PGTypeName,
-	T_PGColumnDef,
-	T_PGIndexElem,
-	T_PGConstraint,
-	T_PGDefElem,
-	T_PGRangeTblEntry,
-	T_PGRangeTblFunction,
-	T_PGTableSampleClause,
-	T_PGWithCheckOption,
-	T_PGSortGroupClause,
-	T_PGGroupingSet,
-	T_PGWindowClause,
-	T_PGObjectWithArgs,
-	T_PGAccessPriv,
-	T_PGCreateOpClassItem,
-	T_PGTableLikeClause,
-	T_PGFunctionParameter,
-	T_PGLockingClause,
-	T_PGRowMarkClause,
-	T_PGXmlSerialize,
-	T_PGWithClause,
-	T_PGInferClause,
-	T_PGOnConflictClause,
-	T_PGCommonTableExpr,
-	T_PGRoleSpec,
-	T_PGTriggerTransition,
-	T_PGPartitionElem,
-	T_PGPartitionSpec,
-	T_PGPartitionBoundSpec,
-	T_PGPartitionRangeDatum,
-	T_PGPartitionCmd,
-	T_PGIntervalConstant,
-	T_PGSampleSize,
-	T_PGSampleOptions,
-	T_PGLimitPercent,
-	T_PGPositionalReference,
-
-	/*
-	 * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h)
-	 */
-	T_PGIdentifySystemCmd,
-	T_PGBaseBackupCmd,
-	T_PGCreateReplicationSlotCmd,
-	T_PGDropReplicationSlotCmd,
-	T_PGStartReplicationCmd,
-	T_PGTimeLineHistoryCmd,
-	T_PGSQLCmd,
-
-	/*
-	 * TAGS FOR RANDOM OTHER STUFF
-	 *
-	 * These are objects that aren't part of parse/plan/execute node tree
-	 * structures, but we give them NodeTags anyway for identification
-	 * purposes (usually because they are involved in APIs where we want to
-	 * pass multiple object types through the same pointer).
-	 */
-	T_PGTriggerData,        /* in commands/trigger.h */
-	T_PGEventTriggerData,   /* in commands/event_trigger.h */
-	T_PGReturnSetInfo,      /* in nodes/execnodes.h */
-	T_PGWindowObjectData,   /* private in nodeWindowAgg.c */
-	T_PGTIDBitmap,          /* in nodes/tidbitmap.h */
-	T_PGInlineCodeBlock,    /* in nodes/parsenodes.h */
-	T_PGFdwRoutine,         /* in foreign/fdwapi.h */
-	T_PGIndexAmRoutine,     /* in access/amapi.h */
-	T_PGTsmRoutine,         /* in access/tsmapi.h */
-	T_PGForeignKeyCacheInfo /* in utils/rel.h */
-} PGNodeTag;
-
-/*
- * The first field of a node of any type is guaranteed to be the NodeTag.
- * Hence the type of any node can be gotten by casting it to Node. Declaring
- * a variable to be of PGNode * (instead of void *) can also facilitate
- * debugging.
- */
-typedef struct PGNode {
-	PGNodeTag type;
-} PGNode;
-
-#define nodeTag(nodeptr) (((const PGNode *)(nodeptr))->type)
-
-#define makeNode(_type_) ((_type_ *)newNode(sizeof(_type_), T_##_type_))
-
-#define NodeSetTag(nodeptr, t) (((PGNode *)(nodeptr))->type = (t))
-
-#define IsA(nodeptr, _type_) (nodeTag(nodeptr) == T_##_type_)
-
-/*
- * castNode(type, ptr) casts ptr to "type *", and if assertions are enabled,
- * verifies that the node has the appropriate type (using its nodeTag()).
- *
- * Use an inline function when assertions are enabled, to avoid multiple
- * evaluations of the ptr argument (which could e.g. be a function call).
- */
-#ifdef USE_ASSERT_CHECKING
-static inline PGNode *castNodeImpl(PGNodeTag type, void *ptr) {
-	Assert(ptr == NULL || nodeTag(ptr) == type);
-	return (PGNode *)ptr;
-}
-#define castNode(_type_, nodeptr) ((_type_ *)castNodeImpl(T_##_type_, nodeptr))
-#else
-#define castNode(_type_, nodeptr) ((_type_ *)(nodeptr))
-#endif /* USE_ASSERT_CHECKING */
-
-/* ----------------------------------------------------------------
- *					  extern declarations follow
- * ----------------------------------------------------------------
- */
-
-/*
- * nodes/{outfuncs.c,print.c}
- */
-struct PGBitmapset;      /* not to include bitmapset.h here */
-struct PGStringInfoData; /* not to include stringinfo.h here */
-
-PGNode* newNode(size_t size, PGNodeTag type);
-
-void outNode(struct PGStringInfoData *str, const void *obj);
-void outToken(struct PGStringInfoData *str, const char *s);
-void outBitmapset(struct PGStringInfoData *str, const struct PGBitmapset *bms);
-void outDatum(struct PGStringInfoData *str, uintptr_t value, int typlen, bool typbyval);
-char *nodeToString(const void *obj);
-char *bmsToString(const struct PGBitmapset *bms);
-
-/*
- * nodes/{readfuncs.c,read.c}
- */
-void *stringToNode(char *str);
-struct PGBitmapset *readBitmapset(void);
-uintptr_t readDatum(bool typbyval);
-bool *readBoolCols(int numCols);
-int *readIntCols(int numCols);
-PGOid *readOidCols(int numCols);
-int16_t *readAttrNumberCols(int numCols);
-
-/*
- * nodes/copyfuncs.c
- */
-void *copyObjectImpl(const void *obj);
-
-/* cast result back to argument type, if supported by compiler */
-//#ifdef HAVE_TYPEOF
-//#define copyObject(obj) ((typeof(obj)) copyObjectImpl(obj))
-//#else
-//#define copyObject(obj) copyObjectImpl(obj)
-//#endif
-
-/*
- * nodes/equalfuncs.c
- */
-// extern bool equal(const void *a, const void *b);
-
-/*
- * Typedefs for identifying qualifier selectivities and plan costs as such.
- * These are just plain "double"s, but declaring a variable as Selectivity
- * or Cost makes the intent more obvious.
- *
- * These could have gone into plannodes.h or some such, but many files
- * depend on them...
- */
-typedef double Selectivity; /* fraction of tuples a qualifier will pass */
-typedef double Cost;        /* execution cost (in page-access units) */
-
-/*
- * PGCmdType -
- *	  enums for type of operation represented by a PGQuery or PGPlannedStmt
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGCmdType {
-	PG_CMD_UNKNOWN,
-	PG_CMD_SELECT, /* select stmt */
-	PG_CMD_UPDATE, /* update stmt */
-	PG_CMD_INSERT, /* insert stmt */
-	PG_CMD_DELETE,
-	PG_CMD_UTILITY, /* cmds like create, destroy, copy, vacuum,
-								 * etc. */
-	PG_CMD_NOTHING  /* dummy command for instead nothing rules
-								 * with qual */
-} PGCmdType;
-
-/*
- * PGJoinType -
- *	  enums for types of relation joins
- *
- * PGJoinType determines the exact semantics of joining two relations using
- * a matching qualification.  For example, it tells what to do with a tuple
- * that has no match in the other relation.
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGJoinType {
-	/*
-	 * The canonical kinds of joins according to the SQL JOIN syntax. Only
-	 * these codes can appear in parser output (e.g., PGJoinExpr nodes).
-	 */
-	PG_JOIN_INNER, /* matching tuple pairs only */
-	PG_JOIN_LEFT,  /* pairs + unmatched LHS tuples */
-	PG_JOIN_FULL,  /* pairs + unmatched LHS + unmatched RHS */
-	PG_JOIN_RIGHT, /* pairs + unmatched RHS tuples */
-
-	/*
-	 * Semijoins and anti-semijoins (as defined in relational theory) do not
-	 * appear in the SQL JOIN syntax, but there are standard idioms for
-	 * representing them (e.g., using EXISTS).  The planner recognizes these
-	 * cases and converts them to joins.  So the planner and executor must
-	 * support these codes.  NOTE: in PG_JOIN_SEMI output, it is unspecified
-	 * which matching RHS row is joined to.  In PG_JOIN_ANTI output, the row is
-	 * guaranteed to be null-extended.
-	 */
-	PG_JOIN_SEMI, /* 1 copy of each LHS row that has match(es) */
-	PG_JOIN_ANTI, /* 1 copy of each LHS row that has no match */
-
-	/*
-	 * These codes are used internally in the planner, but are not supported
-	 * by the executor (nor, indeed, by most of the planner).
-	 */
-	PG_JOIN_UNIQUE_OUTER, /* LHS path must be made unique */
-	PG_JOIN_UNIQUE_INNER, /* RHS path must be made unique */
-
-	/*
-	 * Positional joins are essentially parallel table scans.
-	 */
-	PG_JOIN_POSITION /* Two tables of the same length */
-
-	/*
-	 * We might need additional join types someday.
-	 */
-} PGJoinType;
-
-/*
- * PGJoinRefType -
- *    enums for the types of implied conditions
- *
- * PGJoinRefType specifies the semantics of interpreting the join conditions.
- * These can be explicit (e.g., REGULAR) implied (e.g., NATURAL)
- * or interpreted in a particular manner (e.g., ASOF)
- *
- * This is a generalisation of the old Postgres isNatural flag.
- */
-typedef enum PGJoinRefType {
-	PG_JOIN_REGULAR, /* Join conditions are interpreted as is */
-	PG_JOIN_NATURAL, /* Join conditions are inferred from the column names */
-
-	/*
-	 * ASOF joins are joins with a single inequality predicate
-	 * and optional equality predicates.
-	 * The semantics are equivalent to the following window join:
-	 * 		times t
-	 * 	<jointype> JOIN (
-     *		SELECT *,
-     *			LEAD(begin, 1, 'infinity') OVER ([PARTITION BY key] ORDER BY begin) AS end)
-	 * 		FROM events) e
-	 *	ON t.ts >= e.begin AND t.ts < e.end [AND t.key = e.key]
-	 */
-	PG_JOIN_ASOF
-
-	/*
-	 * Positional join is a candidate to move here
-	 */
-} PGJoinRefType;
-
-/*
- * OUTER joins are those for which pushed-down quals must behave differently
- * from the join's own quals.  This is in fact everything except INNER and
- * SEMI joins.  However, this macro must also exclude the JOIN_UNIQUE symbols
- * since those are temporary proxies for what will eventually be an INNER
- * join.
- *
- * Note: semijoins are a hybrid case, but we choose to treat them as not
- * being outer joins.  This is okay principally because the SQL syntax makes
- * it impossible to have a pushed-down qual that refers to the inner relation
- * of a semijoin; so there is no strong need to distinguish join quals from
- * pushed-down quals.  This is convenient because for almost all purposes,
- * quals attached to a semijoin can be treated the same as innerjoin quals.
- */
-#define IS_OUTER_JOIN(jointype) \
-	(((1 << (jointype)) & ((1 << PG_JOIN_LEFT) | (1 << PG_JOIN_FULL) | (1 << PG_JOIN_RIGHT) | (1 << PG_JOIN_ANTI))) != 0)
-
-/*
- * PGAggStrategy -
- *	  overall execution strategies for PGAgg plan nodes
- *
- * This is needed in both plannodes.h and relation.h, so put it here...
- */
-typedef enum PGAggStrategy {
-	PG_AGG_PLAIN,  /* simple agg across all input rows */
-	PG_AGG_SORTED, /* grouped agg, input must be sorted */
-	PG_AGG_HASHED, /* grouped agg, use internal hashtable */
-	AGG_MIXED      /* grouped agg, hash and sort both used */
-} PGAggStrategy;
-
-/*
- * PGAggSplit -
- *	  splitting (partial aggregation) modes for PGAgg plan nodes
- *
- * This is needed in both plannodes.h and relation.h, so put it here...
- */
-
-/* Primitive options supported by nodeAgg.c: */
-#define AGGSPLITOP_COMBINE 0x01 /* substitute combinefn for transfn */
-#define AGGSPLITOP_SKIPFINAL 0x02 /* skip finalfn, return state as-is */
-#define AGGSPLITOP_SERIALIZE 0x04 /* apply serializefn to output */
-#define AGGSPLITOP_DESERIALIZE 0x08 /* apply deserializefn to input */
-
-/* Supported operating modes (i.e., useful combinations of these options): */
-typedef enum PGAggSplit {
-	/* Basic, non-split aggregation: */
-	PG_AGGSPLIT_SIMPLE = 0,
-	/* Initial phase of partial aggregation, with serialization: */
-	PG_AGGSPLIT_INITIAL_SERIAL = AGGSPLITOP_SKIPFINAL | AGGSPLITOP_SERIALIZE,
-	/* Final phase of partial aggregation, with deserialization: */
-	PG_AGGSPLIT_FINAL_DESERIAL = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE
-} PGAggSplit;
-
-/* Test whether an PGAggSplit value selects each primitive option: */
-#define DO_AGGSPLIT_COMBINE(as) (((as)&AGGSPLITOP_COMBINE) != 0)
-#define DO_AGGSPLIT_SKIPFINAL(as) (((as)&AGGSPLITOP_SKIPFINAL) != 0)
-#define DO_AGGSPLIT_SERIALIZE(as) (((as)&AGGSPLITOP_SERIALIZE) != 0)
-#define DO_AGGSPLIT_DESERIALIZE(as) (((as)&AGGSPLITOP_DESERIALIZE) != 0)
-
-/*
- * PGSetOpCmd and PGSetOpStrategy -
- *	  overall semantics and execution strategies for PGSetOp plan nodes
- *
- * This is needed in both plannodes.h and relation.h, so put it here...
- */
-typedef enum PGSetOpCmd {
-	PG_SETOPCMD_INTERSECT,
-	PG_SETOPCMD_INTERSECT_ALL,
-	PG_SETOPCMD_EXCEPT,
-	PG_SETOPCMD_EXCEPT_ALL
-} PGSetOpCmd;
-
-typedef enum PGSetOpStrategy {
-	PG_SETOP_SORTED, /* input must be sorted */
-	PG_SETOP_HASHED  /* use internal hashtable */
-} PGSetOpStrategy;
-
-/*
- * PGOnConflictAction -
- *	  "ON CONFLICT" clause type of query
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGOnConflictAction {
-	PG_ONCONFLICT_NONE,    /* No "ON CONFLICT" clause */
-	PG_ONCONFLICT_NOTHING, /* ON CONFLICT ... DO NOTHING */
-	PG_ONCONFLICT_UPDATE   /* ON CONFLICT ... DO UPDATE */
-} PGOnConflictAction;
-
-/*
- * PGOnConflictActionAlias -
- *	  "INSERT OR [REPLACE|IGNORE]" aliases for OnConflictAction
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGOnConflictActionAlias {
-	PG_ONCONFLICT_ALIAS_NONE,    /* No "OR [IGNORE|REPLACE]" clause */
-	PG_ONCONFLICT_ALIAS_REPLACE, /* INSERT OR REPLACE */
-	PG_ONCONFLICT_ALIAS_IGNORE   /* INSERT OR IGNORE */
-} PGOnConflictActionAlias;
-
-/*
- * PGInsertByNameOrPosition
- *    "INSERT BY [POSITION|NAME]
- */
-typedef enum PGInsertColumnOrder {
-	PG_INSERT_BY_POSITION,    /* INSERT BY POSITION (default behavior) */
-	PG_INSERT_BY_NAME,        /* INSERT BY NAME */
-} PGInsertColumnOrder;
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp b/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp
deleted file mode 100644
index 2fbf2cf75..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp
+++ /dev/null
@@ -1,2242 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * parsenodes.h
- *	  definitions for parse tree nodes
- *
- * Many of the node types used in parsetrees include a "location" field.
- * This is a byte (not character) offset in the original source text, to be
- * used for positioning an error cursor when there is an error related to
- * the node.  Access to the original source text is needed to make use of
- * the location.  At the topmost (statement) level, we also provide a
- * statement length, likewise measured in bytes, for convenience in
- * identifying statement boundaries in multi-statement source strings.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/parsenodes.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "nodes/bitmapset.hpp"
-#include "nodes/lockoptions.hpp"
-#include "nodes/primnodes.hpp"
-#include "nodes/value.hpp"
-
-namespace duckdb_libpgquery {
-
-typedef enum PGOverridingKind {
-	PG_OVERRIDING_NOT_SET = 0,
-	PG_OVERRIDING_USER_VALUE,
-	OVERRIDING_SYSTEM_VALUE
-} PGOverridingKind;
-
-/* Possible sources of a PGQuery */
-typedef enum PGQuerySource {
-	PG_QSRC_ORIGINAL,          /* original parsetree (explicit query) */
-	PG_QSRC_PARSER,            /* added by parse analysis (now unused) */
-	PG_QSRC_INSTEAD_RULE,      /* added by unconditional INSTEAD rule */
-	PG_QSRC_QUAL_INSTEAD_RULE, /* added by conditional INSTEAD rule */
-	QSRC_NON_INSTEAD_RULE      /* added by non-INSTEAD rule */
-} PGQuerySource;
-
-/* PGSort ordering options for ORDER BY and CREATE INDEX */
-typedef enum PGSortByDir {
-	PG_SORTBY_DEFAULT,
-	PG_SORTBY_ASC,
-	PG_SORTBY_DESC,
-	SORTBY_USING /* not allowed in CREATE INDEX ... */
-} PGSortByDir;
-
-/* PGFuncCall options RESPECT/IGNORE NULLS */
-typedef enum PGIgnoreNulls {
-	PG_DEFAULT_NULLS,
-	PG_RESPECT_NULLS,
-	PG_IGNORE_NULLS
-} PGIgnoreNulls;
-
-typedef enum PGSortByNulls { PG_SORTBY_NULLS_DEFAULT, PG_SORTBY_NULLS_FIRST, PG_SORTBY_NULLS_LAST } PGSortByNulls;
-
-/*****************************************************************************
- *	PGQuery Tree
- *****************************************************************************/
-
-/*
- * PGQuery -
- *	  Parse analysis turns all statements into a PGQuery tree
- *	  for further processing by the rewriter and planner.
- *
- *	  Utility statements (i.e. non-optimizable statements) have the
- *	  utilityStmt field set, and the rest of the PGQuery is mostly dummy.
- *
- *	  Planning converts a PGQuery tree into a PGPlan tree headed by a PGPlannedStmt
- *	  node --- the PGQuery structure is not used by the executor.
- */
-typedef struct PGQuery {
-	PGNodeTag type;
-
-	PGCmdType commandType; /* select|insert|update|delete|utility */
-
-	PGQuerySource querySource; /* where did I come from? */
-
-	uint32_t queryId; /* query identifier (can be set by plugins) */
-
-	bool canSetTag; /* do I set the command result tag? */
-
-	PGNode *utilityStmt; /* non-null if commandType == PG_CMD_UTILITY */
-
-	int resultRelation; /* rtable index of target relation for
-								 * INSERT/UPDATE/DELETE; 0 for SELECT */
-
-	bool hasAggs;         /* has aggregates in tlist or havingQual */
-	bool hasWindowFuncs;  /* has window functions in tlist */
-	bool hasTargetSRFs;   /* has set-returning functions in tlist */
-	bool hasSubLinks;     /* has subquery PGSubLink */
-	bool hasDistinctOn;   /* distinctClause is from DISTINCT ON */
-	bool hasRecursive;    /* WITH RECURSIVE was specified */
-	bool hasModifyingCTE; /* has INSERT/UPDATE/DELETE in WITH */
-	bool hasForUpdate;    /* FOR [KEY] UPDATE/SHARE was specified */
-	bool hasRowSecurity;  /* rewriter has applied some RLS policy */
-
-	PGList *cteList; /* WITH list (of CommonTableExpr's) */
-
-	PGList *rtable;       /* list of range table entries */
-	PGFromExpr *jointree; /* table join tree (FROM and WHERE clauses) */
-
-	PGList *targetList; /* target list (of PGTargetEntry) */
-
-	PGOverridingKind override; /* OVERRIDING clause */
-
-	PGOnConflictExpr *onConflict; /* ON CONFLICT DO [NOTHING | UPDATE] */
-
-	PGList *returningList; /* return-values list (of PGTargetEntry) */
-
-	PGList *groupClause; /* a list of SortGroupClause's */
-
-	PGList *groupingSets; /* a list of GroupingSet's if present */
-
-	PGNode *havingQual; /* qualifications applied to groups */
-
-	PGList *windowClause; /* a list of WindowClause's */
-
-	PGList *distinctClause; /* a list of SortGroupClause's */
-
-	PGList *sortClause; /* a list of SortGroupClause's */
-
-	PGNode *limitOffset; /* # of result tuples to skip (int8_t expr) */
-	PGNode *limitCount;  /* # of result tuples to return (int8_t expr) */
-
-	PGList *rowMarks; /* a list of RowMarkClause's */
-
-	PGNode *setOperations; /* set-operation tree if this is top level of
-								 * a UNION/INTERSECT/EXCEPT query */
-
-	PGList *constraintDeps; /* a list of pg_constraint OIDs that the query
-								 * depends on to be semantically valid */
-
-	PGList *withCheckOptions; /* a list of WithCheckOption's, which are
-									 * only added during rewrite and therefore
-									 * are not written out as part of Query. */
-
-	/*
-	 * The following two fields identify the portion of the source text string
-	 * containing this query.  They are typically only populated in top-level
-	 * Queries, not in sub-queries.  When not set, they might both be zero, or
-	 * both be -1 meaning "unknown".
-	 */
-	int stmt_location; /* start location, or -1 if unknown */
-	int stmt_len;      /* length in bytes; 0 means "rest of string" */
-} PGQuery;
-
-/****************************************************************************
- *	Supporting data structures for Parse Trees
- *
- *	Most of these node types appear in raw parsetrees output by the grammar,
- *	and get transformed to something else by the analyzer.  A few of them
- *	are used as-is in transformed querytrees.
- ****************************************************************************/
-
-/*
- * PGTypeName - specifies a type in definitions
- *
- * For PGTypeName structures generated internally, it is often easier to
- * specify the type by OID than by name.  If "names" is NIL then the
- * actual type OID is given by typeOid, otherwise typeOid is unused.
- * Similarly, if "typmods" is NIL then the actual typmod is expected to
- * be prespecified in typemod, otherwise typemod is unused.
- *
- * If pct_type is true, then names is actually a field name and we look up
- * the type of that field.  Otherwise (the normal case), names is a type
- * name possibly qualified with schema and database name.
- */
-typedef struct PGTypeName {
-	PGNodeTag type;
-	PGList *names;       /* qualified name (list of PGValue strings) */
-	PGOid typeOid;       /* type identified by OID */
-	bool setof;          /* is a set? */
-	bool pct_type;       /* %TYPE specified? */
-	PGList *typmods;     /* type modifier expression(s) */
-	int32_t typemod;     /* prespecified type modifier */
-	PGList *arrayBounds; /* array bounds */
-	int location;        /* token location, or -1 if unknown */
-} PGTypeName;
-
-/*
- * PGColumnRef - specifies a reference to a column, or possibly a whole tuple
- *
- * The "fields" list must be nonempty.  It can contain string PGValue nodes
- * (representing names) and PGAStar nodes (representing occurrence of a '*').
- * Currently, PGAStar must appear only as the last list element --- the grammar
- * is responsible for enforcing this!
- *
- * Note: any array subscripting or selection of fields from composite columns
- * is represented by an PGAIndirection node above the ColumnRef.  However,
- * for simplicity in the normal case, initial field selection from a table
- * name is represented within PGColumnRef and not by adding AIndirection.
- */
-typedef struct PGColumnRef {
-	PGNodeTag type;
-	PGList *fields;       /* field names (PGValue strings) or PGAStar */
-	int location;         /* token location, or -1 if unknown */
-} PGColumnRef;
-
-/*
- * PGParamRef - specifies a $n parameter reference
- */
-typedef struct PGParamRef {
-	PGNodeTag type;
-	int number;   /* the number of the parameter */
-	int location; /* token location, or -1 if unknown */
-	char *name; /* optional name of the parameter */
-} PGParamRef;
-
-/*
- * PGAExpr - infix, prefix, and postfix expressions
- */
-typedef enum PGAExpr_Kind {
-	PG_AEXPR_OP,              /* normal operator */
-	PG_AEXPR_OP_ANY,          /* scalar op ANY (array) */
-	PG_AEXPR_OP_ALL,          /* scalar op ALL (array) */
-	PG_AEXPR_DISTINCT,        /* IS DISTINCT FROM - name must be "=" */
-	PG_AEXPR_NOT_DISTINCT,    /* IS NOT DISTINCT FROM - name must be "=" */
-	PG_AEXPR_NULLIF,          /* NULLIF - name must be "=" */
-	PG_AEXPR_OF,              /* IS [NOT] OF - name must be "=" or "<>" */
-	PG_AEXPR_IN,              /* [NOT] IN - name must be "=" or "<>" */
-	PG_AEXPR_LIKE,            /* [NOT] LIKE - name must be "~~" or "!~~" */
-	PG_AEXPR_ILIKE,           /* [NOT] ILIKE - name must be "~~*" or "!~~*" */
-	PG_AEXPR_GLOB,            /* [NOT] GLOB - name must be "~~~" or "!~~~" */
-	PG_AEXPR_SIMILAR,         /* [NOT] SIMILAR - name must be "~" or "!~" */
-	PG_AEXPR_BETWEEN,         /* name must be "BETWEEN" */
-	PG_AEXPR_NOT_BETWEEN,     /* name must be "NOT BETWEEN" */
-	PG_AEXPR_BETWEEN_SYM,     /* name must be "BETWEEN SYMMETRIC" */
-	PG_AEXPR_NOT_BETWEEN_SYM, /* name must be "NOT BETWEEN SYMMETRIC" */
-	AEXPR_PAREN               /* nameless dummy node for parentheses */
-} PGAExpr_Kind;
-
-typedef struct PGAExpr {
-	PGNodeTag type;
-	PGAExpr_Kind kind; /* see above */
-	PGList *name;      /* possibly-qualified name of operator */
-	PGNode *lexpr;     /* left argument, or NULL if none */
-	PGNode *rexpr;     /* right argument, or NULL if none */
-	int location;      /* token location, or -1 if unknown */
-} PGAExpr;
-
-/*
- * PGAConst - a literal constant
- */
-typedef struct PGAConst {
-	PGNodeTag type;
-	PGValue val;  /* value (includes type info, see value.h) */
-	int location; /* token location, or -1 if unknown */
-} PGAConst;
-
-/*
- * PGTypeCast - a CAST expression
- */
-typedef struct PGTypeCast {
-	PGNodeTag type;
-	PGNode *arg;          /* the expression being casted */
-	PGTypeName *typeName; /* the target type */
-	int tryCast;          /* TRY_CAST or CAST */
-	int location;         /* token location, or -1 if unknown */
-} PGTypeCast;
-
-/*
- * PGCollateClause - a COLLATE expression
- */
-typedef struct PGCollateClause {
-	PGNodeTag type;
-	PGNode *arg;      /* input expression */
-	PGList *collname; /* possibly-qualified collation name */
-	int location;     /* token location, or -1 if unknown */
-} PGCollateClause;
-
-/*
- * PGFuncCall - a function or aggregate invocation
- *
- * agg_order (if not NIL) indicates we saw 'foo(... ORDER BY ...)', or if
- * agg_within_group is true, it was 'foo(...) WITHIN GROUP (ORDER BY ...)'.
- * agg_star indicates we saw a 'foo(*)' construct, while agg_distinct
- * indicates we saw 'foo(DISTINCT ...)'.  In any of these cases, the
- * construct *must* be an aggregate call.  Otherwise, it might be either an
- * aggregate or some other kind of function.  However, if FILTER or OVER is
- * present it had better be an aggregate or window function.
- *
- * Normally, you'd initialize this via makeFuncCall() and then only change the
- * parts of the struct its defaults don't match afterwards, as needed.
- */
-typedef struct PGFuncCall {
-	PGNodeTag type;
-	PGList *funcname;         /* qualified name of function */
-	PGList *args;             /* the arguments (list of exprs) */
-	PGList *agg_order;        /* ORDER BY (list of PGSortBy) */
-	PGNode *agg_filter;       /* FILTER clause, if any */
-	bool export_state;        /* EXPORT_STATE clause, if any */
-	bool agg_within_group;    /* ORDER BY appeared in WITHIN GROUP */
-	bool agg_star;            /* argument was really '*' */
-	bool agg_distinct;        /* arguments were labeled DISTINCT */
-	PGIgnoreNulls agg_ignore_nulls; /* arguments were labeled IGNORE NULLS */
-	bool func_variadic;       /* last argument was labeled VARIADIC */
-	struct PGWindowDef *over; /* OVER clause, if any */
-	int location;             /* token location, or -1 if unknown */
-} PGFuncCall;
-
-/*
- * PGAStar - '*' representing all columns of a table or compound field
- *
- * This can appear within ColumnRef.fields, AIndirection.indirection, and
- * ResTarget.indirection lists.
- */
-typedef struct PGAStar {
-	PGNodeTag type;
-	char *relation;       /* relation name (optional) */
-	PGNode *expr;         /* optional: the expression (regex or list) to select columns */
-	PGList *except_list;  /* optional: EXCLUDE list */
-	PGList *replace_list; /* optional: REPLACE list */
-	PGList *rename_list;  /* optional: RENAME list */
-	bool columns;         /* whether or not this is a columns list */
-	bool unpacked;        /* whether or not the columns list is unpacked */
-	int location;
-} PGAStar;
-
-/*
- * PGAIndices - array subscript or slice bounds ([idx] or [lidx:uidx])
- *
- * In slice case, either or both of lidx and uidx can be NULL (omitted).
- * In non-slice case, uidx holds the single subscript and lidx is always NULL.
- */
-typedef struct PGAIndices {
-	PGNodeTag type;
-	bool is_slice; /* true if slice (i.e., colon present) */
-	PGNode *lidx;  /* slice lower bound, if any */
-	PGNode *uidx;  /* subscript, or slice upper bound if any */
-	PGNode *step;  /* slice step, if any */
-} PGAIndices;
-
-/*
- * PGAIndirection - select a field and/or array element from an expression
- *
- * The indirection list can contain PGAIndices nodes (representing
- * subscripting), string PGValue nodes (representing field selection --- the
- * string value is the name of the field to select), and PGAStar nodes
- * (representing selection of all fields of a composite type).
- * For example, a complex selection operation like
- *				(foo).field1[42][7].field2
- * would be represented with a single PGAIndirection node having a 4-element
- * indirection list.
- *
- * Currently, PGAStar must appear only as the last list element --- the grammar
- * is responsible for enforcing this!
- */
-typedef struct PGAIndirection {
-	PGNodeTag type;
-	PGNode *arg;         /* the thing being selected from */
-	PGList *indirection; /* subscripts and/or field names and/or * */
-} PGAIndirection;
-
-/*
- * PGAArrayExpr - an ARRAY[] construct
- */
-typedef struct PGAArrayExpr {
-	PGNodeTag type;
-	PGList *elements; /* array element expressions */
-	int location;     /* token location, or -1 if unknown */
-} PGAArrayExpr;
-
-/*
- * PGResTarget -
- *	  result target (used in target list of pre-transformed parse trees)
- *
- * In a SELECT target list, 'name' is the column label from an
- * 'AS ColumnLabel' clause, or NULL if there was none, and 'val' is the
- * value expression itself.  The 'indirection' field is not used.
- *
- * INSERT uses PGResTarget in its target-column-names list.  Here, 'name' is
- * the name of the destination column, 'indirection' stores any subscripts
- * attached to the destination, and 'val' is not used.
- *
- * In an UPDATE target list, 'name' is the name of the destination column,
- * 'indirection' stores any subscripts attached to the destination, and
- * 'val' is the expression to assign.
- *
- * See PGAIndirection for more info about what can appear in 'indirection'.
- */
-typedef struct PGResTarget {
-	PGNodeTag type;
-	char *name;          /* column name or NULL */
-	PGList *indirection; /* subscripts, field names, and '*', or NIL */
-	PGNode *val;         /* the value expression to compute or assign */
-	int location;        /* token location, or -1 if unknown */
-} PGResTarget;
-
-/*
- * PGMultiAssignRef - element of a row source expression for UPDATE
- *
- * In an UPDATE target list, when we have SET (a,b,c) = row-valued-expression,
- * we generate separate PGResTarget items for each of a,b,c.  Their "val" trees
- * are PGMultiAssignRef nodes numbered 1..n, linking to a common copy of the
- * row-valued-expression (which parse analysis will process only once, when
- * handling the PGMultiAssignRef with colno=1).
- */
-typedef struct PGMultiAssignRef {
-	PGNodeTag type;
-	PGNode *source; /* the row-valued expression */
-	int colno;      /* column number for this target (1..n) */
-	int ncolumns;   /* number of targets in the construct */
-} PGMultiAssignRef;
-
-/*
- * PGSortBy - for ORDER BY clause
- */
-typedef struct PGSortBy {
-	PGNodeTag type;
-	PGNode *node;               /* expression to sort on */
-	PGSortByDir sortby_dir;     /* ASC/DESC/USING/default */
-	PGSortByNulls sortby_nulls; /* NULLS FIRST/LAST */
-	PGList *useOp;              /* name of op to use, if SORTBY_USING */
-	int location;               /* operator location, or -1 if none/unknown */
-} PGSortBy;
-
-/*
- * PGWindowDef - raw representation of WINDOW and OVER clauses
- *
- * For entries in a WINDOW list, "name" is the window name being defined.
- * For OVER clauses, we use "name" for the "OVER window" syntax, or "refname"
- * for the "OVER (window)" syntax, which is subtly different --- the latter
- * implies overriding the window frame clause.
- */
-typedef struct PGWindowDef {
-	PGNodeTag type;
-	char *name;              /* window's own name */
-	char *refname;           /* referenced window name, if any */
-	PGList *partitionClause; /* PARTITION BY expression list */
-	PGList *orderClause;     /* ORDER BY (list of PGSortBy) */
-	int frameOptions;        /* frame_clause options, see below */
-	PGNode *startOffset;     /* expression for starting bound, if any */
-	PGNode *endOffset;       /* expression for ending bound, if any */
-	int location;            /* parse location, or -1 if none/unknown */
-} PGWindowDef;
-
-/*
- * frameOptions is an OR of these bits.  The NONDEFAULT and BETWEEN bits are
- * used so that ruleutils.c can tell which properties were specified and
- * which were defaulted; the correct behavioral bits must be set either way.
- * The START_foo and END_foo options must come in pairs of adjacent bits for
- * the convenience of gram.y, even though some of them are useless/invalid.
- */
-#define FRAMEOPTION_NONDEFAULT					0x00001 /* any specified? */
-#define FRAMEOPTION_RANGE						0x00002 /* RANGE behavior */
-#define FRAMEOPTION_ROWS						0x00004 /* ROWS behavior */
-#define FRAMEOPTION_GROUPS						0x00008 /* GROUPS behavior */
-#define FRAMEOPTION_BETWEEN						0x00010 /* BETWEEN given? */
-#define FRAMEOPTION_START_UNBOUNDED_PRECEDING	0x00020 /* start is U. P. */
-#define FRAMEOPTION_END_UNBOUNDED_PRECEDING		0x00040 /* (disallowed) */
-#define FRAMEOPTION_START_UNBOUNDED_FOLLOWING	0x00080 /* (disallowed) */
-#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING		0x00100 /* end is U. F. */
-#define FRAMEOPTION_START_CURRENT_ROW			0x00200 /* start is C. R. */
-#define FRAMEOPTION_END_CURRENT_ROW				0x00400 /* end is C. R. */
-#define FRAMEOPTION_START_OFFSET_PRECEDING		0x00800 /* start is O. P. */
-#define FRAMEOPTION_END_OFFSET_PRECEDING		0x01000 /* end is O. P. */
-#define FRAMEOPTION_START_OFFSET_FOLLOWING		0x02000 /* start is O. F. */
-#define FRAMEOPTION_END_OFFSET_FOLLOWING		0x04000 /* end is O. F. */
-#define FRAMEOPTION_EXCLUDE_CURRENT_ROW			0x08000 /* omit C.R. */
-#define FRAMEOPTION_EXCLUDE_GROUP				0x10000 /* omit C.R. & peers */
-#define FRAMEOPTION_EXCLUDE_TIES				0x20000 /* omit C.R.'s peers */
-
-#define FRAMEOPTION_START_OFFSET \
-	(FRAMEOPTION_START_OFFSET_PRECEDING | FRAMEOPTION_START_OFFSET_FOLLOWING)
-#define FRAMEOPTION_END_OFFSET \
-	(FRAMEOPTION_END_OFFSET_PRECEDING | FRAMEOPTION_END_OFFSET_FOLLOWING)
-#define FRAMEOPTION_EXCLUSION \
-	(FRAMEOPTION_EXCLUDE_CURRENT_ROW | FRAMEOPTION_EXCLUDE_GROUP | \
-	 FRAMEOPTION_EXCLUDE_TIES)
-
-#define FRAMEOPTION_DEFAULTS \
-	(FRAMEOPTION_RANGE | FRAMEOPTION_START_UNBOUNDED_PRECEDING | \
-	 FRAMEOPTION_END_CURRENT_ROW)
-
-/*
- * PGRangeSubselect - subquery appearing in a FROM clause
- */
-typedef struct PGRangeSubselect {
-	PGNodeTag type;
-	bool lateral;     /* does it have LATERAL prefix? */
-	PGNode *subquery; /* the untransformed sub-select clause */
-	PGAlias *alias;   /* table alias & optional column aliases */
-	PGNode *sample;   /* sample options (if any) */
-} PGRangeSubselect;
-
-/*
- * PGRangeFunction - function call appearing in a FROM clause
- *
- * functions is a PGList because we use this to represent the construct
- * ROWS FROM(func1(...), func2(...), ...).  Each element of this list is a
- * two-element sublist, the first element being the untransformed function
- * call tree, and the second element being a possibly-empty list of PGColumnDef
- * nodes representing any columndef list attached to that function within the
- * ROWS FROM() syntax.
- *
- * alias and coldeflist represent any alias and/or columndef list attached
- * at the top level.  (We disallow coldeflist appearing both here and
- * per-function, but that's checked in parse analysis, not by the grammar.)
- */
-typedef struct PGRangeFunction {
-	PGNodeTag type;
-	bool lateral;       /* does it have LATERAL prefix? */
-	bool ordinality;    /* does it have WITH ORDINALITY suffix? */
-	bool is_rowsfrom;   /* is result of ROWS FROM() syntax? */
-	PGList *functions;  /* per-function information, see above */
-	PGAlias *alias;     /* table alias & optional column aliases */
-	PGList *coldeflist; /* list of PGColumnDef nodes to describe result
-								 * of function returning RECORD */
-	PGNode *sample;   /* sample options (if any) */
-} PGRangeFunction;
-
-/* Category of the column */
-typedef enum ColumnCategory {
-	COL_STANDARD,	/* regular column */
-	COL_GENERATED	/* generated (VIRTUAL|STORED) */
-}	ColumnCategory;
-
-/*
- * PGColumnDef - column definition (used in various creates)
- *
- * If the column has a default value, we may have the value expression
- * in either "raw" form (an untransformed parse tree) or "cooked" form
- * (a post-parse-analysis, executable expression tree), depending on
- * how this PGColumnDef node was created (by parsing, or by inheritance
- * from an existing relation).  We should never have both in the same node!
- *
- * Similarly, we may have a COLLATE specification in either raw form
- * (represented as a PGCollateClause with arg==NULL) or cooked form
- * (the collation's OID).
- *
- * The constraints list may contain a PG_CONSTR_DEFAULT item in a raw
- * parsetree produced by gram.y, but transformCreateStmt will remove
- * the item and set raw_default instead.  PG_CONSTR_DEFAULT items
- * should not appear in any subsequent processing.
- */
-
-typedef struct PGColumnDef {
-	PGNodeTag type;               /* ENSURES COMPATIBILITY WITH 'PGNode' - has to be first line */
-	char *colname;                /* name of column */
-	PGTypeName *typeName;         /* type of column */
-	int inhcount;                 /* number of times column is inherited */
-	bool is_local;                /* column has local (non-inherited) def'n */
-	bool is_not_null;             /* NOT NULL constraint specified? */
-	bool is_from_type;            /* column definition came from table type */
-	bool is_from_parent;          /* column def came from partition parent */
-	char storage;                 /* attstorage setting, or 0 for default */
-	PGNode *raw_default;          /* default value (untransformed parse tree) */
-	PGNode *cooked_default;       /* default value (transformed expr tree) */
-	char identity;                /* attidentity setting */
-	PGRangeVar *identitySequence; /* to store identity sequence name for ALTER
-								   * TABLE ... ADD COLUMN */
-	PGCollateClause *collClause;  /* untransformed COLLATE spec, if any */
-	PGOid collOid;                /* collation OID (InvalidOid if not set) */
-	PGList *constraints;          /* other constraints on column */
-	PGList *fdwoptions;           /* per-column FDW options */
-	int location;                 /* parse location, or -1 if none/unknown */
-	ColumnCategory category;	  /* category of the column */
-} PGColumnDef;
-
-/*
- * PGTableLikeClause - CREATE TABLE ( ... LIKE ... ) clause
- */
-typedef struct PGTableLikeClause {
-	PGNodeTag type;
-	PGRangeVar *relation;
-	uint32_t options; /* OR of PGTableLikeOption flags */
-} PGTableLikeClause;
-
-typedef enum PGTableLikeOption {
-	PG_CREATE_TABLE_LIKE_DEFAULTS = 1 << 0,
-	PG_CREATE_TABLE_LIKE_CONSTRAINTS = 1 << 1,
-	PG_CREATE_TABLE_LIKE_IDENTITY = 1 << 2,
-	PG_CREATE_TABLE_LIKE_INDEXES = 1 << 3,
-	PG_CREATE_TABLE_LIKE_STORAGE = 1 << 4,
-	PG_CREATE_TABLE_LIKE_COMMENTS = 1 << 5,
-	PG_CREATE_TABLE_LIKE_STATISTICS = 1 << 6,
-	PG_CREATE_TABLE_LIKE_ALL = INT_MAX
-} PGTableLikeOption;
-
-/*
- * PGIndexElem - index parameters (used in CREATE INDEX, and in ON CONFLICT)
- *
- * For a plain index attribute, 'name' is the name of the table column to
- * index, and 'expr' is NULL.  For an index expression, 'name' is NULL and
- * 'expr' is the expression tree.
- */
-typedef struct PGIndexElem {
-	PGNodeTag type;
-	char *name;                   /* name of attribute to index, or NULL */
-	PGNode *expr;                 /* expression to index, or NULL */
-	char *indexcolname;           /* name for index column; NULL = default */
-	PGList *collation;            /* name of collation; NIL = default */
-	PGList *opclass;              /* name of desired opclass; NIL = default */
-	PGSortByDir ordering;         /* ASC/DESC/default */
-	PGSortByNulls nulls_ordering; /* FIRST/LAST/default */
-} PGIndexElem;
-
-/*
- * PGDefElem - a generic "name = value" option definition
- *
- * In some contexts the name can be qualified.  Also, certain SQL commands
- * allow a SET/ADD/DROP action to be attached to option settings, so it's
- * convenient to carry a field for that too.  (Note: currently, it is our
- * practice that the grammar allows namespace and action only in statements
- * where they are relevant; C code can just ignore those fields in other
- * statements.)
- */
-typedef enum PGDefElemAction {
-	PG_DEFELEM_UNSPEC, /* no action given */
-	PG_DEFELEM_SET,
-	PG_DEFELEM_ADD,
-	DEFELEM_DROP
-} PGDefElemAction;
-
-typedef struct PGDefElem {
-	PGNodeTag type;
-	char *defnamespace; /* NULL if unqualified name */
-	char *defname;
-	PGNode *arg;               /* a (PGValue *) or a (PGTypeName *) */
-	PGDefElemAction defaction; /* unspecified action, or SET/ADD/DROP */
-	int location;              /* token location, or -1 if unknown */
-} PGDefElem;
-
-/*
- * PGLockingClause - raw representation of FOR [NO KEY] UPDATE/[KEY] SHARE
- *		options
- *
- * Note: lockedRels == NIL means "all relations in query".  Otherwise it
- * is a list of PGRangeVar nodes.  (We use PGRangeVar mainly because it carries
- * a location field --- currently, parse analysis insists on unqualified
- * names in LockingClause.)
- */
-typedef struct PGLockingClause {
-	PGNodeTag type;
-	PGList *lockedRels; /* FOR [KEY] UPDATE/SHARE relations */
-	PGLockClauseStrength strength;
-	PGLockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED */
-} PGLockingClause;
-
-/****************************************************************************
- *	Nodes for a PGQuery tree
- ****************************************************************************/
-
-/*--------------------
- * PGRangeTblEntry -
- *	  A range table is a PGList of PGRangeTblEntry nodes.
- *
- *	  A range table entry may represent a plain relation, a sub-select in
- *	  FROM, or the result of a JOIN clause.  (Only explicit JOIN syntax
- *	  produces an RTE, not the implicit join resulting from multiple FROM
- *	  items.  This is because we only need the RTE to deal with SQL features
- *	  like outer joins and join-output-column aliasing.)  Other special
- *	  RTE types also exist, as indicated by RTEKind.
- *
- *	  Note that we consider PG_RTE_RELATION to cover anything that has a pg_class
- *	  entry.  relkind distinguishes the sub-cases.
- *
- *	  alias is an PGAlias node representing the AS alias-clause attached to the
- *	  FROM expression, or NULL if no clause.
- *
- *	  eref is the table reference name and column reference names (either
- *	  real or aliases).  Note that system columns (OID etc) are not included
- *	  in the column list.
- *	  eref->aliasname is required to be present, and should generally be used
- *	  to identify the RTE for error messages etc.
- *
- *	  In RELATION RTEs, the colnames in both alias and eref are indexed by
- *	  physical attribute number; this means there must be colname entries for
- *	  dropped columns.  When building an RTE we insert empty strings ("") for
- *	  dropped columns.  Note however that a stored rule may have nonempty
- *	  colnames for columns dropped since the rule was created (and for that
- *	  matter the colnames might be out of date due to column renamings).
- *	  The same comments apply to FUNCTION RTEs when a function's return type
- *	  is a named composite type.
- *
- *	  In JOIN RTEs, the colnames in both alias and eref are one-to-one with
- *	  joinaliasvars entries.  A JOIN RTE will omit columns of its inputs when
- *	  those columns are known to be dropped at parse time.  Again, however,
- *	  a stored rule might contain entries for columns dropped since the rule
- *	  was created.  (This is only possible for columns not actually referenced
- *	  in the rule.)  When loading a stored rule, we replace the joinaliasvars
- *	  items for any such columns with null pointers.  (We can't simply delete
- *	  them from the joinaliasvars list, because that would affect the attnums
- *	  of Vars referencing the rest of the list.)
- *
- *	  inh is true for relation references that should be expanded to include
- *	  inheritance children, if the rel has any.  This *must* be false for
- *	  RTEs other than PG_RTE_RELATION entries.
- *
- *	  inFromCl marks those range variables that are listed in the FROM clause.
- *	  It's false for RTEs that are added to a query behind the scenes, such
- *	  as the NEW and OLD variables for a rule, or the subqueries of a UNION.
- *	  This flag is not used anymore during parsing, since the parser now uses
- *	  a separate "namespace" data structure to control visibility, but it is
- *	  needed by ruleutils.c to determine whether RTEs should be shown in
- *	  decompiled queries.
- *--------------------
- */
-typedef enum PGRTEKind {
-	PG_RTE_RELATION,    /* ordinary relation reference */
-	PG_RTE_SUBQUERY,    /* subquery in FROM */
-	PG_RTE_JOIN,        /* join */
-	PG_RTE_FUNCTION,    /* function in FROM */
-	PG_RTE_TABLEFUNC,   /* TableFunc(.., column list) */
-	PG_RTE_VALUES,      /* VALUES (<exprlist>), (<exprlist>), ... */
-	PG_RTE_CTE,         /* common table expr (WITH list element) */
-	RTE_NAMEDTUPLESTORE /* tuplestore, e.g. for AFTER triggers */
-} PGRTEKind;
-
-typedef struct PGRangeTblEntry {
-	PGNodeTag type;
-
-	PGRTEKind rtekind; /* see above */
-
-	/*
-	 * XXX the fields applicable to only some rte kinds should be merged into
-	 * a union.  I didn't do this yet because the diffs would impact a lot of
-	 * code that is being actively worked on.  FIXME someday.
-	 */
-
-	/*
-	 * Fields valid for a plain relation RTE (else zero):
-	 *
-	 * As a special case, RTE_NAMEDTUPLESTORE can also set relid to indicate
-	 * that the tuple format of the tuplestore is the same as the referenced
-	 * relation.  This allows plans referencing AFTER trigger transition
-	 * tables to be invalidated if the underlying table is altered.
-	 */
-	PGOid relid;                             /* OID of the relation */
-	char relkind;                            /* relation kind (see pg_class.relkind) */
-	struct PGTableSampleClause *tablesample; /* sampling info, or NULL */
-
-	/*
-	 * Fields valid for a subquery RTE (else NULL):
-	 */
-	PGQuery *subquery; /* the sub-query */
-
-	/*
-	 * Fields valid for a join RTE (else NULL/zero):
-	 *
-	 * joinaliasvars is a list of (usually) Vars corresponding to the columns
-	 * of the join result.  An alias PGVar referencing column K of the join
-	 * result can be replaced by the K'th element of joinaliasvars --- but to
-	 * simplify the task of reverse-listing aliases correctly, we do not do
-	 * that until planning time.  In detail: an element of joinaliasvars can
-	 * be a PGVar of one of the join's input relations, or such a PGVar with an
-	 * implicit coercion to the join's output column type, or a COALESCE
-	 * expression containing the two input column Vars (possibly coerced).
-	 * Within a PGQuery loaded from a stored rule, it is also possible for
-	 * joinaliasvars items to be null pointers, which are placeholders for
-	 * (necessarily unreferenced) columns dropped since the rule was made.
-	 * Also, once planning begins, joinaliasvars items can be almost anything,
-	 * as a result of subquery-flattening substitutions.
-	 */
-	PGJoinType jointype;   /* type of join */
-	PGList *joinaliasvars; /* list of alias-var expansions */
-
-	/*
-	 * Fields valid for a function RTE (else NIL/zero):
-	 *
-	 * When funcordinality is true, the eref->colnames list includes an alias
-	 * for the ordinality column.  The ordinality column is otherwise
-	 * implicit, and must be accounted for "by hand" in places such as
-	 * expandRTE().
-	 */
-	PGList *functions;   /* list of PGRangeTblFunction nodes */
-	bool funcordinality; /* is this called WITH ORDINALITY? */
-
-	/*
-	 * Fields valid for a PGTableFunc RTE (else NULL):
-	 */
-	PGTableFunc *tablefunc;
-
-	/*
-	 * Fields valid for a values RTE (else NIL):
-	 */
-	PGList *values_lists; /* list of expression lists */
-
-	/*
-	 * Fields valid for a CTE RTE (else NULL/zero):
-	 */
-	char *ctename;       /* name of the WITH list item */
-	PGIndex ctelevelsup; /* number of query levels up */
-	bool self_reference; /* is this a recursive self-reference? */
-
-	/*
-	 * Fields valid for table functions, values, CTE and ENR RTEs (else NIL):
-	 *
-	 * We need these for CTE RTEs so that the types of self-referential
-	 * columns are well-defined.  For VALUES RTEs, storing these explicitly
-	 * saves having to re-determine the info by scanning the values_lists. For
-	 * ENRs, we store the types explicitly here (we could get the information
-	 * from the catalogs if 'relid' was supplied, but we'd still need these
-	 * for TupleDesc-based ENRs, so we might as well always store the type
-	 * info here).
-	 *
-	 * For ENRs only, we have to consider the possibility of dropped columns.
-	 * A dropped column is included in these lists, but it will have zeroes in
-	 * all three lists (as well as an empty-string entry in eref).  Testing
-	 * for zero coltype is the standard way to detect a dropped column.
-	 */
-	PGList *coltypes;      /* OID list of column type OIDs */
-	PGList *coltypmods;    /* integer list of column typmods */
-	PGList *colcollations; /* OID list of column collation OIDs */
-
-	/*
-	 * Fields valid for ENR RTEs (else NULL/zero):
-	 */
-	char *enrname;    /* name of ephemeral named relation */
-	double enrtuples; /* estimated or actual from caller */
-
-	/*
-	 * Fields valid in all RTEs:
-	 */
-	PGAlias *alias; /* user-written alias clause, if any */
-	PGAlias *eref;  /* expanded reference names */
-	bool lateral;   /* subquery, function, or values is LATERAL? */
-	bool inh;       /* inheritance requested? */
-	bool inFromCl;  /* present in FROM clause? */
-} PGRangeTblEntry;
-
-/*
- * PGRangeTblFunction -
- *	  PGRangeTblEntry subsidiary data for one function in a FUNCTION RTE.
- *
- * If the function had a column definition list (required for an
- * otherwise-unspecified RECORD result), funccolnames lists the names given
- * in the definition list, funccoltypes lists their declared column types,
- * funccoltypmods lists their typmods, funccolcollations their collations.
- * Otherwise, those fields are NIL.
- *
- * Notice we don't attempt to store info about the results of functions
- * returning named composite types, because those can change from time to
- * time.  We do however remember how many columns we thought the type had
- * (including dropped columns!), so that we can successfully ignore any
- * columns added after the query was parsed.
- */
-typedef struct PGRangeTblFunction {
-	PGNodeTag type;
-
-	PGNode *funcexpr; /* expression tree for func call */
-	int funccolcount; /* number of columns it contributes to RTE */
-	/* These fields record the contents of a column definition list, if any: */
-	PGList *funccolnames;      /* column names (list of String) */
-	PGList *funccoltypes;      /* OID list of column type OIDs */
-	PGList *funccoltypmods;    /* integer list of column typmods */
-	PGList *funccolcollations; /* OID list of column collation OIDs */
-	/* This is set during planning for use by the executor: */
-	PGBitmapset *funcparams; /* PG_PARAM_EXEC PGParam IDs affecting this func */
-} PGRangeTblFunction;
-
-/*
- * PGSortGroupClause -
- *		representation of ORDER BY, GROUP BY, PARTITION BY,
- *		DISTINCT, DISTINCT ON items
- *
- * You might think that ORDER BY is only interested in defining ordering,
- * and GROUP/DISTINCT are only interested in defining equality.  However,
- * one way to implement grouping is to sort and then apply a "uniq"-like
- * filter.  So it's also interesting to keep track of possible sort operators
- * for GROUP/DISTINCT, and in particular to try to sort for the grouping
- * in a way that will also yield a requested ORDER BY ordering.  So we need
- * to be able to compare ORDER BY and GROUP/DISTINCT lists, which motivates
- * the decision to give them the same representation.
- *
- * tleSortGroupRef must match ressortgroupref of exactly one entry of the
- *		query's targetlist; that is the expression to be sorted or grouped by.
- * eqop is the OID of the equality operator.
- * sortop is the OID of the ordering operator (a "<" or ">" operator),
- *		or InvalidOid if not available.
- * nulls_first means about what you'd expect.  If sortop is InvalidOid
- *		then nulls_first is meaningless and should be set to false.
- * hashable is true if eqop is hashable (note this condition also depends
- *		on the datatype of the input expression).
- *
- * In an ORDER BY item, all fields must be valid.  (The eqop isn't essential
- * here, but it's cheap to get it along with the sortop, and requiring it
- * to be valid eases comparisons to grouping items.)  Note that this isn't
- * actually enough information to determine an ordering: if the sortop is
- * collation-sensitive, a collation OID is needed too.  We don't store the
- * collation in PGSortGroupClause because it's not available at the time the
- * parser builds the PGSortGroupClause; instead, consult the exposed collation
- * of the referenced targetlist expression to find out what it is.
- *
- * In a grouping item, eqop must be valid.  If the eqop is a btree equality
- * operator, then sortop should be set to a compatible ordering operator.
- * We prefer to set eqop/sortop/nulls_first to match any ORDER BY item that
- * the query presents for the same tlist item.  If there is none, we just
- * use the default ordering op for the datatype.
- *
- * If the tlist item's type has a hash opclass but no btree opclass, then
- * we will set eqop to the hash equality operator, sortop to InvalidOid,
- * and nulls_first to false.  A grouping item of this kind can only be
- * implemented by hashing, and of course it'll never match an ORDER BY item.
- *
- * The hashable flag is provided since we generally have the requisite
- * information readily available when the PGSortGroupClause is constructed,
- * and it's relatively expensive to get it again later.  Note there is no
- * need for a "sortable" flag since OidIsValid(sortop) serves the purpose.
- *
- * A query might have both ORDER BY and DISTINCT (or DISTINCT ON) clauses.
- * In SELECT DISTINCT, the distinctClause list is as long or longer than the
- * sortClause list, while in SELECT DISTINCT ON it's typically shorter.
- * The two lists must match up to the end of the shorter one --- the parser
- * rearranges the distinctClause if necessary to make this true.  (This
- * restriction ensures that only one sort step is needed to both satisfy the
- * ORDER BY and set up for the PGUnique step.  This is semantically necessary
- * for DISTINCT ON, and presents no real drawback for DISTINCT.)
- */
-typedef struct PGSortGroupClause {
-	PGNodeTag type;
-	PGIndex tleSortGroupRef; /* reference into targetlist */
-	PGOid eqop;              /* the equality operator ('=' op) */
-	PGOid sortop;            /* the ordering operator ('<' op), or 0 */
-	bool nulls_first;        /* do NULLs come before normal values? */
-	bool hashable;           /* can eqop be implemented by hashing? */
-} PGSortGroupClause;
-
-/*
- * PGGroupingSet -
- *		representation of CUBE, ROLLUP and GROUPING SETS clauses
- *
- * In a PGQuery with grouping sets, the groupClause contains a flat list of
- * PGSortGroupClause nodes for each distinct expression used.  The actual
- * structure of the GROUP BY clause is given by the groupingSets tree.
- *
- * In the raw parser output, PGGroupingSet nodes (of all types except SIMPLE
- * which is not used) are potentially mixed in with the expressions in the
- * groupClause of the SelectStmt.  (An expression can't contain a PGGroupingSet,
- * but a list may mix PGGroupingSet and expression nodes.)  At this stage, the
- * content of each node is a list of expressions, some of which may be RowExprs
- * which represent sublists rather than actual row constructors, and nested
- * PGGroupingSet nodes where legal in the grammar.  The structure directly
- * reflects the query syntax.
- *
- * In parse analysis, the transformed expressions are used to build the tlist
- * and groupClause list (of PGSortGroupClause nodes), and the groupingSets tree
- * is eventually reduced to a fixed format:
- *
- * EMPTY nodes represent (), and obviously have no content
- *
- * SIMPLE nodes represent a list of one or more expressions to be treated as an
- * atom by the enclosing structure; the content is an integer list of
- * ressortgroupref values (see PGSortGroupClause)
- *
- * CUBE and ROLLUP nodes contain a list of one or more SIMPLE nodes.
- *
- * SETS nodes contain a list of EMPTY, SIMPLE, CUBE or ROLLUP nodes, but after
- * parse analysis they cannot contain more SETS nodes; enough of the syntactic
- * transforms of the spec have been applied that we no longer have arbitrarily
- * deep nesting (though we still preserve the use of cube/rollup).
- *
- * Note that if the groupingSets tree contains no SIMPLE nodes (only EMPTY
- * nodes at the leaves), then the groupClause will be empty, but this is still
- * an aggregation query (similar to using aggs or HAVING without GROUP BY).
- *
- * As an example, the following clause:
- *
- * GROUP BY GROUPING SETS ((a,b), CUBE(c,(d,e)))
- *
- * looks like this after raw parsing:
- *
- * SETS( RowExpr(a,b) , CUBE( c, RowExpr(d,e) ) )
- *
- * and parse analysis converts it to:
- *
- * SETS( SIMPLE(1,2), CUBE( SIMPLE(3), SIMPLE(4,5) ) )
- */
-typedef enum {
-	GROUPING_SET_EMPTY,
-	GROUPING_SET_SIMPLE,
-	GROUPING_SET_ROLLUP,
-	GROUPING_SET_CUBE,
-	GROUPING_SET_SETS,
-	GROUPING_SET_ALL
-} GroupingSetKind;
-
-typedef struct PGGroupingSet {
-	PGNodeTag type;
-	GroupingSetKind kind;
-	PGList *content;
-	int location;
-} PGGroupingSet;
-
-/*
- * PGWindowClause -
- *		transformed representation of WINDOW and OVER clauses
- *
- * A parsed Query's windowClause list contains these structs.  "name" is set
- * if the clause originally came from WINDOW, and is NULL if it originally
- * was an OVER clause (but note that we collapse out duplicate OVERs).
- * partitionClause and orderClause are lists of PGSortGroupClause structs.
- * winref is an ID number referenced by PGWindowFunc nodes; it must be unique
- * among the members of a Query's windowClause list.
- * When refname isn't null, the partitionClause is always copied from there;
- * the orderClause might or might not be copied (see copiedOrder); the framing
- * options are never copied, per spec.
- */
-typedef struct PGWindowClause {
-	PGNodeTag type;
-	char *name;              /* window name (NULL in an OVER clause) */
-	char *refname;           /* referenced window name, if any */
-	PGList *partitionClause; /* PARTITION BY list */
-	PGList *orderClause;     /* ORDER BY list */
-	int frameOptions;        /* frame_clause options, see PGWindowDef */
-	PGNode *startOffset;     /* expression for starting bound, if any */
-	PGNode *endOffset;       /* expression for ending bound, if any */
-	PGIndex winref;          /* ID referenced by window functions */
-	bool copiedOrder;        /* did we copy orderClause from refname? */
-} PGWindowClause;
-
-/*
- * RowMarkClause -
- *	   parser output representation of FOR [KEY] UPDATE/SHARE clauses
- *
- * Query.rowMarks contains a separate RowMarkClause node for each relation
- * identified as a FOR [KEY] UPDATE/SHARE target.  If one of these clauses
- * is applied to a subquery, we generate RowMarkClauses for all normal and
- * subquery rels in the subquery, but they are marked pushedDown = true to
- * distinguish them from clauses that were explicitly written at this query
- * level.  Also, Query.hasForUpdate tells whether there were explicit FOR
- * UPDATE/SHARE/KEY SHARE clauses in the current query level.
- */
-
-/*
- * PGWithClause -
- *	   representation of WITH clause
- *
- * Note: PGWithClause does not propagate into the PGQuery representation;
- * but PGCommonTableExpr does.
- */
-typedef struct PGWithClause {
-	PGNodeTag type;
-	PGList *ctes;   /* list of CommonTableExprs */
-	bool recursive; /* true = WITH RECURSIVE */
-	int location;   /* token location, or -1 if unknown */
-} PGWithClause;
-
-/*
- * PGInferClause -
- *		ON CONFLICT unique index inference clause
- *
- * Note: PGInferClause does not propagate into the PGQuery representation.
- */
-typedef struct PGInferClause {
-	PGNodeTag type;
-	PGList *indexElems;  /* IndexElems to infer unique index */
-	PGNode *whereClause; /* qualification (partial-index predicate) */
-	char *conname;       /* PGConstraint name, or NULL if unnamed */
-	int location;        /* token location, or -1 if unknown */
-} PGInferClause;
-
-/*
- * PGOnConflictClause -
- *		representation of ON CONFLICT clause
- *
- * Note: PGOnConflictClause does not propagate into the PGQuery representation.
- */
-typedef struct PGOnConflictClause {
-	PGNodeTag type;
-	PGOnConflictAction action;               /* DO NOTHING or UPDATE? */
-	PGInferClause *infer;                    /* Optional index inference clause */
-	PGList *targetList;                      /* the target list (of PGResTarget) */
-	PGNode *whereClause;                     /* qualifications */
-	int location;                            /* token location, or -1 if unknown */
-} PGOnConflictClause;
-
-/*
- * PGCommonTableExpr -
- *	   representation of WITH list element
- *
- * We don't currently support the SEARCH or CYCLE clause.
- */
-
-typedef enum PGCTEMaterialize
-{
-	PGCTEMaterializeDefault,		/* no option specified */
-	PGCTEMaterializeAlways,		/* MATERIALIZED */
-	PGCTEMaterializeNever			/* NOT MATERIALIZED */
-} PGCTEMaterialize;
-
-typedef struct PGCommonTableExpr {
-	PGNodeTag type;
-	char *ctename;         /* query name (never qualified) */
-	PGList *aliascolnames; /* optional list of column names */
-	PGCTEMaterialize ctematerialized; /* is this an optimization fence? */
-	/* SelectStmt/InsertStmt/etc before parse analysis, PGQuery afterwards: */
-	PGNode *ctequery; /* the CTE's subquery */
-	int location;     /* token location, or -1 if unknown */
-	/* These fields are set during parse analysis: */
-	bool cterecursive;        /* is this CTE actually recursive? */
-	int cterefcount;          /* number of RTEs referencing this CTE
-								 * (excluding internal self-references) */
-	PGList *ctecolnames;      /* list of output column names */
-	PGList *ctecoltypes;      /* OID list of output column type OIDs */
-	PGList *ctecoltypmods;    /* integer list of output column typmods */
-	PGList *ctecolcollations; /* OID list of column collation OIDs */
-} PGCommonTableExpr;
-
-/* Convenience macro to get the output tlist of a CTE's query */
-#define GetCTETargetList(cte) \
-	(AssertMacro(IsA((cte)->ctequery, PGQuery)), ((PGQuery *)(cte)->ctequery)->commandType == PG_CMD_SELECT ? ((PGQuery *)(cte)->ctequery)->targetList : ((PGQuery *)(cte)->ctequery)->returningList)
-
-/*
- * TriggerTransition -
- *	   representation of transition row or table naming clause
- *
- * Only transition tables are initially supported in the syntax, and only for
- * AFTER triggers, but other permutations are accepted by the parser so we can
- * give a meaningful message from C code.
- */
-
-/*****************************************************************************
- *		Raw Grammar Output Statements
- *****************************************************************************/
-
-/*
- *		PGRawStmt --- container for any one statement's raw parse tree
- *
- * Parse analysis converts a raw parse tree headed by a PGRawStmt node into
- * an analyzed statement headed by a PGQuery node.  For optimizable statements,
- * the conversion is complex.  For utility statements, the parser usually just
- * transfers the raw parse tree (sans PGRawStmt) into the utilityStmt field of
- * the PGQuery node, and all the useful work happens at execution time.
- *
- * stmt_location/stmt_len identify the portion of the source text string
- * containing this raw statement (useful for multi-statement strings).
- */
-typedef struct PGRawStmt {
-	PGNodeTag type;
-	PGNode *stmt;      /* raw parse tree */
-	int stmt_location; /* start location, or -1 if unknown */
-	int stmt_len;      /* length in bytes; 0 means "rest of string" */
-} PGRawStmt;
-
-/*****************************************************************************
- *		Optimizable Statements
- *****************************************************************************/
-
-/* ----------------------
- *		Insert Statement
- *
- * The source expression is represented by PGSelectStmt for both the
- * SELECT and VALUES cases.  If selectStmt is NULL, then the query
- * is INSERT ... DEFAULT VALUES.
- * ----------------------
- */
-typedef struct PGInsertStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;                    /* relation to insert into */
-	PGList *cols;                            /* optional: names of the target columns */
-	PGNode *selectStmt;                      /* the source SELECT/VALUES, or NULL */
-	PGOnConflictActionAlias onConflictAlias; /* the (optional) shorthand provided for the onConflictClause */
-	PGOnConflictClause *onConflictClause;    /* ON CONFLICT clause */
-	PGList *returningList;                   /* list of expressions to return */
-	PGWithClause *withClause;                /* WITH clause */
-	PGOverridingKind override;               /* OVERRIDING clause */
-	PGInsertColumnOrder insert_column_order; /* INSERT BY NAME or INSERT BY POSITION */
-} PGInsertStmt;
-
-/* ----------------------
- *		Delete Statement
- * ----------------------
- */
-typedef struct PGDeleteStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;     /* relation to delete from */
-	PGList *usingClause;      /* optional using clause for more tables */
-	PGNode *whereClause;      /* qualifications */
-	PGList *returningList;    /* list of expressions to return */
-	PGWithClause *withClause; /* WITH clause */
-} PGDeleteStmt;
-
-/* ----------------------
- *		Update Statement
- * ----------------------
- */
-typedef struct PGUpdateStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;     /* relation to update */
-	PGList *targetList;       /* the target list (of PGResTarget) */
-	PGNode *whereClause;      /* qualifications */
-	PGList *fromClause;       /* optional from clause for more tables */
-	PGList *returningList;    /* list of expressions to return */
-	PGWithClause *withClause; /* WITH clause */
-} PGUpdateStmt;
-
-/* ----------------------
- *		Pivot Expression
- * ----------------------
- */
-typedef struct PGPivot {
-	PGNodeTag type;
-	PGList *pivot_columns;  /* The column names to pivot on */
-	PGList *unpivot_columns;/* The column names to unpivot */
-	PGList *pivot_value;    /* The set of pivot values */
-	PGNode *subquery;       /* Subquery to fetch valid pivot values (if any) */
-	char *pivot_enum;       /* The enum to fetch the unique values from */
-} PGPivot;
-
-typedef struct PGPivotExpr {
-	PGNodeTag type;
-	PGNode *source;      /* the source subtree */
-	PGList *aggrs;       /* The aggregations to pivot over (PIVOT only) */
-	PGList *unpivots;    /* The names to unpivot over (UNPIVOT only) */
-	PGList *pivots;      /* The set of pivot values */
-	PGList *groups;      /* The set of groups to pivot over (if any) */
-	PGAlias *alias;      /* table alias & optional column aliases */
-	bool include_nulls;  /* Whether or not to include NULL values (UNPIVOT only */
-	int location;        /* token location, or -1 if unknown */
-} PGPivotExpr;
-
-typedef struct PGPivotStmt {
-	PGNodeTag type;
-	PGNode *source;      /* The source to pivot */
-	PGList *aggrs;       /* The aggregations to pivot over (PIVOT only) */
-	PGList *unpivots;    /* The names to unpivot over (UNPIVOT only) */
-	PGList *columns;     /* The set of columns to pivot over */
-	PGList *groups;      /* The set of groups to pivot over (if any) */
-	int location;        /* token location, or -1 if unknown */
-} PGPivotStmt;
-
-/* ----------------------
- *		Select Statement
- *
- * A "simple" SELECT is represented in the output of gram.y by a single
- * PGSelectStmt node; so is a VALUES construct.  A query containing set
- * operators (UNION, INTERSECT, EXCEPT) is represented by a tree of PGSelectStmt
- * nodes, in which the leaf nodes are component SELECTs and the internal nodes
- * represent UNION, INTERSECT, or EXCEPT operators.  Using the same node
- * type for both leaf and internal nodes allows gram.y to stick ORDER BY,
- * LIMIT, etc, clause values into a SELECT statement without worrying
- * whether it is a simple or compound SELECT.
- * ----------------------
- */
-typedef enum PGSetOperation { PG_SETOP_NONE = 0, PG_SETOP_UNION, PG_SETOP_INTERSECT, PG_SETOP_EXCEPT, PG_SETOP_UNION_BY_NAME } PGSetOperation;
-
-typedef struct PGSelectStmt {
-	PGNodeTag type;
-
-	/*
-	 * These fields are used only in "leaf" SelectStmts.
-	 */
-	PGList *distinctClause;   /* NULL, list of DISTINCT ON exprs, or
-								 * lcons(NIL,NIL) for all (SELECT DISTINCT) */
-	PGIntoClause *intoClause; /* target for SELECT INTO */
-	PGList *targetList;       /* the target list (of PGResTarget) */
-	PGList *fromClause;       /* the FROM clause */
-	PGNode *whereClause;      /* WHERE qualification */
-	PGList *groupClause;      /* GROUP BY clauses */
-	PGNode *havingClause;     /* HAVING conditional-expression */
-	PGList *windowClause;     /* WINDOW window_name AS (...), ... */
-	PGNode *qualifyClause;    /* QUALIFY conditional-expression */
-
-	/*
-	 * In a "leaf" node representing a VALUES list, the above fields are all
-	 * null, and instead this field is set.  Note that the elements of the
-	 * sublists are just expressions, without PGResTarget decoration. Also note
-	 * that a list element can be DEFAULT (represented as a PGSetToDefault
-	 * node), regardless of the context of the VALUES list. It's up to parse
-	 * analysis to reject that where not valid.
-	 */
-	PGList *valuesLists; /* untransformed list of expression lists */
-
-	/* When representing a pivot statement, all values are NULL besides the pivot field */
-	PGPivotStmt *pivot;       /* PIVOT statement */
-
-	/*
-	 * These fields are used in both "leaf" SelectStmts and upper-level
-	 * SelectStmts.
-	 */
-	PGList *sortClause;       /* sort clause (a list of SortBy's) */
-	PGNode *limitOffset;      /* # of result tuples to skip */
-	PGNode *limitCount;       /* # of result tuples to return */
-	PGNode *sampleOptions;    /* sample options (if any) */
-	PGList *lockingClause;    /* FOR UPDATE (list of LockingClause's) */
-	PGWithClause *withClause; /* WITH clause */
-
-	/*
-	 * These fields are used only in upper-level SelectStmts.
-	 */
-	PGSetOperation op;         /* type of set op */
-	bool all;                  /* ALL specified? */
-	bool from_first;           /* FROM first or SELECT first */
-	struct PGNode *larg; /* left child */
-	struct PGNode *rarg; /* right child */
-	                           /* Eventually add fields for CORRESPONDING spec here */
-} PGSelectStmt;
-
-/* ----------------------
- *		Set Operation node for post-analysis query trees
- *
- * After parse analysis, a SELECT with set operations is represented by a
- * top-level PGQuery node containing the leaf SELECTs as subqueries in its
- * range table.  Its setOperations field shows the tree of set operations,
- * with leaf PGSelectStmt nodes replaced by PGRangeTblRef nodes, and internal
- * nodes replaced by SetOperationStmt nodes.  Information about the output
- * column types is added, too.  (Note that the child nodes do not necessarily
- * produce these types directly, but we've checked that their output types
- * can be coerced to the output column type.)  Also, if it's not UNION ALL,
- * information about the types' sort/group semantics is provided in the form
- * of a PGSortGroupClause list (same representation as, eg, DISTINCT).
- * The resolved common column collations are provided too; but note that if
- * it's not UNION ALL, it's okay for a column to not have a common collation,
- * so a member of the colCollations list could be InvalidOid even though the
- * column has a collatable type.
- * ----------------------
- */
-
-/*****************************************************************************
- *		Other Statements (no optimizations required)
- *
- *		These are not touched by parser/analyze.c except to put them into
- *		the utilityStmt field of a Query.  This is eventually passed to
- *		ProcessUtility (by-passing rewriting and planning).  Some of the
- *		statements do need attention from parse analysis, and this is
- *		done by routines in parser/parse_utilcmd.c after ProcessUtility
- *		receives the command for execution.
- *		DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are special cases:
- *		they contain optimizable statements, which get processed normally
- *		by parser/analyze.c.
- *****************************************************************************/
-
-/*
- * When a command can act on several kinds of objects with only one
- * parse structure required, use these constants to designate the
- * object type.  Note that commands typically don't support all the types.
- */
-
-typedef enum PGObjectType {
-	PG_OBJECT_ACCESS_METHOD,
-	PG_OBJECT_AGGREGATE,
-	PG_OBJECT_AMOP,
-	PG_OBJECT_AMPROC,
-	PG_OBJECT_ATTRIBUTE, /* type's attribute, when distinct from column */
-	PG_OBJECT_CAST,
-	PG_OBJECT_COLUMN,
-	PG_OBJECT_COLLATION,
-	PG_OBJECT_CONVERSION,
-	PG_OBJECT_DATABASE,
-	PG_OBJECT_DEFAULT,
-	PG_OBJECT_DEFACL,
-	PG_OBJECT_DOMAIN,
-	PG_OBJECT_DOMCONSTRAINT,
-	PG_OBJECT_EVENT_TRIGGER,
-	PG_OBJECT_EXTENSION,
-	PG_OBJECT_FDW,
-	PG_OBJECT_FOREIGN_SERVER,
-	PG_OBJECT_FOREIGN_TABLE,
-	PG_OBJECT_FUNCTION,
-	PG_OBJECT_TABLE_MACRO,
-	PG_OBJECT_INDEX,
-	PG_OBJECT_LANGUAGE,
-	PG_OBJECT_LARGEOBJECT,
-	PG_OBJECT_MATVIEW,
-	PG_OBJECT_OPCLASS,
-	PG_OBJECT_OPERATOR,
-	PG_OBJECT_OPFAMILY,
-	PG_OBJECT_POLICY,
-	PG_OBJECT_PUBLICATION,
-	PG_OBJECT_PUBLICATION_REL,
-	PG_OBJECT_ROLE,
-	PG_OBJECT_RULE,
-	PG_OBJECT_SCHEMA,
-	PG_OBJECT_SEQUENCE,
-	PG_OBJECT_SUBSCRIPTION,
-	PG_OBJECT_STATISTIC_EXT,
-	PG_OBJECT_TABCONSTRAINT,
-	PG_OBJECT_TABLE,
-	PG_OBJECT_TABLESPACE,
-	PG_OBJECT_TRANSFORM,
-	PG_OBJECT_TRIGGER,
-	PG_OBJECT_TSCONFIGURATION,
-	PG_OBJECT_TSDICTIONARY,
-	PG_OBJECT_TSPARSER,
-	PG_OBJECT_TSTEMPLATE,
-	PG_OBJECT_TYPE,
-	PG_OBJECT_USER_MAPPING,
-	PG_OBJECT_VIEW
-} PGObjectType;
-
-/* ----------------------
- *		Create Schema Statement
- *
- * NOTE: the schemaElts list contains raw parsetrees for component statements
- * of the schema, such as CREATE TABLE, GRANT, etc.  These are analyzed and
- * executed after the schema itself is created.
- * ----------------------
- */
-typedef struct PGCreateSchemaStmt {
-	PGNodeTag type;
-	char *catalogname;                    /* the name of the catalog in which to create the schema */
-	char *schemaname;                     /* the name of the schema to create */
-	PGList *schemaElts;                   /* schema components (list of parsenodes) */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateSchemaStmt;
-
-typedef enum PGDropBehavior {
-	PG_DROP_RESTRICT, /* drop fails if any dependent objects */
-	PG_DROP_CASCADE   /* remove dependent objects too */
-} PGDropBehavior;
-
-/* ----------------------
- *	Alter Table
- * ----------------------
- */
-typedef struct PGAlterTableStmt {
-	PGNodeTag type;
-	PGRangeVar *relation; /* table to work on */
-	PGList *cmds;         /* list of subcommands */
-	PGObjectType relkind; /* type of object */
-	bool missing_ok;      /* skip error if table missing */
-} PGAlterTableStmt;
-
-typedef enum PGAlterTableType {
-	PG_AT_AddColumn,                 /* add column */
-	PG_AT_AddColumnRecurse,          /* internal to commands/tablecmds.c */
-	PG_AT_AddColumnToView,           /* implicitly via CREATE OR REPLACE VIEW */
-	PG_AT_ColumnDefault,             /* alter column default */
-	PG_AT_DropNotNull,               /* alter column drop not null */
-	PG_AT_SetNotNull,                /* alter column set not null */
-	PG_AT_SetStatistics,             /* alter column set statistics */
-	PG_AT_SetOptions,                /* alter column set ( options ) */
-	PG_AT_ResetOptions,              /* alter column reset ( options ) */
-	PG_AT_SetStorage,                /* alter column set storage */
-	PG_AT_DropColumn,                /* drop column */
-	PG_AT_DropColumnRecurse,         /* internal to commands/tablecmds.c */
-	PG_AT_AddIndex,                  /* add index */
-	PG_AT_ReAddIndex,                /* internal to commands/tablecmds.c */
-	PG_AT_AddConstraint,             /* add constraint */
-	PG_AT_AddConstraintRecurse,      /* internal to commands/tablecmds.c */
-	PG_AT_ReAddConstraint,           /* internal to commands/tablecmds.c */
-	PG_AT_AlterConstraint,           /* alter constraint */
-	PG_AT_ValidateConstraint,        /* validate constraint */
-	PG_AT_ValidateConstraintRecurse, /* internal to commands/tablecmds.c */
-	PG_AT_ProcessedConstraint,       /* pre-processed add constraint (local in
-								 * parser/parse_utilcmd.c) */
-	PG_AT_AddIndexConstraint,        /* add constraint using existing index */
-	PG_AT_DropConstraint,            /* drop constraint */
-	PG_AT_DropConstraintRecurse,     /* internal to commands/tablecmds.c */
-	PG_AT_ReAddComment,              /* internal to commands/tablecmds.c */
-	PG_AT_AlterColumnType,           /* alter column type */
-	PG_AT_AlterColumnGenericOptions, /* alter column OPTIONS (...) */
-	PG_AT_ChangeOwner,               /* change owner */
-	PG_AT_ClusterOn,                 /* CLUSTER ON */
-	PG_AT_DropCluster,               /* SET WITHOUT CLUSTER */
-	PG_AT_SetLogged,                 /* SET LOGGED */
-	PG_AT_SetUnLogged,               /* SET UNLOGGED */
-	PG_AT_AddOids,                   /* SET WITH OIDS */
-	PG_AT_AddOidsRecurse,            /* internal to commands/tablecmds.c */
-	PG_AT_DropOids,                  /* SET WITHOUT OIDS */
-	PG_AT_SetTableSpace,             /* SET TABLESPACE */
-	PG_AT_SetRelOptions,             /* SET (...) -- AM specific parameters */
-	PG_AT_ResetRelOptions,           /* RESET (...) -- AM specific parameters */
-	PG_AT_ReplaceRelOptions,         /* replace reloption list in its entirety */
-	PG_AT_EnableTrig,                /* ENABLE TRIGGER name */
-	PG_AT_EnableAlwaysTrig,          /* ENABLE ALWAYS TRIGGER name */
-	PG_AT_EnableReplicaTrig,         /* ENABLE REPLICA TRIGGER name */
-	PG_AT_DisableTrig,               /* DISABLE TRIGGER name */
-	PG_AT_EnableTrigAll,             /* ENABLE TRIGGER ALL */
-	PG_AT_DisableTrigAll,            /* DISABLE TRIGGER ALL */
-	PG_AT_EnableTrigUser,            /* ENABLE TRIGGER USER */
-	PG_AT_DisableTrigUser,           /* DISABLE TRIGGER USER */
-	PG_AT_EnableRule,                /* ENABLE RULE name */
-	PG_AT_EnableAlwaysRule,          /* ENABLE ALWAYS RULE name */
-	PG_AT_EnableReplicaRule,         /* ENABLE REPLICA RULE name */
-	PG_AT_DisableRule,               /* DISABLE RULE name */
-	PG_AT_AddInherit,                /* INHERIT parent */
-	PG_AT_DropInherit,               /* NO INHERIT parent */
-	PG_AT_AddOf,                     /* OF <type_name> */
-	PG_AT_DropOf,                    /* NOT OF */
-	PG_AT_ReplicaIdentity,           /* REPLICA IDENTITY */
-	PG_AT_EnableRowSecurity,         /* ENABLE ROW SECURITY */
-	PG_AT_DisableRowSecurity,        /* DISABLE ROW SECURITY */
-	PG_AT_ForceRowSecurity,          /* FORCE ROW SECURITY */
-	PG_AT_NoForceRowSecurity,        /* NO FORCE ROW SECURITY */
-	PG_AT_GenericOptions,            /* OPTIONS (...) */
-	PG_AT_AttachPartition,           /* ATTACH PARTITION */
-	PG_AT_DetachPartition,           /* DETACH PARTITION */
-	PG_AT_AddIdentity,               /* ADD IDENTITY */
-	PG_AT_SetIdentity,               /* SET identity column options */
-	AT_DropIdentity                  /* DROP IDENTITY */
-} PGAlterTableType;
-
-typedef struct PGAlterTableCmd /* one subcommand of an ALTER TABLE */
-{
-	PGNodeTag type;
-	PGAlterTableType subtype; /* Type of table alteration to apply */
-	char *name;               /* column, constraint, or trigger to act on,
-								 * or tablespace */
-	PGNode *def;              /* definition of new column, index,
-								 * constraint, or parent table */
-	PGDropBehavior behavior;  /* RESTRICT or CASCADE for DROP cases */
-	bool missing_ok;          /* skip error if missing? */
-} PGAlterTableCmd;
-
-/*
- * Note: PGObjectWithArgs carries only the types of the input parameters of the
- * function.  So it is sufficient to identify an existing function, but it
- * is not enough info to define a function nor to call it.
- */
-typedef struct PGObjectWithArgs {
-	PGNodeTag type;
-	PGList *objname;       /* qualified name of function/operator */
-	PGList *objargs;       /* list of Typename nodes */
-	bool args_unspecified; /* argument list was omitted, so name must
-									 * be unique (note that objargs == NIL
-									 * means zero args) */
-} PGObjectWithArgs;
-
-/* ----------------------
- *		Copy Statement
- *
- * We support "COPY relation FROM file", "COPY relation TO file", and
- * "COPY (query) TO file".  In any given PGCopyStmt, exactly one of "relation"
- * and "query" must be non-NULL.
- * ----------------------
- */
-typedef struct PGCopyStmt {
-	PGNodeTag type;
-	PGRangeVar *relation; /* the relation to copy */
-	PGNode *query;        /* the query (SELECT or DML statement with
-								 * RETURNING) to copy, as a raw parse tree */
-	PGList *attlist;      /* PGList of column names (as Strings), or NIL
-								 * for all columns */
-	bool is_from;         /* TO or FROM */
-	bool is_program;      /* is 'filename' a program to popen? */
-	char *filename;       /* filename, or NULL for STDIN/STDOUT */
-	PGList *options;      /* PGList of PGDefElem nodes */
-} PGCopyStmt;
-
-/* ----------------------
- * SET Statement (includes RESET)
- *
- * "SET var TO DEFAULT" and "RESET var" are semantically equivalent, but we
- * preserve the distinction in VariableSetKind for CreateCommandTag().
- * ----------------------
- */
-typedef enum {
-
-	VAR_SET_VALUE,   /* SET var = value */
-	VAR_SET_DEFAULT, /* SET var TO DEFAULT */
-	VAR_SET_CURRENT, /* SET var FROM CURRENT */
-	VAR_SET_MULTI,   /* special case for SET TRANSACTION ... */
-	VAR_RESET,       /* RESET var */
-	VAR_RESET_ALL,   /* RESET ALL */
-} VariableSetKind;
-
-typedef enum {
-	VAR_SET_SCOPE_LOCAL,   /* SET LOCAL var */
-	VAR_SET_SCOPE_SESSION, /* SET SESSION var */
-	VAR_SET_SCOPE_GLOBAL,  /* SET GLOBAL var */
-	VAR_SET_SCOPE_VARIABLE,/* SET VARIABLE var */
-	VAR_SET_SCOPE_DEFAULT  /* SET var (same as SET_SESSION) */
-} VariableSetScope;
-
-typedef struct PGVariableSetStmt {
-	PGNodeTag type;
-	VariableSetKind kind;
-	VariableSetScope scope;
-	char *name;    /* variable to be set */
-	PGList *args;  /* PGList of PGAConst nodes */
-} PGVariableSetStmt;
-
-/* ----------------------
- * Show Statement
- * ----------------------
- */
-typedef struct PGVariableShowStmt {
-	PGNodeTag   type;
-	PGRangeVar *relation;   /* relation to describe (if any) */
-	char       *set;        /* set to describe (e.g. set when using SHOW ALL TABLES) */
-	int         is_summary; // whether or not this is a DESCRIBE or a SUMMARIZE
-} PGVariableShowStmt;
-
-/* ----------------------
- * Show Statement with Select Statement
- * ----------------------
- */
-typedef struct PGVariableShowSelectStmt
-{
-	PGNodeTag   type;
-	PGNode     *stmt;
-	char       *name;
-	int         is_summary; // whether or not this is a DESCRIBE or a SUMMARIZE
-} PGVariableShowSelectStmt;
-
-
-/* ----------------------
- *		Create Table Statement
- *
- * NOTE: in the raw gram.y output, PGColumnDef and PGConstraint nodes are
- * intermixed in tableElts, and constraints is NIL.  After parse analysis,
- * tableElts contains just ColumnDefs, and constraints contains just
- * PGConstraint nodes (in fact, only PG_CONSTR_CHECK nodes, in the present
- * implementation).
- * ----------------------
- */
-
-typedef struct PGCreateStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;                 /* relation to create */
-	PGList *tableElts;                    /* column definitions (list of PGColumnDef) */
-	PGList *inhRelations;                 /* relations to inherit from (list of
-										* inhRelation) */
-	PGTypeName *ofTypename;               /* OF typename */
-	PGList *constraints;                  /* constraints (list of PGConstraint nodes) */
-	PGList *options;                      /* options from WITH clause */
-	PGOnCommitAction oncommit;            /* what do we do at COMMIT? */
-	char *tablespacename;                 /* table space to use, or NULL */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateStmt;
-
-/* ----------
- * Definitions for constraints in PGCreateStmt
- *
- * Note that column defaults are treated as a type of constraint,
- * even though that's a bit odd semantically.
- *
- * For constraints that use expressions (CONSTR_CHECK, PG_CONSTR_DEFAULT)
- * we may have the expression in either "raw" form (an untransformed
- * parse tree) or "cooked" form (the nodeToString representation of
- * an executable expression tree), depending on how this PGConstraint
- * node was created (by parsing, or by inheritance from an existing
- * relation).  We should never have both in the same node!
- *
- * PG_FKCONSTR_ACTION_xxx values are stored into pg_constraint.confupdtype
- * and pg_constraint.confdeltype columns; PG_FKCONSTR_MATCH_xxx values are
- * stored into pg_constraint.confmatchtype.  Changing the code values may
- * require an initdb!
- *
- * If skip_validation is true then we skip checking that the existing rows
- * in the table satisfy the constraint, and just install the catalog entries
- * for the constraint.  A new FK constraint is marked as valid iff
- * initially_valid is true.  (Usually skip_validation and initially_valid
- * are inverses, but we can set both true if the table is known empty.)
- *
- * PGConstraint attributes (DEFERRABLE etc) are initially represented as
- * separate PGConstraint nodes for simplicity of parsing.  parse_utilcmd.c makes
- * a pass through the constraints list to insert the info into the appropriate
- * PGConstraint node.
- * ----------
- */
-
-typedef enum PGConstrType /* types of constraints */
-{ PG_CONSTR_NULL,         /* not standard SQL, but a lot of people
-								 * expect it */
-  PG_CONSTR_NOTNULL,
-  PG_CONSTR_DEFAULT,
-  PG_CONSTR_IDENTITY,
-  PG_CONSTR_CHECK,
-  PG_CONSTR_PRIMARY,
-  PG_CONSTR_UNIQUE,
-  PG_CONSTR_EXCLUSION,
-  PG_CONSTR_FOREIGN,
-  PG_CONSTR_ATTR_DEFERRABLE, /* attributes for previous constraint node */
-  PG_CONSTR_ATTR_NOT_DEFERRABLE,
-  PG_CONSTR_ATTR_DEFERRED,
-  PG_CONSTR_ATTR_IMMEDIATE,
-  PG_CONSTR_COMPRESSION,
-  PG_CONSTR_GENERATED_VIRTUAL,
-  PG_CONSTR_GENERATED_STORED,
-  } PGConstrType;
-
-/* Foreign key action codes */
-#define PG_FKCONSTR_ACTION_NOACTION 'a'
-#define PG_FKCONSTR_ACTION_RESTRICT 'r'
-#define PG_FKCONSTR_ACTION_CASCADE 'c'
-#define PG_FKCONSTR_ACTION_SETNULL 'n'
-#define PG_FKCONSTR_ACTION_SETDEFAULT 'd'
-
-/* Foreign key matchtype codes */
-#define PG_FKCONSTR_MATCH_FULL 'f'
-#define PG_FKCONSTR_MATCH_PARTIAL 'p'
-#define PG_FKCONSTR_MATCH_SIMPLE 's'
-
-typedef struct PGConstraint {
-	PGNodeTag type;
-	PGConstrType contype; /* see above */
-
-	/* Fields used for most/all constraint types: */
-	char *conname;     /* PGConstraint name, or NULL if unnamed */
-	bool deferrable;   /* DEFERRABLE? */
-	bool initdeferred; /* INITIALLY DEFERRED? */
-	int location;      /* token location, or -1 if unknown */
-
-	/* Fields used for constraints with expressions (CHECK and DEFAULT): */
-	bool is_no_inherit; /* is constraint non-inheritable? */
-	PGNode *raw_expr;   /* expr, as untransformed parse tree */
-	char *cooked_expr;  /* expr, as nodeToString representation */
-	char generated_when;
-
-	/* Fields used for unique constraints (UNIQUE and PRIMARY KEY): */
-	PGList *keys; /* String nodes naming referenced column(s) */
-
-	/* Fields used for EXCLUSION constraints: */
-	PGList *exclusions; /* list of (PGIndexElem, operator name) pairs */
-
-	/* Fields used for index constraints (UNIQUE, PRIMARY KEY, EXCLUSION): */
-	PGList *options;  /* options from WITH clause */
-	char *indexname;  /* existing index to use; otherwise NULL */
-	char *indexspace; /* index tablespace; NULL for default */
-	/* These could be, but currently are not, used for UNIQUE/PKEY: */
-	char *access_method;  /* index access method; NULL for default */
-	PGNode *where_clause; /* partial index predicate */
-
-	/* Fields used for FOREIGN KEY constraints: */
-	PGRangeVar *pktable;   /* Primary key table */
-	PGList *fk_attrs;      /* Attributes of foreign key */
-	PGList *pk_attrs;      /* Corresponding attrs in PK table */
-	char fk_matchtype;     /* FULL, PARTIAL, SIMPLE */
-	char fk_upd_action;    /* ON UPDATE action */
-	char fk_del_action;    /* ON DELETE action */
-	PGList *old_conpfeqop; /* pg_constraint.conpfeqop of my former self */
-	PGOid old_pktable_oid; /* pg_constraint.confrelid of my former
-									 * self */
-
-	/* Fields used for constraints that allow a NOT VALID specification */
-	bool skip_validation; /* skip validation of existing rows? */
-	bool initially_valid; /* mark the new constraint as valid? */
-
-
-	/* Field Used for COMPRESSION constraint */
-	char *compression_name;  /* existing index to use; otherwise NULL */
-
-} PGConstraint;
-
-/* ----------------------
- *		{Create|Alter} SEQUENCE Statement
- * ----------------------
- */
-
-typedef struct PGCreateSeqStmt {
-	PGNodeTag type;
-	PGRangeVar *sequence; /* the sequence to create */
-	PGList *options;
-	PGOid ownerId; /* ID of owner, or InvalidOid for default */
-	bool for_identity;
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateSeqStmt;
-
-typedef struct PGAlterSeqStmt {
-	PGNodeTag type;
-	PGRangeVar *sequence; /* the sequence to alter */
-	PGList *options;
-	bool for_identity;
-	bool missing_ok; /* skip error if a role is missing? */
-} PGAlterSeqStmt;
-
-/* ----------------------
- *		CREATE FUNCTION Statement
- * ----------------------
- */
-typedef struct PGFunctionDefinition {
-	PGList *params;
-	PGNode *function;
-	PGNode *query;
-} PGFunctionDefinition;
-
-typedef struct PGCreateFunctionStmt {
-	PGNodeTag type;
-	PGRangeVar *name;
-	PGList *functions;
-	PGOnCreateConflict onconflict;
-} PGCreateFunctionStmt;
-
-/* ----------------------
- *		Drop Table|Sequence|View|Index|Type|Domain|Conversion|Schema Statement
- * ----------------------
- */
-
-typedef struct PGDropStmt {
-	PGNodeTag type;
-	PGList *objects;         /* list of names */
-	PGObjectType removeType; /* object type */
-	PGDropBehavior behavior; /* RESTRICT or CASCADE behavior */
-	bool missing_ok;         /* skip error if object is missing? */
-	bool concurrent;         /* drop index concurrently? */
-} PGDropStmt;
-
-/* ----------------------
- *		Create PGIndex Statement
- *
- * This represents creation of an index and/or an associated constraint.
- * If isconstraint is true, we should create a pg_constraint entry along
- * with the index.  But if indexOid isn't InvalidOid, we are not creating an
- * index, just a UNIQUE/PKEY constraint using an existing index.  isconstraint
- * must always be true in this case, and the fields describing the index
- * properties are empty.
- * ----------------------
- */
-typedef struct PGIndexStmt {
-	PGNodeTag type;
-	char *idxname;          /* name of new index, or NULL for default */
-	PGRangeVar *relation;   /* relation to build index on */
-	char *accessMethod;     /* name of access method (eg. btree) */
-	char *tableSpace;       /* tablespace, or NULL for default */
-	PGList *indexParams;    /* columns to index: a list of PGIndexElem */
-	PGList *options;        /* WITH clause options: a list of PGDefElem */
-	PGNode *whereClause;    /* qualification (partial-index predicate) */
-	PGList *excludeOpNames; /* exclusion operator names, or NIL if none */
-	char *idxcomment;       /* comment to apply to index, or NULL */
-	PGOid indexOid;         /* OID of an existing index, if any */
-	PGOid oldNode;          /* relfilenode of existing storage, if any */
-	bool unique;            /* is index unique? */
-	bool primary;           /* is index a primary key? */
-	bool isconstraint;      /* is it for a pkey/unique constraint? */
-	bool deferrable;        /* is the constraint DEFERRABLE? */
-	bool initdeferred;      /* is the constraint INITIALLY DEFERRED? */
-	bool transformed;       /* true when transformIndexStmt is finished */
-	bool concurrent;        /* should this be a concurrent index build? */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGIndexStmt;
-
-/* ----------------------
- *		Alter Object Rename Statement
- * ----------------------
- */
-typedef struct PGRenameStmt {
-	PGNodeTag type;
-	PGObjectType renameType;   /* PG_OBJECT_TABLE, PG_OBJECT_COLUMN, etc */
-	PGObjectType relationType; /* if column name, associated relation type */
-	PGRangeVar *relation;      /* in case it's a table */
-	PGNode *object;            /* in case it's some other object */
-	char *subname;             /* name of contained object (column, rule,
-								 * trigger, etc) */
-	char *newname;             /* the new name */
-	PGDropBehavior behavior;   /* RESTRICT or CASCADE behavior */
-	bool missing_ok;           /* skip error if missing? */
-} PGRenameStmt;
-
-/* ----------------------
- *		ALTER object SET SCHEMA Statement
- * ----------------------
- */
-typedef struct PGAlterObjectSchemaStmt {
-	PGNodeTag type;
-	PGObjectType objectType; /* PG_OBJECT_TABLE, PG_OBJECT_TYPE, etc */
-	PGRangeVar *relation;    /* in case it's a table */
-	PGNode *object;          /* in case it's some other object */
-	char *newschema;         /* the new schema */
-	bool missing_ok;         /* skip error if missing? */
-} PGAlterObjectSchemaStmt;
-
-/* ----------------------
- *		{Begin|Commit|Rollback} Transaction Statement
- * ----------------------
- */
-typedef enum PGTransactionStmtKind {
-	PG_TRANS_STMT_BEGIN,
-	PG_TRANS_STMT_START, /* semantically identical to BEGIN */
-	PG_TRANS_STMT_COMMIT,
-	PG_TRANS_STMT_ROLLBACK,
-	PG_TRANS_STMT_SAVEPOINT,
-	PG_TRANS_STMT_RELEASE,
-	PG_TRANS_STMT_ROLLBACK_TO,
-	PG_TRANS_STMT_PREPARE,
-	PG_TRANS_STMT_COMMIT_PREPARED,
-	TRANS_STMT_ROLLBACK_PREPARED
-} PGTransactionStmtKind;
-
-typedef enum PGTransactionStmtType {
-	PG_TRANS_TYPE_DEFAULT,
-	PG_TRANS_TYPE_READ_ONLY, // explicit READ ONLY
-	PG_TRANS_TYPE_READ_WRITE // explicit READ WRITE
-} PGTransactionStmtType;
-
-typedef struct PGTransactionStmt {
-	PGNodeTag type;
-	PGTransactionStmtKind kind;             /* see above */
-	PGList *options;                        /* for BEGIN/START and savepoint commands */
-	char *gid;                              /* for two-phase-commit related commands */
-	PGTransactionStmtType transaction_type; /* read only or read write */
-} PGTransactionStmt;
-
-/* ----------------------
- *		Create View Statement
- * ----------------------
- */
-typedef enum PGViewCheckOption { PG_NO_CHECK_OPTION, PG_LOCAL_CHECK_OPTION, CASCADED_CHECK_OPTION } PGViewCheckOption;
-
-typedef struct PGViewStmt {
-	PGNodeTag type;
-	PGRangeVar *view;                  /* the view to be created */
-	PGList *aliases;                   /* target column names */
-	PGNode *query;                     /* the SELECT query (as a raw parse tree) */
-	PGOnCreateConflict onconflict;     /* what to do on create conflict */
-	PGList *options;                   /* options from WITH clause */
-	PGViewCheckOption withCheckOption; /* WITH CHECK OPTION */
-} PGViewStmt;
-
-/* ----------------------
- *		Load Statement
- * ----------------------
- */
-
-typedef enum PGLoadInstallType { PG_LOAD_TYPE_LOAD,  PG_LOAD_TYPE_INSTALL, PG_LOAD_TYPE_FORCE_INSTALL } PGLoadInstallType;
-
-
-typedef struct PGLoadStmt {
-	PGNodeTag type;
-	const char *filename; /* file to load */
-	const char *repository; /* optionally, the repository to load from */
-	bool repo_is_alias; /* whether the repository was passed as an alias or a raw path */
-	const char *version; /* optionally, the version of the extension to be loaded */
-	PGLoadInstallType load_type;
-} PGLoadStmt;
-
-/* ----------------------
- *		Update Extensions Statement
- * ----------------------
- */
-
-typedef struct PGUpdateExtensionsStmt {
-	PGNodeTag type;
-	PGList * extensions;
-} PGUpdateExtensionsStmt;
-
-/* ----------------------
- *		Vacuum and Analyze Statements
- *
- * Even though these are nominally two statements, it's convenient to use
- * just one node type for both.  Note that at least one of PG_VACOPT_VACUUM
- * and PG_VACOPT_ANALYZE must be set in options.
- * ----------------------
- */
-typedef enum PGVacuumOption {
-	PG_VACOPT_VACUUM = 1 << 0,               /* do VACUUM */
-	PG_VACOPT_ANALYZE = 1 << 1,              /* do ANALYZE */
-	PG_VACOPT_VERBOSE = 1 << 2,              /* print progress info */
-	PG_VACOPT_FREEZE = 1 << 3,               /* FREEZE option */
-	PG_VACOPT_FULL = 1 << 4,                 /* FULL (non-concurrent) vacuum */
-	PG_VACOPT_NOWAIT = 1 << 5,               /* don't wait to get lock (autovacuum only) */
-	PG_VACOPT_SKIPTOAST = 1 << 6,            /* don't process the TOAST table, if any */
-	PG_VACOPT_DISABLE_PAGE_SKIPPING = 1 << 7 /* don't skip any pages */
-} PGVacuumOption;
-
-typedef struct PGVacuumStmt {
-	PGNodeTag type;
-	int options;          /* OR of PGVacuumOption flags */
-	PGRangeVar *relation; /* single table to process, or NULL */
-	PGList *va_cols;      /* list of column names, or NIL for all */
-} PGVacuumStmt;
-
-/* ----------------------
- *		Explain Statement
- *
- * The "query" field is initially a raw parse tree, and is converted to a
- * PGQuery node during parse analysis.  Note that rewriting and planning
- * of the query are always postponed until execution.
- * ----------------------
- */
-typedef struct PGExplainStmt {
-	PGNodeTag type;
-	PGNode *query;   /* the query (see comments above) */
-	PGList *options; /* list of PGDefElem nodes */
-} PGExplainStmt;
-
-/* ----------------------
- *		CREATE TABLE AS Statement (a/k/a SELECT INTO)
- *
- * A query written as CREATE TABLE AS will produce this node type natively.
- * A query written as SELECT ... INTO will be transformed to this form during
- * parse analysis.
- * A query written as CREATE MATERIALIZED view will produce this node type,
- * during parse analysis, since it needs all the same data.
- *
- * The "query" field is handled similarly to EXPLAIN, though note that it
- * can be a SELECT or an EXECUTE, but not other DML statements.
- * ----------------------
- */
-typedef struct PGCreateTableAsStmt {
-	PGNodeTag type;
-	PGNode *query;        /* the query (see comments above) */
-	PGIntoClause *into;   /* destination table */
-	PGObjectType relkind; /* PG_OBJECT_TABLE or PG_OBJECT_MATVIEW */
-	bool is_select_into;  /* it was written as SELECT INTO */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateTableAsStmt;
-
-/* ----------------------
- * Checkpoint Statement
- * ----------------------
- */
-typedef struct PGCheckPointStmt {
-	PGNodeTag type;
-	bool force;
-	char *name;
-} PGCheckPointStmt;
-
-/* ----------------------
- *		PREPARE Statement
- * ----------------------
- */
-typedef struct PGPrepareStmt {
-	PGNodeTag type;
-	char *name;       /* Name of plan, arbitrary */
-	PGList *argtypes; /* Types of parameters (PGList of PGTypeName) */
-	PGNode *query;    /* The query itself (as a raw parsetree) */
-} PGPrepareStmt;
-
-/* ----------------------
- *		EXECUTE Statement
- * ----------------------
- */
-
-typedef struct PGExecuteStmt {
-	PGNodeTag type;
-	char *name;     /* The name of the plan to execute */
-	PGList *params; /* Values to assign to parameters */
-} PGExecuteStmt;
-
-/* ----------------------
- *		DEALLOCATE Statement
- * ----------------------
- */
-typedef struct PGDeallocateStmt {
-	PGNodeTag type;
-	char *name; /* The name of the plan to remove */
-	            /* NULL means DEALLOCATE ALL */
-} PGDeallocateStmt;
-
-/* ----------------------
- * PRAGMA statements
- * Three types of pragma statements:
- * PRAGMA pragma_name;          (NOTHING)
- * PRAGMA pragma_name='param';  (ASSIGNMENT)
- * PRAGMA pragma_name('param'); (CALL)
- * ----------------------
- */
-typedef enum { PG_PRAGMA_TYPE_NOTHING, PG_PRAGMA_TYPE_ASSIGNMENT, PG_PRAGMA_TYPE_CALL } PGPragmaKind;
-
-typedef struct PGPragmaStmt {
-	PGNodeTag type;
-	PGPragmaKind kind;
-	char *name;   /* variable to be set */
-	PGList *args; /* PGList of PGAConst nodes */
-} PGPragmaStmt;
-
-/* ----------------------
- *		CALL Statement
- * ----------------------
- */
-
-typedef struct PGCallStmt {
-	PGNodeTag type;
-	PGNode *func;
-} PGCallStmt;
-
-/* ----------------------
- *		EXPORT/IMPORT Statements
- * ----------------------
- */
-
-typedef struct PGExportStmt {
-	PGNodeTag type;
-	char *database;       /* database name */
-	char *filename;       /* filename */
-	PGList *options;      /* PGList of PGDefElem nodes */
-} PGExportStmt;
-
-typedef struct PGImportStmt {
-	PGNodeTag type;
-	char *filename;       /* filename */
-} PGImportStmt;
-
-/* ----------------------
- *		Copy Database Statement
- * ----------------------
- */
-typedef struct PGCopyDatabaseStmt {
-	PGNodeTag type;
-	const char *from_database;
-	const char *to_database;
-	const char *copy_database_flag;
-} PGCopyDatabaseStmt;
-
-/* ----------------------
- *		Interval Constant
- * ----------------------
- */
-typedef struct PGIntervalConstant {
-	PGNodeTag type;
-	int val_type;         /* interval constant type, either duckdb_libpgquery::T_PGString, duckdb_libpgquery::T_PGInteger or duckdb_libpgquery::T_PGAExpr */
-	char *sval;           /* duckdb_libpgquery::T_PGString */
-	int ival;             /* duckdb_libpgquery::T_PGString */
-	PGNode *eval;         /* duckdb_libpgquery::T_PGAExpr */
-	PGList *typmods;      /* how to interpret the interval constant (year, month, day, etc)  */
-	int location;         /* token location, or -1 if unknown */
-} PGIntervalConstant;
-
-/* ----------------------
- *		Sample Options
- * ----------------------
- */
-typedef struct PGSampleSize {
-	PGNodeTag type;
-	bool is_percentage;   /* whether or not the sample size is expressed in row numbers or a percentage */
-	PGNode *sample_size;  /* sample size */
-} PGSampleSize;
-
-typedef struct PGSampleOptions {
-	PGNodeTag type;
-	PGNode *sample_size;      /* the size of the sample to take */
-	char *method;             /* sample method, or NULL for default */
-	bool has_seed;            /* if the sample method has seed */
-	int seed;                 /* the seed value if set; */
-	int location;             /* token location, or -1 if unknown */
-} PGSampleOptions;
-
-/* ----------------------
- *      Limit Percentage
- * ----------------------
- */
-typedef struct PGLimitPercent {
-	PGNodeTag type;
-    PGNode* limit_percent;  /* limit percent */
-} PGLimitPercent;
-
-/* ----------------------
- *		Lambda Function (or Arrow Operator)
- * ----------------------
- */
-typedef struct PGLambdaFunction {
-	PGNodeTag type;
-	PGNode *lhs;                 /* parameter expression */
-	PGNode *rhs;                 /* lambda expression */
-	int location;                /* token location, or -1 if unknown */
-} PGLambdaFunction;
-
-/* ----------------------
- *		Positional Reference
- * ----------------------
- */
-typedef struct PGPositionalReference {
-	PGNodeTag type;
-	int position;
-	int location;                /* token location, or -1 if unknown */
-} PGPositionalReference;
-
-/* ----------------------
- *		Type Statement
- * ----------------------
- */
-
-typedef enum { PG_NEWTYPE_NONE, PG_NEWTYPE_ENUM, PG_NEWTYPE_ALIAS } PGNewTypeKind;
-
-typedef struct PGCreateTypeStmt
-{
-	PGNodeTag		type;
-	PGNewTypeKind	kind;
-	PGRangeVar	   *typeName;	/* qualified name (list of Value strings) */
-	PGList	   *vals;			/* enum values (list of Value strings) */
-	PGTypeName *ofType;			/* original type of alias name */
-    PGNode *query;
-} PGCreateTypeStmt;
-
-/* ----------------------
- *		Attach Statement
- * ----------------------
- */
-
-typedef struct PGAttachStmt
-{
-	PGNodeTag		type;
-	char *path;			/* The file path of the to-be-attached database */
-	char *name;			/* The name of the attached database */
-	PGList *options;      /* PGList of PGDefElem nodes */
-    PGNode *query;
-	PGOnCreateConflict onconflict;        /* what to do on attach conflict */
-} PGAttachStmt;
-
-/* ----------------------
- *		Dettach Statement
- * ----------------------
- */
-
-typedef struct PGDetachStmt
-{
-	PGNodeTag		type;
-	char *db_name;         /* list of names of attached databases */
-	bool missing_ok;
-} PGDetachStmt;
-
-/* ----------------------
- *		Use Statement
- * ----------------------
- */
-
-typedef struct PGUseStmt {
-	PGNodeTag type;
-	PGRangeVar *name;    /* variable to be set */
-} PGUseStmt;
-
-
-/* ----------------------
- *		Create Secret Statement
- * ----------------------
- */
-typedef struct PGCreateSecretStmt {
-	PGNodeTag type;
-	char *persist_type;                   /* the requested persist mode */
-	char *secret_name;                    /* name of the secret */
-	char *secret_storage;                 /* the optional storage type of the secret */
-	PGList *scope;                        /* optionally the scopes of the secret */
-	PGList *options;                      /* Secret options */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateSecretStmt;
-
-
-/* ----------------------
- *		Drop Secret Statement
- * ----------------------
- */
-typedef struct PGDropSecretStmt {
-	PGNodeTag type;
-	char *persist_type;                   /* the requested persist mode */
-	char *secret_name;                    /* name of the secret */
-	char *secret_storage;
-	bool missing_ok;
-} PGDropSecretStmt;
-
-/* ----------------------
- *		Comment On Statement
- * ----------------------
- */
-typedef struct PGCommentOnStmt {
-	PGNodeTag type;
-	PGObjectType object_type; 	/* object type */
-	PGRangeVar *name;         /* the object to comment on */
-	PGNode *value;				/* the comment: a string or NULL*/
-	PGNode *column_expr;
-} PGCommentOnStmt;
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/pg_list.hpp b/src/duckdb/third_party/libpg_query/include/nodes/pg_list.hpp
deleted file mode 100644
index 4d06c853d..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/pg_list.hpp
+++ /dev/null
@@ -1,339 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_list.h
- *	  interface for PostgreSQL generic linked list package
- *
- * This package implements singly-linked homogeneous lists.
- *
- * It is important to have constant-time length, append, and prepend
- * operations. To achieve this, we deal with two distinct data
- * structures:
- *
- *		1. A set of "list cells": each cell contains a data field and
- *		   a link to the next cell in the list or NULL.
- *		2. A single structure containing metadata about the list: the
- *		   type of the list, pointers to the head and tail cells, and
- *		   the length of the list.
- *
- * We support three types of lists:
- *
- *	duckdb_libpgquery::T_PGList: lists of pointers
- *		(in practice usually pointers to Nodes, but not always;
- *		declared as "void *" to minimize casting annoyances)
- *	duckdb_libpgquery::T_PGIntList: lists of integers
- *	duckdb_libpgquery::T_PGOidList: lists of Oids
- *
- * (At the moment, ints and Oids are the same size, but they may not
- * always be so; try to be careful to maintain the distinction.)
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/pg_list.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "nodes/nodes.hpp"
-
-namespace duckdb_libpgquery {
-
-typedef struct PGListCell ListCell;
-
-typedef struct PGList {
-	PGNodeTag		type;			/* duckdb_libpgquery::T_PGList, duckdb_libpgquery::T_PGIntList, or duckdb_libpgquery::T_PGOidList */
-	int			length;
-	PGListCell   *head;
-	PGListCell   *tail;
-} PGList;
-
-struct PGListCell {
-	union
-	{
-		void	   *ptr_value;
-		int			int_value;
-		PGOid			oid_value;
-	}			data;
-	PGListCell   *next;
-};
-
-/*
- * The *only* valid representation of an empty list is NIL; in other
- * words, a non-NIL list is guaranteed to have length >= 1 and
- * head/tail != NULL
- */
-#define NIL						((PGList *) NULL)
-
-/*
- * These routines are used frequently. However, we can't implement
- * them as macros, since we want to avoid double-evaluation of macro
- * arguments.
- */
-static inline PGListCell *
-list_head(const PGList *l)
-{
-	return l ? l->head : NULL;
-}
-
-static inline PGListCell *
-list_tail(PGList *l)
-{
-	return l ? l->tail : NULL;
-}
-
-static inline int
-list_length(const PGList *l)
-{
-	return l ? l->length : 0;
-}
-
-/*
- * NB: There is an unfortunate legacy from a previous incarnation of
- * the PGList API: the macro lfirst() was used to mean "the data in this
- * cons cell". To avoid changing every usage of lfirst(), that meaning
- * has been kept. As a result, lfirst() takes a PGListCell and returns
- * the data it contains; to get the data in the first cell of a
- * PGList, use linitial(). Worse, lsecond() is more closely related to
- * linitial() than lfirst(): given a PGList, lsecond() returns the data
- * in the second cons cell.
- */
-
-#define lnext(lc)				((lc)->next)
-#define lfirst(lc)				((lc)->data.ptr_value)
-#define lfirst_int(lc)			((lc)->data.int_value)
-#define lfirst_oid(lc)			((lc)->data.oid_value)
-#define lfirst_node(type,lc)	castNode(type, lfirst(lc))
-
-#define linitial(l)				lfirst(list_head(l))
-#define linitial_int(l)			lfirst_int(list_head(l))
-#define linitial_oid(l)			lfirst_oid(list_head(l))
-#define linitial_node(type,l)	castNode(type, linitial(l))
-
-#define lsecond(l)				lfirst(lnext(list_head(l)))
-#define lsecond_int(l)			lfirst_int(lnext(list_head(l)))
-#define lsecond_oid(l)			lfirst_oid(lnext(list_head(l)))
-#define lsecond_node(type,l)	castNode(type, lsecond(l))
-
-#define lthird(l)				lfirst(lnext(lnext(list_head(l))))
-#define lthird_int(l)			lfirst_int(lnext(lnext(list_head(l))))
-#define lthird_oid(l)			lfirst_oid(lnext(lnext(list_head(l))))
-#define lthird_node(type,l)		castNode(type, lthird(l))
-
-#define lfourth(l)				lfirst(lnext(lnext(lnext(list_head(l)))))
-#define lfourth_int(l)			lfirst_int(lnext(lnext(lnext(list_head(l)))))
-#define lfourth_oid(l)			lfirst_oid(lnext(lnext(lnext(list_head(l)))))
-#define lfourth_node(type,l)	castNode(type, lfourth(l))
-
-#define llast(l)				lfirst(list_tail(l))
-#define llast_int(l)			lfirst_int(list_tail(l))
-#define llast_oid(l)			lfirst_oid(list_tail(l))
-#define llast_node(type,l)		castNode(type, llast(l))
-
-/*
- * Convenience macros for building fixed-length lists
- */
-#define list_make1(x1)				lcons(x1, NIL)
-#define list_make2(x1,x2)			lcons(x1, list_make1(x2))
-#define list_make3(x1,x2,x3)		lcons(x1, list_make2(x2, x3))
-#define list_make4(x1,x2,x3,x4)		lcons(x1, list_make3(x2, x3, x4))
-#define list_make5(x1,x2,x3,x4,x5)	lcons(x1, list_make4(x2, x3, x4, x5))
-
-#define list_make1_int(x1)			lcons_int(x1, NIL)
-#define list_make2_int(x1,x2)		lcons_int(x1, list_make1_int(x2))
-#define list_make3_int(x1,x2,x3)	lcons_int(x1, list_make2_int(x2, x3))
-#define list_make4_int(x1,x2,x3,x4) lcons_int(x1, list_make3_int(x2, x3, x4))
-#define list_make5_int(x1,x2,x3,x4,x5)	lcons_int(x1, list_make4_int(x2, x3, x4, x5))
-
-#define list_make1_oid(x1)			lcons_oid(x1, NIL)
-#define list_make2_oid(x1,x2)		lcons_oid(x1, list_make1_oid(x2))
-#define list_make3_oid(x1,x2,x3)	lcons_oid(x1, list_make2_oid(x2, x3))
-#define list_make4_oid(x1,x2,x3,x4) lcons_oid(x1, list_make3_oid(x2, x3, x4))
-#define list_make5_oid(x1,x2,x3,x4,x5)	lcons_oid(x1, list_make4_oid(x2, x3, x4, x5))
-
-/*
- * foreach -
- *	  a convenience macro which loops through the list
- */
-#define foreach(cell, l)	\
-	for ((cell) = list_head(l); (cell) != NULL; (cell) = lnext(cell))
-
-/*
- * for_each_cell -
- *	  a convenience macro which loops through a list starting from a
- *	  specified cell
- */
-#define for_each_cell(cell, initcell)	\
-	for ((cell) = (initcell); (cell) != NULL; (cell) = lnext(cell))
-
-/*
- * forboth -
- *	  a convenience macro for advancing through two linked lists
- *	  simultaneously. This macro loops through both lists at the same
- *	  time, stopping when either list runs out of elements. Depending
- *	  on the requirements of the call site, it may also be wise to
- *	  assert that the lengths of the two lists are equal.
- */
-#define forboth(cell1, list1, cell2, list2)							\
-	for ((cell1) = list_head(list1), (cell2) = list_head(list2);	\
-		 (cell1) != NULL && (cell2) != NULL;						\
-		 (cell1) = lnext(cell1), (cell2) = lnext(cell2))
-
-/*
- * for_both_cell -
- *	  a convenience macro which loops through two lists starting from the
- *	  specified cells of each. This macro loops through both lists at the same
- *	  time, stopping when either list runs out of elements.  Depending on the
- *	  requirements of the call site, it may also be wise to assert that the
- *	  lengths of the two lists are equal, and initcell1 and initcell2 are at
- *	  the same position in the respective lists.
- */
-#define for_both_cell(cell1, initcell1, cell2, initcell2)	\
-	for ((cell1) = (initcell1), (cell2) = (initcell2);		\
-		 (cell1) != NULL && (cell2) != NULL;				\
-		 (cell1) = lnext(cell1), (cell2) = lnext(cell2))
-
-/*
- * forthree -
- *	  the same for three lists
- */
-#define forthree(cell1, list1, cell2, list2, cell3, list3)			\
-	for ((cell1) = list_head(list1), (cell2) = list_head(list2), (cell3) = list_head(list3); \
-		 (cell1) != NULL && (cell2) != NULL && (cell3) != NULL;		\
-		 (cell1) = lnext(cell1), (cell2) = lnext(cell2), (cell3) = lnext(cell3))
-
-PGList *lappend(PGList *list, void *datum);
-PGList *lappend_int(PGList *list, int datum);
-PGList *lappend_oid(PGList *list, PGOid datum);
-
-PGListCell *lappend_cell(PGList *list, PGListCell *prev, void *datum);
-PGListCell *lappend_cell_int(PGList *list, PGListCell *prev, int datum);
-PGListCell *lappend_cell_oid(PGList *list, PGListCell *prev, PGOid datum);
-
-PGList *lcons(void *datum, PGList *list);
-PGList *lcons_int(int datum, PGList *list);
-PGList *lcons_oid(PGOid datum, PGList *list);
-
-PGList *list_concat(PGList *list1, PGList *list2);
-PGList *list_truncate(PGList *list, int new_size);
-
-PGListCell *list_nth_cell(const PGList *list, int n);
-void *list_nth(const PGList *list, int n);
-int	list_nth_int(const PGList *list, int n);
-PGOid	list_nth_oid(const PGList *list, int n);
-#define list_nth_node(type,list,n)	castNode(type, list_nth(list, n))
-
-bool list_member(const PGList *list, const void *datum);
-bool list_member_ptr(const PGList *list, const void *datum);
-bool list_member_int(const PGList *list, int datum);
-bool list_member_oid(const PGList *list, PGOid datum);
-
-PGList *list_delete(PGList *list, void *datum);
-PGList *list_delete_ptr(PGList *list, void *datum);
-PGList *list_delete_int(PGList *list, int datum);
-PGList *list_delete_oid(PGList *list, PGOid datum);
-PGList *list_delete_first(PGList *list);
-PGList *list_delete_cell(PGList *list, PGListCell *cell, PGListCell *prev);
-
-PGList *list_union(const PGList *list1, const PGList *list2);
-PGList *list_union_ptr(const PGList *list1, const PGList *list2);
-PGList *list_union_int(const PGList *list1, const PGList *list2);
-PGList *list_union_oid(const PGList *list1, const PGList *list2);
-
-PGList *list_intersection(const PGList *list1, const PGList *list2);
-PGList *list_intersection_int(const PGList *list1, const PGList *list2);
-
-/* currently, there's no need for list_intersection_ptr etc */
-
-PGList *list_difference(const PGList *list1, const PGList *list2);
-PGList *list_difference_ptr(const PGList *list1, const PGList *list2);
-PGList *list_difference_int(const PGList *list1, const PGList *list2);
-PGList *list_difference_oid(const PGList *list1, const PGList *list2);
-
-PGList *list_append_unique(PGList *list, void *datum);
-PGList *list_append_unique_ptr(PGList *list, void *datum);
-PGList *list_append_unique_int(PGList *list, int datum);
-PGList *list_append_unique_oid(PGList *list, PGOid datum);
-
-PGList *list_concat_unique(PGList *list1, PGList *list2);
-PGList *list_concat_unique_ptr(PGList *list1, PGList *list2);
-PGList *list_concat_unique_int(PGList *list1, PGList *list2);
-PGList *list_concat_unique_oid(PGList *list1, PGList *list2);
-
-void list_free(PGList *list);
-void list_free_deep(PGList *list);
-
-PGList *list_copy(const PGList *list);
-PGList *list_copy_tail(const PGList *list, int nskip);
-
-/*
- * To ease migration to the new list API, a set of compatibility
- * macros are provided that reduce the impact of the list API changes
- * as far as possible. Until client code has been rewritten to use the
- * new list API, the ENABLE_LIST_COMPAT symbol can be defined before
- * including pg_list.h
- */
-#ifdef ENABLE_LIST_COMPAT
-
-#define lfirsti(lc)					lfirst_int(lc)
-#define lfirsto(lc)					lfirst_oid(lc)
-
-#define makeList1(x1)				list_make1(x1)
-#define makeList2(x1, x2)			list_make2(x1, x2)
-#define makeList3(x1, x2, x3)		list_make3(x1, x2, x3)
-#define makeList4(x1, x2, x3, x4)	list_make4(x1, x2, x3, x4)
-
-#define makeListi1(x1)				list_make1_int(x1)
-#define makeListi2(x1, x2)			list_make2_int(x1, x2)
-
-#define makeListo1(x1)				list_make1_oid(x1)
-#define makeListo2(x1, x2)			list_make2_oid(x1, x2)
-
-#define lconsi(datum, list)			lcons_int(datum, list)
-#define lconso(datum, list)			lcons_oid(datum, list)
-
-#define lappendi(list, datum)		lappend_int(list, datum)
-#define lappendo(list, datum)		lappend_oid(list, datum)
-
-#define nconc(l1, l2)				list_concat(l1, l2)
-
-#define nth(n, list)				list_nth(list, n)
-
-#define member(datum, list)			list_member(list, datum)
-#define ptrMember(datum, list)		list_member_ptr(list, datum)
-#define intMember(datum, list)		list_member_int(list, datum)
-#define oidMember(datum, list)		list_member_oid(list, datum)
-
-/*
- * Note that the old lremove() determined equality via pointer
- * comparison, whereas the new list_delete() uses equal(); in order to
- * keep the same behavior, we therefore need to map lremove() calls to
- * list_delete_ptr() rather than list_delete()
- */
-#define lremove(elem, list)			list_delete_ptr(list, elem)
-#define LispRemove(elem, list)		list_delete(list, elem)
-#define lremovei(elem, list)		list_delete_int(list, elem)
-#define lremoveo(elem, list)		list_delete_oid(list, elem)
-
-#define ltruncate(n, list)			list_truncate(list, n)
-
-#define set_union(l1, l2)			list_union(l1, l2)
-#define set_uniono(l1, l2)			list_union_oid(l1, l2)
-#define set_ptrUnion(l1, l2)		list_union_ptr(l1, l2)
-
-#define set_difference(l1, l2)		list_difference(l1, l2)
-#define set_differenceo(l1, l2)		list_difference_oid(l1, l2)
-#define set_ptrDifference(l1, l2)	list_difference_ptr(l1, l2)
-
-#define equali(l1, l2)				equal(l1, l2)
-#define equalo(l1, l2)				equal(l1, l2)
-
-#define freeList(list)				list_free(list)
-
-#define listCopy(list)				list_copy(list)
-
-int	length(PGList *list);
-#endif							/* ENABLE_LIST_COMPAT */
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/primnodes.hpp b/src/duckdb/third_party/libpg_query/include/nodes/primnodes.hpp
deleted file mode 100644
index 890c9304e..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/primnodes.hpp
+++ /dev/null
@@ -1,1401 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * primnodes.h
- *	  Definitions for "primitive" node types, those that are used in more
- *	  than one of the parse/plan/execute stages of the query pipeline.
- *	  Currently, these are mostly nodes for executable expressions
- *	  and join trees.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/primnodes.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "access/attnum.hpp"
-#include "nodes/bitmapset.hpp"
-#include "nodes/pg_list.hpp"
-
-namespace duckdb_libpgquery {
-
-/* ----------------------------------------------------------------
- *						node definitions
- * ----------------------------------------------------------------
- */
-
-/*
- * PGAlias -
- *	  specifies an alias for a range variable; the alias might also
- *	  specify renaming of columns within the table.
- *
- * Note: colnames is a list of PGValue nodes (always strings).  In PGAlias structs
- * associated with RTEs, there may be entries corresponding to dropped
- * columns; these are normally empty strings ("").  See parsenodes.h for info.
- */
-typedef struct PGAlias {
-	PGNodeTag type;
-	char *aliasname;  /* aliased rel name (never qualified) */
-	PGList *colnames; /* optional list of column aliases */
-} PGAlias;
-
-/* What to do at commit time for temporary relations */
-typedef enum PGOnCommitAction {
-	PG_ONCOMMIT_NOOP,          /* No ON COMMIT clause (do nothing) */
-	PG_ONCOMMIT_PRESERVE_ROWS, /* ON COMMIT PRESERVE ROWS (do nothing) */
-	PG_ONCOMMIT_DELETE_ROWS,   /* ON COMMIT DELETE ROWS */
-	ONCOMMIT_DROP              /* ON COMMIT DROP */
-} PGOnCommitAction;
-
-/* What to do at commit time for temporary relations */
-typedef enum PGOnCreateConflict {
-	// Standard: throw error
-	PG_ERROR_ON_CONFLICT,
-	// CREATE IF NOT EXISTS, silently do nothing on conflict
-	PG_IGNORE_ON_CONFLICT,
-	// CREATE OR REPLACE
-	PG_REPLACE_ON_CONFLICT
-} PGOnCreateConflict;
-
-/*
- * PGRangeVar - range variable, used in FROM clauses
- *
- * Also used to represent table names in utility statements; there, the alias
- * field is not used, and inh tells whether to apply the operation
- * recursively to child tables.  In some contexts it is also useful to carry
- * a TEMP table indication here.
- */
-typedef struct PGRangeVar {
-	PGNodeTag type;
-	char *catalogname;   /* the catalog (database) name, or NULL */
-	char *schemaname;    /* the schema name, or NULL */
-	char *relname;       /* the relation/sequence name */
-	bool inh;            /* expand rel by inheritance? recursively act
-								 * on children? */
-	char relpersistence; /* see RELPERSISTENCE_* in pg_class.h */
-	PGAlias *alias;      /* table alias & optional column aliases */
-	int location;        /* token location, or -1 if unknown */
-	PGNode *sample;      /* sample, if any */
-} PGRangeVar;
-
-/*
- * PGTableFunc - node for a table function, such as XMLTABLE.
- */
-typedef struct PGTableFunc {
-	PGNodeTag type;
-	PGList *ns_uris;       /* list of namespace uri */
-	PGList *ns_names;      /* list of namespace names */
-	PGNode *docexpr;       /* input document expression */
-	PGNode *rowexpr;       /* row filter expression */
-	PGList *colnames;      /* column names (list of String) */
-	PGList *coltypes;      /* OID list of column type OIDs */
-	PGList *coltypmods;    /* integer list of column typmods */
-	PGList *colcollations; /* OID list of column collation OIDs */
-	PGList *colexprs;      /* list of column filter expressions */
-	PGList *coldefexprs;   /* list of column default expressions */
-	PGBitmapset *notnulls; /* nullability flag for each output column */
-	int ordinalitycol;     /* counts from 0; -1 if none specified */
-	int location;          /* token location, or -1 if unknown */
-} PGTableFunc;
-
-/*
- * PGIntoClause - target information for SELECT INTO, CREATE TABLE AS, and
- * CREATE MATERIALIZED VIEW
- *
- * For CREATE MATERIALIZED VIEW, viewQuery is the parsed-but-not-rewritten
- * SELECT PGQuery for the view; otherwise it's NULL.  (Although it's actually
- * PGQuery*, we declare it as PGNode* to avoid a forward reference.)
- */
-typedef struct PGIntoClause {
-	PGNodeTag type;
-
-	PGRangeVar *rel;           /* target relation name */
-	PGList *colNames;          /* column names to assign, or NIL */
-	PGList *options;           /* options from WITH clause */
-	PGOnCommitAction onCommit; /* what do we do at COMMIT? */
-	char *tableSpaceName;      /* table space to use, or NULL */
-	PGNode *viewQuery;         /* materialized view's SELECT query */
-	bool skipData;             /* true for WITH NO DATA */
-} PGIntoClause;
-
-/* ----------------------------------------------------------------
- *					node types for executable expressions
- * ----------------------------------------------------------------
- */
-
-/*
- * PGExpr - generic superclass for executable-expression nodes
- *
- * All node types that are used in executable expression trees should derive
- * from PGExpr (that is, have PGExpr as their first field).  Since PGExpr only
- * contains PGNodeTag, this is a formality, but it is an easy form of
- * documentation.  See also the ExprState node types in execnodes.h.
- */
-typedef struct PGExpr {
-	PGNodeTag type;
-} PGExpr;
-
-/*
- * PGVar - expression node representing a variable (ie, a table column)
- *
- * Note: during parsing/planning, varnoold/varoattno are always just copies
- * of varno/varattno.  At the tail end of planning, PGVar nodes appearing in
- * upper-level plan nodes are reassigned to point to the outputs of their
- * subplans; for example, in a join node varno becomes INNER_VAR or OUTER_VAR
- * and varattno becomes the index of the proper element of that subplan's
- * target list.  Similarly, INDEX_VAR is used to identify Vars that reference
- * an index column rather than a heap column.  (In PGForeignScan and PGCustomScan
- * plan nodes, INDEX_VAR is abused to signify references to columns of a
- * custom scan tuple type.)  In all these cases, varnoold/varoattno hold the
- * original values.  The code doesn't really need varnoold/varoattno, but they
- * are very useful for debugging and interpreting completed plans, so we keep
- * them around.
- */
-#define INNER_VAR 65000 /* reference to inner subplan */
-#define OUTER_VAR 65001 /* reference to outer subplan */
-#define INDEX_VAR 65002 /* reference to index column */
-
-#define IS_SPECIAL_VARNO(varno) ((varno) >= INNER_VAR)
-
-/* Symbols for the indexes of the special RTE entries in rules */
-#define PRS2_OLD_VARNO 1
-#define PRS2_NEW_VARNO 2
-
-typedef struct PGVar {
-	PGExpr xpr;
-	PGIndex varno;          /* index of this var's relation in the range
-								 * table, or INNER_VAR/OUTER_VAR/INDEX_VAR */
-	PGAttrNumber varattno;  /* attribute number of this var, or zero for
-								 * all */
-	PGOid vartype;          /* pg_type OID for the type of this var */
-	int32_t vartypmod;      /* pg_attribute typmod value */
-	PGOid varcollid;        /* OID of collation, or InvalidOid if none */
-	PGIndex varlevelsup;    /* for subquery variables referencing outer
-								 * relations; 0 in a normal var, >0 means N
-								 * levels up */
-	PGIndex varnoold;       /* original value of varno, for debugging */
-	PGAttrNumber varoattno; /* original value of varattno */
-	int location;           /* token location, or -1 if unknown */
-} PGVar;
-
-/*
- * PGConst
- *
- * Note: for pg_varlena data types, we make a rule that a PGConst node's value
- * must be in non-extended form (4-byte header, no compression or external
- * references).  This ensures that the PGConst node is self-contained and makes
- * it more likely that equal() will see logically identical values as equal.
- */
-typedef struct PGConst {
-	PGExpr xpr;
-	PGOid consttype;     /* pg_type OID of the constant's datatype */
-	int32_t consttypmod; /* typmod value, if any */
-	PGOid constcollid;   /* OID of collation, or InvalidOid if none */
-	int constlen;        /* typlen of the constant's datatype */
-	PGDatum constvalue;  /* the constant's value */
-	bool constisnull;    /* whether the constant is null (if true,
-								 * constvalue is undefined) */
-	bool constbyval;     /* whether this datatype is passed by value.
-								 * If true, then all the information is stored
-								 * in the Datum. If false, then the PGDatum
-								 * contains a pointer to the information. */
-	int location;        /* token location, or -1 if unknown */
-} PGConst;
-
-/*
- * PGParam
- *
- *		paramkind specifies the kind of parameter. The possible values
- *		for this field are:
- *
- *		PG_PARAM_EXTERN:  The parameter value is supplied from outside the plan.
- *				Such parameters are numbered from 1 to n.
- *
- *		PG_PARAM_EXEC:  The parameter is an internal executor parameter, used
- *				for passing values into and out of sub-queries or from
- *				nestloop joins to their inner scans.
- *				For historical reasons, such parameters are numbered from 0.
- *				These numbers are independent of PG_PARAM_EXTERN numbers.
- *
- *		PG_PARAM_SUBLINK:	The parameter represents an output column of a PGSubLink
- *				node's sub-select.  The column number is contained in the
- *				`paramid' field.  (This type of PGParam is converted to
- *				PG_PARAM_EXEC during planning.)
- *
- *		PG_PARAM_MULTIEXPR:  Like PG_PARAM_SUBLINK, the parameter represents an
- *				output column of a PGSubLink node's sub-select, but here, the
- *				PGSubLink is always a MULTIEXPR SubLink.  The high-order 16 bits
- *				of the `paramid' field contain the SubLink's subLinkId, and
- *				the low-order 16 bits contain the column number.  (This type
- *				of PGParam is also converted to PG_PARAM_EXEC during planning.)
- */
-typedef enum PGParamKind { PG_PARAM_EXTERN, PG_PARAM_EXEC, PG_PARAM_SUBLINK, PG_PARAM_MULTIEXPR } PGParamKind;
-
-typedef struct PGParam {
-	PGExpr xpr;
-	PGParamKind paramkind; /* kind of parameter. See above */
-	int paramid;           /* numeric ID for parameter */
-	PGOid paramtype;       /* pg_type OID of parameter's datatype */
-	int32_t paramtypmod;   /* typmod value, if known */
-	PGOid paramcollid;     /* OID of collation, or InvalidOid if none */
-	int location;          /* token location, or -1 if unknown */
-} PGParam;
-
-/*
- * PGAggref
- *
- * The aggregate's args list is a targetlist, ie, a list of PGTargetEntry nodes.
- *
- * For a normal (non-ordered-set) aggregate, the non-resjunk TargetEntries
- * represent the aggregate's regular arguments (if any) and resjunk TLEs can
- * be added at the end to represent ORDER BY expressions that are not also
- * arguments.  As in a top-level PGQuery, the TLEs can be marked with
- * ressortgroupref indexes to let them be referenced by PGSortGroupClause
- * entries in the aggorder and/or aggdistinct lists.  This represents ORDER BY
- * and DISTINCT operations to be applied to the aggregate input rows before
- * they are passed to the transition function.  The grammar only allows a
- * simple "DISTINCT" specifier for the arguments, but we use the full
- * query-level representation to allow more code sharing.
- *
- * For an ordered-set aggregate, the args list represents the WITHIN GROUP
- * (aggregated) arguments, all of which will be listed in the aggorder list.
- * DISTINCT is not supported in this case, so aggdistinct will be NIL.
- * The direct arguments appear in aggdirectargs (as a list of plain
- * expressions, not PGTargetEntry nodes).
- *
- * aggtranstype is the data type of the state transition values for this
- * aggregate (resolved to an actual type, if agg's transtype is polymorphic).
- * This is determined during planning and is InvalidOid before that.
- *
- * aggargtypes is an OID list of the data types of the direct and regular
- * arguments.  Normally it's redundant with the aggdirectargs and args lists,
- * but in a combining aggregate, it's not because the args list has been
- * replaced with a single argument representing the partial-aggregate
- * transition values.
- *
- * aggsplit indicates the expected partial-aggregation mode for the Aggref's
- * parent plan node.  It's always set to PG_AGGSPLIT_SIMPLE in the parser, but
- * the planner might change it to something else.  We use this mainly as
- * a crosscheck that the Aggrefs match the plan; but note that when aggsplit
- * indicates a non-final mode, aggtype reflects the transition data type
- * not the SQL-level output type of the aggregate.
- */
-typedef struct PGAggref {
-	PGExpr xpr;
-	PGOid aggfnoid;        /* pg_proc PGOid of the aggregate */
-	PGOid aggtype;         /* type PGOid of result of the aggregate */
-	PGOid aggcollid;       /* OID of collation of result */
-	PGOid inputcollid;     /* OID of collation that function should use */
-	PGOid aggtranstype;    /* type PGOid of aggregate's transition value */
-	PGList *aggargtypes;   /* type Oids of direct and aggregated args */
-	PGList *aggdirectargs; /* direct arguments, if an ordered-set agg */
-	PGList *args;          /* aggregated arguments and sort expressions */
-	PGList *aggorder;      /* ORDER BY (list of PGSortGroupClause) */
-	PGList *aggdistinct;   /* DISTINCT (list of PGSortGroupClause) */
-	PGExpr *aggfilter;     /* FILTER expression, if any */
-	bool aggstar;          /* true if argument list was really '*' */
-	bool aggvariadic;      /* true if variadic arguments have been
-								 * combined into an array last argument */
-	char aggkind;          /* aggregate kind (see pg_aggregate.h) */
-	PGIndex agglevelsup;   /* > 0 if agg belongs to outer query */
-	PGAggSplit aggsplit;   /* expected agg-splitting mode of parent PGAgg */
-	int location;          /* token location, or -1 if unknown */
-} PGAggref;
-
-/*
- * PGGroupingFunc
- *
- * A PGGroupingFunc is a GROUPING(...) expression, which behaves in many ways
- * like an aggregate function (e.g. it "belongs" to a specific query level,
- * which might not be the one immediately containing it), but also differs in
- * an important respect: it never evaluates its arguments, they merely
- * designate expressions from the GROUP BY clause of the query level to which
- * it belongs.
- *
- * The spec defines the evaluation of GROUPING() purely by syntactic
- * replacement, but we make it a real expression for optimization purposes so
- * that one PGAgg node can handle multiple grouping sets at once.  Evaluating the
- * result only needs the column positions to check against the grouping set
- * being projected.  However, for EXPLAIN to produce meaningful output, we have
- * to keep the original expressions around, since expression deparse does not
- * give us any feasible way to get at the GROUP BY clause.
- *
- * Also, we treat two PGGroupingFunc nodes as equal if they have equal arguments
- * lists and agglevelsup, without comparing the refs and cols annotations.
- *
- * In raw parse output we have only the args list; parse analysis fills in the
- * refs list, and the planner fills in the cols list.
- */
-typedef struct PGGroupingFunc {
-	PGExpr xpr;
-	PGList *args;        /* arguments, not evaluated but kept for
-								 * benefit of EXPLAIN etc. */
-	PGList *refs;        /* ressortgrouprefs of arguments */
-	PGList *cols;        /* actual column positions set by planner */
-	PGIndex agglevelsup; /* same as Aggref.agglevelsup */
-	int location;        /* token location */
-} PGGroupingFunc;
-
-/*
- * PGWindowFunc
- */
-typedef struct PGWindowFunc {
-	PGExpr xpr;
-	PGOid winfnoid;    /* pg_proc PGOid of the function */
-	PGOid wintype;     /* type PGOid of result of the window function */
-	PGOid wincollid;   /* OID of collation of result */
-	PGOid inputcollid; /* OID of collation that function should use */
-	PGList *args;      /* arguments to the window function */
-	PGExpr *aggfilter; /* FILTER expression, if any */
-	PGIndex winref;    /* index of associated PGWindowClause */
-	bool winstar;      /* true if argument list was really '*' */
-	bool winagg;       /* is function a simple aggregate? */
-	int location;      /* token location, or -1 if unknown */
-} PGWindowFunc;
-
-/* ----------------
- *	PGArrayRef: describes an array subscripting operation
- *
- * An PGArrayRef can describe fetching a single element from an array,
- * fetching a subarray (array slice), storing a single element into
- * an array, or storing a slice.  The "store" cases work with an
- * initial array value and a source value that is inserted into the
- * appropriate part of the array; the result of the operation is an
- * entire new modified array value.
- *
- * If reflowerindexpr = NIL, then we are fetching or storing a single array
- * element at the subscripts given by refupperindexpr.  Otherwise we are
- * fetching or storing an array slice, that is a rectangular subarray
- * with lower and upper bounds given by the index expressions.
- * reflowerindexpr must be the same length as refupperindexpr when it
- * is not NIL.
- *
- * In the slice case, individual expressions in the subscript lists can be
- * NULL, meaning "substitute the array's current lower or upper bound".
- *
- * Note: the result datatype is the element type when fetching a single
- * element; but it is the array type when doing subarray fetch or either
- * type of store.
- *
- * Note: for the cases where an array is returned, if refexpr yields a R/W
- * expanded array, then the implementation is allowed to modify that object
- * in-place and return the same object.)
- * ----------------
- */
-typedef struct PGArrayRef {
-	PGExpr xpr;
-	PGOid refarraytype;      /* type of the array proper */
-	PGOid refelemtype;       /* type of the array elements */
-	int32_t reftypmod;       /* typmod of the array (and elements too) */
-	PGOid refcollid;         /* OID of collation, or InvalidOid if none */
-	PGList *refupperindexpr; /* expressions that evaluate to upper
-									 * array indexes */
-	PGList *reflowerindexpr; /* expressions that evaluate to lower
-									 * array indexes, or NIL for single array
-									 * element */
-	PGExpr *refexpr;         /* the expression that evaluates to an array
-								 * value */
-	PGExpr *refassgnexpr;    /* expression for the source value, or NULL if
-								 * fetch */
-} PGArrayRef;
-
-/*
- * PGCoercionContext - distinguishes the allowed set of type casts
- *
- * NB: ordering of the alternatives is significant; later (larger) values
- * allow more casts than earlier ones.
- */
-typedef enum PGCoercionContext {
-	PG_COERCION_IMPLICIT,   /* coercion in context of expression */
-	PG_COERCION_ASSIGNMENT, /* coercion in context of assignment */
-	PG_COERCION_EXPLICIT    /* explicit cast operation */
-} PGCoercionContext;
-
-/*
- * PGCoercionForm - how to display a node that could have come from a cast
- *
- * NB: equal() ignores PGCoercionForm fields, therefore this *must* not carry
- * any semantically significant information.  We need that behavior so that
- * the planner will consider equivalent implicit and explicit casts to be
- * equivalent.  In cases where those actually behave differently, the coercion
- * function's arguments will be different.
- */
-typedef enum PGCoercionForm {
-	PG_COERCE_EXPLICIT_CALL, /* display as a function call */
-	PG_COERCE_EXPLICIT_CAST, /* display as an explicit cast */
-	PG_COERCE_IMPLICIT_CAST  /* implicit cast, so hide it */
-} PGCoercionForm;
-
-/*
- * PGFuncExpr - expression node for a function call
- */
-typedef struct PGFuncExpr {
-	PGExpr xpr;
-	PGOid funcid;              /* PG_PROC OID of the function */
-	PGOid funcresulttype;      /* PG_TYPE OID of result value */
-	bool funcretset;           /* true if function returns set */
-	bool funcvariadic;         /* true if variadic arguments have been
-								 * combined into an array last argument */
-	PGCoercionForm funcformat; /* how to display this function call */
-	PGOid funccollid;          /* OID of collation of result */
-	PGOid inputcollid;         /* OID of collation that function should use */
-	PGList *args;              /* arguments to the function */
-	int location;              /* token location, or -1 if unknown */
-} PGFuncExpr;
-
-/*
- * PGNamedArgExpr - a named argument of a function
- *
- * This node type can only appear in the args list of a PGFuncCall or PGFuncExpr
- * node.  We support pure positional call notation (no named arguments),
- * named notation (all arguments are named), and mixed notation (unnamed
- * arguments followed by named ones).
- *
- * Parse analysis sets argnumber to the positional index of the argument,
- * but doesn't rearrange the argument list.
- *
- * The planner will convert argument lists to pure positional notation
- * during expression preprocessing, so execution never sees a NamedArgExpr.
- */
-typedef struct PGNamedArgExpr {
-	PGExpr xpr;
-	PGExpr *arg;   /* the argument expression */
-	char *name;    /* the name */
-	int argnumber; /* argument's number in positional notation */
-	int location;  /* argument name location, or -1 if unknown */
-} PGNamedArgExpr;
-
-/*
- * PGOpExpr - expression node for an operator invocation
- *
- * Semantically, this is essentially the same as a function call.
- *
- * Note that opfuncid is not necessarily filled in immediately on creation
- * of the node.  The planner makes sure it is valid before passing the node
- * tree to the executor, but during parsing/planning opfuncid can be 0.
- */
-typedef struct PGOpExpr {
-	PGExpr xpr;
-	PGOid opno;         /* PG_OPERATOR OID of the operator */
-	PGOid opfuncid;     /* PG_PROC OID of underlying function */
-	PGOid opresulttype; /* PG_TYPE OID of result value */
-	bool opretset;      /* true if operator returns set */
-	PGOid opcollid;     /* OID of collation of result */
-	PGOid inputcollid;  /* OID of collation that operator should use */
-	PGList *args;       /* arguments to the operator (1 or 2) */
-	int location;       /* token location, or -1 if unknown */
-} PGOpExpr;
-
-/*
- * DistinctExpr - expression node for "x IS DISTINCT FROM y"
- *
- * Except for the nodetag, this is represented identically to an PGOpExpr
- * referencing the "=" operator for x and y.
- * We use "=", not the more obvious "<>", because more datatypes have "="
- * than "<>".  This means the executor must invert the operator result.
- * Note that the operator function won't be called at all if either input
- * is NULL, since then the result can be determined directly.
- */
-typedef PGOpExpr DistinctExpr;
-
-/*
- * NullIfExpr - a NULLIF expression
- *
- * Like DistinctExpr, this is represented the same as an PGOpExpr referencing
- * the "=" operator for x and y.
- */
-typedef PGOpExpr NullIfExpr;
-
-/*
- * PGScalarArrayOpExpr - expression node for "scalar op ANY/ALL (array)"
- *
- * The operator must yield boolean.  It is applied to the left operand
- * and each element of the righthand array, and the results are combined
- * with OR or AND (for ANY or ALL respectively).  The node representation
- * is almost the same as for the underlying operator, but we need a useOr
- * flag to remember whether it's ANY or ALL, and we don't have to store
- * the result type (or the collation) because it must be boolean.
- */
-typedef struct PGScalarArrayOpExpr {
-	PGExpr xpr;
-	PGOid opno;        /* PG_OPERATOR OID of the operator */
-	PGOid opfuncid;    /* PG_PROC OID of underlying function */
-	bool useOr;        /* true for ANY, false for ALL */
-	PGOid inputcollid; /* OID of collation that operator should use */
-	PGList *args;      /* the scalar and array operands */
-	int location;      /* token location, or -1 if unknown */
-} PGScalarArrayOpExpr;
-
-/*
- * PGBoolExpr - expression node for the basic Boolean operators AND, OR, NOT
- *
- * Notice the arguments are given as a List.  For NOT, of course the list
- * must always have exactly one element.  For AND and OR, there can be two
- * or more arguments.
- */
-typedef enum PGBoolExprType { PG_AND_EXPR, PG_OR_EXPR, PG_NOT_EXPR } PGBoolExprType;
-
-typedef struct PGBoolExpr {
-	PGExpr xpr;
-	PGBoolExprType boolop;
-	PGList *args; /* arguments to this expression */
-	int location; /* token location, or -1 if unknown */
-} PGBoolExpr;
-
-/*
- * PGSubLink
- *
- * A PGSubLink represents a subselect appearing in an expression, and in some
- * cases also the combining operator(s) just above it.  The subLinkType
- * indicates the form of the expression represented:
- *	PG_EXISTS_SUBLINK		EXISTS(SELECT ...)
- *	PG_ALL_SUBLINK			(lefthand) op ALL (SELECT ...)
- *	PG_ANY_SUBLINK			(lefthand) op ANY (SELECT ...)
- *	PG_ROWCOMPARE_SUBLINK	(lefthand) op (SELECT ...)
- *	PG_EXPR_SUBLINK		(SELECT with single targetlist item ...)
- *	PG_MULTIEXPR_SUBLINK	(SELECT with multiple targetlist items ...)
- *	PG_ARRAY_SUBLINK		ARRAY(SELECT with single targetlist item ...)
- *	PG_CTE_SUBLINK			WITH query (never actually part of an expression)
- * For ALL, ANY, and ROWCOMPARE, the lefthand is a list of expressions of the
- * same length as the subselect's targetlist.  ROWCOMPARE will *always* have
- * a list with more than one entry; if the subselect has just one target
- * then the parser will create an PG_EXPR_SUBLINK instead (and any operator
- * above the subselect will be represented separately).
- * ROWCOMPARE, EXPR, and MULTIEXPR require the subselect to deliver at most
- * one row (if it returns no rows, the result is NULL).
- * ALL, ANY, and ROWCOMPARE require the combining operators to deliver boolean
- * results.  ALL and ANY combine the per-row results using AND and OR
- * semantics respectively.
- * ARRAY requires just one target column, and creates an array of the target
- * column's type using any number of rows resulting from the subselect.
- *
- * PGSubLink is classed as an PGExpr node, but it is not actually executable;
- * it must be replaced in the expression tree by a PGSubPlan node during
- * planning.
- *
- * NOTE: in the raw output of gram.y, testexpr contains just the raw form
- * of the lefthand expression (if any), and operName is the String name of
- * the combining operator.  Also, subselect is a raw parsetree.  During parse
- * analysis, the parser transforms testexpr into a complete boolean expression
- * that compares the lefthand value(s) to PG_PARAM_SUBLINK nodes representing the
- * output columns of the subselect.  And subselect is transformed to a Query.
- * This is the representation seen in saved rules and in the rewriter.
- *
- * In EXISTS, EXPR, MULTIEXPR, and ARRAY SubLinks, testexpr and operName
- * are unused and are always null.
- *
- * subLinkId is currently used only for MULTIEXPR SubLinks, and is zero in
- * other SubLinks.  This number identifies different multiple-assignment
- * subqueries within an UPDATE statement's SET list.  It is unique only
- * within a particular targetlist.  The output column(s) of the MULTIEXPR
- * are referenced by PG_PARAM_MULTIEXPR Params appearing elsewhere in the tlist.
- *
- * The PG_CTE_SUBLINK case never occurs in actual PGSubLink nodes, but it is used
- * in SubPlans generated for WITH subqueries.
- */
-typedef enum PGSubLinkType {
-	PG_EXISTS_SUBLINK,
-	PG_ALL_SUBLINK,
-	PG_ANY_SUBLINK,
-	PG_ROWCOMPARE_SUBLINK,
-	PG_EXPR_SUBLINK,
-	PG_MULTIEXPR_SUBLINK,
-	PG_ARRAY_SUBLINK,
-	PG_CTE_SUBLINK /* for SubPlans only */
-} PGSubLinkType;
-
-typedef struct PGSubLink {
-	PGExpr xpr;
-	PGSubLinkType subLinkType; /* see above */
-	int subLinkId;             /* ID (1..n); 0 if not MULTIEXPR */
-	PGNode *testexpr;          /* outer-query test for ALL/ANY/ROWCOMPARE */
-	PGList *operName;          /* originally specified operator name */
-	PGNode *subselect;         /* subselect as PGQuery* or raw parsetree */
-	int location;              /* token location, or -1 if unknown */
-} PGSubLink;
-
-/*
- * PGSubPlan - executable expression node for a subplan (sub-SELECT)
- *
- * The planner replaces PGSubLink nodes in expression trees with PGSubPlan
- * nodes after it has finished planning the subquery.  PGSubPlan references
- * a sub-plantree stored in the subplans list of the toplevel PlannedStmt.
- * (We avoid a direct link to make it easier to copy expression trees
- * without causing multiple processing of the subplan.)
- *
- * In an ordinary subplan, testexpr points to an executable expression
- * (PGOpExpr, an AND/OR tree of OpExprs, or PGRowCompareExpr) for the combining
- * operator(s); the left-hand arguments are the original lefthand expressions,
- * and the right-hand arguments are PG_PARAM_EXEC PGParam nodes representing the
- * outputs of the sub-select.  (NOTE: runtime coercion functions may be
- * inserted as well.)  This is just the same expression tree as testexpr in
- * the original PGSubLink node, but the PG_PARAM_SUBLINK nodes are replaced by
- * suitably numbered PG_PARAM_EXEC nodes.
- *
- * If the sub-select becomes an initplan rather than a subplan, the executable
- * expression is part of the outer plan's expression tree (and the PGSubPlan
- * node itself is not, but rather is found in the outer plan's initPlan
- * list).  In this case testexpr is NULL to avoid duplication.
- *
- * The planner also derives lists of the values that need to be passed into
- * and out of the subplan.  Input values are represented as a list "args" of
- * expressions to be evaluated in the outer-query context (currently these
- * args are always just Vars, but in principle they could be any expression).
- * The values are assigned to the global PG_PARAM_EXEC params indexed by parParam
- * (the parParam and args lists must have the same ordering).  setParam is a
- * list of the PG_PARAM_EXEC params that are computed by the sub-select, if it
- * is an initplan; they are listed in order by sub-select output column
- * position.  (parParam and setParam are integer Lists, not Bitmapsets,
- * because their ordering is significant.)
- *
- * Also, the planner computes startup and per-call costs for use of the
- * SubPlan.  Note that these include the cost of the subquery proper,
- * evaluation of the testexpr if any, and any hashtable management overhead.
- */
-typedef struct PGSubPlan {
-	PGExpr xpr;
-	/* Fields copied from original PGSubLink: */
-	PGSubLinkType subLinkType; /* see above */
-	/* The combining operators, transformed to an executable expression: */
-	PGNode *testexpr; /* PGOpExpr or PGRowCompareExpr expression tree */
-	PGList *paramIds; /* IDs of Params embedded in the above */
-	/* Identification of the PGPlan tree to use: */
-	int plan_id; /* PGIndex (from 1) in PlannedStmt.subplans */
-	/* Identification of the PGSubPlan for EXPLAIN and debugging purposes: */
-	char *plan_name; /* A name assigned during planning */
-	/* Extra data useful for determining subplan's output type: */
-	PGOid firstColType;      /* Type of first column of subplan result */
-	int32_t firstColTypmod;  /* Typmod of first column of subplan result */
-	PGOid firstColCollation; /* Collation of first column of subplan
-									 * result */
-	/* Information about execution strategy: */
-	bool useHashTable;   /* true to store subselect output in a hash
-								 * table (implies we are doing "IN") */
-	bool unknownEqFalse; /* true if it's okay to return false when the
-								 * spec result is UNKNOWN; this allows much
-								 * simpler handling of null values */
-	bool parallel_safe;  /* is the subplan parallel-safe? */
-	/* Note: parallel_safe does not consider contents of testexpr or args */
-	/* Information for passing params into and out of the subselect: */
-	/* setParam and parParam are lists of integers (param IDs) */
-	PGList *setParam; /* initplan subqueries have to set these
-								 * Params for parent plan */
-	PGList *parParam; /* indices of input Params from parent plan */
-	PGList *args;     /* exprs to pass as parParam values */
-	/* Estimated execution costs: */
-	Cost startup_cost;  /* one-time setup cost */
-	Cost per_call_cost; /* cost for each subplan evaluation */
-} PGSubPlan;
-
-/*
- * PGAlternativeSubPlan - expression node for a choice among SubPlans
- *
- * The subplans are given as a PGList so that the node definition need not
- * change if there's ever more than two alternatives.  For the moment,
- * though, there are always exactly two; and the first one is the fast-start
- * plan.
- */
-typedef struct PGAlternativeSubPlan {
-	PGExpr xpr;
-	PGList *subplans; /* SubPlan(s) with equivalent results */
-} PGAlternativeSubPlan;
-
-/* ----------------
- * PGFieldSelect
- *
- * PGFieldSelect represents the operation of extracting one field from a tuple
- * value.  At runtime, the input expression is expected to yield a rowtype
- * Datum.  The specified field number is extracted and returned as a Datum.
- * ----------------
- */
-
-typedef struct PGFieldSelect {
-	PGExpr xpr;
-	PGExpr *arg;           /* input expression */
-	PGAttrNumber fieldnum; /* attribute number of field to extract */
-	PGOid resulttype;      /* type of the field (result type of this
-								 * node) */
-	int32_t resulttypmod;  /* output typmod (usually -1) */
-	PGOid resultcollid;    /* OID of collation of the field */
-} PGFieldSelect;
-
-/* ----------------
- * PGFieldStore
- *
- * PGFieldStore represents the operation of modifying one field in a tuple
- * value, yielding a new tuple value (the input is not touched!).  Like
- * the assign case of PGArrayRef, this is used to implement UPDATE of a
- * portion of a column.
- *
- * A single PGFieldStore can actually represent updates of several different
- * fields.  The parser only generates FieldStores with single-element lists,
- * but the planner will collapse multiple updates of the same base column
- * into one FieldStore.
- * ----------------
- */
-
-typedef struct PGFieldStore {
-	PGExpr xpr;
-	PGExpr *arg;       /* input tuple value */
-	PGList *newvals;   /* new value(s) for field(s) */
-	PGList *fieldnums; /* integer list of field attnums */
-	PGOid resulttype;  /* type of result (same as type of arg) */
-	                   /* Like PGRowExpr, we deliberately omit a typmod and collation here */
-} PGFieldStore;
-
-/* ----------------
- * PGRelabelType
- *
- * PGRelabelType represents a "dummy" type coercion between two binary-
- * compatible datatypes, such as reinterpreting the result of an OID
- * expression as an int4.  It is a no-op at runtime; we only need it
- * to provide a place to store the correct type to be attributed to
- * the expression result during type resolution.  (We can't get away
- * with just overwriting the type field of the input expression node,
- * so we need a separate node to show the coercion's result type.)
- * ----------------
- */
-
-typedef struct PGRelabelType {
-	PGExpr xpr;
-	PGExpr *arg;                  /* input expression */
-	PGOid resulttype;             /* output type of coercion expression */
-	int32_t resulttypmod;         /* output typmod (usually -1) */
-	PGOid resultcollid;           /* OID of collation, or InvalidOid if none */
-	PGCoercionForm relabelformat; /* how to display this node */
-	int location;                 /* token location, or -1 if unknown */
-} PGRelabelType;
-
-/* ----------------
- * PGCoerceViaIO
- *
- * PGCoerceViaIO represents a type coercion between two types whose textual
- * representations are compatible, implemented by invoking the source type's
- * typoutput function then the destination type's typinput function.
- * ----------------
- */
-
-typedef struct PGCoerceViaIO {
-	PGExpr xpr;
-	PGExpr *arg;      /* input expression */
-	PGOid resulttype; /* output type of coercion */
-	/* output typmod is not stored, but is presumed -1 */
-	PGOid resultcollid;          /* OID of collation, or InvalidOid if none */
-	PGCoercionForm coerceformat; /* how to display this node */
-	int location;                /* token location, or -1 if unknown */
-} PGCoerceViaIO;
-
-/* ----------------
- * PGArrayCoerceExpr
- *
- * PGArrayCoerceExpr represents a type coercion from one array type to another,
- * which is implemented by applying the indicated element-type coercion
- * function to each element of the source array.  If elemfuncid is InvalidOid
- * then the element types are binary-compatible, but the coercion still
- * requires some effort (we have to fix the element type ID stored in the
- * array header).
- * ----------------
- */
-
-typedef struct PGArrayCoerceExpr {
-	PGExpr xpr;
-	PGExpr *arg;                 /* input expression (yields an array) */
-	PGOid elemfuncid;            /* OID of element coercion function, or 0 */
-	PGOid resulttype;            /* output type of coercion (an array type) */
-	int32_t resulttypmod;        /* output typmod (also element typmod) */
-	PGOid resultcollid;          /* OID of collation, or InvalidOid if none */
-	bool isExplicit;             /* conversion semantics flag to pass to func */
-	PGCoercionForm coerceformat; /* how to display this node */
-	int location;                /* token location, or -1 if unknown */
-} PGArrayCoerceExpr;
-
-/* ----------------
- * PGConvertRowtypeExpr
- *
- * PGConvertRowtypeExpr represents a type coercion from one composite type
- * to another, where the source type is guaranteed to contain all the columns
- * needed for the destination type plus possibly others; the columns need not
- * be in the same positions, but are matched up by name.  This is primarily
- * used to convert a whole-row value of an inheritance child table into a
- * valid whole-row value of its parent table's rowtype.
- * ----------------
- */
-
-typedef struct PGConvertRowtypeExpr {
-	PGExpr xpr;
-	PGExpr *arg;      /* input expression */
-	PGOid resulttype; /* output type (always a composite type) */
-	/* Like PGRowExpr, we deliberately omit a typmod and collation here */
-	PGCoercionForm convertformat; /* how to display this node */
-	int location;                 /* token location, or -1 if unknown */
-} PGConvertRowtypeExpr;
-
-/*----------
- * PGCollateExpr - COLLATE
- *
- * The planner replaces PGCollateExpr with PGRelabelType during expression
- * preprocessing, so execution never sees a CollateExpr.
- *----------
- */
-typedef struct PGCollateExpr {
-	PGExpr xpr;
-	PGExpr *arg;   /* input expression */
-	PGOid collOid; /* collation's OID */
-	int location;  /* token location, or -1 if unknown */
-} PGCollateExpr;
-
-/*----------
- * PGCaseExpr - a CASE expression
- *
- * We support two distinct forms of CASE expression:
- *		CASE WHEN boolexpr THEN expr [ WHEN boolexpr THEN expr ... ]
- *		CASE testexpr WHEN compexpr THEN expr [ WHEN compexpr THEN expr ... ]
- * These are distinguishable by the "arg" field being NULL in the first case
- * and the testexpr in the second case.
- *
- * In the raw grammar output for the second form, the condition expressions
- * of the WHEN clauses are just the comparison values.  Parse analysis
- * converts these to valid boolean expressions of the form
- *		PGCaseTestExpr '=' compexpr
- * where the PGCaseTestExpr node is a placeholder that emits the correct
- * value at runtime.  This structure is used so that the testexpr need be
- * evaluated only once.  Note that after parse analysis, the condition
- * expressions always yield boolean.
- *
- * Note: we can test whether a PGCaseExpr has been through parse analysis
- * yet by checking whether casetype is InvalidOid or not.
- *----------
- */
-typedef struct PGCaseExpr {
-	PGExpr xpr;
-	PGOid casetype;    /* type of expression result */
-	PGOid casecollid;  /* OID of collation, or InvalidOid if none */
-	PGExpr *arg;       /* implicit equality comparison argument */
-	PGList *args;      /* the arguments (list of WHEN clauses) */
-	PGExpr *defresult; /* the default result (ELSE clause) */
-	int location;      /* token location, or -1 if unknown */
-} PGCaseExpr;
-
-/*
- * PGCaseWhen - one arm of a CASE expression
- */
-typedef struct PGCaseWhen {
-	PGExpr xpr;
-	PGExpr *expr;   /* condition expression */
-	PGExpr *result; /* substitution result */
-	int location;   /* token location, or -1 if unknown */
-} PGCaseWhen;
-
-/*
- * Placeholder node for the test value to be processed by a CASE expression.
- * This is effectively like a PGParam, but can be implemented more simply
- * since we need only one replacement value at a time.
- *
- * We also use this in nested UPDATE expressions.
- * See transformAssignmentIndirection().
- */
-typedef struct PGCaseTestExpr {
-	PGExpr xpr;
-	PGOid typeId;    /* type for substituted value */
-	int32_t typeMod; /* typemod for substituted value */
-	PGOid collation; /* collation for the substituted value */
-} PGCaseTestExpr;
-
-/*
- * PGArrayExpr - an ARRAY[] expression
- *
- * Note: if multidims is false, the constituent expressions all yield the
- * scalar type identified by element_typeid.  If multidims is true, the
- * constituent expressions all yield arrays of element_typeid (ie, the same
- * type as array_typeid); at runtime we must check for compatible subscripts.
- */
-typedef struct PGArrayExpr {
-	PGExpr xpr;
-	PGOid array_typeid;   /* type of expression result */
-	PGOid array_collid;   /* OID of collation, or InvalidOid if none */
-	PGOid element_typeid; /* common type of array elements */
-	PGList *elements;     /* the array elements or sub-arrays */
-	bool multidims;       /* true if elements are sub-arrays */
-	int location;         /* token location, or -1 if unknown */
-} PGArrayExpr;
-
-/*
- * PGRowExpr - a ROW() expression
- *
- * Note: the list of fields must have a one-for-one correspondence with
- * physical fields of the associated rowtype, although it is okay for it
- * to be shorter than the rowtype.  That is, the N'th list element must
- * match up with the N'th physical field.  When the N'th physical field
- * is a dropped column (attisdropped) then the N'th list element can just
- * be a NULL constant.  (This case can only occur for named composite types,
- * not RECORD types, since those are built from the PGRowExpr itself rather
- * than vice versa.)  It is important not to assume that length(args) is
- * the same as the number of columns logically present in the rowtype.
- *
- * colnames provides field names in cases where the names can't easily be
- * obtained otherwise.  Names *must* be provided if row_typeid is RECORDOID.
- * If row_typeid identifies a known composite type, colnames can be NIL to
- * indicate the type's cataloged field names apply.  Note that colnames can
- * be non-NIL even for a composite type, and typically is when the PGRowExpr
- * was created by expanding a whole-row Var.  This is so that we can retain
- * the column alias names of the RTE that the PGVar referenced (which would
- * otherwise be very difficult to extract from the parsetree).  Like the
- * args list, colnames is one-for-one with physical fields of the rowtype.
- */
-typedef struct PGRowExpr {
-	PGExpr xpr;
-	PGList *args;     /* the fields */
-	PGOid row_typeid; /* RECORDOID or a composite type's ID */
-
-	/*
-	 * Note: we deliberately do NOT store a typmod.  Although a typmod will be
-	 * associated with specific RECORD types at runtime, it will differ for
-	 * different backends, and so cannot safely be stored in stored
-	 * parsetrees.  We must assume typmod -1 for a PGRowExpr node.
-	 *
-	 * We don't need to store a collation either.  The result type is
-	 * necessarily composite, and composite types never have a collation.
-	 */
-	PGCoercionForm row_format; /* how to display this node */
-	PGList *colnames;          /* list of String, or NIL */
-	int location;              /* token location, or -1 if unknown */
-} PGRowExpr;
-
-/*
- * PGRowCompareExpr - row-wise comparison, such as (a, b) <= (1, 2)
- *
- * We support row comparison for any operator that can be determined to
- * act like =, <>, <, <=, >, or >= (we determine this by looking for the
- * operator in btree opfamilies).  Note that the same operator name might
- * map to a different operator for each pair of row elements, since the
- * element datatypes can vary.
- *
- * A PGRowCompareExpr node is only generated for the < <= > >= cases;
- * the = and <> cases are translated to simple AND or OR combinations
- * of the pairwise comparisons.  However, we include = and <> in the
- * PGRowCompareType enum for the convenience of parser logic.
- */
-typedef enum PGRowCompareType {
-	/* Values of this enum are chosen to match btree strategy numbers */
-	PG_ROWCOMPARE_LT = 1, /* BTLessStrategyNumber */
-	PG_ROWCOMPARE_LE = 2, /* BTLessEqualStrategyNumber */
-	PG_ROWCOMPARE_EQ = 3, /* BTEqualStrategyNumber */
-	PG_ROWCOMPARE_GE = 4, /* BTGreaterEqualStrategyNumber */
-	PG_ROWCOMPARE_GT = 5, /* BTGreaterStrategyNumber */
-	PG_ROWCOMPARE_NE = 6  /* no such btree strategy */
-} PGRowCompareType;
-
-typedef struct PGRowCompareExpr {
-	PGExpr xpr;
-	PGRowCompareType rctype; /* LT LE GE or GT, never EQ or NE */
-	PGList *opnos;           /* OID list of pairwise comparison ops */
-	PGList *opfamilies;      /* OID list of containing operator families */
-	PGList *inputcollids;    /* OID list of collations for comparisons */
-	PGList *largs;           /* the left-hand input arguments */
-	PGList *rargs;           /* the right-hand input arguments */
-} PGRowCompareExpr;
-
-/*
- * PGCoalesceExpr - a COALESCE expression
- */
-typedef struct PGCoalesceExpr {
-	PGExpr xpr;
-	PGOid coalescetype;   /* type of expression result */
-	PGOid coalescecollid; /* OID of collation, or InvalidOid if none */
-	PGList *args;         /* the arguments */
-	int location;         /* token location, or -1 if unknown */
-} PGCoalesceExpr;
-
-/*
- * PGMinMaxExpr - a GREATEST or LEAST function
- */
-typedef enum PGMinMaxOp { PG_IS_GREATEST, IS_LEAST } PGMinMaxOp;
-
-typedef struct PGMinMaxExpr {
-	PGExpr xpr;
-	PGOid minmaxtype;   /* common type of arguments and result */
-	PGOid minmaxcollid; /* OID of collation of result */
-	PGOid inputcollid;  /* OID of collation that function should use */
-	PGMinMaxOp op;      /* function to execute */
-	PGList *args;       /* the arguments */
-	int location;       /* token location, or -1 if unknown */
-} PGMinMaxExpr;
-
-/*
- * PGSQLValueFunction - parameterless functions with special grammar productions
- *
- * The SQL standard categorizes some of these as <datetime value function>
- * and others as <general value specification>.  We call 'em SQLValueFunctions
- * for lack of a better term.  We store type and typmod of the result so that
- * some code doesn't need to know each function individually, and because
- * we would need to store typmod anyway for some of the datetime functions.
- * Note that currently, all variants return non-collating datatypes, so we do
- * not need a collation field; also, all these functions are stable.
- */
-typedef enum PGSQLValueFunctionOp {
-	PG_SVFOP_CURRENT_DATE,
-	PG_SVFOP_CURRENT_TIME,
-	PG_SVFOP_CURRENT_TIME_N,
-	PG_SVFOP_CURRENT_TIMESTAMP,
-	PG_SVFOP_CURRENT_TIMESTAMP_N,
-	PG_SVFOP_LOCALTIME,
-	PG_SVFOP_LOCALTIME_N,
-	PG_SVFOP_LOCALTIMESTAMP,
-	PG_SVFOP_LOCALTIMESTAMP_N,
-	PG_SVFOP_CURRENT_ROLE,
-	PG_SVFOP_CURRENT_USER,
-	PG_SVFOP_USER,
-	PG_SVFOP_SESSION_USER,
-	PG_SVFOP_CURRENT_CATALOG,
-	PG_SVFOP_CURRENT_SCHEMA
-} PGSQLValueFunctionOp;
-
-typedef struct PGSQLValueFunction {
-	PGExpr xpr;
-	PGSQLValueFunctionOp op; /* which function this is */
-	PGOid type;              /* result type/typmod */
-	int32_t typmod;
-	int location; /* token location, or -1 if unknown */
-} PGSQLValueFunction;
-
-/* ----------------
- * PGNullTest
- *
- * PGNullTest represents the operation of testing a value for NULLness.
- * The appropriate test is performed and returned as a boolean Datum.
- *
- * When argisrow is false, this simply represents a test for the null value.
- *
- * When argisrow is true, the input expression must yield a rowtype, and
- * the node implements "row IS [NOT] NULL" per the SQL standard.  This
- * includes checking individual fields for NULLness when the row datum
- * itself isn't NULL.
- *
- * NOTE: the combination of a rowtype input and argisrow==false does NOT
- * correspond to the SQL notation "row IS [NOT] NULL"; instead, this case
- * represents the SQL notation "row IS [NOT] DISTINCT FROM NULL".
- * ----------------
- */
-
-typedef enum PGNullTestType { PG_IS_NULL, IS_NOT_NULL } PGNullTestType;
-
-typedef struct PGNullTest {
-	PGExpr xpr;
-	PGExpr *arg;                 /* input expression */
-	PGNullTestType nulltesttype; /* IS NULL, IS NOT NULL */
-	bool argisrow;               /* T to perform field-by-field null checks */
-	int location;                /* token location, or -1 if unknown */
-} PGNullTest;
-
-/*
- * PGBooleanTest
- *
- * PGBooleanTest represents the operation of determining whether a boolean
- * is true, false, or UNKNOWN (ie, NULL).  All six meaningful combinations
- * are supported.  Note that a NULL input does *not* cause a NULL result.
- * The appropriate test is performed and returned as a boolean Datum.
- */
-
-typedef enum PGBoolTestType {
-	PG_IS_TRUE,
-	IS_NOT_TRUE,
-	IS_FALSE,
-	IS_NOT_FALSE,
-	IS_UNKNOWN,
-	IS_NOT_UNKNOWN
-} PGBoolTestType;
-
-typedef struct PGBooleanTest {
-	PGExpr xpr;
-	PGExpr *arg;                 /* input expression */
-	PGBoolTestType booltesttype; /* test type */
-	int location;                /* token location, or -1 if unknown */
-} PGBooleanTest;
-
-/*
- * PGCoerceToDomain
- *
- * PGCoerceToDomain represents the operation of coercing a value to a domain
- * type.  At runtime (and not before) the precise set of constraints to be
- * checked will be determined.  If the value passes, it is returned as the
- * result; if not, an error is raised.  Note that this is equivalent to
- * PGRelabelType in the scenario where no constraints are applied.
- */
-typedef struct PGCoerceToDomain {
-	PGExpr xpr;
-	PGExpr *arg;                   /* input expression */
-	PGOid resulttype;              /* domain type ID (result type) */
-	int32_t resulttypmod;          /* output typmod (currently always -1) */
-	PGOid resultcollid;            /* OID of collation, or InvalidOid if none */
-	PGCoercionForm coercionformat; /* how to display this node */
-	int location;                  /* token location, or -1 if unknown */
-} PGCoerceToDomain;
-
-/*
- * Placeholder node for the value to be processed by a domain's check
- * constraint.  This is effectively like a PGParam, but can be implemented more
- * simply since we need only one replacement value at a time.
- *
- * Note: the typeId/typeMod/collation will be set from the domain's base type,
- * not the domain itself.  This is because we shouldn't consider the value
- * to be a member of the domain if we haven't yet checked its constraints.
- */
-typedef struct PGCoerceToDomainValue {
-	PGExpr xpr;
-	PGOid typeId;    /* type for substituted value */
-	int32_t typeMod; /* typemod for substituted value */
-	PGOid collation; /* collation for the substituted value */
-	int location;    /* token location, or -1 if unknown */
-} PGCoerceToDomainValue;
-
-/*
- * Placeholder node for a DEFAULT marker in an INSERT or UPDATE command.
- *
- * This is not an executable expression: it must be replaced by the actual
- * column default expression during rewriting.  But it is convenient to
- * treat it as an expression node during parsing and rewriting.
- */
-typedef struct PGSetToDefault {
-	PGExpr xpr;
-	PGOid typeId;    /* type for substituted value */
-	int32_t typeMod; /* typemod for substituted value */
-	PGOid collation; /* collation for the substituted value */
-	int location;    /* token location, or -1 if unknown */
-} PGSetToDefault;
-
-/*
- * PGNode representing [WHERE] CURRENT OF cursor_name
- *
- * CURRENT OF is a bit like a PGVar, in that it carries the rangetable index
- * of the target relation being constrained; this aids placing the expression
- * correctly during planning.  We can assume however that its "levelsup" is
- * always zero, due to the syntactic constraints on where it can appear.
- *
- * The referenced cursor can be represented either as a hardwired string
- * or as a reference to a run-time parameter of type REFCURSOR.  The latter
- * case is for the convenience of plpgsql.
- */
-typedef struct PGCurrentOfExpr {
-	PGExpr xpr;
-	PGIndex cvarno;    /* RT index of target relation */
-	char *cursor_name; /* name of referenced cursor, or NULL */
-	int cursor_param;  /* refcursor parameter number, or 0 */
-} PGCurrentOfExpr;
-
-/*
- * PGNextValueExpr - get next value from sequence
- *
- * This has the same effect as calling the nextval() function, but it does not
- * check permissions on the sequence.  This is used for identity columns,
- * where the sequence is an implicit dependency without its own permissions.
- */
-typedef struct PGNextValueExpr {
-	PGExpr xpr;
-	PGOid seqid;
-	PGOid typeId;
-} PGNextValueExpr;
-
-/*
- * PGInferenceElem - an element of a unique index inference specification
- *
- * This mostly matches the structure of IndexElems, but having a dedicated
- * primnode allows for a clean separation between the use of index parameters
- * by utility commands, and this node.
- */
-typedef struct PGInferenceElem {
-	PGExpr xpr;
-	PGNode *expr;       /* expression to infer from, or NULL */
-	PGOid infercollid;  /* OID of collation, or InvalidOid */
-	PGOid inferopclass; /* OID of att opclass, or InvalidOid */
-} PGInferenceElem;
-
-/*--------------------
- * PGTargetEntry -
- *	   a target entry (used in query target lists)
- *
- * Strictly speaking, a PGTargetEntry isn't an expression node (since it can't
- * be evaluated by ExecEvalExpr).  But we treat it as one anyway, since in
- * very many places it's convenient to process a whole query targetlist as a
- * single expression tree.
- *
- * In a SELECT's targetlist, resno should always be equal to the item's
- * ordinal position (counting from 1).  However, in an INSERT or UPDATE
- * targetlist, resno represents the attribute number of the destination
- * column for the item; so there may be missing or out-of-order resnos.
- * It is even legal to have duplicated resnos; consider
- *		UPDATE table SET arraycol[1] = ..., arraycol[2] = ..., ...
- * The two meanings come together in the executor, because the planner
- * transforms INSERT/UPDATE tlists into a normalized form with exactly
- * one entry for each column of the destination table.  Before that's
- * happened, however, it is risky to assume that resno == position.
- * Generally get_tle_by_resno() should be used rather than list_nth()
- * to fetch tlist entries by resno, and only in SELECT should you assume
- * that resno is a unique identifier.
- *
- * resname is required to represent the correct column name in non-resjunk
- * entries of top-level SELECT targetlists, since it will be used as the
- * column title sent to the frontend.  In most other contexts it is only
- * a debugging aid, and may be wrong or even NULL.  (In particular, it may
- * be wrong in a tlist from a stored rule, if the referenced column has been
- * renamed by ALTER TABLE since the rule was made.  Also, the planner tends
- * to store NULL rather than look up a valid name for tlist entries in
- * non-toplevel plan nodes.)  In resjunk entries, resname should be either
- * a specific system-generated name (such as "ctid") or NULL; anything else
- * risks confusing ExecGetJunkAttribute!
- *
- * ressortgroupref is used in the representation of ORDER BY, GROUP BY, and
- * DISTINCT items.  Targetlist entries with ressortgroupref=0 are not
- * sort/group items.  If ressortgroupref>0, then this item is an ORDER BY,
- * GROUP BY, and/or DISTINCT target value.  No two entries in a targetlist
- * may have the same nonzero ressortgroupref --- but there is no particular
- * meaning to the nonzero values, except as tags.  (For example, one must
- * not assume that lower ressortgroupref means a more significant sort key.)
- * The order of the associated PGSortGroupClause lists determine the semantics.
- *
- * resorigtbl/resorigcol identify the source of the column, if it is a
- * simple reference to a column of a base table (or view).  If it is not
- * a simple reference, these fields are zeroes.
- *
- * If resjunk is true then the column is a working column (such as a sort key)
- * that should be removed from the final output of the query.  Resjunk columns
- * must have resnos that cannot duplicate any regular column's resno.  Also
- * note that there are places that assume resjunk columns come after non-junk
- * columns.
- *--------------------
- */
-typedef struct PGTargetEntry {
-	PGExpr xpr;
-	PGExpr *expr;            /* expression to evaluate */
-	PGAttrNumber resno;      /* attribute number (see notes above) */
-	char *resname;           /* name of the column (could be NULL) */
-	PGIndex ressortgroupref; /* nonzero if referenced by a sort/group
-									 * clause */
-	PGOid resorigtbl;        /* OID of column's source table */
-	PGAttrNumber resorigcol; /* column's number in source table */
-	bool resjunk;            /* set to true to eliminate the attribute from
-								 * final target list */
-} PGTargetEntry;
-
-/* ----------------------------------------------------------------
- *					node types for join trees
- *
- * The leaves of a join tree structure are PGRangeTblRef nodes.  Above
- * these, PGJoinExpr nodes can appear to denote a specific kind of join
- * or qualified join.  Also, PGFromExpr nodes can appear to denote an
- * ordinary cross-product join ("FROM foo, bar, baz WHERE ...").
- * PGFromExpr is like a PGJoinExpr of jointype PG_JOIN_INNER, except that it
- * may have any number of child nodes, not just two.
- *
- * NOTE: the top level of a Query's jointree is always a FromExpr.
- * Even if the jointree contains no rels, there will be a FromExpr.
- *
- * NOTE: the qualification expressions present in PGJoinExpr nodes are
- * *in addition to* the query's main WHERE clause, which appears as the
- * qual of the top-level FromExpr.  The reason for associating quals with
- * specific nodes in the jointree is that the position of a qual is critical
- * when outer joins are present.  (If we enforce a qual too soon or too late,
- * that may cause the outer join to produce the wrong set of NULL-extended
- * rows.)  If all joins are inner joins then all the qual positions are
- * semantically interchangeable.
- *
- * NOTE: in the raw output of gram.y, a join tree contains PGRangeVar,
- * PGRangeSubselect, and PGRangeFunction nodes, which are all replaced by
- * PGRangeTblRef nodes during the parse analysis phase.  Also, the top-level
- * PGFromExpr is added during parse analysis; the grammar regards FROM and
- * WHERE as separate.
- * ----------------------------------------------------------------
- */
-
-/*
- * PGRangeTblRef - reference to an entry in the query's rangetable
- *
- * We could use direct pointers to the RT entries and skip having these
- * nodes, but multiple pointers to the same node in a querytree cause
- * lots of headaches, so it seems better to store an index into the RT.
- */
-typedef struct PGRangeTblRef {
-	PGNodeTag type;
-	int rtindex;
-} PGRangeTblRef;
-
-/*----------
- * PGJoinExpr - for SQL JOIN expressions
- *
- * joinreftype, usingClause, and quals are interdependent.  The user can write
- * only one of NATURAL, USING(), or ON() (this is enforced by the grammar).
- * If he writes NATURAL then parse analysis generates the equivalent USING()
- * list, and from that fills in "quals" with the right equality comparisons.
- * If he writes USING() then "quals" is filled with equality comparisons.
- * If he writes ON() then only "quals" is set.  Note that NATURAL/USING
- * are not equivalent to ON() since they also affect the output column list.
- *
- * alias is an PGAlias node representing the AS alias-clause attached to the
- * join expression, or NULL if no clause.  NB: presence or absence of the
- * alias has a critical impact on semantics, because a join with an alias
- * restricts visibility of the tables/columns inside it.
- *
- * During parse analysis, an RTE is created for the PGJoin, and its index
- * is filled into rtindex.  This RTE is present mainly so that Vars can
- * be created that refer to the outputs of the join.  The planner sometimes
- * generates JoinExprs internally; these can have rtindex = 0 if there are
- * no join alias variables referencing such joins.
- *----------
- */
-typedef struct PGJoinExpr {
-	PGNodeTag type;
-	PGJoinType jointype; /* type of join */
-	PGJoinRefType joinreftype; /* Regular/Natural/AsOf join? Will need to shape table */
-	PGNode *larg;        /* left subtree */
-	PGNode *rarg;        /* right subtree */
-	PGList *usingClause; /* USING clause, if any (list of String) */
-	PGNode *quals;       /* qualifiers on join, if any */
-	PGAlias *alias;      /* user-written alias clause, if any */
-	int rtindex;         /* RT index assigned for join, or 0 */
-	int location;          /* token location, or -1 if unknown */
-} PGJoinExpr;
-
-/*----------
- * PGFromExpr - represents a FROM ... WHERE ... construct
- *
- * This is both more flexible than a PGJoinExpr (it can have any number of
- * children, including zero) and less so --- we don't need to deal with
- * aliases and so on.  The output column set is implicitly just the union
- * of the outputs of the children.
- *----------
- */
-typedef struct PGFromExpr {
-	PGNodeTag type;
-	PGList *fromlist; /* PGList of join subtrees */
-	PGNode *quals;    /* qualifiers on join, if any */
-} PGFromExpr;
-
-/*----------
- * PGOnConflictExpr - represents an ON CONFLICT DO ... expression
- *
- * The optimizer requires a list of inference elements, and optionally a WHERE
- * clause to infer a unique index.  The unique index (or, occasionally,
- * indexes) inferred are used to arbitrate whether or not the alternative ON
- * CONFLICT path is taken.
- *----------
- */
-typedef struct PGOnConflictExpr {
-	PGNodeTag type;
-	PGOnConflictAction action; /* DO NOTHING or UPDATE? */
-
-	/* Arbiter */
-	PGList *arbiterElems; /* unique index arbiter list (of
-								 * InferenceElem's) */
-	PGNode *arbiterWhere; /* unique index arbiter WHERE clause */
-	PGOid constraint;     /* pg_constraint OID for arbiter */
-
-	/* ON CONFLICT UPDATE */
-	PGList *onConflictSet;   /* PGList of ON CONFLICT SET TargetEntrys */
-	PGNode *onConflictWhere; /* qualifiers to restrict UPDATE to */
-	int exclRelIndex;        /* RT index of 'excluded' relation */
-	PGList *exclRelTlist;    /* tlist of the EXCLUDED pseudo relation */
-} PGOnConflictExpr;
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/nodes/value.hpp b/src/duckdb/third_party/libpg_query/include/nodes/value.hpp
deleted file mode 100644
index 45feca2ee..000000000
--- a/src/duckdb/third_party/libpg_query/include/nodes/value.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * value.h
- *	  interface for PGValue nodes
- *
- *
- * Copyright (c) 2003-2017, PostgreSQL Global Development PGGroup
- *
- * src/include/nodes/value.h
- *
- *-------------------------------------------------------------------------
- */
-
-#pragma once
-
-#include "nodes/nodes.hpp"
-
-namespace duckdb_libpgquery {
-
-/*----------------------
- *		PGValue node
- *
- * The same PGValue struct is used for five node types: duckdb_libpgquery::T_PGInteger,
- * duckdb_libpgquery::T_PGFloat, duckdb_libpgquery::T_PGString, duckdb_libpgquery::T_PGBitString, T_Null.
- *
- * Integral values are actually represented by a machine integer,
- * but both floats and strings are represented as strings.
- * Using duckdb_libpgquery::T_PGFloat as the node type simply indicates that
- * the contents of the string look like a valid numeric literal.
- *
- * (Before Postgres 7.0, we used a double to represent duckdb_libpgquery::T_PGFloat,
- * but that creates loss-of-precision problems when the value is
- * ultimately destined to be converted to NUMERIC.  Since PGValue nodes
- * are only used in the parsing process, not for runtime data, it's
- * better to use the more general representation.)
- *
- * Note that an integer-looking string will get lexed as duckdb_libpgquery::T_PGFloat if
- * the value is too large to fit in a 'long'.
- *
- * Nulls, of course, don't need the value part at all.
- *----------------------
- */
-typedef struct PGValue {
-	PGNodeTag type; /* tag appropriately (eg. duckdb_libpgquery::T_PGString) */
-	union ValUnion {
-		long ival; /* machine integer */
-		char *str; /* string */
-	} val;
-} PGValue;
-
-#define intVal(v) (((PGValue *)(v))->val.ival)
-#define floatVal(v) atof(((PGValue *)(v))->val.str)
-#define strVal(v) (((PGValue *)(v))->val.str)
-
-PGValue *makeInteger(long i);
-PGValue *makeFloat(char *numericStr);
-PGValue *makeString(const char *str);
-PGValue *makeBitString(char *str);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/parser/gram.hpp b/src/duckdb/third_party/libpg_query/include/parser/gram.hpp
deleted file mode 100644
index b4e16ccca..000000000
--- a/src/duckdb/third_party/libpg_query/include/parser/gram.hpp
+++ /dev/null
@@ -1,1133 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.3.  */
-
-/* Skeleton interface for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     IDENT = 258,
-     FCONST = 259,
-     SCONST = 260,
-     BCONST = 261,
-     XCONST = 262,
-     Op = 263,
-     ICONST = 264,
-     PARAM = 265,
-     TYPECAST = 266,
-     DOT_DOT = 267,
-     COLON_EQUALS = 268,
-     EQUALS_GREATER = 269,
-     INTEGER_DIVISION = 270,
-     POWER_OF = 271,
-     LAMBDA_ARROW = 272,
-     DOUBLE_ARROW = 273,
-     LESS_EQUALS = 274,
-     GREATER_EQUALS = 275,
-     NOT_EQUALS = 276,
-     ABORT_P = 277,
-     ABSOLUTE_P = 278,
-     ACCESS = 279,
-     ACTION = 280,
-     ADD_P = 281,
-     ADMIN = 282,
-     AFTER = 283,
-     AGGREGATE = 284,
-     ALL = 285,
-     ALSO = 286,
-     ALTER = 287,
-     ALWAYS = 288,
-     ANALYSE = 289,
-     ANALYZE = 290,
-     AND = 291,
-     ANTI = 292,
-     ANY = 293,
-     ARRAY = 294,
-     AS = 295,
-     ASC_P = 296,
-     ASOF = 297,
-     ASSERTION = 298,
-     ASSIGNMENT = 299,
-     ASYMMETRIC = 300,
-     AT = 301,
-     ATTACH = 302,
-     ATTRIBUTE = 303,
-     AUTHORIZATION = 304,
-     BACKWARD = 305,
-     BEFORE = 306,
-     BEGIN_P = 307,
-     BETWEEN = 308,
-     BIGINT = 309,
-     BINARY = 310,
-     BIT = 311,
-     BOOLEAN_P = 312,
-     BOTH = 313,
-     BY = 314,
-     CACHE = 315,
-     CALL_P = 316,
-     CALLED = 317,
-     CASCADE = 318,
-     CASCADED = 319,
-     CASE = 320,
-     CAST = 321,
-     CATALOG_P = 322,
-     CENTURIES_P = 323,
-     CENTURY_P = 324,
-     CHAIN = 325,
-     CHAR_P = 326,
-     CHARACTER = 327,
-     CHARACTERISTICS = 328,
-     CHECK_P = 329,
-     CHECKPOINT = 330,
-     CLASS = 331,
-     CLOSE = 332,
-     CLUSTER = 333,
-     COALESCE = 334,
-     COLLATE = 335,
-     COLLATION = 336,
-     COLUMN = 337,
-     COLUMNS = 338,
-     COMMENT = 339,
-     COMMENTS = 340,
-     COMMIT = 341,
-     COMMITTED = 342,
-     COMPRESSION = 343,
-     CONCURRENTLY = 344,
-     CONFIGURATION = 345,
-     CONFLICT = 346,
-     CONNECTION = 347,
-     CONSTRAINT = 348,
-     CONSTRAINTS = 349,
-     CONTENT_P = 350,
-     CONTINUE_P = 351,
-     CONVERSION_P = 352,
-     COPY = 353,
-     COST = 354,
-     CREATE_P = 355,
-     CROSS = 356,
-     CSV = 357,
-     CUBE = 358,
-     CURRENT_P = 359,
-     CURSOR = 360,
-     CYCLE = 361,
-     DATA_P = 362,
-     DATABASE = 363,
-     DAY_P = 364,
-     DAYS_P = 365,
-     DEALLOCATE = 366,
-     DEC = 367,
-     DECADE_P = 368,
-     DECADES_P = 369,
-     DECIMAL_P = 370,
-     DECLARE = 371,
-     DEFAULT = 372,
-     DEFAULTS = 373,
-     DEFERRABLE = 374,
-     DEFERRED = 375,
-     DEFINER = 376,
-     DELETE_P = 377,
-     DELIMITER = 378,
-     DELIMITERS = 379,
-     DEPENDS = 380,
-     DESC_P = 381,
-     DESCRIBE = 382,
-     DETACH = 383,
-     DICTIONARY = 384,
-     DISABLE_P = 385,
-     DISCARD = 386,
-     DISTINCT = 387,
-     DO = 388,
-     DOCUMENT_P = 389,
-     DOMAIN_P = 390,
-     DOUBLE_P = 391,
-     DROP = 392,
-     EACH = 393,
-     ELSE = 394,
-     ENABLE_P = 395,
-     ENCODING = 396,
-     ENCRYPTED = 397,
-     END_P = 398,
-     ENUM_P = 399,
-     ESCAPE = 400,
-     EVENT = 401,
-     EXCEPT = 402,
-     EXCLUDE = 403,
-     EXCLUDING = 404,
-     EXCLUSIVE = 405,
-     EXECUTE = 406,
-     EXISTS = 407,
-     EXPLAIN = 408,
-     EXPORT_P = 409,
-     EXPORT_STATE = 410,
-     EXTENSION = 411,
-     EXTENSIONS = 412,
-     EXTERNAL = 413,
-     EXTRACT = 414,
-     FALSE_P = 415,
-     FAMILY = 416,
-     FETCH = 417,
-     FILTER = 418,
-     FIRST_P = 419,
-     FLOAT_P = 420,
-     FOLLOWING = 421,
-     FOR = 422,
-     FORCE = 423,
-     FOREIGN = 424,
-     FORWARD = 425,
-     FREEZE = 426,
-     FROM = 427,
-     FULL = 428,
-     FUNCTION = 429,
-     FUNCTIONS = 430,
-     GENERATED = 431,
-     GLOB = 432,
-     GLOBAL = 433,
-     GRANT = 434,
-     GRANTED = 435,
-     GROUP_P = 436,
-     GROUPING = 437,
-     GROUPING_ID = 438,
-     GROUPS = 439,
-     HANDLER = 440,
-     HAVING = 441,
-     HEADER_P = 442,
-     HOLD = 443,
-     HOUR_P = 444,
-     HOURS_P = 445,
-     IDENTITY_P = 446,
-     IF_P = 447,
-     IGNORE_P = 448,
-     ILIKE = 449,
-     IMMEDIATE = 450,
-     IMMUTABLE = 451,
-     IMPLICIT_P = 452,
-     IMPORT_P = 453,
-     IN_P = 454,
-     INCLUDE_P = 455,
-     INCLUDING = 456,
-     INCREMENT = 457,
-     INDEX = 458,
-     INDEXES = 459,
-     INHERIT = 460,
-     INHERITS = 461,
-     INITIALLY = 462,
-     INLINE_P = 463,
-     INNER_P = 464,
-     INOUT = 465,
-     INPUT_P = 466,
-     INSENSITIVE = 467,
-     INSERT = 468,
-     INSTALL = 469,
-     INSTEAD = 470,
-     INT_P = 471,
-     INTEGER = 472,
-     INTERSECT = 473,
-     INTERVAL = 474,
-     INTO = 475,
-     INVOKER = 476,
-     IS = 477,
-     ISNULL = 478,
-     ISOLATION = 479,
-     JOIN = 480,
-     JSON = 481,
-     KEY = 482,
-     LABEL = 483,
-     LANGUAGE = 484,
-     LARGE_P = 485,
-     LAST_P = 486,
-     LATERAL_P = 487,
-     LEADING = 488,
-     LEAKPROOF = 489,
-     LEFT = 490,
-     LEVEL = 491,
-     LIKE = 492,
-     LIMIT = 493,
-     LISTEN = 494,
-     LOAD = 495,
-     LOCAL = 496,
-     LOCATION = 497,
-     LOCK_P = 498,
-     LOCKED = 499,
-     LOGGED = 500,
-     MACRO = 501,
-     MAP = 502,
-     MAPPING = 503,
-     MATCH = 504,
-     MATERIALIZED = 505,
-     MAXVALUE = 506,
-     METHOD = 507,
-     MICROSECOND_P = 508,
-     MICROSECONDS_P = 509,
-     MILLENNIA_P = 510,
-     MILLENNIUM_P = 511,
-     MILLISECOND_P = 512,
-     MILLISECONDS_P = 513,
-     MINUTE_P = 514,
-     MINUTES_P = 515,
-     MINVALUE = 516,
-     MODE = 517,
-     MONTH_P = 518,
-     MONTHS_P = 519,
-     MOVE = 520,
-     NAME_P = 521,
-     NAMES = 522,
-     NATIONAL = 523,
-     NATURAL = 524,
-     NCHAR = 525,
-     NEW = 526,
-     NEXT = 527,
-     NO = 528,
-     NONE = 529,
-     NOT = 530,
-     NOTHING = 531,
-     NOTIFY = 532,
-     NOTNULL = 533,
-     NOWAIT = 534,
-     NULL_P = 535,
-     NULLIF = 536,
-     NULLS_P = 537,
-     NUMERIC = 538,
-     OBJECT_P = 539,
-     OF = 540,
-     OFF = 541,
-     OFFSET = 542,
-     OIDS = 543,
-     OLD = 544,
-     ON = 545,
-     ONLY = 546,
-     OPERATOR = 547,
-     OPTION = 548,
-     OPTIONS = 549,
-     OR = 550,
-     ORDER = 551,
-     ORDINALITY = 552,
-     OTHERS = 553,
-     OUT_P = 554,
-     OUTER_P = 555,
-     OVER = 556,
-     OVERLAPS = 557,
-     OVERLAY = 558,
-     OVERRIDING = 559,
-     OWNED = 560,
-     OWNER = 561,
-     PARALLEL = 562,
-     PARSER = 563,
-     PARTIAL = 564,
-     PARTITION = 565,
-     PASSING = 566,
-     PASSWORD = 567,
-     PERCENT = 568,
-     PERSISTENT = 569,
-     PIVOT = 570,
-     PIVOT_LONGER = 571,
-     PIVOT_WIDER = 572,
-     PLACING = 573,
-     PLANS = 574,
-     POLICY = 575,
-     POSITION = 576,
-     POSITIONAL = 577,
-     PRAGMA_P = 578,
-     PRECEDING = 579,
-     PRECISION = 580,
-     PREPARE = 581,
-     PREPARED = 582,
-     PRESERVE = 583,
-     PRIMARY = 584,
-     PRIOR = 585,
-     PRIVILEGES = 586,
-     PROCEDURAL = 587,
-     PROCEDURE = 588,
-     PROGRAM = 589,
-     PUBLICATION = 590,
-     QUALIFY = 591,
-     QUARTER_P = 592,
-     QUARTERS_P = 593,
-     QUOTE = 594,
-     RANGE = 595,
-     READ_P = 596,
-     REAL = 597,
-     REASSIGN = 598,
-     RECHECK = 599,
-     RECURSIVE = 600,
-     REF = 601,
-     REFERENCES = 602,
-     REFERENCING = 603,
-     REFRESH = 604,
-     REINDEX = 605,
-     RELATIVE_P = 606,
-     RELEASE = 607,
-     RENAME = 608,
-     REPEATABLE = 609,
-     REPLACE = 610,
-     REPLICA = 611,
-     RESET = 612,
-     RESPECT_P = 613,
-     RESTART = 614,
-     RESTRICT = 615,
-     RETURNING = 616,
-     RETURNS = 617,
-     REVOKE = 618,
-     RIGHT = 619,
-     ROLE = 620,
-     ROLLBACK = 621,
-     ROLLUP = 622,
-     ROW = 623,
-     ROWS = 624,
-     RULE = 625,
-     SAMPLE = 626,
-     SAVEPOINT = 627,
-     SCHEMA = 628,
-     SCHEMAS = 629,
-     SCOPE = 630,
-     SCROLL = 631,
-     SEARCH = 632,
-     SECOND_P = 633,
-     SECONDS_P = 634,
-     SECRET = 635,
-     SECURITY = 636,
-     SELECT = 637,
-     SEMI = 638,
-     SEQUENCE = 639,
-     SEQUENCES = 640,
-     SERIALIZABLE = 641,
-     SERVER = 642,
-     SESSION = 643,
-     SET = 644,
-     SETOF = 645,
-     SETS = 646,
-     SHARE = 647,
-     SHOW = 648,
-     SIMILAR = 649,
-     SIMPLE = 650,
-     SKIP = 651,
-     SMALLINT = 652,
-     SNAPSHOT = 653,
-     SOME = 654,
-     SQL_P = 655,
-     STABLE = 656,
-     STANDALONE_P = 657,
-     START = 658,
-     STATEMENT = 659,
-     STATISTICS = 660,
-     STDIN = 661,
-     STDOUT = 662,
-     STORAGE = 663,
-     STORED = 664,
-     STRICT_P = 665,
-     STRIP_P = 666,
-     STRUCT = 667,
-     SUBSCRIPTION = 668,
-     SUBSTRING = 669,
-     SUMMARIZE = 670,
-     SYMMETRIC = 671,
-     SYSID = 672,
-     SYSTEM_P = 673,
-     TABLE = 674,
-     TABLES = 675,
-     TABLESAMPLE = 676,
-     TABLESPACE = 677,
-     TEMP = 678,
-     TEMPLATE = 679,
-     TEMPORARY = 680,
-     TEXT_P = 681,
-     THEN = 682,
-     TIES = 683,
-     TIME = 684,
-     TIMESTAMP = 685,
-     TO = 686,
-     TRAILING = 687,
-     TRANSACTION = 688,
-     TRANSFORM = 689,
-     TREAT = 690,
-     TRIGGER = 691,
-     TRIM = 692,
-     TRUE_P = 693,
-     TRUNCATE = 694,
-     TRUSTED = 695,
-     TRY_CAST = 696,
-     TYPE_P = 697,
-     TYPES_P = 698,
-     UNBOUNDED = 699,
-     UNCOMMITTED = 700,
-     UNENCRYPTED = 701,
-     UNION = 702,
-     UNIQUE = 703,
-     UNKNOWN = 704,
-     UNLISTEN = 705,
-     UNLOGGED = 706,
-     UNPIVOT = 707,
-     UNTIL = 708,
-     UPDATE = 709,
-     USE_P = 710,
-     USER = 711,
-     USING = 712,
-     VACUUM = 713,
-     VALID = 714,
-     VALIDATE = 715,
-     VALIDATOR = 716,
-     VALUE_P = 717,
-     VALUES = 718,
-     VARCHAR = 719,
-     VARIABLE_P = 720,
-     VARIADIC = 721,
-     VARYING = 722,
-     VERBOSE = 723,
-     VERSION_P = 724,
-     VIEW = 725,
-     VIEWS = 726,
-     VIRTUAL = 727,
-     VOLATILE = 728,
-     WEEK_P = 729,
-     WEEKS_P = 730,
-     WHEN = 731,
-     WHERE = 732,
-     WHITESPACE_P = 733,
-     WINDOW = 734,
-     WITH = 735,
-     WITHIN = 736,
-     WITHOUT = 737,
-     WORK = 738,
-     WRAPPER = 739,
-     WRITE_P = 740,
-     XML_P = 741,
-     XMLATTRIBUTES = 742,
-     XMLCONCAT = 743,
-     XMLELEMENT = 744,
-     XMLEXISTS = 745,
-     XMLFOREST = 746,
-     XMLNAMESPACES = 747,
-     XMLPARSE = 748,
-     XMLPI = 749,
-     XMLROOT = 750,
-     XMLSERIALIZE = 751,
-     XMLTABLE = 752,
-     YEAR_P = 753,
-     YEARS_P = 754,
-     YES_P = 755,
-     ZONE = 756,
-     NOT_LA = 757,
-     NULLS_LA = 758,
-     WITH_LA = 759,
-     POSTFIXOP = 760,
-     UMINUS = 761
-   };
-#endif
-/* Tokens.  */
-#define IDENT 258
-#define FCONST 259
-#define SCONST 260
-#define BCONST 261
-#define XCONST 262
-#define Op 263
-#define ICONST 264
-#define PARAM 265
-#define TYPECAST 266
-#define DOT_DOT 267
-#define COLON_EQUALS 268
-#define EQUALS_GREATER 269
-#define INTEGER_DIVISION 270
-#define POWER_OF 271
-#define LAMBDA_ARROW 272
-#define DOUBLE_ARROW 273
-#define LESS_EQUALS 274
-#define GREATER_EQUALS 275
-#define NOT_EQUALS 276
-#define ABORT_P 277
-#define ABSOLUTE_P 278
-#define ACCESS 279
-#define ACTION 280
-#define ADD_P 281
-#define ADMIN 282
-#define AFTER 283
-#define AGGREGATE 284
-#define ALL 285
-#define ALSO 286
-#define ALTER 287
-#define ALWAYS 288
-#define ANALYSE 289
-#define ANALYZE 290
-#define AND 291
-#define ANTI 292
-#define ANY 293
-#define ARRAY 294
-#define AS 295
-#define ASC_P 296
-#define ASOF 297
-#define ASSERTION 298
-#define ASSIGNMENT 299
-#define ASYMMETRIC 300
-#define AT 301
-#define ATTACH 302
-#define ATTRIBUTE 303
-#define AUTHORIZATION 304
-#define BACKWARD 305
-#define BEFORE 306
-#define BEGIN_P 307
-#define BETWEEN 308
-#define BIGINT 309
-#define BINARY 310
-#define BIT 311
-#define BOOLEAN_P 312
-#define BOTH 313
-#define BY 314
-#define CACHE 315
-#define CALL_P 316
-#define CALLED 317
-#define CASCADE 318
-#define CASCADED 319
-#define CASE 320
-#define CAST 321
-#define CATALOG_P 322
-#define CENTURIES_P 323
-#define CENTURY_P 324
-#define CHAIN 325
-#define CHAR_P 326
-#define CHARACTER 327
-#define CHARACTERISTICS 328
-#define CHECK_P 329
-#define CHECKPOINT 330
-#define CLASS 331
-#define CLOSE 332
-#define CLUSTER 333
-#define COALESCE 334
-#define COLLATE 335
-#define COLLATION 336
-#define COLUMN 337
-#define COLUMNS 338
-#define COMMENT 339
-#define COMMENTS 340
-#define COMMIT 341
-#define COMMITTED 342
-#define COMPRESSION 343
-#define CONCURRENTLY 344
-#define CONFIGURATION 345
-#define CONFLICT 346
-#define CONNECTION 347
-#define CONSTRAINT 348
-#define CONSTRAINTS 349
-#define CONTENT_P 350
-#define CONTINUE_P 351
-#define CONVERSION_P 352
-#define COPY 353
-#define COST 354
-#define CREATE_P 355
-#define CROSS 356
-#define CSV 357
-#define CUBE 358
-#define CURRENT_P 359
-#define CURSOR 360
-#define CYCLE 361
-#define DATA_P 362
-#define DATABASE 363
-#define DAY_P 364
-#define DAYS_P 365
-#define DEALLOCATE 366
-#define DEC 367
-#define DECADE_P 368
-#define DECADES_P 369
-#define DECIMAL_P 370
-#define DECLARE 371
-#define DEFAULT 372
-#define DEFAULTS 373
-#define DEFERRABLE 374
-#define DEFERRED 375
-#define DEFINER 376
-#define DELETE_P 377
-#define DELIMITER 378
-#define DELIMITERS 379
-#define DEPENDS 380
-#define DESC_P 381
-#define DESCRIBE 382
-#define DETACH 383
-#define DICTIONARY 384
-#define DISABLE_P 385
-#define DISCARD 386
-#define DISTINCT 387
-#define DO 388
-#define DOCUMENT_P 389
-#define DOMAIN_P 390
-#define DOUBLE_P 391
-#define DROP 392
-#define EACH 393
-#define ELSE 394
-#define ENABLE_P 395
-#define ENCODING 396
-#define ENCRYPTED 397
-#define END_P 398
-#define ENUM_P 399
-#define ESCAPE 400
-#define EVENT 401
-#define EXCEPT 402
-#define EXCLUDE 403
-#define EXCLUDING 404
-#define EXCLUSIVE 405
-#define EXECUTE 406
-#define EXISTS 407
-#define EXPLAIN 408
-#define EXPORT_P 409
-#define EXPORT_STATE 410
-#define EXTENSION 411
-#define EXTENSIONS 412
-#define EXTERNAL 413
-#define EXTRACT 414
-#define FALSE_P 415
-#define FAMILY 416
-#define FETCH 417
-#define FILTER 418
-#define FIRST_P 419
-#define FLOAT_P 420
-#define FOLLOWING 421
-#define FOR 422
-#define FORCE 423
-#define FOREIGN 424
-#define FORWARD 425
-#define FREEZE 426
-#define FROM 427
-#define FULL 428
-#define FUNCTION 429
-#define FUNCTIONS 430
-#define GENERATED 431
-#define GLOB 432
-#define GLOBAL 433
-#define GRANT 434
-#define GRANTED 435
-#define GROUP_P 436
-#define GROUPING 437
-#define GROUPING_ID 438
-#define GROUPS 439
-#define HANDLER 440
-#define HAVING 441
-#define HEADER_P 442
-#define HOLD 443
-#define HOUR_P 444
-#define HOURS_P 445
-#define IDENTITY_P 446
-#define IF_P 447
-#define IGNORE_P 448
-#define ILIKE 449
-#define IMMEDIATE 450
-#define IMMUTABLE 451
-#define IMPLICIT_P 452
-#define IMPORT_P 453
-#define IN_P 454
-#define INCLUDE_P 455
-#define INCLUDING 456
-#define INCREMENT 457
-#define INDEX 458
-#define INDEXES 459
-#define INHERIT 460
-#define INHERITS 461
-#define INITIALLY 462
-#define INLINE_P 463
-#define INNER_P 464
-#define INOUT 465
-#define INPUT_P 466
-#define INSENSITIVE 467
-#define INSERT 468
-#define INSTALL 469
-#define INSTEAD 470
-#define INT_P 471
-#define INTEGER 472
-#define INTERSECT 473
-#define INTERVAL 474
-#define INTO 475
-#define INVOKER 476
-#define IS 477
-#define ISNULL 478
-#define ISOLATION 479
-#define JOIN 480
-#define JSON 481
-#define KEY 482
-#define LABEL 483
-#define LANGUAGE 484
-#define LARGE_P 485
-#define LAST_P 486
-#define LATERAL_P 487
-#define LEADING 488
-#define LEAKPROOF 489
-#define LEFT 490
-#define LEVEL 491
-#define LIKE 492
-#define LIMIT 493
-#define LISTEN 494
-#define LOAD 495
-#define LOCAL 496
-#define LOCATION 497
-#define LOCK_P 498
-#define LOCKED 499
-#define LOGGED 500
-#define MACRO 501
-#define MAP 502
-#define MAPPING 503
-#define MATCH 504
-#define MATERIALIZED 505
-#define MAXVALUE 506
-#define METHOD 507
-#define MICROSECOND_P 508
-#define MICROSECONDS_P 509
-#define MILLENNIA_P 510
-#define MILLENNIUM_P 511
-#define MILLISECOND_P 512
-#define MILLISECONDS_P 513
-#define MINUTE_P 514
-#define MINUTES_P 515
-#define MINVALUE 516
-#define MODE 517
-#define MONTH_P 518
-#define MONTHS_P 519
-#define MOVE 520
-#define NAME_P 521
-#define NAMES 522
-#define NATIONAL 523
-#define NATURAL 524
-#define NCHAR 525
-#define NEW 526
-#define NEXT 527
-#define NO 528
-#define NONE 529
-#define NOT 530
-#define NOTHING 531
-#define NOTIFY 532
-#define NOTNULL 533
-#define NOWAIT 534
-#define NULL_P 535
-#define NULLIF 536
-#define NULLS_P 537
-#define NUMERIC 538
-#define OBJECT_P 539
-#define OF 540
-#define OFF 541
-#define OFFSET 542
-#define OIDS 543
-#define OLD 544
-#define ON 545
-#define ONLY 546
-#define OPERATOR 547
-#define OPTION 548
-#define OPTIONS 549
-#define OR 550
-#define ORDER 551
-#define ORDINALITY 552
-#define OTHERS 553
-#define OUT_P 554
-#define OUTER_P 555
-#define OVER 556
-#define OVERLAPS 557
-#define OVERLAY 558
-#define OVERRIDING 559
-#define OWNED 560
-#define OWNER 561
-#define PARALLEL 562
-#define PARSER 563
-#define PARTIAL 564
-#define PARTITION 565
-#define PASSING 566
-#define PASSWORD 567
-#define PERCENT 568
-#define PERSISTENT 569
-#define PIVOT 570
-#define PIVOT_LONGER 571
-#define PIVOT_WIDER 572
-#define PLACING 573
-#define PLANS 574
-#define POLICY 575
-#define POSITION 576
-#define POSITIONAL 577
-#define PRAGMA_P 578
-#define PRECEDING 579
-#define PRECISION 580
-#define PREPARE 581
-#define PREPARED 582
-#define PRESERVE 583
-#define PRIMARY 584
-#define PRIOR 585
-#define PRIVILEGES 586
-#define PROCEDURAL 587
-#define PROCEDURE 588
-#define PROGRAM 589
-#define PUBLICATION 590
-#define QUALIFY 591
-#define QUARTER_P 592
-#define QUARTERS_P 593
-#define QUOTE 594
-#define RANGE 595
-#define READ_P 596
-#define REAL 597
-#define REASSIGN 598
-#define RECHECK 599
-#define RECURSIVE 600
-#define REF 601
-#define REFERENCES 602
-#define REFERENCING 603
-#define REFRESH 604
-#define REINDEX 605
-#define RELATIVE_P 606
-#define RELEASE 607
-#define RENAME 608
-#define REPEATABLE 609
-#define REPLACE 610
-#define REPLICA 611
-#define RESET 612
-#define RESPECT_P 613
-#define RESTART 614
-#define RESTRICT 615
-#define RETURNING 616
-#define RETURNS 617
-#define REVOKE 618
-#define RIGHT 619
-#define ROLE 620
-#define ROLLBACK 621
-#define ROLLUP 622
-#define ROW 623
-#define ROWS 624
-#define RULE 625
-#define SAMPLE 626
-#define SAVEPOINT 627
-#define SCHEMA 628
-#define SCHEMAS 629
-#define SCOPE 630
-#define SCROLL 631
-#define SEARCH 632
-#define SECOND_P 633
-#define SECONDS_P 634
-#define SECRET 635
-#define SECURITY 636
-#define SELECT 637
-#define SEMI 638
-#define SEQUENCE 639
-#define SEQUENCES 640
-#define SERIALIZABLE 641
-#define SERVER 642
-#define SESSION 643
-#define SET 644
-#define SETOF 645
-#define SETS 646
-#define SHARE 647
-#define SHOW 648
-#define SIMILAR 649
-#define SIMPLE 650
-#define SKIP 651
-#define SMALLINT 652
-#define SNAPSHOT 653
-#define SOME 654
-#define SQL_P 655
-#define STABLE 656
-#define STANDALONE_P 657
-#define START 658
-#define STATEMENT 659
-#define STATISTICS 660
-#define STDIN 661
-#define STDOUT 662
-#define STORAGE 663
-#define STORED 664
-#define STRICT_P 665
-#define STRIP_P 666
-#define STRUCT 667
-#define SUBSCRIPTION 668
-#define SUBSTRING 669
-#define SUMMARIZE 670
-#define SYMMETRIC 671
-#define SYSID 672
-#define SYSTEM_P 673
-#define TABLE 674
-#define TABLES 675
-#define TABLESAMPLE 676
-#define TABLESPACE 677
-#define TEMP 678
-#define TEMPLATE 679
-#define TEMPORARY 680
-#define TEXT_P 681
-#define THEN 682
-#define TIES 683
-#define TIME 684
-#define TIMESTAMP 685
-#define TO 686
-#define TRAILING 687
-#define TRANSACTION 688
-#define TRANSFORM 689
-#define TREAT 690
-#define TRIGGER 691
-#define TRIM 692
-#define TRUE_P 693
-#define TRUNCATE 694
-#define TRUSTED 695
-#define TRY_CAST 696
-#define TYPE_P 697
-#define TYPES_P 698
-#define UNBOUNDED 699
-#define UNCOMMITTED 700
-#define UNENCRYPTED 701
-#define UNION 702
-#define UNIQUE 703
-#define UNKNOWN 704
-#define UNLISTEN 705
-#define UNLOGGED 706
-#define UNPIVOT 707
-#define UNTIL 708
-#define UPDATE 709
-#define USE_P 710
-#define USER 711
-#define USING 712
-#define VACUUM 713
-#define VALID 714
-#define VALIDATE 715
-#define VALIDATOR 716
-#define VALUE_P 717
-#define VALUES 718
-#define VARCHAR 719
-#define VARIABLE_P 720
-#define VARIADIC 721
-#define VARYING 722
-#define VERBOSE 723
-#define VERSION_P 724
-#define VIEW 725
-#define VIEWS 726
-#define VIRTUAL 727
-#define VOLATILE 728
-#define WEEK_P 729
-#define WEEKS_P 730
-#define WHEN 731
-#define WHERE 732
-#define WHITESPACE_P 733
-#define WINDOW 734
-#define WITH 735
-#define WITHIN 736
-#define WITHOUT 737
-#define WORK 738
-#define WRAPPER 739
-#define WRITE_P 740
-#define XML_P 741
-#define XMLATTRIBUTES 742
-#define XMLCONCAT 743
-#define XMLELEMENT 744
-#define XMLEXISTS 745
-#define XMLFOREST 746
-#define XMLNAMESPACES 747
-#define XMLPARSE 748
-#define XMLPI 749
-#define XMLROOT 750
-#define XMLSERIALIZE 751
-#define XMLTABLE 752
-#define YEAR_P 753
-#define YEARS_P 754
-#define YES_P 755
-#define ZONE 756
-#define NOT_LA 757
-#define NULLS_LA 758
-#define WITH_LA 759
-#define POSTFIXOP 760
-#define UMINUS 761
-
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-#line 14 "third_party/libpg_query/grammar/grammar.y"
-{
-	core_YYSTYPE		core_yystype;
-	/* these fields must match core_YYSTYPE: */
-	int					ival;
-	char				*str;
-	const char			*keyword;
-	const char          *conststr;
-
-	char				chr;
-	bool				boolean;
-	PGJoinType			jtype;
-	PGDropBehavior		dbehavior;
-	PGOnCommitAction		oncommit;
-	PGOnCreateConflict		oncreateconflict;
-	PGList				*list;
-	PGNode				*node;
-	PGValue				*value;
-	PGObjectType			objtype;
-	PGTypeName			*typnam;
-	PGObjectWithArgs		*objwithargs;
-	PGDefElem				*defelt;
-	PGSortBy				*sortby;
-	PGWindowDef			*windef;
-	PGJoinExpr			*jexpr;
-	PGIndexElem			*ielem;
-	PGAlias				*alias;
-	PGRangeVar			*range;
-	PGIntoClause			*into;
-	PGCTEMaterialize			ctematerialize;
-	PGWithClause			*with;
-	PGInferClause			*infer;
-	PGOnConflictClause	*onconflict;
-	PGOnConflictActionAlias onconflictshorthand;
-	PGAIndices			*aind;
-	PGResTarget			*target;
-	PGInsertStmt			*istmt;
-	PGVariableSetStmt		*vsetstmt;
-	PGOverridingKind       override;
-	PGSortByDir            sortorder;
-	PGSortByNulls          nullorder;
-	PGIgnoreNulls          ignorenulls;
-	PGConstrType           constr;
-	PGLockClauseStrength lockstrength;
-	PGLockWaitPolicy lockwaitpolicy;
-	PGSubLinkType subquerytype;
-	PGViewCheckOption viewcheckoption;
-	PGInsertColumnOrder bynameorposition;
-	PGLoadInstallType loadinstalltype;
-	PGTransactionStmtType transactiontype;
-}
-/* Line 1529 of yacc.c.  */
-#line 1112 "third_party/libpg_query/grammar/grammar_out.hpp"
-	YYSTYPE;
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
diff --git a/src/duckdb/third_party/libpg_query/include/parser/gramparse.hpp b/src/duckdb/third_party/libpg_query/include/parser/gramparse.hpp
deleted file mode 100644
index e374dcf8c..000000000
--- a/src/duckdb/third_party/libpg_query/include/parser/gramparse.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * gramparse.h
- *		Shared definitions for the "raw" parser (flex and bison phases only)
- *
- * NOTE: this file is only meant to be included in the core parsing files,
- * ie, parser.c, gram.y, scan.l, and src/common/keywords.c.
- * Definitions that are needed outside the core parser should be in parser.h.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/gramparse.h
- *
- *-------------------------------------------------------------------------
- */
-
-#pragma once
-
-#include "nodes/parsenodes.hpp"
-#include "parser/scanner.hpp"
-
-namespace duckdb_libpgquery {
-#include "parser/gram.hpp"
-
-/*
- * The YY_EXTRA data that a flex scanner allows us to pass around.  Private
- * state needed for raw parsing/lexing goes here.
- */
-typedef struct base_yy_extra_type {
-	/*
-	 * Fields used by the core scanner.
-	 */
-	core_yy_extra_type core_yy_extra;
-
-	/*
-	 * State variables for base_yylex().
-	 */
-	bool have_lookahead;           /* is lookahead info valid? */
-	int lookahead_token;           /* one-token lookahead */
-	core_YYSTYPE lookahead_yylval; /* yylval for lookahead token */
-	YYLTYPE lookahead_yylloc;      /* yylloc for lookahead token */
-	char *lookahead_end;           /* end of current token */
-	char lookahead_hold_char;      /* to be put back at *lookahead_end */
-
-	/*
-	 * State variables that belong to the grammar.
-	 */
-	PGList *parsetree; /* final parse result is delivered here */
-} base_yy_extra_type;
-
-/*
- * In principle we should use yyget_extra() to fetch the yyextra field
- * from a yyscanner struct.  However, flex always puts that field first,
- * and this is sufficiently performance-critical to make it seem worth
- * cheating a bit to use an inline macro.
- */
-#define pg_yyget_extra(yyscanner) (*((base_yy_extra_type **)(yyscanner)))
-
-/* from parser.c */
-int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner);
-
-/* from gram.y */
-void parser_init(base_yy_extra_type *yyext);
-int base_yyparse(core_yyscan_t yyscanner);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/parser/kwlist.hpp b/src/duckdb/third_party/libpg_query/include/parser/kwlist.hpp
deleted file mode 100644
index 9d54b6f2d..000000000
--- a/src/duckdb/third_party/libpg_query/include/parser/kwlist.hpp
+++ /dev/null
@@ -1,490 +0,0 @@
-
-namespace duckdb_libpgquery {
-#define PG_KEYWORD(a,b,c) {a,b,c},
-
-const PGScanKeyword ScanKeywords[] = {
-PG_KEYWORD("abort", ABORT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("absolute", ABSOLUTE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("access", ACCESS, UNRESERVED_KEYWORD)
-PG_KEYWORD("action", ACTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("add", ADD_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("admin", ADMIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("after", AFTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("aggregate", AGGREGATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("all", ALL, RESERVED_KEYWORD)
-PG_KEYWORD("also", ALSO, UNRESERVED_KEYWORD)
-PG_KEYWORD("alter", ALTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("always", ALWAYS, UNRESERVED_KEYWORD)
-PG_KEYWORD("analyse", ANALYSE, RESERVED_KEYWORD)
-PG_KEYWORD("analyze", ANALYZE, RESERVED_KEYWORD)
-PG_KEYWORD("and", AND, RESERVED_KEYWORD)
-PG_KEYWORD("anti", ANTI, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("any", ANY, RESERVED_KEYWORD)
-PG_KEYWORD("array", ARRAY, RESERVED_KEYWORD)
-PG_KEYWORD("as", AS, RESERVED_KEYWORD)
-PG_KEYWORD("asc", ASC_P, RESERVED_KEYWORD)
-PG_KEYWORD("asof", ASOF, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("assertion", ASSERTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("assignment", ASSIGNMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("asymmetric", ASYMMETRIC, RESERVED_KEYWORD)
-PG_KEYWORD("at", AT, UNRESERVED_KEYWORD)
-PG_KEYWORD("attach", ATTACH, UNRESERVED_KEYWORD)
-PG_KEYWORD("attribute", ATTRIBUTE, UNRESERVED_KEYWORD)
-PG_KEYWORD("authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("backward", BACKWARD, UNRESERVED_KEYWORD)
-PG_KEYWORD("before", BEFORE, UNRESERVED_KEYWORD)
-PG_KEYWORD("begin", BEGIN_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("between", BETWEEN, COL_NAME_KEYWORD)
-PG_KEYWORD("bigint", BIGINT, COL_NAME_KEYWORD)
-PG_KEYWORD("binary", BINARY, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("bit", BIT, COL_NAME_KEYWORD)
-PG_KEYWORD("boolean", BOOLEAN_P, COL_NAME_KEYWORD)
-PG_KEYWORD("both", BOTH, RESERVED_KEYWORD)
-PG_KEYWORD("by", BY, UNRESERVED_KEYWORD)
-PG_KEYWORD("cache", CACHE, UNRESERVED_KEYWORD)
-PG_KEYWORD("call", CALL_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("called", CALLED, UNRESERVED_KEYWORD)
-PG_KEYWORD("cascade", CASCADE, UNRESERVED_KEYWORD)
-PG_KEYWORD("cascaded", CASCADED, UNRESERVED_KEYWORD)
-PG_KEYWORD("case", CASE, RESERVED_KEYWORD)
-PG_KEYWORD("cast", CAST, RESERVED_KEYWORD)
-PG_KEYWORD("catalog", CATALOG_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("centuries", CENTURIES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("century", CENTURY_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("chain", CHAIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("char", CHAR_P, COL_NAME_KEYWORD)
-PG_KEYWORD("character", CHARACTER, COL_NAME_KEYWORD)
-PG_KEYWORD("characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD)
-PG_KEYWORD("check", CHECK_P, RESERVED_KEYWORD)
-PG_KEYWORD("checkpoint", CHECKPOINT, UNRESERVED_KEYWORD)
-PG_KEYWORD("class", CLASS, UNRESERVED_KEYWORD)
-PG_KEYWORD("close", CLOSE, UNRESERVED_KEYWORD)
-PG_KEYWORD("cluster", CLUSTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("coalesce", COALESCE, COL_NAME_KEYWORD)
-PG_KEYWORD("collate", COLLATE, RESERVED_KEYWORD)
-PG_KEYWORD("collation", COLLATION, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("column", COLUMN, RESERVED_KEYWORD)
-PG_KEYWORD("columns", COLUMNS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("comments", COMMENTS, UNRESERVED_KEYWORD)
-PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD)
-PG_KEYWORD("committed", COMMITTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("compression", COMPRESSION, UNRESERVED_KEYWORD)
-PG_KEYWORD("concurrently", CONCURRENTLY, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("configuration", CONFIGURATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("conflict", CONFLICT, UNRESERVED_KEYWORD)
-PG_KEYWORD("connection", CONNECTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("constraint", CONSTRAINT, RESERVED_KEYWORD)
-PG_KEYWORD("constraints", CONSTRAINTS, UNRESERVED_KEYWORD)
-PG_KEYWORD("content", CONTENT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("continue", CONTINUE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("conversion", CONVERSION_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("copy", COPY, UNRESERVED_KEYWORD)
-PG_KEYWORD("cost", COST, UNRESERVED_KEYWORD)
-PG_KEYWORD("create", CREATE_P, RESERVED_KEYWORD)
-PG_KEYWORD("cross", CROSS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("csv", CSV, UNRESERVED_KEYWORD)
-PG_KEYWORD("cube", CUBE, UNRESERVED_KEYWORD)
-PG_KEYWORD("current", CURRENT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("cursor", CURSOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("cycle", CYCLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("data", DATA_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("database", DATABASE, UNRESERVED_KEYWORD)
-PG_KEYWORD("day", DAY_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("days", DAYS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("deallocate", DEALLOCATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("dec", DEC, COL_NAME_KEYWORD)
-PG_KEYWORD("decade", DECADE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("decades", DECADES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("decimal", DECIMAL_P, COL_NAME_KEYWORD)
-PG_KEYWORD("declare", DECLARE, UNRESERVED_KEYWORD)
-PG_KEYWORD("default", DEFAULT, RESERVED_KEYWORD)
-PG_KEYWORD("defaults", DEFAULTS, UNRESERVED_KEYWORD)
-PG_KEYWORD("deferrable", DEFERRABLE, RESERVED_KEYWORD)
-PG_KEYWORD("deferred", DEFERRED, UNRESERVED_KEYWORD)
-PG_KEYWORD("definer", DEFINER, UNRESERVED_KEYWORD)
-PG_KEYWORD("delete", DELETE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("delimiter", DELIMITER, UNRESERVED_KEYWORD)
-PG_KEYWORD("delimiters", DELIMITERS, UNRESERVED_KEYWORD)
-PG_KEYWORD("depends", DEPENDS, UNRESERVED_KEYWORD)
-PG_KEYWORD("desc", DESC_P, RESERVED_KEYWORD)
-PG_KEYWORD("describe", DESCRIBE, RESERVED_KEYWORD)
-PG_KEYWORD("detach", DETACH, UNRESERVED_KEYWORD)
-PG_KEYWORD("dictionary", DICTIONARY, UNRESERVED_KEYWORD)
-PG_KEYWORD("disable", DISABLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("discard", DISCARD, UNRESERVED_KEYWORD)
-PG_KEYWORD("distinct", DISTINCT, RESERVED_KEYWORD)
-PG_KEYWORD("do", DO, RESERVED_KEYWORD)
-PG_KEYWORD("document", DOCUMENT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("domain", DOMAIN_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("double", DOUBLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("drop", DROP, UNRESERVED_KEYWORD)
-PG_KEYWORD("each", EACH, UNRESERVED_KEYWORD)
-PG_KEYWORD("else", ELSE, RESERVED_KEYWORD)
-PG_KEYWORD("enable", ENABLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("encoding", ENCODING, UNRESERVED_KEYWORD)
-PG_KEYWORD("encrypted", ENCRYPTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("end", END_P, RESERVED_KEYWORD)
-PG_KEYWORD("enum", ENUM_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("escape", ESCAPE, UNRESERVED_KEYWORD)
-PG_KEYWORD("event", EVENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("except", EXCEPT, RESERVED_KEYWORD)
-PG_KEYWORD("exclude", EXCLUDE, UNRESERVED_KEYWORD)
-PG_KEYWORD("excluding", EXCLUDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("exclusive", EXCLUSIVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("execute", EXECUTE, UNRESERVED_KEYWORD)
-PG_KEYWORD("exists", EXISTS, COL_NAME_KEYWORD)
-PG_KEYWORD("explain", EXPLAIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("export", EXPORT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("export_state", EXPORT_STATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("extension", EXTENSION, UNRESERVED_KEYWORD)
-PG_KEYWORD("extensions", EXTENSIONS, UNRESERVED_KEYWORD)
-PG_KEYWORD("external", EXTERNAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("extract", EXTRACT, COL_NAME_KEYWORD)
-PG_KEYWORD("false", FALSE_P, RESERVED_KEYWORD)
-PG_KEYWORD("family", FAMILY, UNRESERVED_KEYWORD)
-PG_KEYWORD("fetch", FETCH, RESERVED_KEYWORD)
-PG_KEYWORD("filter", FILTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("first", FIRST_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("float", FLOAT_P, COL_NAME_KEYWORD)
-PG_KEYWORD("following", FOLLOWING, UNRESERVED_KEYWORD)
-PG_KEYWORD("for", FOR, RESERVED_KEYWORD)
-PG_KEYWORD("force", FORCE, UNRESERVED_KEYWORD)
-PG_KEYWORD("foreign", FOREIGN, RESERVED_KEYWORD)
-PG_KEYWORD("forward", FORWARD, UNRESERVED_KEYWORD)
-PG_KEYWORD("freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("from", FROM, RESERVED_KEYWORD)
-PG_KEYWORD("full", FULL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("function", FUNCTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("functions", FUNCTIONS, UNRESERVED_KEYWORD)
-PG_KEYWORD("generated", GENERATED, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("glob", GLOB, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("global", GLOBAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("grant", GRANT, RESERVED_KEYWORD)
-PG_KEYWORD("granted", GRANTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("group", GROUP_P, RESERVED_KEYWORD)
-PG_KEYWORD("grouping", GROUPING, COL_NAME_KEYWORD)
-PG_KEYWORD("grouping_id", GROUPING_ID, COL_NAME_KEYWORD)
-PG_KEYWORD("groups", GROUPS, UNRESERVED_KEYWORD)
-PG_KEYWORD("handler", HANDLER, UNRESERVED_KEYWORD)
-PG_KEYWORD("having", HAVING, RESERVED_KEYWORD)
-PG_KEYWORD("header", HEADER_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("hold", HOLD, UNRESERVED_KEYWORD)
-PG_KEYWORD("hour", HOUR_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("hours", HOURS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("identity", IDENTITY_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("if", IF_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("ignore", IGNORE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("immediate", IMMEDIATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("immutable", IMMUTABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("implicit", IMPLICIT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("import", IMPORT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("in", IN_P, RESERVED_KEYWORD)
-PG_KEYWORD("include", INCLUDE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("including", INCLUDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("increment", INCREMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("index", INDEX, UNRESERVED_KEYWORD)
-PG_KEYWORD("indexes", INDEXES, UNRESERVED_KEYWORD)
-PG_KEYWORD("inherit", INHERIT, UNRESERVED_KEYWORD)
-PG_KEYWORD("inherits", INHERITS, UNRESERVED_KEYWORD)
-PG_KEYWORD("initially", INITIALLY, RESERVED_KEYWORD)
-PG_KEYWORD("inline", INLINE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("inner", INNER_P, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("inout", INOUT, COL_NAME_KEYWORD)
-PG_KEYWORD("input", INPUT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("insensitive", INSENSITIVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("insert", INSERT, UNRESERVED_KEYWORD)
-PG_KEYWORD("install", INSTALL, UNRESERVED_KEYWORD)
-PG_KEYWORD("instead", INSTEAD, UNRESERVED_KEYWORD)
-PG_KEYWORD("int", INT_P, COL_NAME_KEYWORD)
-PG_KEYWORD("integer", INTEGER, COL_NAME_KEYWORD)
-PG_KEYWORD("intersect", INTERSECT, RESERVED_KEYWORD)
-PG_KEYWORD("interval", INTERVAL, COL_NAME_KEYWORD)
-PG_KEYWORD("into", INTO, RESERVED_KEYWORD)
-PG_KEYWORD("invoker", INVOKER, UNRESERVED_KEYWORD)
-PG_KEYWORD("is", IS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("isolation", ISOLATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("join", JOIN, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("json", JSON, UNRESERVED_KEYWORD)
-PG_KEYWORD("key", KEY, UNRESERVED_KEYWORD)
-PG_KEYWORD("label", LABEL, UNRESERVED_KEYWORD)
-PG_KEYWORD("language", LANGUAGE, UNRESERVED_KEYWORD)
-PG_KEYWORD("large", LARGE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("last", LAST_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("lateral", LATERAL_P, RESERVED_KEYWORD)
-PG_KEYWORD("leading", LEADING, RESERVED_KEYWORD)
-PG_KEYWORD("leakproof", LEAKPROOF, UNRESERVED_KEYWORD)
-PG_KEYWORD("left", LEFT, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("level", LEVEL, UNRESERVED_KEYWORD)
-PG_KEYWORD("like", LIKE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("limit", LIMIT, RESERVED_KEYWORD)
-PG_KEYWORD("listen", LISTEN, UNRESERVED_KEYWORD)
-PG_KEYWORD("load", LOAD, UNRESERVED_KEYWORD)
-PG_KEYWORD("local", LOCAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("location", LOCATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("lock", LOCK_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("locked", LOCKED, UNRESERVED_KEYWORD)
-PG_KEYWORD("logged", LOGGED, UNRESERVED_KEYWORD)
-PG_KEYWORD("macro", MACRO, UNRESERVED_KEYWORD)
-PG_KEYWORD("map", MAP, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("mapping", MAPPING, UNRESERVED_KEYWORD)
-PG_KEYWORD("match", MATCH, UNRESERVED_KEYWORD)
-PG_KEYWORD("materialized", MATERIALIZED, UNRESERVED_KEYWORD)
-PG_KEYWORD("maxvalue", MAXVALUE, UNRESERVED_KEYWORD)
-PG_KEYWORD("method", METHOD, UNRESERVED_KEYWORD)
-PG_KEYWORD("microsecond", MICROSECOND_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("microseconds", MICROSECONDS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("millennia", MILLENNIA_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("millennium", MILLENNIUM_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("millisecond", MILLISECOND_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("milliseconds", MILLISECONDS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("minute", MINUTE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("minutes", MINUTES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("minvalue", MINVALUE, UNRESERVED_KEYWORD)
-PG_KEYWORD("mode", MODE, UNRESERVED_KEYWORD)
-PG_KEYWORD("month", MONTH_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("months", MONTHS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("move", MOVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("name", NAME_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("names", NAMES, UNRESERVED_KEYWORD)
-PG_KEYWORD("national", NATIONAL, COL_NAME_KEYWORD)
-PG_KEYWORD("natural", NATURAL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("nchar", NCHAR, COL_NAME_KEYWORD)
-PG_KEYWORD("new", NEW, UNRESERVED_KEYWORD)
-PG_KEYWORD("next", NEXT, UNRESERVED_KEYWORD)
-PG_KEYWORD("no", NO, UNRESERVED_KEYWORD)
-PG_KEYWORD("none", NONE, COL_NAME_KEYWORD)
-PG_KEYWORD("not", NOT, RESERVED_KEYWORD)
-PG_KEYWORD("nothing", NOTHING, UNRESERVED_KEYWORD)
-PG_KEYWORD("notify", NOTIFY, UNRESERVED_KEYWORD)
-PG_KEYWORD("notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("nowait", NOWAIT, UNRESERVED_KEYWORD)
-PG_KEYWORD("null", NULL_P, RESERVED_KEYWORD)
-PG_KEYWORD("nullif", NULLIF, COL_NAME_KEYWORD)
-PG_KEYWORD("nulls", NULLS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("numeric", NUMERIC, COL_NAME_KEYWORD)
-PG_KEYWORD("object", OBJECT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("of", OF, UNRESERVED_KEYWORD)
-PG_KEYWORD("off", OFF, UNRESERVED_KEYWORD)
-PG_KEYWORD("offset", OFFSET, RESERVED_KEYWORD)
-PG_KEYWORD("oids", OIDS, UNRESERVED_KEYWORD)
-PG_KEYWORD("old", OLD, UNRESERVED_KEYWORD)
-PG_KEYWORD("on", ON, RESERVED_KEYWORD)
-PG_KEYWORD("only", ONLY, RESERVED_KEYWORD)
-PG_KEYWORD("operator", OPERATOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("option", OPTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("options", OPTIONS, UNRESERVED_KEYWORD)
-PG_KEYWORD("or", OR, RESERVED_KEYWORD)
-PG_KEYWORD("order", ORDER, RESERVED_KEYWORD)
-PG_KEYWORD("ordinality", ORDINALITY, UNRESERVED_KEYWORD)
-PG_KEYWORD("others", OTHERS, UNRESERVED_KEYWORD)
-PG_KEYWORD("out", OUT_P, COL_NAME_KEYWORD)
-PG_KEYWORD("outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("over", OVER, UNRESERVED_KEYWORD)
-PG_KEYWORD("overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("overlay", OVERLAY, COL_NAME_KEYWORD)
-PG_KEYWORD("overriding", OVERRIDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("owned", OWNED, UNRESERVED_KEYWORD)
-PG_KEYWORD("owner", OWNER, UNRESERVED_KEYWORD)
-PG_KEYWORD("parallel", PARALLEL, UNRESERVED_KEYWORD)
-PG_KEYWORD("parser", PARSER, UNRESERVED_KEYWORD)
-PG_KEYWORD("partial", PARTIAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("partition", PARTITION, UNRESERVED_KEYWORD)
-PG_KEYWORD("passing", PASSING, UNRESERVED_KEYWORD)
-PG_KEYWORD("password", PASSWORD, UNRESERVED_KEYWORD)
-PG_KEYWORD("percent", PERCENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("persistent", PERSISTENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("pivot", PIVOT, RESERVED_KEYWORD)
-PG_KEYWORD("pivot_longer", PIVOT_LONGER, RESERVED_KEYWORD)
-PG_KEYWORD("pivot_wider", PIVOT_WIDER, RESERVED_KEYWORD)
-PG_KEYWORD("placing", PLACING, RESERVED_KEYWORD)
-PG_KEYWORD("plans", PLANS, UNRESERVED_KEYWORD)
-PG_KEYWORD("policy", POLICY, UNRESERVED_KEYWORD)
-PG_KEYWORD("position", POSITION, COL_NAME_KEYWORD)
-PG_KEYWORD("positional", POSITIONAL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("pragma", PRAGMA_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("preceding", PRECEDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("precision", PRECISION, COL_NAME_KEYWORD)
-PG_KEYWORD("prepare", PREPARE, UNRESERVED_KEYWORD)
-PG_KEYWORD("prepared", PREPARED, UNRESERVED_KEYWORD)
-PG_KEYWORD("preserve", PRESERVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("primary", PRIMARY, RESERVED_KEYWORD)
-PG_KEYWORD("prior", PRIOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("privileges", PRIVILEGES, UNRESERVED_KEYWORD)
-PG_KEYWORD("procedural", PROCEDURAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("procedure", PROCEDURE, UNRESERVED_KEYWORD)
-PG_KEYWORD("program", PROGRAM, UNRESERVED_KEYWORD)
-PG_KEYWORD("publication", PUBLICATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("qualify", QUALIFY, RESERVED_KEYWORD)
-PG_KEYWORD("quarter", QUARTER_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("quarters", QUARTERS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("quote", QUOTE, UNRESERVED_KEYWORD)
-PG_KEYWORD("range", RANGE, UNRESERVED_KEYWORD)
-PG_KEYWORD("read", READ_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("real", REAL, COL_NAME_KEYWORD)
-PG_KEYWORD("reassign", REASSIGN, UNRESERVED_KEYWORD)
-PG_KEYWORD("recheck", RECHECK, UNRESERVED_KEYWORD)
-PG_KEYWORD("recursive", RECURSIVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("ref", REF, UNRESERVED_KEYWORD)
-PG_KEYWORD("references", REFERENCES, RESERVED_KEYWORD)
-PG_KEYWORD("referencing", REFERENCING, UNRESERVED_KEYWORD)
-PG_KEYWORD("refresh", REFRESH, UNRESERVED_KEYWORD)
-PG_KEYWORD("reindex", REINDEX, UNRESERVED_KEYWORD)
-PG_KEYWORD("relative", RELATIVE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("release", RELEASE, UNRESERVED_KEYWORD)
-PG_KEYWORD("rename", RENAME, UNRESERVED_KEYWORD)
-PG_KEYWORD("repeatable", REPEATABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("replace", REPLACE, UNRESERVED_KEYWORD)
-PG_KEYWORD("replica", REPLICA, UNRESERVED_KEYWORD)
-PG_KEYWORD("reset", RESET, UNRESERVED_KEYWORD)
-PG_KEYWORD("respect", RESPECT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("restart", RESTART, UNRESERVED_KEYWORD)
-PG_KEYWORD("restrict", RESTRICT, UNRESERVED_KEYWORD)
-PG_KEYWORD("returning", RETURNING, RESERVED_KEYWORD)
-PG_KEYWORD("returns", RETURNS, UNRESERVED_KEYWORD)
-PG_KEYWORD("revoke", REVOKE, UNRESERVED_KEYWORD)
-PG_KEYWORD("right", RIGHT, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("role", ROLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("rollback", ROLLBACK, UNRESERVED_KEYWORD)
-PG_KEYWORD("rollup", ROLLUP, UNRESERVED_KEYWORD)
-PG_KEYWORD("row", ROW, COL_NAME_KEYWORD)
-PG_KEYWORD("rows", ROWS, UNRESERVED_KEYWORD)
-PG_KEYWORD("rule", RULE, UNRESERVED_KEYWORD)
-PG_KEYWORD("sample", SAMPLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("savepoint", SAVEPOINT, UNRESERVED_KEYWORD)
-PG_KEYWORD("schema", SCHEMA, UNRESERVED_KEYWORD)
-PG_KEYWORD("schemas", SCHEMAS, UNRESERVED_KEYWORD)
-PG_KEYWORD("scope", SCOPE, UNRESERVED_KEYWORD)
-PG_KEYWORD("scroll", SCROLL, UNRESERVED_KEYWORD)
-PG_KEYWORD("search", SEARCH, UNRESERVED_KEYWORD)
-PG_KEYWORD("second", SECOND_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("seconds", SECONDS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("secret", SECRET, UNRESERVED_KEYWORD)
-PG_KEYWORD("security", SECURITY, UNRESERVED_KEYWORD)
-PG_KEYWORD("select", SELECT, RESERVED_KEYWORD)
-PG_KEYWORD("semi", SEMI, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("sequence", SEQUENCE, UNRESERVED_KEYWORD)
-PG_KEYWORD("sequences", SEQUENCES, UNRESERVED_KEYWORD)
-PG_KEYWORD("serializable", SERIALIZABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("server", SERVER, UNRESERVED_KEYWORD)
-PG_KEYWORD("session", SESSION, UNRESERVED_KEYWORD)
-PG_KEYWORD("set", SET, UNRESERVED_KEYWORD)
-PG_KEYWORD("setof", SETOF, COL_NAME_KEYWORD)
-PG_KEYWORD("sets", SETS, UNRESERVED_KEYWORD)
-PG_KEYWORD("share", SHARE, UNRESERVED_KEYWORD)
-PG_KEYWORD("show", SHOW, RESERVED_KEYWORD)
-PG_KEYWORD("similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("simple", SIMPLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("skip", SKIP, UNRESERVED_KEYWORD)
-PG_KEYWORD("smallint", SMALLINT, COL_NAME_KEYWORD)
-PG_KEYWORD("snapshot", SNAPSHOT, UNRESERVED_KEYWORD)
-PG_KEYWORD("some", SOME, RESERVED_KEYWORD)
-PG_KEYWORD("sql", SQL_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("stable", STABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("standalone", STANDALONE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("start", START, UNRESERVED_KEYWORD)
-PG_KEYWORD("statement", STATEMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("statistics", STATISTICS, UNRESERVED_KEYWORD)
-PG_KEYWORD("stdin", STDIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("stdout", STDOUT, UNRESERVED_KEYWORD)
-PG_KEYWORD("storage", STORAGE, UNRESERVED_KEYWORD)
-PG_KEYWORD("stored", STORED, UNRESERVED_KEYWORD)
-PG_KEYWORD("strict", STRICT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("strip", STRIP_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("struct", STRUCT, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("subscription", SUBSCRIPTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("substring", SUBSTRING, COL_NAME_KEYWORD)
-PG_KEYWORD("summarize", SUMMARIZE, RESERVED_KEYWORD)
-PG_KEYWORD("symmetric", SYMMETRIC, RESERVED_KEYWORD)
-PG_KEYWORD("sysid", SYSID, UNRESERVED_KEYWORD)
-PG_KEYWORD("system", SYSTEM_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("table", TABLE, RESERVED_KEYWORD)
-PG_KEYWORD("tables", TABLES, UNRESERVED_KEYWORD)
-PG_KEYWORD("tablesample", TABLESAMPLE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("tablespace", TABLESPACE, UNRESERVED_KEYWORD)
-PG_KEYWORD("temp", TEMP, UNRESERVED_KEYWORD)
-PG_KEYWORD("template", TEMPLATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("temporary", TEMPORARY, UNRESERVED_KEYWORD)
-PG_KEYWORD("text", TEXT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("then", THEN, RESERVED_KEYWORD)
-PG_KEYWORD("ties", TIES, UNRESERVED_KEYWORD)
-PG_KEYWORD("time", TIME, COL_NAME_KEYWORD)
-PG_KEYWORD("timestamp", TIMESTAMP, COL_NAME_KEYWORD)
-PG_KEYWORD("to", TO, RESERVED_KEYWORD)
-PG_KEYWORD("trailing", TRAILING, RESERVED_KEYWORD)
-PG_KEYWORD("transaction", TRANSACTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("transform", TRANSFORM, UNRESERVED_KEYWORD)
-PG_KEYWORD("treat", TREAT, COL_NAME_KEYWORD)
-PG_KEYWORD("trigger", TRIGGER, UNRESERVED_KEYWORD)
-PG_KEYWORD("trim", TRIM, COL_NAME_KEYWORD)
-PG_KEYWORD("true", TRUE_P, RESERVED_KEYWORD)
-PG_KEYWORD("truncate", TRUNCATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("trusted", TRUSTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("try_cast", TRY_CAST, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("type", TYPE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("types", TYPES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("unbounded", UNBOUNDED, UNRESERVED_KEYWORD)
-PG_KEYWORD("uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("union", UNION, RESERVED_KEYWORD)
-PG_KEYWORD("unique", UNIQUE, RESERVED_KEYWORD)
-PG_KEYWORD("unknown", UNKNOWN, UNRESERVED_KEYWORD)
-PG_KEYWORD("unlisten", UNLISTEN, UNRESERVED_KEYWORD)
-PG_KEYWORD("unlogged", UNLOGGED, UNRESERVED_KEYWORD)
-PG_KEYWORD("unpivot", UNPIVOT, RESERVED_KEYWORD)
-PG_KEYWORD("until", UNTIL, UNRESERVED_KEYWORD)
-PG_KEYWORD("update", UPDATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("use", USE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("user", USER, UNRESERVED_KEYWORD)
-PG_KEYWORD("using", USING, RESERVED_KEYWORD)
-PG_KEYWORD("vacuum", VACUUM, UNRESERVED_KEYWORD)
-PG_KEYWORD("valid", VALID, UNRESERVED_KEYWORD)
-PG_KEYWORD("validate", VALIDATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("validator", VALIDATOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("value", VALUE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("values", VALUES, COL_NAME_KEYWORD)
-PG_KEYWORD("varchar", VARCHAR, COL_NAME_KEYWORD)
-PG_KEYWORD("variable", VARIABLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("variadic", VARIADIC, RESERVED_KEYWORD)
-PG_KEYWORD("varying", VARYING, UNRESERVED_KEYWORD)
-PG_KEYWORD("verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("version", VERSION_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("view", VIEW, UNRESERVED_KEYWORD)
-PG_KEYWORD("views", VIEWS, UNRESERVED_KEYWORD)
-PG_KEYWORD("virtual", VIRTUAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("volatile", VOLATILE, UNRESERVED_KEYWORD)
-PG_KEYWORD("week", WEEK_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("weeks", WEEKS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("when", WHEN, RESERVED_KEYWORD)
-PG_KEYWORD("where", WHERE, RESERVED_KEYWORD)
-PG_KEYWORD("whitespace", WHITESPACE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("window", WINDOW, RESERVED_KEYWORD)
-PG_KEYWORD("with", WITH, RESERVED_KEYWORD)
-PG_KEYWORD("within", WITHIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("without", WITHOUT, UNRESERVED_KEYWORD)
-PG_KEYWORD("work", WORK, UNRESERVED_KEYWORD)
-PG_KEYWORD("wrapper", WRAPPER, UNRESERVED_KEYWORD)
-PG_KEYWORD("write", WRITE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("xml", XML_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlconcat", XMLCONCAT, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlelement", XMLELEMENT, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlexists", XMLEXISTS, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlforest", XMLFOREST, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlnamespaces", XMLNAMESPACES, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlparse", XMLPARSE, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlpi", XMLPI, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlroot", XMLROOT, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD)
-PG_KEYWORD("xmltable", XMLTABLE, COL_NAME_KEYWORD)
-PG_KEYWORD("year", YEAR_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("years", YEARS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("yes", YES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("zone", ZONE, UNRESERVED_KEYWORD)
-
-};
-
-const int NumScanKeywords = lengthof(ScanKeywords);
-} // namespace duckdb_libpgquery
diff --git a/src/duckdb/third_party/libpg_query/include/parser/parser.hpp b/src/duckdb/third_party/libpg_query/include/parser/parser.hpp
deleted file mode 100644
index 3c3bf24cc..000000000
--- a/src/duckdb/third_party/libpg_query/include/parser/parser.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * parser.h
- *		Definitions for the "raw" parser (flex and bison phases only)
- *
- * This is the external API for the raw lexing/parsing functions.
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/parser.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "nodes/parsenodes.hpp"
-#include "pg_simplified_token.hpp"
-#include <vector>
-namespace duckdb_libpgquery {
-
-typedef enum PGBackslashQuoteType {
-	PG_BACKSLASH_QUOTE_OFF,
-	PG_BACKSLASH_QUOTE_ON,
-	PG_BACKSLASH_QUOTE_SAFE_ENCODING
-} PGBackslashQuoteType;
-
-/* Primary entry point for the raw parsing functions */
-PGList *raw_parser(const char *str);
-
-PGKeywordCategory is_keyword(const char *str);
-std::vector<PGKeyword> keyword_list();
-
-std::vector<PGSimplifiedToken> tokenize(const char *str);
-
-/* Utility functions exported by gram.y (perhaps these should be elsewhere) */
-PGList *SystemFuncName(const char *name);
-PGTypeName *SystemTypeName(const char *name);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/parser/scanner.hpp b/src/duckdb/third_party/libpg_query/include/parser/scanner.hpp
deleted file mode 100644
index 2813b1b64..000000000
--- a/src/duckdb/third_party/libpg_query/include/parser/scanner.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * scanner.h
- *		API for the core scanner (flex machine)
- *
- * The core scanner is also used by PL/pgSQL, so we provide a public API
- * for it.  However, the rest of the backend is only expected to use the
- * higher-level API provided by parser.h.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/scanner.h
- *
- *-------------------------------------------------------------------------
- */
-
-#pragma once
-
-#include <cstdint>
-
-#include "common/keywords.hpp"
-#include "pg_definitions.hpp"
-
-namespace duckdb_libpgquery {
-
-/*
- * The scanner returns extra data about scanned tokens in this union type.
- * Note that this is a subset of the fields used in YYSTYPE of the bison
- * parsers built atop the scanner.
- */
-typedef union core_YYSTYPE {
-	int ival;            /* for integer literals */
-	char *str;           /* for identifiers and non-integer literals */
-	const char *keyword; /* canonical spelling of keywords */
-} core_YYSTYPE;
-
-/*
- * We track token locations in terms of byte offsets from the start of the
- * source string, not the column number/line number representation that
- * bison uses by default.  Also, to minimize overhead we track only one
- * location (usually the first token location) for each construct, not
- * the beginning and ending locations as bison does by default.  It's
- * therefore sufficient to make YYLTYPE an int.
- */
-#define YYLTYPE int
-
-/*
- * Another important component of the scanner's API is the token code numbers.
- * However, those are not defined in this file, because bison insists on
- * defining them for itself.  The token codes used by the core scanner are
- * the ASCII characters plus these:
- *	%token <str>	IDENT FCONST SCONST BCONST XCONST Op
- *	%token <ival>	ICONST PARAM
- *	%token			TYPECAST DOT_DOT COLON_EQUALS EQUALS_GREATER LAMBDA_ARROW
- *	%token			LESS_EQUALS GREATER_EQUALS NOT_EQUALS
- * The above token definitions *must* be the first ones declared in any
- * bison parser built atop this scanner, so that they will have consistent
- * numbers assigned to them (specifically, IDENT = 258 and so on).
- */
-
-/*
- * The YY_EXTRA data that a flex scanner allows us to pass around.
- * Private state needed by the core scanner goes here.  Note that the actual
- * yy_extra struct may be larger and have this as its first component, thus
- * allowing the calling parser to keep some fields of its own in YY_EXTRA.
- */
-typedef struct core_yy_extra_type {
-	/*
-	 * The string the scanner is physically scanning.  We keep this mainly so
-	 * that we can cheaply compute the offset of the current token (yytext).
-	 */
-	char *scanbuf;
-	PGSize scanbuflen;
-
-	/*
-	 * The keyword list to use.
-	 */
-	const PGScanKeyword *keywords;
-	int num_keywords;
-
-	/*
-	 * Scanner settings to use.  These are initialized from the corresponding
-	 * GUC variables by scanner_init().  Callers can modify them after
-	 * scanner_init() if they don't want the scanner's behavior to follow the
-	 * prevailing GUC settings.
-	 */
-	int backslash_quote;
-	bool escape_string_warning;
-	bool standard_conforming_strings;
-
-	/*
-	 * literalbuf is used to accumulate literal values when multiple rules are
-	 * needed to parse a single literal.  Call startlit() to reset buffer to
-	 * empty, addlit() to add text.  NOTE: the string in literalbuf is NOT
-	 * necessarily null-terminated, but there always IS room to add a trailing
-	 * null at offset literallen.  We store a null only when we need it.
-	 */
-	char *literalbuf; /* palloc'd expandable buffer */
-	int literallen;   /* actual current string length */
-	int literalalloc; /* current allocated buffer size */
-
-	int xcdepth;     /* depth of nesting in slash-star comments */
-	char *dolqstart; /* current $foo$ quote start string */
-
-	/* first part of UTF16 surrogate pair for Unicode escapes */
-	int32_t utf16_first_part;
-
-	/* state variables for literal-lexing warnings */
-	bool warn_on_first_escape;
-	bool saw_non_ascii;
-} core_yy_extra_type;
-
-/*
- * The type of yyscanner is opaque outside scan.l.
- */
-typedef void *core_yyscan_t;
-
-/* Entry points in parser/scan.l */
-core_yyscan_t scanner_init(const char *str, core_yy_extra_type *yyext, const PGScanKeyword *keywords, int num_keywords);
-void scanner_finish(core_yyscan_t yyscanner);
-int core_yylex(core_YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner);
-int scanner_errposition(int location, core_yyscan_t yyscanner);
-void scanner_yyerror(const char *message, core_yyscan_t yyscanner);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/parser/scansup.hpp b/src/duckdb/third_party/libpg_query/include/parser/scansup.hpp
deleted file mode 100644
index d449e8636..000000000
--- a/src/duckdb/third_party/libpg_query/include/parser/scansup.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * scansup.h
- *	  scanner support routines.  used by both the bootstrap lexer
- * as well as the normal lexer
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/scansup.h
- *
- *-------------------------------------------------------------------------
- */
-
-#pragma once
-
-namespace duckdb_libpgquery {
-
-char *scanstr(const char *s);
-
-char *downcase_truncate_identifier(const char *ident, int len, bool warn);
-
-char *downcase_identifier(const char *ident, int len, bool warn, bool truncate);
-
-bool scanner_isspace(char ch);
-
-void set_preserve_identifier_case(bool downcase);
-bool get_preserve_identifier_case();
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/pg_definitions.hpp b/src/duckdb/third_party/libpg_query/include/pg_definitions.hpp
deleted file mode 100644
index 37c58c176..000000000
--- a/src/duckdb/third_party/libpg_query/include/pg_definitions.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// this is a bit of a mess from c.h, port.h and some others. Upside is it makes the parser compile with minimal
-// dependencies.
-
-#pragma once
-
-#include <limits.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string>
-
-#ifdef ERROR
-#undef ERROR
-#endif
-
-typedef uintptr_t PGDatum;
-typedef uint64_t PGSize;
-
-typedef uint32_t PGIndex;
-typedef uint32_t PGOid;
-
-#define InvalidOid ((PGOid)0)
-
-#ifndef _MSC_VER
-#include <assert.h>
-#define Assert(a) assert(a);
-#define AssertMacro(p) ((void)assert(p))
-#else
-#define Assert(a) (a);
-#define AssertMacro(p) ((void)(p))
-#endif
-#define _(a) (a)
-
-#define lengthof(array) (sizeof(array) / sizeof((array)[0]))
-#define CppConcat(x, y) x##y
-
-#define HIGHBIT (0x80)
-#define IS_HIGHBIT_SET(ch) ((unsigned char)(ch)&HIGHBIT)
-
-#define FUNC_MAX_ARGS 100
-#define FLEXIBLE_ARRAY_MEMBER
-
-#define DEFAULT_INDEX_TYPE "art"
-#define INTERVAL_MASK(b) (1 << (b))
-
-#ifdef _MSC_VER
-#define __thread __declspec(thread)
-#endif
-
-
-//typedef struct {
-//	int32_t vl_len_;    /* these fields must match ArrayType! */
-//	int ndim;         /* always 1 for PGint2vector */
-//	int32_t dataoffset; /* always 0 for PGint2vector */
-//	PGOid elemtype;
-//	int dim1;
-//	int lbound1;
-//	int16_t values[];
-//} PGint2vector;
-
-struct pg_varlena {
-	char vl_len_[4];                    /* Do not touch this field directly! */
-	char vl_dat[1]; /* Data content is here */
-};
-
-typedef struct pg_varlena bytea;
-
-typedef int PGMemoryContext;
-
-namespace duckdb_libpgquery {
-
-typedef enum PGPostgresParserErrors {
-	PG_ERRCODE_SYNTAX_ERROR,
-	PG_ERRCODE_FEATURE_NOT_SUPPORTED,
-	PG_ERRCODE_INVALID_PARAMETER_VALUE,
-	PG_ERRCODE_WINDOWING_ERROR,
-	PG_ERRCODE_RESERVED_NAME,
-	PG_ERRCODE_INVALID_ESCAPE_SEQUENCE,
-	PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER,
-	ERRCODE_NAME_TOO_LONG
-} PGPostgresParserErrors;
-
-typedef enum PGPostgresRelPersistence {
-	PG_RELPERSISTENCE_TEMP,
-	PG_RELPERSISTENCE_UNLOGGED,
-	RELPERSISTENCE_PERMANENT
-} PGPostgresRelPersistence;
-
-typedef enum PGPostgresErrorLevel {
-	PGUNDEFINED,
-	PGNOTICE,
-	PGWARNING,
-	ERROR
-} PGPostgresErrorLevel;
-
-typedef enum PGPostgresAttributIdentityTypes {
-	PG_ATTRIBUTE_IDENTITY_ALWAYS,
-	ATTRIBUTE_IDENTITY_BY_DEFAULT
-} PGPostgresAttributIdentityTypes;
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/pg_functions.hpp b/src/duckdb/third_party/libpg_query/include/pg_functions.hpp
deleted file mode 100644
index bb591f75d..000000000
--- a/src/duckdb/third_party/libpg_query/include/pg_functions.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-#include <stdlib.h>
-#include <string>
-
-#define fprintf(...)
-
-#include "pg_definitions.hpp"
-
-#include "nodes/pg_list.hpp"
-#include "nodes/parsenodes.hpp"
-
-namespace duckdb_libpgquery {
-
-typedef struct parse_result_str parse_result;
-struct parse_result_str {
-	bool success;
-	PGList *parse_tree;
-	std::string error_message;
-	int error_location;
-};
-
-void pg_parser_init();
-void pg_parser_parse(const char *query, parse_result *res);
-void pg_parser_cleanup();
-
-// error handling
-int ereport(int code, ...);
-
-void elog(int code, const char *fmt, ...);
-int errcode(int sqlerrcode);
-int errmsg(const char *fmt, ...);
-int errhint(const char *msg);
-int errmsg_internal(const char *fmt, ...);
-int errdetail(const char *fmt, ...);
-int errposition(int cursorpos);
-char *psprintf(const char *fmt, ...);
-
-// memory mgmt
-char *pstrdup(const char *in);
-void *palloc(size_t n);
-void pfree(void *ptr);
-void *palloc0fast(size_t n);
-void *repalloc(void *ptr, size_t n);
-
-char *NameListToString(PGList *names);
-void *copyObject(const void *from);
-bool equal(const void *a, const void *b);
-int exprLocation(const PGNode *expr);
-
-// string gunk
-int pg_database_encoding_max_length(void);
-bool pg_verifymbstr(const char *mbstr, int len, bool noError);
-int pg_mbstrlen_with_len(const char *mbstr, int len);
-int pg_mbcliplen(const char *mbstr, int len, int limit);
-int pg_mblen(const char *mbstr);
-
-PGDefElem *defWithOids(bool value);
-
-typedef unsigned int pg_wchar;
-unsigned char *unicode_to_utf8(pg_wchar c, unsigned char *utf8string);
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/pg_simplified_token.hpp b/src/duckdb/third_party/libpg_query/include/pg_simplified_token.hpp
deleted file mode 100644
index 6d21fa616..000000000
--- a/src/duckdb/third_party/libpg_query/include/pg_simplified_token.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-namespace duckdb_libpgquery {
-
-enum class PGSimplifiedTokenType : uint8_t {
-	PG_SIMPLIFIED_TOKEN_IDENTIFIER,
-	PG_SIMPLIFIED_TOKEN_NUMERIC_CONSTANT,
-	PG_SIMPLIFIED_TOKEN_STRING_CONSTANT,
-	PG_SIMPLIFIED_TOKEN_OPERATOR,
-	PG_SIMPLIFIED_TOKEN_KEYWORD,
-	PG_SIMPLIFIED_TOKEN_COMMENT
-};
-
-struct PGSimplifiedToken {
-	PGSimplifiedTokenType type;
-	int32_t start;
-};
-
-enum class PGKeywordCategory : uint8_t {
-	PG_KEYWORD_UNRESERVED = 0,
-	PG_KEYWORD_COL_NAME = 1,
-	PG_KEYWORD_TYPE_FUNC= 2,
-	PG_KEYWORD_RESERVED = 3,
-	PG_KEYWORD_NONE = 4
-};
-
-
-struct PGKeyword {
-	std::string text;
-	PGKeywordCategory category;
-};
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/pgtime.hpp b/src/duckdb/third_party/libpg_query/include/pgtime.hpp
deleted file mode 100644
index 27906a942..000000000
--- a/src/duckdb/third_party/libpg_query/include/pgtime.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pgtime.h
- *	  PostgreSQL internal timezone library
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- *
- * IDENTIFICATION
- *	  src/include/pgtime.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include <cstdint>
-
-/*
- * The API of this library is generally similar to the corresponding
- * C library functions, except that we use pg_time_t which (we hope) is
- * 64 bits wide, and which is most definitely signed not unsigned.
- */
-
-typedef int64_t pg_time_t;
-
-struct pg_tm
-{
-	int			tm_sec;
-	int			tm_min;
-	int			tm_hour;
-	int			tm_mday;
-	int			tm_mon;			/* origin 1, not 0! */
-	int			tm_year;		/* relative to 1900 */
-	int			tm_wday;
-	int			tm_yday;
-	int			tm_isdst;
-	long int	tm_gmtoff;
-	const char *tm_zone;
-};
-
-typedef struct pg_tz pg_tz;
-typedef struct pg_tzenum pg_tzenum;
-
-/* Maximum length of a timezone name (not including trailing null) */
-#define TZ_STRLEN_MAX 255
-
-/* these functions are in localtime.c */
-
-struct pg_tm *pg_localtime(const pg_time_t *timep, const pg_tz *tz);
-struct pg_tm *pg_gmtime(const pg_time_t *timep);
-int pg_next_dst_boundary(const pg_time_t *timep,
-					 long int *before_gmtoff,
-					 int *before_isdst,
-					 pg_time_t *boundary,
-					 long int *after_gmtoff,
-					 int *after_isdst,
-					 const pg_tz *tz);
-bool pg_interpret_timezone_abbrev(const char *abbrev,
-							 const pg_time_t *timep,
-							 long int *gmtoff,
-							 int *isdst,
-							 const pg_tz *tz);
-bool pg_get_timezone_offset(const pg_tz *tz, long int *gmtoff);
-const char *pg_get_timezone_name(pg_tz *tz);
-bool pg_tz_acceptable(pg_tz *tz);
-
-/* these functions and variables are in pgtz.c */
-
-pg_tz *session_timezone;
-pg_tz *log_timezone;
-
-void pg_timezone_initialize(void);
-pg_tz *pg_tzset(const char *tzname);
-pg_tz *pg_tzset_offset(long gmtoffset);
-
-pg_tzenum *pg_tzenumerate_start(void);
-pg_tz *pg_tzenumerate_next(pg_tzenum *dir);
-void pg_tzenumerate_end(pg_tzenum *dir);
diff --git a/src/duckdb/third_party/libpg_query/include/postgres_parser.hpp b/src/duckdb/third_party/libpg_query/include/postgres_parser.hpp
deleted file mode 100644
index 88d92c818..000000000
--- a/src/duckdb/third_party/libpg_query/include/postgres_parser.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// postgres_parser.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include "nodes/pg_list.hpp"
-#include "pg_simplified_token.hpp"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb {
-class PostgresParser {
-public:
-	PostgresParser();
-	~PostgresParser();
-
-	bool success;
-	duckdb_libpgquery::PGList *parse_tree;
-	std::string error_message;
-	int error_location;
-public:
-	void Parse(const std::string &query);
-	static duckdb::vector<duckdb_libpgquery::PGSimplifiedToken> Tokenize(const std::string &query);
-
-	static duckdb_libpgquery::PGKeywordCategory IsKeyword(const std::string &text);
-	static duckdb::vector<duckdb_libpgquery::PGKeyword> KeywordList();
-
-	static void SetPreserveIdentifierCase(bool downcase);
-};
-
-}
diff --git a/src/duckdb/third_party/libpg_query/include/utils/datetime.hpp b/src/duckdb/third_party/libpg_query/include/utils/datetime.hpp
deleted file mode 100644
index 249652c77..000000000
--- a/src/duckdb/third_party/libpg_query/include/utils/datetime.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * datetime.h
- *	  Definitions for date/time support code.
- *	  The support code is shared with other date data types,
- *	   including abstime, reltime, date, and time.
- *
- *
- * Portions Copyright (c) 1996-2015, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/datetime.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "nodes/nodes.hpp"
-#include "utils/timestamp.hpp"
-
-
-/*
- * Field types for time decoding.
- *
- * Can't have more of these than there are bits in an unsigned int
- * since these are turned into bit masks during parsing and decoding.
- *
- * Furthermore, the values for YEAR, MONTH, DAY, HOUR, MINUTE, SECOND
- * must be in the range 0..14 so that the associated bitmasks can fit
- * into the left half of an INTERVAL's typmod value.  Since those bits
- * are stored in typmods, you can't change them without initdb!
- */
-
-#define RESERV	0
-#define MONTH	1
-#define YEAR	2
-#define DAY		3
-#define JULIAN	4
-#define TZ		5				/* fixed-offset timezone abbreviation */
-#define DTZ		6				/* fixed-offset timezone abbrev, DST */
-#define DYNTZ	7				/* dynamic timezone abbreviation */
-#define IGNORE_DTF	8
-#define AMPM	9
-#define HOUR	10
-#define MINUTE	11
-#define SECOND	12
-#define MILLISECOND 13
-#define MICROSECOND 14
-#define DOY		15
-#define DOW		16
-#define UNITS	17
-#define ADBC	18
-/* these are only for relative dates */
-#define AGO		19
-#define ABS_BEFORE		20
-#define ABS_AFTER		21
-/* generic fields to help with parsing */
-#define ISODATE 22
-#define ISOTIME 23
-/* these are only for parsing intervals */
-#define WEEK		24
-#define DECADE		25
-#define CENTURY		26
-#define MILLENNIUM	27
-/* hack for parsing two-word timezone specs "MET DST" etc */
-#define DTZMOD	28				/* "DST" as a separate word */
-#define QUARTER		29
-/* reserved for unrecognized string values */
-#define UNKNOWN_FIELD	31
-
-
diff --git a/src/duckdb/third_party/libpg_query/include/utils/timestamp.hpp b/src/duckdb/third_party/libpg_query/include/utils/timestamp.hpp
deleted file mode 100644
index 55f7ac0cc..000000000
--- a/src/duckdb/third_party/libpg_query/include/utils/timestamp.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * timestamp.h
- *	  Definitions for the SQL "timestamp" and "interval" types.
- *
- * Portions Copyright (c) 1996-2015, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/timestamp.h
- *
- *-------------------------------------------------------------------------
- */
-#pragma once
-
-#include "datatype/timestamp.hpp"
-#include "fmgr.hpp"
-#include "pgtime.hpp"
-
-/* Macros to handle packing and unpacking the typmod field for intervals */
-#define INTERVAL_FULL_RANGE (0x7FFF)
-#define INTERVAL_RANGE_MASK (0x7FFF)
-#define INTERVAL_FULL_PRECISION (0xFFFF)
-#define INTERVAL_PRECISION_MASK (0xFFFF)
-#define INTERVAL_TYPMOD(p,r) ((((r) & INTERVAL_RANGE_MASK) << 16) | ((p) & INTERVAL_PRECISION_MASK))
-#define INTERVAL_PRECISION(t) ((t) & INTERVAL_PRECISION_MASK)
-#define INTERVAL_RANGE(t) (((t) >> 16) & INTERVAL_RANGE_MASK)
diff --git a/src/duckdb/third_party/libpg_query/pg_functions.cpp b/src/duckdb/third_party/libpg_query/pg_functions.cpp
deleted file mode 100644
index 3b7a7515e..000000000
--- a/src/duckdb/third_party/libpg_query/pg_functions.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <mutex>
-#include "pg_functions.hpp"
-#include "parser/parser.hpp"
-#include <stdarg.h>
-#include <mutex>
-#include <cstring>
-
-#ifdef __MVS__
-#include <zos-tls.h>
-#endif
-
-// max parse tree size approx 100 MB, should be enough
-#define PG_MALLOC_SIZE 10240
-
-namespace duckdb_libpgquery {
-
-typedef struct pg_parser_state_str parser_state;
-struct pg_parser_state_str {
-	int pg_err_code;
-	int pg_err_pos;
-	char pg_err_msg[BUFSIZ];
-
-	size_t malloc_pos;
-	size_t malloc_ptr_idx;
-	char **malloc_ptrs;
-	size_t malloc_ptr_size;
-};
-
-#ifdef __MVS__
-// --------------------------------------------------------
-// Permanent - WIP
-// static __tlssim<parser_state> pg_parser_state_impl();
-// #define pg_parser_state (*pg_parser_state_impl.access())
-// --------------------------------------------------------
-// Temporary
-static parser_state pg_parser_state;
-#else
-static __thread parser_state pg_parser_state;
-#endif
-
-#ifndef __GNUC__
-__thread PGNode *duckdb_newNodeMacroHolder;
-#endif
-
-static void allocate_new(parser_state *state, size_t n) {
-	if (state->malloc_ptr_idx >= state->malloc_ptr_size) {
-		size_t new_size = state->malloc_ptr_size * 2;
-		auto new_malloc_ptrs = (char **) malloc(sizeof(char *) * new_size);
-		if (!new_malloc_ptrs) {
-			throw std::bad_alloc();
-		}
-		memset(new_malloc_ptrs, 0, sizeof(char*) * new_size);
-		memcpy(new_malloc_ptrs, state->malloc_ptrs, state->malloc_ptr_size * sizeof(char*));
-		free(state->malloc_ptrs);
-		state->malloc_ptr_size = new_size;
-		state->malloc_ptrs = new_malloc_ptrs;
-	}
-	if (n < PG_MALLOC_SIZE) {
-		n = PG_MALLOC_SIZE;
-	}
-	auto base_ptr = (char *)malloc(n);
-	if (!base_ptr) {
-		throw std::bad_alloc();
-	}
-	state->malloc_ptrs[state->malloc_ptr_idx] = base_ptr;
-	state->malloc_ptr_idx++;
-	state->malloc_pos = 0;
-}
-
-void *palloc(size_t n) {
-	// we need to align our pointers for the sanitizer
-	auto allocate_n = n + sizeof(size_t);
-	auto aligned_n = ((allocate_n + 7) / 8) * 8;
-	if (pg_parser_state.malloc_pos + aligned_n > PG_MALLOC_SIZE) {
-		allocate_new(&pg_parser_state, aligned_n);
-	}
-
-	// store the length of the allocation
-	char *base_ptr = pg_parser_state.malloc_ptrs[pg_parser_state.malloc_ptr_idx - 1] + pg_parser_state.malloc_pos;
-	memcpy(base_ptr, &n, sizeof(size_t));
-	// store the actual pointer
-	char *ptr = (char*) base_ptr + sizeof(size_t);
-	memset(ptr, 0, n);
-	pg_parser_state.malloc_pos += aligned_n;
-	return ptr;
-}
-
-void pg_parser_init() {
-	pg_parser_state.pg_err_code = PGUNDEFINED;
-	pg_parser_state.pg_err_msg[0] = '\0';
-
-	pg_parser_state.malloc_ptr_size = 4;
-	auto new_malloc_ptrs = (char **) malloc(sizeof(char *) * pg_parser_state.malloc_ptr_size);
-	if (!new_malloc_ptrs) {
-		throw std::bad_alloc();
-	}
-	pg_parser_state.malloc_ptrs = new_malloc_ptrs;
-	memset(pg_parser_state.malloc_ptrs, 0, sizeof(char*) * pg_parser_state.malloc_ptr_size);
-	pg_parser_state.malloc_ptr_idx = 0;
-	allocate_new(&pg_parser_state, 1);
-}
-
-void pg_parser_parse(const char *query, parse_result *res) {
-	res->parse_tree = nullptr;
-	try {
-		res->parse_tree = duckdb_libpgquery::raw_parser(query);
-		res->success = pg_parser_state.pg_err_code == PGUNDEFINED;
-	} catch (std::exception &ex) {
-		res->success = false;
-		res->error_message = ex.what();
-		res->error_location = pg_parser_state.pg_err_pos;
-	}
-}
-
-void pg_parser_cleanup() {
-	for (size_t ptr_idx = 0; ptr_idx < pg_parser_state.malloc_ptr_idx; ptr_idx++) {
-		char *ptr = pg_parser_state.malloc_ptrs[ptr_idx];
-		if (ptr) {
-			free(ptr);
-			pg_parser_state.malloc_ptrs[ptr_idx] = nullptr;
-		}
-	}
-	free(pg_parser_state.malloc_ptrs);
-}
-
-int ereport(int code, ...) {
-	throw std::runtime_error(pg_parser_state.pg_err_msg);
-}
-void elog(int code, const char *fmt, ...) {
-	throw std::runtime_error("elog NOT IMPLEMENTED");
-}
-int errcode(int sqlerrcode) {
-	pg_parser_state.pg_err_code = sqlerrcode;
-	return 1;
-}
-int errmsg(const char *fmt, ...) {
-	va_list argptr;
-	va_start(argptr, fmt);
-	vsnprintf(pg_parser_state.pg_err_msg, BUFSIZ, fmt, argptr);
-	va_end(argptr);
-	return 1;
-}
-int errhint(const char *msg) {
-	throw std::runtime_error("errhint NOT IMPLEMENTED");
-}
-int errmsg_internal(const char *fmt, ...) {
-	throw std::runtime_error("errmsg_internal NOT IMPLEMENTED");
-}
-int errdetail(const char *fmt, ...) {
-	throw std::runtime_error("errdetail NOT IMPLEMENTED");
-}
-int errposition(int cursorpos) {
-	pg_parser_state.pg_err_pos = cursorpos;
-	return 1;
-}
-
-char *psprintf(const char *fmt, ...) {
-	char buf[BUFSIZ];
-	va_list args;
-	size_t newlen;
-
-	// attempt one: use stack buffer and determine length
-	va_start(args, fmt);
-	newlen = vsnprintf(buf, BUFSIZ, fmt, args);
-	va_end(args);
-	if (newlen < BUFSIZ) {
-		return pstrdup(buf);
-	}
-
-	// attempt two, malloc
-	auto mbuf = (char *)palloc(newlen);
-	va_start(args, fmt);
-	vsnprintf(mbuf, newlen, fmt, args);
-	va_end(args);
-	return mbuf;
-}
-
-char *pstrdup(const char *in) {
-	auto new_str = (char*) palloc(strlen(in) + 1);
-	memcpy(new_str, in, strlen(in));
-	return new_str;
-}
-
-void pfree(void *ptr) {
-	// nop, we free up entire context on parser cleanup
-}
-void *palloc0fast(size_t n) { // very fast
-	return palloc(n);
-}
-void *repalloc(void *ptr, size_t n) {
-	// get the length of the allocation
-	size_t old_len;
-	char *old_len_ptr = (char *) ptr - sizeof(size_t);
-	memcpy((void *) &old_len, old_len_ptr, sizeof(size_t));
-	// re-allocate and copy the data
-	auto new_buf = palloc(n);
-	memcpy(new_buf, ptr, old_len);
-	return new_buf;
-}
-char *NameListToString(PGList *names) {
-	throw std::runtime_error("NameListToString NOT IMPLEMENTED");
-}
-void *copyObject(const void *from) {
-	throw std::runtime_error("copyObject NOT IMPLEMENTED");
-}
-bool equal(const void *a, const void *b) {
-	throw std::runtime_error("equal NOT IMPLEMENTED");
-}
-int exprLocation(const PGNode *expr) {
-	throw std::runtime_error("exprLocation NOT IMPLEMENTED");
-}
-bool pg_verifymbstr(const char *mbstr, int len, bool noError) {
-	throw std::runtime_error("pg_verifymbstr NOT IMPLEMENTED");
-}
-
-int pg_database_encoding_max_length(void) {
-	return 4; // UTF8
-}
-
-static int pg_utf_mblen(const unsigned char *s) {
-	int len;
-
-	if ((*s & 0x80) == 0)
-		len = 1;
-	else if ((*s & 0xe0) == 0xc0)
-		len = 2;
-	else if ((*s & 0xf0) == 0xe0)
-		len = 3;
-	else if ((*s & 0xf8) == 0xf0)
-		len = 4;
-#ifdef NOT_USED
-	else if ((*s & 0xfc) == 0xf8)
-		len = 5;
-	else if ((*s & 0xfe) == 0xfc)
-		len = 6;
-#endif
-	else
-		len = 1;
-	return len;
-}
-
-int pg_mbstrlen_with_len(const char *mbstr, int limit) {
-	int len = 0;
-	while (limit > 0 && *mbstr) {
-		int l = pg_utf_mblen((const unsigned char *)mbstr);
-		limit -= l;
-		mbstr += l;
-		len++;
-	}
-	return len;
-}
-
-int pg_mbcliplen(const char *mbstr, int len, int limit) {
-	throw std::runtime_error("pg_mbcliplen NOT IMPLEMENTED");
-}
-int pg_mblen(const char *mbstr) {
-	throw std::runtime_error("pg_mblen NOT IMPLEMENTED");
-}
-PGDefElem *defWithOids(bool value) {
-	throw std::runtime_error("defWithOids NOT IMPLEMENTED");
-}
-unsigned char *unicode_to_utf8(pg_wchar c, unsigned char *utf8string) {
-	throw std::runtime_error("unicode_to_utf8 NOT IMPLEMENTED");
-}
-
-// this replaces a brain damaged macro in nodes.hpp
-PGNode *newNode(size_t size, PGNodeTag type) {
-	auto result = (PGNode *)palloc0fast(size);
-	result->type = type;
-	return result;
-}
-}
diff --git a/src/duckdb/third_party/libpg_query/postgres_parser.cpp b/src/duckdb/third_party/libpg_query/postgres_parser.cpp
deleted file mode 100644
index 7aea7a21b..000000000
--- a/src/duckdb/third_party/libpg_query/postgres_parser.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "postgres_parser.hpp"
-
-#include "pg_functions.hpp"
-#include "parser/parser.hpp"
-#include "parser/scansup.hpp"
-#include "common/keywords.hpp"
-
-namespace duckdb {
-
-PostgresParser::PostgresParser() : success(false), parse_tree(nullptr), error_message(""), error_location(0) {}
-
-void PostgresParser::Parse(const std::string &query) {
-	duckdb_libpgquery::pg_parser_init();
-	duckdb_libpgquery::parse_result res;
-	pg_parser_parse(query.c_str(), &res);
-	success = res.success;
-
-	if (success) {
-		parse_tree = res.parse_tree;
-	} else {
-		error_message = std::string(res.error_message);
-		error_location = res.error_location;
-	}
-}
-
-vector<duckdb_libpgquery::PGSimplifiedToken> PostgresParser::Tokenize(const std::string &query) {
-	duckdb_libpgquery::pg_parser_init();
-	auto tokens = duckdb_libpgquery::tokenize(query.c_str());
-	duckdb_libpgquery::pg_parser_cleanup();
-	return std::move(tokens);
-}
-
-PostgresParser::~PostgresParser()  {
-    duckdb_libpgquery::pg_parser_cleanup();
-}
-
-duckdb_libpgquery::PGKeywordCategory PostgresParser::IsKeyword(const std::string &text) {
-	return duckdb_libpgquery::is_keyword(text.c_str());
-}
-
-vector<duckdb_libpgquery::PGKeyword> PostgresParser::KeywordList() {
-	// FIXME: because of this, we might need to change the libpg_query library to use duckdb::vector
-	vector<duckdb_libpgquery::PGKeyword> tmp(duckdb_libpgquery::keyword_list());
-	return tmp;
-}
-
-void PostgresParser::SetPreserveIdentifierCase(bool preserve) {
-	duckdb_libpgquery::set_preserve_identifier_case(preserve);
-}
-
-}
diff --git a/src/duckdb/third_party/libpg_query/src_backend_nodes_list.cpp b/src/duckdb/third_party/libpg_query/src_backend_nodes_list.cpp
deleted file mode 100644
index 0de79132b..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_nodes_list.cpp
+++ /dev/null
@@ -1,540 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - lappend
- * - new_list
- * - new_tail_cell
- * - lcons
- * - new_head_cell
- * - list_concat
- * - list_nth
- * - list_nth_cell
- * - list_delete_cell
- * - list_free
- * - list_free_private
- * - list_copy
- * - list_copy_tail
- * - list_truncate
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * list.c
- *	  implementation for PostgreSQL generic linked list package
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/nodes/list.c
- *
- *-------------------------------------------------------------------------
- */
-#include "pg_functions.hpp"
-#include "nodes/pg_list.hpp"
-
-
-namespace duckdb_libpgquery {
-
-/*
- * Routines to simplify writing assertions about the type of a list; a
- * NIL list is considered to be an empty list of any type.
- */
-#define IsPointerList(l)		((l) == NIL || IsA((l), PGList))
-#define IsIntegerList(l)		((l) == NIL || IsA((l), IntList))
-#define IsOidList(l)			((l) == NIL || IsA((l), OidList))
-
-#ifdef USE_ASSERT_CHECKING
-/*
- * Check that the specified PGList is valid (so far as we can tell).
- */
-static void
-check_list_invariants(const PGList *list)
-{
-	if (list == NIL)
-		return;
-
-	Assert(list->length > 0);
-	Assert(list->head != NULL);
-	Assert(list->tail != NULL);
-
-	Assert(list->type == T_PGList ||
-		   list->type == T_PGIntList ||
-		   list->type == T_PGOidList);
-
-	if (list->length == 1)
-		Assert(list->head == list->tail);
-	if (list->length == 2)
-		Assert(list->head->next == list->tail);
-	Assert(list->tail->next == NULL);
-}
-#else
-#define check_list_invariants(l)
-#endif							/* USE_ASSERT_CHECKING */
-
-/*
- * Return a freshly allocated List. Since empty non-NIL lists are
- * invalid, new_list() also allocates the head cell of the new list:
- * the caller should be sure to fill in that cell's data.
- */
-static PGList *
-new_list(PGNodeTag type)
-{
-	PGList	   *new_list;
-	PGListCell   *new_head;
-
-	new_head = (PGListCell *) palloc(sizeof(*new_head));
-	new_head->next = NULL;
-	/* new_head->data is left undefined! */
-
-	new_list = (PGList *) palloc(sizeof(*new_list));
-	new_list->type = type;
-	new_list->length = 1;
-	new_list->head = new_head;
-	new_list->tail = new_head;
-
-	return new_list;
-}
-
-/*
- * Allocate a new cell and make it the head of the specified
- * list. Assumes the list it is passed is non-NIL.
- *
- * The data in the new head cell is undefined; the caller should be
- * sure to fill it in
- */
-static void
-new_head_cell(PGList *list)
-{
-	PGListCell   *new_head;
-
-	new_head = (PGListCell *) palloc(sizeof(*new_head));
-	new_head->next = list->head;
-
-	list->head = new_head;
-	list->length++;
-}
-
-/*
- * Allocate a new cell and make it the tail of the specified
- * list. Assumes the list it is passed is non-NIL.
- *
- * The data in the new tail cell is undefined; the caller should be
- * sure to fill it in
- */
-static void
-new_tail_cell(PGList *list)
-{
-	PGListCell   *new_tail;
-
-	new_tail = (PGListCell *) palloc(sizeof(*new_tail));
-	new_tail->next = NULL;
-
-	list->tail->next = new_tail;
-	list->tail = new_tail;
-	list->length++;
-}
-
-/*
- * PGAppend a pointer to the list. A pointer to the modified list is
- * returned. Note that this function may or may not destructively
- * modify the list; callers should always use this function's return
- * value, rather than continuing to use the pointer passed as the
- * first argument.
- */
-PGList *
-lappend(PGList *list, void *datum)
-{
-	Assert(IsPointerList(list));
-
-	if (list == NIL)
-		list = new_list(T_PGList);
-	else
-		new_tail_cell(list);
-
-	lfirst(list->tail) = datum;
-	check_list_invariants(list);
-	return list;
-}
-
-/*
- * PGAppend an integer to the specified list. See lappend()
- */
-
-
-/*
- * PGAppend an OID to the specified list. See lappend()
- */
-
-
-/*
- * Add a new cell to the list, in the position after 'prev_cell'. The
- * data in the cell is left undefined, and must be filled in by the
- * caller. 'list' is assumed to be non-NIL, and 'prev_cell' is assumed
- * to be non-NULL and a member of 'list'.
- */
-
-
-/*
- * Add a new cell to the specified list (which must be non-NIL);
- * it will be placed after the list cell 'prev' (which must be
- * non-NULL and a member of 'list'). The data placed in the new cell
- * is 'datum'. The newly-constructed cell is returned.
- */
-
-
-
-
-
-
-/*
- * Prepend a new element to the list. A pointer to the modified list
- * is returned. Note that this function may or may not destructively
- * modify the list; callers should always use this function's return
- * value, rather than continuing to use the pointer passed as the
- * second argument.
- *
- * Caution: before Postgres 8.0, the original PGList was unmodified and
- * could be considered to retain its separate identity.  This is no longer
- * the case.
- */
-PGList *
-lcons(void *datum, PGList *list)
-{
-	Assert(IsPointerList(list));
-
-	if (list == NIL)
-		list = new_list(T_PGList);
-	else
-		new_head_cell(list);
-
-	lfirst(list->head) = datum;
-	check_list_invariants(list);
-	return list;
-}
-
-/*
- * Prepend an integer to the list. See lcons()
- */
-
-
-/*
- * Prepend an OID to the list. See lcons()
- */
-
-
-/*
- * Concatenate list2 to the end of list1, and return list1. list1 is
- * destructively changed. Callers should be sure to use the return
- * value as the new pointer to the concatenated list: the 'list1'
- * input pointer may or may not be the same as the returned pointer.
- *
- * The nodes in list2 are merely appended to the end of list1 in-place
- * (i.e. they aren't copied; the two lists will share some of the same
- * storage). Therefore, invoking list_free() on list2 will also
- * invalidate a portion of list1.
- */
-PGList *
-list_concat(PGList *list1, PGList *list2)
-{
-	if (list1 == NIL)
-		return list2;
-	if (list2 == NIL)
-		return list1;
-	if (list1 == list2)
-		elog(ERROR, "cannot list_concat() a list to itself");
-
-	Assert(list1->type == list2->type);
-
-	list1->length += list2->length;
-	list1->tail->next = list2->head;
-	list1->tail = list2->tail;
-
-	check_list_invariants(list1);
-	return list1;
-}
-
-/*
- * Truncate 'list' to contain no more than 'new_size' elements. This
- * modifies the list in-place! Despite this, callers should use the
- * pointer returned by this function to refer to the newly truncated
- * list -- it may or may not be the same as the pointer that was
- * passed.
- *
- * Note that any cells removed by list_truncate() are NOT pfree'd.
- */
-PGList *
-list_truncate(PGList *list, int new_size)
-{
-	PGListCell   *cell;
-	int			n;
-
-	if (new_size <= 0)
-		return NIL;				/* truncate to zero length */
-
-	/* If asked to effectively extend the list, do nothing */
-	if (new_size >= list_length(list))
-		return list;
-
-	n = 1;
-	foreach(cell, list)
-	{
-		if (n == new_size)
-		{
-			cell->next = NULL;
-			list->tail = cell;
-			list->length = new_size;
-			check_list_invariants(list);
-			return list;
-		}
-		n++;
-	}
-
-	/* keep the compiler quiet; never reached */
-	Assert(false);
-	return list;
-}
-
-/*
- * Locate the n'th cell (counting from 0) of the list.  It is an assertion
- * failure if there is no such cell.
- */
-PGListCell *
-list_nth_cell(const PGList *list, int n)
-{
-	PGListCell   *match;
-
-	Assert(list != NIL);
-	Assert(n >= 0);
-	Assert(n < list->length);
-	check_list_invariants(list);
-
-	/* Does the caller actually mean to fetch the tail? */
-	if (n == list->length - 1)
-		return list->tail;
-
-	for (match = list->head; n-- > 0; match = match->next)
-		;
-
-	return match;
-}
-
-/*
- * Return the data value contained in the n'th element of the
- * specified list. (PGList elements begin at 0.)
- */
-void *
-list_nth(const PGList *list, int n)
-{
-	Assert(IsPointerList(list));
-	return lfirst(list_nth_cell(list, n));
-}
-
-/*
- * Delete 'cell' from 'list'; 'prev' is the previous element to 'cell'
- * in 'list', if any (i.e. prev == NULL iff list->head == cell)
- *
- * The cell is pfree'd, as is the PGList header if this was the last member.
- */
-PGList *
-list_delete_cell(PGList *list, PGListCell *cell, PGListCell *prev)
-{
-	check_list_invariants(list);
-	Assert(prev != NULL ? lnext(prev) == cell : list_head(list) == cell);
-
-	/*
-	 * If we're about to delete the last node from the list, free the whole
-	 * list instead and return NIL, which is the only valid representation of
-	 * a zero-length list.
-	 */
-	if (list->length == 1)
-	{
-		list_free(list);
-		return NIL;
-	}
-
-	/*
-	 * Otherwise, adjust the necessary list links, deallocate the particular
-	 * node we have just removed, and return the list we were given.
-	 */
-	list->length--;
-
-	if (prev)
-		prev->next = cell->next;
-	else
-		list->head = cell->next;
-
-	if (list->tail == cell)
-		list->tail = prev;
-
-	pfree(cell);
-	return list;
-}
-
-/*
- * Free all storage in a list, and optionally the pointed-to elements
- */
-static void
-list_free_private(PGList *list, bool deep)
-{
-	PGListCell   *cell;
-
-	check_list_invariants(list);
-
-	cell = list_head(list);
-	while (cell != NULL)
-	{
-		PGListCell   *tmp = cell;
-
-		cell = lnext(cell);
-		if (deep)
-			pfree(lfirst(tmp));
-		pfree(tmp);
-	}
-
-	if (list)
-		pfree(list);
-}
-
-/*
- * Free all the cells of the list, as well as the list itself. Any
- * objects that are pointed-to by the cells of the list are NOT
- * free'd.
- *
- * On return, the argument to this function has been freed, so the
- * caller would be wise to set it to NIL for safety's sake.
- */
-void
-list_free(PGList *list)
-{
-	list_free_private(list, false);
-}
-
-/*
- * Free all the cells of the list, the list itself, and all the
- * objects pointed-to by the cells of the list (each element in the
- * list must contain a pointer to a palloc()'d region of memory!)
- *
- * On return, the argument to this function has been freed, so the
- * caller would be wise to set it to NIL for safety's sake.
- */
-
-
-/*
- * Return a shallow copy of the specified list.
- */
-PGList *
-list_copy(const PGList *oldlist)
-{
-	PGList	   *newlist;
-	PGListCell   *newlist_prev;
-	PGListCell   *oldlist_cur;
-
-	if (oldlist == NIL)
-		return NIL;
-
-	newlist = new_list(oldlist->type);
-	newlist->length = oldlist->length;
-
-	/*
-	 * Copy over the data in the first cell; new_list() has already allocated
-	 * the head cell itself
-	 */
-	newlist->head->data = oldlist->head->data;
-
-	newlist_prev = newlist->head;
-	oldlist_cur = oldlist->head->next;
-	while (oldlist_cur)
-	{
-		PGListCell   *newlist_cur;
-
-		newlist_cur = (PGListCell *) palloc(sizeof(*newlist_cur));
-		newlist_cur->data = oldlist_cur->data;
-		newlist_prev->next = newlist_cur;
-
-		newlist_prev = newlist_cur;
-		oldlist_cur = oldlist_cur->next;
-	}
-
-	newlist_prev->next = NULL;
-	newlist->tail = newlist_prev;
-
-	check_list_invariants(newlist);
-	return newlist;
-}
-
-/*
- * Return a shallow copy of the specified list, without the first N elements.
- */
-PGList *
-list_copy_tail(const PGList *oldlist, int nskip)
-{
-	PGList	   *newlist;
-	PGListCell   *newlist_prev;
-	PGListCell   *oldlist_cur;
-
-	if (nskip < 0)
-		nskip = 0;				/* would it be better to elog? */
-
-	if (oldlist == NIL || nskip >= oldlist->length)
-		return NIL;
-
-	newlist = new_list(oldlist->type);
-	newlist->length = oldlist->length - nskip;
-
-	/*
-	 * Skip over the unwanted elements.
-	 */
-	oldlist_cur = oldlist->head;
-	while (nskip-- > 0)
-		oldlist_cur = oldlist_cur->next;
-
-	/*
-	 * Copy over the data in the first remaining cell; new_list() has already
-	 * allocated the head cell itself
-	 */
-	newlist->head->data = oldlist_cur->data;
-
-	newlist_prev = newlist->head;
-	oldlist_cur = oldlist_cur->next;
-	while (oldlist_cur)
-	{
-		PGListCell   *newlist_cur;
-
-		newlist_cur = (PGListCell *) palloc(sizeof(*newlist_cur));
-		newlist_cur->data = oldlist_cur->data;
-		newlist_prev->next = newlist_cur;
-
-		newlist_prev = newlist_cur;
-		oldlist_cur = oldlist_cur->next;
-	}
-
-	newlist_prev->next = NULL;
-	newlist->tail = newlist_prev;
-
-	check_list_invariants(newlist);
-	return newlist;
-}
-
-/*
- * Temporary compatibility functions
- *
- * In order to avoid warnings for these function definitions, we need
- * to include a prototype here as well as in pg_list.h. That's because
- * we don't enable list API compatibility in list.c, so we
- * don't see the prototypes for these functions.
- */
-
-/*
- * Given a list, return its length. This is merely defined for the
- * sake of backward compatibility: we can't afford to define a macro
- * called "length", so it must be a function. New code should use the
- * list_length() macro in order to avoid the overhead of a function
- * call.
- */
-int			length(const PGList *list);
-
-
-}
diff --git a/src/duckdb/third_party/libpg_query/src_backend_nodes_makefuncs.cpp b/src/duckdb/third_party/libpg_query/src_backend_nodes_makefuncs.cpp
deleted file mode 100644
index b19b40d77..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_nodes_makefuncs.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - makeDefElem
- * - makeTypeNameFromNameList
- * - makeDefElemExtended
- * - makeAlias
- * - makeSimpleAExpr
- * - makeGroupingSet
- * - makeTypeName
- * - makeFuncCall
- * - makeAExpr
- * - makeRangeVar
- * - makeBoolExpr
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * makefuncs.c
- *	  creator functions for primitive nodes. The functions here are for
- *	  the most frequently created nodes.
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/nodes/makefuncs.c
- *
- *-------------------------------------------------------------------------
- */
-#include "pg_functions.hpp"
-
-
-
-#include "fmgr.hpp"
-#include "nodes/makefuncs.hpp"
-#include "nodes/nodeFuncs.hpp"
-
-namespace duckdb_libpgquery {
-
-/*
- * makeAExpr -
- *		makes an PGAExpr node
- */
-PGAExpr *makeAExpr(PGAExpr_Kind kind, PGList *name, PGNode *lexpr, PGNode *rexpr, int location) {
-	PGAExpr *a = makeNode(PGAExpr);
-
-	a->kind = kind;
-	a->name = name;
-	a->lexpr = lexpr;
-	a->rexpr = rexpr;
-	a->location = location;
-	return a;
-}
-
-/*
- * makeSimpleAExpr -
- *		As above, given a simple (unqualified) operator name
- */
-PGAExpr *makeSimpleAExpr(PGAExpr_Kind kind, const char *name, PGNode *lexpr, PGNode *rexpr, int location) {
-	PGAExpr *a = makeNode(PGAExpr);
-
-	a->kind = kind;
-	a->name = list_make1(makeString((char *)name));
-	a->lexpr = lexpr;
-	a->rexpr = rexpr;
-	a->location = location;
-	return a;
-}
-
-/*
- * makeVar -
- *	  creates a PGVar node
- */
-
-/*
- * makeVarFromTargetEntry -
- *		convenience function to create a same-level PGVar node from a
- *		PGTargetEntry
- */
-
-/*
- * makeWholeRowVar -
- *	  creates a PGVar node representing a whole row of the specified RTE
- *
- * A whole-row reference is a PGVar with varno set to the correct range
- * table entry, and varattno == 0 to signal that it references the whole
- * tuple.  (Use of zero here is unclean, since it could easily be confused
- * with error cases, but it's not worth changing now.)  The vartype indicates
- * a rowtype; either a named composite type, or RECORD.  This function
- * encapsulates the logic for determining the correct rowtype OID to use.
- *
- * If allowScalar is true, then for the case where the RTE is a single function
- * returning a non-composite result type, we produce a normal PGVar referencing
- * the function's result directly, instead of the single-column composite
- * value that the whole-row notation might otherwise suggest.
- */
-
-/*
- * makeTargetEntry -
- *	  creates a PGTargetEntry node
- */
-
-/*
- * flatCopyTargetEntry -
- *	  duplicate a PGTargetEntry, but don't copy substructure
- *
- * This is commonly used when we just want to modify the resno or substitute
- * a new expression.
- */
-
-/*
- * makeFromExpr -
- *	  creates a PGFromExpr node
- */
-
-/*
- * makeConst -
- *	  creates a PGConst node
- */
-
-/*
- * makeNullConst -
- *	  creates a PGConst node representing a NULL of the specified type/typmod
- *
- * This is a convenience routine that just saves a lookup of the type's
- * storage properties.
- */
-
-/*
- * makeBoolConst -
- *	  creates a PGConst node representing a boolean value (can be NULL too)
- */
-
-/*
- * makeBoolExpr -
- *	  creates a PGBoolExpr node
- */
-PGExpr *makeBoolExpr(PGBoolExprType boolop, PGList *args, int location) {
-	PGBoolExpr *b = makeNode(PGBoolExpr);
-
-	b->boolop = boolop;
-	b->args = args;
-	b->location = location;
-
-	return (PGExpr *)b;
-}
-
-/*
- * makeAlias -
- *	  creates an PGAlias node
- *
- * NOTE: the given name is copied, but the colnames list (if any) isn't.
- */
-PGAlias *makeAlias(const char *aliasname, PGList *colnames) {
-	PGAlias *a = makeNode(PGAlias);
-
-	a->aliasname = pstrdup(aliasname);
-	a->colnames = colnames;
-
-	return a;
-}
-
-/*
- * makeRelabelType -
- *	  creates a PGRelabelType node
- */
-
-/*
- * makeRangeVar -
- *	  creates a PGRangeVar node (rather oversimplified case)
- */
-PGRangeVar *makeRangeVar(char *schemaname, char *relname, int location) {
-	PGRangeVar *r = makeNode(PGRangeVar);
-
-	r->catalogname = NULL;
-	r->schemaname = schemaname;
-	r->relname = relname;
-	r->inh = true;
-	r->relpersistence = RELPERSISTENCE_PERMANENT;
-	r->alias = NULL;
-	r->location = location;
-	r->sample = NULL;
-
-	return r;
-}
-
-/*
- * makeTypeName -
- *	build a PGTypeName node for an unqualified name.
- *
- * typmod is defaulted, but can be changed later by caller.
- */
-PGTypeName *makeTypeName(char *typnam) {
-	return makeTypeNameFromNameList(list_make1(makeString(typnam)));
-}
-
-/*
- * makeTypeNameFromNameList -
- *	build a PGTypeName node for a String list representing a qualified name.
- *
- * typmod is defaulted, but can be changed later by caller.
- */
-PGTypeName *makeTypeNameFromNameList(PGList *names) {
-	PGTypeName *n = makeNode(PGTypeName);
-
-	n->names = names;
-	n->typmods = NIL;
-	n->typemod = -1;
-	n->location = -1;
-	return n;
-}
-
-/*
- * makeTypeNameFromOid -
- *	build a PGTypeName node to represent a type already known by OID/typmod.
- */
-
-/*
- * makeColumnDef -
- *	build a PGColumnDef node to represent a simple column definition.
- *
- * Type and collation are specified by OID.
- * Other properties are all basic to start with.
- */
-
-/*
- * makeFuncExpr -
- *	build an expression tree representing a function call.
- *
- * The argument expressions must have been transformed already.
- */
-
-/*
- * makeDefElem -
- *	build a PGDefElem node
- *
- * This is sufficient for the "typical" case with an unqualified option name
- * and no special action.
- */
-PGDefElem *makeDefElem(const char *name, PGNode *arg, int location) {
-	PGDefElem *res = makeNode(PGDefElem);
-
-	res->defnamespace = NULL;
-	res->defname = (char *)name;
-	res->arg = arg;
-	res->defaction = PG_DEFELEM_UNSPEC;
-	res->location = location;
-
-	return res;
-}
-
-/*
- * makeDefElemExtended -
- *	build a PGDefElem node with all fields available to be specified
- */
-PGDefElem *makeDefElemExtended(const char *nameSpace, const char *name, PGNode *arg, PGDefElemAction defaction,
-                               int location) {
-	PGDefElem *res = makeNode(PGDefElem);
-
-	res->defnamespace = (char *)nameSpace;
-	res->defname = (char *)name;
-	res->arg = arg;
-	res->defaction = defaction;
-	res->location = location;
-
-	return res;
-}
-
-/*
- * makeFuncCall -
- *
- * Initialize a PGFuncCall struct with the information every caller must
- * supply.  Any non-default parameters have to be inserted by the caller.
- */
-PGFuncCall *makeFuncCall(PGList *name, PGList *args, int location) {
-	PGFuncCall *n = makeNode(PGFuncCall);
-
-	n->funcname = name;
-	n->args = args;
-	n->agg_order = NIL;
-	n->agg_filter = NULL;
-	n->agg_within_group = false;
-	n->agg_star = false;
-	n->agg_distinct = false;
-	n->func_variadic = false;
-	n->over = NULL;
-	n->location = location;
-	return n;
-}
-
-/*
- * makeGroupingSet
- *
- */
-PGGroupingSet *makeGroupingSet(GroupingSetKind kind, PGList *content, int location) {
-	PGGroupingSet *n = makeNode(PGGroupingSet);
-
-	n->kind = kind;
-	n->content = content;
-	n->location = location;
-	return n;
-}
-}
diff --git a/src/duckdb/third_party/libpg_query/src_backend_nodes_value.cpp b/src/duckdb/third_party/libpg_query/src_backend_nodes_value.cpp
deleted file mode 100644
index 487103fd1..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_nodes_value.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - makeInteger
- * - makeString
- * - makeFloat
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * value.c
- *	  implementation of PGValue nodes
- *
- *
- * Copyright (c) 2003-2017, PostgreSQL Global Development PGGroup
- *
- *
- * IDENTIFICATION
- *	  src/backend/nodes/value.c
- *
- *-------------------------------------------------------------------------
- */
-#include "pg_functions.hpp"
-
-#include "nodes/parsenodes.hpp"
-#include <string>
-#include <cstring>
-
-namespace duckdb_libpgquery {
-
-/*
- *	makeInteger
- */
-PGValue *makeInteger(long i) {
-	PGValue *v = makeNode(PGValue);
-
-	v->type = T_PGInteger;
-	v->val.ival = i;
-	return v;
-}
-
-/*
- *	makeFloat
- *
- * Caller is responsible for passing a palloc'd string.
- */
-PGValue *makeFloat(char *numericStr) {
-	PGValue *v = makeNode(PGValue);
-
-	v->type = T_PGFloat;
-	v->val.str = numericStr;
-	return v;
-}
-
-/*
- *	makeString
- *
- * Caller is responsible for passing a palloc'd string.
- */
-PGValue *makeString(const char *str) {
-	PGValue *v = makeNode(PGValue);
-
-	v->type = T_PGString;
-	v->val.str = (char *)str;
-	return v;
-}
-
-/*
- *	makeBitString
- *
- * Caller is responsible for passing a palloc'd string.
- */
-
-}
diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp
deleted file mode 100644
index 71ed8b023..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp
+++ /dev/null
@@ -1,32502 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.3.  */
-
-/* Skeleton implementation for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
-   simplifying the original so-called "semantic" parser.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output.  */
-#define YYBISON 1
-
-/* Bison version.  */
-#define YYBISON_VERSION "2.3"
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 1
-
-/* Using locations.  */
-#define YYLSP_NEEDED 1
-
-/* Substitute the variable and function names.  */
-#define yyparse base_yyparse
-#define yylex   base_yylex
-#define yyerror base_yyerror
-#define yylval  base_yylval
-#define yychar  base_yychar
-#define yydebug base_yydebug
-#define yynerrs base_yynerrs
-#define yylloc base_yylloc
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     IDENT = 258,
-     FCONST = 259,
-     SCONST = 260,
-     BCONST = 261,
-     XCONST = 262,
-     Op = 263,
-     ICONST = 264,
-     PARAM = 265,
-     TYPECAST = 266,
-     DOT_DOT = 267,
-     COLON_EQUALS = 268,
-     EQUALS_GREATER = 269,
-     INTEGER_DIVISION = 270,
-     POWER_OF = 271,
-     LAMBDA_ARROW = 272,
-     DOUBLE_ARROW = 273,
-     LESS_EQUALS = 274,
-     GREATER_EQUALS = 275,
-     NOT_EQUALS = 276,
-     ABORT_P = 277,
-     ABSOLUTE_P = 278,
-     ACCESS = 279,
-     ACTION = 280,
-     ADD_P = 281,
-     ADMIN = 282,
-     AFTER = 283,
-     AGGREGATE = 284,
-     ALL = 285,
-     ALSO = 286,
-     ALTER = 287,
-     ALWAYS = 288,
-     ANALYSE = 289,
-     ANALYZE = 290,
-     AND = 291,
-     ANTI = 292,
-     ANY = 293,
-     ARRAY = 294,
-     AS = 295,
-     ASC_P = 296,
-     ASOF = 297,
-     ASSERTION = 298,
-     ASSIGNMENT = 299,
-     ASYMMETRIC = 300,
-     AT = 301,
-     ATTACH = 302,
-     ATTRIBUTE = 303,
-     AUTHORIZATION = 304,
-     BACKWARD = 305,
-     BEFORE = 306,
-     BEGIN_P = 307,
-     BETWEEN = 308,
-     BIGINT = 309,
-     BINARY = 310,
-     BIT = 311,
-     BOOLEAN_P = 312,
-     BOTH = 313,
-     BY = 314,
-     CACHE = 315,
-     CALL_P = 316,
-     CALLED = 317,
-     CASCADE = 318,
-     CASCADED = 319,
-     CASE = 320,
-     CAST = 321,
-     CATALOG_P = 322,
-     CENTURIES_P = 323,
-     CENTURY_P = 324,
-     CHAIN = 325,
-     CHAR_P = 326,
-     CHARACTER = 327,
-     CHARACTERISTICS = 328,
-     CHECK_P = 329,
-     CHECKPOINT = 330,
-     CLASS = 331,
-     CLOSE = 332,
-     CLUSTER = 333,
-     COALESCE = 334,
-     COLLATE = 335,
-     COLLATION = 336,
-     COLUMN = 337,
-     COLUMNS = 338,
-     COMMENT = 339,
-     COMMENTS = 340,
-     COMMIT = 341,
-     COMMITTED = 342,
-     COMPRESSION = 343,
-     CONCURRENTLY = 344,
-     CONFIGURATION = 345,
-     CONFLICT = 346,
-     CONNECTION = 347,
-     CONSTRAINT = 348,
-     CONSTRAINTS = 349,
-     CONTENT_P = 350,
-     CONTINUE_P = 351,
-     CONVERSION_P = 352,
-     COPY = 353,
-     COST = 354,
-     CREATE_P = 355,
-     CROSS = 356,
-     CSV = 357,
-     CUBE = 358,
-     CURRENT_P = 359,
-     CURSOR = 360,
-     CYCLE = 361,
-     DATA_P = 362,
-     DATABASE = 363,
-     DAY_P = 364,
-     DAYS_P = 365,
-     DEALLOCATE = 366,
-     DEC = 367,
-     DECADE_P = 368,
-     DECADES_P = 369,
-     DECIMAL_P = 370,
-     DECLARE = 371,
-     DEFAULT = 372,
-     DEFAULTS = 373,
-     DEFERRABLE = 374,
-     DEFERRED = 375,
-     DEFINER = 376,
-     DELETE_P = 377,
-     DELIMITER = 378,
-     DELIMITERS = 379,
-     DEPENDS = 380,
-     DESC_P = 381,
-     DESCRIBE = 382,
-     DETACH = 383,
-     DICTIONARY = 384,
-     DISABLE_P = 385,
-     DISCARD = 386,
-     DISTINCT = 387,
-     DO = 388,
-     DOCUMENT_P = 389,
-     DOMAIN_P = 390,
-     DOUBLE_P = 391,
-     DROP = 392,
-     EACH = 393,
-     ELSE = 394,
-     ENABLE_P = 395,
-     ENCODING = 396,
-     ENCRYPTED = 397,
-     END_P = 398,
-     ENUM_P = 399,
-     ESCAPE = 400,
-     EVENT = 401,
-     EXCEPT = 402,
-     EXCLUDE = 403,
-     EXCLUDING = 404,
-     EXCLUSIVE = 405,
-     EXECUTE = 406,
-     EXISTS = 407,
-     EXPLAIN = 408,
-     EXPORT_P = 409,
-     EXPORT_STATE = 410,
-     EXTENSION = 411,
-     EXTENSIONS = 412,
-     EXTERNAL = 413,
-     EXTRACT = 414,
-     FALSE_P = 415,
-     FAMILY = 416,
-     FETCH = 417,
-     FILTER = 418,
-     FIRST_P = 419,
-     FLOAT_P = 420,
-     FOLLOWING = 421,
-     FOR = 422,
-     FORCE = 423,
-     FOREIGN = 424,
-     FORWARD = 425,
-     FREEZE = 426,
-     FROM = 427,
-     FULL = 428,
-     FUNCTION = 429,
-     FUNCTIONS = 430,
-     GENERATED = 431,
-     GLOB = 432,
-     GLOBAL = 433,
-     GRANT = 434,
-     GRANTED = 435,
-     GROUP_P = 436,
-     GROUPING = 437,
-     GROUPING_ID = 438,
-     GROUPS = 439,
-     HANDLER = 440,
-     HAVING = 441,
-     HEADER_P = 442,
-     HOLD = 443,
-     HOUR_P = 444,
-     HOURS_P = 445,
-     IDENTITY_P = 446,
-     IF_P = 447,
-     IGNORE_P = 448,
-     ILIKE = 449,
-     IMMEDIATE = 450,
-     IMMUTABLE = 451,
-     IMPLICIT_P = 452,
-     IMPORT_P = 453,
-     IN_P = 454,
-     INCLUDE_P = 455,
-     INCLUDING = 456,
-     INCREMENT = 457,
-     INDEX = 458,
-     INDEXES = 459,
-     INHERIT = 460,
-     INHERITS = 461,
-     INITIALLY = 462,
-     INLINE_P = 463,
-     INNER_P = 464,
-     INOUT = 465,
-     INPUT_P = 466,
-     INSENSITIVE = 467,
-     INSERT = 468,
-     INSTALL = 469,
-     INSTEAD = 470,
-     INT_P = 471,
-     INTEGER = 472,
-     INTERSECT = 473,
-     INTERVAL = 474,
-     INTO = 475,
-     INVOKER = 476,
-     IS = 477,
-     ISNULL = 478,
-     ISOLATION = 479,
-     JOIN = 480,
-     JSON = 481,
-     KEY = 482,
-     LABEL = 483,
-     LANGUAGE = 484,
-     LARGE_P = 485,
-     LAST_P = 486,
-     LATERAL_P = 487,
-     LEADING = 488,
-     LEAKPROOF = 489,
-     LEFT = 490,
-     LEVEL = 491,
-     LIKE = 492,
-     LIMIT = 493,
-     LISTEN = 494,
-     LOAD = 495,
-     LOCAL = 496,
-     LOCATION = 497,
-     LOCK_P = 498,
-     LOCKED = 499,
-     LOGGED = 500,
-     MACRO = 501,
-     MAP = 502,
-     MAPPING = 503,
-     MATCH = 504,
-     MATERIALIZED = 505,
-     MAXVALUE = 506,
-     METHOD = 507,
-     MICROSECOND_P = 508,
-     MICROSECONDS_P = 509,
-     MILLENNIA_P = 510,
-     MILLENNIUM_P = 511,
-     MILLISECOND_P = 512,
-     MILLISECONDS_P = 513,
-     MINUTE_P = 514,
-     MINUTES_P = 515,
-     MINVALUE = 516,
-     MODE = 517,
-     MONTH_P = 518,
-     MONTHS_P = 519,
-     MOVE = 520,
-     NAME_P = 521,
-     NAMES = 522,
-     NATIONAL = 523,
-     NATURAL = 524,
-     NCHAR = 525,
-     NEW = 526,
-     NEXT = 527,
-     NO = 528,
-     NONE = 529,
-     NOT = 530,
-     NOTHING = 531,
-     NOTIFY = 532,
-     NOTNULL = 533,
-     NOWAIT = 534,
-     NULL_P = 535,
-     NULLIF = 536,
-     NULLS_P = 537,
-     NUMERIC = 538,
-     OBJECT_P = 539,
-     OF = 540,
-     OFF = 541,
-     OFFSET = 542,
-     OIDS = 543,
-     OLD = 544,
-     ON = 545,
-     ONLY = 546,
-     OPERATOR = 547,
-     OPTION = 548,
-     OPTIONS = 549,
-     OR = 550,
-     ORDER = 551,
-     ORDINALITY = 552,
-     OTHERS = 553,
-     OUT_P = 554,
-     OUTER_P = 555,
-     OVER = 556,
-     OVERLAPS = 557,
-     OVERLAY = 558,
-     OVERRIDING = 559,
-     OWNED = 560,
-     OWNER = 561,
-     PARALLEL = 562,
-     PARSER = 563,
-     PARTIAL = 564,
-     PARTITION = 565,
-     PASSING = 566,
-     PASSWORD = 567,
-     PERCENT = 568,
-     PERSISTENT = 569,
-     PIVOT = 570,
-     PIVOT_LONGER = 571,
-     PIVOT_WIDER = 572,
-     PLACING = 573,
-     PLANS = 574,
-     POLICY = 575,
-     POSITION = 576,
-     POSITIONAL = 577,
-     PRAGMA_P = 578,
-     PRECEDING = 579,
-     PRECISION = 580,
-     PREPARE = 581,
-     PREPARED = 582,
-     PRESERVE = 583,
-     PRIMARY = 584,
-     PRIOR = 585,
-     PRIVILEGES = 586,
-     PROCEDURAL = 587,
-     PROCEDURE = 588,
-     PROGRAM = 589,
-     PUBLICATION = 590,
-     QUALIFY = 591,
-     QUARTER_P = 592,
-     QUARTERS_P = 593,
-     QUOTE = 594,
-     RANGE = 595,
-     READ_P = 596,
-     REAL = 597,
-     REASSIGN = 598,
-     RECHECK = 599,
-     RECURSIVE = 600,
-     REF = 601,
-     REFERENCES = 602,
-     REFERENCING = 603,
-     REFRESH = 604,
-     REINDEX = 605,
-     RELATIVE_P = 606,
-     RELEASE = 607,
-     RENAME = 608,
-     REPEATABLE = 609,
-     REPLACE = 610,
-     REPLICA = 611,
-     RESET = 612,
-     RESPECT_P = 613,
-     RESTART = 614,
-     RESTRICT = 615,
-     RETURNING = 616,
-     RETURNS = 617,
-     REVOKE = 618,
-     RIGHT = 619,
-     ROLE = 620,
-     ROLLBACK = 621,
-     ROLLUP = 622,
-     ROW = 623,
-     ROWS = 624,
-     RULE = 625,
-     SAMPLE = 626,
-     SAVEPOINT = 627,
-     SCHEMA = 628,
-     SCHEMAS = 629,
-     SCOPE = 630,
-     SCROLL = 631,
-     SEARCH = 632,
-     SECOND_P = 633,
-     SECONDS_P = 634,
-     SECRET = 635,
-     SECURITY = 636,
-     SELECT = 637,
-     SEMI = 638,
-     SEQUENCE = 639,
-     SEQUENCES = 640,
-     SERIALIZABLE = 641,
-     SERVER = 642,
-     SESSION = 643,
-     SET = 644,
-     SETOF = 645,
-     SETS = 646,
-     SHARE = 647,
-     SHOW = 648,
-     SIMILAR = 649,
-     SIMPLE = 650,
-     SKIP = 651,
-     SMALLINT = 652,
-     SNAPSHOT = 653,
-     SOME = 654,
-     SQL_P = 655,
-     STABLE = 656,
-     STANDALONE_P = 657,
-     START = 658,
-     STATEMENT = 659,
-     STATISTICS = 660,
-     STDIN = 661,
-     STDOUT = 662,
-     STORAGE = 663,
-     STORED = 664,
-     STRICT_P = 665,
-     STRIP_P = 666,
-     STRUCT = 667,
-     SUBSCRIPTION = 668,
-     SUBSTRING = 669,
-     SUMMARIZE = 670,
-     SYMMETRIC = 671,
-     SYSID = 672,
-     SYSTEM_P = 673,
-     TABLE = 674,
-     TABLES = 675,
-     TABLESAMPLE = 676,
-     TABLESPACE = 677,
-     TEMP = 678,
-     TEMPLATE = 679,
-     TEMPORARY = 680,
-     TEXT_P = 681,
-     THEN = 682,
-     TIES = 683,
-     TIME = 684,
-     TIMESTAMP = 685,
-     TO = 686,
-     TRAILING = 687,
-     TRANSACTION = 688,
-     TRANSFORM = 689,
-     TREAT = 690,
-     TRIGGER = 691,
-     TRIM = 692,
-     TRUE_P = 693,
-     TRUNCATE = 694,
-     TRUSTED = 695,
-     TRY_CAST = 696,
-     TYPE_P = 697,
-     TYPES_P = 698,
-     UNBOUNDED = 699,
-     UNCOMMITTED = 700,
-     UNENCRYPTED = 701,
-     UNION = 702,
-     UNIQUE = 703,
-     UNKNOWN = 704,
-     UNLISTEN = 705,
-     UNLOGGED = 706,
-     UNPIVOT = 707,
-     UNTIL = 708,
-     UPDATE = 709,
-     USE_P = 710,
-     USER = 711,
-     USING = 712,
-     VACUUM = 713,
-     VALID = 714,
-     VALIDATE = 715,
-     VALIDATOR = 716,
-     VALUE_P = 717,
-     VALUES = 718,
-     VARCHAR = 719,
-     VARIABLE_P = 720,
-     VARIADIC = 721,
-     VARYING = 722,
-     VERBOSE = 723,
-     VERSION_P = 724,
-     VIEW = 725,
-     VIEWS = 726,
-     VIRTUAL = 727,
-     VOLATILE = 728,
-     WEEK_P = 729,
-     WEEKS_P = 730,
-     WHEN = 731,
-     WHERE = 732,
-     WHITESPACE_P = 733,
-     WINDOW = 734,
-     WITH = 735,
-     WITHIN = 736,
-     WITHOUT = 737,
-     WORK = 738,
-     WRAPPER = 739,
-     WRITE_P = 740,
-     XML_P = 741,
-     XMLATTRIBUTES = 742,
-     XMLCONCAT = 743,
-     XMLELEMENT = 744,
-     XMLEXISTS = 745,
-     XMLFOREST = 746,
-     XMLNAMESPACES = 747,
-     XMLPARSE = 748,
-     XMLPI = 749,
-     XMLROOT = 750,
-     XMLSERIALIZE = 751,
-     XMLTABLE = 752,
-     YEAR_P = 753,
-     YEARS_P = 754,
-     YES_P = 755,
-     ZONE = 756,
-     NOT_LA = 757,
-     NULLS_LA = 758,
-     WITH_LA = 759,
-     POSTFIXOP = 760,
-     UMINUS = 761
-   };
-#endif
-/* Tokens.  */
-#define IDENT 258
-#define FCONST 259
-#define SCONST 260
-#define BCONST 261
-#define XCONST 262
-#define Op 263
-#define ICONST 264
-#define PARAM 265
-#define TYPECAST 266
-#define DOT_DOT 267
-#define COLON_EQUALS 268
-#define EQUALS_GREATER 269
-#define INTEGER_DIVISION 270
-#define POWER_OF 271
-#define LAMBDA_ARROW 272
-#define DOUBLE_ARROW 273
-#define LESS_EQUALS 274
-#define GREATER_EQUALS 275
-#define NOT_EQUALS 276
-#define ABORT_P 277
-#define ABSOLUTE_P 278
-#define ACCESS 279
-#define ACTION 280
-#define ADD_P 281
-#define ADMIN 282
-#define AFTER 283
-#define AGGREGATE 284
-#define ALL 285
-#define ALSO 286
-#define ALTER 287
-#define ALWAYS 288
-#define ANALYSE 289
-#define ANALYZE 290
-#define AND 291
-#define ANTI 292
-#define ANY 293
-#define ARRAY 294
-#define AS 295
-#define ASC_P 296
-#define ASOF 297
-#define ASSERTION 298
-#define ASSIGNMENT 299
-#define ASYMMETRIC 300
-#define AT 301
-#define ATTACH 302
-#define ATTRIBUTE 303
-#define AUTHORIZATION 304
-#define BACKWARD 305
-#define BEFORE 306
-#define BEGIN_P 307
-#define BETWEEN 308
-#define BIGINT 309
-#define BINARY 310
-#define BIT 311
-#define BOOLEAN_P 312
-#define BOTH 313
-#define BY 314
-#define CACHE 315
-#define CALL_P 316
-#define CALLED 317
-#define CASCADE 318
-#define CASCADED 319
-#define CASE 320
-#define CAST 321
-#define CATALOG_P 322
-#define CENTURIES_P 323
-#define CENTURY_P 324
-#define CHAIN 325
-#define CHAR_P 326
-#define CHARACTER 327
-#define CHARACTERISTICS 328
-#define CHECK_P 329
-#define CHECKPOINT 330
-#define CLASS 331
-#define CLOSE 332
-#define CLUSTER 333
-#define COALESCE 334
-#define COLLATE 335
-#define COLLATION 336
-#define COLUMN 337
-#define COLUMNS 338
-#define COMMENT 339
-#define COMMENTS 340
-#define COMMIT 341
-#define COMMITTED 342
-#define COMPRESSION 343
-#define CONCURRENTLY 344
-#define CONFIGURATION 345
-#define CONFLICT 346
-#define CONNECTION 347
-#define CONSTRAINT 348
-#define CONSTRAINTS 349
-#define CONTENT_P 350
-#define CONTINUE_P 351
-#define CONVERSION_P 352
-#define COPY 353
-#define COST 354
-#define CREATE_P 355
-#define CROSS 356
-#define CSV 357
-#define CUBE 358
-#define CURRENT_P 359
-#define CURSOR 360
-#define CYCLE 361
-#define DATA_P 362
-#define DATABASE 363
-#define DAY_P 364
-#define DAYS_P 365
-#define DEALLOCATE 366
-#define DEC 367
-#define DECADE_P 368
-#define DECADES_P 369
-#define DECIMAL_P 370
-#define DECLARE 371
-#define DEFAULT 372
-#define DEFAULTS 373
-#define DEFERRABLE 374
-#define DEFERRED 375
-#define DEFINER 376
-#define DELETE_P 377
-#define DELIMITER 378
-#define DELIMITERS 379
-#define DEPENDS 380
-#define DESC_P 381
-#define DESCRIBE 382
-#define DETACH 383
-#define DICTIONARY 384
-#define DISABLE_P 385
-#define DISCARD 386
-#define DISTINCT 387
-#define DO 388
-#define DOCUMENT_P 389
-#define DOMAIN_P 390
-#define DOUBLE_P 391
-#define DROP 392
-#define EACH 393
-#define ELSE 394
-#define ENABLE_P 395
-#define ENCODING 396
-#define ENCRYPTED 397
-#define END_P 398
-#define ENUM_P 399
-#define ESCAPE 400
-#define EVENT 401
-#define EXCEPT 402
-#define EXCLUDE 403
-#define EXCLUDING 404
-#define EXCLUSIVE 405
-#define EXECUTE 406
-#define EXISTS 407
-#define EXPLAIN 408
-#define EXPORT_P 409
-#define EXPORT_STATE 410
-#define EXTENSION 411
-#define EXTENSIONS 412
-#define EXTERNAL 413
-#define EXTRACT 414
-#define FALSE_P 415
-#define FAMILY 416
-#define FETCH 417
-#define FILTER 418
-#define FIRST_P 419
-#define FLOAT_P 420
-#define FOLLOWING 421
-#define FOR 422
-#define FORCE 423
-#define FOREIGN 424
-#define FORWARD 425
-#define FREEZE 426
-#define FROM 427
-#define FULL 428
-#define FUNCTION 429
-#define FUNCTIONS 430
-#define GENERATED 431
-#define GLOB 432
-#define GLOBAL 433
-#define GRANT 434
-#define GRANTED 435
-#define GROUP_P 436
-#define GROUPING 437
-#define GROUPING_ID 438
-#define GROUPS 439
-#define HANDLER 440
-#define HAVING 441
-#define HEADER_P 442
-#define HOLD 443
-#define HOUR_P 444
-#define HOURS_P 445
-#define IDENTITY_P 446
-#define IF_P 447
-#define IGNORE_P 448
-#define ILIKE 449
-#define IMMEDIATE 450
-#define IMMUTABLE 451
-#define IMPLICIT_P 452
-#define IMPORT_P 453
-#define IN_P 454
-#define INCLUDE_P 455
-#define INCLUDING 456
-#define INCREMENT 457
-#define INDEX 458
-#define INDEXES 459
-#define INHERIT 460
-#define INHERITS 461
-#define INITIALLY 462
-#define INLINE_P 463
-#define INNER_P 464
-#define INOUT 465
-#define INPUT_P 466
-#define INSENSITIVE 467
-#define INSERT 468
-#define INSTALL 469
-#define INSTEAD 470
-#define INT_P 471
-#define INTEGER 472
-#define INTERSECT 473
-#define INTERVAL 474
-#define INTO 475
-#define INVOKER 476
-#define IS 477
-#define ISNULL 478
-#define ISOLATION 479
-#define JOIN 480
-#define JSON 481
-#define KEY 482
-#define LABEL 483
-#define LANGUAGE 484
-#define LARGE_P 485
-#define LAST_P 486
-#define LATERAL_P 487
-#define LEADING 488
-#define LEAKPROOF 489
-#define LEFT 490
-#define LEVEL 491
-#define LIKE 492
-#define LIMIT 493
-#define LISTEN 494
-#define LOAD 495
-#define LOCAL 496
-#define LOCATION 497
-#define LOCK_P 498
-#define LOCKED 499
-#define LOGGED 500
-#define MACRO 501
-#define MAP 502
-#define MAPPING 503
-#define MATCH 504
-#define MATERIALIZED 505
-#define MAXVALUE 506
-#define METHOD 507
-#define MICROSECOND_P 508
-#define MICROSECONDS_P 509
-#define MILLENNIA_P 510
-#define MILLENNIUM_P 511
-#define MILLISECOND_P 512
-#define MILLISECONDS_P 513
-#define MINUTE_P 514
-#define MINUTES_P 515
-#define MINVALUE 516
-#define MODE 517
-#define MONTH_P 518
-#define MONTHS_P 519
-#define MOVE 520
-#define NAME_P 521
-#define NAMES 522
-#define NATIONAL 523
-#define NATURAL 524
-#define NCHAR 525
-#define NEW 526
-#define NEXT 527
-#define NO 528
-#define NONE 529
-#define NOT 530
-#define NOTHING 531
-#define NOTIFY 532
-#define NOTNULL 533
-#define NOWAIT 534
-#define NULL_P 535
-#define NULLIF 536
-#define NULLS_P 537
-#define NUMERIC 538
-#define OBJECT_P 539
-#define OF 540
-#define OFF 541
-#define OFFSET 542
-#define OIDS 543
-#define OLD 544
-#define ON 545
-#define ONLY 546
-#define OPERATOR 547
-#define OPTION 548
-#define OPTIONS 549
-#define OR 550
-#define ORDER 551
-#define ORDINALITY 552
-#define OTHERS 553
-#define OUT_P 554
-#define OUTER_P 555
-#define OVER 556
-#define OVERLAPS 557
-#define OVERLAY 558
-#define OVERRIDING 559
-#define OWNED 560
-#define OWNER 561
-#define PARALLEL 562
-#define PARSER 563
-#define PARTIAL 564
-#define PARTITION 565
-#define PASSING 566
-#define PASSWORD 567
-#define PERCENT 568
-#define PERSISTENT 569
-#define PIVOT 570
-#define PIVOT_LONGER 571
-#define PIVOT_WIDER 572
-#define PLACING 573
-#define PLANS 574
-#define POLICY 575
-#define POSITION 576
-#define POSITIONAL 577
-#define PRAGMA_P 578
-#define PRECEDING 579
-#define PRECISION 580
-#define PREPARE 581
-#define PREPARED 582
-#define PRESERVE 583
-#define PRIMARY 584
-#define PRIOR 585
-#define PRIVILEGES 586
-#define PROCEDURAL 587
-#define PROCEDURE 588
-#define PROGRAM 589
-#define PUBLICATION 590
-#define QUALIFY 591
-#define QUARTER_P 592
-#define QUARTERS_P 593
-#define QUOTE 594
-#define RANGE 595
-#define READ_P 596
-#define REAL 597
-#define REASSIGN 598
-#define RECHECK 599
-#define RECURSIVE 600
-#define REF 601
-#define REFERENCES 602
-#define REFERENCING 603
-#define REFRESH 604
-#define REINDEX 605
-#define RELATIVE_P 606
-#define RELEASE 607
-#define RENAME 608
-#define REPEATABLE 609
-#define REPLACE 610
-#define REPLICA 611
-#define RESET 612
-#define RESPECT_P 613
-#define RESTART 614
-#define RESTRICT 615
-#define RETURNING 616
-#define RETURNS 617
-#define REVOKE 618
-#define RIGHT 619
-#define ROLE 620
-#define ROLLBACK 621
-#define ROLLUP 622
-#define ROW 623
-#define ROWS 624
-#define RULE 625
-#define SAMPLE 626
-#define SAVEPOINT 627
-#define SCHEMA 628
-#define SCHEMAS 629
-#define SCOPE 630
-#define SCROLL 631
-#define SEARCH 632
-#define SECOND_P 633
-#define SECONDS_P 634
-#define SECRET 635
-#define SECURITY 636
-#define SELECT 637
-#define SEMI 638
-#define SEQUENCE 639
-#define SEQUENCES 640
-#define SERIALIZABLE 641
-#define SERVER 642
-#define SESSION 643
-#define SET 644
-#define SETOF 645
-#define SETS 646
-#define SHARE 647
-#define SHOW 648
-#define SIMILAR 649
-#define SIMPLE 650
-#define SKIP 651
-#define SMALLINT 652
-#define SNAPSHOT 653
-#define SOME 654
-#define SQL_P 655
-#define STABLE 656
-#define STANDALONE_P 657
-#define START 658
-#define STATEMENT 659
-#define STATISTICS 660
-#define STDIN 661
-#define STDOUT 662
-#define STORAGE 663
-#define STORED 664
-#define STRICT_P 665
-#define STRIP_P 666
-#define STRUCT 667
-#define SUBSCRIPTION 668
-#define SUBSTRING 669
-#define SUMMARIZE 670
-#define SYMMETRIC 671
-#define SYSID 672
-#define SYSTEM_P 673
-#define TABLE 674
-#define TABLES 675
-#define TABLESAMPLE 676
-#define TABLESPACE 677
-#define TEMP 678
-#define TEMPLATE 679
-#define TEMPORARY 680
-#define TEXT_P 681
-#define THEN 682
-#define TIES 683
-#define TIME 684
-#define TIMESTAMP 685
-#define TO 686
-#define TRAILING 687
-#define TRANSACTION 688
-#define TRANSFORM 689
-#define TREAT 690
-#define TRIGGER 691
-#define TRIM 692
-#define TRUE_P 693
-#define TRUNCATE 694
-#define TRUSTED 695
-#define TRY_CAST 696
-#define TYPE_P 697
-#define TYPES_P 698
-#define UNBOUNDED 699
-#define UNCOMMITTED 700
-#define UNENCRYPTED 701
-#define UNION 702
-#define UNIQUE 703
-#define UNKNOWN 704
-#define UNLISTEN 705
-#define UNLOGGED 706
-#define UNPIVOT 707
-#define UNTIL 708
-#define UPDATE 709
-#define USE_P 710
-#define USER 711
-#define USING 712
-#define VACUUM 713
-#define VALID 714
-#define VALIDATE 715
-#define VALIDATOR 716
-#define VALUE_P 717
-#define VALUES 718
-#define VARCHAR 719
-#define VARIABLE_P 720
-#define VARIADIC 721
-#define VARYING 722
-#define VERBOSE 723
-#define VERSION_P 724
-#define VIEW 725
-#define VIEWS 726
-#define VIRTUAL 727
-#define VOLATILE 728
-#define WEEK_P 729
-#define WEEKS_P 730
-#define WHEN 731
-#define WHERE 732
-#define WHITESPACE_P 733
-#define WINDOW 734
-#define WITH 735
-#define WITHIN 736
-#define WITHOUT 737
-#define WORK 738
-#define WRAPPER 739
-#define WRITE_P 740
-#define XML_P 741
-#define XMLATTRIBUTES 742
-#define XMLCONCAT 743
-#define XMLELEMENT 744
-#define XMLEXISTS 745
-#define XMLFOREST 746
-#define XMLNAMESPACES 747
-#define XMLPARSE 748
-#define XMLPI 749
-#define XMLROOT 750
-#define XMLSERIALIZE 751
-#define XMLTABLE 752
-#define YEAR_P 753
-#define YEARS_P 754
-#define YES_P 755
-#define ZONE 756
-#define NOT_LA 757
-#define NULLS_LA 758
-#define WITH_LA 759
-#define POSTFIXOP 760
-#define UMINUS 761
-
-
-
-
-/* Copy the first part of user declarations.  */
-#line 1 "third_party/libpg_query/grammar/grammar.y.tmp"
-
-#line 1 "third_party/libpg_query/grammar/grammar.hpp"
-/*#define YYDEBUG 1*/
-/*-------------------------------------------------------------------------
- *
- * gram.y
- *	  POSTGRESQL BISON rules/actions
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/parser/gram.y
- *
- * HISTORY
- *	  AUTHOR			DATE			MAJOR EVENT
- *	  Andrew Yu			Sept, 1994		POSTQUEL to SQL conversion
- *	  Andrew Yu			Oct, 1994		lispy code conversion
- *
- * NOTES
- *	  CAPITALS are used to represent terminal symbols.
- *	  non-capitals are used to represent non-terminals.
- *
- *	  In general, nothing in this file should initiate database accesses
- *	  nor depend on changeable state (such as SET variables).  If you do
- *	  database accesses, your code will fail when we have aborted the
- *	  current transaction and are just parsing commands to find the next
- *	  ROLLBACK or COMMIT.  If you make use of SET variables, then you
- *	  will do the wrong thing in multi-query strings like this:
- *			SET constraint_exclusion TO off; SELECT * FROM foo;
- *	  because the entire string is parsed by gram.y before the SET gets
- *	  executed.  Anything that depends on the database or changeable state
- *	  should be handled during parse analysis so that it happens at the
- *	  right time not the wrong time.
- *
- * WARNINGS
- *	  If you use a list, make sure the datum is a node so that the printing
- *	  routines work.
- *
- *	  Sometimes we assign constants to makeStrings. Make sure we don't free
- *	  those.
- *
- *-------------------------------------------------------------------------
- */
-#include "pg_functions.hpp"
-#include <string.h>
-
-#include <ctype.h>
-#include <limits.h>
-
-#include "nodes/makefuncs.hpp"
-#include "nodes/nodeFuncs.hpp"
-#include "parser/gramparse.hpp"
-#include "parser/parser.hpp"
-#include "utils/datetime.hpp"
-
-namespace duckdb_libpgquery {
-#define DEFAULT_SCHEMA "main"
-
-/*
- * Location tracking support --- simpler than bison's default, since we only
- * want to track the start position not the end position of each nonterminal.
- */
-#define YYLLOC_DEFAULT(Current, Rhs, N) \
-	do { \
-		if ((N) > 0) \
-			(Current) = (Rhs)[1]; \
-		else \
-			(Current) = (-1); \
-	} while (0)
-
-/*
- * The above macro assigns -1 (unknown) as the parse location of any
- * nonterminal that was reduced from an empty rule, or whose leftmost
- * component was reduced from an empty rule.  This is problematic
- * for nonterminals defined like
- *		OptFooList: / * EMPTY * / { ... } | OptFooList Foo { ... } ;
- * because we'll set -1 as the location during the first reduction and then
- * copy it during each subsequent reduction, leaving us with -1 for the
- * location even when the list is not empty.  To fix that, do this in the
- * action for the nonempty rule(s):
- *		if (@$ < 0) @$ = @2;
- * (Although we have many nonterminals that follow this pattern, we only
- * bother with fixing @$ like this when the nonterminal's parse location
- * is actually referenced in some rule.)
- *
- * A cleaner answer would be to make YYLLOC_DEFAULT scan all the Rhs
- * locations until it's found one that's not -1.  Then we'd get a correct
- * location for any nonterminal that isn't entirely empty.  But this way
- * would add overhead to every rule reduction, and so far there's not been
- * a compelling reason to pay that overhead.
- */
-
-/*
- * Bison doesn't allocate anything that needs to live across parser calls,
- * so we can easily have it use palloc instead of malloc.  This prevents
- * memory leaks if we error out during parsing.  Note this only works with
- * bison >= 2.0.  However, in bison 1.875 the default is to use alloca()
- * if possible, so there's not really much problem anyhow, at least if
- * you're building with gcc.
- */
-#define YYMALLOC palloc
-#define YYFREE   pfree
-#define YYINITDEPTH 1000
-
-/* yields an integer bitmask of these flags: */
-#define CAS_NOT_DEFERRABLE			0x01
-#define CAS_DEFERRABLE				0x02
-#define CAS_INITIALLY_IMMEDIATE		0x04
-#define CAS_INITIALLY_DEFERRED		0x08
-#define CAS_NOT_VALID				0x10
-#define CAS_NO_INHERIT				0x20
-
-
-#define parser_yyerror(msg)  scanner_yyerror(msg, yyscanner)
-#define parser_errposition(pos)  scanner_errposition(pos, yyscanner)
-
-#if YYBISON == 1
-// explicitly define stack growing support
-// yacc cannot handle stack growing by default YYLTYPE is overriden - which the Postgres parser overrides with an `int`
-// so we need to copy these definitions here explicitly
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  short int yyss;
-  YYSTYPE yyvs;
-  YYLTYPE yyls;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
-      + 2 * YYSTACK_GAP_MAXIMUM)
-
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (YYID (0))
-#  endif
-# endif
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack)					\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack, Stack, yysize);				\
-	Stack = &yyptr->Stack;						\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (YYID (0))
-#endif
-
-static void base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner,
-						 const char *msg);
-static PGRawStmt *makeRawStmt(PGNode *stmt, int stmt_location);
-static void updateRawStmtEnd(PGRawStmt *rs, int end_location);
-static PGNode *makeColumnRef(char *colname, PGList *indirection,
-						   int location, core_yyscan_t yyscanner);
-static PGNode *makeTypeCast(PGNode *arg, PGTypeName *tpname, int trycast, int location);
-static PGNode *makeStringConst(char *str, int location);
-static PGNode *makeStringConstCast(char *str, int location, PGTypeName *tpname);
-static PGNode *makeIntervalNode(char *str, int location, PGList *typmods);
-static PGNode *makeIntervalNode(int val, int location, PGList *typmods);
-static PGNode *makeIntervalNode(PGNode *arg, int location, PGList *typmods);
-static PGNode *makeSampleSize(PGNode *sample_size, bool is_percentage);
-static PGNode *makeSampleOptions(PGNode *sample_size, char *method, int *seed, int location);
-static PGNode *makeIntConst(int val, int location);
-static PGNode *makeFloatConst(char *str, int location);
-static PGNode *makeBitStringConst(char *str, int location);
-static PGNode *makeNullAConst(int location);
-static PGNode *makeAConst(PGValue *v, int location);
-static PGNode *makeBoolAConst(bool state, int location);
-static PGNode *makeParamRef(int number, int location);
-static PGNode *makeNamedParamRef(char* name, int location);
-static void check_qualified_name(PGList *names, core_yyscan_t yyscanner);
-static PGList *check_func_name(PGList *names, core_yyscan_t yyscanner);
-static PGList *check_indirection(PGList *indirection, core_yyscan_t yyscanner);
-static void insertSelectOptions(PGSelectStmt *stmt,
-								PGList *sortClause, PGList *lockingClause,
-								PGNode *limitOffset, PGNode *limitCount,
-								PGWithClause *withClause,
-								core_yyscan_t yyscanner);
-static PGNode *makeSetOp(PGSetOperation op, bool all, PGNode *larg, PGNode *rarg);
-static PGNode *doNegate(PGNode *n, int location);
-static void doNegateFloat(PGValue *v);
-static PGNode *makeAndExpr(PGNode *lexpr, PGNode *rexpr, int location);
-static PGNode *makeOrExpr(PGNode *lexpr, PGNode *rexpr, int location);
-static PGNode *makeNotExpr(PGNode *expr, int location);
-static void SplitColQualList(PGList *qualList,
-							 PGList **constraintList, PGCollateClause **collClause,
-							 core_yyscan_t yyscanner);
-static void processCASbits(int cas_bits, int location, const char *constrType,
-			   bool *deferrable, bool *initdeferred, bool *not_valid,
-			   bool *no_inherit, core_yyscan_t yyscanner);
-static PGNode *makeRecursiveViewSelect(char *relname, PGList *aliases, PGNode *query);
-static PGNode *makeLimitPercent(PGNode *limit_percent);
-
-
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-#line 14 "third_party/libpg_query/grammar/grammar.y"
-{
-	core_YYSTYPE		core_yystype;
-	/* these fields must match core_YYSTYPE: */
-	int					ival;
-	char				*str;
-	const char			*keyword;
-	const char          *conststr;
-
-	char				chr;
-	bool				boolean;
-	PGJoinType			jtype;
-	PGDropBehavior		dbehavior;
-	PGOnCommitAction		oncommit;
-	PGOnCreateConflict		oncreateconflict;
-	PGList				*list;
-	PGNode				*node;
-	PGValue				*value;
-	PGObjectType			objtype;
-	PGTypeName			*typnam;
-	PGObjectWithArgs		*objwithargs;
-	PGDefElem				*defelt;
-	PGSortBy				*sortby;
-	PGWindowDef			*windef;
-	PGJoinExpr			*jexpr;
-	PGIndexElem			*ielem;
-	PGAlias				*alias;
-	PGRangeVar			*range;
-	PGIntoClause			*into;
-	PGCTEMaterialize			ctematerialize;
-	PGWithClause			*with;
-	PGInferClause			*infer;
-	PGOnConflictClause	*onconflict;
-	PGOnConflictActionAlias onconflictshorthand;
-	PGAIndices			*aind;
-	PGResTarget			*target;
-	PGInsertStmt			*istmt;
-	PGVariableSetStmt		*vsetstmt;
-	PGOverridingKind       override;
-	PGSortByDir            sortorder;
-	PGSortByNulls          nullorder;
-	PGIgnoreNulls          ignorenulls;
-	PGConstrType           constr;
-	PGLockClauseStrength lockstrength;
-	PGLockWaitPolicy lockwaitpolicy;
-	PGSubLinkType subquerytype;
-	PGViewCheckOption viewcheckoption;
-	PGInsertColumnOrder bynameorposition;
-	PGLoadInstallType loadinstalltype;
-	PGTransactionStmtType transactiontype;
-}
-/* Line 193 of yacc.c.  */
-#line 1388 "third_party/libpg_query/grammar/grammar_out.cpp"
-	YYSTYPE;
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-/* Copy the second part of user declarations.  */
-
-
-/* Line 216 of yacc.c.  */
-#line 1413 "third_party/libpg_query/grammar/grammar_out.cpp"
-
-#ifdef short
-# undef short
-#endif
-
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
-
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
-#else
-typedef short int yytype_int8;
-#endif
-
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short int yytype_uint16;
-#endif
-
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short int yytype_int16;
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-#  define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-#  define YYSIZE_T size_t
-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# else
-#  define YYSIZE_T unsigned int
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-#  if ENABLE_NLS
-#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
-#  endif
-# endif
-# ifndef YY_
-#  define YY_(msgid) msgid
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E.  */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
-#else
-# define YYUSE(e) /* empty */
-#endif
-
-/* Identity function, used to suppress warnings about constant conditions.  */
-#ifndef lint
-# define YYID(n) (n)
-#else
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static int
-YYID (int i)
-#else
-static int
-YYID (i)
-    int i;
-#endif
-{
-  return i;
-}
-#endif
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   elif defined __BUILTIN_VA_ARG_INCR
-#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#   elif defined _AIX
-#    define YYSTACK_ALLOC __alloca
-#   elif defined _MSC_VER
-#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#    define alloca _alloca
-#   else
-#    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#     ifndef _STDLIB_H
-#      define _STDLIB_H 1
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning.  */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-    /* The OS might guarantee only one guard page at the bottom of the stack,
-       and a page size can be as small as 4096 bytes.  So we cannot safely
-       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-       to allow for a few compiler-allocated temporary stack slots.  */
-#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#  endif
-# else
-#  define YYSTACK_ALLOC YYMALLOC
-#  define YYSTACK_FREE YYFREE
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#  endif
-#  if (defined __cplusplus && ! defined _STDLIB_H \
-       && ! ((defined YYMALLOC || defined malloc) \
-	     && (defined YYFREE || defined free)))
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef _STDLIB_H
-#    define _STDLIB_H 1
-#   endif
-#  endif
-#  ifndef YYMALLOC
-#   define YYMALLOC malloc
-#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-#  ifndef YYFREE
-#   define YYFREE free
-#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
-     && (! defined __cplusplus \
-	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
-	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  yytype_int16 yyss;
-  YYSTYPE yyvs;
-    YYLTYPE yyls;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
-      + 2 * YYSTACK_GAP_MAXIMUM)
-
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (YYID (0))
-#  endif
-# endif
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack)					\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack, Stack, yysize);				\
-	Stack = &yyptr->Stack;						\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (YYID (0))
-
-#endif
-
-/* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  874
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   74510
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  529
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  483
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  2176
-/* YYNRULES -- Number of states.  */
-#define YYNSTATES  3617
-
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  2
-#define YYMAXUTOK   761
-
-#define YYTRANSLATE(YYX)						\
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const yytype_uint16 yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,   526,   525,   513,     2,     2,
-     518,   519,   511,   509,   522,   510,   520,   512,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   523,   521,
-     505,   507,   506,   524,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   516,     2,   517,   514,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   527,     2,   528,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,   502,   503,   504,
-     508,   515
-};
-
-#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-   YYRHS.  */
-static const yytype_uint16 yyprhs[] =
-{
-       0,     0,     3,     5,     9,    11,    13,    15,    17,    19,
-      21,    23,    25,    27,    29,    31,    33,    35,    37,    39,
-      41,    43,    45,    47,    49,    51,    53,    55,    57,    59,
-      61,    63,    65,    67,    69,    71,    73,    75,    77,    79,
-      81,    83,    85,    87,    89,    91,    93,    94,    99,   106,
-     111,   118,   123,   130,   135,   142,   144,   147,   151,   154,
-     156,   160,   163,   167,   169,   173,   176,   182,   186,   193,
-     198,   205,   212,   219,   225,   231,   238,   248,   253,   259,
-     267,   274,   279,   288,   293,   296,   301,   305,   312,   317,
-     320,   323,   326,   329,   331,   334,   335,   337,   340,   343,
-     346,   348,   352,   357,   360,   362,   363,   366,   370,   373,
-     377,   379,   382,   384,   386,   388,   390,   392,   394,   396,
-     399,   402,   404,   406,   408,   410,   412,   419,   426,   435,
-     442,   451,   458,   467,   474,   483,   492,   503,   512,   523,
-     525,   526,   536,   538,   543,   548,   556,   559,   561,   565,
-     568,   571,   572,   577,   581,   582,   584,   585,   588,   592,
-     598,   601,   604,   605,   614,   620,   621,   627,   633,   641,
-     644,   645,   647,   649,   651,   655,   658,   659,   661,   662,
-     664,   668,   670,   674,   676,   679,   681,   685,   688,   695,
-     704,   710,   712,   713,   715,   719,   722,   727,   733,   739,
-     748,   756,   758,   759,   768,   780,   791,   792,   794,   795,
-     797,   799,   800,   803,   808,   812,   822,   835,   837,   841,
-     843,   847,   851,   852,   857,   864,   866,   869,   871,   873,
-     874,   876,   879,   882,   884,   887,   890,   892,   895,   899,
-     902,   905,   908,   911,   915,   919,   923,   925,   929,   931,
-     932,   934,   937,   940,   946,   954,   955,   958,   961,   965,
-     969,   972,   975,   978,   980,   982,   983,   986,   989,   990,
-     993,  1003,  1016,  1028,  1029,  1032,  1034,  1036,  1038,  1040,
-    1042,  1044,  1048,  1049,  1051,  1054,  1056,  1058,  1061,  1064,
-    1068,  1070,  1072,  1075,  1078,  1080,  1083,  1087,  1093,  1097,
-    1100,  1106,  1108,  1110,  1112,  1113,  1119,  1127,  1133,  1136,
-    1140,  1142,  1144,  1147,  1150,  1151,  1155,  1160,  1165,  1166,
-    1170,  1173,  1174,  1178,  1180,  1182,  1184,  1186,  1188,  1190,
-    1192,  1194,  1196,  1198,  1202,  1206,  1208,  1211,  1214,  1217,
-    1220,  1223,  1226,  1227,  1231,  1235,  1239,  1240,  1242,  1245,
-    1247,  1250,  1253,  1256,  1259,  1263,  1268,  1270,  1274,  1276,
-    1278,  1280,  1282,  1286,  1288,  1291,  1292,  1294,  1297,  1298,
-    1300,  1304,  1305,  1308,  1309,  1313,  1317,  1319,  1325,  1329,
-    1331,  1335,  1337,  1340,  1342,  1347,  1353,  1359,  1366,  1370,
-    1378,  1383,  1395,  1397,  1401,  1404,  1407,  1410,  1411,  1415,
-    1417,  1419,  1422,  1425,  1428,  1431,  1433,  1434,  1436,  1439,
-    1446,  1451,  1458,  1463,  1470,  1479,  1481,  1483,  1485,  1487,
-    1490,  1492,  1495,  1497,  1500,  1502,  1504,  1506,  1508,  1512,
-    1516,  1520,  1524,  1526,  1529,  1532,  1534,  1538,  1540,  1542,
-    1544,  1548,  1550,  1552,  1553,  1555,  1557,  1559,  1565,  1574,
-    1582,  1588,  1597,  1605,  1610,  1615,  1617,  1621,  1623,  1625,
-    1629,  1631,  1635,  1637,  1639,  1642,  1646,  1655,  1667,  1677,
-    1685,  1686,  1690,  1694,  1696,  1698,  1702,  1703,  1705,  1709,
-    1711,  1712,  1714,  1715,  1717,  1718,  1720,  1724,  1726,  1728,
-    1730,  1732,  1736,  1738,  1740,  1741,  1744,  1747,  1748,  1751,
-    1752,  1754,  1755,  1757,  1759,  1761,  1765,  1769,  1771,  1773,
-    1777,  1781,  1785,  1789,  1793,  1797,  1802,  1806,  1809,  1811,
-    1813,  1815,  1817,  1821,  1823,  1825,  1829,  1831,  1833,  1837,
-    1841,  1845,  1847,  1850,  1855,  1860,  1863,  1867,  1873,  1879,
-    1881,  1883,  1887,  1888,  1900,  1912,  1923,  1936,  1938,  1941,
-    1947,  1952,  1957,  1962,  1967,  1975,  1981,  1986,  1994,  2001,
-    2011,  2021,  2026,  2028,  2030,  2032,  2034,  2036,  2038,  2040,
-    2046,  2048,  2050,  2054,  2056,  2059,  2062,  2065,  2069,  2071,
-    2075,  2083,  2085,  2088,  2089,  2092,  2093,  2097,  2101,  2106,
-    2111,  2116,  2121,  2125,  2128,  2130,  2132,  2133,  2135,  2137,
-    2138,  2141,  2143,  2149,  2151,  2152,  2155,  2158,  2159,  2161,
-    2162,  2166,  2172,  2174,  2178,  2183,  2187,  2189,  2191,  2192,
-    2195,  2198,  2199,  2202,  2205,  2207,  2209,  2211,  2212,  2215,
-    2220,  2226,  2231,  2234,  2238,  2240,  2242,  2244,  2247,  2250,
-    2252,  2255,  2259,  2260,  2262,  2263,  2269,  2271,  2276,  2283,
-    2286,  2288,  2289,  2294,  2295,  2297,  2299,  2302,  2305,  2308,
-    2310,  2312,  2315,  2318,  2320,  2322,  2324,  2326,  2328,  2330,
-    2334,  2338,  2339,  2341,  2345,  2347,  2350,  2352,  2354,  2356,
-    2358,  2360,  2363,  2368,  2373,  2379,  2381,  2383,  2386,  2387,
-    2390,  2391,  2393,  2397,  2399,  2400,  2402,  2405,  2409,  2412,
-    2417,  2420,  2424,  2427,  2428,  2430,  2433,  2434,  2439,  2445,
-    2447,  2450,  2453,  2454,  2456,  2460,  2462,  2465,  2468,  2472,
-    2476,  2480,  2484,  2488,  2492,  2496,  2500,  2504,  2506,  2511,
-    2516,  2526,  2536,  2540,  2541,  2544,  2547,  2548,  2554,  2558,
-    2560,  2562,  2566,  2572,  2576,  2578,  2581,  2583,  2587,  2593,
-    2595,  2598,  2602,  2607,  2613,  2618,  2624,  2629,  2636,  2642,
-    2647,  2653,  2659,  2665,  2668,  2673,  2675,  2677,  2678,  2680,
-    2685,  2691,  2696,  2697,  2700,  2703,  2706,  2708,  2710,  2712,
-    2714,  2715,  2720,  2723,  2725,  2728,  2731,  2736,  2739,  2746,
-    2749,  2751,  2755,  2760,  2761,  2764,  2765,  2768,  2769,  2771,
-    2775,  2779,  2782,  2783,  2786,  2791,  2793,  2795,  2797,  2798,
-    2801,  2805,  2811,  2818,  2821,  2825,  2827,  2833,  2839,  2845,
-    2849,  2853,  2857,  2862,  2863,  2865,  2867,  2869,  2871,  2873,
-    2876,  2881,  2883,  2885,  2887,  2889,  2892,  2896,  2897,  2899,
-    2901,  2903,  2905,  2907,  2910,  2913,  2916,  2919,  2922,  2924,
-    2928,  2929,  2931,  2933,  2935,  2937,  2943,  2946,  2948,  2950,
-    2952,  2954,  2959,  2961,  2964,  2967,  2969,  2973,  2977,  2980,
-    2982,  2983,  2989,  2992,  2998,  3001,  3003,  3007,  3011,  3012,
-    3014,  3016,  3018,  3020,  3022,  3024,  3026,  3028,  3030,  3032,
-    3034,  3036,  3038,  3040,  3042,  3044,  3046,  3048,  3050,  3052,
-    3054,  3056,  3058,  3060,  3062,  3064,  3066,  3068,  3070,  3072,
-    3074,  3076,  3078,  3080,  3082,  3084,  3086,  3088,  3090,  3094,
-    3098,  3102,  3106,  3110,  3114,  3118,  3119,  3121,  3125,  3129,
-    3135,  3138,  3141,  3145,  3149,  3153,  3157,  3161,  3165,  3169,
-    3173,  3177,  3181,  3185,  3189,  3193,  3197,  3201,  3204,  3207,
-    3211,  3215,  3218,  3221,  3225,  3229,  3235,  3240,  3247,  3251,
-    3257,  3262,  3269,  3274,  3281,  3287,  3295,  3299,  3302,  3307,
-    3311,  3314,  3318,  3322,  3326,  3330,  3335,  3339,  3344,  3348,
-    3353,  3359,  3366,  3373,  3381,  3388,  3396,  3403,  3411,  3415,
-    3420,  3425,  3432,  3434,  3440,  3445,  3450,  3457,  3459,  3463,
-    3466,  3469,  3473,  3477,  3481,  3485,  3489,  3493,  3497,  3501,
-    3505,  3509,  3513,  3517,  3521,  3525,  3529,  3532,  3535,  3541,
-    3548,  3555,  3563,  3565,  3568,  3570,  3572,  3574,  3577,  3580,
-    3585,  3589,  3591,  3593,  3595,  3597,  3600,  3602,  3604,  3606,
-    3608,  3610,  3612,  3614,  3617,  3622,  3625,  3629,  3633,  3638,
-    3642,  3648,  3655,  3663,  3673,  3681,  3689,  3695,  3697,  3699,
-    3701,  3707,  3714,  3721,  3726,  3731,  3736,  3741,  3748,  3754,
-    3760,  3766,  3771,  3778,  3783,  3785,  3793,  3803,  3809,  3810,
-    3816,  3821,  3822,  3824,  3825,  3828,  3829,  3831,  3835,  3839,
-    3842,  3845,  3846,  3853,  3855,  3856,  3860,  3861,  3865,  3869,
-    3873,  3874,  3876,  3881,  3884,  3887,  3890,  3893,  3896,  3900,
-    3903,  3906,  3910,  3911,  3916,  3920,  3922,  3928,  3932,  3934,
-    3938,  3940,  3943,  3947,  3949,  3953,  3955,  3958,  3960,  3961,
-    3963,  3965,  3967,  3969,  3971,  3973,  3975,  3977,  3979,  3981,
-    3983,  3985,  3987,  3989,  3991,  3993,  3995,  3997,  3999,  4001,
-    4006,  4008,  4013,  4015,  4020,  4022,  4025,  4027,  4030,  4032,
-    4035,  4037,  4041,  4043,  4047,  4049,  4052,  4054,  4058,  4060,
-    4063,  4065,  4066,  4068,  4072,  4074,  4078,  4082,  4084,  4088,
-    4092,  4093,  4095,  4097,  4099,  4101,  4103,  4105,  4107,  4109,
-    4111,  4113,  4115,  4117,  4119,  4121,  4123,  4128,  4132,  4135,
-    4139,  4140,  4144,  4148,  4151,  4154,  4156,  4157,  4160,  4163,
-    4167,  4170,  4172,  4174,  4178,  4180,  4182,  4188,  4190,  4193,
-    4198,  4201,  4202,  4204,  4205,  4207,  4211,  4213,  4215,  4218,
-    4222,  4228,  4236,  4244,  4246,  4247,  4248,  4251,  4252,  4255,
-    4259,  4263,  4267,  4273,  4281,  4289,  4290,  4293,  4295,  4296,
-    4298,  4299,  4301,  4305,  4307,  4310,  4314,  4317,  4319,  4323,
-    4328,  4331,  4333,  4337,  4339,  4343,  4345,  4348,  4350,  4351,
-    4355,  4357,  4361,  4363,  4366,  4371,  4374,  4375,  4379,  4381,
-    4385,  4387,  4390,  4395,  4398,  4399,  4401,  4405,  4407,  4411,
-    4413,  4416,  4418,  4422,  4424,  4426,  4429,  4431,  4433,  4436,
-    4438,  4440,  4443,  4451,  4454,  4460,  4464,  4468,  4470,  4472,
-    4474,  4476,  4478,  4480,  4482,  4484,  4486,  4488,  4490,  4492,
-    4494,  4496,  4499,  4502,  4506,  4510,  4511,  4513,  4515,  4517,
-    4523,  4527,  4528,  4530,  4532,  4534,  4536,  4538,  4540,  4545,
-    4553,  4560,  4563,  4564,  4566,  4568,  4570,  4572,  4586,  4603,
-    4605,  4608,  4609,  4611,  4612,  4614,  4615,  4618,  4619,  4621,
-    4622,  4629,  4638,  4645,  4654,  4661,  4670,  4674,  4677,  4679,
-    4680,  4687,  4694,  4696,  4698,  4700,  4702,  4704,  4706,  4709,
-    4711,  4713,  4715,  4717,  4719,  4724,  4731,  4735,  4738,  4743,
-    4747,  4753,  4755,  4756,  4758,  4760,  4761,  4763,  4765,  4767,
-    4769,  4771,  4773,  4775,  4777,  4779,  4781,  4783,  4785,  4787,
-    4789,  4791,  4793,  4795,  4797,  4799,  4801,  4803,  4805,  4807,
-    4809,  4811,  4813,  4815,  4817,  4819,  4821,  4823,  4825,  4827,
-    4829,  4831,  4833,  4835,  4839,  4841,  4843,  4845,  4847,  4849,
-    4851,  4854,  4856,  4858,  4861,  4865,  4869,  4873,  4877,  4879,
-    4883,  4887,  4890,  4894,  4898,  4900,  4902,  4904,  4908,  4914,
-    4916,  4918,  4920,  4922,  4926,  4929,  4934,  4941,  4948,  4949,
-    4951,  4953,  4955,  4956,  4959,  4962,  4967,  4974,  4980,  4985,
-    4992,  4994,  4996,  4998,  5000,  5002,  5004,  5005,  5007,  5011,
-    5013,  5014,  5022,  5026,  5028,  5031,  5035,  5038,  5039,  5042,
-    5043,  5046,  5051,  5057,  5066,  5069,  5073,  5079,  5081,  5082,
-    5085,  5086,  5089,  5093,  5097,  5101,  5105,  5107,  5109,  5111,
-    5114,  5118,  5121,  5124,  5127,  5130,  5134,  5139,  5143,  5145,
-    5147,  5149,  5151,  5153,  5155,  5156,  5158,  5162,  5165,  5175,
-    5188,  5200,  5213,  5228,  5232,  5237,  5242,  5243,  5251,  5262,
-    5272,  5275,  5279,  5280,  5285,  5287,  5289,  5291,  5293,  5295,
-    5297,  5299,  5301,  5303,  5305,  5307,  5309,  5311,  5313,  5315,
-    5317,  5319,  5321,  5323,  5325,  5327,  5329,  5331,  5333,  5335,
-    5337,  5339,  5341,  5343,  5345,  5347,  5349,  5351,  5353,  5355,
-    5357,  5359,  5361,  5363,  5365,  5367,  5369,  5371,  5373,  5375,
-    5377,  5379,  5381,  5383,  5385,  5387,  5389,  5391,  5393,  5395,
-    5397,  5399,  5401,  5403,  5405,  5407,  5409,  5411,  5413,  5415,
-    5417,  5419,  5421,  5423,  5425,  5427,  5429,  5431,  5433,  5435,
-    5437,  5439,  5441,  5443,  5445,  5447,  5449,  5451,  5453,  5455,
-    5457,  5459,  5461,  5463,  5465,  5467,  5469,  5471,  5473,  5475,
-    5477,  5479,  5481,  5483,  5485,  5487,  5489,  5491,  5493,  5495,
-    5497,  5499,  5501,  5503,  5505,  5507,  5509,  5511,  5513,  5515,
-    5517,  5519,  5521,  5523,  5525,  5527,  5529,  5531,  5533,  5535,
-    5537,  5539,  5541,  5543,  5545,  5547,  5549,  5551,  5553,  5555,
-    5557,  5559,  5561,  5563,  5565,  5567,  5569,  5571,  5573,  5575,
-    5577,  5579,  5581,  5583,  5585,  5587,  5589,  5591,  5593,  5595,
-    5597,  5599,  5601,  5603,  5605,  5607,  5609,  5611,  5613,  5615,
-    5617,  5619,  5621,  5623,  5625,  5627,  5629,  5631,  5633,  5635,
-    5637,  5639,  5641,  5643,  5645,  5647,  5649,  5651,  5653,  5655,
-    5657,  5659,  5661,  5663,  5665,  5667,  5669,  5671,  5673,  5675,
-    5677,  5679,  5681,  5683,  5685,  5687,  5689,  5691,  5693,  5695,
-    5697,  5699,  5701,  5703,  5705,  5707,  5709,  5711,  5713,  5715,
-    5717,  5719,  5721,  5723,  5725,  5727,  5729,  5731,  5733,  5735,
-    5737,  5739,  5741,  5743,  5745,  5747,  5749,  5751,  5753,  5755,
-    5757,  5759,  5761,  5763,  5765,  5767,  5769,  5771,  5773,  5775,
-    5777,  5779,  5781,  5783,  5785,  5787,  5789,  5791,  5793,  5795,
-    5797,  5799,  5801,  5803,  5805,  5807,  5809,  5811,  5813,  5815,
-    5817,  5819,  5821,  5823,  5825,  5827,  5829,  5831,  5833,  5835,
-    5837,  5839,  5841,  5843,  5845,  5847,  5849,  5851,  5853,  5855,
-    5857,  5859,  5861,  5863,  5865,  5867,  5869,  5871,  5873,  5875,
-    5877,  5879,  5881,  5883,  5885,  5887,  5889,  5891,  5893,  5895,
-    5897,  5899,  5901,  5903,  5905,  5907,  5909,  5911,  5913,  5915,
-    5917,  5919,  5921,  5923,  5925,  5927,  5929,  5931,  5933,  5935,
-    5937,  5939,  5941,  5943,  5945,  5947,  5949,  5951,  5953,  5955,
-    5957,  5959,  5961,  5963,  5965,  5967,  5969,  5971,  5973,  5975,
-    5977,  5979,  5981,  5983,  5985,  5987,  5989,  5991,  5993,  5995,
-    5997,  5999,  6001,  6003,  6005,  6007,  6009,  6011,  6013,  6015,
-    6017,  6019,  6021,  6023,  6025,  6027,  6029,  6031,  6033,  6035,
-    6037,  6039,  6041,  6043,  6045,  6047,  6049,  6051,  6053,  6055,
-    6057,  6059,  6061,  6063,  6065,  6067,  6069,  6071,  6073,  6075,
-    6077,  6079,  6081,  6083,  6085,  6087,  6089,  6091,  6093,  6095,
-    6097,  6099,  6101,  6103,  6105,  6107,  6109,  6111,  6113,  6115,
-    6117,  6119,  6121,  6123,  6125,  6127,  6129,  6131,  6133,  6135,
-    6137,  6139,  6141,  6143,  6145,  6147,  6149,  6151,  6153,  6155,
-    6157,  6159,  6161,  6163,  6165,  6167,  6169,  6171,  6173,  6175,
-    6177,  6179,  6181,  6183,  6185,  6187,  6189,  6191,  6193,  6195,
-    6197,  6199,  6201,  6203,  6205,  6207,  6209,  6211,  6213,  6215,
-    6217,  6219,  6221,  6223,  6225,  6227,  6229,  6231,  6233,  6235,
-    6237,  6239,  6241,  6243,  6245,  6247,  6249,  6251,  6253,  6255,
-    6257,  6259,  6261,  6263,  6265,  6267,  6269,  6271,  6273,  6275,
-    6277,  6279,  6281,  6283,  6285,  6287,  6289,  6291,  6293,  6295,
-    6297,  6299,  6301,  6303,  6305,  6307,  6309,  6311,  6313,  6315,
-    6317,  6319,  6321,  6323,  6325,  6327,  6329,  6331,  6333,  6335,
-    6337,  6339,  6341,  6343,  6345,  6347,  6349,  6351,  6353,  6355,
-    6357,  6359,  6361,  6363,  6365,  6367,  6369,  6371,  6373,  6375,
-    6377,  6379,  6381,  6383,  6385,  6387,  6389,  6391,  6393,  6395,
-    6397,  6399,  6401,  6403,  6405,  6407,  6409,  6411,  6413,  6415,
-    6417,  6419,  6421,  6423,  6425,  6427,  6429,  6431,  6433,  6435,
-    6437,  6439,  6441,  6443,  6445,  6447,  6449,  6451,  6453,  6455,
-    6457,  6459,  6461,  6463,  6465,  6467,  6469,  6471,  6473,  6475,
-    6477,  6479,  6481,  6483,  6485,  6487,  6489,  6491,  6493,  6495,
-    6497,  6499,  6501,  6503,  6505,  6507,  6509,  6511,  6513,  6515,
-    6517,  6519,  6521,  6523,  6525,  6527,  6529
-};
-
-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
-static const yytype_int16 yyrhs[] =
-{
-     530,     0,    -1,   531,    -1,   531,   521,   532,    -1,   532,
-      -1,   948,    -1,   591,    -1,   533,    -1,   986,    -1,   987,
-      -1,   999,    -1,   949,    -1,   951,    -1,   668,    -1,  1002,
-      -1,   658,    -1,   938,    -1,   582,    -1,   580,    -1,   604,
-      -1,   576,    -1,   544,    -1,   982,    -1,   988,    -1,   598,
-      -1,   652,    -1,   587,    -1,   956,    -1,   954,    -1,   955,
-      -1,   941,    -1,   555,    -1,   973,    -1,   579,    -1,   935,
-      -1,   553,    -1,   686,    -1,   600,    -1,   586,    -1,   667,
-      -1,   603,    -1,   977,    -1,   991,    -1,   967,    -1,   994,
-      -1,  1000,    -1,    -1,    32,   419,   775,   541,    -1,    32,
-     419,   192,   152,   775,   541,    -1,    32,   203,   545,   541,
-      -1,    32,   203,   192,   152,   545,   541,    -1,    32,   384,
-     545,   541,    -1,    32,   384,   192,   152,   545,   541,    -1,
-      32,   470,   545,   541,    -1,    32,   470,   192,   152,   545,
-     541,    -1,   536,    -1,   534,   536,    -1,   389,   117,   824,
-      -1,   137,   117,    -1,   359,    -1,   359,   593,   594,    -1,
-     389,   595,    -1,   389,   176,   651,    -1,   540,    -1,   537,
-     522,   540,    -1,    26,   631,    -1,    26,   192,   275,   152,
-     631,    -1,    26,    82,   631,    -1,    26,    82,   192,   275,
-     152,   631,    -1,    32,   554,   546,   535,    -1,    32,   554,
-     546,   137,   275,   280,    -1,    32,   554,   546,   389,   275,
-     280,    -1,    32,   554,   546,   389,   405,   597,    -1,    32,
-     554,   546,   389,   619,    -1,    32,   554,   546,   357,   619,
-      -1,    32,   554,   546,   389,   408,   546,    -1,    32,   554,
-     546,    26,   176,   651,    40,   191,   607,    -1,    32,   554,
-     546,   534,    -1,    32,   554,   546,   137,   191,    -1,    32,
-     554,   546,   137,   191,   192,   152,    -1,   137,   554,   192,
-     152,   546,   656,    -1,   137,   554,   546,   656,    -1,    32,
-     554,   546,   543,   442,   787,   784,   539,    -1,    32,   554,
-     546,   542,    -1,    26,   621,    -1,    32,    93,   923,   605,
-      -1,   460,    93,   923,    -1,   137,    93,   192,   152,   923,
-     656,    -1,   137,    93,   923,   656,    -1,   389,   245,    -1,
-     389,   451,    -1,   389,   619,    -1,   357,   619,    -1,   542,
-      -1,   457,   824,    -1,    -1,   615,    -1,   389,   615,    -1,
-      26,   615,    -1,   137,   629,    -1,   538,    -1,   541,   522,
-     538,    -1,   294,   518,   537,   519,    -1,   389,   107,    -1,
-     389,    -1,    -1,   111,   923,    -1,   111,   326,   923,    -1,
-     111,    30,    -1,   111,   326,    30,    -1,   547,    -1,   546,
-     549,    -1,     3,    -1,  1005,    -1,  1006,    -1,   546,    -1,
-       5,    -1,     5,    -1,   550,    -1,   549,   550,    -1,   520,
-     551,    -1,   552,    -1,     3,    -1,  1009,    -1,  1005,    -1,
-    1011,    -1,    32,   373,   923,   353,   431,   923,    -1,    32,
-     419,   775,   353,   431,   923,    -1,    32,   419,   192,   152,
-     775,   353,   431,   923,    -1,    32,   384,   545,   353,   431,
-     923,    -1,    32,   384,   192,   152,   545,   353,   431,   923,
-      -1,    32,   470,   545,   353,   431,   923,    -1,    32,   470,
-     192,   152,   545,   353,   431,   923,    -1,    32,   203,   545,
-     353,   431,   923,    -1,    32,   203,   192,   152,   545,   353,
-     431,   923,    -1,    32,   419,   775,   353,   554,   923,   431,
-     923,    -1,    32,   419,   192,   152,   775,   353,   554,   923,
-     431,   923,    -1,    32,   419,   775,   353,    93,   923,   431,
-     923,    -1,    32,   419,   192,   152,   775,   353,    93,   923,
-     431,   923,    -1,    82,    -1,    -1,   560,   213,   563,   220,
-     557,   558,   556,   564,   566,    -1,   686,    -1,   304,   567,
-     462,   686,    -1,   518,   571,   519,   686,    -1,   518,   571,
-     519,   304,   567,   462,   686,    -1,   117,   463,    -1,   545,
-      -1,   545,    40,   546,    -1,    59,   266,    -1,    59,   321,
-      -1,    -1,   518,   574,   519,   781,    -1,   290,    93,   923,
-      -1,    -1,   698,    -1,    -1,   546,   897,    -1,   575,   507,
-     824,    -1,   518,   568,   519,   507,   824,    -1,   295,   355,
-      -1,   295,   193,    -1,    -1,   290,    91,   559,   133,   454,
-     389,   573,   781,    -1,   290,    91,   559,   133,   276,    -1,
-      -1,   546,   569,   570,   714,   715,    -1,   836,   569,   570,
-     714,   715,    -1,   518,   824,   519,   569,   570,   714,   715,
-      -1,   361,   903,    -1,    -1,   456,    -1,   418,    -1,   575,
-      -1,   568,   522,   575,    -1,    80,   930,    -1,    -1,   930,
-      -1,    -1,   561,    -1,   571,   522,   561,    -1,   562,    -1,
-     572,   522,   562,    -1,   572,    -1,   572,   522,    -1,   565,
-      -1,   574,   522,   565,    -1,   546,   897,    -1,   100,   442,
-     545,    40,   144,   687,    -1,   100,   442,   545,    40,   144,
-     518,   577,   519,    -1,   100,   442,   545,    40,   788,    -1,
-     578,    -1,    -1,   548,    -1,   578,   522,   548,    -1,   323,
-     546,    -1,   323,   546,   507,   972,    -1,   323,   546,   518,
-     875,   519,    -1,   100,   650,   384,   545,   581,    -1,   100,
-     650,   384,   192,   275,   152,   545,   581,    -1,   100,   295,
-     355,   650,   384,   545,   581,    -1,   592,    -1,    -1,   100,
-     584,   380,   583,   585,   518,   685,   519,    -1,   100,   584,
-     380,   192,   275,   152,   583,   585,   518,   685,   519,    -1,
-     100,   295,   355,   584,   380,   583,   585,   518,   685,   519,
-      -1,    -1,   546,    -1,    -1,   425,    -1,   314,    -1,    -1,
-     199,     3,    -1,   560,   454,   157,   639,    -1,   151,   923,
-     590,    -1,   100,   650,   419,  1004,    40,   151,   923,   590,
-    1003,    -1,   100,   650,   419,   192,   275,   152,  1004,    40,
-     151,   923,   590,  1003,    -1,   824,    -1,   933,    13,   824,
-      -1,   588,    -1,   589,   522,   588,    -1,   518,   589,   519,
-      -1,    -1,    32,   384,   545,   592,    -1,    32,   384,   192,
-     152,   545,   592,    -1,   595,    -1,   592,   595,    -1,   480,
-      -1,   504,    -1,    -1,     4,    -1,   509,     4,    -1,   510,
-       4,    -1,   597,    -1,    40,   791,    -1,    60,   594,    -1,
-     106,    -1,   273,   106,    -1,   202,   596,   594,    -1,   251,
-     594,    -1,   261,   594,    -1,   273,   251,    -1,   273,   261,
-      -1,   305,    59,   930,    -1,   384,   266,   930,    -1,   403,
-     593,   594,    -1,   359,    -1,   359,   593,   594,    -1,    59,
-      -1,    -1,   926,    -1,   509,   926,    -1,   510,   926,    -1,
-     137,   584,   380,   546,   599,    -1,   137,   584,   380,   192,
-     152,   546,   599,    -1,    -1,   172,     3,    -1,    22,   601,
-      -1,    52,   601,   602,    -1,   403,   601,   602,    -1,    86,
-     601,    -1,   143,   601,    -1,   366,   601,    -1,   483,    -1,
-     433,    -1,    -1,   341,   291,    -1,   341,   485,    -1,    -1,
-     455,   545,    -1,   100,   650,   419,   545,   518,   637,   519,
-     626,   618,    -1,   100,   650,   419,   192,   275,   152,   545,
-     518,   637,   519,   626,   618,    -1,   100,   295,   355,   650,
-     419,   545,   518,   637,   519,   626,   618,    -1,    -1,   605,
-     630,    -1,   645,    -1,  1011,    -1,   867,    -1,   594,    -1,
-     548,    -1,   274,    -1,   518,   592,   519,    -1,    -1,   548,
-      -1,   273,    25,    -1,   360,    -1,    63,    -1,   389,   280,
-      -1,   389,   117,    -1,    93,   923,   611,    -1,   611,    -1,
-     625,    -1,    80,   930,    -1,   275,   280,    -1,   280,    -1,
-     448,   636,    -1,   329,   227,   636,    -1,    74,   518,   824,
-     519,   620,    -1,   457,    88,   923,    -1,   117,   825,    -1,
-     347,   545,   639,   648,   617,    -1,   472,    -1,   409,    -1,
-     612,    -1,    -1,   176,   651,    40,   191,   607,    -1,   176,
-     651,    40,   518,   824,   519,   613,    -1,    40,   518,   824,
-     519,   613,    -1,   629,   608,    -1,   290,   454,   609,    -1,
-     616,    -1,   641,    -1,   616,   641,    -1,   641,   616,    -1,
-      -1,   290,    86,   137,    -1,   290,    86,   122,   369,    -1,
-     290,    86,   328,   369,    -1,    -1,   518,   623,   519,    -1,
-     273,   205,    -1,    -1,    93,   923,   646,    -1,   646,    -1,
-      85,    -1,    94,    -1,   118,    -1,   191,    -1,   204,    -1,
-     405,    -1,   408,    -1,    30,    -1,   642,    -1,   623,   522,
-     642,    -1,   457,   203,   633,    -1,   119,    -1,   275,   119,
-      -1,   207,   120,    -1,   207,   195,    -1,   480,   619,    -1,
-     480,   288,    -1,   482,   288,    -1,    -1,   518,   632,   519,
-      -1,   628,   201,   622,    -1,   628,   149,   622,    -1,    -1,
-     552,    -1,   275,   119,    -1,   119,    -1,   207,   195,    -1,
-     207,   120,    -1,   275,   459,    -1,   273,   205,    -1,   546,
-     788,   640,    -1,   546,   787,   614,   640,    -1,   635,    -1,
-     632,   522,   635,    -1,   546,    -1,   631,    -1,   649,    -1,
-     621,    -1,   552,   507,   606,    -1,   552,    -1,   480,   627,
-      -1,    -1,   647,    -1,   647,   522,    -1,    -1,   546,    -1,
-     518,   643,   519,    -1,    -1,   640,   610,    -1,    -1,   290,
-     122,   609,    -1,   552,   507,   606,    -1,   552,    -1,   552,
-     520,   552,   507,   606,    -1,   552,   520,   552,    -1,   638,
-      -1,   643,   522,   638,    -1,   643,    -1,   643,   522,    -1,
-     788,    -1,   927,   931,   513,   442,    -1,   390,   927,   931,
-     513,   442,    -1,    74,   518,   824,   519,   605,    -1,   448,
-     518,   644,   519,   636,   605,    -1,   448,   624,   605,    -1,
-     329,   227,   518,   644,   519,   636,   605,    -1,   329,   227,
-     624,   605,    -1,   169,   227,   518,   644,   519,   347,   545,
-     639,   648,   617,   605,    -1,   634,    -1,   647,   522,   634,
-      -1,   249,   173,    -1,   249,   309,    -1,   249,   395,    -1,
-      -1,   237,   545,   628,    -1,   425,    -1,   423,    -1,   241,
-     425,    -1,   241,   423,    -1,   178,   425,    -1,   178,   423,
-      -1,   451,    -1,    -1,    33,    -1,    59,   117,    -1,   137,
-     653,   192,   152,   655,   656,    -1,   137,   653,   655,   656,
-      -1,   137,   654,   192,   152,   920,   656,    -1,   137,   654,
-     920,   656,    -1,   137,   657,   923,   290,   930,   656,    -1,
-     137,   657,   192,   152,   923,   290,   930,   656,    -1,   419,
-      -1,   384,    -1,   174,    -1,   246,    -1,   246,   419,    -1,
-     470,    -1,   250,   470,    -1,   203,    -1,   169,   419,    -1,
-      81,    -1,    97,    -1,   373,    -1,   405,    -1,   426,   377,
-     308,    -1,   426,   377,   129,    -1,   426,   377,   424,    -1,
-     426,   377,    90,    -1,   442,    -1,    24,   252,    -1,   146,
-     436,    -1,   156,    -1,   169,   107,   484,    -1,   335,    -1,
-     387,    -1,   930,    -1,   655,   522,   930,    -1,    63,    -1,
-     360,    -1,    -1,   320,    -1,   370,    -1,   436,    -1,   100,
-     650,   665,   545,   662,    -1,   100,   650,   665,   192,   275,
-     152,   545,   662,    -1,   100,   295,   355,   650,   665,   545,
-     662,    -1,   100,   650,   665,   545,   664,    -1,   100,   650,
-     665,   192,   275,   152,   545,   664,    -1,   100,   295,   355,
-     650,   665,   545,   664,    -1,   666,    40,   419,   688,    -1,
-     666,    40,   419,   687,    -1,   660,    -1,   661,   522,   660,
-      -1,   659,    -1,   661,    -1,   666,    40,   824,    -1,   663,
-      -1,   664,   522,   663,    -1,   174,    -1,   246,    -1,   518,
-     519,    -1,   518,   875,   519,    -1,   560,   454,   983,   389,
-     573,   754,   984,   566,    -1,    98,   681,   545,   639,   679,
-     670,   675,   684,   671,   593,   676,    -1,    98,   518,   686,
-     519,   431,   675,   684,   593,   676,    -1,    98,   172,   108,
-     546,   431,   546,   669,    -1,    -1,   518,   373,   519,    -1,
-     518,   107,   519,    -1,   172,    -1,   431,    -1,   673,   124,
-     548,    -1,    -1,   683,    -1,   672,   522,   683,    -1,   457,
-      -1,    -1,    40,    -1,    -1,   334,    -1,    -1,   680,    -1,
-     518,   685,   519,    -1,   964,    -1,   594,    -1,   831,    -1,
-     511,    -1,   518,   672,   519,    -1,   832,    -1,   833,    -1,
-      -1,   552,   677,    -1,   480,   288,    -1,    -1,   680,   682,
-      -1,    -1,    55,    -1,    -1,    55,    -1,   288,    -1,   171,
-      -1,   123,   674,   548,    -1,   280,   674,   548,    -1,   102,
-      -1,   187,    -1,   339,   674,   548,    -1,   145,   674,   548,
-      -1,   168,   339,   643,    -1,   168,   339,   511,    -1,   310,
-      59,   643,    -1,   310,    59,   511,    -1,   168,   275,   280,
-     643,    -1,   168,   280,   643,    -1,   141,   548,    -1,   964,
-      -1,   548,    -1,   406,    -1,   407,    -1,     3,   520,   546,
-      -1,     3,    -1,   678,    -1,   685,   522,   678,    -1,   688,
-      -1,   687,    -1,   518,   688,   519,    -1,   518,   687,   519,
-      -1,   518,   994,   519,    -1,   691,    -1,   689,   711,    -1,
-     689,   710,   745,   717,    -1,   689,   710,   716,   746,    -1,
-     698,   689,    -1,   698,   689,   711,    -1,   698,   689,   710,
-     745,   717,    -1,   698,   689,   710,   716,   746,    -1,   691,
-      -1,   687,    -1,   382,   708,   902,    -1,    -1,   382,   708,
-     902,   702,   754,   781,   734,   743,   843,   744,   722,    -1,
-     382,   707,   904,   702,   754,   781,   734,   743,   843,   744,
-     722,    -1,   172,   755,   690,   702,   781,   734,   743,   843,
-     744,   722,    -1,   172,   755,   382,   707,   904,   702,   781,
-     734,   743,   843,   744,   722,    -1,   753,    -1,   419,   775,
-      -1,   689,   447,   705,   706,   689,    -1,   689,   447,   705,
-     689,    -1,   689,   218,   705,   689,    -1,   689,   147,   705,
-     689,    -1,   693,   758,   457,   904,    -1,   693,   758,   457,
-     904,   181,    59,   922,    -1,   693,   758,   181,    59,   922,
-      -1,   693,   758,   290,   697,    -1,   693,   758,   290,   697,
-     181,    59,   922,    -1,   693,   758,   290,   697,   457,   904,
-      -1,   693,   758,   290,   697,   457,   904,   181,    59,   922,
-      -1,   694,   758,   290,   904,   220,   266,   923,   692,   922,
-      -1,   694,   758,   290,   904,    -1,   462,    -1,   463,    -1,
-     315,    -1,   317,    -1,   452,    -1,   316,    -1,   825,    -1,
-     825,   199,   518,   688,   519,    -1,   761,    -1,   695,    -1,
-     696,   522,   695,    -1,   696,    -1,   696,   522,    -1,   480,
-     699,    -1,   504,   699,    -1,   480,   345,   699,    -1,   700,
-      -1,   699,   522,   700,    -1,   923,   932,    40,   701,   518,
-     937,   519,    -1,   250,    -1,   275,   250,    -1,    -1,   220,
-     703,    -1,    -1,   425,   704,   545,    -1,   423,   704,   545,
-      -1,   241,   425,   704,   545,    -1,   241,   423,   704,   545,
-      -1,   178,   425,   704,   545,    -1,   178,   423,   704,   545,
-      -1,   451,   704,   545,    -1,   419,   545,    -1,   545,    -1,
-     419,    -1,    -1,    30,    -1,   132,    -1,    -1,    59,   266,
-      -1,   132,    -1,   132,   290,   518,   873,   519,    -1,    30,
-      -1,    -1,   193,   282,    -1,   358,   282,    -1,    -1,   711,
-      -1,    -1,   296,    59,   712,    -1,   296,    59,    30,   714,
-     715,    -1,   713,    -1,   712,   522,   713,    -1,   824,   457,
-     867,   715,    -1,   824,   714,   715,    -1,    41,    -1,   126,
-      -1,    -1,   503,   164,    -1,   503,   231,    -1,    -1,   718,
-     719,    -1,   719,   718,    -1,   718,    -1,   719,    -1,   716,
-      -1,    -1,   238,   728,    -1,   238,   728,   522,   729,    -1,
-     162,   733,   730,   732,   291,    -1,   162,   733,   732,   291,
-      -1,   287,   729,    -1,   287,   730,   732,    -1,     4,    -1,
-       9,    -1,   829,    -1,   720,   513,    -1,   720,   313,    -1,
-     720,    -1,   720,   369,    -1,   457,   371,   724,    -1,    -1,
-     546,    -1,    -1,   723,   518,   721,   519,   727,    -1,   721,
-      -1,   721,   518,   546,   519,    -1,   721,   518,   546,   522,
-       9,   519,    -1,   421,   724,    -1,   725,    -1,    -1,   354,
-     518,     9,   519,    -1,    -1,   824,    -1,    30,    -1,   824,
-     513,    -1,     4,   313,    -1,     9,   313,    -1,   824,    -1,
-     826,    -1,   509,   731,    -1,   510,   731,    -1,   926,    -1,
-       4,    -1,   368,    -1,   369,    -1,   164,    -1,   272,    -1,
-     181,    59,   736,    -1,   181,    59,    30,    -1,    -1,   737,
-      -1,   735,   522,   737,    -1,   735,    -1,   735,   522,    -1,
-     824,    -1,   738,    -1,   740,    -1,   739,    -1,   741,    -1,
-     518,   519,    -1,   367,   518,   873,   519,    -1,   103,   518,
-     873,   519,    -1,   182,   391,   518,   736,   519,    -1,   182,
-      -1,   183,    -1,   186,   824,    -1,    -1,   336,   824,    -1,
-      -1,   747,    -1,   167,   341,   291,    -1,   745,    -1,    -1,
-     748,    -1,   747,   748,    -1,   749,   750,   751,    -1,   167,
-     454,    -1,   167,   273,   227,   454,    -1,   167,   392,    -1,
-     167,   227,   392,    -1,   285,   919,    -1,    -1,   279,    -1,
-     396,   244,    -1,    -1,   463,   518,   873,   519,    -1,   752,
-     522,   518,   873,   519,    -1,   752,    -1,   752,   522,    -1,
-     172,   756,    -1,    -1,   758,    -1,   755,   522,   758,    -1,
-     755,    -1,   755,   522,    -1,   547,   523,    -1,   775,   770,
-     726,    -1,   757,   775,   726,    -1,   776,   771,   726,    -1,
-     757,   776,   726,    -1,   753,   769,   726,    -1,   232,   776,
-     771,    -1,   687,   770,   726,    -1,   757,   687,   726,    -1,
-     232,   687,   770,    -1,   768,    -1,   518,   768,   519,   769,
-      -1,   757,   518,   768,   519,    -1,   758,   315,   518,   904,
-     167,   764,   759,   519,   770,    -1,   758,   452,   760,   518,
-     765,   167,   767,   519,   770,    -1,   181,    59,   921,    -1,
-      -1,   200,   282,    -1,   148,   282,    -1,    -1,   825,   199,
-     518,   904,   519,    -1,   825,   199,   547,    -1,   827,    -1,
-     830,    -1,   518,   871,   519,    -1,   762,   199,   518,   904,
-     519,    -1,   762,   199,   547,    -1,   763,    -1,   764,   763,
-      -1,   547,    -1,   518,   921,   519,    -1,   765,   199,   518,
-     904,   519,    -1,   766,    -1,   767,   766,    -1,   518,   768,
-     519,    -1,   758,   101,   225,   758,    -1,   758,   772,   225,
-     758,   774,    -1,   758,   225,   758,   774,    -1,   758,   269,
-     772,   225,   758,    -1,   758,   269,   225,   758,    -1,   758,
-      42,   772,   225,   758,   774,    -1,   758,    42,   225,   758,
-     774,    -1,   758,   322,   225,   758,    -1,   758,    37,   225,
-     758,   774,    -1,   758,   383,   225,   758,   774,    -1,    40,
-     547,   518,   921,   519,    -1,    40,   547,    -1,   546,   518,
-     921,   519,    -1,   546,    -1,   769,    -1,    -1,   769,    -1,
-      40,   518,   782,   519,    -1,    40,   547,   518,   782,   519,
-      -1,   546,   518,   782,   519,    -1,    -1,   173,   773,    -1,
-     235,   773,    -1,   364,   773,    -1,   383,    -1,    37,    -1,
-     209,    -1,   300,    -1,    -1,   457,   518,   921,   519,    -1,
-     290,   824,    -1,   545,    -1,   545,   511,    -1,   291,   545,
-      -1,   291,   518,   545,   519,    -1,   836,   780,    -1,   369,
-     172,   518,   778,   519,   780,    -1,   836,   779,    -1,   777,
-      -1,   778,   522,   777,    -1,    40,   518,   782,   519,    -1,
-      -1,   504,   297,    -1,    -1,   477,   824,    -1,    -1,   783,
-      -1,   782,   522,   783,    -1,   547,   788,   784,    -1,    80,
-     930,    -1,    -1,   546,   788,    -1,   785,   522,   546,   788,
-      -1,   368,    -1,   412,    -1,   788,    -1,    -1,   791,   790,
-      -1,   390,   791,   790,    -1,   791,    39,   516,   926,   517,
-      -1,   390,   791,    39,   516,   926,   517,    -1,   791,    39,
-      -1,   390,   791,    39,    -1,   789,    -1,   786,   518,   785,
-     519,   790,    -1,   247,   518,   877,   519,   790,    -1,   447,
-     518,   785,   519,   790,    -1,     3,   520,     3,    -1,   789,
-     520,     3,    -1,   790,   516,   517,    -1,   790,   516,   926,
-     517,    -1,    -1,   793,    -1,   795,    -1,   797,    -1,   801,
-      -1,   807,    -1,   808,   823,    -1,   808,   518,   926,   519,
-      -1,   795,    -1,   798,    -1,   802,    -1,   807,    -1,   929,
-     794,    -1,   518,   874,   519,    -1,    -1,   216,    -1,   217,
-      -1,   397,    -1,    54,    -1,   342,    -1,   165,   796,    -1,
-     136,   325,    -1,   115,   794,    -1,   112,   794,    -1,   283,
-     794,    -1,    57,    -1,   518,   926,   519,    -1,    -1,   799,
-      -1,   800,    -1,   799,    -1,   800,    -1,    56,   806,   518,
-     873,   519,    -1,    56,   806,    -1,   803,    -1,   804,    -1,
-     803,    -1,   804,    -1,   805,   518,   926,   519,    -1,   805,
-      -1,    72,   806,    -1,    71,   806,    -1,   464,    -1,   268,
-      72,   806,    -1,   268,    71,   806,    -1,   270,   806,    -1,
-     467,    -1,    -1,   430,   518,   926,   519,   809,    -1,   430,
-     809,    -1,   429,   518,   926,   519,   809,    -1,   429,   809,
-      -1,   219,    -1,   504,   429,   501,    -1,   482,   429,   501,
-      -1,    -1,   498,    -1,   499,    -1,   263,    -1,   264,    -1,
-     109,    -1,   110,    -1,   189,    -1,   190,    -1,   259,    -1,
-     260,    -1,   378,    -1,   379,    -1,   257,    -1,   258,    -1,
-     253,    -1,   254,    -1,   474,    -1,   475,    -1,   337,    -1,
-     338,    -1,   113,    -1,   114,    -1,    69,    -1,    68,    -1,
-     256,    -1,   255,    -1,   810,    -1,   811,    -1,   812,    -1,
-     813,    -1,   814,    -1,   815,    -1,   816,    -1,   817,    -1,
-     818,    -1,   819,    -1,   820,    -1,   821,    -1,   822,    -1,
-     810,   431,   811,    -1,   812,   431,   813,    -1,   812,   431,
-     814,    -1,   812,   431,   815,    -1,   813,   431,   814,    -1,
-     813,   431,   815,    -1,   814,   431,   815,    -1,    -1,   826,
-      -1,   824,    11,   788,    -1,   824,    80,   930,    -1,   824,
-      46,   429,   501,   824,    -1,   509,   824,    -1,   510,   824,
-      -1,   824,   509,   824,    -1,   824,   510,   824,    -1,   824,
-     511,   824,    -1,   824,   512,   824,    -1,   824,    15,   824,
-      -1,   824,   513,   824,    -1,   824,   514,   824,    -1,   824,
-      16,   824,    -1,   824,   505,   824,    -1,   824,   506,   824,
-      -1,   824,   507,   824,    -1,   824,    19,   824,    -1,   824,
-      20,   824,    -1,   824,    21,   824,    -1,   824,   866,   824,
-      -1,   866,   824,    -1,   824,   866,    -1,   824,    36,   824,
-      -1,   824,   295,   824,    -1,   275,   824,    -1,   502,   824,
-      -1,   824,   177,   824,    -1,   824,   237,   824,    -1,   824,
-     237,   824,   145,   824,    -1,   824,   502,   237,   824,    -1,
-     824,   502,   237,   824,   145,   824,    -1,   824,   194,   824,
-      -1,   824,   194,   824,   145,   824,    -1,   824,   502,   194,
-     824,    -1,   824,   502,   194,   824,   145,   824,    -1,   824,
-     394,   431,   824,    -1,   824,   394,   431,   824,   145,   824,
-      -1,   824,   502,   394,   431,   824,    -1,   824,   502,   394,
-     431,   824,   145,   824,    -1,   824,   222,   280,    -1,   824,
-     223,    -1,   824,   222,   275,   280,    -1,   824,   275,   280,
-      -1,   824,   278,    -1,   824,    17,   824,    -1,   824,    18,
-     824,    -1,   855,   302,   855,    -1,   824,   222,   438,    -1,
-     824,   222,   275,   438,    -1,   824,   222,   160,    -1,   824,
-     222,   275,   160,    -1,   824,   222,   449,    -1,   824,   222,
-     275,   449,    -1,   824,   222,   132,   172,   824,    -1,   824,
-     222,   275,   132,   172,   824,    -1,   824,   222,   285,   518,
-     877,   519,    -1,   824,   222,   275,   285,   518,   877,   519,
-      -1,   824,    53,   901,   825,    36,   824,    -1,   824,   502,
-      53,   901,   825,    36,   824,    -1,   824,    53,   416,   825,
-      36,   824,    -1,   824,   502,    53,   416,   825,    36,   824,
-      -1,   824,   199,   887,    -1,   824,   502,   199,   887,    -1,
-     824,   868,   863,   687,    -1,   824,   868,   863,   518,   824,
-     519,    -1,   117,    -1,   511,    83,   518,   824,   519,    -1,
-      83,   518,   824,   519,    -1,   511,   910,   914,   918,    -1,
-     546,   520,   511,   910,   914,   918,    -1,   826,    -1,   825,
-      11,   788,    -1,   509,   825,    -1,   510,   825,    -1,   825,
-     509,   825,    -1,   825,   510,   825,    -1,   825,   511,   825,
-      -1,   825,   512,   825,    -1,   825,    15,   825,    -1,   825,
-     513,   825,    -1,   825,   514,   825,    -1,   825,    16,   825,
-      -1,   825,   505,   825,    -1,   825,   506,   825,    -1,   825,
-     507,   825,    -1,   825,    19,   825,    -1,   825,    20,   825,
-      -1,   825,    21,   825,    -1,   825,   866,   825,    -1,   866,
-     825,    -1,   825,   866,    -1,   825,   222,   132,   172,   825,
-      -1,   825,   222,   275,   132,   172,   825,    -1,   825,   222,
-     285,   518,   877,   519,    -1,   825,   222,   275,   285,   518,
-     877,   519,    -1,   827,    -1,   828,   900,    -1,   895,    -1,
-     925,    -1,   687,    -1,   687,   549,    -1,   152,   687,    -1,
-     742,   518,   873,   519,    -1,   518,   824,   519,    -1,   830,
-      -1,   855,    -1,   524,    -1,    10,    -1,   525,   552,    -1,
-     829,    -1,   832,    -1,   833,    -1,   835,    -1,   888,    -1,
-     831,    -1,   839,    -1,    39,   687,    -1,    39,   516,   874,
-     517,    -1,   526,     9,    -1,   516,   874,   517,    -1,   527,
-     858,   528,    -1,   247,   527,   862,   528,    -1,   924,   518,
-     519,    -1,   924,   518,   711,   709,   519,    -1,   924,   518,
-     875,   710,   709,   519,    -1,   924,   518,   466,   876,   710,
-     709,   519,    -1,   924,   518,   875,   522,   466,   876,   710,
-     709,   519,    -1,   924,   518,    30,   875,   710,   709,   519,
-      -1,   924,   518,   132,   875,   710,   709,   519,    -1,   834,
-     840,   841,   842,   846,    -1,   837,    -1,   834,    -1,   837,
-      -1,    81,   167,   518,   824,   519,    -1,    66,   518,   824,
-      40,   788,   519,    -1,   441,   518,   824,    40,   788,   519,
-      -1,   159,   518,   878,   519,    -1,   303,   518,   880,   519,
-      -1,   321,   518,   882,   519,    -1,   414,   518,   883,   519,
-      -1,   435,   518,   824,    40,   788,   519,    -1,   437,   518,
-      58,   886,   519,    -1,   437,   518,   233,   886,   519,    -1,
-     437,   518,   432,   886,   519,    -1,   437,   518,   886,   519,
-      -1,   281,   518,   824,   522,   824,   519,    -1,    79,   518,
-     873,   519,    -1,   893,    -1,   516,   824,   167,   838,   199,
-     824,   517,    -1,   516,   824,   167,   838,   199,   826,   192,
-     824,   517,    -1,   481,   181,   518,   711,   519,    -1,    -1,
-     163,   518,   477,   824,   519,    -1,   163,   518,   824,   519,
-      -1,    -1,   155,    -1,    -1,   479,   844,    -1,    -1,   845,
-      -1,   844,   522,   845,    -1,   546,    40,   847,    -1,   301,
-     847,    -1,   301,   546,    -1,    -1,   518,   848,   849,   710,
-     850,   519,    -1,   546,    -1,    -1,   310,    59,   872,    -1,
-      -1,   340,   851,   853,    -1,   369,   851,   853,    -1,   184,
-     851,   853,    -1,    -1,   852,    -1,    53,   852,    36,   852,
-      -1,   444,   324,    -1,   444,   166,    -1,   104,   368,    -1,
-     824,   324,    -1,   824,   166,    -1,   148,   104,   368,    -1,
-     148,   181,    -1,   148,   428,    -1,   148,   273,   298,    -1,
-      -1,   368,   518,   873,   519,    -1,   368,   518,   519,    -1,
-     854,    -1,   518,   872,   522,   824,   519,    -1,   547,   523,
-     824,    -1,   856,    -1,   857,   522,   856,    -1,   857,    -1,
-     857,   522,    -1,   824,   523,   824,    -1,   859,    -1,   860,
-     522,   859,    -1,   860,    -1,   860,   522,    -1,   861,    -1,
-      -1,    38,    -1,   399,    -1,    30,    -1,     8,    -1,   865,
-      -1,   509,    -1,   510,    -1,   511,    -1,   512,    -1,    15,
-      -1,   513,    -1,   514,    -1,    16,    -1,   505,    -1,   506,
-      -1,   507,    -1,    19,    -1,    20,    -1,    21,    -1,     8,
-      -1,   292,   518,   869,   519,    -1,   864,    -1,   292,   518,
-     869,   519,    -1,   864,    -1,   292,   518,   869,   519,    -1,
-     237,    -1,   502,   237,    -1,   177,    -1,   502,   177,    -1,
-     194,    -1,   502,   194,    -1,   864,    -1,   546,   520,   869,
-      -1,   826,    -1,   870,   522,   826,    -1,   870,    -1,   870,
-     522,    -1,   824,    -1,   872,   522,   824,    -1,   872,    -1,
-     872,   522,    -1,   873,    -1,    -1,   876,    -1,   875,   522,
-     876,    -1,   824,    -1,   933,    13,   824,    -1,   933,    14,
-     824,    -1,   788,    -1,   877,   522,   788,    -1,   879,   172,
-     824,    -1,    -1,     3,    -1,   810,    -1,   811,    -1,   812,
-      -1,   813,    -1,   814,    -1,   815,    -1,   816,    -1,   817,
-      -1,   818,    -1,   819,    -1,   820,    -1,   821,    -1,   822,
-      -1,   548,    -1,   824,   881,   884,   885,    -1,   824,   881,
-     884,    -1,   318,   824,    -1,   825,   199,   825,    -1,    -1,
-     824,   884,   885,    -1,   824,   885,   884,    -1,   824,   884,
-      -1,   824,   885,    -1,   872,    -1,    -1,   172,   824,    -1,
-     167,   824,    -1,   824,   172,   873,    -1,   172,   873,    -1,
-     873,    -1,   687,    -1,   518,   873,   519,    -1,   895,    -1,
-     830,    -1,    65,   892,   889,   891,   143,    -1,   890,    -1,
-     889,   890,    -1,   476,   824,   427,   824,    -1,   139,   824,
-      -1,    -1,   824,    -1,    -1,   894,    -1,   893,   522,   894,
-      -1,   546,    -1,   546,    -1,   546,   549,    -1,   516,   824,
-     517,    -1,   516,   896,   523,   896,   517,    -1,   516,   896,
-     523,   896,   523,   896,   517,    -1,   516,   896,   523,   510,
-     523,   896,   517,    -1,   824,    -1,    -1,    -1,   897,   550,
-      -1,    -1,   518,   519,    -1,   518,   875,   519,    -1,   520,
-     551,   898,    -1,   516,   824,   517,    -1,   516,   896,   523,
-     896,   517,    -1,   516,   896,   523,   896,   523,   896,   517,
-      -1,   516,   896,   523,   510,   523,   896,   517,    -1,    -1,
-     900,   899,    -1,    45,    -1,    -1,   904,    -1,    -1,   905,
-      -1,   903,   522,   905,    -1,   903,    -1,   903,   522,    -1,
-     824,    40,   934,    -1,   824,     3,    -1,   824,    -1,   546,
-     523,   824,    -1,   148,   518,   909,   519,    -1,   148,   907,
-      -1,   547,    -1,   907,   520,   547,    -1,   907,    -1,   908,
-     522,   907,    -1,   908,    -1,   908,   522,    -1,   906,    -1,
-      -1,   824,    40,   546,    -1,   911,    -1,   912,   522,   911,
-      -1,   912,    -1,   912,   522,    -1,   355,   518,   913,   519,
-      -1,   355,   911,    -1,    -1,   907,    40,   546,    -1,   915,
-      -1,   916,   522,   915,    -1,   916,    -1,   916,   522,    -1,
-     353,   518,   917,   519,    -1,   353,   915,    -1,    -1,   545,
-      -1,   919,   522,   545,    -1,   923,    -1,   920,   522,   923,
-      -1,   920,    -1,   920,   522,    -1,   921,    -1,   518,   921,
-     519,    -1,   547,    -1,   928,    -1,   546,   549,    -1,   926,
-      -1,     4,    -1,   548,   897,    -1,     6,    -1,     7,    -1,
-     924,   548,    -1,   924,   518,   875,   710,   709,   519,   548,
-      -1,   792,   548,    -1,   808,   518,   824,   519,   823,    -1,
-     808,   926,   823,    -1,   808,   548,   823,    -1,   438,    -1,
-     160,    -1,   280,    -1,     9,    -1,     3,    -1,  1005,    -1,
-    1010,    -1,     3,    -1,  1005,    -1,  1007,    -1,     3,    -1,
-    1005,    -1,  1008,    -1,   546,    -1,   546,   931,    -1,   520,
-     551,    -1,   931,   520,   551,    -1,   518,   921,   519,    -1,
-      -1,   927,    -1,   552,    -1,     5,    -1,   326,   923,   936,
-      40,   937,    -1,   518,   877,   519,    -1,    -1,   686,    -1,
-     555,    -1,   667,    -1,   668,    -1,   982,    -1,   994,    -1,
-     100,   373,   545,   939,    -1,   100,   373,   192,   275,   152,
-     545,   939,    -1,   100,   295,   355,   373,   545,   939,    -1,
-     939,   940,    -1,    -1,   604,    -1,   941,    -1,   580,    -1,
-    1000,    -1,   100,   947,   203,   944,   945,   290,   545,   943,
-     518,   574,   519,   946,   781,    -1,   100,   947,   203,   944,
-     192,   275,   152,   633,   290,   545,   943,   518,   574,   519,
-     946,   781,    -1,   546,    -1,   457,   942,    -1,    -1,    89,
-      -1,    -1,   633,    -1,    -1,   480,   619,    -1,    -1,   448,
-      -1,    -1,    32,   419,   775,   389,   373,   923,    -1,    32,
-     419,   192,   152,   775,   389,   373,   923,    -1,    32,   384,
-     545,   389,   373,   923,    -1,    32,   384,   192,   152,   545,
-     389,   373,   923,    -1,    32,   470,   545,   389,   373,   923,
-      -1,    32,   470,   192,   152,   545,   389,   373,   923,    -1,
-     168,    75,   950,    -1,    75,   950,    -1,   546,    -1,    -1,
-      84,   290,   953,   545,   222,   952,    -1,    84,   290,    82,
-     824,   222,   952,    -1,   548,    -1,   280,    -1,   419,    -1,
-     384,    -1,   174,    -1,   246,    -1,   246,   419,    -1,   470,
-      -1,   108,    -1,   203,    -1,   373,    -1,   442,    -1,   154,
-     108,   548,   676,    -1,   154,   108,   546,   431,   548,   676,
-      -1,   198,   108,   548,    -1,   153,   959,    -1,   153,   963,
-     957,   959,    -1,   153,   468,   959,    -1,   153,   518,   962,
-     519,   959,    -1,   468,    -1,    -1,   964,    -1,   594,    -1,
-      -1,   948,    -1,   591,    -1,   533,    -1,   999,    -1,   949,
-      -1,   668,    -1,  1002,    -1,   658,    -1,   938,    -1,   580,
-      -1,   604,    -1,   576,    -1,   544,    -1,   982,    -1,   652,
-      -1,   587,    -1,   941,    -1,   555,    -1,   973,    -1,   579,
-      -1,   935,    -1,   553,    -1,   686,    -1,   600,    -1,   667,
-      -1,   586,    -1,   977,    -1,   991,    -1,   967,    -1,   994,
-      -1,  1000,    -1,     3,    -1,  1005,    -1,  1009,    -1,   960,
-      -1,   548,    -1,   965,    -1,   962,   522,   965,    -1,    35,
-      -1,    34,    -1,   438,    -1,   160,    -1,   290,    -1,   961,
-      -1,   966,   958,    -1,   960,    -1,   963,    -1,   389,   968,
-      -1,   389,   241,   968,    -1,   389,   388,   968,    -1,   389,
-     178,   968,    -1,   389,   465,   968,    -1,   969,    -1,   998,
-     172,   104,    -1,   429,   501,   971,    -1,   373,   548,    -1,
-     998,   431,   972,    -1,   998,   507,   972,    -1,   824,    -1,
-     548,    -1,     3,    -1,   808,   548,   823,    -1,   808,   518,
-     926,   519,   548,    -1,   594,    -1,   117,    -1,   241,    -1,
-     970,    -1,   972,   522,   970,    -1,   240,   975,    -1,   974,
-     214,   975,   976,    -1,   974,   214,   975,   172,   546,   976,
-      -1,   974,   214,   975,   172,   548,   976,    -1,    -1,   168,
-      -1,   548,    -1,   546,    -1,    -1,   469,   548,    -1,   469,
-     546,    -1,   458,   979,   981,   957,    -1,   458,   979,   981,
-     957,   545,   932,    -1,   458,   979,   981,   957,   986,    -1,
-     458,   518,   980,   519,    -1,   458,   518,   980,   519,   545,
-     932,    -1,   963,    -1,   468,    -1,   171,    -1,   173,    -1,
-       3,    -1,   173,    -1,    -1,   978,    -1,   980,   522,   978,
-      -1,   171,    -1,    -1,   560,   122,   172,   983,   985,   984,
-     566,    -1,   439,   704,   983,    -1,   775,    -1,   775,   546,
-      -1,   775,    40,   546,    -1,   477,   824,    -1,    -1,   457,
-     756,    -1,    -1,   963,   957,    -1,   963,   957,   545,   932,
-      -1,    47,   989,   548,   990,   676,    -1,    47,   192,   275,
-     152,   989,   548,   990,   676,    -1,   128,   552,    -1,   128,
-     108,   552,    -1,   128,   108,   192,   152,   552,    -1,   108,
-      -1,    -1,    40,   546,    -1,    -1,   357,   993,    -1,   357,
-     241,   993,    -1,   357,   388,   993,    -1,   357,   178,   993,
-      -1,   357,   465,   993,    -1,   998,    -1,    30,    -1,   992,
-      -1,   429,   501,    -1,   433,   224,   236,    -1,   996,   686,
-      -1,   415,   686,    -1,   415,   545,    -1,   996,   545,    -1,
-     996,   429,   501,    -1,   996,   433,   224,   236,    -1,   996,
-      30,   997,    -1,   996,    -1,   127,    -1,   126,    -1,   393,
-      -1,   995,    -1,   420,    -1,    -1,   546,    -1,   998,   520,
-     546,    -1,    61,   834,    -1,   100,   650,   470,   545,   639,
-     946,    40,   686,  1001,    -1,   100,   650,   470,   192,   275,
-     152,   545,   639,   946,    40,   686,  1001,    -1,   100,   295,
-     355,   650,   470,   545,   639,   946,    40,   686,  1001,    -1,
-     100,   650,   345,   470,   545,   518,   643,   519,   946,    40,
-     686,  1001,    -1,   100,   295,   355,   650,   345,   470,   545,
-     518,   643,   519,   946,    40,   686,  1001,    -1,   480,    74,
-     293,    -1,   480,    64,    74,   293,    -1,   480,   241,    74,
-     293,    -1,    -1,   100,   650,   419,  1004,    40,   686,  1003,
-      -1,   100,   650,   419,   192,   275,   152,  1004,    40,   686,
-    1003,    -1,   100,   295,   355,   650,   419,  1004,    40,   686,
-    1003,    -1,   480,   107,    -1,   480,   273,   107,    -1,    -1,
-     545,   639,   626,   618,    -1,    22,    -1,    23,    -1,    24,
-      -1,    25,    -1,    26,    -1,    27,    -1,    28,    -1,    29,
-      -1,    31,    -1,    32,    -1,    33,    -1,    43,    -1,    44,
-      -1,    46,    -1,    47,    -1,    48,    -1,    50,    -1,    51,
-      -1,    52,    -1,    59,    -1,    60,    -1,    61,    -1,    62,
-      -1,    63,    -1,    64,    -1,    67,    -1,    68,    -1,    69,
-      -1,    70,    -1,    73,    -1,    75,    -1,    76,    -1,    77,
-      -1,    78,    -1,    84,    -1,    85,    -1,    86,    -1,    87,
-      -1,    88,    -1,    90,    -1,    91,    -1,    92,    -1,    94,
-      -1,    95,    -1,    96,    -1,    97,    -1,    98,    -1,    99,
-      -1,   102,    -1,   103,    -1,   104,    -1,   105,    -1,   106,
-      -1,   107,    -1,   108,    -1,   109,    -1,   110,    -1,   111,
-      -1,   113,    -1,   114,    -1,   116,    -1,   118,    -1,   120,
-      -1,   121,    -1,   122,    -1,   123,    -1,   124,    -1,   125,
-      -1,   128,    -1,   129,    -1,   130,    -1,   131,    -1,   134,
-      -1,   135,    -1,   136,    -1,   137,    -1,   138,    -1,   140,
-      -1,   141,    -1,   142,    -1,   144,    -1,   145,    -1,   146,
-      -1,   148,    -1,   149,    -1,   150,    -1,   151,    -1,   153,
-      -1,   154,    -1,   155,    -1,   156,    -1,   157,    -1,   158,
-      -1,   161,    -1,   163,    -1,   164,    -1,   166,    -1,   168,
-      -1,   170,    -1,   174,    -1,   175,    -1,   178,    -1,   180,
-      -1,   184,    -1,   185,    -1,   187,    -1,   188,    -1,   189,
-      -1,   190,    -1,   191,    -1,   192,    -1,   193,    -1,   195,
-      -1,   196,    -1,   197,    -1,   198,    -1,   200,    -1,   201,
-      -1,   202,    -1,   203,    -1,   204,    -1,   205,    -1,   206,
-      -1,   208,    -1,   211,    -1,   212,    -1,   213,    -1,   214,
-      -1,   215,    -1,   221,    -1,   224,    -1,   226,    -1,   227,
-      -1,   228,    -1,   229,    -1,   230,    -1,   231,    -1,   234,
-      -1,   236,    -1,   239,    -1,   240,    -1,   241,    -1,   242,
-      -1,   243,    -1,   244,    -1,   245,    -1,   246,    -1,   248,
-      -1,   249,    -1,   250,    -1,   251,    -1,   252,    -1,   253,
-      -1,   254,    -1,   255,    -1,   256,    -1,   257,    -1,   258,
-      -1,   259,    -1,   260,    -1,   261,    -1,   262,    -1,   263,
-      -1,   264,    -1,   265,    -1,   266,    -1,   267,    -1,   271,
-      -1,   272,    -1,   273,    -1,   276,    -1,   277,    -1,   279,
-      -1,   282,    -1,   284,    -1,   285,    -1,   286,    -1,   288,
-      -1,   289,    -1,   292,    -1,   293,    -1,   294,    -1,   297,
-      -1,   298,    -1,   301,    -1,   304,    -1,   305,    -1,   306,
-      -1,   307,    -1,   308,    -1,   309,    -1,   310,    -1,   311,
-      -1,   312,    -1,   313,    -1,   314,    -1,   319,    -1,   320,
-      -1,   323,    -1,   324,    -1,   326,    -1,   327,    -1,   328,
-      -1,   330,    -1,   331,    -1,   332,    -1,   333,    -1,   334,
-      -1,   335,    -1,   337,    -1,   338,    -1,   339,    -1,   340,
-      -1,   341,    -1,   343,    -1,   344,    -1,   345,    -1,   346,
-      -1,   348,    -1,   349,    -1,   350,    -1,   351,    -1,   352,
-      -1,   353,    -1,   354,    -1,   355,    -1,   356,    -1,   357,
-      -1,   358,    -1,   359,    -1,   360,    -1,   362,    -1,   363,
-      -1,   365,    -1,   366,    -1,   367,    -1,   369,    -1,   370,
-      -1,   371,    -1,   372,    -1,   373,    -1,   374,    -1,   375,
-      -1,   376,    -1,   377,    -1,   378,    -1,   379,    -1,   380,
-      -1,   381,    -1,   384,    -1,   385,    -1,   386,    -1,   387,
-      -1,   388,    -1,   389,    -1,   391,    -1,   392,    -1,   395,
-      -1,   396,    -1,   398,    -1,   400,    -1,   401,    -1,   402,
-      -1,   403,    -1,   404,    -1,   405,    -1,   406,    -1,   407,
-      -1,   408,    -1,   409,    -1,   410,    -1,   411,    -1,   413,
-      -1,   417,    -1,   418,    -1,   420,    -1,   422,    -1,   423,
-      -1,   424,    -1,   425,    -1,   426,    -1,   428,    -1,   433,
-      -1,   434,    -1,   436,    -1,   439,    -1,   440,    -1,   442,
-      -1,   443,    -1,   444,    -1,   445,    -1,   446,    -1,   449,
-      -1,   450,    -1,   451,    -1,   453,    -1,   454,    -1,   455,
-      -1,   456,    -1,   458,    -1,   459,    -1,   460,    -1,   461,
-      -1,   462,    -1,   465,    -1,   467,    -1,   469,    -1,   470,
-      -1,   471,    -1,   472,    -1,   473,    -1,   474,    -1,   475,
-      -1,   478,    -1,   481,    -1,   482,    -1,   483,    -1,   484,
-      -1,   485,    -1,   486,    -1,   498,    -1,   499,    -1,   500,
-      -1,   501,    -1,    53,    -1,    54,    -1,    56,    -1,    57,
-      -1,    71,    -1,    72,    -1,    79,    -1,    83,    -1,   112,
-      -1,   115,    -1,   152,    -1,   159,    -1,   165,    -1,   176,
-      -1,   182,    -1,   183,    -1,   210,    -1,   216,    -1,   217,
-      -1,   219,    -1,   247,    -1,   268,    -1,   270,    -1,   274,
-      -1,   281,    -1,   283,    -1,   299,    -1,   303,    -1,   321,
-      -1,   325,    -1,   342,    -1,   368,    -1,   390,    -1,   397,
-      -1,   412,    -1,   414,    -1,   429,    -1,   430,    -1,   435,
-      -1,   437,    -1,   441,    -1,   463,    -1,   464,    -1,   487,
-      -1,   488,    -1,   489,    -1,   490,    -1,   491,    -1,   492,
-      -1,   493,    -1,   494,    -1,   495,    -1,   496,    -1,   497,
-      -1,    42,    -1,    49,    -1,    55,    -1,    81,    -1,    89,
-      -1,   101,    -1,   171,    -1,   173,    -1,   176,    -1,   177,
-      -1,   194,    -1,   209,    -1,   222,    -1,   223,    -1,   225,
-      -1,   235,    -1,   237,    -1,   247,    -1,   269,    -1,   278,
-      -1,   300,    -1,   302,    -1,   322,    -1,   364,    -1,   394,
-      -1,   412,    -1,   421,    -1,   468,    -1,    37,    -1,    42,
-      -1,    49,    -1,    55,    -1,    81,    -1,    83,    -1,    89,
-      -1,   101,    -1,   171,    -1,   173,    -1,   177,    -1,   194,
-      -1,   209,    -1,   222,    -1,   223,    -1,   225,    -1,   235,
-      -1,   237,    -1,   269,    -1,   278,    -1,   300,    -1,   302,
-      -1,   322,    -1,   364,    -1,   383,    -1,   394,    -1,   421,
-      -1,   441,    -1,   468,    -1,    37,    -1,    42,    -1,    49,
-      -1,    53,    -1,    54,    -1,    55,    -1,    56,    -1,    57,
-      -1,    72,    -1,    71,    -1,    79,    -1,    81,    -1,    83,
-      -1,    89,    -1,   101,    -1,   112,    -1,   115,    -1,   152,
-      -1,   159,    -1,   165,    -1,   171,    -1,   173,    -1,   176,
-      -1,   177,    -1,   182,    -1,   183,    -1,   194,    -1,   209,
-      -1,   210,    -1,   217,    -1,   219,    -1,   216,    -1,   222,
-      -1,   223,    -1,   225,    -1,   235,    -1,   237,    -1,   247,
-      -1,   268,    -1,   269,    -1,   270,    -1,   274,    -1,   278,
-      -1,   281,    -1,   283,    -1,   300,    -1,   299,    -1,   302,
-      -1,   303,    -1,   321,    -1,   322,    -1,   325,    -1,   342,
-      -1,   364,    -1,   368,    -1,   383,    -1,   390,    -1,   394,
-      -1,   397,    -1,   412,    -1,   414,    -1,   421,    -1,   429,
-      -1,   430,    -1,   435,    -1,   437,    -1,   441,    -1,   463,
-      -1,   464,    -1,   468,    -1,   487,    -1,   488,    -1,   489,
-      -1,   490,    -1,   491,    -1,   492,    -1,   493,    -1,   494,
-      -1,   495,    -1,   496,    -1,   497,    -1,    37,    -1,    42,
-      -1,    49,    -1,    55,    -1,    81,    -1,    83,    -1,    89,
-      -1,   101,    -1,   171,    -1,   173,    -1,   176,    -1,   177,
-      -1,   194,    -1,   209,    -1,   222,    -1,   223,    -1,   225,
-      -1,   235,    -1,   237,    -1,   247,    -1,   269,    -1,   278,
-      -1,   300,    -1,   302,    -1,   322,    -1,   364,    -1,   383,
-      -1,   394,    -1,   412,    -1,   421,    -1,   441,    -1,   468,
-      -1,    30,    -1,    34,    -1,    35,    -1,    36,    -1,    38,
-      -1,    39,    -1,    40,    -1,    41,    -1,    45,    -1,    58,
-      -1,    65,    -1,    66,    -1,    74,    -1,    80,    -1,    82,
-      -1,    93,    -1,   100,    -1,   117,    -1,   119,    -1,   126,
-      -1,   127,    -1,   132,    -1,   133,    -1,   139,    -1,   143,
-      -1,   147,    -1,   160,    -1,   162,    -1,   167,    -1,   169,
-      -1,   172,    -1,   179,    -1,   181,    -1,   186,    -1,   199,
-      -1,   207,    -1,   218,    -1,   220,    -1,   232,    -1,   233,
-      -1,   238,    -1,   275,    -1,   280,    -1,   287,    -1,   290,
-      -1,   291,    -1,   295,    -1,   296,    -1,   315,    -1,   316,
-      -1,   317,    -1,   318,    -1,   329,    -1,   336,    -1,   347,
-      -1,   361,    -1,   382,    -1,   393,    -1,   399,    -1,   415,
-      -1,   416,    -1,   419,    -1,   427,    -1,   431,    -1,   432,
-      -1,   438,    -1,   447,    -1,   448,    -1,   452,    -1,   457,
-      -1,   466,    -1,   476,    -1,   477,    -1,   479,    -1,   480,
-      -1
-};
-
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const yytype_uint16 yyrline[] =
-{
-       0,   509,   509,   525,   537,   546,   547,   548,   549,   550,
-     551,   552,   553,   554,   555,   556,   557,   558,   559,   560,
-     561,   562,   563,   564,   565,   566,   567,   568,   569,   570,
-     571,   572,   573,   574,   575,   576,   577,   578,   579,   580,
-     581,   582,   583,   584,   585,   586,   588,     9,    18,    27,
-      36,    45,    54,    63,    72,    85,    87,    93,    94,    99,
-     103,   107,   118,   126,   130,   139,   148,   157,   166,   175,
-     184,   192,   200,   209,   218,   227,   236,   253,   262,   271,
-     280,   290,   303,   318,   327,   335,   350,   358,   368,   378,
-     385,   392,   400,   407,   418,   419,   424,   428,   433,   438,
-     446,   447,   452,   456,   457,   458,     7,    13,    19,    25,
-       9,    13,    44,    45,    46,    50,    51,    55,    59,    60,
-      64,    70,    75,    76,    77,    78,     6,    15,    25,    35,
-      45,    55,    65,    75,    85,    95,   106,   117,   127,   140,
-     141,     9,    23,    29,    36,    42,    49,    59,    63,    71,
-      72,    73,    77,    86,    95,   102,   103,   108,   120,   125,
-     150,   155,   160,   166,   176,   186,   192,   203,   214,   229,
-     230,   236,   237,   242,   243,   249,   250,   254,   255,   260,
-     262,   268,   269,   273,   274,   277,   278,   283,     7,    16,
-      25,    46,    47,    50,    54,     7,    14,    22,     9,    19,
-      29,    42,    43,     7,    17,    27,    40,    41,    45,    46,
-      47,    51,    52,     7,     7,    14,    31,    51,    55,    65,
-      69,    75,    76,     9,    17,    29,    30,    34,    35,    36,
-      41,    42,    43,    48,    52,    56,    60,    64,    68,    72,
-      76,    80,    84,    88,    92,    97,   101,   105,   112,   113,
-     117,   118,   119,     7,    16,    28,    29,     2,    10,    17,
-      24,    32,    40,    51,    52,    53,    57,    58,    59,     2,
-       7,    21,    36,    56,    57,    84,    85,    86,    87,    88,
-      89,    93,    94,    99,   104,   105,   106,   107,   108,   113,
-     120,   121,   122,   139,   146,   153,   163,   173,   185,   193,
-     202,   220,   221,   225,   226,   230,   239,   262,   276,   283,
-     288,   290,   292,   294,   297,   300,   301,   302,   303,   308,
-     312,   313,   318,   325,   330,   331,   332,   333,   334,   335,
-     336,   337,   343,   344,   348,   353,   360,   367,   374,   386,
-     387,   388,   389,   393,   398,   399,   400,   405,   410,   411,
-     412,   413,   414,   415,   420,   440,   469,   470,   474,   478,
-     479,   480,   484,   488,   496,   497,   502,   503,   504,   508,
-     516,   517,   522,   523,   527,   532,   536,   540,   545,   553,
-     554,   558,   559,   563,   564,   570,   581,   594,   608,   622,
-     636,   650,   673,   677,   684,   688,   696,   701,   708,   718,
-     719,   720,   721,   722,   729,   736,   737,   742,   743,     9,
-      19,    29,    39,    49,    59,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    89,    90,    95,    96,    97,    98,    99,   100,   105,
-     106,   111,   112,   113,   118,   119,   120,     8,    18,    29,
-      39,    49,    59,    71,    81,    91,    95,   102,   106,   110,
-     119,   123,   130,   131,   135,   139,     7,     1,    30,    49,
-      61,    62,    63,    67,    68,    73,    77,    82,    86,    94,
-      95,    99,   100,   105,   106,   110,   111,   116,   117,   118,
-     119,   120,   121,   122,   123,   128,   136,   140,   145,   146,
-     151,   155,   160,   164,   168,   172,   176,   180,   184,   188,
-     192,   196,   200,   204,   208,   212,   216,   220,   228,   233,
-     234,   235,   236,   237,   243,   247,    47,    48,    52,    53,
-      54,    72,    73,    80,    88,    96,   104,   112,   120,   131,
-     132,   159,   164,   172,   188,   205,   223,   241,   242,   261,
-     265,   269,   273,   277,   287,   298,   308,   317,   328,   339,
-     351,   366,   384,   384,   388,   388,   392,   392,   396,   402,
-     409,   413,   414,   418,   419,   433,   440,   447,   457,   458,
-     461,   474,   475,   476,   480,   491,   499,   504,   509,   514,
-     519,   527,   535,   540,   545,   552,   553,   557,   558,   559,
-     563,   570,   571,   575,   576,   580,   581,   582,   586,   587,
-     591,   592,   608,   609,   612,   621,   632,   633,   634,   637,
-     638,   639,   643,   644,   645,   646,   650,   651,   655,   657,
-     673,   675,   680,   683,   688,   692,   696,   703,   707,   711,
-     715,   722,   727,   734,   735,   739,   744,   748,   752,   760,
-     767,   768,   773,   774,   778,   779,   784,   786,   788,   793,
-     813,   814,   816,   821,   822,   826,   827,   830,   831,   856,
-     857,   862,   866,   867,   871,   872,   876,   877,   878,   879,
-     880,   884,   897,   904,   911,   918,   919,   923,   924,   928,
-     929,   933,   934,   938,   939,   943,   944,   948,   959,   960,
-     961,   962,   966,   967,   972,   973,   974,   983,   989,   998,
-     999,  1012,  1013,  1017,  1018,  1022,  1023,  1027,  1038,  1044,
-    1050,  1058,  1066,  1076,  1084,  1093,  1102,  1111,  1115,  1120,
-    1125,  1136,  1150,  1151,  1154,  1155,  1156,  1159,  1167,  1177,
-    1178,  1179,  1182,  1190,  1199,  1203,  1210,  1211,  1215,  1224,
-    1228,  1253,  1257,  1270,  1284,  1299,  1311,  1324,  1338,  1352,
-    1365,  1380,  1399,  1405,  1410,  1416,  1423,  1424,  1432,  1436,
-    1440,  1446,  1453,  1458,  1459,  1460,  1461,  1462,  1463,  1467,
-    1468,  1480,  1481,  1486,  1493,  1500,  1507,  1539,  1550,  1563,
-    1568,  1569,  1572,  1573,  1576,  1577,  1582,  1583,  1588,  1592,
-    1598,  1619,  1627,  1641,  1644,  1648,  1648,  1651,  1652,  1654,
-    1659,  1666,  1671,  1677,  1682,  1688,  1692,  1699,  1706,  1716,
-    1717,  1721,  1723,  1726,  1730,  1731,  1732,  1733,  1734,  1735,
-    1740,  1760,  1761,  1762,  1763,  1774,  1788,  1789,  1795,  1800,
-    1805,  1810,  1815,  1820,  1825,  1830,  1836,  1842,  1848,  1855,
-    1877,  1886,  1890,  1898,  1902,  1910,  1922,  1943,  1947,  1953,
-    1957,  1970,  1978,  1988,  1990,  1992,  1994,  1996,  1998,  2003,
-    2004,  2011,  2020,  2028,  2037,  2048,  2056,  2057,  2058,  2062,
-    2062,  2065,  2065,  2068,  2068,  2071,  2071,  2074,  2074,  2077,
-    2077,  2080,  2080,  2083,  2083,  2086,  2086,  2089,  2089,  2092,
-    2092,  2095,  2095,  2098,  2098,  2101,  2103,  2105,  2107,  2109,
-    2111,  2113,  2115,  2117,  2119,  2121,  2123,  2125,  2127,  2132,
-    2137,  2143,  2150,  2155,  2161,  2167,  2198,  2200,  2202,  2210,
-    2225,  2227,  2229,  2231,  2233,  2235,  2237,  2239,  2241,  2243,
-    2245,  2247,  2249,  2251,  2253,  2255,  2258,  2260,  2262,  2265,
-    2267,  2269,  2271,  2273,  2278,  2283,  2290,  2295,  2302,  2307,
-    2314,  2319,  2327,  2335,  2343,  2351,  2369,  2377,  2385,  2393,
-    2401,  2409,  2417,  2421,  2437,  2445,  2453,  2461,  2469,  2477,
-    2485,  2489,  2493,  2497,  2501,  2509,  2517,  2525,  2533,  2553,
-    2575,  2586,  2593,  2607,  2616,  2624,  2633,  2654,  2656,  2658,
-    2660,  2662,  2664,  2666,  2668,  2670,  2672,  2674,  2676,  2678,
-    2680,  2682,  2684,  2686,  2688,  2690,  2692,  2694,  2696,  2700,
-    2704,  2708,  2722,  2723,  2737,  2738,  2739,  2750,  2774,  2785,
-    2795,  2799,  2803,  2810,  2814,  2821,  2828,  2829,  2830,  2831,
-    2832,  2833,  2834,  2835,  2846,  2851,  2860,  2866,  2873,  2893,
-    2897,  2904,  2911,  2919,  2927,  2938,  2958,  2994,  3005,  3006,
-    3013,  3019,  3021,  3023,  3027,  3036,  3041,  3048,  3063,  3070,
-    3074,  3078,  3082,  3086,  3096,  3104,  3113,  3135,  3136,  3140,
-    3141,  3142,  3146,  3147,  3154,  3155,  3159,  3160,  3165,  3173,
-    3175,  3189,  3192,  3219,  3220,  3223,  3224,  3232,  3240,  3248,
-    3257,  3267,  3285,  3331,  3340,  3349,  3358,  3367,  3379,  3380,
-    3381,  3382,  3383,  3397,  3398,  3401,  3402,  3406,  3416,  3417,
-    3421,  3422,  3426,  3433,  3434,  3439,  3440,  3445,  3446,  3449,
-    3450,  3451,  3454,  3455,  3458,  3459,  3460,  3461,  3462,  3463,
-    3464,  3465,  3466,  3467,  3468,  3469,  3470,  3471,  3474,  3476,
-    3481,  3483,  3488,  3490,  3492,  3494,  3496,  3498,  3500,  3502,
-    3516,  3518,  3523,  3527,  3534,  3539,  3545,  3549,  3556,  3561,
-    3568,  3573,  3581,  3585,  3591,  3595,  3604,  3615,  3616,  3620,
-    3624,  3631,  3632,  3633,  3634,  3635,  3636,  3637,  3638,  3639,
-    3640,  3641,  3642,  3643,  3644,  3645,  3655,  3659,  3666,  3673,
-    3674,  3690,  3694,  3699,  3703,  3718,  3723,  3727,  3730,  3733,
-    3734,  3735,  3738,  3745,  3746,  3747,  3757,  3771,  3772,  3776,
-    3787,  3788,  3791,  3792,  3796,  3797,  3800,  3806,  3810,  3817,
-    3825,  3833,  3841,  3851,  3852,  3857,  3858,  3862,  3863,  3864,
-    3868,  3877,  3885,  3893,  3902,  3917,  3918,  3923,  3924,  3934,
-    3935,  3939,  3940,  3944,  3945,  3948,  3964,  3972,  3980,  3990,
-    3991,  3995,  3999,  4005,  4007,  4012,  4013,  4017,  4018,  4021,
-    4025,  4026,  4030,  4031,  4034,  4035,  4036,  4039,  4043,  4044,
-    4048,  4049,  4051,  4052,  4053,  4063,  4064,  4068,  4070,  4076,
-    4077,  4081,  4082,  4085,  4096,  4099,  4110,  4114,  4118,  4130,
-    4134,  4143,  4150,  4188,  4192,  4196,  4200,  4204,  4208,  4212,
-    4218,  4235,  4236,  4237,  4240,  4241,  4242,  4245,  4246,  4247,
-    4250,  4251,  4254,  4256,  4261,  4262,  4265,  4269,  4270,     7,
-      18,    19,    23,    24,    25,    26,    27,    28,     7,    26,
-      50,    73,    80,    85,    86,    87,    88,     8,    33,    62,
-      66,    67,    72,    73,    78,    79,    83,    84,    89,    90,
-       7,    16,    25,    34,    43,    52,     5,    12,    22,    23,
-       7,    15,    26,    27,    30,    31,    32,    33,    34,    35,
-      36,    37,    38,    39,     7,    19,    33,     9,    16,    26,
-      33,    44,    45,    50,    51,    52,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    91,    92,    93,
-      98,    99,   104,   108,   116,   117,   122,   123,   124,   130,
-     135,   143,   144,    10,    16,    22,    28,    34,    44,    45,
-      53,    64,    76,    84,    95,   101,   105,   109,   124,   131,
-     132,   133,   137,   138,     7,    17,    26,    35,    46,    47,
-      49,    50,    53,    54,    55,     8,    22,    36,    48,    56,
-      70,    71,    72,    73,    74,    87,    88,    93,    94,    98,
-      99,     7,    18,    31,    35,    42,    53,    54,    60,    61,
-       9,    19,     7,    16,    28,    35,    42,    51,    52,    56,
-      57,     2,     7,    12,    17,    22,    31,    38,    48,    49,
-      56,     3,    10,    17,    24,    31,    38,    45,    52,    61,
-      61,    63,    63,    65,    65,    67,    68,     6,     8,    21,
-      34,    47,    65,    87,    88,    89,    90,    11,    24,    37,
-      54,    55,    56,    61,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    76,    76,    76,    76,    76,    76,    76,    76,
-      76,    76,    76,    76,    76,    76,    76,    76,    76,    76,
-      76,    76,    76,    76,    76,    76,    76,    76,    76,    76,
-      77,    77,    77,    77,    77,    77,    77,    77,    77,    77,
-      77,    77,    77,    77,    77,    77,    77,    77,    77,    77,
-      77,    77,    77,    77,    77,    77,    77,    77,    77,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
-      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
-      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
-      79,    79,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char *const yytname[] =
-{
-  "$end", "error", "$undefined", "IDENT", "FCONST", "SCONST", "BCONST",
-  "XCONST", "Op", "ICONST", "PARAM", "TYPECAST", "DOT_DOT", "COLON_EQUALS",
-  "EQUALS_GREATER", "INTEGER_DIVISION", "POWER_OF", "LAMBDA_ARROW",
-  "DOUBLE_ARROW", "LESS_EQUALS", "GREATER_EQUALS", "NOT_EQUALS", "ABORT_P",
-  "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE",
-  "ALL", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", "AND", "ANTI",
-  "ANY", "ARRAY", "AS", "ASC_P", "ASOF", "ASSERTION", "ASSIGNMENT",
-  "ASYMMETRIC", "AT", "ATTACH", "ATTRIBUTE", "AUTHORIZATION", "BACKWARD",
-  "BEFORE", "BEGIN_P", "BETWEEN", "BIGINT", "BINARY", "BIT", "BOOLEAN_P",
-  "BOTH", "BY", "CACHE", "CALL_P", "CALLED", "CASCADE", "CASCADED", "CASE",
-  "CAST", "CATALOG_P", "CENTURIES_P", "CENTURY_P", "CHAIN", "CHAR_P",
-  "CHARACTER", "CHARACTERISTICS", "CHECK_P", "CHECKPOINT", "CLASS",
-  "CLOSE", "CLUSTER", "COALESCE", "COLLATE", "COLLATION", "COLUMN",
-  "COLUMNS", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "COMPRESSION",
-  "CONCURRENTLY", "CONFIGURATION", "CONFLICT", "CONNECTION", "CONSTRAINT",
-  "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", "COPY", "COST",
-  "CREATE_P", "CROSS", "CSV", "CUBE", "CURRENT_P", "CURSOR", "CYCLE",
-  "DATA_P", "DATABASE", "DAY_P", "DAYS_P", "DEALLOCATE", "DEC", "DECADE_P",
-  "DECADES_P", "DECIMAL_P", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE",
-  "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", "DELIMITERS", "DEPENDS",
-  "DESC_P", "DESCRIBE", "DETACH", "DICTIONARY", "DISABLE_P", "DISCARD",
-  "DISTINCT", "DO", "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", "DROP", "EACH",
-  "ELSE", "ENABLE_P", "ENCODING", "ENCRYPTED", "END_P", "ENUM_P", "ESCAPE",
-  "EVENT", "EXCEPT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE",
-  "EXISTS", "EXPLAIN", "EXPORT_P", "EXPORT_STATE", "EXTENSION",
-  "EXTENSIONS", "EXTERNAL", "EXTRACT", "FALSE_P", "FAMILY", "FETCH",
-  "FILTER", "FIRST_P", "FLOAT_P", "FOLLOWING", "FOR", "FORCE", "FOREIGN",
-  "FORWARD", "FREEZE", "FROM", "FULL", "FUNCTION", "FUNCTIONS",
-  "GENERATED", "GLOB", "GLOBAL", "GRANT", "GRANTED", "GROUP_P", "GROUPING",
-  "GROUPING_ID", "GROUPS", "HANDLER", "HAVING", "HEADER_P", "HOLD",
-  "HOUR_P", "HOURS_P", "IDENTITY_P", "IF_P", "IGNORE_P", "ILIKE",
-  "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", "IMPORT_P", "IN_P", "INCLUDE_P",
-  "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS",
-  "INITIALLY", "INLINE_P", "INNER_P", "INOUT", "INPUT_P", "INSENSITIVE",
-  "INSERT", "INSTALL", "INSTEAD", "INT_P", "INTEGER", "INTERSECT",
-  "INTERVAL", "INTO", "INVOKER", "IS", "ISNULL", "ISOLATION", "JOIN",
-  "JSON", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LATERAL_P",
-  "LEADING", "LEAKPROOF", "LEFT", "LEVEL", "LIKE", "LIMIT", "LISTEN",
-  "LOAD", "LOCAL", "LOCATION", "LOCK_P", "LOCKED", "LOGGED", "MACRO",
-  "MAP", "MAPPING", "MATCH", "MATERIALIZED", "MAXVALUE", "METHOD",
-  "MICROSECOND_P", "MICROSECONDS_P", "MILLENNIA_P", "MILLENNIUM_P",
-  "MILLISECOND_P", "MILLISECONDS_P", "MINUTE_P", "MINUTES_P", "MINVALUE",
-  "MODE", "MONTH_P", "MONTHS_P", "MOVE", "NAME_P", "NAMES", "NATIONAL",
-  "NATURAL", "NCHAR", "NEW", "NEXT", "NO", "NONE", "NOT", "NOTHING",
-  "NOTIFY", "NOTNULL", "NOWAIT", "NULL_P", "NULLIF", "NULLS_P", "NUMERIC",
-  "OBJECT_P", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON", "ONLY",
-  "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "ORDINALITY", "OTHERS",
-  "OUT_P", "OUTER_P", "OVER", "OVERLAPS", "OVERLAY", "OVERRIDING", "OWNED",
-  "OWNER", "PARALLEL", "PARSER", "PARTIAL", "PARTITION", "PASSING",
-  "PASSWORD", "PERCENT", "PERSISTENT", "PIVOT", "PIVOT_LONGER",
-  "PIVOT_WIDER", "PLACING", "PLANS", "POLICY", "POSITION", "POSITIONAL",
-  "PRAGMA_P", "PRECEDING", "PRECISION", "PREPARE", "PREPARED", "PRESERVE",
-  "PRIMARY", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROGRAM",
-  "PUBLICATION", "QUALIFY", "QUARTER_P", "QUARTERS_P", "QUOTE", "RANGE",
-  "READ_P", "REAL", "REASSIGN", "RECHECK", "RECURSIVE", "REF",
-  "REFERENCES", "REFERENCING", "REFRESH", "REINDEX", "RELATIVE_P",
-  "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", "RESET",
-  "RESPECT_P", "RESTART", "RESTRICT", "RETURNING", "RETURNS", "REVOKE",
-  "RIGHT", "ROLE", "ROLLBACK", "ROLLUP", "ROW", "ROWS", "RULE", "SAMPLE",
-  "SAVEPOINT", "SCHEMA", "SCHEMAS", "SCOPE", "SCROLL", "SEARCH",
-  "SECOND_P", "SECONDS_P", "SECRET", "SECURITY", "SELECT", "SEMI",
-  "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER", "SESSION", "SET",
-  "SETOF", "SETS", "SHARE", "SHOW", "SIMILAR", "SIMPLE", "SKIP",
-  "SMALLINT", "SNAPSHOT", "SOME", "SQL_P", "STABLE", "STANDALONE_P",
-  "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", "STORAGE",
-  "STORED", "STRICT_P", "STRIP_P", "STRUCT", "SUBSCRIPTION", "SUBSTRING",
-  "SUMMARIZE", "SYMMETRIC", "SYSID", "SYSTEM_P", "TABLE", "TABLES",
-  "TABLESAMPLE", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P",
-  "THEN", "TIES", "TIME", "TIMESTAMP", "TO", "TRAILING", "TRANSACTION",
-  "TRANSFORM", "TREAT", "TRIGGER", "TRIM", "TRUE_P", "TRUNCATE", "TRUSTED",
-  "TRY_CAST", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED",
-  "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNLOGGED",
-  "UNPIVOT", "UNTIL", "UPDATE", "USE_P", "USER", "USING", "VACUUM",
-  "VALID", "VALIDATE", "VALIDATOR", "VALUE_P", "VALUES", "VARCHAR",
-  "VARIABLE_P", "VARIADIC", "VARYING", "VERBOSE", "VERSION_P", "VIEW",
-  "VIEWS", "VIRTUAL", "VOLATILE", "WEEK_P", "WEEKS_P", "WHEN", "WHERE",
-  "WHITESPACE_P", "WINDOW", "WITH", "WITHIN", "WITHOUT", "WORK", "WRAPPER",
-  "WRITE_P", "XML_P", "XMLATTRIBUTES", "XMLCONCAT", "XMLELEMENT",
-  "XMLEXISTS", "XMLFOREST", "XMLNAMESPACES", "XMLPARSE", "XMLPI",
-  "XMLROOT", "XMLSERIALIZE", "XMLTABLE", "YEAR_P", "YEARS_P", "YES_P",
-  "ZONE", "NOT_LA", "NULLS_LA", "WITH_LA", "'<'", "'>'", "'='",
-  "POSTFIXOP", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "UMINUS", "'['",
-  "']'", "'('", "')'", "'.'", "';'", "','", "':'", "'?'", "'$'", "'#'",
-  "'{'", "'}'", "$accept", "stmtblock", "stmtmulti", "stmt",
-  "AlterTableStmt", "alter_identity_column_option_list",
-  "alter_column_default", "alter_identity_column_option",
-  "alter_generic_option_list", "alter_table_cmd", "alter_using",
-  "alter_generic_option_elem", "alter_table_cmds", "alter_generic_options",
-  "opt_set_data", "DeallocateStmt", "qualified_name", "ColId",
-  "ColIdOrString", "Sconst", "indirection", "indirection_el", "attr_name",
-  "ColLabel", "RenameStmt", "opt_column", "InsertStmt", "insert_rest",
-  "insert_target", "opt_by_name_or_position", "opt_conf_expr",
-  "opt_with_clause", "insert_column_item", "set_clause", "opt_or_action",
-  "opt_on_conflict", "index_elem", "returning_clause", "override_kind",
-  "set_target_list", "opt_collate", "opt_class", "insert_column_list",
-  "set_clause_list", "set_clause_list_opt_comma", "index_params",
-  "set_target", "CreateTypeStmt", "opt_enum_val_list", "enum_val_list",
-  "PragmaStmt", "CreateSeqStmt", "OptSeqOptList", "CreateSecretStmt",
-  "opt_secret_name", "opt_persist", "opt_storage_specifier",
-  "UpdateExtensionsStmt", "ExecuteStmt", "execute_param_expr",
-  "execute_param_list", "execute_param_clause", "AlterSeqStmt",
-  "SeqOptList", "opt_with", "NumericOnly", "SeqOptElem", "opt_by",
-  "SignedIconst", "DropSecretStmt", "opt_storage_drop_specifier",
-  "TransactionStmt", "opt_transaction", "opt_transaction_type", "UseStmt",
-  "CreateStmt", "ConstraintAttributeSpec", "def_arg",
-  "OptParenthesizedSeqOptList", "generic_option_arg", "key_action",
-  "ColConstraint", "ColConstraintElem", "GeneratedColumnType",
-  "opt_GeneratedColumnType", "GeneratedConstraintElem",
-  "generic_option_elem", "key_update", "key_actions", "OnCommitOption",
-  "reloptions", "opt_no_inherit", "TableConstraint", "TableLikeOption",
-  "reloption_list", "ExistingIndex", "ConstraintAttr", "OptWith",
-  "definition", "TableLikeOptionList", "generic_option_name",
-  "ConstraintAttributeElem", "columnDef", "def_list", "index_name",
-  "TableElement", "def_elem", "opt_definition", "OptTableElementList",
-  "columnElem", "opt_column_list", "ColQualList", "key_delete",
-  "reloption_elem", "columnList", "columnList_opt_comma", "func_type",
-  "ConstraintElem", "TableElementList", "key_match", "TableLikeClause",
-  "OptTemp", "generated_when", "DropStmt", "drop_type_any_name",
-  "drop_type_name", "any_name_list", "opt_drop_behavior",
-  "drop_type_name_on_any_name", "CreateFunctionStmt",
-  "table_macro_definition", "table_macro_definition_parens",
-  "table_macro_list_internal", "table_macro_list", "macro_definition",
-  "macro_definition_list", "macro_alias", "param_list", "UpdateStmt",
-  "CopyStmt", "copy_database_flag", "copy_from", "copy_delimiter",
-  "copy_generic_opt_arg_list", "opt_using", "opt_as", "opt_program",
-  "copy_options", "copy_generic_opt_arg", "copy_generic_opt_elem",
-  "opt_oids", "copy_opt_list", "opt_binary", "copy_opt_item",
-  "copy_generic_opt_arg_list_item", "copy_file_name",
-  "copy_generic_opt_list", "SelectStmt", "select_with_parens",
-  "select_no_parens", "select_clause", "opt_select", "simple_select",
-  "value_or_values", "pivot_keyword", "unpivot_keyword",
-  "pivot_column_entry", "pivot_column_list_internal", "pivot_column_list",
-  "with_clause", "cte_list", "common_table_expr", "opt_materialized",
-  "into_clause", "OptTempTableName", "opt_table", "all_or_distinct",
-  "by_name", "distinct_clause", "opt_all_clause", "opt_ignore_nulls",
-  "opt_sort_clause", "sort_clause", "sortby_list", "sortby",
-  "opt_asc_desc", "opt_nulls_order", "select_limit", "opt_select_limit",
-  "limit_clause", "offset_clause", "sample_value", "sample_count",
-  "sample_clause", "opt_sample_func", "tablesample_entry",
-  "tablesample_clause", "opt_tablesample_clause", "opt_repeatable_clause",
-  "select_limit_value", "select_offset_value", "select_fetch_first_value",
-  "I_or_F_const", "row_or_rows", "first_or_next", "group_clause",
-  "group_by_list", "group_by_list_opt_comma", "group_by_item",
-  "empty_grouping_set", "rollup_clause", "cube_clause",
-  "grouping_sets_clause", "grouping_or_grouping_id", "having_clause",
-  "qualify_clause", "for_locking_clause", "opt_for_locking_clause",
-  "for_locking_items", "for_locking_item", "for_locking_strength",
-  "locked_rels_list", "opt_nowait_or_skip", "values_clause",
-  "values_clause_opt_comma", "from_clause", "from_list",
-  "from_list_opt_comma", "alias_prefix_colon_clause", "table_ref",
-  "opt_pivot_group_by", "opt_include_nulls", "single_pivot_value",
-  "pivot_header", "pivot_value", "pivot_value_list", "unpivot_header",
-  "unpivot_value", "unpivot_value_list", "joined_table", "alias_clause",
-  "opt_alias_clause", "func_alias_clause", "join_type", "join_outer",
-  "join_qual", "relation_expr", "func_table", "rowsfrom_item",
-  "rowsfrom_list", "opt_col_def_list", "opt_ordinality", "where_clause",
-  "TableFuncElementList", "TableFuncElement", "opt_collate_clause",
-  "colid_type_list", "RowOrStruct", "opt_Typename", "Typename",
-  "qualified_typename", "opt_array_bounds", "SimpleTypename",
-  "ConstTypename", "GenericType", "opt_type_modifiers", "Numeric",
-  "opt_float", "Bit", "ConstBit", "BitWithLength", "BitWithoutLength",
-  "Character", "ConstCharacter", "CharacterWithLength",
-  "CharacterWithoutLength", "character", "opt_varying", "ConstDatetime",
-  "ConstInterval", "opt_timezone", "year_keyword", "month_keyword",
-  "day_keyword", "hour_keyword", "minute_keyword", "second_keyword",
-  "millisecond_keyword", "microsecond_keyword", "week_keyword",
-  "quarter_keyword", "decade_keyword", "century_keyword",
-  "millennium_keyword", "opt_interval", "a_expr", "b_expr", "c_expr",
-  "d_expr", "indirection_expr_or_a_expr", "param_expr", "indirection_expr",
-  "list_expr", "struct_expr", "map_expr", "func_application", "func_expr",
-  "func_expr_windowless", "func_expr_common_subexpr",
-  "list_comprehension_lhs", "list_comprehension", "within_group_clause",
-  "filter_clause", "export_clause", "window_clause",
-  "window_definition_list", "window_definition", "over_clause",
-  "window_specification", "opt_existing_window_name",
-  "opt_partition_clause", "opt_frame_clause", "frame_extent",
-  "frame_bound", "opt_window_exclusion_clause", "qualified_row", "row",
-  "dict_arg", "dict_arguments", "dict_arguments_opt_comma", "map_arg",
-  "map_arguments", "map_arguments_opt_comma",
-  "opt_map_arguments_opt_comma", "sub_type", "all_Op", "MathOp", "qual_Op",
-  "qual_all_Op", "subquery_Op", "any_operator", "c_expr_list",
-  "c_expr_list_opt_comma", "expr_list", "expr_list_opt_comma",
-  "opt_expr_list_opt_comma", "func_arg_list", "func_arg_expr", "type_list",
-  "extract_list", "extract_arg", "overlay_list", "overlay_placing",
-  "position_list", "substr_list", "substr_from", "substr_for", "trim_list",
-  "in_expr", "case_expr", "when_clause_list", "when_clause",
-  "case_default", "case_arg", "columnrefList", "columnref",
-  "columnref_opt_indirection", "opt_slice_bound", "opt_indirection",
-  "opt_func_arguments", "extended_indirection_el",
-  "opt_extended_indirection", "opt_asymmetric",
-  "opt_target_list_opt_comma", "target_list", "target_list_opt_comma",
-  "target_el", "except_list", "except_name", "except_name_list",
-  "except_name_list_opt_comma", "opt_except_list", "replace_list_el",
-  "replace_list", "replace_list_opt_comma", "opt_replace_list",
-  "rename_list_el", "rename_list", "rename_list_opt_comma",
-  "opt_rename_list", "qualified_name_list", "name_list",
-  "name_list_opt_comma", "name_list_opt_comma_opt_bracket", "name",
-  "func_name", "AexprConst", "Iconst", "type_function_name",
-  "function_name_token", "type_name_token", "any_name", "attrs",
-  "opt_name_list", "param_name", "ColLabelOrString", "PrepareStmt",
-  "prep_type_clause", "PreparableStmt", "CreateSchemaStmt",
-  "OptSchemaEltList", "schema_stmt", "IndexStmt", "access_method",
-  "access_method_clause", "opt_concurrently", "opt_index_name",
-  "opt_reloptions", "opt_unique", "AlterObjectSchemaStmt",
-  "CheckPointStmt", "opt_col_id", "CommentOnStmt", "comment_value",
-  "comment_on_type_any_name", "ExportStmt", "ImportStmt", "ExplainStmt",
-  "opt_verbose", "explain_option_arg", "ExplainableStmt",
-  "NonReservedWord", "NonReservedWord_or_Sconst", "explain_option_list",
-  "analyze_keyword", "opt_boolean_or_string", "explain_option_elem",
-  "explain_option_name", "VariableSetStmt", "set_rest", "generic_set",
-  "var_value", "zone_value", "var_list", "LoadStmt", "opt_force",
-  "file_name", "opt_ext_version", "VacuumStmt", "vacuum_option_elem",
-  "opt_full", "vacuum_option_list", "opt_freeze", "DeleteStmt",
-  "relation_expr_opt_alias", "where_or_current_clause", "using_clause",
-  "AnalyzeStmt", "AttachStmt", "DetachStmt", "opt_database",
-  "opt_database_alias", "VariableResetStmt", "generic_reset", "reset_rest",
-  "VariableShowStmt", "describe_or_desc", "show_or_describe", "opt_tables",
-  "var_name", "CallStmt", "ViewStmt", "opt_check_option", "CreateAsStmt",
-  "opt_with_data", "create_as_target", "unreserved_keyword",
-  "col_name_keyword", "func_name_keyword", "type_name_keyword",
-  "other_keyword", "type_func_name_keyword", "reserved_keyword", 0
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   token YYLEX-NUM.  */
-static const yytype_uint16 yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   521,   522,   523,   524,
-     525,   526,   527,   528,   529,   530,   531,   532,   533,   534,
-     535,   536,   537,   538,   539,   540,   541,   542,   543,   544,
-     545,   546,   547,   548,   549,   550,   551,   552,   553,   554,
-     555,   556,   557,   558,   559,   560,   561,   562,   563,   564,
-     565,   566,   567,   568,   569,   570,   571,   572,   573,   574,
-     575,   576,   577,   578,   579,   580,   581,   582,   583,   584,
-     585,   586,   587,   588,   589,   590,   591,   592,   593,   594,
-     595,   596,   597,   598,   599,   600,   601,   602,   603,   604,
-     605,   606,   607,   608,   609,   610,   611,   612,   613,   614,
-     615,   616,   617,   618,   619,   620,   621,   622,   623,   624,
-     625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
-     635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
-     645,   646,   647,   648,   649,   650,   651,   652,   653,   654,
-     655,   656,   657,   658,   659,   660,   661,   662,   663,   664,
-     665,   666,   667,   668,   669,   670,   671,   672,   673,   674,
-     675,   676,   677,   678,   679,   680,   681,   682,   683,   684,
-     685,   686,   687,   688,   689,   690,   691,   692,   693,   694,
-     695,   696,   697,   698,   699,   700,   701,   702,   703,   704,
-     705,   706,   707,   708,   709,   710,   711,   712,   713,   714,
-     715,   716,   717,   718,   719,   720,   721,   722,   723,   724,
-     725,   726,   727,   728,   729,   730,   731,   732,   733,   734,
-     735,   736,   737,   738,   739,   740,   741,   742,   743,   744,
-     745,   746,   747,   748,   749,   750,   751,   752,   753,   754,
-     755,   756,   757,   758,   759,    60,    62,    61,   760,    43,
-      45,    42,    47,    37,    94,   761,    91,    93,    40,    41,
-      46,    59,    44,    58,    63,    36,    35,   123,   125
-};
-# endif
-
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint16 yyr1[] =
-{
-       0,   529,   530,   531,   531,   532,   532,   532,   532,   532,
-     532,   532,   532,   532,   532,   532,   532,   532,   532,   532,
-     532,   532,   532,   532,   532,   532,   532,   532,   532,   532,
-     532,   532,   532,   532,   532,   532,   532,   532,   532,   532,
-     532,   532,   532,   532,   532,   532,   532,   533,   533,   533,
-     533,   533,   533,   533,   533,   534,   534,   535,   535,   536,
-     536,   536,   536,   537,   537,   538,   538,   538,   538,   538,
-     538,   538,   538,   538,   538,   538,   538,   538,   538,   538,
-     538,   538,   538,   538,   538,   538,   538,   538,   538,   538,
-     538,   538,   538,   538,   539,   539,   540,   540,   540,   540,
-     541,   541,   542,   543,   543,   543,   544,   544,   544,   544,
-     545,   545,   546,   546,   546,   547,   547,   548,   549,   549,
-     550,   551,   552,   552,   552,   552,   553,   553,   553,   553,
-     553,   553,   553,   553,   553,   553,   553,   553,   553,   554,
-     554,   555,   556,   556,   556,   556,   556,   557,   557,   558,
-     558,   558,   559,   559,   559,   560,   560,   561,   562,   562,
-     563,   563,   563,   564,   564,   564,   565,   565,   565,   566,
-     566,   567,   567,   568,   568,   569,   569,   570,   570,   571,
-     571,   572,   572,   573,   573,   574,   574,   575,   576,   576,
-     576,   577,   577,   578,   578,   579,   579,   579,   580,   580,
-     580,   581,   581,   582,   582,   582,   583,   583,   584,   584,
-     584,   585,   585,   586,   587,   587,   587,   588,   588,   589,
-     589,   590,   590,   591,   591,   592,   592,   593,   593,   593,
-     594,   594,   594,   594,   595,   595,   595,   595,   595,   595,
-     595,   595,   595,   595,   595,   595,   595,   595,   596,   596,
-     597,   597,   597,   598,   598,   599,   599,   600,   600,   600,
-     600,   600,   600,   601,   601,   601,   602,   602,   602,   603,
-     604,   604,   604,   605,   605,   606,   606,   606,   606,   606,
-     606,   607,   607,   608,   609,   609,   609,   609,   609,   610,
-     610,   610,   610,   611,   611,   611,   611,   611,   611,   611,
-     611,   612,   612,   613,   613,   614,   614,   614,   615,   616,
-     617,   617,   617,   617,   617,   618,   618,   618,   618,   619,
-     620,   620,   621,   621,   622,   622,   622,   622,   622,   622,
-     622,   622,   623,   623,   624,   625,   625,   625,   625,   626,
-     626,   626,   626,   627,   628,   628,   628,   629,   630,   630,
-     630,   630,   630,   630,   631,   631,   632,   632,   633,   634,
-     634,   634,   635,   635,   636,   636,   637,   637,   637,   638,
-     639,   639,   640,   640,   641,   642,   642,   642,   642,   643,
-     643,   644,   644,   645,   645,   645,   646,   646,   646,   646,
-     646,   646,   647,   647,   648,   648,   648,   648,   649,   650,
-     650,   650,   650,   650,   650,   650,   650,   651,   651,   652,
-     652,   652,   652,   652,   652,   653,   653,   653,   653,   653,
-     653,   653,   653,   653,   653,   653,   653,   653,   653,   653,
-     653,   653,   653,   654,   654,   654,   654,   654,   654,   655,
-     655,   656,   656,   656,   657,   657,   657,   658,   658,   658,
-     658,   658,   658,   659,   660,   661,   661,   662,   662,   663,
-     664,   664,   665,   665,   666,   666,   667,   668,   668,   668,
-     669,   669,   669,   670,   670,   671,   671,   672,   672,   673,
-     673,   674,   674,   675,   675,   676,   676,   677,   677,   677,
-     677,   677,   677,   677,   677,   678,   679,   679,   680,   680,
-     681,   681,   682,   682,   682,   682,   682,   682,   682,   682,
-     682,   682,   682,   682,   682,   682,   682,   682,   683,   684,
-     684,   684,   684,   684,   685,   685,   686,   686,   687,   687,
-     687,   688,   688,   688,   688,   688,   688,   688,   688,   689,
-     689,   690,   690,   691,   691,   691,   691,   691,   691,   691,
-     691,   691,   691,   691,   691,   691,   691,   691,   691,   691,
-     691,   691,   692,   692,   693,   693,   694,   694,   695,   695,
-     695,   696,   696,   697,   697,   698,   698,   698,   699,   699,
-     700,   701,   701,   701,   702,   702,   703,   703,   703,   703,
-     703,   703,   703,   703,   703,   704,   704,   705,   705,   705,
-     706,   707,   707,   708,   708,   709,   709,   709,   710,   710,
-     711,   711,   712,   712,   713,   713,   714,   714,   714,   715,
-     715,   715,   716,   716,   716,   716,   717,   717,   718,   718,
-     718,   718,   719,   719,   720,   720,   720,   721,   721,   721,
-     721,   722,   722,   723,   723,   724,   724,   724,   724,   725,
-     726,   726,   727,   727,   728,   728,   728,   728,   728,   729,
-     730,   730,   730,   731,   731,   732,   732,   733,   733,   734,
-     734,   734,   735,   735,   736,   736,   737,   737,   737,   737,
-     737,   738,   739,   740,   741,   742,   742,   743,   743,   744,
-     744,   745,   745,   746,   746,   747,   747,   748,   749,   749,
-     749,   749,   750,   750,   751,   751,   751,   752,   752,   753,
-     753,   754,   754,   755,   755,   756,   756,   757,   758,   758,
-     758,   758,   758,   758,   758,   758,   758,   758,   758,   758,
-     758,   758,   759,   759,   760,   760,   760,   761,   761,   762,
-     762,   762,   763,   763,   764,   764,   765,   765,   766,   767,
-     767,   768,   768,   768,   768,   768,   768,   768,   768,   768,
-     768,   768,   769,   769,   769,   769,   770,   770,   771,   771,
-     771,   771,   771,   772,   772,   772,   772,   772,   772,   773,
-     773,   774,   774,   775,   775,   775,   775,   776,   776,   777,
-     778,   778,   779,   779,   780,   780,   781,   781,   782,   782,
-     783,   784,   784,   785,   785,   786,   786,   787,   787,   788,
-     788,   788,   788,   788,   788,   788,   788,   788,   788,   789,
-     789,   790,   790,   790,   791,   791,   791,   791,   791,   791,
-     791,   792,   792,   792,   792,   793,   794,   794,   795,   795,
-     795,   795,   795,   795,   795,   795,   795,   795,   795,   796,
-     796,   797,   797,   798,   798,   799,   800,   801,   801,   802,
-     802,   803,   804,   805,   805,   805,   805,   805,   805,   806,
-     806,   807,   807,   807,   807,   808,   809,   809,   809,   810,
-     810,   811,   811,   812,   812,   813,   813,   814,   814,   815,
-     815,   816,   816,   817,   817,   818,   818,   819,   819,   820,
-     820,   821,   821,   822,   822,   823,   823,   823,   823,   823,
-     823,   823,   823,   823,   823,   823,   823,   823,   823,   823,
-     823,   823,   823,   823,   823,   823,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   825,   825,   825,
-     825,   825,   825,   825,   825,   825,   825,   825,   825,   825,
-     825,   825,   825,   825,   825,   825,   825,   825,   825,   825,
-     825,   825,   826,   826,   827,   827,   827,   827,   827,   827,
-     828,   828,   828,   829,   829,   829,   830,   830,   830,   830,
-     830,   830,   830,   830,   830,   830,   831,   832,   833,   834,
-     834,   834,   834,   834,   834,   834,   835,   835,   836,   836,
-     837,   837,   837,   837,   837,   837,   837,   837,   837,   837,
-     837,   837,   837,   837,   838,   839,   839,   840,   840,   841,
-     841,   841,   842,   842,   843,   843,   844,   844,   845,   846,
-     846,   846,   847,   848,   848,   849,   849,   850,   850,   850,
-     850,   851,   851,   852,   852,   852,   852,   852,   853,   853,
-     853,   853,   853,   854,   854,   855,   855,   856,   857,   857,
-     858,   858,   859,   860,   860,   861,   861,   862,   862,   863,
-     863,   863,   864,   864,   865,   865,   865,   865,   865,   865,
-     865,   865,   865,   865,   865,   865,   865,   865,   866,   866,
-     867,   867,   868,   868,   868,   868,   868,   868,   868,   868,
-     869,   869,   870,   870,   871,   871,   872,   872,   873,   873,
-     874,   874,   875,   875,   876,   876,   876,   877,   877,   878,
-     878,   879,   879,   879,   879,   879,   879,   879,   879,   879,
-     879,   879,   879,   879,   879,   879,   880,   880,   881,   882,
-     882,   883,   883,   883,   883,   883,   883,   884,   885,   886,
-     886,   886,   887,   887,   887,   887,   888,   889,   889,   890,
-     891,   891,   892,   892,   893,   893,   894,   895,   895,   550,
-     550,   550,   550,   896,   896,   897,   897,   898,   898,   898,
-     899,   899,   899,   899,   899,   900,   900,   901,   901,   902,
-     902,   903,   903,   904,   904,   905,   905,   905,   905,   906,
-     906,   907,   907,   908,   908,   909,   909,   910,   910,   911,
-     912,   912,   913,   913,   914,   914,   914,   915,   916,   916,
-     917,   917,   918,   918,   918,   919,   919,   920,   920,   921,
-     921,   922,   922,   923,   924,   924,   925,   925,   925,   925,
-     925,   925,   925,   925,   925,   925,   925,   925,   925,   925,
-     926,   927,   927,   927,   928,   928,   928,   929,   929,   929,
-     930,   930,   931,   931,   932,   932,   933,   934,   934,   935,
-     936,   936,   937,   937,   937,   937,   937,   937,   938,   938,
-     938,   939,   939,   940,   940,   940,   940,   941,   941,   942,
-     943,   943,   944,   944,   945,   945,   946,   946,   947,   947,
-     948,   948,   948,   948,   948,   948,   949,   949,   950,   950,
-     951,   951,   952,   952,   953,   953,   953,   953,   953,   953,
-     953,   953,   953,   953,   954,   954,   955,   956,   956,   956,
-     956,   957,   957,   958,   958,   958,   959,   959,   959,   959,
-     959,   959,   959,   959,   959,   959,   959,   959,   959,   959,
-     959,   959,   959,   959,   959,   959,   959,   959,   959,   959,
-     959,   959,   959,   959,   959,   959,   959,   960,   960,   960,
-     961,   961,   962,   962,   963,   963,   964,   964,   964,   964,
-     965,   966,   966,   967,   967,   967,   967,   967,   968,   968,
-     968,   968,   969,   969,   970,   971,   971,   971,   971,   971,
-     971,   971,   972,   972,   973,   973,   973,   973,   974,   974,
-     975,   975,   976,   976,   976,   977,   977,   977,   977,   977,
-     978,   978,   978,   978,   978,   979,   979,   980,   980,   981,
-     981,   982,   982,   983,   983,   983,   984,   984,   985,   985,
-     986,   986,   987,   987,   988,   988,   988,   989,   989,   990,
-     990,   991,   991,   991,   991,   991,   992,   992,   993,   993,
-     993,   994,   994,   994,   994,   994,   994,   994,   994,   995,
-     995,   996,   996,   997,   997,   998,   998,   999,  1000,  1000,
-    1000,  1000,  1000,  1001,  1001,  1001,  1001,  1002,  1002,  1002,
-    1003,  1003,  1003,  1004,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,
-    1005,  1005,  1005,  1005,  1005,  1005,  1005,  1005,  1006,  1006,
-    1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,
-    1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,
-    1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,
-    1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,
-    1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,  1006,
-    1006,  1006,  1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,
-    1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,
-    1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,  1007,
-    1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,
-    1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,
-    1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,  1008,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,  1009,
-    1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,
-    1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,
-    1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,  1010,
-    1010,  1010,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,  1011,
-    1011,  1011,  1011,  1011,  1011,  1011,  1011
-};
-
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const yytype_uint8 yyr2[] =
-{
-       0,     2,     1,     3,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     0,     4,     6,     4,
-       6,     4,     6,     4,     6,     1,     2,     3,     2,     1,
-       3,     2,     3,     1,     3,     2,     5,     3,     6,     4,
-       6,     6,     6,     5,     5,     6,     9,     4,     5,     7,
-       6,     4,     8,     4,     2,     4,     3,     6,     4,     2,
-       2,     2,     2,     1,     2,     0,     1,     2,     2,     2,
-       1,     3,     4,     2,     1,     0,     2,     3,     2,     3,
-       1,     2,     1,     1,     1,     1,     1,     1,     1,     2,
-       2,     1,     1,     1,     1,     1,     6,     6,     8,     6,
-       8,     6,     8,     6,     8,     8,    10,     8,    10,     1,
-       0,     9,     1,     4,     4,     7,     2,     1,     3,     2,
-       2,     0,     4,     3,     0,     1,     0,     2,     3,     5,
-       2,     2,     0,     8,     5,     0,     5,     5,     7,     2,
-       0,     1,     1,     1,     3,     2,     0,     1,     0,     1,
-       3,     1,     3,     1,     2,     1,     3,     2,     6,     8,
-       5,     1,     0,     1,     3,     2,     4,     5,     5,     8,
-       7,     1,     0,     8,    11,    10,     0,     1,     0,     1,
-       1,     0,     2,     4,     3,     9,    12,     1,     3,     1,
-       3,     3,     0,     4,     6,     1,     2,     1,     1,     0,
-       1,     2,     2,     1,     2,     2,     1,     2,     3,     2,
-       2,     2,     2,     3,     3,     3,     1,     3,     1,     0,
-       1,     2,     2,     5,     7,     0,     2,     2,     3,     3,
-       2,     2,     2,     1,     1,     0,     2,     2,     0,     2,
-       9,    12,    11,     0,     2,     1,     1,     1,     1,     1,
-       1,     3,     0,     1,     2,     1,     1,     2,     2,     3,
-       1,     1,     2,     2,     1,     2,     3,     5,     3,     2,
-       5,     1,     1,     1,     0,     5,     7,     5,     2,     3,
-       1,     1,     2,     2,     0,     3,     4,     4,     0,     3,
-       2,     0,     3,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     3,     3,     1,     2,     2,     2,     2,
-       2,     2,     0,     3,     3,     3,     0,     1,     2,     1,
-       2,     2,     2,     2,     3,     4,     1,     3,     1,     1,
-       1,     1,     3,     1,     2,     0,     1,     2,     0,     1,
-       3,     0,     2,     0,     3,     3,     1,     5,     3,     1,
-       3,     1,     2,     1,     4,     5,     5,     6,     3,     7,
-       4,    11,     1,     3,     2,     2,     2,     0,     3,     1,
-       1,     2,     2,     2,     2,     1,     0,     1,     2,     6,
-       4,     6,     4,     6,     8,     1,     1,     1,     1,     2,
-       1,     2,     1,     2,     1,     1,     1,     1,     3,     3,
-       3,     3,     1,     2,     2,     1,     3,     1,     1,     1,
-       3,     1,     1,     0,     1,     1,     1,     5,     8,     7,
-       5,     8,     7,     4,     4,     1,     3,     1,     1,     3,
-       1,     3,     1,     1,     2,     3,     8,    11,     9,     7,
-       0,     3,     3,     1,     1,     3,     0,     1,     3,     1,
-       0,     1,     0,     1,     0,     1,     3,     1,     1,     1,
-       1,     3,     1,     1,     0,     2,     2,     0,     2,     0,
-       1,     0,     1,     1,     1,     3,     3,     1,     1,     3,
-       3,     3,     3,     3,     3,     4,     3,     2,     1,     1,
-       1,     1,     3,     1,     1,     3,     1,     1,     3,     3,
-       3,     1,     2,     4,     4,     2,     3,     5,     5,     1,
-       1,     3,     0,    11,    11,    10,    12,     1,     2,     5,
-       4,     4,     4,     4,     7,     5,     4,     7,     6,     9,
-       9,     4,     1,     1,     1,     1,     1,     1,     1,     5,
-       1,     1,     3,     1,     2,     2,     2,     3,     1,     3,
-       7,     1,     2,     0,     2,     0,     3,     3,     4,     4,
-       4,     4,     3,     2,     1,     1,     0,     1,     1,     0,
-       2,     1,     5,     1,     0,     2,     2,     0,     1,     0,
-       3,     5,     1,     3,     4,     3,     1,     1,     0,     2,
-       2,     0,     2,     2,     1,     1,     1,     0,     2,     4,
-       5,     4,     2,     3,     1,     1,     1,     2,     2,     1,
-       2,     3,     0,     1,     0,     5,     1,     4,     6,     2,
-       1,     0,     4,     0,     1,     1,     2,     2,     2,     1,
-       1,     2,     2,     1,     1,     1,     1,     1,     1,     3,
-       3,     0,     1,     3,     1,     2,     1,     1,     1,     1,
-       1,     2,     4,     4,     5,     1,     1,     2,     0,     2,
-       0,     1,     3,     1,     0,     1,     2,     3,     2,     4,
-       2,     3,     2,     0,     1,     2,     0,     4,     5,     1,
-       2,     2,     0,     1,     3,     1,     2,     2,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     1,     4,     4,
-       9,     9,     3,     0,     2,     2,     0,     5,     3,     1,
-       1,     3,     5,     3,     1,     2,     1,     3,     5,     1,
-       2,     3,     4,     5,     4,     5,     4,     6,     5,     4,
-       5,     5,     5,     2,     4,     1,     1,     0,     1,     4,
-       5,     4,     0,     2,     2,     2,     1,     1,     1,     1,
-       0,     4,     2,     1,     2,     2,     4,     2,     6,     2,
-       1,     3,     4,     0,     2,     0,     2,     0,     1,     3,
-       3,     2,     0,     2,     4,     1,     1,     1,     0,     2,
-       3,     5,     6,     2,     3,     1,     5,     5,     5,     3,
-       3,     3,     4,     0,     1,     1,     1,     1,     1,     2,
-       4,     1,     1,     1,     1,     2,     3,     0,     1,     1,
-       1,     1,     1,     2,     2,     2,     2,     2,     1,     3,
-       0,     1,     1,     1,     1,     5,     2,     1,     1,     1,
-       1,     4,     1,     2,     2,     1,     3,     3,     2,     1,
-       0,     5,     2,     5,     2,     1,     3,     3,     0,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     3,     3,
-       3,     3,     3,     3,     3,     0,     1,     3,     3,     5,
-       2,     2,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     2,     2,     3,
-       3,     2,     2,     3,     3,     5,     4,     6,     3,     5,
-       4,     6,     4,     6,     5,     7,     3,     2,     4,     3,
-       2,     3,     3,     3,     3,     4,     3,     4,     3,     4,
-       5,     6,     6,     7,     6,     7,     6,     7,     3,     4,
-       4,     6,     1,     5,     4,     4,     6,     1,     3,     2,
-       2,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     2,     2,     5,     6,
-       6,     7,     1,     2,     1,     1,     1,     2,     2,     4,
-       3,     1,     1,     1,     1,     2,     1,     1,     1,     1,
-       1,     1,     1,     2,     4,     2,     3,     3,     4,     3,
-       5,     6,     7,     9,     7,     7,     5,     1,     1,     1,
-       5,     6,     6,     4,     4,     4,     4,     6,     5,     5,
-       5,     4,     6,     4,     1,     7,     9,     5,     0,     5,
-       4,     0,     1,     0,     2,     0,     1,     3,     3,     2,
-       2,     0,     6,     1,     0,     3,     0,     3,     3,     3,
-       0,     1,     4,     2,     2,     2,     2,     2,     3,     2,
-       2,     3,     0,     4,     3,     1,     5,     3,     1,     3,
-       1,     2,     3,     1,     3,     1,     2,     1,     0,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     4,
-       1,     4,     1,     4,     1,     2,     1,     2,     1,     2,
-       1,     3,     1,     3,     1,     2,     1,     3,     1,     2,
-       1,     0,     1,     3,     1,     3,     3,     1,     3,     3,
-       0,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     4,     3,     2,     3,
-       0,     3,     3,     2,     2,     1,     0,     2,     2,     3,
-       2,     1,     1,     3,     1,     1,     5,     1,     2,     4,
-       2,     0,     1,     0,     1,     3,     1,     1,     2,     3,
-       5,     7,     7,     1,     0,     0,     2,     0,     2,     3,
-       3,     3,     5,     7,     7,     0,     2,     1,     0,     1,
-       0,     1,     3,     1,     2,     3,     2,     1,     3,     4,
-       2,     1,     3,     1,     3,     1,     2,     1,     0,     3,
-       1,     3,     1,     2,     4,     2,     0,     3,     1,     3,
-       1,     2,     4,     2,     0,     1,     3,     1,     3,     1,
-       2,     1,     3,     1,     1,     2,     1,     1,     2,     1,
-       1,     2,     7,     2,     5,     3,     3,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     2,     2,     3,     3,     0,     1,     1,     1,     5,
-       3,     0,     1,     1,     1,     1,     1,     1,     4,     7,
-       6,     2,     0,     1,     1,     1,     1,    13,    16,     1,
-       2,     0,     1,     0,     1,     0,     2,     0,     1,     0,
-       6,     8,     6,     8,     6,     8,     3,     2,     1,     0,
-       6,     6,     1,     1,     1,     1,     1,     1,     2,     1,
-       1,     1,     1,     1,     4,     6,     3,     2,     4,     3,
-       5,     1,     0,     1,     1,     0,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     3,     1,     1,     1,     1,     1,     1,
-       2,     1,     1,     2,     3,     3,     3,     3,     1,     3,
-       3,     2,     3,     3,     1,     1,     1,     3,     5,     1,
-       1,     1,     1,     3,     2,     4,     6,     6,     0,     1,
-       1,     1,     0,     2,     2,     4,     6,     5,     4,     6,
-       1,     1,     1,     1,     1,     1,     0,     1,     3,     1,
-       0,     7,     3,     1,     2,     3,     2,     0,     2,     0,
-       2,     4,     5,     8,     2,     3,     5,     1,     0,     2,
-       0,     2,     3,     3,     3,     3,     1,     1,     1,     2,
-       3,     2,     2,     2,     2,     3,     4,     3,     1,     1,
-       1,     1,     1,     1,     0,     1,     3,     2,     9,    12,
-      11,    12,    14,     3,     4,     4,     0,     7,    10,     9,
-       2,     3,     0,     4,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1
-};
-
-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-   means the default is an error.  */
-static const yytype_uint16 yydefact[] =
-{
-     156,   265,     0,  1435,  1434,  1508,   265,     0,  1369,     0,
-     265,   501,   406,     0,  1530,  1529,     0,   208,   265,     0,
-     156,     0,  1469,     0,     0,     0,   564,   567,   565,     0,
-       0,     0,   265,   604,     0,  1531,   265,     0,     0,   596,
-     566,     0,  1486,     0,     0,     0,     0,     0,     2,     4,
-       7,    21,    35,    31,     0,    20,    33,    18,    17,    38,
-      26,     6,    24,    37,    40,    19,    25,    15,    39,    13,
-      36,   540,   526,   609,   539,     0,     0,   155,   709,   547,
-      34,    16,    30,     5,    11,    12,    28,    29,    27,  1392,
-      43,    32,     0,    41,    22,     8,     9,    23,    42,    44,
-    1532,  1528,    10,    45,    14,   264,   263,   257,     0,     0,
-       0,     0,     0,  1507,     0,     0,   268,   112,  1554,  1555,
-    1556,  1557,  1558,  1559,  1560,  1561,  1562,  1563,  1564,  1932,
-    1565,  1566,  1567,  1568,  1569,  1933,  1570,  1571,  1572,  1878,
-    1879,  1934,  1880,  1881,  1573,  1574,  1575,  1576,  1577,  1578,
-    1579,  1580,  1581,  1582,  1882,  1883,  1583,  1584,  1585,  1586,
-    1587,  1884,  1935,  1885,  1588,  1589,  1590,  1591,  1592,  1936,
-    1593,  1594,  1595,  1596,  1597,  1598,  1599,  1600,  1601,  1937,
-    1602,  1603,  1604,  1605,  1606,  1607,  1608,  1609,  1610,  1611,
-    1886,  1612,  1613,  1887,  1614,  1615,  1616,  1617,  1618,  1619,
-    1620,  1621,  1622,  1623,  1624,  1625,  1626,  1627,  1628,  1629,
-    1630,  1631,  1632,  1633,  1634,  1635,  1636,  1637,  1638,  1639,
-    1640,  1888,  1641,  1642,  1643,  1644,  1645,  1646,  1889,  1647,
-    1648,  1649,  1890,  1650,  1651,  1652,  1938,  1939,  1653,  1654,
-    1891,  1941,  1655,  1656,  1892,  1893,  1657,  1658,  1659,  1660,
-    1661,  1662,  1663,  1664,  1665,  1942,  1666,  1667,  1668,  1669,
-    1670,  1671,  1672,  1673,  1674,  1675,  1676,  1677,  1943,  1894,
-    1678,  1679,  1680,  1681,  1682,  1895,  1896,  1897,  1683,  1944,
-    1945,  1684,  1946,  1685,  1686,  1687,  1688,  1689,  1690,  1691,
-    1947,  1692,  1948,  1693,  1694,  1695,  1696,  1697,  1698,  1699,
-    1700,  1898,  1701,  1702,  1703,  1704,  1705,  1706,  1707,  1708,
-    1709,  1710,  1711,  1712,  1713,  1714,  1715,  1716,  1717,  1718,
-    1719,  1720,  1899,  1950,  1900,  1721,  1722,  1723,  1901,  1724,
-    1725,  1951,  1726,  1902,  1727,  1903,  1728,  1729,  1730,  1731,
-    1732,  1733,  1734,  1735,  1736,  1737,  1904,  1952,  1738,  1953,
-    1905,  1739,  1740,  1741,  1742,  1743,  1744,  1745,  1746,  1747,
-    1748,  1749,  1750,  1751,  1906,  1954,  1752,  1753,  1907,  1754,
-    1755,  1756,  1757,  1758,  1759,  1760,  1761,  1762,  1763,  1764,
-    1765,  1766,  1767,  1908,  1768,  1769,  1770,  1771,  1772,  1773,
-    1774,  1775,  1776,  1777,  1778,  1779,  1780,  1781,  1782,  1783,
-    1784,  1785,  1786,  1955,  1787,  1788,  1789,  1909,  1790,  1791,
-    1792,  1793,  1794,  1795,  1796,  1797,  1798,  1799,  1800,  1801,
-    1802,  1803,  1804,  1805,  1806,  1807,  1808,  1910,  1809,  1810,
-    1956,  1811,  1812,  1911,  1813,  1814,  1815,  1816,  1817,  1818,
-    1819,  1820,  1821,  1822,  1823,  1824,  1825,  1912,  1826,  1913,
-    1827,  1828,  1829,  1958,  1830,  1831,  1832,  1833,  1834,  1835,
-    1914,  1915,  1836,  1837,  1916,  1838,  1917,  1839,  1840,  1918,
-    1841,  1842,  1843,  1844,  1845,  1846,  1847,  1848,  1849,  1850,
-    1851,  1852,  1853,  1854,  1855,  1856,  1857,  1919,  1920,  1858,
-    1859,  1959,  1860,  1861,  1862,  1863,  1864,  1865,  1866,  1867,
-    1868,  1869,  1870,  1871,  1872,  1873,  1921,  1922,  1923,  1924,
-    1925,  1926,  1927,  1928,  1929,  1930,  1931,  1874,  1875,  1876,
-    1877,     0,  1537,     0,  1294,   113,   114,  1316,   112,  1891,
-    1898,  1912,  1368,  1367,   113,     0,   260,   500,     0,     0,
-       0,     0,     0,     0,   210,     0,   400,   399,     0,  1358,
-     405,     0,     0,     0,   116,   108,  1754,   115,  1293,   106,
-     122,  2102,  2103,  2104,  2105,  1989,  2106,  2107,  2108,  2109,
-    1990,  2110,  1991,  1992,  1993,  1994,  1995,  1996,  2111,  2112,
-    2113,  1998,  1997,  2114,  1999,  2115,  2000,  2116,  2001,  2002,
-    2117,  2118,  2003,  1608,  2004,  2005,  2119,  2120,  2121,  2122,
-    2123,  2124,  2125,  2126,  2127,  2006,  2007,  2128,  2129,  2008,
-    2130,  2131,  2009,  2132,  2010,  2011,  2012,  2133,  2134,  2013,
-    2014,  2135,  2015,  2136,  2137,  2016,  2017,  2020,  2018,  2138,
-    2019,  2139,  2021,  2022,  2023,  2140,  2141,  2024,  2025,  2142,
-    2026,  2027,  2028,  2029,  2030,  2143,  2031,  2144,  2032,  2033,
-    2145,  2146,  2147,  2148,  2149,  2035,  2034,  2036,  2037,  2150,
-    2151,  2152,  2153,  2038,  2039,  2040,  2154,  2155,  2041,  2156,
-    2157,  2042,  2043,  2158,  2044,  2045,  2159,  2046,  2047,  2160,
-    2048,  2049,  2161,  2162,  2163,  2050,  2164,  2051,  2052,  2165,
-    2166,  2053,  2054,  2167,  2055,  2168,  2169,  2170,  2171,  2056,
-    2057,  2172,  2058,  2173,  2174,  2175,  2176,  2059,  2060,  2061,
-    2062,  2063,  2064,  2065,  2066,  2067,  2068,  2069,  1504,   124,
-     123,   125,     0,   424,   425,     0,   435,     0,   417,   422,
-     418,     0,   444,   437,   445,   426,   416,   438,   427,   415,
-     209,     0,   446,   432,   420,     0,     0,     0,     0,   261,
-     222,   406,     0,   156,     0,  1398,  1408,  1417,  1413,  1407,
-    1415,  1405,  1421,  1411,  1397,  1419,  1406,  1410,  1403,  1420,
-    1401,  1418,  1416,  1404,  1412,  1396,  1400,  1387,  1392,  1424,
-    1414,  1422,  1409,  1423,  1425,  1399,  1426,  1402,     0,  1369,
-       0,  1884,  1935,  1889,     0,  1902,     0,  1905,  1906,  1790,
-    1913,  1916,  1917,  1918,  1919,     0,   783,   115,   110,   767,
-       0,   542,     0,   713,   727,   767,   772,  1058,   795,  1059,
-       0,   117,  1471,  1470,  1464,   195,  1331,  1517,  1655,  1695,
-    1807,  1914,  1836,  1858,  1535,  1518,  1511,  1516,   262,   603,
-     601,     0,  1250,  1655,  1695,  1794,  1807,  1914,  1858,  1443,
-    1448,     0,   268,  1523,   115,   110,  1522,     0,   548,   595,
-       0,   269,  1485,     0,  1490,     0,  1770,   575,   578,  1325,
-     576,   540,     0,     0,     1,   156,     0,   162,     0,   599,
-     599,     0,   599,     0,   532,     0,     0,   540,   535,   539,
-     710,  1391,  1500,     0,  1534,  1914,  1836,  1524,  1521,  1664,
-       0,     0,  1664,     0,  1664,     0,  1664,     0,     0,  1510,
-       0,   258,  1234,     0,  1295,   118,     0,     0,  1380,  1376,
-    1381,  1377,  1382,  1375,  1374,  1383,  1379,     0,     0,     0,
-     371,   404,   403,   402,   401,   406,  1664,  1342,     0,   206,
-     462,   463,     0,     0,     0,     0,     0,  1353,   109,   107,
-    1664,  1505,   433,   434,     0,   423,   419,   421,     0,     0,
-    1664,  1320,   443,   439,  1664,   443,  1287,  1664,     0,     0,
-     214,     0,   399,  1389,  1427,  2056,  1441,     0,  1442,  1432,
-    1395,  1428,  1429,   156,     0,   499,  1366,     0,     0,     0,
-    1180,   767,   772,     0,     0,   785,     0,  1200,     0,  1206,
-       0,     0,     0,   767,   547,     0,   727,   784,   111,   717,
-       0,   765,   766,   651,   651,   604,     0,   585,     0,   651,
-     651,   651,   777,     0,     0,   780,   778,     0,   780,     0,
-       0,     0,   780,   776,   736,     0,   651,     0,   765,   768,
-     651,     0,   787,  1386,     0,     0,     0,     0,  1514,  1512,
-    1513,  1519,     0,  1515,     0,     0,  1297,  1299,  1300,  1148,
-    1310,  1034,     0,  1879,  1880,  1881,  1223,  1882,  1883,  1885,
-    1886,  1887,   992,  1628,  1888,  1308,  1890,  1892,  1893,  1895,
-    1896,  1897,  1898,  1899,  1900,     0,  1309,  1903,  1733,  1908,
-    1909,  1911,  1914,  1915,  1307,  1920,     0,     0,     0,  1268,
-    1171,     0,  1033,     0,     0,     0,  1227,  1235,  1026,     0,
-       0,   831,   832,   853,   854,   833,   859,   860,   862,   834,
-       0,  1257,   926,  1022,  1245,  1036,  1031,  1041,  1037,  1038,
-    1078,  1039,  1057,  1042,  1115,  1032,     0,  1040,  1024,  1253,
-     585,  1251,     0,  1025,  1296,   585,  1249,  1446,  1444,  1451,
-    1445,     0,  1447,     0,     0,     0,   259,   111,  1493,  1492,
-    1484,  1482,  1483,  1481,  1480,  1487,     0,  1489,  1392,  1227,
-    1166,  1168,     0,   577,     0,     0,     0,   529,   528,   530,
-       3,     0,     0,     0,  1645,     0,   597,   598,     0,     0,
-       0,     0,     0,     0,     0,     0,   694,   624,   625,   627,
-     691,   695,   703,     0,     0,     0,     0,     0,   536,     0,
-    1325,  1472,  1533,  1527,  1525,     0,     0,     0,   140,   140,
-       0,     0,     0,     0,     0,   100,    49,    93,     0,     0,
-       0,     0,   236,   249,     0,     0,     0,     0,     0,   246,
-       0,     0,   229,    51,   223,   225,     0,   140,     0,    47,
-       0,     0,     0,    53,  1508,     0,   499,   266,   267,  1233,
-       0,   120,   121,   119,   112,     0,  2070,  1932,  1933,  1934,
-    1935,  1885,  1936,  1937,     0,  1938,  1939,  1891,  1941,  1942,
-    1943,  1944,  1945,  1946,  1947,  1948,  1898,  1950,  1951,  1952,
-    1953,  1954,  1955,  2096,  1956,  1912,  1958,  1918,     0,  1959,
-    1049,   607,  1174,   609,  1172,  1326,     0,   113,  1313,     0,
-    1378,     0,     0,     0,     0,   497,     0,     0,     0,     0,
-    1338,     0,  1664,   207,   211,     0,  1664,   202,  1664,   371,
-       0,  1664,   371,  1664,     0,  1352,  1355,     0,   436,   431,
-     429,   428,   430,  1664,   255,     0,     0,  1321,   441,   442,
-       0,   410,     0,     0,   412,     0,     0,   219,     0,   217,
-       0,   406,   156,     0,   230,  1437,  1438,  1436,     0,     0,
-    1431,  1394,   233,   250,  1440,  1430,  1439,  1393,  1388,     0,
-       0,  1384,   485,     0,     0,     0,  1181,   902,   901,   883,
-     884,   899,   900,   885,   886,   893,   894,   904,   903,   891,
-     892,   887,   888,   881,   882,   897,   898,   889,   890,   895,
-     896,   879,   880,  1195,  1182,  1183,  1184,  1185,  1186,  1187,
-    1188,  1189,  1190,  1191,  1192,  1193,  1194,     0,     0,   726,
-     723,     0,     0,     0,     0,     0,     0,  1227,     0,   997,
-    1032,     0,     0,     0,  1166,  1205,     0,     0,     0,     0,
-       0,     0,  1166,  1211,     0,     0,   751,   763,     0,   644,
-     650,   724,   722,     0,  1250,   714,     0,   797,   727,   725,
-     719,   721,     0,   777,     0,   776,     0,     0,   779,   773,
-       0,   774,     0,     0,     0,     0,   775,     0,     0,     0,
-       0,     0,   718,     0,   763,     0,   720,   794,  1454,  1462,
-     196,     0,  1317,  1960,  1961,  1962,   841,  1963,   870,   848,
-     870,   870,  1964,  1965,  1966,  1967,   837,   837,   850,  1968,
-    1969,  1970,  1971,  1972,   838,   839,   875,  1973,  1974,  1975,
-    1976,  1977,     0,     0,  1978,   870,  1979,   837,  1980,  1981,
-    1982,   842,  1983,   805,  1984,     0,  1985,   840,   806,  1986,
-     878,   878,  1987,     0,   865,  1988,     0,  1177,   815,   823,
-     824,   825,   826,   851,   852,   827,   857,   858,   828,   925,
-       0,   837,  1318,  1319,   156,  1520,  1536,     0,  1171,  1043,
-     869,   856,  1222,     0,   864,   863,     0,  1171,   846,   845,
-     844,  1028,     0,   843,  1128,   870,   870,   868,   951,   847,
-       0,     0,     0,     0,     0,   874,     0,   872,   952,   930,
-     931,     0,     0,  1267,  1276,  1166,  1170,     0,  1026,  1166,
-       0,  1035,  1045,     0,  1118,  1120,     0,     0,     0,  1228,
-    1298,  1027,     0,  1303,     0,     0,   925,   925,  1256,  1148,
-       0,  1138,  1141,     0,     0,  1145,  1146,  1147,     0,     0,
-       0,  1248,     0,  1156,  1158,     0,     0,   967,  1154,     0,
-     970,     0,     0,     0,     0,  1142,  1143,  1144,  1134,  1135,
-    1136,  1137,  1139,  1140,  1152,  1133,   948,     0,  1023,     0,
-    1081,     0,   947,  1254,   712,     0,  1301,   712,  1456,  1460,
-    1461,  1455,  1459,     0,  1450,  1449,  1452,  1453,     0,  1494,
-    1478,     0,  1475,  1169,   707,   579,  1289,     0,   583,  1499,
-     161,   160,     0,   213,     0,   552,   551,   618,   610,   612,
-     618,     0,   550,     0,   667,   668,     0,     0,     0,     0,
-     700,   698,  1297,  1310,   655,   628,   654,     0,     0,   632,
-       0,   659,   926,   693,   534,   622,   623,   626,   533,     0,
-     696,     0,   706,     0,   571,   573,   556,   570,   568,   553,
-     561,   694,   627,     0,  1501,     0,     0,  1465,  1526,     0,
-       0,     0,     0,     0,  1664,     0,     0,   808,    84,    65,
-     323,   139,     0,     0,     0,     0,     0,     0,     0,    92,
-      89,    90,    91,     0,     0,     0,     0,  1317,   234,   235,
-     248,     0,   239,   240,   237,   241,   242,     0,     0,   227,
-     228,     0,     0,     0,     0,   226,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1509,  1502,  1229,  1234,   609,
-     609,   609,     0,     0,     0,     0,   607,   608,     0,     0,
-       0,     0,     0,   484,   369,   379,     0,     0,     0,  1342,
-     206,     0,     0,     0,     0,     0,     0,   406,  1345,  1343,
-    1341,  1344,  1346,  1634,   190,     0,     0,     0,     0,     0,
-     198,   201,     0,   368,   342,     0,     0,  1357,     0,     0,
-     457,   455,   458,   447,   460,   450,     0,  1664,   358,  1354,
-       0,  1506,     0,     0,   253,   443,  1322,     0,   440,   443,
-    1288,     0,   443,   221,     0,     0,  1390,  1433,   231,   251,
-     232,   252,   499,   494,   524,     0,   502,   507,   482,     0,
-     482,     0,   504,   508,   482,   503,     0,   482,   498,     0,
-    1073,     0,  1063,     0,     0,   786,     0,     0,  1064,   999,
-    1000,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1017,
-    1016,  1065,   790,     0,   793,     0,     0,  1203,  1204,     0,
-    1066,     0,     0,  1210,     0,     0,     0,  1071,     0,   728,
-       0,     0,   634,   635,   643,   639,   646,     0,   649,   636,
-     585,   541,  1655,  1695,     0,   596,   596,   596,   594,   584,
-       0,   671,   729,     0,     0,     0,   752,     0,     0,   754,
-     756,     0,     0,   759,     0,   735,   734,     0,     0,     0,
-       0,   798,     0,  1293,     0,     0,   197,     0,     0,     0,
-     823,     0,     0,     0,   813,   809,     0,   905,   906,   907,
-     908,   909,   910,   911,   912,   913,   914,   915,   916,   917,
-     829,  1330,     0,   835,  1333,     0,  1334,  1335,  1332,  1329,
-    1336,  1337,     0,     0,     0,     0,  1221,  1217,     0,     0,
-       0,     0,  1123,  1125,  1127,     0,   867,   866,  1132,  1138,
-    1141,  1145,  1146,  1147,  1142,  1143,  1144,  1134,  1135,  1136,
-    1137,  1139,  1140,     0,  1160,     0,  1114,     0,     0,     0,
-       0,     0,     0,     0,  1261,  1260,     0,  1284,     0,  1046,
-    1030,     0,     0,  1121,  1047,  1268,  1258,  1236,     0,     0,
-       0,  1306,  1305,   927,   936,   939,   971,   972,   943,   944,
-     945,   949,  1328,  1327,  1255,     0,  1247,     0,     0,   928,
-     953,   958,     0,  1212,  1215,   988,  1214,     0,   976,     0,
-     966,     0,   974,   978,   954,   969,     0,   950,     0,  1248,
-    1157,  1159,     0,  1155,     0,   940,   941,   942,   932,   933,
-     934,   935,   937,   938,   946,  1131,  1129,  1130,     0,  1234,
-       0,  1246,     0,     0,  1083,     0,     0,   973,  1252,     0,
-     797,   609,   797,     0,   925,  1495,  1325,  1488,  1325,  1477,
-    1167,  1290,  1324,   581,     0,     0,     0,  1497,   147,   151,
-       0,  1235,   181,   183,   712,     0,   616,   617,   621,     0,
-       0,   621,   600,   549,  1909,  1790,     0,     0,     0,     0,
-     660,   701,     0,   692,   657,   658,     0,   656,  1297,   661,
-    1296,   662,   665,   666,   633,  1285,   702,   704,     0,   697,
-       0,  1291,   555,   574,     0,     0,     0,     0,     0,   538,
-     537,   708,  1472,  1472,  1474,  1473,     0,    50,     0,  1664,
-      67,     0,     0,     0,     0,     0,     0,   273,     0,   373,
-     273,   105,  1664,   443,  1664,   443,  1558,  1629,  1808,     0,
-      63,   347,    96,     0,   133,   376,     0,   332,    86,   101,
-     126,     0,     0,    52,   224,   238,   243,   129,   247,   244,
-    1362,   245,   140,     0,    48,     0,   127,     0,  1360,     0,
-       0,    54,   131,  1364,  1510,     0,  1233,     0,   607,   607,
-     607,   605,   606,  1050,     0,  1173,     0,  1175,  1176,   966,
-    1372,  1371,  1373,  1370,   470,   483,     0,   370,     0,   496,
-     473,   474,   484,  1340,   211,     0,   202,   371,     0,   371,
-       0,  1342,     0,     0,   192,   188,   206,   212,     0,     0,
-       0,     0,     0,   369,   361,   359,   392,     0,   366,   360,
-       0,     0,   318,     0,  1552,     0,     0,     0,     0,   464,
-       0,     0,     0,     0,     0,     0,   255,   256,   409,  1323,
-     411,     0,   413,   220,   218,  1385,  2026,   490,  1171,     0,
-     488,   495,   489,   492,   493,   487,   486,     0,   481,     0,
-     517,     0,     0,     0,     0,     0,     0,     0,     0,  1060,
-    1179,     0,  1198,  1197,   998,  1005,  1008,  1012,  1013,  1014,
-    1199,     0,     0,     0,  1009,  1010,  1011,  1001,  1002,  1003,
-    1004,  1006,  1007,  1015,   795,     0,     0,   789,  1208,  1207,
-    1201,  1202,     0,  1068,  1069,  1070,  1209,     0,     0,   764,
-     638,   640,   637,     0,     0,   797,   596,   596,   596,   596,
-     593,     0,     0,     0,   796,     0,   688,   760,   758,     0,
-     782,     0,   755,     0,   761,     0,   746,     0,   753,   802,
-     769,     0,     0,   771,  1463,   819,     0,   814,   810,     0,
-       0,     0,   820,     0,     0,     0,     0,     0,     0,     0,
-    1178,     0,   602,  1044,     0,     0,     0,  1218,     0,   994,
-     836,   849,     0,  1126,  1048,     0,  1149,  1113,   877,   876,
-     878,   878,     0,  1263,  1265,     0,     0,     0,     0,  1275,
-       0,   995,  1226,     0,  1074,  1224,  1167,  1117,  1119,  1276,
-    1029,   861,   925,     0,     0,     0,     0,     0,     0,     0,
-     977,   968,     0,   975,   979,     0,     0,     0,   962,     0,
-       0,   960,   989,   956,     0,     0,   990,  1233,     0,  1237,
-       0,     0,  1082,  1091,   715,   711,   671,   607,   671,     0,
-    1457,  1479,  1476,   582,   156,  1498,     0,   170,     0,     0,
-       0,     0,   173,   187,   184,  1497,     0,     0,   611,   613,
-       0,  1150,   621,   615,   664,   663,     0,   631,   699,   629,
-       0,   705,     0,   572,     0,   558,     0,   738,     0,     0,
-    1466,  1467,     0,     0,     0,   322,     0,     0,     0,   273,
-       0,   381,     0,   388,     0,     0,   373,   354,    85,     0,
-       0,     0,    59,   104,    77,    69,    55,    83,     0,     0,
-      88,     0,    81,    98,    99,    97,   102,     0,   283,   308,
-       0,     0,   319,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   499,  1234,  1230,  1234,     0,     0,
-       0,   609,  1051,     0,   469,   523,   520,   521,   519,   229,
-     380,     0,     0,     0,   200,   368,     0,  1357,   449,   452,
-    1339,   406,     0,   193,     0,   191,   211,     0,     0,   202,
-     371,     0,   346,   342,   367,   340,   339,   341,     0,  1553,
-     222,     0,  1547,   371,  1356,     0,     0,   465,   456,     0,
-     461,     0,     0,   459,     0,  1351,   254,   443,     0,   477,
-     518,   525,   505,   510,     0,   516,   512,   511,   506,   514,
-     513,   509,  1061,  1072,  1196,     0,     0,     0,     0,   788,
-     791,     0,  1067,  1062,   762,     0,     0,   671,     0,     0,
-       0,     0,   587,   586,   592,     0,     0,  1085,   757,     0,
-       0,     0,   744,   733,   739,   740,     0,     0,     0,   800,
-     799,   770,   823,     0,   803,   823,     0,   823,     0,   821,
-       0,   830,   918,   919,   920,   921,   922,   923,   924,   855,
-       0,  1220,  1216,  1122,  1124,  1161,   873,   871,   993,  1266,
-    1259,  1262,  1166,  1270,  1272,     0,     0,     0,     0,  1283,
-       0,     0,  1116,  1284,  1304,   929,     0,     0,   959,  1213,
-     980,     0,     0,     0,   955,  1149,     0,     0,     0,     0,
-       0,   964,     0,  1241,  1234,     0,  1240,     0,     0,     0,
-       0,  1056,   716,   688,     0,   688,     0,     0,  1496,     0,
-    1491,   148,   149,   150,     0,     0,     0,   165,   142,     0,
-       0,   182,   170,   158,   619,   620,     0,   614,   630,  1286,
-    1292,   557,     0,  1026,     0,     0,   554,     0,   134,   273,
-       0,     0,    66,     0,   390,   334,   382,   365,   349,     0,
-       0,     0,   274,     0,   407,     0,     0,   355,     0,     0,
-       0,     0,   335,     0,     0,   294,     0,     0,   365,     0,
-     372,   290,   291,     0,    58,    78,     0,    74,     0,   103,
-       0,     0,     0,     0,     0,    61,    73,     0,    56,   808,
-     443,   443,    64,  1317,  1960,  1961,  1962,  1963,  1964,  1965,
-    1966,  1967,  1968,  1969,  2080,  1970,  1971,  1972,  1973,  1974,
-    1975,  1976,  1977,  2089,  1978,   280,  1979,  1733,  1980,  1981,
-    1982,  1983,  1984,     0,  1985,   806,  1986,  1987,  2168,  1988,
-    1134,  1135,   279,   278,   375,   275,   383,   277,     0,  1318,
-     276,   378,   333,   130,  1363,     0,   128,     0,  1361,   137,
-     135,   132,  1365,  1503,     0,     0,  1054,  1055,  1052,   607,
-       0,     0,     0,   499,   476,     0,     0,     0,  1552,     0,
-       0,  1664,     0,   189,     0,     0,   203,  1357,   199,   368,
-       0,   398,   318,   393,     0,  1552,  1550,     0,  1357,  1546,
-     448,   451,     0,     0,   540,   453,     0,     0,     0,   414,
-     491,     0,   515,  1018,     0,     0,     0,     0,   647,     0,
-     653,   688,   591,   590,   589,   588,   670,  1603,  1892,  1789,
-       0,   674,   669,   672,   677,   679,   678,   680,   676,   687,
-       0,   690,   781,  1162,  1164,     0,     0,     0,     0,   745,
-     747,     0,   749,     0,   801,   817,     0,   818,     0,   816,
-     811,   822,  1219,  1264,  1273,  1274,  1269,  1278,  1280,     0,
-       0,     0,   926,  1225,   996,   986,   984,   981,     0,   982,
-     963,     0,     0,   961,   957,     0,   991,     0,     0,  1238,
-       0,  1077,     0,  1080,  1094,  1090,  1089,  1085,  1051,  1085,
-    1458,   580,   169,   146,   172,   171,     0,  1235,   179,     0,
-       0,   170,     0,   174,   466,     0,     0,   569,   737,   562,
-     563,     0,   386,    68,     0,   365,     0,   273,   351,   350,
-     353,   348,   352,     0,   408,     0,     0,   292,     0,   299,
-     337,   338,   336,   293,   365,   371,   295,     0,     0,     0,
-      70,    60,    57,    62,    71,     0,     0,    72,    75,   802,
-     807,    87,    80,  1317,  2089,  2098,     0,     0,     0,     0,
-       0,  1232,  1231,     0,   472,   471,   522,   468,   479,   229,
-       0,     0,     0,   342,  1549,     0,     0,     0,   368,   194,
-       0,     0,     0,     0,  1552,     0,     0,   270,     0,   315,
-       0,   215,  1551,     0,     0,  1538,     0,     0,  1349,  1350,
-       0,   478,  1019,     0,  1020,   792,     0,     0,   645,  1085,
-       0,     0,     0,   681,   675,     0,  1084,  1086,     0,   642,
-    1165,   741,     0,   743,     0,   767,     0,   767,   750,   812,
-     804,  1271,  1281,  1282,  1277,  1075,     0,   983,   987,   985,
-     965,  1234,  1242,  1234,  1239,  1079,  1093,  1096,   690,  1302,
-     690,     0,     0,   157,     0,     0,   154,   141,   159,  1151,
-     559,   560,     0,   273,     0,   364,   387,   304,   282,     0,
-       0,     0,   289,   296,   397,   298,     0,    79,    95,     0,
-       0,   377,   138,   136,  1053,   499,     0,   205,  1357,   318,
-    1546,     0,     0,     0,     0,   342,   222,  1548,   331,   324,
-     325,   326,   327,   328,   329,   330,   345,   344,   316,   317,
-       0,     0,     0,     0,   454,  1351,     0,   176,   185,     0,
-     176,  1021,   648,     0,   690,     0,     0,     0,   673,     0,
-       0,   689,     0,   545,  1163,     0,   732,   730,     0,   731,
-    1279,     0,     0,     0,     0,   609,   642,   642,   143,     0,
-     144,   180,     0,     0,     0,   371,   389,   363,     0,   356,
-     302,   301,   303,   307,     0,   305,     0,   321,     0,   314,
-     282,     0,    82,     0,   384,   467,   475,     0,   272,  1540,
-     368,     0,   204,  1546,   318,  1552,  1546,     0,  1543,     0,
-       0,     0,     0,   178,  1357,     0,   178,     0,   642,   683,
-       0,   682,  1088,  1087,   644,   742,     0,  1076,  1244,  1243,
-       0,  1100,   544,   543,     0,     0,     0,     0,   397,     0,
-     343,     0,     0,   304,     0,   297,   394,   395,   396,     0,
-     310,   300,   311,    76,    94,   385,     0,   368,  1541,   271,
-     216,  1539,  1544,  1545,     0,   176,   175,   618,   177,   797,
-     186,   618,   652,   546,   684,   641,   748,  1095,     0,     0,
-       0,     0,     0,   153,   797,   164,     0,   314,   362,   357,
-     281,   306,   320,     0,     0,     0,   312,     0,   313,  1546,
-       0,   178,   621,  1347,   621,  1878,  1604,  1843,     0,  1112,
-    1101,  1112,  1112,  1092,   145,   152,     0,   273,   286,     0,
-     285,     0,   374,   309,  1542,  1357,   618,   166,   167,     0,
-    1105,  1104,  1103,  1107,  1106,     0,  1099,  1097,  1098,   797,
-     391,   284,   288,   287,   797,   621,     0,     0,  1109,     0,
-    1110,   163,  1348,   168,  1102,  1108,  1111
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-      -1,    47,    48,    49,   755,  2664,  2665,  2666,  2289,  1225,
-    3452,  2290,  1226,  1227,  2668,   756,   806,  1169,   855,  1107,
-    1629,   915,  1261,  1262,   757,  1783,   758,  2897,  2209,  2610,
-    3434,    54,  3178,  2212,  1183,  3181,  3398,  2890,  3176,  2611,
-    3473,  3527,  3179,  2213,  2214,  3399,  2215,   759,  2724,  2725,
-     760,   761,  1870,    58,  1324,   551,  1867,   762,   763,  1357,
-    1358,   970,   764,  1871,  1811,  3013,  1245,  1801,  1372,    62,
-    1894,   765,   107,   911,    64,   766,  2653,  3014,  3445,  2679,
-    3582,  2950,  2951,  3442,  3443,  2656,  2292,  3510,  3511,  2739,
-    1792,  3505,  2374,  3386,  2296,  2277,  2952,  2382,  3345,  3061,
-    2293,  2932,  2375,  3438,  1889,  2376,  3439,  3197,  2377,  1845,
-    1874,  2657,  3512,  2297,  1846,  2652,  3015,  1780,  2378,  3449,
-    2379,   552,  2936,   767,   746,   747,   962,  1351,   748,   768,
-    1880,  1881,  1882,  1883,  1884,  1885,   946,  1886,   769,   770,
-    2704,  2352,  3249,  2758,  3250,  2419,  2346,  1381,  2411,  1914,
-    1848,  1382,   540,  1928,  2759,  2709,  1915,   771,  1108,    72,
-      73,  1017,    74,  3191,    75,    76,  1754,  1755,  1756,   857,
-     867,   868,  2205,  1467,  1999,   860,  1188,  1723,   841,   842,
-    1834,   883,  1837,  1718,  1719,  2218,  2618,  1747,  1748,  1197,
-    1198,  1985,  1986,  3413,  1987,  1988,  1460,  1461,  3288,  1735,
-    1739,  1740,  2239,  2229,  1726,  2486,  3101,  3102,  3103,  3104,
-    3105,  3106,  3107,  1109,  2797,  3299,  1743,  1744,  1200,  1201,
-    1202,  1752,  2249,    78,    79,  2190,  2594,  2595,   812,   813,
-    3118,  1490,  1757,  2801,  2802,  2803,  3121,  3122,  3123,   814,
-    1012,  1013,  1040,  1035,  1479,  2009,   815,   816,  1962,  1963,
-    2457,  1042,  2001,  2020,  2021,  2809,  2510,  1556,  2278,  1557,
-    1558,  2035,  1559,  1110,  1560,  1588,  1111,  1593,  1562,  1112,
-    1113,  1114,  1565,  1115,  1116,  1117,  1118,  1581,  1119,  1120,
-    1605,  2037,  2038,  2039,  2040,  2041,  2042,  2043,  2044,  2045,
-    2046,  2047,  2048,  2049,  2050,  1170,  1758,  1122,  1123,  1124,
-    1125,  1126,  1127,  1128,  1129,  1130,  1131,   818,  1132,  2553,
-    1133,  1680,  2184,  2593,  3111,  3296,  3297,  2881,  3166,  3327,
-    3425,  3541,  3569,  3570,  3596,  1134,  1135,  1624,  1625,  1626,
-    2072,  2073,  2074,  2075,  2178,  1674,  1675,  1136,  3017,  1677,
-    2095,  3114,  3115,  1171,  1453,  1617,  1303,  1304,  1570,  1427,
-    1428,  1434,  1937,  1442,  1446,  1967,  1968,  1454,  2145,  1137,
-    2066,  2067,  2528,  1583,  2554,  2555,  1138,  1260,  1630,  2876,
-    2181,  1678,  2138,  1145,  1139,  1146,  1141,  1613,  2848,  2544,
-    2545,  1614,  2549,  2844,  2845,  2107,  2849,  3138,  3139,  2551,
-    2246,  1706,  2251,  2252,   966,  1142,  1143,  1144,  1305,   524,
-    1571,  3528,  1347,  1176,  1306,  2134,   772,  1047,  2059,   773,
-    1320,  1860,   774,  3279,  3078,  1336,  1890,  2387,   553,   775,
-     776,   533,    85,  2341,   927,    86,    87,    88,   892,  1374,
-     777,  1375,  1376,   977,    89,  2760,   979,   980,   779,   849,
-     850,  1499,  1694,  1500,   780,    92,   824,  1767,   781,  1165,
-     864,  1166,  1168,   782,  1185,  2607,  2207,    95,    96,    97,
-     115,  1256,   783,   835,   836,   873,   100,   101,  1213,   837,
-     785,   786,  3275,   787,  2742,  1330,   534,   526,   527,  1573,
-     720,  1308,   721
-};
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-#define YYPACT_NINF -3162
-static const int yypact[] =
-{
-    6054,   348,   823, -3162, -3162,   279,   348, 51623, 66578,   339,
-     348,   118,  2095, 53619, -3162, -3162, 48130,  8709,   348, 56613,
-   73974,   548,   689, 32620,   719, 57112, -3162, -3162, -3162, 66578,
-   56613, 57611,   348,   359, 67077, -3162,   348, 35616, 54118,   453,
-   -3162, 56613,    47,   383, 58110, 56613,  3130,   946,   431, -3162,
-   -3162, -3162, -3162, -3162,   128, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162,   159, -3162,    98,   174, 32620, 32620,  2484,   438, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,   498,
-   -3162, -3162,   807, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, 35116, -3162, -3162, -3162, -3162, -3162, -3162, 58609, 56613,
-   59108, 54617, 59607, -3162,   727,  1020,   705,   152, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-     170, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162,   512, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162,   182, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162,   399, -3162,   535, -3162,   188, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162,  1886, -3162, -3162,   961,  2952,
-   56613,   715,   753,   724, -3162, 60106, -3162,   712, 56613, -3162,
-   -3162,   729,  1039,   901, -3162, -3162, 55116, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, 48629, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162,   868, -3162, -3162,   688, -3162,   124, -3162, -3162,
-     709,   686, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162,   791, -3162, -3162, -3162,   805, 67576, 60605, 61104, -3162,
-     674,  2617,  9200, 73992, 31620, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,   498, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 57112, 66578,
-     720,   731,  1013,   736, 33618,   771, 36116,   776,   802,  1032,
-     810,   814,   824,   841,   383, 32120,   699,   399,   704, 61603,
-   61603,   -22, 33119,  3628, -3162, 61603, 62102, -3162,   798, -3162,
-    1020, -3162, -3162, -3162, -3162,   -99,   845, -3162, 62601, 62601,
-   62601,   836,  1087, 62601, -3162, -3162, -3162,   878, -3162, -3162,
-    1097, 20189, 20189, 68075, 68075,  1020, 68075,   916, 68075, -3162,
-   -3162,    76,   705, -3162,   399, -3162, -3162,  2484, -3162, -3162,
-   54118, -3162, -3162,   270,  1250, 20189, 56613,   926, -3162,   920,
-     926,   936,   949,   977, -3162,  6054,  1328,  1209, 55615,   369,
-     369,  1467,   369,   662,   701,  2582,  2099, -3162,  1234, -3162,
-    1015, -3162, 56613, 57112,  1116,  1042,  1323, -3162, -3162,  1400,
-     786,  1204,  1423,  1991,  1431,   788,  1434,  1240,  1440,  1532,
-      31, -3162, 20189, 49128,   399, -3162, 11264, 20189, -3162, -3162,
-   -3162,  1176, -3162, -3162, -3162, -3162, -3162, 56613, 66578,  1108,
-    1132, -3162, -3162, -3162, -3162,  1530,  1377, -3162,  1614, 68574,
-   -3162, -3162,  1197, 63100, 63599, 64098, 64597,  1585, -3162, -3162,
-    1525, -3162, -3162, -3162,  1199, -3162, -3162, -3162,   168, 69073,
-    1534,  1168,   105, -3162,  1547,   119, -3162,  1562,  1426, 14939,
-   -3162,  1363, -3162, -3162, -3162,   383, -3162,   377, -3162, -3162,
-   45231, -3162, -3162, 73992,  1293,  1210, -3162, 20189, 20189,  1214,
-    6413, 61603, 62102, 20189, 56613, -3162, 20189, 24914,  1218, 20189,
-   20189, 12314, 20189, 30622, 61603,  3628,  1207, -3162,   567, -3162,
-   56613,  1225, -3162,  1324,  1324,   359, 32620,  1546, 32120,  1324,
-    1324,  1324, -3162,  1035,  1539,  1452, -3162, 32620,  1452,  1502,
-    1254,  1572,  1452, -3162,   261,  1579,  1324, 36615,  1262, -3162,
-    1324,  1512, -3162, -3162, 20189, 14939, 71568,  1784, -3162, -3162,
-   -3162, -3162,  1591, -3162, 66578,  1318, -3162, -3162, -3162, -3162,
-   -3162, -3162,   772,  1845,   165,  1851, 20189,   165,   165,  1339,
-     190,   190, -3162,  1538,  1341, -3162,   198,  1347,  1349,  1863,
-    1864,   167,   147,  1028,   165, 20189, -3162,   190,  1352,  1866,
-    1356,  1868,   197,   207, -3162,   201, 20189, 20189, 20189,   305,
-   20189, 10214, -3162, 49128,  1867, 56613,   590, -3162,   399,  1359,
-    1020, -3162, -3162, -3162, -3162, -3162, -3162, -3162,  1360, -3162,
-     185,  7096, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-    1394, -3162, -3162, -3162, -3162,  1577, 20189, -3162, -3162,  1358,
-    1546, -3162,   205, -3162, -3162,  1546, -3162, -3162, -3162, -3162,
-   -3162,   218, -3162,  1779, 20189, 20189, -3162,   399, 69572, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162,   536, -3162,   498,   515,
-   46949,  1362,  1367,   926, 56613, 56613,  1847, -3162, -3162, -3162,
-   -3162, 54118,   144,  1668,   169,  1504, -3162, -3162,  2484,  2484,
-   15464,  1290,   222,   549, 15989, 20714,  1724,  1607,   213,   600,
-    1729, -3162,  1615,  1840, 24914, 20189, 20189,   662,   701, 20189,
-     920,   122, -3162, -3162, -3162,  1665, 56613, 52122,   334,   778,
-    1387,  1476,  1390,    91,  1816, -3162,  1389, -3162,  1482, 56613,
-   73519,   226, -3162,  1856,   226,   226,   245,  1857,  1486,   233,
-    1652,    67,   -83,  1389,  4318, -3162, 54118,   150,   738,  1389,
-   56613,  1488,   822,  1389,  1812, 66578,  1210, -3162, -3162, 42797,
-    1398, -3162, -3162, -3162,   186, 14939, -3162,   971,  1202,  1208,
-     367,   212,  1248,  1263, 14939,  1269,  1355,   200,  1361,  1380,
-    1450,  1505,  1554,  1596,  1602,  1618,   134,  1643,  1666,  1680,
-    1693,  1699,  1721, -3162,  1725,   202,  1727,   215, 14939,  1755,
-   -3162,   146, 46949,    -1, -3162, -3162,  1761,   204, -3162, 47049,
-   -3162,  1701,  1493,  1494, 66578,  1448, 56613,  1550,  1422,  1780,
-    1831, 72052,  1658, -3162,  1757, 56613,  1679,  4318,  1682,  1442,
-    1921,  1688,  1132,  1691,  1449, -3162, 70071, 49128, -3162, -3162,
-   -3162, -3162, -3162,  1818,  1802, 66578, 49128,  1455, -3162, -3162,
-   66578, -3162, 56613, 56613, -3162, 56613, 66578, -3162,   542, 46949,
-    1963,  1022, 73992, 50625, -3162, -3162, -3162, -3162,   933,   939,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,  1020,
-   49128, -3162,  3393, 45852,  1458, 20189, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162,  1461,  1811, -3162,
-   -3162,  6931,  1465, 46147,  1468, 24914, 24914,   399,  2469, -3162,
-   -3162, 24914,  1469, 51124, 45766,  1464,  1470, 46332, 16514, 20189,
-   16514, 16514, 46398, -3162,  1471, 46487, 61603,  1473, 56613, 30118,
-   -3162, -3162, -3162, 20189, 20189,  3628, 56114,  1515,  1477, -3162,
-   -3162, -3162, 32620, -3162, 32620, -3162,  1770, 32620, -3162, -3162,
-    3794, -3162, 32620,  1772, 20189, 32620, -3162, 32620,  1717,  1719,
-    1485, 32620, -3162, 56613,  1487, 56613, -3162, -3162, 46949, -3162,
-    1484,   586,  1489, -3162, -3162, -3162, -3162, -3162,  1541, -3162,
-    1541,  1541, -3162, -3162, -3162, -3162,  1492,  1492,  1495, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162,  1496,  1028, -3162,  1541, -3162,  1492, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, 73519, -3162, -3162, -3162, -3162,
-     -92,   -79, -3162,  1497, -3162, -3162,  1501, -3162,  1506,  1985,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,  8118,
-     687,  1492, -3162, -3162,  4489, -3162, -3162, 20189, 20189, -3162,
-   -3162,  1507, 46949,  1552, -3162, -3162, 20189, 20189, -3162, -3162,
-   -3162, -3162,  2020, -3162, 20189,  1541,  1541, -3162,  6264, -3162,
-   41607, 17039,  1601,  1604,  2020, -3162,  2020, -3162,  6264,  2021,
-    2021,  1517, 37114, -3162,  1681, 46696, -3162,  1523,  1555,  7666,
-    1520, -3162, -3162,  1524, -3162,  1526,  1518, 43734, 20189,   178,
-     399,   399, 20189, -3162,  2020, 20189,  9122,  9122, -3162,   224,
-   71568, 20189, 20189, 20189, 20189, 20189, 20189, 20189, 20189, 47631,
-    1621,   136, 66578, 20189, 20189, 29608,   984, -3162, 20189,  1782,
-   -3162,  1548, 20189,  1628,   253, 20189, 20189, 20189, 20189, 20189,
-   20189, 20189, 20189, 20189, -3162, -3162, 28589,   308,   520,  1871,
-    1901,   -10,   538, 20189,  1893, 11264, -3162,  1893, -3162, -3162,
-   -3162, -3162, -3162,   206, -3162, -3162,  1484,  1484, 66578, -3162,
-   56613,   270, 53120, 20189, -3162, -3162,  1545,  1549,   599,  1612,
-   -3162, -3162, 56613, -3162, 40108,  1852, -3162,   332,  1558, -3162,
-   45727,  1806,  1852,  2484, -3162, -3162, 25964,  1684,  1854,  1791,
-   -3162, -3162,  1771,  1774, -3162,  1561, 47138, 21239, 21239, -3162,
-    1409, 46949,  1414, -3162, -3162, -3162, -3162, -3162, -3162,   671,
-   -3162, 56613,    99, 37613, -3162,  1563,   164, -3162,  2765,  1909,
-    1872,  1724,   600,  1574, -3162, 57112, 57112, -3162, -3162,  1255,
-    1573, 70570, 56613,  1869,  1819,  1873,   -64, 71568, -3162, -3162,
-   -3162, -3162, 56613, 66578, 65096, 71069, 49627, 56613, 49128, -3162,
-   -3162, -3162, -3162, 56613,   890, 56613,  3834, -3162, -3162, -3162,
-   -3162,   226, -3162, -3162, -3162, -3162, -3162, 66578, 56613, -3162,
-   -3162,   226, 66578, 56613,   226, -3162,  1260, 56613, 56613, 56613,
-   56613,  1332, 56613, 56613,  1020, -3162, -3162, -3162, 21764,    37,
-      37,  1805,  1821,  1824,  1588, 12839,   146, -3162, 20189, 20189,
-     325,   295, 66578,  1777, -3162, -3162,   692,  1832,   109, -3162,
-   66578,  1649, 56613, 56613, 56613, 56613, 56613,  2508, -3162, -3162,
-   -3162, -3162, -3162,  1605, -3162,  1969,  2119,  1606,  1609,  1977,
-   -3162,  4318,  1981, 52621,   866,  3367,  1982,  1659,  1986, 13364,
-   -3162, -3162,  1622, -3162, -3162,  1624,  2107,  1874, -3162, -3162,
-    1862, -3162, 66578,  2150, -3162,   105, -3162, 49128, -3162,   119,
-   -3162,  1870,   214, -3162, 14939, 20189, -3162, -3162, -3162, -3162,
-   -3162, -3162,  1210, 29099, -3162,   713, -3162, -3162,  2118,  1020,
-    2118,   497, -3162, -3162,  2118, -3162,  2102,  2118, -3162, 71568,
-   -3162,  8056, -3162, 20189, 20189, -3162, 20189,  1990, -3162,  2152,
-    2152, 71568, 24914, 24914, 24914, 24914, 24914, 24914,   199,  1352,
-   24914, 24914, 24914, 24914, 24914, 24914, 24914, 24914, 24914, 26489,
-     622, -3162, -3162,   749,  2125, 20189, 20189,  1999,  1990, 20189,
-   -3162, 71568,  1650, -3162,  1655,  1657, 20189, -3162, 71568, -3162,
-   56613,  1661, -3162, -3162, -3162,    48,  1653,  1663, -3162, -3162,
-    1546, -3162,  1060,  1064, 56613,  1978,  3821,  4733, -3162, -3162,
-   20189,  1987, -3162,  3794,  3794, 32620, -3162, 20189,  1667, -3162,
-   -3162, 32620,  2010, -3162,  3794, -3162, -3162, 38112,  3794, 71568,
-     756, -3162, 56613, 71568,   777, 20189, -3162, 14939,  2180, 71568,
-    2145, 66578, 66578,  2184,  1672,  1673,  2020,  1759, -3162,  1763,
-    1764,  1767, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, 71568, -3162, -3162,   158, -3162, -3162, -3162, -3162,
-   -3162, -3162,  1683,  1675, 20189, 20189,    62, -3162,  8203,  1687,
-    1690,  6565, -3162,  1685, -3162,  1686, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162, -3162,  1697, -3162,  1694, -3162,  1700,  1702,  1709,
-    1704,  1705, 20189, 56613, -3162,  1698, 22289,  1848, 66578, -3162,
-   -3162, 20189, 20189, 56613, -3162,  2072, 46949, -3162,  1706,  1707,
-    8647, -3162, -3162, -3162,   252,   737,  6322,   538,  3743,  3743,
-    3743,  6264, -3162, -3162, -3162,  1731, -3162, 24914, 24914, -3162,
-    4673,  3933, 10214, -3162, -3162, -3162, -3162,  2056, -3162,   665,
-   -3162,  1716, -3162, -3162,  4655, -3162, 41607,  7006, 20189,   163,
-   -3162, 20189, 29608, 20189,  1804,  3743,  3743,  3743,   333,   333,
-     252,   252,   252,   737,   538, -3162, -3162, -3162,  1718, 20189,
-   49128, -3162,  1720,  1722,  2082,  1356, 20189, -3162, -3162, 32620,
-    1515,    -1,  1515,  2020,  9122, -3162,   920, -3162,   920, -3162,
-   46949, 56613, -3162, -3162,  1993,  1723, 32620,  1768,  2207,  2190,
-   66578, -3162, -3162,  1728,  1893,  1744, -3162, -3162,  1750, 20189,
-    3187,  1750, -3162,  1852,    19,  1964,  1014,  1014,  1409,  1966,
-   -3162, -3162,  1800, -3162, -3162, -3162, 20189, 13889,  1416, -3162,
-    1420, -3162, -3162, -3162, -3162, -3162,  1736, -3162,  2016, -3162,
-   56613, -3162, -3162, 24914,  2203, 20189, 38611,  2204,  2000, -3162,
-   -3162, -3162,  1798,  1798, -3162, -3162,  1838,  1389, 20189,  1996,
-   -3162,   115,  1758,  2123,   298,  2079, 66578, -3162,   316,   329,
-   -3162,   166,  2131,   214,  2132,   214, 49128, 49128, 49128,   779,
-   -3162, -3162, -3162,  1020, -3162,    12,   784, -3162, -3162, -3162,
-   -3162,  1858,   892,  1389,  4318, -3162, -3162, -3162, -3162, -3162,
-   -3162, -3162,   156,   956,  1389,  1859, -3162,  1875, -3162,  1878,
-     958,  1389, -3162, -3162,  1532, 17564, 46949,   394,   146,   146,
-     146, -3162, -3162, -3162, 14939, -3162,  1775, 46949, 46949,   151,
-   -3162, -3162, -3162, -3162,  1769, -3162,   352, -3162, 66578, -3162,
-   -3162, -3162,  1777,  1831,  1757, 56613,  4318,  1781,  2253,  1132,
-    1449, -3162,  1940,    23,   902, -3162, 66578, -3162, 49128, 66578,
-   56613, 56613, 56613, 65595, -3162, -3162, -3162,  1778,  1793, -3162,
-      -6,  2013,  2014, 56613,  1823, 56613,  1390,  2273, 56613, -3162,
-     793,  1449,  1449, 18089,  2164, 56613,  1802, -3162, -3162, -3162,
-   -3162, 66578, -3162, -3162, 46949, -3162,  1790, -3162, 20189, 50126,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, 49128, -3162,  1020,
-   -3162,  1020,  2039, 66578, 44233,  1020, 44732,  1020,  1803, -3162,
-   46949,  8811, 46949,  1999, -3162,   230,  2152,  1603,  1603,  1603,
-    1289,  2149,   528,  1807,  1603,  1603,  1603,   277,   277,   230,
-     230,   230,  2152,   622,   798, 51124,  1808, -3162, 46949, 46949,
-   -3162, -3162,  1813, -3162, -3162, -3162, -3162,  1814,  1826, -3162,
-   -3162, -3162, -3162, 66578,   157,  1515,   453,   453,   453,   453,
-   -3162, 56613, 56613, 56613, 46949,  2264,  2144, -3162, -3162,  3794,
-   46949, 56613, -3162, 27539, -3162, 56613, -3162,  2168, -3162,  2257,
-   -3162, 56613,   800, -3162, -3162, -3162,   819,  1822,  1673, 71568,
-     833,   861, -3162,  2020,   145,  1830,  1527,   992,  1075,  1435,
-   -3162, 54118, -3162, -3162,  1834, 46753, 20189, -3162,  2197, -3162,
-   -3162, -3162, 20189, 20189, -3162, 41607, -3162, -3162, -3162, -3162,
-     131,   131,  8900,  1698,  1820,  1844, 56613, 10214, 46840, -3162,
-   39110, -3162, -3162,  2166,  1829, -3162,  8978, 46949, -3162,  1681,
-   -3162, -3162,  9122, 20189,  2794,  5118, 20189,  1850, 20189,  2198,
-   -3162, -3162,  1853, -3162, -3162, 71568, 20189,  1855,  5420, 24914,
-   24914,  5942, -3162,  6836, 20189, 10214, -3162, 42884,  1865,  1877,
-    1805, 18614, -3162,  2084,  1876, -3162,  1987,   146,  1987,  1881,
-   -3162, -3162, -3162, -3162,  4489, -3162, 20189,  2026, 66578,   505,
-    2525,   867, -3162,   399, 40108,  1768, 20189,   553, -3162, -3162,
-    1885, -3162,  1750, -3162, -3162, -3162,  2100, -3162, -3162, -3162,
-   56613, -3162,  1887, -3162, 37613,  2215, 10739, -3162, 37613, 56613,
-   -3162, -3162, 56613, 42114,  2252, -3162, 66578, 66578, 66578, -3162,
-   66578,  1883,  1888,   266,  1894,   721, -3162,  2619,   266,  2235,
-     275,  1390,   233,  2821,    61, -3162, -3162, -3162,  1971, 56613,
-   -3162, 66578, -3162, -3162, -3162, -3162, -3162, 49627, -3162, -3162,
-   41107, 49128, -3162, 49128, 56613, 56613, 56613, 56613, 56613, 56613,
-   56613, 56613, 56613, 56613,  1210, 20189, -3162, 20189,  1896,  1898,
-    1900,  1805, -3162,   221, -3162,  1903, -3162, -3162, -3162,   -83,
-   -3162,   352,  1902,  1906, -3162, 52621,  2952,  1659, -3162,  1624,
-    1831,   379, 66079, -3162,  1907,  1905,  1757,   881,   883,  4318,
-    1910,  2390, -3162,   866, 52621, -3162, -3162, -3162,  2345, -3162,
-     674,   194, -3162,  1132, -3162,  2952,  1449, -3162, -3162,  2393,
-   -3162,  2394,  2952, 46949, 66578,  1979, -3162,   214,   889, -3162,
-   -3162, -3162, -3162, -3162, 66578,  1915, -3162,  1915, -3162, -3162,
-    1915, -3162, -3162, -3162, -3162, 24914,  2266,  1924, 71568, -3162,
-   -3162, 56613, -3162, -3162, -3162,   893,  1926,  1987, 56613, 56613,
-   56613, 56613, -3162, -3162, -3162, 19139, 20189,  1967, -3162,  1928,
-   11789,  2251, -3162, 27014, -3162, -3162,  1933, 38112, 66578, -3162,
-   -3162, -3162, -3162,  2020, -3162, -3162, 66578, -3162,  1936, -3162,
-    1937, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-   20189, 46949, -3162, 46949, -3162, -3162, -3162, -3162, -3162, 56613,
-   -3162, -3162,  7517, -3162,  1934,  1941, 66578, 56613,   231, -3162,
-   20189, 66578, -3162,  1848, -3162,   390, 20189, 20189,  4673, -3162,
-   43162, 20189, 71568,   897,  4673,   353, 20189,  5250,  5349, 20189,
-   20189,  7468, 42153, -3162, 22814, 14414, -3162,  1942, 20189, 42192,
-   40607, -3162, 32620,  2144,  1943,  2144,  1020,  1945, 46949, 20189,
-   -3162, -3162, -3162, -3162,  2002,   452, 34616,  2169, -3162,  1959,
-   66578, -3162,  2026, 46949, -3162, -3162, 41607, -3162, -3162, -3162,
-   -3162, -3162,  2408,  2615,  1950,  1951, -3162,  1357, -3162, -3162,
-   66578,  1953, -3162,  1955,   266, -3162, 66578,  1998, -3162,   286,
-    2274,   117, -3162, 20189, -3162,  2370,  2451,  2619,  1974, 66578,
-   56613, 24914, -3162,   302,   223, -3162,  2268, 56613,  1998,  2412,
-   -3162, -3162, -3162,   721, -3162,  2304,  2221, -3162,   226, -3162,
-   20189,   721,  2224,   149, 66578, -3162, -3162,  2171, -3162, 71568,
-     214,   214, -3162,  1489,  1988,  1994,  1995,  1997,  2001,  2003,
-    2004,  2008,  2009,  2011, -3162,  2012,  2018,  2019,  2022,  2024,
-    2025,  2027,  2028,  1496,  2029, -3162,  2032,  1885,  2033,  2034,
-    2037,  2038,  2042, 72536,  2043,  2044,  2045,  2046,  1497,  2047,
-     933,   939, -3162, -3162, -3162, -3162, -3162, -3162,  1168,  2050,
-   -3162,  2006, -3162, -3162, -3162,  2074, -3162,  2075, -3162, -3162,
-   -3162, -3162, -3162, -3162,  2005,  2017, -3162, -3162, -3162,   146,
-    1992,  2052, 66578,  1210,   154, 49128, 66578,  2057,  1823,  2493,
-     458,  2261,  2062, -3162,  1020,  2064, -3162,  1659, -3162, 52621,
-    3754,   636,  2014, -3162,   273,  1823, -3162,  2468,  1659,  2103,
-   -3162,  1624,  2167, 20189,   155, -3162,  2295, 66578,  2069, -3162,
-   -3162, 50126,  1915,  5813, 24914, 71568,   908,   913, -3162,  2579,
-    2237,  2144, -3162, -3162, -3162, -3162, -3162,  2076,   -29,  2080,
-    9689,  2078, -3162, -3162, -3162, -3162, -3162, -3162, 46949, 46949,
-   66578,  2267, -3162, -3162,  2083,  2085, 39609,  2538,  2087, -3162,
-   -3162,  2403, -3162, 31121, -3162,  1673,  2091,  1673, 71568,  1673,
-   -3162, -3162, 46949,  1698, 20189, -3162, -3162, -3162,  2088,  2092,
-   66578, 43181,  2421, -3162, -3162,  4673,  4673, 43162,   918, -3162,
-    4673, 20189, 20189,  4673,  4673, 20189, -3162, 19664,   413, -3162,
-     927, -3162, 42240, -3162, 73020, -3162, -3162,  1967,  1020,  1967,
-   -3162, -3162,  2098, -3162, -3162, -3162,  2163, -3162, -3162,   960,
-    2535,  2026, 20189, -3162, -3162,  2108, 37613, -3162, -3162, -3162,
-   -3162, 37613,   266, -3162,  2286,  1998,  2117, -3162, -3162, -3162,
-   -3162, -3162, -3162, 42279, -3162,    79, 20189, -3162,  1038,  1289,
-   -3162, -3162, -3162, -3162,  1998,  1132, -3162, 56613,  2596,  2489,
-   -3162, -3162, 46949, -3162, -3162,  2020,  2020, -3162, -3162,  2257,
-   -3162, -3162, -3162,  2124, -3162, -3162,  1168,    95, 41107, 56613,
-   56613, -3162, -3162,  2126, -3162, -3162, -3162, -3162, -3162,   -83,
-    2524,   983,   994,   866, -3162,  2952, 56613,  2497, 52621, -3162,
-   49128,  2611,  2133, 56613,  1823,  1156,  1156, -3162,  2288, -3162,
-    2289, -3162, -3162,  2620,   290, -3162,  1341, 56613, -3162, -3162,
-   34117, -3162,  5813,   995, -3162, -3162,  2136,  2141, -3162,  1967,
-   20189,  2143, 20189, -3162, 23339,  2622,  2142, -3162, 20189,  2206,
-   28064, -3162, 20189, -3162, 56613, 61603,  2148, 61603, -3162, -3162,
-   -3162, -3162, 56613, -3162, -3162, -3162, 20189, -3162,  4673,  4673,
-    4673, 20189, -3162, 20189, -3162, -3162, -3162,  2357,  2267, -3162,
-    2267, 20189,  2952,   399,  4497, 66578,    18, -3162, 46949, -3162,
-   -3162, -3162, 56613, -3162, 49128, -3162,   266,    -4,  2151, 20189,
-   42632,  2392, -3162, -3162,  2429, -3162,  2488, -3162,  2223,   344,
-    2240, -3162, -3162, -3162, -3162,  1210,  1020, -3162,  1659,  2014,
-    2103,  2174, 56613,  1009,  2952,   866,   674, -3162, -3162, -3162,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162,
-    2952,  2613,  2396,  2621, -3162,  1979, 20189,   108, -3162,  1029,
-    2614, -3162, -3162,  2687,  2267,  2179, 23339,  2183, -3162,  2185,
-   66578, 46949,  2335, -3162, -3162,  2194, -3162, -3162, 20189, -3162,
-   -3162, 43238,  2192,  2199,  2655,  1805,  2206,  2206, -3162,   452,
-   -3162, -3162,  2629, 34117,  2590,  1132,   266,  2208,  1041, -3162,
-   -3162, -3162, -3162, -3162,  4318, -3162, 42719,  2455,   129,  2439,
-    2151, 20189, -3162,  2290, -3162, -3162, -3162,  2690, -3162, -3162,
-   52621,  2213, -3162,  2103,  2014,  1823,  2103,  2440, -3162,  2441,
-    2217, 42758, 66578, 66578,  1659, 34117, 66578,  2218,  2206, -3162,
-    2220, -3162, -3162, -3162, 30118, -3162,  2225, -3162, -3162, -3162,
-   20189,   140, -3162, -3162,  2278, 56613,  1043,    74,  2429, 41107,
-   -3162, 49128,  1783,    -4,  2537, -3162, -3162, -3162, -3162,   102,
-    2456, -3162,  2457, -3162, 46949, -3162,  2952, 52621, -3162, -3162,
-   -3162, -3162, -3162, -3162, 34117,  2614, -3162,   332, -3162,  1515,
-   -3162,   332, -3162, -3162, -3162, -3162, -3162,  1464, 23864, 23864,
-   23864,  2229,  2952, -3162,  1515, -3162,  2361,  2439, -3162, -3162,
-   -3162, -3162, -3162,   209,   209,  2630, -3162,  2297, -3162,  2103,
-    1047, 66578,  1750, -3162,  1750, 25439,  2386,   193, 45805,  2610,
-   -3162,  2610,  2610, -3162, -3162, -3162, 40108, -3162, -3162,  2732,
-   -3162,   203, -3162, -3162, -3162,  1659,   332, -3162, -3162,  2723,
-   -3162, -3162, -3162, -3162, -3162,   162, -3162, -3162, -3162,  1515,
-     266, -3162, -3162, -3162,  1515,  1750, 24389,  2397, -3162,  2466,
-   -3162, -3162, -3162, -3162, -3162, -3162, -3162
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int16 yypgoto[] =
-{
-   -3162, -3162, -3162,  1891,    78, -3162, -3162,   103, -3162,   975,
-   -3162,   106,  -797,   489, -3162,    82,  3221,  2609,  4184,  1298,
-    -520,  -890, -1248,    24,    84, -1138,     3, -3162, -3162, -3162,
-   -3162, -1516,  -560,   173, -3162, -3162,  -697, -2619,  -650, -3162,
-   -3037, -3092, -3162, -3162,  -786, -3061, -2089,    86, -3162, -3162,
-      90,     4, -2178, -3162, -1700,    63, -2168,    93,    94,   888,
-   -3162, -2620,    96,  -884, -1212,  -917, -1202, -3162,  -169, -3162,
-     401,   100,  1828,  1946, -3162,     5, -2220, -2969,  -646, -3162,
-    -748, -3162,  -400, -3162,  -692, -3162,  -730,  -700,  -729, -2891,
-   -1155, -3162,  1599,  -447, -3162,   547, -3162, -2602, -3162, -3162,
-     537, -3162, -1176, -3162, -2268,    88,  -676, -2435, -2604, -2212,
-    -908,   171,  -682,   148, -2171, -1048, -3162,   561, -3162,  -664,
-   -3162,  -899, -2099,   101, -3162, -3162,  1490,  -932, -3162,   104,
-   -3162,   445, -3162, -2176,   446, -2175,  1519,  -562,     8,    10,
-   -3162, -3162, -3162, -3162, -3162,  -691,   487, -1228, -3162,   427,
-   -3162, -3162, -3162, -3162,  -236,   135, -2296,    27,  3629,   -44,
-     -18, -3162,     2, -3162, -3162, -3162,   594, -3162, -3162,    14,
-      58,  1674, -3162, -1043, -3162, -1670,   763, -3162,  1841,  1842,
-   -1782,  -875,   -55, -3162,   641, -1682, -2174,  -639,  1102,  1671,
-    1676, -3162,   396, -2574, -3162,  -610, -3162,   797, -3162, -3162,
-     640,  1152, -1582, -1578, -3162, -2277, -3162,  -527,  -414, -3162,
-   -3162, -3162, -3162, -3162, -2576, -2932,  -627,  1122, -3162,  1689,
-   -3162, -3162, -3162, -3162,    50, -1547,  2861,   679, -3162,    68,
-   -3162, -3162, -3162, -3162,    87, -3162,   870,  -232, -3162,  -492,
-    -681,  -795,  1904,  -496,    13, -1739,   -12,  -380,   437, -3162,
-   -3162,   441, -2105, -1445,   400,  -329,   873, -3162,   -63, -1266,
-   -3162, -1877, -1198, -3162, -3162,  -772,   652, -3162, -3162, -3162,
-    1544,  2347, -3162, -3162,  2552,  2561, -3162,  -904,  2808,  -799,
-   -1049,  1918,  -938,  1919,  -941,  -928,  -915,  1920,  1923,  1925,
-    1927,  1929,  1931,  1932, -1548,  5255,  -196,  1160, -2204, -3162,
-   -1430, -1598,  1001,  1003,  1005,    38, -3162, -1422,   210, -3162,
-   -3162, -3162, -3162, -3162, -2802, -3162,  -487, -3162,  -484, -3162,
-   -3162, -3162, -1692, -3161, -1732, -3162,  -793,   816, -3162, -3162,
-     397, -3162, -3162, -3162, -3162, -1534, -3162,  6195,   717, -3162,
-   -2037, -3162, -3162,  -974,  -809,  -711, -1014, -1233, -1959, -3162,
-   -3162, -3162, -3162, -3162, -3162, -1522, -1807,  -655,   773, -3162,
-   -3162,   874, -3162, -3162, -3162,    92, -1436, -1777, -2135, -3162,
-   -3162, -3162,   780,  1481,    52,  -829, -1640, -3162, -1559, -3162,
-   -3162,   834, -2413, -3162, -3162,   392, -2682, -3162, -3162,   110,
-   -3162,  -623, -1129, -2489,   559,    16, -3162,  1773, -2585, -3162,
-   -3162,  -731, -2722, -1136,  -898, -3162,   107, -3162,   350,   112,
-   -1652, -3162,     6, -3162,  -443, -3162, -3162, -2634, -3162,   116,
-     130,  2172, -3162,  1114, -3162, -3162, -3162, -3162,  -601, -3162,
-    -630,  -632, -3162, -3162,    28,  -903,  1594, -3162,   132,   227,
-   -3162,   935, -3162,   698,   133, -3162,  2065,  -408,   137,  1266,
-   -3162, -3162, -3162,    11,  -621,   354, -3162,  1268, -3162, -3162,
-    1714,   647,   138, -3162,   289,    17, -3162, -3162, -3162,    83,
-     141,     7, -3030,   142, -2808, -1707,    -7, -3162, -3162, -3162,
-    -719, -3162, -2565
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -2102
-static const yytype_int16 yytable[] =
-{
-     525,   914,   872,    53,    57,    65,    82,   103,    68,   719,
-      69,    94,  1140,  1207,    77,   963,   525,    99,   884,  1244,
-    1036,  1964,  1315,   523,  1263,  1445,   858,    70,  1826,  1989,
-    1814,  1501,  1798,  1354,    77,   982,  1318,   784,  2221,   523,
-     718,  1779,  1815,  2188,  1607,   522,  1707,  2623,   778,  1417,
-    2024,  2327,  1415,  2105,  2336,  1864,  1172,  2144,  2055,   888,
-    2658,   817,  1418,  1371,   856,  1831,  2094,  1789,   525,   525,
-    2506,  1360,  2727,   810,  1764,  1419,  2613,  1377,    50,   889,
-     745,  1785,    51,  3049,    52,  2596,    55,  2598,  2121,  2122,
-      56,   523,   523,    59,    60,  3018,    61,  1684,  1896,   905,
-      63,    66,  1687,   870,    67,  2651,  1243,    80,  1249,  1819,
-    1253,  3047,    81,   817,   817,  3020,    83,   851,  1263,  2577,
-    3065,  2612,   976,   973,   965,   810,   810,  1620,   898,  1014,
-      84,  3062,    90,    91,  2843,  1039,  2710,    93,    98, -1949,
-    2192,   102,   104,   885,   886,  2911,  2358, -2089, -2089,  2916,
-    2354, -1373, -1949,  2508,  1060,  -454,  2241, -1314,  1060,  -527,
-    2460,  1982,  2244,  1584,  1585,  3137,  1983,  1061,  1348,  -371,
-    -870,  3267,  -875,   537,  -531, -1940,  -875,   983,  2714,  1384,
-    1597,  2136,  1348, -1295,  2718,  2719,  2712, -1957,  3472,  1770,
-     821, -1314,  2659, -1315,  1060,  -837,  1429,  2353,  2728, -1311,
-   -1311,  2526,  -878,  -850,  1440, -1940,  -865, -1957,  2136, -1315,
-     821,   821,  -878, -2080, -2080, -2098, -2098, -1312, -1312,  2146,
-     862,  1688,  1364,   821,  3553, -2075, -2075,  1060, -2100, -2100,
-    1364,   954,  1781,   819,  1692,  1060,  3201,  -229,  1781,  1159,
-    3254,  1941,  -229,  1817,  1196,   879,  1943,  1569,  1153,  2686,
-     876,  1829,  2765,  2767, -1132,  2770,  1199,  3271,  1339,  -527,
-    1830,   982, -1132,  1640,  2487,  2488,  3607,  1263,  1642,  3361,
-    3348,  3140,  3578,  1160,  -531,  2494,  1713,  1348,  -480,  2498,
-     876,  2350,  2735,  3184,  1773,   819,   819,  1008,  1941,  2804,
-     538,  1616,  1942,  1943,  1765,   881,  3237,  1340,  1650,  1589,
-     821,  3066,  3506,  2660,     3,     4,  2159,  3167,  3432,  3169,
-    -665,  1039,  1790,  1006,  1799,  1599,   880,  1802,  1803,  2883,
-    3602,  2885,  1257,  1014,  3538,  2481,  2482,  2483,  3040,  1981,
-     821,  2441,  1652,   881,  1157,  1689,  1790,  1710,  2175,  1832,
-    3459,   877,  3212,  3608,  1640,  2254,  2176,  2030,  1641,  1642,
-    3545,  1804,  1693,  1378,  3391,  2705,  2654,   821,  2185,  3591,
-    1015,  2470,  3291,  3476,  3392,  3328,  1981,  3330,   942,  -807,
-    2787,   877,  3496,  2216,  2123,  1192,  1759,  1760,  2247,  1650,
-   -2074, -2074,  2925, -1153,  3531,  2928,  1724,   113,  1611,   839,
-    1602, -1153,  2954,  2275,   881,  3268,  3426,  1809,  3427,  1186,
-    1763,  1640,  2588,  1602,  3589,  3440,  3198,   943,  1044,  1488,
-    3269,  1440,  1603,  1652,   992,  2433,  1781,  2471,  3236,  1045,
-    2662,  1810,  3210,  3261,  1877,  1603,  1604,  1782,  1836,  2924,
-    2160,  1569,  1021,  3518,  3273,  3609,  3521,  1526,  3507,  1606,
-    1813,  1161,  2722,  1162,  1775,  3614,  2461,  2161,  2907,  -527,
-    2967,  1194,  2162,  1612,  2276,  3262,  3377,  2147,  2217,  1690,
-    1220,  1489,  1318,  3560,  -531,  1349,  2955,  3067,  3441,  3586,
-    1652,   114,  3478,  2929,  2442,  2651,  1341,  2651,  3458,  1349,
-    3539,  3199,  3579,  3603,  2443,  2148,  3076,  3404,  3561,  -685,
-    2163,   840,  2655,   945,  1725,  2248,  1805,  3211,  2835,  1711,
-    1016,  1187,  1607,  3213,  1833,  -807,  1806,  1154,  2186,  3540,
-    3091,  2279,  1788,  3216,  3359,  3289,  1258,  3592,  1791,  2680,
-    -527,  1835,  1569,  2661,  3508,  2662,  1468,  1476,  3546,  3584,
-    3548,  3393,  2681,  1483,   989,  -531,  3433,  1601,  2065,  2930,
-    2351,  2931,  1791,   955,  2543,   882,  2698,  2699,  2700,  1640,
-    2956,  3058,  2137,  1641,  1642,  2663,  3554,   541,  3055,  2027,
-    1709,  2472,  3337,  1776,  2144,   863,   929,  1702,  1761,  3580,
-    3070,  3071,   559,  3519,  1349,  2342,  3202,  2502,   750,  2579,
-    1762,  1818,   878,  1155,  1650,  1788,   719,  2687,  1631,   826,
-    3610,  1766,  1342,  3082,  3041,  2270,  1054,  3349,  3581,  2804,
-    2149,  3270,  2335,   869,   869,  2339,  1584,  1585,  3360,  1788,
-    2151,  3248,  2521,  1602,   963,  1897,  2863,   951,  1652,  1898,
-     542,  2255,  2094, -1132,   912,  1902,  2774,  1350,   913,   535,
-    3420,  1597,  1580,  1941,  1990,  1603,   539,  1942,  1943,  -527,
-    1973,  1353,  1440,  1440,   982,  2241,  2600,  2164,  1440,  2399,
-    2626,  3369, -1949,  3018,  -531,  2012,   788,  3520,  3225,  3226,
-    2776,  1594,  2819,  2428,  2731, -1949,  2726,  2615,   901,  1815,
-   -1314,  2191, -1373,  3020,  1594,  2434,  -454,  -454,  -527,  1602,
-    -527,  1102,  1103,  -870,  2405,  -875,  2621,  1314, -1940,  1602,
-    -371,  2076,  2077,  -531,   912,  -531, -1295,  3340,   913,  3192,
-   -1957,  1603,  3341,  1635, -1314,  2462, -1315,  2177,  1587,  2720,
-     872,  1603,  2467,  1809,  2710,  1604,  1592,  2904, -1940,  -865,
-   -1957,  3311, -1315,  1685,  2193,  1606,  2146,  1368,  1369,  1899,
-    1586,   976,  1906,  1002,  3457,  1368,  1369,  1810,  1163,  1263,
-    2117,  1263,  -229,  -229,  1958,  1589,  1569,   981,  1640,  3251,
-    2798,  2546, -1153,  2499,  2934,  2275,  3465,  2499,  2706,  2707,
-    3343,   872,  1192,  2152,   789,  1599,  1673,    77,  2062,  1616,
-     784,  2892,  2422,  3464,  2153,  1979,  1727,  2423,  1616,  3353,
-    2935,   105,   978,  1650,  2905,  3265,  2520,   525,  1955,  1956,
-    1957,  1958,  2097,  1972,  2335,  1974,  1975,  2569,   525,  2053,
-    1020,  1438,   546,  1851,   972,   525,  2788,  2789,  2790,  2791,
-     523,  3183,  1217,  2777,  1217,  2884,  2648,  1652,  1218,  3086,
-    1218,   523,  1728,  2118,  1192,  2570,  2893,   820,   523,  1193,
-     550,   106,   817,  1208,   525,   525,  2424,  3266,  1194,   888,
-    3529,  1569,  1852,   817,  1670,  1671,  1672,  1673,  1158,  2203,
-     817,  2468,  3492,  3493,  3218,  1004,  3047,  3453,   525,   889,
-    1781,  1301,  3223,  -608,  1897,  2390,  1158,  2063,  -608,  3185,
-    3174,  1784,   859,  1005,  2204,  3252,  2069,  3256,    53,    57,
-      65,    82,   103,    68,  2305,    69,    94,  1195,  2187,    77,
-    1729,  1164,    99,  2468,  2308,  2805,  1362,  2311,  1727,  1363,
-    1194,   865,    70,  3148,  3533,   525,   719,   821,  3175,  1307,
-     525,  2696,  2304,  3262,  3018,   912,  1217,  2697,  3034,   913,
-    3035,  2139,  1218,  1219,  1173,  1219,   851,   851,  1854,   851,
-    3322,   851,  2589,  1440,  3020,  3125,  3323,  1908,  3127,  -608,
-    3129,  1730,  1060,  1910,  1728,  2571,   874,  2475,  1060,  1195,
-    2572,  3604,   875,    50,  2328,  2329,  2330,    51,  2363,    52,
-     890,    55,  1307,  2398,  3373,    56,   891,  2400,    59,    60,
-    2402,    61,  2267,   981,   872,    63,    66,  3346,  1569,    67,
-     525,   525,    80,  1790, -2071, -2071,   525,    81,  -608,   525,
-     525,    83,   525,   525,   525,   525,  2410,    77,  1317,  2303,
-     784,  2094,   908,  1731,   819,    84,  1360,    90,    91,   525,
-    2415,   525,    93,    98,  2854,   819,   102,   104,  2624,  2314,
-     525,   893,   819,  1060,  2321,   821,   108,  1219,    14,    15,
-   -1949,   912,   523,  1964,   523,  1627,  2179,   525,  1307,  1572,
-    2180,  1481,  3333,   523,  1989,  1486,   910,  1668,  1669,  1670,
-    1671,  1672,  1673,   916,   817,  1700,   817,   872,  1701,   525,
-    2601,  1903,  2602,  1730,  1904,   817,   810,  1790,  1004,   928,
-    1147,  1148,  1473,  1150,    23,  1152,  2306,   810,   525,   935,
-    1220,  2309,  1220,   912,  1465, -1295,  1005,   913,  2055,   525,
-     525,   525,  -209,   525,   525,  1480,   719,  3158,  1631,  1595,
-    1596,  2701,  1815,  2573,   947,  2026,   912,  2279,  2027,   939,
-    1627,  1820,  2938,  1628,  2574,   949,  2147,  1048,  1049,  1050,
-     952,  2632,  1053,  3436,   953,  1731,  3283,  1621,   956,   525,
-    1569,  1953,  1954,  1955,  1956,  1957,  1958,  1790,   931,  1221,
-     932,  1247,  1569,  1222,  2148,  1222,  2621,   525,   525,  1440,
-    1440,  1440,  1440,  1440,  1440,  2941,   957,  1440,  1440,  1440,
-    1440,  1440,  1440,  1440,  1440,  1440,  1440,  2466,   958,  1158,
-    1715,  1716,  1569,  1722,  2688,  1223,   933,  1248,   934,  1569,
-     989,  1393,  1394,   525,  1220,   959,  3378,   525,   525,  1791,
-     889,   889,   969,   889,   982,  1823,   109,   525,   525,   525,
-     541,  1790,   525,  1790,   998,  2805,  2051,   110,  1025,  2052,
-    1007,  2347,  1620,   940,  2348, -2072, -2072,    26,    27,    28,
-    1569, -2073, -2073,  1572,  1569,  2736,   819,  1009,   819,  2421,
-    1569,  2744,  2416,  2425,  1816,  2417,  2427,   819,   987,  1939,
-    1940,  3379,   111,  2814,  1026,  1960,  1224,  1222,  1224,   988,
-    3380,  1401,  1402,  1569,   990,  2524,  1788,  3243,  1307,  2149,
-    1474, -2076, -2076,   542,  2150,  2685,  1217,  1307,  2454,  2151,
-    1028,  2455,  1218,  1791,  3381,  2500, -2077, -2077,  2501,  1223,
-    3133,  1217, -2078, -2078,    33,   941,  1217,  1218,  1578,   993,
-      46,  1307,  1218,   112,   996,    35,  2503,  1059,  2676,  2501,
-    1941,  2677,  1041,  2682,  1942,  1943,  2683,   968,  1944,  1945,
-    1946,  1052,  2747,  3351,  1572,  2027,  2597,    37,  2945,  2811,
-     997,    38,  2501,   823,  1858,  1859,  1861,  1862,   999,  2689,
-     719,  2693,  1000,  2567,  1401,  1402,  3087,  1051,  2812,   719,
-    1788,  2052,  1001,  1791,  1440,  1440,  2380,  3382,  2381,  1721,
-    1224,  2670,  2815,  2672,    40,  2816,   981,  3600,  1217,  1002,
-    3383,  1891,  2799,  1046,  1218,    43,  2806,  2946, -2079, -2079,
-    1407,  1408,  2094,   719, -2081, -2081,    77,  1219,   525,   784,
-    2817,   879,    44,  2816,   942,  2947,  2899,  1055,  3587,  2900,
-    3588,   978,  1219, -2082, -2082,  1316,  -609,  1219,  1054,  1032,
-    3056,  -609,  3057,  2417,  1913,  2348,    45,  1791,  3080,  1791,
-    1788,  3081,  3088,   909,  3016,  3089,  3149,  1151,  1475,  2052,
-      46,  1167,  2152,   943,  3563,   869,  2635,  3284,   525,   525,
-    2052,  3613,  3285,  2153,   525,  2501,   525,  3317,  1175,  3575,
-    2052,   525,   525,   525,   525,   546,  3324,   972,  1174,  2027,
-    2958,  2717,   880,  1407,  1408,  1177,   525,   525,   944,   523,
-    1440,  2965,    23, -2083, -2083,   525,  3033,   525,  1178,  1219,
-     525,  2922,  -609,   550,  1788,   525,  1788,   525,   525,  3334,
-     525,   817,  3335,  2476,   525,  2477,  2948,  2478,   523,  2479,
-     523,  2836,  2837,   523,  3611,  2949,  1179,  3043,   523,  3612,
-    1181,   523,  3367,   523,  1182,  2417,  2957,   523,  2966,   945,
-     817,  1948,   817,  3368,  3401,   817,  2348,  2052, -2084, -2084,
-     817,  -609,   810,   817,   810,   817,  1190,   810,  3462,   817,
-     881,  2417,   810,  1209,  1220,   810,  1212,   810,  1572,  1473,
-    2003,   810,  2004,  1214,  3422,  2006,  3423,  1215,  3474,  1220,
-    2010,  3475,  1216,  2013,  1220,  2014,  2673,  1228,  2675,  2018,
-    3500,  3384,  3544,  3501,  3385,  3475,  3585, -2085, -2085,  3475,
-     525,   525,  1255,  1620,  1569,  1229,  2823,  2054,  2822,   525,
-     525,  1949,  2056,  1246,  2057,  2060,  1250,   525,    77,  2824,
-    2826,  2061,  1254,  1251,   525,  1310,   940,  1222,  2921,  1616,
-    2923,  2058,  2825,  2827,  2828,    26,    27,    28,  2266, -2086,
-   -2086,  1059,  1222,  2312,  1941, -2087, -2087,  1222,  1942,  1943,
-     719,   525, -2102, -2102, -2102,   525,  1220,  1313,   525,  1252,
-    1301, -2088, -2088,  1572,   525,   525,   525,   525,   525,   525,
-     525,   525,   719,  1189,  1223,  1191,   525,   525,   525,  2313,
-    1314,   525,  1319,   819,  1321,   525, -2090, -2090,   525,   525,
-     525,   525,   525,   525,   525,   525,   525,  1325,   941,   525,
-    2757,   523,    33,  2133,  1335,  1025,   525,  1337,  1307, -2091,
-   -2091,   882,   819,  1338,   819,  2319,  1345,   819,  1346,  1222,
-     982,  2188,   819, -2092, -2092,   819,   525,   819,  1561,  1352,
-    1224,   819,  -540,  3230,  2621,  2223, -2093, -2093,   541,    38,
-    1569,  1026, -2094, -2094,  1355,  1224,  1356,  -540,  1361,   525,
-    1224,  2320,  -540,  2117,  1379,   889,  1456,  1482,  1380,  1164,
-     525,   525,  1385,   869, -2095, -2095,  1443,  1028, -2097, -2097,
-   -2099, -2099,    40,  1458,  3193,  1459,  2435,  2436,  2437,  2438,
-    2439,  2440,  1478,    43,  2444,  2445,  2446,  2447,  2448,  2449,
-    2450,  2451,  2452,  2453,  1477,  2965,  1466,  1851, -2101, -2101,
-    1572,   542,  1484,  -540,  1838,  1839,  1569,  2242,  2243,   719,
-    1495,   719,  -660,  -660,  -664,  -664,  1440,  1440,  -663,  -663,
-    1403,  1404,  1224,  -540,  1950,  1951,  1952,  1485,  1953,  1954,
-    1955,  1956,  1957,  1958,  1491,  2030,  1852,  2915,    46,  1497,
-    2291,  1462,  2295,  1407,  1408,  3247,  1469,  1470,  1471,  3189,
-    3190,   525,  3050,  1230,  1574,  3079,  3039,  1575,  1307,  2749,
-    2751,   525,   525,  1492,   116,  3068,  1577,  1496,   536,  3597,
-    3598,  1853,  -540,  1231,   544,  3562,   749,  3571,  3572,  3564,
-    -841,  -540,  1696,  1697,  2640,  2641,  -848,  1586,  3400,    46,
-     838,  3160,  3310,  1590,   852,  -685,  1032,  -686,  -838,  -839,
-    1600,  -842,  1307,  -840,  1601,  1679,  1622,  1632,  1634,  1681,
-    1683,  1569,  1561,  1695,  1703,  1475,  1704,  1708,  1712,  1232,
-     719,  1193,  1854,  1714,  1195,  1949,  1749,  1307,   525,  1753,
-    1751,  1768,  2384,  1316,  3605,  1786,   981,  1787,  1788,  1793,
-    -208,  1794,  1900,  1795,  1901,  1800,  1807,  1808,  1812,  1822,
-     113,  1828,  1572,  1841,  1842,  1843,   525,   525,  1847,   525,
-    1850,  1857,  1856,  1865,  1572,   525,   525,   525,   525,   525,
-     525,  2564,  2565,   525,   525,   525,   525,   525,   525,   525,
-     525,   525,   525,   546,  1869,   547,  1866,  1872,   525,   525,
-    1873,  1875,   525,  1876,  1572,  2621,  1878,  1879,   917,   525,
-    1892,  1572,  3016,  1561,  1893,  1897,  1905,  1930, -1831,  1569,
-    1932,   550,  1440,  1933,  1935,  1233,  1969,  1938,  1961,  1970,
-    1977,  1980,  2000,   525,   918,  2005,  2002,  2011,   525,  2015,
-     525,  2016,  -540,  2017,   525,  2022,  2025,  1440,  1580,  2028,
-    1587,  3400,  1572,  1592,  2029,  2031,  1572,  1217,   525,  2032,
-    1307,   523,  1572,  1218,  2034,  2064,  2033,   523,  2065,  1060,
-    2098,  1230,  1640,  2099,  1234,  2102,  2106,  3365,  3231,  3232,
-    2109,  3221,  2111,   817,  1235,  1572,  2114,  2112,  2113,   817,
-    2135,  1231,  2182,  3400,  1989,   810,  1236,   525,   525,  2158,
-     919,   810,  2155,  1569,  2183,  2189,  2156,  2201,  2202,  2206,
-     880,   912,  2222,  2489,  1177,   913,  2231,  3124, -1831,  2492,
-    2219,  2232,  2233,  2236,  2234,  2253,   985,  2235,  1237,   920,
-    2257,  2268,  2258,  2261,  2273,   525,  2272,  1232,   872,   525,
-    2274,   881,  3400,  2331,   525,   525,  2332,  2333, -2102, -2102,
-   -2102,  2345,  1953,  1954,  1955,  1956,  1957,  1958,  1043,  2355,
-    2349,  2366,  2367,  2364,  2368, -1831,  1620,  2369,  1219,  2370,
-     525,   525,   921,  2371,  2385,   525,  1022,  3455,  2388,  2386,
-   -1831,  1023,  1239,  1149,  2391, -1831,  2392,  2393,  1440,  2394,
-   -1831,   525,  2395,  2397,   525,   525,   525,  1439,  2418, -1831,
-    2401,  2426,  1966,  1941, -1831,  2456,  1965,  1240,  2485,  2463,
-    1569,  2473,   525,   719,  2464,  3416,  2465,  2493,   523,   525,
-    2469,  2474,   525,  2505,  2507,  2491,  1242,  2512,  2513,  2514,
-    2516,   823,  2523,  1233,  2517,  2518, -1831,  1561,  2519,   525,
-    1024,  2550,  2522,  2538,  1569,   523,  2530,  2533,  3207,  2531,
-    2539,  1230,   525,  2536,  2534,   819, -1831,  2535,  2546,  2537,
-    1612,   819,   523,  2540,  2541,  2560,  2561,   817,  2568,   525,
-     525,  1231,  2563,  3016,  2575,  2584,  2585,  2592,  2590,   810,
-    2591,  2604,  1234,  2603,   817,  2606,   525,  2608,   525,  2609,
-    2614,  2616,  1235,  2617,  2628,  -666,   810,  2627,  2630,   922,
-    2631,   525,  2634,  2638,  1236, -1831,  2639,  1766, -1831,  2642,
-     923,  2644,  1025,   541, -1831,  2647,  2646,  1232,  1370,   719,
-     719,   719,  2650,  2669,  2671,  1220,  1569,  2703,  1413,  2684,
-    2690,  1440,  1561,  2716,  2702,  2721,  1237,  2733, -1359,  2715,
-    1815,  2737,  3550,  2741,  2738,   924,  2691,  3354,  1026,  2692,
-    2291,  2291,  2291,  2745, -1831,  2734,  2754,  1594,   525,  2764,
-     872,  2775,  2772,  2795,  1027,  2778,  2781,  1307,   925,  1569,
-    2796,  2271,  2782,  2783,  1028,  2807,   542,  2808,  2813, -1831,
-    2832,  2280,  2839,  2283,  1238,  2784,  2294,  2961,  1222,  2821,
-    1239,  2851,  2298,  2829,  2300,  1742,   926,  1858,  1859,  1861,
-    1862,   719,   982,  2840,  1439,  2850,  1572,  2307,  1029,  2859,
-    2861,  2862,  2310,  1233,  2865,  1240,  2315,  2316,  2317,  2318,
-    1241,  2322,  2323,  2867,  2868,  2880,   525,  2889,  2874,  1206,
-     543,  2908,  1913,  1631,  1242,  2875,  2912,   859,  2882,   819,
-    2886,   525,   981,  2906,  2920,  2926,  2910,  2927,  1633,   544,
-     719,  2953,  2933,  2969,  1030,  3036,   819,  3037,  1636,  3038,
-    3045,  1031,  1234,  3042,  3046, -1831,  3053,  3054,  3059,  1561,
-    3060,  3064,  1235,  3072,  3073, -1831,  3077,  2348,  3084,  1569,
-    1686,  1913,  3085,  2117,  1236,  3090,  3110,  3112,   525,  1691,
-    3116,  1224,  3120,  3130,  3131, -1831,  3134, -1831, -1831,  3180,
-    3135,  3161,  3168,  1032,  3171,  3173,  3182,  3186,   545,  3187,
-    3188,   523,  3194,  3415,  3195,  -208,  1237,  1059,  3196,  3200,
-    1941,  3405,  1033,  3407,  1942,  1943,   525,  3204,  1944,  1945,
-    1946,  3205,  3206,   817, -1831,  3214,  3219, -1831, -1831, -1831,
-    3217,  3220,  1572,   872,  3224,  3239,  3240,  1440, -2070,  1158,
-    3417,  3244,  3419,  3238, -2071, -2072,  3537, -2073,   546,   525,
-     547, -2074,  3241, -2075, -2076,   525,   525,  3498, -2077, -2078,
-    1239, -2079, -2081,  3255,  3242,  2877,  3257,   548, -2082, -2083,
-     525,   872, -2084,   549, -2085, -2086,   550, -2087, -2088, -2090,
-    3491,  1034, -2091, -2092, -2093,  1240,   525, -2094, -2095,   525,
-    3502,   525, -2096, -2097, -2098, -2099, -2100, -2101,  1572,   525,
-   -1312,  3245,   525,   525,  1242,  3272,  3253,   525,   525,  3083,
-    3258,  1561,  3260,  3274,   525,  3277,  3276,  3280,  3286,  3486,
-    1563,  3287,  2914,  1561,  3290,  1439,  1439,  3304,  3292,   525,
-    3294,  1439,  3306,  3298,  3301,  3300,  3305,  2054,  3309,   525,
-    3312,  3313,  2056,  3316,  2057,  2060,   521,   532,    77,  1022,
-    3331,  2061,   557,  1561,  1023,  3332,  3336,  3339,   557,   525,
-    1561,  2058,   807,  3342,   822,  3344,  3356,  2898,   825,   557,
-     834,  3357,  2894,   834, -1311,  3364,   854,   854,  3366,  3372,
-     854,  3374,  3375,   557,   557,  3402,    23,  3388,  3389,  3403,
-    3390,  3406,  3409,  3412,  3410,   819,  3418,  3424,  1947,  3444,
-     719,  1561,  3213,  3019,   719,  1561,   719,  1912,  3448,  3450,
-    3451,  1561,  3454,  1024,   807,   807,   541,  3467,   525,  3468,
-     525,  1948,  3460,  2938,  3472,  3469,  3477,    23,  3479,  2939,
-    1569,  2291,  3481,  3164,  1561,  3021,  3484,  2295,  3075,  3488,
-     854, -1359,  2940,  3485,  3490,  3499,  3489,   854,   557,   854,
-     854,   854,  3495,  3497,  1858,  1859,  1861,  1862,  3504,  3509,
-    3516,  3517,  3515,  3522,  3523,  3524,  2941,  3532,  2942,  3534,
-    3542,  3526,  3552,  3048,  3536,  3209,  3555,  3557,  3573,   542,
-    3576,  3554,  3553,  1373,  3590,  1025,   872,  3601,  3595,  3606,
-    1900,  1949,  -540,  1203,  3616,  3615,  1180,  2968,   525,  2299,
-    2667,  1572,  3069,  1059,  1563,  3431,  1941,  -540,  3530,  3494,
-    1942,  1943,  -540,  2972,  1944,  1945,  1946,  2901,   525,   525,
-    3599,  1026,  2403,   525,  3227,   541,   525,  2756,  1156,    26,
-      27,    28,  1059,  2362,  3513,  1941,  3583,  1027,  3352,  1942,
-    1943,  3551,  3558,  1944,  1945,  1946,  1778,  1028,  3577,  3387,
-   -1359,  2649,  3063,   525,  2674,  3549,  2943,  2937,  3556,  2895,
-    2856,  3022,  2645,  -540,  3547,  1895,  2748,  1855,  2750,  2711,
-      26,    27,    28,   525,  2761,  3281,  3044,  2633,  1705,   525,
-     525,  1029,   872,  -540,   525,  1572,  1463,  1464,   542,   525,
-    2619,  1230,   525,   525,  2260,  1563,    33,   525,  1307,  1746,
-    2786,   525,  1204,  1745,  3535,   525,  2629,   914,  2228,  3480,
-    3408,  1231,   525,  2259,   811,  2605,  2230,  2497,  3282,  1750,
-    3119,  3308,  2780,  1637,  2944,  2779,  1430,  1030,   523,  2945,
-    3358,  2810,  -540,    38,  1031,  2511,  3229,    33,  1414,  1416,
-    1420,  -540,   971,  1421,  2412,  1422,  2413,  1423,  2414,  1424,
-     817,  1425,  1426,  3483,  1373,  3482,   525,  1232,  2959,  2558,
-    2834,   546,   810,   972,   525,  2582,    40,  2622,  2960,  2580,
-    2527,  3172,  2740,  3143,    38,  1991,  1032,    43,  2946,  2559,
-    1465,  2853,  3470,   525,  2887,  2343,   549,  1907,  1211,   550,
-    2504,   986,  1572,  3144,  2256,  1033,  2947,  2197,  1824,  2902,
-    2199,  2694,     0,     0,  1950,  1951,  1952,    40,  1953,  1954,
-    1955,  1956,  1957,  1958,     0,     0,     0,  1948,    43,     0,
-     545,  2194,     0,     0,     0,     0,  3019,  2961,     0,     0,
-       0,     0,    46,     0,  1373,    44,     0,  1373,  1373,     0,
-       0,     0,     0,     0,     0,     0,  1948,     0,     0,     0,
-       0,     0,     0,  1233,     0,  1561,     0,     0,     0,    45,
-       0,     0,     0,     0,  1034,     0,     0,     0,   719,  1205,
-     546,     0,   972,  2896,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   872,  1949,     0,   548,
-       0,     0,  -540,  2263,  2265,   549,   525,  2948,   550,  1913,
-       0,     0,  1234,     0,   981,     0,  2949,   525,  1572,     0,
-       0,     0,  1235,     0,     0,     0,  1949,  3264,     0,  1563,
-       0,     0,   819,   525,  1236,     0,  2962,     0,     0,     0,
-       0,     0,  1439,  1439,  1439,  1439,  1439,  1439,     0,     0,
-    1439,  1439,  1439,  1439,  1439,  1439,  1439,  1439,  1439,  1439,
-       0,  1572,  2324,     0,    23,     0,  1237,   525,     0,     0,
-       0,   912,     0,     0,     0,   913,     0,     0,  2340,  2340,
-       0,  1909,  1911,     0,   525,   525,     0,     0,   525,   854,
-     525,     0,     0,     0,   854,     0,     0,   854,     0,     0,
-       0,  1561,     0,     0,     0,   557,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   525,     0,     0,     0,     0,
-    1239,     0,     0,     0,  1563,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  2078,     0,     0,  2917,   525,
-       0,  2918,  2079,  2080,     0,  1240,  2081,  2082,  2083,     0,
-       0,  1370,     0,     0,     0,     0,     0,  2420,     0,     0,
-       0,     0,     0,     0,  1242,     0,  2963,  1561,  2970,  2964,
-       0,  3019,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  3023,  3024,  3025,  3026,  3027,  3028,  3029,
-    3030,  3031,  3032,   719,     0,     0,    14,    15,   853,     0,
-       0,     0,   861,     0,     0,     0,     0,    26,    27,    28,
-    1950,  1951,  1952,   525,  1953,  1954,  1955,  1956,  1957,  1958,
-       0,     0,  3370,   525,  1913,   525,     0,   525,     0,     0,
-       0,   525,     0,   525,     0,   525,   523,  1439,  1439,  1950,
-    1951,  1952,    23,  1953,  1954,  1955,  1956,  1957,  1958,   525,
-       0,     0,     0,     0,   525,     0,   525,     0,   817,     0,
-       0,  1563,   897,     0,   525,     0,     0,     0,     0,   900,
-       0,   903,  1561,   907,    33,     0,     0,   719,     0,  1788,
-       0,     0,   525,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   961,   557,   557,     0,  3428,
-       0,  3430,     0,     0,     0,  2070,     0,     0,  3437,     0,
-       0,    38,     0,     0,     0,     0,     0,  2100,     0,  2101,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   525,
-       0,     0,     0,  1564,     0,     0,     0,   984,   532,   525,
-       0,  3463,     0,   521,    40,   854,     0,  2119,     0,     0,
-       0,   525,     0,  1439,   807,    43,     0,  3466,  1011,  1011,
-       0,   807,     0,     0,  1011,  1038,   525,     0,     0,     0,
-    1561,     0,    44,     0,     0,     0,     0,   834,   834,   834,
-       0,     0,   834,     0,   525,    26,    27,    28,  1916,   523,
-    1106,  1106,   834,   834,     0,   834,    45,   834,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   525,   854,
-      46,   817,     0,  1563,     0,   557,     0,     0,     0,  2620,
-       0,     0,     0,   525,     0,  1563,     0,   854,     0,     0,
-     819,   523,  3019,     0,   719,  1917,     0,     0,     0,  3208,
-       0,   854,   822,     0,     0,     0,     0,     0,     0,     0,
-    2240,  2240,    33,   817,  1561,  1563,  1918,   525,  2383,     0,
-       0,     0,  1563,    35,     0,  3437,     0,     0,     0,     0,
-       0,   525,   525,   525,  1919,     0,   854,  1312,  1920,    23,
-     523,     0,     0,  3559,     0,    37,     0,     0,  1323,    38,
-       0,     0,   854,   854,   854,   854,     0,     0,   525,     0,
-       0,  1921,   817,  1563,  1922,     0,     0,  1563,  1344,  3574,
-       0,     0,     0,  1563,  1373,     0,     0,  1564,     0,     0,
-    1923,     0,    40,     0,  1373,     0,     0,  1373,     0,     0,
-       0,  2678,     0,    43,     0,     0,  1563,     0,  1566,   525,
-    1011,  1038,     0,   854,     0,     0,  1437,  1567,     0,     0,
-      44,     0,  1011,  1011,     0,     0,     0,     0,     0,   557,
-       0,  1561,     0,     0,     0,   807,     0,   807,     0,    71,
-       0,     0,     0,     0,    45,     0,   807,     0,     0,     0,
-       0,     0,     0,   819,  2708,     0,   557,     0,    46,    71,
-       0,     0,   809,     0,     0,  1561,     0,     0,     0,     0,
-       0,     0,  2723,  1576,     0,  1022,    71,     0,  1564,     0,
-    1023,     0,     0,  1924,     0,   871,     0,     0,     0,     0,
-       0,  1925,    26,    27,    28,   819,  1373,     0,     0,     0,
-       0,     0,  2084,  2085,  2086,     0,  2087,  2088,  2089,  2090,
-    2091,  2092,     0,  1926,   809,   809,   887,  1370,     0,     0,
-       0,     0,     0,     0,   557,     0,     0,  2762,     0,  2763,
-       0,     0,     0,  2768,     0,  2771,     0,     0,     0,  1024,
-      71,     0,  1927,     0,   819,     0,     0,  1561,     0,  1439,
-    1439,     0,     0,     0,     0,     0,     0,     0,     0,    33,
-       0,  1639,     0,     0,  1640,     0,     0,     0,  1641,  1642,
-       0,   930, -2102, -2102, -2102,     0,   937,  1699,     0,   938,
-       0,     0,     0,     0,     0,     0,  3355,     0,     0,     0,
-    1561,     0,  1566,   557,   557,     0,    38,     0,     0,  1650,
-     854,  1567,     0,     0,     0,     0,  1651,     0,  3362,  3363,
-       0,  1025,     0,     0,     0,     0,     0,     0,     0,  2515,
-       0,     0,     0,  1437,  1106,  1106,     0,     0,     0,    40,
-       0, -1833,  3376,  1652,     0,   854,  1777,     0,     0,     0,
-      43,  1022,     0,     0,     0,     0,  1023,  1026,   854,     0,
-       0,     0,     0,     0,     0,     0,     0,    44,     0,     0,
-       0,     0,     0,  1027,  1568,   854,     0,     0,     0,   854,
-    1217,     0,     0,  1028,  1825,     0,  1218,     0,     0,     0,
-       0,    45,     0,  1566,  1230,     0,     0,     0,     0,     0,
-       0,     0,  1567,     0,     0,    46,     0,     0,     0,     0,
-    1561,     0,  1564,     0,  1231,  1024,     0,  1029,     0,     0,
-       0,     0,     0,     0,     0,  3263,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1563,     0,     0,
-    1653, -1833,     0,  1844,     0,   854,    23,     0,     0,     0,
-       0,     0,     0,     0,   854,  1439,     0,  1654,     0,     0,
-    1232,  1639,  1655,  1030,  1640,  1888,     0,     0,  1641,  1642,
-    1031,     0,     0,     0,   961,     0,     0,     0,     0,   961,
-    3113,   557,   557,     0,   557,   961,  2599,  1025, -1833,     0,
-       0,  1219,     0,     0,     0,     0,     0,     0,  3012,  1650,
-    1658,     0,     0, -1833,     0,     0, -2102,  1564, -1833,     0,
-       0,     0,  1032, -1833,     0,     0,     0,     0,     0,  2625,
-    2625,     0, -1833,  1026,     0,     0,     0, -1833,     0,  2708,
-    3142,  1033,     0,  1652,     0,     0,     0,   995,     0,  1027,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1028,
-       0,     0,     0,     0,     0,  1661,  1233,     0,  1568, -1833,
-       0,     0,     0,     0,  1437,  1437,     0,     0,     0,     0,
-    1437,     0,   521,  1563,  3543,     0,     0,     0,     0, -1833,
-       0,     0,     0,  1029,     0,  1011,     0,   557,  1984,    26,
-      27,    28,  1106,  1106,     0,   854,     0,     0,  2566,     0,
-    1034,   807,     0,   807,  2007,  1234,   807,     0,     0,     0,
-       0,   807,     0,  1106,   807,  1235,   807,  1566,     0,     0,
-     807,  1439,   557,     0,   557,     0,  1567,  1236, -1833,  1030,
-   -2102, -1833,     0,  1210,     0,     0,  1031, -1833,     0,  1563,
-       0,     0,     0,     0,  1564,     0,     0, -2102,  1220,  1568,
-       0,     0, -2102,     0,     0,     0,    33,  1663,     0,  1237,
-       0,     0,     0,     0,     0,     0,     0,     0,  1311,     0,
-       0,  1561,     0,     0,     0,     0,     0, -1833,  1032,     0,
-       0,     0,     0,     0,  1327,  1329,  1332,  1334,    71,     0,
-   -2102,     0,     0,    38,     0,     0,     0,  1033,     0,     0,
-       0,     0, -1833,     0,  3170,     0,     0,  2301,     0,     0,
-       0,  1222,  1566,  1239,     0,     0,     0,   558,     0,     0,
-       0,  1567,     0,   558,     0,     0,    40,   808,     0,  2093,
-       0,     0,     0,     0,   558,  1432,     0,    43,  1240,     0,
-       0,   557,     0,  2302,  1563,  1661,     0,     0,   558,   558,
-       0,     0,     0,     0,    44,     0,     0,  1242,     0,     0,
-     859,     0,     0,     0,  1439,  1664,  1034,     0, -2102, -2102,
-   -2102,  2008,  1668,  1669,  1670,  1671,  1672,  1673,    45,   808,
-     808,   961,     0,     0,  1437,     0,     0,     0, -1833,     0,
-       0,     0,    46,     0,     0,     0,  1564,     0, -1833,     0,
-       0,     0,     0,     0,     0,     0,  2818,  2820,  1564,     0,
-       0,     0,  1106,   558,  1224,     0,     0,     0, -1833,     0,
-   -1833, -1833,     0,     0,     0,     0,     0,  2195,     0,   854,
-       0,   854,     0,     0,     0,     0,     0,     0,  1564,     0,
-       0,   854,  1563,  2211,     0,  1564,     0, -2102,     0,  1566,
-       0,     0,     0,     0,     0,  1437,     0, -1833,  1567,     0,
-   -1833, -1833, -1833,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  3259,  1568,     0,     0,     0,     0,  1230,     0,
-     854,     0,   557,     0,     0,     0,  1564,     0,     0,     0,
-    1564,     0,     0,     0,  2262,  2264,  1564,     0,  1231,  1370,
-    1777,   557,    71,   871,     0,     0,     0,     0,     0,     0,
-       0,   557,  2281,   557,  2285,     0,   557,     0,     0,  1564,
-       0,     0,   557,     0,   557,     0,  1563,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   961,   557,     0,     0,
-       0,   961,   557,   991,  1232,     0,   557,   557,   557,   557,
-       0,   557,   557,     0,  1003, -2102,     0,  1769,     0,     0,
-       0,  1019,  1668,  1669,  1670,  1671,  1672,  1673,  1568,     0,
-    1796,  2344,     0,  1373,     0,     0,     0,     0,     0,  1323,
-    3414,   854,   854,   854,   854,   854,  3329,     0,     0,     0,
-       0,  1821,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1566,  2373,     0,     0,     0,   887,     0,     0,     0,
-    1567,     0,     0,  1566,     0,     0,     0,     0,     0,     0,
-       0,  2396,  1567,     0,    71,     0,     0,     0,     0,     0,
-       0,     0,     0,  1563,     0,     0,     0,     0,     0,     0,
-    1233,     0,     0,  1566,     0,     0,     0,     0,     0,     0,
-    1566,     0,  1567,     0,     0,     0,  3012,  1849,     0,  1567,
-       0,     0,     0,     0,     0,     0,  1868,  1563,     0,     0,
-       0,  1437,  1437,  1437,  1437,  1437,  1437,     0,     0,  1437,
-    1437,  1437,  1437,  1437,  1437,  1437,  1437,  1437,  1437,  1234,
-       0,  1566,     0,     0,     0,  1566,     0,     0,     0,  1235,
-    1567,  1566,     0,     0,  1567,  1568,  3126,    11,     0,   557,
-    1567,  1236,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   854,  1566,     0,     0,     0,     0,     0,
-       0,     0,    71,  1567,   807,    14,    15,     0,     0,     0,
-     807,     0,     0,  1237,     0,     0,   557,     0,     0,  1563,
-       0,   557,     0,     0,     0,     0,     0,     0,     0,     0,
-    2509,  2509,     0,     0,     0,   809,     0,  1003,     0,     0,
-       0,     0,     0,     0,     0,     0,   809,     0,     0,     0,
-       0,    23,     0,  1639,  3456,     0,  1640,     0,     0,    23,
-    1641,  1642,  1563,     0,     0,     0,     0,  1239,     0,     0,
-       0,  1639,     0,     0,  1640,     0,     0,  1998,  1641,  1642,
-       0,  1579,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1650,  1240,  1591,     0,     0,     0,     0, -2102,     0,
-       0,     0,   557,     0,     0,     0,     0,  2552,     0,  1650,
-    1564,  1242,   557,     0,     0,     0, -2102,     0,     0,     0,
-    1618,  1373,     0, -1848,     0,  1652,  1373,  1568,     0,     0,
-     558,     0,     0,     0,     0,     0,  1437,  1437,     0,  1568,
-       0,     0,     0,  1652,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  2093,     0,     0,     0,     0,
-       0,  1437,     0,     0,     0,     0,     0,     0,     0,  1568,
-       0,     0,  1563,  1909,  1911,     0,  1568,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  3012,   807,     0,
-    2576,  3429,     0,     0,    26,    27,    28,     0,     0,     0,
-     557,     0,    26,    27,    28,   807,     0,   887,   887,  2211,
-     887,     0,     0,     0,     0,     0,     0,  1568,     0,     0,
-       0,  1568, -2102, -1848,     0,     0,     0,  1568,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0, -2102,
-   -2102,     0,     0,     0, -2102,     0,  1564,     0,     0,   557,
-    1568,     0,  1437,     0,  1106,   557,     0, -2102,     0,     0,
-       0,    33, -2102,     0,     0,     0,     0,     0,     0,    33,
-   -1848,     0,    35,     0,     0,  1844,     0,     0,     0,     0,
-       0,     0, -2102,     0,     0, -1848,     0,     0,     0,     0,
-   -1848,     0,     0,     0,    37, -1848,     0,     0,    38,     0,
-   -2102,     0,     0,     0, -1848,     0,    38,     0,     0, -1848,
-       0,  2196,  1564,  2198,     0,  1566,     0,     0,    39,     0,
-       0,   558,   558,  2208,  1567,     0,     0,     0,     0,     0,
-       0,    40,     0,     0,     0,     0,     0,  1661,     0,    40,
-       0, -1848,    43,     0,     0,     0,     0,  1844,     0,     0,
-      43,     0,     0,     0,   854,  1661,     0,     0,     0,    44,
-       0, -1848,  2245,     0,     0,  1323,     0,    44,  1844,   854,
-     854,   854,     0,     0,     0,     0,     0,     0,     0,   808,
-       0,    71,   557,    45,   854,     0,     0,   854,  1909,  1911,
-       0,    45,     0,     0,   854,     0,     0,    46,     0,     0,
-     961,  1373,     0,     0,     0,    46,     0,     0,     0,     0,
-   -1848,     0,     0, -1848,     0,     0,     0,  1564,     0, -1848,
-       0,     0,  1844,  1844,     0,  1844,     0,     0,     0,     0,
-       0,     0,     0,  1563,     0,     0,     0,     0,     0, -2102,
-     558,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1566,     0,     0,   521,     0,     0, -2102,     0, -1848,
-    1567,     0,     0,  2356,  2357,  2359,  2360,  2361,     0,     0,
-       0,     0,  2785,     0,     0,     0,     0,     0,     0,     0,
-     854,   854,   854,     0, -1848,     0,     0,     0,     0,     0,
-     557,   809,  1437,   809,   557,     0,   809,     0,     0,     0,
-     557,   809,     0,     0,   809,     0,   809,     0,     0,     0,
-     809,     0,     0,     0,     0,  1564,  1059,  1566,     0,  1941,
-     854,     0,     0,  1942,  1943,     0,  1567,  1944,  1945,  1946,
-       0,     0,     0,     0,  2093,     0,     0,     0,     0,     0,
-       0,     0,   859,     0,  2857,   557,     0, -2102,     0,   557,
-       0,     0,     0,     0,  1668,  1669,  1670,  1671,  1672,  1673,
-       0,     0,     0,     0,     0, -2102,     0,     0,     0,     0,
-   -1848,  1568,  1668,  1669,  1670,  1671,  1672,  1673,  1437,  1437,
-   -1848,     0,     0,     0,  1457,     0,     0,     0,     0,     0,
-     808,     0,   808,    71,     0,     0,     0,     0,     0,  1564,
-   -1848,   808, -1848, -1848,     0,  2480,     0,  2891,     0,     0,
-       0,  1494,     0,  2211,     0,     0,     0,     0,     0,     0,
-       0,     0,  1566,     0,     0,     0,     0,     0,     0,   854,
-       0,  1567,     0,   557,     0,  1106,     0,   557,   557, -1848,
-       0,   557, -1848, -1848, -1848,  1844,  1777,  1844,  1059,  1888,
-       0,  1941,     0,     0,     0,  1942,  1943,     0,     0,  1944,
-    1945,  1946,  1373,     0,     0,     0,     0,     0,   557,     0,
-    2971,     0,     0,     0,  2143,     0,  3151,     0,     0,  1623,
-       0,     0,     0,   557,   557,   557,   557,   557,   557,   557,
-     557,   557,   557,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1564,  1568,     0,     0,
-       0,     0,     0,     0,  2373,     0,     0,     0,     0,     0,
-    1566,   854,     0,     0,     0,     0,     0,     0,     0,  1567,
-    1948,     0,     0,  1777,     0,     0,     0,     0,     0,     0,
-    1564,     0,   887,     0,     0,     0,     0,  1059,   558,   558,
-    1941,     0,     0,  1888,  1942,  1943,     0,     0,  1944,  1945,
-    1946,     0,     0,  1844,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1568,  1437,  3152,     0,     0,     0,     0,
-     557,     0,     0,     0,     0,     0,     0,   854,   854,   854,
-     854,     0,     0,     0,     0,     0,     0,     0,     0,  1437,
-    1949,     0,  1437,     0,  1566,     0,   557,   961,     0,     0,
-       0,     0,     0,  1567,     0,  3128,     0,     0,  1639,     0,
-       0,  1640,  1564,     0,     0,  1641,  1642,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   557,     0,
-       0,     0,     0,     0,     0,  3136,   557,     0,     0,     0,
-    2552,     0,     0,     0,     0,     0,  1650,     0,     0,     0,
-       0,     0,  1948, -2102,     0,  1564,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1568,  3165,
-       0,   807,  2365,     0,     0,     0,     0,     0,  1106,     0,
-    1652,     0,     0,     0,    71,  3177,     0,     0,     0,  2211,
-       0,     0,     0,     0,     0,  2093,     0,     0,     0,     0,
-       0,  1566,     0,     0,     0,     0,     0,     0,     0,  1777,
-    1567,     0,     0,     0,     0,  1844,   558,   558,     0,   558,
-       0,     0,  1949,     0,     0,     0,     0,     0,   961,   557,
-    1437,     0,     0,     0,     0,  1566,   854,     0,     0,     0,
-       0,     0,     0,     0,  1567,  2866,     0,     0,     0,     0,
-       0,  1948,     0,  3228,     0,     0,  2713,     0,     0,     0,
-       0,     0,     0,     0,     0,  1564,  1568,     0,     0,     0,
-       0,  2729,  2730,  2732,     0,     0,     0, -2102,     0,     0,
-       0,     0,     0,     0,     0,     0,  2743,     0,     0,  2746,
-       0,     0,     0,     0, -2102,     0,  2755,     0,     0, -2102,
-       0,     0,     0,  1950,  1951,  1952,     0,  1953,  1954,  1955,
-    1956,  1957,  1958,     0,   809,     0,     0,  1566,     0,     0,
-     809,  1949,   558,     0,     0,     0,  1567,     0,     0,     0,
-       0,  3246,     0,     0,     0,  1844,   808, -2102,   808,     0,
-       0,   808,     0,     0,     0,     0,   808,     0,  2373,   808,
-    1568,   808,     0,     0,     0,   808,     0,  2019,     0,  2023,
-    1566,     0,     0,     0,     0,     0,  3278,     0,     0,  1567,
-       0,     0,     0,  1437,     0,     0,     0,     0,     0,     0,
-       0,     0,  2792,  2793,  2794,     0,     0,     0,     0,     0,
-       0,     0,  1661,     0,     0,     0,     0,     0,     0,  3295,
-       0,     0,     0,     0,     0,   557,     0,     0,     0,     0,
-       0,     0,   557,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  3314,
-       0,     0,     0,     0,     0,  1950,  1951,  1952,     0,  1953,
-    1954,  1955,  1956,  1957,  1958,     0,     0,     0,     0,     0,
-       0,  1618,     0,  3326,     0,     0,     0,  1568,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1566,  2143,     0,     0,     0,   557,  2104,     0,     0,  1567,
-     557,     0,     0,     0,     0,     0,     0,  2586,     0,     0,
-       0,  1568,     0,     0, -2102,     0,     0,     0,   809,     0,
-       0,  1059,     0,     0,  1941,     0,   557,     0,  1942,  1943,
-       0,     0,  1944,  1945,  1946,   809,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1564,     0,   557,   557,
-       0,  2909,     0,     0,  1950,  1951,  1952,     0,  1953,  1954,
-    1955,  1956,  1957,  1958,     0,   854,     0,  1777,     0,     0,
-       0,     0,   557,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   854,     0,     0,  3397,
-       0,     0,     0,  1568,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1437,
-       0,  1106,     0,   557,  1011,     0,  1011,     0,     0,     0,
-       0,   557, -2102,     0,     0,     0,     0,     0,     0,  1668,
-    1669,  1670,  1671,  1672,  1673,     0,  1568,   558,     0,     0,
-    1106,     0,     0,  3052,  3177,     0,     0,     0,     0,     0,
-    1639,   854,     0,  1640,     0,     0,   558,  1641,  1642,     0,
-       0,     0,     0,     0,     0,     0,   558,     0,   558,     0,
-       0,   558,     0,     0,     0,     0,     0,   558,     0,   558,
-       0,   854,     0,     0,     0,     0,     0,     0,  1650,     0,
-       0,     0,   558,   871,     0, -2102,     0,   558,     0,     0,
-       0,   558,   558,   558,   558,     0,   558,   558,     0,  3092,
-    3093,  3094,  3095,     0,     0,     0,     0,     0,     0,  3295,
-       0,     0,  1652,     0,     0,     0,     0,  1106,     0,     0,
-       0,     0,     0,     0,     0, -2102,     0,     0,     0,     0,
-       0,     0,  3397,     0,     0,     0,  1568,     0,     0,     0,
-       0,  1566,     0,     0,   -46,     0,     0,     0,     0,     0,
-    1567,     0,     0,     0,     0,     0,     0,     0,     0,  1777,
-       0,     0,     0,     0,     0,     0,     1,     0,     0,     0,
-       0,   961,   961,     0,  3397,   961,     2,  2869,     3,     4,
-       0,     0,     0,  1984,     0,     0,  1121,  1121,     0,     0,
-       0,     5,     0,     0,   557,  1949,     6,     0,     0,     0,
-       0,     0,     0,     0,     0,     7,     0,     0,     0, -2102,
-       0,     0,     0,     0,     0,     0,  1777,     0,     0,     8,
-       0,     0,     0,  3397,     0,     0, -2102,     0,     9,     0,
-      10, -2102,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    11,     0,    12,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   558,    13,     0,  1259,  3215,     0,
-     961,  1302,  1309,     0,     0,     0,  1618,     0,     0, -2102,
-      14,    15,    16,     0,     0,  2211,     0,     0,     0,   808,
-       0,    17,     0,     0,     0,   808,     0,    18,     0,     0,
-       0,  2496,     0,     0,     0,    19,  2023,    20,    21,     0,
-       0,     0,     0,     0,  1618,     0,     0,     0,     0,     0,
-       0,     0,    22,     0,  1359,     0,    23,     0,     0,     0,
-       0,     0,     0,    71,  1661,     0,     0,     0,     0,    71,
-       0,     0,  1383,     0,     0,     0,     0,     0,  1431,     0,
-       0,  1433,    24,     0,  1444,  1447,  1452,  1455,     0,     0,
-       0,     0,     0,     0,     0,  2913,     0,     0, -1468,     0,
-       0,     0,  1639,     0,     0,  1640,     0,     0,     0,  1641,
-    1642,     0,     0,  1645,  1646,  1647,     0,  2104,     0,     0,
-       0,     0,     0,     0,    25,     0,     0,  1623,     0,  1498,
-    1302,     0,     0,     0,     0,     0,     0,  1568,     0,     0,
-    1650,     0,     0,     0,     0,     0,     0,  1651,  1950,  1951,
-    1952,  1582,  1953,  1954,  1955,  1956,  1957,  1958,     0,     0,
-    1639,     0,     0,  1640,     0,     0, -2102,  1641,  1642,     0,
-    1598,  1645,  1646,  1647,  1652,    71,     0,     0,     0,     0,
-       0,  1608,  1609,  1610,     0,  1615,  1619,     0,  1648,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1650,    26,
-      27,    28,     0,   808,    71,  1651,     0,    29,     0,     0,
-      30,  3074,     0,     0,     0,   558,     0,     0,     0,     0,
-     808,  1682,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1652,     0,     0,     0,     0,     0,     0,  1498,
-    1498,    31,     0,     0,     0,     0,  1386,     0,   821,     0,
-      32,     0,     0,     0,     0,     0,     0,     0,     0,  1618,
-       0,     0,     0,     0,   558,     0,    33,     0,     0,     0,
-    2637,  1653,     0,    34, -2102,  1720,     0,    35,     0,  1736,
-    1741,  1668,  1669,  1670,  1671,  1672,  1673,    36,  1654,     0,
-    1121,  1121,     0,  1655,     0,     0,     0,     0,     0,    37,
-       0,     0,     0,    38,     0,     0,     0,  3371,     0,     0,
-       0,  1387,  1388,     0,     0,     0,  1656,  1657,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,  3395,  1653,
-       0,  1658,     0,     0,     0,     0,    40,     0,     0,    41,
-       0,   809,    42,     0,     0,     0,  1654,    43,     0,     0,
-    1302,  1655,  1389,  1390,     0,   871,  1391,  1392,     0,  1302,
-       0,     0,     0,     0,    44,     0,     0,     0,     0,  1659,
-       0,     0,  1660,     0,  1656,  1657,     0,     0,     0,     0,
-       0,     0,     0,  1302,     0,     0,  1661,     0,    45,  1658,
-       0,     0,     0,  3435,     0,     0,     0,   558,     0,     0,
-       0,     0,    46,  1639,     0,   -46,  1640,     0,     0,     0,
-    1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,     0,
-       0,     0,     0,  3461,     0,     0,     0,  1659,     0,     0,
-    1660,  1648,  1393,  1394,     0,     0,     0,     0,     0,     0,
-       0,  1650,     0,     0,  1661,     0,     0,  1662,  1651,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1931,     0,     0,     0,     0,  1652,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1663,     0,
-       0,     0,     0,     0,     0,     0,  1395,  1396,  1397,  1398,
-    1399,  1400,  1401,  1402,     0,   558,  1403,  1404,     0,   558,
-       0,     0,     0,     0,     0,  2019,     0,     0,     0,    71,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1452,     0,  1452,  1452,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1663,     0,  1121,  1121,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1618,
-    2841,     0,     0,     0,  2104,     0,     0,     0,     0,  1121,
-       0,     0,  1653,     0,     0,     0,     0,     0,     0,     0,
-    1405,  1406,     0,     0,     0,     0,     0,     0,     0,  1654,
-       0,     0,     0,     0,  1655,     0,  1664,     0,     0,  1665,
-    1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,     0,
-       0,     0,     0,     0,     0,     0,     0,  1656,  1657,     0,
-       0,  1407,  1408,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1658,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   558,     0,
-       0,     0,   558,   558,  1664,     0,   558,  1665,  1666,  1667,
-       0,  1668,  1669,  1670,  1671,  1672,  1673,     0,     0,     0,
-    1659,  2068,     0,  1660,  1639,     0,     0,  1640,     0,  2071,
-       0,  1641,  1642,   558,     0,     0,     0,  1661,     0,     0,
-    1662,     0,     0,     0,     0,     0,     0,     0,   558,   558,
-     558,   558,   558,   558,   558,   558,   558,   558,     0,     0,
-       0,     0,  1650,  2116,    71,     0,     0,  1409,  1410, -2102,
-    2120,     0,     0,     0,     0,     0,  2124,  2125,  2126,  2127,
-    2128,  2129,  2130,  2131,     0,  3394,     0,     0,  2140,  2141,
-       0,  1411,  1412,  2154,     0,     0,  1652,  2157,     0,     0,
-    2165,  2166,  2167,  2168,  2169,  2170,  2171,  2172,  2173,     0,
-       0,  2174,     0,     0,     0,     0,     0,     0,  1121,  1639,
-    1302,     0,  1640,     0,     0,     0,  1641,  1642,  1643,  1644,
-    1645,  1646,  1647,     0,     0,     0,     0,     0,  2200,  1663,
-       0,    71,     0,    71,     0,  2019,     0,  1648,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1650,     0,     0,
-       0,  2870,     0,     0,  1651,     0,     0,     0,     0,     0,
-       0,  2496,  1609,  1610,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    71,     0,     0,     0,     0,     0,     0,
-       0,  1652,     0, -2102,  1639,     0,     0,  1640,     0,    71,
-       0,  1641,  1642,  2104,     0,  1645,  1646,  1647,     0,     0,
-   -2102,  2104,     0,     0,     0, -2102,     0,     0,     0,     0,
-       0,     0,  1648,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1650,     0,     0,     0,     0,     0,     0,  1651,
-       0,     0,     0,     0,     0,     0,   808,  1664,     0,     0,
-    1665,  1666,  1667, -2102,  1668,  1669,  1670,  1671,  1672,  1673,
-       0,     0,     0,  2326,     0,     0,  1652,     0,  2532,     0,
-    1302,     0,     0,  2337,  2338,     0,     0,     0,     0,  1638,
-       0,     0,     0,     0,  1639,     0,     0,  1640,  1653,     0,
-       0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,
-       0,     0,     0,     0,   558,  1654,     0,     0,  1661,     0,
-    1655,     0,  1648,     0,  1302,     0,  1649,     0,     0,     0,
-       0,     0,  1650,     0,     0,    71,     0,     0,     0,  1651,
-       0,     0,     0,  1656,  1657,     0,     0,     0,     0,  1359,
-    2404,     0,     0,     0,     0,     0,     0,     0,  1658,     0,
-       0,    71,     0,     0,     0,     0,  1652,     0,     0,     0,
-       0,     0,     0,  1653,     0,     0,     0,     0,  2430,  2431,
-       0,  2432,  1441,     0,     0,     0,     0,     0,     0,     0,
-    1654,     0,     0,     0,     0,  1655,  1659,     0,     0,  1660,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    2458,  2459,     0,  1661,  2200,     0,  1662,     0,  1656,  1657,
-   -2102,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1658,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  2484,     0,     0,     0,     0,
-       0,     0,  2490,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1653,     0,     0,     0,     0,     0,     0,
-    1498,  1659,  1302,     0,  1660,     0,     0,     0,     0,     0,
-    1654,     0,     0,     0,     0,  1655,     0,     0,  1661,     0,
-    3303,     0,     0,     0,     0,     0,     0,  2496,     0,     0,
-       0,     0,     0,     0,     0,     0,  1676,     0,  1656,  1657,
-    2525,     0,     0,     0,     0,  1663,     0,     0,     0,     0,
-       0,     0,     0,  1658,     0,     0,     0,     0, -2102,     0,
-       0,     0,     0,     0,     0,  1668,  1669,  1670,  1671,  1672,
-    1673,     0,     0,     0,     0,     0,     0,  2542,     0,     0,
-       0,  2548,     0,     0,     0,  1676,  2556,  2557,     0,     0,
-     558,  1659,     0,     0,  1660,   558,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1661,     0,
-       0,  1662,     0,     0,     0,     0,     0,     0,     0,  1441,
-    1663,   558,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  2578,     0,     0,  2581,     0,  2583,     0,
-       0,     0,     0,   558,   558,     0,     0,     0,     0,     0,
-       0,     0,     0,  1664,  2587,     0,  1665,  1666,  1667,     0,
-    1668,  1669,  1670,  1671,  1672,  1673,     0,   558,     0,     0,
-       0,     0,     0,  1934,  1676,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1720,     0,  1639,     0,     0,  1640,
-       0,     0,     0,  1641,  1642,     0,     0,     0,   558,     0,
-    1663,  1741,  2172,     0,     0,     0,  2104,  1676,     0,     0,
-       0,     0,     0,     0,  1676,     0,     0,     0,  1664,     0,
-    1121,  1665,  1666,  1667,  1650,  1668,  1669,  1670,  1671,  1672,
-    1673, -2102,     0,  2643,     0,  1639,     0,     0,  1640,     0,
-       0,     0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1652,     0,
-       0,     0,     0,  1648,  1676,     0,     0,  2846,     0,     0,
-       0,     0,     0,  1650,     0,     0,     0,     0,     0,     0,
-    1651,     0,     0,     0,     0,     0,     0,     0,  1676,     0,
-    1610,     0,     0,     0,     0,     0,     0,     0,     0,  1302,
-       0,     0,     0,     0,     0,     0,     0,  1652,  1664,     0,
-       0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,
-    1673,     0,     0,  3155,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1676,     0,  1676,     0,
-    1441,  1441,     0,  1959,     0,     0,  1441,     0,     0,  1676,
-       0,     0,  1676,     0,     0, -2102,     0,  1676,  2753,     0,
-    1676,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0, -2102,     0,     0,     0,     0, -2102,     0,     0,
-       0,     0,     0,     0,  1639,     0,     0,  1640,     0,   558,
-       0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,
-       0,     0,     0,  1676,  1653,     0,     0,     0,     0,     0,
-       0,     0,  1648,     0,     0, -2102,     0,     0,     0,     0,
-       0,  1654,  1650,     0,     0,     0,  1655,     0,     0,  1651,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1656,
-    1657,     0,     0,     0,     0,     0,  1652,     0,     0,     0,
-       0,     0,     0,     0,  1658,     0,     0,     0,     0,     0,
-    1661,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1676,     0,     0,
-       0,  2831,     0,     0,     0,     0,     0,  2833,  2071,     0,
-       0,     0,  1659,  1676,     0,  1660,     0,     0,     0,     0,
-       0,     0,  2842,  1676,  1676,  1676,     0,     0,     0,  1661,
-    1676,     0,  1662,     0,  1676,     0,     0,     0,  2855,     0,
-       0,  2858,     0,  2860,     0,     0,     0,     0,     0,     0,
-       0,  2864,     0,     0,     0,     0,     0,     0,     0,  2871,
-    2872,     0,     0,  1653,     0,     0,  2879,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1654,  2888, -2102,     0,     0,  1655,     0,     0,     0,     0,
-       0,  2903,     0,     0,     0,     0,     0,  1676,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1656,  1657,
-       0,  1121,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1658,     0,     0,     0,     0,     0,     0,
-       0,  1663,     0,     0,     0,  1676,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1676,     0,     0,     0,     0,  1676,     0,     0,     0,
-       0,  1659,     0,     0,  1660,     0,     0,     0,     0,     0,
-    2326,     0,  2326,  1959,     0,     0,     0,     0,  1661,     0,
-       0,  1662,     0,     0,     0,     0,     0,     0,     0,     0,
-   -2102,     0,     0,     0,     0,     0,     0,  1668,  1669,  1670,
-    1671,  1672,  1673,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1664,
-       0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,
-    1672,  1673,     0,     0,     0,     0,  2110,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    3108,  3109,     0,     0,     0,     0,     0,     0,     0,     0,
-    1663,     0,     0,     0,  1639,     0,     0,  1640,     0,     0,
-       0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,
-       0,     0,     0,     0,     0,  3132,     0,     0,     0,     0,
-       0,     0,  1648,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1650,     0,     0,  3141,     0,     0,     0,  1651,
-       0,  3145,  3146,     0,     0,     0,  3147,     0,     0,     0,
-       0,  3150,     0,     0,  3153,  3154,  1676,     0,     0,  2326,
-    1302,     0,     0,  3162,  1959,  1959,  1652,  1441,  1441,  1441,
-    1441,  1441,  1441,     0,  1121,  1441,  1441,  1441,  1441,  1441,
-    1441,  1441,  1441,  1441,  1441,  1959,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1664,     0,
-       0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,
-    1673,     0,     0,     0,     0,  2110,  1387,  1388,  3203,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1639,     0,     0,  1640,  3222,     0,     0,  1641,  1642,
-    1643,  1644,  1645,  1646,  1647,     0,     0,  1389,  1390,     0,
-       0,  1391,  1392,  1653,     0,     0,     0,     0,     0,  1648,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1650,
-    1654,     0,     0,     0,     0,  1655,  1651,     0,     0,     0,
-       0,     0,     0,  1676,     0,     0,  1676,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1656,  1657,
-       0,     0,     0,  1652,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1658,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1393,  1394,     0,
-       0,  1676,     0,     0,     0,  1676,     0,     0,     0,  1676,
-    1676,  1676,  1676,  1676,  1676,  1676,  1676,     0,  2753,     0,
-       0,  1659,  1441,  1441,  1660,  1676,  1676,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1661,  1676,
-       0,  1662,  1676,     0,     0,  1619,     0,     0,     0,     0,
-    1676,  1676,  1676,  1676,  1676,  1676,  1676,  1676,  1676,  1676,
-       0,  1395,  1396,  1397,  1398,  1399,  1400,  1401,  1402,     0,
-    1653,  1403,  1404,     0,     0,     0,     0,     0,     0,  2548,
-       0,     0,     0,     0,     0,  1676,     0,  1654,     0,     0,
-       0,     0,  1655,     0,     0,     0,  3318,  3319,     0,     0,
-    3320,     0,  1610,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1656,  1657,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  3338,     0,     0,
-    1658,     0,     0,     0,     0,     0,     0,     0,  1441,     0,
-    1663,     0,     0,     0,     0,  1405,  1406,     0,     0,     0,
-       0,  3350,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1659,     0,
-       0,  1660,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1661,  1407,  1408,  1662,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1676,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1676,  1676,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  3108,
-       0,     0,     0,  3411,     0,     0,     0,  1121,  1664,     0,
-       0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,
-    1673,  3421,     0,     0,     0,  2429,  2326,     0,  2326,     0,
-       0,     0,     0,     0,     0,     0,  1121,     0,     0,     0,
-       0,     0,  1409,  1410,     0,     0,     0,  1663,     0,  1676,
-       0,     0,     0,     0,  3446,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1411,  1412,     0,     0,
-       0,     0,     0,     0,     0,  1676,  1676,  1676,     0,     0,
-    1959,  1959,  1959,  1959,  1959,  1959,  2036,     0,     0,  1959,
-    1959,  1959,  1959,  1959,  1959,  1959,  1959,  1959,  1959,     0,
-       0,  3471,     0,  1676,  1676,  1639,     0,     0,  1640,     0,
-       0,  3108,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,
-       0,     0,     0,  1121,     0,     0,     0,     0,     0,  1676,
-       0,     0,     0,  1648,     0,  1676,     0,     0,     0,     0,
-       0,     0,     0,  1650,     0,     0,     0,     0,     0,     0,
-    1651,     0,     0,     0,     0,  1664,  3514,     0,  1665,  1666,
-    1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,     0,     0,
-    1676,     0,  2529,     0,     0,     0,     0,  1652,     0,     0,
-       0,     0,     0,   722,     0,     0,     0,  1676,     0,     0,
-       0,     0,     0,  1676,     0,     0,     0,     0,     0,     0,
-       0,  1676,  1676,     0,     0,     0,     0,     0,     0,  1959,
-    1959,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1676,  1441,  1441,  1676,     0,  1676,     0,
-       0,     0,  1676,     0,     0,     0,     0,     0,     0,     0,
-     723,     0,     0,  3568,  3568,  3568,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   724,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1639,
-    3568,     0,  1640,     0,  1653,     0,  1641,  1642,  1643,  1644,
-    1645,  1646,  1647,     0,     0,     0,     0,     0,  1676,     0,
-       0,  1654,     0,     0,     0,     0,  1655,  1648,     0,     0,
-       0,     0,     0,     0,     0,   725,     0,  1650,     0,     0,
-       0,  3568,     0,     0,  1651,   726,     0,     0,     0,  1656,
-    1657,     0,     0,     0,     0,     0,     0,     0,   727,     0,
-       0,     0,     0,   728,  1658,     0,     0,     0,     0,     0,
-       0,  1652,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1639,     0,
-       0,  1640,   729,     0,     0,  1641,  1642,  1643,  1644,  1645,
-    1646,  1647,  1659,     0,     0,  1660,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1648,     0,     0,  1661,
-       0,     0,  1662,     0,     0,     0,  1650,     0,  1676,     0,
-       0,     0,     0,  1651,     0,   730,     0,     0,     0,   731,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1441,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1652,     0,     0,     0,     0,     0,  1639,     0,  1653,  1640,
-       0,     0,     0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,
-       0,     0,     0,     0,     0,  1654,     0,     0,     0,     0,
-    1655,     0,     0,     0,  1648,     0,     0,     0,     0,     0,
-       0,     0,     0,   544,  1650,     0,  1676,     0,  1676,   732,
-       0,  1651,     0,  1656,  1657,     0,     0,  1676,     0,     0,
-       0,  1663,     0,     0,   733,     0,     0,     0,  1658,     0,
-    1676,     0,     0,  1676,     0,  1676,     0,     0,  1652,  1676,
-       0,     0,  1959,  1959,     0,     0,  1676,  1676,     0,     0,
-       0,     0,     0,     0,  1676,     0,     0,  1653,     0,   734,
-       0,     0,   735,  1676,     0,     0,  1659,     0,     0,  1660,
-       0,     0,     0,   736,  1654,     0,   737,     0,  1676,  1655,
-       0,     0,     0,  1661,     0,     0,  1662,     0,     0,     0,
-       0,     0,     0,     0,   738,     0,     0,     0,     0,     0,
-       0,     0,  1656,  1657,     0,     0,     0,     0,   739,     0,
-       0,     0,     0,     0,   740,   741,  1441,  1658,     0,     0,
-       0,     0,     0,     0,     0,   742,     0,     0,     0,  1664,
-       0,   743,  1665,  1666,  1667,  1653,  1668,  1669,  1670,  1671,
-    1672,  1673,     0,     0,     0,     0,  2562,     0,     0,     0,
-       0,     0,  1654,     0,     0,  1659,     0,  1655,  1660,   744,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1387,  1388,  1661,     0,     0,  1662,     0,     0,     0,     0,
-    1656,  1657,     0,     0,     0,  1663,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1658,     0,     0,     0,     0,
-       0,     0,     0,     0,   722,     0,     0,     0,     0,     0,
-       0,  1389,  1390,     0,     0,  1391,  1392,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1659,     0,     0,  1660,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1661,     0,     0,  1662,     0,     0,     0,     0,  1959,  1441,
-       0,   723,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1663,     0,     0,   724,     0,     0,
-       0,     0,     0,  1676,  1676,     0,     0,     0,     0,     0,
-       0,  1393,  1394,  1664,     0,     0,  1665,  1666,  1667,     0,
-    1668,  1669,  1670,  1671,  1672,  1673,     0,  1676,     0,     0,
-    2773,     0,     0,     0,     0,     0,  1676,     0,     0,     0,
-    1676,  1676,  1676,     0,     0,  1676,   725,     0,  1676,  1676,
-       0,     0,     0,     0,     0,     0,   726,  1676,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   727,
-       0,     0,  1663,     0,   728,  1395,  1396,  1397,  1398,  1399,
-    1400,  1401,  1402,     0,     0,  1403,  1404,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1676,     0,
-       0,     0,  1664,   729,  1959,  1665,  1666,  1667,     0,  1668,
-    1669,  1670,  1671,  1672,  1673,     0,     0,  1676,     0,  2838,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   730,     0,     0,     0,
-     731,     0,     0,     0,     0,     0,     0,     0,     0,  1405,
-    1406,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1959,     0,     0,
-    1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,
-    1671,  1672,  1673,     0,     0,     0,     0,  2852,     0,     0,
-    1407,  1408,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1676,  1676,  1676,     0,     0,     0,     0,
-     732,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1676,     0,   733,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1676,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     734,     0,     0,   735,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   736,     0,     0,   737,     0,     0,
-       0,     0,     0,     0,     0,     0,  1409,  1410,     0,     0,
-       0,     0,     0,     0,     0,   738,  1676,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1676,     0,     0,   739,
-    1411,  1412,     0,     0,     0,     0,   741,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   742,     0,     0,     0,
-       0,  1676,   743,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1676,     0,     0,     0,
-     744,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1676,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,  1676,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,    14,    15,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,    23,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,    26,    27,    28,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,    33,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,    35,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,    37,     0,   450,   451,    38,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,    40,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   804,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,    44,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,    45,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,  3293,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-      14,    15,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,    23,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,    26,
-      27,    28,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,    33,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,    35,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,    37,
-       0,   450,   451,    38,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,    40,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   804,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,    44,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,    45,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,    23,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,    26,    27,    28,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,    33,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,    38,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,    40,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   804,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,    44,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,    45,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,  1264,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,  1265,   126,   127,   128,     0,     0,
-       0,  1266,     0,  1062,     0,     0,  1267,   130,   131,     0,
-     132,   133,   134,  1268,   136,   137,   138,   139,  1063,  1269,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,  1270,     0,  1271,   164,   165,
-     166,   167,   168,  1272,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,  1273,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,  1274,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,  1275,     0,  1276,   238,   239,
-    1277,  1278,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,  1279,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,  1280,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,  1281,  1282,   281,  1283,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,  1284,
-     291,  1285,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1286,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,  1287,  1084,   325,   326,   327,   328,  1085,
-     329,   330,  1288,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-     881,   344,   345,   346,  1289,   348,  1290,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,  1291,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,  1292,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,  1293,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,  1294,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,  1295,   448,   800,     0,
-       0,   450,   451,     0,   452,  1296,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,  1297,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-    1298,   490,  1299,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,  1300,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,     0,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,    14,    15,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,    23,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,     0,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,    26,    27,    28,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,    33,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,    35,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,    37,     0,   450,   451,    38,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,    40,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   804,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,    44,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,     0,     0,    45,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,  1448,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,  1449,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,  1450,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,  1451,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,  1264,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,  1266,     0,  1062,     0,
-       0,  1267,   130,   131,     0,   132,   133,   134,  1268,   136,
-     137,   138,   139,  1063,  1269,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-    1270,     0,  1271,   164,   165,   166,   167,   168,  1272,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-    1273,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-    1275,     0,  1276,   238,   239,  1277,  1278,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,  1279,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,  1280,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,  1281,  1282,   281,  1283,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,  1284,   291,  1285,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1286,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,  1287,  1084,
-     325,   326,   327,   328,  1085,   329,   330,  1288,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,  1289,
-     348,  1290,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,  1291,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,  1292,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,  1293,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,  1294,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,  1295,   448,   800,     0,     0,   450,   451,     0,   452,
-    1296,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-    1297,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,  2334,   490,  1299,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,  1264,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,  1266,     0,  1062,     0,     0,  1267,   130,   131,     0,
-     132,   133,   134,  1268,   136,   137,   138,   139,  1063,  1269,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,  1270,     0,  1271,   164,   165,
-     166,   167,   168,  1272,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,  1273,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,  1275,     0,  1276,   238,   239,
-    1277,  1278,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,  1279,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,  1280,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,  1281,  1282,   281,  1283,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,  1284,
-     291,  1285,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1286,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,  1287,  1084,   325,   326,   327,   328,  1085,
-     329,   330,  1288,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,  1289,   348,  1290,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,  1291,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,  1292,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,  1293,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,  1294,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,  1295,   448,   800,     0,
-       0,   450,   451,     0,   452,  1296,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,  1297,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,  1299,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,  2389,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125, -1139,
-     126,   127,   128,     0,     0,     0,     0, -1139,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434, -1139,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,  1264,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,  1266,     0,  1062,     0,     0,  1267,   130,   131,     0,
-     132,   133,   134,  1268,   136,   137,   138,   139,  1063,  1269,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,  1270,     0,  1271,   164,   165,
-     166,   167,   168,  1272,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,  1273,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,  1275,     0,  1276,   238,   239,
-    1277,  1278,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,  1279,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,  1280,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,  1281,  1282,   281,  1283,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,  1284,
-     291,  1285,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1286,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,  1287,  1084,   325,   326,   327,   328,  1085,
-     329,   330,  1288,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,  1289,   348,  1290,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,  1291,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,  1292,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,  1293,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,  1294,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,  1295,   448,   800,     0,
-       0,   450,   451,     0,   452,  1296,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,  1297,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,  1299,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,  3159,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,  1264,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,  1266,     0,  1062,     0,
-       0,  1267,   130,   131,     0,   132,   133,   134,  1268,   136,
-     137,   138,   139,  1063,  1269,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-    1270,     0,  1271,   164,   165,   166,   167,   168,  1272,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-    1273,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-    1275,     0,  1276,   238,   239,  1277,  1278,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,  1279,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,  1280,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,  1281,  1282,   281,  1283,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,  1284,   291,  1285,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1286,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,  1287,  1084,
-     325,   326,   327,   328,  1085,   329,   330,  1288,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,  1289,
-     348,  1290,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,  1291,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,  1292,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,  1293,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,  1294,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,  1295,   448,   800,     0,     0,   450,   451,     0,   452,
-    1296,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-    1297,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,  1299,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,  1717,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1732,   821,  1057,  1058,  1059,  1733,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,  1734,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,  1449,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,  2096,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,  2695,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,  2752,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,  2878,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,  3096,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,  3097,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  3098,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,  3099,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  3100,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,  3321,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1737,  1738,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  2238,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  2325,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  2547,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  3157,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,  3097,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  3098,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,  3099,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  3100,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,  3565,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,  1069,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,  3566,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,  1072,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,  1085,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,  3567,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,  1096,     0,     0,     0,
-       0,     0,     0,  1097,  1098,  1099,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,  3566,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,  1085,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,  3567,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1096,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,  1059,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,     0,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,  1088,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,     0,     0,     0,     0,
-       0,     0,     0,  1435,  1436,     0,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138, -2102,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,  3566,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240, -2102,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254, -2102,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,     0,     0,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291, -2102,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0, -2102,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,  3567,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520, -2102,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,     0,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,     0,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  2224,  2225,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,     0,     0,     0,     0,
-       0,     0,     0,  2226,  2227,     0,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,     0,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,     0,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,     0,     0,     0,     0,     0,     0,     0,  1435,  1436,
-       0,     0,     0,     0,     0,  1100,     0,  1101,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,     0,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,  3117,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,     0,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1100,     0,  2800,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,     0,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,     0,   329,   330,   331,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1100,     0,  2800,     0,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,   117,  1056,   821,
-    1057,  1058,     0,  1060,  1061,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,  1062,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,  1063,   141,
-    1064,  1065,     0,   144,   145,   146,   147,   148,   149,  1066,
-     790,   150,   151,   152,   153,  1067,  1068,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,  1070,   191,   192,  1071,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-    1073,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,  1074,   222,   223,   224,
-     225,   226,   227,   793,  1075,   229,     0,   230,   231,  1076,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,  1077,  1078,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-    1079,  1080,     0,  1081,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,  1082,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,  1083,   323,  1084,   325,   326,   327,   328,     0,
-     329,   330,   331,   332,  1086,   795,   334,  1087,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,  1089,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,  1090,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,  1091,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,  1092,  1093,     0,     0,   462,   463,   801,
-     465,   802,  1094,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,  1095,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1100,     0,  1101,     0,     0,     0,     0,     0,  1102,  1103,
-    1104,  1105,   117,  1056,   821,  1057,  1058,  1059,  1060,  1061,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,  1062,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,     0,  1063,   141,  1064,  1065,     0,   144,   145,
-     146,   147,   148,   149,  1066,   790,   150,   151,   152,   153,
-    1067,  1068,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,  1069,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1070,   191,   192,  1071,   194,  1072,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,     0,   216,     0,   217,   218,   219,
-     220,  1074,   222,   223,   224,   225,   226,   227,   793,  1075,
-     229,     0,   230,   231,  1076,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,     0,   242,     0,   243,
-       0,  1077,  1078,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,  1079,  1080,     0,  1081,     0,
-     278,     0,     0,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  1082,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1083,   323,  1084,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,  1086,
-     795,   334,  1087,   336,   337,   338,     0,   339,   340,     0,
-       0,  1088,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1089,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,  1090,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,  1091,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,  1092,  1093,
-       0,     0,   462,   463,   801,   465,   802,  1094,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,  1095,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,     0,     0,     0,     0,     0,     0,     0,  1097,  1098,
-    1099,     0,   974,  1364,   821,  1100,     0,  1101,  1060,     0,
-       0,     0,     0,  1102,  1103,  1104,  1105,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,   565,     0,     0,     0,
-       0,   570,   130,   131,     0,   132,   133,   134,   572,   136,
-     137,   138,   573,   574,   575,   576,   577,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     581,   582,   156,     0,   157,   158,   159,   160,   584,     0,
-     586,     0,   588,   164,   165,   166,   167,   168,   589,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     592,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   594,   191,   192,   595,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   605,   222,   223,   224,   225,   226,   227,   606,  1365,
-     229,     0,   230,   231,   609,   233,     0,   234,     0,   235,
-     612,     0,   614,   238,   239,   615,   616,   242,     0,   243,
-       0,   619,   620,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   622,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   625,   626,
-     270,   271,   272,   273,   274,   627,   628,     0,   630,     0,
-     278,   632,   633,   281,   634,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   637,   291,   638,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,  2406,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   641,   642,   643,
-     325,   326,   327,   644,     0,   329,   330,   646,   332,     0,
-     648,   334,   649,   336,   337,   338,     0,   339,   340,  1366,
-       0,   341,   342,   343,     0,     0,   344,   345,   655,   656,
-     348,   657,   658,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     663,   664,   366,   367,   665,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   668,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   671,   404,   405,   406,   672,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,   674,   421,   422,   423,   424,   425,   426,   675,
-     428,   429,     0,   677,   431,   432,   678,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   680,   448,   681,     0,     0,   450,   451,     0,   452,
-     685,   454,   455,   456,   457,   458,     0,   459,   687,   688,
-       0,     0,   462,   463,   691,   465,   692,  1367,   467,   468,
-     694,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   699,   700,   489,     0,   490,   702,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   707,   708,   709,   710,
-     711,   712,   713,   714,   715,   716,   717,   517,   518,   519,
-     520,     0,     0,     0,     0,     0,     0,     0,  1368,  1369,
-    2407,   117,     0,     0,     0,  2408,     0,  2409,  1061,     0,
-       0,     0,     0,     0,     0,     0,  1105,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,  1062,     0,     0,
-     129,   130,   131,     0,   132,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,  1066,   790,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   791,     0,   792,
-       0,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,   179,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   793,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,   236,
-       0,   237,   238,   239,   240,   241,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,   290,   291,   292,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,  1082,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,     0,   329,   330,   331,   332,     0,   795,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,   347,   348,
-     349,   797,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   798,
-     365,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,   430,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     447,   448,   800,     0,     0,   450,   451,     0,   452,   453,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   801,   465,   802,     0,   467,   468,   803,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   528,  1982,     0,  1100,     0,  2142,  1983,  1061,     0,
-       0,     0,  1102,  1103,  1104,  1105,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   130,   131,     0,   132,   133,   134,     0,   136,   137,
-     138,   139,   140,     0,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   161,     0,     0,
-       0,   163,   164,   165,   166,   167,   168,     0,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,     0,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,     0,
-       0,     0,   238,   239,   529,     0,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,     0,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,     0,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-       0,     0,   281,     0,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,     0,   291,     0,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   530,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,     0,   324,   325,
-     326,   327,   328,     0,   329,   330,     0,   332,     0,   333,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,     0,   348,
-       0,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   364,
-       0,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,     0,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,     0,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     531,   448,   449,     0,     0,   450,   451,     0,   452,     0,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   464,   465,   466,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,     0,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-       0,     0,     0,     0,     0,   528,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1102,  1103,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,  1010,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,   159,
-     160,   161,     0,     0,     0,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,  -540,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,  -540,   230,   231,   232,   233,  -540,
-     234,     0,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-    -540,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-    -540,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,  -540,
-     339,   340,     0,     0,   341,   342,   343,     0,  -540,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,  -540,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   528,     0,   554,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1177,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,     0,   126,   127,   128,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   130,   131,     0,   132,   133,   134,
-       0,   136,   137,   138,   139,   140,     0,   142,   143,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,   159,   160,
-     161,     0,     0,     0,   163,   164,   165,   166,   167,   168,
-       0,   170,   171,   172,     0,   173,   174,   175,   176,   177,
-     178,     0,     0,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,     0,   229,     0,   230,   231,   232,   233,     0,   234,
-       0,   235,     0,     0,     0,   238,   239,   529,     0,   242,
-       0,   243,     0,   244,   245,   246,   247,     0,   248,   249,
-     250,   251,   252,   253,   254,     0,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-       0,   269,   270,   271,   272,   273,   274,   275,   276,     0,
-     277,     0,   278,     0,     0,   281,     0,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,     0,   291,     0,     0,
-     293,   294,   295,   296,   297,   298,   299,   300,   530,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-       0,   324,   325,   326,   327,   328,     0,   329,   330,     0,
-     332,     0,   333,   334,   335,   336,   337,   338,     0,   339,
-     340,     0,     0,   341,   342,   343,     0,     0,   344,   345,
-     346,     0,   348,     0,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   364,     0,   366,   367,   368,   369,   370,   371,
-       0,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,     0,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,     0,   421,   422,   423,   424,   425,
-     426,   427,   428,   429,     0,     0,   431,   432,   433,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   531,   448,   449,     0,     0,   450,   451,
-       0,   452,     0,   454,   455,   456,   457,   458,     0,   459,
-     460,   461,     0,     0,   462,   463,   464,   465,   466,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,     0,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   487,   488,   489,     0,   490,     0,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   974,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  2495,
-    3307,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     3,     4,     0,   565,     0,     0,
-       0,     0,   570,   130,   131,     0,   132,   133,   134,   572,
-     136,   137,   138,   573,   574,   575,   576,   577,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   581,   582,   156,     0,   157,   158,   159,   160,   584,
-       0,   586,     0,   588,   164,   165,   166,   167,   168,   589,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,   592,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   594,   191,   192,   595,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,    14,    15,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   605,   222,   223,   224,   225,   226,   227,   606,
-       0,   229,     0,   230,   231,   609,   233,     0,   234,     0,
-     235,   612,    23,   614,   238,   239,   615,   616,   242,     0,
-     243,     0,   619,   620,   246,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,   622,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,   625,
-     626,   270,   271,   272,   273,   274,   627,   628,     0,   630,
-       0,   278,   632,   633,   281,   634,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,   637,   291,   638,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   640,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   641,   642,
-     643,   325,   326,   327,   644,     0,   329,   330,   646,   332,
-       0,   648,   334,   649,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   655,
-     656,   348,   657,   658,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,    26,    27,    28,     0,   362,
-     363,   663,   664,   366,   367,   665,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   668,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,   671,   404,   405,   406,   672,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,    33,   674,   421,   422,   423,   424,   425,   426,
-     675,   428,   429,    35,   677,   431,   432,   678,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   680,   448,   681,    37,     0,   450,   451,    38,
-     452,   685,   454,   455,   456,   457,   458,     0,   459,   687,
-     688,     0,     0,   462,   463,   691,   465,   692,     0,   467,
-     468,   694,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,    40,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   975,   700,   489,     0,   490,   702,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-      44,   500,   501,   502,   503,   504,   505,   707,   708,   709,
-     710,   711,   712,   713,   714,   715,   716,   717,   517,   518,
-     519,   520,     0,   117,    45,   554,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    46,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,   129,   130,   131,     0,   132,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,   790,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   791,
-       0,   792,     0,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,    14,    15,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   793,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,   236,    23,   237,   238,   239,   240,   241,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   794,     0,   289,   290,   291,   292,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
-     324,   325,   326,   327,   328,     0,   329,   330,   331,   332,
-       0,   795,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,   796,   341,   342,   343,     0,     0,   344,   345,   346,
-     347,   348,   349,   797,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,    26,    27,    28,     0,   362,
-     363,   798,   365,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,   403,   404,   405,   406,   407,   799,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,    33,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,    35,   430,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   800,    37,     0,   450,   451,    38,
-     452,   453,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   801,   465,   802,     0,   467,
-     468,   803,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,    40,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   804,   488,   489,     0,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-      44,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,     0,   117,    45,   554,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   805,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,   129,   130,   131,     0,   132,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,   790,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   791,
-       0,   792,     0,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   793,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,   236,     0,   237,   238,   239,   240,   241,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   794,     0,   289,   290,   291,   292,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
-     324,   325,   326,   327,   328,     0,   329,   330,   331,   332,
-       0,   795,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,   796,   341,   342,   343,     0,     0,   344,   345,   346,
-     347,   348,   349,   797,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   798,   365,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,   403,   404,   405,   406,   407,   799,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,   430,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   800,     0,     0,   450,   451,     0,
-     452,   453,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   801,   465,   802,     0,   467,
-     468,   803,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   804,   488,   489,     0,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,   117,     0,   554,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   805,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,   129,   130,   131,     0,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,   790,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   791,     0,
-     792,     0,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   793,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-     236,     0,   237,   238,   239,   240,   241,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,   268,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,   290,   291,   292,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,     0,   329,   330,   331,   332,     0,
-     795,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-     796,   341,   342,   343,     0,     0,   344,   345,   346,   347,
-     348,   349,   797,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     798,   365,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,   403,   404,   405,   406,   407,   799,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,   430,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   800,     0,     0,   450,   451,     0,   452,
-     453,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   801,   465,   802,     0,   467,   468,
-     803,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1018,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-     129,   130,   131,     0,   132,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,   790,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   791,     0,   792,
-       0,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,   179,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   793,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,   236,
-       0,   237,   238,   239,   240,   241,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,   290,   291,   292,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,     0,   329,   330,   331,   332,     0,   795,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,   347,   348,
-     349,   797,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   798,
-     365,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,   403,   404,   405,   406,   407,   799,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,   430,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     447,   448,   800,     0,     0,   450,   451,     0,   452,   453,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   801,   465,   802,     0,   467,   468,   803,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     117,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    46,     0,     0,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,   129,
-     130,   131,     0,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,   790,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   791,     0,   792,     0,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   793,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,   236,     0,
-     237,   238,   239,   240,   241,   242,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,   268,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,   290,   291,   292,     0,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,     0,   329,   330,   331,   332,     0,   795,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,     0,   341,
-     342,   343,     0,     0,   344,   345,   346,   347,   348,   349,
-     797,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   798,   365,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-       0,   430,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   447,
-     448,   800,     0,     0,   450,   451,     0,   452,   453,   454,
-     455,   456,   457,   458,     0,   459,   460,   461,     0,     0,
-     462,   463,   801,   465,   802,     0,   467,   468,   803,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   489,     0,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,   528,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  3396,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,    14,    15,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,    23,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,    26,    27,    28,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,    33,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,    35,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,    37,     0,   450,   451,    38,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,    40,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   804,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,    44,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,     0,   528,
-      45,   554,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    46,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,   894,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,    23,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,    26,    27,    28,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,    33,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,    38,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   895,   461,     0,     0,   896,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,    40,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   804,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,    44,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,     0,   528,
-      45,   554,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    46,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,    23,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,    26,    27,    28,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,    33,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,    38,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,    40,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   804,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,    44,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,     0,   528,
-      45,   554,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    46,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,     0,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,     0,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   487,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,   528,     0,
-     554,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   994,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,     0,   126,   127,   128,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   130,   131,
-       0,   132,   133,   134,     0,   136,   137,   138,   139,   140,
-       0,   142,   143,     0,   144,   145,   146,   147,   148,   149,
-       0,     0,   150,   151,   152,   153,   154,   155,   156,     0,
-     157,   158,   159,   160,   161,     0,     0,     0,   163,   164,
-     165,   166,   167,   168,     0,   170,   171,   172,     0,   173,
-     174,   175,   176,   177,   178,     0,     0,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,     0,   196,   197,   198,   199,   200,
-     201,     0,     0,   202,   203,   204,   205,     0,     0,   206,
-     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
-     215,   216,     0,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,   228,     0,   229,     0,   230,   231,
-     232,   233,     0,   234,     0,   235,     0,     0,     0,   238,
-     239,   529,     0,   242,     0,   243,     0,   244,   245,   246,
-     247,     0,   248,   249,   250,   251,   252,   253,   254,     0,
-     256,   257,   258,   259,     0,   260,   261,   262,   263,   264,
-     265,   266,     0,   267,     0,   269,   270,   271,   272,   273,
-     274,   275,   276,     0,   277,     0,   278,     0,     0,   281,
-       0,   283,   284,   285,   286,   287,   288,     0,     0,   289,
-       0,   291,     0,     0,   293,   294,   295,   296,   297,   298,
-     299,   300,   530,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,     0,   324,   325,   326,   327,   328,
-       0,   329,   330,     0,   332,     0,   333,   334,   335,   336,
-     337,   338,     0,   339,   340,     0,     0,   341,   342,   343,
-       0,     0,   344,   345,   346,     0,   348,     0,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-       0,     0,     0,     0,   362,   363,   364,     0,   366,   367,
-     368,   369,   370,   371,     0,   372,   373,   374,   375,   376,
-     377,     0,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,   387,     0,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,     0,   401,   402,     0,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,     0,     0,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,     0,     0,
-     431,   432,   433,   434,     0,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   531,   448,   449,
-       0,     0,   450,   451,     0,   452,     0,   454,   455,   456,
-     457,   458,     0,   459,   460,   461,     0,     0,   462,   463,
-     464,   465,   466,     0,   467,   468,   469,   470,   471,   472,
-     473,   474,     0,     0,   475,   476,   477,     0,   478,   479,
-     480,   481,     0,   482,   483,   484,   485,   486,   487,   488,
-     489,     0,   490,     0,   492,   493,   494,   495,   496,   497,
-     498,     0,     0,   499,     0,     0,   500,   501,   502,   503,
-     504,   505,   506,   507,   508,   509,   510,   511,   512,   513,
-     514,   515,   516,   517,   518,   519,   520,   528,     0,   554,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1493,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   130,   131,     0,
-     132,   133,   134,     0,   136,   137,   138,   139,   140,     0,
-     142,   143,     0,   144,   145,   146,   147,   148,   149,     0,
-       0,   150,   151,   152,   153,   154,   155,   156,     0,   157,
-     158,   159,   160,   161,     0,     0,     0,   163,   164,   165,
-     166,   167,   168,     0,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,     0,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-     208,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,     0,   229,     0,   230,   231,   232,
-     233,     0,   234,     0,   235,     0,     0,     0,   238,   239,
-     529,     0,   242,     0,   243,     0,   244,   245,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,     0,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,     0,   269,   270,   271,   272,   273,   274,
-     275,   276,     0,   277,     0,   278,     0,     0,   281,     0,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,     0,
-     291,     0,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,   530,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,     0,   324,   325,   326,   327,   328,     0,
-     329,   330,     0,   332,     0,   333,   334,   335,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,     0,   348,     0,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   364,     0,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,     0,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,     0,   431,
-     432,   433,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   531,   448,   449,     0,
-       0,   450,   451,     0,   452,     0,   454,   455,   456,   457,
-     458,     0,   459,   460,   461,     0,     0,   462,   463,   464,
-     465,   466,     0,   467,   468,   469,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,   488,   489,
-       0,   490,     0,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   528,     0,   554,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  2103,     0,     0,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,   126,   127,   128,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   130,   131,     0,   132,
-     133,   134,     0,   136,   137,   138,   139,   140,     0,   142,
-     143,     0,   144,   145,   146,   147,   148,   149,     0,     0,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-     159,   160,   161,     0,     0,     0,   163,   164,   165,   166,
-     167,   168,     0,   170,   171,   172,     0,   173,   174,   175,
-     176,   177,   178,     0,     0,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,     0,   196,   197,   198,   199,   200,   201,     0,
-       0,   202,   203,   204,   205,     0,     0,   206,   207,   208,
-     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
-       0,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,     0,   229,     0,   230,   231,   232,   233,
-       0,   234,     0,   235,     0,     0,     0,   238,   239,   529,
-       0,   242,     0,   243,     0,   244,   245,   246,   247,     0,
-     248,   249,   250,   251,   252,   253,   254,     0,   256,   257,
-     258,   259,     0,   260,   261,   262,   263,   264,   265,   266,
-       0,   267,     0,   269,   270,   271,   272,   273,   274,   275,
-     276,     0,   277,     0,   278,     0,     0,   281,     0,   283,
-     284,   285,   286,   287,   288,     0,     0,   289,     0,   291,
-       0,     0,   293,   294,   295,   296,   297,   298,   299,   300,
-     530,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,     0,   324,   325,   326,   327,   328,     0,   329,
-     330,     0,   332,     0,   333,   334,   335,   336,   337,   338,
-       0,   339,   340,     0,     0,   341,   342,   343,     0,     0,
-     344,   345,   346,     0,   348,     0,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,     0,     0,
-       0,     0,   362,   363,   364,     0,   366,   367,   368,   369,
-     370,   371,     0,   372,   373,   374,   375,   376,   377,     0,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-       0,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,     0,   401,   402,     0,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,     0,     0,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,     0,     0,   431,   432,
-     433,   434,     0,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   531,   448,   449,     0,     0,
-     450,   451,     0,   452,     0,   454,   455,   456,   457,   458,
-       0,   459,   460,   461,     0,     0,   462,   463,   464,   465,
-     466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
-       0,     0,   475,   476,   477,     0,   478,   479,   480,   481,
-       0,   482,   483,   484,   485,   486,   487,   488,   489,     0,
-     490,     0,   492,   493,   494,   495,   496,   497,   498,     0,
-       0,   499,     0,     0,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
-     516,   517,   518,   519,   520,   528,     0,   554,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  2250,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,   159,
-     160,   161,     0,     0,     0,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,     0,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,     0,   230,   231,   232,   233,     0,
-     234,     0,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-       0,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   528,     0,   554,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    2495,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,     0,   126,   127,   128,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   130,   131,     0,   132,   133,   134,
-       0,   136,   137,   138,   139,   140,     0,   142,   143,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,   159,   160,
-     161,     0,     0,     0,   163,   164,   165,   166,   167,   168,
-       0,   170,   171,   172,     0,   173,   174,   175,   176,   177,
-     178,     0,     0,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,     0,   229,     0,   230,   231,   232,   233,     0,   234,
-       0,   235,     0,     0,     0,   238,   239,   529,     0,   242,
-       0,   243,     0,   244,   245,   246,   247,     0,   248,   249,
-     250,   251,   252,   253,   254,     0,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-       0,   269,   270,   271,   272,   273,   274,   275,   276,     0,
-     277,     0,   278,     0,     0,   281,     0,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,     0,   291,     0,     0,
-     293,   294,   295,   296,   297,   298,   299,   300,   530,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-       0,   324,   325,   326,   327,   328,     0,   329,   330,     0,
-     332,     0,   333,   334,   335,   336,   337,   338,     0,   339,
-     340,     0,     0,   341,   342,   343,     0,     0,   344,   345,
-     346,     0,   348,     0,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   364,     0,   366,   367,   368,   369,   370,   371,
-       0,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,     0,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,     0,   421,   422,   423,   424,   425,
-     426,   427,   428,   429,     0,     0,   431,   432,   433,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   531,   448,   449,     0,     0,   450,   451,
-       0,   452,     0,   454,   455,   456,   457,   458,     0,   459,
-     460,   461,     0,     0,   462,   463,   464,   465,   466,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,     0,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   487,   488,   489,     0,   490,     0,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   528,     0,   554,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  2636,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   130,   131,     0,   132,   133,   134,     0,
-     136,   137,   138,   139,   140,     0,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   161,
-       0,     0,     0,   163,   164,   165,   166,   167,   168,     0,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,     0,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,     0,     0,     0,   238,   239,   529,     0,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,     0,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,     0,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,     0,     0,   281,     0,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,     0,   291,     0,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   530,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,     0,
-     324,   325,   326,   327,   328,     0,   329,   330,     0,   332,
-       0,   333,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   346,
-       0,   348,     0,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   364,     0,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,     0,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,     0,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   531,   448,   449,     0,     0,   450,   451,     0,
-     452,     0,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   464,   465,   466,     0,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   487,   488,   489,     0,   490,     0,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,   528,     0,   554,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  2847,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   130,   131,     0,   132,   133,   134,     0,   136,
-     137,   138,   139,   140,     0,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   161,     0,
-       0,     0,   163,   164,   165,   166,   167,   168,     0,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-       0,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-       0,     0,     0,   238,   239,   529,     0,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,     0,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,     0,     0,   281,     0,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,     0,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   530,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,     0,   324,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,     0,
-     333,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,     0,
-     348,     0,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     364,     0,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,     0,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   531,   448,   449,     0,     0,   450,   451,     0,   452,
-       0,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   464,   465,   466,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,     0,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   528,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  3302,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   130,   131,     0,   132,   133,   134,     0,   136,   137,
-     138,   139,   140,     0,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   161,     0,     0,
-       0,   163,   164,   165,   166,   167,   168,     0,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,     0,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,     0,
-       0,     0,   238,   239,   529,     0,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,     0,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,     0,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-       0,     0,   281,     0,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,     0,   291,     0,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   530,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,     0,   324,   325,
-     326,   327,   328,     0,   329,   330,     0,   332,     0,   333,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,     0,   348,
-       0,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   364,
-       0,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,     0,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,     0,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     531,   448,   449,     0,     0,   450,   451,     0,   452,     0,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   464,   465,   466,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,     0,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     528,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  2210,     0,     0,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     130,   131,     0,   132,   133,   134,     0,   136,   137,   138,
-     139,   140,     0,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,     0,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   161,     0,     0,     0,
-     163,   164,   165,   166,   167,   168,     0,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,     0,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,     0,     0,
-       0,   238,   239,   529,     0,   242,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,   253,
-     254,     0,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,     0,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,     0,
-       0,   281,     0,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,     0,   291,     0,     0,   293,   294,   295,   296,
-     297,   298,   299,   300,   530,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,     0,   324,   325,   326,
-     327,   328,     0,   329,   330,     0,   332,     0,   333,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,     0,   341,
-     342,   343,     0,     0,   344,   345,   346,     0,   348,     0,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   364,     0,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,     0,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-       0,     0,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   531,
-     448,   449,     0,     0,   450,   451,     0,   452,     0,   454,
-     455,   456,   457,   458,     0,   459,   460,   461,     0,     0,
-     462,   463,   464,   465,   466,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   489,     0,   490,     0,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,     0,
-    2973,  1364,   821,     0,     0,  2078,  1060,     0,     0,     0,
-       0,     0,  2079,  2080,     0,  3164,  2081,  2082,  2083,   118,
-     119,   120,   121,   122,   123,   124,   125,   561,   126,   127,
-     128,   562,   563,   564,  2974,   566,   567,   568,   569,  2975,
-     130,   131,   571,   132,   133,   134,  2976,   136,   137,   138,
-       0,  1506,  2977,  1508,  1509,   578,   144,   145,   146,   147,
-     148,   149,   579,   580,   150,   151,   152,   153,  1510,  1511,
-     156,   583,   157,   158,   159,   160,     0,   585,  2978,   587,
-    2979,   164,   165,   166,   167,   168,  2980,   170,   171,   172,
-     590,   173,   174,   175,   176,   177,   178,   591,  2981,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,  1516,
-     191,   192,  1517,   194,   596,   195,   597,   196,   197,   198,
-     199,   200,   201,   598,   599,   202,   203,   204,   205,   600,
-     601,   206,   207,  1073,   209,   210,   602,   211,   212,   213,
-     603,   214,   215,   216,   604,   217,   218,   219,   220,     0,
-     222,   223,   224,   225,   226,   227,     0,   607,   229,   608,
-     230,   231,  1518,   233,   610,   234,   611,   235,  2982,   613,
-    2983,   238,   239,  2984,  2985,   242,   617,   243,   618,     0,
-       0,   246,   247,   621,   248,   249,   250,   251,   252,   253,
-     254,  2986,   256,   257,   258,   259,   623,   260,   261,   262,
-     263,   264,   265,   266,   624,   267,  2987,     0,   270,   271,
-     272,   273,   274,  1524,  1525,   629,  1526,   631,   278,  2988,
-    2989,   281,  2990,   283,   284,   285,   286,   287,   288,   635,
-     636,   289,  2991,   291,  2992,   639,   293,   294,   295,   296,
-     297,   298,   299,   300,  2993,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,  1533,  2994,  1535,   325,   326,
-     327,  2995,   645,   329,   330,  2996,   332,   647,     0,   334,
-    1537,   336,   337,   338,   650,   339,   340,   651,   652,  2997,
-     342,   343,   653,   654,   344,   345,     0,  2998,   348,  2999,
-       0,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   659,   660,   661,   662,   362,   363,     0,  3000,
-     366,   367,     0,   369,   370,   371,   666,   372,   373,   374,
-     375,   376,   377,   667,   378,   379,   380,   381,   382,  1541,
-     384,   385,   386,   387,   669,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   670,   401,
-     402,  3001,   404,   405,   406,  1543,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,   673,
-    3002,   421,   422,   423,   424,   425,   426,  3003,   428,   429,
-     676,  3004,   431,   432,  1547,   434,   679,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,  3005,
-     448,     0,   682,   683,   450,   451,   684,   452,  3006,   454,
-     455,   456,   457,   458,   686,   459,  1550,  1551,   689,   690,
-     462,   463,     0,   465,     0,   693,   467,   468,  3007,   470,
-     471,   472,   473,   474,  3008,   696,   475,   476,   477,   697,
-     478,   479,   480,   481,   698,   482,   483,   484,   485,   486,
-       0,  1554,   489,   701,   490,  3009,   492,   493,   494,   495,
-     496,   497,   498,   703,   704,   499,   705,   706,   500,   501,
-     502,   503,   504,   505,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   517,   518,   519,   520,     0,
-     528,     0,  2084,  2085,  2086,  2078,  3010,  3011,  2089,  2090,
-    2091,  2092,  2079,  2080,     0,     0,  2081,  2082,  2083,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     130,   131,     0,   132,   133,   134,     0,   136,   137,   138,
-     139,   140,     0,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,     0,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   161,     0,     0,     0,
-     163,   164,   165,   166,   167,   168,     0,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,     0,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,     0,     0,
-       0,   238,   239,   529,     0,   242,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,   253,
-     254,     0,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,     0,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,     0,
-       0,   281,     0,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,     0,   291,     0,     0,   293,   294,   295,   296,
-     297,   298,   299,   300,   530,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,     0,   324,   325,   326,
-     327,   328,     0,   329,   330,     0,   332,     0,   333,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,     0,   341,
-     342,   343,     0,     0,   344,   345,   346,     0,   348,     0,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   364,     0,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,     0,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-       0,     0,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   531,
-     448,   449,     0,     0,   450,   451,     0,   452,     0,   454,
-     455,   456,   457,   458,     0,   459,   460,   461,     0,     0,
-     462,   463,   464,   465,   466,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   489,     0,   490,     0,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,     0,
-       0,     0,  2084,  2085,  2086,     0,  2087,  2088,  2089,  2090,
-    2091,  2092,  1639,     0,     0,  1640,     0,     0,     0,  1641,
-    1642,  1643,  1644,  1645,  1646,  1647,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1648,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1650,  1639,     0,     0,  1640,     0,     0,  1651,  1641,  1642,
-    1643,  1644,  1645,  1646,  1647,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1648,
-       0,     0,     0,     0,  1652,     0,     0,     0,     0,  1650,
-    1639,     0,     0,  1640,     0,     0,  1651,  1641,  1642,  1643,
-    1644,  1645,  1646,  1647,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1648,     0,
-       0,     0,     0,  1652,     0,     0,     0,     0,  1650,     0,
-       0,     0,     0,     0,     0,  1651,     0,     0,  1639,     0,
-       0,  1640,     0,     0,     0,  1641,  1642,  1643,  1644,  1645,
-    1646,  1647,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1652,     0,     0,     0,  1648,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1650,  1639,     0,     0,
-    1640,  1653,     0,  1651,  1641,  1642,  1643,  1644,  1645,  1646,
-    1647,     0,     0,     0,     0,     0,     0,     0,  1654,     0,
-       0,     0,     0,  1655,     0,  1648,     0,     0,     0,     0,
-    1652,     0,     0,     0,     0,  1650,     0,     0,     0,     0,
-    1653,     0,  1651,     0,     0,     0,  1656,  1657,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1654,     0,     0,
-       0,  1658,  1655,     0,     0,     0,     0,     0,     0,  1652,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1653,
-       0,     0,     0,     0,     0,  1656,  1657,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1654,     0,     0,  1659,
-    1658,  1655,  1660,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1661,     0,     0,  1662,
-       0,     0,     0,     0,  1656,  1657,     0,  1653,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1659,  1658,
-       0,  1660,     0,     0,  1654,     0,     0,     0,     0,  1655,
-       0,     0,     0,     0,     0,  1661,     0,     0,  1662,     0,
-       0,     0,     0,     0,     0,     0,  1653,     0,     0,     0,
-       0,     0,  1656,  1657,     0,     0,     0,  1659,     0,     0,
-    1660,     0,     0,  1654,     0,     0,     0,  1658,  1655,     0,
-       0,     0,     0,     0,  1661,     0,     0,  1662,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1656,  1657,     0,     0,     0,     0,     0,  1663,     0,
-       0,     0,     0,     0,     0,  1659,  1658,     0,  1660,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1661,     0,     0,  1662,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1663,     0,     0,
-       0,     0,     0,     0,  1659,     0,     0,  1660,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1661,     0,     0,  1662,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1663,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1664,     0,     0,  1665,
-    1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,     0,
-       0,     0,     0,  2919,  1663,     0,     0,     0,     0,     0,
-    1639,     0,     0,  1640,     0,     0,     0,  1641,  1642,  1643,
-    1644,  1645,  1646,  1647,     0,  1664,     0,     0,  1665,  1666,
-    1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,  1648,     0,
-       0,     0,  3156,  1663,     0,     0,     0,     0,  1650,     0,
-       0,     0,     0,     0,     0,  1651,     0,     0,     0,     0,
-       0,     0,     0,     0,  1664,     0,     0,  1665,  1666,  1667,
-       0,  1668,  1669,  1670,  1671,  1672,  1673,     0,     0,     0,
-       0,  3163,  1652,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1639,     0,     0,
-    1640,     0,     0,     0,  1641,  1642,  1643,  1644,  1645,  1646,
-    1647,     0,  1664,     0,     0,  1665,  1666,  1667,     0,  1668,
-    1669,  1670,  1671,  1672,  1673,  1648,     0,     0,     0,  3325,
-       0,     0,     0,     0,     0,  1650,  1639,     0,     0,  1640,
-       0,     0,  1651,  1641,  1642,  1643,  1644,  1645,  1646,  1647,
-       0,  1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,
-    1670,  1671,  1672,  1673,  1648,     0,     0,     0,  3347,  1652,
-       0,     0,     0,     0,  1650,  1639,     0,     0,  1640,  1653,
-       0,  1651,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,
-       0,     0,     0,     0,     0,     0,  1654,     0,     0,     0,
-       0,  1655,     0,  1648,     0,     0,     0,     0,  1652,     0,
-       0,     0,     0,  1650,     0,     0,     0,     0,     0,     0,
-    1651,     0,     0,     0,  1656,  1657,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1658,
-       0,     0,     0,     0,     0,     0,     0,  1652,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1639,     0,     0,  1640,  1653,     0,     0,  1641,
-    1642,  1643,  1644,  1645,  1646,  1647,     0,  1659,     0,     0,
-    1660,     0,     0,  1654,     0,     0,     0,     0,  1655,     0,
-    1648,     0,     0,     0,  1661,     0,     0,  1662,     0,     0,
-    1650,     0,     0,     0,     0,  1653,     0,  1651,     0,     0,
-       0,  1656,  1657,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1654,     0,     0,     0,  1658,  1655,     0,     0,
-       0,     0,     0,     0,  1652,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1653,     0,     0,     0,     0,     0,
-    1656,  1657,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1654,     0,     0,  1659,  1658,  1655,  1660,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1661,     0,     0,  1662,     0,     0,     0,     0,  1656,
-    1657,     0,     0,     0,     0,     0,  1663,     0,     0,     0,
-       0,     0,     0,  1659,  1658,     0,  1660,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1661,     0,     0,  1662,     0,     0,     0,     0,     0,     0,
-       0,  1653,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1659,     0,     0,  1660,     0,     0,  1654,     0,
-       0,     0,     0,  1655,     0,     0,     0,     0,     0,  1661,
-       0,     0,  1662,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1656,  1657,     0,     0,
-       0,     0,     0,  1663,     0,     0,     0,     0,     0,     0,
-       0,  1658,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1664,     0,     0,  1665,  1666,  1667,
-       0,  1668,  1669,  1670,  1671,  1672,  1673,     0,     0,     0,
-       0,  3447,  1663,     0,     0,     0,     0,     0,     0,  1659,
-       0,     0,  1660,     0,     0,     0,     0,     0,     0,     0,
-    1639,     0,     0,  1640,     0,     0,  1661,  1641,  1642,  1662,
-       0,  1645,  1646,  1647,     0,     0,     0,     0,     0,  1639,
-       0,  1663,  1640,     0,     0,     0,  1641,  1642,  1643,  1644,
-    1645,  1646,  1647,     0,     0,     0,     0,     0,  1650,     0,
-       0,     0,     0,     0,     0,  1651,     0,  1648,     0,     0,
-       0,  1664,     0,     0,  1665,  1666,  1667,  1650,  1668,  1669,
-    1670,  1671,  1672,  1673,  1651,     0,     0,     0,  3503,     0,
-       0,     0,  1652,     0,     0,     0,  1639,     0,     0,  1640,
-       0,     0,     0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,
-    1664,  1652,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,
-    1671,  1672,  1673,     0,  1648,     0,     0,  3525,  1663,     0,
-       0,     0,     0,     0,  1650,     0,     0,     0,     0,     0,
-       0,  1651,     0,     0,     0,     0,     0,     0,     0,  1664,
-       0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,
-    1672,  1673,     0,     0,  1827,     0,     0,     0,  1652,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1653,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1654,     0,  1653,     0,
-       0,  1655,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1654,     0,     0,     0,     0,
-    1655,     0,     0,     0, -2102, -2102,  1664,     0,     0,  1665,
-    1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,  1658,
-       0,  2873,     0,  1656,  1657,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1653,     0,     0,  1658,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1654,     0,     0,     0,     0,  1655,     0,     0,
-   -2102,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1661,     0,  1659,     0,     0,  1660,
-    1656,  1657,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1661,     0,  1658,  1662,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1659,     0,     0,  1660,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1661,     0,     0,  1662,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1663,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1663,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1663,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1664,     0,     0,  1665,  1666,  1667,
-       0,  1668,  1669,  1670,  1671,  1672,  1673,     0,     0,     0,
-       0,     0,     0,  1664,     0,     0,  1665,  1666,  1667,     0,
-    1668,  1669,  1670,  1671,  1672,  1673,     0,     0,  3315,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   560,     0,     0,
-    1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,
-    1671,  1672,  1673,     0,     0,  3487,   118,   119,   120,   121,
-     122,   123,   124,   125,   561,   126,   127,   128,   562,   563,
-     564,   565,   566,   567,   568,   569,   570,   130,   131,   571,
-     132,   133,   134,   572,   136,   137,   138,   573,   574,   575,
-     576,   577,   578,   144,   145,   146,   147,   148,   149,   579,
-     580,   150,   151,   152,   153,   581,   582,   156,   583,   157,
-     158,   159,   160,   584,   585,   586,   587,   588,   164,   165,
-     166,   167,   168,   589,   170,   171,   172,   590,   173,   174,
-     175,   176,   177,   178,   591,   592,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,   594,   191,   192,   595,
-     194,   596,   195,   597,   196,   197,   198,   199,   200,   201,
-     598,   599,   202,   203,   204,   205,   600,   601,   206,   207,
-     208,   209,   210,   602,   211,   212,   213,   603,   214,   215,
-     216,   604,   217,   218,   219,   220,   605,   222,   223,   224,
-     225,   226,   227,   606,   607,   229,   608,   230,   231,   609,
-     233,   610,   234,   611,   235,   612,   613,   614,   238,   239,
-     615,   616,   242,   617,   243,   618,   619,   620,   246,   247,
-     621,   248,   249,   250,   251,   252,   253,   254,   622,   256,
-     257,   258,   259,   623,   260,   261,   262,   263,   264,   265,
-     266,   624,   267,   625,   626,   270,   271,   272,   273,   274,
-     627,   628,   629,   630,   631,   278,   632,   633,   281,   634,
-     283,   284,   285,   286,   287,   288,   635,   636,   289,   637,
-     291,   638,   639,   293,   294,   295,   296,   297,   298,   299,
-     300,   640,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   641,   642,   643,   325,   326,   327,   644,   645,
-     329,   330,   646,   332,   647,   648,   334,   649,   336,   337,
-     338,   650,   339,   340,   651,   652,   341,   342,   343,   653,
-     654,   344,   345,   655,   656,   348,   657,   658,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   659,
-     660,   661,   662,   362,   363,   663,   664,   366,   367,   665,
-     369,   370,   371,   666,   372,   373,   374,   375,   376,   377,
-     667,   378,   379,   380,   381,   382,   668,   384,   385,   386,
-     387,   669,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   670,   401,   402,   671,   404,
-     405,   406,   672,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   673,   674,   421,   422,
-     423,   424,   425,   426,   675,   428,   429,   676,   677,   431,
-     432,   678,   434,   679,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   680,   448,   681,   682,
-     683,   450,   451,   684,   452,   685,   454,   455,   456,   457,
-     458,   686,   459,   687,   688,   689,   690,   462,   463,   691,
-     465,   692,   693,   467,   468,   694,   470,   471,   472,   473,
-     474,   695,   696,   475,   476,   477,   697,   478,   479,   480,
-     481,   698,   482,   483,   484,   485,   486,   699,   700,   489,
-     701,   490,   702,   492,   493,   494,   495,   496,   497,   498,
-     703,   704,   499,   705,   706,   500,   501,   502,   503,   504,
-     505,   707,   708,   709,   710,   711,   712,   713,   714,   715,
-     716,   717,   517,   518,   519,   520,   528,     0,     0,     0,
-       0,     0,     0,     0,     0,  2115,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,   126,   127,   128,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   130,   131,     0,   132,
-     133,   134,     0,   136,   137,   138,   139,   140,     0,   142,
-     143,     0,   144,   145,   146,   147,   148,   149,     0,     0,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-     159,   160,   161,     0,     0,     0,   163,   164,   165,   166,
-     167,   168,     0,   170,   171,   172,     0,   173,   174,   175,
-     176,   177,   178,     0,     0,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,     0,   196,   197,   198,   199,   200,   201,     0,
-       0,   202,   203,   204,   205,     0,     0,   206,   207,   208,
-     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
-       0,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,     0,   229,     0,   230,   231,   232,   233,
-       0,   234,     0,   235,     0,     0,     0,   238,   239,   529,
-       0,   242,     0,   243,     0,   244,   245,   246,   247,     0,
-     248,   249,   250,   251,   252,   253,   254,     0,   256,   257,
-     258,   259,     0,   260,   261,   262,   263,   264,   265,   266,
-       0,   267,     0,   269,   270,   271,   272,   273,   274,   275,
-     276,     0,   277,     0,   278,     0,     0,   281,     0,   283,
-     284,   285,   286,   287,   288,     0,     0,   289,     0,   291,
-       0,     0,   293,   294,   295,   296,   297,   298,   299,   300,
-     530,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,     0,   324,   325,   326,   327,   328,     0,   329,
-     330,     0,   332,     0,   333,   334,   335,   336,   337,   338,
-       0,   339,   340,     0,     0,   341,   342,   343,     0,     0,
-     344,   345,   346,     0,   348,     0,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,     0,     0,
-       0,     0,   362,   363,   364,     0,   366,   367,   368,   369,
-     370,   371,     0,   372,   373,   374,   375,   376,   377,     0,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-       0,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,     0,   401,   402,     0,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,     0,     0,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,     0,     0,   431,   432,
-     433,   434,     0,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   531,   448,   449,     0,     0,
-     450,   451,     0,   452,     0,   454,   455,   456,   457,   458,
-       0,   459,   460,   461,     0,     0,   462,   463,   464,   465,
-     466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
-       0,     0,   475,   476,   477,     0,   478,   479,   480,   481,
-       0,   482,   483,   484,   485,   486,   487,   488,   489,     0,
-     490,     0,   492,   493,   494,   495,   496,   497,   498,     0,
-       0,   499,     0,     0,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
-     516,   517,   518,   519,   520,   528,     0,     0,     0,     0,
-       0,     0,     0,     0,  2766,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,   159,
-     160,   161,     0,     0,     0,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,     0,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,     0,   230,   231,   232,   233,     0,
-     234,     0,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-       0,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   974,  1364,   821,     0,     0,     0,
-    1060,     0,     0,  2769,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,     0,   126,   127,   128,     0,     0,     0,   565,     0,
-       0,     0,     0,   570,   130,   131,     0,   132,   133,   134,
-     572,   136,   137,   138,   573,   574,   575,   576,   577,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   581,   582,   156,     0,   157,   158,   159,   160,
-     584,     0,   586,     0,   588,   164,   165,   166,   167,   168,
-     589,   170,   171,   172,     0,   173,   174,   175,   176,   177,
-     178,     0,   592,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   594,   191,   192,   595,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   605,   222,   223,   224,   225,   226,   227,
-     606,  1365,   229,     0,   230,   231,   609,   233,     0,   234,
-       0,   235,   612,     0,   614,   238,   239,   615,   616,   242,
-       0,   243,     0,   619,   620,   246,   247,     0,   248,   249,
-     250,   251,   252,   253,   254,   622,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-     625,   626,   270,   271,   272,   273,   274,   627,   628,     0,
-     630,     0,   278,   632,   633,   281,   634,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,   637,   291,   638,     0,
-     293,   294,   295,   296,   297,   298,   299,   300,   640,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   641,
-     642,   643,   325,   326,   327,   644,     0,   329,   330,   646,
-     332,     0,   648,   334,   649,   336,   337,   338,     0,   339,
-     340,  1366,     0,   341,   342,   343,     0,     0,   344,   345,
-     655,   656,   348,   657,   658,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   663,   664,   366,   367,   665,   369,   370,   371,
-       0,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   668,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,   671,   404,   405,   406,   672,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,   674,   421,   422,   423,   424,   425,
-     426,   675,   428,   429,     0,   677,   431,   432,   678,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   680,   448,   681,     0,     0,   450,   451,
-       0,   452,   685,   454,   455,   456,   457,   458,     0,   459,
-     687,   688,     0,     0,   462,   463,   691,   465,   692,  1367,
-     467,   468,   694,   470,   471,   472,   473,   474,     0,     0,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   699,   700,   489,     0,   490,   702,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   707,   708,
-     709,   710,   711,   712,   713,   714,   715,   716,   717,   517,
-     518,   519,   520,     0,     0,  1639,     0,     0,  1640,     0,
-    1368,  1369,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1648,     0,     0,     0,     0,  2216,     0,
-       0,     0,     0,  1650,  1639,     0,     0,  1640,     0,     0,
-    1651,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1648,     0,     0,     0,     0,  1652,     0,     0,
-       0,     0,  1650,  1639,     0,     0,  1640,     0,     0,  1651,
-    1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1648,     0,     0,     0,     0,  1652,     0,     0,     0,
-       0,  1650,     0,  2217,     0,     0,     0,     0,  1651,     0,
-    1639,     0,     0,  1640,     0,     0,     0,  1641,  1642,  1643,
-    1644,  1645,  1646,  1647,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1652,     0,     0,  1648,     0,
-       0,     0,  1929,     0,     0,     0,     0,     0,  1650,     0,
-       0,     0,     0,     0,  1653,  1651,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1654,     0,     0,     0,     0,  1655,     0,     0,     0,
-       0,     0,  1652,  1965,     0,     0,     0,     0,  1966,     0,
-       0,     0,     0,  1653,     0,     0,     0,     0,     0,  1656,
-    1657,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1654,     0,     0,     0,  1658,  1655,     0,     0,     0,     0,
-       0,  3593,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1653,     0,     0,     0,     0,     0,  1656,  1657,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1654,
-       0,     0,  1659,  1658,  1655,  1660,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1661,
-       0,     0,  1662,     0,     0,     0,     0,  1656,  1657,  1653,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1659,  1658,     0,  1660,     0,  1654,     0,     0,     0,
-       0,  1655,     0,     0,     0,     0,     0,     0,  1661,     0,
-       0,  1662,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1656,  1657,     0,     0,     0,     0,
-    1659,     0,     0,  1660,     0,     0,     0,     0,     0,  1658,
-       0,     0,     0,     0,     0,     0,     0,  1661,     0,     0,
-    1662,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1663,     0,     0,     0,     0,     0,  1659,     0,  3594,
-    1660,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1661,     0,     0,  1662,     0,     0,
-       0,     0,     0,     0,     0,  1639,     0,     0,  1640,     0,
-    1663,     0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1648,  2220,     0,     0,     0,     0,     0,
-       0,     0,     0,  1650,     0,     0,     0,     0,     0,  1663,
-    1651,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1652,     0,  1664,
-       0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,
-    1672,  1673,     0,     0,     0,     0,  1663,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1664,     0,
-       0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,
-    1673,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1664,     0,     0,
-    1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,
-       0,     0,     0,     0,  1653,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1639,  1654,     0,  1640,     0,     0,  1655,  1641,  1642,  1643,
-    1644,  1645,  1646,  1647,  1664,     0,     0,  1665,  1666,  1667,
-       0,  1668,  1669,  1670,  1671,  1672,  1673,     0,  1648,  1656,
-    1657,     0,  1971,     0,     0,     0,     0,     0,  1650,     0,
-       0,     0,     0,     0,  1658,  1651,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1639,     0,     0,  1640,
-       0,     0,  1652,  1641,  1642,  1643,  1644,  1645,  1646,  1647,
-       0,     0,  1659,     0,     0,  1660,     0,     0,     0,     0,
-       0,     0,     0,     0,  1648,     0,     0,     0,     0,  1661,
-       0,     0,  1662,     0,  1650,     0,     0,     0,     0,     0,
-       0,  1651,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1936,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1652,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1639,     0,     0,  1640,     0,
-       0,     0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,  1653,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1648,     0,     0,  1654,  1978,     0,     0,
-       0,  1655,     0,  1650,     0,     0,     0,     0,     0,     0,
-    1651,  1663,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1656,  1657,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1652,     0,  1658,
-    1976,     0,     0,     0,     0,  1653,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1654,     0,     0,     0,     0,  1655,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1659,     0,     0,
-    1660,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1656,  1657,     0,     0,  1661,     0,     0,  1662,     0,     0,
-       0,     0,     0,     0,     0,  1658,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1664,
-       0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,
-    1672,  1673,     0,     0,  1653,     0,     0,     0,     0,     0,
-       0,     0,     0,  1659,     0,     0,  1660,     0,     0,     0,
-       0,  1654,     0,     0,     0,     0,  1655,     0,     0,     0,
-    1661,     0,     0,  1662,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1639,     0,     0,  1640,     0,  1656,
-    1657,  1641,  1642,  1643,  1644,  1645,  1646,  1647,     0,     0,
-       0,     0,     0,     0,  1658,     0,  1663,     0,     0,     0,
-       0,     0,  1648,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1650,     0,     0,     0,     0,     0,     0,  1651,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1639,  1659,     0,  1640,  1660,     0,     0,  1641,  1642,
-    1643,  1644,  1645,  1646,  1647,     0,  1652,     0,     0,  1661,
-       0,     0,  1662,     0,     0,     0,     0,     0,     0,  1648,
-       0,     0,  1663,     0,     0,     0,     0,     0,     0,  1650,
-       0,     0,     0,     0,     0,     0,  1651,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1652,  1664,     0,     0,  1665,  1666,  1667,
-       0,  1668,  1669,  1670,  1671,  1672,  1673,     0,  1639,     0,
-       0,  1640,     0,     0,     0,  1641,  1642,  1643,  1644,  1645,
-    1646,  1647,     0,  2108,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1653,     0,     0,  1648,     0,     0,     0,
-    2846,  1663,     0,     0,     0,     0,  1650,     0,     0,     0,
-    1654,     0,     0,  1651,     0,  1655,     0,     0,     0,     0,
-    1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,
-    1671,  1672,  1673,     0,     0,     0,     0,     0,  1656,  1657,
-    1652,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1653,     0,     0,  1658,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1654,     0,     0,
-       0,     0,  1655,     0,     0,     0,     0,  1639,     0,     0,
-    1640,     0,     0,     0,  1641,  1642,  1643,  1644,  1645,  1646,
-    1647,  1659,     0,     0,  1660,  1656,  1657,     0,     0,     0,
-       0,     0,     0,     0,     0,  1648,     0,     0,  1661,  1664,
-    1658,  1662,  1665,  1666,  1667,  1650,  1668,  1669,  1670,  1671,
-    1672,  1673,  1651,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1653,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1659,  1652,
-       0,  1660,     0,     0,  1654,     0,     0,     0,     0,  1655,
-       0,     0,     0,     0,     0,  1661,     0,     0,  1662,     0,
-       0,     0,     0,     0,     0,     0,     0,  1639,     0,     0,
-    1640,     0,  1656,  1657,  1641,  1642,  1643,  1644,  1645,  1646,
-    1647,     0,     0,     0,     0,     0,     0,  1658,     0,     0,
-       0,     0,     0,     0,     0,  1648,     0,     0,     0,     0,
-    1663,     0,     0,     0,     0,  1650,     0,     0,     0,     0,
-       0,     0,  1651,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1659,     0,     0,  1660,     0,
-       0,     0,     0,     0,     0,     0,  1653,     0,     0,  1652,
-       0,     0,  1661,     0,     0,  1662,     0,     0,     0,     0,
-       0,     0,     0,  1654,     0,     0,  1639,  1663,  1655,  1640,
-       0,     0,     0,  1641,  1642,  1643,  1644,  1645,  1646,  1647,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1656,  1657,     0,  1648,     0,     0,     0,     0,     0,
-    2830,     0,     0,     0,  1650,     0,  1658,     0,     0,     0,
-       0,  1651,     0,     0,     0,     0,     0,     0,  1664,     0,
-       0,  1665,  1666,  1667,     0,  1668,  1669,  1670,  1671,  1672,
-    1673,     0,     0,     0,     0,     0,     0,     0,  1652,     0,
-       0,     0,     0,     0,  1659,     0,  1653,  1660,     0,     0,
-       0,     0,     0,     0,  1663,     0,     0,     0,     0,     0,
-       0,  1661,     0,  1654,  1662,     0,     0,     0,  1655,     0,
-       0,     0,     0,     0,     0,  1664,     0,     0,  1665,  1666,
-    1667,     0,  1668,  1669,  1670,  1671,  1672,  1673,     0,     0,
-       0,  1840,  1657,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1658,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1653,     0,     0,     0,     0,
-       0,     0,     0,     0,  1659,     0,     0,  1660,     0,     0,
-       0,     0,  1654,     0,     0,     0,     0,  1655,     0,     0,
-       0,  1661,  1664,  1663,  1662,  1665,  1666,  1667,     0,  1668,
-    1669,  1670,  1671,  1672,  1673,     0,     0,     0,     0,     0,
-    1656,  1657,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1658,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1659,     0,     0,  1660,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1661,     0,     0,  1662,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1663,     0,     0,     0,     0,     0,     0,
-       0,  1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,
-    1670,  1671,  1672,  1673,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1663,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,
-    1670,  1671,  1672,  1673,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   560,     0,  2132,     0,     0,     0,
-    1664,     0,     0,  1665,  1666,  1667,     0,  1668,  1669,  1670,
-    1671,  2237,  1673,   118,   119,   120,   121,   122,   123,   124,
-     125,   561,   126,   127,   128,   562,   563,   564,   565,   566,
-     567,   568,   569,   570,   130,   131,   571,   132,   133,   134,
-     572,   136,   137,   138,   573,   574,   575,   576,   577,   578,
-     144,   145,   146,   147,   148,   149,   579,   580,   150,   151,
-     152,   153,   581,   582,   156,   583,   157,   158,   159,   160,
-     584,   585,   586,   587,   588,   164,   165,   166,   167,   168,
-     589,   170,   171,   172,   590,   173,   174,   175,   176,   177,
-     178,   591,   592,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   594,   191,   192,   595,   194,   596,   195,
-     597,   196,   197,   198,   199,   200,   201,   598,   599,   202,
-     203,   204,   205,   600,   601,   206,   207,   208,   209,   210,
-     602,   211,   212,   213,   603,   214,   215,   216,   604,   217,
-     218,   219,   220,   605,   222,   223,   224,   225,   226,   227,
-     606,   607,   229,   608,   230,   231,   609,   233,   610,   234,
-     611,   235,   612,   613,   614,   238,   239,   615,   616,   242,
-     617,   243,   618,   619,   620,   246,   247,   621,   248,   249,
-     250,   251,   252,   253,   254,   622,   256,   257,   258,   259,
-     623,   260,   261,   262,   263,   264,   265,   266,   624,   267,
-     625,   626,   270,   271,   272,   273,   274,   627,   628,   629,
-     630,   631,   278,   632,   633,   281,   634,   283,   284,   285,
-     286,   287,   288,   635,   636,   289,   637,   291,   638,   639,
-     293,   294,   295,   296,   297,   298,   299,   300,   640,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   641,
-     642,   643,   325,   326,   327,   644,   645,   329,   330,   646,
-     332,   647,   648,   334,   649,   336,   337,   338,   650,   339,
-     340,   651,   652,   341,   342,   343,   653,   654,   344,   345,
-     655,   656,   348,   657,   658,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   659,   660,   661,   662,
-     362,   363,   663,   664,   366,   367,   665,   369,   370,   371,
-     666,   372,   373,   374,   375,   376,   377,   667,   378,   379,
-     380,   381,   382,   668,   384,   385,   386,   387,   669,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   670,   401,   402,   671,   404,   405,   406,   672,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,   673,   674,   421,   422,   423,   424,   425,
-     426,   675,   428,   429,   676,   677,   431,   432,   678,   434,
-     679,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   680,   448,   681,   682,   683,   450,   451,
-     684,   452,   685,   454,   455,   456,   457,   458,   686,   459,
-     687,   688,   689,   690,   462,   463,   691,   465,   692,   693,
-     467,   468,   694,   470,   471,   472,   473,   474,   695,   696,
-     475,   476,   477,   697,   478,   479,   480,   481,   698,   482,
-     483,   484,   485,   486,   699,   700,   489,   701,   490,   702,
-     492,   493,   494,   495,   496,   497,   498,   703,   704,   499,
-     705,   706,   500,   501,   502,   503,   504,   505,   707,   708,
-     709,   710,   711,   712,   713,   714,   715,   716,   717,   517,
-     518,   519,   520,   560,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-     561,   126,   127,   128,   562,   563,   564,   565,   566,   567,
-     568,   569,   570,   130,   131,   571,   132,   133,   134,   572,
-     136,   137,   138,   573,   574,   575,   576,   577,   578,   144,
-     145,   146,   147,   148,   149,   579,   580,   150,   151,   152,
-     153,   581,   582,   156,   583,   157,   158,   159,   160,   584,
-     585,   586,   587,   588,   164,   165,   166,   167,   168,   589,
-     170,   171,   172,   590,   173,   174,   175,   176,   177,   178,
-     591,   592,   180,   181,   182,   183,   184,   185,   593,   187,
-     188,   189,   594,   191,   192,   595,   194,   596,   195,   597,
-     196,   197,   198,   199,   200,   201,   598,   599,   202,   203,
-     204,   205,   600,   601,   206,   207,   208,   209,   210,   602,
-     211,   212,   213,   603,   214,   215,   216,   604,   217,   218,
-     219,   220,   605,   222,   223,   224,   225,   226,   227,   606,
-     607,   229,   608,   230,   231,   609,   233,   610,   234,   611,
-     235,   612,   613,   614,   238,   239,   615,   616,   242,   617,
-     243,   618,   619,   620,   246,   247,   621,   248,   249,   250,
-     251,   252,   253,   254,   622,   256,   257,   258,   259,   623,
-     260,   261,   262,   263,   264,   265,   266,   624,   267,   625,
-     626,   270,   271,   272,   273,   274,   627,   628,   629,   630,
-     631,   278,   632,   633,   281,   634,   283,   284,   285,   286,
-     287,   288,   635,   636,   289,   637,   291,   638,   639,   293,
-     294,   295,   296,   297,   298,   299,   300,   640,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   641,   642,
-     643,   325,   326,   327,   644,   645,   329,   330,   646,   332,
-     647,   648,   334,   649,   336,   337,   338,   650,   339,   340,
-     651,   652,   341,   342,   343,   653,   654,   344,   345,   655,
-     656,   348,   657,   658,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   659,   660,   661,   662,   362,
-     363,   663,   664,   366,   367,   665,   369,   370,   371,   666,
-     372,   373,   374,   375,   376,   377,   667,   378,   379,   380,
-     381,   382,   668,   384,   385,   386,   387,   669,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   670,   401,   402,   671,   404,   405,   406,   672,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,   673,   674,   421,   422,   423,   424,   425,   426,
-     675,   428,   429,   676,   677,   431,   432,   678,   434,   679,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   680,   448,   681,   682,   683,   450,   451,   684,
-     452,   685,   454,   455,   456,   457,   458,   686,   459,   687,
-     688,   689,   690,   462,   463,   691,   465,   692,   693,   467,
-     468,   694,   470,   471,   472,   473,   474,   695,   696,   475,
-     476,   477,   697,   478,   479,   480,   481,   698,   482,   483,
-     484,   485,   486,   699,   700,   489,   701,   490,   702,   492,
-     493,   494,   495,   496,   497,   498,   703,   704,   499,   705,
-     706,   500,   501,   502,   503,   504,   505,   707,   708,   709,
-     710,   711,   712,   713,   714,   715,   716,   717,   517,   518,
-     519,   520,   560,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,   561,
-     126,   127,   128,   562,   563,   564,   565,   566,   567,   568,
-     569,   570,   130,   131,   571,   132,   133,   134,   572,   136,
-     137,   138,   573,   574,   575,   576,   577,   578,   144,   145,
-     146,   147,   148,   149,   579,   580,   150,   151,   152,   153,
-     581,   582,   156,   583,   157,   158,   159,   160,   584,   585,
-     586,   587,   588,   164,   165,   166,   167,   168,   589,   170,
-     171,   172,   590,   173,   174,   175,   176,   177,   178,   591,
-     592,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   594,   191,   192,   595,   194,   596,   195,   597,   196,
-     197,   198,   199,   200,   201,   598,   599,   202,   203,   204,
-     205,   600,   601,   206,   207,   208,   209,   210,   602,   211,
-     212,   213,   603,   214,   215,   216,   604,   217,   218,   219,
-     220,   605,   222,   223,   224,   225,   226,   227,   606,   607,
-     229,   608,   230,   231,   609,   233,   610,   234,   611,   235,
-     612,   613,   614,   238,   239,   615,   616,   242,   617,   243,
-     618,   619,   620,   246,   247,   621,   248,   249,   250,   251,
-     252,   950,   254,   622,   256,   257,   258,   259,   623,   260,
-     261,   262,   263,   264,   265,   266,   624,   267,   625,   626,
-     270,   271,   272,   273,   274,   627,   628,   629,   630,   631,
-     278,   632,   633,   281,   634,   283,   284,   285,   286,   287,
-     288,   635,   636,   289,   637,   291,   638,   639,   293,   294,
-     295,   296,   297,   298,   299,   300,   640,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   641,   642,   643,
-     325,   326,   327,   644,   645,   329,   330,   646,   332,   647,
-     648,   334,   649,   336,   337,   338,   650,   339,   340,   651,
-     652,   341,   342,   343,   653,   654,   344,   345,   655,   656,
-     348,   657,   658,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   659,   660,   661,   662,   362,   363,
-     663,   664,   366,   367,   665,   369,   370,   371,   666,   372,
-     373,   374,   375,   376,   377,   667,   378,   379,   380,   381,
-     382,   668,   384,   385,   386,   387,   669,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     670,   401,   402,   671,   404,   405,   406,   672,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,   673,   674,   421,   422,   423,   424,   425,   426,   675,
-     428,   429,   676,   677,   431,   432,   678,   434,   679,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   680,   448,   681,   682,   683,   450,   451,   684,   452,
-     685,   454,   455,   456,   457,   458,   686,   459,   687,   688,
-     689,   690,   462,   463,   691,   465,   692,   693,   467,   468,
-     694,   470,   471,   472,   473,   474,   695,   696,   475,   476,
-     477,   697,   478,   479,   480,   481,   698,   482,   483,   484,
-     485,   486,   699,   700,   489,   701,   490,   702,   492,   493,
-     494,   495,   496,   497,   498,   703,   704,   499,   705,   706,
-     500,   501,   502,   503,   504,   505,   707,   708,   709,   710,
-     711,   712,   713,   714,   715,   716,   717,   517,   518,   519,
-     520,   560,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,   561,   126,
-     127,   128,   562,   563,   564,   565,   566,   567,   568,   569,
-     570,   130,   131,   571,   132,   133,   134,   572,   136,   137,
-     138,   573,   574,   575,   576,   577,   578,   144,   145,   146,
-     147,   148,   149,   579,   580,   150,   151,   152,   153,   581,
-     582,   156,   583,   157,   158,   159,   160,   584,   585,   586,
-     587,   588,   164,   165,   166,   167,   168,   589,   170,   171,
-     172,   590,   173,   174,   175,   176,   177,   178,   591,   592,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     594,   191,   192,   595,   194,   596,   195,   597,   196,   197,
-     198,   199,   200,   201,   598,   599,   202,   203,   204,   205,
-     600,   601,   206,   207,   208,   209,   210,   602,   211,   212,
-     213,   603,   214,   215,   216,   604,   217,   218,   219,   220,
-     605,   222,   223,   224,   225,   226,   227,   606,   607,   229,
-     608,   230,   231,   609,   233,   610,   234,   611,   235,   612,
-     613,   614,   238,   239,   615,   616,   242,   617,   243,   618,
-     619,   620,   246,   247,   621,   248,   249,   250,   251,   252,
-     253,   254,   622,   256,   257,   258,   259,   623,   260,   261,
-     262,   263,   264,   265,   266,   624,   267,   625,   626,   270,
-     271,   272,   273,   274,   627,   628,   629,   630,   631,   278,
-     632,   633,   281,   634,   283,   284,   285,   286,   287,   288,
-     635,   636,   289,   637,   291,   638,   639,   293,   294,   295,
-     296,   297,   298,   299,   300,   640,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   641,   642,   643,   325,
-     326,   327,   644,   645,   329,   330,   646,   332,   647,   648,
-     334,   649,   336,   337,   338,   650,   339,   340,   651,   652,
-     341,   342,   343,   653,   654,   344,   345,   655,   656,   348,
-     657,   658,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   659,   660,   661,   662,   362,   363,   663,
-     664,   366,   367,   665,   369,   370,   371,   666,   372,   373,
-     374,   375,   376,   377,   667,   378,   379,   380,   381,   382,
-     668,   384,   385,   386,   387,   669,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   670,
-     401,   402,   671,   404,   405,   406,   672,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-     673,   674,   421,   422,   423,   424,   425,   426,   675,   428,
-     429,   676,   677,   431,   432,   678,   434,   679,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     680,   448,   681,   682,   683,   450,   451,   684,   452,   685,
-     454,   455,   456,   457,   458,   686,   459,   687,   688,   689,
-     690,   462,   463,   691,   465,   692,   693,   467,   468,   694,
-     470,   471,   472,   473,   474,   695,   696,   475,   476,   477,
-     697,   478,   479,   480,   481,   698,   482,   483,   484,   485,
-     486,   699,   700,   489,   701,   490,   702,   492,   493,   494,
-     495,   496,   497,   498,   703,   704,   499,   705,   706,   500,
-     501,   502,   503,   504,   505,   707,   708,   709,   710,   711,
-     712,   713,   714,   715,   716,   717,   517,   518,   519,   520,
-     560,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-     119,   120,   121,  2286,   123,   124,   125,   561,   126,   127,
-     128,   562,   563,   564,   565,   566,   567,   568,   569,   570,
-     130,   131,   571,   132,   133,   134,   572,   136,   137,   138,
-     573,   574,   575,   576,   577,   578,   144,   145,   146,   147,
-     148,   149,   579,   580,   150,   151,   152,   153,   581,   582,
-     156,   583,   157,   158,   159,   160,   584,   585,   586,   587,
-     588,   164,   165,   166,   167,   168,   589,   170,   171,   172,
-     590,   173,   174,   175,   176,   177,   178,   591,   592,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   594,
-     191,   192,   595,   194,   596,   195,   597,   196,   197,   198,
-     199,   200,   201,   598,   599,   202,   203,   204,   205,   600,
-     601,   206,   207,   208,  2287,   210,   602,   211,   212,   213,
-     603,   214,   215,   216,   604,   217,   218,   219,   220,   605,
-     222,   223,   224,   225,   226,   227,   606,   607,   229,   608,
-     230,   231,   609,   233,   610,   234,   611,   235,   612,   613,
-     614,   238,   239,   615,   616,   242,   617,   243,   618,   619,
-     620,   246,   247,   621,   248,   249,   250,   251,   252,   253,
-     254,   622,   256,   257,   258,   259,   623,   260,   261,   262,
-     263,   264,   265,   266,   624,   267,   625,   626,   270,   271,
-     272,   273,   274,   627,   628,   629,   630,   631,   278,   632,
-     633,   281,   634,   283,   284,   285,   286,   287,   288,   635,
-     636,   289,   637,   291,   638,   639,   293,   294,   295,   296,
-     297,   298,   299,   300,   640,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   641,   642,   643,   325,   326,
-     327,   644,   645,   329,   330,   646,   332,   647,   648,   334,
-     649,   336,   337,   338,   650,   339,   340,   651,   652,   341,
-     342,   343,   653,   654,   344,   345,   655,   656,   348,   657,
-     658,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   659,   660,   661,   662,   362,   363,   663,   664,
-     366,   367,   665,   369,   370,   371,   666,   372,   373,   374,
-     375,   376,   377,   667,   378,   379,   380,   381,   382,   668,
-     384,   385,   386,   387,   669,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   670,   401,
-     402,   671,   404,   405,   406,   672,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,   673,
-     674,   421,   422,   423,   424,   425,  2288,   675,   428,   429,
-     676,   677,   431,   432,   678,   434,   679,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   680,
-     448,   681,   682,   683,   450,   451,   684,   452,   685,   454,
-     455,   456,   457,   458,   686,   459,   687,   688,   689,   690,
-     462,   463,   691,   465,   692,   693,   467,   468,   694,   470,
-     471,   472,   473,   474,   695,   696,   475,   476,   477,   697,
-     478,   479,   480,   481,   698,   482,   483,   484,   485,   486,
-     699,   700,   489,   701,   490,   702,   492,   493,   494,   495,
-     496,   497,   498,   703,   704,   499,   705,   706,   500,   501,
-     502,   503,   504,   505,   707,   708,   709,   710,   711,   712,
-     713,   714,   715,   716,   717,   517,   518,   519,   520,   974,
-       0,   821,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,   565,     0,     0,     0,     0,   570,   130,
-     131,     0,   132,   133,   134,   572,   136,   137,   138,   573,
-     574,   575,   576,   577,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   581,   582,   156,
-       0,   157,   158,   159,   160,   584,     0,   586,     0,   588,
-     164,   165,   166,   167,   168,   589,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,   592,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   594,   191,
-     192,   595,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   605,   222,
-     223,   224,   225,   226,   227,   606,  1365,   229,     0,   230,
-     231,   609,   233,     0,   234,     0,   235,   612,     0,   614,
-     238,   239,   615,   616,   242,     0,   243,     0,   619,   620,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-     622,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,   625,   626,   270,   271,   272,
-     273,   274,   627,   628,     0,   630,     0,   278,   632,   633,
-     281,   634,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,   637,   291,   638,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   640,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   641,   642,   643,   325,   326,   327,
-     644,     0,   329,   330,   646,   332,     0,   648,   334,   649,
-     336,   337,   338,     0,   339,   340,  1366,     0,   341,   342,
-     343,     0,     0,   344,   345,   655,   656,   348,   657,   658,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,   663,   664,   366,
-     367,   665,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   668,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-     671,   404,   405,   406,   672,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,   674,
-     421,   422,   423,   424,   425,   426,   675,   428,   429,     0,
-     677,   431,   432,   678,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   680,   448,
-     681,     0,     0,   450,   451,     0,   452,   685,   454,   455,
-     456,   457,   458,     0,   459,   687,   688,     0,     0,   462,
-     463,   691,   465,   692,  1367,   467,   468,   694,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   699,
-     700,   489,     0,   490,   702,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   707,   708,   709,   710,   711,   712,   713,
-     714,   715,   716,   717,   517,   518,   519,   520,   974,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,     0,   126,   127,   128,     3,
-       4,     0,   565,     0,     0,     0,     0,   570,   130,   131,
-       0,   132,   133,   134,   572,   136,   137,   138,   573,   574,
-     575,   576,   577,     0,   144,   145,   146,   147,   148,   149,
-       0,     0,   150,   151,   152,   153,   581,   582,   156,     0,
-     157,   158,   159,   160,   584,     0,   586,     0,   588,   164,
-     165,   166,   167,   168,   589,   170,   171,   172,     0,   173,
-     174,   175,   176,   177,   178,     0,   592,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   594,   191,   192,
-     595,   194,     0,   195,     0,   196,   197,   198,   199,   200,
-     201,     0,     0,   202,   203,   204,   205,     0,     0,   206,
-     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
-     215,   216,     0,   217,   218,   219,   220,   605,   222,   223,
-     224,   225,   226,   227,   606,     0,   229,     0,   230,   231,
-     609,   233,     0,   234,     0,   235,   612,     0,   614,   238,
-     239,   615,   616,   242,     0,   243,     0,   619,   620,   246,
-     247,     0,   248,   249,   250,   251,   252,   253,   254,   622,
-     256,   257,   258,   259,     0,   260,   261,   262,   263,   264,
-     265,   266,     0,   267,   625,   626,   270,   271,   272,   273,
-     274,   627,   628,     0,   630,     0,   278,   632,   633,   281,
-     634,   283,   284,   285,   286,   287,   288,     0,     0,   289,
-     637,   291,   638,     0,   293,   294,   295,   296,   297,   298,
-     299,   300,   640,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   641,   642,   643,   325,   326,   327,   644,
-       0,   329,   330,   646,   332,     0,   648,   334,   649,   336,
-     337,   338,     0,   339,   340,     0,     0,   341,   342,   343,
-       0,     0,   344,   345,   655,   656,   348,   657,   658,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-       0,     0,     0,     0,   362,   363,   663,   664,   366,   367,
-     665,   369,   370,   371,     0,   372,   373,   374,   375,   376,
-     377,     0,   378,   379,   380,   381,   382,   668,   384,   385,
-     386,   387,     0,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,     0,   401,   402,   671,
-     404,   405,   406,   672,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,     0,   674,   421,
-     422,   423,   424,   425,   426,   675,   428,   429,     0,   677,
-     431,   432,   678,   434,     0,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   680,   448,   681,
-       0,     0,   450,   451,     0,   452,   685,   454,   455,   456,
-     457,   458,     0,   459,   687,   688,     0,     0,   462,   463,
-     691,   465,   692,     0,   467,   468,   694,   470,   471,   472,
-     473,   474,     0,     0,   475,   476,   477,     0,   478,   479,
-     480,   481,     0,   482,   483,   484,   485,   486,   699,   700,
-     489,     0,   490,   702,   492,   493,   494,   495,   496,   497,
-     498,     0,     0,   499,     0,     0,   500,   501,   502,   503,
-     504,   505,   707,   708,   709,   710,   711,   712,   713,   714,
-     715,   716,   717,   517,   518,   519,   520,   117,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,     0,     0,     0,   129,   130,   131,     0,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,     0,   144,   145,   146,   147,   148,   149,     0,
-     790,   150,   151,   152,   153,   154,   155,   156,     0,   157,
-     158,   159,   160,   791,     0,   792,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-     208,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   793,     0,   229,     0,   230,   231,   232,
-     233,     0,   234,     0,   235,   236,     0,   237,   238,   239,
-     240,   241,   242,     0,   243,     0,   244,   245,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,     0,   277,     0,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,   290,
-     291,   292,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,     0,
-     329,   330,   331,   332,     0,   795,   334,   335,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,   347,   348,   349,   797,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   798,   365,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,   430,   431,
-     432,   433,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   800,     0,
-       0,   450,   451,     0,   452,   453,   454,   455,   456,   457,
-     458,     0,   459,   460,   461,     0,     0,   462,   463,   801,
-     465,   802,     0,   467,   468,   803,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,   488,   489,
-       0,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   117,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,   126,   127,   128,     0,     0,     0,
-       0,     0,     0,     0,     0,   129,   130,   131,     0,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,     0,   144,   145,   146,   147,   148,   149,     0,     0,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-     159,   160,   161,     0,   162,     0,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,     0,   173,   174,   175,
-     176,   177,   178,     0,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,     0,   196,   197,   198,   199,   200,   201,     0,
-       0,   202,   203,   204,   205,     0,     0,   206,   207,   208,
-     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
-       0,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,     0,   229,     0,   230,   231,   232,   233,
-       0,   234,     0,   235,   236,     0,   237,   238,   239,   240,
-     241,   242,     0,   243,     0,   244,   245,   246,   247,     0,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,     0,   260,   261,   262,   263,   264,   265,   266,
-       0,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,     0,   277,     0,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,     0,     0,   289,   290,   291,
-     292,     0,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,     0,   329,
-     330,   331,   332,     0,   333,   334,   335,   336,   337,   338,
-       0,   339,   340,     0,     0,   341,   342,   343,     0,     0,
-     344,   345,   346,   347,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,     0,     0,
-       0,     0,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,     0,   372,   373,   374,   375,   376,   377,     0,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-       0,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,     0,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,     0,     0,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,     0,   430,   431,   432,
-     433,   434,     0,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   447,   448,   449,     0,     0,
-     450,   451,     0,   452,   453,   454,   455,   456,   457,   458,
-       0,   459,   460,   461,     0,     0,   462,   463,   464,   465,
-     466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
-       0,     0,   475,   476,   477,     0,   478,   479,   480,   481,
-       0,   482,   483,   484,   485,   486,   487,   488,   489,     0,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,     0,
-       0,   499,     0,     0,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
-     516,   517,   518,   519,   520,   528,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,  1770,   157,   158,   159,
-     160,   161,     0,     0,  1771,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,  1772,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,     0,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,     0,   230,   231,   232,   233,     0,
-     234,  1773,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,  1774,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-       0,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,  1775,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
-    1776,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   528,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,     0,   126,   127,   128,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   130,   131,     0,   132,   133,   134,
-       0,   136,   137,   138,   139,   140,     0,   142,   143,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   154,   155,   156,  1770,   157,   158,   159,   160,
-     161,     0,     0,     0,   163,   164,   165,   166,   167,   168,
-       0,   170,   171,   172,  1772,   173,   174,   175,   176,   177,
-     178,     0,     0,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,     0,   229,     0,   230,   231,   232,   233,     0,   234,
-    1773,   235,     0,     0,     0,   238,   239,   529,     0,   242,
-       0,   243,     0,   244,   245,   246,   247,     0,   248,   249,
-     250,   251,   252,   253,   254,     0,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-       0,   269,   270,   271,   272,   273,   274,   275,   276,     0,
-     277,     0,   278,     0,     0,   281,     0,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,     0,   291,  2372,     0,
-     293,   294,   295,   296,   297,   298,   299,   300,   530,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-       0,   324,   325,   326,   327,   328,     0,   329,   330,     0,
-     332,     0,   333,   334,   335,   336,   337,   338,     0,   339,
-     340,     0,     0,   341,   342,   343,     0,     0,   344,   345,
-     346,     0,   348,     0,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   364,     0,   366,   367,   368,   369,   370,   371,
-    1775,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,     0,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,     0,   421,   422,   423,   424,   425,
-     426,   427,   428,   429,     0,     0,   431,   432,   433,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   531,   448,   449,     0,     0,   450,   451,
-       0,   452,     0,   454,   455,   456,   457,   458,     0,   459,
-     460,   461,     0,     0,   462,   463,   464,   465,   466,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,  1776,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   487,   488,   489,     0,   490,     0,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   528,     0,   554,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     3,     4,     0,     0,     0,     0,
-       0,     0,     0,   130,   131,     0,   132,   133,   134,     0,
-     136,   137,   138,   139,   140,     0,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   161,
-       0,     0,     0,   163,   164,   165,   166,   167,   168,     0,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,     0,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,     0,     0,     0,   238,   239,   529,     0,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,     0,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,     0,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,     0,     0,   281,     0,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,     0,   291,     0,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   530,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,     0,
-     324,   325,   326,   327,   328,     0,   329,   330,     0,   332,
-       0,   333,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   346,
-       0,   348,     0,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   364,     0,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,     0,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,     0,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   531,   448,   449,     0,     0,   450,   451,     0,
-     452,     0,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   464,   465,   466,     0,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   487,   488,   489,     0,   490,     0,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,   528,     0,   554,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,   555,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   130,   131,     0,   132,   133,   134,     0,   136,
-     137,   138,   139,   140,     0,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   161,     0,
-       0,     0,   163,   164,   165,   166,   167,   168,     0,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-       0,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-       0,     0,     0,   238,   239,   529,     0,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,     0,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,     0,     0,   281,     0,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,     0,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   530,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,     0,   324,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,     0,
-     333,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,     0,
-     348,     0,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     364,     0,   366,   367,   368,   556,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,     0,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   531,   448,   449,     0,     0,   450,   451,     0,   452,
-       0,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   464,   465,   466,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,     0,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   528,     0,   554,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   130,   131,     0,   132,   133,   134,     0,   136,   137,
-     138,   139,   140,     0,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   161,     0,     0,
-       0,   163,   164,   165,   166,   167,   168,     0,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,     0,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,     0,
-       0,     0,   238,   239,   529,     0,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,     0,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,     0,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-       0,     0,   281,     0,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,     0,   291,     0,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   530,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,     0,   324,   325,
-     326,   327,   328,     0,   329,   330,     0,   332,     0,   333,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,   796,
-     341,   342,   343,     0,     0,   344,   345,   346,     0,   348,
-       0,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   364,
-       0,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,     0,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,     0,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     531,   448,   449,     0,     0,   450,   451,     0,   452,     0,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   464,   465,   466,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,     0,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     528,     0,   554,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     130,   131,     0,   132,   133,   134,     0,   136,   137,   138,
-     139,   140,     0,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,     0,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   161,     0,     0,     0,
-     163,   164,   165,   166,   167,   168,     0,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,     0,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,     0,     0,
-       0,   238,   239,   529,     0,   242,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,   904,
-     254,     0,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,     0,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,     0,
-       0,   281,     0,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,     0,   291,     0,     0,   293,   294,   295,   296,
-     297,   298,   299,   300,   530,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,     0,   324,   325,   326,
-     327,   328,     0,   329,   330,     0,   332,     0,   333,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,   796,   341,
-     342,   343,     0,     0,   344,   345,   346,     0,   348,     0,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   364,     0,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,     0,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-       0,     0,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   531,
-     448,   449,     0,     0,   450,   451,     0,   452,     0,   454,
-     455,   456,   457,   458,     0,   459,   460,   461,     0,     0,
-     462,   463,   464,   465,   466,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   489,     0,   490,     0,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,   528,
-       0,   554,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,   948,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,     0,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,     0,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   487,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,   528,     0,
-     554,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,     0,   126,   127,   128,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   130,   131,
-       0,   132,   133,   134,     0,   136,   137,   138,   139,   140,
-       0,   142,   143,     0,   144,   145,   146,   147,   148,   149,
-       0,     0,   150,   151,   152,   153,   154,   155,   156,     0,
-     157,   158,   159,   160,   161,     0,     0,     0,   163,   164,
-     165,   166,   167,   168,     0,   170,   171,   172,     0,   173,
-     174,   175,   176,   177,   178,     0,     0,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,     0,   196,   197,   198,   199,   200,
-     201,     0,     0,   202,   203,   204,   205,     0,     0,   206,
-     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
-     215,   216,     0,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,  1184,   227,   228,     0,   229,     0,   230,   231,
-     232,   233,     0,   234,     0,   235,     0,     0,     0,   238,
-     239,   529,     0,   242,     0,   243,     0,   244,   245,   246,
-     247,     0,   248,   249,   250,   251,   252,   253,   254,     0,
-     256,   257,   258,   259,     0,   260,   261,   262,   263,   264,
-     265,   266,     0,   267,     0,   269,   270,   271,   272,   273,
-     274,   275,   276,     0,   277,     0,   278,     0,     0,   281,
-       0,   283,   284,   285,   286,   287,   288,     0,     0,   289,
-       0,   291,     0,     0,   293,   294,   295,   296,   297,   298,
-     299,   300,   530,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,     0,   324,   325,   326,   327,   328,
-       0,   329,   330,     0,   332,     0,   333,   334,   335,   336,
-     337,   338,     0,   339,   340,     0,   796,   341,   342,   343,
-       0,     0,   344,   345,   346,     0,   348,     0,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-       0,     0,     0,     0,   362,   363,   364,     0,   366,   367,
-     368,   369,   370,   371,     0,   372,   373,   374,   375,   376,
-     377,     0,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,   387,     0,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,     0,   401,   402,     0,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,     0,     0,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,     0,     0,
-     431,   432,   433,   434,     0,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   531,   448,   449,
-       0,     0,   450,   451,     0,   452,     0,   454,   455,   456,
-     457,   458,     0,   459,   460,   461,     0,     0,   462,   463,
-     464,   465,   466,     0,   467,   468,   469,   470,   471,   472,
-     473,   474,     0,     0,   475,   476,   477,     0,   478,   479,
-     480,   481,     0,   482,   483,   484,   485,   486,   487,   488,
-     489,     0,   490,     0,   492,   493,   494,   495,   496,   497,
-     498,     0,     0,   499,     0,     0,   500,   501,   502,   503,
-     504,   505,   506,   507,   508,   509,   510,   511,   512,   513,
-     514,   515,   516,   517,   518,   519,   520,   528,     0,   554,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   130,   131,     0,
-     132,   133,   134,     0,   136,   137,   138,   139,   140,     0,
-     142,   143,     0,   144,   145,   146,   147,   148,   149,     0,
-       0,   150,   151,   152,   153,   154,   155,   156,     0,   157,
-     158,   159,   160,   161,     0,     0,     0,   163,   164,   165,
-     166,   167,   168,     0,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,     0,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-     208,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,     0,   229,     0,   230,   231,   232,
-     233,     0,   234,     0,   235,     0,     0,     0,   238,   239,
-     529,     0,  1992,     0,   243,     0,   244,   245,   246,   247,
-       0,   248,   249,   250,   251,   252,   253,   254,     0,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,     0,   269,   270,   271,   272,   273,   274,
-     275,   276,     0,   277,     0,   278,     0,     0,   281,     0,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,     0,
-     291,     0,     0,   293,   294,  1993,   296,   297,   298,   299,
-     300,   530,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,     0,   324,   325,   326,   327,   328,     0,
-     329,   330,     0,   332,     0,   333,   334,   335,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,     0,   348,     0,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   364,     0,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,     0,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,     0,   431,
-     432,   433,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   531,   448,   449,     0,
-       0,   450,   451,  1994,   452,     0,   454,  1995,   456,  1996,
-     458,     0,   459,   460,   461,     0,     0,   462,   463,   464,
-     465,   466,     0,   467,   468,   469,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,  1997,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,   488,   489,
-       0,   490,     0,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   528,     0,   554,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,   126,   127,   128,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   130,   131,     0,   132,
-     133,   134,     0,   136,   137,   138,   139,   140,     0,   142,
-     143,     0,   144,   145,   146,   147,   148,   149,     0,     0,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-     159,   160,   161,     0,     0,     0,   163,   164,   165,   166,
-     167,   168,     0,   170,   171,   172,     0,   173,   174,   175,
-     176,   177,   178,     0,     0,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,     0,   196,   197,   198,   199,   200,   201,     0,
-       0,   202,   203,   204,   205,     0,     0,   206,   207,   208,
-     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
-       0,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,     0,   229,     0,   230,   231,   232,   233,
-       0,   234,     0,   235,     0,     0,     0,   238,   239,   529,
-       0,   242,     0,   243,     0,   244,   245,   246,   247,     0,
-     248,   249,   250,   251,   252,   253,   254,     0,   256,   257,
-     258,   259,     0,   260,   261,   262,   263,   264,   265,   266,
-       0,   267,     0,   269,   270,   271,   272,   273,   274,   275,
-     276,     0,   277,     0,   278,     0,     0,   281,     0,   283,
-     284,   285,   286,   287,   288,     0,     0,   289,     0,   291,
-       0,     0,   293,   294,   295,   296,   297,   298,   299,   300,
-     530,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,     0,   324,   325,   326,   327,   328,     0,   329,
-     330,     0,   332,     0,   333,   334,   335,   336,   337,   338,
-       0,   339,   340,     0,     0,   341,   342,   343,     0,     0,
-     344,   345,   346,     0,   348,     0,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,     0,     0,
-       0,     0,   362,   363,   364,     0,   366,   367,   368,   369,
-     370,   371,     0,   372,   373,   374,   375,   376,   377,     0,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-       0,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,     0,   401,   402,     0,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,     0,     0,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,     0,     0,   431,   432,
-     433,   434,     0,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   531,   448,   449,     0,     0,
-     450,   451,     0,   452,     0,   454,   455,   456,   457,   458,
-       0,   459,   460,   461,     0,     0,   462,   463,   464,   465,
-     466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
-       0,     0,   475,   476,   477,     0,   478,   479,   480,   481,
-       0,   482,   483,   484,   485,   486,   487,   488,   489,     0,
-     490,     0,   492,   493,   494,   495,   496,   497,   498,     0,
-       0,   499,     0,     0,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
-     516,   517,   518,   519,   520,   528,     0,   821,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,   159,
-     160,   161,     0,     0,     0,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,     0,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,     0,   230,   231,   232,   233,     0,
-     234,     0,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-       0,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   528,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,   827,   126,   127,   128,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   130,   131,     0,   132,   133,   134,
-       0,   136,   137,   138,   139,   140,     0,   142,   143,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,   159,   160,
-     161,     0,     0,     0,   163,   164,   165,   166,   167,   168,
-       0,   170,   171,   172,     0,   173,   174,   175,   176,   177,
-     178,     0,     0,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,     0,   229,     0,   230,   231,   232,   233,     0,   234,
-       0,   235,     0,     0,     0,   238,   239,   529,     0,   828,
-       0,   243,     0,   244,   245,   246,   247,     0,   248,   249,
-     250,   251,   252,   253,   254,     0,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-       0,   269,   270,   271,   272,   273,   274,   275,   276,     0,
-     277,     0,   278,     0,     0,   281,     0,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,     0,   291,     0,     0,
-     293,   294,   829,   296,   297,   298,   299,   300,   530,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-       0,   324,   325,   326,   327,   328,     0,   329,   330,     0,
-     332,     0,   333,   334,   335,   336,   337,   338,     0,   339,
-     340,     0,     0,   341,   342,   343,     0,     0,   344,   345,
-     346,     0,   348,     0,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   364,     0,   366,   367,   368,   369,   370,   371,
-       0,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,     0,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,     0,   421,   422,   423,   424,   830,
-     426,   427,   428,   429,     0,     0,   431,   432,   433,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   531,   448,   449,     0,     0,   450,   451,
-       0,   452,     0,   454,   455,   456,   457,   458,     0,   459,
-     831,   461,     0,     0,   832,   463,   464,   465,   466,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,     0,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   487,   488,   833,     0,   490,     0,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   528,     0,   554,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   130,   131,     0,   132,   133,   134,     0,
-     136,   137,   138,   139,   140,     0,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   161,
-       0,     0,     0,   163,   164,   165,   166,   167,   168,     0,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,     0,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,     0,     0,     0,   238,   239,   529,     0,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,     0,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,     0,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,     0,     0,   281,     0,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,     0,   291,     0,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   530,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,     0,
-     324,   325,   326,   327,   328,     0,   329,   330,     0,   332,
-       0,   333,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   346,
-       0,   348,     0,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   364,     0,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   866,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,     0,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,     0,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   531,   448,   449,     0,     0,   450,   451,     0,
-     452,     0,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   464,   465,   466,     0,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   487,   488,   489,     0,   490,     0,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,   528,     0,   554,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   130,   131,     0,   132,   133,   134,     0,   136,
-     137,   138,   139,   140,     0,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   161,     0,
-       0,     0,   163,   164,   165,   166,   167,   168,     0,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-       0,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-       0,     0,     0,   238,   239,   529,     0,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,   899,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,     0,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,     0,     0,   281,     0,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,     0,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   530,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,     0,   324,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,     0,
-     333,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,     0,
-     348,     0,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     364,     0,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,     0,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   531,   448,   449,     0,     0,   450,   451,     0,   452,
-       0,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   464,   465,   466,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,     0,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   528,     0,   554,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   130,   131,     0,   132,   133,   134,     0,   136,   137,
-     138,   139,   140,     0,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   161,     0,     0,
-       0,   163,   164,   165,   166,   167,   168,     0,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,     0,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,     0,
-       0,     0,   238,   239,   529,     0,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     902,   254,     0,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,     0,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-       0,     0,   281,     0,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,     0,   291,     0,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   530,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,     0,   324,   325,
-     326,   327,   328,     0,   329,   330,     0,   332,     0,   333,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,     0,   348,
-       0,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   364,
-       0,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,     0,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,     0,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     531,   448,   449,     0,     0,   450,   451,     0,   452,     0,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   464,   465,   466,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,     0,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     528,     0,   554,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     130,   131,     0,   132,   133,   134,     0,   136,   137,   138,
-     139,   140,     0,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,     0,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   161,     0,     0,     0,
-     163,   164,   165,   166,   167,   168,     0,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,     0,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,     0,     0,
-       0,   238,   239,   529,     0,   242,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,   906,
-     254,     0,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,     0,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,     0,
-       0,   281,     0,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,     0,   291,     0,     0,   293,   294,   295,   296,
-     297,   298,   299,   300,   530,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,     0,   324,   325,   326,
-     327,   328,     0,   329,   330,     0,   332,     0,   333,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,     0,   341,
-     342,   343,     0,     0,   344,   345,   346,     0,   348,     0,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   364,     0,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,     0,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-       0,     0,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   531,
-     448,   449,     0,     0,   450,   451,     0,   452,     0,   454,
-     455,   456,   457,   458,     0,   459,   460,   461,     0,     0,
-     462,   463,   464,   465,   466,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   489,     0,   490,     0,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,   528,
-       0,   554,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,     0,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   936,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,     0,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   487,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,   528,     0,
-     554,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,     0,   126,   127,   128,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   130,   131,
-       0,   132,   133,   134,     0,   136,   137,   138,   139,   140,
-       0,   142,   143,     0,   144,   145,   146,   147,   148,   149,
-       0,     0,   150,   151,   152,   153,   154,   155,   156,     0,
-     157,   158,   159,   160,   161,     0,     0,     0,   163,   164,
-     165,   166,   167,   168,     0,   170,   171,   172,     0,   173,
-     174,   175,   176,   177,   178,     0,     0,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,     0,   196,   197,   198,   199,   200,
-     201,     0,     0,   202,   203,   204,   205,     0,     0,   206,
-     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
-     215,   216,     0,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,   228,     0,   229,     0,   230,   231,
-     232,   233,     0,   234,     0,   235,     0,     0,     0,   238,
-     239,   529,     0,   242,     0,   243,     0,   244,   245,   246,
-     247,     0,   248,   249,   250,   251,   252,   964,   254,     0,
-     256,   257,   258,   259,     0,   260,   261,   262,   263,   264,
-     265,   266,     0,   267,     0,   269,   270,   271,   272,   273,
-     274,   275,   276,     0,   277,     0,   278,     0,     0,   281,
-       0,   283,   284,   285,   286,   287,   288,     0,     0,   289,
-       0,   291,     0,     0,   293,   294,   295,   296,   297,   298,
-     299,   300,   530,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,     0,   324,   325,   326,   327,   328,
-       0,   329,   330,     0,   332,     0,   333,   334,   335,   336,
-     337,   338,     0,   339,   340,     0,     0,   341,   342,   343,
-       0,     0,   344,   345,   346,     0,   348,     0,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-       0,     0,     0,     0,   362,   363,   364,     0,   366,   367,
-     368,   369,   370,   371,     0,   372,   373,   374,   375,   376,
-     377,     0,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,   387,     0,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,     0,   401,   402,     0,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,     0,     0,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,     0,     0,
-     431,   432,   433,   434,     0,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   531,   448,   449,
-       0,     0,   450,   451,     0,   452,     0,   454,   455,   456,
-     457,   458,     0,   459,   460,   461,     0,     0,   462,   463,
-     464,   465,   466,     0,   467,   468,   469,   470,   471,   472,
-     473,   474,     0,     0,   475,   476,   477,     0,   478,   479,
-     480,   481,     0,   482,   483,   484,   485,   486,   487,   488,
-     489,     0,   490,     0,   492,   493,   494,   495,   496,   497,
-     498,     0,     0,   499,     0,     0,   500,   501,   502,   503,
-     504,   505,   506,   507,   508,   509,   510,   511,   512,   513,
-     514,   515,   516,   517,   518,   519,   520,   528,     0,   554,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   130,   131,     0,
-     132,   133,   134,     0,   136,   137,   138,   139,   140,     0,
-     142,   143,     0,   144,   145,   146,   147,   148,   149,     0,
-       0,   150,   151,   152,   153,   154,   155,   156,     0,   157,
-     158,   159,   160,   161,     0,     0,     0,   163,   164,   165,
-     166,   167,   168,     0,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,     0,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-     208,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,     0,   229,     0,   230,   231,   232,
-     233,     0,   234,     0,   235,     0,     0,     0,   238,   239,
-     529,     0,   242,     0,   243,     0,   244,   245,   246,   247,
-       0,   248,   249,   250,   251,   252,   967,   254,     0,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,     0,   269,   270,   271,   272,   273,   274,
-     275,   276,     0,   277,     0,   278,     0,     0,   281,     0,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,     0,
-     291,     0,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,   530,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,     0,   324,   325,   326,   327,   328,     0,
-     329,   330,     0,   332,     0,   333,   334,   335,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,     0,   348,     0,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   364,     0,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,     0,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,     0,   431,
-     432,   433,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   531,   448,   449,     0,
-       0,   450,   451,     0,   452,     0,   454,   455,   456,   457,
-     458,     0,   459,   460,   461,     0,     0,   462,   463,   464,
-     465,   466,     0,   467,   468,   469,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,   488,   489,
-       0,   490,     0,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   528,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,   126,   127,   128,     0,     0,     0,
-       0,     0,     0,  1010,     0,     0,   130,   131,     0,   132,
-     133,   134,     0,   136,   137,   138,   139,   140,     0,   142,
-     143,     0,   144,   145,   146,   147,   148,   149,     0,     0,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-     159,   160,   161,     0,     0,     0,   163,   164,   165,   166,
-     167,   168,     0,   170,   171,   172,     0,   173,   174,   175,
-     176,   177,   178,     0,     0,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,     0,   196,   197,   198,   199,   200,   201,     0,
-       0,   202,   203,   204,   205,     0,     0,   206,   207,   208,
-     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
-       0,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,     0,   229,     0,   230,   231,   232,   233,
-       0,   234,     0,   235,     0,     0,     0,   238,   239,   529,
-       0,   242,     0,   243,     0,   244,   245,   246,   247,     0,
-     248,   249,   250,   251,   252,   253,   254,     0,   256,   257,
-     258,   259,     0,   260,   261,   262,   263,   264,   265,   266,
-       0,   267,     0,   269,   270,   271,   272,   273,   274,   275,
-     276,     0,   277,     0,   278,     0,     0,   281,     0,   283,
-     284,   285,   286,   287,   288,     0,     0,   289,     0,   291,
-       0,     0,   293,   294,   295,   296,   297,   298,   299,   300,
-     530,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,     0,   324,   325,   326,   327,   328,     0,   329,
-     330,     0,   332,     0,   333,   334,   335,   336,   337,   338,
-       0,   339,   340,     0,     0,   341,   342,   343,     0,     0,
-     344,   345,   346,     0,   348,     0,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,     0,     0,
-       0,     0,   362,   363,   364,     0,   366,   367,   368,   369,
-     370,   371,     0,   372,   373,   374,   375,   376,   377,     0,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-       0,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,     0,   401,   402,     0,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,     0,     0,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,     0,     0,   431,   432,
-     433,   434,     0,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   531,   448,   449,     0,     0,
-     450,   451,     0,   452,     0,   454,   455,   456,   457,   458,
-       0,   459,   460,   461,     0,     0,   462,   463,   464,   465,
-     466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
-       0,     0,   475,   476,   477,     0,   478,   479,   480,   481,
-       0,   482,   483,   484,   485,   486,   487,   488,   489,     0,
-     490,     0,   492,   493,   494,   495,   496,   497,   498,     0,
-       0,   499,     0,     0,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
-     516,   517,   518,   519,   520,   528,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,  1037,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,   159,
-     160,   161,     0,     0,     0,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,     0,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,     0,   230,   231,   232,   233,     0,
-     234,     0,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-       0,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   528,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,   827,   126,   127,   128,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   130,   131,     0,   132,   133,   134,
-       0,   136,   137,   138,   139,   140,     0,   142,   143,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,   159,   160,
-     161,     0,     0,     0,   163,   164,   165,   166,   167,   168,
-       0,   170,   171,   172,     0,   173,   174,   175,   176,   177,
-     178,     0,     0,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,     0,   229,     0,   230,   231,   232,   233,     0,   234,
-       0,   235,     0,     0,     0,   238,   239,   529,     0,   242,
-       0,   243,     0,   244,   245,   246,   247,     0,   248,   249,
-     250,   251,   252,   253,   254,     0,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-       0,   269,   270,   271,   272,   273,   274,   275,   276,     0,
-     277,     0,   278,     0,     0,   281,     0,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,     0,   291,     0,     0,
-     293,   294,   295,   296,   297,   298,   299,   300,   530,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-       0,   324,   325,   326,   327,   328,     0,   329,   330,     0,
-     332,     0,   333,   334,   335,   336,   337,   338,     0,   339,
-     340,     0,     0,   341,   342,   343,     0,     0,   344,   345,
-     346,     0,   348,     0,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   364,     0,   366,   367,   368,   369,   370,   371,
-       0,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,     0,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,     0,   421,   422,   423,   424,   425,
-     426,   427,   428,   429,     0,     0,   431,   432,   433,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   531,   448,   449,     0,     0,   450,   451,
-       0,   452,     0,   454,   455,   456,   457,   458,     0,   459,
-     831,   461,     0,     0,   832,   463,   464,   465,   466,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,     0,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   487,   488,   489,     0,   490,     0,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   528,     0,   554,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   130,   131,     0,   132,   133,   134,     0,
-     136,   137,   138,   139,   140,     0,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   161,
-       0,     0,     0,   163,   164,   165,   166,   167,   168,     0,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,     0,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,     0,     0,     0,   238,   239,   529,     0,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,  1326,   254,     0,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,     0,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,     0,     0,   281,     0,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,     0,   291,     0,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   530,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,     0,
-     324,   325,   326,   327,   328,     0,   329,   330,     0,   332,
-       0,   333,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   346,
-       0,   348,     0,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   364,     0,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,     0,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,     0,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   531,   448,   449,     0,     0,   450,   451,     0,
-     452,     0,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   464,   465,   466,     0,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   487,   488,   489,     0,   490,     0,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,   528,     0,   554,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   130,   131,     0,   132,   133,   134,     0,   136,
-     137,   138,   139,   140,     0,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   161,     0,
-       0,     0,   163,   164,   165,   166,   167,   168,     0,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-       0,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-       0,     0,     0,   238,   239,   529,     0,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,  1328,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,     0,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,     0,     0,   281,     0,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,     0,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   530,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,     0,   324,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,     0,
-     333,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,     0,
-     348,     0,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     364,     0,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,     0,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   531,   448,   449,     0,     0,   450,   451,     0,   452,
-       0,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   464,   465,   466,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,     0,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   528,     0,   554,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   130,   131,     0,   132,   133,   134,     0,   136,   137,
-     138,   139,   140,     0,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   161,     0,     0,
-       0,   163,   164,   165,   166,   167,   168,     0,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,     0,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,     0,
-       0,     0,   238,   239,   529,     0,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-    1331,   254,     0,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,     0,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-       0,     0,   281,     0,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,     0,   291,     0,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   530,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,     0,   324,   325,
-     326,   327,   328,     0,   329,   330,     0,   332,     0,   333,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,     0,   348,
-       0,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   364,
-       0,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,     0,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,     0,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     531,   448,   449,     0,     0,   450,   451,     0,   452,     0,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   464,   465,   466,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,     0,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     528,     0,   554,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     130,   131,     0,   132,   133,   134,     0,   136,   137,   138,
-     139,   140,     0,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,     0,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   161,     0,     0,     0,
-     163,   164,   165,   166,   167,   168,     0,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,     0,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,     0,     0,
-       0,   238,   239,   529,     0,   242,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,  1333,
-     254,     0,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,     0,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,     0,
-       0,   281,     0,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,     0,   291,     0,     0,   293,   294,   295,   296,
-     297,   298,   299,   300,   530,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,     0,   324,   325,   326,
-     327,   328,     0,   329,   330,     0,   332,     0,   333,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,     0,   341,
-     342,   343,     0,     0,   344,   345,   346,     0,   348,     0,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   364,     0,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,     0,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-       0,     0,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   531,
-     448,   449,     0,     0,   450,   451,     0,   452,     0,   454,
-     455,   456,   457,   458,     0,   459,   460,   461,     0,     0,
-     462,   463,   464,   465,   466,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   489,     0,   490,     0,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,   528,
-       0,   554,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,     0,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,  2282,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,     0,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   487,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,  1502,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,     0,   126,   127,   128,     0,
-       0,     0,  1503,     0,     0,  -808,     0,  1504,   130,   131,
-       0,   132,   133,   134,  1505,   136,   137,   138,     0,  1506,
-    1507,  1508,  1509,     0,   144,   145,   146,   147,   148,   149,
-       0,     0,   150,   151,   152,   153,  1510,  1511,   156,     0,
-     157,   158,   159,   160,     0,     0,  1512,     0,  1513,   164,
-     165,   166,   167,   168,  1514,   170,   171,   172,     0,   173,
-     174,   175,   176,   177,   178,     0,  1515,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,  1516,   191,   192,
-    1517,   194,     0,   195,     0,   196,   197,   198,   199,   200,
-     201,     0,     0,   202,   203,   204,   205,     0,     0,   206,
-     207,  1073,   209,   210,     0,   211,   212,   213,     0,   214,
-     215,   216,     0,   217,   218,   219,   220,     0,   222,   223,
-     224,   225,   226,   227,     0,     0,   229,     0,   230,   231,
-    1518,   233,     0,   234,     0,   235,  1519,     0,  1520,   238,
-     239,  -808,  1521,   242,     0,   243,     0,     0,     0,   246,
-     247,     0,   248,   249,   250,   251,   252,   253,   254,  1522,
-     256,   257,   258,   259,     0,   260,   261,   262,   263,   264,
-     265,   266,     0,   267,  1523,     0,   270,   271,   272,   273,
-     274,  1524,  1525,     0,  1526,     0,   278,  1527,  1528,   281,
-    1529,   283,   284,   285,   286,   287,   288,     0,     0,   289,
-    1530,   291,  1531,     0,   293,   294,   295,   296,   297,   298,
-     299,   300,  1532,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,  1533,  1534,  1535,   325,   326,   327,     0,
-       0,   329,   330,  1536,   332,     0,     0,   334,  1537,   336,
-     337,   338,     0,   339,   340,     0,     0,   341,   342,   343,
-       0,     0,   344,   345,     0,  1538,   348,  1539,     0,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-       0,     0,     0,     0,   362,   363,     0,  1540,   366,   367,
-       0,   369,   370,   371,     0,   372,   373,   374,   375,   376,
-     377,     0,   378,   379,   380,   381,   382,  1541,   384,   385,
-     386,   387,     0,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,     0,   401,   402,  1542,
-     404,   405,   406,  1543,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,     0,  1544,   421,
-     422,   423,   424,   425,   426,  1545,   428,   429,     0,  1546,
-     431,   432,  1547,   434,     0,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,  1548,   448,     0,
-       0,     0,   450,   451,     0,   452,  1549,   454,   455,   456,
-     457,   458,     0,   459,  1550,  1551,     0,     0,   462,   463,
-       0,   465,     0,     0,   467,   468,  1552,   470,   471,   472,
-     473,   474,  1553,     0,   475,   476,   477,     0,   478,   479,
-     480,   481,     0,   482,   483,   484,   485,   486,     0,  1554,
-     489,     0,   490,  1555,   492,   493,   494,   495,   496,   497,
-     498,     0,     0,   499,     0,     0,   500,   501,   502,   503,
-     504,   505,   528,     0,   554,     0,     0,     0,     0,     0,
-       0,     0,     0,   517,   518,   519,   520,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   130,   131,     0,   132,   133,   134,     0,   136,
-     137,   138,   139,   140,     0,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   161,     0,
-       0,     0,   163,   164,   165,   166,   167,   168,     0,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-       0,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-       0,     0,     0,   238,   239,   529,     0,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,  3051,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,     0,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,     0,     0,   281,     0,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,     0,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   530,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,     0,   324,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,     0,
-     333,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,     0,
-     348,     0,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     364,     0,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,     0,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   531,   448,   449,     0,     0,   450,   451,     0,   452,
-       0,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   464,   465,   466,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,     0,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,   528,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   130,   131,     0,   132,   133,   134,     0,   136,   137,
-     138,   139,   140,     0,   142,   143,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,   154,
-     155,   156,     0,   157,   158,   159,   160,   161,     0,     0,
-       0,   163,   164,   165,   166,   167,   168,     0,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,     0,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,   208,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,     0,   229,
-       0,   230,   231,   232,   233,     0,   234,     0,   235,     0,
-       0,     0,   238,   239,   529,     0,   242,     0,   243,     0,
-     244,   245,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,     0,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,     0,   269,   270,
-     271,   272,   273,   274,   275,   276,     0,   277,     0,   278,
-       0,     0,   281,     0,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,     0,   291,     0,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,   530,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,     0,   324,   325,
-     326,   327,   328,     0,   329,   330,     0,   332,     0,   333,
-     334,   335,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,   346,     0,   348,
-       0,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,   364,
-       0,   366,   367,   368,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,     0,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,     0,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,     0,     0,   431,   432,   433,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     531,   448,   449,     0,     0,   450,   451,     0,   452,     0,
-     454,   455,   456,   457,   458,     0,   459,   460,   461,     0,
-       0,   462,   463,   464,   465,   466,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,   487,   488,   489,     0,   490,     0,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     528,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-     119,   120,   121,   122,   123,   124,   125,     0,   126,   127,
-     128,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     130,   131,     0,   132,   133,   134,     0,   136,   137,   138,
-     139,   140,     0,   142,   143,     0,   144,   145,   146,   147,
-     148,   149,     0,     0,   150,   151,   152,   153,   154,   155,
-     156,     0,   157,   158,   159,   160,   161,     0,     0,     0,
-     163,   164,   165,   166,   167,   168,     0,   170,   171,   172,
-       0,   173,   174,   175,   176,   177,   178,     0,     0,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,     0,   196,   197,   198,
-     199,   200,   201,     0,     0,   202,   203,   204,   205,     0,
-       0,   206,   207,   208,   209,   210,     0,   211,   212,   213,
-       0,   214,   215,   216,     0,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,     0,   229,     0,
-     230,   231,   232,   233,     0,   234,     0,   235,     0,     0,
-       0,   238,   239,   529,     0,   843,     0,   243,     0,   244,
-     245,   246,   247,     0,   248,   249,   250,   251,   252,   253,
-     254,     0,   256,   257,   258,   259,     0,   260,   261,   262,
-     263,   264,   265,   266,     0,   267,     0,   269,   270,   271,
-     272,   273,   274,   275,   276,     0,   277,     0,   278,     0,
-       0,   281,     0,   283,   284,   285,   286,   287,   288,     0,
-       0,   289,     0,   291,     0,     0,   293,   294,   844,   296,
-     297,   298,   299,   300,   530,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,     0,   324,   325,   326,
-     327,   328,     0,   329,   330,     0,   332,     0,   333,   334,
-     335,   336,   337,   338,     0,   339,   340,     0,     0,   341,
-     342,   343,     0,     0,   344,   345,   346,     0,   348,     0,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,     0,     0,     0,     0,   362,   363,   364,     0,
-     366,   367,   368,   369,   370,   371,     0,   372,   373,   374,
-     375,   376,   377,     0,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,     0,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,     0,   401,
-     402,     0,   404,   405,   406,   407,   408,   409,   410,   411,
-     845,   413,   414,   415,   416,   417,   418,   419,   420,     0,
-       0,   421,   422,   423,   424,   846,   426,   427,   428,   429,
-       0,     0,   431,   432,   433,   434,     0,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   531,
-     448,   449,     0,     0,   450,   451,     0,   452,     0,   454,
-     455,   456,   457,   458,     0,   459,   847,   461,     0,     0,
-     462,   463,   464,   465,   466,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,   475,   476,   477,     0,
-     478,   479,   480,   481,     0,   482,   483,   484,   485,   486,
-     487,   488,   848,     0,   490,     0,   492,   493,   494,   495,
-     496,   497,   498,     0,     0,   499,     0,     0,   500,   501,
-     502,   503,   504,   505,   506,   507,   508,   509,   510,   511,
-     512,   513,   514,   515,   516,   517,   518,   519,   520,   528,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   130,
-     131,     0,   132,   133,   134,     0,   136,   137,   138,   139,
-     140,     0,   142,   143,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,   154,   155,   156,
-       0,   157,   158,   159,   160,   161,     0,     0,     0,   163,
-     164,   165,   166,   167,   168,     0,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,     0,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,   208,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,     0,   229,     0,   230,
-     231,   232,   233,     0,   234,     0,   235,     0,     0,     0,
-     238,   239,   529,     0,   242,     0,   243,     0,   244,   245,
-     246,   247,     0,   248,   249,   250,   251,   252,   960,   254,
-       0,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,     0,   269,   270,   271,   272,
-     273,   274,   275,   276,     0,   277,     0,   278,     0,     0,
-     281,     0,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,     0,   291,     0,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,   530,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,     0,   324,   325,   326,   327,
-     328,     0,   329,   330,     0,   332,     0,   333,   334,   335,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,   346,     0,   348,     0,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,   364,     0,   366,
-     367,   368,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-       0,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,     0,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,     0,
-       0,   431,   432,   433,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   531,   448,
-     449,     0,     0,   450,   451,     0,   452,     0,   454,   455,
-     456,   457,   458,     0,   459,   460,   461,     0,     0,   462,
-     463,   464,   465,   466,     0,   467,   468,   469,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,   487,
-     488,   489,     0,   490,     0,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
-     513,   514,   515,   516,   517,   518,   519,   520,   528,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,     0,   126,   127,   128,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   130,   131,
-       0,   132,   133,   134,     0,   136,   137,   138,   139,   140,
-       0,   142,   143,     0,   144,   145,   146,   147,   148,   149,
-       0,     0,   150,   151,   152,   153,   154,   155,   156,     0,
-     157,   158,   159,   160,   161,     0,     0,     0,   163,   164,
-     165,   166,   167,   168,     0,   170,   171,   172,     0,   173,
-     174,   175,   176,   177,   178,     0,     0,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,     0,   196,   197,   198,   199,   200,
-     201,     0,     0,   202,   203,   204,   205,     0,     0,   206,
-     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
-     215,   216,     0,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,   228,     0,   229,     0,   230,   231,
-     232,   233,     0,   234,     0,   235,     0,     0,     0,   238,
-     239,   529,     0,   242,     0,   243,     0,   244,   245,   246,
-     247,     0,   248,   249,   250,   251,   252,   253,   254,     0,
-     256,   257,   258,   259,     0,   260,   261,   262,   263,   264,
-     265,   266,     0,   267,     0,   269,   270,   271,   272,   273,
-     274,   275,   276,     0,   277,     0,   278,     0,     0,   281,
-       0,   283,   284,   285,   286,   287,   288,     0,     0,   289,
-       0,   291,     0,     0,   293,   294,   295,   296,   297,   298,
-     299,   300,   530,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,     0,   324,   325,   326,   327,   328,
-       0,   329,   330,     0,   332,     0,   333,   334,   335,   336,
-     337,   338,     0,   339,   340,     0,     0,   341,   342,   343,
-       0,     0,   344,   345,   346,     0,   348,     0,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-       0,     0,     0,     0,   362,   363,   364,     0,   366,   367,
-     368,   369,   370,   371,     0,   372,   373,   374,   375,   376,
-     377,     0,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,   387,     0,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,     0,   401,   402,     0,
-     404,   405,   406,   407,   408,   409,   410,   411,   845,   413,
-     414,   415,   416,   417,   418,   419,   420,     0,     0,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,     0,     0,
-     431,   432,   433,   434,     0,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   531,   448,   449,
-       0,     0,   450,   451,     0,   452,     0,   454,   455,   456,
-     457,   458,     0,   459,   847,   461,     0,     0,   462,   463,
-     464,   465,   466,     0,   467,   468,   469,   470,   471,   472,
-     473,   474,     0,     0,   475,   476,   477,     0,   478,   479,
-     480,   481,     0,   482,   483,   484,   485,   486,   487,   488,
-     489,     0,   490,     0,   492,   493,   494,   495,   496,   497,
-     498,     0,     0,   499,     0,     0,   500,   501,   502,   503,
-     504,   505,   506,   507,   508,   509,   510,   511,   512,   513,
-     514,   515,   516,   517,   518,   519,   520,   528,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   118,   119,   120,   121,
-     122,   123,   124,   125,     0,   126,   127,   128,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   130,   131,     0,
-     132,   133,   134,     0,   136,   137,   138,   139,   140,     0,
-     142,   143,     0,   144,   145,   146,   147,   148,   149,     0,
-       0,   150,   151,   152,   153,   154,   155,   156,     0,   157,
-     158,   159,   160,   161,     0,     0,     0,   163,   164,   165,
-     166,   167,   168,     0,   170,   171,   172,     0,   173,   174,
-     175,   176,   177,   178,     0,     0,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,     0,   195,     0,   196,   197,   198,   199,   200,   201,
-       0,     0,   202,   203,   204,   205,     0,     0,   206,   207,
-     208,   209,   210,     0,   211,   212,   213,     0,   214,   215,
-     216,     0,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,     0,   229,     0,   230,   231,   232,
-     233,     0,   234,     0,   235,     0,     0,     0,   238,   239,
-     529,     0,   242,     0,   243,     0,   244,   245,   246,   247,
-       0,   248,   249,   250,   251,   252,  1322,   254,     0,   256,
-     257,   258,   259,     0,   260,   261,   262,   263,   264,   265,
-     266,     0,   267,     0,   269,   270,   271,   272,   273,   274,
-     275,   276,     0,   277,     0,   278,     0,     0,   281,     0,
-     283,   284,   285,   286,   287,   288,     0,     0,   289,     0,
-     291,     0,     0,   293,   294,   295,   296,   297,   298,   299,
-     300,   530,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,     0,   324,   325,   326,   327,   328,     0,
-     329,   330,     0,   332,     0,   333,   334,   335,   336,   337,
-     338,     0,   339,   340,     0,     0,   341,   342,   343,     0,
-       0,   344,   345,   346,     0,   348,     0,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,     0,
-       0,     0,     0,   362,   363,   364,     0,   366,   367,   368,
-     369,   370,   371,     0,   372,   373,   374,   375,   376,   377,
-       0,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,     0,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,     0,   401,   402,     0,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,     0,     0,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,     0,     0,   431,
-     432,   433,   434,     0,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   531,   448,   449,     0,
-       0,   450,   451,     0,   452,     0,   454,   455,   456,   457,
-     458,     0,   459,   460,   461,     0,     0,   462,   463,   464,
-     465,   466,     0,   467,   468,   469,   470,   471,   472,   473,
-     474,     0,     0,   475,   476,   477,     0,   478,   479,   480,
-     481,     0,   482,   483,   484,   485,   486,   487,   488,   489,
-       0,   490,     0,   492,   493,   494,   495,   496,   497,   498,
-       0,     0,   499,     0,     0,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   528,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,   126,   127,   128,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   130,   131,     0,   132,
-     133,   134,     0,   136,   137,   138,   139,   140,     0,   142,
-     143,     0,   144,   145,   146,   147,   148,   149,     0,     0,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-     159,   160,   161,     0,     0,     0,   163,   164,   165,   166,
-     167,   168,     0,   170,   171,   172,     0,   173,   174,   175,
-     176,   177,   178,     0,     0,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,     0,   196,   197,   198,   199,   200,   201,     0,
-       0,   202,   203,   204,   205,     0,     0,   206,   207,   208,
-     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
-       0,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,     0,   229,     0,   230,   231,   232,   233,
-       0,   234,     0,   235,     0,     0,     0,   238,   239,   529,
-       0,   242,     0,   243,     0,   244,   245,   246,   247,     0,
-     248,   249,   250,   251,   252,  1343,   254,     0,   256,   257,
-     258,   259,     0,   260,   261,   262,   263,   264,   265,   266,
-       0,   267,     0,   269,   270,   271,   272,   273,   274,   275,
-     276,     0,   277,     0,   278,     0,     0,   281,     0,   283,
-     284,   285,   286,   287,   288,     0,     0,   289,     0,   291,
-       0,     0,   293,   294,   295,   296,   297,   298,   299,   300,
-     530,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,     0,   324,   325,   326,   327,   328,     0,   329,
-     330,     0,   332,     0,   333,   334,   335,   336,   337,   338,
-       0,   339,   340,     0,     0,   341,   342,   343,     0,     0,
-     344,   345,   346,     0,   348,     0,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,     0,     0,
-       0,     0,   362,   363,   364,     0,   366,   367,   368,   369,
-     370,   371,     0,   372,   373,   374,   375,   376,   377,     0,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-       0,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,     0,   401,   402,     0,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,     0,     0,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,     0,     0,   431,   432,
-     433,   434,     0,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   531,   448,   449,     0,     0,
-     450,   451,     0,   452,     0,   454,   455,   456,   457,   458,
-       0,   459,   460,   461,     0,     0,   462,   463,   464,   465,
-     466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
-       0,     0,   475,   476,   477,     0,   478,   479,   480,   481,
-       0,   482,   483,   484,   485,   486,   487,   488,   489,     0,
-     490,     0,   492,   493,   494,   495,   496,   497,   498,     0,
-       0,   499,     0,     0,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
-     516,   517,   518,   519,   520,   528,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,     0,
-       0,     0,  1698,     0,     0,   130,   131,     0,   132,   133,
-     134,     0,   136,   137,   138,   139,   140,     0,   142,   143,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,   159,
-     160,   161,     0,     0,     0,   163,   164,   165,   166,   167,
-     168,     0,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,     0,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,   208,   209,
-     210,     0,   211,   212,   213,     0,   214,   215,   216,     0,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,     0,   229,     0,   230,   231,   232,   233,     0,
-     234,     0,   235,     0,     0,     0,   238,   239,   529,     0,
-     242,     0,   243,     0,   244,   245,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,     0,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,     0,   269,   270,   271,   272,   273,   274,   275,   276,
-       0,   277,     0,   278,     0,     0,   281,     0,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,     0,   291,     0,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,   530,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,     0,   324,   325,   326,   327,   328,     0,   329,   330,
-       0,   332,     0,   333,   334,   335,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,   346,     0,   348,     0,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,   364,     0,   366,   367,   368,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,     0,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,     0,   421,   422,   423,   424,
-     425,     0,   427,   428,   429,     0,     0,   431,   432,   433,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   531,   448,   449,     0,     0,   450,
-     451,     0,   452,     0,   454,   455,   456,   457,   458,     0,
-     459,   460,   461,     0,     0,   462,   463,   464,   465,   466,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,   487,   488,   489,     0,   490,
-       0,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,   506,
-     507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
-     517,   518,   519,   520,   528,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-     125,     0,   126,   127,   128,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   130,   131,     0,   132,   133,   134,
-       0,   136,   137,   138,   139,   140,     0,   142,   143,     0,
-     144,   145,   146,   147,   148,   149,     0,     0,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,   159,   160,
-     161,     0,     0,     0,   163,   164,   165,   166,   167,   168,
-       0,   170,   171,   172,     0,   173,   174,   175,   176,   177,
-     178,     0,     0,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-       0,   196,   197,   198,   199,   200,   201,     0,     0,   202,
-     203,   204,   205,     0,     0,   206,   207,   208,   209,   210,
-       0,   211,   212,   213,     0,   214,   215,   216,     0,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,     0,   229,     0,   230,   231,   232,   233,     0,   234,
-       0,   235,     0,     0,     0,   238,   239,   529,     0,   242,
-       0,   243,     0,   244,   245,   246,   247,     0,   248,   249,
-     250,   251,   252,  1887,   254,     0,   256,   257,   258,   259,
-       0,   260,   261,   262,   263,   264,   265,   266,     0,   267,
-       0,   269,   270,   271,   272,   273,   274,   275,   276,     0,
-     277,     0,   278,     0,     0,   281,     0,   283,   284,   285,
-     286,   287,   288,     0,     0,   289,     0,   291,     0,     0,
-     293,   294,   295,   296,   297,   298,   299,   300,   530,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-       0,   324,   325,   326,   327,   328,     0,   329,   330,     0,
-     332,     0,   333,   334,   335,   336,   337,   338,     0,   339,
-     340,     0,     0,   341,   342,   343,     0,     0,   344,   345,
-     346,     0,   348,     0,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,     0,     0,     0,     0,
-     362,   363,   364,     0,   366,   367,   368,   369,   370,   371,
-       0,   372,   373,   374,   375,   376,   377,     0,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,     0,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,     0,   401,   402,     0,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,     0,     0,   421,   422,   423,   424,   425,
-     426,   427,   428,   429,     0,     0,   431,   432,   433,   434,
-       0,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,   531,   448,   449,     0,     0,   450,   451,
-       0,   452,     0,   454,   455,   456,   457,   458,     0,   459,
-     460,   461,     0,     0,   462,   463,   464,   465,   466,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,     0,
-     475,   476,   477,     0,   478,   479,   480,   481,     0,   482,
-     483,   484,   485,   486,   487,   488,   489,     0,   490,     0,
-     492,   493,   494,   495,   496,   497,   498,     0,     0,   499,
-       0,     0,   500,   501,   502,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   528,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   130,   131,     0,   132,   133,   134,     0,
-     136,   137,   138,   139,   140,     0,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   161,
-       0,     0,     0,   163,   164,   165,   166,   167,   168,     0,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,     0,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,     0,     0,     0,   238,   239,   529,     0,   242,     0,
-     243,     0,   244,   245,   246,   247,     0,   248,   249,   250,
-     251,   252,  2269,   254,     0,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,     0,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,     0,     0,   281,     0,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,     0,   291,     0,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   530,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,     0,
-     324,   325,   326,   327,   328,     0,   329,   330,     0,   332,
-       0,   333,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   346,
-       0,   348,     0,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   364,     0,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,     0,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,     0,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   531,   448,   449,     0,     0,   450,   451,     0,
-     452,     0,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   464,   465,   466,     0,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   487,   488,   489,     0,   490,     0,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,   528,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   130,   131,     0,   132,   133,   134,     0,   136,
-     137,   138,   139,   140,     0,   142,   143,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,   159,   160,   161,     0,
-       0,     0,   163,   164,   165,   166,   167,   168,     0,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-       0,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,   208,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,     0,
-     229,     0,   230,   231,   232,   233,     0,   234,     0,   235,
-       0,     0,     0,   238,   239,   529,     0,   242,     0,   243,
-       0,   244,   245,   246,   247,     0,   248,   249,   250,   251,
-     252,  2284,   254,     0,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,     0,   269,
-     270,   271,   272,   273,   274,   275,   276,     0,   277,     0,
-     278,     0,     0,   281,     0,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,     0,   291,     0,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,   530,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,     0,   324,
-     325,   326,   327,   328,     0,   329,   330,     0,   332,     0,
-     333,   334,   335,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,   346,     0,
-     348,     0,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-     364,     0,   366,   367,   368,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,     0,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,     0,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,     0,     0,   431,   432,   433,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   531,   448,   449,     0,     0,   450,   451,     0,   452,
-       0,   454,   455,   456,   457,   458,     0,   459,   460,   461,
-       0,     0,   462,   463,   464,   465,   466,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,   487,   488,   489,     0,   490,     0,   492,   493,
-     494,   495,   496,   497,   498,     0,     0,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,   506,   507,   508,   509,
-     510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
-     520,  1502,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     118,   119,   120,   121,   122,   123,   124,   125,     0,   126,
-     127,   128,     0,     0,     0,  1503,     0,     0,     0,     0,
-    1504,   130,   131,     0,   132,   133,   134,  1505,   136,   137,
-     138,     0,  1506,  1507,  1508,  1509,     0,   144,   145,   146,
-     147,   148,   149,     0,     0,   150,   151,   152,   153,  1510,
-    1511,   156,     0,   157,   158,   159,   160,     0,     0,  1512,
-       0,  1513,   164,   165,   166,   167,   168,  1514,   170,   171,
-     172,     0,   173,   174,   175,   176,   177,   178,     0,  1515,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-    1516,   191,   192,  1517,   194,     0,   195,     0,   196,   197,
-     198,   199,   200,   201,     0,     0,   202,   203,   204,   205,
-       0,     0,   206,   207,  1073,   209,   210,     0,   211,   212,
-     213,     0,   214,   215,   216,     0,   217,   218,   219,   220,
-       0,   222,   223,   224,   225,   226,   227,     0,     0,   229,
-       0,   230,   231,  1518,   233,     0,   234,     0,   235,  1519,
-       0,  1520,   238,   239,     0,  1521,   242,     0,   243,     0,
-       0,     0,   246,   247,     0,   248,   249,   250,   251,   252,
-     253,   254,  1522,   256,   257,   258,   259,     0,   260,   261,
-     262,   263,   264,   265,   266,     0,   267,  1523,     0,   270,
-     271,   272,   273,   274,  1524,  1525,     0,  1526,     0,   278,
-    1527,  1528,   281,  1529,   283,   284,   285,   286,   287,   288,
-       0,     0,   289,  1530,   291,  1531,     0,   293,   294,   295,
-     296,   297,   298,   299,   300,  1532,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,  1533,  1534,  1535,   325,
-     326,   327,     0,     0,   329,   330,  1536,   332,     0,     0,
-     334,  1537,   336,   337,   338,     0,   339,   340,     0,     0,
-     341,   342,   343,     0,     0,   344,   345,     0,  1538,   348,
-    1539,     0,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,     0,     0,     0,     0,   362,   363,     0,
-    1540,   366,   367,     0,   369,   370,   371,     0,   372,   373,
-     374,   375,   376,   377,     0,   378,   379,   380,   381,   382,
-    1541,   384,   385,   386,   387,     0,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,     0,
-     401,   402,  1542,   404,   405,   406,  1543,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-       0,  1544,   421,   422,   423,   424,   425,   426,  1545,   428,
-     429,     0,  1546,   431,   432,  1547,   434,     0,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-    1548,   448,     0,     0,     0,   450,   451,     0,   452,  1549,
-     454,   455,   456,   457,   458,     0,   459,  1550,  1551,     0,
-       0,   462,   463,     0,   465,     0,     0,   467,   468,  1552,
-     470,   471,   472,   473,   474,  1553,     0,   475,   476,   477,
-       0,   478,   479,   480,   481,     0,   482,   483,   484,   485,
-     486,     0,  1554,   489,     0,   490,  1555,   492,   493,   494,
-     495,   496,   497,   498,     0,     0,   499,     0,     0,   500,
-     501,   502,   503,   504,   505,  1502,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   517,   518,   519,   520,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
-     124,   125,     0,   126,   127,   128,     0,     0,     0,  1503,
-       0,     0,     0,     0,  1504,   130,   131,     0,   132,   133,
-     134,  1505,   136,   137,   138,     0,  1506,  1507,  1508,  1509,
-       0,   144,   145,   146,   147,   148,   149,     0,     0,   150,
-     151,   152,   153,  1510,  1511,   156,     0,   157,   158,   159,
-     160,     0,     0,  1512,     0,  1513,   164,   165,   166,   167,
-     168,  1514,   170,   171,   172,     0,   173,   174,   175,   176,
-     177,   178,     0,  1515,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,  1516,   191,   192,  1517,   194,     0,
-     195,     0,   196,   197,   198,   199,   200,   201,     0,     0,
-     202,   203,   204,   205,     0,     0,   206,   207,  1073,   209,
-     210,     0,   211,   212,   213,     0,  1863,   215,   216,     0,
-     217,   218,   219,   220,     0,   222,   223,   224,   225,   226,
-     227,     0,     0,   229,     0,   230,   231,  1518,   233,     0,
-     234,     0,   235,  1519,     0,  1520,   238,   239,     0,  1521,
-     242,     0,   243,     0,     0,     0,   246,   247,     0,   248,
-     249,   250,   251,   252,   253,   254,  1522,   256,   257,   258,
-     259,     0,   260,   261,   262,   263,   264,   265,   266,     0,
-     267,  1523,     0,   270,   271,   272,   273,   274,  1524,  1525,
-       0,  1526,     0,   278,  1527,  1528,   281,  1529,   283,   284,
-     285,   286,   287,   288,     0,     0,   289,  1530,   291,  1531,
-       0,   293,   294,   295,   296,   297,   298,   299,   300,  1532,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-    1533,  1534,  1535,   325,   326,   327,     0,     0,   329,   330,
-    1536,   332,     0,     0,   334,  1537,   336,   337,   338,     0,
-     339,   340,     0,     0,   341,   342,   343,     0,     0,   344,
-     345,     0,  1538,   348,  1539,     0,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,     0,     0,     0,
-       0,   362,   363,     0,  1540,   366,   367,     0,   369,   370,
-     371,     0,   372,   373,   374,   375,   376,   377,     0,   378,
-     379,   380,   381,   382,  1541,   384,   385,   386,   387,     0,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,     0,   401,   402,  1542,   404,   405,   406,
-    1543,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,     0,  1544,   421,   422,   423,   424,
-     425,   426,  1545,   428,   429,     0,  1546,   431,   432,  1547,
-     434,     0,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,  1548,   448,     0,     0,     0,   450,
-     451,     0,   452,  1549,   454,   455,   456,   457,   458,     0,
-     459,  1550,  1551,     0,     0,   462,   463,     0,   465,     0,
-       0,   467,   468,  1552,   470,   471,   472,   473,   474,  1553,
-       0,   475,   476,   477,     0,   478,   479,   480,   481,     0,
-     482,   483,   484,   485,   486,     0,  1554,   489,     0,   490,
-    1555,   492,   493,   494,   495,   496,   497,   498,     0,     0,
-     499,     0,     0,   500,   501,   502,   503,   504,   505,  3233,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     517,   518,   519,   520,     0,     0,     0,     0,   118,   119,
-     120,   121,   122,   123,   124,   125,     0,   126,   127,   128,
-       0,     0,     0,  2974,     0,     0,     0,     0,  2975,   130,
-     131,     0,   132,   133,   134,  2976,   136,   137,   138,     0,
-    1506,  2977,  1508,  1509,     0,   144,   145,   146,   147,   148,
-     149,     0,     0,   150,   151,   152,   153,  1510,  1511,   156,
-       0,   157,   158,   159,   160,     0,     0,  2978,     0,  2979,
-     164,   165,   166,   167,   168,  2980,   170,   171,   172,     0,
-     173,   174,   175,   176,   177,   178,     0,  2981,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,  1516,   191,
-     192,  1517,   194,     0,   195,     0,   196,   197,   198,   199,
-     200,   201,     0,     0,   202,   203,   204,   205,     0,     0,
-     206,   207,  1073,   209,   210,     0,   211,   212,   213,     0,
-     214,   215,   216,     0,   217,   218,   219,   220,     0,   222,
-     223,   224,   225,   226,   227,     0,     0,   229,     0,   230,
-     231,  1518,   233,     0,   234,     0,   235,  2982,     0,  2983,
-     238,   239,  2984,  2985,   242,     0,   243,     0,     0,     0,
-     246,   247,     0,   248,   249,   250,   251,   252,   253,   254,
-    2986,   256,   257,   258,   259,     0,   260,   261,   262,   263,
-     264,   265,   266,     0,   267,  2987,     0,   270,   271,   272,
-     273,   274,  1524,  1525,     0,  1526,     0,   278,  2988,  2989,
-     281,  2990,   283,   284,   285,   286,   287,   288,     0,     0,
-     289,  2991,   291,  2992,     0,   293,   294,   295,   296,   297,
-     298,   299,   300,  3234,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,  1533,  2994,  1535,   325,   326,   327,
-       0,     0,   329,   330,  2996,   332,     0,     0,   334,  1537,
-     336,   337,   338,     0,   339,   340,     0,     0,   341,   342,
-     343,     0,     0,   344,   345,     0,  2998,   348,  2999,     0,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,     0,     0,     0,     0,   362,   363,     0,  3000,   366,
-     367,     0,   369,   370,   371,     0,   372,   373,   374,   375,
-     376,   377,     0,   378,   379,   380,   381,   382,  1541,   384,
-     385,   386,   387,     0,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,     0,   401,   402,
-    3001,   404,   405,   406,     0,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,     0,  3002,
-     421,   422,   423,   424,   425,   426,     0,   428,   429,     0,
-    3004,   431,   432,  1547,   434,     0,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,  3235,   448,
-       0,     0,     0,   450,   451,     0,   452,  3006,   454,   455,
-     456,   457,   458,     0,   459,  1550,  1551,     0,     0,   462,
-     463,     0,   465,     0,     0,   467,   468,  3007,   470,   471,
-     472,   473,   474,     0,     0,   475,   476,   477,     0,   478,
-     479,   480,   481,     0,   482,   483,   484,   485,   486,     0,
-    1554,   489,     0,   490,  3009,   492,   493,   494,   495,   496,
-     497,   498,     0,     0,   499,     0,     0,   500,   501,   502,
-     503,   504,   505,   528,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   517,   518,   519,   520,     0,     0,
-       0,     0,   118,   119,   120,   121,   122,   123,   124,   125,
-       0,   126,   127,   128,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   130,   131,     0,   132,   133,   134,     0,
-     136,   137,   138,   139,   140,     0,   142,   143,     0,   144,
-     145,   146,   147,   148,   149,     0,     0,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,   159,   160,   161,
-       0,     0,     0,   163,   164,   165,   166,   167,   168,     0,
-     170,   171,   172,     0,   173,   174,   175,   176,   177,   178,
-       0,     0,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,     0,   195,     0,
-     196,   197,   198,   199,   200,   201,     0,     0,   202,   203,
-     204,   205,     0,     0,   206,   207,   208,   209,   210,     0,
-     211,   212,   213,     0,   214,   215,   216,     0,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-       0,   229,     0,   230,   231,   232,   233,     0,   234,     0,
-     235,     0,     0,     0,   238,   239,   529,     0,   242,     0,
-     243,     0,   244,   245,     0,   247,     0,   248,   249,   250,
-     251,   252,   253,   254,     0,   256,   257,   258,   259,     0,
-     260,   261,   262,   263,   264,   265,   266,     0,   267,     0,
-     269,   270,   271,   272,   273,   274,   275,   276,     0,   277,
-       0,   278,     0,     0,   281,     0,   283,   284,   285,   286,
-     287,   288,     0,     0,   289,     0,   291,     0,     0,   293,
-     294,   295,   296,   297,   298,   299,   300,   530,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,     0,
-     324,   325,   326,   327,   328,     0,   329,   330,     0,   332,
-       0,   333,   334,   335,   336,   337,   338,     0,   339,   340,
-       0,     0,   341,   342,   343,     0,     0,   344,   345,   346,
-       0,   348,     0,   350,   351,   352,   353,   354,   355,   356,
-       0,   358,   359,   360,   361,     0,     0,     0,     0,   362,
-     363,   364,     0,   366,   367,   368,   369,   370,   371,     0,
-     372,   373,   374,   375,   376,   377,     0,   378,   379,   380,
-       0,   382,   383,   384,   385,   386,   387,     0,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,     0,   401,   402,     0,   404,   405,   406,   407,     0,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,     0,     0,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,     0,     0,   431,   432,   433,   434,     0,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   531,   448,   449,     0,     0,   450,   451,     0,
-     452,     0,   454,   455,   456,   457,   458,     0,   459,   460,
-     461,     0,     0,   462,   463,   464,   465,   466,     0,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,   475,
-     476,   477,     0,   478,   479,   480,   481,     0,   482,   483,
-     484,   485,   486,   487,   488,   489,     0,   490,     0,   492,
-     493,   494,   495,   496,   497,   498,     0,     0,   499,     0,
-       0,   500,   501,   502,   503,   504,   505,   506,   507,   508,
-     509,   510,   511,   512,   513,   514,   515,   516,   517,   518,
-     519,   520,  1797,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   118,   119,   120,   121,   122,   123,   124,   125,     0,
-     126,   127,   128,     0,     0,     0,  1503,     0,     0,     0,
-       0,  1504,   130,   131,     0,   132,   133,   134,  1505,   136,
-     137,   138,     0,  1506,  1507,  1508,  1509,     0,   144,   145,
-     146,   147,   148,   149,     0,     0,   150,   151,   152,   153,
-    1510,  1511,   156,     0,   157,   158,   159,   160,     0,     0,
-    1512,     0,  1513,   164,   165,   166,   167,   168,  1514,   170,
-     171,   172,     0,   173,   174,   175,   176,   177,   178,     0,
-    1515,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,  1516,   191,   192,  1517,   194,     0,   195,     0,   196,
-     197,   198,   199,   200,   201,     0,     0,   202,   203,   204,
-     205,     0,     0,   206,   207,  1073,   209,   210,     0,   211,
-     212,   213,     0,   214,   215,   216,     0,   217,   218,   219,
-     220,     0,   222,   223,   224,   225,   226,   227,     0,     0,
-     229,     0,   230,   231,  1518,   233,     0,   234,     0,   235,
-    1519,     0,  1520,   238,   239,     0,  1521,   242,     0,   243,
-       0,     0,     0,   246,   247,     0,   248,   249,   250,   251,
-     252,   253,   254,  1522,   256,   257,   258,   259,     0,   260,
-     261,   262,   263,   264,   265,   266,     0,   267,  1523,     0,
-     270,   271,   272,   273,   274,  1524,  1525,     0,  1526,     0,
-     278,  1527,  1528,   281,  1529,   283,   284,   285,   286,   287,
-     288,     0,     0,   289,  1530,   291,  1531,     0,   293,   294,
-     295,   296,   297,   298,   299,   300,     0,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,  1533,  1534,  1535,
-     325,   326,   327,     0,     0,   329,   330,  1536,   332,     0,
-       0,   334,  1537,   336,   337,   338,     0,   339,   340,     0,
-       0,   341,   342,   343,     0,     0,   344,   345,     0,  1538,
-     348,  1539,     0,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,     0,     0,     0,     0,   362,   363,
-       0,  1540,   366,   367,     0,   369,   370,   371,     0,   372,
-     373,   374,   375,   376,   377,     0,   378,   379,   380,   381,
-     382,  1541,   384,   385,   386,   387,     0,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-       0,   401,   402,  1542,   404,   405,   406,     0,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,     0,  1544,   421,   422,   423,   424,   425,   426,     0,
-     428,   429,     0,  1546,   431,   432,  1547,   434,     0,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,     0,   448,     0,     0,     0,   450,   451,     0,   452,
-    1549,   454,   455,   456,   457,   458,     0,   459,  1550,  1551,
-       0,     0,   462,   463,     0,   465,     0,     0,   467,   468,
-    1552,   470,   471,   472,   473,   474,     0,     0,   475,   476,
-     477,     0,   478,   479,   480,   481,     0,   482,   483,   484,
-     485,   486,     0,  1554,   489,     0,   490,  1555,   492,   493,
-     494,   495,   496,   497,   498,     0,     1,   499,     0,     0,
-     500,   501,   502,   503,   504,   505,     2,     0,     3,     4,
-       0,     0,     0,     0,     1,     0,     0,   517,   518,   519,
-     520,     0,     0,     0,     2,     0,     6,     0,     0,     0,
-       0,     0,     0,     0,     0,     7,     0,     0,     0,     0,
-       0,     0,     0,     0,     6,     0,     0,     0,     0,     8,
-       0,     0,     0,     7,     0,     0,     0,     0,     0,     0,
-      10,     0,     0,     0,     0,     0,     0,     8,     0,     0,
-       0,     0,    11,     0,   751,     0,     0,     0,    10,     0,
-       0,     0,     0,     0,     0,    13,     0,     0,     0,     0,
-      11,     0,   751,     0,     0,     0,     0,     0,     0,     0,
-      14,    15,     0,    13,     0,     0,     0,     0,     0,     0,
-       0,   752,     0,     0,     0,     0,     0,    18,    14,    15,
-       0,     0,     0,     0,     0,    19,     0,     0,     0,   752,
-       0,     0,     0,     0,     0,    18,     0,     0,     0,     0,
-       0,     0,    22,    19,     0,     0,    23,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      22,     0,     0,     0,    23,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0, -1468,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0, -1468,     0,     0,     0,
-       0,     0,     0,     0,    25,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    25,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    26,
-      27,    28,     0,     0,     0,     0,     0,    29,     0,     0,
-      30,     0,     0,     0,     0,     0,     0,    26,    27,    28,
-       0,     0,     0,     0,     0,    29,     0,     0,    30,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    31,     0,     0,     0,     0,     0,     0,     0,     0,
-      32,     0,     0,     0,     0,     0,     0,     0,     0,    31,
-       0,     0,     0,     0,     0,     0,    33,     0,    32,     0,
-       0,     0,     0,    34,     0,     0,     0,    35,     0,     0,
-       0,     0,     0,     0,    33,     0,     0,    36,     0,     0,
-       0,    34,     0,     0,     0,    35,     0,     0,     0,    37,
-       0,     0,     0,    38,     0,    36,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    37,     0,     0,
-       0,    38,     0,    39,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    40,     0,     0,     0,
-       0,    39,    42,     0,     0,     0,     0,    43,     0,     0,
-       0,     0,   753,     0,    40,     0,     0,     0,     0,     0,
-      42,     0,     0,     0,    44,    43,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    44,     0,     0,     0,     0,     0,    45,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   754,     0,     0,     0,    45,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      46
-};
-
-static const yytype_int16 yycheck[] =
-{
-       7,   521,    46,     0,     0,     0,     0,     0,     0,    16,
-       0,     0,   841,   888,     0,   746,    23,     0,    73,   903,
-     815,  1443,   930,     7,   914,   999,    38,     0,  1256,  1459,
-    1242,  1045,  1230,   965,    20,   754,   935,    20,  1720,    23,
-      16,  1217,  1244,  1683,  1093,     7,  1175,  2221,    20,   990,
-    1495,  1828,   990,  1612,  1836,  1321,   865,  1655,  1574,    77,
-    2280,    23,   990,   980,    37,  1298,  1600,  1222,    75,    76,
-    2029,   969,  2368,    23,  1210,   990,  2211,   980,     0,    77,
-      17,  1219,     0,  2717,     0,  2190,     0,  2192,  1636,  1637,
-       0,    75,    76,     0,     0,  2680,     0,  1140,  1346,   111,
-       0,     0,  1145,    45,     0,  2276,   903,     0,   905,  1247,
-     907,  2715,     0,    75,    76,  2680,     0,    34,  1008,  2156,
-    2740,  2210,   754,   753,   747,    75,    76,  1101,   101,   810,
-       0,  2733,     0,     0,  2547,   816,  2348,     0,     0,     5,
-    1687,     0,     0,    75,    76,  2634,  1853,    13,    14,  2638,
-    1850,     0,     5,  2030,     9,     0,  1738,     5,     9,     0,
-    1967,     4,  1740,  1067,  1068,  2847,     9,    10,    63,     0,
-       5,  3062,     5,    55,     0,     5,     9,   778,  2356,   988,
-    1084,    45,    63,     5,  2360,  2360,  2354,     5,    80,    74,
-       5,     5,    26,     5,     9,     5,   991,  1849,  2369,    13,
-      14,   139,     5,     5,   997,     5,     5,     5,    45,     5,
-       5,     5,     5,    13,    14,    13,    14,    13,    14,  1655,
-     173,     3,     4,     5,   122,    13,    14,     9,    13,    14,
-       4,   107,    82,    23,  1151,     9,   119,     4,    82,   860,
-    3048,    11,     9,    93,   883,   147,    16,  1046,   172,    93,
-     122,  1265,  2423,  2424,    30,  2426,   883,  3065,    90,   100,
-    1274,   980,    38,    11,  2003,  2004,   104,  1157,    16,  3238,
-     191,    40,    63,     3,   100,  2014,  1184,    63,   124,  2018,
-     122,   172,   288,  2902,   169,    75,    76,   807,    11,  2493,
-     172,  1100,    15,    16,   172,   296,  3018,   129,    46,  1071,
-       5,   107,   173,   137,    34,    35,    53,  2883,   290,  2885,
-     291,   992,   245,   805,  1231,  1087,   218,  1234,  1235,  2596,
-     117,  2598,   291,  1004,   184,  1995,  1996,  1997,   107,  1458,
-       5,   132,    80,   296,   854,   117,   245,   193,    30,   193,
-    3370,   213,   119,   181,    11,   181,    38,  1545,    15,    16,
-     276,   106,  1151,   983,    64,     3,    40,     5,   368,   166,
-     382,   313,   391,  3400,    74,  3167,  1495,  3169,   345,    40,
-    2475,   213,  3433,    41,  1640,   162,  1205,  1206,   279,    46,
-      13,    14,  2650,    30,  3476,   119,   164,   108,    83,    30,
-     482,    38,   117,   457,   296,   122,  3328,   480,  3330,    30,
-    1209,    11,  2179,   482,  3565,   409,   120,   384,   507,   148,
-     137,  1204,   504,    80,   794,  1937,    82,   369,  3003,   518,
-     359,   504,   120,  3057,  1332,   504,   518,    93,  1303,  2649,
-     177,  1230,   812,  3463,  3068,   273,  3466,   219,   309,   518,
-     373,   171,   419,   173,   329,  3606,  1968,   194,  2622,   290,
-     389,   238,   199,   148,   518,  3059,  3264,   132,   126,   241,
-     294,   200,  1361,  3524,   290,   360,   191,   273,   472,  3561,
-      80,   192,  3404,   207,   275,  2646,   308,  2648,  3369,   360,
-     340,   195,   273,   280,   285,   160,  2754,  3289,  3525,   518,
-     237,   132,   176,   470,   272,   396,   251,   195,  2535,   355,
-     522,   132,  1551,   280,   358,   176,   261,   431,   518,   369,
-    2787,  1777,   518,  2948,  3236,  3091,   485,   324,   451,   507,
-     361,   522,  1321,   357,   395,   359,  1018,  1023,   454,  3559,
-    3499,   241,   520,  1029,   167,   361,   518,   518,   476,   273,
-     431,   275,   451,   419,  2103,   447,  2328,  2329,  2330,    11,
-     275,  2729,   416,    15,    16,   389,   454,   178,  2726,   522,
-    1181,   513,  3181,   448,  2162,   518,   539,  1168,  1207,   360,
-    2746,  2746,    13,  3464,   360,   280,   459,  2022,    19,   416,
-    1207,   431,   454,   507,    46,   518,   593,   431,  1108,    30,
-     428,   469,   424,  2764,   373,  1771,   520,   518,   389,  2803,
-     275,   328,  1835,    44,    45,   280,  1510,  1511,   513,   518,
-     285,   457,   454,   482,  1345,   520,  2575,   593,    80,  1350,
-     241,   457,  2156,   399,   516,  1356,  2433,   522,   520,   290,
-    3312,  1535,   467,    11,  1463,   504,   518,    15,    16,   480,
-    1449,   522,  1435,  1436,  1363,  2227,  2194,   394,  1441,  1897,
-    2228,  3253,   518,  3238,   480,  1484,   108,  3465,   509,   510,
-     132,   527,   517,  1929,  2371,   518,  2366,  2214,   109,  1871,
-     518,  1685,   521,  3238,   527,  1941,   521,   522,   519,   482,
-     521,   524,   525,   518,  1912,   518,  2220,   518,   518,   482,
-     521,  1595,  1596,   519,   516,   521,   518,  3186,   520,  2919,
-     518,   504,  3191,   518,   518,  1971,   518,   399,   518,  2361,
-     754,   504,  1978,   480,  2926,   518,   518,   164,   518,   518,
-     518,  3134,   518,   518,   518,   518,  2162,   509,   510,  1352,
-     518,  1363,  1362,   518,  3368,   509,   510,   504,   468,  1629,
-    1630,  1631,   509,   510,   514,  1517,  1545,   754,    11,  3045,
-    2489,   520,   399,  2019,    33,   457,  3376,  2023,   406,   407,
-    3195,   805,   162,   438,    75,  1537,   514,   753,  1577,  1578,
-     753,   266,   275,  3375,   449,  1456,   227,   280,  1587,  3214,
-      59,   433,   754,    46,   231,   149,  2052,   794,   511,   512,
-     513,   514,  1601,  1448,  2027,  1450,  1451,   132,   805,  1571,
-     812,   997,   423,   345,   425,   812,  2476,  2477,  2478,  2479,
-     794,  2900,    26,   285,    26,  2597,   518,    80,    32,  2778,
-      32,   805,   273,  1632,   162,   160,   321,   108,   812,   167,
-     451,   483,   794,   888,   841,   842,   339,   201,   238,   857,
-    3474,  1640,   384,   805,   511,   512,   513,   514,   860,   250,
-     812,  1980,  3426,  3427,  2953,   805,  3460,   513,   865,   857,
-      82,   916,  2961,   162,   520,  1879,   878,  1578,   167,  2906,
-     418,    93,   419,   805,   275,  3046,  1587,   419,   875,   875,
-     875,   875,   875,   875,  1801,   875,   875,   287,  1681,   875,
-     341,   863,   875,  2022,  1811,  2493,   519,  1814,   227,   522,
-     238,   518,   875,  2862,  3478,   912,   913,     5,   456,   916,
-     917,   517,  1796,  3517,  3499,   516,    26,   523,  2695,   520,
-    2697,  1652,    32,   137,   866,   137,   843,   844,   470,   846,
-     517,   848,  2180,  1726,  3499,  2812,   523,     4,  2815,   238,
-    2817,   392,     9,     4,   273,   280,     0,  1990,     9,   287,
-     285,  3585,   521,   875,  1829,  1830,  1831,   875,  1857,   875,
-     522,   875,   969,  1895,  3260,   875,   468,  1899,   875,   875,
-    1902,   875,  1769,   980,  1018,   875,   875,  3197,  1777,   875,
-     987,   988,   875,   245,    13,    14,   993,   875,   287,   996,
-     997,   875,   999,  1000,  1001,  1002,  1913,   983,   935,  1796,
-     983,  2535,   275,   454,   794,   875,  1904,   875,   875,  1016,
-    1913,  1018,   875,   875,  2562,   805,   875,   875,     4,  1816,
-    1027,   214,   812,     9,  1821,     5,   203,   137,   126,   127,
-     518,   516,  1016,  2455,  1018,   520,   516,  1044,  1045,  1046,
-     520,  1028,  3177,  1027,  2474,  1032,   341,   509,   510,   511,
-     512,   513,   514,   518,  1016,   519,  1018,  1101,   522,  1066,
-    2196,   519,  2198,   392,   522,  1027,  1016,   245,  1018,   108,
-     843,   844,    37,   846,   172,   848,  1807,  1027,  1085,   355,
-     294,  1812,   294,   516,  1016,   518,  1018,   520,  2604,  1096,
-    1097,  1098,   380,  1100,  1101,  1027,  1103,  2874,  1618,    71,
-      72,  2334,  2304,   438,   203,   519,   516,  2373,   522,   380,
-     520,   373,    74,   523,   449,   556,   132,   828,   829,   830,
-     252,  2250,   833,  3343,   436,   454,  3085,  1103,   419,  1136,
-    1929,   509,   510,   511,   512,   513,   514,   245,   423,   353,
-     425,   353,  1941,   357,   160,   357,  2680,  1154,  1155,  1942,
-    1943,  1944,  1945,  1946,  1947,   117,   470,  1950,  1951,  1952,
-    1953,  1954,  1955,  1956,  1957,  1958,  1959,  1976,   377,  1181,
-    1188,  1189,  1971,  1191,  2312,   389,   423,   389,   425,  1978,
-     167,   189,   190,  1190,   294,   380,    30,  1194,  1195,   451,
-    1188,  1189,   518,  1191,  1913,   373,   373,  1204,  1205,  1206,
-     178,   245,  1209,   245,   172,  2803,   519,   384,   173,   522,
-     511,   519,  2186,   174,   522,    13,    14,   315,   316,   317,
-    2019,    13,    14,  1230,  2023,  2380,  1016,   523,  1018,  1920,
-    2029,  2386,   519,  1924,  1246,   522,  1927,  1027,   518,  1435,
-    1436,    85,   419,  2509,   209,  1441,   460,   357,   460,   518,
-      94,   259,   260,  2052,   518,  2064,   518,  3039,  1265,   275,
-     225,    13,    14,   241,   280,   373,    26,  1274,   519,   285,
-     235,   522,    32,   451,   118,   519,    13,    14,   522,   389,
-    2839,    26,    13,    14,   382,   246,    26,    32,   516,   518,
-     518,  1298,    32,   470,   518,   393,   519,     8,   519,   522,
-      11,   522,   504,   519,    15,    16,   522,   748,    19,    20,
-      21,   224,   519,   275,  1321,   522,  2191,   415,   280,   519,
-     518,   419,   522,    25,  1320,  1320,  1320,  1320,   518,   373,
-    1337,   373,   518,  2142,   259,   260,  2781,   501,   519,  1346,
-     518,   522,   518,   451,  2137,  2138,   480,   191,   482,    59,
-     460,  2283,   519,  2285,   452,   522,  1363,  3577,    26,   518,
-     204,  1337,  2491,   518,    32,   463,  2495,   329,    13,    14,
-     378,   379,  2906,  1380,    13,    14,  1362,   137,  1385,  1362,
-     519,   147,   480,   522,   345,   347,   519,   290,  3562,   522,
-    3564,  1363,   137,    13,    14,   373,   162,   137,   520,   364,
-     519,   167,   519,   522,  1380,   522,   504,   451,   519,   451,
-     518,   522,   519,   115,  2680,   522,   519,   501,   383,   522,
-     518,   171,   438,   384,  3529,   866,  2255,   519,  1435,  1436,
-     522,  3605,   519,   449,  1441,   522,  1443,   519,   518,  3544,
-     522,  1448,  1449,  1450,  1451,   423,   519,   425,   522,   522,
-    2662,  2359,   218,   378,   379,   519,  1463,  1464,   419,  1443,
-    2253,  2663,   172,    13,    14,  1472,  2694,  1474,   519,   137,
-    1477,  2647,   238,   451,   518,  1482,   518,  1484,  1485,   519,
-    1487,  1443,   522,   423,  1491,   425,   448,   423,  1472,   425,
-    1474,  2540,  2541,  1477,  3599,   457,   519,  2709,  1482,  3604,
-     172,  1485,   519,  1487,   295,   522,  2661,  1491,  2663,   470,
-    1472,   222,  1474,   519,   519,  1477,   522,   522,    13,    14,
-    1482,   287,  1472,  1485,  1474,  1487,    59,  1477,   519,  1491,
-     296,   522,  1482,   518,   294,  1485,   420,  1487,  1545,    37,
-    1472,  1491,  1474,   501,  3321,  1477,  3323,   224,   519,   294,
-    1482,   522,   152,  1485,   294,  1487,  2286,   353,  2288,  1491,
-     519,   405,   519,   522,   408,   522,   519,    13,    14,   522,
-    1577,  1578,    40,  2547,  2373,   152,  2517,  1574,  2516,  1586,
-    1587,   292,  1574,   152,  1574,  1574,   152,  1594,  1574,  2517,
-    2518,  1574,   152,   353,  1601,   419,   174,   357,  2646,  2408,
-    2648,  1574,  2517,  2518,  2519,   315,   316,   317,   353,    13,
-      14,     8,   357,   353,    11,    13,    14,   357,    15,    16,
-    1627,  1628,    19,    20,    21,  1632,   294,   519,  1635,   389,
-    1685,    13,    14,  1640,  1641,  1642,  1643,  1644,  1645,  1646,
-    1647,  1648,  1649,   880,   389,   882,  1653,  1654,  1655,   389,
-     518,  1658,   275,  1443,    40,  1662,    13,    14,  1665,  1666,
-    1667,  1668,  1669,  1670,  1671,  1672,  1673,   470,   246,  1676,
-    2401,  1655,   382,  1649,    89,   173,  1683,   152,  1685,    13,
-      14,   447,  1472,   484,  1474,   353,   152,  1477,   520,   357,
-    2409,  3331,  1482,    13,    14,  1485,  1703,  1487,  1046,   152,
-     460,  1491,   147,  2969,  3238,  1723,    13,    14,   178,   419,
-    2509,   209,    13,    14,   152,   460,   290,   162,   355,  1726,
-     460,   389,   167,  2613,   431,  1723,   519,   225,   518,  1701,
-    1737,  1738,   518,  1174,    13,    14,   518,   235,    13,    14,
-      13,    14,   452,   518,  2920,   421,  1942,  1943,  1944,  1945,
-    1946,  1947,   300,   463,  1950,  1951,  1952,  1953,  1954,  1955,
-    1956,  1957,  1958,  1959,   225,  2967,   220,   345,    13,    14,
-    1777,   241,   518,   218,    13,    14,  2575,   368,   369,  1786,
-     518,  1788,   368,   369,   368,   369,  2579,  2580,   368,   369,
-     263,   264,   460,   238,   505,   506,   507,   225,   509,   510,
-     511,   512,   513,   514,   225,  3003,   384,  2636,   518,   297,
-    1786,  1014,  1788,   378,   379,  3043,  1019,  1020,  1021,   462,
-     463,  1828,  2721,    40,    40,  2757,  2701,   236,  1835,  2391,
-    2392,  1838,  1839,  1036,     6,  2743,   518,  1040,    10,  3571,
-    3572,   419,   287,    60,   314,  3527,    18,  3539,  3540,  3531,
-       5,   296,  1154,  1155,  2262,  2263,     5,   518,  3280,   518,
-      32,  2875,  3128,   325,    36,   518,   364,   518,     5,     5,
-     518,     5,  1879,     5,   518,   481,     9,   518,   518,   302,
-     522,  2680,  1230,   104,   522,   383,   519,    40,   220,   106,
-    1897,   167,   470,   389,   287,   292,   167,  1904,  1905,    59,
-     285,   236,  1875,   373,  3586,   518,  1913,   431,   518,    93,
-     380,   522,  1353,   431,  1355,    59,    59,   431,   266,   431,
-     108,   523,  1929,   222,   431,   431,  1933,  1934,   480,  1936,
-     380,   100,   152,   275,  1941,  1942,  1943,  1944,  1945,  1946,
-    1947,  2137,  2138,  1950,  1951,  1952,  1953,  1954,  1955,  1956,
-    1957,  1958,  1959,   423,   275,   425,   199,   275,  1965,  1966,
-     518,    40,  1969,   275,  1971,  3499,   275,   518,    82,  1976,
-     152,  1978,  3238,  1321,   172,   520,    13,   519,     0,  2778,
-     519,   451,  2775,   172,   519,   202,   522,   519,   519,   519,
-     519,   518,   477,  2000,   108,   225,   519,   225,  2005,   282,
-    2007,   282,   447,   518,  2011,   518,   522,  2800,   467,   520,
-     518,  3433,  2019,   518,   518,   518,  2023,    26,  2025,   518,
-    2027,  2005,  2029,    32,    39,   518,   520,  2011,   476,     9,
-     429,    40,    11,   429,   251,   518,   355,  3249,  2970,  2971,
-     517,  2958,   522,  2005,   261,  2052,   528,   523,   522,  2011,
-     429,    60,   181,  3475,  3484,  2005,   273,  2064,  2065,   431,
-     174,  2011,   280,  2862,   163,   172,   518,   522,   519,   457,
-     218,   516,   266,  2005,   519,   520,   392,  2808,   100,  2011,
-     522,   227,   291,   522,   313,   522,   788,   313,   305,   203,
-     181,   518,   220,   519,   275,  2102,   227,   106,  2142,  2106,
-     227,   296,  3524,   282,  2111,  2112,   282,   519,   505,   506,
-     507,   334,   509,   510,   511,   512,   513,   514,   820,   470,
-     288,   152,     3,   518,   518,   147,  3100,   518,   137,   152,
-    2137,  2138,   246,   152,   152,  2142,    37,  3365,   152,   480,
-     162,    42,   359,   845,   522,   167,   522,    40,  2941,   275,
-     172,  2158,   290,     3,  2161,  2162,  2163,   997,    40,   181,
-     290,    59,   172,    11,   186,    40,   167,   384,   181,   519,
-    2969,   518,  2179,  2180,   519,  3304,   519,   167,  2162,  2186,
-     519,   518,  2189,     3,    39,   518,   403,     3,   516,   516,
-     431,   893,   517,   202,   431,   431,   218,  1545,   431,  2206,
-     101,   353,   519,   501,  3003,  2189,   519,   522,  2939,   519,
-     501,    40,  2219,   519,   528,  2005,   238,   520,   520,   519,
-     148,  2011,  2206,   519,   519,   519,   519,  2189,   172,  2236,
-    2237,    60,   501,  3499,   518,   431,   518,   155,   518,  2189,
-     518,   518,   251,   250,  2206,   477,  2253,    40,  2255,    59,
-     522,   507,   261,   503,   454,   291,  2206,   291,   522,   373,
-     244,  2268,    59,    59,   273,   287,   266,   469,   290,   431,
-     384,   275,   173,   178,   296,   152,   518,   106,   980,  2286,
-    2287,  2288,   203,   152,   152,   294,  3085,   518,   990,   431,
-     431,  3084,  1640,    40,   519,   355,   305,   519,   203,   518,
-    3502,   288,   519,   480,   290,   419,   431,  3215,   209,   431,
-    2286,  2287,  2288,    40,   336,   522,   152,   527,  2325,   280,
-    2364,   172,   519,    59,   225,   518,   518,  2334,   442,  3128,
-     186,  1772,   519,   519,   235,   167,   241,    80,   516,   361,
-     143,  1782,   522,  1784,   353,   519,  1787,   176,   357,   519,
-     359,   522,  1793,   519,  1795,  1195,   470,  2353,  2353,  2353,
-    2353,  2368,  3081,   519,  1204,   199,  2373,  1808,   269,   519,
-     172,   518,  1813,   202,   519,   384,  1817,  1818,  1819,  1820,
-     389,  1822,  1823,  2579,  2580,   301,  2393,   361,   523,   290,
-     295,   291,  2368,  2913,   403,   518,   181,   419,   522,  2189,
-     519,  2408,  2409,   518,   152,   522,   519,   519,  1110,   314,
-    2417,   176,   518,   442,   315,   519,  2206,   519,  1120,   519,
-     518,   322,   251,   520,   518,   447,   519,   522,   518,  1777,
-      40,    86,   261,    40,    40,   457,   457,   522,   172,  3238,
-    1142,  2417,   518,  3333,   273,   519,   479,   519,  2455,  1151,
-     199,   460,   519,   517,   517,   477,   522,   479,   480,   290,
-     519,   519,   519,   364,   519,   463,   507,    59,   373,   519,
-     519,  2455,   519,  3302,   519,   380,   305,     8,   480,   205,
-      11,  3290,   383,  3292,    15,    16,  2493,   117,    19,    20,
-      21,    40,   518,  2455,   516,   227,   192,   519,   520,   521,
-      88,   280,  2509,  2547,   280,   431,   431,  3300,   520,  2521,
-    3305,   519,  3307,   507,   520,   520,  3490,   520,   423,  2526,
-     425,   520,   517,   520,   520,  2532,  2533,  3435,   520,   520,
-     359,   520,   520,    40,   517,  2590,   275,   442,   520,   520,
-    2547,  2585,   520,   448,   520,   520,   451,   520,   520,   520,
-    3425,   452,   520,   520,   520,   384,  2563,   520,   520,  2566,
-    3444,  2568,   520,   520,   520,   520,   520,   520,  2575,  2576,
-     520,   519,  2579,  2580,   403,   107,   519,  2584,  2585,  2775,
-     518,  1929,   518,   480,  2591,   290,   419,   518,     9,  3418,
-    1046,   354,  2636,  1941,   518,  1435,  1436,    59,   518,  2606,
-     522,  1441,   199,   336,   519,   522,   519,  2604,   517,  2616,
-     522,   519,  2604,   192,  2604,  2604,     7,     8,  2604,    37,
-     522,  2604,    13,  1971,    42,   462,    91,   519,    19,  2636,
-    1978,  2604,    23,   347,    25,   518,    40,  2610,    29,    30,
-      31,   152,   117,    34,   520,   519,    37,    38,   124,   152,
-      41,    40,   519,    44,    45,   519,   172,   369,   369,   518,
-      40,   518,    40,   457,   522,  2455,   518,   310,   199,   518,
-    2677,  2019,   280,  2680,  2681,  2023,  2683,  1379,   249,   191,
-     457,  2029,   442,   101,    75,    76,   178,    74,  2695,   293,
-    2697,   222,   518,    74,    80,    74,     9,   172,   519,    80,
-    3499,  2677,   519,   518,  2052,  2681,   371,  2683,  2752,   517,
-     101,   203,    93,   519,    59,   507,   517,   108,   109,   110,
-     111,   112,    93,   133,  2720,  2720,  2720,  2720,   273,   290,
-      40,   518,   442,   293,   293,   518,   117,   519,   119,   519,
-     462,  3472,   205,  2716,   519,  2941,   290,   290,   519,   241,
-     389,   454,   122,   980,   368,   173,  2800,    25,   148,    36,
-    2201,   292,   147,   181,   298,   368,   875,  2664,  2775,  1794,
-    2281,  2778,  2745,     8,  1230,  3335,    11,   162,  3475,  3429,
-      15,    16,   167,  2677,    19,    20,    21,  2614,  2795,  2796,
-    3576,   209,  1904,  2800,  2963,   178,  2803,  2396,   852,   315,
-     316,   317,     8,   295,  3450,    11,  3554,   225,  3208,    15,
-      16,  3503,  3512,    19,    20,    21,  1217,   235,  3547,  3266,
-     203,  2274,  2734,  2830,  2287,  3501,   207,  2656,  3510,   304,
-      36,  2683,  2271,   218,  3498,  1345,  2391,  1318,  2392,  2352,
-     315,   316,   317,  2850,  2417,  3081,  2711,  2253,  1174,  2856,
-    2857,   269,  2896,   238,  2861,  2862,  1015,  1015,   241,  2866,
-    2219,    40,  2869,  2870,  1762,  1321,   382,  2874,  2875,  1198,
-    2474,  2878,   290,  1197,  3484,  2882,  2236,  3397,  1726,  3406,
-    3294,    60,  2889,  1761,    23,  2206,  1726,  2017,  3084,  1200,
-    2803,  3123,  2455,  1120,   275,  2454,   992,   315,  2882,   280,
-    3229,  2501,   287,   419,   322,  2032,  2969,   382,   990,   990,
-     990,   296,   295,   990,  1913,   990,  1913,   990,  1913,   990,
-    2882,   990,   990,  3410,  1151,  3409,  2933,   106,   107,  2113,
-    2533,   423,  2882,   425,  2941,  2162,   452,  2220,   117,  2159,
-    2066,  2889,  2383,  2851,   419,  1464,   364,   463,   329,  2115,
-    2882,  2559,  3395,  2960,  2604,  1841,   448,  1363,   893,   451,
-    2025,   789,  2969,  2853,   199,   383,   347,  1701,  1254,  2615,
-    1702,  2324,    -1,    -1,   505,   506,   507,   452,   509,   510,
-     511,   512,   513,   514,    -1,    -1,    -1,   222,   463,    -1,
-     373,  1693,    -1,    -1,    -1,    -1,  3003,   176,    -1,    -1,
-      -1,    -1,   518,    -1,  1231,   480,    -1,  1234,  1235,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   222,    -1,    -1,    -1,
-      -1,    -1,    -1,   202,    -1,  2373,    -1,    -1,    -1,   504,
-      -1,    -1,    -1,    -1,   452,    -1,    -1,    -1,  3045,   457,
-     423,    -1,   425,   518,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  3100,   292,    -1,   442,
-      -1,    -1,   447,  1765,  1766,   448,  3073,   448,   451,  3045,
-      -1,    -1,   251,    -1,  3081,    -1,   457,  3084,  3085,    -1,
-      -1,    -1,   261,    -1,    -1,    -1,   292,  3060,    -1,  1545,
-      -1,    -1,  2882,  3100,   273,    -1,   275,    -1,    -1,    -1,
-      -1,    -1,  1942,  1943,  1944,  1945,  1946,  1947,    -1,    -1,
-    1950,  1951,  1952,  1953,  1954,  1955,  1956,  1957,  1958,  1959,
-      -1,  3128,  1824,    -1,   172,    -1,   305,  3134,    -1,    -1,
-      -1,   516,    -1,    -1,    -1,   520,    -1,    -1,  1840,  1841,
-      -1,  1368,  1369,    -1,  3151,  3152,    -1,    -1,  3155,   540,
-    3157,    -1,    -1,    -1,   545,    -1,    -1,   548,    -1,    -1,
-      -1,  2509,    -1,    -1,    -1,   556,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  3182,    -1,    -1,    -1,    -1,
-     359,    -1,    -1,    -1,  1640,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,  2639,  3206,
-      -1,  2642,    15,    16,    -1,   384,    19,    20,    21,    -1,
-      -1,  1913,    -1,    -1,    -1,    -1,    -1,  1919,    -1,    -1,
-      -1,    -1,    -1,    -1,   403,    -1,   405,  2575,  2669,   408,
-      -1,  3238,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2684,  2685,  2686,  2687,  2688,  2689,  2690,
-    2691,  2692,  2693,  3260,    -1,    -1,   126,   127,    37,    -1,
-      -1,    -1,    41,    -1,    -1,    -1,    -1,   315,   316,   317,
-     505,   506,   507,  3280,   509,   510,   511,   512,   513,   514,
-      -1,    -1,  3255,  3290,  3260,  3292,    -1,  3294,    -1,    -1,
-      -1,  3298,    -1,  3300,    -1,  3302,  3280,  2137,  2138,   505,
-     506,   507,   172,   509,   510,   511,   512,   513,   514,  3316,
-      -1,    -1,    -1,    -1,  3321,    -1,  3323,    -1,  3280,    -1,
-      -1,  1777,   101,    -1,  3331,    -1,    -1,    -1,    -1,   108,
-      -1,   110,  2680,   112,   382,    -1,    -1,  3344,    -1,   518,
-      -1,    -1,  3349,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   746,   747,   748,    -1,  3332,
-      -1,  3334,    -1,    -1,    -1,  1592,    -1,    -1,  3344,    -1,
-      -1,   419,    -1,    -1,    -1,    -1,    -1,  1604,    -1,  1606,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3396,
-      -1,    -1,    -1,  1046,    -1,    -1,    -1,   788,   789,  3406,
-      -1,  3374,    -1,   794,   452,   796,    -1,  1634,    -1,    -1,
-      -1,  3418,    -1,  2253,   805,   463,    -1,  3390,   809,   810,
-      -1,   812,    -1,    -1,   815,   816,  3433,    -1,    -1,    -1,
-    2778,    -1,   480,    -1,    -1,    -1,    -1,   828,   829,   830,
-      -1,    -1,   833,    -1,  3451,   315,   316,   317,    55,  3433,
-     841,   842,   843,   844,    -1,   846,   504,   848,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3475,   860,
-     518,  3433,    -1,  1929,    -1,   866,    -1,    -1,    -1,   292,
-      -1,    -1,    -1,  3490,    -1,  1941,    -1,   878,    -1,    -1,
-    3280,  3475,  3499,    -1,  3501,   102,    -1,    -1,    -1,  2940,
-      -1,   892,   893,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    1737,  1738,   382,  3475,  2862,  1971,   123,  3524,   151,    -1,
-      -1,    -1,  1978,   393,    -1,  3501,    -1,    -1,    -1,    -1,
-      -1,  3538,  3539,  3540,   141,    -1,   927,   928,   145,   172,
-    3524,    -1,    -1,  3516,    -1,   415,    -1,    -1,   939,   419,
-      -1,    -1,   943,   944,   945,   946,    -1,    -1,  3565,    -1,
-      -1,   168,  3524,  2019,   171,    -1,    -1,  2023,   959,  3542,
-      -1,    -1,    -1,  2029,  1801,    -1,    -1,  1230,    -1,    -1,
-     187,    -1,   452,    -1,  1811,    -1,    -1,  1814,    -1,    -1,
-      -1,  2293,    -1,   463,    -1,    -1,  2052,    -1,  1046,  3606,
-     991,   992,    -1,   994,    -1,    -1,   997,  1046,    -1,    -1,
-     480,    -1,  1003,  1004,    -1,    -1,    -1,    -1,    -1,  1010,
-      -1,  2969,    -1,    -1,    -1,  1016,    -1,  1018,    -1,     0,
-      -1,    -1,    -1,    -1,   504,    -1,  1027,    -1,    -1,    -1,
-      -1,    -1,    -1,  3433,  2346,    -1,  1037,    -1,   518,    20,
-      -1,    -1,    23,    -1,    -1,  3003,    -1,    -1,    -1,    -1,
-      -1,    -1,  2364,  1054,    -1,    37,    37,    -1,  1321,    -1,
-      42,    -1,    -1,   280,    -1,    46,    -1,    -1,    -1,    -1,
-      -1,   288,   315,   316,   317,  3475,  1913,    -1,    -1,    -1,
-      -1,    -1,   505,   506,   507,    -1,   509,   510,   511,   512,
-     513,   514,    -1,   310,    75,    76,    77,  2409,    -1,    -1,
-      -1,    -1,    -1,    -1,  1105,    -1,    -1,  2419,    -1,  2421,
-      -1,    -1,    -1,  2425,    -1,  2427,    -1,    -1,    -1,   101,
-     101,    -1,   339,    -1,  3524,    -1,    -1,  3085,    -1,  2579,
-    2580,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   382,
-      -1,     8,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,
-      -1,   540,    19,    20,    21,    -1,   545,  1158,    -1,   548,
-      -1,    -1,    -1,    -1,    -1,    -1,  3217,    -1,    -1,    -1,
-    3128,    -1,  1230,  1174,  1175,    -1,   419,    -1,    -1,    46,
-    1181,  1230,    -1,    -1,    -1,    -1,    53,    -1,  3239,  3240,
-      -1,   173,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2036,
-      -1,    -1,    -1,  1204,  1205,  1206,    -1,    -1,    -1,   452,
-      -1,     0,  3263,    80,    -1,  1216,  1217,    -1,    -1,    -1,
-     463,    37,    -1,    -1,    -1,    -1,    42,   209,  1229,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   480,    -1,    -1,
-      -1,    -1,    -1,   225,  1046,  1246,    -1,    -1,    -1,  1250,
-      26,    -1,    -1,   235,  1255,    -1,    32,    -1,    -1,    -1,
-      -1,   504,    -1,  1321,    40,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1321,    -1,    -1,   518,    -1,    -1,    -1,    -1,
-    3238,    -1,  1545,    -1,    60,   101,    -1,   269,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   151,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  2373,    -1,    -1,
-     177,   100,    -1,  1314,    -1,  1316,   172,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1325,  2775,    -1,   194,    -1,    -1,
-     106,     8,   199,   315,    11,  1336,    -1,    -1,    15,    16,
-     322,    -1,    -1,    -1,  1345,    -1,    -1,    -1,    -1,  1350,
-    2800,  1352,  1353,    -1,  1355,  1356,  2193,   173,   147,    -1,
-      -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,  2680,    46,
-     237,    -1,    -1,   162,    -1,    -1,    53,  1640,   167,    -1,
-      -1,    -1,   364,   172,    -1,    -1,    -1,    -1,    -1,  2226,
-    2227,    -1,   181,   209,    -1,    -1,    -1,   186,    -1,  2711,
-    2850,   383,    -1,    80,    -1,    -1,    -1,   796,    -1,   225,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   235,
-      -1,    -1,    -1,    -1,    -1,   292,   202,    -1,  1230,   218,
-      -1,    -1,    -1,    -1,  1435,  1436,    -1,    -1,    -1,    -1,
-    1441,    -1,  1443,  2509,  3495,    -1,    -1,    -1,    -1,   238,
-      -1,    -1,    -1,   269,    -1,  1456,    -1,  1458,  1459,   315,
-     316,   317,  1463,  1464,    -1,  1466,    -1,    -1,   145,    -1,
-     452,  1472,    -1,  1474,   290,   251,  1477,    -1,    -1,    -1,
-      -1,  1482,    -1,  1484,  1485,   261,  1487,  1545,    -1,    -1,
-    1491,  2941,  1493,    -1,  1495,    -1,  1545,   273,   287,   315,
-     177,   290,    -1,   892,    -1,    -1,   322,   296,    -1,  2575,
-      -1,    -1,    -1,    -1,  1777,    -1,    -1,   194,   294,  1321,
-      -1,    -1,   199,    -1,    -1,    -1,   382,   394,    -1,   305,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   927,    -1,
-      -1,  3499,    -1,    -1,    -1,    -1,    -1,   336,   364,    -1,
-      -1,    -1,    -1,    -1,   943,   944,   945,   946,   539,    -1,
-     237,    -1,    -1,   419,    -1,    -1,    -1,   383,    -1,    -1,
-      -1,    -1,   361,    -1,  2886,    -1,    -1,   353,    -1,    -1,
-      -1,   357,  1640,   359,    -1,    -1,    -1,    13,    -1,    -1,
-      -1,  1640,    -1,    19,    -1,    -1,   452,    23,    -1,  1600,
-      -1,    -1,    -1,    -1,    30,   994,    -1,   463,   384,    -1,
-      -1,  1612,    -1,   389,  2680,   292,    -1,    -1,    44,    45,
-      -1,    -1,    -1,    -1,   480,    -1,    -1,   403,    -1,    -1,
-     419,    -1,    -1,    -1,  3084,   502,   452,    -1,   505,   506,
-     507,   457,   509,   510,   511,   512,   513,   514,   504,    75,
-      76,  1652,    -1,    -1,  1655,    -1,    -1,    -1,   447,    -1,
-      -1,    -1,   518,    -1,    -1,    -1,  1929,    -1,   457,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2513,  2514,  1941,    -1,
-      -1,    -1,  1683,   109,   460,    -1,    -1,    -1,   477,    -1,
-     479,   480,    -1,    -1,    -1,    -1,    -1,  1698,    -1,  1700,
-      -1,  1702,    -1,    -1,    -1,    -1,    -1,    -1,  1971,    -1,
-      -1,  1712,  2778,  1714,    -1,  1978,    -1,   394,    -1,  1777,
-      -1,    -1,    -1,    -1,    -1,  1726,    -1,   516,  1777,    -1,
-     519,   520,   521,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  3054,  1545,    -1,    -1,    -1,    -1,    40,    -1,
-    1751,    -1,  1753,    -1,    -1,    -1,  2019,    -1,    -1,    -1,
-    2023,    -1,    -1,    -1,  1765,  1766,  2029,    -1,    60,  3081,
-    1771,  1772,   753,   754,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  1782,  1783,  1784,  1785,    -1,  1787,    -1,    -1,  2052,
-      -1,    -1,  1793,    -1,  1795,    -1,  2862,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1807,  1808,    -1,    -1,
-      -1,  1812,  1813,   794,   106,    -1,  1817,  1818,  1819,  1820,
-      -1,  1822,  1823,    -1,   805,   502,    -1,  1216,    -1,    -1,
-      -1,   812,   509,   510,   511,   512,   513,   514,  1640,    -1,
-    1229,  1842,    -1,  2680,    -1,    -1,    -1,    -1,    -1,  1850,
-    3300,  1852,  1853,  1854,  1855,  1856,  3168,    -1,    -1,    -1,
-      -1,  1250,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  1929,  1873,    -1,    -1,    -1,   857,    -1,    -1,    -1,
-    1929,    -1,    -1,  1941,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  1892,  1941,    -1,   875,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2969,    -1,    -1,    -1,    -1,    -1,    -1,
-     202,    -1,    -1,  1971,    -1,    -1,    -1,    -1,    -1,    -1,
-    1978,    -1,  1971,    -1,    -1,    -1,  3238,  1316,    -1,  1978,
-      -1,    -1,    -1,    -1,    -1,    -1,  1325,  3003,    -1,    -1,
-      -1,  1942,  1943,  1944,  1945,  1946,  1947,    -1,    -1,  1950,
-    1951,  1952,  1953,  1954,  1955,  1956,  1957,  1958,  1959,   251,
-      -1,  2019,    -1,    -1,    -1,  2023,    -1,    -1,    -1,   261,
-    2019,  2029,    -1,    -1,  2023,  1777,  2813,    98,    -1,  1980,
-    2029,   273,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1994,  2052,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   983,  2052,  2005,   126,   127,    -1,    -1,    -1,
-    2011,    -1,    -1,   305,    -1,    -1,  2017,    -1,    -1,  3085,
-      -1,  2022,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2031,  2032,    -1,    -1,    -1,  1016,    -1,  1018,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1027,    -1,    -1,    -1,
-      -1,   172,    -1,     8,  3366,    -1,    11,    -1,    -1,   172,
-      15,    16,  3128,    -1,    -1,    -1,    -1,   359,    -1,    -1,
-      -1,     8,    -1,    -1,    11,    -1,    -1,  1466,    15,    16,
-      -1,  1062,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    46,   384,  1074,    -1,    -1,    -1,    -1,    53,    -1,
-      -1,    -1,  2103,    -1,    -1,    -1,    -1,  2108,    -1,    46,
-    2373,   403,  2113,    -1,    -1,    -1,    53,    -1,    -1,    -1,
-    1101,  2958,    -1,     0,    -1,    80,  2963,  1929,    -1,    -1,
-     556,    -1,    -1,    -1,    -1,    -1,  2137,  2138,    -1,  1941,
-      -1,    -1,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2156,    -1,    -1,    -1,    -1,
-      -1,  2162,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1971,
-      -1,    -1,  3238,  3010,  3011,    -1,  1978,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  3499,  2189,    -1,
-     145,   304,    -1,    -1,   315,   316,   317,    -1,    -1,    -1,
-    2201,    -1,   315,   316,   317,  2206,    -1,  1188,  1189,  2210,
-    1191,    -1,    -1,    -1,    -1,    -1,    -1,  2019,    -1,    -1,
-      -1,  2023,   177,   100,    -1,    -1,    -1,  2029,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   194,
-     177,    -1,    -1,    -1,   199,    -1,  2509,    -1,    -1,  2250,
-    2052,    -1,  2253,    -1,  2255,  2256,    -1,   194,    -1,    -1,
-      -1,   382,   199,    -1,    -1,    -1,    -1,    -1,    -1,   382,
-     147,    -1,   393,    -1,    -1,  2276,    -1,    -1,    -1,    -1,
-      -1,    -1,   237,    -1,    -1,   162,    -1,    -1,    -1,    -1,
-     167,    -1,    -1,    -1,   415,   172,    -1,    -1,   419,    -1,
-     237,    -1,    -1,    -1,   181,    -1,   419,    -1,    -1,   186,
-      -1,  1700,  2575,  1702,    -1,  2373,    -1,    -1,   439,    -1,
-      -1,   747,   748,  1712,  2373,    -1,    -1,    -1,    -1,    -1,
-      -1,   452,    -1,    -1,    -1,    -1,    -1,   292,    -1,   452,
-      -1,   218,   463,    -1,    -1,    -1,    -1,  2348,    -1,    -1,
-     463,    -1,    -1,    -1,  2355,   292,    -1,    -1,    -1,   480,
-      -1,   238,  1751,    -1,    -1,  2366,    -1,   480,  2369,  2370,
-    2371,  2372,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   805,
-      -1,  1362,  2383,   504,  2385,    -1,    -1,  2388,  3225,  3226,
-      -1,   504,    -1,    -1,  2395,    -1,    -1,   518,    -1,    -1,
-    2401,  3238,    -1,    -1,    -1,   518,    -1,    -1,    -1,    -1,
-     287,    -1,    -1,   290,    -1,    -1,    -1,  2680,    -1,   296,
-      -1,    -1,  2423,  2424,    -1,  2426,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  3499,    -1,    -1,    -1,    -1,    -1,   394,
-     866,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2509,    -1,    -1,  2455,    -1,    -1,   394,    -1,   336,
-    2509,    -1,    -1,  1852,  1853,  1854,  1855,  1856,    -1,    -1,
-      -1,    -1,  2473,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2481,  2482,  2483,    -1,   361,    -1,    -1,    -1,    -1,    -1,
-    2491,  1472,  2493,  1474,  2495,    -1,  1477,    -1,    -1,    -1,
-    2501,  1482,    -1,    -1,  1485,    -1,  1487,    -1,    -1,    -1,
-    1491,    -1,    -1,    -1,    -1,  2778,     8,  2575,    -1,    11,
-    2521,    -1,    -1,    15,    16,    -1,  2575,    19,    20,    21,
-      -1,    -1,    -1,    -1,  2535,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   419,    -1,    36,  2546,    -1,   502,    -1,  2550,
-      -1,    -1,    -1,    -1,   509,   510,   511,   512,   513,   514,
-      -1,    -1,    -1,    -1,    -1,   502,    -1,    -1,    -1,    -1,
-     447,  2373,   509,   510,   511,   512,   513,   514,  2579,  2580,
-     457,    -1,    -1,    -1,  1010,    -1,    -1,    -1,    -1,    -1,
-    1016,    -1,  1018,  1574,    -1,    -1,    -1,    -1,    -1,  2862,
-     477,  1027,   479,   480,    -1,  1994,    -1,  2608,    -1,    -1,
-      -1,  1037,    -1,  2614,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  2680,    -1,    -1,    -1,    -1,    -1,    -1,  2630,
-      -1,  2680,    -1,  2634,    -1,  2636,    -1,  2638,  2639,   516,
-      -1,  2642,   519,   520,   521,  2646,  2647,  2648,     8,  2650,
-      -1,    11,    -1,    -1,    -1,    15,    16,    -1,    -1,    19,
-      20,    21,  3499,    -1,    -1,    -1,    -1,    -1,  2669,    -1,
-    2671,    -1,    -1,    -1,  1655,    -1,    36,    -1,    -1,  1105,
-      -1,    -1,    -1,  2684,  2685,  2686,  2687,  2688,  2689,  2690,
-    2691,  2692,  2693,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2969,  2509,    -1,    -1,
-      -1,    -1,    -1,    -1,  2715,    -1,    -1,    -1,    -1,    -1,
-    2778,  2722,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2778,
-     222,    -1,    -1,  2734,    -1,    -1,    -1,    -1,    -1,    -1,
-    3003,    -1,  1723,    -1,    -1,    -1,    -1,     8,  1174,  1175,
-      11,    -1,    -1,  2754,    15,    16,    -1,    -1,    19,    20,
-      21,    -1,    -1,  2764,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2575,  2775,    36,    -1,    -1,    -1,    -1,
-    2781,    -1,    -1,    -1,    -1,    -1,    -1,  2788,  2789,  2790,
-    2791,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2800,
-     292,    -1,  2803,    -1,  2862,    -1,  2807,  2808,    -1,    -1,
-      -1,    -1,    -1,  2862,    -1,  2816,    -1,    -1,     8,    -1,
-      -1,    11,  3085,    -1,    -1,    15,    16,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2839,    -1,
-      -1,    -1,    -1,    -1,    -1,  2846,  2847,    -1,    -1,    -1,
-    2851,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,
-      -1,    -1,   222,    53,    -1,  3128,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2680,  2880,
-      -1,  2882,  1863,    -1,    -1,    -1,    -1,    -1,  2889,    -1,
-      80,    -1,    -1,    -1,  1875,  2896,    -1,    -1,    -1,  2900,
-      -1,    -1,    -1,    -1,    -1,  2906,    -1,    -1,    -1,    -1,
-      -1,  2969,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2920,
-    2969,    -1,    -1,    -1,    -1,  2926,  1352,  1353,    -1,  1355,
-      -1,    -1,   292,    -1,    -1,    -1,    -1,    -1,  2939,  2940,
-    2941,    -1,    -1,    -1,    -1,  3003,  2947,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  3003,   145,    -1,    -1,    -1,    -1,
-      -1,   222,    -1,  2964,    -1,    -1,  2355,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  3238,  2778,    -1,    -1,    -1,
-      -1,  2370,  2371,  2372,    -1,    -1,    -1,   177,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2385,    -1,    -1,  2388,
-      -1,    -1,    -1,    -1,   194,    -1,  2395,    -1,    -1,   199,
-      -1,    -1,    -1,   505,   506,   507,    -1,   509,   510,   511,
-     512,   513,   514,    -1,  2005,    -1,    -1,  3085,    -1,    -1,
-    2011,   292,  1458,    -1,    -1,    -1,  3085,    -1,    -1,    -1,
-      -1,  3042,    -1,    -1,    -1,  3046,  1472,   237,  1474,    -1,
-      -1,  1477,    -1,    -1,    -1,    -1,  1482,    -1,  3059,  1485,
-    2862,  1487,    -1,    -1,    -1,  1491,    -1,  1493,    -1,  1495,
-    3128,    -1,    -1,    -1,    -1,    -1,  3077,    -1,    -1,  3128,
-      -1,    -1,    -1,  3084,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  2481,  2482,  2483,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   292,    -1,    -1,    -1,    -1,    -1,    -1,  3110,
-      -1,    -1,    -1,    -1,    -1,  3116,    -1,    -1,    -1,    -1,
-      -1,    -1,  3123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3140,
-      -1,    -1,    -1,    -1,    -1,   505,   506,   507,    -1,   509,
-     510,   511,   512,   513,   514,    -1,    -1,    -1,    -1,    -1,
-      -1,  2142,    -1,  3164,    -1,    -1,    -1,  2969,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    3238,  2162,    -1,    -1,    -1,  3186,  1612,    -1,    -1,  3238,
-    3191,    -1,    -1,    -1,    -1,    -1,    -1,  2178,    -1,    -1,
-      -1,  3003,    -1,    -1,   394,    -1,    -1,    -1,  2189,    -1,
-      -1,     8,    -1,    -1,    11,    -1,  3217,    -1,    15,    16,
-      -1,    -1,    19,    20,    21,  2206,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  3499,    -1,  3239,  3240,
-      -1,  2630,    -1,    -1,   505,   506,   507,    -1,   509,   510,
-     511,   512,   513,   514,    -1,  3256,    -1,  3258,    -1,    -1,
-      -1,    -1,  3263,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  3277,    -1,    -1,  3280,
-      -1,    -1,    -1,  3085,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3300,
-      -1,  3302,    -1,  3304,  3305,    -1,  3307,    -1,    -1,    -1,
-      -1,  3312,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,
-     510,   511,   512,   513,   514,    -1,  3128,  1753,    -1,    -1,
-    3331,    -1,    -1,  2722,  3335,    -1,    -1,    -1,    -1,    -1,
-       8,  3342,    -1,    11,    -1,    -1,  1772,    15,    16,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1782,    -1,  1784,    -1,
-      -1,  1787,    -1,    -1,    -1,    -1,    -1,  1793,    -1,  1795,
-      -1,  3372,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,  1808,  2364,    -1,    53,    -1,  1813,    -1,    -1,
-      -1,  1817,  1818,  1819,  1820,    -1,  1822,  1823,    -1,  2788,
-    2789,  2790,  2791,    -1,    -1,    -1,    -1,    -1,    -1,  3410,
-      -1,    -1,    80,    -1,    -1,    -1,    -1,  3418,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   222,    -1,    -1,    -1,    -1,
-      -1,    -1,  3433,    -1,    -1,    -1,  3238,    -1,    -1,    -1,
-      -1,  3499,    -1,    -1,     0,    -1,    -1,    -1,    -1,    -1,
-    3499,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3460,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    -1,    -1,    -1,
-      -1,  3472,  3473,    -1,  3475,  3476,    32,   145,    34,    35,
-      -1,    -1,    -1,  3484,    -1,    -1,   841,   842,    -1,    -1,
-      -1,    47,    -1,    -1,  3495,   292,    52,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    61,    -1,    -1,    -1,   177,
-      -1,    -1,    -1,    -1,    -1,    -1,  3517,    -1,    -1,    75,
-      -1,    -1,    -1,  3524,    -1,    -1,   194,    -1,    84,    -1,
-      86,   199,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    98,    -1,   100,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1980,   111,    -1,   912,  2947,    -1,
-    3561,   916,   917,    -1,    -1,    -1,  2547,    -1,    -1,   237,
-     126,   127,   128,    -1,    -1,  3576,    -1,    -1,    -1,  2005,
-      -1,   137,    -1,    -1,    -1,  2011,    -1,   143,    -1,    -1,
-      -1,  2017,    -1,    -1,    -1,   151,  2022,   153,   154,    -1,
-      -1,    -1,    -1,    -1,  2585,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   168,    -1,   969,    -1,   172,    -1,    -1,    -1,
-      -1,    -1,    -1,  2604,   292,    -1,    -1,    -1,    -1,  2610,
-      -1,    -1,   987,    -1,    -1,    -1,    -1,    -1,   993,    -1,
-      -1,   996,   198,    -1,   999,  1000,  1001,  1002,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2636,    -1,    -1,   214,    -1,
-      -1,    -1,     8,    -1,    -1,    11,    -1,    -1,    -1,    15,
-      16,    -1,    -1,    19,    20,    21,    -1,  2103,    -1,    -1,
-      -1,    -1,    -1,    -1,   240,    -1,    -1,  2113,    -1,  1044,
-    1045,    -1,    -1,    -1,    -1,    -1,    -1,  3499,    -1,    -1,
-      46,    -1,    -1,    -1,    -1,    -1,    -1,    53,   505,   506,
-     507,  1066,   509,   510,   511,   512,   513,   514,    -1,    -1,
-       8,    -1,    -1,    11,    -1,    -1,   394,    15,    16,    -1,
-    1085,    19,    20,    21,    80,  2716,    -1,    -1,    -1,    -1,
-      -1,  1096,  1097,  1098,    -1,  1100,  1101,    -1,    36,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    46,   315,
-     316,   317,    -1,  2189,  2745,    53,    -1,   323,    -1,    -1,
-     326,  2752,    -1,    -1,    -1,  2201,    -1,    -1,    -1,    -1,
-    2206,  1136,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,  1154,
-    1155,   357,    -1,    -1,    -1,    -1,     3,    -1,     5,    -1,
-     366,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2800,
-      -1,    -1,    -1,    -1,  2250,    -1,   382,    -1,    -1,    -1,
-    2256,   177,    -1,   389,   502,  1190,    -1,   393,    -1,  1194,
-    1195,   509,   510,   511,   512,   513,   514,   403,   194,    -1,
-    1205,  1206,    -1,   199,    -1,    -1,    -1,    -1,    -1,   415,
-      -1,    -1,    -1,   419,    -1,    -1,    -1,  3256,    -1,    -1,
-      -1,    68,    69,    -1,    -1,    -1,   222,   223,    -1,    -1,
-      -1,    -1,    -1,   439,    -1,    -1,    -1,    -1,  3277,   177,
-      -1,   237,    -1,    -1,    -1,    -1,   452,    -1,    -1,   455,
-      -1,  2882,   458,    -1,    -1,    -1,   194,   463,    -1,    -1,
-    1265,   199,   109,   110,    -1,  2896,   113,   114,    -1,  1274,
-      -1,    -1,    -1,    -1,   480,    -1,    -1,    -1,    -1,   275,
-      -1,    -1,   278,    -1,   222,   223,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1298,    -1,    -1,   292,    -1,   504,   237,
-      -1,    -1,    -1,  3342,    -1,    -1,    -1,  2383,    -1,    -1,
-      -1,    -1,   518,     8,    -1,   521,    11,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    20,    21,    -1,    -1,    -1,
-      -1,    -1,    -1,  3372,    -1,    -1,    -1,   275,    -1,    -1,
-     278,    36,   189,   190,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    46,    -1,    -1,   292,    -1,    -1,   295,    53,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    1385,    -1,    -1,    -1,    -1,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   394,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   253,   254,   255,   256,
-     257,   258,   259,   260,    -1,  2491,   263,   264,    -1,  2495,
-      -1,    -1,    -1,    -1,    -1,  2501,    -1,    -1,    -1,  3060,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1448,    -1,  1450,  1451,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   394,    -1,  1463,  1464,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3100,
-    2546,    -1,    -1,    -1,  2550,    -1,    -1,    -1,    -1,  1484,
-      -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     337,   338,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   194,
-      -1,    -1,    -1,    -1,   199,    -1,   502,    -1,    -1,   505,
-     506,   507,    -1,   509,   510,   511,   512,   513,   514,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   222,   223,    -1,
-      -1,   378,   379,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2634,    -1,
-      -1,    -1,  2638,  2639,   502,    -1,  2642,   505,   506,   507,
-      -1,   509,   510,   511,   512,   513,   514,    -1,    -1,    -1,
-     275,  1586,    -1,   278,     8,    -1,    -1,    11,    -1,  1594,
-      -1,    15,    16,  2669,    -1,    -1,    -1,   292,    -1,    -1,
-     295,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2684,  2685,
-    2686,  2687,  2688,  2689,  2690,  2691,  2692,  2693,    -1,    -1,
-      -1,    -1,    46,  1628,  3255,    -1,    -1,   474,   475,    53,
-    1635,    -1,    -1,    -1,    -1,    -1,  1641,  1642,  1643,  1644,
-    1645,  1646,  1647,  1648,    -1,  3276,    -1,    -1,  1653,  1654,
-      -1,   498,   499,  1658,    -1,    -1,    80,  1662,    -1,    -1,
-    1665,  1666,  1667,  1668,  1669,  1670,  1671,  1672,  1673,    -1,
-      -1,  1676,    -1,    -1,    -1,    -1,    -1,    -1,  1683,     8,
-    1685,    -1,    11,    -1,    -1,    -1,    15,    16,    17,    18,
-      19,    20,    21,    -1,    -1,    -1,    -1,    -1,  1703,   394,
-      -1,  3332,    -1,  3334,    -1,  2781,    -1,    36,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
-      -1,   145,    -1,    -1,    53,    -1,    -1,    -1,    -1,    -1,
-      -1,  2807,  1737,  1738,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  3374,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    80,    -1,   177,     8,    -1,    -1,    11,    -1,  3390,
-      -1,    15,    16,  2839,    -1,    19,    20,    21,    -1,    -1,
-     194,  2847,    -1,    -1,    -1,   199,    -1,    -1,    -1,    -1,
-      -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    53,
-      -1,    -1,    -1,    -1,    -1,    -1,  2882,   502,    -1,    -1,
-     505,   506,   507,   237,   509,   510,   511,   512,   513,   514,
-      -1,    -1,    -1,  1828,    -1,    -1,    80,    -1,   523,    -1,
-    1835,    -1,    -1,  1838,  1839,    -1,    -1,    -1,    -1,     3,
-      -1,    -1,    -1,    -1,     8,    -1,    -1,    11,   177,    -1,
-      -1,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
-      -1,    -1,    -1,    -1,  2940,   194,    -1,    -1,   292,    -1,
-     199,    -1,    36,    -1,  1879,    -1,    40,    -1,    -1,    -1,
-      -1,    -1,    46,    -1,    -1,  3516,    -1,    -1,    -1,    53,
-      -1,    -1,    -1,   222,   223,    -1,    -1,    -1,    -1,  1904,
-    1905,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   237,    -1,
-      -1,  3542,    -1,    -1,    -1,    -1,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,  1933,  1934,
-      -1,  1936,   997,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     194,    -1,    -1,    -1,    -1,   199,   275,    -1,    -1,   278,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    1965,  1966,    -1,   292,  1969,    -1,   295,    -1,   222,   223,
-     394,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2000,    -1,    -1,    -1,    -1,
-      -1,    -1,  2007,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,    -1,
-    2025,   275,  2027,    -1,   278,    -1,    -1,    -1,    -1,    -1,
-     194,    -1,    -1,    -1,    -1,   199,    -1,    -1,   292,    -1,
-    3116,    -1,    -1,    -1,    -1,    -1,    -1,  3123,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1121,    -1,   222,   223,
-    2065,    -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,   502,    -1,
-      -1,    -1,    -1,    -1,    -1,   509,   510,   511,   512,   513,
-     514,    -1,    -1,    -1,    -1,    -1,    -1,  2102,    -1,    -1,
-      -1,  2106,    -1,    -1,    -1,  1170,  2111,  2112,    -1,    -1,
-    3186,   275,    -1,    -1,   278,  3191,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   292,    -1,
-      -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1204,
-     394,  3217,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2158,    -1,    -1,  2161,    -1,  2163,    -1,
-      -1,    -1,    -1,  3239,  3240,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   502,  2179,    -1,   505,   506,   507,    -1,
-     509,   510,   511,   512,   513,   514,    -1,  3263,    -1,    -1,
-      -1,    -1,    -1,   522,  1259,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  2219,    -1,     8,    -1,    -1,    11,
-      -1,    -1,    -1,    15,    16,    -1,    -1,    -1,  3304,    -1,
-     394,  2236,  2237,    -1,    -1,    -1,  3312,  1302,    -1,    -1,
-      -1,    -1,    -1,    -1,  1309,    -1,    -1,    -1,   502,    -1,
-    2255,   505,   506,   507,    46,   509,   510,   511,   512,   513,
-     514,    53,    -1,  2268,    -1,     8,    -1,    -1,    11,    -1,
-      -1,    -1,    15,    16,    17,    18,    19,    20,    21,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,
-      -1,    -1,    -1,    36,  1359,    -1,    -1,    40,    -1,    -1,
-      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      53,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1383,    -1,
-    2325,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2334,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,   502,    -1,
-      -1,   505,   506,   507,    -1,   509,   510,   511,   512,   513,
-     514,    -1,    -1,   145,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1431,    -1,  1433,    -1,
-    1435,  1436,    -1,  1438,    -1,    -1,  1441,    -1,    -1,  1444,
-      -1,    -1,  1447,    -1,    -1,   177,    -1,  1452,  2393,    -1,
-    1455,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   194,    -1,    -1,    -1,    -1,   199,    -1,    -1,
-      -1,    -1,    -1,    -1,     8,    -1,    -1,    11,    -1,  3495,
-      -1,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
-      -1,    -1,    -1,  1498,   177,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    36,    -1,    -1,   237,    -1,    -1,    -1,    -1,
-      -1,   194,    46,    -1,    -1,    -1,   199,    -1,    -1,    53,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   222,
-     223,    -1,    -1,    -1,    -1,    -1,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,
-     292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1582,    -1,    -1,
-      -1,  2526,    -1,    -1,    -1,    -1,    -1,  2532,  2533,    -1,
-      -1,    -1,   275,  1598,    -1,   278,    -1,    -1,    -1,    -1,
-      -1,    -1,  2547,  1608,  1609,  1610,    -1,    -1,    -1,   292,
-    1615,    -1,   295,    -1,  1619,    -1,    -1,    -1,  2563,    -1,
-      -1,  2566,    -1,  2568,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2576,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2584,
-    2585,    -1,    -1,   177,    -1,    -1,  2591,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     194,  2606,   394,    -1,    -1,   199,    -1,    -1,    -1,    -1,
-      -1,  2616,    -1,    -1,    -1,    -1,    -1,  1682,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   222,   223,
-      -1,  2636,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   394,    -1,    -1,    -1,  1720,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  1736,    -1,    -1,    -1,    -1,  1741,    -1,    -1,    -1,
-      -1,   275,    -1,    -1,   278,    -1,    -1,    -1,    -1,    -1,
-    2695,    -1,  2697,  1758,    -1,    -1,    -1,    -1,   292,    -1,
-      -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,   511,
-     512,   513,   514,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,
-      -1,    -1,   505,   506,   507,    -1,   509,   510,   511,   512,
-     513,   514,    -1,    -1,    -1,    -1,   519,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2795,  2796,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     394,    -1,    -1,    -1,     8,    -1,    -1,    11,    -1,    -1,
-      -1,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2830,    -1,    -1,    -1,    -1,
-      -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    46,    -1,    -1,  2850,    -1,    -1,    -1,    53,
-      -1,  2856,  2857,    -1,    -1,    -1,  2861,    -1,    -1,    -1,
-      -1,  2866,    -1,    -1,  2869,  2870,  1931,    -1,    -1,  2874,
-    2875,    -1,    -1,  2878,  1939,  1940,    80,  1942,  1943,  1944,
-    1945,  1946,  1947,    -1,  2889,  1950,  1951,  1952,  1953,  1954,
-    1955,  1956,  1957,  1958,  1959,  1960,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,    -1,
-      -1,   505,   506,   507,    -1,   509,   510,   511,   512,   513,
-     514,    -1,    -1,    -1,    -1,   519,    68,    69,  2933,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,     8,    -1,    -1,    11,  2960,    -1,    -1,    15,    16,
-      17,    18,    19,    20,    21,    -1,    -1,   109,   110,    -1,
-      -1,   113,   114,   177,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    46,
-     194,    -1,    -1,    -1,    -1,   199,    53,    -1,    -1,    -1,
-      -1,    -1,    -1,  2068,    -1,    -1,  2071,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   222,   223,
-      -1,    -1,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   189,   190,    -1,
-      -1,  2116,    -1,    -1,    -1,  2120,    -1,    -1,    -1,  2124,
-    2125,  2126,  2127,  2128,  2129,  2130,  2131,    -1,  3073,    -1,
-      -1,   275,  2137,  2138,   278,  2140,  2141,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   292,  2154,
-      -1,   295,  2157,    -1,    -1,  3100,    -1,    -1,    -1,    -1,
-    2165,  2166,  2167,  2168,  2169,  2170,  2171,  2172,  2173,  2174,
-      -1,   253,   254,   255,   256,   257,   258,   259,   260,    -1,
-     177,   263,   264,    -1,    -1,    -1,    -1,    -1,    -1,  3134,
-      -1,    -1,    -1,    -1,    -1,  2200,    -1,   194,    -1,    -1,
-      -1,    -1,   199,    -1,    -1,    -1,  3151,  3152,    -1,    -1,
-    3155,    -1,  3157,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   222,   223,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  3182,    -1,    -1,
-     237,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2253,    -1,
-     394,    -1,    -1,    -1,    -1,   337,   338,    -1,    -1,    -1,
-      -1,  3206,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   275,    -1,
-      -1,   278,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   292,   378,   379,   295,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2326,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  2337,  2338,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3294,
-      -1,    -1,    -1,  3298,    -1,    -1,    -1,  3302,   502,    -1,
-      -1,   505,   506,   507,    -1,   509,   510,   511,   512,   513,
-     514,  3316,    -1,    -1,    -1,   519,  3321,    -1,  3323,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  3331,    -1,    -1,    -1,
-      -1,    -1,   474,   475,    -1,    -1,    -1,   394,    -1,  2404,
-      -1,    -1,    -1,    -1,  3349,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   498,   499,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2430,  2431,  2432,    -1,    -1,
-    2435,  2436,  2437,  2438,  2439,  2440,   518,    -1,    -1,  2444,
-    2445,  2446,  2447,  2448,  2449,  2450,  2451,  2452,  2453,    -1,
-      -1,  3396,    -1,  2458,  2459,     8,    -1,    -1,    11,    -1,
-      -1,  3406,    15,    16,    17,    18,    19,    20,    21,    -1,
-      -1,    -1,    -1,  3418,    -1,    -1,    -1,    -1,    -1,  2484,
-      -1,    -1,    -1,    36,    -1,  2490,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      53,    -1,    -1,    -1,    -1,   502,  3451,    -1,   505,   506,
-     507,    -1,   509,   510,   511,   512,   513,   514,    -1,    -1,
-    2525,    -1,   519,    -1,    -1,    -1,    -1,    80,    -1,    -1,
-      -1,    -1,    -1,    24,    -1,    -1,    -1,  2542,    -1,    -1,
-      -1,    -1,    -1,  2548,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2556,  2557,    -1,    -1,    -1,    -1,    -1,    -1,  2564,
-    2565,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2578,  2579,  2580,  2581,    -1,  2583,    -1,
-      -1,    -1,  2587,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      81,    -1,    -1,  3538,  3539,  3540,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    97,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,
-    3565,    -1,    11,    -1,   177,    -1,    15,    16,    17,    18,
-      19,    20,    21,    -1,    -1,    -1,    -1,    -1,  2643,    -1,
-      -1,   194,    -1,    -1,    -1,    -1,   199,    36,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   146,    -1,    46,    -1,    -1,
-      -1,  3606,    -1,    -1,    53,   156,    -1,    -1,    -1,   222,
-     223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   169,    -1,
-      -1,    -1,    -1,   174,   237,    -1,    -1,    -1,    -1,    -1,
-      -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,    -1,
-      -1,    11,   203,    -1,    -1,    15,    16,    17,    18,    19,
-      20,    21,   275,    -1,    -1,   278,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,   292,
-      -1,    -1,   295,    -1,    -1,    -1,    46,    -1,  2753,    -1,
-      -1,    -1,    -1,    53,    -1,   246,    -1,    -1,    -1,   250,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2775,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      80,    -1,    -1,    -1,    -1,    -1,     8,    -1,   177,    11,
-      -1,    -1,    -1,    15,    16,    17,    18,    19,    20,    21,
-      -1,    -1,    -1,    -1,    -1,   194,    -1,    -1,    -1,    -1,
-     199,    -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   314,    46,    -1,  2831,    -1,  2833,   320,
-      -1,    53,    -1,   222,   223,    -1,    -1,  2842,    -1,    -1,
-      -1,   394,    -1,    -1,   335,    -1,    -1,    -1,   237,    -1,
-    2855,    -1,    -1,  2858,    -1,  2860,    -1,    -1,    80,  2864,
-      -1,    -1,  2867,  2868,    -1,    -1,  2871,  2872,    -1,    -1,
-      -1,    -1,    -1,    -1,  2879,    -1,    -1,   177,    -1,   370,
-      -1,    -1,   373,  2888,    -1,    -1,   275,    -1,    -1,   278,
-      -1,    -1,    -1,   384,   194,    -1,   387,    -1,  2903,   199,
-      -1,    -1,    -1,   292,    -1,    -1,   295,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   405,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   222,   223,    -1,    -1,    -1,    -1,   419,    -1,
-      -1,    -1,    -1,    -1,   425,   426,  2941,   237,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   436,    -1,    -1,    -1,   502,
-      -1,   442,   505,   506,   507,   177,   509,   510,   511,   512,
-     513,   514,    -1,    -1,    -1,    -1,   519,    -1,    -1,    -1,
-      -1,    -1,   194,    -1,    -1,   275,    -1,   199,   278,   470,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      68,    69,   292,    -1,    -1,   295,    -1,    -1,    -1,    -1,
-     222,   223,    -1,    -1,    -1,   394,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    24,    -1,    -1,    -1,    -1,    -1,
-      -1,   109,   110,    -1,    -1,   113,   114,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   275,    -1,    -1,   278,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     292,    -1,    -1,   295,    -1,    -1,    -1,    -1,  3083,  3084,
-      -1,    81,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   394,    -1,    -1,    97,    -1,    -1,
-      -1,    -1,    -1,  3108,  3109,    -1,    -1,    -1,    -1,    -1,
-      -1,   189,   190,   502,    -1,    -1,   505,   506,   507,    -1,
-     509,   510,   511,   512,   513,   514,    -1,  3132,    -1,    -1,
-     519,    -1,    -1,    -1,    -1,    -1,  3141,    -1,    -1,    -1,
-    3145,  3146,  3147,    -1,    -1,  3150,   146,    -1,  3153,  3154,
-      -1,    -1,    -1,    -1,    -1,    -1,   156,  3162,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   169,
-      -1,    -1,   394,    -1,   174,   253,   254,   255,   256,   257,
-     258,   259,   260,    -1,    -1,   263,   264,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3203,    -1,
-      -1,    -1,   502,   203,  3209,   505,   506,   507,    -1,   509,
-     510,   511,   512,   513,   514,    -1,    -1,  3222,    -1,   519,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   246,    -1,    -1,    -1,
-     250,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   337,
-     338,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  3282,    -1,    -1,
-     502,    -1,    -1,   505,   506,   507,    -1,   509,   510,   511,
-     512,   513,   514,    -1,    -1,    -1,    -1,   519,    -1,    -1,
-     378,   379,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  3318,  3319,  3320,    -1,    -1,    -1,    -1,
-     320,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  3338,    -1,   335,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  3350,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     370,    -1,    -1,   373,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   384,    -1,    -1,   387,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   474,   475,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   405,  3411,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  3421,    -1,    -1,   419,
-     498,   499,    -1,    -1,    -1,    -1,   426,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   436,    -1,    -1,    -1,
-      -1,  3446,   442,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  3471,    -1,    -1,    -1,
-     470,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3514,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,  3568,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,    -1,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,   452,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,   480,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,   504,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,   519,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,   172,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-      -1,   417,   418,   419,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,   452,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,   480,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,   504,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,   452,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,   480,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,   504,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    33,    -1,    -1,
-      -1,    37,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,   132,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-     296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,   383,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,   519,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,    -1,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,    -1,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,   452,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,   480,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,    -1,    -1,   504,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,   172,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,   233,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,   432,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    37,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,   383,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    37,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,   383,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,   519,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    -1,    -1,    -1,    -1,    38,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    37,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,   383,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,   519,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    37,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,   383,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,   172,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,   519,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,   523,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,   477,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,   523,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,   511,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,    -1,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,    -1,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   502,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,    -1,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   509,   510,    -1,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-      -1,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,   181,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,    -1,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,    -1,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   516,    -1,   518,    -1,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,     3,     4,     5,
-       6,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,    -1,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     516,    -1,   518,    -1,    -1,    -1,    -1,    -1,   524,   525,
-     526,   527,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    -1,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,    -1,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,   280,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,    -1,     3,     4,     5,   516,    -1,   518,     9,    -1,
-      -1,    -1,    -1,   524,   525,   526,   527,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    37,    -1,    -1,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,   278,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,   290,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,   383,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   509,   510,
-     511,     3,    -1,    -1,    -1,   516,    -1,   518,    10,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   527,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    81,
-      -1,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,   171,
-      -1,   173,   174,   175,   176,   177,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,   209,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,   235,   236,   237,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,   274,    -1,   276,   277,   278,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-     322,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,   364,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,   394,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,   421,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,    -1,   516,    -1,   518,     9,    10,    -1,
-      -1,    -1,   524,   525,   526,   527,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    43,    44,    -1,    46,    47,    48,    -1,    50,    51,
-      52,    53,    54,    -1,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    -1,
-      -1,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,    -1,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,    -1,
-      -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,    -1,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,    -1,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-      -1,    -1,   224,    -1,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    -1,   270,   271,
-     272,   273,   274,    -1,   276,   277,    -1,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,    -1,   301,
-      -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-      -1,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,    -1,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,    -1,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-      -1,    -1,    -1,    -1,    -1,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   524,   525,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    40,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    79,    -1,    -1,    -1,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,   162,   163,   164,   165,   166,   167,
-     168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-     218,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,   296,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,   447,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,    -1,     5,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   519,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,
-      -1,    50,    51,    52,    53,    54,    -1,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    -1,    75,    76,    77,    78,
-      79,    -1,    -1,    -1,    83,    84,    85,    86,    87,    88,
-      -1,    90,    91,    92,    -1,    94,    95,    96,    97,    98,
-      99,    -1,    -1,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,    -1,   163,   164,   165,   166,    -1,   168,
-      -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,    -1,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-      -1,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-      -1,   270,   271,   272,   273,   274,    -1,   276,   277,    -1,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,    -1,   301,    -1,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,    -1,   323,   324,   325,   326,   327,   328,
-      -1,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,    -1,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,    -1,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,    -1,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,    -1,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,    -1,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,
-     519,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    34,    35,    -1,    37,    -1,    -1,
-      -1,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    81,    -1,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,   222,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,   235,   236,   237,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,   274,    -1,   276,   277,   278,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,    -1,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,    -1,   417,   418,   419,
-     420,   421,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,   452,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-     480,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,    -1,     3,   504,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    66,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    81,    -1,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,   222,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,    -1,   234,   235,   236,   237,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,   274,    -1,   276,   277,   278,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,   291,   292,   293,   294,    -1,    -1,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,    -1,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,    -1,   417,   418,   419,
-     420,   421,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,   452,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-     480,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,    -1,     3,   504,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    66,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    81,    -1,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,   171,    -1,   173,   174,   175,   176,   177,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,   222,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,    -1,   234,   235,   236,   237,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,   274,    -1,   276,   277,   278,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,   291,   292,   293,   294,    -1,    -1,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,   394,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,   421,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    66,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,   176,   177,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,    -1,   276,   277,   278,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-     291,   292,   293,   294,    -1,    -1,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    66,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    81,
-      -1,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,   171,
-      -1,   173,   174,   175,   176,   177,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,   209,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,   235,   236,   237,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,   274,    -1,   276,   277,   278,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-     322,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,   364,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,   394,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,   421,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
-      43,    44,    -1,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    66,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    81,    -1,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,   171,    -1,
-     173,   174,   175,   176,   177,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,   235,   236,   237,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,    -1,   276,   277,   278,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,    -1,   292,
-     293,   294,    -1,    -1,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,   394,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,   421,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   518,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,   126,   127,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,   172,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,   393,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,    -1,   417,   418,   419,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,   452,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,   480,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,    -1,     3,
-     504,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   518,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,   172,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,   419,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,   452,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,   480,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,    -1,     3,
-     504,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   518,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,   172,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,   419,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,   452,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,   480,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,    -1,     3,
-     504,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   518,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,     3,    -1,
-       5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   518,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    -1,    31,    32,    33,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,
-      -1,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
-      -1,    56,    57,    -1,    59,    60,    61,    62,    63,    64,
-      -1,    -1,    67,    68,    69,    70,    71,    72,    73,    -1,
-      75,    76,    77,    78,    79,    -1,    -1,    -1,    83,    84,
-      85,    86,    87,    88,    -1,    90,    91,    92,    -1,    94,
-      95,    96,    97,    98,    99,    -1,    -1,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,    -1,   118,    -1,   120,   121,   122,   123,   124,
-     125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,
-     135,   136,   137,   138,    -1,   140,   141,   142,    -1,   144,
-     145,   146,    -1,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,    -1,   163,   164,
-     165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,
-     175,   176,    -1,   178,    -1,   180,    -1,   182,   183,   184,
-     185,    -1,   187,   188,   189,   190,   191,   192,   193,    -1,
-     195,   196,   197,   198,    -1,   200,   201,   202,   203,   204,
-     205,   206,    -1,   208,    -1,   210,   211,   212,   213,   214,
-     215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,
-      -1,   226,   227,   228,   229,   230,   231,    -1,    -1,   234,
-      -1,   236,    -1,    -1,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,    -1,   270,   271,   272,   273,   274,
-      -1,   276,   277,    -1,   279,    -1,   281,   282,   283,   284,
-     285,   286,    -1,   288,   289,    -1,    -1,   292,   293,   294,
-      -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-      -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,
-     325,   326,   327,   328,    -1,   330,   331,   332,   333,   334,
-     335,    -1,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,    -1,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,    -1,   362,   363,    -1,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,    -1,    -1,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,    -1,    -1,
-     395,   396,   397,   398,    -1,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-      -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,   424,
-     425,   426,    -1,   428,   429,   430,    -1,    -1,   433,   434,
-     435,   436,   437,    -1,   439,   440,   441,   442,   443,   444,
-     445,   446,    -1,    -1,   449,   450,   451,    -1,   453,   454,
-     455,   456,    -1,   458,   459,   460,   461,   462,   463,   464,
-     465,    -1,   467,    -1,   469,   470,   471,   472,   473,   474,
-     475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,     3,    -1,     5,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   518,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,
-      46,    47,    48,    -1,    50,    51,    52,    53,    54,    -1,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    -1,
-      -1,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    -1,    -1,    83,    84,    85,
-      86,    87,    88,    -1,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,    -1,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,    -1,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,
-     176,    -1,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,    -1,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,    -1,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,    -1,
-     236,    -1,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,    -1,   270,   271,   272,   273,   274,    -1,
-     276,   277,    -1,   279,    -1,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,    -1,   301,    -1,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,    -1,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,    -1,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,    -1,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,    -1,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,    -1,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,     3,    -1,     5,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   518,    -1,    -1,    22,    23,    24,    25,    26,
-      27,    28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,
-      47,    48,    -1,    50,    51,    52,    53,    54,    -1,    56,
-      57,    -1,    59,    60,    61,    62,    63,    64,    -1,    -1,
-      67,    68,    69,    70,    71,    72,    73,    -1,    75,    76,
-      77,    78,    79,    -1,    -1,    -1,    83,    84,    85,    86,
-      87,    88,    -1,    90,    91,    92,    -1,    94,    95,    96,
-      97,    98,    99,    -1,    -1,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-      -1,   118,    -1,   120,   121,   122,   123,   124,   125,    -1,
-      -1,   128,   129,   130,   131,    -1,    -1,   134,   135,   136,
-     137,   138,    -1,   140,   141,   142,    -1,   144,   145,   146,
-      -1,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,    -1,   163,   164,   165,   166,
-      -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,
-      -1,   178,    -1,   180,    -1,   182,   183,   184,   185,    -1,
-     187,   188,   189,   190,   191,   192,   193,    -1,   195,   196,
-     197,   198,    -1,   200,   201,   202,   203,   204,   205,   206,
-      -1,   208,    -1,   210,   211,   212,   213,   214,   215,   216,
-     217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,
-     227,   228,   229,   230,   231,    -1,    -1,   234,    -1,   236,
-      -1,    -1,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,    -1,   270,   271,   272,   273,   274,    -1,   276,
-     277,    -1,   279,    -1,   281,   282,   283,   284,   285,   286,
-      -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,
-     297,   298,   299,    -1,   301,    -1,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,    -1,    -1,
-      -1,    -1,   319,   320,   321,    -1,   323,   324,   325,   326,
-     327,   328,    -1,   330,   331,   332,   333,   334,   335,    -1,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-      -1,   348,   349,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,    -1,   362,   363,    -1,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,    -1,    -1,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,    -1,    -1,   395,   396,
-     397,   398,    -1,   400,   401,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,    -1,    -1,
-     417,   418,    -1,   420,    -1,   422,   423,   424,   425,   426,
-      -1,   428,   429,   430,    -1,    -1,   433,   434,   435,   436,
-     437,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,   450,   451,    -1,   453,   454,   455,   456,
-      -1,   458,   459,   460,   461,   462,   463,   464,   465,    -1,
-     467,    -1,   469,   470,   471,   472,   473,   474,   475,    -1,
-      -1,   478,    -1,    -1,   481,   482,   483,   484,   485,   486,
-     487,   488,   489,   490,   491,   492,   493,   494,   495,   496,
-     497,   498,   499,   500,   501,     3,    -1,     5,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   518,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    79,    -1,    -1,    -1,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,    -1,     5,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     518,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,
-      -1,    50,    51,    52,    53,    54,    -1,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    -1,    75,    76,    77,    78,
-      79,    -1,    -1,    -1,    83,    84,    85,    86,    87,    88,
-      -1,    90,    91,    92,    -1,    94,    95,    96,    97,    98,
-      99,    -1,    -1,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,    -1,   163,   164,   165,   166,    -1,   168,
-      -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,    -1,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-      -1,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-      -1,   270,   271,   272,   273,   274,    -1,   276,   277,    -1,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,    -1,   301,    -1,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,    -1,   323,   324,   325,   326,   327,   328,
-      -1,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,    -1,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,    -1,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,    -1,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,    -1,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,    -1,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,
-      50,    51,    52,    53,    54,    -1,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    -1,    -1,    83,    84,    85,    86,    87,    88,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,    -1,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,    -1,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,    -1,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,    -1,
-     270,   271,   272,   273,   274,    -1,   276,   277,    -1,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-      -1,   301,    -1,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,    -1,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,    -1,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,    -1,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,    -1,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,    -1,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,    50,
-      51,    52,    53,    54,    -1,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      -1,    -1,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-      -1,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-      -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,    -1,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,    -1,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,    -1,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,    -1,
-     301,    -1,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,    -1,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,    -1,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-      -1,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,    -1,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    43,    44,    -1,    46,    47,    48,    -1,    50,    51,
-      52,    53,    54,    -1,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    -1,
-      -1,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,    -1,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,    -1,
-      -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,    -1,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,    -1,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-      -1,    -1,   224,    -1,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    -1,   270,   271,
-     272,   273,   274,    -1,   276,   277,    -1,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,    -1,   301,
-      -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-      -1,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,    -1,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,    -1,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   518,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      43,    44,    -1,    46,    47,    48,    -1,    50,    51,    52,
-      53,    54,    -1,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    -1,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,    -1,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,
-      -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,    -1,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,    -1,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,    -1,
-      -1,   224,    -1,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,    -1,   270,   271,   272,
-     273,   274,    -1,   276,   277,    -1,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,    -1,   292,
-     293,   294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,    -1,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,    -1,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,    -1,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,    -1,
-       3,     4,     5,    -1,    -1,     8,     9,    -1,    -1,    -1,
-      -1,    -1,    15,    16,    -1,   518,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      -1,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    -1,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,    -1,
-     153,   154,   155,   156,   157,   158,    -1,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,    -1,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,    -1,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,    -1,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,    -1,   300,   301,   302,
-      -1,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,    -1,   322,
-     323,   324,    -1,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,    -1,   415,   416,   417,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
-     433,   434,    -1,   436,    -1,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
-     453,   454,   455,   456,   457,   458,   459,   460,   461,   462,
-      -1,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   484,   485,   486,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   498,   499,   500,   501,    -1,
-       3,    -1,   505,   506,   507,     8,   509,   510,   511,   512,
-     513,   514,    15,    16,    -1,    -1,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      43,    44,    -1,    46,    47,    48,    -1,    50,    51,    52,
-      53,    54,    -1,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    -1,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,    -1,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,
-      -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,    -1,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,    -1,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,    -1,
-      -1,   224,    -1,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,    -1,   270,   271,   272,
-     273,   274,    -1,   276,   277,    -1,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,    -1,   292,
-     293,   294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,    -1,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,    -1,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,    -1,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,    -1,
-      -1,    -1,   505,   506,   507,    -1,   509,   510,   511,   512,
-     513,   514,     8,    -1,    -1,    11,    -1,    -1,    -1,    15,
-      16,    17,    18,    19,    20,    21,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      46,     8,    -1,    -1,    11,    -1,    -1,    53,    15,    16,
-      17,    18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    -1,    -1,    80,    -1,    -1,    -1,    -1,    46,
-       8,    -1,    -1,    11,    -1,    -1,    53,    15,    16,    17,
-      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    36,    -1,
-      -1,    -1,    -1,    80,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,    -1,    53,    -1,    -1,     8,    -1,
-      -1,    11,    -1,    -1,    -1,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    80,    -1,    -1,    -1,    36,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    46,     8,    -1,    -1,
-      11,   177,    -1,    53,    15,    16,    17,    18,    19,    20,
-      21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   194,    -1,
-      -1,    -1,    -1,   199,    -1,    36,    -1,    -1,    -1,    -1,
-      80,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
-     177,    -1,    53,    -1,    -1,    -1,   222,   223,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   194,    -1,    -1,
-      -1,   237,   199,    -1,    -1,    -1,    -1,    -1,    -1,    80,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   177,
-      -1,    -1,    -1,    -1,    -1,   222,   223,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   194,    -1,    -1,   275,
-     237,   199,   278,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   292,    -1,    -1,   295,
-      -1,    -1,    -1,    -1,   222,   223,    -1,   177,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   275,   237,
-      -1,   278,    -1,    -1,   194,    -1,    -1,    -1,    -1,   199,
-      -1,    -1,    -1,    -1,    -1,   292,    -1,    -1,   295,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   177,    -1,    -1,    -1,
-      -1,    -1,   222,   223,    -1,    -1,    -1,   275,    -1,    -1,
-     278,    -1,    -1,   194,    -1,    -1,    -1,   237,   199,    -1,
-      -1,    -1,    -1,    -1,   292,    -1,    -1,   295,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   222,   223,    -1,    -1,    -1,    -1,    -1,   394,    -1,
-      -1,    -1,    -1,    -1,    -1,   275,   237,    -1,   278,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   292,    -1,    -1,   295,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   394,    -1,    -1,
-      -1,    -1,    -1,    -1,   275,    -1,    -1,   278,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   292,    -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   502,    -1,    -1,   505,
-     506,   507,    -1,   509,   510,   511,   512,   513,   514,    -1,
-      -1,    -1,    -1,   519,   394,    -1,    -1,    -1,    -1,    -1,
-       8,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,    17,
-      18,    19,    20,    21,    -1,   502,    -1,    -1,   505,   506,
-     507,    -1,   509,   510,   511,   512,   513,   514,    36,    -1,
-      -1,    -1,   519,   394,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   502,    -1,    -1,   505,   506,   507,
-      -1,   509,   510,   511,   512,   513,   514,    -1,    -1,    -1,
-      -1,   519,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,
-      11,    -1,    -1,    -1,    15,    16,    17,    18,    19,    20,
-      21,    -1,   502,    -1,    -1,   505,   506,   507,    -1,   509,
-     510,   511,   512,   513,   514,    36,    -1,    -1,    -1,   519,
-      -1,    -1,    -1,    -1,    -1,    46,     8,    -1,    -1,    11,
-      -1,    -1,    53,    15,    16,    17,    18,    19,    20,    21,
-      -1,   502,    -1,    -1,   505,   506,   507,    -1,   509,   510,
-     511,   512,   513,   514,    36,    -1,    -1,    -1,   519,    80,
-      -1,    -1,    -1,    -1,    46,     8,    -1,    -1,    11,   177,
-      -1,    53,    15,    16,    17,    18,    19,    20,    21,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   194,    -1,    -1,    -1,
-      -1,   199,    -1,    36,    -1,    -1,    -1,    -1,    80,    -1,
-      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      53,    -1,    -1,    -1,   222,   223,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   237,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,     8,    -1,    -1,    11,   177,    -1,    -1,    15,
-      16,    17,    18,    19,    20,    21,    -1,   275,    -1,    -1,
-     278,    -1,    -1,   194,    -1,    -1,    -1,    -1,   199,    -1,
-      36,    -1,    -1,    -1,   292,    -1,    -1,   295,    -1,    -1,
-      46,    -1,    -1,    -1,    -1,   177,    -1,    53,    -1,    -1,
-      -1,   222,   223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   194,    -1,    -1,    -1,   237,   199,    -1,    -1,
-      -1,    -1,    -1,    -1,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,
-     222,   223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   194,    -1,    -1,   275,   237,   199,   278,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   292,    -1,    -1,   295,    -1,    -1,    -1,    -1,   222,
-     223,    -1,    -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,
-      -1,    -1,    -1,   275,   237,    -1,   278,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     292,    -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   177,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   275,    -1,    -1,   278,    -1,    -1,   194,    -1,
-      -1,    -1,    -1,   199,    -1,    -1,    -1,    -1,    -1,   292,
-      -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   222,   223,    -1,    -1,
-      -1,    -1,    -1,   394,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   502,    -1,    -1,   505,   506,   507,
-      -1,   509,   510,   511,   512,   513,   514,    -1,    -1,    -1,
-      -1,   519,   394,    -1,    -1,    -1,    -1,    -1,    -1,   275,
-      -1,    -1,   278,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-       8,    -1,    -1,    11,    -1,    -1,   292,    15,    16,   295,
-      -1,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,     8,
-      -1,   394,    11,    -1,    -1,    -1,    15,    16,    17,    18,
-      19,    20,    21,    -1,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,    -1,    53,    -1,    36,    -1,    -1,
-      -1,   502,    -1,    -1,   505,   506,   507,    46,   509,   510,
-     511,   512,   513,   514,    53,    -1,    -1,    -1,   519,    -1,
-      -1,    -1,    80,    -1,    -1,    -1,     8,    -1,    -1,    11,
-      -1,    -1,    -1,    15,    16,    17,    18,    19,    20,    21,
-     502,    80,    -1,   505,   506,   507,    -1,   509,   510,   511,
-     512,   513,   514,    -1,    36,    -1,    -1,   519,   394,    -1,
-      -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,
-      -1,    53,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,
-      -1,    -1,   505,   506,   507,    -1,   509,   510,   511,   512,
-     513,   514,    -1,    -1,   517,    -1,    -1,    -1,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   177,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   194,    -1,   177,    -1,
-      -1,   199,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   194,    -1,    -1,    -1,    -1,
-     199,    -1,    -1,    -1,   222,   223,   502,    -1,    -1,   505,
-     506,   507,    -1,   509,   510,   511,   512,   513,   514,   237,
-      -1,   517,    -1,   222,   223,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   177,    -1,    -1,   237,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   194,    -1,    -1,    -1,    -1,   199,    -1,    -1,
-     278,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   292,    -1,   275,    -1,    -1,   278,
-     222,   223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   292,    -1,   237,   295,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   275,    -1,    -1,   278,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     292,    -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   394,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   502,    -1,    -1,   505,   506,   507,
-      -1,   509,   510,   511,   512,   513,   514,    -1,    -1,    -1,
-      -1,    -1,    -1,   502,    -1,    -1,   505,   506,   507,    -1,
-     509,   510,   511,   512,   513,   514,    -1,    -1,   517,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,    -1,    -1,
-     502,    -1,    -1,   505,   506,   507,    -1,   509,   510,   511,
-     512,   513,   514,    -1,    -1,   517,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
-     206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
-     236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
-     296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,   421,   422,   423,   424,   425,
-     426,   427,   428,   429,   430,   431,   432,   433,   434,   435,
-     436,   437,   438,   439,   440,   441,   442,   443,   444,   445,
-     446,   447,   448,   449,   450,   451,   452,   453,   454,   455,
-     456,   457,   458,   459,   460,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,     3,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   511,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,
-      27,    28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,
-      47,    48,    -1,    50,    51,    52,    53,    54,    -1,    56,
-      57,    -1,    59,    60,    61,    62,    63,    64,    -1,    -1,
-      67,    68,    69,    70,    71,    72,    73,    -1,    75,    76,
-      77,    78,    79,    -1,    -1,    -1,    83,    84,    85,    86,
-      87,    88,    -1,    90,    91,    92,    -1,    94,    95,    96,
-      97,    98,    99,    -1,    -1,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-      -1,   118,    -1,   120,   121,   122,   123,   124,   125,    -1,
-      -1,   128,   129,   130,   131,    -1,    -1,   134,   135,   136,
-     137,   138,    -1,   140,   141,   142,    -1,   144,   145,   146,
-      -1,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,    -1,   163,   164,   165,   166,
-      -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,
-      -1,   178,    -1,   180,    -1,   182,   183,   184,   185,    -1,
-     187,   188,   189,   190,   191,   192,   193,    -1,   195,   196,
-     197,   198,    -1,   200,   201,   202,   203,   204,   205,   206,
-      -1,   208,    -1,   210,   211,   212,   213,   214,   215,   216,
-     217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,
-     227,   228,   229,   230,   231,    -1,    -1,   234,    -1,   236,
-      -1,    -1,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,    -1,   270,   271,   272,   273,   274,    -1,   276,
-     277,    -1,   279,    -1,   281,   282,   283,   284,   285,   286,
-      -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,
-     297,   298,   299,    -1,   301,    -1,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,    -1,    -1,
-      -1,    -1,   319,   320,   321,    -1,   323,   324,   325,   326,
-     327,   328,    -1,   330,   331,   332,   333,   334,   335,    -1,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-      -1,   348,   349,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,    -1,   362,   363,    -1,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,    -1,    -1,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,    -1,    -1,   395,   396,
-     397,   398,    -1,   400,   401,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,    -1,    -1,
-     417,   418,    -1,   420,    -1,   422,   423,   424,   425,   426,
-      -1,   428,   429,   430,    -1,    -1,   433,   434,   435,   436,
-     437,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,   450,   451,    -1,   453,   454,   455,   456,
-      -1,   458,   459,   460,   461,   462,   463,   464,   465,    -1,
-     467,    -1,   469,   470,   471,   472,   473,   474,   475,    -1,
-      -1,   478,    -1,    -1,   481,   482,   483,   484,   485,   486,
-     487,   488,   489,   490,   491,   492,   493,   494,   495,   496,
-     497,   498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   511,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    79,    -1,    -1,    -1,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,     4,     5,    -1,    -1,    -1,
-       9,    -1,    -1,   511,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    -1,    31,    32,    33,    -1,    -1,    -1,    37,    -1,
-      -1,    -1,    -1,    42,    43,    44,    -1,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    -1,    75,    76,    77,    78,
-      79,    -1,    81,    -1,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    -1,    94,    95,    96,    97,    98,
-      99,    -1,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,    -1,   163,   164,   165,   166,    -1,   168,
-      -1,   170,   171,    -1,   173,   174,   175,   176,   177,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,   235,   236,   237,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,    -1,   276,   277,   278,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,   290,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-      -1,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,   364,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,   394,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,   421,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,    -1,    -1,     8,    -1,    -1,    11,    -1,
-     509,   510,    15,    16,    17,    18,    19,    20,    21,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,    41,    -1,
-      -1,    -1,    -1,    46,     8,    -1,    -1,    11,    -1,    -1,
-      53,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    36,    -1,    -1,    -1,    -1,    80,    -1,    -1,
-      -1,    -1,    46,     8,    -1,    -1,    11,    -1,    -1,    53,
-      15,    16,    17,    18,    19,    20,    21,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    36,    -1,    -1,    -1,    -1,    80,    -1,    -1,    -1,
-      -1,    46,    -1,   126,    -1,    -1,    -1,    -1,    53,    -1,
-       8,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,    17,
-      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    80,    -1,    -1,    36,    -1,
-      -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,   177,    53,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   194,    -1,    -1,    -1,    -1,   199,    -1,    -1,    -1,
-      -1,    -1,    80,   167,    -1,    -1,    -1,    -1,   172,    -1,
-      -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,   222,
-     223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     194,    -1,    -1,    -1,   237,   199,    -1,    -1,    -1,    -1,
-      -1,   166,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,   222,   223,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   194,
-      -1,    -1,   275,   237,   199,   278,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   292,
-      -1,    -1,   295,    -1,    -1,    -1,    -1,   222,   223,   177,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   275,   237,    -1,   278,    -1,   194,    -1,    -1,    -1,
-      -1,   199,    -1,    -1,    -1,    -1,    -1,    -1,   292,    -1,
-      -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   222,   223,    -1,    -1,    -1,    -1,
-     275,    -1,    -1,   278,    -1,    -1,    -1,    -1,    -1,   237,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   292,    -1,    -1,
-     295,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   394,    -1,    -1,    -1,    -1,    -1,   275,    -1,   324,
-     278,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   292,    -1,    -1,   295,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,    11,    -1,
-     394,    -1,    15,    16,    17,    18,    19,    20,    21,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    36,   457,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,   394,
-      53,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,   502,
-      -1,    -1,   505,   506,   507,    -1,   509,   510,   511,   512,
-     513,   514,    -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,    -1,
-      -1,   505,   506,   507,    -1,   509,   510,   511,   512,   513,
-     514,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,    -1,    -1,
-     505,   506,   507,    -1,   509,   510,   511,   512,   513,   514,
-      -1,    -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-       8,   194,    -1,    11,    -1,    -1,   199,    15,    16,    17,
-      18,    19,    20,    21,   502,    -1,    -1,   505,   506,   507,
-      -1,   509,   510,   511,   512,   513,   514,    -1,    36,   222,
-     223,    -1,    40,    -1,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,   237,    53,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,    11,
-      -1,    -1,    80,    15,    16,    17,    18,    19,    20,    21,
-      -1,    -1,   275,    -1,    -1,   278,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,   292,
-      -1,    -1,   295,    -1,    46,    -1,    -1,    -1,    -1,    -1,
-      -1,    53,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   318,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,    11,    -1,
-      -1,    -1,    15,    16,    17,    18,    19,    20,    21,   177,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,   194,    40,    -1,    -1,
-      -1,   199,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      53,   394,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   222,   223,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,   237,
-     172,    -1,    -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   194,    -1,    -1,    -1,    -1,   199,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   275,    -1,    -1,
-     278,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     222,   223,    -1,    -1,   292,    -1,    -1,   295,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,
-      -1,    -1,   505,   506,   507,    -1,   509,   510,   511,   512,
-     513,   514,    -1,    -1,   177,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   275,    -1,    -1,   278,    -1,    -1,    -1,
-      -1,   194,    -1,    -1,    -1,    -1,   199,    -1,    -1,    -1,
-     292,    -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,     8,    -1,    -1,    11,    -1,   222,
-     223,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
-      -1,    -1,    -1,    -1,   237,    -1,   394,    -1,    -1,    -1,
-      -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    53,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,     8,   275,    -1,    11,   278,    -1,    -1,    15,    16,
-      17,    18,    19,    20,    21,    -1,    80,    -1,    -1,   292,
-      -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,   394,    -1,    -1,    -1,    -1,    -1,    -1,    46,
-      -1,    -1,    -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    80,   502,    -1,    -1,   505,   506,   507,
-      -1,   509,   510,   511,   512,   513,   514,    -1,     8,    -1,
-      -1,    11,    -1,    -1,    -1,    15,    16,    17,    18,    19,
-      20,    21,    -1,   167,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   177,    -1,    -1,    36,    -1,    -1,    -1,
-      40,   394,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,
-     194,    -1,    -1,    53,    -1,   199,    -1,    -1,    -1,    -1,
-     502,    -1,    -1,   505,   506,   507,    -1,   509,   510,   511,
-     512,   513,   514,    -1,    -1,    -1,    -1,    -1,   222,   223,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     177,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   194,    -1,    -1,
-      -1,    -1,   199,    -1,    -1,    -1,    -1,     8,    -1,    -1,
-      11,    -1,    -1,    -1,    15,    16,    17,    18,    19,    20,
-      21,   275,    -1,    -1,   278,   222,   223,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,   292,   502,
-     237,   295,   505,   506,   507,    46,   509,   510,   511,   512,
-     513,   514,    53,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   177,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   275,    80,
-      -1,   278,    -1,    -1,   194,    -1,    -1,    -1,    -1,   199,
-      -1,    -1,    -1,    -1,    -1,   292,    -1,    -1,   295,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,
-      11,    -1,   222,   223,    15,    16,    17,    18,    19,    20,
-      21,    -1,    -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,
-     394,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
-      -1,    -1,    53,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   275,    -1,    -1,   278,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   177,    -1,    -1,    80,
-      -1,    -1,   292,    -1,    -1,   295,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   194,    -1,    -1,     8,   394,   199,    11,
-      -1,    -1,    -1,    15,    16,    17,    18,    19,    20,    21,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   222,   223,    -1,    36,    -1,    -1,    -1,    -1,    -1,
-     427,    -1,    -1,    -1,    46,    -1,   237,    -1,    -1,    -1,
-      -1,    53,    -1,    -1,    -1,    -1,    -1,    -1,   502,    -1,
-      -1,   505,   506,   507,    -1,   509,   510,   511,   512,   513,
-     514,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,
-      -1,    -1,    -1,    -1,   275,    -1,   177,   278,    -1,    -1,
-      -1,    -1,    -1,    -1,   394,    -1,    -1,    -1,    -1,    -1,
-      -1,   292,    -1,   194,   295,    -1,    -1,    -1,   199,    -1,
-      -1,    -1,    -1,    -1,    -1,   502,    -1,    -1,   505,   506,
-     507,    -1,   509,   510,   511,   512,   513,   514,    -1,    -1,
-      -1,   222,   223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   177,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   275,    -1,    -1,   278,    -1,    -1,
-      -1,    -1,   194,    -1,    -1,    -1,    -1,   199,    -1,    -1,
-      -1,   292,   502,   394,   295,   505,   506,   507,    -1,   509,
-     510,   511,   512,   513,   514,    -1,    -1,    -1,    -1,    -1,
-     222,   223,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   275,    -1,    -1,   278,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     292,    -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   394,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   502,    -1,    -1,   505,   506,   507,    -1,   509,   510,
-     511,   512,   513,   514,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   394,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   502,    -1,    -1,   505,   506,   507,    -1,   509,   510,
-     511,   512,   513,   514,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,     3,    -1,     5,    -1,    -1,    -1,
-     502,    -1,    -1,   505,   506,   507,    -1,   509,   510,   511,
-     512,   513,   514,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
-     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
-     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
-      60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-     430,   431,   432,   433,   434,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   447,   448,   449,
-     450,   451,   452,   453,   454,   455,   456,   457,   458,   459,
-     460,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,   432,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
-     451,   452,   453,   454,   455,   456,   457,   458,   459,   460,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
-      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
-     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-     332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,   430,   431,
-     432,   433,   434,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   445,   446,   447,   448,   449,   450,   451,
-     452,   453,   454,   455,   456,   457,   458,   459,   460,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
-     433,   434,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
-     453,   454,   455,   456,   457,   458,   459,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,     3,
-      -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    42,    43,
-      44,    -1,    46,    47,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    81,    -1,    83,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,   101,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,   160,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,   171,    -1,   173,
-     174,   175,   176,   177,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,   209,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,   222,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,   235,   236,   237,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-     274,    -1,   276,   277,   278,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,   290,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,   321,   322,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-     364,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,   383,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-     394,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,    -1,   420,   421,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,   438,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    -1,    31,    32,    33,    34,
-      35,    -1,    37,    -1,    -1,    -1,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    -1,    59,    60,    61,    62,    63,    64,
-      -1,    -1,    67,    68,    69,    70,    71,    72,    73,    -1,
-      75,    76,    77,    78,    79,    -1,    81,    -1,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    -1,    94,
-      95,    96,    97,    98,    99,    -1,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,    -1,   118,    -1,   120,   121,   122,   123,   124,
-     125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,
-     135,   136,   137,   138,    -1,   140,   141,   142,    -1,   144,
-     145,   146,    -1,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,    -1,   163,   164,
-     165,   166,    -1,   168,    -1,   170,   171,    -1,   173,   174,
-     175,   176,   177,   178,    -1,   180,    -1,   182,   183,   184,
-     185,    -1,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,    -1,   200,   201,   202,   203,   204,
-     205,   206,    -1,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,    -1,   219,    -1,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,    -1,    -1,   234,
-     235,   236,   237,    -1,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-      -1,   276,   277,   278,   279,    -1,   281,   282,   283,   284,
-     285,   286,    -1,   288,   289,    -1,    -1,   292,   293,   294,
-      -1,    -1,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-      -1,    -1,    -1,    -1,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,    -1,   330,   331,   332,   333,   334,
-     335,    -1,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,    -1,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,    -1,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,    -1,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,    -1,   394,
-     395,   396,   397,   398,    -1,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-      -1,    -1,   417,   418,    -1,   420,   421,   422,   423,   424,
-     425,   426,    -1,   428,   429,   430,    -1,    -1,   433,   434,
-     435,   436,   437,    -1,   439,   440,   441,   442,   443,   444,
-     445,   446,    -1,    -1,   449,   450,   451,    -1,   453,   454,
-     455,   456,    -1,   458,   459,   460,   461,   462,   463,   464,
-     465,    -1,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    -1,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    81,    -1,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,    -1,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,   171,    -1,   173,   174,   175,
-     176,   177,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,   235,
-     236,   237,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,    -1,
-     276,   277,   278,   279,    -1,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,   394,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,   421,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,    -1,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,     3,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,
-      27,    28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    42,    43,    44,    -1,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    -1,    59,    60,    61,    62,    63,    64,    -1,    -1,
-      67,    68,    69,    70,    71,    72,    73,    -1,    75,    76,
-      77,    78,    79,    -1,    81,    -1,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    -1,    94,    95,    96,
-      97,    98,    99,    -1,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-      -1,   118,    -1,   120,   121,   122,   123,   124,   125,    -1,
-      -1,   128,   129,   130,   131,    -1,    -1,   134,   135,   136,
-     137,   138,    -1,   140,   141,   142,    -1,   144,   145,   146,
-      -1,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,    -1,   163,   164,   165,   166,
-      -1,   168,    -1,   170,   171,    -1,   173,   174,   175,   176,
-     177,   178,    -1,   180,    -1,   182,   183,   184,   185,    -1,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,    -1,   200,   201,   202,   203,   204,   205,   206,
-      -1,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,    -1,   219,    -1,   221,   222,   223,   224,   225,   226,
-     227,   228,   229,   230,   231,    -1,    -1,   234,   235,   236,
-     237,    -1,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,    -1,   276,
-     277,   278,   279,    -1,   281,   282,   283,   284,   285,   286,
-      -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,    -1,    -1,
-      -1,    -1,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,    -1,   330,   331,   332,   333,   334,   335,    -1,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-      -1,   348,   349,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,    -1,   362,   363,   364,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,    -1,    -1,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,    -1,   394,   395,   396,
-     397,   398,    -1,   400,   401,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,    -1,    -1,
-     417,   418,    -1,   420,   421,   422,   423,   424,   425,   426,
-      -1,   428,   429,   430,    -1,    -1,   433,   434,   435,   436,
-     437,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,   450,   451,    -1,   453,   454,   455,   456,
-      -1,   458,   459,   460,   461,   462,   463,   464,   465,    -1,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,    -1,
-      -1,   478,    -1,    -1,   481,   482,   483,   484,   485,   486,
-     487,   488,   489,   490,   491,   492,   493,   494,   495,   496,
-     497,   498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    -1,    -1,    82,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,   169,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-     448,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,
-      -1,    50,    51,    52,    53,    54,    -1,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    -1,    -1,    -1,    83,    84,    85,    86,    87,    88,
-      -1,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,    -1,    -1,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,    -1,   163,   164,   165,   166,    -1,   168,
-     169,   170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,    -1,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-      -1,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,    -1,   236,   237,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-      -1,   270,   271,   272,   273,   274,    -1,   276,   277,    -1,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,    -1,   301,    -1,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,    -1,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,    -1,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,    -1,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,    -1,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,    -1,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,   448,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,    -1,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    34,    35,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,
-      50,    51,    52,    53,    54,    -1,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    -1,    -1,    83,    84,    85,    86,    87,    88,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,    -1,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,    -1,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,    -1,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,    -1,
-     270,   271,   272,   273,   274,    -1,   276,   277,    -1,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-      -1,   301,    -1,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,    -1,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,    -1,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,    -1,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,    -1,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,    -1,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,    50,
-      51,    52,    53,    54,    -1,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      -1,    -1,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-      -1,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-      -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,    -1,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,    -1,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,    -1,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,    -1,
-     301,    -1,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,    -1,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,    -1,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-      -1,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,    -1,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    43,    44,    -1,    46,    47,    48,    -1,    50,    51,
-      52,    53,    54,    -1,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    -1,
-      -1,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,    -1,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,    -1,
-      -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,    -1,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,    -1,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-      -1,    -1,   224,    -1,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    -1,   270,   271,
-     272,   273,   274,    -1,   276,   277,    -1,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,   291,
-     292,   293,   294,    -1,    -1,   297,   298,   299,    -1,   301,
-      -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-      -1,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,    -1,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,    -1,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      43,    44,    -1,    46,    47,    48,    -1,    50,    51,    52,
-      53,    54,    -1,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    -1,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,    -1,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,
-      -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,    -1,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,    -1,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,    -1,
-      -1,   224,    -1,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,    -1,   270,   271,   272,
-     273,   274,    -1,   276,   277,    -1,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,   291,   292,
-     293,   294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,    -1,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,    -1,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,    -1,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,     3,
-      -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,     3,    -1,
-       5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    -1,    31,    32,    33,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,
-      -1,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
-      -1,    56,    57,    -1,    59,    60,    61,    62,    63,    64,
-      -1,    -1,    67,    68,    69,    70,    71,    72,    73,    -1,
-      75,    76,    77,    78,    79,    -1,    -1,    -1,    83,    84,
-      85,    86,    87,    88,    -1,    90,    91,    92,    -1,    94,
-      95,    96,    97,    98,    99,    -1,    -1,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,    -1,   118,    -1,   120,   121,   122,   123,   124,
-     125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,
-     135,   136,   137,   138,    -1,   140,   141,   142,    -1,   144,
-     145,   146,    -1,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,    -1,   163,   164,
-     165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,
-     175,   176,    -1,   178,    -1,   180,    -1,   182,   183,   184,
-     185,    -1,   187,   188,   189,   190,   191,   192,   193,    -1,
-     195,   196,   197,   198,    -1,   200,   201,   202,   203,   204,
-     205,   206,    -1,   208,    -1,   210,   211,   212,   213,   214,
-     215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,
-      -1,   226,   227,   228,   229,   230,   231,    -1,    -1,   234,
-      -1,   236,    -1,    -1,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,    -1,   270,   271,   272,   273,   274,
-      -1,   276,   277,    -1,   279,    -1,   281,   282,   283,   284,
-     285,   286,    -1,   288,   289,    -1,   291,   292,   293,   294,
-      -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-      -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,
-     325,   326,   327,   328,    -1,   330,   331,   332,   333,   334,
-     335,    -1,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,    -1,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,    -1,   362,   363,    -1,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,    -1,    -1,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,    -1,    -1,
-     395,   396,   397,   398,    -1,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-      -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,   424,
-     425,   426,    -1,   428,   429,   430,    -1,    -1,   433,   434,
-     435,   436,   437,    -1,   439,   440,   441,   442,   443,   444,
-     445,   446,    -1,    -1,   449,   450,   451,    -1,   453,   454,
-     455,   456,    -1,   458,   459,   460,   461,   462,   463,   464,
-     465,    -1,   467,    -1,   469,   470,   471,   472,   473,   474,
-     475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,     3,    -1,     5,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,
-      46,    47,    48,    -1,    50,    51,    52,    53,    54,    -1,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    -1,
-      -1,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    -1,    -1,    83,    84,    85,
-      86,    87,    88,    -1,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,    -1,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,    -1,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,
-     176,    -1,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,    -1,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,    -1,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,    -1,
-     236,    -1,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,    -1,   270,   271,   272,   273,   274,    -1,
-     276,   277,    -1,   279,    -1,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,    -1,   301,    -1,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,    -1,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,    -1,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,   419,   420,    -1,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,    -1,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,    -1,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,     3,    -1,     5,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,
-      27,    28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,
-      47,    48,    -1,    50,    51,    52,    53,    54,    -1,    56,
-      57,    -1,    59,    60,    61,    62,    63,    64,    -1,    -1,
-      67,    68,    69,    70,    71,    72,    73,    -1,    75,    76,
-      77,    78,    79,    -1,    -1,    -1,    83,    84,    85,    86,
-      87,    88,    -1,    90,    91,    92,    -1,    94,    95,    96,
-      97,    98,    99,    -1,    -1,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-      -1,   118,    -1,   120,   121,   122,   123,   124,   125,    -1,
-      -1,   128,   129,   130,   131,    -1,    -1,   134,   135,   136,
-     137,   138,    -1,   140,   141,   142,    -1,   144,   145,   146,
-      -1,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,    -1,   163,   164,   165,   166,
-      -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,
-      -1,   178,    -1,   180,    -1,   182,   183,   184,   185,    -1,
-     187,   188,   189,   190,   191,   192,   193,    -1,   195,   196,
-     197,   198,    -1,   200,   201,   202,   203,   204,   205,   206,
-      -1,   208,    -1,   210,   211,   212,   213,   214,   215,   216,
-     217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,
-     227,   228,   229,   230,   231,    -1,    -1,   234,    -1,   236,
-      -1,    -1,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,    -1,   270,   271,   272,   273,   274,    -1,   276,
-     277,    -1,   279,    -1,   281,   282,   283,   284,   285,   286,
-      -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,
-     297,   298,   299,    -1,   301,    -1,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,    -1,    -1,
-      -1,    -1,   319,   320,   321,    -1,   323,   324,   325,   326,
-     327,   328,    -1,   330,   331,   332,   333,   334,   335,    -1,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-      -1,   348,   349,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,    -1,   362,   363,    -1,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,    -1,    -1,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,    -1,    -1,   395,   396,
-     397,   398,    -1,   400,   401,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,    -1,    -1,
-     417,   418,    -1,   420,    -1,   422,   423,   424,   425,   426,
-      -1,   428,   429,   430,    -1,    -1,   433,   434,   435,   436,
-     437,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,   450,   451,    -1,   453,   454,   455,   456,
-      -1,   458,   459,   460,   461,   462,   463,   464,   465,    -1,
-     467,    -1,   469,   470,   471,   472,   473,   474,   475,    -1,
-      -1,   478,    -1,    -1,   481,   482,   483,   484,   485,   486,
-     487,   488,   489,   490,   491,   492,   493,   494,   495,   496,
-     497,   498,   499,   500,   501,     3,    -1,     5,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    79,    -1,    -1,    -1,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,
-      -1,    50,    51,    52,    53,    54,    -1,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    -1,    75,    76,    77,    78,
-      79,    -1,    -1,    -1,    83,    84,    85,    86,    87,    88,
-      -1,    90,    91,    92,    -1,    94,    95,    96,    97,    98,
-      99,    -1,    -1,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,    -1,   163,   164,   165,   166,    -1,   168,
-      -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,    -1,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-      -1,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-      -1,   270,   271,   272,   273,   274,    -1,   276,   277,    -1,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,    -1,   301,    -1,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,    -1,   323,   324,   325,   326,   327,   328,
-      -1,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,    -1,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,    -1,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,    -1,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,    -1,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,    -1,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,
-      50,    51,    52,    53,    54,    -1,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    -1,    -1,    83,    84,    85,    86,    87,    88,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,    -1,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,    -1,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,    -1,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,    -1,
-     270,   271,   272,   273,   274,    -1,   276,   277,    -1,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-      -1,   301,    -1,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,    -1,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,    -1,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,    -1,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,    -1,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,    -1,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,    50,
-      51,    52,    53,    54,    -1,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      -1,    -1,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-      -1,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-      -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,    -1,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,    -1,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,    -1,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,    -1,
-     301,    -1,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,    -1,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,    -1,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-      -1,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,    -1,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    43,    44,    -1,    46,    47,    48,    -1,    50,    51,
-      52,    53,    54,    -1,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    -1,
-      -1,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,    -1,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,    -1,
-      -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,    -1,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,    -1,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-      -1,    -1,   224,    -1,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    -1,   270,   271,
-     272,   273,   274,    -1,   276,   277,    -1,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,    -1,   301,
-      -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-      -1,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,    -1,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,    -1,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      43,    44,    -1,    46,    47,    48,    -1,    50,    51,    52,
-      53,    54,    -1,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    -1,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,    -1,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,
-      -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,    -1,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,    -1,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,    -1,
-      -1,   224,    -1,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,    -1,   270,   271,   272,
-     273,   274,    -1,   276,   277,    -1,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,    -1,   292,
-     293,   294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,    -1,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,    -1,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,    -1,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,     3,
-      -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,     3,    -1,
-       5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    -1,    31,    32,    33,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,
-      -1,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
-      -1,    56,    57,    -1,    59,    60,    61,    62,    63,    64,
-      -1,    -1,    67,    68,    69,    70,    71,    72,    73,    -1,
-      75,    76,    77,    78,    79,    -1,    -1,    -1,    83,    84,
-      85,    86,    87,    88,    -1,    90,    91,    92,    -1,    94,
-      95,    96,    97,    98,    99,    -1,    -1,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,    -1,   118,    -1,   120,   121,   122,   123,   124,
-     125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,
-     135,   136,   137,   138,    -1,   140,   141,   142,    -1,   144,
-     145,   146,    -1,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,    -1,   163,   164,
-     165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,
-     175,   176,    -1,   178,    -1,   180,    -1,   182,   183,   184,
-     185,    -1,   187,   188,   189,   190,   191,   192,   193,    -1,
-     195,   196,   197,   198,    -1,   200,   201,   202,   203,   204,
-     205,   206,    -1,   208,    -1,   210,   211,   212,   213,   214,
-     215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,
-      -1,   226,   227,   228,   229,   230,   231,    -1,    -1,   234,
-      -1,   236,    -1,    -1,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,    -1,   270,   271,   272,   273,   274,
-      -1,   276,   277,    -1,   279,    -1,   281,   282,   283,   284,
-     285,   286,    -1,   288,   289,    -1,    -1,   292,   293,   294,
-      -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-      -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,
-     325,   326,   327,   328,    -1,   330,   331,   332,   333,   334,
-     335,    -1,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,    -1,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,    -1,   362,   363,    -1,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,    -1,    -1,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,    -1,    -1,
-     395,   396,   397,   398,    -1,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-      -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,   424,
-     425,   426,    -1,   428,   429,   430,    -1,    -1,   433,   434,
-     435,   436,   437,    -1,   439,   440,   441,   442,   443,   444,
-     445,   446,    -1,    -1,   449,   450,   451,    -1,   453,   454,
-     455,   456,    -1,   458,   459,   460,   461,   462,   463,   464,
-     465,    -1,   467,    -1,   469,   470,   471,   472,   473,   474,
-     475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,     3,    -1,     5,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,
-      46,    47,    48,    -1,    50,    51,    52,    53,    54,    -1,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    -1,
-      -1,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    -1,    -1,    83,    84,    85,
-      86,    87,    88,    -1,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,    -1,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,    -1,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,
-     176,    -1,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,    -1,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,    -1,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,    -1,
-     236,    -1,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,    -1,   270,   271,   272,   273,   274,    -1,
-     276,   277,    -1,   279,    -1,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,    -1,   301,    -1,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,    -1,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,    -1,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,    -1,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,    -1,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,    -1,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,     3,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,
-      27,    28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    -1,    40,    -1,    -1,    43,    44,    -1,    46,
-      47,    48,    -1,    50,    51,    52,    53,    54,    -1,    56,
-      57,    -1,    59,    60,    61,    62,    63,    64,    -1,    -1,
-      67,    68,    69,    70,    71,    72,    73,    -1,    75,    76,
-      77,    78,    79,    -1,    -1,    -1,    83,    84,    85,    86,
-      87,    88,    -1,    90,    91,    92,    -1,    94,    95,    96,
-      97,    98,    99,    -1,    -1,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-      -1,   118,    -1,   120,   121,   122,   123,   124,   125,    -1,
-      -1,   128,   129,   130,   131,    -1,    -1,   134,   135,   136,
-     137,   138,    -1,   140,   141,   142,    -1,   144,   145,   146,
-      -1,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,    -1,   163,   164,   165,   166,
-      -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,
-      -1,   178,    -1,   180,    -1,   182,   183,   184,   185,    -1,
-     187,   188,   189,   190,   191,   192,   193,    -1,   195,   196,
-     197,   198,    -1,   200,   201,   202,   203,   204,   205,   206,
-      -1,   208,    -1,   210,   211,   212,   213,   214,   215,   216,
-     217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,
-     227,   228,   229,   230,   231,    -1,    -1,   234,    -1,   236,
-      -1,    -1,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,    -1,   270,   271,   272,   273,   274,    -1,   276,
-     277,    -1,   279,    -1,   281,   282,   283,   284,   285,   286,
-      -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,
-     297,   298,   299,    -1,   301,    -1,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,    -1,    -1,
-      -1,    -1,   319,   320,   321,    -1,   323,   324,   325,   326,
-     327,   328,    -1,   330,   331,   332,   333,   334,   335,    -1,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-      -1,   348,   349,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,    -1,   362,   363,    -1,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,    -1,    -1,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,    -1,    -1,   395,   396,
-     397,   398,    -1,   400,   401,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,    -1,    -1,
-     417,   418,    -1,   420,    -1,   422,   423,   424,   425,   426,
-      -1,   428,   429,   430,    -1,    -1,   433,   434,   435,   436,
-     437,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,   450,   451,    -1,   453,   454,   455,   456,
-      -1,   458,   459,   460,   461,   462,   463,   464,   465,    -1,
-     467,    -1,   469,   470,   471,   472,   473,   474,   475,    -1,
-      -1,   478,    -1,    -1,   481,   482,   483,   484,   485,   486,
-     487,   488,   489,   490,   491,   492,   493,   494,   495,   496,
-     497,   498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    40,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    79,    -1,    -1,    -1,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,
-      -1,    50,    51,    52,    53,    54,    -1,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    -1,    75,    76,    77,    78,
-      79,    -1,    -1,    -1,    83,    84,    85,    86,    87,    88,
-      -1,    90,    91,    92,    -1,    94,    95,    96,    97,    98,
-      99,    -1,    -1,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,    -1,   163,   164,   165,   166,    -1,   168,
-      -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,    -1,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-      -1,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-      -1,   270,   271,   272,   273,   274,    -1,   276,   277,    -1,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,    -1,   301,    -1,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,    -1,   323,   324,   325,   326,   327,   328,
-      -1,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,    -1,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,    -1,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,    -1,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,    -1,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,    -1,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,
-      50,    51,    52,    53,    54,    -1,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    -1,    -1,    83,    84,    85,    86,    87,    88,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,    -1,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,    -1,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,    -1,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,    -1,
-     270,   271,   272,   273,   274,    -1,   276,   277,    -1,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-      -1,   301,    -1,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,    -1,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,    -1,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,    -1,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,    -1,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,    -1,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,    50,
-      51,    52,    53,    54,    -1,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      -1,    -1,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-      -1,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-      -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,    -1,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,    -1,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,    -1,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,    -1,
-     301,    -1,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,    -1,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,    -1,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-      -1,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,    -1,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    43,    44,    -1,    46,    47,    48,    -1,    50,    51,
-      52,    53,    54,    -1,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    -1,
-      -1,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,    -1,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,    -1,
-      -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,    -1,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,    -1,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-      -1,    -1,   224,    -1,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    -1,   270,   271,
-     272,   273,   274,    -1,   276,   277,    -1,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,    -1,   301,
-      -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-      -1,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,    -1,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,    -1,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      43,    44,    -1,    46,    47,    48,    -1,    50,    51,    52,
-      53,    54,    -1,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    -1,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,    -1,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,
-      -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,    -1,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,    -1,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,    -1,
-      -1,   224,    -1,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,    -1,   270,   271,   272,
-     273,   274,    -1,   276,   277,    -1,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,    -1,   292,
-     293,   294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,    -1,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,    -1,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,    -1,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,     3,
-      -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    -1,    31,    32,    33,    -1,
-      -1,    -1,    37,    -1,    -1,    40,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    51,    52,    -1,    54,
-      55,    56,    57,    -1,    59,    60,    61,    62,    63,    64,
-      -1,    -1,    67,    68,    69,    70,    71,    72,    73,    -1,
-      75,    76,    77,    78,    -1,    -1,    81,    -1,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    -1,    94,
-      95,    96,    97,    98,    99,    -1,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,    -1,   118,    -1,   120,   121,   122,   123,   124,
-     125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,
-     135,   136,   137,   138,    -1,   140,   141,   142,    -1,   144,
-     145,   146,    -1,   148,   149,   150,   151,    -1,   153,   154,
-     155,   156,   157,   158,    -1,    -1,   161,    -1,   163,   164,
-     165,   166,    -1,   168,    -1,   170,   171,    -1,   173,   174,
-     175,   176,   177,   178,    -1,   180,    -1,    -1,    -1,   184,
-     185,    -1,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,    -1,   200,   201,   202,   203,   204,
-     205,   206,    -1,   208,   209,    -1,   211,   212,   213,   214,
-     215,   216,   217,    -1,   219,    -1,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,    -1,    -1,   234,
-     235,   236,   237,    -1,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,    -1,
-      -1,   276,   277,   278,   279,    -1,    -1,   282,   283,   284,
-     285,   286,    -1,   288,   289,    -1,    -1,   292,   293,   294,
-      -1,    -1,   297,   298,    -1,   300,   301,   302,    -1,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-      -1,    -1,    -1,    -1,   319,   320,    -1,   322,   323,   324,
-      -1,   326,   327,   328,    -1,   330,   331,   332,   333,   334,
-     335,    -1,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,    -1,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,    -1,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,    -1,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,    -1,   394,
-     395,   396,   397,   398,    -1,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,    -1,
-      -1,    -1,   417,   418,    -1,   420,   421,   422,   423,   424,
-     425,   426,    -1,   428,   429,   430,    -1,    -1,   433,   434,
-      -1,   436,    -1,    -1,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,    -1,   453,   454,
-     455,   456,    -1,   458,   459,   460,   461,   462,    -1,   464,
-     465,    -1,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,
-     485,   486,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   498,   499,   500,   501,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,    50,
-      51,    52,    53,    54,    -1,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      -1,    -1,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-      -1,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-      -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,    -1,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,    -1,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,    -1,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,    -1,
-     301,    -1,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,    -1,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,    -1,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-      -1,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,    -1,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    43,    44,    -1,    46,    47,    48,    -1,    50,    51,
-      52,    53,    54,    -1,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    79,    -1,    -1,
-      -1,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,    -1,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,    -1,
-      -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,
-     182,   183,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,    -1,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,    -1,   210,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-      -1,    -1,   224,    -1,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    -1,   270,   271,
-     272,   273,   274,    -1,   276,   277,    -1,   279,    -1,   281,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,   299,    -1,   301,
-      -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,
-      -1,   323,   324,   325,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,    -1,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,    -1,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,   435,   436,   437,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,   463,   464,   465,    -1,   467,    -1,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,   487,   488,   489,   490,   491,
-     492,   493,   494,   495,   496,   497,   498,   499,   500,   501,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      43,    44,    -1,    46,    47,    48,    -1,    50,    51,    52,
-      53,    54,    -1,    56,    57,    -1,    59,    60,    61,    62,
-      63,    64,    -1,    -1,    67,    68,    69,    70,    71,    72,
-      73,    -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    97,    98,    99,    -1,    -1,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,    -1,   118,    -1,   120,   121,   122,
-     123,   124,   125,    -1,    -1,   128,   129,   130,   131,    -1,
-      -1,   134,   135,   136,   137,   138,    -1,   140,   141,   142,
-      -1,   144,   145,   146,    -1,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,    -1,
-     163,   164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,
-      -1,   174,   175,   176,    -1,   178,    -1,   180,    -1,   182,
-     183,   184,   185,    -1,   187,   188,   189,   190,   191,   192,
-     193,    -1,   195,   196,   197,   198,    -1,   200,   201,   202,
-     203,   204,   205,   206,    -1,   208,    -1,   210,   211,   212,
-     213,   214,   215,   216,   217,    -1,   219,    -1,   221,    -1,
-      -1,   224,    -1,   226,   227,   228,   229,   230,   231,    -1,
-      -1,   234,    -1,   236,    -1,    -1,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,    -1,   270,   271,   272,
-     273,   274,    -1,   276,   277,    -1,   279,    -1,   281,   282,
-     283,   284,   285,   286,    -1,   288,   289,    -1,    -1,   292,
-     293,   294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,
-     323,   324,   325,   326,   327,   328,    -1,   330,   331,   332,
-     333,   334,   335,    -1,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,    -1,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,    -1,   362,
-     363,    -1,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,    -1,
-      -1,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-      -1,    -1,   395,   396,   397,   398,    -1,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,
-     423,   424,   425,   426,    -1,   428,   429,   430,    -1,    -1,
-     433,   434,   435,   436,   437,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,   450,   451,    -1,
-     453,   454,   455,   456,    -1,   458,   459,   460,   461,   462,
-     463,   464,   465,    -1,   467,    -1,   469,   470,   471,   472,
-     473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,
-     483,   484,   485,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,
-      44,    -1,    46,    47,    48,    -1,    50,    51,    52,    53,
-      54,    -1,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    79,    -1,    -1,    -1,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,    -1,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,
-     174,   175,   176,    -1,   178,    -1,   180,    -1,   182,   183,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-      -1,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,    -1,   210,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,
-     224,    -1,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,    -1,   236,    -1,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,    -1,   270,   271,   272,   273,
-     274,    -1,   276,   277,    -1,   279,    -1,   281,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,
-     324,   325,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,    -1,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,    -1,
-      -1,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,    -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,   435,   436,   437,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,   463,
-     464,   465,    -1,   467,    -1,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
-     494,   495,   496,   497,   498,   499,   500,   501,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    -1,    31,    32,    33,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,
-      -1,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
-      -1,    56,    57,    -1,    59,    60,    61,    62,    63,    64,
-      -1,    -1,    67,    68,    69,    70,    71,    72,    73,    -1,
-      75,    76,    77,    78,    79,    -1,    -1,    -1,    83,    84,
-      85,    86,    87,    88,    -1,    90,    91,    92,    -1,    94,
-      95,    96,    97,    98,    99,    -1,    -1,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,    -1,   118,    -1,   120,   121,   122,   123,   124,
-     125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,
-     135,   136,   137,   138,    -1,   140,   141,   142,    -1,   144,
-     145,   146,    -1,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,    -1,   163,   164,
-     165,   166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,
-     175,   176,    -1,   178,    -1,   180,    -1,   182,   183,   184,
-     185,    -1,   187,   188,   189,   190,   191,   192,   193,    -1,
-     195,   196,   197,   198,    -1,   200,   201,   202,   203,   204,
-     205,   206,    -1,   208,    -1,   210,   211,   212,   213,   214,
-     215,   216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,
-      -1,   226,   227,   228,   229,   230,   231,    -1,    -1,   234,
-      -1,   236,    -1,    -1,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,    -1,   270,   271,   272,   273,   274,
-      -1,   276,   277,    -1,   279,    -1,   281,   282,   283,   284,
-     285,   286,    -1,   288,   289,    -1,    -1,   292,   293,   294,
-      -1,    -1,   297,   298,   299,    -1,   301,    -1,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-      -1,    -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,
-     325,   326,   327,   328,    -1,   330,   331,   332,   333,   334,
-     335,    -1,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,    -1,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,    -1,   362,   363,    -1,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,    -1,    -1,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,    -1,    -1,
-     395,   396,   397,   398,    -1,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-      -1,    -1,   417,   418,    -1,   420,    -1,   422,   423,   424,
-     425,   426,    -1,   428,   429,   430,    -1,    -1,   433,   434,
-     435,   436,   437,    -1,   439,   440,   441,   442,   443,   444,
-     445,   446,    -1,    -1,   449,   450,   451,    -1,   453,   454,
-     455,   456,    -1,   458,   459,   460,   461,   462,   463,   464,
-     465,    -1,   467,    -1,   469,   470,   471,   472,   473,   474,
-     475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,
-      26,    27,    28,    29,    -1,    31,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,
-      46,    47,    48,    -1,    50,    51,    52,    53,    54,    -1,
-      56,    57,    -1,    59,    60,    61,    62,    63,    64,    -1,
-      -1,    67,    68,    69,    70,    71,    72,    73,    -1,    75,
-      76,    77,    78,    79,    -1,    -1,    -1,    83,    84,    85,
-      86,    87,    88,    -1,    90,    91,    92,    -1,    94,    95,
-      96,    97,    98,    99,    -1,    -1,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,    -1,   118,    -1,   120,   121,   122,   123,   124,   125,
-      -1,    -1,   128,   129,   130,   131,    -1,    -1,   134,   135,
-     136,   137,   138,    -1,   140,   141,   142,    -1,   144,   145,
-     146,    -1,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,    -1,   161,    -1,   163,   164,   165,
-     166,    -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,
-     176,    -1,   178,    -1,   180,    -1,   182,   183,   184,   185,
-      -1,   187,   188,   189,   190,   191,   192,   193,    -1,   195,
-     196,   197,   198,    -1,   200,   201,   202,   203,   204,   205,
-     206,    -1,   208,    -1,   210,   211,   212,   213,   214,   215,
-     216,   217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,
-     226,   227,   228,   229,   230,   231,    -1,    -1,   234,    -1,
-     236,    -1,    -1,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,    -1,   270,   271,   272,   273,   274,    -1,
-     276,   277,    -1,   279,    -1,   281,   282,   283,   284,   285,
-     286,    -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,
-      -1,   297,   298,   299,    -1,   301,    -1,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,    -1,
-      -1,    -1,    -1,   319,   320,   321,    -1,   323,   324,   325,
-     326,   327,   328,    -1,   330,   331,   332,   333,   334,   335,
-      -1,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,    -1,   362,   363,    -1,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,    -1,    -1,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,    -1,    -1,   395,
-     396,   397,   398,    -1,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,    -1,
-      -1,   417,   418,    -1,   420,    -1,   422,   423,   424,   425,
-     426,    -1,   428,   429,   430,    -1,    -1,   433,   434,   435,
-     436,   437,    -1,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,   450,   451,    -1,   453,   454,   455,
-     456,    -1,   458,   459,   460,   461,   462,   463,   464,   465,
-      -1,   467,    -1,   469,   470,   471,   472,   473,   474,   475,
-      -1,    -1,   478,    -1,    -1,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,     3,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,
-      27,    28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    46,
-      47,    48,    -1,    50,    51,    52,    53,    54,    -1,    56,
-      57,    -1,    59,    60,    61,    62,    63,    64,    -1,    -1,
-      67,    68,    69,    70,    71,    72,    73,    -1,    75,    76,
-      77,    78,    79,    -1,    -1,    -1,    83,    84,    85,    86,
-      87,    88,    -1,    90,    91,    92,    -1,    94,    95,    96,
-      97,    98,    99,    -1,    -1,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-      -1,   118,    -1,   120,   121,   122,   123,   124,   125,    -1,
-      -1,   128,   129,   130,   131,    -1,    -1,   134,   135,   136,
-     137,   138,    -1,   140,   141,   142,    -1,   144,   145,   146,
-      -1,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,    -1,   163,   164,   165,   166,
-      -1,   168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,
-      -1,   178,    -1,   180,    -1,   182,   183,   184,   185,    -1,
-     187,   188,   189,   190,   191,   192,   193,    -1,   195,   196,
-     197,   198,    -1,   200,   201,   202,   203,   204,   205,   206,
-      -1,   208,    -1,   210,   211,   212,   213,   214,   215,   216,
-     217,    -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,
-     227,   228,   229,   230,   231,    -1,    -1,   234,    -1,   236,
-      -1,    -1,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,    -1,   270,   271,   272,   273,   274,    -1,   276,
-     277,    -1,   279,    -1,   281,   282,   283,   284,   285,   286,
-      -1,   288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,
-     297,   298,   299,    -1,   301,    -1,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,    -1,    -1,
-      -1,    -1,   319,   320,   321,    -1,   323,   324,   325,   326,
-     327,   328,    -1,   330,   331,   332,   333,   334,   335,    -1,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-      -1,   348,   349,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,    -1,   362,   363,    -1,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,    -1,    -1,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,    -1,    -1,   395,   396,
-     397,   398,    -1,   400,   401,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,    -1,    -1,
-     417,   418,    -1,   420,    -1,   422,   423,   424,   425,   426,
-      -1,   428,   429,   430,    -1,    -1,   433,   434,   435,   436,
-     437,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,   450,   451,    -1,   453,   454,   455,   456,
-      -1,   458,   459,   460,   461,   462,   463,   464,   465,    -1,
-     467,    -1,   469,   470,   471,   472,   473,   474,   475,    -1,
-      -1,   478,    -1,    -1,   481,   482,   483,   484,   485,   486,
-     487,   488,   489,   490,   491,   492,   493,   494,   495,   496,
-     497,   498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
-      -1,    -1,    40,    -1,    -1,    43,    44,    -1,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    -1,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    79,    -1,    -1,    -1,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,    -1,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,    -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,
-     178,    -1,   180,    -1,   182,   183,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,    -1,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,    -1,   210,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,    -1,   270,   271,   272,   273,   274,    -1,   276,   277,
-      -1,   279,    -1,   281,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,   299,    -1,   301,    -1,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,   321,    -1,   323,   324,   325,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,    -1,   384,   385,   386,   387,
-     388,    -1,   390,   391,   392,    -1,    -1,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,    -1,    -1,   417,
-     418,    -1,   420,    -1,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,   435,   436,   437,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,   463,   464,   465,    -1,   467,
-      -1,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,   487,
-     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
-     498,   499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
-      29,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,
-      -1,    50,    51,    52,    53,    54,    -1,    56,    57,    -1,
-      59,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
-      69,    70,    71,    72,    73,    -1,    75,    76,    77,    78,
-      79,    -1,    -1,    -1,    83,    84,    85,    86,    87,    88,
-      -1,    90,    91,    92,    -1,    94,    95,    96,    97,    98,
-      99,    -1,    -1,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,    -1,   118,
-      -1,   120,   121,   122,   123,   124,   125,    -1,    -1,   128,
-     129,   130,   131,    -1,    -1,   134,   135,   136,   137,   138,
-      -1,   140,   141,   142,    -1,   144,   145,   146,    -1,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,    -1,   163,   164,   165,   166,    -1,   168,
-      -1,   170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,
-      -1,   180,    -1,   182,   183,   184,   185,    -1,   187,   188,
-     189,   190,   191,   192,   193,    -1,   195,   196,   197,   198,
-      -1,   200,   201,   202,   203,   204,   205,   206,    -1,   208,
-      -1,   210,   211,   212,   213,   214,   215,   216,   217,    -1,
-     219,    -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,
-     229,   230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-      -1,   270,   271,   272,   273,   274,    -1,   276,   277,    -1,
-     279,    -1,   281,   282,   283,   284,   285,   286,    -1,   288,
-     289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,
-     299,    -1,   301,    -1,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,
-     319,   320,   321,    -1,   323,   324,   325,   326,   327,   328,
-      -1,   330,   331,   332,   333,   334,   335,    -1,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,    -1,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,    -1,   362,   363,    -1,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,    -1,    -1,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,    -1,    -1,   395,   396,   397,   398,
-      -1,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,    -1,    -1,   417,   418,
-      -1,   420,    -1,   422,   423,   424,   425,   426,    -1,   428,
-     429,   430,    -1,    -1,   433,   434,   435,   436,   437,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,   450,   451,    -1,   453,   454,   455,   456,    -1,   458,
-     459,   460,   461,   462,   463,   464,   465,    -1,   467,    -1,
-     469,   470,   471,   472,   473,   474,   475,    -1,    -1,   478,
-      -1,    -1,   481,   482,   483,   484,   485,   486,   487,   488,
-     489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
-     499,   500,   501,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,
-      50,    51,    52,    53,    54,    -1,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    -1,    -1,    83,    84,    85,    86,    87,    88,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,    -1,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,
-     180,    -1,   182,   183,   184,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,    -1,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,    -1,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,    -1,
-     270,   271,   272,   273,   274,    -1,   276,   277,    -1,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-      -1,   301,    -1,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,    -1,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,    -1,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,    -1,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,    -1,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,    -1,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,    50,
-      51,    52,    53,    54,    -1,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    79,    -1,
-      -1,    -1,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-      -1,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-      -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,   180,
-      -1,   182,   183,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,    -1,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,    -1,   210,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,    -1,    -1,   224,    -1,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,    -1,   270,
-     271,   272,   273,   274,    -1,   276,   277,    -1,   279,    -1,
-     281,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,   299,    -1,
-     301,    -1,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-     321,    -1,   323,   324,   325,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,    -1,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,    -1,   384,   385,   386,   387,   388,   389,   390,
-     391,   392,    -1,    -1,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,    -1,    -1,   417,   418,    -1,   420,
-      -1,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,   435,   436,   437,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,   463,   464,   465,    -1,   467,    -1,   469,   470,
-     471,   472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
-      32,    33,    -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    51,
-      52,    -1,    54,    55,    56,    57,    -1,    59,    60,    61,
-      62,    63,    64,    -1,    -1,    67,    68,    69,    70,    71,
-      72,    73,    -1,    75,    76,    77,    78,    -1,    -1,    81,
-      -1,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    -1,    94,    95,    96,    97,    98,    99,    -1,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,    -1,   118,    -1,   120,   121,
-     122,   123,   124,   125,    -1,    -1,   128,   129,   130,   131,
-      -1,    -1,   134,   135,   136,   137,   138,    -1,   140,   141,
-     142,    -1,   144,   145,   146,    -1,   148,   149,   150,   151,
-      -1,   153,   154,   155,   156,   157,   158,    -1,    -1,   161,
-      -1,   163,   164,   165,   166,    -1,   168,    -1,   170,   171,
-      -1,   173,   174,   175,    -1,   177,   178,    -1,   180,    -1,
-      -1,    -1,   184,   185,    -1,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,   196,   197,   198,    -1,   200,   201,
-     202,   203,   204,   205,   206,    -1,   208,   209,    -1,   211,
-     212,   213,   214,   215,   216,   217,    -1,   219,    -1,   221,
-     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-      -1,    -1,   234,   235,   236,   237,    -1,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,    -1,    -1,   276,   277,   278,   279,    -1,    -1,
-     282,   283,   284,   285,   286,    -1,   288,   289,    -1,    -1,
-     292,   293,   294,    -1,    -1,   297,   298,    -1,   300,   301,
-     302,    -1,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,    -1,
-     322,   323,   324,    -1,   326,   327,   328,    -1,   330,   331,
-     332,   333,   334,   335,    -1,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
-     362,   363,   364,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-      -1,   383,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,    -1,   394,   395,   396,   397,   398,    -1,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,    -1,    -1,    -1,   417,   418,    -1,   420,   421,
-     422,   423,   424,   425,   426,    -1,   428,   429,   430,    -1,
-      -1,   433,   434,    -1,   436,    -1,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,   450,   451,
-      -1,   453,   454,   455,   456,    -1,   458,   459,   460,   461,
-     462,    -1,   464,   465,    -1,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,    -1,    -1,   478,    -1,    -1,   481,
-     482,   483,   484,   485,   486,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   498,   499,   500,   501,
-      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
-      28,    29,    -1,    31,    32,    33,    -1,    -1,    -1,    37,
-      -1,    -1,    -1,    -1,    42,    43,    44,    -1,    46,    47,
-      48,    49,    50,    51,    52,    -1,    54,    55,    56,    57,
-      -1,    59,    60,    61,    62,    63,    64,    -1,    -1,    67,
-      68,    69,    70,    71,    72,    73,    -1,    75,    76,    77,
-      78,    -1,    -1,    81,    -1,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    -1,    94,    95,    96,    97,
-      98,    99,    -1,   101,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
-     118,    -1,   120,   121,   122,   123,   124,   125,    -1,    -1,
-     128,   129,   130,   131,    -1,    -1,   134,   135,   136,   137,
-     138,    -1,   140,   141,   142,    -1,   144,   145,   146,    -1,
-     148,   149,   150,   151,    -1,   153,   154,   155,   156,   157,
-     158,    -1,    -1,   161,    -1,   163,   164,   165,   166,    -1,
-     168,    -1,   170,   171,    -1,   173,   174,   175,    -1,   177,
-     178,    -1,   180,    -1,    -1,    -1,   184,   185,    -1,   187,
-     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
-     198,    -1,   200,   201,   202,   203,   204,   205,   206,    -1,
-     208,   209,    -1,   211,   212,   213,   214,   215,   216,   217,
-      -1,   219,    -1,   221,   222,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,    -1,    -1,   234,   235,   236,   237,
-      -1,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,    -1,    -1,   276,   277,
-     278,   279,    -1,    -1,   282,   283,   284,   285,   286,    -1,
-     288,   289,    -1,    -1,   292,   293,   294,    -1,    -1,   297,
-     298,    -1,   300,   301,   302,    -1,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,    -1,    -1,    -1,
-      -1,   319,   320,    -1,   322,   323,   324,    -1,   326,   327,
-     328,    -1,   330,   331,   332,   333,   334,   335,    -1,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,    -1,   362,   363,   364,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,    -1,   383,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,    -1,   394,   395,   396,   397,
-     398,    -1,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,    -1,    -1,    -1,   417,
-     418,    -1,   420,   421,   422,   423,   424,   425,   426,    -1,
-     428,   429,   430,    -1,    -1,   433,   434,    -1,   436,    -1,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,   447,
-      -1,   449,   450,   451,    -1,   453,   454,   455,   456,    -1,
-     458,   459,   460,   461,   462,    -1,   464,   465,    -1,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,    -1,    -1,
-     478,    -1,    -1,   481,   482,   483,   484,   485,   486,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     498,   499,   500,   501,    -1,    -1,    -1,    -1,    22,    23,
-      24,    25,    26,    27,    28,    29,    -1,    31,    32,    33,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    42,    43,
-      44,    -1,    46,    47,    48,    49,    50,    51,    52,    -1,
-      54,    55,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    -1,    -1,    67,    68,    69,    70,    71,    72,    73,
-      -1,    75,    76,    77,    78,    -1,    -1,    81,    -1,    83,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    -1,
-      94,    95,    96,    97,    98,    99,    -1,   101,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,    -1,   118,    -1,   120,   121,   122,   123,
-     124,   125,    -1,    -1,   128,   129,   130,   131,    -1,    -1,
-     134,   135,   136,   137,   138,    -1,   140,   141,   142,    -1,
-     144,   145,   146,    -1,   148,   149,   150,   151,    -1,   153,
-     154,   155,   156,   157,   158,    -1,    -1,   161,    -1,   163,
-     164,   165,   166,    -1,   168,    -1,   170,   171,    -1,   173,
-     174,   175,   176,   177,   178,    -1,   180,    -1,    -1,    -1,
-     184,   185,    -1,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,   196,   197,   198,    -1,   200,   201,   202,   203,
-     204,   205,   206,    -1,   208,   209,    -1,   211,   212,   213,
-     214,   215,   216,   217,    -1,   219,    -1,   221,   222,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,    -1,    -1,
-     234,   235,   236,   237,    -1,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-      -1,    -1,   276,   277,   278,   279,    -1,    -1,   282,   283,
-     284,   285,   286,    -1,   288,   289,    -1,    -1,   292,   293,
-     294,    -1,    -1,   297,   298,    -1,   300,   301,   302,    -1,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,    -1,    -1,    -1,    -1,   319,   320,    -1,   322,   323,
-     324,    -1,   326,   327,   328,    -1,   330,   331,   332,   333,
-     334,   335,    -1,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,    -1,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,    -1,   383,
-     384,   385,   386,   387,   388,   389,    -1,   391,   392,    -1,
-     394,   395,   396,   397,   398,    -1,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-      -1,    -1,    -1,   417,   418,    -1,   420,   421,   422,   423,
-     424,   425,   426,    -1,   428,   429,   430,    -1,    -1,   433,
-     434,    -1,   436,    -1,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,   450,   451,    -1,   453,
-     454,   455,   456,    -1,   458,   459,   460,   461,   462,    -1,
-     464,   465,    -1,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,    -1,    -1,   478,    -1,    -1,   481,   482,   483,
-     484,   485,   486,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   498,   499,   500,   501,    -1,    -1,
-      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
-      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    43,    44,    -1,    46,    47,    48,    -1,
-      50,    51,    52,    53,    54,    -1,    56,    57,    -1,    59,
-      60,    61,    62,    63,    64,    -1,    -1,    67,    68,    69,
-      70,    71,    72,    73,    -1,    75,    76,    77,    78,    79,
-      -1,    -1,    -1,    83,    84,    85,    86,    87,    88,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    97,    98,    99,
-      -1,    -1,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,    -1,   118,    -1,
-     120,   121,   122,   123,   124,   125,    -1,    -1,   128,   129,
-     130,   131,    -1,    -1,   134,   135,   136,   137,   138,    -1,
-     140,   141,   142,    -1,   144,   145,   146,    -1,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-      -1,   161,    -1,   163,   164,   165,   166,    -1,   168,    -1,
-     170,    -1,    -1,    -1,   174,   175,   176,    -1,   178,    -1,
-     180,    -1,   182,   183,    -1,   185,    -1,   187,   188,   189,
-     190,   191,   192,   193,    -1,   195,   196,   197,   198,    -1,
-     200,   201,   202,   203,   204,   205,   206,    -1,   208,    -1,
-     210,   211,   212,   213,   214,   215,   216,   217,    -1,   219,
-      -1,   221,    -1,    -1,   224,    -1,   226,   227,   228,   229,
-     230,   231,    -1,    -1,   234,    -1,   236,    -1,    -1,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,    -1,
-     270,   271,   272,   273,   274,    -1,   276,   277,    -1,   279,
-      -1,   281,   282,   283,   284,   285,   286,    -1,   288,   289,
-      -1,    -1,   292,   293,   294,    -1,    -1,   297,   298,   299,
-      -1,   301,    -1,   303,   304,   305,   306,   307,   308,   309,
-      -1,   311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,
-     320,   321,    -1,   323,   324,   325,   326,   327,   328,    -1,
-     330,   331,   332,   333,   334,   335,    -1,   337,   338,   339,
-      -1,   341,   342,   343,   344,   345,   346,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,    -1,   362,   363,    -1,   365,   366,   367,   368,    -1,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,    -1,    -1,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,    -1,    -1,   395,   396,   397,   398,    -1,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,    -1,    -1,   417,   418,    -1,
-     420,    -1,   422,   423,   424,   425,   426,    -1,   428,   429,
-     430,    -1,    -1,   433,   434,   435,   436,   437,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
-     450,   451,    -1,   453,   454,   455,   456,    -1,   458,   459,
-     460,   461,   462,   463,   464,   465,    -1,   467,    -1,   469,
-     470,   471,   472,   473,   474,   475,    -1,    -1,   478,    -1,
-      -1,   481,   482,   483,   484,   485,   486,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
-     500,   501,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    -1,
-      31,    32,    33,    -1,    -1,    -1,    37,    -1,    -1,    -1,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      51,    52,    -1,    54,    55,    56,    57,    -1,    59,    60,
-      61,    62,    63,    64,    -1,    -1,    67,    68,    69,    70,
-      71,    72,    73,    -1,    75,    76,    77,    78,    -1,    -1,
-      81,    -1,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    -1,    94,    95,    96,    97,    98,    99,    -1,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,    -1,   118,    -1,   120,
-     121,   122,   123,   124,   125,    -1,    -1,   128,   129,   130,
-     131,    -1,    -1,   134,   135,   136,   137,   138,    -1,   140,
-     141,   142,    -1,   144,   145,   146,    -1,   148,   149,   150,
-     151,    -1,   153,   154,   155,   156,   157,   158,    -1,    -1,
-     161,    -1,   163,   164,   165,   166,    -1,   168,    -1,   170,
-     171,    -1,   173,   174,   175,    -1,   177,   178,    -1,   180,
-      -1,    -1,    -1,   184,   185,    -1,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,    -1,   200,
-     201,   202,   203,   204,   205,   206,    -1,   208,   209,    -1,
-     211,   212,   213,   214,   215,   216,   217,    -1,   219,    -1,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,    -1,    -1,   234,   235,   236,   237,    -1,   239,   240,
-     241,   242,   243,   244,   245,   246,    -1,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,    -1,    -1,   276,   277,   278,   279,    -1,
-      -1,   282,   283,   284,   285,   286,    -1,   288,   289,    -1,
-      -1,   292,   293,   294,    -1,    -1,   297,   298,    -1,   300,
-     301,   302,    -1,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,    -1,    -1,    -1,    -1,   319,   320,
-      -1,   322,   323,   324,    -1,   326,   327,   328,    -1,   330,
-     331,   332,   333,   334,   335,    -1,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,    -1,   348,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-      -1,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,    -1,   383,   384,   385,   386,   387,   388,   389,    -1,
-     391,   392,    -1,   394,   395,   396,   397,   398,    -1,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,    -1,   413,    -1,    -1,    -1,   417,   418,    -1,   420,
-     421,   422,   423,   424,   425,   426,    -1,   428,   429,   430,
-      -1,    -1,   433,   434,    -1,   436,    -1,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,   450,
-     451,    -1,   453,   454,   455,   456,    -1,   458,   459,   460,
-     461,   462,    -1,   464,   465,    -1,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,    -1,    22,   478,    -1,    -1,
-     481,   482,   483,   484,   485,   486,    32,    -1,    34,    35,
-      -1,    -1,    -1,    -1,    22,    -1,    -1,   498,   499,   500,
-     501,    -1,    -1,    -1,    32,    -1,    52,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    61,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    52,    -1,    -1,    -1,    -1,    75,
-      -1,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,
-      86,    -1,    -1,    -1,    -1,    -1,    -1,    75,    -1,    -1,
-      -1,    -1,    98,    -1,   100,    -1,    -1,    -1,    86,    -1,
-      -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
-      98,    -1,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     126,   127,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   137,    -1,    -1,    -1,    -1,    -1,   143,   126,   127,
-      -1,    -1,    -1,    -1,    -1,   151,    -1,    -1,    -1,   137,
-      -1,    -1,    -1,    -1,    -1,   143,    -1,    -1,    -1,    -1,
-      -1,    -1,   168,   151,    -1,    -1,   172,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     168,    -1,    -1,    -1,   172,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   214,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   214,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   240,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   240,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   315,
-     316,   317,    -1,    -1,    -1,    -1,    -1,   323,    -1,    -1,
-     326,    -1,    -1,    -1,    -1,    -1,    -1,   315,   316,   317,
-      -1,    -1,    -1,    -1,    -1,   323,    -1,    -1,   326,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     366,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   357,
-      -1,    -1,    -1,    -1,    -1,    -1,   382,    -1,   366,    -1,
-      -1,    -1,    -1,   389,    -1,    -1,    -1,   393,    -1,    -1,
-      -1,    -1,    -1,    -1,   382,    -1,    -1,   403,    -1,    -1,
-      -1,   389,    -1,    -1,    -1,   393,    -1,    -1,    -1,   415,
-      -1,    -1,    -1,   419,    -1,   403,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   415,    -1,    -1,
-      -1,   419,    -1,   439,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   452,    -1,    -1,    -1,
-      -1,   439,   458,    -1,    -1,    -1,    -1,   463,    -1,    -1,
-      -1,    -1,   468,    -1,   452,    -1,    -1,    -1,    -1,    -1,
-     458,    -1,    -1,    -1,   480,   463,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   480,    -1,    -1,    -1,    -1,    -1,   504,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   518,    -1,    -1,    -1,   504,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     518
-};
-
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   symbol of state STATE-NUM.  */
-static const yytype_uint16 yystos[] =
-{
-       0,    22,    32,    34,    35,    47,    52,    61,    75,    84,
-      86,    98,   100,   111,   126,   127,   128,   137,   143,   151,
-     153,   154,   168,   172,   198,   240,   315,   316,   317,   323,
-     326,   357,   366,   382,   389,   393,   403,   415,   419,   439,
-     452,   455,   458,   463,   480,   504,   518,   530,   531,   532,
-     533,   544,   553,   555,   560,   576,   579,   580,   582,   586,
-     587,   591,   598,   600,   603,   604,   652,   658,   667,   668,
-     686,   687,   688,   689,   691,   693,   694,   698,   752,   753,
-     935,   938,   941,   948,   949,   951,   954,   955,   956,   963,
-     967,   973,   974,   977,   982,   986,   987,   988,   991,   994,
-     995,   996,   999,  1000,  1002,   433,   483,   601,   203,   373,
-     384,   419,   470,   108,   192,   989,   601,     3,    22,    23,
-      24,    25,    26,    27,    28,    29,    31,    32,    33,    42,
-      43,    44,    46,    47,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    57,    59,    60,    61,    62,    63,    64,
-      67,    68,    69,    70,    71,    72,    73,    75,    76,    77,
-      78,    79,    81,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    94,    95,    96,    97,    98,    99,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   118,   120,   121,   122,   123,
-     124,   125,   128,   129,   130,   131,   134,   135,   136,   137,
-     138,   140,   141,   142,   144,   145,   146,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   161,
-     163,   164,   165,   166,   168,   170,   171,   173,   174,   175,
-     176,   177,   178,   180,   182,   183,   184,   185,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     200,   201,   202,   203,   204,   205,   206,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   219,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   234,
-     235,   236,   237,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   276,
-     277,   278,   279,   281,   282,   283,   284,   285,   286,   288,
-     289,   292,   293,   294,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   330,   331,   332,   333,   334,   335,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-     394,   395,   396,   397,   398,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     417,   418,   420,   421,   422,   423,   424,   425,   426,   428,
-     429,   430,   433,   434,   435,   436,   437,   439,   440,   441,
-     442,   443,   444,   445,   446,   449,   450,   451,   453,   454,
-     455,   456,   458,   459,   460,   461,   462,   463,   464,   465,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   478,
-     481,   482,   483,   484,   485,   486,   487,   488,   489,   490,
-     491,   492,   493,   494,   495,   496,   497,   498,   499,   500,
-     501,   546,   834,   924,   928,  1005,  1006,  1007,     3,   176,
-     247,   412,   546,   950,  1005,   290,   601,    55,   172,   518,
-     681,   178,   241,   295,   314,   373,   423,   425,   442,   448,
-     451,   584,   650,   947,     5,    30,   326,   546,   547,   923,
-       3,    30,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    45,    49,    53,    54,    55,    56,    57,    58,    65,
-      66,    71,    72,    74,    79,    80,    81,    82,    83,    89,
-      93,   100,   101,   108,   112,   115,   117,   119,   126,   127,
-     132,   133,   139,   143,   147,   152,   159,   160,   162,   165,
-     167,   169,   171,   172,   173,   176,   177,   179,   181,   182,
-     183,   186,   194,   199,   207,   209,   210,   216,   217,   218,
-     219,   220,   222,   223,   225,   232,   233,   235,   237,   238,
-     247,   268,   269,   270,   274,   275,   278,   280,   281,   283,
-     287,   290,   291,   295,   296,   299,   300,   302,   303,   315,
-     316,   317,   318,   321,   322,   325,   329,   336,   342,   347,
-     361,   364,   368,   382,   383,   390,   393,   394,   397,   399,
-     412,   414,   415,   416,   419,   421,   427,   429,   430,   431,
-     432,   435,   437,   438,   441,   447,   448,   452,   457,   463,
-     464,   466,   468,   476,   477,   479,   480,   487,   488,   489,
-     490,   491,   492,   493,   494,   495,   496,   497,   552,  1005,
-    1009,  1011,    24,    81,    97,   146,   156,   169,   174,   203,
-     246,   250,   320,   335,   370,   373,   384,   387,   405,   419,
-     425,   426,   436,   442,   470,   584,   653,   654,   657,   601,
-     923,   100,   137,   468,   518,   533,   544,   553,   555,   576,
-     579,   580,   586,   587,   591,   600,   604,   652,   658,   667,
-     668,   686,   935,   938,   941,   948,   949,   959,   963,   967,
-     973,   977,   982,   991,   994,   999,  1000,  1002,   108,    75,
-      66,    79,    81,   159,   232,   281,   291,   303,   321,   369,
-     414,   435,   437,   441,   463,   518,   545,   546,   547,   687,
-     753,   755,   757,   758,   768,   775,   776,   834,   836,   837,
-     108,     5,   546,   548,   975,   546,   923,    30,   178,   241,
-     388,   429,   433,   465,   546,   992,   993,   998,   601,    30,
-     132,   707,   708,   178,   241,   373,   388,   429,   465,   968,
-     969,   998,   601,   545,   546,   547,   686,   698,   775,   419,
-     704,   545,   173,   518,   979,   518,   345,   699,   700,   923,
-     699,   687,   688,   994,     0,   521,   122,   213,   454,   147,
-     218,   296,   447,   710,   711,   758,   758,   687,   689,   691,
-     522,   468,   957,   214,    30,   429,   433,   545,   686,   192,
-     545,   923,   192,   545,   192,   775,   192,   545,   275,   548,
-     341,   602,   516,   520,   549,   550,   518,    82,   108,   174,
-     203,   246,   373,   384,   419,   442,   470,   953,   108,   686,
-     545,   423,   425,   423,   425,   355,   192,   545,   545,   380,
-     174,   246,   345,   384,   419,   470,   665,   203,    30,   923,
-     192,   552,   252,   436,   107,   419,   419,   470,   377,   380,
-     192,   546,   655,   930,   192,   920,   923,   192,   923,   518,
-     590,   295,   425,   959,     3,   463,   960,   962,   963,   965,
-     966,  1005,  1009,   957,   546,   548,   950,   518,   518,   167,
-     518,   687,   776,   518,   518,   545,   518,   518,   172,   518,
-     518,   518,   518,   687,   753,   758,   768,   511,   549,   523,
-      40,   546,   769,   770,   769,   382,   522,   690,   518,   687,
-     775,   776,    37,    42,   101,   173,   209,   225,   235,   269,
-     315,   322,   364,   383,   452,   772,   770,    40,   546,   769,
-     771,   504,   780,   548,   507,   518,   518,   936,   993,   993,
-     993,   501,   224,   993,   520,   290,     4,     6,     7,     8,
-       9,    10,    39,    54,    56,    57,    65,    71,    72,    83,
-     112,   115,   117,   136,   152,   160,   165,   182,   183,   216,
-     217,   219,   247,   268,   270,   275,   280,   283,   292,   342,
-     368,   397,   429,   430,   438,   464,   502,   509,   510,   511,
-     516,   518,   524,   525,   526,   527,   546,   548,   687,   742,
-     792,   795,   798,   799,   800,   802,   803,   804,   805,   807,
-     808,   824,   826,   827,   828,   829,   830,   831,   832,   833,
-     834,   835,   837,   839,   854,   855,   866,   888,   895,   903,
-     904,   905,   924,   925,   926,   902,   904,   968,   968,   548,
-     968,   501,   968,   172,   431,   507,   602,   549,   775,   983,
-       3,   171,   173,   468,   963,   978,   980,   171,   981,   546,
-     824,   872,   873,   699,   522,   518,   932,   519,   519,   519,
-     532,   172,   295,   563,   157,   983,    30,   132,   705,   705,
-      59,   705,   162,   167,   238,   287,   716,   718,   719,   745,
-     747,   748,   749,   181,   290,   457,   290,   710,   711,   518,
-     545,   975,   420,   997,   501,   224,   152,    26,    32,   137,
-     294,   353,   357,   389,   460,   538,   541,   542,   353,   152,
-      40,    60,   106,   202,   251,   261,   273,   305,   353,   359,
-     384,   389,   403,   541,   592,   595,   152,   353,   389,   541,
-     152,   353,   389,   541,   152,    40,   990,   291,   485,   824,
-     896,   551,   552,   550,     3,    30,    37,    42,    49,    55,
-      81,    83,    89,   101,   132,   171,   173,   176,   177,   194,
-     209,   222,   223,   225,   235,   237,   247,   269,   278,   300,
-     302,   322,   364,   383,   394,   412,   421,   441,   466,   468,
-     519,   711,   824,   875,   876,   927,   933,  1005,  1010,   824,
-     419,   545,   546,   519,   518,   639,   373,   584,   650,   275,
-     939,    40,   192,   546,   583,   470,   192,   545,   192,   545,
-    1004,   192,   545,   192,   545,    89,   944,   152,   484,    90,
-     129,   308,   424,   192,   546,   152,   520,   931,    63,   360,
-     522,   656,   152,   522,   656,   152,   290,   588,   589,   824,
-     933,   355,   519,   522,     4,   160,   290,   438,   509,   510,
-     548,   594,   597,   926,   958,   960,   961,   964,   959,   431,
-     518,   676,   680,   824,   873,   518,     3,    68,    69,   109,
-     110,   113,   114,   189,   190,   253,   254,   255,   256,   257,
-     258,   259,   260,   263,   264,   337,   338,   378,   379,   474,
-     475,   498,   499,   548,   810,   811,   812,   813,   814,   815,
-     816,   817,   818,   819,   820,   821,   822,   878,   879,   770,
-     771,   824,   545,   824,   880,   509,   510,   546,   825,   826,
-     855,   866,   882,   518,   824,   872,   883,   824,    58,   172,
-     233,   432,   824,   873,   886,   824,   519,   547,   518,   421,
-     725,   726,   726,   707,   708,   758,   220,   702,   768,   726,
-     726,   726,   225,    37,   225,   383,   772,   225,   300,   773,
-     758,   773,   225,   772,   518,   225,   773,   225,   148,   200,
-     760,   225,   726,   518,   547,   518,   726,   297,   824,   970,
-     972,   875,     3,    37,    42,    49,    54,    55,    56,    57,
-      71,    72,    81,    83,    89,   101,   112,   115,   165,   171,
-     173,   177,   194,   209,   216,   217,   219,   222,   223,   225,
-     235,   237,   247,   268,   269,   270,   278,   283,   300,   302,
-     322,   342,   364,   368,   383,   390,   394,   397,   412,   421,
-     429,   430,   441,   447,   464,   468,   786,   788,   789,   791,
-     793,   795,   797,   799,   800,   801,   803,   804,   807,   808,
-     877,   929,  1005,  1008,    40,   236,   546,   518,   516,   687,
-     467,   806,   824,   892,   806,   806,   518,   518,   794,   794,
-     325,   687,   518,   796,   527,    71,    72,   806,   824,   794,
-     518,   518,   482,   504,   518,   809,   518,   809,   824,   824,
-     824,    83,   148,   906,   910,   824,   873,   874,   687,   824,
-     872,   552,     9,   547,   856,   857,   858,   520,   523,   549,
-     897,   549,   518,   548,   518,   518,   548,   926,     3,     8,
-      11,    15,    16,    17,    18,    19,    20,    21,    36,    40,
-      46,    53,    80,   177,   194,   199,   222,   223,   237,   275,
-     278,   292,   295,   394,   502,   505,   506,   507,   509,   510,
-     511,   512,   513,   514,   864,   865,   866,   868,   900,   481,
-     840,   302,   824,   522,   702,   518,   548,   702,     3,   117,
-     241,   548,   594,   808,   971,   104,   972,   972,    40,   546,
-     519,   522,   957,   522,   519,   700,   920,   921,    40,   983,
-     193,   355,   220,   639,   389,   689,   689,    30,   712,   713,
-     824,    59,   689,   706,   164,   272,   733,   227,   273,   341,
-     392,   454,     4,     9,    30,   728,   824,   509,   510,   729,
-     730,   824,   826,   745,   746,   719,   718,   716,   717,   167,
-     748,   285,   750,    59,   695,   696,   697,   761,   825,   904,
-     904,   716,   745,   873,   932,   172,   469,   976,   236,   545,
-      74,    82,    93,   169,   192,   329,   448,   546,   621,   631,
-     646,    82,    93,   554,    93,   554,   518,   431,   518,   619,
-     245,   451,   619,    93,   522,   431,   545,     3,   791,   594,
-      59,   596,   594,   594,   106,   251,   261,    59,   431,   480,
-     504,   593,   266,   373,   593,   595,   775,    93,   431,   554,
-     373,   545,   431,   373,   989,   546,   676,   517,   523,   875,
-     875,   876,   193,   358,   709,   522,   710,   711,    13,    14,
-     222,   222,   431,   431,   546,   638,   643,   480,   679,   545,
-     380,   345,   384,   419,   470,   665,   152,   100,   580,   604,
-     940,   941,  1000,   144,   788,   275,   199,   585,   545,   275,
-     581,   592,   275,   518,   639,    40,   275,   639,   275,   518,
-     659,   660,   661,   662,   663,   664,   666,   192,   546,   633,
-     945,   552,   152,   172,   599,   655,   551,   520,   930,   920,
-     923,   923,   930,   519,   522,    13,   959,   965,     4,   926,
-       4,   926,   548,   552,   678,   685,    55,   102,   123,   141,
-     145,   168,   171,   187,   280,   288,   310,   339,   682,    40,
-     519,   824,   519,   172,   522,   519,   318,   881,   519,   825,
-     825,    11,    15,    16,    19,    20,    21,   199,   222,   292,
-     505,   506,   507,   509,   510,   511,   512,   513,   514,   866,
-     825,   519,   777,   778,   836,   167,   172,   884,   885,   522,
-     519,    40,   886,   873,   886,   886,   172,   519,    40,   769,
-     518,   921,     4,     9,   546,   720,   721,   723,   724,   829,
-     904,   902,   178,   241,   419,   423,   425,   451,   545,   703,
-     477,   781,   519,   758,   758,   225,   758,   290,   457,   774,
-     758,   225,   904,   758,   758,   282,   282,   518,   758,   547,
-     782,   783,   518,   547,   782,   522,   519,   522,   520,   518,
-     791,   518,   518,   520,    39,   790,   518,   810,   811,   812,
-     813,   814,   815,   816,   817,   818,   819,   820,   821,   822,
-     823,   519,   522,   794,   555,   560,   667,   668,   686,   937,
-     982,   994,   873,   874,   518,   476,   889,   890,   824,   874,
-     926,   824,   859,   860,   861,   862,   806,   806,     8,    15,
-      16,    19,    20,    21,   505,   506,   507,   509,   510,   511,
-     512,   513,   514,   546,   864,   869,   519,   873,   429,   429,
-     926,   926,   518,   518,   547,   907,   355,   914,   167,   517,
-     519,   522,   523,   522,   528,   511,   824,   550,   873,   926,
-     824,   823,   823,   788,   824,   824,   824,   824,   824,   824,
-     824,   824,     5,   552,   934,   429,    45,   416,   901,   930,
-     824,   824,   518,   687,   830,   887,   895,   132,   160,   275,
-     280,   285,   438,   449,   824,   280,   518,   824,   431,    53,
-     177,   194,   199,   237,   394,   824,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,    30,    38,   399,   863,   516,
-     520,   899,   181,   163,   841,   368,   518,   855,   905,   172,
-     754,   875,   754,   518,   548,   546,   545,   978,   545,   986,
-     824,   522,   519,   250,   275,   701,   457,   985,   545,   557,
-     518,   546,   562,   572,   573,   575,    41,   126,   714,   522,
-     457,   714,   266,   689,   368,   369,   509,   510,   730,   732,
-     826,   392,   227,   291,   313,   313,   522,   513,     4,   731,
-     926,   731,   368,   369,   732,   545,   919,   279,   396,   751,
-     518,   921,   922,   522,   181,   457,   199,   181,   220,   746,
-     717,   519,   546,   548,   546,   548,   353,   541,   518,   192,
-     631,   923,   227,   275,   227,   457,   518,   624,   787,   788,
-     923,   546,   192,   923,   192,   546,    26,   137,   389,   537,
-     540,   552,   615,   629,   923,   552,   623,   642,   923,   538,
-     923,   353,   389,   541,   592,   594,   930,   923,   594,   930,
-     923,   594,   353,   389,   541,   923,   923,   923,   923,   353,
-     389,   541,   923,   923,   548,   510,   824,   896,   710,   710,
-     710,   282,   282,   519,   466,   876,   709,   824,   824,   280,
-     548,   952,   280,   952,   546,   334,   675,   519,   522,   288,
-     172,   431,   670,   939,   583,   470,   545,   545,  1004,   545,
-     545,   545,   295,   650,   518,   687,   152,     3,   518,   518,
-     152,   152,   237,   546,   621,   631,   634,   637,   647,   649,
-     480,   482,   626,   151,   686,   152,   480,   946,   152,   519,
-     875,   522,   522,    40,   275,   290,   546,     3,   656,   551,
-     656,   290,   656,   588,   824,   676,   247,   511,   516,   518,
-     594,   677,   831,   832,   833,   964,   519,   522,    40,   674,
-     548,   674,   275,   280,   339,   674,    59,   674,   788,   519,
-     824,   824,   824,   884,   788,   825,   825,   825,   825,   825,
-     825,   132,   275,   285,   825,   825,   825,   825,   825,   825,
-     825,   825,   825,   825,   519,   522,    40,   779,   824,   824,
-     885,   884,   788,   519,   519,   519,   873,   788,   921,   519,
-     313,   369,   513,   518,   518,   702,   423,   425,   423,   425,
-     545,   704,   704,   704,   824,   181,   734,   774,   774,   758,
-     824,   518,   758,   167,   774,   518,   547,   765,   774,   788,
-     519,   522,   782,   519,   970,     3,   877,    39,   790,   546,
-     785,   785,     3,   516,   516,   926,   431,   431,   431,   431,
-     788,   454,   519,   517,   873,   824,   139,   890,   891,   519,
-     519,   519,   523,   522,   528,   520,   519,   519,   501,   501,
-     519,   519,   824,   907,   908,   909,   520,   518,   824,   911,
-     353,   918,   546,   838,   893,   894,   824,   824,   856,   910,
-     519,   519,   519,   501,   825,   825,   145,   873,   172,   132,
-     160,   280,   285,   438,   449,   518,   145,   869,   824,   416,
-     901,   824,   887,   824,   431,   518,   687,   824,   896,   551,
-     518,   518,   155,   842,   755,   756,   781,   710,   781,   926,
-     823,   932,   932,   250,   518,   756,   477,   984,    40,    59,
-     558,   568,   575,   897,   522,   754,   507,   503,   715,   713,
-     292,   864,   867,   715,     4,   926,   732,   291,   454,   729,
-     522,   244,   921,   695,    59,   904,   518,   547,    59,   266,
-     976,   976,   431,   824,   275,   646,   518,   152,   518,   624,
-     203,   643,   644,   605,    40,   176,   614,   640,   605,    26,
-     137,   357,   359,   389,   534,   535,   536,   542,   543,   152,
-     656,   152,   656,   615,   629,   615,   519,   522,   548,   608,
-     507,   520,   519,   522,   431,   373,    93,   431,   554,   373,
-     431,   431,   431,   373,   990,   523,   517,   523,   709,   709,
-     709,   876,   519,   518,   669,     3,   406,   407,   548,   684,
-     638,   675,   585,   545,   581,   518,    40,   639,   662,   664,
-     939,   355,   419,   548,   577,   578,   583,   685,   643,   545,
-     545,  1004,   545,   519,   522,   288,   619,   288,   290,   618,
-     923,   480,  1003,   545,   619,    40,   545,   519,   660,   666,
-     663,   666,   419,   824,   152,   545,   599,   930,   672,   683,
-     964,   678,   548,   548,   280,   643,   511,   643,   548,   511,
-     643,   548,   519,   519,   885,   172,   132,   285,   518,   780,
-     777,   518,   519,   519,   519,   546,   721,   781,   704,   704,
-     704,   704,   545,   545,   545,    59,   186,   743,   774,   921,
-     518,   762,   763,   764,   827,   830,   921,   167,    80,   784,
-     783,   519,   519,   516,   788,   519,   522,   519,   926,   517,
-     926,   519,   811,   813,   814,   815,   814,   815,   815,   519,
-     427,   824,   143,   824,   859,   869,   809,   809,   519,   522,
-     519,   547,   824,   911,   912,   913,    40,   518,   907,   915,
-     199,   522,   519,   914,   823,   824,    36,    36,   824,   519,
-     824,   172,   518,   877,   824,   519,   145,   825,   825,   145,
-     145,   824,   824,   517,   523,   518,   898,   711,   477,   824,
-     301,   846,   522,   734,   709,   734,   519,   937,   824,   361,
-     566,   546,   266,   321,   117,   304,   518,   556,   686,   519,
-     522,   562,   984,   824,   164,   231,   518,   715,   291,   545,
-     519,   922,   181,   687,   688,   904,   922,   923,   923,   519,
-     152,   644,   631,   644,   605,   633,   522,   519,   119,   207,
-     273,   275,   630,   518,    33,    59,   651,   640,    74,    80,
-      93,   117,   119,   207,   275,   280,   329,   347,   448,   457,
-     610,   611,   625,   176,   117,   191,   275,   619,   593,   107,
-     117,   176,   275,   405,   408,   595,   619,   389,   536,   442,
-     923,   546,   540,     3,    37,    42,    49,    55,    81,    83,
-      89,   101,   171,   173,   176,   177,   194,   209,   222,   223,
-     225,   235,   237,   247,   269,   274,   278,   292,   300,   302,
-     322,   364,   383,   390,   394,   412,   421,   441,   447,   468,
-     509,   510,   548,   594,   606,   645,   788,   867,   927,  1005,
-    1011,   552,   642,   923,   923,   923,   923,   923,   923,   923,
-     923,   923,   923,   676,   896,   896,   519,   519,   519,   710,
-     107,   373,   520,   593,   684,   518,   518,   637,   686,   946,
-     650,   192,   545,   519,   522,   585,   519,   519,   581,   518,
-      40,   628,   626,   634,    86,   590,   107,   273,   639,   686,
-     662,   664,    40,    40,   687,   688,   633,   457,   943,   656,
-     519,   522,   643,   825,   172,   518,   877,   782,   519,   522,
-     519,   734,   545,   545,   545,   545,    30,   103,   182,   367,
-     518,   735,   736,   737,   738,   739,   740,   741,   824,   824,
-     479,   843,   519,   826,   870,   871,   199,   181,   759,   763,
-     519,   765,   766,   767,   930,   790,   926,   790,   546,   790,
-     517,   517,   824,   907,   522,   519,   546,   915,   916,   917,
-      40,   824,   826,   894,   918,   824,   824,   824,   877,   519,
-     824,    36,    36,   824,   824,   145,   519,   510,   896,   519,
-     875,   519,   824,   519,   518,   546,   847,   743,   519,   743,
-     548,   519,   903,   463,   418,   456,   567,   546,   561,   571,
-     290,   564,   507,   575,   566,   869,    59,   519,   519,   462,
-     463,   692,   605,   631,   519,   519,   480,   636,   120,   195,
-     205,   119,   459,   824,   117,    40,   518,   930,   923,   825,
-     120,   195,   119,   280,   227,   545,   636,    88,   651,   192,
-     280,   594,   824,   651,   280,   509,   510,   597,   546,   787,
-     788,   656,   656,     3,   247,   412,   927,   931,   507,   431,
-     431,   517,   517,   709,   519,   519,   546,   676,   457,   671,
-     673,   685,   643,   519,  1003,    40,   419,   275,   518,   548,
-     518,   946,   637,   151,   686,   149,   201,   618,   122,   137,
-     328,  1003,   107,   946,   480,  1001,   419,   290,   546,   942,
-     518,   683,   825,   877,   519,   519,     9,   354,   727,   743,
-     518,   391,   518,   519,   522,   546,   844,   845,   336,   744,
-     522,   519,   518,   547,    59,   519,   199,   519,   766,   517,
-     788,   911,   522,   519,   546,   517,   192,   519,   824,   824,
-     824,   523,   517,   523,   519,   519,   546,   848,   843,   548,
-     843,   522,   462,   897,   519,   522,    91,   566,   824,   519,
-     922,   922,   347,   636,   518,   627,   605,   519,   191,   518,
-     824,   275,   611,   636,   639,   923,    40,   152,   784,   931,
-     513,   606,   923,   923,   519,   593,   124,   519,   519,   626,
-     686,   545,   152,   685,    40,   519,   923,  1003,    30,    85,
-      94,   118,   191,   204,   405,   408,   622,   622,   369,   369,
-      40,    64,    74,   241,   687,   545,   518,   546,   565,   574,
-     836,   519,   519,   518,   843,   873,   518,   873,   737,    40,
-     522,   824,   457,   722,   826,   904,   921,   770,   518,   770,
-     915,   824,   896,   896,   310,   849,   744,   744,   686,   304,
-     686,   561,   290,   518,   559,   545,   605,   552,   632,   635,
-     409,   472,   612,   613,   518,   607,   824,   519,   249,   648,
-     191,   457,   539,   513,   442,   676,   548,   946,   618,  1001,
-     518,   545,   519,   686,   626,   590,   686,    74,   293,    74,
-     943,   824,    80,   569,   519,   522,   569,     9,   744,   519,
-     736,   519,   847,   845,   371,   519,   904,   517,   517,   517,
-      59,   710,   722,   722,   567,    93,   574,   133,   639,   507,
-     519,   522,   592,   519,   273,   620,   173,   309,   395,   290,
-     616,   617,   641,   607,   824,   442,    40,   518,  1001,   618,
-    1003,  1001,   293,   293,   518,   519,   930,   570,   930,   946,
-     565,   570,   519,   722,   519,   724,   519,   872,   184,   340,
-     369,   850,   462,   923,   519,   276,   454,   648,   606,   635,
-     519,   613,   205,   122,   454,   290,   641,   290,   616,   686,
-     574,   569,   714,   781,   714,    53,   104,   444,   824,   851,
-     852,   851,   851,   519,   686,   781,   389,   617,    63,   273,
-     360,   389,   609,   609,  1001,   519,   570,   715,   715,   852,
-     368,   166,   324,   166,   324,   148,   853,   853,   853,   573,
-     605,    25,   117,   280,   946,   714,    36,   104,   181,   273,
-     428,   781,   781,   715,   852,   368,   298
-};
-
-#define yyerrok		(yyerrstatus = 0)
-#define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		(-2)
-#define YYEOF		0
-
-#define YYACCEPT	goto yyacceptlab
-#define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror.  This remains here temporarily
-   to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
-
-#define YYFAIL		goto yyerrlab
-
-#define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)					\
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      yytoken = YYTRANSLATE (yychar);				\
-      YYPOPSTACK (1);						\
-      goto yybackup;						\
-    }								\
-  else								\
-    {								\
-      yyerror (&yylloc, yyscanner, YY_("syntax error: cannot back up")); \
-      YYERROR;							\
-    }								\
-while (YYID (0))
-
-
-#define YYTERROR	1
-#define YYERRCODE	256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
-    do									\
-      if (YYID (N))                                                    \
-	{								\
-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
-	}								\
-      else								\
-	{								\
-	  (Current).first_line   = (Current).last_line   =		\
-	    YYRHSLOC (Rhs, 0).last_line;				\
-	  (Current).first_column = (Current).last_column =		\
-	    YYRHSLOC (Rhs, 0).last_column;				\
-	}								\
-    while (YYID (0))
-#endif
-
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-#ifndef YY_LOCATION_PRINT
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-#  define YY_LOCATION_PRINT(File, Loc)			\
-     fprintf (File, "%d.%d-%d.%d",			\
-	      (Loc).first_line, (Loc).first_column,	\
-	      (Loc).last_line,  (Loc).last_column)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
-#endif
-
-
-/* YYLEX -- calling `yylex' with the right arguments.  */
-
-#ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
-#else
-# define YYLEX yylex (&yylval, &yylloc, yyscanner)
-#endif
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)			\
-do {						\
-  if (yydebug)					\
-    YYFPRINTF Args;				\
-} while (YYID (0))
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
-do {									  \
-  if (yydebug)								  \
-    {									  \
-      YYFPRINTF (stderr, "%s ", Title);					  \
-      yy_symbol_print (stderr,						  \
-		  Type, Value, Location, yyscanner); \
-      YYFPRINTF (stderr, "\n");						  \
-    }									  \
-} while (YYID (0))
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner)
-#else
-static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    core_yyscan_t yyscanner;
-#endif
-{
-  if (!yyvaluep)
-    return;
-  YYUSE (yylocationp);
-  YYUSE (yyscanner);
-# ifdef YYPRINT
-  if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# else
-  YYUSE (yyoutput);
-# endif
-  switch (yytype)
-    {
-      default:
-	break;
-    }
-}
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner)
-#else
-static void
-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    core_yyscan_t yyscanner;
-#endif
-{
-  if (yytype < YYNTOKENS)
-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-  else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-  YY_LOCATION_PRINT (yyoutput, *yylocationp);
-  YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner);
-  YYFPRINTF (yyoutput, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
-#else
-static void
-yy_stack_print (bottom, top)
-    yytype_int16 *bottom;
-    yytype_int16 *top;
-#endif
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (; bottom <= top; ++bottom)
-    YYFPRINTF (stderr, " %d", *bottom);
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)				\
-do {								\
-  if (yydebug)							\
-    yy_stack_print ((Bottom), (Top));				\
-} while (YYID (0))
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, core_yyscan_t yyscanner)
-#else
-static void
-yy_reduce_print (yyvsp, yylsp, yyrule, yyscanner)
-    YYSTYPE *yyvsp;
-    YYLTYPE *yylsp;
-    int yyrule;
-    core_yyscan_t yyscanner;
-#endif
-{
-  int yynrhs = yyr2[yyrule];
-  int yyi;
-  unsigned long int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
-	     yyrule - 1, yylno);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      fprintf (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , yyscanner);
-      fprintf (stderr, "\n");
-    }
-}
-
-# define YY_REDUCE_PRINT(Rule)		\
-do {					\
-  if (yydebug)				\
-    yy_reduce_print (yyvsp, yylsp, Rule, yyscanner); \
-} while (YYID (0))
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef	YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-#  if defined __GLIBC__ && defined _STRING_H
-#   define yystrlen strlen
-#  else
-/* Return the length of YYSTR.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static YYSIZE_T
-yystrlen (const char *yystr)
-#else
-static YYSIZE_T
-yystrlen (yystr)
-    const char *yystr;
-#endif
-{
-  YYSIZE_T yylen;
-  for (yylen = 0; yystr[yylen]; yylen++)
-    continue;
-  return yylen;
-}
-#  endif
-# endif
-
-# ifndef yystpcpy
-#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-#   define yystpcpy stpcpy
-#  else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
-   YYDEST.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-#else
-static char *
-yystpcpy (yydest, yysrc)
-    char *yydest;
-    const char *yysrc;
-#endif
-{
-  char *yyd = yydest;
-  const char *yys = yysrc;
-
-  while ((*yyd++ = *yys++) != '\0')
-    continue;
-
-  return yyd - 1;
-}
-#  endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
-   quotes and backslashes, so that it's suitable for yyerror.  The
-   heuristic is that double-quoting is unnecessary unless the string
-   contains an apostrophe, a comma, or backslash (other than
-   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
-   null, do not copy; instead, return the length of what the result
-   would have been.  */
-static YYSIZE_T
-yytnamerr (char *yyres, const char *yystr)
-{
-  if (*yystr == '"')
-    {
-      YYSIZE_T yyn = 0;
-      char const *yyp = yystr;
-
-      for (;;)
-	switch (*++yyp)
-	  {
-	  case '\'':
-	  case ',':
-	    goto do_not_strip_quotes;
-
-	  case '\\':
-	    if (*++yyp != '\\')
-	      goto do_not_strip_quotes;
-	    /* Fall through.  */
-	  default:
-	    if (yyres)
-	      yyres[yyn] = *yyp;
-	    yyn++;
-	    break;
-
-	  case '"':
-	    if (yyres)
-	      yyres[yyn] = '\0';
-	    return yyn;
-	  }
-    do_not_strip_quotes: ;
-    }
-
-  if (! yyres)
-    return yystrlen (yystr);
-
-  return yystpcpy (yyres, yystr) - yyres;
-}
-# endif
-
-/* Copy into YYRESULT an error message about the unexpected token
-   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
-   including the terminating null byte.  If YYRESULT is null, do not
-   copy anything; just return the number of bytes that would be
-   copied.  As a special case, return 0 if an ordinary "syntax error"
-   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
-   size calculation.  */
-static YYSIZE_T
-yysyntax_error (char *yyresult, int yystate, int yychar)
-{
-  int yyn = yypact[yystate];
-
-  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
-    return 0;
-  else
-    {
-      int yytype = YYTRANSLATE (yychar);
-      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
-      YYSIZE_T yysize = yysize0;
-      YYSIZE_T yysize1;
-      int yysize_overflow = 0;
-      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-      int yyx;
-
-# if 0
-      /* This is so xgettext sees the translatable formats that are
-	 constructed on the fly.  */
-      YY_("syntax error, unexpected %s");
-      YY_("syntax error, unexpected %s, expecting %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
-# endif
-      char *yyfmt;
-      char const *yyf;
-      static char const yyunexpected[] = "syntax error, unexpected %s";
-      static char const yyexpecting[] = ", expecting %s";
-      static char const yyor[] = " or %s";
-      char yyformat[sizeof yyunexpected
-		    + sizeof yyexpecting - 1
-		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
-		       * (sizeof yyor - 1))];
-      char const *yyprefix = yyexpecting;
-
-      /* Start YYX at -YYN if negative to avoid negative indexes in
-	 YYCHECK.  */
-      int yyxbegin = yyn < 0 ? -yyn : 0;
-
-      /* Stay within bounds of both yycheck and yytname.  */
-      int yychecklim = YYLAST - yyn + 1;
-      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-      int yycount = 1;
-
-      yyarg[0] = yytname[yytype];
-      yyfmt = yystpcpy (yyformat, yyunexpected);
-
-      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-	  {
-	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-	      {
-		yycount = 1;
-		yysize = yysize0;
-		yyformat[sizeof yyunexpected - 1] = '\0';
-		break;
-	      }
-	    yyarg[yycount++] = yytname[yyx];
-	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-	    yysize_overflow |= (yysize1 < yysize);
-	    yysize = yysize1;
-	    yyfmt = yystpcpy (yyfmt, yyprefix);
-	    yyprefix = yyor;
-	  }
-
-      yyf = YY_(yyformat);
-      yysize1 = yysize + yystrlen (yyf);
-      yysize_overflow |= (yysize1 < yysize);
-      yysize = yysize1;
-
-      if (yysize_overflow)
-	return YYSIZE_MAXIMUM;
-
-      if (yyresult)
-	{
-	  /* Avoid sprintf, as that infringes on the user's name space.
-	     Don't have undefined behavior even if the translation
-	     produced a string with the wrong number of "%s"s.  */
-	  char *yyp = yyresult;
-	  int yyi = 0;
-	  while ((*yyp = *yyf) != '\0')
-	    {
-	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
-		{
-		  yyp += yytnamerr (yyp, yyarg[yyi++]);
-		  yyf += 2;
-		}
-	      else
-		{
-		  yyp++;
-		  yyf++;
-		}
-	    }
-	}
-      return yysize;
-    }
-}
-#endif /* YYERROR_VERBOSE */
-
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, core_yyscan_t yyscanner)
-#else
-static void
-yydestruct (yymsg, yytype, yyvaluep, yylocationp, yyscanner)
-    const char *yymsg;
-    int yytype;
-    YYSTYPE *yyvaluep;
-    YYLTYPE *yylocationp;
-    core_yyscan_t yyscanner;
-#endif
-{
-  YYUSE (yyvaluep);
-  YYUSE (yylocationp);
-  YYUSE (yyscanner);
-
-  if (!yymsg)
-    yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
-  switch (yytype)
-    {
-
-      default:
-	break;
-    }
-}
-
-
-/* Prevent warnings from -Wmissing-prototypes.  */
-
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (core_yyscan_t yyscanner);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-
-
-
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
-#ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void *YYPARSE_PARAM)
-#else
-int
-yyparse (YYPARSE_PARAM)
-    void *YYPARSE_PARAM;
-#endif
-#else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (core_yyscan_t yyscanner)
-#else
-int
-yyparse (yyscanner)
-    core_yyscan_t yyscanner;
-#endif
-#endif
-{
-  /* The look-ahead symbol.  */
-int yychar;
-
-/* The semantic value of the look-ahead symbol.  */
-YYSTYPE yylval;
-
-/* Number of syntax errors so far.  */
-int yynerrs;
-/* Location data for the look-ahead symbol.  */
-YYLTYPE yylloc;
-
-  int yystate;
-  int yyn;
-  int yyresult;
-  /* Number of tokens to shift before error messages enabled.  */
-  int yyerrstatus;
-  /* Look-ahead token as an internal (translated) token number.  */
-  int yytoken = 0;
-#if YYERROR_VERBOSE
-  /* Buffer for error messages, and its allocated size.  */
-  char yymsgbuf[128];
-  char *yymsg = yymsgbuf;
-  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-  /* Three stacks and their tools:
-     `yyss': related to states,
-     `yyvs': related to semantic values,
-     `yyls': related to locations.
-
-     Refer to the stacks thru separate pointers, to allow yyoverflow
-     to reallocate them elsewhere.  */
-
-  /* The state stack.  */
-  yytype_int16 yyssa[YYINITDEPTH];
-  yytype_int16 *yyss = yyssa;
-  yytype_int16 *yyssp;
-
-  /* The semantic value stack.  */
-  YYSTYPE yyvsa[YYINITDEPTH];
-  YYSTYPE *yyvs = yyvsa;
-  YYSTYPE *yyvsp;
-
-  /* The location stack.  */
-  YYLTYPE yylsa[YYINITDEPTH];
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-  /* The locations where the error started and ended.  */
-  YYLTYPE yyerror_range[2];
-
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
-
-  YYSIZE_T yystacksize = YYINITDEPTH;
-
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-  YYLTYPE yyloc;
-
-  /* The number of symbols on the RHS of the reduced rule.
-     Keep to zero when no symbol should be popped.  */
-  int yylen = 0;
-
-  YYDPRINTF ((stderr, "Starting parse\n"));
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0; (void)yynerrs;
-  yychar = YYEMPTY;		/* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-
-  yyssp = yyss;
-  yyvsp = yyvs;
-  yylsp = yyls;
-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-  /* Initialize the default location before parsing starts.  */
-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 0;
-#endif
-
-  goto yysetstate;
-
-/*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
- yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed.  So pushing a state here evens the stacks.  */
-  yyssp++;
-
- yysetstate:
-  *yyssp = yystate;
-
-  if (yyss + yystacksize - 1 <= yyssp)
-    {
-      /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      {
-	/* Give user a chance to reallocate the stack.  Use copies of
-	   these so that the &'s don't force the real ones into
-	   memory.  */
-	YYSTYPE *yyvs1 = yyvs;
-	yytype_int16 *yyss1 = yyss;
-	YYLTYPE *yyls1 = yyls;
-
-	/* Each stack pointer address is followed by the size of the
-	   data in use in that stack, in bytes.  This used to be a
-	   conditional around just the two extra args, but that might
-	   be undefined if yyoverflow is a macro.  */
-	yyoverflow (YY_("memory exhausted"),
-		    &yyss1, yysize * sizeof (*yyssp),
-		    &yyvs1, yysize * sizeof (*yyvsp),
-		    &yyls1, yysize * sizeof (*yylsp),
-		    &yystacksize);
-	yyls = yyls1;
-	yyss = yyss1;
-	yyvs = yyvs1;
-      }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
-      /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-	goto yyexhaustedlab;
-      yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
-	yystacksize = YYMAXDEPTH;
-
-      {
-	yytype_int16 *yyss1 = yyss;
-	union yyalloc *yyptr =
-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-	if (! yyptr)
-	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss);
-	YYSTACK_RELOCATE (yyvs);
-	YYSTACK_RELOCATE (yyls);
-#  undef YYSTACK_RELOCATE
-	if (yyss1 != yyssa)
-	  YYSTACK_FREE (yyss1);
-      }
-# endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-      yylsp = yyls + yysize - 1;
-
-      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-		  (unsigned long int) yystacksize));
-
-      if (yyss + yystacksize - 1 <= yyssp)
-	YYABORT;
-    }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-
-  goto yybackup;
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
-
-  /* Do appropriate processing given the current state.  Read a
-     look-ahead token if we need one and don't already have one.  */
-
-  /* First try to decide what to do without reference to look-ahead token.  */
-  yyn = yypact[yystate];
-  if (yyn == YYPACT_NINF)
-    goto yydefault;
-
-  /* Not known => get a look-ahead token if don't already have one.  */
-
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
-  if (yychar == YYEMPTY)
-    {
-      YYDPRINTF ((stderr, "Reading a token: "));
-      yychar = YYLEX;
-    }
-
-  if (yychar <= YYEOF)
-    {
-      yychar = yytoken = YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
-    }
-  else
-    {
-      yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
-    }
-
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
-    goto yydefault;
-  yyn = yytable[yyn];
-  if (yyn <= 0)
-    {
-      if (yyn == 0 || yyn == YYTABLE_NINF)
-	goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
-
-  /* Shift the look-ahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
-  /* Discard the shifted token unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
-
-  yystate = yyn;
-  *++yyvsp = yylval;
-  *++yylsp = yylloc;
-  goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-  goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
-yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
-  yylen = yyr2[yyn];
-
-  /* If YYLEN is nonzero, implement the default value of the action:
-     `$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-  /* Default location.  */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
-    {
-        case 2:
-#line 510 "third_party/libpg_query/grammar/grammar.y"
-    {
-				pg_yyget_extra(yyscanner)->parsetree = (yyvsp[(1) - (1)].list);
-			;}
-    break;
-
-  case 3:
-#line 526 "third_party/libpg_query/grammar/grammar.y"
-    {
-					if ((yyvsp[(1) - (3)].list) != NIL)
-					{
-						/* update length of previous stmt */
-						updateRawStmtEnd(llast_node(PGRawStmt, (yyvsp[(1) - (3)].list)), (yylsp[(2) - (3)]));
-					}
-					if ((yyvsp[(3) - (3)].node) != NULL)
-						(yyval.list) = lappend((yyvsp[(1) - (3)].list), makeRawStmt((yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]) + 1));
-					else
-						(yyval.list) = (yyvsp[(1) - (3)].list);
-				;}
-    break;
-
-  case 4:
-#line 538 "third_party/libpg_query/grammar/grammar.y"
-    {
-					if ((yyvsp[(1) - (1)].node) != NULL)
-						(yyval.list) = list_make1(makeRawStmt((yyvsp[(1) - (1)].node), 0));
-					else
-						(yyval.list) = NIL;
-				;}
-    break;
-
-  case 46:
-#line 588 "third_party/libpg_query/grammar/grammar.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 47:
-#line 10 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_TABLE;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 48:
-#line 19 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_TABLE;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 49:
-#line 28 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_INDEX;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 50:
-#line 37 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_INDEX;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 51:
-#line 46 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_SEQUENCE;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 52:
-#line 55 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_SEQUENCE;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 53:
-#line 64 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_VIEW;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 54:
-#line 73 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_VIEW;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 55:
-#line 86 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 56:
-#line 88 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;}
-    break;
-
-  case 57:
-#line 93 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = (yyvsp[(3) - (3)].node); ;}
-    break;
-
-  case 58:
-#line 94 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 59:
-#line 100 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 60:
-#line 104 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 61:
-#line 108 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					if (strcmp((yyvsp[(2) - (2)].defelt)->defname, "as") == 0 ||
-						strcmp((yyvsp[(2) - (2)].defelt)->defname, "restart") == 0 ||
-						strcmp((yyvsp[(2) - (2)].defelt)->defname, "owned_by") == 0)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("sequence option \"%s\" not supported here", (yyvsp[(2) - (2)].defelt)->defname),
-								 parser_errposition((yylsp[(2) - (2)]))));
-					(yyval.defelt) = (yyvsp[(2) - (2)].defelt);
-				;}
-    break;
-
-  case 62:
-#line 119 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElem("generated", (PGNode *) makeInteger((yyvsp[(3) - (3)].ival)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 63:
-#line 127 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].defelt));
-				;}
-    break;
-
-  case 64:
-#line 131 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt));
-				;}
-    break;
-
-  case 65:
-#line 140 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(2) - (2)].node);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 66:
-#line 149 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(5) - (5)].node);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 67:
-#line 158 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(3) - (3)].node);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 68:
-#line 167 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(6) - (6)].node);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 69:
-#line 176 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ColumnDefault;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->def = (yyvsp[(4) - (4)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 70:
-#line 185 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropNotNull;
-					n->name = (yyvsp[(3) - (6)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 71:
-#line 193 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetNotNull;
-					n->name = (yyvsp[(3) - (6)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 72:
-#line 201 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetStatistics;
-					n->name = (yyvsp[(3) - (6)].str);
-					n->def = (PGNode *) makeInteger((yyvsp[(6) - (6)].ival));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 73:
-#line 210 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetOptions;
-					n->name = (yyvsp[(3) - (5)].str);
-					n->def = (PGNode *) (yyvsp[(5) - (5)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 74:
-#line 219 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ResetOptions;
-					n->name = (yyvsp[(3) - (5)].str);
-					n->def = (PGNode *) (yyvsp[(5) - (5)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 75:
-#line 228 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetStorage;
-					n->name = (yyvsp[(3) - (6)].str);
-					n->def = (PGNode *) makeString((yyvsp[(6) - (6)].str));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 76:
-#line 237 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					PGConstraint *c = makeNode(PGConstraint);
-
-					c->contype = PG_CONSTR_IDENTITY;
-					c->generated_when = (yyvsp[(6) - (9)].ival);
-					c->options = (yyvsp[(9) - (9)].list);
-					c->location = (yylsp[(5) - (9)]);
-
-					n->subtype = PG_AT_AddIdentity;
-					n->name = (yyvsp[(3) - (9)].str);
-					n->def = (PGNode *) c;
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 77:
-#line 254 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetIdentity;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->def = (PGNode *) (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 78:
-#line 263 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = AT_DropIdentity;
-					n->name = (yyvsp[(3) - (5)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 79:
-#line 272 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = AT_DropIdentity;
-					n->name = (yyvsp[(3) - (7)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 80:
-#line 281 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropColumn;
-					n->name = (yyvsp[(5) - (6)].str);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 81:
-#line 291 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropColumn;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 82:
-#line 304 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					PGColumnDef *def = makeNode(PGColumnDef);
-					n->subtype = PG_AT_AlterColumnType;
-					n->name = (yyvsp[(3) - (8)].str);
-					n->def = (PGNode *) def;
-					/* We only use these fields of the PGColumnDef node */
-					def->typeName = (yyvsp[(6) - (8)].typnam);
-					def->collClause = (PGCollateClause *) (yyvsp[(7) - (8)].node);
-					def->raw_default = (yyvsp[(8) - (8)].node);
-					def->location = (yylsp[(3) - (8)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 83:
-#line 319 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AlterColumnGenericOptions;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->def = (PGNode *) (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 84:
-#line 328 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddConstraint;
-					n->def = (yyvsp[(2) - (2)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 85:
-#line 336 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					PGConstraint *c = makeNode(PGConstraint);
-					n->subtype = PG_AT_AlterConstraint;
-					n->def = (PGNode *) c;
-					c->contype = PG_CONSTR_FOREIGN; /* others not supported, yet */
-					c->conname = (yyvsp[(3) - (4)].str);
-					processCASbits((yyvsp[(4) - (4)].ival), (yylsp[(4) - (4)]), "ALTER CONSTRAINT statement",
-									&c->deferrable,
-									&c->initdeferred,
-									NULL, NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 86:
-#line 351 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ValidateConstraint;
-					n->name = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 87:
-#line 359 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropConstraint;
-					n->name = (yyvsp[(5) - (6)].str);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 88:
-#line 369 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropConstraint;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 89:
-#line 379 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetLogged;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 90:
-#line 386 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetUnLogged;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 91:
-#line 393 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetRelOptions;
-					n->def = (PGNode *)(yyvsp[(2) - (2)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 92:
-#line 401 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ResetRelOptions;
-					n->def = (PGNode *)(yyvsp[(2) - (2)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 93:
-#line 408 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_GenericOptions;
-					n->def = (PGNode *)(yyvsp[(1) - (1)].list);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 94:
-#line 418 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 95:
-#line 419 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 96:
-#line 425 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = (yyvsp[(1) - (1)].defelt);
-				;}
-    break;
-
-  case 97:
-#line 429 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = (yyvsp[(2) - (2)].defelt);
-					(yyval.defelt)->defaction = PG_DEFELEM_SET;
-				;}
-    break;
-
-  case 98:
-#line 434 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = (yyvsp[(2) - (2)].defelt);
-					(yyval.defelt)->defaction = PG_DEFELEM_ADD;
-				;}
-    break;
-
-  case 99:
-#line 439 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[(2) - (2)].str), NULL, DEFELEM_DROP, (yylsp[(2) - (2)]));
-				;}
-    break;
-
-  case 100:
-#line 446 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 101:
-#line 447 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 102:
-#line 452 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 103:
-#line 456 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.ival) = 1; ;}
-    break;
-
-  case 104:
-#line 457 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 105:
-#line 458 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 106:
-#line 8 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = (yyvsp[(2) - (2)].str);
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 107:
-#line 14 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = (yyvsp[(3) - (3)].str);
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 108:
-#line 20 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = NULL;
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 109:
-#line 26 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = NULL;
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 110:
-#line 10 "third_party/libpg_query/grammar/statements/common.y"
-    {
-					(yyval.range) = makeRangeVar(NULL, (yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 111:
-#line 14 "third_party/libpg_query/grammar/statements/common.y"
-    {
-					check_qualified_name((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.range) = makeRangeVar(NULL, NULL, (yylsp[(1) - (2)]));
-					switch (list_length((yyvsp[(2) - (2)].list)))
-					{
-						case 1:
-							(yyval.range)->catalogname = NULL;
-							(yyval.range)->schemaname = (yyvsp[(1) - (2)].str);
-							(yyval.range)->relname = strVal(linitial((yyvsp[(2) - (2)].list)));
-							break;
-						case 2:
-							(yyval.range)->catalogname = (yyvsp[(1) - (2)].str);
-							(yyval.range)->schemaname = strVal(linitial((yyvsp[(2) - (2)].list)));
-							(yyval.range)->relname = strVal(lsecond((yyvsp[(2) - (2)].list)));
-							break;
-						case 3:
-						default:
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("improper qualified name (too many dotted names): %s",
-											NameListToString(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)))),
-									 parser_errposition((yylsp[(1) - (2)]))));
-							break;
-					}
-				;}
-    break;
-
-  case 112:
-#line 44 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 113:
-#line 45 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 114:
-#line 46 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 115:
-#line 50 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 116:
-#line 51 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 117:
-#line 55 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 118:
-#line 59 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 119:
-#line 60 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 120:
-#line 65 "third_party/libpg_query/grammar/statements/common.y"
-    {
-					(yyval.node) = (PGNode *) makeString((yyvsp[(2) - (2)].str));
-				;}
-    break;
-
-  case 121:
-#line 70 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 122:
-#line 75 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 123:
-#line 76 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 124:
-#line 77 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 125:
-#line 78 "third_party/libpg_query/grammar/statements/common.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 126:
-#line 7 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_SCHEMA;
-					n->subname = (yyvsp[(3) - (6)].str);
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 127:
-#line 16 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 128:
-#line 26 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 129:
-#line 36 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 130:
-#line 46 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 131:
-#line 56 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 132:
-#line 66 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 133:
-#line 76 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_INDEX;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 134:
-#line 86 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_INDEX;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 135:
-#line 96 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_COLUMN;
-					n->relationType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(3) - (8)].range);
-					n->subname = (yyvsp[(6) - (8)].str);
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 136:
-#line 107 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_COLUMN;
-					n->relationType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(5) - (10)].range);
-					n->subname = (yyvsp[(8) - (10)].str);
-					n->newname = (yyvsp[(10) - (10)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 137:
-#line 118 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABCONSTRAINT;
-					n->relation = (yyvsp[(3) - (8)].range);
-					n->subname = (yyvsp[(6) - (8)].str);
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 138:
-#line 128 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABCONSTRAINT;
-					n->relation = (yyvsp[(5) - (10)].range);
-					n->subname = (yyvsp[(8) - (10)].str);
-					n->newname = (yyvsp[(10) - (10)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 139:
-#line 140 "third_party/libpg_query/grammar/statements/rename.y"
-    { (yyval.ival) = COLUMN; ;}
-    break;
-
-  case 140:
-#line 141 "third_party/libpg_query/grammar/statements/rename.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 141:
-#line 11 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyvsp[(7) - (9)].istmt)->relation = (yyvsp[(5) - (9)].range);
-					(yyvsp[(7) - (9)].istmt)->onConflictAlias = (yyvsp[(3) - (9)].onconflictshorthand);
-					(yyvsp[(7) - (9)].istmt)->onConflictClause = (yyvsp[(8) - (9)].onconflict);
-					(yyvsp[(7) - (9)].istmt)->returningList = (yyvsp[(9) - (9)].list);
-					(yyvsp[(7) - (9)].istmt)->withClause = (yyvsp[(1) - (9)].with);
-					(yyvsp[(7) - (9)].istmt)->insert_column_order = (yyvsp[(6) - (9)].bynameorposition);
-					(yyval.node) = (PGNode *) (yyvsp[(7) - (9)].istmt);
-				;}
-    break;
-
-  case 142:
-#line 24 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = NIL;
-					(yyval.istmt)->selectStmt = (yyvsp[(1) - (1)].node);
-				;}
-    break;
-
-  case 143:
-#line 30 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = NIL;
-					(yyval.istmt)->override = (yyvsp[(2) - (4)].override);
-					(yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node);
-				;}
-    break;
-
-  case 144:
-#line 37 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = (yyvsp[(2) - (4)].list);
-					(yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node);
-				;}
-    break;
-
-  case 145:
-#line 43 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = (yyvsp[(2) - (7)].list);
-					(yyval.istmt)->override = (yyvsp[(5) - (7)].override);
-					(yyval.istmt)->selectStmt = (yyvsp[(7) - (7)].node);
-				;}
-    break;
-
-  case 146:
-#line 50 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = NIL;
-					(yyval.istmt)->selectStmt = NULL;
-				;}
-    break;
-
-  case 147:
-#line 60 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-				;}
-    break;
-
-  case 148:
-#line 64 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyvsp[(1) - (3)].range)->alias = makeAlias((yyvsp[(3) - (3)].str), NIL);
-					(yyval.range) = (yyvsp[(1) - (3)].range);
-				;}
-    break;
-
-  case 149:
-#line 71 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.bynameorposition) = PG_INSERT_BY_NAME; ;}
-    break;
-
-  case 150:
-#line 72 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; ;}
-    break;
-
-  case 151:
-#line 73 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; ;}
-    break;
-
-  case 152:
-#line 78 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.infer) = makeNode(PGInferClause);
-					(yyval.infer)->indexElems = (yyvsp[(2) - (4)].list);
-					(yyval.infer)->whereClause = (yyvsp[(4) - (4)].node);
-					(yyval.infer)->conname = NULL;
-					(yyval.infer)->location = (yylsp[(1) - (4)]);
-				;}
-    break;
-
-  case 153:
-#line 87 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.infer) = makeNode(PGInferClause);
-					(yyval.infer)->indexElems = NIL;
-					(yyval.infer)->whereClause = NULL;
-					(yyval.infer)->conname = (yyvsp[(3) - (3)].str);
-					(yyval.infer)->location = (yylsp[(1) - (3)]);
-				;}
-    break;
-
-  case 154:
-#line 95 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.infer) = NULL;
-				;}
-    break;
-
-  case 155:
-#line 102 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.with) = (yyvsp[(1) - (1)].with); ;}
-    break;
-
-  case 156:
-#line 103 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.with) = NULL; ;}
-    break;
-
-  case 157:
-#line 109 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(1) - (2)].str);
-					(yyval.target)->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.target)->val = NULL;
-					(yyval.target)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 158:
-#line 121 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyvsp[(1) - (3)].target)->val = (PGNode *) (yyvsp[(3) - (3)].node);
-					(yyval.list) = list_make1((yyvsp[(1) - (3)].target));
-				;}
-    break;
-
-  case 159:
-#line 126 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					int ncolumns = list_length((yyvsp[(2) - (5)].list));
-					int i = 1;
-					PGListCell *col_cell;
-
-					/* Create a PGMultiAssignRef source for each target */
-					foreach(col_cell, (yyvsp[(2) - (5)].list))
-					{
-						PGResTarget *res_col = (PGResTarget *) lfirst(col_cell);
-						PGMultiAssignRef *r = makeNode(PGMultiAssignRef);
-
-						r->source = (PGNode *) (yyvsp[(5) - (5)].node);
-						r->colno = i;
-						r->ncolumns = ncolumns;
-						res_col->val = (PGNode *) r;
-						i++;
-					}
-
-					(yyval.list) = (yyvsp[(2) - (5)].list);
-				;}
-    break;
-
-  case 160:
-#line 151 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_REPLACE;
-				;}
-    break;
-
-  case 161:
-#line 156 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_IGNORE;
-				;}
-    break;
-
-  case 162:
-#line 160 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_NONE;
-				;}
-    break;
-
-  case 163:
-#line 167 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflict) = makeNode(PGOnConflictClause);
-					(yyval.onconflict)->action = PG_ONCONFLICT_UPDATE;
-					(yyval.onconflict)->infer = (yyvsp[(3) - (8)].infer);
-					(yyval.onconflict)->targetList = (yyvsp[(7) - (8)].list);
-					(yyval.onconflict)->whereClause = (yyvsp[(8) - (8)].node);
-					(yyval.onconflict)->location = (yylsp[(1) - (8)]);
-				;}
-    break;
-
-  case 164:
-#line 177 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflict) = makeNode(PGOnConflictClause);
-					(yyval.onconflict)->action = PG_ONCONFLICT_NOTHING;
-					(yyval.onconflict)->infer = (yyvsp[(3) - (5)].infer);
-					(yyval.onconflict)->targetList = NIL;
-					(yyval.onconflict)->whereClause = NULL;
-					(yyval.onconflict)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 165:
-#line 186 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflict) = NULL;
-				;}
-    break;
-
-  case 166:
-#line 193 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.ielem) = makeNode(PGIndexElem);
-					(yyval.ielem)->name = (yyvsp[(1) - (5)].str);
-					(yyval.ielem)->expr = NULL;
-					(yyval.ielem)->indexcolname = NULL;
-					(yyval.ielem)->collation = (yyvsp[(2) - (5)].list);
-					(yyval.ielem)->opclass = (yyvsp[(3) - (5)].list);
-					(yyval.ielem)->ordering = (yyvsp[(4) - (5)].sortorder);
-					(yyval.ielem)->nulls_ordering = (yyvsp[(5) - (5)].nullorder);
-				;}
-    break;
-
-  case 167:
-#line 204 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.ielem) = makeNode(PGIndexElem);
-					(yyval.ielem)->name = NULL;
-					(yyval.ielem)->expr = (yyvsp[(1) - (5)].node);
-					(yyval.ielem)->indexcolname = NULL;
-					(yyval.ielem)->collation = (yyvsp[(2) - (5)].list);
-					(yyval.ielem)->opclass = (yyvsp[(3) - (5)].list);
-					(yyval.ielem)->ordering = (yyvsp[(4) - (5)].sortorder);
-					(yyval.ielem)->nulls_ordering = (yyvsp[(5) - (5)].nullorder);
-				;}
-    break;
-
-  case 168:
-#line 215 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.ielem) = makeNode(PGIndexElem);
-					(yyval.ielem)->name = NULL;
-					(yyval.ielem)->expr = (yyvsp[(2) - (7)].node);
-					(yyval.ielem)->indexcolname = NULL;
-					(yyval.ielem)->collation = (yyvsp[(4) - (7)].list);
-					(yyval.ielem)->opclass = (yyvsp[(5) - (7)].list);
-					(yyval.ielem)->ordering = (yyvsp[(6) - (7)].sortorder);
-					(yyval.ielem)->nulls_ordering = (yyvsp[(7) - (7)].nullorder);
-				;}
-    break;
-
-  case 169:
-#line 229 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 170:
-#line 230 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 171:
-#line 236 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.override) = PG_OVERRIDING_USER_VALUE; ;}
-    break;
-
-  case 172:
-#line 237 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.override) = OVERRIDING_SYSTEM_VALUE; ;}
-    break;
-
-  case 173:
-#line 242 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;}
-    break;
-
-  case 174:
-#line 243 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].target)); ;}
-    break;
-
-  case 175:
-#line 249 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 176:
-#line 250 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 177:
-#line 254 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 178:
-#line 255 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 179:
-#line 261 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;}
-    break;
-
-  case 180:
-#line 263 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;}
-    break;
-
-  case 181:
-#line 268 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 182:
-#line 269 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_concat((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 183:
-#line 273 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 184:
-#line 274 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 185:
-#line 277 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].ielem)); ;}
-    break;
-
-  case 186:
-#line 278 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].ielem)); ;}
-    break;
-
-  case 187:
-#line 284 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(1) - (2)].str);
-					(yyval.target)->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.target)->val = NULL;	/* upper production sets this */
-					(yyval.target)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 188:
-#line 8 "third_party/libpg_query/grammar/statements/create_type.y"
-    {
-					PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt);
-					n->typeName = (yyvsp[(3) - (6)].range);
-					n->kind = PG_NEWTYPE_ENUM;
-					n->query = (yyvsp[(6) - (6)].node);
-					n->vals = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 189:
-#line 17 "third_party/libpg_query/grammar/statements/create_type.y"
-    {
-					PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt);
-					n->typeName = (yyvsp[(3) - (8)].range);
-					n->kind = PG_NEWTYPE_ENUM;
-					n->vals = (yyvsp[(7) - (8)].list);
-					n->query = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 190:
-#line 26 "third_party/libpg_query/grammar/statements/create_type.y"
-    {
-					PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt);
-					n->typeName = (yyvsp[(3) - (5)].range);
-					n->query = NULL;
-					auto name = std::string(reinterpret_cast<PGValue *>((yyvsp[(5) - (5)].typnam)->names->tail->data.ptr_value)->val.str);
-					if (name == "enum") {
-						n->kind = PG_NEWTYPE_ENUM;
-						n->vals = (yyvsp[(5) - (5)].typnam)->typmods;
-					} else {
-						n->kind = PG_NEWTYPE_ALIAS;
-						n->ofType = (yyvsp[(5) - (5)].typnam);
-					}
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 191:
-#line 46 "third_party/libpg_query/grammar/statements/create_type.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list);;}
-    break;
-
-  case 192:
-#line 47 "third_party/libpg_query/grammar/statements/create_type.y"
-    {(yyval.list) = NIL;;}
-    break;
-
-  case 193:
-#line 51 "third_party/libpg_query/grammar/statements/create_type.y"
-    {
-					(yyval.list) = list_make1(makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])));
-				;}
-    break;
-
-  case 194:
-#line 55 "third_party/libpg_query/grammar/statements/create_type.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)])));
-				;}
-    break;
-
-  case 195:
-#line 8 "third_party/libpg_query/grammar/statements/pragma.y"
-    {
-					PGPragmaStmt *n = makeNode(PGPragmaStmt);
-					n->kind = PG_PRAGMA_TYPE_NOTHING;
-					n->name = (yyvsp[(2) - (2)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 196:
-#line 15 "third_party/libpg_query/grammar/statements/pragma.y"
-    {
-					PGPragmaStmt *n = makeNode(PGPragmaStmt);
-					n->kind = PG_PRAGMA_TYPE_ASSIGNMENT;
-					n->name = (yyvsp[(2) - (4)].str);
-					n->args = (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 197:
-#line 23 "third_party/libpg_query/grammar/statements/pragma.y"
-    {
-					PGPragmaStmt *n = makeNode(PGPragmaStmt);
-					n->kind = PG_PRAGMA_TYPE_CALL;
-					n->name = (yyvsp[(2) - (5)].str);
-					n->args = (yyvsp[(4) - (5)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 198:
-#line 10 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    {
-					PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt);
-					(yyvsp[(4) - (5)].range)->relpersistence = (yyvsp[(2) - (5)].ival);
-					n->sequence = (yyvsp[(4) - (5)].range);
-					n->options = (yyvsp[(5) - (5)].list);
-					n->ownerId = InvalidOid;
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 199:
-#line 20 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    {
-					PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt);
-					(yyvsp[(7) - (8)].range)->relpersistence = (yyvsp[(2) - (8)].ival);
-					n->sequence = (yyvsp[(7) - (8)].range);
-					n->options = (yyvsp[(8) - (8)].list);
-					n->ownerId = InvalidOid;
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 200:
-#line 30 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    {
-					PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt);
-					(yyvsp[(6) - (7)].range)->relpersistence = (yyvsp[(4) - (7)].ival);
-					n->sequence = (yyvsp[(6) - (7)].range);
-					n->options = (yyvsp[(7) - (7)].list);
-					n->ownerId = InvalidOid;
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 201:
-#line 42 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 202:
-#line 43 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 203:
-#line 8 "third_party/libpg_query/grammar/statements/create_secret.y"
-    {
-					PGCreateSecretStmt *n = makeNode(PGCreateSecretStmt);
-					n->persist_type = (yyvsp[(2) - (8)].str);
-					n->secret_name = (yyvsp[(4) - (8)].str);
-					n->secret_storage = (yyvsp[(5) - (8)].str);
-					n->options = (yyvsp[(7) - (8)].list);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 204:
-#line 18 "third_party/libpg_query/grammar/statements/create_secret.y"
-    {
-					PGCreateSecretStmt *n = makeNode(PGCreateSecretStmt);
-					n->persist_type = (yyvsp[(2) - (11)].str);
-					n->secret_name = (yyvsp[(7) - (11)].str);
-					n->secret_storage = (yyvsp[(8) - (11)].str);
-					n->options = (yyvsp[(10) - (11)].list);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 205:
-#line 28 "third_party/libpg_query/grammar/statements/create_secret.y"
-    {
-					PGCreateSecretStmt *n = makeNode(PGCreateSecretStmt);
-					n->persist_type = (yyvsp[(4) - (10)].str);
-					n->secret_name = (yyvsp[(6) - (10)].str);
-					n->secret_storage = (yyvsp[(7) - (10)].str);
-					n->options = (yyvsp[(9) - (10)].list);
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 206:
-#line 40 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 207:
-#line 41 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 208:
-#line 45 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = pstrdup("default"); ;}
-    break;
-
-  case 209:
-#line 46 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = pstrdup("temporary"); ;}
-    break;
-
-  case 210:
-#line 47 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = pstrdup("persistent"); ;}
-    break;
-
-  case 211:
-#line 51 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = pstrdup(""); ;}
-    break;
-
-  case 212:
-#line 52 "third_party/libpg_query/grammar/statements/create_secret.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 213:
-#line 8 "third_party/libpg_query/grammar/statements/update_extensions.y"
-    {
-					PGUpdateExtensionsStmt *n = makeNode(PGUpdateExtensionsStmt);
-					n->extensions = (yyvsp[(4) - (4)].list);
-
-					if ((yyvsp[(1) - (4)].with)) {
-                          ereport(ERROR,
-                                  (errcode(PG_ERRCODE_SYNTAX_ERROR),
-                                   errmsg("Providing a with clause with an UPDATE EXTENSIONS statement is not allowed"),
-                                   parser_errposition((yylsp[(1) - (4)]))));
-                          break;
-                    }
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 214:
-#line 8 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGExecuteStmt *n = makeNode(PGExecuteStmt);
-					n->name = (yyvsp[(2) - (3)].str);
-					n->params = (yyvsp[(3) - (3)].list);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 215:
-#line 16 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					PGExecuteStmt *n = makeNode(PGExecuteStmt);
-					n->name = (yyvsp[(7) - (9)].str);
-					n->params = (yyvsp[(8) - (9)].list);
-					ctas->query = (PGNode *) n;
-					ctas->into = (yyvsp[(4) - (9)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_ERROR_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(4) - (9)].into)->rel->relpersistence = (yyvsp[(2) - (9)].ival);
-					(yyvsp[(4) - (9)].into)->skipData = !((yyvsp[(9) - (9)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 216:
-#line 33 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					PGExecuteStmt *n = makeNode(PGExecuteStmt);
-					n->name = (yyvsp[(10) - (12)].str);
-					n->params = (yyvsp[(11) - (12)].list);
-					ctas->query = (PGNode *) n;
-					ctas->into = (yyvsp[(7) - (12)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_IGNORE_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(7) - (12)].into)->rel->relpersistence = (yyvsp[(2) - (12)].ival);
-					(yyvsp[(7) - (12)].into)->skipData = !((yyvsp[(12) - (12)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 217:
-#line 52 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					(yyval.node) = (yyvsp[(1) - (1)].node);
-				;}
-    break;
-
-  case 218:
-#line 56 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-					na->name = (yyvsp[(1) - (3)].str);
-					na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-					na->argnumber = -1;		/* until determined */
-					na->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) na;
-				;}
-    break;
-
-  case 219:
-#line 66 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 220:
-#line 70 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 221:
-#line 75 "third_party/libpg_query/grammar/statements/execute.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 222:
-#line 76 "third_party/libpg_query/grammar/statements/execute.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 223:
-#line 10 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					PGAlterSeqStmt *n = makeNode(PGAlterSeqStmt);
-					n->sequence = (yyvsp[(3) - (4)].range);
-					n->options = (yyvsp[(4) - (4)].list);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 224:
-#line 18 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					PGAlterSeqStmt *n = makeNode(PGAlterSeqStmt);
-					n->sequence = (yyvsp[(5) - (6)].range);
-					n->options = (yyvsp[(6) - (6)].list);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 225:
-#line 29 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 226:
-#line 30 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;}
-    break;
-
-  case 227:
-#line 34 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 228:
-#line 35 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 229:
-#line 36 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 230:
-#line 41 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.value) = makeFloat((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 231:
-#line 42 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.value) = makeFloat((yyvsp[(2) - (2)].str)); ;}
-    break;
-
-  case 232:
-#line 44 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.value) = makeFloat((yyvsp[(2) - (2)].str));
-					doNegateFloat((yyval.value));
-				;}
-    break;
-
-  case 233:
-#line 48 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.value) = makeInteger((yyvsp[(1) - (1)].ival)); ;}
-    break;
-
-  case 234:
-#line 53 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("as", (PGNode *)(yyvsp[(2) - (2)].typnam), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 235:
-#line 57 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("cache", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 236:
-#line 61 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 237:
-#line 65 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(false), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 238:
-#line 69 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("increment", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 239:
-#line 73 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("maxvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 240:
-#line 77 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("minvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 241:
-#line 81 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("maxvalue", NULL, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 242:
-#line 85 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("minvalue", NULL, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 243:
-#line 89 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("owned_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 244:
-#line 93 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					/* not documented, only used by pg_dump */
-					(yyval.defelt) = makeDefElem("sequence_name", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 245:
-#line 98 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("start", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 246:
-#line 102 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 247:
-#line 106 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 248:
-#line 112 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 249:
-#line 113 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 250:
-#line 117 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;}
-    break;
-
-  case 251:
-#line 118 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.ival) = + (yyvsp[(2) - (2)].ival); ;}
-    break;
-
-  case 252:
-#line 119 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.ival) = - (yyvsp[(2) - (2)].ival); ;}
-    break;
-
-  case 253:
-#line 8 "third_party/libpg_query/grammar/statements/drop_secret.y"
-    {
-					PGDropSecretStmt *n = makeNode(PGDropSecretStmt);
-					n->persist_type = (yyvsp[(2) - (5)].str);
-					n->secret_name = (yyvsp[(4) - (5)].str);
-					n->secret_storage = (yyvsp[(5) - (5)].str);
-					n->missing_ok  = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 254:
-#line 17 "third_party/libpg_query/grammar/statements/drop_secret.y"
-    {
-                    PGDropSecretStmt *n = makeNode(PGDropSecretStmt);
-                    n->persist_type = (yyvsp[(2) - (7)].str);
-                    n->secret_name = (yyvsp[(6) - (7)].str);
-                    n->secret_storage = (yyvsp[(7) - (7)].str);
-                    n->missing_ok  = true;
-                    (yyval.node) = (PGNode *)n;
-                ;}
-    break;
-
-  case 255:
-#line 28 "third_party/libpg_query/grammar/statements/drop_secret.y"
-    { (yyval.str) = pstrdup(""); ;}
-    break;
-
-  case 256:
-#line 29 "third_party/libpg_query/grammar/statements/drop_secret.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 257:
-#line 3 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_ROLLBACK;
-					n->options = NIL;
-					n->transaction_type = PG_TRANS_TYPE_DEFAULT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 258:
-#line 11 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_BEGIN;
-					n->transaction_type = (yyvsp[(3) - (3)].transactiontype);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 259:
-#line 18 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_START;
-					n->transaction_type = (yyvsp[(3) - (3)].transactiontype);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 260:
-#line 25 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_COMMIT;
-					n->options = NIL;
-					n->transaction_type = PG_TRANS_TYPE_DEFAULT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 261:
-#line 33 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_COMMIT;
-					n->options = NIL;
-					n->transaction_type = PG_TRANS_TYPE_DEFAULT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 262:
-#line 41 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_ROLLBACK;
-					n->options = NIL;
-					n->transaction_type = PG_TRANS_TYPE_DEFAULT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 263:
-#line 51 "third_party/libpg_query/grammar/statements/transaction.y"
-    {;}
-    break;
-
-  case 264:
-#line 52 "third_party/libpg_query/grammar/statements/transaction.y"
-    {;}
-    break;
-
-  case 265:
-#line 53 "third_party/libpg_query/grammar/statements/transaction.y"
-    {;}
-    break;
-
-  case 266:
-#line 57 "third_party/libpg_query/grammar/statements/transaction.y"
-    { (yyval.transactiontype) = PG_TRANS_TYPE_READ_ONLY; ;}
-    break;
-
-  case 267:
-#line 58 "third_party/libpg_query/grammar/statements/transaction.y"
-    { (yyval.transactiontype) = PG_TRANS_TYPE_READ_WRITE; ;}
-    break;
-
-  case 268:
-#line 59 "third_party/libpg_query/grammar/statements/transaction.y"
-    { (yyval.transactiontype) = PG_TRANS_TYPE_DEFAULT; ;}
-    break;
-
-  case 269:
-#line 3 "third_party/libpg_query/grammar/statements/use.y"
-    {
-					PGUseStmt *n = makeNode(PGUseStmt);
-					n->name = (yyvsp[(2) - (2)].range);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 270:
-#line 9 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGCreateStmt *n = makeNode(PGCreateStmt);
-					(yyvsp[(4) - (9)].range)->relpersistence = (yyvsp[(2) - (9)].ival);
-					n->relation = (yyvsp[(4) - (9)].range);
-					n->tableElts = (yyvsp[(6) - (9)].list);
-					n->ofTypename = NULL;
-					n->constraints = NIL;
-					n->options = (yyvsp[(8) - (9)].list);
-					n->oncommit = (yyvsp[(9) - (9)].oncommit);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 271:
-#line 24 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGCreateStmt *n = makeNode(PGCreateStmt);
-					(yyvsp[(7) - (12)].range)->relpersistence = (yyvsp[(2) - (12)].ival);
-					n->relation = (yyvsp[(7) - (12)].range);
-					n->tableElts = (yyvsp[(9) - (12)].list);
-					n->ofTypename = NULL;
-					n->constraints = NIL;
-					n->options = (yyvsp[(11) - (12)].list);
-					n->oncommit = (yyvsp[(12) - (12)].oncommit);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 272:
-#line 39 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGCreateStmt *n = makeNode(PGCreateStmt);
-					(yyvsp[(6) - (11)].range)->relpersistence = (yyvsp[(4) - (11)].ival);
-					n->relation = (yyvsp[(6) - (11)].range);
-					n->tableElts = (yyvsp[(8) - (11)].list);
-					n->ofTypename = NULL;
-					n->constraints = NIL;
-					n->options = (yyvsp[(10) - (11)].list);
-					n->oncommit = (yyvsp[(11) - (11)].oncommit);
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 273:
-#line 56 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 274:
-#line 58 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					/*
-					 * We must complain about conflicting options.
-					 * We could, but choose not to, complain about redundant
-					 * options (ie, where $2's bit is already set in $1).
-					 */
-					int		newspec = (yyvsp[(1) - (2)].ival) | (yyvsp[(2) - (2)].ival);
-
-					/* special message for this case */
-					if ((newspec & (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED)) == (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
-								 parser_errposition((yylsp[(2) - (2)]))));
-					/* generic message for other conflicts */
-					if ((newspec & (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE)) == (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE) ||
-						(newspec & (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED)) == (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("conflicting constraint properties"),
-								 parser_errposition((yylsp[(2) - (2)]))));
-					(yyval.ival) = newspec;
-				;}
-    break;
-
-  case 275:
-#line 84 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 276:
-#line 85 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;}
-    break;
-
-  case 277:
-#line 86 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 278:
-#line 87 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].value); ;}
-    break;
-
-  case 279:
-#line 88 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 280:
-#line 89 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;}
-    break;
-
-  case 281:
-#line 93 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 282:
-#line 94 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 283:
-#line 99 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 284:
-#line 104 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; ;}
-    break;
-
-  case 285:
-#line 105 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; ;}
-    break;
-
-  case 286:
-#line 106 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; ;}
-    break;
-
-  case 287:
-#line 107 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; ;}
-    break;
-
-  case 288:
-#line 108 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; ;}
-    break;
-
-  case 289:
-#line 114 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node));
-					n->conname = (yyvsp[(2) - (3)].str);
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 290:
-#line 120 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 291:
-#line 121 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 292:
-#line 123 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					/*
-					 * Note: the PGCollateClause is momentarily included in
-					 * the list built by ColQualList, but we split it out
-					 * again in SplitColQualList.
-					 */
-					PGCollateClause *n = makeNode(PGCollateClause);
-					n->arg = NULL;
-					n->collname = (yyvsp[(2) - (2)].list);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 293:
-#line 140 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_NOTNULL;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 294:
-#line 147 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_NULL;
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 295:
-#line 154 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_UNIQUE;
-					n->location = (yylsp[(1) - (2)]);
-					n->keys = NULL;
-					n->options = (yyvsp[(2) - (2)].list);
-					n->indexname = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 296:
-#line 164 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_PRIMARY;
-					n->location = (yylsp[(1) - (3)]);
-					n->keys = NULL;
-					n->options = (yyvsp[(3) - (3)].list);
-					n->indexname = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 297:
-#line 174 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_CHECK;
-					n->location = (yylsp[(1) - (5)]);
-					n->is_no_inherit = (yyvsp[(5) - (5)].boolean);
-					n->raw_expr = (yyvsp[(3) - (5)].node);
-					n->cooked_expr = NULL;
-					n->skip_validation = false;
-					n->initially_valid = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 298:
-#line 186 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_COMPRESSION;
-					n->location = (yylsp[(1) - (3)]);
-					n->compression_name = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 299:
-#line 194 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_DEFAULT;
-					n->location = (yylsp[(1) - (2)]);
-					n->raw_expr = (yyvsp[(2) - (2)].node);
-					n->cooked_expr = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 300:
-#line 203 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_FOREIGN;
-					n->location = (yylsp[(1) - (5)]);
-					n->pktable			= (yyvsp[(2) - (5)].range);
-					n->fk_attrs			= NIL;
-					n->pk_attrs			= (yyvsp[(3) - (5)].list);
-					n->fk_matchtype		= (yyvsp[(4) - (5)].ival);
-					n->fk_upd_action	= (char) ((yyvsp[(5) - (5)].ival) >> 8);
-					n->fk_del_action	= (char) ((yyvsp[(5) - (5)].ival) & 0xFF);
-					n->skip_validation  = false;
-					n->initially_valid  = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 301:
-#line 220 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;}
-    break;
-
-  case 302:
-#line 221 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = PG_CONSTR_GENERATED_STORED; ;}
-    break;
-
-  case 303:
-#line 225 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = (yyvsp[(1) - (1)].constr); ;}
-    break;
-
-  case 304:
-#line 226 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;}
-    break;
-
-  case 305:
-#line 231 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_IDENTITY;
-					n->generated_when = (yyvsp[(2) - (5)].ival);
-					n->options = (yyvsp[(5) - (5)].list);
-					n->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 306:
-#line 240 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = (yyvsp[(7) - (7)].constr);
-					n->generated_when = (yyvsp[(2) - (7)].ival);
-					n->raw_expr = (yyvsp[(5) - (7)].node);
-					n->cooked_expr = NULL;
-					n->location = (yylsp[(1) - (7)]);
-
-					/*
-					 * Can't do this in the grammar because of shift/reduce
-					 * conflicts.  (IDENTITY allows both ALWAYS and BY
-					 * DEFAULT, but generated columns only allow ALWAYS.)  We
-					 * can also give a more useful error message and location.
-					 */
-					if ((yyvsp[(2) - (7)].ival) != PG_ATTRIBUTE_IDENTITY_ALWAYS)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("for a generated column, GENERATED ALWAYS must be specified"),
-								 parser_errposition((yylsp[(2) - (7)]))));
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 307:
-#line 263 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = (yyvsp[(5) - (5)].constr);
-					n->generated_when = PG_ATTRIBUTE_IDENTITY_ALWAYS;
-					n->raw_expr = (yyvsp[(3) - (5)].node);
-					n->cooked_expr = NULL;
-					n->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 308:
-#line 277 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 309:
-#line 283 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 310:
-#line 289 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ((yyvsp[(1) - (1)].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;}
-    break;
-
-  case 311:
-#line 291 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[(1) - (1)].ival) & 0xFF); ;}
-    break;
-
-  case 312:
-#line 293 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ((yyvsp[(1) - (2)].ival) << 8) | ((yyvsp[(2) - (2)].ival) & 0xFF); ;}
-    break;
-
-  case 313:
-#line 295 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ((yyvsp[(2) - (2)].ival) << 8) | ((yyvsp[(1) - (2)].ival) & 0xFF); ;}
-    break;
-
-  case 314:
-#line 297 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;}
-    break;
-
-  case 315:
-#line 300 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = ONCOMMIT_DROP; ;}
-    break;
-
-  case 316:
-#line 301 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; ;}
-    break;
-
-  case 317:
-#line 302 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; ;}
-    break;
-
-  case 318:
-#line 303 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = PG_ONCOMMIT_NOOP; ;}
-    break;
-
-  case 319:
-#line 308 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 320:
-#line 312 "third_party/libpg_query/grammar/statements/create.y"
-    {  (yyval.boolean) = true; ;}
-    break;
-
-  case 321:
-#line 313 "third_party/libpg_query/grammar/statements/create.y"
-    {  (yyval.boolean) = false; ;}
-    break;
-
-  case 322:
-#line 319 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node));
-					n->conname = (yyvsp[(2) - (3)].str);
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 323:
-#line 325 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 324:
-#line 330 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; ;}
-    break;
-
-  case 325:
-#line 331 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; ;}
-    break;
-
-  case 326:
-#line 332 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; ;}
-    break;
-
-  case 327:
-#line 333 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; ;}
-    break;
-
-  case 328:
-#line 334 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; ;}
-    break;
-
-  case 329:
-#line 335 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; ;}
-    break;
-
-  case 330:
-#line 336 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; ;}
-    break;
-
-  case 331:
-#line 337 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; ;}
-    break;
-
-  case 332:
-#line 343 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 333:
-#line 344 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;}
-    break;
-
-  case 334:
-#line 348 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.str) = (yyvsp[(3) - (3)].str); ;}
-    break;
-
-  case 335:
-#line 354 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_DEFERRABLE;
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 336:
-#line 361 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_NOT_DEFERRABLE;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 337:
-#line 368 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_DEFERRED;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 338:
-#line 375 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_IMMEDIATE;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 339:
-#line 386 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 340:
-#line 387 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 341:
-#line 388 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 342:
-#line 389 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 343:
-#line 393 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 344:
-#line 398 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 345:
-#line 399 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 346:
-#line 400 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 347:
-#line 405 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 348:
-#line 410 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_NOT_DEFERRABLE; ;}
-    break;
-
-  case 349:
-#line 411 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_DEFERRABLE; ;}
-    break;
-
-  case 350:
-#line 412 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; ;}
-    break;
-
-  case 351:
-#line 413 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_INITIALLY_DEFERRED; ;}
-    break;
-
-  case 352:
-#line 414 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_NOT_VALID; ;}
-    break;
-
-  case 353:
-#line 415 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_NO_INHERIT; ;}
-    break;
-
-  case 354:
-#line 421 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGColumnDef *n = makeNode(PGColumnDef);
-					n->category = COL_STANDARD;
-					n->colname = (yyvsp[(1) - (3)].str);
-					n->typeName = (yyvsp[(2) - (3)].typnam);
-					n->inhcount = 0;
-					n->is_local = true;
-					n->is_not_null = false;
-					n->is_from_type = false;
-					n->storage = 0;
-					n->raw_default = NULL;
-					n->cooked_default = NULL;
-					n->collOid = InvalidOid;
-					SplitColQualList((yyvsp[(3) - (3)].list), &n->constraints, &n->collClause,
-									 yyscanner);
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 355:
-#line 441 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGColumnDef *n = makeNode(PGColumnDef);
-					n->category = COL_GENERATED;
-					n->colname = (yyvsp[(1) - (4)].str);
-					n->typeName = (yyvsp[(2) - (4)].typnam);
-					n->inhcount = 0;
-					n->is_local = true;
-					n->is_not_null = false;
-					n->is_from_type = false;
-					n->storage = 0;
-					n->raw_default = NULL;
-					n->cooked_default = NULL;
-					n->collOid = InvalidOid;
-					// merge the constraints with the generated column constraint
-					auto constraints = (yyvsp[(4) - (4)].list);
-					if (constraints) {
-					    constraints = lappend(constraints, (yyvsp[(3) - (4)].node));
-					} else {
-					    constraints = list_make1((yyvsp[(3) - (4)].node));
-					}
-					SplitColQualList(constraints, &n->constraints, &n->collClause,
-									 yyscanner);
-					n->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 356:
-#line 469 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 357:
-#line 470 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;}
-    break;
-
-  case 358:
-#line 474 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 359:
-#line 478 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 360:
-#line 479 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 361:
-#line 480 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 362:
-#line 485 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 363:
-#line 489 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 364:
-#line 496 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 365:
-#line 497 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 366:
-#line 502 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 367:
-#line 503 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 368:
-#line 504 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 369:
-#line 509 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str));
-				;}
-    break;
-
-  case 370:
-#line 516 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 371:
-#line 517 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 372:
-#line 522 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 373:
-#line 523 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 374:
-#line 527 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 375:
-#line 533 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 376:
-#line 537 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 377:
-#line 541 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (PGNode *) (yyvsp[(5) - (5)].node),
-											 PG_DEFELEM_UNSPEC, (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 378:
-#line 546 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL, PG_DEFELEM_UNSPEC, (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 379:
-#line 553 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 380:
-#line 554 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 381:
-#line 558 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 382:
-#line 559 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 383:
-#line 563 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 384:
-#line 565 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(1) - (4)].str)), (yyvsp[(2) - (4)].list)));
-					(yyval.typnam)->pct_type = true;
-					(yyval.typnam)->location = (yylsp[(1) - (4)]);
-				;}
-    break;
-
-  case 385:
-#line 571 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].list)));
-					(yyval.typnam)->pct_type = true;
-					(yyval.typnam)->setof = true;
-					(yyval.typnam)->location = (yylsp[(2) - (5)]);
-				;}
-    break;
-
-  case 386:
-#line 582 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_CHECK;
-					n->location = (yylsp[(1) - (5)]);
-					n->raw_expr = (yyvsp[(3) - (5)].node);
-					n->cooked_expr = NULL;
-					processCASbits((yyvsp[(5) - (5)].ival), (yylsp[(5) - (5)]), "CHECK",
-								   NULL, NULL, &n->skip_validation,
-								   &n->is_no_inherit, yyscanner);
-					n->initially_valid = !n->skip_validation;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 387:
-#line 596 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_UNIQUE;
-					n->location = (yylsp[(1) - (6)]);
-					n->keys = (yyvsp[(3) - (6)].list);
-					n->options = (yyvsp[(5) - (6)].list);
-					n->indexname = NULL;
-					processCASbits((yyvsp[(6) - (6)].ival), (yylsp[(6) - (6)]), "UNIQUE",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 388:
-#line 609 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_UNIQUE;
-					n->location = (yylsp[(1) - (3)]);
-					n->keys = NIL;
-					n->options = NIL;
-					n->indexname = (yyvsp[(2) - (3)].str);
-					n->indexspace = NULL;
-					processCASbits((yyvsp[(3) - (3)].ival), (yylsp[(3) - (3)]), "UNIQUE",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 389:
-#line 624 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_PRIMARY;
-					n->location = (yylsp[(1) - (7)]);
-					n->keys = (yyvsp[(4) - (7)].list);
-					n->options = (yyvsp[(6) - (7)].list);
-					n->indexname = NULL;
-					processCASbits((yyvsp[(7) - (7)].ival), (yylsp[(7) - (7)]), "PRIMARY KEY",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 390:
-#line 637 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_PRIMARY;
-					n->location = (yylsp[(1) - (4)]);
-					n->keys = NIL;
-					n->options = NIL;
-					n->indexname = (yyvsp[(3) - (4)].str);
-					n->indexspace = NULL;
-					processCASbits((yyvsp[(4) - (4)].ival), (yylsp[(4) - (4)]), "PRIMARY KEY",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 391:
-#line 652 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_FOREIGN;
-					n->location = (yylsp[(1) - (11)]);
-					n->pktable			= (yyvsp[(7) - (11)].range);
-					n->fk_attrs			= (yyvsp[(4) - (11)].list);
-					n->pk_attrs			= (yyvsp[(8) - (11)].list);
-					n->fk_matchtype		= (yyvsp[(9) - (11)].ival);
-					n->fk_upd_action	= (char) ((yyvsp[(10) - (11)].ival) >> 8);
-					n->fk_del_action	= (char) ((yyvsp[(10) - (11)].ival) & 0xFF);
-					processCASbits((yyvsp[(11) - (11)].ival), (yylsp[(11) - (11)]), "FOREIGN KEY",
-								   &n->deferrable, &n->initdeferred,
-								   &n->skip_validation, NULL,
-								   yyscanner);
-					n->initially_valid = !n->skip_validation;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 392:
-#line 674 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 393:
-#line 678 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 394:
-#line 685 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				(yyval.ival) = PG_FKCONSTR_MATCH_FULL;
-			;}
-    break;
-
-  case 395:
-#line 689 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				ereport(ERROR,
-						(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-						 errmsg("MATCH PARTIAL not yet implemented"),
-						 parser_errposition((yylsp[(1) - (2)]))));
-				(yyval.ival) = PG_FKCONSTR_MATCH_PARTIAL;
-			;}
-    break;
-
-  case 396:
-#line 697 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				(yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE;
-			;}
-    break;
-
-  case 397:
-#line 701 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				(yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE;
-			;}
-    break;
-
-  case 398:
-#line 709 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGTableLikeClause *n = makeNode(PGTableLikeClause);
-					n->relation = (yyvsp[(2) - (3)].range);
-					n->options = (yyvsp[(3) - (3)].ival);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 399:
-#line 718 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 400:
-#line 719 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 401:
-#line 720 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 402:
-#line 721 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 403:
-#line 723 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (2)]))));
-					(yyval.ival) = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 404:
-#line 730 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (2)]))));
-					(yyval.ival) = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 405:
-#line 736 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; ;}
-    break;
-
-  case 406:
-#line 737 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = RELPERSISTENCE_PERMANENT; ;}
-    break;
-
-  case 407:
-#line 742 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; ;}
-    break;
-
-  case 408:
-#line 743 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; ;}
-    break;
-
-  case 409:
-#line 10 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (6)].objtype);
-					n->missing_ok = true;
-					n->objects = (yyvsp[(5) - (6)].list);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 410:
-#line 20 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (4)].objtype);
-					n->missing_ok = false;
-					n->objects = (yyvsp[(3) - (4)].list);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 411:
-#line 30 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (6)].objtype);
-					n->missing_ok = true;
-					n->objects = (yyvsp[(5) - (6)].list);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 412:
-#line 40 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (4)].objtype);
-					n->missing_ok = false;
-					n->objects = (yyvsp[(3) - (4)].list);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 413:
-#line 50 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (6)].objtype);
-					n->objects = list_make1(lappend((yyvsp[(5) - (6)].list), makeString((yyvsp[(3) - (6)].str))));
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->missing_ok = false;
-					n->concurrent = false;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 414:
-#line 60 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (8)].objtype);
-					n->objects = list_make1(lappend((yyvsp[(7) - (8)].list), makeString((yyvsp[(5) - (8)].str))));
-					n->behavior = (yyvsp[(8) - (8)].dbehavior);
-					n->missing_ok = true;
-					n->concurrent = false;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 415:
-#line 73 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TABLE; ;}
-    break;
-
-  case 416:
-#line 74 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;}
-    break;
-
-  case 417:
-#line 75 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FUNCTION; ;}
-    break;
-
-  case 418:
-#line 76 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FUNCTION; ;}
-    break;
-
-  case 419:
-#line 77 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;}
-    break;
-
-  case 420:
-#line 78 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_VIEW; ;}
-    break;
-
-  case 421:
-#line 79 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_MATVIEW; ;}
-    break;
-
-  case 422:
-#line 80 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_INDEX; ;}
-    break;
-
-  case 423:
-#line 81 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; ;}
-    break;
-
-  case 424:
-#line 82 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_COLLATION; ;}
-    break;
-
-  case 425:
-#line 83 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_CONVERSION; ;}
-    break;
-
-  case 426:
-#line 84 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_SCHEMA; ;}
-    break;
-
-  case 427:
-#line 85 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; ;}
-    break;
-
-  case 428:
-#line 86 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSPARSER; ;}
-    break;
-
-  case 429:
-#line 87 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; ;}
-    break;
-
-  case 430:
-#line 88 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; ;}
-    break;
-
-  case 431:
-#line 89 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; ;}
-    break;
-
-  case 432:
-#line 90 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TYPE; ;}
-    break;
-
-  case 433:
-#line 95 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; ;}
-    break;
-
-  case 434:
-#line 96 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; ;}
-    break;
-
-  case 435:
-#line 97 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_EXTENSION; ;}
-    break;
-
-  case 436:
-#line 98 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FDW; ;}
-    break;
-
-  case 437:
-#line 99 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_PUBLICATION; ;}
-    break;
-
-  case 438:
-#line 100 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; ;}
-    break;
-
-  case 439:
-#line 105 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 440:
-#line 106 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 441:
-#line 111 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.dbehavior) = PG_DROP_CASCADE; ;}
-    break;
-
-  case 442:
-#line 112 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.dbehavior) = PG_DROP_RESTRICT; ;}
-    break;
-
-  case 443:
-#line 113 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ ;}
-    break;
-
-  case 444:
-#line 118 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_POLICY; ;}
-    break;
-
-  case 445:
-#line 119 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_RULE; ;}
-    break;
-
-  case 446:
-#line 120 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TRIGGER; ;}
-    break;
-
-  case 447:
-#line 9 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				(yyvsp[(4) - (5)].range)->relpersistence = (yyvsp[(2) - (5)].ival);
-				n->name = (yyvsp[(4) - (5)].range);
-				n->functions = (yyvsp[(5) - (5)].list);
-				n->onconflict = PG_ERROR_ON_CONFLICT;
-				(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 448:
-#line 19 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				(yyvsp[(7) - (8)].range)->relpersistence = (yyvsp[(2) - (8)].ival);
-				n->name = (yyvsp[(7) - (8)].range);
-				n->functions = (yyvsp[(8) - (8)].list);
-				n->onconflict = PG_IGNORE_ON_CONFLICT;
-				(yyval.node) = (PGNode *)n;
-
-			;}
-    break;
-
-  case 449:
-#line 30 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				(yyvsp[(6) - (7)].range)->relpersistence = (yyvsp[(4) - (7)].ival);
-				n->name = (yyvsp[(6) - (7)].range);
-				n->functions = (yyvsp[(7) - (7)].list);
-				n->onconflict = PG_REPLACE_ON_CONFLICT;
-				(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 450:
-#line 40 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				(yyvsp[(4) - (5)].range)->relpersistence = (yyvsp[(2) - (5)].ival);
-				n->name = (yyvsp[(4) - (5)].range);
-				n->functions = (yyvsp[(5) - (5)].list);
-				n->onconflict = PG_ERROR_ON_CONFLICT;
-				(yyval.node) = (PGNode *)n;
-             ;}
-    break;
-
-  case 451:
-#line 50 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				(yyvsp[(7) - (8)].range)->relpersistence = (yyvsp[(2) - (8)].ival);
-				n->name = (yyvsp[(7) - (8)].range);
-				n->functions = (yyvsp[(8) - (8)].list);
-				n->onconflict = PG_IGNORE_ON_CONFLICT;
-				(yyval.node) = (PGNode *)n;
-			 ;}
-    break;
-
-  case 452:
-#line 60 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				(yyvsp[(6) - (7)].range)->relpersistence = (yyvsp[(4) - (7)].ival);
-				n->name = (yyvsp[(6) - (7)].range);
-				n->functions = (yyvsp[(7) - (7)].list);
-				n->onconflict = PG_REPLACE_ON_CONFLICT;
-				(yyval.node) = (PGNode *)n;
-			 ;}
-    break;
-
-  case 453:
-#line 72 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGFunctionDefinition *n = makeNode(PGFunctionDefinition);
-				n->params = (yyvsp[(1) - (4)].list);
-				n->query = (yyvsp[(4) - (4)].node);
-				(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 454:
-#line 82 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGFunctionDefinition *n = makeNode(PGFunctionDefinition);
-				n->params = (yyvsp[(1) - (4)].list);
-				n->query = (yyvsp[(4) - (4)].node);
-				(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 455:
-#line 92 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-			;}
-    break;
-
-  case 456:
-#line 96 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-			;}
-    break;
-
-  case 457:
-#line 103 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-			;}
-    break;
-
-  case 459:
-#line 111 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGFunctionDefinition *n = makeNode(PGFunctionDefinition);
-				n->params = (yyvsp[(1) - (3)].list);
-				n->function = (yyvsp[(3) - (3)].node);
-				(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 460:
-#line 120 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 461:
-#line 124 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 464:
-#line 136 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = NIL;
-			;}
-    break;
-
-  case 465:
-#line 140 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = (yyvsp[(2) - (3)].list);
-			;}
-    break;
-
-  case 466:
-#line 12 "third_party/libpg_query/grammar/statements/update.y"
-    {
-					PGUpdateStmt *n = makeNode(PGUpdateStmt);
-					n->relation = (yyvsp[(3) - (8)].range);
-					n->targetList = (yyvsp[(5) - (8)].list);
-					n->fromClause = (yyvsp[(6) - (8)].list);
-					n->whereClause = (yyvsp[(7) - (8)].node);
-					n->returningList = (yyvsp[(8) - (8)].list);
-					n->withClause = (yyvsp[(1) - (8)].with);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 467:
-#line 3 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					PGCopyStmt *n = makeNode(PGCopyStmt);
-					n->relation = (yyvsp[(3) - (11)].range);
-					n->query = NULL;
-					n->attlist = (yyvsp[(4) - (11)].list);
-					n->is_from = (yyvsp[(6) - (11)].boolean);
-					n->is_program = (yyvsp[(7) - (11)].boolean);
-					n->filename = (yyvsp[(8) - (11)].str);
-
-					if (n->is_program && n->filename == NULL)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("STDIN/STDOUT not allowed with PROGRAM"),
-								 parser_errposition((yylsp[(8) - (11)]))));
-
-					n->options = NIL;
-					/* Concatenate user-supplied flags */
-					if ((yyvsp[(2) - (11)].defelt))
-						n->options = lappend(n->options, (yyvsp[(2) - (11)].defelt));
-					if ((yyvsp[(5) - (11)].defelt))
-						n->options = lappend(n->options, (yyvsp[(5) - (11)].defelt));
-					if ((yyvsp[(9) - (11)].defelt))
-						n->options = lappend(n->options, (yyvsp[(9) - (11)].defelt));
-					if ((yyvsp[(11) - (11)].list))
-						n->options = list_concat(n->options, (yyvsp[(11) - (11)].list));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 468:
-#line 31 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					PGCopyStmt *n = makeNode(PGCopyStmt);
-					n->relation = NULL;
-					n->query = (yyvsp[(3) - (9)].node);
-					n->attlist = NIL;
-					n->is_from = false;
-					n->is_program = (yyvsp[(6) - (9)].boolean);
-					n->filename = (yyvsp[(7) - (9)].str);
-					n->options = (yyvsp[(9) - (9)].list);
-
-					if (n->is_program && n->filename == NULL)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("STDIN/STDOUT not allowed with PROGRAM"),
-								 parser_errposition((yylsp[(5) - (9)]))));
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 469:
-#line 50 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-				PGCopyDatabaseStmt *n = makeNode(PGCopyDatabaseStmt);
-				n->from_database = (yyvsp[(4) - (7)].str);
-				n->to_database = (yyvsp[(6) - (7)].str);
-				n->copy_database_flag = (yyvsp[(7) - (7)].conststr);
-				(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 470:
-#line 61 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.conststr) = NULL; ;}
-    break;
-
-  case 471:
-#line 62 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.conststr) = "schema"; ;}
-    break;
-
-  case 472:
-#line 63 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.conststr) = "data"; ;}
-    break;
-
-  case 473:
-#line 67 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 474:
-#line 68 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 475:
-#line 74 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 476:
-#line 77 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.defelt) = NULL; ;}
-    break;
-
-  case 477:
-#line 83 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 478:
-#line 87 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 479:
-#line 94 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 480:
-#line 95 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 481:
-#line 99 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 482:
-#line 100 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 483:
-#line 105 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 484:
-#line 106 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 485:
-#line 110 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 486:
-#line 111 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 487:
-#line 116 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 488:
-#line 117 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;}
-    break;
-
-  case 489:
-#line 118 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 490:
-#line 119 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) makeNode(PGAStar); ;}
-    break;
-
-  case 491:
-#line 120 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 492:
-#line 121 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 493:
-#line 122 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 494:
-#line 123 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 495:
-#line 129 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 496:
-#line 137 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 497:
-#line 140 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.defelt) = NULL; ;}
-    break;
-
-  case 498:
-#line 145 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;}
-    break;
-
-  case 499:
-#line 146 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 500:
-#line 152 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 501:
-#line 155 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.defelt) = NULL; ;}
-    break;
-
-  case 502:
-#line 161 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 503:
-#line 165 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 504:
-#line 169 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("freeze", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 505:
-#line 173 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 506:
-#line 177 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("null", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 507:
-#line 181 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("format", (PGNode *)makeString("csv"), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 508:
-#line 185 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("header", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 509:
-#line 189 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("quote", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 510:
-#line 193 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("escape", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 511:
-#line 197 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 512:
-#line 201 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 513:
-#line 205 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("partition_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 514:
-#line 209 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("partition_by", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 515:
-#line 213 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[(4) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 516:
-#line 217 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 517:
-#line 221 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("encoding", (PGNode *)makeString((yyvsp[(2) - (2)].str)), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 518:
-#line 228 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 519:
-#line 233 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 520:
-#line 234 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 521:
-#line 235 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 522:
-#line 236 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;}
-    break;
-
-  case 523:
-#line 237 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 524:
-#line 244 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].defelt));
-				;}
-    break;
-
-  case 525:
-#line 248 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt));
-				;}
-    break;
-
-  case 528:
-#line 52 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (3)].node); ;}
-    break;
-
-  case 529:
-#line 53 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (3)].node); ;}
-    break;
-
-  case 530:
-#line 55 "third_party/libpg_query/grammar/statements/select.y"
-    {
-		    	(yyval.node) = (yyvsp[(2) - (3)].node);
-			;}
-    break;
-
-  case 531:
-#line 72 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 532:
-#line 74 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list), NIL,
-										NULL, NULL, NULL,
-										yyscanner);
-					(yyval.node) = (yyvsp[(1) - (2)].node);
-				;}
-    break;
-
-  case 533:
-#line 81 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(3) - (4)].list),
-										(PGNode*) list_nth((yyvsp[(4) - (4)].list), 0), (PGNode*) list_nth((yyvsp[(4) - (4)].list), 1),
-										NULL,
-										yyscanner);
-					(yyval.node) = (yyvsp[(1) - (4)].node);
-				;}
-    break;
-
-  case 534:
-#line 89 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(4) - (4)].list),
-										(PGNode*) list_nth((yyvsp[(3) - (4)].list), 0), (PGNode*) list_nth((yyvsp[(3) - (4)].list), 1),
-										NULL,
-										yyscanner);
-					(yyval.node) = (yyvsp[(1) - (4)].node);
-				;}
-    break;
-
-  case 535:
-#line 97 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (2)].node), NULL, NIL,
-										NULL, NULL,
-										(yyvsp[(1) - (2)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (2)].node);
-				;}
-    break;
-
-  case 536:
-#line 105 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].list), NIL,
-										NULL, NULL,
-										(yyvsp[(1) - (3)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (3)].node);
-				;}
-    break;
-
-  case 537:
-#line 113 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(4) - (5)].list),
-										(PGNode*) list_nth((yyvsp[(5) - (5)].list), 0), (PGNode*) list_nth((yyvsp[(5) - (5)].list), 1),
-										(yyvsp[(1) - (5)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (5)].node);
-				;}
-    break;
-
-  case 538:
-#line 121 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list),
-										(PGNode*) list_nth((yyvsp[(4) - (5)].list), 0), (PGNode*) list_nth((yyvsp[(4) - (5)].list), 1),
-										(yyvsp[(1) - (5)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (5)].node);
-				;}
-    break;
-
-  case 539:
-#line 131 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 540:
-#line 132 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 541:
-#line 160 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.list) = (yyvsp[(3) - (3)].list);
-			;}
-    break;
-
-  case 542:
-#line 164 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGAStar *star = makeNode(PGAStar);
-				(yyval.list) = list_make1(star);
-			;}
-    break;
-
-  case 543:
-#line 175 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->targetList = (yyvsp[(3) - (11)].list);
-					n->intoClause = (yyvsp[(4) - (11)].into);
-					n->fromClause = (yyvsp[(5) - (11)].list);
-					n->whereClause = (yyvsp[(6) - (11)].node);
-					n->groupClause = (yyvsp[(7) - (11)].list);
-					n->havingClause = (yyvsp[(8) - (11)].node);
-					n->windowClause = (yyvsp[(9) - (11)].list);
-					n->qualifyClause = (yyvsp[(10) - (11)].node);
-					n->sampleOptions = (yyvsp[(11) - (11)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 544:
-#line 191 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->distinctClause = (yyvsp[(2) - (11)].list);
-					n->targetList = (yyvsp[(3) - (11)].list);
-					n->intoClause = (yyvsp[(4) - (11)].into);
-					n->fromClause = (yyvsp[(5) - (11)].list);
-					n->whereClause = (yyvsp[(6) - (11)].node);
-					n->groupClause = (yyvsp[(7) - (11)].list);
-					n->havingClause = (yyvsp[(8) - (11)].node);
-					n->windowClause = (yyvsp[(9) - (11)].list);
-					n->qualifyClause = (yyvsp[(10) - (11)].node);
-					n->sampleOptions = (yyvsp[(11) - (11)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 545:
-#line 208 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->targetList = (yyvsp[(3) - (10)].list);
-					n->fromClause = (yyvsp[(2) - (10)].list);
-					n->intoClause = (yyvsp[(4) - (10)].into);
-					n->whereClause = (yyvsp[(5) - (10)].node);
-					n->groupClause = (yyvsp[(6) - (10)].list);
-					n->havingClause = (yyvsp[(7) - (10)].node);
-					n->windowClause = (yyvsp[(8) - (10)].list);
-					n->qualifyClause = (yyvsp[(9) - (10)].node);
-					n->sampleOptions = (yyvsp[(10) - (10)].node);
-					n->from_first = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 546:
-#line 226 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->targetList = (yyvsp[(5) - (12)].list);
-					n->distinctClause = (yyvsp[(4) - (12)].list);
-					n->fromClause = (yyvsp[(2) - (12)].list);
-					n->intoClause = (yyvsp[(6) - (12)].into);
-					n->whereClause = (yyvsp[(7) - (12)].node);
-					n->groupClause = (yyvsp[(8) - (12)].list);
-					n->havingClause = (yyvsp[(9) - (12)].node);
-					n->windowClause = (yyvsp[(10) - (12)].list);
-					n->qualifyClause = (yyvsp[(11) - (12)].node);
-					n->sampleOptions = (yyvsp[(12) - (12)].node);
-					n->from_first = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 547:
-#line 241 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 548:
-#line 243 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* same as SELECT * FROM relation_expr */
-					PGColumnRef *cr = makeNode(PGColumnRef);
-					PGResTarget *rt = makeNode(PGResTarget);
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-
-					cr->fields = list_make1(makeNode(PGAStar));
-					cr->location = -1;
-
-					rt->name = NULL;
-					rt->indirection = NIL;
-					rt->val = (PGNode *)cr;
-					rt->location = -1;
-
-					n->targetList = list_make1(rt);
-					n->fromClause = list_make1((yyvsp[(2) - (2)].range));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 549:
-#line 262 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_UNION_BY_NAME, (yyvsp[(3) - (5)].boolean), (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node));
-				;}
-    break;
-
-  case 550:
-#line 266 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_UNION, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 551:
-#line 270 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_INTERSECT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 552:
-#line 274 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_EXCEPT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 553:
-#line 278 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (4)].node);
-					n->aggrs = (yyvsp[(4) - (4)].list);
-					n->location = (yylsp[(1) - (4)]);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 554:
-#line 288 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (7)].node);
-					n->aggrs = (yyvsp[(4) - (7)].list);
-					n->groups = (yyvsp[(7) - (7)].list);
-					n->location = (yylsp[(1) - (7)]);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 555:
-#line 299 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (5)].node);
-					n->groups = (yyvsp[(5) - (5)].list);
-					n->location = (yylsp[(1) - (5)]);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 556:
-#line 309 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (4)].node);
-					n->columns = (yyvsp[(4) - (4)].list);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 557:
-#line 318 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (7)].node);
-					n->columns = (yyvsp[(4) - (7)].list);
-					n->groups = (yyvsp[(7) - (7)].list);
-					n->location = (yylsp[(1) - (7)]);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 558:
-#line 329 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (6)].node);
-					n->columns = (yyvsp[(4) - (6)].list);
-					n->aggrs = (yyvsp[(6) - (6)].list);
-					n->location = (yylsp[(1) - (6)]);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 559:
-#line 340 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (9)].node);
-					n->columns = (yyvsp[(4) - (9)].list);
-					n->aggrs = (yyvsp[(6) - (9)].list);
-					n->groups = (yyvsp[(9) - (9)].list);
-					n->location = (yylsp[(1) - (9)]);
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 560:
-#line 352 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (9)].node);
-					n->unpivots = (yyvsp[(9) - (9)].list);
-					n->location = (yylsp[(1) - (9)]);
-					PGPivot *piv = makeNode(PGPivot);
-					piv->unpivot_columns = list_make1(makeString((yyvsp[(7) - (9)].str)));
-					piv->pivot_value = (yyvsp[(4) - (9)].list);
-					n->columns = list_make1(piv);
-
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 561:
-#line 367 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *res = makeNode(PGSelectStmt);
-					PGPivotStmt *n = makeNode(PGPivotStmt);
-					n->source = (yyvsp[(2) - (4)].node);
-					n->unpivots = list_make1(makeString("value"));
-					n->location = (yylsp[(1) - (4)]);
-					PGPivot *piv = makeNode(PGPivot);
-					piv->unpivot_columns = list_make1(makeString("name"));
-					piv->pivot_value = (yyvsp[(4) - (4)].list);
-					n->columns = list_make1(piv);
-
-					res->pivot = n;
-					(yyval.node) = (PGNode *)res;
-				;}
-    break;
-
-  case 568:
-#line 397 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGPivot *n = makeNode(PGPivot);
-				n->pivot_columns = list_make1((yyvsp[(1) - (1)].node));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 569:
-#line 403 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGPivot *n = makeNode(PGPivot);
-				n->pivot_columns = list_make1((yyvsp[(1) - (5)].node));
-				n->subquery = (yyvsp[(4) - (5)].node);
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 570:
-#line 409 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 571:
-#line 413 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 572:
-#line 414 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 573:
-#line 418 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 574:
-#line 419 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 575:
-#line 434 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.with) = makeNode(PGWithClause);
-				(yyval.with)->ctes = (yyvsp[(2) - (2)].list);
-				(yyval.with)->recursive = false;
-				(yyval.with)->location = (yylsp[(1) - (2)]);
-			;}
-    break;
-
-  case 576:
-#line 441 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.with) = makeNode(PGWithClause);
-				(yyval.with)->ctes = (yyvsp[(2) - (2)].list);
-				(yyval.with)->recursive = false;
-				(yyval.with)->location = (yylsp[(1) - (2)]);
-			;}
-    break;
-
-  case 577:
-#line 448 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.with) = makeNode(PGWithClause);
-				(yyval.with)->ctes = (yyvsp[(3) - (3)].list);
-				(yyval.with)->recursive = true;
-				(yyval.with)->location = (yylsp[(1) - (3)]);
-			;}
-    break;
-
-  case 578:
-#line 457 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 579:
-#line 458 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 580:
-#line 462 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGCommonTableExpr *n = makeNode(PGCommonTableExpr);
-				n->ctename = (yyvsp[(1) - (7)].str);
-				n->aliascolnames = (yyvsp[(2) - (7)].list);
-				n->ctematerialized = (yyvsp[(4) - (7)].ctematerialize);
-				n->ctequery = (yyvsp[(6) - (7)].node);
-				n->location = (yylsp[(1) - (7)]);
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 581:
-#line 474 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ctematerialize) = PGCTEMaterializeAlways; ;}
-    break;
-
-  case 582:
-#line 475 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ctematerialize) = PGCTEMaterializeNever; ;}
-    break;
-
-  case 583:
-#line 476 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ctematerialize) = PGCTEMaterializeDefault; ;}
-    break;
-
-  case 584:
-#line 481 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.into) = makeNode(PGIntoClause);
-					(yyval.into)->rel = (yyvsp[(2) - (2)].range);
-					(yyval.into)->colNames = NIL;
-					(yyval.into)->options = NIL;
-					(yyval.into)->onCommit = PG_ONCOMMIT_NOOP;
-					(yyval.into)->viewQuery = NULL;
-					(yyval.into)->skipData = false;
-				;}
-    break;
-
-  case 585:
-#line 491 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.into) = NULL; ;}
-    break;
-
-  case 586:
-#line 500 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(3) - (3)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 587:
-#line 505 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(3) - (3)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 588:
-#line 510 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 589:
-#line 515 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 590:
-#line 520 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (4)]))));
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 591:
-#line 528 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (4)]))));
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 592:
-#line 536 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(3) - (3)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_UNLOGGED;
-				;}
-    break;
-
-  case 593:
-#line 541 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(2) - (2)].range);
-					(yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT;
-				;}
-    break;
-
-  case 594:
-#line 546 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-					(yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT;
-				;}
-    break;
-
-  case 595:
-#line 552 "third_party/libpg_query/grammar/statements/select.y"
-    {;}
-    break;
-
-  case 596:
-#line 553 "third_party/libpg_query/grammar/statements/select.y"
-    {;}
-    break;
-
-  case 597:
-#line 557 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 598:
-#line 558 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 599:
-#line 559 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 600:
-#line 563 "third_party/libpg_query/grammar/statements/select.y"
-    { ;}
-    break;
-
-  case 601:
-#line 570 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(NIL); ;}
-    break;
-
-  case 602:
-#line 571 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(4) - (5)].list); ;}
-    break;
-
-  case 603:
-#line 575 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL;;}
-    break;
-
-  case 604:
-#line 576 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 605:
-#line 580 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ignorenulls) = PG_IGNORE_NULLS;;}
-    break;
-
-  case 606:
-#line 581 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ignorenulls) = PG_RESPECT_NULLS;;}
-    break;
-
-  case 607:
-#line 582 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ignorenulls) = PG_DEFAULT_NULLS; ;}
-    break;
-
-  case 608:
-#line 586 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list);;}
-    break;
-
-  case 609:
-#line 587 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 610:
-#line 591 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 611:
-#line 593 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSortBy *sort = makeNode(PGSortBy);
-					PGAStar *star = makeNode(PGAStar);
-					star->columns = true;
-					star->location = (yylsp[(3) - (5)]);
-					sort->node = (PGNode *) star;
-					sort->sortby_dir = (yyvsp[(4) - (5)].sortorder);
-					sort->sortby_nulls = (yyvsp[(5) - (5)].nullorder);
-					sort->useOp = NIL;
-					sort->location = -1;		/* no operator */
-					(yyval.list) = list_make1(sort);
-				;}
-    break;
-
-  case 612:
-#line 608 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].sortby)); ;}
-    break;
-
-  case 613:
-#line 609 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].sortby)); ;}
-    break;
-
-  case 614:
-#line 613 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.sortby) = makeNode(PGSortBy);
-					(yyval.sortby)->node = (yyvsp[(1) - (4)].node);
-					(yyval.sortby)->sortby_dir = SORTBY_USING;
-					(yyval.sortby)->sortby_nulls = (yyvsp[(4) - (4)].nullorder);
-					(yyval.sortby)->useOp = (yyvsp[(3) - (4)].list);
-					(yyval.sortby)->location = (yylsp[(3) - (4)]);
-				;}
-    break;
-
-  case 615:
-#line 622 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.sortby) = makeNode(PGSortBy);
-					(yyval.sortby)->node = (yyvsp[(1) - (3)].node);
-					(yyval.sortby)->sortby_dir = (yyvsp[(2) - (3)].sortorder);
-					(yyval.sortby)->sortby_nulls = (yyvsp[(3) - (3)].nullorder);
-					(yyval.sortby)->useOp = NIL;
-					(yyval.sortby)->location = -1;		/* no operator */
-				;}
-    break;
-
-  case 616:
-#line 632 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.sortorder) = PG_SORTBY_ASC; ;}
-    break;
-
-  case 617:
-#line 633 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.sortorder) = PG_SORTBY_DESC; ;}
-    break;
-
-  case 618:
-#line 634 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.sortorder) = PG_SORTBY_DEFAULT; ;}
-    break;
-
-  case 619:
-#line 637 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; ;}
-    break;
-
-  case 620:
-#line 638 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; ;}
-    break;
-
-  case 621:
-#line 639 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; ;}
-    break;
-
-  case 622:
-#line 643 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node)); ;}
-    break;
-
-  case 623:
-#line 644 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 624:
-#line 645 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2(NULL, (yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 625:
-#line 646 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (1)].node), NULL); ;}
-    break;
-
-  case 626:
-#line 650 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 627:
-#line 651 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2(NULL,NULL); ;}
-    break;
-
-  case 628:
-#line 656 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 629:
-#line 658 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* Disabled because it was too confusing, bjm 2002-02-18 */
-					ereport(ERROR,
-							(errcode(PG_ERRCODE_SYNTAX_ERROR),
-							 errmsg("LIMIT #,# syntax is not supported"),
-							 errhint("Use separate LIMIT and OFFSET clauses."),
-							 parser_errposition((yylsp[(1) - (4)]))));
-				;}
-    break;
-
-  case 630:
-#line 674 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(3) - (5)].node); ;}
-    break;
-
-  case 631:
-#line 676 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeIntConst(1, -1); ;}
-    break;
-
-  case 632:
-#line 681 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 633:
-#line 684 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (3)].node); ;}
-    break;
-
-  case 634:
-#line 689 "third_party/libpg_query/grammar/statements/select.y"
-    {
-            (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-        ;}
-    break;
-
-  case 635:
-#line 693 "third_party/libpg_query/grammar/statements/select.y"
-    {
-            (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)]));
-        ;}
-    break;
-
-  case 637:
-#line 704 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize((yyvsp[(1) - (2)].node), true);
-		;}
-    break;
-
-  case 638:
-#line 708 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize((yyvsp[(1) - (2)].node), true);
-		;}
-    break;
-
-  case 639:
-#line 712 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize((yyvsp[(1) - (1)].node), false);
-		;}
-    break;
-
-  case 640:
-#line 716 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize((yyvsp[(1) - (2)].node), false);
-		;}
-    break;
-
-  case 641:
-#line 723 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(3) - (3)].node);
-				;}
-    break;
-
-  case 642:
-#line 727 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 643:
-#line 734 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 644:
-#line 735 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 645:
-#line 740 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					int seed = (yyvsp[(5) - (5)].ival);
-					(yyval.node) = makeSampleOptions((yyvsp[(3) - (5)].node), (yyvsp[(1) - (5)].str), &seed, (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 646:
-#line 745 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleOptions((yyvsp[(1) - (1)].node), NULL, NULL, (yylsp[(1) - (1)]));
-		;}
-    break;
-
-  case 647:
-#line 749 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleOptions((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str), NULL, (yylsp[(1) - (4)]));
-		;}
-    break;
-
-  case 648:
-#line 753 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			int seed = (yyvsp[(5) - (6)].ival);
-			(yyval.node) = makeSampleOptions((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].str), &seed, (yylsp[(1) - (6)]));
-		;}
-    break;
-
-  case 649:
-#line 761 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(2) - (2)].node);
-				;}
-    break;
-
-  case 650:
-#line 767 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 651:
-#line 768 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 652:
-#line 773 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = (yyvsp[(3) - (4)].ival); ;}
-    break;
-
-  case 653:
-#line 774 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = -1; ;}
-    break;
-
-  case 654:
-#line 778 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 655:
-#line 780 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* LIMIT ALL is represented as a NULL constant */
-					(yyval.node) = makeNullAConst((yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 656:
-#line 785 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeLimitPercent((yyvsp[(1) - (2)].node)); ;}
-    break;
-
-  case 657:
-#line 787 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[(1) - (2)].str),(yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 658:
-#line 789 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[(1) - (2)].ival),(yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 659:
-#line 793 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 660:
-#line 813 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 661:
-#line 815 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 662:
-#line 817 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 663:
-#line 821 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival),(yylsp[(1) - (1)])); ;}
-    break;
-
-  case 664:
-#line 822 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str),(yylsp[(1) - (1)])); ;}
-    break;
-
-  case 665:
-#line 826 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 666:
-#line 827 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 667:
-#line 830 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 668:
-#line 831 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 669:
-#line 856 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 670:
-#line 858 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[(3) - (3)]));
-					(yyval.list) = list_make1(node);
-				;}
-    break;
-
-  case 671:
-#line 862 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 672:
-#line 866 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 673:
-#line 867 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 674:
-#line 871 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 675:
-#line 872 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 676:
-#line 876 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 677:
-#line 877 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 678:
-#line 878 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 679:
-#line 879 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 680:
-#line 880 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 681:
-#line 885 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 682:
-#line 898 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 683:
-#line 905 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 684:
-#line 912 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 685:
-#line 918 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 686:
-#line 919 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 687:
-#line 923 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 688:
-#line 924 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 689:
-#line 928 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 690:
-#line 929 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 691:
-#line 933 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 692:
-#line 934 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 693:
-#line 938 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 694:
-#line 939 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 695:
-#line 943 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 696:
-#line 944 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 697:
-#line 949 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGLockingClause *n = makeNode(PGLockingClause);
-					n->lockedRels = (yyvsp[(2) - (3)].list);
-					n->strength = (yyvsp[(1) - (3)].lockstrength);
-					n->waitPolicy = (yyvsp[(3) - (3)].lockwaitpolicy);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 698:
-#line 959 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = LCS_FORUPDATE; ;}
-    break;
-
-  case 699:
-#line 960 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; ;}
-    break;
-
-  case 700:
-#line 961 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = PG_LCS_FORSHARE; ;}
-    break;
-
-  case 701:
-#line 962 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; ;}
-    break;
-
-  case 702:
-#line 966 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 703:
-#line 967 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 704:
-#line 972 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockwaitpolicy) = LockWaitError; ;}
-    break;
-
-  case 705:
-#line 973 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockwaitpolicy) = PGLockWaitSkip; ;}
-    break;
-
-  case 706:
-#line 974 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockwaitpolicy) = PGLockWaitBlock; ;}
-    break;
-
-  case 707:
-#line 984 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->valuesLists = list_make1((yyvsp[(3) - (4)].list));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 708:
-#line 990 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = (PGSelectStmt *) (yyvsp[(1) - (5)].node);
-					n->valuesLists = lappend(n->valuesLists, (yyvsp[(4) - (5)].list));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 709:
-#line 998 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 710:
-#line 999 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (2)].node); ;}
-    break;
-
-  case 711:
-#line 1012 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 712:
-#line 1013 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 713:
-#line 1017 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 714:
-#line 1018 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 715:
-#line 1022 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 716:
-#line 1023 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 717:
-#line 1028 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                (yyval.alias) = makeNode(PGAlias);
-                (yyval.alias)->aliasname = (yyvsp[(1) - (2)].str);
-            ;}
-    break;
-
-  case 718:
-#line 1039 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyvsp[(1) - (3)].range)->alias = (yyvsp[(2) - (3)].alias);
-					(yyvsp[(1) - (3)].range)->sample = (yyvsp[(3) - (3)].node);
-					(yyval.node) = (PGNode *) (yyvsp[(1) - (3)].range);
-				;}
-    break;
-
-  case 719:
-#line 1045 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                    (yyvsp[(2) - (3)].range)->alias = (yyvsp[(1) - (3)].alias);
-                    (yyvsp[(2) - (3)].range)->sample = (yyvsp[(3) - (3)].node);
-                    (yyval.node) = (PGNode *) (yyvsp[(2) - (3)].range);
-                ;}
-    break;
-
-  case 720:
-#line 1051 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(1) - (3)].node);
-					n->alias = (PGAlias*) linitial((yyvsp[(2) - (3)].list));
-					n->coldeflist = (PGList*) lsecond((yyvsp[(2) - (3)].list));
-					n->sample = (yyvsp[(3) - (3)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 721:
-#line 1059 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                        PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(2) - (3)].node);
-                        n->alias = (yyvsp[(1) - (3)].alias);
-                        n->sample = (yyvsp[(3) - (3)].node);
-                        (yyval.node) = (PGNode *) n;
-                    ;}
-    break;
-
-  case 722:
-#line 1067 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                    PGRangeSubselect *n = makeNode(PGRangeSubselect);
-                    n->lateral = false;
-                    n->subquery = (yyvsp[(1) - (3)].node);
-                    n->alias = (yyvsp[(2) - (3)].alias);
-                    n->sample = (yyvsp[(3) - (3)].node);
-                    (yyval.node) = (PGNode *) n;
-                ;}
-    break;
-
-  case 723:
-#line 1077 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(2) - (3)].node);
-					n->lateral = true;
-					n->alias = (PGAlias*) linitial((yyvsp[(3) - (3)].list));
-					n->coldeflist = (PGList*) lsecond((yyvsp[(3) - (3)].list));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 724:
-#line 1085 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeSubselect *n = makeNode(PGRangeSubselect);
-					n->lateral = false;
-					n->subquery = (yyvsp[(1) - (3)].node);
-					n->alias = (yyvsp[(2) - (3)].alias);
-					n->sample = (yyvsp[(3) - (3)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 725:
-#line 1094 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                    PGRangeSubselect *n = makeNode(PGRangeSubselect);
-                    n->lateral = false;
-                    n->subquery = (yyvsp[(2) - (3)].node);
-                    n->alias = (yyvsp[(1) - (3)].alias);
-                    n->sample = (yyvsp[(3) - (3)].node);
-                    (yyval.node) = (PGNode *) n;
-                ;}
-    break;
-
-  case 726:
-#line 1103 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeSubselect *n = makeNode(PGRangeSubselect);
-					n->lateral = true;
-					n->subquery = (yyvsp[(2) - (3)].node);
-					n->alias = (yyvsp[(3) - (3)].alias);
-					n->sample = NULL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 727:
-#line 1112 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) (yyvsp[(1) - (1)].jexpr);
-				;}
-    break;
-
-  case 728:
-#line 1116 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyvsp[(2) - (4)].jexpr)->alias = (yyvsp[(4) - (4)].alias);
-					(yyval.node) = (PGNode *) (yyvsp[(2) - (4)].jexpr);
-				;}
-    break;
-
-  case 729:
-#line 1121 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                    (yyvsp[(3) - (4)].jexpr)->alias = (yyvsp[(1) - (4)].alias);
-                    (yyval.node) = (PGNode *) (yyvsp[(3) - (4)].jexpr);
-                ;}
-    break;
-
-  case 730:
-#line 1126 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGPivotExpr *n = makeNode(PGPivotExpr);
-					n->source = (yyvsp[(1) - (9)].node);
-					n->aggrs = (yyvsp[(4) - (9)].list);
-					n->pivots = (yyvsp[(6) - (9)].list);
-					n->groups = (yyvsp[(7) - (9)].list);
-					n->alias = (yyvsp[(9) - (9)].alias);
-					n->location = (yylsp[(2) - (9)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 731:
-#line 1137 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGPivotExpr *n = makeNode(PGPivotExpr);
-					n->source = (yyvsp[(1) - (9)].node);
-					n->include_nulls = (yyvsp[(3) - (9)].boolean);
-					n->unpivots = (yyvsp[(5) - (9)].list);
-					n->pivots = (yyvsp[(7) - (9)].list);
-					n->alias = (yyvsp[(9) - (9)].alias);
-					n->location = (yylsp[(2) - (9)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 732:
-#line 1150 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 733:
-#line 1151 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 734:
-#line 1154 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 735:
-#line 1155 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 736:
-#line 1156 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 737:
-#line 1160 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			PGPivot *n = makeNode(PGPivot);
-			n->pivot_columns = list_make1((yyvsp[(1) - (5)].node));
-			n->pivot_value = (yyvsp[(4) - (5)].list);
-			(yyval.node) = (PGNode *) n;
-		;}
-    break;
-
-  case 738:
-#line 1168 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			PGPivot *n = makeNode(PGPivot);
-			n->pivot_columns = list_make1((yyvsp[(1) - (3)].node));
-			n->pivot_enum = (yyvsp[(3) - (3)].str);
-			(yyval.node) = (PGNode *) n;
-		;}
-    break;
-
-  case 739:
-#line 1177 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 740:
-#line 1178 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 741:
-#line 1179 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 742:
-#line 1183 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			PGPivot *n = makeNode(PGPivot);
-			n->pivot_columns = (yyvsp[(1) - (5)].list);
-			n->pivot_value = (yyvsp[(4) - (5)].list);
-			(yyval.node) = (PGNode *) n;
-		;}
-    break;
-
-  case 743:
-#line 1191 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			PGPivot *n = makeNode(PGPivot);
-			n->pivot_columns = (yyvsp[(1) - (3)].list);
-			n->pivot_enum = (yyvsp[(3) - (3)].str);
-			(yyval.node) = (PGNode *) n;
-		;}
-    break;
-
-  case 744:
-#line 1200 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 745:
-#line 1204 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node));
-				;}
-    break;
-
-  case 746:
-#line 1210 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 747:
-#line 1211 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 748:
-#line 1216 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			PGPivot *n = makeNode(PGPivot);
-			n->unpivot_columns = (yyvsp[(1) - (5)].list);
-			n->pivot_value = (yyvsp[(4) - (5)].list);
-			(yyval.node) = (PGNode *) n;
-		;}
-    break;
-
-  case 749:
-#line 1225 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 750:
-#line 1229 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node));
-				;}
-    break;
-
-  case 751:
-#line 1254 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.jexpr) = (yyvsp[(2) - (3)].jexpr);
-				;}
-    break;
-
-  case 752:
-#line 1258 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* CROSS JOIN is same as unqualified inner join */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->joinreftype = PG_JOIN_REGULAR;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(4) - (4)].node);
-					n->usingClause = NIL;
-					n->quals = NULL;
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 753:
-#line 1271 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = (yyvsp[(2) - (5)].jtype);
-					n->joinreftype = PG_JOIN_REGULAR;
-					n->larg = (yyvsp[(1) - (5)].node);
-					n->rarg = (yyvsp[(4) - (5)].node);
-					if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList))
-						n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */
-					else
-						n->quals = (yyvsp[(5) - (5)].node); /* ON clause */
-					n->location = (yylsp[(2) - (5)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 754:
-#line 1285 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* letting join_type reduce to empty doesn't work */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->joinreftype = PG_JOIN_REGULAR;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(3) - (4)].node);
-					if ((yyvsp[(4) - (4)].node) != NULL && IsA((yyvsp[(4) - (4)].node), PGList))
-						n->usingClause = (PGList *) (yyvsp[(4) - (4)].node); /* USING clause */
-					else
-						n->quals = (yyvsp[(4) - (4)].node); /* ON clause */
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 755:
-#line 1300 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = (yyvsp[(3) - (5)].jtype);
-					n->joinreftype = PG_JOIN_NATURAL;
-					n->larg = (yyvsp[(1) - (5)].node);
-					n->rarg = (yyvsp[(5) - (5)].node);
-					n->usingClause = NIL; /* figure out which columns later... */
-					n->quals = NULL; /* fill later */
-					n->location = (yylsp[(2) - (5)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 756:
-#line 1312 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* letting join_type reduce to empty doesn't work */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->joinreftype = PG_JOIN_NATURAL;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(4) - (4)].node);
-					n->usingClause = NIL; /* figure out which columns later... */
-					n->quals = NULL; /* fill later */
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 757:
-#line 1325 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = (yyvsp[(3) - (6)].jtype);
-					n->joinreftype = PG_JOIN_ASOF;
-					n->larg = (yyvsp[(1) - (6)].node);
-					n->rarg = (yyvsp[(5) - (6)].node);
-					if ((yyvsp[(6) - (6)].node) != NULL && IsA((yyvsp[(6) - (6)].node), PGList))
-						n->usingClause = (PGList *) (yyvsp[(6) - (6)].node); /* USING clause */
-					else
-						n->quals = (yyvsp[(6) - (6)].node); /* ON clause */
-					n->location = (yylsp[(2) - (6)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 758:
-#line 1339 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->joinreftype = PG_JOIN_ASOF;
-					n->larg = (yyvsp[(1) - (5)].node);
-					n->rarg = (yyvsp[(4) - (5)].node);
-					if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList))
-						n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */
-					else
-						n->quals = (yyvsp[(5) - (5)].node); /* ON clause */
-					n->location = (yylsp[(2) - (5)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 759:
-#line 1353 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* POSITIONAL JOIN is a coordinated scan */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_POSITION;
-					n->joinreftype = PG_JOIN_REGULAR;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(4) - (4)].node);
-					n->usingClause = NIL;
-					n->quals = NULL;
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 760:
-#line 1366 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                    /* ANTI JOIN is a filter */
-                    PGJoinExpr *n = makeNode(PGJoinExpr);
-                    n->jointype = PG_JOIN_ANTI;
-                    n->joinreftype = PG_JOIN_REGULAR;
-                    n->larg = (yyvsp[(1) - (5)].node);
-                    n->rarg = (yyvsp[(4) - (5)].node);
-                    if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList))
-                        n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */
-                    else
-                        n->quals = (yyvsp[(5) - (5)].node); /* ON clause */
-                    n->location = (yylsp[(2) - (5)]);
-                    (yyval.jexpr) = n;
-                ;}
-    break;
-
-  case 761:
-#line 1381 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                   /* SEMI JOIN is also a filter */
-                   PGJoinExpr *n = makeNode(PGJoinExpr);
-                   n->jointype = PG_JOIN_SEMI;
-                   n->joinreftype = PG_JOIN_REGULAR;
-                   n->larg = (yyvsp[(1) - (5)].node);
-                   n->rarg = (yyvsp[(4) - (5)].node);
-                   if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList))
-                       n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */
-                   else
-                       n->quals = (yyvsp[(5) - (5)].node); /* ON clause */
-                   n->location = (yylsp[(2) - (5)]);
-                   n->location = (yylsp[(2) - (5)]);
-                   (yyval.jexpr) = n;
-               ;}
-    break;
-
-  case 762:
-#line 1400 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(2) - (5)].str);
-					(yyval.alias)->colnames = (yyvsp[(4) - (5)].list);
-				;}
-    break;
-
-  case 763:
-#line 1406 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(2) - (2)].str);
-				;}
-    break;
-
-  case 764:
-#line 1411 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(1) - (4)].str);
-					(yyval.alias)->colnames = (yyvsp[(3) - (4)].list);
-				;}
-    break;
-
-  case 765:
-#line 1417 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(1) - (1)].str);
-				;}
-    break;
-
-  case 766:
-#line 1423 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.alias) = (yyvsp[(1) - (1)].alias); ;}
-    break;
-
-  case 767:
-#line 1424 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.alias) = NULL; ;}
-    break;
-
-  case 768:
-#line 1433 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2((yyvsp[(1) - (1)].alias), NIL);
-				;}
-    break;
-
-  case 769:
-#line 1437 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2(NULL, (yyvsp[(3) - (4)].list));
-				;}
-    break;
-
-  case 770:
-#line 1441 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAlias *a = makeNode(PGAlias);
-					a->aliasname = (yyvsp[(2) - (5)].str);
-					(yyval.list) = list_make2(a, (yyvsp[(4) - (5)].list));
-				;}
-    break;
-
-  case 771:
-#line 1447 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAlias *a = makeNode(PGAlias);
-					a->aliasname = (yyvsp[(1) - (4)].str);
-					(yyval.list) = list_make2(a, (yyvsp[(3) - (4)].list));
-				;}
-    break;
-
-  case 772:
-#line 1453 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2(NULL, NIL);
-				;}
-    break;
-
-  case 773:
-#line 1458 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_FULL; ;}
-    break;
-
-  case 774:
-#line 1459 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_LEFT; ;}
-    break;
-
-  case 775:
-#line 1460 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_RIGHT; ;}
-    break;
-
-  case 776:
-#line 1461 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_SEMI; ;}
-    break;
-
-  case 777:
-#line 1462 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_ANTI; ;}
-    break;
-
-  case 778:
-#line 1463 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_INNER; ;}
-    break;
-
-  case 779:
-#line 1467 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 780:
-#line 1468 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 781:
-#line 1480 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 782:
-#line 1481 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 783:
-#line 1487 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* inheritance query, implicitly */
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-					(yyval.range)->inh = true;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 784:
-#line 1494 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* inheritance query, explicitly */
-					(yyval.range) = (yyvsp[(1) - (2)].range);
-					(yyval.range)->inh = true;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 785:
-#line 1501 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* no inheritance */
-					(yyval.range) = (yyvsp[(2) - (2)].range);
-					(yyval.range)->inh = false;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 786:
-#line 1508 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* no inheritance, SQL99-style syntax */
-					(yyval.range) = (yyvsp[(3) - (4)].range);
-					(yyval.range)->inh = false;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 787:
-#line 1540 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = makeNode(PGRangeFunction);
-					n->lateral = false;
-					n->ordinality = (yyvsp[(2) - (2)].boolean);
-					n->is_rowsfrom = false;
-					n->functions = list_make1(list_make2((yyvsp[(1) - (2)].node), NIL));
-					n->sample = NULL;
-					/* alias and coldeflist are set by table_ref production */
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 788:
-#line 1551 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = makeNode(PGRangeFunction);
-					n->lateral = false;
-					n->ordinality = (yyvsp[(6) - (6)].boolean);
-					n->is_rowsfrom = true;
-					n->functions = (yyvsp[(4) - (6)].list);
-					n->sample = NULL;
-					/* alias and coldeflist are set by table_ref production */
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 789:
-#line 1564 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 790:
-#line 1568 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 791:
-#line 1569 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 792:
-#line 1572 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 793:
-#line 1573 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 794:
-#line 1576 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 795:
-#line 1577 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 796:
-#line 1582 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 797:
-#line 1583 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 798:
-#line 1589 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 799:
-#line 1593 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 800:
-#line 1599 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGColumnDef *n = makeNode(PGColumnDef);
-					n->colname = (yyvsp[(1) - (3)].str);
-					n->typeName = (yyvsp[(2) - (3)].typnam);
-					n->inhcount = 0;
-					n->is_local = true;
-					n->is_not_null = false;
-					n->is_from_type = false;
-					n->storage = 0;
-					n->raw_default = NULL;
-					n->cooked_default = NULL;
-					n->collClause = (PGCollateClause *) (yyvsp[(3) - (3)].node);
-					n->collOid = InvalidOid;
-					n->constraints = NIL;
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 801:
-#line 1620 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCollateClause *n = makeNode(PGCollateClause);
-					n->arg = NULL;
-					n->collname = (yyvsp[(2) - (2)].list);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 802:
-#line 1627 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 803:
-#line 1641 "third_party/libpg_query/grammar/statements/select.y"
-    {
-             (yyval.list) = list_make1(list_make2(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].typnam)));
-            ;}
-    break;
-
-  case 804:
-#line 1644 "third_party/libpg_query/grammar/statements/select.y"
-    {
-             (yyval.list) = lappend((yyvsp[(1) - (4)].list), list_make2(makeString((yyvsp[(3) - (4)].str)), (yyvsp[(4) - (4)].typnam)));
-            ;}
-    break;
-
-  case 807:
-#line 1651 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 808:
-#line 1652 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = NULL; ;}
-    break;
-
-  case 809:
-#line 1655 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (2)].typnam);
-					(yyval.typnam)->arrayBounds = (yyvsp[(2) - (2)].list);
-				;}
-    break;
-
-  case 810:
-#line 1660 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (3)].typnam);
-					(yyval.typnam)->arrayBounds = (yyvsp[(3) - (3)].list);
-					(yyval.typnam)->setof = true;
-				;}
-    break;
-
-  case 811:
-#line 1667 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (5)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(4) - (5)].ival)));
-				;}
-    break;
-
-  case 812:
-#line 1672 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (6)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(5) - (6)].ival)));
-					(yyval.typnam)->setof = true;
-				;}
-    break;
-
-  case 813:
-#line 1678 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (2)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger(-1));
-				;}
-    break;
-
-  case 814:
-#line 1683 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (3)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger(-1));
-					(yyval.typnam)->setof = true;
-				;}
-    break;
-
-  case 815:
-#line 1689 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = makeTypeNameFromNameList((yyvsp[(1) - (1)].list));
-				;}
-    break;
-
-  case 816:
-#line 1693 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				   (yyval.typnam) = SystemTypeName("struct");
-				   (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list);
-				   (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list);
-				   (yyval.typnam)->location = (yylsp[(1) - (5)]);
-               ;}
-    break;
-
-  case 817:
-#line 1700 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				   (yyval.typnam) = SystemTypeName("map");
-				   (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list);
-				   (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list);
-				   (yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 818:
-#line 1707 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				   (yyval.typnam) = SystemTypeName("union");
-				   (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list);
-				   (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list);
-				   (yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 819:
-#line 1716 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2(makeString((yyvsp[(1) - (3)].str)), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 820:
-#line 1717 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 821:
-#line 1722 "third_party/libpg_query/grammar/statements/select.y"
-    {  (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeInteger(-1)); ;}
-    break;
-
-  case 822:
-#line 1724 "third_party/libpg_query/grammar/statements/select.y"
-    {  (yyval.list) = lappend((yyvsp[(1) - (4)].list), makeInteger((yyvsp[(3) - (4)].ival))); ;}
-    break;
-
-  case 823:
-#line 1726 "third_party/libpg_query/grammar/statements/select.y"
-    {  (yyval.list) = NIL; ;}
-    break;
-
-  case 824:
-#line 1730 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 825:
-#line 1731 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 826:
-#line 1732 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 827:
-#line 1733 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 828:
-#line 1734 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 829:
-#line 1736 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (2)].typnam);
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-				;}
-    break;
-
-  case 830:
-#line 1741 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (4)].typnam);
-					(yyval.typnam)->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
-											 makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)])));
-				;}
-    break;
-
-  case 831:
-#line 1760 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 832:
-#line 1761 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 833:
-#line 1762 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 834:
-#line 1763 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 835:
-#line 1775 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = makeTypeName((yyvsp[(1) - (2)].str));
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 836:
-#line 1788 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 837:
-#line 1789 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 838:
-#line 1796 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int4");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 839:
-#line 1801 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int4");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 840:
-#line 1806 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int2");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 841:
-#line 1811 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int8");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 842:
-#line 1816 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("float4");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 843:
-#line 1821 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (2)].typnam);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 844:
-#line 1826 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("float8");
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 845:
-#line 1831 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("numeric");
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 846:
-#line 1837 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("numeric");
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 847:
-#line 1843 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("numeric");
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 848:
-#line 1849 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("bool");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 849:
-#line 1856 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * Check FLOAT() precision limits assuming IEEE floating
-					 * types - thomas 1997-09-18
-					 */
-					if ((yyvsp[(2) - (3)].ival) < 1)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_INVALID_PARAMETER_VALUE),
-								 errmsg("precision for type float must be at least 1 bit"),
-								 parser_errposition((yylsp[(2) - (3)]))));
-					else if ((yyvsp[(2) - (3)].ival) <= 24)
-						(yyval.typnam) = SystemTypeName("float4");
-					else if ((yyvsp[(2) - (3)].ival) <= 53)
-						(yyval.typnam) = SystemTypeName("float8");
-					else
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_INVALID_PARAMETER_VALUE),
-								 errmsg("precision for type float must be less than 54 bits"),
-								 parser_errposition((yylsp[(2) - (3)]))));
-				;}
-    break;
-
-  case 850:
-#line 1877 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("float4");
-				;}
-    break;
-
-  case 851:
-#line 1887 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 852:
-#line 1891 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 853:
-#line 1899 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 854:
-#line 1903 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-					(yyval.typnam)->typmods = NIL;
-				;}
-    break;
-
-  case 855:
-#line 1911 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					const char *typname;
-
-					typname = (yyvsp[(2) - (5)].boolean) ? "varbit" : "bit";
-					(yyval.typnam) = SystemTypeName(typname);
-					(yyval.typnam)->typmods = (yyvsp[(4) - (5)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 856:
-#line 1923 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* bit defaults to bit(1), varbit to no limit */
-					if ((yyvsp[(2) - (2)].boolean))
-					{
-						(yyval.typnam) = SystemTypeName("varbit");
-					}
-					else
-					{
-						(yyval.typnam) = SystemTypeName("bit");
-						(yyval.typnam)->typmods = list_make1(makeIntConst(1, -1));
-					}
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 857:
-#line 1944 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 858:
-#line 1948 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 859:
-#line 1954 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 860:
-#line 1958 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* Length was not specified so allow to be unrestricted.
-					 * This handles problems with fixed-length (bpchar) strings
-					 * which in column definitions must default to a length
-					 * of one, but should not be constrained if the length
-					 * was not specified.
-					 */
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-					(yyval.typnam)->typmods = NIL;
-				;}
-    break;
-
-  case 861:
-#line 1971 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName((yyvsp[(1) - (4)].conststr));
-					(yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)])));
-					(yyval.typnam)->location = (yylsp[(1) - (4)]);
-				;}
-    break;
-
-  case 862:
-#line 1979 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName((yyvsp[(1) - (1)].conststr));
-					/* char defaults to char(1), varchar to no limit */
-					if (strcmp((yyvsp[(1) - (1)].conststr), "bpchar") == 0)
-						(yyval.typnam)->typmods = list_make1(makeIntConst(1, -1));
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 863:
-#line 1989 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 864:
-#line 1991 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 865:
-#line 1993 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "varchar"; ;}
-    break;
-
-  case 866:
-#line 1995 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 867:
-#line 1997 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 868:
-#line 1999 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 869:
-#line 2003 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 870:
-#line 2004 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 871:
-#line 2012 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(5) - (5)].boolean))
-						(yyval.typnam) = SystemTypeName("timestamptz");
-					else
-						(yyval.typnam) = SystemTypeName("timestamp");
-					(yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)])));
-					(yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 872:
-#line 2021 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].boolean))
-						(yyval.typnam) = SystemTypeName("timestamptz");
-					else
-						(yyval.typnam) = SystemTypeName("timestamp");
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 873:
-#line 2029 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(5) - (5)].boolean))
-						(yyval.typnam) = SystemTypeName("timetz");
-					else
-						(yyval.typnam) = SystemTypeName("time");
-					(yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)])));
-					(yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 874:
-#line 2038 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].boolean))
-						(yyval.typnam) = SystemTypeName("timetz");
-					else
-						(yyval.typnam) = SystemTypeName("time");
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 875:
-#line 2049 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("interval");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 876:
-#line 2056 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 877:
-#line 2057 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 878:
-#line 2058 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 905:
-#line 2102 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 906:
-#line 2104 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 907:
-#line 2106 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 908:
-#line 2108 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 909:
-#line 2110 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 910:
-#line 2112 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 911:
-#line 2114 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 912:
-#line 2116 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 913:
-#line 2118 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(WEEK), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 914:
-#line 2120 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(QUARTER), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 915:
-#line 2122 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DECADE), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 916:
-#line 2124 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(CENTURY), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 917:
-#line 2126 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLENNIUM), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 918:
-#line 2128 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR) |
-												 INTERVAL_MASK(MONTH), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 919:
-#line 2133 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
-												 INTERVAL_MASK(HOUR), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 920:
-#line 2138 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
-												 INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 921:
-#line 2144 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
-												 INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE) |
-												 INTERVAL_MASK(SECOND), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 922:
-#line 2151 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 923:
-#line 2156 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE) |
-												 INTERVAL_MASK(SECOND), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 924:
-#line 2162 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE) |
-												 INTERVAL_MASK(SECOND), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 925:
-#line 2167 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 926:
-#line 2198 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 927:
-#line 2201 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 928:
-#line 2203 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCollateClause *n = makeNode(PGCollateClause);
-					n->arg = (yyvsp[(1) - (3)].node);
-					n->collname = (yyvsp[(3) - (3)].list);
-					n->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 929:
-#line 2211 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("timezone"),
-											   list_make2((yyvsp[(5) - (5)].node), (yyvsp[(1) - (5)].node)),
-											   (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 930:
-#line 2226 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 931:
-#line 2228 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 932:
-#line 2230 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 933:
-#line 2232 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 934:
-#line 2234 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 935:
-#line 2236 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 936:
-#line 2238 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 937:
-#line 2240 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 938:
-#line 2242 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 939:
-#line 2244 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 940:
-#line 2246 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 941:
-#line 2248 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 942:
-#line 2250 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 943:
-#line 2252 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 944:
-#line 2254 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 945:
-#line 2256 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 946:
-#line 2259 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 947:
-#line 2261 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 948:
-#line 2263 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;}
-    break;
-
-  case 949:
-#line 2266 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeAndExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 950:
-#line 2268 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeOrExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 951:
-#line 2270 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 952:
-#line 2272 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 953:
-#line 2274 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_GLOB, "~~~",
-												   (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 954:
-#line 2279 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "~~",
-												   (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 955:
-#line 2284 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
-											   list_make3((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)),
-											   (yylsp[(2) - (5)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 956:
-#line 2291 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "!~~",
-												   (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)]));
-				;}
-    break;
-
-  case 957:
-#line 2296 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("not_like_escape"),
-											   list_make3((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-											   (yylsp[(2) - (6)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 958:
-#line 2303 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "~~*",
-												   (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 959:
-#line 2308 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("ilike_escape"),
-											   list_make3((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)),
-											   (yylsp[(2) - (5)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 960:
-#line 2315 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "!~~*",
-												   (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)]));
-				;}
-    break;
-
-  case 961:
-#line 2320 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("not_ilike_escape"),
-											   list_make3((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-											   (yylsp[(2) - (6)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 962:
-#line 2328 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(4) - (4)].node), makeNullAConst(-1)),
-											   (yylsp[(2) - (4)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "~",
-												   (yyvsp[(1) - (4)].node), (PGNode *) n, (yylsp[(2) - (4)]));
-				;}
-    break;
-
-  case 963:
-#line 2336 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-											   (yylsp[(2) - (6)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "~",
-												   (yyvsp[(1) - (6)].node), (PGNode *) n, (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 964:
-#line 2344 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(5) - (5)].node), makeNullAConst(-1)),
-											   (yylsp[(2) - (5)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "!~",
-												   (yyvsp[(1) - (5)].node), (PGNode *) n, (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 965:
-#line 2352 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)),
-											   (yylsp[(2) - (7)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "!~",
-												   (yyvsp[(1) - (7)].node), (PGNode *) n, (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 966:
-#line 2370 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					n->nulltesttype = PG_IS_NULL;
-					n->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 967:
-#line 2378 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (2)].node);
-					n->nulltesttype = PG_IS_NULL;
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 968:
-#line 2386 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					n->nulltesttype = IS_NOT_NULL;
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 969:
-#line 2394 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					n->nulltesttype = IS_NOT_NULL;
-					n->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 970:
-#line 2402 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (2)].node);
-					n->nulltesttype = IS_NOT_NULL;
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 971:
-#line 2410 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGLambdaFunction *n = makeNode(PGLambdaFunction);
-				n->lhs = (yyvsp[(1) - (3)].node);
-				n->rhs = (yyvsp[(3) - (3)].node);
-				n->location = (yylsp[(2) - (3)]);
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 972:
-#line 2418 "third_party/libpg_query/grammar/statements/select.y"
-    {
-							(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "->>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-			;}
-    break;
-
-  case 973:
-#line 2422 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if (list_length((yyvsp[(1) - (3)].list)) != 2)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("wrong number of parameters on left side of OVERLAPS expression"),
-								 parser_errposition((yylsp[(1) - (3)]))));
-					if (list_length((yyvsp[(3) - (3)].list)) != 2)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("wrong number of parameters on right side of OVERLAPS expression"),
-								 parser_errposition((yylsp[(3) - (3)]))));
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlaps"),
-											   list_concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)),
-											   (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 974:
-#line 2438 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					b->booltesttype = PG_IS_TRUE;
-					b->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 975:
-#line 2446 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					b->booltesttype = IS_NOT_TRUE;
-					b->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 976:
-#line 2454 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					b->booltesttype = IS_FALSE;
-					b->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 977:
-#line 2462 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					b->booltesttype = IS_NOT_FALSE;
-					b->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 978:
-#line 2470 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					b->booltesttype = IS_UNKNOWN;
-					b->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 979:
-#line 2478 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					b->booltesttype = IS_NOT_UNKNOWN;
-					b->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 980:
-#line 2486 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 981:
-#line 2490 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 982:
-#line 2494 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 983:
-#line 2498 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 984:
-#line 2502 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN,
-												   "BETWEEN",
-												   (yyvsp[(1) - (6)].node),
-												   (PGNode *) list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-												   (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 985:
-#line 2510 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN,
-												   "NOT BETWEEN",
-												   (yyvsp[(1) - (7)].node),
-												   (PGNode *) list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)),
-												   (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 986:
-#line 2518 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN_SYM,
-												   "BETWEEN SYMMETRIC",
-												   (yyvsp[(1) - (6)].node),
-												   (PGNode *) list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-												   (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 987:
-#line 2526 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN_SYM,
-												   "NOT BETWEEN SYMMETRIC",
-												   (yyvsp[(1) - (7)].node),
-												   (PGNode *) list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)),
-												   (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 988:
-#line 2534 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* in_expr returns a PGSubLink or a list of a_exprs */
-					if (IsA((yyvsp[(3) - (3)].node), PGSubLink))
-					{
-						/* generate foo = ANY (subquery) */
-						PGSubLink *n = (PGSubLink *) (yyvsp[(3) - (3)].node);
-						n->subLinkType = PG_ANY_SUBLINK;
-						n->subLinkId = 0;
-						n->testexpr = (yyvsp[(1) - (3)].node);
-						n->operName = NIL;		/* show it's IN not = ANY */
-						n->location = (yylsp[(2) - (3)]);
-						(yyval.node) = (PGNode *)n;
-					}
-					else
-					{
-						/* generate scalar IN expression */
-						(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-					}
-				;}
-    break;
-
-  case 989:
-#line 2554 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* in_expr returns a PGSubLink or a list of a_exprs */
-					if (IsA((yyvsp[(4) - (4)].node), PGSubLink))
-					{
-						/* generate NOT (foo = ANY (subquery)) */
-						/* Make an = ANY node */
-						PGSubLink *n = (PGSubLink *) (yyvsp[(4) - (4)].node);
-						n->subLinkType = PG_ANY_SUBLINK;
-						n->subLinkId = 0;
-						n->testexpr = (yyvsp[(1) - (4)].node);
-						n->operName = NIL;		/* show it's IN not = ANY */
-						n->location = (yylsp[(2) - (4)]);
-						/* Stick a NOT on top; must have same parse location */
-						(yyval.node) = makeNotExpr((PGNode *) n, (yylsp[(2) - (4)]));
-					}
-					else
-					{
-						/* generate scalar NOT IN expression */
-						(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "<>", (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)]));
-					}
-				;}
-    break;
-
-  case 990:
-#line 2576 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = (yyvsp[(3) - (4)].subquerytype);
-					n->subLinkId = 0;
-					n->testexpr = (yyvsp[(1) - (4)].node);
-					n->operName = (yyvsp[(2) - (4)].list);
-					n->subselect = (yyvsp[(4) - (4)].node);
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 991:
-#line 2587 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(3) - (6)].subquerytype) == PG_ANY_SUBLINK)
-						(yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ANY, (yyvsp[(2) - (6)].list), (yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(2) - (6)]));
-					else
-						(yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ALL, (yyvsp[(2) - (6)].list), (yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 992:
-#line 2594 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * The SQL spec only allows DEFAULT in "contextually typed
-					 * expressions", but for us, it's easier to allow it in
-					 * any a_expr and then throw error during parse analysis
-					 * if it's in an inappropriate context.  This way also
-					 * lets us say something smarter than "syntax error".
-					 */
-					PGSetToDefault *n = makeNode(PGSetToDefault);
-					/* parse analysis will fill in the rest */
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 993:
-#line 2608 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAStar *star = makeNode(PGAStar);
-					star->expr = (yyvsp[(4) - (5)].node);
-					star->columns = true;
-					star->unpacked = true;
-					star->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *) star;
-				;}
-    break;
-
-  case 994:
-#line 2617 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAStar *star = makeNode(PGAStar);
-					star->expr = (yyvsp[(3) - (4)].node);
-					star->columns = true;
-					star->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *) star;
-				;}
-    break;
-
-  case 995:
-#line 2625 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAStar *star = makeNode(PGAStar);
-					star->except_list = (yyvsp[(2) - (4)].list);
-					star->replace_list = (yyvsp[(3) - (4)].list);
-					star->rename_list = (yyvsp[(4) - (4)].list);
-					star->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *) star;
-				;}
-    break;
-
-  case 996:
-#line 2634 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAStar *star = makeNode(PGAStar);
-					star->relation = (yyvsp[(1) - (6)].str);
-					star->except_list = (yyvsp[(4) - (6)].list);
-					star->replace_list = (yyvsp[(5) - (6)].list);
-					star->rename_list = (yyvsp[(6) - (6)].list);
-					star->location = (yylsp[(1) - (6)]);
-					(yyval.node) = (PGNode *) star;
-				;}
-    break;
-
-  case 997:
-#line 2655 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 998:
-#line 2657 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 999:
-#line 2659 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 1000:
-#line 2661 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 1001:
-#line 2663 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1002:
-#line 2665 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1003:
-#line 2667 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1004:
-#line 2669 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1005:
-#line 2671 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1006:
-#line 2673 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1007:
-#line 2675 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1008:
-#line 2677 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1009:
-#line 2679 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1010:
-#line 2681 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1011:
-#line 2683 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1012:
-#line 2685 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1013:
-#line 2687 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1014:
-#line 2689 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1015:
-#line 2691 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 1016:
-#line 2693 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 1017:
-#line 2695 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;}
-    break;
-
-  case 1018:
-#line 2697 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 1019:
-#line 2701 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 1020:
-#line 2705 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 1021:
-#line 2709 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 1023:
-#line 2724 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].list))
-					{
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = (PGNode *) (yyvsp[(1) - (2)].node);
-						n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-						(yyval.node) = (PGNode *) n;
-					}
-					else
-						(yyval.node) = (PGNode *) (yyvsp[(1) - (2)].node);
-				;}
-    break;
-
-  case 1024:
-#line 2737 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1025:
-#line 2738 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1026:
-#line 2740 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = PG_EXPR_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NIL;
-					n->subselect = (yyvsp[(1) - (1)].node);
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1027:
-#line 2751 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * Because the select_with_parens nonterminal is designed
-					 * to "eat" as many levels of parens as possible, the
-					 * '(' a_expr ')' opt_indirection production above will
-					 * fail to match a sub-SELECT with indirection decoration;
-					 * the sub-SELECT won't be regarded as an a_expr as long
-					 * as there are parens around it.  To support applying
-					 * subscripting or field selection to a sub-SELECT result,
-					 * we need this redundant-looking production.
-					 */
-					PGSubLink *n = makeNode(PGSubLink);
-					PGAIndirection *a = makeNode(PGAIndirection);
-					n->subLinkType = PG_EXPR_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NIL;
-					n->subselect = (yyvsp[(1) - (2)].node);
-					n->location = (yylsp[(1) - (2)]);
-					a->arg = (PGNode *)n;
-					a->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.node) = (PGNode *)a;
-				;}
-    break;
-
-  case 1028:
-#line 2775 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = PG_EXISTS_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NIL;
-					n->subselect = (yyvsp[(2) - (2)].node);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1029:
-#line 2786 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				  PGGroupingFunc *g = makeNode(PGGroupingFunc);
-				  g->args = (yyvsp[(3) - (4)].list);
-				  g->location = (yylsp[(1) - (4)]);
-				  (yyval.node) = (PGNode *)g;
-			  ;}
-    break;
-
-  case 1030:
-#line 2796 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(2) - (3)].node);
-				;}
-    break;
-
-  case 1031:
-#line 2800 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(1) - (1)].node);
-				;}
-    break;
-
-  case 1032:
-#line 2803 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)]));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1033:
-#line 2811 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeParamRef(0, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1034:
-#line 2815 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGParamRef *p = makeNode(PGParamRef);
-					p->number = (yyvsp[(1) - (1)].ival);
-					p->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *) p;
-				;}
-    break;
-
-  case 1035:
-#line 2822 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeNamedParamRef((yyvsp[(2) - (2)].str), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 1043:
-#line 2836 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = PG_ARRAY_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NULL;
-					n->subselect = (yyvsp[(2) - (2)].node);
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1044:
-#line 2846 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGList *func_name = list_make1(makeString("construct_array"));
-				PGFuncCall *n = makeFuncCall(func_name, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1045:
-#line 2852 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGPositionalReference *n = makeNode(PGPositionalReference);
-					n->position = (yyvsp[(2) - (2)].ival);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1046:
-#line 2860 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)]));
-                (yyval.node) = (PGNode *) n;
-            ;}
-    break;
-
-  case 1047:
-#line 2867 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *f = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)]));
-					(yyval.node) = (PGNode *) f;
-				;}
-    break;
-
-  case 1048:
-#line 2874 "third_party/libpg_query/grammar/statements/select.y"
-    {
-                    PGList *key_list = NULL;
-                    PGList *value_list = NULL;
-                    PGListCell *lc;
-                    PGList *entry_list = (yyvsp[(3) - (4)].list);
-                    foreach(lc, entry_list)
-                    {
-                        PGList *l = (PGList *) lc->data.ptr_value;
-                        key_list = lappend(key_list, (PGNode *) l->head->data.ptr_value);
-                        value_list = lappend(value_list, (PGNode *) l->tail->data.ptr_value);
-                    }
-                    PGNode *keys   = (PGNode *) makeFuncCall(SystemFuncName("list_value"), key_list, (yylsp[(3) - (4)]));
-                    PGNode *values = (PGNode *) makeFuncCall(SystemFuncName("list_value"), value_list, (yylsp[(3) - (4)]));
-                    PGFuncCall *f = makeFuncCall(SystemFuncName("map"), list_make2(keys, values), (yylsp[(3) - (4)]));
-                    (yyval.node) = (PGNode *) f;
-                ;}
-    break;
-
-  case 1049:
-#line 2894 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall((yyvsp[(1) - (3)].list), NIL, (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 1050:
-#line 2898 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (5)].list), NIL, (yylsp[(1) - (5)]));
-					n->agg_order = (yyvsp[(3) - (5)].list);
-					n->agg_ignore_nulls = (yyvsp[(4) - (5)].ignorenulls);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1051:
-#line 2905 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (6)].list), (yyvsp[(3) - (6)].list), (yylsp[(1) - (6)]));
-					n->agg_order = (yyvsp[(4) - (6)].list);
-					n->agg_ignore_nulls = (yyvsp[(5) - (6)].ignorenulls);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1052:
-#line 2912 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), list_make1((yyvsp[(4) - (7)].node)), (yylsp[(1) - (7)]));
-					n->func_variadic = true;
-					n->agg_order = (yyvsp[(5) - (7)].list);
-					n->agg_ignore_nulls = (yyvsp[(6) - (7)].ignorenulls);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1053:
-#line 2920 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (9)].list), lappend((yyvsp[(3) - (9)].list), (yyvsp[(6) - (9)].node)), (yylsp[(1) - (9)]));
-					n->func_variadic = true;
-					n->agg_order = (yyvsp[(7) - (9)].list);
-					n->agg_ignore_nulls = (yyvsp[(8) - (9)].ignorenulls);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1054:
-#line 2928 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)]));
-					n->agg_order = (yyvsp[(5) - (7)].list);
-					n->agg_ignore_nulls = (yyvsp[(6) - (7)].ignorenulls);
-					/* Ideally we'd mark the PGFuncCall node to indicate
-					 * "must be an aggregate", but there's no provision
-					 * for that in PGFuncCall at the moment.
-					 */
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1055:
-#line 2939 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)]));
-					n->agg_order = (yyvsp[(5) - (7)].list);
-					n->agg_ignore_nulls = (yyvsp[(6) - (7)].ignorenulls);
-					n->agg_distinct = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1056:
-#line 2959 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = (PGFuncCall *) (yyvsp[(1) - (5)].node);
-					/*
-					 * The order clause for WITHIN GROUP and the one for
-					 * plain-aggregate ORDER BY share a field, so we have to
-					 * check here that at most one is present.  We also check
-					 * for DISTINCT and VARIADIC here to give a better error
-					 * location.  Other consistency checks are deferred to
-					 * parse analysis.
-					 */
-					if ((yyvsp[(2) - (5)].list) != NIL)
-					{
-						if (n->agg_order != NIL)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("cannot use multiple ORDER BY clauses with WITHIN GROUP"),
-									 parser_errposition((yylsp[(2) - (5)]))));
-						if (n->agg_distinct)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("cannot use DISTINCT with WITHIN GROUP"),
-									 parser_errposition((yylsp[(2) - (5)]))));
-						if (n->func_variadic)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("cannot use VARIADIC with WITHIN GROUP"),
-									 parser_errposition((yylsp[(2) - (5)]))));
-						n->agg_order = (yyvsp[(2) - (5)].list);
-						n->agg_within_group = true;
-					}
-					n->agg_filter = (yyvsp[(3) - (5)].node);
-					n->export_state = (yyvsp[(4) - (5)].boolean);
-					n->over = (yyvsp[(5) - (5)].windef);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1057:
-#line 2995 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1058:
-#line 3005 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1059:
-#line 3006 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1060:
-#line 3014 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("pg_collation_for"),
-											   list_make1((yyvsp[(4) - (5)].node)),
-											   (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 1061:
-#line 3020 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 0, (yylsp[(1) - (6)])); ;}
-    break;
-
-  case 1062:
-#line 3022 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 1, (yylsp[(1) - (6)])); ;}
-    break;
-
-  case 1063:
-#line 3024 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 1064:
-#line 3028 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* overlay(A PLACING B FROM C FOR D) is converted to
-					 * overlay(A, B, C, D)
-					 * overlay(A PLACING B FROM C) is converted to
-					 * overlay(A, B, C)
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlay"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 1065:
-#line 3037 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* position(A in B) is converted to position_inverse(A, B) */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("__internal_position_operator"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 1066:
-#line 3042 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* substring(A from B for C) is converted to
-					 * substring(A, B, C) - thomas 2000-11-28
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("substring"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 1067:
-#line 3049 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* TREAT(expr AS target) converts expr of a particular type to target,
-					 * which is defined to be a subtype of the original expression.
-					 * In SQL99, this is intended for use with structured UDTs,
-					 * but let's make this a generally useful form allowing stronger
-					 * coercions than are handled by implicit casting.
-					 *
-					 * Convert SystemTypeName() to SystemFuncName() even though
-					 * at the moment they result in the same thing.
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName(((PGValue *)llast((yyvsp[(5) - (6)].typnam)->names))->val.str),
-												list_make1((yyvsp[(3) - (6)].node)),
-												(yylsp[(1) - (6)]));
-				;}
-    break;
-
-  case 1068:
-#line 3064 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* various trim expressions are defined in SQL
-					 * - thomas 1997-07-19
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 1069:
-#line 3071 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 1070:
-#line 3075 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 1071:
-#line 3079 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 1072:
-#line 3083 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NULLIF, "=", (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(1) - (6)]));
-				;}
-    break;
-
-  case 1073:
-#line 3087 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCoalesceExpr *c = makeNode(PGCoalesceExpr);
-					c->args = (yyvsp[(3) - (4)].list);
-					c->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *)c;
-				;}
-    break;
-
-  case 1074:
-#line 3097 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)]));
-			(yyval.node) = (PGNode *) n;
-		;}
-    break;
-
-  case 1075:
-#line 3105 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGLambdaFunction *lambda = makeNode(PGLambdaFunction);
-					lambda->lhs = (yyvsp[(4) - (7)].node);
-					lambda->rhs = (yyvsp[(2) - (7)].node);
-					lambda->location = (yylsp[(1) - (7)]);
-					PGFuncCall *n = makeFuncCall(SystemFuncName("list_apply"), list_make2((yyvsp[(6) - (7)].node), lambda), (yylsp[(1) - (7)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1076:
-#line 3114 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGLambdaFunction *lambda = makeNode(PGLambdaFunction);
-					lambda->lhs = (yyvsp[(4) - (9)].node);
-					lambda->rhs = (yyvsp[(2) - (9)].node);
-					lambda->location = (yylsp[(1) - (9)]);
-
-					PGLambdaFunction *lambda_filter = makeNode(PGLambdaFunction);
-					lambda_filter->lhs = (yyvsp[(4) - (9)].node);
-					lambda_filter->rhs = (yyvsp[(8) - (9)].node);
-					lambda_filter->location = (yylsp[(8) - (9)]);
-					PGFuncCall *filter = makeFuncCall(SystemFuncName("list_filter"), list_make2((yyvsp[(6) - (9)].node), lambda_filter), (yylsp[(1) - (9)]));
-					PGFuncCall *n = makeFuncCall(SystemFuncName("list_apply"), list_make2(filter, lambda), (yylsp[(1) - (9)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1077:
-#line 3135 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(4) - (5)].list); ;}
-    break;
-
-  case 1078:
-#line 3136 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1079:
-#line 3140 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(4) - (5)].node); ;}
-    break;
-
-  case 1080:
-#line 3141 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(3) - (4)].node); ;}
-    break;
-
-  case 1081:
-#line 3142 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1082:
-#line 3146 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1083:
-#line 3147 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1084:
-#line 3154 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1085:
-#line 3155 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1086:
-#line 3159 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;}
-    break;
-
-  case 1087:
-#line 3161 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;}
-    break;
-
-  case 1088:
-#line 3166 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(3) - (3)].windef);
-					n->name = (yyvsp[(1) - (3)].str);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1089:
-#line 3174 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;}
-    break;
-
-  case 1090:
-#line 3176 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->name = (yyvsp[(2) - (2)].str);
-					n->refname = NULL;
-					n->partitionClause = NIL;
-					n->orderClause = NIL;
-					n->frameOptions = FRAMEOPTION_DEFAULTS;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1091:
-#line 3189 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.windef) = NULL; ;}
-    break;
-
-  case 1092:
-#line 3194 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->name = NULL;
-					n->refname = (yyvsp[(2) - (6)].str);
-					n->partitionClause = (yyvsp[(3) - (6)].list);
-					n->orderClause = (yyvsp[(4) - (6)].list);
-					/* copy relevant fields of opt_frame_clause */
-					n->frameOptions = (yyvsp[(5) - (6)].windef)->frameOptions;
-					n->startOffset = (yyvsp[(5) - (6)].windef)->startOffset;
-					n->endOffset = (yyvsp[(5) - (6)].windef)->endOffset;
-					n->location = (yylsp[(1) - (6)]);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1093:
-#line 3219 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1094:
-#line 3220 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 1095:
-#line 3223 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 1096:
-#line 3224 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1097:
-#line 3233 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(2) - (3)].windef);
-
-					n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_RANGE;
-					n->frameOptions |= (yyvsp[(3) - (3)].ival);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1098:
-#line 3241 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(2) - (3)].windef);
-
-					n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_ROWS;
-					n->frameOptions |= (yyvsp[(3) - (3)].ival);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1099:
-#line 3249 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(2) - (3)].windef);
-
-					n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_GROUPS;
-					n->frameOptions |= (yyvsp[(3) - (3)].ival);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1100:
-#line 3257 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-
-					n->frameOptions = FRAMEOPTION_DEFAULTS;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1101:
-#line 3268 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(1) - (1)].windef);
-
-					/* reject invalid cases */
-					if (n->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame start cannot be UNBOUNDED FOLLOWING"),
-								 parser_errposition((yylsp[(1) - (1)]))));
-					if (n->frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame starting from following row cannot end with current row"),
-								 parser_errposition((yylsp[(1) - (1)]))));
-					n->frameOptions |= FRAMEOPTION_END_CURRENT_ROW;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1102:
-#line 3286 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n1 = (yyvsp[(2) - (4)].windef);
-					PGWindowDef *n2 = (yyvsp[(4) - (4)].windef);
-
-					/* form merged options */
-					int		frameOptions = n1->frameOptions;
-					/* shift converts START_ options to END_ options */
-					frameOptions |= n2->frameOptions << 1;
-					frameOptions |= FRAMEOPTION_BETWEEN;
-					/* reject invalid cases */
-					if (frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame start cannot be UNBOUNDED FOLLOWING"),
-								 parser_errposition((yylsp[(2) - (4)]))));
-					if (frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame end cannot be UNBOUNDED PRECEDING"),
-								 parser_errposition((yylsp[(4) - (4)]))));
-					if ((frameOptions & FRAMEOPTION_START_CURRENT_ROW) &&
-						(frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame starting from current row cannot have preceding rows"),
-								 parser_errposition((yylsp[(4) - (4)]))));
-					if ((frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) &&
-						(frameOptions & (FRAMEOPTION_END_OFFSET_PRECEDING |
-										 FRAMEOPTION_END_CURRENT_ROW)))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame starting from following row cannot have preceding rows"),
-								 parser_errposition((yylsp[(4) - (4)]))));
-					n1->frameOptions = frameOptions;
-					n1->endOffset = n2->startOffset;
-					(yyval.windef) = n1;
-				;}
-    break;
-
-  case 1103:
-#line 3332 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-
-					n->frameOptions = FRAMEOPTION_START_UNBOUNDED_PRECEDING;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1104:
-#line 3341 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-
-					n->frameOptions = FRAMEOPTION_START_UNBOUNDED_FOLLOWING;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1105:
-#line 3350 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-
-					n->frameOptions = FRAMEOPTION_START_CURRENT_ROW;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1106:
-#line 3359 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-
-					n->frameOptions = FRAMEOPTION_START_OFFSET_PRECEDING;
-					n->startOffset = (yyvsp[(1) - (2)].node);
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1107:
-#line 3368 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-
-					n->frameOptions = FRAMEOPTION_START_OFFSET_FOLLOWING;
-					n->startOffset = (yyvsp[(1) - (2)].node);
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 1108:
-#line 3379 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; ;}
-    break;
-
-  case 1109:
-#line 3380 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; ;}
-    break;
-
-  case 1110:
-#line 3381 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; ;}
-    break;
-
-  case 1111:
-#line 3382 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 1112:
-#line 3383 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 1113:
-#line 3397 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1114:
-#line 3398 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1115:
-#line 3401 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list);;}
-    break;
-
-  case 1116:
-#line 3402 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;}
-    break;
-
-  case 1117:
-#line 3406 "third_party/libpg_query/grammar/statements/select.y"
-    {
-		PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-		na->name = (yyvsp[(1) - (3)].str);
-		na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-		na->argnumber = -1;
-		na->location = (yylsp[(1) - (3)]);
-		(yyval.node) = (PGNode *) na;
-	;}
-    break;
-
-  case 1118:
-#line 3416 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1119:
-#line 3417 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 1120:
-#line 3421 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1121:
-#line 3422 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1122:
-#line 3427 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
-			;}
-    break;
-
-  case 1123:
-#line 3433 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 1124:
-#line 3434 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 1125:
-#line 3439 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1126:
-#line 3440 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1127:
-#line 3445 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1128:
-#line 3446 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1129:
-#line 3449 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.subquerytype) = PG_ANY_SUBLINK; ;}
-    break;
-
-  case 1130:
-#line 3450 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.subquerytype) = PG_ANY_SUBLINK; ;}
-    break;
-
-  case 1131:
-#line 3451 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.subquerytype) = PG_ALL_SUBLINK; ;}
-    break;
-
-  case 1132:
-#line 3454 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1133:
-#line 3455 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) (yyvsp[(1) - (1)].conststr); ;}
-    break;
-
-  case 1134:
-#line 3458 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "+"; ;}
-    break;
-
-  case 1135:
-#line 3459 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "-"; ;}
-    break;
-
-  case 1136:
-#line 3460 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "*"; ;}
-    break;
-
-  case 1137:
-#line 3461 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "/"; ;}
-    break;
-
-  case 1138:
-#line 3462 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "//"; ;}
-    break;
-
-  case 1139:
-#line 3463 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "%"; ;}
-    break;
-
-  case 1140:
-#line 3464 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "^"; ;}
-    break;
-
-  case 1141:
-#line 3465 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "**"; ;}
-    break;
-
-  case 1142:
-#line 3466 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "<"; ;}
-    break;
-
-  case 1143:
-#line 3467 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = ">"; ;}
-    break;
-
-  case 1144:
-#line 3468 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "="; ;}
-    break;
-
-  case 1145:
-#line 3469 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "<="; ;}
-    break;
-
-  case 1146:
-#line 3470 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = ">="; ;}
-    break;
-
-  case 1147:
-#line 3471 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "<>"; ;}
-    break;
-
-  case 1148:
-#line 3475 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1149:
-#line 3477 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1150:
-#line 3482 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1151:
-#line 3484 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1152:
-#line 3489 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1153:
-#line 3491 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1154:
-#line 3493 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("~~")); ;}
-    break;
-
-  case 1155:
-#line 3495 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("!~~")); ;}
-    break;
-
-  case 1156:
-#line 3497 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("~~~")); ;}
-    break;
-
-  case 1157:
-#line 3499 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("!~~~")); ;}
-    break;
-
-  case 1158:
-#line 3501 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("~~*")); ;}
-    break;
-
-  case 1159:
-#line 3503 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("!~~*")); ;}
-    break;
-
-  case 1160:
-#line 3517 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1161:
-#line 3519 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 1162:
-#line 3524 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 1163:
-#line 3528 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1164:
-#line 3535 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 1165:
-#line 3540 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (2)].list);
-				;}
-    break;
-
-  case 1166:
-#line 3546 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 1167:
-#line 3550 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1168:
-#line 3557 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 1169:
-#line 3562 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (2)].list);
-				;}
-    break;
-
-  case 1170:
-#line 3569 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 1171:
-#line 3573 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = NULL;
-				;}
-    break;
-
-  case 1172:
-#line 3582 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 1173:
-#line 3586 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1174:
-#line 3592 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(1) - (1)].node);
-				;}
-    break;
-
-  case 1175:
-#line 3596 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-					na->name = (yyvsp[(1) - (3)].str);
-					na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-					na->argnumber = -1;		/* until determined */
-					na->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) na;
-				;}
-    break;
-
-  case 1176:
-#line 3605 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-					na->name = (yyvsp[(1) - (3)].str);
-					na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-					na->argnumber = -1;		/* until determined */
-					na->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) na;
-				;}
-    break;
-
-  case 1177:
-#line 3615 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;}
-    break;
-
-  case 1178:
-#line 3616 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;}
-    break;
-
-  case 1179:
-#line 3621 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2(makeStringConst((yyvsp[(1) - (3)].str), (yylsp[(1) - (3)])), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1180:
-#line 3624 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1181:
-#line 3631 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1182:
-#line 3632 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "year"; ;}
-    break;
-
-  case 1183:
-#line 3633 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "month"; ;}
-    break;
-
-  case 1184:
-#line 3634 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "day"; ;}
-    break;
-
-  case 1185:
-#line 3635 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "hour"; ;}
-    break;
-
-  case 1186:
-#line 3636 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "minute"; ;}
-    break;
-
-  case 1187:
-#line 3637 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "second"; ;}
-    break;
-
-  case 1188:
-#line 3638 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "millisecond"; ;}
-    break;
-
-  case 1189:
-#line 3639 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "microsecond"; ;}
-    break;
-
-  case 1190:
-#line 3640 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "week"; ;}
-    break;
-
-  case 1191:
-#line 3641 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "quarter"; ;}
-    break;
-
-  case 1192:
-#line 3642 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "decade"; ;}
-    break;
-
-  case 1193:
-#line 3643 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "century"; ;}
-    break;
-
-  case 1194:
-#line 3644 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "millennium"; ;}
-    break;
-
-  case 1195:
-#line 3645 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1196:
-#line 3656 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make4((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 1197:
-#line 3660 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1198:
-#line 3667 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1199:
-#line 3673 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 1200:
-#line 3674 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1201:
-#line 3691 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1202:
-#line 3695 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* not legal per SQL99, but might as well allow it */
-					(yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yyvsp[(2) - (3)].node));
-				;}
-    break;
-
-  case 1203:
-#line 3700 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
-				;}
-    break;
-
-  case 1204:
-#line 3704 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * Since there are no cases where this syntax allows
-					 * a textual FOR value, we forcibly cast the argument
-					 * to int4.  The possible matches in pg_proc are
-					 * substring(text,int4) and substring(text,text),
-					 * and we don't want the parser to choose the latter,
-					 * which it is likely to do if the second argument
-					 * is unknown or doesn't have an implicit cast to int4.
-					 */
-					(yyval.list) = list_make3((yyvsp[(1) - (2)].node), makeIntConst(1, -1),
-									makeTypeCast((yyvsp[(2) - (2)].node),
-												 SystemTypeName("int4"), 0, -1));
-				;}
-    break;
-
-  case 1205:
-#line 3719 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 1206:
-#line 3723 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1207:
-#line 3727 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1208:
-#line 3730 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1209:
-#line 3733 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;}
-    break;
-
-  case 1210:
-#line 3734 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1211:
-#line 3735 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1212:
-#line 3739 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subselect = (yyvsp[(1) - (1)].node);
-					/* other fields will be filled later */
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1213:
-#line 3745 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1215:
-#line 3747 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1216:
-#line 3758 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCaseExpr *c = makeNode(PGCaseExpr);
-					c->casetype = InvalidOid; /* not analyzed yet */
-					c->arg = (PGExpr *) (yyvsp[(2) - (5)].node);
-					c->args = (yyvsp[(3) - (5)].list);
-					c->defresult = (PGExpr *) (yyvsp[(4) - (5)].node);
-					c->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *)c;
-				;}
-    break;
-
-  case 1217:
-#line 3771 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1218:
-#line 3772 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 1219:
-#line 3777 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCaseWhen *w = makeNode(PGCaseWhen);
-					w->expr = (PGExpr *) (yyvsp[(2) - (4)].node);
-					w->result = (PGExpr *) (yyvsp[(4) - (4)].node);
-					w->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *)w;
-				;}
-    break;
-
-  case 1220:
-#line 3787 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1221:
-#line 3788 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1222:
-#line 3791 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1223:
-#line 3792 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1224:
-#line 3796 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1225:
-#line 3797 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 1226:
-#line 3801 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner);
-		;}
-    break;
-
-  case 1227:
-#line 3807 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner);
-				;}
-    break;
-
-  case 1228:
-#line 3811 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeColumnRef((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].list), (yylsp[(1) - (2)]), yyscanner);
-				;}
-    break;
-
-  case 1229:
-#line 3818 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = false;
-					ai->lidx = NULL;
-					ai->uidx = (yyvsp[(2) - (3)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1230:
-#line 3826 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = true;
-					ai->lidx = (yyvsp[(2) - (5)].node);
-					ai->uidx = (yyvsp[(4) - (5)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1231:
-#line 3833 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				    	PGAIndices *ai = makeNode(PGAIndices);
-				    	ai->is_slice = true;
-				    	ai->lidx = (yyvsp[(2) - (7)].node);
-				    	ai->uidx = (yyvsp[(4) - (7)].node);
-				    	ai->step = (yyvsp[(6) - (7)].node);
-				    	(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1232:
-#line 3841 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = true;
-					ai->lidx = (yyvsp[(2) - (7)].node);
-					ai->step = (yyvsp[(6) - (7)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1233:
-#line 3851 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1234:
-#line 3852 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1235:
-#line 3857 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1236:
-#line 3858 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 1237:
-#line 3862 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1238:
-#line 3863 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(NULL); ;}
-    break;
-
-  case 1239:
-#line 3864 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1240:
-#line 3869 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(3) - (3)].list)) {
-						PGFuncCall *n = makeFuncCall(list_make1(makeString((yyvsp[(2) - (3)].str))), (yyvsp[(3) - (3)].list)->head->data.ptr_value ? (yyvsp[(3) - (3)].list) : NULL, (yylsp[(2) - (3)]));
-						(yyval.node) = (PGNode *) n;
-					} else {
-						(yyval.node) = (PGNode *) makeString((yyvsp[(2) - (3)].str));
-					}
-				;}
-    break;
-
-  case 1241:
-#line 3878 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = false;
-					ai->lidx = NULL;
-					ai->uidx = (yyvsp[(2) - (3)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1242:
-#line 3886 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = true;
-					ai->lidx = (yyvsp[(2) - (5)].node);
-					ai->uidx = (yyvsp[(4) - (5)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1243:
-#line 3893 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = true;
-					ai->lidx = (yyvsp[(2) - (7)].node);
-					ai->uidx = (yyvsp[(4) - (7)].node);
-					ai->step = (yyvsp[(6) - (7)].node);
-                 			(yyval.node) = (PGNode *) ai;
-                		;}
-    break;
-
-  case 1244:
-#line 3902 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = true;
-					ai->lidx = (yyvsp[(2) - (7)].node);
-					ai->step = (yyvsp[(6) - (7)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1245:
-#line 3917 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1246:
-#line 3918 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 1249:
-#line 3934 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1250:
-#line 3935 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1251:
-#line 3939 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;}
-    break;
-
-  case 1252:
-#line 3940 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;}
-    break;
-
-  case 1253:
-#line 3944 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1254:
-#line 3945 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1255:
-#line 3949 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(3) - (3)].str);
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(1) - (3)].node);
-					(yyval.target)->location = (yylsp[(1) - (3)]);
-				;}
-    break;
-
-  case 1256:
-#line 3965 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(2) - (2)].str);
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(1) - (2)].node);
-					(yyval.target)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 1257:
-#line 3973 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = NULL;
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(1) - (1)].node);
-					(yyval.target)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 1258:
-#line 3981 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(1) - (3)].str);
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(3) - (3)].node);
-					(yyval.target)->location = (yylsp[(1) - (3)]);
-				;}
-    break;
-
-  case 1259:
-#line 3990 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1260:
-#line 3991 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 1261:
-#line 3996 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.list) = list_make1((yyvsp[(1) - (1)].str));
-			;}
-    break;
-
-  case 1262:
-#line 4000 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].str));
-			;}
-    break;
-
-  case 1263:
-#line 4006 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 1264:
-#line 4008 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 1265:
-#line 4012 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1266:
-#line 4013 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1267:
-#line 4017 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1268:
-#line 4018 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1269:
-#line 4021 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 1270:
-#line 4025 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 1271:
-#line 4026 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 1272:
-#line 4030 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1273:
-#line 4031 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1274:
-#line 4034 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1275:
-#line 4035 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 1276:
-#line 4036 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1277:
-#line 4039 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].str)); ;}
-    break;
-
-  case 1278:
-#line 4043 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 1279:
-#line 4044 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 1280:
-#line 4048 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1281:
-#line 4049 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1282:
-#line 4051 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1283:
-#line 4052 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 1284:
-#line 4053 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1285:
-#line 4063 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;}
-    break;
-
-  case 1286:
-#line 4064 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;}
-    break;
-
-  case 1287:
-#line 4069 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1288:
-#line 4071 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 1289:
-#line 4076 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1290:
-#line 4077 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1291:
-#line 4081 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1292:
-#line 4082 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1293:
-#line 4085 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1294:
-#line 4097 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1295:
-#line 4100 "third_party/libpg_query/grammar/statements/select.y"
-    {
-						(yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)),
-											 yyscanner);
-					;}
-    break;
-
-  case 1296:
-#line 4111 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1297:
-#line 4115 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1298:
-#line 4119 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].list))
-					{
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)]));
-						n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-						(yyval.node) = (PGNode *) n;
-					}
-					else
-						(yyval.node) = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 1299:
-#line 4131 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1300:
-#line 4135 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* This is a bit constant per SQL99:
-					 * Without Feature F511, "BIT data type",
-					 * a <general literal> shall not be a
-					 * <bit string literal> or a <hex string literal>.
-					 */
-					(yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1301:
-#line 4144 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* generic type 'literal' syntax */
-					PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (2)].list));
-					t->location = (yylsp[(1) - (2)]);
-					(yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), t);
-				;}
-    break;
-
-  case 1302:
-#line 4151 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* generic syntax with a type modifier */
-					PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (7)].list));
-					PGListCell *lc;
-
-					/*
-					 * We must use func_arg_list and opt_sort_clause in the
-					 * production to avoid reduce/reduce conflicts, but we
-					 * don't actually wish to allow PGNamedArgExpr in this
-					 * context, ORDER BY, nor IGNORE NULLS.
-					 */
-					foreach(lc, (yyvsp[(3) - (7)].list))
-					{
-						PGNamedArgExpr *arg = (PGNamedArgExpr *) lfirst(lc);
-
-						if (IsA(arg, PGNamedArgExpr))
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("type modifier cannot have parameter name"),
-									 parser_errposition(arg->location)));
-					}
-					if ((yyvsp[(4) - (7)].list) != NIL)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("type modifier cannot have ORDER BY"),
-									 parser_errposition((yylsp[(4) - (7)]))));
-					if ((yyvsp[(5) - (7)].ignorenulls) != false)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("type modifier cannot have IGNORE NULLS"),
-									 parser_errposition((yylsp[(5) - (7)]))));
-
-
-					t->typmods = (yyvsp[(3) - (7)].list);
-					t->location = (yylsp[(1) - (7)]);
-					(yyval.node) = makeStringConstCast((yyvsp[(7) - (7)].str), (yylsp[(7) - (7)]), t);
-				;}
-    break;
-
-  case 1303:
-#line 4189 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam));
-				;}
-    break;
-
-  case 1304:
-#line 4193 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntervalNode((yyvsp[(3) - (5)].node), (yylsp[(3) - (5)]), (yyvsp[(5) - (5)].list));
-				;}
-    break;
-
-  case 1305:
-#line 4197 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].ival), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list));
-				;}
-    break;
-
-  case 1306:
-#line 4201 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list));
-				;}
-    break;
-
-  case 1307:
-#line 4205 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeBoolAConst(true, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1308:
-#line 4209 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeBoolAConst(false, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1309:
-#line 4213 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeNullAConst((yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1310:
-#line 4218 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;}
-    break;
-
-  case 1311:
-#line 4235 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1312:
-#line 4236 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1313:
-#line 4237 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1314:
-#line 4240 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1315:
-#line 4241 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1316:
-#line 4242 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1317:
-#line 4245 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1318:
-#line 4246 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1319:
-#line 4247 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1320:
-#line 4250 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1321:
-#line 4251 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 1322:
-#line 4255 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;}
-    break;
-
-  case 1323:
-#line 4257 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 1324:
-#line 4261 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1325:
-#line 4262 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1327:
-#line 4269 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1328:
-#line 4270 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1329:
-#line 8 "third_party/libpg_query/grammar/statements/prepare.y"
-    {
-					PGPrepareStmt *n = makeNode(PGPrepareStmt);
-					n->name = (yyvsp[(2) - (5)].str);
-					n->argtypes = (yyvsp[(3) - (5)].list);
-					n->query = (yyvsp[(5) - (5)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1330:
-#line 18 "third_party/libpg_query/grammar/statements/prepare.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1331:
-#line 19 "third_party/libpg_query/grammar/statements/prepare.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1338:
-#line 8 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt);
-					if ((yyvsp[(3) - (4)].range)->catalogname) {
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("CREATE SCHEMA too many dots: expected \"catalog.schema\" or \"schema\""),
-								 parser_errposition((yylsp[(3) - (4)]))));
-					}
-					if ((yyvsp[(3) - (4)].range)->schemaname) {
-						n->catalogname = (yyvsp[(3) - (4)].range)->schemaname;
-						n->schemaname = (yyvsp[(3) - (4)].range)->relname;
-					} else {
-						n->schemaname = (yyvsp[(3) - (4)].range)->relname;
-					}
-					n->schemaElts = (yyvsp[(4) - (4)].list);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1339:
-#line 27 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt);
-					if ((yyvsp[(6) - (7)].range)->catalogname) {
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("CREATE SCHEMA too many dots: expected \"catalog.schema\" or \"schema\""),
-								 parser_errposition((yylsp[(6) - (7)]))));
-					}
-					if ((yyvsp[(6) - (7)].range)->schemaname) {
-						n->catalogname = (yyvsp[(6) - (7)].range)->schemaname;
-						n->schemaname = (yyvsp[(6) - (7)].range)->relname;
-					} else {
-						n->schemaname = (yyvsp[(6) - (7)].range)->relname;
-					}
-					if ((yyvsp[(7) - (7)].list) != NIL)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("CREATE SCHEMA IF NOT EXISTS cannot include schema elements"),
-								 parser_errposition((yylsp[(7) - (7)]))));
-					n->schemaElts = (yyvsp[(7) - (7)].list);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1340:
-#line 51 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt);
-					if ((yyvsp[(5) - (6)].range)->catalogname) {
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("CREATE SCHEMA too many dots: expected \"catalog.schema\" or \"schema\""),
-								 parser_errposition((yylsp[(5) - (6)]))));
-					}
-					if ((yyvsp[(5) - (6)].range)->schemaname) {
-						n->catalogname = (yyvsp[(5) - (6)].range)->schemaname;
-						n->schemaname = (yyvsp[(5) - (6)].range)->relname;
-					} else {
-						n->schemaname = (yyvsp[(5) - (6)].range)->relname;
-					}
-					n->schemaElts = (yyvsp[(6) - (6)].list);
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1341:
-#line 74 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					if ((yyloc) < 0)			/* see comments for YYLLOC_DEFAULT */
-						(yyloc) = (yylsp[(2) - (2)]);
-					(yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node));
-				;}
-    break;
-
-  case 1342:
-#line 80 "third_party/libpg_query/grammar/statements/create_schema.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1347:
-#line 11 "third_party/libpg_query/grammar/statements/index.y"
-    {
-					PGIndexStmt *n = makeNode(PGIndexStmt);
-					n->unique = (yyvsp[(2) - (13)].boolean);
-					n->concurrent = (yyvsp[(4) - (13)].boolean);
-					n->idxname = (yyvsp[(5) - (13)].str);
-					n->relation = (yyvsp[(7) - (13)].range);
-					n->accessMethod = (yyvsp[(8) - (13)].str);
-					n->indexParams = (yyvsp[(10) - (13)].list);
-					n->options = (yyvsp[(12) - (13)].list);
-					n->whereClause = (yyvsp[(13) - (13)].node);
-					n->excludeOpNames = NIL;
-					n->idxcomment = NULL;
-					n->indexOid = InvalidOid;
-					n->oldNode = InvalidOid;
-					n->primary = false;
-					n->isconstraint = false;
-					n->deferrable = false;
-					n->initdeferred = false;
-					n->transformed = false;
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1348:
-#line 36 "third_party/libpg_query/grammar/statements/index.y"
-    {
-					PGIndexStmt *n = makeNode(PGIndexStmt);
-					n->unique = (yyvsp[(2) - (16)].boolean);
-					n->concurrent = (yyvsp[(4) - (16)].boolean);
-					n->idxname = (yyvsp[(8) - (16)].str);
-					n->relation = (yyvsp[(10) - (16)].range);
-					n->accessMethod = (yyvsp[(11) - (16)].str);
-					n->indexParams = (yyvsp[(13) - (16)].list);
-					n->options = (yyvsp[(15) - (16)].list);
-					n->whereClause = (yyvsp[(16) - (16)].node);
-					n->excludeOpNames = NIL;
-					n->idxcomment = NULL;
-					n->indexOid = InvalidOid;
-					n->oldNode = InvalidOid;
-					n->primary = false;
-					n->isconstraint = false;
-					n->deferrable = false;
-					n->initdeferred = false;
-					n->transformed = false;
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1349:
-#line 62 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1350:
-#line 66 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 1351:
-#line 67 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; ;}
-    break;
-
-  case 1352:
-#line 72 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1353:
-#line 73 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1354:
-#line 78 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1355:
-#line 79 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 1356:
-#line 83 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1357:
-#line 84 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1358:
-#line 89 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1359:
-#line 90 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1360:
-#line 8 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->newschema = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1361:
-#line 17 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->newschema = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1362:
-#line 26 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->newschema = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1363:
-#line 35 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->newschema = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1364:
-#line 44 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->newschema = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1365:
-#line 53 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->newschema = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1366:
-#line 6 "third_party/libpg_query/grammar/statements/checkpoint.y"
-    {
-					PGCheckPointStmt *n = makeNode(PGCheckPointStmt);
-					n->force = true;
-					n->name = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1367:
-#line 13 "third_party/libpg_query/grammar/statements/checkpoint.y"
-    {
-					PGCheckPointStmt *n = makeNode(PGCheckPointStmt);
-					n->force = false;
-					n->name = (yyvsp[(2) - (2)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1368:
-#line 22 "third_party/libpg_query/grammar/statements/checkpoint.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1369:
-#line 23 "third_party/libpg_query/grammar/statements/checkpoint.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 1370:
-#line 8 "third_party/libpg_query/grammar/statements/comment_on.y"
-    {
-					PGCommentOnStmt *n = makeNode(PGCommentOnStmt);
-					n->object_type = (yyvsp[(3) - (6)].objtype);
-					n->name = (yyvsp[(4) - (6)].range);
-					n->value = (yyvsp[(6) - (6)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1371:
-#line 16 "third_party/libpg_query/grammar/statements/comment_on.y"
-    {
-                    PGCommentOnStmt *n = makeNode(PGCommentOnStmt);
-                    n->object_type = PG_OBJECT_COLUMN;
-                    n->column_expr = (yyvsp[(4) - (6)].node);
-                    n->value = (yyvsp[(6) - (6)].node);
-                    (yyval.node) = (PGNode *)n;
-                ;}
-    break;
-
-  case 1372:
-#line 26 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;}
-    break;
-
-  case 1373:
-#line 27 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); ;}
-    break;
-
-  case 1374:
-#line 30 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_TABLE; ;}
-    break;
-
-  case 1375:
-#line 31 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;}
-    break;
-
-  case 1376:
-#line 32 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_FUNCTION; ;}
-    break;
-
-  case 1377:
-#line 33 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_FUNCTION; ;}
-    break;
-
-  case 1378:
-#line 34 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;}
-    break;
-
-  case 1379:
-#line 35 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_VIEW; ;}
-    break;
-
-  case 1380:
-#line 36 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_DATABASE; ;}
-    break;
-
-  case 1381:
-#line 37 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_INDEX; ;}
-    break;
-
-  case 1382:
-#line 38 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_SCHEMA; ;}
-    break;
-
-  case 1383:
-#line 39 "third_party/libpg_query/grammar/statements/comment_on.y"
-    { (yyval.objtype) = PG_OBJECT_TYPE; ;}
-    break;
-
-  case 1384:
-#line 8 "third_party/libpg_query/grammar/statements/export.y"
-    {
-					PGExportStmt *n = makeNode(PGExportStmt);
-					n->database = NULL;
-					n->filename = (yyvsp[(3) - (4)].str);
-					n->options = NIL;
-					if ((yyvsp[(4) - (4)].list)) {
-						n->options = list_concat(n->options, (yyvsp[(4) - (4)].list));
-					}
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1385:
-#line 20 "third_party/libpg_query/grammar/statements/export.y"
-    {
-					PGExportStmt *n = makeNode(PGExportStmt);
-					n->database = (yyvsp[(3) - (6)].str);
-					n->filename = (yyvsp[(5) - (6)].str);
-					n->options = NIL;
-					if ((yyvsp[(6) - (6)].list)) {
-						n->options = list_concat(n->options, (yyvsp[(6) - (6)].list));
-					}
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1386:
-#line 34 "third_party/libpg_query/grammar/statements/export.y"
-    {
-					PGImportStmt *n = makeNode(PGImportStmt);
-					n->filename = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1387:
-#line 10 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(2) - (2)].node);
-					n->options = NIL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1388:
-#line 17 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(4) - (4)].node);
-					n->options = list_make1(makeDefElem("analyze", NULL, (yylsp[(2) - (4)])));
-					if ((yyvsp[(3) - (4)].boolean))
-						n->options = lappend(n->options,
-											 makeDefElem("verbose", NULL, (yylsp[(3) - (4)])));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1389:
-#line 27 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(3) - (3)].node);
-					n->options = list_make1(makeDefElem("verbose", NULL, (yylsp[(2) - (3)])));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1390:
-#line 34 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(5) - (5)].node);
-					n->options = (yyvsp[(3) - (5)].list);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1391:
-#line 44 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1392:
-#line 45 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1393:
-#line 50 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 1394:
-#line 51 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;}
-    break;
-
-  case 1395:
-#line 52 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1427:
-#line 91 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1428:
-#line 92 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1429:
-#line 93 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1430:
-#line 98 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1431:
-#line 99 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1432:
-#line 105 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].defelt));
-				;}
-    break;
-
-  case 1433:
-#line 109 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt));
-				;}
-    break;
-
-  case 1434:
-#line 116 "third_party/libpg_query/grammar/statements/explain.y"
-    {;}
-    break;
-
-  case 1435:
-#line 117 "third_party/libpg_query/grammar/statements/explain.y"
-    {;}
-    break;
-
-  case 1436:
-#line 122 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "true"; ;}
-    break;
-
-  case 1437:
-#line 123 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "false"; ;}
-    break;
-
-  case 1438:
-#line 124 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "on"; ;}
-    break;
-
-  case 1439:
-#line 130 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1440:
-#line 136 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 1441:
-#line 143 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1442:
-#line 144 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "analyze"; ;}
-    break;
-
-  case 1443:
-#line 11 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(2) - (2)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_DEFAULT;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1444:
-#line 17 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_LOCAL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1445:
-#line 23 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_SESSION;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1446:
-#line 29 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_GLOBAL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1447:
-#line 35 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_VARIABLE;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1448:
-#line 44 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {(yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt);;}
-    break;
-
-  case 1449:
-#line 46 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_CURRENT;
-					n->name = (yyvsp[(1) - (3)].str);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1450:
-#line 54 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (char*) "timezone";
-					if ((yyvsp[(3) - (3)].node) != NULL)
-						n->args = list_make1((yyvsp[(3) - (3)].node));
-					else
-						n->kind = VAR_SET_DEFAULT;
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1451:
-#line 65 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (char*) "search_path";
-					n->args = list_make1(makeStringConst((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)])));
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1452:
-#line 77 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (yyvsp[(1) - (3)].str);
-					n->args = (yyvsp[(3) - (3)].list);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1453:
-#line 85 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (yyvsp[(1) - (3)].str);
-					n->args = (yyvsp[(3) - (3)].list);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1454:
-#line 96 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1455:
-#line 102 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					(yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1456:
-#line 106 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					(yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1457:
-#line 110 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGTypeName *t = (yyvsp[(1) - (3)].typnam);
-					if ((yyvsp[(3) - (3)].list) != NIL)
-					{
-						PGAConst *n = (PGAConst *) linitial((yyvsp[(3) - (3)].list));
-						if ((n->val.val.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("time zone interval must be HOUR or HOUR TO MINUTE"),
-									 parser_errposition((yylsp[(3) - (3)]))));
-					}
-					t->typmods = (yyvsp[(3) - (3)].list);
-					(yyval.node) = makeStringConstCast((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), t);
-				;}
-    break;
-
-  case 1458:
-#line 125 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGTypeName *t = (yyvsp[(1) - (5)].typnam);
-					t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
-											makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)])));
-					(yyval.node) = makeStringConstCast((yyvsp[(5) - (5)].str), (yylsp[(5) - (5)]), t);
-				;}
-    break;
-
-  case 1459:
-#line 131 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;}
-    break;
-
-  case 1460:
-#line 132 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1461:
-#line 133 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1462:
-#line 137 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1463:
-#line 138 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 1464:
-#line 8 "third_party/libpg_query/grammar/statements/load.y"
-    {
-					PGLoadStmt *n = makeNode(PGLoadStmt);
-					n->filename = (yyvsp[(2) - (2)].str);
-					n->repository = NULL;
-					n->repo_is_alias = false;
-					n->version = NULL;
-					n->load_type = PG_LOAD_TYPE_LOAD;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1465:
-#line 17 "third_party/libpg_query/grammar/statements/load.y"
-    {
-                    PGLoadStmt *n = makeNode(PGLoadStmt);
-                    n->filename = (yyvsp[(3) - (4)].str);
-                    n->repository = NULL;
-                    n->repo_is_alias = false;
-                    n->version = (yyvsp[(4) - (4)].str);
-                    n->load_type = (yyvsp[(1) - (4)].loadinstalltype);
-                    (yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1466:
-#line 26 "third_party/libpg_query/grammar/statements/load.y"
-    {
-                    PGLoadStmt *n = makeNode(PGLoadStmt);
-                    n->repository = (yyvsp[(5) - (6)].str);
-                    n->repo_is_alias = true;
-                    n->filename = (yyvsp[(3) - (6)].str);
-                    n->version = (yyvsp[(6) - (6)].str);
-                    n->load_type = (yyvsp[(1) - (6)].loadinstalltype);
-                    (yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1467:
-#line 35 "third_party/libpg_query/grammar/statements/load.y"
-    {
-                    PGLoadStmt *n = makeNode(PGLoadStmt);
-                    n->filename = (yyvsp[(3) - (6)].str);
-                    n->repository = (yyvsp[(5) - (6)].str);
-                    n->repo_is_alias = false;
-                    n->version = (yyvsp[(6) - (6)].str);
-                    n->load_type = (yyvsp[(1) - (6)].loadinstalltype);
-                    (yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1468:
-#line 46 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.loadinstalltype) = PG_LOAD_TYPE_INSTALL; ;}
-    break;
-
-  case 1469:
-#line 47 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.loadinstalltype) = PG_LOAD_TYPE_FORCE_INSTALL; ;}
-    break;
-
-  case 1470:
-#line 49 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1471:
-#line 50 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1472:
-#line 53 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 1473:
-#line 54 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 1474:
-#line 55 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 1475:
-#line 9 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM;
-					if ((yyvsp[(2) - (4)].boolean))
-						n->options |= PG_VACOPT_FULL;
-					if ((yyvsp[(3) - (4)].boolean))
-						n->options |= PG_VACOPT_FREEZE;
-					if ((yyvsp[(4) - (4)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = NULL;
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1476:
-#line 23 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM;
-					if ((yyvsp[(2) - (6)].boolean))
-						n->options |= PG_VACOPT_FULL;
-					if ((yyvsp[(3) - (6)].boolean))
-						n->options |= PG_VACOPT_FREEZE;
-					if ((yyvsp[(4) - (6)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->va_cols = (yyvsp[(6) - (6)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1477:
-#line 37 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = (PGVacuumStmt *) (yyvsp[(5) - (5)].node);
-					n->options |= PG_VACOPT_VACUUM;
-					if ((yyvsp[(2) - (5)].boolean))
-						n->options |= PG_VACOPT_FULL;
-					if ((yyvsp[(3) - (5)].boolean))
-						n->options |= PG_VACOPT_FREEZE;
-					if ((yyvsp[(4) - (5)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1478:
-#line 49 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM | (yyvsp[(3) - (4)].ival);
-					n->relation = NULL;
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1479:
-#line 57 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM | (yyvsp[(3) - (6)].ival);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->va_cols = (yyvsp[(6) - (6)].list);
-					if (n->va_cols != NIL)	/* implies analyze */
-						n->options |= PG_VACOPT_ANALYZE;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1480:
-#line 70 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_ANALYZE; ;}
-    break;
-
-  case 1481:
-#line 71 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_VERBOSE; ;}
-    break;
-
-  case 1482:
-#line 72 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_FREEZE; ;}
-    break;
-
-  case 1483:
-#line 73 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_FULL; ;}
-    break;
-
-  case 1484:
-#line 75 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					if (strcmp((yyvsp[(1) - (1)].str), "disable_page_skipping") == 0)
-						(yyval.ival) = PG_VACOPT_DISABLE_PAGE_SKIPPING;
-					else
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-							 errmsg("unrecognized VACUUM option \"%s\"", (yyvsp[(1) - (1)].str)),
-									 parser_errposition((yylsp[(1) - (1)]))));
-				;}
-    break;
-
-  case 1485:
-#line 87 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1486:
-#line 88 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1487:
-#line 93 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;}
-    break;
-
-  case 1488:
-#line 94 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 1489:
-#line 98 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1490:
-#line 99 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1491:
-#line 9 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGDeleteStmt *n = makeNode(PGDeleteStmt);
-					n->relation = (yyvsp[(4) - (7)].range);
-					n->usingClause = (yyvsp[(5) - (7)].list);
-					n->whereClause = (yyvsp[(6) - (7)].node);
-					n->returningList = (yyvsp[(7) - (7)].list);
-					n->withClause = (yyvsp[(1) - (7)].with);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1492:
-#line 19 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGDeleteStmt *n = makeNode(PGDeleteStmt);
-					n->relation = (yyvsp[(3) - (3)].range);
-					n->usingClause = NULL;
-					n->whereClause = NULL;
-					n->returningList = NULL;
-					n->withClause = NULL;
-					(yyval.node) = (PGNode *)n;
-			    ;}
-    break;
-
-  case 1493:
-#line 32 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-				;}
-    break;
-
-  case 1494:
-#line 36 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGAlias *alias = makeNode(PGAlias);
-					alias->aliasname = (yyvsp[(2) - (2)].str);
-					(yyvsp[(1) - (2)].range)->alias = alias;
-					(yyval.range) = (yyvsp[(1) - (2)].range);
-				;}
-    break;
-
-  case 1495:
-#line 43 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGAlias *alias = makeNode(PGAlias);
-					alias->aliasname = (yyvsp[(3) - (3)].str);
-					(yyvsp[(1) - (3)].range)->alias = alias;
-					(yyval.range) = (yyvsp[(1) - (3)].range);
-				;}
-    break;
-
-  case 1496:
-#line 53 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1497:
-#line 54 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1498:
-#line 60 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1499:
-#line 61 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1500:
-#line 10 "third_party/libpg_query/grammar/statements/analyze.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_ANALYZE;
-					if ((yyvsp[(2) - (2)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = NULL;
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1501:
-#line 20 "third_party/libpg_query/grammar/statements/analyze.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_ANALYZE;
-					if ((yyvsp[(2) - (4)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->va_cols = (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1502:
-#line 8 "third_party/libpg_query/grammar/statements/attach.y"
-    {
-					PGAttachStmt *n = makeNode(PGAttachStmt);
-					n->path = (yyvsp[(3) - (5)].str);
-					n->name = (yyvsp[(4) - (5)].str);
-					n->options = (yyvsp[(5) - (5)].list);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1503:
-#line 17 "third_party/libpg_query/grammar/statements/attach.y"
-    {
-					PGAttachStmt *n = makeNode(PGAttachStmt);
-					n->path = (yyvsp[(6) - (8)].str);
-					n->name = (yyvsp[(7) - (8)].str);
-					n->options = (yyvsp[(8) - (8)].list);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1504:
-#line 29 "third_party/libpg_query/grammar/statements/attach.y"
-    {
-					PGDetachStmt *n = makeNode(PGDetachStmt);
-					n->missing_ok = false;
-					n->db_name = (yyvsp[(2) - (2)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1505:
-#line 36 "third_party/libpg_query/grammar/statements/attach.y"
-    {
-					PGDetachStmt *n = makeNode(PGDetachStmt);
-					n->missing_ok = false;
-					n->db_name = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1506:
-#line 43 "third_party/libpg_query/grammar/statements/attach.y"
-    {
-					PGDetachStmt *n = makeNode(PGDetachStmt);
-					n->missing_ok = true;
-					n->db_name = (yyvsp[(5) - (5)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1507:
-#line 51 "third_party/libpg_query/grammar/statements/attach.y"
-    {;}
-    break;
-
-  case 1508:
-#line 52 "third_party/libpg_query/grammar/statements/attach.y"
-    {;}
-    break;
-
-  case 1509:
-#line 56 "third_party/libpg_query/grammar/statements/attach.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 1510:
-#line 57 "third_party/libpg_query/grammar/statements/attach.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 1511:
-#line 3 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-				(yyvsp[(2) - (2)].vsetstmt)->scope = VAR_SET_SCOPE_DEFAULT;
-				(yyval.node) = (PGNode *) (yyvsp[(2) - (2)].vsetstmt);
-			;}
-    break;
-
-  case 1512:
-#line 8 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					(yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_LOCAL;
-					(yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt);
-				;}
-    break;
-
-  case 1513:
-#line 13 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					(yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_SESSION;
-					(yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt);
-				;}
-    break;
-
-  case 1514:
-#line 18 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					(yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_GLOBAL;
-					(yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt);
-				;}
-    break;
-
-  case 1515:
-#line 23 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					(yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_VARIABLE;
-					(yyval.node) = (PGNode *) (yyvsp[(3) - (3)].vsetstmt);
-				;}
-    break;
-
-  case 1516:
-#line 32 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET;
-					n->name = (yyvsp[(1) - (1)].str);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1517:
-#line 39 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET_ALL;
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1518:
-#line 48 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    { (yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt); ;}
-    break;
-
-  case 1519:
-#line 50 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET;
-					n->name = (char*) "timezone";
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1520:
-#line 57 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET;
-					n->name = (char*) "transaction_isolation";
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1521:
-#line 3 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt);
-				n->stmt = (yyvsp[(2) - (2)].node);
-				n->name = (char*) "select";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1522:
-#line 10 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt);
-				n->stmt = (yyvsp[(2) - (2)].node);
-				n->name = (char*) "select";
-				n->is_summary = 1;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1523:
-#line 18 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->relation = (yyvsp[(2) - (2)].range);
-				n->is_summary = 1;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1524:
-#line 25 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->relation = (yyvsp[(2) - (2)].range);
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1525:
-#line 32 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->set = (char*) "timezone";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1526:
-#line 39 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->set = (char*) "transaction_isolation";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1527:
-#line 46 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->set = (char*) "__show_tables_expanded";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1528:
-#line 53 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->set = (char*) "__show_tables_expanded";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1535:
-#line 67 "third_party/libpg_query/grammar/statements/variable_show.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1536:
-#line 69 "third_party/libpg_query/grammar/statements/variable_show.y"
-    { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;}
-    break;
-
-  case 1537:
-#line 7 "third_party/libpg_query/grammar/statements/call.y"
-    {
-					PGCallStmt *n = makeNode(PGCallStmt);
-					n->func = (yyvsp[(2) - (2)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1538:
-#line 10 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(4) - (9)].range);
-					n->view->relpersistence = (yyvsp[(2) - (9)].ival);
-					n->aliases = (yyvsp[(5) - (9)].list);
-					n->query = (yyvsp[(8) - (9)].node);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					n->options = (yyvsp[(6) - (9)].list);
-					n->withCheckOption = (yyvsp[(9) - (9)].viewcheckoption);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1539:
-#line 23 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(7) - (12)].range);
-					n->view->relpersistence = (yyvsp[(2) - (12)].ival);
-					n->aliases = (yyvsp[(8) - (12)].list);
-					n->query = (yyvsp[(11) - (12)].node);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					n->options = (yyvsp[(9) - (12)].list);
-					n->withCheckOption = (yyvsp[(12) - (12)].viewcheckoption);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1540:
-#line 36 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(6) - (11)].range);
-					n->view->relpersistence = (yyvsp[(4) - (11)].ival);
-					n->aliases = (yyvsp[(7) - (11)].list);
-					n->query = (yyvsp[(10) - (11)].node);
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					n->options = (yyvsp[(8) - (11)].list);
-					n->withCheckOption = (yyvsp[(11) - (11)].viewcheckoption);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1541:
-#line 49 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(5) - (12)].range);
-					n->view->relpersistence = (yyvsp[(2) - (12)].ival);
-					n->aliases = (yyvsp[(7) - (12)].list);
-					n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[(11) - (12)].node));
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					n->options = (yyvsp[(9) - (12)].list);
-					n->withCheckOption = (yyvsp[(12) - (12)].viewcheckoption);
-					if (n->withCheckOption != PG_NO_CHECK_OPTION)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("WITH CHECK OPTION not supported on recursive views"),
-								 parser_errposition((yylsp[(12) - (12)]))));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1542:
-#line 67 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(7) - (14)].range);
-					n->view->relpersistence = (yyvsp[(4) - (14)].ival);
-					n->aliases = (yyvsp[(9) - (14)].list);
-					n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[(13) - (14)].node));
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					n->options = (yyvsp[(11) - (14)].list);
-					n->withCheckOption = (yyvsp[(14) - (14)].viewcheckoption);
-					if (n->withCheckOption != PG_NO_CHECK_OPTION)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("WITH CHECK OPTION not supported on recursive views"),
-								 parser_errposition((yylsp[(14) - (14)]))));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1543:
-#line 87 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;}
-    break;
-
-  case 1544:
-#line 88 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;}
-    break;
-
-  case 1545:
-#line 89 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; ;}
-    break;
-
-  case 1546:
-#line 90 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; ;}
-    break;
-
-  case 1547:
-#line 12 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					ctas->query = (yyvsp[(6) - (7)].node);
-					ctas->into = (yyvsp[(4) - (7)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_ERROR_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(4) - (7)].into)->rel->relpersistence = (yyvsp[(2) - (7)].ival);
-					(yyvsp[(4) - (7)].into)->skipData = !((yyvsp[(7) - (7)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 1548:
-#line 25 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					ctas->query = (yyvsp[(9) - (10)].node);
-					ctas->into = (yyvsp[(7) - (10)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_IGNORE_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(7) - (10)].into)->rel->relpersistence = (yyvsp[(2) - (10)].ival);
-					(yyvsp[(7) - (10)].into)->skipData = !((yyvsp[(10) - (10)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 1549:
-#line 38 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					ctas->query = (yyvsp[(8) - (9)].node);
-					ctas->into = (yyvsp[(6) - (9)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_REPLACE_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(6) - (9)].into)->rel->relpersistence = (yyvsp[(4) - (9)].ival);
-					(yyvsp[(6) - (9)].into)->skipData = !((yyvsp[(9) - (9)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 1550:
-#line 54 "third_party/libpg_query/grammar/statements/create_as.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1551:
-#line 55 "third_party/libpg_query/grammar/statements/create_as.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1552:
-#line 56 "third_party/libpg_query/grammar/statements/create_as.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1553:
-#line 62 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					(yyval.into) = makeNode(PGIntoClause);
-					(yyval.into)->rel = (yyvsp[(1) - (4)].range);
-					(yyval.into)->colNames = (yyvsp[(2) - (4)].list);
-					(yyval.into)->options = (yyvsp[(3) - (4)].list);
-					(yyval.into)->onCommit = (yyvsp[(4) - (4)].oncommit);
-					(yyval.into)->viewQuery = NULL;
-					(yyval.into)->skipData = false;		/* might get changed later */
-				;}
-    break;
-
-
-/* Line 1267 of yacc.c.  */
-#line 31526 "third_party/libpg_query/grammar/grammar_out.cpp"
-      default: break;
-    }
-  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-
-  *++yyvsp = yyval;
-  *++yylsp = yyloc;
-
-  /* Now `shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
-
-  goto yynewstate;
-
-
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
-    {
-      ++yynerrs;
-#if ! YYERROR_VERBOSE
-      yyerror (&yylloc, yyscanner, YY_("syntax error"));
-#else
-      {
-	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
-	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
-	  {
-	    YYSIZE_T yyalloc = 2 * yysize;
-	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
-	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
-	    if (yymsg != yymsgbuf)
-	      YYSTACK_FREE (yymsg);
-	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
-	    if (yymsg)
-	      yymsg_alloc = yyalloc;
-	    else
-	      {
-		yymsg = yymsgbuf;
-		yymsg_alloc = sizeof yymsgbuf;
-	      }
-	  }
-
-	if (0 < yysize && yysize <= yymsg_alloc)
-	  {
-	    (void) yysyntax_error (yymsg, yystate, yychar);
-	    yyerror (&yylloc, yyscanner, yymsg);
-	  }
-	else
-	  {
-	    yyerror (&yylloc, yyscanner, YY_("syntax error"));
-	    if (yysize != 0)
-	      goto yyexhaustedlab;
-	  }
-      }
-#endif
-    }
-
-  yyerror_range[0] = yylloc;
-
-  if (yyerrstatus == 3)
-    {
-      /* If just tried and failed to reuse look-ahead token after an
-	 error, discard it.  */
-
-      if (yychar <= YYEOF)
-	{
-	  /* Return failure if at end of input.  */
-	  if (yychar == YYEOF)
-	    YYABORT;
-	}
-      else
-	{
-	  yydestruct ("Error: discarding",
-		      yytoken, &yylval, &yylloc, yyscanner);
-	  yychar = YYEMPTY;
-	}
-    }
-
-  /* Else will try to reuse look-ahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
-
-  yyerror_range[0] = yylsp[1-yylen];
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYERROR.  */
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-  yystate = *yyssp;
-  goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
-
-  for (;;)
-    {
-      yyn = yypact[yystate];
-      if (yyn != YYPACT_NINF)
-	{
-	  yyn += YYTERROR;
-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-	    {
-	      yyn = yytable[yyn];
-	      if (0 < yyn)
-		break;
-	    }
-	}
-
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-	YYABORT;
-
-      yyerror_range[0] = *yylsp;
-      yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp, yylsp, yyscanner);
-      YYPOPSTACK (1);
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
-    }
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  *++yyvsp = yylval;
-
-  yyerror_range[1] = yylloc;
-  /* Using YYLLOC is tempting, but would change the location of
-     the look-ahead.  YYLOC is available though.  */
-  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
-  *++yylsp = yyloc;
-
-  /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
-  yystate = yyn;
-  goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturn;
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturn;
-
-#ifndef yyoverflow
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here.  |
-`-------------------------------------------------*/
-yyexhaustedlab:
-  yyerror (&yylloc, yyscanner, YY_("memory exhausted"));
-  yyresult = 2;
-  /* Fall through.  */
-#endif
-
-yyreturn:
-  if (yychar != YYEOF && yychar != YYEMPTY)
-     yydestruct ("Cleanup: discarding lookahead",
-		 yytoken, &yylval, &yylloc, yyscanner);
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYABORT or YYACCEPT.  */
-  YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
-  while (yyssp != yyss)
-    {
-      yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp, yylsp, yyscanner);
-      YYPOPSTACK (1);
-    }
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
-  if (yymsg != yymsgbuf)
-    YYSTACK_FREE (yymsg);
-#endif
-  /* Make sure YYID is used.  */
-  return YYID (yyresult);
-}
-
-
-#line 83 "third_party/libpg_query/grammar/statements/create_as.y"
-
-
-#line 1 "third_party/libpg_query/grammar/grammar.cpp"
-/*
- * The signature of this function is required by bison.  However, we
- * ignore the passed yylloc and instead use the last token position
- * available from the scanner.
- */
-static void
-base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner, const char *msg)
-{
-	parser_yyerror(msg);
-}
-
-static PGRawStmt *
-makeRawStmt(PGNode *stmt, int stmt_location)
-{
-	PGRawStmt    *rs = makeNode(PGRawStmt);
-
-	rs->stmt = stmt;
-	rs->stmt_location = stmt_location;
-	rs->stmt_len = 0;			/* might get changed later */
-	return rs;
-}
-
-/* Adjust a PGRawStmt to reflect that it doesn't run to the end of the string */
-static void
-updateRawStmtEnd(PGRawStmt *rs, int end_location)
-{
-	/*
-	 * If we already set the length, don't change it.  This is for situations
-	 * like "select foo ;; select bar" where the same statement will be last
-	 * in the string for more than one semicolon.
-	 */
-	if (rs->stmt_len > 0)
-		return;
-
-	/* OK, update length of PGRawStmt */
-	rs->stmt_len = end_location - rs->stmt_location;
-}
-
-static PGNode *
-makeColumnRef(char *colname, PGList *indirection,
-			  int location, core_yyscan_t yyscanner)
-{
-	/*
-	 * Generate a PGColumnRef node, with an PGAIndirection node added if there
-	 * is any subscripting in the specified indirection list.  However,
-	 * any field selection at the start of the indirection list must be
-	 * transposed into the "fields" part of the PGColumnRef node.
-	 */
-	PGColumnRef  *c = makeNode(PGColumnRef);
-	int		nfields = 0;
-	PGListCell *l;
-
-	c->location = location;
-	foreach(l, indirection)
-	{
-		if (IsA(lfirst(l), PGAIndices))
-		{
-			PGAIndirection *i = makeNode(PGAIndirection);
-
-			if (nfields == 0)
-			{
-				/* easy case - all indirection goes to PGAIndirection */
-				c->fields = list_make1(makeString(colname));
-				i->indirection = check_indirection(indirection, yyscanner);
-			}
-			else
-			{
-				/* got to split the list in two */
-				i->indirection = check_indirection(list_copy_tail(indirection,
-																  nfields),
-												   yyscanner);
-				indirection = list_truncate(indirection, nfields);
-				c->fields = lcons(makeString(colname), indirection);
-			}
-			i->arg = (PGNode *) c;
-			return (PGNode *) i;
-		}
-		else if (IsA(lfirst(l), PGAStar))
-		{
-			/* We only allow '*' at the end of a PGColumnRef */
-			if (lnext(l) != NULL)
-				parser_yyerror("improper use of \"*\"");
-		}
-		nfields++;
-	}
-	/* No subscripting, so all indirection gets added to field list */
-	c->fields = lcons(makeString(colname), indirection);
-	return (PGNode *) c;
-}
-
-static PGNode *
-makeTypeCast(PGNode *arg, PGTypeName *tpname, int trycast, int location)
-{
-	PGTypeCast *n = makeNode(PGTypeCast);
-	n->arg = arg;
-	n->typeName = tpname;
-	n->tryCast = trycast;
-	n->location = location;
-	return (PGNode *) n;
-}
-
-static PGNode *
-makeStringConst(char *str, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGString;
-	n->val.val.str = str;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeStringConstCast(char *str, int location, PGTypeName *tpname)
-{
-	PGNode *s = makeStringConst(str, location);
-
-	return makeTypeCast(s, tpname, 0, -1);
-}
-
-static PGNode *
-makeIntervalNode(char *str, int location, PGList *typmods) {
-	PGIntervalConstant *n = makeNode(PGIntervalConstant);
-
-	n->val_type = T_PGString;
-	n->sval = str;
-	n->location = location;
-	n->typmods = typmods;
-
-	return (PGNode *)n;
-
-}
-
-static PGNode *
-makeIntervalNode(int val, int location, PGList *typmods) {
-	PGIntervalConstant *n = makeNode(PGIntervalConstant);
-
-	n->val_type = T_PGInteger;
-	n->ival = val;
-	n->location = location;
-	n->typmods = typmods;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeIntervalNode(PGNode *arg, int location, PGList *typmods) {
-	PGIntervalConstant *n = makeNode(PGIntervalConstant);
-
-	n->val_type = T_PGAExpr;
-	n->eval = arg;
-	n->location = location;
-	n->typmods = typmods;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeSampleSize(PGNode *sample_size, bool is_percentage) {
-	PGSampleSize *n = makeNode(PGSampleSize);
-
-	n->sample_size = sample_size;
-	n->is_percentage = is_percentage;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeSampleOptions(PGNode *sample_size, char *method, int *seed, int location) {
-	PGSampleOptions *n = makeNode(PGSampleOptions);
-
-	n->sample_size = sample_size;
-	n->method = method;
-	if (seed) {
-		n->has_seed = true;
-		n->seed = *seed;
-	}
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-/* makeLimitPercent()
- * Make limit percent node
- */
-static PGNode *
-makeLimitPercent(PGNode *limit_percent) {
-	PGLimitPercent *n = makeNode(PGLimitPercent);
-
-	n->limit_percent = limit_percent;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeIntConst(int val, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGInteger;
-	n->val.val.ival = val;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeFloatConst(char *str, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGFloat;
-	n->val.val.str = str;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeBitStringConst(char *str, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGBitString;
-	n->val.val.str = str;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeNullAConst(int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGNull;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeAConst(PGValue *v, int location)
-{
-	PGNode *n;
-
-	switch (v->type)
-	{
-		case T_PGFloat:
-			n = makeFloatConst(v->val.str, location);
-			break;
-
-		case T_PGInteger:
-			n = makeIntConst(v->val.ival, location);
-			break;
-
-		case T_PGString:
-		default:
-			n = makeStringConst(v->val.str, location);
-			break;
-	}
-
-	return n;
-}
-
-/* makeBoolAConst()
- * Create an PGAConst string node and put it inside a boolean cast.
- */
-static PGNode *
-makeBoolAConst(bool state, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGString;
-	n->val.val.str = (state ? (char*) "t" : (char*) "f");
-	n->location = location;
-
-	return makeTypeCast((PGNode *)n, SystemTypeName("bool"), 0, -1);
-}
-
-/* check_qualified_name --- check the result of qualified_name production
- *
- * It's easiest to let the grammar production for qualified_name allow
- * subscripts and '*', which we then must reject here.
- */
-static void
-check_qualified_name(PGList *names, core_yyscan_t yyscanner)
-{
-	PGListCell   *i;
-
-	foreach(i, names)
-	{
-		if (!IsA(lfirst(i), PGString))
-			parser_yyerror("syntax error");
-	}
-}
-
-/* check_func_name --- check the result of func_name production
- *
- * It's easiest to let the grammar production for func_name allow subscripts
- * and '*', which we then must reject here.
- */
-static PGList *
-check_func_name(PGList *names, core_yyscan_t yyscanner)
-{
-	PGListCell   *i;
-
-	foreach(i, names)
-	{
-		if (!IsA(lfirst(i), PGString))
-			parser_yyerror("syntax error");
-	}
-	return names;
-}
-
-/* check_indirection --- check the result of indirection production
- *
- * We only allow '*' at the end of the list, but it's hard to enforce that
- * in the grammar, so do it here.
- */
-static PGList *
-check_indirection(PGList *indirection, core_yyscan_t yyscanner)
-{
-	PGListCell *l;
-
-	foreach(l, indirection)
-	{
-		if (IsA(lfirst(l), PGAStar))
-		{
-			if (lnext(l) != NULL)
-				parser_yyerror("improper use of \"*\"");
-		}
-	}
-	return indirection;
-}
-
-/* makeParamRef
- * Creates a new PGParamRef node
- */
-static PGNode* makeParamRef(int number, int location)
-{
-	PGParamRef *p = makeNode(PGParamRef);
-	p->number = number;
-	p->location = location;
-	p->name = NULL;
-	return (PGNode *) p;
-}
-
-/* makeNamedParamRef
- * Creates a new PGParamRef node
- */
-static PGNode* makeNamedParamRef(char *name, int location)
-{
-	PGParamRef *p = (PGParamRef *)makeParamRef(0, location);
-	p->name = name;
-	return (PGNode *) p;
-}
-
-
-/* insertSelectOptions()
- * Insert ORDER BY, etc into an already-constructed SelectStmt.
- *
- * This routine is just to avoid duplicating code in PGSelectStmt productions.
- */
-static void
-insertSelectOptions(PGSelectStmt *stmt,
-					PGList *sortClause, PGList *lockingClause,
-					PGNode *limitOffset, PGNode *limitCount,
-					PGWithClause *withClause,
-					core_yyscan_t yyscanner)
-{
-	if (stmt->type != T_PGSelectStmt) {
-		ereport(ERROR,
-				(errcode(PG_ERRCODE_SYNTAX_ERROR),
-						errmsg("DESCRIBE/SHOW/SUMMARIZE with CTE/ORDER BY/... not allowed - wrap the statement in a subquery instead"),
-						parser_errposition(exprLocation((PGNode *) stmt))));
-	}
-	Assert(IsA(stmt, PGSelectStmt));
-
-	/*
-	 * Tests here are to reject constructs like
-	 *	(SELECT foo ORDER BY bar) ORDER BY baz
-	 */
-	if (sortClause)
-	{
-		if (stmt->sortClause)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple ORDER BY clauses not allowed"),
-					 parser_errposition(exprLocation((PGNode *) sortClause))));
-		stmt->sortClause = sortClause;
-	}
-	/* We can handle multiple locking clauses, though */
-	stmt->lockingClause = list_concat(stmt->lockingClause, lockingClause);
-	if (limitOffset)
-	{
-		if (stmt->limitOffset)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple OFFSET clauses not allowed"),
-					 parser_errposition(exprLocation(limitOffset))));
-		stmt->limitOffset = limitOffset;
-	}
-	if (limitCount)
-	{
-		if (stmt->limitCount)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple LIMIT clauses not allowed"),
-					 parser_errposition(exprLocation(limitCount))));
-		stmt->limitCount = limitCount;
-	}
-	if (withClause)
-	{
-		if (stmt->withClause)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple WITH clauses not allowed"),
-					 parser_errposition(exprLocation((PGNode *) withClause))));
-		stmt->withClause = withClause;
-	}
-}
-
-static PGNode *
-makeSetOp(PGSetOperation op, bool all, PGNode *larg, PGNode *rarg)
-{
-	PGSelectStmt *n = makeNode(PGSelectStmt);
-
-	n->op = op;
-	n->all = all;
-	n->larg = larg;
-	n->rarg = rarg;
-	return (PGNode *) n;
-}
-
-/* SystemFuncName()
- * Build a properly-qualified reference to a built-in function.
- */
-PGList *
-SystemFuncName(const char *name)
-{
-	return list_make2(makeString(DEFAULT_SCHEMA), makeString(name));
-}
-
-/* SystemTypeName()
- * Build a properly-qualified reference to a built-in type.
- *
- * typmod is defaulted, but may be changed afterwards by caller.
- * Likewise for the location.
- */
-PGTypeName *
-SystemTypeName(const char *name)
-{
-	return makeTypeNameFromNameList(list_make1(makeString(name)));
-}
-
-/* doNegate()
- * Handle negation of a numeric constant.
- *
- * Formerly, we did this here because the optimizer couldn't cope with
- * indexquals that looked like "var = -4" --- it wants "var = const"
- * and a unary minus operator applied to a constant didn't qualify.
- * As of Postgres 7.0, that problem doesn't exist anymore because there
- * is a constant-subexpression simplifier in the optimizer.  However,
- * there's still a good reason for doing this here, which is that we can
- * postpone committing to a particular internal representation for simple
- * negative constants.	It's better to leave "-123.456" in string form
- * until we know what the desired type is.
- */
-static PGNode *
-doNegate(PGNode *n, int location)
-{
-	if (IsA(n, PGAConst))
-	{
-		PGAConst *con = (PGAConst *)n;
-
-		/* report the constant's location as that of the '-' sign */
-		con->location = location;
-
-		if (con->val.type == T_PGInteger)
-		{
-			con->val.val.ival = -con->val.val.ival;
-			return n;
-		}
-		if (con->val.type == T_PGFloat)
-		{
-			doNegateFloat(&con->val);
-			return n;
-		}
-	}
-
-	return (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", NULL, n, location);
-}
-
-static void
-doNegateFloat(PGValue *v)
-{
-	char   *oldval = v->val.str;
-
-	Assert(IsA(v, PGFloat));
-	if (*oldval == '+')
-		oldval++;
-	if (*oldval == '-')
-		v->val.str = oldval+1;	/* just strip the '-' */
-	else
-		v->val.str = psprintf("-%s", oldval);
-}
-
-static PGNode *
-makeAndExpr(PGNode *lexpr, PGNode *rexpr, int location)
-{
-	PGNode	   *lexp = lexpr;
-
-	/* Look through AEXPR_PAREN nodes so they don't affect flattening */
-	while (IsA(lexp, PGAExpr) &&
-		   ((PGAExpr *) lexp)->kind == AEXPR_PAREN)
-		lexp = ((PGAExpr *) lexp)->lexpr;
-	/* Flatten "a AND b AND c ..." to a single PGBoolExpr on sight */
-	if (IsA(lexp, PGBoolExpr))
-	{
-		PGBoolExpr *blexpr = (PGBoolExpr *) lexp;
-
-		if (blexpr->boolop == PG_AND_EXPR)
-		{
-			blexpr->args = lappend(blexpr->args, rexpr);
-			return (PGNode *) blexpr;
-		}
-	}
-	return (PGNode *) makeBoolExpr(PG_AND_EXPR, list_make2(lexpr, rexpr), location);
-}
-
-static PGNode *
-makeOrExpr(PGNode *lexpr, PGNode *rexpr, int location)
-{
-	PGNode	   *lexp = lexpr;
-
-	/* Look through AEXPR_PAREN nodes so they don't affect flattening */
-	while (IsA(lexp, PGAExpr) &&
-		   ((PGAExpr *) lexp)->kind == AEXPR_PAREN)
-		lexp = ((PGAExpr *) lexp)->lexpr;
-	/* Flatten "a OR b OR c ..." to a single PGBoolExpr on sight */
-	if (IsA(lexp, PGBoolExpr))
-	{
-		PGBoolExpr *blexpr = (PGBoolExpr *) lexp;
-
-		if (blexpr->boolop == PG_OR_EXPR)
-		{
-			blexpr->args = lappend(blexpr->args, rexpr);
-			return (PGNode *) blexpr;
-		}
-	}
-	return (PGNode *) makeBoolExpr(PG_OR_EXPR, list_make2(lexpr, rexpr), location);
-}
-
-static PGNode *
-makeNotExpr(PGNode *expr, int location)
-{
-	return (PGNode *) makeBoolExpr(PG_NOT_EXPR, list_make1(expr), location);
-}
-
-/* Separate PGConstraint nodes from COLLATE clauses in a */
-static void
-SplitColQualList(PGList *qualList,
-				 PGList **constraintList, PGCollateClause **collClause,
-				 core_yyscan_t yyscanner)
-{
-	PGListCell   *cell;
-	PGListCell   *prev;
-	PGListCell   *next;
-
-	*collClause = NULL;
-	prev = NULL;
-	for (cell = list_head(qualList); cell; cell = next)
-	{
-		PGNode   *n = (PGNode *) lfirst(cell);
-
-		next = lnext(cell);
-		if (IsA(n, PGConstraint))
-		{
-			/* keep it in list */
-			prev = cell;
-			continue;
-		}
-		if (IsA(n, PGCollateClause))
-		{
-			PGCollateClause *c = (PGCollateClause *) n;
-
-			if (*collClause)
-				ereport(ERROR,
-						(errcode(PG_ERRCODE_SYNTAX_ERROR),
-						 errmsg("multiple COLLATE clauses not allowed"),
-						 parser_errposition(c->location)));
-			*collClause = c;
-		}
-		else
-			elog(ERROR, "unexpected node type %d", (int) n->type);
-		/* remove non-Constraint nodes from qualList */
-		qualList = list_delete_cell(qualList, cell, prev);
-	}
-	*constraintList = qualList;
-}
-
-/*
- * Process result of ConstraintAttributeSpec, and set appropriate bool flags
- * in the output command node.  Pass NULL for any flags the particular
- * command doesn't support.
- */
-static void
-processCASbits(int cas_bits, int location, const char *constrType,
-			   bool *deferrable, bool *initdeferred, bool *not_valid,
-			   bool *no_inherit, core_yyscan_t yyscanner)
-{
-	/* defaults */
-	if (deferrable)
-		*deferrable = false;
-	if (initdeferred)
-		*initdeferred = false;
-	if (not_valid)
-		*not_valid = false;
-
-	if (cas_bits & (CAS_DEFERRABLE | CAS_INITIALLY_DEFERRED))
-	{
-		if (deferrable)
-			*deferrable = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked DEFERRABLE",
-							constrType),
-					 parser_errposition(location)));
-	}
-
-	if (cas_bits & CAS_INITIALLY_DEFERRED)
-	{
-		if (initdeferred)
-			*initdeferred = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked DEFERRABLE",
-							constrType),
-					 parser_errposition(location)));
-	}
-
-	if (cas_bits & CAS_NOT_VALID)
-	{
-		if (not_valid)
-			*not_valid = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked NOT VALID",
-							constrType),
-					 parser_errposition(location)));
-	}
-
-	if (cas_bits & CAS_NO_INHERIT)
-	{
-		if (no_inherit)
-			*no_inherit = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked NO INHERIT",
-							constrType),
-					 parser_errposition(location)));
-	}
-}
-
-/*----------
- * Recursive view transformation
- *
- * Convert
- *
- *     CREATE RECURSIVE VIEW relname (aliases) AS query
- *
- * to
- *
- *     CREATE VIEW relname (aliases) AS
- *         WITH RECURSIVE relname (aliases) AS (query)
- *         SELECT aliases FROM relname
- *
- * Actually, just the WITH ... part, which is then inserted into the original
- * view as the query.
- * ----------
- */
-static PGNode *
-makeRecursiveViewSelect(char *relname, PGList *aliases, PGNode *query)
-{
-	PGSelectStmt *s = makeNode(PGSelectStmt);
-	PGWithClause *w = makeNode(PGWithClause);
-	PGCommonTableExpr *cte = makeNode(PGCommonTableExpr);
-	PGList	   *tl = NIL;
-	PGListCell   *lc;
-
-	/* create common table expression */
-	cte->ctename = relname;
-	cte->aliascolnames = aliases;
-	cte->ctequery = query;
-	cte->location = -1;
-
-	/* create WITH clause and attach CTE */
-	w->recursive = true;
-	w->ctes = list_make1(cte);
-	w->location = -1;
-
-	/* create target list for the new SELECT from the alias list of the
-	 * recursive view specification */
-	foreach (lc, aliases)
-	{
-		PGResTarget *rt = makeNode(PGResTarget);
-
-		rt->name = NULL;
-		rt->indirection = NIL;
-		rt->val = makeColumnRef(strVal(lfirst(lc)), NIL, -1, 0);
-		rt->location = -1;
-
-		tl = lappend(tl, rt);
-	}
-
-	/* create new SELECT combining WITH clause, target list, and fake FROM
-	 * clause */
-	s->withClause = w;
-	s->targetList = tl;
-	s->fromClause = list_make1(makeRangeVar(NULL, relname, -1));
-
-	return (PGNode *) s;
-}
-
-/* parser_init()
- * Initialize to parse one query string
- */
-void
-parser_init(base_yy_extra_type *yyext)
-{
-	yyext->parsetree = NIL;		/* in case grammar forgets to set it */
-}
-
-#undef yyparse
-#undef yylex
-#undef yyerror
-#undef yylval
-#undef yychar
-#undef yydebug
-#undef yynerrs
-#undef yylloc
-
-} // namespace duckdb_libpgquery
-
diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_parser.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_parser.cpp
deleted file mode 100644
index d9f9139de..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_parser_parser.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - raw_parser
- * - base_yylex
- * - raw_parser
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * parser.c
- *		Main entry point/driver for PostgreSQL grammar
- *
- * Note that the grammar is not allowed to perform any table access
- * (since we need to be able to do basic parsing even while inside an
- * aborted transaction).  Therefore, the data structures returned by
- * the grammar are "raw" parsetrees that still need to be analyzed by
- * analyze.c and related files.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- *	  src/backend/parser/parser.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include "pg_functions.hpp"
-
-#include "parser/gramparse.hpp"
-#include "parser/parser.hpp"
-#include "parser/kwlist.hpp"
-
-namespace duckdb_libpgquery {
-
-/*
- * raw_parser
- *		Given a query in string form, do lexical and grammatical analysis.
- *
- * Returns a list of raw (un-analyzed) parse trees.  The immediate elements
- * of the list are always PGRawStmt nodes.
- */
-PGList *raw_parser(const char *str) {
-	core_yyscan_t yyscanner;
-	base_yy_extra_type yyextra;
-	int yyresult;
-
-	/* initialize the flex scanner */
-	yyscanner = scanner_init(str, &yyextra.core_yy_extra, ScanKeywords, NumScanKeywords);
-
-	/* base_yylex() only needs this much initialization */
-	yyextra.have_lookahead = false;
-
-	/* initialize the bison parser */
-	parser_init(&yyextra);
-
-	/* Parse! */
-	yyresult = base_yyparse(yyscanner);
-
-	/* Clean up (release memory) */
-	scanner_finish(yyscanner);
-
-	if (yyresult) /* error */
-		return NIL;
-
-	return yyextra.parsetree;
-}
-
-PGKeywordCategory is_keyword(const char *text) {
-	auto keyword = ScanKeywordLookup(text, ScanKeywords, NumScanKeywords);
-	if (keyword) {
-		return static_cast<PGKeywordCategory>(keyword->category);
-	}
-	return PGKeywordCategory::PG_KEYWORD_NONE;
-}
-
-std::vector<PGKeyword> keyword_list() {
-    std::vector<PGKeyword> result;
-	for(size_t i = 0; i < NumScanKeywords; i++) {
-		PGKeyword keyword;
-		keyword.text = ScanKeywords[i].name;
-		switch(ScanKeywords[i].category) {
-		case UNRESERVED_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_UNRESERVED;
-			break;
-		case RESERVED_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_RESERVED;
-			break;
-		case TYPE_FUNC_NAME_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_TYPE_FUNC;
-			break;
-		case COL_NAME_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_COL_NAME;
-			break;
-		}
-		result.push_back(keyword);
-	}
-	return result;
-}
-
-std::vector<PGSimplifiedToken> tokenize(const char *str) {
-	core_yyscan_t yyscanner;
-	base_yy_extra_type yyextra;
-
-	std::vector<PGSimplifiedToken> result;
-	yyscanner = scanner_init(str, &yyextra.core_yy_extra, ScanKeywords, NumScanKeywords);
-	yyextra.have_lookahead = false;
-
-	while(true) {
-		YYSTYPE type;
-		YYLTYPE loc;
-		int token;
-		try {
-			token = base_yylex(&type, &loc, yyscanner);
-		} catch(...) {
-			token = 0;
-		}
-		if (token == 0) {
-			break;
-		}
-		PGSimplifiedToken current_token;
-		switch(token) {
-		case IDENT:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_IDENTIFIER;
-			break;
-		case ICONST:
-		case FCONST:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_NUMERIC_CONSTANT;
-			break;
-		case SCONST:
-		case BCONST:
-		case XCONST:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_STRING_CONSTANT;
-			break;
-		case Op:
-		case PARAM:
-		case COLON_EQUALS:
-		case EQUALS_GREATER:
-		case LESS_EQUALS:
-		case GREATER_EQUALS:
-		case NOT_EQUALS:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_OPERATOR;
-			break;
-		default:
-			if (token >= 255) {
-				// non-ascii value, probably a keyword
-				current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_KEYWORD;
-			} else {
-				// ascii value, probably an operator
-				current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_OPERATOR;
-			}
-			break;
-		}
-		current_token.start = loc;
-		result.push_back(current_token);
-	}
-
-	scanner_finish(yyscanner);
-	return result;
-}
-
-
-
-/*
- * Intermediate filter between parser and core lexer (core_yylex in scan.l).
- *
- * This filter is needed because in some cases the standard SQL grammar
- * requires more than one token lookahead.  We reduce these cases to one-token
- * lookahead by replacing tokens here, in order to keep the grammar LALR(1).
- *
- * Using a filter is simpler than trying to recognize multiword tokens
- * directly in scan.l, because we'd have to allow for comments between the
- * words.  Furthermore it's not clear how to do that without re-introducing
- * scanner backtrack, which would cost more performance than this filter
- * layer does.
- *
- * The filter also provides a convenient place to translate between
- * the core_YYSTYPE and YYSTYPE representations (which are really the
- * same thing anyway, but notationally they're different).
- */
-int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner) {
-	base_yy_extra_type *yyextra = pg_yyget_extra(yyscanner);
-	int cur_token;
-	int next_token;
-	int cur_token_length;
-	YYLTYPE cur_yylloc;
-
-	/* Get next token --- we might already have it */
-	if (yyextra->have_lookahead) {
-		cur_token = yyextra->lookahead_token;
-		lvalp->core_yystype = yyextra->lookahead_yylval;
-		*llocp = yyextra->lookahead_yylloc;
-		*(yyextra->lookahead_end) = yyextra->lookahead_hold_char;
-		yyextra->have_lookahead = false;
-	} else
-		cur_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
-
-	/*
-	 * If this token isn't one that requires lookahead, just return it.  If it
-	 * does, determine the token length.  (We could get that via strlen(), but
-	 * since we have such a small set of possibilities, hardwiring seems
-	 * feasible and more efficient.)
-	 */
-	switch (cur_token) {
-	case NOT:
-		cur_token_length = 3;
-		break;
-	case NULLS_P:
-		cur_token_length = 5;
-		break;
-	case WITH:
-		cur_token_length = 4;
-		break;
-	default:
-		return cur_token;
-	}
-
-	/*
-	 * Identify end+1 of current token.  core_yylex() has temporarily stored a
-	 * '\0' here, and will undo that when we call it again.  We need to redo
-	 * it to fully revert the lookahead call for error reporting purposes.
-	 */
-	yyextra->lookahead_end = yyextra->core_yy_extra.scanbuf + *llocp + cur_token_length;
-	Assert(*(yyextra->lookahead_end) == '\0');
-
-	/*
-	 * Save and restore *llocp around the call.  It might look like we could
-	 * avoid this by just passing &lookahead_yylloc to core_yylex(), but that
-	 * does not work because flex actually holds onto the last-passed pointer
-	 * internally, and will use that for error reporting.  We need any error
-	 * reports to point to the current token, not the next one.
-	 */
-	cur_yylloc = *llocp;
-
-	/* Get next token, saving outputs into lookahead variables */
-	next_token = core_yylex(&(yyextra->lookahead_yylval), llocp, yyscanner);
-	yyextra->lookahead_token = next_token;
-	yyextra->lookahead_yylloc = *llocp;
-
-	*llocp = cur_yylloc;
-
-	/* Now revert the un-truncation of the current token */
-	yyextra->lookahead_hold_char = *(yyextra->lookahead_end);
-	*(yyextra->lookahead_end) = '\0';
-
-	yyextra->have_lookahead = true;
-
-	/* Replace cur_token if needed, based on lookahead */
-	switch (cur_token) {
-	case NOT:
-		/* Replace NOT by NOT_LA if it's followed by BETWEEN, IN, etc */
-		switch (next_token) {
-		case BETWEEN:
-		case IN_P:
-		case LIKE:
-		case ILIKE:
-		case SIMILAR:
-			cur_token = NOT_LA;
-			break;
-		}
-		break;
-
-	case NULLS_P:
-		/* Replace NULLS_P by NULLS_LA if it's followed by FIRST or LAST */
-		switch (next_token) {
-		case FIRST_P:
-		case LAST_P:
-			cur_token = NULLS_LA;
-			break;
-		}
-		break;
-
-	case WITH:
-		/* Replace WITH by WITH_LA if it's followed by TIME or ORDINALITY */
-		switch (next_token) {
-		case TIME:
-		case ORDINALITY:
-			cur_token = WITH_LA;
-			break;
-		}
-		break;
-	}
-
-	return cur_token;
-}
-
-}
diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_scan.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_scan.cpp
deleted file mode 100644
index 378637436..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_parser_scan.cpp
+++ /dev/null
@@ -1,4386 +0,0 @@
-#line 1 "third_party/libpg_query/src_backend_parser_scan.cpp"
-/*-------------------------------------------------------------------------
- *
- * scan.l
- *	  lexical scanner for PostgreSQL
- *
- * NOTE NOTE NOTE:
- *
- * The rules in this file must be kept in sync with src/fe_utils/psqlscan.l!
- *
- * The rules are designed so that the scanner never has to backtrack,
- * in the sense that there is always a rule that can match the input
- * consumed so far (the rule action may internally throw back some input
- * with yyless(), however).  As explained in the flex manual, this makes
- * for a useful speed increase --- about a third faster than a plain -CF
- * lexer, in simple testing.  The extra complexity is mostly in the rules
- * for handling float numbers and continued string literals.  If you change
- * the lexical rules, verify that you haven't broken the no-backtrack '
- * property by running flex with the "-b" option and checking that the
- * resulting "lex.backup" file says that no backing up is needed.  (As of
- * Postgres 9.2, this check is made automatically by the Makefile.)
- *
- *
- * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- *	  src/backend/parser/scan.l
- *
- *-------------------------------------------------------------------------
- */
-#include <ctype.h>
-//#include <unistd.h>
-#include "pg_functions.hpp"
-
-#include "parser/gramparse.hpp"
-#include "parser/parser.hpp"		/* only needed for GUC variables */
-#include "parser/scansup.hpp"
-#include "mb/pg_wchar.hpp"
-
-#include <stdexcept>
-
-#line 43 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-#ifdef yy_create_buffer
-#define core_yy_create_buffer_ALREADY_DEFINED
-#else
-#define yy_create_buffer core_yy_create_buffer
-#endif
-
-#ifdef yy_delete_buffer
-#define core_yy_delete_buffer_ALREADY_DEFINED
-#else
-#define yy_delete_buffer core_yy_delete_buffer
-#endif
-
-#ifdef yy_scan_buffer
-#define core_yy_scan_buffer_ALREADY_DEFINED
-#else
-#define yy_scan_buffer core_yy_scan_buffer
-#endif
-
-#ifdef yy_scan_string
-#define core_yy_scan_string_ALREADY_DEFINED
-#else
-#define yy_scan_string core_yy_scan_string
-#endif
-
-#ifdef yy_scan_bytes
-#define core_yy_scan_bytes_ALREADY_DEFINED
-#else
-#define yy_scan_bytes core_yy_scan_bytes
-#endif
-
-#ifdef yy_init_buffer
-#define core_yy_init_buffer_ALREADY_DEFINED
-#else
-#define yy_init_buffer core_yy_init_buffer
-#endif
-
-#ifdef yy_flush_buffer
-#define core_yy_flush_buffer_ALREADY_DEFINED
-#else
-#define yy_flush_buffer core_yy_flush_buffer
-#endif
-
-#ifdef yy_load_buffer_state
-#define core_yy_load_buffer_state_ALREADY_DEFINED
-#else
-#define yy_load_buffer_state core_yy_load_buffer_state
-#endif
-
-#ifdef yy_switch_to_buffer
-#define core_yy_switch_to_buffer_ALREADY_DEFINED
-#else
-#define yy_switch_to_buffer core_yy_switch_to_buffer
-#endif
-
-#ifdef yypush_buffer_state
-#define core_yypush_buffer_state_ALREADY_DEFINED
-#else
-#define yypush_buffer_state core_yypush_buffer_state
-#endif
-
-#ifdef yypop_buffer_state
-#define core_yypop_buffer_state_ALREADY_DEFINED
-#else
-#define yypop_buffer_state core_yypop_buffer_state
-#endif
-
-#ifdef yyensure_buffer_stack
-#define core_yyensure_buffer_stack_ALREADY_DEFINED
-#else
-#define yyensure_buffer_stack core_yyensure_buffer_stack
-#endif
-
-#ifdef yylex
-#define core_yylex_ALREADY_DEFINED
-#else
-#define yylex core_yylex
-#endif
-
-#ifdef yyrestart
-#define core_yyrestart_ALREADY_DEFINED
-#else
-#define yyrestart core_yyrestart
-#endif
-
-#ifdef yylex_init
-#define core_yylex_init_ALREADY_DEFINED
-#else
-#define yylex_init core_yylex_init
-#endif
-
-#ifdef yylex_init_extra
-#define core_yylex_init_extra_ALREADY_DEFINED
-#else
-#define yylex_init_extra core_yylex_init_extra
-#endif
-
-#ifdef yylex_destroy
-#define core_yylex_destroy_ALREADY_DEFINED
-#else
-#define yylex_destroy core_yylex_destroy
-#endif
-
-#ifdef yyget_debug
-#define core_yyget_debug_ALREADY_DEFINED
-#else
-#define yyget_debug core_yyget_debug
-#endif
-
-#ifdef yyset_debug
-#define core_yyset_debug_ALREADY_DEFINED
-#else
-#define yyset_debug core_yyset_debug
-#endif
-
-#ifdef yyget_extra
-#define core_yyget_extra_ALREADY_DEFINED
-#else
-#define yyget_extra core_yyget_extra
-#endif
-
-#ifdef yyset_extra
-#define core_yyset_extra_ALREADY_DEFINED
-#else
-#define yyset_extra core_yyset_extra
-#endif
-
-#ifdef yyget_in
-#define core_yyget_in_ALREADY_DEFINED
-#else
-#define yyget_in core_yyget_in
-#endif
-
-#ifdef yyset_in
-#define core_yyset_in_ALREADY_DEFINED
-#else
-#define yyset_in core_yyset_in
-#endif
-
-#ifdef yyget_out
-#define core_yyget_out_ALREADY_DEFINED
-#else
-#define yyget_out core_yyget_out
-#endif
-
-#ifdef yyset_out
-#define core_yyset_out_ALREADY_DEFINED
-#else
-#define yyset_out core_yyset_out
-#endif
-
-#ifdef yyget_leng
-#define core_yyget_leng_ALREADY_DEFINED
-#else
-#define yyget_leng core_yyget_leng
-#endif
-
-#ifdef yyget_text
-#define core_yyget_text_ALREADY_DEFINED
-#else
-#define yyget_text core_yyget_text
-#endif
-
-#ifdef yyget_lineno
-#define core_yyget_lineno_ALREADY_DEFINED
-#else
-#define yyget_lineno core_yyget_lineno
-#endif
-
-#ifdef yyset_lineno
-#define core_yyset_lineno_ALREADY_DEFINED
-#else
-#define yyset_lineno core_yyset_lineno
-#endif
-
-#ifdef yyget_column
-#define core_yyget_column_ALREADY_DEFINED
-#else
-#define yyget_column core_yyget_column
-#endif
-
-#ifdef yyset_column
-#define core_yyset_column_ALREADY_DEFINED
-#else
-#define yyset_column core_yyset_column
-#endif
-
-#ifdef yywrap
-#define core_yywrap_ALREADY_DEFINED
-#else
-#define yywrap core_yywrap
-#endif
-
-#ifdef yyget_lval
-#define core_yyget_lval_ALREADY_DEFINED
-#else
-#define yyget_lval core_yyget_lval
-#endif
-
-#ifdef yyset_lval
-#define core_yyset_lval_ALREADY_DEFINED
-#else
-#define yyset_lval core_yyset_lval
-#endif
-
-#ifdef yyget_lloc
-#define core_yyget_lloc_ALREADY_DEFINED
-#else
-#define yyget_lloc core_yyget_lloc
-#endif
-
-#ifdef yyset_lloc
-#define core_yyset_lloc_ALREADY_DEFINED
-#else
-#define yyset_lloc core_yyset_lloc
-#endif
-
-#ifdef yyalloc
-#define core_yyalloc_ALREADY_DEFINED
-#else
-#define yyalloc core_yyalloc
-#endif
-
-#ifdef yyrealloc
-#define core_yyrealloc_ALREADY_DEFINED
-#else
-#define yyrealloc core_yyrealloc
-#endif
-
-#ifdef yyfree
-#define core_yyfree_ALREADY_DEFINED
-#else
-#define yyfree core_yyfree
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-namespace duckdb_libpgquery {
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-typedef uint64_t flex_uint64_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#ifndef SIZE_MAX
-#define SIZE_MAX               (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an
- *   integer in range [0..255] for use as an array index.
- */
-#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN yyg->yy_start = 1 + 2 *
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.  The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START ((yyg->yy_start - 1) / 2)
-#define YYSTATE YY_START
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin , yyscanner )
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-    
-    #define YY_LESS_LINENO(n)
-    #define YY_LINENO_REWIND_TO(ptr)
-    
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		*yy_cp = yyg->yy_hold_char; \
-		YY_RESTORE_YY_MORE_OFFSET \
-		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	yy_size_t yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
-                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
-                          : NULL)
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void yyrestart ( FILE *input_file , yyscan_t yyscanner );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
-void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-void yypop_buffer_state ( yyscan_t yyscanner );
-
-static void yyensure_buffer_stack ( yyscan_t yyscanner );
-static void yy_load_buffer_state ( yyscan_t yyscanner );
-static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
-#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len , yyscan_t yyscanner );
-
-void *yyalloc ( yy_size_t , yyscan_t yyscanner );
-void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
-void yyfree ( void * , yyscan_t yyscanner );
-
-#define yy_new_buffer yy_create_buffer
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){ \
-        yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-	}
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){\
-        yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-	}
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-
-#define core_yywrap(yyscanner) (/*CONSTCOND*/1)
-#define YY_SKIP_YYWRAP
-typedef flex_uint8_t YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
-static int yy_get_next_buffer ( yyscan_t yyscanner );
-static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	yyg->yytext_ptr = yy_bp; \
-	yyleng = (yy_size_t) (yy_cp - yy_bp); \
-	yyg->yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-	yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 84
-#define YY_END_OF_BUFFER 85
-/* This struct is not used in this scanner,
-   but its presence is necessary. */
-struct yy_trans_info
-	{
-	flex_int32_t yy_verify;
-	flex_int32_t yy_nxt;
-	};
-static const flex_int16_t yy_accept[309] =
-    {   0,
-        0,    0,   12,   12,    0,    0,    0,    0,   11,   11,
-        0,    0,    0,    0,    0,    0,    0,    0,   55,   55,
-        0,    0,   28,   28,    0,    0,   85,   83,    1,    1,
-       73,   49,   83,   72,   73,   19,   72,   72,   72,   72,
-       72,   76,   72,   72,   72,   72,   83,   82,   82,   82,
-       82,   82,   82,   12,    9,    5,    5,    6,    6,   58,
-       51,   11,   16,   32,   32,   22,   42,   31,   22,   46,
-       46,   48,   52,   54,   53,   53,   54,   54,   24,   27,
-       26,   26,   27,   27,   35,   36,   35,    1,   73,   71,
-       43,   74,   44,   65,    1,   63,   61,   77,    2,   66,
-
-       77,   76,   80,    0,   60,   62,   68,   70,   67,   69,
-       75,   82,    8,   20,   18,   59,   15,   12,    9,    9,
-       10,    5,    7,    4,    3,   58,   57,   11,   16,   16,
-       17,   32,   22,   22,   30,   23,   38,   39,   37,   37,
-       38,   31,   46,   45,   47,   53,   53,   55,   24,   24,
-       25,   26,   26,   28,   37,   37,   74,    0,   44,    1,
-        1,   64,   77,    0,    2,   78,   77,   81,   79,   76,
-       75,    0,   50,   21,    9,   14,   10,    9,    3,   16,
-       13,   17,   16,   22,   41,   23,   22,   39,   37,   37,
-       40,   47,   53,   55,   24,   25,   24,   26,   28,   37,
-
-       37,   77,    0,   79,    0,    9,    9,    9,    9,   16,
-       16,   16,   16,   22,   22,   22,   22,   39,   37,   37,
-       40,   55,   24,   24,   24,   24,   28,   37,   37,    9,
-        9,    9,    9,    9,   16,   16,   16,   16,   16,   22,
-       22,   22,   22,   22,   37,   37,   55,   24,   24,   24,
-       24,   24,   28,   37,   37,    9,   16,   22,   37,   33,
-       55,   24,   28,   37,   34,   37,   55,   28,   37,   37,
-       55,   55,   55,   28,   28,   28,   37,   37,   55,   55,
-       28,   28,   37,   56,   55,   55,   55,   55,   29,   28,
-       28,   28,   28,   55,   55,   55,   55,   55,   28,   28,
-
-       28,   28,   28,   55,   55,   28,   28,    0
-    } ;
-
-static const YY_CHAR yy_ec[256] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        1,    2,    4,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    5,    6,    1,    7,    8,    9,   10,   11,
-       11,   12,   13,   11,   14,   15,   16,   17,   17,   17,
-       17,   17,   17,   17,   17,   18,   18,   19,   11,   20,
-       21,   22,   23,   24,   25,   26,   27,   28,   29,   28,
-       30,   30,   30,   30,   30,   30,   30,   31,   30,   32,
-       30,   30,   33,   30,   34,   30,   30,   35,   30,   30,
-       11,   36,   11,    8,   37,   24,   25,   26,   27,   28,
-
-       29,   28,   30,   30,   30,   30,   30,   30,   30,   31,
-       30,   32,   30,   30,   33,   30,   38,   30,   30,   39,
-       30,   30,    1,   24,    1,   24,    1,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30
-    } ;
-
-static const YY_CHAR yy_meta[40] =
-    {   0,
-        1,    1,    2,    2,    3,    4,    5,    3,    3,    6,
-        1,    7,    3,    3,    1,    7,    8,    8,    1,    3,
-        3,    3,    1,    3,    9,    9,    9,    9,    9,   10,
-       10,   10,   10,   10,   10,   11,   10,   10,   10
-    } ;
-
-static const flex_int16_t yy_base[376] =
-    {   0,
-        0,    0,  486,  484,   35,   55,  483,  475,  466,  465,
-       42,   51,  458,  450,   39,   55,  449,  448,   86,  123,
-      442,  437,  160,  197,   38,   47,  439, 1250,   78,   82,
-      413, 1250,   84,    0,    0, 1250, 1250,  421,   51,   77,
-       54,   81,   84,   85,  409,  405,   91,    0,  408,  403,
-      402,  401,  395,    0,  109,    0,    0,   81,  385,    0,
-      386,    0,  126,    0,    0,  129,  117,    0,  144,    0,
-        0,  384,  370, 1250,  112,  163,  361,  338,  166, 1250,
-      169,  175,  348,  326, 1250, 1250,   83,  179,    0,    0,
-     1250,  167,  342,    0,  231,  325, 1250,  173,    0,    0,
-
-      178,  188,  195,  118, 1250, 1250,    0,    0,    0,    0,
-      197,    0, 1250, 1250, 1250,  132, 1250,    0,  216,  219,
-      332,    0,  129, 1250,    0,    0, 1250,    0,  224,  246,
-      326,    0,  255,  260, 1250,  325, 1250,  297,    0,    0,
-        0,    0,    0, 1250,  297,  184,    0,  269,  263,  269,
-      284,  278,    0,  263,    0,    0,  224,  132,  287,    0,
-      279,    0,  268,  135,    0, 1250,  289,  142,  272,  293,
-      295,  258, 1250, 1250,  313, 1250,  264,  317,    0,  331,
-     1250,  254,  334,  340, 1250,  240,  349,  229,    0,    0,
-        0,  230,    0,  205,  354,  210,  357,    0,  189,    0,
-
-        0,  348,  307,  352,  311,  370,  376,  379,  384,  392,
-      397,  400,  405,  413,  418,  421,  426, 1250,    0,    0,
-     1250,  172,  434,  439,  442,  447,  167,    0,    0,  455,
-      460,  463,  468,  476,  481,  484,  489,  498,  502,  505,
-      511,  518,  527,  531,    0,    0,  157,  534,  540,  547,
-      556,  560,  143,    0,    0,  563,  569,  576,    0, 1250,
-      115,  582,   93,    0, 1250,    0,  585,  590,    0,    0,
-      599,    0,  105,  604,    0,   90,    0,    0,   62,  613,
-       43,  618,    0, 1250,  627,  632,  641,  646, 1250,  655,
-      660,  669,  674,  683,  688,  697,  702,  711,  716,  725,
-
-      730,  739,  744,  753,    0,  758,    0, 1250,  772,  783,
-      794,  805,  816,  827,  838,  849,  860,  871,  880,  883,
-      889,  899,  910,  921,  932,  943,  953,  964,  975,  982,
-      988,  998, 1007, 1012, 1012, 1014, 1016, 1021, 1031, 1042,
-     1046, 1048, 1057, 1068, 1079, 1083, 1085, 1087, 1096, 1100,
-     1102, 1111, 1122, 1133, 1137, 1139, 1148, 1152, 1154, 1156,
-     1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1181, 1192,
-     1196, 1205, 1216, 1227, 1238
-    } ;
-
-static const flex_int16_t yy_def[376] =
-    {   0,
-      308,    1,  309,  309,  310,  310,  311,  311,  312,  312,
-      313,  313,  314,  314,  315,  315,  311,  311,  316,  316,
-      314,  314,  317,  317,  318,  318,  308,  308,  308,  308,
-      319,  308,  320,  319,  319,  308,  308,  319,  319,  308,
-      319,  308,  308,  319,  319,  319,  308,  321,  321,  321,
-      321,  321,  321,  322,  308,  323,  323,  308,  308,  324,
-      308,  325,  308,  326,  326,  308,  327,  328,  308,  329,
-      329,  330,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  319,  319,
-      308,  308,  331,  319,  332,  319,  308,  308,  333,  319,
-
-      308,  308,  308,  308,  308,  308,  319,  319,  319,  319,
-      308,  321,  308,  308,  308,  308,  308,  322,  308,  308,
-      308,  323,  308,  308,  334,  324,  308,  325,  308,  308,
-      308,  326,  308,  308,  308,  308,  308,  308,  335,  336,
-      337,  328,  329,  308,  338,  308,  339,  308,  308,  308,
-      308,  308,  340,  308,  341,  342,  308,  308,  331,  332,
-      332,  319,  308,  308,  333,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  343,  334,  308,
-      308,  308,  344,  308,  308,  308,  345,  308,  346,  347,
-      348,  338,  339,  308,  308,  308,  349,  340,  308,  350,
-
-      351,  308,  308,  308,  308,  352,  343,  343,  343,  353,
-      344,  344,  344,  354,  345,  345,  345,  308,  355,  356,
-      308,  308,  357,  349,  349,  349,  308,  358,  359,  352,
-      352,  308,  352,  343,  353,  353,  308,  353,  344,  354,
-      354,  308,  354,  345,  360,  361,  308,  357,  357,  308,
-      357,  349,  308,  362,  363,  352,  353,  354,  364,  308,
-      308,  357,  308,  365,  308,  366,  308,  308,  367,  368,
-      308,  369,  308,  308,  370,  308,  371,  361,  308,  372,
-      308,  373,  363,  308,  372,  372,  374,  372,  308,  373,
-      373,  375,  373,  372,  372,  308,  372,  372,  373,  373,
-
-      308,  373,  373,  374,  369,  375,  370,    0,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308
-    } ;
-
-static const flex_int16_t yy_nxt[1290] =
-    {   0,
-       28,   29,   30,   29,   31,   32,   33,   34,   35,   36,
-       37,   38,   34,   39,   40,   41,   42,   42,   43,   44,
-       45,   46,   47,   35,   48,   49,   48,   48,   50,   48,
-       51,   48,   48,   52,   53,   28,   48,   52,   53,   57,
-       86,   71,   57,   57,   65,   72,   58,   57,   57,   86,
-       59,   66,  289,   65,   57,   57,   57,   71,   57,   57,
-       66,   72,   57,   57,   95,   99,   58,   57,   57,  100,
-       59,  284,   96,   87,   57,   57,   57,   67,   57,   88,
-       88,   88,   87,   88,   88,   88,   67,   75,   76,   75,
-       91,   97,  123,   98,   98,  101,  124,  102,  102,   77,
-
-       92,   92,  105,  282,  106,  107,  108,  111,  111,  103,
-      119,  120,  120,  146,  146,  146,  155,  104,  280,   78,
-      156,  268,  121,   78,   75,   76,   75,  129,  130,  130,
-      133,  134,  134,  138,  170,  170,   77,  173,  135,  131,
-      123,  174,  136,  267,  124,  133,  134,  134,  157,  157,
-      139,  163,  163,  135,  140,  141,   78,  136,  169,  169,
-       78,   81,   82,   81,  146,  146,  146,  149,  150,  150,
-      152,  152,  152,   83,  263,  135,  152,  152,  152,  151,
-       88,   88,   88,  157,  157,  146,  146,  146,  261,  163,
-      163,  253,  166,   84,  167,  167,  247,   84,   81,   82,
-
-       81,  103,  101,  158,  102,  102,  103,  168,  168,  164,
-       83,  169,  169,  171,  171,  227,  103,  119,  120,  120,
-      175,  175,  175,  223,  104,  129,  130,  130,  176,  121,
-       84,  222,  177,  172,   84,  161,  144,  131,  161,  161,
-      157,  157,  161,  161,  161,  218,  161,  180,  180,  180,
-      161,  161,  161,  214,  161,  181,  133,  134,  134,  182,
-      158,  184,  184,  184,  149,  150,  150,  210,  136,  185,
-      195,  195,  195,  186,  171,  171,  151,  206,  185,  152,
-      152,  152,  196,  161,  163,  163,  161,  161,  204,  204,
-      161,  161,  161,   91,  161,  199,  103,  197,  161,  161,
-
-      161,  194,  161,  144,  164,  202,  202,  101,  205,  102,
-      102,  171,  171,  188,  175,  175,  175,  103,  208,  120,
-      120,  103,  176,  202,  202,  203,  177,  204,  204,  104,
-      209,  172,  180,  180,  180,  212,  130,  130,  187,  183,
-      181,  184,  184,  184,  182,  178,  162,  213,   91,  185,
-      216,  134,  134,  186,  154,  195,  195,  195,  225,  150,
-      150,  153,  217,  185,  202,  202,  148,  196,  204,  204,
-      226,  231,  232,  232,  147,  127,  103,  208,  120,  120,
-      208,  120,  120,  233,  203,  208,  120,  120,  205,  209,
-      144,  127,  209,  236,  237,  237,  125,  234,  212,  130,
-
-      130,  212,  130,  130,  117,  238,  212,  130,  130,  116,
-      213,  115,  114,  213,  241,  242,  242,  113,  239,  216,
-      134,  134,  216,  134,  134,  110,  243,  216,  134,  134,
-      109,  217,   94,   90,  217,  249,  250,  250,  308,  244,
-      225,  150,  150,  225,  150,  150,   79,  251,  225,  150,
-      150,   79,  226,   73,   73,  226,  231,  232,  232,   69,
-      252,  231,  232,  232,  175,  175,  175,   69,  233,  231,
-      232,  232,  176,  233,   63,   63,  177,  208,  120,  120,
-       61,  256,  236,  237,  237,  236,  237,  237,   61,  234,
-      180,  180,  180,   55,  238,   55,  308,  238,  181,  236,
-
-      237,  237,  182,  212,  130,  130,  241,  242,  242,  308,
-      308,  257,  241,  242,  242,  239,  308,  308,  243,  184,
-      184,  184,  308,  308,  243,  308,  308,  185,  241,  242,
-      242,  186,  216,  134,  134,  249,  250,  250,  308,  308,
-      258,  249,  250,  250,  244,  308,  308,  251,  195,  195,
-      195,  308,  308,  251,  308,  308,  185,  249,  250,  250,
-      196,  225,  150,  150,  231,  232,  232,  308,  308,  262,
-      236,  237,  237,  252,  308,  308,  256,  241,  242,  242,
-      308,  308,  257,  249,  250,  250,  271,  271,  271,  258,
-      308,  274,  274,  274,  272,  262,  308,  308,  273,  275,
-
-      271,  271,  271,  276,  308,  274,  274,  274,  272,  308,
-      308,  308,  273,  275,  286,  271,  271,  276,  308,  291,
-      274,  274,  287,  308,  308,  308,  288,  292,  286,  271,
-      271,  293,  308,  286,  271,  271,  287,  308,  308,  308,
-      288,  287,  295,  296,  296,  288,  308,  286,  271,  271,
-      287,  308,  308,  308,  297,  287,  291,  274,  274,  298,
-      308,  291,  274,  274,  292,  308,  308,  308,  293,  292,
-      300,  301,  301,  293,  308,  291,  274,  274,  292,  308,
-      308,  308,  302,  292,  286,  271,  271,  303,  308,  286,
-      271,  271,  304,  308,  308,  308,  288,  304,  271,  271,
-
-      271,  288,  308,  286,  271,  271,  305,  308,  308,  308,
-      273,  304,  286,  271,  271,  298,  308,  291,  274,  274,
-      287,  308,  308,  308,  298,  306,  291,  274,  274,  293,
-      308,  274,  274,  274,  306,  308,  308,  308,  293,  307,
-      291,  274,  274,  276,  308,  291,  274,  274,  306,  308,
-      308,  308,  303,  292,  295,  296,  296,  303,  308,  300,
-      301,  301,  287,  308,  308,  308,  297,  292,  308,  308,
-      308,  302,   54,   54,   54,   54,   54,   54,   54,   54,
-       54,   54,   54,   56,   56,   56,   56,   56,   56,   56,
-       56,   56,   56,   56,   60,   60,   60,   60,   60,   60,
-
-       60,   60,   60,   60,   60,   62,   62,   62,   62,   62,
-       62,   62,   62,   62,   62,   62,   64,   64,   64,   64,
-       64,   64,   64,   64,   64,   64,   64,   68,   68,   68,
-       68,   68,   68,   68,   68,   68,   68,   68,   70,   70,
-       70,   70,   70,   70,   70,   70,   70,   70,   70,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
-       80,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   89,  308,  308,  308,   89,   93,  308,  308,
-       93,   93,   93,  112,  308,  308,  112,  112,  112,  118,
-
-      118,  118,  118,  118,  308,  118,  118,  118,  118,  118,
-      122,  122,  122,  122,  122,  122,  308,  122,  122,  122,
-      122,  126,  126,  126,  308,  126,  126,  126,  126,  126,
-      126,  126,  128,  128,  128,  128,  128,  308,  128,  128,
-      128,  128,  128,  132,  132,  132,  132,  132,  308,  132,
-      132,  132,  132,  137,  137,  137,  137,  137,  137,  137,
-      137,  137,  137,  137,  142,  142,  142,  142,  142,  308,
-      142,  142,  142,  142,  142,  143,  143,  143,  143,  308,
-      143,  143,  143,  143,  143,  143,  145,  308,  308,  308,
-      145,  145,  159,  308,  308,  159,  159,  159,  160,  308,
-
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  165,
-      308,  308,  308,  165,  179,  308,  308,  308,  179,  189,
-      189,  190,  190,  191,  191,  192,  308,  308,  192,  192,
-      192,  193,  308,  193,  193,  193,  193,  193,  193,  193,
-      193,  193,  198,  308,  198,  198,  198,  198,  198,  198,
-      198,  198,  198,  200,  200,  201,  201,  207,  207,  207,
-      207,  207,  207,  207,  207,  207,  207,  207,  211,  211,
-      211,  211,  211,  211,  211,  211,  211,  211,  211,  215,
-      215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
-      219,  219,  220,  220,  221,  221,  224,  224,  224,  224,
-
-      224,  224,  224,  224,  224,  224,  224,  228,  228,  229,
-      229,  230,  230,  230,  230,  230,  230,  230,  230,  230,
-      230,  230,  235,  235,  235,  235,  235,  235,  235,  235,
-      235,  235,  235,  240,  240,  240,  240,  240,  240,  240,
-      240,  240,  240,  240,  245,  245,  246,  246,  248,  248,
-      248,  248,  248,  248,  248,  248,  248,  248,  248,  254,
-      254,  255,  255,  259,  259,  260,  260,  264,  264,  265,
-      265,  266,  266,  269,  269,  270,  270,  277,  277,  278,
-      278,  279,  279,  279,  279,  279,  308,  279,  279,  279,
-      279,  279,  281,  281,  281,  281,  281,  308,  281,  281,
-
-      281,  281,  281,  283,  283,  285,  285,  285,  285,  285,
-      285,  285,  285,  285,  285,  285,  290,  290,  290,  290,
-      290,  290,  290,  290,  290,  290,  290,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  299,  299,
-      299,  299,  299,  299,  299,  299,  299,  299,  299,   27,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308
-    } ;
-
-static const flex_int16_t yy_chk[1290] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    5,
-       25,   15,    5,    5,   11,   15,    5,    5,    5,   26,
-        5,   11,  281,   12,    5,    5,    5,   16,    5,    6,
-       12,   16,    6,    6,   39,   41,    6,    6,    6,   41,
-        6,  279,   39,   25,    6,    6,    6,   11,    6,   29,
-       29,   29,   26,   30,   30,   30,   12,   19,   19,   19,
-       33,   40,   58,   40,   40,   42,   58,   42,   42,   19,
-
-       33,   33,   43,  276,   43,   44,   44,   47,   47,   42,
-       55,   55,   55,   75,   75,   75,   87,   42,  273,   19,
-       87,  263,   55,   19,   20,   20,   20,   63,   63,   63,
-       66,   66,   66,   67,  104,  104,   20,  116,   66,   63,
-      123,  116,   66,  261,  123,   69,   69,   69,  158,  158,
-       67,  164,  164,   69,   67,   67,   20,   69,  168,  168,
-       20,   23,   23,   23,   76,   76,   76,   79,   79,   79,
-       81,   81,   81,   23,  253,   79,   82,   82,   82,   79,
-       88,   88,   88,   92,   92,  146,  146,  146,  247,   98,
-       98,  227,  101,   23,  101,  101,  222,   23,   24,   24,
-
-       24,   98,  102,   92,  102,  102,  101,  103,  103,   98,
-       24,  103,  103,  111,  111,  199,  102,  119,  119,  119,
-      120,  120,  120,  196,  102,  129,  129,  129,  120,  119,
-       24,  194,  120,  111,   24,   95,  192,  129,   95,   95,
-      157,  157,   95,   95,   95,  188,   95,  130,  130,  130,
-       95,   95,   95,  186,   95,  130,  133,  133,  133,  130,
-      157,  134,  134,  134,  149,  149,  149,  182,  133,  134,
-      150,  150,  150,  134,  172,  172,  149,  177,  150,  152,
-      152,  152,  150,  161,  163,  163,  161,  161,  169,  169,
-      161,  161,  161,  159,  161,  154,  163,  151,  161,  161,
-
-      161,  148,  161,  145,  163,  167,  167,  170,  169,  170,
-      170,  171,  171,  138,  175,  175,  175,  167,  178,  178,
-      178,  170,  175,  203,  203,  167,  175,  205,  205,  170,
-      178,  171,  180,  180,  180,  183,  183,  183,  136,  131,
-      180,  184,  184,  184,  180,  121,   96,  183,   93,  184,
-      187,  187,  187,  184,   84,  195,  195,  195,  197,  197,
-      197,   83,  187,  195,  202,  202,   78,  195,  204,  204,
-      197,  206,  206,  206,   77,   73,  202,  207,  207,  207,
-      208,  208,  208,  206,  202,  209,  209,  209,  204,  207,
-       72,   61,  208,  210,  210,  210,   59,  209,  211,  211,
-
-      211,  212,  212,  212,   53,  210,  213,  213,  213,   52,
-      211,   51,   50,  212,  214,  214,  214,   49,  213,  215,
-      215,  215,  216,  216,  216,   46,  214,  217,  217,  217,
-       45,  215,   38,   31,  216,  223,  223,  223,   27,  217,
-      224,  224,  224,  225,  225,  225,   22,  223,  226,  226,
-      226,   21,  224,   18,   17,  225,  230,  230,  230,   14,
-      226,  231,  231,  231,  232,  232,  232,   13,  230,  233,
-      233,  233,  232,  231,   10,    9,  232,  234,  234,  234,
-        8,  233,  235,  235,  235,  236,  236,  236,    7,  234,
-      237,  237,  237,    4,  235,    3,    0,  236,  237,  238,
-
-      238,  238,  237,  239,  239,  239,  240,  240,  240,    0,
-        0,  238,  241,  241,  241,  239,    0,    0,  240,  242,
-      242,  242,    0,    0,  241,    0,    0,  242,  243,  243,
-      243,  242,  244,  244,  244,  248,  248,  248,    0,    0,
-      243,  249,  249,  249,  244,    0,    0,  248,  250,  250,
-      250,    0,    0,  249,    0,    0,  250,  251,  251,  251,
-      250,  252,  252,  252,  256,  256,  256,    0,    0,  251,
-      257,  257,  257,  252,    0,    0,  256,  258,  258,  258,
-        0,    0,  257,  262,  262,  262,  267,  267,  267,  258,
-        0,  268,  268,  268,  267,  262,    0,    0,  267,  268,
-
-      271,  271,  271,  268,    0,  274,  274,  274,  271,    0,
-        0,    0,  271,  274,  280,  280,  280,  274,    0,  282,
-      282,  282,  280,    0,    0,    0,  280,  282,  285,  285,
-      285,  282,    0,  286,  286,  286,  285,    0,    0,    0,
-      285,  286,  287,  287,  287,  286,    0,  288,  288,  288,
-      287,    0,    0,    0,  287,  288,  290,  290,  290,  288,
-        0,  291,  291,  291,  290,    0,    0,    0,  290,  291,
-      292,  292,  292,  291,    0,  293,  293,  293,  292,    0,
-        0,    0,  292,  293,  294,  294,  294,  293,    0,  295,
-      295,  295,  294,    0,    0,    0,  294,  295,  296,  296,
-
-      296,  295,    0,  297,  297,  297,  296,    0,    0,    0,
-      296,  297,  298,  298,  298,  297,    0,  299,  299,  299,
-      298,    0,    0,    0,  298,  299,  300,  300,  300,  299,
-        0,  301,  301,  301,  300,    0,    0,    0,  300,  301,
-      302,  302,  302,  301,    0,  303,  303,  303,  302,    0,
-        0,    0,  302,  303,  304,  304,  304,  303,    0,  306,
-      306,  306,  304,    0,    0,    0,  304,  306,    0,    0,
-        0,  306,  309,  309,  309,  309,  309,  309,  309,  309,
-      309,  309,  309,  310,  310,  310,  310,  310,  310,  310,
-      310,  310,  310,  310,  311,  311,  311,  311,  311,  311,
-
-      311,  311,  311,  311,  311,  312,  312,  312,  312,  312,
-      312,  312,  312,  312,  312,  312,  313,  313,  313,  313,
-      313,  313,  313,  313,  313,  313,  313,  314,  314,  314,
-      314,  314,  314,  314,  314,  314,  314,  314,  315,  315,
-      315,  315,  315,  315,  315,  315,  315,  315,  315,  316,
-      316,  316,  316,  316,  316,  316,  316,  316,  316,  316,
-      317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
-      317,  318,  318,  318,  318,  318,  318,  318,  318,  318,
-      318,  318,  319,    0,    0,    0,  319,  320,    0,    0,
-      320,  320,  320,  321,    0,    0,  321,  321,  321,  322,
-
-      322,  322,  322,  322,    0,  322,  322,  322,  322,  322,
-      323,  323,  323,  323,  323,  323,    0,  323,  323,  323,
-      323,  324,  324,  324,    0,  324,  324,  324,  324,  324,
-      324,  324,  325,  325,  325,  325,  325,    0,  325,  325,
-      325,  325,  325,  326,  326,  326,  326,  326,    0,  326,
-      326,  326,  326,  327,  327,  327,  327,  327,  327,  327,
-      327,  327,  327,  327,  328,  328,  328,  328,  328,    0,
-      328,  328,  328,  328,  328,  329,  329,  329,  329,    0,
-      329,  329,  329,  329,  329,  329,  330,    0,    0,    0,
-      330,  330,  331,    0,    0,  331,  331,  331,  332,    0,
-
-      332,  332,  332,  332,  332,  332,  332,  332,  332,  333,
-        0,    0,    0,  333,  334,    0,    0,    0,  334,  335,
-      335,  336,  336,  337,  337,  338,    0,    0,  338,  338,
-      338,  339,    0,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  340,    0,  340,  340,  340,  340,  340,  340,
-      340,  340,  340,  341,  341,  342,  342,  343,  343,  343,
-      343,  343,  343,  343,  343,  343,  343,  343,  344,  344,
-      344,  344,  344,  344,  344,  344,  344,  344,  344,  345,
-      345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-      346,  346,  347,  347,  348,  348,  349,  349,  349,  349,
-
-      349,  349,  349,  349,  349,  349,  349,  350,  350,  351,
-      351,  352,  352,  352,  352,  352,  352,  352,  352,  352,
-      352,  352,  353,  353,  353,  353,  353,  353,  353,  353,
-      353,  353,  353,  354,  354,  354,  354,  354,  354,  354,
-      354,  354,  354,  354,  355,  355,  356,  356,  357,  357,
-      357,  357,  357,  357,  357,  357,  357,  357,  357,  358,
-      358,  359,  359,  360,  360,  361,  361,  362,  362,  363,
-      363,  364,  364,  365,  365,  366,  366,  367,  367,  368,
-      368,  369,  369,  369,  369,  369,    0,  369,  369,  369,
-      369,  369,  370,  370,  370,  370,  370,    0,  370,  370,
-
-      370,  370,  370,  371,  371,  372,  372,  372,  372,  372,
-      372,  372,  372,  372,  372,  372,  373,  373,  373,  373,
-      373,  373,  373,  373,  373,  373,  373,  374,  374,  374,
-      374,  374,  374,  374,  374,  374,  374,  374,  375,  375,
-      375,  375,  375,  375,  375,  375,  375,  375,  375,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
-      308,  308,  308,  308,  308,  308,  308,  308,  308
-    } ;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "third_party/libpg_query/scan.l"
-
-#line 46 "third_party/libpg_query/scan.l"
-
-/* LCOV_EXCL_START */
-
-/*
- * GUC variables.  This is a DIRECT violation of the warning given at the
- * head of gram.y, ie flex/bison code must not depend on any GUC variables;
- * as such, changing their values can induce very unintuitive behavior.
- * But we shall have to live with it until we can remove these variables.
- */
-
-int			backslash_quote = PG_BACKSLASH_QUOTE_SAFE_ENCODING;
-bool		escape_string_warning = true;
-bool		standard_conforming_strings = true;
-
-/*
- * Set the type of YYSTYPE.
- */
-#define YYSTYPE core_YYSTYPE
-
-/*
- * Set the type of yyextra.  All state variables used by the scanner should
- * be in yyextra, *not* statically allocated.
- */
-#define YY_EXTRA_TYPE core_yy_extra_type *
-
-/*
- * Each call to yylex must set yylloc to the location of the found token
- * (expressed as a byte offset from the start of the input text).
- * When we parse a token that requires multiple lexer rules to process,
- * this should be done in the first such rule, else yylloc will point
- * into the middle of the token.
- */
-#define SET_YYLLOC()  (*(yylloc) = yytext - yyextra->scanbuf)
-
-/*
- * Advance yylloc by the given number of bytes.
- */
-#define ADVANCE_YYLLOC(delta)  ( *(yylloc) += (delta) )
-
-#define startlit()	( yyextra->literallen = 0 )
-static void addlit(char *ytext, int yleng, core_yyscan_t yyscanner);
-static void addlitchar(unsigned char ychar, core_yyscan_t yyscanner);
-static char *litbufdup(core_yyscan_t yyscanner);
-static char *litbuf_udeescape(unsigned char escape, core_yyscan_t yyscanner);
-static unsigned char unescape_single_char(unsigned char c, core_yyscan_t yyscanner);
-static int	process_integer_literal(const char *token, YYSTYPE *lval);
-static bool is_utf16_surrogate_first(pg_wchar c);
-static bool is_utf16_surrogate_second(pg_wchar c);
-static pg_wchar surrogate_pair_to_codepoint(pg_wchar first, pg_wchar second);
-static void addunicode(pg_wchar c, yyscan_t yyscanner);
-static bool check_uescapechar(unsigned char escape);
-
-#define yyerror(msg)  scanner_yyerror(msg, yyscanner)
-
-#define lexer_errposition()  scanner_errposition(*(yylloc), yyscanner)
-
-static void check_string_escape_warning(unsigned char ychar, core_yyscan_t yyscanner);
-static void check_escape_warning(core_yyscan_t yyscanner);
-
-/*
- * Work around a bug in flex 2.5.35: it emits a couple of functions that
- * it forgets to emit declarations for.  Since we use -Wmissing-prototypes,
- * this would cause warnings.  Providing our own declarations should be
- * harmless even when the bug gets fixed.
- */
-extern int	core_yyget_column(yyscan_t yyscanner);
-extern void core_yyset_column(int column_no, yyscan_t yyscanner);
-
-#line 1162 "third_party/libpg_query/src_backend_parser_scan.cpp"
-#define YY_NO_INPUT 1
-/*
- * OK, here is a short description of lex/flex rules behavior.
- * The longest pattern which matches an input string is always chosen.
- * For equal-length patterns, the first occurring in the rules list is chosen.
- * INITIAL is the starting state, to which all non-conditional rules apply.
- * Exclusive states change parsing rules while the state is active.  When in
- * an exclusive state, only those rules defined for that state apply.
- *
- * We use exclusive states for quoted strings, extended comments,
- * and to eliminate parsing troubles for numeric strings.
- * Exclusive states:
- *  <xb> bit string literal
- *  <xc> extended C-style comments
- *  <xd> delimited identifiers (double-quoted identifiers)
- *  <xh> hexadecimal numeric string
- *  <xq> standard quoted strings
- *  <xe> extended quoted strings (support backslash escape sequences)
- *  <xdolq> $foo$ quoted strings
- *  <xui> quoted identifier with Unicode escapes
- *  <xuiend> end of a quoted identifier with Unicode escapes, UESCAPE can follow
- *  <xus> quoted string with Unicode escapes
- *  <xusend> end of a quoted string with Unicode escapes, UESCAPE can follow
- *  <xeu> Unicode surrogate pair in extended quoted string
- *
- * Remember to add an <<EOF>> case whenever you add a new exclusive state!
- * The default one is probably not the right thing.
- */
-
-/*
- * In order to make the world safe for Windows and Mac clients as well as
- * Unix ones, we accept either \n or \r as a newline.  A DOS-style \r\n
- * sequence will be seen as two successive newlines, but that doesn't cause '
- * any problems.  Comments that start with -- and extend to the next
- * newline are treated as equivalent to a single whitespace character.
- *
- * NOTE a fine point: if there is no newline following --, we will absorb
- * everything to the end of the input as a comment.  This is correct.  Older
- * versions of Postgres failed to recognize -- as a comment if the input
- * did not end with a newline.
- *
- * XXX perhaps \f (formfeed) should be treated as a newline as well?
- *
- * XXX if you change the set of whitespace characters, fix scanner_isspace()
- * to agree, and see also the plpgsql lexer.
- */
-/*
- * SQL requires at least one newline in the whitespace separating
- * string literals that are to be concatenated.  Silly, but who are we
- * to argue?  Note that {whitespace_with_newline} should not have * after
- * it, whereas {whitespace} should generally have a * after it...
- */
-/*
- * To ensure that {quotecontinue} can be scanned without having to back up
- * if the full pattern isn't matched, we include trailing whitespace in
- * {quotestop}.  This matches all cases where {quotecontinue} fails to match,
- * except for {quote} followed by whitespace and just one "-" (not two,
- * which would start a {comment}).  To cover that we have {quotefail}.
- * The actions for {quotestop} and {quotefail} must throw back characters
- * beyond the quote proper.
- */
-/* Bit string
- * It is tempting to scan the string for only those characters
- * which are allowed. However, this leads to silently swallowed
- * characters if illegal characters are included in the string.
- * For example, if xbinside is [01] then B'ABCD' is interpreted
- * as a zero-length string, and the ABCD' is lost!
- * Better to pass the string forward and let the input routines
- * validate the contents.
- */
-/* Hexadecimal number */
-/* National character */
-/* Quoted string that allows backslash escapes */
-/* Extended quote
- * xqdouble implements embedded quote, ''''
- */
-/* $foo$ style quotes ("dollar quoting")
- * The quoted string starts with $foo$ where "foo" is an optional string
- * in the form of an identifier, except that it may not contain "$",
- * and extends to the first occurrence of an identical string.
- * There is *no* processing of the quoted text.
- *
- * {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
- * fails to match its trailing "$".
- */
-/* Double quote
- * Allows embedded spaces and other special characters into identifiers.
- */
-/* Unicode escapes */
-/* error rule to avoid backup */
-/* Quoted identifier with Unicode escapes */
-/* Quoted string with Unicode escapes */
-/* Optional UESCAPE after a quoted string or identifier with Unicode escapes. */
-/* error rule to avoid backup */
-/* C-style comments
- *
- * The "extended comment" syntax closely resembles allowable operator syntax.
- * The tricky part here is to get lex to recognize a string starting with
- * slash-star as a comment, when interpreting it as an operator would produce
- * a longer match --- remember lex will prefer a longer match!  Also, if we
- * have something like plus-slash-star, lex will think this is a 3-character
- * operator whereas we want to see it as a + operator and a comment start.
- * The solution is two-fold:
- * 1. append {op_chars}* to xcstart so that it matches as much text as
- *    {operator} would. Then the tie-breaker (first matching rule of same
- *    length) ensures xcstart wins.  We put back the extra stuff with yyless()
- *    in case it contains a star-slash that should terminate the comment.
- * 2. In the operator rule, check for slash-star within the operator, and
- *    if found throw it back with yyless().  This handles the plus-slash-star
- *    problem.
- * Dash-dash comments have similar interactions with the operator rule.
- */
-/* Assorted special-case operators and operator-like tokens */
-/* " */
-/*
- * These operator-like tokens (unlike the above ones) also match the {operator}
- * rule, which means that they might be overridden by a longer match if they
- * are followed by a comment start or a + or - character. Accordingly, if you
- * add to this list, you must also add corresponding code to the {operator}
- * block to return the correct token in such cases. (This is not needed in
- * psqlscan.l since the token value is ignored there.)
- */
-/*
- * "self" is the set of chars that should be returned as single-character
- * tokens.  "op_chars" is the set of chars that can make up "Op" tokens,
- * which can be one or more characters long (but if a single-char token
- * appears in the "self" set, it is not to be returned as an Op).  Note
- * that the sets overlap, but each has some chars that are not in the other.
- *
- * If you change either set, adjust the character lists appearing in the
- * rule for "operator"!
- */
-/* we no longer allow unary minus in numbers.
- * instead we pass it separately to parser. there it gets
- * coerced via doNegate() -- Leon aug 20 1999
- *
- * {decimalfail} is used because we would like "1..10" to lex as 1, dot_dot, 10.
- *
- * {realfail1} and {realfail2} are added to prevent the need for scanner
- * backup when the {real} rule fails to match completely.
- */
-/*
- * Dollar quoted strings are totally opaque, and no escaping is done on them.
- * Other quoted strings must allow some special characters such as single-quote
- *  and newline.
- * Embedded single-quotes are implemented both in the SQL standard
- *  style of two adjacent single quotes "''" and in the Postgres/Java style
- *  of escaped-quote "\'".
- * Other embedded escaped characters are matched explicitly and the leading
- *  backslash is dropped from the string.
- * Note that xcstart must appear before operator, as explained above!
- *  Also whitespace (comment) must appear before operator.
- */
-#line 1316 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-#define INITIAL 0
-#define xb 1
-#define xc 2
-#define xd 3
-#define xh 4
-#define xe 5
-#define xq 6
-#define xdolq 7
-#define xui 8
-#define xuiend 9
-#define xus 10
-#define xusend 11
-#define xeu 12
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
-    {
-
-    /* User-defined. Not touched by flex. */
-    YY_EXTRA_TYPE yyextra_r;
-
-    /* The rest are the same as the globals declared in the non-reentrant scanner. */
-    FILE *yyin_r, *yyout_r;
-    size_t yy_buffer_stack_top; /**< index of top of stack. */
-    size_t yy_buffer_stack_max; /**< capacity of stack. */
-    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
-    char yy_hold_char;
-    yy_size_t yy_n_chars;
-    yy_size_t yyleng_r;
-    char *yy_c_buf_p;
-    int yy_init;
-    int yy_start;
-    int yy_did_buffer_switch_on_eof;
-    int yy_start_stack_ptr;
-    int yy_start_stack_depth;
-    int *yy_start_stack;
-    yy_state_type yy_last_accepting_state;
-    char* yy_last_accepting_cpos;
-
-    int yylineno_r;
-    int yy_flex_debug_r;
-
-    char *yytext_r;
-    int yy_more_flag;
-    int yy_more_len;
-
-    YYSTYPE * yylval_r;
-
-    YYLTYPE * yylloc_r;
-
-    }; /* end struct yyguts_t */
-
-static int yy_init_globals ( yyscan_t yyscanner );
-
-    /* This must go here because YYSTYPE and YYLTYPE are included
-     * from bison output in section 1.*/
-    #    define yylval yyg->yylval_r
-    
-    #    define yylloc yyg->yylloc_r
-    
-int yylex_init (yyscan_t* scanner);
-
-int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( yyscan_t yyscanner );
-
-int yyget_debug ( yyscan_t yyscanner );
-
-void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-
-YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-
-FILE *yyget_in ( yyscan_t yyscanner );
-
-void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
-
-FILE *yyget_out ( yyscan_t yyscanner );
-
-void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
-
-			yy_size_t yyget_leng ( yyscan_t yyscanner );
-
-char *yyget_text ( yyscan_t yyscanner );
-
-int yyget_lineno ( yyscan_t yyscanner );
-
-void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-
-int yyget_column  ( yyscan_t yyscanner );
-
-void yyset_column ( int _column_no , yyscan_t yyscanner );
-
-YYSTYPE * yyget_lval ( yyscan_t yyscanner );
-
-void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
-
-       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
-    
-        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( yyscan_t yyscanner );
-#else
-extern int yywrap ( yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef YY_NO_UNPUT
-    
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput ( yyscan_t yyscanner );
-#else
-static int input ( yyscan_t yyscanner );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-		{ \
-		int c = '*'; \
-		yy_size_t n; \
-		for ( n = 0; n < max_size && \
-			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-			buf[n] = (char) c; \
-		if ( c == '\n' ) \
-			buf[n++] = (char) c; \
-		if ( c == EOF && ferror( yyin ) ) \
-			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-		result = n; \
-		} \
-	else \
-		{ \
-		errno=0; \
-		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
-			{ \
-			if( errno != EINTR) \
-				{ \
-				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-				break; \
-				} \
-			errno=0; \
-			clearerr(yyin); \
-			} \
-		}\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
-
-#define YY_DECL int yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK /*LINTED*/break;
-#endif
-
-#define YY_RULE_SETUP \
-	YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
-	yy_state_type yy_current_state;
-	char *yy_cp, *yy_bp;
-	int yy_act;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    yylval = yylval_param;
-
-    yylloc = yylloc_param;
-
-	if ( !yyg->yy_init )
-		{
-		yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! yyg->yy_start )
-			yyg->yy_start = 1;	/* first start state */
-		if ( ! YY_CURRENT_BUFFER ) {
-			yyensure_buffer_stack (yyscanner);
-			YY_CURRENT_BUFFER_LVALUE =
-				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
-		}
-
-		yy_load_buffer_state( yyscanner );
-		}
-
-	{
-#line 404 "third_party/libpg_query/scan.l"
-
-
-#line 1605 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
-		{
-		yy_cp = yyg->yy_c_buf_p;
-
-		/* Support of yytext. */
-		*yy_cp = yyg->yy_hold_char;
-
-		/* yy_bp points to the position in yy_ch_buf of the start of
-		 * the current run.
-		 */
-		yy_bp = yy_cp;
-
-		yy_current_state = yyg->yy_start;
-yy_match:
-		do
-			{
-			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
-			if ( yy_accept[yy_current_state] )
-				{
-				yyg->yy_last_accepting_state = yy_current_state;
-				yyg->yy_last_accepting_cpos = yy_cp;
-				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 309 )
-					yy_c = yy_meta[yy_c];
-				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-			++yy_cp;
-			}
-		while ( yy_current_state != 308 );
-		yy_cp = yyg->yy_last_accepting_cpos;
-		yy_current_state = yyg->yy_last_accepting_state;
-
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
-
-		YY_DO_BEFORE_ACTION;
-
-do_action:	/* This label is used only to access EOF actions. */
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = yyg->yy_hold_char;
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			goto yy_find_action;
-
-case 1:
-/* rule 1 can match eol */
-YY_RULE_SETUP
-#line 406 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 410 "third_party/libpg_query/scan.l"
-{
-					/* Set location in case of syntax error in comment */
-					SET_YYLLOC();
-					yyextra->xcdepth = 0;
-					BEGIN(xc);
-					/* Put back any characters past slash-star; see above */
-					yyless(2);
-				}
-	YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 419 "third_party/libpg_query/scan.l"
-{
-					(yyextra->xcdepth)++;
-					/* Put back any characters past slash-star; see above */
-					yyless(2);
-				}
-	YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 425 "third_party/libpg_query/scan.l"
-{
-					if (yyextra->xcdepth <= 0)
-						BEGIN(INITIAL);
-					else
-						(yyextra->xcdepth)--;
-				}
-	YY_BREAK
-case 5:
-/* rule 5 can match eol */
-YY_RULE_SETUP
-#line 432 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 436 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 440 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xc):
-#line 444 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated /* comment"); }
-	YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 446 "third_party/libpg_query/scan.l"
-{
-					/* Binary bit type.
-					 * At some point we should simply pass the string
-					 * forward to the parser and label it there.
-					 * In the meantime, place a leading "b" on the string
-					 * to mark it for the input routine as a binary string.
-					 */
-					SET_YYLLOC();
-					BEGIN(xb);
-					startlit();
-					addlitchar('b', yyscanner);
-				}
-	YY_BREAK
-case 9:
-/* rule 9 can match eol */
-#line 459 "third_party/libpg_query/scan.l"
-case 10:
-/* rule 10 can match eol */
-YY_RULE_SETUP
-#line 459 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					BEGIN(INITIAL);
-					yylval->str = litbufdup(yyscanner);
-					return BCONST;
-				}
-	YY_BREAK
-case 11:
-/* rule 11 can match eol */
-#line 466 "third_party/libpg_query/scan.l"
-case 12:
-/* rule 12 can match eol */
-YY_RULE_SETUP
-#line 466 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 13:
-/* rule 13 can match eol */
-#line 470 "third_party/libpg_query/scan.l"
-case 14:
-/* rule 14 can match eol */
-YY_RULE_SETUP
-#line 470 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xb):
-#line 473 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated bit string literal"); }
-	YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 475 "third_party/libpg_query/scan.l"
-{
-					/* Hexadecimal bit type.
-					 * At some point we should simply pass the string
-					 * forward to the parser and label it there.
-					 * In the meantime, place a leading "x" on the string
-					 * to mark it for the input routine as a hex string.
-					 */
-					SET_YYLLOC();
-					BEGIN(xh);
-					startlit();
-					addlitchar('x', yyscanner);
-				}
-	YY_BREAK
-case 16:
-/* rule 16 can match eol */
-#line 488 "third_party/libpg_query/scan.l"
-case 17:
-/* rule 17 can match eol */
-YY_RULE_SETUP
-#line 488 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					BEGIN(INITIAL);
-					yylval->str = litbufdup(yyscanner);
-					return XCONST;
-				}
-	YY_BREAK
-case YY_STATE_EOF(xh):
-#line 494 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated hexadecimal string literal"); }
-	YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 496 "third_party/libpg_query/scan.l"
-{
-					/* National character.
-					 * We will pass this along as a normal character string,
-					 * but preceded with an internally-generated "NCHAR".
-					 */
-					const PGScanKeyword *keyword;
-
-					SET_YYLLOC();
-					yyless(1);	/* eat only 'n' this time */
-
-					keyword = ScanKeywordLookup("nchar",
-												yyextra->keywords,
-												yyextra->num_keywords);
-					if (keyword != NULL)
-					{
-						yylval->keyword = keyword->name;
-						return keyword->value;
-					}
-					else
-					{
-						/* If NCHAR isn't a keyword, just return "n" */
-						yylval->str = pstrdup("n");
-						return IDENT;
-					}
-				}
-	YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 522 "third_party/libpg_query/scan.l"
-{
-					yyextra->warn_on_first_escape = true;
-					yyextra->saw_non_ascii = false;
-					SET_YYLLOC();
-					if (yyextra->standard_conforming_strings)
-						BEGIN(xq);
-					else
-						BEGIN(xe);
-					startlit();
-				}
-	YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 532 "third_party/libpg_query/scan.l"
-{
-					yyextra->warn_on_first_escape = false;
-					yyextra->saw_non_ascii = false;
-					SET_YYLLOC();
-					BEGIN(xe);
-					startlit();
-				}
-	YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 539 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					if (!yyextra->standard_conforming_strings)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("unsafe use of string constant with Unicode escapes"),
-								 errdetail("String constants with Unicode escapes cannot be used when standard_conforming_strings is off."),
-								 lexer_errposition()));
-					BEGIN(xus);
-					startlit();
-				}
-	YY_BREAK
-case 22:
-/* rule 22 can match eol */
-#line 551 "third_party/libpg_query/scan.l"
-case 23:
-/* rule 23 can match eol */
-YY_RULE_SETUP
-#line 551 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					BEGIN(INITIAL);
-					/*
-					 * check that the data remains valid if it might have been
-					 * made invalid by unescaping any chars.
-					 */
-					if (yyextra->saw_non_ascii)
-						pg_verifymbstr(yyextra->literalbuf,
-									   yyextra->literallen,
-									   false);
-					yylval->str = litbufdup(yyscanner);
-					return SCONST;
-				}
-	YY_BREAK
-case 24:
-/* rule 24 can match eol */
-#line 566 "third_party/libpg_query/scan.l"
-case 25:
-/* rule 25 can match eol */
-YY_RULE_SETUP
-#line 566 "third_party/libpg_query/scan.l"
-{
-					/* throw back all but the quote */
-					yyless(1);
-					/* xusend state looks for possible UESCAPE */
-					BEGIN(xusend);
-				}
-	YY_BREAK
-case 26:
-/* rule 26 can match eol */
-YY_RULE_SETUP
-#line 572 "third_party/libpg_query/scan.l"
-{
-					/* stay in xusend state over whitespace */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xusend):
-#line 575 "third_party/libpg_query/scan.l"
-case 27:
-/* rule 27 can match eol */
-#line 577 "third_party/libpg_query/scan.l"
-case 28:
-/* rule 28 can match eol */
-YY_RULE_SETUP
-#line 577 "third_party/libpg_query/scan.l"
-{
-					/* no UESCAPE after the quote, throw back everything */
-					yyless(0);
-					BEGIN(INITIAL);
-					yylval->str = litbuf_udeescape('\\', yyscanner);
-					return SCONST;
-				}
-	YY_BREAK
-case 29:
-/* rule 29 can match eol */
-YY_RULE_SETUP
-#line 584 "third_party/libpg_query/scan.l"
-{
-					/* found UESCAPE after the end quote */
-					BEGIN(INITIAL);
-					if (!check_uescapechar(yytext[yyleng - 2]))
-					{
-						SET_YYLLOC();
-						ADVANCE_YYLLOC(yyleng - 2);
-						yyerror("invalid Unicode escape character");
-					}
-					yylval->str = litbuf_udeescape(yytext[yyleng - 2],
-												   yyscanner);
-					return SCONST;
-				}
-	YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 597 "third_party/libpg_query/scan.l"
-{
-					addlitchar('\'', yyscanner);
-				}
-	YY_BREAK
-case 31:
-/* rule 31 can match eol */
-YY_RULE_SETUP
-#line 600 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 32:
-/* rule 32 can match eol */
-YY_RULE_SETUP
-#line 603 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 606 "third_party/libpg_query/scan.l"
-{
-					pg_wchar	c = strtoul(yytext + 2, NULL, 16);
-
-					check_escape_warning(yyscanner);
-
-					if (is_utf16_surrogate_first(c))
-					{
-						yyextra->utf16_first_part = c;
-						BEGIN(xeu);
-					}
-					else if (is_utf16_surrogate_second(c))
-						yyerror("invalid Unicode surrogate pair");
-					else
-						addunicode(c, yyscanner);
-				}
-	YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 621 "third_party/libpg_query/scan.l"
-{
-					pg_wchar	c = strtoul(yytext + 2, NULL, 16);
-
-					if (!is_utf16_surrogate_second(c))
-						yyerror("invalid Unicode surrogate pair");
-
-					c = surrogate_pair_to_codepoint(yyextra->utf16_first_part, c);
-
-					addunicode(c, yyscanner);
-
-					BEGIN(xe);
-				}
-	YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 633 "third_party/libpg_query/scan.l"
-{ yyerror("invalid Unicode surrogate pair"); }
-	YY_BREAK
-case 36:
-/* rule 36 can match eol */
-YY_RULE_SETUP
-#line 634 "third_party/libpg_query/scan.l"
-{ yyerror("invalid Unicode surrogate pair"); }
-	YY_BREAK
-case YY_STATE_EOF(xeu):
-#line 635 "third_party/libpg_query/scan.l"
-{ yyerror("invalid Unicode surrogate pair"); }
-	YY_BREAK
-case 37:
-YY_RULE_SETUP
-#line 636 "third_party/libpg_query/scan.l"
-{
-					ereport(ERROR,
-							(errcode(PG_ERRCODE_INVALID_ESCAPE_SEQUENCE),
-							 errmsg("invalid Unicode escape"),
-							 errhint("Unicode escapes must be \\uXXXX or \\UXXXXXXXX."),
-							 lexer_errposition()));
-				}
-	YY_BREAK
-case 38:
-/* rule 38 can match eol */
-YY_RULE_SETUP
-#line 643 "third_party/libpg_query/scan.l"
-{
-					// if (yytext[1] == '\'')
-					// {
-					// 	if (yyextra->backslash_quote == PG_BACKSLASH_QUOTE_OFF ||
-					// 		(yyextra->backslash_quote == PG_BACKSLASH_QUOTE_SAFE_ENCODING &&
-					// 		 PG_ENCODING_IS_CLIENT_ONLY(pg_get_client_encoding())))
-					// 		ereport(ERROR,
-					// 				(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-					// 				 errmsg("unsafe use of \\' in a string literal"),
-					// 				 errhint("Use '' to write quotes in strings. \\' is insecure in client-only encodings."),
-					// 				 lexer_errposition()));
-					// }
-					check_string_escape_warning(yytext[1], yyscanner);
-					addlitchar(unescape_single_char(yytext[1], yyscanner),
-							   yyscanner);
-				}
-	YY_BREAK
-case 39:
-YY_RULE_SETUP
-#line 659 "third_party/libpg_query/scan.l"
-{
-					unsigned char c = strtoul(yytext + 1, NULL, 8);
-
-					check_escape_warning(yyscanner);
-					addlitchar(c, yyscanner);
-					if (c == '\0' || IS_HIGHBIT_SET(c))
-						yyextra->saw_non_ascii = true;
-				}
-	YY_BREAK
-case 40:
-YY_RULE_SETUP
-#line 667 "third_party/libpg_query/scan.l"
-{
-					unsigned char c = strtoul(yytext + 2, NULL, 16);
-
-					check_escape_warning(yyscanner);
-					addlitchar(c, yyscanner);
-					if (c == '\0' || IS_HIGHBIT_SET(c))
-						yyextra->saw_non_ascii = true;
-				}
-	YY_BREAK
-case 41:
-/* rule 41 can match eol */
-YY_RULE_SETUP
-#line 675 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 42:
-YY_RULE_SETUP
-#line 678 "third_party/libpg_query/scan.l"
-{
-					/* This is only needed for \ just before EOF */
-					addlitchar(yytext[0], yyscanner);
-				}
-	YY_BREAK
-case YY_STATE_EOF(xq):
-case YY_STATE_EOF(xe):
-case YY_STATE_EOF(xus):
-#line 682 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated quoted string"); }
-	YY_BREAK
-case 43:
-YY_RULE_SETUP
-#line 684 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yyextra->dolqstart = pstrdup(yytext);
-					BEGIN(xdolq);
-					startlit();
-				}
-	YY_BREAK
-case 44:
-YY_RULE_SETUP
-#line 690 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					/* throw back all but the initial "$" */
-					yyless(1);
-					/* and treat it as {other} */
-					return yytext[0];
-				}
-	YY_BREAK
-case 45:
-YY_RULE_SETUP
-#line 697 "third_party/libpg_query/scan.l"
-{
-					if (strcmp(yytext, yyextra->dolqstart) == 0)
-					{
-						pfree(yyextra->dolqstart);
-						yyextra->dolqstart = NULL;
-						BEGIN(INITIAL);
-						yylval->str = litbufdup(yyscanner);
-						return SCONST;
-					}
-					else
-					{
-						/*
-						 * When we fail to match $...$ to dolqstart, transfer
-						 * the $... part to the output, but put back the final
-						 * $ for rescanning.  Consider $delim$...$junk$delim$
-						 */
-						addlit(yytext, yyleng - 1, yyscanner);
-						yyless(yyleng - 1);
-					}
-				}
-	YY_BREAK
-case 46:
-/* rule 46 can match eol */
-YY_RULE_SETUP
-#line 717 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 47:
-YY_RULE_SETUP
-#line 720 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 48:
-YY_RULE_SETUP
-#line 723 "third_party/libpg_query/scan.l"
-{
-					/* This is only needed for $ inside the quoted text */
-					addlitchar(yytext[0], yyscanner);
-				}
-	YY_BREAK
-case YY_STATE_EOF(xdolq):
-#line 727 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated dollar-quoted string"); }
-	YY_BREAK
-case 49:
-YY_RULE_SETUP
-#line 729 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					BEGIN(xd);
-					startlit();
-				}
-	YY_BREAK
-case 50:
-YY_RULE_SETUP
-#line 734 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					BEGIN(xui);
-					startlit();
-				}
-	YY_BREAK
-case 51:
-YY_RULE_SETUP
-#line 739 "third_party/libpg_query/scan.l"
-{
-					char	   *ident;
-
-					BEGIN(INITIAL);
-					if (yyextra->literallen == 0)
-						yyerror("zero-length delimited identifier");
-					ident = litbufdup(yyscanner);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 52:
-YY_RULE_SETUP
-#line 749 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					/* xuiend state looks for possible UESCAPE */
-					BEGIN(xuiend);
-				}
-	YY_BREAK
-case 53:
-/* rule 53 can match eol */
-YY_RULE_SETUP
-#line 754 "third_party/libpg_query/scan.l"
-{
-					/* stay in xuiend state over whitespace */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xuiend):
-#line 757 "third_party/libpg_query/scan.l"
-case 54:
-/* rule 54 can match eol */
-#line 759 "third_party/libpg_query/scan.l"
-case 55:
-/* rule 55 can match eol */
-YY_RULE_SETUP
-#line 759 "third_party/libpg_query/scan.l"
-{
-					/* no UESCAPE after the quote, throw back everything */
-					char	   *ident;
-
-					yyless(0);
-
-					BEGIN(INITIAL);
-					if (yyextra->literallen == 0)
-						yyerror("zero-length delimited identifier");
-					ident = litbuf_udeescape('\\', yyscanner);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 56:
-/* rule 56 can match eol */
-YY_RULE_SETUP
-#line 772 "third_party/libpg_query/scan.l"
-{
-					/* found UESCAPE after the end quote */
-					char	   *ident;
-
-					BEGIN(INITIAL);
-					if (yyextra->literallen == 0)
-						yyerror("zero-length delimited identifier");
-					if (!check_uescapechar(yytext[yyleng - 2]))
-					{
-						SET_YYLLOC();
-						ADVANCE_YYLLOC(yyleng - 2);
-						yyerror("invalid Unicode escape character");
-					}
-					ident = litbuf_udeescape(yytext[yyleng - 2], yyscanner);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 57:
-YY_RULE_SETUP
-#line 789 "third_party/libpg_query/scan.l"
-{
-					addlitchar('"', yyscanner);
-				}
-	YY_BREAK
-case 58:
-/* rule 58 can match eol */
-YY_RULE_SETUP
-#line 792 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case YY_STATE_EOF(xd):
-case YY_STATE_EOF(xui):
-#line 795 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated quoted identifier"); }
-	YY_BREAK
-case 59:
-YY_RULE_SETUP
-#line 797 "third_party/libpg_query/scan.l"
-{
-					char	   *ident;
-
-					SET_YYLLOC();
-					/* throw back all but the initial u/U */
-					yyless(1);
-					/* and treat it as {identifier} */
-					ident = downcase_truncate_identifier(yytext, yyleng, true);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 60:
-YY_RULE_SETUP
-#line 809 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return TYPECAST;
-				}
-	YY_BREAK
-case 61:
-YY_RULE_SETUP
-#line 814 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return DOT_DOT;
-				}
-	YY_BREAK
-case 62:
-YY_RULE_SETUP
-#line 819 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return COLON_EQUALS;
-				}
-	YY_BREAK
-case 63:
-YY_RULE_SETUP
-#line 824 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return LAMBDA_ARROW;
-				}
-	YY_BREAK
-case 64:
-YY_RULE_SETUP
-#line 829 "third_party/libpg_query/scan.l"
-{
-                    SET_YYLLOC();
-                    return DOUBLE_ARROW;
-                		}
-	YY_BREAK
-case 65:
-YY_RULE_SETUP
-#line 834 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return POWER_OF;
-				}
-	YY_BREAK
-case 66:
-YY_RULE_SETUP
-#line 839 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return INTEGER_DIVISION;
-				}
-	YY_BREAK
-case 67:
-YY_RULE_SETUP
-#line 844 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return EQUALS_GREATER;
-				}
-	YY_BREAK
-case 68:
-YY_RULE_SETUP
-#line 849 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return LESS_EQUALS;
-				}
-	YY_BREAK
-case 69:
-YY_RULE_SETUP
-#line 854 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return GREATER_EQUALS;
-				}
-	YY_BREAK
-case 70:
-YY_RULE_SETUP
-#line 859 "third_party/libpg_query/scan.l"
-{
-					/* We accept both "<>" and "!=" as meaning NOT_EQUALS */
-					SET_YYLLOC();
-					return NOT_EQUALS;
-				}
-	YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 865 "third_party/libpg_query/scan.l"
-{
-					/* We accept both "<>" and "!=" as meaning NOT_EQUALS */
-					SET_YYLLOC();
-					return NOT_EQUALS;
-				}
-	YY_BREAK
-case 72:
-YY_RULE_SETUP
-#line 871 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return yytext[0];
-				}
-	YY_BREAK
-case 73:
-YY_RULE_SETUP
-#line 876 "third_party/libpg_query/scan.l"
-{
-					/*
-					 * Check for embedded slash-star or dash-dash; those
-					 * are comment starts, so operator must stop there.
-					 * Note that slash-star or dash-dash at the first
-					 * character will match a prior rule, not this one.
-					 */
-					int			nchars = yyleng;
-					char	   *slashstar = strstr(yytext, "/*"); /* slash star */
-					char	   *dashdash = strstr(yytext, "--");
-
-					if (slashstar && dashdash) {
-						/* if both appear, take the first one */
-						if (slashstar > dashdash)
-							slashstar = dashdash;
-					} else if (!slashstar) {
-						slashstar = dashdash;
-					}
-					if (slashstar) {
-						nchars = slashstar - yytext;
-					}
-
-					/*
-					 * For SQL compatibility, '+' and '-' cannot be the
-					 * last char of a multi-char operator unless the operator
-					 * contains chars that are not in SQL operators.
-					 * The idea is to lex '=-' as two operators, but not
-					 * to forbid operator names like '?-' that could not be
-					 * sequences of SQL operators.
-					 */
-					while (nchars > 1 &&
-						(yytext[nchars - 1] == '+' ||
-						 yytext[nchars - 1] == '-'))
-					{
-						int			ic;
-
-						for (ic = nchars - 2; ic >= 0; ic--)
-						{
-							if (strchr("~!@^&|`?%", yytext[ic]))
-								break;
-						}
-						if (ic >= 0)
-							break; /* found a char that makes it OK */
-						nchars--; /* else remove the +/-, and check again */
-					}
-
-					/* We don't accept leading ? in any multi-character operators
-					* except for those in use by hstore, JSON and geometric operators.
-					*
-					* We don't accept contained or trailing ? in any
-					* multi-character operators.
-					*
-					* This is necessary in order to support normalized queries without
-					* spacing between ? as a substition character and a simple operator (e.g. "?=?")
-					*/
-					if (yytext[0] == '?' &&
-						strcmp(yytext, "?|") != 0 && strcmp(yytext, "?&") != 0 &&
-						strcmp(yytext, "?-") != 0 &&
-						strcmp(yytext, "?-|") != 0 && strcmp(yytext, "?||") != 0) {
-						nchars = 1;
-					}
-
-					if (yytext[0] != '?' && strchr(yytext, '?')) {
-						/* Lex up to just before the ? character */
-						nchars = strchr(yytext, '?') - yytext;
-					}
-
-					SET_YYLLOC();
-
-					if ((yy_size_t) nchars < yyleng)
-					{
-						/* Strip the unwanted chars from the token */
-						yyless(nchars);
-						/*
-						 * If what we have left is only one char, and it's
-						 * one of the characters matching "self", then
-						 * return it as a character token the same way
-						 * that the "self" rule would have.
-						 */
-						if (nchars == 1 &&
-							strchr(",()[].;:+-*/%^<>=?", yytext[0])) {
-							return yytext[0];
-						}
-						/*
-						 * Likewise, if what we have left is two chars, and
-						 * those match the tokens ">=", "<=", "=>", "<>" or
-						 * "!=", then we must return the appropriate token
-						 * rather than the generic Op.
-						 */
-						if (nchars == 2)
-						{
-							if (yytext[0] == '=' && yytext[1] == '>')
-								return EQUALS_GREATER;
-							if (yytext[0] == '>' && yytext[1] == '=')
-								return GREATER_EQUALS;
-							if (yytext[0] == '<' && yytext[1] == '=')
-								return LESS_EQUALS;
-							if (yytext[0] == '<' && yytext[1] == '>')
-								return NOT_EQUALS;
-							if (yytext[0] == '!' && yytext[1] == '=')
-								return NOT_EQUALS;
-						}
-					}
-
-					/*
-					 * Complain if operator is too long.  Unlike the case
-					 * for identifiers, we make this an error not a notice-
-					 * and-truncate, because the odds are we are looking at
-					 * a syntactic mistake anyway. NAMEDDATALEN
-					 */
-					if (nchars >= 64)
-						yyerror("operator too long: operators longer than 64 bytes are not supported");
-
-					yylval->str = pstrdup(yytext);
-					return Op;
-				}
-	YY_BREAK
-case 74:
-YY_RULE_SETUP
-#line 993 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->ival = atol(yytext + 1);
-					return PARAM;
-				}
-	YY_BREAK
-case 75:
-YY_RULE_SETUP
-#line 999 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->ival = atol(yytext + 1);
-					return PARAM;
-				}
-	YY_BREAK
-case 76:
-YY_RULE_SETUP
-#line 1005 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return process_integer_literal(yytext, yylval);
-				}
-	YY_BREAK
-case 77:
-YY_RULE_SETUP
-#line 1009 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 78:
-YY_RULE_SETUP
-#line 1014 "third_party/libpg_query/scan.l"
-{
-					/* throw back the .., and treat as integer */
-					yyless(yyleng - 2);
-					SET_YYLLOC();
-					return process_integer_literal(yytext, yylval);
-				}
-	YY_BREAK
-case 79:
-YY_RULE_SETUP
-#line 1020 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 80:
-YY_RULE_SETUP
-#line 1025 "third_party/libpg_query/scan.l"
-{
-					/*
-					 * throw back the [Ee], and treat as {decimal}.  Note
-					 * that it is possible the input is actually {integer},
-					 * but since this case will almost certainly lead to a
-					 * syntax error anyway, we don't bother to distinguish.
-					 */
-					yyless(yyleng - 1);
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 81:
-YY_RULE_SETUP
-#line 1037 "third_party/libpg_query/scan.l"
-{
-					/* throw back the [Ee][+-], and proceed as above */
-					yyless(yyleng - 2);
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 82:
-YY_RULE_SETUP
-#line 1046 "third_party/libpg_query/scan.l"
-{
-					const PGScanKeyword *keyword;
-					char	   *ident;
-					char       *keyword_text = pstrdup(yytext);
-
-					SET_YYLLOC();
-
-					if (yytext[yyleng - 1] == '?') {
-						keyword_text[yyleng - 1] = '\0';
-					}
-
-					/* Is it a keyword? */
-					keyword = ScanKeywordLookup(keyword_text,
-												yyextra->keywords,
-												yyextra->num_keywords);
-					if (keyword != NULL)
-					{
-						if (keyword_text[yyleng - 1] == '\0') {
-							yyless(yyleng - 1);
-						}
-						yylval->keyword = keyword_text;
-						return keyword->value;
-					}
-
-					/*
-					 * No.  Convert the identifier to lower case, and truncate
-					 * if necessary.
-					 */
-					ident = downcase_truncate_identifier(yytext, yyleng, true);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 83:
-YY_RULE_SETUP
-#line 1079 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return yytext[0];
-				}
-	YY_BREAK
-case YY_STATE_EOF(INITIAL):
-#line 1084 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yyterminate();
-				}
-	YY_BREAK
-case 84:
-YY_RULE_SETUP
-#line 1089 "third_party/libpg_query/scan.l"
-YY_FATAL_ERROR( "flex scanner jammed" );
-	YY_BREAK
-#line 2676 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-	case YY_END_OF_BUFFER:
-		{
-		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = yyg->yy_hold_char;
-		YY_RESTORE_YY_MORE_OFFSET
-
-		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * yylex().  If so, then we have to assure
-			 * consistency between YY_CURRENT_BUFFER and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
-
-			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
-			yy_current_state = yy_get_previous_state( yyscanner );
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
-
-			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
-			if ( yy_next_state )
-				{
-				/* Consume the NUL. */
-				yy_cp = ++yyg->yy_c_buf_p;
-				yy_current_state = yy_next_state;
-				goto yy_match;
-				}
-
-			else
-				{
-				yy_cp = yyg->yy_last_accepting_cpos;
-				yy_current_state = yyg->yy_last_accepting_state;
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer( yyscanner ) )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				yyg->yy_did_buffer_switch_on_eof = 0;
-
-				if ( yywrap( yyscanner ) )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
-					yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				yyg->yy_c_buf_p =
-					yyg->yytext_ptr + yy_amount_of_matched_text;
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				yyg->yy_c_buf_p =
-				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-	} /* end of user's declarations */
-} /* end of yylex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	char *source = yyg->yytext_ptr;
-	int number_to_move, i;
-	int ret_val;
-
-	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
-			{
-			/* We matched a single character, the EOB, so
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
-
-	else
-		{
-			yy_size_t num_to_read =
-			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-
-			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
-
-			int yy_c_buf_p_offset =
-				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
-
-			if ( b->yy_is_our_buffer )
-				{
-				yy_size_t new_size = b->yy_buf_size * 2;
-
-				if ( new_size <= 0 )
-					b->yy_buf_size += b->yy_buf_size / 8;
-				else
-					b->yy_buf_size *= 2;
-
-				b->yy_ch_buf = (char *)
-					/* Include room in for 2 EOB chars. */
-					yyrealloc( (void *) b->yy_ch_buf,
-							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
-				}
-			else
-				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = NULL;
-
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1;
-
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, num_to_read );
-
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	if ( yyg->yy_n_chars == 0 )
-		{
-		if ( number_to_move == YY_MORE_ADJ )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart( yyin  , yyscanner);
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
-			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
-		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-		/* "- 2" to take care of EOB's */
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
-	}
-
-	yyg->yy_n_chars += number_to_move;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
-	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-	return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
-{
-	yy_state_type yy_current_state;
-	char *yy_cp;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_current_state = yyg->yy_start;
-
-	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
-		{
-		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
-			{
-			yyg->yy_last_accepting_state = yy_current_state;
-			yyg->yy_last_accepting_cpos = yy_cp;
-			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 309 )
-				yy_c = yy_meta[yy_c];
-			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-		}
-
-	return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
- */
-    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
-{
-	int yy_is_jam;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-	char *yy_cp = yyg->yy_c_buf_p;
-
-	YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
-		{
-		yyg->yy_last_accepting_state = yy_current_state;
-		yyg->yy_last_accepting_cpos = yy_cp;
-		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 309 )
-			yy_c = yy_meta[yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 308);
-
-	(void)yyg;
-	return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-    static int yyinput (yyscan_t yyscanner)
-#else
-    static int input  (yyscan_t yyscanner)
-#endif
-
-{
-	int c;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	*yyg->yy_c_buf_p = yyg->yy_hold_char;
-
-	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
-		{
-		/* yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			/* This was really a NUL. */
-			*yyg->yy_c_buf_p = '\0';
-
-		else
-			{ /* need more input */
-			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
-			++yyg->yy_c_buf_p;
-
-			switch ( yy_get_next_buffer( yyscanner ) )
-				{
-				case EOB_ACT_LAST_MATCH:
-					/* This happens because yy_g_n_b()
-					 * sees that we've accumulated a
-					 * token and flags that we need to
-					 * try matching the token before
-					 * proceeding.  But for input(),
-					 * there's no matching to consider.
-					 * So convert the EOB_ACT_LAST_MATCH
-					 * to EOB_ACT_END_OF_FILE.
-					 */
-
-					/* Reset buffer status. */
-					yyrestart( yyin , yyscanner);
-
-					/*FALLTHROUGH*/
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( yywrap( yyscanner ) )
-						return 0;
-
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-#ifdef __cplusplus
-					return yyinput(yyscanner);
-#else
-					return input(yyscanner);
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
-					break;
-				}
-			}
-		}
-
-	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
-	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
-	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
-	return c;
-}
-#endif	/* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
-    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! YY_CURRENT_BUFFER ){
-        yyensure_buffer_stack (yyscanner);
-		YY_CURRENT_BUFFER_LVALUE =
-            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
-	}
-
-	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
-	yy_load_buffer_state( yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
-    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	/* TODO. We should be able to replace this entire function body
-	 * with
-	 *		yypop_buffer_state();
-	 *		yypush_buffer_state(new_buffer);
-     */
-	yyensure_buffer_stack (yyscanner);
-	if ( YY_CURRENT_BUFFER == new_buffer )
-		return;
-
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	yy_load_buffer_state( yyscanner );
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (yywrap()) processing, but the only time this flag
-	 * is looked at is after yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-static void yy_load_buffer_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-	yyg->yy_hold_char = *yyg->yy_c_buf_p;
-}
-
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
-    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_buf_size = size;
-
-	/* yy_ch_buf has to be 2 characters longer than the size given because
-	 * we need to put in 2 end-of-buffer characters.
-	 */
-	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	yy_init_buffer( b, file , yyscanner);
-
-	return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with yy_create_buffer()
- * @param yyscanner The scanner object.
- */
-    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! b )
-		return;
-
-	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		yyfree( (void *) b->yy_ch_buf , yyscanner );
-
-	yyfree( (void *) b , yyscanner );
-}
-
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a yyrestart() or at EOF.
- */
-    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
-
-{
-	int oerrno = errno;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_flush_buffer( b , yyscanner);
-
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-    /* If b is the current buffer, then yy_init_buffer was _probably_
-     * called from yyrestart() or through yy_get_next_buffer.
-     * In that case, we don't want to reset the lineno or column.
-     */
-    if (b != YY_CURRENT_BUFFER){
-        b->yy_bs_lineno = 1;
-        b->yy_bs_column = 0;
-    }
-
-        b->yy_is_interactive = 0;
-    
-	errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- * @param yyscanner The scanner object.
- */
-    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( ! b )
-		return;
-
-	b->yy_n_chars = 0;
-
-	/* We always need two end-of-buffer characters.  The first causes
-	 * a transition to the end-of-buffer state.  The second causes
-	 * a jam in that state.
-	 */
-	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
-	b->yy_buf_pos = &b->yy_ch_buf[0];
-
-	b->yy_at_bol = 1;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	if ( b == YY_CURRENT_BUFFER )
-		yy_load_buffer_state( yyscanner );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- *  the current state. This function will allocate the stack
- *  if necessary.
- *  @param new_buffer The new state.
- *  @param yyscanner The scanner object.
- */
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (new_buffer == NULL)
-		return;
-
-	yyensure_buffer_stack(yyscanner);
-
-	/* This block is copied from yy_switch_to_buffer. */
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	/* Only push if top exists. Otherwise, replace top. */
-	if (YY_CURRENT_BUFFER)
-		yyg->yy_buffer_stack_top++;
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-	/* copied from yy_switch_to_buffer. */
-	yy_load_buffer_state( yyscanner );
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- *  The next element becomes the new top.
- *  @param yyscanner The scanner object.
- */
-void yypop_buffer_state (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (!YY_CURRENT_BUFFER)
-		return;
-
-	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
-	YY_CURRENT_BUFFER_LVALUE = NULL;
-	if (yyg->yy_buffer_stack_top > 0)
-		--yyg->yy_buffer_stack_top;
-
-	if (YY_CURRENT_BUFFER) {
-		yy_load_buffer_state( yyscanner );
-		yyg->yy_did_buffer_switch_on_eof = 1;
-	}
-}
-
-/* Allocates the stack if it does not exist.
- *  Guarantees space for at least one push.
- */
-static void yyensure_buffer_stack (yyscan_t yyscanner)
-{
-	yy_size_t num_to_alloc;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if (!yyg->yy_buffer_stack) {
-
-		/* First allocation is just for 2 elements, since we don't know if this
-		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-		 * immediate realloc on the next call.
-         */
-      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
-								(num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
-		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
-		yyg->yy_buffer_stack_max = num_to_alloc;
-		yyg->yy_buffer_stack_top = 0;
-		return;
-	}
-
-	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
-		/* Increase the buffer to prepare for a possible push. */
-		yy_size_t grow_size = 8 /* arbitrary grow size */;
-
-		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
-								(yyg->yy_buffer_stack,
-								num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
-		/* zero only the new slots.*/
-		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-		yyg->yy_buffer_stack_max = num_to_alloc;
-	}
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	if ( size < 2 ||
-	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-		/* They forgot to leave room for the EOB's. */
-		return NULL;
-
-	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-
-	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
-	b->yy_buf_pos = b->yy_ch_buf = base;
-	b->yy_is_our_buffer = 0;
-	b->yy_input_file = NULL;
-	b->yy_n_chars = b->yy_buf_size;
-	b->yy_is_interactive = 0;
-	b->yy_at_bol = 1;
-	b->yy_fill_buffer = 0;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	yy_switch_to_buffer( b , yyscanner );
-
-	return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- *       yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
-{
-    
-	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	yy_size_t i;
-    
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = (yy_size_t) (_yybytes_len + 2);
-	buf = (char *) yyalloc( n , yyscanner );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
-	for ( i = 0; i < _yybytes_len; ++i )
-		buf[i] = yybytes[i];
-
-	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = yy_scan_buffer( buf, n , yyscanner);
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
-
-	/* It's okay to grow etc. this buffer, and we should throw it
-	 * away when we're done.
-	 */
-	b->yy_is_our_buffer = 1;
-
-	return b;
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
-{
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-	//( stderr, "%s\n", msg );
-	throw std::runtime_error(msg); // YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        yy_size_t yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		yytext[yyleng] = yyg->yy_hold_char; \
-		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
-		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
-		*yyg->yy_c_buf_p = '\0'; \
-		yyleng = yyless_macro_arg; \
-		} \
-	while ( 0 )
-
-/* Accessor  methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int yyget_lineno  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int yyget_column  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_in  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_out  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-yy_size_t yyget_leng  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *yyget_text  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param _line_number line number
- * @param yyscanner The scanner object.
- */
-void yyset_lineno (int  _line_number , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* lineno is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
-    
-    yylineno = _line_number;
-}
-
-/** Set the current column.
- * @param _column_no column number
- * @param yyscanner The scanner object.
- */
-void yyset_column (int  _column_no , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* column is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "yyset_column called with no buffer" );
-    
-    yycolumn = _column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param _in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see yy_switch_to_buffer
- */
-void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyin = _in_str ;
-}
-
-void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyout = _out_str ;
-}
-
-int yyget_debug  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yy_flex_debug;
-}
-
-void yyset_debug (int  _bdebug , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yy_flex_debug = _bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-YYSTYPE * yyget_lval  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylval;
-}
-
-void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylval = yylval_param;
-}
-
-YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylloc;
-}
-    
-void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylloc = yylloc_param;
-}
-    
-/* User-visible API */
-
-/* yylex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-int yylex_init(yyscan_t* ptr_yy_globals)
-{
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-
-    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-
-    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* yylex_init_extra has the same functionality as yylex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to yyalloc in
- * the yyextra field.
- */
-int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
-{
-    struct yyguts_t dummy_yyguts;
-
-    yyset_extra (yy_user_defined, &dummy_yyguts);
-
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-
-    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-
-    /* By setting to 0xAA, we expose bugs in
-    yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    yyset_extra (yy_user_defined, *ptr_yy_globals);
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    /* Initialization is the same as for the non-reentrant scanner.
-     * This function is called from yylex_destroy(), so don't allocate here.
-     */
-
-    yyg->yy_buffer_stack = NULL;
-    yyg->yy_buffer_stack_top = 0;
-    yyg->yy_buffer_stack_max = 0;
-    yyg->yy_c_buf_p = NULL;
-    yyg->yy_init = 0;
-    yyg->yy_start = 0;
-
-    yyg->yy_start_stack_ptr = 0;
-    yyg->yy_start_stack_depth = 0;
-    yyg->yy_start_stack =  NULL;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
-    yyin = NULL;
-    yyout = NULL;
-#endif
-
-    /* For future reference: Set errno on error, since we are called by
-     * yylex_init()
-     */
-    return 0;
-}
-
-/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-int yylex_destroy  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    /* Pop the buffer stack, destroying each element. */
-	while(YY_CURRENT_BUFFER){
-		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
-		YY_CURRENT_BUFFER_LVALUE = NULL;
-		yypop_buffer_state(yyscanner);
-	}
-
-	/* Destroy the stack itself. */
-	yyfree(yyg->yy_buffer_stack , yyscanner);
-	yyg->yy_buffer_stack = NULL;
-
-    /* Destroy the start condition stack. */
-        yyfree( yyg->yy_start_stack , yyscanner );
-        yyg->yy_start_stack = NULL;
-
-    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-     * yylex() is called, initialization will occur. */
-    yy_init_globals( yyscanner);
-
-    /* Destroy the main struct (reentrant only). */
-    yyfree ( yyscanner , yyscanner );
-    yyscanner = NULL;
-    return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
-{
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-
-	int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
-{
-	int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-}
-#endif
-
-#define YYTABLES_NAME "yytables"
-
-#line 1089 "third_party/libpg_query/scan.l"
-
-
-/* LCOV_EXCL_STOP */
-
-/*
- * Arrange access to yyextra for subroutines of the main yylex() function.
- * We expect each subroutine to have a yyscanner parameter.  Rather than
- * use the yyget_xxx functions, which might or might not get inlined by the
- * compiler, we cheat just a bit and cast yyscanner to the right type.
- */
-#undef yyextra
-#define yyextra  (((struct yyguts_t *) yyscanner)->yyextra_r)
-
-/* Likewise for a couple of other things we need. */
-#undef yylloc
-#define yylloc	(((struct yyguts_t *) yyscanner)->yylloc_r)
-#undef yyleng
-#define yyleng	(((struct yyguts_t *) yyscanner)->yyleng_r)
-
-
-/*
- * scanner_errposition
- *		Report a lexer or grammar error cursor position, if possible.
- *
- * This is expected to be used within an ereport() call.  The return value
- * is a dummy (always 0, in fact).
- *
- * Note that this can only be used for messages emitted during raw parsing
- * (essentially, scan.l and gram.y), since it requires the yyscanner struct
- * to still be available.
- */
-int
-scanner_errposition(int location, core_yyscan_t yyscanner)
-{
-	int			pos;
-
-	if (location < 0)
-		return 0;				/* no-op if location is unknown */
-
-	/* Convert byte offset to character number */
-	pos = pg_mbstrlen_with_len(yyextra->scanbuf, location) + 1;
-	/* And pass it to the ereport mechanism */
-	return errposition(pos);
-}
-
-/*
- * scanner_yyerror
- *		Report a lexer or grammar error.
- *
- * The message's cursor position is whatever YYLLOC was last set to,
- * ie, the start of the current token if called within yylex(), or the
- * most recently lexed token if called from the grammar.
- * This is OK for syntax error messages from the Bison parser, because Bison
- * parsers report error as soon as the first unparsable token is reached.
- * Beware of using yyerror for other purposes, as the cursor position might
- * be misleading!
- */
-void
-scanner_yyerror(const char *message, core_yyscan_t yyscanner)
-{
-	const char *loc = yyextra->scanbuf + *yylloc;
-
-	if (*loc == YY_END_OF_BUFFER_CHAR)
-	{
-		ereport(ERROR,
-				(errcode(PG_ERRCODE_SYNTAX_ERROR),
-		/* translator: %s is typically the translation of "syntax error" */
-				 errmsg("%s at end of input", _(message)),
-				 lexer_errposition()));
-	}
-	else
-	{
-		ereport(ERROR,
-				(errcode(PG_ERRCODE_SYNTAX_ERROR),
-		/* translator: first %s is typically the translation of "syntax error" */
-				 errmsg("%s at or near \"%s\"", _(message), loc),
-				 lexer_errposition()));
-	}
-}
-
-
-/*
- * Called before any actual parsing is done
- */
-core_yyscan_t
-scanner_init(const char *str,
-			 core_yy_extra_type *yyext,
-			 const PGScanKeyword *keywords,
-			 int num_keywords)
-{
-	PGSize		slen = strlen(str);
-	yyscan_t	scanner;
-
-	if (yylex_init(&scanner) != 0)
-		elog(ERROR, "yylex_init() failed: %m");
-
-	core_yyset_extra(yyext, scanner);
-
-	yyext->keywords = keywords;
-	yyext->num_keywords = num_keywords;
-
-	yyext->backslash_quote = backslash_quote;
-	yyext->escape_string_warning = escape_string_warning;
-	yyext->standard_conforming_strings = standard_conforming_strings;
-
-	/*
-	 * Make a scan buffer with special termination needed by flex.
-	 */
-	yyext->scanbuf = (char *) palloc(slen + 2);
-	yyext->scanbuflen = slen;
-	memcpy(yyext->scanbuf, str, slen);
-	yyext->scanbuf[slen] = yyext->scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
-	yy_scan_buffer(yyext->scanbuf, slen + 2, scanner);
-
-	/* initialize literal buffer to a reasonable but expansible size */
-	yyext->literalalloc = 1024;
-	yyext->literalbuf = (char *) palloc(yyext->literalalloc);
-	yyext->literallen = 0;
-
-	return scanner;
-}
-
-
-/*
- * Called after parsing is done to clean up after scanner_init()
- */
-void
-scanner_finish(core_yyscan_t yyscanner)
-{
-	/*
-	 * We don't bother to call yylex_destroy(), because all it would do is
-	 * pfree a small amount of control storage.  It's cheaper to leak the
-	 * storage until the parsing context is destroyed.  The amount of space
-	 * involved is usually negligible compared to the output parse tree
-	 * anyway.
-	 *
-	 * We do bother to pfree the scanbuf and literal buffer, but only if they
-	 * represent a nontrivial amount of space.  The 8K cutoff is arbitrary.
-	 */
-	if (yyextra->scanbuflen >= 8192)
-		pfree(yyextra->scanbuf);
-	if (yyextra->literalalloc >= 8192)
-		pfree(yyextra->literalbuf);
-}
-
-
-static void
-addlit(char *ytext, int yleng, core_yyscan_t yyscanner)
-{
-	/* enlarge buffer if needed */
-	if ((yyextra->literallen + yleng) >= yyextra->literalalloc)
-	{
-		do
-		{
-			yyextra->literalalloc *= 2;
-		} while ((yyextra->literallen + yleng) >= yyextra->literalalloc);
-		yyextra->literalbuf = (char *) repalloc(yyextra->literalbuf,
-												yyextra->literalalloc);
-	}
-	/* append new data */
-	memcpy(yyextra->literalbuf + yyextra->literallen, ytext, yleng);
-	yyextra->literallen += yleng;
-}
-
-
-static void
-addlitchar(unsigned char ychar, core_yyscan_t yyscanner)
-{
-	/* enlarge buffer if needed */
-	if ((yyextra->literallen + 1) >= yyextra->literalalloc)
-	{
-		yyextra->literalalloc *= 2;
-		yyextra->literalbuf = (char *) repalloc(yyextra->literalbuf,
-												yyextra->literalalloc);
-	}
-	/* append new data */
-	yyextra->literalbuf[yyextra->literallen] = ychar;
-	yyextra->literallen += 1;
-}
-
-
-/*
- * Create a palloc'd copy of literalbuf, adding a trailing null.
- */
-static char *
-litbufdup(core_yyscan_t yyscanner)
-{
-	int			llen = yyextra->literallen;
-	char	   *newbuf;
-
-	newbuf = (char*) palloc(llen + 1);
-	memcpy(newbuf, yyextra->literalbuf, llen);
-	newbuf[llen] = '\0';
-	return newbuf;
-}
-
-static int
-process_integer_literal(const char *token, YYSTYPE *lval)
-{
-	int underscores = 0;
-	int len = 0;
-	for(char* cursor = (char*)token; *cursor != '\0'; cursor++)
-	{
-		len++;
-		if(*cursor == '_')
-			underscores++;
-	}
-
-	if(underscores != 0)
-	{
-		char* new_token = (char*)palloc(len - underscores + 1);
-		char* cursor = new_token;
-		for(char* old_cursor = (char*)token; *old_cursor != '\0'; old_cursor++)
-		{
-			if(*old_cursor != '_')
-				*cursor++ = *old_cursor;
-		}
-		*cursor = '\0';
-		token = new_token;
-	}
-
-	long		val;
-	char	   *endptr;
-
-	errno = 0;
-	val = strtol(token, &endptr, 10);
-	if (*endptr != '\0' || errno == ERANGE
-	/* if long > 32 bits, check for overflow of int4_t */
-		|| val != (long) ((int32_t) val) )
-	{
-		/* integer too large, treat it as a float */
-		lval->str = pstrdup(token);
-		return FCONST;
-	}
-	lval->ival = val;
-	return ICONST;
-}
-
-static unsigned int
-hexval(unsigned char c)
-{
-	if (c >= '0' && c <= '9')
-		return c - '0';
-	if (c >= 'a' && c <= 'f')
-		return c - 'a' + 0xA;
-	if (c >= 'A' && c <= 'F')
-		return c - 'A' + 0xA;
-	elog(ERROR, "invalid hexadecimal digit");
-	return 0;					/* not reached */
-}
-
-static void
-check_unicode_value(pg_wchar c, char *loc, core_yyscan_t yyscanner)
-{
-	// database encoding is always UTF8
-	// if (GetDatabaseEncoding() == PG_UTF8)
-	// 	return;
-
-	// if (c > 0x7F)
-	// {
-	// 	ADVANCE_YYLLOC(loc - yyextra->literalbuf + 3);	/* 3 for U&" */
-	// 	yyerror("Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8");
-	// }
-}
-
-static bool
-is_utf16_surrogate_first(pg_wchar c)
-{
-	return (c >= 0xD800 && c <= 0xDBFF);
-}
-
-static bool
-is_utf16_surrogate_second(pg_wchar c)
-{
-	return (c >= 0xDC00 && c <= 0xDFFF);
-}
-
-static pg_wchar
-surrogate_pair_to_codepoint(pg_wchar first, pg_wchar second)
-{
-	return ((first & 0x3FF) << 10) + 0x10000 + (second & 0x3FF);
-}
-
-static void
-addunicode(pg_wchar c, core_yyscan_t yyscanner)
-{
-	char		buf[8];
-
-	if (c == 0 || c > 0x10FFFF)
-		yyerror("invalid Unicode escape value");
-	if (c > 0x7F)
-	{
-		// if (GetDatabaseEncoding() != PG_UTF8)
-		// 	yyerror("Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8");
-		yyextra->saw_non_ascii = true;
-	}
-	unicode_to_utf8(c, (unsigned char *) buf);
-	addlit(buf, pg_mblen(buf), yyscanner);
-}
-
-/* is 'escape' acceptable as Unicode escape character (UESCAPE syntax) ? */
-static bool
-check_uescapechar(unsigned char escape)
-{
-	if (isxdigit(escape)
-		|| escape == '+'
-		|| escape == '\''
-		|| escape == '"'
-		|| scanner_isspace(escape))
-	{
-		return false;
-	}
-	else
-		return true;
-}
-
-/* like litbufdup, but handle unicode escapes */
-static char *
-litbuf_udeescape(unsigned char escape, core_yyscan_t yyscanner)
-{
-	char	   *newbuf;
-	char	   *litbuf,
-			   *in,
-			   *out;
-	pg_wchar	pair_first = 0;
-
-	/* Make literalbuf null-terminated to simplify the scanning loop */
-	litbuf = yyextra->literalbuf;
-	litbuf[yyextra->literallen] = '\0';
-
-	/*
-	 * This relies on the subtle assumption that a UTF-8 expansion cannot be
-	 * longer than its escaped representation.
-	 */
-	newbuf = (char*) palloc(yyextra->literallen + 1);
-
-	in = litbuf;
-	out = newbuf;
-	while (*in)
-	{
-		if (in[0] == escape)
-		{
-			if (in[1] == escape)
-			{
-				if (pair_first)
-				{
-					ADVANCE_YYLLOC(in - litbuf + 3);	/* 3 for U&" */
-					yyerror("invalid Unicode surrogate pair");
-				}
-				*out++ = escape;
-				in += 2;
-			}
-			else if (isxdigit((unsigned char) in[1]) &&
-					 isxdigit((unsigned char) in[2]) &&
-					 isxdigit((unsigned char) in[3]) &&
-					 isxdigit((unsigned char) in[4]))
-			{
-				pg_wchar	unicode;
-
-				unicode = (hexval(in[1]) << 12) +
-					(hexval(in[2]) << 8) +
-					(hexval(in[3]) << 4) +
-					hexval(in[4]);
-				check_unicode_value(unicode, in, yyscanner);
-				if (pair_first)
-				{
-					if (is_utf16_surrogate_second(unicode))
-					{
-						unicode = surrogate_pair_to_codepoint(pair_first, unicode);
-						pair_first = 0;
-					}
-					else
-					{
-						ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-						yyerror("invalid Unicode surrogate pair");
-					}
-				}
-				else if (is_utf16_surrogate_second(unicode))
-					yyerror("invalid Unicode surrogate pair");
-
-				if (is_utf16_surrogate_first(unicode))
-					pair_first = unicode;
-				else
-				{
-					unicode_to_utf8(unicode, (unsigned char *) out);
-					out += pg_mblen(out);
-				}
-				in += 5;
-			}
-			else if (in[1] == '+' &&
-					 isxdigit((unsigned char) in[2]) &&
-					 isxdigit((unsigned char) in[3]) &&
-					 isxdigit((unsigned char) in[4]) &&
-					 isxdigit((unsigned char) in[5]) &&
-					 isxdigit((unsigned char) in[6]) &&
-					 isxdigit((unsigned char) in[7]))
-			{
-				pg_wchar	unicode;
-
-				unicode = (hexval(in[2]) << 20) +
-					(hexval(in[3]) << 16) +
-					(hexval(in[4]) << 12) +
-					(hexval(in[5]) << 8) +
-					(hexval(in[6]) << 4) +
-					hexval(in[7]);
-				check_unicode_value(unicode, in, yyscanner);
-				if (pair_first)
-				{
-					if (is_utf16_surrogate_second(unicode))
-					{
-						unicode = surrogate_pair_to_codepoint(pair_first, unicode);
-						pair_first = 0;
-					}
-					else
-					{
-						ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-						yyerror("invalid Unicode surrogate pair");
-					}
-				}
-				else if (is_utf16_surrogate_second(unicode))
-					yyerror("invalid Unicode surrogate pair");
-
-				if (is_utf16_surrogate_first(unicode))
-					pair_first = unicode;
-				else
-				{
-					unicode_to_utf8(unicode, (unsigned char *) out);
-					out += pg_mblen(out);
-				}
-				in += 8;
-			}
-			else
-			{
-				ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-				yyerror("invalid Unicode escape value");
-			}
-		}
-		else
-		{
-			if (pair_first)
-			{
-				ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-				yyerror("invalid Unicode surrogate pair");
-			}
-			*out++ = *in++;
-		}
-	}
-
-	/* unfinished surrogate pair? */
-	if (pair_first)
-	{
-		ADVANCE_YYLLOC(in - litbuf + 3);				/* 3 for U&" */
-		yyerror("invalid Unicode surrogate pair");
-	}
-
-	*out = '\0';
-
-	/*
-	 * We could skip pg_verifymbstr if we didn't process any non-7-bit-ASCII
-	 * codes; but it's probably not worth the trouble, since this isn't likely
-	 * to be a performance-critical path.
-	 */
-	pg_verifymbstr(newbuf, out - newbuf, false);
-	return newbuf;
-}
-
-static unsigned char
-unescape_single_char(unsigned char c, core_yyscan_t yyscanner)
-{
-	switch (c)
-	{
-		case 'b':
-			return '\b';
-		case 'f':
-			return '\f';
-		case 'n':
-			return '\n';
-		case 'r':
-			return '\r';
-		case 't':
-			return '\t';
-		default:
-			/* check for backslash followed by non-7-bit-ASCII */
-			if (c == '\0' || IS_HIGHBIT_SET(c))
-				yyextra->saw_non_ascii = true;
-
-			return c;
-	}
-}
-
-static void
-check_string_escape_warning(unsigned char ychar, core_yyscan_t yyscanner)
-{
-	if (ychar == '\'')
-	{
-		if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
-			ereport(PGWARNING,
-					(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-					 errmsg("nonstandard use of \\' in a string literal"),
-					 errhint("Use '' to write quotes in strings, or use the escape string syntax (E'...')."),
-					 lexer_errposition()));
-		yyextra->warn_on_first_escape = false;	/* warn only once per string */
-	}
-	else if (ychar == '\\')
-	{
-		if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
-			ereport(PGWARNING,
-					(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-					 errmsg("nonstandard use of \\\\ in a string literal"),
-					 errhint("Use the escape string syntax for backslashes, e.g., E'\\\\'."),
-					 lexer_errposition()));
-		yyextra->warn_on_first_escape = false;	/* warn only once per string */
-	}
-	else
-		check_escape_warning(yyscanner);
-}
-
-static void
-check_escape_warning(core_yyscan_t yyscanner)
-{
-	if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
-		ereport(PGWARNING,
-				(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-				 errmsg("nonstandard use of escape in a string literal"),
-		errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
-				 lexer_errposition()));
-	yyextra->warn_on_first_escape = false;		/* warn only once per string */
-}
-
-/*
- * Interface functions to make flex use palloc() instead of malloc().
- * It'd be better to make these static, but flex insists otherwise.
- */
-
-void *
-core_yyalloc(yy_size_t bytes, core_yyscan_t yyscanner)
-{
-	return palloc(bytes);
-}
-
-void *
-core_yyrealloc(void *ptr, yy_size_t bytes, core_yyscan_t yyscanner)
-{
-	if (ptr)
-		return repalloc(ptr, bytes);
-	else
-		return palloc(bytes);
-}
-
-void
-core_yyfree(void *ptr, core_yyscan_t yyscanner)
-{
-	if (ptr)
-		pfree(ptr);
-}
-
-#undef yyerror
-#undef yylloc
-#undef yylval
-#undef yyin
-#undef yyout
-#undef yyextra
-#undef yyleng
-#undef yytext
-#undef yylineno
-#undef yycolumn
-#undef yy_flex_debug
-#undef yyless
-#undef YYSTYPE
-#undef YY_EXTRA_TYPE
-#undef SET_YYLLOC
-#undef ADVANCE_YYLLOC
-#undef BEGIN
-#undef REJECT
-#undef INITIAL
-#undef xb
-#undef xc
-#undef xd
-#undef xh
-#undef xe
-#undef xq
-#undef xdolq
-#undef xui
-#undef xuiend
-#undef xus
-#undef xusend
-#undef xeu
-#undef ECHO
-
-
-} /* duckdb_libpgquery */
diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp
deleted file mode 100644
index 0c5ed6843..000000000
--- a/src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - truncate_identifier
- * - downcase_truncate_identifier
- * - downcase_identifier
- * - scanner_isspace
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * scansup.c
- *	  support routines for the lex/flex scanner, used by both the normal
- * backend as well as the bootstrap backend
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/parser/scansup.c
- *
- *-------------------------------------------------------------------------
- */
-#include "pg_functions.hpp"
-#include <string.h>
-
-#include <ctype.h>
-
-#include "parser/scansup.hpp"
-#include "mb/pg_wchar.hpp"
-
-#ifdef __MVS__
-#include <zos-tls.h>
-#endif
-
-namespace duckdb_libpgquery {
-
-/* ----------------
- *		scanstr
- *
- * if the string passed in has escaped codes, map the escape codes to actual
- * chars
- *
- * the string returned is palloc'd and should eventually be pfree'd by the
- * caller!
- * ----------------
- */
-
-/*
- * downcase_truncate_identifier() --- do appropriate downcasing and
- * truncation of an unquoted identifier.  Optionally warn of truncation.
- *
- * Returns a palloc'd string containing the adjusted identifier.
- *
- * Note: in some usages the passed string is not null-terminated.
- *
- * Note: the API of this function is designed to allow for downcasing
- * transformations that increase the string length, but we don't yet
- * support that.  If you want to implement it, you'll need to fix
- * SplitIdentifierString() in utils/adt/varlena.c.
- */
-char *downcase_truncate_identifier(const char *ident, int len, bool warn) {
-	return downcase_identifier(ident, len, warn, true);
-}
-
-#ifdef __MVS__
-static __tlssim<bool> pg_preserve_identifier_case_impl(false);
-#define pg_preserve_identifier_case (*pg_preserve_identifier_case_impl.access())
-#else
-static __thread bool pg_preserve_identifier_case = false;
-#endif
-
-void set_preserve_identifier_case(bool preserve) {
-	pg_preserve_identifier_case = preserve;
-}
-
-bool get_preserve_identifier_case() {
-	return pg_preserve_identifier_case;
-}
-
-/*
- * a workhorse for downcase_truncate_identifier
- */
-char *downcase_identifier(const char *ident, int len, bool warn, bool truncate) {
-	char *result;
-	int i;
-	bool enc_is_single_byte;
-
-	result = (char *)palloc(len + 1);
-	enc_is_single_byte = pg_database_encoding_max_length() == 1;
-
-	/*
-	 * SQL99 specifies Unicode-aware case normalization, which we don't yet
-	 * have the infrastructure for.  Instead we use tolower() to provide a
-	 * locale-aware translation.  However, there are some locales where this
-	 * is not right either (eg, Turkish may do strange things with 'i' and
-	 * 'I').  Our current compromise is to use tolower() for characters with
-	 * the high bit set, as long as they aren't part of a multi-byte
-	 * character, and use an ASCII-only downcasing for 7-bit characters.
-	 */
-	for (i = 0; i < len; i++) {
-		unsigned char ch = (unsigned char)ident[i];
-
-		if (!get_preserve_identifier_case()) {
-			if (ch >= 'A' && ch <= 'Z')
-				ch += 'a' - 'A';
-			else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
-				ch = tolower(ch);
-		}
-		result[i] = (char)ch;
-	}
-	result[i] = '\0';
-
-	return result;
-}
-
-/*
- * scanner_isspace() --- return true if flex scanner considers char whitespace
- *
- * This should be used instead of the potentially locale-dependent isspace()
- * function when it's important to match the lexer's behavior.
- *
- * In principle we might need similar functions for isalnum etc, but for the
- * moment only isspace seems needed.
- */
-bool scanner_isspace(char ch) {
-	/* This must match scan.l's list of {space} characters */
-	if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\f')
-		return true;
-	return false;
-}
-}
diff --git a/src/duckdb/third_party/libpg_query/src_common_keywords.cpp b/src/duckdb/third_party/libpg_query/src_common_keywords.cpp
deleted file mode 100644
index 1549a5d17..000000000
--- a/src/duckdb/third_party/libpg_query/src_common_keywords.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - ScanKeywords
- * - NumScanKeywords
- * - ScanKeywordLookup
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * keywords.c
- *	  lexical token lookup for key words in PostgreSQL
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/common/keywords.c
- *
- *-------------------------------------------------------------------------
- */
-#include "pg_functions.hpp"
-#include <string.h>
-#include <string>
-#include <memory>
-#include "parser/gramparse.hpp"
-
-#include "parser/kwlist.hpp"
-
-namespace duckdb_libpgquery {
-
-/*
- * ScanKeywordLookup - see if a given word is a keyword
- *
- * The table to be searched is passed explicitly, so that this can be used
- * to search keyword lists other than the standard list appearing above.
- *
- * Returns a pointer to the PGScanKeyword table entry, or NULL if no match.
- *
- * The match is done case-insensitively.  Note that we deliberately use a
- * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z',
- * even if we are in a locale where tolower() would produce more or different
- * translations.  This is to conform to the SQL99 spec, which says that
- * keywords are to be matched in this way even though non-keyword identifiers
- * receive a different case-normalization mapping.
- */
-const PGScanKeyword *ScanKeywordLookup(const char *text, const PGScanKeyword *keywords, int num_keywords) {
-	int len, i;
-	const PGScanKeyword *low;
-	const PGScanKeyword *high;
-
-	len = strlen(text);
-	auto data = std::unique_ptr<char[]>(new char[len + 1]);
-	auto word = data.get();
-	/* We assume all keywords are shorter than NAMEDATALEN. */
-
-	/*
-	 * Apply an ASCII-only downcasing.  We must not use tolower() since it may
-	 * produce the wrong translation in some locales (eg, Turkish).
-	 */
-	for (i = 0; i < len; i++) {
-		char ch = text[i];
-
-		if (ch >= 'A' && ch <= 'Z')
-			ch += 'a' - 'A';
-		word[i] = ch;
-	}
-	word[len] = '\0';
-
-	/*
-	 * Now do a binary search using plain strcmp() comparison.
-	 */
-	low = keywords;
-	high = keywords + (num_keywords - 1);
-	while (low <= high) {
-		const PGScanKeyword *middle;
-		int difference;
-
-		middle = low + (high - low) / 2;
-		difference = strcmp(middle->name, word);
-		if (difference == 0)
-			return middle;
-		else if (difference < 0)
-			low = middle + 1;
-		else
-			high = middle - 1;
-	}
-
-	return NULL;
-}
-}
diff --git a/src/duckdb/third_party/lz4/lz4.cpp b/src/duckdb/third_party/lz4/lz4.cpp
deleted file mode 100644
index 3d11bfca4..000000000
--- a/src/duckdb/third_party/lz4/lz4.cpp
+++ /dev/null
@@ -1,2605 +0,0 @@
-/*
-   LZ4 - Fast LZ compression algorithm
-   Copyright (C) 2011-2020, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN 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.
-
-   You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
-*/
-
-/*-************************************
-*  Tuning parameters
-**************************************/
-/*
- * LZ4_HEAPMODE :
- * Select how default compression functions will allocate memory for their hash table,
- * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
- */
-#ifndef LZ4_HEAPMODE
-#  define LZ4_HEAPMODE 0
-#endif
-
-/*
- * LZ4_ACCELERATION_DEFAULT :
- * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
- */
-#define LZ4_ACCELERATION_DEFAULT 1
-/*
- * LZ4_ACCELERATION_MAX :
- * Any "acceleration" value higher than this threshold
- * get treated as LZ4_ACCELERATION_MAX instead (fix #876)
- */
-#define LZ4_ACCELERATION_MAX 65537
-
-
-/*-************************************
-*  CPU Feature Detection
-**************************************/
-/* LZ4_FORCE_MEMORY_ACCESS
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method is portable but violate C standard.
- *            It can generate buggy code on targets which assembly generation depends on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
-#  if defined(__GNUC__) && \
-  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
-  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define LZ4_FORCE_MEMORY_ACCESS 2
-#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__)
-#    define LZ4_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*
- * LZ4_FORCE_SW_BITCOUNT
- * Define this parameter if your target system or compiler does not support hardware bit count
- */
-#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */
-#  undef  LZ4_FORCE_SW_BITCOUNT  /* avoid double def */
-#  define LZ4_FORCE_SW_BITCOUNT
-#endif
-
-
-
-/*-************************************
-*  Dependency
-**************************************/
-/*
- * LZ4_SRC_INCLUDED:
- * Amalgamation flag, whether lz4.c is included
- */
-#ifndef LZ4_SRC_INCLUDED
-#  define LZ4_SRC_INCLUDED 1
-#endif
-
-#ifndef LZ4_STATIC_LINKING_ONLY
-#define LZ4_STATIC_LINKING_ONLY
-#endif
-
-#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS
-#define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */
-#endif
-
-#define LZ4_STATIC_LINKING_ONLY  /* LZ4_DISTANCE_MAX */
-#include <stdlib.h>
-
-#include "lz4.hpp"
-/* see also "memory routines" below */
-
-
-/*-************************************
-*  Compiler Options
-**************************************/
-
-#define LZ4_FORCE_INLINE static
-#define LZ4_FORCE_O2
-
-#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
-#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
-#else
-#  define expect(expr,value)    (expr)
-#endif
-
-#ifndef likely
-#define likely(expr)     expect((expr) != 0, 1)
-#endif
-#ifndef unlikely
-#define unlikely(expr)   expect((expr) != 0, 0)
-#endif
-
-/* Should the alignment test prove unreliable, for some reason,
- * it can be disabled by setting LZ4_ALIGN_TEST to 0 */
-#ifndef LZ4_ALIGN_TEST  /* can be externally provided */
-# define LZ4_ALIGN_TEST 1
-#endif
-
-namespace duckdb_lz4 {
-/*-************************************
-*  Memory routines
-**************************************/
-
-/*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION :
- *  Disable relatively high-level LZ4/HC functions that use dynamic memory
- *  allocation functions (malloc(), calloc(), free()).
- *
- *  Note that this is a compile-time switch. And since it disables
- *  public/stable LZ4 v1 API functions, we don't recommend using this
- *  symbol to generate a library for distribution.
- *
- *  The following public functions are removed when this symbol is defined.
- *  - lz4   : LZ4_createStream, LZ4_freeStream,
- *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)
- *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,
- *            LZ4_createHC (deprecated), LZ4_freeHC  (deprecated)
- *  - lz4frame, lz4file : All LZ4F_* functions
- */
-#if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-#  define ALLOC(s)          lz4_error_memory_allocation_is_disabled
-#  define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled
-#  define FREEMEM(p)        lz4_error_memory_allocation_is_disabled
-#elif defined(LZ4_USER_MEMORY_FUNCTIONS)
-/* memory management functions can be customized by user project.
- * Below functions must exist somewhere in the Project
- * and be available at link time */
-void* LZ4_malloc(size_t s);
-void* LZ4_calloc(size_t n, size_t s);
-void  LZ4_free(void* p);
-# define ALLOC(s)          LZ4_malloc(s)
-# define ALLOC_AND_ZERO(s) LZ4_calloc(1,s)
-# define FREEMEM(p)        LZ4_free(p)
-#else
-# include <stdlib.h>   /* malloc, calloc, free */
-# define ALLOC(s)          malloc(s)
-# define ALLOC_AND_ZERO(s) calloc(1,s)
-# define FREEMEM(p)        free(p)
-#endif
-
-#if ! LZ4_FREESTANDING
-#  include <string.h>   /* memset, memcpy */
-#endif
-#if !defined(LZ4_memset)
-#  define LZ4_memset(p,v,s) memset((p),(v),(s))
-#endif
-#define MEM_INIT(p,v,s)   LZ4_memset((p),(v),(s))
-
-
-/*-************************************
-*  Common Constants
-**************************************/
-#define MINMATCH 4
-
-#define WILDCOPYLENGTH 8
-#define LASTLITERALS   5   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
-#define MFLIMIT       12   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
-#define MATCH_SAFEGUARD_DISTANCE  ((2*WILDCOPYLENGTH) - MINMATCH)   /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */
-#define FASTLOOP_SAFE_DISTANCE 64
-static const int LZ4_minLength = (MFLIMIT+1);
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define LZ4_DISTANCE_ABSOLUTE_MAX 65535
-#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX)   /* max supported by LZ4 format */
-#  error "LZ4_DISTANCE_MAX is too big : must be <= 65535"
-#endif
-
-#define ML_BITS  4
-#define ML_MASK  ((1U<<ML_BITS)-1)
-#define RUN_BITS (8-ML_BITS)
-#define RUN_MASK ((1U<<RUN_BITS)-1)
-
-
-/*-************************************
-*  Error detection
-**************************************/
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
-#  include <assert.h>
-#else
-#  ifndef assert
-#    define assert(condition) ((void)0)
-#  endif
-#endif
-
-#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */
-
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
-#  include <stdio.h>
-   static int g_debuglog_enable = 1;
-#  define DEBUGLOG(l, ...) {                          \
-        if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-            fprintf(stderr, __FILE__ ": ");           \
-            fprintf(stderr, __VA_ARGS__);             \
-            fprintf(stderr, " \n");                   \
-    }   }
-#else
-#  define DEBUGLOG(l, ...) {}    /* disabled */
-#endif
-
-static int LZ4_isAligned(const void* ptr, size_t alignment)
-{
-    return ((size_t)ptr & (alignment -1)) == 0;
-}
-
-
-/*-************************************
-*  Types
-**************************************/
-#include <limits.h>
-#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef uintptr_t uptrval;
-#else
-# if UINT_MAX != 4294967295UL
-#   error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4"
-# endif
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef size_t              uptrval;   /* generally true, except OpenVMS-64 */
-#endif
-
-#if defined(__x86_64__)
-  typedef U64    reg_t;   /* 64-bits in x32 mode */
-#else
-  typedef size_t reg_t;   /* 32-bits in x32 mode */
-#endif
-
-typedef enum {
-    notLimited = 0,
-    limitedOutput = 1,
-    fillOutput = 2
-} limitedOutput_directive;
-
-
-/*-************************************
-*  Reading and writing into memory
-**************************************/
-
-/**
- * LZ4 relies on memcpy with a constant size being inlined. In freestanding
- * environments, the compiler can't assume the implementation of memcpy() is
- * standard compliant, so it can't apply its specialized memcpy() inlining
- * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze
- * memcpy() as if it were standard compliant, so it can inline it in freestanding
- * environments. This is needed when decompressing the Linux Kernel, for example.
- */
-#if !defined(LZ4_memcpy)
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size)
-#  else
-#    define LZ4_memcpy(dst, src, size) memcpy(dst, src, size)
-#  endif
-#endif
-
-#if !defined(LZ4_memmove)
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4_memmove __builtin_memmove
-#  else
-#    define LZ4_memmove memmove
-#  endif
-#endif
-
-static unsigned LZ4_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
-    return one.c[0];
-}
-
-
-#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
-/* lie to the compiler about data alignment; use with caution */
-
-static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; }
-static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; }
-static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; }
-
-static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-
-#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) LZ4_unalign;
-
-static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign*)ptr)->u16; }
-static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign*)ptr)->u32; }
-static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalign*)ptr)->uArch; }
-
-static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign*)memPtr)->u16 = value; }
-static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign*)memPtr)->u32 = value; }
-
-#else  /* safe and portable access using memcpy() */
-
-static U16 LZ4_read16(const void* memPtr)
-{
-    U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static U32 LZ4_read32(const void* memPtr)
-{
-    U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static reg_t LZ4_read_ARCH(const void* memPtr)
-{
-    reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static void LZ4_write16(void* memPtr, U16 value)
-{
-    LZ4_memcpy(memPtr, &value, sizeof(value));
-}
-
-static void LZ4_write32(void* memPtr, U32 value)
-{
-    LZ4_memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* LZ4_FORCE_MEMORY_ACCESS */
-
-
-static U16 LZ4_readLE16(const void* memPtr)
-{
-    if (LZ4_isLittleEndian()) {
-        return LZ4_read16(memPtr);
-    } else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)((U16)p[0] + (p[1]<<8));
-    }
-}
-
-static void LZ4_writeLE16(void* memPtr, U16 value)
-{
-    if (LZ4_isLittleEndian()) {
-        LZ4_write16(memPtr, value);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE) value;
-        p[1] = (BYTE)(value>>8);
-    }
-}
-
-/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
-LZ4_FORCE_INLINE
-void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
-{
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
-
-    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
-}
-
-static const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
-static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
-
-
-#ifndef LZ4_FAST_DEC_LOOP
-#  if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64
-#    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && defined(__APPLE__)
-#    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && !defined(__clang__)
-     /* On non-Apple aarch64, we disable this optimization for clang because
-      * on certain mobile chipsets, performance is reduced with clang. For
-      * more information refer to https://github.com/lz4/lz4/pull/707 */
-#    define LZ4_FAST_DEC_LOOP 1
-#  else
-#    define LZ4_FAST_DEC_LOOP 0
-#  endif
-#endif
-
-#if LZ4_FAST_DEC_LOOP
-
-LZ4_FORCE_INLINE void
-LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
-{
-    assert(srcPtr + offset == dstPtr);
-    if (offset < 8) {
-        LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */
-        dstPtr[0] = srcPtr[0];
-        dstPtr[1] = srcPtr[1];
-        dstPtr[2] = srcPtr[2];
-        dstPtr[3] = srcPtr[3];
-        srcPtr += inc32table[offset];
-        LZ4_memcpy(dstPtr+4, srcPtr, 4);
-        srcPtr -= dec64table[offset];
-        dstPtr += 8;
-    } else {
-        LZ4_memcpy(dstPtr, srcPtr, 8);
-        dstPtr += 8;
-        srcPtr += 8;
-    }
-
-    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
-}
-
-/* customized variant of memcpy, which can overwrite up to 32 bytes beyond dstEnd
- * this version copies two times 16 bytes (instead of one time 32 bytes)
- * because it must be compatible with offsets >= 16. */
-LZ4_FORCE_INLINE void
-LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
-{
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
-
-    do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
-}
-
-/* LZ4_memcpy_using_offset()  presumes :
- * - dstEnd >= dstPtr + MINMATCH
- * - there is at least 8 bytes available to write after dstEnd */
-LZ4_FORCE_INLINE void
-LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
-{
-    BYTE v[8];
-
-    assert(dstEnd >= dstPtr + MINMATCH);
-
-    switch(offset) {
-    case 1:
-        MEM_INIT(v, *srcPtr, 8);
-        break;
-    case 2:
-        LZ4_memcpy(v, srcPtr, 2);
-        LZ4_memcpy(&v[2], srcPtr, 2);
-#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */
-#  pragma warning(push)
-#  pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */
-#endif
-        LZ4_memcpy(&v[4], v, 4);
-#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */
-#  pragma warning(pop)
-#endif
-        break;
-    case 4:
-        LZ4_memcpy(v, srcPtr, 4);
-        LZ4_memcpy(&v[4], srcPtr, 4);
-        break;
-    default:
-        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
-        return;
-    }
-
-    LZ4_memcpy(dstPtr, v, 8);
-    dstPtr += 8;
-    while (dstPtr < dstEnd) {
-        LZ4_memcpy(dstPtr, v, 8);
-        dstPtr += 8;
-    }
-}
-#endif
-
-
-/*-************************************
-*  Common functions
-**************************************/
-static unsigned LZ4_NbCommonBytes (reg_t val)
-{
-    assert(val != 0);
-    if (LZ4_isLittleEndian()) {
-        if (sizeof(val) == 8) {
-            const U64 m = 0x0101010101010101ULL;
-            val ^= val - 1;
-            return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56);
-        } else /* 32 bits */ {
-            const U32 m = 0x01010101;
-            return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
-        }
-    } else   /* Big Endian CPU */ {
-		assert(false);
-		return 0;
-    }
-}
-
-
-#define STEPSIZE sizeof(reg_t)
-LZ4_FORCE_INLINE
-unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-{
-    const BYTE* const pStart = pIn;
-
-    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) {
-            pIn+=STEPSIZE; pMatch+=STEPSIZE;
-        } else {
-            return LZ4_NbCommonBytes(diff);
-    }   }
-
-    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
-        pIn += LZ4_NbCommonBytes(diff);
-        return (unsigned)(pIn - pStart);
-    }
-
-    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (unsigned)(pIn - pStart);
-}
-
-
-#ifndef LZ4_COMMONDEFS_ONLY
-/*-************************************
-*  Local Constants
-**************************************/
-static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
-static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
-
-
-/*-************************************
-*  Local Structures and types
-**************************************/
-typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;
-
-/**
- * This enum distinguishes several different modes of accessing previous
- * content in the stream.
- *
- * - noDict        : There is no preceding content.
- * - withPrefix64k : Table entries up to ctx->dictSize before the current blob
- *                   blob being compressed are valid and refer to the preceding
- *                   content (of length ctx->dictSize), which is available
- *                   contiguously preceding in memory the content currently
- *                   being compressed.
- * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere
- *                   else in memory, starting at ctx->dictionary with length
- *                   ctx->dictSize.
- * - usingDictCtx  : Everything concerning the preceding content is
- *                   in a separate context, pointed to by ctx->dictCtx.
- *                   ctx->dictionary, ctx->dictSize, and table entries
- *                   in the current context that refer to positions
- *                   preceding the beginning of the current compression are
- *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx
- *                   ->dictSize describe the location and size of the preceding
- *                   content, and matches are found by looking in the ctx
- *                   ->dictCtx->hashTable.
- */
-typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;
-typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
-
-
-/*-************************************
-*  Local Utils
-**************************************/
-int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
-const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; }
-int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
-int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); }
-
-
-/*-****************************************
-*  Internal Definitions, used only in Tests
-*******************************************/
-//#if defined (__cplusplus)
-//extern "C" {
-//#endif
-
-int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize);
-
-int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int maxOutputSize,
-                                     const void* dictStart, size_t dictSize);
-int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int targetOutputSize, int dstCapacity,
-                                     const void* dictStart, size_t dictSize);
-//#if defined (__cplusplus)
-//}
-//#endif
-
-/*-******************************
-*  Compression functions
-********************************/
-LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
-{
-    if (tableType == byU16)
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
-    else
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
-}
-
-LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
-{
-    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
-    if (LZ4_isLittleEndian()) {
-        const U64 prime5bytes = 889523592379ULL;
-        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
-    } else {
-        const U64 prime8bytes = 11400714785074694791ULL;
-        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
-    }
-}
-
-LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
-{
-    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
-    return LZ4_hash4(LZ4_read32(p), tableType);
-}
-
-LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
-{
-    switch (tableType)
-    {
-    default: /* fallthrough */
-    case clearedTable: { /* illegal! */ assert(0); return; }
-    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
-{
-    switch (tableType)
-    {
-    default: /* fallthrough */
-    case clearedTable: /* fallthrough */
-    case byPtr: { /* illegal! */ assert(0); return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h,
-                                  void* tableBase, tableType_t const tableType,
-                            const BYTE* srcBase)
-{
-    switch (tableType)
-    {
-    case clearedTable: { /* illegal! */ assert(0); return; }
-    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-{
-    U32 const h = LZ4_hashPosition(p, tableType);
-    LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
-}
-
-/* LZ4_getIndexOnHash() :
- * Index of match position registered in hash table.
- * hash position must be calculated by using base+index, or dictBase+index.
- * Assumption 1 : only valid if tableType == byU32 or byU16.
- * Assumption 2 : h is presumed valid (within limits of hash table)
- */
-LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
-{
-    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
-    if (tableType == byU32) {
-        const U32* const hashTable = (const U32*) tableBase;
-        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
-        return hashTable[h];
-    }
-    if (tableType == byU16) {
-        const U16* const hashTable = (const U16*) tableBase;
-        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
-        return hashTable[h];
-    }
-    assert(0); return 0;  /* forbidden case */
-}
-
-static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType, const BYTE* srcBase)
-{
-    if (tableType == byPtr) { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
-    if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; return hashTable[h] + srcBase; }
-    { const U16* const hashTable = (const U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
-}
-
-LZ4_FORCE_INLINE const BYTE*
-LZ4_getPosition(const BYTE* p,
-                const void* tableBase, tableType_t tableType,
-                const BYTE* srcBase)
-{
-    U32 const h = LZ4_hashPosition(p, tableType);
-    return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
-}
-
-LZ4_FORCE_INLINE void
-LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
-           const int inputSize,
-           const tableType_t tableType) {
-    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
-     * therefore safe to use no matter what mode we're in. Otherwise, we figure
-     * out if it's safe to leave as is or whether it needs to be reset.
-     */
-    if ((tableType_t)cctx->tableType != clearedTable) {
-        assert(inputSize >= 0);
-        if ((tableType_t)cctx->tableType != tableType
-          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
-          || ((tableType == byU32) && cctx->currentOffset > 1 GB)
-          || tableType == byPtr
-          || inputSize >= 4 KB)
-        {
-            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
-            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
-            cctx->currentOffset = 0;
-            cctx->tableType = (U32)clearedTable;
-        } else {
-            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
-        }
-    }
-
-    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back,
-     * is faster than compressing without a gap.
-     * However, compressing with currentOffset == 0 is faster still,
-     * so we preserve that case.
-     */
-    if (cctx->currentOffset != 0 && tableType == byU32) {
-        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
-        cctx->currentOffset += 64 KB;
-    }
-
-    /* Finally, clear history */
-    cctx->dictCtx = NULL;
-    cctx->dictionary = NULL;
-    cctx->dictSize = 0;
-}
-
-/** LZ4_compress_generic() :
- *  inlined, to ensure branches are decided at compilation time.
- *  Presumed already validated at this stage:
- *  - source != NULL
- *  - inputSize > 0
- */
-LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const source,
-                 char* const dest,
-                 const int inputSize,
-                 int*  inputConsumed, /* only written when outputDirective == fillOutput */
-                 const int maxOutputSize,
-                 const limitedOutput_directive outputDirective,
-                 const tableType_t tableType,
-                 const dict_directive dictDirective,
-                 const dictIssue_directive dictIssue,
-                 const int acceleration)
-{
-    int result;
-    const BYTE* ip = (const BYTE*) source;
-
-    U32 const startIndex = cctx->currentOffset;
-    const BYTE* base = (const BYTE*) source - startIndex;
-    const BYTE* lowLimit;
-
-    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
-    const BYTE* const dictionary =
-        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
-    const U32 dictSize =
-        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
-    const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with index in current context */
-
-    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
-    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
-    const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary;
-    const BYTE* anchor = (const BYTE*) source;
-    const BYTE* const iend = ip + inputSize;
-    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-
-    /* the dictCtx currentOffset is indexed on the start of the dictionary,
-     * while a dictionary in the current context precedes the currentOffset */
-    const BYTE* dictBase = (dictionary == NULL) ? NULL :
-                           (dictDirective == usingDictCtx) ?
-                            dictionary + dictSize - dictCtx->currentOffset :
-                            dictionary + dictSize - startIndex;
-
-    BYTE* op = (BYTE*) dest;
-    BYTE* const olimit = op + maxOutputSize;
-
-    U32 offset = 0;
-    U32 forwardH;
-
-    DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType);
-    assert(ip != NULL);
-    /* If init conditions are not met, we don't have to mark stream
-     * as having dirty context, since no action was taken yet */
-    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */
-    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) { return 0; }  /* Size too large (not within 64K limit) */
-    if (tableType==byPtr) assert(dictDirective==noDict);      /* only supported use case with byPtr */
-    assert(acceleration >= 1);
-
-    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
-
-    /* Update context state */
-    if (dictDirective == usingDictCtx) {
-        /* Subsequent linked blocks can't use the dictionary. */
-        /* Instead, they use the block we just compressed. */
-        cctx->dictCtx = NULL;
-        cctx->dictSize = (U32)inputSize;
-    } else {
-        cctx->dictSize += (U32)inputSize;
-    }
-    cctx->currentOffset += (U32)inputSize;
-    cctx->tableType = (U32)tableType;
-
-    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
-
-    /* First Byte */
-    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-
-    /* Main Loop */
-    for ( ; ; ) {
-        const BYTE* match;
-        BYTE* token;
-        const BYTE* filledIp;
-
-        /* Find a match */
-        if (tableType == byPtr) {
-            const BYTE* forwardIp = ip;
-            int step = 1;
-            int searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-                assert(ip < mflimitPlusOne);
-
-                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
-
-            } while ( (match+LZ4_DISTANCE_MAX < ip)
-                   || (LZ4_read32(match) != LZ4_read32(ip)) );
-
-        } else {   /* byU32, byU16 */
-
-            const BYTE* forwardIp = ip;
-            int step = 1;
-            int searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                U32 const current = (U32)(forwardIp - base);
-                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-                assert(matchIndex <= current);
-                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-                assert(ip < mflimitPlusOne);
-
-                if (dictDirective == usingDictCtx) {
-                    if (matchIndex < startIndex) {
-                        /* there was no match, try the dictionary */
-                        assert(tableType == byU32);
-                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-                        match = dictBase + matchIndex;
-                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
-                        lowLimit = dictionary;
-                    } else {
-                        match = base + matchIndex;
-                        lowLimit = (const BYTE*)source;
-                    }
-                } else if (dictDirective == usingExtDict) {
-                    if (matchIndex < startIndex) {
-                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
-                        assert(startIndex - matchIndex >= MINMATCH);
-                        assert(dictBase);
-                        match = dictBase + matchIndex;
-                        lowLimit = dictionary;
-                    } else {
-                        match = base + matchIndex;
-                        lowLimit = (const BYTE*)source;
-                    }
-                } else {   /* single continuous memory segment */
-                    match = base + matchIndex;
-                }
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-
-                DEBUGLOG(7, "candidate at pos=%u  (offset=%u \n", matchIndex, current - matchIndex);
-                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; }    /* match outside of valid area */
-                assert(matchIndex < current);
-                if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX))
-                  && (matchIndex+LZ4_DISTANCE_MAX < current)) {
-                    continue;
-                } /* too far */
-                assert((current - matchIndex) <= LZ4_DISTANCE_MAX);  /* match now expected within distance */
-
-                if (LZ4_read32(match) == LZ4_read32(ip)) {
-                    if (maybe_extMem) offset = current - matchIndex;
-                    break;   /* match found */
-                }
-
-            } while(1);
-        }
-
-        /* Catch up */
-        filledIp = ip;
-        while (((ip>anchor) & (match > lowLimit)) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
-
-        /* Encode Literals */
-        {   unsigned const litLength = (unsigned)(ip - anchor);
-            token = op++;
-            if ((outputDirective == limitedOutput) &&  /* Check output buffer overflow */
-                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) {
-                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-            }
-            if ((outputDirective == fillOutput) &&
-                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
-                op--;
-                goto _last_literals;
-            }
-            if (litLength >= RUN_MASK) {
-                int len = (int)(litLength - RUN_MASK);
-                *token = (RUN_MASK<<ML_BITS);
-                for(; len >= 255 ; len-=255) *op++ = 255;
-                *op++ = (BYTE)len;
-            }
-            else *token = (BYTE)(litLength<<ML_BITS);
-
-            /* Copy Literals */
-            LZ4_wildCopy8(op, anchor, op+litLength);
-            op+=litLength;
-            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
-        }
-
-_next_match:
-        /* at this stage, the following variables must be correctly set :
-         * - ip : at start of LZ operation
-         * - match : at start of previous pattern occurrence; can be within current prefix, or within extDict
-         * - offset : if maybe_ext_memSegment==1 (constant)
-         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
-         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
-         */
-
-        if ((outputDirective == fillOutput) &&
-            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
-            /* the match was too close to the end, rewind and go to last literals */
-            op = token;
-            goto _last_literals;
-        }
-
-        /* Encode Offset */
-        if (maybe_extMem) {   /* static test */
-            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
-            assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
-            LZ4_writeLE16(op, (U16)offset); op+=2;
-        } else  {
-            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
-            assert(ip-match <= LZ4_DISTANCE_MAX);
-            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
-        }
-
-        /* Encode MatchLength */
-        {   unsigned matchCode;
-
-            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
-              && (lowLimit==dictionary) /* match within extDict */ ) {
-                const BYTE* limit = ip + (dictEnd-match);
-                assert(dictEnd > match);
-                if (limit > matchlimit) limit = matchlimit;
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
-                ip += (size_t)matchCode + MINMATCH;
-                if (ip==limit) {
-                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
-                    matchCode += more;
-                    ip += more;
-                }
-                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
-            } else {
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-                ip += (size_t)matchCode + MINMATCH;
-                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
-            }
-
-            if ((outputDirective) &&    /* Check output buffer overflow */
-                (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) {
-                if (outputDirective == fillOutput) {
-                    /* Match description too long : reduce it */
-                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255;
-                    ip -= matchCode - newMatchCode;
-                    assert(newMatchCode < matchCode);
-                    matchCode = newMatchCode;
-                    if (unlikely(ip <= filledIp)) {
-                        /* We have already filled up to filledIp so if ip ends up less than filledIp
-                         * we have positions in the hash table beyond the current position. This is
-                         * a problem if we reuse the hash table. So we have to remove these positions
-                         * from the hash table.
-                         */
-                        const BYTE* ptr;
-                        DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip));
-                        for (ptr = ip; ptr <= filledIp; ++ptr) {
-                            U32 const h = LZ4_hashPosition(ptr, tableType);
-                            LZ4_clearHash(h, cctx->hashTable, tableType);
-                        }
-                    }
-                } else {
-                    assert(outputDirective == limitedOutput);
-                    return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-                }
-            }
-            if (matchCode >= ML_MASK) {
-                *token += ML_MASK;
-                matchCode -= ML_MASK;
-                LZ4_write32(op, 0xFFFFFFFF);
-                while (matchCode >= 4*255) {
-                    op+=4;
-                    LZ4_write32(op, 0xFFFFFFFF);
-                    matchCode -= 4*255;
-                }
-                op += matchCode / 255;
-                *op++ = (BYTE)(matchCode % 255);
-            } else
-                *token += (BYTE)(matchCode);
-        }
-        /* Ensure we have enough space for the last literals. */
-        assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit));
-
-        anchor = ip;
-
-        /* Test end of chunk */
-        if (ip >= mflimitPlusOne) break;
-
-        /* Fill table */
-        LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
-
-        /* Test next position */
-        if (tableType == byPtr) {
-
-            match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
-            LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-            if ( (match+LZ4_DISTANCE_MAX >= ip)
-              && (LZ4_read32(match) == LZ4_read32(ip)) )
-            { token=op++; *token=0; goto _next_match; }
-
-        } else {   /* byU32, byU16 */
-
-            U32 const h = LZ4_hashPosition(ip, tableType);
-            U32 const current = (U32)(ip-base);
-            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-            assert(matchIndex < current);
-            if (dictDirective == usingDictCtx) {
-                if (matchIndex < startIndex) {
-                    /* there was no match, try the dictionary */
-                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-                    match = dictBase + matchIndex;
-                    lowLimit = dictionary;   /* required for match length counter */
-                    matchIndex += dictDelta;
-                } else {
-                    match = base + matchIndex;
-                    lowLimit = (const BYTE*)source;  /* required for match length counter */
-                }
-            } else if (dictDirective==usingExtDict) {
-                if (matchIndex < startIndex) {
-                    assert(dictBase);
-                    match = dictBase + matchIndex;
-                    lowLimit = dictionary;   /* required for match length counter */
-                } else {
-                    match = base + matchIndex;
-                    lowLimit = (const BYTE*)source;   /* required for match length counter */
-                }
-            } else {   /* single memory segment */
-                match = base + matchIndex;
-            }
-            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-            assert(matchIndex < current);
-            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
-              && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current))
-              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
-                token=op++;
-                *token=0;
-                if (maybe_extMem) offset = current - matchIndex;
-                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
-                goto _next_match;
-            }
-        }
-
-        /* Prepare next loop */
-        forwardH = LZ4_hashPosition(++ip, tableType);
-
-    }
-
-_last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRun = (size_t)(iend - anchor);
-        if ( (outputDirective) &&  /* Check output buffer overflow */
-            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
-            if (outputDirective == fillOutput) {
-                /* adapt lastRun to fill 'dst' */
-                assert(olimit >= op);
-                lastRun  = (size_t)(olimit-op) - 1/*token*/;
-                lastRun -= (lastRun + 256 - RUN_MASK) / 256;  /*additional length tokens*/
-            } else {
-                assert(outputDirective == limitedOutput);
-                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-            }
-        }
-        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun);
-        if (lastRun >= RUN_MASK) {
-            size_t accumulator = lastRun - RUN_MASK;
-            *op++ = RUN_MASK << ML_BITS;
-            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRun<<ML_BITS);
-        }
-        LZ4_memcpy(op, anchor, lastRun);
-        ip = anchor + lastRun;
-        op += lastRun;
-    }
-
-    if (outputDirective == fillOutput) {
-        *inputConsumed = (int) (((const char*)ip)-source);
-    }
-    result = (int)(((char*)op) - dest);
-    assert(result > 0);
-    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result);
-    return result;
-}
-
-/** LZ4_compress_generic() :
- *  inlined, to ensure branches are decided at compilation time;
- *  takes care of src == (NULL, 0)
- *  and forward the rest to LZ4_compress_generic_validated */
-LZ4_FORCE_INLINE int LZ4_compress_generic(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const src,
-                 char* const dst,
-                 const int srcSize,
-                 int *inputConsumed, /* only written when outputDirective == fillOutput */
-                 const int dstCapacity,
-                 const limitedOutput_directive outputDirective,
-                 const tableType_t tableType,
-                 const dict_directive dictDirective,
-                 const dictIssue_directive dictIssue,
-                 const int acceleration)
-{
-    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
-                srcSize, dstCapacity);
-
-    if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }  /* Unsupported srcSize, too large (or negative) */
-    if (srcSize == 0) {   /* src == NULL supported if srcSize == 0 */
-        if (outputDirective != notLimited && dstCapacity <= 0) return 0;  /* no output, can't write anything */
-        DEBUGLOG(5, "Generating an empty block");
-        assert(outputDirective == notLimited || dstCapacity >= 1);
-        assert(dst != NULL);
-        dst[0] = 0;
-        if (outputDirective == fillOutput) {
-            assert (inputConsumed != NULL);
-            *inputConsumed = 0;
-        }
-        return 1;
-    }
-    assert(src != NULL);
-
-    return LZ4_compress_generic_validated(cctx, src, dst, srcSize,
-                inputConsumed, /* only written into if outputDirective == fillOutput */
-                dstCapacity, outputDirective,
-                tableType, dictDirective, dictIssue, acceleration);
-}
-
-
-int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-{
-    LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
-    assert(ctx != NULL);
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
-        if (inputSize < LZ4_64Klimit) {
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-        }
-    } else {
-        if (inputSize < LZ4_64Klimit) {
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-        }
-    }
-}
-
-/**
- * LZ4_compress_fast_extState_fastReset() :
- * A variant of LZ4_compress_fast_extState().
- *
- * Using this variant avoids an expensive initialization step. It is only safe
- * to call if the state buffer is known to be correctly initialized already
- * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
- * "correctly initialized").
- */
-int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
-{
-    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-
-    if (dstCapacity >= LZ4_compressBound(srcSize)) {
-        if (srcSize < LZ4_64Klimit) {
-            const tableType_t tableType = byU16;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            if (ctx->currentOffset) {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
-            } else {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-            }
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-        }
-    } else {
-        if (srcSize < LZ4_64Klimit) {
-            const tableType_t tableType = byU16;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            if (ctx->currentOffset) {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
-            } else {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-            }
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-        }
-    }
-}
-
-
-int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-{
-    int result;
-#if (LZ4_HEAPMODE)
-    LZ4_stream_t* ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-    if (ctxPtr == NULL) return 0;
-#else
-    LZ4_stream_t ctx;
-    LZ4_stream_t* const ctxPtr = &ctx;
-#endif
-    result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
-
-#if (LZ4_HEAPMODE)
-    FREEMEM(ctxPtr);
-#endif
-    return result;
-}
-
-
-int LZ4_compress_default(const char* src, char* dst, int srcSize, int maxOutputSize)
-{
-    return LZ4_compress_fast(src, dst, srcSize, maxOutputSize, 1);
-}
-
-
-/* Note!: This function leaves the stream in an unclean/broken state!
- * It is not safe to subsequently use the same state with a _fastReset() or
- * _continue() call without resetting it. */
-static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-{
-    void* const s = LZ4_initStream(state, sizeof (*state));
-    assert(s != NULL); (void)s;
-
-    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
-        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
-    } else {
-        if (*srcSizePtr < LZ4_64Klimit) {
-            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, 1);
-        } else {
-            tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, 1);
-    }   }
-}
-
-
-int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-{
-#if (LZ4_HEAPMODE)
-    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-    if (ctx == NULL) return 0;
-#else
-    LZ4_stream_t ctxBody;
-    LZ4_stream_t* ctx = &ctxBody;
-#endif
-
-    int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
-
-#if (LZ4_HEAPMODE)
-    FREEMEM(ctx);
-#endif
-    return result;
-}
-
-
-
-/*-******************************
-*  Streaming functions
-********************************/
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4_stream_t* LZ4_createStream(void)
-{
-    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
-    LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal));
-    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
-    if (lz4s == NULL) return NULL;
-    LZ4_initStream(lz4s, sizeof(*lz4s));
-    return lz4s;
-}
-#endif
-
-static size_t LZ4_stream_t_alignment(void)
-{
-#if LZ4_ALIGN_TEST
-    typedef struct { char c; LZ4_stream_t t; } t_a;
-    return sizeof(t_a) - sizeof(LZ4_stream_t);
-#else
-    return 1;  /* effectively disabled */
-#endif
-}
-
-LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
-{
-    DEBUGLOG(5, "LZ4_initStream");
-    if (buffer == NULL) { return NULL; }
-    if (size < sizeof(LZ4_stream_t)) { return NULL; }
-    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
-    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
-    return (LZ4_stream_t*)buffer;
-}
-
-/* resetStream is now deprecated,
- * prefer initStream() which is more general */
-void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
-{
-    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
-    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
-}
-
-void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
-    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
-}
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
-{
-    if (!LZ4_stream) return 0;   /* support free on NULL */
-    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
-    FREEMEM(LZ4_stream);
-    return (0);
-}
-#endif
-
-
-#define HASH_UNIT sizeof(reg_t)
-int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
-{
-    LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
-    const tableType_t tableType = byU32;
-    const BYTE* p = (const BYTE*)dictionary;
-    const BYTE* const dictEnd = p + dictSize;
-    const BYTE* base;
-
-    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
-
-    /* It's necessary to reset the context,
-     * and not just continue it with prepareTable()
-     * to avoid any risk of generating overflowing matchIndex
-     * when compressing using this dictionary */
-    LZ4_resetStream(LZ4_dict);
-
-    /* We always increment the offset by 64 KB, since, if the dict is longer,
-     * we truncate it to the last 64k, and if it's shorter, we still want to
-     * advance by a whole window length so we can provide the guarantee that
-     * there are only valid offsets in the window, which allows an optimization
-     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
-     * dictionary isn't a full 64k. */
-    dict->currentOffset += 64 KB;
-
-    if (dictSize < (int)HASH_UNIT) {
-        return 0;
-    }
-
-    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
-    base = dictEnd - dict->currentOffset;
-    dict->dictionary = p;
-    dict->dictSize = (U32)(dictEnd - p);
-    dict->tableType = (U32)tableType;
-
-    while (p <= dictEnd-HASH_UNIT) {
-        LZ4_putPosition(p, dict->hashTable, tableType, base);
-        p+=3;
-    }
-
-    return (int)dict->dictSize;
-}
-
-void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
-{
-    const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
-        &(dictionaryStream->internal_donotuse);
-
-    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
-             workingStream, dictionaryStream,
-             dictCtx != NULL ? dictCtx->dictSize : 0);
-
-    if (dictCtx != NULL) {
-        /* If the current offset is zero, we will never look in the
-         * external dictionary context, since there is no value a table
-         * entry can take that indicate a miss. In that case, we need
-         * to bump the offset to something non-zero.
-         */
-        if (workingStream->internal_donotuse.currentOffset == 0) {
-            workingStream->internal_donotuse.currentOffset = 64 KB;
-        }
-
-        /* Don't actually attach an empty dictionary.
-         */
-        if (dictCtx->dictSize == 0) {
-            dictCtx = NULL;
-        }
-    }
-    workingStream->internal_donotuse.dictCtx = dictCtx;
-}
-
-
-static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
-{
-    assert(nextSize >= 0);
-    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
-        /* rescale hash table */
-        U32 const delta = LZ4_dict->currentOffset - 64 KB;
-        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
-        int i;
-        DEBUGLOG(4, "LZ4_renormDictT");
-        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
-            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
-            else LZ4_dict->hashTable[i] -= delta;
-        }
-        LZ4_dict->currentOffset = 64 KB;
-        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
-        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
-    }
-}
-
-
-int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
-                                const char* source, char* dest,
-                                int inputSize, int maxOutputSize,
-                                int acceleration)
-{
-    const tableType_t tableType = byU32;
-    LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse;
-    const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL;
-
-    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize);
-
-    LZ4_renormDictT(streamPtr, inputSize);   /* fix index overflow */
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-
-    /* invalidate tiny dictionaries */
-    if ( (streamPtr->dictSize < 4)     /* tiny dictionary : not enough for a hash */
-      && (dictEnd != source)           /* prefix mode */
-      && (inputSize > 0)               /* tolerance : don't lose history, in case next invocation would use prefix mode */
-      && (streamPtr->dictCtx == NULL)  /* usingDictCtx */
-      ) {
-        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
-        /* remove dictionary existence from history, to employ faster prefix mode */
-        streamPtr->dictSize = 0;
-        streamPtr->dictionary = (const BYTE*)source;
-        dictEnd = source;
-    }
-
-    /* Check overlapping input/dictionary space */
-    {   const char* const sourceEnd = source + inputSize;
-        if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) {
-            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
-            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
-            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
-            streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize;
-        }
-    }
-
-    /* prefix mode : source data follows dictionary */
-    if (dictEnd == source) {
-        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
-        else
-            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
-    }
-
-    /* external dictionary mode */
-    {   int result;
-        if (streamPtr->dictCtx) {
-            /* We depend here on the fact that dictCtx'es (produced by
-             * LZ4_loadDict) guarantee that their tables contain no references
-             * to offsets between dictCtx->currentOffset - 64 KB and
-             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
-             * to use noDictIssue even when the dict isn't a full 64 KB.
-             */
-            if (inputSize > 4 KB) {
-                /* For compressing large blobs, it is faster to pay the setup
-                 * cost to copy the dictionary's tables into the active context,
-                 * so that the compression loop is only looking into one table.
-                 */
-                LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr));
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-            } else {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
-            }
-        } else {  /* small data <= 4 KB */
-            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
-            } else {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-            }
-        }
-        streamPtr->dictionary = (const BYTE*)source;
-        streamPtr->dictSize = (U32)inputSize;
-        return result;
-    }
-}
-
-
-/* Hidden debug function, to force-test external dictionary mode */
-int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
-{
-    LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
-    int result;
-
-    LZ4_renormDictT(streamPtr, srcSize);
-
-    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
-    } else {
-        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
-    }
-
-    streamPtr->dictionary = (const BYTE*)source;
-    streamPtr->dictSize = (U32)srcSize;
-
-    return result;
-}
-
-
-/*! LZ4_saveDict() :
- *  If previously compressed data block is not guaranteed to remain available at its memory location,
- *  save it into a safer place (char* safeBuffer).
- *  Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable,
- *         one can therefore call LZ4_compress_fast_continue() right after.
- * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
- */
-int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
-{
-    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
-
-    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer);
-
-    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
-    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
-
-    if (safeBuffer == NULL) assert(dictSize == 0);
-    if (dictSize > 0) {
-        const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
-        assert(dict->dictionary);
-        LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize);
-    }
-
-    dict->dictionary = (const BYTE*)safeBuffer;
-    dict->dictSize = (U32)dictSize;
-
-    return dictSize;
-}
-
-
-
-/*-*******************************
- *  Decompression functions
- ********************************/
-
-typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
-
-#undef MIN
-#define MIN(a,b)    ( (a) < (b) ? (a) : (b) )
-
-
-/* variant for decompress_unsafe()
- * does not know end of input
- * presumes input is well formed
- * note : will consume at least one byte */
-size_t read_long_length_no_check(const BYTE** pp)
-{
-    size_t b, l = 0;
-    do { b = **pp; (*pp)++; l += b; } while (b==255);
-    DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1)
-    return l;
-}
-
-/* core decoder variant for LZ4_decompress_fast*()
- * for legacy support only : these entry points are deprecated.
- * - Presumes input is correctly formed (no defense vs malformed inputs)
- * - Does not know input size (presume input buffer is "large enough")
- * - Decompress a full block (only)
- * @return : nb of bytes read from input.
- * Note : this variant is not optimized for speed, just for maintenance.
- *        the goal is to remove support of decompress_fast*() variants by v2.0
-**/
-LZ4_FORCE_INLINE int
-LZ4_decompress_unsafe_generic(
-                 const BYTE* const istart,
-                 BYTE* const ostart,
-                 int decompressedSize,
-
-                 size_t prefixSize,
-                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-                 const size_t dictSize         /* note: =0 if dictStart==NULL */
-                 )
-{
-    const BYTE* ip = istart;
-    BYTE* op = (BYTE*)ostart;
-    BYTE* const oend = ostart + decompressedSize;
-    const BYTE* const prefixStart = ostart - prefixSize;
-
-    DEBUGLOG(5, "LZ4_decompress_unsafe_generic");
-    if (dictStart == NULL) assert(dictSize == 0);
-
-    while (1) {
-        /* start new sequence */
-        unsigned token = *ip++;
-
-        /* literals */
-        {   size_t ll = token >> ML_BITS;
-            if (ll==15) {
-                /* long literal length */
-                ll += read_long_length_no_check(&ip);
-            }
-            if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */
-            LZ4_memmove(op, ip, ll); /* support in-place decompression */
-            op += ll;
-            ip += ll;
-            if ((size_t)(oend-op) < MFLIMIT) {
-                if (op==oend) break;  /* end of block */
-                DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op);
-                /* incorrect end of block :
-                 * last match must start at least MFLIMIT==12 bytes before end of output block */
-                return -1;
-        }   }
-
-        /* match */
-        {   size_t ml = token & 15;
-            size_t const offset = LZ4_readLE16(ip);
-            ip+=2;
-
-            if (ml==15) {
-                /* long literal length */
-                ml += read_long_length_no_check(&ip);
-            }
-            ml += MINMATCH;
-
-            if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */
-
-            {   const BYTE* match = op - offset;
-
-                /* out of range */
-                if (offset > (size_t)(op - prefixStart) + dictSize) {
-                    DEBUGLOG(6, "offset out of range");
-                    return -1;
-                }
-
-                /* check special case : extDict */
-                if (offset > (size_t)(op - prefixStart)) {
-                    /* extDict scenario */
-                    const BYTE* const dictEnd = dictStart + dictSize;
-                    const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart));
-                    size_t const extml = (size_t)(dictEnd - extMatch);
-                    if (extml > ml) {
-                        /* match entirely within extDict */
-                        LZ4_memmove(op, extMatch, ml);
-                        op += ml;
-                        ml = 0;
-                    } else {
-                        /* match split between extDict & prefix */
-                        LZ4_memmove(op, extMatch, extml);
-                        op += extml;
-                        ml -= extml;
-                    }
-                    match = prefixStart;
-                }
-
-                /* match copy - slow variant, supporting overlap copy */
-                {   size_t u;
-                    for (u=0; u<ml; u++) {
-                        op[u] = match[u];
-            }   }   }
-            op += ml;
-            if ((size_t)(oend-op) < LASTLITERALS) {
-                DEBUGLOG(5, "invalid: match ends at distance %zi from end of block", oend-op);
-                /* incorrect end of block :
-                 * last match must stop at least LASTLITERALS==5 bytes before end of output block */
-                return -1;
-            }
-        } /* match */
-    } /* main loop */
-    return (int)(ip - istart);
-}
-
-
-/* Read the variable-length literal or match length.
- *
- * @ip : input pointer
- * @ilimit : position after which if length is not decoded, the input is necessarily corrupted.
- * @initial_check - check ip >= ipmax before start of loop.  Returns initial_error if so.
- * @error (output) - error code.  Must be set to 0 before call.
-**/
-typedef size_t Rvl_t;
-static const Rvl_t rvl_error = (Rvl_t)(-1);
-LZ4_FORCE_INLINE Rvl_t
-read_variable_length(const BYTE** ip, const BYTE* ilimit,
-                     int initial_check)
-{
-    Rvl_t s, length = 0;
-    assert(ip != NULL);
-    assert(*ip !=  NULL);
-    assert(ilimit != NULL);
-    if (initial_check && unlikely((*ip) >= ilimit)) {    /* read limit reached */
-        return rvl_error;
-    }
-    do {
-        s = **ip;
-        (*ip)++;
-        length += s;
-        if (unlikely((*ip) > ilimit)) {    /* read limit reached */
-            return rvl_error;
-        }
-        /* accumulator overflow detection (32-bit mode only) */
-        if ((sizeof(length)<8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
-            return rvl_error;
-        }
-    } while (s==255);
-
-    return length;
-}
-
-/*! LZ4_decompress_generic() :
- *  This generic decompression function covers all use cases.
- *  It shall be instantiated several times, using different sets of directives.
- *  Note that it is important for performance that this function really get inlined,
- *  in order to remove useless branches during compilation optimization.
- */
-LZ4_FORCE_INLINE int
-LZ4_decompress_generic(
-                 const char* const src,
-                 char* const dst,
-                 int srcSize,
-                 int outputSize,         /* If endOnInput==endOnInputSize, this value is `dstCapacity` */
-
-                 earlyEnd_directive partialDecoding,  /* full, partial */
-                 dict_directive dict,                 /* noDict, withPrefix64k, usingExtDict */
-                 const BYTE* const lowPrefix,  /* always <= dst, == dst when no prefix */
-                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-                 const size_t dictSize         /* note : = 0 if noDict */
-                 )
-{
-    if ((src == NULL) || (outputSize < 0)) { return -1; }
-
-    {   const BYTE* ip = (const BYTE*) src;
-        const BYTE* const iend = ip + srcSize;
-
-        BYTE* op = (BYTE*) dst;
-        BYTE* const oend = op + outputSize;
-        BYTE* cpy;
-
-        const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize;
-
-        const int checkOffset = (dictSize < (int)(64 KB));
-
-
-        /* Set up the "end" pointers for the shortcut. */
-        const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/;
-        const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/;
-
-        const BYTE* match;
-        size_t offset;
-        unsigned token;
-        size_t length;
-
-
-        DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize);
-
-        /* Special cases */
-        assert(lowPrefix <= op);
-        if (unlikely(outputSize==0)) {
-            /* Empty output buffer */
-            if (partialDecoding) return 0;
-            return ((srcSize==1) && (*ip==0)) ? 0 : -1;
-        }
-        if (unlikely(srcSize==0)) { return -1; }
-
-    /* LZ4_FAST_DEC_LOOP:
-     * designed for modern OoO performance cpus,
-     * where copying reliably 32-bytes is preferable to an unpredictable branch.
-     * note : fast loop may show a regression for some client arm chips. */
-#if LZ4_FAST_DEC_LOOP
-        if ((oend - op) < FASTLOOP_SAFE_DISTANCE) {
-            DEBUGLOG(6, "skip fast decode loop");
-            goto safe_decode;
-        }
-
-        /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */
-        while (1) {
-            /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */
-            assert(oend - op >= FASTLOOP_SAFE_DISTANCE);
-            assert(ip < iend);
-            token = *ip++;
-            length = token >> ML_BITS;  /* literal length */
-
-            /* decode literal length */
-            if (length == RUN_MASK) {
-                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
-                if (addl == rvl_error) { goto _output_error; }
-                length += addl;
-                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
-                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
-
-                /* copy literals */
-                cpy = op+length;
-                LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
-                if ((cpy>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; }
-                LZ4_wildCopy32(op, ip, cpy);
-                ip += length; op = cpy;
-            } else {
-                cpy = op+length;
-                DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length);
-                /* We don't need to check oend, since we check it once for each loop below */
-                if (ip > iend-(16 + 1/*max lit + offset + nextToken*/)) { goto safe_literal_copy; }
-                /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */
-                LZ4_memcpy(op, ip, 16);
-                ip += length; op = cpy;
-            }
-
-            /* get offset */
-            offset = LZ4_readLE16(ip); ip+=2;
-            match = op - offset;
-            assert(match <= op);  /* overflow check */
-
-            /* get matchlength */
-            length = token & ML_MASK;
-
-            if (length == ML_MASK) {
-                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
-                if (addl == rvl_error) { goto _output_error; }
-                length += addl;
-                length += MINMATCH;
-                if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */
-                if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
-                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
-                    goto safe_match_copy;
-                }
-            } else {
-                length += MINMATCH;
-                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
-                    goto safe_match_copy;
-                }
-
-                /* Fastpath check: skip LZ4_wildCopy32 when true */
-                if ((dict == withPrefix64k) || (match >= lowPrefix)) {
-                    if (offset >= 8) {
-                        assert(match >= lowPrefix);
-                        assert(match <= op);
-                        assert(op + 18 <= oend);
-
-                        LZ4_memcpy(op, match, 8);
-                        LZ4_memcpy(op+8, match+8, 8);
-                        LZ4_memcpy(op+16, match+16, 2);
-                        op += length;
-                        continue;
-            }   }   }
-
-            if (checkOffset && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
-            /* match starting within external dictionary */
-            if ((dict==usingExtDict) && (match < lowPrefix)) {
-                assert(dictEnd != NULL);
-                if (unlikely(op+length > oend-LASTLITERALS)) {
-                    if (partialDecoding) {
-                        DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd");
-                        length = MIN(length, (size_t)(oend-op));
-                    } else {
-                        goto _output_error;  /* end-of-block condition violated */
-                }   }
-
-                if (length <= (size_t)(lowPrefix-match)) {
-                    /* match fits entirely within external dictionary : just copy */
-                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
-                    op += length;
-                } else {
-                    /* match stretches into both external dictionary and current block */
-                    size_t const copySize = (size_t)(lowPrefix - match);
-                    size_t const restSize = length - copySize;
-                    LZ4_memcpy(op, dictEnd - copySize, copySize);
-                    op += copySize;
-                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
-                        BYTE* const endOfMatch = op + restSize;
-                        const BYTE* copyFrom = lowPrefix;
-                        while (op < endOfMatch) { *op++ = *copyFrom++; }
-                    } else {
-                        LZ4_memcpy(op, lowPrefix, restSize);
-                        op += restSize;
-                }   }
-                continue;
-            }
-
-            /* copy match within block */
-            cpy = op + length;
-
-            assert((op <= oend) && (oend-op >= 32));
-            if (unlikely(offset<16)) {
-                LZ4_memcpy_using_offset(op, match, cpy, offset);
-            } else {
-                LZ4_wildCopy32(op, match, cpy);
-            }
-
-            op = cpy;   /* wildcopy correction */
-        }
-    safe_decode:
-#endif
-
-        /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */
-        while (1) {
-            assert(ip < iend);
-            token = *ip++;
-            length = token >> ML_BITS;  /* literal length */
-
-            /* A two-stage shortcut for the most common case:
-             * 1) If the literal length is 0..14, and there is enough space,
-             * enter the shortcut and copy 16 bytes on behalf of the literals
-             * (in the fast mode, only 8 bytes can be safely copied this way).
-             * 2) Further if the match length is 4..18, copy 18 bytes in a similar
-             * manner; but we ensure that there's enough space in the output for
-             * those 18 bytes earlier, upon entering the shortcut (in other words,
-             * there is a combined check for both stages).
-             */
-            if ( (length != RUN_MASK)
-                /* strictly "less than" on input, to re-enter the loop with at least one byte */
-              && likely((ip < shortiend) & (op <= shortoend)) ) {
-                /* Copy the literals */
-                LZ4_memcpy(op, ip, 16);
-                op += length; ip += length;
-
-                /* The second stage: prepare for match copying, decode full info.
-                 * If it doesn't work out, the info won't be wasted. */
-                length = token & ML_MASK; /* match length */
-                offset = LZ4_readLE16(ip); ip += 2;
-                match = op - offset;
-                assert(match <= op); /* check overflow */
-
-                /* Do not deal with overlapping matches. */
-                if ( (length != ML_MASK)
-                  && (offset >= 8)
-                  && (dict==withPrefix64k || match >= lowPrefix) ) {
-                    /* Copy the match. */
-                    LZ4_memcpy(op + 0, match + 0, 8);
-                    LZ4_memcpy(op + 8, match + 8, 8);
-                    LZ4_memcpy(op +16, match +16, 2);
-                    op += length + MINMATCH;
-                    /* Both stages worked, load the next token. */
-                    continue;
-                }
-
-                /* The second stage didn't work out, but the info is ready.
-                 * Propel it right to the point of match copying. */
-                goto _copy_match;
-            }
-
-            /* decode literal length */
-            if (length == RUN_MASK) {
-                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
-                if (addl == rvl_error) { goto _output_error; }
-                length += addl;
-                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
-                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
-            }
-
-            /* copy literals */
-            cpy = op+length;
-#if LZ4_FAST_DEC_LOOP
-        safe_literal_copy:
-#endif
-            LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
-            if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) {
-                /* We've either hit the input parsing restriction or the output parsing restriction.
-                 * In the normal scenario, decoding a full block, it must be the last sequence,
-                 * otherwise it's an error (invalid input or dimensions).
-                 * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow.
-                 */
-                if (partialDecoding) {
-                    /* Since we are partial decoding we may be in this block because of the output parsing
-                     * restriction, which is not valid since the output buffer is allowed to be undersized.
-                     */
-                    DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end")
-                    DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length);
-                    DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op));
-                    DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip));
-                    /* Finishing in the middle of a literals segment,
-                     * due to lack of input.
-                     */
-                    if (ip+length > iend) {
-                        length = (size_t)(iend-ip);
-                        cpy = op + length;
-                    }
-                    /* Finishing in the middle of a literals segment,
-                     * due to lack of output space.
-                     */
-                    if (cpy > oend) {
-                        cpy = oend;
-                        assert(op<=oend);
-                        length = (size_t)(oend-op);
-                    }
-                } else {
-                     /* We must be on the last sequence (or invalid) because of the parsing limitations
-                      * so check that we exactly consume the input and don't overrun the output buffer.
-                      */
-                    if ((ip+length != iend) || (cpy > oend)) {
-                        DEBUGLOG(6, "should have been last run of literals")
-                        DEBUGLOG(6, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend);
-                        DEBUGLOG(6, "or cpy(%p) > oend(%p)", cpy, oend);
-                        goto _output_error;
-                    }
-                }
-                LZ4_memmove(op, ip, length);  /* supports overlapping memory regions, for in-place decompression scenarios */
-                ip += length;
-                op += length;
-                /* Necessarily EOF when !partialDecoding.
-                 * When partialDecoding, it is EOF if we've either
-                 * filled the output buffer or
-                 * can't proceed with reading an offset for following match.
-                 */
-                if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) {
-                    break;
-                }
-            } else {
-                LZ4_wildCopy8(op, ip, cpy);   /* can overwrite up to 8 bytes beyond cpy */
-                ip += length; op = cpy;
-            }
-
-            /* get offset */
-            offset = LZ4_readLE16(ip); ip+=2;
-            match = op - offset;
-
-            /* get matchlength */
-            length = token & ML_MASK;
-
-    _copy_match:
-            if (length == ML_MASK) {
-                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
-                if (addl == rvl_error) { goto _output_error; }
-                length += addl;
-                if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
-            }
-            length += MINMATCH;
-
-#if LZ4_FAST_DEC_LOOP
-        safe_match_copy:
-#endif
-            if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
-            /* match starting within external dictionary */
-            if ((dict==usingExtDict) && (match < lowPrefix)) {
-                assert(dictEnd != NULL);
-                if (unlikely(op+length > oend-LASTLITERALS)) {
-                    if (partialDecoding) length = MIN(length, (size_t)(oend-op));
-                    else goto _output_error;   /* doesn't respect parsing restriction */
-                }
-
-                if (length <= (size_t)(lowPrefix-match)) {
-                    /* match fits entirely within external dictionary : just copy */
-                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
-                    op += length;
-                } else {
-                    /* match stretches into both external dictionary and current block */
-                    size_t const copySize = (size_t)(lowPrefix - match);
-                    size_t const restSize = length - copySize;
-                    LZ4_memcpy(op, dictEnd - copySize, copySize);
-                    op += copySize;
-                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
-                        BYTE* const endOfMatch = op + restSize;
-                        const BYTE* copyFrom = lowPrefix;
-                        while (op < endOfMatch) *op++ = *copyFrom++;
-                    } else {
-                        LZ4_memcpy(op, lowPrefix, restSize);
-                        op += restSize;
-                }   }
-                continue;
-            }
-            assert(match >= lowPrefix);
-
-            /* copy match within block */
-            cpy = op + length;
-
-            /* partialDecoding : may end anywhere within the block */
-            assert(op<=oend);
-            if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
-                size_t const mlen = MIN(length, (size_t)(oend-op));
-                const BYTE* const matchEnd = match + mlen;
-                BYTE* const copyEnd = op + mlen;
-                if (matchEnd > op) {   /* overlap copy */
-                    while (op < copyEnd) { *op++ = *match++; }
-                } else {
-                    LZ4_memcpy(op, match, mlen);
-                }
-                op = copyEnd;
-                if (op == oend) { break; }
-                continue;
-            }
-
-            if (unlikely(offset<8)) {
-                LZ4_write32(op, 0);   /* silence msan warning when offset==0 */
-                op[0] = match[0];
-                op[1] = match[1];
-                op[2] = match[2];
-                op[3] = match[3];
-                match += inc32table[offset];
-                LZ4_memcpy(op+4, match, 4);
-                match -= dec64table[offset];
-            } else {
-                LZ4_memcpy(op, match, 8);
-                match += 8;
-            }
-            op += 8;
-
-            if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
-                BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1);
-                if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
-                if (op < oCopyLimit) {
-                    LZ4_wildCopy8(op, match, oCopyLimit);
-                    match += oCopyLimit - op;
-                    op = oCopyLimit;
-                }
-                while (op < cpy) { *op++ = *match++; }
-            } else {
-                LZ4_memcpy(op, match, 8);
-                if (length > 16)  { LZ4_wildCopy8(op+8, match+8, cpy); }
-            }
-            op = cpy;   /* wildcopy correction */
-        }
-
-        /* end of decoding */
-        DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst));
-        return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
-
-        /* Overflow error detected */
-    _output_error:
-        return (int) (-(((const char*)ip)-src))-1;
-    }
-}
-
-
-/*===== Instantiate the API decoding functions. =====*/
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
-                                  decode_full_block, noDict,
-                                  (BYTE*)dest, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
-                                  partial_decode,
-                                  noDict, (BYTE*)dst, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
-{
-    DEBUGLOG(5, "LZ4_decompress_fast");
-    return LZ4_decompress_unsafe_generic(
-                (const BYTE*)source, (BYTE*)dest, originalSize,
-                0, NULL, 0);
-}
-
-/*===== Instantiate a few more decoding cases, used more than once. =====*/
-
-LZ4_FORCE_O2 /* Exported, an obsolete API function. */
-int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, withPrefix64k,
-                                  (BYTE*)dest - 64 KB, NULL, 0);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
-                                  partial_decode, withPrefix64k,
-                                  (BYTE*)dest - 64 KB, NULL, 0);
-}
-
-/* Another obsolete API function, paired with the previous one. */
-int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
-{
-    return LZ4_decompress_unsafe_generic(
-                (const BYTE*)source, (BYTE*)dest, originalSize,
-                64 KB, NULL, 0);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
-                                               size_t prefixSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, noDict,
-                                  (BYTE*)dest-prefixSize, NULL, 0);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity,
-                                               size_t prefixSize)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
-                                  partial_decode, noDict,
-                                  (BYTE*)dest-prefixSize, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int maxOutputSize,
-                                     const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, usingExtDict,
-                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int targetOutputSize, int dstCapacity,
-                                     const void* dictStart, size_t dictSize)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
-                                  partial_decode, usingExtDict,
-                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize,
-                                       const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_unsafe_generic(
-                (const BYTE*)source, (BYTE*)dest, originalSize,
-                0, (const BYTE*)dictStart, dictSize);
-}
-
-/* The "double dictionary" mode, for use with e.g. ring buffers: the first part
- * of the dictionary is passed as prefix, and the second via dictStart + dictSize.
- * These routines are used only once, in LZ4_decompress_*_continue().
- */
-LZ4_FORCE_INLINE
-int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
-                                   size_t prefixSize, const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, usingExtDict,
-                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
-}
-
-/*===== streaming decompression functions =====*/
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4_streamDecode_t* LZ4_createStreamDecode(void)
-{
-    LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal));
-    return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
-}
-
-int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
-{
-    if (LZ4_stream == NULL) { return 0; }  /* support free on NULL */
-    FREEMEM(LZ4_stream);
-    return 0;
-}
-#endif
-
-/*! LZ4_setStreamDecode() :
- *  Use this function to instruct where to find the dictionary.
- *  This function is not necessary if previous data is still available where it was decoded.
- *  Loading a size of 0 is allowed (same effect as no dictionary).
- * @return : 1 if OK, 0 if error
- */
-int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    lz4sd->prefixSize = (size_t)dictSize;
-    if (dictSize) {
-        assert(dictionary != NULL);
-        lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
-    } else {
-        lz4sd->prefixEnd = (const BYTE*) dictionary;
-    }
-    lz4sd->externalDict = NULL;
-    lz4sd->extDictSize  = 0;
-    return 1;
-}
-
-/*! LZ4_decoderRingBufferSize() :
- *  when setting a ring buffer for streaming decompression (optional scenario),
- *  provides the minimum size of this ring buffer
- *  to be compatible with any source respecting maxBlockSize condition.
- *  Note : in a ring buffer scenario,
- *  blocks are presumed decompressed next to each other.
- *  When not enough space remains for next block (remainingSize < maxBlockSize),
- *  decoding resumes from beginning of ring buffer.
- * @return : minimum ring buffer size,
- *           or 0 if there is an error (invalid maxBlockSize).
- */
-int LZ4_decoderRingBufferSize(int maxBlockSize)
-{
-    if (maxBlockSize < 0) return 0;
-    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
-    if (maxBlockSize < 16) maxBlockSize = 16;
-    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
-}
-
-/*
-*_continue() :
-    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-    Previously decoded blocks must still be available at the memory position where they were decoded.
-    If it's not possible, save the relevant part of decoded data into a safe buffer,
-    and indicate where it stands using LZ4_setStreamDecode()
-*/
-LZ4_FORCE_O2
-int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    int result;
-
-    if (lz4sd->prefixSize == 0) {
-        /* The first call, no dictionary yet. */
-        assert(lz4sd->extDictSize == 0);
-        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)result;
-        lz4sd->prefixEnd = (BYTE*)dest + result;
-    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-        /* They're rolling the current segment. */
-        if (lz4sd->prefixSize >= 64 KB - 1)
-            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-        else if (lz4sd->extDictSize == 0)
-            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
-                                                         lz4sd->prefixSize);
-        else
-            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
-                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += (size_t)result;
-        lz4sd->prefixEnd  += result;
-    } else {
-        /* The buffer wraps around, or they're switching to another buffer. */
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize,
-                                                  lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)result;
-        lz4sd->prefixEnd  = (BYTE*)dest + result;
-    }
-
-    return result;
-}
-
-LZ4_FORCE_O2 int
-LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode,
-                        const char* source, char* dest, int originalSize)
-{
-    LZ4_streamDecode_t_internal* const lz4sd =
-        (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse);
-    int result;
-
-    DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize);
-    assert(originalSize >= 0);
-
-    if (lz4sd->prefixSize == 0) {
-        DEBUGLOG(5, "first invocation : no prefix nor extDict");
-        assert(lz4sd->extDictSize == 0);
-        result = LZ4_decompress_fast(source, dest, originalSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)originalSize;
-        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
-    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-        DEBUGLOG(5, "continue using existing prefix");
-        result = LZ4_decompress_unsafe_generic(
-                        (const BYTE*)source, (BYTE*)dest, originalSize,
-                        lz4sd->prefixSize,
-                        lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += (size_t)originalSize;
-        lz4sd->prefixEnd  += originalSize;
-    } else {
-        DEBUGLOG(5, "prefix becomes extDict");
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
-                                             lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)originalSize;
-        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
-    }
-
-    return result;
-}
-
-
-/*
-Advanced decoding functions :
-*_usingDict() :
-    These decoding functions work the same as "_continue" ones,
-    the dictionary must be explicitly provided within parameters
-*/
-
-int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
-{
-    if (dictSize==0)
-        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-    if (dictStart+dictSize == dest) {
-        if (dictSize >= 64 KB - 1) {
-            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-        }
-        assert(dictSize >= 0);
-        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
-    }
-    assert(dictSize >= 0);
-    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
-}
-
-int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize)
-{
-    if (dictSize==0)
-        return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity);
-    if (dictStart+dictSize == dest) {
-        if (dictSize >= 64 KB - 1) {
-            return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity);
-        }
-        assert(dictSize >= 0);
-        return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize);
-    }
-    assert(dictSize >= 0);
-    return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize);
-}
-
-int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
-{
-    if (dictSize==0 || dictStart+dictSize == dest)
-        return LZ4_decompress_unsafe_generic(
-                        (const BYTE*)source, (BYTE*)dest, originalSize,
-                        (size_t)dictSize, NULL, 0);
-    assert(dictSize >= 0);
-    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize);
-}
-
-
-/*=*************************************************
-*  Obsolete Functions
-***************************************************/
-/* obsolete compression functions */
-int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
-{
-    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
-}
-int LZ4_compress(const char* src, char* dest, int srcSize)
-{
-    return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
-}
-int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
-{
-    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
-}
-int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
-{
-    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
-}
-int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
-{
-    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
-}
-int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
-{
-    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
-}
-
-/*
-These decompression functions are deprecated and should no longer be used.
-They are only provided here for compatibility with older user programs.
-- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
-- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
-*/
-int LZ4_uncompress (const char* source, char* dest, int outputSize)
-{
-    return LZ4_decompress_fast(source, dest, outputSize);
-}
-int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
-{
-    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
-}
-
-/* Obsolete Streaming functions */
-
-int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }
-
-int LZ4_resetStreamState(void* state, char* inputBuffer)
-{
-    (void)inputBuffer;
-    LZ4_resetStream((LZ4_stream_t*)state);
-    return 0;
-}
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-void* LZ4_create (char* inputBuffer)
-{
-    (void)inputBuffer;
-    return LZ4_createStream();
-}
-#endif
-
-char* LZ4_slideInputBuffer (void* state)
-{
-    /* avoid const char * -> char * conversion warning */
-    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
-}
-
-#endif   /* LZ4_COMMONDEFS_ONLY */
-}
diff --git a/src/duckdb/third_party/lz4/lz4.hpp b/src/duckdb/third_party/lz4/lz4.hpp
deleted file mode 100644
index dcf1f032c..000000000
--- a/src/duckdb/third_party/lz4/lz4.hpp
+++ /dev/null
@@ -1,843 +0,0 @@
-/*
- *  LZ4 - Fast LZ compression algorithm
- *  Header File
- *  Copyright (C) 2011-2020, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN 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.
-
-   You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
-*/
-//#if defined (__cplusplus)
-//extern "C" {
-//#endif
-
-#ifndef LZ4_H_2983827168210
-#define LZ4_H_2983827168210
-
-/* --- Dependency --- */
-#include <stddef.h>   /* size_t */
-
-namespace duckdb_lz4 {
-
-/**
-  Introduction
-
-  LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core,
-  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
-  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
-
-  The LZ4 compression library provides in-memory compression and decompression functions.
-  It gives full buffer control to user.
-  Compression can be done in:
-    - a single step (described as Simple Functions)
-    - a single step, reusing a context (described in Advanced Functions)
-    - unbounded multiple steps (described as Streaming compression)
-
-  lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md).
-  Decompressing such a compressed block requires additional metadata.
-  Exact metadata depends on exact decompression function.
-  For the typical case of LZ4_decompress_safe(),
-  metadata includes block's compressed size, and maximum bound of decompressed size.
-  Each application is free to encode and pass such metadata in whichever way it wants.
-
-  lz4.h only handle blocks, it can not generate Frames.
-
-  Blocks are different from Frames (doc/lz4_Frame_format.md).
-  Frames bundle both blocks and metadata in a specified manner.
-  Embedding metadata is required for compressed data to be self-contained and portable.
-  Frame format is delivered through a companion API, declared in lz4frame.h.
-  The `lz4` CLI can only manage frames.
-*/
-
-/*^***************************************************************
-*  Export parameters
-*****************************************************************/
-/*
-*  LZ4_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*  LZ4LIB_VISIBILITY :
-*  Control library symbols visibility.
-*/
-#ifndef LZ4LIB_VISIBILITY
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
-#  else
-#    define LZ4LIB_VISIBILITY
-#  endif
-#endif
-#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
-#  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
-#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
-#  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define LZ4LIB_API LZ4LIB_VISIBILITY
-#endif
-
-/*! LZ4_FREESTANDING :
- *  When this macro is set to 1, it enables "freestanding mode" that is
- *  suitable for typical freestanding environment which doesn't support
- *  standard C library.
- *
- *  - LZ4_FREESTANDING is a compile-time switch.
- *  - It requires the following macros to be defined:
- *    LZ4_memcpy, LZ4_memmove, LZ4_memset.
- *  - It only enables LZ4/HC functions which don't use heap.
- *    All LZ4F_* functions are not supported.
- *  - See tests/freestanding.c to check its basic setup.
- */
-#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1)
-#  define LZ4_HEAPMODE 0
-#  define LZ4HC_HEAPMODE 0
-#  define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1
-#  if !defined(LZ4_memcpy)
-#    error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'."
-#  endif
-#  if !defined(LZ4_memset)
-#    error "LZ4_FREESTANDING requires macro 'LZ4_memset'."
-#  endif
-#  if !defined(LZ4_memmove)
-#    error "LZ4_FREESTANDING requires macro 'LZ4_memmove'."
-#  endif
-#elif ! defined(LZ4_FREESTANDING)
-#  define LZ4_FREESTANDING 0
-#endif
-
-
-/*------   Version   ------*/
-#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
-#define LZ4_VERSION_MINOR    9    /* for new (non-breaking) interface capabilities */
-#define LZ4_VERSION_RELEASE  4    /* for tweaks, bug-fixes, or development */
-
-#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
-
-#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
-#define LZ4_QUOTE(str) #str
-#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
-#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)  /* requires v1.7.3+ */
-
-LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; useful to check dll version; requires v1.3.0+ */
-LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; useful to check dll version; requires v1.7.5+ */
-
-
-/*-************************************
-*  Tuning parameter
-**************************************/
-#define LZ4_MEMORY_USAGE_MIN 10
-#define LZ4_MEMORY_USAGE_DEFAULT 14
-#define LZ4_MEMORY_USAGE_MAX 20
-
-/*!
- * LZ4_MEMORY_USAGE :
- * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; )
- * Increasing memory usage improves compression ratio, at the cost of speed.
- * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality.
- * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
- */
-#ifndef LZ4_MEMORY_USAGE
-# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT
-#endif
-
-#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN)
-#  error "LZ4_MEMORY_USAGE is too small !"
-#endif
-
-#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX)
-#  error "LZ4_MEMORY_USAGE is too large !"
-#endif
-
-/*-************************************
-*  Simple Functions
-**************************************/
-/*! LZ4_compress_default() :
- *  Compresses 'srcSize' bytes from buffer 'src'
- *  into already allocated 'dst' buffer of size 'dstCapacity'.
- *  Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
- *  It also runs faster, so it's a recommended setting.
- *  If the function cannot compress 'src' into a more limited 'dst' budget,
- *  compression stops *immediately*, and the function result is zero.
- *  In which case, 'dst' content is undefined (invalid).
- *      srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
- *      dstCapacity : size of buffer 'dst' (which must be already allocated)
- *     @return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
- *                or 0 if compression fails
- * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
- */
-LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
-
-/*! LZ4_decompress_safe() :
- *  compressedSize : is the exact complete size of the compressed block.
- *  dstCapacity : is the size of destination buffer (which must be already allocated), presumed an upper bound of decompressed size.
- * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
- *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
- *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
- * Note 1 : This function is protected against malicious data packets :
- *          it will never writes outside 'dst' buffer, nor read outside 'source' buffer,
- *          even if the compressed block is maliciously modified to order the decoder to do these actions.
- *          In such case, the decoder stops immediately, and considers the compressed block malformed.
- * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them.
- *          The implementation is free to send / store / derive this information in whichever way is most beneficial.
- *          If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.
- */
-LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
-
-
-/*-************************************
-*  Advanced Functions
-**************************************/
-#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
-#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
-
-/*! LZ4_compressBound() :
-    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
-    This function is primarily useful for memory allocation purposes (destination buffer size).
-    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
-    Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
-        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
-        return : maximum output size in a "worst case" scenario
-              or 0, if input size is incorrect (too large or negative)
-*/
-LZ4LIB_API int LZ4_compressBound(int inputSize);
-
-/*! LZ4_compress_fast() :
-    Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
-    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
-    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
-    An acceleration value of "1" is the same as regular LZ4_compress_default()
-    Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c).
-    Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).
-*/
-LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-
-/*! LZ4_compress_fast_extState() :
- *  Same as LZ4_compress_fast(), using an externally allocated memory space for its state.
- *  Use LZ4_sizeofState() to know how much memory must be allocated,
- *  and allocate it on 8-bytes boundaries (using `malloc()` typically).
- *  Then, provide this buffer as `void* state` to compression function.
- */
-LZ4LIB_API int LZ4_sizeofState(void);
-LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-
-/*! LZ4_compress_destSize() :
- *  Reverse the logic : compresses as much data as possible from 'src' buffer
- *  into already allocated buffer 'dst', of size >= 'targetDestSize'.
- *  This function either compresses the entire 'src' content into 'dst' if it's large enough,
- *  or fill 'dst' buffer completely with as much data as possible from 'src'.
- *  note: acceleration parameter is fixed to "default".
- *
- * *srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
- *               New value is necessarily <= input value.
- * @return : Nb bytes written into 'dst' (necessarily <= targetDestSize)
- *           or 0 if compression fails.
- *
- * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un v1.9.2+):
- *        the produced compressed content could, in specific circumstances,
- *        require to be decompressed into a destination buffer larger
- *        by at least 1 byte than the content to decompress.
- *        If an application uses `LZ4_compress_destSize()`,
- *        it's highly recommended to update liblz4 to v1.9.2 or better.
- *        If this can't be done or ensured,
- *        the receiving decompression function should provide
- *        a dstCapacity which is > decompressedSize, by at least 1 byte.
- *        See https://github.com/lz4/lz4/issues/859 for details
- */
-LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize);
-
-
-/*! LZ4_decompress_safe_partial() :
- *  Decompress an LZ4 compressed block, of size 'srcSize' at position 'src',
- *  into destination buffer 'dst' of size 'dstCapacity'.
- *  Up to 'targetOutputSize' bytes will be decoded.
- *  The function stops decoding on reaching this objective.
- *  This can be useful to boost performance
- *  whenever only the beginning of a block is required.
- *
- * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize)
- *           If source stream is detected malformed, function returns a negative result.
- *
- *  Note 1 : @return can be < targetOutputSize, if compressed block contains less data.
- *
- *  Note 2 : targetOutputSize must be <= dstCapacity
- *
- *  Note 3 : this function effectively stops decoding on reaching targetOutputSize,
- *           so dstCapacity is kind of redundant.
- *           This is because in older versions of this function,
- *           decoding operation would still write complete sequences.
- *           Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize,
- *           it could write more bytes, though only up to dstCapacity.
- *           Some "margin" used to be required for this operation to work properly.
- *           Thankfully, this is no longer necessary.
- *           The function nonetheless keeps the same signature, in an effort to preserve API compatibility.
- *
- *  Note 4 : If srcSize is the exact size of the block,
- *           then targetOutputSize can be any value,
- *           including larger than the block's decompressed size.
- *           The function will, at most, generate block's decompressed size.
- *
- *  Note 5 : If srcSize is _larger_ than block's compressed size,
- *           then targetOutputSize **MUST** be <= block's decompressed size.
- *           Otherwise, *silent corruption will occur*.
- */
-LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
-
-
-/*-*********************************************
-*  Streaming Compression Functions
-***********************************************/
-typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
-
-/**
- Note about RC_INVOKED
-
- - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio).
-   https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros
-
- - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars)
-   and reports warning "RC4011: identifier truncated".
-
- - To eliminate the warning, we surround long preprocessor symbol with
-   "#if !defined(RC_INVOKED) ... #endif" block that means
-   "skip this block when rc.exe is trying to read it".
-*/
-#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
-LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
-#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
-#endif
-
-/*! LZ4_resetStream_fast() : v1.9.0+
- *  Use this to prepare an LZ4_stream_t for a new chain of dependent blocks
- *  (e.g., LZ4_compress_fast_continue()).
- *
- *  An LZ4_stream_t must be initialized once before usage.
- *  This is automatically done when created by LZ4_createStream().
- *  However, should the LZ4_stream_t be simply declared on stack (for example),
- *  it's necessary to initialize it first, using LZ4_initStream().
- *
- *  After init, start any new stream with LZ4_resetStream_fast().
- *  A same LZ4_stream_t can be re-used multiple times consecutively
- *  and compress multiple streams,
- *  provided that it starts each new stream with LZ4_resetStream_fast().
- *
- *  LZ4_resetStream_fast() is much faster than LZ4_initStream(),
- *  but is not compatible with memory regions containing garbage data.
- *
- *  Note: it's only useful to call LZ4_resetStream_fast()
- *        in the context of streaming compression.
- *        The *extState* functions perform their own resets.
- *        Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.
- */
-LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
-
-/*! LZ4_loadDict() :
- *  Use this function to reference a static dictionary into LZ4_stream_t.
- *  The dictionary must remain available during compression.
- *  LZ4_loadDict() triggers a reset, so any previous data will be forgotten.
- *  The same dictionary will have to be loaded on decompression side for successful decoding.
- *  Dictionary are useful for better compression of small data (KB range).
- *  While LZ4 accept any input as dictionary,
- *  results are generally better when using Zstandard's Dictionary Builder.
- *  Loading a size of 0 is allowed, and is the same as reset.
- * @return : loaded dictionary size, in bytes (necessarily <= 64 KB)
- */
-LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
-
-/*! LZ4_compress_fast_continue() :
- *  Compress 'src' content using data from previously compressed blocks, for better compression ratio.
- * 'dst' buffer must be already allocated.
- *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
- *
- * @return : size of compressed block
- *           or 0 if there is an error (typically, cannot fit into 'dst').
- *
- *  Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block.
- *           Each block has precise boundaries.
- *           Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata.
- *           It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.
- *
- *  Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory !
- *
- *  Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB.
- *           Make sure that buffers are separated, by at least one byte.
- *           This construction ensures that each block only depends on previous block.
- *
- *  Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
- *
- *  Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.
- */
-LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_saveDict() :
- *  If last 64KB data cannot be guaranteed to remain available at its current memory location,
- *  save it into a safer place (char* safeBuffer).
- *  This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
- *  but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
- * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
- */
-LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
-
-
-/*-**********************************************
-*  Streaming Decompression Functions
-*  Bufferless synchronous API
-************************************************/
-typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
-
-/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
- *  creation / destruction of streaming decompression tracking context.
- *  A tracking context can be re-used multiple times.
- */
-#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
-LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
-#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
-#endif
-
-/*! LZ4_setStreamDecode() :
- *  An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
- *  Use this function to start decompression of a new stream of blocks.
- *  A dictionary can optionally be set. Use NULL or size 0 for a reset order.
- *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
- * @return : 1 if OK, 0 if error
- */
-LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
-
-/*! LZ4_decoderRingBufferSize() : v1.8.2+
- *  Note : in a ring buffer scenario (optional),
- *  blocks are presumed decompressed next to each other
- *  up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
- *  at which stage it resumes from beginning of ring buffer.
- *  When setting such a ring buffer for streaming decompression,
- *  provides the minimum size of this ring buffer
- *  to be compatible with any source respecting maxBlockSize condition.
- * @return : minimum ring buffer size,
- *           or 0 if there is an error (invalid maxBlockSize).
- */
-LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
-#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize))  /* for static allocation; maxBlockSize presumed valid */
-
-/*! LZ4_decompress_*_continue() :
- *  These decoding functions allow decompression of consecutive blocks in "streaming" mode.
- *  A block is an unsplittable entity, it must be presented entirely to a decompression function.
- *  Decompression functions only accepts one block at a time.
- *  The last 64KB of previously decoded data *must* remain available and unmodified at the memory position where they were decoded.
- *  If less than 64KB of data has been decoded, all the data must be present.
- *
- *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
- *  - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
- *    maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
- *    In which case, encoding and decoding buffers do not need to be synchronized.
- *    Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
- *  - Synchronized mode :
- *    Decompression buffer size is _exactly_ the same as compression buffer size,
- *    and follows exactly same update rule (block boundaries at same positions),
- *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
- *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
- *  - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
- *    In which case, encoding and decoding buffers do not need to be synchronized,
- *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
- *
- *  Whenever these conditions are not possible,
- *  save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
- *  then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
-*/
-LZ4LIB_API int
-LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode,
-                        const char* src, char* dst,
-                        int srcSize, int dstCapacity);
-
-
-/*! LZ4_decompress_*_usingDict() :
- *  These decoding functions work the same as
- *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
- *  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
- *  Dictionary is presumed stable : it must remain accessible and unmodified during decompression.
- *  Performance tip : Decompression speed can be substantially increased
- *                    when dst == dictStart + dictSize.
- */
-LZ4LIB_API int
-LZ4_decompress_safe_usingDict(const char* src, char* dst,
-                              int srcSize, int dstCapacity,
-                              const char* dictStart, int dictSize);
-
-LZ4LIB_API int
-LZ4_decompress_safe_partial_usingDict(const char* src, char* dst,
-                                      int compressedSize,
-                                      int targetOutputSize, int maxOutputSize,
-                                      const char* dictStart, int dictSize);
-
-#endif /* LZ4_H_2983827168210 */
-
-
-/*^*************************************
- * !!!!!!   STATIC LINKING ONLY   !!!!!!
- ***************************************/
-
-/*-****************************************************************************
- * Experimental section
- *
- * Symbols declared in this section must be considered unstable. Their
- * signatures or semantics may change, or they may be removed altogether in the
- * future. They are therefore only safe to depend on when the caller is
- * statically linked against the library.
- *
- * To protect against unsafe usage, not only are the declarations guarded,
- * the definitions are hidden by default
- * when building LZ4 as a shared/dynamic library.
- *
- * In order to access these declarations,
- * define LZ4_STATIC_LINKING_ONLY in your application
- * before including LZ4's headers.
- *
- * In order to make their implementations accessible dynamically, you must
- * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library.
- ******************************************************************************/
-
-#ifdef LZ4_STATIC_LINKING_ONLY
-
-#ifndef LZ4_STATIC_3504398509
-#define LZ4_STATIC_3504398509
-
-#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS
-#define LZ4LIB_STATIC_API LZ4LIB_API
-#else
-#define LZ4LIB_STATIC_API
-#endif
-
-
-/*! LZ4_compress_fast_extState_fastReset() :
- *  A variant of LZ4_compress_fast_extState().
- *
- *  Using this variant avoids an expensive initialization step.
- *  It is only safe to call if the state buffer is known to be correctly initialized already
- *  (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized").
- *  From a high level, the difference is that
- *  this function initializes the provided state with a call to something like LZ4_resetStream_fast()
- *  while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream().
- */
-LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_attach_dictionary() :
- *  This is an experimental API that allows
- *  efficient use of a static dictionary many times.
- *
- *  Rather than re-loading the dictionary buffer into a working context before
- *  each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
- *  working LZ4_stream_t, this function introduces a no-copy setup mechanism,
- *  in which the working stream references the dictionary stream in-place.
- *
- *  Several assumptions are made about the state of the dictionary stream.
- *  Currently, only streams which have been prepared by LZ4_loadDict() should
- *  be expected to work.
- *
- *  Alternatively, the provided dictionaryStream may be NULL,
- *  in which case any existing dictionary stream is unset.
- *
- *  If a dictionary is provided, it replaces any pre-existing stream history.
- *  The dictionary contents are the only history that can be referenced and
- *  logically immediately precede the data compressed in the first subsequent
- *  compression call.
- *
- *  The dictionary will only remain attached to the working stream through the
- *  first compression call, at the end of which it is cleared. The dictionary
- *  stream (and source buffer) must remain in-place / accessible / unchanged
- *  through the completion of the first compression call on the stream.
- */
-LZ4LIB_STATIC_API void
-LZ4_attach_dictionary(LZ4_stream_t* workingStream,
-                const LZ4_stream_t* dictionaryStream);
-
-
-/*! In-place compression and decompression
- *
- * It's possible to have input and output sharing the same buffer,
- * for highly constrained memory environments.
- * In both cases, it requires input to lay at the end of the buffer,
- * and decompression to start at beginning of the buffer.
- * Buffer size must feature some margin, hence be larger than final size.
- *
- * |<------------------------buffer--------------------------------->|
- *                             |<-----------compressed data--------->|
- * |<-----------decompressed size------------------>|
- *                                                  |<----margin---->|
- *
- * This technique is more useful for decompression,
- * since decompressed size is typically larger,
- * and margin is short.
- *
- * In-place decompression will work inside any buffer
- * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize).
- * This presumes that decompressedSize > compressedSize.
- * Otherwise, it means compression actually expanded data,
- * and it would be more efficient to store such data with a flag indicating it's not compressed.
- * This can happen when data is not compressible (already compressed, or encrypted).
- *
- * For in-place compression, margin is larger, as it must be able to cope with both
- * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX,
- * and data expansion, which can happen when input is not compressible.
- * As a consequence, buffer size requirements are much higher,
- * and memory savings offered by in-place compression are more limited.
- *
- * There are ways to limit this cost for compression :
- * - Reduce history size, by modifying LZ4_DISTANCE_MAX.
- *   Note that it is a compile-time constant, so all compressions will apply this limit.
- *   Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX,
- *   so it's a reasonable trick when inputs are known to be small.
- * - Require the compressor to deliver a "maximum compressed size".
- *   This is the `dstCapacity` parameter in `LZ4_compress*()`.
- *   When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail,
- *   in which case, the return code will be 0 (zero).
- *   The caller must be ready for these cases to happen,
- *   and typically design a backup scheme to send data uncompressed.
- * The combination of both techniques can significantly reduce
- * the amount of margin required for in-place compression.
- *
- * In-place compression can work in any buffer
- * which size is >= (maxCompressedSize)
- * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success.
- * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX,
- * so it's possible to reduce memory requirements by playing with them.
- */
-
-#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize)          (((compressedSize) >> 8) + 32)
-#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize)   ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize))  /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */
-
-#ifndef LZ4_DISTANCE_MAX   /* history window size; can be user-defined at compile time */
-#  define LZ4_DISTANCE_MAX 65535   /* set to maximum value by default */
-#endif
-
-#define LZ4_COMPRESS_INPLACE_MARGIN                           (LZ4_DISTANCE_MAX + 32)   /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */
-#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize)   ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN)  /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */
-
-#endif   /* LZ4_STATIC_3504398509 */
-#endif   /* LZ4_STATIC_LINKING_ONLY */
-
-
-
-#ifndef LZ4_H_98237428734687
-#define LZ4_H_98237428734687
-
-/*-************************************************************
- *  Private Definitions
- **************************************************************
- * Do not use these definitions directly.
- * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
- * Accessing members will expose user code to API and/or ABI break in future versions of the library.
- **************************************************************/
-#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
-#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
-#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
-
-#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  int8_t  LZ4_i8;
-  typedef uint8_t  LZ4_byte;
-  typedef uint16_t LZ4_u16;
-  typedef uint32_t LZ4_u32;
-#else
-  typedef   signed char  LZ4_i8;
-  typedef unsigned char  LZ4_byte;
-  typedef unsigned short LZ4_u16;
-  typedef unsigned int   LZ4_u32;
-#endif
-
-/*! LZ4_stream_t :
- *  Never ever use below internal definitions directly !
- *  These definitions are not API/ABI safe, and may change in future versions.
- *  If you need static allocation, declare or allocate an LZ4_stream_t object.
-**/
-
-typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
-struct LZ4_stream_t_internal {
-    LZ4_u32 hashTable[LZ4_HASH_SIZE_U32];
-    const LZ4_byte* dictionary;
-    const LZ4_stream_t_internal* dictCtx;
-    LZ4_u32 currentOffset;
-    LZ4_u32 tableType;
-    LZ4_u32 dictSize;
-    /* Implicit padding to ensure structure is aligned */
-};
-
-#define LZ4_STREAM_MINSIZE  ((1UL << LZ4_MEMORY_USAGE) + 32)  /* static size, for inter-version compatibility */
-union LZ4_stream_u {
-    char minStateSize[LZ4_STREAM_MINSIZE];
-    LZ4_stream_t_internal internal_donotuse;
-}; /* previously typedef'd to LZ4_stream_t */
-
-
-/*! LZ4_initStream() : v1.9.0+
- *  An LZ4_stream_t structure must be initialized at least once.
- *  This is automatically done when invoking LZ4_createStream(),
- *  but it's not when the structure is simply declared on stack (for example).
- *
- *  Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t.
- *  It can also initialize any arbitrary buffer of sufficient size,
- *  and will @return a pointer of proper type upon initialization.
- *
- *  Note : initialization fails if size and alignment conditions are not respected.
- *         In which case, the function will @return NULL.
- *  Note2: An LZ4_stream_t structure guarantees correct alignment and size.
- *  Note3: Before v1.9.0, use LZ4_resetStream() instead
-**/
-LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* buffer, size_t size);
-
-
-/*! LZ4_streamDecode_t :
- *  Never ever use below internal definitions directly !
- *  These definitions are not API/ABI safe, and may change in future versions.
- *  If you need static allocation, declare or allocate an LZ4_streamDecode_t object.
-**/
-typedef struct {
-    const LZ4_byte* externalDict;
-    const LZ4_byte* prefixEnd;
-    size_t extDictSize;
-    size_t prefixSize;
-} LZ4_streamDecode_t_internal;
-
-#define LZ4_STREAMDECODE_MINSIZE 32
-union LZ4_streamDecode_u {
-    char minStateSize[LZ4_STREAMDECODE_MINSIZE];
-    LZ4_streamDecode_t_internal internal_donotuse;
-} ;   /* previously typedef'd to LZ4_streamDecode_t */
-
-
-
-/*-************************************
-*  Obsolete Functions
-**************************************/
-
-/*! Deprecation warnings
- *
- *  Deprecated functions make the compiler generate a warning when invoked.
- *  This is meant to invite users to update their source code.
- *  Should deprecation warnings be a problem, it is generally possible to disable them,
- *  typically with -Wno-deprecated-declarations for gcc
- *  or _CRT_SECURE_NO_WARNINGS in Visual.
- *
- *  Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS
- *  before including the header file.
- */
-#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
-#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
-#else
-#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
-#  elif defined(_MSC_VER)
-#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
-#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45))
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
-#  elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31)
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
-#  else
-#    pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler")
-#    define LZ4_DEPRECATED(message)   /* disabled */
-#  endif
-#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
-
-/*! Obsolete compression functions (since v1.7.3) */
-LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress               (const char* src, char* dest, int srcSize);
-LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
-
-/*! Obsolete decompression functions (since v1.8.0) */
-LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
-LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
-
-/* Obsolete streaming functions (since v1.7.0)
- * degraded functionality; do not use!
- *
- * In order to perform streaming compression, these functions depended on data
- * that is no longer tracked in the state. They have been preserved as well as
- * possible: using them will still produce a correct output. However, they don't
- * actually retain any history between compression calls. The compression ratio
- * achieved will therefore be no better than compressing each chunk
- * independently.
- */
-LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
-LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
-LZ4_DEPRECATED("Use LZ4_resetStream() instead")  LZ4LIB_API int   LZ4_resetStreamState(void* state, char* inputBuffer);
-LZ4_DEPRECATED("Use LZ4_saveDict() instead")     LZ4LIB_API char* LZ4_slideInputBuffer (void* state);
-
-/*! Obsolete streaming decoding functions (since v1.7.0) */
-LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
-LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
-
-/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) :
- *  These functions used to be faster than LZ4_decompress_safe(),
- *  but this is no longer the case. They are now slower.
- *  This is because LZ4_decompress_fast() doesn't know the input size,
- *  and therefore must progress more cautiously into the input buffer to not read beyond the end of block.
- *  On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability.
- *  As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.
- *
- *  The last remaining LZ4_decompress_fast() specificity is that
- *  it can decompress a block without knowing its compressed size.
- *  Such functionality can be achieved in a more secure manner
- *  by employing LZ4_decompress_safe_partial().
- *
- *  Parameters:
- *  originalSize : is the uncompressed size to regenerate.
- *                 `dst` must be already allocated, its size must be >= 'originalSize' bytes.
- * @return : number of bytes read from source buffer (== compressed size).
- *           The function expects to finish at block's end exactly.
- *           If the source stream is detected malformed, the function stops decoding and returns a negative result.
- *  note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer.
- *         However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds.
- *         Also, since match offsets are not validated, match reads from 'src' may underflow too.
- *         These issues never happen if input (compressed) data is correct.
- *         But they may happen if input data is invalid (error or intentional tampering).
- *         As a consequence, use these functions in trusted environments with trusted data **only**.
- */
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe() instead")
-LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_continue() instead")
-LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_usingDict() instead")
-LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
-
-/*! LZ4_resetStream() :
- *  An LZ4_stream_t structure must be initialized at least once.
- *  This is done with LZ4_initStream(), or LZ4_resetStream().
- *  Consider switching to LZ4_initStream(),
- *  invoking LZ4_resetStream() will trigger deprecation warnings in the future.
- */
-LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
-
-
-#endif /* LZ4_H_98237428734687 */
-
-
-#if defined (__cplusplus)
-}
-#endif
diff --git a/src/duckdb/third_party/mbedtls/include/des_alt.h b/src/duckdb/third_party/mbedtls/include/des_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/des_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/aes.h b/src/duckdb/third_party/mbedtls/include/mbedtls/aes.h
deleted file mode 100644
index 63d7edb48..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/aes.h
+++ /dev/null
@@ -1,640 +0,0 @@
-/**
-* \file aes.h
-*
-* \brief   This file contains AES definitions and functions.
-*
-*          The Advanced Encryption Standard (AES) specifies a FIPS-approved
-*          cryptographic algorithm that can be used to protect electronic
-*          data.
-*
-*          The AES algorithm is a symmetric block cipher that can
-*          encrypt and decrypt information. For more information, see
-*          <em>FIPS Publication 197: Advanced Encryption Standard</em> and
-*          <em>ISO/IEC 18033-2:2006: Information technology -- Security
-*          techniques -- Encryption algorithms -- Part 2: Asymmetric
-*          ciphers</em>.
-*
-*          The AES-XTS block mode is standardized by NIST SP 800-38E
-*          <https://nvlpubs.nist.gov/nistpubs/legacy/sp/nistspecialpublication800-38e.pdf>
-*          and described in detail by IEEE P1619
-*          <https://ieeexplore.ieee.org/servlet/opac?punumber=4375278>.
-*/
-
-/*
-*  Copyright The Mbed TLS Contributors
-*  SPDX-License-Identifier: Apache-2.0
-*
-*  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.
-*/
-
-#ifndef MBEDTLS_AES_H
-#define MBEDTLS_AES_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-#include "mbedtls/platform_util.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-/* padlock.c and aesni.c rely on these values! */
-#define MBEDTLS_AES_ENCRYPT     1 /**< AES encryption. */
-#define MBEDTLS_AES_DECRYPT     0 /**< AES decryption. */
-
-/* Error codes in range 0x0020-0x0022 */
-/** Invalid key length. */
-#define MBEDTLS_ERR_AES_INVALID_KEY_LENGTH                -0x0020
-/** Invalid data input length. */
-#define MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH              -0x0022
-
-/* Error codes in range 0x0021-0x0025 */
-/** Invalid input data. */
-#define MBEDTLS_ERR_AES_BAD_INPUT_DATA                    -0x0021
-
-#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
-   !defined(inline) && !defined(__cplusplus)
-#define inline __inline
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_AES_ALT)
-// Regular implementation
-//
-
-/**
-* \brief The AES context-type definition.
-*/
-typedef struct mbedtls_aes_context
-{
-   int MBEDTLS_PRIVATE(nr);                     /*!< The number of rounds. */
-   uint32_t *MBEDTLS_PRIVATE(rk);               /*!< AES round keys. */
-   uint32_t MBEDTLS_PRIVATE(buf)[68];           /*!< Unaligned data buffer. This buffer can
-						  hold 32 extra Bytes, which can be used for
-						  one of the following purposes:
-						  <ul><li>Alignment if VIA padlock is
-								  used.</li>
-						  <li>Simplifying key expansion in the 256-bit
-							  case by generating an extra round key.
-							  </li></ul> */
-}
-mbedtls_aes_context;
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-/**
-* \brief The AES XTS context-type definition.
-*/
-typedef struct mbedtls_aes_xts_context
-{
-   mbedtls_aes_context MBEDTLS_PRIVATE(crypt); /*!< The AES context to use for AES block
-									   encryption or decryption. */
-   mbedtls_aes_context MBEDTLS_PRIVATE(tweak); /*!< The AES context used for tweak
-									   computation. */
-} mbedtls_aes_xts_context;
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-#else  /* MBEDTLS_AES_ALT */
-#include "mbedtls/aes_alt.h"
-#endif /* MBEDTLS_AES_ALT */
-
-/**
-* \brief          This function initializes the specified AES context.
-*
-*                 It must be the first API called before using
-*                 the context.
-*
-* \param ctx      The AES context to initialize. This must not be \c NULL.
-*/
-void mbedtls_aes_init( mbedtls_aes_context *ctx );
-
-/**
-* \brief          This function releases and clears the specified AES context.
-*
-* \param ctx      The AES context to clear.
-*                 If this is \c NULL, this function does nothing.
-*                 Otherwise, the context must have been at least initialized.
-*/
-void mbedtls_aes_free( mbedtls_aes_context *ctx );
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-/**
-* \brief          This function initializes the specified AES XTS context.
-*
-*                 It must be the first API called before using
-*                 the context.
-*
-* \param ctx      The AES XTS context to initialize. This must not be \c NULL.
-*/
-void mbedtls_aes_xts_init( mbedtls_aes_xts_context *ctx );
-
-/**
-* \brief          This function releases and clears the specified AES XTS context.
-*
-* \param ctx      The AES XTS context to clear.
-*                 If this is \c NULL, this function does nothing.
-*                 Otherwise, the context must have been at least initialized.
-*/
-void mbedtls_aes_xts_free( mbedtls_aes_xts_context *ctx );
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-/**
-* \brief          This function sets the encryption key.
-*
-* \param ctx      The AES context to which the key should be bound.
-*                 It must be initialized.
-* \param key      The encryption key.
-*                 This must be a readable buffer of size \p keybits bits.
-* \param keybits  The size of data passed in bits. Valid options are:
-*                 <ul><li>128 bits</li>
-*                 <li>192 bits</li>
-*                 <li>256 bits</li></ul>
-*
-* \return         \c 0 on success.
-* \return         #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
-						  unsigned int keybits );
-
-/**
-* \brief          This function sets the decryption key.
-*
-* \param ctx      The AES context to which the key should be bound.
-*                 It must be initialized.
-* \param key      The decryption key.
-*                 This must be a readable buffer of size \p keybits bits.
-* \param keybits  The size of data passed. Valid options are:
-*                 <ul><li>128 bits</li>
-*                 <li>192 bits</li>
-*                 <li>256 bits</li></ul>
-*
-* \return         \c 0 on success.
-* \return         #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
-						  unsigned int keybits );
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-/**
-* \brief          This function prepares an XTS context for encryption and
-*                 sets the encryption key.
-*
-* \param ctx      The AES XTS context to which the key should be bound.
-*                 It must be initialized.
-* \param key      The encryption key. This is comprised of the XTS key1
-*                 concatenated with the XTS key2.
-*                 This must be a readable buffer of size \p keybits bits.
-* \param keybits  The size of \p key passed in bits. Valid options are:
-*                 <ul><li>256 bits (each of key1 and key2 is a 128-bit key)</li>
-*                 <li>512 bits (each of key1 and key2 is a 256-bit key)</li></ul>
-*
-* \return         \c 0 on success.
-* \return         #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_xts_setkey_enc( mbedtls_aes_xts_context *ctx,
-							  const unsigned char *key,
-							  unsigned int keybits );
-
-/**
-* \brief          This function prepares an XTS context for decryption and
-*                 sets the decryption key.
-*
-* \param ctx      The AES XTS context to which the key should be bound.
-*                 It must be initialized.
-* \param key      The decryption key. This is comprised of the XTS key1
-*                 concatenated with the XTS key2.
-*                 This must be a readable buffer of size \p keybits bits.
-* \param keybits  The size of \p key passed in bits. Valid options are:
-*                 <ul><li>256 bits (each of key1 and key2 is a 128-bit key)</li>
-*                 <li>512 bits (each of key1 and key2 is a 256-bit key)</li></ul>
-*
-* \return         \c 0 on success.
-* \return         #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,
-							  const unsigned char *key,
-							  unsigned int keybits );
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-/**
-* \brief          This function performs an AES single-block encryption or
-*                 decryption operation.
-*
-*                 It performs the operation defined in the \p mode parameter
-*                 (encrypt or decrypt), on the input data buffer defined in
-*                 the \p input parameter.
-*
-*                 mbedtls_aes_init(), and either mbedtls_aes_setkey_enc() or
-*                 mbedtls_aes_setkey_dec() must be called before the first
-*                 call to this API with the same context.
-*
-* \param ctx      The AES context to use for encryption or decryption.
-*                 It must be initialized and bound to a key.
-* \param mode     The AES operation: #MBEDTLS_AES_ENCRYPT or
-*                 #MBEDTLS_AES_DECRYPT.
-* \param input    The buffer holding the input data.
-*                 It must be readable and at least \c 16 Bytes long.
-* \param output   The buffer where the output data will be written.
-*                 It must be writeable and at least \c 16 Bytes long.
-
-* \return         \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
-						 int mode,
-						 const unsigned char input[16],
-						 unsigned char output[16] );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/**
-* \brief  This function performs an AES-CBC encryption or decryption operation
-*         on full blocks.
-*
-*         It performs the operation defined in the \p mode
-*         parameter (encrypt/decrypt), on the input data buffer defined in
-*         the \p input parameter.
-*
-*         It can be called as many times as needed, until all the input
-*         data is processed. mbedtls_aes_init(), and either
-*         mbedtls_aes_setkey_enc() or mbedtls_aes_setkey_dec() must be called
-*         before the first call to this API with the same context.
-*
-* \note   This function operates on full blocks, that is, the input size
-*         must be a multiple of the AES block size of \c 16 Bytes.
-*
-* \note   Upon exit, the content of the IV is updated so that you can
-*         call the same function again on the next
-*         block(s) of data and get the same result as if it was
-*         encrypted in one call. This allows a "streaming" usage.
-*         If you need to retain the contents of the IV, you should
-*         either save it manually or use the cipher module instead.
-*
-*
-* \param ctx      The AES context to use for encryption or decryption.
-*                 It must be initialized and bound to a key.
-* \param mode     The AES operation: #MBEDTLS_AES_ENCRYPT or
-*                 #MBEDTLS_AES_DECRYPT.
-* \param length   The length of the input data in Bytes. This must be a
-*                 multiple of the block size (\c 16 Bytes).
-* \param iv       Initialization vector (updated after use).
-*                 It must be a readable and writeable buffer of \c 16 Bytes.
-* \param input    The buffer holding the input data.
-*                 It must be readable and of size \p length Bytes.
-* \param output   The buffer holding the output data.
-*                 It must be writeable and of size \p length Bytes.
-*
-* \return         \c 0 on success.
-* \return         #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH
-*                 on failure.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
-						 int mode,
-						 size_t length,
-						 unsigned char iv[16],
-						 const unsigned char *input,
-						 unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-/**
-* \brief      This function performs an AES-XTS encryption or decryption
-*             operation for an entire XTS data unit.
-*
-*             AES-XTS encrypts or decrypts blocks based on their location as
-*             defined by a data unit number. The data unit number must be
-*             provided by \p data_unit.
-*
-*             NIST SP 800-38E limits the maximum size of a data unit to 2^20
-*             AES blocks. If the data unit is larger than this, this function
-*             returns #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH.
-*
-* \param ctx          The AES XTS context to use for AES XTS operations.
-*                     It must be initialized and bound to a key.
-* \param mode         The AES operation: #MBEDTLS_AES_ENCRYPT or
-*                     #MBEDTLS_AES_DECRYPT.
-* \param length       The length of a data unit in Bytes. This can be any
-*                     length between 16 bytes and 2^24 bytes inclusive
-*                     (between 1 and 2^20 block cipher blocks).
-* \param data_unit    The address of the data unit encoded as an array of 16
-*                     bytes in little-endian format. For disk encryption, this
-*                     is typically the index of the block device sector that
-*                     contains the data.
-* \param input        The buffer holding the input data (which is an entire
-*                     data unit). This function reads \p length Bytes from \p
-*                     input.
-* \param output       The buffer holding the output data (which is an entire
-*                     data unit). This function writes \p length Bytes to \p
-*                     output.
-*
-* \return             \c 0 on success.
-* \return             #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH if \p length is
-*                     smaller than an AES block in size (16 Bytes) or if \p
-*                     length is larger than 2^20 blocks (16 MiB).
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_xts( mbedtls_aes_xts_context *ctx,
-						 int mode,
-						 size_t length,
-						 const unsigned char data_unit[16],
-						 const unsigned char *input,
-						 unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/**
-* \brief This function performs an AES-CFB128 encryption or decryption
-*        operation.
-*
-*        It performs the operation defined in the \p mode
-*        parameter (encrypt or decrypt), on the input data buffer
-*        defined in the \p input parameter.
-*
-*        For CFB, you must set up the context with mbedtls_aes_setkey_enc(),
-*        regardless of whether you are performing an encryption or decryption
-*        operation, that is, regardless of the \p mode parameter. This is
-*        because CFB mode uses the same key schedule for encryption and
-*        decryption.
-*
-* \note  Upon exit, the content of the IV is updated so that you can
-*        call the same function again on the next
-*        block(s) of data and get the same result as if it was
-*        encrypted in one call. This allows a "streaming" usage.
-*        If you need to retain the contents of the
-*        IV, you must either save it manually or use the cipher
-*        module instead.
-*
-*
-* \param ctx      The AES context to use for encryption or decryption.
-*                 It must be initialized and bound to a key.
-* \param mode     The AES operation: #MBEDTLS_AES_ENCRYPT or
-*                 #MBEDTLS_AES_DECRYPT.
-* \param length   The length of the input data in Bytes.
-* \param iv_off   The offset in IV (updated after use).
-*                 It must point to a valid \c size_t.
-* \param iv       The initialization vector (updated after use).
-*                 It must be a readable and writeable buffer of \c 16 Bytes.
-* \param input    The buffer holding the input data.
-*                 It must be readable and of size \p length Bytes.
-* \param output   The buffer holding the output data.
-*                 It must be writeable and of size \p length Bytes.
-*
-* \return         \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
-							int mode,
-							size_t length,
-							size_t *iv_off,
-							unsigned char iv[16],
-							const unsigned char *input,
-							unsigned char *output );
-
-/**
-* \brief This function performs an AES-CFB8 encryption or decryption
-*        operation.
-*
-*        It performs the operation defined in the \p mode
-*        parameter (encrypt/decrypt), on the input data buffer defined
-*        in the \p input parameter.
-*
-*        Due to the nature of CFB, you must use the same key schedule for
-*        both encryption and decryption operations. Therefore, you must
-*        use the context initialized with mbedtls_aes_setkey_enc() for
-*        both #MBEDTLS_AES_ENCRYPT and #MBEDTLS_AES_DECRYPT.
-*
-* \note  Upon exit, the content of the IV is updated so that you can
-*        call the same function again on the next
-*        block(s) of data and get the same result as if it was
-*        encrypted in one call. This allows a "streaming" usage.
-*        If you need to retain the contents of the
-*        IV, you should either save it manually or use the cipher
-*        module instead.
-*
-*
-* \param ctx      The AES context to use for encryption or decryption.
-*                 It must be initialized and bound to a key.
-* \param mode     The AES operation: #MBEDTLS_AES_ENCRYPT or
-*                 #MBEDTLS_AES_DECRYPT
-* \param length   The length of the input data.
-* \param iv       The initialization vector (updated after use).
-*                 It must be a readable and writeable buffer of \c 16 Bytes.
-* \param input    The buffer holding the input data.
-*                 It must be readable and of size \p length Bytes.
-* \param output   The buffer holding the output data.
-*                 It must be writeable and of size \p length Bytes.
-*
-* \return         \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
-						  int mode,
-						  size_t length,
-						  unsigned char iv[16],
-						  const unsigned char *input,
-						  unsigned char *output );
-#endif /*MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-/**
-* \brief       This function performs an AES-OFB (Output Feedback Mode)
-*              encryption or decryption operation.
-*
-*              For OFB, you must set up the context with
-*              mbedtls_aes_setkey_enc(), regardless of whether you are
-*              performing an encryption or decryption operation. This is
-*              because OFB mode uses the same key schedule for encryption and
-*              decryption.
-*
-*              The OFB operation is identical for encryption or decryption,
-*              therefore no operation mode needs to be specified.
-*
-* \note        Upon exit, the content of iv, the Initialisation Vector, is
-*              updated so that you can call the same function again on the next
-*              block(s) of data and get the same result as if it was encrypted
-*              in one call. This allows a "streaming" usage, by initialising
-*              iv_off to 0 before the first call, and preserving its value
-*              between calls.
-*
-*              For non-streaming use, the iv should be initialised on each call
-*              to a unique value, and iv_off set to 0 on each call.
-*
-*              If you need to retain the contents of the initialisation vector,
-*              you must either save it manually or use the cipher module
-*              instead.
-*
-* \warning     For the OFB mode, the initialisation vector must be unique
-*              every encryption operation. Reuse of an initialisation vector
-*              will compromise security.
-*
-* \param ctx      The AES context to use for encryption or decryption.
-*                 It must be initialized and bound to a key.
-* \param length   The length of the input data.
-* \param iv_off   The offset in IV (updated after use).
-*                 It must point to a valid \c size_t.
-* \param iv       The initialization vector (updated after use).
-*                 It must be a readable and writeable buffer of \c 16 Bytes.
-* \param input    The buffer holding the input data.
-*                 It must be readable and of size \p length Bytes.
-* \param output   The buffer holding the output data.
-*                 It must be writeable and of size \p length Bytes.
-*
-* \return         \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,
-						 size_t length,
-						 size_t *iv_off,
-						 unsigned char iv[16],
-						 const unsigned char *input,
-						 unsigned char *output );
-
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/**
-* \brief      This function performs an AES-CTR encryption or decryption
-*             operation.
-*
-*             Due to the nature of CTR, you must use the same key schedule
-*             for both encryption and decryption operations. Therefore, you
-*             must use the context initialized with mbedtls_aes_setkey_enc()
-*             for both #MBEDTLS_AES_ENCRYPT and #MBEDTLS_AES_DECRYPT.
-*
-* \warning    You must never reuse a nonce value with the same key. Doing so
-*             would void the encryption for the two messages encrypted with
-*             the same nonce and key.
-*
-*             There are two common strategies for managing nonces with CTR:
-*
-*             1. You can handle everything as a single message processed over
-*             successive calls to this function. In that case, you want to
-*             set \p nonce_counter and \p nc_off to 0 for the first call, and
-*             then preserve the values of \p nonce_counter, \p nc_off and \p
-*             stream_block across calls to this function as they will be
-*             updated by this function.
-*
-*             With this strategy, you must not encrypt more than 2**128
-*             blocks of data with the same key.
-*
-*             2. You can encrypt separate messages by dividing the \p
-*             nonce_counter buffer in two areas: the first one used for a
-*             per-message nonce, handled by yourself, and the second one
-*             updated by this function internally.
-*
-*             For example, you might reserve the first 12 bytes for the
-*             per-message nonce, and the last 4 bytes for internal use. In that
-*             case, before calling this function on a new message you need to
-*             set the first 12 bytes of \p nonce_counter to your chosen nonce
-*             value, the last 4 to 0, and \p nc_off to 0 (which will cause \p
-*             stream_block to be ignored). That way, you can encrypt at most
-*             2**96 messages of up to 2**32 blocks each with the same key.
-*
-*             The per-message nonce (or information sufficient to reconstruct
-*             it) needs to be communicated with the ciphertext and must be unique.
-*             The recommended way to ensure uniqueness is to use a message
-*             counter. An alternative is to generate random nonces, but this
-*             limits the number of messages that can be securely encrypted:
-*             for example, with 96-bit random nonces, you should not encrypt
-*             more than 2**32 messages with the same key.
-*
-*             Note that for both stategies, sizes are measured in blocks and
-*             that an AES block is 16 bytes.
-*
-* \warning    Upon return, \p stream_block contains sensitive data. Its
-*             content must not be written to insecure storage and should be
-*             securely discarded as soon as it's no longer needed.
-*
-* \param ctx              The AES context to use for encryption or decryption.
-*                         It must be initialized and bound to a key.
-* \param length           The length of the input data.
-* \param nc_off           The offset in the current \p stream_block, for
-*                         resuming within the current cipher stream. The
-*                         offset pointer should be 0 at the start of a stream.
-*                         It must point to a valid \c size_t.
-* \param nonce_counter    The 128-bit nonce and counter.
-*                         It must be a readable-writeable buffer of \c 16 Bytes.
-* \param stream_block     The saved stream block for resuming. This is
-*                         overwritten by the function.
-*                         It must be a readable-writeable buffer of \c 16 Bytes.
-* \param input            The buffer holding the input data.
-*                         It must be readable and of size \p length Bytes.
-* \param output           The buffer holding the output data.
-*                         It must be writeable and of size \p length Bytes.
-*
-* \return                 \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
-						 size_t length,
-						 size_t *nc_off,
-						 unsigned char nonce_counter[16],
-						 unsigned char stream_block[16],
-						 const unsigned char *input,
-						 unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-/**
-* \brief           Internal AES block encryption function. This is only
-*                  exposed to allow overriding it using
-*                  \c MBEDTLS_AES_ENCRYPT_ALT.
-*
-* \param ctx       The AES context to use for encryption.
-* \param input     The plaintext block.
-* \param output    The output (ciphertext) block.
-*
-* \return          \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
-								const unsigned char input[16],
-								unsigned char output[16] );
-
-/**
-* \brief           Internal AES block decryption function. This is only
-*                  exposed to allow overriding it using see
-*                  \c MBEDTLS_AES_DECRYPT_ALT.
-*
-* \param ctx       The AES context to use for decryption.
-* \param input     The ciphertext block.
-* \param output    The output (plaintext) block.
-*
-* \return          \c 0 on success.
-*/
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
-								const unsigned char input[16],
-								unsigned char output[16] );
-
-#if defined(MBEDTLS_SELF_TEST)
-/**
-* \brief          Checkup routine.
-*
-* \return         \c 0 on success.
-* \return         \c 1 on failure.
-*/
-MBEDTLS_CHECK_RETURN_CRITICAL
-int mbedtls_aes_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* aes.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/aes_alt.h b/src/duckdb/third_party/mbedtls/include/mbedtls/aes_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/aes_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/aria.h b/src/duckdb/third_party/mbedtls/include/mbedtls/aria.h
deleted file mode 100644
index 4a2634fa8..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/aria.h
+++ /dev/null
@@ -1,358 +0,0 @@
-/**
- * \file aria.h
- *
- * \brief ARIA block cipher
- *
- *        The ARIA algorithm is a symmetric block cipher that can encrypt and
- *        decrypt information. It is defined by the Korean Agency for
- *        Technology and Standards (KATS) in <em>KS X 1213:2004</em> (in
- *        Korean, but see http://210.104.33.10/ARIA/index-e.html in English)
- *        and also described by the IETF in <em>RFC 5794</em>.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_ARIA_H
-#define MBEDTLS_ARIA_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "mbedtls/platform_util.h"
-
-#define MBEDTLS_ARIA_ENCRYPT     1 /**< ARIA encryption. */
-#define MBEDTLS_ARIA_DECRYPT     0 /**< ARIA decryption. */
-
-#define MBEDTLS_ARIA_BLOCKSIZE   16 /**< ARIA block size in bytes. */
-#define MBEDTLS_ARIA_MAX_ROUNDS  16 /**< Maxiumum number of rounds in ARIA. */
-#define MBEDTLS_ARIA_MAX_KEYSIZE 32 /**< Maximum size of an ARIA key in bytes. */
-
-/** Bad input data. */
-#define MBEDTLS_ERR_ARIA_BAD_INPUT_DATA -0x005C
-
-/** Invalid data input length. */
-#define MBEDTLS_ERR_ARIA_INVALID_INPUT_LENGTH -0x005E
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_ARIA_ALT)
-// Regular implementation
-//
-
-/**
- * \brief The ARIA context-type definition.
- */
-typedef struct mbedtls_aria_context
-{
-    unsigned char MBEDTLS_PRIVATE(nr);           /*!< The number of rounds (12, 14 or 16) */
-    /*! The ARIA round keys. */
-    uint32_t MBEDTLS_PRIVATE(rk)[MBEDTLS_ARIA_MAX_ROUNDS + 1][MBEDTLS_ARIA_BLOCKSIZE / 4];
-}
-mbedtls_aria_context;
-
-#else  /* MBEDTLS_ARIA_ALT */
-#include "mbedtls/aria_alt.h"
-#endif /* MBEDTLS_ARIA_ALT */
-
-/**
- * \brief          This function initializes the specified ARIA context.
- *
- *                 It must be the first API called before using
- *                 the context.
- *
- * \param ctx      The ARIA context to initialize. This must not be \c NULL.
- */
-void mbedtls_aria_init( mbedtls_aria_context *ctx );
-
-/**
- * \brief          This function releases and clears the specified ARIA context.
- *
- * \param ctx      The ARIA context to clear. This may be \c NULL, in which
- *                 case this function returns immediately. If it is not \c NULL,
- *                 it must point to an initialized ARIA context.
- */
-void mbedtls_aria_free( mbedtls_aria_context *ctx );
-
-/**
- * \brief          This function sets the encryption key.
- *
- * \param ctx      The ARIA context to which the key should be bound.
- *                 This must be initialized.
- * \param key      The encryption key. This must be a readable buffer
- *                 of size \p keybits Bits.
- * \param keybits  The size of \p key in Bits. Valid options are:
- *                 <ul><li>128 bits</li>
- *                 <li>192 bits</li>
- *                 <li>256 bits</li></ul>
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_aria_setkey_enc( mbedtls_aria_context *ctx,
-                             const unsigned char *key,
-                             unsigned int keybits );
-
-/**
- * \brief          This function sets the decryption key.
- *
- * \param ctx      The ARIA context to which the key should be bound.
- *                 This must be initialized.
- * \param key      The decryption key. This must be a readable buffer
- *                 of size \p keybits Bits.
- * \param keybits  The size of data passed. Valid options are:
- *                 <ul><li>128 bits</li>
- *                 <li>192 bits</li>
- *                 <li>256 bits</li></ul>
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_aria_setkey_dec( mbedtls_aria_context *ctx,
-                             const unsigned char *key,
-                             unsigned int keybits );
-
-/**
- * \brief          This function performs an ARIA single-block encryption or
- *                 decryption operation.
- *
- *                 It performs encryption or decryption (depending on whether
- *                 the key was set for encryption on decryption) on the input
- *                 data buffer defined in the \p input parameter.
- *
- *                 mbedtls_aria_init(), and either mbedtls_aria_setkey_enc() or
- *                 mbedtls_aria_setkey_dec() must be called before the first
- *                 call to this API with the same context.
- *
- * \param ctx      The ARIA context to use for encryption or decryption.
- *                 This must be initialized and bound to a key.
- * \param input    The 16-Byte buffer holding the input data.
- * \param output   The 16-Byte buffer holding the output data.
-
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_aria_crypt_ecb( mbedtls_aria_context *ctx,
-                            const unsigned char input[MBEDTLS_ARIA_BLOCKSIZE],
-                            unsigned char output[MBEDTLS_ARIA_BLOCKSIZE] );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/**
- * \brief  This function performs an ARIA-CBC encryption or decryption operation
- *         on full blocks.
- *
- *         It performs the operation defined in the \p mode
- *         parameter (encrypt/decrypt), on the input data buffer defined in
- *         the \p input parameter.
- *
- *         It can be called as many times as needed, until all the input
- *         data is processed. mbedtls_aria_init(), and either
- *         mbedtls_aria_setkey_enc() or mbedtls_aria_setkey_dec() must be called
- *         before the first call to this API with the same context.
- *
- * \note   This function operates on aligned blocks, that is, the input size
- *         must be a multiple of the ARIA block size of 16 Bytes.
- *
- * \note   Upon exit, the content of the IV is updated so that you can
- *         call the same function again on the next
- *         block(s) of data and get the same result as if it was
- *         encrypted in one call. This allows a "streaming" usage.
- *         If you need to retain the contents of the IV, you should
- *         either save it manually or use the cipher module instead.
- *
- *
- * \param ctx      The ARIA context to use for encryption or decryption.
- *                 This must be initialized and bound to a key.
- * \param mode     The mode of operation. This must be either
- *                 #MBEDTLS_ARIA_ENCRYPT for encryption, or
- *                 #MBEDTLS_ARIA_DECRYPT for decryption.
- * \param length   The length of the input data in Bytes. This must be a
- *                 multiple of the block size (16 Bytes).
- * \param iv       Initialization vector (updated after use).
- *                 This must be a readable buffer of size 16 Bytes.
- * \param input    The buffer holding the input data. This must
- *                 be a readable buffer of length \p length Bytes.
- * \param output   The buffer holding the output data. This must
- *                 be a writable buffer of length \p length Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_aria_crypt_cbc( mbedtls_aria_context *ctx,
-                            int mode,
-                            size_t length,
-                            unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE],
-                            const unsigned char *input,
-                            unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/**
- * \brief This function performs an ARIA-CFB128 encryption or decryption
- *        operation.
- *
- *        It performs the operation defined in the \p mode
- *        parameter (encrypt or decrypt), on the input data buffer
- *        defined in the \p input parameter.
- *
- *        For CFB, you must set up the context with mbedtls_aria_setkey_enc(),
- *        regardless of whether you are performing an encryption or decryption
- *        operation, that is, regardless of the \p mode parameter. This is
- *        because CFB mode uses the same key schedule for encryption and
- *        decryption.
- *
- * \note  Upon exit, the content of the IV is updated so that you can
- *        call the same function again on the next
- *        block(s) of data and get the same result as if it was
- *        encrypted in one call. This allows a "streaming" usage.
- *        If you need to retain the contents of the
- *        IV, you must either save it manually or use the cipher
- *        module instead.
- *
- *
- * \param ctx      The ARIA context to use for encryption or decryption.
- *                 This must be initialized and bound to a key.
- * \param mode     The mode of operation. This must be either
- *                 #MBEDTLS_ARIA_ENCRYPT for encryption, or
- *                 #MBEDTLS_ARIA_DECRYPT for decryption.
- * \param length   The length of the input data \p input in Bytes.
- * \param iv_off   The offset in IV (updated after use).
- *                 This must not be larger than 15.
- * \param iv       The initialization vector (updated after use).
- *                 This must be a readable buffer of size 16 Bytes.
- * \param input    The buffer holding the input data. This must
- *                 be a readable buffer of length \p length Bytes.
- * \param output   The buffer holding the output data. This must
- *                 be a writable buffer of length \p length Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_aria_crypt_cfb128( mbedtls_aria_context *ctx,
-                               int mode,
-                               size_t length,
-                               size_t *iv_off,
-                               unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE],
-                               const unsigned char *input,
-                               unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/**
- * \brief      This function performs an ARIA-CTR encryption or decryption
- *             operation.
- *
- *             This function performs the operation defined in the \p mode
- *             parameter (encrypt/decrypt), on the input data buffer
- *             defined in the \p input parameter.
- *
- *             Due to the nature of CTR, you must use the same key schedule
- *             for both encryption and decryption operations. Therefore, you
- *             must use the context initialized with mbedtls_aria_setkey_enc()
- *             for both #MBEDTLS_ARIA_ENCRYPT and #MBEDTLS_ARIA_DECRYPT.
- *
- * \warning    You must never reuse a nonce value with the same key. Doing so
- *             would void the encryption for the two messages encrypted with
- *             the same nonce and key.
- *
- *             There are two common strategies for managing nonces with CTR:
- *
- *             1. You can handle everything as a single message processed over
- *             successive calls to this function. In that case, you want to
- *             set \p nonce_counter and \p nc_off to 0 for the first call, and
- *             then preserve the values of \p nonce_counter, \p nc_off and \p
- *             stream_block across calls to this function as they will be
- *             updated by this function.
- *
- *             With this strategy, you must not encrypt more than 2**128
- *             blocks of data with the same key.
- *
- *             2. You can encrypt separate messages by dividing the \p
- *             nonce_counter buffer in two areas: the first one used for a
- *             per-message nonce, handled by yourself, and the second one
- *             updated by this function internally.
- *
- *             For example, you might reserve the first 12 bytes for the
- *             per-message nonce, and the last 4 bytes for internal use. In that
- *             case, before calling this function on a new message you need to
- *             set the first 12 bytes of \p nonce_counter to your chosen nonce
- *             value, the last 4 to 0, and \p nc_off to 0 (which will cause \p
- *             stream_block to be ignored). That way, you can encrypt at most
- *             2**96 messages of up to 2**32 blocks each with the same key.
- *
- *             The per-message nonce (or information sufficient to reconstruct
- *             it) needs to be communicated with the ciphertext and must be unique.
- *             The recommended way to ensure uniqueness is to use a message
- *             counter. An alternative is to generate random nonces, but this
- *             limits the number of messages that can be securely encrypted:
- *             for example, with 96-bit random nonces, you should not encrypt
- *             more than 2**32 messages with the same key.
- *
- *             Note that for both stategies, sizes are measured in blocks and
- *             that an ARIA block is 16 bytes.
- *
- * \warning    Upon return, \p stream_block contains sensitive data. Its
- *             content must not be written to insecure storage and should be
- *             securely discarded as soon as it's no longer needed.
- *
- * \param ctx              The ARIA context to use for encryption or decryption.
- *                         This must be initialized and bound to a key.
- * \param length           The length of the input data \p input in Bytes.
- * \param nc_off           The offset in Bytes in the current \p stream_block,
- *                         for resuming within the current cipher stream. The
- *                         offset pointer should be \c 0 at the start of a
- *                         stream. This must not be larger than \c 15 Bytes.
- * \param nonce_counter    The 128-bit nonce and counter. This must point to
- *                         a read/write buffer of length \c 16 bytes.
- * \param stream_block     The saved stream block for resuming. This must
- *                         point to a read/write buffer of length \c 16 bytes.
- *                         This is overwritten by the function.
- * \param input            The buffer holding the input data. This must
- *                         be a readable buffer of length \p length Bytes.
- * \param output           The buffer holding the output data. This must
- *                         be a writable buffer of length \p length Bytes.
- *
- * \return                 \c 0 on success.
- * \return                 A negative error code on failure.
- */
-int mbedtls_aria_crypt_ctr( mbedtls_aria_context *ctx,
-                            size_t length,
-                            size_t *nc_off,
-                            unsigned char nonce_counter[MBEDTLS_ARIA_BLOCKSIZE],
-                            unsigned char stream_block[MBEDTLS_ARIA_BLOCKSIZE],
-                            const unsigned char *input,
-                            unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_SELF_TEST)
-/**
- * \brief          Checkup routine.
- *
- * \return         \c 0 on success, or \c 1 on failure.
- */
-int mbedtls_aria_self_test( int verbose );
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* aria.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/aria_alt.h b/src/duckdb/third_party/mbedtls/include/mbedtls/aria_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/aria_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/asn1.h b/src/duckdb/third_party/mbedtls/include/mbedtls/asn1.h
deleted file mode 100644
index 4746c1cb4..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/asn1.h
+++ /dev/null
@@ -1,633 +0,0 @@
-/**
- * \file asn1.h
- *
- * \brief Generic ASN.1 parsing
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_ASN1_H
-#define MBEDTLS_ASN1_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-#if defined(MBEDTLS_BIGNUM_C)
-#include "mbedtls/bignum.h"
-#endif
-
-/**
- * \addtogroup asn1_module
- * \{
- */
-
-/**
- * \name ASN1 Error codes
- * These error codes are OR'ed to X509 error codes for
- * higher error granularity.
- * ASN1 is a standard to specify data structures.
- * \{
- */
-/** Out of data when parsing an ASN1 data structure. */
-#define MBEDTLS_ERR_ASN1_OUT_OF_DATA                      -0x0060
-/** ASN1 tag was of an unexpected value. */
-#define MBEDTLS_ERR_ASN1_UNEXPECTED_TAG                   -0x0062
-/** Error when trying to determine the length or invalid length. */
-#define MBEDTLS_ERR_ASN1_INVALID_LENGTH                   -0x0064
-/** Actual length differs from expected length. */
-#define MBEDTLS_ERR_ASN1_LENGTH_MISMATCH                  -0x0066
-/** Data is invalid. */
-#define MBEDTLS_ERR_ASN1_INVALID_DATA                     -0x0068
-/** Memory allocation failed */
-#define MBEDTLS_ERR_ASN1_ALLOC_FAILED                     -0x006A
-/** Buffer too small when writing ASN.1 data structure. */
-#define MBEDTLS_ERR_ASN1_BUF_TOO_SMALL                    -0x006C
-
-/* \} name */
-
-/**
- * \name DER constants
- * These constants comply with the DER encoded ASN.1 type tags.
- * DER encoding uses hexadecimal representation.
- * An example DER sequence is:\n
- * - 0x02 -- tag indicating INTEGER
- * - 0x01 -- length in octets
- * - 0x05 -- value
- * Such sequences are typically read into \c ::mbedtls_x509_buf.
- * \{
- */
-#define MBEDTLS_ASN1_BOOLEAN                 0x01
-#define MBEDTLS_ASN1_INTEGER                 0x02
-#define MBEDTLS_ASN1_BIT_STRING              0x03
-#define MBEDTLS_ASN1_OCTET_STRING            0x04
-#define MBEDTLS_ASN1_NULL                    0x05
-#define MBEDTLS_ASN1_OID                     0x06
-#define MBEDTLS_ASN1_ENUMERATED              0x0A
-#define MBEDTLS_ASN1_UTF8_STRING             0x0C
-#define MBEDTLS_ASN1_SEQUENCE                0x10
-#define MBEDTLS_ASN1_SET                     0x11
-#define MBEDTLS_ASN1_PRINTABLE_STRING        0x13
-#define MBEDTLS_ASN1_T61_STRING              0x14
-#define MBEDTLS_ASN1_IA5_STRING              0x16
-#define MBEDTLS_ASN1_UTC_TIME                0x17
-#define MBEDTLS_ASN1_GENERALIZED_TIME        0x18
-#define MBEDTLS_ASN1_UNIVERSAL_STRING        0x1C
-#define MBEDTLS_ASN1_BMP_STRING              0x1E
-#define MBEDTLS_ASN1_PRIMITIVE               0x00
-#define MBEDTLS_ASN1_CONSTRUCTED             0x20
-#define MBEDTLS_ASN1_CONTEXT_SPECIFIC        0x80
-
-/* Slightly smaller way to check if tag is a string tag
- * compared to canonical implementation. */
-#define MBEDTLS_ASN1_IS_STRING_TAG( tag )                                     \
-    ( ( tag ) < 32u && (                                                      \
-        ( ( 1u << ( tag ) ) & ( ( 1u << MBEDTLS_ASN1_BMP_STRING )       |     \
-                                ( 1u << MBEDTLS_ASN1_UTF8_STRING )      |     \
-                                ( 1u << MBEDTLS_ASN1_T61_STRING )       |     \
-                                ( 1u << MBEDTLS_ASN1_IA5_STRING )       |     \
-                                ( 1u << MBEDTLS_ASN1_UNIVERSAL_STRING ) |     \
-                                ( 1u << MBEDTLS_ASN1_PRINTABLE_STRING ) |     \
-                                ( 1u << MBEDTLS_ASN1_BIT_STRING ) ) ) != 0 ) )
-
-/*
- * Bit masks for each of the components of an ASN.1 tag as specified in
- * ITU X.690 (08/2015), section 8.1 "General rules for encoding",
- * paragraph 8.1.2.2:
- *
- * Bit  8     7   6   5          1
- *     +-------+-----+------------+
- *     | Class | P/C | Tag number |
- *     +-------+-----+------------+
- */
-#define MBEDTLS_ASN1_TAG_CLASS_MASK          0xC0
-#define MBEDTLS_ASN1_TAG_PC_MASK             0x20
-#define MBEDTLS_ASN1_TAG_VALUE_MASK          0x1F
-
-/* \} name */
-/* \} addtogroup asn1_module */
-
-/** Returns the size of the binary string, without the trailing \\0 */
-#define MBEDTLS_OID_SIZE(x) (sizeof(x) - 1)
-
-/**
- * Compares an mbedtls_asn1_buf structure to a reference OID.
- *
- * Only works for 'defined' oid_str values (MBEDTLS_OID_HMAC_SHA1), you cannot use a
- * 'unsigned char *oid' here!
- */
-#define MBEDTLS_OID_CMP(oid_str, oid_buf)                                   \
-        ( ( MBEDTLS_OID_SIZE(oid_str) != (oid_buf)->len ) ||                \
-          memcmp( (oid_str), (oid_buf)->p, (oid_buf)->len) != 0 )
-
-#define MBEDTLS_OID_CMP_RAW(oid_str, oid_buf, oid_buf_len)              \
-        ( ( MBEDTLS_OID_SIZE(oid_str) != (oid_buf_len) ) ||             \
-          memcmp( (oid_str), (oid_buf), (oid_buf_len) ) != 0 )
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \name Functions to parse ASN.1 data structures
- * \{
- */
-
-/**
- * Type-length-value structure that allows for ASN1 using DER.
- */
-typedef struct mbedtls_asn1_buf
-{
-    int tag;                /**< ASN1 type, e.g. MBEDTLS_ASN1_UTF8_STRING. */
-    size_t len;             /**< ASN1 length, in octets. */
-    unsigned char *p;       /**< ASN1 data, e.g. in ASCII. */
-}
-mbedtls_asn1_buf;
-
-/**
- * Container for ASN1 bit strings.
- */
-typedef struct mbedtls_asn1_bitstring
-{
-    size_t len;                 /**< ASN1 length, in octets. */
-    unsigned char unused_bits;  /**< Number of unused bits at the end of the string */
-    unsigned char *p;           /**< Raw ASN1 data for the bit string */
-}
-mbedtls_asn1_bitstring;
-
-/**
- * Container for a sequence of ASN.1 items
- */
-typedef struct mbedtls_asn1_sequence
-{
-    mbedtls_asn1_buf buf;                   /**< Buffer containing the given ASN.1 item. */
-
-    /** The next entry in the sequence.
-     *
-     * The details of memory management for sequences are not documented and
-     * may change in future versions. Set this field to \p NULL when
-     * initializing a structure, and do not modify it except via Mbed TLS
-     * library functions.
-     */
-    struct mbedtls_asn1_sequence *next;
-}
-mbedtls_asn1_sequence;
-
-/**
- * Container for a sequence or list of 'named' ASN.1 data items
- */
-typedef struct mbedtls_asn1_named_data
-{
-    mbedtls_asn1_buf oid;                   /**< The object identifier. */
-    mbedtls_asn1_buf val;                   /**< The named value. */
-
-    /** The next entry in the sequence.
-     *
-     * The details of memory management for named data sequences are not
-     * documented and may change in future versions. Set this field to \p NULL
-     * when initializing a structure, and do not modify it except via Mbed TLS
-     * library functions.
-     */
-    struct mbedtls_asn1_named_data *next;
-
-    /** Merge next item into the current one?
-     *
-     * This field exists for the sake of Mbed TLS's X.509 certificate parsing
-     * code and may change in future versions of the library.
-     */
-    unsigned char MBEDTLS_PRIVATE(next_merged);
-}
-mbedtls_asn1_named_data;
-
-/**
- * \brief       Get the length of an ASN.1 element.
- *              Updates the pointer to immediately behind the length.
- *
- * \param p     On entry, \c *p points to the first byte of the length,
- *              i.e. immediately after the tag.
- *              On successful completion, \c *p points to the first byte
- *              after the length, i.e. the first byte of the content.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param len   On successful completion, \c *len contains the length
- *              read from the ASN.1 input.
- *
- * \return      0 if successful.
- * \return      #MBEDTLS_ERR_ASN1_OUT_OF_DATA if the ASN.1 element
- *              would end beyond \p end.
- * \return      #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the length is unparseable.
- */
-int mbedtls_asn1_get_len( unsigned char **p,
-                          const unsigned char *end,
-                          size_t *len );
-
-/**
- * \brief       Get the tag and length of the element.
- *              Check for the requested tag.
- *              Updates the pointer to immediately behind the tag and length.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              after the length, i.e. the first byte of the content.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param len   On successful completion, \c *len contains the length
- *              read from the ASN.1 input.
- * \param tag   The expected tag.
- *
- * \return      0 if successful.
- * \return      #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the data does not start
- *              with the requested tag.
- * \return      #MBEDTLS_ERR_ASN1_OUT_OF_DATA if the ASN.1 element
- *              would end beyond \p end.
- * \return      #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the length is unparseable.
- */
-int mbedtls_asn1_get_tag( unsigned char **p,
-                          const unsigned char *end,
-                          size_t *len, int tag );
-
-/**
- * \brief       Retrieve a boolean ASN.1 tag and its value.
- *              Updates the pointer to immediately behind the full tag.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              beyond the ASN.1 element.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param val   On success, the parsed value (\c 0 or \c 1).
- *
- * \return      0 if successful.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 BOOLEAN.
- */
-int mbedtls_asn1_get_bool( unsigned char **p,
-                           const unsigned char *end,
-                           int *val );
-
-/**
- * \brief       Retrieve an integer ASN.1 tag and its value.
- *              Updates the pointer to immediately behind the full tag.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              beyond the ASN.1 element.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param val   On success, the parsed value.
- *
- * \return      0 if successful.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 INTEGER.
- * \return      #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does
- *              not fit in an \c int.
- */
-int mbedtls_asn1_get_int( unsigned char **p,
-                          const unsigned char *end,
-                          int *val );
-
-/**
- * \brief       Retrieve an enumerated ASN.1 tag and its value.
- *              Updates the pointer to immediately behind the full tag.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              beyond the ASN.1 element.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param val   On success, the parsed value.
- *
- * \return      0 if successful.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 ENUMERATED.
- * \return      #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does
- *              not fit in an \c int.
- */
-int mbedtls_asn1_get_enum( unsigned char **p,
-                           const unsigned char *end,
-                           int *val );
-
-/**
- * \brief       Retrieve a bitstring ASN.1 tag and its value.
- *              Updates the pointer to immediately behind the full tag.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p is equal to \p end.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param bs    On success, ::mbedtls_asn1_bitstring information about
- *              the parsed value.
- *
- * \return      0 if successful.
- * \return      #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input contains
- *              extra data after a valid BIT STRING.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 BIT STRING.
- */
-int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end,
-                                mbedtls_asn1_bitstring *bs );
-
-/**
- * \brief       Retrieve a bitstring ASN.1 tag without unused bits and its
- *              value.
- *              Updates the pointer to the beginning of the bit/octet string.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              of the content of the BIT STRING.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param len   On success, \c *len is the length of the content in bytes.
- *
- * \return      0 if successful.
- * \return      #MBEDTLS_ERR_ASN1_INVALID_DATA if the input starts with
- *              a valid BIT STRING with a nonzero number of unused bits.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 BIT STRING.
- */
-int mbedtls_asn1_get_bitstring_null( unsigned char **p,
-                                     const unsigned char *end,
-                                     size_t *len );
-
-/**
- * \brief       Parses and splits an ASN.1 "SEQUENCE OF <tag>".
- *              Updates the pointer to immediately behind the full sequence tag.
- *
- * This function allocates memory for the sequence elements. You can free
- * the allocated memory with mbedtls_asn1_sequence_free().
- *
- * \note        On error, this function may return a partial list in \p cur.
- *              You must set `cur->next = NULL` before calling this function!
- *              Otherwise it is impossible to distinguish a previously non-null
- *              pointer from a pointer to an object allocated by this function.
- *
- * \note        If the sequence is empty, this function does not modify
- *              \c *cur. If the sequence is valid and non-empty, this
- *              function sets `cur->buf.tag` to \p tag. This allows
- *              callers to distinguish between an empty sequence and
- *              a one-element sequence.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p is equal to \p end.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param cur   A ::mbedtls_asn1_sequence which this function fills.
- *              When this function returns, \c *cur is the head of a linked
- *              list. Each node in this list is allocated with
- *              mbedtls_calloc() apart from \p cur itself, and should
- *              therefore be freed with mbedtls_free().
- *              The list describes the content of the sequence.
- *              The head of the list (i.e. \c *cur itself) describes the
- *              first element, `*cur->next` describes the second element, etc.
- *              For each element, `buf.tag == tag`, `buf.len` is the length
- *              of the content of the content of the element, and `buf.p`
- *              points to the first byte of the content (i.e. immediately
- *              past the length of the element).
- *              Note that list elements may be allocated even on error.
- * \param tag   Each element of the sequence must have this tag.
- *
- * \return      0 if successful.
- * \return      #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input contains
- *              extra data after a valid SEQUENCE OF \p tag.
- * \return      #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the input starts with
- *              an ASN.1 SEQUENCE in which an element has a tag that
- *              is different from \p tag.
- * \return      #MBEDTLS_ERR_ASN1_ALLOC_FAILED if a memory allocation failed.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 SEQUENCE.
- */
-int mbedtls_asn1_get_sequence_of( unsigned char **p,
-                                  const unsigned char *end,
-                                  mbedtls_asn1_sequence *cur,
-                                  int tag );
-/**
- * \brief          Free a heap-allocated linked list presentation of
- *                 an ASN.1 sequence, including the first element.
- *
- * There are two common ways to manage the memory used for the representation
- * of a parsed ASN.1 sequence:
- * - Allocate a head node `mbedtls_asn1_sequence *head` with mbedtls_calloc().
- *   Pass this node as the `cur` argument to mbedtls_asn1_get_sequence_of().
- *   When you have finished processing the sequence,
- *   call mbedtls_asn1_sequence_free() on `head`.
- * - Allocate a head node `mbedtls_asn1_sequence *head` in any manner,
- *   for example on the stack. Make sure that `head->next == NULL`.
- *   Pass `head` as the `cur` argument to mbedtls_asn1_get_sequence_of().
- *   When you have finished processing the sequence,
- *   call mbedtls_asn1_sequence_free() on `head->cur`,
- *   then free `head` itself in the appropriate manner.
- *
- * \param seq      The address of the first sequence component. This may
- *                 be \c NULL, in which case this functions returns
- *                 immediately.
- */
-void mbedtls_asn1_sequence_free( mbedtls_asn1_sequence *seq );
-
-/**
- * \brief                Traverse an ASN.1 SEQUENCE container and
- *                       call a callback for each entry.
- *
- * This function checks that the input is a SEQUENCE of elements that
- * each have a "must" tag, and calls a callback function on the elements
- * that have a "may" tag.
- *
- * For example, to validate that the input is a SEQUENCE of `tag1` and call
- * `cb` on each element, use
- * ```
- * mbedtls_asn1_traverse_sequence_of(&p, end, 0xff, tag1, 0, 0, cb, ctx);
- * ```
- *
- * To validate that the input is a SEQUENCE of ANY and call `cb` on
- * each element, use
- * ```
- * mbedtls_asn1_traverse_sequence_of(&p, end, 0, 0, 0, 0, cb, ctx);
- * ```
- *
- * To validate that the input is a SEQUENCE of CHOICE {NULL, OCTET STRING}
- * and call `cb` on each element that is an OCTET STRING, use
- * ```
- * mbedtls_asn1_traverse_sequence_of(&p, end, 0xfe, 0x04, 0xff, 0x04, cb, ctx);
- * ```
- *
- * The callback is called on the elements with a "may" tag from left to
- * right. If the input is not a valid SEQUENCE of elements with a "must" tag,
- * the callback is called on the elements up to the leftmost point where
- * the input is invalid.
- *
- * \warning              This function is still experimental and may change
- *                       at any time.
- *
- * \param p              The address of the pointer to the beginning of
- *                       the ASN.1 SEQUENCE header. This is updated to
- *                       point to the end of the ASN.1 SEQUENCE container
- *                       on a successful invocation.
- * \param end            The end of the ASN.1 SEQUENCE container.
- * \param tag_must_mask  A mask to be applied to the ASN.1 tags found within
- *                       the SEQUENCE before comparing to \p tag_must_value.
- * \param tag_must_val   The required value of each ASN.1 tag found in the
- *                       SEQUENCE, after masking with \p tag_must_mask.
- *                       Mismatching tags lead to an error.
- *                       For example, a value of \c 0 for both \p tag_must_mask
- *                       and \p tag_must_val means that every tag is allowed,
- *                       while a value of \c 0xFF for \p tag_must_mask means
- *                       that \p tag_must_val is the only allowed tag.
- * \param tag_may_mask   A mask to be applied to the ASN.1 tags found within
- *                       the SEQUENCE before comparing to \p tag_may_value.
- * \param tag_may_val    The desired value of each ASN.1 tag found in the
- *                       SEQUENCE, after masking with \p tag_may_mask.
- *                       Mismatching tags will be silently ignored.
- *                       For example, a value of \c 0 for \p tag_may_mask and
- *                       \p tag_may_val means that any tag will be considered,
- *                       while a value of \c 0xFF for \p tag_may_mask means
- *                       that all tags with value different from \p tag_may_val
- *                       will be ignored.
- * \param cb             The callback to trigger for each component
- *                       in the ASN.1 SEQUENCE that matches \p tag_may_val.
- *                       The callback function is called with the following
- *                       parameters:
- *                       - \p ctx.
- *                       - The tag of the current element.
- *                       - A pointer to the start of the current element's
- *                         content inside the input.
- *                       - The length of the content of the current element.
- *                       If the callback returns a non-zero value,
- *                       the function stops immediately,
- *                       forwarding the callback's return value.
- * \param ctx            The context to be passed to the callback \p cb.
- *
- * \return               \c 0 if successful the entire ASN.1 SEQUENCE
- *                       was traversed without parsing or callback errors.
- * \return               #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input
- *                       contains extra data after a valid SEQUENCE
- *                       of elements with an accepted tag.
- * \return               #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the input starts
- *                       with an ASN.1 SEQUENCE in which an element has a tag
- *                       that is not accepted.
- * \return               An ASN.1 error code if the input does not start with
- *                       a valid ASN.1 SEQUENCE.
- * \return               A non-zero error code forwarded from the callback
- *                       \p cb in case the latter returns a non-zero value.
- */
-int mbedtls_asn1_traverse_sequence_of(
-    unsigned char **p,
-    const unsigned char *end,
-    unsigned char tag_must_mask, unsigned char tag_must_val,
-    unsigned char tag_may_mask, unsigned char tag_may_val,
-    int (*cb)( void *ctx, int tag,
-               unsigned char* start, size_t len ),
-    void *ctx );
-
-#if defined(MBEDTLS_BIGNUM_C)
-/**
- * \brief       Retrieve an integer ASN.1 tag and its value.
- *              Updates the pointer to immediately behind the full tag.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              beyond the ASN.1 element.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param X     On success, the parsed value.
- *
- * \return      0 if successful.
- * \return      An ASN.1 error code if the input does not start with
- *              a valid ASN.1 INTEGER.
- * \return      #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does
- *              not fit in an \c int.
- * \return      An MPI error code if the parsed value is too large.
- */
-int mbedtls_asn1_get_mpi( unsigned char **p,
-                          const unsigned char *end,
-                          mbedtls_mpi *X );
-#endif /* MBEDTLS_BIGNUM_C */
-
-/**
- * \brief       Retrieve an AlgorithmIdentifier ASN.1 sequence.
- *              Updates the pointer to immediately behind the full
- *              AlgorithmIdentifier.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              beyond the AlgorithmIdentifier element.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param alg   The buffer to receive the OID.
- * \param params The buffer to receive the parameters.
- *              This is zeroized if there are no parameters.
- *
- * \return      0 if successful or a specific ASN.1 or MPI error code.
- */
-int mbedtls_asn1_get_alg( unsigned char **p,
-                  const unsigned char *end,
-                  mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params );
-
-/**
- * \brief       Retrieve an AlgorithmIdentifier ASN.1 sequence with NULL or no
- *              params.
- *              Updates the pointer to immediately behind the full
- *              AlgorithmIdentifier.
- *
- * \param p     On entry, \c *p points to the start of the ASN.1 element.
- *              On successful completion, \c *p points to the first byte
- *              beyond the AlgorithmIdentifier element.
- *              On error, the value of \c *p is undefined.
- * \param end   End of data.
- * \param alg   The buffer to receive the OID.
- *
- * \return      0 if successful or a specific ASN.1 or MPI error code.
- */
-int mbedtls_asn1_get_alg_null( unsigned char **p,
-                       const unsigned char *end,
-                       mbedtls_asn1_buf *alg );
-
-/**
- * \brief       Find a specific named_data entry in a sequence or list based on
- *              the OID.
- *
- * \param list  The list to seek through
- * \param oid   The OID to look for
- * \param len   Size of the OID
- *
- * \return      NULL if not found, or a pointer to the existing entry.
- */
-const mbedtls_asn1_named_data *mbedtls_asn1_find_named_data( const mbedtls_asn1_named_data *list,
-                                       const char *oid, size_t len );
-
-/**
- * \brief       Free a mbedtls_asn1_named_data entry
- *
- * \param entry The named data entry to free.
- *              This function calls mbedtls_free() on
- *              `entry->oid.p` and `entry->val.p`.
- */
-void mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *entry );
-
-/**
- * \brief       Free all entries in a mbedtls_asn1_named_data list.
- *
- * \param head  Pointer to the head of the list of named data entries to free.
- *              This function calls mbedtls_asn1_free_named_data() and
- *              mbedtls_free() on each list element and
- *              sets \c *head to \c NULL.
- */
-void mbedtls_asn1_free_named_data_list( mbedtls_asn1_named_data **head );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* asn1.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/asn1write.h b/src/duckdb/third_party/mbedtls/include/mbedtls/asn1write.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/asn1write.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/base64.h b/src/duckdb/third_party/mbedtls/include/mbedtls/base64.h
deleted file mode 100644
index 8378589f3..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/base64.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/**
- * \file base64.h
- *
- * \brief RFC 1521 base64 encoding/decoding
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_BASE64_H
-#define MBEDTLS_BASE64_H
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-/** Output buffer too small. */
-#define MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL               -0x002A
-/** Invalid character in input. */
-#define MBEDTLS_ERR_BASE64_INVALID_CHARACTER              -0x002C
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief          Encode a buffer into base64 format
- *
- * \param dst      destination buffer
- * \param dlen     size of the destination buffer
- * \param olen     number of bytes written
- * \param src      source buffer
- * \param slen     amount of data to be encoded
- *
- * \return         0 if successful, or MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL.
- *                 *olen is always updated to reflect the amount
- *                 of data that has (or would have) been written.
- *                 If that length cannot be represented, then no data is
- *                 written to the buffer and *olen is set to the maximum
- *                 length representable as a size_t.
- *
- * \note           Call this function with dlen = 0 to obtain the
- *                 required buffer size in *olen
- */
-int mbedtls_base64_encode( unsigned char *dst, size_t dlen, size_t *olen,
-                   const unsigned char *src, size_t slen );
-
-/**
- * \brief          Decode a base64-formatted buffer
- *
- * \param dst      destination buffer (can be NULL for checking size)
- * \param dlen     size of the destination buffer
- * \param olen     number of bytes written
- * \param src      source buffer
- * \param slen     amount of data to be decoded
- *
- * \return         0 if successful, MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL, or
- *                 MBEDTLS_ERR_BASE64_INVALID_CHARACTER if the input data is
- *                 not correct. *olen is always updated to reflect the amount
- *                 of data that has (or would have) been written.
- *
- * \note           Call this function with *dst = NULL or dlen = 0 to obtain
- *                 the required buffer size in *olen
- */
-int mbedtls_base64_decode( unsigned char *dst, size_t dlen, size_t *olen,
-                   const unsigned char *src, size_t slen );
-
-#if defined(MBEDTLS_SELF_TEST)
-/**
- * \brief          Checkup routine
- *
- * \return         0 if successful, or 1 if the test failed
- */
-int mbedtls_base64_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* base64.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/bignum.h b/src/duckdb/third_party/mbedtls/include/mbedtls/bignum.h
deleted file mode 100644
index 45d311991..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/bignum.h
+++ /dev/null
@@ -1,1029 +0,0 @@
-/**
- * \file bignum.h
- *
- * \brief Multi-precision integer library
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_BIGNUM_H
-#define MBEDTLS_BIGNUM_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#if defined(MBEDTLS_FS_IO)
-#include <stdio.h>
-#endif
-
-/** An error occurred while reading from or writing to a file. */
-#define MBEDTLS_ERR_MPI_FILE_IO_ERROR                     -0x0002
-/** Bad input parameters to function. */
-#define MBEDTLS_ERR_MPI_BAD_INPUT_DATA                    -0x0004
-/** There is an invalid character in the digit string. */
-#define MBEDTLS_ERR_MPI_INVALID_CHARACTER                 -0x0006
-/** The buffer is too small to write to. */
-#define MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL                  -0x0008
-/** The input arguments are negative or result in illegal output. */
-#define MBEDTLS_ERR_MPI_NEGATIVE_VALUE                    -0x000A
-/** The input argument for division is zero, which is not allowed. */
-#define MBEDTLS_ERR_MPI_DIVISION_BY_ZERO                  -0x000C
-/** The input arguments are not acceptable. */
-#define MBEDTLS_ERR_MPI_NOT_ACCEPTABLE                    -0x000E
-/** Memory allocation failed. */
-#define MBEDTLS_ERR_MPI_ALLOC_FAILED                      -0x0010
-
-#define MBEDTLS_MPI_CHK(f)       \
-    do                           \
-    {                            \
-        if( ( ret = (f) ) != 0 ) \
-            goto cleanup;        \
-    } while( 0 )
-
-/*
- * Maximum size MPIs are allowed to grow to in number of limbs.
- */
-#define MBEDTLS_MPI_MAX_LIMBS                             10000
-
-#if !defined(MBEDTLS_MPI_WINDOW_SIZE)
-/*
- * Maximum window size used for modular exponentiation. Default: 6
- * Minimum value: 1. Maximum value: 6.
- *
- * Result is an array of ( 2 ** MBEDTLS_MPI_WINDOW_SIZE ) MPIs used
- * for the sliding window calculation. (So 64 by default)
- *
- * Reduction in size, reduces speed.
- */
-#define MBEDTLS_MPI_WINDOW_SIZE                           6        /**< Maximum window size used. */
-#endif /* !MBEDTLS_MPI_WINDOW_SIZE */
-
-#if !defined(MBEDTLS_MPI_MAX_SIZE)
-/*
- * Maximum size of MPIs allowed in bits and bytes for user-MPIs.
- * ( Default: 512 bytes => 4096 bits, Maximum tested: 2048 bytes => 16384 bits )
- *
- * Note: Calculations can temporarily result in larger MPIs. So the number
- * of limbs required (MBEDTLS_MPI_MAX_LIMBS) is higher.
- */
-#define MBEDTLS_MPI_MAX_SIZE                              1024     /**< Maximum number of bytes for usable MPIs. */
-#endif /* !MBEDTLS_MPI_MAX_SIZE */
-
-#define MBEDTLS_MPI_MAX_BITS                              ( 8 * MBEDTLS_MPI_MAX_SIZE )    /**< Maximum number of bits for usable MPIs. */
-
-/*
- * When reading from files with mbedtls_mpi_read_file() and writing to files with
- * mbedtls_mpi_write_file() the buffer should have space
- * for a (short) label, the MPI (in the provided radix), the newline
- * characters and the '\0'.
- *
- * By default we assume at least a 10 char label, a minimum radix of 10
- * (decimal) and a maximum of 4096 bit numbers (1234 decimal chars).
- * Autosized at compile time for at least a 10 char label, a minimum radix
- * of 10 (decimal) for a number of MBEDTLS_MPI_MAX_BITS size.
- *
- * This used to be statically sized to 1250 for a maximum of 4096 bit
- * numbers (1234 decimal chars).
- *
- * Calculate using the formula:
- *  MBEDTLS_MPI_RW_BUFFER_SIZE = ceil(MBEDTLS_MPI_MAX_BITS / ln(10) * ln(2)) +
- *                                LabelSize + 6
- */
-#define MBEDTLS_MPI_MAX_BITS_SCALE100          ( 100 * MBEDTLS_MPI_MAX_BITS )
-#define MBEDTLS_LN_2_DIV_LN_10_SCALE100                 332
-#define MBEDTLS_MPI_RW_BUFFER_SIZE             ( ((MBEDTLS_MPI_MAX_BITS_SCALE100 + MBEDTLS_LN_2_DIV_LN_10_SCALE100 - 1) / MBEDTLS_LN_2_DIV_LN_10_SCALE100) + 10 + 6 )
-
-/*
- * Define the base integer type, architecture-wise.
- *
- * 32 or 64-bit integer types can be forced regardless of the underlying
- * architecture by defining MBEDTLS_HAVE_INT32 or MBEDTLS_HAVE_INT64
- * respectively and undefining MBEDTLS_HAVE_ASM.
- *
- * Double-width integers (e.g. 128-bit in 64-bit architectures) can be
- * disabled by defining MBEDTLS_NO_UDBL_DIVISION.
- */
-#if !defined(MBEDTLS_HAVE_INT32)
-    #if defined(_MSC_VER) && defined(_M_AMD64)
-        /* Always choose 64-bit when using MSC */
-        #if !defined(MBEDTLS_HAVE_INT64)
-            #define MBEDTLS_HAVE_INT64
-        #endif /* !MBEDTLS_HAVE_INT64 */
-        typedef  int64_t mbedtls_mpi_sint;
-        typedef uint64_t mbedtls_mpi_uint;
-    #elif defined(__GNUC__) && (                         \
-        defined(__amd64__) || defined(__x86_64__)     || \
-        defined(__ppc64__) || defined(__powerpc64__)  || \
-        defined(__ia64__)  || defined(__alpha__)      || \
-        ( defined(__sparc__) && defined(__arch64__) ) || \
-        defined(__s390x__) || defined(__mips64)       || \
-        defined(__aarch64__) )
-        #if !defined(MBEDTLS_HAVE_INT64)
-            #define MBEDTLS_HAVE_INT64
-        #endif /* MBEDTLS_HAVE_INT64 */
-        typedef  int64_t mbedtls_mpi_sint;
-        typedef uint64_t mbedtls_mpi_uint;
-        #if !defined(MBEDTLS_NO_UDBL_DIVISION)
-            /* mbedtls_t_udbl defined as 128-bit unsigned int */
-            typedef unsigned int mbedtls_t_udbl __attribute__((mode(TI)));
-            #define MBEDTLS_HAVE_UDBL
-        #endif /* !MBEDTLS_NO_UDBL_DIVISION */
-    #elif defined(__ARMCC_VERSION) && defined(__aarch64__)
-        /*
-         * __ARMCC_VERSION is defined for both armcc and armclang and
-         * __aarch64__ is only defined by armclang when compiling 64-bit code
-         */
-        #if !defined(MBEDTLS_HAVE_INT64)
-            #define MBEDTLS_HAVE_INT64
-        #endif /* !MBEDTLS_HAVE_INT64 */
-        typedef  int64_t mbedtls_mpi_sint;
-        typedef uint64_t mbedtls_mpi_uint;
-        #if !defined(MBEDTLS_NO_UDBL_DIVISION)
-            /* mbedtls_t_udbl defined as 128-bit unsigned int */
-            typedef __uint128_t mbedtls_t_udbl;
-            #define MBEDTLS_HAVE_UDBL
-        #endif /* !MBEDTLS_NO_UDBL_DIVISION */
-    #elif defined(MBEDTLS_HAVE_INT64)
-        /* Force 64-bit integers with unknown compiler */
-        typedef  int64_t mbedtls_mpi_sint;
-        typedef uint64_t mbedtls_mpi_uint;
-    #endif
-#endif /* !MBEDTLS_HAVE_INT32 */
-
-#if !defined(MBEDTLS_HAVE_INT64)
-    /* Default to 32-bit compilation */
-    #if !defined(MBEDTLS_HAVE_INT32)
-        #define MBEDTLS_HAVE_INT32
-    #endif /* !MBEDTLS_HAVE_INT32 */
-    typedef  int32_t mbedtls_mpi_sint;
-    typedef uint32_t mbedtls_mpi_uint;
-    #if !defined(MBEDTLS_NO_UDBL_DIVISION)
-        typedef uint64_t mbedtls_t_udbl;
-        #define MBEDTLS_HAVE_UDBL
-    #endif /* !MBEDTLS_NO_UDBL_DIVISION */
-#endif /* !MBEDTLS_HAVE_INT64 */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief          MPI structure
- */
-typedef struct mbedtls_mpi
-{
-    int MBEDTLS_PRIVATE(s);              /*!<  Sign: -1 if the mpi is negative, 1 otherwise */
-    size_t MBEDTLS_PRIVATE(n);           /*!<  total # of limbs  */
-    mbedtls_mpi_uint *MBEDTLS_PRIVATE(p);          /*!<  pointer to limbs  */
-}
-mbedtls_mpi;
-
-/**
- * \brief           Initialize an MPI context.
- *
- *                  This makes the MPI ready to be set or freed,
- *                  but does not define a value for the MPI.
- *
- * \param X         The MPI context to initialize. This must not be \c NULL.
- */
-void mbedtls_mpi_init( mbedtls_mpi *X );
-
-/**
- * \brief          This function frees the components of an MPI context.
- *
- * \param X        The MPI context to be cleared. This may be \c NULL,
- *                 in which case this function is a no-op. If it is
- *                 not \c NULL, it must point to an initialized MPI.
- */
-void mbedtls_mpi_free( mbedtls_mpi *X );
-
-/**
- * \brief          Enlarge an MPI to the specified number of limbs.
- *
- * \note           This function does nothing if the MPI is
- *                 already large enough.
- *
- * \param X        The MPI to grow. It must be initialized.
- * \param nblimbs  The target number of limbs.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs );
-
-/**
- * \brief          This function resizes an MPI downwards, keeping at least the
- *                 specified number of limbs.
- *
- *                 If \c X is smaller than \c nblimbs, it is resized up
- *                 instead.
- *
- * \param X        The MPI to shrink. This must point to an initialized MPI.
- * \param nblimbs  The minimum number of limbs to keep.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed
- *                 (this can only happen when resizing up).
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_shrink( mbedtls_mpi *X, size_t nblimbs );
-
-/**
- * \brief          Make a copy of an MPI.
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param Y        The source MPI. This must point to an initialized MPI.
- *
- * \note           The limb-buffer in the destination MPI is enlarged
- *                 if necessary to hold the value in the source MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_copy( mbedtls_mpi *X, const mbedtls_mpi *Y );
-
-/**
- * \brief          Swap the contents of two MPIs.
- *
- * \param X        The first MPI. It must be initialized.
- * \param Y        The second MPI. It must be initialized.
- */
-void mbedtls_mpi_swap( mbedtls_mpi *X, mbedtls_mpi *Y );
-
-/**
- * \brief          Perform a safe conditional copy of MPI which doesn't
- *                 reveal whether the condition was true or not.
- *
- * \param X        The MPI to conditionally assign to. This must point
- *                 to an initialized MPI.
- * \param Y        The MPI to be assigned from. This must point to an
- *                 initialized MPI.
- * \param assign   The condition deciding whether to perform the
- *                 assignment or not. Possible values:
- *                 * \c 1: Perform the assignment `X = Y`.
- *                 * \c 0: Keep the original value of \p X.
- *
- * \note           This function is equivalent to
- *                      `if( assign ) mbedtls_mpi_copy( X, Y );`
- *                 except that it avoids leaking any information about whether
- *                 the assignment was done or not (the above code may leak
- *                 information through branch prediction and/or memory access
- *                 patterns analysis).
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_safe_cond_assign( mbedtls_mpi *X, const mbedtls_mpi *Y, unsigned char assign );
-
-/**
- * \brief          Perform a safe conditional swap which doesn't
- *                 reveal whether the condition was true or not.
- *
- * \param X        The first MPI. This must be initialized.
- * \param Y        The second MPI. This must be initialized.
- * \param assign   The condition deciding whether to perform
- *                 the swap or not. Possible values:
- *                 * \c 1: Swap the values of \p X and \p Y.
- *                 * \c 0: Keep the original values of \p X and \p Y.
- *
- * \note           This function is equivalent to
- *                      if( assign ) mbedtls_mpi_swap( X, Y );
- *                 except that it avoids leaking any information about whether
- *                 the assignment was done or not (the above code may leak
- *                 information through branch prediction and/or memory access
- *                 patterns analysis).
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on other kinds of failure.
- *
- */
-int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X, mbedtls_mpi *Y, unsigned char assign );
-
-/**
- * \brief          Store integer value in MPI.
- *
- * \param X        The MPI to set. This must be initialized.
- * \param z        The value to use.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_lset( mbedtls_mpi *X, mbedtls_mpi_sint z );
-
-/**
- * \brief          Get a specific bit from an MPI.
- *
- * \param X        The MPI to query. This must be initialized.
- * \param pos      Zero-based index of the bit to query.
- *
- * \return         \c 0 or \c 1 on success, depending on whether bit \c pos
- *                 of \c X is unset or set.
- * \return         A negative error code on failure.
- */
-int mbedtls_mpi_get_bit( const mbedtls_mpi *X, size_t pos );
-
-/**
- * \brief          Modify a specific bit in an MPI.
- *
- * \note           This function will grow the target MPI if necessary to set a
- *                 bit to \c 1 in a not yet existing limb. It will not grow if
- *                 the bit should be set to \c 0.
- *
- * \param X        The MPI to modify. This must be initialized.
- * \param pos      Zero-based index of the bit to modify.
- * \param val      The desired value of bit \c pos: \c 0 or \c 1.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val );
-
-/**
- * \brief          Return the number of bits of value \c 0 before the
- *                 least significant bit of value \c 1.
- *
- * \note           This is the same as the zero-based index of
- *                 the least significant bit of value \c 1.
- *
- * \param X        The MPI to query.
- *
- * \return         The number of bits of value \c 0 before the least significant
- *                 bit of value \c 1 in \p X.
- */
-size_t mbedtls_mpi_lsb( const mbedtls_mpi *X );
-
-/**
- * \brief          Return the number of bits up to and including the most
- *                 significant bit of value \c 1.
- *
- * * \note         This is same as the one-based index of the most
- *                 significant bit of value \c 1.
- *
- * \param X        The MPI to query. This must point to an initialized MPI.
- *
- * \return         The number of bits up to and including the most
- *                 significant bit of value \c 1.
- */
-size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X );
-
-/**
- * \brief          Return the total size of an MPI value in bytes.
- *
- * \param X        The MPI to use. This must point to an initialized MPI.
- *
- * \note           The value returned by this function may be less than
- *                 the number of bytes used to store \p X internally.
- *                 This happens if and only if there are trailing bytes
- *                 of value zero.
- *
- * \return         The least number of bytes capable of storing
- *                 the absolute value of \p X.
- */
-size_t mbedtls_mpi_size( const mbedtls_mpi *X );
-
-/**
- * \brief          Import an MPI from an ASCII string.
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param radix    The numeric base of the input string.
- * \param s        Null-terminated string buffer.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s );
-
-/**
- * \brief          Export an MPI to an ASCII string.
- *
- * \param X        The source MPI. This must point to an initialized MPI.
- * \param radix    The numeric base of the output string.
- * \param buf      The buffer to write the string to. This must be writable
- *                 buffer of length \p buflen Bytes.
- * \param buflen   The available size in Bytes of \p buf.
- * \param olen     The address at which to store the length of the string
- *                 written, including the  final \c NULL byte. This must
- *                 not be \c NULL.
- *
- * \note           You can call this function with `buflen == 0` to obtain the
- *                 minimum required buffer size in `*olen`.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if the target buffer \p buf
- *                 is too small to hold the value of \p X in the desired base.
- *                 In this case, `*olen` is nonetheless updated to contain the
- *                 size of \p buf required for a successful call.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix,
-                              char *buf, size_t buflen, size_t *olen );
-
-#if defined(MBEDTLS_FS_IO)
-/**
- * \brief          Read an MPI from a line in an opened file.
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param radix    The numeric base of the string representation used
- *                 in the source line.
- * \param fin      The input file handle to use. This must not be \c NULL.
- *
- * \note           On success, this function advances the file stream
- *                 to the end of the current line or to EOF.
- *
- *                 The function returns \c 0 on an empty line.
- *
- *                 Leading whitespaces are ignored, as is a
- *                 '0x' prefix for radix \c 16.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if the file read buffer
- *                 is too small.
- * \return         Another negative error code on failure.
- */
-int mbedtls_mpi_read_file( mbedtls_mpi *X, int radix, FILE *fin );
-
-/**
- * \brief          Export an MPI into an opened file.
- *
- * \param p        A string prefix to emit prior to the MPI data.
- *                 For example, this might be a label, or "0x" when
- *                 printing in base \c 16. This may be \c NULL if no prefix
- *                 is needed.
- * \param X        The source MPI. This must point to an initialized MPI.
- * \param radix    The numeric base to be used in the emitted string.
- * \param fout     The output file handle. This may be \c NULL, in which case
- *                 the output is written to \c stdout.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_mpi_write_file( const char *p, const mbedtls_mpi *X,
-                            int radix, FILE *fout );
-#endif /* MBEDTLS_FS_IO */
-
-/**
- * \brief          Import an MPI from unsigned big endian binary data.
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param buf      The input buffer. This must be a readable buffer of length
- *                 \p buflen Bytes.
- * \param buflen   The length of the input buffer \p p in Bytes.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_read_binary( mbedtls_mpi *X, const unsigned char *buf,
-                             size_t buflen );
-
-/**
- * \brief          Import X from unsigned binary data, little endian
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param buf      The input buffer. This must be a readable buffer of length
- *                 \p buflen Bytes.
- * \param buflen   The length of the input buffer \p p in Bytes.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_read_binary_le( mbedtls_mpi *X,
-                                const unsigned char *buf, size_t buflen );
-
-/**
- * \brief          Export X into unsigned binary data, big endian.
- *                 Always fills the whole buffer, which will start with zeros
- *                 if the number is smaller.
- *
- * \param X        The source MPI. This must point to an initialized MPI.
- * \param buf      The output buffer. This must be a writable buffer of length
- *                 \p buflen Bytes.
- * \param buflen   The size of the output buffer \p buf in Bytes.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p buf isn't
- *                 large enough to hold the value of \p X.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_write_binary( const mbedtls_mpi *X, unsigned char *buf,
-                              size_t buflen );
-
-/**
- * \brief          Export X into unsigned binary data, little endian.
- *                 Always fills the whole buffer, which will end with zeros
- *                 if the number is smaller.
- *
- * \param X        The source MPI. This must point to an initialized MPI.
- * \param buf      The output buffer. This must be a writable buffer of length
- *                 \p buflen Bytes.
- * \param buflen   The size of the output buffer \p buf in Bytes.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p buf isn't
- *                 large enough to hold the value of \p X.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_write_binary_le( const mbedtls_mpi *X,
-                                 unsigned char *buf, size_t buflen );
-
-/**
- * \brief          Perform a left-shift on an MPI: X <<= count
- *
- * \param X        The MPI to shift. This must point to an initialized MPI.
- * \param count    The number of bits to shift by.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_shift_l( mbedtls_mpi *X, size_t count );
-
-/**
- * \brief          Perform a right-shift on an MPI: X >>= count
- *
- * \param X        The MPI to shift. This must point to an initialized MPI.
- * \param count    The number of bits to shift by.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count );
-
-/**
- * \brief          Compare the absolute values of two MPIs.
- *
- * \param X        The left-hand MPI. This must point to an initialized MPI.
- * \param Y        The right-hand MPI. This must point to an initialized MPI.
- *
- * \return         \c 1 if `|X|` is greater than `|Y|`.
- * \return         \c -1 if `|X|` is lesser than `|Y|`.
- * \return         \c 0 if `|X|` is equal to `|Y|`.
- */
-int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y );
-
-/**
- * \brief          Compare two MPIs.
- *
- * \param X        The left-hand MPI. This must point to an initialized MPI.
- * \param Y        The right-hand MPI. This must point to an initialized MPI.
- *
- * \return         \c 1 if \p X is greater than \p Y.
- * \return         \c -1 if \p X is lesser than \p Y.
- * \return         \c 0 if \p X is equal to \p Y.
- */
-int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y );
-
-/**
- * \brief          Check if an MPI is less than the other in constant time.
- *
- * \param X        The left-hand MPI. This must point to an initialized MPI
- *                 with the same allocated length as Y.
- * \param Y        The right-hand MPI. This must point to an initialized MPI
- *                 with the same allocated length as X.
- * \param ret      The result of the comparison:
- *                 \c 1 if \p X is less than \p Y.
- *                 \c 0 if \p X is greater than or equal to \p Y.
- *
- * \return         0 on success.
- * \return         MBEDTLS_ERR_MPI_BAD_INPUT_DATA if the allocated length of
- *                 the two input MPIs is not the same.
- */
-int mbedtls_mpi_lt_mpi_ct( const mbedtls_mpi *X, const mbedtls_mpi *Y,
-        unsigned *ret );
-
-/**
- * \brief          Compare an MPI with an integer.
- *
- * \param X        The left-hand MPI. This must point to an initialized MPI.
- * \param z        The integer value to compare \p X to.
- *
- * \return         \c 1 if \p X is greater than \p z.
- * \return         \c -1 if \p X is lesser than \p z.
- * \return         \c 0 if \p X is equal to \p z.
- */
-int mbedtls_mpi_cmp_int( const mbedtls_mpi *X, mbedtls_mpi_sint z );
-
-/**
- * \brief          Perform an unsigned addition of MPIs: X = |A| + |B|
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The first summand. This must point to an initialized MPI.
- * \param B        The second summand. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_add_abs( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform an unsigned subtraction of MPIs: X = |A| - |B|
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The minuend. This must point to an initialized MPI.
- * \param B        The subtrahend. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_NEGATIVE_VALUE if \p B is greater than \p A.
- * \return         Another negative error code on different kinds of failure.
- *
- */
-int mbedtls_mpi_sub_abs( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform a signed addition of MPIs: X = A + B
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The first summand. This must point to an initialized MPI.
- * \param B        The second summand. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform a signed subtraction of MPIs: X = A - B
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The minuend. This must point to an initialized MPI.
- * \param B        The subtrahend. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_sub_mpi( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform a signed addition of an MPI and an integer: X = A + b
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The first summand. This must point to an initialized MPI.
- * \param b        The second summand.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         mbedtls_mpi_sint b );
-
-/**
- * \brief          Perform a signed subtraction of an MPI and an integer:
- *                 X = A - b
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The minuend. This must point to an initialized MPI.
- * \param b        The subtrahend.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         mbedtls_mpi_sint b );
-
-/**
- * \brief          Perform a multiplication of two MPIs: X = A * B
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The first factor. This must point to an initialized MPI.
- * \param B        The second factor. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- *
- */
-int mbedtls_mpi_mul_mpi( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform a multiplication of an MPI with an unsigned integer:
- *                 X = A * b
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The first factor. This must point to an initialized MPI.
- * \param b        The second factor.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- *
- */
-int mbedtls_mpi_mul_int( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         mbedtls_mpi_uint b );
-
-/**
- * \brief          Perform a division with remainder of two MPIs:
- *                 A = Q * B + R
- *
- * \param Q        The destination MPI for the quotient.
- *                 This may be \c NULL if the value of the
- *                 quotient is not needed.
- * \param R        The destination MPI for the remainder value.
- *                 This may be \c NULL if the value of the
- *                 remainder is not needed.
- * \param A        The dividend. This must point to an initialized MPi.
- * \param B        The divisor. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p B equals zero.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_div_mpi( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform a division with remainder of an MPI by an integer:
- *                 A = Q * b + R
- *
- * \param Q        The destination MPI for the quotient.
- *                 This may be \c NULL if the value of the
- *                 quotient is not needed.
- * \param R        The destination MPI for the remainder value.
- *                 This may be \c NULL if the value of the
- *                 remainder is not needed.
- * \param A        The dividend. This must point to an initialized MPi.
- * \param b        The divisor.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p b equals zero.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_div_int( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A,
-                         mbedtls_mpi_sint b );
-
-/**
- * \brief          Perform a modular reduction. R = A mod B
- *
- * \param R        The destination MPI for the residue value.
- *                 This must point to an initialized MPI.
- * \param A        The MPI to compute the residue of.
- *                 This must point to an initialized MPI.
- * \param B        The base of the modular reduction.
- *                 This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p B equals zero.
- * \return         #MBEDTLS_ERR_MPI_NEGATIVE_VALUE if \p B is negative.
- * \return         Another negative error code on different kinds of failure.
- *
- */
-int mbedtls_mpi_mod_mpi( mbedtls_mpi *R, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B );
-
-/**
- * \brief          Perform a modular reduction with respect to an integer.
- *                 r = A mod b
- *
- * \param r        The address at which to store the residue.
- *                 This must not be \c NULL.
- * \param A        The MPI to compute the residue of.
- *                 This must point to an initialized MPi.
- * \param b        The integer base of the modular reduction.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p b equals zero.
- * \return         #MBEDTLS_ERR_MPI_NEGATIVE_VALUE if \p b is negative.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A,
-                         mbedtls_mpi_sint b );
-
-/**
- * \brief          Perform a sliding-window exponentiation: X = A^E mod N
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The base of the exponentiation.
- *                 This must point to an initialized MPI.
- * \param E        The exponent MPI. This must point to an initialized MPI.
- * \param N        The base for the modular reduction. This must point to an
- *                 initialized MPI.
- * \param prec_RR  A helper MPI depending solely on \p N which can be used to
- *                 speed-up multiple modular exponentiations for the same value
- *                 of \p N. This may be \c NULL. If it is not \c NULL, it must
- *                 point to an initialized MPI. If it hasn't been used after
- *                 the call to mbedtls_mpi_init(), this function will compute
- *                 the helper value and store it in \p prec_RR for reuse on
- *                 subsequent calls to this function. Otherwise, the function
- *                 will assume that \p prec_RR holds the helper value set by a
- *                 previous call to mbedtls_mpi_exp_mod(), and reuse it.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \c N is negative or
- *                 even, or if \c E is negative.
- * \return         Another negative error code on different kinds of failures.
- *
- */
-int mbedtls_mpi_exp_mod( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *E, const mbedtls_mpi *N,
-                         mbedtls_mpi *prec_RR );
-
-/**
- * \brief          Fill an MPI with a number of random bytes.
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param size     The number of random bytes to generate.
- * \param f_rng    The RNG function to use. This must not be \c NULL.
- * \param p_rng    The RNG parameter to be passed to \p f_rng. This may be
- *                 \c NULL if \p f_rng doesn't need a context argument.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on failure.
- *
- * \note           The bytes obtained from the RNG are interpreted
- *                 as a big-endian representation of an MPI; this can
- *                 be relevant in applications like deterministic ECDSA.
- */
-int mbedtls_mpi_fill_random( mbedtls_mpi *X, size_t size,
-                     int (*f_rng)(void *, unsigned char *, size_t),
-                     void *p_rng );
-
-/** Generate a random number uniformly in a range.
- *
- * This function generates a random number between \p min inclusive and
- * \p N exclusive.
- *
- * The procedure complies with RFC 6979 §3.3 (deterministic ECDSA)
- * when the RNG is a suitably parametrized instance of HMAC_DRBG
- * and \p min is \c 1.
- *
- * \note           There are `N - min` possible outputs. The lower bound
- *                 \p min can be reached, but the upper bound \p N cannot.
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param min      The minimum value to return.
- *                 It must be nonnegative.
- * \param N        The upper bound of the range, exclusive.
- *                 In other words, this is one plus the maximum value to return.
- *                 \p N must be strictly larger than \p min.
- * \param f_rng    The RNG function to use. This must not be \c NULL.
- * \param p_rng    The RNG parameter to be passed to \p f_rng.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \p min or \p N is invalid
- *                 or if they are incompatible.
- * \return         #MBEDTLS_ERR_MPI_NOT_ACCEPTABLE if the implementation was
- *                 unable to find a suitable value within a limited number
- *                 of attempts. This has a negligible probability if \p N
- *                 is significantly larger than \p min, which is the case
- *                 for all usual cryptographic applications.
- * \return         Another negative error code on failure.
- */
-int mbedtls_mpi_random( mbedtls_mpi *X,
-                        mbedtls_mpi_sint min,
-                        const mbedtls_mpi *N,
-                        int (*f_rng)(void *, unsigned char *, size_t),
-                        void *p_rng );
-
-/**
- * \brief          Compute the greatest common divisor: G = gcd(A, B)
- *
- * \param G        The destination MPI. This must point to an initialized MPI.
- * \param A        The first operand. This must point to an initialized MPI.
- * \param B        The second operand. This must point to an initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         Another negative error code on different kinds of failure.
- */
-int mbedtls_mpi_gcd( mbedtls_mpi *G, const mbedtls_mpi *A,
-                     const mbedtls_mpi *B );
-
-/**
- * \brief          Compute the modular inverse: X = A^-1 mod N
- *
- * \param X        The destination MPI. This must point to an initialized MPI.
- * \param A        The MPI to calculate the modular inverse of. This must point
- *                 to an initialized MPI.
- * \param N        The base of the modular inversion. This must point to an
- *                 initialized MPI.
- *
- * \return         \c 0 if successful.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \p N is less than
- *                 or equal to one.
- * \return         #MBEDTLS_ERR_MPI_NOT_ACCEPTABLE if \p has no modular inverse
- *                 with respect to \p N.
- */
-int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *N );
-
-/**
- * \brief          Miller-Rabin primality test.
- *
- * \warning        If \p X is potentially generated by an adversary, for example
- *                 when validating cryptographic parameters that you didn't
- *                 generate yourself and that are supposed to be prime, then
- *                 \p rounds should be at least the half of the security
- *                 strength of the cryptographic algorithm. On the other hand,
- *                 if \p X is chosen uniformly or non-adversially (as is the
- *                 case when mbedtls_mpi_gen_prime calls this function), then
- *                 \p rounds can be much lower.
- *
- * \param X        The MPI to check for primality.
- *                 This must point to an initialized MPI.
- * \param rounds   The number of bases to perform the Miller-Rabin primality
- *                 test for. The probability of returning 0 on a composite is
- *                 at most 2<sup>-2*\p rounds</sup>.
- * \param f_rng    The RNG function to use. This must not be \c NULL.
- * \param p_rng    The RNG parameter to be passed to \p f_rng.
- *                 This may be \c NULL if \p f_rng doesn't use
- *                 a context parameter.
- *
- * \return         \c 0 if successful, i.e. \p X is probably prime.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_NOT_ACCEPTABLE if \p X is not prime.
- * \return         Another negative error code on other kinds of failure.
- */
-int mbedtls_mpi_is_prime_ext( const mbedtls_mpi *X, int rounds,
-                              int (*f_rng)(void *, unsigned char *, size_t),
-                              void *p_rng );
-/**
- * \brief Flags for mbedtls_mpi_gen_prime()
- *
- * Each of these flags is a constraint on the result X returned by
- * mbedtls_mpi_gen_prime().
- */
-typedef enum {
-    MBEDTLS_MPI_GEN_PRIME_FLAG_DH =      0x0001, /**< (X-1)/2 is prime too */
-    MBEDTLS_MPI_GEN_PRIME_FLAG_LOW_ERR = 0x0002, /**< lower error rate from 2<sup>-80</sup> to 2<sup>-128</sup> */
-} mbedtls_mpi_gen_prime_flag_t;
-
-/**
- * \brief          Generate a prime number.
- *
- * \param X        The destination MPI to store the generated prime in.
- *                 This must point to an initialized MPi.
- * \param nbits    The required size of the destination MPI in bits.
- *                 This must be between \c 3 and #MBEDTLS_MPI_MAX_BITS.
- * \param flags    A mask of flags of type #mbedtls_mpi_gen_prime_flag_t.
- * \param f_rng    The RNG function to use. This must not be \c NULL.
- * \param p_rng    The RNG parameter to be passed to \p f_rng.
- *                 This may be \c NULL if \p f_rng doesn't use
- *                 a context parameter.
- *
- * \return         \c 0 if successful, in which case \p X holds a
- *                 probably prime number.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
- * \return         #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if `nbits` is not between
- *                 \c 3 and #MBEDTLS_MPI_MAX_BITS.
- */
-int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int flags,
-                   int (*f_rng)(void *, unsigned char *, size_t),
-                   void *p_rng );
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          Checkup routine
- *
- * \return         0 if successful, or 1 if the test failed
- */
-int mbedtls_mpi_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* bignum.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/build_info.h b/src/duckdb/third_party/mbedtls/include/mbedtls/build_info.h
deleted file mode 100644
index cef6566c3..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/build_info.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/**
- * \file build_info.h
- *
- * \brief Build-time configuration info
- *
- *  Include this file if you need to depend on the
- *  configuration options defined in mbedtls_config.h or MBEDTLS_CONFIG_FILE
- */
- /*
-  *  Copyright The Mbed TLS Contributors
-  *  SPDX-License-Identifier: Apache-2.0
-  *
-  *  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.
-  */
-
-#ifndef MBEDTLS_BUILD_INFO_H
-#define MBEDTLS_BUILD_INFO_H
-
-/*
- * This set of compile-time defines can be used to determine the version number
- * of the Mbed TLS library used. Run-time variables for the same can be found in
- * version.h
- */
-
-/**
- * The version number x.y.z is split into three parts.
- * Major, Minor, Patchlevel
- */
-#define MBEDTLS_VERSION_MAJOR  3
-#define MBEDTLS_VERSION_MINOR  1
-#define MBEDTLS_VERSION_PATCH  0
-
-/**
- * The single version number has the following structure:
- *    MMNNPP00
- *    Major version | Minor version | Patch version
- */
-#define MBEDTLS_VERSION_NUMBER         0x03010000
-#define MBEDTLS_VERSION_STRING         "3.1.0"
-#define MBEDTLS_VERSION_STRING_FULL    "mbed TLS 3.1.0"
-
-#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
-#define _CRT_SECURE_NO_DEPRECATE 1
-#endif
-
-#if !defined(MBEDTLS_CONFIG_FILE)
-#include "mbedtls/mbedtls_config.h"
-#else
-#include MBEDTLS_CONFIG_FILE
-#endif
-
-#if defined(MBEDTLS_CONFIG_VERSION) && ( \
-    MBEDTLS_CONFIG_VERSION < 0x03000000 || \
-    MBEDTLS_CONFIG_VERSION > MBEDTLS_VERSION_NUMBER )
-#error "Invalid config version, defined value of MBEDTLS_CONFIG_VERSION is unsupported"
-#endif
-
-/* Target and application specific configurations
- *
- * Allow user to override any previous default.
- *
- */
-#if defined(MBEDTLS_USER_CONFIG_FILE)
-#include MBEDTLS_USER_CONFIG_FILE
-#endif
-
-#if defined(MBEDTLS_PSA_CRYPTO_CONFIG)
-#include "mbedtls/config_psa.h"
-#endif
-
-#include "mbedtls/check_config.h"
-
-#endif /* MBEDTLS_BUILD_INFO_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/camellia.h b/src/duckdb/third_party/mbedtls/include/mbedtls/camellia.h
deleted file mode 100644
index c74193171..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/camellia.h
+++ /dev/null
@@ -1,316 +0,0 @@
-/**
- * \file camellia.h
- *
- * \brief Camellia block cipher
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_CAMELLIA_H
-#define MBEDTLS_CAMELLIA_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "mbedtls/platform_util.h"
-
-#define MBEDTLS_CAMELLIA_ENCRYPT     1
-#define MBEDTLS_CAMELLIA_DECRYPT     0
-
-/** Bad input data. */
-#define MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA -0x0024
-
-/** Invalid data input length. */
-#define MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH -0x0026
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_CAMELLIA_ALT)
-// Regular implementation
-//
-
-/**
- * \brief          CAMELLIA context structure
- */
-typedef struct mbedtls_camellia_context
-{
-    int MBEDTLS_PRIVATE(nr);                     /*!<  number of rounds  */
-    uint32_t MBEDTLS_PRIVATE(rk)[68];            /*!<  CAMELLIA round keys    */
-}
-mbedtls_camellia_context;
-
-#else  /* MBEDTLS_CAMELLIA_ALT */
-#include "mbedtls/camellia_alt.h"
-#endif /* MBEDTLS_CAMELLIA_ALT */
-
-/**
- * \brief          Initialize a CAMELLIA context.
- *
- * \param ctx      The CAMELLIA context to be initialized.
- *                 This must not be \c NULL.
- */
-void mbedtls_camellia_init( mbedtls_camellia_context *ctx );
-
-/**
- * \brief          Clear a CAMELLIA context.
- *
- * \param ctx      The CAMELLIA context to be cleared. This may be \c NULL,
- *                 in which case this function returns immediately. If it is not
- *                 \c NULL, it must be initialized.
- */
-void mbedtls_camellia_free( mbedtls_camellia_context *ctx );
-
-/**
- * \brief          Perform a CAMELLIA key schedule operation for encryption.
- *
- * \param ctx      The CAMELLIA context to use. This must be initialized.
- * \param key      The encryption key to use. This must be a readable buffer
- *                 of size \p keybits Bits.
- * \param keybits  The length of \p key in Bits. This must be either \c 128,
- *                 \c 192 or \c 256.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_camellia_setkey_enc( mbedtls_camellia_context *ctx,
-                                 const unsigned char *key,
-                                 unsigned int keybits );
-
-/**
- * \brief          Perform a CAMELLIA key schedule operation for decryption.
- *
- * \param ctx      The CAMELLIA context to use. This must be initialized.
- * \param key      The decryption key. This must be a readable buffer
- *                 of size \p keybits Bits.
- * \param keybits  The length of \p key in Bits. This must be either \c 128,
- *                 \c 192 or \c 256.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx,
-                                 const unsigned char *key,
-                                 unsigned int keybits );
-
-/**
- * \brief          Perform a CAMELLIA-ECB block encryption/decryption operation.
- *
- * \param ctx      The CAMELLIA context to use. This must be initialized
- *                 and bound to a key.
- * \param mode     The mode of operation. This must be either
- *                 #MBEDTLS_CAMELLIA_ENCRYPT or #MBEDTLS_CAMELLIA_DECRYPT.
- * \param input    The input block. This must be a readable buffer
- *                 of size \c 16 Bytes.
- * \param output   The output block. This must be a writable buffer
- *                 of size \c 16 Bytes.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
-                    int mode,
-                    const unsigned char input[16],
-                    unsigned char output[16] );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/**
- * \brief          Perform a CAMELLIA-CBC buffer encryption/decryption operation.
- *
- * \note           Upon exit, the content of the IV is updated so that you can
- *                 call the function same function again on the following
- *                 block(s) of data and get the same result as if it was
- *                 encrypted in one call. This allows a "streaming" usage.
- *                 If on the other hand you need to retain the contents of the
- *                 IV, you should either save it manually or use the cipher
- *                 module instead.
- *
- * \param ctx      The CAMELLIA context to use. This must be initialized
- *                 and bound to a key.
- * \param mode     The mode of operation. This must be either
- *                 #MBEDTLS_CAMELLIA_ENCRYPT or #MBEDTLS_CAMELLIA_DECRYPT.
- * \param length   The length in Bytes of the input data \p input.
- *                 This must be a multiple of \c 16 Bytes.
- * \param iv       The initialization vector. This must be a read/write buffer
- *                 of length \c 16 Bytes. It is updated to allow streaming
- *                 use as explained above.
- * \param input    The buffer holding the input data. This must point to a
- *                 readable buffer of length \p length Bytes.
- * \param output   The buffer holding the output data. This must point to a
- *                 writable buffer of length \p length Bytes.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_camellia_crypt_cbc( mbedtls_camellia_context *ctx,
-                    int mode,
-                    size_t length,
-                    unsigned char iv[16],
-                    const unsigned char *input,
-                    unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/**
- * \brief          Perform a CAMELLIA-CFB128 buffer encryption/decryption
- *                 operation.
- *
- * \note           Due to the nature of CFB mode, you should use the same
- *                 key for both encryption and decryption. In particular, calls
- *                 to this function should be preceded by a key-schedule via
- *                 mbedtls_camellia_setkey_enc() regardless of whether \p mode
- *                 is #MBEDTLS_CAMELLIA_ENCRYPT or #MBEDTLS_CAMELLIA_DECRYPT.
- *
- * \note           Upon exit, the content of the IV is updated so that you can
- *                 call the function same function again on the following
- *                 block(s) of data and get the same result as if it was
- *                 encrypted in one call. This allows a "streaming" usage.
- *                 If on the other hand you need to retain the contents of the
- *                 IV, you should either save it manually or use the cipher
- *                 module instead.
- *
- * \param ctx      The CAMELLIA context to use. This must be initialized
- *                 and bound to a key.
- * \param mode     The mode of operation. This must be either
- *                 #MBEDTLS_CAMELLIA_ENCRYPT or #MBEDTLS_CAMELLIA_DECRYPT.
- * \param length   The length of the input data \p input. Any value is allowed.
- * \param iv_off   The current offset in the IV. This must be smaller
- *                 than \c 16 Bytes. It is updated after this call to allow
- *                 the aforementioned streaming usage.
- * \param iv       The initialization vector. This must be a read/write buffer
- *                 of length \c 16 Bytes. It is updated after this call to
- *                 allow the aforementioned streaming usage.
- * \param input    The buffer holding the input data. This must be a readable
- *                 buffer of size \p length Bytes.
- * \param output   The buffer to hold the output data. This must be a writable
- *                 buffer of length \p length Bytes.
- *
- * \return         \c 0 if successful.
- * \return         A negative error code on failure.
- */
-int mbedtls_camellia_crypt_cfb128( mbedtls_camellia_context *ctx,
-                       int mode,
-                       size_t length,
-                       size_t *iv_off,
-                       unsigned char iv[16],
-                       const unsigned char *input,
-                       unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/**
- * \brief      Perform a CAMELLIA-CTR buffer encryption/decryption operation.
- *
- * *note       Due to the nature of CTR mode, you should use the same
- *             key for both encryption and decryption. In particular, calls
- *             to this function should be preceded by a key-schedule via
- *             mbedtls_camellia_setkey_enc() regardless of whether \p mode
- *             is #MBEDTLS_CAMELLIA_ENCRYPT or #MBEDTLS_CAMELLIA_DECRYPT.
- *
- * \warning    You must never reuse a nonce value with the same key. Doing so
- *             would void the encryption for the two messages encrypted with
- *             the same nonce and key.
- *
- *             There are two common strategies for managing nonces with CTR:
- *
- *             1. You can handle everything as a single message processed over
- *             successive calls to this function. In that case, you want to
- *             set \p nonce_counter and \p nc_off to 0 for the first call, and
- *             then preserve the values of \p nonce_counter, \p nc_off and \p
- *             stream_block across calls to this function as they will be
- *             updated by this function.
- *
- *             With this strategy, you must not encrypt more than 2**128
- *             blocks of data with the same key.
- *
- *             2. You can encrypt separate messages by dividing the \p
- *             nonce_counter buffer in two areas: the first one used for a
- *             per-message nonce, handled by yourself, and the second one
- *             updated by this function internally.
- *
- *             For example, you might reserve the first \c 12 Bytes for the
- *             per-message nonce, and the last \c 4 Bytes for internal use.
- *             In that case, before calling this function on a new message you
- *             need to set the first \c 12 Bytes of \p nonce_counter to your
- *             chosen nonce value, the last four to \c 0, and \p nc_off to \c 0
- *             (which will cause \p stream_block to be ignored). That way, you
- *             can encrypt at most \c 2**96 messages of up to \c 2**32 blocks
- *             each  with the same key.
- *
- *             The per-message nonce (or information sufficient to reconstruct
- *             it) needs to be communicated with the ciphertext and must be
- *             unique. The recommended way to ensure uniqueness is to use a
- *             message counter. An alternative is to generate random nonces,
- *             but this limits the number of messages that can be securely
- *             encrypted: for example, with 96-bit random nonces, you should
- *             not encrypt more than 2**32 messages with the same key.
- *
- *             Note that for both stategies, sizes are measured in blocks and
- *             that a CAMELLIA block is \c 16 Bytes.
- *
- * \warning    Upon return, \p stream_block contains sensitive data. Its
- *             content must not be written to insecure storage and should be
- *             securely discarded as soon as it's no longer needed.
- *
- * \param ctx           The CAMELLIA context to use. This must be initialized
- *                      and bound to a key.
- * \param length        The length of the input data \p input in Bytes.
- *                      Any value is allowed.
- * \param nc_off        The offset in the current \p stream_block (for resuming
- *                      within current cipher stream). The offset pointer to
- *                      should be \c 0 at the start of a stream. It is updated
- *                      at the end of this call.
- * \param nonce_counter The 128-bit nonce and counter. This must be a read/write
- *                      buffer of length \c 16 Bytes.
- * \param stream_block  The saved stream-block for resuming. This must be a
- *                      read/write buffer of length \c 16 Bytes.
- * \param input         The input data stream. This must be a readable buffer of
- *                      size \p length Bytes.
- * \param output        The output data stream. This must be a writable buffer
- *                      of size \p length Bytes.
- *
- * \return              \c 0 if successful.
- * \return              A negative error code on failure.
- */
-int mbedtls_camellia_crypt_ctr( mbedtls_camellia_context *ctx,
-                       size_t length,
-                       size_t *nc_off,
-                       unsigned char nonce_counter[16],
-                       unsigned char stream_block[16],
-                       const unsigned char *input,
-                       unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          Checkup routine
- *
- * \return         0 if successful, or 1 if the test failed
- */
-int mbedtls_camellia_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* camellia.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/camellia_alt.h b/src/duckdb/third_party/mbedtls/include/mbedtls/camellia_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/camellia_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/ccm.h b/src/duckdb/third_party/mbedtls/include/mbedtls/ccm.h
deleted file mode 100644
index 20245d938..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/ccm.h
+++ /dev/null
@@ -1,532 +0,0 @@
-/**
- * \file ccm.h
- *
- * \brief This file provides an API for the CCM authenticated encryption
- *        mode for block ciphers.
- *
- * CCM combines Counter mode encryption with CBC-MAC authentication
- * for 128-bit block ciphers.
- *
- * Input to CCM includes the following elements:
- * <ul><li>Payload - data that is both authenticated and encrypted.</li>
- * <li>Associated data (Adata) - data that is authenticated but not
- * encrypted, For example, a header.</li>
- * <li>Nonce - A unique value that is assigned to the payload and the
- * associated data.</li></ul>
- *
- * Definition of CCM:
- * http://csrc.nist.gov/publications/nistpubs/800-38C/SP800-38C_updated-July20_2007.pdf
- * RFC 3610 "Counter with CBC-MAC (CCM)"
- *
- * Related:
- * RFC 5116 "An Interface and Algorithms for Authenticated Encryption"
- *
- * Definition of CCM*:
- * IEEE 802.15.4 - IEEE Standard for Local and metropolitan area networks
- * Integer representation is fixed most-significant-octet-first order and
- * the representation of octets is most-significant-bit-first order. This is
- * consistent with RFC 3610.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_CCM_H
-#define MBEDTLS_CCM_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/cipher.h"
-
-#define MBEDTLS_CCM_DECRYPT       0
-#define MBEDTLS_CCM_ENCRYPT       1
-#define MBEDTLS_CCM_STAR_DECRYPT  2
-#define MBEDTLS_CCM_STAR_ENCRYPT  3
-
-/** Bad input parameters to the function. */
-#define MBEDTLS_ERR_CCM_BAD_INPUT       -0x000D
-/** Authenticated decryption failed. */
-#define MBEDTLS_ERR_CCM_AUTH_FAILED     -0x000F
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_CCM_ALT)
-// Regular implementation
-//
-
-/**
- * \brief    The CCM context-type definition. The CCM context is passed
- *           to the APIs called.
- */
-typedef struct mbedtls_ccm_context
-{
-    unsigned char MBEDTLS_PRIVATE(y)[16];    /*!< The Y working buffer */
-    unsigned char MBEDTLS_PRIVATE(ctr)[16];  /*!< The counter buffer */
-    mbedtls_cipher_context_t MBEDTLS_PRIVATE(cipher_ctx);    /*!< The cipher context used. */
-    size_t MBEDTLS_PRIVATE(plaintext_len);   /*!< Total plaintext length */
-    size_t MBEDTLS_PRIVATE(add_len);         /*!< Total authentication data length */
-    size_t MBEDTLS_PRIVATE(tag_len);         /*!< Total tag length */
-    size_t MBEDTLS_PRIVATE(processed);       /*!< Track how many bytes of input data
-                                                  were processed (chunked input).
-                                                  Used independently for both auth data
-                                                  and plaintext/ciphertext.
-                                                  This variable is set to zero after
-                                                  auth data input is finished. */
-    unsigned char MBEDTLS_PRIVATE(q);        /*!< The Q working value */
-    unsigned char MBEDTLS_PRIVATE(mode);     /*!< The operation to perform:
-                                                  #MBEDTLS_CCM_ENCRYPT or
-                                                  #MBEDTLS_CCM_DECRYPT or
-                                                  #MBEDTLS_CCM_STAR_ENCRYPT or
-                                                  #MBEDTLS_CCM_STAR_DECRYPT. */
-    int MBEDTLS_PRIVATE(state);              /*!< Working value holding context's
-                                                  state. Used for chunked data
-                                                  input */
-}
-mbedtls_ccm_context;
-
-#else  /* MBEDTLS_CCM_ALT */
-#include "mbedtls/ccm_alt.h"
-#endif /* MBEDTLS_CCM_ALT */
-
-/**
- * \brief           This function initializes the specified CCM context,
- *                  to make references valid, and prepare the context
- *                  for mbedtls_ccm_setkey() or mbedtls_ccm_free().
- *
- * \param ctx       The CCM context to initialize. This must not be \c NULL.
- */
-void mbedtls_ccm_init( mbedtls_ccm_context *ctx );
-
-/**
- * \brief           This function initializes the CCM context set in the
- *                  \p ctx parameter and sets the encryption key.
- *
- * \param ctx       The CCM context to initialize. This must be an initialized
- *                  context.
- * \param cipher    The 128-bit block cipher to use.
- * \param key       The encryption key. This must not be \c NULL.
- * \param keybits   The key size in bits. This must be acceptable by the cipher.
- *
- * \return          \c 0 on success.
- * \return          A CCM or cipher-specific error code on failure.
- */
-int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
-                        mbedtls_cipher_id_t cipher,
-                        const unsigned char *key,
-                        unsigned int keybits );
-
-/**
- * \brief   This function releases and clears the specified CCM context
- *          and underlying cipher sub-context.
- *
- * \param ctx       The CCM context to clear. If this is \c NULL, the function
- *                  has no effect. Otherwise, this must be initialized.
- */
-void mbedtls_ccm_free( mbedtls_ccm_context *ctx );
-
-/**
- * \brief           This function encrypts a buffer using CCM.
- *
- * \note            The tag is written to a separate buffer. To concatenate
- *                  the \p tag with the \p output, as done in <em>RFC-3610:
- *                  Counter with CBC-MAC (CCM)</em>, use
- *                  \p tag = \p output + \p length, and make sure that the
- *                  output buffer is at least \p length + \p tag_len wide.
- *
- * \param ctx       The CCM context to use for encryption. This must be
- *                  initialized and bound to a key.
- * \param length    The length of the input data in Bytes.
- * \param iv        The initialization vector (nonce). This must be a readable
- *                  buffer of at least \p iv_len Bytes.
- * \param iv_len    The length of the nonce in Bytes: 7, 8, 9, 10, 11, 12,
- *                  or 13. The length L of the message length field is
- *                  15 - \p iv_len.
- * \param ad        The additional data field. If \p ad_len is greater than
- *                  zero, \p ad must be a readable buffer of at least that
- *                  length.
- * \param ad_len    The length of additional data in Bytes.
- *                  This must be less than `2^16 - 2^8`.
- * \param input     The buffer holding the input data. If \p length is greater
- *                  than zero, \p input must be a readable buffer of at least
- *                  that length.
- * \param output    The buffer holding the output data. If \p length is greater
- *                  than zero, \p output must be a writable buffer of at least
- *                  that length.
- * \param tag       The buffer holding the authentication field. This must be a
- *                  writable buffer of at least \p tag_len Bytes.
- * \param tag_len   The length of the authentication field to generate in Bytes:
- *                  4, 6, 8, 10, 12, 14 or 16.
- *
- * \return          \c 0 on success.
- * \return          A CCM or cipher-specific error code on failure.
- */
-int mbedtls_ccm_encrypt_and_tag( mbedtls_ccm_context *ctx, size_t length,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, unsigned char *output,
-                         unsigned char *tag, size_t tag_len );
-
-/**
- * \brief           This function encrypts a buffer using CCM*.
- *
- * \note            The tag is written to a separate buffer. To concatenate
- *                  the \p tag with the \p output, as done in <em>RFC-3610:
- *                  Counter with CBC-MAC (CCM)</em>, use
- *                  \p tag = \p output + \p length, and make sure that the
- *                  output buffer is at least \p length + \p tag_len wide.
- *
- * \note            When using this function in a variable tag length context,
- *                  the tag length has to be encoded into the \p iv passed to
- *                  this function.
- *
- * \param ctx       The CCM context to use for encryption. This must be
- *                  initialized and bound to a key.
- * \param length    The length of the input data in Bytes.
- *                  For tag length = 0, input length is ignored.
- * \param iv        The initialization vector (nonce). This must be a readable
- *                  buffer of at least \p iv_len Bytes.
- * \param iv_len    The length of the nonce in Bytes: 7, 8, 9, 10, 11, 12,
- *                  or 13. The length L of the message length field is
- *                  15 - \p iv_len.
- * \param ad        The additional data field. This must be a readable buffer of
- *                  at least \p ad_len Bytes.
- * \param ad_len    The length of additional data in Bytes.
- *                  This must be less than 2^16 - 2^8.
- * \param input     The buffer holding the input data. If \p length is greater
- *                  than zero, \p input must be a readable buffer of at least
- *                  that length.
- * \param output    The buffer holding the output data. If \p length is greater
- *                  than zero, \p output must be a writable buffer of at least
- *                  that length.
- * \param tag       The buffer holding the authentication field. This must be a
- *                  writable buffer of at least \p tag_len Bytes.
- * \param tag_len   The length of the authentication field to generate in Bytes:
- *                  0, 4, 6, 8, 10, 12, 14 or 16.
- *
- * \warning         Passing \c 0 as \p tag_len means that the message is no
- *                  longer authenticated.
- *
- * \return          \c 0 on success.
- * \return          A CCM or cipher-specific error code on failure.
- */
-int mbedtls_ccm_star_encrypt_and_tag( mbedtls_ccm_context *ctx, size_t length,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, unsigned char *output,
-                         unsigned char *tag, size_t tag_len );
-
-/**
- * \brief           This function performs a CCM authenticated decryption of a
- *                  buffer.
- *
- * \param ctx       The CCM context to use for decryption. This must be
- *                  initialized and bound to a key.
- * \param length    The length of the input data in Bytes.
- * \param iv        The initialization vector (nonce). This must be a readable
- *                  buffer of at least \p iv_len Bytes.
- * \param iv_len    The length of the nonce in Bytes: 7, 8, 9, 10, 11, 12,
- *                  or 13. The length L of the message length field is
- *                  15 - \p iv_len.
- * \param ad        The additional data field. This must be a readable buffer
- *                  of at least that \p ad_len Bytes..
- * \param ad_len    The length of additional data in Bytes.
- *                  This must be less than 2^16 - 2^8.
- * \param input     The buffer holding the input data. If \p length is greater
- *                  than zero, \p input must be a readable buffer of at least
- *                  that length.
- * \param output    The buffer holding the output data. If \p length is greater
- *                  than zero, \p output must be a writable buffer of at least
- *                  that length.
- * \param tag       The buffer holding the authentication field. This must be a
- *                  readable buffer of at least \p tag_len Bytes.
- * \param tag_len   The length of the authentication field to generate in Bytes:
- *                  4, 6, 8, 10, 12, 14 or 16.
- *
- * \return          \c 0 on success. This indicates that the message is authentic.
- * \return          #MBEDTLS_ERR_CCM_AUTH_FAILED if the tag does not match.
- * \return          A cipher-specific error code on calculation failure.
- */
-int mbedtls_ccm_auth_decrypt( mbedtls_ccm_context *ctx, size_t length,
-                      const unsigned char *iv, size_t iv_len,
-                      const unsigned char *ad, size_t ad_len,
-                      const unsigned char *input, unsigned char *output,
-                      const unsigned char *tag, size_t tag_len );
-
-/**
- * \brief           This function performs a CCM* authenticated decryption of a
- *                  buffer.
- *
- * \note            When using this function in a variable tag length context,
- *                  the tag length has to be decoded from \p iv and passed to
- *                  this function as \p tag_len. (\p tag needs to be adjusted
- *                  accordingly.)
- *
- * \param ctx       The CCM context to use for decryption. This must be
- *                  initialized and bound to a key.
- * \param length    The length of the input data in Bytes.
- *                  For tag length = 0, input length is ignored.
- * \param iv        The initialization vector (nonce). This must be a readable
- *                  buffer of at least \p iv_len Bytes.
- * \param iv_len    The length of the nonce in Bytes: 7, 8, 9, 10, 11, 12,
- *                  or 13. The length L of the message length field is
- *                  15 - \p iv_len.
- * \param ad        The additional data field. This must be a readable buffer of
- *                  at least that \p ad_len Bytes.
- * \param ad_len    The length of additional data in Bytes.
- *                  This must be less than 2^16 - 2^8.
- * \param input     The buffer holding the input data. If \p length is greater
- *                  than zero, \p input must be a readable buffer of at least
- *                  that length.
- * \param output    The buffer holding the output data. If \p length is greater
- *                  than zero, \p output must be a writable buffer of at least
- *                  that length.
- * \param tag       The buffer holding the authentication field. This must be a
- *                  readable buffer of at least \p tag_len Bytes.
- * \param tag_len   The length of the authentication field in Bytes.
- *                  0, 4, 6, 8, 10, 12, 14 or 16.
- *
- * \warning         Passing \c 0 as \p tag_len means that the message is nos
- *                  longer authenticated.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_CCM_AUTH_FAILED if the tag does not match.
- * \return          A cipher-specific error code on calculation failure.
- */
-int mbedtls_ccm_star_auth_decrypt( mbedtls_ccm_context *ctx, size_t length,
-                      const unsigned char *iv, size_t iv_len,
-                      const unsigned char *ad, size_t ad_len,
-                      const unsigned char *input, unsigned char *output,
-                      const unsigned char *tag, size_t tag_len );
-
-/**
- * \brief           This function starts a CCM encryption or decryption
- *                  operation.
- *
- *                  This function and mbedtls_ccm_set_lengths() must be called
- *                  before calling mbedtls_ccm_update_ad() or
- *                  mbedtls_ccm_update(). This function can be called before
- *                  or after mbedtls_ccm_set_lengths().
- *
- * \note            This function is not implemented in Mbed TLS yet.
- *
- * \param ctx       The CCM context. This must be initialized.
- * \param mode      The operation to perform: #MBEDTLS_CCM_ENCRYPT or
- *                  #MBEDTLS_CCM_DECRYPT or #MBEDTLS_CCM_STAR_ENCRYPT or
- *                  #MBEDTLS_CCM_STAR_DECRYPT.
- * \param iv        The initialization vector. This must be a readable buffer
- *                  of at least \p iv_len Bytes.
- * \param iv_len    The length of the nonce in Bytes: 7, 8, 9, 10, 11, 12,
- *                  or 13. The length L of the message length field is
- *                  15 - \p iv_len.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_CCM_BAD_INPUT on failure:
- *                  \p ctx is in an invalid state,
- *                  \p mode is invalid,
- *                  \p iv_len is invalid (lower than \c 7 or greater than
- *                  \c 13).
- */
-int mbedtls_ccm_starts( mbedtls_ccm_context *ctx,
-                        int mode,
-                        const unsigned char *iv,
-                        size_t iv_len );
-
-/**
- * \brief           This function declares the lengths of the message
- *                  and additional data for a CCM encryption or decryption
- *                  operation.
- *
- *                  This function and mbedtls_ccm_starts() must be called
- *                  before calling mbedtls_ccm_update_ad() or
- *                  mbedtls_ccm_update(). This function can be called before
- *                  or after mbedtls_ccm_starts().
- *
- * \note            This function is not implemented in Mbed TLS yet.
- *
- * \param ctx       The CCM context. This must be initialized.
- * \param total_ad_len   The total length of additional data in bytes.
- *                       This must be less than `2^16 - 2^8`.
- * \param plaintext_len  The length in bytes of the plaintext to encrypt or
- *                       result of the decryption (thus not encompassing the
- *                       additional data that are not encrypted).
- * \param tag_len   The length of the tag to generate in Bytes:
- *                  4, 6, 8, 10, 12, 14 or 16.
- *                  For CCM*, zero is also valid.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_CCM_BAD_INPUT on failure:
- *                  \p ctx is in an invalid state,
- *                  \p total_ad_len is greater than \c 0xFF00.
- */
-int mbedtls_ccm_set_lengths( mbedtls_ccm_context *ctx,
-                             size_t total_ad_len,
-                             size_t plaintext_len,
-                             size_t tag_len );
-
-/**
- * \brief           This function feeds an input buffer as associated data
- *                  (authenticated but not encrypted data) in a CCM
- *                  encryption or decryption operation.
- *
- *                  You may call this function zero, one or more times
- *                  to pass successive parts of the additional data. The
- *                  lengths \p ad_len of the data parts should eventually add
- *                  up exactly to the total length of additional data
- *                  \c total_ad_len passed to mbedtls_ccm_set_lengths(). You
- *                  may not call this function after calling
- *                  mbedtls_ccm_update().
- *
- * \note            This function is not implemented in Mbed TLS yet.
- *
- * \param ctx       The CCM context. This must have been started with
- *                  mbedtls_ccm_starts(), the lengths of the message and
- *                  additional data must have been declared with
- *                  mbedtls_ccm_set_lengths() and this must not have yet
- *                  received any input with mbedtls_ccm_update().
- * \param ad        The buffer holding the additional data, or \c NULL
- *                  if \p ad_len is \c 0.
- * \param ad_len    The length of the additional data. If \c 0,
- *                  \p ad may be \c NULL.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_CCM_BAD_INPUT on failure:
- *                  \p ctx is in an invalid state,
- *                  total input length too long.
- */
-int mbedtls_ccm_update_ad( mbedtls_ccm_context *ctx,
-                           const unsigned char *ad,
-                           size_t ad_len );
-
-/**
- * \brief           This function feeds an input buffer into an ongoing CCM
- *                  encryption or decryption operation.
- *
- *                  You may call this function zero, one or more times
- *                  to pass successive parts of the input: the plaintext to
- *                  encrypt, or the ciphertext (not including the tag) to
- *                  decrypt. After the last part of the input, call
- *                  mbedtls_ccm_finish(). The lengths \p input_len of the
- *                  data parts should eventually add up exactly to the
- *                  plaintext length \c plaintext_len passed to
- *                  mbedtls_ccm_set_lengths().
- *
- *                  This function may produce output in one of the following
- *                  ways:
- *                  - Immediate output: the output length is always equal
- *                    to the input length.
- *                  - Buffered output: except for the last part of input data,
- *                    the output consists of a whole number of 16-byte blocks.
- *                    If the total input length so far (not including
- *                    associated data) is 16 \* *B* + *A* with *A* < 16 then
- *                    the total output length is 16 \* *B*.
- *                    For the last part of input data, the output length is
- *                    equal to the input length plus the number of bytes (*A*)
- *                    buffered in the previous call to the function (if any).
- *                    The function uses the plaintext length
- *                    \c plaintext_len passed to mbedtls_ccm_set_lengths()
- *                    to detect the last part of input data.
- *
- *                  In particular:
- *                  - It is always correct to call this function with
- *                    \p output_size >= \p input_len + 15.
- *                  - If \p input_len is a multiple of 16 for all the calls
- *                    to this function during an operation (not necessary for
- *                    the last one) then it is correct to use \p output_size
- *                    =\p input_len.
- *
- * \note            This function is not implemented in Mbed TLS yet.
- *
- * \param ctx           The CCM context. This must have been started with
- *                      mbedtls_ccm_starts() and the lengths of the message and
- *                      additional data must have been declared with
- *                      mbedtls_ccm_set_lengths().
- * \param input         The buffer holding the input data. If \p input_len
- *                      is greater than zero, this must be a readable buffer
- *                      of at least \p input_len bytes.
- * \param input_len     The length of the input data in bytes.
- * \param output        The buffer for the output data. If \p output_size
- *                      is greater than zero, this must be a writable buffer of
- *                      at least \p output_size bytes.
- * \param output_size   The size of the output buffer in bytes.
- *                      See the function description regarding the output size.
- * \param output_len    On success, \p *output_len contains the actual
- *                      length of the output written in \p output.
- *                      On failure, the content of \p *output_len is
- *                      unspecified.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_CCM_BAD_INPUT on failure:
- *                 \p ctx is in an invalid state,
- *                 total input length too long,
- *                 or \p output_size too small.
- */
-int mbedtls_ccm_update( mbedtls_ccm_context *ctx,
-                        const unsigned char *input, size_t input_len,
-                        unsigned char *output, size_t output_size,
-                        size_t *output_len );
-
-/**
- * \brief           This function finishes the CCM operation and generates
- *                  the authentication tag.
- *
- *                  It wraps up the CCM stream, and generates the
- *                  tag. The tag can have a maximum length of 16 Bytes.
- *
- * \note            This function is not implemented in Mbed TLS yet.
- *
- * \param ctx       The CCM context. This must have been started with
- *                  mbedtls_ccm_starts() and the lengths of the message and
- *                  additional data must have been declared with
- *                  mbedtls_ccm_set_lengths().
- * \param tag       The buffer for holding the tag. If \p tag_len is greater
- *                  than zero, this must be a writable buffer of at least \p
- *                  tag_len Bytes.
- * \param tag_len   The length of the tag. Must match the tag length passed to
- *                  mbedtls_ccm_set_lengths() function.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_CCM_BAD_INPUT on failure:
- *                  \p ctx is in an invalid state,
- *                  invalid value of \p tag_len,
- *                  the total amount of additional data passed to
- *                  mbedtls_ccm_update_ad() was lower than the total length of
- *                  additional data \c total_ad_len passed to
- *                  mbedtls_ccm_set_lengths(),
- *                  the total amount of input data passed to
- *                  mbedtls_ccm_update() was lower than the plaintext length
- *                  \c plaintext_len passed to mbedtls_ccm_set_lengths().
- */
-int mbedtls_ccm_finish( mbedtls_ccm_context *ctx,
-                        unsigned char *tag, size_t tag_len );
-
-#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
-/**
- * \brief          The CCM checkup routine.
- *
- * \return         \c 0 on success.
- * \return         \c 1 on failure.
- */
-int mbedtls_ccm_self_test( int verbose );
-#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_CCM_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/ccm_alt.h b/src/duckdb/third_party/mbedtls/include/mbedtls/ccm_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/ccm_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/chacha20.h b/src/duckdb/third_party/mbedtls/include/mbedtls/chacha20.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/chacha20.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/chachapoly.h b/src/duckdb/third_party/mbedtls/include/mbedtls/chachapoly.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/chachapoly.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/check_config.h b/src/duckdb/third_party/mbedtls/include/mbedtls/check_config.h
deleted file mode 100644
index ce97f6a35..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/check_config.h
+++ /dev/null
@@ -1,833 +0,0 @@
-/**
- * \file check_config.h
- *
- * \brief Consistency checks for configuration options
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_CHECK_CONFIG_H
-#define MBEDTLS_CHECK_CONFIG_H
-
-/*
- * We assume CHAR_BIT is 8 in many places. In practice, this is true on our
- * target platforms, so not an issue, but let's just be extra sure.
- */
-#include <limits.h>
-#if CHAR_BIT != 8
-#error "mbed TLS requires a platform with 8-bit chars"
-#endif
-
-#if defined(_WIN32)
-#if !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_C is required on Windows"
-#endif
-
-/* Fix the config here. Not convenient to put an #ifdef _WIN32 in mbedtls_config.h as
- * it would confuse config.py. */
-#if !defined(MBEDTLS_PLATFORM_SNPRINTF_ALT) && \
-    !defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO)
-#define MBEDTLS_PLATFORM_SNPRINTF_ALT
-#endif
-
-#if !defined(MBEDTLS_PLATFORM_VSNPRINTF_ALT) && \
-    !defined(MBEDTLS_PLATFORM_VSNPRINTF_MACRO)
-#define MBEDTLS_PLATFORM_VSNPRINTF_ALT
-#endif
-#endif /* _WIN32 */
-
-#if defined(TARGET_LIKE_MBED) && defined(MBEDTLS_NET_C)
-#error "The NET module is not available for mbed OS - please use the network functions provided by Mbed OS"
-#endif
-
-#if defined(MBEDTLS_DEPRECATED_WARNING) && \
-    !defined(__GNUC__) && !defined(__clang__)
-#error "MBEDTLS_DEPRECATED_WARNING only works with GCC and Clang"
-#endif
-
-#if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_HAVE_TIME)
-#error "MBEDTLS_HAVE_TIME_DATE without MBEDTLS_HAVE_TIME does not make sense"
-#endif
-
-#if defined(MBEDTLS_AESNI_C) && !defined(MBEDTLS_HAVE_ASM)
-#error "MBEDTLS_AESNI_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_CTR_DRBG_C) && !defined(MBEDTLS_AES_C)
-#error "MBEDTLS_CTR_DRBG_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_DHM_C) && !defined(MBEDTLS_BIGNUM_C)
-#error "MBEDTLS_DHM_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_CMAC_C) && \
-    !defined(MBEDTLS_AES_C) && !defined(MBEDTLS_DES_C)
-#error "MBEDTLS_CMAC_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_NIST_KW_C) && \
-    ( !defined(MBEDTLS_AES_C) || !defined(MBEDTLS_CIPHER_C) )
-#error "MBEDTLS_NIST_KW_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECDH_C) && !defined(MBEDTLS_ECP_C)
-#error "MBEDTLS_ECDH_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECDSA_C) &&            \
-    ( !defined(MBEDTLS_ECP_C) ||           \
-      !( defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED) || \
-         defined(MBEDTLS_ECP_DP_BP256R1_ENABLED) ||   \
-         defined(MBEDTLS_ECP_DP_BP384R1_ENABLED) ||   \
-         defined(MBEDTLS_ECP_DP_BP512R1_ENABLED) ) || \
-      !defined(MBEDTLS_ASN1_PARSE_C) ||    \
-      !defined(MBEDTLS_ASN1_WRITE_C) )
-#error "MBEDTLS_ECDSA_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECJPAKE_C) &&           \
-    ( !defined(MBEDTLS_ECP_C) || !defined(MBEDTLS_MD_C) )
-#error "MBEDTLS_ECJPAKE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_RESTARTABLE)           && \
-    ( defined(MBEDTLS_USE_PSA_CRYPTO)          || \
-      defined(MBEDTLS_ECDH_COMPUTE_SHARED_ALT) || \
-      defined(MBEDTLS_ECDH_GEN_PUBLIC_ALT)     || \
-      defined(MBEDTLS_ECDSA_SIGN_ALT)          || \
-      defined(MBEDTLS_ECDSA_VERIFY_ALT)        || \
-      defined(MBEDTLS_ECDSA_GENKEY_ALT)        || \
-      defined(MBEDTLS_ECP_INTERNAL_ALT)        || \
-      defined(MBEDTLS_ECP_ALT) )
-#error "MBEDTLS_ECP_RESTARTABLE defined, but it cannot coexist with an alternative or PSA-based ECP implementation"
-#endif
-
-#if defined(MBEDTLS_ECDSA_DETERMINISTIC) && !defined(MBEDTLS_HMAC_DRBG_C)
-#error "MBEDTLS_ECDSA_DETERMINISTIC defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_C) && ( !defined(MBEDTLS_BIGNUM_C) || (    \
-    !defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)   &&                  \
-    !defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)   &&                  \
-    !defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)   &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED) &&                  \
-    !defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED) &&                 \
-    !defined(MBEDTLS_ECP_DP_CURVE448_ENABLED) ) )
-#error "MBEDTLS_ECP_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PK_PARSE_C) && !defined(MBEDTLS_ASN1_PARSE_C)
-#error "MBEDTLS_PK_PARSE_C defined, but not all prerequesites"
-#endif
-
-#if defined(MBEDTLS_ENTROPY_C) && (!defined(MBEDTLS_SHA512_C) &&      \
-                                    !defined(MBEDTLS_SHA256_C))
-#error "MBEDTLS_ENTROPY_C defined, but not all prerequisites"
-#endif
-#if defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_SHA512_C) &&         \
-    defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) && (MBEDTLS_CTR_DRBG_ENTROPY_LEN > 64)
-#error "MBEDTLS_CTR_DRBG_ENTROPY_LEN value too high"
-#endif
-#if defined(MBEDTLS_ENTROPY_C) &&                                            \
-    ( !defined(MBEDTLS_SHA512_C) || defined(MBEDTLS_ENTROPY_FORCE_SHA256) ) \
-    && defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) && (MBEDTLS_CTR_DRBG_ENTROPY_LEN > 32)
-#error "MBEDTLS_CTR_DRBG_ENTROPY_LEN value too high"
-#endif
-#if defined(MBEDTLS_ENTROPY_C) && \
-    defined(MBEDTLS_ENTROPY_FORCE_SHA256) && !defined(MBEDTLS_SHA256_C)
-#error "MBEDTLS_ENTROPY_FORCE_SHA256 defined, but not all prerequisites"
-#endif
-
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#define MBEDTLS_HAS_MEMSAN
-#endif
-#endif
-#if defined(MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN) &&  !defined(MBEDTLS_HAS_MEMSAN)
-#error "MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN requires building with MemorySanitizer"
-#endif
-#undef MBEDTLS_HAS_MEMSAN
-
-#if defined(MBEDTLS_GCM_C) && (                                        \
-        !defined(MBEDTLS_AES_C) && !defined(MBEDTLS_CAMELLIA_C) && !defined(MBEDTLS_ARIA_C) )
-#error "MBEDTLS_GCM_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_RANDOMIZE_JAC_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_ADD_MIXED_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_ADD_MIXED_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_DOUBLE_JAC_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_NORMALIZE_JAC_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_RANDOMIZE_MXZ_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_NORMALIZE_MXZ_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ECP_NO_FALLBACK) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
-#error "MBEDTLS_ECP_NO_FALLBACK defined, but no alternative implementation enabled"
-#endif
-
-#if defined(MBEDTLS_HKDF_C) && !defined(MBEDTLS_MD_C)
-#error "MBEDTLS_HKDF_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_HMAC_DRBG_C) && !defined(MBEDTLS_MD_C)
-#error "MBEDTLS_HMAC_DRBG_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED) &&                 \
-    ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_ECDSA_C) ||          \
-      !defined(MBEDTLS_X509_CRT_PARSE_C) )
-#error "MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) &&                 \
-    ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_RSA_C) ||          \
-      !defined(MBEDTLS_X509_CRT_PARSE_C) )
-#error "MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) && !defined(MBEDTLS_DHM_C)
-#error "MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) &&                     \
-    !defined(MBEDTLS_ECDH_C)
-#error "MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) &&                   \
-    ( !defined(MBEDTLS_DHM_C) || !defined(MBEDTLS_RSA_C) ||           \
-      !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_PKCS1_V15) )
-#error "MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) &&                 \
-    ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_RSA_C) ||          \
-      !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_PKCS1_V15) )
-#error "MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) &&                 \
-    ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_ECDSA_C) ||          \
-      !defined(MBEDTLS_X509_CRT_PARSE_C) )
-#error "MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED) &&                   \
-    ( !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_X509_CRT_PARSE_C) || \
-      !defined(MBEDTLS_PKCS1_V15) )
-#error "MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) &&                       \
-    ( !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_X509_CRT_PARSE_C) || \
-      !defined(MBEDTLS_PKCS1_V15) )
-#error "MBEDTLS_KEY_EXCHANGE_RSA_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) &&                    \
-    ( !defined(MBEDTLS_ECJPAKE_C) || !defined(MBEDTLS_SHA256_C) ||      \
-      !defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) )
-#error "MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) &&        \
-    !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE) &&              \
-    ( !defined(MBEDTLS_SHA256_C) &&                             \
-      !defined(MBEDTLS_SHA512_C) &&                             \
-      !defined(MBEDTLS_SHA1_C) )
-#error "!MBEDTLS_SSL_KEEP_PEER_CERTIFICATE requires MBEDTLS_SHA512_C, MBEDTLS_SHA256_C or MBEDTLS_SHA1_C"
-#endif
-
-#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) &&                          \
-    ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_PLATFORM_MEMORY) )
-#error "MBEDTLS_MEMORY_BUFFER_ALLOC_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_MEMORY_BACKTRACE) && !defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
-#error "MBEDTLS_MEMORY_BACKTRACE defined, but not all prerequesites"
-#endif
-
-#if defined(MBEDTLS_MEMORY_DEBUG) && !defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
-#error "MBEDTLS_MEMORY_DEBUG defined, but not all prerequesites"
-#endif
-
-#if defined(MBEDTLS_PADLOCK_C) && !defined(MBEDTLS_HAVE_ASM)
-#error "MBEDTLS_PADLOCK_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PEM_PARSE_C) && !defined(MBEDTLS_BASE64_C)
-#error "MBEDTLS_PEM_PARSE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PEM_WRITE_C) && !defined(MBEDTLS_BASE64_C)
-#error "MBEDTLS_PEM_WRITE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PK_C) && \
-    ( !defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_ECP_C) )
-#error "MBEDTLS_PK_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PK_PARSE_C) && !defined(MBEDTLS_PK_C)
-#error "MBEDTLS_PK_PARSE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PK_WRITE_C) && !defined(MBEDTLS_PK_C)
-#error "MBEDTLS_PK_WRITE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_EXIT_ALT) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_EXIT_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_EXIT_MACRO) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_EXIT_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_EXIT_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_EXIT) ||\
-        defined(MBEDTLS_PLATFORM_EXIT_ALT) )
-#error "MBEDTLS_PLATFORM_EXIT_MACRO and MBEDTLS_PLATFORM_STD_EXIT/MBEDTLS_PLATFORM_EXIT_ALT cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_TIME_ALT) &&\
-    ( !defined(MBEDTLS_PLATFORM_C) ||\
-        !defined(MBEDTLS_HAVE_TIME) )
-#error "MBEDTLS_PLATFORM_TIME_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_TIME_MACRO) &&\
-    ( !defined(MBEDTLS_PLATFORM_C) ||\
-        !defined(MBEDTLS_HAVE_TIME) )
-#error "MBEDTLS_PLATFORM_TIME_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO) &&\
-    ( !defined(MBEDTLS_PLATFORM_C) ||\
-        !defined(MBEDTLS_HAVE_TIME) )
-#error "MBEDTLS_PLATFORM_TIME_TYPE_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_TIME_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_TIME) ||\
-        defined(MBEDTLS_PLATFORM_TIME_ALT) )
-#error "MBEDTLS_PLATFORM_TIME_MACRO and MBEDTLS_PLATFORM_STD_TIME/MBEDTLS_PLATFORM_TIME_ALT cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_TIME) ||\
-        defined(MBEDTLS_PLATFORM_TIME_ALT) )
-#error "MBEDTLS_PLATFORM_TIME_TYPE_MACRO and MBEDTLS_PLATFORM_STD_TIME/MBEDTLS_PLATFORM_TIME_ALT cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_FPRINTF_ALT) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_FPRINTF_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_FPRINTF_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_FPRINTF) ||\
-        defined(MBEDTLS_PLATFORM_FPRINTF_ALT) )
-#error "MBEDTLS_PLATFORM_FPRINTF_MACRO and MBEDTLS_PLATFORM_STD_FPRINTF/MBEDTLS_PLATFORM_FPRINTF_ALT cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_FREE_MACRO) &&\
-    ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_PLATFORM_MEMORY) )
-#error "MBEDTLS_PLATFORM_FREE_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_FREE_MACRO) &&\
-    defined(MBEDTLS_PLATFORM_STD_FREE)
-#error "MBEDTLS_PLATFORM_FREE_MACRO and MBEDTLS_PLATFORM_STD_FREE cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_FREE_MACRO) && !defined(MBEDTLS_PLATFORM_CALLOC_MACRO)
-#error "MBEDTLS_PLATFORM_CALLOC_MACRO must be defined if MBEDTLS_PLATFORM_FREE_MACRO is"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&\
-    ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_PLATFORM_MEMORY) )
-#error "MBEDTLS_PLATFORM_CALLOC_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&\
-    defined(MBEDTLS_PLATFORM_STD_CALLOC)
-#error "MBEDTLS_PLATFORM_CALLOC_MACRO and MBEDTLS_PLATFORM_STD_CALLOC cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_CALLOC_MACRO) && !defined(MBEDTLS_PLATFORM_FREE_MACRO)
-#error "MBEDTLS_PLATFORM_FREE_MACRO must be defined if MBEDTLS_PLATFORM_CALLOC_MACRO is"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_MEMORY) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_MEMORY defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_PRINTF_ALT) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_PRINTF_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_PRINTF_MACRO) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_PRINTF_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_PRINTF_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_PRINTF) ||\
-        defined(MBEDTLS_PLATFORM_PRINTF_ALT) )
-#error "MBEDTLS_PLATFORM_PRINTF_MACRO and MBEDTLS_PLATFORM_STD_PRINTF/MBEDTLS_PLATFORM_PRINTF_ALT cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_SNPRINTF_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO) && !defined(MBEDTLS_PLATFORM_C)
-#error "MBEDTLS_PLATFORM_SNPRINTF_MACRO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_SNPRINTF) ||\
-        defined(MBEDTLS_PLATFORM_SNPRINTF_ALT) )
-#error "MBEDTLS_PLATFORM_SNPRINTF_MACRO and MBEDTLS_PLATFORM_STD_SNPRINTF/MBEDTLS_PLATFORM_SNPRINTF_ALT cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_MEM_HDR) &&\
-    !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
-#error "MBEDTLS_PLATFORM_STD_MEM_HDR defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_CALLOC) && !defined(MBEDTLS_PLATFORM_MEMORY)
-#error "MBEDTLS_PLATFORM_STD_CALLOC defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_FREE) && !defined(MBEDTLS_PLATFORM_MEMORY)
-#error "MBEDTLS_PLATFORM_STD_FREE defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_EXIT) &&\
-    !defined(MBEDTLS_PLATFORM_EXIT_ALT)
-#error "MBEDTLS_PLATFORM_STD_EXIT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_TIME) &&\
-    ( !defined(MBEDTLS_PLATFORM_TIME_ALT) ||\
-        !defined(MBEDTLS_HAVE_TIME) )
-#error "MBEDTLS_PLATFORM_STD_TIME defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_FPRINTF) &&\
-    !defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
-#error "MBEDTLS_PLATFORM_STD_FPRINTF defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_PRINTF) &&\
-    !defined(MBEDTLS_PLATFORM_PRINTF_ALT)
-#error "MBEDTLS_PLATFORM_STD_PRINTF defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_SNPRINTF) &&\
-    !defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
-#error "MBEDTLS_PLATFORM_STD_SNPRINTF defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED) &&\
-    ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_ENTROPY_C) )
-#error "MBEDTLS_ENTROPY_NV_SEED defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_NV_SEED_ALT) &&\
-    !defined(MBEDTLS_ENTROPY_NV_SEED)
-#error "MBEDTLS_PLATFORM_NV_SEED_ALT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ) &&\
-    !defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
-#error "MBEDTLS_PLATFORM_STD_NV_SEED_READ defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE) &&\
-    !defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
-#error "MBEDTLS_PLATFORM_STD_NV_SEED_WRITE defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ) ||\
-      defined(MBEDTLS_PLATFORM_NV_SEED_ALT) )
-#error "MBEDTLS_PLATFORM_NV_SEED_READ_MACRO and MBEDTLS_PLATFORM_STD_NV_SEED_READ cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO) &&\
-    ( defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE) ||\
-      defined(MBEDTLS_PLATFORM_NV_SEED_ALT) )
-#error "MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO and MBEDTLS_PLATFORM_STD_NV_SEED_WRITE cannot be defined simultaneously"
-#endif
-
-#if defined(MBEDTLS_PSA_CRYPTO_C) &&                                    \
-    !( ( ( defined(MBEDTLS_CTR_DRBG_C) || defined(MBEDTLS_HMAC_DRBG_C) ) && \
-         defined(MBEDTLS_ENTROPY_C) ) ||                                \
-       defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) )
-#error "MBEDTLS_PSA_CRYPTO_C defined, but not all prerequisites (missing RNG)"
-#endif
-
-#if defined(MBEDTLS_PSA_CRYPTO_SPM) && !defined(MBEDTLS_PSA_CRYPTO_C)
-#error "MBEDTLS_PSA_CRYPTO_SPM defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PSA_CRYPTO_SE_C) &&    \
-    ! ( defined(MBEDTLS_PSA_CRYPTO_C) && \
-        defined(MBEDTLS_PSA_CRYPTO_STORAGE_C) )
-#error "MBEDTLS_PSA_CRYPTO_SE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C) &&            \
-    ! defined(MBEDTLS_PSA_CRYPTO_C)
-#error "MBEDTLS_PSA_CRYPTO_STORAGE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PSA_INJECT_ENTROPY) &&      \
-    !( defined(MBEDTLS_PSA_CRYPTO_STORAGE_C) && \
-       defined(MBEDTLS_ENTROPY_NV_SEED) )
-#error "MBEDTLS_PSA_INJECT_ENTROPY defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PSA_INJECT_ENTROPY) &&              \
-    !defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
-#error "MBEDTLS_PSA_INJECT_ENTROPY is not compatible with actual entropy sources"
-#endif
-
-#if defined(MBEDTLS_PSA_INJECT_ENTROPY) &&              \
-    defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
-#error "MBEDTLS_PSA_INJECT_ENTROPY is not compatible with MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG"
-#endif
-
-#if defined(MBEDTLS_PSA_ITS_FILE_C) && \
-    !defined(MBEDTLS_FS_IO)
-#error "MBEDTLS_PSA_ITS_FILE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) && \
-    defined(MBEDTLS_USE_PSA_CRYPTO)
-#error "MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER defined, but it cannot coexist with MBEDTLS_USE_PSA_CRYPTO."
-#endif
-
-#if defined(MBEDTLS_RSA_C) && ( !defined(MBEDTLS_BIGNUM_C) ||         \
-    !defined(MBEDTLS_OID_C) )
-#error "MBEDTLS_RSA_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_RSA_C) && ( !defined(MBEDTLS_PKCS1_V21) &&         \
-    !defined(MBEDTLS_PKCS1_V15) )
-#error "MBEDTLS_RSA_C defined, but none of the PKCS1 versions enabled"
-#endif
-
-#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT) &&                        \
-    ( !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_PKCS1_V21) )
-#error "MBEDTLS_X509_RSASSA_PSS_SUPPORT defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SHA384_C) && !defined(MBEDTLS_SHA512_C)
-#error "MBEDTLS_SHA384_C defined without MBEDTLS_SHA512_C"
-#endif
-
-#if defined(MBEDTLS_SHA224_C) && !defined(MBEDTLS_SHA256_C)
-#error "MBEDTLS_SHA224_C defined without MBEDTLS_SHA256_C"
-#endif
-
-#if defined(MBEDTLS_SHA256_C) && !defined(MBEDTLS_SHA224_C)
-#error "MBEDTLS_SHA256_C defined without MBEDTLS_SHA224_C"
-#endif
-
-#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && ( !defined(MBEDTLS_SHA1_C) &&     \
-    !defined(MBEDTLS_SHA256_C) && !defined(MBEDTLS_SHA512_C) )
-#error "MBEDTLS_SSL_PROTO_TLS1_2 defined, but not all prerequisites"
-#endif
-
-/*
- * HKDF is mandatory for TLS 1.3.
- * Otherwise support for at least one ciphersuite mandates either SHA_256 or
- * SHA_384.
- */
-#if defined(MBEDTLS_SSL_PROTO_TLS1_3) && \
-    ( ( !defined(MBEDTLS_HKDF_C) ) || \
-      ( !defined(MBEDTLS_SHA256_C) && !defined(MBEDTLS_SHA384_C) ) || \
-      ( !defined(MBEDTLS_PSA_CRYPTO_C) ) )
-#error "MBEDTLS_SSL_PROTO_TLS1_3 defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_PROTO_TLS1_2) &&                                    \
-    !(defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) ||                          \
-      defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) ||                      \
-      defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) ||                    \
-      defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) ||                  \
-      defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||                     \
-      defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED) ||                   \
-      defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) ||                          \
-      defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) ||                      \
-      defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED) ||                      \
-      defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) ||                    \
-      defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) )
-#error "One or more versions of the TLS protocol are enabled " \
-        "but no key exchange methods defined with MBEDTLS_KEY_EXCHANGE_xxxx"
-#endif
-
-#if defined(MBEDTLS_SSL_PROTO_DTLS)     && \
-    !defined(MBEDTLS_SSL_PROTO_TLS1_2)
-#error "MBEDTLS_SSL_PROTO_DTLS defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_CLI_C) && !defined(MBEDTLS_SSL_TLS_C)
-#error "MBEDTLS_SSL_CLI_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_TLS_C) && ( !defined(MBEDTLS_CIPHER_C) ||     \
-    !defined(MBEDTLS_MD_C) )
-#error "MBEDTLS_SSL_TLS_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_SRV_C) && !defined(MBEDTLS_SSL_TLS_C)
-#error "MBEDTLS_SSL_SRV_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_TLS_C) && !defined(MBEDTLS_SSL_PROTO_TLS1_2)
-#error "MBEDTLS_SSL_TLS_C defined, but no protocols are active"
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && !defined(MBEDTLS_SSL_PROTO_DTLS)
-#error "MBEDTLS_SSL_DTLS_HELLO_VERIFY  defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE) && \
-    !defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
-#error "MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE  defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY) &&                              \
-    ( !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_PROTO_DTLS) )
-#error "MBEDTLS_SSL_DTLS_ANTI_REPLAY  defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID) &&                              \
-    ( !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_PROTO_DTLS) )
-#error "MBEDTLS_SSL_DTLS_CONNECTION_ID  defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)            &&                 \
-    defined(MBEDTLS_SSL_CID_IN_LEN_MAX) &&                 \
-    MBEDTLS_SSL_CID_IN_LEN_MAX > 255
-#error "MBEDTLS_SSL_CID_IN_LEN_MAX too large (max 255)"
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)            &&                  \
-    defined(MBEDTLS_SSL_CID_OUT_LEN_MAX) &&                 \
-    MBEDTLS_SSL_CID_OUT_LEN_MAX > 255
-#error "MBEDTLS_SSL_CID_OUT_LEN_MAX too large (max 255)"
-#endif
-
-#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) &&   \
-    !defined(MBEDTLS_SSL_PROTO_TLS1_2)
-#error "MBEDTLS_SSL_ENCRYPT_THEN_MAC defined, but not all prerequsites"
-#endif
-
-#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET) && \
-    !defined(MBEDTLS_SSL_PROTO_TLS1_2)
-#error "MBEDTLS_SSL_EXTENDED_MASTER_SECRET defined, but not all prerequsites"
-#endif
-
-#if defined(MBEDTLS_SSL_TICKET_C) && !defined(MBEDTLS_CIPHER_C)
-#error "MBEDTLS_SSL_TICKET_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION) && \
-        !defined(MBEDTLS_X509_CRT_PARSE_C)
-#error "MBEDTLS_SSL_SERVER_NAME_INDICATION defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_THREADING_PTHREAD)
-#if !defined(MBEDTLS_THREADING_C) || defined(MBEDTLS_THREADING_IMPL)
-#error "MBEDTLS_THREADING_PTHREAD defined, but not all prerequisites"
-#endif
-#define MBEDTLS_THREADING_IMPL
-#endif
-
-#if defined(MBEDTLS_THREADING_ALT)
-#if !defined(MBEDTLS_THREADING_C) || defined(MBEDTLS_THREADING_IMPL)
-#error "MBEDTLS_THREADING_ALT defined, but not all prerequisites"
-#endif
-#define MBEDTLS_THREADING_IMPL
-#endif
-
-#if defined(MBEDTLS_THREADING_C) && !defined(MBEDTLS_THREADING_IMPL)
-#error "MBEDTLS_THREADING_C defined, single threading implementation required"
-#endif
-#undef MBEDTLS_THREADING_IMPL
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO) && !defined(MBEDTLS_PSA_CRYPTO_C)
-#error "MBEDTLS_USE_PSA_CRYPTO defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_VERSION_FEATURES) && !defined(MBEDTLS_VERSION_C)
-#error "MBEDTLS_VERSION_FEATURES defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_USE_C) && ( !defined(MBEDTLS_BIGNUM_C) ||  \
-    !defined(MBEDTLS_OID_C) || !defined(MBEDTLS_ASN1_PARSE_C) ||      \
-    !defined(MBEDTLS_PK_PARSE_C) )
-#error "MBEDTLS_X509_USE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_CREATE_C) && ( !defined(MBEDTLS_BIGNUM_C) ||  \
-    !defined(MBEDTLS_OID_C) || !defined(MBEDTLS_ASN1_WRITE_C) ||       \
-    !defined(MBEDTLS_PK_WRITE_C) )
-#error "MBEDTLS_X509_CREATE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_CRT_PARSE_C) && ( !defined(MBEDTLS_X509_USE_C) )
-#error "MBEDTLS_X509_CRT_PARSE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_CRL_PARSE_C) && ( !defined(MBEDTLS_X509_USE_C) )
-#error "MBEDTLS_X509_CRL_PARSE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_CSR_PARSE_C) && ( !defined(MBEDTLS_X509_USE_C) )
-#error "MBEDTLS_X509_CSR_PARSE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_CRT_WRITE_C) && ( !defined(MBEDTLS_X509_CREATE_C) )
-#error "MBEDTLS_X509_CRT_WRITE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_X509_CSR_WRITE_C) && ( !defined(MBEDTLS_X509_CREATE_C) )
-#error "MBEDTLS_X509_CSR_WRITE_C defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_HAVE_INT32) && defined(MBEDTLS_HAVE_INT64)
-#error "MBEDTLS_HAVE_INT32 and MBEDTLS_HAVE_INT64 cannot be defined simultaneously"
-#endif /* MBEDTLS_HAVE_INT32 && MBEDTLS_HAVE_INT64 */
-
-#if ( defined(MBEDTLS_HAVE_INT32) || defined(MBEDTLS_HAVE_INT64) ) && \
-    defined(MBEDTLS_HAVE_ASM)
-#error "MBEDTLS_HAVE_INT32/MBEDTLS_HAVE_INT64 and MBEDTLS_HAVE_ASM cannot be defined simultaneously"
-#endif /* (MBEDTLS_HAVE_INT32 || MBEDTLS_HAVE_INT64) && MBEDTLS_HAVE_ASM */
-
-#if defined(MBEDTLS_SSL_DTLS_SRTP) && ( !defined(MBEDTLS_SSL_PROTO_DTLS) )
-#error "MBEDTLS_SSL_DTLS_SRTP defined, but not all prerequisites"
-#endif
-
-#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH) && ( !defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) )
-#error "MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH defined, but not all prerequisites"
-#endif
-
-
-
-/* Reject attempts to enable options that have been removed and that could
- * cause a build to succeed but with features removed. */
-
-#if defined(MBEDTLS_HAVEGE_C) //no-check-names
-#error "MBEDTLS_HAVEGE_C was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/2599"
-#endif
-
-#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL) //no-check-names
-#error "MBEDTLS_SSL_HW_RECORD_ACCEL was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4031"
-#endif
-
-#if defined(MBEDTLS_SSL_PROTO_SSL3) //no-check-names
-#error "MBEDTLS_SSL_PROTO_SSL3 (SSL v3.0 support) was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4031"
-#endif
-
-#if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO) //no-check-names
-#error "MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO (SSL v2 ClientHello support) was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4031"
-#endif
-
-#if defined(MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT) //no-check-names
-#error "MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT (compatibility with the buggy implementation of truncated HMAC in Mbed TLS up to 2.7) was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4031"
-#endif
-
-#if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES) //no-check-names
-#error "MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES was removed in Mbed TLS 3.0. See the ChangeLog entry if you really need SHA-1-signed certificates."
-#endif
-
-#if defined(MBEDTLS_ZLIB_SUPPORT) //no-check-names
-#error "MBEDTLS_ZLIB_SUPPORT was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4031"
-#endif
-
-#if defined(MBEDTLS_CHECK_PARAMS) //no-check-names
-#error "MBEDTLS_CHECK_PARAMS was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4313"
-#endif
-
-#if defined(MBEDTLS_SSL_CID_PADDING_GRANULARITY) //no-check-names
-#error "MBEDTLS_SSL_CID_PADDING_GRANULARITY was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4335"
-#endif
-
-#if defined(MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY) //no-check-names
-#error "MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4335"
-#endif
-
-#if defined(MBEDTLS_SSL_TRUNCATED_HMAC) //no-check-names
-#error "MBEDTLS_SSL_TRUNCATED_HMAC was removed in Mbed TLS 3.0. See https://github.com/ARMmbed/mbedtls/issues/4341"
-#endif
-
-/*
- * Avoid warning from -pedantic. This is a convenient place for this
- * workaround since this is included by every single file before the
- * #if defined(MBEDTLS_xxx_C) that results in empty translation units.
- */
-typedef int mbedtls_iso_c_forbids_empty_translation_units;
-
-#endif /* MBEDTLS_CHECK_CONFIG_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/cipher.h b/src/duckdb/third_party/mbedtls/include/mbedtls/cipher.h
deleted file mode 100644
index b02ab76c0..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/cipher.h
+++ /dev/null
@@ -1,1159 +0,0 @@
-/**
- * \file cipher.h
- *
- * \brief This file contains an abstraction interface for use with the cipher
- * primitives provided by the library. It provides a common interface to all of
- * the available cipher operations.
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_CIPHER_H
-#define MBEDTLS_CIPHER_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include "mbedtls/platform_util.h"
-
-#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
-#define MBEDTLS_CIPHER_MODE_AEAD
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-#define MBEDTLS_CIPHER_MODE_WITH_PADDING
-#endif
-
-#if defined(MBEDTLS_CIPHER_NULL_CIPHER) || \
-    defined(MBEDTLS_CHACHA20_C)
-#define MBEDTLS_CIPHER_MODE_STREAM
-#endif
-
-#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
-    !defined(inline) && !defined(__cplusplus)
-#define inline __inline
-#endif
-
-/** The selected feature is not available. */
-#define MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE  -0x6080
-/** Bad input parameters. */
-#define MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA       -0x6100
-/** Failed to allocate memory. */
-#define MBEDTLS_ERR_CIPHER_ALLOC_FAILED         -0x6180
-/** Input data contains invalid padding and is rejected. */
-#define MBEDTLS_ERR_CIPHER_INVALID_PADDING      -0x6200
-/** Decryption of block requires a full block. */
-#define MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED  -0x6280
-/** Authentication failed (for AEAD modes). */
-#define MBEDTLS_ERR_CIPHER_AUTH_FAILED          -0x6300
-/** The context is invalid. For example, because it was freed. */
-#define MBEDTLS_ERR_CIPHER_INVALID_CONTEXT      -0x6380
-
-#define MBEDTLS_CIPHER_VARIABLE_IV_LEN     0x01    /**< Cipher accepts IVs of variable length. */
-#define MBEDTLS_CIPHER_VARIABLE_KEY_LEN    0x02    /**< Cipher accepts keys of variable length. */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief     Supported cipher types.
- *
- * \warning   DES is considered weak cipher and its use
- *            constitutes a security risk. Arm recommends considering stronger
- *            ciphers instead.
- */
-typedef enum {
-    MBEDTLS_CIPHER_ID_NONE = 0,  /**< Placeholder to mark the end of cipher ID lists. */
-    MBEDTLS_CIPHER_ID_NULL,      /**< The identity cipher, treated as a stream cipher. */
-    MBEDTLS_CIPHER_ID_AES,       /**< The AES cipher. */
-    MBEDTLS_CIPHER_ID_DES,       /**< The DES cipher. */
-    MBEDTLS_CIPHER_ID_3DES,      /**< The Triple DES cipher. */
-    MBEDTLS_CIPHER_ID_CAMELLIA,  /**< The Camellia cipher. */
-    MBEDTLS_CIPHER_ID_ARIA,      /**< The Aria cipher. */
-    MBEDTLS_CIPHER_ID_CHACHA20,  /**< The ChaCha20 cipher. */
-} mbedtls_cipher_id_t;
-
-/**
- * \brief     Supported {cipher type, cipher mode} pairs.
- *
- * \warning   DES is considered weak cipher and its use
- *            constitutes a security risk. Arm recommends considering stronger
- *            ciphers instead.
- */
-typedef enum {
-    MBEDTLS_CIPHER_NONE = 0,             /**< Placeholder to mark the end of cipher-pair lists. */
-    MBEDTLS_CIPHER_NULL,                 /**< The identity stream cipher. */
-    MBEDTLS_CIPHER_AES_128_ECB,          /**< AES cipher with 128-bit ECB mode. */
-    MBEDTLS_CIPHER_AES_192_ECB,          /**< AES cipher with 192-bit ECB mode. */
-    MBEDTLS_CIPHER_AES_256_ECB,          /**< AES cipher with 256-bit ECB mode. */
-    MBEDTLS_CIPHER_AES_128_CBC,          /**< AES cipher with 128-bit CBC mode. */
-    MBEDTLS_CIPHER_AES_192_CBC,          /**< AES cipher with 192-bit CBC mode. */
-    MBEDTLS_CIPHER_AES_256_CBC,          /**< AES cipher with 256-bit CBC mode. */
-    MBEDTLS_CIPHER_AES_128_CFB128,       /**< AES cipher with 128-bit CFB128 mode. */
-    MBEDTLS_CIPHER_AES_192_CFB128,       /**< AES cipher with 192-bit CFB128 mode. */
-    MBEDTLS_CIPHER_AES_256_CFB128,       /**< AES cipher with 256-bit CFB128 mode. */
-    MBEDTLS_CIPHER_AES_128_CTR,          /**< AES cipher with 128-bit CTR mode. */
-    MBEDTLS_CIPHER_AES_192_CTR,          /**< AES cipher with 192-bit CTR mode. */
-    MBEDTLS_CIPHER_AES_256_CTR,          /**< AES cipher with 256-bit CTR mode. */
-    MBEDTLS_CIPHER_AES_128_GCM,          /**< AES cipher with 128-bit GCM mode. */
-    MBEDTLS_CIPHER_AES_192_GCM,          /**< AES cipher with 192-bit GCM mode. */
-    MBEDTLS_CIPHER_AES_256_GCM,          /**< AES cipher with 256-bit GCM mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_ECB,     /**< Camellia cipher with 128-bit ECB mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_ECB,     /**< Camellia cipher with 192-bit ECB mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_ECB,     /**< Camellia cipher with 256-bit ECB mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_CBC,     /**< Camellia cipher with 128-bit CBC mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_CBC,     /**< Camellia cipher with 192-bit CBC mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_CBC,     /**< Camellia cipher with 256-bit CBC mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_CFB128,  /**< Camellia cipher with 128-bit CFB128 mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_CFB128,  /**< Camellia cipher with 192-bit CFB128 mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_CFB128,  /**< Camellia cipher with 256-bit CFB128 mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_CTR,     /**< Camellia cipher with 128-bit CTR mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_CTR,     /**< Camellia cipher with 192-bit CTR mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_CTR,     /**< Camellia cipher with 256-bit CTR mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_GCM,     /**< Camellia cipher with 128-bit GCM mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_GCM,     /**< Camellia cipher with 192-bit GCM mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_GCM,     /**< Camellia cipher with 256-bit GCM mode. */
-    MBEDTLS_CIPHER_DES_ECB,              /**< DES cipher with ECB mode. */
-    MBEDTLS_CIPHER_DES_CBC,              /**< DES cipher with CBC mode. */
-    MBEDTLS_CIPHER_DES_EDE_ECB,          /**< DES cipher with EDE ECB mode. */
-    MBEDTLS_CIPHER_DES_EDE_CBC,          /**< DES cipher with EDE CBC mode. */
-    MBEDTLS_CIPHER_DES_EDE3_ECB,         /**< DES cipher with EDE3 ECB mode. */
-    MBEDTLS_CIPHER_DES_EDE3_CBC,         /**< DES cipher with EDE3 CBC mode. */
-    MBEDTLS_CIPHER_AES_128_CCM,          /**< AES cipher with 128-bit CCM mode. */
-    MBEDTLS_CIPHER_AES_192_CCM,          /**< AES cipher with 192-bit CCM mode. */
-    MBEDTLS_CIPHER_AES_256_CCM,          /**< AES cipher with 256-bit CCM mode. */
-    MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG, /**< AES cipher with 128-bit CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG, /**< AES cipher with 192-bit CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG, /**< AES cipher with 256-bit CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_CCM,     /**< Camellia cipher with 128-bit CCM mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_CCM,     /**< Camellia cipher with 192-bit CCM mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_CCM,     /**< Camellia cipher with 256-bit CCM mode. */
-    MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG, /**< Camellia cipher with 128-bit CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG, /**< Camellia cipher with 192-bit CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG, /**< Camellia cipher with 256-bit CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_ARIA_128_ECB,         /**< Aria cipher with 128-bit key and ECB mode. */
-    MBEDTLS_CIPHER_ARIA_192_ECB,         /**< Aria cipher with 192-bit key and ECB mode. */
-    MBEDTLS_CIPHER_ARIA_256_ECB,         /**< Aria cipher with 256-bit key and ECB mode. */
-    MBEDTLS_CIPHER_ARIA_128_CBC,         /**< Aria cipher with 128-bit key and CBC mode. */
-    MBEDTLS_CIPHER_ARIA_192_CBC,         /**< Aria cipher with 192-bit key and CBC mode. */
-    MBEDTLS_CIPHER_ARIA_256_CBC,         /**< Aria cipher with 256-bit key and CBC mode. */
-    MBEDTLS_CIPHER_ARIA_128_CFB128,      /**< Aria cipher with 128-bit key and CFB-128 mode. */
-    MBEDTLS_CIPHER_ARIA_192_CFB128,      /**< Aria cipher with 192-bit key and CFB-128 mode. */
-    MBEDTLS_CIPHER_ARIA_256_CFB128,      /**< Aria cipher with 256-bit key and CFB-128 mode. */
-    MBEDTLS_CIPHER_ARIA_128_CTR,         /**< Aria cipher with 128-bit key and CTR mode. */
-    MBEDTLS_CIPHER_ARIA_192_CTR,         /**< Aria cipher with 192-bit key and CTR mode. */
-    MBEDTLS_CIPHER_ARIA_256_CTR,         /**< Aria cipher with 256-bit key and CTR mode. */
-    MBEDTLS_CIPHER_ARIA_128_GCM,         /**< Aria cipher with 128-bit key and GCM mode. */
-    MBEDTLS_CIPHER_ARIA_192_GCM,         /**< Aria cipher with 192-bit key and GCM mode. */
-    MBEDTLS_CIPHER_ARIA_256_GCM,         /**< Aria cipher with 256-bit key and GCM mode. */
-    MBEDTLS_CIPHER_ARIA_128_CCM,         /**< Aria cipher with 128-bit key and CCM mode. */
-    MBEDTLS_CIPHER_ARIA_192_CCM,         /**< Aria cipher with 192-bit key and CCM mode. */
-    MBEDTLS_CIPHER_ARIA_256_CCM,         /**< Aria cipher with 256-bit key and CCM mode. */
-    MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG, /**< Aria cipher with 128-bit key and CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG, /**< Aria cipher with 192-bit key and CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG, /**< Aria cipher with 256-bit key and CCM_STAR_NO_TAG mode. */
-    MBEDTLS_CIPHER_AES_128_OFB,          /**< AES 128-bit cipher in OFB mode. */
-    MBEDTLS_CIPHER_AES_192_OFB,          /**< AES 192-bit cipher in OFB mode. */
-    MBEDTLS_CIPHER_AES_256_OFB,          /**< AES 256-bit cipher in OFB mode. */
-    MBEDTLS_CIPHER_AES_128_XTS,          /**< AES 128-bit cipher in XTS block mode. */
-    MBEDTLS_CIPHER_AES_256_XTS,          /**< AES 256-bit cipher in XTS block mode. */
-    MBEDTLS_CIPHER_CHACHA20,             /**< ChaCha20 stream cipher. */
-    MBEDTLS_CIPHER_CHACHA20_POLY1305,    /**< ChaCha20-Poly1305 AEAD cipher. */
-    MBEDTLS_CIPHER_AES_128_KW,           /**< AES cipher with 128-bit NIST KW mode. */
-    MBEDTLS_CIPHER_AES_192_KW,           /**< AES cipher with 192-bit NIST KW mode. */
-    MBEDTLS_CIPHER_AES_256_KW,           /**< AES cipher with 256-bit NIST KW mode. */
-    MBEDTLS_CIPHER_AES_128_KWP,          /**< AES cipher with 128-bit NIST KWP mode. */
-    MBEDTLS_CIPHER_AES_192_KWP,          /**< AES cipher with 192-bit NIST KWP mode. */
-    MBEDTLS_CIPHER_AES_256_KWP,          /**< AES cipher with 256-bit NIST KWP mode. */
-} mbedtls_cipher_type_t;
-
-/** Supported cipher modes. */
-typedef enum {
-    MBEDTLS_MODE_NONE = 0,               /**< None.                        */
-    MBEDTLS_MODE_ECB,                    /**< The ECB cipher mode.         */
-    MBEDTLS_MODE_CBC,                    /**< The CBC cipher mode.         */
-    MBEDTLS_MODE_CFB,                    /**< The CFB cipher mode.         */
-    MBEDTLS_MODE_OFB,                    /**< The OFB cipher mode.         */
-    MBEDTLS_MODE_CTR,                    /**< The CTR cipher mode.         */
-    MBEDTLS_MODE_GCM,                    /**< The GCM cipher mode.         */
-    MBEDTLS_MODE_STREAM,                 /**< The stream cipher mode.      */
-    MBEDTLS_MODE_CCM,                    /**< The CCM cipher mode.         */
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,        /**< The CCM*-no-tag cipher mode. */
-    MBEDTLS_MODE_XTS,                    /**< The XTS cipher mode.         */
-    MBEDTLS_MODE_CHACHAPOLY,             /**< The ChaCha-Poly cipher mode. */
-    MBEDTLS_MODE_KW,                     /**< The SP800-38F KW mode */
-    MBEDTLS_MODE_KWP,                    /**< The SP800-38F KWP mode */
-} mbedtls_cipher_mode_t;
-
-/** Supported cipher padding types. */
-typedef enum {
-    MBEDTLS_PADDING_PKCS7 = 0,     /**< PKCS7 padding (default).        */
-    MBEDTLS_PADDING_ONE_AND_ZEROS, /**< ISO/IEC 7816-4 padding.         */
-    MBEDTLS_PADDING_ZEROS_AND_LEN, /**< ANSI X.923 padding.             */
-    MBEDTLS_PADDING_ZEROS,         /**< Zero padding (not reversible). */
-    MBEDTLS_PADDING_NONE,          /**< Never pad (full blocks only).   */
-} mbedtls_cipher_padding_t;
-
-/** Type of operation. */
-typedef enum {
-    MBEDTLS_OPERATION_NONE = -1,
-    MBEDTLS_DECRYPT = 0,
-    MBEDTLS_ENCRYPT,
-} mbedtls_operation_t;
-
-enum {
-    /** Undefined key length. */
-    MBEDTLS_KEY_LENGTH_NONE = 0,
-    /** Key length, in bits (including parity), for DES keys. */
-    MBEDTLS_KEY_LENGTH_DES  = 64,
-    /** Key length in bits, including parity, for DES in two-key EDE. */
-    MBEDTLS_KEY_LENGTH_DES_EDE = 128,
-    /** Key length in bits, including parity, for DES in three-key EDE. */
-    MBEDTLS_KEY_LENGTH_DES_EDE3 = 192,
-};
-
-/** Maximum length of any IV, in Bytes. */
-/* This should ideally be derived automatically from list of ciphers.
- * This should be kept in sync with MBEDTLS_SSL_MAX_IV_LENGTH defined
- * in library/ssl_misc.h. */
-#define MBEDTLS_MAX_IV_LENGTH      16
-
-/** Maximum block size of any cipher, in Bytes. */
-/* This should ideally be derived automatically from list of ciphers.
- * This should be kept in sync with MBEDTLS_SSL_MAX_BLOCK_LENGTH defined
- * in library/ssl_misc.h. */
-#define MBEDTLS_MAX_BLOCK_LENGTH   16
-
-/** Maximum key length, in Bytes. */
-/* This should ideally be derived automatically from list of ciphers.
- * For now, only check whether XTS is enabled which uses 64 Byte keys,
- * and use 32 Bytes as an upper bound for the maximum key length otherwise.
- * This should be kept in sync with MBEDTLS_SSL_MAX_BLOCK_LENGTH defined
- * in library/ssl_misc.h, which however deliberately ignores the case of XTS
- * since the latter isn't used in SSL/TLS. */
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-#define MBEDTLS_MAX_KEY_LENGTH     64
-#else
-#define MBEDTLS_MAX_KEY_LENGTH     32
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-/**
- * Base cipher information (opaque struct).
- */
-typedef struct mbedtls_cipher_base_t mbedtls_cipher_base_t;
-
-/**
- * CMAC context (opaque struct).
- */
-typedef struct mbedtls_cmac_context_t mbedtls_cmac_context_t;
-
-/**
- * Cipher information. Allows calling cipher functions
- * in a generic way.
- *
- * \note        The library does not support custom cipher info structures,
- *              only built-in structures returned by the functions
- *              mbedtls_cipher_info_from_string(),
- *              mbedtls_cipher_info_from_type(),
- *              mbedtls_cipher_info_from_values(),
- *              mbedtls_cipher_info_from_psa().
- */
-typedef struct mbedtls_cipher_info_t
-{
-    /** Full cipher identifier. For example,
-     * MBEDTLS_CIPHER_AES_256_CBC.
-     */
-    mbedtls_cipher_type_t MBEDTLS_PRIVATE(type);
-
-    /** The cipher mode. For example, MBEDTLS_MODE_CBC. */
-    mbedtls_cipher_mode_t MBEDTLS_PRIVATE(mode);
-
-    /** The cipher key length, in bits. This is the
-     * default length for variable sized ciphers.
-     * Includes parity bits for ciphers like DES.
-     */
-    unsigned int MBEDTLS_PRIVATE(key_bitlen);
-
-    /** Name of the cipher. */
-    const char * MBEDTLS_PRIVATE(name);
-
-    /** IV or nonce size, in Bytes.
-     * For ciphers that accept variable IV sizes,
-     * this is the recommended size.
-     */
-    unsigned int MBEDTLS_PRIVATE(iv_size);
-
-    /** Bitflag comprised of MBEDTLS_CIPHER_VARIABLE_IV_LEN and
-     *  MBEDTLS_CIPHER_VARIABLE_KEY_LEN indicating whether the
-     *  cipher supports variable IV or variable key sizes, respectively.
-     */
-    int MBEDTLS_PRIVATE(flags);
-
-    /** The block size, in Bytes. */
-    unsigned int MBEDTLS_PRIVATE(block_size);
-
-    /** Struct for base cipher information and functions. */
-    const mbedtls_cipher_base_t *MBEDTLS_PRIVATE(base);
-
-} mbedtls_cipher_info_t;
-
-/**
- * Generic cipher context.
- */
-typedef struct mbedtls_cipher_context_t
-{
-    /** Information about the associated cipher. */
-    const mbedtls_cipher_info_t *MBEDTLS_PRIVATE(cipher_info);
-
-    /** Key length to use. */
-    int MBEDTLS_PRIVATE(key_bitlen);
-
-    /** Operation that the key of the context has been
-     * initialized for.
-     */
-    mbedtls_operation_t MBEDTLS_PRIVATE(operation);
-
-#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
-    /** Padding functions to use, if relevant for
-     * the specific cipher mode.
-     */
-    void (*MBEDTLS_PRIVATE(add_padding))( unsigned char *output, size_t olen, size_t data_len );
-    int (*MBEDTLS_PRIVATE(get_padding))( unsigned char *input, size_t ilen, size_t *data_len );
-#endif
-
-    /** Buffer for input that has not been processed yet. */
-    unsigned char MBEDTLS_PRIVATE(unprocessed_data)[MBEDTLS_MAX_BLOCK_LENGTH];
-
-    /** Number of Bytes that have not been processed yet. */
-    size_t MBEDTLS_PRIVATE(unprocessed_len);
-
-    /** Current IV or NONCE_COUNTER for CTR-mode, data unit (or sector) number
-     * for XTS-mode. */
-    unsigned char MBEDTLS_PRIVATE(iv)[MBEDTLS_MAX_IV_LENGTH];
-
-    /** IV size in Bytes, for ciphers with variable-length IVs. */
-    size_t MBEDTLS_PRIVATE(iv_size);
-
-    /** The cipher-specific context. */
-    void *MBEDTLS_PRIVATE(cipher_ctx);
-
-#if defined(MBEDTLS_CMAC_C)
-    /** CMAC-specific context. */
-    mbedtls_cmac_context_t *MBEDTLS_PRIVATE(cmac_ctx);
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    /** Indicates whether the cipher operations should be performed
-     *  by Mbed TLS' own crypto library or an external implementation
-     *  of the PSA Crypto API.
-     *  This is unset if the cipher context was established through
-     *  mbedtls_cipher_setup(), and set if it was established through
-     *  mbedtls_cipher_setup_psa().
-     */
-    unsigned char MBEDTLS_PRIVATE(psa_enabled);
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-} mbedtls_cipher_context_t;
-
-/**
- * \brief This function retrieves the list of ciphers supported
- *        by the generic cipher module.
- *
- *        For any cipher identifier in the returned list, you can
- *        obtain the corresponding generic cipher information structure
- *        via mbedtls_cipher_info_from_type(), which can then be used
- *        to prepare a cipher context via mbedtls_cipher_setup().
- *
- *
- * \return      A statically-allocated array of cipher identifiers
- *              of type cipher_type_t. The last entry is zero.
- */
-const int *mbedtls_cipher_list( void );
-
-/**
- * \brief               This function retrieves the cipher-information
- *                      structure associated with the given cipher name.
- *
- * \param cipher_name   Name of the cipher to search for. This must not be
- *                      \c NULL.
- *
- * \return              The cipher information structure associated with the
- *                      given \p cipher_name.
- * \return              \c NULL if the associated cipher information is not found.
- */
-const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name );
-
-/**
- * \brief               This function retrieves the cipher-information
- *                      structure associated with the given cipher type.
- *
- * \param cipher_type   Type of the cipher to search for.
- *
- * \return              The cipher information structure associated with the
- *                      given \p cipher_type.
- * \return              \c NULL if the associated cipher information is not found.
- */
-const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type( const mbedtls_cipher_type_t cipher_type );
-
-/**
- * \brief               This function retrieves the cipher-information
- *                      structure associated with the given cipher ID,
- *                      key size and mode.
- *
- * \param cipher_id     The ID of the cipher to search for. For example,
- *                      #MBEDTLS_CIPHER_ID_AES.
- * \param key_bitlen    The length of the key in bits.
- * \param mode          The cipher mode. For example, #MBEDTLS_MODE_CBC.
- *
- * \return              The cipher information structure associated with the
- *                      given \p cipher_id.
- * \return              \c NULL if the associated cipher information is not found.
- */
-const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
-                                              int key_bitlen,
-                                              const mbedtls_cipher_mode_t mode );
-
-/**
- * \brief               Retrieve the identifier for a cipher info structure.
- *
- * \param[in] info      The cipher info structure to query.
- *                      This may be \c NULL.
- *
- * \return              The full cipher identifier (\c MBEDTLS_CIPHER_xxx).
- * \return              #MBEDTLS_CIPHER_NONE if \p info is \c NULL.
- */
-//static inline mbedtls_cipher_type_t mbedtls_cipher_info_get_type(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( MBEDTLS_CIPHER_NONE );
-//    else
-//        return( info->MBEDTLS_PRIVATE(type) );
-//}
-
-/**
- * \brief               Retrieve the operation mode for a cipher info structure.
- *
- * \param[in] info      The cipher info structure to query.
- *                      This may be \c NULL.
- *
- * \return              The cipher mode (\c MBEDTLS_MODE_xxx).
- * \return              #MBEDTLS_MODE_NONE if \p info is \c NULL.
- */
-//static inline mbedtls_cipher_mode_t mbedtls_cipher_info_get_mode(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( MBEDTLS_MODE_NONE );
-//    else
-//        return( info->MBEDTLS_PRIVATE(mode) );
-//}
-
-/**
- * \brief               Retrieve the key size for a cipher info structure.
- *
- * \param[in] info      The cipher info structure to query.
- *                      This may be \c NULL.
- *
- * \return              The key length in bits.
- *                      For variable-sized ciphers, this is the default length.
- *                      For DES, this includes the parity bits.
- * \return              \c 0 if \p info is \c NULL.
- */
-//static inline size_t mbedtls_cipher_info_get_key_bitlen(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( 0 );
-//    else
-//        return( info->MBEDTLS_PRIVATE(key_bitlen) );
-//}
-
-/**
- * \brief               Retrieve the human-readable name for a
- *                      cipher info structure.
- *
- * \param[in] info      The cipher info structure to query.
- *                      This may be \c NULL.
- *
- * \return              The cipher name, which is a human readable string,
- *                      with static storage duration.
- * \return              \c NULL if \c info is \p NULL.
- */
-//static inline const char *mbedtls_cipher_info_get_name(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( NULL );
-//    else
-//        return( info->MBEDTLS_PRIVATE(name) );
-//}
-
-/**
- * \brief       This function returns the size of the IV or nonce
- *              for the cipher info structure, in bytes.
- *
- * \param info  The cipher info structure. This may be \c NULL.
- *
- * \return      The recommended IV size.
- * \return      \c 0 for ciphers not using an IV or a nonce.
- * \return      \c 0 if \p info is \c NULL.
- */
-//static inline size_t mbedtls_cipher_info_get_iv_size(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( 0 );
-//
-//    return( (size_t) info->MBEDTLS_PRIVATE(iv_size) );
-//}
-
-/**
- * \brief        This function returns the block size of the given
- *               cipher info structure in bytes.
- *
- * \param info   The cipher info structure. This may be \c NULL.
- *
- * \return       The block size of the cipher.
- * \return       \c 1 if the cipher is a stream cipher.
- * \return       \c 0 if \p info is \c NULL.
- */
-//static inline size_t mbedtls_cipher_info_get_block_size(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( 0 );
-//
-//    return( (size_t) info->MBEDTLS_PRIVATE(block_size) );
-//}
-
-/**
- * \brief        This function returns a non-zero value if the key length for
- *               the given cipher is variable.
- *
- * \param info   The cipher info structure. This may be \c NULL.
- *
- * \return       Non-zero if the key length is variable, \c 0 otherwise.
- * \return       \c 0 if the given pointer is \c NULL.
- */
-//static inline int mbedtls_cipher_info_has_variable_key_bitlen(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( 0 );
-//
-//    return( info->MBEDTLS_PRIVATE(flags) & MBEDTLS_CIPHER_VARIABLE_KEY_LEN );
-//}
-
-/**
- * \brief        This function returns a non-zero value if the IV size for
- *               the given cipher is variable.
- *
- * \param info   The cipher info structure. This may be \c NULL.
- *
- * \return       Non-zero if the IV size is variable, \c 0 otherwise.
- * \return       \c 0 if the given pointer is \c NULL.
- */
-//static inline int mbedtls_cipher_info_has_variable_iv_size(
-//    const mbedtls_cipher_info_t *info )
-//{
-//    if( info == NULL )
-//        return( 0 );
-//
-//    return( info->MBEDTLS_PRIVATE(flags) & MBEDTLS_CIPHER_VARIABLE_IV_LEN );
-//}
-
-/**
- * \brief               This function initializes a \p cipher_context as NONE.
- *
- * \param ctx           The context to be initialized. This must not be \c NULL.
- */
-void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx );
-
-/**
- * \brief               This function frees and clears the cipher-specific
- *                      context of \p ctx. Freeing \p ctx itself remains the
- *                      responsibility of the caller.
- *
- * \param ctx           The context to be freed. If this is \c NULL, the
- *                      function has no effect, otherwise this must point to an
- *                      initialized context.
- */
-void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx );
-
-
-/**
- * \brief               This function prepares a cipher context for
- *                      use with the given cipher primitive.
- *
- * \note                After calling this function, you should call
- *                      mbedtls_cipher_setkey() and, if the mode uses padding,
- *                      mbedtls_cipher_set_padding_mode(), then for each
- *                      message to encrypt or decrypt with this key, either:
- *                      - mbedtls_cipher_crypt() for one-shot processing with
- *                      non-AEAD modes;
- *                      - mbedtls_cipher_auth_encrypt_ext() or
- *                      mbedtls_cipher_auth_decrypt_ext() for one-shot
- *                      processing with AEAD modes or NIST_KW;
- *                      - for multi-part processing, see the documentation of
- *                      mbedtls_cipher_reset().
- *
- * \param ctx           The context to prepare. This must be initialized by
- *                      a call to mbedtls_cipher_init() first.
- * \param cipher_info   The cipher to use.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              #MBEDTLS_ERR_CIPHER_ALLOC_FAILED if allocation of the
- *                      cipher-specific context fails.
- */
-int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx,
-                          const mbedtls_cipher_info_t *cipher_info );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-/**
- * \brief               This function initializes a cipher context for
- *                      PSA-based use with the given cipher primitive.
- *
- * \note                See #MBEDTLS_USE_PSA_CRYPTO for information on PSA.
- *
- * \param ctx           The context to initialize. May not be \c NULL.
- * \param cipher_info   The cipher to use.
- * \param taglen        For AEAD ciphers, the length in bytes of the
- *                      authentication tag to use. Subsequent uses of
- *                      mbedtls_cipher_auth_encrypt_ext() or
- *                      mbedtls_cipher_auth_decrypt_ext() must provide
- *                      the same tag length.
- *                      For non-AEAD ciphers, the value must be \c 0.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              #MBEDTLS_ERR_CIPHER_ALLOC_FAILED if allocation of the
- *                      cipher-specific context fails.
- */
-int mbedtls_cipher_setup_psa( mbedtls_cipher_context_t *ctx,
-                              const mbedtls_cipher_info_t *cipher_info,
-                              size_t taglen );
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-/**
- * \brief        This function returns the block size of the given cipher
- *               in bytes.
- *
- * \param ctx    The context of the cipher.
- *
- * \return       The block size of the underlying cipher.
- * \return       \c 1 if the cipher is a stream cipher.
- * \return       \c 0 if \p ctx has not been initialized.
- */
-static inline unsigned int mbedtls_cipher_get_block_size(
-    const mbedtls_cipher_context_t *ctx )
-{
-    MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, 0 );
-    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-        return 0;
-
-    return ctx->MBEDTLS_PRIVATE(cipher_info)->MBEDTLS_PRIVATE(block_size);
-}
-
-/**
- * \brief        This function returns the mode of operation for
- *               the cipher. For example, MBEDTLS_MODE_CBC.
- *
- * \param ctx    The context of the cipher. This must be initialized.
- *
- * \return       The mode of operation.
- * \return       #MBEDTLS_MODE_NONE if \p ctx has not been initialized.
- */
-//static inline mbedtls_cipher_mode_t mbedtls_cipher_get_cipher_mode(
-//    const mbedtls_cipher_context_t *ctx )
-//{
-//    MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, MBEDTLS_MODE_NONE );
-//    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-//        return MBEDTLS_MODE_NONE;
-//
-//    return ctx->MBEDTLS_PRIVATE(cipher_info)->MBEDTLS_PRIVATE(mode);
-//}
-
-/**
- * \brief       This function returns the size of the IV or nonce
- *              of the cipher, in Bytes.
- *
- * \param ctx   The context of the cipher. This must be initialized.
- *
- * \return      The recommended IV size if no IV has been set.
- * \return      \c 0 for ciphers not using an IV or a nonce.
- * \return      The actual size if an IV has been set.
- */
-//static inline int mbedtls_cipher_get_iv_size(
-//    const mbedtls_cipher_context_t *ctx )
-//{
-//    MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, 0 );
-//    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-//        return 0;
-//
-//    if( ctx->MBEDTLS_PRIVATE(iv_size) != 0 )
-//        return (int) ctx->MBEDTLS_PRIVATE(iv_size);
-//
-//    return (int) ctx->MBEDTLS_PRIVATE(cipher_info)->MBEDTLS_PRIVATE(iv_size);
-//}
-
-/**
- * \brief               This function returns the type of the given cipher.
- *
- * \param ctx           The context of the cipher. This must be initialized.
- *
- * \return              The type of the cipher.
- * \return              #MBEDTLS_CIPHER_NONE if \p ctx has not been initialized.
- */
-//static inline mbedtls_cipher_type_t mbedtls_cipher_get_type(
-//    const mbedtls_cipher_context_t *ctx )
-//{
-//    MBEDTLS_INTERNAL_VALIDATE_RET(
-//        ctx != NULL, MBEDTLS_CIPHER_NONE );
-//    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-//        return MBEDTLS_CIPHER_NONE;
-//
-//    return ctx->MBEDTLS_PRIVATE(cipher_info)->MBEDTLS_PRIVATE(type);
-//}
-
-/**
- * \brief               This function returns the name of the given cipher
- *                      as a string.
- *
- * \param ctx           The context of the cipher. This must be initialized.
- *
- * \return              The name of the cipher.
- * \return              NULL if \p ctx has not been not initialized.
- */
-//static inline const char *mbedtls_cipher_get_name(
-//    const mbedtls_cipher_context_t *ctx )
-//{
-//    MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, 0 );
-//    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-//        return 0;
-//
-//    return ctx->MBEDTLS_PRIVATE(cipher_info)->MBEDTLS_PRIVATE(name);
-//}
-
-/**
- * \brief               This function returns the key length of the cipher.
- *
- * \param ctx           The context of the cipher. This must be initialized.
- *
- * \return              The key length of the cipher in bits.
- * \return              #MBEDTLS_KEY_LENGTH_NONE if ctx \p has not been
- *                      initialized.
- */
-//static inline int mbedtls_cipher_get_key_bitlen(
-//    const mbedtls_cipher_context_t *ctx )
-//{
-//    MBEDTLS_INTERNAL_VALIDATE_RET(
-//        ctx != NULL, MBEDTLS_KEY_LENGTH_NONE );
-//    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-//        return MBEDTLS_KEY_LENGTH_NONE;
-//
-//    return (int) ctx->MBEDTLS_PRIVATE(cipher_info)->MBEDTLS_PRIVATE(key_bitlen);
-//}
-
-/**
- * \brief          This function returns the operation of the given cipher.
- *
- * \param ctx      The context of the cipher. This must be initialized.
- *
- * \return         The type of operation: #MBEDTLS_ENCRYPT or #MBEDTLS_DECRYPT.
- * \return         #MBEDTLS_OPERATION_NONE if \p ctx has not been initialized.
- */
-//static inline mbedtls_operation_t mbedtls_cipher_get_operation(
-//    const mbedtls_cipher_context_t *ctx )
-//{
-//    MBEDTLS_INTERNAL_VALIDATE_RET(
-//        ctx != NULL, MBEDTLS_OPERATION_NONE );
-//    if( ctx->MBEDTLS_PRIVATE(cipher_info) == NULL )
-//        return MBEDTLS_OPERATION_NONE;
-//
-//    return ctx->MBEDTLS_PRIVATE(operation);
-//}
-
-/**
- * \brief               This function sets the key to use with the given context.
- *
- * \param ctx           The generic cipher context. This must be initialized and
- *                      bound to a cipher information structure.
- * \param key           The key to use. This must be a readable buffer of at
- *                      least \p key_bitlen Bits.
- * \param key_bitlen    The key length to use, in Bits.
- * \param operation     The operation that the key will be used for:
- *                      #MBEDTLS_ENCRYPT or #MBEDTLS_DECRYPT.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              A cipher-specific error code on failure.
- */
-int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx,
-                           const unsigned char *key,
-                           int key_bitlen,
-                           const mbedtls_operation_t operation );
-
-#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
-/**
- * \brief               This function sets the padding mode, for cipher modes
- *                      that use padding.
- *
- *                      The default passing mode is PKCS7 padding.
- *
- * \param ctx           The generic cipher context. This must be initialized and
- *                      bound to a cipher information structure.
- * \param mode          The padding mode.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE
- *                      if the selected padding mode is not supported.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA if the cipher mode
- *                      does not support padding.
- */
-int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx,
-                                     mbedtls_cipher_padding_t mode );
-#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
-
-/**
- * \brief           This function sets the initialization vector (IV)
- *                  or nonce.
- *
- * \note            Some ciphers do not use IVs nor nonce. For these
- *                  ciphers, this function has no effect.
- *
- * \param ctx       The generic cipher context. This must be initialized and
- *                  bound to a cipher information structure.
- * \param iv        The IV to use, or NONCE_COUNTER for CTR-mode ciphers. This
- *                  must be a readable buffer of at least \p iv_len Bytes.
- * \param iv_len    The IV length for ciphers with variable-size IV.
- *                  This parameter is discarded by ciphers with fixed-size IV.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                  parameter-verification failure.
- */
-int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
-                           const unsigned char *iv,
-                           size_t iv_len );
-
-/**
- * \brief         This function resets the cipher state.
- *
- * \note          With non-AEAD ciphers, the order of calls for each message
- *                is as follows:
- *                1. mbedtls_cipher_set_iv() if the mode uses an IV/nonce.
- *                2. mbedtls_cipher_reset()
- *                3. mbedtls_cipher_update() one or more times
- *                4. mbedtls_cipher_finish()
- *                .
- *                This sequence can be repeated to encrypt or decrypt multiple
- *                messages with the same key.
- *
- * \note          With AEAD ciphers, the order of calls for each message
- *                is as follows:
- *                1. mbedtls_cipher_set_iv() if the mode uses an IV/nonce.
- *                2. mbedtls_cipher_reset()
- *                3. mbedtls_cipher_update_ad()
- *                4. mbedtls_cipher_update() one or more times
- *                5. mbedtls_cipher_finish()
- *                6. mbedtls_cipher_check_tag() (for decryption) or
- *                mbedtls_cipher_write_tag() (for encryption).
- *                .
- *                This sequence can be repeated to encrypt or decrypt multiple
- *                messages with the same key.
- *
- * \param ctx     The generic cipher context. This must be bound to a key.
- *
- * \return        \c 0 on success.
- * \return        #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                parameter-verification failure.
- */
-int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx );
-
-#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
-/**
- * \brief               This function adds additional data for AEAD ciphers.
- *                      Currently supported with GCM and ChaCha20+Poly1305.
- *
- * \param ctx           The generic cipher context. This must be initialized.
- * \param ad            The additional data to use. This must be a readable
- *                      buffer of at least \p ad_len Bytes.
- * \param ad_len        The length of \p ad in Bytes.
- *
- * \return              \c 0 on success.
- * \return              A specific error code on failure.
- */
-int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
-                      const unsigned char *ad, size_t ad_len );
-#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
-
-/**
- * \brief               The generic cipher update function. It encrypts or
- *                      decrypts using the given cipher context. Writes as
- *                      many block-sized blocks of data as possible to output.
- *                      Any data that cannot be written immediately is either
- *                      added to the next block, or flushed when
- *                      mbedtls_cipher_finish() is called.
- *                      Exception: For MBEDTLS_MODE_ECB, expects a single block
- *                      in size. For example, 16 Bytes for AES.
- *
- * \param ctx           The generic cipher context. This must be initialized and
- *                      bound to a key.
- * \param input         The buffer holding the input data. This must be a
- *                      readable buffer of at least \p ilen Bytes.
- * \param ilen          The length of the input data.
- * \param output        The buffer for the output data. This must be able to
- *                      hold at least `ilen + block_size`. This must not be the
- *                      same buffer as \p input.
- * \param olen          The length of the output data, to be updated with the
- *                      actual number of Bytes written. This must not be
- *                      \c NULL.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              #MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE on an
- *                      unsupported mode for a cipher.
- * \return              A cipher-specific error code on failure.
- */
-int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx,
-                           const unsigned char *input,
-                           size_t ilen, unsigned char *output,
-                           size_t *olen );
-
-/**
- * \brief               The generic cipher finalization function. If data still
- *                      needs to be flushed from an incomplete block, the data
- *                      contained in it is padded to the size of
- *                      the last block, and written to the \p output buffer.
- *
- * \param ctx           The generic cipher context. This must be initialized and
- *                      bound to a key.
- * \param output        The buffer to write data to. This needs to be a writable
- *                      buffer of at least \p block_size Bytes.
- * \param olen          The length of the data written to the \p output buffer.
- *                      This may not be \c NULL.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              #MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption
- *                      expecting a full block but not receiving one.
- * \return              #MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding
- *                      while decrypting.
- * \return              A cipher-specific error code on failure.
- */
-int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
-                   unsigned char *output, size_t *olen );
-
-#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
-/**
- * \brief               This function writes a tag for AEAD ciphers.
- *                      Currently supported with GCM and ChaCha20+Poly1305.
- *                      This must be called after mbedtls_cipher_finish().
- *
- * \param ctx           The generic cipher context. This must be initialized,
- *                      bound to a key, and have just completed a cipher
- *                      operation through mbedtls_cipher_finish() the tag for
- *                      which should be written.
- * \param tag           The buffer to write the tag to. This must be a writable
- *                      buffer of at least \p tag_len Bytes.
- * \param tag_len       The length of the tag to write.
- *
- * \return              \c 0 on success.
- * \return              A specific error code on failure.
- */
-int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
-                      unsigned char *tag, size_t tag_len );
-
-/**
- * \brief               This function checks the tag for AEAD ciphers.
- *                      Currently supported with GCM and ChaCha20+Poly1305.
- *                      This must be called after mbedtls_cipher_finish().
- *
- * \param ctx           The generic cipher context. This must be initialized.
- * \param tag           The buffer holding the tag. This must be a readable
- *                      buffer of at least \p tag_len Bytes.
- * \param tag_len       The length of the tag to check.
- *
- * \return              \c 0 on success.
- * \return              A specific error code on failure.
- */
-int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
-                      const unsigned char *tag, size_t tag_len );
-#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
-
-/**
- * \brief               The generic all-in-one encryption/decryption function,
- *                      for all ciphers except AEAD constructs.
- *
- * \param ctx           The generic cipher context. This must be initialized.
- * \param iv            The IV to use, or NONCE_COUNTER for CTR-mode ciphers.
- *                      This must be a readable buffer of at least \p iv_len
- *                      Bytes.
- * \param iv_len        The IV length for ciphers with variable-size IV.
- *                      This parameter is discarded by ciphers with fixed-size
- *                      IV.
- * \param input         The buffer holding the input data. This must be a
- *                      readable buffer of at least \p ilen Bytes.
- * \param ilen          The length of the input data in Bytes.
- * \param output        The buffer for the output data. This must be able to
- *                      hold at least `ilen + block_size`. This must not be the
- *                      same buffer as \p input.
- * \param olen          The length of the output data, to be updated with the
- *                      actual number of Bytes written. This must not be
- *                      \c NULL.
- *
- * \note                Some ciphers do not use IVs nor nonce. For these
- *                      ciphers, use \p iv = NULL and \p iv_len = 0.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              #MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption
- *                      expecting a full block but not receiving one.
- * \return              #MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding
- *                      while decrypting.
- * \return              A cipher-specific error code on failure.
- */
-int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
-                  const unsigned char *iv, size_t iv_len,
-                  const unsigned char *input, size_t ilen,
-                  unsigned char *output, size_t *olen );
-
-#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
-/**
- * \brief               The authenticated encryption (AEAD/NIST_KW) function.
- *
- * \note                For AEAD modes, the tag will be appended to the
- *                      ciphertext, as recommended by RFC 5116.
- *                      (NIST_KW doesn't have a separate tag.)
- *
- * \param ctx           The generic cipher context. This must be initialized and
- *                      bound to a key, with an AEAD algorithm or NIST_KW.
- * \param iv            The nonce to use. This must be a readable buffer of
- *                      at least \p iv_len Bytes and may be \c NULL if \p
- *                      iv_len is \c 0.
- * \param iv_len        The length of the nonce. For AEAD ciphers, this must
- *                      satisfy the constraints imposed by the cipher used.
- *                      For NIST_KW, this must be \c 0.
- * \param ad            The additional data to authenticate. This must be a
- *                      readable buffer of at least \p ad_len Bytes, and may
- *                      be \c NULL is \p ad_len is \c 0.
- * \param ad_len        The length of \p ad. For NIST_KW, this must be \c 0.
- * \param input         The buffer holding the input data. This must be a
- *                      readable buffer of at least \p ilen Bytes, and may be
- *                      \c NULL if \p ilen is \c 0.
- * \param ilen          The length of the input data.
- * \param output        The buffer for the output data. This must be a
- *                      writable buffer of at least \p output_len Bytes, and
- *                      must not be \c NULL.
- * \param output_len    The length of the \p output buffer in Bytes. For AEAD
- *                      ciphers, this must be at least \p ilen + \p tag_len.
- *                      For NIST_KW, this must be at least \p ilen + 8
- *                      (rounded up to a multiple of 8 if KWP is used);
- *                      \p ilen + 15 is always a safe value.
- * \param olen          This will be filled with the actual number of Bytes
- *                      written to the \p output buffer. This must point to a
- *                      writable object of type \c size_t.
- * \param tag_len       The desired length of the authentication tag. For AEAD
- *                      ciphers, this must match the constraints imposed by
- *                      the cipher used, and in particular must not be \c 0.
- *                      For NIST_KW, this must be \c 0.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              A cipher-specific error code on failure.
- */
-int mbedtls_cipher_auth_encrypt_ext( mbedtls_cipher_context_t *ctx,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t output_len,
-                         size_t *olen, size_t tag_len );
-
-/**
- * \brief               The authenticated encryption (AEAD/NIST_KW) function.
- *
- * \note                If the data is not authentic, then the output buffer
- *                      is zeroed out to prevent the unauthentic plaintext being
- *                      used, making this interface safer.
- *
- * \note                For AEAD modes, the tag must be appended to the
- *                      ciphertext, as recommended by RFC 5116.
- *                      (NIST_KW doesn't have a separate tag.)
- *
- * \param ctx           The generic cipher context. This must be initialized and
- *                      bound to a key, with an AEAD algorithm or NIST_KW.
- * \param iv            The nonce to use. This must be a readable buffer of
- *                      at least \p iv_len Bytes and may be \c NULL if \p
- *                      iv_len is \c 0.
- * \param iv_len        The length of the nonce. For AEAD ciphers, this must
- *                      satisfy the constraints imposed by the cipher used.
- *                      For NIST_KW, this must be \c 0.
- * \param ad            The additional data to authenticate. This must be a
- *                      readable buffer of at least \p ad_len Bytes, and may
- *                      be \c NULL is \p ad_len is \c 0.
- * \param ad_len        The length of \p ad. For NIST_KW, this must be \c 0.
- * \param input         The buffer holding the input data. This must be a
- *                      readable buffer of at least \p ilen Bytes, and may be
- *                      \c NULL if \p ilen is \c 0.
- * \param ilen          The length of the input data. For AEAD ciphers this
- *                      must be at least \p tag_len. For NIST_KW this must be
- *                      at least \c 8.
- * \param output        The buffer for the output data. This must be a
- *                      writable buffer of at least \p output_len Bytes, and
- *                      may be \c NULL if \p output_len is \c 0.
- * \param output_len    The length of the \p output buffer in Bytes. For AEAD
- *                      ciphers, this must be at least \p ilen - \p tag_len.
- *                      For NIST_KW, this must be at least \p ilen - 8.
- * \param olen          This will be filled with the actual number of Bytes
- *                      written to the \p output buffer. This must point to a
- *                      writable object of type \c size_t.
- * \param tag_len       The actual length of the authentication tag. For AEAD
- *                      ciphers, this must match the constraints imposed by
- *                      the cipher used, and in particular must not be \c 0.
- *                      For NIST_KW, this must be \c 0.
- *
- * \return              \c 0 on success.
- * \return              #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
- *                      parameter-verification failure.
- * \return              #MBEDTLS_ERR_CIPHER_AUTH_FAILED if data is not authentic.
- * \return              A cipher-specific error code on failure.
- */
-int mbedtls_cipher_auth_decrypt_ext( mbedtls_cipher_context_t *ctx,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t output_len,
-                         size_t *olen, size_t tag_len );
-#endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_CIPHER_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/cmac.h b/src/duckdb/third_party/mbedtls/include/mbedtls/cmac.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/cmac.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/config_psa.h b/src/duckdb/third_party/mbedtls/include/mbedtls/config_psa.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/config_psa.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/constant_time.h b/src/duckdb/third_party/mbedtls/include/mbedtls/constant_time.h
deleted file mode 100644
index c5de57a01..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/constant_time.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- *  Constant-time functions
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_CONSTANT_TIME_H
-#define MBEDTLS_CONSTANT_TIME_H
-
-#include <stddef.h>
-
-
-/** Constant-time buffer comparison without branches.
- *
- * This is equivalent to the standard memcmp function, but is likely to be
- * compiled to code using bitwise operation rather than a branch.
- *
- * This function can be used to write constant-time code by replacing branches
- * with bit operations using masks.
- *
- * \param a     Pointer to the first buffer.
- * \param b     Pointer to the second buffer.
- * \param n     The number of bytes to compare in the buffer.
- *
- * \return      Zero if the content of the two buffer is the same,
- *              otherwise non-zero.
- */
-int mbedtls_ct_memcmp( const void *a,
-                       const void *b,
-                       size_t n );
-
-#endif /* MBEDTLS_CONSTANT_TIME_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/des.h b/src/duckdb/third_party/mbedtls/include/mbedtls/des.h
deleted file mode 100644
index be74cb111..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/des.h
+++ /dev/null
@@ -1,363 +0,0 @@
-/**
- * \file des.h
- *
- * \brief DES block cipher
- *
- * \warning   DES is considered a weak cipher and its use constitutes a
- *            security risk. We recommend considering stronger ciphers
- *            instead.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- *
- */
-#ifndef MBEDTLS_DES_H
-#define MBEDTLS_DES_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-#include "mbedtls/platform_util.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#define MBEDTLS_DES_ENCRYPT     1
-#define MBEDTLS_DES_DECRYPT     0
-
-/** The data input has an invalid length. */
-#define MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH              -0x0032
-
-#define MBEDTLS_DES_KEY_SIZE    8
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_DES_ALT)
-// Regular implementation
-//
-
-/**
- * \brief          DES context structure
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-typedef struct mbedtls_des_context
-{
-    uint32_t MBEDTLS_PRIVATE(sk)[32];            /*!<  DES subkeys       */
-}
-mbedtls_des_context;
-
-/**
- * \brief          Triple-DES context structure
- */
-typedef struct mbedtls_des3_context
-{
-    uint32_t MBEDTLS_PRIVATE(sk)[96];            /*!<  3DES subkeys      */
-}
-mbedtls_des3_context;
-
-#else  /* MBEDTLS_DES_ALT */
-#include "des_alt.h"
-#endif /* MBEDTLS_DES_ALT */
-
-/**
- * \brief          Initialize DES context
- *
- * \param ctx      DES context to be initialized
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-void mbedtls_des_init( mbedtls_des_context *ctx );
-
-/**
- * \brief          Clear DES context
- *
- * \param ctx      DES context to be cleared
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-void mbedtls_des_free( mbedtls_des_context *ctx );
-
-/**
- * \brief          Initialize Triple-DES context
- *
- * \param ctx      DES3 context to be initialized
- */
-void mbedtls_des3_init( mbedtls_des3_context *ctx );
-
-/**
- * \brief          Clear Triple-DES context
- *
- * \param ctx      DES3 context to be cleared
- */
-void mbedtls_des3_free( mbedtls_des3_context *ctx );
-
-/**
- * \brief          Set key parity on the given key to odd.
- *
- *                 DES keys are 56 bits long, but each byte is padded with
- *                 a parity bit to allow verification.
- *
- * \param key      8-byte secret key
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-void mbedtls_des_key_set_parity( unsigned char key[MBEDTLS_DES_KEY_SIZE] );
-
-/**
- * \brief          Check that key parity on the given key is odd.
- *
- *                 DES keys are 56 bits long, but each byte is padded with
- *                 a parity bit to allow verification.
- *
- * \param key      8-byte secret key
- *
- * \return         0 is parity was ok, 1 if parity was not correct.
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des_key_check_key_parity( const unsigned char key[MBEDTLS_DES_KEY_SIZE] );
-
-/**
- * \brief          Check that key is not a weak or semi-weak DES key
- *
- * \param key      8-byte secret key
- *
- * \return         0 if no weak key was found, 1 if a weak key was identified.
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des_key_check_weak( const unsigned char key[MBEDTLS_DES_KEY_SIZE] );
-
-/**
- * \brief          DES key schedule (56-bit, encryption)
- *
- * \param ctx      DES context to be initialized
- * \param key      8-byte secret key
- *
- * \return         0
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des_setkey_enc( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] );
-
-/**
- * \brief          DES key schedule (56-bit, decryption)
- *
- * \param ctx      DES context to be initialized
- * \param key      8-byte secret key
- *
- * \return         0
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] );
-
-/**
- * \brief          Triple-DES key schedule (112-bit, encryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      16-byte secret key
- *
- * \return         0
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des3_set2key_enc( mbedtls_des3_context *ctx,
-                      const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] );
-
-/**
- * \brief          Triple-DES key schedule (112-bit, decryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      16-byte secret key
- *
- * \return         0
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des3_set2key_dec( mbedtls_des3_context *ctx,
-                      const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] );
-
-/**
- * \brief          Triple-DES key schedule (168-bit, encryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      24-byte secret key
- *
- * \return         0
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des3_set3key_enc( mbedtls_des3_context *ctx,
-                      const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] );
-
-/**
- * \brief          Triple-DES key schedule (168-bit, decryption)
- *
- * \param ctx      3DES context to be initialized
- * \param key      24-byte secret key
- *
- * \return         0
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des3_set3key_dec( mbedtls_des3_context *ctx,
-                      const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] );
-
-/**
- * \brief          DES-ECB block encryption/decryption
- *
- * \param ctx      DES context
- * \param input    64-bit input block
- * \param output   64-bit output block
- *
- * \return         0 if successful
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
-                    const unsigned char input[8],
-                    unsigned char output[8] );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/**
- * \brief          DES-CBC buffer encryption/decryption
- *
- * \note           Upon exit, the content of the IV is updated so that you can
- *                 call the function same function again on the following
- *                 block(s) of data and get the same result as if it was
- *                 encrypted in one call. This allows a "streaming" usage.
- *                 If on the other hand you need to retain the contents of the
- *                 IV, you should either save it manually or use the cipher
- *                 module instead.
- *
- * \param ctx      DES context
- * \param mode     MBEDTLS_DES_ENCRYPT or MBEDTLS_DES_DECRYPT
- * \param length   length of the input data
- * \param iv       initialization vector (updated after use)
- * \param input    buffer holding the input data
- * \param output   buffer holding the output data
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
-                    int mode,
-                    size_t length,
-                    unsigned char iv[8],
-                    const unsigned char *input,
-                    unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-/**
- * \brief          3DES-ECB block encryption/decryption
- *
- * \param ctx      3DES context
- * \param input    64-bit input block
- * \param output   64-bit output block
- *
- * \return         0 if successful
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
-                     const unsigned char input[8],
-                     unsigned char output[8] );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/**
- * \brief          3DES-CBC buffer encryption/decryption
- *
- * \note           Upon exit, the content of the IV is updated so that you can
- *                 call the function same function again on the following
- *                 block(s) of data and get the same result as if it was
- *                 encrypted in one call. This allows a "streaming" usage.
- *                 If on the other hand you need to retain the contents of the
- *                 IV, you should either save it manually or use the cipher
- *                 module instead.
- *
- * \param ctx      3DES context
- * \param mode     MBEDTLS_DES_ENCRYPT or MBEDTLS_DES_DECRYPT
- * \param length   length of the input data
- * \param iv       initialization vector (updated after use)
- * \param input    buffer holding the input data
- * \param output   buffer holding the output data
- *
- * \return         0 if successful, or MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx,
-                     int mode,
-                     size_t length,
-                     unsigned char iv[8],
-                     const unsigned char *input,
-                     unsigned char *output );
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-/**
- * \brief          Internal function for key expansion.
- *                 (Only exposed to allow overriding it,
- *                 see MBEDTLS_DES_SETKEY_ALT)
- *
- * \param SK       Round keys
- * \param key      Base key
- *
- * \warning        DES is considered a weak cipher and its use constitutes a
- *                 security risk. We recommend considering stronger ciphers
- *                 instead.
- */
-void mbedtls_des_setkey( uint32_t SK[32],
-                         const unsigned char key[MBEDTLS_DES_KEY_SIZE] );
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          Checkup routine
- *
- * \return         0 if successful, or 1 if the test failed
- */
-MBEDTLS_CHECK_RETURN_CRITICAL
-int mbedtls_des_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* des.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/ecdsa.h b/src/duckdb/third_party/mbedtls/include/mbedtls/ecdsa.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/ecdsa.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/ecp.h b/src/duckdb/third_party/mbedtls/include/mbedtls/ecp.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/ecp.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/entropy.h b/src/duckdb/third_party/mbedtls/include/mbedtls/entropy.h
deleted file mode 100644
index fede05ffa..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/entropy.h
+++ /dev/null
@@ -1,293 +0,0 @@
-/**
- * \file entropy.h
- *
- * \brief Entropy accumulator implementation
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_ENTROPY_H
-#define MBEDTLS_ENTROPY_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-#if defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256)
-#include "mbedtls/sha512.h"
-#define MBEDTLS_ENTROPY_SHA512_ACCUMULATOR
-#else
-#if defined(MBEDTLS_SHA256_C)
-#define MBEDTLS_ENTROPY_SHA256_ACCUMULATOR
-#include "mbedtls/sha256.h"
-#endif
-#endif
-
-#if defined(MBEDTLS_THREADING_C)
-#include "mbedtls/threading.h"
-#endif
-
-
-/** Critical entropy source failure. */
-#define MBEDTLS_ERR_ENTROPY_SOURCE_FAILED                 -0x003C
-/** No more sources can be added. */
-#define MBEDTLS_ERR_ENTROPY_MAX_SOURCES                   -0x003E
-/** No sources have been added to poll. */
-#define MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED            -0x0040
-/** No strong sources have been added to poll. */
-#define MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE              -0x003D
-/** Read/write error in file. */
-#define MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR                 -0x003F
-
-/**
- * \name SECTION: Module settings
- *
- * The configuration options you can set for this module are in this section.
- * Either change them in mbedtls_config.h or define them on the compiler command line.
- * \{
- */
-
-#if !defined(MBEDTLS_ENTROPY_MAX_SOURCES)
-#define MBEDTLS_ENTROPY_MAX_SOURCES     20      /**< Maximum number of sources supported */
-#endif
-
-#if !defined(MBEDTLS_ENTROPY_MAX_GATHER)
-#define MBEDTLS_ENTROPY_MAX_GATHER      128     /**< Maximum amount requested from entropy sources */
-#endif
-
-/* \} name SECTION: Module settings */
-
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-#define MBEDTLS_ENTROPY_BLOCK_SIZE      64      /**< Block size of entropy accumulator (SHA-512) */
-#else
-#define MBEDTLS_ENTROPY_BLOCK_SIZE      32      /**< Block size of entropy accumulator (SHA-256) */
-#endif
-
-#define MBEDTLS_ENTROPY_MAX_SEED_SIZE   1024    /**< Maximum size of seed we read from seed file */
-#define MBEDTLS_ENTROPY_SOURCE_MANUAL   MBEDTLS_ENTROPY_MAX_SOURCES
-
-#define MBEDTLS_ENTROPY_SOURCE_STRONG   1       /**< Entropy source is strong   */
-#define MBEDTLS_ENTROPY_SOURCE_WEAK     0       /**< Entropy source is weak     */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief           Entropy poll callback pointer
- *
- * \param data      Callback-specific data pointer
- * \param output    Data to fill
- * \param len       Maximum size to provide
- * \param olen      The actual amount of bytes put into the buffer (Can be 0)
- *
- * \return          0 if no critical failures occurred,
- *                  MBEDTLS_ERR_ENTROPY_SOURCE_FAILED otherwise
- */
-typedef int (*mbedtls_entropy_f_source_ptr)(void *data, unsigned char *output, size_t len,
-                            size_t *olen);
-
-/**
- * \brief           Entropy source state
- */
-typedef struct mbedtls_entropy_source_state
-{
-    mbedtls_entropy_f_source_ptr    MBEDTLS_PRIVATE(f_source);   /**< The entropy source callback */
-    void *          MBEDTLS_PRIVATE(p_source);   /**< The callback data pointer */
-    size_t          MBEDTLS_PRIVATE(size);       /**< Amount received in bytes */
-    size_t          MBEDTLS_PRIVATE(threshold);  /**< Minimum bytes required before release */
-    int             MBEDTLS_PRIVATE(strong);     /**< Is the source strong? */
-}
-mbedtls_entropy_source_state;
-
-/**
- * \brief           Entropy context structure
- */
-typedef struct mbedtls_entropy_context
-{
-    int MBEDTLS_PRIVATE(accumulator_started); /* 0 after init.
-                              * 1 after the first update.
-                              * -1 after free. */
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-    mbedtls_sha512_context  MBEDTLS_PRIVATE(accumulator);
-#elif defined(MBEDTLS_ENTROPY_SHA256_ACCUMULATOR)
-    mbedtls_sha256_context  MBEDTLS_PRIVATE(accumulator);
-#endif
-    int             MBEDTLS_PRIVATE(source_count); /* Number of entries used in source. */
-    mbedtls_entropy_source_state    MBEDTLS_PRIVATE(source)[MBEDTLS_ENTROPY_MAX_SOURCES];
-#if defined(MBEDTLS_THREADING_C)
-    mbedtls_threading_mutex_t MBEDTLS_PRIVATE(mutex);    /*!< mutex                  */
-#endif
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-    int MBEDTLS_PRIVATE(initial_entropy_run);
-#endif
-}
-mbedtls_entropy_context;
-
-#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
-/**
- * \brief           Platform-specific entropy poll callback
- */
-int mbedtls_platform_entropy_poll( void *data,
-                           unsigned char *output, size_t len, size_t *olen );
-#endif
-
-/**
- * \brief           Initialize the context
- *
- * \param ctx       Entropy context to initialize
- */
-void mbedtls_entropy_init( mbedtls_entropy_context *ctx );
-
-/**
- * \brief           Free the data in the context
- *
- * \param ctx       Entropy context to free
- */
-void mbedtls_entropy_free( mbedtls_entropy_context *ctx );
-
-/**
- * \brief           Adds an entropy source to poll
- *                  (Thread-safe if MBEDTLS_THREADING_C is enabled)
- *
- * \param ctx       Entropy context
- * \param f_source  Entropy function
- * \param p_source  Function data
- * \param threshold Minimum required from source before entropy is released
- *                  ( with mbedtls_entropy_func() ) (in bytes)
- * \param strong    MBEDTLS_ENTROPY_SOURCE_STRONG or
- *                  MBEDTLS_ENTROPY_SOURCE_WEAK.
- *                  At least one strong source needs to be added.
- *                  Weaker sources (such as the cycle counter) can be used as
- *                  a complement.
- *
- * \return          0 if successful or MBEDTLS_ERR_ENTROPY_MAX_SOURCES
- */
-int mbedtls_entropy_add_source( mbedtls_entropy_context *ctx,
-                        mbedtls_entropy_f_source_ptr f_source, void *p_source,
-                        size_t threshold, int strong );
-
-/**
- * \brief           Trigger an extra gather poll for the accumulator
- *                  (Thread-safe if MBEDTLS_THREADING_C is enabled)
- *
- * \param ctx       Entropy context
- *
- * \return          0 if successful, or MBEDTLS_ERR_ENTROPY_SOURCE_FAILED
- */
-int mbedtls_entropy_gather( mbedtls_entropy_context *ctx );
-
-/**
- * \brief           Retrieve entropy from the accumulator
- *                  (Maximum length: MBEDTLS_ENTROPY_BLOCK_SIZE)
- *                  (Thread-safe if MBEDTLS_THREADING_C is enabled)
- *
- * \param data      Entropy context
- * \param output    Buffer to fill
- * \param len       Number of bytes desired, must be at most MBEDTLS_ENTROPY_BLOCK_SIZE
- *
- * \return          0 if successful, or MBEDTLS_ERR_ENTROPY_SOURCE_FAILED
- */
-int mbedtls_entropy_func( void *data, unsigned char *output, size_t len );
-
-/**
- * \brief           Add data to the accumulator manually
- *                  (Thread-safe if MBEDTLS_THREADING_C is enabled)
- *
- * \param ctx       Entropy context
- * \param data      Data to add
- * \param len       Length of data
- *
- * \return          0 if successful
- */
-int mbedtls_entropy_update_manual( mbedtls_entropy_context *ctx,
-                           const unsigned char *data, size_t len );
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-/**
- * \brief           Trigger an update of the seed file in NV by using the
- *                  current entropy pool.
- *
- * \param ctx       Entropy context
- *
- * \return          0 if successful
- */
-int mbedtls_entropy_update_nv_seed( mbedtls_entropy_context *ctx );
-#endif /* MBEDTLS_ENTROPY_NV_SEED */
-
-#if defined(MBEDTLS_FS_IO)
-/**
- * \brief               Write a seed file
- *
- * \param ctx           Entropy context
- * \param path          Name of the file
- *
- * \return              0 if successful,
- *                      MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR on file error, or
- *                      MBEDTLS_ERR_ENTROPY_SOURCE_FAILED
- */
-int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path );
-
-/**
- * \brief               Read and update a seed file. Seed is added to this
- *                      instance. No more than MBEDTLS_ENTROPY_MAX_SEED_SIZE bytes are
- *                      read from the seed file. The rest is ignored.
- *
- * \param ctx           Entropy context
- * \param path          Name of the file
- *
- * \return              0 if successful,
- *                      MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR on file error,
- *                      MBEDTLS_ERR_ENTROPY_SOURCE_FAILED
- */
-int mbedtls_entropy_update_seed_file( mbedtls_entropy_context *ctx, const char *path );
-#endif /* MBEDTLS_FS_IO */
-
-#if defined(MBEDTLS_SELF_TEST)
-/**
- * \brief          Checkup routine
- *
- *                 This module self-test also calls the entropy self-test,
- *                 mbedtls_entropy_source_self_test();
- *
- * \return         0 if successful, or 1 if a test failed
- */
-int mbedtls_entropy_self_test( int verbose );
-
-#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
-/**
- * \brief          Checkup routine
- *
- *                 Verifies the integrity of the hardware entropy source
- *                 provided by the function 'mbedtls_hardware_poll()'.
- *
- *                 Note this is the only hardware entropy source that is known
- *                 at link time, and other entropy sources configured
- *                 dynamically at runtime by the function
- *                 mbedtls_entropy_add_source() will not be tested.
- *
- * \return         0 if successful, or 1 if a test failed
- */
-int mbedtls_entropy_source_self_test( int verbose );
-#endif /* MBEDTLS_ENTROPY_HARDWARE_ALT */
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* entropy.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/error.h b/src/duckdb/third_party/mbedtls/include/mbedtls/error.h
deleted file mode 100644
index 8b2b9ea58..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/error.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/**
- * \file error.h
- *
- * \brief Error to string translation
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_ERROR_H
-#define MBEDTLS_ERROR_H
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
-    !defined(inline) && !defined(__cplusplus)
-#define inline __inline
-#endif
-
-/**
- * Error code layout.
- *
- * Currently we try to keep all error codes within the negative space of 16
- * bits signed integers to support all platforms (-0x0001 - -0x7FFF). In
- * addition we'd like to give two layers of information on the error if
- * possible.
- *
- * For that purpose the error codes are segmented in the following manner:
- *
- * 16 bit error code bit-segmentation
- *
- * 1 bit  - Unused (sign bit)
- * 3 bits - High level module ID
- * 5 bits - Module-dependent error code
- * 7 bits - Low level module errors
- *
- * For historical reasons, low-level error codes are divided in even and odd,
- * even codes were assigned first, and -1 is reserved for other errors.
- *
- * Low-level module errors (0x0002-0x007E, 0x0001-0x007F)
- *
- * Module   Nr  Codes assigned
- * ERROR     2  0x006E          0x0001
- * MPI       7  0x0002-0x0010
- * GCM       3  0x0012-0x0016   0x0013-0x0013
- * THREADING 3  0x001A-0x001E
- * AES       5  0x0020-0x0022   0x0021-0x0025
- * CAMELLIA  3  0x0024-0x0026   0x0027-0x0027
- * BASE64    2  0x002A-0x002C
- * OID       1  0x002E-0x002E   0x000B-0x000B
- * PADLOCK   1  0x0030-0x0030
- * DES       2  0x0032-0x0032   0x0033-0x0033
- * CTR_DBRG  4  0x0034-0x003A
- * ENTROPY   3  0x003C-0x0040   0x003D-0x003F
- * NET      13  0x0042-0x0052   0x0043-0x0049
- * ARIA      4  0x0058-0x005E
- * ASN1      7  0x0060-0x006C
- * CMAC      1  0x007A-0x007A
- * PBKDF2    1  0x007C-0x007C
- * HMAC_DRBG 4                  0x0003-0x0009
- * CCM       3                  0x000D-0x0011
- * MD5       1                  0x002F-0x002F
- * RIPEMD160 1                  0x0031-0x0031
- * SHA1      1                  0x0035-0x0035 0x0073-0x0073
- * SHA256    1                  0x0037-0x0037 0x0074-0x0074
- * SHA512    1                  0x0039-0x0039 0x0075-0x0075
- * CHACHA20  3                  0x0051-0x0055
- * POLY1305  3                  0x0057-0x005B
- * CHACHAPOLY 2 0x0054-0x0056
- * PLATFORM  2  0x0070-0x0072
- *
- * High-level module nr (3 bits - 0x0...-0x7...)
- * Name      ID  Nr of Errors
- * PEM       1   9
- * PKCS#12   1   4 (Started from top)
- * X509      2   20
- * PKCS5     2   4 (Started from top)
- * DHM       3   11
- * PK        3   15 (Started from top)
- * RSA       4   11
- * ECP       4   10 (Started from top)
- * MD        5   5
- * HKDF      5   1 (Started from top)
- * SSL       5   2 (Started from 0x5F00)
- * CIPHER    6   8 (Started from 0x6080)
- * SSL       6   22 (Started from top, plus 0x6000)
- * SSL       7   20 (Started from 0x7000, gaps at
- *                   0x7380, 0x7900-0x7980, 0x7A80-0x7E80)
- *
- * Module dependent error code (5 bits 0x.00.-0x.F8.)
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Generic error */
-#define MBEDTLS_ERR_ERROR_GENERIC_ERROR       -0x0001
-/** This is a bug in the library */
-#define MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED -0x006E
-
-/** Hardware accelerator failed */
-#define MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED     -0x0070
-/** The requested feature is not supported by the platform */
-#define MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED -0x0072
-
-/**
- * \brief Combines a high-level and low-level error code together.
- *
- *        Wrapper macro for mbedtls_error_add(). See that function for
- *        more details.
- */
-#define MBEDTLS_ERROR_ADD( high, low ) \
-        mbedtls_error_add( high, low, __FILE__, __LINE__ )
-
-#if defined(MBEDTLS_TEST_HOOKS)
-/**
- * \brief Testing hook called before adding/combining two error codes together.
- *        Only used when invasive testing is enabled via MBEDTLS_TEST_HOOKS.
- */
-extern void (*mbedtls_test_hook_error_add)( int, int, const char *, int );
-#endif
-
-/**
- * \brief Combines a high-level and low-level error code together.
- *
- *        This function can be called directly however it is usually
- *        called via the #MBEDTLS_ERROR_ADD macro.
- *
- *        While a value of zero is not a negative error code, it is still an
- *        error code (that denotes success) and can be combined with both a
- *        negative error code or another value of zero.
- *
- * \note  When invasive testing is enabled via #MBEDTLS_TEST_HOOKS, also try to
- *        call \link mbedtls_test_hook_error_add \endlink.
- *
- * \param high      high-level error code. See error.h for more details.
- * \param low       low-level error code. See error.h for more details.
- * \param file      file where this error code addition occurred.
- * \param line      line where this error code addition occurred.
- */
-static inline int mbedtls_error_add( int high, int low,
-                                     const char *file, int line )
-{
-#if defined(MBEDTLS_TEST_HOOKS)
-    if( *mbedtls_test_hook_error_add != NULL )
-        ( *mbedtls_test_hook_error_add )( high, low, file, line );
-#endif
-    (void)file;
-    (void)line;
-
-    return( high + low );
-}
-
-/**
- * \brief Translate a mbed TLS error code into a string representation,
- *        Result is truncated if necessary and always includes a terminating
- *        null byte.
- *
- * \param errnum    error code
- * \param buffer    buffer to place representation in
- * \param buflen    length of the buffer
- */
-void mbedtls_strerror( int errnum, char *buffer, size_t buflen );
-
-/**
- * \brief Translate the high-level part of an Mbed TLS error code into a string
- *        representation.
- *
- * This function returns a const pointer to an un-modifiable string. The caller
- * must not try to modify the string. It is intended to be used mostly for
- * logging purposes.
- *
- * \param error_code    error code
- *
- * \return The string representation of the error code, or \c NULL if the error
- *         code is unknown.
- */
-const char * mbedtls_high_level_strerr( int error_code );
-
-/**
- * \brief Translate the low-level part of an Mbed TLS error code into a string
- *        representation.
- *
- * This function returns a const pointer to an un-modifiable string. The caller
- * must not try to modify the string. It is intended to be used mostly for
- * logging purposes.
- *
- * \param error_code    error code
- *
- * \return The string representation of the error code, or \c NULL if the error
- *         code is unknown.
- */
-const char * mbedtls_low_level_strerr( int error_code );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* error.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/gcm.h b/src/duckdb/third_party/mbedtls/include/mbedtls/gcm.h
deleted file mode 100644
index 500b1ee6e..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/gcm.h
+++ /dev/null
@@ -1,383 +0,0 @@
-/**
- * \file gcm.h
- *
- * \brief This file contains GCM definitions and functions.
- *
- * The Galois/Counter Mode (GCM) for 128-bit block ciphers is defined
- * in <em>D. McGrew, J. Viega, The Galois/Counter Mode of Operation
- * (GCM), Natl. Inst. Stand. Technol.</em>
- *
- * For more information on GCM, see <em>NIST SP 800-38D: Recommendation for
- * Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC</em>.
- *
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_GCM_H
-#define MBEDTLS_GCM_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/cipher.h"
-
-#include <stdint.h>
-
-#define MBEDTLS_GCM_ENCRYPT     1
-#define MBEDTLS_GCM_DECRYPT     0
-
-/** Authenticated decryption failed. */
-#define MBEDTLS_ERR_GCM_AUTH_FAILED                       -0x0012
-/** Bad input parameters to function. */
-#define MBEDTLS_ERR_GCM_BAD_INPUT                         -0x0014
-/** An output buffer is too small. */
-#define MBEDTLS_ERR_GCM_BUFFER_TOO_SMALL                  -0x0016
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_GCM_ALT)
-
-/**
- * \brief          The GCM context structure.
- */
-typedef struct mbedtls_gcm_context
-{
-    mbedtls_cipher_context_t MBEDTLS_PRIVATE(cipher_ctx);  /*!< The cipher context used. */
-    uint64_t MBEDTLS_PRIVATE(HL)[16];                      /*!< Precalculated HTable low. */
-    uint64_t MBEDTLS_PRIVATE(HH)[16];                      /*!< Precalculated HTable high. */
-    uint64_t MBEDTLS_PRIVATE(len);                         /*!< The total length of the encrypted data. */
-    uint64_t MBEDTLS_PRIVATE(add_len);                     /*!< The total length of the additional data. */
-    unsigned char MBEDTLS_PRIVATE(base_ectr)[16];          /*!< The first ECTR for tag. */
-    unsigned char MBEDTLS_PRIVATE(y)[16];                  /*!< The Y working value. */
-    unsigned char MBEDTLS_PRIVATE(buf)[16];                /*!< The buf working value. */
-    int MBEDTLS_PRIVATE(mode);                             /*!< The operation to perform:
-                                               #MBEDTLS_GCM_ENCRYPT or
-                                               #MBEDTLS_GCM_DECRYPT. */
-}
-mbedtls_gcm_context;
-
-#else  /* !MBEDTLS_GCM_ALT */
-#include "mbedtls/gcm_alt.h"
-#endif /* !MBEDTLS_GCM_ALT */
-
-/**
- * \brief           This function initializes the specified GCM context,
- *                  to make references valid, and prepares the context
- *                  for mbedtls_gcm_setkey() or mbedtls_gcm_free().
- *
- *                  The function does not bind the GCM context to a particular
- *                  cipher, nor set the key. For this purpose, use
- *                  mbedtls_gcm_setkey().
- *
- * \param ctx       The GCM context to initialize. This must not be \c NULL.
- */
-void mbedtls_gcm_init( mbedtls_gcm_context *ctx );
-
-/**
- * \brief           This function associates a GCM context with a
- *                  cipher algorithm and a key.
- *
- * \param ctx       The GCM context. This must be initialized.
- * \param cipher    The 128-bit block cipher to use.
- * \param key       The encryption key. This must be a readable buffer of at
- *                  least \p keybits bits.
- * \param keybits   The key size in bits. Valid options are:
- *                  <ul><li>128 bits</li>
- *                  <li>192 bits</li>
- *                  <li>256 bits</li></ul>
- *
- * \return          \c 0 on success.
- * \return          A cipher-specific error code on failure.
- */
-int mbedtls_gcm_setkey( mbedtls_gcm_context *ctx,
-                        mbedtls_cipher_id_t cipher,
-                        const unsigned char *key,
-                        unsigned int keybits );
-
-/**
- * \brief           This function performs GCM encryption or decryption of a buffer.
- *
- * \note            For encryption, the output buffer can be the same as the
- *                  input buffer. For decryption, the output buffer cannot be
- *                  the same as input buffer. If the buffers overlap, the output
- *                  buffer must trail at least 8 Bytes behind the input buffer.
- *
- * \warning         When this function performs a decryption, it outputs the
- *                  authentication tag and does not verify that the data is
- *                  authentic. You should use this function to perform encryption
- *                  only. For decryption, use mbedtls_gcm_auth_decrypt() instead.
- *
- * \param ctx       The GCM context to use for encryption or decryption. This
- *                  must be initialized.
- * \param mode      The operation to perform:
- *                  - #MBEDTLS_GCM_ENCRYPT to perform authenticated encryption.
- *                    The ciphertext is written to \p output and the
- *                    authentication tag is written to \p tag.
- *                  - #MBEDTLS_GCM_DECRYPT to perform decryption.
- *                    The plaintext is written to \p output and the
- *                    authentication tag is written to \p tag.
- *                    Note that this mode is not recommended, because it does
- *                    not verify the authenticity of the data. For this reason,
- *                    you should use mbedtls_gcm_auth_decrypt() instead of
- *                    calling this function in decryption mode.
- * \param length    The length of the input data, which is equal to the length
- *                  of the output data.
- * \param iv        The initialization vector. This must be a readable buffer of
- *                  at least \p iv_len Bytes.
- * \param iv_len    The length of the IV.
- * \param add       The buffer holding the additional data. This must be of at
- *                  least that size in Bytes.
- * \param add_len   The length of the additional data.
- * \param input     The buffer holding the input data. If \p length is greater
- *                  than zero, this must be a readable buffer of at least that
- *                  size in Bytes.
- * \param output    The buffer for holding the output data. If \p length is greater
- *                  than zero, this must be a writable buffer of at least that
- *                  size in Bytes.
- * \param tag_len   The length of the tag to generate.
- * \param tag       The buffer for holding the tag. This must be a writable
- *                  buffer of at least \p tag_len Bytes.
- *
- * \return          \c 0 if the encryption or decryption was performed
- *                  successfully. Note that in #MBEDTLS_GCM_DECRYPT mode,
- *                  this does not indicate that the data is authentic.
- * \return          #MBEDTLS_ERR_GCM_BAD_INPUT if the lengths or pointers are
- *                  not valid or a cipher-specific error code if the encryption
- *                  or decryption failed.
- */
-int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx,
-                       int mode,
-                       size_t length,
-                       const unsigned char *iv,
-                       size_t iv_len,
-                       const unsigned char *add,
-                       size_t add_len,
-                       const unsigned char *input,
-                       unsigned char *output,
-                       size_t tag_len,
-                       unsigned char *tag );
-
-/**
- * \brief           This function performs a GCM authenticated decryption of a
- *                  buffer.
- *
- * \note            For decryption, the output buffer cannot be the same as
- *                  input buffer. If the buffers overlap, the output buffer
- *                  must trail at least 8 Bytes behind the input buffer.
- *
- * \param ctx       The GCM context. This must be initialized.
- * \param length    The length of the ciphertext to decrypt, which is also
- *                  the length of the decrypted plaintext.
- * \param iv        The initialization vector. This must be a readable buffer
- *                  of at least \p iv_len Bytes.
- * \param iv_len    The length of the IV.
- * \param add       The buffer holding the additional data. This must be of at
- *                  least that size in Bytes.
- * \param add_len   The length of the additional data.
- * \param tag       The buffer holding the tag to verify. This must be a
- *                  readable buffer of at least \p tag_len Bytes.
- * \param tag_len   The length of the tag to verify.
- * \param input     The buffer holding the ciphertext. If \p length is greater
- *                  than zero, this must be a readable buffer of at least that
- *                  size.
- * \param output    The buffer for holding the decrypted plaintext. If \p length
- *                  is greater than zero, this must be a writable buffer of at
- *                  least that size.
- *
- * \return          \c 0 if successful and authenticated.
- * \return          #MBEDTLS_ERR_GCM_AUTH_FAILED if the tag does not match.
- * \return          #MBEDTLS_ERR_GCM_BAD_INPUT if the lengths or pointers are
- *                  not valid or a cipher-specific error code if the decryption
- *                  failed.
- */
-int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *ctx,
-                      size_t length,
-                      const unsigned char *iv,
-                      size_t iv_len,
-                      const unsigned char *add,
-                      size_t add_len,
-                      const unsigned char *tag,
-                      size_t tag_len,
-                      const unsigned char *input,
-                      unsigned char *output );
-
-/**
- * \brief           This function starts a GCM encryption or decryption
- *                  operation.
- *
- * \param ctx       The GCM context. This must be initialized.
- * \param mode      The operation to perform: #MBEDTLS_GCM_ENCRYPT or
- *                  #MBEDTLS_GCM_DECRYPT.
- * \param iv        The initialization vector. This must be a readable buffer of
- *                  at least \p iv_len Bytes.
- * \param iv_len    The length of the IV.
- *
- * \return          \c 0 on success.
- */
-int mbedtls_gcm_starts( mbedtls_gcm_context *ctx,
-                        int mode,
-                        const unsigned char *iv,
-                        size_t iv_len );
-
-/**
- * \brief           This function feeds an input buffer as associated data
- *                  (authenticated but not encrypted data) in a GCM
- *                  encryption or decryption operation.
- *
- *                  Call this function after mbedtls_gcm_starts() to pass
- *                  the associated data. If the associated data is empty,
- *                  you do not need to call this function. You may not
- *                  call this function after calling mbedtls_cipher_update().
- *
- * \param ctx       The GCM context. This must have been started with
- *                  mbedtls_gcm_starts() and must not have yet received
- *                  any input with mbedtls_gcm_update().
- * \param add       The buffer holding the additional data, or \c NULL
- *                  if \p add_len is \c 0.
- * \param add_len   The length of the additional data. If \c 0,
- *                  \p add may be \c NULL.
- *
- * \return          \c 0 on success.
- */
-int mbedtls_gcm_update_ad( mbedtls_gcm_context *ctx,
-                           const unsigned char *add,
-                           size_t add_len );
-
-/**
- * \brief           This function feeds an input buffer into an ongoing GCM
- *                  encryption or decryption operation.
- *
- *                  You may call this function zero, one or more times
- *                  to pass successive parts of the input: the plaintext to
- *                  encrypt, or the ciphertext (not including the tag) to
- *                  decrypt. After the last part of the input, call
- *                  mbedtls_gcm_finish().
- *
- *                  This function may produce output in one of the following
- *                  ways:
- *                  - Immediate output: the output length is always equal
- *                    to the input length.
- *                  - Buffered output: the output consists of a whole number
- *                    of 16-byte blocks. If the total input length so far
- *                    (not including associated data) is 16 \* *B* + *A*
- *                    with *A* < 16 then the total output length is 16 \* *B*.
- *
- *                  In particular:
- *                  - It is always correct to call this function with
- *                    \p output_size >= \p input_length + 15.
- *                  - If \p input_length is a multiple of 16 for all the calls
- *                    to this function during an operation, then it is
- *                    correct to use \p output_size = \p input_length.
- *
- * \note            For decryption, the output buffer cannot be the same as
- *                  input buffer. If the buffers overlap, the output buffer
- *                  must trail at least 8 Bytes behind the input buffer.
- *
- * \param ctx           The GCM context. This must be initialized.
- * \param input         The buffer holding the input data. If \p input_length
- *                      is greater than zero, this must be a readable buffer
- *                      of at least \p input_length bytes.
- * \param input_length  The length of the input data in bytes.
- * \param output        The buffer for the output data. If \p output_size
- *                      is greater than zero, this must be a writable buffer of
- *                      of at least \p output_size bytes.
- * \param output_size   The size of the output buffer in bytes.
- *                      See the function description regarding the output size.
- * \param output_length On success, \p *output_length contains the actual
- *                      length of the output written in \p output.
- *                      On failure, the content of \p *output_length is
- *                      unspecified.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_GCM_BAD_INPUT on failure:
- *                 total input length too long,
- *                 unsupported input/output buffer overlap detected,
- *                 or \p output_size too small.
- */
-int mbedtls_gcm_update( mbedtls_gcm_context *ctx,
-                        const unsigned char *input, size_t input_length,
-                        unsigned char *output, size_t output_size,
-                        size_t *output_length );
-
-/**
- * \brief           This function finishes the GCM operation and generates
- *                  the authentication tag.
- *
- *                  It wraps up the GCM stream, and generates the
- *                  tag. The tag can have a maximum length of 16 Bytes.
- *
- * \param ctx       The GCM context. This must be initialized.
- * \param tag       The buffer for holding the tag. This must be a writable
- *                  buffer of at least \p tag_len Bytes.
- * \param tag_len   The length of the tag to generate. This must be at least
- *                  four.
- * \param output    The buffer for the final output.
- *                  If \p output_size is nonzero, this must be a writable
- *                  buffer of at least \p output_size bytes.
- * \param output_size  The size of the \p output buffer in bytes.
- *                  This must be large enough for the output that
- *                  mbedtls_gcm_update() has not produced. In particular:
- *                  - If mbedtls_gcm_update() produces immediate output,
- *                    or if the total input size is a multiple of \c 16,
- *                    then mbedtls_gcm_finish() never produces any output,
- *                    so \p output_size can be \c 0.
- *                  - \p output_size never needs to be more than \c 15.
- * \param output_length On success, \p *output_length contains the actual
- *                      length of the output written in \p output.
- *                      On failure, the content of \p *output_length is
- *                      unspecified.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_GCM_BAD_INPUT on failure:
- *                  invalid value of \p tag_len,
- *                  or \p output_size too small.
- */
-int mbedtls_gcm_finish( mbedtls_gcm_context *ctx,
-                        unsigned char *output, size_t output_size,
-                        size_t *output_length,
-                        unsigned char *tag, size_t tag_len );
-
-/**
- * \brief           This function clears a GCM context and the underlying
- *                  cipher sub-context.
- *
- * \param ctx       The GCM context to clear. If this is \c NULL, the call has
- *                  no effect. Otherwise, this must be initialized.
- */
-void mbedtls_gcm_free( mbedtls_gcm_context *ctx );
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          The GCM checkup routine.
- *
- * \return         \c 0 on success.
- * \return         \c 1 on failure.
- */
-int mbedtls_gcm_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* gcm.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/gcm_alt.h b/src/duckdb/third_party/mbedtls/include/mbedtls/gcm_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/gcm_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/mbedtls_config.h b/src/duckdb/third_party/mbedtls/include/mbedtls/mbedtls_config.h
deleted file mode 100644
index 6487c7123..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/mbedtls_config.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#define MBEDTLS_SHA1_C
-#define MBEDTLS_SHA256_C
-#define MBEDTLS_SHA224_C
-#define MBEDTLS_RSA_C
-#define MBEDTLS_PKCS1_V15
-#define MBEDTLS_BIGNUM_C
-#define MBEDTLS_OID_C
-#define MBEDTLS_MD_C
-#define MBEDTLS_BASE64_C
-#define MBEDTLS_PK_PARSE_C
-#define MBEDTLS_ASN1_PARSE_C
-#define MBEDTLS_PK_C
-#define MBEDTLS_PEM_PARSE_C
-#define MBEDTLS_PLATFORM_C
-#define MBEDTLS_AES_C
-#define MBEDTLS_CIPHER_C
-#define MBEDTLS_CAMELLIA_C
-#define MBEDTLS_ARIA_C
-#define MBEDTLS_GCM_C
-#define MBEDTLS_ENTROPY_C
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/md.h b/src/duckdb/third_party/mbedtls/include/mbedtls/md.h
deleted file mode 100644
index 2b668f55e..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/md.h
+++ /dev/null
@@ -1,464 +0,0 @@
- /**
- * \file md.h
- *
- * \brief This file contains the generic message-digest wrapper.
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_MD_H
-#define MBEDTLS_MD_H
-#include "mbedtls/private_access.h"
-
-#include <stddef.h>
-
-#include "mbedtls/build_info.h"
-#include "mbedtls/platform_util.h"
-
-/** The selected feature is not available. */
-#define MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE                -0x5080
-/** Bad input parameters to function. */
-#define MBEDTLS_ERR_MD_BAD_INPUT_DATA                     -0x5100
-/** Failed to allocate memory. */
-#define MBEDTLS_ERR_MD_ALLOC_FAILED                       -0x5180
-/** Opening or reading of file failed. */
-#define MBEDTLS_ERR_MD_FILE_IO_ERROR                      -0x5200
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief     Supported message digests.
- *
- * \warning   MD5 and SHA-1 are considered weak message digests and
- *            their use constitutes a security risk. We recommend considering
- *            stronger message digests instead.
- *
- */
-typedef enum {
-    MBEDTLS_MD_NONE=0,    /**< None. */
-    MBEDTLS_MD_MD5,       /**< The MD5 message digest. */
-    MBEDTLS_MD_SHA1,      /**< The SHA-1 message digest. */
-    MBEDTLS_MD_SHA224,    /**< The SHA-224 message digest. */
-    MBEDTLS_MD_SHA256,    /**< The SHA-256 message digest. */
-    MBEDTLS_MD_SHA384,    /**< The SHA-384 message digest. */
-    MBEDTLS_MD_SHA512,    /**< The SHA-512 message digest. */
-    MBEDTLS_MD_RIPEMD160, /**< The RIPEMD-160 message digest. */
-} mbedtls_md_type_t;
-
-#if defined(MBEDTLS_SHA512_C)
-#define MBEDTLS_MD_MAX_SIZE         64  /* longest known is SHA512 */
-#else
-#define MBEDTLS_MD_MAX_SIZE         32  /* longest known is SHA256 or less */
-#endif
-
-#if defined(MBEDTLS_SHA512_C)
-#define MBEDTLS_MD_MAX_BLOCK_SIZE         128
-#else
-#define MBEDTLS_MD_MAX_BLOCK_SIZE         64
-#endif
-
-/**
- * Opaque struct.
- *
- * Constructed using either #mbedtls_md_info_from_string or
- * #mbedtls_md_info_from_type.
- *
- * Fields can be accessed with #mbedtls_md_get_size,
- * #mbedtls_md_get_type and #mbedtls_md_get_name.
- */
-/* Defined internally in library/md_wrap.h. */
-typedef struct mbedtls_md_info_t mbedtls_md_info_t;
-
-/**
- * The generic message-digest context.
- */
-typedef struct mbedtls_md_context_t
-{
-    /** Information about the associated message digest. */
-    const mbedtls_md_info_t *MBEDTLS_PRIVATE(md_info);
-
-    /** The digest-specific context. */
-    void *MBEDTLS_PRIVATE(md_ctx);
-
-    /** The HMAC part of the context. */
-    void *MBEDTLS_PRIVATE(hmac_ctx);
-} mbedtls_md_context_t;
-
-/**
- * \brief           This function returns the list of digests supported by the
- *                  generic digest module.
- *
- * \note            The list starts with the strongest available hashes.
- *
- * \return          A statically allocated array of digests. Each element
- *                  in the returned list is an integer belonging to the
- *                  message-digest enumeration #mbedtls_md_type_t.
- *                  The last entry is 0.
- */
-const int *mbedtls_md_list( void );
-
-/**
- * \brief           This function returns the message-digest information
- *                  associated with the given digest name.
- *
- * \param md_name   The name of the digest to search for.
- *
- * \return          The message-digest information associated with \p md_name.
- * \return          NULL if the associated message-digest information is not found.
- */
-const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name );
-
-/**
- * \brief           This function returns the message-digest information
- *                  associated with the given digest type.
- *
- * \param md_type   The type of digest to search for.
- *
- * \return          The message-digest information associated with \p md_type.
- * \return          NULL if the associated message-digest information is not found.
- */
-const mbedtls_md_info_t *mbedtls_md_info_from_type( mbedtls_md_type_t md_type );
-
-/**
- * \brief           This function initializes a message-digest context without
- *                  binding it to a particular message-digest algorithm.
- *
- *                  This function should always be called first. It prepares the
- *                  context for mbedtls_md_setup() for binding it to a
- *                  message-digest algorithm.
- */
-void mbedtls_md_init( mbedtls_md_context_t *ctx );
-
-/**
- * \brief           This function clears the internal structure of \p ctx and
- *                  frees any embedded internal structure, but does not free
- *                  \p ctx itself.
- *
- *                  If you have called mbedtls_md_setup() on \p ctx, you must
- *                  call mbedtls_md_free() when you are no longer using the
- *                  context.
- *                  Calling this function if you have previously
- *                  called mbedtls_md_init() and nothing else is optional.
- *                  You must not call this function if you have not called
- *                  mbedtls_md_init().
- */
-void mbedtls_md_free( mbedtls_md_context_t *ctx );
-
-
-/**
- * \brief           This function selects the message digest algorithm to use,
- *                  and allocates internal structures.
- *
- *                  It should be called after mbedtls_md_init() or
- *                  mbedtls_md_free(). Makes it necessary to call
- *                  mbedtls_md_free() later.
- *
- * \param ctx       The context to set up.
- * \param md_info   The information structure of the message-digest algorithm
- *                  to use.
- * \param hmac      Defines if HMAC is used. 0: HMAC is not used (saves some memory),
- *                  or non-zero: HMAC is used with this context.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- * \return          #MBEDTLS_ERR_MD_ALLOC_FAILED on memory-allocation failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac );
-
-/**
- * \brief           This function clones the state of an message-digest
- *                  context.
- *
- * \note            You must call mbedtls_md_setup() on \c dst before calling
- *                  this function.
- *
- * \note            The two contexts must have the same type,
- *                  for example, both are SHA-256.
- *
- * \warning         This function clones the message-digest state, not the
- *                  HMAC state.
- *
- * \param dst       The destination context.
- * \param src       The context to be cloned.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_clone( mbedtls_md_context_t *dst,
-                      const mbedtls_md_context_t *src );
-
-/**
- * \brief           This function extracts the message-digest size from the
- *                  message-digest information structure.
- *
- * \param md_info   The information structure of the message-digest algorithm
- *                  to use.
- *
- * \return          The size of the message-digest output in Bytes.
- */
-unsigned char mbedtls_md_get_size( const mbedtls_md_info_t *md_info );
-
-/**
- * \brief           This function extracts the message-digest type from the
- *                  message-digest information structure.
- *
- * \param md_info   The information structure of the message-digest algorithm
- *                  to use.
- *
- * \return          The type of the message digest.
- */
-mbedtls_md_type_t mbedtls_md_get_type( const mbedtls_md_info_t *md_info );
-
-/**
- * \brief           This function extracts the message-digest name from the
- *                  message-digest information structure.
- *
- * \param md_info   The information structure of the message-digest algorithm
- *                  to use.
- *
- * \return          The name of the message digest.
- */
-const char *mbedtls_md_get_name( const mbedtls_md_info_t *md_info );
-
-/**
- * \brief           This function starts a message-digest computation.
- *
- *                  You must call this function after setting up the context
- *                  with mbedtls_md_setup(), and before passing data with
- *                  mbedtls_md_update().
- *
- * \param ctx       The generic message-digest context.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_starts( mbedtls_md_context_t *ctx );
-
-/**
- * \brief           This function feeds an input buffer into an ongoing
- *                  message-digest computation.
- *
- *                  You must call mbedtls_md_starts() before calling this
- *                  function. You may call this function multiple times.
- *                  Afterwards, call mbedtls_md_finish().
- *
- * \param ctx       The generic message-digest context.
- * \param input     The buffer holding the input data.
- * \param ilen      The length of the input data.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen );
-
-/**
- * \brief           This function finishes the digest operation,
- *                  and writes the result to the output buffer.
- *
- *                  Call this function after a call to mbedtls_md_starts(),
- *                  followed by any number of calls to mbedtls_md_update().
- *                  Afterwards, you may either clear the context with
- *                  mbedtls_md_free(), or call mbedtls_md_starts() to reuse
- *                  the context for another digest operation with the same
- *                  algorithm.
- *
- * \param ctx       The generic message-digest context.
- * \param output    The buffer for the generic message-digest checksum result.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output );
-
-/**
- * \brief          This function calculates the message-digest of a buffer,
- *                 with respect to a configurable message-digest algorithm
- *                 in a single call.
- *
- *                 The result is calculated as
- *                 Output = message_digest(input buffer).
- *
- * \param md_info  The information structure of the message-digest algorithm
- *                 to use.
- * \param input    The buffer holding the data.
- * \param ilen     The length of the input data.
- * \param output   The generic message-digest checksum result.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                 failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md( const mbedtls_md_info_t *md_info, const unsigned char *input, size_t ilen,
-        unsigned char *output );
-
-#if defined(MBEDTLS_FS_IO)
-/**
- * \brief          This function calculates the message-digest checksum
- *                 result of the contents of the provided file.
- *
- *                 The result is calculated as
- *                 Output = message_digest(file contents).
- *
- * \param md_info  The information structure of the message-digest algorithm
- *                 to use.
- * \param path     The input file name.
- * \param output   The generic message-digest checksum result.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_MD_FILE_IO_ERROR on an I/O error accessing
- *                 the file pointed by \p path.
- * \return         #MBEDTLS_ERR_MD_BAD_INPUT_DATA if \p md_info was NULL.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path,
-                     unsigned char *output );
-#endif /* MBEDTLS_FS_IO */
-
-/**
- * \brief           This function sets the HMAC key and prepares to
- *                  authenticate a new message.
- *
- *                  Call this function after mbedtls_md_setup(), to use
- *                  the MD context for an HMAC calculation, then call
- *                  mbedtls_md_hmac_update() to provide the input data, and
- *                  mbedtls_md_hmac_finish() to get the HMAC value.
- *
- * \param ctx       The message digest context containing an embedded HMAC
- *                  context.
- * \param key       The HMAC secret key.
- * \param keylen    The length of the HMAC key in Bytes.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key,
-                    size_t keylen );
-
-/**
- * \brief           This function feeds an input buffer into an ongoing HMAC
- *                  computation.
- *
- *                  Call mbedtls_md_hmac_starts() or mbedtls_md_hmac_reset()
- *                  before calling this function.
- *                  You may call this function multiple times to pass the
- *                  input piecewise.
- *                  Afterwards, call mbedtls_md_hmac_finish().
- *
- * \param ctx       The message digest context containing an embedded HMAC
- *                  context.
- * \param input     The buffer holding the input data.
- * \param ilen      The length of the input data.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_hmac_update( mbedtls_md_context_t *ctx, const unsigned char *input,
-                    size_t ilen );
-
-/**
- * \brief           This function finishes the HMAC operation, and writes
- *                  the result to the output buffer.
- *
- *                  Call this function after mbedtls_md_hmac_starts() and
- *                  mbedtls_md_hmac_update() to get the HMAC value. Afterwards
- *                  you may either call mbedtls_md_free() to clear the context,
- *                  or call mbedtls_md_hmac_reset() to reuse the context with
- *                  the same HMAC key.
- *
- * \param ctx       The message digest context containing an embedded HMAC
- *                  context.
- * \param output    The generic HMAC checksum result.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output);
-
-/**
- * \brief           This function prepares to authenticate a new message with
- *                  the same key as the previous HMAC operation.
- *
- *                  You may call this function after mbedtls_md_hmac_finish().
- *                  Afterwards call mbedtls_md_hmac_update() to pass the new
- *                  input.
- *
- * \param ctx       The message digest context containing an embedded HMAC
- *                  context.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                  failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx );
-
-/**
- * \brief          This function calculates the full generic HMAC
- *                 on the input buffer with the provided key.
- *
- *                 The function allocates the context, performs the
- *                 calculation, and frees the context.
- *
- *                 The HMAC result is calculated as
- *                 output = generic HMAC(hmac key, input buffer).
- *
- * \param md_info  The information structure of the message-digest algorithm
- *                 to use.
- * \param key      The HMAC secret key.
- * \param keylen   The length of the HMAC secret key in Bytes.
- * \param input    The buffer holding the input data.
- * \param ilen     The length of the input data.
- * \param output   The generic HMAC result.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_MD_BAD_INPUT_DATA on parameter-verification
- *                 failure.
- */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_hmac( const mbedtls_md_info_t *md_info, const unsigned char *key, size_t keylen,
-                const unsigned char *input, size_t ilen,
-                unsigned char *output );
-
-/* Internal use */
-MBEDTLS_CHECK_RETURN_TYPICAL
-int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_MD_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/md5.h b/src/duckdb/third_party/mbedtls/include/mbedtls/md5.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/md5.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/memory_buffer_alloc.h b/src/duckdb/third_party/mbedtls/include/mbedtls/memory_buffer_alloc.h
deleted file mode 100644
index d4737f5c4..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/memory_buffer_alloc.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/**
- * \file memory_buffer_alloc.h
- *
- * \brief Buffer-based memory allocator
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_MEMORY_BUFFER_ALLOC_H
-#define MBEDTLS_MEMORY_BUFFER_ALLOC_H
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-/**
- * \name SECTION: Module settings
- *
- * The configuration options you can set for this module are in this section.
- * Either change them in mbedtls_config.h or define them on the compiler command line.
- * \{
- */
-
-#if !defined(MBEDTLS_MEMORY_ALIGN_MULTIPLE)
-#define MBEDTLS_MEMORY_ALIGN_MULTIPLE       4 /**< Align on multiples of this value */
-#endif
-
-/* \} name SECTION: Module settings */
-
-#define MBEDTLS_MEMORY_VERIFY_NONE         0
-#define MBEDTLS_MEMORY_VERIFY_ALLOC        (1 << 0)
-#define MBEDTLS_MEMORY_VERIFY_FREE         (1 << 1)
-#define MBEDTLS_MEMORY_VERIFY_ALWAYS       (MBEDTLS_MEMORY_VERIFY_ALLOC | MBEDTLS_MEMORY_VERIFY_FREE)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief   Initialize use of stack-based memory allocator.
- *          The stack-based allocator does memory management inside the
- *          presented buffer and does not call calloc() and free().
- *          It sets the global mbedtls_calloc() and mbedtls_free() pointers
- *          to its own functions.
- *          (Provided mbedtls_calloc() and mbedtls_free() are thread-safe if
- *           MBEDTLS_THREADING_C is defined)
- *
- * \note    This code is not optimized and provides a straight-forward
- *          implementation of a stack-based memory allocator.
- *
- * \param buf   buffer to use as heap
- * \param len   size of the buffer
- */
-void mbedtls_memory_buffer_alloc_init( unsigned char *buf, size_t len );
-
-/**
- * \brief   Free the mutex for thread-safety and clear remaining memory
- */
-void mbedtls_memory_buffer_alloc_free( void );
-
-/**
- * \brief   Determine when the allocator should automatically verify the state
- *          of the entire chain of headers / meta-data.
- *          (Default: MBEDTLS_MEMORY_VERIFY_NONE)
- *
- * \param verify    One of MBEDTLS_MEMORY_VERIFY_NONE, MBEDTLS_MEMORY_VERIFY_ALLOC,
- *                  MBEDTLS_MEMORY_VERIFY_FREE or MBEDTLS_MEMORY_VERIFY_ALWAYS
- */
-void mbedtls_memory_buffer_set_verify( int verify );
-
-#if defined(MBEDTLS_MEMORY_DEBUG)
-/**
- * \brief   Print out the status of the allocated memory (primarily for use
- *          after a program should have de-allocated all memory)
- *          Prints out a list of 'still allocated' blocks and their stack
- *          trace if MBEDTLS_MEMORY_BACKTRACE is defined.
- */
-void mbedtls_memory_buffer_alloc_status( void );
-
-/**
- * \brief   Get the peak heap usage so far
- *
- * \param max_used      Peak number of bytes in use or committed. This
- *                      includes bytes in allocated blocks too small to split
- *                      into smaller blocks but larger than the requested size.
- * \param max_blocks    Peak number of blocks in use, including free and used
- */
-void mbedtls_memory_buffer_alloc_max_get( size_t *max_used, size_t *max_blocks );
-
-/**
- * \brief   Reset peak statistics
- */
-void mbedtls_memory_buffer_alloc_max_reset( void );
-
-/**
- * \brief   Get the current heap usage
- *
- * \param cur_used      Current number of bytes in use or committed. This
- *                      includes bytes in allocated blocks too small to split
- *                      into smaller blocks but larger than the requested size.
- * \param cur_blocks    Current number of blocks in use, including free and used
- */
-void mbedtls_memory_buffer_alloc_cur_get( size_t *cur_used, size_t *cur_blocks );
-#endif /* MBEDTLS_MEMORY_DEBUG */
-
-/**
- * \brief   Verifies that all headers in the memory buffer are correct
- *          and contain sane values. Helps debug buffer-overflow errors.
- *
- *          Prints out first failure if MBEDTLS_MEMORY_DEBUG is defined.
- *          Prints out full header information if MBEDTLS_MEMORY_DEBUG
- *          is defined. (Includes stack trace information for each block if
- *          MBEDTLS_MEMORY_BACKTRACE is defined as well).
- *
- * \return             0 if verified, 1 otherwise
- */
-int mbedtls_memory_buffer_alloc_verify( void );
-
-#if defined(MBEDTLS_SELF_TEST)
-/**
- * \brief          Checkup routine
- *
- * \return         0 if successful, or 1 if a test failed
- */
-int mbedtls_memory_buffer_alloc_self_test( int verbose );
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* memory_buffer_alloc.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/nist_kw.h b/src/duckdb/third_party/mbedtls/include/mbedtls/nist_kw.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/nist_kw.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/oid.h b/src/duckdb/third_party/mbedtls/include/mbedtls/oid.h
deleted file mode 100644
index 836e455b3..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/oid.h
+++ /dev/null
@@ -1,643 +0,0 @@
-/**
- * \file oid.h
- *
- * \brief Object Identifier (OID) database
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_OID_H
-#define MBEDTLS_OID_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/asn1.h"
-#include "mbedtls/pk.h"
-
-#include <stddef.h>
-
-#if defined(MBEDTLS_CIPHER_C)
-#include "mbedtls/cipher.h"
-#endif
-
-#if defined(MBEDTLS_MD_C)
-#include "mbedtls/md.h"
-#endif
-
-/** OID is not found. */
-#define MBEDTLS_ERR_OID_NOT_FOUND                         -0x002E
-/** output buffer is too small */
-#define MBEDTLS_ERR_OID_BUF_TOO_SMALL                     -0x000B
-
-/* This is for the benefit of X.509, but defined here in order to avoid
- * having a "backwards" include of x.509.h here */
-/*
- * X.509 extension types (internal, arbitrary values for bitsets)
- */
-#define MBEDTLS_OID_X509_EXT_AUTHORITY_KEY_IDENTIFIER    (1 << 0)
-#define MBEDTLS_OID_X509_EXT_SUBJECT_KEY_IDENTIFIER      (1 << 1)
-#define MBEDTLS_OID_X509_EXT_KEY_USAGE                   (1 << 2)
-#define MBEDTLS_OID_X509_EXT_CERTIFICATE_POLICIES        (1 << 3)
-#define MBEDTLS_OID_X509_EXT_POLICY_MAPPINGS             (1 << 4)
-#define MBEDTLS_OID_X509_EXT_SUBJECT_ALT_NAME            (1 << 5)
-#define MBEDTLS_OID_X509_EXT_ISSUER_ALT_NAME             (1 << 6)
-#define MBEDTLS_OID_X509_EXT_SUBJECT_DIRECTORY_ATTRS     (1 << 7)
-#define MBEDTLS_OID_X509_EXT_BASIC_CONSTRAINTS           (1 << 8)
-#define MBEDTLS_OID_X509_EXT_NAME_CONSTRAINTS            (1 << 9)
-#define MBEDTLS_OID_X509_EXT_POLICY_CONSTRAINTS          (1 << 10)
-#define MBEDTLS_OID_X509_EXT_EXTENDED_KEY_USAGE          (1 << 11)
-#define MBEDTLS_OID_X509_EXT_CRL_DISTRIBUTION_POINTS     (1 << 12)
-#define MBEDTLS_OID_X509_EXT_INIHIBIT_ANYPOLICY          (1 << 13)
-#define MBEDTLS_OID_X509_EXT_FRESHEST_CRL                (1 << 14)
-#define MBEDTLS_OID_X509_EXT_NS_CERT_TYPE                (1 << 16)
-
-/*
- * Top level OID tuples
- */
-#define MBEDTLS_OID_ISO_MEMBER_BODIES           "\x2a"          /* {iso(1) member-body(2)} */
-#define MBEDTLS_OID_ISO_IDENTIFIED_ORG          "\x2b"          /* {iso(1) identified-organization(3)} */
-#define MBEDTLS_OID_ISO_CCITT_DS                "\x55"          /* {joint-iso-ccitt(2) ds(5)} */
-#define MBEDTLS_OID_ISO_ITU_COUNTRY             "\x60"          /* {joint-iso-itu-t(2) country(16)} */
-
-/*
- * ISO Member bodies OID parts
- */
-#define MBEDTLS_OID_COUNTRY_US                  "\x86\x48"      /* {us(840)} */
-#define MBEDTLS_OID_ORG_RSA_DATA_SECURITY       "\x86\xf7\x0d"  /* {rsadsi(113549)} */
-#define MBEDTLS_OID_RSA_COMPANY                 MBEDTLS_OID_ISO_MEMBER_BODIES MBEDTLS_OID_COUNTRY_US \
-                                        MBEDTLS_OID_ORG_RSA_DATA_SECURITY /* {iso(1) member-body(2) us(840) rsadsi(113549)} */
-#define MBEDTLS_OID_ORG_ANSI_X9_62              "\xce\x3d" /* ansi-X9-62(10045) */
-#define MBEDTLS_OID_ANSI_X9_62                  MBEDTLS_OID_ISO_MEMBER_BODIES MBEDTLS_OID_COUNTRY_US \
-                                        MBEDTLS_OID_ORG_ANSI_X9_62
-
-/*
- * ISO Identified organization OID parts
- */
-#define MBEDTLS_OID_ORG_DOD                     "\x06"          /* {dod(6)} */
-#define MBEDTLS_OID_ORG_OIW                     "\x0e"
-#define MBEDTLS_OID_OIW_SECSIG                  MBEDTLS_OID_ORG_OIW "\x03"
-#define MBEDTLS_OID_OIW_SECSIG_ALG              MBEDTLS_OID_OIW_SECSIG "\x02"
-#define MBEDTLS_OID_OIW_SECSIG_SHA1             MBEDTLS_OID_OIW_SECSIG_ALG "\x1a"
-#define MBEDTLS_OID_ORG_CERTICOM                "\x81\x04"  /* certicom(132) */
-#define MBEDTLS_OID_CERTICOM                    MBEDTLS_OID_ISO_IDENTIFIED_ORG MBEDTLS_OID_ORG_CERTICOM
-#define MBEDTLS_OID_ORG_TELETRUST               "\x24" /* teletrust(36) */
-#define MBEDTLS_OID_TELETRUST                   MBEDTLS_OID_ISO_IDENTIFIED_ORG MBEDTLS_OID_ORG_TELETRUST
-
-/*
- * ISO ITU OID parts
- */
-#define MBEDTLS_OID_ORGANIZATION                "\x01"          /* {organization(1)} */
-#define MBEDTLS_OID_ISO_ITU_US_ORG              MBEDTLS_OID_ISO_ITU_COUNTRY MBEDTLS_OID_COUNTRY_US MBEDTLS_OID_ORGANIZATION /* {joint-iso-itu-t(2) country(16) us(840) organization(1)} */
-
-#define MBEDTLS_OID_ORG_GOV                     "\x65"          /* {gov(101)} */
-#define MBEDTLS_OID_GOV                         MBEDTLS_OID_ISO_ITU_US_ORG MBEDTLS_OID_ORG_GOV /* {joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101)} */
-
-#define MBEDTLS_OID_ORG_NETSCAPE                "\x86\xF8\x42"  /* {netscape(113730)} */
-#define MBEDTLS_OID_NETSCAPE                    MBEDTLS_OID_ISO_ITU_US_ORG MBEDTLS_OID_ORG_NETSCAPE /* Netscape OID {joint-iso-itu-t(2) country(16) us(840) organization(1) netscape(113730)} */
-
-/* ISO arc for standard certificate and CRL extensions */
-#define MBEDTLS_OID_ID_CE                       MBEDTLS_OID_ISO_CCITT_DS "\x1D" /**< id-ce OBJECT IDENTIFIER  ::=  {joint-iso-ccitt(2) ds(5) 29} */
-
-#define MBEDTLS_OID_NIST_ALG                    MBEDTLS_OID_GOV "\x03\x04" /** { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistAlgorithm(4) */
-
-/**
- * Private Internet Extensions
- * { iso(1) identified-organization(3) dod(6) internet(1)
- *                      security(5) mechanisms(5) pkix(7) }
- */
-#define MBEDTLS_OID_INTERNET                    MBEDTLS_OID_ISO_IDENTIFIED_ORG MBEDTLS_OID_ORG_DOD "\x01"
-#define MBEDTLS_OID_PKIX                        MBEDTLS_OID_INTERNET "\x05\x05\x07"
-
-/*
- * Arc for standard naming attributes
- */
-#define MBEDTLS_OID_AT                          MBEDTLS_OID_ISO_CCITT_DS "\x04" /**< id-at OBJECT IDENTIFIER ::= {joint-iso-ccitt(2) ds(5) 4} */
-#define MBEDTLS_OID_AT_CN                       MBEDTLS_OID_AT "\x03" /**< id-at-commonName AttributeType:= {id-at 3} */
-#define MBEDTLS_OID_AT_SUR_NAME                 MBEDTLS_OID_AT "\x04" /**< id-at-surName AttributeType:= {id-at 4} */
-#define MBEDTLS_OID_AT_SERIAL_NUMBER            MBEDTLS_OID_AT "\x05" /**< id-at-serialNumber AttributeType:= {id-at 5} */
-#define MBEDTLS_OID_AT_COUNTRY                  MBEDTLS_OID_AT "\x06" /**< id-at-countryName AttributeType:= {id-at 6} */
-#define MBEDTLS_OID_AT_LOCALITY                 MBEDTLS_OID_AT "\x07" /**< id-at-locality AttributeType:= {id-at 7} */
-#define MBEDTLS_OID_AT_STATE                    MBEDTLS_OID_AT "\x08" /**< id-at-state AttributeType:= {id-at 8} */
-#define MBEDTLS_OID_AT_ORGANIZATION             MBEDTLS_OID_AT "\x0A" /**< id-at-organizationName AttributeType:= {id-at 10} */
-#define MBEDTLS_OID_AT_ORG_UNIT                 MBEDTLS_OID_AT "\x0B" /**< id-at-organizationalUnitName AttributeType:= {id-at 11} */
-#define MBEDTLS_OID_AT_TITLE                    MBEDTLS_OID_AT "\x0C" /**< id-at-title AttributeType:= {id-at 12} */
-#define MBEDTLS_OID_AT_POSTAL_ADDRESS           MBEDTLS_OID_AT "\x10" /**< id-at-postalAddress AttributeType:= {id-at 16} */
-#define MBEDTLS_OID_AT_POSTAL_CODE              MBEDTLS_OID_AT "\x11" /**< id-at-postalCode AttributeType:= {id-at 17} */
-#define MBEDTLS_OID_AT_GIVEN_NAME               MBEDTLS_OID_AT "\x2A" /**< id-at-givenName AttributeType:= {id-at 42} */
-#define MBEDTLS_OID_AT_INITIALS                 MBEDTLS_OID_AT "\x2B" /**< id-at-initials AttributeType:= {id-at 43} */
-#define MBEDTLS_OID_AT_GENERATION_QUALIFIER     MBEDTLS_OID_AT "\x2C" /**< id-at-generationQualifier AttributeType:= {id-at 44} */
-#define MBEDTLS_OID_AT_UNIQUE_IDENTIFIER        MBEDTLS_OID_AT "\x2D" /**< id-at-uniqueIdentifier AttributType:= {id-at 45} */
-#define MBEDTLS_OID_AT_DN_QUALIFIER             MBEDTLS_OID_AT "\x2E" /**< id-at-dnQualifier AttributeType:= {id-at 46} */
-#define MBEDTLS_OID_AT_PSEUDONYM                MBEDTLS_OID_AT "\x41" /**< id-at-pseudonym AttributeType:= {id-at 65} */
-
-#define MBEDTLS_OID_UID                         "\x09\x92\x26\x89\x93\xF2\x2C\x64\x01\x01" /** id-domainComponent AttributeType:= {itu-t(0) data(9) pss(2342) ucl(19200300) pilot(100) pilotAttributeType(1) uid(1)} */
-#define MBEDTLS_OID_DOMAIN_COMPONENT            "\x09\x92\x26\x89\x93\xF2\x2C\x64\x01\x19" /** id-domainComponent AttributeType:= {itu-t(0) data(9) pss(2342) ucl(19200300) pilot(100) pilotAttributeType(1) domainComponent(25)} */
-
-/*
- * OIDs for standard certificate extensions
- */
-#define MBEDTLS_OID_AUTHORITY_KEY_IDENTIFIER    MBEDTLS_OID_ID_CE "\x23" /**< id-ce-authorityKeyIdentifier OBJECT IDENTIFIER ::=  { id-ce 35 } */
-#define MBEDTLS_OID_SUBJECT_KEY_IDENTIFIER      MBEDTLS_OID_ID_CE "\x0E" /**< id-ce-subjectKeyIdentifier OBJECT IDENTIFIER ::=  { id-ce 14 } */
-#define MBEDTLS_OID_KEY_USAGE                   MBEDTLS_OID_ID_CE "\x0F" /**< id-ce-keyUsage OBJECT IDENTIFIER ::=  { id-ce 15 } */
-#define MBEDTLS_OID_CERTIFICATE_POLICIES        MBEDTLS_OID_ID_CE "\x20" /**< id-ce-certificatePolicies OBJECT IDENTIFIER ::=  { id-ce 32 } */
-#define MBEDTLS_OID_POLICY_MAPPINGS             MBEDTLS_OID_ID_CE "\x21" /**< id-ce-policyMappings OBJECT IDENTIFIER ::=  { id-ce 33 } */
-#define MBEDTLS_OID_SUBJECT_ALT_NAME            MBEDTLS_OID_ID_CE "\x11" /**< id-ce-subjectAltName OBJECT IDENTIFIER ::=  { id-ce 17 } */
-#define MBEDTLS_OID_ISSUER_ALT_NAME             MBEDTLS_OID_ID_CE "\x12" /**< id-ce-issuerAltName OBJECT IDENTIFIER ::=  { id-ce 18 } */
-#define MBEDTLS_OID_SUBJECT_DIRECTORY_ATTRS     MBEDTLS_OID_ID_CE "\x09" /**< id-ce-subjectDirectoryAttributes OBJECT IDENTIFIER ::=  { id-ce 9 } */
-#define MBEDTLS_OID_BASIC_CONSTRAINTS           MBEDTLS_OID_ID_CE "\x13" /**< id-ce-basicConstraints OBJECT IDENTIFIER ::=  { id-ce 19 } */
-#define MBEDTLS_OID_NAME_CONSTRAINTS            MBEDTLS_OID_ID_CE "\x1E" /**< id-ce-nameConstraints OBJECT IDENTIFIER ::=  { id-ce 30 } */
-#define MBEDTLS_OID_POLICY_CONSTRAINTS          MBEDTLS_OID_ID_CE "\x24" /**< id-ce-policyConstraints OBJECT IDENTIFIER ::=  { id-ce 36 } */
-#define MBEDTLS_OID_EXTENDED_KEY_USAGE          MBEDTLS_OID_ID_CE "\x25" /**< id-ce-extKeyUsage OBJECT IDENTIFIER ::= { id-ce 37 } */
-#define MBEDTLS_OID_CRL_DISTRIBUTION_POINTS     MBEDTLS_OID_ID_CE "\x1F" /**< id-ce-cRLDistributionPoints OBJECT IDENTIFIER ::=  { id-ce 31 } */
-#define MBEDTLS_OID_INIHIBIT_ANYPOLICY          MBEDTLS_OID_ID_CE "\x36" /**< id-ce-inhibitAnyPolicy OBJECT IDENTIFIER ::=  { id-ce 54 } */
-#define MBEDTLS_OID_FRESHEST_CRL                MBEDTLS_OID_ID_CE "\x2E" /**< id-ce-freshestCRL OBJECT IDENTIFIER ::=  { id-ce 46 } */
-
-/*
- * Certificate policies
- */
-#define MBEDTLS_OID_ANY_POLICY              MBEDTLS_OID_CERTIFICATE_POLICIES "\x00" /**< anyPolicy OBJECT IDENTIFIER ::= { id-ce-certificatePolicies 0 } */
-
-/*
- * Netscape certificate extensions
- */
-#define MBEDTLS_OID_NS_CERT                 MBEDTLS_OID_NETSCAPE "\x01"
-#define MBEDTLS_OID_NS_CERT_TYPE            MBEDTLS_OID_NS_CERT  "\x01"
-#define MBEDTLS_OID_NS_BASE_URL             MBEDTLS_OID_NS_CERT  "\x02"
-#define MBEDTLS_OID_NS_REVOCATION_URL       MBEDTLS_OID_NS_CERT  "\x03"
-#define MBEDTLS_OID_NS_CA_REVOCATION_URL    MBEDTLS_OID_NS_CERT  "\x04"
-#define MBEDTLS_OID_NS_RENEWAL_URL          MBEDTLS_OID_NS_CERT  "\x07"
-#define MBEDTLS_OID_NS_CA_POLICY_URL        MBEDTLS_OID_NS_CERT  "\x08"
-#define MBEDTLS_OID_NS_SSL_SERVER_NAME      MBEDTLS_OID_NS_CERT  "\x0C"
-#define MBEDTLS_OID_NS_COMMENT              MBEDTLS_OID_NS_CERT  "\x0D"
-#define MBEDTLS_OID_NS_DATA_TYPE            MBEDTLS_OID_NETSCAPE "\x02"
-#define MBEDTLS_OID_NS_CERT_SEQUENCE        MBEDTLS_OID_NS_DATA_TYPE "\x05"
-
-/*
- * OIDs for CRL extensions
- */
-#define MBEDTLS_OID_PRIVATE_KEY_USAGE_PERIOD    MBEDTLS_OID_ID_CE "\x10"
-#define MBEDTLS_OID_CRL_NUMBER                  MBEDTLS_OID_ID_CE "\x14" /**< id-ce-cRLNumber OBJECT IDENTIFIER ::= { id-ce 20 } */
-
-/*
- * X.509 v3 Extended key usage OIDs
- */
-#define MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE      MBEDTLS_OID_EXTENDED_KEY_USAGE "\x00" /**< anyExtendedKeyUsage OBJECT IDENTIFIER ::= { id-ce-extKeyUsage 0 } */
-
-#define MBEDTLS_OID_KP                          MBEDTLS_OID_PKIX "\x03" /**< id-kp OBJECT IDENTIFIER ::= { id-pkix 3 } */
-#define MBEDTLS_OID_SERVER_AUTH                 MBEDTLS_OID_KP "\x01" /**< id-kp-serverAuth OBJECT IDENTIFIER ::= { id-kp 1 } */
-#define MBEDTLS_OID_CLIENT_AUTH                 MBEDTLS_OID_KP "\x02" /**< id-kp-clientAuth OBJECT IDENTIFIER ::= { id-kp 2 } */
-#define MBEDTLS_OID_CODE_SIGNING                MBEDTLS_OID_KP "\x03" /**< id-kp-codeSigning OBJECT IDENTIFIER ::= { id-kp 3 } */
-#define MBEDTLS_OID_EMAIL_PROTECTION            MBEDTLS_OID_KP "\x04" /**< id-kp-emailProtection OBJECT IDENTIFIER ::= { id-kp 4 } */
-#define MBEDTLS_OID_TIME_STAMPING               MBEDTLS_OID_KP "\x08" /**< id-kp-timeStamping OBJECT IDENTIFIER ::= { id-kp 8 } */
-#define MBEDTLS_OID_OCSP_SIGNING                MBEDTLS_OID_KP "\x09" /**< id-kp-OCSPSigning OBJECT IDENTIFIER ::= { id-kp 9 } */
-
-/**
- * Wi-SUN Alliance Field Area Network
- * { iso(1) identified-organization(3) dod(6) internet(1)
- *                      private(4) enterprise(1) WiSUN(45605) FieldAreaNetwork(1) }
- */
-#define MBEDTLS_OID_WISUN_FAN                   MBEDTLS_OID_INTERNET "\x04\x01\x82\xe4\x25\x01"
-
-#define MBEDTLS_OID_ON                          MBEDTLS_OID_PKIX "\x08" /**< id-on OBJECT IDENTIFIER ::= { id-pkix 8 } */
-#define MBEDTLS_OID_ON_HW_MODULE_NAME           MBEDTLS_OID_ON "\x04" /**< id-on-hardwareModuleName OBJECT IDENTIFIER ::= { id-on 4 } */
-
-/*
- * PKCS definition OIDs
- */
-
-#define MBEDTLS_OID_PKCS                MBEDTLS_OID_RSA_COMPANY "\x01" /**< pkcs OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) 1 } */
-#define MBEDTLS_OID_PKCS1               MBEDTLS_OID_PKCS "\x01" /**< pkcs-1 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 1 } */
-#define MBEDTLS_OID_PKCS5               MBEDTLS_OID_PKCS "\x05" /**< pkcs-5 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 5 } */
-#define MBEDTLS_OID_PKCS9               MBEDTLS_OID_PKCS "\x09" /**< pkcs-9 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 9 } */
-#define MBEDTLS_OID_PKCS12              MBEDTLS_OID_PKCS "\x0c" /**< pkcs-12 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 12 } */
-
-/*
- * PKCS#1 OIDs
- */
-#define MBEDTLS_OID_PKCS1_RSA           MBEDTLS_OID_PKCS1 "\x01" /**< rsaEncryption OBJECT IDENTIFIER ::= { pkcs-1 1 } */
-#define MBEDTLS_OID_PKCS1_MD5           MBEDTLS_OID_PKCS1 "\x04" /**< md5WithRSAEncryption ::= { pkcs-1 4 } */
-#define MBEDTLS_OID_PKCS1_SHA1          MBEDTLS_OID_PKCS1 "\x05" /**< sha1WithRSAEncryption ::= { pkcs-1 5 } */
-#define MBEDTLS_OID_PKCS1_SHA224        MBEDTLS_OID_PKCS1 "\x0e" /**< sha224WithRSAEncryption ::= { pkcs-1 14 } */
-#define MBEDTLS_OID_PKCS1_SHA256        MBEDTLS_OID_PKCS1 "\x0b" /**< sha256WithRSAEncryption ::= { pkcs-1 11 } */
-#define MBEDTLS_OID_PKCS1_SHA384        MBEDTLS_OID_PKCS1 "\x0c" /**< sha384WithRSAEncryption ::= { pkcs-1 12 } */
-#define MBEDTLS_OID_PKCS1_SHA512        MBEDTLS_OID_PKCS1 "\x0d" /**< sha512WithRSAEncryption ::= { pkcs-1 13 } */
-
-#define MBEDTLS_OID_RSA_SHA_OBS         "\x2B\x0E\x03\x02\x1D"
-
-#define MBEDTLS_OID_PKCS9_EMAIL         MBEDTLS_OID_PKCS9 "\x01" /**< emailAddress AttributeType ::= { pkcs-9 1 } */
-
-/* RFC 4055 */
-#define MBEDTLS_OID_RSASSA_PSS          MBEDTLS_OID_PKCS1 "\x0a" /**< id-RSASSA-PSS ::= { pkcs-1 10 } */
-#define MBEDTLS_OID_MGF1                MBEDTLS_OID_PKCS1 "\x08" /**< id-mgf1 ::= { pkcs-1 8 } */
-
-/*
- * Digest algorithms
- */
-#define MBEDTLS_OID_DIGEST_ALG_MD5              MBEDTLS_OID_RSA_COMPANY "\x02\x05" /**< id-mbedtls_md5 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 5 } */
-#define MBEDTLS_OID_DIGEST_ALG_SHA1             MBEDTLS_OID_ISO_IDENTIFIED_ORG MBEDTLS_OID_OIW_SECSIG_SHA1 /**< id-mbedtls_sha1 OBJECT IDENTIFIER ::= { iso(1) identified-organization(3) oiw(14) secsig(3) algorithms(2) 26 } */
-#define MBEDTLS_OID_DIGEST_ALG_SHA224           MBEDTLS_OID_NIST_ALG "\x02\x04" /**< id-sha224 OBJECT IDENTIFIER ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistalgorithm(4) hashalgs(2) 4 } */
-#define MBEDTLS_OID_DIGEST_ALG_SHA256           MBEDTLS_OID_NIST_ALG "\x02\x01" /**< id-mbedtls_sha256 OBJECT IDENTIFIER ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistalgorithm(4) hashalgs(2) 1 } */
-
-#define MBEDTLS_OID_DIGEST_ALG_SHA384           MBEDTLS_OID_NIST_ALG "\x02\x02" /**< id-sha384 OBJECT IDENTIFIER ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistalgorithm(4) hashalgs(2) 2 } */
-
-#define MBEDTLS_OID_DIGEST_ALG_SHA512           MBEDTLS_OID_NIST_ALG "\x02\x03" /**< id-mbedtls_sha512 OBJECT IDENTIFIER ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistalgorithm(4) hashalgs(2) 3 } */
-
-#define MBEDTLS_OID_DIGEST_ALG_RIPEMD160        MBEDTLS_OID_TELETRUST "\x03\x02\x01" /**< id-ripemd160 OBJECT IDENTIFIER :: { iso(1) identified-organization(3) teletrust(36) algorithm(3) hashAlgorithm(2) ripemd160(1) } */
-
-#define MBEDTLS_OID_HMAC_SHA1                   MBEDTLS_OID_RSA_COMPANY "\x02\x07" /**< id-hmacWithSHA1 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 7 } */
-
-#define MBEDTLS_OID_HMAC_SHA224                 MBEDTLS_OID_RSA_COMPANY "\x02\x08" /**< id-hmacWithSHA224 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 8 } */
-
-#define MBEDTLS_OID_HMAC_SHA256                 MBEDTLS_OID_RSA_COMPANY "\x02\x09" /**< id-hmacWithSHA256 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 9 } */
-
-#define MBEDTLS_OID_HMAC_SHA384                 MBEDTLS_OID_RSA_COMPANY "\x02\x0A" /**< id-hmacWithSHA384 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 10 } */
-
-#define MBEDTLS_OID_HMAC_SHA512                 MBEDTLS_OID_RSA_COMPANY "\x02\x0B" /**< id-hmacWithSHA512 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840) rsadsi(113549) digestAlgorithm(2) 11 } */
-
-/*
- * Encryption algorithms
- */
-#define MBEDTLS_OID_DES_CBC                     MBEDTLS_OID_ISO_IDENTIFIED_ORG MBEDTLS_OID_OIW_SECSIG_ALG "\x07" /**< desCBC OBJECT IDENTIFIER ::= { iso(1) identified-organization(3) oiw(14) secsig(3) algorithms(2) 7 } */
-#define MBEDTLS_OID_DES_EDE3_CBC                MBEDTLS_OID_RSA_COMPANY "\x03\x07" /**< des-ede3-cbc OBJECT IDENTIFIER ::= { iso(1) member-body(2) -- us(840) rsadsi(113549) encryptionAlgorithm(3) 7 } */
-#define MBEDTLS_OID_AES                         MBEDTLS_OID_NIST_ALG "\x01" /** aes OBJECT IDENTIFIER ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistAlgorithm(4) 1 } */
-
-/*
- * Key Wrapping algorithms
- */
-/*
- * RFC 5649
- */
-#define MBEDTLS_OID_AES128_KW                   MBEDTLS_OID_AES "\x05" /** id-aes128-wrap     OBJECT IDENTIFIER ::= { aes 5 } */
-#define MBEDTLS_OID_AES128_KWP                  MBEDTLS_OID_AES "\x08" /** id-aes128-wrap-pad OBJECT IDENTIFIER ::= { aes 8 } */
-#define MBEDTLS_OID_AES192_KW                   MBEDTLS_OID_AES "\x19" /** id-aes192-wrap     OBJECT IDENTIFIER ::= { aes 25 } */
-#define MBEDTLS_OID_AES192_KWP                  MBEDTLS_OID_AES "\x1c" /** id-aes192-wrap-pad OBJECT IDENTIFIER ::= { aes 28 } */
-#define MBEDTLS_OID_AES256_KW                   MBEDTLS_OID_AES "\x2d" /** id-aes256-wrap     OBJECT IDENTIFIER ::= { aes 45 } */
-#define MBEDTLS_OID_AES256_KWP                  MBEDTLS_OID_AES "\x30" /** id-aes256-wrap-pad OBJECT IDENTIFIER ::= { aes 48 } */
-/*
- * PKCS#5 OIDs
- */
-#define MBEDTLS_OID_PKCS5_PBKDF2                MBEDTLS_OID_PKCS5 "\x0c" /**< id-PBKDF2 OBJECT IDENTIFIER ::= {pkcs-5 12} */
-#define MBEDTLS_OID_PKCS5_PBES2                 MBEDTLS_OID_PKCS5 "\x0d" /**< id-PBES2 OBJECT IDENTIFIER ::= {pkcs-5 13} */
-#define MBEDTLS_OID_PKCS5_PBMAC1                MBEDTLS_OID_PKCS5 "\x0e" /**< id-PBMAC1 OBJECT IDENTIFIER ::= {pkcs-5 14} */
-
-/*
- * PKCS#5 PBES1 algorithms
- */
-#define MBEDTLS_OID_PKCS5_PBE_MD5_DES_CBC       MBEDTLS_OID_PKCS5 "\x03" /**< pbeWithMD5AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 3} */
-#define MBEDTLS_OID_PKCS5_PBE_MD5_RC2_CBC       MBEDTLS_OID_PKCS5 "\x06" /**< pbeWithMD5AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 6} */
-#define MBEDTLS_OID_PKCS5_PBE_SHA1_DES_CBC      MBEDTLS_OID_PKCS5 "\x0a" /**< pbeWithSHA1AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 10} */
-#define MBEDTLS_OID_PKCS5_PBE_SHA1_RC2_CBC      MBEDTLS_OID_PKCS5 "\x0b" /**< pbeWithSHA1AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 11} */
-
-/*
- * PKCS#8 OIDs
- */
-#define MBEDTLS_OID_PKCS9_CSR_EXT_REQ           MBEDTLS_OID_PKCS9 "\x0e" /**< extensionRequest OBJECT IDENTIFIER ::= {pkcs-9 14} */
-
-/*
- * PKCS#12 PBE OIDs
- */
-#define MBEDTLS_OID_PKCS12_PBE                      MBEDTLS_OID_PKCS12 "\x01" /**< pkcs-12PbeIds OBJECT IDENTIFIER ::= {pkcs-12 1} */
-
-#define MBEDTLS_OID_PKCS12_PBE_SHA1_DES3_EDE_CBC    MBEDTLS_OID_PKCS12_PBE "\x03" /**< pbeWithSHAAnd3-KeyTripleDES-CBC OBJECT IDENTIFIER ::= {pkcs-12PbeIds 3} */
-#define MBEDTLS_OID_PKCS12_PBE_SHA1_DES2_EDE_CBC    MBEDTLS_OID_PKCS12_PBE "\x04" /**< pbeWithSHAAnd2-KeyTripleDES-CBC OBJECT IDENTIFIER ::= {pkcs-12PbeIds 4} */
-#define MBEDTLS_OID_PKCS12_PBE_SHA1_RC2_128_CBC     MBEDTLS_OID_PKCS12_PBE "\x05" /**< pbeWithSHAAnd128BitRC2-CBC OBJECT IDENTIFIER ::= {pkcs-12PbeIds 5} */
-#define MBEDTLS_OID_PKCS12_PBE_SHA1_RC2_40_CBC      MBEDTLS_OID_PKCS12_PBE "\x06" /**< pbeWithSHAAnd40BitRC2-CBC OBJECT IDENTIFIER ::= {pkcs-12PbeIds 6} */
-
-/*
- * EC key algorithms from RFC 5480
- */
-
-/* id-ecPublicKey OBJECT IDENTIFIER ::= {
- *       iso(1) member-body(2) us(840) ansi-X9-62(10045) keyType(2) 1 } */
-#define MBEDTLS_OID_EC_ALG_UNRESTRICTED         MBEDTLS_OID_ANSI_X9_62 "\x02\01"
-
-/*   id-ecDH OBJECT IDENTIFIER ::= {
- *     iso(1) identified-organization(3) certicom(132)
- *     schemes(1) ecdh(12) } */
-#define MBEDTLS_OID_EC_ALG_ECDH                 MBEDTLS_OID_CERTICOM "\x01\x0c"
-
-/*
- * ECParameters namedCurve identifiers, from RFC 5480, RFC 5639, and SEC2
- */
-
-/* secp192r1 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3) prime(1) 1 } */
-#define MBEDTLS_OID_EC_GRP_SECP192R1        MBEDTLS_OID_ANSI_X9_62 "\x03\x01\x01"
-
-/* secp224r1 OBJECT IDENTIFIER ::= {
- *   iso(1) identified-organization(3) certicom(132) curve(0) 33 } */
-#define MBEDTLS_OID_EC_GRP_SECP224R1        MBEDTLS_OID_CERTICOM "\x00\x21"
-
-/* secp256r1 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3) prime(1) 7 } */
-#define MBEDTLS_OID_EC_GRP_SECP256R1        MBEDTLS_OID_ANSI_X9_62 "\x03\x01\x07"
-
-/* secp384r1 OBJECT IDENTIFIER ::= {
- *   iso(1) identified-organization(3) certicom(132) curve(0) 34 } */
-#define MBEDTLS_OID_EC_GRP_SECP384R1        MBEDTLS_OID_CERTICOM "\x00\x22"
-
-/* secp521r1 OBJECT IDENTIFIER ::= {
- *   iso(1) identified-organization(3) certicom(132) curve(0) 35 } */
-#define MBEDTLS_OID_EC_GRP_SECP521R1        MBEDTLS_OID_CERTICOM "\x00\x23"
-
-/* secp192k1 OBJECT IDENTIFIER ::= {
- *   iso(1) identified-organization(3) certicom(132) curve(0) 31 } */
-#define MBEDTLS_OID_EC_GRP_SECP192K1        MBEDTLS_OID_CERTICOM "\x00\x1f"
-
-/* secp224k1 OBJECT IDENTIFIER ::= {
- *   iso(1) identified-organization(3) certicom(132) curve(0) 32 } */
-#define MBEDTLS_OID_EC_GRP_SECP224K1        MBEDTLS_OID_CERTICOM "\x00\x20"
-
-/* secp256k1 OBJECT IDENTIFIER ::= {
- *   iso(1) identified-organization(3) certicom(132) curve(0) 10 } */
-#define MBEDTLS_OID_EC_GRP_SECP256K1        MBEDTLS_OID_CERTICOM "\x00\x0a"
-
-/* RFC 5639 4.1
- * ecStdCurvesAndGeneration OBJECT IDENTIFIER::= {iso(1)
- * identified-organization(3) teletrust(36) algorithm(3) signature-
- * algorithm(3) ecSign(2) 8}
- * ellipticCurve OBJECT IDENTIFIER ::= {ecStdCurvesAndGeneration 1}
- * versionOne OBJECT IDENTIFIER ::= {ellipticCurve 1} */
-#define MBEDTLS_OID_EC_BRAINPOOL_V1         MBEDTLS_OID_TELETRUST "\x03\x03\x02\x08\x01\x01"
-
-/* brainpoolP256r1 OBJECT IDENTIFIER ::= {versionOne 7} */
-#define MBEDTLS_OID_EC_GRP_BP256R1          MBEDTLS_OID_EC_BRAINPOOL_V1 "\x07"
-
-/* brainpoolP384r1 OBJECT IDENTIFIER ::= {versionOne 11} */
-#define MBEDTLS_OID_EC_GRP_BP384R1          MBEDTLS_OID_EC_BRAINPOOL_V1 "\x0B"
-
-/* brainpoolP512r1 OBJECT IDENTIFIER ::= {versionOne 13} */
-#define MBEDTLS_OID_EC_GRP_BP512R1          MBEDTLS_OID_EC_BRAINPOOL_V1 "\x0D"
-
-/*
- * SEC1 C.1
- *
- * prime-field OBJECT IDENTIFIER ::= { id-fieldType 1 }
- * id-fieldType OBJECT IDENTIFIER ::= { ansi-X9-62 fieldType(1)}
- */
-#define MBEDTLS_OID_ANSI_X9_62_FIELD_TYPE   MBEDTLS_OID_ANSI_X9_62 "\x01"
-#define MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD  MBEDTLS_OID_ANSI_X9_62_FIELD_TYPE "\x01"
-
-/*
- * ECDSA signature identifiers, from RFC 5480
- */
-#define MBEDTLS_OID_ANSI_X9_62_SIG          MBEDTLS_OID_ANSI_X9_62 "\x04" /* signatures(4) */
-#define MBEDTLS_OID_ANSI_X9_62_SIG_SHA2     MBEDTLS_OID_ANSI_X9_62_SIG "\x03" /* ecdsa-with-SHA2(3) */
-
-/* ecdsa-with-SHA1 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) 1 } */
-#define MBEDTLS_OID_ECDSA_SHA1              MBEDTLS_OID_ANSI_X9_62_SIG "\x01"
-
-/* ecdsa-with-SHA224 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
- *   ecdsa-with-SHA2(3) 1 } */
-#define MBEDTLS_OID_ECDSA_SHA224            MBEDTLS_OID_ANSI_X9_62_SIG_SHA2 "\x01"
-
-/* ecdsa-with-SHA256 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
- *   ecdsa-with-SHA2(3) 2 } */
-#define MBEDTLS_OID_ECDSA_SHA256            MBEDTLS_OID_ANSI_X9_62_SIG_SHA2 "\x02"
-
-/* ecdsa-with-SHA384 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
- *   ecdsa-with-SHA2(3) 3 } */
-#define MBEDTLS_OID_ECDSA_SHA384            MBEDTLS_OID_ANSI_X9_62_SIG_SHA2 "\x03"
-
-/* ecdsa-with-SHA512 OBJECT IDENTIFIER ::= {
- *   iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
- *   ecdsa-with-SHA2(3) 4 } */
-#define MBEDTLS_OID_ECDSA_SHA512            MBEDTLS_OID_ANSI_X9_62_SIG_SHA2 "\x04"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief Base OID descriptor structure
- */
-typedef struct mbedtls_oid_descriptor_t
-{
-    const char *MBEDTLS_PRIVATE(asn1);               /*!< OID ASN.1 representation       */
-    size_t MBEDTLS_PRIVATE(asn1_len);                /*!< length of asn1                 */
-#if !defined(MBEDTLS_X509_REMOVE_INFO)
-    const char *MBEDTLS_PRIVATE(name);               /*!< official name (e.g. from RFC)  */
-    const char *MBEDTLS_PRIVATE(description);        /*!< human friendly description     */
-#endif
-} mbedtls_oid_descriptor_t;
-
-/**
- * \brief           Translate an ASN.1 OID into its numeric representation
- *                  (e.g. "\x2A\x86\x48\x86\xF7\x0D" into "1.2.840.113549")
- *
- * \param buf       buffer to put representation in
- * \param size      size of the buffer
- * \param oid       OID to translate
- *
- * \return          Length of the string written (excluding final NULL) or
- *                  MBEDTLS_ERR_OID_BUF_TOO_SMALL in case of error
- */
-int mbedtls_oid_get_numeric_string( char *buf, size_t size, const mbedtls_asn1_buf *oid );
-
-/**
- * \brief          Translate an X.509 extension OID into local values
- *
- * \param oid      OID to use
- * \param ext_type place to store the extension type
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_x509_ext_type( const mbedtls_asn1_buf *oid, int *ext_type );
-
-/**
- * \brief          Translate an X.509 attribute type OID into the short name
- *                 (e.g. the OID for an X520 Common Name into "CN")
- *
- * \param oid      OID to use
- * \param short_name    place to store the string pointer
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_attr_short_name( const mbedtls_asn1_buf *oid, const char **short_name );
-
-/**
- * \brief          Translate PublicKeyAlgorithm OID into pk_type
- *
- * \param oid      OID to use
- * \param pk_alg   place to store public key algorithm
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_pk_alg( const mbedtls_asn1_buf *oid, mbedtls_pk_type_t *pk_alg );
-
-/**
- * \brief          Translate pk_type into PublicKeyAlgorithm OID
- *
- * \param pk_alg   Public key type to look for
- * \param oid      place to store ASN.1 OID string pointer
- * \param olen     length of the OID
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_oid_by_pk_alg( mbedtls_pk_type_t pk_alg,
-                           const char **oid, size_t *olen );
-
-#if defined(MBEDTLS_ECP_C)
-/**
- * \brief          Translate NamedCurve OID into an EC group identifier
- *
- * \param oid      OID to use
- * \param grp_id   place to store group id
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_ec_grp( const mbedtls_asn1_buf *oid, mbedtls_ecp_group_id *grp_id );
-
-/**
- * \brief          Translate EC group identifier into NamedCurve OID
- *
- * \param grp_id   EC group identifier
- * \param oid      place to store ASN.1 OID string pointer
- * \param olen     length of the OID
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_oid_by_ec_grp( mbedtls_ecp_group_id grp_id,
-                           const char **oid, size_t *olen );
-#endif /* MBEDTLS_ECP_C */
-
-#if defined(MBEDTLS_MD_C)
-/**
- * \brief          Translate SignatureAlgorithm OID into md_type and pk_type
- *
- * \param oid      OID to use
- * \param md_alg   place to store message digest algorithm
- * \param pk_alg   place to store public key algorithm
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_sig_alg( const mbedtls_asn1_buf *oid,
-                     mbedtls_md_type_t *md_alg, mbedtls_pk_type_t *pk_alg );
-
-/**
- * \brief          Translate SignatureAlgorithm OID into description
- *
- * \param oid      OID to use
- * \param desc     place to store string pointer
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_sig_alg_desc( const mbedtls_asn1_buf *oid, const char **desc );
-
-/**
- * \brief          Translate md_type and pk_type into SignatureAlgorithm OID
- *
- * \param md_alg   message digest algorithm
- * \param pk_alg   public key algorithm
- * \param oid      place to store ASN.1 OID string pointer
- * \param olen     length of the OID
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_oid_by_sig_alg( mbedtls_pk_type_t pk_alg, mbedtls_md_type_t md_alg,
-                            const char **oid, size_t *olen );
-
-/**
- * \brief          Translate hash algorithm OID into md_type
- *
- * \param oid      OID to use
- * \param md_alg   place to store message digest algorithm
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_md_alg( const mbedtls_asn1_buf *oid, mbedtls_md_type_t *md_alg );
-
-/**
- * \brief          Translate hmac algorithm OID into md_type
- *
- * \param oid      OID to use
- * \param md_hmac  place to store message hmac algorithm
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_md_hmac( const mbedtls_asn1_buf *oid, mbedtls_md_type_t *md_hmac );
-#endif /* MBEDTLS_MD_C */
-
-#if !defined(MBEDTLS_X509_REMOVE_INFO)
-/**
- * \brief          Translate Extended Key Usage OID into description
- *
- * \param oid      OID to use
- * \param desc     place to store string pointer
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_extended_key_usage( const mbedtls_asn1_buf *oid, const char **desc );
-#endif
-
-/**
- * \brief          Translate certificate policies OID into description
- *
- * \param oid      OID to use
- * \param desc     place to store string pointer
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_certificate_policies( const mbedtls_asn1_buf *oid, const char **desc );
-
-/**
- * \brief          Translate md_type into hash algorithm OID
- *
- * \param md_alg   message digest algorithm
- * \param oid      place to store ASN.1 OID string pointer
- * \param olen     length of the OID
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_oid_by_md( mbedtls_md_type_t md_alg, const char **oid, size_t *olen );
-
-#if defined(MBEDTLS_CIPHER_C)
-/**
- * \brief          Translate encryption algorithm OID into cipher_type
- *
- * \param oid           OID to use
- * \param cipher_alg    place to store cipher algorithm
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_cipher_alg( const mbedtls_asn1_buf *oid, mbedtls_cipher_type_t *cipher_alg );
-#endif /* MBEDTLS_CIPHER_C */
-
-#if defined(MBEDTLS_PKCS12_C)
-/**
- * \brief          Translate PKCS#12 PBE algorithm OID into md_type and
- *                 cipher_type
- *
- * \param oid           OID to use
- * \param md_alg        place to store message digest algorithm
- * \param cipher_alg    place to store cipher algorithm
- *
- * \return         0 if successful, or MBEDTLS_ERR_OID_NOT_FOUND
- */
-int mbedtls_oid_get_pkcs12_pbe_alg( const mbedtls_asn1_buf *oid, mbedtls_md_type_t *md_alg,
-                            mbedtls_cipher_type_t *cipher_alg );
-#endif /* MBEDTLS_PKCS12_C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* oid.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/pem.h b/src/duckdb/third_party/mbedtls/include/mbedtls/pem.h
deleted file mode 100644
index baceb0762..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/pem.h
+++ /dev/null
@@ -1,150 +0,0 @@
-/**
- * \file pem.h
- *
- * \brief Privacy Enhanced Mail (PEM) decoding
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_PEM_H
-#define MBEDTLS_PEM_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-/**
- * \name PEM Error codes
- * These error codes are returned in case of errors reading the
- * PEM data.
- * \{
- */
-/** No PEM header or footer found. */
-#define MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT          -0x1080
-/** PEM string is not as expected. */
-#define MBEDTLS_ERR_PEM_INVALID_DATA                      -0x1100
-/** Failed to allocate memory. */
-#define MBEDTLS_ERR_PEM_ALLOC_FAILED                      -0x1180
-/** RSA IV is not in hex-format. */
-#define MBEDTLS_ERR_PEM_INVALID_ENC_IV                    -0x1200
-/** Unsupported key encryption algorithm. */
-#define MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG                   -0x1280
-/** Private key password can't be empty. */
-#define MBEDTLS_ERR_PEM_PASSWORD_REQUIRED                 -0x1300
-/** Given private key password does not allow for correct decryption. */
-#define MBEDTLS_ERR_PEM_PASSWORD_MISMATCH                 -0x1380
-/** Unavailable feature, e.g. hashing/encryption combination. */
-#define MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE               -0x1400
-/** Bad input parameters to function. */
-#define MBEDTLS_ERR_PEM_BAD_INPUT_DATA                    -0x1480
-/* \} name */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(MBEDTLS_PEM_PARSE_C)
-/**
- * \brief       PEM context structure
- */
-typedef struct mbedtls_pem_context
-{
-    unsigned char *MBEDTLS_PRIVATE(buf);     /*!< buffer for decoded data             */
-    size_t MBEDTLS_PRIVATE(buflen);          /*!< length of the buffer                */
-    unsigned char *MBEDTLS_PRIVATE(info);    /*!< buffer for extra header information */
-}
-mbedtls_pem_context;
-
-/**
- * \brief       PEM context setup
- *
- * \param ctx   context to be initialized
- */
-void mbedtls_pem_init( mbedtls_pem_context *ctx );
-
-/**
- * \brief       Read a buffer for PEM information and store the resulting
- *              data into the specified context buffers.
- *
- * \param ctx       context to use
- * \param header    header string to seek and expect
- * \param footer    footer string to seek and expect
- * \param data      source data to look in (must be nul-terminated)
- * \param pwd       password for decryption (can be NULL)
- * \param pwdlen    length of password
- * \param use_len   destination for total length used (set after header is
- *                  correctly read, so unless you get
- *                  MBEDTLS_ERR_PEM_BAD_INPUT_DATA or
- *                  MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT, use_len is
- *                  the length to skip)
- *
- * \note            Attempts to check password correctness by verifying if
- *                  the decrypted text starts with an ASN.1 sequence of
- *                  appropriate length
- *
- * \return          0 on success, or a specific PEM error code
- */
-int mbedtls_pem_read_buffer( mbedtls_pem_context *ctx, const char *header, const char *footer,
-                     const unsigned char *data,
-                     const unsigned char *pwd,
-                     size_t pwdlen, size_t *use_len );
-
-/**
- * \brief       PEM context memory freeing
- *
- * \param ctx   context to be freed
- */
-void mbedtls_pem_free( mbedtls_pem_context *ctx );
-#endif /* MBEDTLS_PEM_PARSE_C */
-
-#if defined(MBEDTLS_PEM_WRITE_C)
-/**
- * \brief           Write a buffer of PEM information from a DER encoded
- *                  buffer.
- *
- * \param header    The header string to write.
- * \param footer    The footer string to write.
- * \param der_data  The DER data to encode.
- * \param der_len   The length of the DER data \p der_data in Bytes.
- * \param buf       The buffer to write to.
- * \param buf_len   The length of the output buffer \p buf in Bytes.
- * \param olen      The address at which to store the total length written
- *                  or required (if \p buf_len is not enough).
- *
- * \note            You may pass \c NULL for \p buf and \c 0 for \p buf_len
- *                  to request the length of the resulting PEM buffer in
- *                  `*olen`.
- *
- * \note            This function may be called with overlapping \p der_data
- *                  and \p buf buffers.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL if \p buf isn't large
- *                  enough to hold the PEM buffer. In  this case, `*olen` holds
- *                  the required minimum size of \p buf.
- * \return          Another PEM or BASE64 error code on other kinds of failure.
- */
-int mbedtls_pem_write_buffer( const char *header, const char *footer,
-                      const unsigned char *der_data, size_t der_len,
-                      unsigned char *buf, size_t buf_len, size_t *olen );
-#endif /* MBEDTLS_PEM_WRITE_C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* pem.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/pk.h b/src/duckdb/third_party/mbedtls/include/mbedtls/pk.h
deleted file mode 100644
index 33c83f5e3..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/pk.h
+++ /dev/null
@@ -1,909 +0,0 @@
-/**
- * \file pk.h
- *
- * \brief Public Key abstraction layer
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_PK_H
-#define MBEDTLS_PK_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/md.h"
-
-#if defined(MBEDTLS_RSA_C)
-#include "mbedtls/rsa.h"
-#endif
-
-#if defined(MBEDTLS_ECP_C)
-#include "mbedtls/ecp.h"
-#endif
-
-#if defined(MBEDTLS_ECDSA_C)
-#include "mbedtls/ecdsa.h"
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#include "psa/crypto.h"
-#endif
-
-#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
-    !defined(inline) && !defined(__cplusplus)
-#define inline __inline
-#endif
-
-/** Memory allocation failed. */
-#define MBEDTLS_ERR_PK_ALLOC_FAILED        -0x3F80
-/** Type mismatch, eg attempt to encrypt with an ECDSA key */
-#define MBEDTLS_ERR_PK_TYPE_MISMATCH       -0x3F00
-/** Bad input parameters to function. */
-#define MBEDTLS_ERR_PK_BAD_INPUT_DATA      -0x3E80
-/** Read/write of file failed. */
-#define MBEDTLS_ERR_PK_FILE_IO_ERROR       -0x3E00
-/** Unsupported key version */
-#define MBEDTLS_ERR_PK_KEY_INVALID_VERSION -0x3D80
-/** Invalid key tag or value. */
-#define MBEDTLS_ERR_PK_KEY_INVALID_FORMAT  -0x3D00
-/** Key algorithm is unsupported (only RSA and EC are supported). */
-#define MBEDTLS_ERR_PK_UNKNOWN_PK_ALG      -0x3C80
-/** Private key password can't be empty. */
-#define MBEDTLS_ERR_PK_PASSWORD_REQUIRED   -0x3C00
-/** Given private key password does not allow for correct decryption. */
-#define MBEDTLS_ERR_PK_PASSWORD_MISMATCH   -0x3B80
-/** The pubkey tag or value is invalid (only RSA and EC are supported). */
-#define MBEDTLS_ERR_PK_INVALID_PUBKEY      -0x3B00
-/** The algorithm tag or value is invalid. */
-#define MBEDTLS_ERR_PK_INVALID_ALG         -0x3A80
-/** Elliptic curve is unsupported (only NIST curves are supported). */
-#define MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE -0x3A00
-/** Unavailable feature, e.g. RSA disabled for RSA key. */
-#define MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE -0x3980
-/** The buffer contains a valid signature followed by more data. */
-#define MBEDTLS_ERR_PK_SIG_LEN_MISMATCH    -0x3900
-/** The output buffer is too small. */
-#define MBEDTLS_ERR_PK_BUFFER_TOO_SMALL    -0x3880
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief          Public key types
- */
-typedef enum {
-    MBEDTLS_PK_NONE=0,
-    MBEDTLS_PK_RSA,
-    MBEDTLS_PK_ECKEY,
-    MBEDTLS_PK_ECKEY_DH,
-    MBEDTLS_PK_ECDSA,
-    MBEDTLS_PK_RSA_ALT,
-    MBEDTLS_PK_RSASSA_PSS,
-    MBEDTLS_PK_OPAQUE,
-} mbedtls_pk_type_t;
-
-/**
- * \brief           Options for RSASSA-PSS signature verification.
- *                  See \c mbedtls_rsa_rsassa_pss_verify_ext()
- */
-typedef struct mbedtls_pk_rsassa_pss_options
-{
-    mbedtls_md_type_t MBEDTLS_PRIVATE(mgf1_hash_id);
-    int MBEDTLS_PRIVATE(expected_salt_len);
-
-} mbedtls_pk_rsassa_pss_options;
-
-/**
- * \brief           Maximum size of a signature made by mbedtls_pk_sign().
- */
-/* We need to set MBEDTLS_PK_SIGNATURE_MAX_SIZE to the maximum signature
- * size among the supported signature types. Do it by starting at 0,
- * then incrementally increasing to be large enough for each supported
- * signature mechanism.
- *
- * The resulting value can be 0, for example if MBEDTLS_ECDH_C is enabled
- * (which allows the pk module to be included) but neither MBEDTLS_ECDSA_C
- * nor MBEDTLS_RSA_C nor any opaque signature mechanism (PSA or RSA_ALT).
- */
-#define MBEDTLS_PK_SIGNATURE_MAX_SIZE 0
-
-#if ( defined(MBEDTLS_RSA_C) || defined(MBEDTLS_PK_RSA_ALT_SUPPORT) ) && \
-    MBEDTLS_MPI_MAX_SIZE > MBEDTLS_PK_SIGNATURE_MAX_SIZE
-/* For RSA, the signature can be as large as the bignum module allows.
- * For RSA_ALT, the signature size is not necessarily tied to what the
- * bignum module can do, but in the absence of any specific setting,
- * we use that (rsa_alt_sign_wrap in library/pk_wrap.h will check). */
-#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
-#define MBEDTLS_PK_SIGNATURE_MAX_SIZE MBEDTLS_MPI_MAX_SIZE
-#endif
-
-#if defined(MBEDTLS_ECDSA_C) &&                                 \
-    MBEDTLS_ECDSA_MAX_LEN > MBEDTLS_PK_SIGNATURE_MAX_SIZE
-/* For ECDSA, the ecdsa module exports a constant for the maximum
- * signature size. */
-#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
-#define MBEDTLS_PK_SIGNATURE_MAX_SIZE MBEDTLS_ECDSA_MAX_LEN
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#if PSA_SIGNATURE_MAX_SIZE > MBEDTLS_PK_SIGNATURE_MAX_SIZE
-/* PSA_SIGNATURE_MAX_SIZE is the maximum size of a signature made
- * through the PSA API in the PSA representation. */
-#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
-#define MBEDTLS_PK_SIGNATURE_MAX_SIZE PSA_SIGNATURE_MAX_SIZE
-#endif
-
-#if PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE + 11 > MBEDTLS_PK_SIGNATURE_MAX_SIZE
-/* The Mbed TLS representation is different for ECDSA signatures:
- * PSA uses the raw concatenation of r and s,
- * whereas Mbed TLS uses the ASN.1 representation (SEQUENCE of two INTEGERs).
- * Add the overhead of ASN.1: up to (1+2) + 2 * (1+2+1) for the
- * types, lengths (represented by up to 2 bytes), and potential leading
- * zeros of the INTEGERs and the SEQUENCE. */
-#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
-#define MBEDTLS_PK_SIGNATURE_MAX_SIZE ( PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE + 11 )
-#endif
-#endif /* defined(MBEDTLS_USE_PSA_CRYPTO) */
-
-/**
- * \brief           Types for interfacing with the debug module
- */
-typedef enum
-{
-    MBEDTLS_PK_DEBUG_NONE = 0,
-    MBEDTLS_PK_DEBUG_MPI,
-    MBEDTLS_PK_DEBUG_ECP,
-} mbedtls_pk_debug_type;
-
-/**
- * \brief           Item to send to the debug module
- */
-typedef struct mbedtls_pk_debug_item
-{
-    mbedtls_pk_debug_type MBEDTLS_PRIVATE(type);
-    const char *MBEDTLS_PRIVATE(name);
-    void *MBEDTLS_PRIVATE(value);
-} mbedtls_pk_debug_item;
-
-/** Maximum number of item send for debugging, plus 1 */
-#define MBEDTLS_PK_DEBUG_MAX_ITEMS 3
-
-/**
- * \brief           Public key information and operations
- *
- * \note        The library does not support custom pk info structures,
- *              only built-in structures returned by
- *              mbedtls_cipher_info_from_type().
- */
-typedef struct mbedtls_pk_info_t mbedtls_pk_info_t;
-
-/**
- * \brief           Public key container
- */
-typedef struct mbedtls_pk_context
-{
-    const mbedtls_pk_info_t *   MBEDTLS_PRIVATE(pk_info); /**< Public key information         */
-    void *                      MBEDTLS_PRIVATE(pk_ctx);  /**< Underlying public key context  */
-} mbedtls_pk_context;
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-/**
- * \brief           Context for resuming operations
- */
-typedef struct
-{
-    const mbedtls_pk_info_t *   MBEDTLS_PRIVATE(pk_info); /**< Public key information         */
-    void *                      MBEDTLS_PRIVATE(rs_ctx);  /**< Underlying restart context     */
-} mbedtls_pk_restart_ctx;
-#else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-/* Now we can declare functions that take a pointer to that */
-typedef void mbedtls_pk_restart_ctx;
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-#if defined(MBEDTLS_RSA_C)
-/**
- * Quick access to an RSA context inside a PK context.
- *
- * \warning You must make sure the PK context actually holds an RSA context
- * before using this function!
- */
-static inline mbedtls_rsa_context *mbedtls_pk_rsa( const mbedtls_pk_context pk )
-{
-    return( (mbedtls_rsa_context *) (pk).MBEDTLS_PRIVATE(pk_ctx) );
-}
-#endif /* MBEDTLS_RSA_C */
-
-#if defined(MBEDTLS_ECP_C)
-/**
- * Quick access to an EC context inside a PK context.
- *
- * \warning You must make sure the PK context actually holds an EC context
- * before using this function!
- */
-static inline mbedtls_ecp_keypair *mbedtls_pk_ec( const mbedtls_pk_context pk )
-{
-    return( (mbedtls_ecp_keypair *) (pk).MBEDTLS_PRIVATE(pk_ctx) );
-}
-#endif /* MBEDTLS_ECP_C */
-
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-/**
- * \brief           Types for RSA-alt abstraction
- */
-typedef int (*mbedtls_pk_rsa_alt_decrypt_func)( void *ctx, size_t *olen,
-                    const unsigned char *input, unsigned char *output,
-                    size_t output_max_len );
-typedef int (*mbedtls_pk_rsa_alt_sign_func)( void *ctx,
-                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
-                    mbedtls_md_type_t md_alg, unsigned int hashlen,
-                    const unsigned char *hash, unsigned char *sig );
-typedef size_t (*mbedtls_pk_rsa_alt_key_len_func)( void *ctx );
-#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
-
-/**
- * \brief           Return information associated with the given PK type
- *
- * \param pk_type   PK type to search for.
- *
- * \return          The PK info associated with the type or NULL if not found.
- */
-const mbedtls_pk_info_t *mbedtls_pk_info_from_type( mbedtls_pk_type_t pk_type );
-
-/**
- * \brief           Initialize a #mbedtls_pk_context (as NONE).
- *
- * \param ctx       The context to initialize.
- *                  This must not be \c NULL.
- */
-void mbedtls_pk_init( mbedtls_pk_context *ctx );
-
-/**
- * \brief           Free the components of a #mbedtls_pk_context.
- *
- * \param ctx       The context to clear. It must have been initialized.
- *                  If this is \c NULL, this function does nothing.
- *
- * \note            For contexts that have been set up with
- *                  mbedtls_pk_setup_opaque(), this does not free the underlying
- *                  PSA key and you still need to call psa_destroy_key()
- *                  independently if you want to destroy that key.
- */
-void mbedtls_pk_free( mbedtls_pk_context *ctx );
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-/**
- * \brief           Initialize a restart context
- *
- * \param ctx       The context to initialize.
- *                  This must not be \c NULL.
- */
-void mbedtls_pk_restart_init( mbedtls_pk_restart_ctx *ctx );
-
-/**
- * \brief           Free the components of a restart context
- *
- * \param ctx       The context to clear. It must have been initialized.
- *                  If this is \c NULL, this function does nothing.
- */
-void mbedtls_pk_restart_free( mbedtls_pk_restart_ctx *ctx );
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-/**
- * \brief           Initialize a PK context with the information given
- *                  and allocates the type-specific PK subcontext.
- *
- * \param ctx       Context to initialize. It must not have been set
- *                  up yet (type #MBEDTLS_PK_NONE).
- * \param info      Information to use
- *
- * \return          0 on success,
- *                  MBEDTLS_ERR_PK_BAD_INPUT_DATA on invalid input,
- *                  MBEDTLS_ERR_PK_ALLOC_FAILED on allocation failure.
- *
- * \note            For contexts holding an RSA-alt key, use
- *                  \c mbedtls_pk_setup_rsa_alt() instead.
- */
-int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-/**
- * \brief           Initialize a PK context to wrap a PSA key.
- *
- * \note            This function replaces mbedtls_pk_setup() for contexts
- *                  that wrap a (possibly opaque) PSA key instead of
- *                  storing and manipulating the key material directly.
- *
- * \param ctx       The context to initialize. It must be empty (type NONE).
- * \param key       The PSA key to wrap, which must hold an ECC key pair
- *                  (see notes below).
- *
- * \note            The wrapped key must remain valid as long as the
- *                  wrapping PK context is in use, that is at least between
- *                  the point this function is called and the point
- *                  mbedtls_pk_free() is called on this context. The wrapped
- *                  key might then be independently used or destroyed.
- *
- * \note            This function is currently only available for ECC key
- *                  pairs (that is, ECC keys containing private key material).
- *                  Support for other key types may be added later.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_PK_BAD_INPUT_DATA on invalid input
- *                  (context already used, invalid key identifier).
- * \return          #MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE if the key is not an
- *                  ECC key pair.
- * \return          #MBEDTLS_ERR_PK_ALLOC_FAILED on allocation failure.
- */
-int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx,
-                             const psa_key_id_t key );
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-/**
- * \brief           Initialize an RSA-alt context
- *
- * \param ctx       Context to initialize. It must not have been set
- *                  up yet (type #MBEDTLS_PK_NONE).
- * \param key       RSA key pointer
- * \param decrypt_func  Decryption function
- * \param sign_func     Signing function
- * \param key_len_func  Function returning key length in bytes
- *
- * \return          0 on success, or MBEDTLS_ERR_PK_BAD_INPUT_DATA if the
- *                  context wasn't already initialized as RSA_ALT.
- *
- * \note            This function replaces \c mbedtls_pk_setup() for RSA-alt.
- */
-int mbedtls_pk_setup_rsa_alt( mbedtls_pk_context *ctx, void * key,
-                         mbedtls_pk_rsa_alt_decrypt_func decrypt_func,
-                         mbedtls_pk_rsa_alt_sign_func sign_func,
-                         mbedtls_pk_rsa_alt_key_len_func key_len_func );
-#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
-
-/**
- * \brief           Get the size in bits of the underlying key
- *
- * \param ctx       The context to query. It must have been initialized.
- *
- * \return          Key size in bits, or 0 on error
- */
-size_t mbedtls_pk_get_bitlen( const mbedtls_pk_context *ctx );
-
-///**
-// * \brief           Get the length in bytes of the underlying key
-// *
-// * \param ctx       The context to query. It must have been initialized.
-// *
-// * \return          Key length in bytes, or 0 on error
-// */
-//static inline size_t mbedtls_pk_get_len( const mbedtls_pk_context *ctx )
-//{
-//    return( ( mbedtls_pk_get_bitlen( ctx ) + 7 ) / 8 );
-//}
-
-/**
- * \brief           Tell if a context can do the operation given by type
- *
- * \param ctx       The context to query. It must have been initialized.
- * \param type      The desired type.
- *
- * \return          1 if the context can do operations on the given type.
- * \return          0 if the context cannot do the operations on the given
- *                  type. This is always the case for a context that has
- *                  been initialized but not set up, or that has been
- *                  cleared with mbedtls_pk_free().
- */
-int mbedtls_pk_can_do( const mbedtls_pk_context *ctx, mbedtls_pk_type_t type );
-
-/**
- * \brief           Verify signature (including padding if relevant).
- *
- * \param ctx       The PK context to use. It must have been set up.
- * \param md_alg    Hash algorithm used.
- *                  This can be #MBEDTLS_MD_NONE if the signature algorithm
- *                  does not rely on a hash algorithm (non-deterministic
- *                  ECDSA, RSA PKCS#1 v1.5).
- *                  For PKCS#1 v1.5, if \p md_alg is #MBEDTLS_MD_NONE, then
- *                  \p hash is the DigestInfo structure used by RFC 8017
- *                  &sect;9.2 steps 3&ndash;6. If \p md_alg is a valid hash
- *                  algorithm then \p hash is the digest itself, and this
- *                  function calculates the DigestInfo encoding internally.
- * \param hash      Hash of the message to sign
- * \param hash_len  Hash length
- * \param sig       Signature to verify
- * \param sig_len   Signature length
- *
- * \return          0 on success (signature is valid),
- *                  #MBEDTLS_ERR_PK_SIG_LEN_MISMATCH if there is a valid
- *                  signature in sig but its length is less than \p siglen,
- *                  or a specific error code.
- *
- * \note            For RSA keys, the default padding type is PKCS#1 v1.5.
- *                  Use \c mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, ... )
- *                  to verify RSASSA_PSS signatures.
- */
-int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
-               const unsigned char *hash, size_t hash_len,
-               const unsigned char *sig, size_t sig_len );
-
-/**
- * \brief           Restartable version of \c mbedtls_pk_verify()
- *
- * \note            Performs the same job as \c mbedtls_pk_verify(), but can
- *                  return early and restart according to the limit set with
- *                  \c mbedtls_ecp_set_max_ops() to reduce blocking for ECC
- *                  operations. For RSA, same as \c mbedtls_pk_verify().
- *
- * \param ctx       The PK context to use. It must have been set up.
- * \param md_alg    Hash algorithm used (see notes)
- * \param hash      Hash of the message to sign
- * \param hash_len  Hash length or 0 (see notes)
- * \param sig       Signature to verify
- * \param sig_len   Signature length
- * \param rs_ctx    Restart context (NULL to disable restart)
- *
- * \return          See \c mbedtls_pk_verify(), or
- * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
- *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
- */
-int mbedtls_pk_verify_restartable( mbedtls_pk_context *ctx,
-               mbedtls_md_type_t md_alg,
-               const unsigned char *hash, size_t hash_len,
-               const unsigned char *sig, size_t sig_len,
-               mbedtls_pk_restart_ctx *rs_ctx );
-
-/**
- * \brief           Verify signature, with options.
- *                  (Includes verification of the padding depending on type.)
- *
- * \param type      Signature type (inc. possible padding type) to verify
- * \param options   Pointer to type-specific options, or NULL
- * \param ctx       The PK context to use. It must have been set up.
- * \param md_alg    Hash algorithm used (see notes)
- * \param hash      Hash of the message to sign
- * \param hash_len  Hash length or 0 (see notes)
- * \param sig       Signature to verify
- * \param sig_len   Signature length
- *
- * \return          0 on success (signature is valid),
- *                  #MBEDTLS_ERR_PK_TYPE_MISMATCH if the PK context can't be
- *                  used for this type of signatures,
- *                  #MBEDTLS_ERR_PK_SIG_LEN_MISMATCH if there is a valid
- *                  signature in sig but its length is less than \p siglen,
- *                  or a specific error code.
- *
- * \note            If hash_len is 0, then the length associated with md_alg
- *                  is used instead, or an error returned if it is invalid.
- *
- * \note            md_alg may be MBEDTLS_MD_NONE, only if hash_len != 0
- *
- * \note            If type is MBEDTLS_PK_RSASSA_PSS, then options must point
- *                  to a mbedtls_pk_rsassa_pss_options structure,
- *                  otherwise it must be NULL.
- */
-int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
-                   mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   const unsigned char *sig, size_t sig_len );
-
-/**
- * \brief           Make signature, including padding if relevant.
- *
- * \param ctx       The PK context to use. It must have been set up
- *                  with a private key.
- * \param md_alg    Hash algorithm used (see notes)
- * \param hash      Hash of the message to sign
- * \param hash_len  Hash length
- * \param sig       Place to write the signature.
- *                  It must have enough room for the signature.
- *                  #MBEDTLS_PK_SIGNATURE_MAX_SIZE is always enough.
- *                  You may use a smaller buffer if it is large enough
- *                  given the key type.
- * \param sig_size  The size of the \p sig buffer in bytes.
- * \param sig_len   On successful return,
- *                  the number of bytes written to \p sig.
- * \param f_rng     RNG function, must not be \c NULL.
- * \param p_rng     RNG parameter
- *
- * \return          0 on success, or a specific error code.
- *
- * \note            For RSA keys, the default padding type is PKCS#1 v1.5.
- *                  There is no interface in the PK module to make RSASSA-PSS
- *                  signatures yet.
- *
- * \note            For RSA, md_alg may be MBEDTLS_MD_NONE if hash_len != 0.
- *                  For ECDSA, md_alg may never be MBEDTLS_MD_NONE.
- */
-int mbedtls_pk_sign( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
-             const unsigned char *hash, size_t hash_len,
-             unsigned char *sig, size_t sig_size, size_t *sig_len,
-             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-
-/**
- * \brief           Restartable version of \c mbedtls_pk_sign()
- *
- * \note            Performs the same job as \c mbedtls_pk_sign(), but can
- *                  return early and restart according to the limit set with
- *                  \c mbedtls_ecp_set_max_ops() to reduce blocking for ECC
- *                  operations. For RSA, same as \c mbedtls_pk_sign().
- *
- * \param ctx       The PK context to use. It must have been set up
- *                  with a private key.
- * \param md_alg    Hash algorithm used (see notes for mbedtls_pk_sign())
- * \param hash      Hash of the message to sign
- * \param hash_len  Hash length
- * \param sig       Place to write the signature.
- *                  It must have enough room for the signature.
- *                  #MBEDTLS_PK_SIGNATURE_MAX_SIZE is always enough.
- *                  You may use a smaller buffer if it is large enough
- *                  given the key type.
- * \param sig_size  The size of the \p sig buffer in bytes.
- * \param sig_len   On successful return,
- *                  the number of bytes written to \p sig.
- * \param f_rng     RNG function, must not be \c NULL.
- * \param p_rng     RNG parameter
- * \param rs_ctx    Restart context (NULL to disable restart)
- *
- * \return          See \c mbedtls_pk_sign().
- * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
- *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
- */
-int mbedtls_pk_sign_restartable( mbedtls_pk_context *ctx,
-             mbedtls_md_type_t md_alg,
-             const unsigned char *hash, size_t hash_len,
-             unsigned char *sig, size_t sig_size, size_t *sig_len,
-             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
-             mbedtls_pk_restart_ctx *rs_ctx );
-
-/**
- * \brief           Decrypt message (including padding if relevant).
- *
- * \param ctx       The PK context to use. It must have been set up
- *                  with a private key.
- * \param input     Input to decrypt
- * \param ilen      Input size
- * \param output    Decrypted output
- * \param olen      Decrypted message length
- * \param osize     Size of the output buffer
- * \param f_rng     RNG function, must not be \c NULL.
- * \param p_rng     RNG parameter
- *
- * \note            For RSA keys, the default padding type is PKCS#1 v1.5.
- *
- * \return          0 on success, or a specific error code.
- */
-int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
-                const unsigned char *input, size_t ilen,
-                unsigned char *output, size_t *olen, size_t osize,
-                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-
-/**
- * \brief           Encrypt message (including padding if relevant).
- *
- * \param ctx       The PK context to use. It must have been set up.
- * \param input     Message to encrypt
- * \param ilen      Message size
- * \param output    Encrypted output
- * \param olen      Encrypted output length
- * \param osize     Size of the output buffer
- * \param f_rng     RNG function, must not be \c NULL.
- * \param p_rng     RNG parameter
- *
- * \note            \p f_rng is used for padding generation.
- *
- * \note            For RSA keys, the default padding type is PKCS#1 v1.5.
- *
- * \return          0 on success, or a specific error code.
- */
-int mbedtls_pk_encrypt( mbedtls_pk_context *ctx,
-                const unsigned char *input, size_t ilen,
-                unsigned char *output, size_t *olen, size_t osize,
-                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-
-/**
- * \brief           Check if a public-private pair of keys matches.
- *
- * \param pub       Context holding a public key.
- * \param prv       Context holding a private (and public) key.
- * \param f_rng     RNG function, must not be \c NULL.
- * \param p_rng     RNG parameter
- *
- * \return          \c 0 on success (keys were checked and match each other).
- * \return          #MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE if the keys could not
- *                  be checked - in that case they may or may not match.
- * \return          #MBEDTLS_ERR_PK_BAD_INPUT_DATA if a context is invalid.
- * \return          Another non-zero value if the keys do not match.
- */
-int mbedtls_pk_check_pair( const mbedtls_pk_context *pub,
-                           const mbedtls_pk_context *prv,
-                           int (*f_rng)(void *, unsigned char *, size_t),
-                           void *p_rng );
-
-/**
- * \brief           Export debug information
- *
- * \param ctx       The PK context to use. It must have been initialized.
- * \param items     Place to write debug items
- *
- * \return          0 on success or MBEDTLS_ERR_PK_BAD_INPUT_DATA
- */
-int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items );
-
-/**
- * \brief           Access the type name
- *
- * \param ctx       The PK context to use. It must have been initialized.
- *
- * \return          Type name on success, or "invalid PK"
- */
-const char * mbedtls_pk_get_name( const mbedtls_pk_context *ctx );
-
-/**
- * \brief           Get the key type
- *
- * \param ctx       The PK context to use. It must have been initialized.
- *
- * \return          Type on success.
- * \return          #MBEDTLS_PK_NONE for a context that has not been set up.
- */
-mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context *ctx );
-
-#if defined(MBEDTLS_PK_PARSE_C)
-/** \ingroup pk_module */
-/**
- * \brief           Parse a private key in PEM or DER format
- *
- * \param ctx       The PK context to fill. It must have been initialized
- *                  but not set up.
- * \param key       Input buffer to parse.
- *                  The buffer must contain the input exactly, with no
- *                  extra trailing material. For PEM, the buffer must
- *                  contain a null-terminated string.
- * \param keylen    Size of \b key in bytes.
- *                  For PEM data, this includes the terminating null byte,
- *                  so \p keylen must be equal to `strlen(key) + 1`.
- * \param pwd       Optional password for decryption.
- *                  Pass \c NULL if expecting a non-encrypted key.
- *                  Pass a string of \p pwdlen bytes if expecting an encrypted
- *                  key; a non-encrypted key will also be accepted.
- *                  The empty password is not supported.
- * \param pwdlen    Size of the password in bytes.
- *                  Ignored if \p pwd is \c NULL.
- * \param f_rng     RNG function, must not be \c NULL. Used for blinding.
- * \param p_rng     RNG parameter
- *
- * \note            On entry, ctx must be empty, either freshly initialised
- *                  with mbedtls_pk_init() or reset with mbedtls_pk_free(). If you need a
- *                  specific key type, check the result with mbedtls_pk_can_do().
- *
- * \note            The key is also checked for correctness.
- *
- * \return          0 if successful, or a specific PK or PEM error code
- */
-int mbedtls_pk_parse_key( mbedtls_pk_context *ctx,
-              const unsigned char *key, size_t keylen,
-              const unsigned char *pwd, size_t pwdlen,
-              int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-
-/** \ingroup pk_module */
-/**
- * \brief           Parse a public key in PEM or DER format
- *
- * \param ctx       The PK context to fill. It must have been initialized
- *                  but not set up.
- * \param key       Input buffer to parse.
- *                  The buffer must contain the input exactly, with no
- *                  extra trailing material. For PEM, the buffer must
- *                  contain a null-terminated string.
- * \param keylen    Size of \b key in bytes.
- *                  For PEM data, this includes the terminating null byte,
- *                  so \p keylen must be equal to `strlen(key) + 1`.
- *
- * \note            On entry, ctx must be empty, either freshly initialised
- *                  with mbedtls_pk_init() or reset with mbedtls_pk_free(). If you need a
- *                  specific key type, check the result with mbedtls_pk_can_do().
- *
- * \note            The key is also checked for correctness.
- *
- * \return          0 if successful, or a specific PK or PEM error code
- */
-int mbedtls_pk_parse_public_key( mbedtls_pk_context *ctx,
-                         const unsigned char *key, size_t keylen );
-
-#if defined(MBEDTLS_FS_IO)
-/** \ingroup pk_module */
-/**
- * \brief           Load and parse a private key
- *
- * \param ctx       The PK context to fill. It must have been initialized
- *                  but not set up.
- * \param path      filename to read the private key from
- * \param password  Optional password to decrypt the file.
- *                  Pass \c NULL if expecting a non-encrypted key.
- *                  Pass a null-terminated string if expecting an encrypted
- *                  key; a non-encrypted key will also be accepted.
- *                  The empty password is not supported.
- * \param f_rng     RNG function, must not be \c NULL. Used for blinding.
- * \param p_rng     RNG parameter
- *
- * \note            On entry, ctx must be empty, either freshly initialised
- *                  with mbedtls_pk_init() or reset with mbedtls_pk_free(). If you need a
- *                  specific key type, check the result with mbedtls_pk_can_do().
- *
- * \note            The key is also checked for correctness.
- *
- * \return          0 if successful, or a specific PK or PEM error code
- */
-int mbedtls_pk_parse_keyfile( mbedtls_pk_context *ctx,
-                  const char *path, const char *password,
-                  int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-
-/** \ingroup pk_module */
-/**
- * \brief           Load and parse a public key
- *
- * \param ctx       The PK context to fill. It must have been initialized
- *                  but not set up.
- * \param path      filename to read the public key from
- *
- * \note            On entry, ctx must be empty, either freshly initialised
- *                  with mbedtls_pk_init() or reset with mbedtls_pk_free(). If
- *                  you need a specific key type, check the result with
- *                  mbedtls_pk_can_do().
- *
- * \note            The key is also checked for correctness.
- *
- * \return          0 if successful, or a specific PK or PEM error code
- */
-int mbedtls_pk_parse_public_keyfile( mbedtls_pk_context *ctx, const char *path );
-#endif /* MBEDTLS_FS_IO */
-#endif /* MBEDTLS_PK_PARSE_C */
-
-#if defined(MBEDTLS_PK_WRITE_C)
-/**
- * \brief           Write a private key to a PKCS#1 or SEC1 DER structure
- *                  Note: data is written at the end of the buffer! Use the
- *                        return value to determine where you should start
- *                        using the buffer
- *
- * \param ctx       PK context which must contain a valid private key.
- * \param buf       buffer to write to
- * \param size      size of the buffer
- *
- * \return          length of data written if successful, or a specific
- *                  error code
- */
-int mbedtls_pk_write_key_der( const mbedtls_pk_context *ctx, unsigned char *buf, size_t size );
-
-/**
- * \brief           Write a public key to a SubjectPublicKeyInfo DER structure
- *                  Note: data is written at the end of the buffer! Use the
- *                        return value to determine where you should start
- *                        using the buffer
- *
- * \param ctx       PK context which must contain a valid public or private key.
- * \param buf       buffer to write to
- * \param size      size of the buffer
- *
- * \return          length of data written if successful, or a specific
- *                  error code
- */
-int mbedtls_pk_write_pubkey_der( const mbedtls_pk_context *ctx, unsigned char *buf, size_t size );
-
-#if defined(MBEDTLS_PEM_WRITE_C)
-/**
- * \brief           Write a public key to a PEM string
- *
- * \param ctx       PK context which must contain a valid public or private key.
- * \param buf       Buffer to write to. The output includes a
- *                  terminating null byte.
- * \param size      Size of the buffer in bytes.
- *
- * \return          0 if successful, or a specific error code
- */
-int mbedtls_pk_write_pubkey_pem( const mbedtls_pk_context *ctx, unsigned char *buf, size_t size );
-
-/**
- * \brief           Write a private key to a PKCS#1 or SEC1 PEM string
- *
- * \param ctx       PK context which must contain a valid private key.
- * \param buf       Buffer to write to. The output includes a
- *                  terminating null byte.
- * \param size      Size of the buffer in bytes.
- *
- * \return          0 if successful, or a specific error code
- */
-int mbedtls_pk_write_key_pem( const mbedtls_pk_context *ctx, unsigned char *buf, size_t size );
-#endif /* MBEDTLS_PEM_WRITE_C */
-#endif /* MBEDTLS_PK_WRITE_C */
-
-/*
- * WARNING: Low-level functions. You probably do not want to use these unless
- *          you are certain you do ;)
- */
-
-#if defined(MBEDTLS_PK_PARSE_C)
-/**
- * \brief           Parse a SubjectPublicKeyInfo DER structure
- *
- * \param p         the position in the ASN.1 data
- * \param end       end of the buffer
- * \param pk        The PK context to fill. It must have been initialized
- *                  but not set up.
- *
- * \return          0 if successful, or a specific PK error code
- */
-int mbedtls_pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
-                        mbedtls_pk_context *pk );
-#endif /* MBEDTLS_PK_PARSE_C */
-
-#if defined(MBEDTLS_PK_WRITE_C)
-/**
- * \brief           Write a subjectPublicKey to ASN.1 data
- *                  Note: function works backwards in data buffer
- *
- * \param p         reference to current position pointer
- * \param start     start of the buffer (for bounds-checking)
- * \param key       PK context which must contain a valid public or private key.
- *
- * \return          the length written or a negative error code
- */
-int mbedtls_pk_write_pubkey( unsigned char **p, unsigned char *start,
-                     const mbedtls_pk_context *key );
-#endif /* MBEDTLS_PK_WRITE_C */
-
-/*
- * Internal module functions. You probably do not want to use these unless you
- * know you do.
- */
-#if defined(MBEDTLS_FS_IO)
-int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n );
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-/**
- * \brief           Turn an EC key into an opaque one.
- *
- * \warning         This is a temporary utility function for tests. It might
- *                  change or be removed at any time without notice.
- *
- * \note            Only ECDSA keys are supported so far. Signing with the
- *                  specified hash is the only allowed use of that key.
- *
- * \param pk        Input: the EC key to import to a PSA key.
- *                  Output: a PK context wrapping that PSA key.
- * \param key       Output: a PSA key identifier.
- *                  It's the caller's responsibility to call
- *                  psa_destroy_key() on that key identifier after calling
- *                  mbedtls_pk_free() on the PK context.
- * \param hash_alg  The hash algorithm to allow for use with that key.
- *
- * \return          \c 0 if successful.
- * \return          An Mbed TLS error code otherwise.
- */
-int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk,
-                               psa_key_id_t *key,
-                               psa_algorithm_t hash_alg );
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_PK_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/pkcs12.h b/src/duckdb/third_party/mbedtls/include/mbedtls/pkcs12.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/pkcs12.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/pkcs5.h b/src/duckdb/third_party/mbedtls/include/mbedtls/pkcs5.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/pkcs5.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/platform.h b/src/duckdb/third_party/mbedtls/include/mbedtls/platform.h
deleted file mode 100644
index 277a85c7d..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/platform.h
+++ /dev/null
@@ -1,411 +0,0 @@
-/**
- * \file platform.h
- *
- * \brief This file contains the definitions and functions of the
- *        Mbed TLS platform abstraction layer.
- *
- *        The platform abstraction layer removes the need for the library
- *        to directly link to standard C library functions or operating
- *        system services, making the library easier to port and embed.
- *        Application developers and users of the library can provide their own
- *        implementations of these functions, or implementations specific to
- *        their platform, which can be statically linked to the library or
- *        dynamically configured at runtime.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_PLATFORM_H
-#define MBEDTLS_PLATFORM_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#if defined(MBEDTLS_HAVE_TIME)
-#include "mbedtls/platform_time.h"
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \name SECTION: Module settings
- *
- * The configuration options you can set for this module are in this section.
- * Either change them in mbedtls_config.h or define them on the compiler command line.
- * \{
- */
-
-/* The older Microsoft Windows common runtime provides non-conforming
- * implementations of some standard library functions, including snprintf
- * and vsnprintf. This affects MSVC and MinGW builds.
- */
-#if defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER <= 1900)
-#define MBEDTLS_PLATFORM_HAS_NON_CONFORMING_SNPRINTF
-#define MBEDTLS_PLATFORM_HAS_NON_CONFORMING_VSNPRINTF
-#endif
-
-#if !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#if !defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
-#if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_SNPRINTF)
-#define MBEDTLS_PLATFORM_STD_SNPRINTF   mbedtls_platform_win32_snprintf /**< The default \c snprintf function to use.  */
-#else
-#define MBEDTLS_PLATFORM_STD_SNPRINTF   snprintf /**< The default \c snprintf function to use.  */
-#endif
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_VSNPRINTF)
-#if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_VSNPRINTF)
-#define MBEDTLS_PLATFORM_STD_VSNPRINTF   mbedtls_platform_win32_vsnprintf /**< The default \c vsnprintf function to use.  */
-#else
-#define MBEDTLS_PLATFORM_STD_VSNPRINTF   vsnprintf /**< The default \c vsnprintf function to use.  */
-#endif
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_PRINTF)
-#define MBEDTLS_PLATFORM_STD_PRINTF   printf /**< The default \c printf function to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_FPRINTF)
-#define MBEDTLS_PLATFORM_STD_FPRINTF fprintf /**< The default \c fprintf function to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_CALLOC)
-#define MBEDTLS_PLATFORM_STD_CALLOC   calloc /**< The default \c calloc function to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_FREE)
-#define MBEDTLS_PLATFORM_STD_FREE       free /**< The default \c free function to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_EXIT)
-#define MBEDTLS_PLATFORM_STD_EXIT      exit /**< The default \c exit function to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_TIME)
-#define MBEDTLS_PLATFORM_STD_TIME       time    /**< The default \c time function to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_EXIT_SUCCESS)
-#define MBEDTLS_PLATFORM_STD_EXIT_SUCCESS  EXIT_SUCCESS /**< The default exit value to use. */
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_EXIT_FAILURE)
-#define MBEDTLS_PLATFORM_STD_EXIT_FAILURE  EXIT_FAILURE /**< The default exit value to use. */
-#endif
-#if defined(MBEDTLS_FS_IO)
-#if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)
-#define MBEDTLS_PLATFORM_STD_NV_SEED_READ   mbedtls_platform_std_nv_seed_read
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)
-#define MBEDTLS_PLATFORM_STD_NV_SEED_WRITE  mbedtls_platform_std_nv_seed_write
-#endif
-#if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_FILE)
-#define MBEDTLS_PLATFORM_STD_NV_SEED_FILE   "seedfile"
-#endif
-#endif /* MBEDTLS_FS_IO */
-#else /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
-#if defined(MBEDTLS_PLATFORM_STD_MEM_HDR)
-#include MBEDTLS_PLATFORM_STD_MEM_HDR
-#endif
-#endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
-
-
-/* \} name SECTION: Module settings */
-
-/*
- * The function pointers for calloc and free.
- */
-#if defined(MBEDTLS_PLATFORM_MEMORY)
-#if defined(MBEDTLS_PLATFORM_FREE_MACRO) && \
-    defined(MBEDTLS_PLATFORM_CALLOC_MACRO)
-#define mbedtls_free       MBEDTLS_PLATFORM_FREE_MACRO
-#define mbedtls_calloc     MBEDTLS_PLATFORM_CALLOC_MACRO
-#else
-/* For size_t */
-#include <stddef.h>
-extern void *mbedtls_calloc( size_t n, size_t size );
-extern void mbedtls_free( void *ptr );
-
-/**
- * \brief               This function dynamically sets the memory-management
- *                      functions used by the library, during runtime.
- *
- * \param calloc_func   The \c calloc function implementation.
- * \param free_func     The \c free function implementation.
- *
- * \return              \c 0.
- */
-int mbedtls_platform_set_calloc_free( void * (*calloc_func)( size_t, size_t ),
-                              void (*free_func)( void * ) );
-#endif /* MBEDTLS_PLATFORM_FREE_MACRO && MBEDTLS_PLATFORM_CALLOC_MACRO */
-#else /* !MBEDTLS_PLATFORM_MEMORY */
-#define mbedtls_free       free
-#define mbedtls_calloc     calloc
-#endif /* MBEDTLS_PLATFORM_MEMORY && !MBEDTLS_PLATFORM_{FREE,CALLOC}_MACRO */
-
-/*
- * The function pointers for fprintf
- */
-#if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
-/* We need FILE * */
-#include <stdio.h>
-extern int (*mbedtls_fprintf)( FILE *stream, const char *format, ... );
-
-/**
- * \brief                This function dynamically configures the fprintf
- *                       function that is called when the
- *                       mbedtls_fprintf() function is invoked by the library.
- *
- * \param fprintf_func   The \c fprintf function implementation.
- *
- * \return               \c 0.
- */
-int mbedtls_platform_set_fprintf( int (*fprintf_func)( FILE *stream, const char *,
-                                               ... ) );
-#else
-#if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO)
-#define mbedtls_fprintf    MBEDTLS_PLATFORM_FPRINTF_MACRO
-#else
-#define mbedtls_fprintf    fprintf
-#endif /* MBEDTLS_PLATFORM_FPRINTF_MACRO */
-#endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
-
-/*
- * The function pointers for printf
- */
-#if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
-extern int (*mbedtls_printf)( const char *format, ... );
-
-/**
- * \brief               This function dynamically configures the snprintf
- *                      function that is called when the mbedtls_snprintf()
- *                      function is invoked by the library.
- *
- * \param printf_func   The \c printf function implementation.
- *
- * \return              \c 0 on success.
- */
-int mbedtls_platform_set_printf( int (*printf_func)( const char *, ... ) );
-#else /* !MBEDTLS_PLATFORM_PRINTF_ALT */
-#if defined(MBEDTLS_PLATFORM_PRINTF_MACRO)
-#define mbedtls_printf     MBEDTLS_PLATFORM_PRINTF_MACRO
-#else
-#define mbedtls_printf     printf
-#endif /* MBEDTLS_PLATFORM_PRINTF_MACRO */
-#endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
-
-/*
- * The function pointers for snprintf
- *
- * The snprintf implementation should conform to C99:
- * - it *must* always correctly zero-terminate the buffer
- *   (except when n == 0, then it must leave the buffer untouched)
- * - however it is acceptable to return -1 instead of the required length when
- *   the destination buffer is too short.
- */
-#if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_SNPRINTF)
-/* For Windows (inc. MSYS2), we provide our own fixed implementation */
-int mbedtls_platform_win32_snprintf( char *s, size_t n, const char *fmt, ... );
-#endif
-
-#if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
-extern int (*mbedtls_snprintf)( char * s, size_t n, const char * format, ... );
-
-/**
- * \brief                 This function allows configuring a custom
- *                        \c snprintf function pointer.
- *
- * \param snprintf_func   The \c snprintf function implementation.
- *
- * \return                \c 0 on success.
- */
-int mbedtls_platform_set_snprintf( int (*snprintf_func)( char * s, size_t n,
-                                                 const char * format, ... ) );
-#else /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
-#if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO)
-#define mbedtls_snprintf   MBEDTLS_PLATFORM_SNPRINTF_MACRO
-#else
-#define mbedtls_snprintf   MBEDTLS_PLATFORM_STD_SNPRINTF
-#endif /* MBEDTLS_PLATFORM_SNPRINTF_MACRO */
-#endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
-
-/*
- * The function pointers for vsnprintf
- *
- * The vsnprintf implementation should conform to C99:
- * - it *must* always correctly zero-terminate the buffer
- *   (except when n == 0, then it must leave the buffer untouched)
- * - however it is acceptable to return -1 instead of the required length when
- *   the destination buffer is too short.
- */
-#if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_VSNPRINTF)
-#include <stdarg.h>
-/* For Older Windows (inc. MSYS2), we provide our own fixed implementation */
-int mbedtls_platform_win32_vsnprintf( char *s, size_t n, const char *fmt, va_list arg );
-#endif
-
-#if defined(MBEDTLS_PLATFORM_VSNPRINTF_ALT)
-#include <stdarg.h>
-extern int (*mbedtls_vsnprintf)( char * s, size_t n, const char * format, va_list arg );
-
-/**
- * \brief   Set your own snprintf function pointer
- *
- * \param   vsnprintf_func   The \c vsnprintf function implementation
- *
- * \return  \c 0
- */
-int mbedtls_platform_set_vsnprintf( int (*vsnprintf_func)( char * s, size_t n,
-                                                 const char * format, va_list arg ) );
-#else /* MBEDTLS_PLATFORM_VSNPRINTF_ALT */
-#if defined(MBEDTLS_PLATFORM_VSNPRINTF_MACRO)
-#define mbedtls_vsnprintf   MBEDTLS_PLATFORM_VSNPRINTF_MACRO
-#else
-#define mbedtls_vsnprintf   vsnprintf
-#endif /* MBEDTLS_PLATFORM_VSNPRINTF_MACRO */
-#endif /* MBEDTLS_PLATFORM_VSNPRINTF_ALT */
-
-/*
- * The function pointers for exit
- */
-#if defined(MBEDTLS_PLATFORM_EXIT_ALT)
-extern void (*mbedtls_exit)( int status );
-
-/**
- * \brief             This function dynamically configures the exit
- *                    function that is called when the mbedtls_exit()
- *                    function is invoked by the library.
- *
- * \param exit_func   The \c exit function implementation.
- *
- * \return            \c 0 on success.
- */
-int mbedtls_platform_set_exit( void (*exit_func)( int status ) );
-#else
-#if defined(MBEDTLS_PLATFORM_EXIT_MACRO)
-#define mbedtls_exit   MBEDTLS_PLATFORM_EXIT_MACRO
-#else
-#define mbedtls_exit   exit
-#endif /* MBEDTLS_PLATFORM_EXIT_MACRO */
-#endif /* MBEDTLS_PLATFORM_EXIT_ALT */
-
-/*
- * The default exit values
- */
-#if defined(MBEDTLS_PLATFORM_STD_EXIT_SUCCESS)
-#define MBEDTLS_EXIT_SUCCESS MBEDTLS_PLATFORM_STD_EXIT_SUCCESS
-#else
-#define MBEDTLS_EXIT_SUCCESS 0
-#endif
-#if defined(MBEDTLS_PLATFORM_STD_EXIT_FAILURE)
-#define MBEDTLS_EXIT_FAILURE MBEDTLS_PLATFORM_STD_EXIT_FAILURE
-#else
-#define MBEDTLS_EXIT_FAILURE 1
-#endif
-
-/*
- * The function pointers for reading from and writing a seed file to
- * Non-Volatile storage (NV) in a platform-independent way
- *
- * Only enabled when the NV seed entropy source is enabled
- */
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-#if !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS) && defined(MBEDTLS_FS_IO)
-/* Internal standard platform definitions */
-int mbedtls_platform_std_nv_seed_read( unsigned char *buf, size_t buf_len );
-int mbedtls_platform_std_nv_seed_write( unsigned char *buf, size_t buf_len );
-#endif
-
-#if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
-extern int (*mbedtls_nv_seed_read)( unsigned char *buf, size_t buf_len );
-extern int (*mbedtls_nv_seed_write)( unsigned char *buf, size_t buf_len );
-
-/**
- * \brief   This function allows configuring custom seed file writing and
- *          reading functions.
- *
- * \param   nv_seed_read_func   The seed reading function implementation.
- * \param   nv_seed_write_func  The seed writing function implementation.
- *
- * \return  \c 0 on success.
- */
-int mbedtls_platform_set_nv_seed(
-            int (*nv_seed_read_func)( unsigned char *buf, size_t buf_len ),
-            int (*nv_seed_write_func)( unsigned char *buf, size_t buf_len )
-            );
-#else
-#if defined(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO) && \
-    defined(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO)
-#define mbedtls_nv_seed_read    MBEDTLS_PLATFORM_NV_SEED_READ_MACRO
-#define mbedtls_nv_seed_write   MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO
-#else
-#define mbedtls_nv_seed_read    mbedtls_platform_std_nv_seed_read
-#define mbedtls_nv_seed_write   mbedtls_platform_std_nv_seed_write
-#endif
-#endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
-#endif /* MBEDTLS_ENTROPY_NV_SEED */
-
-#if !defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)
-
-/**
- * \brief   The platform context structure.
- *
- * \note    This structure may be used to assist platform-specific
- *          setup or teardown operations.
- */
-typedef struct mbedtls_platform_context
-{
-    char MBEDTLS_PRIVATE(dummy); /**< A placeholder member, as empty structs are not portable. */
-}
-mbedtls_platform_context;
-
-#else
-#include "platform_alt.h"
-#endif /* !MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */
-
-/**
- * \brief   This function performs any platform-specific initialization
- *          operations.
- *
- * \note    This function should be called before any other library functions.
- *
- *          Its implementation is platform-specific, and unless
- *          platform-specific code is provided, it does nothing.
- *
- * \note    The usage and necessity of this function is dependent on the platform.
- *
- * \param   ctx     The platform context.
- *
- * \return  \c 0 on success.
- */
-int mbedtls_platform_setup( mbedtls_platform_context *ctx );
-/**
- * \brief   This function performs any platform teardown operations.
- *
- * \note    This function should be called after every other Mbed TLS module
- *          has been correctly freed using the appropriate free function.
- *
- *          Its implementation is platform-specific, and unless
- *          platform-specific code is provided, it does nothing.
- *
- * \note    The usage and necessity of this function is dependent on the platform.
- *
- * \param   ctx     The platform context.
- *
- */
-void mbedtls_platform_teardown( mbedtls_platform_context *ctx );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* platform.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/platform_time.h b/src/duckdb/third_party/mbedtls/include/mbedtls/platform_time.h
deleted file mode 100644
index 8d4b95d1d..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/platform_time.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * \file platform_time.h
- *
- * \brief mbed TLS Platform time abstraction
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_PLATFORM_TIME_H
-#define MBEDTLS_PLATFORM_TIME_H
-
-#include "mbedtls/build_info.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \name SECTION: Module settings
- *
- * The configuration options you can set for this module are in this section.
- * Either change them in mbedtls_config.h or define them on the compiler command line.
- * \{
- */
-
-/*
- * The time_t datatype
- */
-#if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO)
-typedef MBEDTLS_PLATFORM_TIME_TYPE_MACRO mbedtls_time_t;
-#else
-/* For time_t */
-#include <time.h>
-typedef time_t mbedtls_time_t;
-#endif /* MBEDTLS_PLATFORM_TIME_TYPE_MACRO */
-
-/*
- * The function pointers for time
- */
-#if defined(MBEDTLS_PLATFORM_TIME_ALT)
-extern mbedtls_time_t (*mbedtls_time)( mbedtls_time_t* time );
-
-/**
- * \brief   Set your own time function pointer
- *
- * \param   time_func   the time function implementation
- *
- * \return              0
- */
-int mbedtls_platform_set_time( mbedtls_time_t (*time_func)( mbedtls_time_t* time ) );
-#else
-#if defined(MBEDTLS_PLATFORM_TIME_MACRO)
-#define mbedtls_time    MBEDTLS_PLATFORM_TIME_MACRO
-#else
-#define mbedtls_time   time
-#endif /* MBEDTLS_PLATFORM_TIME_MACRO */
-#endif /* MBEDTLS_PLATFORM_TIME_ALT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* platform_time.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/platform_util.h b/src/duckdb/third_party/mbedtls/include/mbedtls/platform_util.h
deleted file mode 100644
index 5d2fefc36..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/platform_util.h
+++ /dev/null
@@ -1,207 +0,0 @@
-/**
- * \file platform_util.h
- *
- * \brief Common and shared functions used by multiple modules in the Mbed TLS
- *        library.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_PLATFORM_UTIL_H
-#define MBEDTLS_PLATFORM_UTIL_H
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#if defined(MBEDTLS_HAVE_TIME_DATE)
-#include "mbedtls/platform_time.h"
-#include <time.h>
-#endif /* MBEDTLS_HAVE_TIME_DATE */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Internal macros meant to be called only from within the library. */
-#define MBEDTLS_INTERNAL_VALIDATE_RET( cond, ret )  do { } while( 0 )
-#define MBEDTLS_INTERNAL_VALIDATE( cond )           do { } while( 0 )
-
-/* Internal helper macros for deprecating API constants. */
-#if !defined(MBEDTLS_DEPRECATED_REMOVED)
-#if defined(MBEDTLS_DEPRECATED_WARNING)
-#define MBEDTLS_DEPRECATED __attribute__((deprecated))
-MBEDTLS_DEPRECATED typedef char const * mbedtls_deprecated_string_constant_t;
-#define MBEDTLS_DEPRECATED_STRING_CONSTANT( VAL )       \
-    ( (mbedtls_deprecated_string_constant_t) ( VAL ) )
-MBEDTLS_DEPRECATED typedef int mbedtls_deprecated_numeric_constant_t;
-#define MBEDTLS_DEPRECATED_NUMERIC_CONSTANT( VAL )       \
-    ( (mbedtls_deprecated_numeric_constant_t) ( VAL ) )
-#else /* MBEDTLS_DEPRECATED_WARNING */
-#define MBEDTLS_DEPRECATED
-#define MBEDTLS_DEPRECATED_STRING_CONSTANT( VAL ) VAL
-#define MBEDTLS_DEPRECATED_NUMERIC_CONSTANT( VAL ) VAL
-#endif /* MBEDTLS_DEPRECATED_WARNING */
-#endif /* MBEDTLS_DEPRECATED_REMOVED */
-
-/* Implementation of the check-return facility.
- * See the user documentation in mbedtls_config.h.
- *
- * Do not use this macro directly to annotate function: instead,
- * use one of MBEDTLS_CHECK_RETURN_CRITICAL or MBEDTLS_CHECK_RETURN_TYPICAL
- * depending on how important it is to check the return value.
- */
-#if !defined(MBEDTLS_CHECK_RETURN)
-#if defined(__GNUC__)
-#define MBEDTLS_CHECK_RETURN __attribute__((__warn_unused_result__))
-#elif defined(_MSC_VER) && _MSC_VER >= 1700
-#include <sal.h>
-#define MBEDTLS_CHECK_RETURN _Check_return_
-#else
-#define MBEDTLS_CHECK_RETURN
-#endif
-#endif
-
-/** Critical-failure function
- *
- * This macro appearing at the beginning of the declaration of a function
- * indicates that its return value should be checked in all applications.
- * Omitting the check is very likely to indicate a bug in the application
- * and will result in a compile-time warning if #MBEDTLS_CHECK_RETURN
- * is implemented for the compiler in use.
- *
- * \note  The use of this macro is a work in progress.
- *        This macro may be added to more functions in the future.
- *        Such an extension is not considered an API break, provided that
- *        there are near-unavoidable circumstances under which the function
- *        can fail. For example, signature/MAC/AEAD verification functions,
- *        and functions that require a random generator, are considered
- *        return-check-critical.
- */
-#define MBEDTLS_CHECK_RETURN_CRITICAL MBEDTLS_CHECK_RETURN
-
-/** Ordinary-failure function
- *
- * This macro appearing at the beginning of the declaration of a function
- * indicates that its return value should be generally be checked in portable
- * applications. Omitting the check will result in a compile-time warning if
- * #MBEDTLS_CHECK_RETURN is implemented for the compiler in use and
- * #MBEDTLS_CHECK_RETURN_WARNING is enabled in the compile-time configuration.
- *
- * You can use #MBEDTLS_IGNORE_RETURN to explicitly ignore the return value
- * of a function that is annotated with #MBEDTLS_CHECK_RETURN.
- *
- * \note  The use of this macro is a work in progress.
- *        This macro will be added to more functions in the future.
- *        Eventually this should appear before most functions returning
- *        an error code (as \c int in the \c mbedtls_xxx API or
- *        as ::psa_status_t in the \c psa_xxx API).
- */
-#if defined(MBEDTLS_CHECK_RETURN_WARNING)
-#define MBEDTLS_CHECK_RETURN_TYPICAL MBEDTLS_CHECK_RETURN
-#else
-#define MBEDTLS_CHECK_RETURN_TYPICAL
-#endif
-
-/** Benign-failure function
- *
- * This macro appearing at the beginning of the declaration of a function
- * indicates that it is rarely useful to check its return value.
- *
- * This macro has an empty expansion. It exists for documentation purposes:
- * a #MBEDTLS_CHECK_RETURN_OPTIONAL annotation indicates that the function
- * has been analyzed for return-check usefuless, whereas the lack of
- * an annotation indicates that the function has not been analyzed and its
- * return-check usefulness is unknown.
- */
-#define MBEDTLS_CHECK_RETURN_OPTIONAL
-
-/** \def MBEDTLS_IGNORE_RETURN
- *
- * Call this macro with one argument, a function call, to suppress a warning
- * from #MBEDTLS_CHECK_RETURN due to that function call.
- */
-#if !defined(MBEDTLS_IGNORE_RETURN)
-/* GCC doesn't silence the warning with just (void)(result).
- * (void)!(result) is known to work up at least up to GCC 10, as well
- * as with Clang and MSVC.
- *
- * https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Non_002dbugs.html
- * https://stackoverflow.com/questions/40576003/ignoring-warning-wunused-result
- * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425#c34
- */
-#define MBEDTLS_IGNORE_RETURN(result) ( (void) !( result ) )
-#endif
-
-/**
- * \brief       Securely zeroize a buffer
- *
- *              The function is meant to wipe the data contained in a buffer so
- *              that it can no longer be recovered even if the program memory
- *              is later compromised. Call this function on sensitive data
- *              stored on the stack before returning from a function, and on
- *              sensitive data stored on the heap before freeing the heap
- *              object.
- *
- *              It is extremely difficult to guarantee that calls to
- *              mbedtls_platform_zeroize() are not removed by aggressive
- *              compiler optimizations in a portable way. For this reason, Mbed
- *              TLS provides the configuration option
- *              MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
- *              mbedtls_platform_zeroize() to use a suitable implementation for
- *              their platform and needs
- *
- * \param buf   Buffer to be zeroized
- * \param len   Length of the buffer in bytes
- *
- */
-void mbedtls_platform_zeroize( void *buf, size_t len );
-
-#if defined(MBEDTLS_HAVE_TIME_DATE)
-/**
- * \brief      Platform-specific implementation of gmtime_r()
- *
- *             The function is a thread-safe abstraction that behaves
- *             similarly to the gmtime_r() function from Unix/POSIX.
- *
- *             Mbed TLS will try to identify the underlying platform and
- *             make use of an appropriate underlying implementation (e.g.
- *             gmtime_r() for POSIX and gmtime_s() for Windows). If this is
- *             not possible, then gmtime() will be used. In this case, calls
- *             from the library to gmtime() will be guarded by the mutex
- *             mbedtls_threading_gmtime_mutex if MBEDTLS_THREADING_C is
- *             enabled. It is recommended that calls from outside the library
- *             are also guarded by this mutex.
- *
- *             If MBEDTLS_PLATFORM_GMTIME_R_ALT is defined, then Mbed TLS will
- *             unconditionally use the alternative implementation for
- *             mbedtls_platform_gmtime_r() supplied by the user at compile time.
- *
- * \param tt     Pointer to an object containing time (in seconds) since the
- *               epoch to be converted
- * \param tm_buf Pointer to an object where the results will be stored
- *
- * \return      Pointer to an object of type struct tm on success, otherwise
- *              NULL
- */
-struct tm *mbedtls_platform_gmtime_r( const mbedtls_time_t *tt,
-                                      struct tm *tm_buf );
-#endif /* MBEDTLS_HAVE_TIME_DATE */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_PLATFORM_UTIL_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/private_access.h b/src/duckdb/third_party/mbedtls/include/mbedtls/private_access.h
deleted file mode 100644
index 98d3419f6..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/private_access.h
+++ /dev/null
@@ -1,32 +0,0 @@
- /**
- * \file private_access.h
- *
- * \brief Macro wrapper for struct's memebrs.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_PRIVATE_ACCESS_H
-#define MBEDTLS_PRIVATE_ACCESS_H
-
-#ifndef MBEDTLS_ALLOW_PRIVATE_ACCESS
-#define MBEDTLS_PRIVATE(member) private_##member
-#else
-#define MBEDTLS_PRIVATE(member) member
-#endif
-
-#endif /* MBEDTLS_PRIVATE_ACCESS_H */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/psa_util.h b/src/duckdb/third_party/mbedtls/include/mbedtls/psa_util.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/psa_util.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/ripemd160.h b/src/duckdb/third_party/mbedtls/include/mbedtls/ripemd160.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/ripemd160.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/rsa.h b/src/duckdb/third_party/mbedtls/include/mbedtls/rsa.h
deleted file mode 100644
index d03c31d71..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/rsa.h
+++ /dev/null
@@ -1,1128 +0,0 @@
-/**
- * \file rsa.h
- *
- * \brief This file provides an API for the RSA public-key cryptosystem.
- *
- * The RSA public-key cryptosystem is defined in <em>Public-Key
- * Cryptography Standards (PKCS) #1 v1.5: RSA Encryption</em>
- * and <em>Public-Key Cryptography Standards (PKCS) #1 v2.1:
- * RSA Cryptography Specifications</em>.
- *
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_RSA_H
-#define MBEDTLS_RSA_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/bignum.h"
-#include "mbedtls/md.h"
-
-#if defined(MBEDTLS_THREADING_C)
-#include "mbedtls/threading.h"
-#endif
-
-/*
- * RSA Error codes
- */
-/** Bad input parameters to function. */
-#define MBEDTLS_ERR_RSA_BAD_INPUT_DATA                    -0x4080
-/** Input data contains invalid padding and is rejected. */
-#define MBEDTLS_ERR_RSA_INVALID_PADDING                   -0x4100
-/** Something failed during generation of a key. */
-#define MBEDTLS_ERR_RSA_KEY_GEN_FAILED                    -0x4180
-/** Key failed to pass the validity check of the library. */
-#define MBEDTLS_ERR_RSA_KEY_CHECK_FAILED                  -0x4200
-/** The public key operation failed. */
-#define MBEDTLS_ERR_RSA_PUBLIC_FAILED                     -0x4280
-/** The private key operation failed. */
-#define MBEDTLS_ERR_RSA_PRIVATE_FAILED                    -0x4300
-/** The PKCS#1 verification failed. */
-#define MBEDTLS_ERR_RSA_VERIFY_FAILED                     -0x4380
-/** The output buffer for decryption is not large enough. */
-#define MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE                  -0x4400
-/** The random generator failed to generate non-zeros. */
-#define MBEDTLS_ERR_RSA_RNG_FAILED                        -0x4480
-
-/*
- * RSA constants
- */
-
-#define MBEDTLS_RSA_PKCS_V15    0 /**< Use PKCS#1 v1.5 encoding. */
-#define MBEDTLS_RSA_PKCS_V21    1 /**< Use PKCS#1 v2.1 encoding. */
-
-#define MBEDTLS_RSA_SIGN        1 /**< Identifier for RSA signature operations. */
-#define MBEDTLS_RSA_CRYPT       2 /**< Identifier for RSA encryption and decryption operations. */
-
-#define MBEDTLS_RSA_SALT_LEN_ANY    -1
-
-/*
- * The above constants may be used even if the RSA module is compile out,
- * eg for alternative (PKCS#11) RSA implemenations in the PK layers.
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_RSA_ALT)
-// Regular implementation
-//
-
-/**
- * \brief   The RSA context structure.
- */
-typedef struct mbedtls_rsa_context
-{
-    int MBEDTLS_PRIVATE(ver);                    /*!<  Reserved for internal purposes.
-                                 *    Do not set this field in application
-                                 *    code. Its meaning might change without
-                                 *    notice. */
-    size_t MBEDTLS_PRIVATE(len);                 /*!<  The size of \p N in Bytes. */
-
-    mbedtls_mpi MBEDTLS_PRIVATE(N);              /*!<  The public modulus. */
-    mbedtls_mpi MBEDTLS_PRIVATE(E);              /*!<  The public exponent. */
-
-    mbedtls_mpi MBEDTLS_PRIVATE(D);              /*!<  The private exponent. */
-    mbedtls_mpi MBEDTLS_PRIVATE(P);              /*!<  The first prime factor. */
-    mbedtls_mpi MBEDTLS_PRIVATE(Q);              /*!<  The second prime factor. */
-
-    mbedtls_mpi MBEDTLS_PRIVATE(DP);             /*!<  <code>D % (P - 1)</code>. */
-    mbedtls_mpi MBEDTLS_PRIVATE(DQ);             /*!<  <code>D % (Q - 1)</code>. */
-    mbedtls_mpi MBEDTLS_PRIVATE(QP);             /*!<  <code>1 / (Q % P)</code>. */
-
-    mbedtls_mpi MBEDTLS_PRIVATE(RN);             /*!<  cached <code>R^2 mod N</code>. */
-
-    mbedtls_mpi MBEDTLS_PRIVATE(RP);             /*!<  cached <code>R^2 mod P</code>. */
-    mbedtls_mpi MBEDTLS_PRIVATE(RQ);             /*!<  cached <code>R^2 mod Q</code>. */
-
-    mbedtls_mpi MBEDTLS_PRIVATE(Vi);             /*!<  The cached blinding value. */
-    mbedtls_mpi MBEDTLS_PRIVATE(Vf);             /*!<  The cached un-blinding value. */
-
-    int MBEDTLS_PRIVATE(padding);                /*!< Selects padding mode:
-                                     #MBEDTLS_RSA_PKCS_V15 for 1.5 padding and
-                                     #MBEDTLS_RSA_PKCS_V21 for OAEP or PSS. */
-    int MBEDTLS_PRIVATE(hash_id);                /*!< Hash identifier of mbedtls_md_type_t type,
-                                     as specified in md.h for use in the MGF
-                                     mask generating function used in the
-                                     EME-OAEP and EMSA-PSS encodings. */
-#if defined(MBEDTLS_THREADING_C)
-    /* Invariant: the mutex is initialized iff ver != 0. */
-    mbedtls_threading_mutex_t MBEDTLS_PRIVATE(mutex);    /*!<  Thread-safety mutex. */
-#endif
-}
-mbedtls_rsa_context;
-
-#else  /* MBEDTLS_RSA_ALT */
-#include "rsa_alt.h"
-#endif /* MBEDTLS_RSA_ALT */
-
-/**
- * \brief          This function initializes an RSA context.
- *
- * \note           This function initializes the padding and the hash
- *                 identifier to respectively #MBEDTLS_RSA_PKCS_V15 and
- *                 #MBEDTLS_MD_NONE. See mbedtls_rsa_set_padding() for more
- *                 information about those parameters.
- *
- * \param ctx      The RSA context to initialize. This must not be \c NULL.
- */
-void mbedtls_rsa_init( mbedtls_rsa_context *ctx );
-
-/**
- * \brief          This function sets padding for an already initialized RSA
- *                 context.
- *
- * \note           Set padding to #MBEDTLS_RSA_PKCS_V21 for the RSAES-OAEP
- *                 encryption scheme and the RSASSA-PSS signature scheme.
- *
- * \note           The \p hash_id parameter is ignored when using
- *                 #MBEDTLS_RSA_PKCS_V15 padding.
- *
- * \note           The choice of padding mode is strictly enforced for private
- *                 key operations, since there might be security concerns in
- *                 mixing padding modes. For public key operations it is
- *                 a default value, which can be overridden by calling specific
- *                 \c mbedtls_rsa_rsaes_xxx or \c mbedtls_rsa_rsassa_xxx
- *                 functions.
- *
- * \note           The hash selected in \p hash_id is always used for OEAP
- *                 encryption. For PSS signatures, it is always used for
- *                 making signatures, but can be overridden for verifying them.
- *                 If set to #MBEDTLS_MD_NONE, it is always overridden.
- *
- * \param ctx      The initialized RSA context to be configured.
- * \param padding  The padding mode to use. This must be either
- *                 #MBEDTLS_RSA_PKCS_V15 or #MBEDTLS_RSA_PKCS_V21.
- * \param hash_id  The hash identifier for PSS or OAEP, if \p padding is
- *                 #MBEDTLS_RSA_PKCS_V21. #MBEDTLS_MD_NONE is accepted by this
- *                 function but may be not suitable for some operations.
- *                 Ignored if \p padding is #MBEDTLS_RSA_PKCS_V15.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_RSA_INVALID_PADDING failure:
- *                 \p padding or \p hash_id is invalid.
- */
-int mbedtls_rsa_set_padding( mbedtls_rsa_context *ctx, int padding,
-                             mbedtls_md_type_t hash_id );
-
-/**
- * \brief          This function imports a set of core parameters into an
- *                 RSA context.
- *
- * \note           This function can be called multiple times for successive
- *                 imports, if the parameters are not simultaneously present.
- *
- *                 Any sequence of calls to this function should be followed
- *                 by a call to mbedtls_rsa_complete(), which checks and
- *                 completes the provided information to a ready-for-use
- *                 public or private RSA key.
- *
- * \note           See mbedtls_rsa_complete() for more information on which
- *                 parameters are necessary to set up a private or public
- *                 RSA key.
- *
- * \note           The imported parameters are copied and need not be preserved
- *                 for the lifetime of the RSA context being set up.
- *
- * \param ctx      The initialized RSA context to store the parameters in.
- * \param N        The RSA modulus. This may be \c NULL.
- * \param P        The first prime factor of \p N. This may be \c NULL.
- * \param Q        The second prime factor of \p N. This may be \c NULL.
- * \param D        The private exponent. This may be \c NULL.
- * \param E        The public exponent. This may be \c NULL.
- *
- * \return         \c 0 on success.
- * \return         A non-zero error code on failure.
- */
-int mbedtls_rsa_import( mbedtls_rsa_context *ctx,
-                        const mbedtls_mpi *N,
-                        const mbedtls_mpi *P, const mbedtls_mpi *Q,
-                        const mbedtls_mpi *D, const mbedtls_mpi *E );
-
-/**
- * \brief          This function imports core RSA parameters, in raw big-endian
- *                 binary format, into an RSA context.
- *
- * \note           This function can be called multiple times for successive
- *                 imports, if the parameters are not simultaneously present.
- *
- *                 Any sequence of calls to this function should be followed
- *                 by a call to mbedtls_rsa_complete(), which checks and
- *                 completes the provided information to a ready-for-use
- *                 public or private RSA key.
- *
- * \note           See mbedtls_rsa_complete() for more information on which
- *                 parameters are necessary to set up a private or public
- *                 RSA key.
- *
- * \note           The imported parameters are copied and need not be preserved
- *                 for the lifetime of the RSA context being set up.
- *
- * \param ctx      The initialized RSA context to store the parameters in.
- * \param N        The RSA modulus. This may be \c NULL.
- * \param N_len    The Byte length of \p N; it is ignored if \p N == NULL.
- * \param P        The first prime factor of \p N. This may be \c NULL.
- * \param P_len    The Byte length of \p P; it ns ignored if \p P == NULL.
- * \param Q        The second prime factor of \p N. This may be \c NULL.
- * \param Q_len    The Byte length of \p Q; it is ignored if \p Q == NULL.
- * \param D        The private exponent. This may be \c NULL.
- * \param D_len    The Byte length of \p D; it is ignored if \p D == NULL.
- * \param E        The public exponent. This may be \c NULL.
- * \param E_len    The Byte length of \p E; it is ignored if \p E == NULL.
- *
- * \return         \c 0 on success.
- * \return         A non-zero error code on failure.
- */
-int mbedtls_rsa_import_raw( mbedtls_rsa_context *ctx,
-                            unsigned char const *N, size_t N_len,
-                            unsigned char const *P, size_t P_len,
-                            unsigned char const *Q, size_t Q_len,
-                            unsigned char const *D, size_t D_len,
-                            unsigned char const *E, size_t E_len );
-
-/**
- * \brief          This function completes an RSA context from
- *                 a set of imported core parameters.
- *
- *                 To setup an RSA public key, precisely \p N and \p E
- *                 must have been imported.
- *
- *                 To setup an RSA private key, sufficient information must
- *                 be present for the other parameters to be derivable.
- *
- *                 The default implementation supports the following:
- *                 <ul><li>Derive \p P, \p Q from \p N, \p D, \p E.</li>
- *                 <li>Derive \p N, \p D from \p P, \p Q, \p E.</li></ul>
- *                 Alternative implementations need not support these.
- *
- *                 If this function runs successfully, it guarantees that
- *                 the RSA context can be used for RSA operations without
- *                 the risk of failure or crash.
- *
- * \warning        This function need not perform consistency checks
- *                 for the imported parameters. In particular, parameters that
- *                 are not needed by the implementation might be silently
- *                 discarded and left unchecked. To check the consistency
- *                 of the key material, see mbedtls_rsa_check_privkey().
- *
- * \param ctx      The initialized RSA context holding imported parameters.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_RSA_BAD_INPUT_DATA if the attempted derivations
- *                 failed.
- *
- */
-int mbedtls_rsa_complete( mbedtls_rsa_context *ctx );
-
-/**
- * \brief          This function exports the core parameters of an RSA key.
- *
- *                 If this function runs successfully, the non-NULL buffers
- *                 pointed to by \p N, \p P, \p Q, \p D, and \p E are fully
- *                 written, with additional unused space filled leading by
- *                 zero Bytes.
- *
- *                 Possible reasons for returning
- *                 #MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED:<ul>
- *                 <li>An alternative RSA implementation is in use, which
- *                 stores the key externally, and either cannot or should
- *                 not export it into RAM.</li>
- *                 <li>A SW or HW implementation might not support a certain
- *                 deduction. For example, \p P, \p Q from \p N, \p D,
- *                 and \p E if the former are not part of the
- *                 implementation.</li></ul>
- *
- *                 If the function fails due to an unsupported operation,
- *                 the RSA context stays intact and remains usable.
- *
- * \param ctx      The initialized RSA context.
- * \param N        The MPI to hold the RSA modulus.
- *                 This may be \c NULL if this field need not be exported.
- * \param P        The MPI to hold the first prime factor of \p N.
- *                 This may be \c NULL if this field need not be exported.
- * \param Q        The MPI to hold the second prime factor of \p N.
- *                 This may be \c NULL if this field need not be exported.
- * \param D        The MPI to hold the private exponent.
- *                 This may be \c NULL if this field need not be exported.
- * \param E        The MPI to hold the public exponent.
- *                 This may be \c NULL if this field need not be exported.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED if exporting the
- *                 requested parameters cannot be done due to missing
- *                 functionality or because of security policies.
- * \return         A non-zero return code on any other failure.
- *
- */
-int mbedtls_rsa_export( const mbedtls_rsa_context *ctx,
-                        mbedtls_mpi *N, mbedtls_mpi *P, mbedtls_mpi *Q,
-                        mbedtls_mpi *D, mbedtls_mpi *E );
-
-/**
- * \brief          This function exports core parameters of an RSA key
- *                 in raw big-endian binary format.
- *
- *                 If this function runs successfully, the non-NULL buffers
- *                 pointed to by \p N, \p P, \p Q, \p D, and \p E are fully
- *                 written, with additional unused space filled leading by
- *                 zero Bytes.
- *
- *                 Possible reasons for returning
- *                 #MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED:<ul>
- *                 <li>An alternative RSA implementation is in use, which
- *                 stores the key externally, and either cannot or should
- *                 not export it into RAM.</li>
- *                 <li>A SW or HW implementation might not support a certain
- *                 deduction. For example, \p P, \p Q from \p N, \p D,
- *                 and \p E if the former are not part of the
- *                 implementation.</li></ul>
- *                 If the function fails due to an unsupported operation,
- *                 the RSA context stays intact and remains usable.
- *
- * \note           The length parameters are ignored if the corresponding
- *                 buffer pointers are NULL.
- *
- * \param ctx      The initialized RSA context.
- * \param N        The Byte array to store the RSA modulus,
- *                 or \c NULL if this field need not be exported.
- * \param N_len    The size of the buffer for the modulus.
- * \param P        The Byte array to hold the first prime factor of \p N,
- *                 or \c NULL if this field need not be exported.
- * \param P_len    The size of the buffer for the first prime factor.
- * \param Q        The Byte array to hold the second prime factor of \p N,
- *                 or \c NULL if this field need not be exported.
- * \param Q_len    The size of the buffer for the second prime factor.
- * \param D        The Byte array to hold the private exponent,
- *                 or \c NULL if this field need not be exported.
- * \param D_len    The size of the buffer for the private exponent.
- * \param E        The Byte array to hold the public exponent,
- *                 or \c NULL if this field need not be exported.
- * \param E_len    The size of the buffer for the public exponent.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED if exporting the
- *                 requested parameters cannot be done due to missing
- *                 functionality or because of security policies.
- * \return         A non-zero return code on any other failure.
- */
-int mbedtls_rsa_export_raw( const mbedtls_rsa_context *ctx,
-                            unsigned char *N, size_t N_len,
-                            unsigned char *P, size_t P_len,
-                            unsigned char *Q, size_t Q_len,
-                            unsigned char *D, size_t D_len,
-                            unsigned char *E, size_t E_len );
-
-/**
- * \brief          This function exports CRT parameters of a private RSA key.
- *
- * \note           Alternative RSA implementations not using CRT-parameters
- *                 internally can implement this function based on
- *                 mbedtls_rsa_deduce_opt().
- *
- * \param ctx      The initialized RSA context.
- * \param DP       The MPI to hold \c D modulo `P-1`,
- *                 or \c NULL if it need not be exported.
- * \param DQ       The MPI to hold \c D modulo `Q-1`,
- *                 or \c NULL if it need not be exported.
- * \param QP       The MPI to hold modular inverse of \c Q modulo \c P,
- *                 or \c NULL if it need not be exported.
- *
- * \return         \c 0 on success.
- * \return         A non-zero error code on failure.
- *
- */
-int mbedtls_rsa_export_crt( const mbedtls_rsa_context *ctx,
-                            mbedtls_mpi *DP, mbedtls_mpi *DQ, mbedtls_mpi *QP );
-
-/**
- * \brief          This function retrieves the length of RSA modulus in Bytes.
- *
- * \param ctx      The initialized RSA context.
- *
- * \return         The length of the RSA modulus in Bytes.
- *
- */
-size_t mbedtls_rsa_get_len( const mbedtls_rsa_context *ctx );
-
-/**
- * \brief          This function generates an RSA keypair.
- *
- * \note           mbedtls_rsa_init() must be called before this function,
- *                 to set up the RSA context.
- *
- * \param ctx      The initialized RSA context used to hold the key.
- * \param f_rng    The RNG function to be used for key generation.
- *                 This is mandatory and must not be \c NULL.
- * \param p_rng    The RNG context to be passed to \p f_rng.
- *                 This may be \c NULL if \p f_rng doesn't need a context.
- * \param nbits    The size of the public key in bits.
- * \param exponent The public exponent to use. For example, \c 65537.
- *                 This must be odd and greater than \c 1.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_gen_key( mbedtls_rsa_context *ctx,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng,
-                         unsigned int nbits, int exponent );
-
-/**
- * \brief          This function checks if a context contains at least an RSA
- *                 public key.
- *
- *                 If the function runs successfully, it is guaranteed that
- *                 enough information is present to perform an RSA public key
- *                 operation using mbedtls_rsa_public().
- *
- * \param ctx      The initialized RSA context to check.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- *
- */
-int mbedtls_rsa_check_pubkey( const mbedtls_rsa_context *ctx );
-
-/**
- * \brief      This function checks if a context contains an RSA private key
- *             and perform basic consistency checks.
- *
- * \note       The consistency checks performed by this function not only
- *             ensure that mbedtls_rsa_private() can be called successfully
- *             on the given context, but that the various parameters are
- *             mutually consistent with high probability, in the sense that
- *             mbedtls_rsa_public() and mbedtls_rsa_private() are inverses.
- *
- * \warning    This function should catch accidental misconfigurations
- *             like swapping of parameters, but it cannot establish full
- *             trust in neither the quality nor the consistency of the key
- *             material that was used to setup the given RSA context:
- *             <ul><li>Consistency: Imported parameters that are irrelevant
- *             for the implementation might be silently dropped. If dropped,
- *             the current function does not have access to them,
- *             and therefore cannot check them. See mbedtls_rsa_complete().
- *             If you want to check the consistency of the entire
- *             content of an PKCS1-encoded RSA private key, for example, you
- *             should use mbedtls_rsa_validate_params() before setting
- *             up the RSA context.
- *             Additionally, if the implementation performs empirical checks,
- *             these checks substantiate but do not guarantee consistency.</li>
- *             <li>Quality: This function is not expected to perform
- *             extended quality assessments like checking that the prime
- *             factors are safe. Additionally, it is the responsibility of the
- *             user to ensure the trustworthiness of the source of his RSA
- *             parameters, which goes beyond what is effectively checkable
- *             by the library.</li></ul>
- *
- * \param ctx  The initialized RSA context to check.
- *
- * \return     \c 0 on success.
- * \return     An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_check_privkey( const mbedtls_rsa_context *ctx );
-
-/**
- * \brief          This function checks a public-private RSA key pair.
- *
- *                 It checks each of the contexts, and makes sure they match.
- *
- * \param pub      The initialized RSA context holding the public key.
- * \param prv      The initialized RSA context holding the private key.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_check_pub_priv( const mbedtls_rsa_context *pub,
-                                const mbedtls_rsa_context *prv );
-
-/**
- * \brief          This function performs an RSA public key operation.
- *
- * \param ctx      The initialized RSA context to use.
- * \param input    The input buffer. This must be a readable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- * \param output   The output buffer. This must be a writable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \note           This function does not handle message padding.
- *
- * \note           Make sure to set \p input[0] = 0 or ensure that
- *                 input is smaller than \p N.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_public( mbedtls_rsa_context *ctx,
-                const unsigned char *input,
-                unsigned char *output );
-
-/**
- * \brief          This function performs an RSA private key operation.
- *
- * \note           Blinding is used if and only if a PRNG is provided.
- *
- * \note           If blinding is used, both the base of exponentation
- *                 and the exponent are blinded, providing protection
- *                 against some side-channel attacks.
- *
- * \warning        It is deprecated and a security risk to not provide
- *                 a PRNG here and thereby prevent the use of blinding.
- *                 Future versions of the library may enforce the presence
- *                 of a PRNG.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function, used for blinding. It is mandatory.
- * \param p_rng    The RNG context to pass to \p f_rng. This may be \c NULL
- *                 if \p f_rng doesn't need a context.
- * \param input    The input buffer. This must be a readable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- * \param output   The output buffer. This must be a writable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- *
- */
-int mbedtls_rsa_private( mbedtls_rsa_context *ctx,
-                 int (*f_rng)(void *, unsigned char *, size_t),
-                 void *p_rng,
-                 const unsigned char *input,
-                 unsigned char *output );
-
-/**
- * \brief          This function adds the message padding, then performs an RSA
- *                 operation.
- *
- *                 It is the generic wrapper for performing a PKCS#1 encryption
- *                 operation.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG to use. It is used for padding generation
- *                 and it is mandatory.
- * \param p_rng    The RNG context to be passed to \p f_rng. May be
- *                 \c NULL if \p f_rng doesn't need a context argument.
- * \param ilen     The length of the plaintext in Bytes.
- * \param input    The input data to encrypt. This must be a readable
- *                 buffer of size \p ilen Bytes. It may be \c NULL if
- *                 `ilen == 0`.
- * \param output   The output buffer. This must be a writable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_pkcs1_encrypt( mbedtls_rsa_context *ctx,
-                       int (*f_rng)(void *, unsigned char *, size_t),
-                       void *p_rng,
-                       size_t ilen,
-                       const unsigned char *input,
-                       unsigned char *output );
-
-/**
- * \brief          This function performs a PKCS#1 v1.5 encryption operation
- *                 (RSAES-PKCS1-v1_5-ENCRYPT).
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function to use. It is mandatory and used for
- *                 padding generation.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may
- *                 be \c NULL if \p f_rng doesn't need a context argument.
- * \param ilen     The length of the plaintext in Bytes.
- * \param input    The input data to encrypt. This must be a readable
- *                 buffer of size \p ilen Bytes. It may be \c NULL if
- *                 `ilen == 0`.
- * \param output   The output buffer. This must be a writable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsaes_pkcs1_v15_encrypt( mbedtls_rsa_context *ctx,
-                                 int (*f_rng)(void *, unsigned char *, size_t),
-                                 void *p_rng,
-                                 size_t ilen,
-                                 const unsigned char *input,
-                                 unsigned char *output );
-
-/**
- * \brief            This function performs a PKCS#1 v2.1 OAEP encryption
- *                   operation (RSAES-OAEP-ENCRYPT).
- *
- * \note             The output buffer must be as large as the size
- *                   of ctx->N. For example, 128 Bytes if RSA-1024 is used.
- *
- * \param ctx        The initnialized RSA context to use.
- * \param f_rng      The RNG function to use. This is needed for padding
- *                   generation and is mandatory.
- * \param p_rng      The RNG context to be passed to \p f_rng. This may
- *                   be \c NULL if \p f_rng doesn't need a context argument.
- * \param label      The buffer holding the custom label to use.
- *                   This must be a readable buffer of length \p label_len
- *                   Bytes. It may be \c NULL if \p label_len is \c 0.
- * \param label_len  The length of the label in Bytes.
- * \param ilen       The length of the plaintext buffer \p input in Bytes.
- * \param input      The input data to encrypt. This must be a readable
- *                   buffer of size \p ilen Bytes. It may be \c NULL if
- *                   `ilen == 0`.
- * \param output     The output buffer. This must be a writable buffer
- *                   of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                   for an 2048-bit RSA modulus.
- *
- * \return           \c 0 on success.
- * \return           An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsaes_oaep_encrypt( mbedtls_rsa_context *ctx,
-                            int (*f_rng)(void *, unsigned char *, size_t),
-                            void *p_rng,
-                            const unsigned char *label, size_t label_len,
-                            size_t ilen,
-                            const unsigned char *input,
-                            unsigned char *output );
-
-/**
- * \brief          This function performs an RSA operation, then removes the
- *                 message padding.
- *
- *                 It is the generic wrapper for performing a PKCS#1 decryption
- *                 operation.
- *
- * \note           The output buffer length \c output_max_len should be
- *                 as large as the size \p ctx->len of \p ctx->N (for example,
- *                 128 Bytes if RSA-1024 is used) to be able to hold an
- *                 arbitrary decrypted message. If it is not large enough to
- *                 hold the decryption of the particular ciphertext provided,
- *                 the function returns \c MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function. This is used for blinding and is
- *                 mandatory; see mbedtls_rsa_private() for more.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may be
- *                 \c NULL if \p f_rng doesn't need a context.
- * \param olen     The address at which to store the length of
- *                 the plaintext. This must not be \c NULL.
- * \param input    The ciphertext buffer. This must be a readable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- * \param output   The buffer used to hold the plaintext. This must
- *                 be a writable buffer of length \p output_max_len Bytes.
- * \param output_max_len The length in Bytes of the output buffer \p output.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
-                       int (*f_rng)(void *, unsigned char *, size_t),
-                       void *p_rng,
-                       size_t *olen,
-                       const unsigned char *input,
-                       unsigned char *output,
-                       size_t output_max_len );
-
-/**
- * \brief          This function performs a PKCS#1 v1.5 decryption
- *                 operation (RSAES-PKCS1-v1_5-DECRYPT).
- *
- * \note           The output buffer length \c output_max_len should be
- *                 as large as the size \p ctx->len of \p ctx->N, for example,
- *                 128 Bytes if RSA-1024 is used, to be able to hold an
- *                 arbitrary decrypted message. If it is not large enough to
- *                 hold the decryption of the particular ciphertext provided,
- *                 the function returns #MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function. This is used for blinding and is
- *                 mandatory; see mbedtls_rsa_private() for more.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may be
- *                 \c NULL if \p f_rng doesn't need a context.
- * \param olen     The address at which to store the length of
- *                 the plaintext. This must not be \c NULL.
- * \param input    The ciphertext buffer. This must be a readable buffer
- *                 of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- * \param output   The buffer used to hold the plaintext. This must
- *                 be a writable buffer of length \p output_max_len Bytes.
- * \param output_max_len The length in Bytes of the output buffer \p output.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- *
- */
-int mbedtls_rsa_rsaes_pkcs1_v15_decrypt( mbedtls_rsa_context *ctx,
-                                 int (*f_rng)(void *, unsigned char *, size_t),
-                                 void *p_rng,
-                                 size_t *olen,
-                                 const unsigned char *input,
-                                 unsigned char *output,
-                                 size_t output_max_len );
-
-/**
- * \brief            This function performs a PKCS#1 v2.1 OAEP decryption
- *                   operation (RSAES-OAEP-DECRYPT).
- *
- * \note             The output buffer length \c output_max_len should be
- *                   as large as the size \p ctx->len of \p ctx->N, for
- *                   example, 128 Bytes if RSA-1024 is used, to be able to
- *                   hold an arbitrary decrypted message. If it is not
- *                   large enough to hold the decryption of the particular
- *                   ciphertext provided, the function returns
- *                   #MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE.
- *
- * \param ctx        The initialized RSA context to use.
- * \param f_rng      The RNG function. This is used for blinding and is
- *                   mandatory.
- * \param p_rng      The RNG context to be passed to \p f_rng. This may be
- *                   \c NULL if \p f_rng doesn't need a context.
- * \param label      The buffer holding the custom label to use.
- *                   This must be a readable buffer of length \p label_len
- *                   Bytes. It may be \c NULL if \p label_len is \c 0.
- * \param label_len  The length of the label in Bytes.
- * \param olen       The address at which to store the length of
- *                   the plaintext. This must not be \c NULL.
- * \param input      The ciphertext buffer. This must be a readable buffer
- *                   of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                   for an 2048-bit RSA modulus.
- * \param output     The buffer used to hold the plaintext. This must
- *                   be a writable buffer of length \p output_max_len Bytes.
- * \param output_max_len The length in Bytes of the output buffer \p output.
- *
- * \return         \c 0 on success.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsaes_oaep_decrypt( mbedtls_rsa_context *ctx,
-                            int (*f_rng)(void *, unsigned char *, size_t),
-                            void *p_rng,
-                            const unsigned char *label, size_t label_len,
-                            size_t *olen,
-                            const unsigned char *input,
-                            unsigned char *output,
-                            size_t output_max_len );
-
-/**
- * \brief          This function performs a private RSA operation to sign
- *                 a message digest using PKCS#1.
- *
- *                 It is the generic wrapper for performing a PKCS#1
- *                 signature.
- *
- * \note           The \p sig buffer must be as large as the size
- *                 of \p ctx->N. For example, 128 Bytes if RSA-1024 is used.
- *
- * \note           For PKCS#1 v2.1 encoding, see comments on
- *                 mbedtls_rsa_rsassa_pss_sign() for details on
- *                 \p md_alg and \p hash_id.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function to use. This is mandatory and
- *                 must not be \c NULL.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may be \c NULL
- *                 if \p f_rng doesn't need a context argument.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param sig      The buffer to hold the signature. This must be a writable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus. A buffer length of
- *                 #MBEDTLS_MPI_MAX_SIZE is always safe.
- *
- * \return         \c 0 if the signing operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_pkcs1_sign( mbedtls_rsa_context *ctx,
-                    int (*f_rng)(void *, unsigned char *, size_t),
-                    void *p_rng,
-                    mbedtls_md_type_t md_alg,
-                    unsigned int hashlen,
-                    const unsigned char *hash,
-                    unsigned char *sig );
-
-/**
- * \brief          This function performs a PKCS#1 v1.5 signature
- *                 operation (RSASSA-PKCS1-v1_5-SIGN).
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function. This is used for blinding and is
- *                 mandatory; see mbedtls_rsa_private() for more.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may be \c NULL
- *                 if \p f_rng doesn't need a context argument.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param sig      The buffer to hold the signature. This must be a writable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus. A buffer length of
- *                 #MBEDTLS_MPI_MAX_SIZE is always safe.
- *
- * \return         \c 0 if the signing operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsassa_pkcs1_v15_sign( mbedtls_rsa_context *ctx,
-                               int (*f_rng)(void *, unsigned char *, size_t),
-                               void *p_rng,
-                               mbedtls_md_type_t md_alg,
-                               unsigned int hashlen,
-                               const unsigned char *hash,
-                               unsigned char *sig );
-
-/**
- * \brief          This function performs a PKCS#1 v2.1 PSS signature
- *                 operation (RSASSA-PSS-SIGN).
- *
- * \note           The \c hash_id set in \p ctx by calling
- *                 mbedtls_rsa_set_padding() selects the hash used for the
- *                 encoding operation and for the mask generation function
- *                 (MGF1). For more details on the encoding operation and the
- *                 mask generation function, consult <em>RFC-3447: Public-Key
- *                 Cryptography Standards (PKCS) #1 v2.1: RSA Cryptography
- *                 Specifications</em>.
- *
- * \note           This function enforces that the provided salt length complies
- *                 with FIPS 186-4 §5.5 (e) and RFC 8017 (PKCS#1 v2.2) §9.1.1
- *                 step 3. The constraint is that the hash length plus the salt
- *                 length plus 2 bytes must be at most the key length. If this
- *                 constraint is not met, this function returns
- *                 #MBEDTLS_ERR_RSA_BAD_INPUT_DATA.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function. It is mandatory and must not be \c NULL.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may be \c NULL
- *                 if \p f_rng doesn't need a context argument.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param saltlen  The length of the salt that should be used.
- *                 If passed #MBEDTLS_RSA_SALT_LEN_ANY, the function will use
- *                 the largest possible salt length up to the hash length,
- *                 which is the largest permitted by some standards including
- *                 FIPS 186-4 §5.5.
- * \param sig      The buffer to hold the signature. This must be a writable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus. A buffer length of
- *                 #MBEDTLS_MPI_MAX_SIZE is always safe.
- *
- * \return         \c 0 if the signing operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsassa_pss_sign_ext( mbedtls_rsa_context *ctx,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng,
-                         mbedtls_md_type_t md_alg,
-                         unsigned int hashlen,
-                         const unsigned char *hash,
-                         int saltlen,
-                         unsigned char *sig );
-
-/**
- * \brief          This function performs a PKCS#1 v2.1 PSS signature
- *                 operation (RSASSA-PSS-SIGN).
- *
- * \note           The \c hash_id set in \p ctx by calling
- *                 mbedtls_rsa_set_padding() selects the hash used for the
- *                 encoding operation and for the mask generation function
- *                 (MGF1). For more details on the encoding operation and the
- *                 mask generation function, consult <em>RFC-3447: Public-Key
- *                 Cryptography Standards (PKCS) #1 v2.1: RSA Cryptography
- *                 Specifications</em>.
- *
- * \note           This function always uses the maximum possible salt size,
- *                 up to the length of the payload hash. This choice of salt
- *                 size complies with FIPS 186-4 §5.5 (e) and RFC 8017 (PKCS#1
- *                 v2.2) §9.1.1 step 3. Furthermore this function enforces a
- *                 minimum salt size which is the hash size minus 2 bytes. If
- *                 this minimum size is too large given the key size (the salt
- *                 size, plus the hash size, plus 2 bytes must be no more than
- *                 the key size in bytes), this function returns
- *                 #MBEDTLS_ERR_RSA_BAD_INPUT_DATA.
- *
- * \param ctx      The initialized RSA context to use.
- * \param f_rng    The RNG function. It is mandatory and must not be \c NULL.
- * \param p_rng    The RNG context to be passed to \p f_rng. This may be \c NULL
- *                 if \p f_rng doesn't need a context argument.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param sig      The buffer to hold the signature. This must be a writable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus. A buffer length of
- *                 #MBEDTLS_MPI_MAX_SIZE is always safe.
- *
- * \return         \c 0 if the signing operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsassa_pss_sign( mbedtls_rsa_context *ctx,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng,
-                         mbedtls_md_type_t md_alg,
-                         unsigned int hashlen,
-                         const unsigned char *hash,
-                         unsigned char *sig );
-
-/**
- * \brief          This function performs a public RSA operation and checks
- *                 the message digest.
- *
- *                 This is the generic wrapper for performing a PKCS#1
- *                 verification.
- *
- * \note           For PKCS#1 v2.1 encoding, see comments on
- *                 mbedtls_rsa_rsassa_pss_verify() about \p md_alg and
- *                 \p hash_id.
- *
- * \param ctx      The initialized RSA public key context to use.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param sig      The buffer holding the signature. This must be a readable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 if the verify operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_pkcs1_verify( mbedtls_rsa_context *ctx,
-                      mbedtls_md_type_t md_alg,
-                      unsigned int hashlen,
-                      const unsigned char *hash,
-                      const unsigned char *sig );
-
-/**
- * \brief          This function performs a PKCS#1 v1.5 verification
- *                 operation (RSASSA-PKCS1-v1_5-VERIFY).
- *
- * \param ctx      The initialized RSA public key context to use.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param sig      The buffer holding the signature. This must be a readable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 if the verify operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsassa_pkcs1_v15_verify( mbedtls_rsa_context *ctx,
-                                 mbedtls_md_type_t md_alg,
-                                 unsigned int hashlen,
-                                 const unsigned char *hash,
-                                 const unsigned char *sig );
-
-/**
- * \brief          This function performs a PKCS#1 v2.1 PSS verification
- *                 operation (RSASSA-PSS-VERIFY).
- *
- * \note           The \c hash_id set in \p ctx by calling
- *                 mbedtls_rsa_set_padding() selects the hash used for the
- *                 encoding operation and for the mask generation function
- *                 (MGF1). For more details on the encoding operation and the
- *                 mask generation function, consult <em>RFC-3447: Public-Key
- *                 Cryptography Standards (PKCS) #1 v2.1: RSA Cryptography
- *                 Specifications</em>. If the \c hash_id set in \p ctx by
- *                 mbedtls_rsa_set_padding() is #MBEDTLS_MD_NONE, the \p md_alg
- *                 parameter is used.
- *
- * \param ctx      The initialized RSA public key context to use.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param sig      The buffer holding the signature. This must be a readable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 if the verify operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsassa_pss_verify( mbedtls_rsa_context *ctx,
-                           mbedtls_md_type_t md_alg,
-                           unsigned int hashlen,
-                           const unsigned char *hash,
-                           const unsigned char *sig );
-
-/**
- * \brief          This function performs a PKCS#1 v2.1 PSS verification
- *                 operation (RSASSA-PSS-VERIFY).
- *
- * \note           The \p sig buffer must be as large as the size
- *                 of \p ctx->N. For example, 128 Bytes if RSA-1024 is used.
- *
- * \note           The \c hash_id set in \p ctx by mbedtls_rsa_set_padding() is
- *                 ignored.
- *
- * \param ctx      The initialized RSA public key context to use.
- * \param md_alg   The message-digest algorithm used to hash the original data.
- *                 Use #MBEDTLS_MD_NONE for signing raw data.
- * \param hashlen  The length of the message digest or raw data in Bytes.
- *                 If \p md_alg is not #MBEDTLS_MD_NONE, this must match the
- *                 output length of the corresponding hash algorithm.
- * \param hash     The buffer holding the message digest or raw data.
- *                 This must be a readable buffer of at least \p hashlen Bytes.
- * \param mgf1_hash_id      The message digest algorithm used for the
- *                          verification operation and the mask generation
- *                          function (MGF1). For more details on the encoding
- *                          operation and the mask generation function, consult
- *                          <em>RFC-3447: Public-Key Cryptography Standards
- *                          (PKCS) #1 v2.1: RSA Cryptography
- *                          Specifications</em>.
- * \param expected_salt_len The length of the salt used in padding. Use
- *                          #MBEDTLS_RSA_SALT_LEN_ANY to accept any salt length.
- * \param sig      The buffer holding the signature. This must be a readable
- *                 buffer of length \c ctx->len Bytes. For example, \c 256 Bytes
- *                 for an 2048-bit RSA modulus.
- *
- * \return         \c 0 if the verify operation was successful.
- * \return         An \c MBEDTLS_ERR_RSA_XXX error code on failure.
- */
-int mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_rsa_context *ctx,
-                               mbedtls_md_type_t md_alg,
-                               unsigned int hashlen,
-                               const unsigned char *hash,
-                               mbedtls_md_type_t mgf1_hash_id,
-                               int expected_salt_len,
-                               const unsigned char *sig );
-
-/**
- * \brief          This function copies the components of an RSA context.
- *
- * \param dst      The destination context. This must be initialized.
- * \param src      The source context. This must be initialized.
- *
- * \return         \c 0 on success.
- * \return         #MBEDTLS_ERR_MPI_ALLOC_FAILED on memory allocation failure.
- */
-int mbedtls_rsa_copy( mbedtls_rsa_context *dst, const mbedtls_rsa_context *src );
-
-/**
- * \brief          This function frees the components of an RSA key.
- *
- * \param ctx      The RSA context to free. May be \c NULL, in which case
- *                 this function is a no-op. If it is not \c NULL, it must
- *                 point to an initialized RSA context.
- */
-void mbedtls_rsa_free( mbedtls_rsa_context *ctx );
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          The RSA checkup routine.
- *
- * \return         \c 0 on success.
- * \return         \c 1 on failure.
- */
-int mbedtls_rsa_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* rsa.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/sha1.h b/src/duckdb/third_party/mbedtls/include/mbedtls/sha1.h
deleted file mode 100644
index 6b55174a5..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/sha1.h
+++ /dev/null
@@ -1,232 +0,0 @@
-/**
- * \file sha1.h
- *
- * \brief This file contains SHA-1 definitions and functions.
- *
- * The Secure Hash Algorithm 1 (SHA-1) cryptographic hash function is defined in
- * <em>FIPS 180-4: Secure Hash Standard (SHS)</em>.
- *
- * \warning   SHA-1 is considered a weak message digest and its use constitutes
- *            a security risk. We recommend considering stronger message
- *            digests instead.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_SHA1_H
-#define MBEDTLS_SHA1_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-/** SHA-1 input data was malformed. */
-#define MBEDTLS_ERR_SHA1_BAD_INPUT_DATA                   -0x0073
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_SHA1_ALT)
-// Regular implementation
-//
-
-/**
- * \brief          The SHA-1 context structure.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- */
-typedef struct mbedtls_sha1_context
-{
-    uint32_t MBEDTLS_PRIVATE(total)[2];          /*!< The number of Bytes processed.  */
-    uint32_t MBEDTLS_PRIVATE(state)[5];          /*!< The intermediate digest state.  */
-    unsigned char MBEDTLS_PRIVATE(buffer)[64];   /*!< The data block being processed. */
-}
-mbedtls_sha1_context;
-
-#else  /* MBEDTLS_SHA1_ALT */
-#include "sha1_alt.h"
-#endif /* MBEDTLS_SHA1_ALT */
-
-/**
- * \brief          This function initializes a SHA-1 context.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param ctx      The SHA-1 context to initialize.
- *                 This must not be \c NULL.
- *
- */
-void mbedtls_sha1_init( mbedtls_sha1_context *ctx );
-
-/**
- * \brief          This function clears a SHA-1 context.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param ctx      The SHA-1 context to clear. This may be \c NULL,
- *                 in which case this function does nothing. If it is
- *                 not \c NULL, it must point to an initialized
- *                 SHA-1 context.
- *
- */
-void mbedtls_sha1_free( mbedtls_sha1_context *ctx );
-
-/**
- * \brief          This function clones the state of a SHA-1 context.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param dst      The SHA-1 context to clone to. This must be initialized.
- * \param src      The SHA-1 context to clone from. This must be initialized.
- *
- */
-void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
-                         const mbedtls_sha1_context *src );
-
-/**
- * \brief          This function starts a SHA-1 checksum calculation.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param ctx      The SHA-1 context to initialize. This must be initialized.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- *
- */
-int mbedtls_sha1_starts( mbedtls_sha1_context *ctx );
-
-/**
- * \brief          This function feeds an input buffer into an ongoing SHA-1
- *                 checksum calculation.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param ctx      The SHA-1 context. This must be initialized
- *                 and have a hash operation started.
- * \param input    The buffer holding the input data.
- *                 This must be a readable buffer of length \p ilen Bytes.
- * \param ilen     The length of the input data \p input in Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha1_update( mbedtls_sha1_context *ctx,
-                         const unsigned char *input,
-                         size_t ilen );
-
-/**
- * \brief          This function finishes the SHA-1 operation, and writes
- *                 the result to the output buffer.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param ctx      The SHA-1 context to use. This must be initialized and
- *                 have a hash operation started.
- * \param output   The SHA-1 checksum result. This must be a writable
- *                 buffer of length \c 20 Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha1_finish( mbedtls_sha1_context *ctx,
-                         unsigned char output[20] );
-
-/**
- * \brief          SHA-1 process data block (internal use only).
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param ctx      The SHA-1 context to use. This must be initialized.
- * \param data     The data block being processed. This must be a
- *                 readable buffer of length \c 64 Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- *
- */
-int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
-                                   const unsigned char data[64] );
-
-/**
- * \brief          This function calculates the SHA-1 checksum of a buffer.
- *
- *                 The function allocates the context, performs the
- *                 calculation, and frees the context.
- *
- *                 The SHA-1 result is calculated as
- *                 output = SHA-1(input buffer).
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \param input    The buffer holding the input data.
- *                 This must be a readable buffer of length \p ilen Bytes.
- * \param ilen     The length of the input data \p input in Bytes.
- * \param output   The SHA-1 checksum result.
- *                 This must be a writable buffer of length \c 20 Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- *
- */
-int mbedtls_sha1( const unsigned char *input,
-                  size_t ilen,
-                  unsigned char output[20] );
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          The SHA-1 checkup routine.
- *
- * \warning        SHA-1 is considered a weak message digest and its use
- *                 constitutes a security risk. We recommend considering
- *                 stronger message digests instead.
- *
- * \return         \c 0 on success.
- * \return         \c 1 on failure.
- *
- */
-int mbedtls_sha1_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* mbedtls_sha1.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/sha256.h b/src/duckdb/third_party/mbedtls/include/mbedtls/sha256.h
deleted file mode 100644
index 0cbbac11f..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/sha256.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/**
- * \file sha256.h
- *
- * \brief This file contains SHA-224 and SHA-256 definitions and functions.
- *
- * The Secure Hash Algorithms 224 and 256 (SHA-224 and SHA-256) cryptographic
- * hash functions are defined in <em>FIPS 180-4: Secure Hash Standard (SHS)</em>.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_SHA256_H
-#define MBEDTLS_SHA256_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-/** SHA-256 input data was malformed. */
-#define MBEDTLS_ERR_SHA256_BAD_INPUT_DATA                 -0x0074
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_SHA256_ALT)
-// Regular implementation
-//
-
-/**
- * \brief          The SHA-256 context structure.
- *
- *                 The structure is used both for SHA-256 and for SHA-224
- *                 checksum calculations. The choice between these two is
- *                 made in the call to mbedtls_sha256_starts().
- */
-typedef struct mbedtls_sha256_context
-{
-    uint32_t MBEDTLS_PRIVATE(total)[2];          /*!< The number of Bytes processed.  */
-    uint32_t MBEDTLS_PRIVATE(state)[8];          /*!< The intermediate digest state.  */
-    unsigned char MBEDTLS_PRIVATE(buffer)[64];   /*!< The data block being processed. */
-    int MBEDTLS_PRIVATE(is224);                  /*!< Determines which function to use:
-                                     0: Use SHA-256, or 1: Use SHA-224. */
-}
-mbedtls_sha256_context;
-
-#else  /* MBEDTLS_SHA256_ALT */
-#include "sha256_alt.h"
-#endif /* MBEDTLS_SHA256_ALT */
-
-/**
- * \brief          This function initializes a SHA-256 context.
- *
- * \param ctx      The SHA-256 context to initialize. This must not be \c NULL.
- */
-void mbedtls_sha256_init( mbedtls_sha256_context *ctx );
-
-/**
- * \brief          This function clears a SHA-256 context.
- *
- * \param ctx      The SHA-256 context to clear. This may be \c NULL, in which
- *                 case this function returns immediately. If it is not \c NULL,
- *                 it must point to an initialized SHA-256 context.
- */
-void mbedtls_sha256_free( mbedtls_sha256_context *ctx );
-
-/**
- * \brief          This function clones the state of a SHA-256 context.
- *
- * \param dst      The destination context. This must be initialized.
- * \param src      The context to clone. This must be initialized.
- */
-void mbedtls_sha256_clone( mbedtls_sha256_context *dst,
-                           const mbedtls_sha256_context *src );
-
-/**
- * \brief          This function starts a SHA-224 or SHA-256 checksum
- *                 calculation.
- *
- * \param ctx      The context to use. This must be initialized.
- * \param is224    This determines which function to use. This must be
- *                 either \c 0 for SHA-256, or \c 1 for SHA-224.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 );
-
-/**
- * \brief          This function feeds an input buffer into an ongoing
- *                 SHA-256 checksum calculation.
- *
- * \param ctx      The SHA-256 context. This must be initialized
- *                 and have a hash operation started.
- * \param input    The buffer holding the data. This must be a readable
- *                 buffer of length \p ilen Bytes.
- * \param ilen     The length of the input data in Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha256_update( mbedtls_sha256_context *ctx,
-                           const unsigned char *input,
-                           size_t ilen );
-
-/**
- * \brief          This function finishes the SHA-256 operation, and writes
- *                 the result to the output buffer.
- *
- * \param ctx      The SHA-256 context. This must be initialized
- *                 and have a hash operation started.
- * \param output   The SHA-224 or SHA-256 checksum result.
- *                 This must be a writable buffer of length \c 32 bytes
- *                 for SHA-256, \c 28 bytes for SHA-224.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha256_finish( mbedtls_sha256_context *ctx,
-                           unsigned char *output );
-
-/**
- * \brief          This function processes a single data block within
- *                 the ongoing SHA-256 computation. This function is for
- *                 internal use only.
- *
- * \param ctx      The SHA-256 context. This must be initialized.
- * \param data     The buffer holding one block of data. This must
- *                 be a readable buffer of length \c 64 Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx,
-                                     const unsigned char data[64] );
-
-/**
- * \brief          This function calculates the SHA-224 or SHA-256
- *                 checksum of a buffer.
- *
- *                 The function allocates the context, performs the
- *                 calculation, and frees the context.
- *
- *                 The SHA-256 result is calculated as
- *                 output = SHA-256(input buffer).
- *
- * \param input    The buffer holding the data. This must be a readable
- *                 buffer of length \p ilen Bytes.
- * \param ilen     The length of the input data in Bytes.
- * \param output   The SHA-224 or SHA-256 checksum result.
- *                 This must be a writable buffer of length \c 32 bytes
- *                 for SHA-256, \c 28 bytes for SHA-224.
- * \param is224    Determines which function to use. This must be
- *                 either \c 0 for SHA-256, or \c 1 for SHA-224.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha256( const unsigned char *input,
-                    size_t ilen,
-                    unsigned char *output,
-                    int is224 );
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/**
- * \brief          The SHA-224 and SHA-256 checkup routine.
- *
- * \return         \c 0 on success.
- * \return         \c 1 on failure.
- */
-int mbedtls_sha256_self_test( int verbose );
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* mbedtls_sha256.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/sha512.h b/src/duckdb/third_party/mbedtls/include/mbedtls/sha512.h
deleted file mode 100644
index 48901cc39..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/sha512.h
+++ /dev/null
@@ -1,205 +0,0 @@
-/**
- * \file sha512.h
- * \brief This file contains SHA-384 and SHA-512 definitions and functions.
- *
- * The Secure Hash Algorithms 384 and 512 (SHA-384 and SHA-512) cryptographic
- * hash functions are defined in <em>FIPS 180-4: Secure Hash Standard (SHS)</em>.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_SHA512_H
-#define MBEDTLS_SHA512_H
-#include "mbedtls/private_access.h"
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-/** SHA-512 input data was malformed. */
-#define MBEDTLS_ERR_SHA512_BAD_INPUT_DATA                 -0x0075
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined(MBEDTLS_SHA512_ALT)
-// Regular implementation
-//
-
-/**
- * \brief          The SHA-512 context structure.
- *
- *                 The structure is used both for SHA-384 and for SHA-512
- *                 checksum calculations. The choice between these two is
- *                 made in the call to mbedtls_sha512_starts().
- */
-typedef struct mbedtls_sha512_context
-{
-    uint64_t MBEDTLS_PRIVATE(total)[2];          /*!< The number of Bytes processed. */
-    uint64_t MBEDTLS_PRIVATE(state)[8];          /*!< The intermediate digest state. */
-    unsigned char MBEDTLS_PRIVATE(buffer)[128];  /*!< The data block being processed. */
-#if defined(MBEDTLS_SHA384_C)
-    int MBEDTLS_PRIVATE(is384);                  /*!< Determines which function to use:
-                                                      0: Use SHA-512, or 1: Use SHA-384. */
-#endif
-}
-mbedtls_sha512_context;
-
-#else  /* MBEDTLS_SHA512_ALT */
-#include "sha512_alt.h"
-#endif /* MBEDTLS_SHA512_ALT */
-
-/**
- * \brief          This function initializes a SHA-512 context.
- *
- * \param ctx      The SHA-512 context to initialize. This must
- *                 not be \c NULL.
- */
-void mbedtls_sha512_init( mbedtls_sha512_context *ctx );
-
-/**
- * \brief          This function clears a SHA-512 context.
- *
- * \param ctx      The SHA-512 context to clear. This may be \c NULL,
- *                 in which case this function does nothing. If it
- *                 is not \c NULL, it must point to an initialized
- *                 SHA-512 context.
- */
-void mbedtls_sha512_free( mbedtls_sha512_context *ctx );
-
-/**
- * \brief          This function clones the state of a SHA-512 context.
- *
- * \param dst      The destination context. This must be initialized.
- * \param src      The context to clone. This must be initialized.
- */
-void mbedtls_sha512_clone( mbedtls_sha512_context *dst,
-                           const mbedtls_sha512_context *src );
-
-/**
- * \brief          This function starts a SHA-384 or SHA-512 checksum
- *                 calculation.
- *
- * \param ctx      The SHA-512 context to use. This must be initialized.
- * \param is384    Determines which function to use. This must be
- *                 either \c 0 for SHA-512, or \c 1 for SHA-384.
- *
- * \note           When \c MBEDTLS_SHA384_C is not defined,
- *                 \p is384 must be \c 0, or the function will return
- *                 #MBEDTLS_ERR_SHA512_BAD_INPUT_DATA.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha512_starts( mbedtls_sha512_context *ctx, int is384 );
-
-/**
- * \brief          This function feeds an input buffer into an ongoing
- *                 SHA-512 checksum calculation.
- *
- * \param ctx      The SHA-512 context. This must be initialized
- *                 and have a hash operation started.
- * \param input    The buffer holding the input data. This must
- *                 be a readable buffer of length \p ilen Bytes.
- * \param ilen     The length of the input data in Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha512_update( mbedtls_sha512_context *ctx,
-                           const unsigned char *input,
-                           size_t ilen );
-
-/**
- * \brief          This function finishes the SHA-512 operation, and writes
- *                 the result to the output buffer.
- *
- * \param ctx      The SHA-512 context. This must be initialized
- *                 and have a hash operation started.
- * \param output   The SHA-384 or SHA-512 checksum result.
- *                 This must be a writable buffer of length \c 64 bytes
- *                 for SHA-512, \c 48 bytes for SHA-384.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha512_finish( mbedtls_sha512_context *ctx,
-                           unsigned char *output );
-
-/**
- * \brief          This function processes a single data block within
- *                 the ongoing SHA-512 computation.
- *                 This function is for internal use only.
- *
- * \param ctx      The SHA-512 context. This must be initialized.
- * \param data     The buffer holding one block of data. This
- *                 must be a readable buffer of length \c 128 Bytes.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx,
-                                     const unsigned char data[128] );
-
-/**
- * \brief          This function calculates the SHA-512 or SHA-384
- *                 checksum of a buffer.
- *
- *                 The function allocates the context, performs the
- *                 calculation, and frees the context.
- *
- *                 The SHA-512 result is calculated as
- *                 output = SHA-512(input buffer).
- *
- * \param input    The buffer holding the input data. This must be
- *                 a readable buffer of length \p ilen Bytes.
- * \param ilen     The length of the input data in Bytes.
- * \param output   The SHA-384 or SHA-512 checksum result.
- *                 This must be a writable buffer of length \c 64 bytes
- *                 for SHA-512, \c 48 bytes for SHA-384.
- * \param is384    Determines which function to use. This must be either
- *                 \c 0 for SHA-512, or \c 1 for SHA-384.
- *
- * \note           When \c MBEDTLS_SHA384_C is not defined, \p is384 must
- *                 be \c 0, or the function will return
- *                 #MBEDTLS_ERR_SHA512_BAD_INPUT_DATA.
- *
- * \return         \c 0 on success.
- * \return         A negative error code on failure.
- */
-int mbedtls_sha512( const unsigned char *input,
-                    size_t ilen,
-                    unsigned char *output,
-                    int is384 );
-
-#if defined(MBEDTLS_SELF_TEST)
-
- /**
- * \brief          The SHA-384 or SHA-512 checkup routine.
- *
- * \return         \c 0 on success.
- * \return         \c 1 on failure.
- */
-int mbedtls_sha512_self_test( int verbose );
-#endif /* MBEDTLS_SELF_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* mbedtls_sha512.h */
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/threading.h b/src/duckdb/third_party/mbedtls/include/mbedtls/threading.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/threading.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls/timing.h b/src/duckdb/third_party/mbedtls/include/mbedtls/timing.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls/timing.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/mbedtls_wrapper.hpp b/src/duckdb/third_party/mbedtls/include/mbedtls_wrapper.hpp
deleted file mode 100644
index 13d3cbd74..000000000
--- a/src/duckdb/third_party/mbedtls/include/mbedtls_wrapper.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// mbedtls_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/optional_ptr.hpp"
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/encryption_state.hpp"
-
-#include <string>
-
-namespace duckdb_mbedtls {
-
-class MbedTlsWrapper {
-public:
-	static void ComputeSha256Hash(const char *in, size_t in_len, char *out);
-	static std::string ComputeSha256Hash(const std::string &file_content);
-	static bool IsValidSha256Signature(const std::string &pubkey, const std::string &signature,
-	                                   const std::string &sha256_hash);
-	static void Hmac256(const char *key, size_t key_len, const char *message, size_t message_len, char *out);
-	static void ToBase16(char *in, char *out, size_t len);
-
-	static constexpr size_t SHA256_HASH_LENGTH_BYTES = 32;
-	static constexpr size_t SHA256_HASH_LENGTH_TEXT = 64;
-
-	class SHA256State {
-	public:
-		SHA256State();
-		~SHA256State();
-		void AddString(const std::string &str);
-		std::string Finalize();
-		void FinishHex(char *out);
-
-	private:
-		void *sha_context;
-	};
-
-	static constexpr size_t SHA1_HASH_LENGTH_BYTES = 20;
-	static constexpr size_t SHA1_HASH_LENGTH_TEXT = 40;
-
-	class SHA1State {
-	public:
-		SHA1State();
-		~SHA1State();
-		void AddString(const std::string &str);
-		std::string Finalize();
-		void FinishHex(char *out);
-
-	private:
-		void *sha_context;
-	};
-
-class AESGCMStateMBEDTLS : public duckdb::EncryptionState {
-	public:
-		DUCKDB_API explicit AESGCMStateMBEDTLS();
-		DUCKDB_API ~AESGCMStateMBEDTLS() override;
-
-	public:
-		DUCKDB_API bool IsOpenSSL() override;
-		DUCKDB_API void InitializeEncryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, const std::string *key) override;
-		DUCKDB_API void InitializeDecryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, const std::string *key) override;
-		DUCKDB_API size_t Process(duckdb::const_data_ptr_t in, duckdb::idx_t in_len, duckdb::data_ptr_t out,
-		                          duckdb::idx_t out_len) override;
-		DUCKDB_API size_t Finalize(duckdb::data_ptr_t out, duckdb::idx_t out_len, duckdb::data_ptr_t tag, duckdb::idx_t tag_len) override;
-		DUCKDB_API void GenerateRandomData(duckdb::data_ptr_t data, duckdb::idx_t len) override;
-		DUCKDB_API const std::string GetLib();
-
-	private:
-		bool ssl = false;
-		void *gcm_context;
-	};
-
-	class AESGCMStateMBEDTLSFactory : public duckdb::EncryptionUtil {
-
-	public:
-		duckdb::shared_ptr<duckdb::EncryptionState> CreateEncryptionState() const override {
-			return duckdb::make_shared_ptr<MbedTlsWrapper::AESGCMStateMBEDTLS>();
-		}
-
-		~AESGCMStateMBEDTLSFactory() override {} //
-	};
-};
-
-} // namespace duckdb_mbedtls
diff --git a/src/duckdb/third_party/mbedtls/include/platform_alt.h b/src/duckdb/third_party/mbedtls/include/platform_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/platform_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/psa/crypto.h b/src/duckdb/third_party/mbedtls/include/psa/crypto.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/psa/crypto.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/rsa_alt.h b/src/duckdb/third_party/mbedtls/include/rsa_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/rsa_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/sha1_alt.h b/src/duckdb/third_party/mbedtls/include/sha1_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/sha1_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/sha256_alt.h b/src/duckdb/third_party/mbedtls/include/sha256_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/sha256_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/sha512_alt.h b/src/duckdb/third_party/mbedtls/include/sha512_alt.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/sha512_alt.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/include/ssl_misc.h b/src/duckdb/third_party/mbedtls/include/ssl_misc.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/include/ssl_misc.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/library/aes.cpp b/src/duckdb/third_party/mbedtls/library/aes.cpp
deleted file mode 100644
index 4f772d631..000000000
--- a/src/duckdb/third_party/mbedtls/library/aes.cpp
+++ /dev/null
@@ -1,2171 +0,0 @@
-/*
-*  FIPS-197 compliant AES implementation
-*
-*  Copyright The Mbed TLS Contributors
-*  SPDX-License-Identifier: Apache-2.0
-*
-*  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.
-*/
-/*
-*  The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
-*
-*  http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
-*  http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
-*/
-
-#include "common.h"
-
-#if defined(MBEDTLS_AES_C)
-
-#include <string.h>
-
-#include "mbedtls/aes.h"
-#include "mbedtls/platform.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-#if defined(MBEDTLS_PADLOCK_C)
-#include "padlock.h"
-#endif
-#if defined(MBEDTLS_AESNI_C)
-#include "aesni.h"
-#endif
-
-#if defined(MBEDTLS_SELF_TEST)
-//#if defined(MBEDTLS_PLATFORM_C)
-//#include "mbedtls/platform.h"
-//#else
-//#include <stdio.h>
-//#define mbedtls_printf printf
-//#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#if !defined(MBEDTLS_AES_ALT)
-
-/* Parameter validation macros based on platform_util.h */
-#define AES_VALIDATE_RET( cond )    \
-   MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_AES_BAD_INPUT_DATA )
-#define AES_VALIDATE( cond )        \
-   MBEDTLS_INTERNAL_VALIDATE( cond )
-
-#if defined(MBEDTLS_PADLOCK_C) &&                      \
-   ( defined(MBEDTLS_HAVE_X86) || defined(MBEDTLS_PADLOCK_ALIGN16) )
-static int aes_padlock_ace = -1;
-#endif
-
-#if defined(MBEDTLS_AES_ROM_TABLES)
-/*
-* Forward S-box
-*/
-static const unsigned char AESFSb[256] =
-   {
-	   0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
-	   0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
-	   0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
-	   0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
-	   0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
-	   0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
-	   0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
-	   0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
-	   0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
-	   0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
-	   0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
-	   0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
-	   0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
-	   0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
-	   0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
-	   0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
-	   0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
-	   0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
-	   0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
-	   0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
-	   0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
-	   0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
-	   0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
-	   0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
-	   0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
-	   0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
-	   0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
-	   0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
-	   0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
-	   0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
-	   0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
-	   0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
-};
-
-/*
-* Forward tables
-*/
-#define FT \
-\
-   V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
-   V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
-   V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
-   V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
-   V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
-   V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
-   V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
-   V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
-   V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
-   V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
-   V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
-   V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
-   V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
-   V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
-   V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
-   V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
-   V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
-   V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
-   V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
-   V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
-   V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
-   V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
-   V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
-   V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
-   V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
-   V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
-   V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
-   V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
-   V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
-   V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
-   V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
-   V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
-   V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
-   V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
-   V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
-   V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
-   V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
-   V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
-   V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
-   V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
-   V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
-   V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
-   V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
-   V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
-   V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
-   V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
-   V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
-   V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
-   V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
-   V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
-   V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
-   V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
-   V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
-   V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
-   V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
-   V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
-   V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
-   V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
-   V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
-   V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
-   V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
-   V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
-   V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
-   V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)
-
-#define V(a,b,c,d) 0x##a##b##c##d
-static const uint32_t FT0[256] = { FT };
-#undef V
-
-#if !defined(MBEDTLS_AES_FEWER_TABLES)
-
-#define V(a,b,c,d) 0x##b##c##d##a
-static const uint32_t FT1[256] = { FT };
-#undef V
-
-#define V(a,b,c,d) 0x##c##d##a##b
-static const uint32_t FT2[256] = { FT };
-#undef V
-
-#define V(a,b,c,d) 0x##d##a##b##c
-static const uint32_t FT3[256] = { FT };
-#undef V
-
-#endif /* !MBEDTLS_AES_FEWER_TABLES */
-
-#undef FT
-
-/*
-* Reverse S-box
-*/
-static const unsigned char RSb[256] =
-   {
-	   0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
-	   0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
-	   0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
-	   0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
-	   0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
-	   0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
-	   0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
-	   0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
-	   0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
-	   0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
-	   0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
-	   0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
-	   0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
-	   0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
-	   0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
-	   0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
-	   0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
-	   0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
-	   0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
-	   0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
-	   0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
-	   0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
-	   0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
-	   0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
-	   0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
-	   0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
-	   0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
-	   0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
-	   0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
-	   0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
-	   0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
-	   0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
-};
-
-/*
-* Reverse tables
-*/
-#define RT \
-\
-   V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \
-   V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \
-   V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \
-   V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \
-   V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \
-   V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \
-   V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \
-   V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \
-   V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \
-   V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \
-   V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \
-   V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \
-   V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \
-   V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \
-   V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \
-   V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \
-   V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \
-   V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \
-   V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \
-   V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \
-   V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \
-   V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \
-   V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \
-   V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \
-   V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \
-   V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \
-   V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \
-   V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \
-   V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \
-   V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \
-   V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \
-   V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \
-   V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \
-   V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \
-   V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \
-   V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \
-   V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \
-   V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \
-   V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \
-   V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \
-   V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \
-   V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \
-   V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \
-   V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \
-   V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \
-   V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \
-   V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \
-   V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \
-   V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \
-   V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \
-   V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \
-   V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \
-   V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \
-   V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \
-   V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \
-   V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \
-   V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \
-   V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \
-   V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \
-   V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \
-   V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \
-   V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \
-   V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \
-   V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)
-
-#define V(a,b,c,d) 0x##a##b##c##d
-static const uint32_t RT0[256] = { RT };
-#undef V
-
-#if !defined(MBEDTLS_AES_FEWER_TABLES)
-
-#define V(a,b,c,d) 0x##b##c##d##a
-static const uint32_t RT1[256] = { RT };
-#undef V
-
-#define V(a,b,c,d) 0x##c##d##a##b
-static const uint32_t RT2[256] = { RT };
-#undef V
-
-#define V(a,b,c,d) 0x##d##a##b##c
-static const uint32_t RT3[256] = { RT };
-#undef V
-
-#endif /* !MBEDTLS_AES_FEWER_TABLES */
-
-#undef RT
-
-/*
-* Round constants
-*/
-static const uint32_t RCON[10] =
-   {
-	   0x00000001, 0x00000002, 0x00000004, 0x00000008,
-	   0x00000010, 0x00000020, 0x00000040, 0x00000080,
-	   0x0000001B, 0x00000036
-};
-
-#else /* MBEDTLS_AES_ROM_TABLES */
-
-/*
-* Forward S-box & tables
-*/
-static unsigned char AESFSb[256];
-static uint32_t FT0[256];
-#if !defined(MBEDTLS_AES_FEWER_TABLES)
-static uint32_t FT1[256];
-static uint32_t FT2[256];
-static uint32_t FT3[256];
-#endif /* !MBEDTLS_AES_FEWER_TABLES */
-
-/*
-* Reverse S-box & tables
-*/
-static unsigned char RSb[256];
-static uint32_t RT0[256];
-#if !defined(MBEDTLS_AES_FEWER_TABLES)
-static uint32_t RT1[256];
-static uint32_t RT2[256];
-static uint32_t RT3[256];
-#endif /* !MBEDTLS_AES_FEWER_TABLES */
-
-/*
-* Round constants
-*/
-static uint32_t RCON[10];
-
-/*
-* Tables generation code
-*/
-#define ROTL8(x) ( ( (x) << 8 ) & 0xFFFFFFFF ) | ( (x) >> 24 )
-#define XTIME(x) ( ( (x) << 1 ) ^ ( ( (x) & 0x80 ) ? 0x1B : 0x00 ) )
-#define MUL(x,y) ( ( (x) && (y) ) ? pow[(log[(x)]+log[(y)]) % 255] : 0 )
-
-static int aes_init_done = 0;
-
-static void aes_gen_tables( void )
-{
-   int i, x, y, z;
-   int pow[256];
-   int log[256];
-
-   /*
-	* compute pow and log tables over GF(2^8)
-	*/
-   for( i = 0, x = 1; i < 256; i++ )
-   {
-	   pow[i] = x;
-	   log[x] = i;
-	   x = MBEDTLS_BYTE_0( x ^ XTIME( x ) );
-   }
-
-   /*
-	* calculate the round constants
-	*/
-   for( i = 0, x = 1; i < 10; i++ )
-   {
-	   RCON[i] = (uint32_t) x;
-	   x = MBEDTLS_BYTE_0( XTIME( x ) );
-   }
-
-   /*
-	* generate the forward and reverse S-boxes
-	*/
-   AESFSb[0x00] = 0x63;
-   RSb[0x63] = 0x00;
-
-   for( i = 1; i < 256; i++ )
-   {
-	   x = pow[255 - log[i]];
-
-	   y  = x; y = MBEDTLS_BYTE_0( ( y << 1 ) | ( y >> 7 ) );
-	   x ^= y; y = MBEDTLS_BYTE_0( ( y << 1 ) | ( y >> 7 ) );
-	   x ^= y; y = MBEDTLS_BYTE_0( ( y << 1 ) | ( y >> 7 ) );
-	   x ^= y; y = MBEDTLS_BYTE_0( ( y << 1 ) | ( y >> 7 ) );
-	   x ^= y ^ 0x63;
-
-	   AESFSb[i] = (unsigned char) x;
-	   RSb[x] = (unsigned char) i;
-   }
-
-   /*
-	* generate the forward and reverse tables
-	*/
-   for( i = 0; i < 256; i++ )
-   {
-	   x = AESFSb[i];
-	   y = MBEDTLS_BYTE_0( XTIME( x ) );
-	   z = MBEDTLS_BYTE_0( y ^ x );
-
-	   FT0[i] = ( (uint32_t) y       ) ^
-				( (uint32_t) x <<  8 ) ^
-				( (uint32_t) x << 16 ) ^
-				( (uint32_t) z << 24 );
-
-#if !defined(MBEDTLS_AES_FEWER_TABLES)
-	   FT1[i] = ROTL8( FT0[i] );
-	   FT2[i] = ROTL8( FT1[i] );
-	   FT3[i] = ROTL8( FT2[i] );
-#endif /* !MBEDTLS_AES_FEWER_TABLES */
-
-	   x = RSb[i];
-
-	   RT0[i] = ( (uint32_t) MUL( 0x0E, x )       ) ^
-				( (uint32_t) MUL( 0x09, x ) <<  8 ) ^
-				( (uint32_t) MUL( 0x0D, x ) << 16 ) ^
-				( (uint32_t) MUL( 0x0B, x ) << 24 );
-
-#if !defined(MBEDTLS_AES_FEWER_TABLES)
-	   RT1[i] = ROTL8( RT0[i] );
-	   RT2[i] = ROTL8( RT1[i] );
-	   RT3[i] = ROTL8( RT2[i] );
-#endif /* !MBEDTLS_AES_FEWER_TABLES */
-   }
-}
-
-#undef ROTL8
-
-#endif /* MBEDTLS_AES_ROM_TABLES */
-
-#if defined(MBEDTLS_AES_FEWER_TABLES)
-
-#define ROTL8(x)  ( (uint32_t)( ( x ) <<  8 ) + (uint32_t)( ( x ) >> 24 ) )
-#define ROTL16(x) ( (uint32_t)( ( x ) << 16 ) + (uint32_t)( ( x ) >> 16 ) )
-#define ROTL24(x) ( (uint32_t)( ( x ) << 24 ) + (uint32_t)( ( x ) >>  8 ) )
-
-#define AES_RT0(idx) RT0[idx]
-#define AES_RT1(idx) ROTL8(  RT0[idx] )
-#define AES_RT2(idx) ROTL16( RT0[idx] )
-#define AES_RT3(idx) ROTL24( RT0[idx] )
-
-#define AES_FT0(idx) FT0[idx]
-#define AES_FT1(idx) ROTL8(  FT0[idx] )
-#define AES_FT2(idx) ROTL16( FT0[idx] )
-#define AES_FT3(idx) ROTL24( FT0[idx] )
-
-#else /* MBEDTLS_AES_FEWER_TABLES */
-
-#define AES_RT0(idx) RT0[idx]
-#define AES_RT1(idx) RT1[idx]
-#define AES_RT2(idx) RT2[idx]
-#define AES_RT3(idx) RT3[idx]
-
-#define AES_FT0(idx) FT0[idx]
-#define AES_FT1(idx) FT1[idx]
-#define AES_FT2(idx) FT2[idx]
-#define AES_FT3(idx) FT3[idx]
-
-#endif /* MBEDTLS_AES_FEWER_TABLES */
-
-void mbedtls_aes_init( mbedtls_aes_context *ctx )
-{
-   AES_VALIDATE( ctx != NULL );
-
-   memset( ctx, 0, sizeof( mbedtls_aes_context ) );
-}
-
-void mbedtls_aes_free( mbedtls_aes_context *ctx )
-{
-   if( ctx == NULL )
-	   return;
-
-   mbedtls_platform_zeroize( ctx, sizeof( mbedtls_aes_context ) );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-void mbedtls_aes_xts_init( mbedtls_aes_xts_context *ctx )
-{
-   AES_VALIDATE( ctx != NULL );
-
-   mbedtls_aes_init( &ctx->crypt );
-   mbedtls_aes_init( &ctx->tweak );
-}
-
-void mbedtls_aes_xts_free( mbedtls_aes_xts_context *ctx )
-{
-   if( ctx == NULL )
-	   return;
-
-   mbedtls_aes_free( &ctx->crypt );
-   mbedtls_aes_free( &ctx->tweak );
-}
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-/*
-* AES key schedule (encryption)
-*/
-#if !defined(MBEDTLS_AES_SETKEY_ENC_ALT)
-int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
-						  unsigned int keybits )
-{
-   unsigned int i;
-   uint32_t *RK;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( key != NULL );
-
-   switch( keybits )
-   {
-   case 128: ctx->nr = 10; break;
-   case 192: ctx->nr = 12; break;
-   case 256: ctx->nr = 14; break;
-   default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
-   }
-
-#if !defined(MBEDTLS_AES_ROM_TABLES)
-   if( aes_init_done == 0 )
-   {
-	   aes_gen_tables();
-	   aes_init_done = 1;
-   }
-#endif
-
-#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
-   if( aes_padlock_ace == -1 )
-	   aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
-
-   if( aes_padlock_ace )
-	   ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
-   else
-#endif
-	   ctx->rk = RK = ctx->buf;
-
-#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
-   if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
-	   return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );
-#endif
-
-   for( i = 0; i < ( keybits >> 5 ); i++ )
-   {
-	   RK[i] = MBEDTLS_GET_UINT32_LE( key, i << 2 );
-   }
-
-   switch( ctx->nr )
-   {
-   case 10:
-
-	   for( i = 0; i < 10; i++, RK += 4 )
-	   {
-		   RK[4]  = RK[0] ^ RCON[i] ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( RK[3] ) ]       ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( RK[3] ) ] <<  8 ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( RK[3] ) ] << 16 ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( RK[3] ) ] << 24 );
-
-		   RK[5]  = RK[1] ^ RK[4];
-		   RK[6]  = RK[2] ^ RK[5];
-		   RK[7]  = RK[3] ^ RK[6];
-	   }
-	   break;
-
-   case 12:
-
-	   for( i = 0; i < 8; i++, RK += 6 )
-	   {
-		   RK[6]  = RK[0] ^ RCON[i] ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( RK[5] ) ]       ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( RK[5] ) ] <<  8 ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( RK[5] ) ] << 16 ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( RK[5] ) ] << 24 );
-
-		   RK[7]  = RK[1] ^ RK[6];
-		   RK[8]  = RK[2] ^ RK[7];
-		   RK[9]  = RK[3] ^ RK[8];
-		   RK[10] = RK[4] ^ RK[9];
-		   RK[11] = RK[5] ^ RK[10];
-	   }
-	   break;
-
-   case 14:
-
-	   for( i = 0; i < 7; i++, RK += 8 )
-	   {
-		   RK[8]  = RK[0] ^ RCON[i] ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( RK[7] ) ]       ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( RK[7] ) ] <<  8 ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( RK[7] ) ] << 16 ) ^
-				   ( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( RK[7] ) ] << 24 );
-
-		   RK[9]  = RK[1] ^ RK[8];
-		   RK[10] = RK[2] ^ RK[9];
-		   RK[11] = RK[3] ^ RK[10];
-
-		   RK[12] = RK[4] ^
-					( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( RK[11] ) ]       ) ^
-					( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( RK[11] ) ] <<  8 ) ^
-					( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( RK[11] ) ] << 16 ) ^
-					( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( RK[11] ) ] << 24 );
-
-		   RK[13] = RK[5] ^ RK[12];
-		   RK[14] = RK[6] ^ RK[13];
-		   RK[15] = RK[7] ^ RK[14];
-	   }
-	   break;
-   }
-
-   return( 0 );
-}
-#endif /* !MBEDTLS_AES_SETKEY_ENC_ALT */
-
-/*
-* AES key schedule (decryption)
-*/
-#if !defined(MBEDTLS_AES_SETKEY_DEC_ALT)
-int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
-						  unsigned int keybits )
-{
-   int i, j, ret;
-   mbedtls_aes_context cty;
-   uint32_t *RK;
-   uint32_t *SK;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( key != NULL );
-
-   mbedtls_aes_init( &cty );
-
-#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
-   if( aes_padlock_ace == -1 )
-	   aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
-
-   if( aes_padlock_ace )
-	   ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
-   else
-#endif
-	   ctx->rk = RK = ctx->buf;
-
-   /* Also checks keybits */
-   if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
-	   goto exit;
-
-   ctx->nr = cty.nr;
-
-#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
-   if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
-   {
-	   mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
-								 (const unsigned char *) cty.rk, ctx->nr );
-	   goto exit;
-   }
-#endif
-
-   SK = cty.rk + cty.nr * 4;
-
-   *RK++ = *SK++;
-   *RK++ = *SK++;
-   *RK++ = *SK++;
-   *RK++ = *SK++;
-
-   for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
-   {
-	   for( j = 0; j < 4; j++, SK++ )
-	   {
-		   *RK++ = AES_RT0( AESFSb[ MBEDTLS_BYTE_0( *SK ) ] ) ^
-				   AES_RT1( AESFSb[ MBEDTLS_BYTE_1( *SK ) ] ) ^
-				   AES_RT2( AESFSb[ MBEDTLS_BYTE_2( *SK ) ] ) ^
-				   AES_RT3( AESFSb[ MBEDTLS_BYTE_3( *SK ) ] );
-	   }
-   }
-
-   *RK++ = *SK++;
-   *RK++ = *SK++;
-   *RK++ = *SK++;
-   *RK++ = *SK++;
-
-exit:
-   mbedtls_aes_free( &cty );
-
-   return( ret );
-}
-#endif /* !MBEDTLS_AES_SETKEY_DEC_ALT */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-static int mbedtls_aes_xts_decode_keys( const unsigned char *key,
-									  unsigned int keybits,
-									  const unsigned char **key1,
-									  unsigned int *key1bits,
-									  const unsigned char **key2,
-									  unsigned int *key2bits )
-{
-   const unsigned int half_keybits = keybits / 2;
-   const unsigned int half_keybytes = half_keybits / 8;
-
-   switch( keybits )
-   {
-   case 256: break;
-   case 512: break;
-   default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
-   }
-
-   *key1bits = half_keybits;
-   *key2bits = half_keybits;
-   *key1 = &key[0];
-   *key2 = &key[half_keybytes];
-
-   return 0;
-}
-
-int mbedtls_aes_xts_setkey_enc( mbedtls_aes_xts_context *ctx,
-							  const unsigned char *key,
-							  unsigned int keybits)
-{
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   const unsigned char *key1, *key2;
-   unsigned int key1bits, key2bits;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( key != NULL );
-
-   ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,
-									 &key2, &key2bits );
-   if( ret != 0 )
-	   return( ret );
-
-   /* Set the tweak key. Always set tweak key for the encryption mode. */
-   ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );
-   if( ret != 0 )
-	   return( ret );
-
-   /* Set crypt key for encryption. */
-   return mbedtls_aes_setkey_enc( &ctx->crypt, key1, key1bits );
-}
-
-int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,
-							  const unsigned char *key,
-							  unsigned int keybits)
-{
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   const unsigned char *key1, *key2;
-   unsigned int key1bits, key2bits;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( key != NULL );
-
-   ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,
-									 &key2, &key2bits );
-   if( ret != 0 )
-	   return( ret );
-
-   /* Set the tweak key. Always set tweak key for encryption. */
-   ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );
-   if( ret != 0 )
-	   return( ret );
-
-   /* Set crypt key for decryption. */
-   return mbedtls_aes_setkey_dec( &ctx->crypt, key1, key1bits );
-}
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)                 \
-   do                                                      \
-   {                                                       \
-	   (X0) = *RK++ ^ AES_FT0( MBEDTLS_BYTE_0( Y0 ) ) ^    \
-					  AES_FT1( MBEDTLS_BYTE_1( Y1 ) ) ^    \
-					  AES_FT2( MBEDTLS_BYTE_2( Y2 ) ) ^    \
-					  AES_FT3( MBEDTLS_BYTE_3( Y3 ) );     \
-														   \
-	   (X1) = *RK++ ^ AES_FT0( MBEDTLS_BYTE_0( Y1 ) ) ^    \
-					  AES_FT1( MBEDTLS_BYTE_1( Y2 ) ) ^    \
-					  AES_FT2( MBEDTLS_BYTE_2( Y3 ) ) ^    \
-					  AES_FT3( MBEDTLS_BYTE_3( Y0 ) );     \
-														   \
-	   (X2) = *RK++ ^ AES_FT0( MBEDTLS_BYTE_0( Y2 ) ) ^    \
-					  AES_FT1( MBEDTLS_BYTE_1( Y3 ) ) ^    \
-					  AES_FT2( MBEDTLS_BYTE_2( Y0 ) ) ^    \
-					  AES_FT3( MBEDTLS_BYTE_3( Y1 ) );     \
-														   \
-	   (X3) = *RK++ ^ AES_FT0( MBEDTLS_BYTE_0( Y3 ) ) ^    \
-					  AES_FT1( MBEDTLS_BYTE_1( Y0 ) ) ^    \
-					  AES_FT2( MBEDTLS_BYTE_2( Y1 ) ) ^    \
-					  AES_FT3( MBEDTLS_BYTE_3( Y2 ) );     \
-   } while( 0 )
-
-#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)                 \
-   do                                                      \
-   {                                                       \
-	   (X0) = *RK++ ^ AES_RT0( MBEDTLS_BYTE_0( Y0 ) ) ^    \
-					  AES_RT1( MBEDTLS_BYTE_1( Y3 ) ) ^    \
-					  AES_RT2( MBEDTLS_BYTE_2( Y2 ) ) ^    \
-					  AES_RT3( MBEDTLS_BYTE_3( Y1 ) );     \
-														   \
-	   (X1) = *RK++ ^ AES_RT0( MBEDTLS_BYTE_0( Y1 ) ) ^    \
-					  AES_RT1( MBEDTLS_BYTE_1( Y0 ) ) ^    \
-					  AES_RT2( MBEDTLS_BYTE_2( Y3 ) ) ^    \
-					  AES_RT3( MBEDTLS_BYTE_3( Y2 ) );     \
-														   \
-	   (X2) = *RK++ ^ AES_RT0( MBEDTLS_BYTE_0( Y2 ) ) ^    \
-					  AES_RT1( MBEDTLS_BYTE_1( Y1 ) ) ^    \
-					  AES_RT2( MBEDTLS_BYTE_2( Y0 ) ) ^    \
-					  AES_RT3( MBEDTLS_BYTE_3( Y3 ) );     \
-														   \
-	   (X3) = *RK++ ^ AES_RT0( MBEDTLS_BYTE_0( Y3 ) ) ^    \
-					  AES_RT1( MBEDTLS_BYTE_1( Y2 ) ) ^    \
-					  AES_RT2( MBEDTLS_BYTE_2( Y1 ) ) ^    \
-					  AES_RT3( MBEDTLS_BYTE_3( Y0 ) );     \
-   } while( 0 )
-
-/*
-* AES-ECB block encryption
-*/
-#if !defined(MBEDTLS_AES_ENCRYPT_ALT)
-int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
-								const unsigned char input[16],
-								unsigned char output[16] )
-{
-   int i;
-   uint32_t *RK = ctx->rk;
-   struct
-   {
-	   uint32_t X[4];
-	   uint32_t Y[4];
-   } t;
-
-   t.X[0] = MBEDTLS_GET_UINT32_LE( input,  0 ); t.X[0] ^= *RK++;
-   t.X[1] = MBEDTLS_GET_UINT32_LE( input,  4 ); t.X[1] ^= *RK++;
-   t.X[2] = MBEDTLS_GET_UINT32_LE( input,  8 ); t.X[2] ^= *RK++;
-   t.X[3] = MBEDTLS_GET_UINT32_LE( input, 12 ); t.X[3] ^= *RK++;
-
-   for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
-   {
-	   AES_FROUND( t.Y[0], t.Y[1], t.Y[2], t.Y[3], t.X[0], t.X[1], t.X[2], t.X[3] );
-	   AES_FROUND( t.X[0], t.X[1], t.X[2], t.X[3], t.Y[0], t.Y[1], t.Y[2], t.Y[3] );
-   }
-
-   AES_FROUND( t.Y[0], t.Y[1], t.Y[2], t.Y[3], t.X[0], t.X[1], t.X[2], t.X[3] );
-
-   t.X[0] = *RK++ ^ \
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( t.Y[0] ) ]       ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( t.Y[1] ) ] <<  8 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( t.Y[2] ) ] << 16 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( t.Y[3] ) ] << 24 );
-
-   t.X[1] = *RK++ ^ \
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( t.Y[1] ) ]       ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( t.Y[2] ) ] <<  8 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( t.Y[3] ) ] << 16 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( t.Y[0] ) ] << 24 );
-
-   t.X[2] = *RK++ ^ \
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( t.Y[2] ) ]       ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( t.Y[3] ) ] <<  8 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( t.Y[0] ) ] << 16 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( t.Y[1] ) ] << 24 );
-
-   t.X[3] = *RK++ ^ \
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_0( t.Y[3] ) ]       ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_1( t.Y[0] ) ] <<  8 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_2( t.Y[1] ) ] << 16 ) ^
-			( (uint32_t) AESFSb[ MBEDTLS_BYTE_3( t.Y[2] ) ] << 24 );
-
-   MBEDTLS_PUT_UINT32_LE( t.X[0], output,  0 );
-   MBEDTLS_PUT_UINT32_LE( t.X[1], output,  4 );
-   MBEDTLS_PUT_UINT32_LE( t.X[2], output,  8 );
-   MBEDTLS_PUT_UINT32_LE( t.X[3], output, 12 );
-
-   mbedtls_platform_zeroize( &t, sizeof( t ) );
-
-   return( 0 );
-}
-#endif /* !MBEDTLS_AES_ENCRYPT_ALT */
-
-/*
-* AES-ECB block decryption
-*/
-#if !defined(MBEDTLS_AES_DECRYPT_ALT)
-int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
-								const unsigned char input[16],
-								unsigned char output[16] )
-{
-   int i;
-   uint32_t *RK = ctx->rk;
-   struct
-   {
-	   uint32_t X[4];
-	   uint32_t Y[4];
-   } t;
-
-   t.X[0] = MBEDTLS_GET_UINT32_LE( input,  0 ); t.X[0] ^= *RK++;
-   t.X[1] = MBEDTLS_GET_UINT32_LE( input,  4 ); t.X[1] ^= *RK++;
-   t.X[2] = MBEDTLS_GET_UINT32_LE( input,  8 ); t.X[2] ^= *RK++;
-   t.X[3] = MBEDTLS_GET_UINT32_LE( input, 12 ); t.X[3] ^= *RK++;
-
-   for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
-   {
-	   AES_RROUND( t.Y[0], t.Y[1], t.Y[2], t.Y[3], t.X[0], t.X[1], t.X[2], t.X[3] );
-	   AES_RROUND( t.X[0], t.X[1], t.X[2], t.X[3], t.Y[0], t.Y[1], t.Y[2], t.Y[3] );
-   }
-
-   AES_RROUND( t.Y[0], t.Y[1], t.Y[2], t.Y[3], t.X[0], t.X[1], t.X[2], t.X[3] );
-
-   t.X[0] = *RK++ ^ \
-			( (uint32_t) RSb[ MBEDTLS_BYTE_0( t.Y[0] ) ]       ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_1( t.Y[3] ) ] <<  8 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_2( t.Y[2] ) ] << 16 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_3( t.Y[1] ) ] << 24 );
-
-   t.X[1] = *RK++ ^ \
-			( (uint32_t) RSb[ MBEDTLS_BYTE_0( t.Y[1] ) ]       ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_1( t.Y[0] ) ] <<  8 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_2( t.Y[3] ) ] << 16 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_3( t.Y[2] ) ] << 24 );
-
-   t.X[2] = *RK++ ^ \
-			( (uint32_t) RSb[ MBEDTLS_BYTE_0( t.Y[2] ) ]       ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_1( t.Y[1] ) ] <<  8 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_2( t.Y[0] ) ] << 16 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_3( t.Y[3] ) ] << 24 );
-
-   t.X[3] = *RK++ ^ \
-			( (uint32_t) RSb[ MBEDTLS_BYTE_0( t.Y[3] ) ]       ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_1( t.Y[2] ) ] <<  8 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_2( t.Y[1] ) ] << 16 ) ^
-			( (uint32_t) RSb[ MBEDTLS_BYTE_3( t.Y[0] ) ] << 24 );
-
-   MBEDTLS_PUT_UINT32_LE( t.X[0], output,  0 );
-   MBEDTLS_PUT_UINT32_LE( t.X[1], output,  4 );
-   MBEDTLS_PUT_UINT32_LE( t.X[2], output,  8 );
-   MBEDTLS_PUT_UINT32_LE( t.X[3], output, 12 );
-
-   mbedtls_platform_zeroize( &t, sizeof( t ) );
-
-   return( 0 );
-}
-#endif /* !MBEDTLS_AES_DECRYPT_ALT */
-
-/*
-* AES-ECB block encryption/decryption
-*/
-int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
-						 int mode,
-						 const unsigned char input[16],
-						 unsigned char output[16] )
-{
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-   AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||
-					mode == MBEDTLS_AES_DECRYPT );
-
-#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
-   if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
-	   return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
-#endif
-
-#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
-   if( aes_padlock_ace > 0)
-   {
-	   if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
-		   return( 0 );
-
-	   // If padlock data misaligned, we just fall back to
-	   // unaccelerated mode
-	   //
-   }
-#endif
-
-   if( mode == MBEDTLS_AES_ENCRYPT )
-	   return( mbedtls_internal_aes_encrypt( ctx, input, output ) );
-   else
-	   return( mbedtls_internal_aes_decrypt( ctx, input, output ) );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/*
-* AES-CBC buffer encryption/decryption
-*/
-int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
-						 int mode,
-						 size_t length,
-						 unsigned char iv[16],
-						 const unsigned char *input,
-						 unsigned char *output )
-{
-   int i;
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   unsigned char temp[16];
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||
-					mode == MBEDTLS_AES_DECRYPT );
-   AES_VALIDATE_RET( iv != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-
-   if( length % 16 )
-	   return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
-
-#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
-   if( aes_padlock_ace > 0 )
-   {
-	   if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
-		   return( 0 );
-
-	   // If padlock data misaligned, we just fall back to
-	   // unaccelerated mode
-	   //
-   }
-#endif
-
-   if( mode == MBEDTLS_AES_DECRYPT )
-   {
-	   while( length > 0 )
-	   {
-		   memcpy( temp, input, 16 );
-		   ret = mbedtls_aes_crypt_ecb( ctx, mode, input, output );
-		   if( ret != 0 )
-			   goto exit;
-
-		   for( i = 0; i < 16; i++ )
-			   output[i] = (unsigned char)( output[i] ^ iv[i] );
-
-		   memcpy( iv, temp, 16 );
-
-		   input  += 16;
-		   output += 16;
-		   length -= 16;
-	   }
-   }
-   else
-   {
-	   while( length > 0 )
-	   {
-		   for( i = 0; i < 16; i++ )
-			   output[i] = (unsigned char)( input[i] ^ iv[i] );
-
-		   ret = mbedtls_aes_crypt_ecb( ctx, mode, output, output );
-		   if( ret != 0 )
-			   goto exit;
-		   memcpy( iv, output, 16 );
-
-		   input  += 16;
-		   output += 16;
-		   length -= 16;
-	   }
-   }
-   ret = 0;
-
-exit:
-   return( ret );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-
-typedef unsigned char mbedtls_be128[16];
-
-/*
-* GF(2^128) multiplication function
-*
-* This function multiplies a field element by x in the polynomial field
-* representation. It uses 64-bit word operations to gain speed but compensates
-* for machine endianess and hence works correctly on both big and little
-* endian machines.
-*/
-static void mbedtls_gf128mul_x_ble( unsigned char r[16],
-								  const unsigned char x[16] )
-{
-   uint64_t a, b, ra, rb;
-
-   a = MBEDTLS_GET_UINT64_LE( x, 0 );
-   b = MBEDTLS_GET_UINT64_LE( x, 8 );
-
-   ra = ( a << 1 )  ^ 0x0087 >> ( 8 - ( ( b >> 63 ) << 3 ) );
-   rb = ( a >> 63 ) | ( b << 1 );
-
-   MBEDTLS_PUT_UINT64_LE( ra, r, 0 );
-   MBEDTLS_PUT_UINT64_LE( rb, r, 8 );
-}
-
-/*
-* AES-XTS buffer encryption/decryption
-*/
-int mbedtls_aes_crypt_xts( mbedtls_aes_xts_context *ctx,
-						 int mode,
-						 size_t length,
-						 const unsigned char data_unit[16],
-						 const unsigned char *input,
-						 unsigned char *output )
-{
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   size_t blocks = length / 16;
-   size_t leftover = length % 16;
-   unsigned char tweak[16];
-   unsigned char prev_tweak[16];
-   unsigned char tmp[16];
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||
-					mode == MBEDTLS_AES_DECRYPT );
-   AES_VALIDATE_RET( data_unit != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-
-   /* Data units must be at least 16 bytes long. */
-   if( length < 16 )
-	   return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
-
-   /* NIST SP 800-38E disallows data units larger than 2**20 blocks. */
-   if( length > ( 1 << 20 ) * 16 )
-	   return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
-
-   /* Compute the tweak. */
-   ret = mbedtls_aes_crypt_ecb( &ctx->tweak, MBEDTLS_AES_ENCRYPT,
-							   data_unit, tweak );
-   if( ret != 0 )
-	   return( ret );
-
-   while( blocks-- )
-   {
-	   size_t i;
-
-	   if( leftover && ( mode == MBEDTLS_AES_DECRYPT ) && blocks == 0 )
-	   {
-		   /* We are on the last block in a decrypt operation that has
-			* leftover bytes, so we need to use the next tweak for this block,
-			* and this tweak for the lefover bytes. Save the current tweak for
-			* the leftovers and then update the current tweak for use on this,
-			* the last full block. */
-		   memcpy( prev_tweak, tweak, sizeof( tweak ) );
-		   mbedtls_gf128mul_x_ble( tweak, tweak );
-	   }
-
-	   for( i = 0; i < 16; i++ )
-		   tmp[i] = input[i] ^ tweak[i];
-
-	   ret = mbedtls_aes_crypt_ecb( &ctx->crypt, mode, tmp, tmp );
-	   if( ret != 0 )
-		   return( ret );
-
-	   for( i = 0; i < 16; i++ )
-		   output[i] = tmp[i] ^ tweak[i];
-
-	   /* Update the tweak for the next block. */
-	   mbedtls_gf128mul_x_ble( tweak, tweak );
-
-	   output += 16;
-	   input += 16;
-   }
-
-   if( leftover )
-   {
-	   /* If we are on the leftover bytes in a decrypt operation, we need to
-		* use the previous tweak for these bytes (as saved in prev_tweak). */
-	   unsigned char *t = mode == MBEDTLS_AES_DECRYPT ? prev_tweak : tweak;
-
-	   /* We are now on the final part of the data unit, which doesn't divide
-		* evenly by 16. It's time for ciphertext stealing. */
-	   size_t i;
-	   unsigned char *prev_output = output - 16;
-
-	   /* Copy ciphertext bytes from the previous block to our output for each
-		* byte of cyphertext we won't steal. At the same time, copy the
-		* remainder of the input for this final round (since the loop bounds
-		* are the same). */
-	   for( i = 0; i < leftover; i++ )
-	   {
-		   output[i] = prev_output[i];
-		   tmp[i] = input[i] ^ t[i];
-	   }
-
-	   /* Copy ciphertext bytes from the previous block for input in this
-		* round. */
-	   for( ; i < 16; i++ )
-		   tmp[i] = prev_output[i] ^ t[i];
-
-	   ret = mbedtls_aes_crypt_ecb( &ctx->crypt, mode, tmp, tmp );
-	   if( ret != 0 )
-		   return ret;
-
-	   /* Write the result back to the previous block, overriding the previous
-		* output we copied. */
-	   for( i = 0; i < 16; i++ )
-		   prev_output[i] = tmp[i] ^ t[i];
-   }
-
-   return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/*
-* AES-CFB128 buffer encryption/decryption
-*/
-int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
-							int mode,
-							size_t length,
-							size_t *iv_off,
-							unsigned char iv[16],
-							const unsigned char *input,
-							unsigned char *output )
-{
-   int c;
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   size_t n;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||
-					mode == MBEDTLS_AES_DECRYPT );
-   AES_VALIDATE_RET( iv_off != NULL );
-   AES_VALIDATE_RET( iv != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-
-   n = *iv_off;
-
-   if( n > 15 )
-	   return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );
-
-   if( mode == MBEDTLS_AES_DECRYPT )
-   {
-	   while( length-- )
-	   {
-		   if( n == 0 )
-		   {
-			   ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
-			   if( ret != 0 )
-				   goto exit;
-		   }
-
-		   c = *input++;
-		   *output++ = (unsigned char)( c ^ iv[n] );
-		   iv[n] = (unsigned char) c;
-
-		   n = ( n + 1 ) & 0x0F;
-	   }
-   }
-   else
-   {
-	   while( length-- )
-	   {
-		   if( n == 0 )
-		   {
-			   ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
-			   if( ret != 0 )
-				   goto exit;
-		   }
-
-		   iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
-
-		   n = ( n + 1 ) & 0x0F;
-	   }
-   }
-
-   *iv_off = n;
-   ret = 0;
-
-exit:
-   return( ret );
-}
-
-/*
-* AES-CFB8 buffer encryption/decryption
-*/
-int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
-						  int mode,
-						  size_t length,
-						  unsigned char iv[16],
-						  const unsigned char *input,
-						  unsigned char *output )
-{
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   unsigned char c;
-   unsigned char ov[17];
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||
-					mode == MBEDTLS_AES_DECRYPT );
-   AES_VALIDATE_RET( iv != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-   while( length-- )
-   {
-	   memcpy( ov, iv, 16 );
-	   ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
-	   if( ret != 0 )
-		   goto exit;
-
-	   if( mode == MBEDTLS_AES_DECRYPT )
-		   ov[16] = *input;
-
-	   c = *output++ = (unsigned char)( iv[0] ^ *input++ );
-
-	   if( mode == MBEDTLS_AES_ENCRYPT )
-		   ov[16] = c;
-
-	   memcpy( iv, ov + 1, 16 );
-   }
-   ret = 0;
-
-exit:
-   return( ret );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-/*
-* AES-OFB (Output Feedback Mode) buffer encryption/decryption
-*/
-int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,
-						 size_t length,
-						 size_t *iv_off,
-						 unsigned char iv[16],
-						 const unsigned char *input,
-						 unsigned char *output )
-{
-   int ret = 0;
-   size_t n;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( iv_off != NULL );
-   AES_VALIDATE_RET( iv != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-
-   n = *iv_off;
-
-   if( n > 15 )
-	   return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );
-
-   while( length-- )
-   {
-	   if( n == 0 )
-	   {
-		   ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
-		   if( ret != 0 )
-			   goto exit;
-	   }
-	   *output++ =  *input++ ^ iv[n];
-
-	   n = ( n + 1 ) & 0x0F;
-   }
-
-   *iv_off = n;
-
-exit:
-   return( ret );
-}
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/*
-* AES-CTR buffer encryption/decryption
-*/
-int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
-						 size_t length,
-						 size_t *nc_off,
-						 unsigned char nonce_counter[16],
-						 unsigned char stream_block[16],
-						 const unsigned char *input,
-						 unsigned char *output )
-{
-   int c, i;
-   int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-   size_t n;
-
-   AES_VALIDATE_RET( ctx != NULL );
-   AES_VALIDATE_RET( nc_off != NULL );
-   AES_VALIDATE_RET( nonce_counter != NULL );
-   AES_VALIDATE_RET( stream_block != NULL );
-   AES_VALIDATE_RET( input != NULL );
-   AES_VALIDATE_RET( output != NULL );
-
-   n = *nc_off;
-
-   if ( n > 0x0F )
-	   return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );
-
-   while( length-- )
-   {
-	   if( n == 0 ) {
-		   ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block );
-		   if( ret != 0 )
-			   goto exit;
-
-		   for( i = 16; i > 0; i-- )
-			   if( ++nonce_counter[i - 1] != 0 )
-				   break;
-	   }
-	   c = *input++;
-	   *output++ = (unsigned char)( c ^ stream_block[n] );
-
-	   n = ( n + 1 ) & 0x0F;
-   }
-
-   *nc_off = n;
-   ret = 0;
-
-exit:
-   return( ret );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#endif /* !MBEDTLS_AES_ALT */
-
-#if defined(MBEDTLS_SELF_TEST)
-/*
-* AES test vectors from:
-*
-* http://csrc.nist.gov/archive/aes/rijndael/rijndael-vals.zip
-*/
-static const unsigned char aes_test_ecb_dec[3][16] =
-   {
-	   { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
-		0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },
-	   { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
-		0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },
-	   { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
-		0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }
-};
-
-static const unsigned char aes_test_ecb_enc[3][16] =
-   {
-	   { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
-		0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },
-	   { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
-		0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },
-	   { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
-		0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const unsigned char aes_test_cbc_dec[3][16] =
-   {
-	   { 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,
-		0xDF, 0x70, 0x6E, 0x73, 0xF7, 0xC9, 0xAF, 0x86 },
-	   { 0x5D, 0xF6, 0x78, 0xDD, 0x17, 0xBA, 0x4E, 0x75,
-		0xB6, 0x17, 0x68, 0xC6, 0xAD, 0xEF, 0x7C, 0x7B },
-	   { 0x48, 0x04, 0xE1, 0x81, 0x8F, 0xE6, 0x29, 0x75,
-		0x19, 0xA3, 0xE8, 0x8C, 0x57, 0x31, 0x04, 0x13 }
-};
-
-static const unsigned char aes_test_cbc_enc[3][16] =
-   {
-	   { 0x8A, 0x05, 0xFC, 0x5E, 0x09, 0x5A, 0xF4, 0x84,
-		0x8A, 0x08, 0xD3, 0x28, 0xD3, 0x68, 0x8E, 0x3D },
-	   { 0x7B, 0xD9, 0x66, 0xD5, 0x3A, 0xD8, 0xC1, 0xBB,
-		0x85, 0xD2, 0xAD, 0xFA, 0xE8, 0x7B, 0xB1, 0x04 },
-	   { 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,
-		0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0 }
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/*
-* AES-CFB128 test vectors from:
-*
-* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-*/
-static const unsigned char aes_test_cfb128_key[3][32] =
-   {
-	   { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
-		0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },
-	   { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
-		0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
-		0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },
-	   { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
-		0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
-		0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
-		0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
-};
-
-static const unsigned char aes_test_cfb128_iv[16] =
-   {
-	   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-	   0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
-};
-
-static const unsigned char aes_test_cfb128_pt[64] =
-   {
-	   0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
-	   0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
-	   0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
-	   0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
-	   0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
-	   0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
-	   0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
-	   0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
-};
-
-static const unsigned char aes_test_cfb128_ct[3][64] =
-   {
-	   { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
-		0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
-		0xC8, 0xA6, 0x45, 0x37, 0xA0, 0xB3, 0xA9, 0x3F,
-		0xCD, 0xE3, 0xCD, 0xAD, 0x9F, 0x1C, 0xE5, 0x8B,
-		0x26, 0x75, 0x1F, 0x67, 0xA3, 0xCB, 0xB1, 0x40,
-		0xB1, 0x80, 0x8C, 0xF1, 0x87, 0xA4, 0xF4, 0xDF,
-		0xC0, 0x4B, 0x05, 0x35, 0x7C, 0x5D, 0x1C, 0x0E,
-		0xEA, 0xC4, 0xC6, 0x6F, 0x9F, 0xF7, 0xF2, 0xE6 },
-	   { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
-		0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
-		0x67, 0xCE, 0x7F, 0x7F, 0x81, 0x17, 0x36, 0x21,
-		0x96, 0x1A, 0x2B, 0x70, 0x17, 0x1D, 0x3D, 0x7A,
-		0x2E, 0x1E, 0x8A, 0x1D, 0xD5, 0x9B, 0x88, 0xB1,
-		0xC8, 0xE6, 0x0F, 0xED, 0x1E, 0xFA, 0xC4, 0xC9,
-		0xC0, 0x5F, 0x9F, 0x9C, 0xA9, 0x83, 0x4F, 0xA0,
-		0x42, 0xAE, 0x8F, 0xBA, 0x58, 0x4B, 0x09, 0xFF },
-	   { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
-		0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
-		0x39, 0xFF, 0xED, 0x14, 0x3B, 0x28, 0xB1, 0xC8,
-		0x32, 0x11, 0x3C, 0x63, 0x31, 0xE5, 0x40, 0x7B,
-		0xDF, 0x10, 0x13, 0x24, 0x15, 0xE5, 0x4B, 0x92,
-		0xA1, 0x3E, 0xD0, 0xA8, 0x26, 0x7A, 0xE2, 0xF9,
-		0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,
-		0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71 }
-};
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-/*
-* AES-OFB test vectors from:
-*
-* https://csrc.nist.gov/publications/detail/sp/800-38a/final
-*/
-static const unsigned char aes_test_ofb_key[3][32] =
-   {
-	   { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
-		0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },
-	   { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
-		0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
-		0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },
-	   { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
-		0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
-		0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
-		0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
-};
-
-static const unsigned char aes_test_ofb_iv[16] =
-   {
-	   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-	   0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
-};
-
-static const unsigned char aes_test_ofb_pt[64] =
-   {
-	   0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
-	   0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
-	   0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
-	   0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
-	   0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
-	   0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
-	   0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
-	   0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
-};
-
-static const unsigned char aes_test_ofb_ct[3][64] =
-   {
-	   { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
-		0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
-		0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
-		0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25,
-		0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
-		0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc,
-		0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
-		0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e },
-	   { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
-		0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
-		0xfc, 0xc2, 0x8b, 0x8d, 0x4c, 0x63, 0x83, 0x7c,
-		0x09, 0xe8, 0x17, 0x00, 0xc1, 0x10, 0x04, 0x01,
-		0x8d, 0x9a, 0x9a, 0xea, 0xc0, 0xf6, 0x59, 0x6f,
-		0x55, 0x9c, 0x6d, 0x4d, 0xaf, 0x59, 0xa5, 0xf2,
-		0x6d, 0x9f, 0x20, 0x08, 0x57, 0xca, 0x6c, 0x3e,
-		0x9c, 0xac, 0x52, 0x4b, 0xd9, 0xac, 0xc9, 0x2a },
-	   { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
-		0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
-		0x4f, 0xeb, 0xdc, 0x67, 0x40, 0xd2, 0x0b, 0x3a,
-		0xc8, 0x8f, 0x6a, 0xd8, 0x2a, 0x4f, 0xb0, 0x8d,
-		0x71, 0xab, 0x47, 0xa0, 0x86, 0xe8, 0x6e, 0xed,
-		0xf3, 0x9d, 0x1c, 0x5b, 0xba, 0x97, 0xc4, 0x08,
-		0x01, 0x26, 0x14, 0x1d, 0x67, 0xf3, 0x7b, 0xe8,
-		0x53, 0x8f, 0x5a, 0x8b, 0xe7, 0x40, 0xe4, 0x84 }
-};
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/*
-* AES-CTR test vectors from:
-*
-* http://www.faqs.org/rfcs/rfc3686.html
-*/
-
-static const unsigned char aes_test_ctr_key[3][16] =
-   {
-	   { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
-		0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },
-	   { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
-		0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },
-	   { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
-		0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }
-};
-
-static const unsigned char aes_test_ctr_nonce_counter[3][16] =
-   {
-	   { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
-	   { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
-		0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },
-	   { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
-		0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }
-};
-
-static const unsigned char aes_test_ctr_pt[3][48] =
-   {
-	   { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
-		0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },
-
-	   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-		0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-		0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
-
-	   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-		0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-		0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
-		0x20, 0x21, 0x22, 0x23 }
-};
-
-static const unsigned char aes_test_ctr_ct[3][48] =
-   {
-	   { 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,
-		0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8 },
-	   { 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,
-		0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,
-		0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,
-		0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28 },
-	   { 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,
-		0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,
-		0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,
-		0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,
-		0x25, 0xB2, 0x07, 0x2F }
-};
-
-static const int aes_test_ctr_len[3] =
-   { 16, 32, 36 };
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-/*
-* AES-XTS test vectors from:
-*
-* IEEE P1619/D16 Annex B
-* https://web.archive.org/web/20150629024421/http://grouper.ieee.org/groups/1619/email/pdf00086.pdf
-* (Archived from original at http://grouper.ieee.org/groups/1619/email/pdf00086.pdf)
-*/
-static const unsigned char aes_test_xts_key[][32] =
-   {
-	   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-	   { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-		0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-		0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-		0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },
-	   { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
-		0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
-		0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-		0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },
-};
-
-static const unsigned char aes_test_xts_pt32[][32] =
-   {
-	   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-	   { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-		0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-		0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-		0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },
-	   { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-		0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-		0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
-		0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },
-};
-
-static const unsigned char aes_test_xts_ct32[][32] =
-   {
-	   { 0x91, 0x7c, 0xf6, 0x9e, 0xbd, 0x68, 0xb2, 0xec,
-		0x9b, 0x9f, 0xe9, 0xa3, 0xea, 0xdd, 0xa6, 0x92,
-		0xcd, 0x43, 0xd2, 0xf5, 0x95, 0x98, 0xed, 0x85,
-		0x8c, 0x02, 0xc2, 0x65, 0x2f, 0xbf, 0x92, 0x2e },
-	   { 0xc4, 0x54, 0x18, 0x5e, 0x6a, 0x16, 0x93, 0x6e,
-		0x39, 0x33, 0x40, 0x38, 0xac, 0xef, 0x83, 0x8b,
-		0xfb, 0x18, 0x6f, 0xff, 0x74, 0x80, 0xad, 0xc4,
-		0x28, 0x93, 0x82, 0xec, 0xd6, 0xd3, 0x94, 0xf0 },
-	   { 0xaf, 0x85, 0x33, 0x6b, 0x59, 0x7a, 0xfc, 0x1a,
-		0x90, 0x0b, 0x2e, 0xb2, 0x1e, 0xc9, 0x49, 0xd2,
-		0x92, 0xdf, 0x4c, 0x04, 0x7e, 0x0b, 0x21, 0x53,
-		0x21, 0x86, 0xa5, 0x97, 0x1a, 0x22, 0x7a, 0x89 },
-};
-
-static const unsigned char aes_test_xts_data_unit[][16] =
-   {
-	   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-	   { 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-	   { 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-};
-
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-/*
-* Checkup routine
-*/
-int mbedtls_aes_self_test( int verbose )
-{
-   int ret = 0, i, j, u, mode;
-   unsigned int keybits;
-   unsigned char key[32];
-   unsigned char buf[64];
-   const unsigned char *aes_tests;
-#if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB)
-   unsigned char iv[16];
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-   unsigned char prv[16];
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_CFB) || \
-   defined(MBEDTLS_CIPHER_MODE_OFB)
-   size_t offset;
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_XTS)
-   int len;
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-   unsigned char nonce_counter[16];
-   unsigned char stream_block[16];
-#endif
-   mbedtls_aes_context ctx;
-
-   memset( key, 0, 32 );
-   mbedtls_aes_init( &ctx );
-
-   /*
-	* ECB mode
-	*/
-   for( i = 0; i < 6; i++ )
-   {
-	   u = i >> 1;
-	   keybits = 128 + u * 64;
-	   mode = i & 1;
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "  AES-ECB-%3u (%s): ", keybits,
-						  ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
-
-	   memset( buf, 0, 16 );
-
-	   if( mode == MBEDTLS_AES_DECRYPT )
-	   {
-		   ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
-		   aes_tests = aes_test_ecb_dec[u];
-	   }
-	   else
-	   {
-		   ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
-		   aes_tests = aes_test_ecb_enc[u];
-	   }
-
-	   /*
-		* AES-192 is an optional feature that may be unavailable when
-		* there is an alternative underlying implementation i.e. when
-		* MBEDTLS_AES_ALT is defined.
-		*/
-	   if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
-	   {
-		   mbedtls_printf( "skipped\n" );
-		   continue;
-	   }
-	   else if( ret != 0 )
-	   {
-		   goto exit;
-	   }
-
-	   for( j = 0; j < 10000; j++ )
-	   {
-		   ret = mbedtls_aes_crypt_ecb( &ctx, mode, buf, buf );
-		   if( ret != 0 )
-			   goto exit;
-	   }
-
-	   if( memcmp( buf, aes_tests, 16 ) != 0 )
-	   {
-		   ret = 1;
-		   goto exit;
-	   }
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "passed\n" );
-   }
-
-   if( verbose != 0 )
-	   mbedtls_printf( "\n" );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-   /*
-	* CBC mode
-	*/
-   for( i = 0; i < 6; i++ )
-   {
-	   u = i >> 1;
-	   keybits = 128 + u * 64;
-	   mode = i & 1;
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "  AES-CBC-%3u (%s): ", keybits,
-						  ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
-
-	   memset( iv , 0, 16 );
-	   memset( prv, 0, 16 );
-	   memset( buf, 0, 16 );
-
-	   if( mode == MBEDTLS_AES_DECRYPT )
-	   {
-		   ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
-		   aes_tests = aes_test_cbc_dec[u];
-	   }
-	   else
-	   {
-		   ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
-		   aes_tests = aes_test_cbc_enc[u];
-	   }
-
-	   /*
-		* AES-192 is an optional feature that may be unavailable when
-		* there is an alternative underlying implementation i.e. when
-		* MBEDTLS_AES_ALT is defined.
-		*/
-	   if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
-	   {
-		   mbedtls_printf( "skipped\n" );
-		   continue;
-	   }
-	   else if( ret != 0 )
-	   {
-		   goto exit;
-	   }
-
-	   for( j = 0; j < 10000; j++ )
-	   {
-		   if( mode == MBEDTLS_AES_ENCRYPT )
-		   {
-			   unsigned char tmp[16];
-
-			   memcpy( tmp, prv, 16 );
-			   memcpy( prv, buf, 16 );
-			   memcpy( buf, tmp, 16 );
-		   }
-
-		   ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf );
-		   if( ret != 0 )
-			   goto exit;
-
-	   }
-
-	   if( memcmp( buf, aes_tests, 16 ) != 0 )
-	   {
-		   ret = 1;
-		   goto exit;
-	   }
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "passed\n" );
-   }
-
-   if( verbose != 0 )
-	   mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-   /*
-	* CFB128 mode
-	*/
-   for( i = 0; i < 6; i++ )
-   {
-	   u = i >> 1;
-	   keybits = 128 + u * 64;
-	   mode = i & 1;
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "  AES-CFB128-%3u (%s): ", keybits,
-						  ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
-
-	   memcpy( iv,  aes_test_cfb128_iv, 16 );
-	   memcpy( key, aes_test_cfb128_key[u], keybits / 8 );
-
-	   offset = 0;
-	   ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
-	   /*
-		* AES-192 is an optional feature that may be unavailable when
-		* there is an alternative underlying implementation i.e. when
-		* MBEDTLS_AES_ALT is defined.
-		*/
-	   if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
-	   {
-		   mbedtls_printf( "skipped\n" );
-		   continue;
-	   }
-	   else if( ret != 0 )
-	   {
-		   goto exit;
-	   }
-
-	   if( mode == MBEDTLS_AES_DECRYPT )
-	   {
-		   memcpy( buf, aes_test_cfb128_ct[u], 64 );
-		   aes_tests = aes_test_cfb128_pt;
-	   }
-	   else
-	   {
-		   memcpy( buf, aes_test_cfb128_pt, 64 );
-		   aes_tests = aes_test_cfb128_ct[u];
-	   }
-
-	   ret = mbedtls_aes_crypt_cfb128( &ctx, mode, 64, &offset, iv, buf, buf );
-	   if( ret != 0 )
-		   goto exit;
-
-	   if( memcmp( buf, aes_tests, 64 ) != 0 )
-	   {
-		   ret = 1;
-		   goto exit;
-	   }
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "passed\n" );
-   }
-
-   if( verbose != 0 )
-	   mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-   /*
-	* OFB mode
-	*/
-   for( i = 0; i < 6; i++ )
-   {
-	   u = i >> 1;
-	   keybits = 128 + u * 64;
-	   mode = i & 1;
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "  AES-OFB-%3u (%s): ", keybits,
-						  ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
-
-	   memcpy( iv,  aes_test_ofb_iv, 16 );
-	   memcpy( key, aes_test_ofb_key[u], keybits / 8 );
-
-	   offset = 0;
-	   ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
-	   /*
-		* AES-192 is an optional feature that may be unavailable when
-		* there is an alternative underlying implementation i.e. when
-		* MBEDTLS_AES_ALT is defined.
-		*/
-	   if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
-	   {
-		   mbedtls_printf( "skipped\n" );
-		   continue;
-	   }
-	   else if( ret != 0 )
-	   {
-		   goto exit;
-	   }
-
-	   if( mode == MBEDTLS_AES_DECRYPT )
-	   {
-		   memcpy( buf, aes_test_ofb_ct[u], 64 );
-		   aes_tests = aes_test_ofb_pt;
-	   }
-	   else
-	   {
-		   memcpy( buf, aes_test_ofb_pt, 64 );
-		   aes_tests = aes_test_ofb_ct[u];
-	   }
-
-	   ret = mbedtls_aes_crypt_ofb( &ctx, 64, &offset, iv, buf, buf );
-	   if( ret != 0 )
-		   goto exit;
-
-	   if( memcmp( buf, aes_tests, 64 ) != 0 )
-	   {
-		   ret = 1;
-		   goto exit;
-	   }
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "passed\n" );
-   }
-
-   if( verbose != 0 )
-	   mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-   /*
-	* CTR mode
-	*/
-   for( i = 0; i < 6; i++ )
-   {
-	   u = i >> 1;
-	   mode = i & 1;
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "  AES-CTR-128 (%s): ",
-						  ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
-
-	   memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
-	   memcpy( key, aes_test_ctr_key[u], 16 );
-
-	   offset = 0;
-	   if( ( ret = mbedtls_aes_setkey_enc( &ctx, key, 128 ) ) != 0 )
-		   goto exit;
-
-	   len = aes_test_ctr_len[u];
-
-	   if( mode == MBEDTLS_AES_DECRYPT )
-	   {
-		   memcpy( buf, aes_test_ctr_ct[u], len );
-		   aes_tests = aes_test_ctr_pt[u];
-	   }
-	   else
-	   {
-		   memcpy( buf, aes_test_ctr_pt[u], len );
-		   aes_tests = aes_test_ctr_ct[u];
-	   }
-
-	   ret = mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter,
-								   stream_block, buf, buf );
-	   if( ret != 0 )
-		   goto exit;
-
-	   if( memcmp( buf, aes_tests, len ) != 0 )
-	   {
-		   ret = 1;
-		   goto exit;
-	   }
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "passed\n" );
-   }
-
-   if( verbose != 0 )
-	   mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-   {
-	   static const int num_tests =
-		   sizeof(aes_test_xts_key) / sizeof(*aes_test_xts_key);
-	   mbedtls_aes_xts_context ctx_xts;
-
-	   /*
-	* XTS mode
-		*/
-	   mbedtls_aes_xts_init( &ctx_xts );
-
-	   for( i = 0; i < num_tests << 1; i++ )
-	   {
-		   const unsigned char *data_unit;
-		   u = i >> 1;
-		   mode = i & 1;
-
-		   if( verbose != 0 )
-			   mbedtls_printf( "  AES-XTS-128 (%s): ",
-							  ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
-
-		   memset( key, 0, sizeof( key ) );
-		   memcpy( key, aes_test_xts_key[u], 32 );
-		   data_unit = aes_test_xts_data_unit[u];
-
-		   len = sizeof( *aes_test_xts_ct32 );
-
-		   if( mode == MBEDTLS_AES_DECRYPT )
-		   {
-			   ret = mbedtls_aes_xts_setkey_dec( &ctx_xts, key, 256 );
-			   if( ret != 0)
-				   goto exit;
-			   memcpy( buf, aes_test_xts_ct32[u], len );
-			   aes_tests = aes_test_xts_pt32[u];
-		   }
-		   else
-		   {
-			   ret = mbedtls_aes_xts_setkey_enc( &ctx_xts, key, 256 );
-			   if( ret != 0)
-				   goto exit;
-			   memcpy( buf, aes_test_xts_pt32[u], len );
-			   aes_tests = aes_test_xts_ct32[u];
-		   }
-
-
-		   ret = mbedtls_aes_crypt_xts( &ctx_xts, mode, len, data_unit,
-									   buf, buf );
-		   if( ret != 0 )
-			   goto exit;
-
-		   if( memcmp( buf, aes_tests, len ) != 0 )
-		   {
-			   ret = 1;
-			   goto exit;
-		   }
-
-		   if( verbose != 0 )
-			   mbedtls_printf( "passed\n" );
-	   }
-
-	   if( verbose != 0 )
-		   mbedtls_printf( "\n" );
-
-	   mbedtls_aes_xts_free( &ctx_xts );
-   }
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-   ret = 0;
-
-exit:
-   if( ret != 0 && verbose != 0 )
-	   mbedtls_printf( "failed\n" );
-
-   mbedtls_aes_free( &ctx );
-
-   return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_AES_C */
diff --git a/src/duckdb/third_party/mbedtls/library/aesni.h b/src/duckdb/third_party/mbedtls/library/aesni.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/library/aesni.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/library/aria.cpp b/src/duckdb/third_party/mbedtls/library/aria.cpp
deleted file mode 100644
index bc05c4a31..000000000
--- a/src/duckdb/third_party/mbedtls/library/aria.cpp
+++ /dev/null
@@ -1,1058 +0,0 @@
-/*
- *  ARIA implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-/*
- * This implementation is based on the following standards:
- * [1] http://210.104.33.10/ARIA/doc/ARIA-specification-e.pdf
- * [2] https://tools.ietf.org/html/rfc5794
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_ARIA_C)
-
-#include "mbedtls/aria.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_SELF_TEST)
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#define mbedtls_printf printf
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#if !defined(MBEDTLS_ARIA_ALT)
-
-#include "mbedtls/platform_util.h"
-
-#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
-    !defined(inline) && !defined(__cplusplus)
-#define inline __inline
-#endif
-
-/* Parameter validation macros */
-#define ARIA_VALIDATE_RET( cond )                                       \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_ARIA_BAD_INPUT_DATA )
-#define ARIA_VALIDATE( cond )                                           \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-/*
- * modify byte order: ( A B C D ) -> ( B A D C ), i.e. swap pairs of bytes
- *
- * This is submatrix P1 in [1] Appendix B.1
- *
- * Common compilers fail to translate this to minimal number of instructions,
- * so let's provide asm versions for common platforms with C fallback.
- */
-#if defined(MBEDTLS_HAVE_ASM)
-#if defined(__arm__) /* rev16 available from v6 up */
-/* armcc5 --gnu defines __GNUC__ but doesn't support GNU's extended asm */
-#if defined(__GNUC__) && \
-    ( !defined(__ARMCC_VERSION) || __ARMCC_VERSION >= 6000000 ) && \
-    __ARM_ARCH >= 6
-static inline uint32_t aria_p1( uint32_t x )
-{
-    uint32_t r;
-    __asm( "rev16 %0, %1" : "=l" (r) : "l" (x) );
-    return( r );
-}
-#define ARIA_P1 aria_p1
-#elif defined(__ARMCC_VERSION) && __ARMCC_VERSION < 6000000 && \
-    ( __TARGET_ARCH_ARM >= 6 || __TARGET_ARCH_THUMB >= 3 )
-static inline uint32_t aria_p1( uint32_t x )
-{
-    uint32_t r;
-    __asm( "rev16 r, x" );
-    return( r );
-}
-#define ARIA_P1 aria_p1
-#endif
-#endif /* arm */
-#if defined(__GNUC__) && \
-    defined(__i386__) || defined(__amd64__) || defined( __x86_64__)
-/* I couldn't find an Intel equivalent of rev16, so two instructions */
-#define ARIA_P1(x) ARIA_P2( ARIA_P3( x ) )
-#endif /* x86 gnuc */
-#endif /* MBEDTLS_HAVE_ASM && GNUC */
-#if !defined(ARIA_P1)
-#define ARIA_P1(x) ((((x) >> 8) & 0x00FF00FF) ^ (((x) & 0x00FF00FF) << 8))
-#endif
-
-/*
- * modify byte order: ( A B C D ) -> ( C D A B ), i.e. rotate by 16 bits
- *
- * This is submatrix P2 in [1] Appendix B.1
- *
- * Common compilers will translate this to a single instruction.
- */
-#define ARIA_P2(x) (((x) >> 16) ^ ((x) << 16))
-
-/*
- * modify byte order: ( A B C D ) -> ( D C B A ), i.e. change endianness
- *
- * This is submatrix P3 in [1] Appendix B.1
- *
- * Some compilers fail to translate this to a single instruction,
- * so let's provide asm versions for common platforms with C fallback.
- */
-#if defined(MBEDTLS_HAVE_ASM)
-#if defined(__arm__) /* rev available from v6 up */
-/* armcc5 --gnu defines __GNUC__ but doesn't support GNU's extended asm */
-#if defined(__GNUC__) && \
-    ( !defined(__ARMCC_VERSION) || __ARMCC_VERSION >= 6000000 ) && \
-    __ARM_ARCH >= 6
-static inline uint32_t aria_p3( uint32_t x )
-{
-    uint32_t r;
-    __asm( "rev %0, %1" : "=l" (r) : "l" (x) );
-    return( r );
-}
-#define ARIA_P3 aria_p3
-#elif defined(__ARMCC_VERSION) && __ARMCC_VERSION < 6000000 && \
-    ( __TARGET_ARCH_ARM >= 6 || __TARGET_ARCH_THUMB >= 3 )
-static inline uint32_t aria_p3( uint32_t x )
-{
-    uint32_t r;
-    __asm( "rev r, x" );
-    return( r );
-}
-#define ARIA_P3 aria_p3
-#endif
-#endif /* arm */
-#if defined(__GNUC__) && \
-    defined(__i386__) || defined(__amd64__) || defined( __x86_64__)
-static inline uint32_t aria_p3( uint32_t x )
-{
-    __asm( "bswap %0" : "=r" (x) : "0" (x) );
-    return( x );
-}
-#define ARIA_P3 aria_p3
-#endif /* x86 gnuc */
-#endif /* MBEDTLS_HAVE_ASM && GNUC */
-#if !defined(ARIA_P3)
-#define ARIA_P3(x) ARIA_P2( ARIA_P1 ( x ) )
-#endif
-
-/*
- * ARIA Affine Transform
- * (a, b, c, d) = state in/out
- *
- * If we denote the first byte of input by 0, ..., the last byte by f,
- * then inputs are: a = 0123, b = 4567, c = 89ab, d = cdef.
- *
- * Reading [1] 2.4 or [2] 2.4.3 in columns and performing simple
- * rearrangements on adjacent pairs, output is:
- *
- * a = 3210 + 4545 + 6767 + 88aa + 99bb + dccd + effe
- *   = 3210 + 4567 + 6745 + 89ab + 98ba + dcfe + efcd
- * b = 0101 + 2323 + 5476 + 8998 + baab + eecc + ffdd
- *   = 0123 + 2301 + 5476 + 89ab + ba98 + efcd + fedc
- * c = 0022 + 1133 + 4554 + 7667 + ab89 + dcdc + fefe
- *   = 0123 + 1032 + 4567 + 7654 + ab89 + dcfe + fedc
- * d = 1001 + 2332 + 6644 + 7755 + 9898 + baba + cdef
- *   = 1032 + 2301 + 6745 + 7654 + 98ba + ba98 + cdef
- *
- * Note: another presentation of the A transform can be found as the first
- * half of App. B.1 in [1] in terms of 4-byte operators P1, P2, P3 and P4.
- * The implementation below uses only P1 and P2 as they are sufficient.
- */
-static inline void aria_a( uint32_t *a, uint32_t *b,
-                           uint32_t *c, uint32_t *d )
-{
-    uint32_t ta, tb, tc;
-    ta  =  *b;                      // 4567
-    *b  =  *a;                      // 0123
-    *a  =  ARIA_P2( ta );           // 6745
-    tb  =  ARIA_P2( *d );           // efcd
-    *d  =  ARIA_P1( *c );           // 98ba
-    *c  =  ARIA_P1( tb );           // fedc
-    ta  ^= *d;                      // 4567+98ba
-    tc  =  ARIA_P2( *b );           // 2301
-    ta  =  ARIA_P1( ta ) ^ tc ^ *c; // 2301+5476+89ab+fedc
-    tb  ^= ARIA_P2( *d );           // ba98+efcd
-    tc  ^= ARIA_P1( *a );           // 2301+7654
-    *b  ^= ta ^ tb;                 // 0123+2301+5476+89ab+ba98+efcd+fedc OUT
-    tb  =  ARIA_P2( tb ) ^ ta;      // 2301+5476+89ab+98ba+cdef+fedc
-    *a  ^= ARIA_P1( tb );           // 3210+4567+6745+89ab+98ba+dcfe+efcd OUT
-    ta  =  ARIA_P2( ta );           // 0123+7654+ab89+dcfe
-    *d  ^= ARIA_P1( ta ) ^ tc;      // 1032+2301+6745+7654+98ba+ba98+cdef OUT
-    tc  =  ARIA_P2( tc );           // 0123+5476
-    *c  ^= ARIA_P1( tc ) ^ ta;      // 0123+1032+4567+7654+ab89+dcfe+fedc OUT
-}
-
-/*
- * ARIA Substitution Layer SL1 / SL2
- * (a, b, c, d) = state in/out
- * (sa, sb, sc, sd) = 256 8-bit S-Boxes (see below)
- *
- * By passing sb1, sb2, is1, is2 as S-Boxes you get SL1
- * By passing is1, is2, sb1, sb2 as S-Boxes you get SL2
- */
-static inline void aria_sl( uint32_t *a, uint32_t *b,
-                            uint32_t *c, uint32_t *d,
-                            const uint8_t sa[256], const uint8_t sb[256],
-                            const uint8_t sc[256], const uint8_t sd[256] )
-{
-    *a = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *a ) ]       ) ^
-         (((uint32_t) sb[ MBEDTLS_BYTE_1( *a ) ]) <<  8) ^
-         (((uint32_t) sc[ MBEDTLS_BYTE_2( *a ) ]) << 16) ^
-         (((uint32_t) sd[ MBEDTLS_BYTE_3( *a ) ]) << 24);
-    *b = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *b ) ]       ) ^
-         (((uint32_t) sb[ MBEDTLS_BYTE_1( *b ) ]) <<  8) ^
-         (((uint32_t) sc[ MBEDTLS_BYTE_2( *b ) ]) << 16) ^
-         (((uint32_t) sd[ MBEDTLS_BYTE_3( *b ) ]) << 24);
-    *c = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *c ) ]       ) ^
-         (((uint32_t) sb[ MBEDTLS_BYTE_1( *c ) ]) <<  8) ^
-         (((uint32_t) sc[ MBEDTLS_BYTE_2( *c ) ]) << 16) ^
-         (((uint32_t) sd[ MBEDTLS_BYTE_3( *c ) ]) << 24);
-    *d = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *d ) ]       ) ^
-         (((uint32_t) sb[ MBEDTLS_BYTE_1( *d ) ]) <<  8) ^
-         (((uint32_t) sc[ MBEDTLS_BYTE_2( *d ) ]) << 16) ^
-         (((uint32_t) sd[ MBEDTLS_BYTE_3( *d ) ]) << 24);
-}
-
-/*
- * S-Boxes
- */
-static const uint8_t aria_sb1[256] =
-{
-    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B,
-    0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
-    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26,
-    0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
-    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2,
-    0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
-    0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED,
-    0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
-    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F,
-    0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
-    0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC,
-    0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
-    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14,
-    0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
-    0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D,
-    0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
-    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F,
-    0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
-    0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11,
-    0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
-    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F,
-    0xB0, 0x54, 0xBB, 0x16
-};
-
-static const uint8_t aria_sb2[256] =
-{
-    0xE2, 0x4E, 0x54, 0xFC, 0x94, 0xC2, 0x4A, 0xCC, 0x62, 0x0D, 0x6A, 0x46,
-    0x3C, 0x4D, 0x8B, 0xD1, 0x5E, 0xFA, 0x64, 0xCB, 0xB4, 0x97, 0xBE, 0x2B,
-    0xBC, 0x77, 0x2E, 0x03, 0xD3, 0x19, 0x59, 0xC1, 0x1D, 0x06, 0x41, 0x6B,
-    0x55, 0xF0, 0x99, 0x69, 0xEA, 0x9C, 0x18, 0xAE, 0x63, 0xDF, 0xE7, 0xBB,
-    0x00, 0x73, 0x66, 0xFB, 0x96, 0x4C, 0x85, 0xE4, 0x3A, 0x09, 0x45, 0xAA,
-    0x0F, 0xEE, 0x10, 0xEB, 0x2D, 0x7F, 0xF4, 0x29, 0xAC, 0xCF, 0xAD, 0x91,
-    0x8D, 0x78, 0xC8, 0x95, 0xF9, 0x2F, 0xCE, 0xCD, 0x08, 0x7A, 0x88, 0x38,
-    0x5C, 0x83, 0x2A, 0x28, 0x47, 0xDB, 0xB8, 0xC7, 0x93, 0xA4, 0x12, 0x53,
-    0xFF, 0x87, 0x0E, 0x31, 0x36, 0x21, 0x58, 0x48, 0x01, 0x8E, 0x37, 0x74,
-    0x32, 0xCA, 0xE9, 0xB1, 0xB7, 0xAB, 0x0C, 0xD7, 0xC4, 0x56, 0x42, 0x26,
-    0x07, 0x98, 0x60, 0xD9, 0xB6, 0xB9, 0x11, 0x40, 0xEC, 0x20, 0x8C, 0xBD,
-    0xA0, 0xC9, 0x84, 0x04, 0x49, 0x23, 0xF1, 0x4F, 0x50, 0x1F, 0x13, 0xDC,
-    0xD8, 0xC0, 0x9E, 0x57, 0xE3, 0xC3, 0x7B, 0x65, 0x3B, 0x02, 0x8F, 0x3E,
-    0xE8, 0x25, 0x92, 0xE5, 0x15, 0xDD, 0xFD, 0x17, 0xA9, 0xBF, 0xD4, 0x9A,
-    0x7E, 0xC5, 0x39, 0x67, 0xFE, 0x76, 0x9D, 0x43, 0xA7, 0xE1, 0xD0, 0xF5,
-    0x68, 0xF2, 0x1B, 0x34, 0x70, 0x05, 0xA3, 0x8A, 0xD5, 0x79, 0x86, 0xA8,
-    0x30, 0xC6, 0x51, 0x4B, 0x1E, 0xA6, 0x27, 0xF6, 0x35, 0xD2, 0x6E, 0x24,
-    0x16, 0x82, 0x5F, 0xDA, 0xE6, 0x75, 0xA2, 0xEF, 0x2C, 0xB2, 0x1C, 0x9F,
-    0x5D, 0x6F, 0x80, 0x0A, 0x72, 0x44, 0x9B, 0x6C, 0x90, 0x0B, 0x5B, 0x33,
-    0x7D, 0x5A, 0x52, 0xF3, 0x61, 0xA1, 0xF7, 0xB0, 0xD6, 0x3F, 0x7C, 0x6D,
-    0xED, 0x14, 0xE0, 0xA5, 0x3D, 0x22, 0xB3, 0xF8, 0x89, 0xDE, 0x71, 0x1A,
-    0xAF, 0xBA, 0xB5, 0x81
-};
-
-static const uint8_t aria_is1[256] =
-{
-    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E,
-    0x81, 0xF3, 0xD7, 0xFB, 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
-    0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, 0x54, 0x7B, 0x94, 0x32,
-    0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
-    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49,
-    0x6D, 0x8B, 0xD1, 0x25, 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
-    0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92, 0x6C, 0x70, 0x48, 0x50,
-    0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
-    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05,
-    0xB8, 0xB3, 0x45, 0x06, 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
-    0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B, 0x3A, 0x91, 0x11, 0x41,
-    0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
-    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8,
-    0x1C, 0x75, 0xDF, 0x6E, 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
-    0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x3E, 0x4B,
-    0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
-    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59,
-    0x27, 0x80, 0xEC, 0x5F, 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
-    0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF, 0xA0, 0xE0, 0x3B, 0x4D,
-    0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
-    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63,
-    0x55, 0x21, 0x0C, 0x7D
-};
-
-static const uint8_t aria_is2[256] =
-{
-    0x30, 0x68, 0x99, 0x1B, 0x87, 0xB9, 0x21, 0x78, 0x50, 0x39, 0xDB, 0xE1,
-    0x72, 0x09, 0x62, 0x3C, 0x3E, 0x7E, 0x5E, 0x8E, 0xF1, 0xA0, 0xCC, 0xA3,
-    0x2A, 0x1D, 0xFB, 0xB6, 0xD6, 0x20, 0xC4, 0x8D, 0x81, 0x65, 0xF5, 0x89,
-    0xCB, 0x9D, 0x77, 0xC6, 0x57, 0x43, 0x56, 0x17, 0xD4, 0x40, 0x1A, 0x4D,
-    0xC0, 0x63, 0x6C, 0xE3, 0xB7, 0xC8, 0x64, 0x6A, 0x53, 0xAA, 0x38, 0x98,
-    0x0C, 0xF4, 0x9B, 0xED, 0x7F, 0x22, 0x76, 0xAF, 0xDD, 0x3A, 0x0B, 0x58,
-    0x67, 0x88, 0x06, 0xC3, 0x35, 0x0D, 0x01, 0x8B, 0x8C, 0xC2, 0xE6, 0x5F,
-    0x02, 0x24, 0x75, 0x93, 0x66, 0x1E, 0xE5, 0xE2, 0x54, 0xD8, 0x10, 0xCE,
-    0x7A, 0xE8, 0x08, 0x2C, 0x12, 0x97, 0x32, 0xAB, 0xB4, 0x27, 0x0A, 0x23,
-    0xDF, 0xEF, 0xCA, 0xD9, 0xB8, 0xFA, 0xDC, 0x31, 0x6B, 0xD1, 0xAD, 0x19,
-    0x49, 0xBD, 0x51, 0x96, 0xEE, 0xE4, 0xA8, 0x41, 0xDA, 0xFF, 0xCD, 0x55,
-    0x86, 0x36, 0xBE, 0x61, 0x52, 0xF8, 0xBB, 0x0E, 0x82, 0x48, 0x69, 0x9A,
-    0xE0, 0x47, 0x9E, 0x5C, 0x04, 0x4B, 0x34, 0x15, 0x79, 0x26, 0xA7, 0xDE,
-    0x29, 0xAE, 0x92, 0xD7, 0x84, 0xE9, 0xD2, 0xBA, 0x5D, 0xF3, 0xC5, 0xB0,
-    0xBF, 0xA4, 0x3B, 0x71, 0x44, 0x46, 0x2B, 0xFC, 0xEB, 0x6F, 0xD5, 0xF6,
-    0x14, 0xFE, 0x7C, 0x70, 0x5A, 0x7D, 0xFD, 0x2F, 0x18, 0x83, 0x16, 0xA5,
-    0x91, 0x1F, 0x05, 0x95, 0x74, 0xA9, 0xC1, 0x5B, 0x4A, 0x85, 0x6D, 0x13,
-    0x07, 0x4F, 0x4E, 0x45, 0xB2, 0x0F, 0xC9, 0x1C, 0xA6, 0xBC, 0xEC, 0x73,
-    0x90, 0x7B, 0xCF, 0x59, 0x8F, 0xA1, 0xF9, 0x2D, 0xF2, 0xB1, 0x00, 0x94,
-    0x37, 0x9F, 0xD0, 0x2E, 0x9C, 0x6E, 0x28, 0x3F, 0x80, 0xF0, 0x3D, 0xD3,
-    0x25, 0x8A, 0xB5, 0xE7, 0x42, 0xB3, 0xC7, 0xEA, 0xF7, 0x4C, 0x11, 0x33,
-    0x03, 0xA2, 0xAC, 0x60
-};
-
-/*
- * Helper for key schedule: r = FO( p, k ) ^ x
- */
-static void aria_fo_xor( uint32_t r[4], const uint32_t p[4],
-                         const uint32_t k[4], const uint32_t x[4] )
-{
-    uint32_t a, b, c, d;
-
-    a = p[0] ^ k[0];
-    b = p[1] ^ k[1];
-    c = p[2] ^ k[2];
-    d = p[3] ^ k[3];
-
-    aria_sl( &a, &b, &c, &d, aria_sb1, aria_sb2, aria_is1, aria_is2 );
-    aria_a( &a, &b, &c, &d );
-
-    r[0] = a ^ x[0];
-    r[1] = b ^ x[1];
-    r[2] = c ^ x[2];
-    r[3] = d ^ x[3];
-}
-
-/*
- * Helper for key schedule: r = FE( p, k ) ^ x
- */
-static void aria_fe_xor( uint32_t r[4], const uint32_t p[4],
-                         const uint32_t k[4], const uint32_t x[4] )
-{
-    uint32_t a, b, c, d;
-
-    a = p[0] ^ k[0];
-    b = p[1] ^ k[1];
-    c = p[2] ^ k[2];
-    d = p[3] ^ k[3];
-
-    aria_sl( &a, &b, &c, &d, aria_is1, aria_is2, aria_sb1, aria_sb2 );
-    aria_a( &a, &b, &c, &d );
-
-    r[0] = a ^ x[0];
-    r[1] = b ^ x[1];
-    r[2] = c ^ x[2];
-    r[3] = d ^ x[3];
-}
-
-/*
- * Big endian 128-bit rotation: r = a ^ (b <<< n), used only in key setup.
- *
- * We chose to store bytes into 32-bit words in little-endian format (see
- * MBEDTLS_GET_UINT32_LE / MBEDTLS_PUT_UINT32_LE ) so we need to reverse
- * bytes here.
- */
-static void aria_rot128( uint32_t r[4], const uint32_t a[4],
-                         const uint32_t b[4], uint8_t n )
-{
-    uint8_t i, j;
-    uint32_t t, u;
-
-    const uint8_t n1 = n % 32;              // bit offset
-    const uint8_t n2 = n1 ? 32 - n1 : 0;    // reverse bit offset
-
-    j = ( n / 32 ) % 4;                     // initial word offset
-    t = ARIA_P3( b[j] );                    // big endian
-    for( i = 0; i < 4; i++ )
-    {
-        j = ( j + 1 ) % 4;                  // get next word, big endian
-        u = ARIA_P3( b[j] );
-        t <<= n1;                           // rotate
-        t |= u >> n2;
-        t = ARIA_P3( t );                   // back to little endian
-        r[i] = a[i] ^ t;                    // store
-        t = u;                              // move to next word
-    }
-}
-
-/*
- * Set encryption key
- */
-int mbedtls_aria_setkey_enc( mbedtls_aria_context *ctx,
-                             const unsigned char *key, unsigned int keybits )
-{
-    /* round constant masks */
-    const uint32_t rc[3][4] =
-    {
-        {   0xB7C17C51, 0x940A2227, 0xE8AB13FE, 0xE06E9AFA  },
-        {   0xCC4AB16D, 0x20C8219E, 0xD5B128FF, 0xB0E25DEF  },
-        {   0x1D3792DB, 0x70E92621, 0x75972403, 0x0EC9E804  }
-    };
-
-    int i;
-    uint32_t w[4][4], *w2;
-    ARIA_VALIDATE_RET( ctx != NULL );
-    ARIA_VALIDATE_RET( key != NULL );
-
-    if( keybits != 128 && keybits != 192 && keybits != 256 )
-        return( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA );
-
-    /* Copy key to W0 (and potential remainder to W1) */
-    w[0][0] = MBEDTLS_GET_UINT32_LE( key,  0 );
-    w[0][1] = MBEDTLS_GET_UINT32_LE( key,  4 );
-    w[0][2] = MBEDTLS_GET_UINT32_LE( key,  8 );
-    w[0][3] = MBEDTLS_GET_UINT32_LE( key, 12 );
-
-    memset( w[1], 0, 16 );
-    if( keybits >= 192 )
-    {
-        w[1][0] = MBEDTLS_GET_UINT32_LE( key, 16 );  // 192 bit key
-        w[1][1] = MBEDTLS_GET_UINT32_LE( key, 20 );
-    }
-    if( keybits == 256 )
-    {
-        w[1][2] = MBEDTLS_GET_UINT32_LE( key, 24 );  // 256 bit key
-        w[1][3] = MBEDTLS_GET_UINT32_LE( key, 28 );
-    }
-
-    i = ( keybits - 128 ) >> 6;             // index: 0, 1, 2
-    ctx->nr = 12 + 2 * i;                   // no. rounds: 12, 14, 16
-
-    aria_fo_xor( w[1], w[0], rc[i], w[1] ); // W1 = FO(W0, CK1) ^ KR
-    i = i < 2 ? i + 1 : 0;
-    aria_fe_xor( w[2], w[1], rc[i], w[0] ); // W2 = FE(W1, CK2) ^ W0
-    i = i < 2 ? i + 1 : 0;
-    aria_fo_xor( w[3], w[2], rc[i], w[1] ); // W3 = FO(W2, CK3) ^ W1
-
-    for( i = 0; i < 4; i++ )                // create round keys
-    {
-        w2 = w[(i + 1) & 3];
-        aria_rot128( ctx->rk[i     ], w[i], w2, 128 - 19 );
-        aria_rot128( ctx->rk[i +  4], w[i], w2, 128 - 31 );
-        aria_rot128( ctx->rk[i +  8], w[i], w2,       61 );
-        aria_rot128( ctx->rk[i + 12], w[i], w2,       31 );
-    }
-    aria_rot128( ctx->rk[16], w[0], w[1], 19 );
-
-    /* w holds enough info to reconstruct the round keys */
-    mbedtls_platform_zeroize( w, sizeof( w ) );
-
-    return( 0 );
-}
-
-/*
- * Set decryption key
- */
-int mbedtls_aria_setkey_dec( mbedtls_aria_context *ctx,
-                             const unsigned char *key, unsigned int keybits )
-{
-    int i, j, k, ret;
-    ARIA_VALIDATE_RET( ctx != NULL );
-    ARIA_VALIDATE_RET( key != NULL );
-
-    ret = mbedtls_aria_setkey_enc( ctx, key, keybits );
-    if( ret != 0 )
-        return( ret );
-
-    /* flip the order of round keys */
-    for( i = 0, j = ctx->nr; i < j; i++, j-- )
-    {
-        for( k = 0; k < 4; k++ )
-        {
-            uint32_t t = ctx->rk[i][k];
-            ctx->rk[i][k] = ctx->rk[j][k];
-            ctx->rk[j][k] = t;
-        }
-    }
-
-    /* apply affine transform to middle keys */
-    for( i = 1; i < ctx->nr; i++ )
-    {
-        aria_a( &ctx->rk[i][0], &ctx->rk[i][1],
-                &ctx->rk[i][2], &ctx->rk[i][3] );
-    }
-
-    return( 0 );
-}
-
-/*
- * Encrypt a block
- */
-int mbedtls_aria_crypt_ecb( mbedtls_aria_context *ctx,
-                            const unsigned char input[MBEDTLS_ARIA_BLOCKSIZE],
-                            unsigned char output[MBEDTLS_ARIA_BLOCKSIZE] )
-{
-    int i;
-
-    uint32_t a, b, c, d;
-    ARIA_VALIDATE_RET( ctx != NULL );
-    ARIA_VALIDATE_RET( input != NULL );
-    ARIA_VALIDATE_RET( output != NULL );
-
-    a = MBEDTLS_GET_UINT32_LE( input,  0 );
-    b = MBEDTLS_GET_UINT32_LE( input,  4 );
-    c = MBEDTLS_GET_UINT32_LE( input,  8 );
-    d = MBEDTLS_GET_UINT32_LE( input, 12 );
-
-    i = 0;
-    while( 1 )
-    {
-        a ^= ctx->rk[i][0];
-        b ^= ctx->rk[i][1];
-        c ^= ctx->rk[i][2];
-        d ^= ctx->rk[i][3];
-        i++;
-
-        aria_sl( &a, &b, &c, &d, aria_sb1, aria_sb2, aria_is1, aria_is2 );
-        aria_a( &a, &b, &c, &d );
-
-        a ^= ctx->rk[i][0];
-        b ^= ctx->rk[i][1];
-        c ^= ctx->rk[i][2];
-        d ^= ctx->rk[i][3];
-        i++;
-
-        aria_sl( &a, &b, &c, &d, aria_is1, aria_is2, aria_sb1, aria_sb2 );
-        if( i >= ctx->nr )
-            break;
-        aria_a( &a, &b, &c, &d );
-    }
-
-    /* final key mixing */
-    a ^= ctx->rk[i][0];
-    b ^= ctx->rk[i][1];
-    c ^= ctx->rk[i][2];
-    d ^= ctx->rk[i][3];
-
-    MBEDTLS_PUT_UINT32_LE( a, output,  0 );
-    MBEDTLS_PUT_UINT32_LE( b, output,  4 );
-    MBEDTLS_PUT_UINT32_LE( c, output,  8 );
-    MBEDTLS_PUT_UINT32_LE( d, output, 12 );
-
-    return( 0 );
-}
-
-/* Initialize context */
-void mbedtls_aria_init( mbedtls_aria_context *ctx )
-{
-    ARIA_VALIDATE( ctx != NULL );
-    memset( ctx, 0, sizeof( mbedtls_aria_context ) );
-}
-
-/* Clear context */
-void mbedtls_aria_free( mbedtls_aria_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_aria_context ) );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/*
- * ARIA-CBC buffer encryption/decryption
- */
-int mbedtls_aria_crypt_cbc( mbedtls_aria_context *ctx,
-                            int mode,
-                            size_t length,
-                            unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE],
-                            const unsigned char *input,
-                            unsigned char *output )
-{
-    int i;
-    unsigned char temp[MBEDTLS_ARIA_BLOCKSIZE];
-
-    ARIA_VALIDATE_RET( ctx != NULL );
-    ARIA_VALIDATE_RET( mode == MBEDTLS_ARIA_ENCRYPT ||
-                       mode == MBEDTLS_ARIA_DECRYPT );
-    ARIA_VALIDATE_RET( length == 0 || input  != NULL );
-    ARIA_VALIDATE_RET( length == 0 || output != NULL );
-    ARIA_VALIDATE_RET( iv != NULL );
-
-    if( length % MBEDTLS_ARIA_BLOCKSIZE )
-        return( MBEDTLS_ERR_ARIA_INVALID_INPUT_LENGTH );
-
-    if( mode == MBEDTLS_ARIA_DECRYPT )
-    {
-        while( length > 0 )
-        {
-            memcpy( temp, input, MBEDTLS_ARIA_BLOCKSIZE );
-            mbedtls_aria_crypt_ecb( ctx, input, output );
-
-            for( i = 0; i < MBEDTLS_ARIA_BLOCKSIZE; i++ )
-                output[i] = (unsigned char)( output[i] ^ iv[i] );
-
-            memcpy( iv, temp, MBEDTLS_ARIA_BLOCKSIZE );
-
-            input  += MBEDTLS_ARIA_BLOCKSIZE;
-            output += MBEDTLS_ARIA_BLOCKSIZE;
-            length -= MBEDTLS_ARIA_BLOCKSIZE;
-        }
-    }
-    else
-    {
-        while( length > 0 )
-        {
-            for( i = 0; i < MBEDTLS_ARIA_BLOCKSIZE; i++ )
-                output[i] = (unsigned char)( input[i] ^ iv[i] );
-
-            mbedtls_aria_crypt_ecb( ctx, output, output );
-            memcpy( iv, output, MBEDTLS_ARIA_BLOCKSIZE );
-
-            input  += MBEDTLS_ARIA_BLOCKSIZE;
-            output += MBEDTLS_ARIA_BLOCKSIZE;
-            length -= MBEDTLS_ARIA_BLOCKSIZE;
-        }
-    }
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/*
- * ARIA-CFB128 buffer encryption/decryption
- */
-int mbedtls_aria_crypt_cfb128( mbedtls_aria_context *ctx,
-                               int mode,
-                               size_t length,
-                               size_t *iv_off,
-                               unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE],
-                               const unsigned char *input,
-                               unsigned char *output )
-{
-    unsigned char c;
-    size_t n;
-
-    ARIA_VALIDATE_RET( ctx != NULL );
-    ARIA_VALIDATE_RET( mode == MBEDTLS_ARIA_ENCRYPT ||
-                       mode == MBEDTLS_ARIA_DECRYPT );
-    ARIA_VALIDATE_RET( length == 0 || input  != NULL );
-    ARIA_VALIDATE_RET( length == 0 || output != NULL );
-    ARIA_VALIDATE_RET( iv != NULL );
-    ARIA_VALIDATE_RET( iv_off != NULL );
-
-    n = *iv_off;
-
-    /* An overly large value of n can lead to an unlimited
-     * buffer overflow. Therefore, guard against this
-     * outside of parameter validation. */
-    if( n >= MBEDTLS_ARIA_BLOCKSIZE )
-        return( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA );
-
-    if( mode == MBEDTLS_ARIA_DECRYPT )
-    {
-        while( length-- )
-        {
-            if( n == 0 )
-                mbedtls_aria_crypt_ecb( ctx, iv, iv );
-
-            c = *input++;
-            *output++ = c ^ iv[n];
-            iv[n] = c;
-
-            n = ( n + 1 ) & 0x0F;
-        }
-    }
-    else
-    {
-        while( length-- )
-        {
-            if( n == 0 )
-                mbedtls_aria_crypt_ecb( ctx, iv, iv );
-
-            iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
-
-            n = ( n + 1 ) & 0x0F;
-        }
-    }
-
-    *iv_off = n;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/*
- * ARIA-CTR buffer encryption/decryption
- */
-int mbedtls_aria_crypt_ctr( mbedtls_aria_context *ctx,
-                            size_t length,
-                            size_t *nc_off,
-                            unsigned char nonce_counter[MBEDTLS_ARIA_BLOCKSIZE],
-                            unsigned char stream_block[MBEDTLS_ARIA_BLOCKSIZE],
-                            const unsigned char *input,
-                            unsigned char *output )
-{
-    int c, i;
-    size_t n;
-
-    ARIA_VALIDATE_RET( ctx != NULL );
-    ARIA_VALIDATE_RET( length == 0 || input  != NULL );
-    ARIA_VALIDATE_RET( length == 0 || output != NULL );
-    ARIA_VALIDATE_RET( nonce_counter != NULL );
-    ARIA_VALIDATE_RET( stream_block  != NULL );
-    ARIA_VALIDATE_RET( nc_off != NULL );
-
-    n = *nc_off;
-    /* An overly large value of n can lead to an unlimited
-     * buffer overflow. Therefore, guard against this
-     * outside of parameter validation. */
-    if( n >= MBEDTLS_ARIA_BLOCKSIZE )
-        return( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA );
-
-    while( length-- )
-    {
-        if( n == 0 ) {
-            mbedtls_aria_crypt_ecb( ctx, nonce_counter,
-                                stream_block );
-
-            for( i = MBEDTLS_ARIA_BLOCKSIZE; i > 0; i-- )
-                if( ++nonce_counter[i - 1] != 0 )
-                    break;
-        }
-        c = *input++;
-        *output++ = (unsigned char)( c ^ stream_block[n] );
-
-        n = ( n + 1 ) & 0x0F;
-    }
-
-    *nc_off = n;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-#endif /* !MBEDTLS_ARIA_ALT */
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/*
- * Basic ARIA ECB test vectors from RFC 5794
- */
-static const uint8_t aria_test1_ecb_key[32] =           // test key
-{
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,     // 128 bit
-    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,     // 192 bit
-    0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F      // 256 bit
-};
-
-static const uint8_t aria_test1_ecb_pt[MBEDTLS_ARIA_BLOCKSIZE] =            // plaintext
-{
-    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,     // same for all
-    0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF      // key sizes
-};
-
-static const uint8_t aria_test1_ecb_ct[3][MBEDTLS_ARIA_BLOCKSIZE] =         // ciphertext
-{
-    { 0xD7, 0x18, 0xFB, 0xD6, 0xAB, 0x64, 0x4C, 0x73,   // 128 bit
-      0x9D, 0xA9, 0x5F, 0x3B, 0xE6, 0x45, 0x17, 0x78 },
-    { 0x26, 0x44, 0x9C, 0x18, 0x05, 0xDB, 0xE7, 0xAA,   // 192 bit
-      0x25, 0xA4, 0x68, 0xCE, 0x26, 0x3A, 0x9E, 0x79 },
-    { 0xF9, 0x2B, 0xD7, 0xC7, 0x9F, 0xB7, 0x2E, 0x2F,   // 256 bit
-      0x2B, 0x8F, 0x80, 0xC1, 0x97, 0x2D, 0x24, 0xFC }
-};
-
-/*
- * Mode tests from "Test Vectors for ARIA"  Version 1.0
- * http://210.104.33.10/ARIA/doc/ARIA-testvector-e.pdf
- */
-#if (defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB) || \
-    defined(MBEDTLS_CIPHER_MODE_CTR))
-static const uint8_t aria_test2_key[32] =
-{
-    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,     // 128 bit
-    0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
-    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,     // 192 bit
-    0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff      // 256 bit
-};
-
-static const uint8_t aria_test2_pt[48] =
-{
-    0x11, 0x11, 0x11, 0x11, 0xaa, 0xaa, 0xaa, 0xaa,     // same for all
-    0x11, 0x11, 0x11, 0x11, 0xbb, 0xbb, 0xbb, 0xbb,
-    0x11, 0x11, 0x11, 0x11, 0xcc, 0xcc, 0xcc, 0xcc,
-    0x11, 0x11, 0x11, 0x11, 0xdd, 0xdd, 0xdd, 0xdd,
-    0x22, 0x22, 0x22, 0x22, 0xaa, 0xaa, 0xaa, 0xaa,
-    0x22, 0x22, 0x22, 0x22, 0xbb, 0xbb, 0xbb, 0xbb,
-};
-#endif
-
-#if (defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB))
-static const uint8_t aria_test2_iv[MBEDTLS_ARIA_BLOCKSIZE] =
-{
-    0x0f, 0x1e, 0x2d, 0x3c, 0x4b, 0x5a, 0x69, 0x78,     // same for CBC, CFB
-    0x87, 0x96, 0xa5, 0xb4, 0xc3, 0xd2, 0xe1, 0xf0      // CTR has zero IV
-};
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const uint8_t aria_test2_cbc_ct[3][48] =         // CBC ciphertext
-{
-    { 0x49, 0xd6, 0x18, 0x60, 0xb1, 0x49, 0x09, 0x10,   // 128-bit key
-      0x9c, 0xef, 0x0d, 0x22, 0xa9, 0x26, 0x81, 0x34,
-      0xfa, 0xdf, 0x9f, 0xb2, 0x31, 0x51, 0xe9, 0x64,
-      0x5f, 0xba, 0x75, 0x01, 0x8b, 0xdb, 0x15, 0x38,
-      0xb5, 0x33, 0x34, 0x63, 0x4b, 0xbf, 0x7d, 0x4c,
-      0xd4, 0xb5, 0x37, 0x70, 0x33, 0x06, 0x0c, 0x15 },
-    { 0xaf, 0xe6, 0xcf, 0x23, 0x97, 0x4b, 0x53, 0x3c,   // 192-bit key
-      0x67, 0x2a, 0x82, 0x62, 0x64, 0xea, 0x78, 0x5f,
-      0x4e, 0x4f, 0x7f, 0x78, 0x0d, 0xc7, 0xf3, 0xf1,
-      0xe0, 0x96, 0x2b, 0x80, 0x90, 0x23, 0x86, 0xd5,
-      0x14, 0xe9, 0xc3, 0xe7, 0x72, 0x59, 0xde, 0x92,
-      0xdd, 0x11, 0x02, 0xff, 0xab, 0x08, 0x6c, 0x1e },
-    { 0x52, 0x3a, 0x8a, 0x80, 0x6a, 0xe6, 0x21, 0xf1,   // 256-bit key
-      0x55, 0xfd, 0xd2, 0x8d, 0xbc, 0x34, 0xe1, 0xab,
-      0x7b, 0x9b, 0x42, 0x43, 0x2a, 0xd8, 0xb2, 0xef,
-      0xb9, 0x6e, 0x23, 0xb1, 0x3f, 0x0a, 0x6e, 0x52,
-      0xf3, 0x61, 0x85, 0xd5, 0x0a, 0xd0, 0x02, 0xc5,
-      0xf6, 0x01, 0xbe, 0xe5, 0x49, 0x3f, 0x11, 0x8b }
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static const uint8_t aria_test2_cfb_ct[3][48] =         // CFB ciphertext
-{
-    { 0x37, 0x20, 0xe5, 0x3b, 0xa7, 0xd6, 0x15, 0x38,   // 128-bit key
-      0x34, 0x06, 0xb0, 0x9f, 0x0a, 0x05, 0xa2, 0x00,
-      0xc0, 0x7c, 0x21, 0xe6, 0x37, 0x0f, 0x41, 0x3a,
-      0x5d, 0x13, 0x25, 0x00, 0xa6, 0x82, 0x85, 0x01,
-      0x7c, 0x61, 0xb4, 0x34, 0xc7, 0xb7, 0xca, 0x96,
-      0x85, 0xa5, 0x10, 0x71, 0x86, 0x1e, 0x4d, 0x4b },
-    { 0x41, 0x71, 0xf7, 0x19, 0x2b, 0xf4, 0x49, 0x54,   // 192-bit key
-      0x94, 0xd2, 0x73, 0x61, 0x29, 0x64, 0x0f, 0x5c,
-      0x4d, 0x87, 0xa9, 0xa2, 0x13, 0x66, 0x4c, 0x94,
-      0x48, 0x47, 0x7c, 0x6e, 0xcc, 0x20, 0x13, 0x59,
-      0x8d, 0x97, 0x66, 0x95, 0x2d, 0xd8, 0xc3, 0x86,
-      0x8f, 0x17, 0xe3, 0x6e, 0xf6, 0x6f, 0xd8, 0x4b },
-    { 0x26, 0x83, 0x47, 0x05, 0xb0, 0xf2, 0xc0, 0xe2,   // 256-bit key
-      0x58, 0x8d, 0x4a, 0x7f, 0x09, 0x00, 0x96, 0x35,
-      0xf2, 0x8b, 0xb9, 0x3d, 0x8c, 0x31, 0xf8, 0x70,
-      0xec, 0x1e, 0x0b, 0xdb, 0x08, 0x2b, 0x66, 0xfa,
-      0x40, 0x2d, 0xd9, 0xc2, 0x02, 0xbe, 0x30, 0x0c,
-      0x45, 0x17, 0xd1, 0x96, 0xb1, 0x4d, 0x4c, 0xe1 }
-};
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static const uint8_t aria_test2_ctr_ct[3][48] =         // CTR ciphertext
-{
-    { 0xac, 0x5d, 0x7d, 0xe8, 0x05, 0xa0, 0xbf, 0x1c,   // 128-bit key
-      0x57, 0xc8, 0x54, 0x50, 0x1a, 0xf6, 0x0f, 0xa1,
-      0x14, 0x97, 0xe2, 0xa3, 0x45, 0x19, 0xde, 0xa1,
-      0x56, 0x9e, 0x91, 0xe5, 0xb5, 0xcc, 0xae, 0x2f,
-      0xf3, 0xbf, 0xa1, 0xbf, 0x97, 0x5f, 0x45, 0x71,
-      0xf4, 0x8b, 0xe1, 0x91, 0x61, 0x35, 0x46, 0xc3 },
-    { 0x08, 0x62, 0x5c, 0xa8, 0xfe, 0x56, 0x9c, 0x19,   // 192-bit key
-      0xba, 0x7a, 0xf3, 0x76, 0x0a, 0x6e, 0xd1, 0xce,
-      0xf4, 0xd1, 0x99, 0x26, 0x3e, 0x99, 0x9d, 0xde,
-      0x14, 0x08, 0x2d, 0xbb, 0xa7, 0x56, 0x0b, 0x79,
-      0xa4, 0xc6, 0xb4, 0x56, 0xb8, 0x70, 0x7d, 0xce,
-      0x75, 0x1f, 0x98, 0x54, 0xf1, 0x88, 0x93, 0xdf },
-    { 0x30, 0x02, 0x6c, 0x32, 0x96, 0x66, 0x14, 0x17,   // 256-bit key
-      0x21, 0x17, 0x8b, 0x99, 0xc0, 0xa1, 0xf1, 0xb2,
-      0xf0, 0x69, 0x40, 0x25, 0x3f, 0x7b, 0x30, 0x89,
-      0xe2, 0xa3, 0x0e, 0xa8, 0x6a, 0xa3, 0xc8, 0x8f,
-      0x59, 0x40, 0xf0, 0x5a, 0xd7, 0xee, 0x41, 0xd7,
-      0x13, 0x47, 0xbb, 0x72, 0x61, 0xe3, 0x48, 0xf1 }
-};
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#define ARIA_SELF_TEST_IF_FAIL              \
-        {                                   \
-            if( verbose )                   \
-                mbedtls_printf( "failed\n" );       \
-            goto exit;                              \
-        } else {                            \
-            if( verbose )                   \
-                mbedtls_printf( "passed\n" );       \
-        }
-
-/*
- * Checkup routine
- */
-int mbedtls_aria_self_test( int verbose )
-{
-    int i;
-    uint8_t blk[MBEDTLS_ARIA_BLOCKSIZE];
-    mbedtls_aria_context ctx;
-    int ret = 1;
-
-#if (defined(MBEDTLS_CIPHER_MODE_CFB) || defined(MBEDTLS_CIPHER_MODE_CTR))
-    size_t j;
-#endif
-
-#if (defined(MBEDTLS_CIPHER_MODE_CBC) || \
-     defined(MBEDTLS_CIPHER_MODE_CFB) || \
-     defined(MBEDTLS_CIPHER_MODE_CTR))
-    uint8_t buf[48], iv[MBEDTLS_ARIA_BLOCKSIZE];
-#endif
-
-    mbedtls_aria_init( &ctx );
-
-    /*
-     * Test set 1
-     */
-    for( i = 0; i < 3; i++ )
-    {
-        /* test ECB encryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-ECB-%d (enc): ", 128 + 64 * i );
-        mbedtls_aria_setkey_enc( &ctx, aria_test1_ecb_key, 128 + 64 * i );
-        mbedtls_aria_crypt_ecb( &ctx, aria_test1_ecb_pt, blk );
-        if( memcmp( blk, aria_test1_ecb_ct[i], MBEDTLS_ARIA_BLOCKSIZE ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-
-        /* test ECB decryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-ECB-%d (dec): ", 128 + 64 * i );
-        mbedtls_aria_setkey_dec( &ctx, aria_test1_ecb_key, 128 + 64 * i );
-        mbedtls_aria_crypt_ecb( &ctx, aria_test1_ecb_ct[i], blk );
-        if( memcmp( blk, aria_test1_ecb_pt, MBEDTLS_ARIA_BLOCKSIZE ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-    }
-    if( verbose )
-        mbedtls_printf( "\n" );
-
-    /*
-     * Test set 2
-     */
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    for( i = 0; i < 3; i++ )
-    {
-        /* Test CBC encryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-CBC-%d (enc): ", 128 + 64 * i );
-        mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
-        memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
-        memset( buf, 0x55, sizeof( buf ) );
-        mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_ENCRYPT, 48, iv,
-            aria_test2_pt, buf );
-        if( memcmp( buf, aria_test2_cbc_ct[i], 48 ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-
-        /* Test CBC decryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-CBC-%d (dec): ", 128 + 64 * i );
-        mbedtls_aria_setkey_dec( &ctx, aria_test2_key, 128 + 64 * i );
-        memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
-        memset( buf, 0xAA, sizeof( buf ) );
-        mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_DECRYPT, 48, iv,
-            aria_test2_cbc_ct[i], buf );
-        if( memcmp( buf, aria_test2_pt, 48 ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-    }
-    if( verbose )
-        mbedtls_printf( "\n" );
-
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    for( i = 0; i < 3; i++ )
-    {
-        /* Test CFB encryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-CFB-%d (enc): ", 128 + 64 * i );
-        mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
-        memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
-        memset( buf, 0x55, sizeof( buf ) );
-        j = 0;
-        mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_ENCRYPT, 48, &j, iv,
-            aria_test2_pt, buf );
-        if( memcmp( buf, aria_test2_cfb_ct[i], 48 ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-
-        /* Test CFB decryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-CFB-%d (dec): ", 128 + 64 * i );
-        mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
-        memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
-        memset( buf, 0xAA, sizeof( buf ) );
-        j = 0;
-        mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_DECRYPT, 48, &j,
-            iv, aria_test2_cfb_ct[i], buf );
-        if( memcmp( buf, aria_test2_pt, 48 ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-    }
-    if( verbose )
-        mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    for( i = 0; i < 3; i++ )
-    {
-        /* Test CTR encryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-CTR-%d (enc): ", 128 + 64 * i );
-        mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
-        memset( iv, 0, MBEDTLS_ARIA_BLOCKSIZE );                    // IV = 0
-        memset( buf, 0x55, sizeof( buf ) );
-        j = 0;
-        mbedtls_aria_crypt_ctr( &ctx, 48, &j, iv, blk,
-            aria_test2_pt, buf );
-        if( memcmp( buf, aria_test2_ctr_ct[i], 48 ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-
-        /* Test CTR decryption */
-        if( verbose )
-            mbedtls_printf( "  ARIA-CTR-%d (dec): ", 128 + 64 * i );
-        mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
-        memset( iv, 0, MBEDTLS_ARIA_BLOCKSIZE );                    // IV = 0
-        memset( buf, 0xAA, sizeof( buf ) );
-        j = 0;
-        mbedtls_aria_crypt_ctr( &ctx, 48, &j, iv, blk,
-            aria_test2_ctr_ct[i], buf );
-        if( memcmp( buf, aria_test2_pt, 48 ) != 0 )
-            ARIA_SELF_TEST_IF_FAIL;
-    }
-    if( verbose )
-        mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-    ret = 0;
-
-exit:
-    mbedtls_aria_free( &ctx );
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_ARIA_C */
diff --git a/src/duckdb/third_party/mbedtls/library/asn1parse.cpp b/src/duckdb/third_party/mbedtls/library/asn1parse.cpp
deleted file mode 100644
index bf7e195e7..000000000
--- a/src/duckdb/third_party/mbedtls/library/asn1parse.cpp
+++ /dev/null
@@ -1,481 +0,0 @@
-/*
- *  Generic ASN.1 parsing
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_ASN1_PARSE_C)
-
-#include "mbedtls/asn1.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_BIGNUM_C)
-#include "mbedtls/bignum.h"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdlib.h>
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-/*
- * ASN.1 DER decoding routines
- */
-int mbedtls_asn1_get_len( unsigned char **p,
-                  const unsigned char *end,
-                  size_t *len )
-{
-    if( ( end - *p ) < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-    if( ( **p & 0x80 ) == 0 )
-        *len = *(*p)++;
-    else
-    {
-        switch( **p & 0x7F )
-        {
-        case 1:
-            if( ( end - *p ) < 2 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-            *len = (*p)[1];
-            (*p) += 2;
-            break;
-
-        case 2:
-            if( ( end - *p ) < 3 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-            *len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
-            (*p) += 3;
-            break;
-
-        case 3:
-            if( ( end - *p ) < 4 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-            *len = ( (size_t)(*p)[1] << 16 ) |
-                   ( (size_t)(*p)[2] << 8  ) | (*p)[3];
-            (*p) += 4;
-            break;
-
-        case 4:
-            if( ( end - *p ) < 5 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-            *len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
-                   ( (size_t)(*p)[3] << 8  ) |           (*p)[4];
-            (*p) += 5;
-            break;
-
-        default:
-            return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-        }
-    }
-
-    if( *len > (size_t) ( end - *p ) )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-    return( 0 );
-}
-
-int mbedtls_asn1_get_tag( unsigned char **p,
-                  const unsigned char *end,
-                  size_t *len, int tag )
-{
-    if( ( end - *p ) < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-    if( **p != tag )
-        return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
-
-    (*p)++;
-
-    return( mbedtls_asn1_get_len( p, end, len ) );
-}
-
-int mbedtls_asn1_get_bool( unsigned char **p,
-                   const unsigned char *end,
-                   int *val )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
-        return( ret );
-
-    if( len != 1 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-
-    *val = ( **p != 0 ) ? 1 : 0;
-    (*p)++;
-
-    return( 0 );
-}
-
-static int asn1_get_tagged_int( unsigned char **p,
-                                const unsigned char *end,
-                                int tag, int *val )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len, tag ) ) != 0 )
-        return( ret );
-
-    /*
-     * len==0 is malformed (0 must be represented as 020100 for INTEGER,
-     * or 0A0100 for ENUMERATED tags
-     */
-    if( len == 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-    /* This is a cryptography library. Reject negative integers. */
-    if( ( **p & 0x80 ) != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-
-    /* Skip leading zeros. */
-    while( len > 0 && **p == 0 )
-    {
-        ++( *p );
-        --len;
-    }
-
-    /* Reject integers that don't fit in an int. This code assumes that
-     * the int type has no padding bit. */
-    if( len > sizeof( int ) )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-    if( len == sizeof( int ) && ( **p & 0x80 ) != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-
-    *val = 0;
-    while( len-- > 0 )
-    {
-        *val = ( *val << 8 ) | **p;
-        (*p)++;
-    }
-
-    return( 0 );
-}
-
-int mbedtls_asn1_get_int( unsigned char **p,
-                          const unsigned char *end,
-                          int *val )
-{
-    return( asn1_get_tagged_int( p, end, MBEDTLS_ASN1_INTEGER, val) );
-}
-
-int mbedtls_asn1_get_enum( unsigned char **p,
-                           const unsigned char *end,
-                           int *val )
-{
-    return( asn1_get_tagged_int( p, end, MBEDTLS_ASN1_ENUMERATED, val) );
-}
-
-#if defined(MBEDTLS_BIGNUM_C)
-int mbedtls_asn1_get_mpi( unsigned char **p,
-                  const unsigned char *end,
-                  mbedtls_mpi *X )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
-        return( ret );
-
-    ret = mbedtls_mpi_read_binary( X, *p, len );
-
-    *p += len;
-
-    return( ret );
-}
-#endif /* MBEDTLS_BIGNUM_C */
-
-int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end,
-                        mbedtls_asn1_bitstring *bs)
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    /* Certificate type is a single byte bitstring */
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
-        return( ret );
-
-    /* Check length, subtract one for actual bit string length */
-    if( bs->len < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-    bs->len -= 1;
-
-    /* Get number of unused bits, ensure unused bits <= 7 */
-    bs->unused_bits = **p;
-    if( bs->unused_bits > 7 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
-    (*p)++;
-
-    /* Get actual bitstring */
-    bs->p = *p;
-    *p += bs->len;
-
-    if( *p != end )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
-
-    return( 0 );
-}
-
-/*
- * Traverse an ASN.1 "SEQUENCE OF <tag>"
- * and call a callback for each entry found.
- */
-int mbedtls_asn1_traverse_sequence_of(
-    unsigned char **p,
-    const unsigned char *end,
-    unsigned char tag_must_mask, unsigned char tag_must_val,
-    unsigned char tag_may_mask, unsigned char tag_may_val,
-    int (*cb)( void *ctx, int tag,
-               unsigned char *start, size_t len ),
-    void *ctx )
-{
-    int ret;
-    size_t len;
-
-    /* Get main sequence tag */
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    if( *p + len != end )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
-
-    while( *p < end )
-    {
-        unsigned char const tag = *(*p)++;
-
-        if( ( tag & tag_must_mask ) != tag_must_val )
-            return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
-
-        if( ( ret = mbedtls_asn1_get_len( p, end, &len ) ) != 0 )
-            return( ret );
-
-        if( ( tag & tag_may_mask ) == tag_may_val )
-        {
-            if( cb != NULL )
-            {
-                ret = cb( ctx, tag, *p, len );
-                if( ret != 0 )
-                    return( ret );
-            }
-        }
-
-        *p += len;
-    }
-
-    return( 0 );
-}
-
-/*
- * Get a bit string without unused bits
- */
-int mbedtls_asn1_get_bitstring_null( unsigned char **p, const unsigned char *end,
-                             size_t *len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
-        return( ret );
-
-    if( *len == 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_DATA );
-    --( *len );
-
-    if( **p != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_DATA );
-    ++( *p );
-
-    return( 0 );
-}
-
-void mbedtls_asn1_sequence_free( mbedtls_asn1_sequence *seq )
-{
-    while( seq != NULL )
-    {
-        mbedtls_asn1_sequence *next = seq->next;
-        mbedtls_platform_zeroize( seq, sizeof( *seq ) );
-        mbedtls_free( seq );
-        seq = next;
-    }
-}
-
-typedef struct
-{
-    int tag;
-    mbedtls_asn1_sequence *cur;
-} asn1_get_sequence_of_cb_ctx_t;
-
-static int asn1_get_sequence_of_cb( void *ctx,
-                                    int tag,
-                                    unsigned char *start,
-                                    size_t len )
-{
-    asn1_get_sequence_of_cb_ctx_t *cb_ctx =
-        (asn1_get_sequence_of_cb_ctx_t *) ctx;
-    mbedtls_asn1_sequence *cur =
-        cb_ctx->cur;
-
-    if( cur->buf.p != NULL )
-    {
-        cur->next =
-            (struct mbedtls_asn1_sequence *) mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
-
-        if( cur->next == NULL )
-            return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
-
-        cur = cur->next;
-    }
-
-    cur->buf.p = start;
-    cur->buf.len = len;
-    cur->buf.tag = tag;
-
-    cb_ctx->cur = cur;
-    return( 0 );
-}
-
-/*
- *  Parses and splits an ASN.1 "SEQUENCE OF <tag>"
- */
-int mbedtls_asn1_get_sequence_of( unsigned char **p,
-                          const unsigned char *end,
-                          mbedtls_asn1_sequence *cur,
-                          int tag)
-{
-    asn1_get_sequence_of_cb_ctx_t cb_ctx = { tag, cur };
-    memset( cur, 0, sizeof( mbedtls_asn1_sequence ) );
-    return( mbedtls_asn1_traverse_sequence_of(
-                p, end, 0xFF, tag, 0, 0,
-                asn1_get_sequence_of_cb, &cb_ctx ) );
-}
-
-int mbedtls_asn1_get_alg( unsigned char **p,
-                  const unsigned char *end,
-                  mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-        return( ret );
-
-    if( ( end - *p ) < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
-
-    alg->tag = **p;
-    end = *p + len;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &alg->len, MBEDTLS_ASN1_OID ) ) != 0 )
-        return( ret );
-
-    alg->p = *p;
-    *p += alg->len;
-
-    if( *p == end )
-    {
-        mbedtls_platform_zeroize( params, sizeof(mbedtls_asn1_buf) );
-        return( 0 );
-    }
-
-    params->tag = **p;
-    (*p)++;
-
-    if( ( ret = mbedtls_asn1_get_len( p, end, &params->len ) ) != 0 )
-        return( ret );
-
-    params->p = *p;
-    *p += params->len;
-
-    if( *p != end )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
-
-    return( 0 );
-}
-
-int mbedtls_asn1_get_alg_null( unsigned char **p,
-                       const unsigned char *end,
-                       mbedtls_asn1_buf *alg )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_asn1_buf params;
-
-    memset( &params, 0, sizeof(mbedtls_asn1_buf) );
-
-    if( ( ret = mbedtls_asn1_get_alg( p, end, alg, &params ) ) != 0 )
-        return( ret );
-
-    if( ( params.tag != MBEDTLS_ASN1_NULL && params.tag != 0 ) || params.len != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_DATA );
-
-    return( 0 );
-}
-
-void mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *cur )
-{
-    if( cur == NULL )
-        return;
-
-    mbedtls_free( cur->oid.p );
-    mbedtls_free( cur->val.p );
-
-    mbedtls_platform_zeroize( cur, sizeof( mbedtls_asn1_named_data ) );
-}
-
-void mbedtls_asn1_free_named_data_list( mbedtls_asn1_named_data **head )
-{
-    mbedtls_asn1_named_data *cur;
-
-    while( ( cur = *head ) != NULL )
-    {
-        *head = cur->next;
-        mbedtls_asn1_free_named_data( cur );
-        mbedtls_free( cur );
-    }
-}
-
-const mbedtls_asn1_named_data *mbedtls_asn1_find_named_data( const mbedtls_asn1_named_data *list,
-                                       const char *oid, size_t len )
-{
-    while( list != NULL )
-    {
-        if( list->oid.len == len &&
-            memcmp( list->oid.p, oid, len ) == 0 )
-        {
-            break;
-        }
-
-        list = list->next;
-    }
-
-    return( list );
-}
-
-#endif /* MBEDTLS_ASN1_PARSE_C */
diff --git a/src/duckdb/third_party/mbedtls/library/base64.cpp b/src/duckdb/third_party/mbedtls/library/base64.cpp
deleted file mode 100644
index 83daa0bcc..000000000
--- a/src/duckdb/third_party/mbedtls/library/base64.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- *  RFC 1521 base64 encoding/decoding
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_BASE64_C)
-
-#include "mbedtls/base64.h"
-#include "constant_time_internal.h"
-
-#include <stdint.h>
-
-#if defined(MBEDTLS_SELF_TEST)
-#include <string.h>
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#define mbedtls_printf printf
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#define BASE64_SIZE_T_MAX   ( (size_t) -1 ) /* SIZE_T_MAX is not standard */
-
-/*
- * Encode a buffer into base64 format
- */
-int mbedtls_base64_encode( unsigned char *dst, size_t dlen, size_t *olen,
-                   const unsigned char *src, size_t slen )
-{
-    size_t i, n;
-    int C1, C2, C3;
-    unsigned char *p;
-
-    if( slen == 0 )
-    {
-        *olen = 0;
-        return( 0 );
-    }
-
-    n = slen / 3 + ( slen % 3 != 0 );
-
-    if( n > ( BASE64_SIZE_T_MAX - 1 ) / 4 )
-    {
-        *olen = BASE64_SIZE_T_MAX;
-        return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
-    }
-
-    n *= 4;
-
-    if( ( dlen < n + 1 ) || ( NULL == dst ) )
-    {
-        *olen = n + 1;
-        return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
-    }
-
-    n = ( slen / 3 ) * 3;
-
-    for( i = 0, p = dst; i < n; i += 3 )
-    {
-        C1 = *src++;
-        C2 = *src++;
-        C3 = *src++;
-
-        *p++ = mbedtls_ct_base64_enc_char( ( C1 >> 2 ) & 0x3F );
-        *p++ = mbedtls_ct_base64_enc_char( ( ( ( C1 &  3 ) << 4 ) + ( C2 >> 4 ) )
-                                        & 0x3F );
-        *p++ = mbedtls_ct_base64_enc_char( ( ( ( C2 & 15 ) << 2 ) + ( C3 >> 6 ) )
-                                        & 0x3F );
-        *p++ = mbedtls_ct_base64_enc_char( C3 & 0x3F );
-    }
-
-    if( i < slen )
-    {
-        C1 = *src++;
-        C2 = ( ( i + 1 ) < slen ) ? *src++ : 0;
-
-        *p++ = mbedtls_ct_base64_enc_char( ( C1 >> 2 ) & 0x3F );
-        *p++ = mbedtls_ct_base64_enc_char( ( ( ( C1 & 3 ) << 4 ) + ( C2 >> 4 ) )
-                                        & 0x3F );
-
-        if( ( i + 1 ) < slen )
-             *p++ = mbedtls_ct_base64_enc_char( ( ( C2 & 15 ) << 2 ) & 0x3F );
-        else *p++ = '=';
-
-        *p++ = '=';
-    }
-
-    *olen = p - dst;
-    *p = 0;
-
-    return( 0 );
-}
-
-/*
- * Decode a base64-formatted buffer
- */
-int mbedtls_base64_decode( unsigned char *dst, size_t dlen, size_t *olen,
-                   const unsigned char *src, size_t slen )
-{
-    size_t i; /* index in source */
-    size_t n; /* number of digits or trailing = in source */
-    uint32_t x; /* value accumulator */
-    unsigned accumulated_digits = 0;
-    unsigned equals = 0;
-    int spaces_present = 0;
-    unsigned char *p;
-
-    /* First pass: check for validity and get output length */
-    for( i = n = 0; i < slen; i++ )
-    {
-        /* Skip spaces before checking for EOL */
-        spaces_present = 0;
-        while( i < slen && src[i] == ' ' )
-        {
-            ++i;
-            spaces_present = 1;
-        }
-
-        /* Spaces at end of buffer are OK */
-        if( i == slen )
-            break;
-
-        if( ( slen - i ) >= 2 &&
-            src[i] == '\r' && src[i + 1] == '\n' )
-            continue;
-
-        if( src[i] == '\n' )
-            continue;
-
-        /* Space inside a line is an error */
-        if( spaces_present )
-            return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
-
-        if( src[i] > 127 )
-            return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
-
-        if( src[i] == '=' )
-        {
-            if( ++equals > 2 )
-                return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
-        }
-        else
-        {
-            if( equals != 0 )
-                return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
-            if( mbedtls_ct_base64_dec_value( src[i] ) < 0 )
-                return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
-        }
-        n++;
-    }
-
-    if( n == 0 )
-    {
-        *olen = 0;
-        return( 0 );
-    }
-
-    /* The following expression is to calculate the following formula without
-     * risk of integer overflow in n:
-     *     n = ( ( n * 6 ) + 7 ) >> 3;
-     */
-    n = ( 6 * ( n >> 3 ) ) + ( ( 6 * ( n & 0x7 ) + 7 ) >> 3 );
-    n -= equals;
-
-    if( dst == NULL || dlen < n )
-    {
-        *olen = n;
-        return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
-    }
-
-    equals = 0;
-    for( x = 0, p = dst; i > 0; i--, src++ )
-    {
-        if( *src == '\r' || *src == '\n' || *src == ' ' )
-            continue;
-
-        x = x << 6;
-        if( *src == '=' )
-            ++equals;
-        else
-            x |= mbedtls_ct_base64_dec_value( *src );
-
-        if( ++accumulated_digits == 4 )
-        {
-            accumulated_digits = 0;
-            *p++ = MBEDTLS_BYTE_2( x );
-            if( equals <= 1 ) *p++ = MBEDTLS_BYTE_1( x );
-            if( equals <= 0 ) *p++ = MBEDTLS_BYTE_0( x );
-        }
-    }
-
-    *olen = p - dst;
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_SELF_TEST)
-
-static const unsigned char base64_test_dec[64] =
-{
-    0x24, 0x48, 0x6E, 0x56, 0x87, 0x62, 0x5A, 0xBD,
-    0xBF, 0x17, 0xD9, 0xA2, 0xC4, 0x17, 0x1A, 0x01,
-    0x94, 0xED, 0x8F, 0x1E, 0x11, 0xB3, 0xD7, 0x09,
-    0x0C, 0xB6, 0xE9, 0x10, 0x6F, 0x22, 0xEE, 0x13,
-    0xCA, 0xB3, 0x07, 0x05, 0x76, 0xC9, 0xFA, 0x31,
-    0x6C, 0x08, 0x34, 0xFF, 0x8D, 0xC2, 0x6C, 0x38,
-    0x00, 0x43, 0xE9, 0x54, 0x97, 0xAF, 0x50, 0x4B,
-    0xD1, 0x41, 0xBA, 0x95, 0x31, 0x5A, 0x0B, 0x97
-};
-
-static const unsigned char base64_test_enc[] =
-    "JEhuVodiWr2/F9mixBcaAZTtjx4Rs9cJDLbpEG8i7hPK"
-    "swcFdsn6MWwINP+Nwmw4AEPpVJevUEvRQbqVMVoLlw==";
-
-/*
- * Checkup routine
- */
-int mbedtls_base64_self_test( int verbose )
-{
-    size_t len;
-    const unsigned char *src;
-    unsigned char buffer[128];
-
-    if( verbose != 0 )
-        mbedtls_printf( "  Base64 encoding test: " );
-
-    src = base64_test_dec;
-
-    if( mbedtls_base64_encode( buffer, sizeof( buffer ), &len, src, 64 ) != 0 ||
-         memcmp( base64_test_enc, buffer, 88 ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        return( 1 );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n  Base64 decoding test: " );
-
-    src = base64_test_enc;
-
-    if( mbedtls_base64_decode( buffer, sizeof( buffer ), &len, src, 88 ) != 0 ||
-         memcmp( base64_test_dec, buffer, 64 ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        return( 1 );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n\n" );
-
-    return( 0 );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_BASE64_C */
diff --git a/src/duckdb/third_party/mbedtls/library/bignum.cpp b/src/duckdb/third_party/mbedtls/library/bignum.cpp
deleted file mode 100644
index d4b51ca57..000000000
--- a/src/duckdb/third_party/mbedtls/library/bignum.cpp
+++ /dev/null
@@ -1,3071 +0,0 @@
-/*
- *  Multi-precision integer library
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-/*
- *  The following sources were referenced in the design of this Multi-precision
- *  Integer library:
- *
- *  [1] Handbook of Applied Cryptography - 1997
- *      Menezes, van Oorschot and Vanstone
- *
- *  [2] Multi-Precision Math
- *      Tom St Denis
- *      https://github.com/libtom/libtommath/blob/develop/tommath.pdf
- *
- *  [3] GNU Multi-Precision Arithmetic Library
- *      https://gmplib.org/manual/index.html
- *
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-#include "mbedtls/bignum.h"
-#include "bn_mul.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-#include "constant_time_internal.h"
-
-#include <limits.h>
-#include <string.h>
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#include <stdlib.h>
-#define mbedtls_printf     printf
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-#define MPI_VALIDATE_RET( cond )                                       \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_MPI_BAD_INPUT_DATA )
-#define MPI_VALIDATE( cond )                                           \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-#define ciL    (sizeof(mbedtls_mpi_uint))         /* chars in limb  */
-#define biL    (ciL << 3)               /* bits  in limb  */
-#define biH    (ciL << 2)               /* half limb size */
-
-#define MPI_SIZE_T_MAX  ( (size_t) -1 ) /* SIZE_T_MAX is not standard */
-
-/*
- * Convert between bits/chars and number of limbs
- * Divide first in order to avoid potential overflows
- */
-#define BITS_TO_LIMBS(i)  ( (i) / biL + ( (i) % biL != 0 ) )
-#define CHARS_TO_LIMBS(i) ( (i) / ciL + ( (i) % ciL != 0 ) )
-
-/* Implementation that should never be optimized out by the compiler */
-static void mbedtls_mpi_zeroize( mbedtls_mpi_uint *v, size_t n )
-{
-    mbedtls_platform_zeroize( v, ciL * n );
-}
-
-/*
- * Initialize one MPI
- */
-void mbedtls_mpi_init( mbedtls_mpi *X )
-{
-    MPI_VALIDATE( X != NULL );
-
-    X->s = 1;
-    X->n = 0;
-    X->p = NULL;
-}
-
-/*
- * Unallocate one MPI
- */
-void mbedtls_mpi_free( mbedtls_mpi *X )
-{
-    if( X == NULL )
-        return;
-
-    if( X->p != NULL )
-    {
-        mbedtls_mpi_zeroize( X->p, X->n );
-        mbedtls_free( X->p );
-    }
-
-    X->s = 1;
-    X->n = 0;
-    X->p = NULL;
-}
-
-/*
- * Enlarge to the specified number of limbs
- */
-int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs )
-{
-    mbedtls_mpi_uint *p;
-    MPI_VALIDATE_RET( X != NULL );
-
-    if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
-        return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
-
-    if( X->n < nblimbs )
-    {
-        if( ( p = (mbedtls_mpi_uint*)mbedtls_calloc( nblimbs, ciL ) ) == NULL )
-            return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
-
-        if( X->p != NULL )
-        {
-            memcpy( p, X->p, X->n * ciL );
-            mbedtls_mpi_zeroize( X->p, X->n );
-            mbedtls_free( X->p );
-        }
-
-        X->n = nblimbs;
-        X->p = p;
-    }
-
-    return( 0 );
-}
-
-/*
- * Resize down as much as possible,
- * while keeping at least the specified number of limbs
- */
-int mbedtls_mpi_shrink( mbedtls_mpi *X, size_t nblimbs )
-{
-    mbedtls_mpi_uint *p;
-    size_t i;
-    MPI_VALIDATE_RET( X != NULL );
-
-    if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
-        return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
-
-    /* Actually resize up if there are currently fewer than nblimbs limbs. */
-    if( X->n <= nblimbs )
-        return( mbedtls_mpi_grow( X, nblimbs ) );
-    /* After this point, then X->n > nblimbs and in particular X->n > 0. */
-
-    for( i = X->n - 1; i > 0; i-- )
-        if( X->p[i] != 0 )
-            break;
-    i++;
-
-    if( i < nblimbs )
-        i = nblimbs;
-
-    if( ( p = (mbedtls_mpi_uint*)mbedtls_calloc( i, ciL ) ) == NULL )
-        return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
-
-    if( X->p != NULL )
-    {
-        memcpy( p, X->p, i * ciL );
-        mbedtls_mpi_zeroize( X->p, X->n );
-        mbedtls_free( X->p );
-    }
-
-    X->n = i;
-    X->p = p;
-
-    return( 0 );
-}
-
-/* Resize X to have exactly n limbs and set it to 0. */
-static int mbedtls_mpi_resize_clear( mbedtls_mpi *X, size_t limbs )
-{
-    if( limbs == 0 )
-    {
-        mbedtls_mpi_free( X );
-        return( 0 );
-    }
-    else if( X->n == limbs )
-    {
-        memset( X->p, 0, limbs * ciL );
-        X->s = 1;
-        return( 0 );
-    }
-    else
-    {
-        mbedtls_mpi_free( X );
-        return( mbedtls_mpi_grow( X, limbs ) );
-    }
-}
-
-/*
- * Copy the contents of Y into X.
- *
- * This function is not constant-time. Leading zeros in Y may be removed.
- *
- * Ensure that X does not shrink. This is not guaranteed by the public API,
- * but some code in the bignum module relies on this property, for example
- * in mbedtls_mpi_exp_mod().
- */
-int mbedtls_mpi_copy( mbedtls_mpi *X, const mbedtls_mpi *Y )
-{
-    int ret = 0;
-    size_t i;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( Y != NULL );
-
-    if( X == Y )
-        return( 0 );
-
-    if( Y->n == 0 )
-    {
-        if( X->n != 0 )
-        {
-            X->s = 1;
-            memset( X->p, 0, X->n * ciL );
-        }
-        return( 0 );
-    }
-
-    for( i = Y->n - 1; i > 0; i-- )
-        if( Y->p[i] != 0 )
-            break;
-    i++;
-
-    X->s = Y->s;
-
-    if( X->n < i )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i ) );
-    }
-    else
-    {
-        memset( X->p + i, 0, ( X->n - i ) * ciL );
-    }
-
-    memcpy( X->p, Y->p, i * ciL );
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Swap the contents of X and Y
- */
-void mbedtls_mpi_swap( mbedtls_mpi *X, mbedtls_mpi *Y )
-{
-    mbedtls_mpi T;
-    MPI_VALIDATE( X != NULL );
-    MPI_VALIDATE( Y != NULL );
-
-    memcpy( &T,  X, sizeof( mbedtls_mpi ) );
-    memcpy(  X,  Y, sizeof( mbedtls_mpi ) );
-    memcpy(  Y, &T, sizeof( mbedtls_mpi ) );
-}
-
-/*
- * Set value from integer
- */
-int mbedtls_mpi_lset( mbedtls_mpi *X, mbedtls_mpi_sint z )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    MPI_VALIDATE_RET( X != NULL );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, 1 ) );
-    memset( X->p, 0, X->n * ciL );
-
-    X->p[0] = ( z < 0 ) ? -z : z;
-    X->s    = ( z < 0 ) ? -1 : 1;
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Get a specific bit
- */
-int mbedtls_mpi_get_bit( const mbedtls_mpi *X, size_t pos )
-{
-    MPI_VALIDATE_RET( X != NULL );
-
-    if( X->n * biL <= pos )
-        return( 0 );
-
-    return( ( X->p[pos / biL] >> ( pos % biL ) ) & 0x01 );
-}
-
-/* Get a specific byte, without range checks. */
-#define GET_BYTE( X, i )                                \
-    ( ( ( X )->p[( i ) / ciL] >> ( ( ( i ) % ciL ) * 8 ) ) & 0xff )
-
-/*
- * Set a bit to a specific value of 0 or 1
- */
-int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
-{
-    int ret = 0;
-    size_t off = pos / biL;
-    size_t idx = pos % biL;
-    MPI_VALIDATE_RET( X != NULL );
-
-    if( val != 0 && val != 1 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    if( X->n * biL <= pos )
-    {
-        if( val == 0 )
-            return( 0 );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, off + 1 ) );
-    }
-
-    X->p[off] &= ~( (mbedtls_mpi_uint) 0x01 << idx );
-    X->p[off] |= (mbedtls_mpi_uint) val << idx;
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Return the number of less significant zero-bits
- */
-size_t mbedtls_mpi_lsb( const mbedtls_mpi *X )
-{
-    size_t i, j, count = 0;
-    MBEDTLS_INTERNAL_VALIDATE_RET( X != NULL, 0 );
-
-    for( i = 0; i < X->n; i++ )
-        for( j = 0; j < biL; j++, count++ )
-            if( ( ( X->p[i] >> j ) & 1 ) != 0 )
-                return( count );
-
-    return( 0 );
-}
-
-/*
- * Count leading zero bits in a given integer
- */
-static size_t mbedtls_clz( const mbedtls_mpi_uint x )
-{
-    size_t j;
-    mbedtls_mpi_uint mask = (mbedtls_mpi_uint) 1 << (biL - 1);
-
-    for( j = 0; j < biL; j++ )
-    {
-        if( x & mask ) break;
-
-        mask >>= 1;
-    }
-
-    return j;
-}
-
-/*
- * Return the number of bits
- */
-size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X )
-{
-    size_t i, j;
-
-    if( X->n == 0 )
-        return( 0 );
-
-    for( i = X->n - 1; i > 0; i-- )
-        if( X->p[i] != 0 )
-            break;
-
-    j = biL - mbedtls_clz( X->p[i] );
-
-    return( ( i * biL ) + j );
-}
-
-/*
- * Return the total size in bytes
- */
-size_t mbedtls_mpi_size( const mbedtls_mpi *X )
-{
-    return( ( mbedtls_mpi_bitlen( X ) + 7 ) >> 3 );
-}
-
-/*
- * Convert an ASCII character to digit value
- */
-static int mpi_get_digit( mbedtls_mpi_uint *d, int radix, char c )
-{
-    *d = 255;
-
-    if( c >= 0x30 && c <= 0x39 ) *d = c - 0x30;
-    if( c >= 0x41 && c <= 0x46 ) *d = c - 0x37;
-    if( c >= 0x61 && c <= 0x66 ) *d = c - 0x57;
-
-    if( *d >= (mbedtls_mpi_uint) radix )
-        return( MBEDTLS_ERR_MPI_INVALID_CHARACTER );
-
-    return( 0 );
-}
-
-/*
- * Import from an ASCII string
- */
-int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i, j, slen, n;
-    int sign = 1;
-    mbedtls_mpi_uint d;
-    mbedtls_mpi T;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( s != NULL );
-
-    if( radix < 2 || radix > 16 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    mbedtls_mpi_init( &T );
-
-    if( s[0] == 0 )
-    {
-        mbedtls_mpi_free( X );
-        return( 0 );
-    }
-
-    if( s[0] == '-' )
-    {
-        ++s;
-        sign = -1;
-    }
-
-    slen = strlen( s );
-
-    if( radix == 16 )
-    {
-        if( slen > MPI_SIZE_T_MAX >> 2 )
-            return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-        n = BITS_TO_LIMBS( slen << 2 );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
-
-        for( i = slen, j = 0; i > 0; i--, j++ )
-        {
-            MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
-            X->p[j / ( 2 * ciL )] |= d << ( ( j % ( 2 * ciL ) ) << 2 );
-        }
-    }
-    else
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
-
-        for( i = 0; i < slen; i++ )
-        {
-            MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T, X, radix ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, &T, d ) );
-        }
-    }
-
-    if( sign < 0 && mbedtls_mpi_bitlen( X ) != 0 )
-        X->s = -1;
-
-cleanup:
-
-    mbedtls_mpi_free( &T );
-
-    return( ret );
-}
-
-/*
- * Helper to write the digits high-order first.
- */
-static int mpi_write_hlp( mbedtls_mpi *X, int radix,
-                          char **p, const size_t buflen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_mpi_uint r;
-    size_t length = 0;
-    char *p_end = *p + buflen;
-
-    do
-    {
-        if( length >= buflen )
-        {
-            return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
-        }
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, radix ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_div_int( X, NULL, X, radix ) );
-        /*
-         * Write the residue in the current position, as an ASCII character.
-         */
-        if( r < 0xA )
-            *(--p_end) = (char)( '0' + r );
-        else
-            *(--p_end) = (char)( 'A' + ( r - 0xA ) );
-
-        length++;
-    } while( mbedtls_mpi_cmp_int( X, 0 ) != 0 );
-
-    memmove( *p, p_end, length );
-    *p += length;
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Export into an ASCII string
- */
-int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix,
-                              char *buf, size_t buflen, size_t *olen )
-{
-    int ret = 0;
-    size_t n;
-    char *p;
-    mbedtls_mpi T;
-    MPI_VALIDATE_RET( X    != NULL );
-    MPI_VALIDATE_RET( olen != NULL );
-    MPI_VALIDATE_RET( buflen == 0 || buf != NULL );
-
-    if( radix < 2 || radix > 16 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    n = mbedtls_mpi_bitlen( X ); /* Number of bits necessary to present `n`. */
-    if( radix >=  4 ) n >>= 1;   /* Number of 4-adic digits necessary to present
-                                  * `n`. If radix > 4, this might be a strict
-                                  * overapproximation of the number of
-                                  * radix-adic digits needed to present `n`. */
-    if( radix >= 16 ) n >>= 1;   /* Number of hexadecimal digits necessary to
-                                  * present `n`. */
-
-    n += 1; /* Terminating null byte */
-    n += 1; /* Compensate for the divisions above, which round down `n`
-             * in case it's not even. */
-    n += 1; /* Potential '-'-sign. */
-    n += ( n & 1 ); /* Make n even to have enough space for hexadecimal writing,
-                     * which always uses an even number of hex-digits. */
-
-    if( buflen < n )
-    {
-        *olen = n;
-        return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
-    }
-
-    p = buf;
-    mbedtls_mpi_init( &T );
-
-    if( X->s == -1 )
-    {
-        *p++ = '-';
-        buflen--;
-    }
-
-    if( radix == 16 )
-    {
-        int c;
-        size_t i, j, k;
-
-        for( i = X->n, k = 0; i > 0; i-- )
-        {
-            for( j = ciL; j > 0; j-- )
-            {
-                c = ( X->p[i - 1] >> ( ( j - 1 ) << 3) ) & 0xFF;
-
-                if( c == 0 && k == 0 && ( i + j ) != 2 )
-                    continue;
-
-                *(p++) = "0123456789ABCDEF" [c / 16];
-                *(p++) = "0123456789ABCDEF" [c % 16];
-                k = 1;
-            }
-        }
-    }
-    else
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T, X ) );
-
-        if( T.s == -1 )
-            T.s = 1;
-
-        MBEDTLS_MPI_CHK( mpi_write_hlp( &T, radix, &p, buflen ) );
-    }
-
-    *p++ = '\0';
-    *olen = p - buf;
-
-cleanup:
-
-    mbedtls_mpi_free( &T );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_FS_IO)
-/*
- * Read X from an opened file
- */
-int mbedtls_mpi_read_file( mbedtls_mpi *X, int radix, FILE *fin )
-{
-    mbedtls_mpi_uint d;
-    size_t slen;
-    char *p;
-    /*
-     * Buffer should have space for (short) label and decimal formatted MPI,
-     * newline characters and '\0'
-     */
-    char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
-
-    MPI_VALIDATE_RET( X   != NULL );
-    MPI_VALIDATE_RET( fin != NULL );
-
-    if( radix < 2 || radix > 16 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    memset( s, 0, sizeof( s ) );
-    if( fgets( s, sizeof( s ) - 1, fin ) == NULL )
-        return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
-
-    slen = strlen( s );
-    if( slen == sizeof( s ) - 2 )
-        return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
-
-    if( slen > 0 && s[slen - 1] == '\n' ) { slen--; s[slen] = '\0'; }
-    if( slen > 0 && s[slen - 1] == '\r' ) { slen--; s[slen] = '\0'; }
-
-    p = s + slen;
-    while( p-- > s )
-        if( mpi_get_digit( &d, radix, *p ) != 0 )
-            break;
-
-    return( mbedtls_mpi_read_string( X, radix, p + 1 ) );
-}
-
-/*
- * Write X into an opened file (or stdout if fout == NULL)
- */
-int mbedtls_mpi_write_file( const char *p, const mbedtls_mpi *X, int radix, FILE *fout )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t n, slen, plen;
-    /*
-     * Buffer should have space for (short) label and decimal formatted MPI,
-     * newline characters and '\0'
-     */
-    char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
-    MPI_VALIDATE_RET( X != NULL );
-
-    if( radix < 2 || radix > 16 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    memset( s, 0, sizeof( s ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_write_string( X, radix, s, sizeof( s ) - 2, &n ) );
-
-    if( p == NULL ) p = "";
-
-    plen = strlen( p );
-    slen = strlen( s );
-    s[slen++] = '\r';
-    s[slen++] = '\n';
-
-    if( fout != NULL )
-    {
-        if( fwrite( p, 1, plen, fout ) != plen ||
-            fwrite( s, 1, slen, fout ) != slen )
-            return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
-    }
-    else
-        mbedtls_printf( "%s%s", p, s );
-
-cleanup:
-
-    return( ret );
-}
-#endif /* MBEDTLS_FS_IO */
-
-
-/* Convert a big-endian byte array aligned to the size of mbedtls_mpi_uint
- * into the storage form used by mbedtls_mpi. */
-
-static mbedtls_mpi_uint mpi_uint_bigendian_to_host_c( mbedtls_mpi_uint x )
-{
-    uint8_t i;
-    unsigned char *x_ptr;
-    mbedtls_mpi_uint tmp = 0;
-
-    for( i = 0, x_ptr = (unsigned char*) &x; i < ciL; i++, x_ptr++ )
-    {
-        tmp <<= CHAR_BIT;
-        tmp |= (mbedtls_mpi_uint) *x_ptr;
-    }
-
-    return( tmp );
-}
-
-static mbedtls_mpi_uint mpi_uint_bigendian_to_host( mbedtls_mpi_uint x )
-{
-#if defined(__BYTE_ORDER__)
-
-/* Nothing to do on bigendian systems. */
-#if ( __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ )
-    return( x );
-#endif /* __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ */
-
-#if ( __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ )
-
-/* For GCC and Clang, have builtins for byte swapping. */
-#if defined(__GNUC__) && defined(__GNUC_PREREQ)
-#if __GNUC_PREREQ(4,3)
-#define have_bswap
-#endif
-#endif
-
-#if defined(__clang__) && defined(__has_builtin)
-#if __has_builtin(__builtin_bswap32)  &&                 \
-    __has_builtin(__builtin_bswap64)
-#define have_bswap
-#endif
-#endif
-
-#if defined(have_bswap)
-    /* The compiler is hopefully able to statically evaluate this! */
-    switch( sizeof(mbedtls_mpi_uint) )
-    {
-        case 4:
-            return( __builtin_bswap32(x) );
-        case 8:
-            return( __builtin_bswap64(x) );
-    }
-#endif
-#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ */
-#endif /* __BYTE_ORDER__ */
-
-    /* Fall back to C-based reordering if we don't know the byte order
-     * or we couldn't use a compiler-specific builtin. */
-    return( mpi_uint_bigendian_to_host_c( x ) );
-}
-
-static void mpi_bigendian_to_host( mbedtls_mpi_uint * const p, size_t limbs )
-{
-    mbedtls_mpi_uint *cur_limb_left;
-    mbedtls_mpi_uint *cur_limb_right;
-    if( limbs == 0 )
-        return;
-
-    /*
-     * Traverse limbs and
-     * - adapt byte-order in each limb
-     * - swap the limbs themselves.
-     * For that, simultaneously traverse the limbs from left to right
-     * and from right to left, as long as the left index is not bigger
-     * than the right index (it's not a problem if limbs is odd and the
-     * indices coincide in the last iteration).
-     */
-    for( cur_limb_left = p, cur_limb_right = p + ( limbs - 1 );
-         cur_limb_left <= cur_limb_right;
-         cur_limb_left++, cur_limb_right-- )
-    {
-        mbedtls_mpi_uint tmp;
-        /* Note that if cur_limb_left == cur_limb_right,
-         * this code effectively swaps the bytes only once. */
-        tmp             = mpi_uint_bigendian_to_host( *cur_limb_left  );
-        *cur_limb_left  = mpi_uint_bigendian_to_host( *cur_limb_right );
-        *cur_limb_right = tmp;
-    }
-}
-
-/*
- * Import X from unsigned binary data, little endian
- */
-int mbedtls_mpi_read_binary_le( mbedtls_mpi *X,
-                                const unsigned char *buf, size_t buflen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i;
-    size_t const limbs = CHARS_TO_LIMBS( buflen );
-
-    /* Ensure that target MPI has exactly the necessary number of limbs */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_resize_clear( X, limbs ) );
-
-    for( i = 0; i < buflen; i++ )
-        X->p[i / ciL] |= ((mbedtls_mpi_uint) buf[i]) << ((i % ciL) << 3);
-
-cleanup:
-
-    /*
-     * This function is also used to import keys. However, wiping the buffers
-     * upon failure is not necessary because failure only can happen before any
-     * input is copied.
-     */
-    return( ret );
-}
-
-/*
- * Import X from unsigned binary data, big endian
- */
-int mbedtls_mpi_read_binary( mbedtls_mpi *X, const unsigned char *buf, size_t buflen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t const limbs    = CHARS_TO_LIMBS( buflen );
-    size_t const overhead = ( limbs * ciL ) - buflen;
-    unsigned char *Xp;
-
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( buflen == 0 || buf != NULL );
-
-    /* Ensure that target MPI has exactly the necessary number of limbs */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_resize_clear( X, limbs ) );
-
-    /* Avoid calling `memcpy` with NULL source or destination argument,
-     * even if buflen is 0. */
-    if( buflen != 0 )
-    {
-        Xp = (unsigned char*) X->p;
-        memcpy( Xp + overhead, buf, buflen );
-
-        mpi_bigendian_to_host( X->p, limbs );
-    }
-
-cleanup:
-
-    /*
-     * This function is also used to import keys. However, wiping the buffers
-     * upon failure is not necessary because failure only can happen before any
-     * input is copied.
-     */
-    return( ret );
-}
-
-/*
- * Export X into unsigned binary data, little endian
- */
-int mbedtls_mpi_write_binary_le( const mbedtls_mpi *X,
-                                 unsigned char *buf, size_t buflen )
-{
-    size_t stored_bytes = X->n * ciL;
-    size_t bytes_to_copy;
-    size_t i;
-
-    if( stored_bytes < buflen )
-    {
-        bytes_to_copy = stored_bytes;
-    }
-    else
-    {
-        bytes_to_copy = buflen;
-
-        /* The output buffer is smaller than the allocated size of X.
-         * However X may fit if its leading bytes are zero. */
-        for( i = bytes_to_copy; i < stored_bytes; i++ )
-        {
-            if( GET_BYTE( X, i ) != 0 )
-                return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
-        }
-    }
-
-    for( i = 0; i < bytes_to_copy; i++ )
-        buf[i] = GET_BYTE( X, i );
-
-    if( stored_bytes < buflen )
-    {
-        /* Write trailing 0 bytes */
-        memset( buf + stored_bytes, 0, buflen - stored_bytes );
-    }
-
-    return( 0 );
-}
-
-/*
- * Export X into unsigned binary data, big endian
- */
-int mbedtls_mpi_write_binary( const mbedtls_mpi *X,
-                              unsigned char *buf, size_t buflen )
-{
-    size_t stored_bytes;
-    size_t bytes_to_copy;
-    unsigned char *p;
-    size_t i;
-
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( buflen == 0 || buf != NULL );
-
-    stored_bytes = X->n * ciL;
-
-    if( stored_bytes < buflen )
-    {
-        /* There is enough space in the output buffer. Write initial
-         * null bytes and record the position at which to start
-         * writing the significant bytes. In this case, the execution
-         * trace of this function does not depend on the value of the
-         * number. */
-        bytes_to_copy = stored_bytes;
-        p = buf + buflen - stored_bytes;
-        memset( buf, 0, buflen - stored_bytes );
-    }
-    else
-    {
-        /* The output buffer is smaller than the allocated size of X.
-         * However X may fit if its leading bytes are zero. */
-        bytes_to_copy = buflen;
-        p = buf;
-        for( i = bytes_to_copy; i < stored_bytes; i++ )
-        {
-            if( GET_BYTE( X, i ) != 0 )
-                return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
-        }
-    }
-
-    for( i = 0; i < bytes_to_copy; i++ )
-        p[bytes_to_copy - i - 1] = GET_BYTE( X, i );
-
-    return( 0 );
-}
-
-/*
- * Left-shift: X <<= count
- */
-int mbedtls_mpi_shift_l( mbedtls_mpi *X, size_t count )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i, v0, t1;
-    mbedtls_mpi_uint r0 = 0, r1;
-    MPI_VALIDATE_RET( X != NULL );
-
-    v0 = count / (biL    );
-    t1 = count & (biL - 1);
-
-    i = mbedtls_mpi_bitlen( X ) + count;
-
-    if( X->n * biL < i )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, BITS_TO_LIMBS( i ) ) );
-
-    ret = 0;
-
-    /*
-     * shift by count / limb_size
-     */
-    if( v0 > 0 )
-    {
-        for( i = X->n; i > v0; i-- )
-            X->p[i - 1] = X->p[i - v0 - 1];
-
-        for( ; i > 0; i-- )
-            X->p[i - 1] = 0;
-    }
-
-    /*
-     * shift by count % limb_size
-     */
-    if( t1 > 0 )
-    {
-        for( i = v0; i < X->n; i++ )
-        {
-            r1 = X->p[i] >> (biL - t1);
-            X->p[i] <<= t1;
-            X->p[i] |= r0;
-            r0 = r1;
-        }
-    }
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Right-shift: X >>= count
- */
-int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count )
-{
-    size_t i, v0, v1;
-    mbedtls_mpi_uint r0 = 0, r1;
-    MPI_VALIDATE_RET( X != NULL );
-
-    v0 = count /  biL;
-    v1 = count & (biL - 1);
-
-    if( v0 > X->n || ( v0 == X->n && v1 > 0 ) )
-        return mbedtls_mpi_lset( X, 0 );
-
-    /*
-     * shift by count / limb_size
-     */
-    if( v0 > 0 )
-    {
-        for( i = 0; i < X->n - v0; i++ )
-            X->p[i] = X->p[i + v0];
-
-        for( ; i < X->n; i++ )
-            X->p[i] = 0;
-    }
-
-    /*
-     * shift by count % limb_size
-     */
-    if( v1 > 0 )
-    {
-        for( i = X->n; i > 0; i-- )
-        {
-            r1 = X->p[i - 1] << (biL - v1);
-            X->p[i - 1] >>= v1;
-            X->p[i - 1] |= r0;
-            r0 = r1;
-        }
-    }
-
-    return( 0 );
-}
-
-/*
- * Compare unsigned values
- */
-int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y )
-{
-    size_t i, j;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( Y != NULL );
-
-    for( i = X->n; i > 0; i-- )
-        if( X->p[i - 1] != 0 )
-            break;
-
-    for( j = Y->n; j > 0; j-- )
-        if( Y->p[j - 1] != 0 )
-            break;
-
-    if( i == 0 && j == 0 )
-        return( 0 );
-
-    if( i > j ) return(  1 );
-    if( j > i ) return( -1 );
-
-    for( ; i > 0; i-- )
-    {
-        if( X->p[i - 1] > Y->p[i - 1] ) return(  1 );
-        if( X->p[i - 1] < Y->p[i - 1] ) return( -1 );
-    }
-
-    return( 0 );
-}
-
-/*
- * Compare signed values
- */
-int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
-{
-    size_t i, j;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( Y != NULL );
-
-    for( i = X->n; i > 0; i-- )
-        if( X->p[i - 1] != 0 )
-            break;
-
-    for( j = Y->n; j > 0; j-- )
-        if( Y->p[j - 1] != 0 )
-            break;
-
-    if( i == 0 && j == 0 )
-        return( 0 );
-
-    if( i > j ) return(  X->s );
-    if( j > i ) return( -Y->s );
-
-    if( X->s > 0 && Y->s < 0 ) return(  1 );
-    if( Y->s > 0 && X->s < 0 ) return( -1 );
-
-    for( ; i > 0; i-- )
-    {
-        if( X->p[i - 1] > Y->p[i - 1] ) return(  X->s );
-        if( X->p[i - 1] < Y->p[i - 1] ) return( -X->s );
-    }
-
-    return( 0 );
-}
-
-/*
- * Compare signed values
- */
-int mbedtls_mpi_cmp_int( const mbedtls_mpi *X, mbedtls_mpi_sint z )
-{
-    mbedtls_mpi Y;
-    mbedtls_mpi_uint p[1];
-    MPI_VALIDATE_RET( X != NULL );
-
-    *p  = ( z < 0 ) ? -z : z;
-    Y.s = ( z < 0 ) ? -1 : 1;
-    Y.n = 1;
-    Y.p = p;
-
-    return( mbedtls_mpi_cmp_mpi( X, &Y ) );
-}
-
-/*
- * Unsigned addition: X = |A| + |B|  (HAC 14.7)
- */
-int mbedtls_mpi_add_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i, j;
-    mbedtls_mpi_uint *o, *p, c, tmp;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    if( X == B )
-    {
-        const mbedtls_mpi *T = A; A = X; B = T;
-    }
-
-    if( X != A )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
-
-    /*
-     * X should always be positive as a result of unsigned additions.
-     */
-    X->s = 1;
-
-    for( j = B->n; j > 0; j-- )
-        if( B->p[j - 1] != 0 )
-            break;
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
-
-    o = B->p; p = X->p; c = 0;
-
-    /*
-     * tmp is used because it might happen that p == o
-     */
-    for( i = 0; i < j; i++, o++, p++ )
-    {
-        tmp= *o;
-        *p +=  c; c  = ( *p <  c );
-        *p += tmp; c += ( *p < tmp );
-    }
-
-    while( c != 0 )
-    {
-        if( i >= X->n )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + 1 ) );
-            p = X->p + i;
-        }
-
-        *p += c; c = ( *p < c ); i++; p++;
-    }
-
-cleanup:
-
-    return( ret );
-}
-
-/**
- * Helper for mbedtls_mpi subtraction.
- *
- * Calculate l - r where l and r have the same size.
- * This function operates modulo (2^ciL)^n and returns the carry
- * (1 if there was a wraparound, i.e. if `l < r`, and 0 otherwise).
- *
- * d may be aliased to l or r.
- *
- * \param n             Number of limbs of \p d, \p l and \p r.
- * \param[out] d        The result of the subtraction.
- * \param[in] l         The left operand.
- * \param[in] r         The right operand.
- *
- * \return              1 if `l < r`.
- *                      0 if `l >= r`.
- */
-static mbedtls_mpi_uint mpi_sub_hlp( size_t n,
-                                     mbedtls_mpi_uint *d,
-                                     const mbedtls_mpi_uint *l,
-                                     const mbedtls_mpi_uint *r )
-{
-    size_t i;
-    mbedtls_mpi_uint c = 0, t, z;
-
-    for( i = 0; i < n; i++ )
-    {
-        z = ( l[i] <  c );    t = l[i] - c;
-        c = ( t < r[i] ) + z; d[i] = t - r[i];
-    }
-
-    return( c );
-}
-
-/*
- * Unsigned subtraction: X = |A| - |B|  (HAC 14.9, 14.10)
- */
-int mbedtls_mpi_sub_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t n;
-    mbedtls_mpi_uint carry;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    for( n = B->n; n > 0; n-- )
-        if( B->p[n - 1] != 0 )
-            break;
-    if( n > A->n )
-    {
-        /* B >= (2^ciL)^n > A */
-        ret = MBEDTLS_ERR_MPI_NEGATIVE_VALUE;
-        goto cleanup;
-    }
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, A->n ) );
-
-    /* Set the high limbs of X to match A. Don't touch the lower limbs
-     * because X might be aliased to B, and we must not overwrite the
-     * significant digits of B. */
-    if( A->n > n )
-        memcpy( X->p + n, A->p + n, ( A->n - n ) * ciL );
-    if( X->n > A->n )
-        memset( X->p + A->n, 0, ( X->n - A->n ) * ciL );
-
-    carry = mpi_sub_hlp( n, X->p, A->p, B->p );
-    if( carry != 0 )
-    {
-        /* Propagate the carry to the first nonzero limb of X. */
-        for( ; n < X->n && X->p[n] == 0; n++ )
-            --X->p[n];
-        /* If we ran out of space for the carry, it means that the result
-         * is negative. */
-        if( n == X->n )
-        {
-            ret = MBEDTLS_ERR_MPI_NEGATIVE_VALUE;
-            goto cleanup;
-        }
-        --X->p[n];
-    }
-
-    /* X should always be positive as a result of unsigned subtractions. */
-    X->s = 1;
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Signed addition: X = A + B
- */
-int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret, s;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    s = A->s;
-    if( A->s * B->s < 0 )
-    {
-        if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
-            X->s =  s;
-        }
-        else
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, B, A ) );
-            X->s = -s;
-        }
-    }
-    else
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
-        X->s = s;
-    }
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Signed subtraction: X = A - B
- */
-int mbedtls_mpi_sub_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret, s;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    s = A->s;
-    if( A->s * B->s > 0 )
-    {
-        if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
-            X->s =  s;
-        }
-        else
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, B, A ) );
-            X->s = -s;
-        }
-    }
-    else
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
-        X->s = s;
-    }
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Signed addition: X = A + b
- */
-int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
-{
-    mbedtls_mpi B;
-    mbedtls_mpi_uint p[1];
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-
-    p[0] = ( b < 0 ) ? -b : b;
-    B.s = ( b < 0 ) ? -1 : 1;
-    B.n = 1;
-    B.p = p;
-
-    return( mbedtls_mpi_add_mpi( X, A, &B ) );
-}
-
-/*
- * Signed subtraction: X = A - b
- */
-int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
-{
-    mbedtls_mpi B;
-    mbedtls_mpi_uint p[1];
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-
-    p[0] = ( b < 0 ) ? -b : b;
-    B.s = ( b < 0 ) ? -1 : 1;
-    B.n = 1;
-    B.p = p;
-
-    return( mbedtls_mpi_sub_mpi( X, A, &B ) );
-}
-
-/** Helper for mbedtls_mpi multiplication.
- *
- * Add \p b * \p s to \p d.
- *
- * \param i             The number of limbs of \p s.
- * \param[in] s         A bignum to multiply, of size \p i.
- *                      It may overlap with \p d, but only if
- *                      \p d <= \p s.
- *                      Its leading limb must not be \c 0.
- * \param[in,out] d     The bignum to add to.
- *                      It must be sufficiently large to store the
- *                      result of the multiplication. This means
- *                      \p i + 1 limbs if \p d[\p i - 1] started as 0 and \p b
- *                      is not known a priori.
- * \param b             A scalar to multiply.
- */
-static
-#if defined(__APPLE__) && defined(__arm__)
-/*
- * Apple LLVM version 4.2 (clang-425.0.24) (based on LLVM 3.2svn)
- * appears to need this to prevent bad ARM code generation at -O3.
- */
-__attribute__ ((noinline))
-#endif
-void mpi_mul_hlp( size_t i,
-                  const mbedtls_mpi_uint *s,
-                  mbedtls_mpi_uint *d,
-                  mbedtls_mpi_uint b )
-{
-    mbedtls_mpi_uint c = 0;
-
-#if defined(MULADDC_HUIT)
-    for( ; i >= 8; i -= 8 )
-    {
-        MULADDC_INIT
-        MULADDC_HUIT
-        MULADDC_STOP
-    }
-
-    for( ; i > 0; i-- )
-    {
-        MULADDC_INIT
-        MULADDC_CORE
-        MULADDC_STOP
-    }
-#else /* MULADDC_HUIT */
-    for( ; i >= 16; i -= 16 )
-    {
-        MULADDC_INIT
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_STOP
-    }
-
-    for( ; i >= 8; i -= 8 )
-    {
-        MULADDC_INIT
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_CORE   MULADDC_CORE
-        MULADDC_STOP
-    }
-
-    for( ; i > 0; i-- )
-    {
-        MULADDC_INIT
-        MULADDC_CORE
-        MULADDC_STOP
-    }
-#endif /* MULADDC_HUIT */
-
-    while( c != 0 )
-    {
-        *d += c; c = ( *d < c ); d++;
-    }
-}
-
-/*
- * Baseline multiplication: X = A * B  (HAC 14.12)
- */
-int mbedtls_mpi_mul_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i, j;
-    mbedtls_mpi TA, TB;
-    int result_is_zero = 0;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
-
-    if( X == A ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) ); A = &TA; }
-    if( X == B ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) ); B = &TB; }
-
-    for( i = A->n; i > 0; i-- )
-        if( A->p[i - 1] != 0 )
-            break;
-    if( i == 0 )
-        result_is_zero = 1;
-
-    for( j = B->n; j > 0; j-- )
-        if( B->p[j - 1] != 0 )
-            break;
-    if( j == 0 )
-        result_is_zero = 1;
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + j ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
-
-    for( ; j > 0; j-- )
-        mpi_mul_hlp( i, A->p, X->p + j - 1, B->p[j - 1] );
-
-    /* If the result is 0, we don't shortcut the operation, which reduces
-     * but does not eliminate side channels leaking the zero-ness. We do
-     * need to take care to set the sign bit properly since the library does
-     * not fully support an MPI object with a value of 0 and s == -1. */
-    if( result_is_zero )
-        X->s = 1;
-    else
-        X->s = A->s * B->s;
-
-cleanup:
-
-    mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TA );
-
-    return( ret );
-}
-
-/*
- * Baseline multiplication: X = A * b
- */
-int mbedtls_mpi_mul_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_uint b )
-{
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-
-    /* mpi_mul_hlp can't deal with a leading 0. */
-    size_t n = A->n;
-    while( n > 0 && A->p[n - 1] == 0 )
-        --n;
-
-    /* The general method below doesn't work if n==0 or b==0. By chance
-     * calculating the result is trivial in those cases. */
-    if( b == 0 || n == 0 )
-    {
-        return( mbedtls_mpi_lset( X, 0 ) );
-    }
-
-    /* Calculate A*b as A + A*(b-1) to take advantage of mpi_mul_hlp */
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    /* In general, A * b requires 1 limb more than b. If
-     * A->p[n - 1] * b / b == A->p[n - 1], then A * b fits in the same
-     * number of limbs as A and the call to grow() is not required since
-     * copy() will take care of the growth if needed. However, experimentally,
-     * making the call to grow() unconditional causes slightly fewer
-     * calls to calloc() in ECP code, presumably because it reuses the
-     * same mpi for a while and this way the mpi is more likely to directly
-     * grow to its final size. */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n + 1 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
-    mpi_mul_hlp( n, A->p, X->p, b - 1 );
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Unsigned integer divide - double mbedtls_mpi_uint dividend, u1/u0, and
- * mbedtls_mpi_uint divisor, d
- */
-static mbedtls_mpi_uint mbedtls_int_div_int( mbedtls_mpi_uint u1,
-            mbedtls_mpi_uint u0, mbedtls_mpi_uint d, mbedtls_mpi_uint *r )
-{
-#if defined(MBEDTLS_HAVE_UDBL)
-    mbedtls_t_udbl dividend, quotient;
-#else
-    const mbedtls_mpi_uint radix = (mbedtls_mpi_uint) 1 << biH;
-    const mbedtls_mpi_uint uint_halfword_mask = ( (mbedtls_mpi_uint) 1 << biH ) - 1;
-    mbedtls_mpi_uint d0, d1, q0, q1, rAX, r0, quotient;
-    mbedtls_mpi_uint u0_msw, u0_lsw;
-    size_t s;
-#endif
-
-    /*
-     * Check for overflow
-     */
-    if( 0 == d || u1 >= d )
-    {
-        if (r != NULL) *r = ~0;
-
-        return ( ~0 );
-    }
-
-#if defined(MBEDTLS_HAVE_UDBL)
-    dividend  = (mbedtls_t_udbl) u1 << biL;
-    dividend |= (mbedtls_t_udbl) u0;
-    quotient = dividend / d;
-    if( quotient > ( (mbedtls_t_udbl) 1 << biL ) - 1 )
-        quotient = ( (mbedtls_t_udbl) 1 << biL ) - 1;
-
-    if( r != NULL )
-        *r = (mbedtls_mpi_uint)( dividend - (quotient * d ) );
-
-    return (mbedtls_mpi_uint) quotient;
-#else
-
-    /*
-     * Algorithm D, Section 4.3.1 - The Art of Computer Programming
-     *   Vol. 2 - Seminumerical Algorithms, Knuth
-     */
-
-    /*
-     * Normalize the divisor, d, and dividend, u0, u1
-     */
-    s = mbedtls_clz( d );
-    d = d << s;
-
-    u1 = u1 << s;
-    u1 |= ( u0 >> ( biL - s ) ) & ( -(mbedtls_mpi_sint)s >> ( biL - 1 ) );
-    u0 =  u0 << s;
-
-    d1 = d >> biH;
-    d0 = d & uint_halfword_mask;
-
-    u0_msw = u0 >> biH;
-    u0_lsw = u0 & uint_halfword_mask;
-
-    /*
-     * Find the first quotient and remainder
-     */
-    q1 = u1 / d1;
-    r0 = u1 - d1 * q1;
-
-    while( q1 >= radix || ( q1 * d0 > radix * r0 + u0_msw ) )
-    {
-        q1 -= 1;
-        r0 += d1;
-
-        if ( r0 >= radix ) break;
-    }
-
-    rAX = ( u1 * radix ) + ( u0_msw - q1 * d );
-    q0 = rAX / d1;
-    r0 = rAX - q0 * d1;
-
-    while( q0 >= radix || ( q0 * d0 > radix * r0 + u0_lsw ) )
-    {
-        q0 -= 1;
-        r0 += d1;
-
-        if ( r0 >= radix ) break;
-    }
-
-    if (r != NULL)
-        *r = ( rAX * radix + u0_lsw - q0 * d ) >> s;
-
-    quotient = q1 * radix + q0;
-
-    return quotient;
-#endif
-}
-
-/*
- * Division by mbedtls_mpi: A = Q * B + R  (HAC 14.20)
- */
-int mbedtls_mpi_div_mpi( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A,
-                         const mbedtls_mpi *B )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i, n, t, k;
-    mbedtls_mpi X, Y, Z, T1, T2;
-    mbedtls_mpi_uint TP2[3];
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    if( mbedtls_mpi_cmp_int( B, 0 ) == 0 )
-        return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
-
-    mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
-    mbedtls_mpi_init( &T1 );
-    /*
-     * Avoid dynamic memory allocations for constant-size T2.
-     *
-     * T2 is used for comparison only and the 3 limbs are assigned explicitly,
-     * so nobody increase the size of the MPI and we're safe to use an on-stack
-     * buffer.
-     */
-    T2.s = 1;
-    T2.n = sizeof( TP2 ) / sizeof( *TP2 );
-    T2.p = TP2;
-
-    if( mbedtls_mpi_cmp_abs( A, B ) < 0 )
-    {
-        if( Q != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_lset( Q, 0 ) );
-        if( R != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, A ) );
-        return( 0 );
-    }
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &X, A ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, B ) );
-    X.s = Y.s = 1;
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &Z, A->n + 2 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Z,  0 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T1, A->n + 2 ) );
-
-    k = mbedtls_mpi_bitlen( &Y ) % biL;
-    if( k < biL - 1 )
-    {
-        k = biL - 1 - k;
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &X, k ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, k ) );
-    }
-    else k = 0;
-
-    n = X.n - 1;
-    t = Y.n - 1;
-    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, biL * ( n - t ) ) );
-
-    while( mbedtls_mpi_cmp_mpi( &X, &Y ) >= 0 )
-    {
-        Z.p[n - t]++;
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &Y ) );
-    }
-    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, biL * ( n - t ) ) );
-
-    for( i = n; i > t ; i-- )
-    {
-        if( X.p[i] >= Y.p[t] )
-            Z.p[i - t - 1] = ~0;
-        else
-        {
-            Z.p[i - t - 1] = mbedtls_int_div_int( X.p[i], X.p[i - 1],
-                                                            Y.p[t], NULL);
-        }
-
-        T2.p[0] = ( i < 2 ) ? 0 : X.p[i - 2];
-        T2.p[1] = ( i < 1 ) ? 0 : X.p[i - 1];
-        T2.p[2] = X.p[i];
-
-        Z.p[i - t - 1]++;
-        do
-        {
-            Z.p[i - t - 1]--;
-
-            MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T1, 0 ) );
-            T1.p[0] = ( t < 1 ) ? 0 : Y.p[t - 1];
-            T1.p[1] = Y.p[t];
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &T1, Z.p[i - t - 1] ) );
-        }
-        while( mbedtls_mpi_cmp_mpi( &T1, &T2 ) > 0 );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &Y, Z.p[i - t - 1] ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T1,  biL * ( i - t - 1 ) ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &T1 ) );
-
-        if( mbedtls_mpi_cmp_int( &X, 0 ) < 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T1, &Y ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &X, &X, &T1 ) );
-            Z.p[i - t - 1]--;
-        }
-    }
-
-    if( Q != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( Q, &Z ) );
-        Q->s = A->s * B->s;
-    }
-
-    if( R != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &X, k ) );
-        X.s = A->s;
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, &X ) );
-
-        if( mbedtls_mpi_cmp_int( R, 0 ) == 0 )
-            R->s = 1;
-    }
-
-cleanup:
-
-    mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
-    mbedtls_mpi_free( &T1 );
-    mbedtls_platform_zeroize( TP2, sizeof( TP2 ) );
-
-    return( ret );
-}
-
-/*
- * Division by int: A = Q * b + R
- */
-int mbedtls_mpi_div_int( mbedtls_mpi *Q, mbedtls_mpi *R,
-                         const mbedtls_mpi *A,
-                         mbedtls_mpi_sint b )
-{
-    mbedtls_mpi B;
-    mbedtls_mpi_uint p[1];
-    MPI_VALIDATE_RET( A != NULL );
-
-    p[0] = ( b < 0 ) ? -b : b;
-    B.s = ( b < 0 ) ? -1 : 1;
-    B.n = 1;
-    B.p = p;
-
-    return( mbedtls_mpi_div_mpi( Q, R, A, &B ) );
-}
-
-/*
- * Modulo: R = A mod B
- */
-int mbedtls_mpi_mod_mpi( mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    MPI_VALIDATE_RET( R != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    if( mbedtls_mpi_cmp_int( B, 0 ) < 0 )
-        return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( NULL, R, A, B ) );
-
-    while( mbedtls_mpi_cmp_int( R, 0 ) < 0 )
-      MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( R, R, B ) );
-
-    while( mbedtls_mpi_cmp_mpi( R, B ) >= 0 )
-      MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( R, R, B ) );
-
-cleanup:
-
-    return( ret );
-}
-
-/*
- * Modulo: r = A mod b
- */
-int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )
-{
-    size_t i;
-    mbedtls_mpi_uint x, y, z;
-    MPI_VALIDATE_RET( r != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-
-    if( b == 0 )
-        return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
-
-    if( b < 0 )
-        return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
-
-    /*
-     * handle trivial cases
-     */
-    if( b == 1 )
-    {
-        *r = 0;
-        return( 0 );
-    }
-
-    if( b == 2 )
-    {
-        *r = A->p[0] & 1;
-        return( 0 );
-    }
-
-    /*
-     * general case
-     */
-    for( i = A->n, y = 0; i > 0; i-- )
-    {
-        x  = A->p[i - 1];
-        y  = ( y << biH ) | ( x >> biH );
-        z  = y / b;
-        y -= z * b;
-
-        x <<= biH;
-        y  = ( y << biH ) | ( x >> biH );
-        z  = y / b;
-        y -= z * b;
-    }
-
-    /*
-     * If A is negative, then the current y represents a negative value.
-     * Flipping it to the positive side.
-     */
-    if( A->s < 0 && y != 0 )
-        y = b - y;
-
-    *r = y;
-
-    return( 0 );
-}
-
-/*
- * Fast Montgomery initialization (thanks to Tom St Denis)
- */
-static void mpi_montg_init( mbedtls_mpi_uint *mm, const mbedtls_mpi *N )
-{
-    mbedtls_mpi_uint x, m0 = N->p[0];
-    unsigned int i;
-
-    x  = m0;
-    x += ( ( m0 + 2 ) & 4 ) << 1;
-
-    for( i = biL; i >= 8; i /= 2 )
-        x *= ( 2 - ( m0 * x ) );
-
-    *mm = ~x + 1;
-}
-
-/** Montgomery multiplication: A = A * B * R^-1 mod N  (HAC 14.36)
- *
- * \param[in,out]   A   One of the numbers to multiply.
- *                      It must have at least as many limbs as N
- *                      (A->n >= N->n), and any limbs beyond n are ignored.
- *                      On successful completion, A contains the result of
- *                      the multiplication A * B * R^-1 mod N where
- *                      R = (2^ciL)^n.
- * \param[in]       B   One of the numbers to multiply.
- *                      It must be nonzero and must not have more limbs than N
- *                      (B->n <= N->n).
- * \param[in]       N   The modulo. N must be odd.
- * \param           mm  The value calculated by `mpi_montg_init(&mm, N)`.
- *                      This is -N^-1 mod 2^ciL.
- * \param[in,out]   T   A bignum for temporary storage.
- *                      It must be at least twice the limb size of N plus 2
- *                      (T->n >= 2 * (N->n + 1)).
- *                      Its initial content is unused and
- *                      its final content is indeterminate.
- *                      Note that unlike the usual convention in the library
- *                      for `const mbedtls_mpi*`, the content of T can change.
- */
-static void mpi_montmul( mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N, mbedtls_mpi_uint mm,
-                         const mbedtls_mpi *T )
-{
-    size_t i, n, m;
-    mbedtls_mpi_uint u0, u1, *d;
-
-    memset( T->p, 0, T->n * ciL );
-
-    d = T->p;
-    n = N->n;
-    m = ( B->n < n ) ? B->n : n;
-
-    for( i = 0; i < n; i++ )
-    {
-        /*
-         * T = (T + u0*B + u1*N) / 2^biL
-         */
-        u0 = A->p[i];
-        u1 = ( d[0] + u0 * B->p[0] ) * mm;
-
-        mpi_mul_hlp( m, B->p, d, u0 );
-        mpi_mul_hlp( n, N->p, d, u1 );
-
-        *d++ = u0; d[n + 1] = 0;
-    }
-
-    /* At this point, d is either the desired result or the desired result
-     * plus N. We now potentially subtract N, avoiding leaking whether the
-     * subtraction is performed through side channels. */
-
-    /* Copy the n least significant limbs of d to A, so that
-     * A = d if d < N (recall that N has n limbs). */
-    memcpy( A->p, d, n * ciL );
-    /* If d >= N then we want to set A to d - N. To prevent timing attacks,
-     * do the calculation without using conditional tests. */
-    /* Set d to d0 + (2^biL)^n - N where d0 is the current value of d. */
-    d[n] += 1;
-    d[n] -= mpi_sub_hlp( n, d, d, N->p );
-    /* If d0 < N then d < (2^biL)^n
-     * so d[n] == 0 and we want to keep A as it is.
-     * If d0 >= N then d >= (2^biL)^n, and d <= (2^biL)^n + N < 2 * (2^biL)^n
-     * so d[n] == 1 and we want to set A to the result of the subtraction
-     * which is d - (2^biL)^n, i.e. the n least significant limbs of d.
-     * This exactly corresponds to a conditional assignment. */
-    mbedtls_ct_mpi_uint_cond_assign( n, A->p, d, (unsigned char) d[n] );
-}
-
-/*
- * Montgomery reduction: A = A * R^-1 mod N
- *
- * See mpi_montmul() regarding constraints and guarantees on the parameters.
- */
-static void mpi_montred( mbedtls_mpi *A, const mbedtls_mpi *N,
-                         mbedtls_mpi_uint mm, const mbedtls_mpi *T )
-{
-    mbedtls_mpi_uint z = 1;
-    mbedtls_mpi U;
-
-    U.n = U.s = (int) z;
-    U.p = &z;
-
-    mpi_montmul( A, &U, N, mm, T );
-}
-
-/**
- * Select an MPI from a table without leaking the index.
- *
- * This is functionally equivalent to mbedtls_mpi_copy(R, T[idx]) except it
- * reads the entire table in order to avoid leaking the value of idx to an
- * attacker able to observe memory access patterns.
- *
- * \param[out] R        Where to write the selected MPI.
- * \param[in] T         The table to read from.
- * \param[in] T_size    The number of elements in the table.
- * \param[in] idx       The index of the element to select;
- *                      this must satisfy 0 <= idx < T_size.
- *
- * \return \c 0 on success, or a negative error code.
- */
-static int mpi_select( mbedtls_mpi *R, const mbedtls_mpi *T, size_t T_size, size_t idx )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    for( size_t i = 0; i < T_size; i++ )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( R, &T[i],
-                        (unsigned char) mbedtls_ct_size_bool_eq( i, idx ) ) );
-    }
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Sliding-window exponentiation: X = A^E mod N  (HAC 14.85)
- */
-int mbedtls_mpi_exp_mod( mbedtls_mpi *X, const mbedtls_mpi *A,
-                         const mbedtls_mpi *E, const mbedtls_mpi *N,
-                         mbedtls_mpi *prec_RR )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t wbits, wsize, one = 1;
-    size_t i, j, nblimbs;
-    size_t bufsize, nbits;
-    mbedtls_mpi_uint ei, mm, state;
-    mbedtls_mpi RR, T, W[ 1 << MBEDTLS_MPI_WINDOW_SIZE ], WW, Apos;
-    int neg;
-
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( E != NULL );
-    MPI_VALIDATE_RET( N != NULL );
-
-    if( mbedtls_mpi_cmp_int( N, 0 ) <= 0 || ( N->p[0] & 1 ) == 0 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    if( mbedtls_mpi_cmp_int( E, 0 ) < 0 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    if( mbedtls_mpi_bitlen( E ) > MBEDTLS_MPI_MAX_BITS ||
-        mbedtls_mpi_bitlen( N ) > MBEDTLS_MPI_MAX_BITS )
-        return ( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    /*
-     * Init temps and window size
-     */
-    mpi_montg_init( &mm, N );
-    mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &T );
-    mbedtls_mpi_init( &Apos );
-    mbedtls_mpi_init( &WW );
-    memset( W, 0, sizeof( W ) );
-
-    i = mbedtls_mpi_bitlen( E );
-
-    wsize = ( i > 671 ) ? 6 : ( i > 239 ) ? 5 :
-            ( i >  79 ) ? 4 : ( i >  23 ) ? 3 : 1;
-
-#if( MBEDTLS_MPI_WINDOW_SIZE < 6 )
-    if( wsize > MBEDTLS_MPI_WINDOW_SIZE )
-        wsize = MBEDTLS_MPI_WINDOW_SIZE;
-#endif
-
-    j = N->n + 1;
-    /* All W[i] and X must have at least N->n limbs for the mpi_montmul()
-     * and mpi_montred() calls later. Here we ensure that W[1] and X are
-     * large enough, and later we'll grow other W[i] to the same length.
-     * They must not be shrunk midway through this function!
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[1],  j ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T, j * 2 ) );
-
-    /*
-     * Compensate for negative A (and correct at the end)
-     */
-    neg = ( A->s == -1 );
-    if( neg )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Apos, A ) );
-        Apos.s = 1;
-        A = &Apos;
-    }
-
-    /*
-     * If 1st call, pre-compute R^2 mod N
-     */
-    if( prec_RR == NULL || prec_RR->p == NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &RR, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &RR, N->n * 2 * biL ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &RR, &RR, N ) );
-
-        if( prec_RR != NULL )
-            memcpy( prec_RR, &RR, sizeof( mbedtls_mpi ) );
-    }
-    else
-        memcpy( &RR, prec_RR, sizeof( mbedtls_mpi ) );
-
-    /*
-     * W[1] = A * R^2 * R^-1 mod N = A * R mod N
-     */
-    if( mbedtls_mpi_cmp_mpi( A, N ) >= 0 )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &W[1], A, N ) );
-        /* This should be a no-op because W[1] is already that large before
-         * mbedtls_mpi_mod_mpi(), but it's necessary to avoid an overflow
-         * in mpi_montmul() below, so let's make sure. */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[1], N->n + 1 ) );
-    }
-    else
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[1], A ) );
-
-    /* Note that this is safe because W[1] always has at least N->n limbs
-     * (it grew above and was preserved by mbedtls_mpi_copy()). */
-    mpi_montmul( &W[1], &RR, N, mm, &T );
-
-    /*
-     * X = R^2 * R^-1 mod N = R mod N
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &RR ) );
-    mpi_montred( X, N, mm, &T );
-
-    if( wsize > 1 )
-    {
-        /*
-         * W[1 << (wsize - 1)] = W[1] ^ (wsize - 1)
-         */
-        j =  one << ( wsize - 1 );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[j], N->n + 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[j], &W[1]    ) );
-
-        for( i = 0; i < wsize - 1; i++ )
-            mpi_montmul( &W[j], &W[j], N, mm, &T );
-
-        /*
-         * W[i] = W[i - 1] * W[1]
-         */
-        for( i = j + 1; i < ( one << wsize ); i++ )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[i], N->n + 1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[i], &W[i - 1] ) );
-
-            mpi_montmul( &W[i], &W[1], N, mm, &T );
-        }
-    }
-
-    nblimbs = E->n;
-    bufsize = 0;
-    nbits   = 0;
-    wbits   = 0;
-    state   = 0;
-
-    while( 1 )
-    {
-        if( bufsize == 0 )
-        {
-            if( nblimbs == 0 )
-                break;
-
-            nblimbs--;
-
-            bufsize = sizeof( mbedtls_mpi_uint ) << 3;
-        }
-
-        bufsize--;
-
-        ei = (E->p[nblimbs] >> bufsize) & 1;
-
-        /*
-         * skip leading 0s
-         */
-        if( ei == 0 && state == 0 )
-            continue;
-
-        if( ei == 0 && state == 1 )
-        {
-            /*
-             * out of window, square X
-             */
-            mpi_montmul( X, X, N, mm, &T );
-            continue;
-        }
-
-        /*
-         * add ei to current window
-         */
-        state = 2;
-
-        nbits++;
-        wbits |= ( ei << ( wsize - nbits ) );
-
-        if( nbits == wsize )
-        {
-            /*
-             * X = X^wsize R^-1 mod N
-             */
-            for( i = 0; i < wsize; i++ )
-                mpi_montmul( X, X, N, mm, &T );
-
-            /*
-             * X = X * W[wbits] R^-1 mod N
-             */
-            MBEDTLS_MPI_CHK( mpi_select( &WW, W, (size_t) 1 << wsize, wbits ) );
-            mpi_montmul( X, &WW, N, mm, &T );
-
-            state--;
-            nbits = 0;
-            wbits = 0;
-        }
-    }
-
-    /*
-     * process the remaining bits
-     */
-    for( i = 0; i < nbits; i++ )
-    {
-        mpi_montmul( X, X, N, mm, &T );
-
-        wbits <<= 1;
-
-        if( ( wbits & ( one << wsize ) ) != 0 )
-            mpi_montmul( X, &W[1], N, mm, &T );
-    }
-
-    /*
-     * X = A^E * R * R^-1 mod N = A^E mod N
-     */
-    mpi_montred( X, N, mm, &T );
-
-    if( neg && E->n != 0 && ( E->p[0] & 1 ) != 0 )
-    {
-        X->s = -1;
-        MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( X, N, X ) );
-    }
-
-cleanup:
-
-    for( i = ( one << ( wsize - 1 ) ); i < ( one << wsize ); i++ )
-        mbedtls_mpi_free( &W[i] );
-
-    mbedtls_mpi_free( &W[1] ); mbedtls_mpi_free( &T ); mbedtls_mpi_free( &Apos );
-    mbedtls_mpi_free( &WW );
-
-    if( prec_RR == NULL || prec_RR->p == NULL )
-        mbedtls_mpi_free( &RR );
-
-    return( ret );
-}
-
-/*
- * Greatest common divisor: G = gcd(A, B)  (HAC 14.54)
- */
-int mbedtls_mpi_gcd( mbedtls_mpi *G, const mbedtls_mpi *A, const mbedtls_mpi *B )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t lz, lzt;
-    mbedtls_mpi TA, TB;
-
-    MPI_VALIDATE_RET( G != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( B != NULL );
-
-    mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
-
-    lz = mbedtls_mpi_lsb( &TA );
-    lzt = mbedtls_mpi_lsb( &TB );
-
-    /* The loop below gives the correct result when A==0 but not when B==0.
-     * So have a special case for B==0. Leverage the fact that we just
-     * calculated the lsb and lsb(B)==0 iff B is odd or 0 to make the test
-     * slightly more efficient than cmp_int(). */
-    if( lzt == 0 && mbedtls_mpi_get_bit( &TB, 0 ) == 0 )
-    {
-        ret = mbedtls_mpi_copy( G, A );
-        goto cleanup;
-    }
-
-    if( lzt < lz )
-        lz = lzt;
-
-    TA.s = TB.s = 1;
-
-    /* We mostly follow the procedure described in HAC 14.54, but with some
-     * minor differences:
-     * - Sequences of multiplications or divisions by 2 are grouped into a
-     *   single shift operation.
-     * - The procedure in HAC assumes that 0 < TB <= TA.
-     *     - The condition TB <= TA is not actually necessary for correctness.
-     *       TA and TB have symmetric roles except for the loop termination
-     *       condition, and the shifts at the beginning of the loop body
-     *       remove any significance from the ordering of TA vs TB before
-     *       the shifts.
-     *     - If TA = 0, the loop goes through 0 iterations and the result is
-     *       correctly TB.
-     *     - The case TB = 0 was short-circuited above.
-     *
-     * For the correctness proof below, decompose the original values of
-     * A and B as
-     *   A = sa * 2^a * A' with A'=0 or A' odd, and sa = +-1
-     *   B = sb * 2^b * B' with B'=0 or B' odd, and sb = +-1
-     * Then gcd(A, B) = 2^{min(a,b)} * gcd(A',B'),
-     * and gcd(A',B') is odd or 0.
-     *
-     * At the beginning, we have TA = |A| and TB = |B| so gcd(A,B) = gcd(TA,TB).
-     * The code maintains the following invariant:
-     *     gcd(A,B) = 2^k * gcd(TA,TB) for some k   (I)
-     */
-
-    /* Proof that the loop terminates:
-     * At each iteration, either the right-shift by 1 is made on a nonzero
-     * value and the nonnegative integer bitlen(TA) + bitlen(TB) decreases
-     * by at least 1, or the right-shift by 1 is made on zero and then
-     * TA becomes 0 which ends the loop (TB cannot be 0 if it is right-shifted
-     * since in that case TB is calculated from TB-TA with the condition TB>TA).
-     */
-    while( mbedtls_mpi_cmp_int( &TA, 0 ) != 0 )
-    {
-        /* Divisions by 2 preserve the invariant (I). */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, mbedtls_mpi_lsb( &TA ) ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, mbedtls_mpi_lsb( &TB ) ) );
-
-        /* Set either TA or TB to |TA-TB|/2. Since TA and TB are both odd,
-         * TA-TB is even so the division by 2 has an integer result.
-         * Invariant (I) is preserved since any odd divisor of both TA and TB
-         * also divides |TA-TB|/2, and any odd divisor of both TA and |TA-TB|/2
-         * also divides TB, and any odd divisior of both TB and |TA-TB|/2 also
-         * divides TA.
-         */
-        if( mbedtls_mpi_cmp_mpi( &TA, &TB ) >= 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &TA, &TA, &TB ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, 1 ) );
-        }
-        else
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &TB, &TB, &TA ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, 1 ) );
-        }
-        /* Note that one of TA or TB is still odd. */
-    }
-
-    /* By invariant (I), gcd(A,B) = 2^k * gcd(TA,TB) for some k.
-     * At the loop exit, TA = 0, so gcd(TA,TB) = TB.
-     * - If there was at least one loop iteration, then one of TA or TB is odd,
-     *   and TA = 0, so TB is odd and gcd(TA,TB) = gcd(A',B'). In this case,
-     *   lz = min(a,b) so gcd(A,B) = 2^lz * TB.
-     * - If there was no loop iteration, then A was 0, and gcd(A,B) = B.
-     *   In this case, lz = 0 and B = TB so gcd(A,B) = B = 2^lz * TB as well.
-     */
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &TB, lz ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( G, &TB ) );
-
-cleanup:
-
-    mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TB );
-
-    return( ret );
-}
-
-/* Fill X with n_bytes random bytes.
- * X must already have room for those bytes.
- * The ordering of the bytes returned from the RNG is suitable for
- * deterministic ECDSA (see RFC 6979 §3.3 and mbedtls_mpi_random()).
- * The size and sign of X are unchanged.
- * n_bytes must not be 0.
- */
-static int mpi_fill_random_internal(
-    mbedtls_mpi *X, size_t n_bytes,
-    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    const size_t limbs = CHARS_TO_LIMBS( n_bytes );
-    const size_t overhead = ( limbs * ciL ) - n_bytes;
-
-    if( X->n < limbs )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    memset( X->p, 0, overhead );
-    memset( (unsigned char *) X->p + limbs * ciL, 0, ( X->n - limbs ) * ciL );
-    MBEDTLS_MPI_CHK( f_rng( p_rng, (unsigned char *) X->p + overhead, n_bytes ) );
-    mpi_bigendian_to_host( X->p, limbs );
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Fill X with size bytes of random.
- *
- * Use a temporary bytes representation to make sure the result is the same
- * regardless of the platform endianness (useful when f_rng is actually
- * deterministic, eg for tests).
- */
-int mbedtls_mpi_fill_random( mbedtls_mpi *X, size_t size,
-                     int (*f_rng)(void *, unsigned char *, size_t),
-                     void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t const limbs = CHARS_TO_LIMBS( size );
-
-    MPI_VALIDATE_RET( X     != NULL );
-    MPI_VALIDATE_RET( f_rng != NULL );
-
-    /* Ensure that target MPI has exactly the necessary number of limbs */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_resize_clear( X, limbs ) );
-    if( size == 0 )
-        return( 0 );
-
-    ret = mpi_fill_random_internal( X, size, f_rng, p_rng );
-
-cleanup:
-    return( ret );
-}
-
-int mbedtls_mpi_random( mbedtls_mpi *X,
-                        mbedtls_mpi_sint min,
-                        const mbedtls_mpi *N,
-                        int (*f_rng)(void *, unsigned char *, size_t),
-                        void *p_rng )
-{
-    int ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
-    int count;
-    unsigned lt_lower = 1, lt_upper = 0;
-    size_t n_bits = mbedtls_mpi_bitlen( N );
-    size_t n_bytes = ( n_bits + 7 ) / 8;
-    mbedtls_mpi lower_bound;
-
-    if( min < 0 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-    if( mbedtls_mpi_cmp_int( N, min ) <= 0 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    /*
-     * When min == 0, each try has at worst a probability 1/2 of failing
-     * (the msb has a probability 1/2 of being 0, and then the result will
-     * be < N), so after 30 tries failure probability is a most 2**(-30).
-     *
-     * When N is just below a power of 2, as is the case when generating
-     * a random scalar on most elliptic curves, 1 try is enough with
-     * overwhelming probability. When N is just above a power of 2,
-     * as when generating a random scalar on secp224k1, each try has
-     * a probability of failing that is almost 1/2.
-     *
-     * The probabilities are almost the same if min is nonzero but negligible
-     * compared to N. This is always the case when N is crypto-sized, but
-     * it's convenient to support small N for testing purposes. When N
-     * is small, use a higher repeat count, otherwise the probability of
-     * failure is macroscopic.
-     */
-    count = ( n_bytes > 4 ? 30 : 250 );
-
-    mbedtls_mpi_init( &lower_bound );
-
-    /* Ensure that target MPI has exactly the same number of limbs
-     * as the upper bound, even if the upper bound has leading zeros.
-     * This is necessary for the mbedtls_mpi_lt_mpi_ct() check. */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_resize_clear( X, N->n ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &lower_bound, N->n ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &lower_bound, min ) );
-
-    /*
-     * Match the procedure given in RFC 6979 §3.3 (deterministic ECDSA)
-     * when f_rng is a suitably parametrized instance of HMAC_DRBG:
-     * - use the same byte ordering;
-     * - keep the leftmost n_bits bits of the generated octet string;
-     * - try until result is in the desired range.
-     * This also avoids any bias, which is especially important for ECDSA.
-     */
-    do
-    {
-        MBEDTLS_MPI_CHK( mpi_fill_random_internal( X, n_bytes, f_rng, p_rng ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, 8 * n_bytes - n_bits ) );
-
-        if( --count == 0 )
-        {
-            ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
-            goto cleanup;
-        }
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lt_mpi_ct( X, &lower_bound, &lt_lower ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lt_mpi_ct( X, N, &lt_upper ) );
-    }
-    while( lt_lower != 0 || lt_upper == 0 );
-
-cleanup:
-    mbedtls_mpi_free( &lower_bound );
-    return( ret );
-}
-
-/*
- * Modular inverse: X = A^-1 mod N  (HAC 14.61 / 14.64)
- */
-int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *N )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( A != NULL );
-    MPI_VALIDATE_RET( N != NULL );
-
-    if( mbedtls_mpi_cmp_int( N, 1 ) <= 0 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TU ); mbedtls_mpi_init( &U1 ); mbedtls_mpi_init( &U2 );
-    mbedtls_mpi_init( &G ); mbedtls_mpi_init( &TB ); mbedtls_mpi_init( &TV );
-    mbedtls_mpi_init( &V1 ); mbedtls_mpi_init( &V2 );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, A, N ) );
-
-    if( mbedtls_mpi_cmp_int( &G, 1 ) != 0 )
-    {
-        ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
-        goto cleanup;
-    }
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &TA, A, N ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TU, &TA ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, N ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TV, N ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U1, 1 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U2, 0 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V1, 0 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V2, 1 ) );
-
-    do
-    {
-        while( ( TU.p[0] & 1 ) == 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TU, 1 ) );
-
-            if( ( U1.p[0] & 1 ) != 0 || ( U2.p[0] & 1 ) != 0 )
-            {
-                MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &U1, &U1, &TB ) );
-                MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &TA ) );
-            }
-
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U1, 1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U2, 1 ) );
-        }
-
-        while( ( TV.p[0] & 1 ) == 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TV, 1 ) );
-
-            if( ( V1.p[0] & 1 ) != 0 || ( V2.p[0] & 1 ) != 0 )
-            {
-                MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, &TB ) );
-                MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &TA ) );
-            }
-
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V1, 1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V2, 1 ) );
-        }
-
-        if( mbedtls_mpi_cmp_mpi( &TU, &TV ) >= 0 )
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TU, &TU, &TV ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U1, &U1, &V1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &V2 ) );
-        }
-        else
-        {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TV, &TV, &TU ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, &U1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &U2 ) );
-        }
-    }
-    while( mbedtls_mpi_cmp_int( &TU, 0 ) != 0 );
-
-    while( mbedtls_mpi_cmp_int( &V1, 0 ) < 0 )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, N ) );
-
-    while( mbedtls_mpi_cmp_mpi( &V1, N ) >= 0 )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, N ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &V1 ) );
-
-cleanup:
-
-    mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TU ); mbedtls_mpi_free( &U1 ); mbedtls_mpi_free( &U2 );
-    mbedtls_mpi_free( &G ); mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TV );
-    mbedtls_mpi_free( &V1 ); mbedtls_mpi_free( &V2 );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_GENPRIME)
-
-static const int small_prime[] =
-{
-        3,    5,    7,   11,   13,   17,   19,   23,
-       29,   31,   37,   41,   43,   47,   53,   59,
-       61,   67,   71,   73,   79,   83,   89,   97,
-      101,  103,  107,  109,  113,  127,  131,  137,
-      139,  149,  151,  157,  163,  167,  173,  179,
-      181,  191,  193,  197,  199,  211,  223,  227,
-      229,  233,  239,  241,  251,  257,  263,  269,
-      271,  277,  281,  283,  293,  307,  311,  313,
-      317,  331,  337,  347,  349,  353,  359,  367,
-      373,  379,  383,  389,  397,  401,  409,  419,
-      421,  431,  433,  439,  443,  449,  457,  461,
-      463,  467,  479,  487,  491,  499,  503,  509,
-      521,  523,  541,  547,  557,  563,  569,  571,
-      577,  587,  593,  599,  601,  607,  613,  617,
-      619,  631,  641,  643,  647,  653,  659,  661,
-      673,  677,  683,  691,  701,  709,  719,  727,
-      733,  739,  743,  751,  757,  761,  769,  773,
-      787,  797,  809,  811,  821,  823,  827,  829,
-      839,  853,  857,  859,  863,  877,  881,  883,
-      887,  907,  911,  919,  929,  937,  941,  947,
-      953,  967,  971,  977,  983,  991,  997, -103
-};
-
-/*
- * Small divisors test (X must be positive)
- *
- * Return values:
- * 0: no small factor (possible prime, more tests needed)
- * 1: certain prime
- * MBEDTLS_ERR_MPI_NOT_ACCEPTABLE: certain non-prime
- * other negative: error
- */
-static int mpi_check_small_factors( const mbedtls_mpi *X )
-{
-    int ret = 0;
-    size_t i;
-    mbedtls_mpi_uint r;
-
-    if( ( X->p[0] & 1 ) == 0 )
-        return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
-
-    for( i = 0; small_prime[i] > 0; i++ )
-    {
-        if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 )
-            return( 1 );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, small_prime[i] ) );
-
-        if( r == 0 )
-            return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
-    }
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Miller-Rabin pseudo-primality test  (HAC 4.24)
- */
-static int mpi_miller_rabin( const mbedtls_mpi *X, size_t rounds,
-                             int (*f_rng)(void *, unsigned char *, size_t),
-                             void *p_rng )
-{
-    int ret, count;
-    size_t i, j, k, s;
-    mbedtls_mpi W, R, T, A, RR;
-
-    MPI_VALIDATE_RET( X     != NULL );
-    MPI_VALIDATE_RET( f_rng != NULL );
-
-    mbedtls_mpi_init( &W ); mbedtls_mpi_init( &R );
-    mbedtls_mpi_init( &T ); mbedtls_mpi_init( &A );
-    mbedtls_mpi_init( &RR );
-
-    /*
-     * W = |X| - 1
-     * R = W >> lsb( W )
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &W, X, 1 ) );
-    s = mbedtls_mpi_lsb( &W );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R, &W ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &R, s ) );
-
-    for( i = 0; i < rounds; i++ )
-    {
-        /*
-         * pick a random A, 1 < A < |X| - 1
-         */
-        count = 0;
-        do {
-            MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &A, X->n * ciL, f_rng, p_rng ) );
-
-            j = mbedtls_mpi_bitlen( &A );
-            k = mbedtls_mpi_bitlen( &W );
-            if (j > k) {
-                A.p[A.n - 1] &= ( (mbedtls_mpi_uint) 1 << ( k - ( A.n - 1 ) * biL - 1 ) ) - 1;
-            }
-
-            if (count++ > 30) {
-                ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
-                goto cleanup;
-            }
-
-        } while ( mbedtls_mpi_cmp_mpi( &A, &W ) >= 0 ||
-                  mbedtls_mpi_cmp_int( &A, 1 )  <= 0    );
-
-        /*
-         * A = A^R mod |X|
-         */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &A, &A, &R, X, &RR ) );
-
-        if( mbedtls_mpi_cmp_mpi( &A, &W ) == 0 ||
-            mbedtls_mpi_cmp_int( &A,  1 ) == 0 )
-            continue;
-
-        j = 1;
-        while( j < s && mbedtls_mpi_cmp_mpi( &A, &W ) != 0 )
-        {
-            /*
-             * A = A * A mod |X|
-             */
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &A, &A ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &A, &T, X  ) );
-
-            if( mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
-                break;
-
-            j++;
-        }
-
-        /*
-         * not prime if A != |X| - 1 or A == 1
-         */
-        if( mbedtls_mpi_cmp_mpi( &A, &W ) != 0 ||
-            mbedtls_mpi_cmp_int( &A,  1 ) == 0 )
-        {
-            ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
-            break;
-        }
-    }
-
-cleanup:
-    mbedtls_mpi_free( &W ); mbedtls_mpi_free( &R );
-    mbedtls_mpi_free( &T ); mbedtls_mpi_free( &A );
-    mbedtls_mpi_free( &RR );
-
-    return( ret );
-}
-
-/*
- * Pseudo-primality test: small factors, then Miller-Rabin
- */
-int mbedtls_mpi_is_prime_ext( const mbedtls_mpi *X, int rounds,
-                              int (*f_rng)(void *, unsigned char *, size_t),
-                              void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_mpi XX;
-    MPI_VALIDATE_RET( X     != NULL );
-    MPI_VALIDATE_RET( f_rng != NULL );
-
-    XX.s = 1;
-    XX.n = X->n;
-    XX.p = X->p;
-
-    if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 ||
-        mbedtls_mpi_cmp_int( &XX, 1 ) == 0 )
-        return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
-
-    if( mbedtls_mpi_cmp_int( &XX, 2 ) == 0 )
-        return( 0 );
-
-    if( ( ret = mpi_check_small_factors( &XX ) ) != 0 )
-    {
-        if( ret == 1 )
-            return( 0 );
-
-        return( ret );
-    }
-
-    return( mpi_miller_rabin( &XX, rounds, f_rng, p_rng ) );
-}
-
-/*
- * Prime number generation
- *
- * To generate an RSA key in a way recommended by FIPS 186-4, both primes must
- * be either 1024 bits or 1536 bits long, and flags must contain
- * MBEDTLS_MPI_GEN_PRIME_FLAG_LOW_ERR.
- */
-int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int flags,
-                   int (*f_rng)(void *, unsigned char *, size_t),
-                   void *p_rng )
-{
-#ifdef MBEDTLS_HAVE_INT64
-// ceil(2^63.5)
-#define CEIL_MAXUINT_DIV_SQRT2 0xb504f333f9de6485ULL
-#else
-// ceil(2^31.5)
-#define CEIL_MAXUINT_DIV_SQRT2 0xb504f334U
-#endif
-    int ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
-    size_t k, n;
-    int rounds;
-    mbedtls_mpi_uint r;
-    mbedtls_mpi Y;
-
-    MPI_VALIDATE_RET( X     != NULL );
-    MPI_VALIDATE_RET( f_rng != NULL );
-
-    if( nbits < 3 || nbits > MBEDTLS_MPI_MAX_BITS )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    mbedtls_mpi_init( &Y );
-
-    n = BITS_TO_LIMBS( nbits );
-
-    if( ( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_LOW_ERR ) == 0 )
-    {
-        /*
-         * 2^-80 error probability, number of rounds chosen per HAC, table 4.4
-         */
-        rounds = ( ( nbits >= 1300 ) ?  2 : ( nbits >=  850 ) ?  3 :
-                   ( nbits >=  650 ) ?  4 : ( nbits >=  350 ) ?  8 :
-                   ( nbits >=  250 ) ? 12 : ( nbits >=  150 ) ? 18 : 27 );
-    }
-    else
-    {
-        /*
-         * 2^-100 error probability, number of rounds computed based on HAC,
-         * fact 4.48
-         */
-        rounds = ( ( nbits >= 1450 ) ?  4 : ( nbits >=  1150 ) ?  5 :
-                   ( nbits >= 1000 ) ?  6 : ( nbits >=   850 ) ?  7 :
-                   ( nbits >=  750 ) ?  8 : ( nbits >=   500 ) ? 13 :
-                   ( nbits >=  250 ) ? 28 : ( nbits >=   150 ) ? 40 : 51 );
-    }
-
-    while( 1 )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
-        /* make sure generated number is at least (nbits-1)+0.5 bits (FIPS 186-4 §B.3.3 steps 4.4, 5.5) */
-        if( X->p[n-1] < CEIL_MAXUINT_DIV_SQRT2 ) continue;
-
-        k = n * biL;
-        if( k > nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, k - nbits ) );
-        X->p[0] |= 1;
-
-        if( ( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_DH ) == 0 )
-        {
-            ret = mbedtls_mpi_is_prime_ext( X, rounds, f_rng, p_rng );
-
-            if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
-                goto cleanup;
-        }
-        else
-        {
-            /*
-             * An necessary condition for Y and X = 2Y + 1 to be prime
-             * is X = 2 mod 3 (which is equivalent to Y = 2 mod 3).
-             * Make sure it is satisfied, while keeping X = 3 mod 4
-             */
-
-            X->p[0] |= 2;
-
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, 3 ) );
-            if( r == 0 )
-                MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 8 ) );
-            else if( r == 1 )
-                MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 4 ) );
-
-            /* Set Y = (X-1) / 2, which is X / 2 because X is odd */
-            MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, X ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, 1 ) );
-
-            while( 1 )
-            {
-                /*
-                 * First, check small factors for X and Y
-                 * before doing Miller-Rabin on any of them
-                 */
-                if( ( ret = mpi_check_small_factors(  X         ) ) == 0 &&
-                    ( ret = mpi_check_small_factors( &Y         ) ) == 0 &&
-                    ( ret = mpi_miller_rabin(  X, rounds, f_rng, p_rng  ) )
-                                                                    == 0 &&
-                    ( ret = mpi_miller_rabin( &Y, rounds, f_rng, p_rng  ) )
-                                                                    == 0 )
-                    goto cleanup;
-
-                if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
-                    goto cleanup;
-
-                /*
-                 * Next candidates. We want to preserve Y = (X-1) / 2 and
-                 * Y = 1 mod 2 and Y = 2 mod 3 (eq X = 3 mod 4 and X = 2 mod 3)
-                 * so up Y by 6 and X by 12.
-                 */
-                MBEDTLS_MPI_CHK( mbedtls_mpi_add_int(  X,  X, 12 ) );
-                MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &Y, &Y, 6  ) );
-            }
-        }
-    }
-
-cleanup:
-
-    mbedtls_mpi_free( &Y );
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_GENPRIME */
-
-#if defined(MBEDTLS_SELF_TEST)
-
-#define GCD_PAIR_COUNT  3
-
-static const int gcd_pairs[GCD_PAIR_COUNT][3] =
-{
-    { 693, 609, 21 },
-    { 1764, 868, 28 },
-    { 768454923, 542167814, 1 }
-};
-
-/*
- * Checkup routine
- */
-int mbedtls_mpi_self_test( int verbose )
-{
-    int ret, i;
-    mbedtls_mpi A, E, N, X, Y, U, V;
-
-    mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N ); mbedtls_mpi_init( &X );
-    mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &U ); mbedtls_mpi_init( &V );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &A, 16,
-        "EFE021C2645FD1DC586E69184AF4A31E" \
-        "D5F53E93B5F123FA41680867BA110131" \
-        "944FE7952E2517337780CB0DB80E61AA" \
-        "E7C8DDC6C5C6AADEB34EB38A2F40D5E6" ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &E, 16,
-        "B2E7EFD37075B9F03FF989C7C5051C20" \
-        "34D2A323810251127E7BF8625A4F49A5" \
-        "F3E27F4DA8BD59C47D6DAABA4C8127BD" \
-        "5B5C25763222FEFCCFC38B832366C29E" ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &N, 16,
-        "0066A198186C18C10B2F5ED9B522752A" \
-        "9830B69916E535C8F047518A889A43A5" \
-        "94B6BED27A168D31D4A52F88925AA8F5" ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X, &A, &N ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
-        "602AB7ECA597A3D6B56FF9829A5E8B85" \
-        "9E857EA95A03512E2BAE7391688D264A" \
-        "A5663B0341DB9CCFD2C4C5F421FEC814" \
-        "8001B72E848A38CAE1C65F78E56ABDEF" \
-        "E12D3C039B8A02D6BE593F0BBBDA56F1" \
-        "ECF677152EF804370C1A305CAF3B5BF1" \
-        "30879B56C61DE584A0F53A2447A51E" ) );
-
-    if( verbose != 0 )
-        mbedtls_printf( "  MPI test #1 (mul_mpi): " );
-
-    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &X, &Y, &A, &N ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
-        "256567336059E52CAE22925474705F39A94" ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &V, 16,
-        "6613F26162223DF488E9CD48CC132C7A" \
-        "0AC93C701B001B092E4E5B9F73BCD27B" \
-        "9EE50D0657C77F374E903CDFA4C642" ) );
-
-    if( verbose != 0 )
-        mbedtls_printf( "  MPI test #2 (div_mpi): " );
-
-    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 ||
-        mbedtls_mpi_cmp_mpi( &Y, &V ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &X, &A, &E, &N, NULL ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
-        "36E139AEA55215609D2816998ED020BB" \
-        "BD96C37890F65171D948E9BC7CBAA4D9" \
-        "325D24D6A3C12710F10A09FA08AB87" ) );
-
-    if( verbose != 0 )
-        mbedtls_printf( "  MPI test #3 (exp_mod): " );
-
-    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &X, &A, &N ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
-        "003A0AAEDD7E784FC07D8F9EC6E3BFD5" \
-        "C3DBA76456363A10869622EAC2DD84EC" \
-        "C5B8A74DAC4D09E03B5E0BE779F2DF61" ) );
-
-    if( verbose != 0 )
-        mbedtls_printf( "  MPI test #4 (inv_mod): " );
-
-    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-
-    if( verbose != 0 )
-        mbedtls_printf( "  MPI test #5 (simple gcd): " );
-
-    for( i = 0; i < GCD_PAIR_COUNT; i++ )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &X, gcd_pairs[i][0] ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Y, gcd_pairs[i][1] ) );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &A, &X, &Y ) );
-
-        if( mbedtls_mpi_cmp_int( &A, gcd_pairs[i][2] ) != 0 )
-        {
-            if( verbose != 0 )
-                mbedtls_printf( "failed at %d\n", i );
-
-            ret = 1;
-            goto cleanup;
-        }
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-
-cleanup:
-
-    if( ret != 0 && verbose != 0 )
-        mbedtls_printf( "Unexpected error, return code = %08X\n", (unsigned int) ret );
-
-    mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N ); mbedtls_mpi_free( &X );
-    mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &U ); mbedtls_mpi_free( &V );
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_BIGNUM_C */
diff --git a/src/duckdb/third_party/mbedtls/library/bn_mul.h b/src/duckdb/third_party/mbedtls/library/bn_mul.h
deleted file mode 100644
index b71ddd881..000000000
--- a/src/duckdb/third_party/mbedtls/library/bn_mul.h
+++ /dev/null
@@ -1,974 +0,0 @@
-/**
- * \file bn_mul.h
- *
- * \brief Multi-precision integer library
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-/*
- *      Multiply source vector [s] with b, add result
- *       to destination vector [d] and set carry c.
- *
- *      Currently supports:
- *
- *         . IA-32 (386+)         . AMD64 / EM64T
- *         . IA-32 (SSE2)         . Motorola 68000
- *         . PowerPC, 32-bit      . MicroBlaze
- *         . PowerPC, 64-bit      . TriCore
- *         . SPARC v8             . ARM v3+
- *         . Alpha                . MIPS32
- *         . C, longlong          . C, generic
- */
-#ifndef MBEDTLS_BN_MUL_H
-#define MBEDTLS_BN_MUL_H
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/bignum.h"
-
-
-/*
- * Conversion macros for embedded constants:
- * build lists of mbedtls_mpi_uint's from lists of unsigned char's grouped by 8, 4 or 2
- */
-#if defined(MBEDTLS_HAVE_INT32)
-
-#define MBEDTLS_BYTES_TO_T_UINT_4( a, b, c, d )               \
-    ( (mbedtls_mpi_uint) (a) <<  0 ) |                        \
-    ( (mbedtls_mpi_uint) (b) <<  8 ) |                        \
-    ( (mbedtls_mpi_uint) (c) << 16 ) |                        \
-    ( (mbedtls_mpi_uint) (d) << 24 )
-
-#define MBEDTLS_BYTES_TO_T_UINT_2( a, b )                   \
-    MBEDTLS_BYTES_TO_T_UINT_4( a, b, 0, 0 )
-
-#define MBEDTLS_BYTES_TO_T_UINT_8( a, b, c, d, e, f, g, h ) \
-    MBEDTLS_BYTES_TO_T_UINT_4( a, b, c, d ),                \
-    MBEDTLS_BYTES_TO_T_UINT_4( e, f, g, h )
-
-#else /* 64-bits */
-
-#define MBEDTLS_BYTES_TO_T_UINT_8( a, b, c, d, e, f, g, h )   \
-    ( (mbedtls_mpi_uint) (a) <<  0 ) |                        \
-    ( (mbedtls_mpi_uint) (b) <<  8 ) |                        \
-    ( (mbedtls_mpi_uint) (c) << 16 ) |                        \
-    ( (mbedtls_mpi_uint) (d) << 24 ) |                        \
-    ( (mbedtls_mpi_uint) (e) << 32 ) |                        \
-    ( (mbedtls_mpi_uint) (f) << 40 ) |                        \
-    ( (mbedtls_mpi_uint) (g) << 48 ) |                        \
-    ( (mbedtls_mpi_uint) (h) << 56 )
-
-#define MBEDTLS_BYTES_TO_T_UINT_4( a, b, c, d )             \
-    MBEDTLS_BYTES_TO_T_UINT_8( a, b, c, d, 0, 0, 0, 0 )
-
-#define MBEDTLS_BYTES_TO_T_UINT_2( a, b )                   \
-    MBEDTLS_BYTES_TO_T_UINT_8( a, b, 0, 0, 0, 0, 0, 0 )
-
-#endif /* bits in mbedtls_mpi_uint */
-
-#if defined(MBEDTLS_HAVE_ASM)
-
-#ifndef asm
-#define asm __asm
-#endif
-
-/* armcc5 --gnu defines __GNUC__ but doesn't support GNU's extended asm */
-#if defined(__GNUC__) && \
-    ( !defined(__ARMCC_VERSION) || __ARMCC_VERSION >= 6000000 )
-
-/*
- * Disable use of the i386 assembly code below if option -O0, to disable all
- * compiler optimisations, is passed, detected with __OPTIMIZE__
- * This is done as the number of registers used in the assembly code doesn't
- * work with the -O0 option.
- */
-#if defined(__i386__) && defined(__OPTIMIZE__)
-
-#define MULADDC_INIT                        \
-    asm(                                    \
-        "movl   %%ebx, %0           \n\t"   \
-        "movl   %5, %%esi           \n\t"   \
-        "movl   %6, %%edi           \n\t"   \
-        "movl   %7, %%ecx           \n\t"   \
-        "movl   %8, %%ebx           \n\t"
-
-#define MULADDC_CORE                        \
-        "lodsl                      \n\t"   \
-        "mull   %%ebx               \n\t"   \
-        "addl   %%ecx,   %%eax      \n\t"   \
-        "adcl   $0,      %%edx      \n\t"   \
-        "addl   (%%edi), %%eax      \n\t"   \
-        "adcl   $0,      %%edx      \n\t"   \
-        "movl   %%edx,   %%ecx      \n\t"   \
-        "stosl                      \n\t"
-
-#if defined(MBEDTLS_HAVE_SSE2)
-
-#define MULADDC_HUIT                            \
-        "movd     %%ecx,     %%mm1      \n\t"   \
-        "movd     %%ebx,     %%mm0      \n\t"   \
-        "movd     (%%edi),   %%mm3      \n\t"   \
-        "paddq    %%mm3,     %%mm1      \n\t"   \
-        "movd     (%%esi),   %%mm2      \n\t"   \
-        "pmuludq  %%mm0,     %%mm2      \n\t"   \
-        "movd     4(%%esi),  %%mm4      \n\t"   \
-        "pmuludq  %%mm0,     %%mm4      \n\t"   \
-        "movd     8(%%esi),  %%mm6      \n\t"   \
-        "pmuludq  %%mm0,     %%mm6      \n\t"   \
-        "movd     12(%%esi), %%mm7      \n\t"   \
-        "pmuludq  %%mm0,     %%mm7      \n\t"   \
-        "paddq    %%mm2,     %%mm1      \n\t"   \
-        "movd     4(%%edi),  %%mm3      \n\t"   \
-        "paddq    %%mm4,     %%mm3      \n\t"   \
-        "movd     8(%%edi),  %%mm5      \n\t"   \
-        "paddq    %%mm6,     %%mm5      \n\t"   \
-        "movd     12(%%edi), %%mm4      \n\t"   \
-        "paddq    %%mm4,     %%mm7      \n\t"   \
-        "movd     %%mm1,     (%%edi)    \n\t"   \
-        "movd     16(%%esi), %%mm2      \n\t"   \
-        "pmuludq  %%mm0,     %%mm2      \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "movd     20(%%esi), %%mm4      \n\t"   \
-        "pmuludq  %%mm0,     %%mm4      \n\t"   \
-        "paddq    %%mm3,     %%mm1      \n\t"   \
-        "movd     24(%%esi), %%mm6      \n\t"   \
-        "pmuludq  %%mm0,     %%mm6      \n\t"   \
-        "movd     %%mm1,     4(%%edi)   \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "movd     28(%%esi), %%mm3      \n\t"   \
-        "pmuludq  %%mm0,     %%mm3      \n\t"   \
-        "paddq    %%mm5,     %%mm1      \n\t"   \
-        "movd     16(%%edi), %%mm5      \n\t"   \
-        "paddq    %%mm5,     %%mm2      \n\t"   \
-        "movd     %%mm1,     8(%%edi)   \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "paddq    %%mm7,     %%mm1      \n\t"   \
-        "movd     20(%%edi), %%mm5      \n\t"   \
-        "paddq    %%mm5,     %%mm4      \n\t"   \
-        "movd     %%mm1,     12(%%edi)  \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "paddq    %%mm2,     %%mm1      \n\t"   \
-        "movd     24(%%edi), %%mm5      \n\t"   \
-        "paddq    %%mm5,     %%mm6      \n\t"   \
-        "movd     %%mm1,     16(%%edi)  \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "paddq    %%mm4,     %%mm1      \n\t"   \
-        "movd     28(%%edi), %%mm5      \n\t"   \
-        "paddq    %%mm5,     %%mm3      \n\t"   \
-        "movd     %%mm1,     20(%%edi)  \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "paddq    %%mm6,     %%mm1      \n\t"   \
-        "movd     %%mm1,     24(%%edi)  \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "paddq    %%mm3,     %%mm1      \n\t"   \
-        "movd     %%mm1,     28(%%edi)  \n\t"   \
-        "addl     $32,       %%edi      \n\t"   \
-        "addl     $32,       %%esi      \n\t"   \
-        "psrlq    $32,       %%mm1      \n\t"   \
-        "movd     %%mm1,     %%ecx      \n\t"
-
-#define MULADDC_STOP                    \
-        "emms                   \n\t"   \
-        "movl   %4, %%ebx       \n\t"   \
-        "movl   %%ecx, %1       \n\t"   \
-        "movl   %%edi, %2       \n\t"   \
-        "movl   %%esi, %3       \n\t"   \
-        : "=m" (t), "=m" (c), "=m" (d), "=m" (s)        \
-        : "m" (t), "m" (s), "m" (d), "m" (c), "m" (b)   \
-        : "eax", "ebx", "ecx", "edx", "esi", "edi"      \
-    );
-
-#else
-
-#define MULADDC_STOP                    \
-        "movl   %4, %%ebx       \n\t"   \
-        "movl   %%ecx, %1       \n\t"   \
-        "movl   %%edi, %2       \n\t"   \
-        "movl   %%esi, %3       \n\t"   \
-        : "=m" (t), "=m" (c), "=m" (d), "=m" (s)        \
-        : "m" (t), "m" (s), "m" (d), "m" (c), "m" (b)   \
-        : "eax", "ebx", "ecx", "edx", "esi", "edi"      \
-    );
-#endif /* SSE2 */
-#endif /* i386 */
-
-#if defined(__amd64__) || defined (__x86_64__)
-
-#define MULADDC_INIT                        \
-    asm(                                    \
-        "xorq   %%r8, %%r8\n"
-
-#define MULADDC_CORE                        \
-        "movq   (%%rsi), %%rax\n"           \
-        "mulq   %%rbx\n"                    \
-        "addq   $8, %%rsi\n"                \
-        "addq   %%rcx, %%rax\n"             \
-        "movq   %%r8, %%rcx\n"              \
-        "adcq   $0, %%rdx\n"                \
-        "nop    \n"                         \
-        "addq   %%rax, (%%rdi)\n"           \
-        "adcq   %%rdx, %%rcx\n"             \
-        "addq   $8, %%rdi\n"
-
-#define MULADDC_STOP                                                 \
-        : "+c" (c), "+D" (d), "+S" (s), "+m" (*(uint64_t (*)[16]) d) \
-        : "b" (b), "m" (*(const uint64_t (*)[16]) s)                 \
-        : "rax", "rdx", "r8"                                         \
-    );
-
-#endif /* AMD64 */
-
-#if defined(__aarch64__)
-
-#define MULADDC_INIT                \
-    asm(
-
-#define MULADDC_CORE                \
-        "ldr x4, [%2], #8   \n\t"   \
-        "ldr x5, [%1]       \n\t"   \
-        "mul x6, x4, %4     \n\t"   \
-        "umulh x7, x4, %4   \n\t"   \
-        "adds x5, x5, x6    \n\t"   \
-        "adc x7, x7, xzr    \n\t"   \
-        "adds x5, x5, %0    \n\t"   \
-        "adc %0, x7, xzr    \n\t"   \
-        "str x5, [%1], #8   \n\t"
-
-#define MULADDC_STOP                                                    \
-         : "+r" (c),  "+r" (d), "+r" (s), "+m" (*(uint64_t (*)[16]) d)  \
-         : "r" (b), "m" (*(const uint64_t (*)[16]) s)                   \
-         : "x4", "x5", "x6", "x7", "cc"                                 \
-    );
-
-#endif /* Aarch64 */
-
-#if defined(__mc68020__) || defined(__mcpu32__)
-
-#define MULADDC_INIT                    \
-    asm(                                \
-        "movl   %3, %%a2        \n\t"   \
-        "movl   %4, %%a3        \n\t"   \
-        "movl   %5, %%d3        \n\t"   \
-        "movl   %6, %%d2        \n\t"   \
-        "moveq  #0, %%d0        \n\t"
-
-#define MULADDC_CORE                    \
-        "movel  %%a2@+, %%d1    \n\t"   \
-        "mulul  %%d2, %%d4:%%d1 \n\t"   \
-        "addl   %%d3, %%d1      \n\t"   \
-        "addxl  %%d0, %%d4      \n\t"   \
-        "moveq  #0,   %%d3      \n\t"   \
-        "addl   %%d1, %%a3@+    \n\t"   \
-        "addxl  %%d4, %%d3      \n\t"
-
-#define MULADDC_STOP                    \
-        "movl   %%d3, %0        \n\t"   \
-        "movl   %%a3, %1        \n\t"   \
-        "movl   %%a2, %2        \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "d0", "d1", "d2", "d3", "d4", "a2", "a3"  \
-    );
-
-#define MULADDC_HUIT                        \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d4:%%d1  \n\t"   \
-        "addxl  %%d3,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d4       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d3:%%d1  \n\t"   \
-        "addxl  %%d4,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d3       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d4:%%d1  \n\t"   \
-        "addxl  %%d3,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d4       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d3:%%d1  \n\t"   \
-        "addxl  %%d4,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d3       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d4:%%d1  \n\t"   \
-        "addxl  %%d3,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d4       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d3:%%d1  \n\t"   \
-        "addxl  %%d4,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d3       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d4:%%d1  \n\t"   \
-        "addxl  %%d3,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d4       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "movel  %%a2@+,  %%d1       \n\t"   \
-        "mulul  %%d2,    %%d3:%%d1  \n\t"   \
-        "addxl  %%d4,    %%d1       \n\t"   \
-        "addxl  %%d0,    %%d3       \n\t"   \
-        "addl   %%d1,    %%a3@+     \n\t"   \
-        "addxl  %%d0,    %%d3       \n\t"
-
-#endif /* MC68000 */
-
-#if defined(__powerpc64__) || defined(__ppc64__)
-
-#if defined(__MACH__) && defined(__APPLE__)
-
-#define MULADDC_INIT                        \
-    asm(                                    \
-        "ld     r3, %3              \n\t"   \
-        "ld     r4, %4              \n\t"   \
-        "ld     r5, %5              \n\t"   \
-        "ld     r6, %6              \n\t"   \
-        "addi   r3, r3, -8          \n\t"   \
-        "addi   r4, r4, -8          \n\t"   \
-        "addic  r5, r5,  0          \n\t"
-
-#define MULADDC_CORE                        \
-        "ldu    r7, 8(r3)           \n\t"   \
-        "mulld  r8, r7, r6          \n\t"   \
-        "mulhdu r9, r7, r6          \n\t"   \
-        "adde   r8, r8, r5          \n\t"   \
-        "ld     r7, 8(r4)           \n\t"   \
-        "addze  r5, r9              \n\t"   \
-        "addc   r8, r8, r7          \n\t"   \
-        "stdu   r8, 8(r4)           \n\t"
-
-#define MULADDC_STOP                        \
-        "addze  r5, r5              \n\t"   \
-        "addi   r4, r4, 8           \n\t"   \
-        "addi   r3, r3, 8           \n\t"   \
-        "std    r5, %0              \n\t"   \
-        "std    r4, %1              \n\t"   \
-        "std    r3, %2              \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
-    );
-
-
-#else /* __MACH__ && __APPLE__ */
-
-#define MULADDC_INIT                        \
-    asm(                                    \
-        "ld     %%r3, %3            \n\t"   \
-        "ld     %%r4, %4            \n\t"   \
-        "ld     %%r5, %5            \n\t"   \
-        "ld     %%r6, %6            \n\t"   \
-        "addi   %%r3, %%r3, -8      \n\t"   \
-        "addi   %%r4, %%r4, -8      \n\t"   \
-        "addic  %%r5, %%r5,  0      \n\t"
-
-#define MULADDC_CORE                        \
-        "ldu    %%r7, 8(%%r3)       \n\t"   \
-        "mulld  %%r8, %%r7, %%r6    \n\t"   \
-        "mulhdu %%r9, %%r7, %%r6    \n\t"   \
-        "adde   %%r8, %%r8, %%r5    \n\t"   \
-        "ld     %%r7, 8(%%r4)       \n\t"   \
-        "addze  %%r5, %%r9          \n\t"   \
-        "addc   %%r8, %%r8, %%r7    \n\t"   \
-        "stdu   %%r8, 8(%%r4)       \n\t"
-
-#define MULADDC_STOP                        \
-        "addze  %%r5, %%r5          \n\t"   \
-        "addi   %%r4, %%r4, 8       \n\t"   \
-        "addi   %%r3, %%r3, 8       \n\t"   \
-        "std    %%r5, %0            \n\t"   \
-        "std    %%r4, %1            \n\t"   \
-        "std    %%r3, %2            \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
-    );
-
-#endif /* __MACH__ && __APPLE__ */
-
-#elif defined(__powerpc__) || defined(__ppc__) /* end PPC64/begin PPC32  */
-
-#if defined(__MACH__) && defined(__APPLE__)
-
-#define MULADDC_INIT                    \
-    asm(                                \
-        "lwz    r3, %3          \n\t"   \
-        "lwz    r4, %4          \n\t"   \
-        "lwz    r5, %5          \n\t"   \
-        "lwz    r6, %6          \n\t"   \
-        "addi   r3, r3, -4      \n\t"   \
-        "addi   r4, r4, -4      \n\t"   \
-        "addic  r5, r5,  0      \n\t"
-
-#define MULADDC_CORE                    \
-        "lwzu   r7, 4(r3)       \n\t"   \
-        "mullw  r8, r7, r6      \n\t"   \
-        "mulhwu r9, r7, r6      \n\t"   \
-        "adde   r8, r8, r5      \n\t"   \
-        "lwz    r7, 4(r4)       \n\t"   \
-        "addze  r5, r9          \n\t"   \
-        "addc   r8, r8, r7      \n\t"   \
-        "stwu   r8, 4(r4)       \n\t"
-
-#define MULADDC_STOP                    \
-        "addze  r5, r5          \n\t"   \
-        "addi   r4, r4, 4       \n\t"   \
-        "addi   r3, r3, 4       \n\t"   \
-        "stw    r5, %0          \n\t"   \
-        "stw    r4, %1          \n\t"   \
-        "stw    r3, %2          \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
-    );
-
-#else /* __MACH__ && __APPLE__ */
-
-#define MULADDC_INIT                        \
-    asm(                                    \
-        "lwz    %%r3, %3            \n\t"   \
-        "lwz    %%r4, %4            \n\t"   \
-        "lwz    %%r5, %5            \n\t"   \
-        "lwz    %%r6, %6            \n\t"   \
-        "addi   %%r3, %%r3, -4      \n\t"   \
-        "addi   %%r4, %%r4, -4      \n\t"   \
-        "addic  %%r5, %%r5,  0      \n\t"
-
-#define MULADDC_CORE                        \
-        "lwzu   %%r7, 4(%%r3)       \n\t"   \
-        "mullw  %%r8, %%r7, %%r6    \n\t"   \
-        "mulhwu %%r9, %%r7, %%r6    \n\t"   \
-        "adde   %%r8, %%r8, %%r5    \n\t"   \
-        "lwz    %%r7, 4(%%r4)       \n\t"   \
-        "addze  %%r5, %%r9          \n\t"   \
-        "addc   %%r8, %%r8, %%r7    \n\t"   \
-        "stwu   %%r8, 4(%%r4)       \n\t"
-
-#define MULADDC_STOP                        \
-        "addze  %%r5, %%r5          \n\t"   \
-        "addi   %%r4, %%r4, 4       \n\t"   \
-        "addi   %%r3, %%r3, 4       \n\t"   \
-        "stw    %%r5, %0            \n\t"   \
-        "stw    %%r4, %1            \n\t"   \
-        "stw    %%r3, %2            \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
-    );
-
-#endif /* __MACH__ && __APPLE__ */
-
-#endif /* PPC32 */
-
-/*
- * The Sparc(64) assembly is reported to be broken.
- * Disable it for now, until we're able to fix it.
- */
-#if 0 && defined(__sparc__)
-#if defined(__sparc64__)
-
-#define MULADDC_INIT                                    \
-    asm(                                                \
-                "ldx     %3, %%o0               \n\t"   \
-                "ldx     %4, %%o1               \n\t"   \
-                "ld      %5, %%o2               \n\t"   \
-                "ld      %6, %%o3               \n\t"
-
-#define MULADDC_CORE                                    \
-                "ld      [%%o0], %%o4           \n\t"   \
-                "inc     4, %%o0                \n\t"   \
-                "ld      [%%o1], %%o5           \n\t"   \
-                "umul    %%o3, %%o4, %%o4       \n\t"   \
-                "addcc   %%o4, %%o2, %%o4       \n\t"   \
-                "rd      %%y, %%g1              \n\t"   \
-                "addx    %%g1, 0, %%g1          \n\t"   \
-                "addcc   %%o4, %%o5, %%o4       \n\t"   \
-                "st      %%o4, [%%o1]           \n\t"   \
-                "addx    %%g1, 0, %%o2          \n\t"   \
-                "inc     4, %%o1                \n\t"
-
-        #define MULADDC_STOP                            \
-                "st      %%o2, %0               \n\t"   \
-                "stx     %%o1, %1               \n\t"   \
-                "stx     %%o0, %2               \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)          \
-        : "m" (s), "m" (d), "m" (c), "m" (b)    \
-        : "g1", "o0", "o1", "o2", "o3", "o4",   \
-          "o5"                                  \
-        );
-
-#else /* __sparc64__ */
-
-#define MULADDC_INIT                                    \
-    asm(                                                \
-                "ld      %3, %%o0               \n\t"   \
-                "ld      %4, %%o1               \n\t"   \
-                "ld      %5, %%o2               \n\t"   \
-                "ld      %6, %%o3               \n\t"
-
-#define MULADDC_CORE                                    \
-                "ld      [%%o0], %%o4           \n\t"   \
-                "inc     4, %%o0                \n\t"   \
-                "ld      [%%o1], %%o5           \n\t"   \
-                "umul    %%o3, %%o4, %%o4       \n\t"   \
-                "addcc   %%o4, %%o2, %%o4       \n\t"   \
-                "rd      %%y, %%g1              \n\t"   \
-                "addx    %%g1, 0, %%g1          \n\t"   \
-                "addcc   %%o4, %%o5, %%o4       \n\t"   \
-                "st      %%o4, [%%o1]           \n\t"   \
-                "addx    %%g1, 0, %%o2          \n\t"   \
-                "inc     4, %%o1                \n\t"
-
-#define MULADDC_STOP                                    \
-                "st      %%o2, %0               \n\t"   \
-                "st      %%o1, %1               \n\t"   \
-                "st      %%o0, %2               \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)          \
-        : "m" (s), "m" (d), "m" (c), "m" (b)    \
-        : "g1", "o0", "o1", "o2", "o3", "o4",   \
-          "o5"                                  \
-        );
-
-#endif /* __sparc64__ */
-#endif /* __sparc__ */
-
-#if defined(__microblaze__) || defined(microblaze)
-
-#define MULADDC_INIT                    \
-    asm(                                \
-        "lwi   r3,   %3         \n\t"   \
-        "lwi   r4,   %4         \n\t"   \
-        "lwi   r5,   %5         \n\t"   \
-        "lwi   r6,   %6         \n\t"   \
-        "andi  r7,   r6, 0xffff \n\t"   \
-        "bsrli r6,   r6, 16     \n\t"
-
-#define MULADDC_CORE                    \
-        "lhui  r8,   r3,   0    \n\t"   \
-        "addi  r3,   r3,   2    \n\t"   \
-        "lhui  r9,   r3,   0    \n\t"   \
-        "addi  r3,   r3,   2    \n\t"   \
-        "mul   r10,  r9,  r6    \n\t"   \
-        "mul   r11,  r8,  r7    \n\t"   \
-        "mul   r12,  r9,  r7    \n\t"   \
-        "mul   r13,  r8,  r6    \n\t"   \
-        "bsrli  r8, r10,  16    \n\t"   \
-        "bsrli  r9, r11,  16    \n\t"   \
-        "add   r13, r13,  r8    \n\t"   \
-        "add   r13, r13,  r9    \n\t"   \
-        "bslli r10, r10,  16    \n\t"   \
-        "bslli r11, r11,  16    \n\t"   \
-        "add   r12, r12, r10    \n\t"   \
-        "addc  r13, r13,  r0    \n\t"   \
-        "add   r12, r12, r11    \n\t"   \
-        "addc  r13, r13,  r0    \n\t"   \
-        "lwi   r10,  r4,   0    \n\t"   \
-        "add   r12, r12, r10    \n\t"   \
-        "addc  r13, r13,  r0    \n\t"   \
-        "add   r12, r12,  r5    \n\t"   \
-        "addc   r5, r13,  r0    \n\t"   \
-        "swi   r12,  r4,   0    \n\t"   \
-        "addi   r4,  r4,   4    \n\t"
-
-#define MULADDC_STOP                    \
-        "swi   r5,   %0         \n\t"   \
-        "swi   r4,   %1         \n\t"   \
-        "swi   r3,   %2         \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "r3", "r4", "r5", "r6", "r7", "r8",       \
-          "r9", "r10", "r11", "r12", "r13"          \
-    );
-
-#endif /* MicroBlaze */
-
-#if defined(__tricore__)
-
-#define MULADDC_INIT                            \
-    asm(                                        \
-        "ld.a   %%a2, %3                \n\t"   \
-        "ld.a   %%a3, %4                \n\t"   \
-        "ld.w   %%d4, %5                \n\t"   \
-        "ld.w   %%d1, %6                \n\t"   \
-        "xor    %%d5, %%d5              \n\t"
-
-#define MULADDC_CORE                            \
-        "ld.w   %%d0,   [%%a2+]         \n\t"   \
-        "madd.u %%e2, %%e4, %%d0, %%d1  \n\t"   \
-        "ld.w   %%d0,   [%%a3]          \n\t"   \
-        "addx   %%d2,    %%d2,  %%d0    \n\t"   \
-        "addc   %%d3,    %%d3,    0     \n\t"   \
-        "mov    %%d4,    %%d3           \n\t"   \
-        "st.w  [%%a3+],  %%d2           \n\t"
-
-#define MULADDC_STOP                            \
-        "st.w   %0, %%d4                \n\t"   \
-        "st.a   %1, %%a3                \n\t"   \
-        "st.a   %2, %%a2                \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)          \
-        : "m" (s), "m" (d), "m" (c), "m" (b)    \
-        : "d0", "d1", "e2", "d4", "a2", "a3"    \
-    );
-
-#endif /* TriCore */
-
-/*
- * Note, gcc -O0 by default uses r7 for the frame pointer, so it complains about
- * our use of r7 below, unless -fomit-frame-pointer is passed.
- *
- * On the other hand, -fomit-frame-pointer is implied by any -Ox options with
- * x !=0, which we can detect using __OPTIMIZE__ (which is also defined by
- * clang and armcc5 under the same conditions).
- *
- * So, only use the optimized assembly below for optimized build, which avoids
- * the build error and is pretty reasonable anyway.
- */
-#if defined(__GNUC__) && !defined(__OPTIMIZE__)
-#define MULADDC_CANNOT_USE_R7
-#endif
-
-#if defined(__arm__) && !defined(MULADDC_CANNOT_USE_R7)
-
-#if defined(__thumb__) && !defined(__thumb2__)
-
-#define MULADDC_INIT                                    \
-    asm(                                                \
-            "ldr    r0, %3                      \n\t"   \
-            "ldr    r1, %4                      \n\t"   \
-            "ldr    r2, %5                      \n\t"   \
-            "ldr    r3, %6                      \n\t"   \
-            "lsr    r7, r3, #16                 \n\t"   \
-            "mov    r9, r7                      \n\t"   \
-            "lsl    r7, r3, #16                 \n\t"   \
-            "lsr    r7, r7, #16                 \n\t"   \
-            "mov    r8, r7                      \n\t"
-
-#define MULADDC_CORE                                    \
-            "ldmia  r0!, {r6}                   \n\t"   \
-            "lsr    r7, r6, #16                 \n\t"   \
-            "lsl    r6, r6, #16                 \n\t"   \
-            "lsr    r6, r6, #16                 \n\t"   \
-            "mov    r4, r8                      \n\t"   \
-            "mul    r4, r6                      \n\t"   \
-            "mov    r3, r9                      \n\t"   \
-            "mul    r6, r3                      \n\t"   \
-            "mov    r5, r9                      \n\t"   \
-            "mul    r5, r7                      \n\t"   \
-            "mov    r3, r8                      \n\t"   \
-            "mul    r7, r3                      \n\t"   \
-            "lsr    r3, r6, #16                 \n\t"   \
-            "add    r5, r5, r3                  \n\t"   \
-            "lsr    r3, r7, #16                 \n\t"   \
-            "add    r5, r5, r3                  \n\t"   \
-            "add    r4, r4, r2                  \n\t"   \
-            "mov    r2, #0                      \n\t"   \
-            "adc    r5, r2                      \n\t"   \
-            "lsl    r3, r6, #16                 \n\t"   \
-            "add    r4, r4, r3                  \n\t"   \
-            "adc    r5, r2                      \n\t"   \
-            "lsl    r3, r7, #16                 \n\t"   \
-            "add    r4, r4, r3                  \n\t"   \
-            "adc    r5, r2                      \n\t"   \
-            "ldr    r3, [r1]                    \n\t"   \
-            "add    r4, r4, r3                  \n\t"   \
-            "adc    r2, r5                      \n\t"   \
-            "stmia  r1!, {r4}                   \n\t"
-
-#define MULADDC_STOP                                    \
-            "str    r2, %0                      \n\t"   \
-            "str    r1, %1                      \n\t"   \
-            "str    r0, %2                      \n\t"   \
-         : "=m" (c),  "=m" (d), "=m" (s)        \
-         : "m" (s), "m" (d), "m" (c), "m" (b)   \
-         : "r0", "r1", "r2", "r3", "r4", "r5",  \
-           "r6", "r7", "r8", "r9", "cc"         \
-         );
-
-#elif (__ARM_ARCH >= 6) && \
-    defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1)
-
-#define MULADDC_INIT                            \
-    asm(
-
-#define MULADDC_CORE                            \
-            "ldr    r0, [%0], #4        \n\t"   \
-            "ldr    r1, [%1]            \n\t"   \
-            "umaal  r1, %2, %3, r0      \n\t"   \
-            "str    r1, [%1], #4        \n\t"
-
-#define MULADDC_STOP                            \
-         : "=r" (s),  "=r" (d), "=r" (c)        \
-         : "r" (b), "0" (s), "1" (d), "2" (c)   \
-         : "r0", "r1", "memory"                 \
-         );
-
-#else
-
-#define MULADDC_INIT                                    \
-    asm(                                                \
-            "ldr    r0, %3                      \n\t"   \
-            "ldr    r1, %4                      \n\t"   \
-            "ldr    r2, %5                      \n\t"   \
-            "ldr    r3, %6                      \n\t"
-
-#define MULADDC_CORE                                    \
-            "ldr    r4, [r0], #4                \n\t"   \
-            "mov    r5, #0                      \n\t"   \
-            "ldr    r6, [r1]                    \n\t"   \
-            "umlal  r2, r5, r3, r4              \n\t"   \
-            "adds   r7, r6, r2                  \n\t"   \
-            "adc    r2, r5, #0                  \n\t"   \
-            "str    r7, [r1], #4                \n\t"
-
-#define MULADDC_STOP                                    \
-            "str    r2, %0                      \n\t"   \
-            "str    r1, %1                      \n\t"   \
-            "str    r0, %2                      \n\t"   \
-         : "=m" (c),  "=m" (d), "=m" (s)        \
-         : "m" (s), "m" (d), "m" (c), "m" (b)   \
-         : "r0", "r1", "r2", "r3", "r4", "r5",  \
-           "r6", "r7", "cc"                     \
-         );
-
-#endif /* Thumb */
-
-#endif /* ARMv3 */
-
-#if defined(__alpha__)
-
-#define MULADDC_INIT                    \
-    asm(                                \
-        "ldq    $1, %3          \n\t"   \
-        "ldq    $2, %4          \n\t"   \
-        "ldq    $3, %5          \n\t"   \
-        "ldq    $4, %6          \n\t"
-
-#define MULADDC_CORE                    \
-        "ldq    $6,  0($1)      \n\t"   \
-        "addq   $1,  8, $1      \n\t"   \
-        "mulq   $6, $4, $7      \n\t"   \
-        "umulh  $6, $4, $6      \n\t"   \
-        "addq   $7, $3, $7      \n\t"   \
-        "cmpult $7, $3, $3      \n\t"   \
-        "ldq    $5,  0($2)      \n\t"   \
-        "addq   $7, $5, $7      \n\t"   \
-        "cmpult $7, $5, $5      \n\t"   \
-        "stq    $7,  0($2)      \n\t"   \
-        "addq   $2,  8, $2      \n\t"   \
-        "addq   $6, $3, $3      \n\t"   \
-        "addq   $5, $3, $3      \n\t"
-
-#define MULADDC_STOP                                    \
-        "stq    $3, %0          \n\t"   \
-        "stq    $2, %1          \n\t"   \
-        "stq    $1, %2          \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)              \
-        : "m" (s), "m" (d), "m" (c), "m" (b)        \
-        : "$1", "$2", "$3", "$4", "$5", "$6", "$7"  \
-    );
-#endif /* Alpha */
-
-#if defined(__mips__) && !defined(__mips64)
-
-#define MULADDC_INIT                    \
-    asm(                                \
-        "lw     $10, %3         \n\t"   \
-        "lw     $11, %4         \n\t"   \
-        "lw     $12, %5         \n\t"   \
-        "lw     $13, %6         \n\t"
-
-#define MULADDC_CORE                    \
-        "lw     $14, 0($10)     \n\t"   \
-        "multu  $13, $14        \n\t"   \
-        "addi   $10, $10, 4     \n\t"   \
-        "mflo   $14             \n\t"   \
-        "mfhi   $9              \n\t"   \
-        "addu   $14, $12, $14   \n\t"   \
-        "lw     $15, 0($11)     \n\t"   \
-        "sltu   $12, $14, $12   \n\t"   \
-        "addu   $15, $14, $15   \n\t"   \
-        "sltu   $14, $15, $14   \n\t"   \
-        "addu   $12, $12, $9    \n\t"   \
-        "sw     $15, 0($11)     \n\t"   \
-        "addu   $12, $12, $14   \n\t"   \
-        "addi   $11, $11, 4     \n\t"
-
-#define MULADDC_STOP                    \
-        "sw     $12, %0         \n\t"   \
-        "sw     $11, %1         \n\t"   \
-        "sw     $10, %2         \n\t"   \
-        : "=m" (c), "=m" (d), "=m" (s)                      \
-        : "m" (s), "m" (d), "m" (c), "m" (b)                \
-        : "$9", "$10", "$11", "$12", "$13", "$14", "$15", "lo", "hi" \
-    );
-
-#endif /* MIPS */
-#endif /* GNUC */
-
-#if (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
-
-#define MULADDC_INIT                            \
-    __asm   mov     esi, s                      \
-    __asm   mov     edi, d                      \
-    __asm   mov     ecx, c                      \
-    __asm   mov     ebx, b
-
-#define MULADDC_CORE                            \
-    __asm   lodsd                               \
-    __asm   mul     ebx                         \
-    __asm   add     eax, ecx                    \
-    __asm   adc     edx, 0                      \
-    __asm   add     eax, [edi]                  \
-    __asm   adc     edx, 0                      \
-    __asm   mov     ecx, edx                    \
-    __asm   stosd
-
-#if defined(MBEDTLS_HAVE_SSE2)
-
-#define EMIT __asm _emit
-
-#define MULADDC_HUIT                            \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0xC9             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0xC3             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x1F             \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x16             \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xD0             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x66  EMIT 0x04  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xE0             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x76  EMIT 0x08  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xF0             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x7E  EMIT 0x0C  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xF8             \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCA             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x5F  EMIT 0x04  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xDC             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x08  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xEE             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x67  EMIT 0x0C  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xFC             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x0F             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x56  EMIT 0x10  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xD0             \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x66  EMIT 0x14  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xE0             \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x76  EMIT 0x18  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xF0             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x04  \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x5E  EMIT 0x1C  \
-    EMIT 0x0F  EMIT 0xF4  EMIT 0xD8             \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCD             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x10  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xD5             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x08  \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCF             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x14  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xE5             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x0C  \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCA             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x18  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xF5             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x10  \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCC             \
-    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x1C  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xDD             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x14  \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCE             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x18  \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x1C  \
-    EMIT 0x83  EMIT 0xC7  EMIT 0x20             \
-    EMIT 0x83  EMIT 0xC6  EMIT 0x20             \
-    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
-    EMIT 0x0F  EMIT 0x7E  EMIT 0xC9
-
-#define MULADDC_STOP                            \
-    EMIT 0x0F  EMIT 0x77                        \
-    __asm   mov     c, ecx                      \
-    __asm   mov     d, edi                      \
-    __asm   mov     s, esi                      \
-
-#else
-
-#define MULADDC_STOP                            \
-    __asm   mov     c, ecx                      \
-    __asm   mov     d, edi                      \
-    __asm   mov     s, esi                      \
-
-#endif /* SSE2 */
-#endif /* MSVC */
-
-#endif /* MBEDTLS_HAVE_ASM */
-
-#if !defined(MULADDC_CORE)
-#if defined(MBEDTLS_HAVE_UDBL)
-
-#define MULADDC_INIT                    \
-{                                       \
-    mbedtls_t_udbl r;                           \
-    mbedtls_mpi_uint r0, r1;
-
-#define MULADDC_CORE                    \
-    r   = *(s++) * (mbedtls_t_udbl) b;          \
-    r0  = (mbedtls_mpi_uint) r;                   \
-    r1  = (mbedtls_mpi_uint)( r >> biL );         \
-    r0 += c;  r1 += (r0 <  c);          \
-    r0 += *d; r1 += (r0 < *d);          \
-    c = r1; *(d++) = r0;
-
-#define MULADDC_STOP                    \
-}
-
-#else
-#define MULADDC_INIT                    \
-{                                       \
-    mbedtls_mpi_uint s0, s1, b0, b1;              \
-    mbedtls_mpi_uint r0, r1, rx, ry;              \
-    b0 = ( b << biH ) >> biH;           \
-    b1 = ( b >> biH );
-
-#define MULADDC_CORE                    \
-    s0 = ( *s << biH ) >> biH;          \
-    s1 = ( *s >> biH ); s++;            \
-    rx = s0 * b1; r0 = s0 * b0;         \
-    ry = s1 * b0; r1 = s1 * b1;         \
-    r1 += ( rx >> biH );                \
-    r1 += ( ry >> biH );                \
-    rx <<= biH; ry <<= biH;             \
-    r0 += rx; r1 += (r0 < rx);          \
-    r0 += ry; r1 += (r0 < ry);          \
-    r0 +=  c; r1 += (r0 <  c);          \
-    r0 += *d; r1 += (r0 < *d);          \
-    c = r1; *(d++) = r0;
-
-#define MULADDC_STOP                    \
-}
-
-#endif /* C (generic)  */
-#endif /* C (longlong) */
-
-#endif /* bn_mul.h */
diff --git a/src/duckdb/third_party/mbedtls/library/camellia.cpp b/src/duckdb/third_party/mbedtls/library/camellia.cpp
deleted file mode 100644
index 29d730ab5..000000000
--- a/src/duckdb/third_party/mbedtls/library/camellia.cpp
+++ /dev/null
@@ -1,1087 +0,0 @@
-/*
- *  Camellia implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-/*
- *  The Camellia block cipher was designed by NTT and Mitsubishi Electric
- *  Corporation.
- *
- *  http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/01espec.pdf
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_CAMELLIA_C)
-
-#include "mbedtls/camellia.h"
-#include "mbedtls/platform_util.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_SELF_TEST)
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#define mbedtls_printf printf
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#if !defined(MBEDTLS_CAMELLIA_ALT)
-
-/* Parameter validation macros */
-#define CAMELLIA_VALIDATE_RET( cond )                                       \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA )
-#define CAMELLIA_VALIDATE( cond )                                           \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-static const unsigned char SIGMA_CHARS[6][8] =
-{
-    { 0xa0, 0x9e, 0x66, 0x7f, 0x3b, 0xcc, 0x90, 0x8b },
-    { 0xb6, 0x7a, 0xe8, 0x58, 0x4c, 0xaa, 0x73, 0xb2 },
-    { 0xc6, 0xef, 0x37, 0x2f, 0xe9, 0x4f, 0x82, 0xbe },
-    { 0x54, 0xff, 0x53, 0xa5, 0xf1, 0xd3, 0x6f, 0x1c },
-    { 0x10, 0xe5, 0x27, 0xfa, 0xde, 0x68, 0x2d, 0x1d },
-    { 0xb0, 0x56, 0x88, 0xc2, 0xb3, 0xe6, 0xc1, 0xfd }
-};
-
-#if defined(MBEDTLS_CAMELLIA_SMALL_MEMORY)
-
-static const unsigned char FSb[256] =
-{
-    112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65,
-     35,239,107,147, 69, 25,165, 33,237, 14, 79, 78, 29,101,146,189,
-    134,184,175,143,124,235, 31,206, 62, 48,220, 95, 94,197, 11, 26,
-    166,225, 57,202,213, 71, 93, 61,217,  1, 90,214, 81, 86,108, 77,
-    139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153,
-    223, 76,203,194, 52,126,118,  5,109,183,169, 49,209, 23,  4,215,
-     20, 88, 58, 97,222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34,
-    254, 68,207,178,195,181,122,145, 36,  8,232,168, 96,252,105, 80,
-    170,208,160,125,161,137, 98,151, 84, 91, 30,149,224,255,100,210,
-     16,196,  0, 72,163,247,117,219,138,  3,230,218,  9, 63,221,148,
-    135, 92,131,  2,205, 74,144, 51,115,103,246,243,157,127,191,226,
-     82,155,216, 38,200, 55,198, 59,129,150,111, 75, 19,190, 99, 46,
-    233,121,167,140,159,110,188,142, 41,245,249,182, 47,253,180, 89,
-    120,152,  6,106,231, 70,113,186,212, 37,171, 66,136,162,141,250,
-    114,  7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164,
-     64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158
-};
-
-#define SBOX1(n) FSb[(n)]
-#define SBOX2(n) (unsigned char)((FSb[(n)] >> 7 ^ FSb[(n)] << 1) & 0xff)
-#define SBOX3(n) (unsigned char)((FSb[(n)] >> 1 ^ FSb[(n)] << 7) & 0xff)
-#define SBOX4(n) FSb[((n) << 1 ^ (n) >> 7) &0xff]
-
-#else /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
-
-static const unsigned char FSb[256] =
-{
- 112, 130,  44, 236, 179,  39, 192, 229, 228, 133,  87,  53, 234,  12, 174,  65,
-  35, 239, 107, 147,  69,  25, 165,  33, 237,  14,  79,  78,  29, 101, 146, 189,
- 134, 184, 175, 143, 124, 235,  31, 206,  62,  48, 220,  95,  94, 197,  11,  26,
- 166, 225,  57, 202, 213,  71,  93,  61, 217,   1,  90, 214,  81,  86, 108,  77,
- 139,  13, 154, 102, 251, 204, 176,  45, 116,  18,  43,  32, 240, 177, 132, 153,
- 223,  76, 203, 194,  52, 126, 118,   5, 109, 183, 169,  49, 209,  23,   4, 215,
-  20,  88,  58,  97, 222,  27,  17,  28,  50,  15, 156,  22,  83,  24, 242,  34,
- 254,  68, 207, 178, 195, 181, 122, 145,  36,   8, 232, 168,  96, 252, 105,  80,
- 170, 208, 160, 125, 161, 137,  98, 151,  84,  91,  30, 149, 224, 255, 100, 210,
-  16, 196,   0,  72, 163, 247, 117, 219, 138,   3, 230, 218,   9,  63, 221, 148,
- 135,  92, 131,   2, 205,  74, 144,  51, 115, 103, 246, 243, 157, 127, 191, 226,
-  82, 155, 216,  38, 200,  55, 198,  59, 129, 150, 111,  75,  19, 190,  99,  46,
- 233, 121, 167, 140, 159, 110, 188, 142,  41, 245, 249, 182,  47, 253, 180,  89,
- 120, 152,   6, 106, 231,  70, 113, 186, 212,  37, 171,  66, 136, 162, 141, 250,
- 114,   7, 185,  85, 248, 238, 172,  10,  54,  73,  42, 104,  60,  56, 241, 164,
- 64,  40, 211, 123, 187, 201,  67, 193,  21, 227, 173, 244, 119, 199, 128, 158
-};
-
-static const unsigned char FSb2[256] =
-{
- 224,   5,  88, 217, 103,  78, 129, 203, 201,  11, 174, 106, 213,  24,  93, 130,
-  70, 223, 214,  39, 138,  50,  75,  66, 219,  28, 158, 156,  58, 202,  37, 123,
-  13, 113,  95,  31, 248, 215,  62, 157, 124,  96, 185, 190, 188, 139,  22,  52,
-  77, 195, 114, 149, 171, 142, 186, 122, 179,   2, 180, 173, 162, 172, 216, 154,
-  23,  26,  53, 204, 247, 153,  97,  90, 232,  36,  86,  64, 225,  99,   9,  51,
- 191, 152, 151, 133, 104, 252, 236,  10, 218, 111,  83,  98, 163,  46,   8, 175,
-  40, 176, 116, 194, 189,  54,  34,  56, 100,  30,  57,  44, 166,  48, 229,  68,
- 253, 136, 159, 101, 135, 107, 244,  35,  72,  16, 209,  81, 192, 249, 210, 160,
-  85, 161,  65, 250,  67,  19, 196,  47, 168, 182,  60,  43, 193, 255, 200, 165,
-  32, 137,   0, 144,  71, 239, 234, 183,  21,   6, 205, 181,  18, 126, 187,  41,
-  15, 184,   7,   4, 155, 148,  33, 102, 230, 206, 237, 231,  59, 254, 127, 197,
- 164,  55, 177,  76, 145, 110, 141, 118,   3,  45, 222, 150,  38, 125, 198,  92,
- 211, 242,  79,  25,  63, 220, 121,  29,  82, 235, 243, 109,  94, 251, 105, 178,
- 240,  49,  12, 212, 207, 140, 226, 117, 169,  74,  87, 132,  17,  69,  27, 245,
- 228,  14, 115, 170, 241, 221,  89,  20, 108, 146,  84, 208, 120, 112, 227,  73,
- 128,  80, 167, 246, 119, 147, 134, 131,  42, 199,  91, 233, 238, 143,   1,  61
-};
-
-static const unsigned char FSb3[256] =
-{
-  56,  65,  22, 118, 217, 147,  96, 242, 114, 194, 171, 154, 117,   6,  87, 160,
- 145, 247, 181, 201, 162, 140, 210, 144, 246,   7, 167,  39, 142, 178,  73, 222,
-  67,  92, 215, 199,  62, 245, 143, 103,  31,  24, 110, 175,  47, 226, 133,  13,
-  83, 240, 156, 101, 234, 163, 174, 158, 236, 128,  45, 107, 168,  43,  54, 166,
- 197, 134,  77,  51, 253, 102,  88, 150,  58,   9, 149,  16, 120, 216,  66, 204,
- 239,  38, 229,  97,  26,  63,  59, 130, 182, 219, 212, 152, 232, 139,   2, 235,
-  10,  44,  29, 176, 111, 141, 136,  14,  25, 135,  78,  11, 169,  12, 121,  17,
- 127,  34, 231,  89, 225, 218,  61, 200,  18,   4, 116,  84,  48, 126, 180,  40,
-  85, 104,  80, 190, 208, 196,  49, 203,  42, 173,  15, 202, 112, 255,  50, 105,
-   8,  98,   0,  36, 209, 251, 186, 237,  69, 129, 115, 109, 132, 159, 238,  74,
- 195,  46, 193,   1, 230,  37,  72, 153, 185, 179, 123, 249, 206, 191, 223, 113,
-  41, 205, 108,  19, 100, 155,  99, 157, 192,  75, 183, 165, 137,  95, 177,  23,
- 244, 188, 211,  70, 207,  55,  94,  71, 148, 250, 252,  91, 151, 254,  90, 172,
-  60,  76,   3,  53, 243,  35, 184,  93, 106, 146, 213,  33,  68,  81, 198, 125,
-  57, 131, 220, 170, 124, 119,  86,   5,  27, 164,  21,  52,  30,  28, 248,  82,
-  32,  20, 233, 189, 221, 228, 161, 224, 138, 241, 214, 122, 187, 227,  64,  79
-};
-
-static const unsigned char FSb4[256] =
-{
- 112,  44, 179, 192, 228,  87, 234, 174,  35, 107,  69, 165, 237,  79,  29, 146,
- 134, 175, 124,  31,  62, 220,  94,  11, 166,  57, 213,  93, 217,  90,  81, 108,
- 139, 154, 251, 176, 116,  43, 240, 132, 223, 203,  52, 118, 109, 169, 209,   4,
-  20,  58, 222,  17,  50, 156,  83, 242, 254, 207, 195, 122,  36, 232,  96, 105,
- 170, 160, 161,  98,  84,  30, 224, 100,  16,   0, 163, 117, 138, 230,   9, 221,
- 135, 131, 205, 144, 115, 246, 157, 191,  82, 216, 200, 198, 129, 111,  19,  99,
- 233, 167, 159, 188,  41, 249,  47, 180, 120,   6, 231, 113, 212, 171, 136, 141,
- 114, 185, 248, 172,  54,  42,  60, 241,  64, 211, 187,  67,  21, 173, 119, 128,
- 130, 236,  39, 229, 133,  53,  12,  65, 239, 147,  25,  33,  14,  78, 101, 189,
- 184, 143, 235, 206,  48,  95, 197,  26, 225, 202,  71,  61,   1, 214,  86,  77,
-  13, 102, 204,  45,  18,  32, 177, 153,  76, 194, 126,   5, 183,  49,  23, 215,
-  88,  97,  27,  28,  15,  22,  24,  34,  68, 178, 181, 145,   8, 168, 252,  80,
- 208, 125, 137, 151,  91, 149, 255, 210, 196,  72, 247, 219,   3, 218,  63, 148,
-  92,   2,  74,  51, 103, 243, 127, 226, 155,  38,  55,  59, 150,  75, 190,  46,
- 121, 140, 110, 142, 245, 182, 253,  89, 152, 106,  70, 186,  37,  66, 162, 250,
-  7,  85, 238,  10,  73, 104,  56, 164,  40, 123, 201, 193, 227, 244, 199, 158
-};
-
-#define SBOX1(n) FSb[(n)]
-#define SBOX2(n) FSb2[(n)]
-#define SBOX3(n) FSb3[(n)]
-#define SBOX4(n) FSb4[(n)]
-
-#endif /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
-
-static const unsigned char shifts[2][4][4] =
-{
-    {
-        { 1, 1, 1, 1 }, /* KL */
-        { 0, 0, 0, 0 }, /* KR */
-        { 1, 1, 1, 1 }, /* KA */
-        { 0, 0, 0, 0 }  /* KB */
-    },
-    {
-        { 1, 0, 1, 1 }, /* KL */
-        { 1, 1, 0, 1 }, /* KR */
-        { 1, 1, 1, 0 }, /* KA */
-        { 1, 1, 0, 1 }  /* KB */
-    }
-};
-
-static const signed char indexes[2][4][20] =
-{
-    {
-        {  0,  1,  2,  3,  8,  9, 10, 11, 38, 39,
-          36, 37, 23, 20, 21, 22, 27, -1, -1, 26 }, /* KL -> RK */
-        { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-          -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, /* KR -> RK */
-        {  4,  5,  6,  7, 12, 13, 14, 15, 16, 17,
-          18, 19, -1, 24, 25, -1, 31, 28, 29, 30 }, /* KA -> RK */
-        { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-          -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }  /* KB -> RK */
-    },
-    {
-        {  0,  1,  2,  3, 61, 62, 63, 60, -1, -1,
-          -1, -1, 27, 24, 25, 26, 35, 32, 33, 34 }, /* KL -> RK */
-        { -1, -1, -1, -1,  8,  9, 10, 11, 16, 17,
-          18, 19, -1, -1, -1, -1, 39, 36, 37, 38 }, /* KR -> RK */
-        { -1, -1, -1, -1, 12, 13, 14, 15, 58, 59,
-          56, 57, 31, 28, 29, 30, -1, -1, -1, -1 }, /* KA -> RK */
-        {  4,  5,  6,  7, 65, 66, 67, 64, 20, 21,
-          22, 23, -1, -1, -1, -1, 43, 40, 41, 42 }  /* KB -> RK */
-    }
-};
-
-static const signed char transposes[2][20] =
-{
-    {
-        21, 22, 23, 20,
-        -1, -1, -1, -1,
-        18, 19, 16, 17,
-        11,  8,  9, 10,
-        15, 12, 13, 14
-    },
-    {
-        25, 26, 27, 24,
-        29, 30, 31, 28,
-        18, 19, 16, 17,
-        -1, -1, -1, -1,
-        -1, -1, -1, -1
-    }
-};
-
-/* Shift macro for 128 bit strings with rotation smaller than 32 bits (!) */
-#define ROTL(DEST, SRC, SHIFT)                                      \
-{                                                                   \
-    (DEST)[0] = (SRC)[0] << (SHIFT) ^ (SRC)[1] >> (32 - (SHIFT));   \
-    (DEST)[1] = (SRC)[1] << (SHIFT) ^ (SRC)[2] >> (32 - (SHIFT));   \
-    (DEST)[2] = (SRC)[2] << (SHIFT) ^ (SRC)[3] >> (32 - (SHIFT));   \
-    (DEST)[3] = (SRC)[3] << (SHIFT) ^ (SRC)[0] >> (32 - (SHIFT));   \
-}
-
-#define FL(XL, XR, KL, KR)                                          \
-{                                                                   \
-    (XR) = ((((XL) & (KL)) << 1) | (((XL) & (KL)) >> 31)) ^ (XR);   \
-    (XL) = ((XR) | (KR)) ^ (XL);                                    \
-}
-
-#define FLInv(YL, YR, KL, KR)                                       \
-{                                                                   \
-    (YL) = ((YR) | (KR)) ^ (YL);                                    \
-    (YR) = ((((YL) & (KL)) << 1) | (((YL) & (KL)) >> 31)) ^ (YR);   \
-}
-
-#define SHIFT_AND_PLACE(INDEX, OFFSET)                      \
-{                                                           \
-    TK[0] = KC[(OFFSET) * 4 + 0];                           \
-    TK[1] = KC[(OFFSET) * 4 + 1];                           \
-    TK[2] = KC[(OFFSET) * 4 + 2];                           \
-    TK[3] = KC[(OFFSET) * 4 + 3];                           \
-                                                            \
-    for( i = 1; i <= 4; i++ )                               \
-        if( shifts[(INDEX)][(OFFSET)][i -1] )               \
-            ROTL(TK + i * 4, TK, ( 15 * i ) % 32);          \
-                                                            \
-    for( i = 0; i < 20; i++ )                               \
-        if( indexes[(INDEX)][(OFFSET)][i] != -1 ) {         \
-            RK[indexes[(INDEX)][(OFFSET)][i]] = TK[ i ];    \
-        }                                                   \
-}
-
-static void camellia_feistel( const uint32_t x[2], const uint32_t k[2],
-                              uint32_t z[2])
-{
-    uint32_t I0, I1;
-    I0 = x[0] ^ k[0];
-    I1 = x[1] ^ k[1];
-
-    I0 = ((uint32_t) SBOX1( MBEDTLS_BYTE_3( I0 )) << 24) |
-         ((uint32_t) SBOX2( MBEDTLS_BYTE_2( I0 )) << 16) |
-         ((uint32_t) SBOX3( MBEDTLS_BYTE_1( I0 )) <<  8) |
-         ((uint32_t) SBOX4( MBEDTLS_BYTE_0( I0 ))      );
-    I1 = ((uint32_t) SBOX2( MBEDTLS_BYTE_3( I1 )) << 24) |
-         ((uint32_t) SBOX3( MBEDTLS_BYTE_2( I1 )) << 16) |
-         ((uint32_t) SBOX4( MBEDTLS_BYTE_1( I1 )) <<  8) |
-         ((uint32_t) SBOX1( MBEDTLS_BYTE_0( I1 ))      );
-
-    I0 ^= (I1 << 8) | (I1 >> 24);
-    I1 ^= (I0 << 16) | (I0 >> 16);
-    I0 ^= (I1 >> 8) | (I1 << 24);
-    I1 ^= (I0 >> 8) | (I0 << 24);
-
-    z[0] ^= I1;
-    z[1] ^= I0;
-}
-
-void mbedtls_camellia_init( mbedtls_camellia_context *ctx )
-{
-    CAMELLIA_VALIDATE( ctx != NULL );
-    memset( ctx, 0, sizeof( mbedtls_camellia_context ) );
-}
-
-void mbedtls_camellia_free( mbedtls_camellia_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_camellia_context ) );
-}
-
-/*
- * Camellia key schedule (encryption)
- */
-int mbedtls_camellia_setkey_enc( mbedtls_camellia_context *ctx,
-                                 const unsigned char *key,
-                                 unsigned int keybits )
-{
-    int idx;
-    size_t i;
-    uint32_t *RK;
-    unsigned char t[64];
-    uint32_t SIGMA[6][2];
-    uint32_t KC[16];
-    uint32_t TK[20];
-
-    CAMELLIA_VALIDATE_RET( ctx != NULL );
-    CAMELLIA_VALIDATE_RET( key != NULL );
-
-    RK = ctx->rk;
-
-    memset( t, 0, 64 );
-    memset( RK, 0, sizeof(ctx->rk) );
-
-    switch( keybits )
-    {
-        case 128: ctx->nr = 3; idx = 0; break;
-        case 192:
-        case 256: ctx->nr = 4; idx = 1; break;
-        default : return( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA );
-    }
-
-    for( i = 0; i < keybits / 8; ++i )
-        t[i] = key[i];
-
-    if( keybits == 192 ) {
-        for( i = 0; i < 8; i++ )
-            t[24 + i] = ~t[16 + i];
-    }
-
-    /*
-     * Prepare SIGMA values
-     */
-    for( i = 0; i < 6; i++ ) {
-        SIGMA[i][0] = MBEDTLS_GET_UINT32_BE( SIGMA_CHARS[i], 0 );
-        SIGMA[i][1] = MBEDTLS_GET_UINT32_BE( SIGMA_CHARS[i], 4 );
-    }
-
-    /*
-     * Key storage in KC
-     * Order: KL, KR, KA, KB
-     */
-    memset( KC, 0, sizeof(KC) );
-
-    /* Store KL, KR */
-    for( i = 0; i < 8; i++ )
-        KC[i] = MBEDTLS_GET_UINT32_BE( t, i * 4 );
-
-    /* Generate KA */
-    for( i = 0; i < 4; ++i )
-        KC[8 + i] = KC[i] ^ KC[4 + i];
-
-    camellia_feistel( KC + 8, SIGMA[0], KC + 10 );
-    camellia_feistel( KC + 10, SIGMA[1], KC + 8 );
-
-    for( i = 0; i < 4; ++i )
-        KC[8 + i] ^= KC[i];
-
-    camellia_feistel( KC + 8, SIGMA[2], KC + 10 );
-    camellia_feistel( KC + 10, SIGMA[3], KC + 8 );
-
-    if( keybits > 128 ) {
-        /* Generate KB */
-        for( i = 0; i < 4; ++i )
-            KC[12 + i] = KC[4 + i] ^ KC[8 + i];
-
-        camellia_feistel( KC + 12, SIGMA[4], KC + 14 );
-        camellia_feistel( KC + 14, SIGMA[5], KC + 12 );
-    }
-
-    /*
-     * Generating subkeys
-     */
-
-    /* Manipulating KL */
-    SHIFT_AND_PLACE( idx, 0 );
-
-    /* Manipulating KR */
-    if( keybits > 128 ) {
-        SHIFT_AND_PLACE( idx, 1 );
-    }
-
-    /* Manipulating KA */
-    SHIFT_AND_PLACE( idx, 2 );
-
-    /* Manipulating KB */
-    if( keybits > 128 ) {
-        SHIFT_AND_PLACE( idx, 3 );
-    }
-
-    /* Do transpositions */
-    for( i = 0; i < 20; i++ ) {
-        if( transposes[idx][i] != -1 ) {
-            RK[32 + 12 * idx + i] = RK[transposes[idx][i]];
-        }
-    }
-
-    return( 0 );
-}
-
-/*
- * Camellia key schedule (decryption)
- */
-int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx,
-                                 const unsigned char *key,
-                                 unsigned int keybits )
-{
-    int idx, ret;
-    size_t i;
-    mbedtls_camellia_context cty;
-    uint32_t *RK;
-    uint32_t *SK;
-    CAMELLIA_VALIDATE_RET( ctx != NULL );
-    CAMELLIA_VALIDATE_RET( key != NULL );
-
-    mbedtls_camellia_init( &cty );
-
-    /* Also checks keybits */
-    if( ( ret = mbedtls_camellia_setkey_enc( &cty, key, keybits ) ) != 0 )
-        goto exit;
-
-    ctx->nr = cty.nr;
-    idx = ( ctx->nr == 4 );
-
-    RK = ctx->rk;
-    SK = cty.rk + 24 * 2 + 8 * idx * 2;
-
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-
-    for( i = 22 + 8 * idx, SK -= 6; i > 0; i--, SK -= 4 )
-    {
-        *RK++ = *SK++;
-        *RK++ = *SK++;
-    }
-
-    SK -= 2;
-
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-
-exit:
-    mbedtls_camellia_free( &cty );
-
-    return( ret );
-}
-
-/*
- * Camellia-ECB block encryption/decryption
- */
-int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
-                    int mode,
-                    const unsigned char input[16],
-                    unsigned char output[16] )
-{
-    int NR;
-    uint32_t *RK, X[4];
-    CAMELLIA_VALIDATE_RET( ctx != NULL );
-    CAMELLIA_VALIDATE_RET( mode == MBEDTLS_CAMELLIA_ENCRYPT ||
-                           mode == MBEDTLS_CAMELLIA_DECRYPT );
-    CAMELLIA_VALIDATE_RET( input  != NULL );
-    CAMELLIA_VALIDATE_RET( output != NULL );
-
-    ( (void) mode );
-
-    NR = ctx->nr;
-    RK = ctx->rk;
-
-    X[0] = MBEDTLS_GET_UINT32_BE( input,  0 );
-    X[1] = MBEDTLS_GET_UINT32_BE( input,  4 );
-    X[2] = MBEDTLS_GET_UINT32_BE( input,  8 );
-    X[3] = MBEDTLS_GET_UINT32_BE( input, 12 );
-
-    X[0] ^= *RK++;
-    X[1] ^= *RK++;
-    X[2] ^= *RK++;
-    X[3] ^= *RK++;
-
-    while( NR ) {
-        --NR;
-        camellia_feistel( X, RK, X + 2 );
-        RK += 2;
-        camellia_feistel( X + 2, RK, X );
-        RK += 2;
-        camellia_feistel( X, RK, X + 2 );
-        RK += 2;
-        camellia_feistel( X + 2, RK, X );
-        RK += 2;
-        camellia_feistel( X, RK, X + 2 );
-        RK += 2;
-        camellia_feistel( X + 2, RK, X );
-        RK += 2;
-
-        if( NR ) {
-            FL(X[0], X[1], RK[0], RK[1]);
-            RK += 2;
-            FLInv(X[2], X[3], RK[0], RK[1]);
-            RK += 2;
-        }
-    }
-
-    X[2] ^= *RK++;
-    X[3] ^= *RK++;
-    X[0] ^= *RK++;
-    X[1] ^= *RK++;
-
-    MBEDTLS_PUT_UINT32_BE( X[2], output,  0 );
-    MBEDTLS_PUT_UINT32_BE( X[3], output,  4 );
-    MBEDTLS_PUT_UINT32_BE( X[0], output,  8 );
-    MBEDTLS_PUT_UINT32_BE( X[1], output, 12 );
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-/*
- * Camellia-CBC buffer encryption/decryption
- */
-int mbedtls_camellia_crypt_cbc( mbedtls_camellia_context *ctx,
-                                int mode,
-                                size_t length,
-                                unsigned char iv[16],
-                                const unsigned char *input,
-                                unsigned char *output )
-{
-    int i;
-    unsigned char temp[16];
-    CAMELLIA_VALIDATE_RET( ctx != NULL );
-    CAMELLIA_VALIDATE_RET( mode == MBEDTLS_CAMELLIA_ENCRYPT ||
-                           mode == MBEDTLS_CAMELLIA_DECRYPT );
-    CAMELLIA_VALIDATE_RET( iv != NULL );
-    CAMELLIA_VALIDATE_RET( length == 0 || input  != NULL );
-    CAMELLIA_VALIDATE_RET( length == 0 || output != NULL );
-
-    if( length % 16 )
-        return( MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH );
-
-    if( mode == MBEDTLS_CAMELLIA_DECRYPT )
-    {
-        while( length > 0 )
-        {
-            memcpy( temp, input, 16 );
-            mbedtls_camellia_crypt_ecb( ctx, mode, input, output );
-
-            for( i = 0; i < 16; i++ )
-                output[i] = (unsigned char)( output[i] ^ iv[i] );
-
-            memcpy( iv, temp, 16 );
-
-            input  += 16;
-            output += 16;
-            length -= 16;
-        }
-    }
-    else
-    {
-        while( length > 0 )
-        {
-            for( i = 0; i < 16; i++ )
-                output[i] = (unsigned char)( input[i] ^ iv[i] );
-
-            mbedtls_camellia_crypt_ecb( ctx, mode, output, output );
-            memcpy( iv, output, 16 );
-
-            input  += 16;
-            output += 16;
-            length -= 16;
-        }
-    }
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-/*
- * Camellia-CFB128 buffer encryption/decryption
- */
-int mbedtls_camellia_crypt_cfb128( mbedtls_camellia_context *ctx,
-                       int mode,
-                       size_t length,
-                       size_t *iv_off,
-                       unsigned char iv[16],
-                       const unsigned char *input,
-                       unsigned char *output )
-{
-    int c;
-    size_t n;
-    CAMELLIA_VALIDATE_RET( ctx != NULL );
-    CAMELLIA_VALIDATE_RET( mode == MBEDTLS_CAMELLIA_ENCRYPT ||
-                           mode == MBEDTLS_CAMELLIA_DECRYPT );
-    CAMELLIA_VALIDATE_RET( iv     != NULL );
-    CAMELLIA_VALIDATE_RET( iv_off != NULL );
-    CAMELLIA_VALIDATE_RET( length == 0 || input  != NULL );
-    CAMELLIA_VALIDATE_RET( length == 0 || output != NULL );
-
-    n = *iv_off;
-    if( n >= 16 )
-        return( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA );
-
-    if( mode == MBEDTLS_CAMELLIA_DECRYPT )
-    {
-        while( length-- )
-        {
-            if( n == 0 )
-                mbedtls_camellia_crypt_ecb( ctx, MBEDTLS_CAMELLIA_ENCRYPT, iv, iv );
-
-            c = *input++;
-            *output++ = (unsigned char)( c ^ iv[n] );
-            iv[n] = (unsigned char) c;
-
-            n = ( n + 1 ) & 0x0F;
-        }
-    }
-    else
-    {
-        while( length-- )
-        {
-            if( n == 0 )
-                mbedtls_camellia_crypt_ecb( ctx, MBEDTLS_CAMELLIA_ENCRYPT, iv, iv );
-
-            iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
-
-            n = ( n + 1 ) & 0x0F;
-        }
-    }
-
-    *iv_off = n;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/*
- * Camellia-CTR buffer encryption/decryption
- */
-int mbedtls_camellia_crypt_ctr( mbedtls_camellia_context *ctx,
-                       size_t length,
-                       size_t *nc_off,
-                       unsigned char nonce_counter[16],
-                       unsigned char stream_block[16],
-                       const unsigned char *input,
-                       unsigned char *output )
-{
-    int c, i;
-    size_t n;
-    CAMELLIA_VALIDATE_RET( ctx != NULL );
-    CAMELLIA_VALIDATE_RET( nonce_counter != NULL );
-    CAMELLIA_VALIDATE_RET( stream_block  != NULL );
-    CAMELLIA_VALIDATE_RET( nc_off != NULL );
-    CAMELLIA_VALIDATE_RET( length == 0 || input  != NULL );
-    CAMELLIA_VALIDATE_RET( length == 0 || output != NULL );
-
-    n = *nc_off;
-    if( n >= 16 )
-        return( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA );
-
-    while( length-- )
-    {
-        if( n == 0 ) {
-            mbedtls_camellia_crypt_ecb( ctx, MBEDTLS_CAMELLIA_ENCRYPT, nonce_counter,
-                                stream_block );
-
-            for( i = 16; i > 0; i-- )
-                if( ++nonce_counter[i - 1] != 0 )
-                    break;
-        }
-        c = *input++;
-        *output++ = (unsigned char)( c ^ stream_block[n] );
-
-        n = ( n + 1 ) & 0x0F;
-    }
-
-    *nc_off = n;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-#endif /* !MBEDTLS_CAMELLIA_ALT */
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/*
- * Camellia test vectors from:
- *
- * http://info.isl.ntt.co.jp/crypt/eng/camellia/technology.html:
- *   http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/cryptrec/intermediate.txt
- *   http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/cryptrec/t_camellia.txt
- *                      (For each bitlength: Key 0, Nr 39)
- */
-#define CAMELLIA_TESTS_ECB  2
-
-static const unsigned char camellia_test_ecb_key[3][CAMELLIA_TESTS_ECB][32] =
-{
-    {
-        { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-          0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
-        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
-    },
-    {
-        { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-          0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
-          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
-        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
-    },
-    {
-        { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-          0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
-          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-          0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
-        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
-    },
-};
-
-static const unsigned char camellia_test_ecb_plain[CAMELLIA_TESTS_ECB][16] =
-{
-    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-      0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
-    { 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
-};
-
-static const unsigned char camellia_test_ecb_cipher[3][CAMELLIA_TESTS_ECB][16] =
-{
-    {
-        { 0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73,
-          0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43 },
-        { 0x38, 0x3C, 0x6C, 0x2A, 0xAB, 0xEF, 0x7F, 0xDE,
-          0x25, 0xCD, 0x47, 0x0B, 0xF7, 0x74, 0xA3, 0x31 }
-    },
-    {
-        { 0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9, 0x96, 0xf8,
-          0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9 },
-        { 0xD1, 0x76, 0x3F, 0xC0, 0x19, 0xD7, 0x7C, 0xC9,
-          0x30, 0xBF, 0xF2, 0xA5, 0x6F, 0x7C, 0x93, 0x64 }
-    },
-    {
-        { 0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c,
-          0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09 },
-        { 0x05, 0x03, 0xFB, 0x10, 0xAB, 0x24, 0x1E, 0x7C,
-          0xF4, 0x5D, 0x8C, 0xDE, 0xEE, 0x47, 0x43, 0x35 }
-    }
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-#define CAMELLIA_TESTS_CBC  3
-
-static const unsigned char camellia_test_cbc_key[3][32] =
-{
-        { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
-          0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C }
-    ,
-        { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
-          0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
-          0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B }
-    ,
-        { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
-          0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
-          0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
-          0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
-};
-
-static const unsigned char camellia_test_cbc_iv[16] =
-
-    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }
-;
-
-static const unsigned char camellia_test_cbc_plain[CAMELLIA_TESTS_CBC][16] =
-{
-    { 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
-      0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
-    { 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
-      0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
-    { 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
-      0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF }
-
-};
-
-static const unsigned char camellia_test_cbc_cipher[3][CAMELLIA_TESTS_CBC][16] =
-{
-    {
-        { 0x16, 0x07, 0xCF, 0x49, 0x4B, 0x36, 0xBB, 0xF0,
-          0x0D, 0xAE, 0xB0, 0xB5, 0x03, 0xC8, 0x31, 0xAB },
-        { 0xA2, 0xF2, 0xCF, 0x67, 0x16, 0x29, 0xEF, 0x78,
-          0x40, 0xC5, 0xA5, 0xDF, 0xB5, 0x07, 0x48, 0x87 },
-        { 0x0F, 0x06, 0x16, 0x50, 0x08, 0xCF, 0x8B, 0x8B,
-          0x5A, 0x63, 0x58, 0x63, 0x62, 0x54, 0x3E, 0x54 }
-    },
-    {
-        { 0x2A, 0x48, 0x30, 0xAB, 0x5A, 0xC4, 0xA1, 0xA2,
-          0x40, 0x59, 0x55, 0xFD, 0x21, 0x95, 0xCF, 0x93 },
-        { 0x5D, 0x5A, 0x86, 0x9B, 0xD1, 0x4C, 0xE5, 0x42,
-          0x64, 0xF8, 0x92, 0xA6, 0xDD, 0x2E, 0xC3, 0xD5 },
-        { 0x37, 0xD3, 0x59, 0xC3, 0x34, 0x98, 0x36, 0xD8,
-          0x84, 0xE3, 0x10, 0xAD, 0xDF, 0x68, 0xC4, 0x49 }
-    },
-    {
-        { 0xE6, 0xCF, 0xA3, 0x5F, 0xC0, 0x2B, 0x13, 0x4A,
-          0x4D, 0x2C, 0x0B, 0x67, 0x37, 0xAC, 0x3E, 0xDA },
-        { 0x36, 0xCB, 0xEB, 0x73, 0xBD, 0x50, 0x4B, 0x40,
-          0x70, 0xB1, 0xB7, 0xDE, 0x2B, 0x21, 0xEB, 0x50 },
-        { 0xE3, 0x1A, 0x60, 0x55, 0x29, 0x7D, 0x96, 0xCA,
-          0x33, 0x30, 0xCD, 0xF1, 0xB1, 0x86, 0x0A, 0x83 }
-    }
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-/*
- * Camellia-CTR test vectors from:
- *
- * http://www.faqs.org/rfcs/rfc5528.html
- */
-
-static const unsigned char camellia_test_ctr_key[3][16] =
-{
-    { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
-      0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },
-    { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
-      0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },
-    { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
-      0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }
-};
-
-static const unsigned char camellia_test_ctr_nonce_counter[3][16] =
-{
-    { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
-    { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
-      0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },
-    { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
-      0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }
-};
-
-static const unsigned char camellia_test_ctr_pt[3][48] =
-{
-    { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
-      0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },
-
-    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-      0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
-
-    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-      0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
-      0x20, 0x21, 0x22, 0x23 }
-};
-
-static const unsigned char camellia_test_ctr_ct[3][48] =
-{
-    { 0xD0, 0x9D, 0xC2, 0x9A, 0x82, 0x14, 0x61, 0x9A,
-      0x20, 0x87, 0x7C, 0x76, 0xDB, 0x1F, 0x0B, 0x3F },
-    { 0xDB, 0xF3, 0xC7, 0x8D, 0xC0, 0x83, 0x96, 0xD4,
-      0xDA, 0x7C, 0x90, 0x77, 0x65, 0xBB, 0xCB, 0x44,
-      0x2B, 0x8E, 0x8E, 0x0F, 0x31, 0xF0, 0xDC, 0xA7,
-      0x2C, 0x74, 0x17, 0xE3, 0x53, 0x60, 0xE0, 0x48 },
-    { 0xB1, 0x9D, 0x1F, 0xCD, 0xCB, 0x75, 0xEB, 0x88,
-      0x2F, 0x84, 0x9C, 0xE2, 0x4D, 0x85, 0xCF, 0x73,
-      0x9C, 0xE6, 0x4B, 0x2B, 0x5C, 0x9D, 0x73, 0xF1,
-      0x4F, 0x2D, 0x5D, 0x9D, 0xCE, 0x98, 0x89, 0xCD,
-      0xDF, 0x50, 0x86, 0x96 }
-};
-
-static const int camellia_test_ctr_len[3] =
-    { 16, 32, 36 };
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-/*
- * Checkup routine
- */
-int mbedtls_camellia_self_test( int verbose )
-{
-    int i, j, u, v;
-    unsigned char key[32];
-    unsigned char buf[64];
-    unsigned char src[16];
-    unsigned char dst[16];
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    unsigned char iv[16];
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    size_t offset, len;
-    unsigned char nonce_counter[16];
-    unsigned char stream_block[16];
-#endif
-    int ret = 1;
-
-    mbedtls_camellia_context ctx;
-
-    mbedtls_camellia_init( &ctx );
-    memset( key, 0, 32 );
-
-    for( j = 0; j < 6; j++ ) {
-        u = j >> 1;
-    v = j & 1;
-
-    if( verbose != 0 )
-        mbedtls_printf( "  CAMELLIA-ECB-%3d (%s): ", 128 + u * 64,
-                         (v == MBEDTLS_CAMELLIA_DECRYPT) ? "dec" : "enc");
-
-    for( i = 0; i < CAMELLIA_TESTS_ECB; i++ ) {
-        memcpy( key, camellia_test_ecb_key[u][i], 16 + 8 * u );
-
-        if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
-            mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
-            memcpy( src, camellia_test_ecb_cipher[u][i], 16 );
-            memcpy( dst, camellia_test_ecb_plain[i], 16 );
-        } else { /* MBEDTLS_CAMELLIA_ENCRYPT */
-            mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
-            memcpy( src, camellia_test_ecb_plain[i], 16 );
-            memcpy( dst, camellia_test_ecb_cipher[u][i], 16 );
-        }
-
-        mbedtls_camellia_crypt_ecb( &ctx, v, src, buf );
-
-        if( memcmp( buf, dst, 16 ) != 0 )
-        {
-            if( verbose != 0 )
-                mbedtls_printf( "failed\n" );
-            goto exit;
-        }
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    /*
-     * CBC mode
-     */
-    for( j = 0; j < 6; j++ )
-    {
-        u = j >> 1;
-        v = j  & 1;
-
-        if( verbose != 0 )
-            mbedtls_printf( "  CAMELLIA-CBC-%3d (%s): ", 128 + u * 64,
-                             ( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
-
-        memcpy( src, camellia_test_cbc_iv, 16 );
-        memcpy( dst, camellia_test_cbc_iv, 16 );
-        memcpy( key, camellia_test_cbc_key[u], 16 + 8 * u );
-
-        if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
-            mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
-        } else {
-            mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
-        }
-
-        for( i = 0; i < CAMELLIA_TESTS_CBC; i++ ) {
-
-            if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
-                memcpy( iv , src, 16 );
-                memcpy( src, camellia_test_cbc_cipher[u][i], 16 );
-                memcpy( dst, camellia_test_cbc_plain[i], 16 );
-            } else { /* MBEDTLS_CAMELLIA_ENCRYPT */
-                memcpy( iv , dst, 16 );
-                memcpy( src, camellia_test_cbc_plain[i], 16 );
-                memcpy( dst, camellia_test_cbc_cipher[u][i], 16 );
-            }
-
-            mbedtls_camellia_crypt_cbc( &ctx, v, 16, iv, src, buf );
-
-            if( memcmp( buf, dst, 16 ) != 0 )
-            {
-                if( verbose != 0 )
-                    mbedtls_printf( "failed\n" );
-                goto exit;
-            }
-        }
-
-        if( verbose != 0 )
-            mbedtls_printf( "passed\n" );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    /*
-     * CTR mode
-     */
-    for( i = 0; i < 6; i++ )
-    {
-        u = i >> 1;
-        v = i  & 1;
-
-        if( verbose != 0 )
-            mbedtls_printf( "  CAMELLIA-CTR-128 (%s): ",
-                             ( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
-
-        memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 );
-        memcpy( key, camellia_test_ctr_key[u], 16 );
-
-        offset = 0;
-        mbedtls_camellia_setkey_enc( &ctx, key, 128 );
-
-        if( v == MBEDTLS_CAMELLIA_DECRYPT )
-        {
-            len = camellia_test_ctr_len[u];
-            memcpy( buf, camellia_test_ctr_ct[u], len );
-
-            mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
-                                buf, buf );
-
-            if( memcmp( buf, camellia_test_ctr_pt[u], len ) != 0 )
-            {
-                if( verbose != 0 )
-                    mbedtls_printf( "failed\n" );
-                goto exit;
-            }
-        }
-        else
-        {
-            len = camellia_test_ctr_len[u];
-            memcpy( buf, camellia_test_ctr_pt[u], len );
-
-            mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
-                                buf, buf );
-
-            if( memcmp( buf, camellia_test_ctr_ct[u], len ) != 0 )
-            {
-                if( verbose != 0 )
-                    mbedtls_printf( "failed\n" );
-                goto exit;
-            }
-        }
-
-        if( verbose != 0 )
-            mbedtls_printf( "passed\n" );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-    ret = 0;
-
-exit:
-    mbedtls_camellia_free( &ctx );
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_CAMELLIA_C */
diff --git a/src/duckdb/third_party/mbedtls/library/cipher.cpp b/src/duckdb/third_party/mbedtls/library/cipher.cpp
deleted file mode 100644
index b905e8556..000000000
--- a/src/duckdb/third_party/mbedtls/library/cipher.cpp
+++ /dev/null
@@ -1,1633 +0,0 @@
-/**
- * \file cipher.c
- *
- * \brief Generic cipher wrapper for mbed TLS
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_CIPHER_C)
-
-#include "mbedtls/cipher.h"
-#include "cipher_wrap.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-#include "mbedtls/constant_time.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-#include "mbedtls/chachapoly.h"
-#endif
-
-#if defined(MBEDTLS_GCM_C)
-#include "mbedtls/gcm.h"
-#endif
-
-#if defined(MBEDTLS_CCM_C)
-#include "mbedtls/ccm.h"
-#endif
-
-#if defined(MBEDTLS_CHACHA20_C)
-#include "mbedtls/chacha20.h"
-#endif
-
-#if defined(MBEDTLS_CMAC_C)
-#include "mbedtls/cmac.h"
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#include "psa/crypto.h"
-#include "mbedtls/psa_util.h"
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_NIST_KW_C)
-#include "mbedtls/nist_kw.h"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#define mbedtls_calloc calloc
-#define mbedtls_free   free
-#endif
-
-#define CIPHER_VALIDATE_RET( cond )    \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA )
-#define CIPHER_VALIDATE( cond )        \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-static int supported_init = 0;
-
-const int *mbedtls_cipher_list( void )
-{
-    const mbedtls_cipher_definition_t *def;
-    int *type;
-
-    if( ! supported_init )
-    {
-        def = mbedtls_cipher_definitions;
-        type = mbedtls_cipher_supported;
-
-        while( def->type != 0 )
-            *type++ = (*def++).type;
-
-        *type = 0;
-
-        supported_init = 1;
-    }
-
-    return( mbedtls_cipher_supported );
-}
-
-const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type(
-    const mbedtls_cipher_type_t cipher_type )
-{
-    const mbedtls_cipher_definition_t *def;
-
-    for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
-        if( def->type == cipher_type )
-            return( def->info );
-
-    return( NULL );
-}
-
-const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string(
-    const char *cipher_name )
-{
-    const mbedtls_cipher_definition_t *def;
-
-    if( NULL == cipher_name )
-        return( NULL );
-
-    for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
-        if( !  strcmp( def->info->name, cipher_name ) )
-            return( def->info );
-
-    return( NULL );
-}
-
-const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values(
-    const mbedtls_cipher_id_t cipher_id,
-    int key_bitlen,
-    const mbedtls_cipher_mode_t mode )
-{
-    const mbedtls_cipher_definition_t *def;
-
-    for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
-        if( def->info->base->cipher == cipher_id &&
-            def->info->key_bitlen == (unsigned) key_bitlen &&
-            def->info->mode == mode )
-            return( def->info );
-
-    return( NULL );
-}
-
-void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx )
-{
-    CIPHER_VALIDATE( ctx != NULL );
-    memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
-}
-
-void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        if( ctx->cipher_ctx != NULL )
-        {
-            mbedtls_cipher_context_psa * const cipher_psa =
-                (mbedtls_cipher_context_psa *) ctx->cipher_ctx;
-
-            if( cipher_psa->slot_state == MBEDTLS_CIPHER_PSA_KEY_OWNED )
-            {
-                /* xxx_free() doesn't allow to return failures. */
-                (void) psa_destroy_key( cipher_psa->slot );
-            }
-
-            mbedtls_platform_zeroize( cipher_psa, sizeof( *cipher_psa ) );
-            mbedtls_free( cipher_psa );
-        }
-
-        mbedtls_platform_zeroize( ctx, sizeof(mbedtls_cipher_context_t) );
-        return;
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_CMAC_C)
-    if( ctx->cmac_ctx )
-    {
-       mbedtls_platform_zeroize( ctx->cmac_ctx,
-                                 sizeof( mbedtls_cmac_context_t ) );
-       mbedtls_free( ctx->cmac_ctx );
-    }
-#endif
-
-    if( ctx->cipher_ctx )
-        ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
-
-    mbedtls_platform_zeroize( ctx, sizeof(mbedtls_cipher_context_t) );
-}
-
-int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx,
-                          const mbedtls_cipher_info_t *cipher_info )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    if( cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
-
-    if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
-        return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
-
-    ctx->cipher_info = cipher_info;
-
-#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
-    /*
-     * Ignore possible errors caused by a cipher mode that doesn't use padding
-     */
-#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
-    (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_PKCS7 );
-#else
-    (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_NONE );
-#endif
-#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-int mbedtls_cipher_setup_psa( mbedtls_cipher_context_t *ctx,
-                              const mbedtls_cipher_info_t *cipher_info,
-                              size_t taglen )
-{
-    psa_algorithm_t alg;
-    mbedtls_cipher_context_psa *cipher_psa;
-
-    if( NULL == cipher_info || NULL == ctx )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    /* Check that the underlying cipher mode and cipher type are
-     * supported by the underlying PSA Crypto implementation. */
-    alg = mbedtls_psa_translate_cipher_mode( cipher_info->mode, taglen );
-    if( alg == 0 )
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    if( mbedtls_psa_translate_cipher_type( cipher_info->type ) == 0 )
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-
-    memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
-
-    cipher_psa = mbedtls_calloc( 1, sizeof(mbedtls_cipher_context_psa ) );
-    if( cipher_psa == NULL )
-        return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
-    cipher_psa->alg  = alg;
-    ctx->cipher_ctx  = cipher_psa;
-    ctx->cipher_info = cipher_info;
-    ctx->psa_enabled = 1;
-    return( 0 );
-}
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx,
-                           const unsigned char *key,
-                           int key_bitlen,
-                           const mbedtls_operation_t operation )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( key != NULL );
-    CIPHER_VALIDATE_RET( operation == MBEDTLS_ENCRYPT ||
-                         operation == MBEDTLS_DECRYPT );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        mbedtls_cipher_context_psa * const cipher_psa =
-            (mbedtls_cipher_context_psa *) ctx->cipher_ctx;
-
-        size_t const key_bytelen = ( (size_t) key_bitlen + 7 ) / 8;
-
-        psa_status_t status;
-        psa_key_type_t key_type;
-        psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
-        /* PSA Crypto API only accepts byte-aligned keys. */
-        if( key_bitlen % 8 != 0 )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        /* Don't allow keys to be set multiple times. */
-        if( cipher_psa->slot_state != MBEDTLS_CIPHER_PSA_KEY_UNSET )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        key_type = mbedtls_psa_translate_cipher_type(
-            ctx->cipher_info->type );
-        if( key_type == 0 )
-            return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-        psa_set_key_type( &attributes, key_type );
-
-        /* Mbed TLS' cipher layer doesn't enforce the mode of operation
-         * (encrypt vs. decrypt): it is possible to setup a key for encryption
-         * and use it for AEAD decryption. Until tests relying on this
-         * are changed, allow any usage in PSA. */
-        psa_set_key_usage_flags( &attributes,
-                                 /* mbedtls_psa_translate_cipher_operation( operation ); */
-                                 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
-        psa_set_key_algorithm( &attributes, cipher_psa->alg );
-
-        status = psa_import_key( &attributes, key, key_bytelen,
-                                 &cipher_psa->slot );
-        switch( status )
-        {
-            case PSA_SUCCESS:
-                break;
-            case PSA_ERROR_INSUFFICIENT_MEMORY:
-                return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
-            case PSA_ERROR_NOT_SUPPORTED:
-                return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-            default:
-                return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-        }
-        /* Indicate that we own the key slot and need to
-         * destroy it in mbedtls_cipher_free(). */
-        cipher_psa->slot_state = MBEDTLS_CIPHER_PSA_KEY_OWNED;
-
-        ctx->key_bitlen = key_bitlen;
-        ctx->operation = operation;
-        return( 0 );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_KEY_LEN ) == 0 &&
-        (int) ctx->cipher_info->key_bitlen != key_bitlen )
-    {
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-    }
-
-    ctx->key_bitlen = key_bitlen;
-    ctx->operation = operation;
-
-    /*
-     * For OFB, CFB and CTR mode always use the encryption key schedule
-     */
-    if( MBEDTLS_ENCRYPT == operation ||
-        MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_OFB == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_CTR == ctx->cipher_info->mode )
-    {
-        return( ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
-                                                         ctx->key_bitlen ) );
-    }
-
-    if( MBEDTLS_DECRYPT == operation )
-        return( ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
-                                                         ctx->key_bitlen ) );
-
-    return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-}
-
-int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
-                           const unsigned char *iv,
-                           size_t iv_len )
-{
-    size_t actual_iv_size;
-
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( iv_len == 0 || iv != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto has an API for multipart
-         * operations, we currently don't make it
-         * accessible through the cipher layer. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    /* avoid buffer overflow in ctx->iv */
-    if( iv_len > MBEDTLS_MAX_IV_LENGTH )
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-
-    if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_IV_LEN ) != 0 )
-        actual_iv_size = iv_len;
-    else
-    {
-        actual_iv_size = ctx->cipher_info->iv_size;
-
-        /* avoid reading past the end of input buffer */
-        if( actual_iv_size > iv_len )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-    }
-
-#if defined(MBEDTLS_CHACHA20_C)
-    if ( ctx->cipher_info->type == MBEDTLS_CIPHER_CHACHA20 )
-    {
-        if ( 0 != mbedtls_chacha20_starts( (mbedtls_chacha20_context*)ctx->cipher_ctx,
-                                           iv,
-                                           0U ) ) /* Initial counter value */
-        {
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-        }
-    }
-#endif
-
-#if defined(MBEDTLS_GCM_C)
-    if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
-    {
-        return( mbedtls_gcm_starts( (mbedtls_gcm_context *) ctx->cipher_ctx,
-                                    ctx->operation,
-                                    iv, iv_len ) );
-    }
-#endif
-
-#if defined(MBEDTLS_CCM_C)
-    if( MBEDTLS_MODE_CCM_STAR_NO_TAG == ctx->cipher_info->mode )
-    {
-        int set_lengths_result;
-        int ccm_star_mode;
-
-        set_lengths_result = mbedtls_ccm_set_lengths(
-                                (mbedtls_ccm_context *) ctx->cipher_ctx,
-                                0, 0, 0 );
-        if( set_lengths_result != 0 )
-            return set_lengths_result;
-
-        if( ctx->operation == MBEDTLS_DECRYPT )
-            ccm_star_mode = MBEDTLS_CCM_STAR_DECRYPT;
-        else if( ctx->operation == MBEDTLS_ENCRYPT )
-            ccm_star_mode = MBEDTLS_CCM_STAR_ENCRYPT;
-        else
-            return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
-
-        return( mbedtls_ccm_starts( (mbedtls_ccm_context *) ctx->cipher_ctx,
-                                    ccm_star_mode,
-                                    iv, iv_len ) );
-    }
-#endif
-
-    if ( actual_iv_size != 0 )
-    {
-        memcpy( ctx->iv, iv, actual_iv_size );
-        ctx->iv_size = actual_iv_size;
-    }
-
-    return( 0 );
-}
-
-int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* We don't support resetting PSA-based
-         * cipher contexts, yet. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    ctx->unprocessed_len = 0;
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
-int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
-                      const unsigned char *ad, size_t ad_len )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( ad_len == 0 || ad != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto has an API for multipart
-         * operations, we currently don't make it
-         * accessible through the cipher layer. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_GCM_C)
-    if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
-    {
-        return( mbedtls_gcm_update_ad( (mbedtls_gcm_context *) ctx->cipher_ctx,
-                                       ad, ad_len ) );
-    }
-#endif
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    if (MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
-    {
-        int result;
-        mbedtls_chachapoly_mode_t mode;
-
-        mode = ( ctx->operation == MBEDTLS_ENCRYPT )
-                ? MBEDTLS_CHACHAPOLY_ENCRYPT
-                : MBEDTLS_CHACHAPOLY_DECRYPT;
-
-        result = mbedtls_chachapoly_starts( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
-                                                        ctx->iv,
-                                                        mode );
-        if ( result != 0 )
-            return( result );
-
-        return( mbedtls_chachapoly_update_aad( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
-                                               ad, ad_len ) );
-    }
-#endif
-
-    return( 0 );
-}
-#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
-
-int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
-                   size_t ilen, unsigned char *output, size_t *olen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t block_size;
-
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( ilen == 0 || input != NULL );
-    CIPHER_VALIDATE_RET( output != NULL );
-    CIPHER_VALIDATE_RET( olen != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto has an API for multipart
-         * operations, we currently don't make it
-         * accessible through the cipher layer. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    *olen = 0;
-    block_size = mbedtls_cipher_get_block_size( ctx );
-    if ( 0 == block_size )
-    {
-        return( MBEDTLS_ERR_CIPHER_INVALID_CONTEXT );
-    }
-
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_ECB )
-    {
-        if( ilen != block_size )
-            return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
-
-        *olen = ilen;
-
-        if( 0 != ( ret = ctx->cipher_info->base->ecb_func( ctx->cipher_ctx,
-                    ctx->operation, input, output ) ) )
-        {
-            return( ret );
-        }
-
-        return( 0 );
-    }
-
-#if defined(MBEDTLS_GCM_C)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_GCM )
-    {
-        return( mbedtls_gcm_update( (mbedtls_gcm_context *) ctx->cipher_ctx,
-                                    input, ilen,
-                                    output, ilen, olen ) );
-    }
-#endif
-
-#if defined(MBEDTLS_CCM_C)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_CCM_STAR_NO_TAG )
-    {
-        return( mbedtls_ccm_update( (mbedtls_ccm_context *) ctx->cipher_ctx,
-                                    input, ilen,
-                                    output, ilen, olen ) );
-    }
-#endif
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    if ( ctx->cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305 )
-    {
-        *olen = ilen;
-        return( mbedtls_chachapoly_update( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
-                                           ilen, input, output ) );
-    }
-#endif
-
-    if( input == output &&
-       ( ctx->unprocessed_len != 0 || ilen % block_size ) )
-    {
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-    }
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_CBC )
-    {
-        size_t copy_len = 0;
-
-        /*
-         * If there is not enough data for a full block, cache it.
-         */
-        if( ( ctx->operation == MBEDTLS_DECRYPT && NULL != ctx->add_padding &&
-                ilen <= block_size - ctx->unprocessed_len ) ||
-            ( ctx->operation == MBEDTLS_DECRYPT && NULL == ctx->add_padding &&
-                ilen < block_size - ctx->unprocessed_len ) ||
-             ( ctx->operation == MBEDTLS_ENCRYPT &&
-                ilen < block_size - ctx->unprocessed_len ) )
-        {
-            memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
-                    ilen );
-
-            ctx->unprocessed_len += ilen;
-            return( 0 );
-        }
-
-        /*
-         * Process cached data first
-         */
-        if( 0 != ctx->unprocessed_len )
-        {
-            copy_len = block_size - ctx->unprocessed_len;
-
-            memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
-                    copy_len );
-
-            if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
-                    ctx->operation, block_size, ctx->iv,
-                    ctx->unprocessed_data, output ) ) )
-            {
-                return( ret );
-            }
-
-            *olen += block_size;
-            output += block_size;
-            ctx->unprocessed_len = 0;
-
-            input += copy_len;
-            ilen -= copy_len;
-        }
-
-        /*
-         * Cache final, incomplete block
-         */
-        if( 0 != ilen )
-        {
-            /* Encryption: only cache partial blocks
-             * Decryption w/ padding: always keep at least one whole block
-             * Decryption w/o padding: only cache partial blocks
-             */
-            copy_len = ilen % block_size;
-            if( copy_len == 0 &&
-                ctx->operation == MBEDTLS_DECRYPT &&
-                NULL != ctx->add_padding)
-            {
-                copy_len = block_size;
-            }
-
-            memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
-                    copy_len );
-
-            ctx->unprocessed_len += copy_len;
-            ilen -= copy_len;
-        }
-
-        /*
-         * Process remaining full blocks
-         */
-        if( ilen )
-        {
-            if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
-                    ctx->operation, ilen, ctx->iv, input, output ) ) )
-            {
-                return( ret );
-            }
-
-            *olen += ilen;
-        }
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_CFB )
-    {
-        if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
-                ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
-                input, output ) ) )
-        {
-            return( ret );
-        }
-
-        *olen = ilen;
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_OFB )
-    {
-        if( 0 != ( ret = ctx->cipher_info->base->ofb_func( ctx->cipher_ctx,
-                ilen, &ctx->unprocessed_len, ctx->iv, input, output ) ) )
-        {
-            return( ret );
-        }
-
-        *olen = ilen;
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_CTR )
-    {
-        if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
-                ilen, &ctx->unprocessed_len, ctx->iv,
-                ctx->unprocessed_data, input, output ) ) )
-        {
-            return( ret );
-        }
-
-        *olen = ilen;
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_XTS )
-    {
-        if( ctx->unprocessed_len > 0 ) {
-            /* We can only process an entire data unit at a time. */
-            return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-        }
-
-        ret = ctx->cipher_info->base->xts_func( ctx->cipher_ctx,
-                ctx->operation, ilen, ctx->iv, input, output );
-        if( ret != 0 )
-        {
-            return( ret );
-        }
-
-        *olen = ilen;
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    if( ctx->cipher_info->mode == MBEDTLS_MODE_STREAM )
-    {
-        if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
-                                                    ilen, input, output ) ) )
-        {
-            return( ret );
-        }
-
-        *olen = ilen;
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_CIPHER_MODE_STREAM */
-
-    return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
-#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
-/*
- * PKCS7 (and PKCS5) padding: fill with ll bytes, with ll = padding_len
- */
-static void add_pkcs_padding( unsigned char *output, size_t output_len,
-        size_t data_len )
-{
-    size_t padding_len = output_len - data_len;
-    unsigned char i;
-
-    for( i = 0; i < padding_len; i++ )
-        output[data_len + i] = (unsigned char) padding_len;
-}
-
-static int get_pkcs_padding( unsigned char *input, size_t input_len,
-        size_t *data_len )
-{
-    size_t i, pad_idx;
-    unsigned char padding_len, bad = 0;
-
-    if( NULL == input || NULL == data_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    padding_len = input[input_len - 1];
-    *data_len = input_len - padding_len;
-
-    /* Avoid logical || since it results in a branch */
-    bad |= padding_len > input_len;
-    bad |= padding_len == 0;
-
-    /* The number of bytes checked must be independent of padding_len,
-     * so pick input_len, which is usually 8 or 16 (one block) */
-    pad_idx = input_len - padding_len;
-    for( i = 0; i < input_len; i++ )
-        bad |= ( input[i] ^ padding_len ) * ( i >= pad_idx );
-
-    return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
-}
-#endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
-
-#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
-/*
- * One and zeros padding: fill with 80 00 ... 00
- */
-static void add_one_and_zeros_padding( unsigned char *output,
-                                       size_t output_len, size_t data_len )
-{
-    size_t padding_len = output_len - data_len;
-    unsigned char i = 0;
-
-    output[data_len] = 0x80;
-    for( i = 1; i < padding_len; i++ )
-        output[data_len + i] = 0x00;
-}
-
-static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
-                                      size_t *data_len )
-{
-    size_t i;
-    unsigned char done = 0, prev_done, bad;
-
-    if( NULL == input || NULL == data_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    bad = 0x80;
-    *data_len = 0;
-    for( i = input_len; i > 0; i-- )
-    {
-        prev_done = done;
-        done |= ( input[i - 1] != 0 );
-        *data_len |= ( i - 1 ) * ( done != prev_done );
-        bad ^= input[i - 1] * ( done != prev_done );
-    }
-
-    return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
-
-}
-#endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
-
-#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
-/*
- * Zeros and len padding: fill with 00 ... 00 ll, where ll is padding length
- */
-static void add_zeros_and_len_padding( unsigned char *output,
-                                       size_t output_len, size_t data_len )
-{
-    size_t padding_len = output_len - data_len;
-    unsigned char i = 0;
-
-    for( i = 1; i < padding_len; i++ )
-        output[data_len + i - 1] = 0x00;
-    output[output_len - 1] = (unsigned char) padding_len;
-}
-
-static int get_zeros_and_len_padding( unsigned char *input, size_t input_len,
-                                      size_t *data_len )
-{
-    size_t i, pad_idx;
-    unsigned char padding_len, bad = 0;
-
-    if( NULL == input || NULL == data_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    padding_len = input[input_len - 1];
-    *data_len = input_len - padding_len;
-
-    /* Avoid logical || since it results in a branch */
-    bad |= padding_len > input_len;
-    bad |= padding_len == 0;
-
-    /* The number of bytes checked must be independent of padding_len */
-    pad_idx = input_len - padding_len;
-    for( i = 0; i < input_len - 1; i++ )
-        bad |= input[i] * ( i >= pad_idx );
-
-    return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
-}
-#endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
-
-#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
-/*
- * Zero padding: fill with 00 ... 00
- */
-static void add_zeros_padding( unsigned char *output,
-                               size_t output_len, size_t data_len )
-{
-    size_t i;
-
-    for( i = data_len; i < output_len; i++ )
-        output[i] = 0x00;
-}
-
-static int get_zeros_padding( unsigned char *input, size_t input_len,
-                              size_t *data_len )
-{
-    size_t i;
-    unsigned char done = 0, prev_done;
-
-    if( NULL == input || NULL == data_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    *data_len = 0;
-    for( i = input_len; i > 0; i-- )
-    {
-        prev_done = done;
-        done |= ( input[i-1] != 0 );
-        *data_len |= i * ( done != prev_done );
-    }
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
-
-/*
- * No padding: don't pad :)
- *
- * There is no add_padding function (check for NULL in mbedtls_cipher_finish)
- * but a trivial get_padding function
- */
-static int get_no_padding( unsigned char *input, size_t input_len,
-                              size_t *data_len )
-{
-    if( NULL == input || NULL == data_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    *data_len = input_len;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
-
-int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
-                   unsigned char *output, size_t *olen )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( output != NULL );
-    CIPHER_VALIDATE_RET( olen != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto has an API for multipart
-         * operations, we currently don't make it
-         * accessible through the cipher layer. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    *olen = 0;
-
-    if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_OFB == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_CCM_STAR_NO_TAG == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_XTS == ctx->cipher_info->mode ||
-        MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
-    {
-        return( 0 );
-    }
-
-    if ( ( MBEDTLS_CIPHER_CHACHA20          == ctx->cipher_info->type ) ||
-         ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type ) )
-    {
-        return( 0 );
-    }
-
-    if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
-    {
-        if( ctx->unprocessed_len != 0 )
-            return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
-
-        return( 0 );
-    }
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
-    {
-        int ret = 0;
-
-        if( MBEDTLS_ENCRYPT == ctx->operation )
-        {
-            /* check for 'no padding' mode */
-            if( NULL == ctx->add_padding )
-            {
-                if( 0 != ctx->unprocessed_len )
-                    return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
-
-                return( 0 );
-            }
-
-            ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
-                    ctx->unprocessed_len );
-        }
-        else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
-        {
-            /*
-             * For decrypt operations, expect a full block,
-             * or an empty block if no padding
-             */
-            if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
-                return( 0 );
-
-            return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
-        }
-
-        /* cipher block */
-        if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
-                ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
-                ctx->unprocessed_data, output ) ) )
-        {
-            return( ret );
-        }
-
-        /* Set output size for decryption */
-        if( MBEDTLS_DECRYPT == ctx->operation )
-            return( ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
-                                      olen ) );
-
-        /* Set output size for encryption */
-        *olen = mbedtls_cipher_get_block_size( ctx );
-        return( 0 );
-    }
-#else
-    ((void) output);
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-    return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
-int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx,
-                                     mbedtls_cipher_padding_t mode )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-
-    if( NULL == ctx->cipher_info || MBEDTLS_MODE_CBC != ctx->cipher_info->mode )
-    {
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-    }
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto knows about CBC padding
-         * schemes, we currently don't make them
-         * accessible through the cipher layer. */
-        if( mode != MBEDTLS_PADDING_NONE )
-            return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    switch( mode )
-    {
-#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
-    case MBEDTLS_PADDING_PKCS7:
-        ctx->add_padding = add_pkcs_padding;
-        ctx->get_padding = get_pkcs_padding;
-        break;
-#endif
-#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
-    case MBEDTLS_PADDING_ONE_AND_ZEROS:
-        ctx->add_padding = add_one_and_zeros_padding;
-        ctx->get_padding = get_one_and_zeros_padding;
-        break;
-#endif
-#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
-    case MBEDTLS_PADDING_ZEROS_AND_LEN:
-        ctx->add_padding = add_zeros_and_len_padding;
-        ctx->get_padding = get_zeros_and_len_padding;
-        break;
-#endif
-#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
-    case MBEDTLS_PADDING_ZEROS:
-        ctx->add_padding = add_zeros_padding;
-        ctx->get_padding = get_zeros_padding;
-        break;
-#endif
-    case MBEDTLS_PADDING_NONE:
-        ctx->add_padding = NULL;
-        ctx->get_padding = get_no_padding;
-        break;
-
-    default:
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-
-    return( 0 );
-}
-#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
-
-#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
-int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
-                      unsigned char *tag, size_t tag_len )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( tag_len == 0 || tag != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    if( MBEDTLS_ENCRYPT != ctx->operation )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto has an API for multipart
-         * operations, we currently don't make it
-         * accessible through the cipher layer. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_GCM_C)
-    if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
-    {
-        size_t output_length;
-        /* The code here doesn't yet support alternative implementations
-         * that can delay up to a block of output. */
-        return( mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx,
-                                    NULL, 0, &output_length,
-                                    tag, tag_len ) );
-    }
-#endif
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
-    {
-        /* Don't allow truncated MAC for Poly1305 */
-        if ( tag_len != 16U )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        return( mbedtls_chachapoly_finish(
-                    (mbedtls_chachapoly_context*) ctx->cipher_ctx, tag ) );
-    }
-#endif
-
-    return( 0 );
-}
-
-int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
-                      const unsigned char *tag, size_t tag_len )
-{
-    unsigned char check_tag[16];
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( tag_len == 0 || tag != NULL );
-    if( ctx->cipher_info == NULL )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    if( MBEDTLS_DECRYPT != ctx->operation )
-    {
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-    }
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* While PSA Crypto has an API for multipart
-         * operations, we currently don't make it
-         * accessible through the cipher layer. */
-        return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    /* Status to return on a non-authenticated algorithm. It would make sense
-     * to return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT or perhaps
-     * MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA, but at the time I write this our
-     * unit tests assume 0. */
-    ret = 0;
-
-#if defined(MBEDTLS_GCM_C)
-    if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
-    {
-        size_t output_length;
-        /* The code here doesn't yet support alternative implementations
-         * that can delay up to a block of output. */
-
-        if( tag_len > sizeof( check_tag ) )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        if( 0 != ( ret = mbedtls_gcm_finish(
-                       (mbedtls_gcm_context *) ctx->cipher_ctx,
-                       NULL, 0, &output_length,
-                       check_tag, tag_len ) ) )
-        {
-            return( ret );
-        }
-
-        /* Check the tag in "constant-time" */
-        if( mbedtls_ct_memcmp( tag, check_tag, tag_len ) != 0 )
-        {
-            ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
-            goto exit;
-        }
-    }
-#endif /* MBEDTLS_GCM_C */
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
-    {
-        /* Don't allow truncated MAC for Poly1305 */
-        if ( tag_len != sizeof( check_tag ) )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        ret = mbedtls_chachapoly_finish(
-            (mbedtls_chachapoly_context*) ctx->cipher_ctx, check_tag );
-        if ( ret != 0 )
-        {
-            return( ret );
-        }
-
-        /* Check the tag in "constant-time" */
-        if( mbedtls_ct_memcmp( tag, check_tag, tag_len ) != 0 )
-        {
-            ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
-            goto exit;
-        }
-    }
-#endif /* MBEDTLS_CHACHAPOLY_C */
-
-exit:
-    mbedtls_platform_zeroize( check_tag, tag_len );
-    return( ret );
-}
-#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
-
-/*
- * Packet-oriented wrapper for non-AEAD modes
- */
-int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
-                  const unsigned char *iv, size_t iv_len,
-                  const unsigned char *input, size_t ilen,
-                  unsigned char *output, size_t *olen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t finish_olen;
-
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( iv_len == 0 || iv != NULL );
-    CIPHER_VALIDATE_RET( ilen == 0 || input != NULL );
-    CIPHER_VALIDATE_RET( output != NULL );
-    CIPHER_VALIDATE_RET( olen != NULL );
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* As in the non-PSA case, we don't check that
-         * a key has been set. If not, the key slot will
-         * still be in its default state of 0, which is
-         * guaranteed to be invalid, hence the PSA-call
-         * below will gracefully fail. */
-        mbedtls_cipher_context_psa * const cipher_psa =
-            (mbedtls_cipher_context_psa *) ctx->cipher_ctx;
-
-        psa_status_t status;
-        psa_cipher_operation_t cipher_op = PSA_CIPHER_OPERATION_INIT;
-        size_t part_len;
-
-        if( ctx->operation == MBEDTLS_DECRYPT )
-        {
-            status = psa_cipher_decrypt_setup( &cipher_op,
-                                               cipher_psa->slot,
-                                               cipher_psa->alg );
-        }
-        else if( ctx->operation == MBEDTLS_ENCRYPT )
-        {
-            status = psa_cipher_encrypt_setup( &cipher_op,
-                                               cipher_psa->slot,
-                                               cipher_psa->alg );
-        }
-        else
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        /* In the following, we can immediately return on an error,
-         * because the PSA Crypto API guarantees that cipher operations
-         * are terminated by unsuccessful calls to psa_cipher_update(),
-         * and by any call to psa_cipher_finish(). */
-        if( status != PSA_SUCCESS )
-            return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-        if( ctx->cipher_info->mode != MBEDTLS_MODE_ECB )
-        {
-            status = psa_cipher_set_iv( &cipher_op, iv, iv_len );
-            if( status != PSA_SUCCESS )
-                return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-        }
-
-        status = psa_cipher_update( &cipher_op,
-                                    input, ilen,
-                                    output, ilen, olen );
-        if( status != PSA_SUCCESS )
-            return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-        status = psa_cipher_finish( &cipher_op,
-                                    output + *olen, ilen - *olen,
-                                    &part_len );
-        if( status != PSA_SUCCESS )
-            return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-        *olen += part_len;
-        return( 0 );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-    if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv_len ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_cipher_reset( ctx ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_cipher_update( ctx, input, ilen,
-                                       output, olen ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_cipher_finish( ctx, output + *olen,
-                                       &finish_olen ) ) != 0 )
-        return( ret );
-
-    *olen += finish_olen;
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_AEAD)
-/*
- * Packet-oriented encryption for AEAD modes: internal function used by
- * mbedtls_cipher_auth_encrypt_ext().
- */
-static int mbedtls_cipher_aead_encrypt( mbedtls_cipher_context_t *ctx,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t *olen,
-                         unsigned char *tag, size_t tag_len )
-{
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* As in the non-PSA case, we don't check that
-         * a key has been set. If not, the key slot will
-         * still be in its default state of 0, which is
-         * guaranteed to be invalid, hence the PSA-call
-         * below will gracefully fail. */
-        mbedtls_cipher_context_psa * const cipher_psa =
-            (mbedtls_cipher_context_psa *) ctx->cipher_ctx;
-
-        psa_status_t status;
-
-        /* PSA Crypto API always writes the authentication tag
-         * at the end of the encrypted message. */
-        if( output == NULL || tag != output + ilen )
-            return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-
-        status = psa_aead_encrypt( cipher_psa->slot,
-                                   cipher_psa->alg,
-                                   iv, iv_len,
-                                   ad, ad_len,
-                                   input, ilen,
-                                   output, ilen + tag_len, olen );
-        if( status != PSA_SUCCESS )
-            return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-        *olen -= tag_len;
-        return( 0 );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_GCM_C)
-    if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
-    {
-        *olen = ilen;
-        return( mbedtls_gcm_crypt_and_tag( (mbedtls_gcm_context *)ctx->cipher_ctx, MBEDTLS_GCM_ENCRYPT,
-                                           ilen, iv, iv_len, ad, ad_len,
-                                           input, output, tag_len, tag ) );
-    }
-#endif /* MBEDTLS_GCM_C */
-#if defined(MBEDTLS_CCM_C)
-    if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
-    {
-        *olen = ilen;
-        return( mbedtls_ccm_encrypt_and_tag( ctx->cipher_ctx, ilen,
-                                     iv, iv_len, ad, ad_len, input, output,
-                                     tag, tag_len ) );
-    }
-#endif /* MBEDTLS_CCM_C */
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
-    {
-        /* ChachaPoly has fixed length nonce and MAC (tag) */
-        if ( ( iv_len != ctx->cipher_info->iv_size ) ||
-             ( tag_len != 16U ) )
-        {
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-        }
-
-        *olen = ilen;
-        return( mbedtls_chachapoly_encrypt_and_tag( ctx->cipher_ctx,
-                                ilen, iv, ad, ad_len, input, output, tag ) );
-    }
-#endif /* MBEDTLS_CHACHAPOLY_C */
-
-    return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-}
-
-/*
- * Packet-oriented encryption for AEAD modes: internal function used by
- * mbedtls_cipher_auth_encrypt_ext().
- */
-static int mbedtls_cipher_aead_decrypt( mbedtls_cipher_context_t *ctx,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t *olen,
-                         const unsigned char *tag, size_t tag_len )
-{
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-    if( ctx->psa_enabled == 1 )
-    {
-        /* As in the non-PSA case, we don't check that
-         * a key has been set. If not, the key slot will
-         * still be in its default state of 0, which is
-         * guaranteed to be invalid, hence the PSA-call
-         * below will gracefully fail. */
-        mbedtls_cipher_context_psa * const cipher_psa =
-            (mbedtls_cipher_context_psa *) ctx->cipher_ctx;
-
-        psa_status_t status;
-
-        /* PSA Crypto API always writes the authentication tag
-         * at the end of the encrypted message. */
-        if( input == NULL || tag != input + ilen )
-            return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-
-        status = psa_aead_decrypt( cipher_psa->slot,
-                                   cipher_psa->alg,
-                                   iv, iv_len,
-                                   ad, ad_len,
-                                   input, ilen + tag_len,
-                                   output, ilen, olen );
-        if( status == PSA_ERROR_INVALID_SIGNATURE )
-            return( MBEDTLS_ERR_CIPHER_AUTH_FAILED );
-        else if( status != PSA_SUCCESS )
-            return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-        return( 0 );
-    }
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_GCM_C)
-    if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
-    {
-        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-        *olen = ilen;
-        ret = mbedtls_gcm_auth_decrypt( (mbedtls_gcm_context *)ctx->cipher_ctx, ilen,
-                                iv, iv_len, ad, ad_len,
-                                tag, tag_len, input, output );
-
-        if( ret == MBEDTLS_ERR_GCM_AUTH_FAILED )
-            ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
-
-        return( ret );
-    }
-#endif /* MBEDTLS_GCM_C */
-#if defined(MBEDTLS_CCM_C)
-    if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
-    {
-        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-        *olen = ilen;
-        ret = mbedtls_ccm_auth_decrypt( ctx->cipher_ctx, ilen,
-                                iv, iv_len, ad, ad_len,
-                                input, output, tag, tag_len );
-
-        if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
-            ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
-
-        return( ret );
-    }
-#endif /* MBEDTLS_CCM_C */
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
-    {
-        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-        /* ChachaPoly has fixed length nonce and MAC (tag) */
-        if ( ( iv_len != ctx->cipher_info->iv_size ) ||
-             ( tag_len != 16U ) )
-        {
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-        }
-
-        *olen = ilen;
-        ret = mbedtls_chachapoly_auth_decrypt( ctx->cipher_ctx, ilen,
-                                iv, ad, ad_len, tag, input, output );
-
-        if( ret == MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED )
-            ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
-
-        return( ret );
-    }
-#endif /* MBEDTLS_CHACHAPOLY_C */
-
-    return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-}
-#endif /* MBEDTLS_CIPHER_MODE_AEAD */
-
-#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
-/*
- * Packet-oriented encryption for AEAD/NIST_KW: public function.
- */
-int mbedtls_cipher_auth_encrypt_ext( mbedtls_cipher_context_t *ctx,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t output_len,
-                         size_t *olen, size_t tag_len )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( iv_len == 0 || iv != NULL );
-    CIPHER_VALIDATE_RET( ad_len == 0 || ad != NULL );
-    CIPHER_VALIDATE_RET( ilen == 0 || input != NULL );
-    CIPHER_VALIDATE_RET( output != NULL );
-    CIPHER_VALIDATE_RET( olen != NULL );
-
-#if defined(MBEDTLS_NIST_KW_C)
-    if(
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-        ctx->psa_enabled == 0 &&
-#endif
-        ( MBEDTLS_MODE_KW == ctx->cipher_info->mode ||
-          MBEDTLS_MODE_KWP == ctx->cipher_info->mode ) )
-    {
-        mbedtls_nist_kw_mode_t mode = ( MBEDTLS_MODE_KW == ctx->cipher_info->mode ) ?
-                                        MBEDTLS_KW_MODE_KW : MBEDTLS_KW_MODE_KWP;
-
-        /* There is no iv, tag or ad associated with KW and KWP,
-         * so these length should be 0 as documented. */
-        if( iv_len != 0 || tag_len != 0 || ad_len != 0 )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        (void) iv;
-        (void) ad;
-
-        return( mbedtls_nist_kw_wrap( ctx->cipher_ctx, mode, input, ilen,
-                                      output, olen, output_len ) );
-    }
-#endif /* MBEDTLS_NIST_KW_C */
-
-#if defined(MBEDTLS_CIPHER_MODE_AEAD)
-    /* AEAD case: check length before passing on to shared function */
-    if( output_len < ilen + tag_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    int ret = mbedtls_cipher_aead_encrypt( ctx, iv, iv_len, ad, ad_len,
-                                       input, ilen, output, olen,
-                                       output + ilen, tag_len );
-    *olen += tag_len;
-    return( ret );
-#else
-    return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-#endif /* MBEDTLS_CIPHER_MODE_AEAD */
-}
-
-/*
- * Packet-oriented decryption for AEAD/NIST_KW: public function.
- */
-int mbedtls_cipher_auth_decrypt_ext( mbedtls_cipher_context_t *ctx,
-                         const unsigned char *iv, size_t iv_len,
-                         const unsigned char *ad, size_t ad_len,
-                         const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t output_len,
-                         size_t *olen, size_t tag_len )
-{
-    CIPHER_VALIDATE_RET( ctx != NULL );
-    CIPHER_VALIDATE_RET( iv_len == 0 || iv != NULL );
-    CIPHER_VALIDATE_RET( ad_len == 0 || ad != NULL );
-    CIPHER_VALIDATE_RET( ilen == 0 || input != NULL );
-    CIPHER_VALIDATE_RET( output_len == 0 || output != NULL );
-    CIPHER_VALIDATE_RET( olen != NULL );
-
-#if defined(MBEDTLS_NIST_KW_C)
-    if(
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-        ctx->psa_enabled == 0 &&
-#endif
-        ( MBEDTLS_MODE_KW == ctx->cipher_info->mode ||
-          MBEDTLS_MODE_KWP == ctx->cipher_info->mode ) )
-    {
-        mbedtls_nist_kw_mode_t mode = ( MBEDTLS_MODE_KW == ctx->cipher_info->mode ) ?
-                                        MBEDTLS_KW_MODE_KW : MBEDTLS_KW_MODE_KWP;
-
-        /* There is no iv, tag or ad associated with KW and KWP,
-         * so these length should be 0 as documented. */
-        if( iv_len != 0 || tag_len != 0 || ad_len != 0 )
-            return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-        (void) iv;
-        (void) ad;
-
-        return( mbedtls_nist_kw_unwrap( ctx->cipher_ctx, mode, input, ilen,
-                                        output, olen, output_len ) );
-    }
-#endif /* MBEDTLS_NIST_KW_C */
-
-#if defined(MBEDTLS_CIPHER_MODE_AEAD)
-    /* AEAD case: check length before passing on to shared function */
-    if( ilen < tag_len || output_len < ilen - tag_len )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    return( mbedtls_cipher_aead_decrypt( ctx, iv, iv_len, ad, ad_len,
-                                         input, ilen - tag_len, output, olen,
-                                         input + ilen - tag_len, tag_len ) );
-#else
-    return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
-#endif /* MBEDTLS_CIPHER_MODE_AEAD */
-}
-#endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */
-
-#endif /* MBEDTLS_CIPHER_C */
diff --git a/src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp b/src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp
deleted file mode 100644
index d7b2a3ce7..000000000
--- a/src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp
+++ /dev/null
@@ -1,2270 +0,0 @@
-/**
- * \file cipher_wrap.c
- *
- * \brief Generic cipher wrapper for mbed TLS
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_CIPHER_C)
-
-#include "cipher_wrap.h"
-#include "mbedtls/error.h"
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-#include "mbedtls/chachapoly.h"
-#endif
-
-#if defined(MBEDTLS_AES_C)
-#include "mbedtls/aes.h"
-#endif
-
-#if defined(MBEDTLS_CAMELLIA_C)
-#include "mbedtls/camellia.h"
-#endif
-
-#if defined(MBEDTLS_ARIA_C)
-#include "mbedtls/aria.h"
-#endif
-
-#if defined(MBEDTLS_DES_C)
-#include "mbedtls/des.h"
-#endif
-
-#if defined(MBEDTLS_CHACHA20_C)
-#include "mbedtls/chacha20.h"
-#endif
-
-#if defined(MBEDTLS_GCM_C)
-#include "mbedtls/gcm.h"
-#endif
-
-#if defined(MBEDTLS_CCM_C)
-#include "mbedtls/ccm.h"
-#endif
-
-#if defined(MBEDTLS_NIST_KW_C)
-#include "mbedtls/nist_kw.h"
-#endif
-
-#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
-#include <string.h>
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdlib.h>
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-#if defined(MBEDTLS_GCM_C)
-/* shared by all GCM ciphers */
-static void *gcm_ctx_alloc( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_gcm_context ) );
-
-    if( ctx != NULL )
-        mbedtls_gcm_init( (mbedtls_gcm_context *) ctx );
-
-    return( ctx );
-}
-
-static void gcm_ctx_free( void *ctx )
-{
-    mbedtls_gcm_free( (mbedtls_gcm_context *)ctx );
-    mbedtls_free( ctx );
-}
-#endif /* MBEDTLS_GCM_C */
-
-#if defined(MBEDTLS_CCM_C)
-/* shared by all CCM ciphers */
-static void *ccm_ctx_alloc( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ccm_context ) );
-
-    if( ctx != NULL )
-        mbedtls_ccm_init( (mbedtls_ccm_context *) ctx );
-
-    return( ctx );
-}
-
-static void ccm_ctx_free( void *ctx )
-{
-    mbedtls_ccm_free( ctx );
-    mbedtls_free( ctx );
-}
-#endif /* MBEDTLS_CCM_C */
-
-#if defined(MBEDTLS_AES_C)
-
-static int aes_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aes_crypt_ecb( (mbedtls_aes_context *) ctx, operation, input, output );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static int aes_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
-        unsigned char *iv, const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aes_crypt_cbc( (mbedtls_aes_context *) ctx, operation, length, iv, input,
-                          output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static int aes_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
-        size_t length, size_t *iv_off, unsigned char *iv,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aes_crypt_cfb128( (mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
-                             input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-static int aes_crypt_ofb_wrap( void *ctx, size_t length, size_t *iv_off,
-        unsigned char *iv, const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aes_crypt_ofb( (mbedtls_aes_context *) ctx, length, iv_off,
-                                    iv, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static int aes_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
-        unsigned char *nonce_counter, unsigned char *stream_block,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aes_crypt_ctr( (mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
-                          stream_block, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-static int aes_crypt_xts_wrap( void *ctx, mbedtls_operation_t operation,
-                               size_t length,
-                               const unsigned char data_unit[16],
-                               const unsigned char *input,
-                               unsigned char *output )
-{
-    mbedtls_aes_xts_context *xts_ctx = ctx;
-    int mode;
-
-    switch( operation )
-    {
-        case MBEDTLS_ENCRYPT:
-            mode = MBEDTLS_AES_ENCRYPT;
-            break;
-        case MBEDTLS_DECRYPT:
-            mode = MBEDTLS_AES_DECRYPT;
-            break;
-        default:
-            return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
-    }
-
-    return mbedtls_aes_crypt_xts( xts_ctx, mode, length,
-                                  data_unit, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-static int aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    return mbedtls_aes_setkey_dec( (mbedtls_aes_context *) ctx, key, key_bitlen );
-}
-
-static int aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    return mbedtls_aes_setkey_enc( (mbedtls_aes_context *) ctx, key, key_bitlen );
-}
-
-static void * aes_ctx_alloc( void )
-{
-    mbedtls_aes_context *aes = (mbedtls_aes_context *)mbedtls_calloc( 1, sizeof( mbedtls_aes_context ) );
-
-    if( aes == NULL )
-        return( NULL );
-
-    mbedtls_aes_init( aes );
-
-    return( aes );
-}
-
-static void aes_ctx_free( void *ctx )
-{
-    mbedtls_aes_free( (mbedtls_aes_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static const mbedtls_cipher_base_t aes_info = {
-    MBEDTLS_CIPHER_ID_AES,
-    aes_crypt_ecb_wrap,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    aes_crypt_cbc_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    aes_crypt_cfb128_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    aes_crypt_ofb_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    aes_crypt_ctr_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    aes_setkey_enc_wrap,
-    aes_setkey_dec_wrap,
-    aes_ctx_alloc,
-    aes_ctx_free
-};
-
-static const mbedtls_cipher_info_t aes_128_ecb_info = {
-    MBEDTLS_CIPHER_AES_128_ECB,
-    MBEDTLS_MODE_ECB,
-    128,
-    "AES-128-ECB",
-    0,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_ecb_info = {
-    MBEDTLS_CIPHER_AES_192_ECB,
-    MBEDTLS_MODE_ECB,
-    192,
-    "AES-192-ECB",
-    0,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_ecb_info = {
-    MBEDTLS_CIPHER_AES_256_ECB,
-    MBEDTLS_MODE_ECB,
-    256,
-    "AES-256-ECB",
-    0,
-    0,
-    16,
-    &aes_info
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const mbedtls_cipher_info_t aes_128_cbc_info = {
-    MBEDTLS_CIPHER_AES_128_CBC,
-    MBEDTLS_MODE_CBC,
-    128,
-    "AES-128-CBC",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_cbc_info = {
-    MBEDTLS_CIPHER_AES_192_CBC,
-    MBEDTLS_MODE_CBC,
-    192,
-    "AES-192-CBC",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_cbc_info = {
-    MBEDTLS_CIPHER_AES_256_CBC,
-    MBEDTLS_MODE_CBC,
-    256,
-    "AES-256-CBC",
-    16,
-    0,
-    16,
-    &aes_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static const mbedtls_cipher_info_t aes_128_cfb128_info = {
-    MBEDTLS_CIPHER_AES_128_CFB128,
-    MBEDTLS_MODE_CFB,
-    128,
-    "AES-128-CFB128",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_cfb128_info = {
-    MBEDTLS_CIPHER_AES_192_CFB128,
-    MBEDTLS_MODE_CFB,
-    192,
-    "AES-192-CFB128",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_cfb128_info = {
-    MBEDTLS_CIPHER_AES_256_CFB128,
-    MBEDTLS_MODE_CFB,
-    256,
-    "AES-256-CFB128",
-    16,
-    0,
-    16,
-    &aes_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-static const mbedtls_cipher_info_t aes_128_ofb_info = {
-    MBEDTLS_CIPHER_AES_128_OFB,
-    MBEDTLS_MODE_OFB,
-    128,
-    "AES-128-OFB",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_ofb_info = {
-    MBEDTLS_CIPHER_AES_192_OFB,
-    MBEDTLS_MODE_OFB,
-    192,
-    "AES-192-OFB",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_ofb_info = {
-    MBEDTLS_CIPHER_AES_256_OFB,
-    MBEDTLS_MODE_OFB,
-    256,
-    "AES-256-OFB",
-    16,
-    0,
-    16,
-    &aes_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_OFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static const mbedtls_cipher_info_t aes_128_ctr_info = {
-    MBEDTLS_CIPHER_AES_128_CTR,
-    MBEDTLS_MODE_CTR,
-    128,
-    "AES-128-CTR",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_ctr_info = {
-    MBEDTLS_CIPHER_AES_192_CTR,
-    MBEDTLS_MODE_CTR,
-    192,
-    "AES-192-CTR",
-    16,
-    0,
-    16,
-    &aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_ctr_info = {
-    MBEDTLS_CIPHER_AES_256_CTR,
-    MBEDTLS_MODE_CTR,
-    256,
-    "AES-256-CTR",
-    16,
-    0,
-    16,
-    &aes_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-static int xts_aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
-                                    unsigned int key_bitlen )
-{
-    mbedtls_aes_xts_context *xts_ctx = ctx;
-    return( mbedtls_aes_xts_setkey_enc( xts_ctx, key, key_bitlen ) );
-}
-
-static int xts_aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
-                                    unsigned int key_bitlen )
-{
-    mbedtls_aes_xts_context *xts_ctx = ctx;
-    return( mbedtls_aes_xts_setkey_dec( xts_ctx, key, key_bitlen ) );
-}
-
-static void *xts_aes_ctx_alloc( void )
-{
-    mbedtls_aes_xts_context *xts_ctx = mbedtls_calloc( 1, sizeof( *xts_ctx ) );
-
-    if( xts_ctx != NULL )
-        mbedtls_aes_xts_init( xts_ctx );
-
-    return( xts_ctx );
-}
-
-static void xts_aes_ctx_free( void *ctx )
-{
-    mbedtls_aes_xts_context *xts_ctx = ctx;
-
-    if( xts_ctx == NULL )
-        return;
-
-    mbedtls_aes_xts_free( xts_ctx );
-    mbedtls_free( xts_ctx );
-}
-
-static const mbedtls_cipher_base_t xts_aes_info = {
-    MBEDTLS_CIPHER_ID_AES,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    aes_crypt_xts_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    xts_aes_setkey_enc_wrap,
-    xts_aes_setkey_dec_wrap,
-    xts_aes_ctx_alloc,
-    xts_aes_ctx_free
-};
-
-static const mbedtls_cipher_info_t aes_128_xts_info = {
-    MBEDTLS_CIPHER_AES_128_XTS,
-    MBEDTLS_MODE_XTS,
-    256,
-    "AES-128-XTS",
-    16,
-    0,
-    16,
-    &xts_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_xts_info = {
-    MBEDTLS_CIPHER_AES_256_XTS,
-    MBEDTLS_MODE_XTS,
-    512,
-    "AES-256-XTS",
-    16,
-    0,
-    16,
-    &xts_aes_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_XTS */
-
-#if defined(MBEDTLS_GCM_C)
-static int gcm_aes_setkey_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
-                     key, key_bitlen );
-}
-
-static const mbedtls_cipher_base_t gcm_aes_info = {
-    MBEDTLS_CIPHER_ID_AES,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    gcm_aes_setkey_wrap,
-    gcm_aes_setkey_wrap,
-    gcm_ctx_alloc,
-    gcm_ctx_free,
-};
-
-static const mbedtls_cipher_info_t aes_128_gcm_info = {
-    MBEDTLS_CIPHER_AES_128_GCM,
-    MBEDTLS_MODE_GCM,
-    128,
-    "AES-128-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_gcm_info = {
-    MBEDTLS_CIPHER_AES_192_GCM,
-    MBEDTLS_MODE_GCM,
-    192,
-    "AES-192-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_gcm_info = {
-    MBEDTLS_CIPHER_AES_256_GCM,
-    MBEDTLS_MODE_GCM,
-    256,
-    "AES-256-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_aes_info
-};
-#endif /* MBEDTLS_GCM_C */
-
-#if defined(MBEDTLS_CCM_C)
-static int ccm_aes_setkey_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
-                     key, key_bitlen );
-}
-
-static const mbedtls_cipher_base_t ccm_aes_info = {
-    MBEDTLS_CIPHER_ID_AES,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    ccm_aes_setkey_wrap,
-    ccm_aes_setkey_wrap,
-    ccm_ctx_alloc,
-    ccm_ctx_free,
-};
-
-static const mbedtls_cipher_info_t aes_128_ccm_info = {
-    MBEDTLS_CIPHER_AES_128_CCM,
-    MBEDTLS_MODE_CCM,
-    128,
-    "AES-128-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_ccm_info = {
-    MBEDTLS_CIPHER_AES_192_CCM,
-    MBEDTLS_MODE_CCM,
-    192,
-    "AES-192-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_ccm_info = {
-    MBEDTLS_CIPHER_AES_256_CCM,
-    MBEDTLS_MODE_CCM,
-    256,
-    "AES-256-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_128_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    128,
-    "AES-128-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    192,
-    "AES-192-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    256,
-    "AES-256-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aes_info
-};
-#endif /* MBEDTLS_CCM_C */
-
-#endif /* MBEDTLS_AES_C */
-
-#if defined(MBEDTLS_CAMELLIA_C)
-
-static int camellia_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_camellia_crypt_ecb( (mbedtls_camellia_context *) ctx, operation, input,
-                               output );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static int camellia_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
-        size_t length, unsigned char *iv,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_camellia_crypt_cbc( (mbedtls_camellia_context *) ctx, operation, length, iv,
-                               input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static int camellia_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
-        size_t length, size_t *iv_off, unsigned char *iv,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_camellia_crypt_cfb128( (mbedtls_camellia_context *) ctx, operation, length,
-                                  iv_off, iv, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static int camellia_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
-        unsigned char *nonce_counter, unsigned char *stream_block,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_camellia_crypt_ctr( (mbedtls_camellia_context *) ctx, length, nc_off,
-                               nonce_counter, stream_block, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-static int camellia_setkey_dec_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_camellia_setkey_dec( (mbedtls_camellia_context *) ctx, key, key_bitlen );
-}
-
-static int camellia_setkey_enc_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_camellia_setkey_enc( (mbedtls_camellia_context *) ctx, key, key_bitlen );
-}
-
-static void * camellia_ctx_alloc( void )
-{
-    mbedtls_camellia_context *ctx;
-    ctx = (mbedtls_camellia_context *)mbedtls_calloc( 1, sizeof( mbedtls_camellia_context ) );
-
-    if( ctx == NULL )
-        return( NULL );
-
-    mbedtls_camellia_init( ctx );
-
-    return( ctx );
-}
-
-static void camellia_ctx_free( void *ctx )
-{
-    mbedtls_camellia_free( (mbedtls_camellia_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static const mbedtls_cipher_base_t camellia_info = {
-    MBEDTLS_CIPHER_ID_CAMELLIA,
-    camellia_crypt_ecb_wrap,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    camellia_crypt_cbc_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    camellia_crypt_cfb128_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    camellia_crypt_ctr_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    camellia_setkey_enc_wrap,
-    camellia_setkey_dec_wrap,
-    camellia_ctx_alloc,
-    camellia_ctx_free
-};
-
-static const mbedtls_cipher_info_t camellia_128_ecb_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_ECB,
-    MBEDTLS_MODE_ECB,
-    128,
-    "CAMELLIA-128-ECB",
-    0,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_ecb_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_ECB,
-    MBEDTLS_MODE_ECB,
-    192,
-    "CAMELLIA-192-ECB",
-    0,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_ecb_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_ECB,
-    MBEDTLS_MODE_ECB,
-    256,
-    "CAMELLIA-256-ECB",
-    0,
-    0,
-    16,
-    &camellia_info
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const mbedtls_cipher_info_t camellia_128_cbc_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_CBC,
-    MBEDTLS_MODE_CBC,
-    128,
-    "CAMELLIA-128-CBC",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_cbc_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_CBC,
-    MBEDTLS_MODE_CBC,
-    192,
-    "CAMELLIA-192-CBC",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_cbc_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_CBC,
-    MBEDTLS_MODE_CBC,
-    256,
-    "CAMELLIA-256-CBC",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static const mbedtls_cipher_info_t camellia_128_cfb128_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
-    MBEDTLS_MODE_CFB,
-    128,
-    "CAMELLIA-128-CFB128",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_cfb128_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
-    MBEDTLS_MODE_CFB,
-    192,
-    "CAMELLIA-192-CFB128",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_cfb128_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
-    MBEDTLS_MODE_CFB,
-    256,
-    "CAMELLIA-256-CFB128",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static const mbedtls_cipher_info_t camellia_128_ctr_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_CTR,
-    MBEDTLS_MODE_CTR,
-    128,
-    "CAMELLIA-128-CTR",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_ctr_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_CTR,
-    MBEDTLS_MODE_CTR,
-    192,
-    "CAMELLIA-192-CTR",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_ctr_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_CTR,
-    MBEDTLS_MODE_CTR,
-    256,
-    "CAMELLIA-256-CTR",
-    16,
-    0,
-    16,
-    &camellia_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_GCM_C)
-static int gcm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
-                     key, key_bitlen );
-}
-
-static const mbedtls_cipher_base_t gcm_camellia_info = {
-    MBEDTLS_CIPHER_ID_CAMELLIA,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    gcm_camellia_setkey_wrap,
-    gcm_camellia_setkey_wrap,
-    gcm_ctx_alloc,
-    gcm_ctx_free,
-};
-
-static const mbedtls_cipher_info_t camellia_128_gcm_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_GCM,
-    MBEDTLS_MODE_GCM,
-    128,
-    "CAMELLIA-128-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_gcm_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_GCM,
-    MBEDTLS_MODE_GCM,
-    192,
-    "CAMELLIA-192-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_gcm_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_GCM,
-    MBEDTLS_MODE_GCM,
-    256,
-    "CAMELLIA-256-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_camellia_info
-};
-#endif /* MBEDTLS_GCM_C */
-
-#if defined(MBEDTLS_CCM_C)
-static int ccm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
-                     key, key_bitlen );
-}
-
-static const mbedtls_cipher_base_t ccm_camellia_info = {
-    MBEDTLS_CIPHER_ID_CAMELLIA,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    ccm_camellia_setkey_wrap,
-    ccm_camellia_setkey_wrap,
-    ccm_ctx_alloc,
-    ccm_ctx_free,
-};
-
-static const mbedtls_cipher_info_t camellia_128_ccm_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_CCM,
-    MBEDTLS_MODE_CCM,
-    128,
-    "CAMELLIA-128-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_ccm_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_CCM,
-    MBEDTLS_MODE_CCM,
-    192,
-    "CAMELLIA-192-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_ccm_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_CCM,
-    MBEDTLS_MODE_CCM,
-    256,
-    "CAMELLIA-256-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_128_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    128,
-    "CAMELLIA-128-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_192_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    192,
-    "CAMELLIA-192-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_camellia_info
-};
-
-static const mbedtls_cipher_info_t camellia_256_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    256,
-    "CAMELLIA-256-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_camellia_info
-};
-#endif /* MBEDTLS_CCM_C */
-
-#endif /* MBEDTLS_CAMELLIA_C */
-
-#if defined(MBEDTLS_ARIA_C)
-
-static int aria_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
-        const unsigned char *input, unsigned char *output )
-{
-    (void) operation;
-    return mbedtls_aria_crypt_ecb( (mbedtls_aria_context *) ctx, input,
-                               output );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static int aria_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
-        size_t length, unsigned char *iv,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aria_crypt_cbc( (mbedtls_aria_context *) ctx, operation, length, iv,
-                               input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static int aria_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
-        size_t length, size_t *iv_off, unsigned char *iv,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aria_crypt_cfb128( (mbedtls_aria_context *) ctx, operation, length,
-                                  iv_off, iv, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static int aria_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
-        unsigned char *nonce_counter, unsigned char *stream_block,
-        const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_aria_crypt_ctr( (mbedtls_aria_context *) ctx, length, nc_off,
-                               nonce_counter, stream_block, input, output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-static int aria_setkey_dec_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_aria_setkey_dec( (mbedtls_aria_context *) ctx, key, key_bitlen );
-}
-
-static int aria_setkey_enc_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_aria_setkey_enc( (mbedtls_aria_context *) ctx, key, key_bitlen );
-}
-
-static void * aria_ctx_alloc( void )
-{
-    mbedtls_aria_context *ctx;
-    ctx = (mbedtls_aria_context *)mbedtls_calloc( 1, sizeof( mbedtls_aria_context ) );
-
-    if( ctx == NULL )
-        return( NULL );
-
-    mbedtls_aria_init( ctx );
-
-    return( ctx );
-}
-
-static void aria_ctx_free( void *ctx )
-{
-    mbedtls_aria_free( (mbedtls_aria_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static const mbedtls_cipher_base_t aria_info = {
-    MBEDTLS_CIPHER_ID_ARIA,
-    aria_crypt_ecb_wrap,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    aria_crypt_cbc_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    aria_crypt_cfb128_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    aria_crypt_ctr_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    aria_setkey_enc_wrap,
-    aria_setkey_dec_wrap,
-    aria_ctx_alloc,
-    aria_ctx_free
-};
-
-static const mbedtls_cipher_info_t aria_128_ecb_info = {
-    MBEDTLS_CIPHER_ARIA_128_ECB,
-    MBEDTLS_MODE_ECB,
-    128,
-    "ARIA-128-ECB",
-    0,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_ecb_info = {
-    MBEDTLS_CIPHER_ARIA_192_ECB,
-    MBEDTLS_MODE_ECB,
-    192,
-    "ARIA-192-ECB",
-    0,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_ecb_info = {
-    MBEDTLS_CIPHER_ARIA_256_ECB,
-    MBEDTLS_MODE_ECB,
-    256,
-    "ARIA-256-ECB",
-    0,
-    0,
-    16,
-    &aria_info
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const mbedtls_cipher_info_t aria_128_cbc_info = {
-    MBEDTLS_CIPHER_ARIA_128_CBC,
-    MBEDTLS_MODE_CBC,
-    128,
-    "ARIA-128-CBC",
-    16,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_cbc_info = {
-    MBEDTLS_CIPHER_ARIA_192_CBC,
-    MBEDTLS_MODE_CBC,
-    192,
-    "ARIA-192-CBC",
-    16,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_cbc_info = {
-    MBEDTLS_CIPHER_ARIA_256_CBC,
-    MBEDTLS_MODE_CBC,
-    256,
-    "ARIA-256-CBC",
-    16,
-    0,
-    16,
-    &aria_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-static const mbedtls_cipher_info_t aria_128_cfb128_info = {
-    MBEDTLS_CIPHER_ARIA_128_CFB128,
-    MBEDTLS_MODE_CFB,
-    128,
-    "ARIA-128-CFB128",
-    16,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_cfb128_info = {
-    MBEDTLS_CIPHER_ARIA_192_CFB128,
-    MBEDTLS_MODE_CFB,
-    192,
-    "ARIA-192-CFB128",
-    16,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_cfb128_info = {
-    MBEDTLS_CIPHER_ARIA_256_CFB128,
-    MBEDTLS_MODE_CFB,
-    256,
-    "ARIA-256-CFB128",
-    16,
-    0,
-    16,
-    &aria_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CFB */
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-static const mbedtls_cipher_info_t aria_128_ctr_info = {
-    MBEDTLS_CIPHER_ARIA_128_CTR,
-    MBEDTLS_MODE_CTR,
-    128,
-    "ARIA-128-CTR",
-    16,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_ctr_info = {
-    MBEDTLS_CIPHER_ARIA_192_CTR,
-    MBEDTLS_MODE_CTR,
-    192,
-    "ARIA-192-CTR",
-    16,
-    0,
-    16,
-    &aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_ctr_info = {
-    MBEDTLS_CIPHER_ARIA_256_CTR,
-    MBEDTLS_MODE_CTR,
-    256,
-    "ARIA-256-CTR",
-    16,
-    0,
-    16,
-    &aria_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CTR */
-
-#if defined(MBEDTLS_GCM_C)
-static int gcm_aria_setkey_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
-                     key, key_bitlen );
-}
-
-static const mbedtls_cipher_base_t gcm_aria_info = {
-    MBEDTLS_CIPHER_ID_ARIA,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    gcm_aria_setkey_wrap,
-    gcm_aria_setkey_wrap,
-    gcm_ctx_alloc,
-    gcm_ctx_free,
-};
-
-static const mbedtls_cipher_info_t aria_128_gcm_info = {
-    MBEDTLS_CIPHER_ARIA_128_GCM,
-    MBEDTLS_MODE_GCM,
-    128,
-    "ARIA-128-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_gcm_info = {
-    MBEDTLS_CIPHER_ARIA_192_GCM,
-    MBEDTLS_MODE_GCM,
-    192,
-    "ARIA-192-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_gcm_info = {
-    MBEDTLS_CIPHER_ARIA_256_GCM,
-    MBEDTLS_MODE_GCM,
-    256,
-    "ARIA-256-GCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &gcm_aria_info
-};
-#endif /* MBEDTLS_GCM_C */
-
-#if defined(MBEDTLS_CCM_C)
-static int ccm_aria_setkey_wrap( void *ctx, const unsigned char *key,
-                                     unsigned int key_bitlen )
-{
-    return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
-                     key, key_bitlen );
-}
-
-static const mbedtls_cipher_base_t ccm_aria_info = {
-    MBEDTLS_CIPHER_ID_ARIA,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    ccm_aria_setkey_wrap,
-    ccm_aria_setkey_wrap,
-    ccm_ctx_alloc,
-    ccm_ctx_free,
-};
-
-static const mbedtls_cipher_info_t aria_128_ccm_info = {
-    MBEDTLS_CIPHER_ARIA_128_CCM,
-    MBEDTLS_MODE_CCM,
-    128,
-    "ARIA-128-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_ccm_info = {
-    MBEDTLS_CIPHER_ARIA_192_CCM,
-    MBEDTLS_MODE_CCM,
-    192,
-    "ARIA-192-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_ccm_info = {
-    MBEDTLS_CIPHER_ARIA_256_CCM,
-    MBEDTLS_MODE_CCM,
-    256,
-    "ARIA-256-CCM",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_128_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    128,
-    "ARIA-128-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_192_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    192,
-    "ARIA-192-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aria_info
-};
-
-static const mbedtls_cipher_info_t aria_256_ccm_star_no_tag_info = {
-    MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG,
-    MBEDTLS_MODE_CCM_STAR_NO_TAG,
-    256,
-    "ARIA-256-CCM*-NO-TAG",
-    12,
-    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
-    16,
-    &ccm_aria_info
-};
-#endif /* MBEDTLS_CCM_C */
-
-#endif /* MBEDTLS_ARIA_C */
-
-#if defined(MBEDTLS_DES_C)
-
-static int des_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
-        const unsigned char *input, unsigned char *output )
-{
-    ((void) operation);
-    return mbedtls_des_crypt_ecb( (mbedtls_des_context *) ctx, input, output );
-}
-
-static int des3_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
-        const unsigned char *input, unsigned char *output )
-{
-    ((void) operation);
-    return mbedtls_des3_crypt_ecb( (mbedtls_des3_context *) ctx, input, output );
-}
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static int des_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
-        unsigned char *iv, const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_des_crypt_cbc( (mbedtls_des_context *) ctx, operation, length, iv, input,
-                          output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static int des3_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
-        unsigned char *iv, const unsigned char *input, unsigned char *output )
-{
-    return mbedtls_des3_crypt_cbc( (mbedtls_des3_context *) ctx, operation, length, iv, input,
-                           output );
-}
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-static int des_setkey_dec_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    ((void) key_bitlen);
-
-    return mbedtls_des_setkey_dec( (mbedtls_des_context *) ctx, key );
-}
-
-static int des_setkey_enc_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    ((void) key_bitlen);
-
-    return mbedtls_des_setkey_enc( (mbedtls_des_context *) ctx, key );
-}
-
-static int des3_set2key_dec_wrap( void *ctx, const unsigned char *key,
-                                  unsigned int key_bitlen )
-{
-    ((void) key_bitlen);
-
-    return mbedtls_des3_set2key_dec( (mbedtls_des3_context *) ctx, key );
-}
-
-static int des3_set2key_enc_wrap( void *ctx, const unsigned char *key,
-                                  unsigned int key_bitlen )
-{
-    ((void) key_bitlen);
-
-    return mbedtls_des3_set2key_enc( (mbedtls_des3_context *) ctx, key );
-}
-
-static int des3_set3key_dec_wrap( void *ctx, const unsigned char *key,
-                                  unsigned int key_bitlen )
-{
-    ((void) key_bitlen);
-
-    return mbedtls_des3_set3key_dec( (mbedtls_des3_context *) ctx, key );
-}
-
-static int des3_set3key_enc_wrap( void *ctx, const unsigned char *key,
-                                  unsigned int key_bitlen )
-{
-    ((void) key_bitlen);
-
-    return mbedtls_des3_set3key_enc( (mbedtls_des3_context *) ctx, key );
-}
-
-static void * des_ctx_alloc( void )
-{
-    mbedtls_des_context *des = mbedtls_calloc( 1, sizeof( mbedtls_des_context ) );
-
-    if( des == NULL )
-        return( NULL );
-
-    mbedtls_des_init( des );
-
-    return( des );
-}
-
-static void des_ctx_free( void *ctx )
-{
-    mbedtls_des_free( (mbedtls_des_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static void * des3_ctx_alloc( void )
-{
-    mbedtls_des3_context *des3;
-    des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
-
-    if( des3 == NULL )
-        return( NULL );
-
-    mbedtls_des3_init( des3 );
-
-    return( des3 );
-}
-
-static void des3_ctx_free( void *ctx )
-{
-    mbedtls_des3_free( (mbedtls_des3_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static const mbedtls_cipher_base_t des_info = {
-    MBEDTLS_CIPHER_ID_DES,
-    des_crypt_ecb_wrap,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    des_crypt_cbc_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    des_setkey_enc_wrap,
-    des_setkey_dec_wrap,
-    des_ctx_alloc,
-    des_ctx_free
-};
-
-static const mbedtls_cipher_info_t des_ecb_info = {
-    MBEDTLS_CIPHER_DES_ECB,
-    MBEDTLS_MODE_ECB,
-    MBEDTLS_KEY_LENGTH_DES,
-    "DES-ECB",
-    0,
-    0,
-    8,
-    &des_info
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const mbedtls_cipher_info_t des_cbc_info = {
-    MBEDTLS_CIPHER_DES_CBC,
-    MBEDTLS_MODE_CBC,
-    MBEDTLS_KEY_LENGTH_DES,
-    "DES-CBC",
-    8,
-    0,
-    8,
-    &des_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-static const mbedtls_cipher_base_t des_ede_info = {
-    MBEDTLS_CIPHER_ID_DES,
-    des3_crypt_ecb_wrap,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    des3_crypt_cbc_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    des3_set2key_enc_wrap,
-    des3_set2key_dec_wrap,
-    des3_ctx_alloc,
-    des3_ctx_free
-};
-
-static const mbedtls_cipher_info_t des_ede_ecb_info = {
-    MBEDTLS_CIPHER_DES_EDE_ECB,
-    MBEDTLS_MODE_ECB,
-    MBEDTLS_KEY_LENGTH_DES_EDE,
-    "DES-EDE-ECB",
-    0,
-    0,
-    8,
-    &des_ede_info
-};
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const mbedtls_cipher_info_t des_ede_cbc_info = {
-    MBEDTLS_CIPHER_DES_EDE_CBC,
-    MBEDTLS_MODE_CBC,
-    MBEDTLS_KEY_LENGTH_DES_EDE,
-    "DES-EDE-CBC",
-    8,
-    0,
-    8,
-    &des_ede_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-
-static const mbedtls_cipher_base_t des_ede3_info = {
-    MBEDTLS_CIPHER_ID_3DES,
-    des3_crypt_ecb_wrap,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    des3_crypt_cbc_wrap,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    des3_set3key_enc_wrap,
-    des3_set3key_dec_wrap,
-    des3_ctx_alloc,
-    des3_ctx_free
-};
-
-static const mbedtls_cipher_info_t des_ede3_ecb_info = {
-    MBEDTLS_CIPHER_DES_EDE3_ECB,
-    MBEDTLS_MODE_ECB,
-    MBEDTLS_KEY_LENGTH_DES_EDE3,
-    "DES-EDE3-ECB",
-    0,
-    0,
-    8,
-    &des_ede3_info
-};
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const mbedtls_cipher_info_t des_ede3_cbc_info = {
-    MBEDTLS_CIPHER_DES_EDE3_CBC,
-    MBEDTLS_MODE_CBC,
-    MBEDTLS_KEY_LENGTH_DES_EDE3,
-    "DES-EDE3-CBC",
-    8,
-    0,
-    8,
-    &des_ede3_info
-};
-#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#endif /* MBEDTLS_DES_C */
-
-#if defined(MBEDTLS_CHACHA20_C)
-
-static int chacha20_setkey_wrap( void *ctx, const unsigned char *key,
-                                 unsigned int key_bitlen )
-{
-    if( key_bitlen != 256U )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    if ( 0 != mbedtls_chacha20_setkey( (mbedtls_chacha20_context*)ctx, key ) )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    return( 0 );
-}
-
-static int chacha20_stream_wrap( void *ctx,  size_t length,
-                                 const unsigned char *input,
-                                 unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    ret = mbedtls_chacha20_update( ctx, length, input, output );
-    if( ret == MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    return( ret );
-}
-
-static void * chacha20_ctx_alloc( void )
-{
-    mbedtls_chacha20_context *ctx;
-    ctx = mbedtls_calloc( 1, sizeof( mbedtls_chacha20_context ) );
-
-    if( ctx == NULL )
-        return( NULL );
-
-    mbedtls_chacha20_init( ctx );
-
-    return( ctx );
-}
-
-static void chacha20_ctx_free( void *ctx )
-{
-    mbedtls_chacha20_free( (mbedtls_chacha20_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static const mbedtls_cipher_base_t chacha20_base_info = {
-    MBEDTLS_CIPHER_ID_CHACHA20,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    chacha20_stream_wrap,
-#endif
-    chacha20_setkey_wrap,
-    chacha20_setkey_wrap,
-    chacha20_ctx_alloc,
-    chacha20_ctx_free
-};
-static const mbedtls_cipher_info_t chacha20_info = {
-    MBEDTLS_CIPHER_CHACHA20,
-    MBEDTLS_MODE_STREAM,
-    256,
-    "CHACHA20",
-    12,
-    0,
-    1,
-    &chacha20_base_info
-};
-#endif /* MBEDTLS_CHACHA20_C */
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-
-static int chachapoly_setkey_wrap( void *ctx,
-                                   const unsigned char *key,
-                                   unsigned int key_bitlen )
-{
-    if( key_bitlen != 256U )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    if ( 0 != mbedtls_chachapoly_setkey( (mbedtls_chachapoly_context*)ctx, key ) )
-        return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
-
-    return( 0 );
-}
-
-static void * chachapoly_ctx_alloc( void )
-{
-    mbedtls_chachapoly_context *ctx;
-    ctx = mbedtls_calloc( 1, sizeof( mbedtls_chachapoly_context ) );
-
-    if( ctx == NULL )
-        return( NULL );
-
-    mbedtls_chachapoly_init( ctx );
-
-    return( ctx );
-}
-
-static void chachapoly_ctx_free( void *ctx )
-{
-    mbedtls_chachapoly_free( (mbedtls_chachapoly_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static const mbedtls_cipher_base_t chachapoly_base_info = {
-    MBEDTLS_CIPHER_ID_CHACHA20,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    chachapoly_setkey_wrap,
-    chachapoly_setkey_wrap,
-    chachapoly_ctx_alloc,
-    chachapoly_ctx_free
-};
-static const mbedtls_cipher_info_t chachapoly_info = {
-    MBEDTLS_CIPHER_CHACHA20_POLY1305,
-    MBEDTLS_MODE_CHACHAPOLY,
-    256,
-    "CHACHA20-POLY1305",
-    12,
-    0,
-    1,
-    &chachapoly_base_info
-};
-#endif /* MBEDTLS_CHACHAPOLY_C */
-
-#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
-static int null_crypt_stream( void *ctx, size_t length,
-                              const unsigned char *input,
-                              unsigned char *output )
-{
-    ((void) ctx);
-    memmove( output, input, length );
-    return( 0 );
-}
-
-static int null_setkey( void *ctx, const unsigned char *key,
-                        unsigned int key_bitlen )
-{
-    ((void) ctx);
-    ((void) key);
-    ((void) key_bitlen);
-
-    return( 0 );
-}
-
-static void * null_ctx_alloc( void )
-{
-    return( (void *) 1 );
-}
-
-static void null_ctx_free( void *ctx )
-{
-    ((void) ctx);
-}
-
-static const mbedtls_cipher_base_t null_base_info = {
-    MBEDTLS_CIPHER_ID_NULL,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    null_crypt_stream,
-#endif
-    null_setkey,
-    null_setkey,
-    null_ctx_alloc,
-    null_ctx_free
-};
-
-static const mbedtls_cipher_info_t null_cipher_info = {
-    MBEDTLS_CIPHER_NULL,
-    MBEDTLS_MODE_STREAM,
-    0,
-    "NULL",
-    0,
-    0,
-    1,
-    &null_base_info
-};
-#endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
-
-#if defined(MBEDTLS_NIST_KW_C)
-static void *kw_ctx_alloc( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_nist_kw_context ) );
-
-    if( ctx != NULL )
-        mbedtls_nist_kw_init( (mbedtls_nist_kw_context *) ctx );
-
-    return( ctx );
-}
-
-static void kw_ctx_free( void *ctx )
-{
-    mbedtls_nist_kw_free( ctx );
-    mbedtls_free( ctx );
-}
-
-static int kw_aes_setkey_wrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-    return mbedtls_nist_kw_setkey( (mbedtls_nist_kw_context *) ctx,
-                                   MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 1 );
-}
-
-static int kw_aes_setkey_unwrap( void *ctx, const unsigned char *key,
-                                unsigned int key_bitlen )
-{
-   return mbedtls_nist_kw_setkey( (mbedtls_nist_kw_context *) ctx,
-                                  MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 0 );
-}
-
-static const mbedtls_cipher_base_t kw_aes_info = {
-    MBEDTLS_CIPHER_ID_AES,
-    NULL,
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    NULL,
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    NULL,
-#endif
-    kw_aes_setkey_wrap,
-    kw_aes_setkey_unwrap,
-    kw_ctx_alloc,
-    kw_ctx_free,
-};
-
-static const mbedtls_cipher_info_t aes_128_nist_kw_info = {
-    MBEDTLS_CIPHER_AES_128_KW,
-    MBEDTLS_MODE_KW,
-    128,
-    "AES-128-KW",
-    0,
-    0,
-    16,
-    &kw_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_nist_kw_info = {
-    MBEDTLS_CIPHER_AES_192_KW,
-    MBEDTLS_MODE_KW,
-    192,
-    "AES-192-KW",
-    0,
-    0,
-    16,
-    &kw_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_nist_kw_info = {
-    MBEDTLS_CIPHER_AES_256_KW,
-    MBEDTLS_MODE_KW,
-    256,
-    "AES-256-KW",
-    0,
-    0,
-    16,
-    &kw_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_128_nist_kwp_info = {
-    MBEDTLS_CIPHER_AES_128_KWP,
-    MBEDTLS_MODE_KWP,
-    128,
-    "AES-128-KWP",
-    0,
-    0,
-    16,
-    &kw_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_192_nist_kwp_info = {
-    MBEDTLS_CIPHER_AES_192_KWP,
-    MBEDTLS_MODE_KWP,
-    192,
-    "AES-192-KWP",
-    0,
-    0,
-    16,
-    &kw_aes_info
-};
-
-static const mbedtls_cipher_info_t aes_256_nist_kwp_info = {
-    MBEDTLS_CIPHER_AES_256_KWP,
-    MBEDTLS_MODE_KWP,
-    256,
-    "AES-256-KWP",
-    0,
-    0,
-    16,
-    &kw_aes_info
-};
-#endif /* MBEDTLS_NIST_KW_C */
-
-const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
-{
-#if defined(MBEDTLS_AES_C)
-    { MBEDTLS_CIPHER_AES_128_ECB,          &aes_128_ecb_info },
-    { MBEDTLS_CIPHER_AES_192_ECB,          &aes_192_ecb_info },
-    { MBEDTLS_CIPHER_AES_256_ECB,          &aes_256_ecb_info },
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    { MBEDTLS_CIPHER_AES_128_CBC,          &aes_128_cbc_info },
-    { MBEDTLS_CIPHER_AES_192_CBC,          &aes_192_cbc_info },
-    { MBEDTLS_CIPHER_AES_256_CBC,          &aes_256_cbc_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    { MBEDTLS_CIPHER_AES_128_CFB128,       &aes_128_cfb128_info },
-    { MBEDTLS_CIPHER_AES_192_CFB128,       &aes_192_cfb128_info },
-    { MBEDTLS_CIPHER_AES_256_CFB128,       &aes_256_cfb128_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    { MBEDTLS_CIPHER_AES_128_OFB,          &aes_128_ofb_info },
-    { MBEDTLS_CIPHER_AES_192_OFB,          &aes_192_ofb_info },
-    { MBEDTLS_CIPHER_AES_256_OFB,          &aes_256_ofb_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    { MBEDTLS_CIPHER_AES_128_CTR,          &aes_128_ctr_info },
-    { MBEDTLS_CIPHER_AES_192_CTR,          &aes_192_ctr_info },
-    { MBEDTLS_CIPHER_AES_256_CTR,          &aes_256_ctr_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    { MBEDTLS_CIPHER_AES_128_XTS,          &aes_128_xts_info },
-    { MBEDTLS_CIPHER_AES_256_XTS,          &aes_256_xts_info },
-#endif
-#if defined(MBEDTLS_GCM_C)
-    { MBEDTLS_CIPHER_AES_128_GCM,          &aes_128_gcm_info },
-    { MBEDTLS_CIPHER_AES_192_GCM,          &aes_192_gcm_info },
-    { MBEDTLS_CIPHER_AES_256_GCM,          &aes_256_gcm_info },
-#endif
-#if defined(MBEDTLS_CCM_C)
-    { MBEDTLS_CIPHER_AES_128_CCM,          &aes_128_ccm_info },
-    { MBEDTLS_CIPHER_AES_192_CCM,          &aes_192_ccm_info },
-    { MBEDTLS_CIPHER_AES_256_CCM,          &aes_256_ccm_info },
-    { MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG,          &aes_128_ccm_star_no_tag_info },
-    { MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG,          &aes_192_ccm_star_no_tag_info },
-    { MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG,          &aes_256_ccm_star_no_tag_info },
-#endif
-#endif /* MBEDTLS_AES_C */
-
-#if defined(MBEDTLS_CAMELLIA_C)
-    { MBEDTLS_CIPHER_CAMELLIA_128_ECB,     &camellia_128_ecb_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_ECB,     &camellia_192_ecb_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_ECB,     &camellia_256_ecb_info },
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    { MBEDTLS_CIPHER_CAMELLIA_128_CBC,     &camellia_128_cbc_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_CBC,     &camellia_192_cbc_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_CBC,     &camellia_256_cbc_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    { MBEDTLS_CIPHER_CAMELLIA_128_CFB128,  &camellia_128_cfb128_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_CFB128,  &camellia_192_cfb128_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_CFB128,  &camellia_256_cfb128_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    { MBEDTLS_CIPHER_CAMELLIA_128_CTR,     &camellia_128_ctr_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_CTR,     &camellia_192_ctr_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_CTR,     &camellia_256_ctr_info },
-#endif
-#if defined(MBEDTLS_GCM_C)
-    { MBEDTLS_CIPHER_CAMELLIA_128_GCM,     &camellia_128_gcm_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_GCM,     &camellia_192_gcm_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_GCM,     &camellia_256_gcm_info },
-#endif
-#if defined(MBEDTLS_CCM_C)
-    { MBEDTLS_CIPHER_CAMELLIA_128_CCM,     &camellia_128_ccm_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_CCM,     &camellia_192_ccm_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_CCM,     &camellia_256_ccm_info },
-    { MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG,     &camellia_128_ccm_star_no_tag_info },
-    { MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG,     &camellia_192_ccm_star_no_tag_info },
-    { MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG,     &camellia_256_ccm_star_no_tag_info },
-#endif
-#endif /* MBEDTLS_CAMELLIA_C */
-
-#if defined(MBEDTLS_ARIA_C)
-    { MBEDTLS_CIPHER_ARIA_128_ECB,     &aria_128_ecb_info },
-    { MBEDTLS_CIPHER_ARIA_192_ECB,     &aria_192_ecb_info },
-    { MBEDTLS_CIPHER_ARIA_256_ECB,     &aria_256_ecb_info },
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    { MBEDTLS_CIPHER_ARIA_128_CBC,     &aria_128_cbc_info },
-    { MBEDTLS_CIPHER_ARIA_192_CBC,     &aria_192_cbc_info },
-    { MBEDTLS_CIPHER_ARIA_256_CBC,     &aria_256_cbc_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    { MBEDTLS_CIPHER_ARIA_128_CFB128,  &aria_128_cfb128_info },
-    { MBEDTLS_CIPHER_ARIA_192_CFB128,  &aria_192_cfb128_info },
-    { MBEDTLS_CIPHER_ARIA_256_CFB128,  &aria_256_cfb128_info },
-#endif
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    { MBEDTLS_CIPHER_ARIA_128_CTR,     &aria_128_ctr_info },
-    { MBEDTLS_CIPHER_ARIA_192_CTR,     &aria_192_ctr_info },
-    { MBEDTLS_CIPHER_ARIA_256_CTR,     &aria_256_ctr_info },
-#endif
-#if defined(MBEDTLS_GCM_C)
-    { MBEDTLS_CIPHER_ARIA_128_GCM,     &aria_128_gcm_info },
-    { MBEDTLS_CIPHER_ARIA_192_GCM,     &aria_192_gcm_info },
-    { MBEDTLS_CIPHER_ARIA_256_GCM,     &aria_256_gcm_info },
-#endif
-#if defined(MBEDTLS_CCM_C)
-    { MBEDTLS_CIPHER_ARIA_128_CCM,     &aria_128_ccm_info },
-    { MBEDTLS_CIPHER_ARIA_192_CCM,     &aria_192_ccm_info },
-    { MBEDTLS_CIPHER_ARIA_256_CCM,     &aria_256_ccm_info },
-    { MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG,     &aria_128_ccm_star_no_tag_info },
-    { MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG,     &aria_192_ccm_star_no_tag_info },
-    { MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG,     &aria_256_ccm_star_no_tag_info },
-#endif
-#endif /* MBEDTLS_ARIA_C */
-
-#if defined(MBEDTLS_DES_C)
-    { MBEDTLS_CIPHER_DES_ECB,              &des_ecb_info },
-    { MBEDTLS_CIPHER_DES_EDE_ECB,          &des_ede_ecb_info },
-    { MBEDTLS_CIPHER_DES_EDE3_ECB,         &des_ede3_ecb_info },
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    { MBEDTLS_CIPHER_DES_CBC,              &des_cbc_info },
-    { MBEDTLS_CIPHER_DES_EDE_CBC,          &des_ede_cbc_info },
-    { MBEDTLS_CIPHER_DES_EDE3_CBC,         &des_ede3_cbc_info },
-#endif
-#endif /* MBEDTLS_DES_C */
-
-#if defined(MBEDTLS_CHACHA20_C)
-    { MBEDTLS_CIPHER_CHACHA20,             &chacha20_info },
-#endif
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    { MBEDTLS_CIPHER_CHACHA20_POLY1305,    &chachapoly_info },
-#endif
-
-#if defined(MBEDTLS_NIST_KW_C)
-    { MBEDTLS_CIPHER_AES_128_KW,          &aes_128_nist_kw_info },
-    { MBEDTLS_CIPHER_AES_192_KW,          &aes_192_nist_kw_info },
-    { MBEDTLS_CIPHER_AES_256_KW,          &aes_256_nist_kw_info },
-    { MBEDTLS_CIPHER_AES_128_KWP,         &aes_128_nist_kwp_info },
-    { MBEDTLS_CIPHER_AES_192_KWP,         &aes_192_nist_kwp_info },
-    { MBEDTLS_CIPHER_AES_256_KWP,         &aes_256_nist_kwp_info },
-#endif
-
-#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
-    { MBEDTLS_CIPHER_NULL,                 &null_cipher_info },
-#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
-
-    { MBEDTLS_CIPHER_NONE, NULL }
-};
-
-#define NUM_CIPHERS ( sizeof(mbedtls_cipher_definitions) /      \
-                      sizeof(mbedtls_cipher_definitions[0]) )
-int mbedtls_cipher_supported[NUM_CIPHERS];
-
-#endif /* MBEDTLS_CIPHER_C */
diff --git a/src/duckdb/third_party/mbedtls/library/cipher_wrap.h b/src/duckdb/third_party/mbedtls/library/cipher_wrap.h
deleted file mode 100644
index 90563d85d..000000000
--- a/src/duckdb/third_party/mbedtls/library/cipher_wrap.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * \file cipher_wrap.h
- *
- * \brief Cipher wrappers.
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_CIPHER_WRAP_H
-#define MBEDTLS_CIPHER_WRAP_H
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/cipher.h"
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#include "psa/crypto.h"
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Base cipher information. The non-mode specific functions and values.
- */
-struct mbedtls_cipher_base_t
-{
-    /** Base Cipher type (e.g. MBEDTLS_CIPHER_ID_AES) */
-    mbedtls_cipher_id_t cipher;
-
-    /** Encrypt using ECB */
-    int (*ecb_func)( void *ctx, mbedtls_operation_t mode,
-                     const unsigned char *input, unsigned char *output );
-
-#if defined(MBEDTLS_CIPHER_MODE_CBC)
-    /** Encrypt using CBC */
-    int (*cbc_func)( void *ctx, mbedtls_operation_t mode, size_t length,
-                     unsigned char *iv, const unsigned char *input,
-                     unsigned char *output );
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_CFB)
-    /** Encrypt using CFB (Full length) */
-    int (*cfb_func)( void *ctx, mbedtls_operation_t mode, size_t length, size_t *iv_off,
-                     unsigned char *iv, const unsigned char *input,
-                     unsigned char *output );
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_OFB)
-    /** Encrypt using OFB (Full length) */
-    int (*ofb_func)( void *ctx, size_t length, size_t *iv_off,
-                     unsigned char *iv,
-                     const unsigned char *input,
-                     unsigned char *output );
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_CTR)
-    /** Encrypt using CTR */
-    int (*ctr_func)( void *ctx, size_t length, size_t *nc_off,
-                     unsigned char *nonce_counter, unsigned char *stream_block,
-                     const unsigned char *input, unsigned char *output );
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_XTS)
-    /** Encrypt or decrypt using XTS. */
-    int (*xts_func)( void *ctx, mbedtls_operation_t mode, size_t length,
-                     const unsigned char data_unit[16],
-                     const unsigned char *input, unsigned char *output );
-#endif
-
-#if defined(MBEDTLS_CIPHER_MODE_STREAM)
-    /** Encrypt using STREAM */
-    int (*stream_func)( void *ctx, size_t length,
-                        const unsigned char *input, unsigned char *output );
-#endif
-
-    /** Set key for encryption purposes */
-    int (*setkey_enc_func)( void *ctx, const unsigned char *key,
-                            unsigned int key_bitlen );
-
-    /** Set key for decryption purposes */
-    int (*setkey_dec_func)( void *ctx, const unsigned char *key,
-                            unsigned int key_bitlen);
-
-    /** Allocate a new context */
-    void * (*ctx_alloc_func)( void );
-
-    /** Free the given context */
-    void (*ctx_free_func)( void *ctx );
-
-};
-
-typedef struct
-{
-    mbedtls_cipher_type_t type;
-    const mbedtls_cipher_info_t *info;
-} mbedtls_cipher_definition_t;
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-typedef enum
-{
-    MBEDTLS_CIPHER_PSA_KEY_UNSET = 0,
-    MBEDTLS_CIPHER_PSA_KEY_OWNED, /* Used for PSA-based cipher contexts which */
-                                  /* use raw key material internally imported */
-                                  /* as a volatile key, and which hence need  */
-                                  /* to destroy that key when the context is  */
-                                  /* freed.                                   */
-    MBEDTLS_CIPHER_PSA_KEY_NOT_OWNED, /* Used for PSA-based cipher contexts   */
-                                      /* which use a key provided by the      */
-                                      /* user, and which hence will not be    */
-                                      /* destroyed when the context is freed. */
-} mbedtls_cipher_psa_key_ownership;
-
-typedef struct
-{
-    psa_algorithm_t alg;
-    psa_key_id_t slot;
-    mbedtls_cipher_psa_key_ownership slot_state;
-} mbedtls_cipher_context_psa;
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-extern const mbedtls_cipher_definition_t mbedtls_cipher_definitions[];
-
-extern int mbedtls_cipher_supported[];
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_CIPHER_WRAP_H */
diff --git a/src/duckdb/third_party/mbedtls/library/common.h b/src/duckdb/third_party/mbedtls/library/common.h
deleted file mode 100644
index a630fcc45..000000000
--- a/src/duckdb/third_party/mbedtls/library/common.h
+++ /dev/null
@@ -1,401 +0,0 @@
-/**
- * \file common.h
- *
- * \brief Utility macros for internal use in the library
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_LIBRARY_COMMON_H
-#define MBEDTLS_LIBRARY_COMMON_H
-
-#include "mbedtls/build_info.h"
-
-#include <stdint.h>
-
-/** Helper to define a function as static except when building invasive tests.
- *
- * If a function is only used inside its own source file and should be
- * declared `static` to allow the compiler to optimize for code size,
- * but that function has unit tests, define it with
- * ```
- * MBEDTLS_STATIC_TESTABLE int mbedtls_foo(...) { ... }
- * ```
- * and declare it in a header in the `library/` directory with
- * ```
- * #if defined(MBEDTLS_TEST_HOOKS)
- * int mbedtls_foo(...);
- * #endif
- * ```
- */
-#if defined(MBEDTLS_TEST_HOOKS)
-#define MBEDTLS_STATIC_TESTABLE
-#else
-#define MBEDTLS_STATIC_TESTABLE static
-#endif
-
-#if defined(MBEDTLS_TEST_HOOKS)
-extern void (*mbedtls_test_hook_test_fail)( const char * test, int line, const char * file );
-#define MBEDTLS_TEST_HOOK_TEST_ASSERT( TEST ) \
-       do { \
-            if( ( ! ( TEST ) ) && ( ( *mbedtls_test_hook_test_fail ) != NULL ) ) \
-            { \
-              ( *mbedtls_test_hook_test_fail )( #TEST, __LINE__, __FILE__ ); \
-            } \
-    } while( 0 )
-#else
-#define MBEDTLS_TEST_HOOK_TEST_ASSERT( TEST )
-#endif /* defined(MBEDTLS_TEST_HOOKS) */
-
-/** Allow library to access its structs' private members.
- *
- * Although structs defined in header files are publicly available,
- * their members are private and should not be accessed by the user.
- */
-#define MBEDTLS_ALLOW_PRIVATE_ACCESS
-
-/** Byte Reading Macros
- *
- * Given a multi-byte integer \p x, MBEDTLS_BYTE_n retrieves the n-th
- * byte from x, where byte 0 is the least significant byte.
- */
-#define MBEDTLS_BYTE_0( x ) ( (uint8_t) (   ( x )         & 0xff ) )
-#define MBEDTLS_BYTE_1( x ) ( (uint8_t) ( ( ( x ) >> 8  ) & 0xff ) )
-#define MBEDTLS_BYTE_2( x ) ( (uint8_t) ( ( ( x ) >> 16 ) & 0xff ) )
-#define MBEDTLS_BYTE_3( x ) ( (uint8_t) ( ( ( x ) >> 24 ) & 0xff ) )
-#define MBEDTLS_BYTE_4( x ) ( (uint8_t) ( ( ( x ) >> 32 ) & 0xff ) )
-#define MBEDTLS_BYTE_5( x ) ( (uint8_t) ( ( ( x ) >> 40 ) & 0xff ) )
-#define MBEDTLS_BYTE_6( x ) ( (uint8_t) ( ( ( x ) >> 48 ) & 0xff ) )
-#define MBEDTLS_BYTE_7( x ) ( (uint8_t) ( ( ( x ) >> 56 ) & 0xff ) )
-
-/**
- * Get the unsigned 32 bits integer corresponding to four bytes in
- * big-endian order (MSB first).
- *
- * \param   data    Base address of the memory to get the four bytes from.
- * \param   offset  Offset from \p data of the first and most significant
- *                  byte of the four bytes to build the 32 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT32_BE
-#define MBEDTLS_GET_UINT32_BE( data , offset )                  \
-    (                                                           \
-          ( (uint32_t) ( data )[( offset )    ] << 24 )         \
-        | ( (uint32_t) ( data )[( offset ) + 1] << 16 )         \
-        | ( (uint32_t) ( data )[( offset ) + 2] <<  8 )         \
-        | ( (uint32_t) ( data )[( offset ) + 3]       )         \
-    )
-#endif
-
-/**
- * Put in memory a 32 bits unsigned integer in big-endian order.
- *
- * \param   n       32 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 32
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the most significant
- *                  byte of the 32 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT32_BE
-#define MBEDTLS_PUT_UINT32_BE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_3( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_2( n );             \
-    ( data )[( offset ) + 2] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 3] = MBEDTLS_BYTE_0( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 32 bits integer corresponding to four bytes in
- * little-endian order (LSB first).
- *
- * \param   data    Base address of the memory to get the four bytes from.
- * \param   offset  Offset from \p data of the first and least significant
- *                  byte of the four bytes to build the 32 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT32_LE
-#define MBEDTLS_GET_UINT32_LE( data, offset )                   \
-    (                                                           \
-          ( (uint32_t) ( data )[( offset )    ]       )         \
-        | ( (uint32_t) ( data )[( offset ) + 1] <<  8 )         \
-        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )         \
-        | ( (uint32_t) ( data )[( offset ) + 3] << 24 )         \
-    )
-#endif
-
-/**
- * Put in memory a 32 bits unsigned integer in little-endian order.
- *
- * \param   n       32 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 32
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the least significant
- *                  byte of the 32 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT32_LE
-#define MBEDTLS_PUT_UINT32_LE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
-    ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 16 bits integer corresponding to two bytes in
- * little-endian order (LSB first).
- *
- * \param   data    Base address of the memory to get the two bytes from.
- * \param   offset  Offset from \p data of the first and least significant
- *                  byte of the two bytes to build the 16 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT16_LE
-#define MBEDTLS_GET_UINT16_LE( data, offset )                   \
-    (                                                           \
-          ( (uint16_t) ( data )[( offset )    ]       )         \
-        | ( (uint16_t) ( data )[( offset ) + 1] <<  8 )         \
-    )
-#endif
-
-/**
- * Put in memory a 16 bits unsigned integer in little-endian order.
- *
- * \param   n       16 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 16
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the least significant
- *                  byte of the 16 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT16_LE
-#define MBEDTLS_PUT_UINT16_LE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 16 bits integer corresponding to two bytes in
- * big-endian order (MSB first).
- *
- * \param   data    Base address of the memory to get the two bytes from.
- * \param   offset  Offset from \p data of the first and most significant
- *                  byte of the two bytes to build the 16 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT16_BE
-#define MBEDTLS_GET_UINT16_BE( data, offset )                   \
-    (                                                           \
-          ( (uint16_t) ( data )[( offset )    ] << 8 )          \
-        | ( (uint16_t) ( data )[( offset ) + 1]      )          \
-    )
-#endif
-
-/**
- * Put in memory a 16 bits unsigned integer in big-endian order.
- *
- * \param   n       16 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 16
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the most significant
- *                  byte of the 16 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT16_BE
-#define MBEDTLS_PUT_UINT16_BE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_0( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 24 bits integer corresponding to three bytes in
- * big-endian order (MSB first).
- *
- * \param   data    Base address of the memory to get the three bytes from.
- * \param   offset  Offset from \p data of the first and most significant
- *                  byte of the three bytes to build the 24 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT24_BE
-#define MBEDTLS_GET_UINT24_BE( data , offset )                  \
-    (                                                           \
-          ( (uint32_t) ( data )[( offset )    ] << 16 )         \
-        | ( (uint32_t) ( data )[( offset ) + 1] << 8  )         \
-        | ( (uint32_t) ( data )[( offset ) + 2]       )         \
-    )
-#endif
-
-/**
- * Put in memory a 24 bits unsigned integer in big-endian order.
- *
- * \param   n       24 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 24
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the most significant
- *                  byte of the 24 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT24_BE
-#define MBEDTLS_PUT_UINT24_BE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_2( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 2] = MBEDTLS_BYTE_0( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 24 bits integer corresponding to three bytes in
- * little-endian order (LSB first).
- *
- * \param   data    Base address of the memory to get the three bytes from.
- * \param   offset  Offset from \p data of the first and least significant
- *                  byte of the three bytes to build the 24 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT24_LE
-#define MBEDTLS_GET_UINT24_LE( data, offset )                   \
-    (                                                           \
-          ( (uint32_t) ( data )[( offset )    ]       )         \
-        | ( (uint32_t) ( data )[( offset ) + 1] <<  8 )         \
-        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )         \
-    )
-#endif
-
-/**
- * Put in memory a 24 bits unsigned integer in little-endian order.
- *
- * \param   n       24 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 24
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the least significant
- *                  byte of the 24 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT24_LE
-#define MBEDTLS_PUT_UINT24_LE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 64 bits integer corresponding to eight bytes in
- * big-endian order (MSB first).
- *
- * \param   data    Base address of the memory to get the eight bytes from.
- * \param   offset  Offset from \p data of the first and most significant
- *                  byte of the eight bytes to build the 64 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT64_BE
-#define MBEDTLS_GET_UINT64_BE( data, offset )                   \
-    (                                                           \
-          ( (uint64_t) ( data )[( offset )    ] << 56 )         \
-        | ( (uint64_t) ( data )[( offset ) + 1] << 48 )         \
-        | ( (uint64_t) ( data )[( offset ) + 2] << 40 )         \
-        | ( (uint64_t) ( data )[( offset ) + 3] << 32 )         \
-        | ( (uint64_t) ( data )[( offset ) + 4] << 24 )         \
-        | ( (uint64_t) ( data )[( offset ) + 5] << 16 )         \
-        | ( (uint64_t) ( data )[( offset ) + 6] <<  8 )         \
-        | ( (uint64_t) ( data )[( offset ) + 7]       )         \
-    )
-#endif
-
-/**
- * Put in memory a 64 bits unsigned integer in big-endian order.
- *
- * \param   n       64 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 64
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the most significant
- *                  byte of the 64 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT64_BE
-#define MBEDTLS_PUT_UINT64_BE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_7( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_6( n );             \
-    ( data )[( offset ) + 2] = MBEDTLS_BYTE_5( n );             \
-    ( data )[( offset ) + 3] = MBEDTLS_BYTE_4( n );             \
-    ( data )[( offset ) + 4] = MBEDTLS_BYTE_3( n );             \
-    ( data )[( offset ) + 5] = MBEDTLS_BYTE_2( n );             \
-    ( data )[( offset ) + 6] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 7] = MBEDTLS_BYTE_0( n );             \
-}
-#endif
-
-/**
- * Get the unsigned 64 bits integer corresponding to eight bytes in
- * little-endian order (LSB first).
- *
- * \param   data    Base address of the memory to get the eight bytes from.
- * \param   offset  Offset from \p data of the first and least significant
- *                  byte of the eight bytes to build the 64 bits unsigned
- *                  integer from.
- */
-#ifndef MBEDTLS_GET_UINT64_LE
-#define MBEDTLS_GET_UINT64_LE( data, offset )                   \
-    (                                                           \
-          ( (uint64_t) ( data )[( offset ) + 7] << 56 )         \
-        | ( (uint64_t) ( data )[( offset ) + 6] << 48 )         \
-        | ( (uint64_t) ( data )[( offset ) + 5] << 40 )         \
-        | ( (uint64_t) ( data )[( offset ) + 4] << 32 )         \
-        | ( (uint64_t) ( data )[( offset ) + 3] << 24 )         \
-        | ( (uint64_t) ( data )[( offset ) + 2] << 16 )         \
-        | ( (uint64_t) ( data )[( offset ) + 1] <<  8 )         \
-        | ( (uint64_t) ( data )[( offset )    ]       )         \
-    )
-#endif
-
-/**
- * Put in memory a 64 bits unsigned integer in little-endian order.
- *
- * \param   n       64 bits unsigned integer to put in memory.
- * \param   data    Base address of the memory where to put the 64
- *                  bits unsigned integer in.
- * \param   offset  Offset from \p data where to put the least significant
- *                  byte of the 64 bits unsigned integer \p n.
- */
-#ifndef MBEDTLS_PUT_UINT64_LE
-#define MBEDTLS_PUT_UINT64_LE( n, data, offset )                \
-{                                                               \
-    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
-    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
-    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
-    ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n );             \
-    ( data )[( offset ) + 4] = MBEDTLS_BYTE_4( n );             \
-    ( data )[( offset ) + 5] = MBEDTLS_BYTE_5( n );             \
-    ( data )[( offset ) + 6] = MBEDTLS_BYTE_6( n );             \
-    ( data )[( offset ) + 7] = MBEDTLS_BYTE_7( n );             \
-}
-#endif
-
-/* Fix MSVC C99 compatible issue
- *      MSVC support __func__ from visual studio 2015( 1900 )
- *      Use MSVC predefine macro to avoid name check fail.
- */
-#if (defined(_MSC_VER) && ( _MSC_VER <= 1900 ))
-#define /*no-check-names*/ __func__ __FUNCTION__
-#endif
-
-#endif /* MBEDTLS_LIBRARY_COMMON_H */
diff --git a/src/duckdb/third_party/mbedtls/library/constant_time.cpp b/src/duckdb/third_party/mbedtls/library/constant_time.cpp
deleted file mode 100644
index d2a2239e5..000000000
--- a/src/duckdb/third_party/mbedtls/library/constant_time.cpp
+++ /dev/null
@@ -1,801 +0,0 @@
-/**
- *  Constant-time functions
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
- /*
- * The following functions are implemented without using comparison operators, as those
- * might be translated to branches by some compilers on some platforms.
- */
-
-#include "common.h"
-#include "constant_time_internal.h"
-#include "mbedtls/constant_time.h"
-#include "mbedtls/error.h"
-#include "mbedtls/platform_util.h"
-
-#if defined(MBEDTLS_BIGNUM_C)
-#include "mbedtls/bignum.h"
-#endif
-
-#if defined(MBEDTLS_SSL_TLS_C)
-#include "ssl_misc.h"
-#endif
-
-#if defined(MBEDTLS_RSA_C)
-#include "mbedtls/rsa.h"
-#endif
-
-#if defined(MBEDTLS_BASE64_C)
-#include "constant_time_invasive.h"
-#endif
-
-#include <string.h>
-
-int mbedtls_ct_memcmp( const void *a,
-                       const void *b,
-                       size_t n )
-{
-    size_t i;
-    volatile const unsigned char *A = (volatile const unsigned char *) a;
-    volatile const unsigned char *B = (volatile const unsigned char *) b;
-    volatile unsigned char diff = 0;
-
-    for( i = 0; i < n; i++ )
-    {
-        /* Read volatile data in order before computing diff.
-         * This avoids IAR compiler warning:
-         * 'the order of volatile accesses is undefined ..' */
-        unsigned char x = A[i], y = B[i];
-        diff = (diff | (x ^ y));
-    }
-
-    return( (int)diff );
-}
-
-unsigned mbedtls_ct_uint_mask( unsigned value )
-{
-    /* MSVC has a warning about unary minus on unsigned, but this is
-     * well-defined and precisely what we want to do here */
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4146 )
-#endif
-    return( - ( ( value | - value ) >> ( sizeof( value ) * 8 - 1 ) ) );
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-}
-
-#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
-
-size_t mbedtls_ct_size_mask( size_t value )
-{
-    /* MSVC has a warning about unary minus on unsigned integer types,
-     * but this is well-defined and precisely what we want to do here. */
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4146 )
-#endif
-    return( - ( ( value | - value ) >> ( sizeof( value ) * 8 - 1 ) ) );
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-}
-
-#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-mbedtls_mpi_uint mbedtls_ct_mpi_uint_mask( mbedtls_mpi_uint value )
-{
-    /* MSVC has a warning about unary minus on unsigned, but this is
-     * well-defined and precisely what we want to do here */
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4146 )
-#endif
-    return( - ( ( value | - value ) >> ( sizeof( value ) * 8 - 1 ) ) );
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-}
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
-
-/** Constant-flow mask generation for "less than" comparison:
- * - if \p x < \p y, return all-bits 1, that is (size_t) -1
- * - otherwise, return all bits 0, that is 0
- *
- * This function can be used to write constant-time code by replacing branches
- * with bit operations using masks.
- *
- * \param x     The first value to analyze.
- * \param y     The second value to analyze.
- *
- * \return      All-bits-one if \p x is less than \p y, otherwise zero.
- */
-static size_t mbedtls_ct_size_mask_lt( size_t x,
-                                       size_t y )
-{
-    /* This has the most significant bit set if and only if x < y */
-    const size_t sub = x - y;
-
-    /* sub1 = (x < y) ? 1 : 0 */
-    const size_t sub1 = sub >> ( sizeof( sub ) * 8 - 1 );
-
-    /* mask = (x < y) ? 0xff... : 0x00... */
-    const size_t mask = mbedtls_ct_size_mask( sub1 );
-
-    return( mask );
-}
-
-size_t mbedtls_ct_size_mask_ge( size_t x,
-                                size_t y )
-{
-    return( ~mbedtls_ct_size_mask_lt( x, y ) );
-}
-
-#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
-
-#if defined(MBEDTLS_BASE64_C)
-
-/* Return 0xff if low <= c <= high, 0 otherwise.
- *
- * Constant flow with respect to c.
- */
-MBEDTLS_STATIC_TESTABLE
-unsigned char mbedtls_ct_uchar_mask_of_range( unsigned char low,
-                                              unsigned char high,
-                                              unsigned char c )
-{
-    /* low_mask is: 0 if low <= c, 0x...ff if low > c */
-    unsigned low_mask = ( (unsigned) c - low ) >> 8;
-    /* high_mask is: 0 if c <= high, 0x...ff if c > high */
-    unsigned high_mask = ( (unsigned) high - c ) >> 8;
-    return( ~( low_mask | high_mask ) & 0xff );
-}
-
-#endif /* MBEDTLS_BASE64_C */
-
-unsigned mbedtls_ct_size_bool_eq( size_t x,
-                                  size_t y )
-{
-    /* diff = 0 if x == y, non-zero otherwise */
-    const size_t diff = x ^ y;
-
-    /* MSVC has a warning about unary minus on unsigned integer types,
-     * but this is well-defined and precisely what we want to do here. */
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4146 )
-#endif
-
-    /* diff_msb's most significant bit is equal to x != y */
-    const size_t diff_msb = ( diff | (size_t) -diff );
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-    /* diff1 = (x != y) ? 1 : 0 */
-    const unsigned diff1 = diff_msb >> ( sizeof( diff_msb ) * 8 - 1 );
-
-    return( 1 ^ diff1 );
-}
-
-#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT)
-
-/** Constant-flow "greater than" comparison:
- * return x > y
- *
- * This is equivalent to \p x > \p y, but is likely to be compiled
- * to code using bitwise operation rather than a branch.
- *
- * \param x     The first value to analyze.
- * \param y     The second value to analyze.
- *
- * \return      1 if \p x greater than \p y, otherwise 0.
- */
-static unsigned mbedtls_ct_size_gt( size_t x,
-                                    size_t y )
-{
-    /* Return the sign bit (1 for negative) of (y - x). */
-    return( ( y - x ) >> ( sizeof( size_t ) * 8 - 1 ) );
-}
-
-#endif /* MBEDTLS_PKCS1_V15 && MBEDTLS_RSA_C && ! MBEDTLS_RSA_ALT */
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-unsigned mbedtls_ct_mpi_uint_lt( const mbedtls_mpi_uint x,
-                                 const mbedtls_mpi_uint y )
-{
-    mbedtls_mpi_uint ret;
-    mbedtls_mpi_uint cond;
-
-    /*
-     * Check if the most significant bits (MSB) of the operands are different.
-     */
-    cond = ( x ^ y );
-    /*
-     * If the MSB are the same then the difference x-y will be negative (and
-     * have its MSB set to 1 during conversion to unsigned) if and only if x<y.
-     */
-    ret = ( x - y ) & ~cond;
-    /*
-     * If the MSB are different, then the operand with the MSB of 1 is the
-     * bigger. (That is if y has MSB of 1, then x<y is true and it is false if
-     * the MSB of y is 0.)
-     */
-    ret |= y & cond;
-
-
-    ret = ret >> ( sizeof( mbedtls_mpi_uint ) * 8 - 1 );
-
-    return (unsigned) ret;
-}
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-unsigned mbedtls_ct_uint_if( unsigned condition,
-                             unsigned if1,
-                             unsigned if0 )
-{
-    unsigned mask = mbedtls_ct_uint_mask( condition );
-    return( ( mask & if1 ) | (~mask & if0 ) );
-}
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-/** Select between two sign values without branches.
- *
- * This is functionally equivalent to `condition ? if1 : if0` but uses only bit
- * operations in order to avoid branches.
- *
- * \note if1 and if0 must be either 1 or -1, otherwise the result
- *       is undefined.
- *
- * \param condition     Condition to test.
- * \param if1           The first sign; must be either +1 or -1.
- * \param if0           The second sign; must be either +1 or -1.
- *
- * \return  \c if1 if \p condition is nonzero, otherwise \c if0.
- * */
-static int mbedtls_ct_cond_select_sign( unsigned char condition,
-                                        int if1,
-                                        int if0 )
-{
-    /* In order to avoid questions about what we can reasonably assume about
-     * the representations of signed integers, move everything to unsigned
-     * by taking advantage of the fact that if1 and if0 are either +1 or -1. */
-    unsigned uif1 = if1 + 1;
-    unsigned uif0 = if0 + 1;
-
-    /* condition was 0 or 1, mask is 0 or 2 as are uif1 and uif0 */
-    const unsigned mask = condition << 1;
-
-    /* select uif1 or uif0 */
-    unsigned ur = ( uif0 & ~mask ) | ( uif1 & mask );
-
-    /* ur is now 0 or 2, convert back to -1 or +1 */
-    return( (int) ur - 1 );
-}
-
-void mbedtls_ct_mpi_uint_cond_assign( size_t n,
-                                      mbedtls_mpi_uint *dest,
-                                      const mbedtls_mpi_uint *src,
-                                      unsigned char condition )
-{
-    size_t i;
-
-    /* MSVC has a warning about unary minus on unsigned integer types,
-     * but this is well-defined and precisely what we want to do here. */
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4146 )
-#endif
-
-    /* all-bits 1 if condition is 1, all-bits 0 if condition is 0 */
-    const mbedtls_mpi_uint mask = -condition;
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-    for( i = 0; i < n; i++ )
-        dest[i] = ( src[i] & mask ) | ( dest[i] & ~mask );
-}
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-#if defined(MBEDTLS_BASE64_C)
-
-unsigned char mbedtls_ct_base64_enc_char( unsigned char value )
-{
-    unsigned char digit = 0;
-    /* For each range of values, if value is in that range, mask digit with
-     * the corresponding value. Since value can only be in a single range,
-     * only at most one masking will change digit. */
-    digit |= mbedtls_ct_uchar_mask_of_range(  0, 25, value ) & ( 'A' + value );
-    digit |= mbedtls_ct_uchar_mask_of_range( 26, 51, value ) & ( 'a' + value - 26 );
-    digit |= mbedtls_ct_uchar_mask_of_range( 52, 61, value ) & ( '0' + value - 52 );
-    digit |= mbedtls_ct_uchar_mask_of_range( 62, 62, value ) & '+';
-    digit |= mbedtls_ct_uchar_mask_of_range( 63, 63, value ) & '/';
-    return( digit );
-}
-
-signed char mbedtls_ct_base64_dec_value( unsigned char c )
-{
-    unsigned char val = 0;
-    /* For each range of digits, if c is in that range, mask val with
-     * the corresponding value. Since c can only be in a single range,
-     * only at most one masking will change val. Set val to one plus
-     * the desired value so that it stays 0 if c is in none of the ranges. */
-    val |= mbedtls_ct_uchar_mask_of_range( 'A', 'Z', c ) & ( c - 'A' +  0 + 1 );
-    val |= mbedtls_ct_uchar_mask_of_range( 'a', 'z', c ) & ( c - 'a' + 26 + 1 );
-    val |= mbedtls_ct_uchar_mask_of_range( '0', '9', c ) & ( c - '0' + 52 + 1 );
-    val |= mbedtls_ct_uchar_mask_of_range( '+', '+', c ) & ( c - '+' + 62 + 1 );
-    val |= mbedtls_ct_uchar_mask_of_range( '/', '/', c ) & ( c - '/' + 63 + 1 );
-    /* At this point, val is 0 if c is an invalid digit and v+1 if c is
-     * a digit with the value v. */
-    return( val - 1 );
-}
-
-#endif /* MBEDTLS_BASE64_C */
-
-#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT)
-
-/** Shift some data towards the left inside a buffer.
- *
- * `mbedtls_ct_mem_move_to_left(start, total, offset)` is functionally
- * equivalent to
- * ```
- * memmove(start, start + offset, total - offset);
- * memset(start + offset, 0, total - offset);
- * ```
- * but it strives to use a memory access pattern (and thus total timing)
- * that does not depend on \p offset. This timing independence comes at
- * the expense of performance.
- *
- * \param start     Pointer to the start of the buffer.
- * \param total     Total size of the buffer.
- * \param offset    Offset from which to copy \p total - \p offset bytes.
- */
-static void mbedtls_ct_mem_move_to_left( void *start,
-                                         size_t total,
-                                         size_t offset )
-{
-    volatile unsigned char *buf = (volatile unsigned char *) start;
-    size_t i, n;
-    if( total == 0 )
-        return;
-    for( i = 0; i < total; i++ )
-    {
-        unsigned no_op = mbedtls_ct_size_gt( total - offset, i );
-        /* The first `total - offset` passes are a no-op. The last
-         * `offset` passes shift the data one byte to the left and
-         * zero out the last byte. */
-        for( n = 0; n < total - 1; n++ )
-        {
-            unsigned char current = buf[n];
-            unsigned char next = buf[n+1];
-            buf[n] = mbedtls_ct_uint_if( no_op, current, next );
-        }
-        buf[total-1] = mbedtls_ct_uint_if( no_op, buf[total-1], 0 );
-    }
-}
-
-#endif /* MBEDTLS_PKCS1_V15 && MBEDTLS_RSA_C && ! MBEDTLS_RSA_ALT */
-
-#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
-
-void mbedtls_ct_memcpy_if_eq( unsigned char *dest,
-                              const unsigned char *src,
-                              size_t len,
-                              size_t c1,
-                              size_t c2 )
-{
-    /* mask = c1 == c2 ? 0xff : 0x00 */
-    const size_t equal = mbedtls_ct_size_bool_eq( c1, c2 );
-    const unsigned char mask = (unsigned char) mbedtls_ct_size_mask( equal );
-
-    /* dest[i] = c1 == c2 ? src[i] : dest[i] */
-    for( size_t i = 0; i < len; i++ )
-        dest[i] = ( src[i] & mask ) | ( dest[i] & ~mask );
-}
-
-void mbedtls_ct_memcpy_offset( unsigned char *dest,
-                               const unsigned char *src,
-                               size_t offset,
-                               size_t offset_min,
-                               size_t offset_max,
-                               size_t len )
-{
-    size_t offsetval;
-
-    for( offsetval = offset_min; offsetval <= offset_max; offsetval++ )
-    {
-        mbedtls_ct_memcpy_if_eq( dest, src + offsetval, len,
-                                 offsetval, offset );
-    }
-}
-
-int mbedtls_ct_hmac( mbedtls_md_context_t *ctx,
-                     const unsigned char *add_data,
-                     size_t add_data_len,
-                     const unsigned char *data,
-                     size_t data_len_secret,
-                     size_t min_data_len,
-                     size_t max_data_len,
-                     unsigned char *output )
-{
-    /*
-     * This function breaks the HMAC abstraction and uses the md_clone()
-     * extension to the MD API in order to get constant-flow behaviour.
-     *
-     * HMAC(msg) is defined as HASH(okey + HASH(ikey + msg)) where + means
-     * concatenation, and okey/ikey are the XOR of the key with some fixed bit
-     * patterns (see RFC 2104, sec. 2), which are stored in ctx->hmac_ctx.
-     *
-     * We'll first compute inner_hash = HASH(ikey + msg) by hashing up to
-     * minlen, then cloning the context, and for each byte up to maxlen
-     * finishing up the hash computation, keeping only the correct result.
-     *
-     * Then we only need to compute HASH(okey + inner_hash) and we're done.
-     */
-    const mbedtls_md_type_t md_alg = mbedtls_md_get_type( ctx->md_info );
-    /* TLS 1.2 only supports SHA-384, SHA-256, SHA-1, MD-5,
-     * all of which have the same block size except SHA-384. */
-    const size_t block_size = md_alg == MBEDTLS_MD_SHA384 ? 128 : 64;
-    const unsigned char * const ikey = ctx->hmac_ctx;
-    const unsigned char * const okey = ikey + block_size;
-    const size_t hash_size = mbedtls_md_get_size( ctx->md_info );
-
-    unsigned char aux_out[MBEDTLS_MD_MAX_SIZE];
-    mbedtls_md_context_t aux;
-    size_t offset;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    mbedtls_md_init( &aux );
-
-#define MD_CHK( func_call ) \
-    do {                    \
-        ret = (func_call);  \
-        if( ret != 0 )      \
-            goto cleanup;   \
-    } while( 0 )
-
-    MD_CHK( mbedtls_md_setup( &aux, ctx->md_info, 0 ) );
-
-    /* After hmac_start() of hmac_reset(), ikey has already been hashed,
-     * so we can start directly with the message */
-    MD_CHK( mbedtls_md_update( ctx, add_data, add_data_len ) );
-    MD_CHK( mbedtls_md_update( ctx, data, min_data_len ) );
-
-    /* For each possible length, compute the hash up to that point */
-    for( offset = min_data_len; offset <= max_data_len; offset++ )
-    {
-        MD_CHK( mbedtls_md_clone( &aux, ctx ) );
-        MD_CHK( mbedtls_md_finish( &aux, aux_out ) );
-        /* Keep only the correct inner_hash in the output buffer */
-        mbedtls_ct_memcpy_if_eq( output, aux_out, hash_size,
-                                 offset, data_len_secret );
-
-        if( offset < max_data_len )
-            MD_CHK( mbedtls_md_update( ctx, data + offset, 1 ) );
-    }
-
-    /* The context needs to finish() before it starts() again */
-    MD_CHK( mbedtls_md_finish( ctx, aux_out ) );
-
-    /* Now compute HASH(okey + inner_hash) */
-    MD_CHK( mbedtls_md_starts( ctx ) );
-    MD_CHK( mbedtls_md_update( ctx, okey, block_size ) );
-    MD_CHK( mbedtls_md_update( ctx, output, hash_size ) );
-    MD_CHK( mbedtls_md_finish( ctx, output ) );
-
-    /* Done, get ready for next time */
-    MD_CHK( mbedtls_md_hmac_reset( ctx ) );
-
-#undef MD_CHK
-
-cleanup:
-    mbedtls_md_free( &aux );
-    return( ret );
-}
-
-#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-#define MPI_VALIDATE_RET( cond )                                       \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_MPI_BAD_INPUT_DATA )
-
-/*
- * Conditionally assign X = Y, without leaking information
- * about whether the assignment was made or not.
- * (Leaking information about the respective sizes of X and Y is ok however.)
- */
-int mbedtls_mpi_safe_cond_assign( mbedtls_mpi *X,
-                                  const mbedtls_mpi *Y,
-                                  unsigned char assign )
-{
-    int ret = 0;
-    size_t i;
-    mbedtls_mpi_uint limb_mask;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( Y != NULL );
-
-    /* all-bits 1 if assign is 1, all-bits 0 if assign is 0 */
-    limb_mask = mbedtls_ct_mpi_uint_mask( assign );;
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
-
-    X->s = mbedtls_ct_cond_select_sign( assign, Y->s, X->s );
-
-    mbedtls_ct_mpi_uint_cond_assign( Y->n, X->p, Y->p, assign );
-
-    for( i = Y->n; i < X->n; i++ )
-        X->p[i] &= ~limb_mask;
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Conditionally swap X and Y, without leaking information
- * about whether the swap was made or not.
- * Here it is not ok to simply swap the pointers, which whould lead to
- * different memory access patterns when X and Y are used afterwards.
- */
-int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X,
-                                mbedtls_mpi *Y,
-                                unsigned char swap )
-{
-    int ret, s;
-    size_t i;
-    mbedtls_mpi_uint limb_mask;
-    mbedtls_mpi_uint tmp;
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( Y != NULL );
-
-    if( X == Y )
-        return( 0 );
-
-    /* all-bits 1 if swap is 1, all-bits 0 if swap is 0 */
-    limb_mask = mbedtls_ct_mpi_uint_mask( swap );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( Y, X->n ) );
-
-    s = X->s;
-    X->s = mbedtls_ct_cond_select_sign( swap, Y->s, X->s );
-    Y->s = mbedtls_ct_cond_select_sign( swap, s, Y->s );
-
-
-    for( i = 0; i < X->n; i++ )
-    {
-        tmp = X->p[i];
-        X->p[i] = ( X->p[i] & ~limb_mask ) | ( Y->p[i] & limb_mask );
-        Y->p[i] = ( Y->p[i] & ~limb_mask ) | (     tmp & limb_mask );
-    }
-
-cleanup:
-    return( ret );
-}
-
-/*
- * Compare signed values in constant time
- */
-int mbedtls_mpi_lt_mpi_ct( const mbedtls_mpi *X,
-                           const mbedtls_mpi *Y,
-                           unsigned *ret )
-{
-    size_t i;
-    /* The value of any of these variables is either 0 or 1 at all times. */
-    unsigned cond, done, X_is_negative, Y_is_negative;
-
-    MPI_VALIDATE_RET( X != NULL );
-    MPI_VALIDATE_RET( Y != NULL );
-    MPI_VALIDATE_RET( ret != NULL );
-
-    if( X->n != Y->n )
-        return MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
-
-    /*
-     * Set sign_N to 1 if N >= 0, 0 if N < 0.
-     * We know that N->s == 1 if N >= 0 and N->s == -1 if N < 0.
-     */
-    X_is_negative = ( X->s & 2 ) >> 1;
-    Y_is_negative = ( Y->s & 2 ) >> 1;
-
-    /*
-     * If the signs are different, then the positive operand is the bigger.
-     * That is if X is negative (X_is_negative == 1), then X < Y is true and it
-     * is false if X is positive (X_is_negative == 0).
-     */
-    cond = ( X_is_negative ^ Y_is_negative );
-    *ret = cond & X_is_negative;
-
-    /*
-     * This is a constant-time function. We might have the result, but we still
-     * need to go through the loop. Record if we have the result already.
-     */
-    done = cond;
-
-    for( i = X->n; i > 0; i-- )
-    {
-        /*
-         * If Y->p[i - 1] < X->p[i - 1] then X < Y is true if and only if both
-         * X and Y are negative.
-         *
-         * Again even if we can make a decision, we just mark the result and
-         * the fact that we are done and continue looping.
-         */
-        cond = mbedtls_ct_mpi_uint_lt( Y->p[i - 1], X->p[i - 1] );
-        *ret |= cond & ( 1 - done ) & X_is_negative;
-        done |= cond;
-
-        /*
-         * If X->p[i - 1] < Y->p[i - 1] then X < Y is true if and only if both
-         * X and Y are positive.
-         *
-         * Again even if we can make a decision, we just mark the result and
-         * the fact that we are done and continue looping.
-         */
-        cond = mbedtls_ct_mpi_uint_lt( X->p[i - 1], Y->p[i - 1] );
-        *ret |= cond & ( 1 - done ) & ( 1 - X_is_negative );
-        done |= cond;
-    }
-
-    return( 0 );
-}
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT)
-
-int mbedtls_ct_rsaes_pkcs1_v15_unpadding( unsigned char *input,
-                                          size_t ilen,
-                                          unsigned char *output,
-                                          size_t output_max_len,
-                                          size_t *olen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t i, plaintext_max_size;
-
-    /* The following variables take sensitive values: their value must
-     * not leak into the observable behavior of the function other than
-     * the designated outputs (output, olen, return value). Otherwise
-     * this would open the execution of the function to
-     * side-channel-based variants of the Bleichenbacher padding oracle
-     * attack. Potential side channels include overall timing, memory
-     * access patterns (especially visible to an adversary who has access
-     * to a shared memory cache), and branches (especially visible to
-     * an adversary who has access to a shared code cache or to a shared
-     * branch predictor). */
-    size_t pad_count = 0;
-    unsigned bad = 0;
-    unsigned char pad_done = 0;
-    size_t plaintext_size = 0;
-    unsigned output_too_large;
-
-    plaintext_max_size = ( output_max_len > ilen - 11 ) ? ilen - 11
-                                                        : output_max_len;
-
-    /* Check and get padding length in constant time and constant
-     * memory trace. The first byte must be 0. */
-    bad |= input[0];
-
-
-    /* Decode EME-PKCS1-v1_5 padding: 0x00 || 0x02 || PS || 0x00
-     * where PS must be at least 8 nonzero bytes. */
-    bad |= input[1] ^ MBEDTLS_RSA_CRYPT;
-
-    /* Read the whole buffer. Set pad_done to nonzero if we find
-     * the 0x00 byte and remember the padding length in pad_count. */
-    for( i = 2; i < ilen; i++ )
-    {
-        pad_done  |= ((input[i] | (unsigned char)-input[i]) >> 7) ^ 1;
-        pad_count += ((pad_done | (unsigned char)-pad_done) >> 7) ^ 1;
-    }
-
-
-    /* If pad_done is still zero, there's no data, only unfinished padding. */
-    bad |= mbedtls_ct_uint_if( pad_done, 0, 1 );
-
-    /* There must be at least 8 bytes of padding. */
-    bad |= mbedtls_ct_size_gt( 8, pad_count );
-
-    /* If the padding is valid, set plaintext_size to the number of
-     * remaining bytes after stripping the padding. If the padding
-     * is invalid, avoid leaking this fact through the size of the
-     * output: use the maximum message size that fits in the output
-     * buffer. Do it without branches to avoid leaking the padding
-     * validity through timing. RSA keys are small enough that all the
-     * size_t values involved fit in unsigned int. */
-    plaintext_size = mbedtls_ct_uint_if(
-                        bad, (unsigned) plaintext_max_size,
-                        (unsigned) ( ilen - pad_count - 3 ) );
-
-    /* Set output_too_large to 0 if the plaintext fits in the output
-     * buffer and to 1 otherwise. */
-    output_too_large = mbedtls_ct_size_gt( plaintext_size,
-                                           plaintext_max_size );
-
-    /* Set ret without branches to avoid timing attacks. Return:
-     * - INVALID_PADDING if the padding is bad (bad != 0).
-     * - OUTPUT_TOO_LARGE if the padding is good but the decrypted
-     *   plaintext does not fit in the output buffer.
-     * - 0 if the padding is correct. */
-    ret = - (int) mbedtls_ct_uint_if(
-                    bad, - MBEDTLS_ERR_RSA_INVALID_PADDING,
-                    mbedtls_ct_uint_if( output_too_large,
-                                        - MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE,
-                                        0 ) );
-
-    /* If the padding is bad or the plaintext is too large, zero the
-     * data that we're about to copy to the output buffer.
-     * We need to copy the same amount of data
-     * from the same buffer whether the padding is good or not to
-     * avoid leaking the padding validity through overall timing or
-     * through memory or cache access patterns. */
-    bad = mbedtls_ct_uint_mask( bad | output_too_large );
-    for( i = 11; i < ilen; i++ )
-        input[i] &= ~bad;
-
-    /* If the plaintext is too large, truncate it to the buffer size.
-     * Copy anyway to avoid revealing the length through timing, because
-     * revealing the length is as bad as revealing the padding validity
-     * for a Bleichenbacher attack. */
-    plaintext_size = mbedtls_ct_uint_if( output_too_large,
-                                         (unsigned) plaintext_max_size,
-                                         (unsigned) plaintext_size );
-
-    /* Move the plaintext to the leftmost position where it can start in
-     * the working buffer, i.e. make it start plaintext_max_size from
-     * the end of the buffer. Do this with a memory access trace that
-     * does not depend on the plaintext size. After this move, the
-     * starting location of the plaintext is no longer sensitive
-     * information. */
-    mbedtls_ct_mem_move_to_left( input + ilen - plaintext_max_size,
-                                 plaintext_max_size,
-                                 plaintext_max_size - plaintext_size );
-
-    /* Finally copy the decrypted plaintext plus trailing zeros into the output
-     * buffer. If output_max_len is 0, then output may be an invalid pointer
-     * and the result of memcpy() would be undefined; prevent undefined
-     * behavior making sure to depend only on output_max_len (the size of the
-     * user-provided output buffer), which is independent from plaintext
-     * length, validity of padding, success of the decryption, and other
-     * secrets. */
-    if( output_max_len != 0 )
-        memcpy( output, input + ilen - plaintext_max_size, plaintext_max_size );
-
-    /* Report the amount of data we copied to the output buffer. In case
-     * of errors (bad padding or output too large), the value of *olen
-     * when this function returns is not specified. Making it equivalent
-     * to the good case limits the risks of leaking the padding validity. */
-    *olen = plaintext_size;
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_PKCS1_V15 && MBEDTLS_RSA_C && ! MBEDTLS_RSA_ALT */
diff --git a/src/duckdb/third_party/mbedtls/library/constant_time_internal.h b/src/duckdb/third_party/mbedtls/library/constant_time_internal.h
deleted file mode 100644
index 053cf123c..000000000
--- a/src/duckdb/third_party/mbedtls/library/constant_time_internal.h
+++ /dev/null
@@ -1,326 +0,0 @@
-/**
- *  Constant-time functions
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_CONSTANT_TIME_INTERNAL_H
-#define MBEDTLS_CONSTANT_TIME_INTERNAL_H
-
-#include "common.h"
-
-#if defined(MBEDTLS_BIGNUM_C)
-#include "mbedtls/bignum.h"
-#endif
-
-#if defined(MBEDTLS_SSL_TLS_C)
-#include "ssl_misc.h"
-#endif
-
-#include <stddef.h>
-
-
-/** Turn a value into a mask:
- * - if \p value == 0, return the all-bits 0 mask, aka 0
- * - otherwise, return the all-bits 1 mask, aka (unsigned) -1
- *
- * This function can be used to write constant-time code by replacing branches
- * with bit operations using masks.
- *
- * \param value     The value to analyze.
- *
- * \return          Zero if \p value is zero, otherwise all-bits-one.
- */
-unsigned mbedtls_ct_uint_mask( unsigned value );
-
-#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
-
-/** Turn a value into a mask:
- * - if \p value == 0, return the all-bits 0 mask, aka 0
- * - otherwise, return the all-bits 1 mask, aka (size_t) -1
- *
- * This function can be used to write constant-time code by replacing branches
- * with bit operations using masks.
- *
- * \param value     The value to analyze.
- *
- * \return          Zero if \p value is zero, otherwise all-bits-one.
- */
-size_t mbedtls_ct_size_mask( size_t value );
-
-#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-/** Turn a value into a mask:
- * - if \p value == 0, return the all-bits 0 mask, aka 0
- * - otherwise, return the all-bits 1 mask, aka (mbedtls_mpi_uint) -1
- *
- * This function can be used to write constant-time code by replacing branches
- * with bit operations using masks.
- *
- * \param value     The value to analyze.
- *
- * \return          Zero if \p value is zero, otherwise all-bits-one.
- */
-mbedtls_mpi_uint mbedtls_ct_mpi_uint_mask( mbedtls_mpi_uint value );
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
-
-/** Constant-flow mask generation for "greater or equal" comparison:
- * - if \p x >= \p y, return all-bits 1, that is (size_t) -1
- * - otherwise, return all bits 0, that is 0
- *
- * This function can be used to write constant-time code by replacing branches
- * with bit operations using masks.
- *
- * \param x     The first value to analyze.
- * \param y     The second value to analyze.
- *
- * \return      All-bits-one if \p x is greater or equal than \p y,
- *              otherwise zero.
- */
-size_t mbedtls_ct_size_mask_ge( size_t x,
-                                size_t y );
-
-#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
-
-/** Constant-flow boolean "equal" comparison:
- * return x == y
- *
- * This is equivalent to \p x == \p y, but is likely to be compiled
- * to code using bitwise operation rather than a branch.
- *
- * \param x     The first value to analyze.
- * \param y     The second value to analyze.
- *
- * \return      1 if \p x equals to \p y, otherwise 0.
- */
-unsigned mbedtls_ct_size_bool_eq( size_t x,
-                                  size_t y );
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-/** Decide if an integer is less than the other, without branches.
- *
- * This is equivalent to \p x < \p y, but is likely to be compiled
- * to code using bitwise operation rather than a branch.
- *
- * \param x     The first value to analyze.
- * \param y     The second value to analyze.
- *
- * \return      1 if \p x is less than \p y, otherwise 0.
- */
-unsigned mbedtls_ct_mpi_uint_lt( const mbedtls_mpi_uint x,
-                                 const mbedtls_mpi_uint y );
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-/** Choose between two integer values without branches.
- *
- * This is equivalent to `condition ? if1 : if0`, but is likely to be compiled
- * to code using bitwise operation rather than a branch.
- *
- * \param condition     Condition to test.
- * \param if1           Value to use if \p condition is nonzero.
- * \param if0           Value to use if \p condition is zero.
- *
- * \return  \c if1 if \p condition is nonzero, otherwise \c if0.
- */
-unsigned mbedtls_ct_uint_if( unsigned condition,
-                             unsigned if1,
-                             unsigned if0 );
-
-#if defined(MBEDTLS_BIGNUM_C)
-
-/** Conditionally assign a value without branches.
- *
- * This is equivalent to `if ( condition ) dest = src`, but is likely
- * to be compiled to code using bitwise operation rather than a branch.
- *
- * \param n             \p dest and \p src must be arrays of limbs of size n.
- * \param dest          The MPI to conditionally assign to. This must point
- *                      to an initialized MPI.
- * \param src           The MPI to be assigned from. This must point to an
- *                      initialized MPI.
- * \param condition     Condition to test, must be 0 or 1.
- */
-void mbedtls_ct_mpi_uint_cond_assign( size_t n,
-                                      mbedtls_mpi_uint *dest,
-                                      const mbedtls_mpi_uint *src,
-                                      unsigned char condition );
-
-#endif /* MBEDTLS_BIGNUM_C */
-
-#if defined(MBEDTLS_BASE64_C)
-
-/** Given a value in the range 0..63, return the corresponding Base64 digit.
- *
- * The implementation assumes that letters are consecutive (e.g. ASCII
- * but not EBCDIC).
- *
- * \param value     A value in the range 0..63.
- *
- * \return          A base64 digit converted from \p value.
- */
-unsigned char mbedtls_ct_base64_enc_char( unsigned char value );
-
-/** Given a Base64 digit, return its value.
- *
- * If c is not a Base64 digit ('A'..'Z', 'a'..'z', '0'..'9', '+' or '/'),
- * return -1.
- *
- * The implementation assumes that letters are consecutive (e.g. ASCII
- * but not EBCDIC).
- *
- * \param c     A base64 digit.
- *
- * \return      The value of the base64 digit \p c.
- */
-signed char mbedtls_ct_base64_dec_value( unsigned char c );
-
-#endif /* MBEDTLS_BASE64_C */
-
-#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
-
-/** Conditional memcpy without branches.
- *
- * This is equivalent to `if ( c1 == c2 ) memcpy(dest, src, len)`, but is likely
- * to be compiled to code using bitwise operation rather than a branch.
- *
- * \param dest      The pointer to conditionally copy to.
- * \param src       The pointer to copy from. Shouldn't overlap with \p dest.
- * \param len       The number of bytes to copy.
- * \param c1        The first value to analyze in the condition.
- * \param c2        The second value to analyze in the condition.
- */
-void mbedtls_ct_memcpy_if_eq( unsigned char *dest,
-                              const unsigned char *src,
-                              size_t len,
-                              size_t c1, size_t c2 );
-
-/** Copy data from a secret position with constant flow.
- *
- * This function copies \p len bytes from \p src_base + \p offset_secret to \p
- * dst, with a code flow and memory access pattern that does not depend on \p
- * offset_secret, but only on \p offset_min, \p offset_max and \p len.
- * Functionally equivalent to `memcpy(dst, src + offset_secret, len)`.
- *
- * \param dest          The destination buffer. This must point to a writable
- *                      buffer of at least \p len bytes.
- * \param src           The base of the source buffer. This must point to a
- *                      readable buffer of at least \p offset_max + \p len
- *                      bytes. Shouldn't overlap with \p dest.
- * \param offset        The offset in the source buffer from which to copy.
- *                      This must be no less than \p offset_min and no greater
- *                      than \p offset_max.
- * \param offset_min    The minimal value of \p offset.
- * \param offset_max    The maximal value of \p offset.
- * \param len           The number of bytes to copy.
- */
-void mbedtls_ct_memcpy_offset( unsigned char *dest,
-                               const unsigned char *src,
-                               size_t offset,
-                               size_t offset_min,
-                               size_t offset_max,
-                               size_t len );
-
-/** Compute the HMAC of variable-length data with constant flow.
- *
- * This function computes the HMAC of the concatenation of \p add_data and \p
- * data, and does with a code flow and memory access pattern that does not
- * depend on \p data_len_secret, but only on \p min_data_len and \p
- * max_data_len. In particular, this function always reads exactly \p
- * max_data_len bytes from \p data.
- *
- * \param ctx               The HMAC context. It must have keys configured
- *                          with mbedtls_md_hmac_starts() and use one of the
- *                          following hashes: SHA-384, SHA-256, SHA-1 or MD-5.
- *                          It is reset using mbedtls_md_hmac_reset() after
- *                          the computation is complete to prepare for the
- *                          next computation.
- * \param add_data          The first part of the message whose HMAC is being
- *                          calculated. This must point to a readable buffer
- *                          of \p add_data_len bytes.
- * \param add_data_len      The length of \p add_data in bytes.
- * \param data              The buffer containing the second part of the
- *                          message. This must point to a readable buffer
- *                          of \p max_data_len bytes.
- * \param data_len_secret   The length of the data to process in \p data.
- *                          This must be no less than \p min_data_len and no
- *                          greater than \p max_data_len.
- * \param min_data_len      The minimal length of the second part of the
- *                          message, read from \p data.
- * \param max_data_len      The maximal length of the second part of the
- *                          message, read from \p data.
- * \param output            The HMAC will be written here. This must point to
- *                          a writable buffer of sufficient size to hold the
- *                          HMAC value.
- *
- * \retval 0 on success.
- * \retval #MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED
- *         The hardware accelerator failed.
- */
-int mbedtls_ct_hmac( mbedtls_md_context_t *ctx,
-                     const unsigned char *add_data,
-                     size_t add_data_len,
-                     const unsigned char *data,
-                     size_t data_len_secret,
-                     size_t min_data_len,
-                     size_t max_data_len,
-                     unsigned char *output );
-
-#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
-
-#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT)
-
-/** This function performs the unpadding part of a PKCS#1 v1.5 decryption
- *  operation (EME-PKCS1-v1_5 decoding).
- *
- * \note The return value from this function is a sensitive value
- *       (this is unusual). #MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE shouldn't happen
- *       in a well-written application, but 0 vs #MBEDTLS_ERR_RSA_INVALID_PADDING
- *       is often a situation that an attacker can provoke and leaking which
- *       one is the result is precisely the information the attacker wants.
- *
- * \param input          The input buffer which is the payload inside PKCS#1v1.5
- *                       encryption padding, called the "encoded message EM"
- *                       by the terminology.
- * \param ilen           The length of the payload in the \p input buffer.
- * \param output         The buffer for the payload, called "message M" by the
- *                       PKCS#1 terminology. This must be a writable buffer of
- *                       length \p output_max_len bytes.
- * \param olen           The address at which to store the length of
- *                       the payload. This must not be \c NULL.
- * \param output_max_len The length in bytes of the output buffer \p output.
- *
- * \return      \c 0 on success.
- * \return      #MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE
- *              The output buffer is too small for the unpadded payload.
- * \return      #MBEDTLS_ERR_RSA_INVALID_PADDING
- *              The input doesn't contain properly formatted padding.
- */
-int mbedtls_ct_rsaes_pkcs1_v15_unpadding( unsigned char *input,
-                                          size_t ilen,
-                                          unsigned char *output,
-                                          size_t output_max_len,
-                                          size_t *olen );
-
-#endif /* MBEDTLS_PKCS1_V15 && MBEDTLS_RSA_C && ! MBEDTLS_RSA_ALT */
-
-#endif /* MBEDTLS_CONSTANT_TIME_INTERNAL_H */
diff --git a/src/duckdb/third_party/mbedtls/library/constant_time_invasive.h b/src/duckdb/third_party/mbedtls/library/constant_time_invasive.h
deleted file mode 100644
index 4620ca137..000000000
--- a/src/duckdb/third_party/mbedtls/library/constant_time_invasive.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/**
- * \file constant_time_invasive.h
- *
- * \brief Constant-time module: interfaces for invasive testing only.
- *
- * The interfaces in this file are intended for testing purposes only.
- * They SHOULD NOT be made available in library integrations except when
- * building the library for testing.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_CONSTANT_TIME_INVASIVE_H
-#define MBEDTLS_CONSTANT_TIME_INVASIVE_H
-
-#include "common.h"
-
-#if defined(MBEDTLS_TEST_HOOKS)
-
-/** Turn a value into a mask:
- * - if \p low <= \p c <= \p high,
- *   return the all-bits 1 mask, aka (unsigned) -1
- * - otherwise, return the all-bits 0 mask, aka 0
- *
- * \param low   The value to analyze.
- * \param high  The value to analyze.
- * \param c     The value to analyze.
- *
- * \return      All-bits-one if \p low <= \p c <= \p high, otherwise zero.
- */
-unsigned char mbedtls_ct_uchar_mask_of_range( unsigned char low,
-                                              unsigned char high,
-                                              unsigned char c );
-
-#endif /* MBEDTLS_TEST_HOOKS */
-
-#endif /* MBEDTLS_CONSTANT_TIME_INVASIVE_H */
diff --git a/src/duckdb/third_party/mbedtls/library/entropy.cpp b/src/duckdb/third_party/mbedtls/library/entropy.cpp
deleted file mode 100644
index 5e1f65f13..000000000
--- a/src/duckdb/third_party/mbedtls/library/entropy.cpp
+++ /dev/null
@@ -1,701 +0,0 @@
-/*
- *  Entropy accumulator implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_ENTROPY_C)
-
-#include "mbedtls/entropy.h"
-#include "entropy_poll.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_FS_IO)
-#include <stdio.h>
-#endif
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-#include "mbedtls/platform.h"
-#endif
-
-#if defined(MBEDTLS_SELF_TEST)
-//#if defined(MBEDTLS_PLATFORM_C)
-//#include "mbedtls/platform.h"
-//#else
-//#include <stdio.h>
-//#define mbedtls_printf     printf
-//#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-
-#define ENTROPY_MAX_LOOP    256     /**< Maximum amount to loop before error */
-
-void mbedtls_entropy_init( mbedtls_entropy_context *ctx )
-{
-    ctx->source_count = 0;
-    memset( ctx->source, 0, sizeof( ctx->source ) );
-
-#if defined(MBEDTLS_THREADING_C)
-    mbedtls_mutex_init( &ctx->mutex );
-#endif
-
-    ctx->accumulator_started = 0;
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-    mbedtls_sha512_init( &ctx->accumulator );
-#else
-    mbedtls_sha256_init( &ctx->accumulator );
-#endif
-
-    /* Reminder: Update ENTROPY_HAVE_STRONG in the test files
-     *           when adding more strong entropy sources here. */
-
-#if !defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
-#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
-    mbedtls_entropy_add_source( ctx, mbedtls_platform_entropy_poll, NULL,
-                                MBEDTLS_ENTROPY_MIN_PLATFORM,
-                                MBEDTLS_ENTROPY_SOURCE_STRONG );
-#endif
-#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
-    mbedtls_entropy_add_source( ctx, mbedtls_hardware_poll, NULL,
-                                MBEDTLS_ENTROPY_MIN_HARDWARE,
-                                MBEDTLS_ENTROPY_SOURCE_STRONG );
-#endif
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-    mbedtls_entropy_add_source( ctx, mbedtls_nv_seed_poll, NULL,
-                                MBEDTLS_ENTROPY_BLOCK_SIZE,
-                                MBEDTLS_ENTROPY_SOURCE_STRONG );
-    ctx->initial_entropy_run = 0;
-#endif
-#endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
-}
-
-void mbedtls_entropy_free( mbedtls_entropy_context *ctx )
-{
-    /* If the context was already free, don't call free() again.
-     * This is important for mutexes which don't allow double-free. */
-    if( ctx->accumulator_started == -1 )
-        return;
-
-#if defined(MBEDTLS_THREADING_C)
-    mbedtls_mutex_free( &ctx->mutex );
-#endif
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-    mbedtls_sha512_free( &ctx->accumulator );
-#else
-    mbedtls_sha256_free( &ctx->accumulator );
-#endif
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-    ctx->initial_entropy_run = 0;
-#endif
-    ctx->source_count = 0;
-    mbedtls_platform_zeroize( ctx->source, sizeof( ctx->source ) );
-    ctx->accumulator_started = -1;
-}
-
-int mbedtls_entropy_add_source( mbedtls_entropy_context *ctx,
-                        mbedtls_entropy_f_source_ptr f_source, void *p_source,
-                        size_t threshold, int strong )
-{
-    int idx, ret = 0;
-
-#if defined(MBEDTLS_THREADING_C)
-    if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
-        return( ret );
-#endif
-
-    idx = ctx->source_count;
-    if( idx >= MBEDTLS_ENTROPY_MAX_SOURCES )
-    {
-        ret = MBEDTLS_ERR_ENTROPY_MAX_SOURCES;
-        goto exit;
-    }
-
-    ctx->source[idx].f_source  = f_source;
-    ctx->source[idx].p_source  = p_source;
-    ctx->source[idx].threshold = threshold;
-    ctx->source[idx].strong    = strong;
-
-    ctx->source_count++;
-
-exit:
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
-        return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
-#endif
-
-    return( ret );
-}
-
-/*
- * Entropy accumulator update
- */
-static int entropy_update( mbedtls_entropy_context *ctx, unsigned char source_id,
-                           const unsigned char *data, size_t len )
-{
-    unsigned char header[2];
-    unsigned char tmp[MBEDTLS_ENTROPY_BLOCK_SIZE];
-    size_t use_len = len;
-    const unsigned char *p = data;
-    int ret = 0;
-
-    if( use_len > MBEDTLS_ENTROPY_BLOCK_SIZE )
-    {
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-        if( ( ret = mbedtls_sha512( data, len, tmp, 0 ) ) != 0 )
-            goto cleanup;
-#else
-        if( ( ret = mbedtls_sha256( data, len, tmp, 0 ) ) != 0 )
-            goto cleanup;
-#endif
-        p = tmp;
-        use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
-    }
-
-    header[0] = source_id;
-    header[1] = use_len & 0xFF;
-
-    /*
-     * Start the accumulator if this has not already happened. Note that
-     * it is sufficient to start the accumulator here only because all calls to
-     * gather entropy eventually execute this code.
-     */
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-    if( ctx->accumulator_started == 0 &&
-        ( ret = mbedtls_sha512_starts( &ctx->accumulator, 0 ) ) != 0 )
-        goto cleanup;
-    else
-        ctx->accumulator_started = 1;
-    if( ( ret = mbedtls_sha512_update( &ctx->accumulator, header, 2 ) ) != 0 )
-        goto cleanup;
-    ret = mbedtls_sha512_update( &ctx->accumulator, p, use_len );
-#else
-    if( ctx->accumulator_started == 0 &&
-        ( ret = mbedtls_sha256_starts( &ctx->accumulator, 0 ) ) != 0 )
-        goto cleanup;
-    else
-        ctx->accumulator_started = 1;
-    if( ( ret = mbedtls_sha256_update( &ctx->accumulator, header, 2 ) ) != 0 )
-        goto cleanup;
-    ret = mbedtls_sha256_update( &ctx->accumulator, p, use_len );
-#endif
-
-cleanup:
-    mbedtls_platform_zeroize( tmp, sizeof( tmp ) );
-
-    return( ret );
-}
-
-int mbedtls_entropy_update_manual( mbedtls_entropy_context *ctx,
-                           const unsigned char *data, size_t len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-#if defined(MBEDTLS_THREADING_C)
-    if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
-        return( ret );
-#endif
-
-    ret = entropy_update( ctx, MBEDTLS_ENTROPY_SOURCE_MANUAL, data, len );
-
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
-        return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
-#endif
-
-    return( ret );
-}
-
-/*
- * Run through the different sources to add entropy to our accumulator
- */
-static int entropy_gather_internal( mbedtls_entropy_context *ctx )
-{
-    int ret = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
-    int i;
-    int have_one_strong = 0;
-    unsigned char buf[MBEDTLS_ENTROPY_MAX_GATHER];
-    size_t olen;
-
-    if( ctx->source_count == 0 )
-        return( MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED );
-
-    /*
-     * Run through our entropy sources
-     */
-    for( i = 0; i < ctx->source_count; i++ )
-    {
-        if( ctx->source[i].strong == MBEDTLS_ENTROPY_SOURCE_STRONG )
-            have_one_strong = 1;
-
-        olen = 0;
-        if( ( ret = ctx->source[i].f_source( ctx->source[i].p_source,
-                        buf, MBEDTLS_ENTROPY_MAX_GATHER, &olen ) ) != 0 )
-        {
-            goto cleanup;
-        }
-
-        /*
-         * Add if we actually gathered something
-         */
-        if( olen > 0 )
-        {
-            if( ( ret = entropy_update( ctx, (unsigned char) i,
-                                        buf, olen ) ) != 0 )
-                return( ret );
-            ctx->source[i].size += olen;
-        }
-    }
-
-    if( have_one_strong == 0 )
-        ret = MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE;
-
-cleanup:
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-
-    return( ret );
-}
-
-/*
- * Thread-safe wrapper for entropy_gather_internal()
- */
-int mbedtls_entropy_gather( mbedtls_entropy_context *ctx )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-#if defined(MBEDTLS_THREADING_C)
-    if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
-        return( ret );
-#endif
-
-    ret = entropy_gather_internal( ctx );
-
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
-        return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
-#endif
-
-    return( ret );
-}
-
-int mbedtls_entropy_func( void *data, unsigned char *output, size_t len )
-{
-    int ret, count = 0, i, thresholds_reached;
-    size_t strong_size;
-    mbedtls_entropy_context *ctx = (mbedtls_entropy_context *) data;
-    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
-
-    if( len > MBEDTLS_ENTROPY_BLOCK_SIZE )
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-    /* Update the NV entropy seed before generating any entropy for outside
-     * use.
-     */
-    if( ctx->initial_entropy_run == 0 )
-    {
-        ctx->initial_entropy_run = 1;
-        if( ( ret = mbedtls_entropy_update_nv_seed( ctx ) ) != 0 )
-            return( ret );
-    }
-#endif
-
-#if defined(MBEDTLS_THREADING_C)
-    if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
-        return( ret );
-#endif
-
-    /*
-     * Always gather extra entropy before a call
-     */
-    do
-    {
-        if( count++ > ENTROPY_MAX_LOOP )
-        {
-            ret = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
-            goto exit;
-        }
-
-        if( ( ret = entropy_gather_internal( ctx ) ) != 0 )
-            goto exit;
-
-        thresholds_reached = 1;
-        strong_size = 0;
-        for( i = 0; i < ctx->source_count; i++ )
-        {
-            if( ctx->source[i].size < ctx->source[i].threshold )
-                thresholds_reached = 0;
-            if( ctx->source[i].strong == MBEDTLS_ENTROPY_SOURCE_STRONG )
-                strong_size += ctx->source[i].size;
-        }
-    }
-    while( ! thresholds_reached || strong_size < MBEDTLS_ENTROPY_BLOCK_SIZE );
-
-    memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
-
-#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
-    /*
-     * Note that at this stage it is assumed that the accumulator was started
-     * in a previous call to entropy_update(). If this is not guaranteed, the
-     * code below will fail.
-     */
-    if( ( ret = mbedtls_sha512_finish( &ctx->accumulator, buf ) ) != 0 )
-        goto exit;
-
-    /*
-     * Reset accumulator and counters and recycle existing entropy
-     */
-    mbedtls_sha512_free( &ctx->accumulator );
-    mbedtls_sha512_init( &ctx->accumulator );
-    if( ( ret = mbedtls_sha512_starts( &ctx->accumulator, 0 ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_sha512_update( &ctx->accumulator, buf,
-                                           MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
-        goto exit;
-
-    /*
-     * Perform second SHA-512 on entropy
-     */
-    if( ( ret = mbedtls_sha512( buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
-                                    buf, 0 ) ) != 0 )
-        goto exit;
-#else /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
-    if( ( ret = mbedtls_sha256_finish( &ctx->accumulator, buf ) ) != 0 )
-        goto exit;
-
-    /*
-     * Reset accumulator and counters and recycle existing entropy
-     */
-    mbedtls_sha256_free( &ctx->accumulator );
-    mbedtls_sha256_init( &ctx->accumulator );
-    if( ( ret = mbedtls_sha256_starts( &ctx->accumulator, 0 ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_sha256_update( &ctx->accumulator, buf,
-                                           MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
-        goto exit;
-
-    /*
-     * Perform second SHA-256 on entropy
-     */
-    if( ( ret = mbedtls_sha256( buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
-                                    buf, 0 ) ) != 0 )
-        goto exit;
-#endif /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
-
-    for( i = 0; i < ctx->source_count; i++ )
-        ctx->source[i].size = 0;
-
-    memcpy( output, buf, len );
-
-    ret = 0;
-
-exit:
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
-        return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
-#endif
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-int mbedtls_entropy_update_nv_seed( mbedtls_entropy_context *ctx )
-{
-    int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
-    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
-
-    /* Read new seed  and write it to NV */
-    if( ( ret = mbedtls_entropy_func( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
-        return( ret );
-
-    if( mbedtls_nv_seed_write( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
-        return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
-
-    /* Manually update the remaining stream with a separator value to diverge */
-    memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
-    ret = mbedtls_entropy_update_manual( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
-
-    return( ret );
-}
-#endif /* MBEDTLS_ENTROPY_NV_SEED */
-
-#if defined(MBEDTLS_FS_IO)
-int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    FILE *f = NULL;
-    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
-
-    if( ( ret = mbedtls_entropy_func( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
-    {
-        ret = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
-        goto exit;
-    }
-
-    if( ( f = fopen( path, "wb" ) ) == NULL )
-    {
-        ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
-        goto exit;
-    }
-
-    if( fwrite( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) != MBEDTLS_ENTROPY_BLOCK_SIZE )
-    {
-        ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
-        goto exit;
-    }
-
-    ret = 0;
-
-exit:
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-
-    if( f != NULL )
-        fclose( f );
-
-    return( ret );
-}
-
-int mbedtls_entropy_update_seed_file( mbedtls_entropy_context *ctx, const char *path )
-{
-    int ret = 0;
-    FILE *f;
-    size_t n;
-    unsigned char buf[ MBEDTLS_ENTROPY_MAX_SEED_SIZE ];
-
-    if( ( f = fopen( path, "rb" ) ) == NULL )
-        return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
-
-    fseek( f, 0, SEEK_END );
-    n = (size_t) ftell( f );
-    fseek( f, 0, SEEK_SET );
-
-    if( n > MBEDTLS_ENTROPY_MAX_SEED_SIZE )
-        n = MBEDTLS_ENTROPY_MAX_SEED_SIZE;
-
-    if( fread( buf, 1, n, f ) != n )
-        ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
-    else
-        ret = mbedtls_entropy_update_manual( ctx, buf, n );
-
-    fclose( f );
-
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-
-    if( ret != 0 )
-        return( ret );
-
-    return( mbedtls_entropy_write_seed_file( ctx, path ) );
-}
-#endif /* MBEDTLS_FS_IO */
-
-#if defined(MBEDTLS_SELF_TEST)
-/*
- * Dummy source function
- */
-static int entropy_dummy_source( void *data, unsigned char *output,
-                                 size_t len, size_t *olen )
-{
-    ((void) data);
-
-    memset( output, 0x2a, len );
-    *olen = len;
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
-
-static int mbedtls_entropy_source_self_test_gather( unsigned char *buf, size_t buf_len )
-{
-    int ret = 0;
-    size_t entropy_len = 0;
-    size_t olen = 0;
-    size_t attempts = buf_len;
-
-    while( attempts > 0 && entropy_len < buf_len )
-    {
-        if( ( ret = mbedtls_hardware_poll( NULL, buf + entropy_len,
-            buf_len - entropy_len, &olen ) ) != 0 )
-            return( ret );
-
-        entropy_len += olen;
-        attempts--;
-    }
-
-    if( entropy_len < buf_len )
-    {
-        ret = 1;
-    }
-
-    return( ret );
-}
-
-
-static int mbedtls_entropy_source_self_test_check_bits( const unsigned char *buf,
-                                                        size_t buf_len )
-{
-    unsigned char set= 0xFF;
-    unsigned char unset = 0x00;
-    size_t i;
-
-    for( i = 0; i < buf_len; i++ )
-    {
-        set &= buf[i];
-        unset |= buf[i];
-    }
-
-    return( set == 0xFF || unset == 0x00 );
-}
-
-/*
- * A test to ensure hat the entropy sources are functioning correctly
- * and there is no obvious failure. The test performs the following checks:
- *  - The entropy source is not providing only 0s (all bits unset) or 1s (all
- *    bits set).
- *  - The entropy source is not providing values in a pattern. Because the
- *    hardware could be providing data in an arbitrary length, this check polls
- *    the hardware entropy source twice and compares the result to ensure they
- *    are not equal.
- *  - The error code returned by the entropy source is not an error.
- */
-int mbedtls_entropy_source_self_test( int verbose )
-{
-    int ret = 0;
-    unsigned char buf0[2 * sizeof( unsigned long long int )];
-    unsigned char buf1[2 * sizeof( unsigned long long int )];
-
-    if( verbose != 0 )
-        mbedtls_printf( "  ENTROPY_BIAS test: " );
-
-    memset( buf0, 0x00, sizeof( buf0 ) );
-    memset( buf1, 0x00, sizeof( buf1 ) );
-
-    if( ( ret = mbedtls_entropy_source_self_test_gather( buf0, sizeof( buf0 ) ) ) != 0 )
-        goto cleanup;
-    if( ( ret = mbedtls_entropy_source_self_test_gather( buf1, sizeof( buf1 ) ) ) != 0 )
-        goto cleanup;
-
-    /* Make sure that the returned values are not all 0 or 1 */
-    if( ( ret = mbedtls_entropy_source_self_test_check_bits( buf0, sizeof( buf0 ) ) ) != 0 )
-        goto cleanup;
-    if( ( ret = mbedtls_entropy_source_self_test_check_bits( buf1, sizeof( buf1 ) ) ) != 0 )
-        goto cleanup;
-
-    /* Make sure that the entropy source is not returning values in a
-     * pattern */
-    ret = memcmp( buf0, buf1, sizeof( buf0 ) ) == 0;
-
-cleanup:
-    if( verbose != 0 )
-    {
-        if( ret != 0 )
-            mbedtls_printf( "failed\n" );
-        else
-            mbedtls_printf( "passed\n" );
-
-        mbedtls_printf( "\n" );
-    }
-
-    return( ret != 0 );
-}
-
-#endif /* MBEDTLS_ENTROPY_HARDWARE_ALT */
-
-/*
- * The actual entropy quality is hard to test, but we can at least
- * test that the functions don't cause errors and write the correct
- * amount of data to buffers.
- */
-int mbedtls_entropy_self_test( int verbose )
-{
-    int ret = 1;
-    mbedtls_entropy_context ctx;
-    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
-    unsigned char acc[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
-    size_t i, j;
-
-    if( verbose != 0 )
-        mbedtls_printf( "  ENTROPY test: " );
-
-    mbedtls_entropy_init( &ctx );
-
-    /* First do a gather to make sure we have default sources */
-    if( ( ret = mbedtls_entropy_gather( &ctx ) ) != 0 )
-        goto cleanup;
-
-    ret = mbedtls_entropy_add_source( &ctx, entropy_dummy_source, NULL, 16,
-                                      MBEDTLS_ENTROPY_SOURCE_WEAK );
-    if( ret != 0 )
-        goto cleanup;
-
-    if( ( ret = mbedtls_entropy_update_manual( &ctx, buf, sizeof buf ) ) != 0 )
-        goto cleanup;
-
-    /*
-     * To test that mbedtls_entropy_func writes correct number of bytes:
-     * - use the whole buffer and rely on ASan to detect overruns
-     * - collect entropy 8 times and OR the result in an accumulator:
-     *   any byte should then be 0 with probably 2^(-64), so requiring
-     *   each of the 32 or 64 bytes to be non-zero has a false failure rate
-     *   of at most 2^(-58) which is acceptable.
-     */
-    for( i = 0; i < 8; i++ )
-    {
-        if( ( ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) ) ) != 0 )
-            goto cleanup;
-
-        for( j = 0; j < sizeof( buf ); j++ )
-            acc[j] |= buf[j];
-    }
-
-    for( j = 0; j < sizeof( buf ); j++ )
-    {
-        if( acc[j] == 0 )
-        {
-            ret = 1;
-            goto cleanup;
-        }
-    }
-
-#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
-    if( ( ret = mbedtls_entropy_source_self_test( 0 ) ) != 0 )
-        goto cleanup;
-#endif
-
-cleanup:
-    mbedtls_entropy_free( &ctx );
-
-    if( verbose != 0 )
-    {
-        if( ret != 0 )
-            mbedtls_printf( "failed\n" );
-        else
-            mbedtls_printf( "passed\n" );
-
-        mbedtls_printf( "\n" );
-    }
-
-    return( ret != 0 );
-}
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_ENTROPY_C */
diff --git a/src/duckdb/third_party/mbedtls/library/entropy_poll.cpp b/src/duckdb/third_party/mbedtls/library/entropy_poll.cpp
deleted file mode 100644
index 067ec2f3c..000000000
--- a/src/duckdb/third_party/mbedtls/library/entropy_poll.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- *  Platform-specific and custom entropy polling functions
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#if defined(__linux__) && !defined(_GNU_SOURCE)
-/* Ensure that syscall() is available even when compiling with -std=c99 */
-#define _GNU_SOURCE
-#endif
-
-#include "common.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_ENTROPY_C)
-
-#include "mbedtls/entropy.h"
-#include "entropy_poll.h"
-#include "mbedtls/error.h"
-
-#if defined(MBEDTLS_TIMING_C)
-#include "mbedtls/timing.h"
-#endif
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-#include "mbedtls/platform.h"
-#endif
-
-#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
-
-#if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
-    !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \
-    !defined(__HAIKU__) && !defined(__midipix__) && !defined(__MVS__)
-#error "Platform entropy sources only work on Unix and Windows, see MBEDTLS_NO_PLATFORM_ENTROPY in mbedtls_config.h"
-#endif
-
-#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
-
-#include <windows.h>
-#include <bcrypt.h>
-#include <intsafe.h>
-
-#if defined(__MINGW32__)
-// MINGW
-int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len,
-                           size_t *olen )
-{
-    HCRYPTPROV provider;
-    ((void) data);
-    *olen = 0;
-
-    if( CryptAcquireContext( &provider, NULL, NULL,
-                              PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE )
-    {
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    }
-
-    if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE )
-    {
-        CryptReleaseContext( provider, 0 );
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    }
-
-    CryptReleaseContext( provider, 0 );
-    *olen = len;
-
-    return( 0 );
-}
-#else
-int mbedtls_platform_entropy_poll(void *data, unsigned char *output, size_t len,
-                                  size_t *olen)
-{
-    ((void) data);
-    *olen = 0;
-
-    /*
-     * BCryptGenRandom takes ULONG for size, which is smaller than size_t on
-     * 64-bit Windows platforms. Extract entropy in chunks of len (dependent
-     * on ULONG_MAX) size.
-     */
-    while (len != 0) {
-        unsigned long ulong_bytes =
-            (len > ULONG_MAX) ? ULONG_MAX : (unsigned long) len;
-
-        if (!BCRYPT_SUCCESS(BCryptGenRandom(NULL, output, ulong_bytes,
-                                            BCRYPT_USE_SYSTEM_PREFERRED_RNG))) {
-            return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
-        }
-
-        *olen += ulong_bytes;
-        len -= ulong_bytes;
-    }
-
-    return 0;
-}
-#endif
-#else /* _WIN32 && !EFIX64 && !EFI32 */
-
-/*
- * Test for Linux getrandom() support.
- * Since there is no wrapper in the libc yet, use the generic syscall wrapper
- * available in GNU libc and compatible libc's (eg uClibc).
- */
-#if ((defined(__linux__) && defined(__GLIBC__)) || defined(__midipix__))
-#include <unistd.h>
-#include <sys/syscall.h>
-#if defined(SYS_getrandom)
-#define HAVE_GETRANDOM
-#include <errno.h>
-
-static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags )
-{
-    /* MemSan cannot understand that the syscall writes to the buffer */
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-    memset( buf, 0, buflen );
-#endif
-#endif
-    return( syscall( SYS_getrandom, buf, buflen, flags ) );
-}
-#endif /* SYS_getrandom */
-#endif /* __linux__ || __midipix__ */
-
-#if defined(__FreeBSD__) || defined(__DragonFly__)
-#include <sys/param.h>
-#if (defined(__FreeBSD__) && __FreeBSD_version >= 1200000) || \
-    (defined(__DragonFly__) && __DragonFly_version >= 500700)
-#include <errno.h>
-#include <sys/random.h>
-#define HAVE_GETRANDOM
-static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags )
-{
-    return getrandom( buf, buflen, flags );
-}
-#endif /* (__FreeBSD__ && __FreeBSD_version >= 1200000) ||
-          (__DragonFly__ && __DragonFly_version >= 500700) */
-#endif /* __FreeBSD__ || __DragonFly__ */
-
-/*
- * Some BSD systems provide KERN_ARND.
- * This is equivalent to reading from /dev/urandom, only it doesn't require an
- * open file descriptor, and provides up to 256 bytes per call (basically the
- * same as getentropy(), but with a longer history).
- *
- * Documentation: https://netbsd.gw.com/cgi-bin/man-cgi?sysctl+7
- */
-#if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM)
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#if defined(KERN_ARND)
-#define HAVE_SYSCTL_ARND
-
-static int sysctl_arnd_wrapper( unsigned char *buf, size_t buflen )
-{
-    int name[2];
-    size_t len;
-
-    name[0] = CTL_KERN;
-    name[1] = KERN_ARND;
-
-    while( buflen > 0 )
-    {
-        len = buflen > 256 ? 256 : buflen;
-        if( sysctl(name, 2, buf, &len, NULL, 0) == -1 )
-            return( -1 );
-        buflen -= len;
-        buf += len;
-    }
-    return( 0 );
-}
-#endif /* KERN_ARND */
-#endif /* __FreeBSD__ || __NetBSD__ */
-
-#include <stdio.h>
-
-int mbedtls_platform_entropy_poll( void *data,
-                           unsigned char *output, size_t len, size_t *olen )
-{
-    FILE *file;
-    size_t read_len;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    ((void) data);
-
-#if defined(HAVE_GETRANDOM)
-    ret = getrandom_wrapper( output, len, 0 );
-    if( ret >= 0 )
-    {
-        *olen = ret;
-        return( 0 );
-    }
-    else if( errno != ENOSYS )
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    /* Fall through if the system call isn't known. */
-#else
-    ((void) ret);
-#endif /* HAVE_GETRANDOM */
-
-#if defined(HAVE_SYSCTL_ARND)
-    ((void) file);
-    ((void) read_len);
-    if( sysctl_arnd_wrapper( output, len ) == -1 )
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    *olen = len;
-    return( 0 );
-#else
-
-    *olen = 0;
-
-    file = fopen( "/dev/urandom", "rb" );
-    if( file == NULL )
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-    read_len = fread( output, 1, len, file );
-    if( read_len != len )
-    {
-        fclose( file );
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    }
-
-    fclose( file );
-    *olen = len;
-
-    return( 0 );
-#endif /* HAVE_SYSCTL_ARND */
-}
-#endif /* _WIN32 && !EFIX64 && !EFI32 */
-#endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-int mbedtls_nv_seed_poll( void *data,
-                          unsigned char *output, size_t len, size_t *olen )
-{
-    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
-    size_t use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
-    ((void) data);
-
-    memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
-
-    if( mbedtls_nv_seed_read( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
-      return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-    if( len < use_len )
-      use_len = len;
-
-    memcpy( output, buf, use_len );
-    *olen = use_len;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_ENTROPY_NV_SEED */
-
-#endif /* MBEDTLS_ENTROPY_C */
diff --git a/src/duckdb/third_party/mbedtls/library/entropy_poll.h b/src/duckdb/third_party/mbedtls/library/entropy_poll.h
deleted file mode 100644
index aef1a0977..000000000
--- a/src/duckdb/third_party/mbedtls/library/entropy_poll.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * \file entropy_poll.h
- *
- * \brief Platform-specific and custom entropy polling functions
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_ENTROPY_POLL_H
-#define MBEDTLS_ENTROPY_POLL_H
-
-#include "mbedtls/build_info.h"
-
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Default thresholds for built-in sources, in bytes
- */
-#define MBEDTLS_ENTROPY_MIN_PLATFORM     32     /**< Minimum for platform source    */
-#if !defined(MBEDTLS_ENTROPY_MIN_HARDWARE)
-#define MBEDTLS_ENTROPY_MIN_HARDWARE     32     /**< Minimum for the hardware source */
-#endif
-
-#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
-/**
- * \brief           Platform-specific entropy poll callback
- */
-int mbedtls_platform_entropy_poll( void *data,
-                           unsigned char *output, size_t len, size_t *olen );
-#endif
-
-#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
-/**
- * \brief           Entropy poll callback for a hardware source
- *
- * \warning         This is not provided by mbed TLS!
- *                  See \c MBEDTLS_ENTROPY_HARDWARE_ALT in mbedtls_config.h.
- *
- * \note            This must accept NULL as its first argument.
- */
-int mbedtls_hardware_poll( void *data,
-                           unsigned char *output, size_t len, size_t *olen );
-#endif
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-/**
- * \brief           Entropy poll callback for a non-volatile seed file
- *
- * \note            This must accept NULL as its first argument.
- */
-int mbedtls_nv_seed_poll( void *data,
-                          unsigned char *output, size_t len, size_t *olen );
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* entropy_poll.h */
diff --git a/src/duckdb/third_party/mbedtls/library/gcm.cpp b/src/duckdb/third_party/mbedtls/library/gcm.cpp
deleted file mode 100644
index 8505cf4e0..000000000
--- a/src/duckdb/third_party/mbedtls/library/gcm.cpp
+++ /dev/null
@@ -1,1161 +0,0 @@
-/*
- *  NIST SP800-38D compliant GCM implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-/*
- * http://csrc.nist.gov/publications/nistpubs/800-38D/SP-800-38D.pdf
- *
- * See also:
- * [MGV] http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-revised-spec.pdf
- *
- * We use the algorithm described as Shoup's method with 4-bit tables in
- * [MGV] 4.1, pp. 12-13, to enhance speed without using too much memory.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_GCM_C)
-
-#include "mbedtls/gcm.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_AESNI_C)
-#include "aesni.h"
-#endif
-
-#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
-#include "mbedtls/aes.h"
-#include "mbedtls/platform.h"
-#if !defined(MBEDTLS_PLATFORM_C)
-#include <stdio.h>
-#define mbedtls_printf printf
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
-
-#if !defined(MBEDTLS_GCM_ALT)
-
-/* Parameter validation macros */
-#define GCM_VALIDATE_RET( cond ) \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_GCM_BAD_INPUT )
-#define GCM_VALIDATE( cond ) \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-/*
- * Initialize a context
- */
-void mbedtls_gcm_init( mbedtls_gcm_context *ctx )
-{
-    GCM_VALIDATE( ctx != NULL );
-    memset( ctx, 0, sizeof( mbedtls_gcm_context ) );
-}
-
-/*
- * Precompute small multiples of H, that is set
- *      HH[i] || HL[i] = H times i,
- * where i is seen as a field element as in [MGV], ie high-order bits
- * correspond to low powers of P. The result is stored in the same way, that
- * is the high-order bit of HH corresponds to P^0 and the low-order bit of HL
- * corresponds to P^127.
- */
-static int gcm_gen_table( mbedtls_gcm_context *ctx )
-{
-    int ret, i, j;
-    uint64_t hi, lo;
-    uint64_t vl, vh;
-    unsigned char h[16];
-    size_t olen = 0;
-
-    memset( h, 0, 16 );
-    if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, h, 16, h, &olen ) ) != 0 )
-        return( ret );
-
-    /* pack h as two 64-bits ints, big-endian */
-    hi = MBEDTLS_GET_UINT32_BE( h,  0  );
-    lo = MBEDTLS_GET_UINT32_BE( h,  4  );
-    vh = (uint64_t) hi << 32 | lo;
-
-    hi = MBEDTLS_GET_UINT32_BE( h,  8  );
-    lo = MBEDTLS_GET_UINT32_BE( h,  12 );
-    vl = (uint64_t) hi << 32 | lo;
-
-    /* 8 = 1000 corresponds to 1 in GF(2^128) */
-    ctx->HL[8] = vl;
-    ctx->HH[8] = vh;
-
-#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
-    /* With CLMUL support, we need only h, not the rest of the table */
-    if( mbedtls_aesni_has_support( MBEDTLS_AESNI_CLMUL ) )
-        return( 0 );
-#endif
-
-    /* 0 corresponds to 0 in GF(2^128) */
-    ctx->HH[0] = 0;
-    ctx->HL[0] = 0;
-
-    for( i = 4; i > 0; i >>= 1 )
-    {
-        uint32_t T = ( vl & 1 ) * 0xe1000000U;
-        vl  = ( vh << 63 ) | ( vl >> 1 );
-        vh  = ( vh >> 1 ) ^ ( (uint64_t) T << 32);
-
-        ctx->HL[i] = vl;
-        ctx->HH[i] = vh;
-    }
-
-    for( i = 2; i <= 8; i *= 2 )
-    {
-        uint64_t *HiL = ctx->HL + i, *HiH = ctx->HH + i;
-        vh = *HiH;
-        vl = *HiL;
-        for( j = 1; j < i; j++ )
-        {
-            HiH[j] = vh ^ ctx->HH[j];
-            HiL[j] = vl ^ ctx->HL[j];
-        }
-    }
-
-    return( 0 );
-}
-
-int mbedtls_gcm_setkey( mbedtls_gcm_context *ctx,
-                        mbedtls_cipher_id_t cipher,
-                        const unsigned char *key,
-                        unsigned int keybits )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    const mbedtls_cipher_info_t *cipher_info;
-
-    GCM_VALIDATE_RET( ctx != NULL );
-    GCM_VALIDATE_RET( key != NULL );
-    GCM_VALIDATE_RET( keybits == 128 || keybits == 192 || keybits == 256 );
-
-    cipher_info = mbedtls_cipher_info_from_values( cipher, keybits,
-                                                   MBEDTLS_MODE_ECB );
-    if( cipher_info == NULL )
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-
-    if( cipher_info->block_size != 16 )
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-
-    mbedtls_cipher_free( &ctx->cipher_ctx );
-
-    if( ( ret = mbedtls_cipher_setup( &ctx->cipher_ctx, cipher_info ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keybits,
-                               MBEDTLS_ENCRYPT ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    if( ( ret = gcm_gen_table( ctx ) ) != 0 )
-        return( ret );
-
-    return( 0 );
-}
-
-/*
- * Shoup's method for multiplication use this table with
- *      last4[x] = x times P^128
- * where x and last4[x] are seen as elements of GF(2^128) as in [MGV]
- */
-static const uint64_t last4[16] =
-{
-    0x0000, 0x1c20, 0x3840, 0x2460,
-    0x7080, 0x6ca0, 0x48c0, 0x54e0,
-    0xe100, 0xfd20, 0xd940, 0xc560,
-    0x9180, 0x8da0, 0xa9c0, 0xb5e0
-};
-
-/*
- * Sets output to x times H using the precomputed tables.
- * x and output are seen as elements of GF(2^128) as in [MGV].
- */
-static void gcm_mult( mbedtls_gcm_context *ctx, const unsigned char x[16],
-                      unsigned char output[16] )
-{
-    int i = 0;
-    unsigned char lo, hi, rem;
-    uint64_t zh, zl;
-
-#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
-    if( mbedtls_aesni_has_support( MBEDTLS_AESNI_CLMUL ) ) {
-        unsigned char h[16];
-
-        MBEDTLS_PUT_UINT32_BE( ctx->HH[8] >> 32, h,  0 );
-        MBEDTLS_PUT_UINT32_BE( ctx->HH[8],       h,  4 );
-        MBEDTLS_PUT_UINT32_BE( ctx->HL[8] >> 32, h,  8 );
-        MBEDTLS_PUT_UINT32_BE( ctx->HL[8],       h, 12 );
-
-        mbedtls_aesni_gcm_mult( output, x, h );
-        return;
-    }
-#endif /* MBEDTLS_AESNI_C && MBEDTLS_HAVE_X86_64 */
-
-    lo = x[15] & 0xf;
-
-    zh = ctx->HH[lo];
-    zl = ctx->HL[lo];
-
-    for( i = 15; i >= 0; i-- )
-    {
-        lo = x[i] & 0xf;
-        hi = ( x[i] >> 4 ) & 0xf;
-
-        if( i != 15 )
-        {
-            rem = (unsigned char) zl & 0xf;
-            zl = ( zh << 60 ) | ( zl >> 4 );
-            zh = ( zh >> 4 );
-            zh ^= (uint64_t) last4[rem] << 48;
-            zh ^= ctx->HH[lo];
-            zl ^= ctx->HL[lo];
-
-        }
-
-        rem = (unsigned char) zl & 0xf;
-        zl = ( zh << 60 ) | ( zl >> 4 );
-        zh = ( zh >> 4 );
-        zh ^= (uint64_t) last4[rem] << 48;
-        zh ^= ctx->HH[hi];
-        zl ^= ctx->HL[hi];
-    }
-
-    MBEDTLS_PUT_UINT32_BE( zh >> 32, output, 0 );
-    MBEDTLS_PUT_UINT32_BE( zh, output, 4 );
-    MBEDTLS_PUT_UINT32_BE( zl >> 32, output, 8 );
-    MBEDTLS_PUT_UINT32_BE( zl, output, 12 );
-}
-
-int mbedtls_gcm_starts( mbedtls_gcm_context *ctx,
-                        int mode,
-                        const unsigned char *iv, size_t iv_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char work_buf[16];
-    size_t i;
-    const unsigned char *p;
-    size_t use_len, olen = 0;
-    uint64_t iv_bits;
-
-    GCM_VALIDATE_RET( ctx != NULL );
-    GCM_VALIDATE_RET( iv != NULL );
-
-    /* IV is limited to 2^64 bits, so 2^61 bytes */
-    /* IV is not allowed to be zero length */
-    if( iv_len == 0 || (uint64_t) iv_len >> 61 != 0 )
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-
-    memset( ctx->y, 0x00, sizeof(ctx->y) );
-    memset( ctx->buf, 0x00, sizeof(ctx->buf) );
-
-    ctx->mode = mode;
-    ctx->len = 0;
-    ctx->add_len = 0;
-
-    if( iv_len == 12 )
-    {
-        memcpy( ctx->y, iv, iv_len );
-        ctx->y[15] = 1;
-    }
-    else
-    {
-        memset( work_buf, 0x00, 16 );
-        iv_bits = (uint64_t)iv_len * 8;
-        MBEDTLS_PUT_UINT64_BE( iv_bits, work_buf, 8 );
-
-        p = iv;
-        while( iv_len > 0 )
-        {
-            use_len = ( iv_len < 16 ) ? iv_len : 16;
-
-            for( i = 0; i < use_len; i++ )
-                ctx->y[i] ^= p[i];
-
-            gcm_mult( ctx, ctx->y, ctx->y );
-
-            iv_len -= use_len;
-            p += use_len;
-        }
-
-        for( i = 0; i < 16; i++ )
-            ctx->y[i] ^= work_buf[i];
-
-        gcm_mult( ctx, ctx->y, ctx->y );
-    }
-
-    if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctx->y, 16,
-                                       ctx->base_ectr, &olen ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    return( 0 );
-}
-
-/**
- * mbedtls_gcm_context::buf contains the partial state of the computation of
- * the authentication tag.
- * mbedtls_gcm_context::add_len and mbedtls_gcm_context::len indicate
- * different stages of the computation:
- *     * len == 0 && add_len == 0:      initial state
- *     * len == 0 && add_len % 16 != 0: the first `add_len % 16` bytes have
- *                                      a partial block of AD that has been
- *                                      xored in but not yet multiplied in.
- *     * len == 0 && add_len % 16 == 0: the authentication tag is correct if
- *                                      the data ends now.
- *     * len % 16 != 0:                 the first `len % 16` bytes have
- *                                      a partial block of ciphertext that has
- *                                      been xored in but not yet multiplied in.
- *     * len > 0 && len % 16 == 0:      the authentication tag is correct if
- *                                      the data ends now.
- */
-int mbedtls_gcm_update_ad( mbedtls_gcm_context *ctx,
-                           const unsigned char *add, size_t add_len )
-{
-    const unsigned char *p;
-    size_t use_len, i, offset;
-
-    GCM_VALIDATE_RET( add_len == 0 || add != NULL );
-
-    /* IV is limited to 2^64 bits, so 2^61 bytes */
-    if( (uint64_t) add_len >> 61 != 0 )
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-
-    offset = ctx->add_len % 16;
-    p = add;
-
-    if( offset != 0 )
-    {
-        use_len = 16 - offset;
-        if( use_len > add_len )
-            use_len = add_len;
-
-        for( i = 0; i < use_len; i++ )
-            ctx->buf[i+offset] ^= p[i];
-
-        if( offset + use_len == 16 )
-            gcm_mult( ctx, ctx->buf, ctx->buf );
-
-        ctx->add_len += use_len;
-        add_len -= use_len;
-        p += use_len;
-    }
-
-    ctx->add_len += add_len;
-
-    while( add_len >= 16 )
-    {
-        for( i = 0; i < 16; i++ )
-            ctx->buf[i] ^= p[i];
-
-        gcm_mult( ctx, ctx->buf, ctx->buf );
-
-        add_len -= 16;
-        p += 16;
-    }
-
-    if( add_len > 0 )
-    {
-        for( i = 0; i < add_len; i++ )
-            ctx->buf[i] ^= p[i];
-    }
-
-    return( 0 );
-}
-
-/* Increment the counter. */
-static void gcm_incr( unsigned char y[16] )
-{
-    size_t i;
-    for( i = 16; i > 12; i-- )
-        if( ++y[i - 1] != 0 )
-            break;
-}
-
-/* Calculate and apply the encryption mask. Process use_len bytes of data,
- * starting at position offset in the mask block. */
-static int gcm_mask( mbedtls_gcm_context *ctx,
-                     unsigned char ectr[16],
-                     size_t offset, size_t use_len,
-                     const unsigned char *input,
-                     unsigned char *output )
-{
-    size_t i;
-    size_t olen = 0;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctx->y, 16, ectr,
-                                       &olen ) ) != 0 )
-    {
-        mbedtls_platform_zeroize( ectr, 16 );
-        return( ret );
-    }
-
-    for( i = 0; i < use_len; i++ )
-    {
-        if( ctx->mode == MBEDTLS_GCM_DECRYPT )
-            ctx->buf[offset + i] ^= input[i];
-        output[i] = ectr[offset + i] ^ input[i];
-        if( ctx->mode == MBEDTLS_GCM_ENCRYPT )
-            ctx->buf[offset + i] ^= output[i];
-    }
-    return( 0 );
-}
-
-int mbedtls_gcm_update( mbedtls_gcm_context *ctx,
-                        const unsigned char *input, size_t input_length,
-                        unsigned char *output, size_t output_size,
-                        size_t *output_length )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    const unsigned char *p = input;
-    unsigned char *out_p = output;
-    size_t offset;
-    unsigned char ectr[16];
-
-    if( output_size < input_length )
-        return( MBEDTLS_ERR_GCM_BUFFER_TOO_SMALL );
-    GCM_VALIDATE_RET( output_length != NULL );
-    *output_length = input_length;
-
-    /* Exit early if input_length==0 so that we don't do any pointer arithmetic
-     * on a potentially null pointer.
-     * Returning early also means that the last partial block of AD remains
-     * untouched for mbedtls_gcm_finish */
-    if( input_length == 0 )
-        return( 0 );
-
-    GCM_VALIDATE_RET( ctx != NULL );
-    GCM_VALIDATE_RET( input != NULL );
-    GCM_VALIDATE_RET( output != NULL );
-
-    if( output > input && (size_t) ( output - input ) < input_length )
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-
-    /* Total length is restricted to 2^39 - 256 bits, ie 2^36 - 2^5 bytes
-     * Also check for possible overflow */
-    if( ctx->len + input_length < ctx->len ||
-        (uint64_t) ctx->len + input_length > 0xFFFFFFFE0ull )
-    {
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-    }
-
-    if( ctx->len == 0 && ctx->add_len % 16 != 0 )
-    {
-        gcm_mult( ctx, ctx->buf, ctx->buf );
-    }
-
-    offset = ctx->len % 16;
-    if( offset != 0 )
-    {
-        size_t use_len = 16 - offset;
-        if( use_len > input_length )
-            use_len = input_length;
-
-        if( ( ret = gcm_mask( ctx, ectr, offset, use_len, p, out_p ) ) != 0 )
-            return( ret );
-
-        if( offset + use_len == 16 )
-            gcm_mult( ctx, ctx->buf, ctx->buf );
-
-        ctx->len += use_len;
-        input_length -= use_len;
-        p += use_len;
-        out_p += use_len;
-    }
-
-    ctx->len += input_length;
-
-    while( input_length >= 16 )
-    {
-        gcm_incr( ctx->y );
-        if( ( ret = gcm_mask( ctx, ectr, 0, 16, p, out_p ) ) != 0 )
-            return( ret );
-
-        gcm_mult( ctx, ctx->buf, ctx->buf );
-
-        input_length -= 16;
-        p += 16;
-        out_p += 16;
-    }
-
-    if( input_length > 0 )
-    {
-        gcm_incr( ctx->y );
-        if( ( ret = gcm_mask( ctx, ectr, 0, input_length, p, out_p ) ) != 0 )
-            return( ret );
-    }
-
-    mbedtls_platform_zeroize( ectr, sizeof( ectr ) );
-    return( 0 );
-}
-
-int mbedtls_gcm_finish( mbedtls_gcm_context *ctx,
-                        unsigned char *output, size_t output_size,
-                        size_t *output_length,
-                        unsigned char *tag, size_t tag_len )
-{
-    unsigned char work_buf[16];
-    size_t i;
-    uint64_t orig_len;
-    uint64_t orig_add_len;
-
-    GCM_VALIDATE_RET( ctx != NULL );
-    GCM_VALIDATE_RET( tag != NULL );
-
-    /* We never pass any output in finish(). The output parameter exists only
-     * for the sake of alternative implementations. */
-    (void) output;
-    (void) output_size;
-    *output_length = 0;
-
-    orig_len = ctx->len * 8;
-    orig_add_len = ctx->add_len * 8;
-
-    if( ctx->len == 0 && ctx->add_len % 16 != 0 )
-    {
-        gcm_mult( ctx, ctx->buf, ctx->buf );
-    }
-
-    if( tag_len > 16 || tag_len < 4 )
-        return( MBEDTLS_ERR_GCM_BAD_INPUT );
-
-    if( ctx->len % 16 != 0 )
-        gcm_mult( ctx, ctx->buf, ctx->buf );
-
-    memcpy( tag, ctx->base_ectr, tag_len );
-
-    if( orig_len || orig_add_len )
-    {
-        memset( work_buf, 0x00, 16 );
-
-        MBEDTLS_PUT_UINT32_BE( ( orig_add_len >> 32 ), work_buf, 0  );
-        MBEDTLS_PUT_UINT32_BE( ( orig_add_len       ), work_buf, 4  );
-        MBEDTLS_PUT_UINT32_BE( ( orig_len     >> 32 ), work_buf, 8  );
-        MBEDTLS_PUT_UINT32_BE( ( orig_len           ), work_buf, 12 );
-
-        for( i = 0; i < 16; i++ )
-            ctx->buf[i] ^= work_buf[i];
-
-        gcm_mult( ctx, ctx->buf, ctx->buf );
-
-        for( i = 0; i < tag_len; i++ )
-            tag[i] ^= ctx->buf[i];
-    }
-
-    return( 0 );
-}
-
-int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx,
-                       int mode,
-                       size_t length,
-                       const unsigned char *iv,
-                       size_t iv_len,
-                       const unsigned char *add,
-                       size_t add_len,
-                       const unsigned char *input,
-                       unsigned char *output,
-                       size_t tag_len,
-                       unsigned char *tag )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t olen;
-
-    GCM_VALIDATE_RET( ctx != NULL );
-    GCM_VALIDATE_RET( iv != NULL );
-    GCM_VALIDATE_RET( add_len == 0 || add != NULL );
-    GCM_VALIDATE_RET( length == 0 || input != NULL );
-    GCM_VALIDATE_RET( length == 0 || output != NULL );
-    GCM_VALIDATE_RET( tag != NULL );
-
-    if( ( ret = mbedtls_gcm_starts( ctx, mode, iv, iv_len ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_gcm_update_ad( ctx, add, add_len ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_gcm_update( ctx, input, length,
-                                    output, length, &olen ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_gcm_finish( ctx, NULL, 0, &olen, tag, tag_len ) ) != 0 )
-        return( ret );
-
-    return( 0 );
-}
-
-int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *ctx,
-                      size_t length,
-                      const unsigned char *iv,
-                      size_t iv_len,
-                      const unsigned char *add,
-                      size_t add_len,
-                      const unsigned char *tag,
-                      size_t tag_len,
-                      const unsigned char *input,
-                      unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char check_tag[16];
-    size_t i;
-    int diff;
-
-    GCM_VALIDATE_RET( ctx != NULL );
-    GCM_VALIDATE_RET( iv != NULL );
-    GCM_VALIDATE_RET( add_len == 0 || add != NULL );
-    GCM_VALIDATE_RET( tag != NULL );
-    GCM_VALIDATE_RET( length == 0 || input != NULL );
-    GCM_VALIDATE_RET( length == 0 || output != NULL );
-
-    if( ( ret = mbedtls_gcm_crypt_and_tag( ctx, MBEDTLS_GCM_DECRYPT, length,
-                                   iv, iv_len, add, add_len,
-                                   input, output, tag_len, check_tag ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    /* Check tag in "constant-time" */
-    for( diff = 0, i = 0; i < tag_len; i++ )
-        diff |= tag[i] ^ check_tag[i];
-
-    if( diff != 0 )
-    {
-        mbedtls_platform_zeroize( output, length );
-        return( MBEDTLS_ERR_GCM_AUTH_FAILED );
-    }
-
-    return( 0 );
-}
-
-void mbedtls_gcm_free( mbedtls_gcm_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-    mbedtls_cipher_free( &ctx->cipher_ctx );
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_gcm_context ) );
-}
-
-#endif /* !MBEDTLS_GCM_ALT */
-
-#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
-/*
- * AES-GCM test vectors from:
- *
- * http://csrc.nist.gov/groups/STM/cavp/documents/mac/gcmtestvectors.zip
- */
-#define MAX_TESTS   6
-
-static const int key_index_test_data[MAX_TESTS] =
-    { 0, 0, 1, 1, 1, 1 };
-
-static const unsigned char key_test_data[MAX_TESTS][32] =
-{
-    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-    { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
-      0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
-      0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
-      0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08 },
-};
-
-static const size_t iv_len_test_data[MAX_TESTS] =
-    { 12, 12, 12, 12, 8, 60 };
-
-static const int iv_index_test_data[MAX_TESTS] =
-    { 0, 0, 1, 1, 1, 2 };
-
-static const unsigned char iv_test_data[MAX_TESTS][64] =
-{
-    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00 },
-    { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
-      0xde, 0xca, 0xf8, 0x88 },
-    { 0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
-      0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
-      0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
-      0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
-      0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
-      0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
-      0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
-      0xa6, 0x37, 0xb3, 0x9b },
-};
-
-static const size_t add_len_test_data[MAX_TESTS] =
-    { 0, 0, 0, 20, 20, 20 };
-
-static const int add_index_test_data[MAX_TESTS] =
-    { 0, 0, 0, 1, 1, 1 };
-
-static const unsigned char additional_test_data[MAX_TESTS][64] =
-{
-    { 0x00 },
-    { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
-      0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
-      0xab, 0xad, 0xda, 0xd2 },
-};
-
-static const size_t pt_len_test_data[MAX_TESTS] =
-    { 0, 16, 64, 60, 60, 60 };
-
-static const int pt_index_test_data[MAX_TESTS] =
-    { 0, 0, 1, 1, 1, 1 };
-
-static const unsigned char pt_test_data[MAX_TESTS][64] =
-{
-    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-    { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
-      0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
-      0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
-      0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
-      0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
-      0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
-      0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
-      0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55 },
-};
-
-static const unsigned char ct_test_data[MAX_TESTS * 3][64] =
-{
-    { 0x00 },
-    { 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92,
-      0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78 },
-    { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
-      0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
-      0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
-      0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
-      0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
-      0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
-      0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
-      0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85 },
-    { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
-      0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
-      0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
-      0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
-      0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
-      0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
-      0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
-      0x3d, 0x58, 0xe0, 0x91 },
-    { 0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a,
-      0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55,
-      0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8,
-      0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23,
-      0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2,
-      0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42,
-      0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07,
-      0xc2, 0x3f, 0x45, 0x98 },
-    { 0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6,
-      0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94,
-      0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8,
-      0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7,
-      0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90,
-      0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f,
-      0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03,
-      0x4c, 0x34, 0xae, 0xe5 },
-    { 0x00 },
-    { 0x98, 0xe7, 0x24, 0x7c, 0x07, 0xf0, 0xfe, 0x41,
-      0x1c, 0x26, 0x7e, 0x43, 0x84, 0xb0, 0xf6, 0x00 },
-    { 0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
-      0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
-      0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
-      0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
-      0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
-      0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
-      0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
-      0xcc, 0xda, 0x27, 0x10, 0xac, 0xad, 0xe2, 0x56 },
-    { 0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
-      0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
-      0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
-      0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
-      0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
-      0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
-      0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
-      0xcc, 0xda, 0x27, 0x10 },
-    { 0x0f, 0x10, 0xf5, 0x99, 0xae, 0x14, 0xa1, 0x54,
-      0xed, 0x24, 0xb3, 0x6e, 0x25, 0x32, 0x4d, 0xb8,
-      0xc5, 0x66, 0x63, 0x2e, 0xf2, 0xbb, 0xb3, 0x4f,
-      0x83, 0x47, 0x28, 0x0f, 0xc4, 0x50, 0x70, 0x57,
-      0xfd, 0xdc, 0x29, 0xdf, 0x9a, 0x47, 0x1f, 0x75,
-      0xc6, 0x65, 0x41, 0xd4, 0xd4, 0xda, 0xd1, 0xc9,
-      0xe9, 0x3a, 0x19, 0xa5, 0x8e, 0x8b, 0x47, 0x3f,
-      0xa0, 0xf0, 0x62, 0xf7 },
-    { 0xd2, 0x7e, 0x88, 0x68, 0x1c, 0xe3, 0x24, 0x3c,
-      0x48, 0x30, 0x16, 0x5a, 0x8f, 0xdc, 0xf9, 0xff,
-      0x1d, 0xe9, 0xa1, 0xd8, 0xe6, 0xb4, 0x47, 0xef,
-      0x6e, 0xf7, 0xb7, 0x98, 0x28, 0x66, 0x6e, 0x45,
-      0x81, 0xe7, 0x90, 0x12, 0xaf, 0x34, 0xdd, 0xd9,
-      0xe2, 0xf0, 0x37, 0x58, 0x9b, 0x29, 0x2d, 0xb3,
-      0xe6, 0x7c, 0x03, 0x67, 0x45, 0xfa, 0x22, 0xe7,
-      0xe9, 0xb7, 0x37, 0x3b },
-    { 0x00 },
-    { 0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e,
-      0x07, 0x4e, 0xc5, 0xd3, 0xba, 0xf3, 0x9d, 0x18 },
-    { 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
-      0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
-      0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
-      0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
-      0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
-      0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
-      0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
-      0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad },
-    { 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
-      0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
-      0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
-      0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
-      0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
-      0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
-      0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
-      0xbc, 0xc9, 0xf6, 0x62 },
-    { 0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32,
-      0xae, 0x47, 0xc1, 0x3b, 0xf1, 0x98, 0x44, 0xcb,
-      0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
-      0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0,
-      0xfe, 0xb5, 0x82, 0xd3, 0x39, 0x34, 0xa4, 0xf0,
-      0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
-      0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99,
-      0xf4, 0x7c, 0x9b, 0x1f },
-    { 0x5a, 0x8d, 0xef, 0x2f, 0x0c, 0x9e, 0x53, 0xf1,
-      0xf7, 0x5d, 0x78, 0x53, 0x65, 0x9e, 0x2a, 0x20,
-      0xee, 0xb2, 0xb2, 0x2a, 0xaf, 0xde, 0x64, 0x19,
-      0xa0, 0x58, 0xab, 0x4f, 0x6f, 0x74, 0x6b, 0xf4,
-      0x0f, 0xc0, 0xc3, 0xb7, 0x80, 0xf2, 0x44, 0x45,
-      0x2d, 0xa3, 0xeb, 0xf1, 0xc5, 0xd8, 0x2c, 0xde,
-      0xa2, 0x41, 0x89, 0x97, 0x20, 0x0e, 0xf8, 0x2e,
-      0x44, 0xae, 0x7e, 0x3f },
-};
-
-static const unsigned char tag_test_data[MAX_TESTS * 3][16] =
-{
-    { 0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, 0x30, 0x61,
-      0x36, 0x7f, 0x1d, 0x57, 0xa4, 0xe7, 0x45, 0x5a },
-    { 0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd,
-      0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf },
-    { 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6,
-      0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4 },
-    { 0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
-      0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47 },
-    { 0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85,
-      0x56, 0x1b, 0xe1, 0x4a, 0xac, 0xa2, 0xfc, 0xcb },
-    { 0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa,
-      0x46, 0x2a, 0xf4, 0x3c, 0x16, 0x99, 0xd0, 0x50 },
-    { 0xcd, 0x33, 0xb2, 0x8a, 0xc7, 0x73, 0xf7, 0x4b,
-      0xa0, 0x0e, 0xd1, 0xf3, 0x12, 0x57, 0x24, 0x35 },
-    { 0x2f, 0xf5, 0x8d, 0x80, 0x03, 0x39, 0x27, 0xab,
-      0x8e, 0xf4, 0xd4, 0x58, 0x75, 0x14, 0xf0, 0xfb },
-    { 0x99, 0x24, 0xa7, 0xc8, 0x58, 0x73, 0x36, 0xbf,
-      0xb1, 0x18, 0x02, 0x4d, 0xb8, 0x67, 0x4a, 0x14 },
-    { 0x25, 0x19, 0x49, 0x8e, 0x80, 0xf1, 0x47, 0x8f,
-      0x37, 0xba, 0x55, 0xbd, 0x6d, 0x27, 0x61, 0x8c },
-    { 0x65, 0xdc, 0xc5, 0x7f, 0xcf, 0x62, 0x3a, 0x24,
-      0x09, 0x4f, 0xcc, 0xa4, 0x0d, 0x35, 0x33, 0xf8 },
-    { 0xdc, 0xf5, 0x66, 0xff, 0x29, 0x1c, 0x25, 0xbb,
-      0xb8, 0x56, 0x8f, 0xc3, 0xd3, 0x76, 0xa6, 0xd9 },
-    { 0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9,
-      0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b },
-    { 0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0,
-      0x26, 0x5b, 0x98, 0xb5, 0xd4, 0x8a, 0xb9, 0x19 },
-    { 0xb0, 0x94, 0xda, 0xc5, 0xd9, 0x34, 0x71, 0xbd,
-      0xec, 0x1a, 0x50, 0x22, 0x70, 0xe3, 0xcc, 0x6c },
-    { 0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68,
-      0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b },
-    { 0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4,
-      0x5e, 0x45, 0x49, 0x13, 0xfe, 0x2e, 0xa8, 0xf2 },
-    { 0xa4, 0x4a, 0x82, 0x66, 0xee, 0x1c, 0x8e, 0xb0,
-      0xc8, 0xb5, 0xd4, 0xcf, 0x5a, 0xe9, 0xf1, 0x9a },
-};
-
-int mbedtls_gcm_self_test( int verbose )
-{
-    mbedtls_gcm_context ctx;
-    unsigned char buf[64];
-    unsigned char tag_buf[16];
-    int i, j, ret;
-    mbedtls_cipher_id_t cipher = MBEDTLS_CIPHER_ID_AES;
-    size_t olen;
-
-    for( j = 0; j < 3; j++ )
-    {
-        int key_len = 128 + 64 * j;
-
-        for( i = 0; i < MAX_TESTS; i++ )
-        {
-            mbedtls_gcm_init( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "  AES-GCM-%3d #%d (%s): ",
-                                key_len, i, "enc" );
-
-            ret = mbedtls_gcm_setkey( &ctx, cipher,
-                                      key_test_data[key_index_test_data[i]],
-                                      key_len );
-            /*
-             * AES-192 is an optional feature that may be unavailable when
-             * there is an alternative underlying implementation i.e. when
-             * MBEDTLS_AES_ALT is defined.
-             */
-            if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && key_len == 192 )
-            {
-                mbedtls_printf( "skipped\n" );
-                break;
-            }
-            else if( ret != 0 )
-            {
-                goto exit;
-            }
-
-            ret = mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_ENCRYPT,
-                                pt_len_test_data[i],
-                                iv_test_data[iv_index_test_data[i]],
-                                iv_len_test_data[i],
-                                additional_test_data[add_index_test_data[i]],
-                                add_len_test_data[i],
-                                pt_test_data[pt_index_test_data[i]],
-                                buf, 16, tag_buf );
-#if defined(MBEDTLS_GCM_ALT)
-            /* Allow alternative implementations to only support 12-byte nonces. */
-            if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED &&
-                iv_len_test_data[i] != 12 )
-            {
-                mbedtls_printf( "skipped\n" );
-                break;
-            }
-#endif /* defined(MBEDTLS_GCM_ALT) */
-            if( ret != 0 )
-                goto exit;
-
-            if ( memcmp( buf, ct_test_data[j * 6 + i],
-                         pt_len_test_data[i] ) != 0 ||
-                 memcmp( tag_buf, tag_test_data[j * 6 + i], 16 ) != 0 )
-            {
-                ret = 1;
-                goto exit;
-            }
-
-            mbedtls_gcm_free( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "passed\n" );
-
-            mbedtls_gcm_init( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "  AES-GCM-%3d #%d (%s): ",
-                                key_len, i, "dec" );
-
-            ret = mbedtls_gcm_setkey( &ctx, cipher,
-                                      key_test_data[key_index_test_data[i]],
-                                      key_len );
-            if( ret != 0 )
-                goto exit;
-
-            ret = mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_DECRYPT,
-                                pt_len_test_data[i],
-                                iv_test_data[iv_index_test_data[i]],
-                                iv_len_test_data[i],
-                                additional_test_data[add_index_test_data[i]],
-                                add_len_test_data[i],
-                                ct_test_data[j * 6 + i], buf, 16, tag_buf );
-
-            if( ret != 0 )
-                goto exit;
-
-            if( memcmp( buf, pt_test_data[pt_index_test_data[i]],
-                        pt_len_test_data[i] ) != 0 ||
-                memcmp( tag_buf, tag_test_data[j * 6 + i], 16 ) != 0 )
-            {
-                ret = 1;
-                goto exit;
-            }
-
-            mbedtls_gcm_free( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "passed\n" );
-
-            mbedtls_gcm_init( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "  AES-GCM-%3d #%d split (%s): ",
-                                key_len, i, "enc" );
-
-            ret = mbedtls_gcm_setkey( &ctx, cipher,
-                                      key_test_data[key_index_test_data[i]],
-                                      key_len );
-            if( ret != 0 )
-                goto exit;
-
-            ret = mbedtls_gcm_starts( &ctx, MBEDTLS_GCM_ENCRYPT,
-                                      iv_test_data[iv_index_test_data[i]],
-                                      iv_len_test_data[i] );
-            if( ret != 0 )
-                goto exit;
-
-            ret = mbedtls_gcm_update_ad( &ctx,
-                              additional_test_data[add_index_test_data[i]],
-                              add_len_test_data[i] );
-            if( ret != 0 )
-                goto exit;
-
-            if( pt_len_test_data[i] > 32 )
-            {
-                size_t rest_len = pt_len_test_data[i] - 32;
-                ret = mbedtls_gcm_update( &ctx,
-                                          pt_test_data[pt_index_test_data[i]],
-                                          32,
-                                          buf, sizeof( buf ), &olen );
-                if( ret != 0 )
-                    goto exit;
-                if( olen != 32 )
-                    goto exit;
-
-                ret = mbedtls_gcm_update( &ctx,
-                                          pt_test_data[pt_index_test_data[i]] + 32,
-                                          rest_len,
-                                          buf + 32, sizeof( buf ) - 32, &olen );
-                if( ret != 0 )
-                    goto exit;
-                if( olen != rest_len )
-                    goto exit;
-            }
-            else
-            {
-                ret = mbedtls_gcm_update( &ctx,
-                                          pt_test_data[pt_index_test_data[i]],
-                                          pt_len_test_data[i],
-                                          buf, sizeof( buf ), &olen );
-                if( ret != 0 )
-                    goto exit;
-                if( olen != pt_len_test_data[i] )
-                    goto exit;
-            }
-
-            ret = mbedtls_gcm_finish( &ctx, NULL, 0, &olen, tag_buf, 16 );
-            if( ret != 0 )
-                goto exit;
-
-            if( memcmp( buf, ct_test_data[j * 6 + i],
-                        pt_len_test_data[i] ) != 0 ||
-                memcmp( tag_buf, tag_test_data[j * 6 + i], 16 ) != 0 )
-            {
-                ret = 1;
-                goto exit;
-            }
-
-            mbedtls_gcm_free( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "passed\n" );
-
-            mbedtls_gcm_init( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "  AES-GCM-%3d #%d split (%s): ",
-                                key_len, i, "dec" );
-
-            ret = mbedtls_gcm_setkey( &ctx, cipher,
-                                      key_test_data[key_index_test_data[i]],
-                                      key_len );
-            if( ret != 0 )
-                goto exit;
-
-            ret = mbedtls_gcm_starts( &ctx, MBEDTLS_GCM_DECRYPT,
-                                      iv_test_data[iv_index_test_data[i]],
-                                      iv_len_test_data[i] );
-            if( ret != 0 )
-                goto exit;
-            ret = mbedtls_gcm_update_ad( &ctx,
-                              additional_test_data[add_index_test_data[i]],
-                              add_len_test_data[i] );
-            if( ret != 0 )
-                goto exit;
-
-            if( pt_len_test_data[i] > 32 )
-            {
-                size_t rest_len = pt_len_test_data[i] - 32;
-                ret = mbedtls_gcm_update( &ctx,
-                                          ct_test_data[j * 6 + i], 32,
-                                          buf, sizeof( buf ), &olen );
-                if( ret != 0 )
-                    goto exit;
-                if( olen != 32 )
-                    goto exit;
-
-                ret = mbedtls_gcm_update( &ctx,
-                                          ct_test_data[j * 6 + i] + 32,
-                                          rest_len,
-                                          buf + 32, sizeof( buf ) - 32, &olen );
-                if( ret != 0 )
-                    goto exit;
-                if( olen != rest_len )
-                    goto exit;
-            }
-            else
-            {
-                ret = mbedtls_gcm_update( &ctx,
-                                          ct_test_data[j * 6 + i],
-                                          pt_len_test_data[i],
-                                          buf, sizeof( buf ), &olen );
-                if( ret != 0 )
-                    goto exit;
-                if( olen != pt_len_test_data[i] )
-                    goto exit;
-            }
-
-            ret = mbedtls_gcm_finish( &ctx, NULL, 0, &olen, tag_buf, 16 );
-            if( ret != 0 )
-                goto exit;
-
-            if( memcmp( buf, pt_test_data[pt_index_test_data[i]],
-                        pt_len_test_data[i] ) != 0 ||
-                memcmp( tag_buf, tag_test_data[j * 6 + i], 16 ) != 0 )
-            {
-                ret = 1;
-                goto exit;
-            }
-
-            mbedtls_gcm_free( &ctx );
-
-            if( verbose != 0 )
-                mbedtls_printf( "passed\n" );
-        }
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-    ret = 0;
-
-exit:
-    if( ret != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-        mbedtls_gcm_free( &ctx );
-    }
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
-
-#endif /* MBEDTLS_GCM_C */
diff --git a/src/duckdb/third_party/mbedtls/library/md.cpp b/src/duckdb/third_party/mbedtls/library/md.cpp
deleted file mode 100644
index 56ca22971..000000000
--- a/src/duckdb/third_party/mbedtls/library/md.cpp
+++ /dev/null
@@ -1,822 +0,0 @@
-/**
- * \file md.c
- *
- * \brief Generic message digest wrapper for mbed TLS
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_MD_C)
-
-#include "mbedtls/md.h"
-#include "md_wrap.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#if defined(MBEDTLS_MD5_C)
-#include "mbedtls/md5.h"
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-#include "mbedtls/ripemd160.h"
-#endif
-#if defined(MBEDTLS_SHA1_C)
-#include "mbedtls/sha1.h"
-#endif
-#if defined(MBEDTLS_SHA256_C)
-#include "mbedtls/sha256.h"
-#endif
-#if defined(MBEDTLS_SHA512_C)
-#include "mbedtls/sha512.h"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdlib.h>
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-#include <string.h>
-
-#if defined(MBEDTLS_FS_IO)
-#include <stdio.h>
-#endif
-
-#if defined(MBEDTLS_MD5_C)
-const mbedtls_md_info_t mbedtls_md5_info = {
-    "MD5",
-    MBEDTLS_MD_MD5,
-    16,
-    64,
-};
-#endif
-
-#if defined(MBEDTLS_RIPEMD160_C)
-const mbedtls_md_info_t mbedtls_ripemd160_info = {
-    "RIPEMD160",
-    MBEDTLS_MD_RIPEMD160,
-    20,
-    64,
-};
-#endif
-
-#if defined(MBEDTLS_SHA1_C)
-const mbedtls_md_info_t mbedtls_sha1_info = {
-    "SHA1",
-    MBEDTLS_MD_SHA1,
-    20,
-    64,
-};
-#endif
-
-#if defined(MBEDTLS_SHA224_C)
-const mbedtls_md_info_t mbedtls_sha224_info = {
-    "SHA224",
-    MBEDTLS_MD_SHA224,
-    28,
-    64,
-};
-#endif
-
-#if defined(MBEDTLS_SHA256_C)
-const mbedtls_md_info_t mbedtls_sha256_info = {
-    "SHA256",
-    MBEDTLS_MD_SHA256,
-    32,
-    64,
-};
-#endif
-
-#if defined(MBEDTLS_SHA384_C)
-const mbedtls_md_info_t mbedtls_sha384_info = {
-    "SHA384",
-    MBEDTLS_MD_SHA384,
-    48,
-    128,
-};
-#endif
-
-#if defined(MBEDTLS_SHA512_C)
-const mbedtls_md_info_t mbedtls_sha512_info = {
-    "SHA512",
-    MBEDTLS_MD_SHA512,
-    64,
-    128,
-};
-#endif
-
-/*
- * Reminder: update profiles in x509_crt.c when adding a new hash!
- */
-static const int supported_digests[] = {
-
-#if defined(MBEDTLS_SHA512_C)
-        MBEDTLS_MD_SHA512,
-#endif
-
-#if defined(MBEDTLS_SHA384_C)
-        MBEDTLS_MD_SHA384,
-#endif
-
-#if defined(MBEDTLS_SHA256_C)
-        MBEDTLS_MD_SHA256,
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        MBEDTLS_MD_SHA224,
-#endif
-
-#if defined(MBEDTLS_SHA1_C)
-        MBEDTLS_MD_SHA1,
-#endif
-
-#if defined(MBEDTLS_RIPEMD160_C)
-        MBEDTLS_MD_RIPEMD160,
-#endif
-
-#if defined(MBEDTLS_MD5_C)
-        MBEDTLS_MD_MD5,
-#endif
-
-        MBEDTLS_MD_NONE
-};
-
-const int *mbedtls_md_list( void )
-{
-    return( supported_digests );
-}
-
-const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name )
-{
-    if( NULL == md_name )
-        return( NULL );
-
-    /* Get the appropriate digest information */
-#if defined(MBEDTLS_MD5_C)
-    if( !strcmp( "MD5", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_MD5 );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-    if( !strcmp( "RIPEMD160", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-    if( !strcmp( "SHA1", md_name ) || !strcmp( "SHA", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-    if( !strcmp( "SHA224", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-    if( !strcmp( "SHA256", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-    if( !strcmp( "SHA384", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-    if( !strcmp( "SHA512", md_name ) )
-        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
-#endif
-    return( NULL );
-}
-
-const mbedtls_md_info_t *mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
-{
-    switch( md_type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            return( &mbedtls_md5_info );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            return( &mbedtls_ripemd160_info );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            return( &mbedtls_sha1_info );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            return( &mbedtls_sha224_info );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            return( &mbedtls_sha256_info );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            return( &mbedtls_sha384_info );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            return( &mbedtls_sha512_info );
-#endif
-        default:
-            return( NULL );
-    }
-}
-
-void mbedtls_md_init( mbedtls_md_context_t *ctx )
-{
-    memset( ctx, 0, sizeof( mbedtls_md_context_t ) );
-}
-
-void mbedtls_md_free( mbedtls_md_context_t *ctx )
-{
-    if( ctx == NULL || ctx->md_info == NULL )
-        return;
-
-    if( ctx->md_ctx != NULL )
-    {
-        switch( ctx->md_info->type )
-        {
-#if defined(MBEDTLS_MD5_C)
-            case MBEDTLS_MD_MD5:
-                mbedtls_md5_free( ctx->md_ctx );
-                break;
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-            case MBEDTLS_MD_RIPEMD160:
-                mbedtls_ripemd160_free( ctx->md_ctx );
-                break;
-#endif
-#if defined(MBEDTLS_SHA1_C)
-            case MBEDTLS_MD_SHA1:
-                mbedtls_sha1_free((mbedtls_sha1_context *) ctx->md_ctx );
-                break;
-#endif
-#if defined(MBEDTLS_SHA224_C)
-            case MBEDTLS_MD_SHA224:
-                mbedtls_sha256_free((mbedtls_sha256_context *) ctx->md_ctx );
-                break;
-#endif
-#if defined(MBEDTLS_SHA256_C)
-            case MBEDTLS_MD_SHA256:
-                mbedtls_sha256_free((mbedtls_sha256_context *) ctx->md_ctx );
-                break;
-#endif
-#if defined(MBEDTLS_SHA384_C)
-            case MBEDTLS_MD_SHA384:
-                mbedtls_sha512_free( ctx->md_ctx );
-                break;
-#endif
-#if defined(MBEDTLS_SHA512_C)
-            case MBEDTLS_MD_SHA512:
-                mbedtls_sha512_free( ctx->md_ctx );
-                break;
-#endif
-            default:
-                /* Shouldn't happen */
-                break;
-        }
-        mbedtls_free( ctx->md_ctx );
-    }
-
-    if( ctx->hmac_ctx != NULL )
-    {
-        mbedtls_platform_zeroize( ctx->hmac_ctx,
-                                  2 * ctx->md_info->block_size );
-        mbedtls_free( ctx->hmac_ctx );
-    }
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_md_context_t ) );
-}
-
-int mbedtls_md_clone( mbedtls_md_context_t *dst,
-                      const mbedtls_md_context_t *src )
-{
-    if( dst == NULL || dst->md_info == NULL ||
-        src == NULL || src->md_info == NULL ||
-        dst->md_info != src->md_info )
-    {
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-
-    switch( src->md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            mbedtls_md5_clone( dst->md_ctx, src->md_ctx );
-            break;
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            mbedtls_ripemd160_clone( dst->md_ctx, src->md_ctx );
-            break;
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            mbedtls_sha1_clone((mbedtls_sha1_context *) dst->md_ctx, (mbedtls_sha1_context *)src->md_ctx );
-            break;
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            mbedtls_sha256_clone((mbedtls_sha256_context *) dst->md_ctx, (mbedtls_sha256_context *) src->md_ctx );
-            break;
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            mbedtls_sha256_clone((mbedtls_sha256_context *) dst->md_ctx, (mbedtls_sha256_context *)src->md_ctx );
-            break;
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            mbedtls_sha512_clone( dst->md_ctx, src->md_ctx );
-            break;
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            mbedtls_sha512_clone( dst->md_ctx, src->md_ctx );
-            break;
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-
-    return( 0 );
-}
-
-#define ALLOC( type )                                                   \
-    do {                                                                \
-        ctx->md_ctx = (mbedtls_##type##_context*) mbedtls_calloc( 1, sizeof( mbedtls_##type##_context ) ); \
-        if( ctx->md_ctx == NULL )                                       \
-            return( MBEDTLS_ERR_MD_ALLOC_FAILED );                      \
-        mbedtls_##type##_init((mbedtls_##type##_context*) ctx->md_ctx );                           \
-    }                                                                   \
-    while( 0 )
-
-int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
-{
-    if( md_info == NULL || ctx == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    ctx->md_info = md_info;
-    ctx->md_ctx = NULL;
-    ctx->hmac_ctx = NULL;
-
-    switch( md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            ALLOC( md5 );
-            break;
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            ALLOC( ripemd160 );
-            break;
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            ALLOC( sha1 );
-            break;
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            ALLOC( sha256 );
-            break;
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            ALLOC( sha256 );
-            break;
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            ALLOC( sha512 );
-            break;
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            ALLOC( sha512 );
-            break;
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-
-    if( hmac != 0 )
-    {
-        ctx->hmac_ctx = mbedtls_calloc( 2, md_info->block_size );
-        if( ctx->hmac_ctx == NULL )
-        {
-            mbedtls_md_free( ctx );
-            return( MBEDTLS_ERR_MD_ALLOC_FAILED );
-        }
-    }
-
-    return( 0 );
-}
-#undef ALLOC
-
-int mbedtls_md_starts( mbedtls_md_context_t *ctx )
-{
-    if( ctx == NULL || ctx->md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    switch( ctx->md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            return( mbedtls_md5_starts( ctx->md_ctx ) );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            return( mbedtls_ripemd160_starts( ctx->md_ctx ) );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            return( mbedtls_sha1_starts( (mbedtls_sha1_context *)ctx->md_ctx ) );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            return( mbedtls_sha256_starts( (mbedtls_sha256_context *)ctx->md_ctx, 1 ) );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            return( mbedtls_sha256_starts( (mbedtls_sha256_context *) ctx->md_ctx, 0 ) );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            return( mbedtls_sha512_starts( ctx->md_ctx, 1 ) );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            return( mbedtls_sha512_starts( ctx->md_ctx, 0 ) );
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-}
-
-int mbedtls_md_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
-{
-    if( ctx == NULL || ctx->md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    switch( ctx->md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            return( mbedtls_md5_update( ctx->md_ctx, input, ilen ) );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            return( mbedtls_ripemd160_update( ctx->md_ctx, input, ilen ) );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            return( mbedtls_sha1_update( (mbedtls_sha1_context *)ctx->md_ctx, input, ilen ) );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            return( mbedtls_sha256_update( (mbedtls_sha256_context *)ctx->md_ctx, input, ilen ) );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            return( mbedtls_sha256_update( (mbedtls_sha256_context *)ctx->md_ctx, input, ilen ) );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            return( mbedtls_sha512_update( ctx->md_ctx, input, ilen ) );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            return( mbedtls_sha512_update( ctx->md_ctx, input, ilen ) );
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-}
-
-int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
-{
-    if( ctx == NULL || ctx->md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    switch( ctx->md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            return( mbedtls_md5_finish( ctx->md_ctx, output ) );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            return( mbedtls_ripemd160_finish( ctx->md_ctx, output ) );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            return( mbedtls_sha1_finish((mbedtls_sha1_context *) ctx->md_ctx, output ) );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            return( mbedtls_sha256_finish((mbedtls_sha256_context *) ctx->md_ctx, output ) );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            return( mbedtls_sha256_finish((mbedtls_sha256_context *) (mbedtls_sha256_context *)ctx->md_ctx, output ) );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            return( mbedtls_sha512_finish( ctx->md_ctx, output ) );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            return( mbedtls_sha512_finish( ctx->md_ctx, output ) );
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-}
-
-int mbedtls_md( const mbedtls_md_info_t *md_info, const unsigned char *input, size_t ilen,
-            unsigned char *output )
-{
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    switch( md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            return( mbedtls_md5( input, ilen, output ) );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            return( mbedtls_ripemd160( input, ilen, output ) );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            return( mbedtls_sha1( input, ilen, output ) );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            return( mbedtls_sha256( input, ilen, output, 1 ) );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            return( mbedtls_sha256( input, ilen, output, 0 ) );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            return( mbedtls_sha512( input, ilen, output, 1 ) );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            return( mbedtls_sha512( input, ilen, output, 0 ) );
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-}
-
-#if defined(MBEDTLS_FS_IO)
-int mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path, unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    FILE *f;
-    size_t n;
-    mbedtls_md_context_t ctx;
-    unsigned char buf[1024];
-
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    if( ( f = fopen( path, "rb" ) ) == NULL )
-        return( MBEDTLS_ERR_MD_FILE_IO_ERROR );
-
-    mbedtls_md_init( &ctx );
-
-    if( ( ret = mbedtls_md_setup( &ctx, md_info, 0 ) ) != 0 )
-        goto cleanup;
-
-    if( ( ret = mbedtls_md_starts( &ctx ) ) != 0 )
-        goto cleanup;
-
-    while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
-        if( ( ret = mbedtls_md_update( &ctx, buf, n ) ) != 0 )
-            goto cleanup;
-
-    if( ferror( f ) != 0 )
-        ret = MBEDTLS_ERR_MD_FILE_IO_ERROR;
-    else
-        ret = mbedtls_md_finish( &ctx, output );
-
-cleanup:
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-    fclose( f );
-    mbedtls_md_free( &ctx );
-
-    return( ret );
-}
-#endif /* MBEDTLS_FS_IO */
-
-int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char sum[MBEDTLS_MD_MAX_SIZE];
-    unsigned char *ipad, *opad;
-    size_t i;
-
-    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    if( keylen > (size_t) ctx->md_info->block_size )
-    {
-        if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
-            goto cleanup;
-        if( ( ret = mbedtls_md_update( ctx, key, keylen ) ) != 0 )
-            goto cleanup;
-        if( ( ret = mbedtls_md_finish( ctx, sum ) ) != 0 )
-            goto cleanup;
-
-        keylen = ctx->md_info->size;
-        key = sum;
-    }
-
-    ipad = (unsigned char *) ctx->hmac_ctx;
-    opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
-
-    memset( ipad, 0x36, ctx->md_info->block_size );
-    memset( opad, 0x5C, ctx->md_info->block_size );
-
-    for( i = 0; i < keylen; i++ )
-    {
-        ipad[i] = (unsigned char)( ipad[i] ^ key[i] );
-        opad[i] = (unsigned char)( opad[i] ^ key[i] );
-    }
-
-    if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
-        goto cleanup;
-    if( ( ret = mbedtls_md_update( ctx, ipad,
-                                   ctx->md_info->block_size ) ) != 0 )
-        goto cleanup;
-
-cleanup:
-    mbedtls_platform_zeroize( sum, sizeof( sum ) );
-
-    return( ret );
-}
-
-int mbedtls_md_hmac_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
-{
-    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    return( mbedtls_md_update( ctx, input, ilen ) );
-}
-
-int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char tmp[MBEDTLS_MD_MAX_SIZE];
-    unsigned char *opad;
-
-    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
-
-    if( ( ret = mbedtls_md_finish( ctx, tmp ) ) != 0 )
-        return( ret );
-    if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
-        return( ret );
-    if( ( ret = mbedtls_md_update( ctx, opad,
-                                   ctx->md_info->block_size ) ) != 0 )
-        return( ret );
-    if( ( ret = mbedtls_md_update( ctx, tmp,
-                                   ctx->md_info->size ) ) != 0 )
-        return( ret );
-    return( mbedtls_md_finish( ctx, output ) );
-}
-
-int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *ipad;
-
-    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    ipad = (unsigned char *) ctx->hmac_ctx;
-
-    if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
-        return( ret );
-    return( mbedtls_md_update( ctx, ipad, ctx->md_info->block_size ) );
-}
-
-int mbedtls_md_hmac( const mbedtls_md_info_t *md_info,
-                     const unsigned char *key, size_t keylen,
-                     const unsigned char *input, size_t ilen,
-                     unsigned char *output )
-{
-    mbedtls_md_context_t ctx;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    mbedtls_md_init( &ctx );
-
-    if( ( ret = mbedtls_md_setup( &ctx, md_info, 1 ) ) != 0 )
-        goto cleanup;
-
-    if( ( ret = mbedtls_md_hmac_starts( &ctx, key, keylen ) ) != 0 )
-        goto cleanup;
-    if( ( ret = mbedtls_md_hmac_update( &ctx, input, ilen ) ) != 0 )
-        goto cleanup;
-    if( ( ret = mbedtls_md_hmac_finish( &ctx, output ) ) != 0 )
-        goto cleanup;
-
-cleanup:
-    mbedtls_md_free( &ctx );
-
-    return( ret );
-}
-
-int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data )
-{
-    if( ctx == NULL || ctx->md_info == NULL )
-        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-
-    switch( ctx->md_info->type )
-    {
-#if defined(MBEDTLS_MD5_C)
-        case MBEDTLS_MD_MD5:
-            return( mbedtls_internal_md5_process( ctx->md_ctx, data ) );
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-        case MBEDTLS_MD_RIPEMD160:
-            return( mbedtls_internal_ripemd160_process( ctx->md_ctx, data ) );
-#endif
-#if defined(MBEDTLS_SHA1_C)
-        case MBEDTLS_MD_SHA1:
-            return( mbedtls_internal_sha1_process((mbedtls_sha1_context *) ctx->md_ctx, data ) );
-#endif
-#if defined(MBEDTLS_SHA224_C)
-        case MBEDTLS_MD_SHA224:
-            return( mbedtls_internal_sha256_process((mbedtls_sha256_context *) ctx->md_ctx, data ) );
-#endif
-#if defined(MBEDTLS_SHA256_C)
-        case MBEDTLS_MD_SHA256:
-            return( mbedtls_internal_sha256_process((mbedtls_sha256_context *) ctx->md_ctx, data ) );
-#endif
-#if defined(MBEDTLS_SHA384_C)
-        case MBEDTLS_MD_SHA384:
-            return( mbedtls_internal_sha512_process( ctx->md_ctx, data ) );
-#endif
-#if defined(MBEDTLS_SHA512_C)
-        case MBEDTLS_MD_SHA512:
-            return( mbedtls_internal_sha512_process( ctx->md_ctx, data ) );
-#endif
-        default:
-            return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-    }
-}
-
-unsigned char mbedtls_md_get_size( const mbedtls_md_info_t *md_info )
-{
-    if( md_info == NULL )
-        return( 0 );
-
-    return md_info->size;
-}
-
-mbedtls_md_type_t mbedtls_md_get_type( const mbedtls_md_info_t *md_info )
-{
-    if( md_info == NULL )
-        return( MBEDTLS_MD_NONE );
-
-    return md_info->type;
-}
-
-const char *mbedtls_md_get_name( const mbedtls_md_info_t *md_info )
-{
-    if( md_info == NULL )
-        return( NULL );
-
-    return md_info->name;
-}
-
-#endif /* MBEDTLS_MD_C */
diff --git a/src/duckdb/third_party/mbedtls/library/md_wrap.h b/src/duckdb/third_party/mbedtls/library/md_wrap.h
deleted file mode 100644
index 90c795731..000000000
--- a/src/duckdb/third_party/mbedtls/library/md_wrap.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/**
- * \file md_wrap.h
- *
- * \brief Message digest wrappers.
- *
- * \warning This in an internal header. Do not include directly.
- *
- * \author Adriaan de Jong <dejong@fox-it.com>
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-#ifndef MBEDTLS_MD_WRAP_H
-#define MBEDTLS_MD_WRAP_H
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/md.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Message digest information.
- * Allows message digest functions to be called in a generic way.
- */
-struct mbedtls_md_info_t
-{
-    /** Name of the message digest */
-    const char * name;
-
-    /** Digest identifier */
-    mbedtls_md_type_t type;
-
-    /** Output length of the digest function in bytes */
-    unsigned char size;
-
-    /** Block length of the digest function in bytes */
-    unsigned char block_size;
-};
-
-#if defined(MBEDTLS_MD5_C)
-extern const mbedtls_md_info_t mbedtls_md5_info;
-#endif
-#if defined(MBEDTLS_RIPEMD160_C)
-extern const mbedtls_md_info_t mbedtls_ripemd160_info;
-#endif
-#if defined(MBEDTLS_SHA1_C)
-extern const mbedtls_md_info_t mbedtls_sha1_info;
-#endif
-#if defined(MBEDTLS_SHA224_C)
-extern const mbedtls_md_info_t mbedtls_sha224_info;
-#endif
-#if defined(MBEDTLS_SHA256_C)
-extern const mbedtls_md_info_t mbedtls_sha256_info;
-#endif
-#if defined(MBEDTLS_SHA384_C)
-extern const mbedtls_md_info_t mbedtls_sha384_info;
-#endif
-#if defined(MBEDTLS_SHA512_C)
-extern const mbedtls_md_info_t mbedtls_sha512_info;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MBEDTLS_MD_WRAP_H */
diff --git a/src/duckdb/third_party/mbedtls/library/oid.cpp b/src/duckdb/third_party/mbedtls/library/oid.cpp
deleted file mode 100644
index fd6bbfd83..000000000
--- a/src/duckdb/third_party/mbedtls/library/oid.cpp
+++ /dev/null
@@ -1,748 +0,0 @@
-/**
- * \file oid.c
- *
- * \brief Object Identifier (OID) database
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_OID_C)
-
-#include "mbedtls/oid.h"
-#include "mbedtls/rsa.h"
-#include "mbedtls/error.h"
-
-#include <stdio.h>
-#include <string.h>
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#define mbedtls_snprintf snprintf
-#endif
-
-/*
- * Macro to automatically add the size of #define'd OIDs
- */
-#define ADD_LEN(s)      s, MBEDTLS_OID_SIZE(s)
-
-/*
- * Macro to generate mbedtls_oid_descriptor_t
- */
-#if !defined(MBEDTLS_X509_REMOVE_INFO)
-#define OID_DESCRIPTOR(s, name, description)  { ADD_LEN(s), name, description }
-#define NULL_OID_DESCRIPTOR                   { NULL, 0, NULL, NULL }
-#else
-#define OID_DESCRIPTOR(s, name, description)  { ADD_LEN(s) }
-#define NULL_OID_DESCRIPTOR                   { NULL, 0 }
-#endif
-
-/*
- * Macro to generate an internal function for oid_XXX_from_asn1() (used by
- * the other functions)
- */
-#define FN_OID_TYPED_FROM_ASN1( TYPE_T, NAME, LIST )                    \
-    static const TYPE_T * oid_ ## NAME ## _from_asn1(                   \
-                                      const mbedtls_asn1_buf *oid )     \
-    {                                                                   \
-        const TYPE_T *p = (LIST);                                       \
-        const mbedtls_oid_descriptor_t *cur =                           \
-            (const mbedtls_oid_descriptor_t *) p;                       \
-        if( p == NULL || oid == NULL ) return( NULL );                  \
-        while( cur->asn1 != NULL ) {                                    \
-            if( cur->asn1_len == oid->len &&                            \
-                memcmp( cur->asn1, oid->p, oid->len ) == 0 ) {          \
-                return( p );                                            \
-            }                                                           \
-            p++;                                                        \
-            cur = (const mbedtls_oid_descriptor_t *) p;                 \
-        }                                                               \
-        return( NULL );                                                 \
-    }
-
-#if !defined(MBEDTLS_X509_REMOVE_INFO)
-/*
- * Macro to generate a function for retrieving a single attribute from the
- * descriptor of an mbedtls_oid_descriptor_t wrapper.
- */
-#define FN_OID_GET_DESCRIPTOR_ATTR1(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1) \
-int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1 )                  \
-{                                                                       \
-    const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid );        \
-    if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND );            \
-    *ATTR1 = data->descriptor.ATTR1;                                    \
-    return( 0 );                                                        \
-}
-#endif /* MBEDTLS_X509_REMOVE_INFO */
-
-/*
- * Macro to generate a function for retrieving a single attribute from an
- * mbedtls_oid_descriptor_t wrapper.
- */
-#define FN_OID_GET_ATTR1(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1) \
-int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1 )                  \
-{                                                                       \
-    const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid );        \
-    if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND );            \
-    *ATTR1 = data->ATTR1;                                               \
-    return( 0 );                                                        \
-}
-
-/*
- * Macro to generate a function for retrieving two attributes from an
- * mbedtls_oid_descriptor_t wrapper.
- */
-#define FN_OID_GET_ATTR2(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1,     \
-                         ATTR2_TYPE, ATTR2)                                 \
-int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1,               \
-                                          ATTR2_TYPE * ATTR2 )              \
-{                                                                           \
-    const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid );            \
-    if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND );                 \
-    *(ATTR1) = data->ATTR1;                                                 \
-    *(ATTR2) = data->ATTR2;                                                 \
-    return( 0 );                                                            \
-}
-
-/*
- * Macro to generate a function for retrieving the OID based on a single
- * attribute from a mbedtls_oid_descriptor_t wrapper.
- */
-#define FN_OID_GET_OID_BY_ATTR1(FN_NAME, TYPE_T, LIST, ATTR1_TYPE, ATTR1)   \
-int FN_NAME( ATTR1_TYPE ATTR1, const char **oid, size_t *olen )             \
-{                                                                           \
-    const TYPE_T *cur = (LIST);                                             \
-    while( cur->descriptor.asn1 != NULL ) {                                 \
-        if( cur->ATTR1 == (ATTR1) ) {                                       \
-            *oid = cur->descriptor.asn1;                                    \
-            *olen = cur->descriptor.asn1_len;                               \
-            return( 0 );                                                    \
-        }                                                                   \
-        cur++;                                                              \
-    }                                                                       \
-    return( MBEDTLS_ERR_OID_NOT_FOUND );                                    \
-}
-
-/*
- * Macro to generate a function for retrieving the OID based on two
- * attributes from a mbedtls_oid_descriptor_t wrapper.
- */
-#define FN_OID_GET_OID_BY_ATTR2(FN_NAME, TYPE_T, LIST, ATTR1_TYPE, ATTR1,   \
-                                ATTR2_TYPE, ATTR2)                          \
-int FN_NAME( ATTR1_TYPE ATTR1, ATTR2_TYPE ATTR2, const char **oid ,         \
-             size_t *olen )                                                 \
-{                                                                           \
-    const TYPE_T *cur = (LIST);                                             \
-    while( cur->descriptor.asn1 != NULL ) {                                 \
-        if( cur->ATTR1 == (ATTR1) && cur->ATTR2 == (ATTR2) ) {              \
-            *oid = cur->descriptor.asn1;                                    \
-            *olen = cur->descriptor.asn1_len;                               \
-            return( 0 );                                                    \
-        }                                                                   \
-        cur++;                                                              \
-    }                                                                       \
-    return( MBEDTLS_ERR_OID_NOT_FOUND );                                   \
-}
-
-/*
- * For X520 attribute types
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    const char          *short_name;
-} oid_x520_attr_t;
-
-static const oid_x520_attr_t oid_x520_attr_type[] =
-{
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_CN,          "id-at-commonName",               "Common Name" ),
-        "CN",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_COUNTRY,     "id-at-countryName",              "Country" ),
-        "C",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_LOCALITY,    "id-at-locality",                 "Locality" ),
-        "L",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_STATE,       "id-at-state",                    "State" ),
-        "ST",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_ORGANIZATION,"id-at-organizationName",         "Organization" ),
-        "O",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_ORG_UNIT,    "id-at-organizationalUnitName",   "Org Unit" ),
-        "OU",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS9_EMAIL,    "emailAddress",                   "E-mail address" ),
-        "emailAddress",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_SERIAL_NUMBER,"id-at-serialNumber",            "Serial number" ),
-        "serialNumber",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_POSTAL_ADDRESS,"id-at-postalAddress",          "Postal address" ),
-        "postalAddress",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_POSTAL_CODE, "id-at-postalCode",               "Postal code" ),
-        "postalCode",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_SUR_NAME,    "id-at-surName",                  "Surname" ),
-        "SN",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_GIVEN_NAME,  "id-at-givenName",                "Given name" ),
-        "GN",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_INITIALS,    "id-at-initials",                 "Initials" ),
-        "initials",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_GENERATION_QUALIFIER, "id-at-generationQualifier", "Generation qualifier" ),
-        "generationQualifier",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_TITLE,       "id-at-title",                    "Title" ),
-        "title",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_DN_QUALIFIER,"id-at-dnQualifier",              "Distinguished Name qualifier" ),
-        "dnQualifier",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_PSEUDONYM,   "id-at-pseudonym",                "Pseudonym" ),
-        "pseudonym",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_UID,            "id-uid",                         "User Id" ),
-        "uid",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DOMAIN_COMPONENT, "id-domainComponent",           "Domain component" ),
-        "DC",
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_AT_UNIQUE_IDENTIFIER, "id-at-uniqueIdentifier",    "Unique Identifier" ),
-        "uniqueIdentifier",
-    },
-    {
-        NULL_OID_DESCRIPTOR,
-        NULL,
-    }
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_x520_attr_t, x520_attr, oid_x520_attr_type)
-FN_OID_GET_ATTR1(mbedtls_oid_get_attr_short_name, oid_x520_attr_t, x520_attr, const char *, short_name)
-
-/*
- * For X509 extensions
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    int                 ext_type;
-} oid_x509_ext_t;
-
-static const oid_x509_ext_t oid_x509_ext[] =
-{
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_BASIC_CONSTRAINTS,    "id-ce-basicConstraints",    "Basic Constraints" ),
-        MBEDTLS_OID_X509_EXT_BASIC_CONSTRAINTS,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_KEY_USAGE,            "id-ce-keyUsage",            "Key Usage" ),
-        MBEDTLS_OID_X509_EXT_KEY_USAGE,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EXTENDED_KEY_USAGE,   "id-ce-extKeyUsage",         "Extended Key Usage" ),
-        MBEDTLS_OID_X509_EXT_EXTENDED_KEY_USAGE,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_SUBJECT_ALT_NAME,     "id-ce-subjectAltName",      "Subject Alt Name" ),
-        MBEDTLS_OID_X509_EXT_SUBJECT_ALT_NAME,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_NS_CERT_TYPE,         "id-netscape-certtype",      "Netscape Certificate Type" ),
-        MBEDTLS_OID_X509_EXT_NS_CERT_TYPE,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_CERTIFICATE_POLICIES, "id-ce-certificatePolicies",  "Certificate Policies" ),
-        MBEDTLS_OID_X509_EXT_CERTIFICATE_POLICIES,
-    },
-    {
-        NULL_OID_DESCRIPTOR,
-        0,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_x509_ext_t, x509_ext, oid_x509_ext)
-FN_OID_GET_ATTR1(mbedtls_oid_get_x509_ext_type, oid_x509_ext_t, x509_ext, int, ext_type)
-
-#if !defined(MBEDTLS_X509_REMOVE_INFO)
-static const mbedtls_oid_descriptor_t oid_ext_key_usage[] =
-{
-    OID_DESCRIPTOR( MBEDTLS_OID_SERVER_AUTH,      "id-kp-serverAuth",      "TLS Web Server Authentication" ),
-    OID_DESCRIPTOR( MBEDTLS_OID_CLIENT_AUTH,      "id-kp-clientAuth",      "TLS Web Client Authentication" ),
-    OID_DESCRIPTOR( MBEDTLS_OID_CODE_SIGNING,     "id-kp-codeSigning",     "Code Signing" ),
-    OID_DESCRIPTOR( MBEDTLS_OID_EMAIL_PROTECTION, "id-kp-emailProtection", "E-mail Protection" ),
-    OID_DESCRIPTOR( MBEDTLS_OID_TIME_STAMPING,    "id-kp-timeStamping",    "Time Stamping" ),
-    OID_DESCRIPTOR( MBEDTLS_OID_OCSP_SIGNING,     "id-kp-OCSPSigning",     "OCSP Signing" ),
-    OID_DESCRIPTOR( MBEDTLS_OID_WISUN_FAN,        "id-kp-wisun-fan-device", "Wi-SUN Alliance Field Area Network (FAN)" ),
-    NULL_OID_DESCRIPTOR,
-};
-
-FN_OID_TYPED_FROM_ASN1(mbedtls_oid_descriptor_t, ext_key_usage, oid_ext_key_usage)
-FN_OID_GET_ATTR1(mbedtls_oid_get_extended_key_usage, mbedtls_oid_descriptor_t, ext_key_usage, const char *, description)
-
-static const mbedtls_oid_descriptor_t oid_certificate_policies[] =
-{
-    OID_DESCRIPTOR( MBEDTLS_OID_ANY_POLICY,      "anyPolicy",       "Any Policy" ),
-    NULL_OID_DESCRIPTOR,
-};
-
-FN_OID_TYPED_FROM_ASN1(mbedtls_oid_descriptor_t, certificate_policies, oid_certificate_policies)
-FN_OID_GET_ATTR1(mbedtls_oid_get_certificate_policies, mbedtls_oid_descriptor_t, certificate_policies, const char *, description)
-#endif /* MBEDTLS_X509_REMOVE_INFO */
-
-#if defined(MBEDTLS_MD_C)
-/*
- * For SignatureAlgorithmIdentifier
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_md_type_t           md_alg;
-    mbedtls_pk_type_t           pk_alg;
-} oid_sig_alg_t;
-
-static const oid_sig_alg_t oid_sig_alg[] =
-{
-#if defined(MBEDTLS_RSA_C)
-#if defined(MBEDTLS_MD5_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_MD5,        "md5WithRSAEncryption",     "RSA with MD5" ),
-        MBEDTLS_MD_MD5,      MBEDTLS_PK_RSA,
-    },
-#endif /* MBEDTLS_MD5_C */
-#if defined(MBEDTLS_SHA1_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_SHA1,       "sha-1WithRSAEncryption",   "RSA with SHA1" ),
-        MBEDTLS_MD_SHA1,     MBEDTLS_PK_RSA,
-    },
-#endif /* MBEDTLS_SHA1_C */
-#if defined(MBEDTLS_SHA224_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_SHA224,     "sha224WithRSAEncryption",  "RSA with SHA-224" ),
-        MBEDTLS_MD_SHA224,   MBEDTLS_PK_RSA,
-    },
-#endif
-#if defined(MBEDTLS_SHA256_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_SHA256,     "sha256WithRSAEncryption",  "RSA with SHA-256" ),
-        MBEDTLS_MD_SHA256,   MBEDTLS_PK_RSA,
-    },
-#endif /* MBEDTLS_SHA256_C */
-#if defined(MBEDTLS_SHA384_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_SHA384,     "sha384WithRSAEncryption",  "RSA with SHA-384" ),
-        MBEDTLS_MD_SHA384,   MBEDTLS_PK_RSA,
-    },
-#endif /* MBEDTLS_SHA384_C */
-#if defined(MBEDTLS_SHA512_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_SHA512,     "sha512WithRSAEncryption",  "RSA with SHA-512" ),
-        MBEDTLS_MD_SHA512,   MBEDTLS_PK_RSA,
-    },
-#endif /* MBEDTLS_SHA512_C */
-#if defined(MBEDTLS_SHA1_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_RSA_SHA_OBS,      "sha-1WithRSAEncryption",   "RSA with SHA1" ),
-        MBEDTLS_MD_SHA1,     MBEDTLS_PK_RSA,
-    },
-#endif /* MBEDTLS_SHA1_C */
-#endif /* MBEDTLS_RSA_C */
-#if defined(MBEDTLS_ECDSA_C)
-#if defined(MBEDTLS_SHA1_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_ECDSA_SHA1,       "ecdsa-with-SHA1",      "ECDSA with SHA1" ),
-        MBEDTLS_MD_SHA1,     MBEDTLS_PK_ECDSA,
-    },
-#endif /* MBEDTLS_SHA1_C */
-#if defined(MBEDTLS_SHA224_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_ECDSA_SHA224,     "ecdsa-with-SHA224",    "ECDSA with SHA224" ),
-        MBEDTLS_MD_SHA224,   MBEDTLS_PK_ECDSA,
-    },
-#endif
-#if defined(MBEDTLS_SHA256_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_ECDSA_SHA256,     "ecdsa-with-SHA256",    "ECDSA with SHA256" ),
-        MBEDTLS_MD_SHA256,   MBEDTLS_PK_ECDSA,
-    },
-#endif /* MBEDTLS_SHA256_C */
-#if defined(MBEDTLS_SHA384_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_ECDSA_SHA384,     "ecdsa-with-SHA384",    "ECDSA with SHA384" ),
-        MBEDTLS_MD_SHA384,   MBEDTLS_PK_ECDSA,
-    },
-#endif /* MBEDTLS_SHA384_C */
-#if defined(MBEDTLS_SHA512_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_ECDSA_SHA512,     "ecdsa-with-SHA512",    "ECDSA with SHA512" ),
-        MBEDTLS_MD_SHA512,   MBEDTLS_PK_ECDSA,
-    },
-#endif /* MBEDTLS_SHA512_C */
-#endif /* MBEDTLS_ECDSA_C */
-#if defined(MBEDTLS_RSA_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_RSASSA_PSS,        "RSASSA-PSS",           "RSASSA-PSS" ),
-        MBEDTLS_MD_NONE,     MBEDTLS_PK_RSASSA_PSS,
-    },
-#endif /* MBEDTLS_RSA_C */
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_MD_NONE, MBEDTLS_PK_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_sig_alg_t, sig_alg, oid_sig_alg)
-
-#if !defined(MBEDTLS_X509_REMOVE_INFO)
-FN_OID_GET_DESCRIPTOR_ATTR1(mbedtls_oid_get_sig_alg_desc, oid_sig_alg_t, sig_alg, const char *, description)
-#endif
-
-FN_OID_GET_ATTR2(mbedtls_oid_get_sig_alg, oid_sig_alg_t, sig_alg, mbedtls_md_type_t, md_alg, mbedtls_pk_type_t, pk_alg)
-FN_OID_GET_OID_BY_ATTR2(mbedtls_oid_get_oid_by_sig_alg, oid_sig_alg_t, oid_sig_alg, mbedtls_pk_type_t, pk_alg, mbedtls_md_type_t, md_alg)
-#endif /* MBEDTLS_MD_C */
-
-/*
- * For PublicKeyInfo (PKCS1, RFC 5480)
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_pk_type_t           pk_alg;
-} oid_pk_alg_t;
-
-static const oid_pk_alg_t oid_pk_alg[] =
-{
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS1_RSA,           "rsaEncryption",    "RSA" ),
-        MBEDTLS_PK_RSA,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_ALG_UNRESTRICTED, "id-ecPublicKey",   "Generic EC key" ),
-        MBEDTLS_PK_ECKEY,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_ALG_ECDH,         "id-ecDH",          "EC key for ECDH" ),
-        MBEDTLS_PK_ECKEY_DH,
-    },
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_PK_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_pk_alg_t, pk_alg, oid_pk_alg)
-FN_OID_GET_ATTR1(mbedtls_oid_get_pk_alg, oid_pk_alg_t, pk_alg, mbedtls_pk_type_t, pk_alg)
-FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_pk_alg, oid_pk_alg_t, oid_pk_alg, mbedtls_pk_type_t, pk_alg)
-
-#if defined(MBEDTLS_ECP_C)
-/*
- * For namedCurve (RFC 5480)
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_ecp_group_id        grp_id;
-} oid_ecp_grp_t;
-
-static const oid_ecp_grp_t oid_ecp_grp[] =
-{
-#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP192R1, "secp192r1",    "secp192r1" ),
-        MBEDTLS_ECP_DP_SECP192R1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP224R1, "secp224r1",    "secp224r1" ),
-        MBEDTLS_ECP_DP_SECP224R1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP256R1, "secp256r1",    "secp256r1" ),
-        MBEDTLS_ECP_DP_SECP256R1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP384R1, "secp384r1",    "secp384r1" ),
-        MBEDTLS_ECP_DP_SECP384R1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP521R1, "secp521r1",    "secp521r1" ),
-        MBEDTLS_ECP_DP_SECP521R1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP192K1, "secp192k1",    "secp192k1" ),
-        MBEDTLS_ECP_DP_SECP192K1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP224K1, "secp224k1",    "secp224k1" ),
-        MBEDTLS_ECP_DP_SECP224K1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_SECP256K1, "secp256k1",    "secp256k1" ),
-        MBEDTLS_ECP_DP_SECP256K1,
-    },
-#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_BP256R1,   "brainpoolP256r1","brainpool256r1" ),
-        MBEDTLS_ECP_DP_BP256R1,
-    },
-#endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_BP384R1,   "brainpoolP384r1","brainpool384r1" ),
-        MBEDTLS_ECP_DP_BP384R1,
-    },
-#endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
-#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_EC_GRP_BP512R1,   "brainpoolP512r1","brainpool512r1" ),
-        MBEDTLS_ECP_DP_BP512R1,
-    },
-#endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_ECP_DP_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_ecp_grp_t, grp_id, oid_ecp_grp)
-FN_OID_GET_ATTR1(mbedtls_oid_get_ec_grp, oid_ecp_grp_t, grp_id, mbedtls_ecp_group_id, grp_id)
-FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_ec_grp, oid_ecp_grp_t, oid_ecp_grp, mbedtls_ecp_group_id, grp_id)
-#endif /* MBEDTLS_ECP_C */
-
-#if defined(MBEDTLS_CIPHER_C)
-/*
- * For PKCS#5 PBES2 encryption algorithm
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_cipher_type_t       cipher_alg;
-} oid_cipher_alg_t;
-
-static const oid_cipher_alg_t oid_cipher_alg[] =
-{
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DES_CBC,              "desCBC",       "DES-CBC" ),
-        MBEDTLS_CIPHER_DES_CBC,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DES_EDE3_CBC,         "des-ede3-cbc", "DES-EDE3-CBC" ),
-        MBEDTLS_CIPHER_DES_EDE3_CBC,
-    },
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_CIPHER_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_cipher_alg_t, cipher_alg, oid_cipher_alg)
-FN_OID_GET_ATTR1(mbedtls_oid_get_cipher_alg, oid_cipher_alg_t, cipher_alg, mbedtls_cipher_type_t, cipher_alg)
-#endif /* MBEDTLS_CIPHER_C */
-
-#if defined(MBEDTLS_MD_C)
-/*
- * For digestAlgorithm
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_md_type_t           md_alg;
-} oid_md_alg_t;
-
-static const oid_md_alg_t oid_md_alg[] =
-{
-#if defined(MBEDTLS_MD5_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_MD5,       "id-md5",       "MD5" ),
-        MBEDTLS_MD_MD5,
-    },
-#endif /* MBEDTLS_MD5_C */
-#if defined(MBEDTLS_SHA1_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_SHA1,      "id-sha1",      "SHA-1" ),
-        MBEDTLS_MD_SHA1,
-    },
-#endif /* MBEDTLS_SHA1_C */
-#if defined(MBEDTLS_SHA224_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_SHA224,    "id-sha224",    "SHA-224" ),
-        MBEDTLS_MD_SHA224,
-    },
-#endif
-#if defined(MBEDTLS_SHA256_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_SHA256,    "id-sha256",    "SHA-256" ),
-        MBEDTLS_MD_SHA256,
-    },
-#endif /* MBEDTLS_SHA256_C */
-#if defined(MBEDTLS_SHA384_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_SHA384,    "id-sha384",    "SHA-384" ),
-        MBEDTLS_MD_SHA384,
-    },
-#endif /* MBEDTLS_SHA384_C */
-#if defined(MBEDTLS_SHA512_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_SHA512,    "id-sha512",    "SHA-512" ),
-        MBEDTLS_MD_SHA512,
-    },
-#endif /* MBEDTLS_SHA512_C */
-#if defined(MBEDTLS_RIPEMD160_C)
-    {
-     OID_DESCRIPTOR( MBEDTLS_OID_DIGEST_ALG_RIPEMD160, "id-ripemd160", "RIPEMD-160" ),
-        MBEDTLS_MD_RIPEMD160,
-    },
-#endif /* MBEDTLS_RIPEMD160_C */
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_MD_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_md_alg_t, md_alg, oid_md_alg)
-FN_OID_GET_ATTR1(mbedtls_oid_get_md_alg, oid_md_alg_t, md_alg, mbedtls_md_type_t, md_alg)
-FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_md, oid_md_alg_t, oid_md_alg, mbedtls_md_type_t, md_alg)
-
-/*
- * For HMAC digestAlgorithm
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_md_type_t           md_hmac;
-} oid_md_hmac_t;
-
-static const oid_md_hmac_t oid_md_hmac[] =
-{
-#if defined(MBEDTLS_SHA1_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_HMAC_SHA1,      "hmacSHA1",      "HMAC-SHA-1" ),
-        MBEDTLS_MD_SHA1,
-    },
-#endif /* MBEDTLS_SHA1_C */
-#if defined(MBEDTLS_SHA224_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_HMAC_SHA224,    "hmacSHA224",    "HMAC-SHA-224" ),
-        MBEDTLS_MD_SHA224,
-    },
-#endif
-#if defined(MBEDTLS_SHA256_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_HMAC_SHA256,    "hmacSHA256",    "HMAC-SHA-256" ),
-        MBEDTLS_MD_SHA256,
-    },
-#endif /* MBEDTLS_SHA256_C */
-#if defined(MBEDTLS_SHA384_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_HMAC_SHA384,    "hmacSHA384",    "HMAC-SHA-384" ),
-        MBEDTLS_MD_SHA384,
-    },
-#endif /* MBEDTLS_SHA384_C */
-#if defined(MBEDTLS_SHA512_C)
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_HMAC_SHA512,    "hmacSHA512",    "HMAC-SHA-512" ),
-        MBEDTLS_MD_SHA512,
-    },
-#endif /* MBEDTLS_SHA512_C */
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_MD_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_md_hmac_t, md_hmac, oid_md_hmac)
-FN_OID_GET_ATTR1(mbedtls_oid_get_md_hmac, oid_md_hmac_t, md_hmac, mbedtls_md_type_t, md_hmac)
-#endif /* MBEDTLS_MD_C */
-
-#if defined(MBEDTLS_PKCS12_C)
-/*
- * For PKCS#12 PBEs
- */
-typedef struct {
-    mbedtls_oid_descriptor_t    descriptor;
-    mbedtls_md_type_t           md_alg;
-    mbedtls_cipher_type_t       cipher_alg;
-} oid_pkcs12_pbe_alg_t;
-
-static const oid_pkcs12_pbe_alg_t oid_pkcs12_pbe_alg[] =
-{
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS12_PBE_SHA1_DES3_EDE_CBC, "pbeWithSHAAnd3-KeyTripleDES-CBC", "PBE with SHA1 and 3-Key 3DES" ),
-        MBEDTLS_MD_SHA1,      MBEDTLS_CIPHER_DES_EDE3_CBC,
-    },
-    {
-        OID_DESCRIPTOR( MBEDTLS_OID_PKCS12_PBE_SHA1_DES2_EDE_CBC, "pbeWithSHAAnd2-KeyTripleDES-CBC", "PBE with SHA1 and 2-Key 3DES" ),
-        MBEDTLS_MD_SHA1,      MBEDTLS_CIPHER_DES_EDE_CBC,
-    },
-    {
-        NULL_OID_DESCRIPTOR,
-        MBEDTLS_MD_NONE, MBEDTLS_CIPHER_NONE,
-    },
-};
-
-FN_OID_TYPED_FROM_ASN1(oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, oid_pkcs12_pbe_alg)
-FN_OID_GET_ATTR2(mbedtls_oid_get_pkcs12_pbe_alg, oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, mbedtls_md_type_t, md_alg, mbedtls_cipher_type_t, cipher_alg)
-#endif /* MBEDTLS_PKCS12_C */
-
-#define OID_SAFE_SNPRINTF                               \
-    do {                                                \
-        if( ret < 0 || (size_t) ret >= n )              \
-            return( MBEDTLS_ERR_OID_BUF_TOO_SMALL );    \
-                                                        \
-        n -= (size_t) ret;                              \
-        p += (size_t) ret;                              \
-    } while( 0 )
-
-/* Return the x.y.z.... style numeric string for the given OID */
-int mbedtls_oid_get_numeric_string( char *buf, size_t size,
-                            const mbedtls_asn1_buf *oid )
-{
-   return MBEDTLS_ERR_ERROR_GENERIC_ERROR; // patched because it used to require printf which would fail on Windows
-}
-
-#endif /* MBEDTLS_OID_C */
diff --git a/src/duckdb/third_party/mbedtls/library/padlock.h b/src/duckdb/third_party/mbedtls/library/padlock.h
deleted file mode 100644
index 6b63dc037..000000000
--- a/src/duckdb/third_party/mbedtls/library/padlock.h
+++ /dev/null
@@ -1 +0,0 @@
-// dummy file to make amalgamantion happy
diff --git a/src/duckdb/third_party/mbedtls/library/pem.cpp b/src/duckdb/third_party/mbedtls/library/pem.cpp
deleted file mode 100644
index 67dd4e6f2..000000000
--- a/src/duckdb/third_party/mbedtls/library/pem.cpp
+++ /dev/null
@@ -1,493 +0,0 @@
-/*
- *  Privacy Enhanced Mail (PEM) decoding
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
-
-#include "mbedtls/pem.h"
-#include "mbedtls/base64.h"
-#include "mbedtls/des.h"
-#ifdef MBEDTLS_AES_C
-#include "mbedtls/aes.h"
-#endif
-#ifdef MBEDTLS_MD5_C
-#include "mbedtls/md5.h"
-#endif
-#include "mbedtls/cipher.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdlib.h>
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-#if defined(MBEDTLS_PEM_PARSE_C)
-void mbedtls_pem_init( mbedtls_pem_context *ctx )
-{
-    memset( ctx, 0, sizeof( mbedtls_pem_context ) );
-}
-
-#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) &&         \
-    ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
-/*
- * Read a 16-byte hex string and convert it to binary
- */
-static int pem_get_iv( const unsigned char *s, unsigned char *iv,
-                       size_t iv_len )
-{
-    size_t i, j, k;
-
-    memset( iv, 0, iv_len );
-
-    for( i = 0; i < iv_len * 2; i++, s++ )
-    {
-        if( *s >= '0' && *s <= '9' ) j = *s - '0'; else
-        if( *s >= 'A' && *s <= 'F' ) j = *s - '7'; else
-        if( *s >= 'a' && *s <= 'f' ) j = *s - 'W'; else
-            return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
-
-        k = ( ( i & 1 ) != 0 ) ? j : j << 4;
-
-        iv[i >> 1] = (unsigned char)( iv[i >> 1] | k );
-    }
-
-    return( 0 );
-}
-
-static int pem_pbkdf1( unsigned char *key, size_t keylen,
-                       unsigned char *iv,
-                       const unsigned char *pwd, size_t pwdlen )
-{
-    mbedtls_md5_context md5_ctx;
-    unsigned char md5sum[16];
-    size_t use_len;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    mbedtls_md5_init( &md5_ctx );
-
-    /*
-     * key[ 0..15] = MD5(pwd || IV)
-     */
-    if( ( ret = mbedtls_md5_starts( &md5_ctx ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_update( &md5_ctx, pwd, pwdlen ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_update( &md5_ctx, iv,  8 ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_finish( &md5_ctx, md5sum ) ) != 0 )
-        goto exit;
-
-    if( keylen <= 16 )
-    {
-        memcpy( key, md5sum, keylen );
-        goto exit;
-    }
-
-    memcpy( key, md5sum, 16 );
-
-    /*
-     * key[16..23] = MD5(key[ 0..15] || pwd || IV])
-     */
-    if( ( ret = mbedtls_md5_starts( &md5_ctx ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_update( &md5_ctx, md5sum, 16 ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_update( &md5_ctx, pwd, pwdlen ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_update( &md5_ctx, iv, 8 ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md5_finish( &md5_ctx, md5sum ) ) != 0 )
-        goto exit;
-
-    use_len = 16;
-    if( keylen < 32 )
-        use_len = keylen - 16;
-
-    memcpy( key + 16, md5sum, use_len );
-
-exit:
-    mbedtls_md5_free( &md5_ctx );
-    mbedtls_platform_zeroize( md5sum, 16 );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_DES_C)
-/*
- * Decrypt with DES-CBC, using PBKDF1 for key derivation
- */
-static int pem_des_decrypt( unsigned char des_iv[8],
-                            unsigned char *buf, size_t buflen,
-                            const unsigned char *pwd, size_t pwdlen )
-{
-    mbedtls_des_context des_ctx;
-    unsigned char des_key[8];
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    mbedtls_des_init( &des_ctx );
-
-    if( ( ret = pem_pbkdf1( des_key, 8, des_iv, pwd, pwdlen ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_des_setkey_dec( &des_ctx, des_key ) ) != 0 )
-        goto exit;
-    ret = mbedtls_des_crypt_cbc( &des_ctx, MBEDTLS_DES_DECRYPT, buflen,
-                     des_iv, buf, buf );
-
-exit:
-    mbedtls_des_free( &des_ctx );
-    mbedtls_platform_zeroize( des_key, 8 );
-
-    return( ret );
-}
-
-/*
- * Decrypt with 3DES-CBC, using PBKDF1 for key derivation
- */
-static int pem_des3_decrypt( unsigned char des3_iv[8],
-                             unsigned char *buf, size_t buflen,
-                             const unsigned char *pwd, size_t pwdlen )
-{
-    mbedtls_des3_context des3_ctx;
-    unsigned char des3_key[24];
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    mbedtls_des3_init( &des3_ctx );
-
-    if( ( ret = pem_pbkdf1( des3_key, 24, des3_iv, pwd, pwdlen ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_des3_set3key_dec( &des3_ctx, des3_key ) ) != 0 )
-        goto exit;
-    ret = mbedtls_des3_crypt_cbc( &des3_ctx, MBEDTLS_DES_DECRYPT, buflen,
-                     des3_iv, buf, buf );
-
-exit:
-    mbedtls_des3_free( &des3_ctx );
-    mbedtls_platform_zeroize( des3_key, 24 );
-
-    return( ret );
-}
-#endif /* MBEDTLS_DES_C */
-
-#if defined(MBEDTLS_AES_C)
-/*
- * Decrypt with AES-XXX-CBC, using PBKDF1 for key derivation
- */
-static int pem_aes_decrypt( unsigned char aes_iv[16], unsigned int keylen,
-                            unsigned char *buf, size_t buflen,
-                            const unsigned char *pwd, size_t pwdlen )
-{
-    mbedtls_aes_context aes_ctx;
-    unsigned char aes_key[32];
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    mbedtls_aes_init( &aes_ctx );
-
-    if( ( ret = pem_pbkdf1( aes_key, keylen, aes_iv, pwd, pwdlen ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_aes_setkey_dec( &aes_ctx, aes_key, keylen * 8 ) ) != 0 )
-        goto exit;
-    ret = mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_DECRYPT, buflen,
-                     aes_iv, buf, buf );
-
-exit:
-    mbedtls_aes_free( &aes_ctx );
-    mbedtls_platform_zeroize( aes_key, keylen );
-
-    return( ret );
-}
-#endif /* MBEDTLS_AES_C */
-
-#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
-          ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
-
-int mbedtls_pem_read_buffer( mbedtls_pem_context *ctx, const char *header, const char *footer,
-                     const unsigned char *data, const unsigned char *pwd,
-                     size_t pwdlen, size_t *use_len )
-{
-    int ret, enc;
-    size_t len;
-    unsigned char *buf;
-    const unsigned char *s1, *s2, *end;
-#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) &&         \
-    ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
-    unsigned char pem_iv[16];
-    mbedtls_cipher_type_t enc_alg = MBEDTLS_CIPHER_NONE;
-#else
-    ((void) pwd);
-    ((void) pwdlen);
-#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
-          ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
-
-    if( ctx == NULL )
-        return( MBEDTLS_ERR_PEM_BAD_INPUT_DATA );
-
-    s1 = (unsigned char *) strstr( (const char *) data, header );
-
-    if( s1 == NULL )
-        return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
-
-    s2 = (unsigned char *) strstr( (const char *) data, footer );
-
-    if( s2 == NULL || s2 <= s1 )
-        return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
-
-    s1 += strlen( header );
-    if( *s1 == ' '  ) s1++;
-    if( *s1 == '\r' ) s1++;
-    if( *s1 == '\n' ) s1++;
-    else return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
-
-    end = s2;
-    end += strlen( footer );
-    if( *end == ' '  ) end++;
-    if( *end == '\r' ) end++;
-    if( *end == '\n' ) end++;
-    *use_len = end - data;
-
-    enc = 0;
-
-    if( s2 - s1 >= 22 && memcmp( s1, "Proc-Type: 4,ENCRYPTED", 22 ) == 0 )
-    {
-#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) &&         \
-    ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
-        enc++;
-
-        s1 += 22;
-        if( *s1 == '\r' ) s1++;
-        if( *s1 == '\n' ) s1++;
-        else return( MBEDTLS_ERR_PEM_INVALID_DATA );
-
-
-#if defined(MBEDTLS_DES_C)
-        if( s2 - s1 >= 23 && memcmp( s1, "DEK-Info: DES-EDE3-CBC,", 23 ) == 0 )
-        {
-            enc_alg = MBEDTLS_CIPHER_DES_EDE3_CBC;
-
-            s1 += 23;
-            if( s2 - s1 < 16 || pem_get_iv( s1, pem_iv, 8 ) != 0 )
-                return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
-
-            s1 += 16;
-        }
-        else if( s2 - s1 >= 18 && memcmp( s1, "DEK-Info: DES-CBC,", 18 ) == 0 )
-        {
-            enc_alg = MBEDTLS_CIPHER_DES_CBC;
-
-            s1 += 18;
-            if( s2 - s1 < 16 || pem_get_iv( s1, pem_iv, 8) != 0 )
-                return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
-
-            s1 += 16;
-        }
-#endif /* MBEDTLS_DES_C */
-
-#if defined(MBEDTLS_AES_C)
-        if( s2 - s1 >= 14 && memcmp( s1, "DEK-Info: AES-", 14 ) == 0 )
-        {
-            if( s2 - s1 < 22 )
-                return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
-            else if( memcmp( s1, "DEK-Info: AES-128-CBC,", 22 ) == 0 )
-                enc_alg = MBEDTLS_CIPHER_AES_128_CBC;
-            else if( memcmp( s1, "DEK-Info: AES-192-CBC,", 22 ) == 0 )
-                enc_alg = MBEDTLS_CIPHER_AES_192_CBC;
-            else if( memcmp( s1, "DEK-Info: AES-256-CBC,", 22 ) == 0 )
-                enc_alg = MBEDTLS_CIPHER_AES_256_CBC;
-            else
-                return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
-
-            s1 += 22;
-            if( s2 - s1 < 32 || pem_get_iv( s1, pem_iv, 16 ) != 0 )
-                return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
-
-            s1 += 32;
-        }
-#endif /* MBEDTLS_AES_C */
-
-        if( enc_alg == MBEDTLS_CIPHER_NONE )
-            return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
-
-        if( *s1 == '\r' ) s1++;
-        if( *s1 == '\n' ) s1++;
-        else return( MBEDTLS_ERR_PEM_INVALID_DATA );
-#else
-        return( MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE );
-#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
-          ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
-    }
-
-    if( s1 >= s2 )
-        return( MBEDTLS_ERR_PEM_INVALID_DATA );
-
-    ret = mbedtls_base64_decode( NULL, 0, &len, s1, s2 - s1 );
-
-    if( ret == MBEDTLS_ERR_BASE64_INVALID_CHARACTER )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PEM_INVALID_DATA, ret ) );
-
-    if( ( buf = (unsigned char *) mbedtls_calloc( 1, len ) ) == NULL )
-        return( MBEDTLS_ERR_PEM_ALLOC_FAILED );
-
-    if( ( ret = mbedtls_base64_decode( buf, len, &len, s1, s2 - s1 ) ) != 0 )
-    {
-        mbedtls_platform_zeroize( buf, len );
-        mbedtls_free( buf );
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PEM_INVALID_DATA, ret ) );
-    }
-
-    if( enc != 0 )
-    {
-#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) &&         \
-    ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
-        if( pwd == NULL )
-        {
-            mbedtls_platform_zeroize( buf, len );
-            mbedtls_free( buf );
-            return( MBEDTLS_ERR_PEM_PASSWORD_REQUIRED );
-        }
-
-        ret = 0;
-
-#if defined(MBEDTLS_DES_C)
-        if( enc_alg == MBEDTLS_CIPHER_DES_EDE3_CBC )
-            ret = pem_des3_decrypt( pem_iv, buf, len, pwd, pwdlen );
-        else if( enc_alg == MBEDTLS_CIPHER_DES_CBC )
-            ret = pem_des_decrypt( pem_iv, buf, len, pwd, pwdlen );
-#endif /* MBEDTLS_DES_C */
-
-#if defined(MBEDTLS_AES_C)
-        if( enc_alg == MBEDTLS_CIPHER_AES_128_CBC )
-            ret = pem_aes_decrypt( pem_iv, 16, buf, len, pwd, pwdlen );
-        else if( enc_alg == MBEDTLS_CIPHER_AES_192_CBC )
-            ret = pem_aes_decrypt( pem_iv, 24, buf, len, pwd, pwdlen );
-        else if( enc_alg == MBEDTLS_CIPHER_AES_256_CBC )
-            ret = pem_aes_decrypt( pem_iv, 32, buf, len, pwd, pwdlen );
-#endif /* MBEDTLS_AES_C */
-
-        if( ret != 0 )
-        {
-            mbedtls_free( buf );
-            return( ret );
-        }
-
-        /*
-         * The result will be ASN.1 starting with a SEQUENCE tag, with 1 to 3
-         * length bytes (allow 4 to be sure) in all known use cases.
-         *
-         * Use that as a heuristic to try to detect password mismatches.
-         */
-        if( len <= 2 || buf[0] != 0x30 || buf[1] > 0x83 )
-        {
-            mbedtls_platform_zeroize( buf, len );
-            mbedtls_free( buf );
-            return( MBEDTLS_ERR_PEM_PASSWORD_MISMATCH );
-        }
-#else
-        mbedtls_platform_zeroize( buf, len );
-        mbedtls_free( buf );
-        return( MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE );
-#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
-          ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
-    }
-
-    ctx->buf = buf;
-    ctx->buflen = len;
-
-    return( 0 );
-}
-
-void mbedtls_pem_free( mbedtls_pem_context *ctx )
-{
-    if ( ctx->buf != NULL )
-    {
-        mbedtls_platform_zeroize( ctx->buf, ctx->buflen );
-        mbedtls_free( ctx->buf );
-    }
-    mbedtls_free( ctx->info );
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_pem_context ) );
-}
-#endif /* MBEDTLS_PEM_PARSE_C */
-
-#if defined(MBEDTLS_PEM_WRITE_C)
-int mbedtls_pem_write_buffer( const char *header, const char *footer,
-                      const unsigned char *der_data, size_t der_len,
-                      unsigned char *buf, size_t buf_len, size_t *olen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *encode_buf = NULL, *c, *p = buf;
-    size_t len = 0, use_len, add_len = 0;
-
-    mbedtls_base64_encode( NULL, 0, &use_len, der_data, der_len );
-    add_len = strlen( header ) + strlen( footer ) + ( use_len / 64 ) + 1;
-
-    if( use_len + add_len > buf_len )
-    {
-        *olen = use_len + add_len;
-        return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
-    }
-
-    if( use_len != 0 &&
-        ( ( encode_buf = mbedtls_calloc( 1, use_len ) ) == NULL ) )
-        return( MBEDTLS_ERR_PEM_ALLOC_FAILED );
-
-    if( ( ret = mbedtls_base64_encode( encode_buf, use_len, &use_len, der_data,
-                               der_len ) ) != 0 )
-    {
-        mbedtls_free( encode_buf );
-        return( ret );
-    }
-
-    memcpy( p, header, strlen( header ) );
-    p += strlen( header );
-    c = encode_buf;
-
-    while( use_len )
-    {
-        len = ( use_len > 64 ) ? 64 : use_len;
-        memcpy( p, c, len );
-        use_len -= len;
-        p += len;
-        c += len;
-        *p++ = '\n';
-    }
-
-    memcpy( p, footer, strlen( footer ) );
-    p += strlen( footer );
-
-    *p++ = '\0';
-    *olen = p - buf;
-
-     /* Clean any remaining data previously written to the buffer */
-    memset( buf + *olen, 0, buf_len - *olen );
-
-    mbedtls_free( encode_buf );
-    return( 0 );
-}
-#endif /* MBEDTLS_PEM_WRITE_C */
-#endif /* MBEDTLS_PEM_PARSE_C || MBEDTLS_PEM_WRITE_C */
-
diff --git a/src/duckdb/third_party/mbedtls/library/pk.cpp b/src/duckdb/third_party/mbedtls/library/pk.cpp
deleted file mode 100644
index ea4869c14..000000000
--- a/src/duckdb/third_party/mbedtls/library/pk.cpp
+++ /dev/null
@@ -1,649 +0,0 @@
-/*
- *  Public Key abstraction layer
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_PK_C)
-#include "mbedtls/pk.h"
-#include "pk_wrap.h"
-
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#if defined(MBEDTLS_RSA_C)
-#include "mbedtls/rsa.h"
-#endif
-#if defined(MBEDTLS_ECP_C)
-#include "mbedtls/ecp.h"
-#endif
-#if defined(MBEDTLS_ECDSA_C)
-#include "mbedtls/ecdsa.h"
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#include "mbedtls/psa_util.h"
-#endif
-
-#include <limits.h>
-#include <stdint.h>
-
-/* Parameter validation macros based on platform_util.h */
-#define PK_VALIDATE_RET( cond )    \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_PK_BAD_INPUT_DATA )
-#define PK_VALIDATE( cond )        \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-/*
- * Initialise a mbedtls_pk_context
- */
-void mbedtls_pk_init( mbedtls_pk_context *ctx )
-{
-    PK_VALIDATE( ctx != NULL );
-
-    ctx->pk_info = NULL;
-    ctx->pk_ctx = NULL;
-}
-
-/*
- * Free (the components of) a mbedtls_pk_context
- */
-void mbedtls_pk_free( mbedtls_pk_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    if ( ctx->pk_info != NULL )
-        ctx->pk_info->ctx_free_func( ctx->pk_ctx );
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_pk_context ) );
-}
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-/*
- * Initialize a restart context
- */
-void mbedtls_pk_restart_init( mbedtls_pk_restart_ctx *ctx )
-{
-    PK_VALIDATE( ctx != NULL );
-    ctx->pk_info = NULL;
-    ctx->rs_ctx = NULL;
-}
-
-/*
- * Free the components of a restart context
- */
-void mbedtls_pk_restart_free( mbedtls_pk_restart_ctx *ctx )
-{
-    if( ctx == NULL || ctx->pk_info == NULL ||
-        ctx->pk_info->rs_free_func == NULL )
-    {
-        return;
-    }
-
-    ctx->pk_info->rs_free_func( ctx->rs_ctx );
-
-    ctx->pk_info = NULL;
-    ctx->rs_ctx = NULL;
-}
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-/*
- * Get pk_info structure from type
- */
-const mbedtls_pk_info_t * mbedtls_pk_info_from_type( mbedtls_pk_type_t pk_type )
-{
-    switch( pk_type ) {
-#if defined(MBEDTLS_RSA_C)
-        case MBEDTLS_PK_RSA:
-            return( &mbedtls_rsa_info );
-#endif
-#if defined(MBEDTLS_ECP_C)
-        case MBEDTLS_PK_ECKEY:
-            return( &mbedtls_eckey_info );
-        case MBEDTLS_PK_ECKEY_DH:
-            return( &mbedtls_eckeydh_info );
-#endif
-#if defined(MBEDTLS_ECDSA_C)
-        case MBEDTLS_PK_ECDSA:
-            return( &mbedtls_ecdsa_info );
-#endif
-        /* MBEDTLS_PK_RSA_ALT omitted on purpose */
-        default:
-            return( NULL );
-    }
-}
-
-/*
- * Initialise context
- */
-int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    if( info == NULL || ctx->pk_info != NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
-        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
-
-    ctx->pk_info = info;
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-/*
- * Initialise a PSA-wrapping context
- */
-int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx,
-                             const psa_key_id_t key )
-{
-    const mbedtls_pk_info_t * const info = &mbedtls_pk_opaque_info;
-    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    psa_key_id_t *pk_ctx;
-    psa_key_type_t type;
-
-    if( ctx == NULL || ctx->pk_info != NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( PSA_SUCCESS != psa_get_key_attributes( key, &attributes ) )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-    type = psa_get_key_type( &attributes );
-    psa_reset_key_attributes( &attributes );
-
-    /* Current implementation of can_do() relies on this. */
-    if( ! PSA_KEY_TYPE_IS_ECC_KEY_PAIR( type ) )
-        return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE) ;
-
-    if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
-        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
-
-    ctx->pk_info = info;
-
-    pk_ctx = (psa_key_id_t *) ctx->pk_ctx;
-    *pk_ctx = key;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-/*
- * Initialize an RSA-alt context
- */
-int mbedtls_pk_setup_rsa_alt( mbedtls_pk_context *ctx, void * key,
-                         mbedtls_pk_rsa_alt_decrypt_func decrypt_func,
-                         mbedtls_pk_rsa_alt_sign_func sign_func,
-                         mbedtls_pk_rsa_alt_key_len_func key_len_func )
-{
-    mbedtls_rsa_alt_context *rsa_alt;
-    const mbedtls_pk_info_t *info = &mbedtls_rsa_alt_info;
-
-    PK_VALIDATE_RET( ctx != NULL );
-    if( ctx->pk_info != NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
-        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
-
-    ctx->pk_info = info;
-
-    rsa_alt = (mbedtls_rsa_alt_context *) ctx->pk_ctx;
-
-    rsa_alt->key = key;
-    rsa_alt->decrypt_func = decrypt_func;
-    rsa_alt->sign_func = sign_func;
-    rsa_alt->key_len_func = key_len_func;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
-
-/*
- * Tell if a PK can do the operations of the given type
- */
-int mbedtls_pk_can_do( const mbedtls_pk_context *ctx, mbedtls_pk_type_t type )
-{
-    /* A context with null pk_info is not set up yet and can't do anything.
-     * For backward compatibility, also accept NULL instead of a context
-     * pointer. */
-    if( ctx == NULL || ctx->pk_info == NULL )
-        return( 0 );
-
-    return( ctx->pk_info->can_do( type ) );
-}
-
-/*
- * Helper for mbedtls_pk_sign and mbedtls_pk_verify
- */
-static inline int pk_hashlen_helper( mbedtls_md_type_t md_alg, size_t *hash_len )
-{
-    const mbedtls_md_info_t *md_info;
-
-    if( *hash_len != 0 )
-        return( 0 );
-
-    if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
-        return( -1 );
-
-    *hash_len = mbedtls_md_get_size( md_info );
-    return( 0 );
-}
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-/*
- * Helper to set up a restart context if needed
- */
-static int pk_restart_setup( mbedtls_pk_restart_ctx *ctx,
-                             const mbedtls_pk_info_t *info )
-{
-    /* Don't do anything if already set up or invalid */
-    if( ctx == NULL || ctx->pk_info != NULL )
-        return( 0 );
-
-    /* Should never happen when we're called */
-    if( info->rs_alloc_func == NULL || info->rs_free_func == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ( ctx->rs_ctx = info->rs_alloc_func() ) == NULL )
-        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
-
-    ctx->pk_info = info;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-/*
- * Verify a signature (restartable)
- */
-int mbedtls_pk_verify_restartable( mbedtls_pk_context *ctx,
-               mbedtls_md_type_t md_alg,
-               const unsigned char *hash, size_t hash_len,
-               const unsigned char *sig, size_t sig_len,
-               mbedtls_pk_restart_ctx *rs_ctx )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE && hash_len == 0 ) ||
-                     hash != NULL );
-    PK_VALIDATE_RET( sig != NULL );
-
-    if( ctx->pk_info == NULL ||
-        pk_hashlen_helper( md_alg, &hash_len ) != 0 )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    /* optimization: use non-restartable version if restart disabled */
-    if( rs_ctx != NULL &&
-        mbedtls_ecp_restart_is_enabled() &&
-        ctx->pk_info->verify_rs_func != NULL )
-    {
-        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-        if( ( ret = pk_restart_setup( rs_ctx, ctx->pk_info ) ) != 0 )
-            return( ret );
-
-        ret = ctx->pk_info->verify_rs_func( ctx->pk_ctx,
-                   md_alg, hash, hash_len, sig, sig_len, rs_ctx->rs_ctx );
-
-        if( ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
-            mbedtls_pk_restart_free( rs_ctx );
-
-        return( ret );
-    }
-#else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-    (void) rs_ctx;
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-    if( ctx->pk_info->verify_func == NULL )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    return( ctx->pk_info->verify_func( ctx->pk_ctx, md_alg, hash, hash_len,
-                                       sig, sig_len ) );
-}
-
-/*
- * Verify a signature
- */
-int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
-               const unsigned char *hash, size_t hash_len,
-               const unsigned char *sig, size_t sig_len )
-{
-    return( mbedtls_pk_verify_restartable( ctx, md_alg, hash, hash_len,
-                                           sig, sig_len, NULL ) );
-}
-
-/*
- * Verify a signature with options
- */
-int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
-                   mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   const unsigned char *sig, size_t sig_len )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE && hash_len == 0 ) ||
-                     hash != NULL );
-    PK_VALIDATE_RET( sig != NULL );
-
-    if( ctx->pk_info == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ! mbedtls_pk_can_do( ctx, type ) )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    if( type == MBEDTLS_PK_RSASSA_PSS )
-    {
-#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21)
-        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-        const mbedtls_pk_rsassa_pss_options *pss_opts;
-
-#if SIZE_MAX > UINT_MAX
-        if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
-            return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-#endif /* SIZE_MAX > UINT_MAX */
-
-        if( options == NULL )
-            return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-        pss_opts = (const mbedtls_pk_rsassa_pss_options *) options;
-
-        if( sig_len < mbedtls_pk_get_len( ctx ) )
-            return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
-
-        ret = mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_pk_rsa( *ctx ),
-                                                 md_alg, (unsigned int) hash_len, hash,
-                                                 pss_opts->mgf1_hash_id,
-                                                 pss_opts->expected_salt_len,
-                                                 sig );
-        if( ret != 0 )
-            return( ret );
-
-        if( sig_len > mbedtls_pk_get_len( ctx ) )
-            return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
-
-        return( 0 );
-#else
-        return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
-#endif /* MBEDTLS_RSA_C && MBEDTLS_PKCS1_V21 */
-    }
-
-    /* General case: no options */
-    if( options != NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    return( mbedtls_pk_verify( ctx, md_alg, hash, hash_len, sig, sig_len ) );
-}
-
-/*
- * Make a signature (restartable)
- */
-int mbedtls_pk_sign_restartable( mbedtls_pk_context *ctx,
-             mbedtls_md_type_t md_alg,
-             const unsigned char *hash, size_t hash_len,
-             unsigned char *sig, size_t sig_size, size_t *sig_len,
-             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
-             mbedtls_pk_restart_ctx *rs_ctx )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE && hash_len == 0 ) ||
-                     hash != NULL );
-    PK_VALIDATE_RET( sig != NULL );
-
-    if( ctx->pk_info == NULL ||
-        pk_hashlen_helper( md_alg, &hash_len ) != 0 )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    /* optimization: use non-restartable version if restart disabled */
-    if( rs_ctx != NULL &&
-        mbedtls_ecp_restart_is_enabled() &&
-        ctx->pk_info->sign_rs_func != NULL )
-    {
-        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-        if( ( ret = pk_restart_setup( rs_ctx, ctx->pk_info ) ) != 0 )
-            return( ret );
-
-        ret = ctx->pk_info->sign_rs_func( ctx->pk_ctx, md_alg,
-                                          hash, hash_len,
-                                          sig, sig_size, sig_len,
-                                          f_rng, p_rng, rs_ctx->rs_ctx );
-
-        if( ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
-            mbedtls_pk_restart_free( rs_ctx );
-
-        return( ret );
-    }
-#else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-    (void) rs_ctx;
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-    if( ctx->pk_info->sign_func == NULL )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    return( ctx->pk_info->sign_func( ctx->pk_ctx, md_alg,
-                                     hash, hash_len,
-                                     sig, sig_size, sig_len,
-                                     f_rng, p_rng ) );
-}
-
-/*
- * Make a signature
- */
-int mbedtls_pk_sign( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
-             const unsigned char *hash, size_t hash_len,
-             unsigned char *sig, size_t sig_size, size_t *sig_len,
-             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    return( mbedtls_pk_sign_restartable( ctx, md_alg, hash, hash_len,
-                                         sig, sig_size, sig_len,
-                                         f_rng, p_rng, NULL ) );
-}
-
-/*
- * Decrypt message
- */
-int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
-                const unsigned char *input, size_t ilen,
-                unsigned char *output, size_t *olen, size_t osize,
-                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( input != NULL || ilen == 0 );
-    PK_VALIDATE_RET( output != NULL || osize == 0 );
-    PK_VALIDATE_RET( olen != NULL );
-
-    if( ctx->pk_info == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ctx->pk_info->decrypt_func == NULL )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    return( ctx->pk_info->decrypt_func( ctx->pk_ctx, input, ilen,
-                output, olen, osize, f_rng, p_rng ) );
-}
-
-/*
- * Encrypt message
- */
-int mbedtls_pk_encrypt( mbedtls_pk_context *ctx,
-                const unsigned char *input, size_t ilen,
-                unsigned char *output, size_t *olen, size_t osize,
-                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( input != NULL || ilen == 0 );
-    PK_VALIDATE_RET( output != NULL || osize == 0 );
-    PK_VALIDATE_RET( olen != NULL );
-
-    if( ctx->pk_info == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ctx->pk_info->encrypt_func == NULL )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    return( ctx->pk_info->encrypt_func( ctx->pk_ctx, input, ilen,
-                output, olen, osize, f_rng, p_rng ) );
-}
-
-/*
- * Check public-private key pair
- */
-int mbedtls_pk_check_pair( const mbedtls_pk_context *pub,
-                           const mbedtls_pk_context *prv,
-                           int (*f_rng)(void *, unsigned char *, size_t),
-                           void *p_rng )
-{
-    PK_VALIDATE_RET( pub != NULL );
-    PK_VALIDATE_RET( prv != NULL );
-
-    if( pub->pk_info == NULL ||
-        prv->pk_info == NULL )
-    {
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-    }
-
-    if( f_rng == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( prv->pk_info->check_pair_func == NULL )
-        return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
-
-    if( prv->pk_info->type == MBEDTLS_PK_RSA_ALT )
-    {
-        if( pub->pk_info->type != MBEDTLS_PK_RSA )
-            return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-    }
-    else
-    {
-        if( pub->pk_info != prv->pk_info )
-            return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-    }
-
-    return( prv->pk_info->check_pair_func( pub->pk_ctx, prv->pk_ctx, f_rng, p_rng ) );
-}
-
-/*
- * Get key size in bits
- */
-size_t mbedtls_pk_get_bitlen( const mbedtls_pk_context *ctx )
-{
-    /* For backward compatibility, accept NULL or a context that
-     * isn't set up yet, and return a fake value that should be safe. */
-    if( ctx == NULL || ctx->pk_info == NULL )
-        return( 0 );
-
-    return( ctx->pk_info->get_bitlen( ctx->pk_ctx ) );
-}
-
-/*
- * Export debug information
- */
-int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items )
-{
-    PK_VALIDATE_RET( ctx != NULL );
-    if( ctx->pk_info == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    if( ctx->pk_info->debug_func == NULL )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    ctx->pk_info->debug_func( ctx->pk_ctx, items );
-    return( 0 );
-}
-
-/*
- * Access the PK type name
- */
-const char *mbedtls_pk_get_name( const mbedtls_pk_context *ctx )
-{
-    if( ctx == NULL || ctx->pk_info == NULL )
-        return( "invalid PK" );
-
-    return( ctx->pk_info->name );
-}
-
-/*
- * Access the PK type
- */
-mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context *ctx )
-{
-    if( ctx == NULL || ctx->pk_info == NULL )
-        return( MBEDTLS_PK_NONE );
-
-    return( ctx->pk_info->type );
-}
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-/*
- * Load the key to a PSA key slot,
- * then turn the PK context into a wrapper for that key slot.
- *
- * Currently only works for EC private keys.
- */
-int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk,
-                               psa_key_id_t *key,
-                               psa_algorithm_t hash_alg )
-{
-#if !defined(MBEDTLS_ECP_C)
-    ((void) pk);
-    ((void) key);
-    ((void) hash_alg);
-    return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-#else
-    const mbedtls_ecp_keypair *ec;
-    unsigned char d[MBEDTLS_ECP_MAX_BYTES];
-    size_t d_len;
-    psa_ecc_family_t curve_id;
-    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    psa_key_type_t key_type;
-    size_t bits;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    /* export the private key material in the format PSA wants */
-    if( mbedtls_pk_get_type( pk ) != MBEDTLS_PK_ECKEY )
-        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
-
-    ec = mbedtls_pk_ec( *pk );
-    d_len = ( ec->grp.nbits + 7 ) / 8;
-    if( ( ret = mbedtls_mpi_write_binary( &ec->d, d, d_len ) ) != 0 )
-        return( ret );
-
-    curve_id = mbedtls_ecc_group_to_psa( ec->grp.id, &bits );
-    key_type = PSA_KEY_TYPE_ECC_KEY_PAIR( curve_id );
-
-    /* prepare the key attributes */
-    psa_set_key_type( &attributes, key_type );
-    psa_set_key_bits( &attributes, bits );
-    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
-    psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(hash_alg) );
-
-    /* import private key into PSA */
-    if( PSA_SUCCESS != psa_import_key( &attributes, d, d_len, key ) )
-        return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-    /* make PK context wrap the key slot */
-    mbedtls_pk_free( pk );
-    mbedtls_pk_init( pk );
-
-    return( mbedtls_pk_setup_opaque( pk, *key ) );
-#endif /* MBEDTLS_ECP_C */
-}
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-#endif /* MBEDTLS_PK_C */
diff --git a/src/duckdb/third_party/mbedtls/library/pk_wrap.cpp b/src/duckdb/third_party/mbedtls/library/pk_wrap.cpp
deleted file mode 100644
index 80c0aad27..000000000
--- a/src/duckdb/third_party/mbedtls/library/pk_wrap.cpp
+++ /dev/null
@@ -1,1080 +0,0 @@
-/*
- *  Public Key abstraction layer: wrapper functions
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_PK_C)
-#include "pk_wrap.h"
-#include "mbedtls/error.h"
-
-/* Even if RSA not activated, for the sake of RSA-alt */
-#include "mbedtls/rsa.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_ECP_C)
-#include "mbedtls/ecp.h"
-#endif
-
-#if defined(MBEDTLS_ECDSA_C)
-#include "mbedtls/ecdsa.h"
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#include "mbedtls/asn1write.h"
-#endif
-
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-#include "mbedtls/platform_util.h"
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#include "psa/crypto.h"
-#include "mbedtls/psa_util.h"
-#include "mbedtls/asn1.h"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdlib.h>
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-#include <limits.h>
-#include <stdint.h>
-
-#if defined(MBEDTLS_RSA_C)
-static int rsa_can_do( mbedtls_pk_type_t type )
-{
-    return( type == MBEDTLS_PK_RSA ||
-            type == MBEDTLS_PK_RSASSA_PSS );
-}
-
-static size_t rsa_get_bitlen( const void *ctx )
-{
-    const mbedtls_rsa_context * rsa = (const mbedtls_rsa_context *) ctx;
-    return( 8 * mbedtls_rsa_get_len( rsa ) );
-}
-
-static int rsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   const unsigned char *sig, size_t sig_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
-    size_t rsa_len = mbedtls_rsa_get_len( rsa );
-
-#if SIZE_MAX > UINT_MAX
-    if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-#endif /* SIZE_MAX > UINT_MAX */
-
-    if( sig_len < rsa_len )
-        return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
-
-    if( ( ret = mbedtls_rsa_pkcs1_verify( rsa, md_alg,
-                                          (unsigned int) hash_len,
-                                          hash, sig ) ) != 0 )
-        return( ret );
-
-    /* The buffer contains a valid signature followed by extra data.
-     * We have a special error code for that so that so that callers can
-     * use mbedtls_pk_verify() to check "Does the buffer start with a
-     * valid signature?" and not just "Does the buffer contain a valid
-     * signature?". */
-    if( sig_len > rsa_len )
-        return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
-
-    return( 0 );
-}
-
-static int rsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
-
-#if SIZE_MAX > UINT_MAX
-    if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-#endif /* SIZE_MAX > UINT_MAX */
-
-    *sig_len = mbedtls_rsa_get_len( rsa );
-    if( sig_size < *sig_len )
-        return( MBEDTLS_ERR_PK_BUFFER_TOO_SMALL );
-
-    return( mbedtls_rsa_pkcs1_sign( rsa, f_rng, p_rng,
-                                    md_alg, (unsigned int) hash_len,
-                                    hash, sig ) );
-}
-
-static int rsa_decrypt_wrap( void *ctx,
-                    const unsigned char *input, size_t ilen,
-                    unsigned char *output, size_t *olen, size_t osize,
-                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
-
-    if( ilen != mbedtls_rsa_get_len( rsa ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    return( mbedtls_rsa_pkcs1_decrypt( rsa, f_rng, p_rng,
-                olen, input, output, osize ) );
-}
-
-static int rsa_encrypt_wrap( void *ctx,
-                    const unsigned char *input, size_t ilen,
-                    unsigned char *output, size_t *olen, size_t osize,
-                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
-    *olen = mbedtls_rsa_get_len( rsa );
-
-    if( *olen > osize )
-        return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
-
-    return( mbedtls_rsa_pkcs1_encrypt( rsa, f_rng, p_rng,
-                                       ilen, input, output ) );
-}
-
-static int rsa_check_pair_wrap( const void *pub, const void *prv,
-                                int (*f_rng)(void *, unsigned char *, size_t),
-                                void *p_rng )
-{
-    (void) f_rng;
-    (void) p_rng;
-    return( mbedtls_rsa_check_pub_priv( (const mbedtls_rsa_context *) pub,
-                                (const mbedtls_rsa_context *) prv ) );
-}
-
-static void *rsa_alloc_wrap( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_rsa_context ) );
-
-    if( ctx != NULL )
-        mbedtls_rsa_init( (mbedtls_rsa_context *) ctx );
-
-    return( ctx );
-}
-
-static void rsa_free_wrap( void *ctx )
-{
-    mbedtls_rsa_free( (mbedtls_rsa_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-static void rsa_debug( const void *ctx, mbedtls_pk_debug_item *items )
-{
-#if defined(MBEDTLS_RSA_ALT)
-    /* Not supported */
-    (void) ctx;
-    (void) items;
-#else
-    items->type = MBEDTLS_PK_DEBUG_MPI;
-    items->name = "rsa.N";
-    items->value = &( ((mbedtls_rsa_context *) ctx)->N );
-
-    items++;
-
-    items->type = MBEDTLS_PK_DEBUG_MPI;
-    items->name = "rsa.E";
-    items->value = &( ((mbedtls_rsa_context *) ctx)->E );
-#endif
-}
-
-const mbedtls_pk_info_t mbedtls_rsa_info = {
-    MBEDTLS_PK_RSA,
-    "RSA",
-    rsa_get_bitlen,
-    rsa_can_do,
-    rsa_verify_wrap,
-    rsa_sign_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL,
-    NULL,
-#endif
-    rsa_decrypt_wrap,
-    rsa_encrypt_wrap,
-    rsa_check_pair_wrap,
-    rsa_alloc_wrap,
-    rsa_free_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL,
-    NULL,
-#endif
-    rsa_debug,
-};
-#endif /* MBEDTLS_RSA_C */
-
-#if defined(MBEDTLS_ECP_C)
-/*
- * Generic EC key
- */
-static int eckey_can_do( mbedtls_pk_type_t type )
-{
-    return( type == MBEDTLS_PK_ECKEY ||
-            type == MBEDTLS_PK_ECKEY_DH ||
-            type == MBEDTLS_PK_ECDSA );
-}
-
-static size_t eckey_get_bitlen( const void *ctx )
-{
-    return( ((mbedtls_ecp_keypair *) ctx)->grp.pbits );
-}
-
-#if defined(MBEDTLS_ECDSA_C)
-/* Forward declarations */
-static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len );
-
-static int ecdsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-
-static int eckey_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_ecdsa_context ecdsa;
-
-    mbedtls_ecdsa_init( &ecdsa );
-
-    if( ( ret = mbedtls_ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
-        ret = ecdsa_verify_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len );
-
-    mbedtls_ecdsa_free( &ecdsa );
-
-    return( ret );
-}
-
-static int eckey_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_ecdsa_context ecdsa;
-
-    mbedtls_ecdsa_init( &ecdsa );
-
-    if( ( ret = mbedtls_ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
-        ret = ecdsa_sign_wrap( &ecdsa, md_alg, hash, hash_len,
-                               sig, sig_size, sig_len,
-                               f_rng, p_rng );
-
-    mbedtls_ecdsa_free( &ecdsa );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_ECP_RESTARTABLE)
-/* Forward declarations */
-static int ecdsa_verify_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len,
-                       void *rs_ctx );
-
-static int ecdsa_sign_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
-                   void *rs_ctx );
-
-/*
- * Restart context for ECDSA operations with ECKEY context
- *
- * We need to store an actual ECDSA context, as we need to pass the same to
- * the underlying ecdsa function, so we can't create it on the fly every time.
- */
-typedef struct
-{
-    mbedtls_ecdsa_restart_ctx ecdsa_rs;
-    mbedtls_ecdsa_context ecdsa_ctx;
-} eckey_restart_ctx;
-
-static void *eckey_rs_alloc( void )
-{
-    eckey_restart_ctx *rs_ctx;
-
-    void *ctx = mbedtls_calloc( 1, sizeof( eckey_restart_ctx ) );
-
-    if( ctx != NULL )
-    {
-        rs_ctx = ctx;
-        mbedtls_ecdsa_restart_init( &rs_ctx->ecdsa_rs );
-        mbedtls_ecdsa_init( &rs_ctx->ecdsa_ctx );
-    }
-
-    return( ctx );
-}
-
-static void eckey_rs_free( void *ctx )
-{
-    eckey_restart_ctx *rs_ctx;
-
-    if( ctx == NULL)
-        return;
-
-    rs_ctx = ctx;
-    mbedtls_ecdsa_restart_free( &rs_ctx->ecdsa_rs );
-    mbedtls_ecdsa_free( &rs_ctx->ecdsa_ctx );
-
-    mbedtls_free( ctx );
-}
-
-static int eckey_verify_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len,
-                       void *rs_ctx )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    eckey_restart_ctx *rs = rs_ctx;
-
-    /* Should never happen */
-    if( rs == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    /* set up our own sub-context if needed (that is, on first run) */
-    if( rs->ecdsa_ctx.grp.pbits == 0 )
-        MBEDTLS_MPI_CHK( mbedtls_ecdsa_from_keypair( &rs->ecdsa_ctx, ctx ) );
-
-    MBEDTLS_MPI_CHK( ecdsa_verify_rs_wrap( &rs->ecdsa_ctx,
-                                           md_alg, hash, hash_len,
-                                           sig, sig_len, &rs->ecdsa_rs ) );
-
-cleanup:
-    return( ret );
-}
-
-static int eckey_sign_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
-                       void *rs_ctx )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    eckey_restart_ctx *rs = rs_ctx;
-
-    /* Should never happen */
-    if( rs == NULL )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    /* set up our own sub-context if needed (that is, on first run) */
-    if( rs->ecdsa_ctx.grp.pbits == 0 )
-        MBEDTLS_MPI_CHK( mbedtls_ecdsa_from_keypair( &rs->ecdsa_ctx, ctx ) );
-
-    MBEDTLS_MPI_CHK( ecdsa_sign_rs_wrap( &rs->ecdsa_ctx, md_alg,
-                                         hash, hash_len, sig, sig_size, sig_len,
-                                         f_rng, p_rng, &rs->ecdsa_rs ) );
-
-cleanup:
-    return( ret );
-}
-#endif /* MBEDTLS_ECP_RESTARTABLE */
-#endif /* MBEDTLS_ECDSA_C */
-
-static int eckey_check_pair( const void *pub, const void *prv,
-                             int (*f_rng)(void *, unsigned char *, size_t),
-                             void *p_rng )
-{
-    return( mbedtls_ecp_check_pub_priv( (const mbedtls_ecp_keypair *) pub,
-                                (const mbedtls_ecp_keypair *) prv,
-                                f_rng, p_rng ) );
-}
-
-static void *eckey_alloc_wrap( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ecp_keypair ) );
-
-    if( ctx != NULL )
-        mbedtls_ecp_keypair_init( ctx );
-
-    return( ctx );
-}
-
-static void eckey_free_wrap( void *ctx )
-{
-    mbedtls_ecp_keypair_free( (mbedtls_ecp_keypair *) ctx );
-    mbedtls_free( ctx );
-}
-
-static void eckey_debug( const void *ctx, mbedtls_pk_debug_item *items )
-{
-    items->type = MBEDTLS_PK_DEBUG_ECP;
-    items->name = "eckey.Q";
-    items->value = &( ((mbedtls_ecp_keypair *) ctx)->Q );
-}
-
-const mbedtls_pk_info_t mbedtls_eckey_info = {
-    MBEDTLS_PK_ECKEY,
-    "EC",
-    eckey_get_bitlen,
-    eckey_can_do,
-#if defined(MBEDTLS_ECDSA_C)
-    eckey_verify_wrap,
-    eckey_sign_wrap,
-#if defined(MBEDTLS_ECP_RESTARTABLE)
-    eckey_verify_rs_wrap,
-    eckey_sign_rs_wrap,
-#endif
-#else /* MBEDTLS_ECDSA_C */
-    NULL,
-    NULL,
-#endif /* MBEDTLS_ECDSA_C */
-    NULL,
-    NULL,
-    eckey_check_pair,
-    eckey_alloc_wrap,
-    eckey_free_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    eckey_rs_alloc,
-    eckey_rs_free,
-#endif
-    eckey_debug,
-};
-
-/*
- * EC key restricted to ECDH
- */
-static int eckeydh_can_do( mbedtls_pk_type_t type )
-{
-    return( type == MBEDTLS_PK_ECKEY ||
-            type == MBEDTLS_PK_ECKEY_DH );
-}
-
-const mbedtls_pk_info_t mbedtls_eckeydh_info = {
-    MBEDTLS_PK_ECKEY_DH,
-    "EC_DH",
-    eckey_get_bitlen,         /* Same underlying key structure */
-    eckeydh_can_do,
-    NULL,
-    NULL,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL,
-    NULL,
-#endif
-    NULL,
-    NULL,
-    eckey_check_pair,
-    eckey_alloc_wrap,       /* Same underlying key structure */
-    eckey_free_wrap,        /* Same underlying key structure */
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL,
-    NULL,
-#endif
-    eckey_debug,            /* Same underlying key structure */
-};
-#endif /* MBEDTLS_ECP_C */
-
-#if defined(MBEDTLS_ECDSA_C)
-static int ecdsa_can_do( mbedtls_pk_type_t type )
-{
-    return( type == MBEDTLS_PK_ECDSA );
-}
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-/*
- * An ASN.1 encoded signature is a sequence of two ASN.1 integers. Parse one of
- * those integers and convert it to the fixed-length encoding expected by PSA.
- */
-static int extract_ecdsa_sig_int( unsigned char **from, const unsigned char *end,
-                                  unsigned char *to, size_t to_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t unpadded_len, padding_len;
-
-    if( ( ret = mbedtls_asn1_get_tag( from, end, &unpadded_len,
-                                      MBEDTLS_ASN1_INTEGER ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    while( unpadded_len > 0 && **from == 0x00 )
-    {
-        ( *from )++;
-        unpadded_len--;
-    }
-
-    if( unpadded_len > to_len || unpadded_len == 0 )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
-
-    padding_len = to_len - unpadded_len;
-    memset( to, 0x00, padding_len );
-    memcpy( to + padding_len, *from, unpadded_len );
-    ( *from ) += unpadded_len;
-
-    return( 0 );
-}
-
-/*
- * Convert a signature from an ASN.1 sequence of two integers
- * to a raw {r,s} buffer. Note: the provided sig buffer must be at least
- * twice as big as int_size.
- */
-static int extract_ecdsa_sig( unsigned char **p, const unsigned char *end,
-                              unsigned char *sig, size_t int_size )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t tmp_size;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &tmp_size,
-                MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-        return( ret );
-
-    /* Extract r */
-    if( ( ret = extract_ecdsa_sig_int( p, end, sig, int_size ) ) != 0 )
-        return( ret );
-    /* Extract s */
-    if( ( ret = extract_ecdsa_sig_int( p, end, sig + int_size, int_size ) ) != 0 )
-        return( ret );
-
-    return( 0 );
-}
-
-static int ecdsa_verify_wrap( void *ctx_arg, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len )
-{
-    mbedtls_ecdsa_context *ctx = ctx_arg;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    psa_key_id_t key_id = 0;
-    psa_status_t status;
-    mbedtls_pk_context key;
-    int key_len;
-    /* see ECP_PUB_DER_MAX_BYTES in pkwrite.c */
-    unsigned char buf[30 + 2 * MBEDTLS_ECP_MAX_BYTES];
-    unsigned char *p;
-    mbedtls_pk_info_t pk_info = mbedtls_eckey_info;
-    psa_algorithm_t psa_sig_md = PSA_ALG_ECDSA_ANY;
-    size_t curve_bits;
-    psa_ecc_family_t curve =
-        mbedtls_ecc_group_to_psa( ctx->grp.id, &curve_bits );
-    const size_t signature_part_size = ( ctx->grp.nbits + 7 ) / 8;
-    ((void) md_alg);
-
-    if( curve == 0 )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    /* mbedtls_pk_write_pubkey() expects a full PK context;
-     * re-construct one to make it happy */
-    key.pk_info = &pk_info;
-    key.pk_ctx = ctx;
-    p = buf + sizeof( buf );
-    key_len = mbedtls_pk_write_pubkey( &p, buf, &key );
-    if( key_len <= 0 )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
-    psa_set_key_type( &attributes, PSA_KEY_TYPE_ECC_PUBLIC_KEY( curve ) );
-    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
-    psa_set_key_algorithm( &attributes, psa_sig_md );
-
-    status = psa_import_key( &attributes,
-                             buf + sizeof( buf ) - key_len, key_len,
-                             &key_id );
-    if( status != PSA_SUCCESS )
-    {
-        ret = mbedtls_psa_err_translate_pk( status );
-        goto cleanup;
-    }
-
-    /* We don't need the exported key anymore and can
-     * reuse its buffer for signature extraction. */
-    if( 2 * signature_part_size > sizeof( buf ) )
-    {
-        ret = MBEDTLS_ERR_PK_BAD_INPUT_DATA;
-        goto cleanup;
-    }
-
-    p = (unsigned char*) sig;
-    if( ( ret = extract_ecdsa_sig( &p, sig + sig_len, buf,
-                                   signature_part_size ) ) != 0 )
-    {
-        goto cleanup;
-    }
-
-    if( psa_verify_hash( key_id, psa_sig_md,
-                         hash, hash_len,
-                         buf, 2 * signature_part_size )
-         != PSA_SUCCESS )
-    {
-         ret = MBEDTLS_ERR_ECP_VERIFY_FAILED;
-         goto cleanup;
-    }
-
-    if( p != sig + sig_len )
-    {
-        ret = MBEDTLS_ERR_PK_SIG_LEN_MISMATCH;
-        goto cleanup;
-    }
-    ret = 0;
-
-cleanup:
-    psa_destroy_key( key_id );
-    return( ret );
-}
-#else /* MBEDTLS_USE_PSA_CRYPTO */
-static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    ((void) md_alg);
-
-    ret = mbedtls_ecdsa_read_signature( (mbedtls_ecdsa_context *) ctx,
-                                hash, hash_len, sig, sig_len );
-
-    if( ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH )
-        return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
-
-    return( ret );
-}
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-static int ecdsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    return( mbedtls_ecdsa_write_signature( (mbedtls_ecdsa_context *) ctx,
-                                           md_alg, hash, hash_len,
-                                           sig, sig_size, sig_len,
-                                           f_rng, p_rng ) );
-}
-
-#if defined(MBEDTLS_ECP_RESTARTABLE)
-static int ecdsa_verify_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                       const unsigned char *hash, size_t hash_len,
-                       const unsigned char *sig, size_t sig_len,
-                       void *rs_ctx )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    ((void) md_alg);
-
-    ret = mbedtls_ecdsa_read_signature_restartable(
-            (mbedtls_ecdsa_context *) ctx,
-            hash, hash_len, sig, sig_len,
-            (mbedtls_ecdsa_restart_ctx *) rs_ctx );
-
-    if( ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH )
-        return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
-
-    return( ret );
-}
-
-static int ecdsa_sign_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
-                   void *rs_ctx )
-{
-    return( mbedtls_ecdsa_write_signature_restartable(
-                (mbedtls_ecdsa_context *) ctx,
-                md_alg, hash, hash_len, sig, sig_size, sig_len, f_rng, p_rng,
-                (mbedtls_ecdsa_restart_ctx *) rs_ctx ) );
-
-}
-#endif /* MBEDTLS_ECP_RESTARTABLE */
-
-static void *ecdsa_alloc_wrap( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ecdsa_context ) );
-
-    if( ctx != NULL )
-        mbedtls_ecdsa_init( (mbedtls_ecdsa_context *) ctx );
-
-    return( ctx );
-}
-
-static void ecdsa_free_wrap( void *ctx )
-{
-    mbedtls_ecdsa_free( (mbedtls_ecdsa_context *) ctx );
-    mbedtls_free( ctx );
-}
-
-#if defined(MBEDTLS_ECP_RESTARTABLE)
-static void *ecdsa_rs_alloc( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ecdsa_restart_ctx ) );
-
-    if( ctx != NULL )
-        mbedtls_ecdsa_restart_init( ctx );
-
-    return( ctx );
-}
-
-static void ecdsa_rs_free( void *ctx )
-{
-    mbedtls_ecdsa_restart_free( ctx );
-    mbedtls_free( ctx );
-}
-#endif /* MBEDTLS_ECP_RESTARTABLE */
-
-const mbedtls_pk_info_t mbedtls_ecdsa_info = {
-    MBEDTLS_PK_ECDSA,
-    "ECDSA",
-    eckey_get_bitlen,     /* Compatible key structures */
-    ecdsa_can_do,
-    ecdsa_verify_wrap,
-    ecdsa_sign_wrap,
-#if defined(MBEDTLS_ECP_RESTARTABLE)
-    ecdsa_verify_rs_wrap,
-    ecdsa_sign_rs_wrap,
-#endif
-    NULL,
-    NULL,
-    eckey_check_pair,   /* Compatible key structures */
-    ecdsa_alloc_wrap,
-    ecdsa_free_wrap,
-#if defined(MBEDTLS_ECP_RESTARTABLE)
-    ecdsa_rs_alloc,
-    ecdsa_rs_free,
-#endif
-    eckey_debug,        /* Compatible key structures */
-};
-#endif /* MBEDTLS_ECDSA_C */
-
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-/*
- * Support for alternative RSA-private implementations
- */
-
-static int rsa_alt_can_do( mbedtls_pk_type_t type )
-{
-    return( type == MBEDTLS_PK_RSA );
-}
-
-static size_t rsa_alt_get_bitlen( const void *ctx )
-{
-    const mbedtls_rsa_alt_context *rsa_alt = (const mbedtls_rsa_alt_context *) ctx;
-
-    return( 8 * rsa_alt->key_len_func( rsa_alt->key ) );
-}
-
-static int rsa_alt_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_context *) ctx;
-
-#if SIZE_MAX > UINT_MAX
-    if( UINT_MAX < hash_len )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-#endif /* SIZE_MAX > UINT_MAX */
-
-    *sig_len = rsa_alt->key_len_func( rsa_alt->key );
-    if( *sig_len > MBEDTLS_PK_SIGNATURE_MAX_SIZE )
-        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-    if( *sig_len > sig_size )
-        return( MBEDTLS_ERR_PK_BUFFER_TOO_SMALL );
-
-    return( rsa_alt->sign_func( rsa_alt->key, f_rng, p_rng,
-                md_alg, (unsigned int) hash_len, hash, sig ) );
-}
-
-static int rsa_alt_decrypt_wrap( void *ctx,
-                    const unsigned char *input, size_t ilen,
-                    unsigned char *output, size_t *olen, size_t osize,
-                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_context *) ctx;
-
-    ((void) f_rng);
-    ((void) p_rng);
-
-    if( ilen != rsa_alt->key_len_func( rsa_alt->key ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    return( rsa_alt->decrypt_func( rsa_alt->key,
-                olen, input, output, osize ) );
-}
-
-#if defined(MBEDTLS_RSA_C)
-static int rsa_alt_check_pair( const void *pub, const void *prv,
-                               int (*f_rng)(void *, unsigned char *, size_t),
-                               void *p_rng )
-{
-    unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
-    unsigned char hash[32];
-    size_t sig_len = 0;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    if( rsa_alt_get_bitlen( prv ) != rsa_get_bitlen( pub ) )
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-
-    memset( hash, 0x2a, sizeof( hash ) );
-
-    if( ( ret = rsa_alt_sign_wrap( (void *) prv, MBEDTLS_MD_NONE,
-                                   hash, sizeof( hash ),
-                                   sig, sizeof( sig ), &sig_len,
-                                   f_rng, p_rng ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    if( rsa_verify_wrap( (void *) pub, MBEDTLS_MD_NONE,
-                         hash, sizeof( hash ), sig, sig_len ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-    return( 0 );
-}
-#endif /* MBEDTLS_RSA_C */
-
-static void *rsa_alt_alloc_wrap( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_rsa_alt_context ) );
-
-    if( ctx != NULL )
-        memset( ctx, 0, sizeof( mbedtls_rsa_alt_context ) );
-
-    return( ctx );
-}
-
-static void rsa_alt_free_wrap( void *ctx )
-{
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_rsa_alt_context ) );
-    mbedtls_free( ctx );
-}
-
-const mbedtls_pk_info_t mbedtls_rsa_alt_info = {
-    MBEDTLS_PK_RSA_ALT,
-    "RSA-alt",
-    rsa_alt_get_bitlen,
-    rsa_alt_can_do,
-    NULL,
-    rsa_alt_sign_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL,
-    NULL,
-#endif
-    rsa_alt_decrypt_wrap,
-    NULL,
-#if defined(MBEDTLS_RSA_C)
-    rsa_alt_check_pair,
-#else
-    NULL,
-#endif
-    rsa_alt_alloc_wrap,
-    rsa_alt_free_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL,
-    NULL,
-#endif
-    NULL,
-};
-
-#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-
-static void *pk_opaque_alloc_wrap( void )
-{
-    void *ctx = mbedtls_calloc( 1, sizeof( psa_key_id_t ) );
-
-    /* no _init() function to call, an calloc() already zeroized */
-
-    return( ctx );
-}
-
-static void pk_opaque_free_wrap( void *ctx )
-{
-    mbedtls_platform_zeroize( ctx, sizeof( psa_key_id_t ) );
-    mbedtls_free( ctx );
-}
-
-static size_t pk_opaque_get_bitlen( const void *ctx )
-{
-    const psa_key_id_t *key = (const psa_key_id_t *) ctx;
-    size_t bits;
-    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
-    if( PSA_SUCCESS != psa_get_key_attributes( *key, &attributes ) )
-        return( 0 );
-
-    bits = psa_get_key_bits( &attributes );
-    psa_reset_key_attributes( &attributes );
-    return( bits );
-}
-
-static int pk_opaque_can_do( mbedtls_pk_type_t type )
-{
-    /* For now opaque PSA keys can only wrap ECC keypairs,
-     * as checked by setup_psa().
-     * Also, ECKEY_DH does not really make sense with the current API. */
-    return( type == MBEDTLS_PK_ECKEY ||
-            type == MBEDTLS_PK_ECDSA );
-}
-
-#if defined(MBEDTLS_ECDSA_C)
-
-/*
- * Simultaneously convert and move raw MPI from the beginning of a buffer
- * to an ASN.1 MPI at the end of the buffer.
- * See also mbedtls_asn1_write_mpi().
- *
- * p: pointer to the end of the output buffer
- * start: start of the output buffer, and also of the mpi to write at the end
- * n_len: length of the mpi to read from start
- */
-static int asn1_write_mpibuf( unsigned char **p, unsigned char *start,
-                              size_t n_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len = 0;
-
-    if( (size_t)( *p - start ) < n_len )
-        return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
-
-    len = n_len;
-    *p -= len;
-    memmove( *p, start, len );
-
-    /* ASN.1 DER encoding requires minimal length, so skip leading 0s.
-     * Neither r nor s should be 0, but as a failsafe measure, still detect
-     * that rather than overflowing the buffer in case of a PSA error. */
-    while( len > 0 && **p == 0x00 )
-    {
-        ++(*p);
-        --len;
-    }
-
-    /* this is only reached if the signature was invalid */
-    if( len == 0 )
-        return( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
-
-    /* if the msb is 1, ASN.1 requires that we prepend a 0.
-     * Neither r nor s can be 0, so we can assume len > 0 at all times. */
-    if( **p & 0x80 )
-    {
-        if( *p - start < 1 )
-            return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
-
-        *--(*p) = 0x00;
-        len += 1;
-    }
-
-    MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
-    MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
-                                                MBEDTLS_ASN1_INTEGER ) );
-
-    return( (int) len );
-}
-
-/* Transcode signature from PSA format to ASN.1 sequence.
- * See ecdsa_signature_to_asn1 in ecdsa.c, but with byte buffers instead of
- * MPIs, and in-place.
- *
- * [in/out] sig: the signature pre- and post-transcoding
- * [in/out] sig_len: signature length pre- and post-transcoding
- * [int] buf_len: the available size the in/out buffer
- */
-static int pk_ecdsa_sig_asn1_from_psa( unsigned char *sig, size_t *sig_len,
-                                       size_t buf_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len = 0;
-    const size_t rs_len = *sig_len / 2;
-    unsigned char *p = sig + buf_len;
-
-    MBEDTLS_ASN1_CHK_ADD( len, asn1_write_mpibuf( &p, sig + rs_len, rs_len ) );
-    MBEDTLS_ASN1_CHK_ADD( len, asn1_write_mpibuf( &p, sig, rs_len ) );
-
-    MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &p, sig, len ) );
-    MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &p, sig,
-                          MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) );
-
-    memmove( sig, p, len );
-    *sig_len = len;
-
-    return( 0 );
-}
-
-#endif /* MBEDTLS_ECDSA_C */
-
-static int pk_opaque_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
-                   const unsigned char *hash, size_t hash_len,
-                   unsigned char *sig, size_t sig_size, size_t *sig_len,
-                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-#if !defined(MBEDTLS_ECDSA_C)
-    ((void) ctx);
-    ((void) md_alg);
-    ((void) hash);
-    ((void) hash_len);
-    ((void) sig);
-    ((void) sig_size);
-    ((void) sig_len);
-    ((void) f_rng);
-    ((void) p_rng);
-    return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
-#else /* !MBEDTLS_ECDSA_C */
-    const psa_key_id_t *key = (const psa_key_id_t *) ctx;
-    psa_algorithm_t alg = PSA_ALG_ECDSA( mbedtls_psa_translate_md( md_alg ) );
-    psa_status_t status;
-
-    /* PSA has its own RNG */
-    (void) f_rng;
-    (void) p_rng;
-
-    /* make the signature */
-    status = psa_sign_hash( *key, alg, hash, hash_len,
-                            sig, sig_size, sig_len );
-    if( status != PSA_SUCCESS )
-        return( mbedtls_psa_err_translate_pk( status ) );
-
-    /* transcode it to ASN.1 sequence */
-    return( pk_ecdsa_sig_asn1_from_psa( sig, sig_len, sig_size ) );
-#endif /* !MBEDTLS_ECDSA_C */
-}
-
-const mbedtls_pk_info_t mbedtls_pk_opaque_info = {
-    MBEDTLS_PK_OPAQUE,
-    "Opaque",
-    pk_opaque_get_bitlen,
-    pk_opaque_can_do,
-    NULL, /* verify - will be done later */
-    pk_opaque_sign_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL, /* restartable verify - not relevant */
-    NULL, /* restartable sign - not relevant */
-#endif
-    NULL, /* decrypt - will be done later */
-    NULL, /* encrypt - will be done later */
-    NULL, /* check_pair - could be done later or left NULL */
-    pk_opaque_alloc_wrap,
-    pk_opaque_free_wrap,
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    NULL, /* restart alloc - not relevant */
-    NULL, /* restart free - not relevant */
-#endif
-    NULL, /* debug - could be done later, or even left NULL */
-};
-
-#endif /* MBEDTLS_USE_PSA_CRYPTO */
-
-#endif /* MBEDTLS_PK_C */
diff --git a/src/duckdb/third_party/mbedtls/library/pk_wrap.h b/src/duckdb/third_party/mbedtls/library/pk_wrap.h
deleted file mode 100644
index 6f5addf75..000000000
--- a/src/duckdb/third_party/mbedtls/library/pk_wrap.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * \file pk_wrap.h
- *
- * \brief Public Key abstraction layer: wrapper functions
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#ifndef MBEDTLS_PK_WRAP_H
-#define MBEDTLS_PK_WRAP_H
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/pk.h"
-
-struct mbedtls_pk_info_t
-{
-    /** Public key type */
-    mbedtls_pk_type_t type;
-
-    /** Type name */
-    const char *name;
-
-    /** Get key size in bits */
-    size_t (*get_bitlen)( const void * );
-
-    /** Tell if the context implements this type (e.g. ECKEY can do ECDSA) */
-    int (*can_do)( mbedtls_pk_type_t type );
-
-    /** Verify signature */
-    int (*verify_func)( void *ctx, mbedtls_md_type_t md_alg,
-                        const unsigned char *hash, size_t hash_len,
-                        const unsigned char *sig, size_t sig_len );
-
-    /** Make signature */
-    int (*sign_func)( void *ctx, mbedtls_md_type_t md_alg,
-                      const unsigned char *hash, size_t hash_len,
-                      unsigned char *sig, size_t sig_size, size_t *sig_len,
-                      int (*f_rng)(void *, unsigned char *, size_t),
-                      void *p_rng );
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    /** Verify signature (restartable) */
-    int (*verify_rs_func)( void *ctx, mbedtls_md_type_t md_alg,
-                           const unsigned char *hash, size_t hash_len,
-                           const unsigned char *sig, size_t sig_len,
-                           void *rs_ctx );
-
-    /** Make signature (restartable) */
-    int (*sign_rs_func)( void *ctx, mbedtls_md_type_t md_alg,
-                         const unsigned char *hash, size_t hash_len,
-                         unsigned char *sig, size_t sig_size, size_t *sig_len,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng, void *rs_ctx );
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-    /** Decrypt message */
-    int (*decrypt_func)( void *ctx, const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t *olen, size_t osize,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng );
-
-    /** Encrypt message */
-    int (*encrypt_func)( void *ctx, const unsigned char *input, size_t ilen,
-                         unsigned char *output, size_t *olen, size_t osize,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng );
-
-    /** Check public-private key pair */
-    int (*check_pair_func)( const void *pub, const void *prv,
-                            int (*f_rng)(void *, unsigned char *, size_t),
-                            void *p_rng );
-
-    /** Allocate a new context */
-    void * (*ctx_alloc_func)( void );
-
-    /** Free the given context */
-    void (*ctx_free_func)( void *ctx );
-
-#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
-    /** Allocate the restart context */
-    void * (*rs_alloc_func)( void );
-
-    /** Free the restart context */
-    void (*rs_free_func)( void *rs_ctx );
-#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
-
-    /** Interface with the debug module */
-    void (*debug_func)( const void *ctx, mbedtls_pk_debug_item *items );
-
-};
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-/* Container for RSA-alt */
-typedef struct
-{
-    void *key;
-    mbedtls_pk_rsa_alt_decrypt_func decrypt_func;
-    mbedtls_pk_rsa_alt_sign_func sign_func;
-    mbedtls_pk_rsa_alt_key_len_func key_len_func;
-} mbedtls_rsa_alt_context;
-#endif
-
-#if defined(MBEDTLS_RSA_C)
-extern const mbedtls_pk_info_t mbedtls_rsa_info;
-#endif
-
-#if defined(MBEDTLS_ECP_C)
-extern const mbedtls_pk_info_t mbedtls_eckey_info;
-extern const mbedtls_pk_info_t mbedtls_eckeydh_info;
-#endif
-
-#if defined(MBEDTLS_ECDSA_C)
-extern const mbedtls_pk_info_t mbedtls_ecdsa_info;
-#endif
-
-#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
-extern const mbedtls_pk_info_t mbedtls_rsa_alt_info;
-#endif
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO)
-extern const mbedtls_pk_info_t mbedtls_pk_opaque_info;
-#endif
-
-#endif /* MBEDTLS_PK_WRAP_H */
diff --git a/src/duckdb/third_party/mbedtls/library/pkparse.cpp b/src/duckdb/third_party/mbedtls/library/pkparse.cpp
deleted file mode 100644
index b2d3bb074..000000000
--- a/src/duckdb/third_party/mbedtls/library/pkparse.cpp
+++ /dev/null
@@ -1,1529 +0,0 @@
-/*
- *  Public Key layer for parsing key files and structures
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_PK_PARSE_C)
-
-#include "mbedtls/pk.h"
-#include "mbedtls/asn1.h"
-#include "mbedtls/oid.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_RSA_C)
-#include "mbedtls/rsa.h"
-#endif
-#if defined(MBEDTLS_ECP_C)
-#include "mbedtls/ecp.h"
-#endif
-#if defined(MBEDTLS_ECDSA_C)
-#include "mbedtls/ecdsa.h"
-#endif
-#if defined(MBEDTLS_PEM_PARSE_C)
-#include "mbedtls/pem.h"
-#endif
-#if defined(MBEDTLS_PKCS5_C)
-#include "mbedtls/pkcs5.h"
-#endif
-#if defined(MBEDTLS_PKCS12_C)
-#include "mbedtls/pkcs12.h"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdlib.h>
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif
-
-/* Parameter validation macros based on platform_util.h */
-#define PK_VALIDATE_RET( cond )    \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_PK_BAD_INPUT_DATA )
-#define PK_VALIDATE( cond )        \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-#if defined(MBEDTLS_FS_IO)
-/*
- * Load all data from a file into a given buffer.
- *
- * The file is expected to contain either PEM or DER encoded data.
- * A terminating null byte is always appended. It is included in the announced
- * length only if the data looks like it is PEM encoded.
- */
-int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n )
-{
-    FILE *f;
-    long size;
-
-    PK_VALIDATE_RET( path != NULL );
-    PK_VALIDATE_RET( buf != NULL );
-    PK_VALIDATE_RET( n != NULL );
-
-    if( ( f = fopen( path, "rb" ) ) == NULL )
-        return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
-
-    fseek( f, 0, SEEK_END );
-    if( ( size = ftell( f ) ) == -1 )
-    {
-        fclose( f );
-        return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
-    }
-    fseek( f, 0, SEEK_SET );
-
-    *n = (size_t) size;
-
-    if( *n + 1 == 0 ||
-        ( *buf = mbedtls_calloc( 1, *n + 1 ) ) == NULL )
-    {
-        fclose( f );
-        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
-    }
-
-    if( fread( *buf, 1, *n, f ) != *n )
-    {
-        fclose( f );
-
-        mbedtls_platform_zeroize( *buf, *n );
-        mbedtls_free( *buf );
-
-        return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
-    }
-
-    fclose( f );
-
-    (*buf)[*n] = '\0';
-
-    if( strstr( (const char *) *buf, "-----BEGIN " ) != NULL )
-        ++*n;
-
-    return( 0 );
-}
-
-/*
- * Load and parse a private key
- */
-int mbedtls_pk_parse_keyfile( mbedtls_pk_context *ctx,
-        const char *path, const char *pwd,
-        int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t n;
-    unsigned char *buf;
-
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( path != NULL );
-
-    if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
-        return( ret );
-
-    if( pwd == NULL )
-        ret = mbedtls_pk_parse_key( ctx, buf, n, NULL, 0, f_rng, p_rng );
-    else
-        ret = mbedtls_pk_parse_key( ctx, buf, n,
-                (const unsigned char *) pwd, strlen( pwd ), f_rng, p_rng );
-
-    mbedtls_platform_zeroize( buf, n );
-    mbedtls_free( buf );
-
-    return( ret );
-}
-
-/*
- * Load and parse a public key
- */
-int mbedtls_pk_parse_public_keyfile( mbedtls_pk_context *ctx, const char *path )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t n;
-    unsigned char *buf;
-
-    PK_VALIDATE_RET( ctx != NULL );
-    PK_VALIDATE_RET( path != NULL );
-
-    if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
-        return( ret );
-
-    ret = mbedtls_pk_parse_public_key( ctx, buf, n );
-
-    mbedtls_platform_zeroize( buf, n );
-    mbedtls_free( buf );
-
-    return( ret );
-}
-#endif /* MBEDTLS_FS_IO */
-
-#if defined(MBEDTLS_ECP_C)
-/* Minimally parse an ECParameters buffer to and mbedtls_asn1_buf
- *
- * ECParameters ::= CHOICE {
- *   namedCurve         OBJECT IDENTIFIER
- *   specifiedCurve     SpecifiedECDomain -- = SEQUENCE { ... }
- *   -- implicitCurve   NULL
- * }
- */
-static int pk_get_ecparams( unsigned char **p, const unsigned char *end,
-                            mbedtls_asn1_buf *params )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    if ( end - *p < 1 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                MBEDTLS_ERR_ASN1_OUT_OF_DATA ) );
-
-    /* Tag may be either OID or SEQUENCE */
-    params->tag = **p;
-    if( params->tag != MBEDTLS_ASN1_OID
-#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
-            && params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE )
-#endif
-            )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) );
-    }
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &params->len, params->tag ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    params->p = *p;
-    *p += params->len;
-
-    if( *p != end )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-    return( 0 );
-}
-
-#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
-/*
- * Parse a SpecifiedECDomain (SEC 1 C.2) and (mostly) fill the group with it.
- * WARNING: the resulting group should only be used with
- * pk_group_id_from_specified(), since its base point may not be set correctly
- * if it was encoded compressed.
- *
- *  SpecifiedECDomain ::= SEQUENCE {
- *      version SpecifiedECDomainVersion(ecdpVer1 | ecdpVer2 | ecdpVer3, ...),
- *      fieldID FieldID {{FieldTypes}},
- *      curve Curve,
- *      base ECPoint,
- *      order INTEGER,
- *      cofactor INTEGER OPTIONAL,
- *      hash HashAlgorithm OPTIONAL,
- *      ...
- *  }
- *
- * We only support prime-field as field type, and ignore hash and cofactor.
- */
-static int pk_group_from_specified( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *p = params->p;
-    const unsigned char * const end = params->p + params->len;
-    const unsigned char *end_field, *end_curve;
-    size_t len;
-    int ver;
-
-    /* SpecifiedECDomainVersion ::= INTEGER { 1, 2, 3 } */
-    if( ( ret = mbedtls_asn1_get_int( &p, end, &ver ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( ver < 1 || ver > 3 )
-        return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-
-    /*
-     * FieldID { FIELD-ID:IOSet } ::= SEQUENCE { -- Finite field
-     *       fieldType FIELD-ID.&id({IOSet}),
-     *       parameters FIELD-ID.&Type({IOSet}{@fieldType})
-     * }
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-        return( ret );
-
-    end_field = p + len;
-
-    /*
-     * FIELD-ID ::= TYPE-IDENTIFIER
-     * FieldTypes FIELD-ID ::= {
-     *       { Prime-p IDENTIFIED BY prime-field } |
-     *       { Characteristic-two IDENTIFIED BY characteristic-two-field }
-     * }
-     * prime-field OBJECT IDENTIFIER ::= { id-fieldType 1 }
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end_field, &len, MBEDTLS_ASN1_OID ) ) != 0 )
-        return( ret );
-
-    if( len != MBEDTLS_OID_SIZE( MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD ) ||
-        memcmp( p, MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD, len ) != 0 )
-    {
-        return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
-    }
-
-    p += len;
-
-    /* Prime-p ::= INTEGER -- Field of size p. */
-    if( ( ret = mbedtls_asn1_get_mpi( &p, end_field, &grp->P ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    grp->pbits = mbedtls_mpi_bitlen( &grp->P );
-
-    if( p != end_field )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-    /*
-     * Curve ::= SEQUENCE {
-     *       a FieldElement,
-     *       b FieldElement,
-     *       seed BIT STRING OPTIONAL
-     *       -- Shall be present if used in SpecifiedECDomain
-     *       -- with version equal to ecdpVer2 or ecdpVer3
-     * }
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-        return( ret );
-
-    end_curve = p + len;
-
-    /*
-     * FieldElement ::= OCTET STRING
-     * containing an integer in the case of a prime field
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 ||
-        ( ret = mbedtls_mpi_read_binary( &grp->A, p, len ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    p += len;
-
-    if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 ||
-        ( ret = mbedtls_mpi_read_binary( &grp->B, p, len ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    p += len;
-
-    /* Ignore seed BIT STRING OPTIONAL */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_BIT_STRING ) ) == 0 )
-        p += len;
-
-    if( p != end_curve )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-    /*
-     * ECPoint ::= OCTET STRING
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( ( ret = mbedtls_ecp_point_read_binary( grp, &grp->G,
-                                      ( const unsigned char *) p, len ) ) != 0 )
-    {
-        /*
-         * If we can't read the point because it's compressed, cheat by
-         * reading only the X coordinate and the parity bit of Y.
-         */
-        if( ret != MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE ||
-            ( p[0] != 0x02 && p[0] != 0x03 ) ||
-            len != mbedtls_mpi_size( &grp->P ) + 1 ||
-            mbedtls_mpi_read_binary( &grp->G.X, p + 1, len - 1 ) != 0 ||
-            mbedtls_mpi_lset( &grp->G.Y, p[0] - 2 ) != 0 ||
-            mbedtls_mpi_lset( &grp->G.Z, 1 ) != 0 )
-        {
-            return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-        }
-    }
-
-    p += len;
-
-    /*
-     * order INTEGER
-     */
-    if( ( ret = mbedtls_asn1_get_mpi( &p, end, &grp->N ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    grp->nbits = mbedtls_mpi_bitlen( &grp->N );
-
-    /*
-     * Allow optional elements by purposefully not enforcing p == end here.
-     */
-
-    return( 0 );
-}
-
-/*
- * Find the group id associated with an (almost filled) group as generated by
- * pk_group_from_specified(), or return an error if unknown.
- */
-static int pk_group_id_from_group( const mbedtls_ecp_group *grp, mbedtls_ecp_group_id *grp_id )
-{
-    int ret = 0;
-    mbedtls_ecp_group ref;
-    const mbedtls_ecp_group_id *id;
-
-    mbedtls_ecp_group_init( &ref );
-
-    for( id = mbedtls_ecp_grp_id_list(); *id != MBEDTLS_ECP_DP_NONE; id++ )
-    {
-        /* Load the group associated to that id */
-        mbedtls_ecp_group_free( &ref );
-        MBEDTLS_MPI_CHK( mbedtls_ecp_group_load( &ref, *id ) );
-
-        /* Compare to the group we were given, starting with easy tests */
-        if( grp->pbits == ref.pbits && grp->nbits == ref.nbits &&
-            mbedtls_mpi_cmp_mpi( &grp->P, &ref.P ) == 0 &&
-            mbedtls_mpi_cmp_mpi( &grp->A, &ref.A ) == 0 &&
-            mbedtls_mpi_cmp_mpi( &grp->B, &ref.B ) == 0 &&
-            mbedtls_mpi_cmp_mpi( &grp->N, &ref.N ) == 0 &&
-            mbedtls_mpi_cmp_mpi( &grp->G.X, &ref.G.X ) == 0 &&
-            mbedtls_mpi_cmp_mpi( &grp->G.Z, &ref.G.Z ) == 0 &&
-            /* For Y we may only know the parity bit, so compare only that */
-            mbedtls_mpi_get_bit( &grp->G.Y, 0 ) == mbedtls_mpi_get_bit( &ref.G.Y, 0 ) )
-        {
-            break;
-        }
-
-    }
-
-cleanup:
-    mbedtls_ecp_group_free( &ref );
-
-    *grp_id = *id;
-
-    if( ret == 0 && *id == MBEDTLS_ECP_DP_NONE )
-        ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
-
-    return( ret );
-}
-
-/*
- * Parse a SpecifiedECDomain (SEC 1 C.2) and find the associated group ID
- */
-static int pk_group_id_from_specified( const mbedtls_asn1_buf *params,
-                                       mbedtls_ecp_group_id *grp_id )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_ecp_group grp;
-
-    mbedtls_ecp_group_init( &grp );
-
-    if( ( ret = pk_group_from_specified( params, &grp ) ) != 0 )
-        goto cleanup;
-
-    ret = pk_group_id_from_group( &grp, grp_id );
-
-cleanup:
-    mbedtls_ecp_group_free( &grp );
-
-    return( ret );
-}
-#endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
-
-/*
- * Use EC parameters to initialise an EC group
- *
- * ECParameters ::= CHOICE {
- *   namedCurve         OBJECT IDENTIFIER
- *   specifiedCurve     SpecifiedECDomain -- = SEQUENCE { ... }
- *   -- implicitCurve   NULL
- */
-static int pk_use_ecparams( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_ecp_group_id grp_id;
-
-    if( params->tag == MBEDTLS_ASN1_OID )
-    {
-        if( mbedtls_oid_get_ec_grp( params, &grp_id ) != 0 )
-            return( MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE );
-    }
-    else
-    {
-#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
-        if( ( ret = pk_group_id_from_specified( params, &grp_id ) ) != 0 )
-            return( ret );
-#else
-        return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-#endif
-    }
-
-    /*
-     * grp may already be initilialized; if so, make sure IDs match
-     */
-    if( grp->id != MBEDTLS_ECP_DP_NONE && grp->id != grp_id )
-        return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-
-    if( ( ret = mbedtls_ecp_group_load( grp, grp_id ) ) != 0 )
-        return( ret );
-
-    return( 0 );
-}
-
-/*
- * EC public key is an EC point
- *
- * The caller is responsible for clearing the structure upon failure if
- * desired. Take care to pass along the possible ECP_FEATURE_UNAVAILABLE
- * return code of mbedtls_ecp_point_read_binary() and leave p in a usable state.
- */
-static int pk_get_ecpubkey( unsigned char **p, const unsigned char *end,
-                            mbedtls_ecp_keypair *key )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-
-    if( ( ret = mbedtls_ecp_point_read_binary( &key->grp, &key->Q,
-                    (const unsigned char *) *p, end - *p ) ) == 0 )
-    {
-        ret = mbedtls_ecp_check_pubkey( &key->grp, &key->Q );
-    }
-
-    /*
-     * We know mbedtls_ecp_point_read_binary consumed all bytes or failed
-     */
-    *p = (unsigned char *) end;
-
-    return( ret );
-}
-#endif /* MBEDTLS_ECP_C */
-
-#if defined(MBEDTLS_RSA_C)
-/*
- *  RSAPublicKey ::= SEQUENCE {
- *      modulus           INTEGER,  -- n
- *      publicExponent    INTEGER   -- e
- *  }
- */
-static int pk_get_rsapubkey( unsigned char **p,
-                             const unsigned char *end,
-                             mbedtls_rsa_context *rsa )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len;
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY, ret ) );
-
-    if( *p + len != end )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY,
-                MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-    /* Import N */
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY, ret ) );
-
-    if( ( ret = mbedtls_rsa_import_raw( rsa, *p, len, NULL, 0, NULL, 0,
-                                        NULL, 0, NULL, 0 ) ) != 0 )
-        return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
-
-    *p += len;
-
-    /* Import E */
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY, ret ) );
-
-    if( ( ret = mbedtls_rsa_import_raw( rsa, NULL, 0, NULL, 0, NULL, 0,
-                                        NULL, 0, *p, len ) ) != 0 )
-        return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
-
-    *p += len;
-
-    if( mbedtls_rsa_complete( rsa ) != 0 ||
-        mbedtls_rsa_check_pubkey( rsa ) != 0 )
-    {
-        return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
-    }
-
-    if( *p != end )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY,
-                MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-    return( 0 );
-}
-#endif /* MBEDTLS_RSA_C */
-
-/* Get a PK algorithm identifier
- *
- *  AlgorithmIdentifier  ::=  SEQUENCE  {
- *       algorithm               OBJECT IDENTIFIER,
- *       parameters              ANY DEFINED BY algorithm OPTIONAL  }
- */
-static int pk_get_pk_alg( unsigned char **p,
-                          const unsigned char *end,
-                          mbedtls_pk_type_t *pk_alg, mbedtls_asn1_buf *params )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_asn1_buf alg_oid;
-
-    memset( params, 0, sizeof(mbedtls_asn1_buf) );
-
-    if( ( ret = mbedtls_asn1_get_alg( p, end, &alg_oid, params ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_ALG, ret ) );
-
-    if( mbedtls_oid_get_pk_alg( &alg_oid, pk_alg ) != 0 )
-        return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
-
-    /*
-     * No parameters with RSA (only for EC)
-     */
-    if( *pk_alg == MBEDTLS_PK_RSA &&
-            ( ( params->tag != MBEDTLS_ASN1_NULL && params->tag != 0 ) ||
-                params->len != 0 ) )
-    {
-        return( MBEDTLS_ERR_PK_INVALID_ALG );
-    }
-
-    return( 0 );
-}
-
-/*
- *  SubjectPublicKeyInfo  ::=  SEQUENCE  {
- *       algorithm            AlgorithmIdentifier,
- *       subjectPublicKey     BIT STRING }
- */
-int mbedtls_pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
-                        mbedtls_pk_context *pk )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t len;
-    mbedtls_asn1_buf alg_params;
-    mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
-    const mbedtls_pk_info_t *pk_info;
-
-    PK_VALIDATE_RET( p != NULL );
-    PK_VALIDATE_RET( *p != NULL );
-    PK_VALIDATE_RET( end != NULL );
-    PK_VALIDATE_RET( pk != NULL );
-
-    if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
-                    MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    end = *p + len;
-
-    if( ( ret = pk_get_pk_alg( p, end, &pk_alg, &alg_params ) ) != 0 )
-        return( ret );
-
-    if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY, ret ) );
-
-    if( *p + len != end )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY,
-                MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-    if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
-        return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
-
-    if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 )
-        return( ret );
-
-#if defined(MBEDTLS_RSA_C)
-    if( pk_alg == MBEDTLS_PK_RSA )
-    {
-        ret = pk_get_rsapubkey( p, end, mbedtls_pk_rsa( *pk ) );
-    } else
-#endif /* MBEDTLS_RSA_C */
-#if defined(MBEDTLS_ECP_C)
-    if( pk_alg == MBEDTLS_PK_ECKEY_DH || pk_alg == MBEDTLS_PK_ECKEY )
-    {
-        ret = pk_use_ecparams( &alg_params, &mbedtls_pk_ec( *pk )->grp );
-        if( ret == 0 )
-            ret = pk_get_ecpubkey( p, end, mbedtls_pk_ec( *pk ) );
-    } else
-#endif /* MBEDTLS_ECP_C */
-        ret = MBEDTLS_ERR_PK_UNKNOWN_PK_ALG;
-
-    if( ret == 0 && *p != end )
-        ret = MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY,
-              MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
-
-    if( ret != 0 )
-        mbedtls_pk_free( pk );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_RSA_C)
-/*
- * Wrapper around mbedtls_asn1_get_mpi() that rejects zero.
- *
- * The value zero is:
- * - never a valid value for an RSA parameter
- * - interpreted as "omitted, please reconstruct" by mbedtls_rsa_complete().
- *
- * Since values can't be omitted in PKCS#1, passing a zero value to
- * rsa_complete() would be incorrect, so reject zero values early.
- */
-static int asn1_get_nonzero_mpi( unsigned char **p,
-                                 const unsigned char *end,
-                                 mbedtls_mpi *X )
-{
-    int ret;
-
-    ret = mbedtls_asn1_get_mpi( p, end, X );
-    if( ret != 0 )
-        return( ret );
-
-    if( mbedtls_mpi_cmp_int( X, 0 ) == 0 )
-        return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-
-    return( 0 );
-}
-
-/*
- * Parse a PKCS#1 encoded private RSA key
- */
-static int pk_parse_key_pkcs1_der( mbedtls_rsa_context *rsa,
-                                   const unsigned char *key,
-                                   size_t keylen )
-{
-    int ret, version;
-    size_t len;
-    unsigned char *p, *end;
-
-    mbedtls_mpi T;
-    mbedtls_mpi_init( &T );
-
-    p = (unsigned char *) key;
-    end = p + keylen;
-
-    /*
-     * This function parses the RSAPrivateKey (PKCS#1)
-     *
-     *  RSAPrivateKey ::= SEQUENCE {
-     *      version           Version,
-     *      modulus           INTEGER,  -- n
-     *      publicExponent    INTEGER,  -- e
-     *      privateExponent   INTEGER,  -- d
-     *      prime1            INTEGER,  -- p
-     *      prime2            INTEGER,  -- q
-     *      exponent1         INTEGER,  -- d mod (p-1)
-     *      exponent2         INTEGER,  -- d mod (q-1)
-     *      coefficient       INTEGER,  -- (inverse of q) mod p
-     *      otherPrimeInfos   OtherPrimeInfos OPTIONAL
-     *  }
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    end = p + len;
-
-    if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    if( version != 0 )
-    {
-        return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION );
-    }
-
-    /* Import N */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_rsa_import( rsa, &T, NULL, NULL,
-                                        NULL, NULL ) ) != 0 )
-        goto cleanup;
-
-    /* Import E */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_rsa_import( rsa, NULL, NULL, NULL,
-                                        NULL, &T ) ) != 0 )
-        goto cleanup;
-
-    /* Import D */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_rsa_import( rsa, NULL, NULL, NULL,
-                                        &T, NULL ) ) != 0 )
-        goto cleanup;
-
-    /* Import P */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_rsa_import( rsa, NULL, &T, NULL,
-                                        NULL, NULL ) ) != 0 )
-        goto cleanup;
-
-    /* Import Q */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_rsa_import( rsa, NULL, NULL, &T,
-                                        NULL, NULL ) ) != 0 )
-        goto cleanup;
-
-#if !defined(MBEDTLS_RSA_NO_CRT) && !defined(MBEDTLS_RSA_ALT)
-    /*
-    * The RSA CRT parameters DP, DQ and QP are nominally redundant, in
-    * that they can be easily recomputed from D, P and Q. However by
-    * parsing them from the PKCS1 structure it is possible to avoid
-    * recalculating them which both reduces the overhead of loading
-    * RSA private keys into memory and also avoids side channels which
-    * can arise when computing those values, since all of D, P, and Q
-    * are secret. See https://eprint.iacr.org/2020/055 for a
-    * description of one such attack.
-    */
-
-    /* Import DP */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_mpi_copy( &rsa->DP, &T ) ) != 0 )
-       goto cleanup;
-
-    /* Import DQ */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_mpi_copy( &rsa->DQ, &T ) ) != 0 )
-       goto cleanup;
-
-    /* Import QP */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = mbedtls_mpi_copy( &rsa->QP, &T ) ) != 0 )
-       goto cleanup;
-
-#else
-    /* Verify existance of the CRT params */
-    if( ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 ||
-        ( ret = asn1_get_nonzero_mpi( &p, end, &T ) ) != 0 )
-       goto cleanup;
-#endif
-
-    /* rsa_complete() doesn't complete anything with the default
-     * implementation but is still called:
-     * - for the benefit of alternative implementation that may want to
-     *   pre-compute stuff beyond what's provided (eg Montgomery factors)
-     * - as is also sanity-checks the key
-     *
-     * Furthermore, we also check the public part for consistency with
-     * mbedtls_pk_parse_pubkey(), as it includes size minima for example.
-     */
-    if( ( ret = mbedtls_rsa_complete( rsa ) ) != 0 ||
-        ( ret = mbedtls_rsa_check_pubkey( rsa ) ) != 0 )
-    {
-        goto cleanup;
-    }
-
-    if( p != end )
-    {
-        ret = MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-              MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
-    }
-
-cleanup:
-
-    mbedtls_mpi_free( &T );
-
-    if( ret != 0 )
-    {
-        /* Wrap error code if it's coming from a lower level */
-        if( ( ret & 0xff80 ) == 0 )
-            ret = MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret );
-        else
-            ret = MBEDTLS_ERR_PK_KEY_INVALID_FORMAT;
-
-        mbedtls_rsa_free( rsa );
-    }
-
-    return( ret );
-}
-#endif /* MBEDTLS_RSA_C */
-
-#if defined(MBEDTLS_ECP_C)
-/*
- * Parse a SEC1 encoded private EC key
- */
-static int pk_parse_key_sec1_der( mbedtls_ecp_keypair *eck,
-        const unsigned char *key, size_t keylen,
-        int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    int version, pubkey_done;
-    size_t len;
-    mbedtls_asn1_buf params;
-    unsigned char *p = (unsigned char *) key;
-    unsigned char *end = p + keylen;
-    unsigned char *end2;
-
-    /*
-     * RFC 5915, or SEC1 Appendix C.4
-     *
-     * ECPrivateKey ::= SEQUENCE {
-     *      version        INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
-     *      privateKey     OCTET STRING,
-     *      parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
-     *      publicKey  [1] BIT STRING OPTIONAL
-     *    }
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    end = p + len;
-
-    if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( version != 1 )
-        return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION );
-
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( ( ret = mbedtls_mpi_read_binary( &eck->d, p, len ) ) != 0 )
-    {
-        mbedtls_ecp_keypair_free( eck );
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    p += len;
-
-    pubkey_done = 0;
-    if( p != end )
-    {
-        /*
-         * Is 'parameters' present?
-         */
-        if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-                        MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) == 0 )
-        {
-            if( ( ret = pk_get_ecparams( &p, p + len, &params) ) != 0 ||
-                ( ret = pk_use_ecparams( &params, &eck->grp )  ) != 0 )
-            {
-                mbedtls_ecp_keypair_free( eck );
-                return( ret );
-            }
-        }
-        else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
-        {
-            mbedtls_ecp_keypair_free( eck );
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-        }
-    }
-
-    if( p != end )
-    {
-        /*
-         * Is 'publickey' present? If not, or if we can't read it (eg because it
-         * is compressed), create it from the private key.
-         */
-        if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-                        MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) ) == 0 )
-        {
-            end2 = p + len;
-
-            if( ( ret = mbedtls_asn1_get_bitstring_null( &p, end2, &len ) ) != 0 )
-                return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-            if( p + len != end2 )
-                return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                        MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
-
-            if( ( ret = pk_get_ecpubkey( &p, end2, eck ) ) == 0 )
-                pubkey_done = 1;
-            else
-            {
-                /*
-                 * The only acceptable failure mode of pk_get_ecpubkey() above
-                 * is if the point format is not recognized.
-                 */
-                if( ret != MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE )
-                    return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-            }
-        }
-        else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
-        {
-            mbedtls_ecp_keypair_free( eck );
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-        }
-    }
-
-    if( ! pubkey_done &&
-        ( ret = mbedtls_ecp_mul( &eck->grp, &eck->Q, &eck->d, &eck->grp.G,
-                                 f_rng, p_rng ) ) != 0 )
-    {
-        mbedtls_ecp_keypair_free( eck );
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    if( ( ret = mbedtls_ecp_check_privkey( &eck->grp, &eck->d ) ) != 0 )
-    {
-        mbedtls_ecp_keypair_free( eck );
-        return( ret );
-    }
-
-    return( 0 );
-}
-#endif /* MBEDTLS_ECP_C */
-
-/*
- * Parse an unencrypted PKCS#8 encoded private key
- *
- * Notes:
- *
- * - This function does not own the key buffer. It is the
- *   responsibility of the caller to take care of zeroizing
- *   and freeing it after use.
- *
- * - The function is responsible for freeing the provided
- *   PK context on failure.
- *
- */
-static int pk_parse_key_pkcs8_unencrypted_der(
-        mbedtls_pk_context *pk,
-        const unsigned char* key, size_t keylen,
-        int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret, version;
-    size_t len;
-    mbedtls_asn1_buf params;
-    unsigned char *p = (unsigned char *) key;
-    unsigned char *end = p + keylen;
-    mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
-    const mbedtls_pk_info_t *pk_info;
-
-#if !defined(MBEDTLS_ECP_C)
-    (void) f_rng;
-    (void) p_rng;
-#endif
-
-    /*
-     * This function parses the PrivateKeyInfo object (PKCS#8 v1.2 = RFC 5208)
-     *
-     *    PrivateKeyInfo ::= SEQUENCE {
-     *      version                   Version,
-     *      privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
-     *      privateKey                PrivateKey,
-     *      attributes           [0]  IMPLICIT Attributes OPTIONAL }
-     *
-     *    Version ::= INTEGER
-     *    PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier
-     *    PrivateKey ::= OCTET STRING
-     *
-     *  The PrivateKey OCTET STRING is a SEC1 ECPrivateKey
-     */
-
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    end = p + len;
-
-    if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( version != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_VERSION, ret ) );
-
-    if( ( ret = pk_get_pk_alg( &p, end, &pk_alg, &params ) ) != 0 )
-    {
-        return( ret );
-    }
-
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( len < 1 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT,
-                MBEDTLS_ERR_ASN1_OUT_OF_DATA ) );
-
-    if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
-        return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
-
-    if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 )
-        return( ret );
-
-#if defined(MBEDTLS_RSA_C)
-    if( pk_alg == MBEDTLS_PK_RSA )
-    {
-        if( ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ), p, len ) ) != 0 )
-        {
-            mbedtls_pk_free( pk );
-            return( ret );
-        }
-    } else
-#endif /* MBEDTLS_RSA_C */
-#if defined(MBEDTLS_ECP_C)
-    if( pk_alg == MBEDTLS_PK_ECKEY || pk_alg == MBEDTLS_PK_ECKEY_DH )
-    {
-        if( ( ret = pk_use_ecparams( &params, &mbedtls_pk_ec( *pk )->grp ) ) != 0 ||
-            ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ), p, len, f_rng, p_rng ) ) != 0 )
-        {
-            mbedtls_pk_free( pk );
-            return( ret );
-        }
-    } else
-#endif /* MBEDTLS_ECP_C */
-        return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
-
-    return( 0 );
-}
-
-/*
- * Parse an encrypted PKCS#8 encoded private key
- *
- * To save space, the decryption happens in-place on the given key buffer.
- * Also, while this function may modify the keybuffer, it doesn't own it,
- * and instead it is the responsibility of the caller to zeroize and properly
- * free it after use.
- *
- */
-#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
-static int pk_parse_key_pkcs8_encrypted_der(
-        mbedtls_pk_context *pk,
-        unsigned char *key, size_t keylen,
-        const unsigned char *pwd, size_t pwdlen,
-        int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret, decrypted = 0;
-    size_t len;
-    unsigned char *buf;
-    unsigned char *p, *end;
-    mbedtls_asn1_buf pbe_alg_oid, pbe_params;
-#if defined(MBEDTLS_PKCS12_C)
-    mbedtls_cipher_type_t cipher_alg;
-    mbedtls_md_type_t md_alg;
-#endif
-
-    p = key;
-    end = p + keylen;
-
-    if( pwdlen == 0 )
-        return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
-
-    /*
-     * This function parses the EncryptedPrivateKeyInfo object (PKCS#8)
-     *
-     *  EncryptedPrivateKeyInfo ::= SEQUENCE {
-     *    encryptionAlgorithm  EncryptionAlgorithmIdentifier,
-     *    encryptedData        EncryptedData
-     *  }
-     *
-     *  EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
-     *
-     *  EncryptedData ::= OCTET STRING
-     *
-     *  The EncryptedData OCTET STRING is a PKCS#8 PrivateKeyInfo
-     *
-     */
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
-            MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-    }
-
-    end = p + len;
-
-    if( ( ret = mbedtls_asn1_get_alg( &p, end, &pbe_alg_oid, &pbe_params ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT, ret ) );
-
-    buf = p;
-
-    /*
-     * Decrypt EncryptedData with appropriate PBE
-     */
-#if defined(MBEDTLS_PKCS12_C)
-    if( mbedtls_oid_get_pkcs12_pbe_alg( &pbe_alg_oid, &md_alg, &cipher_alg ) == 0 )
-    {
-        if( ( ret = mbedtls_pkcs12_pbe( &pbe_params, MBEDTLS_PKCS12_PBE_DECRYPT,
-                                cipher_alg, md_alg,
-                                pwd, pwdlen, p, len, buf ) ) != 0 )
-        {
-            if( ret == MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH )
-                return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
-
-            return( ret );
-        }
-
-        decrypted = 1;
-    }
-    else
-#endif /* MBEDTLS_PKCS12_C */
-#if defined(MBEDTLS_PKCS5_C)
-    if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS5_PBES2, &pbe_alg_oid ) == 0 )
-    {
-        if( ( ret = mbedtls_pkcs5_pbes2( &pbe_params, MBEDTLS_PKCS5_DECRYPT, pwd, pwdlen,
-                                  p, len, buf ) ) != 0 )
-        {
-            if( ret == MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH )
-                return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
-
-            return( ret );
-        }
-
-        decrypted = 1;
-    }
-    else
-#endif /* MBEDTLS_PKCS5_C */
-    {
-        ((void) pwd);
-    }
-
-    if( decrypted == 0 )
-        return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
-
-    return( pk_parse_key_pkcs8_unencrypted_der( pk, buf, len, f_rng, p_rng ) );
-}
-#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
-
-/*
- * Parse a private key
- */
-int mbedtls_pk_parse_key( mbedtls_pk_context *pk,
-                  const unsigned char *key, size_t keylen,
-                  const unsigned char *pwd, size_t pwdlen,
-                  int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    const mbedtls_pk_info_t *pk_info;
-#if defined(MBEDTLS_PEM_PARSE_C)
-    size_t len;
-    mbedtls_pem_context pem;
-#endif
-
-    PK_VALIDATE_RET( pk != NULL );
-    if( keylen == 0 )
-        return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-    PK_VALIDATE_RET( key != NULL );
-
-#if defined(MBEDTLS_PEM_PARSE_C)
-   mbedtls_pem_init( &pem );
-
-#if defined(MBEDTLS_RSA_C)
-    /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
-    if( key[keylen - 1] != '\0' )
-        ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
-    else
-        ret = mbedtls_pem_read_buffer( &pem,
-                               "-----BEGIN RSA PRIVATE KEY-----",
-                               "-----END RSA PRIVATE KEY-----",
-                               key, pwd, pwdlen, &len );
-
-    if( ret == 0 )
-    {
-        pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA );
-        if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 ||
-            ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ),
-                                            pem.buf, pem.buflen ) ) != 0 )
-        {
-            mbedtls_pk_free( pk );
-        }
-
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    else if( ret == MBEDTLS_ERR_PEM_PASSWORD_MISMATCH )
-        return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
-    else if( ret == MBEDTLS_ERR_PEM_PASSWORD_REQUIRED )
-        return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
-    else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
-        return( ret );
-#endif /* MBEDTLS_RSA_C */
-
-#if defined(MBEDTLS_ECP_C)
-    /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
-    if( key[keylen - 1] != '\0' )
-        ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
-    else
-        ret = mbedtls_pem_read_buffer( &pem,
-                               "-----BEGIN EC PRIVATE KEY-----",
-                               "-----END EC PRIVATE KEY-----",
-                               key, pwd, pwdlen, &len );
-    if( ret == 0 )
-    {
-        pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY );
-
-        if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 ||
-            ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ),
-                                           pem.buf, pem.buflen,
-                                           f_rng, p_rng ) ) != 0 )
-        {
-            mbedtls_pk_free( pk );
-        }
-
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    else if( ret == MBEDTLS_ERR_PEM_PASSWORD_MISMATCH )
-        return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
-    else if( ret == MBEDTLS_ERR_PEM_PASSWORD_REQUIRED )
-        return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
-    else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
-        return( ret );
-#endif /* MBEDTLS_ECP_C */
-
-    /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
-    if( key[keylen - 1] != '\0' )
-        ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
-    else
-        ret = mbedtls_pem_read_buffer( &pem,
-                               "-----BEGIN PRIVATE KEY-----",
-                               "-----END PRIVATE KEY-----",
-                               key, NULL, 0, &len );
-    if( ret == 0 )
-    {
-        if( ( ret = pk_parse_key_pkcs8_unencrypted_der( pk,
-                        pem.buf, pem.buflen, f_rng, p_rng ) ) != 0 )
-        {
-            mbedtls_pk_free( pk );
-        }
-
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
-        return( ret );
-
-#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
-    /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
-    if( key[keylen - 1] != '\0' )
-        ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
-    else
-        ret = mbedtls_pem_read_buffer( &pem,
-                               "-----BEGIN ENCRYPTED PRIVATE KEY-----",
-                               "-----END ENCRYPTED PRIVATE KEY-----",
-                               key, NULL, 0, &len );
-    if( ret == 0 )
-    {
-        if( ( ret = pk_parse_key_pkcs8_encrypted_der( pk, pem.buf, pem.buflen,
-                        pwd, pwdlen, f_rng, p_rng ) ) != 0 )
-        {
-            mbedtls_pk_free( pk );
-        }
-
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
-        return( ret );
-#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
-#else
-    ((void) pwd);
-    ((void) pwdlen);
-#endif /* MBEDTLS_PEM_PARSE_C */
-
-    /*
-     * At this point we only know it's not a PEM formatted key. Could be any
-     * of the known DER encoded private key formats
-     *
-     * We try the different DER format parsers to see if one passes without
-     * error
-     */
-#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
-    {
-        unsigned char *key_copy;
-
-        if( ( key_copy = mbedtls_calloc( 1, keylen ) ) == NULL )
-            return( MBEDTLS_ERR_PK_ALLOC_FAILED );
-
-        memcpy( key_copy, key, keylen );
-
-        ret = pk_parse_key_pkcs8_encrypted_der( pk, key_copy, keylen,
-                                                pwd, pwdlen, f_rng, p_rng );
-
-        mbedtls_platform_zeroize( key_copy, keylen );
-        mbedtls_free( key_copy );
-    }
-
-    if( ret == 0 )
-        return( 0 );
-
-    mbedtls_pk_free( pk );
-    mbedtls_pk_init( pk );
-
-    if( ret == MBEDTLS_ERR_PK_PASSWORD_MISMATCH )
-    {
-        return( ret );
-    }
-#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
-
-    ret = pk_parse_key_pkcs8_unencrypted_der( pk, key, keylen, f_rng, p_rng );
-    if( ret == 0 )
-    {
-        return( 0 );
-    }
-
-    mbedtls_pk_free( pk );
-    mbedtls_pk_init( pk );
-
-#if defined(MBEDTLS_RSA_C)
-
-    pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA );
-    if( mbedtls_pk_setup( pk, pk_info ) == 0 &&
-        pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ), key, keylen ) == 0 )
-    {
-        return( 0 );
-    }
-
-    mbedtls_pk_free( pk );
-    mbedtls_pk_init( pk );
-#endif /* MBEDTLS_RSA_C */
-
-#if defined(MBEDTLS_ECP_C)
-    pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY );
-    if( mbedtls_pk_setup( pk, pk_info ) == 0 &&
-        pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ),
-                               key, keylen, f_rng, p_rng ) == 0 )
-    {
-        return( 0 );
-    }
-    mbedtls_pk_free( pk );
-#endif /* MBEDTLS_ECP_C */
-
-    /* If MBEDTLS_RSA_C is defined but MBEDTLS_ECP_C isn't,
-     * it is ok to leave the PK context initialized but not
-     * freed: It is the caller's responsibility to call pk_init()
-     * before calling this function, and to call pk_free()
-     * when it fails. If MBEDTLS_ECP_C is defined but MBEDTLS_RSA_C
-     * isn't, this leads to mbedtls_pk_free() being called
-     * twice, once here and once by the caller, but this is
-     * also ok and in line with the mbedtls_pk_free() calls
-     * on failed PEM parsing attempts. */
-
-    return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-}
-
-/*
- * Parse a public key
- */
-int mbedtls_pk_parse_public_key( mbedtls_pk_context *ctx,
-                         const unsigned char *key, size_t keylen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *p;
-#if defined(MBEDTLS_RSA_C)
-    const mbedtls_pk_info_t *pk_info;
-#endif
-#if defined(MBEDTLS_PEM_PARSE_C)
-    size_t len;
-    mbedtls_pem_context pem;
-#endif
-
-    PK_VALIDATE_RET( ctx != NULL );
-    if( keylen == 0 )
-        return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
-    PK_VALIDATE_RET( key != NULL || keylen == 0 );
-
-#if defined(MBEDTLS_PEM_PARSE_C)
-    mbedtls_pem_init( &pem );
-#if defined(MBEDTLS_RSA_C)
-    /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
-    if( key[keylen - 1] != '\0' )
-        ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
-    else
-        ret = mbedtls_pem_read_buffer( &pem,
-                               "-----BEGIN RSA PUBLIC KEY-----",
-                               "-----END RSA PUBLIC KEY-----",
-                               key, NULL, 0, &len );
-
-    if( ret == 0 )
-    {
-        p = pem.buf;
-        if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == NULL )
-            return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
-
-        if( ( ret = mbedtls_pk_setup( ctx, pk_info ) ) != 0 )
-            return( ret );
-
-        if ( ( ret = pk_get_rsapubkey( &p, p + pem.buflen, mbedtls_pk_rsa( *ctx ) ) ) != 0 )
-            mbedtls_pk_free( ctx );
-
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
-    {
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-#endif /* MBEDTLS_RSA_C */
-
-    /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
-    if( key[keylen - 1] != '\0' )
-        ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
-    else
-        ret = mbedtls_pem_read_buffer( &pem,
-                "-----BEGIN PUBLIC KEY-----",
-                "-----END PUBLIC KEY-----",
-                key, NULL, 0, &len );
-
-    if( ret == 0 )
-    {
-        /*
-         * Was PEM encoded
-         */
-        p = pem.buf;
-
-        ret = mbedtls_pk_parse_subpubkey( &p,  p + pem.buflen, ctx );
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
-    {
-        mbedtls_pem_free( &pem );
-        return( ret );
-    }
-    mbedtls_pem_free( &pem );
-#endif /* MBEDTLS_PEM_PARSE_C */
-
-#if defined(MBEDTLS_RSA_C)
-    if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == NULL )
-        return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
-
-    if( ( ret = mbedtls_pk_setup( ctx, pk_info ) ) != 0 )
-        return( ret );
-
-    p = (unsigned char *)key;
-    ret = pk_get_rsapubkey( &p, p + keylen, mbedtls_pk_rsa( *ctx ) );
-    if( ret == 0 )
-    {
-        return( ret );
-    }
-    mbedtls_pk_free( ctx );
-    if( ret != ( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_PK_INVALID_PUBKEY,
-                                    MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) ) )
-    {
-        return( ret );
-    }
-#endif /* MBEDTLS_RSA_C */
-    p = (unsigned char *) key;
-
-    ret = mbedtls_pk_parse_subpubkey( &p, p + keylen, ctx );
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_PK_PARSE_C */
diff --git a/src/duckdb/third_party/mbedtls/library/platform_util.cpp b/src/duckdb/third_party/mbedtls/library/platform_util.cpp
deleted file mode 100644
index 6d6f17d29..000000000
--- a/src/duckdb/third_party/mbedtls/library/platform_util.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Common and shared functions used by multiple modules in the Mbed TLS
- * library.
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-/*
- * Ensure gmtime_r is available even with -std=c99; must be defined before
- * mbedtls_config.h, which pulls in glibc's features.h. Harmless on other platforms.
- */
-#if !defined(_POSIX_C_SOURCE)
-#define _POSIX_C_SOURCE 200112L
-#endif
-
-#include "common.h"
-
-#include "mbedtls/platform_util.h"
-#include "mbedtls/platform.h"
-#ifdef MBEDTLS_THREADING_C
-#include "mbedtls/threading.h"
-#endif
-#include <stddef.h>
-#include <string.h>
-
-#if !defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
-/*
- * This implementation should never be optimized out by the compiler
- *
- * This implementation for mbedtls_platform_zeroize() was inspired from Colin
- * Percival's blog article at:
- *
- * http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html
- *
- * It uses a volatile function pointer to the standard memset(). Because the
- * pointer is volatile the compiler expects it to change at
- * any time and will not optimize out the call that could potentially perform
- * other operations on the input buffer instead of just setting it to 0.
- * Nevertheless, as pointed out by davidtgoldblatt on Hacker News
- * (refer to http://www.daemonology.net/blog/2014-09-05-erratum.html for
- * details), optimizations of the following form are still possible:
- *
- * if( memset_func != memset )
- *     memset_func( buf, 0, len );
- *
- * Note that it is extremely difficult to guarantee that
- * mbedtls_platform_zeroize() will not be optimized out by aggressive compilers
- * in a portable way. For this reason, Mbed TLS also provides the configuration
- * option MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
- * mbedtls_platform_zeroize() to use a suitable implementation for their
- * platform and needs.
- */
-static void * (* const volatile memset_func)( void *, int, size_t ) = memset;
-
-void mbedtls_platform_zeroize( void *buf, size_t len )
-{
-    MBEDTLS_INTERNAL_VALIDATE( len == 0 || buf != NULL );
-
-    if( len > 0 )
-        memset_func( buf, 0, len );
-}
-#endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
-
-#if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
-#include <time.h>
-#if !defined(_WIN32) && (defined(unix) || \
-    defined(__unix) || defined(__unix__) || (defined(__APPLE__) && \
-    defined(__MACH__)))
-#include <unistd.h>
-#endif /* !_WIN32 && (unix || __unix || __unix__ ||
-        * (__APPLE__ && __MACH__)) */
-
-#if !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) ||     \
-       ( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) &&                     \
-         _POSIX_THREAD_SAFE_FUNCTIONS >= 200112L ) )
-/*
- * This is a convenience shorthand macro to avoid checking the long
- * preprocessor conditions above. Ideally, we could expose this macro in
- * platform_util.h and simply use it in platform_util.c, threading.c and
- * threading.h. However, this macro is not part of the Mbed TLS public API, so
- * we keep it private by only defining it in this file
- */
-#if ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) )
-#define PLATFORM_UTIL_USE_GMTIME
-#endif /* ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) ) */
-
-#endif /* !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) ||     \
-             ( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) &&                     \
-                _POSIX_THREAD_SAFE_FUNCTIONS >= 200112L ) ) */
-
-struct tm *mbedtls_platform_gmtime_r( const mbedtls_time_t *tt,
-                                      struct tm *tm_buf )
-{
-#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
-    return( ( gmtime_s( tm_buf, tt ) == 0 ) ? tm_buf : NULL );
-#elif !defined(PLATFORM_UTIL_USE_GMTIME)
-    return( gmtime_r( tt, tm_buf ) );
-#else
-    struct tm *lt;
-
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_lock( &mbedtls_threading_gmtime_mutex ) != 0 )
-        return( NULL );
-#endif /* MBEDTLS_THREADING_C */
-
-    lt = gmtime( tt );
-
-    if( lt != NULL )
-    {
-        memcpy( tm_buf, lt, sizeof( struct tm ) );
-    }
-
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &mbedtls_threading_gmtime_mutex ) != 0 )
-        return( NULL );
-#endif /* MBEDTLS_THREADING_C */
-
-    return( ( lt == NULL ) ? NULL : tm_buf );
-#endif /* _WIN32 && !EFIX64 && !EFI32 */
-}
-#endif /* MBEDTLS_HAVE_TIME_DATE && MBEDTLS_PLATFORM_GMTIME_R_ALT */
-
-#if defined(MBEDTLS_TEST_HOOKS)
-void (*mbedtls_test_hook_test_fail)( const char *, int, const char *);
-#endif /* MBEDTLS_TEST_HOOKS */
-
diff --git a/src/duckdb/third_party/mbedtls/library/rsa.cpp b/src/duckdb/third_party/mbedtls/library/rsa.cpp
deleted file mode 100644
index 2f94c216b..000000000
--- a/src/duckdb/third_party/mbedtls/library/rsa.cpp
+++ /dev/null
@@ -1,2511 +0,0 @@
-/*
- *  The RSA public-key cryptosystem
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-
-/*
- *  The following sources were referenced in the design of this implementation
- *  of the RSA algorithm:
- *
- *  [1] A method for obtaining digital signatures and public-key cryptosystems
- *      R Rivest, A Shamir, and L Adleman
- *      http://people.csail.mit.edu/rivest/pubs.html#RSA78
- *
- *  [2] Handbook of Applied Cryptography - 1997, Chapter 8
- *      Menezes, van Oorschot and Vanstone
- *
- *  [3] Malware Guard Extension: Using SGX to Conceal Cache Attacks
- *      Michael Schwarz, Samuel Weiser, Daniel Gruss, Clémentine Maurice and
- *      Stefan Mangard
- *      https://arxiv.org/abs/1702.08719v2
- *
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_RSA_C)
-
-#include "mbedtls/rsa.h"
-#include "rsa_alt_helpers.h"
-#include "mbedtls/oid.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-#include "constant_time_internal.h"
-#include "mbedtls/constant_time.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_PKCS1_V21)
-#include "mbedtls/md.h"
-#endif
-
-#if defined(MBEDTLS_PKCS1_V15) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-#include <stdlib.h>
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#define mbedtls_printf printf
-#define mbedtls_calloc calloc
-#define mbedtls_free   free
-#endif
-
-#if !defined(MBEDTLS_RSA_ALT)
-
-/* Parameter validation macros */
-#define RSA_VALIDATE_RET( cond )                                       \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_RSA_BAD_INPUT_DATA )
-#define RSA_VALIDATE( cond )                                           \
-    MBEDTLS_INTERNAL_VALIDATE( cond )
-
-int mbedtls_rsa_import( mbedtls_rsa_context *ctx,
-                        const mbedtls_mpi *N,
-                        const mbedtls_mpi *P, const mbedtls_mpi *Q,
-                        const mbedtls_mpi *D, const mbedtls_mpi *E )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    if( ( N != NULL && ( ret = mbedtls_mpi_copy( &ctx->N, N ) ) != 0 ) ||
-        ( P != NULL && ( ret = mbedtls_mpi_copy( &ctx->P, P ) ) != 0 ) ||
-        ( Q != NULL && ( ret = mbedtls_mpi_copy( &ctx->Q, Q ) ) != 0 ) ||
-        ( D != NULL && ( ret = mbedtls_mpi_copy( &ctx->D, D ) ) != 0 ) ||
-        ( E != NULL && ( ret = mbedtls_mpi_copy( &ctx->E, E ) ) != 0 ) )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-    }
-
-    if( N != NULL )
-        ctx->len = mbedtls_mpi_size( &ctx->N );
-
-    return( 0 );
-}
-
-int mbedtls_rsa_import_raw( mbedtls_rsa_context *ctx,
-                            unsigned char const *N, size_t N_len,
-                            unsigned char const *P, size_t P_len,
-                            unsigned char const *Q, size_t Q_len,
-                            unsigned char const *D, size_t D_len,
-                            unsigned char const *E, size_t E_len )
-{
-    int ret = 0;
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    if( N != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->N, N, N_len ) );
-        ctx->len = mbedtls_mpi_size( &ctx->N );
-    }
-
-    if( P != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->P, P, P_len ) );
-
-    if( Q != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->Q, Q, Q_len ) );
-
-    if( D != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->D, D, D_len ) );
-
-    if( E != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->E, E, E_len ) );
-
-cleanup:
-
-    if( ret != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-
-    return( 0 );
-}
-
-/*
- * Checks whether the context fields are set in such a way
- * that the RSA primitives will be able to execute without error.
- * It does *not* make guarantees for consistency of the parameters.
- */
-static int rsa_check_context( mbedtls_rsa_context const *ctx, int is_priv,
-                              int blinding_needed )
-{
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    /* blinding_needed is only used for NO_CRT to decide whether
-     * P,Q need to be present or not. */
-    ((void) blinding_needed);
-#endif
-
-    if( ctx->len != mbedtls_mpi_size( &ctx->N ) ||
-        ctx->len > MBEDTLS_MPI_MAX_SIZE )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-
-    /*
-     * 1. Modular exponentiation needs positive, odd moduli.
-     */
-
-    /* Modular exponentiation wrt. N is always used for
-     * RSA public key operations. */
-    if( mbedtls_mpi_cmp_int( &ctx->N, 0 ) <= 0 ||
-        mbedtls_mpi_get_bit( &ctx->N, 0 ) == 0  )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    /* Modular exponentiation for P and Q is only
-     * used for private key operations and if CRT
-     * is used. */
-    if( is_priv &&
-        ( mbedtls_mpi_cmp_int( &ctx->P, 0 ) <= 0 ||
-          mbedtls_mpi_get_bit( &ctx->P, 0 ) == 0 ||
-          mbedtls_mpi_cmp_int( &ctx->Q, 0 ) <= 0 ||
-          mbedtls_mpi_get_bit( &ctx->Q, 0 ) == 0  ) )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-#endif /* !MBEDTLS_RSA_NO_CRT */
-
-    /*
-     * 2. Exponents must be positive
-     */
-
-    /* Always need E for public key operations */
-    if( mbedtls_mpi_cmp_int( &ctx->E, 0 ) <= 0 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-#if defined(MBEDTLS_RSA_NO_CRT)
-    /* For private key operations, use D or DP & DQ
-     * as (unblinded) exponents. */
-    if( is_priv && mbedtls_mpi_cmp_int( &ctx->D, 0 ) <= 0 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-#else
-    if( is_priv &&
-        ( mbedtls_mpi_cmp_int( &ctx->DP, 0 ) <= 0 ||
-          mbedtls_mpi_cmp_int( &ctx->DQ, 0 ) <= 0  ) )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-    /* Blinding shouldn't make exponents negative either,
-     * so check that P, Q >= 1 if that hasn't yet been
-     * done as part of 1. */
-#if defined(MBEDTLS_RSA_NO_CRT)
-    if( is_priv && blinding_needed &&
-        ( mbedtls_mpi_cmp_int( &ctx->P, 0 ) <= 0 ||
-          mbedtls_mpi_cmp_int( &ctx->Q, 0 ) <= 0 ) )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-#endif
-
-    /* It wouldn't lead to an error if it wasn't satisfied,
-     * but check for QP >= 1 nonetheless. */
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    if( is_priv &&
-        mbedtls_mpi_cmp_int( &ctx->QP, 0 ) <= 0 )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-#endif
-
-    return( 0 );
-}
-
-int mbedtls_rsa_complete( mbedtls_rsa_context *ctx )
-{
-    int ret = 0;
-    int have_N, have_P, have_Q, have_D, have_E;
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    int have_DP, have_DQ, have_QP;
-#endif
-    int n_missing, pq_missing, d_missing, is_pub, is_priv;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    have_N = ( mbedtls_mpi_cmp_int( &ctx->N, 0 ) != 0 );
-    have_P = ( mbedtls_mpi_cmp_int( &ctx->P, 0 ) != 0 );
-    have_Q = ( mbedtls_mpi_cmp_int( &ctx->Q, 0 ) != 0 );
-    have_D = ( mbedtls_mpi_cmp_int( &ctx->D, 0 ) != 0 );
-    have_E = ( mbedtls_mpi_cmp_int( &ctx->E, 0 ) != 0 );
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    have_DP = ( mbedtls_mpi_cmp_int( &ctx->DP, 0 ) != 0 );
-    have_DQ = ( mbedtls_mpi_cmp_int( &ctx->DQ, 0 ) != 0 );
-    have_QP = ( mbedtls_mpi_cmp_int( &ctx->QP, 0 ) != 0 );
-#endif
-
-    /*
-     * Check whether provided parameters are enough
-     * to deduce all others. The following incomplete
-     * parameter sets for private keys are supported:
-     *
-     * (1) P, Q missing.
-     * (2) D and potentially N missing.
-     *
-     */
-
-    n_missing  =              have_P &&  have_Q &&  have_D && have_E;
-    pq_missing =   have_N && !have_P && !have_Q &&  have_D && have_E;
-    d_missing  =              have_P &&  have_Q && !have_D && have_E;
-    is_pub     =   have_N && !have_P && !have_Q && !have_D && have_E;
-
-    /* These three alternatives are mutually exclusive */
-    is_priv = n_missing || pq_missing || d_missing;
-
-    if( !is_priv && !is_pub )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    /*
-     * Step 1: Deduce N if P, Q are provided.
-     */
-
-    if( !have_N && have_P && have_Q )
-    {
-        if( ( ret = mbedtls_mpi_mul_mpi( &ctx->N, &ctx->P,
-                                         &ctx->Q ) ) != 0 )
-        {
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-        }
-
-        ctx->len = mbedtls_mpi_size( &ctx->N );
-    }
-
-    /*
-     * Step 2: Deduce and verify all remaining core parameters.
-     */
-
-    if( pq_missing )
-    {
-        ret = mbedtls_rsa_deduce_primes( &ctx->N, &ctx->E, &ctx->D,
-                                         &ctx->P, &ctx->Q );
-        if( ret != 0 )
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-
-    }
-    else if( d_missing )
-    {
-        if( ( ret = mbedtls_rsa_deduce_private_exponent( &ctx->P,
-                                                         &ctx->Q,
-                                                         &ctx->E,
-                                                         &ctx->D ) ) != 0 )
-        {
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-        }
-    }
-
-    /*
-     * Step 3: Deduce all additional parameters specific
-     *         to our current RSA implementation.
-     */
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    if( is_priv && ! ( have_DP && have_DQ && have_QP ) )
-    {
-        ret = mbedtls_rsa_deduce_crt( &ctx->P,  &ctx->Q,  &ctx->D,
-                                      &ctx->DP, &ctx->DQ, &ctx->QP );
-        if( ret != 0 )
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-    }
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-    /*
-     * Step 3: Basic sanity checks
-     */
-
-    return( rsa_check_context( ctx, is_priv, 1 ) );
-}
-
-int mbedtls_rsa_export_raw( const mbedtls_rsa_context *ctx,
-                            unsigned char *N, size_t N_len,
-                            unsigned char *P, size_t P_len,
-                            unsigned char *Q, size_t Q_len,
-                            unsigned char *D, size_t D_len,
-                            unsigned char *E, size_t E_len )
-{
-    int ret = 0;
-    int is_priv;
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    /* Check if key is private or public */
-    is_priv =
-        mbedtls_mpi_cmp_int( &ctx->N, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->P, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->Q, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->D, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->E, 0 ) != 0;
-
-    if( !is_priv )
-    {
-        /* If we're trying to export private parameters for a public key,
-         * something must be wrong. */
-        if( P != NULL || Q != NULL || D != NULL )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    }
-
-    if( N != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->N, N, N_len ) );
-
-    if( P != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->P, P, P_len ) );
-
-    if( Q != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->Q, Q, Q_len ) );
-
-    if( D != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->D, D, D_len ) );
-
-    if( E != NULL )
-        MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->E, E, E_len ) );
-
-cleanup:
-
-    return( ret );
-}
-
-int mbedtls_rsa_export( const mbedtls_rsa_context *ctx,
-                        mbedtls_mpi *N, mbedtls_mpi *P, mbedtls_mpi *Q,
-                        mbedtls_mpi *D, mbedtls_mpi *E )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    int is_priv;
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    /* Check if key is private or public */
-    is_priv =
-        mbedtls_mpi_cmp_int( &ctx->N, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->P, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->Q, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->D, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->E, 0 ) != 0;
-
-    if( !is_priv )
-    {
-        /* If we're trying to export private parameters for a public key,
-         * something must be wrong. */
-        if( P != NULL || Q != NULL || D != NULL )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    }
-
-    /* Export all requested core parameters. */
-
-    if( ( N != NULL && ( ret = mbedtls_mpi_copy( N, &ctx->N ) ) != 0 ) ||
-        ( P != NULL && ( ret = mbedtls_mpi_copy( P, &ctx->P ) ) != 0 ) ||
-        ( Q != NULL && ( ret = mbedtls_mpi_copy( Q, &ctx->Q ) ) != 0 ) ||
-        ( D != NULL && ( ret = mbedtls_mpi_copy( D, &ctx->D ) ) != 0 ) ||
-        ( E != NULL && ( ret = mbedtls_mpi_copy( E, &ctx->E ) ) != 0 ) )
-    {
-        return( ret );
-    }
-
-    return( 0 );
-}
-
-/*
- * Export CRT parameters
- * This must also be implemented if CRT is not used, for being able to
- * write DER encoded RSA keys. The helper function mbedtls_rsa_deduce_crt
- * can be used in this case.
- */
-int mbedtls_rsa_export_crt( const mbedtls_rsa_context *ctx,
-                            mbedtls_mpi *DP, mbedtls_mpi *DQ, mbedtls_mpi *QP )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    int is_priv;
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    /* Check if key is private or public */
-    is_priv =
-        mbedtls_mpi_cmp_int( &ctx->N, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->P, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->Q, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->D, 0 ) != 0 &&
-        mbedtls_mpi_cmp_int( &ctx->E, 0 ) != 0;
-
-    if( !is_priv )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    /* Export all requested blinding parameters. */
-    if( ( DP != NULL && ( ret = mbedtls_mpi_copy( DP, &ctx->DP ) ) != 0 ) ||
-        ( DQ != NULL && ( ret = mbedtls_mpi_copy( DQ, &ctx->DQ ) ) != 0 ) ||
-        ( QP != NULL && ( ret = mbedtls_mpi_copy( QP, &ctx->QP ) ) != 0 ) )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-    }
-#else
-    if( ( ret = mbedtls_rsa_deduce_crt( &ctx->P, &ctx->Q, &ctx->D,
-                                        DP, DQ, QP ) ) != 0 )
-    {
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_BAD_INPUT_DATA, ret ) );
-    }
-#endif
-
-    return( 0 );
-}
-
-/*
- * Initialize an RSA context
- */
-void mbedtls_rsa_init( mbedtls_rsa_context *ctx )
-{
-    RSA_VALIDATE( ctx != NULL );
-
-    memset( ctx, 0, sizeof( mbedtls_rsa_context ) );
-
-    ctx->padding = MBEDTLS_RSA_PKCS_V15;
-    ctx->hash_id = MBEDTLS_MD_NONE;
-
-#if defined(MBEDTLS_THREADING_C)
-    /* Set ctx->ver to nonzero to indicate that the mutex has been
-     * initialized and will need to be freed. */
-    ctx->ver = 1;
-    mbedtls_mutex_init( &ctx->mutex );
-#endif
-}
-
-/*
- * Set padding for an existing RSA context
- */
-int mbedtls_rsa_set_padding( mbedtls_rsa_context *ctx, int padding,
-                             mbedtls_md_type_t hash_id )
-{
-    switch( padding )
-    {
-#if defined(MBEDTLS_PKCS1_V15)
-        case MBEDTLS_RSA_PKCS_V15:
-            break;
-#endif
-
-#if defined(MBEDTLS_PKCS1_V21)
-        case MBEDTLS_RSA_PKCS_V21:
-            break;
-#endif
-        default:
-            return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-    }
-
-    if( ( padding == MBEDTLS_RSA_PKCS_V21 ) &&
-        ( hash_id != MBEDTLS_MD_NONE ) )
-    {
-        const mbedtls_md_info_t *md_info;
-
-        md_info = mbedtls_md_info_from_type( hash_id );
-        if( md_info == NULL )
-            return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-    }
-
-    ctx->padding = padding;
-    ctx->hash_id = hash_id;
-
-    return( 0 );
-}
-
-/*
- * Get length in bytes of RSA modulus
- */
-
-size_t mbedtls_rsa_get_len( const mbedtls_rsa_context *ctx )
-{
-    return( ctx->len );
-}
-
-
-#if defined(MBEDTLS_GENPRIME)
-
-/*
- * Generate an RSA keypair
- *
- * This generation method follows the RSA key pair generation procedure of
- * FIPS 186-4 if 2^16 < exponent < 2^256 and nbits = 2048 or nbits = 3072.
- */
-int mbedtls_rsa_gen_key( mbedtls_rsa_context *ctx,
-                 int (*f_rng)(void *, unsigned char *, size_t),
-                 void *p_rng,
-                 unsigned int nbits, int exponent )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_mpi H, G, L;
-    int prime_quality = 0;
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( f_rng != NULL );
-
-    /*
-     * If the modulus is 1024 bit long or shorter, then the security strength of
-     * the RSA algorithm is less than or equal to 80 bits and therefore an error
-     * rate of 2^-80 is sufficient.
-     */
-    if( nbits > 1024 )
-        prime_quality = MBEDTLS_MPI_GEN_PRIME_FLAG_LOW_ERR;
-
-    mbedtls_mpi_init( &H );
-    mbedtls_mpi_init( &G );
-    mbedtls_mpi_init( &L );
-
-    if( nbits < 128 || exponent < 3 || nbits % 2 != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
-        goto cleanup;
-    }
-
-    /*
-     * find primes P and Q with Q < P so that:
-     * 1.  |P-Q| > 2^( nbits / 2 - 100 )
-     * 2.  GCD( E, (P-1)*(Q-1) ) == 1
-     * 3.  E^-1 mod LCM(P-1, Q-1) > 2^( nbits / 2 )
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &ctx->E, exponent ) );
-
-    do
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_gen_prime( &ctx->P, nbits >> 1,
-                                                prime_quality, f_rng, p_rng ) );
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_gen_prime( &ctx->Q, nbits >> 1,
-                                                prime_quality, f_rng, p_rng ) );
-
-        /* make sure the difference between p and q is not too small (FIPS 186-4 §B.3.3 step 5.4) */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &H, &ctx->P, &ctx->Q ) );
-        if( mbedtls_mpi_bitlen( &H ) <= ( ( nbits >= 200 ) ? ( ( nbits >> 1 ) - 99 ) : 0 ) )
-            continue;
-
-        /* not required by any standards, but some users rely on the fact that P > Q */
-        if( H.s < 0 )
-            mbedtls_mpi_swap( &ctx->P, &ctx->Q );
-
-        /* Temporarily replace P,Q by P-1, Q-1 */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &ctx->P, &ctx->P, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &ctx->Q, &ctx->Q, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &H, &ctx->P, &ctx->Q ) );
-
-        /* check GCD( E, (P-1)*(Q-1) ) == 1 (FIPS 186-4 §B.3.1 criterion 2(a)) */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, &ctx->E, &H  ) );
-        if( mbedtls_mpi_cmp_int( &G, 1 ) != 0 )
-            continue;
-
-        /* compute smallest possible D = E^-1 mod LCM(P-1, Q-1) (FIPS 186-4 §B.3.1 criterion 3(b)) */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, &ctx->P, &ctx->Q ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &L, NULL, &H, &G ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &ctx->D, &ctx->E, &L ) );
-
-        if( mbedtls_mpi_bitlen( &ctx->D ) <= ( ( nbits + 1 ) / 2 ) ) // (FIPS 186-4 §B.3.1 criterion 3(a))
-            continue;
-
-        break;
-    }
-    while( 1 );
-
-    /* Restore P,Q */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &ctx->P,  &ctx->P, 1 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &ctx->Q,  &ctx->Q, 1 ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->N, &ctx->P, &ctx->Q ) );
-
-    ctx->len = mbedtls_mpi_size( &ctx->N );
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    /*
-     * DP = D mod (P - 1)
-     * DQ = D mod (Q - 1)
-     * QP = Q^-1 mod P
-     */
-    MBEDTLS_MPI_CHK( mbedtls_rsa_deduce_crt( &ctx->P, &ctx->Q, &ctx->D,
-                                             &ctx->DP, &ctx->DQ, &ctx->QP ) );
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-    /* Double-check */
-    MBEDTLS_MPI_CHK( mbedtls_rsa_check_privkey( ctx ) );
-
-cleanup:
-
-    mbedtls_mpi_free( &H );
-    mbedtls_mpi_free( &G );
-    mbedtls_mpi_free( &L );
-
-    if( ret != 0 )
-    {
-        mbedtls_rsa_free( ctx );
-
-        if( ( -ret & ~0x7f ) == 0 )
-            ret = MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_KEY_GEN_FAILED, ret );
-        return( ret );
-    }
-
-    return( 0 );
-}
-
-#endif /* MBEDTLS_GENPRIME */
-
-/*
- * Check a public RSA key
- */
-int mbedtls_rsa_check_pubkey( const mbedtls_rsa_context *ctx )
-{
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    if( rsa_check_context( ctx, 0 /* public */, 0 /* no blinding */ ) != 0 )
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-
-    if( mbedtls_mpi_bitlen( &ctx->N ) < 128 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-    if( mbedtls_mpi_get_bit( &ctx->E, 0 ) == 0 ||
-        mbedtls_mpi_bitlen( &ctx->E )     < 2  ||
-        mbedtls_mpi_cmp_mpi( &ctx->E, &ctx->N ) >= 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-    return( 0 );
-}
-
-/*
- * Check for the consistency of all fields in an RSA private key context
- */
-int mbedtls_rsa_check_privkey( const mbedtls_rsa_context *ctx )
-{
-    RSA_VALIDATE_RET( ctx != NULL );
-
-    if( mbedtls_rsa_check_pubkey( ctx ) != 0 ||
-        rsa_check_context( ctx, 1 /* private */, 1 /* blinding */ ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-    if( mbedtls_rsa_validate_params( &ctx->N, &ctx->P, &ctx->Q,
-                                     &ctx->D, &ctx->E, NULL, NULL ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    else if( mbedtls_rsa_validate_crt( &ctx->P, &ctx->Q, &ctx->D,
-                                       &ctx->DP, &ctx->DQ, &ctx->QP ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-#endif
-
-    return( 0 );
-}
-
-/*
- * Check if contexts holding a public and private key match
- */
-int mbedtls_rsa_check_pub_priv( const mbedtls_rsa_context *pub,
-                                const mbedtls_rsa_context *prv )
-{
-    RSA_VALIDATE_RET( pub != NULL );
-    RSA_VALIDATE_RET( prv != NULL );
-
-    if( mbedtls_rsa_check_pubkey( pub )  != 0 ||
-        mbedtls_rsa_check_privkey( prv ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-    if( mbedtls_mpi_cmp_mpi( &pub->N, &prv->N ) != 0 ||
-        mbedtls_mpi_cmp_mpi( &pub->E, &prv->E ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
-    }
-
-    return( 0 );
-}
-
-/*
- * Do an RSA public key operation
- */
-int mbedtls_rsa_public( mbedtls_rsa_context *ctx,
-                const unsigned char *input,
-                unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t olen;
-    mbedtls_mpi T;
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( input != NULL );
-    RSA_VALIDATE_RET( output != NULL );
-
-    if( rsa_check_context( ctx, 0 /* public */, 0 /* no blinding */ ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    mbedtls_mpi_init( &T );
-
-#if defined(MBEDTLS_THREADING_C)
-    if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
-        return( ret );
-#endif
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &T, input, ctx->len ) );
-
-    if( mbedtls_mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
-    {
-        ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
-        goto cleanup;
-    }
-
-    olen = ctx->len;
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &T, output, olen ) );
-
-cleanup:
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
-        return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
-#endif
-
-    mbedtls_mpi_free( &T );
-
-    if( ret != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_PUBLIC_FAILED, ret ) );
-
-    return( 0 );
-}
-
-/*
- * Generate or update blinding values, see section 10 of:
- *  KOCHER, Paul C. Timing attacks on implementations of Diffie-Hellman, RSA,
- *  DSS, and other systems. In : Advances in Cryptology-CRYPTO'96. Springer
- *  Berlin Heidelberg, 1996. p. 104-113.
- */
-static int rsa_prepare_blinding( mbedtls_rsa_context *ctx,
-                 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
-{
-    int ret, count = 0;
-    mbedtls_mpi R;
-
-    mbedtls_mpi_init( &R );
-
-    if( ctx->Vf.p != NULL )
-    {
-        /* We already have blinding values, just update them by squaring */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &ctx->Vi ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->N ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vf, &ctx->Vf, &ctx->Vf ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vf, &ctx->Vf, &ctx->N ) );
-
-        goto cleanup;
-    }
-
-    /* Unblinding value: Vf = random number, invertible mod N */
-    do {
-        if( count++ > 10 )
-        {
-            ret = MBEDTLS_ERR_RSA_RNG_FAILED;
-            goto cleanup;
-        }
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &ctx->Vf, ctx->len - 1, f_rng, p_rng ) );
-
-        /* Compute Vf^-1 as R * (R Vf)^-1 to avoid leaks from inv_mod. */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &R, ctx->len - 1, f_rng, p_rng ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vi, &ctx->Vf, &R ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->N ) );
-
-        /* At this point, Vi is invertible mod N if and only if both Vf and R
-         * are invertible mod N. If one of them isn't, we don't need to know
-         * which one, we just loop and choose new values for both of them.
-         * (Each iteration succeeds with overwhelming probability.) */
-        ret = mbedtls_mpi_inv_mod( &ctx->Vi, &ctx->Vi, &ctx->N );
-        if( ret != 0 && ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
-            goto cleanup;
-
-    } while( ret == MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
-
-    /* Finish the computation of Vf^-1 = R * (R Vf)^-1 */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &R ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->N ) );
-
-    /* Blinding value: Vi = Vf^(-e) mod N
-     * (Vi already contains Vf^-1 at this point) */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->Vi, &ctx->Vi, &ctx->E, &ctx->N, &ctx->RN ) );
-
-
-cleanup:
-    mbedtls_mpi_free( &R );
-
-    return( ret );
-}
-
-/*
- * Exponent blinding supposed to prevent side-channel attacks using multiple
- * traces of measurements to recover the RSA key. The more collisions are there,
- * the more bits of the key can be recovered. See [3].
- *
- * Collecting n collisions with m bit long blinding value requires 2^(m-m/n)
- * observations on avarage.
- *
- * For example with 28 byte blinding to achieve 2 collisions the adversary has
- * to make 2^112 observations on avarage.
- *
- * (With the currently (as of 2017 April) known best algorithms breaking 2048
- * bit RSA requires approximately as much time as trying out 2^112 random keys.
- * Thus in this sense with 28 byte blinding the security is not reduced by
- * side-channel attacks like the one in [3])
- *
- * This countermeasure does not help if the key recovery is possible with a
- * single trace.
- */
-#define RSA_EXPONENT_BLINDING 28
-
-/*
- * Do an RSA private key operation
- */
-int mbedtls_rsa_private( mbedtls_rsa_context *ctx,
-                 int (*f_rng)(void *, unsigned char *, size_t),
-                 void *p_rng,
-                 const unsigned char *input,
-                 unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t olen;
-
-    /* Temporary holding the result */
-    mbedtls_mpi T;
-
-    /* Temporaries holding P-1, Q-1 and the
-     * exponent blinding factor, respectively. */
-    mbedtls_mpi P1, Q1, R;
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    /* Temporaries holding the results mod p resp. mod q. */
-    mbedtls_mpi TP, TQ;
-
-    /* Temporaries holding the blinded exponents for
-     * the mod p resp. mod q computation (if used). */
-    mbedtls_mpi DP_blind, DQ_blind;
-
-    /* Pointers to actual exponents to be used - either the unblinded
-     * or the blinded ones, depending on the presence of a PRNG. */
-    mbedtls_mpi *DP = &ctx->DP;
-    mbedtls_mpi *DQ = &ctx->DQ;
-#else
-    /* Temporary holding the blinded exponent (if used). */
-    mbedtls_mpi D_blind;
-
-    /* Pointer to actual exponent to be used - either the unblinded
-     * or the blinded one, depending on the presence of a PRNG. */
-    mbedtls_mpi *D = &ctx->D;
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-    /* Temporaries holding the initial input and the double
-     * checked result; should be the same in the end. */
-    mbedtls_mpi I, C;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( input  != NULL );
-    RSA_VALIDATE_RET( output != NULL );
-
-    if( f_rng == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    if( rsa_check_context( ctx, 1 /* private key checks */,
-                                1 /* blinding on        */ ) != 0 )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-
-#if defined(MBEDTLS_THREADING_C)
-    if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
-        return( ret );
-#endif
-
-    /* MPI Initialization */
-    mbedtls_mpi_init( &T );
-
-    mbedtls_mpi_init( &P1 );
-    mbedtls_mpi_init( &Q1 );
-    mbedtls_mpi_init( &R );
-
-#if defined(MBEDTLS_RSA_NO_CRT)
-    mbedtls_mpi_init( &D_blind );
-#else
-    mbedtls_mpi_init( &DP_blind );
-    mbedtls_mpi_init( &DQ_blind );
-#endif
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    mbedtls_mpi_init( &TP ); mbedtls_mpi_init( &TQ );
-#endif
-
-    mbedtls_mpi_init( &I );
-    mbedtls_mpi_init( &C );
-
-    /* End of MPI initialization */
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &T, input, ctx->len ) );
-    if( mbedtls_mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
-    {
-        ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
-        goto cleanup;
-    }
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &I, &T ) );
-
-    /*
-     * Blinding
-     * T = T * Vi mod N
-     */
-    MBEDTLS_MPI_CHK( rsa_prepare_blinding( ctx, f_rng, p_rng ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &T, &ctx->Vi ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &T, &T, &ctx->N ) );
-
-    /*
-     * Exponent blinding
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &P1, &ctx->P, 1 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &Q1, &ctx->Q, 1 ) );
-
-#if defined(MBEDTLS_RSA_NO_CRT)
-    /*
-     * D_blind = ( P - 1 ) * ( Q - 1 ) * R + D
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &R, RSA_EXPONENT_BLINDING,
-                     f_rng, p_rng ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &D_blind, &P1, &Q1 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &D_blind, &D_blind, &R ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &D_blind, &D_blind, &ctx->D ) );
-
-    D = &D_blind;
-#else
-    /*
-     * DP_blind = ( P - 1 ) * R + DP
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &R, RSA_EXPONENT_BLINDING,
-                     f_rng, p_rng ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &DP_blind, &P1, &R ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &DP_blind, &DP_blind,
-                &ctx->DP ) );
-
-    DP = &DP_blind;
-
-    /*
-     * DQ_blind = ( Q - 1 ) * R + DQ
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &R, RSA_EXPONENT_BLINDING,
-                     f_rng, p_rng ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &DQ_blind, &Q1, &R ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &DQ_blind, &DQ_blind,
-                &ctx->DQ ) );
-
-    DQ = &DQ_blind;
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-#if defined(MBEDTLS_RSA_NO_CRT)
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &T, &T, D, &ctx->N, &ctx->RN ) );
-#else
-    /*
-     * Faster decryption using the CRT
-     *
-     * TP = input ^ dP mod P
-     * TQ = input ^ dQ mod Q
-     */
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &TP, &T, DP, &ctx->P, &ctx->RP ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &TQ, &T, DQ, &ctx->Q, &ctx->RQ ) );
-
-    /*
-     * T = (TP - TQ) * (Q^-1 mod P) mod P
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T, &TP, &TQ ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &TP, &T, &ctx->QP ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &T, &TP, &ctx->P ) );
-
-    /*
-     * T = TQ + T * Q
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &TP, &T, &ctx->Q ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &T, &TQ, &TP ) );
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-    /*
-     * Unblind
-     * T = T * Vf mod N
-     */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &T, &ctx->Vf ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &T, &T, &ctx->N ) );
-
-    /* Verify the result to prevent glitching attacks. */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &C, &T, &ctx->E,
-                                          &ctx->N, &ctx->RN ) );
-    if( mbedtls_mpi_cmp_mpi( &C, &I ) != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_VERIFY_FAILED;
-        goto cleanup;
-    }
-
-    olen = ctx->len;
-    MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &T, output, olen ) );
-
-cleanup:
-#if defined(MBEDTLS_THREADING_C)
-    if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
-        return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
-#endif
-
-    mbedtls_mpi_free( &P1 );
-    mbedtls_mpi_free( &Q1 );
-    mbedtls_mpi_free( &R );
-
-#if defined(MBEDTLS_RSA_NO_CRT)
-    mbedtls_mpi_free( &D_blind );
-#else
-    mbedtls_mpi_free( &DP_blind );
-    mbedtls_mpi_free( &DQ_blind );
-#endif
-
-    mbedtls_mpi_free( &T );
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    mbedtls_mpi_free( &TP ); mbedtls_mpi_free( &TQ );
-#endif
-
-    mbedtls_mpi_free( &C );
-    mbedtls_mpi_free( &I );
-
-    if( ret != 0 && ret >= -0x007f )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_PRIVATE_FAILED, ret ) );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_PKCS1_V21)
-/**
- * Generate and apply the MGF1 operation (from PKCS#1 v2.1) to a buffer.
- *
- * \param dst       buffer to mask
- * \param dlen      length of destination buffer
- * \param src       source of the mask generation
- * \param slen      length of the source buffer
- * \param md_ctx    message digest context to use
- */
-static int mgf_mask( unsigned char *dst, size_t dlen, unsigned char *src,
-                      size_t slen, mbedtls_md_context_t *md_ctx )
-{
-    unsigned char mask[MBEDTLS_MD_MAX_SIZE];
-    unsigned char counter[4];
-    unsigned char *p;
-    unsigned int hlen;
-    size_t i, use_len;
-    int ret = 0;
-
-    memset( mask, 0, MBEDTLS_MD_MAX_SIZE );
-    memset( counter, 0, 4 );
-
-    hlen = mbedtls_md_get_size( md_ctx->md_info );
-
-    /* Generate and apply dbMask */
-    p = dst;
-
-    while( dlen > 0 )
-    {
-        use_len = hlen;
-        if( dlen < hlen )
-            use_len = dlen;
-
-        if( ( ret = mbedtls_md_starts( md_ctx ) ) != 0 )
-            goto exit;
-        if( ( ret = mbedtls_md_update( md_ctx, src, slen ) ) != 0 )
-            goto exit;
-        if( ( ret = mbedtls_md_update( md_ctx, counter, 4 ) ) != 0 )
-            goto exit;
-        if( ( ret = mbedtls_md_finish( md_ctx, mask ) ) != 0 )
-            goto exit;
-
-        for( i = 0; i < use_len; ++i )
-            *p++ ^= mask[i];
-
-        counter[3]++;
-
-        dlen -= use_len;
-    }
-
-exit:
-    mbedtls_platform_zeroize( mask, sizeof( mask ) );
-
-    return( ret );
-}
-#endif /* MBEDTLS_PKCS1_V21 */
-
-#if defined(MBEDTLS_PKCS1_V21)
-/*
- * Implementation of the PKCS#1 v2.1 RSAES-OAEP-ENCRYPT function
- */
-int mbedtls_rsa_rsaes_oaep_encrypt( mbedtls_rsa_context *ctx,
-                            int (*f_rng)(void *, unsigned char *, size_t),
-                            void *p_rng,
-                            const unsigned char *label, size_t label_len,
-                            size_t ilen,
-                            const unsigned char *input,
-                            unsigned char *output )
-{
-    size_t olen;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *p = output;
-    unsigned int hlen;
-    const mbedtls_md_info_t *md_info;
-    mbedtls_md_context_t md_ctx;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( output != NULL );
-    RSA_VALIDATE_RET( ilen == 0 || input != NULL );
-    RSA_VALIDATE_RET( label_len == 0 || label != NULL );
-
-    if( f_rng == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    olen = ctx->len;
-    hlen = mbedtls_md_get_size( md_info );
-
-    /* first comparison checks for overflow */
-    if( ilen + 2 * hlen + 2 < ilen || olen < ilen + 2 * hlen + 2 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    memset( output, 0, olen );
-
-    *p++ = 0;
-
-    /* Generate a random octet string seed */
-    if( ( ret = f_rng( p_rng, p, hlen ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_RNG_FAILED, ret ) );
-
-    p += hlen;
-
-    /* Construct DB */
-    if( ( ret = mbedtls_md( md_info, label, label_len, p ) ) != 0 )
-        return( ret );
-    p += hlen;
-    p += olen - 2 * hlen - 2 - ilen;
-    *p++ = 1;
-    if( ilen != 0 )
-        memcpy( p, input, ilen );
-
-    mbedtls_md_init( &md_ctx );
-    if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
-        goto exit;
-
-    /* maskedDB: Apply dbMask to DB */
-    if( ( ret = mgf_mask( output + hlen + 1, olen - hlen - 1, output + 1, hlen,
-                          &md_ctx ) ) != 0 )
-        goto exit;
-
-    /* maskedSeed: Apply seedMask to seed */
-    if( ( ret = mgf_mask( output + 1, hlen, output + hlen + 1, olen - hlen - 1,
-                          &md_ctx ) ) != 0 )
-        goto exit;
-
-exit:
-    mbedtls_md_free( &md_ctx );
-
-    if( ret != 0 )
-        return( ret );
-
-    return( mbedtls_rsa_public(  ctx, output, output ) );
-}
-#endif /* MBEDTLS_PKCS1_V21 */
-
-#if defined(MBEDTLS_PKCS1_V15)
-/*
- * Implementation of the PKCS#1 v2.1 RSAES-PKCS1-V1_5-ENCRYPT function
- */
-int mbedtls_rsa_rsaes_pkcs1_v15_encrypt( mbedtls_rsa_context *ctx,
-                                 int (*f_rng)(void *, unsigned char *, size_t),
-                                 void *p_rng, size_t ilen,
-                                 const unsigned char *input,
-                                 unsigned char *output )
-{
-    size_t nb_pad, olen;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *p = output;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( output != NULL );
-    RSA_VALIDATE_RET( ilen == 0 || input != NULL );
-
-    olen = ctx->len;
-
-    /* first comparison checks for overflow */
-    if( ilen + 11 < ilen || olen < ilen + 11 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    nb_pad = olen - 3 - ilen;
-
-    *p++ = 0;
-
-    if( f_rng == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    *p++ = MBEDTLS_RSA_CRYPT;
-
-    while( nb_pad-- > 0 )
-    {
-        int rng_dl = 100;
-
-        do {
-            ret = f_rng( p_rng, p, 1 );
-        } while( *p == 0 && --rng_dl && ret == 0 );
-
-        /* Check if RNG failed to generate data */
-        if( rng_dl == 0 || ret != 0 )
-            return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_RNG_FAILED, ret ) );
-
-        p++;
-    }
-
-    *p++ = 0;
-    if( ilen != 0 )
-        memcpy( p, input, ilen );
-
-    return( mbedtls_rsa_public(  ctx, output, output ) );
-}
-#endif /* MBEDTLS_PKCS1_V15 */
-
-/*
- * Add the message padding, then do an RSA operation
- */
-int mbedtls_rsa_pkcs1_encrypt( mbedtls_rsa_context *ctx,
-                       int (*f_rng)(void *, unsigned char *, size_t),
-                       void *p_rng,
-                       size_t ilen,
-                       const unsigned char *input,
-                       unsigned char *output )
-{
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( output != NULL );
-    RSA_VALIDATE_RET( ilen == 0 || input != NULL );
-
-    switch( ctx->padding )
-    {
-#if defined(MBEDTLS_PKCS1_V15)
-        case MBEDTLS_RSA_PKCS_V15:
-            return mbedtls_rsa_rsaes_pkcs1_v15_encrypt( ctx, f_rng, p_rng,
-                                                        ilen, input, output );
-#endif
-
-#if defined(MBEDTLS_PKCS1_V21)
-        case MBEDTLS_RSA_PKCS_V21:
-            return mbedtls_rsa_rsaes_oaep_encrypt( ctx, f_rng, p_rng, NULL, 0,
-                                                   ilen, input, output );
-#endif
-
-        default:
-            return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-    }
-}
-
-#if defined(MBEDTLS_PKCS1_V21)
-/*
- * Implementation of the PKCS#1 v2.1 RSAES-OAEP-DECRYPT function
- */
-int mbedtls_rsa_rsaes_oaep_decrypt( mbedtls_rsa_context *ctx,
-                            int (*f_rng)(void *, unsigned char *, size_t),
-                            void *p_rng,
-                            const unsigned char *label, size_t label_len,
-                            size_t *olen,
-                            const unsigned char *input,
-                            unsigned char *output,
-                            size_t output_max_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t ilen, i, pad_len;
-    unsigned char *p, bad, pad_done;
-    unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
-    unsigned char lhash[MBEDTLS_MD_MAX_SIZE];
-    unsigned int hlen;
-    const mbedtls_md_info_t *md_info;
-    mbedtls_md_context_t md_ctx;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( output_max_len == 0 || output != NULL );
-    RSA_VALIDATE_RET( label_len == 0 || label != NULL );
-    RSA_VALIDATE_RET( input != NULL );
-    RSA_VALIDATE_RET( olen != NULL );
-
-    /*
-     * Parameters sanity checks
-     */
-    if( ctx->padding != MBEDTLS_RSA_PKCS_V21 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    ilen = ctx->len;
-
-    if( ilen < 16 || ilen > sizeof( buf ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    hlen = mbedtls_md_get_size( md_info );
-
-    // checking for integer underflow
-    if( 2 * hlen + 2 > ilen )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    /*
-     * RSA operation
-     */
-    ret = mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
-
-    if( ret != 0 )
-        goto cleanup;
-
-    /*
-     * Unmask data and generate lHash
-     */
-    mbedtls_md_init( &md_ctx );
-    if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
-    {
-        mbedtls_md_free( &md_ctx );
-        goto cleanup;
-    }
-
-    /* seed: Apply seedMask to maskedSeed */
-    if( ( ret = mgf_mask( buf + 1, hlen, buf + hlen + 1, ilen - hlen - 1,
-                          &md_ctx ) ) != 0 ||
-    /* DB: Apply dbMask to maskedDB */
-        ( ret = mgf_mask( buf + hlen + 1, ilen - hlen - 1, buf + 1, hlen,
-                          &md_ctx ) ) != 0 )
-    {
-        mbedtls_md_free( &md_ctx );
-        goto cleanup;
-    }
-
-    mbedtls_md_free( &md_ctx );
-
-    /* Generate lHash */
-    if( ( ret = mbedtls_md( md_info, label, label_len, lhash ) ) != 0 )
-        goto cleanup;
-
-    /*
-     * Check contents, in "constant-time"
-     */
-    p = buf;
-    bad = 0;
-
-    bad |= *p++; /* First byte must be 0 */
-
-    p += hlen; /* Skip seed */
-
-    /* Check lHash */
-    for( i = 0; i < hlen; i++ )
-        bad |= lhash[i] ^ *p++;
-
-    /* Get zero-padding len, but always read till end of buffer
-     * (minus one, for the 01 byte) */
-    pad_len = 0;
-    pad_done = 0;
-    for( i = 0; i < ilen - 2 * hlen - 2; i++ )
-    {
-        pad_done |= p[i];
-        pad_len += ((pad_done | (unsigned char)-pad_done) >> 7) ^ 1;
-    }
-
-    p += pad_len;
-    bad |= *p++ ^ 0x01;
-
-    /*
-     * The only information "leaked" is whether the padding was correct or not
-     * (eg, no data is copied if it was not correct). This meets the
-     * recommendations in PKCS#1 v2.2: an opponent cannot distinguish between
-     * the different error conditions.
-     */
-    if( bad != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_INVALID_PADDING;
-        goto cleanup;
-    }
-
-    if( ilen - ( p - buf ) > output_max_len )
-    {
-        ret = MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
-        goto cleanup;
-    }
-
-    *olen = ilen - (p - buf);
-    if( *olen != 0 )
-        memcpy( output, p, *olen );
-    ret = 0;
-
-cleanup:
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-    mbedtls_platform_zeroize( lhash, sizeof( lhash ) );
-
-    return( ret );
-}
-#endif /* MBEDTLS_PKCS1_V21 */
-
-#if defined(MBEDTLS_PKCS1_V15)
-/*
- * Implementation of the PKCS#1 v2.1 RSAES-PKCS1-V1_5-DECRYPT function
- */
-int mbedtls_rsa_rsaes_pkcs1_v15_decrypt( mbedtls_rsa_context *ctx,
-                                 int (*f_rng)(void *, unsigned char *, size_t),
-                                 void *p_rng,
-                                 size_t *olen,
-                                 const unsigned char *input,
-                                 unsigned char *output,
-                                 size_t output_max_len )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t ilen;
-    unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( output_max_len == 0 || output != NULL );
-    RSA_VALIDATE_RET( input != NULL );
-    RSA_VALIDATE_RET( olen != NULL );
-
-    ilen = ctx->len;
-
-    if( ctx->padding != MBEDTLS_RSA_PKCS_V15 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    if( ilen < 16 || ilen > sizeof( buf ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    ret = mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
-
-    if( ret != 0 )
-        goto cleanup;
-
-    ret = mbedtls_ct_rsaes_pkcs1_v15_unpadding( buf, ilen,
-                                                output, output_max_len, olen );
-
-cleanup:
-    mbedtls_platform_zeroize( buf, sizeof( buf ) );
-
-    return( ret );
-}
-#endif /* MBEDTLS_PKCS1_V15 */
-
-/*
- * Do an RSA operation, then remove the message padding
- */
-int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
-                       int (*f_rng)(void *, unsigned char *, size_t),
-                       void *p_rng,
-                       size_t *olen,
-                       const unsigned char *input,
-                       unsigned char *output,
-                       size_t output_max_len)
-{
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( output_max_len == 0 || output != NULL );
-    RSA_VALIDATE_RET( input != NULL );
-    RSA_VALIDATE_RET( olen != NULL );
-
-    switch( ctx->padding )
-    {
-#if defined(MBEDTLS_PKCS1_V15)
-        case MBEDTLS_RSA_PKCS_V15:
-            return mbedtls_rsa_rsaes_pkcs1_v15_decrypt( ctx, f_rng, p_rng, olen,
-                                                input, output, output_max_len );
-#endif
-
-#if defined(MBEDTLS_PKCS1_V21)
-        case MBEDTLS_RSA_PKCS_V21:
-            return mbedtls_rsa_rsaes_oaep_decrypt( ctx, f_rng, p_rng, NULL, 0,
-                                           olen, input, output,
-                                           output_max_len );
-#endif
-
-        default:
-            return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-    }
-}
-
-#if defined(MBEDTLS_PKCS1_V21)
-static int rsa_rsassa_pss_sign( mbedtls_rsa_context *ctx,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng,
-                         mbedtls_md_type_t md_alg,
-                         unsigned int hashlen,
-                         const unsigned char *hash,
-                         int saltlen,
-                         unsigned char *sig )
-{
-    size_t olen;
-    unsigned char *p = sig;
-    unsigned char *salt = NULL;
-    size_t slen, min_slen, hlen, offset = 0;
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t msb;
-    const mbedtls_md_info_t *md_info;
-    mbedtls_md_context_t md_ctx;
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-
-    if( ctx->padding != MBEDTLS_RSA_PKCS_V21 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    if( f_rng == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    olen = ctx->len;
-
-    if( md_alg != MBEDTLS_MD_NONE )
-    {
-        /* Gather length of hash to sign */
-        md_info = mbedtls_md_info_from_type( md_alg );
-        if( md_info == NULL )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        if( hashlen != mbedtls_md_get_size( md_info ) )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-
-    md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    hlen = mbedtls_md_get_size( md_info );
-
-    if (saltlen == MBEDTLS_RSA_SALT_LEN_ANY)
-    {
-       /* Calculate the largest possible salt length, up to the hash size.
-        * Normally this is the hash length, which is the maximum salt length
-        * according to FIPS 185-4 §5.5 (e) and common practice. If there is not
-        * enough room, use the maximum salt length that fits. The constraint is
-        * that the hash length plus the salt length plus 2 bytes must be at most
-        * the key length. This complies with FIPS 186-4 §5.5 (e) and RFC 8017
-        * (PKCS#1 v2.2) §9.1.1 step 3. */
-        min_slen = hlen - 2;
-        if( olen < hlen + min_slen + 2 )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-        else if( olen >= hlen + hlen + 2 )
-            slen = hlen;
-        else
-            slen = olen - hlen - 2;
-    }
-    else if ( (saltlen < 0) || (saltlen + hlen + 2 > olen) )
-    {
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-    else
-    {
-        slen = (size_t) saltlen;
-    }
-
-    memset( sig, 0, olen );
-
-    /* Note: EMSA-PSS encoding is over the length of N - 1 bits */
-    msb = mbedtls_mpi_bitlen( &ctx->N ) - 1;
-    p += olen - hlen - slen - 2;
-    *p++ = 0x01;
-
-    /* Generate salt of length slen in place in the encoded message */
-    salt = p;
-    if( ( ret = f_rng( p_rng, salt, slen ) ) != 0 )
-        return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_RSA_RNG_FAILED, ret ) );
-
-    p += slen;
-
-    mbedtls_md_init( &md_ctx );
-    if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
-        goto exit;
-
-    /* Generate H = Hash( M' ) */
-    if( ( ret = mbedtls_md_starts( &md_ctx ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md_update( &md_ctx, p, 8 ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md_update( &md_ctx, hash, hashlen ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md_update( &md_ctx, salt, slen ) ) != 0 )
-        goto exit;
-    if( ( ret = mbedtls_md_finish( &md_ctx, p ) ) != 0 )
-        goto exit;
-
-    /* Compensate for boundary condition when applying mask */
-    if( msb % 8 == 0 )
-        offset = 1;
-
-    /* maskedDB: Apply dbMask to DB */
-    if( ( ret = mgf_mask( sig + offset, olen - hlen - 1 - offset, p, hlen,
-                          &md_ctx ) ) != 0 )
-        goto exit;
-
-    msb = mbedtls_mpi_bitlen( &ctx->N ) - 1;
-    sig[0] &= 0xFF >> ( olen * 8 - msb );
-
-    p += hlen;
-    *p++ = 0xBC;
-
-exit:
-    mbedtls_md_free( &md_ctx );
-
-    if( ret != 0 )
-        return( ret );
-
-    return mbedtls_rsa_private( ctx, f_rng, p_rng, sig, sig );
-}
-
-/*
- * Implementation of the PKCS#1 v2.1 RSASSA-PSS-SIGN function with
- * the option to pass in the salt length.
- */
-int mbedtls_rsa_rsassa_pss_sign_ext( mbedtls_rsa_context *ctx,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng,
-                         mbedtls_md_type_t md_alg,
-                         unsigned int hashlen,
-                         const unsigned char *hash,
-                         int saltlen,
-                         unsigned char *sig )
-{
-    return rsa_rsassa_pss_sign( ctx, f_rng, p_rng, md_alg,
-                                hashlen, hash, saltlen, sig );
-}
-
-
-/*
- * Implementation of the PKCS#1 v2.1 RSASSA-PSS-SIGN function
- */
-int mbedtls_rsa_rsassa_pss_sign( mbedtls_rsa_context *ctx,
-                         int (*f_rng)(void *, unsigned char *, size_t),
-                         void *p_rng,
-                         mbedtls_md_type_t md_alg,
-                         unsigned int hashlen,
-                         const unsigned char *hash,
-                         unsigned char *sig )
-{
-    return rsa_rsassa_pss_sign( ctx, f_rng, p_rng, md_alg,
-                                hashlen, hash, MBEDTLS_RSA_SALT_LEN_ANY, sig );
-}
-#endif /* MBEDTLS_PKCS1_V21 */
-
-#if defined(MBEDTLS_PKCS1_V15)
-/*
- * Implementation of the PKCS#1 v2.1 RSASSA-PKCS1-V1_5-SIGN function
- */
-
-/* Construct a PKCS v1.5 encoding of a hashed message
- *
- * This is used both for signature generation and verification.
- *
- * Parameters:
- * - md_alg:  Identifies the hash algorithm used to generate the given hash;
- *            MBEDTLS_MD_NONE if raw data is signed.
- * - hashlen: Length of hash. Must match md_alg if that's not NONE.
- * - hash:    Buffer containing the hashed message or the raw data.
- * - dst_len: Length of the encoded message.
- * - dst:     Buffer to hold the encoded message.
- *
- * Assumptions:
- * - hash has size hashlen.
- * - dst points to a buffer of size at least dst_len.
- *
- */
-static int rsa_rsassa_pkcs1_v15_encode( mbedtls_md_type_t md_alg,
-                                        unsigned int hashlen,
-                                        const unsigned char *hash,
-                                        size_t dst_len,
-                                        unsigned char *dst )
-{
-    size_t oid_size  = 0;
-    size_t nb_pad    = dst_len;
-    unsigned char *p = dst;
-    const char *oid  = NULL;
-
-    /* Are we signing hashed or raw data? */
-    if( md_alg != MBEDTLS_MD_NONE )
-    {
-        const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_alg );
-        if( md_info == NULL )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        if( mbedtls_oid_get_oid_by_md( md_alg, &oid, &oid_size ) != 0 )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        if( hashlen != mbedtls_md_get_size( md_info ) )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        /* Double-check that 8 + hashlen + oid_size can be used as a
-         * 1-byte ASN.1 length encoding and that there's no overflow. */
-        if( 8 + hashlen + oid_size  >= 0x80         ||
-            10 + hashlen            <  hashlen      ||
-            10 + hashlen + oid_size <  10 + hashlen )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        /*
-         * Static bounds check:
-         * - Need 10 bytes for five tag-length pairs.
-         *   (Insist on 1-byte length encodings to protect against variants of
-         *    Bleichenbacher's forgery attack against lax PKCS#1v1.5 verification)
-         * - Need hashlen bytes for hash
-         * - Need oid_size bytes for hash alg OID.
-         */
-        if( nb_pad < 10 + hashlen + oid_size )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-        nb_pad -= 10 + hashlen + oid_size;
-    }
-    else
-    {
-        if( nb_pad < hashlen )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        nb_pad -= hashlen;
-    }
-
-    /* Need space for signature header and padding delimiter (3 bytes),
-     * and 8 bytes for the minimal padding */
-    if( nb_pad < 3 + 8 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    nb_pad -= 3;
-
-    /* Now nb_pad is the amount of memory to be filled
-     * with padding, and at least 8 bytes long. */
-
-    /* Write signature header and padding */
-    *p++ = 0;
-    *p++ = MBEDTLS_RSA_SIGN;
-    memset( p, 0xFF, nb_pad );
-    p += nb_pad;
-    *p++ = 0;
-
-    /* Are we signing raw data? */
-    if( md_alg == MBEDTLS_MD_NONE )
-    {
-        memcpy( p, hash, hashlen );
-        return( 0 );
-    }
-
-    /* Signing hashed data, add corresponding ASN.1 structure
-     *
-     * DigestInfo ::= SEQUENCE {
-     *   digestAlgorithm DigestAlgorithmIdentifier,
-     *   digest Digest }
-     * DigestAlgorithmIdentifier ::= AlgorithmIdentifier
-     * Digest ::= OCTET STRING
-     *
-     * Schematic:
-     * TAG-SEQ + LEN [ TAG-SEQ + LEN [ TAG-OID  + LEN [ OID  ]
-     *                                 TAG-NULL + LEN [ NULL ] ]
-     *                 TAG-OCTET + LEN [ HASH ] ]
-     */
-    *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
-    *p++ = (unsigned char)( 0x08 + oid_size + hashlen );
-    *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
-    *p++ = (unsigned char)( 0x04 + oid_size );
-    *p++ = MBEDTLS_ASN1_OID;
-    *p++ = (unsigned char) oid_size;
-    memcpy( p, oid, oid_size );
-    p += oid_size;
-    *p++ = MBEDTLS_ASN1_NULL;
-    *p++ = 0x00;
-    *p++ = MBEDTLS_ASN1_OCTET_STRING;
-    *p++ = (unsigned char) hashlen;
-    memcpy( p, hash, hashlen );
-    p += hashlen;
-
-    /* Just a sanity-check, should be automatic
-     * after the initial bounds check. */
-    if( p != dst + dst_len )
-    {
-        mbedtls_platform_zeroize( dst, dst_len );
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-
-    return( 0 );
-}
-
-/*
- * Do an RSA operation to sign the message digest
- */
-int mbedtls_rsa_rsassa_pkcs1_v15_sign( mbedtls_rsa_context *ctx,
-                               int (*f_rng)(void *, unsigned char *, size_t),
-                               void *p_rng,
-                               mbedtls_md_type_t md_alg,
-                               unsigned int hashlen,
-                               const unsigned char *hash,
-                               unsigned char *sig )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned char *sig_try = NULL, *verif = NULL;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-
-    if( ctx->padding != MBEDTLS_RSA_PKCS_V15 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    /*
-     * Prepare PKCS1-v1.5 encoding (padding and hash identifier)
-     */
-
-    if( ( ret = rsa_rsassa_pkcs1_v15_encode( md_alg, hashlen, hash,
-                                             ctx->len, sig ) ) != 0 )
-        return( ret );
-
-    /* Private key operation
-     *
-     * In order to prevent Lenstra's attack, make the signature in a
-     * temporary buffer and check it before returning it.
-     */
-
-    sig_try = (unsigned char *) mbedtls_calloc( 1, ctx->len );
-    if( sig_try == NULL )
-        return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
-
-    verif = (unsigned char *) mbedtls_calloc( 1, ctx->len );
-    if( verif == NULL )
-    {
-        mbedtls_free( sig_try );
-        return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
-    }
-
-    MBEDTLS_MPI_CHK( mbedtls_rsa_private( ctx, f_rng, p_rng, sig, sig_try ) );
-    MBEDTLS_MPI_CHK( mbedtls_rsa_public( ctx, sig_try, verif ) );
-
-    if( mbedtls_ct_memcmp( verif, sig, ctx->len ) != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_PRIVATE_FAILED;
-        goto cleanup;
-    }
-
-    memcpy( sig, sig_try, ctx->len );
-
-cleanup:
-    mbedtls_platform_zeroize( sig_try, ctx->len );
-    mbedtls_platform_zeroize( verif, ctx->len );
-    mbedtls_free( sig_try );
-    mbedtls_free( verif );
-
-    if( ret != 0 )
-        memset( sig, '!', ctx->len );
-    return( ret );
-}
-#endif /* MBEDTLS_PKCS1_V15 */
-
-/*
- * Do an RSA operation to sign the message digest
- */
-int mbedtls_rsa_pkcs1_sign( mbedtls_rsa_context *ctx,
-                    int (*f_rng)(void *, unsigned char *, size_t),
-                    void *p_rng,
-                    mbedtls_md_type_t md_alg,
-                    unsigned int hashlen,
-                    const unsigned char *hash,
-                    unsigned char *sig )
-{
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-
-    switch( ctx->padding )
-    {
-#if defined(MBEDTLS_PKCS1_V15)
-        case MBEDTLS_RSA_PKCS_V15:
-            return mbedtls_rsa_rsassa_pkcs1_v15_sign( ctx, f_rng, p_rng,
-                                                      md_alg, hashlen, hash, sig );
-#endif
-
-#if defined(MBEDTLS_PKCS1_V21)
-        case MBEDTLS_RSA_PKCS_V21:
-            return mbedtls_rsa_rsassa_pss_sign( ctx, f_rng, p_rng, md_alg,
-                                                hashlen, hash, sig );
-#endif
-
-        default:
-            return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-    }
-}
-
-#if defined(MBEDTLS_PKCS1_V21)
-/*
- * Implementation of the PKCS#1 v2.1 RSASSA-PSS-VERIFY function
- */
-int mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_rsa_context *ctx,
-                               mbedtls_md_type_t md_alg,
-                               unsigned int hashlen,
-                               const unsigned char *hash,
-                               mbedtls_md_type_t mgf1_hash_id,
-                               int expected_salt_len,
-                               const unsigned char *sig )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t siglen;
-    unsigned char *p;
-    unsigned char *hash_start;
-    unsigned char result[MBEDTLS_MD_MAX_SIZE];
-    unsigned char zeros[8];
-    unsigned int hlen;
-    size_t observed_salt_len, msb;
-    const mbedtls_md_info_t *md_info;
-    mbedtls_md_context_t md_ctx;
-    unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-
-    siglen = ctx->len;
-
-    if( siglen < 16 || siglen > sizeof( buf ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    ret = mbedtls_rsa_public(  ctx, sig, buf );
-
-    if( ret != 0 )
-        return( ret );
-
-    p = buf;
-
-    if( buf[siglen - 1] != 0xBC )
-        return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-
-    if( md_alg != MBEDTLS_MD_NONE )
-    {
-        /* Gather length of hash to sign */
-        md_info = mbedtls_md_info_from_type( md_alg );
-        if( md_info == NULL )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-        if( hashlen != mbedtls_md_get_size( md_info ) )
-            return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    }
-
-    md_info = mbedtls_md_info_from_type( mgf1_hash_id );
-    if( md_info == NULL )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    hlen = mbedtls_md_get_size( md_info );
-
-    memset( zeros, 0, 8 );
-
-    /*
-     * Note: EMSA-PSS verification is over the length of N - 1 bits
-     */
-    msb = mbedtls_mpi_bitlen( &ctx->N ) - 1;
-
-    if( buf[0] >> ( 8 - siglen * 8 + msb ) )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-
-    /* Compensate for boundary condition when applying mask */
-    if( msb % 8 == 0 )
-    {
-        p++;
-        siglen -= 1;
-    }
-
-    if( siglen < hlen + 2 )
-        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
-    hash_start = p + siglen - hlen - 1;
-
-    mbedtls_md_init( &md_ctx );
-    if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
-        goto exit;
-
-    ret = mgf_mask( p, siglen - hlen - 1, hash_start, hlen, &md_ctx );
-    if( ret != 0 )
-        goto exit;
-
-    buf[0] &= 0xFF >> ( siglen * 8 - msb );
-
-    while( p < hash_start - 1 && *p == 0 )
-        p++;
-
-    if( *p++ != 0x01 )
-    {
-        ret = MBEDTLS_ERR_RSA_INVALID_PADDING;
-        goto exit;
-    }
-
-    observed_salt_len = hash_start - p;
-
-    if( expected_salt_len != MBEDTLS_RSA_SALT_LEN_ANY &&
-        observed_salt_len != (size_t) expected_salt_len )
-    {
-        ret = MBEDTLS_ERR_RSA_INVALID_PADDING;
-        goto exit;
-    }
-
-    /*
-     * Generate H = Hash( M' )
-     */
-    ret = mbedtls_md_starts( &md_ctx );
-    if ( ret != 0 )
-        goto exit;
-    ret = mbedtls_md_update( &md_ctx, zeros, 8 );
-    if ( ret != 0 )
-        goto exit;
-    ret = mbedtls_md_update( &md_ctx, hash, hashlen );
-    if ( ret != 0 )
-        goto exit;
-    ret = mbedtls_md_update( &md_ctx, p, observed_salt_len );
-    if ( ret != 0 )
-        goto exit;
-    ret = mbedtls_md_finish( &md_ctx, result );
-    if ( ret != 0 )
-        goto exit;
-
-    if( memcmp( hash_start, result, hlen ) != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_VERIFY_FAILED;
-        goto exit;
-    }
-
-exit:
-    mbedtls_md_free( &md_ctx );
-
-    return( ret );
-}
-
-/*
- * Simplified PKCS#1 v2.1 RSASSA-PSS-VERIFY function
- */
-int mbedtls_rsa_rsassa_pss_verify( mbedtls_rsa_context *ctx,
-                           mbedtls_md_type_t md_alg,
-                           unsigned int hashlen,
-                           const unsigned char *hash,
-                           const unsigned char *sig )
-{
-    mbedtls_md_type_t mgf1_hash_id;
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-
-    mgf1_hash_id = ( ctx->hash_id != MBEDTLS_MD_NONE )
-                             ? (mbedtls_md_type_t) ctx->hash_id
-                             : md_alg;
-
-    return( mbedtls_rsa_rsassa_pss_verify_ext( ctx,
-                                               md_alg, hashlen, hash,
-                                               mgf1_hash_id,
-                                               MBEDTLS_RSA_SALT_LEN_ANY,
-                                               sig ) );
-
-}
-#endif /* MBEDTLS_PKCS1_V21 */
-
-#if defined(MBEDTLS_PKCS1_V15)
-/*
- * Implementation of the PKCS#1 v2.1 RSASSA-PKCS1-v1_5-VERIFY function
- */
-int mbedtls_rsa_rsassa_pkcs1_v15_verify( mbedtls_rsa_context *ctx,
-                                 mbedtls_md_type_t md_alg,
-                                 unsigned int hashlen,
-                                 const unsigned char *hash,
-                                 const unsigned char *sig )
-{
-    int ret = 0;
-    size_t sig_len;
-    unsigned char *encoded = NULL, *encoded_expected = NULL;
-
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-
-    sig_len = ctx->len;
-
-    /*
-     * Prepare expected PKCS1 v1.5 encoding of hash.
-     */
-
-    if( ( encoded          = (unsigned char *) mbedtls_calloc( 1, sig_len ) ) == NULL ||
-        ( encoded_expected = (unsigned char *) mbedtls_calloc( 1, sig_len ) ) == NULL )
-    {
-        ret = MBEDTLS_ERR_MPI_ALLOC_FAILED;
-        goto cleanup;
-    }
-
-    if( ( ret = rsa_rsassa_pkcs1_v15_encode( md_alg, hashlen, hash, sig_len,
-                                             encoded_expected ) ) != 0 )
-        goto cleanup;
-
-    /*
-     * Apply RSA primitive to get what should be PKCS1 encoded hash.
-     */
-
-    ret = mbedtls_rsa_public( ctx, sig, encoded );
-    if( ret != 0 )
-        goto cleanup;
-
-    /*
-     * Compare
-     */
-
-    if( ( ret = mbedtls_ct_memcmp( encoded, encoded_expected,
-                                              sig_len ) ) != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_VERIFY_FAILED;
-        goto cleanup;
-    }
-
-cleanup:
-
-    if( encoded != NULL )
-    {
-        mbedtls_platform_zeroize( encoded, sig_len );
-        mbedtls_free( encoded );
-    }
-
-    if( encoded_expected != NULL )
-    {
-        mbedtls_platform_zeroize( encoded_expected, sig_len );
-        mbedtls_free( encoded_expected );
-    }
-
-    return( ret );
-}
-#endif /* MBEDTLS_PKCS1_V15 */
-
-/*
- * Do an RSA operation and check the message digest
- */
-int mbedtls_rsa_pkcs1_verify( mbedtls_rsa_context *ctx,
-                      mbedtls_md_type_t md_alg,
-                      unsigned int hashlen,
-                      const unsigned char *hash,
-                      const unsigned char *sig )
-{
-    RSA_VALIDATE_RET( ctx != NULL );
-    RSA_VALIDATE_RET( sig != NULL );
-    RSA_VALIDATE_RET( ( md_alg  == MBEDTLS_MD_NONE &&
-                        hashlen == 0 ) ||
-                      hash != NULL );
-
-    switch( ctx->padding )
-    {
-#if defined(MBEDTLS_PKCS1_V15)
-        case MBEDTLS_RSA_PKCS_V15:
-            return mbedtls_rsa_rsassa_pkcs1_v15_verify( ctx, md_alg,
-                                                        hashlen, hash, sig );
-#endif
-
-#if defined(MBEDTLS_PKCS1_V21)
-        case MBEDTLS_RSA_PKCS_V21:
-            return mbedtls_rsa_rsassa_pss_verify( ctx, md_alg,
-                                                  hashlen, hash, sig );
-#endif
-
-        default:
-            return( MBEDTLS_ERR_RSA_INVALID_PADDING );
-    }
-}
-
-/*
- * Copy the components of an RSA key
- */
-int mbedtls_rsa_copy( mbedtls_rsa_context *dst, const mbedtls_rsa_context *src )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    RSA_VALIDATE_RET( dst != NULL );
-    RSA_VALIDATE_RET( src != NULL );
-
-    dst->len = src->len;
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->N, &src->N ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->E, &src->E ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->D, &src->D ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->P, &src->P ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->Q, &src->Q ) );
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->DP, &src->DP ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->DQ, &src->DQ ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->QP, &src->QP ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->RP, &src->RP ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->RQ, &src->RQ ) );
-#endif
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->RN, &src->RN ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->Vi, &src->Vi ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->Vf, &src->Vf ) );
-
-    dst->padding = src->padding;
-    dst->hash_id = src->hash_id;
-
-cleanup:
-    if( ret != 0 )
-        mbedtls_rsa_free( dst );
-
-    return( ret );
-}
-
-/*
- * Free the components of an RSA key
- */
-void mbedtls_rsa_free( mbedtls_rsa_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    mbedtls_mpi_free( &ctx->Vi );
-    mbedtls_mpi_free( &ctx->Vf );
-    mbedtls_mpi_free( &ctx->RN );
-    mbedtls_mpi_free( &ctx->D  );
-    mbedtls_mpi_free( &ctx->Q  );
-    mbedtls_mpi_free( &ctx->P  );
-    mbedtls_mpi_free( &ctx->E  );
-    mbedtls_mpi_free( &ctx->N  );
-
-#if !defined(MBEDTLS_RSA_NO_CRT)
-    mbedtls_mpi_free( &ctx->RQ );
-    mbedtls_mpi_free( &ctx->RP );
-    mbedtls_mpi_free( &ctx->QP );
-    mbedtls_mpi_free( &ctx->DQ );
-    mbedtls_mpi_free( &ctx->DP );
-#endif /* MBEDTLS_RSA_NO_CRT */
-
-#if defined(MBEDTLS_THREADING_C)
-    /* Free the mutex, but only if it hasn't been freed already. */
-    if( ctx->ver != 0 )
-    {
-        mbedtls_mutex_free( &ctx->mutex );
-        ctx->ver = 0;
-    }
-#endif
-}
-
-#endif /* !MBEDTLS_RSA_ALT */
-
-#if defined(MBEDTLS_SELF_TEST)
-
-#include "mbedtls/sha1.h"
-
-/*
- * Example RSA-1024 keypair, for test purposes
- */
-#define KEY_LEN 128
-
-#define RSA_N   "9292758453063D803DD603D5E777D788" \
-                "8ED1D5BF35786190FA2F23EBC0848AEA" \
-                "DDA92CA6C3D80B32C4D109BE0F36D6AE" \
-                "7130B9CED7ACDF54CFC7555AC14EEBAB" \
-                "93A89813FBF3C4F8066D2D800F7C38A8" \
-                "1AE31942917403FF4946B0A83D3D3E05" \
-                "EE57C6F5F5606FB5D4BC6CD34EE0801A" \
-                "5E94BB77B07507233A0BC7BAC8F90F79"
-
-#define RSA_E   "10001"
-
-#define RSA_D   "24BF6185468786FDD303083D25E64EFC" \
-                "66CA472BC44D253102F8B4A9D3BFA750" \
-                "91386C0077937FE33FA3252D28855837" \
-                "AE1B484A8A9A45F7EE8C0C634F99E8CD" \
-                "DF79C5CE07EE72C7F123142198164234" \
-                "CABB724CF78B8173B9F880FC86322407" \
-                "AF1FEDFDDE2BEB674CA15F3E81A1521E" \
-                "071513A1E85B5DFA031F21ECAE91A34D"
-
-#define RSA_P   "C36D0EB7FCD285223CFB5AABA5BDA3D8" \
-                "2C01CAD19EA484A87EA4377637E75500" \
-                "FCB2005C5C7DD6EC4AC023CDA285D796" \
-                "C3D9E75E1EFC42488BB4F1D13AC30A57"
-
-#define RSA_Q   "C000DF51A7C77AE8D7C7370C1FF55B69" \
-                "E211C2B9E5DB1ED0BF61D0D9899620F4" \
-                "910E4168387E3C30AA1E00C339A79508" \
-                "8452DD96A9A5EA5D9DCA68DA636032AF"
-
-#define PT_LEN  24
-#define RSA_PT  "\xAA\xBB\xCC\x03\x02\x01\x00\xFF\xFF\xFF\xFF\xFF" \
-                "\x11\x22\x33\x0A\x0B\x0C\xCC\xDD\xDD\xDD\xDD\xDD"
-
-#if defined(MBEDTLS_PKCS1_V15)
-static int myrand( void *rng_state, unsigned char *output, size_t len )
-{
-#if !defined(__OpenBSD__) && !defined(__NetBSD__)
-    size_t i;
-
-    if( rng_state != NULL )
-        rng_state  = NULL;
-
-    for( i = 0; i < len; ++i )
-        output[i] = rand();
-#else
-    if( rng_state != NULL )
-        rng_state = NULL;
-
-    arc4random_buf( output, len );
-#endif /* !OpenBSD && !NetBSD */
-
-    return( 0 );
-}
-#endif /* MBEDTLS_PKCS1_V15 */
-
-/*
- * Checkup routine
- */
-int mbedtls_rsa_self_test( int verbose )
-{
-    int ret = 0;
-#if defined(MBEDTLS_PKCS1_V15)
-    size_t len;
-    mbedtls_rsa_context rsa;
-    unsigned char rsa_plaintext[PT_LEN];
-    unsigned char rsa_decrypted[PT_LEN];
-    unsigned char rsa_ciphertext[KEY_LEN];
-#if defined(MBEDTLS_SHA1_C)
-    unsigned char sha1sum[20];
-#endif
-
-    mbedtls_mpi K;
-
-    mbedtls_mpi_init( &K );
-    mbedtls_rsa_init( &rsa );
-
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &K, 16, RSA_N  ) );
-    MBEDTLS_MPI_CHK( mbedtls_rsa_import( &rsa, &K, NULL, NULL, NULL, NULL ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &K, 16, RSA_P  ) );
-    MBEDTLS_MPI_CHK( mbedtls_rsa_import( &rsa, NULL, &K, NULL, NULL, NULL ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &K, 16, RSA_Q  ) );
-    MBEDTLS_MPI_CHK( mbedtls_rsa_import( &rsa, NULL, NULL, &K, NULL, NULL ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &K, 16, RSA_D  ) );
-    MBEDTLS_MPI_CHK( mbedtls_rsa_import( &rsa, NULL, NULL, NULL, &K, NULL ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &K, 16, RSA_E  ) );
-    MBEDTLS_MPI_CHK( mbedtls_rsa_import( &rsa, NULL, NULL, NULL, NULL, &K ) );
-
-    MBEDTLS_MPI_CHK( mbedtls_rsa_complete( &rsa ) );
-
-    if( verbose != 0 )
-        mbedtls_printf( "  RSA key validation: " );
-
-    if( mbedtls_rsa_check_pubkey(  &rsa ) != 0 ||
-        mbedtls_rsa_check_privkey( &rsa ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n  PKCS#1 encryption : " );
-
-    memcpy( rsa_plaintext, RSA_PT, PT_LEN );
-
-    if( mbedtls_rsa_pkcs1_encrypt( &rsa, myrand, NULL,
-                                   PT_LEN, rsa_plaintext,
-                                   rsa_ciphertext ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n  PKCS#1 decryption : " );
-
-    if( mbedtls_rsa_pkcs1_decrypt( &rsa, myrand, NULL,
-                                   &len, rsa_ciphertext, rsa_decrypted,
-                                   sizeof(rsa_decrypted) ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( memcmp( rsa_decrypted, rsa_plaintext, len ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-
-#if defined(MBEDTLS_SHA1_C)
-    if( verbose != 0 )
-        mbedtls_printf( "  PKCS#1 data sign  : " );
-
-    if( mbedtls_sha1( rsa_plaintext, PT_LEN, sha1sum ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        return( 1 );
-    }
-
-    if( mbedtls_rsa_pkcs1_sign( &rsa, myrand, NULL,
-                                MBEDTLS_MD_SHA1, 20,
-                                sha1sum, rsa_ciphertext ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n  PKCS#1 sig. verify: " );
-
-    if( mbedtls_rsa_pkcs1_verify( &rsa, MBEDTLS_MD_SHA1, 20,
-                                  sha1sum, rsa_ciphertext ) != 0 )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "failed\n" );
-
-        ret = 1;
-        goto cleanup;
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "passed\n" );
-#endif /* MBEDTLS_SHA1_C */
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-cleanup:
-    mbedtls_mpi_free( &K );
-    mbedtls_rsa_free( &rsa );
-#else /* MBEDTLS_PKCS1_V15 */
-    ((void) verbose);
-#endif /* MBEDTLS_PKCS1_V15 */
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_RSA_C */
diff --git a/src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.cpp b/src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.cpp
deleted file mode 100644
index dff2d9345..000000000
--- a/src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.cpp
+++ /dev/null
@@ -1,486 +0,0 @@
-/*
- *  Helper functions for the RSA module
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- *
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_RSA_C)
-
-#include "mbedtls/rsa.h"
-#include "mbedtls/bignum.h"
-#include "rsa_alt_helpers.h"
-
-/*
- * Compute RSA prime factors from public and private exponents
- *
- * Summary of algorithm:
- * Setting F := lcm(P-1,Q-1), the idea is as follows:
- *
- * (a) For any 1 <= X < N with gcd(X,N)=1, we have X^F = 1 modulo N, so X^(F/2)
- *     is a square root of 1 in Z/NZ. Since Z/NZ ~= Z/PZ x Z/QZ by CRT and the
- *     square roots of 1 in Z/PZ and Z/QZ are +1 and -1, this leaves the four
- *     possibilities X^(F/2) = (+-1, +-1). If it happens that X^(F/2) = (-1,+1)
- *     or (+1,-1), then gcd(X^(F/2) + 1, N) will be equal to one of the prime
- *     factors of N.
- *
- * (b) If we don't know F/2 but (F/2) * K for some odd (!) K, then the same
- *     construction still applies since (-)^K is the identity on the set of
- *     roots of 1 in Z/NZ.
- *
- * The public and private key primitives (-)^E and (-)^D are mutually inverse
- * bijections on Z/NZ if and only if (-)^(DE) is the identity on Z/NZ, i.e.
- * if and only if DE - 1 is a multiple of F, say DE - 1 = F * L.
- * Splitting L = 2^t * K with K odd, we have
- *
- *   DE - 1 = FL = (F/2) * (2^(t+1)) * K,
- *
- * so (F / 2) * K is among the numbers
- *
- *   (DE - 1) >> 1, (DE - 1) >> 2, ..., (DE - 1) >> ord
- *
- * where ord is the order of 2 in (DE - 1).
- * We can therefore iterate through these numbers apply the construction
- * of (a) and (b) above to attempt to factor N.
- *
- */
-int mbedtls_rsa_deduce_primes( mbedtls_mpi const *N,
-                     mbedtls_mpi const *E, mbedtls_mpi const *D,
-                     mbedtls_mpi *P, mbedtls_mpi *Q )
-{
-    int ret = 0;
-
-    uint16_t attempt;  /* Number of current attempt  */
-    uint16_t iter;     /* Number of squares computed in the current attempt */
-
-    uint16_t order;    /* Order of 2 in DE - 1 */
-
-    mbedtls_mpi T;  /* Holds largest odd divisor of DE - 1     */
-    mbedtls_mpi K;  /* Temporary holding the current candidate */
-
-    const unsigned char primes[] = { 2,
-           3,    5,    7,   11,   13,   17,   19,   23,
-          29,   31,   37,   41,   43,   47,   53,   59,
-          61,   67,   71,   73,   79,   83,   89,   97,
-         101,  103,  107,  109,  113,  127,  131,  137,
-         139,  149,  151,  157,  163,  167,  173,  179,
-         181,  191,  193,  197,  199,  211,  223,  227,
-         229,  233,  239,  241,  251
-    };
-
-    const size_t num_primes = sizeof( primes ) / sizeof( *primes );
-
-    if( P == NULL || Q == NULL || P->p != NULL || Q->p != NULL )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    if( mbedtls_mpi_cmp_int( N, 0 ) <= 0 ||
-        mbedtls_mpi_cmp_int( D, 1 ) <= 0 ||
-        mbedtls_mpi_cmp_mpi( D, N ) >= 0 ||
-        mbedtls_mpi_cmp_int( E, 1 ) <= 0 ||
-        mbedtls_mpi_cmp_mpi( E, N ) >= 0 )
-    {
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-    }
-
-    /*
-     * Initializations and temporary changes
-     */
-
-    mbedtls_mpi_init( &K );
-    mbedtls_mpi_init( &T );
-
-    /* T := DE - 1 */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, D,  E ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &T, &T, 1 ) );
-
-    if( ( order = (uint16_t) mbedtls_mpi_lsb( &T ) ) == 0 )
-    {
-        ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
-        goto cleanup;
-    }
-
-    /* After this operation, T holds the largest odd divisor of DE - 1. */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &T, order ) );
-
-    /*
-     * Actual work
-     */
-
-    /* Skip trying 2 if N == 1 mod 8 */
-    attempt = 0;
-    if( N->p[0] % 8 == 1 )
-        attempt = 1;
-
-    for( ; attempt < num_primes; ++attempt )
-    {
-        mbedtls_mpi_lset( &K, primes[attempt] );
-
-        /* Check if gcd(K,N) = 1 */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( P, &K, N ) );
-        if( mbedtls_mpi_cmp_int( P, 1 ) != 0 )
-            continue;
-
-        /* Go through K^T + 1, K^(2T) + 1, K^(4T) + 1, ...
-         * and check whether they have nontrivial GCD with N. */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &K, &K, &T, N,
-                             Q /* temporarily use Q for storing Montgomery
-                                * multiplication helper values */ ) );
-
-        for( iter = 1; iter <= order; ++iter )
-        {
-            /* If we reach 1 prematurely, there's no point
-             * in continuing to square K */
-            if( mbedtls_mpi_cmp_int( &K, 1 ) == 0 )
-                break;
-
-            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &K, &K, 1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( P, &K, N ) );
-
-            if( mbedtls_mpi_cmp_int( P, 1 ) ==  1 &&
-                mbedtls_mpi_cmp_mpi( P, N ) == -1 )
-            {
-                /*
-                 * Have found a nontrivial divisor P of N.
-                 * Set Q := N / P.
-                 */
-
-                MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( Q, NULL, N, P ) );
-                goto cleanup;
-            }
-
-            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, &K, 1 ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &K, &K, &K ) );
-            MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &K, &K, N ) );
-        }
-
-        /*
-         * If we get here, then either we prematurely aborted the loop because
-         * we reached 1, or K holds primes[attempt]^(DE - 1) mod N, which must
-         * be 1 if D,E,N were consistent.
-         * Check if that's the case and abort if not, to avoid very long,
-         * yet eventually failing, computations if N,D,E were not sane.
-         */
-        if( mbedtls_mpi_cmp_int( &K, 1 ) != 0 )
-        {
-            break;
-        }
-    }
-
-    ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
-
-cleanup:
-
-    mbedtls_mpi_free( &K );
-    mbedtls_mpi_free( &T );
-    return( ret );
-}
-
-/*
- * Given P, Q and the public exponent E, deduce D.
- * This is essentially a modular inversion.
- */
-int mbedtls_rsa_deduce_private_exponent( mbedtls_mpi const *P,
-                                         mbedtls_mpi const *Q,
-                                         mbedtls_mpi const *E,
-                                         mbedtls_mpi *D )
-{
-    int ret = 0;
-    mbedtls_mpi K, L;
-
-    if( D == NULL || mbedtls_mpi_cmp_int( D, 0 ) != 0 )
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-
-    if( mbedtls_mpi_cmp_int( P, 1 ) <= 0 ||
-        mbedtls_mpi_cmp_int( Q, 1 ) <= 0 ||
-        mbedtls_mpi_cmp_int( E, 0 ) == 0 )
-    {
-        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
-    }
-
-    mbedtls_mpi_init( &K );
-    mbedtls_mpi_init( &L );
-
-    /* Temporarily put K := P-1 and L := Q-1 */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, P, 1 ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &L, Q, 1 ) );
-
-    /* Temporarily put D := gcd(P-1, Q-1) */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( D, &K, &L ) );
-
-    /* K := LCM(P-1, Q-1) */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &K, &K, &L ) );
-    MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &K, NULL, &K, D ) );
-
-    /* Compute modular inverse of E in LCM(P-1, Q-1) */
-    MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( D, E, &K ) );
-
-cleanup:
-
-    mbedtls_mpi_free( &K );
-    mbedtls_mpi_free( &L );
-
-    return( ret );
-}
-
-int mbedtls_rsa_deduce_crt( const mbedtls_mpi *P, const mbedtls_mpi *Q,
-                            const mbedtls_mpi *D, mbedtls_mpi *DP,
-                            mbedtls_mpi *DQ, mbedtls_mpi *QP )
-{
-    int ret = 0;
-    mbedtls_mpi K;
-    mbedtls_mpi_init( &K );
-
-    /* DP = D mod P-1 */
-    if( DP != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, P, 1  ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( DP, D, &K ) );
-    }
-
-    /* DQ = D mod Q-1 */
-    if( DQ != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, Q, 1  ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( DQ, D, &K ) );
-    }
-
-    /* QP = Q^{-1} mod P */
-    if( QP != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( QP, Q, P ) );
-    }
-
-cleanup:
-    mbedtls_mpi_free( &K );
-
-    return( ret );
-}
-
-/*
- * Check that core RSA parameters are sane.
- */
-int mbedtls_rsa_validate_params( const mbedtls_mpi *N, const mbedtls_mpi *P,
-                                 const mbedtls_mpi *Q, const mbedtls_mpi *D,
-                                 const mbedtls_mpi *E,
-                                 int (*f_rng)(void *, unsigned char *, size_t),
-                                 void *p_rng )
-{
-    int ret = 0;
-    mbedtls_mpi K, L;
-
-    mbedtls_mpi_init( &K );
-    mbedtls_mpi_init( &L );
-
-    /*
-     * Step 1: If PRNG provided, check that P and Q are prime
-     */
-
-#if defined(MBEDTLS_GENPRIME)
-    /*
-     * When generating keys, the strongest security we support aims for an error
-     * rate of at most 2^-100 and we are aiming for the same certainty here as
-     * well.
-     */
-    if( f_rng != NULL && P != NULL &&
-        ( ret = mbedtls_mpi_is_prime_ext( P, 50, f_rng, p_rng ) ) != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-        goto cleanup;
-    }
-
-    if( f_rng != NULL && Q != NULL &&
-        ( ret = mbedtls_mpi_is_prime_ext( Q, 50, f_rng, p_rng ) ) != 0 )
-    {
-        ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-        goto cleanup;
-    }
-#else
-    ((void) f_rng);
-    ((void) p_rng);
-#endif /* MBEDTLS_GENPRIME */
-
-    /*
-     * Step 2: Check that 1 < N = P * Q
-     */
-
-    if( P != NULL && Q != NULL && N != NULL )
-    {
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &K, P, Q ) );
-        if( mbedtls_mpi_cmp_int( N, 1 )  <= 0 ||
-            mbedtls_mpi_cmp_mpi( &K, N ) != 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-    }
-
-    /*
-     * Step 3: Check and 1 < D, E < N if present.
-     */
-
-    if( N != NULL && D != NULL && E != NULL )
-    {
-        if ( mbedtls_mpi_cmp_int( D, 1 ) <= 0 ||
-             mbedtls_mpi_cmp_int( E, 1 ) <= 0 ||
-             mbedtls_mpi_cmp_mpi( D, N ) >= 0 ||
-             mbedtls_mpi_cmp_mpi( E, N ) >= 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-    }
-
-    /*
-     * Step 4: Check that D, E are inverse modulo P-1 and Q-1
-     */
-
-    if( P != NULL && Q != NULL && D != NULL && E != NULL )
-    {
-        if( mbedtls_mpi_cmp_int( P, 1 ) <= 0 ||
-            mbedtls_mpi_cmp_int( Q, 1 ) <= 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-
-        /* Compute DE-1 mod P-1 */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &K, D, E ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, &K, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &L, P, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &K, &K, &L ) );
-        if( mbedtls_mpi_cmp_int( &K, 0 ) != 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-
-        /* Compute DE-1 mod Q-1 */
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &K, D, E ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, &K, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &L, Q, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &K, &K, &L ) );
-        if( mbedtls_mpi_cmp_int( &K, 0 ) != 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-    }
-
-cleanup:
-
-    mbedtls_mpi_free( &K );
-    mbedtls_mpi_free( &L );
-
-    /* Wrap MPI error codes by RSA check failure error code */
-    if( ret != 0 && ret != MBEDTLS_ERR_RSA_KEY_CHECK_FAILED )
-    {
-        ret += MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-    }
-
-    return( ret );
-}
-
-/*
- * Check that RSA CRT parameters are in accordance with core parameters.
- */
-int mbedtls_rsa_validate_crt( const mbedtls_mpi *P,  const mbedtls_mpi *Q,
-                              const mbedtls_mpi *D,  const mbedtls_mpi *DP,
-                              const mbedtls_mpi *DQ, const mbedtls_mpi *QP )
-{
-    int ret = 0;
-
-    mbedtls_mpi K, L;
-    mbedtls_mpi_init( &K );
-    mbedtls_mpi_init( &L );
-
-    /* Check that DP - D == 0 mod P - 1 */
-    if( DP != NULL )
-    {
-        if( P == NULL )
-        {
-            ret = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
-            goto cleanup;
-        }
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, P, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &L, DP, D ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &L, &L, &K ) );
-
-        if( mbedtls_mpi_cmp_int( &L, 0 ) != 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-    }
-
-    /* Check that DQ - D == 0 mod Q - 1 */
-    if( DQ != NULL )
-    {
-        if( Q == NULL )
-        {
-            ret = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
-            goto cleanup;
-        }
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, Q, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &L, DQ, D ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &L, &L, &K ) );
-
-        if( mbedtls_mpi_cmp_int( &L, 0 ) != 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-    }
-
-    /* Check that QP * Q - 1 == 0 mod P */
-    if( QP != NULL )
-    {
-        if( P == NULL || Q == NULL )
-        {
-            ret = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
-            goto cleanup;
-        }
-
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &K, QP, Q ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &K, &K, 1 ) );
-        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &K, &K, P ) );
-        if( mbedtls_mpi_cmp_int( &K, 0 ) != 0 )
-        {
-            ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-            goto cleanup;
-        }
-    }
-
-cleanup:
-
-    /* Wrap MPI error codes by RSA check failure error code */
-    if( ret != 0 &&
-        ret != MBEDTLS_ERR_RSA_KEY_CHECK_FAILED &&
-        ret != MBEDTLS_ERR_RSA_BAD_INPUT_DATA )
-    {
-        ret += MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
-    }
-
-    mbedtls_mpi_free( &K );
-    mbedtls_mpi_free( &L );
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_RSA_C */
diff --git a/src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.h b/src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.h
deleted file mode 100644
index d6fc8e592..000000000
--- a/src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/**
- * \file rsa_alt_helpers.h
- *
- * \brief Context-independent RSA helper functions
- *
- *  This module declares some RSA-related helper functions useful when
- *  implementing the RSA interface. These functions are provided in a separate
- *  compilation unit in order to make it easy for designers of alternative RSA
- *  implementations to use them in their own code, as it is conceived that the
- *  functionality they provide will be necessary for most complete
- *  implementations.
- *
- *  End-users of Mbed TLS who are not providing their own alternative RSA
- *  implementations should not use these functions directly, and should instead
- *  use only the functions declared in rsa.h.
- *
- *  The interface provided by this module will be maintained through LTS (Long
- *  Term Support) branches of Mbed TLS, but may otherwise be subject to change,
- *  and must be considered an internal interface of the library.
- *
- *  There are two classes of helper functions:
- *
- *  (1) Parameter-generating helpers. These are:
- *      - mbedtls_rsa_deduce_primes
- *      - mbedtls_rsa_deduce_private_exponent
- *      - mbedtls_rsa_deduce_crt
- *       Each of these functions takes a set of core RSA parameters and
- *       generates some other, or CRT related parameters.
- *
- *  (2) Parameter-checking helpers. These are:
- *      - mbedtls_rsa_validate_params
- *      - mbedtls_rsa_validate_crt
- *      They take a set of core or CRT related RSA parameters and check their
- *      validity.
- *
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- *
- */
-
-#ifndef MBEDTLS_RSA_INTERNAL_H
-#define MBEDTLS_RSA_INTERNAL_H
-
-#include "mbedtls/build_info.h"
-
-#include "mbedtls/bignum.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * \brief          Compute RSA prime moduli P, Q from public modulus N=PQ
- *                 and a pair of private and public key.
- *
- * \note           This is a 'static' helper function not operating on
- *                 an RSA context. Alternative implementations need not
- *                 overwrite it.
- *
- * \param N        RSA modulus N = PQ, with P, Q to be found
- * \param E        RSA public exponent
- * \param D        RSA private exponent
- * \param P        Pointer to MPI holding first prime factor of N on success
- * \param Q        Pointer to MPI holding second prime factor of N on success
- *
- * \return
- *                 - 0 if successful. In this case, P and Q constitute a
- *                   factorization of N.
- *                 - A non-zero error code otherwise.
- *
- * \note           It is neither checked that P, Q are prime nor that
- *                 D, E are modular inverses wrt. P-1 and Q-1. For that,
- *                 use the helper function \c mbedtls_rsa_validate_params.
- *
- */
-int mbedtls_rsa_deduce_primes( mbedtls_mpi const *N, mbedtls_mpi const *E,
-                               mbedtls_mpi const *D,
-                               mbedtls_mpi *P, mbedtls_mpi *Q );
-
-/**
- * \brief          Compute RSA private exponent from
- *                 prime moduli and public key.
- *
- * \note           This is a 'static' helper function not operating on
- *                 an RSA context. Alternative implementations need not
- *                 overwrite it.
- *
- * \param P        First prime factor of RSA modulus
- * \param Q        Second prime factor of RSA modulus
- * \param E        RSA public exponent
- * \param D        Pointer to MPI holding the private exponent on success.
- *
- * \return
- *                 - 0 if successful. In this case, D is set to a simultaneous
- *                   modular inverse of E modulo both P-1 and Q-1.
- *                 - A non-zero error code otherwise.
- *
- * \note           This function does not check whether P and Q are primes.
- *
- */
-int mbedtls_rsa_deduce_private_exponent( mbedtls_mpi const *P,
-                                         mbedtls_mpi const *Q,
-                                         mbedtls_mpi const *E,
-                                         mbedtls_mpi *D );
-
-
-/**
- * \brief          Generate RSA-CRT parameters
- *
- * \note           This is a 'static' helper function not operating on
- *                 an RSA context. Alternative implementations need not
- *                 overwrite it.
- *
- * \param P        First prime factor of N
- * \param Q        Second prime factor of N
- * \param D        RSA private exponent
- * \param DP       Output variable for D modulo P-1
- * \param DQ       Output variable for D modulo Q-1
- * \param QP       Output variable for the modular inverse of Q modulo P.
- *
- * \return         0 on success, non-zero error code otherwise.
- *
- * \note           This function does not check whether P, Q are
- *                 prime and whether D is a valid private exponent.
- *
- */
-int mbedtls_rsa_deduce_crt( const mbedtls_mpi *P, const mbedtls_mpi *Q,
-                            const mbedtls_mpi *D, mbedtls_mpi *DP,
-                            mbedtls_mpi *DQ, mbedtls_mpi *QP );
-
-
-/**
- * \brief          Check validity of core RSA parameters
- *
- * \note           This is a 'static' helper function not operating on
- *                 an RSA context. Alternative implementations need not
- *                 overwrite it.
- *
- * \param N        RSA modulus N = PQ
- * \param P        First prime factor of N
- * \param Q        Second prime factor of N
- * \param D        RSA private exponent
- * \param E        RSA public exponent
- * \param f_rng    PRNG to be used for primality check, or NULL
- * \param p_rng    PRNG context for f_rng, or NULL
- *
- * \return
- *                 - 0 if the following conditions are satisfied
- *                   if all relevant parameters are provided:
- *                    - P prime if f_rng != NULL (%)
- *                    - Q prime if f_rng != NULL (%)
- *                    - 1 < N = P * Q
- *                    - 1 < D, E < N
- *                    - D and E are modular inverses modulo P-1 and Q-1
- *                   (%) This is only done if MBEDTLS_GENPRIME is defined.
- *                 - A non-zero error code otherwise.
- *
- * \note           The function can be used with a restricted set of arguments
- *                 to perform specific checks only. E.g., calling it with
- *                 (-,P,-,-,-) and a PRNG amounts to a primality check for P.
- */
-int mbedtls_rsa_validate_params( const mbedtls_mpi *N, const mbedtls_mpi *P,
-                                 const mbedtls_mpi *Q, const mbedtls_mpi *D,
-                                 const mbedtls_mpi *E,
-                                 int (*f_rng)(void *, unsigned char *, size_t),
-                                 void *p_rng );
-
-/**
- * \brief          Check validity of RSA CRT parameters
- *
- * \note           This is a 'static' helper function not operating on
- *                 an RSA context. Alternative implementations need not
- *                 overwrite it.
- *
- * \param P        First prime factor of RSA modulus
- * \param Q        Second prime factor of RSA modulus
- * \param D        RSA private exponent
- * \param DP       MPI to check for D modulo P-1
- * \param DQ       MPI to check for D modulo P-1
- * \param QP       MPI to check for the modular inverse of Q modulo P.
- *
- * \return
- *                 - 0 if the following conditions are satisfied:
- *                    - D = DP mod P-1 if P, D, DP != NULL
- *                    - Q = DQ mod P-1 if P, D, DQ != NULL
- *                    - QP = Q^-1 mod P if P, Q, QP != NULL
- *                 - \c MBEDTLS_ERR_RSA_KEY_CHECK_FAILED if check failed,
- *                   potentially including \c MBEDTLS_ERR_MPI_XXX if some
- *                   MPI calculations failed.
- *                 - \c MBEDTLS_ERR_RSA_BAD_INPUT_DATA if insufficient
- *                   data was provided to check DP, DQ or QP.
- *
- * \note           The function can be used with a restricted set of arguments
- *                 to perform specific checks only. E.g., calling it with the
- *                 parameters (P, -, D, DP, -, -) will check DP = D mod P-1.
- */
-int mbedtls_rsa_validate_crt( const mbedtls_mpi *P,  const mbedtls_mpi *Q,
-                              const mbedtls_mpi *D,  const mbedtls_mpi *DP,
-                              const mbedtls_mpi *DQ, const mbedtls_mpi *QP );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* rsa_alt_helpers.h */
diff --git a/src/duckdb/third_party/mbedtls/library/sha1.cpp b/src/duckdb/third_party/mbedtls/library/sha1.cpp
deleted file mode 100644
index 88e47e7c7..000000000
--- a/src/duckdb/third_party/mbedtls/library/sha1.cpp
+++ /dev/null
@@ -1,515 +0,0 @@
-/*
- *  FIPS-180-1 compliant SHA-1 implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-/*
- *  The SHA-1 standard was published by NIST in 1993.
- *
- *  http://www.itl.nist.gov/fipspubs/fip180-1.htm
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_SHA1_C)
-
-#include "mbedtls/sha1.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_SELF_TEST)
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#define mbedtls_printf printf
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#define SHA1_VALIDATE_RET(cond)                             \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_SHA1_BAD_INPUT_DATA )
-
-#define SHA1_VALIDATE(cond)  MBEDTLS_INTERNAL_VALIDATE( cond )
-
-#if !defined(MBEDTLS_SHA1_ALT)
-
-void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
-{
-    SHA1_VALIDATE( ctx != NULL );
-
-    memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
-}
-
-void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
-}
-
-void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
-                         const mbedtls_sha1_context *src )
-{
-    SHA1_VALIDATE( dst != NULL );
-    SHA1_VALIDATE( src != NULL );
-
-    *dst = *src;
-}
-
-/*
- * SHA-1 context setup
- */
-int mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
-{
-    SHA1_VALIDATE_RET( ctx != NULL );
-
-    ctx->total[0] = 0;
-    ctx->total[1] = 0;
-
-    ctx->state[0] = 0x67452301;
-    ctx->state[1] = 0xEFCDAB89;
-    ctx->state[2] = 0x98BADCFE;
-    ctx->state[3] = 0x10325476;
-    ctx->state[4] = 0xC3D2E1F0;
-
-    return( 0 );
-}
-
-#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
-int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
-                                   const unsigned char data[64] )
-{
-    struct
-    {
-        uint32_t temp, W[16], A, B, C, D, E;
-    } local;
-
-    SHA1_VALIDATE_RET( ctx != NULL );
-    SHA1_VALIDATE_RET( (const unsigned char *)data != NULL );
-
-    local.W[ 0] = MBEDTLS_GET_UINT32_BE( data,  0 );
-    local.W[ 1] = MBEDTLS_GET_UINT32_BE( data,  4 );
-    local.W[ 2] = MBEDTLS_GET_UINT32_BE( data,  8 );
-    local.W[ 3] = MBEDTLS_GET_UINT32_BE( data, 12 );
-    local.W[ 4] = MBEDTLS_GET_UINT32_BE( data, 16 );
-    local.W[ 5] = MBEDTLS_GET_UINT32_BE( data, 20 );
-    local.W[ 6] = MBEDTLS_GET_UINT32_BE( data, 24 );
-    local.W[ 7] = MBEDTLS_GET_UINT32_BE( data, 28 );
-    local.W[ 8] = MBEDTLS_GET_UINT32_BE( data, 32 );
-    local.W[ 9] = MBEDTLS_GET_UINT32_BE( data, 36 );
-    local.W[10] = MBEDTLS_GET_UINT32_BE( data, 40 );
-    local.W[11] = MBEDTLS_GET_UINT32_BE( data, 44 );
-    local.W[12] = MBEDTLS_GET_UINT32_BE( data, 48 );
-    local.W[13] = MBEDTLS_GET_UINT32_BE( data, 52 );
-    local.W[14] = MBEDTLS_GET_UINT32_BE( data, 56 );
-    local.W[15] = MBEDTLS_GET_UINT32_BE( data, 60 );
-
-#define S(x,n) (((x) << (n)) | (((x) & 0xFFFFFFFF) >> (32 - (n))))
-
-#define R(t)                                                    \
-    (                                                           \
-        local.temp = local.W[( (t) -  3 ) & 0x0F] ^             \
-                     local.W[( (t) -  8 ) & 0x0F] ^             \
-                     local.W[( (t) - 14 ) & 0x0F] ^             \
-                     local.W[  (t)        & 0x0F],              \
-        ( local.W[(t) & 0x0F] = S(local.temp,1) )               \
-    )
-
-#define P(a,b,c,d,e,x)                                          \
-    do                                                          \
-    {                                                           \
-        (e) += S((a),5) + F((b),(c),(d)) + K + (x);             \
-        (b) = S((b),30);                                        \
-    } while( 0 )
-
-    local.A = ctx->state[0];
-    local.B = ctx->state[1];
-    local.C = ctx->state[2];
-    local.D = ctx->state[3];
-    local.E = ctx->state[4];
-
-#define F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
-#define K 0x5A827999
-
-    P( local.A, local.B, local.C, local.D, local.E, local.W[0]  );
-    P( local.E, local.A, local.B, local.C, local.D, local.W[1]  );
-    P( local.D, local.E, local.A, local.B, local.C, local.W[2]  );
-    P( local.C, local.D, local.E, local.A, local.B, local.W[3]  );
-    P( local.B, local.C, local.D, local.E, local.A, local.W[4]  );
-    P( local.A, local.B, local.C, local.D, local.E, local.W[5]  );
-    P( local.E, local.A, local.B, local.C, local.D, local.W[6]  );
-    P( local.D, local.E, local.A, local.B, local.C, local.W[7]  );
-    P( local.C, local.D, local.E, local.A, local.B, local.W[8]  );
-    P( local.B, local.C, local.D, local.E, local.A, local.W[9]  );
-    P( local.A, local.B, local.C, local.D, local.E, local.W[10] );
-    P( local.E, local.A, local.B, local.C, local.D, local.W[11] );
-    P( local.D, local.E, local.A, local.B, local.C, local.W[12] );
-    P( local.C, local.D, local.E, local.A, local.B, local.W[13] );
-    P( local.B, local.C, local.D, local.E, local.A, local.W[14] );
-    P( local.A, local.B, local.C, local.D, local.E, local.W[15] );
-    P( local.E, local.A, local.B, local.C, local.D, R(16) );
-    P( local.D, local.E, local.A, local.B, local.C, R(17) );
-    P( local.C, local.D, local.E, local.A, local.B, R(18) );
-    P( local.B, local.C, local.D, local.E, local.A, R(19) );
-
-#undef K
-#undef F
-
-#define F(x,y,z) ((x) ^ (y) ^ (z))
-#define K 0x6ED9EBA1
-
-    P( local.A, local.B, local.C, local.D, local.E, R(20) );
-    P( local.E, local.A, local.B, local.C, local.D, R(21) );
-    P( local.D, local.E, local.A, local.B, local.C, R(22) );
-    P( local.C, local.D, local.E, local.A, local.B, R(23) );
-    P( local.B, local.C, local.D, local.E, local.A, R(24) );
-    P( local.A, local.B, local.C, local.D, local.E, R(25) );
-    P( local.E, local.A, local.B, local.C, local.D, R(26) );
-    P( local.D, local.E, local.A, local.B, local.C, R(27) );
-    P( local.C, local.D, local.E, local.A, local.B, R(28) );
-    P( local.B, local.C, local.D, local.E, local.A, R(29) );
-    P( local.A, local.B, local.C, local.D, local.E, R(30) );
-    P( local.E, local.A, local.B, local.C, local.D, R(31) );
-    P( local.D, local.E, local.A, local.B, local.C, R(32) );
-    P( local.C, local.D, local.E, local.A, local.B, R(33) );
-    P( local.B, local.C, local.D, local.E, local.A, R(34) );
-    P( local.A, local.B, local.C, local.D, local.E, R(35) );
-    P( local.E, local.A, local.B, local.C, local.D, R(36) );
-    P( local.D, local.E, local.A, local.B, local.C, R(37) );
-    P( local.C, local.D, local.E, local.A, local.B, R(38) );
-    P( local.B, local.C, local.D, local.E, local.A, R(39) );
-
-#undef K
-#undef F
-
-#define F(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
-#define K 0x8F1BBCDC
-
-    P( local.A, local.B, local.C, local.D, local.E, R(40) );
-    P( local.E, local.A, local.B, local.C, local.D, R(41) );
-    P( local.D, local.E, local.A, local.B, local.C, R(42) );
-    P( local.C, local.D, local.E, local.A, local.B, R(43) );
-    P( local.B, local.C, local.D, local.E, local.A, R(44) );
-    P( local.A, local.B, local.C, local.D, local.E, R(45) );
-    P( local.E, local.A, local.B, local.C, local.D, R(46) );
-    P( local.D, local.E, local.A, local.B, local.C, R(47) );
-    P( local.C, local.D, local.E, local.A, local.B, R(48) );
-    P( local.B, local.C, local.D, local.E, local.A, R(49) );
-    P( local.A, local.B, local.C, local.D, local.E, R(50) );
-    P( local.E, local.A, local.B, local.C, local.D, R(51) );
-    P( local.D, local.E, local.A, local.B, local.C, R(52) );
-    P( local.C, local.D, local.E, local.A, local.B, R(53) );
-    P( local.B, local.C, local.D, local.E, local.A, R(54) );
-    P( local.A, local.B, local.C, local.D, local.E, R(55) );
-    P( local.E, local.A, local.B, local.C, local.D, R(56) );
-    P( local.D, local.E, local.A, local.B, local.C, R(57) );
-    P( local.C, local.D, local.E, local.A, local.B, R(58) );
-    P( local.B, local.C, local.D, local.E, local.A, R(59) );
-
-#undef K
-#undef F
-
-#define F(x,y,z) ((x) ^ (y) ^ (z))
-#define K 0xCA62C1D6
-
-    P( local.A, local.B, local.C, local.D, local.E, R(60) );
-    P( local.E, local.A, local.B, local.C, local.D, R(61) );
-    P( local.D, local.E, local.A, local.B, local.C, R(62) );
-    P( local.C, local.D, local.E, local.A, local.B, R(63) );
-    P( local.B, local.C, local.D, local.E, local.A, R(64) );
-    P( local.A, local.B, local.C, local.D, local.E, R(65) );
-    P( local.E, local.A, local.B, local.C, local.D, R(66) );
-    P( local.D, local.E, local.A, local.B, local.C, R(67) );
-    P( local.C, local.D, local.E, local.A, local.B, R(68) );
-    P( local.B, local.C, local.D, local.E, local.A, R(69) );
-    P( local.A, local.B, local.C, local.D, local.E, R(70) );
-    P( local.E, local.A, local.B, local.C, local.D, R(71) );
-    P( local.D, local.E, local.A, local.B, local.C, R(72) );
-    P( local.C, local.D, local.E, local.A, local.B, R(73) );
-    P( local.B, local.C, local.D, local.E, local.A, R(74) );
-    P( local.A, local.B, local.C, local.D, local.E, R(75) );
-    P( local.E, local.A, local.B, local.C, local.D, R(76) );
-    P( local.D, local.E, local.A, local.B, local.C, R(77) );
-    P( local.C, local.D, local.E, local.A, local.B, R(78) );
-    P( local.B, local.C, local.D, local.E, local.A, R(79) );
-
-#undef K
-#undef F
-#undef R
-#undef P
-
-    ctx->state[0] += local.A;
-    ctx->state[1] += local.B;
-    ctx->state[2] += local.C;
-    ctx->state[3] += local.D;
-    ctx->state[4] += local.E;
-
-    /* Zeroise buffers and variables to clear sensitive data from memory. */
-    mbedtls_platform_zeroize( &local, sizeof( local ) );
-
-    return( 0 );
-}
-
-#endif /* !MBEDTLS_SHA1_PROCESS_ALT */
-
-/*
- * SHA-1 process buffer
- */
-int mbedtls_sha1_update( mbedtls_sha1_context *ctx,
-                             const unsigned char *input,
-                             size_t ilen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t fill;
-    uint32_t left;
-
-    SHA1_VALIDATE_RET( ctx != NULL );
-    SHA1_VALIDATE_RET( ilen == 0 || input != NULL );
-
-    if( ilen == 0 )
-        return( 0 );
-
-    left = ctx->total[0] & 0x3F;
-    fill = 64 - left;
-
-    ctx->total[0] += (uint32_t) ilen;
-    ctx->total[0] &= 0xFFFFFFFF;
-
-    if( ctx->total[0] < (uint32_t) ilen )
-        ctx->total[1]++;
-
-    if( left && ilen >= fill )
-    {
-        memcpy( (void *) (ctx->buffer + left), input, fill );
-
-        if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
-            return( ret );
-
-        input += fill;
-        ilen  -= fill;
-        left = 0;
-    }
-
-    while( ilen >= 64 )
-    {
-        if( ( ret = mbedtls_internal_sha1_process( ctx, input ) ) != 0 )
-            return( ret );
-
-        input += 64;
-        ilen  -= 64;
-    }
-
-    if( ilen > 0 )
-        memcpy( (void *) (ctx->buffer + left), input, ilen );
-
-    return( 0 );
-}
-
-/*
- * SHA-1 final digest
- */
-int mbedtls_sha1_finish( mbedtls_sha1_context *ctx,
-                             unsigned char output[20] )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    uint32_t used;
-    uint32_t high, low;
-
-    SHA1_VALIDATE_RET( ctx != NULL );
-    SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
-
-    /*
-     * Add padding: 0x80 then 0x00 until 8 bytes remain for the length
-     */
-    used = ctx->total[0] & 0x3F;
-
-    ctx->buffer[used++] = 0x80;
-
-    if( used <= 56 )
-    {
-        /* Enough room for padding + length in current block */
-        memset( ctx->buffer + used, 0, 56 - used );
-    }
-    else
-    {
-        /* We'll need an extra block */
-        memset( ctx->buffer + used, 0, 64 - used );
-
-        if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
-            return( ret );
-
-        memset( ctx->buffer, 0, 56 );
-    }
-
-    /*
-     * Add message length
-     */
-    high = ( ctx->total[0] >> 29 )
-         | ( ctx->total[1] <<  3 );
-    low  = ( ctx->total[0] <<  3 );
-
-    MBEDTLS_PUT_UINT32_BE( high, ctx->buffer, 56 );
-    MBEDTLS_PUT_UINT32_BE( low,  ctx->buffer, 60 );
-
-    if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
-        return( ret );
-
-    /*
-     * Output final state
-     */
-    MBEDTLS_PUT_UINT32_BE( ctx->state[0], output,  0 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[1], output,  4 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[2], output,  8 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[3], output, 12 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[4], output, 16 );
-
-    return( 0 );
-}
-
-#endif /* !MBEDTLS_SHA1_ALT */
-
-/*
- * output = SHA-1( input buffer )
- */
-int mbedtls_sha1( const unsigned char *input,
-                      size_t ilen,
-                      unsigned char output[20] )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_sha1_context ctx;
-
-    SHA1_VALIDATE_RET( ilen == 0 || input != NULL );
-    SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
-
-    mbedtls_sha1_init( &ctx );
-
-    if( ( ret = mbedtls_sha1_starts( &ctx ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_sha1_update( &ctx, input, ilen ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_sha1_finish( &ctx, output ) ) != 0 )
-        goto exit;
-
-exit:
-    mbedtls_sha1_free( &ctx );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_SELF_TEST)
-/*
- * FIPS-180-1 test vectors
- */
-static const unsigned char sha1_test_buf[3][57] =
-{
-    { "abc" },
-    { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
-    { "" }
-};
-
-static const size_t sha1_test_buflen[3] =
-{
-    3, 56, 1000
-};
-
-static const unsigned char sha1_test_sum[3][20] =
-{
-    { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
-      0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
-    { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
-      0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
-    { 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
-      0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
-};
-
-/*
- * Checkup routine
- */
-int mbedtls_sha1_self_test( int verbose )
-{
-    int i, j, buflen, ret = 0;
-    unsigned char buf[1024];
-    unsigned char sha1sum[20];
-    mbedtls_sha1_context ctx;
-
-    mbedtls_sha1_init( &ctx );
-
-    /*
-     * SHA-1
-     */
-    for( i = 0; i < 3; i++ )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "  SHA-1 test #%d: ", i + 1 );
-
-        if( ( ret = mbedtls_sha1_starts( &ctx ) ) != 0 )
-            goto fail;
-
-        if( i == 2 )
-        {
-            memset( buf, 'a', buflen = 1000 );
-
-            for( j = 0; j < 1000; j++ )
-            {
-                ret = mbedtls_sha1_update( &ctx, buf, buflen );
-                if( ret != 0 )
-                    goto fail;
-            }
-        }
-        else
-        {
-            ret = mbedtls_sha1_update( &ctx, sha1_test_buf[i],
-                                           sha1_test_buflen[i] );
-            if( ret != 0 )
-                goto fail;
-        }
-
-        if( ( ret = mbedtls_sha1_finish( &ctx, sha1sum ) ) != 0 )
-            goto fail;
-
-        if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
-        {
-            ret = 1;
-            goto fail;
-        }
-
-        if( verbose != 0 )
-            mbedtls_printf( "passed\n" );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-    goto exit;
-
-fail:
-    if( verbose != 0 )
-        mbedtls_printf( "failed\n" );
-
-exit:
-    mbedtls_sha1_free( &ctx );
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_SHA1_C */
diff --git a/src/duckdb/third_party/mbedtls/library/sha256.cpp b/src/duckdb/third_party/mbedtls/library/sha256.cpp
deleted file mode 100644
index c35894532..000000000
--- a/src/duckdb/third_party/mbedtls/library/sha256.cpp
+++ /dev/null
@@ -1,560 +0,0 @@
-/*
- *  FIPS-180-2 compliant SHA-256 implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-/*
- *  The SHA-256 Secure Hash Standard was published by NIST in 2002.
- *
- *  http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_SHA256_C)
-
-#include "mbedtls/sha256.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_SELF_TEST)
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#include <stdlib.h>
-#define mbedtls_printf printf
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#define SHA256_VALIDATE_RET(cond)                           \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_SHA256_BAD_INPUT_DATA )
-#define SHA256_VALIDATE(cond)  MBEDTLS_INTERNAL_VALIDATE( cond )
-
-#if !defined(MBEDTLS_SHA256_ALT)
-
-void mbedtls_sha256_init( mbedtls_sha256_context *ctx )
-{
-    SHA256_VALIDATE( ctx != NULL );
-
-    memset( ctx, 0, sizeof( mbedtls_sha256_context ) );
-}
-
-void mbedtls_sha256_free( mbedtls_sha256_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha256_context ) );
-}
-
-void mbedtls_sha256_clone( mbedtls_sha256_context *dst,
-                           const mbedtls_sha256_context *src )
-{
-    SHA256_VALIDATE( dst != NULL );
-    SHA256_VALIDATE( src != NULL );
-
-    *dst = *src;
-}
-
-/*
- * SHA-256 context setup
- */
-int mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
-{
-    SHA256_VALIDATE_RET( ctx != NULL );
-
-#if defined(MBEDTLS_SHA224_C)
-    SHA256_VALIDATE_RET( is224 == 0 || is224 == 1 );
-#else
-    SHA256_VALIDATE_RET( is224 == 0 );
-#endif
-
-    ctx->total[0] = 0;
-    ctx->total[1] = 0;
-
-    if( is224 == 0 )
-    {
-        /* SHA-256 */
-        ctx->state[0] = 0x6A09E667;
-        ctx->state[1] = 0xBB67AE85;
-        ctx->state[2] = 0x3C6EF372;
-        ctx->state[3] = 0xA54FF53A;
-        ctx->state[4] = 0x510E527F;
-        ctx->state[5] = 0x9B05688C;
-        ctx->state[6] = 0x1F83D9AB;
-        ctx->state[7] = 0x5BE0CD19;
-    }
-    else
-    {
-#if defined(MBEDTLS_SHA224_C)
-        /* SHA-224 */
-        ctx->state[0] = 0xC1059ED8;
-        ctx->state[1] = 0x367CD507;
-        ctx->state[2] = 0x3070DD17;
-        ctx->state[3] = 0xF70E5939;
-        ctx->state[4] = 0xFFC00B31;
-        ctx->state[5] = 0x68581511;
-        ctx->state[6] = 0x64F98FA7;
-        ctx->state[7] = 0xBEFA4FA4;
-#endif
-    }
-
-    ctx->is224 = is224;
-
-    return( 0 );
-}
-
-#if !defined(MBEDTLS_SHA256_PROCESS_ALT)
-static const uint32_t K[] =
-{
-    0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
-    0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
-    0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
-    0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
-    0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
-    0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
-    0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
-    0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
-    0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
-    0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
-    0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
-    0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
-    0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
-    0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
-    0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
-    0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
-};
-
-#define  SHR(x,n) (((x) & 0xFFFFFFFF) >> (n))
-#define ROTR(x,n) (SHR(x,n) | ((x) << (32 - (n))))
-
-#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^  SHR(x, 3))
-#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^  SHR(x,10))
-
-#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
-#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
-
-#define F0(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
-#define F1(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
-
-#define R(t)                                                        \
-    (                                                               \
-        local.W[t] = S1(local.W[(t) -  2]) + local.W[(t) -  7] +    \
-                     S0(local.W[(t) - 15]) + local.W[(t) - 16]      \
-    )
-
-#define P(a,b,c,d,e,f,g,h,x,K)                                      \
-    do                                                              \
-    {                                                               \
-        local.temp1 = (h) + S3(e) + F1((e),(f),(g)) + (K) + (x);    \
-        local.temp2 = S2(a) + F0((a),(b),(c));                      \
-        (d) += local.temp1; (h) = local.temp1 + local.temp2;        \
-    } while( 0 )
-
-int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx,
-                                const unsigned char data[64] )
-{
-    struct
-    {
-        uint32_t temp1, temp2, W[64];
-        uint32_t A[8];
-    } local;
-
-    unsigned int i;
-
-    SHA256_VALIDATE_RET( ctx != NULL );
-    SHA256_VALIDATE_RET( (const unsigned char *)data != NULL );
-
-    for( i = 0; i < 8; i++ )
-        local.A[i] = ctx->state[i];
-
-#if defined(MBEDTLS_SHA256_SMALLER)
-    for( i = 0; i < 64; i++ )
-    {
-        if( i < 16 )
-            local.W[i] = MBEDTLS_GET_UINT32_BE( data, 4 * i );
-        else
-            R( i );
-
-        P( local.A[0], local.A[1], local.A[2], local.A[3], local.A[4],
-           local.A[5], local.A[6], local.A[7], local.W[i], K[i] );
-
-        local.temp1 = local.A[7]; local.A[7] = local.A[6];
-        local.A[6] = local.A[5]; local.A[5] = local.A[4];
-        local.A[4] = local.A[3]; local.A[3] = local.A[2];
-        local.A[2] = local.A[1]; local.A[1] = local.A[0];
-        local.A[0] = local.temp1;
-    }
-#else /* MBEDTLS_SHA256_SMALLER */
-    for( i = 0; i < 16; i++ )
-        local.W[i] = MBEDTLS_GET_UINT32_BE( data, 4 * i );
-
-    for( i = 0; i < 16; i += 8 )
-    {
-        P( local.A[0], local.A[1], local.A[2], local.A[3], local.A[4],
-           local.A[5], local.A[6], local.A[7], local.W[i+0], K[i+0] );
-        P( local.A[7], local.A[0], local.A[1], local.A[2], local.A[3],
-           local.A[4], local.A[5], local.A[6], local.W[i+1], K[i+1] );
-        P( local.A[6], local.A[7], local.A[0], local.A[1], local.A[2],
-           local.A[3], local.A[4], local.A[5], local.W[i+2], K[i+2] );
-        P( local.A[5], local.A[6], local.A[7], local.A[0], local.A[1],
-           local.A[2], local.A[3], local.A[4], local.W[i+3], K[i+3] );
-        P( local.A[4], local.A[5], local.A[6], local.A[7], local.A[0],
-           local.A[1], local.A[2], local.A[3], local.W[i+4], K[i+4] );
-        P( local.A[3], local.A[4], local.A[5], local.A[6], local.A[7],
-           local.A[0], local.A[1], local.A[2], local.W[i+5], K[i+5] );
-        P( local.A[2], local.A[3], local.A[4], local.A[5], local.A[6],
-           local.A[7], local.A[0], local.A[1], local.W[i+6], K[i+6] );
-        P( local.A[1], local.A[2], local.A[3], local.A[4], local.A[5],
-           local.A[6], local.A[7], local.A[0], local.W[i+7], K[i+7] );
-    }
-
-    for( i = 16; i < 64; i += 8 )
-    {
-        P( local.A[0], local.A[1], local.A[2], local.A[3], local.A[4],
-           local.A[5], local.A[6], local.A[7], R(i+0), K[i+0] );
-        P( local.A[7], local.A[0], local.A[1], local.A[2], local.A[3],
-           local.A[4], local.A[5], local.A[6], R(i+1), K[i+1] );
-        P( local.A[6], local.A[7], local.A[0], local.A[1], local.A[2],
-           local.A[3], local.A[4], local.A[5], R(i+2), K[i+2] );
-        P( local.A[5], local.A[6], local.A[7], local.A[0], local.A[1],
-           local.A[2], local.A[3], local.A[4], R(i+3), K[i+3] );
-        P( local.A[4], local.A[5], local.A[6], local.A[7], local.A[0],
-           local.A[1], local.A[2], local.A[3], R(i+4), K[i+4] );
-        P( local.A[3], local.A[4], local.A[5], local.A[6], local.A[7],
-           local.A[0], local.A[1], local.A[2], R(i+5), K[i+5] );
-        P( local.A[2], local.A[3], local.A[4], local.A[5], local.A[6],
-           local.A[7], local.A[0], local.A[1], R(i+6), K[i+6] );
-        P( local.A[1], local.A[2], local.A[3], local.A[4], local.A[5],
-           local.A[6], local.A[7], local.A[0], R(i+7), K[i+7] );
-    }
-#endif /* MBEDTLS_SHA256_SMALLER */
-
-    for( i = 0; i < 8; i++ )
-        ctx->state[i] += local.A[i];
-
-    /* Zeroise buffers and variables to clear sensitive data from memory. */
-    mbedtls_platform_zeroize( &local, sizeof( local ) );
-
-    return( 0 );
-}
-
-#undef P
-#undef R
-
-#endif /* !MBEDTLS_SHA256_PROCESS_ALT */
-
-/*
- * SHA-256 process buffer
- */
-int mbedtls_sha256_update( mbedtls_sha256_context *ctx,
-                               const unsigned char *input,
-                               size_t ilen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t fill;
-    uint32_t left;
-
-    SHA256_VALIDATE_RET( ctx != NULL );
-    SHA256_VALIDATE_RET( ilen == 0 || input != NULL );
-
-    if( ilen == 0 )
-        return( 0 );
-
-    left = ctx->total[0] & 0x3F;
-    fill = 64 - left;
-
-    ctx->total[0] += (uint32_t) ilen;
-    ctx->total[0] &= 0xFFFFFFFF;
-
-    if( ctx->total[0] < (uint32_t) ilen )
-        ctx->total[1]++;
-
-    if( left && ilen >= fill )
-    {
-        memcpy( (void *) (ctx->buffer + left), input, fill );
-
-        if( ( ret = mbedtls_internal_sha256_process( ctx, ctx->buffer ) ) != 0 )
-            return( ret );
-
-        input += fill;
-        ilen  -= fill;
-        left = 0;
-    }
-
-    while( ilen >= 64 )
-    {
-        if( ( ret = mbedtls_internal_sha256_process( ctx, input ) ) != 0 )
-            return( ret );
-
-        input += 64;
-        ilen  -= 64;
-    }
-
-    if( ilen > 0 )
-        memcpy( (void *) (ctx->buffer + left), input, ilen );
-
-    return( 0 );
-}
-
-/*
- * SHA-256 final digest
- */
-int mbedtls_sha256_finish( mbedtls_sha256_context *ctx,
-                               unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    uint32_t used;
-    uint32_t high, low;
-
-    SHA256_VALIDATE_RET( ctx != NULL );
-    SHA256_VALIDATE_RET( (unsigned char *)output != NULL );
-
-    /*
-     * Add padding: 0x80 then 0x00 until 8 bytes remain for the length
-     */
-    used = ctx->total[0] & 0x3F;
-
-    ctx->buffer[used++] = 0x80;
-
-    if( used <= 56 )
-    {
-        /* Enough room for padding + length in current block */
-        memset( ctx->buffer + used, 0, 56 - used );
-    }
-    else
-    {
-        /* We'll need an extra block */
-        memset( ctx->buffer + used, 0, 64 - used );
-
-        if( ( ret = mbedtls_internal_sha256_process( ctx, ctx->buffer ) ) != 0 )
-            return( ret );
-
-        memset( ctx->buffer, 0, 56 );
-    }
-
-    /*
-     * Add message length
-     */
-    high = ( ctx->total[0] >> 29 )
-         | ( ctx->total[1] <<  3 );
-    low  = ( ctx->total[0] <<  3 );
-
-    MBEDTLS_PUT_UINT32_BE( high, ctx->buffer, 56 );
-    MBEDTLS_PUT_UINT32_BE( low,  ctx->buffer, 60 );
-
-    if( ( ret = mbedtls_internal_sha256_process( ctx, ctx->buffer ) ) != 0 )
-        return( ret );
-
-    /*
-     * Output final state
-     */
-    MBEDTLS_PUT_UINT32_BE( ctx->state[0], output,  0 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[1], output,  4 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[2], output,  8 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[3], output, 12 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[4], output, 16 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[5], output, 20 );
-    MBEDTLS_PUT_UINT32_BE( ctx->state[6], output, 24 );
-
-#if defined(MBEDTLS_SHA224_C)
-    if( ctx->is224 == 0 )
-#endif
-        MBEDTLS_PUT_UINT32_BE( ctx->state[7], output, 28 );
-
-    return( 0 );
-}
-
-#endif /* !MBEDTLS_SHA256_ALT */
-
-/*
- * output = SHA-256( input buffer )
- */
-int mbedtls_sha256( const unsigned char *input,
-                        size_t ilen,
-                        unsigned char *output,
-                        int is224 )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_sha256_context ctx;
-
-#if defined(MBEDTLS_SHA224_C)
-    SHA256_VALIDATE_RET( is224 == 0 || is224 == 1 );
-#else
-    SHA256_VALIDATE_RET( is224 == 0 );
-#endif
-
-    SHA256_VALIDATE_RET( ilen == 0 || input != NULL );
-    SHA256_VALIDATE_RET( (unsigned char *)output != NULL );
-
-    mbedtls_sha256_init( &ctx );
-
-    if( ( ret = mbedtls_sha256_starts( &ctx, is224 ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_sha256_update( &ctx, input, ilen ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_sha256_finish( &ctx, output ) ) != 0 )
-        goto exit;
-
-exit:
-    mbedtls_sha256_free( &ctx );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_SELF_TEST)
-/*
- * FIPS-180-2 test vectors
- */
-static const unsigned char sha256_test_buf[3][57] =
-{
-    { "abc" },
-    { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
-    { "" }
-};
-
-static const size_t sha256_test_buflen[3] =
-{
-    3, 56, 1000
-};
-
-static const unsigned char sha256_test_sum[6][32] =
-{
-    /*
-     * SHA-224 test vectors
-     */
-    { 0x23, 0x09, 0x7D, 0x22, 0x34, 0x05, 0xD8, 0x22,
-      0x86, 0x42, 0xA4, 0x77, 0xBD, 0xA2, 0x55, 0xB3,
-      0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0, 0xB3, 0xF7,
-      0xE3, 0x6C, 0x9D, 0xA7 },
-    { 0x75, 0x38, 0x8B, 0x16, 0x51, 0x27, 0x76, 0xCC,
-      0x5D, 0xBA, 0x5D, 0xA1, 0xFD, 0x89, 0x01, 0x50,
-      0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5, 0x8B, 0x19,
-      0x52, 0x52, 0x25, 0x25 },
-    { 0x20, 0x79, 0x46, 0x55, 0x98, 0x0C, 0x91, 0xD8,
-      0xBB, 0xB4, 0xC1, 0xEA, 0x97, 0x61, 0x8A, 0x4B,
-      0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48, 0xB2, 0xEE,
-      0x4E, 0xE7, 0xAD, 0x67 },
-
-    /*
-     * SHA-256 test vectors
-     */
-    { 0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA,
-      0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23,
-      0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C,
-      0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD },
-    { 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
-      0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
-      0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
-      0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1 },
-    { 0xCD, 0xC7, 0x6E, 0x5C, 0x99, 0x14, 0xFB, 0x92,
-      0x81, 0xA1, 0xC7, 0xE2, 0x84, 0xD7, 0x3E, 0x67,
-      0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97, 0x20, 0x0E,
-      0x04, 0x6D, 0x39, 0xCC, 0xC7, 0x11, 0x2C, 0xD0 }
-};
-
-/*
- * Checkup routine
- */
-int mbedtls_sha256_self_test( int verbose )
-{
-    int i, j, k, buflen, ret = 0;
-    unsigned char *buf;
-    unsigned char sha256sum[32];
-    mbedtls_sha256_context ctx;
-
-    buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
-    if( NULL == buf )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "Buffer allocation failed\n" );
-
-        return( 1 );
-    }
-
-    mbedtls_sha256_init( &ctx );
-
-    for( i = 0; i < 6; i++ )
-    {
-        j = i % 3;
-        k = i < 3;
-
-        if( verbose != 0 )
-            mbedtls_printf( "  SHA-%d test #%d: ", 256 - k * 32, j + 1 );
-
-        if( ( ret = mbedtls_sha256_starts( &ctx, k ) ) != 0 )
-            goto fail;
-
-        if( j == 2 )
-        {
-            memset( buf, 'a', buflen = 1000 );
-
-            for( j = 0; j < 1000; j++ )
-            {
-                ret = mbedtls_sha256_update( &ctx, buf, buflen );
-                if( ret != 0 )
-                    goto fail;
-            }
-
-        }
-        else
-        {
-            ret = mbedtls_sha256_update( &ctx, sha256_test_buf[j],
-                                             sha256_test_buflen[j] );
-            if( ret != 0 )
-                 goto fail;
-        }
-
-        if( ( ret = mbedtls_sha256_finish( &ctx, sha256sum ) ) != 0 )
-            goto fail;
-
-
-        if( memcmp( sha256sum, sha256_test_sum[i], 32 - k * 4 ) != 0 )
-        {
-            ret = 1;
-            goto fail;
-        }
-
-        if( verbose != 0 )
-            mbedtls_printf( "passed\n" );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-    goto exit;
-
-fail:
-    if( verbose != 0 )
-        mbedtls_printf( "failed\n" );
-
-exit:
-    mbedtls_sha256_free( &ctx );
-    mbedtls_free( buf );
-
-    return( ret );
-}
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_SHA256_C */
diff --git a/src/duckdb/third_party/mbedtls/library/sha512.cpp b/src/duckdb/third_party/mbedtls/library/sha512.cpp
deleted file mode 100644
index 2b4cc547e..000000000
--- a/src/duckdb/third_party/mbedtls/library/sha512.cpp
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
- *  FIPS-180-2 compliant SHA-384/512 implementation
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  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.
- */
-/*
- *  The SHA-512 Secure Hash Standard was published by NIST in 2002.
- *
- *  http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_SHA512_C)
-
-#include "mbedtls/sha512.h"
-#include "mbedtls/platform_util.h"
-#include "mbedtls/error.h"
-
-#if defined(_MSC_VER) || defined(__WATCOMC__)
-  #define UL64(x) x##ui64
-#else
-  #define UL64(x) x##ULL
-#endif
-
-#include <string.h>
-
-#if defined(MBEDTLS_SELF_TEST)
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#include <stdio.h>
-#include <stdlib.h>
-#define mbedtls_printf printf
-#define mbedtls_calloc    calloc
-#define mbedtls_free       free
-#endif /* MBEDTLS_PLATFORM_C */
-#endif /* MBEDTLS_SELF_TEST */
-
-#define SHA512_VALIDATE_RET(cond)                           \
-    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_SHA512_BAD_INPUT_DATA )
-#define SHA512_VALIDATE(cond)  MBEDTLS_INTERNAL_VALIDATE( cond )
-
-#if !defined(MBEDTLS_SHA512_ALT)
-
-#if defined(MBEDTLS_SHA512_SMALLER)
-static void sha512_put_uint64_be( uint64_t n, unsigned char *b, uint8_t i )
-{
-    MBEDTLS_PUT_UINT64_BE(n, b, i);
-}
-#else
-#define sha512_put_uint64_be    MBEDTLS_PUT_UINT64_BE
-#endif /* MBEDTLS_SHA512_SMALLER */
-
-void mbedtls_sha512_init( mbedtls_sha512_context *ctx )
-{
-    SHA512_VALIDATE( ctx != NULL );
-
-    memset( ctx, 0, sizeof( mbedtls_sha512_context ) );
-}
-
-void mbedtls_sha512_free( mbedtls_sha512_context *ctx )
-{
-    if( ctx == NULL )
-        return;
-
-    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
-}
-
-void mbedtls_sha512_clone( mbedtls_sha512_context *dst,
-                           const mbedtls_sha512_context *src )
-{
-    SHA512_VALIDATE( dst != NULL );
-    SHA512_VALIDATE( src != NULL );
-
-    *dst = *src;
-}
-
-/*
- * SHA-512 context setup
- */
-int mbedtls_sha512_starts( mbedtls_sha512_context *ctx, int is384 )
-{
-    SHA512_VALIDATE_RET( ctx != NULL );
-#if defined(MBEDTLS_SHA384_C)
-    SHA512_VALIDATE_RET( is384 == 0 || is384 == 1 );
-#else
-    SHA512_VALIDATE_RET( is384 == 0 );
-#endif
-
-    ctx->total[0] = 0;
-    ctx->total[1] = 0;
-
-    if( is384 == 0 )
-    {
-        /* SHA-512 */
-        ctx->state[0] = UL64(0x6A09E667F3BCC908);
-        ctx->state[1] = UL64(0xBB67AE8584CAA73B);
-        ctx->state[2] = UL64(0x3C6EF372FE94F82B);
-        ctx->state[3] = UL64(0xA54FF53A5F1D36F1);
-        ctx->state[4] = UL64(0x510E527FADE682D1);
-        ctx->state[5] = UL64(0x9B05688C2B3E6C1F);
-        ctx->state[6] = UL64(0x1F83D9ABFB41BD6B);
-        ctx->state[7] = UL64(0x5BE0CD19137E2179);
-    }
-    else
-    {
-#if !defined(MBEDTLS_SHA384_C)
-        return( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA );
-#else
-        /* SHA-384 */
-        ctx->state[0] = UL64(0xCBBB9D5DC1059ED8);
-        ctx->state[1] = UL64(0x629A292A367CD507);
-        ctx->state[2] = UL64(0x9159015A3070DD17);
-        ctx->state[3] = UL64(0x152FECD8F70E5939);
-        ctx->state[4] = UL64(0x67332667FFC00B31);
-        ctx->state[5] = UL64(0x8EB44A8768581511);
-        ctx->state[6] = UL64(0xDB0C2E0D64F98FA7);
-        ctx->state[7] = UL64(0x47B5481DBEFA4FA4);
-#endif /* MBEDTLS_SHA384_C */
-    }
-
-#if defined(MBEDTLS_SHA384_C)
-    ctx->is384 = is384;
-#endif
-
-    return( 0 );
-}
-
-#if !defined(MBEDTLS_SHA512_PROCESS_ALT)
-
-/*
- * Round constants
- */
-static const uint64_t K[80] =
-{
-    UL64(0x428A2F98D728AE22),  UL64(0x7137449123EF65CD),
-    UL64(0xB5C0FBCFEC4D3B2F),  UL64(0xE9B5DBA58189DBBC),
-    UL64(0x3956C25BF348B538),  UL64(0x59F111F1B605D019),
-    UL64(0x923F82A4AF194F9B),  UL64(0xAB1C5ED5DA6D8118),
-    UL64(0xD807AA98A3030242),  UL64(0x12835B0145706FBE),
-    UL64(0x243185BE4EE4B28C),  UL64(0x550C7DC3D5FFB4E2),
-    UL64(0x72BE5D74F27B896F),  UL64(0x80DEB1FE3B1696B1),
-    UL64(0x9BDC06A725C71235),  UL64(0xC19BF174CF692694),
-    UL64(0xE49B69C19EF14AD2),  UL64(0xEFBE4786384F25E3),
-    UL64(0x0FC19DC68B8CD5B5),  UL64(0x240CA1CC77AC9C65),
-    UL64(0x2DE92C6F592B0275),  UL64(0x4A7484AA6EA6E483),
-    UL64(0x5CB0A9DCBD41FBD4),  UL64(0x76F988DA831153B5),
-    UL64(0x983E5152EE66DFAB),  UL64(0xA831C66D2DB43210),
-    UL64(0xB00327C898FB213F),  UL64(0xBF597FC7BEEF0EE4),
-    UL64(0xC6E00BF33DA88FC2),  UL64(0xD5A79147930AA725),
-    UL64(0x06CA6351E003826F),  UL64(0x142929670A0E6E70),
-    UL64(0x27B70A8546D22FFC),  UL64(0x2E1B21385C26C926),
-    UL64(0x4D2C6DFC5AC42AED),  UL64(0x53380D139D95B3DF),
-    UL64(0x650A73548BAF63DE),  UL64(0x766A0ABB3C77B2A8),
-    UL64(0x81C2C92E47EDAEE6),  UL64(0x92722C851482353B),
-    UL64(0xA2BFE8A14CF10364),  UL64(0xA81A664BBC423001),
-    UL64(0xC24B8B70D0F89791),  UL64(0xC76C51A30654BE30),
-    UL64(0xD192E819D6EF5218),  UL64(0xD69906245565A910),
-    UL64(0xF40E35855771202A),  UL64(0x106AA07032BBD1B8),
-    UL64(0x19A4C116B8D2D0C8),  UL64(0x1E376C085141AB53),
-    UL64(0x2748774CDF8EEB99),  UL64(0x34B0BCB5E19B48A8),
-    UL64(0x391C0CB3C5C95A63),  UL64(0x4ED8AA4AE3418ACB),
-    UL64(0x5B9CCA4F7763E373),  UL64(0x682E6FF3D6B2B8A3),
-    UL64(0x748F82EE5DEFB2FC),  UL64(0x78A5636F43172F60),
-    UL64(0x84C87814A1F0AB72),  UL64(0x8CC702081A6439EC),
-    UL64(0x90BEFFFA23631E28),  UL64(0xA4506CEBDE82BDE9),
-    UL64(0xBEF9A3F7B2C67915),  UL64(0xC67178F2E372532B),
-    UL64(0xCA273ECEEA26619C),  UL64(0xD186B8C721C0C207),
-    UL64(0xEADA7DD6CDE0EB1E),  UL64(0xF57D4F7FEE6ED178),
-    UL64(0x06F067AA72176FBA),  UL64(0x0A637DC5A2C898A6),
-    UL64(0x113F9804BEF90DAE),  UL64(0x1B710B35131C471B),
-    UL64(0x28DB77F523047D84),  UL64(0x32CAAB7B40C72493),
-    UL64(0x3C9EBE0A15C9BEBC),  UL64(0x431D67C49C100D4C),
-    UL64(0x4CC5D4BECB3E42B6),  UL64(0x597F299CFC657E2A),
-    UL64(0x5FCB6FAB3AD6FAEC),  UL64(0x6C44198C4A475817)
-};
-
-int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx,
-                                     const unsigned char data[128] )
-{
-    int i;
-    struct
-    {
-        uint64_t temp1, temp2, W[80];
-        uint64_t A[8];
-    } local;
-
-    SHA512_VALIDATE_RET( ctx != NULL );
-    SHA512_VALIDATE_RET( (const unsigned char *)data != NULL );
-
-#define  SHR(x,n) ((x) >> (n))
-#define ROTR(x,n) (SHR((x),(n)) | ((x) << (64 - (n))))
-
-#define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^  SHR(x, 7))
-#define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^  SHR(x, 6))
-
-#define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
-#define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
-
-#define F0(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
-#define F1(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
-
-#define P(a,b,c,d,e,f,g,h,x,K)                                      \
-    do                                                              \
-    {                                                               \
-        local.temp1 = (h) + S3(e) + F1((e),(f),(g)) + (K) + (x);    \
-        local.temp2 = S2(a) + F0((a),(b),(c));                      \
-        (d) += local.temp1; (h) = local.temp1 + local.temp2;        \
-    } while( 0 )
-
-    for( i = 0; i < 8; i++ )
-        local.A[i] = ctx->state[i];
-
-#if defined(MBEDTLS_SHA512_SMALLER)
-    for( i = 0; i < 80; i++ )
-    {
-        if( i < 16 )
-        {
-            local.W[i] = MBEDTLS_GET_UINT64_BE( data, i << 3 );
-        }
-        else
-        {
-            local.W[i] = S1(local.W[i -  2]) + local.W[i -  7] +
-                   S0(local.W[i - 15]) + local.W[i - 16];
-        }
-
-        P( local.A[0], local.A[1], local.A[2], local.A[3], local.A[4],
-           local.A[5], local.A[6], local.A[7], local.W[i], K[i] );
-
-        local.temp1 = local.A[7]; local.A[7] = local.A[6];
-        local.A[6] = local.A[5]; local.A[5] = local.A[4];
-        local.A[4] = local.A[3]; local.A[3] = local.A[2];
-        local.A[2] = local.A[1]; local.A[1] = local.A[0];
-        local.A[0] = local.temp1;
-    }
-#else /* MBEDTLS_SHA512_SMALLER */
-    for( i = 0; i < 16; i++ )
-    {
-        local.W[i] = MBEDTLS_GET_UINT64_BE( data, i << 3 );
-    }
-
-    for( ; i < 80; i++ )
-    {
-        local.W[i] = S1(local.W[i -  2]) + local.W[i -  7] +
-               S0(local.W[i - 15]) + local.W[i - 16];
-    }
-
-    i = 0;
-    do
-    {
-        P( local.A[0], local.A[1], local.A[2], local.A[3], local.A[4],
-           local.A[5], local.A[6], local.A[7], local.W[i], K[i] ); i++;
-        P( local.A[7], local.A[0], local.A[1], local.A[2], local.A[3],
-           local.A[4], local.A[5], local.A[6], local.W[i], K[i] ); i++;
-        P( local.A[6], local.A[7], local.A[0], local.A[1], local.A[2],
-           local.A[3], local.A[4], local.A[5], local.W[i], K[i] ); i++;
-        P( local.A[5], local.A[6], local.A[7], local.A[0], local.A[1],
-           local.A[2], local.A[3], local.A[4], local.W[i], K[i] ); i++;
-        P( local.A[4], local.A[5], local.A[6], local.A[7], local.A[0],
-           local.A[1], local.A[2], local.A[3], local.W[i], K[i] ); i++;
-        P( local.A[3], local.A[4], local.A[5], local.A[6], local.A[7],
-           local.A[0], local.A[1], local.A[2], local.W[i], K[i] ); i++;
-        P( local.A[2], local.A[3], local.A[4], local.A[5], local.A[6],
-           local.A[7], local.A[0], local.A[1], local.W[i], K[i] ); i++;
-        P( local.A[1], local.A[2], local.A[3], local.A[4], local.A[5],
-           local.A[6], local.A[7], local.A[0], local.W[i], K[i] ); i++;
-    }
-    while( i < 80 );
-#endif /* MBEDTLS_SHA512_SMALLER */
-
-    for( i = 0; i < 8; i++ )
-        ctx->state[i] += local.A[i];
-
-    /* Zeroise buffers and variables to clear sensitive data from memory. */
-    mbedtls_platform_zeroize( &local, sizeof( local ) );
-
-    return( 0 );
-}
-
-#endif /* !MBEDTLS_SHA512_PROCESS_ALT */
-
-/*
- * SHA-512 process buffer
- */
-int mbedtls_sha512_update( mbedtls_sha512_context *ctx,
-                               const unsigned char *input,
-                               size_t ilen )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    size_t fill;
-    unsigned int left;
-
-    SHA512_VALIDATE_RET( ctx != NULL );
-    SHA512_VALIDATE_RET( ilen == 0 || input != NULL );
-
-    if( ilen == 0 )
-        return( 0 );
-
-    left = (unsigned int) (ctx->total[0] & 0x7F);
-    fill = 128 - left;
-
-    ctx->total[0] += (uint64_t) ilen;
-
-    if( ctx->total[0] < (uint64_t) ilen )
-        ctx->total[1]++;
-
-    if( left && ilen >= fill )
-    {
-        memcpy( (void *) (ctx->buffer + left), input, fill );
-
-        if( ( ret = mbedtls_internal_sha512_process( ctx, ctx->buffer ) ) != 0 )
-            return( ret );
-
-        input += fill;
-        ilen  -= fill;
-        left = 0;
-    }
-
-    while( ilen >= 128 )
-    {
-        if( ( ret = mbedtls_internal_sha512_process( ctx, input ) ) != 0 )
-            return( ret );
-
-        input += 128;
-        ilen  -= 128;
-    }
-
-    if( ilen > 0 )
-        memcpy( (void *) (ctx->buffer + left), input, ilen );
-
-    return( 0 );
-}
-
-/*
- * SHA-512 final digest
- */
-int mbedtls_sha512_finish( mbedtls_sha512_context *ctx,
-                               unsigned char *output )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    unsigned used;
-    uint64_t high, low;
-
-    SHA512_VALIDATE_RET( ctx != NULL );
-    SHA512_VALIDATE_RET( (unsigned char *)output != NULL );
-
-    /*
-     * Add padding: 0x80 then 0x00 until 16 bytes remain for the length
-     */
-    used = ctx->total[0] & 0x7F;
-
-    ctx->buffer[used++] = 0x80;
-
-    if( used <= 112 )
-    {
-        /* Enough room for padding + length in current block */
-        memset( ctx->buffer + used, 0, 112 - used );
-    }
-    else
-    {
-        /* We'll need an extra block */
-        memset( ctx->buffer + used, 0, 128 - used );
-
-        if( ( ret = mbedtls_internal_sha512_process( ctx, ctx->buffer ) ) != 0 )
-            return( ret );
-
-        memset( ctx->buffer, 0, 112 );
-    }
-
-    /*
-     * Add message length
-     */
-    high = ( ctx->total[0] >> 61 )
-         | ( ctx->total[1] <<  3 );
-    low  = ( ctx->total[0] <<  3 );
-
-    sha512_put_uint64_be( high, ctx->buffer, 112 );
-    sha512_put_uint64_be( low,  ctx->buffer, 120 );
-
-    if( ( ret = mbedtls_internal_sha512_process( ctx, ctx->buffer ) ) != 0 )
-        return( ret );
-
-    /*
-     * Output final state
-     */
-    sha512_put_uint64_be( ctx->state[0], output,  0 );
-    sha512_put_uint64_be( ctx->state[1], output,  8 );
-    sha512_put_uint64_be( ctx->state[2], output, 16 );
-    sha512_put_uint64_be( ctx->state[3], output, 24 );
-    sha512_put_uint64_be( ctx->state[4], output, 32 );
-    sha512_put_uint64_be( ctx->state[5], output, 40 );
-
-#if defined(MBEDTLS_SHA384_C)
-    if( ctx->is384 == 0 )
-#endif
-    {
-        sha512_put_uint64_be( ctx->state[6], output, 48 );
-        sha512_put_uint64_be( ctx->state[7], output, 56 );
-    }
-
-    return( 0 );
-}
-
-#endif /* !MBEDTLS_SHA512_ALT */
-
-/*
- * output = SHA-512( input buffer )
- */
-int mbedtls_sha512( const unsigned char *input,
-                    size_t ilen,
-                    unsigned char *output,
-                    int is384 )
-{
-    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
-    mbedtls_sha512_context ctx;
-
-#if defined(MBEDTLS_SHA384_C)
-    SHA512_VALIDATE_RET( is384 == 0 || is384 == 1 );
-#else
-    SHA512_VALIDATE_RET( is384 == 0 );
-#endif
-    SHA512_VALIDATE_RET( ilen == 0 || input != NULL );
-    SHA512_VALIDATE_RET( (unsigned char *)output != NULL );
-
-    mbedtls_sha512_init( &ctx );
-
-    if( ( ret = mbedtls_sha512_starts( &ctx, is384 ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_sha512_update( &ctx, input, ilen ) ) != 0 )
-        goto exit;
-
-    if( ( ret = mbedtls_sha512_finish( &ctx, output ) ) != 0 )
-        goto exit;
-
-exit:
-    mbedtls_sha512_free( &ctx );
-
-    return( ret );
-}
-
-#if defined(MBEDTLS_SELF_TEST)
-
-/*
- * FIPS-180-2 test vectors
- */
-static const unsigned char sha512_test_buf[3][113] =
-{
-    { "abc" },
-    { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" },
-    { "" }
-};
-
-static const size_t sha512_test_buflen[3] =
-{
-    3, 112, 1000
-};
-
-static const unsigned char sha512_test_sum[][64] =
-{
-#if defined(MBEDTLS_SHA384_C)
-    /*
-     * SHA-384 test vectors
-     */
-    { 0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B,
-      0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50, 0x07,
-      0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63,
-      0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
-      0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23,
-      0x58, 0xBA, 0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7 },
-    { 0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8,
-      0x3D, 0x19, 0x2F, 0xC7, 0x82, 0xCD, 0x1B, 0x47,
-      0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B, 0x05, 0xD2,
-      0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
-      0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9,
-      0x66, 0xC3, 0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39 },
-    { 0x9D, 0x0E, 0x18, 0x09, 0x71, 0x64, 0x74, 0xCB,
-      0x08, 0x6E, 0x83, 0x4E, 0x31, 0x0A, 0x4A, 0x1C,
-      0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2, 0x48, 0x52,
-      0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
-      0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB,
-      0xAE, 0x97, 0xDD, 0xD8, 0x7F, 0x3D, 0x89, 0x85 },
-#endif /* MBEDTLS_SHA384_C */
-
-    /*
-     * SHA-512 test vectors
-     */
-    { 0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA,
-      0xCC, 0x41, 0x73, 0x49, 0xAE, 0x20, 0x41, 0x31,
-      0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9, 0x7E, 0xA2,
-      0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
-      0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8,
-      0x36, 0xBA, 0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD,
-      0x45, 0x4D, 0x44, 0x23, 0x64, 0x3C, 0xE8, 0x0E,
-      0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C, 0xA4, 0x9F },
-    { 0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
-      0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
-      0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
-      0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
-      0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
-      0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
-      0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
-      0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09 },
-    { 0xE7, 0x18, 0x48, 0x3D, 0x0C, 0xE7, 0x69, 0x64,
-      0x4E, 0x2E, 0x42, 0xC7, 0xBC, 0x15, 0xB4, 0x63,
-      0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20, 0x44, 0x28,
-      0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
-      0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A,
-      0x4C, 0xB0, 0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B,
-      0xEB, 0x00, 0x9C, 0x5C, 0x2C, 0x49, 0xAA, 0x2E,
-      0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C, 0xC0, 0x9B }
-};
-
-#define ARRAY_LENGTH( a )   ( sizeof( a ) / sizeof( ( a )[0] ) )
-
-/*
- * Checkup routine
- */
-int mbedtls_sha512_self_test( int verbose )
-{
-    int i, j, k, buflen, ret = 0;
-    unsigned char *buf;
-    unsigned char sha512sum[64];
-    mbedtls_sha512_context ctx;
-
-    buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
-    if( NULL == buf )
-    {
-        if( verbose != 0 )
-            mbedtls_printf( "Buffer allocation failed\n" );
-
-        return( 1 );
-    }
-
-    mbedtls_sha512_init( &ctx );
-
-    for( i = 0; i < (int) ARRAY_LENGTH(sha512_test_sum); i++ )
-    {
-        j = i % 3;
-#if defined(MBEDTLS_SHA384_C)
-        k = i < 3;
-#else
-        k = 0;
-#endif
-
-        if( verbose != 0 )
-            mbedtls_printf( "  SHA-%d test #%d: ", 512 - k * 128, j + 1 );
-
-        if( ( ret = mbedtls_sha512_starts( &ctx, k ) ) != 0 )
-            goto fail;
-
-        if( j == 2 )
-        {
-            memset( buf, 'a', buflen = 1000 );
-
-            for( j = 0; j < 1000; j++ )
-            {
-                ret = mbedtls_sha512_update( &ctx, buf, buflen );
-                if( ret != 0 )
-                    goto fail;
-            }
-        }
-        else
-        {
-            ret = mbedtls_sha512_update( &ctx, sha512_test_buf[j],
-                                             sha512_test_buflen[j] );
-            if( ret != 0 )
-                goto fail;
-        }
-
-        if( ( ret = mbedtls_sha512_finish( &ctx, sha512sum ) ) != 0 )
-            goto fail;
-
-        if( memcmp( sha512sum, sha512_test_sum[i], 64 - k * 16 ) != 0 )
-        {
-            ret = 1;
-            goto fail;
-        }
-
-        if( verbose != 0 )
-            mbedtls_printf( "passed\n" );
-    }
-
-    if( verbose != 0 )
-        mbedtls_printf( "\n" );
-
-    goto exit;
-
-fail:
-    if( verbose != 0 )
-        mbedtls_printf( "failed\n" );
-
-exit:
-    mbedtls_sha512_free( &ctx );
-    mbedtls_free( buf );
-
-    return( ret );
-}
-
-#undef ARRAY_LENGTH
-
-#endif /* MBEDTLS_SELF_TEST */
-
-#endif /* MBEDTLS_SHA512_C */
diff --git a/src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp b/src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp
deleted file mode 100644
index 66bcc628c..000000000
--- a/src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp
+++ /dev/null
@@ -1,296 +0,0 @@
-#include "mbedtls_wrapper.hpp"
-
-// otherwise we have different definitions for mbedtls_pk_context / mbedtls_sha256_context
-#define MBEDTLS_ALLOW_PRIVATE_ACCESS
-
-#include "duckdb/common/helper.hpp"
-#include "mbedtls/entropy.h"
-#include "mbedtls/gcm.h"
-#include "mbedtls/pk.h"
-#include "mbedtls/sha1.h"
-#include "mbedtls/sha256.h"
-
-#ifdef MBEDTLS_NO_ENTROPY_SOURCE
-#include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#endif
-
-#include <stdexcept>
-
-using namespace std;
-using namespace duckdb_mbedtls;
-
-/*
-# Command line tricks to help here
-# Create a new key
-openssl genrsa -out private.pem 2048
-
-# Export public key
-openssl rsa -in private.pem -outform PEM -pubout -out public.pem
-
-# Calculate digest and write to 'hash' file on command line
-openssl dgst -binary -sha256 dummy > hash
-
-# Calculate signature from hash
-openssl pkeyutl -sign -in hash -inkey private.pem -pkeyopt digest:sha256 -out dummy.sign
-*/
-
-void MbedTlsWrapper::ComputeSha256Hash(const char *in, size_t in_len, char *out) {
-
-	mbedtls_sha256_context sha_context;
-	mbedtls_sha256_init(&sha_context);
-	if (mbedtls_sha256_starts(&sha_context, false) ||
-	    mbedtls_sha256_update(&sha_context, reinterpret_cast<const unsigned char *>(in), in_len) ||
-	    mbedtls_sha256_finish(&sha_context, reinterpret_cast<unsigned char *>(out))) {
-		throw runtime_error("SHA256 Error");
-	}
-	mbedtls_sha256_free(&sha_context);
-}
-
-string MbedTlsWrapper::ComputeSha256Hash(const string &file_content) {
-	string hash;
-	hash.resize(MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
-	ComputeSha256Hash(file_content.data(), file_content.size(), (char *)hash.data());
-	return hash;
-}
-
-bool MbedTlsWrapper::IsValidSha256Signature(const std::string &pubkey, const std::string &signature,
-                                            const std::string &sha256_hash) {
-
-	if (signature.size() != 256 || sha256_hash.size() != 32) {
-		throw std::runtime_error("Invalid input lengths, expected signature length 256, got " +
-		                         to_string(signature.size()) + ", hash length 32, got " +
-		                         to_string(sha256_hash.size()));
-	}
-
-	mbedtls_pk_context pk_context;
-	mbedtls_pk_init(&pk_context);
-
-	if (mbedtls_pk_parse_public_key(&pk_context, reinterpret_cast<const unsigned char *>(pubkey.c_str()),
-	                                pubkey.size() + 1)) {
-		throw runtime_error("RSA public key import error");
-	}
-
-	// actually verify
-	bool valid = mbedtls_pk_verify(&pk_context, MBEDTLS_MD_SHA256,
-	                               reinterpret_cast<const unsigned char *>(sha256_hash.data()), sha256_hash.size(),
-	                               reinterpret_cast<const unsigned char *>(signature.data()), signature.length()) == 0;
-
-	mbedtls_pk_free(&pk_context);
-	return valid;
-}
-
-// used in s3fs
-void MbedTlsWrapper::Hmac256(const char *key, size_t key_len, const char *message, size_t message_len, char *out) {
-	mbedtls_md_context_t hmac_ctx;
-	const mbedtls_md_info_t *md_type = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
-	if (!md_type) {
-		throw runtime_error("failed to init hmac");
-	}
-
-	if (mbedtls_md_setup(&hmac_ctx, md_type, 1) ||
-	    mbedtls_md_hmac_starts(&hmac_ctx, reinterpret_cast<const unsigned char *>(key), key_len) ||
-	    mbedtls_md_hmac_update(&hmac_ctx, reinterpret_cast<const unsigned char *>(message), message_len) ||
-	    mbedtls_md_hmac_finish(&hmac_ctx, reinterpret_cast<unsigned char *>(out))) {
-		throw runtime_error("HMAC256 Error");
-	}
-	mbedtls_md_free(&hmac_ctx);
-}
-
-void MbedTlsWrapper::ToBase16(char *in, char *out, size_t len) {
-	static char const HEX_CODES[] = "0123456789abcdef";
-	size_t i, j;
-
-	for (j = i = 0; i < len; i++) {
-		int a = in[i];
-		out[j++] = HEX_CODES[(a >> 4) & 0xf];
-		out[j++] = HEX_CODES[a & 0xf];
-	}
-}
-
-MbedTlsWrapper::SHA256State::SHA256State() : sha_context(new mbedtls_sha256_context()) {
-	auto context = reinterpret_cast<mbedtls_sha256_context *>(sha_context);
-
-	mbedtls_sha256_init(context);
-
-	if (mbedtls_sha256_starts(context, false)) {
-		throw std::runtime_error("SHA256 Error");
-	}
-}
-
-MbedTlsWrapper::SHA256State::~SHA256State() {
-	auto context = reinterpret_cast<mbedtls_sha256_context *>(sha_context);
-	mbedtls_sha256_free(context);
-	delete context;
-}
-
-void MbedTlsWrapper::SHA256State::AddString(const std::string &str) {
-	auto context = reinterpret_cast<mbedtls_sha256_context *>(sha_context);
-	if (mbedtls_sha256_update(context, (unsigned char *)str.data(), str.size())) {
-		throw std::runtime_error("SHA256 Error");
-	}
-}
-
-std::string MbedTlsWrapper::SHA256State::Finalize() {
-	auto context = reinterpret_cast<mbedtls_sha256_context *>(sha_context);
-
-	string hash;
-	hash.resize(MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
-
-	if (mbedtls_sha256_finish(context, (unsigned char *)hash.data())) {
-		throw std::runtime_error("SHA256 Error");
-	}
-
-	return hash;
-}
-
-void MbedTlsWrapper::SHA256State::FinishHex(char *out) {
-	auto context = reinterpret_cast<mbedtls_sha256_context *>(sha_context);
-
-	string hash;
-	hash.resize(MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
-
-	if (mbedtls_sha256_finish(context, (unsigned char *)hash.data())) {
-		throw std::runtime_error("SHA256 Error");
-	}
-
-	MbedTlsWrapper::ToBase16(const_cast<char *>(hash.c_str()), out, MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
-}
-
-MbedTlsWrapper::SHA1State::SHA1State() : sha_context(new mbedtls_sha1_context()) {
-	auto context = reinterpret_cast<mbedtls_sha1_context *>(sha_context);
-
-	mbedtls_sha1_init(context);
-
-	if (mbedtls_sha1_starts(context)) {
-		throw std::runtime_error("SHA1 Error");
-	}
-}
-
-MbedTlsWrapper::SHA1State::~SHA1State() {
-	auto context = reinterpret_cast<mbedtls_sha1_context *>(sha_context);
-	mbedtls_sha1_free(context);
-	delete context;
-}
-
-void MbedTlsWrapper::SHA1State::AddString(const std::string &str) {
-	auto context = reinterpret_cast<mbedtls_sha1_context *>(sha_context);
-	if (mbedtls_sha1_update(context, (unsigned char *)str.data(), str.size())) {
-		throw std::runtime_error("SHA1 Error");
-	}
-}
-
-std::string MbedTlsWrapper::SHA1State::Finalize() {
-	auto context = reinterpret_cast<mbedtls_sha1_context *>(sha_context);
-
-	string hash;
-	hash.resize(MbedTlsWrapper::SHA1_HASH_LENGTH_BYTES);
-
-	if (mbedtls_sha1_finish(context, (unsigned char *)hash.data())) {
-		throw std::runtime_error("SHA1 Error");
-	}
-
-	return hash;
-}
-
-void MbedTlsWrapper::SHA1State::FinishHex(char *out) {
-	auto context = reinterpret_cast<mbedtls_sha1_context *>(sha_context);
-
-	string hash;
-	hash.resize(MbedTlsWrapper::SHA1_HASH_LENGTH_BYTES);
-
-	if (mbedtls_sha1_finish(context, (unsigned char *)hash.data())) {
-		throw std::runtime_error("SHA1 Error");
-	}
-
-	MbedTlsWrapper::ToBase16(const_cast<char *>(hash.c_str()), out, MbedTlsWrapper::SHA1_HASH_LENGTH_BYTES);
-}
-
-MbedTlsWrapper::AESGCMStateMBEDTLS::AESGCMStateMBEDTLS() : gcm_context(new mbedtls_gcm_context()) {
-	auto context = reinterpret_cast<mbedtls_gcm_context *>(gcm_context);
-	mbedtls_gcm_init(context);
-}
-
-MbedTlsWrapper::AESGCMStateMBEDTLS::~AESGCMStateMBEDTLS() {
-	auto context = reinterpret_cast<mbedtls_gcm_context *>(gcm_context);
-	mbedtls_gcm_free(context);
-	delete context;
-}
-
-bool MbedTlsWrapper::AESGCMStateMBEDTLS::IsOpenSSL() {
-	return ssl;
-}
-
-
-void MbedTlsWrapper::AESGCMStateMBEDTLS::GenerateRandomData(duckdb::data_ptr_t data, duckdb::idx_t len) {
-#ifdef MBEDTLS_NO_ENTROPY_SOURCE
-	duckdb::RandomEngine random_engine(duckdb::Timestamp::GetCurrentTimestamp().value);
-	while (len != 0) {
-		const auto random_integer = random_engine.NextRandomInteger();
-		const auto next = duckdb::MinValue<duckdb::idx_t>(len, sizeof(random_integer));
-		memcpy(data, duckdb::const_data_ptr_cast(&random_integer), next);
-		data += next;
-		len -= next;
-	}
-#else
-	duckdb::data_t buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
-	mbedtls_entropy_context entropy;
-	mbedtls_entropy_init(&entropy);
-
-	while (len != 0) {
-		if (mbedtls_entropy_func(&entropy, buf, MBEDTLS_ENTROPY_BLOCK_SIZE) != 0) {
-			throw runtime_error("Unable to generate random data");
-		}
-		const auto next = duckdb::MinValue<duckdb::idx_t>(len, MBEDTLS_ENTROPY_BLOCK_SIZE);
-		memcpy(data, buf, next);
-		data += next;
-		len -= next;
-	}
-#endif
-}
-
-void MbedTlsWrapper::AESGCMStateMBEDTLS::InitializeEncryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, const std::string *key) {
-	auto context = reinterpret_cast<mbedtls_gcm_context *>(gcm_context);
-	// Set key for mbedtls
-	if (mbedtls_gcm_setkey(context, MBEDTLS_CIPHER_ID_AES, reinterpret_cast<const unsigned char *>(key->data()),
-	                       key->length() * 8) != 0) {
-		throw runtime_error("Invalid AES key length");
-	}
-	if (mbedtls_gcm_starts(context, MBEDTLS_GCM_ENCRYPT, iv, iv_len) != 0) {
-		throw runtime_error("Unable to initialize AES encryption");
-	}
-}
-
-void MbedTlsWrapper::AESGCMStateMBEDTLS::InitializeDecryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, const std::string *key) {
-	auto context = reinterpret_cast<mbedtls_gcm_context *>(gcm_context);
-
-	// Set key for mbedtls
-	if (mbedtls_gcm_setkey(context, MBEDTLS_CIPHER_ID_AES, reinterpret_cast<const unsigned char *>(key->data()),
-	                       key->length() * 8) != 0) {
-		throw runtime_error("Invalid AES key length");
-	}
-
-	if (mbedtls_gcm_starts(context, MBEDTLS_GCM_DECRYPT, iv, iv_len) != 0) {
-		throw runtime_error("Unable to initialize AES decryption");
-	}
-}
-
-size_t MbedTlsWrapper::AESGCMStateMBEDTLS::Process(duckdb::const_data_ptr_t in, duckdb::idx_t in_len, duckdb::data_ptr_t out,
-                                                   duckdb::idx_t out_len) {
-	auto context = reinterpret_cast<mbedtls_gcm_context *>(gcm_context);
-	size_t result;
-	if (mbedtls_gcm_update(context, in, in_len, out, out_len, &result) != 0) {
-		throw runtime_error("Unable to process using AES");
-	}
-	return result;
-}
-
-size_t MbedTlsWrapper::AESGCMStateMBEDTLS::Finalize(duckdb::data_ptr_t out, duckdb::idx_t out_len, duckdb::data_ptr_t tag,
-                                                    duckdb::idx_t tag_len) {
-	auto context = reinterpret_cast<mbedtls_gcm_context *>(gcm_context);
-	size_t result;
-	if (mbedtls_gcm_finish(context, out, out_len, &result, tag, tag_len) != 0) {
-		throw runtime_error("Unable to finalize AES");
-	}
-	return result;
-}
diff --git a/src/duckdb/third_party/miniz/miniz.cpp b/src/duckdb/third_party/miniz/miniz.cpp
deleted file mode 100644
index 387573c0a..000000000
--- a/src/duckdb/third_party/miniz/miniz.cpp
+++ /dev/null
@@ -1,7544 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "miniz.hpp"
-
-namespace duckdb_miniz {
-typedef unsigned char mz_validate_uint16[sizeof(mz_uint16) == 2 ? 1 : -1];
-typedef unsigned char mz_validate_uint32[sizeof(mz_uint32) == 4 ? 1 : -1];
-typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1];
-
-
-
-/* ------------------- zlib-style API's */
-
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
-{
-    mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
-    size_t block_len = buf_len % 5552;
-    if (!ptr)
-        return MZ_ADLER32_INIT;
-    while (buf_len)
-    {
-        for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
-        {
-            s1 += ptr[0], s2 += s1;
-            s1 += ptr[1], s2 += s1;
-            s1 += ptr[2], s2 += s1;
-            s1 += ptr[3], s2 += s1;
-            s1 += ptr[4], s2 += s1;
-            s1 += ptr[5], s2 += s1;
-            s1 += ptr[6], s2 += s1;
-            s1 += ptr[7], s2 += s1;
-        }
-        for (; i < block_len; ++i)
-            s1 += *ptr++, s2 += s1;
-        s1 %= 65521U, s2 %= 65521U;
-        buf_len -= block_len;
-        block_len = 5552;
-    }
-    return (s2 << 16) + s1;
-}
-
-/* Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed": http://www.geocities.com/malbrain/ */
-#if 0
-    mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
-    {
-        static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
-                                               0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
-        mz_uint32 crcu32 = (mz_uint32)crc;
-        if (!ptr)
-            return MZ_CRC32_INIT;
-        crcu32 = ~crcu32;
-        while (buf_len--)
-        {
-            mz_uint8 b = *ptr++;
-            crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)];
-            crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)];
-        }
-        return ~crcu32;
-    }
-#else
-/* Faster, but larger CPU cache footprint.
- */
-mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
-{
-    static const mz_uint32 s_crc_table[256] =
-        {
-          0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
-          0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
-          0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
-          0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
-          0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
-          0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
-          0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
-          0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
-          0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
-          0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
-          0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
-          0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
-          0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
-          0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
-          0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
-          0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
-          0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
-          0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
-          0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
-          0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
-          0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
-          0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
-          0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
-          0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-          0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
-          0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
-          0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
-          0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
-          0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
-          0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
-          0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
-          0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
-          0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
-          0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
-          0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
-          0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-          0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-        };
-
-    mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF;
-    const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr;
-
-    while (buf_len >= 4)
-    {
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF];
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF];
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF];
-        pByte_buf += 4;
-        buf_len -= 4;
-    }
-
-    while (buf_len)
-    {
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
-        ++pByte_buf;
-        --buf_len;
-    }
-
-    return ~crc32;
-}
-#endif
-
-void mz_free(void *p)
-{
-    MZ_FREE(p);
-}
-
-void *miniz_def_alloc_func(void *opaque, size_t items, size_t size)
-{
-    (void)opaque, (void)items, (void)size;
-    return MZ_MALLOC(items * size);
-}
-void miniz_def_free_func(void *opaque, void *address)
-{
-    (void)opaque, (void)address;
-    MZ_FREE(address);
-}
-void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size)
-{
-    (void)opaque, (void)address, (void)items, (void)size;
-    return MZ_REALLOC(address, items * size);
-}
-
-const char *mz_version(void)
-{
-    return MZ_VERSION;
-}
-
-#ifndef MINIZ_NO_ZLIB_APIS
-
-int mz_deflateInit(mz_streamp pStream, int level)
-{
-    return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY);
-}
-
-int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
-{
-    tdefl_compressor *pComp;
-    mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);
-
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
-        return MZ_PARAM_ERROR;
-
-    pStream->data_type = 0;
-    pStream->adler = MZ_ADLER32_INIT;
-    pStream->msg = NULL;
-    pStream->reserved = 0;
-    pStream->total_in = 0;
-    pStream->total_out = 0;
-    if (!pStream->zalloc)
-        pStream->zalloc = miniz_def_alloc_func;
-    if (!pStream->zfree)
-        pStream->zfree = miniz_def_free_func;
-
-    pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
-    if (!pComp)
-        return MZ_MEM_ERROR;
-
-    pStream->state = (struct mz_internal_state *)pComp;
-
-    if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
-    {
-        mz_deflateEnd(pStream);
-        return MZ_PARAM_ERROR;
-    }
-
-    return MZ_OK;
-}
-
-int mz_deflateReset(mz_streamp pStream)
-{
-    if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
-        return MZ_STREAM_ERROR;
-    pStream->total_in = pStream->total_out = 0;
-    tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
-    return MZ_OK;
-}
-
-int mz_deflate(mz_streamp pStream, int flush)
-{
-    size_t in_bytes, out_bytes;
-    mz_ulong orig_total_in, orig_total_out;
-    int mz_status = MZ_OK;
-
-    if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out))
-        return MZ_STREAM_ERROR;
-    if (!pStream->avail_out)
-        return MZ_BUF_ERROR;
-
-    if (flush == MZ_PARTIAL_FLUSH)
-        flush = MZ_SYNC_FLUSH;
-
-    if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE)
-        return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
-
-    orig_total_in = pStream->total_in;
-    orig_total_out = pStream->total_out;
-    for (;;)
-    {
-        tdefl_status defl_status;
-        in_bytes = pStream->avail_in;
-        out_bytes = pStream->avail_out;
-
-        defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush);
-        pStream->next_in += (mz_uint)in_bytes;
-        pStream->avail_in -= (mz_uint)in_bytes;
-        pStream->total_in += (mz_uint)in_bytes;
-        pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
-
-        pStream->next_out += (mz_uint)out_bytes;
-        pStream->avail_out -= (mz_uint)out_bytes;
-        pStream->total_out += (mz_uint)out_bytes;
-
-        if (defl_status < 0)
-        {
-            mz_status = MZ_STREAM_ERROR;
-            break;
-        }
-        else if (defl_status == TDEFL_STATUS_DONE)
-        {
-            mz_status = MZ_STREAM_END;
-            break;
-        }
-        else if (!pStream->avail_out)
-            break;
-        else if ((!pStream->avail_in) && (flush != MZ_FINISH))
-        {
-            if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out))
-                break;
-            return MZ_BUF_ERROR; /* Can't make forward progress without some input.
- */
-        }
-    }
-    return mz_status;
-}
-
-int mz_deflateEnd(mz_streamp pStream)
-{
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if (pStream->state)
-    {
-        pStream->zfree(pStream->opaque, pStream->state);
-        pStream->state = NULL;
-    }
-    return MZ_OK;
-}
-
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)
-{
-    (void)pStream;
-    /* This is really over conservative. (And lame, but it's actually pretty tricky to compute a true upper bound given the way tdefl's blocking works.) */
-    return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
-}
-
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
-{
-    int status;
-    mz_stream stream;
-    memset(&stream, 0, sizeof(stream));
-
-    /* In case mz_ulong is 64-bits (argh I hate longs). */
-    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
-        return MZ_PARAM_ERROR;
-
-    stream.next_in = pSource;
-    stream.avail_in = (mz_uint32)source_len;
-    stream.next_out = pDest;
-    stream.avail_out = (mz_uint32)*pDest_len;
-
-    status = mz_deflateInit(&stream, level);
-    if (status != MZ_OK)
-        return status;
-
-    status = mz_deflate(&stream, MZ_FINISH);
-    if (status != MZ_STREAM_END)
-    {
-        mz_deflateEnd(&stream);
-        return (status == MZ_OK) ? MZ_BUF_ERROR : status;
-    }
-
-    *pDest_len = stream.total_out;
-    return mz_deflateEnd(&stream);
-}
-
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
-{
-    return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION);
-}
-
-mz_ulong mz_compressBound(mz_ulong source_len)
-{
-    return mz_deflateBound(NULL, source_len);
-}
-
-typedef struct
-{
-    tinfl_decompressor m_decomp;
-    mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed;
-    int m_window_bits;
-    mz_uint8 m_dict[TINFL_LZ_DICT_SIZE];
-    tinfl_status m_last_status;
-} inflate_state;
-
-int mz_inflateInit2(mz_streamp pStream, int window_bits)
-{
-    inflate_state *pDecomp;
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
-        return MZ_PARAM_ERROR;
-
-    pStream->data_type = 0;
-    pStream->adler = 0;
-    pStream->msg = NULL;
-    pStream->total_in = 0;
-    pStream->total_out = 0;
-    pStream->reserved = 0;
-    if (!pStream->zalloc)
-        pStream->zalloc = miniz_def_alloc_func;
-    if (!pStream->zfree)
-        pStream->zfree = miniz_def_free_func;
-
-    pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
-    if (!pDecomp)
-        return MZ_MEM_ERROR;
-
-    pStream->state = (struct mz_internal_state *)pDecomp;
-
-    tinfl_init(&pDecomp->m_decomp);
-    pDecomp->m_dict_ofs = 0;
-    pDecomp->m_dict_avail = 0;
-    pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
-    pDecomp->m_first_call = 1;
-    pDecomp->m_has_flushed = 0;
-    pDecomp->m_window_bits = window_bits;
-
-    return MZ_OK;
-}
-
-int mz_inflateInit(mz_streamp pStream)
-{
-    return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS);
-}
-
-int mz_inflate(mz_streamp pStream, int flush)
-{
-    inflate_state *pState;
-    mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32;
-    size_t in_bytes, out_bytes, orig_avail_in;
-    tinfl_status status;
-
-    if ((!pStream) || (!pStream->state))
-        return MZ_STREAM_ERROR;
-    if (flush == MZ_PARTIAL_FLUSH)
-        flush = MZ_SYNC_FLUSH;
-    if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH))
-        return MZ_STREAM_ERROR;
-
-    pState = (inflate_state *)pStream->state;
-    if (pState->m_window_bits > 0)
-        decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
-    orig_avail_in = pStream->avail_in;
-
-    first_call = pState->m_first_call;
-    pState->m_first_call = 0;
-    if (pState->m_last_status < 0)
-        return MZ_DATA_ERROR;
-
-    if (pState->m_has_flushed && (flush != MZ_FINISH))
-        return MZ_STREAM_ERROR;
-    pState->m_has_flushed |= (flush == MZ_FINISH);
-
-    if ((flush == MZ_FINISH) && (first_call))
-    {
-        /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */
-        decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
-        in_bytes = pStream->avail_in;
-        out_bytes = pStream->avail_out;
-        status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags);
-        pState->m_last_status = status;
-        pStream->next_in += (mz_uint)in_bytes;
-        pStream->avail_in -= (mz_uint)in_bytes;
-        pStream->total_in += (mz_uint)in_bytes;
-        pStream->adler = tinfl_get_adler32(&pState->m_decomp);
-        pStream->next_out += (mz_uint)out_bytes;
-        pStream->avail_out -= (mz_uint)out_bytes;
-        pStream->total_out += (mz_uint)out_bytes;
-
-        if (status < 0)
-            return MZ_DATA_ERROR;
-        else if (status != TINFL_STATUS_DONE)
-        {
-            pState->m_last_status = TINFL_STATUS_FAILED;
-            return MZ_BUF_ERROR;
-        }
-        return MZ_STREAM_END;
-    }
-    /* flush != MZ_FINISH then we must assume there's more input. */
-    if (flush != MZ_FINISH)
-        decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT;
-
-    if (pState->m_dict_avail)
-    {
-        n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
-        memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
-        pStream->next_out += n;
-        pStream->avail_out -= n;
-        pStream->total_out += n;
-        pState->m_dict_avail -= n;
-        pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
-        return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
-    }
-
-    for (;;)
-    {
-        in_bytes = pStream->avail_in;
-        out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs;
-
-        status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags);
-        pState->m_last_status = status;
-
-        pStream->next_in += (mz_uint)in_bytes;
-        pStream->avail_in -= (mz_uint)in_bytes;
-        pStream->total_in += (mz_uint)in_bytes;
-        pStream->adler = tinfl_get_adler32(&pState->m_decomp);
-
-        pState->m_dict_avail = (mz_uint)out_bytes;
-
-        n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
-        memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
-        pStream->next_out += n;
-        pStream->avail_out -= n;
-        pStream->total_out += n;
-        pState->m_dict_avail -= n;
-        pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
-
-        if (status < 0)
-            return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */
-        else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
-            return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */
-        else if (flush == MZ_FINISH)
-        {
-            /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */
-            if (status == TINFL_STATUS_DONE)
-                return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END;
-            /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */
-            else if (!pStream->avail_out)
-                return MZ_BUF_ERROR;
-        }
-        else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail))
-            break;
-    }
-
-    return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
-}
-
-int mz_inflateEnd(mz_streamp pStream)
-{
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if (pStream->state)
-    {
-        pStream->zfree(pStream->opaque, pStream->state);
-        pStream->state = NULL;
-    }
-    return MZ_OK;
-}
-
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
-{
-    mz_stream stream;
-    int status;
-    memset(&stream, 0, sizeof(stream));
-
-    /* In case mz_ulong is 64-bits (argh I hate longs). */
-    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
-        return MZ_PARAM_ERROR;
-
-    stream.next_in = pSource;
-    stream.avail_in = (mz_uint32)source_len;
-    stream.next_out = pDest;
-    stream.avail_out = (mz_uint32)*pDest_len;
-
-    status = mz_inflateInit(&stream);
-    if (status != MZ_OK)
-        return status;
-
-    status = mz_inflate(&stream, MZ_FINISH);
-    if (status != MZ_STREAM_END)
-    {
-        mz_inflateEnd(&stream);
-        return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
-    }
-    *pDest_len = stream.total_out;
-
-    return mz_inflateEnd(&stream);
-}
-
-const char *mz_error(int err)
-{
-    static struct
-    {
-        int m_err;
-        const char *m_pDesc;
-    } s_error_descs[] =
-        {
-          { MZ_OK, "" }, { MZ_STREAM_END, "stream end" }, { MZ_NEED_DICT, "need dictionary" }, { MZ_ERRNO, "file error" }, { MZ_STREAM_ERROR, "stream error" }, { MZ_DATA_ERROR, "data error" }, { MZ_MEM_ERROR, "out of memory" }, { MZ_BUF_ERROR, "buf error" }, { MZ_VERSION_ERROR, "version error" }, { MZ_PARAM_ERROR, "parameter error" }
-        };
-    mz_uint i;
-    for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i)
-        if (s_error_descs[i].m_err == err)
-            return s_error_descs[i].m_pDesc;
-    return NULL;
-}
-
-#endif /*MINIZ_NO_ZLIB_APIS */
-
-
-
-/*
-  This is free and unencumbered software released into the public domain.
-
-  Anyone is free to copy, modify, publish, use, compile, sell, or
-  distribute this software, either in source code form or as a compiled
-  binary, for any purpose, commercial or non-commercial, and by any
-  means.
-
-  In jurisdictions that recognize copyright laws, the author or authors
-  of this software dedicate any and all copyright interest in the
-  software to the public domain. We make this dedication for the benefit
-  of the public at large and to the detriment of our heirs and
-  successors. We intend this dedication to be an overt act of
-  relinquishment in perpetuity of all present and future rights to this
-  software under copyright law.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-  OTHER DEALINGS IN THE SOFTWARE.
-
-  For more information, please refer to <http://unlicense.org/>
-*/
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- ***********************************************************************/
-
-/* ------------------- Low-level Compression (independent from all decompression API's) */
-
-/* Purposely making these tables static for faster init and thread safety. */
-static const mz_uint16 s_tdefl_len_sym[256] =
-    {
-      257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272,
-      273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276,
-      277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
-      279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
-      281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
-      282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
-      283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
-      284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285
-    };
-
-static const mz_uint8 s_tdefl_len_extra[256] =
-    {
-      0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0
-    };
-
-static const mz_uint8 s_tdefl_small_dist_sym[512] =
-    {
-      0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,
-      11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13,
-      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-      14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
-    };
-
-static const mz_uint8 s_tdefl_small_dist_extra[512] =
-    {
-      0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
-      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7
-    };
-
-static const mz_uint8 s_tdefl_large_dist_sym[128] =
-    {
-      0, 0, 18, 19, 20, 20, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-      26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-      28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
-    };
-
-static const mz_uint8 s_tdefl_large_dist_extra[128] =
-    {
-      0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-      12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13
-    };
-
-/* Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted values. */
-typedef struct
-{
-    mz_uint16 m_key, m_sym_index;
-} tdefl_sym_freq;
-static tdefl_sym_freq *tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1)
-{
-    mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2];
-    tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1;
-    MZ_CLEAR_OBJ(hist);
-    for (i = 0; i < num_syms; i++)
-    {
-        mz_uint freq = pSyms0[i].m_key;
-        hist[freq & 0xFF]++;
-        hist[256 + ((freq >> 8) & 0xFF)]++;
-    }
-    while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256]))
-        total_passes--;
-    for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
-    {
-        const mz_uint32 *pHist = &hist[pass << 8];
-        mz_uint offsets[256], cur_ofs = 0;
-        for (i = 0; i < 256; i++)
-        {
-            offsets[i] = cur_ofs;
-            cur_ofs += pHist[i];
-        }
-        for (i = 0; i < num_syms; i++)
-            pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
-        {
-            tdefl_sym_freq *t = pCur_syms;
-            pCur_syms = pNew_syms;
-            pNew_syms = t;
-        }
-    }
-    return pCur_syms;
-}
-
-/* tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. */
-static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)
-{
-    int root, leaf, next, avbl, used, dpth;
-    if (n == 0)
-        return;
-    else if (n == 1)
-    {
-        A[0].m_key = 1;
-        return;
-    }
-    A[0].m_key += A[1].m_key;
-    root = 0;
-    leaf = 2;
-    for (next = 1; next < n - 1; next++)
-    {
-        if (leaf >= n || A[root].m_key < A[leaf].m_key)
-        {
-            A[next].m_key = A[root].m_key;
-            A[root++].m_key = (mz_uint16)next;
-        }
-        else
-            A[next].m_key = A[leaf++].m_key;
-        if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key))
-        {
-            A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key);
-            A[root++].m_key = (mz_uint16)next;
-        }
-        else
-            A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key);
-    }
-    A[n - 2].m_key = 0;
-    for (next = n - 3; next >= 0; next--)
-        A[next].m_key = A[A[next].m_key].m_key + 1;
-    avbl = 1;
-    used = dpth = 0;
-    root = n - 2;
-    next = n - 1;
-    while (avbl > 0)
-    {
-        while (root >= 0 && (int)A[root].m_key == dpth)
-        {
-            used++;
-            root--;
-        }
-        while (avbl > used)
-        {
-            A[next--].m_key = (mz_uint16)(dpth);
-            avbl--;
-        }
-        avbl = 2 * used;
-        dpth++;
-        used = 0;
-    }
-}
-
-/* Limits canonical Huffman code table's max code size. */
-enum
-{
-    TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32
-};
-static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
-{
-    int i;
-    mz_uint32 total = 0;
-    if (code_list_len <= 1)
-        return;
-    for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++)
-        pNum_codes[max_code_size] += pNum_codes[i];
-    for (i = max_code_size; i > 0; i--)
-        total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
-    while (total != (1UL << max_code_size))
-    {
-        pNum_codes[max_code_size]--;
-        for (i = max_code_size - 1; i > 0; i--)
-            if (pNum_codes[i])
-            {
-                pNum_codes[i]--;
-                pNum_codes[i + 1] += 2;
-                break;
-            }
-        total--;
-    }
-}
-
-static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
-{
-    int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE];
-    mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1];
-    MZ_CLEAR_OBJ(num_codes);
-    if (static_table)
-    {
-        for (i = 0; i < table_len; i++)
-            num_codes[d->m_huff_code_sizes[table_num][i]]++;
-    }
-    else
-    {
-        tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms;
-        int num_used_syms = 0;
-        const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0];
-        for (i = 0; i < table_len; i++)
-            if (pSym_count[i])
-            {
-                syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i];
-                syms0[num_used_syms++].m_sym_index = (mz_uint16)i;
-            }
-
-        pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1);
-        tdefl_calculate_minimum_redundancy(pSyms, num_used_syms);
-
-        for (i = 0; i < num_used_syms; i++)
-            num_codes[pSyms[i].m_key]++;
-
-        tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit);
-
-        MZ_CLEAR_OBJ(d->m_huff_code_sizes[table_num]);
-        MZ_CLEAR_OBJ(d->m_huff_codes[table_num]);
-        for (i = 1, j = num_used_syms; i <= code_size_limit; i++)
-            for (l = num_codes[i]; l > 0; l--)
-                d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i);
-    }
-
-    next_code[1] = 0;
-    for (j = 0, i = 2; i <= code_size_limit; i++)
-        next_code[i] = j = ((j + num_codes[i - 1]) << 1);
-
-    for (i = 0; i < table_len; i++)
-    {
-        mz_uint rev_code = 0, code, code_size;
-        if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0)
-            continue;
-        code = next_code[code_size]++;
-        for (l = code_size; l > 0; l--, code >>= 1)
-            rev_code = (rev_code << 1) | (code & 1);
-        d->m_huff_codes[table_num][i] = (mz_uint16)rev_code;
-    }
-}
-
-#define TDEFL_PUT_BITS(b, l)                                       \
-    do                                                             \
-    {                                                              \
-        mz_uint bits = b;                                          \
-        mz_uint len = l;                                           \
-        MZ_ASSERT(bits <= ((1U << len) - 1U));                     \
-        d->m_bit_buffer |= (bits << d->m_bits_in);                 \
-        d->m_bits_in += len;                                       \
-        while (d->m_bits_in >= 8)                                  \
-        {                                                          \
-            if (d->m_pOutput_buf < d->m_pOutput_buf_end)           \
-                *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \
-            d->m_bit_buffer >>= 8;                                 \
-            d->m_bits_in -= 8;                                     \
-        }                                                          \
-    }                                                              \
-    MZ_MACRO_END
-
-#define TDEFL_RLE_PREV_CODE_SIZE()                                                                                       \
-    {                                                                                                                    \
-        if (rle_repeat_count)                                                                                            \
-        {                                                                                                                \
-            if (rle_repeat_count < 3)                                                                                    \
-            {                                                                                                            \
-                d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \
-                while (rle_repeat_count--)                                                                               \
-                    packed_code_sizes[num_packed_code_sizes++] = prev_code_size;                                         \
-            }                                                                                                            \
-            else                                                                                                         \
-            {                                                                                                            \
-                d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1);                                        \
-                packed_code_sizes[num_packed_code_sizes++] = 16;                                                         \
-                packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3);                           \
-            }                                                                                                            \
-            rle_repeat_count = 0;                                                                                        \
-        }                                                                                                                \
-    }
-
-#define TDEFL_RLE_ZERO_CODE_SIZE()                                                         \
-    {                                                                                      \
-        if (rle_z_count)                                                                   \
-        {                                                                                  \
-            if (rle_z_count < 3)                                                           \
-            {                                                                              \
-                d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count);  \
-                while (rle_z_count--)                                                      \
-                    packed_code_sizes[num_packed_code_sizes++] = 0;                        \
-            }                                                                              \
-            else if (rle_z_count <= 10)                                                    \
-            {                                                                              \
-                d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1);          \
-                packed_code_sizes[num_packed_code_sizes++] = 17;                           \
-                packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3);  \
-            }                                                                              \
-            else                                                                           \
-            {                                                                              \
-                d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1);          \
-                packed_code_sizes[num_packed_code_sizes++] = 18;                           \
-                packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \
-            }                                                                              \
-            rle_z_count = 0;                                                               \
-        }                                                                                  \
-    }
-
-static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
-
-static void tdefl_start_dynamic_block(tdefl_compressor *d)
-{
-    int num_lit_codes, num_dist_codes, num_bit_lengths;
-    mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
-    mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF;
-
-    d->m_huff_count[0][256] = 1;
-
-    tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE);
-    tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE);
-
-    for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--)
-        if (d->m_huff_code_sizes[0][num_lit_codes - 1])
-            break;
-    for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--)
-        if (d->m_huff_code_sizes[1][num_dist_codes - 1])
-            break;
-
-    memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes);
-    memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes);
-    total_code_sizes_to_pack = num_lit_codes + num_dist_codes;
-    num_packed_code_sizes = 0;
-    rle_z_count = 0;
-    rle_repeat_count = 0;
-
-    memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2);
-    for (i = 0; i < total_code_sizes_to_pack; i++)
-    {
-        mz_uint8 code_size = code_sizes_to_pack[i];
-        if (!code_size)
-        {
-            TDEFL_RLE_PREV_CODE_SIZE();
-            if (++rle_z_count == 138)
-            {
-                TDEFL_RLE_ZERO_CODE_SIZE();
-            }
-        }
-        else
-        {
-            TDEFL_RLE_ZERO_CODE_SIZE();
-            if (code_size != prev_code_size)
-            {
-                TDEFL_RLE_PREV_CODE_SIZE();
-                d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1);
-                packed_code_sizes[num_packed_code_sizes++] = code_size;
-            }
-            else if (++rle_repeat_count == 6)
-            {
-                TDEFL_RLE_PREV_CODE_SIZE();
-            }
-        }
-        prev_code_size = code_size;
-    }
-    if (rle_repeat_count)
-    {
-        TDEFL_RLE_PREV_CODE_SIZE();
-    }
-    else
-    {
-        TDEFL_RLE_ZERO_CODE_SIZE();
-    }
-
-    tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE);
-
-    TDEFL_PUT_BITS(2, 2);
-
-    TDEFL_PUT_BITS(num_lit_codes - 257, 5);
-    TDEFL_PUT_BITS(num_dist_codes - 1, 5);
-
-    for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--)
-        if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]])
-            break;
-    num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1));
-    TDEFL_PUT_BITS(num_bit_lengths - 4, 4);
-    for (i = 0; (int)i < num_bit_lengths; i++)
-        TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3);
-
-    for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;)
-    {
-        mz_uint code = packed_code_sizes[packed_code_sizes_index++];
-        MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2);
-        TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]);
-        if (code >= 16)
-            TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]);
-    }
-}
-
-static void tdefl_start_static_block(tdefl_compressor *d)
-{
-    mz_uint i;
-    mz_uint8 *p = &d->m_huff_code_sizes[0][0];
-
-    for (i = 0; i <= 143; ++i)
-        *p++ = 8;
-    for (; i <= 255; ++i)
-        *p++ = 9;
-    for (; i <= 279; ++i)
-        *p++ = 7;
-    for (; i <= 287; ++i)
-        *p++ = 8;
-
-    memset(d->m_huff_code_sizes[1], 5, 32);
-
-    tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE);
-    tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE);
-
-    TDEFL_PUT_BITS(1, 2);
-}
-
-static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
-static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
-{
-    mz_uint flags;
-    mz_uint8 *pLZ_codes;
-    mz_uint8 *pOutput_buf = d->m_pOutput_buf;
-    mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf;
-    mz_uint64 bit_buffer = d->m_bit_buffer;
-    mz_uint bits_in = d->m_bits_in;
-
-#define TDEFL_PUT_BITS_FAST(b, l)                    \
-    {                                                \
-        bit_buffer |= (((mz_uint64)(b)) << bits_in); \
-        bits_in += (l);                              \
-    }
-
-    flags = 1;
-    for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1)
-    {
-        if (flags == 1)
-            flags = *pLZ_codes++ | 0x100;
-
-        if (flags & 1)
-        {
-            mz_uint s0, s1, n0, n1, sym, num_extra_bits;
-            mz_uint match_len = pLZ_codes[0], match_dist = *(const mz_uint16 *)(pLZ_codes + 1);
-            pLZ_codes += 3;
-
-            MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
-
-            /* This sequence coaxes MSVC into using cmov's vs. jmp's. */
-            s0 = s_tdefl_small_dist_sym[match_dist & 511];
-            n0 = s_tdefl_small_dist_extra[match_dist & 511];
-            s1 = s_tdefl_large_dist_sym[match_dist >> 8];
-            n1 = s_tdefl_large_dist_extra[match_dist >> 8];
-            sym = (match_dist < 512) ? s0 : s1;
-            num_extra_bits = (match_dist < 512) ? n0 : n1;
-
-            MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
-        }
-        else
-        {
-            mz_uint lit = *pLZ_codes++;
-            MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-            TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-
-            if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
-            {
-                flags >>= 1;
-                lit = *pLZ_codes++;
-                MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-                TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-
-                if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
-                {
-                    flags >>= 1;
-                    lit = *pLZ_codes++;
-                    MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-                    TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-                }
-            }
-        }
-
-        if (pOutput_buf >= d->m_pOutput_buf_end)
-            return MZ_FALSE;
-
-        *(mz_uint64 *)pOutput_buf = bit_buffer;
-        pOutput_buf += (bits_in >> 3);
-        bit_buffer >>= (bits_in & ~7);
-        bits_in &= 7;
-    }
-
-#undef TDEFL_PUT_BITS_FAST
-
-    d->m_pOutput_buf = pOutput_buf;
-    d->m_bits_in = 0;
-    d->m_bit_buffer = 0;
-
-    while (bits_in)
-    {
-        mz_uint32 n = MZ_MIN(bits_in, 16);
-        TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n);
-        bit_buffer >>= n;
-        bits_in -= n;
-    }
-
-    TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
-
-    return (d->m_pOutput_buf < d->m_pOutput_buf_end);
-}
-#else
-static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
-{
-    mz_uint flags;
-    mz_uint8 *pLZ_codes;
-
-    flags = 1;
-    for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1)
-    {
-        if (flags == 1)
-            flags = *pLZ_codes++ | 0x100;
-        if (flags & 1)
-        {
-            mz_uint sym, num_extra_bits;
-            mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8));
-            pLZ_codes += 3;
-
-            MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
-
-            if (match_dist < 512)
-            {
-                sym = s_tdefl_small_dist_sym[match_dist];
-                num_extra_bits = s_tdefl_small_dist_extra[match_dist];
-            }
-            else
-            {
-                sym = s_tdefl_large_dist_sym[match_dist >> 8];
-                num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8];
-            }
-            MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
-        }
-        else
-        {
-            mz_uint lit = *pLZ_codes++;
-            MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-            TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-        }
-    }
-
-    TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
-
-    return (d->m_pOutput_buf < d->m_pOutput_buf_end);
-}
-#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS */
-
-static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
-{
-    if (static_block)
-        tdefl_start_static_block(d);
-    else
-        tdefl_start_dynamic_block(d);
-    return tdefl_compress_lz_codes(d);
-}
-
-static int tdefl_flush_block(tdefl_compressor *d, int flush)
-{
-    mz_uint saved_bit_buf, saved_bits_in;
-    mz_uint8 *pSaved_output_buf;
-    mz_bool comp_block_succeeded = MZ_FALSE;
-    int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size;
-    mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf;
-
-    d->m_pOutput_buf = pOutput_buf_start;
-    d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16;
-
-    MZ_ASSERT(!d->m_output_flush_remaining);
-    d->m_output_flush_ofs = 0;
-    d->m_output_flush_remaining = 0;
-
-    *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left);
-    d->m_pLZ_code_buf -= (d->m_num_flags_left == 8);
-
-    if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index))
-    {
-        TDEFL_PUT_BITS(0x78, 8);
-        TDEFL_PUT_BITS(0x01, 8);
-    }
-
-    TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1);
-
-    pSaved_output_buf = d->m_pOutput_buf;
-    saved_bit_buf = d->m_bit_buffer;
-    saved_bits_in = d->m_bits_in;
-
-    if (!use_raw_block)
-        comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48));
-
-    /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */
-    if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) &&
-        ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size))
-    {
-        mz_uint i;
-        d->m_pOutput_buf = pSaved_output_buf;
-        d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
-        TDEFL_PUT_BITS(0, 2);
-        if (d->m_bits_in)
-        {
-            TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
-        }
-        for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF)
-        {
-            TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16);
-        }
-        for (i = 0; i < d->m_total_lz_bytes; ++i)
-        {
-            TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8);
-        }
-    }
-    /* Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes. */
-    else if (!comp_block_succeeded)
-    {
-        d->m_pOutput_buf = pSaved_output_buf;
-        d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
-        tdefl_compress_block(d, MZ_TRUE);
-    }
-
-    if (flush)
-    {
-        if (flush == TDEFL_FINISH)
-        {
-            if (d->m_bits_in)
-            {
-                TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
-            }
-            if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER)
-            {
-                mz_uint i, a = d->m_adler32;
-                for (i = 0; i < 4; i++)
-                {
-                    TDEFL_PUT_BITS((a >> 24) & 0xFF, 8);
-                    a <<= 8;
-                }
-            }
-        }
-        else
-        {
-            mz_uint i, z = 0;
-            TDEFL_PUT_BITS(0, 3);
-            if (d->m_bits_in)
-            {
-                TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
-            }
-            for (i = 2; i; --i, z ^= 0xFFFF)
-            {
-                TDEFL_PUT_BITS(z & 0xFFFF, 16);
-            }
-        }
-    }
-
-    MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end);
-
-    memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
-    memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
-
-    d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
-    d->m_pLZ_flags = d->m_lz_code_buf;
-    d->m_num_flags_left = 8;
-    d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes;
-    d->m_total_lz_bytes = 0;
-    d->m_block_index++;
-
-    if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0)
-    {
-        if (d->m_pPut_buf_func)
-        {
-            *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
-            if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user))
-                return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED);
-        }
-        else if (pOutput_buf_start == d->m_output_buf)
-        {
-            int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs));
-            memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy);
-            d->m_out_buf_ofs += bytes_to_copy;
-            if ((n -= bytes_to_copy) != 0)
-            {
-                d->m_output_flush_ofs = bytes_to_copy;
-                d->m_output_flush_remaining = n;
-            }
-        }
-        else
-        {
-            d->m_out_buf_ofs += n;
-        }
-    }
-
-    return d->m_output_flush_remaining;
-}
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
-#ifdef MINIZ_UNALIGNED_USE_MEMCPY
-static inline mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8* p)
-{
-	mz_uint16 ret;
-	memcpy(&ret, p, sizeof(mz_uint16));
-	return ret;
-}
-static inline mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16* p)
-{
-	mz_uint16 ret;
-	memcpy(&ret, p, sizeof(mz_uint16));
-	return ret;
-}
-#else
-#define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p)
-#define TDEFL_READ_UNALIGNED_WORD2(p) *(const mz_uint16 *)(p)
-#endif
-static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
-{
-    mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
-    mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
-    const mz_uint16 *s = (const mz_uint16 *)(d->m_dict + pos), *p, *q;
-    mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD2(s);
-    MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN);
-    if (max_match_len <= match_len)
-        return;
-    for (;;)
-    {
-        for (;;)
-        {
-            if (--num_probes_left == 0)
-                return;
-#define TDEFL_PROBE                                                                             \
-    next_probe_pos = d->m_next[probe_pos];                                                      \
-    if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \
-        return;                                                                                 \
-    probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK;                                       \
-    if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01)                \
-        break;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-        }
-        if (!dist)
-            break;
-        q = (const mz_uint16 *)(d->m_dict + probe_pos);
-        if (TDEFL_READ_UNALIGNED_WORD2(q) != s01)
-            continue;
-        p = s;
-        probe_len = 32;
-        do
-        {
-        } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&
-                 (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));
-        if (!probe_len)
-        {
-            *pMatch_dist = dist;
-            *pMatch_len = MZ_MIN(max_match_len, (mz_uint)TDEFL_MAX_MATCH_LEN);
-            break;
-        }
-        else if ((probe_len = ((mz_uint)(p - s) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q)) > match_len)
-        {
-            *pMatch_dist = dist;
-            if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == max_match_len)
-                break;
-            c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]);
-        }
-    }
-}
-#else
-static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
-{
-    mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
-    mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
-    const mz_uint8 *s = d->m_dict + pos, *p, *q;
-    mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1];
-    MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN);
-    if (max_match_len <= match_len)
-        return;
-    for (;;)
-    {
-        for (;;)
-        {
-            if (--num_probes_left == 0)
-                return;
-#define TDEFL_PROBE                                                                               \
-    next_probe_pos = d->m_next[probe_pos];                                                        \
-    if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist))   \
-        return;                                                                                   \
-    probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK;                                         \
-    if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \
-        break;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-        }
-        if (!dist)
-            break;
-        p = s;
-        q = d->m_dict + probe_pos;
-        for (probe_len = 0; probe_len < max_match_len; probe_len++)
-            if (*p++ != *q++)
-                break;
-        if (probe_len > match_len)
-        {
-            *pMatch_dist = dist;
-            if ((*pMatch_len = match_len = probe_len) == max_match_len)
-                return;
-            c0 = d->m_dict[pos + match_len];
-            c1 = d->m_dict[pos + match_len - 1];
-        }
-    }
-}
-#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES */
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
-static mz_bool tdefl_compress_fast(tdefl_compressor *d)
-{
-    /* Faster, minimally featured LZRW1-style match+parse loop with better register utilization. Intended for applications where raw throughput is valued more highly than ratio. */
-    mz_uint lookahead_pos = d->m_lookahead_pos, lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, total_lz_bytes = d->m_total_lz_bytes, num_flags_left = d->m_num_flags_left;
-    mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags;
-    mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
-
-    while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size)))
-    {
-        const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;
-        mz_uint dst_pos = (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
-        mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size);
-        d->m_src_buf_left -= num_bytes_to_process;
-        lookahead_size += num_bytes_to_process;
-
-        while (num_bytes_to_process)
-        {
-            mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process);
-            memcpy(d->m_dict + dst_pos, d->m_pSrc, n);
-            if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
-                memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos));
-            d->m_pSrc += n;
-            dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK;
-            num_bytes_to_process -= n;
-        }
-
-        dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size);
-        if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE))
-            break;
-
-        while (lookahead_size >= 4)
-        {
-            mz_uint cur_match_dist, cur_match_len = 1;
-            mz_uint8 *pCur_dict = d->m_dict + cur_pos;
-            mz_uint first_trigram = (*(const mz_uint32 *)pCur_dict) & 0xFFFFFF;
-            mz_uint hash = (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & TDEFL_LEVEL1_HASH_SIZE_MASK;
-            mz_uint probe_pos = d->m_hash[hash];
-            d->m_hash[hash] = (mz_uint16)lookahead_pos;
-
-            if (((cur_match_dist = (mz_uint16)(lookahead_pos - probe_pos)) <= dict_size) && ((*(const mz_uint32 *)(d->m_dict + (probe_pos &= TDEFL_LZ_DICT_SIZE_MASK)) & 0xFFFFFF) == first_trigram))
-            {
-                const mz_uint16 *p = (const mz_uint16 *)pCur_dict;
-                const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos);
-                mz_uint32 probe_len = 32;
-                do
-                {
-                } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&
-                         (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));
-                cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q);
-                if (!probe_len)
-                    cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0;
-
-                if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || ((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)))
-                {
-                    cur_match_len = 1;
-                    *pLZ_code_buf++ = (mz_uint8)first_trigram;
-                    *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
-                    d->m_huff_count[0][(mz_uint8)first_trigram]++;
-                }
-                else
-                {
-                    mz_uint32 s0, s1;
-                    cur_match_len = MZ_MIN(cur_match_len, lookahead_size);
-
-                    MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 1) && (cur_match_dist <= TDEFL_LZ_DICT_SIZE));
-
-                    cur_match_dist--;
-
-                    pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
-                    *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
-                    pLZ_code_buf += 3;
-                    *pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80);
-
-                    s0 = s_tdefl_small_dist_sym[cur_match_dist & 511];
-                    s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8];
-                    d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++;
-
-                    d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++;
-                }
-            }
-            else
-            {
-                *pLZ_code_buf++ = (mz_uint8)first_trigram;
-                *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
-                d->m_huff_count[0][(mz_uint8)first_trigram]++;
-            }
-
-            if (--num_flags_left == 0)
-            {
-                num_flags_left = 8;
-                pLZ_flags = pLZ_code_buf++;
-            }
-
-            total_lz_bytes += cur_match_len;
-            lookahead_pos += cur_match_len;
-            dict_size = MZ_MIN(dict_size + cur_match_len, (mz_uint)TDEFL_LZ_DICT_SIZE);
-            cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK;
-            MZ_ASSERT(lookahead_size >= cur_match_len);
-            lookahead_size -= cur_match_len;
-
-            if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
-            {
-                int n;
-                d->m_lookahead_pos = lookahead_pos;
-                d->m_lookahead_size = lookahead_size;
-                d->m_dict_size = dict_size;
-                d->m_total_lz_bytes = total_lz_bytes;
-                d->m_pLZ_code_buf = pLZ_code_buf;
-                d->m_pLZ_flags = pLZ_flags;
-                d->m_num_flags_left = num_flags_left;
-                if ((n = tdefl_flush_block(d, 0)) != 0)
-                    return (n < 0) ? MZ_FALSE : MZ_TRUE;
-                total_lz_bytes = d->m_total_lz_bytes;
-                pLZ_code_buf = d->m_pLZ_code_buf;
-                pLZ_flags = d->m_pLZ_flags;
-                num_flags_left = d->m_num_flags_left;
-            }
-        }
-
-        while (lookahead_size)
-        {
-            mz_uint8 lit = d->m_dict[cur_pos];
-
-            total_lz_bytes++;
-            *pLZ_code_buf++ = lit;
-            *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
-            if (--num_flags_left == 0)
-            {
-                num_flags_left = 8;
-                pLZ_flags = pLZ_code_buf++;
-            }
-
-            d->m_huff_count[0][lit]++;
-
-            lookahead_pos++;
-            dict_size = MZ_MIN(dict_size + 1, (mz_uint)TDEFL_LZ_DICT_SIZE);
-            cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
-            lookahead_size--;
-
-            if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
-            {
-                int n;
-                d->m_lookahead_pos = lookahead_pos;
-                d->m_lookahead_size = lookahead_size;
-                d->m_dict_size = dict_size;
-                d->m_total_lz_bytes = total_lz_bytes;
-                d->m_pLZ_code_buf = pLZ_code_buf;
-                d->m_pLZ_flags = pLZ_flags;
-                d->m_num_flags_left = num_flags_left;
-                if ((n = tdefl_flush_block(d, 0)) != 0)
-                    return (n < 0) ? MZ_FALSE : MZ_TRUE;
-                total_lz_bytes = d->m_total_lz_bytes;
-                pLZ_code_buf = d->m_pLZ_code_buf;
-                pLZ_flags = d->m_pLZ_flags;
-                num_flags_left = d->m_num_flags_left;
-            }
-        }
-    }
-
-    d->m_lookahead_pos = lookahead_pos;
-    d->m_lookahead_size = lookahead_size;
-    d->m_dict_size = dict_size;
-    d->m_total_lz_bytes = total_lz_bytes;
-    d->m_pLZ_code_buf = pLZ_code_buf;
-    d->m_pLZ_flags = pLZ_flags;
-    d->m_num_flags_left = num_flags_left;
-    return MZ_TRUE;
-}
-#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
-
-static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
-{
-    d->m_total_lz_bytes++;
-    *d->m_pLZ_code_buf++ = lit;
-    *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1);
-    if (--d->m_num_flags_left == 0)
-    {
-        d->m_num_flags_left = 8;
-        d->m_pLZ_flags = d->m_pLZ_code_buf++;
-    }
-    d->m_huff_count[0][lit]++;
-}
-
-static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
-{
-    mz_uint32 s0, s1;
-
-    MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE));
-
-    d->m_total_lz_bytes += match_len;
-
-    d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN);
-
-    match_dist -= 1;
-    d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF);
-    d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8);
-    d->m_pLZ_code_buf += 3;
-
-    *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80);
-    if (--d->m_num_flags_left == 0)
-    {
-        d->m_num_flags_left = 8;
-        d->m_pLZ_flags = d->m_pLZ_code_buf++;
-    }
-
-    s0 = s_tdefl_small_dist_sym[match_dist & 511];
-    s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127];
-    d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++;
-
-    if (match_len >= TDEFL_MIN_MATCH_LEN)
-        d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++;
-}
-
-static mz_bool tdefl_compress_normal(tdefl_compressor *d)
-{
-    const mz_uint8 *pSrc = d->m_pSrc;
-    size_t src_buf_left = d->m_src_buf_left;
-    tdefl_flush flush = d->m_flush;
-
-    while ((src_buf_left) || ((flush) && (d->m_lookahead_size)))
-    {
-        mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
-        /* Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN. */
-        if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1))
-        {
-            mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2;
-            mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK];
-            mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size);
-            const mz_uint8 *pSrc_end = pSrc + num_bytes_to_process;
-            src_buf_left -= num_bytes_to_process;
-            d->m_lookahead_size += num_bytes_to_process;
-            while (pSrc != pSrc_end)
-            {
-                mz_uint8 c = *pSrc++;
-                d->m_dict[dst_pos] = c;
-                if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
-                    d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
-                hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
-                d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash];
-                d->m_hash[hash] = (mz_uint16)(ins_pos);
-                dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
-                ins_pos++;
-            }
-        }
-        else
-        {
-            while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
-            {
-                mz_uint8 c = *pSrc++;
-                mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
-                src_buf_left--;
-                d->m_dict[dst_pos] = c;
-                if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
-                    d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
-                if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN)
-                {
-                    mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2;
-                    mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
-                    d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash];
-                    d->m_hash[hash] = (mz_uint16)(ins_pos);
-                }
-            }
-        }
-        d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size);
-        if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
-            break;
-
-        /* Simple lazy/greedy parsing state machine. */
-        len_to_move = 1;
-        cur_match_dist = 0;
-        cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1);
-        cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
-        if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS))
-        {
-            if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))
-            {
-                mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK];
-                cur_match_len = 0;
-                while (cur_match_len < d->m_lookahead_size)
-                {
-                    if (d->m_dict[cur_pos + cur_match_len] != c)
-                        break;
-                    cur_match_len++;
-                }
-                if (cur_match_len < TDEFL_MIN_MATCH_LEN)
-                    cur_match_len = 0;
-                else
-                    cur_match_dist = 1;
-            }
-        }
-        else
-        {
-            tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len);
-        }
-        if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5)))
-        {
-            cur_match_dist = cur_match_len = 0;
-        }
-        if (d->m_saved_match_len)
-        {
-            if (cur_match_len > d->m_saved_match_len)
-            {
-                tdefl_record_literal(d, (mz_uint8)d->m_saved_lit);
-                if (cur_match_len >= 128)
-                {
-                    tdefl_record_match(d, cur_match_len, cur_match_dist);
-                    d->m_saved_match_len = 0;
-                    len_to_move = cur_match_len;
-                }
-                else
-                {
-                    d->m_saved_lit = d->m_dict[cur_pos];
-                    d->m_saved_match_dist = cur_match_dist;
-                    d->m_saved_match_len = cur_match_len;
-                }
-            }
-            else
-            {
-                tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist);
-                len_to_move = d->m_saved_match_len - 1;
-                d->m_saved_match_len = 0;
-            }
-        }
-        else if (!cur_match_dist)
-            tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]);
-        else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128))
-        {
-            tdefl_record_match(d, cur_match_len, cur_match_dist);
-            len_to_move = cur_match_len;
-        }
-        else
-        {
-            d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)];
-            d->m_saved_match_dist = cur_match_dist;
-            d->m_saved_match_len = cur_match_len;
-        }
-        /* Move the lookahead forward by len_to_move bytes. */
-        d->m_lookahead_pos += len_to_move;
-        MZ_ASSERT(d->m_lookahead_size >= len_to_move);
-        d->m_lookahead_size -= len_to_move;
-        d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE);
-        /* Check if it's time to flush the current LZ codes to the internal output buffer. */
-        if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) ||
-            ((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))))
-        {
-            int n;
-            d->m_pSrc = pSrc;
-            d->m_src_buf_left = src_buf_left;
-            if ((n = tdefl_flush_block(d, 0)) != 0)
-                return (n < 0) ? MZ_FALSE : MZ_TRUE;
-        }
-    }
-
-    d->m_pSrc = pSrc;
-    d->m_src_buf_left = src_buf_left;
-    return MZ_TRUE;
-}
-
-static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
-{
-    if (d->m_pIn_buf_size)
-    {
-        *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
-    }
-
-    if (d->m_pOut_buf_size)
-    {
-        size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
-        memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
-        d->m_output_flush_ofs += (mz_uint)n;
-        d->m_output_flush_remaining -= (mz_uint)n;
-        d->m_out_buf_ofs += n;
-
-        *d->m_pOut_buf_size = d->m_out_buf_ofs;
-    }
-
-    return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
-}
-
-tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
-{
-    if (!d)
-    {
-        if (pIn_buf_size)
-            *pIn_buf_size = 0;
-        if (pOut_buf_size)
-            *pOut_buf_size = 0;
-        return TDEFL_STATUS_BAD_PARAM;
-    }
-
-    d->m_pIn_buf = pIn_buf;
-    d->m_pIn_buf_size = pIn_buf_size;
-    d->m_pOut_buf = pOut_buf;
-    d->m_pOut_buf_size = pOut_buf_size;
-    d->m_pSrc = (const mz_uint8 *)(pIn_buf);
-    d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
-    d->m_out_buf_ofs = 0;
-    d->m_flush = flush;
-
-    if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
-        (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))
-    {
-        if (pIn_buf_size)
-            *pIn_buf_size = 0;
-        if (pOut_buf_size)
-            *pOut_buf_size = 0;
-        return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM);
-    }
-    d->m_wants_to_finish |= (flush == TDEFL_FINISH);
-
-    if ((d->m_output_flush_remaining) || (d->m_finished))
-        return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
-    if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
-        ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
-        ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0))
-    {
-        if (!tdefl_compress_fast(d))
-            return d->m_prev_return_status;
-    }
-    else
-#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
-    {
-        if (!tdefl_compress_normal(d))
-            return d->m_prev_return_status;
-    }
-
-    if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
-        d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
-
-    if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
-    {
-        if (tdefl_flush_block(d, flush) < 0)
-            return d->m_prev_return_status;
-        d->m_finished = (flush == TDEFL_FINISH);
-        if (flush == TDEFL_FULL_FLUSH)
-        {
-            MZ_CLEAR_OBJ(d->m_hash);
-            MZ_CLEAR_OBJ(d->m_next);
-            d->m_dict_size = 0;
-        }
-    }
-
-    return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
-}
-
-tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
-{
-    MZ_ASSERT(d->m_pPut_buf_func);
-    return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
-}
-
-tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
-{
-    d->m_pPut_buf_func = pPut_buf_func;
-    d->m_pPut_buf_user = pPut_buf_user;
-    d->m_flags = (mz_uint)(flags);
-    d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3;
-    d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
-    d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
-    if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
-        MZ_CLEAR_OBJ(d->m_hash);
-    d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
-    d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
-    d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
-    d->m_pLZ_flags = d->m_lz_code_buf;
-    d->m_num_flags_left = 8;
-    d->m_pOutput_buf = d->m_output_buf;
-    d->m_pOutput_buf_end = d->m_output_buf;
-    d->m_prev_return_status = TDEFL_STATUS_OKAY;
-    d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0;
-    d->m_adler32 = 1;
-    d->m_pIn_buf = NULL;
-    d->m_pOut_buf = NULL;
-    d->m_pIn_buf_size = NULL;
-    d->m_pOut_buf_size = NULL;
-    d->m_flush = TDEFL_NO_FLUSH;
-    d->m_pSrc = NULL;
-    d->m_src_buf_left = 0;
-    d->m_out_buf_ofs = 0;
-    if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
-        MZ_CLEAR_OBJ(d->m_dict);
-    memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
-    memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
-    return TDEFL_STATUS_OKAY;
-}
-
-tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)
-{
-    return d->m_prev_return_status;
-}
-
-mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
-{
-    return d->m_adler32;
-}
-
-mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
-{
-    tdefl_compressor *pComp;
-    mz_bool succeeded;
-    if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
-        return MZ_FALSE;
-    pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
-    if (!pComp)
-        return MZ_FALSE;
-    succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
-    succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
-    MZ_FREE(pComp);
-    return succeeded;
-}
-
-typedef struct
-{
-    size_t m_size, m_capacity;
-    mz_uint8 *m_pBuf;
-    mz_bool m_expandable;
-} tdefl_output_buffer;
-
-static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
-{
-    tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
-    size_t new_size = p->m_size + len;
-    if (new_size > p->m_capacity)
-    {
-        size_t new_capacity = p->m_capacity;
-        mz_uint8 *pNew_buf;
-        if (!p->m_expandable)
-            return MZ_FALSE;
-        do
-        {
-            new_capacity = MZ_MAX(128U, new_capacity << 1U);
-        } while (new_size > new_capacity);
-        pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity);
-        if (!pNew_buf)
-            return MZ_FALSE;
-        p->m_pBuf = pNew_buf;
-        p->m_capacity = new_capacity;
-    }
-    memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len);
-    p->m_size = new_size;
-    return MZ_TRUE;
-}
-
-void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
-{
-    tdefl_output_buffer out_buf;
-    MZ_CLEAR_OBJ(out_buf);
-    if (!pOut_len)
-        return MZ_FALSE;
-    else
-        *pOut_len = 0;
-    out_buf.m_expandable = MZ_TRUE;
-    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
-        return NULL;
-    *pOut_len = out_buf.m_size;
-    return out_buf.m_pBuf;
-}
-
-size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
-{
-    tdefl_output_buffer out_buf;
-    MZ_CLEAR_OBJ(out_buf);
-    if (!pOut_buf)
-        return 0;
-    out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
-    out_buf.m_capacity = out_buf_len;
-    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
-        return 0;
-    return out_buf.m_size;
-}
-
-static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
-
-/* level may actually range from [0,10] (10 is a "hidden" max level, where we want a bit more compression and it's fine if throughput to fall off a cliff on some files). */
-mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
-{
-    mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
-    if (window_bits > 0)
-        comp_flags |= TDEFL_WRITE_ZLIB_HEADER;
-
-    if (!level)
-        comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
-    else if (strategy == MZ_FILTERED)
-        comp_flags |= TDEFL_FILTER_MATCHES;
-    else if (strategy == MZ_HUFFMAN_ONLY)
-        comp_flags &= ~TDEFL_MAX_PROBES_MASK;
-    else if (strategy == MZ_FIXED)
-        comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
-    else if (strategy == MZ_RLE)
-        comp_flags |= TDEFL_RLE_MATCHES;
-
-    return comp_flags;
-}
-
-#ifdef _MSC_VER
-//#pragma warning(push)
-//#pragma warning(disable : 4204) /* nonstandard extension used : non-constant aggregate initializer (also supported by GNU C and C99, so no big deal) */
-#endif
-
-/* Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299, more context at
- http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/.
- This is actually a modification of Alex's original code so PNG files generated by this function pass pngcheck. */
-void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip)
-{
-    /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined. */
-    static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
-    tdefl_compressor *pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
-    tdefl_output_buffer out_buf;
-    int i, bpl = w * num_chans, y, z;
-    mz_uint32 c;
-    *pLen_out = 0;
-    if (!pComp)
-        return NULL;
-    MZ_CLEAR_OBJ(out_buf);
-    out_buf.m_expandable = MZ_TRUE;
-    out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h);
-    if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity)))
-    {
-        MZ_FREE(pComp);
-        return NULL;
-    }
-    /* write dummy header */
-    for (z = 41; z; --z)
-        tdefl_output_buffer_putter(&z, 1, &out_buf);
-    /* compress image data */
-    tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER);
-    for (y = 0; y < h; ++y)
-    {
-        tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH);
-        tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH);
-    }
-    if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE)
-    {
-        MZ_FREE(pComp);
-        MZ_FREE(out_buf.m_pBuf);
-        return NULL;
-    }
-    /* write real header */
-    *pLen_out = out_buf.m_size - 41;
-    {
-        static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };
-        mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d,
-                                0x0a, 0x1a, 0x0a, 0x00, 0x00,
-                                0x00, 0x0d, 0x49, 0x48, 0x44,
-                                0x52, 0x00, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x00, 0x00, 0x08,
-                                0x00, 0x00, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x49, 0x44, 0x41,
-                                0x54 };
-        pnghdr[18] = (mz_uint8)(w >> 8);
-        pnghdr[19] = (mz_uint8)w;
-        pnghdr[22] = (mz_uint8)(h >> 8);
-        pnghdr[23] = (mz_uint8)h;
-        pnghdr[25] = chans[num_chans];
-        pnghdr[33] = (mz_uint8)(*pLen_out >> 24);
-        pnghdr[34] = (mz_uint8)(*pLen_out >> 16);
-        pnghdr[35] = (mz_uint8)(*pLen_out >> 8);
-        pnghdr[36] = (mz_uint8)*pLen_out;
-        c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17);
-        for (i = 0; i < 4; ++i, c <<= 8)
-            ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24);
-        memcpy(out_buf.m_pBuf, pnghdr, 41);
-    }
-    /* write footer (IDAT CRC-32, followed by IEND chunk) */
-    if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf))
-    {
-        *pLen_out = 0;
-        MZ_FREE(pComp);
-        MZ_FREE(out_buf.m_pBuf);
-        return NULL;
-    }
-    c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, *pLen_out + 4);
-    for (i = 0; i < 4; ++i, c <<= 8)
-        (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24);
-    /* compute final size of file, grab compressed data buffer and return */
-    *pLen_out += 57;
-    MZ_FREE(pComp);
-    return out_buf.m_pBuf;
-}
-void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out)
-{
-    /* Level 6 corresponds to TDEFL_DEFAULT_MAX_PROBES or MZ_DEFAULT_LEVEL (but we can't depend on MZ_DEFAULT_LEVEL being available in case the zlib API's where #defined out) */
-    return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE);
-}
-
-/* Allocate the tdefl_compressor and tinfl_decompressor structures in C so that */
-/* non-C language bindings to tdefL_ and tinfl_ API don't need to worry about */
-/* structure size and allocation mechanism. */
-tdefl_compressor *tdefl_compressor_alloc()
-{
-    return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
-}
-
-void tdefl_compressor_free(tdefl_compressor *pComp)
-{
-    MZ_FREE(pComp);
-}
-
-#ifdef _MSC_VER
-//#pragma warning(pop)
-#endif
-
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- **************************************************************************/
-
-
-
-
-/* ------------------- Low-level Decompression (completely independent from all compression API's) */
-
-#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
-#define TINFL_MEMSET(p, c, l) memset(p, c, l)
-
-#define TINFL_CR_BEGIN  \
-    switch (r->m_state) \
-    {                   \
-        case 0:
-#define TINFL_CR_RETURN(state_index, result) \
-    do                                       \
-    {                                        \
-        status = result;                     \
-        r->m_state = state_index;            \
-        goto common_exit;                    \
-        case state_index:;                   \
-    }                                        \
-    MZ_MACRO_END
-#define TINFL_CR_RETURN_FOREVER(state_index, result) \
-    do                                               \
-    {                                                \
-        for (;;)                                     \
-        {                                            \
-            TINFL_CR_RETURN(state_index, result);    \
-        }                                            \
-    }                                                \
-    MZ_MACRO_END
-#define TINFL_CR_FINISH }
-
-#define TINFL_GET_BYTE(state_index, c)                                                                                                                           \
-    do                                                                                                                                                           \
-    {                                                                                                                                                            \
-        while (pIn_buf_cur >= pIn_buf_end)                                                                                                                       \
-        {                                                                                                                                                        \
-            TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \
-        }                                                                                                                                                        \
-        c = *pIn_buf_cur++;                                                                                                                                      \
-    }                                                                                                                                                            \
-    MZ_MACRO_END
-
-#define TINFL_NEED_BITS(state_index, n)                \
-    do                                                 \
-    {                                                  \
-        mz_uint c;                                     \
-        TINFL_GET_BYTE(state_index, c);                \
-        bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \
-        num_bits += 8;                                 \
-    } while (num_bits < (mz_uint)(n))
-#define TINFL_SKIP_BITS(state_index, n)      \
-    do                                       \
-    {                                        \
-        if (num_bits < (mz_uint)(n))         \
-        {                                    \
-            TINFL_NEED_BITS(state_index, n); \
-        }                                    \
-        bit_buf >>= (n);                     \
-        num_bits -= (n);                     \
-    }                                        \
-    MZ_MACRO_END
-#define TINFL_GET_BITS(state_index, b, n)    \
-    do                                       \
-    {                                        \
-        if (num_bits < (mz_uint)(n))         \
-        {                                    \
-            TINFL_NEED_BITS(state_index, n); \
-        }                                    \
-        b = bit_buf & ((1 << (n)) - 1);      \
-        bit_buf >>= (n);                     \
-        num_bits -= (n);                     \
-    }                                        \
-    MZ_MACRO_END
-
-/* TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2. */
-/* It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a */
-/* Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the */
-/* bit buffer contains >=15 bits (deflate's max. Huffman code size). */
-#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff)                             \
-    do                                                                         \
-    {                                                                          \
-        temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)];     \
-        if (temp >= 0)                                                         \
-        {                                                                      \
-            code_len = temp >> 9;                                              \
-            if ((code_len) && (num_bits >= code_len))                          \
-                break;                                                         \
-        }                                                                      \
-        else if (num_bits > TINFL_FAST_LOOKUP_BITS)                            \
-        {                                                                      \
-            code_len = TINFL_FAST_LOOKUP_BITS;                                 \
-            do                                                                 \
-            {                                                                  \
-                temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
-            } while ((temp < 0) && (num_bits >= (code_len + 1)));              \
-            if (temp >= 0)                                                     \
-                break;                                                         \
-        }                                                                      \
-        TINFL_GET_BYTE(state_index, c);                                        \
-        bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                         \
-        num_bits += 8;                                                         \
-    } while (num_bits < 15);
-
-/* TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read */
-/* beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully */
-/* decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32. */
-/* The slow path is only executed at the very end of the input buffer. */
-/* v1.16: The original macro handled the case at the very end of the passed-in input buffer, but we also need to handle the case where the user passes in 1+zillion bytes */
-/* following the deflate data and our non-conservative read-ahead path won't kick in here on this code. This is much trickier. */
-#define TINFL_HUFF_DECODE(state_index, sym, pHuff)                                                                                  \
-    do                                                                                                                              \
-    {                                                                                                                               \
-        int temp;                                                                                                                   \
-        mz_uint code_len, c;                                                                                                        \
-        if (num_bits < 15)                                                                                                          \
-        {                                                                                                                           \
-            if ((pIn_buf_end - pIn_buf_cur) < 2)                                                                                    \
-            {                                                                                                                       \
-                TINFL_HUFF_BITBUF_FILL(state_index, pHuff);                                                                         \
-            }                                                                                                                       \
-            else                                                                                                                    \
-            {                                                                                                                       \
-                bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \
-                pIn_buf_cur += 2;                                                                                                   \
-                num_bits += 16;                                                                                                     \
-            }                                                                                                                       \
-        }                                                                                                                           \
-        if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)                                               \
-            code_len = temp >> 9, temp &= 511;                                                                                      \
-        else                                                                                                                        \
-        {                                                                                                                           \
-            code_len = TINFL_FAST_LOOKUP_BITS;                                                                                      \
-            do                                                                                                                      \
-            {                                                                                                                       \
-                temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)];                                                      \
-            } while (temp < 0);                                                                                                     \
-        }                                                                                                                           \
-        sym = temp;                                                                                                                 \
-        bit_buf >>= code_len;                                                                                                       \
-        num_bits -= code_len;                                                                                                       \
-    }                                                                                                                               \
-    MZ_MACRO_END
-
-tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)
-{
-    static const int s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 };
-    static const int s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 };
-    static const int s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 };
-    static const int s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
-    static const mz_uint8 s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
-    static const int s_min_table_sizes[3] = { 257, 1, 4 };
-
-    tinfl_status status = TINFL_STATUS_FAILED;
-    mz_uint32 num_bits, dist, counter, num_extra;
-    tinfl_bit_buf_t bit_buf;
-    const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
-    mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
-    size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
-
-    /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */
-    if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))
-    {
-        *pIn_buf_size = *pOut_buf_size = 0;
-        return TINFL_STATUS_BAD_PARAM;
-    }
-
-    num_bits = r->m_num_bits;
-    bit_buf = r->m_bit_buf;
-    dist = r->m_dist;
-    counter = r->m_counter;
-    num_extra = r->m_num_extra;
-    dist_from_out_buf_start = r->m_dist_from_out_buf_start;
-    TINFL_CR_BEGIN
-
-    bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0;
-    r->m_z_adler32 = r->m_check_adler32 = 1;
-    if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
-    {
-        TINFL_GET_BYTE(1, r->m_zhdr0);
-        TINFL_GET_BYTE(2, r->m_zhdr1);
-        counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
-        if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
-            counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (r->m_zhdr0 >> 4)))));
-        if (counter)
-        {
-            TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED);
-        }
-    }
-
-    do
-    {
-        TINFL_GET_BITS(3, r->m_final, 3);
-        r->m_type = r->m_final >> 1;
-        if (r->m_type == 0)
-        {
-            TINFL_SKIP_BITS(5, num_bits & 7);
-            for (counter = 0; counter < 4; ++counter)
-            {
-                if (num_bits)
-                    TINFL_GET_BITS(6, r->m_raw_header[counter], 8);
-                else
-                    TINFL_GET_BYTE(7, r->m_raw_header[counter]);
-            }
-            if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8))))
-            {
-                TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED);
-            }
-            while ((counter) && (num_bits))
-            {
-                TINFL_GET_BITS(51, dist, 8);
-                while (pOut_buf_cur >= pOut_buf_end)
-                {
-                    TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT);
-                }
-                *pOut_buf_cur++ = (mz_uint8)dist;
-                counter--;
-            }
-            while (counter)
-            {
-                size_t n;
-                while (pOut_buf_cur >= pOut_buf_end)
-                {
-                    TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT);
-                }
-                while (pIn_buf_cur >= pIn_buf_end)
-                {
-                    TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);
-                }
-                n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
-                TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n);
-                pIn_buf_cur += n;
-                pOut_buf_cur += n;
-                counter -= (mz_uint)n;
-            }
-        }
-        else if (r->m_type == 3)
-        {
-            TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
-        }
-        else
-        {
-            if (r->m_type == 1)
-            {
-                mz_uint8 *p = r->m_tables[0].m_code_size;
-                mz_uint i;
-                r->m_table_sizes[0] = 288;
-                r->m_table_sizes[1] = 32;
-                TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32);
-                for (i = 0; i <= 143; ++i)
-                    *p++ = 8;
-                for (; i <= 255; ++i)
-                    *p++ = 9;
-                for (; i <= 279; ++i)
-                    *p++ = 7;
-                for (; i <= 287; ++i)
-                    *p++ = 8;
-            }
-            else
-            {
-                for (counter = 0; counter < 3; counter++)
-                {
-                    TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]);
-                    r->m_table_sizes[counter] += s_min_table_sizes[counter];
-                }
-                MZ_CLEAR_OBJ(r->m_tables[2].m_code_size);
-                for (counter = 0; counter < r->m_table_sizes[2]; counter++)
-                {
-                    mz_uint s;
-                    TINFL_GET_BITS(14, s, 3);
-                    r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s;
-                }
-                r->m_table_sizes[2] = 19;
-            }
-            for (; (int)r->m_type >= 0; r->m_type--)
-            {
-                int tree_next, tree_cur;
-                tinfl_huff_table *pTable;
-                mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
-                pTable = &r->m_tables[r->m_type];
-                MZ_CLEAR_OBJ(total_syms);
-                MZ_CLEAR_OBJ(pTable->m_look_up);
-                MZ_CLEAR_OBJ(pTable->m_tree);
-                for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
-                    total_syms[pTable->m_code_size[i]]++;
-                used_syms = 0, total = 0;
-                next_code[0] = next_code[1] = 0;
-                for (i = 1; i <= 15; ++i)
-                {
-                    used_syms += total_syms[i];
-                    next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
-                }
-                if ((65536 != total) && (used_syms > 1))
-                {
-                    TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
-                }
-                for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
-                {
-                    mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index];
-                    if (!code_size)
-                        continue;
-                    cur_code = next_code[code_size]++;
-                    for (l = code_size; l > 0; l--, cur_code >>= 1)
-                        rev_code = (rev_code << 1) | (cur_code & 1);
-                    if (code_size <= TINFL_FAST_LOOKUP_BITS)
-                    {
-                        mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
-                        while (rev_code < TINFL_FAST_LOOKUP_SIZE)
-                        {
-                            pTable->m_look_up[rev_code] = k;
-                            rev_code += (1 << code_size);
-                        }
-                        continue;
-                    }
-                    if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)]))
-                    {
-                        pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next;
-                        tree_cur = tree_next;
-                        tree_next -= 2;
-                    }
-                    rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
-                    for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
-                    {
-                        tree_cur -= ((rev_code >>= 1) & 1);
-                        if (!pTable->m_tree[-tree_cur - 1])
-                        {
-                            pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next;
-                            tree_cur = tree_next;
-                            tree_next -= 2;
-                        }
-                        else
-                            tree_cur = pTable->m_tree[-tree_cur - 1];
-                    }
-                    tree_cur -= ((rev_code >>= 1) & 1);
-                    pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
-                }
-                if (r->m_type == 2)
-                {
-                    for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);)
-                    {
-                        mz_uint s;
-                        TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]);
-                        if (dist < 16)
-                        {
-                            r->m_len_codes[counter++] = (mz_uint8)dist;
-                            continue;
-                        }
-                        if ((dist == 16) && (!counter))
-                        {
-                            TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
-                        }
-                        num_extra = "\02\03\07"[dist - 16];
-                        TINFL_GET_BITS(18, s, num_extra);
-                        s += "\03\03\013"[dist - 16];
-                        TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s);
-                        counter += s;
-                    }
-                    if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
-                    {
-                        TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
-                    }
-                    TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]);
-                    TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
-                }
-            }
-            for (;;)
-            {
-                mz_uint8 *pSrc;
-                for (;;)
-                {
-                    if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
-                    {
-                        TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]);
-                        if (counter >= 256)
-                            break;
-                        while (pOut_buf_cur >= pOut_buf_end)
-                        {
-                            TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT);
-                        }
-                        *pOut_buf_cur++ = (mz_uint8)counter;
-                    }
-                    else
-                    {
-                        int sym2;
-                        mz_uint code_len;
-#if TINFL_USE_64BIT_BITBUF
-                        if (num_bits < 30)
-                        {
-                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits);
-                            pIn_buf_cur += 4;
-                            num_bits += 32;
-                        }
-#else
-                        if (num_bits < 15)
-                        {
-                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
-                            pIn_buf_cur += 2;
-                            num_bits += 16;
-                        }
-#endif
-                        if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
-                            code_len = sym2 >> 9;
-                        else
-                        {
-                            code_len = TINFL_FAST_LOOKUP_BITS;
-                            do
-                            {
-                                sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
-                            } while (sym2 < 0);
-                        }
-                        counter = sym2;
-                        bit_buf >>= code_len;
-                        num_bits -= code_len;
-                        if (counter & 256)
-                            break;
-
-#if !TINFL_USE_64BIT_BITBUF
-                        if (num_bits < 15)
-                        {
-                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
-                            pIn_buf_cur += 2;
-                            num_bits += 16;
-                        }
-#endif
-                        if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
-                            code_len = sym2 >> 9;
-                        else
-                        {
-                            code_len = TINFL_FAST_LOOKUP_BITS;
-                            do
-                            {
-                                sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
-                            } while (sym2 < 0);
-                        }
-                        bit_buf >>= code_len;
-                        num_bits -= code_len;
-
-                        pOut_buf_cur[0] = (mz_uint8)counter;
-                        if (sym2 & 256)
-                        {
-                            pOut_buf_cur++;
-                            counter = sym2;
-                            break;
-                        }
-                        pOut_buf_cur[1] = (mz_uint8)sym2;
-                        pOut_buf_cur += 2;
-                    }
-                }
-                if ((counter &= 511) == 256)
-                    break;
-
-                num_extra = s_length_extra[counter - 257];
-                counter = s_length_base[counter - 257];
-                if (num_extra)
-                {
-                    mz_uint extra_bits;
-                    TINFL_GET_BITS(25, extra_bits, num_extra);
-                    counter += extra_bits;
-                }
-
-                TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]);
-                num_extra = s_dist_extra[dist];
-                dist = s_dist_base[dist];
-                if (num_extra)
-                {
-                    mz_uint extra_bits;
-                    TINFL_GET_BITS(27, extra_bits, num_extra);
-                    dist += extra_bits;
-                }
-
-                dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
-                if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
-                {
-                    TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
-                }
-
-                pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
-
-                if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
-                {
-                    while (counter--)
-                    {
-                        while (pOut_buf_cur >= pOut_buf_end)
-                        {
-                            TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT);
-                        }
-                        *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
-                    }
-                    continue;
-                }
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
-                else if ((counter >= 9) && (counter <= dist))
-                {
-                    const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
-                    do
-                    {
-                        ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
-                        ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
-                        pOut_buf_cur += 8;
-                    } while ((pSrc += 8) < pSrc_end);
-                    if ((counter &= 7) < 3)
-                    {
-                        if (counter)
-                        {
-                            pOut_buf_cur[0] = pSrc[0];
-                            if (counter > 1)
-                                pOut_buf_cur[1] = pSrc[1];
-                            pOut_buf_cur += counter;
-                        }
-                        continue;
-                    }
-                }
-#endif
-                while(counter>2)
-                {
-                    pOut_buf_cur[0] = pSrc[0];
-                    pOut_buf_cur[1] = pSrc[1];
-                    pOut_buf_cur[2] = pSrc[2];
-                    pOut_buf_cur += 3;
-                    pSrc += 3;
-					counter -= 3;
-                }
-                if (counter > 0)
-                {
-                    pOut_buf_cur[0] = pSrc[0];
-                    if (counter > 1)
-                        pOut_buf_cur[1] = pSrc[1];
-                    pOut_buf_cur += counter;
-                }
-            }
-        }
-    } while (!(r->m_final & 1));
-
-    /* Ensure byte alignment and put back any bytes from the bitbuf if we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
-    /* I'm being super conservative here. A number of simplifications can be made to the byte alignment part, and the Adler32 check shouldn't ever need to worry about reading from the bitbuf now. */
-    TINFL_SKIP_BITS(32, num_bits & 7);
-    while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
-    {
-        --pIn_buf_cur;
-        num_bits -= 8;
-    }
-    bit_buf &= (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1);
-    MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end of non-deflate/zlib streams with following data (such as gzip streams). */
-
-    if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
-    {
-        for (counter = 0; counter < 4; ++counter)
-        {
-            mz_uint s;
-            if (num_bits)
-                TINFL_GET_BITS(41, s, 8);
-            else
-                TINFL_GET_BYTE(42, s);
-            r->m_z_adler32 = (r->m_z_adler32 << 8) | s;
-        }
-    }
-    TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
-
-    TINFL_CR_FINISH
-
-common_exit:
-    /* As long as we aren't telling the caller that we NEED more input to make forward progress: */
-    /* Put back any bytes from the bitbuf in case we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
-    /* We need to be very careful here to NOT push back any bytes we definitely know we need to make forward progress, though, or we'll lock the caller up into an inf loop. */
-    if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS))
-    {
-        while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
-        {
-            --pIn_buf_cur;
-            num_bits -= 8;
-        }
-    }
-    r->m_num_bits = num_bits;
-    r->m_bit_buf = bit_buf & (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1);
-    r->m_dist = dist;
-    r->m_counter = counter;
-    r->m_num_extra = num_extra;
-    r->m_dist_from_out_buf_start = dist_from_out_buf_start;
-    *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
-    *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
-    if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
-    {
-        const mz_uint8 *ptr = pOut_buf_next;
-        size_t buf_len = *pOut_buf_size;
-        mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16;
-        size_t block_len = buf_len % 5552;
-        while (buf_len)
-        {
-            for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
-            {
-                s1 += ptr[0], s2 += s1;
-                s1 += ptr[1], s2 += s1;
-                s1 += ptr[2], s2 += s1;
-                s1 += ptr[3], s2 += s1;
-                s1 += ptr[4], s2 += s1;
-                s1 += ptr[5], s2 += s1;
-                s1 += ptr[6], s2 += s1;
-                s1 += ptr[7], s2 += s1;
-            }
-            for (; i < block_len; ++i)
-                s1 += *ptr++, s2 += s1;
-            s1 %= 65521U, s2 %= 65521U;
-            buf_len -= block_len;
-            block_len = 5552;
-        }
-        r->m_check_adler32 = (s2 << 16) + s1;
-        if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32))
-            status = TINFL_STATUS_ADLER32_MISMATCH;
-    }
-    return status;
-}
-
-/* Higher level helper functions. */
-void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
-{
-    tinfl_decompressor decomp;
-    void *pBuf = NULL, *pNew_buf;
-    size_t src_buf_ofs = 0, out_buf_capacity = 0;
-    *pOut_len = 0;
-    tinfl_init(&decomp);
-    for (;;)
-    {
-        size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
-        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
-                                               (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
-        if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
-        {
-            MZ_FREE(pBuf);
-            *pOut_len = 0;
-            return NULL;
-        }
-        src_buf_ofs += src_buf_size;
-        *pOut_len += dst_buf_size;
-        if (status == TINFL_STATUS_DONE)
-            break;
-        new_out_buf_capacity = out_buf_capacity * 2;
-        if (new_out_buf_capacity < 128)
-            new_out_buf_capacity = 128;
-        pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
-        if (!pNew_buf)
-        {
-            MZ_FREE(pBuf);
-            *pOut_len = 0;
-            return NULL;
-        }
-        pBuf = pNew_buf;
-        out_buf_capacity = new_out_buf_capacity;
-    }
-    return pBuf;
-}
-
-size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
-{
-    tinfl_decompressor decomp;
-    tinfl_status status;
-    tinfl_init(&decomp);
-    status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf, &src_buf_len, (mz_uint8 *)pOut_buf, (mz_uint8 *)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
-    return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
-}
-
-int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
-{
-    int result = 0;
-    tinfl_decompressor decomp;
-    mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
-    size_t in_buf_ofs = 0, dict_ofs = 0;
-    if (!pDict)
-        return TINFL_STATUS_FAILED;
-    tinfl_init(&decomp);
-    for (;;)
-    {
-        size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
-        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
-                                               (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
-        in_buf_ofs += in_buf_size;
-        if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
-            break;
-        if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
-        {
-            result = (status == TINFL_STATUS_DONE);
-            break;
-        }
-        dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
-    }
-    MZ_FREE(pDict);
-    *pIn_buf_size = in_buf_ofs;
-    return result;
-}
-
-tinfl_decompressor *tinfl_decompressor_alloc()
-{
-    tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
-    if (pDecomp)
-        tinfl_init(pDecomp);
-    return pDecomp;
-}
-
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp)
-{
-    MZ_FREE(pDecomp);
-}
-
-
-
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * Copyright 2016 Martin Raiber
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- **************************************************************************/
-
-
-#ifndef MINIZ_NO_ARCHIVE_APIS
-
-
-
-/* ------------------- .ZIP archive reading */
-
-#ifdef MINIZ_NO_STDIO
-#define MZ_FILE void *
-#else
-#include <sys/stat.h>
-
-#if defined(_MSC_VER) || defined(__MINGW64__)
-static FILE *mz_fopen(const char *pFilename, const char *pMode)
-{
-    FILE *pFile = NULL;
-    fopen_s(&pFile, pFilename, pMode);
-    return pFile;
-}
-static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)
-{
-    FILE *pFile = NULL;
-    if (freopen_s(&pFile, pPath, pMode, pStream))
-        return NULL;
-    return pFile;
-}
-#ifndef MINIZ_NO_TIME
-#include <sys/utime.h>
-#endif
-#define MZ_FOPEN mz_fopen
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 _ftelli64
-#define MZ_FSEEK64 _fseeki64
-#define MZ_FILE_STAT_STRUCT _stat
-#define MZ_FILE_STAT _stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN mz_freopen
-#define MZ_DELETE_FILE remove
-#elif defined(__MINGW32__)
-#ifndef MINIZ_NO_TIME
-#include <sys/utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftello64
-#define MZ_FSEEK64 fseeko64
-#define MZ_FILE_STAT_STRUCT _stat
-#define MZ_FILE_STAT _stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
-#define MZ_DELETE_FILE remove
-#elif defined(__TINYC__)
-#ifndef MINIZ_NO_TIME
-#include <sys/utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftell
-#define MZ_FSEEK64 fseek
-#define MZ_FILE_STAT_STRUCT stat
-#define MZ_FILE_STAT stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
-#define MZ_DELETE_FILE remove
-#elif defined(__GNUC__) && _LARGEFILE64_SOURCE
-#ifndef MINIZ_NO_TIME
-#include <utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen64(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftello64
-#define MZ_FSEEK64 fseeko64
-#define MZ_FILE_STAT_STRUCT stat64
-#define MZ_FILE_STAT stat64
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(p, m, s) freopen64(p, m, s)
-#define MZ_DELETE_FILE remove
-#elif defined(__APPLE__)
-#ifndef MINIZ_NO_TIME
-#include <utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftello
-#define MZ_FSEEK64 fseeko
-#define MZ_FILE_STAT_STRUCT stat
-#define MZ_FILE_STAT stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(p, m, s) freopen(p, m, s)
-#define MZ_DELETE_FILE remove
-
-#else
-//#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
-#ifndef MINIZ_NO_TIME
-#include <utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#ifdef __STRICT_ANSI__
-#define MZ_FTELL64 ftell
-#define MZ_FSEEK64 fseek
-#else
-#define MZ_FTELL64 ftello
-#define MZ_FSEEK64 fseeko
-#endif
-#define MZ_FILE_STAT_STRUCT stat
-#define MZ_FILE_STAT stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
-#define MZ_DELETE_FILE remove
-#endif /* #ifdef _MSC_VER */
-#endif /* #ifdef MINIZ_NO_STDIO */
-
-#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
-
-/* Various ZIP archive enums. To completely avoid cross platform compiler alignment and platform endian issues, miniz.c doesn't use structs for any of this stuff. */
-enum
-{
-    /* ZIP archive identifiers and record sizes */
-    MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50,
-    MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50,
-    MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50,
-    MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30,
-    MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46,
-    MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,
-
-    /* ZIP64 archive identifier and record sizes */
-    MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50,
-    MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50,
-    MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56,
-    MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20,
-    MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001,
-    MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50,
-    MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24,
-    MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16,
-
-    /* Central directory header record offsets */
-    MZ_ZIP_CDH_SIG_OFS = 0,
-    MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4,
-    MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6,
-    MZ_ZIP_CDH_BIT_FLAG_OFS = 8,
-    MZ_ZIP_CDH_METHOD_OFS = 10,
-    MZ_ZIP_CDH_FILE_TIME_OFS = 12,
-    MZ_ZIP_CDH_FILE_DATE_OFS = 14,
-    MZ_ZIP_CDH_CRC32_OFS = 16,
-    MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20,
-    MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24,
-    MZ_ZIP_CDH_FILENAME_LEN_OFS = 28,
-    MZ_ZIP_CDH_EXTRA_LEN_OFS = 30,
-    MZ_ZIP_CDH_COMMENT_LEN_OFS = 32,
-    MZ_ZIP_CDH_DISK_START_OFS = 34,
-    MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36,
-    MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38,
-    MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42,
-
-    /* Local directory header offsets */
-    MZ_ZIP_LDH_SIG_OFS = 0,
-    MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4,
-    MZ_ZIP_LDH_BIT_FLAG_OFS = 6,
-    MZ_ZIP_LDH_METHOD_OFS = 8,
-    MZ_ZIP_LDH_FILE_TIME_OFS = 10,
-    MZ_ZIP_LDH_FILE_DATE_OFS = 12,
-    MZ_ZIP_LDH_CRC32_OFS = 14,
-    MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18,
-    MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22,
-    MZ_ZIP_LDH_FILENAME_LEN_OFS = 26,
-    MZ_ZIP_LDH_EXTRA_LEN_OFS = 28,
-    MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3,
-
-    /* End of central directory offsets */
-    MZ_ZIP_ECDH_SIG_OFS = 0,
-    MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4,
-    MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6,
-    MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8,
-    MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10,
-    MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12,
-    MZ_ZIP_ECDH_CDIR_OFS_OFS = 16,
-    MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,
-
-    /* ZIP64 End of central directory locator offsets */
-    MZ_ZIP64_ECDL_SIG_OFS = 0,                    /* 4 bytes */
-    MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4,          /* 4 bytes */
-    MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8,  /* 8 bytes */
-    MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */
-
-    /* ZIP64 End of central directory header offsets */
-    MZ_ZIP64_ECDH_SIG_OFS = 0,                       /* 4 bytes */
-    MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4,            /* 8 bytes */
-    MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12,          /* 2 bytes */
-    MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14,           /* 2 bytes */
-    MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16,            /* 4 bytes */
-    MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20,            /* 4 bytes */
-    MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */
-    MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32,       /* 8 bytes */
-    MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40,                /* 8 bytes */
-    MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48,                 /* 8 bytes */
-    MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0,
-    MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11
-};
-
-typedef struct
-{
-    void *m_p;
-    size_t m_size, m_capacity;
-    mz_uint m_element_size;
-} mz_zip_array;
-
-struct mz_zip_internal_state_tag
-{
-    mz_zip_array m_central_dir;
-    mz_zip_array m_central_dir_offsets;
-    mz_zip_array m_sorted_central_dir_offsets;
-
-    /* The flags passed in when the archive is initially opened. */
-    uint32_t m_init_flags;
-
-    /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. */
-    mz_bool m_zip64;
-
-    /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64 will also be slammed to true too, even if we didn't find a zip64 end of central dir header, etc.) */
-    mz_bool m_zip64_has_extended_info_fields;
-
-    /* These fields are used by the file, FILE, memory, and memory/heap read/write helpers. */
-    MZ_FILE *m_pFile;
-    mz_uint64 m_file_archive_start_ofs;
-
-    void *m_pMem;
-    size_t m_mem_size;
-    size_t m_mem_capacity;
-};
-
-#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size
-
-#if defined(DEBUG) || defined(_DEBUG) || defined(NDEBUG)
-static MZ_FORCEINLINE mz_uint mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index)
-{
-    MZ_ASSERT(index < pArray->m_size);
-    return index;
-}
-#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[mz_zip_array_range_check(array_ptr, index)]
-#else
-#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index]
-#endif
-
-static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)
-{
-    memset(pArray, 0, sizeof(mz_zip_array));
-    pArray->m_element_size = element_size;
-}
-
-static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)
-{
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p);
-    memset(pArray, 0, sizeof(mz_zip_array));
-}
-
-static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
-{
-    void *pNew_p;
-    size_t new_capacity = min_new_capacity;
-    MZ_ASSERT(pArray->m_element_size);
-    if (pArray->m_capacity >= min_new_capacity)
-        return MZ_TRUE;
-    if (growing)
-    {
-        new_capacity = MZ_MAX(1, pArray->m_capacity);
-        while (new_capacity < min_new_capacity)
-            new_capacity *= 2;
-    }
-    if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity)))
-        return MZ_FALSE;
-    pArray->m_p = pNew_p;
-    pArray->m_capacity = new_capacity;
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)
-{
-    if (new_capacity > pArray->m_capacity)
-    {
-        if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing))
-            return MZ_FALSE;
-    }
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
-{
-    if (new_size > pArray->m_capacity)
-    {
-        if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing))
-            return MZ_FALSE;
-    }
-    pArray->m_size = new_size;
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
-{
-    return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE);
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
-{
-    size_t orig_size = pArray->m_size;
-    if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE))
-        return MZ_FALSE;
-    memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, pElements, n * pArray->m_element_size);
-    return MZ_TRUE;
-}
-
-#ifndef MINIZ_NO_TIME
-static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date)
-{
-    struct tm tm;
-    memset(&tm, 0, sizeof(tm));
-    tm.tm_isdst = -1;
-    tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;
-    tm.tm_mon = ((dos_date >> 5) & 15) - 1;
-    tm.tm_mday = dos_date & 31;
-    tm.tm_hour = (dos_time >> 11) & 31;
-    tm.tm_min = (dos_time >> 5) & 63;
-    tm.tm_sec = (dos_time << 1) & 62;
-    return mktime(&tm);
-}
-
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
-{
-#ifdef _MSC_VER
-    struct tm tm_struct;
-    struct tm *tm = &tm_struct;
-    errno_t err = localtime_s(tm, &time);
-    if (err)
-    {
-        *pDOS_date = 0;
-        *pDOS_time = 0;
-        return;
-    }
-#else
-    struct tm *tm = localtime(&time);
-#endif /* #ifdef _MSC_VER */
-
-    *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));
-    *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);
-}
-#endif /* MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-#ifndef MINIZ_NO_STDIO
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime)
-{
-    struct MZ_FILE_STAT_STRUCT file_stat;
-
-    /* On Linux with x86 glibc, this call will fail on large files (I think >= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */
-    if (MZ_FILE_STAT(pFilename, &file_stat) != 0)
-        return MZ_FALSE;
-
-    *pTime = file_stat.st_mtime;
-
-    return MZ_TRUE;
-}
-#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS*/
-
-static mz_bool mz_zip_set_file_times(const char *pFilename, MZ_TIME_T access_time, MZ_TIME_T modified_time)
-{
-    struct utimbuf t;
-
-    memset(&t, 0, sizeof(t));
-    t.actime = access_time;
-    t.modtime = modified_time;
-
-    return !utime(pFilename, &t);
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-#endif /* #ifndef MINIZ_NO_TIME */
-
-static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)
-{
-    if (pZip)
-        pZip->m_last_error = err_num;
-    return MZ_FALSE;
-}
-
-static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)
-{
-    (void)flags;
-    if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!pZip->m_pAlloc)
-        pZip->m_pAlloc = miniz_def_alloc_func;
-    if (!pZip->m_pFree)
-        pZip->m_pFree = miniz_def_free_func;
-    if (!pZip->m_pRealloc)
-        pZip->m_pRealloc = miniz_def_realloc_func;
-
-    pZip->m_archive_size = 0;
-    pZip->m_central_directory_file_ofs = 0;
-    pZip->m_total_files = 0;
-    pZip->m_last_error = MZ_ZIP_NO_ERROR;
-
-    if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
-    pZip->m_pState->m_init_flags = flags;
-    pZip->m_pState->m_zip64 = MZ_FALSE;
-    pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE;
-
-    pZip->m_zip_mode = MZ_ZIP_MODE_READING;
-
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)
-{
-    const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
-    const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index));
-    mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS), r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    mz_uint8 l = 0, r = 0;
-    pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-    pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-    pE = pL + MZ_MIN(l_len, r_len);
-    while (pL < pE)
-    {
-        if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
-            break;
-        pL++;
-        pR++;
-    }
-    return (pL == pE) ? (l_len < r_len) : (l < r);
-}
-
-#define MZ_SWAP_UINT32(a, b) \
-    do                       \
-    {                        \
-        mz_uint32 t = a;     \
-        a = b;               \
-        b = t;               \
-    }                        \
-    MZ_MACRO_END
-
-/* Heap sort of lowercased filenames, used to help accelerate plain central directory searches by mz_zip_reader_locate_file(). (Could also use qsort(), but it could allocate memory.) */
-static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)
-{
-    mz_zip_internal_state *pState = pZip->m_pState;
-    const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
-    const mz_zip_array *pCentral_dir = &pState->m_central_dir;
-    mz_uint32 *pIndices;
-    mz_uint32 start, end;
-    const mz_uint32 size = pZip->m_total_files;
-
-    if (size <= 1U)
-        return;
-
-    pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
-
-    start = (size - 2U) >> 1U;
-    for (;;)
-    {
-        mz_uint64 child, root = start;
-        for (;;)
-        {
-            if ((child = (root << 1U) + 1U) >= size)
-                break;
-            child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])));
-            if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
-                break;
-            MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
-            root = child;
-        }
-        if (!start)
-            break;
-        start--;
-    }
-
-    end = size - 1;
-    while (end > 0)
-    {
-        mz_uint64 child, root = 0;
-        MZ_SWAP_UINT32(pIndices[end], pIndices[0]);
-        for (;;)
-        {
-            if ((child = (root << 1U) + 1U) >= end)
-                break;
-            child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]));
-            if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
-                break;
-            MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
-            root = child;
-        }
-        end--;
-    }
-}
-
-static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs)
-{
-    mz_int64 cur_file_ofs;
-    mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
-    mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-
-    /* Basic sanity checks - reject files which are too small */
-    if (pZip->m_archive_size < record_size)
-        return MZ_FALSE;
-
-    /* Find the record by scanning the file from the end towards the beginning. */
-    cur_file_ofs = MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
-    for (;;)
-    {
-        int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
-            return MZ_FALSE;
-
-        for (i = n - 4; i >= 0; --i)
-        {
-            mz_uint s = MZ_READ_LE32(pBuf + i);
-            if (s == record_sig)
-            {
-                if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)
-                    break;
-            }
-        }
-
-        if (i >= 0)
-        {
-            cur_file_ofs += i;
-            break;
-        }
-
-        /* Give up if we've searched the entire file, or we've gone back "too far" (~64kb) */
-        if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= (MZ_UINT16_MAX + record_size)))
-            return MZ_FALSE;
-
-        cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
-    }
-
-    *pOfs = cur_file_ofs;
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)
-{
-    mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0;
-    mz_uint64 cdir_ofs = 0;
-    mz_int64 cur_file_ofs = 0;
-    const mz_uint8 *p;
-
-    mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
-    mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-    mz_bool sort_central_dir = ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
-    mz_uint32 zip64_end_of_central_dir_locator_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;
-
-    mz_uint32 zip64_end_of_central_dir_header_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pZip64_end_of_central_dir = (mz_uint8 *)zip64_end_of_central_dir_header_u32;
-
-    mz_uint64 zip64_end_of_central_dir_ofs = 0;
-
-    /* Basic sanity checks - reject files which are too small, and check the first 4 bytes of the file to make sure a local header is there. */
-    if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-    if (!mz_zip_reader_locate_header_sig(pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
-        return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
-
-    /* Read and verify the end of central directory record. */
-    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-    if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
-    {
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, pZip64_locator, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
-        {
-            if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG)
-            {
-                zip64_end_of_central_dir_ofs = MZ_READ_LE64(pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);
-                if (zip64_end_of_central_dir_ofs > (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
-                    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-                if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs, pZip64_end_of_central_dir, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
-                {
-                    if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG)
-                    {
-                        pZip->m_pState->m_zip64 = MZ_TRUE;
-                    }
-                }
-            }
-        }
-    }
-
-    pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);
-    cdir_entries_on_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
-    num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
-    cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
-    cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);
-    cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
-
-    if (pZip->m_pState->m_zip64)
-    {
-        mz_uint32 zip64_total_num_of_disks = MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);
-        mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);
-        mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
-        mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);
-        mz_uint64 zip64_size_of_central_directory = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);
-
-        if (zip64_size_of_end_of_central_dir_record < (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-        if (zip64_total_num_of_disks != 1U)
-            return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-        /* Check for miniz's practical limits */
-        if (zip64_cdir_total_entries > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-        pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;
-
-        if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-        cdir_entries_on_this_disk = (mz_uint32)zip64_cdir_total_entries_on_this_disk;
-
-        /* Check for miniz's current practical limits (sorry, this should be enough for millions of files) */
-        if (zip64_size_of_central_directory > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-        cdir_size = (mz_uint32)zip64_size_of_central_directory;
-
-        num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);
-
-        cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);
-
-        cdir_ofs = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);
-    }
-
-    if (pZip->m_total_files != cdir_entries_on_this_disk)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-    if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-    if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    pZip->m_central_directory_file_ofs = cdir_ofs;
-
-    if (pZip->m_total_files)
-    {
-        mz_uint i, n;
-        /* Read the entire central directory into a heap block, and allocate another heap block to hold the unsorted central dir file record offsets, and possibly another to hold the sorted indices. */
-        if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) ||
-            (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE)))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        if (sort_central_dir)
-        {
-            if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE))
-                return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-        /* Now create an index into the central directory file records, do some basic sanity checking on each record */
-        p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
-        for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i)
-        {
-            mz_uint total_header_size, disk_index, bit_flags, filename_size, ext_data_size;
-            mz_uint64 comp_size, decomp_size, local_header_ofs;
-
-            if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, i) = (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
-
-            if (sort_central_dir)
-                MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, mz_uint32, i) = i;
-
-            comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
-            decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-            local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
-            filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-            ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-
-            if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&
-                (ext_data_size) &&
-                (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == MZ_UINT32_MAX))
-            {
-                /* Attempt to find zip64 extended information field in the entry's extra data */
-                mz_uint32 extra_size_remaining = ext_data_size;
-
-                if (extra_size_remaining)
-                {
-                    const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
-
-                    do
-                    {
-                        mz_uint32 field_id;
-                        mz_uint32 field_data_size;
-
-                        if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        field_id = MZ_READ_LE16(pExtra_data);
-                        field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-
-                        if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-                        {
-                            /* Ok, the archive didn't have any zip64 headers but it uses a zip64 extended information field so mark it as zip64 anyway (this can occur with infozip's zip util when it reads compresses files from stdin). */
-                            pZip->m_pState->m_zip64 = MZ_TRUE;
-                            pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;
-                            break;
-                        }
-
-                        pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
-                        extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
-                    } while (extra_size_remaining);
-                }
-            }
-
-            /* I've seen archives that aren't marked as zip64 that uses zip64 ext data, argh */
-            if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX))
-            {
-                if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size))
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
-            if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1)))
-                return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-            if (comp_size != MZ_UINT32_MAX)
-            {
-                if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-            if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)
-                return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-            if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > n)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            n -= total_header_size;
-            p += total_header_size;
-        }
-    }
-
-    if (sort_central_dir)
-        mz_zip_reader_sort_central_dir_offsets_by_filename(pZip);
-
-    return MZ_TRUE;
-}
-
-void mz_zip_zero_struct(mz_zip_archive *pZip)
-{
-    if (pZip)
-        MZ_CLEAR_OBJ(*pZip);
-}
-
-static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
-{
-    mz_bool status = MZ_TRUE;
-
-    if (!pZip)
-        return MZ_FALSE;
-
-    if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
-    {
-        if (set_last_error)
-            pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER;
-
-        return MZ_FALSE;
-    }
-
-    if (pZip->m_pState)
-    {
-        mz_zip_internal_state *pState = pZip->m_pState;
-        pZip->m_pState = NULL;
-
-        mz_zip_array_clear(pZip, &pState->m_central_dir);
-        mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
-        mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
-
-#ifndef MINIZ_NO_STDIO
-        if (pState->m_pFile)
-        {
-            if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
-            {
-                if (MZ_FCLOSE(pState->m_pFile) == EOF)
-                {
-                    if (set_last_error)
-                        pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;
-                    status = MZ_FALSE;
-                }
-            }
-            pState->m_pFile = NULL;
-        }
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-    }
-    pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
-
-    return status;
-}
-
-mz_bool mz_zip_reader_end(mz_zip_archive *pZip)
-{
-    return mz_zip_reader_end_internal(pZip, MZ_TRUE);
-}
-mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)
-{
-    if ((!pZip) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
-    pZip->m_archive_size = size;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
-    memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
-    return s;
-}
-
-mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
-{
-    if (!pMem)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;
-    pZip->m_archive_size = size;
-    pZip->m_pRead = mz_zip_mem_read_func;
-    pZip->m_pIO_opaque = pZip;
-    pZip->m_pNeeds_keepalive = NULL;
-
-#ifdef __cplusplus
-    pZip->m_pState->m_pMem = const_cast<void *>(pMem);
-#else
-    pZip->m_pState->m_pMem = (void *)pMem;
-#endif
-
-    pZip->m_pState->m_mem_size = size;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-#ifndef MINIZ_NO_STDIO
-static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
-
-    file_ofs += pZip->m_pState->m_file_archive_start_ofs;
-
-    if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
-        return 0;
-
-    return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);
-}
-
-mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
-{
-    return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0);
-}
-
-mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)
-{
-    mz_uint64 file_size;
-    MZ_FILE *pFile;
-
-    if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pFile = MZ_FOPEN(pFilename, "rb");
-    if (!pFile)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    file_size = archive_size;
-    if (!file_size)
-    {
-        if (MZ_FSEEK64(pFile, 0, SEEK_END))
-        {
-            MZ_FCLOSE(pFile);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
-        }
-
-        file_size = MZ_FTELL64(pFile);
-    }
-
-    /* TODO: Better sanity check archive_size and the # of actual remaining bytes */
-
-    if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-    {
-	MZ_FCLOSE(pFile);
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-    }
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-    {
-        MZ_FCLOSE(pFile);
-        return MZ_FALSE;
-    }
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
-    pZip->m_pRead = mz_zip_file_read_func;
-    pZip->m_pIO_opaque = pZip;
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_archive_size = file_size;
-    pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags)
-{
-    mz_uint64 cur_file_ofs;
-
-    if ((!pZip) || (!pFile))
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    cur_file_ofs = MZ_FTELL64(pFile);
-
-    if (!archive_size)
-    {
-        if (MZ_FSEEK64(pFile, 0, SEEK_END))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
-
-        archive_size = MZ_FTELL64(pFile) - cur_file_ofs;
-
-        if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-            return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-    }
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
-    pZip->m_pRead = mz_zip_file_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_archive_size = archive_size;
-    pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-static MZ_FORCEINLINE const mz_uint8 *mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index)
-{
-    if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files))
-        return NULL;
-    return &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
-}
-
-mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)
-{
-    mz_uint m_bit_flag;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-    return (m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0;
-}
-
-mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index)
-{
-    mz_uint bit_flag;
-    mz_uint method;
-
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
-    bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-
-    if ((method != 0) && (method != MZ_DEFLATED))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-        return MZ_FALSE;
-    }
-
-    if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-        return MZ_FALSE;
-    }
-
-    if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)
-{
-    mz_uint filename_len, attribute_mapping_id, external_attr;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    if (filename_len)
-    {
-        if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
-            return MZ_TRUE;
-    }
-
-    /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */
-    /* Most/all zip writers (hopefully) set DOS file/directory attributes in the low 16-bits, so check for the DOS directory flag and ignore the source OS ID in the created by field. */
-    /* FIXME: Remove this check? Is it necessary - we already check the filename. */
-    attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
-    (void)attribute_mapping_id;
-
-    external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
-    if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0)
-    {
-        return MZ_TRUE;
-    }
-
-    return MZ_FALSE;
-}
-
-static mz_bool mz_zip_file_stat_internal(mz_zip_archive *pZip, mz_uint file_index, const mz_uint8 *pCentral_dir_header, mz_zip_archive_file_stat *pStat, mz_bool *pFound_zip64_extra_data)
-{
-    mz_uint n;
-    const mz_uint8 *p = pCentral_dir_header;
-
-    if (pFound_zip64_extra_data)
-        *pFound_zip64_extra_data = MZ_FALSE;
-
-    if ((!p) || (!pStat))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* Extract fields from the central directory record. */
-    pStat->m_file_index = file_index;
-    pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index);
-    pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS);
-    pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS);
-    pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-    pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
-#ifndef MINIZ_NO_TIME
-    pStat->m_time = mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS), MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS));
-#endif
-    pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS);
-    pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
-    pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-    pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS);
-    pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
-    pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
-
-    /* Copy as much of the filename and comment as possible. */
-    n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1);
-    memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
-    pStat->m_filename[n] = '\0';
-
-    n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS);
-    n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1);
-    pStat->m_comment_size = n;
-    memcpy(pStat->m_comment, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS), n);
-    pStat->m_comment[n] = '\0';
-
-    /* Set some flags for convienance */
-    pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index);
-    pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index);
-    pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index);
-
-    /* See if we need to read any zip64 extended information fields. */
-    /* Confusingly, these zip64 fields can be present even on non-zip64 archives (Debian zip on a huge files from stdin piped to stdout creates them). */
-    if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), pStat->m_local_header_ofs) == MZ_UINT32_MAX)
-    {
-        /* Attempt to find zip64 extended information field in the entry's extra data */
-        mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-
-        if (extra_size_remaining)
-        {
-            const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-
-            do
-            {
-                mz_uint32 field_id;
-                mz_uint32 field_data_size;
-
-                if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                field_id = MZ_READ_LE16(pExtra_data);
-                field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-
-                if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-                {
-                    const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2;
-                    mz_uint32 field_data_remaining = field_data_size;
-
-                    if (pFound_zip64_extra_data)
-                        *pFound_zip64_extra_data = MZ_TRUE;
-
-                    if (pStat->m_uncomp_size == MZ_UINT32_MAX)
-                    {
-                        if (field_data_remaining < sizeof(mz_uint64))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        pStat->m_uncomp_size = MZ_READ_LE64(pField_data);
-                        pField_data += sizeof(mz_uint64);
-                        field_data_remaining -= sizeof(mz_uint64);
-                    }
-
-                    if (pStat->m_comp_size == MZ_UINT32_MAX)
-                    {
-                        if (field_data_remaining < sizeof(mz_uint64))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        pStat->m_comp_size = MZ_READ_LE64(pField_data);
-                        pField_data += sizeof(mz_uint64);
-                        field_data_remaining -= sizeof(mz_uint64);
-                    }
-
-                    if (pStat->m_local_header_ofs == MZ_UINT32_MAX)
-                    {
-                        if (field_data_remaining < sizeof(mz_uint64))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        pStat->m_local_header_ofs = MZ_READ_LE64(pField_data);
-                        pField_data += sizeof(mz_uint64);
-                        field_data_remaining -= sizeof(mz_uint64);
-                    }
-
-                    break;
-                }
-
-                pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
-                extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
-            } while (extra_size_remaining);
-        }
-    }
-
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)
-{
-    mz_uint i;
-    if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE)
-        return 0 == memcmp(pA, pB, len);
-    for (i = 0; i < len; ++i)
-        if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i]))
-            return MZ_FALSE;
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE int mz_zip_filename_compare(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)
-{
-    const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
-    mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    mz_uint8 l = 0, r = 0;
-    pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-    pE = pL + MZ_MIN(l_len, r_len);
-    while (pL < pE)
-    {
-        if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
-            break;
-        pL++;
-        pR++;
-    }
-    return (pL == pE) ? (int)(l_len - r_len) : (l - r);
-}
-
-static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex)
-{
-    mz_zip_internal_state *pState = pZip->m_pState;
-    const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
-    const mz_zip_array *pCentral_dir = &pState->m_central_dir;
-    mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
-    const uint32_t size = pZip->m_total_files;
-    const mz_uint filename_len = (mz_uint)strlen(pFilename);
-
-    if (pIndex)
-        *pIndex = 0;
-
-    if (size)
-    {
-        /* yes I could use uint32_t's, but then we would have to add some special case checks in the loop, argh, and */
-        /* honestly the major expense here on 32-bit CPU's will still be the filename compare */
-        mz_int64 l = 0, h = (mz_int64)size - 1;
-
-        while (l <= h)
-        {
-            mz_int64 m = l + ((h - l) >> 1);
-            uint32_t file_index = pIndices[(uint32_t)m];
-
-            int comp = mz_zip_filename_compare(pCentral_dir, pCentral_dir_offsets, file_index, pFilename, filename_len);
-            if (!comp)
-            {
-                if (pIndex)
-                    *pIndex = file_index;
-                return MZ_TRUE;
-            }
-            else if (comp < 0)
-                l = m + 1;
-            else
-                h = m - 1;
-        }
-    }
-
-    return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
-}
-
-int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
-{
-    mz_uint32 index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index))
-        return -1;
-    else
-        return (int)index;
-}
-
-mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex)
-{
-    mz_uint file_index;
-    size_t name_len, comment_len;
-
-    if (pIndex)
-        *pIndex = 0;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pName))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* See if we can use a binary search */
-    if (((pZip->m_pState->m_init_flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) &&
-        (pZip->m_zip_mode == MZ_ZIP_MODE_READING) &&
-        ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size))
-    {
-        return mz_zip_locate_file_binary_search(pZip, pName, pIndex);
-    }
-
-    /* Locate the entry by scanning the entire central directory */
-    name_len = strlen(pName);
-    if (name_len > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    comment_len = pComment ? strlen(pComment) : 0;
-    if (comment_len > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    for (file_index = 0; file_index < pZip->m_total_files; file_index++)
-    {
-        const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
-        mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-        const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-        if (filename_len < name_len)
-            continue;
-        if (comment_len)
-        {
-            mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), file_comment_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS);
-            const char *pFile_comment = pFilename + filename_len + file_extra_len;
-            if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags)))
-                continue;
-        }
-        if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len))
-        {
-            int ofs = filename_len - 1;
-            do
-            {
-                if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':'))
-                    break;
-            } while (--ofs >= 0);
-            ofs++;
-            pFilename += ofs;
-            filename_len -= ofs;
-        }
-        if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags)))
-        {
-            if (pIndex)
-                *pIndex = file_index;
-            return MZ_TRUE;
-        }
-    }
-
-    return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
-}
-
-mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
-{
-    int status = TINFL_STATUS_DONE;
-    mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
-    mz_zip_archive_file_stat file_stat;
-    void *pRead_buf;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-    tinfl_decompressor inflator;
-
-    if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    /* A directory or zero length file */
-    if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
-        return MZ_TRUE;
-
-    /* Encryption and patch files are not supported. */
-    if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-    /* This function only supports decompressing stored and deflate. */
-    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-
-    /* Ensure supplied output buffer is large enough. */
-    needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
-    if (buf_size < needed_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL);
-
-    /* Read and parse the local directory entry. */
-    cur_file_ofs = file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
-    {
-        /* The file is stored or the caller has requested the compressed data. */
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0)
-        {
-            if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
-                return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
-        }
-#endif
-
-        return MZ_TRUE;
-    }
-
-    /* Decompress the file either directly from memory or from a file input buffer. */
-    tinfl_init(&inflator);
-
-    if (pZip->m_pState->m_pMem)
-    {
-        /* Read directly from the archive in memory. */
-        pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
-        read_buf_size = read_buf_avail = file_stat.m_comp_size;
-        comp_remaining = 0;
-    }
-    else if (pUser_read_buf)
-    {
-        /* Use a user provided read buffer. */
-        if (!user_read_buf_size)
-            return MZ_FALSE;
-        pRead_buf = (mz_uint8 *)pUser_read_buf;
-        read_buf_size = user_read_buf_size;
-        read_buf_avail = 0;
-        comp_remaining = file_stat.m_comp_size;
-    }
-    else
-    {
-        /* Temporarily allocate a read buffer. */
-        read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
-        if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        read_buf_avail = 0;
-        comp_remaining = file_stat.m_comp_size;
-    }
-
-    do
-    {
-        /* The size_t cast here should be OK because we've verified that the output buffer is >= file_stat.m_uncomp_size above */
-        size_t in_buf_size, out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
-        if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
-        {
-            read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
-            if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-            {
-                status = TINFL_STATUS_FAILED;
-                mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-                break;
-            }
-            cur_file_ofs += read_buf_avail;
-            comp_remaining -= read_buf_avail;
-            read_buf_ofs = 0;
-        }
-        in_buf_size = (size_t)read_buf_avail;
-        status = tinfl_decompress(&inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0));
-        read_buf_avail -= in_buf_size;
-        read_buf_ofs += in_buf_size;
-        out_buf_ofs += out_buf_size;
-    } while (status == TINFL_STATUS_NEEDS_MORE_INPUT);
-
-    if (status == TINFL_STATUS_DONE)
-    {
-        /* Make sure the entire file was decompressed, and check its CRC. */
-        if (out_buf_ofs != file_stat.m_uncomp_size)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
-            status = TINFL_STATUS_FAILED;
-        }
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
-            status = TINFL_STATUS_FAILED;
-        }
-#endif
-    }
-
-    if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf))
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-
-    return status == TINFL_STATUS_DONE;
-}
-
-mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-        return MZ_FALSE;
-    return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size);
-}
-
-mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags)
-{
-    return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, NULL, 0);
-}
-
-mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)
-{
-    return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0);
-}
-
-void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
-{
-    mz_uint64 comp_size, uncomp_size, alloc_size;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    void *pBuf;
-
-    if (pSize)
-        *pSize = 0;
-
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return NULL;
-    }
-
-    comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
-    uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-
-    alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size;
-    if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-        return NULL;
-    }
-
-    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        return NULL;
-    }
-
-    if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size, flags))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-        return NULL;
-    }
-
-    if (pSize)
-        *pSize = (size_t)alloc_size;
-    return pBuf;
-}
-
-void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-    {
-        if (pSize)
-            *pSize = 0;
-        return MZ_FALSE;
-    }
-    return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
-}
-
-mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
-{
-    int status = TINFL_STATUS_DONE;
-    mz_uint file_crc32 = MZ_CRC32_INIT;
-    mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
-    mz_zip_archive_file_stat file_stat;
-    void *pRead_buf = NULL;
-    void *pWrite_buf = NULL;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    /* A directory or zero length file */
-    if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
-        return MZ_TRUE;
-
-    /* Encryption and patch files are not supported. */
-    if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-    /* This function only supports decompressing stored and deflate. */
-    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-
-    /* Read and do some minimal validation of the local directory entry (this doesn't crack the zip64 stuff, which we already have from the central dir) */
-    cur_file_ofs = file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    /* Decompress the file either directly from memory or from a file input buffer. */
-    if (pZip->m_pState->m_pMem)
-    {
-        pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
-        read_buf_size = read_buf_avail = file_stat.m_comp_size;
-        comp_remaining = 0;
-    }
-    else
-    {
-        read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
-        if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        read_buf_avail = 0;
-        comp_remaining = file_stat.m_comp_size;
-    }
-
-    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
-    {
-        /* The file is stored or the caller has requested the compressed data. */
-        if (pZip->m_pState->m_pMem)
-        {
-            if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > MZ_UINT32_MAX))
-                return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-            if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
-            {
-                mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
-                status = TINFL_STATUS_FAILED;
-            }
-            else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-            {
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size);
-#endif
-            }
-
-            cur_file_ofs += file_stat.m_comp_size;
-            out_buf_ofs += file_stat.m_comp_size;
-            comp_remaining = 0;
-        }
-        else
-        {
-            while (comp_remaining)
-            {
-                read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
-                if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                    status = TINFL_STATUS_FAILED;
-                    break;
-                }
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-                {
-                    file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
-                }
-#endif
-
-                if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
-                    status = TINFL_STATUS_FAILED;
-                    break;
-                }
-
-                cur_file_ofs += read_buf_avail;
-                out_buf_ofs += read_buf_avail;
-                comp_remaining -= read_buf_avail;
-            }
-        }
-    }
-    else
-    {
-        tinfl_decompressor inflator;
-        tinfl_init(&inflator);
-
-        if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            status = TINFL_STATUS_FAILED;
-        }
-        else
-        {
-            do
-            {
-                mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-                size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-                if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
-                {
-                    read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
-                    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-                    {
-                        mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                        status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-                    cur_file_ofs += read_buf_avail;
-                    comp_remaining -= read_buf_avail;
-                    read_buf_ofs = 0;
-                }
-
-                in_buf_size = (size_t)read_buf_avail;
-                status = tinfl_decompress(&inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
-                read_buf_avail -= in_buf_size;
-                read_buf_ofs += in_buf_size;
-
-                if (out_buf_size)
-                {
-                    if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
-                    {
-                        mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
-                        status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                    file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size);
-#endif
-                    if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size)
-                    {
-                        mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-                        status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-                }
-            } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT));
-        }
-    }
-
-    if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
-    {
-        /* Make sure the entire file was decompressed, and check its CRC. */
-        if (out_buf_ofs != file_stat.m_uncomp_size)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
-            status = TINFL_STATUS_FAILED;
-        }
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        else if (file_crc32 != file_stat.m_crc32)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-            status = TINFL_STATUS_FAILED;
-        }
-#endif
-    }
-
-    if (!pZip->m_pState->m_pMem)
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-
-    if (pWrite_buf)
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf);
-
-    return status == TINFL_STATUS_DONE;
-}
-
-mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-        return MZ_FALSE;
-
-    return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags);
-}
-
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
-{
-    mz_zip_reader_extract_iter_state *pState;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-
-    /* Argument sanity check */
-    if ((!pZip) || (!pZip->m_pState))
-        return NULL;
-
-    /* Allocate an iterator status structure */
-    pState = (mz_zip_reader_extract_iter_state*)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_reader_extract_iter_state));
-    if (!pState)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        return NULL;
-    }
-
-    /* Fetch file details */
-    if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* Encryption and patch files are not supported. */
-    if (pState->file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* This function only supports decompressing stored and deflate. */
-    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* Init state - save args */
-    pState->pZip = pZip;
-    pState->flags = flags;
-
-    /* Init state - reset variables to defaults */
-    pState->status = TINFL_STATUS_DONE;
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-    pState->file_crc32 = MZ_CRC32_INIT;
-#endif
-    pState->read_buf_ofs = 0;
-    pState->out_buf_ofs = 0;
-    pState->pRead_buf = NULL;
-    pState->pWrite_buf = NULL;
-    pState->out_blk_remain = 0;
-
-    /* Read and parse the local directory entry. */
-    pState->cur_file_ofs = pState->file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, pState->cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    pState->cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* Decompress the file either directly from memory or from a file input buffer. */
-    if (pZip->m_pState->m_pMem)
-    {
-        pState->pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs;
-        pState->read_buf_size = pState->read_buf_avail = pState->file_stat.m_comp_size;
-        pState->comp_remaining = pState->file_stat.m_comp_size;
-    }
-    else
-    {
-        if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
-        {
-            /* Decompression required, therefore intermediate read buffer required */
-            pState->read_buf_size = MZ_MIN(pState->file_stat.m_comp_size, int(MZ_ZIP_MAX_IO_BUF_SIZE));
-            if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size)))
-            {
-                mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-                return NULL;
-            }
-        }
-        else
-        {
-            /* Decompression not required - we will be reading directly into user buffer, no temp buf required */
-            pState->read_buf_size = 0;
-        }
-        pState->read_buf_avail = 0;
-        pState->comp_remaining = pState->file_stat.m_comp_size;
-    }
-
-    if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
-    {
-        /* Decompression required, init decompressor */
-        tinfl_init( &pState->inflator );
-
-        /* Allocate write buffer */
-        if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            if (pState->pRead_buf)
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf);
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-            return NULL;
-        }
-    }
-
-    return pState;
-}
-
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
-{
-    mz_uint32 file_index;
-
-    /* Locate file index by name */
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-        return NULL;
-
-    /* Construct iterator */
-    return mz_zip_reader_extract_iter_new(pZip, file_index, flags);
-}
-
-size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size)
-{
-    size_t copied_to_caller = 0;
-
-    /* Argument sanity check */
-    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf))
-        return 0;
-
-    if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))
-    {
-        /* The file is stored or the caller has requested the compressed data, calc amount to return. */
-        copied_to_caller = MZ_MIN( buf_size, pState->comp_remaining );
-
-        /* Zip is in memory....or requires reading from a file? */
-        if (pState->pZip->m_pState->m_pMem)
-        {
-            /* Copy data to caller's buffer */
-            memcpy( pvBuf, pState->pRead_buf, copied_to_caller );
-            pState->pRead_buf = ((mz_uint8*)pState->pRead_buf) + copied_to_caller;
-        }
-        else
-        {
-            /* Read directly into caller's buffer */
-            if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller)
-            {
-                /* Failed to read all that was asked for, flag failure and alert user */
-                mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
-                pState->status = TINFL_STATUS_FAILED;
-                copied_to_caller = 0;
-            }
-        }
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        /* Compute CRC if not returning compressed data only */
-        if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-            pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller);
-#endif
-
-        /* Advance offsets, dec counters */
-        pState->cur_file_ofs += copied_to_caller;
-        pState->out_buf_ofs += copied_to_caller;
-        pState->comp_remaining -= copied_to_caller;
-    }
-    else
-    {
-        do
-        {
-            /* Calc ptr to write buffer - given current output pos and block size */
-            mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pState->pWrite_buf + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-
-            /* Calc max output size - given current output pos and block size */
-            size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-
-            if (!pState->out_blk_remain)
-            {
-                /* Read more data from file if none available (and reading from file) */
-                if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem))
-                {
-                    /* Calc read size */
-                    pState->read_buf_avail = MZ_MIN(pState->read_buf_size, pState->comp_remaining);
-                    if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pState->pRead_buf, (size_t)pState->read_buf_avail) != pState->read_buf_avail)
-                    {
-                        mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
-                        pState->status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-
-                    /* Advance offsets, dec counters */
-                    pState->cur_file_ofs += pState->read_buf_avail;
-                    pState->comp_remaining -= pState->read_buf_avail;
-                    pState->read_buf_ofs = 0;
-                }
-
-                /* Perform decompression */
-                in_buf_size = (size_t)pState->read_buf_avail;
-                pState->status = tinfl_decompress(&pState->inflator, (const mz_uint8 *)pState->pRead_buf + pState->read_buf_ofs, &in_buf_size, (mz_uint8 *)pState->pWrite_buf, pWrite_buf_cur, &out_buf_size, pState->comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
-                pState->read_buf_avail -= in_buf_size;
-                pState->read_buf_ofs += in_buf_size;
-
-                /* Update current output block size remaining */
-                pState->out_blk_remain = out_buf_size;
-            }
-
-            if (pState->out_blk_remain)
-            {
-                /* Calc amount to return. */
-                size_t to_copy = MZ_MIN( (buf_size - copied_to_caller), pState->out_blk_remain );
-
-                /* Copy data to caller's buffer */
-                memcpy( (uint8_t*)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy );
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                /* Perform CRC */
-                pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy);
-#endif
-
-                /* Decrement data consumed from block */
-                pState->out_blk_remain -= to_copy;
-
-                /* Inc output offset, while performing sanity check */
-                if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size)
-                {
-                    mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-                    pState->status = TINFL_STATUS_FAILED;
-                    break;
-                }
-
-                /* Increment counter of data copied to caller */
-                copied_to_caller += to_copy;
-            }
-        } while ( (copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT)) );
-    }
-
-    /* Return how many bytes were copied into user buffer */
-    return copied_to_caller;
-}
-
-mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState)
-{
-    int status;
-
-    /* Argument sanity check */
-    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState))
-        return MZ_FALSE;
-
-    /* Was decompression completed and requested? */
-    if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
-    {
-        /* Make sure the entire file was decompressed, and check its CRC. */
-        if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size)
-        {
-            mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
-            pState->status = TINFL_STATUS_FAILED;
-        }
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        else if (pState->file_crc32 != pState->file_stat.m_crc32)
-        {
-            mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-            pState->status = TINFL_STATUS_FAILED;
-        }
-#endif
-    }
-
-    /* Free buffers */
-    if (!pState->pZip->m_pState->m_pMem)
-        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf);
-    if (pState->pWrite_buf)
-        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf);
-
-    /* Save status */
-    status = pState->status;
-
-    /* Free context */
-    pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState);
-
-    return status == TINFL_STATUS_DONE;
-}
-
-#ifndef MINIZ_NO_STDIO
-static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
-{
-    (void)ofs;
-
-    return MZ_FWRITE(pBuf, 1, n, (MZ_FILE *)pOpaque);
-}
-
-mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
-{
-    mz_bool status;
-    mz_zip_archive_file_stat file_stat;
-    MZ_FILE *pFile;
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-
-    pFile = MZ_FOPEN(pDst_filename, "wb");
-    if (!pFile)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
-
-    if (MZ_FCLOSE(pFile) == EOF)
-    {
-        if (status)
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
-
-        status = MZ_FALSE;
-    }
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
-    if (status)
-        mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
-#endif
-
-    return status;
-}
-
-mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
-        return MZ_FALSE;
-
-    return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags);
-}
-
-mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *pFile, mz_uint flags)
-{
-    mz_zip_archive_file_stat file_stat;
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-
-    return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
-}
-
-mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
-        return MZ_FALSE;
-
-    return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags);
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
-{
-    mz_uint32 *p = (mz_uint32 *)pOpaque;
-    (void)file_ofs;
-    *p = (mz_uint32)mz_crc32(*p, (const mz_uint8 *)pBuf, n);
-    return n;
-}
-
-mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
-{
-    mz_zip_archive_file_stat file_stat;
-    mz_zip_internal_state *pState;
-    const mz_uint8 *pCentral_dir_header;
-    mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE;
-    mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-    mz_uint64 local_header_ofs = 0;
-    mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32;
-    mz_uint64 local_header_comp_size, local_header_uncomp_size;
-    mz_uint32 uncomp_crc32 = MZ_CRC32_INIT;
-    mz_bool has_data_descriptor;
-    mz_uint32 local_header_bit_flags;
-
-    mz_zip_array file_data_array;
-    mz_zip_array_init(&file_data_array, 1);
-
-    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (file_index > pZip->m_total_files)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    pCentral_dir_header = mz_zip_get_cdh(pZip, file_index);
-
-    if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir))
-        return MZ_FALSE;
-
-    /* A directory or zero length file */
-    if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size))
-        return MZ_TRUE;
-
-    /* Encryption and patch files are not supported. */
-    if (file_stat.m_is_encrypted)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-    /* This function only supports stored and deflate. */
-    if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-
-    if (!file_stat.m_is_supported)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-
-    /* Read and parse the local directory entry. */
-    local_header_ofs = file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    local_header_filename_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
-    local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
-    local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
-    local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS);
-    local_header_bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
-    has_data_descriptor = (local_header_bit_flags & 8) != 0;
-
-    if (local_header_filename_len != strlen(file_stat.m_filename))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if ((local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    if (local_header_filename_len)
-    {
-        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE, file_data_array.m_p, local_header_filename_len) != local_header_filename_len)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            goto handle_failure;
-        }
-
-        /* I've seen 1 archive that had the same pathname, but used backslashes in the local dir and forward slashes in the central dir. Do we care about this? For now, this case will fail validation. */
-        if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            goto handle_failure;
-        }
-    }
-
-    if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
-    {
-        mz_uint32 extra_size_remaining = local_header_extra_len;
-        const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p;
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            goto handle_failure;
-        }
-
-        do
-        {
-            mz_uint32 field_id, field_data_size, field_total_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
-
-            if (field_total_size > extra_size_remaining)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-            {
-                const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
-
-                if (field_data_size < sizeof(mz_uint64) * 2)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-                    goto handle_failure;
-                }
-
-                local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
-                local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64));
-
-                found_zip64_ext_data_in_ldir = MZ_TRUE;
-                break;
-            }
-
-            pExtra_data += field_total_size;
-            extra_size_remaining -= field_total_size;
-        } while (extra_size_remaining);
-    }
-
-    /* TODO: parse local header extra data when local_header_comp_size is 0xFFFFFFFF! (big_descriptor.zip) */
-    /* I've seen zips in the wild with the data descriptor bit set, but proper local header values and bogus data descriptors */
-    if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))
-    {
-        mz_uint8 descriptor_buf[32];
-        mz_bool has_id;
-        const mz_uint8 *pSrc;
-        mz_uint32 file_crc32;
-        mz_uint64 comp_size = 0, uncomp_size = 0;
-
-        mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size, descriptor_buf, sizeof(mz_uint32) * num_descriptor_uint32s) != (sizeof(mz_uint32) * num_descriptor_uint32s))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            goto handle_failure;
-        }
-
-        has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
-        pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf;
-
-        file_crc32 = MZ_READ_LE32(pSrc);
-
-        if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir))
-        {
-            comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32));
-            uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64));
-        }
-        else
-        {
-            comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32));
-            uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32));
-        }
-
-        if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            goto handle_failure;
-        }
-    }
-    else
-    {
-        if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            goto handle_failure;
-        }
-    }
-
-    mz_zip_array_clear(pZip, &file_data_array);
-
-    if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0)
-    {
-        if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0))
-            return MZ_FALSE;
-
-        /* 1 more check to be sure, although the extract checks too. */
-        if (uncomp_crc32 != file_stat.m_crc32)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            return MZ_FALSE;
-        }
-    }
-
-    return MZ_TRUE;
-
-handle_failure:
-    mz_zip_array_clear(pZip, &file_data_array);
-    return MZ_FALSE;
-}
-
-mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)
-{
-    mz_zip_internal_state *pState;
-    uint32_t i;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    /* Basic sanity checks */
-    if (!pState->m_zip64)
-    {
-        if (pZip->m_total_files > MZ_UINT16_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        if (pZip->m_archive_size > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-    }
-    else
-    {
-        if (pZip->m_total_files >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-    }
-
-    for (i = 0; i < pZip->m_total_files; i++)
-    {
-        if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags)
-        {
-            mz_uint32 found_index;
-            mz_zip_archive_file_stat stat;
-
-            if (!mz_zip_reader_file_stat(pZip, i, &stat))
-                return MZ_FALSE;
-
-            if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index))
-                return MZ_FALSE;
-
-            /* This check can fail if there are duplicate filenames in the archive (which we don't check for when writing - that's up to the user) */
-            if (found_index != i)
-                return mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-        }
-
-        if (!mz_zip_validate_file(pZip, i, flags))
-            return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr)
-{
-    mz_bool success = MZ_TRUE;
-    mz_zip_archive zip;
-    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
-
-    if ((!pMem) || (!size))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-        return MZ_FALSE;
-    }
-
-    mz_zip_zero_struct(&zip);
-
-    if (!mz_zip_reader_init_mem(&zip, pMem, size, flags))
-    {
-        if (pErr)
-            *pErr = zip.m_last_error;
-        return MZ_FALSE;
-    }
-
-    if (!mz_zip_validate_archive(&zip, flags))
-    {
-        actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (!mz_zip_reader_end_internal(&zip, success))
-    {
-        if (!actual_err)
-            actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (pErr)
-        *pErr = actual_err;
-
-    return success;
-}
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr)
-{
-    mz_bool success = MZ_TRUE;
-    mz_zip_archive zip;
-    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
-
-    if (!pFilename)
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-        return MZ_FALSE;
-    }
-
-    mz_zip_zero_struct(&zip);
-
-    if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0))
-    {
-        if (pErr)
-            *pErr = zip.m_last_error;
-        return MZ_FALSE;
-    }
-
-    if (!mz_zip_validate_archive(&zip, flags))
-    {
-        actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (!mz_zip_reader_end_internal(&zip, success))
-    {
-        if (!actual_err)
-            actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (pErr)
-        *pErr = actual_err;
-
-    return success;
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-/* ------------------- .ZIP archive writing */
-
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-
-static MZ_FORCEINLINE void mz_write_le16(mz_uint8 *p, mz_uint16 v)
-{
-    p[0] = (mz_uint8)v;
-    p[1] = (mz_uint8)(v >> 8);
-}
-static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v)
-{
-    p[0] = (mz_uint8)v;
-    p[1] = (mz_uint8)(v >> 8);
-    p[2] = (mz_uint8)(v >> 16);
-    p[3] = (mz_uint8)(v >> 24);
-}
-static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v)
-{
-    mz_write_le32(p, (mz_uint32)v);
-    mz_write_le32(p + sizeof(mz_uint32), (mz_uint32)(v >> 32));
-}
-
-#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))
-#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))
-#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v))
-
-static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    mz_zip_internal_state *pState = pZip->m_pState;
-    mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size);
-
-    if (!n)
-        return 0;
-
-    /* An allocation this big is likely to just fail on 32-bit systems, so don't even go there. */
-    if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
-        return 0;
-    }
-
-    if (new_size > pState->m_mem_capacity)
-    {
-        void *pNew_block;
-        size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity);
-
-        while (new_capacity < new_size)
-            new_capacity *= 2;
-
-        if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity)))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            return 0;
-        }
-
-        pState->m_pMem = pNew_block;
-        pState->m_mem_capacity = new_capacity;
-    }
-    memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n);
-    pState->m_mem_size = (size_t)new_size;
-    return n;
-}
-
-static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
-{
-    mz_zip_internal_state *pState;
-    mz_bool status = MZ_TRUE;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)))
-    {
-        if (set_last_error)
-            mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    pState = pZip->m_pState;
-    pZip->m_pState = NULL;
-    mz_zip_array_clear(pZip, &pState->m_central_dir);
-    mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
-    mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
-
-#ifndef MINIZ_NO_STDIO
-    if (pState->m_pFile)
-    {
-        if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
-        {
-            if (MZ_FCLOSE(pState->m_pFile) == EOF)
-            {
-                if (set_last_error)
-                    mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
-                status = MZ_FALSE;
-            }
-        }
-
-        pState->m_pFile = NULL;
-    }
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-    if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem);
-        pState->m_pMem = NULL;
-    }
-
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-    pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
-    return status;
-}
-
-mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)
-{
-    mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0;
-
-    if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-    {
-        if (!pZip->m_pRead)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    if (pZip->m_file_offset_alignment)
-    {
-        /* Ensure user specified file offset alignment is a power of 2. */
-        if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1))
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    if (!pZip->m_pAlloc)
-        pZip->m_pAlloc = miniz_def_alloc_func;
-    if (!pZip->m_pFree)
-        pZip->m_pFree = miniz_def_free_func;
-    if (!pZip->m_pRealloc)
-        pZip->m_pRealloc = miniz_def_realloc_func;
-
-    pZip->m_archive_size = existing_size;
-    pZip->m_central_directory_file_ofs = 0;
-    pZip->m_total_files = 0;
-
-    if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
-
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
-
-    pZip->m_pState->m_zip64 = zip64;
-    pZip->m_pState->m_zip64_has_extended_info_fields = zip64;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
-    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size)
-{
-    return mz_zip_writer_init_v2(pZip, existing_size, 0);
-}
-
-mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)
-{
-    pZip->m_pWrite = mz_zip_heap_write_func;
-    pZip->m_pNeeds_keepalive = NULL;
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-        pZip->m_pRead = mz_zip_mem_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-
-    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_HEAP;
-
-    if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
-    {
-        if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
-        {
-            mz_zip_writer_end_internal(pZip, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-        pZip->m_pState->m_mem_capacity = initial_allocation_size;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
-{
-    return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, initial_allocation_size, 0);
-}
-
-#ifndef MINIZ_NO_STDIO
-static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
-
-    file_ofs += pZip->m_pState->m_file_archive_start_ofs;
-
-    if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
-        return 0;
-    }
-
-    return MZ_FWRITE(pBuf, 1, n, pZip->m_pState->m_pFile);
-}
-
-mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)
-{
-    return mz_zip_writer_init_file_v2(pZip, pFilename, size_to_reserve_at_beginning, 0);
-}
-
-mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)
-{
-    MZ_FILE *pFile;
-
-    pZip->m_pWrite = mz_zip_file_write_func;
-    pZip->m_pNeeds_keepalive = NULL;
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-        pZip->m_pRead = mz_zip_file_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-
-    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
-        return MZ_FALSE;
-
-    if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb")))
-    {
-        mz_zip_writer_end(pZip);
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-    }
-
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
-
-    if (size_to_reserve_at_beginning)
-    {
-        mz_uint64 cur_ofs = 0;
-        char buf[4096];
-
-        MZ_CLEAR_OBJ(buf);
-
-        do
-        {
-            size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
-            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
-            {
-                mz_zip_writer_end(pZip);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-            }
-            cur_ofs += n;
-            size_to_reserve_at_beginning -= n;
-        } while (size_to_reserve_at_beginning);
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags)
-{
-    pZip->m_pWrite = mz_zip_file_write_func;
-    pZip->m_pNeeds_keepalive = NULL;
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-        pZip->m_pRead = mz_zip_file_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-
-    if (!mz_zip_writer_init_v2(pZip, 0, flags))
-        return MZ_FALSE;
-
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_pState->m_file_archive_start_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
-    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
-
-    return MZ_TRUE;
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
-{
-    mz_zip_internal_state *pState;
-
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ZIP64)
-    {
-        /* We don't support converting a non-zip64 file to zip64 - this seems like more trouble than it's worth. (What about the existing 32-bit data descriptors that could follow the compressed data?) */
-        if (!pZip->m_pState->m_zip64)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    /* No sense in trying to write to an archive that's already at the support max size */
-    if (pZip->m_pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-        if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
-    }
-
-    pState = pZip->m_pState;
-
-    if (pState->m_pFile)
-    {
-#ifdef MINIZ_NO_STDIO
-        (void)pFilename;
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-#else
-        if (pZip->m_pIO_opaque != pZip)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-        if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
-        {
-            if (!pFilename)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-            /* Archive is being read from stdio and was originally opened only for reading. Try to reopen as writable. */
-            if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile)))
-            {
-                /* The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it. */
-                mz_zip_reader_end_internal(pZip, MZ_FALSE);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-            }
-        }
-
-        pZip->m_pWrite = mz_zip_file_write_func;
-        pZip->m_pNeeds_keepalive = NULL;
-#endif /* #ifdef MINIZ_NO_STDIO */
-    }
-    else if (pState->m_pMem)
-    {
-        /* Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback. */
-        if (pZip->m_pIO_opaque != pZip)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-        pState->m_mem_capacity = pState->m_mem_size;
-        pZip->m_pWrite = mz_zip_heap_write_func;
-        pZip->m_pNeeds_keepalive = NULL;
-    }
-    /* Archive is being read via a user provided read function - make sure the user has specified a write function too. */
-    else if (!pZip->m_pWrite)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* Start writing new files at the archive's current central directory location. */
-    /* TODO: We could add a flag that lets the user start writing immediately AFTER the existing central dir - this would be safer. */
-    pZip->m_archive_size = pZip->m_central_directory_file_ofs;
-    pZip->m_central_directory_file_ofs = 0;
-
-    /* Clear the sorted central dir offsets, they aren't useful or maintained now. */
-    /* Even though we're now in write mode, files can still be extracted and verified, but file locates will be slow. */
-    /* TODO: We could easily maintain the sorted central directory offsets. */
-    mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets);
-
-    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename)
-{
-    return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0);
-}
-
-/* TODO: pArchive_name is a terrible name here! */
-mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags)
-{
-    return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0);
-}
-
-typedef struct
-{
-    mz_zip_archive *m_pZip;
-    mz_uint64 m_cur_archive_file_ofs;
-    mz_uint64 m_comp_size;
-} mz_zip_writer_add_state;
-
-static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)
-{
-    mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser;
-    if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len)
-        return MZ_FALSE;
-
-    pState->m_cur_archive_file_ofs += len;
-    pState->m_comp_size += len;
-    return MZ_TRUE;
-}
-
-#define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2)
-#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3)
-static mz_uint32 mz_zip_writer_create_zip64_extra_data(mz_uint8 *pBuf, mz_uint64 *pUncomp_size, mz_uint64 *pComp_size, mz_uint64 *pLocal_header_ofs)
-{
-    mz_uint8 *pDst = pBuf;
-    mz_uint32 field_size = 0;
-
-    MZ_WRITE_LE16(pDst + 0, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID);
-    MZ_WRITE_LE16(pDst + 2, 0);
-    pDst += sizeof(mz_uint16) * 2;
-
-    if (pUncomp_size)
-    {
-        MZ_WRITE_LE64(pDst, *pUncomp_size);
-        pDst += sizeof(mz_uint64);
-        field_size += sizeof(mz_uint64);
-    }
-
-    if (pComp_size)
-    {
-        MZ_WRITE_LE64(pDst, *pComp_size);
-        pDst += sizeof(mz_uint64);
-        field_size += sizeof(mz_uint64);
-    }
-
-    if (pLocal_header_ofs)
-    {
-        MZ_WRITE_LE64(pDst, *pLocal_header_ofs);
-        pDst += sizeof(mz_uint64);
-        field_size += sizeof(mz_uint64);
-    }
-
-    MZ_WRITE_LE16(pBuf + 2, field_size);
-
-    return (mz_uint32)(pDst - pBuf);
-}
-
-static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
-{
-    (void)pZip;
-    memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size);
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst,
-                                                       mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size,
-                                                       mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32,
-                                                       mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date,
-                                                       mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
-{
-    (void)pZip;
-    memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_MIN(local_header_ofs, MZ_UINT32_MAX));
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size,
-                                                const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size,
-                                                mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32,
-                                                mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date,
-                                                mz_uint64 local_header_ofs, mz_uint32 ext_attributes,
-                                                const char *user_extra_data, mz_uint user_extra_data_len)
-{
-    mz_zip_internal_state *pState = pZip->m_pState;
-    mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size;
-    size_t orig_central_dir_size = pState->m_central_dir.m_size;
-    mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
-
-    if (!pZip->m_pState->m_zip64)
-    {
-        if (local_header_ofs > 0xFFFFFFFF)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
-    }
-
-    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
-    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + user_extra_data_len + comment_size) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    if (!mz_zip_writer_create_central_dir_header(pZip, central_dir_header, filename_size, extra_size + user_extra_data_len, comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes))
-        return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-    if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, user_extra_data_len)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &central_dir_ofs, 1)))
-    {
-        /* Try to resize the central directory array back into its original state. */
-        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
-{
-    /* Basic ZIP archive filename validity checks: Valid filenames cannot start with a forward slash, cannot contain a drive letter, and cannot use DOS-style backward slashes. */
-    if (*pArchive_name == '/')
-        return MZ_FALSE;
-
-    while (*pArchive_name)
-    {
-        if ((*pArchive_name == '\\') || (*pArchive_name == ':'))
-            return MZ_FALSE;
-
-        pArchive_name++;
-    }
-
-    return MZ_TRUE;
-}
-
-static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
-{
-    mz_uint32 n;
-    if (!pZip->m_file_offset_alignment)
-        return 0;
-    n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1));
-    return (mz_uint)((pZip->m_file_offset_alignment - n) & (pZip->m_file_offset_alignment - 1));
-}
-
-static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
-{
-    char buf[4096];
-    memset(buf, 0, MZ_MIN(sizeof(buf), n));
-    while (n)
-    {
-        mz_uint32 s = MZ_MIN(sizeof(buf), n);
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_file_ofs += s;
-        n -= s;
-    }
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32)
-{
-    return mz_zip_writer_add_mem_ex_v2(pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, uncomp_size, uncomp_crc32, NULL, NULL, 0, NULL, 0);
-}
-
-mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size,
-                                    mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified,
-                                    const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
-{
-    mz_uint16 method = 0, dos_time = 0, dos_date = 0;
-    mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
-    mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0;
-    size_t archive_name_size;
-    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
-    tdefl_compressor *pComp = NULL;
-    mz_bool store_data_uncompressed;
-    mz_zip_internal_state *pState;
-    mz_uint8 *pExtra_data = NULL;
-    mz_uint32 extra_size = 0;
-    mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
-    mz_uint16 bit_flags = 0;
-
-    if ((int)level_and_flags < 0)
-        level_and_flags = MZ_DEFAULT_LEVEL;
-
-    if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
-        bit_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
-
-    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
-        bit_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
-
-    level = level_and_flags & 0xF;
-    store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA));
-
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    if (pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
-        }
-        if ((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        }
-    }
-
-    if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_writer_validate_archive_name(pArchive_name))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-#ifndef MINIZ_NO_TIME
-    if (last_modified != NULL)
-    {
-        mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date);
-    }
-    else
-    {
-        MZ_TIME_T cur_time;
-        time(&cur_time);
-        mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date);
-    }
-#endif /* #ifndef MINIZ_NO_TIME */
-
-	if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-	{
-		uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
-		uncomp_size = buf_size;
-		if (uncomp_size <= 3)
-		{
-			level = 0;
-			store_data_uncompressed = MZ_TRUE;
-		}
-	}
-
-    archive_name_size = strlen(pArchive_name);
-    if (archive_name_size > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
-
-    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
-    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    if (!pState->m_zip64)
-    {
-        /* Bail early if the archive would obviously become too large */
-        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size
-			+ MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
-			pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
-			+ MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        }
-    }
-
-    if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/'))
-    {
-        /* Set DOS Subdirectory attribute bit. */
-        ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG;
-
-        /* Subdirectories cannot contain data. */
-        if ((buf_size) || (uncomp_size))
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    /* Try to do any allocations before writing to the archive, so if an allocation fails the file remains unmodified. (A good idea if we're doing an in-place modification.) */
-    if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1)))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    if ((!store_data_uncompressed) && (buf_size))
-    {
-        if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor))))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-        return MZ_FALSE;
-    }
-
-    local_dir_header_ofs += num_alignment_padding_bytes;
-    if (pZip->m_file_offset_alignment)
-    {
-        MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
-    }
-    cur_archive_file_ofs += num_alignment_padding_bytes;
-
-    MZ_CLEAR_OBJ(local_dir_header);
-
-    if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-    {
-        method = MZ_DEFLATED;
-    }
-
-    if (pState->m_zip64)
-    {
-        if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
-        {
-            pExtra_data = extra_data;
-            extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                               (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-        }
-
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, extra_size + user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-        cur_archive_file_ofs += archive_name_size;
-
-        if (pExtra_data != NULL)
-        {
-            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-            cur_archive_file_ofs += extra_size;
-        }
-    }
-    else
-    {
-        if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-        cur_archive_file_ofs += archive_name_size;
-    }
-
-	if (user_extra_data_len > 0)
-	{
-		if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
-			return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-		cur_archive_file_ofs += user_extra_data_len;
-	}
-
-    if (store_data_uncompressed)
-    {
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_archive_file_ofs += buf_size;
-        comp_size = buf_size;
-    }
-    else if (buf_size)
-    {
-        mz_zip_writer_add_state state;
-
-        state.m_pZip = pZip;
-        state.m_cur_archive_file_ofs = cur_archive_file_ofs;
-        state.m_comp_size = 0;
-
-        if ((tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) ||
-            (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE))
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
-        }
-
-        comp_size = state.m_comp_size;
-        cur_archive_file_ofs = state.m_cur_archive_file_ofs;
-    }
-
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-    pComp = NULL;
-
-    if (uncomp_size)
-    {
-        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
-        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
-
-        MZ_ASSERT(bit_flags & MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR);
-
-        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
-        MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
-        if (pExtra_data == NULL)
-        {
-            if (comp_size > MZ_UINT32_MAX)
-                return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-            MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
-        }
-        else
-        {
-            MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
-            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
-        }
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
-            return MZ_FALSE;
-
-        cur_archive_file_ofs += local_dir_footer_size;
-    }
-
-    if (pExtra_data != NULL)
-    {
-        extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                           (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-    }
-
-    if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, extra_size, pComment,
-                                          comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
-                                          user_extra_data_central, user_extra_data_central_len))
-        return MZ_FALSE;
-
-    pZip->m_total_files++;
-    pZip->m_archive_size = cur_archive_file_ofs;
-
-    return MZ_TRUE;
-}
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
-{
-    mz_uint16 gen_flags = MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
-    mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
-    mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
-    mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = size_to_add, comp_size = 0;
-    size_t archive_name_size;
-    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
-    mz_uint8 *pExtra_data = NULL;
-    mz_uint32 extra_size = 0;
-    mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
-    mz_zip_internal_state *pState;
-
-    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
-        gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
-
-    if ((int)level_and_flags < 0)
-        level_and_flags = MZ_DEFAULT_LEVEL;
-    level = level_and_flags & 0xF;
-
-    /* Sanity checks */
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    if ((!pState->m_zip64) && (uncomp_size > MZ_UINT32_MAX))
-    {
-        /* Source file is too large for non-zip64 */
-        /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        pState->m_zip64 = MZ_TRUE;
-    }
-
-    /* We could support this, but why? */
-    if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_writer_validate_archive_name(pArchive_name))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-    if (pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
-        }
-    }
-
-    archive_name_size = strlen(pArchive_name);
-    if (archive_name_size > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
-
-    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
-    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    if (!pState->m_zip64)
-    {
-        /* Bail early if the archive would obviously become too large */
-        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
-			+ archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
-			+ MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        }
-    }
-
-#ifndef MINIZ_NO_TIME
-    if (pFile_time)
-    {
-        mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date);
-    }
-#endif
-
-    if (uncomp_size <= 3)
-        level = 0;
-
-    if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
-    {
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-    }
-
-    cur_archive_file_ofs += num_alignment_padding_bytes;
-    local_dir_header_ofs = cur_archive_file_ofs;
-
-    if (pZip->m_file_offset_alignment)
-    {
-        MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
-    }
-
-    if (uncomp_size && level)
-    {
-        method = MZ_DEFLATED;
-    }
-
-    MZ_CLEAR_OBJ(local_dir_header);
-    if (pState->m_zip64)
-    {
-        if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
-        {
-            pExtra_data = extra_data;
-            extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                               (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-        }
-
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, extra_size + user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_archive_file_ofs += archive_name_size;
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += extra_size;
-    }
-    else
-    {
-        if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_archive_file_ofs += archive_name_size;
-    }
-
-    if (user_extra_data_len > 0)
-    {
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += user_extra_data_len;
-    }
-
-    if (uncomp_size)
-    {
-        mz_uint64 uncomp_remaining = uncomp_size;
-        void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE);
-        if (!pRead_buf)
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!level)
-        {
-            while (uncomp_remaining)
-            {
-                mz_uint n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, uncomp_remaining);
-                if ((MZ_FREAD(pRead_buf, 1, n, pSrc_file) != n) || (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n))
-                {
-                    pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                }
-                uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
-                uncomp_remaining -= n;
-                cur_archive_file_ofs += n;
-            }
-            comp_size = uncomp_size;
-        }
-        else
-        {
-            mz_bool result = MZ_FALSE;
-            mz_zip_writer_add_state state;
-            tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
-            if (!pComp)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            }
-
-            state.m_pZip = pZip;
-            state.m_cur_archive_file_ofs = cur_archive_file_ofs;
-            state.m_comp_size = 0;
-
-            if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-            }
-
-            for (;;)
-            {
-                size_t in_buf_size = (mz_uint32)MZ_MIN(uncomp_remaining, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
-                tdefl_status status;
-                tdefl_flush flush = TDEFL_NO_FLUSH;
-
-                if (MZ_FREAD(pRead_buf, 1, in_buf_size, pSrc_file) != in_buf_size)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                    break;
-                }
-
-                uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, in_buf_size);
-                uncomp_remaining -= in_buf_size;
-
-                if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque))
-                    flush = TDEFL_FULL_FLUSH;
-
-                status = tdefl_compress_buffer(pComp, pRead_buf, in_buf_size, uncomp_remaining ? flush : TDEFL_FINISH);
-                if (status == TDEFL_STATUS_DONE)
-                {
-                    result = MZ_TRUE;
-                    break;
-                }
-                else if (status != TDEFL_STATUS_OKAY)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
-                    break;
-                }
-            }
-
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-
-            if (!result)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                return MZ_FALSE;
-            }
-
-            comp_size = state.m_comp_size;
-            cur_archive_file_ofs = state.m_cur_archive_file_ofs;
-        }
-
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-    }
-
-    {
-        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
-        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
-
-        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
-        MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
-        if (pExtra_data == NULL)
-        {
-            if (comp_size > MZ_UINT32_MAX)
-                return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-            MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
-        }
-        else
-        {
-            MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
-            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
-        }
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
-            return MZ_FALSE;
-
-        cur_archive_file_ofs += local_dir_footer_size;
-    }
-
-    if (pExtra_data != NULL)
-    {
-        extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                           (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-    }
-
-    if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, extra_size, pComment, comment_size,
-                                          uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
-                                          user_extra_data_central, user_extra_data_central_len))
-        return MZ_FALSE;
-
-    pZip->m_total_files++;
-    pZip->m_archive_size = cur_archive_file_ofs;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
-{
-    MZ_FILE *pSrc_file = NULL;
-    mz_uint64 uncomp_size = 0;
-    MZ_TIME_T file_modified_time;
-    MZ_TIME_T *pFile_time = NULL;
-    mz_bool status;
-
-    memset(&file_modified_time, 0, sizeof(file_modified_time));
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
-    pFile_time = &file_modified_time;
-    if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED);
-#endif
-
-    pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
-    if (!pSrc_file)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    MZ_FSEEK64(pSrc_file, 0, SEEK_END);
-    uncomp_size = MZ_FTELL64(pSrc_file);
-    MZ_FSEEK64(pSrc_file, 0, SEEK_SET);
-
-    status = mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);
-
-    MZ_FCLOSE(pSrc_file);
-
-    return status;
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-static mz_bool mz_zip_writer_update_zip64_extension_block(mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, uint32_t ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start)
-{
-    /* + 64 should be enough for any new zip64 data */
-    if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    mz_zip_array_resize(pZip, pNew_ext, 0, MZ_FALSE);
-
-    if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start))
-    {
-        mz_uint8 new_ext_block[64];
-        mz_uint8 *pDst = new_ext_block;
-        mz_write_le16(pDst, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID);
-        mz_write_le16(pDst + sizeof(mz_uint16), 0);
-        pDst += sizeof(mz_uint16) * 2;
-
-        if (pUncomp_size)
-        {
-            mz_write_le64(pDst, *pUncomp_size);
-            pDst += sizeof(mz_uint64);
-        }
-
-        if (pComp_size)
-        {
-            mz_write_le64(pDst, *pComp_size);
-            pDst += sizeof(mz_uint64);
-        }
-
-        if (pLocal_header_ofs)
-        {
-            mz_write_le64(pDst, *pLocal_header_ofs);
-            pDst += sizeof(mz_uint64);
-        }
-
-        if (pDisk_start)
-        {
-            mz_write_le32(pDst, *pDisk_start);
-            pDst += sizeof(mz_uint32);
-        }
-
-        mz_write_le16(new_ext_block + sizeof(mz_uint16), (mz_uint16)((pDst - new_ext_block) - sizeof(mz_uint16) * 2));
-
-        if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, pDst - new_ext_block))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    if ((pExt) && (ext_len))
-    {
-        mz_uint32 extra_size_remaining = ext_len;
-        const mz_uint8 *pExtra_data = pExt;
-
-        do
-        {
-            mz_uint32 field_id, field_data_size, field_total_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
-
-            if (field_total_size > extra_size_remaining)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            if (field_id != MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-            {
-                if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, field_total_size))
-                    return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            }
-
-            pExtra_data += field_total_size;
-            extra_size_remaining -= field_total_size;
-        } while (extra_size_remaining);
-    }
-
-    return MZ_TRUE;
-}
-
-/* TODO: This func is now pretty freakin complex due to zip64, split it up? */
-mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index)
-{
-    mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
-    mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
-    mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-    mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
-    size_t orig_central_dir_size;
-    mz_zip_internal_state *pState;
-    void *pBuf;
-    const mz_uint8 *pSrc_central_header;
-    mz_zip_archive_file_stat src_file_stat;
-    mz_uint32 src_filename_len, src_comment_len, src_ext_len;
-    mz_uint32 local_header_filename_size, local_header_extra_len;
-    mz_uint64 local_header_comp_size, local_header_uncomp_size;
-    mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
-
-    /* Sanity checks */
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    /* Don't support copying files from zip64 archives to non-zip64, even though in some cases this is possible */
-    if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* Get pointer to the source central dir header and crack it */
-    if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index)))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    src_filename_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    src_comment_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS);
-    src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-    src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;
-
-    /* TODO: We don't support central dir's >= MZ_UINT32_MAX bytes right now (+32 fudge factor in case we need to add more extra data) */
-    if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
-
-    if (!pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        /* TODO: Our zip64 support still has some 32-bit limits that may not be worth fixing. */
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-
-    if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL))
-        return MZ_FALSE;
-
-    cur_src_file_ofs = src_file_stat.m_local_header_ofs;
-    cur_dst_file_ofs = pZip->m_archive_size;
-
-    /* Read the source archive's local dir header */
-    if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
-
-    /* Compute the total size we need to copy (filename+extra data+compressed data) */
-    local_header_filename_size = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
-    local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
-    local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
-    src_archive_bytes_remaining = local_header_filename_size + local_header_extra_len + src_file_stat.m_comp_size;
-
-    /* Try to find a zip64 extended information field */
-    if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
-    {
-        mz_zip_array file_data_array;
-        const mz_uint8 *pExtra_data;
-        mz_uint32 extra_size_remaining = local_header_extra_len;
-
-        mz_zip_array_init(&file_data_array, 1);
-        if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE))
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, src_file_stat.m_local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_size, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
-        {
-            mz_zip_array_clear(pZip, &file_data_array);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-        }
-
-        pExtra_data = (const mz_uint8 *)file_data_array.m_p;
-
-        do
-        {
-            mz_uint32 field_id, field_data_size, field_total_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-            {
-                mz_zip_array_clear(pZip, &file_data_array);
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
-
-            if (field_total_size > extra_size_remaining)
-            {
-                mz_zip_array_clear(pZip, &file_data_array);
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-            {
-                const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
-
-                if (field_data_size < sizeof(mz_uint64) * 2)
-                {
-                    mz_zip_array_clear(pZip, &file_data_array);
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-                }
-
-                local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
-                local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */
-
-                found_zip64_ext_data_in_ldir = MZ_TRUE;
-                break;
-            }
-
-            pExtra_data += field_total_size;
-            extra_size_remaining -= field_total_size;
-        } while (extra_size_remaining);
-
-        mz_zip_array_clear(pZip, &file_data_array);
-    }
-
-    if (!pState->m_zip64)
-    {
-        /* Try to detect if the new archive will most likely wind up too big and bail early (+(sizeof(mz_uint32) * 4) is for the optional descriptor which could be present, +64 is a fudge factor). */
-        /* We also check when the archive is finalized so this doesn't need to be perfect. */
-        mz_uint64 approx_new_archive_size = cur_dst_file_ofs + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + src_archive_bytes_remaining + (sizeof(mz_uint32) * 4) +
-                                            pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 64;
-
-        if (approx_new_archive_size >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-    }
-
-    /* Write dest archive padding */
-    if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes))
-        return MZ_FALSE;
-
-    cur_dst_file_ofs += num_alignment_padding_bytes;
-
-    local_dir_header_ofs = cur_dst_file_ofs;
-    if (pZip->m_file_offset_alignment)
-    {
-        MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
-    }
-
-    /* The original zip's local header+ext block doesn't change, even with zip64, so we can just copy it over to the dest zip */
-    if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-    cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
-
-    /* Copy over the source archive bytes to the dest archive, also ensure we have enough buf space to handle optional data descriptor */
-    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining)))))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    while (src_archive_bytes_remaining)
-    {
-        n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining);
-        if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-        }
-        cur_src_file_ofs += n;
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-        cur_dst_file_ofs += n;
-
-        src_archive_bytes_remaining -= n;
-    }
-
-    /* Now deal with the optional data descriptor */
-    bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
-    if (bit_flags & 8)
-    {
-        /* Copy data descriptor */
-        if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))
-        {
-            /* src is zip64, dest must be zip64 */
-
-            /* name			uint32_t's */
-            /* id				1 (optional in zip64?) */
-            /* crc			1 */
-            /* comp_size	2 */
-            /* uncomp_size 2 */
-            if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            }
-
-            n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5);
-        }
-        else
-        {
-            /* src is NOT zip64 */
-            mz_bool has_id;
-
-            if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            }
-
-            has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
-
-            if (pZip->m_pState->m_zip64)
-            {
-                /* dest is zip64, so upgrade the data descriptor */
-                const mz_uint32 *pSrc_descriptor = (const mz_uint32 *)((const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0));
-                const mz_uint32 src_crc32 = pSrc_descriptor[0];
-                const mz_uint64 src_comp_size = pSrc_descriptor[1];
-                const mz_uint64 src_uncomp_size = pSrc_descriptor[2];
-
-                mz_write_le32((mz_uint8 *)pBuf, MZ_ZIP_DATA_DESCRIPTOR_ID);
-                mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32);
-                mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size);
-                mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, src_uncomp_size);
-
-                n = sizeof(mz_uint32) * 6;
-            }
-            else
-            {
-                /* dest is NOT zip64, just copy it as-is */
-                n = sizeof(mz_uint32) * (has_id ? 4 : 3);
-            }
-        }
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_src_file_ofs += n;
-        cur_dst_file_ofs += n;
-    }
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-
-    /* Finally, add the new central dir header */
-    orig_central_dir_size = pState->m_central_dir.m_size;
-
-    memcpy(new_central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
-
-    if (pState->m_zip64)
-    {
-        /* This is the painful part: We need to write a new central dir header + ext block with updated zip64 fields, and ensure the old fields (if any) are not included. */
-        const mz_uint8 *pSrc_ext = pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len;
-        mz_zip_array new_ext_block;
-
-        mz_zip_array_init(&new_ext_block, sizeof(mz_uint8));
-
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_UINT32_MAX);
-
-        if (!mz_zip_writer_update_zip64_extension_block(&new_ext_block, pZip, pSrc_ext, src_ext_len, &src_file_stat.m_comp_size, &src_file_stat.m_uncomp_size, &local_dir_header_ofs, NULL))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            return MZ_FALSE;
-        }
-
-        MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, new_ext_block.m_size);
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len + src_ext_len, src_comment_len))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        mz_zip_array_clear(pZip, &new_ext_block);
-    }
-    else
-    {
-        /* sanity checks */
-        if (cur_dst_file_ofs > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        if (local_dir_header_ofs >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs);
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_central_dir_following_data_size))
-        {
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-    }
-
-    /* This shouldn't trigger unless we screwed up during the initial sanity checks */
-    if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
-    {
-        /* TODO: Support central dirs >= 32-bits in size */
-        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-    }
-
-    n = (mz_uint32)orig_central_dir_size;
-    if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1))
-    {
-        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    pZip->m_total_files++;
-    pZip->m_archive_size = cur_dst_file_ofs;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)
-{
-    mz_zip_internal_state *pState;
-    mz_uint64 central_dir_ofs, central_dir_size;
-    mz_uint8 hdr[256];
-
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    if (pState->m_zip64)
-    {
-        if ((pZip->m_total_files > MZ_UINT32_MAX) || (pState->m_central_dir.m_size >= MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if ((pZip->m_total_files > MZ_UINT16_MAX) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-
-    central_dir_ofs = 0;
-    central_dir_size = 0;
-    if (pZip->m_total_files)
-    {
-        /* Write central directory */
-        central_dir_ofs = pZip->m_archive_size;
-        central_dir_size = pState->m_central_dir.m_size;
-        pZip->m_central_directory_file_ofs = central_dir_ofs;
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, pState->m_central_dir.m_p, (size_t)central_dir_size) != central_dir_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        pZip->m_archive_size += central_dir_size;
-    }
-
-    if (pState->m_zip64)
-    {
-        /* Write zip64 end of central directory header */
-        mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size;
-
-        MZ_CLEAR_OBJ(hdr);
-        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - sizeof(mz_uint32) - sizeof(mz_uint64));
-        MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, 0x031E); /* TODO: always Unix */
-        MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, pZip->m_total_files);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, pZip->m_total_files);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs);
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
-
-        /* Write zip64 end of central directory locator */
-        MZ_CLEAR_OBJ(hdr);
-        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, rel_ofs_to_zip64_ecdr);
-        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1);
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
-    }
-
-    /* Write end of central directory record */
-    MZ_CLEAR_OBJ(hdr);
-    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG);
-    MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
-    MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
-    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_size));
-    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_ofs));
-
-    if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-#ifndef MINIZ_NO_STDIO
-    if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF))
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-    pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE;
-
-    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED;
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize)
-{
-    if ((!ppBuf) || (!pSize))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    *ppBuf = NULL;
-    *pSize = 0;
-
-    if ((!pZip) || (!pZip->m_pState))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (pZip->m_pWrite != mz_zip_heap_write_func)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_writer_finalize_archive(pZip))
-        return MZ_FALSE;
-
-    *ppBuf = pZip->m_pState->m_pMem;
-    *pSize = pZip->m_pState->m_mem_size;
-    pZip->m_pState->m_pMem = NULL;
-    pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_end(mz_zip_archive *pZip)
-{
-    return mz_zip_writer_end_internal(pZip, MZ_TRUE);
-}
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
-{
-    return mz_zip_add_mem_to_archive_file_in_place_v2(pZip_filename, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, NULL);
-}
-
-mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr)
-{
-    mz_bool status, created_new_archive = MZ_FALSE;
-    mz_zip_archive zip_archive;
-    struct MZ_FILE_STAT_STRUCT file_stat;
-    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
-
-    mz_zip_zero_struct(&zip_archive);
-    if ((int)level_and_flags < 0)
-        level_and_flags = MZ_DEFAULT_LEVEL;
-
-    if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-        return MZ_FALSE;
-    }
-
-    if (!mz_zip_writer_validate_archive_name(pArchive_name))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_FILENAME;
-        return MZ_FALSE;
-    }
-
-    /* Important: The regular non-64 bit version of stat() can fail here if the file is very large, which could cause the archive to be overwritten. */
-    /* So be sure to compile with _LARGEFILE64_SOURCE 1 */
-    if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0)
-    {
-        /* Create a new archive. */
-        if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, level_and_flags))
-        {
-            if (pErr)
-                *pErr = zip_archive.m_last_error;
-            return MZ_FALSE;
-        }
-
-        created_new_archive = MZ_TRUE;
-    }
-    else
-    {
-        /* Append to an existing archive. */
-        if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
-        {
-            if (pErr)
-                *pErr = zip_archive.m_last_error;
-            return MZ_FALSE;
-        }
-
-        if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, level_and_flags))
-        {
-            if (pErr)
-                *pErr = zip_archive.m_last_error;
-
-            mz_zip_reader_end_internal(&zip_archive, MZ_FALSE);
-
-            return MZ_FALSE;
-        }
-    }
-
-    status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
-    actual_err = zip_archive.m_last_error;
-
-    /* Always finalize, even if adding failed for some reason, so we have a valid central directory. (This may not always succeed, but we can try.) */
-    if (!mz_zip_writer_finalize_archive(&zip_archive))
-    {
-        if (!actual_err)
-            actual_err = zip_archive.m_last_error;
-
-        status = MZ_FALSE;
-    }
-
-    if (!mz_zip_writer_end_internal(&zip_archive, status))
-    {
-        if (!actual_err)
-            actual_err = zip_archive.m_last_error;
-
-        status = MZ_FALSE;
-    }
-
-    if ((!status) && (created_new_archive))
-    {
-        /* It's a new archive and something went wrong, so just delete it. */
-        int ignoredStatus = MZ_DELETE_FILE(pZip_filename);
-        (void)ignoredStatus;
-    }
-
-    if (pErr)
-        *pErr = actual_err;
-
-    return status;
-}
-
-void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)
-{
-    mz_uint32 file_index;
-    mz_zip_archive zip_archive;
-    void *p = NULL;
-
-    if (pSize)
-        *pSize = 0;
-
-    if ((!pZip_filename) || (!pArchive_name))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-
-        return NULL;
-    }
-
-    mz_zip_zero_struct(&zip_archive);
-    if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
-    {
-        if (pErr)
-            *pErr = zip_archive.m_last_error;
-
-        return NULL;
-    }
-
-    if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index))
-    {
-        p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
-    }
-
-    mz_zip_reader_end_internal(&zip_archive, p != NULL);
-
-    if (pErr)
-        *pErr = zip_archive.m_last_error;
-
-    return p;
-}
-
-void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags)
-{
-    return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, NULL, pSize, flags, NULL);
-}
-
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-/* ------------------- Misc utils */
-
-mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip)
-{
-    return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID;
-}
-
-mz_zip_type mz_zip_get_type(mz_zip_archive *pZip)
-{
-    return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID;
-}
-
-mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
-{
-    mz_zip_error prev_err;
-
-    if (!pZip)
-        return MZ_ZIP_INVALID_PARAMETER;
-
-    prev_err = pZip->m_last_error;
-
-    pZip->m_last_error = err_num;
-    return prev_err;
-}
-
-mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip)
-{
-    if (!pZip)
-        return MZ_ZIP_INVALID_PARAMETER;
-
-    return pZip->m_last_error;
-}
-
-mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip)
-{
-    return mz_zip_set_last_error(pZip, MZ_ZIP_NO_ERROR);
-}
-
-mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip)
-{
-    mz_zip_error prev_err;
-
-    if (!pZip)
-        return MZ_ZIP_INVALID_PARAMETER;
-
-    prev_err = pZip->m_last_error;
-
-    pZip->m_last_error = MZ_ZIP_NO_ERROR;
-    return prev_err;
-}
-
-const char *mz_zip_get_error_string(mz_zip_error mz_err)
-{
-    switch (mz_err)
-    {
-        case MZ_ZIP_NO_ERROR:
-            return "no error";
-        case MZ_ZIP_UNDEFINED_ERROR:
-            return "undefined error";
-        case MZ_ZIP_TOO_MANY_FILES:
-            return "too many files";
-        case MZ_ZIP_FILE_TOO_LARGE:
-            return "file too large";
-        case MZ_ZIP_UNSUPPORTED_METHOD:
-            return "unsupported method";
-        case MZ_ZIP_UNSUPPORTED_ENCRYPTION:
-            return "unsupported encryption";
-        case MZ_ZIP_UNSUPPORTED_FEATURE:
-            return "unsupported feature";
-        case MZ_ZIP_FAILED_FINDING_CENTRAL_DIR:
-            return "failed finding central directory";
-        case MZ_ZIP_NOT_AN_ARCHIVE:
-            return "not a ZIP archive";
-        case MZ_ZIP_INVALID_HEADER_OR_CORRUPTED:
-            return "invalid header or archive is corrupted";
-        case MZ_ZIP_UNSUPPORTED_MULTIDISK:
-            return "unsupported multidisk archive";
-        case MZ_ZIP_DECOMPRESSION_FAILED:
-            return "decompression failed or archive is corrupted";
-        case MZ_ZIP_COMPRESSION_FAILED:
-            return "compression failed";
-        case MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE:
-            return "unexpected decompressed size";
-        case MZ_ZIP_CRC_CHECK_FAILED:
-            return "CRC-32 check failed";
-        case MZ_ZIP_UNSUPPORTED_CDIR_SIZE:
-            return "unsupported central directory size";
-        case MZ_ZIP_ALLOC_FAILED:
-            return "allocation failed";
-        case MZ_ZIP_FILE_OPEN_FAILED:
-            return "file open failed";
-        case MZ_ZIP_FILE_CREATE_FAILED:
-            return "file create failed";
-        case MZ_ZIP_FILE_WRITE_FAILED:
-            return "file write failed";
-        case MZ_ZIP_FILE_READ_FAILED:
-            return "file read failed";
-        case MZ_ZIP_FILE_CLOSE_FAILED:
-            return "file close failed";
-        case MZ_ZIP_FILE_SEEK_FAILED:
-            return "file seek failed";
-        case MZ_ZIP_FILE_STAT_FAILED:
-            return "file stat failed";
-        case MZ_ZIP_INVALID_PARAMETER:
-            return "invalid parameter";
-        case MZ_ZIP_INVALID_FILENAME:
-            return "invalid filename";
-        case MZ_ZIP_BUF_TOO_SMALL:
-            return "buffer too small";
-        case MZ_ZIP_INTERNAL_ERROR:
-            return "internal error";
-        case MZ_ZIP_FILE_NOT_FOUND:
-            return "file not found";
-        case MZ_ZIP_ARCHIVE_TOO_LARGE:
-            return "archive is too large";
-        case MZ_ZIP_VALIDATION_FAILED:
-            return "validation failed";
-        case MZ_ZIP_WRITE_CALLBACK_FAILED:
-            return "write calledback failed";
-        default:
-            break;
-    }
-
-    return "unknown error";
-}
-
-/* Note: Just because the archive is not zip64 doesn't necessarily mean it doesn't have Zip64 extended information extra field, argh. */
-mz_bool mz_zip_is_zip64(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return MZ_FALSE;
-
-    return pZip->m_pState->m_zip64;
-}
-
-size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return 0;
-
-    return pZip->m_pState->m_central_dir.m_size;
-}
-
-mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip)
-{
-    return pZip ? pZip->m_total_files : 0;
-}
-
-mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip)
-{
-    if (!pZip)
-        return 0;
-    return pZip->m_archive_size;
-}
-
-mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return 0;
-    return pZip->m_pState->m_file_archive_start_ofs;
-}
-
-MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return 0;
-    return pZip->m_pState->m_pFile;
-}
-
-size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n)
-{
-    if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n);
-}
-
-mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
-{
-    mz_uint n;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        if (filename_buf_size)
-            pFilename[0] = '\0';
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return 0;
-    }
-    n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    if (filename_buf_size)
-    {
-        n = MZ_MIN(n, filename_buf_size - 1);
-        memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
-        pFilename[n] = '\0';
-    }
-    return n + 1;
-}
-
-mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
-{
-    return mz_zip_file_stat_internal(pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL);
-}
-
-mz_bool mz_zip_end(mz_zip_archive *pZip)
-{
-    if (!pZip)
-        return MZ_FALSE;
-
-    if (pZip->m_zip_mode == MZ_ZIP_MODE_READING)
-        return mz_zip_reader_end(pZip);
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-    else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))
-        return mz_zip_writer_end(pZip);
-#endif
-
-    return MZ_FALSE;
-}
-
-
-
-#endif /*#ifndef MINIZ_NO_ARCHIVE_APIS*/
-} // namespace duckdb_miniz
diff --git a/src/duckdb/third_party/miniz/miniz.hpp b/src/duckdb/third_party/miniz/miniz.hpp
deleted file mode 100644
index b39eda8b7..000000000
--- a/src/duckdb/third_party/miniz/miniz.hpp
+++ /dev/null
@@ -1,1288 +0,0 @@
-/* miniz.c 2.0.8 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
-   See "unlicense" statement at the end of this file.
-   Rich Geldreich <richgel99@gmail.com>, last updated Oct. 13, 2013
-   Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
-
-   Most API's defined in miniz.c are optional. For example, to disable the archive related functions just define
-   MINIZ_NO_ARCHIVE_APIS, or to get rid of all stdio usage define MINIZ_NO_STDIO (see the list below for more macros).
-
-   * Low-level Deflate/Inflate implementation notes:
-
-     Compression: Use the "tdefl" API's. The compressor supports raw, static, and dynamic blocks, lazy or
-     greedy parsing, match length filtering, RLE-only, and Huffman-only streams. It performs and compresses
-     approximately as well as zlib.
-
-     Decompression: Use the "tinfl" API's. The entire decompressor is implemented as a single function
-     coroutine: see tinfl_decompress(). It supports decompression into a 32KB (or larger power of 2) wrapping buffer, or into a memory
-     block large enough to hold the entire file.
-
-     The low-level tdefl/tinfl API's do not make any use of dynamic memory allocation.
-
-   * zlib-style API notes:
-
-     miniz.c implements a fairly large subset of zlib. There's enough functionality present for it to be a drop-in
-     zlib replacement in many apps:
-        The z_stream struct, optional memory allocation callbacks
-        deflateInit/deflateInit2/deflate/deflateReset/deflateEnd/deflateBound
-        inflateInit/inflateInit2/inflate/inflateEnd
-        compress, compress2, compressBound, uncompress
-        CRC-32, Adler-32 - Using modern, minimal code size, CPU cache friendly routines.
-        Supports raw deflate streams or standard zlib streams with adler-32 checking.
-
-     Limitations:
-      The callback API's are not implemented yet. No support for gzip headers or zlib static dictionaries.
-      I've tried to closely emulate zlib's various flavors of stream flushing and return status codes, but
-      there are no guarantees that miniz.c pulls this off perfectly.
-
-   * PNG writing: See the tdefl_write_image_to_png_file_in_memory() function, originally written by
-     Alex Evans. Supports 1-4 bytes/pixel images.
-
-   * ZIP archive API notes:
-
-     The ZIP archive API's where designed with simplicity and efficiency in mind, with just enough abstraction to
-     get the job done with minimal fuss. There are simple API's to retrieve file information, read files from
-     existing archives, create new archives, append new files to existing archives, or clone archive data from
-     one archive to another. It supports archives located in memory or the heap, on disk (using stdio.h),
-     or you can specify custom file read/write callbacks.
-
-     - Archive reading: Just call this function to read a single file from a disk archive:
-
-      void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name,
-        size_t *pSize, mz_uint zip_flags);
-
-     For more complex cases, use the "mz_zip_reader" functions. Upon opening an archive, the entire central
-     directory is located and read as-is into memory, and subsequent file access only occurs when reading individual files.
-
-     - Archives file scanning: The simple way is to use this function to scan a loaded archive for a specific file:
-
-     int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
-
-     The locate operation can optionally check file comments too, which (as one example) can be used to identify
-     multiple versions of the same file in an archive. This function uses a simple linear search through the central
-     directory, so it's not very fast.
-
-     Alternately, you can iterate through all the files in an archive (using mz_zip_reader_get_num_files()) and
-     retrieve detailed info on each file by calling mz_zip_reader_file_stat().
-
-     - Archive creation: Use the "mz_zip_writer" functions. The ZIP writer immediately writes compressed file data
-     to disk and builds an exact image of the central directory in memory. The central directory image is written
-     all at once at the end of the archive file when the archive is finalized.
-
-     The archive writer can optionally align each file's local header and file data to any power of 2 alignment,
-     which can be useful when the archive will be read from optical media. Also, the writer supports placing
-     arbitrary data blobs at the very beginning of ZIP archives. Archives written using either feature are still
-     readable by any ZIP tool.
-
-     - Archive appending: The simple way to add a single file to an archive is to call this function:
-
-      mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name,
-        const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-
-     The archive will be created if it doesn't already exist, otherwise it'll be appended to.
-     Note the appending is done in-place and is not an atomic operation, so if something goes wrong
-     during the operation it's possible the archive could be left without a central directory (although the local
-     file headers and file data will be fine, so the archive will be recoverable).
-
-     For more complex archive modification scenarios:
-     1. The safest way is to use a mz_zip_reader to read the existing archive, cloning only those bits you want to
-     preserve into a new archive using using the mz_zip_writer_add_from_zip_reader() function (which compiles the
-     compressed file data as-is). When you're done, delete the old archive and rename the newly written archive, and
-     you're done. This is safe but requires a bunch of temporary disk space or heap memory.
-
-     2. Or, you can convert an mz_zip_reader in-place to an mz_zip_writer using mz_zip_writer_init_from_reader(),
-     append new files as needed, then finalize the archive which will write an updated central directory to the
-     original archive. (This is basically what mz_zip_add_mem_to_archive_file_in_place() does.) There's a
-     possibility that the archive's central directory could be lost with this method if anything goes wrong, though.
-
-     - ZIP archive support limitations:
-     No zip64 or spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
-     Requires streams capable of seeking.
-
-   * This is a header file library, like stb_image.c. To get only a header file, either cut and paste the
-     below header, or create miniz.h, #define MINIZ_HEADER_FILE_ONLY, and then include miniz.c from it.
-
-   * Important: For best perf. be sure to customize the below macros for your target platform:
-     #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
-     #define MINIZ_LITTLE_ENDIAN 1
-     #define MINIZ_HAS_64BIT_REGISTERS 1
-
-   * On platforms using glibc, Be sure to "#define _LARGEFILE64_SOURCE 1" before including miniz.c to ensure miniz
-     uses the 64-bit variants: fopen64(), stat64(), etc. Otherwise you won't be able to process large files
-     (i.e. 32-bit stat() fails for me on files > 0x7FFFFFFF bytes).
-*/
-#pragma once
-
-
-
-
-/* Defines to completely disable specific portions of miniz.c:
-   If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl. */
-
-/* Define MINIZ_NO_STDIO to disable all usage and any functions which rely on stdio for file I/O. */
-#define MINIZ_NO_STDIO
-
-/* If MINIZ_NO_TIME is specified then the ZIP archive functions will not be able to get the current time, or */
-/* get/set file times, and the C run-time funcs that get/set times won't be called. */
-/* The current downside is the times written to your archives will be from 1979. */
-#define MINIZ_NO_TIME
-
-/* Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's. */
-/* #define MINIZ_NO_ARCHIVE_APIS */
-
-/* Define MINIZ_NO_ARCHIVE_WRITING_APIS to disable all writing related ZIP archive API's. */
-/* #define MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-/* Define MINIZ_NO_ZLIB_APIS to remove all ZLIB-style compression/decompression API's. */
-/*#define MINIZ_NO_ZLIB_APIS */
-
-/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAME to disable zlib names, to prevent conflicts against stock zlib. */
-#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES
-
-/* Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc.
-   Note if MINIZ_NO_MALLOC is defined then the user must always provide custom user alloc/free/realloc
-   callbacks to the zlib and archive API's, and a few stand-alone helper API's which don't provide custom user
-   functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work. */
-/*#define MINIZ_NO_MALLOC */
-
-#if defined(__TINYC__) && (defined(__linux) || defined(__linux__))
-/* TODO: Work around "error: include file 'sys\utime.h' when compiling with tcc on Linux */
-#define MINIZ_NO_TIME
-#endif
-
-#include <stddef.h>
-
-
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_ARCHIVE_APIS)
-#include <time.h>
-#endif
-
-#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__i386) || defined(__i486__) || defined(__i486) || defined(i386) || defined(__ia64__) || defined(__x86_64__)
-/* MINIZ_X86_OR_X64_CPU is only used to help set the below macros. */
-#define MINIZ_X86_OR_X64_CPU 1
-#else
-#define MINIZ_X86_OR_X64_CPU 0
-#endif
-
-#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */
-#define MINIZ_LITTLE_ENDIAN 1
-#else
-#define MINIZ_LITTLE_ENDIAN 0
-#endif
-
-#if MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */
-#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0 // always 0 because alignment
-#else
-#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
-#endif
-
-#if defined(_M_X64) || defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) || defined(__ia64__) || defined(__x86_64__)
-/* Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions). */
-#define MINIZ_HAS_64BIT_REGISTERS 1
-#else
-#define MINIZ_HAS_64BIT_REGISTERS 0
-#endif
-
-namespace duckdb_miniz {
-
-/* ------------------- zlib-style API Definitions. */
-
-/* For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits! */
-typedef unsigned long mz_ulong;
-
-/* mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap. */
-void mz_free(void *p);
-
-#define MZ_ADLER32_INIT (1)
-/* mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL. */
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
-
-#define MZ_CRC32_INIT (0)
-/* mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL. */
-mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
-
-/* Compression strategies. */
-enum { MZ_DEFAULT_STRATEGY = 0, MZ_FILTERED = 1, MZ_HUFFMAN_ONLY = 2, MZ_RLE = 3, MZ_FIXED = 4 };
-
-/* Method */
-#define MZ_DEFLATED 8
-
-/* Heap allocation callbacks.
-Note that mz_alloc_func parameter types purpsosely differ from zlib's: items/size is size_t, not unsigned long. */
-typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
-typedef void (*mz_free_func)(void *opaque, void *address);
-typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, size_t size);
-
-/* Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL. */
-enum {
-	MZ_NO_COMPRESSION = 0,
-	MZ_BEST_SPEED = 1,
-	MZ_BEST_COMPRESSION = 9,
-	MZ_UBER_COMPRESSION = 10,
-	MZ_DEFAULT_LEVEL = 6,
-	MZ_DEFAULT_COMPRESSION = -1
-};
-
-#define MZ_VERSION "10.0.3"
-#define MZ_VERNUM 0xA030
-#define MZ_VER_MAJOR 10
-#define MZ_VER_MINOR 0
-#define MZ_VER_REVISION 3
-#define MZ_VER_SUBREVISION 0
-
-#ifndef MINIZ_NO_ZLIB_APIS
-
-/* Flush values. For typical usage you only need MZ_NO_FLUSH and MZ_FINISH. The other values are for advanced use (refer to the zlib docs). */
-enum { MZ_NO_FLUSH = 0, MZ_PARTIAL_FLUSH = 1, MZ_SYNC_FLUSH = 2, MZ_FULL_FLUSH = 3, MZ_FINISH = 4, MZ_BLOCK = 5 };
-
-/* Return status codes. MZ_PARAM_ERROR is non-standard. */
-enum {
-	MZ_OK = 0,
-	MZ_STREAM_END = 1,
-	MZ_NEED_DICT = 2,
-	MZ_ERRNO = -1,
-	MZ_STREAM_ERROR = -2,
-	MZ_DATA_ERROR = -3,
-	MZ_MEM_ERROR = -4,
-	MZ_BUF_ERROR = -5,
-	MZ_VERSION_ERROR = -6,
-	MZ_PARAM_ERROR = -10000
-};
-
-/* Window bits */
-#define MZ_DEFAULT_WINDOW_BITS 15
-
-struct mz_internal_state;
-
-/* Compression/decompression stream struct. */
-typedef struct mz_stream_s {
-	const unsigned char *next_in; /* pointer to next byte to read */
-	unsigned int avail_in;        /* number of bytes available at next_in */
-	mz_ulong total_in;            /* total number of bytes consumed so far */
-
-	unsigned char *next_out; /* pointer to next byte to write */
-	unsigned int avail_out;  /* number of bytes that can be written to next_out */
-	mz_ulong total_out;      /* total number of bytes produced so far */
-
-	char *msg;                       /* error msg (unused) */
-	struct mz_internal_state *state; /* internal state, allocated by zalloc/zfree */
-
-	mz_alloc_func zalloc; /* optional heap allocation function (defaults to malloc) */
-	mz_free_func zfree;   /* optional heap free function (defaults to free) */
-	void *opaque;         /* heap alloc function user pointer */
-
-	int data_type;     /* data_type (unused) */
-	mz_ulong adler;    /* adler32 of the source or uncompressed data */
-	mz_ulong reserved; /* not used */
-} mz_stream;
-
-typedef mz_stream *mz_streamp;
-
-/* Returns the version string of miniz.c. */
-const char *mz_version(void);
-
-/* mz_deflateInit() initializes a compressor with default options: */
-/* Parameters: */
-/*  pStream must point to an initialized mz_stream struct. */
-/*  level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION]. */
-/*  level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
- */
-/*  (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.) */
-/* Return values: */
-/*  MZ_OK on success. */
-/*  MZ_STREAM_ERROR if the stream is bogus. */
-/*  MZ_PARAM_ERROR if the input parameters are bogus. */
-/*  MZ_MEM_ERROR on out of memory. */
-int mz_deflateInit(mz_streamp pStream, int level);
-
-/* mz_deflateInit2() is like mz_deflate(), except with more control: */
-/* Additional parameters: */
-/*   method must be MZ_DEFLATED */
-/*   window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer) */
-/*   mem_level must be between [1, 9] (it's checked but ignored by miniz.c) */
-int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
-
-/* Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2(). */
-int mz_deflateReset(mz_streamp pStream);
-
-/* mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
- */
-/* Parameters: */
-/*   pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members. */
-/*   flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH. */
-/* Return values: */
-/*   MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full). */
-/*   MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore. */
-/*   MZ_STREAM_ERROR if the stream is bogus. */
-/*   MZ_PARAM_ERROR if one of the parameters is invalid. */
-/*   MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.) */
-int mz_deflate(mz_streamp pStream, int flush);
-
-/* mz_deflateEnd() deinitializes a compressor: */
-/* Return values: */
-/*  MZ_OK on success. */
-/*  MZ_STREAM_ERROR if the stream is bogus. */
-int mz_deflateEnd(mz_streamp pStream);
-
-/* mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH. */
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);
-
-/* Single-call compression functions mz_compress() and mz_compress2(): */
-/* Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure. */
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len,
-                 int level);
-
-/* mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress(). */
-mz_ulong mz_compressBound(mz_ulong source_len);
-
-/* Initializes a decompressor. */
-int mz_inflateInit(mz_streamp pStream);
-
-/* mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer: */
-/* window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate). */
-int mz_inflateInit2(mz_streamp pStream, int window_bits);
-
-/* Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible. */
-/* Parameters: */
-/*   pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members. */
-/*   flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH. */
-/*   On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster). */
-/*   MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data. */
-/* Return values: */
-/*   MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full. */
-/*   MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified. */
-/*   MZ_STREAM_ERROR if the stream is bogus. */
-/*   MZ_DATA_ERROR if the deflate stream is invalid. */
-/*   MZ_PARAM_ERROR if one of the parameters is invalid. */
-/*   MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again */
-/*   with more input data, or with more room in the output buffer (except when using single call decompression, described above). */
-int mz_inflate(mz_streamp pStream, int flush);
-
-/* Deinitializes a decompressor. */
-int mz_inflateEnd(mz_streamp pStream);
-
-/* Single-call decompression. */
-/* Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure. */
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
-
-/* Returns a string description of the specified error code, or NULL if the error code is invalid. */
-const char *mz_error(int err);
-
-/* Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used as a drop-in replacement for the subset of zlib that miniz.c supports. */
-/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you use zlib in the same project. */
-#ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES
-typedef unsigned char Byte;
-typedef unsigned int uInt;
-typedef mz_ulong uLong;
-typedef Byte Bytef;
-typedef uInt uIntf;
-typedef char charf;
-typedef int intf;
-typedef void *voidpf;
-typedef uLong uLongf;
-typedef void *voidp;
-typedef void *const voidpc;
-#define Z_NULL 0
-#define Z_NO_FLUSH MZ_NO_FLUSH
-#define Z_PARTIAL_FLUSH MZ_PARTIAL_FLUSH
-#define Z_SYNC_FLUSH MZ_SYNC_FLUSH
-#define Z_FULL_FLUSH MZ_FULL_FLUSH
-#define Z_FINISH MZ_FINISH
-#define Z_BLOCK MZ_BLOCK
-#define Z_OK MZ_OK
-#define Z_STREAM_END MZ_STREAM_END
-#define Z_NEED_DICT MZ_NEED_DICT
-#define Z_ERRNO MZ_ERRNO
-#define Z_STREAM_ERROR MZ_STREAM_ERROR
-#define Z_DATA_ERROR MZ_DATA_ERROR
-#define Z_MEM_ERROR MZ_MEM_ERROR
-#define Z_BUF_ERROR MZ_BUF_ERROR
-#define Z_VERSION_ERROR MZ_VERSION_ERROR
-#define Z_PARAM_ERROR MZ_PARAM_ERROR
-#define Z_NO_COMPRESSION MZ_NO_COMPRESSION
-#define Z_BEST_SPEED MZ_BEST_SPEED
-#define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION
-#define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION
-#define Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY
-#define Z_FILTERED MZ_FILTERED
-#define Z_HUFFMAN_ONLY MZ_HUFFMAN_ONLY
-#define Z_RLE MZ_RLE
-#define Z_FIXED MZ_FIXED
-#define Z_DEFLATED MZ_DEFLATED
-#define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS
-#define alloc_func mz_alloc_func
-#define free_func mz_free_func
-#define internal_state mz_internal_state
-#define z_stream mz_stream
-#define deflateInit mz_deflateInit
-#define deflateInit2 mz_deflateInit2
-#define deflateReset mz_deflateReset
-#define deflate mz_deflate
-#define deflateEnd mz_deflateEnd
-#define deflateBound mz_deflateBound
-#define compress mz_compress
-#define compress2 mz_compress2
-#define compressBound mz_compressBound
-#define inflateInit mz_inflateInit
-#define inflateInit2 mz_inflateInit2
-#define inflate mz_inflate
-#define inflateEnd mz_inflateEnd
-#define uncompress mz_uncompress
-#define crc32 mz_crc32
-#define adler32 mz_adler32
-#define MAX_WBITS 15
-#define MAX_MEM_LEVEL 9
-#define zError mz_error
-#define ZLIB_VERSION MZ_VERSION
-#define ZLIB_VERNUM MZ_VERNUM
-#define ZLIB_VER_MAJOR MZ_VER_MAJOR
-#define ZLIB_VER_MINOR MZ_VER_MINOR
-#define ZLIB_VER_REVISION MZ_VER_REVISION
-#define ZLIB_VER_SUBREVISION MZ_VER_SUBREVISION
-#define zlibVersion mz_version
-#define zlib_version mz_version()
-#endif /* #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES */
-
-#endif /* MINIZ_NO_ZLIB_APIS */
-
-}
-
-#pragma once
-#include <assert.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-namespace duckdb_miniz {
-
-/* ------------------- Types and macros */
-typedef unsigned char mz_uint8;
-typedef signed short mz_int16;
-typedef unsigned short mz_uint16;
-typedef unsigned int mz_uint32;
-typedef unsigned int mz_uint;
-typedef int64_t mz_int64;
-typedef uint64_t mz_uint64;
-typedef int mz_bool;
-
-#define MZ_FALSE (0)
-#define MZ_TRUE (1)
-
-/* Works around MSVC's spammy "warning C4127: conditional expression is constant" message. */
-#ifdef _MSC_VER
-#define MZ_MACRO_END while (0, 0)
-#else
-#define MZ_MACRO_END while (0)
-#endif
-
-#ifdef MINIZ_NO_STDIO
-#define MZ_FILE void *
-#else
-#include <stdio.h>
-#define MZ_FILE FILE
-#endif /* #ifdef MINIZ_NO_STDIO */
-
-#ifdef MINIZ_NO_TIME
-typedef struct mz_dummy_time_t_tag
-{
-    int m_dummy;
-} mz_dummy_time_t;
-#define MZ_TIME_T mz_dummy_time_t
-#else
-#define MZ_TIME_T time_t
-#endif
-
-#define MZ_ASSERT(x) assert(x)
-
-#ifdef MINIZ_NO_MALLOC
-#define MZ_MALLOC(x) NULL
-#define MZ_FREE(x) (void)x, ((void)0)
-#define MZ_REALLOC(p, x) NULL
-#else
-#define MZ_MALLOC(x) malloc(x)
-#define MZ_FREE(x) free(x)
-#define MZ_REALLOC(p, x) realloc(p, x)
-#endif
-
-#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
-#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
-#define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj))
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
-#define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
-#define MZ_READ_LE32(p) *((const mz_uint32 *)(p))
-#else
-#define MZ_READ_LE16(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
-#define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
-#endif
-
-#define MZ_READ_LE64(p) (((mz_uint64)MZ_READ_LE32(p)) | (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) << 32U))
-
-#ifdef _MSC_VER
-#define MZ_FORCEINLINE __forceinline
-#elif defined(__GNUC__)
-#define MZ_FORCEINLINE __inline__ __attribute__((__always_inline__))
-#else
-#define MZ_FORCEINLINE inline
-#endif
-
-extern void *miniz_def_alloc_func(void *opaque, size_t items, size_t size);
-extern void miniz_def_free_func(void *opaque, void *address);
-extern void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size);
-
-#define MZ_UINT16_MAX (0xFFFFU)
-#define MZ_UINT32_MAX (0xFFFFFFFFU)
-
-
-#pragma once
-
-
-/* ------------------- Low-level Compression API Definitions */
-
-/* Set TDEFL_LESS_MEMORY to 1 to use less memory (compression will be slightly slower, and raw/dynamic blocks will be output more frequently). */
-#define TDEFL_LESS_MEMORY 0
-
-/* tdefl_init() compression flags logically OR'd together (low 12 bits contain the max. number of probes per dictionary search): */
-/* TDEFL_DEFAULT_MAX_PROBES: The compressor defaults to 128 dictionary probes per dictionary search. 0=Huffman only, 1=Huffman+LZ (fastest/crap compression), 4095=Huffman+LZ (slowest/best compression). */
-enum
-{
-    TDEFL_HUFFMAN_ONLY = 0,
-    TDEFL_DEFAULT_MAX_PROBES = 128,
-    TDEFL_MAX_PROBES_MASK = 0xFFF
-};
-
-/* TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data. */
-/* TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers). */
-/* TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing. */
-/* TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory). */
-/* TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1) */
-/* TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled. */
-/* TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables. */
-/* TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks. */
-/* The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK). */
-enum
-{
-    TDEFL_WRITE_ZLIB_HEADER = 0x01000,
-    TDEFL_COMPUTE_ADLER32 = 0x02000,
-    TDEFL_GREEDY_PARSING_FLAG = 0x04000,
-    TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
-    TDEFL_RLE_MATCHES = 0x10000,
-    TDEFL_FILTER_MATCHES = 0x20000,
-    TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
-    TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
-};
-
-/* High level compression functions: */
-/* tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc(). */
-/* On entry: */
-/*  pSrc_buf, src_buf_len: Pointer and size of source block to compress. */
-/*  flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression. */
-/* On return: */
-/*  Function returns a pointer to the compressed data, or NULL on failure. */
-/*  *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data. */
-/*  The caller must free() the returned block when it's no longer needed. */
-void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
-
-/* tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory. */
-/* Returns 0 on failure. */
-size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
-
-/* Compresses an image to a compressed PNG file in memory. */
-/* On entry: */
-/*  pImage, w, h, and num_chans describe the image to compress. num_chans may be 1, 2, 3, or 4. */
-/*  The image pitch in bytes per scanline will be w*num_chans. The leftmost pixel on the top scanline is stored first in memory. */
-/*  level may range from [0,10], use MZ_NO_COMPRESSION, MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc. or a decent default is MZ_DEFAULT_LEVEL */
-/*  If flip is true, the image will be flipped on the Y axis (useful for OpenGL apps). */
-/* On return: */
-/*  Function returns a pointer to the compressed data, or NULL on failure. */
-/*  *pLen_out will be set to the size of the PNG image file. */
-/*  The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed. */
-void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
-void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);
-
-/* Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time. */
-typedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
-
-/* tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally. */
-mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
-
-enum
-{
-    TDEFL_MAX_HUFF_TABLES = 3,
-    TDEFL_MAX_HUFF_SYMBOLS_0 = 288,
-    TDEFL_MAX_HUFF_SYMBOLS_1 = 32,
-    TDEFL_MAX_HUFF_SYMBOLS_2 = 19,
-    TDEFL_LZ_DICT_SIZE = 32768,
-    TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1,
-    TDEFL_MIN_MATCH_LEN = 3,
-    TDEFL_MAX_MATCH_LEN = 258
-};
-
-/* TDEFL_OUT_BUF_SIZE MUST be large enough to hold a single entire compressed output block (using static/fixed Huffman codes). */
-#if TDEFL_LESS_MEMORY
-enum
-{
-    TDEFL_LZ_CODE_BUF_SIZE = 24 * 1024,
-    TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10,
-    TDEFL_MAX_HUFF_SYMBOLS = 288,
-    TDEFL_LZ_HASH_BITS = 12,
-    TDEFL_LEVEL1_HASH_SIZE_MASK = 4095,
-    TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3,
-    TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS
-};
-#else
-enum
-{
-    TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024,
-    TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10,
-    TDEFL_MAX_HUFF_SYMBOLS = 288,
-    TDEFL_LZ_HASH_BITS = 15,
-    TDEFL_LEVEL1_HASH_SIZE_MASK = 4095,
-    TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3,
-    TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS
-};
-#endif
-
-/* The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions. */
-typedef enum {
-    TDEFL_STATUS_BAD_PARAM = -2,
-    TDEFL_STATUS_PUT_BUF_FAILED = -1,
-    TDEFL_STATUS_OKAY = 0,
-    TDEFL_STATUS_DONE = 1
-} tdefl_status;
-
-/* Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums */
-typedef enum {
-    TDEFL_NO_FLUSH = 0,
-    TDEFL_SYNC_FLUSH = 2,
-    TDEFL_FULL_FLUSH = 3,
-    TDEFL_FINISH = 4
-} tdefl_flush;
-
-/* tdefl's compression state structure. */
-typedef struct
-{
-    tdefl_put_buf_func_ptr m_pPut_buf_func;
-    void *m_pPut_buf_user;
-    mz_uint m_flags, m_max_probes[2];
-    int m_greedy_parsing;
-    mz_uint m_adler32, m_lookahead_pos, m_lookahead_size, m_dict_size;
-    mz_uint8 *m_pLZ_code_buf, *m_pLZ_flags, *m_pOutput_buf, *m_pOutput_buf_end;
-    mz_uint m_num_flags_left, m_total_lz_bytes, m_lz_code_buf_dict_pos, m_bits_in, m_bit_buffer;
-    mz_uint m_saved_match_dist, m_saved_match_len, m_saved_lit, m_output_flush_ofs, m_output_flush_remaining, m_finished, m_block_index, m_wants_to_finish;
-    tdefl_status m_prev_return_status;
-    const void *m_pIn_buf;
-    void *m_pOut_buf;
-    size_t *m_pIn_buf_size, *m_pOut_buf_size;
-    tdefl_flush m_flush;
-    const mz_uint8 *m_pSrc;
-    size_t m_src_buf_left, m_out_buf_ofs;
-    mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE + TDEFL_MAX_MATCH_LEN - 1];
-    mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
-    mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
-    mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
-    mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE];
-    mz_uint16 m_next[TDEFL_LZ_DICT_SIZE];
-    mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE];
-    mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE];
-} tdefl_compressor;
-
-/* Initializes the compressor. */
-/* There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory. */
-/* pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression. */
-/* If pBut_buf_func is NULL the user should always call the tdefl_compress() API. */
-/* flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.) */
-tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
-
-/* Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible. */
-tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);
-
-/* tdefl_compress_buffer() is only usable when the tdefl_init() is called with a non-NULL tdefl_put_buf_func_ptr. */
-/* tdefl_compress_buffer() always consumes the entire input buffer. */
-tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);
-
-tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
-mz_uint32 tdefl_get_adler32(tdefl_compressor *d);
-
-/* Create tdefl_compress() flags given zlib-style compression parameters. */
-/* level may range from [0,10] (where 10 is absolute max compression, but may be much slower on some files) */
-/* window_bits may be -15 (raw deflate) or 15 (zlib) */
-/* strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED */
-mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);
-
-/* Allocate the tdefl_compressor structure in C so that */
-/* non-C language bindings to tdefl_ API don't need to worry about */
-/* structure size and allocation mechanism. */
-tdefl_compressor *tdefl_compressor_alloc();
-void tdefl_compressor_free(tdefl_compressor *pComp);
-
-
-#pragma once
-
-/* ------------------- Low-level Decompression API Definitions */
-
-
-/* Decompression flags used by tinfl_decompress(). */
-/* TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream. */
-/* TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input. */
-/* TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB). */
-/* TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes. */
-enum
-{
-    TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
-    TINFL_FLAG_HAS_MORE_INPUT = 2,
-    TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
-    TINFL_FLAG_COMPUTE_ADLER32 = 8
-};
-
-/* High level decompression functions: */
-/* tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc(). */
-/* On entry: */
-/*  pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress. */
-/* On return: */
-/*  Function returns a pointer to the decompressed data, or NULL on failure. */
-/*  *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data. */
-/*  The caller must call mz_free() on the returned block when it's no longer needed. */
-void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
-
-/* tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory. */
-/* Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success. */
-#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
-size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
-
-/* tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer. */
-/* Returns 1 on success or 0 on failure. */
-typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
-int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
-
-struct tinfl_decompressor_tag;
-typedef struct tinfl_decompressor_tag tinfl_decompressor;
-
-/* Allocate the tinfl_decompressor structure in C so that */
-/* non-C language bindings to tinfl_ API don't need to worry about */
-/* structure size and allocation mechanism. */
-
-tinfl_decompressor *tinfl_decompressor_alloc();
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp);
-
-/* Max size of LZ dictionary. */
-#define TINFL_LZ_DICT_SIZE 32768
-
-/* Return status. */
-typedef enum {
-    /* This flags indicates the inflator needs 1 or more input bytes to make forward progress, but the caller is indicating that no more are available. The compressed data */
-    /* is probably corrupted. If you call the inflator again with more bytes it'll try to continue processing the input but this is a BAD sign (either the data is corrupted or you called it incorrectly). */
-    /* If you call it again with no input you'll just get TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS again. */
-    TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS = -4,
-
-    /* This flag indicates that one or more of the input parameters was obviously bogus. (You can try calling it again, but if you get this error the calling code is wrong.) */
-    TINFL_STATUS_BAD_PARAM = -3,
-
-    /* This flags indicate the inflator is finished but the adler32 check of the uncompressed data didn't match. If you call it again it'll return TINFL_STATUS_DONE. */
-    TINFL_STATUS_ADLER32_MISMATCH = -2,
-
-    /* This flags indicate the inflator has somehow failed (bad code, corrupted input, etc.). If you call it again without resetting via tinfl_init() it it'll just keep on returning the same status failure code. */
-    TINFL_STATUS_FAILED = -1,
-
-    /* Any status code less than TINFL_STATUS_DONE must indicate a failure. */
-
-    /* This flag indicates the inflator has returned every byte of uncompressed data that it can, has consumed every byte that it needed, has successfully reached the end of the deflate stream, and */
-    /* if zlib headers and adler32 checking enabled that it has successfully checked the uncompressed data's adler32. If you call it again you'll just get TINFL_STATUS_DONE over and over again. */
-    TINFL_STATUS_DONE = 0,
-
-    /* This flag indicates the inflator MUST have more input data (even 1 byte) before it can make any more forward progress, or you need to clear the TINFL_FLAG_HAS_MORE_INPUT */
-    /* flag on the next call if you don't have any more source data. If the source data was somehow corrupted it's also possible (but unlikely) for the inflator to keep on demanding input to */
-    /* proceed, so be sure to properly set the TINFL_FLAG_HAS_MORE_INPUT flag. */
-    TINFL_STATUS_NEEDS_MORE_INPUT = 1,
-
-    /* This flag indicates the inflator definitely has 1 or more bytes of uncompressed data available, but it cannot write this data into the output buffer. */
-    /* Note if the source compressed data was corrupted it's possible for the inflator to return a lot of uncompressed data to the caller. I've been assuming you know how much uncompressed data to expect */
-    /* (either exact or worst case) and will stop calling the inflator and fail after receiving too much. In pure streaming scenarios where you have no idea how many bytes to expect this may not be possible */
-    /* so I may need to add some code to address this. */
-    TINFL_STATUS_HAS_MORE_OUTPUT = 2
-} tinfl_status;
-
-/* Initializes the decompressor to its initial state. */
-#define tinfl_init(r)     \
-    do                    \
-    {                     \
-        (r)->m_state = 0; \
-    }                     \
-    MZ_MACRO_END
-#define tinfl_get_adler32(r) (r)->m_check_adler32
-
-/* Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability. */
-/* This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output. */
-tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);
-
-/* Internal/private bits follow. */
-enum
-{
-    TINFL_MAX_HUFF_TABLES = 3,
-    TINFL_MAX_HUFF_SYMBOLS_0 = 288,
-    TINFL_MAX_HUFF_SYMBOLS_1 = 32,
-    TINFL_MAX_HUFF_SYMBOLS_2 = 19,
-    TINFL_FAST_LOOKUP_BITS = 10,
-    TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
-};
-
-typedef struct
-{
-    mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
-    mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
-} tinfl_huff_table;
-
-#if MINIZ_HAS_64BIT_REGISTERS
-#define TINFL_USE_64BIT_BITBUF 1
-#else
-#define TINFL_USE_64BIT_BITBUF 0
-#endif
-
-#if TINFL_USE_64BIT_BITBUF
-typedef mz_uint64 tinfl_bit_buf_t;
-#define TINFL_BITBUF_SIZE (64)
-#else
-typedef mz_uint32 tinfl_bit_buf_t;
-#define TINFL_BITBUF_SIZE (32)
-#endif
-
-struct tinfl_decompressor_tag
-{
-    mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
-    tinfl_bit_buf_t m_bit_buf;
-    size_t m_dist_from_out_buf_start;
-    tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
-    mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
-};
-
-
-
-#pragma once
-
-
-/* ------------------- ZIP archive reading/writing */
-
-#ifndef MINIZ_NO_ARCHIVE_APIS
-
-
-enum
-{
-    /* Note: These enums can be reduced as needed to save memory or stack space - they are pretty conservative. */
-    MZ_ZIP_MAX_IO_BUF_SIZE = 64 * 1024,
-    MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 512,
-    MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 512
-};
-
-typedef struct
-{
-    /* Central directory file index. */
-    mz_uint32 m_file_index;
-
-    /* Byte offset of this entry in the archive's central directory. Note we currently only support up to UINT_MAX or less bytes in the central dir. */
-    mz_uint64 m_central_dir_ofs;
-
-    /* These fields are copied directly from the zip's central dir. */
-    mz_uint16 m_version_made_by;
-    mz_uint16 m_version_needed;
-    mz_uint16 m_bit_flag;
-    mz_uint16 m_method;
-
-#ifndef MINIZ_NO_TIME
-    MZ_TIME_T m_time;
-#endif
-
-    /* CRC-32 of uncompressed data. */
-    mz_uint32 m_crc32;
-
-    /* File's compressed size. */
-    mz_uint64 m_comp_size;
-
-    /* File's uncompressed size. Note, I've seen some old archives where directory entries had 512 bytes for their uncompressed sizes, but when you try to unpack them you actually get 0 bytes. */
-    mz_uint64 m_uncomp_size;
-
-    /* Zip internal and external file attributes. */
-    mz_uint16 m_internal_attr;
-    mz_uint32 m_external_attr;
-
-    /* Entry's local header file offset in bytes. */
-    mz_uint64 m_local_header_ofs;
-
-    /* Size of comment in bytes. */
-    mz_uint32 m_comment_size;
-
-    /* MZ_TRUE if the entry appears to be a directory. */
-    mz_bool m_is_directory;
-
-    /* MZ_TRUE if the entry uses encryption/strong encryption (which miniz_zip doesn't support) */
-    mz_bool m_is_encrypted;
-
-    /* MZ_TRUE if the file is not encrypted, a patch file, and if it uses a compression method we support. */
-    mz_bool m_is_supported;
-
-    /* Filename. If string ends in '/' it's a subdirectory entry. */
-    /* Guaranteed to be zero terminated, may be truncated to fit. */
-    char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
-
-    /* Comment field. */
-    /* Guaranteed to be zero terminated, may be truncated to fit. */
-    char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE];
-
-} mz_zip_archive_file_stat;
-
-typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n);
-typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n);
-typedef mz_bool (*mz_file_needs_keepalive)(void *pOpaque);
-
-struct mz_zip_internal_state_tag;
-typedef struct mz_zip_internal_state_tag mz_zip_internal_state;
-
-typedef enum {
-    MZ_ZIP_MODE_INVALID = 0,
-    MZ_ZIP_MODE_READING = 1,
-    MZ_ZIP_MODE_WRITING = 2,
-    MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3
-} mz_zip_mode;
-
-typedef enum {
-    MZ_ZIP_FLAG_CASE_SENSITIVE = 0x0100,
-    MZ_ZIP_FLAG_IGNORE_PATH = 0x0200,
-    MZ_ZIP_FLAG_COMPRESSED_DATA = 0x0400,
-    MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY = 0x0800,
-    MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG = 0x1000, /* if enabled, mz_zip_reader_locate_file() will be called on each file as its validated to ensure the func finds the file in the central dir (intended for testing) */
-    MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000,     /* validate the local headers, but don't decompress the entire file and check the crc32 */
-    MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000,               /* always use the zip64 file format, instead of the original zip file format with automatic switch to zip64. Use as flags parameter with mz_zip_writer_init*_v2 */
-    MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000,
-    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000
-} mz_zip_flags;
-
-typedef enum {
-    MZ_ZIP_TYPE_INVALID = 0,
-    MZ_ZIP_TYPE_USER,
-    MZ_ZIP_TYPE_MEMORY,
-    MZ_ZIP_TYPE_HEAP,
-    MZ_ZIP_TYPE_FILE,
-    MZ_ZIP_TYPE_CFILE,
-    MZ_ZIP_TOTAL_TYPES
-} mz_zip_type;
-
-/* miniz error codes. Be sure to update mz_zip_get_error_string() if you add or modify this enum. */
-typedef enum {
-    MZ_ZIP_NO_ERROR = 0,
-    MZ_ZIP_UNDEFINED_ERROR,
-    MZ_ZIP_TOO_MANY_FILES,
-    MZ_ZIP_FILE_TOO_LARGE,
-    MZ_ZIP_UNSUPPORTED_METHOD,
-    MZ_ZIP_UNSUPPORTED_ENCRYPTION,
-    MZ_ZIP_UNSUPPORTED_FEATURE,
-    MZ_ZIP_FAILED_FINDING_CENTRAL_DIR,
-    MZ_ZIP_NOT_AN_ARCHIVE,
-    MZ_ZIP_INVALID_HEADER_OR_CORRUPTED,
-    MZ_ZIP_UNSUPPORTED_MULTIDISK,
-    MZ_ZIP_DECOMPRESSION_FAILED,
-    MZ_ZIP_COMPRESSION_FAILED,
-    MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE,
-    MZ_ZIP_CRC_CHECK_FAILED,
-    MZ_ZIP_UNSUPPORTED_CDIR_SIZE,
-    MZ_ZIP_ALLOC_FAILED,
-    MZ_ZIP_FILE_OPEN_FAILED,
-    MZ_ZIP_FILE_CREATE_FAILED,
-    MZ_ZIP_FILE_WRITE_FAILED,
-    MZ_ZIP_FILE_READ_FAILED,
-    MZ_ZIP_FILE_CLOSE_FAILED,
-    MZ_ZIP_FILE_SEEK_FAILED,
-    MZ_ZIP_FILE_STAT_FAILED,
-    MZ_ZIP_INVALID_PARAMETER,
-    MZ_ZIP_INVALID_FILENAME,
-    MZ_ZIP_BUF_TOO_SMALL,
-    MZ_ZIP_INTERNAL_ERROR,
-    MZ_ZIP_FILE_NOT_FOUND,
-    MZ_ZIP_ARCHIVE_TOO_LARGE,
-    MZ_ZIP_VALIDATION_FAILED,
-    MZ_ZIP_WRITE_CALLBACK_FAILED,
-    MZ_ZIP_TOTAL_ERRORS
-} mz_zip_error;
-
-typedef struct
-{
-    mz_uint64 m_archive_size;
-    mz_uint64 m_central_directory_file_ofs;
-
-    /* We only support up to UINT32_MAX files in zip64 mode. */
-    mz_uint32 m_total_files;
-    mz_zip_mode m_zip_mode;
-    mz_zip_type m_zip_type;
-    mz_zip_error m_last_error;
-
-    mz_uint64 m_file_offset_alignment;
-
-    mz_alloc_func m_pAlloc;
-    mz_free_func m_pFree;
-    mz_realloc_func m_pRealloc;
-    void *m_pAlloc_opaque;
-
-    mz_file_read_func m_pRead;
-    mz_file_write_func m_pWrite;
-    mz_file_needs_keepalive m_pNeeds_keepalive;
-    void *m_pIO_opaque;
-
-    mz_zip_internal_state *m_pState;
-
-} mz_zip_archive;
-
-typedef struct
-{
-    mz_zip_archive *pZip;
-    mz_uint flags;
-
-    int status;
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-    mz_uint file_crc32;
-#endif
-    mz_uint64 read_buf_size, read_buf_ofs, read_buf_avail, comp_remaining, out_buf_ofs, cur_file_ofs;
-    mz_zip_archive_file_stat file_stat;
-    void *pRead_buf;
-    void *pWrite_buf;
-
-    size_t out_blk_remain;
-
-    tinfl_decompressor inflator;
-
-} mz_zip_reader_extract_iter_state;
-
-/* -------- ZIP reading */
-
-/* Inits a ZIP archive reader. */
-/* These functions read and validate the archive's central directory. */
-mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);
-
-mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags);
-
-#ifndef MINIZ_NO_STDIO
-/* Read a archive from a disk file. */
-/* file_start_ofs is the file offset where the archive actually begins, or 0. */
-/* actual_archive_size is the true total size of the archive, which may be smaller than the file's actual size on disk. If zero the entire file is treated as the archive. */
-mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
-mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);
-
-/* Read an archive from an already opened FILE, beginning at the current file position. */
-/* The archive is assumed to be archive_size bytes long. If archive_size is < 0, then the entire rest of the file is assumed to contain the archive. */
-/* The FILE will NOT be closed when mz_zip_reader_end() is called. */
-mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);
-#endif
-
-/* Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used. */
-mz_bool mz_zip_reader_end(mz_zip_archive *pZip);
-
-/* -------- ZIP reading or writing */
-
-/* Clears a mz_zip_archive struct to all zeros. */
-/* Important: This must be done before passing the struct to any mz_zip functions. */
-void mz_zip_zero_struct(mz_zip_archive *pZip);
-
-mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip);
-mz_zip_type mz_zip_get_type(mz_zip_archive *pZip);
-
-/* Returns the total number of files in the archive. */
-mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);
-
-mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip);
-mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip);
-MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip);
-
-/* Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf. */
-size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);
-
-/* All mz_zip funcs set the m_last_error field in the mz_zip_archive struct. These functions retrieve/manipulate this field. */
-/* Note that the m_last_error functionality is not thread safe. */
-mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);
-mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);
-const char *mz_zip_get_error_string(mz_zip_error mz_err);
-
-/* MZ_TRUE if the archive file entry is a directory entry. */
-mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);
-
-/* MZ_TRUE if the file is encrypted/strong encrypted. */
-mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);
-
-/* MZ_TRUE if the compression method is supported, and the file is not encrypted, and the file is not a compressed patch file. */
-mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);
-
-/* Retrieves the filename of an archive file entry. */
-/* Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename. */
-mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);
-
-/* Attempts to locates a file in the archive's central directory. */
-/* Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH */
-/* Returns -1 if the file cannot be found. */
-int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
-int mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);
-
-/* Returns detailed information about an archive file entry. */
-mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);
-
-/* MZ_TRUE if the file is in zip64 format. */
-/* A file is considered zip64 if it contained a zip64 end of central directory marker, or if it contained any zip64 extended file information fields in the central directory. */
-mz_bool mz_zip_is_zip64(mz_zip_archive *pZip);
-
-/* Returns the total central directory size in bytes. */
-/* The current max supported size is <= MZ_UINT32_MAX. */
-size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);
-
-/* Extracts a archive file to a memory buffer using no memory allocation. */
-/* There must be at least enough room on the stack to store the inflator's state (~34KB or so). */
-mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
-mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
-
-/* Extracts a archive file to a memory buffer. */
-mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);
-
-/* Extracts a archive file to a dynamically allocated heap buffer. */
-/* The memory will be allocated via the mz_zip_archive's alloc/realloc functions. */
-/* Returns NULL and sets the last error on failure. */
-void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
-void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);
-
-/* Extracts a archive file using a callback function to output the file's data. */
-mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
-
-/* Extract a file iteratively */
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
-size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);
-mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);
-
-#ifndef MINIZ_NO_STDIO
-/* Extracts a archive file to a disk file and sets its last accessed and modified times. */
-/* This function only extracts files, not archive directory records. */
-mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);
-
-/* Extracts a archive file starting at the current position in the destination FILE stream. */
-mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);
-#endif
-
-#if 0
-/* TODO */
-	typedef void *mz_zip_streaming_extract_state_ptr;
-	mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-	uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs);
-	size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
-	mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-#endif
-
-/* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */
-/* It also validates that each file can be successfully uncompressed unless the MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified. */
-mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-
-/* Validates an entire archive by calling mz_zip_validate_file() on each file. */
-mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);
-
-/* Misc utils/helpers, valid for ZIP reading or writing */
-mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);
-mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);
-
-/* Universal end function - calls either mz_zip_reader_end() or mz_zip_writer_end(). */
-mz_bool mz_zip_end(mz_zip_archive *pZip);
-
-/* -------- ZIP writing */
-
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-
-/* Inits a ZIP archive writer. */
-/*Set pZip->m_pWrite (and pZip->m_pIO_opaque) before calling mz_zip_writer_init or mz_zip_writer_init_v2*/
-/*The output is streamable, i.e. file_ofs in mz_file_write_func always increases only by n*/
-mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
-mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);
-
-mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
-mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags);
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
-mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags);
-mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags);
-#endif
-
-/* Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive. */
-/* For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called. */
-/* For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it). */
-/* Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL. */
-/* Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before */
-/* the archive is finalized the file's central directory will be hosed. */
-mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
-mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
-
-/* Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive. */
-/* To add a directory entry, call this method with an archive name ending in a forwardslash with an empty buffer. */
-/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);
-
-/* Like mz_zip_writer_add_mem(), except you can specify a file comment field, and optionally supply the function with already compressed data. */
-/* uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA flag is specified. */
-mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);
-
-mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                    mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-                                    const char *user_extra_data_central, mz_uint user_extra_data_central_len);
-
-#ifndef MINIZ_NO_STDIO
-/* Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive. */
-/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-
-/* Like mz_zip_writer_add_file(), except the file data is read from the specified FILE stream. */
-mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add,
-                                const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-                                const char *user_extra_data_central, mz_uint user_extra_data_central_len);
-#endif
-
-/* Adds a file to an archive by fully cloning the data from another archive. */
-/* This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data (it may add or modify the zip64 local header extra data field), and the optional descriptor following the compressed data. */
-mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);
-
-/* Finalizes the archive by writing the central directory records followed by the end of central directory record. */
-/* After an archive is finalized, the only valid call on the mz_zip_archive struct is mz_zip_writer_end(). */
-/* An archive must be manually finalized by calling this function for it to be valid. */
-mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);
-
-/* Finalizes a heap archive, returning a poiner to the heap block and its size. */
-/* The heap block will be allocated using the mz_zip_archive's alloc/realloc callbacks. */
-mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);
-
-/* Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used. */
-/* Note for the archive to be valid, it *must* have been finalized before ending (this function will not do it for you). */
-mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
-
-/* -------- Misc. high-level helper functions: */
-
-/* mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive. */
-/* Note this is NOT a fully safe operation. If it crashes or dies in some way your archive can be left in a screwed up state (without a central directory). */
-/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-/* TODO: Perhaps add an option to leave the existing central dir in place in case the add dies? We could then truncate the file (so the old central dir would be at the end) if something goes wrong. */
-mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);
-
-/* Reads a single file from an archive into a heap block. */
-/* If pComment is not NULL, only the file with the specified comment will be extracted. */
-/* Returns NULL on failure. */
-void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);
-void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);
-
-#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-
-
-#endif /* MINIZ_NO_ARCHIVE_APIS */
-
-} // namespace duckdb_miniz
diff --git a/src/duckdb/third_party/miniz/miniz_wrapper.hpp b/src/duckdb/third_party/miniz/miniz_wrapper.hpp
deleted file mode 100644
index 9420c5201..000000000
--- a/src/duckdb/third_party/miniz/miniz_wrapper.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// miniz_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "miniz.hpp"
-#include <string>
-#include <stdexcept>
-
-namespace duckdb {
-
-enum class MiniZStreamType {
-	MINIZ_TYPE_NONE,
-	MINIZ_TYPE_INFLATE,
-	MINIZ_TYPE_DEFLATE
-};
-
-struct MiniZStream {
-	static constexpr uint8_t GZIP_HEADER_MINSIZE = 10;
-	static constexpr uint8_t GZIP_FOOTER_SIZE = 8;
-	static constexpr uint8_t GZIP_COMPRESSION_DEFLATE = 0x08;
-	static constexpr unsigned char GZIP_FLAG_UNSUPPORTED = 0x1 | 0x2 | 0x4 | 0x10 | 0x20;
-
-public:
-	MiniZStream() : type(MiniZStreamType::MINIZ_TYPE_NONE) {
-		memset(&stream, 0, sizeof(duckdb_miniz::mz_stream));
-	}
-	~MiniZStream() {
-		switch(type) {
-		case MiniZStreamType::MINIZ_TYPE_INFLATE:
-			duckdb_miniz::mz_inflateEnd(&stream);
-			break;
-		case MiniZStreamType::MINIZ_TYPE_DEFLATE:
-			duckdb_miniz::mz_deflateEnd(&stream);
-			break;
-		default:
-			break;
-		}
-	}
-	void FormatException(std::string error_msg) {
-		throw std::runtime_error(error_msg);
-	}
-	void FormatException(const char *error_msg, int mz_ret) {
-		auto err = duckdb_miniz::mz_error(mz_ret);
-		FormatException(error_msg + std::string(": ") + (err ? err : "Unknown error code"));
-	}
-	void Decompress(const char *compressed_data, size_t compressed_size, char *out_data, size_t out_size) {
-		auto mz_ret = mz_inflateInit2(&stream, -MZ_DEFAULT_WINDOW_BITS);
-		if (mz_ret != duckdb_miniz::MZ_OK) {
-			FormatException("Failed to initialize miniz", mz_ret);
-		}
-		type = MiniZStreamType::MINIZ_TYPE_INFLATE;
-
-		if (compressed_size < GZIP_HEADER_MINSIZE) {
-			FormatException("Failed to decompress GZIP block: compressed size is less than gzip header size");
-		}
-		auto gzip_hdr = (const unsigned char *)compressed_data;
-		if (gzip_hdr[0] != 0x1F || gzip_hdr[1] != 0x8B || gzip_hdr[2] != GZIP_COMPRESSION_DEFLATE ||
-		    gzip_hdr[3] & GZIP_FLAG_UNSUPPORTED) {
-			FormatException("Input is invalid/unsupported GZIP stream");
-		}
-
-		stream.next_in = (const unsigned char *)compressed_data + GZIP_HEADER_MINSIZE;
-		stream.avail_in = static_cast<unsigned int >(compressed_size - GZIP_HEADER_MINSIZE);
-		stream.next_out = (unsigned char *)out_data;
-		stream.avail_out =  static_cast<unsigned int >(out_size);
-
-		mz_ret = mz_inflate(&stream, duckdb_miniz::MZ_FINISH);
-		if (mz_ret != duckdb_miniz::MZ_OK && mz_ret != duckdb_miniz::MZ_STREAM_END) {
-			FormatException("Failed to decompress GZIP block", mz_ret);
-		}
-	}
-	size_t MaxCompressedLength(size_t input_size) {
-		return duckdb_miniz::mz_compressBound(input_size) + GZIP_HEADER_MINSIZE + GZIP_FOOTER_SIZE;
-	}
-	static void InitializeGZIPHeader(unsigned char *gzip_header) {
-		memset(gzip_header, 0, GZIP_HEADER_MINSIZE);
-		gzip_header[0] = 0x1F;
-		gzip_header[1] = 0x8B;
-		gzip_header[2] = GZIP_COMPRESSION_DEFLATE;
-		gzip_header[3] = 0;
-		gzip_header[4] = 0;
-		gzip_header[5] = 0;
-		gzip_header[6] = 0;
-		gzip_header[7] = 0;
-		gzip_header[8] = 0;
-		gzip_header[9] = 0xFF;
-	}
-
-	static void InitializeGZIPFooter(unsigned char *gzip_footer, duckdb_miniz::mz_ulong crc, idx_t uncompressed_size) {
-		gzip_footer[0] = crc & 0xFF;
-		gzip_footer[1] = (crc >> 8) & 0xFF;
-		gzip_footer[2] = (crc >> 16) & 0xFF;
-		gzip_footer[3] = (crc >> 24) & 0xFF;
-		gzip_footer[4] = uncompressed_size & 0xFF;
-		gzip_footer[5] = (uncompressed_size >> 8) & 0xFF;
-		gzip_footer[6] = (uncompressed_size >> 16) & 0xFF;
-		gzip_footer[7] = (uncompressed_size >> 24) & 0xFF;
-	}
-
-	void Compress(const char *uncompressed_data, size_t uncompressed_size, char *out_data, size_t *out_size) {
-		auto mz_ret = mz_deflateInit2(&stream, duckdb_miniz::MZ_DEFAULT_LEVEL, MZ_DEFLATED, -MZ_DEFAULT_WINDOW_BITS, 1, 0);
-		if (mz_ret != duckdb_miniz::MZ_OK) {
-			FormatException("Failed to initialize miniz", mz_ret);
-		}
-		type = MiniZStreamType::MINIZ_TYPE_DEFLATE;
-
-		auto gzip_header = (unsigned char*) out_data;
-		InitializeGZIPHeader(gzip_header);
-
-		auto gzip_body = gzip_header + GZIP_HEADER_MINSIZE;
-
-		stream.next_in = (const unsigned char*) uncompressed_data;
-		stream.avail_in =  static_cast<unsigned int >(uncompressed_size);
-		stream.next_out = gzip_body;
-		stream.avail_out =  static_cast<unsigned int >(*out_size - GZIP_HEADER_MINSIZE);
-
-		mz_ret = mz_deflate(&stream, duckdb_miniz::MZ_FINISH);
-		if (mz_ret != duckdb_miniz::MZ_OK && mz_ret != duckdb_miniz::MZ_STREAM_END) {
-			FormatException("Failed to compress GZIP block", mz_ret);
-		}
-		auto gzip_footer = gzip_body + stream.total_out;
-		auto crc = duckdb_miniz::mz_crc32(MZ_CRC32_INIT, (const unsigned char*) uncompressed_data, uncompressed_size);
-		InitializeGZIPFooter(gzip_footer, crc, uncompressed_size);
-
-		*out_size = stream.total_out + GZIP_HEADER_MINSIZE + GZIP_FOOTER_SIZE;
-	}
-
-private:
-	duckdb_miniz::mz_stream stream;
-	MiniZStreamType type;
-};
-
-}
diff --git a/src/duckdb/third_party/parquet/parquet_types.cpp b/src/duckdb/third_party/parquet/parquet_types.cpp
deleted file mode 100644
index cd989782f..000000000
--- a/src/duckdb/third_party/parquet/parquet_types.cpp
+++ /dev/null
@@ -1,8411 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (0.21.0)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-#include "parquet_types.h"
-
-#include <algorithm>
-#include <ostream>
-
-#include <thrift/TToString.h>
-
-namespace duckdb_parquet {
-
-int _kTypeValues[] = {
-  Type::BOOLEAN,
-  Type::INT32,
-  Type::INT64,
-  Type::INT96,
-  Type::FLOAT,
-  Type::DOUBLE,
-  Type::BYTE_ARRAY,
-  Type::FIXED_LEN_BYTE_ARRAY
-};
-const char* _kTypeNames[] = {
-  "BOOLEAN",
-  "INT32",
-  "INT64",
-  "INT96",
-  "FLOAT",
-  "DOUBLE",
-  "BYTE_ARRAY",
-  "FIXED_LEN_BYTE_ARRAY"
-};
-const std::map<int, const char*> _Type_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kTypeValues, _kTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const Type::type& val) {
-  std::map<int, const char*>::const_iterator it = _Type_VALUES_TO_NAMES.find(val);
-  if (it != _Type_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const Type::type& val) {
-  std::map<int, const char*>::const_iterator it = _Type_VALUES_TO_NAMES.find(val);
-  if (it != _Type_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-int _kConvertedTypeValues[] = {
-  /**
-   * a BYTE_ARRAY actually contains UTF8 encoded chars
-   */
-  ConvertedType::UTF8,
-  /**
-   * a map is converted as an optional field containing a repeated key/value pair
-   */
-  ConvertedType::MAP,
-  /**
-   * a key/value pair is converted into a group of two fields
-   */
-  ConvertedType::MAP_KEY_VALUE,
-  /**
-   * a list is converted into an optional field containing a repeated field for its
-   * values
-   */
-  ConvertedType::LIST,
-  /**
-   * an enum is converted into a BYTE_ARRAY field
-   */
-  ConvertedType::ENUM,
-  /**
-   * A decimal value.
-   * 
-   * This may be used to annotate BYTE_ARRAY or FIXED_LEN_BYTE_ARRAY primitive
-   * types. The underlying byte array stores the unscaled value encoded as two's
-   * complement using big-endian byte order (the most significant byte is the
-   * zeroth element). The value of the decimal is the value * 10^{-scale}.
-   * 
-   * This must be accompanied by a (maximum) precision and a scale in the
-   * SchemaElement. The precision specifies the number of digits in the decimal
-   * and the scale stores the location of the decimal point. For example 1.23
-   * would have precision 3 (3 total digits) and scale 2 (the decimal point is
-   * 2 digits over).
-   */
-  ConvertedType::DECIMAL,
-  /**
-   * A Date
-   * 
-   * Stored as days since Unix epoch, encoded as the INT32 physical type.
-   * 
-   */
-  ConvertedType::DATE,
-  /**
-   * A time
-   * 
-   * The total number of milliseconds since midnight.  The value is stored
-   * as an INT32 physical type.
-   */
-  ConvertedType::TIME_MILLIS,
-  /**
-   * A time.
-   * 
-   * The total number of microseconds since midnight.  The value is stored as
-   * an INT64 physical type.
-   */
-  ConvertedType::TIME_MICROS,
-  /**
-   * A date/time combination
-   * 
-   * Date and time recorded as milliseconds since the Unix epoch.  Recorded as
-   * a physical type of INT64.
-   */
-  ConvertedType::TIMESTAMP_MILLIS,
-  /**
-   * A date/time combination
-   * 
-   * Date and time recorded as microseconds since the Unix epoch.  The value is
-   * stored as an INT64 physical type.
-   */
-  ConvertedType::TIMESTAMP_MICROS,
-  /**
-   * An unsigned integer value.
-   * 
-   * The number describes the maximum number of meaningful data bits in
-   * the stored value. 8, 16 and 32 bit values are stored using the
-   * INT32 physical type.  64 bit values are stored using the INT64
-   * physical type.
-   * 
-   */
-  ConvertedType::UINT_8,
-  ConvertedType::UINT_16,
-  ConvertedType::UINT_32,
-  ConvertedType::UINT_64,
-  /**
-   * A signed integer value.
-   * 
-   * The number describes the maximum number of meaningful data bits in
-   * the stored value. 8, 16 and 32 bit values are stored using the
-   * INT32 physical type.  64 bit values are stored using the INT64
-   * physical type.
-   * 
-   */
-  ConvertedType::INT_8,
-  ConvertedType::INT_16,
-  ConvertedType::INT_32,
-  ConvertedType::INT_64,
-  /**
-   * An embedded JSON document
-   * 
-   * A JSON document embedded within a single UTF8 column.
-   */
-  ConvertedType::JSON,
-  /**
-   * An embedded BSON document
-   * 
-   * A BSON document embedded within a single BYTE_ARRAY column.
-   */
-  ConvertedType::BSON,
-  /**
-   * An interval of time
-   * 
-   * This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
-   * This data is composed of three separate little endian unsigned
-   * integers.  Each stores a component of a duration of time.  The first
-   * integer identifies the number of months associated with the duration,
-   * the second identifies the number of days associated with the duration
-   * and the third identifies the number of milliseconds associated with
-   * the provided duration.  This duration of time is independent of any
-   * particular timezone or date.
-   */
-  ConvertedType::INTERVAL
-};
-const char* _kConvertedTypeNames[] = {
-  /**
-   * a BYTE_ARRAY actually contains UTF8 encoded chars
-   */
-  "UTF8",
-  /**
-   * a map is converted as an optional field containing a repeated key/value pair
-   */
-  "MAP",
-  /**
-   * a key/value pair is converted into a group of two fields
-   */
-  "MAP_KEY_VALUE",
-  /**
-   * a list is converted into an optional field containing a repeated field for its
-   * values
-   */
-  "LIST",
-  /**
-   * an enum is converted into a BYTE_ARRAY field
-   */
-  "ENUM",
-  /**
-   * A decimal value.
-   * 
-   * This may be used to annotate BYTE_ARRAY or FIXED_LEN_BYTE_ARRAY primitive
-   * types. The underlying byte array stores the unscaled value encoded as two's
-   * complement using big-endian byte order (the most significant byte is the
-   * zeroth element). The value of the decimal is the value * 10^{-scale}.
-   * 
-   * This must be accompanied by a (maximum) precision and a scale in the
-   * SchemaElement. The precision specifies the number of digits in the decimal
-   * and the scale stores the location of the decimal point. For example 1.23
-   * would have precision 3 (3 total digits) and scale 2 (the decimal point is
-   * 2 digits over).
-   */
-  "DECIMAL",
-  /**
-   * A Date
-   * 
-   * Stored as days since Unix epoch, encoded as the INT32 physical type.
-   * 
-   */
-  "DATE",
-  /**
-   * A time
-   * 
-   * The total number of milliseconds since midnight.  The value is stored
-   * as an INT32 physical type.
-   */
-  "TIME_MILLIS",
-  /**
-   * A time.
-   * 
-   * The total number of microseconds since midnight.  The value is stored as
-   * an INT64 physical type.
-   */
-  "TIME_MICROS",
-  /**
-   * A date/time combination
-   * 
-   * Date and time recorded as milliseconds since the Unix epoch.  Recorded as
-   * a physical type of INT64.
-   */
-  "TIMESTAMP_MILLIS",
-  /**
-   * A date/time combination
-   * 
-   * Date and time recorded as microseconds since the Unix epoch.  The value is
-   * stored as an INT64 physical type.
-   */
-  "TIMESTAMP_MICROS",
-  /**
-   * An unsigned integer value.
-   * 
-   * The number describes the maximum number of meaningful data bits in
-   * the stored value. 8, 16 and 32 bit values are stored using the
-   * INT32 physical type.  64 bit values are stored using the INT64
-   * physical type.
-   * 
-   */
-  "UINT_8",
-  "UINT_16",
-  "UINT_32",
-  "UINT_64",
-  /**
-   * A signed integer value.
-   * 
-   * The number describes the maximum number of meaningful data bits in
-   * the stored value. 8, 16 and 32 bit values are stored using the
-   * INT32 physical type.  64 bit values are stored using the INT64
-   * physical type.
-   * 
-   */
-  "INT_8",
-  "INT_16",
-  "INT_32",
-  "INT_64",
-  /**
-   * An embedded JSON document
-   * 
-   * A JSON document embedded within a single UTF8 column.
-   */
-  "JSON",
-  /**
-   * An embedded BSON document
-   * 
-   * A BSON document embedded within a single BYTE_ARRAY column.
-   */
-  "BSON",
-  /**
-   * An interval of time
-   * 
-   * This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
-   * This data is composed of three separate little endian unsigned
-   * integers.  Each stores a component of a duration of time.  The first
-   * integer identifies the number of months associated with the duration,
-   * the second identifies the number of days associated with the duration
-   * and the third identifies the number of milliseconds associated with
-   * the provided duration.  This duration of time is independent of any
-   * particular timezone or date.
-   */
-  "INTERVAL"
-};
-const std::map<int, const char*> _ConvertedType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(22, _kConvertedTypeValues, _kConvertedTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const ConvertedType::type& val) {
-  std::map<int, const char*>::const_iterator it = _ConvertedType_VALUES_TO_NAMES.find(val);
-  if (it != _ConvertedType_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const ConvertedType::type& val) {
-  std::map<int, const char*>::const_iterator it = _ConvertedType_VALUES_TO_NAMES.find(val);
-  if (it != _ConvertedType_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-int _kFieldRepetitionTypeValues[] = {
-  /**
-   * This field is required (can not be null) and each row has exactly 1 value.
-   */
-  FieldRepetitionType::REQUIRED,
-  /**
-   * The field is optional (can be null) and each row has 0 or 1 values.
-   */
-  FieldRepetitionType::OPTIONAL,
-  /**
-   * The field is repeated and can contain 0 or more values
-   */
-  FieldRepetitionType::REPEATED
-};
-const char* _kFieldRepetitionTypeNames[] = {
-  /**
-   * This field is required (can not be null) and each row has exactly 1 value.
-   */
-  "REQUIRED",
-  /**
-   * The field is optional (can be null) and each row has 0 or 1 values.
-   */
-  "OPTIONAL",
-  /**
-   * The field is repeated and can contain 0 or more values
-   */
-  "REPEATED"
-};
-const std::map<int, const char*> _FieldRepetitionType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kFieldRepetitionTypeValues, _kFieldRepetitionTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const FieldRepetitionType::type& val) {
-  std::map<int, const char*>::const_iterator it = _FieldRepetitionType_VALUES_TO_NAMES.find(val);
-  if (it != _FieldRepetitionType_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const FieldRepetitionType::type& val) {
-  std::map<int, const char*>::const_iterator it = _FieldRepetitionType_VALUES_TO_NAMES.find(val);
-  if (it != _FieldRepetitionType_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-int _kEncodingValues[] = {
-  /**
-   * Default encoding.
-   * BOOLEAN - 1 bit per value. 0 is false; 1 is true.
-   * INT32 - 4 bytes per value.  Stored as little-endian.
-   * INT64 - 8 bytes per value.  Stored as little-endian.
-   * FLOAT - 4 bytes per value.  IEEE. Stored as little-endian.
-   * DOUBLE - 8 bytes per value.  IEEE. Stored as little-endian.
-   * BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
-   * FIXED_LEN_BYTE_ARRAY - Just the bytes.
-   */
-  Encoding::PLAIN,
-  /**
-   * Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
-   * plain type.
-   * in a data page use RLE_DICTIONARY instead.
-   * in a Dictionary page use PLAIN instead
-   */
-  Encoding::PLAIN_DICTIONARY,
-  /**
-   * Group packed run length encoding. Usable for definition/repetition levels
-   * encoding and Booleans (on one bit: 0 is false; 1 is true.)
-   */
-  Encoding::RLE,
-  /**
-   * Bit packed encoding.  This can only be used if the data has a known max
-   * width.  Usable for definition/repetition levels encoding.
-   */
-  Encoding::BIT_PACKED,
-  /**
-   * Delta encoding for integers. This can be used for int columns and works best
-   * on sorted data
-   */
-  Encoding::DELTA_BINARY_PACKED,
-  /**
-   * Encoding for byte arrays to separate the length values and the data. The lengths
-   * are encoded using DELTA_BINARY_PACKED
-   */
-  Encoding::DELTA_LENGTH_BYTE_ARRAY,
-  /**
-   * Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
-   * Suffixes are stored as delta length byte arrays.
-   */
-  Encoding::DELTA_BYTE_ARRAY,
-  /**
-   * Dictionary encoding: the ids are encoded using the RLE encoding
-   */
-  Encoding::RLE_DICTIONARY,
-  /**
-   * Encoding for fixed-width data (FLOAT, DOUBLE, INT32, INT64, FIXED_LEN_BYTE_ARRAY).
-   * K byte-streams are created where K is the size in bytes of the data type.
-   * The individual bytes of a value are scattered to the corresponding stream and
-   * the streams are concatenated.
-   * This itself does not reduce the size of the data but can lead to better compression
-   * afterwards.
-   * 
-   * Added in 2.8 for FLOAT and DOUBLE.
-   * Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
-   */
-  Encoding::BYTE_STREAM_SPLIT
-};
-const char* _kEncodingNames[] = {
-  /**
-   * Default encoding.
-   * BOOLEAN - 1 bit per value. 0 is false; 1 is true.
-   * INT32 - 4 bytes per value.  Stored as little-endian.
-   * INT64 - 8 bytes per value.  Stored as little-endian.
-   * FLOAT - 4 bytes per value.  IEEE. Stored as little-endian.
-   * DOUBLE - 8 bytes per value.  IEEE. Stored as little-endian.
-   * BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
-   * FIXED_LEN_BYTE_ARRAY - Just the bytes.
-   */
-  "PLAIN",
-  /**
-   * Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
-   * plain type.
-   * in a data page use RLE_DICTIONARY instead.
-   * in a Dictionary page use PLAIN instead
-   */
-  "PLAIN_DICTIONARY",
-  /**
-   * Group packed run length encoding. Usable for definition/repetition levels
-   * encoding and Booleans (on one bit: 0 is false; 1 is true.)
-   */
-  "RLE",
-  /**
-   * Bit packed encoding.  This can only be used if the data has a known max
-   * width.  Usable for definition/repetition levels encoding.
-   */
-  "BIT_PACKED",
-  /**
-   * Delta encoding for integers. This can be used for int columns and works best
-   * on sorted data
-   */
-  "DELTA_BINARY_PACKED",
-  /**
-   * Encoding for byte arrays to separate the length values and the data. The lengths
-   * are encoded using DELTA_BINARY_PACKED
-   */
-  "DELTA_LENGTH_BYTE_ARRAY",
-  /**
-   * Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
-   * Suffixes are stored as delta length byte arrays.
-   */
-  "DELTA_BYTE_ARRAY",
-  /**
-   * Dictionary encoding: the ids are encoded using the RLE encoding
-   */
-  "RLE_DICTIONARY",
-  /**
-   * Encoding for fixed-width data (FLOAT, DOUBLE, INT32, INT64, FIXED_LEN_BYTE_ARRAY).
-   * K byte-streams are created where K is the size in bytes of the data type.
-   * The individual bytes of a value are scattered to the corresponding stream and
-   * the streams are concatenated.
-   * This itself does not reduce the size of the data but can lead to better compression
-   * afterwards.
-   * 
-   * Added in 2.8 for FLOAT and DOUBLE.
-   * Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
-   */
-  "BYTE_STREAM_SPLIT"
-};
-const std::map<int, const char*> _Encoding_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(9, _kEncodingValues, _kEncodingNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const Encoding::type& val) {
-  std::map<int, const char*>::const_iterator it = _Encoding_VALUES_TO_NAMES.find(val);
-  if (it != _Encoding_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const Encoding::type& val) {
-  std::map<int, const char*>::const_iterator it = _Encoding_VALUES_TO_NAMES.find(val);
-  if (it != _Encoding_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-int _kCompressionCodecValues[] = {
-  CompressionCodec::UNCOMPRESSED,
-  CompressionCodec::SNAPPY,
-  CompressionCodec::GZIP,
-  CompressionCodec::LZO,
-  CompressionCodec::BROTLI,
-  CompressionCodec::LZ4,
-  CompressionCodec::ZSTD,
-  CompressionCodec::LZ4_RAW
-};
-const char* _kCompressionCodecNames[] = {
-  "UNCOMPRESSED",
-  "SNAPPY",
-  "GZIP",
-  "LZO",
-  "BROTLI",
-  "LZ4",
-  "ZSTD",
-  "LZ4_RAW"
-};
-const std::map<int, const char*> _CompressionCodec_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kCompressionCodecValues, _kCompressionCodecNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const CompressionCodec::type& val) {
-  std::map<int, const char*>::const_iterator it = _CompressionCodec_VALUES_TO_NAMES.find(val);
-  if (it != _CompressionCodec_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const CompressionCodec::type& val) {
-  std::map<int, const char*>::const_iterator it = _CompressionCodec_VALUES_TO_NAMES.find(val);
-  if (it != _CompressionCodec_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-int _kPageTypeValues[] = {
-  PageType::DATA_PAGE,
-  PageType::INDEX_PAGE,
-  PageType::DICTIONARY_PAGE,
-  PageType::DATA_PAGE_V2
-};
-const char* _kPageTypeNames[] = {
-  "DATA_PAGE",
-  "INDEX_PAGE",
-  "DICTIONARY_PAGE",
-  "DATA_PAGE_V2"
-};
-const std::map<int, const char*> _PageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kPageTypeValues, _kPageTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const PageType::type& val) {
-  std::map<int, const char*>::const_iterator it = _PageType_VALUES_TO_NAMES.find(val);
-  if (it != _PageType_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const PageType::type& val) {
-  std::map<int, const char*>::const_iterator it = _PageType_VALUES_TO_NAMES.find(val);
-  if (it != _PageType_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-int _kBoundaryOrderValues[] = {
-  BoundaryOrder::UNORDERED,
-  BoundaryOrder::ASCENDING,
-  BoundaryOrder::DESCENDING
-};
-const char* _kBoundaryOrderNames[] = {
-  "UNORDERED",
-  "ASCENDING",
-  "DESCENDING"
-};
-const std::map<int, const char*> _BoundaryOrder_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kBoundaryOrderValues, _kBoundaryOrderNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
-
-std::ostream& operator<<(std::ostream& out, const BoundaryOrder::type& val) {
-  std::map<int, const char*>::const_iterator it = _BoundaryOrder_VALUES_TO_NAMES.find(val);
-  if (it != _BoundaryOrder_VALUES_TO_NAMES.end()) {
-    out << it->second;
-  } else {
-    out << static_cast<int>(val);
-  }
-  return out;
-}
-
-std::string to_string(const BoundaryOrder::type& val) {
-  std::map<int, const char*>::const_iterator it = _BoundaryOrder_VALUES_TO_NAMES.find(val);
-  if (it != _BoundaryOrder_VALUES_TO_NAMES.end()) {
-    return std::string(it->second);
-  } else {
-    return std::to_string(static_cast<int>(val));
-  }
-}
-
-
-SizeStatistics::~SizeStatistics() noexcept {
-}
-
-SizeStatistics::SizeStatistics() noexcept
-   : unencoded_byte_array_data_bytes(0) {
-}
-
-void SizeStatistics::__set_unencoded_byte_array_data_bytes(const int64_t val) {
-  this->unencoded_byte_array_data_bytes = val;
-__isset.unencoded_byte_array_data_bytes = true;
-}
-
-void SizeStatistics::__set_repetition_level_histogram(const duckdb::vector<int64_t> & val) {
-  this->repetition_level_histogram = val;
-__isset.repetition_level_histogram = true;
-}
-
-void SizeStatistics::__set_definition_level_histogram(const duckdb::vector<int64_t> & val) {
-  this->definition_level_histogram = val;
-__isset.definition_level_histogram = true;
-}
-std::ostream& operator<<(std::ostream& out, const SizeStatistics& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t SizeStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->unencoded_byte_array_data_bytes);
-          this->__isset.unencoded_byte_array_data_bytes = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->repetition_level_histogram.clear();
-            uint32_t _size0;
-            ::apache::thrift::protocol::TType _etype3;
-            xfer += iprot->readListBegin(_etype3, _size0);
-            this->repetition_level_histogram.resize(_size0);
-            uint32_t _i4;
-            for (_i4 = 0; _i4 < _size0; ++_i4)
-            {
-              xfer += iprot->readI64(this->repetition_level_histogram[_i4]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.repetition_level_histogram = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->definition_level_histogram.clear();
-            uint32_t _size5;
-            ::apache::thrift::protocol::TType _etype8;
-            xfer += iprot->readListBegin(_etype8, _size5);
-            this->definition_level_histogram.resize(_size5);
-            uint32_t _i9;
-            for (_i9 = 0; _i9 < _size5; ++_i9)
-            {
-              xfer += iprot->readI64(this->definition_level_histogram[_i9]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.definition_level_histogram = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t SizeStatistics::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("SizeStatistics");
-
-  if (this->__isset.unencoded_byte_array_data_bytes) {
-    xfer += oprot->writeFieldBegin("unencoded_byte_array_data_bytes", ::apache::thrift::protocol::T_I64, 1);
-    xfer += oprot->writeI64(this->unencoded_byte_array_data_bytes);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.repetition_level_histogram) {
-    xfer += oprot->writeFieldBegin("repetition_level_histogram", ::apache::thrift::protocol::T_LIST, 2);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->repetition_level_histogram.size()));
-      duckdb::vector<int64_t> ::const_iterator _iter10;
-      for (_iter10 = this->repetition_level_histogram.begin(); _iter10 != this->repetition_level_histogram.end(); ++_iter10)
-      {
-        xfer += oprot->writeI64((*_iter10));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.definition_level_histogram) {
-    xfer += oprot->writeFieldBegin("definition_level_histogram", ::apache::thrift::protocol::T_LIST, 3);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->definition_level_histogram.size()));
-      duckdb::vector<int64_t> ::const_iterator _iter11;
-      for (_iter11 = this->definition_level_histogram.begin(); _iter11 != this->definition_level_histogram.end(); ++_iter11)
-      {
-        xfer += oprot->writeI64((*_iter11));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(SizeStatistics &a, SizeStatistics &b) {
-  using ::std::swap;
-  swap(a.unencoded_byte_array_data_bytes, b.unencoded_byte_array_data_bytes);
-  swap(a.repetition_level_histogram, b.repetition_level_histogram);
-  swap(a.definition_level_histogram, b.definition_level_histogram);
-  swap(a.__isset, b.__isset);
-}
-
-SizeStatistics::SizeStatistics(const SizeStatistics& other12) {
-  unencoded_byte_array_data_bytes = other12.unencoded_byte_array_data_bytes;
-  repetition_level_histogram = other12.repetition_level_histogram;
-  definition_level_histogram = other12.definition_level_histogram;
-  __isset = other12.__isset;
-}
-SizeStatistics& SizeStatistics::operator=(const SizeStatistics& other13) {
-  unencoded_byte_array_data_bytes = other13.unencoded_byte_array_data_bytes;
-  repetition_level_histogram = other13.repetition_level_histogram;
-  definition_level_histogram = other13.definition_level_histogram;
-  __isset = other13.__isset;
-  return *this;
-}
-void SizeStatistics::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "SizeStatistics(";
-  out << "unencoded_byte_array_data_bytes="; (__isset.unencoded_byte_array_data_bytes ? (out << to_string(unencoded_byte_array_data_bytes)) : (out << "<null>"));
-  out << ", " << "repetition_level_histogram="; (__isset.repetition_level_histogram ? (out << to_string(repetition_level_histogram)) : (out << "<null>"));
-  out << ", " << "definition_level_histogram="; (__isset.definition_level_histogram ? (out << to_string(definition_level_histogram)) : (out << "<null>"));
-  out << ")";
-}
-
-
-Statistics::~Statistics() noexcept {
-}
-
-Statistics::Statistics() noexcept
-   : max(),
-     min(),
-     null_count(0),
-     distinct_count(0),
-     max_value(),
-     min_value(),
-     is_max_value_exact(0),
-     is_min_value_exact(0) {
-}
-
-void Statistics::__set_max(const std::string& val) {
-  this->max = val;
-__isset.max = true;
-}
-
-void Statistics::__set_min(const std::string& val) {
-  this->min = val;
-__isset.min = true;
-}
-
-void Statistics::__set_null_count(const int64_t val) {
-  this->null_count = val;
-__isset.null_count = true;
-}
-
-void Statistics::__set_distinct_count(const int64_t val) {
-  this->distinct_count = val;
-__isset.distinct_count = true;
-}
-
-void Statistics::__set_max_value(const std::string& val) {
-  this->max_value = val;
-__isset.max_value = true;
-}
-
-void Statistics::__set_min_value(const std::string& val) {
-  this->min_value = val;
-__isset.min_value = true;
-}
-
-void Statistics::__set_is_max_value_exact(const bool val) {
-  this->is_max_value_exact = val;
-__isset.is_max_value_exact = true;
-}
-
-void Statistics::__set_is_min_value_exact(const bool val) {
-  this->is_min_value_exact = val;
-__isset.is_min_value_exact = true;
-}
-std::ostream& operator<<(std::ostream& out, const Statistics& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t Statistics::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->max);
-          this->__isset.max = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->min);
-          this->__isset.min = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->null_count);
-          this->__isset.null_count = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->distinct_count);
-          this->__isset.distinct_count = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->max_value);
-          this->__isset.max_value = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->min_value);
-          this->__isset.min_value = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->is_max_value_exact);
-          this->__isset.is_max_value_exact = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->is_min_value_exact);
-          this->__isset.is_min_value_exact = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t Statistics::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Statistics");
-
-  if (this->__isset.max) {
-    xfer += oprot->writeFieldBegin("max", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeBinary(this->max);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.min) {
-    xfer += oprot->writeFieldBegin("min", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->min);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.null_count) {
-    xfer += oprot->writeFieldBegin("null_count", ::apache::thrift::protocol::T_I64, 3);
-    xfer += oprot->writeI64(this->null_count);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.distinct_count) {
-    xfer += oprot->writeFieldBegin("distinct_count", ::apache::thrift::protocol::T_I64, 4);
-    xfer += oprot->writeI64(this->distinct_count);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.max_value) {
-    xfer += oprot->writeFieldBegin("max_value", ::apache::thrift::protocol::T_STRING, 5);
-    xfer += oprot->writeBinary(this->max_value);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.min_value) {
-    xfer += oprot->writeFieldBegin("min_value", ::apache::thrift::protocol::T_STRING, 6);
-    xfer += oprot->writeBinary(this->min_value);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.is_max_value_exact) {
-    xfer += oprot->writeFieldBegin("is_max_value_exact", ::apache::thrift::protocol::T_BOOL, 7);
-    xfer += oprot->writeBool(this->is_max_value_exact);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.is_min_value_exact) {
-    xfer += oprot->writeFieldBegin("is_min_value_exact", ::apache::thrift::protocol::T_BOOL, 8);
-    xfer += oprot->writeBool(this->is_min_value_exact);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(Statistics &a, Statistics &b) {
-  using ::std::swap;
-  swap(a.max, b.max);
-  swap(a.min, b.min);
-  swap(a.null_count, b.null_count);
-  swap(a.distinct_count, b.distinct_count);
-  swap(a.max_value, b.max_value);
-  swap(a.min_value, b.min_value);
-  swap(a.is_max_value_exact, b.is_max_value_exact);
-  swap(a.is_min_value_exact, b.is_min_value_exact);
-  swap(a.__isset, b.__isset);
-}
-
-Statistics::Statistics(const Statistics& other14) {
-  max = other14.max;
-  min = other14.min;
-  null_count = other14.null_count;
-  distinct_count = other14.distinct_count;
-  max_value = other14.max_value;
-  min_value = other14.min_value;
-  is_max_value_exact = other14.is_max_value_exact;
-  is_min_value_exact = other14.is_min_value_exact;
-  __isset = other14.__isset;
-}
-Statistics& Statistics::operator=(const Statistics& other15) {
-  max = other15.max;
-  min = other15.min;
-  null_count = other15.null_count;
-  distinct_count = other15.distinct_count;
-  max_value = other15.max_value;
-  min_value = other15.min_value;
-  is_max_value_exact = other15.is_max_value_exact;
-  is_min_value_exact = other15.is_min_value_exact;
-  __isset = other15.__isset;
-  return *this;
-}
-void Statistics::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "Statistics(";
-  out << "max="; (__isset.max ? (out << to_string(max)) : (out << "<null>"));
-  out << ", " << "min="; (__isset.min ? (out << to_string(min)) : (out << "<null>"));
-  out << ", " << "null_count="; (__isset.null_count ? (out << to_string(null_count)) : (out << "<null>"));
-  out << ", " << "distinct_count="; (__isset.distinct_count ? (out << to_string(distinct_count)) : (out << "<null>"));
-  out << ", " << "max_value="; (__isset.max_value ? (out << to_string(max_value)) : (out << "<null>"));
-  out << ", " << "min_value="; (__isset.min_value ? (out << to_string(min_value)) : (out << "<null>"));
-  out << ", " << "is_max_value_exact="; (__isset.is_max_value_exact ? (out << to_string(is_max_value_exact)) : (out << "<null>"));
-  out << ", " << "is_min_value_exact="; (__isset.is_min_value_exact ? (out << to_string(is_min_value_exact)) : (out << "<null>"));
-  out << ")";
-}
-
-
-StringType::~StringType() noexcept {
-}
-
-StringType::StringType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const StringType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t StringType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t StringType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("StringType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(StringType &a, StringType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-StringType::StringType(const StringType& other16) noexcept {
-  (void) other16;
-}
-StringType& StringType::operator=(const StringType& other17) noexcept {
-  (void) other17;
-  return *this;
-}
-void StringType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "StringType(";
-  out << ")";
-}
-
-
-UUIDType::~UUIDType() noexcept {
-}
-
-UUIDType::UUIDType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const UUIDType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t UUIDType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t UUIDType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("UUIDType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(UUIDType &a, UUIDType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-UUIDType::UUIDType(const UUIDType& other18) noexcept {
-  (void) other18;
-}
-UUIDType& UUIDType::operator=(const UUIDType& other19) noexcept {
-  (void) other19;
-  return *this;
-}
-void UUIDType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "UUIDType(";
-  out << ")";
-}
-
-
-MapType::~MapType() noexcept {
-}
-
-MapType::MapType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const MapType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t MapType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t MapType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("MapType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(MapType &a, MapType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-MapType::MapType(const MapType& other20) noexcept {
-  (void) other20;
-}
-MapType& MapType::operator=(const MapType& other21) noexcept {
-  (void) other21;
-  return *this;
-}
-void MapType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "MapType(";
-  out << ")";
-}
-
-
-ListType::~ListType() noexcept {
-}
-
-ListType::ListType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const ListType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t ListType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t ListType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("ListType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ListType &a, ListType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-ListType::ListType(const ListType& other22) noexcept {
-  (void) other22;
-}
-ListType& ListType::operator=(const ListType& other23) noexcept {
-  (void) other23;
-  return *this;
-}
-void ListType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "ListType(";
-  out << ")";
-}
-
-
-EnumType::~EnumType() noexcept {
-}
-
-EnumType::EnumType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const EnumType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t EnumType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t EnumType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("EnumType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(EnumType &a, EnumType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-EnumType::EnumType(const EnumType& other24) noexcept {
-  (void) other24;
-}
-EnumType& EnumType::operator=(const EnumType& other25) noexcept {
-  (void) other25;
-  return *this;
-}
-void EnumType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "EnumType(";
-  out << ")";
-}
-
-
-DateType::~DateType() noexcept {
-}
-
-DateType::DateType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const DateType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t DateType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t DateType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("DateType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DateType &a, DateType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-DateType::DateType(const DateType& other26) noexcept {
-  (void) other26;
-}
-DateType& DateType::operator=(const DateType& other27) noexcept {
-  (void) other27;
-  return *this;
-}
-void DateType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "DateType(";
-  out << ")";
-}
-
-
-Float16Type::~Float16Type() noexcept {
-}
-
-Float16Type::Float16Type() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const Float16Type& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t Float16Type::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t Float16Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Float16Type");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(Float16Type &a, Float16Type &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-Float16Type::Float16Type(const Float16Type& other28) noexcept {
-  (void) other28;
-}
-Float16Type& Float16Type::operator=(const Float16Type& other29) noexcept {
-  (void) other29;
-  return *this;
-}
-void Float16Type::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "Float16Type(";
-  out << ")";
-}
-
-
-NullType::~NullType() noexcept {
-}
-
-NullType::NullType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const NullType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t NullType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t NullType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("NullType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(NullType &a, NullType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-NullType::NullType(const NullType& other30) noexcept {
-  (void) other30;
-}
-NullType& NullType::operator=(const NullType& other31) noexcept {
-  (void) other31;
-  return *this;
-}
-void NullType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "NullType(";
-  out << ")";
-}
-
-
-DecimalType::~DecimalType() noexcept {
-}
-
-DecimalType::DecimalType() noexcept
-   : scale(0),
-     precision(0) {
-}
-
-void DecimalType::__set_scale(const int32_t val) {
-  this->scale = val;
-}
-
-void DecimalType::__set_precision(const int32_t val) {
-  this->precision = val;
-}
-std::ostream& operator<<(std::ostream& out, const DecimalType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t DecimalType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_scale = false;
-  bool isset_precision = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->scale);
-          isset_scale = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->precision);
-          isset_precision = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_scale)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_precision)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DecimalType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("DecimalType");
-
-  xfer += oprot->writeFieldBegin("scale", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->scale);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("precision", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->precision);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DecimalType &a, DecimalType &b) {
-  using ::std::swap;
-  swap(a.scale, b.scale);
-  swap(a.precision, b.precision);
-}
-
-DecimalType::DecimalType(const DecimalType& other32) noexcept {
-  scale = other32.scale;
-  precision = other32.precision;
-}
-DecimalType& DecimalType::operator=(const DecimalType& other33) noexcept {
-  scale = other33.scale;
-  precision = other33.precision;
-  return *this;
-}
-void DecimalType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "DecimalType(";
-  out << "scale=" << to_string(scale);
-  out << ", " << "precision=" << to_string(precision);
-  out << ")";
-}
-
-
-MilliSeconds::~MilliSeconds() noexcept {
-}
-
-MilliSeconds::MilliSeconds() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const MilliSeconds& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t MilliSeconds::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t MilliSeconds::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("MilliSeconds");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(MilliSeconds &a, MilliSeconds &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-MilliSeconds::MilliSeconds(const MilliSeconds& other34) noexcept {
-  (void) other34;
-}
-MilliSeconds& MilliSeconds::operator=(const MilliSeconds& other35) noexcept {
-  (void) other35;
-  return *this;
-}
-void MilliSeconds::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "MilliSeconds(";
-  out << ")";
-}
-
-
-MicroSeconds::~MicroSeconds() noexcept {
-}
-
-MicroSeconds::MicroSeconds() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const MicroSeconds& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t MicroSeconds::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t MicroSeconds::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("MicroSeconds");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(MicroSeconds &a, MicroSeconds &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-MicroSeconds::MicroSeconds(const MicroSeconds& other36) noexcept {
-  (void) other36;
-}
-MicroSeconds& MicroSeconds::operator=(const MicroSeconds& other37) noexcept {
-  (void) other37;
-  return *this;
-}
-void MicroSeconds::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "MicroSeconds(";
-  out << ")";
-}
-
-
-NanoSeconds::~NanoSeconds() noexcept {
-}
-
-NanoSeconds::NanoSeconds() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const NanoSeconds& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t NanoSeconds::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t NanoSeconds::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("NanoSeconds");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(NanoSeconds &a, NanoSeconds &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-NanoSeconds::NanoSeconds(const NanoSeconds& other38) noexcept {
-  (void) other38;
-}
-NanoSeconds& NanoSeconds::operator=(const NanoSeconds& other39) noexcept {
-  (void) other39;
-  return *this;
-}
-void NanoSeconds::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "NanoSeconds(";
-  out << ")";
-}
-
-
-TimeUnit::~TimeUnit() noexcept {
-}
-
-TimeUnit::TimeUnit() noexcept {
-}
-
-void TimeUnit::__set_MILLIS(const MilliSeconds& val) {
-  this->MILLIS = val;
-__isset.MILLIS = true;
-}
-
-void TimeUnit::__set_MICROS(const MicroSeconds& val) {
-  this->MICROS = val;
-__isset.MICROS = true;
-}
-
-void TimeUnit::__set_NANOS(const NanoSeconds& val) {
-  this->NANOS = val;
-__isset.NANOS = true;
-}
-std::ostream& operator<<(std::ostream& out, const TimeUnit& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t TimeUnit::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->MILLIS.read(iprot);
-          this->__isset.MILLIS = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->MICROS.read(iprot);
-          this->__isset.MICROS = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->NANOS.read(iprot);
-          this->__isset.NANOS = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t TimeUnit::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("TimeUnit");
-
-  if (this->__isset.MILLIS) {
-    xfer += oprot->writeFieldBegin("MILLIS", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->MILLIS.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.MICROS) {
-    xfer += oprot->writeFieldBegin("MICROS", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->MICROS.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.NANOS) {
-    xfer += oprot->writeFieldBegin("NANOS", ::apache::thrift::protocol::T_STRUCT, 3);
-    xfer += this->NANOS.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(TimeUnit &a, TimeUnit &b) {
-  using ::std::swap;
-  swap(a.MILLIS, b.MILLIS);
-  swap(a.MICROS, b.MICROS);
-  swap(a.NANOS, b.NANOS);
-  swap(a.__isset, b.__isset);
-}
-
-TimeUnit::TimeUnit(const TimeUnit& other40) noexcept {
-  MILLIS = other40.MILLIS;
-  MICROS = other40.MICROS;
-  NANOS = other40.NANOS;
-  __isset = other40.__isset;
-}
-TimeUnit& TimeUnit::operator=(const TimeUnit& other41) noexcept {
-  MILLIS = other41.MILLIS;
-  MICROS = other41.MICROS;
-  NANOS = other41.NANOS;
-  __isset = other41.__isset;
-  return *this;
-}
-void TimeUnit::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "TimeUnit(";
-  out << "MILLIS="; (__isset.MILLIS ? (out << to_string(MILLIS)) : (out << "<null>"));
-  out << ", " << "MICROS="; (__isset.MICROS ? (out << to_string(MICROS)) : (out << "<null>"));
-  out << ", " << "NANOS="; (__isset.NANOS ? (out << to_string(NANOS)) : (out << "<null>"));
-  out << ")";
-}
-
-
-TimestampType::~TimestampType() noexcept {
-}
-
-TimestampType::TimestampType() noexcept
-   : isAdjustedToUTC(0) {
-}
-
-void TimestampType::__set_isAdjustedToUTC(const bool val) {
-  this->isAdjustedToUTC = val;
-}
-
-void TimestampType::__set_unit(const TimeUnit& val) {
-  this->unit = val;
-}
-std::ostream& operator<<(std::ostream& out, const TimestampType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t TimestampType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_isAdjustedToUTC = false;
-  bool isset_unit = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->isAdjustedToUTC);
-          isset_isAdjustedToUTC = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->unit.read(iprot);
-          isset_unit = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_isAdjustedToUTC)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_unit)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t TimestampType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("TimestampType");
-
-  xfer += oprot->writeFieldBegin("isAdjustedToUTC", ::apache::thrift::protocol::T_BOOL, 1);
-  xfer += oprot->writeBool(this->isAdjustedToUTC);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("unit", ::apache::thrift::protocol::T_STRUCT, 2);
-  xfer += this->unit.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(TimestampType &a, TimestampType &b) {
-  using ::std::swap;
-  swap(a.isAdjustedToUTC, b.isAdjustedToUTC);
-  swap(a.unit, b.unit);
-}
-
-TimestampType::TimestampType(const TimestampType& other42) noexcept {
-  isAdjustedToUTC = other42.isAdjustedToUTC;
-  unit = other42.unit;
-}
-TimestampType& TimestampType::operator=(const TimestampType& other43) noexcept {
-  isAdjustedToUTC = other43.isAdjustedToUTC;
-  unit = other43.unit;
-  return *this;
-}
-void TimestampType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "TimestampType(";
-  out << "isAdjustedToUTC=" << to_string(isAdjustedToUTC);
-  out << ", " << "unit=" << to_string(unit);
-  out << ")";
-}
-
-
-TimeType::~TimeType() noexcept {
-}
-
-TimeType::TimeType() noexcept
-   : isAdjustedToUTC(0) {
-}
-
-void TimeType::__set_isAdjustedToUTC(const bool val) {
-  this->isAdjustedToUTC = val;
-}
-
-void TimeType::__set_unit(const TimeUnit& val) {
-  this->unit = val;
-}
-std::ostream& operator<<(std::ostream& out, const TimeType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t TimeType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_isAdjustedToUTC = false;
-  bool isset_unit = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->isAdjustedToUTC);
-          isset_isAdjustedToUTC = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->unit.read(iprot);
-          isset_unit = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_isAdjustedToUTC)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_unit)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t TimeType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("TimeType");
-
-  xfer += oprot->writeFieldBegin("isAdjustedToUTC", ::apache::thrift::protocol::T_BOOL, 1);
-  xfer += oprot->writeBool(this->isAdjustedToUTC);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("unit", ::apache::thrift::protocol::T_STRUCT, 2);
-  xfer += this->unit.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(TimeType &a, TimeType &b) {
-  using ::std::swap;
-  swap(a.isAdjustedToUTC, b.isAdjustedToUTC);
-  swap(a.unit, b.unit);
-}
-
-TimeType::TimeType(const TimeType& other44) noexcept {
-  isAdjustedToUTC = other44.isAdjustedToUTC;
-  unit = other44.unit;
-}
-TimeType& TimeType::operator=(const TimeType& other45) noexcept {
-  isAdjustedToUTC = other45.isAdjustedToUTC;
-  unit = other45.unit;
-  return *this;
-}
-void TimeType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "TimeType(";
-  out << "isAdjustedToUTC=" << to_string(isAdjustedToUTC);
-  out << ", " << "unit=" << to_string(unit);
-  out << ")";
-}
-
-
-IntType::~IntType() noexcept {
-}
-
-IntType::IntType() noexcept
-   : bitWidth(0),
-     isSigned(0) {
-}
-
-void IntType::__set_bitWidth(const int8_t val) {
-  this->bitWidth = val;
-}
-
-void IntType::__set_isSigned(const bool val) {
-  this->isSigned = val;
-}
-std::ostream& operator<<(std::ostream& out, const IntType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t IntType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_bitWidth = false;
-  bool isset_isSigned = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_BYTE) {
-          xfer += iprot->readByte(this->bitWidth);
-          isset_bitWidth = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->isSigned);
-          isset_isSigned = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_bitWidth)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_isSigned)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t IntType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("IntType");
-
-  xfer += oprot->writeFieldBegin("bitWidth", ::apache::thrift::protocol::T_BYTE, 1);
-  xfer += oprot->writeByte(this->bitWidth);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("isSigned", ::apache::thrift::protocol::T_BOOL, 2);
-  xfer += oprot->writeBool(this->isSigned);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(IntType &a, IntType &b) {
-  using ::std::swap;
-  swap(a.bitWidth, b.bitWidth);
-  swap(a.isSigned, b.isSigned);
-}
-
-IntType::IntType(const IntType& other46) noexcept {
-  bitWidth = other46.bitWidth;
-  isSigned = other46.isSigned;
-}
-IntType& IntType::operator=(const IntType& other47) noexcept {
-  bitWidth = other47.bitWidth;
-  isSigned = other47.isSigned;
-  return *this;
-}
-void IntType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "IntType(";
-  out << "bitWidth=" << to_string(bitWidth);
-  out << ", " << "isSigned=" << to_string(isSigned);
-  out << ")";
-}
-
-
-JsonType::~JsonType() noexcept {
-}
-
-JsonType::JsonType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const JsonType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t JsonType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t JsonType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("JsonType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(JsonType &a, JsonType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-JsonType::JsonType(const JsonType& other48) noexcept {
-  (void) other48;
-}
-JsonType& JsonType::operator=(const JsonType& other49) noexcept {
-  (void) other49;
-  return *this;
-}
-void JsonType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "JsonType(";
-  out << ")";
-}
-
-
-BsonType::~BsonType() noexcept {
-}
-
-BsonType::BsonType() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const BsonType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t BsonType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t BsonType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("BsonType");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(BsonType &a, BsonType &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-BsonType::BsonType(const BsonType& other50) noexcept {
-  (void) other50;
-}
-BsonType& BsonType::operator=(const BsonType& other51) noexcept {
-  (void) other51;
-  return *this;
-}
-void BsonType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "BsonType(";
-  out << ")";
-}
-
-
-LogicalType::~LogicalType() noexcept {
-}
-
-LogicalType::LogicalType() noexcept {
-}
-
-void LogicalType::__set_STRING(const StringType& val) {
-  this->STRING = val;
-__isset.STRING = true;
-}
-
-void LogicalType::__set_MAP(const MapType& val) {
-  this->MAP = val;
-__isset.MAP = true;
-}
-
-void LogicalType::__set_LIST(const ListType& val) {
-  this->LIST = val;
-__isset.LIST = true;
-}
-
-void LogicalType::__set_ENUM(const EnumType& val) {
-  this->ENUM = val;
-__isset.ENUM = true;
-}
-
-void LogicalType::__set_DECIMAL(const DecimalType& val) {
-  this->DECIMAL = val;
-__isset.DECIMAL = true;
-}
-
-void LogicalType::__set_DATE(const DateType& val) {
-  this->DATE = val;
-__isset.DATE = true;
-}
-
-void LogicalType::__set_TIME(const TimeType& val) {
-  this->TIME = val;
-__isset.TIME = true;
-}
-
-void LogicalType::__set_TIMESTAMP(const TimestampType& val) {
-  this->TIMESTAMP = val;
-__isset.TIMESTAMP = true;
-}
-
-void LogicalType::__set_INTEGER(const IntType& val) {
-  this->INTEGER = val;
-__isset.INTEGER = true;
-}
-
-void LogicalType::__set_UNKNOWN(const NullType& val) {
-  this->UNKNOWN = val;
-__isset.UNKNOWN = true;
-}
-
-void LogicalType::__set_JSON(const JsonType& val) {
-  this->JSON = val;
-__isset.JSON = true;
-}
-
-void LogicalType::__set_BSON(const BsonType& val) {
-  this->BSON = val;
-__isset.BSON = true;
-}
-
-void LogicalType::__set_UUID(const UUIDType& val) {
-  this->UUID = val;
-__isset.UUID = true;
-}
-
-void LogicalType::__set_FLOAT16(const Float16Type& val) {
-  this->FLOAT16 = val;
-__isset.FLOAT16 = true;
-}
-std::ostream& operator<<(std::ostream& out, const LogicalType& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t LogicalType::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->STRING.read(iprot);
-          this->__isset.STRING = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->MAP.read(iprot);
-          this->__isset.MAP = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->LIST.read(iprot);
-          this->__isset.LIST = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ENUM.read(iprot);
-          this->__isset.ENUM = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->DECIMAL.read(iprot);
-          this->__isset.DECIMAL = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->DATE.read(iprot);
-          this->__isset.DATE = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->TIME.read(iprot);
-          this->__isset.TIME = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->TIMESTAMP.read(iprot);
-          this->__isset.TIMESTAMP = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 10:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->INTEGER.read(iprot);
-          this->__isset.INTEGER = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 11:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->UNKNOWN.read(iprot);
-          this->__isset.UNKNOWN = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 12:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->JSON.read(iprot);
-          this->__isset.JSON = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 13:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->BSON.read(iprot);
-          this->__isset.BSON = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 14:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->UUID.read(iprot);
-          this->__isset.UUID = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 15:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->FLOAT16.read(iprot);
-          this->__isset.FLOAT16 = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t LogicalType::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("LogicalType");
-
-  if (this->__isset.STRING) {
-    xfer += oprot->writeFieldBegin("STRING", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->STRING.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.MAP) {
-    xfer += oprot->writeFieldBegin("MAP", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->MAP.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.LIST) {
-    xfer += oprot->writeFieldBegin("LIST", ::apache::thrift::protocol::T_STRUCT, 3);
-    xfer += this->LIST.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.ENUM) {
-    xfer += oprot->writeFieldBegin("ENUM", ::apache::thrift::protocol::T_STRUCT, 4);
-    xfer += this->ENUM.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.DECIMAL) {
-    xfer += oprot->writeFieldBegin("DECIMAL", ::apache::thrift::protocol::T_STRUCT, 5);
-    xfer += this->DECIMAL.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.DATE) {
-    xfer += oprot->writeFieldBegin("DATE", ::apache::thrift::protocol::T_STRUCT, 6);
-    xfer += this->DATE.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.TIME) {
-    xfer += oprot->writeFieldBegin("TIME", ::apache::thrift::protocol::T_STRUCT, 7);
-    xfer += this->TIME.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.TIMESTAMP) {
-    xfer += oprot->writeFieldBegin("TIMESTAMP", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->TIMESTAMP.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.INTEGER) {
-    xfer += oprot->writeFieldBegin("INTEGER", ::apache::thrift::protocol::T_STRUCT, 10);
-    xfer += this->INTEGER.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.UNKNOWN) {
-    xfer += oprot->writeFieldBegin("UNKNOWN", ::apache::thrift::protocol::T_STRUCT, 11);
-    xfer += this->UNKNOWN.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.JSON) {
-    xfer += oprot->writeFieldBegin("JSON", ::apache::thrift::protocol::T_STRUCT, 12);
-    xfer += this->JSON.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.BSON) {
-    xfer += oprot->writeFieldBegin("BSON", ::apache::thrift::protocol::T_STRUCT, 13);
-    xfer += this->BSON.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.UUID) {
-    xfer += oprot->writeFieldBegin("UUID", ::apache::thrift::protocol::T_STRUCT, 14);
-    xfer += this->UUID.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.FLOAT16) {
-    xfer += oprot->writeFieldBegin("FLOAT16", ::apache::thrift::protocol::T_STRUCT, 15);
-    xfer += this->FLOAT16.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(LogicalType &a, LogicalType &b) {
-  using ::std::swap;
-  swap(a.STRING, b.STRING);
-  swap(a.MAP, b.MAP);
-  swap(a.LIST, b.LIST);
-  swap(a.ENUM, b.ENUM);
-  swap(a.DECIMAL, b.DECIMAL);
-  swap(a.DATE, b.DATE);
-  swap(a.TIME, b.TIME);
-  swap(a.TIMESTAMP, b.TIMESTAMP);
-  swap(a.INTEGER, b.INTEGER);
-  swap(a.UNKNOWN, b.UNKNOWN);
-  swap(a.JSON, b.JSON);
-  swap(a.BSON, b.BSON);
-  swap(a.UUID, b.UUID);
-  swap(a.FLOAT16, b.FLOAT16);
-  swap(a.__isset, b.__isset);
-}
-
-LogicalType::LogicalType(const LogicalType& other52) noexcept {
-  STRING = other52.STRING;
-  MAP = other52.MAP;
-  LIST = other52.LIST;
-  ENUM = other52.ENUM;
-  DECIMAL = other52.DECIMAL;
-  DATE = other52.DATE;
-  TIME = other52.TIME;
-  TIMESTAMP = other52.TIMESTAMP;
-  INTEGER = other52.INTEGER;
-  UNKNOWN = other52.UNKNOWN;
-  JSON = other52.JSON;
-  BSON = other52.BSON;
-  UUID = other52.UUID;
-  FLOAT16 = other52.FLOAT16;
-  __isset = other52.__isset;
-}
-LogicalType& LogicalType::operator=(const LogicalType& other53) noexcept {
-  STRING = other53.STRING;
-  MAP = other53.MAP;
-  LIST = other53.LIST;
-  ENUM = other53.ENUM;
-  DECIMAL = other53.DECIMAL;
-  DATE = other53.DATE;
-  TIME = other53.TIME;
-  TIMESTAMP = other53.TIMESTAMP;
-  INTEGER = other53.INTEGER;
-  UNKNOWN = other53.UNKNOWN;
-  JSON = other53.JSON;
-  BSON = other53.BSON;
-  UUID = other53.UUID;
-  FLOAT16 = other53.FLOAT16;
-  __isset = other53.__isset;
-  return *this;
-}
-void LogicalType::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "LogicalType(";
-  out << "STRING="; (__isset.STRING ? (out << to_string(STRING)) : (out << "<null>"));
-  out << ", " << "MAP="; (__isset.MAP ? (out << to_string(MAP)) : (out << "<null>"));
-  out << ", " << "LIST="; (__isset.LIST ? (out << to_string(LIST)) : (out << "<null>"));
-  out << ", " << "ENUM="; (__isset.ENUM ? (out << to_string(ENUM)) : (out << "<null>"));
-  out << ", " << "DECIMAL="; (__isset.DECIMAL ? (out << to_string(DECIMAL)) : (out << "<null>"));
-  out << ", " << "DATE="; (__isset.DATE ? (out << to_string(DATE)) : (out << "<null>"));
-  out << ", " << "TIME="; (__isset.TIME ? (out << to_string(TIME)) : (out << "<null>"));
-  out << ", " << "TIMESTAMP="; (__isset.TIMESTAMP ? (out << to_string(TIMESTAMP)) : (out << "<null>"));
-  out << ", " << "INTEGER="; (__isset.INTEGER ? (out << to_string(INTEGER)) : (out << "<null>"));
-  out << ", " << "UNKNOWN="; (__isset.UNKNOWN ? (out << to_string(UNKNOWN)) : (out << "<null>"));
-  out << ", " << "JSON="; (__isset.JSON ? (out << to_string(JSON)) : (out << "<null>"));
-  out << ", " << "BSON="; (__isset.BSON ? (out << to_string(BSON)) : (out << "<null>"));
-  out << ", " << "UUID="; (__isset.UUID ? (out << to_string(UUID)) : (out << "<null>"));
-  out << ", " << "FLOAT16="; (__isset.FLOAT16 ? (out << to_string(FLOAT16)) : (out << "<null>"));
-  out << ")";
-}
-
-
-SchemaElement::~SchemaElement() noexcept {
-}
-
-SchemaElement::SchemaElement() noexcept
-   : type(static_cast<Type::type>(0)),
-     type_length(0),
-     repetition_type(static_cast<FieldRepetitionType::type>(0)),
-     name(),
-     num_children(0),
-     converted_type(static_cast<ConvertedType::type>(0)),
-     scale(0),
-     precision(0),
-     field_id(0) {
-}
-
-void SchemaElement::__set_type(const Type::type val) {
-  this->type = val;
-__isset.type = true;
-}
-
-void SchemaElement::__set_type_length(const int32_t val) {
-  this->type_length = val;
-__isset.type_length = true;
-}
-
-void SchemaElement::__set_repetition_type(const FieldRepetitionType::type val) {
-  this->repetition_type = val;
-__isset.repetition_type = true;
-}
-
-void SchemaElement::__set_name(const std::string& val) {
-  this->name = val;
-}
-
-void SchemaElement::__set_num_children(const int32_t val) {
-  this->num_children = val;
-__isset.num_children = true;
-}
-
-void SchemaElement::__set_converted_type(const ConvertedType::type val) {
-  this->converted_type = val;
-__isset.converted_type = true;
-}
-
-void SchemaElement::__set_scale(const int32_t val) {
-  this->scale = val;
-__isset.scale = true;
-}
-
-void SchemaElement::__set_precision(const int32_t val) {
-  this->precision = val;
-__isset.precision = true;
-}
-
-void SchemaElement::__set_field_id(const int32_t val) {
-  this->field_id = val;
-__isset.field_id = true;
-}
-
-void SchemaElement::__set_logicalType(const LogicalType& val) {
-  this->logicalType = val;
-__isset.logicalType = true;
-}
-std::ostream& operator<<(std::ostream& out, const SchemaElement& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_name = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast54;
-          xfer += iprot->readI32(ecast54);
-          this->type = static_cast<Type::type>(ecast54);
-          this->__isset.type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->type_length);
-          this->__isset.type_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast55;
-          xfer += iprot->readI32(ecast55);
-          this->repetition_type = static_cast<FieldRepetitionType::type>(ecast55);
-          this->__isset.repetition_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->name);
-          isset_name = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_children);
-          this->__isset.num_children = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast56;
-          xfer += iprot->readI32(ecast56);
-          this->converted_type = static_cast<ConvertedType::type>(ecast56);
-          this->__isset.converted_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->scale);
-          this->__isset.scale = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->precision);
-          this->__isset.precision = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 9:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->field_id);
-          this->__isset.field_id = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 10:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->logicalType.read(iprot);
-          this->__isset.logicalType = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_name)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t SchemaElement::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("SchemaElement");
-
-  if (this->__isset.type) {
-    xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
-    xfer += oprot->writeI32(static_cast<int32_t>(this->type));
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.type_length) {
-    xfer += oprot->writeFieldBegin("type_length", ::apache::thrift::protocol::T_I32, 2);
-    xfer += oprot->writeI32(this->type_length);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.repetition_type) {
-    xfer += oprot->writeFieldBegin("repetition_type", ::apache::thrift::protocol::T_I32, 3);
-    xfer += oprot->writeI32(static_cast<int32_t>(this->repetition_type));
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 4);
-  xfer += oprot->writeString(this->name);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.num_children) {
-    xfer += oprot->writeFieldBegin("num_children", ::apache::thrift::protocol::T_I32, 5);
-    xfer += oprot->writeI32(this->num_children);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.converted_type) {
-    xfer += oprot->writeFieldBegin("converted_type", ::apache::thrift::protocol::T_I32, 6);
-    xfer += oprot->writeI32(static_cast<int32_t>(this->converted_type));
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.scale) {
-    xfer += oprot->writeFieldBegin("scale", ::apache::thrift::protocol::T_I32, 7);
-    xfer += oprot->writeI32(this->scale);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.precision) {
-    xfer += oprot->writeFieldBegin("precision", ::apache::thrift::protocol::T_I32, 8);
-    xfer += oprot->writeI32(this->precision);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.field_id) {
-    xfer += oprot->writeFieldBegin("field_id", ::apache::thrift::protocol::T_I32, 9);
-    xfer += oprot->writeI32(this->field_id);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.logicalType) {
-    xfer += oprot->writeFieldBegin("logicalType", ::apache::thrift::protocol::T_STRUCT, 10);
-    xfer += this->logicalType.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(SchemaElement &a, SchemaElement &b) {
-  using ::std::swap;
-  swap(a.type, b.type);
-  swap(a.type_length, b.type_length);
-  swap(a.repetition_type, b.repetition_type);
-  swap(a.name, b.name);
-  swap(a.num_children, b.num_children);
-  swap(a.converted_type, b.converted_type);
-  swap(a.scale, b.scale);
-  swap(a.precision, b.precision);
-  swap(a.field_id, b.field_id);
-  swap(a.logicalType, b.logicalType);
-  swap(a.__isset, b.__isset);
-}
-
-SchemaElement::SchemaElement(const SchemaElement& other57) {
-  type = other57.type;
-  type_length = other57.type_length;
-  repetition_type = other57.repetition_type;
-  name = other57.name;
-  num_children = other57.num_children;
-  converted_type = other57.converted_type;
-  scale = other57.scale;
-  precision = other57.precision;
-  field_id = other57.field_id;
-  logicalType = other57.logicalType;
-  __isset = other57.__isset;
-}
-SchemaElement& SchemaElement::operator=(const SchemaElement& other58) {
-  type = other58.type;
-  type_length = other58.type_length;
-  repetition_type = other58.repetition_type;
-  name = other58.name;
-  num_children = other58.num_children;
-  converted_type = other58.converted_type;
-  scale = other58.scale;
-  precision = other58.precision;
-  field_id = other58.field_id;
-  logicalType = other58.logicalType;
-  __isset = other58.__isset;
-  return *this;
-}
-void SchemaElement::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "SchemaElement(";
-  out << "type="; (__isset.type ? (out << to_string(type)) : (out << "<null>"));
-  out << ", " << "type_length="; (__isset.type_length ? (out << to_string(type_length)) : (out << "<null>"));
-  out << ", " << "repetition_type="; (__isset.repetition_type ? (out << to_string(repetition_type)) : (out << "<null>"));
-  out << ", " << "name=" << to_string(name);
-  out << ", " << "num_children="; (__isset.num_children ? (out << to_string(num_children)) : (out << "<null>"));
-  out << ", " << "converted_type="; (__isset.converted_type ? (out << to_string(converted_type)) : (out << "<null>"));
-  out << ", " << "scale="; (__isset.scale ? (out << to_string(scale)) : (out << "<null>"));
-  out << ", " << "precision="; (__isset.precision ? (out << to_string(precision)) : (out << "<null>"));
-  out << ", " << "field_id="; (__isset.field_id ? (out << to_string(field_id)) : (out << "<null>"));
-  out << ", " << "logicalType="; (__isset.logicalType ? (out << to_string(logicalType)) : (out << "<null>"));
-  out << ")";
-}
-
-
-DataPageHeader::~DataPageHeader() noexcept {
-}
-
-DataPageHeader::DataPageHeader() noexcept
-   : num_values(0),
-     encoding(static_cast<Encoding::type>(0)),
-     definition_level_encoding(static_cast<Encoding::type>(0)),
-     repetition_level_encoding(static_cast<Encoding::type>(0)) {
-}
-
-void DataPageHeader::__set_num_values(const int32_t val) {
-  this->num_values = val;
-}
-
-void DataPageHeader::__set_encoding(const Encoding::type val) {
-  this->encoding = val;
-}
-
-void DataPageHeader::__set_definition_level_encoding(const Encoding::type val) {
-  this->definition_level_encoding = val;
-}
-
-void DataPageHeader::__set_repetition_level_encoding(const Encoding::type val) {
-  this->repetition_level_encoding = val;
-}
-
-void DataPageHeader::__set_statistics(const Statistics& val) {
-  this->statistics = val;
-__isset.statistics = true;
-}
-std::ostream& operator<<(std::ostream& out, const DataPageHeader& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_num_values = false;
-  bool isset_encoding = false;
-  bool isset_definition_level_encoding = false;
-  bool isset_repetition_level_encoding = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast59;
-          xfer += iprot->readI32(ecast59);
-          this->encoding = static_cast<Encoding::type>(ecast59);
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast60;
-          xfer += iprot->readI32(ecast60);
-          this->definition_level_encoding = static_cast<Encoding::type>(ecast60);
-          isset_definition_level_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast61;
-          xfer += iprot->readI32(ecast61);
-          this->repetition_level_encoding = static_cast<Encoding::type>(ecast61);
-          isset_repetition_level_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->statistics.read(iprot);
-          this->__isset.statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_definition_level_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_repetition_level_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DataPageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("DataPageHeader");
-
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->encoding));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("definition_level_encoding", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->definition_level_encoding));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("repetition_level_encoding", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->repetition_level_encoding));
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.statistics) {
-    xfer += oprot->writeFieldBegin("statistics", ::apache::thrift::protocol::T_STRUCT, 5);
-    xfer += this->statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DataPageHeader &a, DataPageHeader &b) {
-  using ::std::swap;
-  swap(a.num_values, b.num_values);
-  swap(a.encoding, b.encoding);
-  swap(a.definition_level_encoding, b.definition_level_encoding);
-  swap(a.repetition_level_encoding, b.repetition_level_encoding);
-  swap(a.statistics, b.statistics);
-  swap(a.__isset, b.__isset);
-}
-
-DataPageHeader::DataPageHeader(const DataPageHeader& other62) {
-  num_values = other62.num_values;
-  encoding = other62.encoding;
-  definition_level_encoding = other62.definition_level_encoding;
-  repetition_level_encoding = other62.repetition_level_encoding;
-  statistics = other62.statistics;
-  __isset = other62.__isset;
-}
-DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other63) {
-  num_values = other63.num_values;
-  encoding = other63.encoding;
-  definition_level_encoding = other63.definition_level_encoding;
-  repetition_level_encoding = other63.repetition_level_encoding;
-  statistics = other63.statistics;
-  __isset = other63.__isset;
-  return *this;
-}
-void DataPageHeader::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "DataPageHeader(";
-  out << "num_values=" << to_string(num_values);
-  out << ", " << "encoding=" << to_string(encoding);
-  out << ", " << "definition_level_encoding=" << to_string(definition_level_encoding);
-  out << ", " << "repetition_level_encoding=" << to_string(repetition_level_encoding);
-  out << ", " << "statistics="; (__isset.statistics ? (out << to_string(statistics)) : (out << "<null>"));
-  out << ")";
-}
-
-
-IndexPageHeader::~IndexPageHeader() noexcept {
-}
-
-IndexPageHeader::IndexPageHeader() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const IndexPageHeader& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t IndexPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t IndexPageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("IndexPageHeader");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(IndexPageHeader &a, IndexPageHeader &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-IndexPageHeader::IndexPageHeader(const IndexPageHeader& other64) noexcept {
-  (void) other64;
-}
-IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other65) noexcept {
-  (void) other65;
-  return *this;
-}
-void IndexPageHeader::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "IndexPageHeader(";
-  out << ")";
-}
-
-
-DictionaryPageHeader::~DictionaryPageHeader() noexcept {
-}
-
-DictionaryPageHeader::DictionaryPageHeader() noexcept
-   : num_values(0),
-     encoding(static_cast<Encoding::type>(0)),
-     is_sorted(0) {
-}
-
-void DictionaryPageHeader::__set_num_values(const int32_t val) {
-  this->num_values = val;
-}
-
-void DictionaryPageHeader::__set_encoding(const Encoding::type val) {
-  this->encoding = val;
-}
-
-void DictionaryPageHeader::__set_is_sorted(const bool val) {
-  this->is_sorted = val;
-__isset.is_sorted = true;
-}
-std::ostream& operator<<(std::ostream& out, const DictionaryPageHeader& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t DictionaryPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_num_values = false;
-  bool isset_encoding = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast66;
-          xfer += iprot->readI32(ecast66);
-          this->encoding = static_cast<Encoding::type>(ecast66);
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->is_sorted);
-          this->__isset.is_sorted = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DictionaryPageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("DictionaryPageHeader");
-
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->encoding));
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.is_sorted) {
-    xfer += oprot->writeFieldBegin("is_sorted", ::apache::thrift::protocol::T_BOOL, 3);
-    xfer += oprot->writeBool(this->is_sorted);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DictionaryPageHeader &a, DictionaryPageHeader &b) {
-  using ::std::swap;
-  swap(a.num_values, b.num_values);
-  swap(a.encoding, b.encoding);
-  swap(a.is_sorted, b.is_sorted);
-  swap(a.__isset, b.__isset);
-}
-
-DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other67) noexcept {
-  num_values = other67.num_values;
-  encoding = other67.encoding;
-  is_sorted = other67.is_sorted;
-  __isset = other67.__isset;
-}
-DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other68) noexcept {
-  num_values = other68.num_values;
-  encoding = other68.encoding;
-  is_sorted = other68.is_sorted;
-  __isset = other68.__isset;
-  return *this;
-}
-void DictionaryPageHeader::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "DictionaryPageHeader(";
-  out << "num_values=" << to_string(num_values);
-  out << ", " << "encoding=" << to_string(encoding);
-  out << ", " << "is_sorted="; (__isset.is_sorted ? (out << to_string(is_sorted)) : (out << "<null>"));
-  out << ")";
-}
-
-
-DataPageHeaderV2::~DataPageHeaderV2() noexcept {
-}
-
-DataPageHeaderV2::DataPageHeaderV2() noexcept
-   : num_values(0),
-     num_nulls(0),
-     num_rows(0),
-     encoding(static_cast<Encoding::type>(0)),
-     definition_levels_byte_length(0),
-     repetition_levels_byte_length(0),
-     is_compressed(true) {
-}
-
-void DataPageHeaderV2::__set_num_values(const int32_t val) {
-  this->num_values = val;
-}
-
-void DataPageHeaderV2::__set_num_nulls(const int32_t val) {
-  this->num_nulls = val;
-}
-
-void DataPageHeaderV2::__set_num_rows(const int32_t val) {
-  this->num_rows = val;
-}
-
-void DataPageHeaderV2::__set_encoding(const Encoding::type val) {
-  this->encoding = val;
-}
-
-void DataPageHeaderV2::__set_definition_levels_byte_length(const int32_t val) {
-  this->definition_levels_byte_length = val;
-}
-
-void DataPageHeaderV2::__set_repetition_levels_byte_length(const int32_t val) {
-  this->repetition_levels_byte_length = val;
-}
-
-void DataPageHeaderV2::__set_is_compressed(const bool val) {
-  this->is_compressed = val;
-__isset.is_compressed = true;
-}
-
-void DataPageHeaderV2::__set_statistics(const Statistics& val) {
-  this->statistics = val;
-__isset.statistics = true;
-}
-std::ostream& operator<<(std::ostream& out, const DataPageHeaderV2& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t DataPageHeaderV2::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_num_values = false;
-  bool isset_num_nulls = false;
-  bool isset_num_rows = false;
-  bool isset_encoding = false;
-  bool isset_definition_levels_byte_length = false;
-  bool isset_repetition_levels_byte_length = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_nulls);
-          isset_num_nulls = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast69;
-          xfer += iprot->readI32(ecast69);
-          this->encoding = static_cast<Encoding::type>(ecast69);
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->definition_levels_byte_length);
-          isset_definition_levels_byte_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->repetition_levels_byte_length);
-          isset_repetition_levels_byte_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->is_compressed);
-          this->__isset.is_compressed = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->statistics.read(iprot);
-          this->__isset.statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_nulls)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_definition_levels_byte_length)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_repetition_levels_byte_length)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DataPageHeaderV2::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("DataPageHeaderV2");
-
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("num_nulls", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->num_nulls);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->encoding));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("definition_levels_byte_length", ::apache::thrift::protocol::T_I32, 5);
-  xfer += oprot->writeI32(this->definition_levels_byte_length);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("repetition_levels_byte_length", ::apache::thrift::protocol::T_I32, 6);
-  xfer += oprot->writeI32(this->repetition_levels_byte_length);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.is_compressed) {
-    xfer += oprot->writeFieldBegin("is_compressed", ::apache::thrift::protocol::T_BOOL, 7);
-    xfer += oprot->writeBool(this->is_compressed);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.statistics) {
-    xfer += oprot->writeFieldBegin("statistics", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b) {
-  using ::std::swap;
-  swap(a.num_values, b.num_values);
-  swap(a.num_nulls, b.num_nulls);
-  swap(a.num_rows, b.num_rows);
-  swap(a.encoding, b.encoding);
-  swap(a.definition_levels_byte_length, b.definition_levels_byte_length);
-  swap(a.repetition_levels_byte_length, b.repetition_levels_byte_length);
-  swap(a.is_compressed, b.is_compressed);
-  swap(a.statistics, b.statistics);
-  swap(a.__isset, b.__isset);
-}
-
-DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other70) {
-  num_values = other70.num_values;
-  num_nulls = other70.num_nulls;
-  num_rows = other70.num_rows;
-  encoding = other70.encoding;
-  definition_levels_byte_length = other70.definition_levels_byte_length;
-  repetition_levels_byte_length = other70.repetition_levels_byte_length;
-  is_compressed = other70.is_compressed;
-  statistics = other70.statistics;
-  __isset = other70.__isset;
-}
-DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other71) {
-  num_values = other71.num_values;
-  num_nulls = other71.num_nulls;
-  num_rows = other71.num_rows;
-  encoding = other71.encoding;
-  definition_levels_byte_length = other71.definition_levels_byte_length;
-  repetition_levels_byte_length = other71.repetition_levels_byte_length;
-  is_compressed = other71.is_compressed;
-  statistics = other71.statistics;
-  __isset = other71.__isset;
-  return *this;
-}
-void DataPageHeaderV2::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "DataPageHeaderV2(";
-  out << "num_values=" << to_string(num_values);
-  out << ", " << "num_nulls=" << to_string(num_nulls);
-  out << ", " << "num_rows=" << to_string(num_rows);
-  out << ", " << "encoding=" << to_string(encoding);
-  out << ", " << "definition_levels_byte_length=" << to_string(definition_levels_byte_length);
-  out << ", " << "repetition_levels_byte_length=" << to_string(repetition_levels_byte_length);
-  out << ", " << "is_compressed="; (__isset.is_compressed ? (out << to_string(is_compressed)) : (out << "<null>"));
-  out << ", " << "statistics="; (__isset.statistics ? (out << to_string(statistics)) : (out << "<null>"));
-  out << ")";
-}
-
-
-SplitBlockAlgorithm::~SplitBlockAlgorithm() noexcept {
-}
-
-SplitBlockAlgorithm::SplitBlockAlgorithm() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const SplitBlockAlgorithm& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t SplitBlockAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t SplitBlockAlgorithm::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("SplitBlockAlgorithm");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(SplitBlockAlgorithm &a, SplitBlockAlgorithm &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-SplitBlockAlgorithm::SplitBlockAlgorithm(const SplitBlockAlgorithm& other72) noexcept {
-  (void) other72;
-}
-SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(const SplitBlockAlgorithm& other73) noexcept {
-  (void) other73;
-  return *this;
-}
-void SplitBlockAlgorithm::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "SplitBlockAlgorithm(";
-  out << ")";
-}
-
-
-BloomFilterAlgorithm::~BloomFilterAlgorithm() noexcept {
-}
-
-BloomFilterAlgorithm::BloomFilterAlgorithm() noexcept {
-}
-
-void BloomFilterAlgorithm::__set_BLOCK(const SplitBlockAlgorithm& val) {
-  this->BLOCK = val;
-__isset.BLOCK = true;
-}
-std::ostream& operator<<(std::ostream& out, const BloomFilterAlgorithm& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t BloomFilterAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->BLOCK.read(iprot);
-          this->__isset.BLOCK = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t BloomFilterAlgorithm::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("BloomFilterAlgorithm");
-
-  if (this->__isset.BLOCK) {
-    xfer += oprot->writeFieldBegin("BLOCK", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->BLOCK.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(BloomFilterAlgorithm &a, BloomFilterAlgorithm &b) {
-  using ::std::swap;
-  swap(a.BLOCK, b.BLOCK);
-  swap(a.__isset, b.__isset);
-}
-
-BloomFilterAlgorithm::BloomFilterAlgorithm(const BloomFilterAlgorithm& other74) noexcept {
-  BLOCK = other74.BLOCK;
-  __isset = other74.__isset;
-}
-BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(const BloomFilterAlgorithm& other75) noexcept {
-  BLOCK = other75.BLOCK;
-  __isset = other75.__isset;
-  return *this;
-}
-void BloomFilterAlgorithm::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "BloomFilterAlgorithm(";
-  out << "BLOCK="; (__isset.BLOCK ? (out << to_string(BLOCK)) : (out << "<null>"));
-  out << ")";
-}
-
-
-XxHash::~XxHash() noexcept {
-}
-
-XxHash::XxHash() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const XxHash& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t XxHash::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t XxHash::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("XxHash");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(XxHash &a, XxHash &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-XxHash::XxHash(const XxHash& other76) noexcept {
-  (void) other76;
-}
-XxHash& XxHash::operator=(const XxHash& other77) noexcept {
-  (void) other77;
-  return *this;
-}
-void XxHash::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "XxHash(";
-  out << ")";
-}
-
-
-BloomFilterHash::~BloomFilterHash() noexcept {
-}
-
-BloomFilterHash::BloomFilterHash() noexcept {
-}
-
-void BloomFilterHash::__set_XXHASH(const XxHash& val) {
-  this->XXHASH = val;
-__isset.XXHASH = true;
-}
-std::ostream& operator<<(std::ostream& out, const BloomFilterHash& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t BloomFilterHash::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->XXHASH.read(iprot);
-          this->__isset.XXHASH = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t BloomFilterHash::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("BloomFilterHash");
-
-  if (this->__isset.XXHASH) {
-    xfer += oprot->writeFieldBegin("XXHASH", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->XXHASH.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(BloomFilterHash &a, BloomFilterHash &b) {
-  using ::std::swap;
-  swap(a.XXHASH, b.XXHASH);
-  swap(a.__isset, b.__isset);
-}
-
-BloomFilterHash::BloomFilterHash(const BloomFilterHash& other78) noexcept {
-  XXHASH = other78.XXHASH;
-  __isset = other78.__isset;
-}
-BloomFilterHash& BloomFilterHash::operator=(const BloomFilterHash& other79) noexcept {
-  XXHASH = other79.XXHASH;
-  __isset = other79.__isset;
-  return *this;
-}
-void BloomFilterHash::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "BloomFilterHash(";
-  out << "XXHASH="; (__isset.XXHASH ? (out << to_string(XXHASH)) : (out << "<null>"));
-  out << ")";
-}
-
-
-Uncompressed::~Uncompressed() noexcept {
-}
-
-Uncompressed::Uncompressed() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const Uncompressed& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t Uncompressed::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t Uncompressed::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Uncompressed");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(Uncompressed &a, Uncompressed &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-Uncompressed::Uncompressed(const Uncompressed& other80) noexcept {
-  (void) other80;
-}
-Uncompressed& Uncompressed::operator=(const Uncompressed& other81) noexcept {
-  (void) other81;
-  return *this;
-}
-void Uncompressed::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "Uncompressed(";
-  out << ")";
-}
-
-
-BloomFilterCompression::~BloomFilterCompression() noexcept {
-}
-
-BloomFilterCompression::BloomFilterCompression() noexcept {
-}
-
-void BloomFilterCompression::__set_UNCOMPRESSED(const Uncompressed& val) {
-  this->UNCOMPRESSED = val;
-__isset.UNCOMPRESSED = true;
-}
-std::ostream& operator<<(std::ostream& out, const BloomFilterCompression& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t BloomFilterCompression::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->UNCOMPRESSED.read(iprot);
-          this->__isset.UNCOMPRESSED = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t BloomFilterCompression::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("BloomFilterCompression");
-
-  if (this->__isset.UNCOMPRESSED) {
-    xfer += oprot->writeFieldBegin("UNCOMPRESSED", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->UNCOMPRESSED.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(BloomFilterCompression &a, BloomFilterCompression &b) {
-  using ::std::swap;
-  swap(a.UNCOMPRESSED, b.UNCOMPRESSED);
-  swap(a.__isset, b.__isset);
-}
-
-BloomFilterCompression::BloomFilterCompression(const BloomFilterCompression& other82) noexcept {
-  UNCOMPRESSED = other82.UNCOMPRESSED;
-  __isset = other82.__isset;
-}
-BloomFilterCompression& BloomFilterCompression::operator=(const BloomFilterCompression& other83) noexcept {
-  UNCOMPRESSED = other83.UNCOMPRESSED;
-  __isset = other83.__isset;
-  return *this;
-}
-void BloomFilterCompression::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "BloomFilterCompression(";
-  out << "UNCOMPRESSED="; (__isset.UNCOMPRESSED ? (out << to_string(UNCOMPRESSED)) : (out << "<null>"));
-  out << ")";
-}
-
-
-BloomFilterHeader::~BloomFilterHeader() noexcept {
-}
-
-BloomFilterHeader::BloomFilterHeader() noexcept
-   : numBytes(0) {
-}
-
-void BloomFilterHeader::__set_numBytes(const int32_t val) {
-  this->numBytes = val;
-}
-
-void BloomFilterHeader::__set_algorithm(const BloomFilterAlgorithm& val) {
-  this->algorithm = val;
-}
-
-void BloomFilterHeader::__set_hash(const BloomFilterHash& val) {
-  this->hash = val;
-}
-
-void BloomFilterHeader::__set_compression(const BloomFilterCompression& val) {
-  this->compression = val;
-}
-std::ostream& operator<<(std::ostream& out, const BloomFilterHeader& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t BloomFilterHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_numBytes = false;
-  bool isset_algorithm = false;
-  bool isset_hash = false;
-  bool isset_compression = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->numBytes);
-          isset_numBytes = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->algorithm.read(iprot);
-          isset_algorithm = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->hash.read(iprot);
-          isset_hash = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->compression.read(iprot);
-          isset_compression = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_numBytes)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_algorithm)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_hash)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_compression)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t BloomFilterHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("BloomFilterHeader");
-
-  xfer += oprot->writeFieldBegin("numBytes", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->numBytes);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("algorithm", ::apache::thrift::protocol::T_STRUCT, 2);
-  xfer += this->algorithm.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("hash", ::apache::thrift::protocol::T_STRUCT, 3);
-  xfer += this->hash.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_STRUCT, 4);
-  xfer += this->compression.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(BloomFilterHeader &a, BloomFilterHeader &b) {
-  using ::std::swap;
-  swap(a.numBytes, b.numBytes);
-  swap(a.algorithm, b.algorithm);
-  swap(a.hash, b.hash);
-  swap(a.compression, b.compression);
-}
-
-BloomFilterHeader::BloomFilterHeader(const BloomFilterHeader& other84) noexcept {
-  numBytes = other84.numBytes;
-  algorithm = other84.algorithm;
-  hash = other84.hash;
-  compression = other84.compression;
-}
-BloomFilterHeader& BloomFilterHeader::operator=(const BloomFilterHeader& other85) noexcept {
-  numBytes = other85.numBytes;
-  algorithm = other85.algorithm;
-  hash = other85.hash;
-  compression = other85.compression;
-  return *this;
-}
-void BloomFilterHeader::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "BloomFilterHeader(";
-  out << "numBytes=" << to_string(numBytes);
-  out << ", " << "algorithm=" << to_string(algorithm);
-  out << ", " << "hash=" << to_string(hash);
-  out << ", " << "compression=" << to_string(compression);
-  out << ")";
-}
-
-
-PageHeader::~PageHeader() noexcept {
-}
-
-PageHeader::PageHeader() noexcept
-   : type(static_cast<PageType::type>(0)),
-     uncompressed_page_size(0),
-     compressed_page_size(0),
-     crc(0) {
-}
-
-void PageHeader::__set_type(const PageType::type val) {
-  this->type = val;
-}
-
-void PageHeader::__set_uncompressed_page_size(const int32_t val) {
-  this->uncompressed_page_size = val;
-}
-
-void PageHeader::__set_compressed_page_size(const int32_t val) {
-  this->compressed_page_size = val;
-}
-
-void PageHeader::__set_crc(const int32_t val) {
-  this->crc = val;
-__isset.crc = true;
-}
-
-void PageHeader::__set_data_page_header(const DataPageHeader& val) {
-  this->data_page_header = val;
-__isset.data_page_header = true;
-}
-
-void PageHeader::__set_index_page_header(const IndexPageHeader& val) {
-  this->index_page_header = val;
-__isset.index_page_header = true;
-}
-
-void PageHeader::__set_dictionary_page_header(const DictionaryPageHeader& val) {
-  this->dictionary_page_header = val;
-__isset.dictionary_page_header = true;
-}
-
-void PageHeader::__set_data_page_header_v2(const DataPageHeaderV2& val) {
-  this->data_page_header_v2 = val;
-__isset.data_page_header_v2 = true;
-}
-std::ostream& operator<<(std::ostream& out, const PageHeader& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t PageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_type = false;
-  bool isset_uncompressed_page_size = false;
-  bool isset_compressed_page_size = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast86;
-          xfer += iprot->readI32(ecast86);
-          this->type = static_cast<PageType::type>(ecast86);
-          isset_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->uncompressed_page_size);
-          isset_uncompressed_page_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->compressed_page_size);
-          isset_compressed_page_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->crc);
-          this->__isset.crc = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->data_page_header.read(iprot);
-          this->__isset.data_page_header = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->index_page_header.read(iprot);
-          this->__isset.index_page_header = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->dictionary_page_header.read(iprot);
-          this->__isset.dictionary_page_header = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->data_page_header_v2.read(iprot);
-          this->__isset.data_page_header_v2 = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_type)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_uncompressed_page_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_compressed_page_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t PageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("PageHeader");
-
-  xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->type));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("uncompressed_page_size", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->uncompressed_page_size);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("compressed_page_size", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(this->compressed_page_size);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.crc) {
-    xfer += oprot->writeFieldBegin("crc", ::apache::thrift::protocol::T_I32, 4);
-    xfer += oprot->writeI32(this->crc);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.data_page_header) {
-    xfer += oprot->writeFieldBegin("data_page_header", ::apache::thrift::protocol::T_STRUCT, 5);
-    xfer += this->data_page_header.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.index_page_header) {
-    xfer += oprot->writeFieldBegin("index_page_header", ::apache::thrift::protocol::T_STRUCT, 6);
-    xfer += this->index_page_header.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.dictionary_page_header) {
-    xfer += oprot->writeFieldBegin("dictionary_page_header", ::apache::thrift::protocol::T_STRUCT, 7);
-    xfer += this->dictionary_page_header.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.data_page_header_v2) {
-    xfer += oprot->writeFieldBegin("data_page_header_v2", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->data_page_header_v2.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(PageHeader &a, PageHeader &b) {
-  using ::std::swap;
-  swap(a.type, b.type);
-  swap(a.uncompressed_page_size, b.uncompressed_page_size);
-  swap(a.compressed_page_size, b.compressed_page_size);
-  swap(a.crc, b.crc);
-  swap(a.data_page_header, b.data_page_header);
-  swap(a.index_page_header, b.index_page_header);
-  swap(a.dictionary_page_header, b.dictionary_page_header);
-  swap(a.data_page_header_v2, b.data_page_header_v2);
-  swap(a.__isset, b.__isset);
-}
-
-PageHeader::PageHeader(const PageHeader& other87) {
-  type = other87.type;
-  uncompressed_page_size = other87.uncompressed_page_size;
-  compressed_page_size = other87.compressed_page_size;
-  crc = other87.crc;
-  data_page_header = other87.data_page_header;
-  index_page_header = other87.index_page_header;
-  dictionary_page_header = other87.dictionary_page_header;
-  data_page_header_v2 = other87.data_page_header_v2;
-  __isset = other87.__isset;
-}
-PageHeader& PageHeader::operator=(const PageHeader& other88) {
-  type = other88.type;
-  uncompressed_page_size = other88.uncompressed_page_size;
-  compressed_page_size = other88.compressed_page_size;
-  crc = other88.crc;
-  data_page_header = other88.data_page_header;
-  index_page_header = other88.index_page_header;
-  dictionary_page_header = other88.dictionary_page_header;
-  data_page_header_v2 = other88.data_page_header_v2;
-  __isset = other88.__isset;
-  return *this;
-}
-void PageHeader::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "PageHeader(";
-  out << "type=" << to_string(type);
-  out << ", " << "uncompressed_page_size=" << to_string(uncompressed_page_size);
-  out << ", " << "compressed_page_size=" << to_string(compressed_page_size);
-  out << ", " << "crc="; (__isset.crc ? (out << to_string(crc)) : (out << "<null>"));
-  out << ", " << "data_page_header="; (__isset.data_page_header ? (out << to_string(data_page_header)) : (out << "<null>"));
-  out << ", " << "index_page_header="; (__isset.index_page_header ? (out << to_string(index_page_header)) : (out << "<null>"));
-  out << ", " << "dictionary_page_header="; (__isset.dictionary_page_header ? (out << to_string(dictionary_page_header)) : (out << "<null>"));
-  out << ", " << "data_page_header_v2="; (__isset.data_page_header_v2 ? (out << to_string(data_page_header_v2)) : (out << "<null>"));
-  out << ")";
-}
-
-
-KeyValue::~KeyValue() noexcept {
-}
-
-KeyValue::KeyValue() noexcept
-   : key(),
-     value() {
-}
-
-void KeyValue::__set_key(const std::string& val) {
-  this->key = val;
-}
-
-void KeyValue::__set_value(const std::string& val) {
-  this->value = val;
-__isset.value = true;
-}
-std::ostream& operator<<(std::ostream& out, const KeyValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_key = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->key);
-          isset_key = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->value);
-          this->__isset.value = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_key)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t KeyValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("KeyValue");
-
-  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
-  xfer += oprot->writeString(this->key);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.value) {
-    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeString(this->value);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(KeyValue &a, KeyValue &b) {
-  using ::std::swap;
-  swap(a.key, b.key);
-  swap(a.value, b.value);
-  swap(a.__isset, b.__isset);
-}
-
-KeyValue::KeyValue(const KeyValue& other89) {
-  key = other89.key;
-  value = other89.value;
-  __isset = other89.__isset;
-}
-KeyValue& KeyValue::operator=(const KeyValue& other90) {
-  key = other90.key;
-  value = other90.value;
-  __isset = other90.__isset;
-  return *this;
-}
-void KeyValue::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "KeyValue(";
-  out << "key=" << to_string(key);
-  out << ", " << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
-  out << ")";
-}
-
-
-SortingColumn::~SortingColumn() noexcept {
-}
-
-SortingColumn::SortingColumn() noexcept
-   : column_idx(0),
-     descending(0),
-     nulls_first(0) {
-}
-
-void SortingColumn::__set_column_idx(const int32_t val) {
-  this->column_idx = val;
-}
-
-void SortingColumn::__set_descending(const bool val) {
-  this->descending = val;
-}
-
-void SortingColumn::__set_nulls_first(const bool val) {
-  this->nulls_first = val;
-}
-std::ostream& operator<<(std::ostream& out, const SortingColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t SortingColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_column_idx = false;
-  bool isset_descending = false;
-  bool isset_nulls_first = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->column_idx);
-          isset_column_idx = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->descending);
-          isset_descending = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->nulls_first);
-          isset_nulls_first = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_column_idx)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_descending)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_nulls_first)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t SortingColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("SortingColumn");
-
-  xfer += oprot->writeFieldBegin("column_idx", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->column_idx);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("descending", ::apache::thrift::protocol::T_BOOL, 2);
-  xfer += oprot->writeBool(this->descending);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("nulls_first", ::apache::thrift::protocol::T_BOOL, 3);
-  xfer += oprot->writeBool(this->nulls_first);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(SortingColumn &a, SortingColumn &b) {
-  using ::std::swap;
-  swap(a.column_idx, b.column_idx);
-  swap(a.descending, b.descending);
-  swap(a.nulls_first, b.nulls_first);
-}
-
-SortingColumn::SortingColumn(const SortingColumn& other91) noexcept {
-  column_idx = other91.column_idx;
-  descending = other91.descending;
-  nulls_first = other91.nulls_first;
-}
-SortingColumn& SortingColumn::operator=(const SortingColumn& other92) noexcept {
-  column_idx = other92.column_idx;
-  descending = other92.descending;
-  nulls_first = other92.nulls_first;
-  return *this;
-}
-void SortingColumn::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "SortingColumn(";
-  out << "column_idx=" << to_string(column_idx);
-  out << ", " << "descending=" << to_string(descending);
-  out << ", " << "nulls_first=" << to_string(nulls_first);
-  out << ")";
-}
-
-
-PageEncodingStats::~PageEncodingStats() noexcept {
-}
-
-PageEncodingStats::PageEncodingStats() noexcept
-   : page_type(static_cast<PageType::type>(0)),
-     encoding(static_cast<Encoding::type>(0)),
-     count(0) {
-}
-
-void PageEncodingStats::__set_page_type(const PageType::type val) {
-  this->page_type = val;
-}
-
-void PageEncodingStats::__set_encoding(const Encoding::type val) {
-  this->encoding = val;
-}
-
-void PageEncodingStats::__set_count(const int32_t val) {
-  this->count = val;
-}
-std::ostream& operator<<(std::ostream& out, const PageEncodingStats& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_page_type = false;
-  bool isset_encoding = false;
-  bool isset_count = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast93;
-          xfer += iprot->readI32(ecast93);
-          this->page_type = static_cast<PageType::type>(ecast93);
-          isset_page_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast94;
-          xfer += iprot->readI32(ecast94);
-          this->encoding = static_cast<Encoding::type>(ecast94);
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->count);
-          isset_count = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_page_type)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_count)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t PageEncodingStats::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("PageEncodingStats");
-
-  xfer += oprot->writeFieldBegin("page_type", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->page_type));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->encoding));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(this->count);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(PageEncodingStats &a, PageEncodingStats &b) {
-  using ::std::swap;
-  swap(a.page_type, b.page_type);
-  swap(a.encoding, b.encoding);
-  swap(a.count, b.count);
-}
-
-PageEncodingStats::PageEncodingStats(const PageEncodingStats& other95) noexcept {
-  page_type = other95.page_type;
-  encoding = other95.encoding;
-  count = other95.count;
-}
-PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other96) noexcept {
-  page_type = other96.page_type;
-  encoding = other96.encoding;
-  count = other96.count;
-  return *this;
-}
-void PageEncodingStats::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "PageEncodingStats(";
-  out << "page_type=" << to_string(page_type);
-  out << ", " << "encoding=" << to_string(encoding);
-  out << ", " << "count=" << to_string(count);
-  out << ")";
-}
-
-
-ColumnMetaData::~ColumnMetaData() noexcept {
-}
-
-ColumnMetaData::ColumnMetaData() noexcept
-   : type(static_cast<Type::type>(0)),
-     codec(static_cast<CompressionCodec::type>(0)),
-     num_values(0),
-     total_uncompressed_size(0),
-     total_compressed_size(0),
-     data_page_offset(0),
-     index_page_offset(0),
-     dictionary_page_offset(0),
-     bloom_filter_offset(0),
-     bloom_filter_length(0) {
-}
-
-void ColumnMetaData::__set_type(const Type::type val) {
-  this->type = val;
-}
-
-void ColumnMetaData::__set_encodings(const duckdb::vector<Encoding::type> & val) {
-  this->encodings = val;
-}
-
-void ColumnMetaData::__set_path_in_schema(const duckdb::vector<std::string> & val) {
-  this->path_in_schema = val;
-}
-
-void ColumnMetaData::__set_codec(const CompressionCodec::type val) {
-  this->codec = val;
-}
-
-void ColumnMetaData::__set_num_values(const int64_t val) {
-  this->num_values = val;
-}
-
-void ColumnMetaData::__set_total_uncompressed_size(const int64_t val) {
-  this->total_uncompressed_size = val;
-}
-
-void ColumnMetaData::__set_total_compressed_size(const int64_t val) {
-  this->total_compressed_size = val;
-}
-
-void ColumnMetaData::__set_key_value_metadata(const duckdb::vector<KeyValue> & val) {
-  this->key_value_metadata = val;
-__isset.key_value_metadata = true;
-}
-
-void ColumnMetaData::__set_data_page_offset(const int64_t val) {
-  this->data_page_offset = val;
-}
-
-void ColumnMetaData::__set_index_page_offset(const int64_t val) {
-  this->index_page_offset = val;
-__isset.index_page_offset = true;
-}
-
-void ColumnMetaData::__set_dictionary_page_offset(const int64_t val) {
-  this->dictionary_page_offset = val;
-__isset.dictionary_page_offset = true;
-}
-
-void ColumnMetaData::__set_statistics(const Statistics& val) {
-  this->statistics = val;
-__isset.statistics = true;
-}
-
-void ColumnMetaData::__set_encoding_stats(const duckdb::vector<PageEncodingStats> & val) {
-  this->encoding_stats = val;
-__isset.encoding_stats = true;
-}
-
-void ColumnMetaData::__set_bloom_filter_offset(const int64_t val) {
-  this->bloom_filter_offset = val;
-__isset.bloom_filter_offset = true;
-}
-
-void ColumnMetaData::__set_bloom_filter_length(const int32_t val) {
-  this->bloom_filter_length = val;
-__isset.bloom_filter_length = true;
-}
-
-void ColumnMetaData::__set_size_statistics(const SizeStatistics& val) {
-  this->size_statistics = val;
-__isset.size_statistics = true;
-}
-std::ostream& operator<<(std::ostream& out, const ColumnMetaData& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_type = false;
-  bool isset_encodings = false;
-  bool isset_path_in_schema = false;
-  bool isset_codec = false;
-  bool isset_num_values = false;
-  bool isset_total_uncompressed_size = false;
-  bool isset_total_compressed_size = false;
-  bool isset_data_page_offset = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast97;
-          xfer += iprot->readI32(ecast97);
-          this->type = static_cast<Type::type>(ecast97);
-          isset_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->encodings.clear();
-            uint32_t _size98;
-            ::apache::thrift::protocol::TType _etype101;
-            xfer += iprot->readListBegin(_etype101, _size98);
-            this->encodings.resize(_size98);
-            uint32_t _i102;
-            for (_i102 = 0; _i102 < _size98; ++_i102)
-            {
-              int32_t ecast103;
-              xfer += iprot->readI32(ecast103);
-              this->encodings[_i102] = static_cast<Encoding::type>(ecast103);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_encodings = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->path_in_schema.clear();
-            uint32_t _size104;
-            ::apache::thrift::protocol::TType _etype107;
-            xfer += iprot->readListBegin(_etype107, _size104);
-            this->path_in_schema.resize(_size104);
-            uint32_t _i108;
-            for (_i108 = 0; _i108 < _size104; ++_i108)
-            {
-              xfer += iprot->readString(this->path_in_schema[_i108]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_path_in_schema = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast109;
-          xfer += iprot->readI32(ecast109);
-          this->codec = static_cast<CompressionCodec::type>(ecast109);
-          isset_codec = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_uncompressed_size);
-          isset_total_uncompressed_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_compressed_size);
-          isset_total_compressed_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->key_value_metadata.clear();
-            uint32_t _size110;
-            ::apache::thrift::protocol::TType _etype113;
-            xfer += iprot->readListBegin(_etype113, _size110);
-            this->key_value_metadata.resize(_size110);
-            uint32_t _i114;
-            for (_i114 = 0; _i114 < _size110; ++_i114)
-            {
-              xfer += this->key_value_metadata[_i114].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.key_value_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 9:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->data_page_offset);
-          isset_data_page_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 10:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->index_page_offset);
-          this->__isset.index_page_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 11:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->dictionary_page_offset);
-          this->__isset.dictionary_page_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 12:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->statistics.read(iprot);
-          this->__isset.statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 13:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->encoding_stats.clear();
-            uint32_t _size115;
-            ::apache::thrift::protocol::TType _etype118;
-            xfer += iprot->readListBegin(_etype118, _size115);
-            this->encoding_stats.resize(_size115);
-            uint32_t _i119;
-            for (_i119 = 0; _i119 < _size115; ++_i119)
-            {
-              xfer += this->encoding_stats[_i119].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.encoding_stats = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 14:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->bloom_filter_offset);
-          this->__isset.bloom_filter_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 15:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->bloom_filter_length);
-          this->__isset.bloom_filter_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 16:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->size_statistics.read(iprot);
-          this->__isset.size_statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_type)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encodings)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_path_in_schema)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_codec)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_total_uncompressed_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_total_compressed_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_data_page_offset)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("ColumnMetaData");
-
-  xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->type));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("encodings", ::apache::thrift::protocol::T_LIST, 2);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->encodings.size()));
-    duckdb::vector<Encoding::type> ::const_iterator _iter120;
-    for (_iter120 = this->encodings.begin(); _iter120 != this->encodings.end(); ++_iter120)
-    {
-      xfer += oprot->writeI32(static_cast<int32_t>((*_iter120)));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 3);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    duckdb::vector<std::string> ::const_iterator _iter121;
-    for (_iter121 = this->path_in_schema.begin(); _iter121 != this->path_in_schema.end(); ++_iter121)
-    {
-      xfer += oprot->writeString((*_iter121));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("codec", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->codec));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I64, 5);
-  xfer += oprot->writeI64(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("total_uncompressed_size", ::apache::thrift::protocol::T_I64, 6);
-  xfer += oprot->writeI64(this->total_uncompressed_size);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("total_compressed_size", ::apache::thrift::protocol::T_I64, 7);
-  xfer += oprot->writeI64(this->total_compressed_size);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_value_metadata) {
-    xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 8);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      duckdb::vector<KeyValue> ::const_iterator _iter122;
-      for (_iter122 = this->key_value_metadata.begin(); _iter122 != this->key_value_metadata.end(); ++_iter122)
-      {
-        xfer += (*_iter122).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldBegin("data_page_offset", ::apache::thrift::protocol::T_I64, 9);
-  xfer += oprot->writeI64(this->data_page_offset);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.index_page_offset) {
-    xfer += oprot->writeFieldBegin("index_page_offset", ::apache::thrift::protocol::T_I64, 10);
-    xfer += oprot->writeI64(this->index_page_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.dictionary_page_offset) {
-    xfer += oprot->writeFieldBegin("dictionary_page_offset", ::apache::thrift::protocol::T_I64, 11);
-    xfer += oprot->writeI64(this->dictionary_page_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.statistics) {
-    xfer += oprot->writeFieldBegin("statistics", ::apache::thrift::protocol::T_STRUCT, 12);
-    xfer += this->statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.encoding_stats) {
-    xfer += oprot->writeFieldBegin("encoding_stats", ::apache::thrift::protocol::T_LIST, 13);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->encoding_stats.size()));
-      duckdb::vector<PageEncodingStats> ::const_iterator _iter123;
-      for (_iter123 = this->encoding_stats.begin(); _iter123 != this->encoding_stats.end(); ++_iter123)
-      {
-        xfer += (*_iter123).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.bloom_filter_offset) {
-    xfer += oprot->writeFieldBegin("bloom_filter_offset", ::apache::thrift::protocol::T_I64, 14);
-    xfer += oprot->writeI64(this->bloom_filter_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.bloom_filter_length) {
-    xfer += oprot->writeFieldBegin("bloom_filter_length", ::apache::thrift::protocol::T_I32, 15);
-    xfer += oprot->writeI32(this->bloom_filter_length);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.size_statistics) {
-    xfer += oprot->writeFieldBegin("size_statistics", ::apache::thrift::protocol::T_STRUCT, 16);
-    xfer += this->size_statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnMetaData &a, ColumnMetaData &b) {
-  using ::std::swap;
-  swap(a.type, b.type);
-  swap(a.encodings, b.encodings);
-  swap(a.path_in_schema, b.path_in_schema);
-  swap(a.codec, b.codec);
-  swap(a.num_values, b.num_values);
-  swap(a.total_uncompressed_size, b.total_uncompressed_size);
-  swap(a.total_compressed_size, b.total_compressed_size);
-  swap(a.key_value_metadata, b.key_value_metadata);
-  swap(a.data_page_offset, b.data_page_offset);
-  swap(a.index_page_offset, b.index_page_offset);
-  swap(a.dictionary_page_offset, b.dictionary_page_offset);
-  swap(a.statistics, b.statistics);
-  swap(a.encoding_stats, b.encoding_stats);
-  swap(a.bloom_filter_offset, b.bloom_filter_offset);
-  swap(a.bloom_filter_length, b.bloom_filter_length);
-  swap(a.size_statistics, b.size_statistics);
-  swap(a.__isset, b.__isset);
-}
-
-ColumnMetaData::ColumnMetaData(const ColumnMetaData& other124) {
-  type = other124.type;
-  encodings = other124.encodings;
-  path_in_schema = other124.path_in_schema;
-  codec = other124.codec;
-  num_values = other124.num_values;
-  total_uncompressed_size = other124.total_uncompressed_size;
-  total_compressed_size = other124.total_compressed_size;
-  key_value_metadata = other124.key_value_metadata;
-  data_page_offset = other124.data_page_offset;
-  index_page_offset = other124.index_page_offset;
-  dictionary_page_offset = other124.dictionary_page_offset;
-  statistics = other124.statistics;
-  encoding_stats = other124.encoding_stats;
-  bloom_filter_offset = other124.bloom_filter_offset;
-  bloom_filter_length = other124.bloom_filter_length;
-  size_statistics = other124.size_statistics;
-  __isset = other124.__isset;
-}
-ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other125) {
-  type = other125.type;
-  encodings = other125.encodings;
-  path_in_schema = other125.path_in_schema;
-  codec = other125.codec;
-  num_values = other125.num_values;
-  total_uncompressed_size = other125.total_uncompressed_size;
-  total_compressed_size = other125.total_compressed_size;
-  key_value_metadata = other125.key_value_metadata;
-  data_page_offset = other125.data_page_offset;
-  index_page_offset = other125.index_page_offset;
-  dictionary_page_offset = other125.dictionary_page_offset;
-  statistics = other125.statistics;
-  encoding_stats = other125.encoding_stats;
-  bloom_filter_offset = other125.bloom_filter_offset;
-  bloom_filter_length = other125.bloom_filter_length;
-  size_statistics = other125.size_statistics;
-  __isset = other125.__isset;
-  return *this;
-}
-void ColumnMetaData::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "ColumnMetaData(";
-  out << "type=" << to_string(type);
-  out << ", " << "encodings=" << to_string(encodings);
-  out << ", " << "path_in_schema=" << to_string(path_in_schema);
-  out << ", " << "codec=" << to_string(codec);
-  out << ", " << "num_values=" << to_string(num_values);
-  out << ", " << "total_uncompressed_size=" << to_string(total_uncompressed_size);
-  out << ", " << "total_compressed_size=" << to_string(total_compressed_size);
-  out << ", " << "key_value_metadata="; (__isset.key_value_metadata ? (out << to_string(key_value_metadata)) : (out << "<null>"));
-  out << ", " << "data_page_offset=" << to_string(data_page_offset);
-  out << ", " << "index_page_offset="; (__isset.index_page_offset ? (out << to_string(index_page_offset)) : (out << "<null>"));
-  out << ", " << "dictionary_page_offset="; (__isset.dictionary_page_offset ? (out << to_string(dictionary_page_offset)) : (out << "<null>"));
-  out << ", " << "statistics="; (__isset.statistics ? (out << to_string(statistics)) : (out << "<null>"));
-  out << ", " << "encoding_stats="; (__isset.encoding_stats ? (out << to_string(encoding_stats)) : (out << "<null>"));
-  out << ", " << "bloom_filter_offset="; (__isset.bloom_filter_offset ? (out << to_string(bloom_filter_offset)) : (out << "<null>"));
-  out << ", " << "bloom_filter_length="; (__isset.bloom_filter_length ? (out << to_string(bloom_filter_length)) : (out << "<null>"));
-  out << ", " << "size_statistics="; (__isset.size_statistics ? (out << to_string(size_statistics)) : (out << "<null>"));
-  out << ")";
-}
-
-
-EncryptionWithFooterKey::~EncryptionWithFooterKey() noexcept {
-}
-
-EncryptionWithFooterKey::EncryptionWithFooterKey() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const EncryptionWithFooterKey& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t EncryptionWithFooterKey::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t EncryptionWithFooterKey::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("EncryptionWithFooterKey");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other126) noexcept {
-  (void) other126;
-}
-EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other127) noexcept {
-  (void) other127;
-  return *this;
-}
-void EncryptionWithFooterKey::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "EncryptionWithFooterKey(";
-  out << ")";
-}
-
-
-EncryptionWithColumnKey::~EncryptionWithColumnKey() noexcept {
-}
-
-EncryptionWithColumnKey::EncryptionWithColumnKey() noexcept
-   : key_metadata() {
-}
-
-void EncryptionWithColumnKey::__set_path_in_schema(const duckdb::vector<std::string> & val) {
-  this->path_in_schema = val;
-}
-
-void EncryptionWithColumnKey::__set_key_metadata(const std::string& val) {
-  this->key_metadata = val;
-__isset.key_metadata = true;
-}
-std::ostream& operator<<(std::ostream& out, const EncryptionWithColumnKey& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t EncryptionWithColumnKey::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_path_in_schema = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->path_in_schema.clear();
-            uint32_t _size128;
-            ::apache::thrift::protocol::TType _etype131;
-            xfer += iprot->readListBegin(_etype131, _size128);
-            this->path_in_schema.resize(_size128);
-            uint32_t _i132;
-            for (_i132 = 0; _i132 < _size128; ++_i132)
-            {
-              xfer += iprot->readString(this->path_in_schema[_i132]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_path_in_schema = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->key_metadata);
-          this->__isset.key_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_path_in_schema)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t EncryptionWithColumnKey::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("EncryptionWithColumnKey");
-
-  xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 1);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    duckdb::vector<std::string> ::const_iterator _iter133;
-    for (_iter133 = this->path_in_schema.begin(); _iter133 != this->path_in_schema.end(); ++_iter133)
-    {
-      xfer += oprot->writeString((*_iter133));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_metadata) {
-    xfer += oprot->writeFieldBegin("key_metadata", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->key_metadata);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b) {
-  using ::std::swap;
-  swap(a.path_in_schema, b.path_in_schema);
-  swap(a.key_metadata, b.key_metadata);
-  swap(a.__isset, b.__isset);
-}
-
-EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other134) {
-  path_in_schema = other134.path_in_schema;
-  key_metadata = other134.key_metadata;
-  __isset = other134.__isset;
-}
-EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other135) {
-  path_in_schema = other135.path_in_schema;
-  key_metadata = other135.key_metadata;
-  __isset = other135.__isset;
-  return *this;
-}
-void EncryptionWithColumnKey::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "EncryptionWithColumnKey(";
-  out << "path_in_schema=" << to_string(path_in_schema);
-  out << ", " << "key_metadata="; (__isset.key_metadata ? (out << to_string(key_metadata)) : (out << "<null>"));
-  out << ")";
-}
-
-
-ColumnCryptoMetaData::~ColumnCryptoMetaData() noexcept {
-}
-
-ColumnCryptoMetaData::ColumnCryptoMetaData() noexcept {
-}
-
-void ColumnCryptoMetaData::__set_ENCRYPTION_WITH_FOOTER_KEY(const EncryptionWithFooterKey& val) {
-  this->ENCRYPTION_WITH_FOOTER_KEY = val;
-__isset.ENCRYPTION_WITH_FOOTER_KEY = true;
-}
-
-void ColumnCryptoMetaData::__set_ENCRYPTION_WITH_COLUMN_KEY(const EncryptionWithColumnKey& val) {
-  this->ENCRYPTION_WITH_COLUMN_KEY = val;
-__isset.ENCRYPTION_WITH_COLUMN_KEY = true;
-}
-std::ostream& operator<<(std::ostream& out, const ColumnCryptoMetaData& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t ColumnCryptoMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ENCRYPTION_WITH_FOOTER_KEY.read(iprot);
-          this->__isset.ENCRYPTION_WITH_FOOTER_KEY = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ENCRYPTION_WITH_COLUMN_KEY.read(iprot);
-          this->__isset.ENCRYPTION_WITH_COLUMN_KEY = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t ColumnCryptoMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("ColumnCryptoMetaData");
-
-  if (this->__isset.ENCRYPTION_WITH_FOOTER_KEY) {
-    xfer += oprot->writeFieldBegin("ENCRYPTION_WITH_FOOTER_KEY", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->ENCRYPTION_WITH_FOOTER_KEY.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.ENCRYPTION_WITH_COLUMN_KEY) {
-    xfer += oprot->writeFieldBegin("ENCRYPTION_WITH_COLUMN_KEY", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->ENCRYPTION_WITH_COLUMN_KEY.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b) {
-  using ::std::swap;
-  swap(a.ENCRYPTION_WITH_FOOTER_KEY, b.ENCRYPTION_WITH_FOOTER_KEY);
-  swap(a.ENCRYPTION_WITH_COLUMN_KEY, b.ENCRYPTION_WITH_COLUMN_KEY);
-  swap(a.__isset, b.__isset);
-}
-
-ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other136) {
-  ENCRYPTION_WITH_FOOTER_KEY = other136.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other136.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other136.__isset;
-}
-ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other137) {
-  ENCRYPTION_WITH_FOOTER_KEY = other137.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other137.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other137.__isset;
-  return *this;
-}
-void ColumnCryptoMetaData::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "ColumnCryptoMetaData(";
-  out << "ENCRYPTION_WITH_FOOTER_KEY="; (__isset.ENCRYPTION_WITH_FOOTER_KEY ? (out << to_string(ENCRYPTION_WITH_FOOTER_KEY)) : (out << "<null>"));
-  out << ", " << "ENCRYPTION_WITH_COLUMN_KEY="; (__isset.ENCRYPTION_WITH_COLUMN_KEY ? (out << to_string(ENCRYPTION_WITH_COLUMN_KEY)) : (out << "<null>"));
-  out << ")";
-}
-
-
-ColumnChunk::~ColumnChunk() noexcept {
-}
-
-ColumnChunk::ColumnChunk() noexcept
-   : file_path(),
-     file_offset(0LL),
-     offset_index_offset(0),
-     offset_index_length(0),
-     column_index_offset(0),
-     column_index_length(0),
-     encrypted_column_metadata() {
-}
-
-void ColumnChunk::__set_file_path(const std::string& val) {
-  this->file_path = val;
-__isset.file_path = true;
-}
-
-void ColumnChunk::__set_file_offset(const int64_t val) {
-  this->file_offset = val;
-}
-
-void ColumnChunk::__set_meta_data(const ColumnMetaData& val) {
-  this->meta_data = val;
-__isset.meta_data = true;
-}
-
-void ColumnChunk::__set_offset_index_offset(const int64_t val) {
-  this->offset_index_offset = val;
-__isset.offset_index_offset = true;
-}
-
-void ColumnChunk::__set_offset_index_length(const int32_t val) {
-  this->offset_index_length = val;
-__isset.offset_index_length = true;
-}
-
-void ColumnChunk::__set_column_index_offset(const int64_t val) {
-  this->column_index_offset = val;
-__isset.column_index_offset = true;
-}
-
-void ColumnChunk::__set_column_index_length(const int32_t val) {
-  this->column_index_length = val;
-__isset.column_index_length = true;
-}
-
-void ColumnChunk::__set_crypto_metadata(const ColumnCryptoMetaData& val) {
-  this->crypto_metadata = val;
-__isset.crypto_metadata = true;
-}
-
-void ColumnChunk::__set_encrypted_column_metadata(const std::string& val) {
-  this->encrypted_column_metadata = val;
-__isset.encrypted_column_metadata = true;
-}
-std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t ColumnChunk::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_file_offset = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->file_path);
-          this->__isset.file_path = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->file_offset);
-          isset_file_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->meta_data.read(iprot);
-          this->__isset.meta_data = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->offset_index_offset);
-          this->__isset.offset_index_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->offset_index_length);
-          this->__isset.offset_index_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->column_index_offset);
-          this->__isset.column_index_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->column_index_length);
-          this->__isset.column_index_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->crypto_metadata.read(iprot);
-          this->__isset.crypto_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 9:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->encrypted_column_metadata);
-          this->__isset.encrypted_column_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_file_offset)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t ColumnChunk::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("ColumnChunk");
-
-  if (this->__isset.file_path) {
-    xfer += oprot->writeFieldBegin("file_path", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeString(this->file_path);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldBegin("file_offset", ::apache::thrift::protocol::T_I64, 2);
-  xfer += oprot->writeI64(this->file_offset);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.meta_data) {
-    xfer += oprot->writeFieldBegin("meta_data", ::apache::thrift::protocol::T_STRUCT, 3);
-    xfer += this->meta_data.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.offset_index_offset) {
-    xfer += oprot->writeFieldBegin("offset_index_offset", ::apache::thrift::protocol::T_I64, 4);
-    xfer += oprot->writeI64(this->offset_index_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.offset_index_length) {
-    xfer += oprot->writeFieldBegin("offset_index_length", ::apache::thrift::protocol::T_I32, 5);
-    xfer += oprot->writeI32(this->offset_index_length);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.column_index_offset) {
-    xfer += oprot->writeFieldBegin("column_index_offset", ::apache::thrift::protocol::T_I64, 6);
-    xfer += oprot->writeI64(this->column_index_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.column_index_length) {
-    xfer += oprot->writeFieldBegin("column_index_length", ::apache::thrift::protocol::T_I32, 7);
-    xfer += oprot->writeI32(this->column_index_length);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.crypto_metadata) {
-    xfer += oprot->writeFieldBegin("crypto_metadata", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->crypto_metadata.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.encrypted_column_metadata) {
-    xfer += oprot->writeFieldBegin("encrypted_column_metadata", ::apache::thrift::protocol::T_STRING, 9);
-    xfer += oprot->writeBinary(this->encrypted_column_metadata);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnChunk &a, ColumnChunk &b) {
-  using ::std::swap;
-  swap(a.file_path, b.file_path);
-  swap(a.file_offset, b.file_offset);
-  swap(a.meta_data, b.meta_data);
-  swap(a.offset_index_offset, b.offset_index_offset);
-  swap(a.offset_index_length, b.offset_index_length);
-  swap(a.column_index_offset, b.column_index_offset);
-  swap(a.column_index_length, b.column_index_length);
-  swap(a.crypto_metadata, b.crypto_metadata);
-  swap(a.encrypted_column_metadata, b.encrypted_column_metadata);
-  swap(a.__isset, b.__isset);
-}
-
-ColumnChunk::ColumnChunk(const ColumnChunk& other138) {
-  file_path = other138.file_path;
-  file_offset = other138.file_offset;
-  meta_data = other138.meta_data;
-  offset_index_offset = other138.offset_index_offset;
-  offset_index_length = other138.offset_index_length;
-  column_index_offset = other138.column_index_offset;
-  column_index_length = other138.column_index_length;
-  crypto_metadata = other138.crypto_metadata;
-  encrypted_column_metadata = other138.encrypted_column_metadata;
-  __isset = other138.__isset;
-}
-ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other139) {
-  file_path = other139.file_path;
-  file_offset = other139.file_offset;
-  meta_data = other139.meta_data;
-  offset_index_offset = other139.offset_index_offset;
-  offset_index_length = other139.offset_index_length;
-  column_index_offset = other139.column_index_offset;
-  column_index_length = other139.column_index_length;
-  crypto_metadata = other139.crypto_metadata;
-  encrypted_column_metadata = other139.encrypted_column_metadata;
-  __isset = other139.__isset;
-  return *this;
-}
-void ColumnChunk::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "ColumnChunk(";
-  out << "file_path="; (__isset.file_path ? (out << to_string(file_path)) : (out << "<null>"));
-  out << ", " << "file_offset=" << to_string(file_offset);
-  out << ", " << "meta_data="; (__isset.meta_data ? (out << to_string(meta_data)) : (out << "<null>"));
-  out << ", " << "offset_index_offset="; (__isset.offset_index_offset ? (out << to_string(offset_index_offset)) : (out << "<null>"));
-  out << ", " << "offset_index_length="; (__isset.offset_index_length ? (out << to_string(offset_index_length)) : (out << "<null>"));
-  out << ", " << "column_index_offset="; (__isset.column_index_offset ? (out << to_string(column_index_offset)) : (out << "<null>"));
-  out << ", " << "column_index_length="; (__isset.column_index_length ? (out << to_string(column_index_length)) : (out << "<null>"));
-  out << ", " << "crypto_metadata="; (__isset.crypto_metadata ? (out << to_string(crypto_metadata)) : (out << "<null>"));
-  out << ", " << "encrypted_column_metadata="; (__isset.encrypted_column_metadata ? (out << to_string(encrypted_column_metadata)) : (out << "<null>"));
-  out << ")";
-}
-
-
-RowGroup::~RowGroup() noexcept {
-}
-
-RowGroup::RowGroup() noexcept
-   : total_byte_size(0),
-     num_rows(0),
-     file_offset(0),
-     total_compressed_size(0),
-     ordinal(0) {
-}
-
-void RowGroup::__set_columns(const duckdb::vector<ColumnChunk> & val) {
-  this->columns = val;
-}
-
-void RowGroup::__set_total_byte_size(const int64_t val) {
-  this->total_byte_size = val;
-}
-
-void RowGroup::__set_num_rows(const int64_t val) {
-  this->num_rows = val;
-}
-
-void RowGroup::__set_sorting_columns(const duckdb::vector<SortingColumn> & val) {
-  this->sorting_columns = val;
-__isset.sorting_columns = true;
-}
-
-void RowGroup::__set_file_offset(const int64_t val) {
-  this->file_offset = val;
-__isset.file_offset = true;
-}
-
-void RowGroup::__set_total_compressed_size(const int64_t val) {
-  this->total_compressed_size = val;
-__isset.total_compressed_size = true;
-}
-
-void RowGroup::__set_ordinal(const int16_t val) {
-  this->ordinal = val;
-__isset.ordinal = true;
-}
-std::ostream& operator<<(std::ostream& out, const RowGroup& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_columns = false;
-  bool isset_total_byte_size = false;
-  bool isset_num_rows = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->columns.clear();
-            uint32_t _size140;
-            ::apache::thrift::protocol::TType _etype143;
-            xfer += iprot->readListBegin(_etype143, _size140);
-            this->columns.resize(_size140);
-            uint32_t _i144;
-            for (_i144 = 0; _i144 < _size140; ++_i144)
-            {
-              xfer += this->columns[_i144].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_columns = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_byte_size);
-          isset_total_byte_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->sorting_columns.clear();
-            uint32_t _size145;
-            ::apache::thrift::protocol::TType _etype148;
-            xfer += iprot->readListBegin(_etype148, _size145);
-            this->sorting_columns.resize(_size145);
-            uint32_t _i149;
-            for (_i149 = 0; _i149 < _size145; ++_i149)
-            {
-              xfer += this->sorting_columns[_i149].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.sorting_columns = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->file_offset);
-          this->__isset.file_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_compressed_size);
-          this->__isset.total_compressed_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_I16) {
-          xfer += iprot->readI16(this->ordinal);
-          this->__isset.ordinal = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_columns)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_total_byte_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("RowGroup");
-
-  xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    duckdb::vector<ColumnChunk> ::const_iterator _iter150;
-    for (_iter150 = this->columns.begin(); _iter150 != this->columns.end(); ++_iter150)
-    {
-      xfer += (*_iter150).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("total_byte_size", ::apache::thrift::protocol::T_I64, 2);
-  xfer += oprot->writeI64(this->total_byte_size);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.sorting_columns) {
-    xfer += oprot->writeFieldBegin("sorting_columns", ::apache::thrift::protocol::T_LIST, 4);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sorting_columns.size()));
-      duckdb::vector<SortingColumn> ::const_iterator _iter151;
-      for (_iter151 = this->sorting_columns.begin(); _iter151 != this->sorting_columns.end(); ++_iter151)
-      {
-        xfer += (*_iter151).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.file_offset) {
-    xfer += oprot->writeFieldBegin("file_offset", ::apache::thrift::protocol::T_I64, 5);
-    xfer += oprot->writeI64(this->file_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.total_compressed_size) {
-    xfer += oprot->writeFieldBegin("total_compressed_size", ::apache::thrift::protocol::T_I64, 6);
-    xfer += oprot->writeI64(this->total_compressed_size);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.ordinal) {
-    xfer += oprot->writeFieldBegin("ordinal", ::apache::thrift::protocol::T_I16, 7);
-    xfer += oprot->writeI16(this->ordinal);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(RowGroup &a, RowGroup &b) {
-  using ::std::swap;
-  swap(a.columns, b.columns);
-  swap(a.total_byte_size, b.total_byte_size);
-  swap(a.num_rows, b.num_rows);
-  swap(a.sorting_columns, b.sorting_columns);
-  swap(a.file_offset, b.file_offset);
-  swap(a.total_compressed_size, b.total_compressed_size);
-  swap(a.ordinal, b.ordinal);
-  swap(a.__isset, b.__isset);
-}
-
-RowGroup::RowGroup(const RowGroup& other152) {
-  columns = other152.columns;
-  total_byte_size = other152.total_byte_size;
-  num_rows = other152.num_rows;
-  sorting_columns = other152.sorting_columns;
-  file_offset = other152.file_offset;
-  total_compressed_size = other152.total_compressed_size;
-  ordinal = other152.ordinal;
-  __isset = other152.__isset;
-}
-RowGroup& RowGroup::operator=(const RowGroup& other153) {
-  columns = other153.columns;
-  total_byte_size = other153.total_byte_size;
-  num_rows = other153.num_rows;
-  sorting_columns = other153.sorting_columns;
-  file_offset = other153.file_offset;
-  total_compressed_size = other153.total_compressed_size;
-  ordinal = other153.ordinal;
-  __isset = other153.__isset;
-  return *this;
-}
-void RowGroup::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "RowGroup(";
-  out << "columns=" << to_string(columns);
-  out << ", " << "total_byte_size=" << to_string(total_byte_size);
-  out << ", " << "num_rows=" << to_string(num_rows);
-  out << ", " << "sorting_columns="; (__isset.sorting_columns ? (out << to_string(sorting_columns)) : (out << "<null>"));
-  out << ", " << "file_offset="; (__isset.file_offset ? (out << to_string(file_offset)) : (out << "<null>"));
-  out << ", " << "total_compressed_size="; (__isset.total_compressed_size ? (out << to_string(total_compressed_size)) : (out << "<null>"));
-  out << ", " << "ordinal="; (__isset.ordinal ? (out << to_string(ordinal)) : (out << "<null>"));
-  out << ")";
-}
-
-
-TypeDefinedOrder::~TypeDefinedOrder() noexcept {
-}
-
-TypeDefinedOrder::TypeDefinedOrder() noexcept {
-}
-std::ostream& operator<<(std::ostream& out, const TypeDefinedOrder& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t TypeDefinedOrder::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t TypeDefinedOrder::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("TypeDefinedOrder");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(TypeDefinedOrder &a, TypeDefinedOrder &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other154) noexcept {
-  (void) other154;
-}
-TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other155) noexcept {
-  (void) other155;
-  return *this;
-}
-void TypeDefinedOrder::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "TypeDefinedOrder(";
-  out << ")";
-}
-
-
-ColumnOrder::~ColumnOrder() noexcept {
-}
-
-ColumnOrder::ColumnOrder() noexcept {
-}
-
-void ColumnOrder::__set_TYPE_ORDER(const TypeDefinedOrder& val) {
-  this->TYPE_ORDER = val;
-__isset.TYPE_ORDER = true;
-}
-std::ostream& operator<<(std::ostream& out, const ColumnOrder& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t ColumnOrder::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->TYPE_ORDER.read(iprot);
-          this->__isset.TYPE_ORDER = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t ColumnOrder::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("ColumnOrder");
-
-  if (this->__isset.TYPE_ORDER) {
-    xfer += oprot->writeFieldBegin("TYPE_ORDER", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->TYPE_ORDER.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnOrder &a, ColumnOrder &b) {
-  using ::std::swap;
-  swap(a.TYPE_ORDER, b.TYPE_ORDER);
-  swap(a.__isset, b.__isset);
-}
-
-ColumnOrder::ColumnOrder(const ColumnOrder& other156) noexcept {
-  TYPE_ORDER = other156.TYPE_ORDER;
-  __isset = other156.__isset;
-}
-ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other157) noexcept {
-  TYPE_ORDER = other157.TYPE_ORDER;
-  __isset = other157.__isset;
-  return *this;
-}
-void ColumnOrder::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "ColumnOrder(";
-  out << "TYPE_ORDER="; (__isset.TYPE_ORDER ? (out << to_string(TYPE_ORDER)) : (out << "<null>"));
-  out << ")";
-}
-
-
-PageLocation::~PageLocation() noexcept {
-}
-
-PageLocation::PageLocation() noexcept
-   : offset(0),
-     compressed_page_size(0),
-     first_row_index(0) {
-}
-
-void PageLocation::__set_offset(const int64_t val) {
-  this->offset = val;
-}
-
-void PageLocation::__set_compressed_page_size(const int32_t val) {
-  this->compressed_page_size = val;
-}
-
-void PageLocation::__set_first_row_index(const int64_t val) {
-  this->first_row_index = val;
-}
-std::ostream& operator<<(std::ostream& out, const PageLocation& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t PageLocation::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_offset = false;
-  bool isset_compressed_page_size = false;
-  bool isset_first_row_index = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->offset);
-          isset_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->compressed_page_size);
-          isset_compressed_page_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->first_row_index);
-          isset_first_row_index = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_offset)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_compressed_page_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_first_row_index)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t PageLocation::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("PageLocation");
-
-  xfer += oprot->writeFieldBegin("offset", ::apache::thrift::protocol::T_I64, 1);
-  xfer += oprot->writeI64(this->offset);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("compressed_page_size", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->compressed_page_size);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("first_row_index", ::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->first_row_index);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(PageLocation &a, PageLocation &b) {
-  using ::std::swap;
-  swap(a.offset, b.offset);
-  swap(a.compressed_page_size, b.compressed_page_size);
-  swap(a.first_row_index, b.first_row_index);
-}
-
-PageLocation::PageLocation(const PageLocation& other158) noexcept {
-  offset = other158.offset;
-  compressed_page_size = other158.compressed_page_size;
-  first_row_index = other158.first_row_index;
-}
-PageLocation& PageLocation::operator=(const PageLocation& other159) noexcept {
-  offset = other159.offset;
-  compressed_page_size = other159.compressed_page_size;
-  first_row_index = other159.first_row_index;
-  return *this;
-}
-void PageLocation::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "PageLocation(";
-  out << "offset=" << to_string(offset);
-  out << ", " << "compressed_page_size=" << to_string(compressed_page_size);
-  out << ", " << "first_row_index=" << to_string(first_row_index);
-  out << ")";
-}
-
-
-OffsetIndex::~OffsetIndex() noexcept {
-}
-
-OffsetIndex::OffsetIndex() noexcept {
-}
-
-void OffsetIndex::__set_page_locations(const duckdb::vector<PageLocation> & val) {
-  this->page_locations = val;
-}
-
-void OffsetIndex::__set_unencoded_byte_array_data_bytes(const duckdb::vector<int64_t> & val) {
-  this->unencoded_byte_array_data_bytes = val;
-__isset.unencoded_byte_array_data_bytes = true;
-}
-std::ostream& operator<<(std::ostream& out, const OffsetIndex& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t OffsetIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_page_locations = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->page_locations.clear();
-            uint32_t _size160;
-            ::apache::thrift::protocol::TType _etype163;
-            xfer += iprot->readListBegin(_etype163, _size160);
-            this->page_locations.resize(_size160);
-            uint32_t _i164;
-            for (_i164 = 0; _i164 < _size160; ++_i164)
-            {
-              xfer += this->page_locations[_i164].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_page_locations = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->unencoded_byte_array_data_bytes.clear();
-            uint32_t _size165;
-            ::apache::thrift::protocol::TType _etype168;
-            xfer += iprot->readListBegin(_etype168, _size165);
-            this->unencoded_byte_array_data_bytes.resize(_size165);
-            uint32_t _i169;
-            for (_i169 = 0; _i169 < _size165; ++_i169)
-            {
-              xfer += iprot->readI64(this->unencoded_byte_array_data_bytes[_i169]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.unencoded_byte_array_data_bytes = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_page_locations)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t OffsetIndex::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("OffsetIndex");
-
-  xfer += oprot->writeFieldBegin("page_locations", ::apache::thrift::protocol::T_LIST, 1);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->page_locations.size()));
-    duckdb::vector<PageLocation> ::const_iterator _iter170;
-    for (_iter170 = this->page_locations.begin(); _iter170 != this->page_locations.end(); ++_iter170)
-    {
-      xfer += (*_iter170).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.unencoded_byte_array_data_bytes) {
-    xfer += oprot->writeFieldBegin("unencoded_byte_array_data_bytes", ::apache::thrift::protocol::T_LIST, 2);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->unencoded_byte_array_data_bytes.size()));
-      duckdb::vector<int64_t> ::const_iterator _iter171;
-      for (_iter171 = this->unencoded_byte_array_data_bytes.begin(); _iter171 != this->unencoded_byte_array_data_bytes.end(); ++_iter171)
-      {
-        xfer += oprot->writeI64((*_iter171));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(OffsetIndex &a, OffsetIndex &b) {
-  using ::std::swap;
-  swap(a.page_locations, b.page_locations);
-  swap(a.unencoded_byte_array_data_bytes, b.unencoded_byte_array_data_bytes);
-  swap(a.__isset, b.__isset);
-}
-
-OffsetIndex::OffsetIndex(const OffsetIndex& other172) {
-  page_locations = other172.page_locations;
-  unencoded_byte_array_data_bytes = other172.unencoded_byte_array_data_bytes;
-  __isset = other172.__isset;
-}
-OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other173) {
-  page_locations = other173.page_locations;
-  unencoded_byte_array_data_bytes = other173.unencoded_byte_array_data_bytes;
-  __isset = other173.__isset;
-  return *this;
-}
-void OffsetIndex::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "OffsetIndex(";
-  out << "page_locations=" << to_string(page_locations);
-  out << ", " << "unencoded_byte_array_data_bytes="; (__isset.unencoded_byte_array_data_bytes ? (out << to_string(unencoded_byte_array_data_bytes)) : (out << "<null>"));
-  out << ")";
-}
-
-
-ColumnIndex::~ColumnIndex() noexcept {
-}
-
-ColumnIndex::ColumnIndex() noexcept
-   : boundary_order(static_cast<BoundaryOrder::type>(0)) {
-}
-
-void ColumnIndex::__set_null_pages(const duckdb::vector<bool> & val) {
-  this->null_pages = val;
-}
-
-void ColumnIndex::__set_min_values(const duckdb::vector<std::string> & val) {
-  this->min_values = val;
-}
-
-void ColumnIndex::__set_max_values(const duckdb::vector<std::string> & val) {
-  this->max_values = val;
-}
-
-void ColumnIndex::__set_boundary_order(const BoundaryOrder::type val) {
-  this->boundary_order = val;
-}
-
-void ColumnIndex::__set_null_counts(const duckdb::vector<int64_t> & val) {
-  this->null_counts = val;
-__isset.null_counts = true;
-}
-
-void ColumnIndex::__set_repetition_level_histograms(const duckdb::vector<int64_t> & val) {
-  this->repetition_level_histograms = val;
-__isset.repetition_level_histograms = true;
-}
-
-void ColumnIndex::__set_definition_level_histograms(const duckdb::vector<int64_t> & val) {
-  this->definition_level_histograms = val;
-__isset.definition_level_histograms = true;
-}
-std::ostream& operator<<(std::ostream& out, const ColumnIndex& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_null_pages = false;
-  bool isset_min_values = false;
-  bool isset_max_values = false;
-  bool isset_boundary_order = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->null_pages.clear();
-            uint32_t _size174;
-            ::apache::thrift::protocol::TType _etype177;
-            xfer += iprot->readListBegin(_etype177, _size174);
-            this->null_pages.resize(_size174);
-            uint32_t _i178;
-            for (_i178 = 0; _i178 < _size174; ++_i178)
-            {
-              xfer += iprot->readBool(this->null_pages[_i178]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_null_pages = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->min_values.clear();
-            uint32_t _size179;
-            ::apache::thrift::protocol::TType _etype182;
-            xfer += iprot->readListBegin(_etype182, _size179);
-            this->min_values.resize(_size179);
-            uint32_t _i183;
-            for (_i183 = 0; _i183 < _size179; ++_i183)
-            {
-              xfer += iprot->readBinary(this->min_values[_i183]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_min_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->max_values.clear();
-            uint32_t _size184;
-            ::apache::thrift::protocol::TType _etype187;
-            xfer += iprot->readListBegin(_etype187, _size184);
-            this->max_values.resize(_size184);
-            uint32_t _i188;
-            for (_i188 = 0; _i188 < _size184; ++_i188)
-            {
-              xfer += iprot->readBinary(this->max_values[_i188]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_max_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast189;
-          xfer += iprot->readI32(ecast189);
-          this->boundary_order = static_cast<BoundaryOrder::type>(ecast189);
-          isset_boundary_order = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->null_counts.clear();
-            uint32_t _size190;
-            ::apache::thrift::protocol::TType _etype193;
-            xfer += iprot->readListBegin(_etype193, _size190);
-            this->null_counts.resize(_size190);
-            uint32_t _i194;
-            for (_i194 = 0; _i194 < _size190; ++_i194)
-            {
-              xfer += iprot->readI64(this->null_counts[_i194]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.null_counts = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->repetition_level_histograms.clear();
-            uint32_t _size195;
-            ::apache::thrift::protocol::TType _etype198;
-            xfer += iprot->readListBegin(_etype198, _size195);
-            this->repetition_level_histograms.resize(_size195);
-            uint32_t _i199;
-            for (_i199 = 0; _i199 < _size195; ++_i199)
-            {
-              xfer += iprot->readI64(this->repetition_level_histograms[_i199]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.repetition_level_histograms = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->definition_level_histograms.clear();
-            uint32_t _size200;
-            ::apache::thrift::protocol::TType _etype203;
-            xfer += iprot->readListBegin(_etype203, _size200);
-            this->definition_level_histograms.resize(_size200);
-            uint32_t _i204;
-            for (_i204 = 0; _i204 < _size200; ++_i204)
-            {
-              xfer += iprot->readI64(this->definition_level_histograms[_i204]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.definition_level_histograms = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_null_pages)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_min_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_max_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_boundary_order)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("ColumnIndex");
-
-  xfer += oprot->writeFieldBegin("null_pages", ::apache::thrift::protocol::T_LIST, 1);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->null_pages.size()));
-    duckdb::vector<bool> ::const_iterator _iter205;
-    for (_iter205 = this->null_pages.begin(); _iter205 != this->null_pages.end(); ++_iter205)
-    {
-      xfer += oprot->writeBool((*_iter205));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("min_values", ::apache::thrift::protocol::T_LIST, 2);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->min_values.size()));
-    duckdb::vector<std::string> ::const_iterator _iter206;
-    for (_iter206 = this->min_values.begin(); _iter206 != this->min_values.end(); ++_iter206)
-    {
-      xfer += oprot->writeBinary((*_iter206));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("max_values", ::apache::thrift::protocol::T_LIST, 3);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->max_values.size()));
-    duckdb::vector<std::string> ::const_iterator _iter207;
-    for (_iter207 = this->max_values.begin(); _iter207 != this->max_values.end(); ++_iter207)
-    {
-      xfer += oprot->writeBinary((*_iter207));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("boundary_order", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32(static_cast<int32_t>(this->boundary_order));
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.null_counts) {
-    xfer += oprot->writeFieldBegin("null_counts", ::apache::thrift::protocol::T_LIST, 5);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->null_counts.size()));
-      duckdb::vector<int64_t> ::const_iterator _iter208;
-      for (_iter208 = this->null_counts.begin(); _iter208 != this->null_counts.end(); ++_iter208)
-      {
-        xfer += oprot->writeI64((*_iter208));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.repetition_level_histograms) {
-    xfer += oprot->writeFieldBegin("repetition_level_histograms", ::apache::thrift::protocol::T_LIST, 6);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->repetition_level_histograms.size()));
-      duckdb::vector<int64_t> ::const_iterator _iter209;
-      for (_iter209 = this->repetition_level_histograms.begin(); _iter209 != this->repetition_level_histograms.end(); ++_iter209)
-      {
-        xfer += oprot->writeI64((*_iter209));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.definition_level_histograms) {
-    xfer += oprot->writeFieldBegin("definition_level_histograms", ::apache::thrift::protocol::T_LIST, 7);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->definition_level_histograms.size()));
-      duckdb::vector<int64_t> ::const_iterator _iter210;
-      for (_iter210 = this->definition_level_histograms.begin(); _iter210 != this->definition_level_histograms.end(); ++_iter210)
-      {
-        xfer += oprot->writeI64((*_iter210));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnIndex &a, ColumnIndex &b) {
-  using ::std::swap;
-  swap(a.null_pages, b.null_pages);
-  swap(a.min_values, b.min_values);
-  swap(a.max_values, b.max_values);
-  swap(a.boundary_order, b.boundary_order);
-  swap(a.null_counts, b.null_counts);
-  swap(a.repetition_level_histograms, b.repetition_level_histograms);
-  swap(a.definition_level_histograms, b.definition_level_histograms);
-  swap(a.__isset, b.__isset);
-}
-
-ColumnIndex::ColumnIndex(const ColumnIndex& other211) {
-  null_pages = other211.null_pages;
-  min_values = other211.min_values;
-  max_values = other211.max_values;
-  boundary_order = other211.boundary_order;
-  null_counts = other211.null_counts;
-  repetition_level_histograms = other211.repetition_level_histograms;
-  definition_level_histograms = other211.definition_level_histograms;
-  __isset = other211.__isset;
-}
-ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other212) {
-  null_pages = other212.null_pages;
-  min_values = other212.min_values;
-  max_values = other212.max_values;
-  boundary_order = other212.boundary_order;
-  null_counts = other212.null_counts;
-  repetition_level_histograms = other212.repetition_level_histograms;
-  definition_level_histograms = other212.definition_level_histograms;
-  __isset = other212.__isset;
-  return *this;
-}
-void ColumnIndex::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "ColumnIndex(";
-  out << "null_pages=" << to_string(null_pages);
-  out << ", " << "min_values=" << to_string(min_values);
-  out << ", " << "max_values=" << to_string(max_values);
-  out << ", " << "boundary_order=" << to_string(boundary_order);
-  out << ", " << "null_counts="; (__isset.null_counts ? (out << to_string(null_counts)) : (out << "<null>"));
-  out << ", " << "repetition_level_histograms="; (__isset.repetition_level_histograms ? (out << to_string(repetition_level_histograms)) : (out << "<null>"));
-  out << ", " << "definition_level_histograms="; (__isset.definition_level_histograms ? (out << to_string(definition_level_histograms)) : (out << "<null>"));
-  out << ")";
-}
-
-
-AesGcmV1::~AesGcmV1() noexcept {
-}
-
-AesGcmV1::AesGcmV1() noexcept
-   : aad_prefix(),
-     aad_file_unique(),
-     supply_aad_prefix(0) {
-}
-
-void AesGcmV1::__set_aad_prefix(const std::string& val) {
-  this->aad_prefix = val;
-__isset.aad_prefix = true;
-}
-
-void AesGcmV1::__set_aad_file_unique(const std::string& val) {
-  this->aad_file_unique = val;
-__isset.aad_file_unique = true;
-}
-
-void AesGcmV1::__set_supply_aad_prefix(const bool val) {
-  this->supply_aad_prefix = val;
-__isset.supply_aad_prefix = true;
-}
-std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t AesGcmV1::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->aad_prefix);
-          this->__isset.aad_prefix = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->aad_file_unique);
-          this->__isset.aad_file_unique = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->supply_aad_prefix);
-          this->__isset.supply_aad_prefix = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t AesGcmV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("AesGcmV1");
-
-  if (this->__isset.aad_prefix) {
-    xfer += oprot->writeFieldBegin("aad_prefix", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeBinary(this->aad_prefix);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.aad_file_unique) {
-    xfer += oprot->writeFieldBegin("aad_file_unique", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->aad_file_unique);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.supply_aad_prefix) {
-    xfer += oprot->writeFieldBegin("supply_aad_prefix", ::apache::thrift::protocol::T_BOOL, 3);
-    xfer += oprot->writeBool(this->supply_aad_prefix);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(AesGcmV1 &a, AesGcmV1 &b) {
-  using ::std::swap;
-  swap(a.aad_prefix, b.aad_prefix);
-  swap(a.aad_file_unique, b.aad_file_unique);
-  swap(a.supply_aad_prefix, b.supply_aad_prefix);
-  swap(a.__isset, b.__isset);
-}
-
-AesGcmV1::AesGcmV1(const AesGcmV1& other213) {
-  aad_prefix = other213.aad_prefix;
-  aad_file_unique = other213.aad_file_unique;
-  supply_aad_prefix = other213.supply_aad_prefix;
-  __isset = other213.__isset;
-}
-AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other214) {
-  aad_prefix = other214.aad_prefix;
-  aad_file_unique = other214.aad_file_unique;
-  supply_aad_prefix = other214.supply_aad_prefix;
-  __isset = other214.__isset;
-  return *this;
-}
-void AesGcmV1::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "AesGcmV1(";
-  out << "aad_prefix="; (__isset.aad_prefix ? (out << to_string(aad_prefix)) : (out << "<null>"));
-  out << ", " << "aad_file_unique="; (__isset.aad_file_unique ? (out << to_string(aad_file_unique)) : (out << "<null>"));
-  out << ", " << "supply_aad_prefix="; (__isset.supply_aad_prefix ? (out << to_string(supply_aad_prefix)) : (out << "<null>"));
-  out << ")";
-}
-
-
-AesGcmCtrV1::~AesGcmCtrV1() noexcept {
-}
-
-AesGcmCtrV1::AesGcmCtrV1() noexcept
-   : aad_prefix(),
-     aad_file_unique(),
-     supply_aad_prefix(0) {
-}
-
-void AesGcmCtrV1::__set_aad_prefix(const std::string& val) {
-  this->aad_prefix = val;
-__isset.aad_prefix = true;
-}
-
-void AesGcmCtrV1::__set_aad_file_unique(const std::string& val) {
-  this->aad_file_unique = val;
-__isset.aad_file_unique = true;
-}
-
-void AesGcmCtrV1::__set_supply_aad_prefix(const bool val) {
-  this->supply_aad_prefix = val;
-__isset.supply_aad_prefix = true;
-}
-std::ostream& operator<<(std::ostream& out, const AesGcmCtrV1& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t AesGcmCtrV1::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->aad_prefix);
-          this->__isset.aad_prefix = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->aad_file_unique);
-          this->__isset.aad_file_unique = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->supply_aad_prefix);
-          this->__isset.supply_aad_prefix = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t AesGcmCtrV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("AesGcmCtrV1");
-
-  if (this->__isset.aad_prefix) {
-    xfer += oprot->writeFieldBegin("aad_prefix", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeBinary(this->aad_prefix);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.aad_file_unique) {
-    xfer += oprot->writeFieldBegin("aad_file_unique", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->aad_file_unique);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.supply_aad_prefix) {
-    xfer += oprot->writeFieldBegin("supply_aad_prefix", ::apache::thrift::protocol::T_BOOL, 3);
-    xfer += oprot->writeBool(this->supply_aad_prefix);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b) {
-  using ::std::swap;
-  swap(a.aad_prefix, b.aad_prefix);
-  swap(a.aad_file_unique, b.aad_file_unique);
-  swap(a.supply_aad_prefix, b.supply_aad_prefix);
-  swap(a.__isset, b.__isset);
-}
-
-AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other215) {
-  aad_prefix = other215.aad_prefix;
-  aad_file_unique = other215.aad_file_unique;
-  supply_aad_prefix = other215.supply_aad_prefix;
-  __isset = other215.__isset;
-}
-AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other216) {
-  aad_prefix = other216.aad_prefix;
-  aad_file_unique = other216.aad_file_unique;
-  supply_aad_prefix = other216.supply_aad_prefix;
-  __isset = other216.__isset;
-  return *this;
-}
-void AesGcmCtrV1::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "AesGcmCtrV1(";
-  out << "aad_prefix="; (__isset.aad_prefix ? (out << to_string(aad_prefix)) : (out << "<null>"));
-  out << ", " << "aad_file_unique="; (__isset.aad_file_unique ? (out << to_string(aad_file_unique)) : (out << "<null>"));
-  out << ", " << "supply_aad_prefix="; (__isset.supply_aad_prefix ? (out << to_string(supply_aad_prefix)) : (out << "<null>"));
-  out << ")";
-}
-
-
-EncryptionAlgorithm::~EncryptionAlgorithm() noexcept {
-}
-
-EncryptionAlgorithm::EncryptionAlgorithm() noexcept {
-}
-
-void EncryptionAlgorithm::__set_AES_GCM_V1(const AesGcmV1& val) {
-  this->AES_GCM_V1 = val;
-__isset.AES_GCM_V1 = true;
-}
-
-void EncryptionAlgorithm::__set_AES_GCM_CTR_V1(const AesGcmCtrV1& val) {
-  this->AES_GCM_CTR_V1 = val;
-__isset.AES_GCM_CTR_V1 = true;
-}
-std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t EncryptionAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->AES_GCM_V1.read(iprot);
-          this->__isset.AES_GCM_V1 = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->AES_GCM_CTR_V1.read(iprot);
-          this->__isset.AES_GCM_CTR_V1 = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t EncryptionAlgorithm::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("EncryptionAlgorithm");
-
-  if (this->__isset.AES_GCM_V1) {
-    xfer += oprot->writeFieldBegin("AES_GCM_V1", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->AES_GCM_V1.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.AES_GCM_CTR_V1) {
-    xfer += oprot->writeFieldBegin("AES_GCM_CTR_V1", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->AES_GCM_CTR_V1.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b) {
-  using ::std::swap;
-  swap(a.AES_GCM_V1, b.AES_GCM_V1);
-  swap(a.AES_GCM_CTR_V1, b.AES_GCM_CTR_V1);
-  swap(a.__isset, b.__isset);
-}
-
-EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other217) {
-  AES_GCM_V1 = other217.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other217.AES_GCM_CTR_V1;
-  __isset = other217.__isset;
-}
-EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other218) {
-  AES_GCM_V1 = other218.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other218.AES_GCM_CTR_V1;
-  __isset = other218.__isset;
-  return *this;
-}
-void EncryptionAlgorithm::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "EncryptionAlgorithm(";
-  out << "AES_GCM_V1="; (__isset.AES_GCM_V1 ? (out << to_string(AES_GCM_V1)) : (out << "<null>"));
-  out << ", " << "AES_GCM_CTR_V1="; (__isset.AES_GCM_CTR_V1 ? (out << to_string(AES_GCM_CTR_V1)) : (out << "<null>"));
-  out << ")";
-}
-
-
-FileMetaData::~FileMetaData() noexcept {
-}
-
-FileMetaData::FileMetaData() noexcept
-   : version(0),
-     num_rows(0),
-     created_by(),
-     footer_signing_key_metadata() {
-}
-
-void FileMetaData::__set_version(const int32_t val) {
-  this->version = val;
-}
-
-void FileMetaData::__set_schema(const duckdb::vector<SchemaElement> & val) {
-  this->schema = val;
-}
-
-void FileMetaData::__set_num_rows(const int64_t val) {
-  this->num_rows = val;
-}
-
-void FileMetaData::__set_row_groups(const duckdb::vector<RowGroup> & val) {
-  this->row_groups = val;
-}
-
-void FileMetaData::__set_key_value_metadata(const duckdb::vector<KeyValue> & val) {
-  this->key_value_metadata = val;
-__isset.key_value_metadata = true;
-}
-
-void FileMetaData::__set_created_by(const std::string& val) {
-  this->created_by = val;
-__isset.created_by = true;
-}
-
-void FileMetaData::__set_column_orders(const duckdb::vector<ColumnOrder> & val) {
-  this->column_orders = val;
-__isset.column_orders = true;
-}
-
-void FileMetaData::__set_encryption_algorithm(const EncryptionAlgorithm& val) {
-  this->encryption_algorithm = val;
-__isset.encryption_algorithm = true;
-}
-
-void FileMetaData::__set_footer_signing_key_metadata(const std::string& val) {
-  this->footer_signing_key_metadata = val;
-__isset.footer_signing_key_metadata = true;
-}
-std::ostream& operator<<(std::ostream& out, const FileMetaData& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_version = false;
-  bool isset_schema = false;
-  bool isset_num_rows = false;
-  bool isset_row_groups = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->version);
-          isset_version = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->schema.clear();
-            uint32_t _size219;
-            ::apache::thrift::protocol::TType _etype222;
-            xfer += iprot->readListBegin(_etype222, _size219);
-            this->schema.resize(_size219);
-            uint32_t _i223;
-            for (_i223 = 0; _i223 < _size219; ++_i223)
-            {
-              xfer += this->schema[_i223].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_schema = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->row_groups.clear();
-            uint32_t _size224;
-            ::apache::thrift::protocol::TType _etype227;
-            xfer += iprot->readListBegin(_etype227, _size224);
-            this->row_groups.resize(_size224);
-            uint32_t _i228;
-            for (_i228 = 0; _i228 < _size224; ++_i228)
-            {
-              xfer += this->row_groups[_i228].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_row_groups = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->key_value_metadata.clear();
-            uint32_t _size229;
-            ::apache::thrift::protocol::TType _etype232;
-            xfer += iprot->readListBegin(_etype232, _size229);
-            this->key_value_metadata.resize(_size229);
-            uint32_t _i233;
-            for (_i233 = 0; _i233 < _size229; ++_i233)
-            {
-              xfer += this->key_value_metadata[_i233].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.key_value_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->created_by);
-          this->__isset.created_by = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->column_orders.clear();
-            uint32_t _size234;
-            ::apache::thrift::protocol::TType _etype237;
-            xfer += iprot->readListBegin(_etype237, _size234);
-            this->column_orders.resize(_size234);
-            uint32_t _i238;
-            for (_i238 = 0; _i238 < _size234; ++_i238)
-            {
-              xfer += this->column_orders[_i238].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.column_orders = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->encryption_algorithm.read(iprot);
-          this->__isset.encryption_algorithm = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 9:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->footer_signing_key_metadata);
-          this->__isset.footer_signing_key_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_version)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_schema)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_row_groups)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("FileMetaData");
-
-  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->version);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_LIST, 2);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
-    duckdb::vector<SchemaElement> ::const_iterator _iter239;
-    for (_iter239 = this->schema.begin(); _iter239 != this->schema.end(); ++_iter239)
-    {
-      xfer += (*_iter239).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("row_groups", ::apache::thrift::protocol::T_LIST, 4);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
-    duckdb::vector<RowGroup> ::const_iterator _iter240;
-    for (_iter240 = this->row_groups.begin(); _iter240 != this->row_groups.end(); ++_iter240)
-    {
-      xfer += (*_iter240).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_value_metadata) {
-    xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 5);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      duckdb::vector<KeyValue> ::const_iterator _iter241;
-      for (_iter241 = this->key_value_metadata.begin(); _iter241 != this->key_value_metadata.end(); ++_iter241)
-      {
-        xfer += (*_iter241).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.created_by) {
-    xfer += oprot->writeFieldBegin("created_by", ::apache::thrift::protocol::T_STRING, 6);
-    xfer += oprot->writeString(this->created_by);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.column_orders) {
-    xfer += oprot->writeFieldBegin("column_orders", ::apache::thrift::protocol::T_LIST, 7);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_orders.size()));
-      duckdb::vector<ColumnOrder> ::const_iterator _iter242;
-      for (_iter242 = this->column_orders.begin(); _iter242 != this->column_orders.end(); ++_iter242)
-      {
-        xfer += (*_iter242).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.encryption_algorithm) {
-    xfer += oprot->writeFieldBegin("encryption_algorithm", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->encryption_algorithm.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.footer_signing_key_metadata) {
-    xfer += oprot->writeFieldBegin("footer_signing_key_metadata", ::apache::thrift::protocol::T_STRING, 9);
-    xfer += oprot->writeBinary(this->footer_signing_key_metadata);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(FileMetaData &a, FileMetaData &b) {
-  using ::std::swap;
-  swap(a.version, b.version);
-  swap(a.schema, b.schema);
-  swap(a.num_rows, b.num_rows);
-  swap(a.row_groups, b.row_groups);
-  swap(a.key_value_metadata, b.key_value_metadata);
-  swap(a.created_by, b.created_by);
-  swap(a.column_orders, b.column_orders);
-  swap(a.encryption_algorithm, b.encryption_algorithm);
-  swap(a.footer_signing_key_metadata, b.footer_signing_key_metadata);
-  swap(a.__isset, b.__isset);
-}
-
-FileMetaData::FileMetaData(const FileMetaData& other243) {
-  version = other243.version;
-  schema = other243.schema;
-  num_rows = other243.num_rows;
-  row_groups = other243.row_groups;
-  key_value_metadata = other243.key_value_metadata;
-  created_by = other243.created_by;
-  column_orders = other243.column_orders;
-  encryption_algorithm = other243.encryption_algorithm;
-  footer_signing_key_metadata = other243.footer_signing_key_metadata;
-  __isset = other243.__isset;
-}
-FileMetaData& FileMetaData::operator=(const FileMetaData& other244) {
-  version = other244.version;
-  schema = other244.schema;
-  num_rows = other244.num_rows;
-  row_groups = other244.row_groups;
-  key_value_metadata = other244.key_value_metadata;
-  created_by = other244.created_by;
-  column_orders = other244.column_orders;
-  encryption_algorithm = other244.encryption_algorithm;
-  footer_signing_key_metadata = other244.footer_signing_key_metadata;
-  __isset = other244.__isset;
-  return *this;
-}
-void FileMetaData::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "FileMetaData(";
-  out << "version=" << to_string(version);
-  out << ", " << "schema=" << to_string(schema);
-  out << ", " << "num_rows=" << to_string(num_rows);
-  out << ", " << "row_groups=" << to_string(row_groups);
-  out << ", " << "key_value_metadata="; (__isset.key_value_metadata ? (out << to_string(key_value_metadata)) : (out << "<null>"));
-  out << ", " << "created_by="; (__isset.created_by ? (out << to_string(created_by)) : (out << "<null>"));
-  out << ", " << "column_orders="; (__isset.column_orders ? (out << to_string(column_orders)) : (out << "<null>"));
-  out << ", " << "encryption_algorithm="; (__isset.encryption_algorithm ? (out << to_string(encryption_algorithm)) : (out << "<null>"));
-  out << ", " << "footer_signing_key_metadata="; (__isset.footer_signing_key_metadata ? (out << to_string(footer_signing_key_metadata)) : (out << "<null>"));
-  out << ")";
-}
-
-
-FileCryptoMetaData::~FileCryptoMetaData() noexcept {
-}
-
-FileCryptoMetaData::FileCryptoMetaData() noexcept
-   : key_metadata() {
-}
-
-void FileCryptoMetaData::__set_encryption_algorithm(const EncryptionAlgorithm& val) {
-  this->encryption_algorithm = val;
-}
-
-void FileCryptoMetaData::__set_key_metadata(const std::string& val) {
-  this->key_metadata = val;
-__isset.key_metadata = true;
-}
-std::ostream& operator<<(std::ostream& out, const FileCryptoMetaData& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
-
-uint32_t FileCryptoMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_encryption_algorithm = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->encryption_algorithm.read(iprot);
-          isset_encryption_algorithm = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->key_metadata);
-          this->__isset.key_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_encryption_algorithm)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t FileCryptoMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("FileCryptoMetaData");
-
-  xfer += oprot->writeFieldBegin("encryption_algorithm", ::apache::thrift::protocol::T_STRUCT, 1);
-  xfer += this->encryption_algorithm.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_metadata) {
-    xfer += oprot->writeFieldBegin("key_metadata", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->key_metadata);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(FileCryptoMetaData &a, FileCryptoMetaData &b) {
-  using ::std::swap;
-  swap(a.encryption_algorithm, b.encryption_algorithm);
-  swap(a.key_metadata, b.key_metadata);
-  swap(a.__isset, b.__isset);
-}
-
-FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other245) {
-  encryption_algorithm = other245.encryption_algorithm;
-  key_metadata = other245.key_metadata;
-  __isset = other245.__isset;
-}
-FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other246) {
-  encryption_algorithm = other246.encryption_algorithm;
-  key_metadata = other246.key_metadata;
-  __isset = other246.__isset;
-  return *this;
-}
-void FileCryptoMetaData::printTo(std::ostream& out) const {
-  using ::apache::thrift::to_string;
-  out << "FileCryptoMetaData(";
-  out << "encryption_algorithm=" << to_string(encryption_algorithm);
-  out << ", " << "key_metadata="; (__isset.key_metadata ? (out << to_string(key_metadata)) : (out << "<null>"));
-  out << ")";
-}
-
-} // namespace
diff --git a/src/duckdb/third_party/parquet/parquet_types.h b/src/duckdb/third_party/parquet/parquet_types.h
deleted file mode 100644
index df8cf5f17..000000000
--- a/src/duckdb/third_party/parquet/parquet_types.h
+++ /dev/null
@@ -1,2974 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (0.21.0)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-#ifndef parquet_TYPES_H
-#define parquet_TYPES_H
-
-#include <iosfwd>
-
-#include <thrift/Thrift.h>
-#include <thrift/TApplicationException.h>
-#include <thrift/TBase.h>
-#include <thrift/protocol/TProtocol.h>
-#include <thrift/transport/TTransport.h>
-
-#include <functional>
-#include <memory>
-
-
-#include "windows_compatibility.h"
-namespace apache = duckdb_apache;
-
-namespace duckdb_parquet {
-
-/**
- * Types supported by Parquet.  These types are intended to be used in combination
- * with the encodings to control the on disk storage format.
- * For example INT16 is not included as a type since a good encoding of INT32
- * would handle this.
- */
-struct Type {
-  enum type {
-    BOOLEAN = 0,
-    INT32 = 1,
-    INT64 = 2,
-    INT96 = 3,
-    FLOAT = 4,
-    DOUBLE = 5,
-    BYTE_ARRAY = 6,
-    FIXED_LEN_BYTE_ARRAY = 7
-  };
-};
-
-extern const std::map<int, const char*> _Type_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const Type::type& val);
-
-std::string to_string(const Type::type& val);
-
-/**
- * DEPRECATED: Common types used by frameworks(e.g. hive, pig) using parquet.
- * ConvertedType is superseded by LogicalType.  This enum should not be extended.
- * 
- * See LogicalTypes.md for conversion between ConvertedType and LogicalType.
- */
-struct ConvertedType {
-  enum type {
-    /**
-     * a BYTE_ARRAY actually contains UTF8 encoded chars
-     */
-    UTF8 = 0,
-    /**
-     * a map is converted as an optional field containing a repeated key/value pair
-     */
-    MAP = 1,
-    /**
-     * a key/value pair is converted into a group of two fields
-     */
-    MAP_KEY_VALUE = 2,
-    /**
-     * a list is converted into an optional field containing a repeated field for its
-     * values
-     */
-    LIST = 3,
-    /**
-     * an enum is converted into a BYTE_ARRAY field
-     */
-    ENUM = 4,
-    /**
-     * A decimal value.
-     * 
-     * This may be used to annotate BYTE_ARRAY or FIXED_LEN_BYTE_ARRAY primitive
-     * types. The underlying byte array stores the unscaled value encoded as two's
-     * complement using big-endian byte order (the most significant byte is the
-     * zeroth element). The value of the decimal is the value * 10^{-scale}.
-     * 
-     * This must be accompanied by a (maximum) precision and a scale in the
-     * SchemaElement. The precision specifies the number of digits in the decimal
-     * and the scale stores the location of the decimal point. For example 1.23
-     * would have precision 3 (3 total digits) and scale 2 (the decimal point is
-     * 2 digits over).
-     */
-    DECIMAL = 5,
-    /**
-     * A Date
-     * 
-     * Stored as days since Unix epoch, encoded as the INT32 physical type.
-     * 
-     */
-    DATE = 6,
-    /**
-     * A time
-     * 
-     * The total number of milliseconds since midnight.  The value is stored
-     * as an INT32 physical type.
-     */
-    TIME_MILLIS = 7,
-    /**
-     * A time.
-     * 
-     * The total number of microseconds since midnight.  The value is stored as
-     * an INT64 physical type.
-     */
-    TIME_MICROS = 8,
-    /**
-     * A date/time combination
-     * 
-     * Date and time recorded as milliseconds since the Unix epoch.  Recorded as
-     * a physical type of INT64.
-     */
-    TIMESTAMP_MILLIS = 9,
-    /**
-     * A date/time combination
-     * 
-     * Date and time recorded as microseconds since the Unix epoch.  The value is
-     * stored as an INT64 physical type.
-     */
-    TIMESTAMP_MICROS = 10,
-    /**
-     * An unsigned integer value.
-     * 
-     * The number describes the maximum number of meaningful data bits in
-     * the stored value. 8, 16 and 32 bit values are stored using the
-     * INT32 physical type.  64 bit values are stored using the INT64
-     * physical type.
-     * 
-     */
-    UINT_8 = 11,
-    UINT_16 = 12,
-    UINT_32 = 13,
-    UINT_64 = 14,
-    /**
-     * A signed integer value.
-     * 
-     * The number describes the maximum number of meaningful data bits in
-     * the stored value. 8, 16 and 32 bit values are stored using the
-     * INT32 physical type.  64 bit values are stored using the INT64
-     * physical type.
-     * 
-     */
-    INT_8 = 15,
-    INT_16 = 16,
-    INT_32 = 17,
-    INT_64 = 18,
-    /**
-     * An embedded JSON document
-     * 
-     * A JSON document embedded within a single UTF8 column.
-     */
-    JSON = 19,
-    /**
-     * An embedded BSON document
-     * 
-     * A BSON document embedded within a single BYTE_ARRAY column.
-     */
-    BSON = 20,
-    /**
-     * An interval of time
-     * 
-     * This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
-     * This data is composed of three separate little endian unsigned
-     * integers.  Each stores a component of a duration of time.  The first
-     * integer identifies the number of months associated with the duration,
-     * the second identifies the number of days associated with the duration
-     * and the third identifies the number of milliseconds associated with
-     * the provided duration.  This duration of time is independent of any
-     * particular timezone or date.
-     */
-    INTERVAL = 21
-  };
-};
-
-extern const std::map<int, const char*> _ConvertedType_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const ConvertedType::type& val);
-
-std::string to_string(const ConvertedType::type& val);
-
-/**
- * Representation of Schemas
- */
-struct FieldRepetitionType {
-  enum type {
-    /**
-     * This field is required (can not be null) and each row has exactly 1 value.
-     */
-    REQUIRED = 0,
-    /**
-     * The field is optional (can be null) and each row has 0 or 1 values.
-     */
-    OPTIONAL = 1,
-    /**
-     * The field is repeated and can contain 0 or more values
-     */
-    REPEATED = 2
-  };
-};
-
-extern const std::map<int, const char*> _FieldRepetitionType_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const FieldRepetitionType::type& val);
-
-std::string to_string(const FieldRepetitionType::type& val);
-
-/**
- * Encodings supported by Parquet.  Not all encodings are valid for all types.  These
- * enums are also used to specify the encoding of definition and repetition levels.
- * See the accompanying doc for the details of the more complicated encodings.
- */
-struct Encoding {
-  enum type {
-    /**
-     * Default encoding.
-     * BOOLEAN - 1 bit per value. 0 is false; 1 is true.
-     * INT32 - 4 bytes per value.  Stored as little-endian.
-     * INT64 - 8 bytes per value.  Stored as little-endian.
-     * FLOAT - 4 bytes per value.  IEEE. Stored as little-endian.
-     * DOUBLE - 8 bytes per value.  IEEE. Stored as little-endian.
-     * BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
-     * FIXED_LEN_BYTE_ARRAY - Just the bytes.
-     */
-    PLAIN = 0,
-    /**
-     * Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
-     * plain type.
-     * in a data page use RLE_DICTIONARY instead.
-     * in a Dictionary page use PLAIN instead
-     */
-    PLAIN_DICTIONARY = 2,
-    /**
-     * Group packed run length encoding. Usable for definition/repetition levels
-     * encoding and Booleans (on one bit: 0 is false; 1 is true.)
-     */
-    RLE = 3,
-    /**
-     * Bit packed encoding.  This can only be used if the data has a known max
-     * width.  Usable for definition/repetition levels encoding.
-     */
-    BIT_PACKED = 4,
-    /**
-     * Delta encoding for integers. This can be used for int columns and works best
-     * on sorted data
-     */
-    DELTA_BINARY_PACKED = 5,
-    /**
-     * Encoding for byte arrays to separate the length values and the data. The lengths
-     * are encoded using DELTA_BINARY_PACKED
-     */
-    DELTA_LENGTH_BYTE_ARRAY = 6,
-    /**
-     * Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
-     * Suffixes are stored as delta length byte arrays.
-     */
-    DELTA_BYTE_ARRAY = 7,
-    /**
-     * Dictionary encoding: the ids are encoded using the RLE encoding
-     */
-    RLE_DICTIONARY = 8,
-    /**
-     * Encoding for fixed-width data (FLOAT, DOUBLE, INT32, INT64, FIXED_LEN_BYTE_ARRAY).
-     * K byte-streams are created where K is the size in bytes of the data type.
-     * The individual bytes of a value are scattered to the corresponding stream and
-     * the streams are concatenated.
-     * This itself does not reduce the size of the data but can lead to better compression
-     * afterwards.
-     * 
-     * Added in 2.8 for FLOAT and DOUBLE.
-     * Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
-     */
-    BYTE_STREAM_SPLIT = 9
-  };
-};
-
-extern const std::map<int, const char*> _Encoding_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const Encoding::type& val);
-
-std::string to_string(const Encoding::type& val);
-
-/**
- * Supported compression algorithms.
- * 
- * Codecs added in format version X.Y can be read by readers based on X.Y and later.
- * Codec support may vary between readers based on the format version and
- * libraries available at runtime.
- * 
- * See Compression.md for a detailed specification of these algorithms.
- */
-struct CompressionCodec {
-  enum type {
-    UNCOMPRESSED = 0,
-    SNAPPY = 1,
-    GZIP = 2,
-    LZO = 3,
-    BROTLI = 4,
-    LZ4 = 5,
-    ZSTD = 6,
-    LZ4_RAW = 7
-  };
-};
-
-extern const std::map<int, const char*> _CompressionCodec_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const CompressionCodec::type& val);
-
-std::string to_string(const CompressionCodec::type& val);
-
-struct PageType {
-  enum type {
-    DATA_PAGE = 0,
-    INDEX_PAGE = 1,
-    DICTIONARY_PAGE = 2,
-    DATA_PAGE_V2 = 3
-  };
-};
-
-extern const std::map<int, const char*> _PageType_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const PageType::type& val);
-
-std::string to_string(const PageType::type& val);
-
-/**
- * Enum to annotate whether lists of min/max elements inside ColumnIndex
- * are ordered and if so, in which direction.
- */
-struct BoundaryOrder {
-  enum type {
-    UNORDERED = 0,
-    ASCENDING = 1,
-    DESCENDING = 2
-  };
-};
-
-extern const std::map<int, const char*> _BoundaryOrder_VALUES_TO_NAMES;
-
-std::ostream& operator<<(std::ostream& out, const BoundaryOrder::type& val);
-
-std::string to_string(const BoundaryOrder::type& val);
-
-class SizeStatistics;
-
-class Statistics;
-
-class StringType;
-
-class UUIDType;
-
-class MapType;
-
-class ListType;
-
-class EnumType;
-
-class DateType;
-
-class Float16Type;
-
-class NullType;
-
-class DecimalType;
-
-class MilliSeconds;
-
-class MicroSeconds;
-
-class NanoSeconds;
-
-class TimeUnit;
-
-class TimestampType;
-
-class TimeType;
-
-class IntType;
-
-class JsonType;
-
-class BsonType;
-
-class LogicalType;
-
-class SchemaElement;
-
-class DataPageHeader;
-
-class IndexPageHeader;
-
-class DictionaryPageHeader;
-
-class DataPageHeaderV2;
-
-class SplitBlockAlgorithm;
-
-class BloomFilterAlgorithm;
-
-class XxHash;
-
-class BloomFilterHash;
-
-class Uncompressed;
-
-class BloomFilterCompression;
-
-class BloomFilterHeader;
-
-class PageHeader;
-
-class KeyValue;
-
-class SortingColumn;
-
-class PageEncodingStats;
-
-class ColumnMetaData;
-
-class EncryptionWithFooterKey;
-
-class EncryptionWithColumnKey;
-
-class ColumnCryptoMetaData;
-
-class ColumnChunk;
-
-class RowGroup;
-
-class TypeDefinedOrder;
-
-class ColumnOrder;
-
-class PageLocation;
-
-class OffsetIndex;
-
-class ColumnIndex;
-
-class AesGcmV1;
-
-class AesGcmCtrV1;
-
-class EncryptionAlgorithm;
-
-class FileMetaData;
-
-class FileCryptoMetaData;
-
-typedef struct _SizeStatistics__isset {
-  _SizeStatistics__isset() : unencoded_byte_array_data_bytes(false), repetition_level_histogram(false), definition_level_histogram(false) {}
-  bool unencoded_byte_array_data_bytes :1;
-  bool repetition_level_histogram :1;
-  bool definition_level_histogram :1;
-} _SizeStatistics__isset;
-
-/**
- * A structure for capturing metadata for estimating the unencoded,
- * uncompressed size of data written. This is useful for readers to estimate
- * how much memory is needed to reconstruct data in their memory model and for
- * fine grained filter pushdown on nested structures (the histograms contained
- * in this structure can help determine the number of nulls at a particular
- * nesting level and maximum length of lists).
- */
-class SizeStatistics : public virtual ::apache::thrift::TBase {
- public:
-
-  SizeStatistics(const SizeStatistics&);
-  SizeStatistics& operator=(const SizeStatistics&);
-  SizeStatistics() noexcept;
-
-  virtual ~SizeStatistics() noexcept;
-  /**
-   * The number of physical bytes stored for BYTE_ARRAY data values assuming
-   * no encoding. This is exclusive of the bytes needed to store the length of
-   * each byte array. In other words, this field is equivalent to the `(size
-   * of PLAIN-ENCODING the byte array values) - (4 bytes * number of values
-   * written)`. To determine unencoded sizes of other types readers can use
-   * schema information multiplied by the number of non-null and null values.
-   * The number of null/non-null values can be inferred from the histograms
-   * below.
-   * 
-   * For example, if a column chunk is dictionary-encoded with dictionary
-   * ["a", "bc", "cde"], and a data page contains the indices [0, 0, 1, 2],
-   * then this value for that data page should be 7 (1 + 1 + 2 + 3).
-   * 
-   * This field should only be set for types that use BYTE_ARRAY as their
-   * physical type.
-   */
-  int64_t unencoded_byte_array_data_bytes;
-  /**
-   * When present, there is expected to be one element corresponding to each
-   * repetition (i.e. size=max repetition_level+1) where each element
-   * represents the number of times the repetition level was observed in the
-   * data.
-   * 
-   * This field may be omitted if max_repetition_level is 0 without loss
-   * of information.
-   * 
-   */
-  duckdb::vector<int64_t>  repetition_level_histogram;
-  /**
-   * Same as repetition_level_histogram except for definition levels.
-   * 
-   * This field may be omitted if max_definition_level is 0 or 1 without
-   * loss of information.
-   * 
-   */
-  duckdb::vector<int64_t>  definition_level_histogram;
-
-  _SizeStatistics__isset __isset;
-
-  void __set_unencoded_byte_array_data_bytes(const int64_t val);
-
-  void __set_repetition_level_histogram(const duckdb::vector<int64_t> & val);
-
-  void __set_definition_level_histogram(const duckdb::vector<int64_t> & val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(SizeStatistics &a, SizeStatistics &b);
-
-std::ostream& operator<<(std::ostream& out, const SizeStatistics& obj);
-
-typedef struct _Statistics__isset {
-  _Statistics__isset() : max(false), min(false), null_count(false), distinct_count(false), max_value(false), min_value(false), is_max_value_exact(false), is_min_value_exact(false) {}
-  bool max :1;
-  bool min :1;
-  bool null_count :1;
-  bool distinct_count :1;
-  bool max_value :1;
-  bool min_value :1;
-  bool is_max_value_exact :1;
-  bool is_min_value_exact :1;
-} _Statistics__isset;
-
-/**
- * Statistics per row group and per page
- * All fields are optional.
- */
-class Statistics : public virtual ::apache::thrift::TBase {
- public:
-
-  Statistics(const Statistics&);
-  Statistics& operator=(const Statistics&);
-  Statistics() noexcept;
-
-  virtual ~Statistics() noexcept;
-  /**
-   * DEPRECATED: min and max value of the column. Use min_value and max_value.
-   * 
-   * Values are encoded using PLAIN encoding, except that variable-length byte
-   * arrays do not include a length prefix.
-   * 
-   * These fields encode min and max values determined by signed comparison
-   * only. New files should use the correct order for a column's logical type
-   * and store the values in the min_value and max_value fields.
-   * 
-   * To support older readers, these may be set when the column order is
-   * signed.
-   */
-  std::string max;
-  std::string min;
-  /**
-   * Count of null values in the column.
-   * 
-   * Writers SHOULD always write this field even if it is zero (i.e. no null value)
-   * or the column is not nullable.
-   * Readers MUST distinguish between null_count not being present and null_count == 0.
-   * If null_count is not present, readers MUST NOT assume null_count == 0.
-   */
-  int64_t null_count;
-  /**
-   * count of distinct values occurring
-   */
-  int64_t distinct_count;
-  /**
-   * Lower and upper bound values for the column, determined by its ColumnOrder.
-   * 
-   * These may be the actual minimum and maximum values found on a page or column
-   * chunk, but can also be (more compact) values that do not exist on a page or
-   * column chunk. For example, instead of storing "Blart Versenwald III", a writer
-   * may set min_value="B", max_value="C". Such more compact values must still be
-   * valid values within the column's logical type.
-   * 
-   * Values are encoded using PLAIN encoding, except that variable-length byte
-   * arrays do not include a length prefix.
-   */
-  std::string max_value;
-  std::string min_value;
-  /**
-   * If true, max_value is the actual maximum value for a column
-   */
-  bool is_max_value_exact;
-  /**
-   * If true, min_value is the actual minimum value for a column
-   */
-  bool is_min_value_exact;
-
-  _Statistics__isset __isset;
-
-  void __set_max(const std::string& val);
-
-  void __set_min(const std::string& val);
-
-  void __set_null_count(const int64_t val);
-
-  void __set_distinct_count(const int64_t val);
-
-  void __set_max_value(const std::string& val);
-
-  void __set_min_value(const std::string& val);
-
-  void __set_is_max_value_exact(const bool val);
-
-  void __set_is_min_value_exact(const bool val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(Statistics &a, Statistics &b);
-
-std::ostream& operator<<(std::ostream& out, const Statistics& obj);
-
-
-/**
- * Empty structs to use as logical type annotations
- */
-class StringType : public virtual ::apache::thrift::TBase {
- public:
-
-  StringType(const StringType&) noexcept;
-  StringType& operator=(const StringType&) noexcept;
-  StringType() noexcept;
-
-  virtual ~StringType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(StringType &a, StringType &b);
-
-std::ostream& operator<<(std::ostream& out, const StringType& obj);
-
-
-class UUIDType : public virtual ::apache::thrift::TBase {
- public:
-
-  UUIDType(const UUIDType&) noexcept;
-  UUIDType& operator=(const UUIDType&) noexcept;
-  UUIDType() noexcept;
-
-  virtual ~UUIDType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(UUIDType &a, UUIDType &b);
-
-std::ostream& operator<<(std::ostream& out, const UUIDType& obj);
-
-
-class MapType : public virtual ::apache::thrift::TBase {
- public:
-
-  MapType(const MapType&) noexcept;
-  MapType& operator=(const MapType&) noexcept;
-  MapType() noexcept;
-
-  virtual ~MapType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(MapType &a, MapType &b);
-
-std::ostream& operator<<(std::ostream& out, const MapType& obj);
-
-
-class ListType : public virtual ::apache::thrift::TBase {
- public:
-
-  ListType(const ListType&) noexcept;
-  ListType& operator=(const ListType&) noexcept;
-  ListType() noexcept;
-
-  virtual ~ListType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(ListType &a, ListType &b);
-
-std::ostream& operator<<(std::ostream& out, const ListType& obj);
-
-
-class EnumType : public virtual ::apache::thrift::TBase {
- public:
-
-  EnumType(const EnumType&) noexcept;
-  EnumType& operator=(const EnumType&) noexcept;
-  EnumType() noexcept;
-
-  virtual ~EnumType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(EnumType &a, EnumType &b);
-
-std::ostream& operator<<(std::ostream& out, const EnumType& obj);
-
-
-class DateType : public virtual ::apache::thrift::TBase {
- public:
-
-  DateType(const DateType&) noexcept;
-  DateType& operator=(const DateType&) noexcept;
-  DateType() noexcept;
-
-  virtual ~DateType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(DateType &a, DateType &b);
-
-std::ostream& operator<<(std::ostream& out, const DateType& obj);
-
-
-class Float16Type : public virtual ::apache::thrift::TBase {
- public:
-
-  Float16Type(const Float16Type&) noexcept;
-  Float16Type& operator=(const Float16Type&) noexcept;
-  Float16Type() noexcept;
-
-  virtual ~Float16Type() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(Float16Type &a, Float16Type &b);
-
-std::ostream& operator<<(std::ostream& out, const Float16Type& obj);
-
-
-/**
- * Logical type to annotate a column that is always null.
- * 
- * Sometimes when discovering the schema of existing data, values are always
- * null and the physical type can't be determined. This annotation signals
- * the case where the physical type was guessed from all null values.
- */
-class NullType : public virtual ::apache::thrift::TBase {
- public:
-
-  NullType(const NullType&) noexcept;
-  NullType& operator=(const NullType&) noexcept;
-  NullType() noexcept;
-
-  virtual ~NullType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(NullType &a, NullType &b);
-
-std::ostream& operator<<(std::ostream& out, const NullType& obj);
-
-
-/**
- * Decimal logical type annotation
- * 
- * Scale must be zero or a positive integer less than or equal to the precision.
- * Precision must be a non-zero positive integer.
- * 
- * To maintain forward-compatibility in v1, implementations using this logical
- * type must also set scale and precision on the annotated SchemaElement.
- * 
- * Allowed for physical types: INT32, INT64, FIXED_LEN_BYTE_ARRAY, and BYTE_ARRAY.
- */
-class DecimalType : public virtual ::apache::thrift::TBase {
- public:
-
-  DecimalType(const DecimalType&) noexcept;
-  DecimalType& operator=(const DecimalType&) noexcept;
-  DecimalType() noexcept;
-
-  virtual ~DecimalType() noexcept;
-  int32_t scale;
-  int32_t precision;
-
-  void __set_scale(const int32_t val);
-
-  void __set_precision(const int32_t val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(DecimalType &a, DecimalType &b);
-
-std::ostream& operator<<(std::ostream& out, const DecimalType& obj);
-
-
-/**
- * Time units for logical types
- */
-class MilliSeconds : public virtual ::apache::thrift::TBase {
- public:
-
-  MilliSeconds(const MilliSeconds&) noexcept;
-  MilliSeconds& operator=(const MilliSeconds&) noexcept;
-  MilliSeconds() noexcept;
-
-  virtual ~MilliSeconds() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(MilliSeconds &a, MilliSeconds &b);
-
-std::ostream& operator<<(std::ostream& out, const MilliSeconds& obj);
-
-
-class MicroSeconds : public virtual ::apache::thrift::TBase {
- public:
-
-  MicroSeconds(const MicroSeconds&) noexcept;
-  MicroSeconds& operator=(const MicroSeconds&) noexcept;
-  MicroSeconds() noexcept;
-
-  virtual ~MicroSeconds() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(MicroSeconds &a, MicroSeconds &b);
-
-std::ostream& operator<<(std::ostream& out, const MicroSeconds& obj);
-
-
-class NanoSeconds : public virtual ::apache::thrift::TBase {
- public:
-
-  NanoSeconds(const NanoSeconds&) noexcept;
-  NanoSeconds& operator=(const NanoSeconds&) noexcept;
-  NanoSeconds() noexcept;
-
-  virtual ~NanoSeconds() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(NanoSeconds &a, NanoSeconds &b);
-
-std::ostream& operator<<(std::ostream& out, const NanoSeconds& obj);
-
-typedef struct _TimeUnit__isset {
-  _TimeUnit__isset() : MILLIS(false), MICROS(false), NANOS(false) {}
-  bool MILLIS :1;
-  bool MICROS :1;
-  bool NANOS :1;
-} _TimeUnit__isset;
-
-class TimeUnit : public virtual ::apache::thrift::TBase {
- public:
-
-  TimeUnit(const TimeUnit&) noexcept;
-  TimeUnit& operator=(const TimeUnit&) noexcept;
-  TimeUnit() noexcept;
-
-  virtual ~TimeUnit() noexcept;
-  MilliSeconds MILLIS;
-  MicroSeconds MICROS;
-  NanoSeconds NANOS;
-
-  _TimeUnit__isset __isset;
-
-  void __set_MILLIS(const MilliSeconds& val);
-
-  void __set_MICROS(const MicroSeconds& val);
-
-  void __set_NANOS(const NanoSeconds& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(TimeUnit &a, TimeUnit &b);
-
-std::ostream& operator<<(std::ostream& out, const TimeUnit& obj);
-
-
-/**
- * Timestamp logical type annotation
- * 
- * Allowed for physical types: INT64
- */
-class TimestampType : public virtual ::apache::thrift::TBase {
- public:
-
-  TimestampType(const TimestampType&) noexcept;
-  TimestampType& operator=(const TimestampType&) noexcept;
-  TimestampType() noexcept;
-
-  virtual ~TimestampType() noexcept;
-  bool isAdjustedToUTC;
-  TimeUnit unit;
-
-  void __set_isAdjustedToUTC(const bool val);
-
-  void __set_unit(const TimeUnit& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(TimestampType &a, TimestampType &b);
-
-std::ostream& operator<<(std::ostream& out, const TimestampType& obj);
-
-
-/**
- * Time logical type annotation
- * 
- * Allowed for physical types: INT32 (millis), INT64 (micros, nanos)
- */
-class TimeType : public virtual ::apache::thrift::TBase {
- public:
-
-  TimeType(const TimeType&) noexcept;
-  TimeType& operator=(const TimeType&) noexcept;
-  TimeType() noexcept;
-
-  virtual ~TimeType() noexcept;
-  bool isAdjustedToUTC;
-  TimeUnit unit;
-
-  void __set_isAdjustedToUTC(const bool val);
-
-  void __set_unit(const TimeUnit& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(TimeType &a, TimeType &b);
-
-std::ostream& operator<<(std::ostream& out, const TimeType& obj);
-
-
-/**
- * Integer logical type annotation
- * 
- * bitWidth must be 8, 16, 32, or 64.
- * 
- * Allowed for physical types: INT32, INT64
- */
-class IntType : public virtual ::apache::thrift::TBase {
- public:
-
-  IntType(const IntType&) noexcept;
-  IntType& operator=(const IntType&) noexcept;
-  IntType() noexcept;
-
-  virtual ~IntType() noexcept;
-  int8_t bitWidth;
-  bool isSigned;
-
-  void __set_bitWidth(const int8_t val);
-
-  void __set_isSigned(const bool val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(IntType &a, IntType &b);
-
-std::ostream& operator<<(std::ostream& out, const IntType& obj);
-
-
-/**
- * Embedded JSON logical type annotation
- * 
- * Allowed for physical types: BYTE_ARRAY
- */
-class JsonType : public virtual ::apache::thrift::TBase {
- public:
-
-  JsonType(const JsonType&) noexcept;
-  JsonType& operator=(const JsonType&) noexcept;
-  JsonType() noexcept;
-
-  virtual ~JsonType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(JsonType &a, JsonType &b);
-
-std::ostream& operator<<(std::ostream& out, const JsonType& obj);
-
-
-/**
- * Embedded BSON logical type annotation
- * 
- * Allowed for physical types: BYTE_ARRAY
- */
-class BsonType : public virtual ::apache::thrift::TBase {
- public:
-
-  BsonType(const BsonType&) noexcept;
-  BsonType& operator=(const BsonType&) noexcept;
-  BsonType() noexcept;
-
-  virtual ~BsonType() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(BsonType &a, BsonType &b);
-
-std::ostream& operator<<(std::ostream& out, const BsonType& obj);
-
-typedef struct _LogicalType__isset {
-  _LogicalType__isset() : STRING(false), MAP(false), LIST(false), ENUM(false), DECIMAL(false), DATE(false), TIME(false), TIMESTAMP(false), INTEGER(false), UNKNOWN(false), JSON(false), BSON(false), UUID(false), FLOAT16(false) {}
-  bool STRING :1;
-  bool MAP :1;
-  bool LIST :1;
-  bool ENUM :1;
-  bool DECIMAL :1;
-  bool DATE :1;
-  bool TIME :1;
-  bool TIMESTAMP :1;
-  bool INTEGER :1;
-  bool UNKNOWN :1;
-  bool JSON :1;
-  bool BSON :1;
-  bool UUID :1;
-  bool FLOAT16 :1;
-} _LogicalType__isset;
-
-/**
- * LogicalType annotations to replace ConvertedType.
- * 
- * To maintain compatibility, implementations using LogicalType for a
- * SchemaElement must also set the corresponding ConvertedType (if any)
- * from the following table.
- */
-class LogicalType : public virtual ::apache::thrift::TBase {
- public:
-
-  LogicalType(const LogicalType&) noexcept;
-  LogicalType& operator=(const LogicalType&) noexcept;
-  LogicalType() noexcept;
-
-  virtual ~LogicalType() noexcept;
-  StringType STRING;
-  MapType MAP;
-  ListType LIST;
-  EnumType ENUM;
-  DecimalType DECIMAL;
-  DateType DATE;
-  TimeType TIME;
-  TimestampType TIMESTAMP;
-  IntType INTEGER;
-  NullType UNKNOWN;
-  JsonType JSON;
-  BsonType BSON;
-  UUIDType UUID;
-  Float16Type FLOAT16;
-
-  _LogicalType__isset __isset;
-
-  void __set_STRING(const StringType& val);
-
-  void __set_MAP(const MapType& val);
-
-  void __set_LIST(const ListType& val);
-
-  void __set_ENUM(const EnumType& val);
-
-  void __set_DECIMAL(const DecimalType& val);
-
-  void __set_DATE(const DateType& val);
-
-  void __set_TIME(const TimeType& val);
-
-  void __set_TIMESTAMP(const TimestampType& val);
-
-  void __set_INTEGER(const IntType& val);
-
-  void __set_UNKNOWN(const NullType& val);
-
-  void __set_JSON(const JsonType& val);
-
-  void __set_BSON(const BsonType& val);
-
-  void __set_UUID(const UUIDType& val);
-
-  void __set_FLOAT16(const Float16Type& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(LogicalType &a, LogicalType &b);
-
-std::ostream& operator<<(std::ostream& out, const LogicalType& obj);
-
-typedef struct _SchemaElement__isset {
-  _SchemaElement__isset() : type(false), type_length(false), repetition_type(false), num_children(false), converted_type(false), scale(false), precision(false), field_id(false), logicalType(false) {}
-  bool type :1;
-  bool type_length :1;
-  bool repetition_type :1;
-  bool num_children :1;
-  bool converted_type :1;
-  bool scale :1;
-  bool precision :1;
-  bool field_id :1;
-  bool logicalType :1;
-} _SchemaElement__isset;
-
-/**
- * Represents a element inside a schema definition.
- *  - if it is a group (inner node) then type is undefined and num_children is defined
- *  - if it is a primitive type (leaf) then type is defined and num_children is undefined
- * the nodes are listed in depth first traversal order.
- */
-class SchemaElement : public virtual ::apache::thrift::TBase {
- public:
-
-  SchemaElement(const SchemaElement&);
-  SchemaElement& operator=(const SchemaElement&);
-  SchemaElement() noexcept;
-
-  virtual ~SchemaElement() noexcept;
-  /**
-   * Data type for this field. Not set if the current element is a non-leaf node
-   * 
-   * @see Type
-   */
-  Type::type type;
-  /**
-   * If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values.
-   * Otherwise, if specified, this is the maximum bit length to store any of the values.
-   * (e.g. a low cardinality INT col could have this set to 3).  Note that this is
-   * in the schema, and therefore fixed for the entire file.
-   */
-  int32_t type_length;
-  /**
-   * repetition of the field. The root of the schema does not have a repetition_type.
-   * All other nodes must have one
-   * 
-   * @see FieldRepetitionType
-   */
-  FieldRepetitionType::type repetition_type;
-  /**
-   * Name of the field in the schema
-   */
-  std::string name;
-  /**
-   * Nested fields.  Since thrift does not support nested fields,
-   * the nesting is flattened to a single list by a depth-first traversal.
-   * The children count is used to construct the nested relationship.
-   * This field is not set when the element is a primitive type
-   */
-  int32_t num_children;
-  /**
-   * DEPRECATED: When the schema is the result of a conversion from another model.
-   * Used to record the original type to help with cross conversion.
-   * 
-   * This is superseded by logicalType.
-   * 
-   * @see ConvertedType
-   */
-  ConvertedType::type converted_type;
-  /**
-   * DEPRECATED: Used when this column contains decimal data.
-   * See the DECIMAL converted type for more details.
-   * 
-   * This is superseded by using the DecimalType annotation in logicalType.
-   */
-  int32_t scale;
-  int32_t precision;
-  /**
-   * When the original schema supports field ids, this will save the
-   * original field id in the parquet schema
-   */
-  int32_t field_id;
-  /**
-   * The logical type of this SchemaElement
-   * 
-   * LogicalType replaces ConvertedType, but ConvertedType is still required
-   * for some logical types to ensure forward-compatibility in format v1.
-   */
-  LogicalType logicalType;
-
-  _SchemaElement__isset __isset;
-
-  void __set_type(const Type::type val);
-
-  void __set_type_length(const int32_t val);
-
-  void __set_repetition_type(const FieldRepetitionType::type val);
-
-  void __set_name(const std::string& val);
-
-  void __set_num_children(const int32_t val);
-
-  void __set_converted_type(const ConvertedType::type val);
-
-  void __set_scale(const int32_t val);
-
-  void __set_precision(const int32_t val);
-
-  void __set_field_id(const int32_t val);
-
-  void __set_logicalType(const LogicalType& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(SchemaElement &a, SchemaElement &b);
-
-std::ostream& operator<<(std::ostream& out, const SchemaElement& obj);
-
-typedef struct _DataPageHeader__isset {
-  _DataPageHeader__isset() : statistics(false) {}
-  bool statistics :1;
-} _DataPageHeader__isset;
-
-/**
- * Data page header
- */
-class DataPageHeader : public virtual ::apache::thrift::TBase {
- public:
-
-  DataPageHeader(const DataPageHeader&);
-  DataPageHeader& operator=(const DataPageHeader&);
-  DataPageHeader() noexcept;
-
-  virtual ~DataPageHeader() noexcept;
-  /**
-   * Number of values, including NULLs, in this data page.
-   * 
-   * If a OffsetIndex is present, a page must begin at a row
-   * boundary (repetition_level = 0). Otherwise, pages may begin
-   * within a row (repetition_level > 0).
-   * 
-   */
-  int32_t num_values;
-  /**
-   * Encoding used for this data page *
-   * 
-   * @see Encoding
-   */
-  Encoding::type encoding;
-  /**
-   * Encoding used for definition levels *
-   * 
-   * @see Encoding
-   */
-  Encoding::type definition_level_encoding;
-  /**
-   * Encoding used for repetition levels *
-   * 
-   * @see Encoding
-   */
-  Encoding::type repetition_level_encoding;
-  /**
-   * Optional statistics for the data in this page *
-   */
-  Statistics statistics;
-
-  _DataPageHeader__isset __isset;
-
-  void __set_num_values(const int32_t val);
-
-  void __set_encoding(const Encoding::type val);
-
-  void __set_definition_level_encoding(const Encoding::type val);
-
-  void __set_repetition_level_encoding(const Encoding::type val);
-
-  void __set_statistics(const Statistics& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(DataPageHeader &a, DataPageHeader &b);
-
-std::ostream& operator<<(std::ostream& out, const DataPageHeader& obj);
-
-
-class IndexPageHeader : public virtual ::apache::thrift::TBase {
- public:
-
-  IndexPageHeader(const IndexPageHeader&) noexcept;
-  IndexPageHeader& operator=(const IndexPageHeader&) noexcept;
-  IndexPageHeader() noexcept;
-
-  virtual ~IndexPageHeader() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(IndexPageHeader &a, IndexPageHeader &b);
-
-std::ostream& operator<<(std::ostream& out, const IndexPageHeader& obj);
-
-typedef struct _DictionaryPageHeader__isset {
-  _DictionaryPageHeader__isset() : is_sorted(false) {}
-  bool is_sorted :1;
-} _DictionaryPageHeader__isset;
-
-/**
- * The dictionary page must be placed at the first position of the column chunk
- * if it is partly or completely dictionary encoded. At most one dictionary page
- * can be placed in a column chunk.
- * 
- */
-class DictionaryPageHeader : public virtual ::apache::thrift::TBase {
- public:
-
-  DictionaryPageHeader(const DictionaryPageHeader&) noexcept;
-  DictionaryPageHeader& operator=(const DictionaryPageHeader&) noexcept;
-  DictionaryPageHeader() noexcept;
-
-  virtual ~DictionaryPageHeader() noexcept;
-  /**
-   * Number of values in the dictionary *
-   */
-  int32_t num_values;
-  /**
-   * Encoding using this dictionary page *
-   * 
-   * @see Encoding
-   */
-  Encoding::type encoding;
-  /**
-   * If true, the entries in the dictionary are sorted in ascending order *
-   */
-  bool is_sorted;
-
-  _DictionaryPageHeader__isset __isset;
-
-  void __set_num_values(const int32_t val);
-
-  void __set_encoding(const Encoding::type val);
-
-  void __set_is_sorted(const bool val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(DictionaryPageHeader &a, DictionaryPageHeader &b);
-
-std::ostream& operator<<(std::ostream& out, const DictionaryPageHeader& obj);
-
-typedef struct _DataPageHeaderV2__isset {
-  _DataPageHeaderV2__isset() : is_compressed(true), statistics(false) {}
-  bool is_compressed :1;
-  bool statistics :1;
-} _DataPageHeaderV2__isset;
-
-/**
- * New page format allowing reading levels without decompressing the data
- * Repetition and definition levels are uncompressed
- * The remaining section containing the data is compressed if is_compressed is true
- * 
- */
-class DataPageHeaderV2 : public virtual ::apache::thrift::TBase {
- public:
-
-  DataPageHeaderV2(const DataPageHeaderV2&);
-  DataPageHeaderV2& operator=(const DataPageHeaderV2&);
-  DataPageHeaderV2() noexcept;
-
-  virtual ~DataPageHeaderV2() noexcept;
-  /**
-   * Number of values, including NULLs, in this data page. *
-   */
-  int32_t num_values;
-  /**
-   * Number of NULL values, in this data page.
-   * Number of non-null = num_values - num_nulls which is also the number of values in the data section *
-   */
-  int32_t num_nulls;
-  /**
-   * Number of rows in this data page. Every page must begin at a
-   * row boundary (repetition_level = 0): rows must **not** be
-   * split across page boundaries when using V2 data pages.
-   * 
-   */
-  int32_t num_rows;
-  /**
-   * Encoding used for data in this page *
-   * 
-   * @see Encoding
-   */
-  Encoding::type encoding;
-  /**
-   * Length of the definition levels
-   */
-  int32_t definition_levels_byte_length;
-  /**
-   * Length of the repetition levels
-   */
-  int32_t repetition_levels_byte_length;
-  /**
-   * Whether the values are compressed.
-   * Which means the section of the page between
-   * definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included)
-   * is compressed with the compression_codec.
-   * If missing it is considered compressed
-   */
-  bool is_compressed;
-  /**
-   * Optional statistics for the data in this page *
-   */
-  Statistics statistics;
-
-  _DataPageHeaderV2__isset __isset;
-
-  void __set_num_values(const int32_t val);
-
-  void __set_num_nulls(const int32_t val);
-
-  void __set_num_rows(const int32_t val);
-
-  void __set_encoding(const Encoding::type val);
-
-  void __set_definition_levels_byte_length(const int32_t val);
-
-  void __set_repetition_levels_byte_length(const int32_t val);
-
-  void __set_is_compressed(const bool val);
-
-  void __set_statistics(const Statistics& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b);
-
-std::ostream& operator<<(std::ostream& out, const DataPageHeaderV2& obj);
-
-
-/**
- * Block-based algorithm type annotation. *
- */
-class SplitBlockAlgorithm : public virtual ::apache::thrift::TBase {
- public:
-
-  SplitBlockAlgorithm(const SplitBlockAlgorithm&) noexcept;
-  SplitBlockAlgorithm& operator=(const SplitBlockAlgorithm&) noexcept;
-  SplitBlockAlgorithm() noexcept;
-
-  virtual ~SplitBlockAlgorithm() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(SplitBlockAlgorithm &a, SplitBlockAlgorithm &b);
-
-std::ostream& operator<<(std::ostream& out, const SplitBlockAlgorithm& obj);
-
-typedef struct _BloomFilterAlgorithm__isset {
-  _BloomFilterAlgorithm__isset() : BLOCK(false) {}
-  bool BLOCK :1;
-} _BloomFilterAlgorithm__isset;
-
-/**
- * The algorithm used in Bloom filter. *
- */
-class BloomFilterAlgorithm : public virtual ::apache::thrift::TBase {
- public:
-
-  BloomFilterAlgorithm(const BloomFilterAlgorithm&) noexcept;
-  BloomFilterAlgorithm& operator=(const BloomFilterAlgorithm&) noexcept;
-  BloomFilterAlgorithm() noexcept;
-
-  virtual ~BloomFilterAlgorithm() noexcept;
-  /**
-   * Block-based Bloom filter. *
-   */
-  SplitBlockAlgorithm BLOCK;
-
-  _BloomFilterAlgorithm__isset __isset;
-
-  void __set_BLOCK(const SplitBlockAlgorithm& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(BloomFilterAlgorithm &a, BloomFilterAlgorithm &b);
-
-std::ostream& operator<<(std::ostream& out, const BloomFilterAlgorithm& obj);
-
-
-/**
- * Hash strategy type annotation. xxHash is an extremely fast non-cryptographic hash
- * algorithm. It uses 64 bits version of xxHash.
- * 
- */
-class XxHash : public virtual ::apache::thrift::TBase {
- public:
-
-  XxHash(const XxHash&) noexcept;
-  XxHash& operator=(const XxHash&) noexcept;
-  XxHash() noexcept;
-
-  virtual ~XxHash() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(XxHash &a, XxHash &b);
-
-std::ostream& operator<<(std::ostream& out, const XxHash& obj);
-
-typedef struct _BloomFilterHash__isset {
-  _BloomFilterHash__isset() : XXHASH(false) {}
-  bool XXHASH :1;
-} _BloomFilterHash__isset;
-
-/**
- * The hash function used in Bloom filter. This function takes the hash of a column value
- * using plain encoding.
- * 
- */
-class BloomFilterHash : public virtual ::apache::thrift::TBase {
- public:
-
-  BloomFilterHash(const BloomFilterHash&) noexcept;
-  BloomFilterHash& operator=(const BloomFilterHash&) noexcept;
-  BloomFilterHash() noexcept;
-
-  virtual ~BloomFilterHash() noexcept;
-  /**
-   * xxHash Strategy. *
-   */
-  XxHash XXHASH;
-
-  _BloomFilterHash__isset __isset;
-
-  void __set_XXHASH(const XxHash& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(BloomFilterHash &a, BloomFilterHash &b);
-
-std::ostream& operator<<(std::ostream& out, const BloomFilterHash& obj);
-
-
-/**
- * The compression used in the Bloom filter.
- * 
- */
-class Uncompressed : public virtual ::apache::thrift::TBase {
- public:
-
-  Uncompressed(const Uncompressed&) noexcept;
-  Uncompressed& operator=(const Uncompressed&) noexcept;
-  Uncompressed() noexcept;
-
-  virtual ~Uncompressed() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(Uncompressed &a, Uncompressed &b);
-
-std::ostream& operator<<(std::ostream& out, const Uncompressed& obj);
-
-typedef struct _BloomFilterCompression__isset {
-  _BloomFilterCompression__isset() : UNCOMPRESSED(false) {}
-  bool UNCOMPRESSED :1;
-} _BloomFilterCompression__isset;
-
-class BloomFilterCompression : public virtual ::apache::thrift::TBase {
- public:
-
-  BloomFilterCompression(const BloomFilterCompression&) noexcept;
-  BloomFilterCompression& operator=(const BloomFilterCompression&) noexcept;
-  BloomFilterCompression() noexcept;
-
-  virtual ~BloomFilterCompression() noexcept;
-  Uncompressed UNCOMPRESSED;
-
-  _BloomFilterCompression__isset __isset;
-
-  void __set_UNCOMPRESSED(const Uncompressed& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(BloomFilterCompression &a, BloomFilterCompression &b);
-
-std::ostream& operator<<(std::ostream& out, const BloomFilterCompression& obj);
-
-
-/**
- * Bloom filter header is stored at beginning of Bloom filter data of each column
- * and followed by its bitset.
- * 
- */
-class BloomFilterHeader : public virtual ::apache::thrift::TBase {
- public:
-
-  BloomFilterHeader(const BloomFilterHeader&) noexcept;
-  BloomFilterHeader& operator=(const BloomFilterHeader&) noexcept;
-  BloomFilterHeader() noexcept;
-
-  virtual ~BloomFilterHeader() noexcept;
-  /**
-   * The size of bitset in bytes *
-   */
-  int32_t numBytes;
-  /**
-   * The algorithm for setting bits. *
-   */
-  BloomFilterAlgorithm algorithm;
-  /**
-   * The hash function used for Bloom filter. *
-   */
-  BloomFilterHash hash;
-  /**
-   * The compression used in the Bloom filter *
-   */
-  BloomFilterCompression compression;
-
-  void __set_numBytes(const int32_t val);
-
-  void __set_algorithm(const BloomFilterAlgorithm& val);
-
-  void __set_hash(const BloomFilterHash& val);
-
-  void __set_compression(const BloomFilterCompression& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(BloomFilterHeader &a, BloomFilterHeader &b);
-
-std::ostream& operator<<(std::ostream& out, const BloomFilterHeader& obj);
-
-typedef struct _PageHeader__isset {
-  _PageHeader__isset() : crc(false), data_page_header(false), index_page_header(false), dictionary_page_header(false), data_page_header_v2(false) {}
-  bool crc :1;
-  bool data_page_header :1;
-  bool index_page_header :1;
-  bool dictionary_page_header :1;
-  bool data_page_header_v2 :1;
-} _PageHeader__isset;
-
-class PageHeader : public virtual ::apache::thrift::TBase {
- public:
-
-  PageHeader(const PageHeader&);
-  PageHeader& operator=(const PageHeader&);
-  PageHeader() noexcept;
-
-  virtual ~PageHeader() noexcept;
-  /**
-   * the type of the page: indicates which of the *_header fields is set *
-   * 
-   * @see PageType
-   */
-  PageType::type type;
-  /**
-   * Uncompressed page size in bytes (not including this header) *
-   */
-  int32_t uncompressed_page_size;
-  /**
-   * Compressed (and potentially encrypted) page size in bytes, not including this header *
-   */
-  int32_t compressed_page_size;
-  /**
-   * The 32-bit CRC checksum for the page, to be be calculated as follows:
-   * 
-   * - The standard CRC32 algorithm is used (with polynomial 0x04C11DB7,
-   *   the same as in e.g. GZip).
-   * - All page types can have a CRC (v1 and v2 data pages, dictionary pages,
-   *   etc.).
-   * - The CRC is computed on the serialization binary representation of the page
-   *   (as written to disk), excluding the page header. For example, for v1
-   *   data pages, the CRC is computed on the concatenation of repetition levels,
-   *   definition levels and column values (optionally compressed, optionally
-   *   encrypted).
-   * - The CRC computation therefore takes place after any compression
-   *   and encryption steps, if any.
-   * 
-   * If enabled, this allows for disabling checksumming in HDFS if only a few
-   * pages need to be read.
-   */
-  int32_t crc;
-  DataPageHeader data_page_header;
-  IndexPageHeader index_page_header;
-  DictionaryPageHeader dictionary_page_header;
-  DataPageHeaderV2 data_page_header_v2;
-
-  _PageHeader__isset __isset;
-
-  void __set_type(const PageType::type val);
-
-  void __set_uncompressed_page_size(const int32_t val);
-
-  void __set_compressed_page_size(const int32_t val);
-
-  void __set_crc(const int32_t val);
-
-  void __set_data_page_header(const DataPageHeader& val);
-
-  void __set_index_page_header(const IndexPageHeader& val);
-
-  void __set_dictionary_page_header(const DictionaryPageHeader& val);
-
-  void __set_data_page_header_v2(const DataPageHeaderV2& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(PageHeader &a, PageHeader &b);
-
-std::ostream& operator<<(std::ostream& out, const PageHeader& obj);
-
-typedef struct _KeyValue__isset {
-  _KeyValue__isset() : value(false) {}
-  bool value :1;
-} _KeyValue__isset;
-
-/**
- * Wrapper struct to store key values
- */
-class KeyValue : public virtual ::apache::thrift::TBase {
- public:
-
-  KeyValue(const KeyValue&);
-  KeyValue& operator=(const KeyValue&);
-  KeyValue() noexcept;
-
-  virtual ~KeyValue() noexcept;
-  std::string key;
-  std::string value;
-
-  _KeyValue__isset __isset;
-
-  void __set_key(const std::string& val);
-
-  void __set_value(const std::string& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(KeyValue &a, KeyValue &b);
-
-std::ostream& operator<<(std::ostream& out, const KeyValue& obj);
-
-
-/**
- * Sort order within a RowGroup of a leaf column
- */
-class SortingColumn : public virtual ::apache::thrift::TBase {
- public:
-
-  SortingColumn(const SortingColumn&) noexcept;
-  SortingColumn& operator=(const SortingColumn&) noexcept;
-  SortingColumn() noexcept;
-
-  virtual ~SortingColumn() noexcept;
-  /**
-   * The ordinal position of the column (in this row group) *
-   */
-  int32_t column_idx;
-  /**
-   * If true, indicates this column is sorted in descending order. *
-   */
-  bool descending;
-  /**
-   * If true, nulls will come before non-null values, otherwise,
-   * nulls go at the end.
-   */
-  bool nulls_first;
-
-  void __set_column_idx(const int32_t val);
-
-  void __set_descending(const bool val);
-
-  void __set_nulls_first(const bool val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(SortingColumn &a, SortingColumn &b);
-
-std::ostream& operator<<(std::ostream& out, const SortingColumn& obj);
-
-
-/**
- * statistics of a given page type and encoding
- */
-class PageEncodingStats : public virtual ::apache::thrift::TBase {
- public:
-
-  PageEncodingStats(const PageEncodingStats&) noexcept;
-  PageEncodingStats& operator=(const PageEncodingStats&) noexcept;
-  PageEncodingStats() noexcept;
-
-  virtual ~PageEncodingStats() noexcept;
-  /**
-   * the page type (data/dic/...) *
-   * 
-   * @see PageType
-   */
-  PageType::type page_type;
-  /**
-   * encoding of the page *
-   * 
-   * @see Encoding
-   */
-  Encoding::type encoding;
-  /**
-   * number of pages of this type with this encoding *
-   */
-  int32_t count;
-
-  void __set_page_type(const PageType::type val);
-
-  void __set_encoding(const Encoding::type val);
-
-  void __set_count(const int32_t val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(PageEncodingStats &a, PageEncodingStats &b);
-
-std::ostream& operator<<(std::ostream& out, const PageEncodingStats& obj);
-
-typedef struct _ColumnMetaData__isset {
-  _ColumnMetaData__isset() : key_value_metadata(false), index_page_offset(false), dictionary_page_offset(false), statistics(false), encoding_stats(false), bloom_filter_offset(false), bloom_filter_length(false), size_statistics(false) {}
-  bool key_value_metadata :1;
-  bool index_page_offset :1;
-  bool dictionary_page_offset :1;
-  bool statistics :1;
-  bool encoding_stats :1;
-  bool bloom_filter_offset :1;
-  bool bloom_filter_length :1;
-  bool size_statistics :1;
-} _ColumnMetaData__isset;
-
-/**
- * Description for column metadata
- */
-class ColumnMetaData : public virtual ::apache::thrift::TBase {
- public:
-
-  ColumnMetaData(const ColumnMetaData&);
-  ColumnMetaData& operator=(const ColumnMetaData&);
-  ColumnMetaData() noexcept;
-
-  virtual ~ColumnMetaData() noexcept;
-  /**
-   * Type of this column *
-   * 
-   * @see Type
-   */
-  Type::type type;
-  /**
-   * Set of all encodings used for this column. The purpose is to validate
-   * whether we can decode those pages. *
-   */
-  duckdb::vector<Encoding::type>  encodings;
-  /**
-   * Path in schema *
-   */
-  duckdb::vector<std::string>  path_in_schema;
-  /**
-   * Compression codec *
-   * 
-   * @see CompressionCodec
-   */
-  CompressionCodec::type codec;
-  /**
-   * Number of values in this column *
-   */
-  int64_t num_values;
-  /**
-   * total byte size of all uncompressed pages in this column chunk (including the headers) *
-   */
-  int64_t total_uncompressed_size;
-  /**
-   * total byte size of all compressed, and potentially encrypted, pages
-   * in this column chunk (including the headers) *
-   */
-  int64_t total_compressed_size;
-  /**
-   * Optional key/value metadata *
-   */
-  duckdb::vector<KeyValue>  key_value_metadata;
-  /**
-   * Byte offset from beginning of file to first data page *
-   */
-  int64_t data_page_offset;
-  /**
-   * Byte offset from beginning of file to root index page *
-   */
-  int64_t index_page_offset;
-  /**
-   * Byte offset from the beginning of file to first (only) dictionary page *
-   */
-  int64_t dictionary_page_offset;
-  /**
-   * optional statistics for this column chunk
-   */
-  Statistics statistics;
-  /**
-   * Set of all encodings used for pages in this column chunk.
-   * This information can be used to determine if all data pages are
-   * dictionary encoded for example *
-   */
-  duckdb::vector<PageEncodingStats>  encoding_stats;
-  /**
-   * Byte offset from beginning of file to Bloom filter data. *
-   */
-  int64_t bloom_filter_offset;
-  /**
-   * Size of Bloom filter data including the serialized header, in bytes.
-   * Added in 2.10 so readers may not read this field from old files and
-   * it can be obtained after the BloomFilterHeader has been deserialized.
-   * Writers should write this field so readers can read the bloom filter
-   * in a single I/O.
-   */
-  int32_t bloom_filter_length;
-  /**
-   * Optional statistics to help estimate total memory when converted to in-memory
-   * representations. The histograms contained in these statistics can
-   * also be useful in some cases for more fine-grained nullability/list length
-   * filter pushdown.
-   */
-  SizeStatistics size_statistics;
-
-  _ColumnMetaData__isset __isset;
-
-  void __set_type(const Type::type val);
-
-  void __set_encodings(const duckdb::vector<Encoding::type> & val);
-
-  void __set_path_in_schema(const duckdb::vector<std::string> & val);
-
-  void __set_codec(const CompressionCodec::type val);
-
-  void __set_num_values(const int64_t val);
-
-  void __set_total_uncompressed_size(const int64_t val);
-
-  void __set_total_compressed_size(const int64_t val);
-
-  void __set_key_value_metadata(const duckdb::vector<KeyValue> & val);
-
-  void __set_data_page_offset(const int64_t val);
-
-  void __set_index_page_offset(const int64_t val);
-
-  void __set_dictionary_page_offset(const int64_t val);
-
-  void __set_statistics(const Statistics& val);
-
-  void __set_encoding_stats(const duckdb::vector<PageEncodingStats> & val);
-
-  void __set_bloom_filter_offset(const int64_t val);
-
-  void __set_bloom_filter_length(const int32_t val);
-
-  void __set_size_statistics(const SizeStatistics& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(ColumnMetaData &a, ColumnMetaData &b);
-
-std::ostream& operator<<(std::ostream& out, const ColumnMetaData& obj);
-
-
-class EncryptionWithFooterKey : public virtual ::apache::thrift::TBase {
- public:
-
-  EncryptionWithFooterKey(const EncryptionWithFooterKey&) noexcept;
-  EncryptionWithFooterKey& operator=(const EncryptionWithFooterKey&) noexcept;
-  EncryptionWithFooterKey() noexcept;
-
-  virtual ~EncryptionWithFooterKey() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b);
-
-std::ostream& operator<<(std::ostream& out, const EncryptionWithFooterKey& obj);
-
-typedef struct _EncryptionWithColumnKey__isset {
-  _EncryptionWithColumnKey__isset() : key_metadata(false) {}
-  bool key_metadata :1;
-} _EncryptionWithColumnKey__isset;
-
-class EncryptionWithColumnKey : public virtual ::apache::thrift::TBase {
- public:
-
-  EncryptionWithColumnKey(const EncryptionWithColumnKey&);
-  EncryptionWithColumnKey& operator=(const EncryptionWithColumnKey&);
-  EncryptionWithColumnKey() noexcept;
-
-  virtual ~EncryptionWithColumnKey() noexcept;
-  /**
-   * Column path in schema *
-   */
-  duckdb::vector<std::string>  path_in_schema;
-  /**
-   * Retrieval metadata of column encryption key *
-   */
-  std::string key_metadata;
-
-  _EncryptionWithColumnKey__isset __isset;
-
-  void __set_path_in_schema(const duckdb::vector<std::string> & val);
-
-  void __set_key_metadata(const std::string& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b);
-
-std::ostream& operator<<(std::ostream& out, const EncryptionWithColumnKey& obj);
-
-typedef struct _ColumnCryptoMetaData__isset {
-  _ColumnCryptoMetaData__isset() : ENCRYPTION_WITH_FOOTER_KEY(false), ENCRYPTION_WITH_COLUMN_KEY(false) {}
-  bool ENCRYPTION_WITH_FOOTER_KEY :1;
-  bool ENCRYPTION_WITH_COLUMN_KEY :1;
-} _ColumnCryptoMetaData__isset;
-
-class ColumnCryptoMetaData : public virtual ::apache::thrift::TBase {
- public:
-
-  ColumnCryptoMetaData(const ColumnCryptoMetaData&);
-  ColumnCryptoMetaData& operator=(const ColumnCryptoMetaData&);
-  ColumnCryptoMetaData() noexcept;
-
-  virtual ~ColumnCryptoMetaData() noexcept;
-  EncryptionWithFooterKey ENCRYPTION_WITH_FOOTER_KEY;
-  EncryptionWithColumnKey ENCRYPTION_WITH_COLUMN_KEY;
-
-  _ColumnCryptoMetaData__isset __isset;
-
-  void __set_ENCRYPTION_WITH_FOOTER_KEY(const EncryptionWithFooterKey& val);
-
-  void __set_ENCRYPTION_WITH_COLUMN_KEY(const EncryptionWithColumnKey& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b);
-
-std::ostream& operator<<(std::ostream& out, const ColumnCryptoMetaData& obj);
-
-typedef struct _ColumnChunk__isset {
-  _ColumnChunk__isset() : file_path(false), meta_data(false), offset_index_offset(false), offset_index_length(false), column_index_offset(false), column_index_length(false), crypto_metadata(false), encrypted_column_metadata(false) {}
-  bool file_path :1;
-  bool meta_data :1;
-  bool offset_index_offset :1;
-  bool offset_index_length :1;
-  bool column_index_offset :1;
-  bool column_index_length :1;
-  bool crypto_metadata :1;
-  bool encrypted_column_metadata :1;
-} _ColumnChunk__isset;
-
-class ColumnChunk : public virtual ::apache::thrift::TBase {
- public:
-
-  ColumnChunk(const ColumnChunk&);
-  ColumnChunk& operator=(const ColumnChunk&);
-  ColumnChunk() noexcept;
-
-  virtual ~ColumnChunk() noexcept;
-  /**
-   * File where column data is stored.  If not set, assumed to be same file as
-   * metadata.  This path is relative to the current file.
-   * 
-   */
-  std::string file_path;
-  /**
-   * Deprecated: Byte offset in file_path to the ColumnMetaData
-   * 
-   * Past use of this field has been inconsistent, with some implementations
-   * using it to point to the ColumnMetaData and some using it to point to
-   * the first page in the column chunk. In many cases, the ColumnMetaData at this
-   * location is wrong. This field is now deprecated and should not be used.
-   * Writers should set this field to 0 if no ColumnMetaData has been written outside
-   * the footer.
-   */
-  int64_t file_offset;
-  /**
-   * Column metadata for this chunk. Some writers may also replicate this at the
-   * location pointed to by file_path/file_offset.
-   * Note: while marked as optional, this field is in fact required by most major
-   * Parquet implementations. As such, writers MUST populate this field.
-   * 
-   */
-  ColumnMetaData meta_data;
-  /**
-   * File offset of ColumnChunk's OffsetIndex *
-   */
-  int64_t offset_index_offset;
-  /**
-   * Size of ColumnChunk's OffsetIndex, in bytes *
-   */
-  int32_t offset_index_length;
-  /**
-   * File offset of ColumnChunk's ColumnIndex *
-   */
-  int64_t column_index_offset;
-  /**
-   * Size of ColumnChunk's ColumnIndex, in bytes *
-   */
-  int32_t column_index_length;
-  /**
-   * Crypto metadata of encrypted columns *
-   */
-  ColumnCryptoMetaData crypto_metadata;
-  /**
-   * Encrypted column metadata for this chunk *
-   */
-  std::string encrypted_column_metadata;
-
-  _ColumnChunk__isset __isset;
-
-  void __set_file_path(const std::string& val);
-
-  void __set_file_offset(const int64_t val);
-
-  void __set_meta_data(const ColumnMetaData& val);
-
-  void __set_offset_index_offset(const int64_t val);
-
-  void __set_offset_index_length(const int32_t val);
-
-  void __set_column_index_offset(const int64_t val);
-
-  void __set_column_index_length(const int32_t val);
-
-  void __set_crypto_metadata(const ColumnCryptoMetaData& val);
-
-  void __set_encrypted_column_metadata(const std::string& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(ColumnChunk &a, ColumnChunk &b);
-
-std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj);
-
-typedef struct _RowGroup__isset {
-  _RowGroup__isset() : sorting_columns(false), file_offset(false), total_compressed_size(false), ordinal(false) {}
-  bool sorting_columns :1;
-  bool file_offset :1;
-  bool total_compressed_size :1;
-  bool ordinal :1;
-} _RowGroup__isset;
-
-class RowGroup : public virtual ::apache::thrift::TBase {
- public:
-
-  RowGroup(const RowGroup&);
-  RowGroup& operator=(const RowGroup&);
-  RowGroup() noexcept;
-
-  virtual ~RowGroup() noexcept;
-  /**
-   * Metadata for each column chunk in this row group.
-   * This list must have the same order as the SchemaElement list in FileMetaData.
-   * 
-   */
-  duckdb::vector<ColumnChunk>  columns;
-  /**
-   * Total byte size of all the uncompressed column data in this row group *
-   */
-  int64_t total_byte_size;
-  /**
-   * Number of rows in this row group *
-   */
-  int64_t num_rows;
-  /**
-   * If set, specifies a sort ordering of the rows in this RowGroup.
-   * The sorting columns can be a subset of all the columns.
-   */
-  duckdb::vector<SortingColumn>  sorting_columns;
-  /**
-   * Byte offset from beginning of file to first page (data or dictionary)
-   * in this row group *
-   */
-  int64_t file_offset;
-  /**
-   * Total byte size of all compressed (and potentially encrypted) column data
-   * in this row group *
-   */
-  int64_t total_compressed_size;
-  /**
-   * Row group ordinal in the file *
-   */
-  int16_t ordinal;
-
-  _RowGroup__isset __isset;
-
-  void __set_columns(const duckdb::vector<ColumnChunk> & val);
-
-  void __set_total_byte_size(const int64_t val);
-
-  void __set_num_rows(const int64_t val);
-
-  void __set_sorting_columns(const duckdb::vector<SortingColumn> & val);
-
-  void __set_file_offset(const int64_t val);
-
-  void __set_total_compressed_size(const int64_t val);
-
-  void __set_ordinal(const int16_t val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(RowGroup &a, RowGroup &b);
-
-std::ostream& operator<<(std::ostream& out, const RowGroup& obj);
-
-
-/**
- * Empty struct to signal the order defined by the physical or logical type
- */
-class TypeDefinedOrder : public virtual ::apache::thrift::TBase {
- public:
-
-  TypeDefinedOrder(const TypeDefinedOrder&) noexcept;
-  TypeDefinedOrder& operator=(const TypeDefinedOrder&) noexcept;
-  TypeDefinedOrder() noexcept;
-
-  virtual ~TypeDefinedOrder() noexcept;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(TypeDefinedOrder &a, TypeDefinedOrder &b);
-
-std::ostream& operator<<(std::ostream& out, const TypeDefinedOrder& obj);
-
-typedef struct _ColumnOrder__isset {
-  _ColumnOrder__isset() : TYPE_ORDER(false) {}
-  bool TYPE_ORDER :1;
-} _ColumnOrder__isset;
-
-/**
- * Union to specify the order used for the min_value and max_value fields for a
- * column. This union takes the role of an enhanced enum that allows rich
- * elements (which will be needed for a collation-based ordering in the future).
- * 
- * Possible values are:
- * * TypeDefinedOrder - the column uses the order defined by its logical or
- *                      physical type (if there is no logical type).
- * 
- * If the reader does not support the value of this union, min and max stats
- * for this column should be ignored.
- */
-class ColumnOrder : public virtual ::apache::thrift::TBase {
- public:
-
-  ColumnOrder(const ColumnOrder&) noexcept;
-  ColumnOrder& operator=(const ColumnOrder&) noexcept;
-  ColumnOrder() noexcept;
-
-  virtual ~ColumnOrder() noexcept;
-  /**
-   * The sort orders for logical types are:
-   *   UTF8 - unsigned byte-wise comparison
-   *   INT8 - signed comparison
-   *   INT16 - signed comparison
-   *   INT32 - signed comparison
-   *   INT64 - signed comparison
-   *   UINT8 - unsigned comparison
-   *   UINT16 - unsigned comparison
-   *   UINT32 - unsigned comparison
-   *   UINT64 - unsigned comparison
-   *   DECIMAL - signed comparison of the represented value
-   *   DATE - signed comparison
-   *   TIME_MILLIS - signed comparison
-   *   TIME_MICROS - signed comparison
-   *   TIMESTAMP_MILLIS - signed comparison
-   *   TIMESTAMP_MICROS - signed comparison
-   *   INTERVAL - undefined
-   *   JSON - unsigned byte-wise comparison
-   *   BSON - unsigned byte-wise comparison
-   *   ENUM - unsigned byte-wise comparison
-   *   LIST - undefined
-   *   MAP - undefined
-   * 
-   * In the absence of logical types, the sort order is determined by the physical type:
-   *   BOOLEAN - false, true
-   *   INT32 - signed comparison
-   *   INT64 - signed comparison
-   *   INT96 (only used for legacy timestamps) - undefined
-   *   FLOAT - signed comparison of the represented value (*)
-   *   DOUBLE - signed comparison of the represented value (*)
-   *   BYTE_ARRAY - unsigned byte-wise comparison
-   *   FIXED_LEN_BYTE_ARRAY - unsigned byte-wise comparison
-   * 
-   * (*) Because the sorting order is not specified properly for floating
-   *     point values (relations vs. total ordering) the following
-   *     compatibility rules should be applied when reading statistics:
-   *     - If the min is a NaN, it should be ignored.
-   *     - If the max is a NaN, it should be ignored.
-   *     - If the min is +0, the row group may contain -0 values as well.
-   *     - If the max is -0, the row group may contain +0 values as well.
-   *     - When looking for NaN values, min and max should be ignored.
-   * 
-   *     When writing statistics the following rules should be followed:
-   *     - NaNs should not be written to min or max statistics fields.
-   *     - If the computed max value is zero (whether negative or positive),
-   *       `+0.0` should be written into the max statistics field.
-   *     - If the computed min value is zero (whether negative or positive),
-   *       `-0.0` should be written into the min statistics field.
-   */
-  TypeDefinedOrder TYPE_ORDER;
-
-  _ColumnOrder__isset __isset;
-
-  void __set_TYPE_ORDER(const TypeDefinedOrder& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(ColumnOrder &a, ColumnOrder &b);
-
-std::ostream& operator<<(std::ostream& out, const ColumnOrder& obj);
-
-
-class PageLocation : public virtual ::apache::thrift::TBase {
- public:
-
-  PageLocation(const PageLocation&) noexcept;
-  PageLocation& operator=(const PageLocation&) noexcept;
-  PageLocation() noexcept;
-
-  virtual ~PageLocation() noexcept;
-  /**
-   * Offset of the page in the file *
-   */
-  int64_t offset;
-  /**
-   * Size of the page, including header. Sum of compressed_page_size and header
-   * length
-   */
-  int32_t compressed_page_size;
-  /**
-   * Index within the RowGroup of the first row of the page. When an
-   * OffsetIndex is present, pages must begin on row boundaries
-   * (repetition_level = 0).
-   */
-  int64_t first_row_index;
-
-  void __set_offset(const int64_t val);
-
-  void __set_compressed_page_size(const int32_t val);
-
-  void __set_first_row_index(const int64_t val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(PageLocation &a, PageLocation &b);
-
-std::ostream& operator<<(std::ostream& out, const PageLocation& obj);
-
-typedef struct _OffsetIndex__isset {
-  _OffsetIndex__isset() : unencoded_byte_array_data_bytes(false) {}
-  bool unencoded_byte_array_data_bytes :1;
-} _OffsetIndex__isset;
-
-/**
- * Optional offsets for each data page in a ColumnChunk.
- * 
- * Forms part of the page index, along with ColumnIndex.
- * 
- * OffsetIndex may be present even if ColumnIndex is not.
- */
-class OffsetIndex : public virtual ::apache::thrift::TBase {
- public:
-
-  OffsetIndex(const OffsetIndex&);
-  OffsetIndex& operator=(const OffsetIndex&);
-  OffsetIndex() noexcept;
-
-  virtual ~OffsetIndex() noexcept;
-  /**
-   * PageLocations, ordered by increasing PageLocation.offset. It is required
-   * that page_locations[i].first_row_index < page_locations[i+1].first_row_index.
-   */
-  duckdb::vector<PageLocation>  page_locations;
-  /**
-   * Unencoded/uncompressed size for BYTE_ARRAY types.
-   * 
-   * See documention for unencoded_byte_array_data_bytes in SizeStatistics for
-   * more details on this field.
-   */
-  duckdb::vector<int64_t>  unencoded_byte_array_data_bytes;
-
-  _OffsetIndex__isset __isset;
-
-  void __set_page_locations(const duckdb::vector<PageLocation> & val);
-
-  void __set_unencoded_byte_array_data_bytes(const duckdb::vector<int64_t> & val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(OffsetIndex &a, OffsetIndex &b);
-
-std::ostream& operator<<(std::ostream& out, const OffsetIndex& obj);
-
-typedef struct _ColumnIndex__isset {
-  _ColumnIndex__isset() : null_counts(false), repetition_level_histograms(false), definition_level_histograms(false) {}
-  bool null_counts :1;
-  bool repetition_level_histograms :1;
-  bool definition_level_histograms :1;
-} _ColumnIndex__isset;
-
-/**
- * Optional statistics for each data page in a ColumnChunk.
- * 
- * Forms part the page index, along with OffsetIndex.
- * 
- * If this structure is present, OffsetIndex must also be present.
- * 
- * For each field in this structure, <field>[i] refers to the page at
- * OffsetIndex.page_locations[i]
- */
-class ColumnIndex : public virtual ::apache::thrift::TBase {
- public:
-
-  ColumnIndex(const ColumnIndex&);
-  ColumnIndex& operator=(const ColumnIndex&);
-  ColumnIndex() noexcept;
-
-  virtual ~ColumnIndex() noexcept;
-  /**
-   * A list of Boolean values to determine the validity of the corresponding
-   * min and max values. If true, a page contains only null values, and writers
-   * have to set the corresponding entries in min_values and max_values to
-   * byte[0], so that all lists have the same length. If false, the
-   * corresponding entries in min_values and max_values must be valid.
-   */
-  duckdb::vector<bool>  null_pages;
-  /**
-   * Two lists containing lower and upper bounds for the values of each page
-   * determined by the ColumnOrder of the column. These may be the actual
-   * minimum and maximum values found on a page, but can also be (more compact)
-   * values that do not exist on a page. For example, instead of storing ""Blart
-   * Versenwald III", a writer may set min_values[i]="B", max_values[i]="C".
-   * Such more compact values must still be valid values within the column's
-   * logical type. Readers must make sure that list entries are populated before
-   * using them by inspecting null_pages.
-   */
-  duckdb::vector<std::string>  min_values;
-  duckdb::vector<std::string>  max_values;
-  /**
-   * Stores whether both min_values and max_values are ordered and if so, in
-   * which direction. This allows readers to perform binary searches in both
-   * lists. Readers cannot assume that max_values[i] <= min_values[i+1], even
-   * if the lists are ordered.
-   * 
-   * @see BoundaryOrder
-   */
-  BoundaryOrder::type boundary_order;
-  /**
-   * A list containing the number of null values for each page
-   * 
-   * Writers SHOULD always write this field even if no null values
-   * are present or the column is not nullable.
-   * Readers MUST distinguish between null_counts not being present
-   * and null_count being 0.
-   * If null_counts are not present, readers MUST NOT assume all
-   * null counts are 0.
-   */
-  duckdb::vector<int64_t>  null_counts;
-  /**
-   * Contains repetition level histograms for each page
-   * concatenated together.  The repetition_level_histogram field on
-   * SizeStatistics contains more details.
-   * 
-   * When present the length should always be (number of pages *
-   * (max_repetition_level + 1)) elements.
-   * 
-   * Element 0 is the first element of the histogram for the first page.
-   * Element (max_repetition_level + 1) is the first element of the histogram
-   * for the second page.
-   * 
-   */
-  duckdb::vector<int64_t>  repetition_level_histograms;
-  /**
-   * Same as repetition_level_histograms except for definitions levels.
-   * 
-   */
-  duckdb::vector<int64_t>  definition_level_histograms;
-
-  _ColumnIndex__isset __isset;
-
-  void __set_null_pages(const duckdb::vector<bool> & val);
-
-  void __set_min_values(const duckdb::vector<std::string> & val);
-
-  void __set_max_values(const duckdb::vector<std::string> & val);
-
-  void __set_boundary_order(const BoundaryOrder::type val);
-
-  void __set_null_counts(const duckdb::vector<int64_t> & val);
-
-  void __set_repetition_level_histograms(const duckdb::vector<int64_t> & val);
-
-  void __set_definition_level_histograms(const duckdb::vector<int64_t> & val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(ColumnIndex &a, ColumnIndex &b);
-
-std::ostream& operator<<(std::ostream& out, const ColumnIndex& obj);
-
-typedef struct _AesGcmV1__isset {
-  _AesGcmV1__isset() : aad_prefix(false), aad_file_unique(false), supply_aad_prefix(false) {}
-  bool aad_prefix :1;
-  bool aad_file_unique :1;
-  bool supply_aad_prefix :1;
-} _AesGcmV1__isset;
-
-class AesGcmV1 : public virtual ::apache::thrift::TBase {
- public:
-
-  AesGcmV1(const AesGcmV1&);
-  AesGcmV1& operator=(const AesGcmV1&);
-  AesGcmV1() noexcept;
-
-  virtual ~AesGcmV1() noexcept;
-  /**
-   * AAD prefix *
-   */
-  std::string aad_prefix;
-  /**
-   * Unique file identifier part of AAD suffix *
-   */
-  std::string aad_file_unique;
-  /**
-   * In files encrypted with AAD prefix without storing it,
-   * readers must supply the prefix *
-   */
-  bool supply_aad_prefix;
-
-  _AesGcmV1__isset __isset;
-
-  void __set_aad_prefix(const std::string& val);
-
-  void __set_aad_file_unique(const std::string& val);
-
-  void __set_supply_aad_prefix(const bool val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(AesGcmV1 &a, AesGcmV1 &b);
-
-std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj);
-
-typedef struct _AesGcmCtrV1__isset {
-  _AesGcmCtrV1__isset() : aad_prefix(false), aad_file_unique(false), supply_aad_prefix(false) {}
-  bool aad_prefix :1;
-  bool aad_file_unique :1;
-  bool supply_aad_prefix :1;
-} _AesGcmCtrV1__isset;
-
-class AesGcmCtrV1 : public virtual ::apache::thrift::TBase {
- public:
-
-  AesGcmCtrV1(const AesGcmCtrV1&);
-  AesGcmCtrV1& operator=(const AesGcmCtrV1&);
-  AesGcmCtrV1() noexcept;
-
-  virtual ~AesGcmCtrV1() noexcept;
-  /**
-   * AAD prefix *
-   */
-  std::string aad_prefix;
-  /**
-   * Unique file identifier part of AAD suffix *
-   */
-  std::string aad_file_unique;
-  /**
-   * In files encrypted with AAD prefix without storing it,
-   * readers must supply the prefix *
-   */
-  bool supply_aad_prefix;
-
-  _AesGcmCtrV1__isset __isset;
-
-  void __set_aad_prefix(const std::string& val);
-
-  void __set_aad_file_unique(const std::string& val);
-
-  void __set_supply_aad_prefix(const bool val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b);
-
-std::ostream& operator<<(std::ostream& out, const AesGcmCtrV1& obj);
-
-typedef struct _EncryptionAlgorithm__isset {
-  _EncryptionAlgorithm__isset() : AES_GCM_V1(false), AES_GCM_CTR_V1(false) {}
-  bool AES_GCM_V1 :1;
-  bool AES_GCM_CTR_V1 :1;
-} _EncryptionAlgorithm__isset;
-
-class EncryptionAlgorithm : public virtual ::apache::thrift::TBase {
- public:
-
-  EncryptionAlgorithm(const EncryptionAlgorithm&);
-  EncryptionAlgorithm& operator=(const EncryptionAlgorithm&);
-  EncryptionAlgorithm() noexcept;
-
-  virtual ~EncryptionAlgorithm() noexcept;
-  AesGcmV1 AES_GCM_V1;
-  AesGcmCtrV1 AES_GCM_CTR_V1;
-
-  _EncryptionAlgorithm__isset __isset;
-
-  void __set_AES_GCM_V1(const AesGcmV1& val);
-
-  void __set_AES_GCM_CTR_V1(const AesGcmCtrV1& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b);
-
-std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj);
-
-typedef struct _FileMetaData__isset {
-  _FileMetaData__isset() : key_value_metadata(false), created_by(false), column_orders(false), encryption_algorithm(false), footer_signing_key_metadata(false) {}
-  bool key_value_metadata :1;
-  bool created_by :1;
-  bool column_orders :1;
-  bool encryption_algorithm :1;
-  bool footer_signing_key_metadata :1;
-} _FileMetaData__isset;
-
-/**
- * Description for file metadata
- */
-class FileMetaData : public virtual ::apache::thrift::TBase {
- public:
-
-  FileMetaData(const FileMetaData&);
-  FileMetaData& operator=(const FileMetaData&);
-  FileMetaData() noexcept;
-
-  virtual ~FileMetaData() noexcept;
-  /**
-   * Version of this file *
-   */
-  int32_t version;
-  /**
-   * Parquet schema for this file.  This schema contains metadata for all the columns.
-   * The schema is represented as a tree with a single root.  The nodes of the tree
-   * are flattened to a list by doing a depth-first traversal.
-   * The column metadata contains the path in the schema for that column which can be
-   * used to map columns to nodes in the schema.
-   * The first element is the root *
-   */
-  duckdb::vector<SchemaElement>  schema;
-  /**
-   * Number of rows in this file *
-   */
-  int64_t num_rows;
-  /**
-   * Row groups in this file *
-   */
-  duckdb::vector<RowGroup>  row_groups;
-  /**
-   * Optional key/value metadata *
-   */
-  duckdb::vector<KeyValue>  key_value_metadata;
-  /**
-   * String for application that wrote this file.  This should be in the format
-   * <Application> version <App Version> (build <App Build Hash>).
-   * e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55)
-   * 
-   */
-  std::string created_by;
-  /**
-   * Sort order used for the min_value and max_value fields in the Statistics
-   * objects and the min_values and max_values fields in the ColumnIndex
-   * objects of each column in this file. Sort orders are listed in the order
-   * matching the columns in the schema. The indexes are not necessary the same
-   * though, because only leaf nodes of the schema are represented in the list
-   * of sort orders.
-   * 
-   * Without column_orders, the meaning of the min_value and max_value fields
-   * in the Statistics object and the ColumnIndex object is undefined. To ensure
-   * well-defined behaviour, if these fields are written to a Parquet file,
-   * column_orders must be written as well.
-   * 
-   * The obsolete min and max fields in the Statistics object are always sorted
-   * by signed comparison regardless of column_orders.
-   */
-  duckdb::vector<ColumnOrder>  column_orders;
-  /**
-   * Encryption algorithm. This field is set only in encrypted files
-   * with plaintext footer. Files with encrypted footer store algorithm id
-   * in FileCryptoMetaData structure.
-   */
-  EncryptionAlgorithm encryption_algorithm;
-  /**
-   * Retrieval metadata of key used for signing the footer.
-   * Used only in encrypted files with plaintext footer.
-   */
-  std::string footer_signing_key_metadata;
-
-  _FileMetaData__isset __isset;
-
-  void __set_version(const int32_t val);
-
-  void __set_schema(const duckdb::vector<SchemaElement> & val);
-
-  void __set_num_rows(const int64_t val);
-
-  void __set_row_groups(const duckdb::vector<RowGroup> & val);
-
-  void __set_key_value_metadata(const duckdb::vector<KeyValue> & val);
-
-  void __set_created_by(const std::string& val);
-
-  void __set_column_orders(const duckdb::vector<ColumnOrder> & val);
-
-  void __set_encryption_algorithm(const EncryptionAlgorithm& val);
-
-  void __set_footer_signing_key_metadata(const std::string& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(FileMetaData &a, FileMetaData &b);
-
-std::ostream& operator<<(std::ostream& out, const FileMetaData& obj);
-
-typedef struct _FileCryptoMetaData__isset {
-  _FileCryptoMetaData__isset() : key_metadata(false) {}
-  bool key_metadata :1;
-} _FileCryptoMetaData__isset;
-
-/**
- * Crypto metadata for files with encrypted footer *
- */
-class FileCryptoMetaData : public virtual ::apache::thrift::TBase {
- public:
-
-  FileCryptoMetaData(const FileCryptoMetaData&);
-  FileCryptoMetaData& operator=(const FileCryptoMetaData&);
-  FileCryptoMetaData() noexcept;
-
-  virtual ~FileCryptoMetaData() noexcept;
-  /**
-   * Encryption algorithm. This field is only used for files
-   * with encrypted footer. Files with plaintext footer store algorithm id
-   * inside footer (FileMetaData structure).
-   */
-  EncryptionAlgorithm encryption_algorithm;
-  /**
-   * Retrieval metadata of key used for encryption of footer,
-   * and (possibly) columns *
-   */
-  std::string key_metadata;
-
-  _FileCryptoMetaData__isset __isset;
-
-  void __set_encryption_algorithm(const EncryptionAlgorithm& val);
-
-  void __set_key_metadata(const std::string& val);
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(FileCryptoMetaData &a, FileCryptoMetaData &b);
-
-std::ostream& operator<<(std::ostream& out, const FileCryptoMetaData& obj);
-
-} // namespace
-
-#endif
diff --git a/src/duckdb/third_party/parquet/windows_compatibility.h b/src/duckdb/third_party/parquet/windows_compatibility.h
deleted file mode 100644
index 89beede95..000000000
--- a/src/duckdb/third_party/parquet/windows_compatibility.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#ifdef _WIN32
-#undef CREATE_NEW
-#undef OPTIONAL
-#undef Realloc
-#undef min
-#undef max
-#endif
diff --git a/src/duckdb/third_party/pcg/pcg_extras.hpp b/src/duckdb/third_party/pcg/pcg_extras.hpp
deleted file mode 100644
index 27c3ed5e4..000000000
--- a/src/duckdb/third_party/pcg/pcg_extras.hpp
+++ /dev/null
@@ -1,664 +0,0 @@
-/*
- * PCG Random Number Generation for C++
- *
- * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
- *                     and the PCG Project contributors.
- *
- * SPDX-License-Identifier: (Apache-2.0 OR MIT)
- *
- * Licensed under the Apache License, Version 2.0 (provided in
- * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
- * or under the MIT license (provided in LICENSE-MIT.txt and at
- * http://opensource.org/licenses/MIT), at your option. This file may not
- * be copied, modified, or distributed except according to those terms.
- *
- * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
- * express or implied.  See your chosen license for details.
- *
- * For additional information about the PCG random number generation scheme,
- * visit http://www.pcg-random.org/.
- */
-
-/*
- * This file provides support code that is useful for random-number generation
- * but not specific to the PCG generation scheme, including:
- *      - 128-bit int support for platforms where it isn't available natively
- *      - bit twiddling operations
- *      - I/O of 128-bit and 8-bit integers
- *      - Handling the evilness of SeedSeq
- *      - Support for efficiently producing random numbers less than a given
- *        bound
- */
-
-#ifndef PCG_EXTRAS_HPP_INCLUDED
-#define PCG_EXTRAS_HPP_INCLUDED 1
-
-#include <cinttypes>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-#include <limits>
-#include <iostream>
-#include <type_traits>
-#include <utility>
-#include <locale>
-#include <iterator>
-
-#ifdef __GNUC__
-#include <cxxabi.h> // NOLINT(clang-diagnostic-error)
-#endif
-
-/*
- * Abstractions for compiler-specific directives
- */
-
-#ifdef __GNUC__
-    #define PCG_NOINLINE __attribute__((noinline))
-#else
-    #define PCG_NOINLINE
-#endif
-
-/*
- * Some members of the PCG library use 128-bit math.  When compiling on 64-bit
- * platforms, both GCC and Clang provide 128-bit integer types that are ideal
- * for the job.
- *
- * On 32-bit platforms (or with other compilers), we fall back to a C++
- * class that provides 128-bit unsigned integers instead.  It may seem
- * like we're reinventing the wheel here, because libraries already exist
- * that support large integers, but most existing libraries provide a very
- * generic multiprecision code, but here we're operating at a fixed size.
- * Also, most other libraries are fairly heavyweight.  So we use a direct
- * implementation.  Sadly, it's much slower than hand-coded assembly or
- * direct CPU support.
- *
- */
-#if __SIZEOF_INT128__
-    namespace pcg_extras {
-        typedef __uint128_t pcg128_t;
-    }
-    #define PCG_128BIT_CONSTANT(high,low) \
-            ((pcg_extras::pcg128_t(high) << 64) + low)
-#else
-    #include "pcg_uint128.hpp"
-    namespace pcg_extras {
-        typedef pcg_extras::uint_x4<uint32_t,uint64_t> pcg128_t;
-    }
-    #define PCG_128BIT_CONSTANT(high,low) \
-            pcg_extras::pcg128_t(high,low)
-    #define PCG_EMULATED_128BIT_MATH 1
-#endif
-
-
-namespace pcg_extras {
-
-/*
- * We often need to represent a "number of bits".  When used normally, these
- * numbers are never greater than 128, so an unsigned char is plenty.
- * If you're using a nonstandard generator of a larger size, you can set
- * PCG_BITCOUNT_T to have it define it as a larger size.  (Some compilers
- * might produce faster code if you set it to an unsigned int.)
- */
-
-#ifndef PCG_BITCOUNT_T
-    typedef uint8_t bitcount_t;
-#else
-    typedef PCG_BITCOUNT_T bitcount_t;
-#endif
-
-/*
- * C++ requires us to be able to serialize RNG state by printing or reading
- * it from a stream.  Because we use 128-bit ints, we also need to be able
- * ot print them, so here is code to do so.
- *
- * This code provides enough functionality to print 128-bit ints in decimal
- * and zero-padded in hex.  It's not a full-featured implementation.
- */
-
-template <typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>& out, pcg128_t value)
-{
-    auto desired_base = out.flags() & out.basefield;
-    bool want_hex = desired_base == out.hex;
-
-    if (want_hex) {
-        uint64_t highpart = uint64_t(value >> 64);
-        uint64_t lowpart  = uint64_t(value);
-        auto desired_width = out.width();
-        if (desired_width > 16) {
-            out.width(desired_width - 16);
-        }
-        if (highpart != 0 || desired_width > 16)
-            out << highpart;
-        CharT oldfill = '\0';
-        if (highpart != 0) {
-            out.width(16);
-            oldfill = out.fill('0');
-        }
-        auto oldflags = out.setf(decltype(desired_base){}, out.showbase);
-        out << lowpart;
-        out.setf(oldflags);
-        if (highpart != 0) {
-            out.fill(oldfill);
-        }
-        return out;
-    }
-    constexpr size_t MAX_CHARS_128BIT = 40;
-
-    char buffer[MAX_CHARS_128BIT];
-    char* pos = buffer+sizeof(buffer);
-    *(--pos) = '\0';
-    constexpr auto BASE = pcg128_t(10ULL);
-    do {
-        auto div = value / BASE;
-        auto mod = uint32_t(value - (div * BASE));
-        *(--pos) = '0' + char(mod);
-        value = div;
-    } while(value != pcg128_t(0ULL));
-    return out << pos;
-}
-
-template <typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in, pcg128_t& value)
-{
-    typename std::basic_istream<CharT,Traits>::sentry s(in);
-
-    if (!s)
-         return in;
-
-    constexpr auto BASE = pcg128_t(10ULL);
-    pcg128_t current(0ULL);
-    bool did_nothing = true;
-    bool overflow = false;
-    for(;;) {
-        CharT wide_ch = in.get();
-        if (!in.good())
-            break;
-        auto ch = in.narrow(wide_ch, '\0');
-        if (ch < '0' || ch > '9') {
-            in.unget();
-            break;
-        }
-        did_nothing = false;
-        pcg128_t digit(uint32_t(ch - '0'));
-        pcg128_t timesbase = current*BASE;
-        overflow = overflow || timesbase < current;
-        current = timesbase + digit;
-        overflow = overflow || current < digit;
-    }
-
-    if (did_nothing || overflow) {
-        in.setstate(std::ios::failbit);
-        if (overflow)
-            current = ~pcg128_t(0ULL);
-    }
-
-    value = current;
-
-    return in;
-}
-
-/*
- * Likewise, if people use tiny rngs, we'll be serializing uint8_t.
- * If we just used the provided IO operators, they'd read/write chars,
- * not ints, so we need to define our own.  We *can* redefine this operator
- * here because we're in our own namespace.
- */
-
-template <typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>&out, uint8_t value)
-{
-    return out << uint32_t(value);
-}
-
-template <typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in, uint8_t& target)
-{
-    uint32_t value = 0xdecea5edU;
-    in >> value;
-    if (!in && value == 0xdecea5edU)
-        return in;
-    if (value > uint8_t(~0)) {
-        in.setstate(std::ios::failbit);
-        value = ~0U;
-    }
-    target = uint8_t(value);
-    return in;
-}
-
-/* Unfortunately, the above functions don't get found in preference to the
- * built in ones, so we create some more specific overloads that will.
- * Ugh.
- */
-
-inline std::ostream& operator<<(std::ostream& out, uint8_t value)
-{
-    return pcg_extras::operator<< <char>(out, value);
-}
-
-inline std::istream& operator>>(std::istream& in, uint8_t& value)
-{
-    return pcg_extras::operator>> <char>(in, value);
-}
-
-
-
-/*
- * Useful bitwise operations.
- */
-
-/*
- * XorShifts are invertable, but they are someting of a pain to invert.
- * This function backs them out.  It's used by the whacky "inside out"
- * generator defined later.
- */
-
-template <typename itype>
-inline itype unxorshift(itype x, bitcount_t bits, bitcount_t shift)
-{
-    if (2*shift >= bits) {
-        return x ^ (x >> shift);
-    }
-    itype lowmask1 = (itype(1U) << (bits - shift*2)) - 1;
-    itype highmask1 = ~lowmask1;
-    itype top1 = x;
-    itype bottom1 = x & lowmask1;
-    top1 ^= top1 >> shift;
-    top1 &= highmask1;
-    x = top1 | bottom1;
-    itype lowmask2 = (itype(1U) << (bits - shift)) - 1;
-    itype bottom2 = x & lowmask2;
-    bottom2 = unxorshift(bottom2, bits - shift, shift);
-    bottom2 &= lowmask1;
-    return top1 | bottom2;
-}
-
-/*
- * Rotate left and right.
- *
- * In ideal world, compilers would spot idiomatic rotate code and convert it
- * to a rotate instruction.  Of course, opinions vary on what the correct
- * idiom is and how to spot it.  For clang, sometimes it generates better
- * (but still crappy) code if you define PCG_USE_ZEROCHECK_ROTATE_IDIOM.
- */
-
-template <typename itype>
-inline itype rotl(itype value, bitcount_t rot)
-{
-    constexpr bitcount_t bits = sizeof(itype) * 8;
-    constexpr bitcount_t mask = bits - 1;
-#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
-    return rot ? (value << rot) | (value >> (bits - rot)) : value;
-#else
-    return (value << rot) | (value >> ((- rot) & mask));
-#endif
-}
-
-template <typename itype>
-inline itype rotr(itype value, bitcount_t rot)
-{
-    constexpr bitcount_t bits = sizeof(itype) * 8;
-    constexpr bitcount_t mask = bits - 1;
-#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
-    return rot ? (value >> rot) | (value << (bits - rot)) : value;
-#else
-    return (value >> rot) | (value << ((- rot) & mask));
-#endif
-}
-
-/* Unfortunately, both Clang and GCC sometimes perform poorly when it comes
- * to properly recognizing idiomatic rotate code, so for we also provide
- * assembler directives (enabled with PCG_USE_INLINE_ASM).  Boo, hiss.
- * (I hope that these compilers get better so that this code can die.)
- *
- * These overloads will be preferred over the general template code above.
- */
-#if PCG_USE_INLINE_ASM && __GNUC__ && (__x86_64__  || __i386__)
-
-inline uint8_t rotr(uint8_t value, bitcount_t rot)
-{
-    asm ("rorb   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-
-inline uint16_t rotr(uint16_t value, bitcount_t rot)
-{
-    asm ("rorw   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-
-inline uint32_t rotr(uint32_t value, bitcount_t rot)
-{
-    asm ("rorl   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-
-#if __x86_64__
-inline uint64_t rotr(uint64_t value, bitcount_t rot)
-{
-    asm ("rorq   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-#endif // __x86_64__
-
-#elif defined(_MSC_VER)
-  // Use MSVC++ bit rotation intrinsics
-
-#pragma intrinsic(_rotr, _rotr64, _rotr8, _rotr16)
-
-inline uint8_t rotr(uint8_t value, bitcount_t rot)
-{
-    return _rotr8(value, rot);
-}
-
-inline uint16_t rotr(uint16_t value, bitcount_t rot)
-{
-    return _rotr16(value, rot);
-}
-
-inline uint32_t rotr(uint32_t value, bitcount_t rot)
-{
-    return _rotr(value, rot);
-}
-
-inline uint64_t rotr(uint64_t value, bitcount_t rot)
-{
-    return _rotr64(value, rot);
-}
-
-#endif // PCG_USE_INLINE_ASM
-
-
-/*
- * The C++ SeedSeq concept (modelled by seed_seq) can fill an array of
- * 32-bit integers with seed data, but sometimes we want to produce
- * larger or smaller integers.
- *
- * The following code handles this annoyance.
- *
- * uneven_copy will copy an array of 32-bit ints to an array of larger or
- * smaller ints (actually, the code is general it only needing forward
- * iterators).  The copy is identical to the one that would be performed if
- * we just did memcpy on a standard little-endian machine, but works
- * regardless of the endian of the machine (or the weirdness of the ints
- * involved).
- *
- * generate_to initializes an array of integers using a SeedSeq
- * object.  It is given the size as a static constant at compile time and
- * tries to avoid memory allocation.  If we're filling in 32-bit constants
- * we just do it directly.  If we need a separate buffer and it's small,
- * we allocate it on the stack.  Otherwise, we fall back to heap allocation.
- * Ugh.
- *
- * generate_one produces a single value of some integral type using a
- * SeedSeq object.
- */
-
- /* uneven_copy helper, case where destination ints are less than 32 bit. */
-
-template<class SrcIter, class DestIter>
-SrcIter uneven_copy_impl(
-    SrcIter src_first, DestIter dest_first, DestIter dest_last,
-    std::true_type)
-{
-    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-
-    constexpr bitcount_t SRC_SIZE  = sizeof(src_t);
-    constexpr bitcount_t DEST_SIZE = sizeof(dest_t);
-    constexpr bitcount_t DEST_BITS = DEST_SIZE * 8;
-    constexpr bitcount_t SCALE     = SRC_SIZE / DEST_SIZE;
-
-    size_t count = 0;
-    src_t value = 0;
-
-    while (dest_first != dest_last) {
-        if ((count++ % SCALE) == 0)
-            value = *src_first++;       // Get more bits
-        else
-            value >>= DEST_BITS;        // Move down bits
-
-        *dest_first++ = dest_t(value);  // Truncates, ignores high bits.
-    }
-    return src_first;
-}
-
- /* uneven_copy helper, case where destination ints are more than 32 bit. */
-
-template<class SrcIter, class DestIter>
-SrcIter uneven_copy_impl(
-    SrcIter src_first, DestIter dest_first, DestIter dest_last,
-    std::false_type)
-{
-    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-
-    constexpr auto SRC_SIZE  = sizeof(src_t);
-    constexpr auto SRC_BITS  = SRC_SIZE * 8;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto SCALE     = (DEST_SIZE+SRC_SIZE-1) / SRC_SIZE;
-
-    while (dest_first != dest_last) {
-        dest_t value(0UL);
-        unsigned int shift = 0;
-
-        for (size_t i = 0; i < SCALE; ++i) {
-            value |= dest_t(*src_first++) << shift;
-            shift += SRC_BITS;
-        }
-
-        *dest_first++ = value;
-    }
-    return src_first;
-}
-
-/* uneven_copy, call the right code for larger vs. smaller */
-
-template<class SrcIter, class DestIter>
-inline SrcIter uneven_copy(SrcIter src_first,
-                           DestIter dest_first, DestIter dest_last)
-{
-    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-
-    constexpr bool DEST_IS_SMALLER = sizeof(dest_t) < sizeof(src_t);
-
-    return uneven_copy_impl(src_first, dest_first, dest_last,
-                            std::integral_constant<bool, DEST_IS_SMALLER>{});
-}
-
-/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
- * (actually works for any random-access iterator)
- */
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                             std::true_type)
-{
-    generator.generate(dest, dest+size);
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                      std::false_type)
-{
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto GEN_SIZE  = sizeof(uint32_t);
-
-    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
-    constexpr size_t FROM_ELEMS =
-        GEN_IS_SMALLER
-            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
-            : (size + (GEN_SIZE / DEST_SIZE) - 1)
-                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
-                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
-                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287
-
-    if (FROM_ELEMS <= 1024) {
-        uint32_t buffer[FROM_ELEMS];
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-    } else {
-        uint32_t* buffer = static_cast<uint32_t*>(malloc(GEN_SIZE * FROM_ELEMS));
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-        free(static_cast<void*>(buffer));
-    }
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to(SeedSeq&& generator, DestIter dest)
-{
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);
-
-    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
-                           std::integral_constant<bool, IS_32BIT>{});
-}
-
-/* generate_one, produce a value of integral type using a SeedSeq
- * (optionally, we can have it produce more than one and pick which one
- * we want)
- */
-
-template <typename UInt, size_t i = 0UL, size_t N = i+1UL, typename SeedSeq>
-inline UInt generate_one(SeedSeq&& generator)
-{
-    UInt result[N];
-    generate_to<N>(std::forward<SeedSeq>(generator), result);
-    return result[i];
-}
-
-template <typename RngType>
-auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)
-        -> typename RngType::result_type
-{
-    typedef typename RngType::result_type rtype;
-    rtype threshold = (RngType::max() - RngType::min() + rtype(1) - upper_bound)
-                    % upper_bound;
-    for (;;) {
-        rtype r = rng() - RngType::min();
-        if (r >= threshold)
-            return r % upper_bound;
-    }
-}
-
-template <typename Iter, typename RandType>
-void shuffle(Iter from, Iter to, RandType&& rng)
-{
-    typedef typename std::iterator_traits<Iter>::difference_type delta_t;
-    typedef typename std::remove_reference<RandType>::type::result_type result_t;
-    auto count = to - from;
-    while (count > 1) {
-        delta_t chosen = delta_t(bounded_rand(rng, result_t(count)));
-        --count;
-        --to;
-        using std::swap;
-        swap(*(from + chosen), *to);
-    }
-}
-
-/*
- * Although std::seed_seq is useful, it isn't everything.  Often we want to
- * initialize a random-number generator some other way, such as from a random
- * device.
- *
- * Technically, it does not meet the requirements of a SeedSequence because
- * it lacks some of the rarely-used member functions (some of which would
- * be impossible to provide).  However the C++ standard is quite specific
- * that actual engines only called the generate method, so it ought not to be
- * a problem in practice.
- */
-
-template <typename RngType>
-class seed_seq_from {
-private:
-    RngType rng_;
-
-    typedef uint_least32_t result_type;
-
-public:
-    template<typename... Args>
-    seed_seq_from(Args&&... args) :
-        rng_(std::forward<Args>(args)...)
-    {
-        // Nothing (else) to do...
-    }
-
-    template<typename Iter>
-    void generate(Iter start, Iter finish)
-    {
-        for (auto i = start; i != finish; ++i)
-            *i = result_type(rng_());
-    }
-
-    constexpr size_t size() const
-    {
-        return (sizeof(typename RngType::result_type) > sizeof(result_type)
-                && RngType::max() > ~size_t(0UL))
-             ? ~size_t(0UL)
-             : size_t(RngType::max());
-    }
-};
-
-/*
- * Sometimes you might want a distinct seed based on when the program
- * was compiled.  That way, a particular instance of the program will
- * behave the same way, but when recompiled it'll produce a different
- * value.
- */
-
-template <typename IntType>
-struct static_arbitrary_seed {
-private:
-    static constexpr IntType fnv(IntType hash, const char* pos) {
-        return *pos == '\0'
-             ? hash
-             : fnv((hash * IntType(16777619U)) ^ *pos, (pos+1));
-    }
-
-public:
-    static constexpr IntType value = fnv(IntType(2166136261U ^ sizeof(IntType)),
-                        __DATE__ __TIME__ __FILE__);
-};
-
-// Sometimes, when debugging or testing, it's handy to be able print the name
-// of a (in human-readable form).  This code allows the idiom:
-//
-//      cout << printable_typename<my_foo_type_t>()
-//
-// to print out my_foo_type_t (or its concrete type if it is a synonym)
-
-#if __cpp_rtti || __GXX_RTTI
-
-template <typename T>
-struct printable_typename {};
-
-template <typename T>
-std::ostream& operator<<(std::ostream& out, printable_typename<T>) {
-    const char *implementation_typename = typeid(T).name();
-#ifdef __GNUC__
-    int status;
-    char* pretty_name =
-        abi::__cxa_demangle(implementation_typename, nullptr, nullptr, &status);
-    if (status == 0)
-        out << pretty_name;
-    free(static_cast<void*>(pretty_name));
-    if (status == 0)
-        return out;
-#endif
-    out << implementation_typename;
-    return out;
-}
-
-#endif  // __cpp_rtti || __GXX_RTTI
-
-} // namespace pcg_extras
-
-#endif // PCG_EXTRAS_HPP_INCLUDED
diff --git a/src/duckdb/third_party/pcg/pcg_random.hpp b/src/duckdb/third_party/pcg/pcg_random.hpp
deleted file mode 100644
index f4f5969c6..000000000
--- a/src/duckdb/third_party/pcg/pcg_random.hpp
+++ /dev/null
@@ -1,1955 +0,0 @@
-/*
- * PCG Random Number Generation for C++
- *
- * Copyright 2014-2019 Melissa O'Neill <oneill@pcg-random.org>,
- *                     and the PCG Project contributors.
- *
- * SPDX-License-Identifier: (Apache-2.0 OR MIT)
- *
- * Licensed under the Apache License, Version 2.0 (provided in
- * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
- * or under the MIT license (provided in LICENSE-MIT.txt and at
- * http://opensource.org/licenses/MIT), at your option. This file may not
- * be copied, modified, or distributed except according to those terms.
- *
- * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
- * express or implied.  See your chosen license for details.
- *
- * For additional information about the PCG random number generation scheme,
- * visit http://www.pcg-random.org/.
- */
-
-/*
- * This code provides the reference implementation of the PCG family of
- * random number generators.  The code is complex because it implements
- *
- *      - several members of the PCG family, specifically members corresponding
- *        to the output functions:
- *             - XSH RR         (good for 64-bit state, 32-bit output)
- *             - XSH RS         (good for 64-bit state, 32-bit output)
- *             - XSL RR         (good for 128-bit state, 64-bit output)
- *             - RXS M XS       (statistically most powerful generator)
- *             - XSL RR RR      (good for 128-bit state, 128-bit output)
- *             - and RXS, RXS M, XSH, XSL       (mostly for testing)
- *      - at potentially *arbitrary* bit sizes
- *      - with four different techniques for random streams (MCG, one-stream
- *        LCG, settable-stream LCG, unique-stream LCG)
- *      - and the extended generation schemes allowing arbitrary periods
- *      - with all features of C++11 random number generation (and more),
- *        some of which are somewhat painful, including
- *            - initializing with a SeedSequence which writes 32-bit values
- *              to memory, even though the state of the generator may not
- *              use 32-bit values (it might use smaller or larger integers)
- *            - I/O for RNGs and a prescribed format, which needs to handle
- *              the issue that 8-bit and 128-bit integers don't have working
- *              I/O routines (e.g., normally 8-bit = char, not integer)
- *            - equality and inequality for RNGs
- *      - and a number of convenience typedefs to mask all the complexity
- *
- * The code employes a fairly heavy level of abstraction, and has to deal
- * with various C++ minutia.  If you're looking to learn about how the PCG
- * scheme works, you're probably best of starting with one of the other
- * codebases (see www.pcg-random.org).  But if you're curious about the
- * constants for the various output functions used in those other, simpler,
- * codebases, this code shows how they are calculated.
- *
- * On the positive side, at least there are convenience typedefs so that you
- * can say
- *
- *      pcg32 myRNG;
- *
- * rather than:
- *
- *      pcg_detail::engine<
- *          uint32_t,                                           // Output Type
- *          uint64_t,                                           // State Type
- *          pcg_detail::xsh_rr_mixin<uint32_t, uint64_t>, true, // Output Func
- *          pcg_detail::specific_stream<uint64_t>,              // Stream Kind
- *          pcg_detail::default_multiplier<uint64_t>            // LCG Mult
- *      > myRNG;
- *
- */
-
-#ifndef PCG_RAND_HPP_INCLUDED
-#define PCG_RAND_HPP_INCLUDED 1
-
-#include <algorithm>
-#include <cinttypes>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-#include <limits>
-#include <iostream>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-#include <locale>
-#include <new>
-#include <stdexcept>
-
-#ifdef _MSC_VER
-    #pragma warning(disable:4146)
-#endif
-
-#ifdef _MSC_VER
-    #define PCG_ALWAYS_INLINE __forceinline
-#elif __GNUC__
-    #define PCG_ALWAYS_INLINE __attribute__((always_inline))
-#else
-    #define PCG_ALWAYS_INLINE inline
-#endif
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-/*
- * The pcg_extras namespace contains some support code that is likley to
- * be useful for a variety of RNGs, including:
- *      - 128-bit int support for platforms where it isn't available natively
- *      - bit twiddling operations
- *      - I/O of 128-bit and 8-bit integers
- *      - Handling the evilness of SeedSeq
- *      - Support for efficiently producing random numbers less than a given
- *        bound
- */
-
-#include "pcg_extras.hpp"
-
-namespace pcg_detail {
-
-using namespace pcg_extras;
-
-/*
- * The LCG generators need some constants to function.  This code lets you
- * look up the constant by *type*.  For example
- *
- *      default_multiplier<uint32_t>::multiplier()
- *
- * gives you the default multipler for 32-bit integers.  We use the name
- * of the constant and not a generic word like value to allow these classes
- * to be used as mixins.
- */
-
-template <typename T>
-struct default_multiplier {
-    // Not defined for an arbitrary type
-};
-
-template <typename T>
-struct default_increment {
-    // Not defined for an arbitrary type
-};
-
-#define PCG_DEFINE_CONSTANT(type, what, kind, constant) \
-        template <>                                     \
-        struct what ## _ ## kind<type> {                \
-            static constexpr type kind() {              \
-                return constant;                        \
-            }                                           \
-        };
-
-PCG_DEFINE_CONSTANT(uint8_t,  default, multiplier, 141U)
-PCG_DEFINE_CONSTANT(uint8_t,  default, increment,  77U)
-
-PCG_DEFINE_CONSTANT(uint16_t, default, multiplier, 12829U)
-PCG_DEFINE_CONSTANT(uint16_t, default, increment,  47989U)
-
-PCG_DEFINE_CONSTANT(uint32_t, default, multiplier, 747796405U)
-PCG_DEFINE_CONSTANT(uint32_t, default, increment,  2891336453U)
-
-PCG_DEFINE_CONSTANT(uint64_t, default, multiplier, 6364136223846793005ULL)
-PCG_DEFINE_CONSTANT(uint64_t, default, increment,  1442695040888963407ULL)
-
-PCG_DEFINE_CONSTANT(pcg128_t, default, multiplier,
-        PCG_128BIT_CONSTANT(2549297995355413924ULL,4865540595714422341ULL))
-PCG_DEFINE_CONSTANT(pcg128_t, default, increment,
-        PCG_128BIT_CONSTANT(6364136223846793005ULL,1442695040888963407ULL))
-
-/* Alternative (cheaper) multipliers for 128-bit */
-
-template <typename T>
-struct cheap_multiplier : public default_multiplier<T> {
-    // For most types just use the default.
-};
-
-template <>
-struct cheap_multiplier<pcg128_t> {
-    static constexpr uint64_t multiplier() {
-        return 0xda942042e4dd58b5ULL;
-    }
-};
-
-
-/*
- * Each PCG generator is available in four variants, based on how it applies
- * the additive constant for its underlying LCG; the variations are:
- *
- *     single stream   - all instances use the same fixed constant, thus
- *                       the RNG always somewhere in same sequence
- *     mcg             - adds zero, resulting in a single stream and reduced
- *                       period
- *     specific stream - the constant can be changed at any time, selecting
- *                       a different random sequence
- *     unique stream   - the constant is based on the memory address of the
- *                       object, thus every RNG has its own unique sequence
- *
- * This variation is provided though mixin classes which define a function
- * value called increment() that returns the nesessary additive constant.
- */
-
-
-
-/*
- * unique stream
- */
-
-
-template <typename itype>
-class unique_stream {
-protected:
-    static constexpr bool is_mcg = false;
-
-    // Is never called, but is provided for symmetry with specific_stream
-    void set_stream(...)
-    {
-        abort();
-    }
-
-public:
-    typedef itype state_type;
-
-    constexpr itype increment() const {
-        return itype(reinterpret_cast<uintptr_t>(this) | 1);
-    }
-
-    constexpr itype stream() const
-    {
-         return increment() >> 1;
-    }
-
-    static constexpr bool can_specify_stream = false;
-
-    static constexpr size_t streams_pow2()
-    {
-        return (sizeof(itype) < sizeof(size_t) ? sizeof(itype)
-                                               : sizeof(size_t))*8 - 1u;
-    }
-
-protected:
-    constexpr unique_stream() = default;
-};
-
-
-/*
- * no stream (mcg)
- */
-
-template <typename itype>
-class no_stream {
-protected:
-    static constexpr bool is_mcg = true;
-
-    // Is never called, but is provided for symmetry with specific_stream
-    void set_stream(...)
-    {
-        abort();
-    }
-
-public:
-    typedef itype state_type;
-
-    static constexpr itype increment() {
-        return 0;
-    }
-
-    static constexpr bool can_specify_stream = false;
-
-    static constexpr size_t streams_pow2()
-    {
-        return 0u;
-    }
-
-protected:
-    constexpr no_stream() = default;
-};
-
-
-/*
- * single stream/sequence (oneseq)
- */
-
-template <typename itype>
-class oneseq_stream : public default_increment<itype> {
-protected:
-    static constexpr bool is_mcg = false;
-
-    // Is never called, but is provided for symmetry with specific_stream
-    void set_stream(...)
-    {
-        abort();
-    }
-
-public:
-    typedef itype state_type;
-
-    static constexpr itype stream()
-    {
-         return default_increment<itype>::increment() >> 1;
-    }
-
-    static constexpr bool can_specify_stream = false;
-
-    static constexpr size_t streams_pow2()
-    {
-        return 0u;
-    }
-
-protected:
-    constexpr oneseq_stream() = default;
-};
-
-
-/*
- * specific stream
- */
-
-template <typename itype>
-class specific_stream {
-protected:
-    static constexpr bool is_mcg = false;
-
-    itype inc_ = default_increment<itype>::increment();
-
-public:
-    typedef itype state_type;
-    typedef itype stream_state;
-
-    constexpr itype increment() const {
-        return inc_;
-    }
-
-    itype stream()
-    {
-         return inc_ >> 1;
-    }
-
-    void set_stream(itype specific_seq)
-    {
-         inc_ = (specific_seq << 1) | 1;
-    }
-
-    static constexpr bool can_specify_stream = true;
-
-    static constexpr size_t streams_pow2()
-    {
-        return (sizeof(itype)*8) - 1u;
-    }
-
-protected:
-    specific_stream() = default;
-
-    specific_stream(itype specific_seq)
-        : inc_(itype(specific_seq << 1) | itype(1U))
-    {
-        // Nothing (else) to do.
-    }
-};
-
-
-/*
- * This is where it all comes together.  This function joins together three
- * mixin classes which define
- *    - the LCG additive constant (the stream)
- *    - the LCG multiplier
- *    - the output function
- * in addition, we specify the type of the LCG state, and the result type,
- * and whether to use the pre-advance version of the state for the output
- * (increasing instruction-level parallelism) or the post-advance version
- * (reducing register pressure).
- *
- * Given the high level of parameterization, the code has to use some
- * template-metaprogramming tricks to handle some of the suble variations
- * involved.
- */
-
-template <typename xtype, typename itype,
-          typename output_mixin,
-          bool output_previous = true,
-          typename stream_mixin = oneseq_stream<itype>,
-          typename multiplier_mixin = default_multiplier<itype> >
-class engine : protected output_mixin,
-               public stream_mixin,
-               protected multiplier_mixin {
-protected:
-    itype state_;
-
-    struct can_specify_stream_tag {};
-    struct no_specifiable_stream_tag {};
-
-    using stream_mixin::increment;
-    using multiplier_mixin::multiplier;
-
-public:
-    typedef xtype result_type;
-    typedef itype state_type;
-
-    static constexpr size_t period_pow2()
-    {
-        return sizeof(state_type)*8 - 2*stream_mixin::is_mcg;
-    }
-
-    // It would be nice to use std::numeric_limits for these, but
-    // we can't be sure that it'd be defined for the 128-bit types.
-
-    static constexpr result_type min()
-    {
-        return result_type(0UL);
-    }
-
-    static constexpr result_type max()
-    {
-        return result_type(~result_type(0UL));
-    }
-
-protected:
-    itype bump(itype state)
-    {
-        return state * multiplier() + increment();
-    }
-
-    itype base_generate()
-    {
-        return state_ = bump(state_);
-    }
-
-    itype base_generate0()
-    {
-        itype old_state = state_;
-        state_ = bump(state_);
-        return old_state;
-    }
-
-public:
-    result_type operator()()
-    {
-        if (output_previous)
-            return this->output(base_generate0());
-        else
-            return this->output(base_generate());
-    }
-
-    result_type operator()(result_type upper_bound)
-    {
-        return bounded_rand(*this, upper_bound);
-    }
-
-protected:
-    static itype advance(itype state, itype delta,
-                         itype cur_mult, itype cur_plus);
-
-    static itype distance(itype cur_state, itype newstate, itype cur_mult,
-                          itype cur_plus, itype mask = ~itype(0U));
-
-    itype distance(itype newstate, itype mask = itype(~itype(0U))) const
-    {
-        return distance(state_, newstate, multiplier(), increment(), mask);
-    }
-
-public:
-    void advance(itype delta)
-    {
-        state_ = advance(state_, delta, this->multiplier(), this->increment());
-    }
-
-    void backstep(itype delta)
-    {
-        advance(-delta);
-    }
-
-    void discard(itype delta)
-    {
-        advance(delta);
-    }
-
-    bool wrapped()
-    {
-        if (stream_mixin::is_mcg) {
-            // For MCGs, the low order two bits never change. In this
-            // implementation, we keep them fixed at 3 to make this test
-            // easier.
-            return state_ == 3;
-        } else {
-            return state_ == 0;
-        }
-    }
-
-    engine(itype state = itype(0xcafef00dd15ea5e5ULL))
-        : state_(this->is_mcg ? state|state_type(3U)
-                              : bump(state + this->increment()))
-    {
-        // Nothing else to do.
-    }
-
-    // This function may or may not exist.  It thus has to be a template
-    // to use SFINAE; users don't have to worry about its template-ness.
-
-    template <typename sm = stream_mixin>
-    engine(itype state, typename sm::stream_state stream_seed)
-        : stream_mixin(stream_seed),
-          state_(this->is_mcg ? state|state_type(3U)
-                              : bump(state + this->increment()))
-    {
-        // Nothing else to do.
-    }
-
-    template<typename SeedSeq>
-    engine(SeedSeq&& seedSeq, typename std::enable_if<
-                  !stream_mixin::can_specify_stream
-               && !std::is_convertible<SeedSeq, itype>::value
-               && !std::is_convertible<SeedSeq, engine>::value,
-               no_specifiable_stream_tag>::type = {})
-        : engine(generate_one<itype>(std::forward<SeedSeq>(seedSeq)))
-    {
-        // Nothing else to do.
-    }
-
-    template<typename SeedSeq>
-    engine(SeedSeq&& seedSeq, typename std::enable_if<
-                   stream_mixin::can_specify_stream
-               && !std::is_convertible<SeedSeq, itype>::value
-               && !std::is_convertible<SeedSeq, engine>::value,
-        can_specify_stream_tag>::type = {})
-        : engine(generate_one<itype,1,2>(seedSeq),
-                 generate_one<itype,0,2>(seedSeq))
-    {
-        // Nothing else to do.
-    }
-
-
-    template<typename... Args>
-    void seed(Args&&... args)
-    {
-        new (this) engine(std::forward<Args>(args)...);
-    }
-
-    template <typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-    friend bool operator==(const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
-                           const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
-
-    template <typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-    friend itype1 operator-(const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
-                            const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
-
-    template <typename CharT, typename Traits,
-              typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin1, typename multiplier_mixin1>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& out,
-               const engine<xtype1,itype1,
-                              output_mixin1,output_previous1,
-                              stream_mixin1, multiplier_mixin1>&);
-
-    template <typename CharT, typename Traits,
-              typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin1, typename multiplier_mixin1>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& in,
-               engine<xtype1, itype1,
-                        output_mixin1, output_previous1,
-                        stream_mixin1, multiplier_mixin1>& rng);
-};
-
-template <typename CharT, typename Traits,
-          typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>& out,
-           const engine<xtype,itype,
-                          output_mixin,output_previous,
-                          stream_mixin, multiplier_mixin>& rng)
-{
-    using pcg_extras::operator<<;
-
-    auto orig_flags = out.flags(std::ios_base::dec | std::ios_base::left);
-    auto space = out.widen(' ');
-    auto orig_fill = out.fill();
-
-    out << rng.multiplier() << space
-        << rng.increment() << space
-        << rng.state_;
-
-    out.flags(orig_flags);
-    out.fill(orig_fill);
-    return out;
-}
-
-
-template <typename CharT, typename Traits,
-          typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in,
-           engine<xtype,itype,
-                    output_mixin,output_previous,
-                    stream_mixin, multiplier_mixin>& rng)
-{
-    using pcg_extras::operator>>;
-
-    auto orig_flags = in.flags(std::ios_base::dec | std::ios_base::skipws);
-
-    itype multiplier, increment, state;
-    in >> multiplier >> increment >> state;
-
-    if (!in.fail()) {
-        bool good = true;
-        if (multiplier != rng.multiplier()) {
-           good = false;
-        } else if (rng.can_specify_stream) {
-           rng.set_stream(increment >> 1);
-        } else if (increment != rng.increment()) {
-           good = false;
-        }
-        if (good) {
-            rng.state_ = state;
-        } else {
-            in.clear(std::ios::failbit);
-        }
-    }
-
-    in.flags(orig_flags);
-    return in;
-}
-
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
-             multiplier_mixin>::advance(
-    itype state, itype delta, itype cur_mult, itype cur_plus)
-{
-    // The method used here is based on Brown, "Random Number Generation
-    // with Arbitrary Stride,", Transactions of the American Nuclear
-    // Society (Nov. 1994).  The algorithm is very similar to fast
-    // exponentiation.
-    //
-    // Even though delta is an unsigned integer, we can pass a
-    // signed integer to go backwards, it just goes "the long way round".
-
-    constexpr itype ZERO = 0u;  // itype may be a non-trivial types, so
-    constexpr itype ONE  = 1u;  // we define some ugly constants.
-    itype acc_mult = 1;
-    itype acc_plus = 0;
-    while (delta > ZERO) {
-       if (delta & ONE) {
-          acc_mult *= cur_mult;
-          acc_plus = acc_plus*cur_mult + cur_plus;
-       }
-       cur_plus = (cur_mult+ONE)*cur_plus;
-       cur_mult *= cur_mult;
-       delta >>= 1;
-    }
-    return acc_mult * state + acc_plus;
-}
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
-               multiplier_mixin>::distance(
-    itype cur_state, itype newstate, itype cur_mult, itype cur_plus, itype mask)
-{
-    constexpr itype ONE  = 1u;  // itype could be weird, so use constant
-    bool is_mcg = cur_plus == itype(0);
-    itype the_bit = is_mcg ? itype(4u) : itype(1u);
-    itype distance = 0u;
-    while ((cur_state & mask) != (newstate & mask)) {
-       if ((cur_state & the_bit) != (newstate & the_bit)) {
-           cur_state = cur_state * cur_mult + cur_plus;
-           distance |= the_bit;
-       }
-       assert((cur_state & the_bit) == (newstate & the_bit));
-       the_bit <<= 1;
-       cur_plus = (cur_mult+ONE)*cur_plus;
-       cur_mult *= cur_mult;
-    }
-    return is_mcg ? distance >> 2 : distance;
-}
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-itype operator-(const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
-               const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
-{
-    static_assert(
-        std::is_same<stream_mixin_lhs, stream_mixin_rhs>::value &&
-            std::is_same<multiplier_mixin_lhs, multiplier_mixin_rhs>::value,
-        "Incomparable generators");
-    if (lhs.increment() == rhs.increment()) {
-       return rhs.distance(lhs.state_);
-    } else  {
-       constexpr itype ONE = 1u;
-       itype lhs_diff = lhs.increment() + (lhs.multiplier()-ONE) * lhs.state_;
-       itype rhs_diff = rhs.increment() + (rhs.multiplier()-ONE) * rhs.state_;
-       if ((lhs_diff & itype(3u)) != (rhs_diff & itype(3u))) {
-           rhs_diff = -rhs_diff;
-       }
-       return rhs.distance(rhs_diff, lhs_diff, rhs.multiplier(), itype(0u));
-    }
-}
-
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-bool operator==(const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
-                const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
-{
-    return    (lhs.multiplier() == rhs.multiplier())
-           && (lhs.increment()  == rhs.increment())
-           && (lhs.state_       == rhs.state_);
-}
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-inline bool operator!=(const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
-                       const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
-{
-    return !operator==(lhs,rhs);
-}
-
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using oneseq_base  = engine<xtype, itype,
-                        output_mixin<xtype, itype>, output_previous,
-                        oneseq_stream<itype>,
-                        multiplier_mixin<itype> >;
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using unique_base = engine<xtype, itype,
-                         output_mixin<xtype, itype>, output_previous,
-                         unique_stream<itype>,
-                         multiplier_mixin<itype> >;
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using setseq_base = engine<xtype, itype,
-                         output_mixin<xtype, itype>, output_previous,
-                         specific_stream<itype>,
-                         multiplier_mixin<itype> >;
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using mcg_base = engine<xtype, itype,
-                      output_mixin<xtype, itype>, output_previous,
-                      no_stream<itype>,
-                      multiplier_mixin<itype> >;
-
-/*
- * OUTPUT FUNCTIONS.
- *
- * These are the core of the PCG generation scheme.  They specify how to
- * turn the base LCG's internal state into the output value of the final
- * generator.
- *
- * They're implemented as mixin classes.
- *
- * All of the classes have code that is written to allow it to be applied
- * at *arbitrary* bit sizes, although in practice they'll only be used at
- * standard sizes supported by C++.
- */
-
-/*
- * XSH RS -- high xorshift, followed by a random shift
- *
- * Fast.  A good performer.
- */
-
-template <typename xtype, typename itype>
-struct xsh_rs_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t sparebits   = bits - xtypebits;
-        constexpr bitcount_t opbits =
-                              sparebits-5 >= 64 ? 5
-                            : sparebits-4 >= 32 ? 4
-                            : sparebits-3 >= 16 ? 3
-                            : sparebits-2 >= 4  ? 2
-                            : sparebits-1 >= 1  ? 1
-                            :                     0;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t maxrandshift  = mask;
-        constexpr bitcount_t topspare     = opbits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift     = topspare + (xtypebits+maxrandshift)/2;
-        bitcount_t rshift =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        internal ^= internal >> xshift;
-        xtype result = xtype(internal >> (bottomspare - maxrandshift + rshift));
-        return result;
-    }
-};
-
-/*
- * XSH RR -- high xorshift, followed by a random rotate
- *
- * Fast.  A good performer.  Slightly better statistically than XSH RS.
- */
-
-template <typename xtype, typename itype>
-struct xsh_rr_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
-        constexpr bitcount_t sparebits   = bits - xtypebits;
-        constexpr bitcount_t wantedopbits =
-                              xtypebits >= 128 ? 7
-                            : xtypebits >=  64 ? 6
-                            : xtypebits >=  32 ? 5
-                            : xtypebits >=  16 ? 4
-                            :                    3;
-        constexpr bitcount_t opbits =
-                              sparebits >= wantedopbits ? wantedopbits
-                                                        : sparebits;
-        constexpr bitcount_t amplifier = wantedopbits - opbits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t topspare    = opbits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift      = (topspare + xtypebits)/2;
-        bitcount_t rot = opbits ? bitcount_t(internal >> (bits - opbits)) & mask
-                                : 0;
-        bitcount_t amprot = (rot << amplifier) & mask;
-        internal ^= internal >> xshift;
-        xtype result = xtype(internal >> bottomspare);
-        result = rotr(result, amprot);
-        return result;
-    }
-};
-
-/*
- * RXS -- random xorshift
- */
-
-template <typename xtype, typename itype>
-struct rxs_mixin {
-static xtype output_rxs(itype internal)
-    {
-        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
-        constexpr bitcount_t shift       = bits - xtypebits;
-        constexpr bitcount_t extrashift  = (xtypebits - shift)/2;
-        bitcount_t rshift = shift > 64+8 ? (internal >> (bits - 6)) & 63
-                       : shift > 32+4 ? (internal >> (bits - 5)) & 31
-                       : shift > 16+2 ? (internal >> (bits - 4)) & 15
-                       : shift >  8+1 ? (internal >> (bits - 3)) & 7
-                       : shift >  4+1 ? (internal >> (bits - 2)) & 3
-                       : shift >  2+1 ? (internal >> (bits - 1)) & 1
-                       :              0;
-        internal ^= internal >> (shift + extrashift - rshift);
-        xtype result = internal >> rshift;
-        return result;
-    }
-};
-
-/*
- * RXS M XS -- random xorshift, mcg multiply, fixed xorshift
- *
- * The most statistically powerful generator, but all those steps
- * make it slower than some of the others.  We give it the rottenest jobs.
- *
- * Because it's usually used in contexts where the state type and the
- * result type are the same, it is a permutation and is thus invertable.
- * We thus provide a function to invert it.  This function is used to
- * for the "inside out" generator used by the extended generator.
- */
-
-/* Defined type-based concepts for the multiplication step.  They're actually
- * all derived by truncating the 128-bit, which was computed to be a good
- * "universal" constant.
- */
-
-template <typename T>
-struct mcg_multiplier {
-    // Not defined for an arbitrary type
-};
-
-template <typename T>
-struct mcg_unmultiplier {
-    // Not defined for an arbitrary type
-};
-
-PCG_DEFINE_CONSTANT(uint8_t,  mcg, multiplier,   217U)
-PCG_DEFINE_CONSTANT(uint8_t,  mcg, unmultiplier, 105U)
-
-PCG_DEFINE_CONSTANT(uint16_t, mcg, multiplier,   62169U)
-PCG_DEFINE_CONSTANT(uint16_t, mcg, unmultiplier, 28009U)
-
-PCG_DEFINE_CONSTANT(uint32_t, mcg, multiplier,   277803737U)
-PCG_DEFINE_CONSTANT(uint32_t, mcg, unmultiplier, 2897767785U)
-
-PCG_DEFINE_CONSTANT(uint64_t, mcg, multiplier,   12605985483714917081ULL)
-PCG_DEFINE_CONSTANT(uint64_t, mcg, unmultiplier, 15009553638781119849ULL)
-
-PCG_DEFINE_CONSTANT(pcg128_t, mcg, multiplier,
-        PCG_128BIT_CONSTANT(17766728186571221404ULL, 12605985483714917081ULL))
-PCG_DEFINE_CONSTANT(pcg128_t, mcg, unmultiplier,
-        PCG_128BIT_CONSTANT(14422606686972528997ULL, 15009553638781119849ULL))
-
-
-template <typename xtype, typename itype>
-struct rxs_m_xs_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
-                                 : xtypebits >=  64 ? 5
-                                 : xtypebits >=  32 ? 4
-                                 : xtypebits >=  16 ? 3
-                                 :                    2;
-        constexpr bitcount_t shift = bits - xtypebits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        bitcount_t rshift =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        internal ^= internal >> (opbits + rshift);
-        internal *= mcg_multiplier<itype>::multiplier();
-        xtype result = internal >> shift;
-        result ^= result >> ((2U*xtypebits+2U)/3U);
-        return result;
-    }
-
-    static itype unoutput(itype internal)
-    {
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t opbits = bits >= 128 ? 6
-                                 : bits >=  64 ? 5
-                                 : bits >=  32 ? 4
-                                 : bits >=  16 ? 3
-                                 :               2;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-
-        internal = unxorshift(internal, bits, (2U*bits+2U)/3U);
-
-        internal *= mcg_unmultiplier<itype>::unmultiplier();
-
-        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
-        internal = unxorshift(internal, bits, opbits + rshift);
-
-        return internal;
-    }
-};
-
-
-/*
- * RXS M -- random xorshift, mcg multiply
- */
-
-template <typename xtype, typename itype>
-struct rxs_m_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
-                                 : xtypebits >=  64 ? 5
-                                 : xtypebits >=  32 ? 4
-                                 : xtypebits >=  16 ? 3
-                                 :                    2;
-        constexpr bitcount_t shift = bits - xtypebits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
-        internal ^= internal >> (opbits + rshift);
-        internal *= mcg_multiplier<itype>::multiplier();
-        xtype result = internal >> shift;
-        return result;
-    }
-};
-
-
-/*
- * DXSM -- double xorshift multiply
- *
- * This is a new, more powerful output permutation (added in 2019).  It's
- * a more comprehensive scrambling than RXS M, but runs faster on 128-bit
- * types.  Although primarily intended for use at large sizes, also works
- * at smaller sizes as well.
- *
- * This permutation is similar to xorshift multiply hash functions, except
- * that one of the multipliers is the LCG multiplier (to avoid needing to
- * have a second constant) and the other is based on the low-order bits.
- * This latter aspect means that the scrambling applied to the high bits
- * depends on the low bits, and makes it (to my eye) impractical to back
- * out the permutation without having the low-order bits.
- */
-
-template <typename xtype, typename itype>
-struct dxsm_mixin {
-    inline xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t itypebits = bitcount_t(sizeof(itype) * 8);
-        static_assert(xtypebits <= itypebits/2,
-                      "Output type must be half the size of the state type.");
-
-        xtype hi = xtype(internal >> (itypebits - xtypebits));
-        xtype lo = xtype(internal);
-
-        lo |= 1;
-        hi ^= hi >> (xtypebits/2);
-	hi *= xtype(cheap_multiplier<itype>::multiplier());
-	hi ^= hi >> (3*(xtypebits/4));
-	hi *= lo;
-	return hi;
-    }
-};
-
-
-/*
- * XSL RR -- fixed xorshift (to low bits), random rotate
- *
- * Useful for 128-bit types that are split across two CPU registers.
- */
-
-template <typename xtype, typename itype>
-struct xsl_rr_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - xtypebits;
-        constexpr bitcount_t wantedopbits = xtypebits >= 128 ? 7
-                                       : xtypebits >=  64 ? 6
-                                       : xtypebits >=  32 ? 5
-                                       : xtypebits >=  16 ? 4
-                                       :                    3;
-        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
-                                                             : sparebits;
-        constexpr bitcount_t amplifier = wantedopbits - opbits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t topspare = sparebits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
-
-        bitcount_t rot =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        bitcount_t amprot = (rot << amplifier) & mask;
-        internal ^= internal >> xshift;
-        xtype result = xtype(internal >> bottomspare);
-        result = rotr(result, amprot);
-        return result;
-    }
-};
-
-
-/*
- * XSL RR RR -- fixed xorshift (to low bits), random rotate (both parts)
- *
- * Useful for 128-bit types that are split across two CPU registers.
- * If you really want an invertable 128-bit RNG, I guess this is the one.
- */
-
-template <typename T> struct halfsize_trait {};
-template <> struct halfsize_trait<pcg128_t>  { typedef uint64_t type; };
-template <> struct halfsize_trait<uint64_t>  { typedef uint32_t type; };
-template <> struct halfsize_trait<uint32_t>  { typedef uint16_t type; };
-template <> struct halfsize_trait<uint16_t>  { typedef uint8_t type;  };
-
-template <typename xtype, typename itype>
-struct xsl_rr_rr_mixin {
-    typedef typename halfsize_trait<itype>::type htype;
-
-    static itype output(itype internal)
-    {
-        constexpr bitcount_t htypebits = bitcount_t(sizeof(htype) * 8);
-        constexpr bitcount_t bits      = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - htypebits;
-        constexpr bitcount_t wantedopbits = htypebits >= 128 ? 7
-                                       : htypebits >=  64 ? 6
-                                       : htypebits >=  32 ? 5
-                                       : htypebits >=  16 ? 4
-                                       :                    3;
-        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
-                                                                : sparebits;
-        constexpr bitcount_t amplifier = wantedopbits - opbits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t topspare = sparebits;
-        constexpr bitcount_t xshift = (topspare + htypebits) / 2;
-
-        bitcount_t rot =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        bitcount_t amprot = (rot << amplifier) & mask;
-        internal ^= internal >> xshift;
-        htype lowbits = htype(internal);
-        lowbits = rotr(lowbits, amprot);
-        htype highbits = htype(internal >> topspare);
-        bitcount_t rot2 = lowbits & mask;
-        bitcount_t amprot2 = (rot2 << amplifier) & mask;
-        highbits = rotr(highbits, amprot2);
-        return (itype(highbits) << topspare) ^ itype(lowbits);
-    }
-};
-
-
-/*
- * XSH -- fixed xorshift (to high bits)
- *
- * You shouldn't use this at 64-bits or less.
- */
-
-template <typename xtype, typename itype>
-struct xsh_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - xtypebits;
-        constexpr bitcount_t topspare = 0;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
-
-        internal ^= internal >> xshift;
-        xtype result = internal >> bottomspare;
-        return result;
-    }
-};
-
-/*
- * XSL -- fixed xorshift (to low bits)
- *
- * You shouldn't use this at 64-bits or less.
- */
-
-template <typename xtype, typename itype>
-struct xsl_mixin {
-    inline xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - xtypebits;
-        constexpr bitcount_t topspare = sparebits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
-
-        internal ^= internal >> xshift;
-        xtype result = internal >> bottomspare;
-        return result;
-    }
-};
-
-
-/* ---- End of Output Functions ---- */
-
-
-template <typename baseclass>
-struct inside_out : private baseclass {
-    inside_out() = delete;
-
-    typedef typename baseclass::result_type result_type;
-    typedef typename baseclass::state_type  state_type;
-    static_assert(sizeof(result_type) == sizeof(state_type),
-                  "Require a RNG whose output function is a permutation");
-
-    static bool external_step(result_type& randval, size_t i)
-    {
-        state_type state = baseclass::unoutput(randval);
-        state = state * baseclass::multiplier() + baseclass::increment()
-                + state_type(i*2);
-        result_type result = baseclass::output(state);
-        randval = result;
-        state_type zero =
-            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
-        return result == zero;
-    }
-
-    static bool external_advance(result_type& randval, size_t i,
-                                 result_type delta, bool forwards = true)
-    {
-        state_type state = baseclass::unoutput(randval);
-        state_type mult  = baseclass::multiplier();
-        state_type inc   = baseclass::increment() + state_type(i*2);
-        state_type zero =
-            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
-        state_type dist_to_zero = baseclass::distance(state, zero, mult, inc);
-        bool crosses_zero =
-            forwards ? dist_to_zero <= delta
-                     : (-dist_to_zero) <= delta;
-        if (!forwards)
-            delta = -delta;
-        state = baseclass::advance(state, delta, mult, inc);
-        randval = baseclass::output(state);
-        return crosses_zero;
-    }
-};
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass, typename extvalclass, bool kdd = true>
-class pcg_extended : public baseclass {
-public:
-    typedef typename baseclass::state_type  state_type;
-    typedef typename baseclass::result_type result_type;
-    typedef inside_out<extvalclass> insideout;
-
-private:
-    static constexpr bitcount_t rtypebits = sizeof(result_type)*8;
-    static constexpr bitcount_t stypebits = sizeof(state_type)*8;
-
-    static constexpr bitcount_t tick_limit_pow2 = 64U;
-
-    static constexpr size_t table_size  = 1UL << table_pow2;
-    static constexpr size_t table_shift = stypebits - table_pow2;
-    static constexpr state_type table_mask =
-        (state_type(1U) << table_pow2) - state_type(1U);
-
-    static constexpr bool   may_tick  =
-        (advance_pow2 < stypebits) && (advance_pow2 < tick_limit_pow2);
-    static constexpr size_t tick_shift = stypebits - advance_pow2;
-    static constexpr state_type tick_mask  =
-        may_tick ? state_type(
-                       (uint64_t(1) << (advance_pow2*may_tick)) - 1)
-                                        // ^-- stupidity to appease GCC warnings
-                 : ~state_type(0U);
-
-    static constexpr bool may_tock = stypebits < tick_limit_pow2;
-
-    result_type data_[table_size];
-
-    PCG_NOINLINE void advance_table();
-
-    PCG_NOINLINE void advance_table(state_type delta, bool isForwards = true);
-
-    result_type& get_extended_value()
-    {
-        state_type state = this->state_;
-        if (kdd && baseclass::is_mcg) {
-            // The low order bits of an MCG are constant, so drop them.
-            state >>= 2;
-        }
-        size_t index       = kdd ? state &  table_mask
-                                 : state >> table_shift;
-
-        if (may_tick) {
-            bool tick = kdd ? (state & tick_mask) == state_type(0u)
-                            : (state >> tick_shift) == state_type(0u);
-            if (tick)
-                    advance_table();
-        }
-        if (may_tock) {
-            bool tock = state == state_type(0u);
-            if (tock)
-                advance_table();
-        }
-        return data_[index];
-    }
-
-public:
-    static constexpr size_t period_pow2()
-    {
-        return baseclass::period_pow2() + table_size*extvalclass::period_pow2();
-    }
-
-    PCG_ALWAYS_INLINE result_type operator()()
-    {
-        result_type rhs = get_extended_value();
-        result_type lhs = this->baseclass::operator()();
-        return lhs ^ rhs;
-    }
-
-    result_type operator()(result_type upper_bound)
-    {
-        return bounded_rand(*this, upper_bound);
-    }
-
-    void set(result_type wanted)
-    {
-        result_type& rhs = get_extended_value();
-        result_type lhs = this->baseclass::operator()();
-        rhs = lhs ^ wanted;
-    }
-
-    void advance(state_type distance, bool forwards = true);
-
-    void backstep(state_type distance)
-    {
-        advance(distance, false);
-    }
-
-    pcg_extended(const result_type* data)
-        : baseclass()
-    {
-        datainit(data);
-    }
-
-    pcg_extended(const result_type* data, state_type seed)
-        : baseclass(seed)
-    {
-        datainit(data);
-    }
-
-    // This function may or may not exist.  It thus has to be a template
-    // to use SFINAE; users don't have to worry about its template-ness.
-
-    template <typename bc = baseclass>
-    pcg_extended(const result_type* data, state_type seed,
-            typename bc::stream_state stream_seed)
-        : baseclass(seed, stream_seed)
-    {
-        datainit(data);
-    }
-
-    pcg_extended()
-        : baseclass()
-    {
-        selfinit();
-    }
-
-    pcg_extended(state_type seed)
-        : baseclass(seed)
-    {
-        selfinit();
-    }
-
-    // This function may or may not exist.  It thus has to be a template
-    // to use SFINAE; users don't have to worry about its template-ness.
-
-    template <typename bc = baseclass>
-    pcg_extended(state_type seed, typename bc::stream_state stream_seed)
-        : baseclass(seed, stream_seed)
-    {
-        selfinit();
-    }
-
-private:
-    void selfinit();
-    void datainit(const result_type* data);
-
-public:
-
-    template<typename SeedSeq, typename = typename std::enable_if<
-           !std::is_convertible<SeedSeq, result_type>::value
-        && !std::is_convertible<SeedSeq, pcg_extended>::value>::type>
-    pcg_extended(SeedSeq&& seedSeq)
-        : baseclass(seedSeq)
-    {
-        generate_to<table_size>(seedSeq, data_);
-    }
-
-    template<typename... Args>
-    void seed(Args&&... args)
-    {
-        new (this) pcg_extended(std::forward<Args>(args)...);
-    }
-
-    template <bitcount_t table_pow2_, bitcount_t advance_pow2_,
-              typename baseclass_, typename extvalclass_, bool kdd_>
-    friend bool operator==(const pcg_extended<table_pow2_, advance_pow2_,
-                                              baseclass_, extvalclass_, kdd_>&,
-                           const pcg_extended<table_pow2_, advance_pow2_,
-                                              baseclass_, extvalclass_, kdd_>&);
-
-    template <typename CharT, typename Traits,
-              bitcount_t table_pow2_, bitcount_t advance_pow2_,
-              typename baseclass_, typename extvalclass_, bool kdd_>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& out,
-               const pcg_extended<table_pow2_, advance_pow2_,
-                              baseclass_, extvalclass_, kdd_>&);
-
-    template <typename CharT, typename Traits,
-              bitcount_t table_pow2_, bitcount_t advance_pow2_,
-              typename baseclass_, typename extvalclass_, bool kdd_>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& in,
-               pcg_extended<table_pow2_, advance_pow2_,
-                        baseclass_, extvalclass_, kdd_>&);
-
-};
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::datainit(
-         const result_type* data)
-{
-    for (size_t i = 0; i < table_size; ++i)
-        data_[i] = data[i];
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::selfinit()
-{
-    // We need to fill the extended table with something, and we have
-    // very little provided data, so we use the base generator to
-    // produce values.  Although not ideal (use a seed sequence, folks!),
-    // unexpected correlations are mitigated by
-    //      - using XOR differences rather than the number directly
-    //      - the way the table is accessed, its values *won't* be accessed
-    //        in the same order the were written.
-    //      - any strange correlations would only be apparent if we
-    //        were to backstep the generator so that the base generator
-    //        was generating the same values again
-    result_type lhs = baseclass::operator()();
-    result_type rhs = baseclass::operator()();
-    result_type xdiff = lhs - rhs;
-    for (size_t i = 0; i < table_size; ++i) {
-        data_[i] = baseclass::operator()() ^ xdiff;
-    }
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-bool operator==(const pcg_extended<table_pow2, advance_pow2,
-                               baseclass, extvalclass, kdd>& lhs,
-                const pcg_extended<table_pow2, advance_pow2,
-                               baseclass, extvalclass, kdd>& rhs)
-{
-    auto& base_lhs = static_cast<const baseclass&>(lhs);
-    auto& base_rhs = static_cast<const baseclass&>(rhs);
-    return base_lhs == base_rhs
-        && std::equal(
-               std::begin(lhs.data_), std::end(lhs.data_),
-               std::begin(rhs.data_)
-           );
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-inline bool operator!=(const pcg_extended<table_pow2, advance_pow2,
-                                      baseclass, extvalclass, kdd>& lhs,
-                       const pcg_extended<table_pow2, advance_pow2,
-                                      baseclass, extvalclass, kdd>& rhs)
-{
-    return !operator==(lhs, rhs);
-}
-
-template <typename CharT, typename Traits,
-          bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>& out,
-           const pcg_extended<table_pow2, advance_pow2,
-                          baseclass, extvalclass, kdd>& rng)
-{
-    auto orig_flags = out.flags(std::ios_base::dec | std::ios_base::left);
-    auto space = out.widen(' ');
-    auto orig_fill = out.fill();
-
-    out << rng.multiplier() << space
-        << rng.increment() << space
-        << rng.state_;
-
-    for (const auto& datum : rng.data_)
-        out << space << datum;
-
-    out.flags(orig_flags);
-    out.fill(orig_fill);
-    return out;
-}
-
-template <typename CharT, typename Traits,
-          bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in,
-           pcg_extended<table_pow2, advance_pow2,
-                    baseclass, extvalclass, kdd>& rng)
-{
-    pcg_extended<table_pow2, advance_pow2, baseclass, extvalclass> new_rng;
-    auto& base_rng = static_cast<baseclass&>(new_rng);
-    in >> base_rng;
-
-    if (in.fail())
-        return in;
-
-    auto orig_flags = in.flags(std::ios_base::dec | std::ios_base::skipws);
-
-    for (auto& datum : new_rng.data_) {
-        in >> datum;
-        if (in.fail())
-            goto bail;
-    }
-
-    rng = new_rng;
-
-bail:
-    in.flags(orig_flags);
-    return in;
-}
-
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void
-pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table()
-{
-    bool carry = false;
-    for (size_t i = 0; i < table_size; ++i) {
-        if (carry) {
-            carry = insideout::external_step(data_[i],i+1);
-        }
-        bool carry2 = insideout::external_step(data_[i],i+1);
-        carry = carry || carry2;
-    }
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void
-pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table(
-        state_type delta, bool isForwards)
-{
-    typedef typename baseclass::state_type   base_state_t;
-    typedef typename extvalclass::state_type ext_state_t;
-    constexpr bitcount_t basebits = sizeof(base_state_t)*8;
-    constexpr bitcount_t extbits  = sizeof(ext_state_t)*8;
-    static_assert(basebits <= extbits || advance_pow2 > 0,
-                  "Current implementation might overflow its carry");
-
-    base_state_t carry = 0;
-    for (size_t i = 0; i < table_size; ++i) {
-        base_state_t total_delta = carry + delta;
-        ext_state_t  trunc_delta = ext_state_t(total_delta);
-        if (basebits > extbits) {
-            carry = total_delta >> extbits;
-        } else {
-            carry = 0;
-        }
-        carry +=
-            insideout::external_advance(data_[i],i+1, trunc_delta, isForwards);
-    }
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance(
-    state_type distance, bool forwards)
-{
-    static_assert(kdd,
-        "Efficient advance is too hard for non-kdd extension. "
-        "For a weak advance, cast to base class");
-    state_type zero =
-        baseclass::is_mcg ? this->state_ & state_type(3U) : state_type(0U);
-    if (may_tick) {
-        state_type ticks = distance >> (advance_pow2*may_tick);
-                                        // ^-- stupidity to appease GCC
-                                        // warnings
-        state_type adv_mask =
-            baseclass::is_mcg ? tick_mask << 2 : tick_mask;
-        state_type next_advance_distance = this->distance(zero, adv_mask);
-        if (!forwards)
-            next_advance_distance = (-next_advance_distance) & tick_mask;
-        if (next_advance_distance < (distance & tick_mask)) {
-            ++ticks;
-        }
-        if (ticks)
-            advance_table(ticks, forwards);
-    }
-    if (forwards) {
-        if (may_tock && this->distance(zero) <= distance)
-            advance_table();
-        baseclass::advance(distance);
-    } else {
-        if (may_tock && -(this->distance(zero)) <= distance)
-            advance_table(state_type(1U), false);
-        baseclass::advance(-distance);
-    }
-}
-
-} // namespace pcg_detail
-
-namespace pcg_engines {
-
-using namespace pcg_detail;
-
-/* Predefined types for XSH RS */
-
-typedef oneseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  oneseq_xsh_rs_16_8;
-typedef oneseq_base<uint16_t, uint32_t, xsh_rs_mixin>  oneseq_xsh_rs_32_16;
-typedef oneseq_base<uint32_t, uint64_t, xsh_rs_mixin>  oneseq_xsh_rs_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rs_mixin>  oneseq_xsh_rs_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                       cm_oneseq_xsh_rs_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, xsh_rs_mixin>  unique_xsh_rs_16_8;
-typedef unique_base<uint16_t, uint32_t, xsh_rs_mixin>  unique_xsh_rs_32_16;
-typedef unique_base<uint32_t, uint64_t, xsh_rs_mixin>  unique_xsh_rs_64_32;
-typedef unique_base<uint64_t, pcg128_t, xsh_rs_mixin>  unique_xsh_rs_128_64;
-typedef unique_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                       cm_unique_xsh_rs_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  setseq_xsh_rs_16_8;
-typedef setseq_base<uint16_t, uint32_t, xsh_rs_mixin>  setseq_xsh_rs_32_16;
-typedef setseq_base<uint32_t, uint64_t, xsh_rs_mixin>  setseq_xsh_rs_64_32;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rs_mixin>  setseq_xsh_rs_128_64;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                       cm_setseq_xsh_rs_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, xsh_rs_mixin>  mcg_xsh_rs_16_8;
-typedef mcg_base<uint16_t, uint32_t, xsh_rs_mixin>  mcg_xsh_rs_32_16;
-typedef mcg_base<uint32_t, uint64_t, xsh_rs_mixin>  mcg_xsh_rs_64_32;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rs_mixin>  mcg_xsh_rs_128_64;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                    cm_mcg_xsh_rs_128_64;
-
-/* Predefined types for XSH RR */
-
-typedef oneseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  oneseq_xsh_rr_16_8;
-typedef oneseq_base<uint16_t, uint32_t, xsh_rr_mixin>  oneseq_xsh_rr_32_16;
-typedef oneseq_base<uint32_t, uint64_t, xsh_rr_mixin>  oneseq_xsh_rr_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rr_mixin>  oneseq_xsh_rr_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                       cm_oneseq_xsh_rr_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, xsh_rr_mixin>  unique_xsh_rr_16_8;
-typedef unique_base<uint16_t, uint32_t, xsh_rr_mixin>  unique_xsh_rr_32_16;
-typedef unique_base<uint32_t, uint64_t, xsh_rr_mixin>  unique_xsh_rr_64_32;
-typedef unique_base<uint64_t, pcg128_t, xsh_rr_mixin>  unique_xsh_rr_128_64;
-typedef unique_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                       cm_unique_xsh_rr_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  setseq_xsh_rr_16_8;
-typedef setseq_base<uint16_t, uint32_t, xsh_rr_mixin>  setseq_xsh_rr_32_16;
-typedef setseq_base<uint32_t, uint64_t, xsh_rr_mixin>  setseq_xsh_rr_64_32;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rr_mixin>  setseq_xsh_rr_128_64;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                       cm_setseq_xsh_rr_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, xsh_rr_mixin>  mcg_xsh_rr_16_8;
-typedef mcg_base<uint16_t, uint32_t, xsh_rr_mixin>  mcg_xsh_rr_32_16;
-typedef mcg_base<uint32_t, uint64_t, xsh_rr_mixin>  mcg_xsh_rr_64_32;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rr_mixin>  mcg_xsh_rr_128_64;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                    cm_mcg_xsh_rr_128_64;
-
-
-/* Predefined types for RXS M XS */
-
-typedef oneseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>   oneseq_rxs_m_xs_8_8;
-typedef oneseq_base<uint16_t, uint16_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_16_16;
-typedef oneseq_base<uint32_t, uint32_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_32_32;
-typedef oneseq_base<uint64_t, uint64_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_64_64;
-typedef oneseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin>
-                                                        oneseq_rxs_m_xs_128_128;
-typedef oneseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin, true, cheap_multiplier>
-                                                     cm_oneseq_rxs_m_xs_128_128;
-
-typedef unique_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  unique_rxs_m_xs_8_8;
-typedef unique_base<uint16_t, uint16_t, rxs_m_xs_mixin> unique_rxs_m_xs_16_16;
-typedef unique_base<uint32_t, uint32_t, rxs_m_xs_mixin> unique_rxs_m_xs_32_32;
-typedef unique_base<uint64_t, uint64_t, rxs_m_xs_mixin> unique_rxs_m_xs_64_64;
-typedef unique_base<pcg128_t, pcg128_t, rxs_m_xs_mixin> unique_rxs_m_xs_128_128;
-typedef unique_base<pcg128_t, pcg128_t, rxs_m_xs_mixin, true, cheap_multiplier>
-                                                     cm_unique_rxs_m_xs_128_128;
-
-typedef setseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  setseq_rxs_m_xs_8_8;
-typedef setseq_base<uint16_t, uint16_t, rxs_m_xs_mixin> setseq_rxs_m_xs_16_16;
-typedef setseq_base<uint32_t, uint32_t, rxs_m_xs_mixin> setseq_rxs_m_xs_32_32;
-typedef setseq_base<uint64_t, uint64_t, rxs_m_xs_mixin> setseq_rxs_m_xs_64_64;
-typedef setseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin> setseq_rxs_m_xs_128_128;
-typedef setseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin, true, cheap_multiplier>
-                                                     cm_setseq_rxs_m_xs_128_128;
-
-                // MCG versions don't make sense here, so aren't defined.
-
-/* Predefined types for RXS M */
-
-typedef oneseq_base<uint8_t,  uint16_t, rxs_m_mixin>  oneseq_rxs_m_16_8;
-typedef oneseq_base<uint16_t, uint32_t, rxs_m_mixin>  oneseq_rxs_m_32_16;
-typedef oneseq_base<uint32_t, uint64_t, rxs_m_mixin>  oneseq_rxs_m_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, rxs_m_mixin>  oneseq_rxs_m_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                      cm_oneseq_rxs_m_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, rxs_m_mixin>  unique_rxs_m_16_8;
-typedef unique_base<uint16_t, uint32_t, rxs_m_mixin>  unique_rxs_m_32_16;
-typedef unique_base<uint32_t, uint64_t, rxs_m_mixin>  unique_rxs_m_64_32;
-typedef unique_base<uint64_t, pcg128_t, rxs_m_mixin>  unique_rxs_m_128_64;
-typedef unique_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                      cm_unique_rxs_m_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, rxs_m_mixin>  setseq_rxs_m_16_8;
-typedef setseq_base<uint16_t, uint32_t, rxs_m_mixin>  setseq_rxs_m_32_16;
-typedef setseq_base<uint32_t, uint64_t, rxs_m_mixin>  setseq_rxs_m_64_32;
-typedef setseq_base<uint64_t, pcg128_t, rxs_m_mixin>  setseq_rxs_m_128_64;
-typedef setseq_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                      cm_setseq_rxs_m_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, rxs_m_mixin>  mcg_rxs_m_16_8;
-typedef mcg_base<uint16_t, uint32_t, rxs_m_mixin>  mcg_rxs_m_32_16;
-typedef mcg_base<uint32_t, uint64_t, rxs_m_mixin>  mcg_rxs_m_64_32;
-typedef mcg_base<uint64_t, pcg128_t, rxs_m_mixin>  mcg_rxs_m_128_64;
-typedef mcg_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                   cm_mcg_rxs_m_128_64;
-
-/* Predefined types for DXSM */
-
-typedef oneseq_base<uint8_t,  uint16_t, dxsm_mixin>  oneseq_dxsm_16_8;
-typedef oneseq_base<uint16_t, uint32_t, dxsm_mixin>  oneseq_dxsm_32_16;
-typedef oneseq_base<uint32_t, uint64_t, dxsm_mixin>  oneseq_dxsm_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, dxsm_mixin>  oneseq_dxsm_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                     cm_oneseq_dxsm_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, dxsm_mixin>  unique_dxsm_16_8;
-typedef unique_base<uint16_t, uint32_t, dxsm_mixin>  unique_dxsm_32_16;
-typedef unique_base<uint32_t, uint64_t, dxsm_mixin>  unique_dxsm_64_32;
-typedef unique_base<uint64_t, pcg128_t, dxsm_mixin>  unique_dxsm_128_64;
-typedef unique_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                     cm_unique_dxsm_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, dxsm_mixin>  setseq_dxsm_16_8;
-typedef setseq_base<uint16_t, uint32_t, dxsm_mixin>  setseq_dxsm_32_16;
-typedef setseq_base<uint32_t, uint64_t, dxsm_mixin>  setseq_dxsm_64_32;
-typedef setseq_base<uint64_t, pcg128_t, dxsm_mixin>  setseq_dxsm_128_64;
-typedef setseq_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                     cm_setseq_dxsm_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, dxsm_mixin>  mcg_dxsm_16_8;
-typedef mcg_base<uint16_t, uint32_t, dxsm_mixin>  mcg_dxsm_32_16;
-typedef mcg_base<uint32_t, uint64_t, dxsm_mixin>  mcg_dxsm_64_32;
-typedef mcg_base<uint64_t, pcg128_t, dxsm_mixin>  mcg_dxsm_128_64;
-typedef mcg_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                  cm_mcg_dxsm_128_64;
-
-/* Predefined types for XSL RR (only defined for "large" types) */
-
-typedef oneseq_base<uint32_t, uint64_t, xsl_rr_mixin>  oneseq_xsl_rr_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, xsl_rr_mixin>  oneseq_xsl_rr_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                       cm_oneseq_xsl_rr_128_64;
-
-typedef unique_base<uint32_t, uint64_t, xsl_rr_mixin>  unique_xsl_rr_64_32;
-typedef unique_base<uint64_t, pcg128_t, xsl_rr_mixin>  unique_xsl_rr_128_64;
-typedef unique_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                       cm_unique_xsl_rr_128_64;
-
-typedef setseq_base<uint32_t, uint64_t, xsl_rr_mixin>  setseq_xsl_rr_64_32;
-typedef setseq_base<uint64_t, pcg128_t, xsl_rr_mixin>  setseq_xsl_rr_128_64;
-typedef setseq_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                       cm_setseq_xsl_rr_128_64;
-
-typedef mcg_base<uint32_t, uint64_t, xsl_rr_mixin>  mcg_xsl_rr_64_32;
-typedef mcg_base<uint64_t, pcg128_t, xsl_rr_mixin>  mcg_xsl_rr_128_64;
-typedef mcg_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                    cm_mcg_xsl_rr_128_64;
-
-
-/* Predefined types for XSL RR RR (only defined for "large" types) */
-
-typedef oneseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
-    oneseq_xsl_rr_rr_64_64;
-typedef oneseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
-    oneseq_xsl_rr_rr_128_128;
-typedef oneseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin, true, cheap_multiplier>
-    cm_oneseq_xsl_rr_rr_128_128;
-
-typedef unique_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
-    unique_xsl_rr_rr_64_64;
-typedef unique_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
-    unique_xsl_rr_rr_128_128;
-typedef unique_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin, true, cheap_multiplier>
-    cm_unique_xsl_rr_rr_128_128;
-
-typedef setseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
-    setseq_xsl_rr_rr_64_64;
-typedef setseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
-    setseq_xsl_rr_rr_128_128;
-typedef setseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin, true, cheap_multiplier>
-    cm_setseq_xsl_rr_rr_128_128;
-
-                // MCG versions don't make sense here, so aren't defined.
-
-/* Extended generators */
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std8 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                          oneseq_rxs_m_xs_8_8, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std16 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                           oneseq_rxs_m_xs_16_16, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std32 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                           oneseq_rxs_m_xs_32_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std64 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                           oneseq_rxs_m_xs_64_64, kdd>;
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_oneseq_rxs_m_xs_32_32 =
-          ext_std32<table_pow2, advance_pow2, oneseq_rxs_m_xs_32_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_mcg_xsh_rs_64_32 =
-          ext_std32<table_pow2, advance_pow2, mcg_xsh_rs_64_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_oneseq_xsh_rs_64_32 =
-          ext_std32<table_pow2, advance_pow2, oneseq_xsh_rs_64_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_setseq_xsh_rr_64_32 =
-          ext_std32<table_pow2, advance_pow2, setseq_xsh_rr_64_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_mcg_xsl_rr_128_64 =
-          ext_std64<table_pow2, advance_pow2, mcg_xsl_rr_128_64, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_oneseq_xsl_rr_128_64 =
-          ext_std64<table_pow2, advance_pow2, oneseq_xsl_rr_128_64, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_setseq_xsl_rr_128_64 =
-          ext_std64<table_pow2, advance_pow2, setseq_xsl_rr_128_64, kdd>;
-
-} // namespace pcg_engines
-
-typedef pcg_engines::setseq_xsh_rr_64_32        pcg32;
-typedef pcg_engines::oneseq_xsh_rr_64_32        pcg32_oneseq;
-typedef pcg_engines::unique_xsh_rr_64_32        pcg32_unique;
-typedef pcg_engines::mcg_xsh_rs_64_32           pcg32_fast;
-
-typedef pcg_engines::setseq_xsl_rr_128_64       pcg64;
-typedef pcg_engines::oneseq_xsl_rr_128_64       pcg64_oneseq;
-typedef pcg_engines::unique_xsl_rr_128_64       pcg64_unique;
-typedef pcg_engines::mcg_xsl_rr_128_64          pcg64_fast;
-
-typedef pcg_engines::setseq_rxs_m_xs_8_8        pcg8_once_insecure;
-typedef pcg_engines::setseq_rxs_m_xs_16_16      pcg16_once_insecure;
-typedef pcg_engines::setseq_rxs_m_xs_32_32      pcg32_once_insecure;
-typedef pcg_engines::setseq_rxs_m_xs_64_64      pcg64_once_insecure;
-typedef pcg_engines::setseq_xsl_rr_rr_128_128   pcg128_once_insecure;
-
-typedef pcg_engines::oneseq_rxs_m_xs_8_8        pcg8_oneseq_once_insecure;
-typedef pcg_engines::oneseq_rxs_m_xs_16_16      pcg16_oneseq_once_insecure;
-typedef pcg_engines::oneseq_rxs_m_xs_32_32      pcg32_oneseq_once_insecure;
-typedef pcg_engines::oneseq_rxs_m_xs_64_64      pcg64_oneseq_once_insecure;
-typedef pcg_engines::oneseq_xsl_rr_rr_128_128   pcg128_oneseq_once_insecure;
-
-
-// These two extended RNGs provide two-dimensionally equidistributed
-// 32-bit generators.  pcg32_k2_fast occupies the same space as pcg64,
-// and can be called twice to generate 64 bits, but does not required
-// 128-bit math; on 32-bit systems, it's faster than pcg64 as well.
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<1,16,true>     pcg32_k2;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<1,32,true>     pcg32_k2_fast;
-
-// These eight extended RNGs have about as much state as arc4random
-//
-//  - the k variants are k-dimensionally equidistributed
-//  - the c variants offer better crypographic security
-//
-// (just how good the cryptographic security is is an open question)
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,true>     pcg32_k64;
-typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,true>        pcg32_k64_oneseq;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,true>     pcg32_k64_fast;
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,false>    pcg32_c64;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,false>    pcg32_c64_oneseq;
-typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,false>       pcg32_c64_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<5,16,true>    pcg64_k32;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<5,128,true>   pcg64_k32_oneseq;
-typedef pcg_engines::ext_mcg_xsl_rr_128_64<5,128,true>      pcg64_k32_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<5,16,false>   pcg64_c32;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<5,128,false>  pcg64_c32_oneseq;
-typedef pcg_engines::ext_mcg_xsl_rr_128_64<5,128,false>     pcg64_c32_fast;
-
-// These eight extended RNGs have more state than the Mersenne twister
-//
-//  - the k variants are k-dimensionally equidistributed
-//  - the c variants offer better crypographic security
-//
-// (just how good the cryptographic security is is an open question)
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,true>    pcg32_k1024;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,true>    pcg32_k1024_fast;
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,false>   pcg32_c1024;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,false>   pcg32_c1024_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<10,16,true>   pcg64_k1024;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<10,128,true>  pcg64_k1024_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<10,16,false>  pcg64_c1024;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<10,128,false> pcg64_c1024_fast;
-
-// These generators have an insanely huge period (2^524352), and is suitable
-// for silly party tricks, such as dumping out 64 KB ZIP files at an arbitrary
-// point in the future.   [Actually, over the full period of the generator, it
-// will produce every 64 KB ZIP file 2^64 times!]
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<14,16,true>    pcg32_k16384;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<14,32,true>    pcg32_k16384_fast;
-
-#ifdef _MSC_VER
-    #pragma warning(default:4146)
-#endif
-
-#endif // PCG_RAND_HPP_INCLUDED
diff --git a/src/duckdb/third_party/pcg/pcg_uint128.hpp b/src/duckdb/third_party/pcg/pcg_uint128.hpp
deleted file mode 100644
index faf100237..000000000
--- a/src/duckdb/third_party/pcg/pcg_uint128.hpp
+++ /dev/null
@@ -1,884 +0,0 @@
-/*
- * PCG Random Number Generation for C++
- *
- * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
- *                     and the PCG Project contributors.
- *
- * SPDX-License-Identifier: (Apache-2.0 OR MIT)
- *
- * Licensed under the Apache License, Version 2.0 (provided in
- * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
- * or under the MIT license (provided in LICENSE-MIT.txt and at
- * http://opensource.org/licenses/MIT), at your option. This file may not
- * be copied, modified, or distributed except according to those terms.
- *
- * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
- * express or implied.  See your chosen license for details.
- *
- * For additional information about the PCG random number generation scheme,
- * visit http://www.pcg-random.org/.
- */
-
-/*
- * This code provides a a C++ class that can provide 128-bit (or higher)
- * integers.  To produce 2K-bit integers, it uses two K-bit integers,
- * placed in a union that allowes the code to also see them as four K/2 bit
- * integers (and access them either directly name, or by index).
- *
- * It may seem like we're reinventing the wheel here, because several
- * libraries already exist that support large integers, but most existing
- * libraries provide a very generic multiprecision code, but here we're
- * operating at a fixed size.  Also, most other libraries are fairly
- * heavyweight.  So we use a direct implementation.  Sadly, it's much slower
- * than hand-coded assembly or direct CPU support.
- */
-
-#ifndef PCG_UINT128_HPP_INCLUDED
-#define PCG_UINT128_HPP_INCLUDED 1
-
-#include <cstdint>
-#include <cstdio>
-#include <cassert>
-#include <climits>
-#include <utility>
-#include <initializer_list>
-#include <type_traits>
-
-#if defined(_MSC_VER)  // Use MSVC++ intrinsics
-#include <intrin.h>
-#endif
-
-/*
- * We want to lay the type out the same way that a native type would be laid
- * out, which means we must know the machine's endian, at compile time.
- * This ugliness attempts to do so.
- */
-
-#ifndef PCG_LITTLE_ENDIAN
-    #if defined(__BYTE_ORDER__)
-        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-            #define PCG_LITTLE_ENDIAN 1
-        #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-            #define PCG_LITTLE_ENDIAN 0
-        #else
-            #error __BYTE_ORDER__ does not match a standard endian, pick a side
-        #endif
-    #elif __LITTLE_ENDIAN__ || _LITTLE_ENDIAN
-        #define PCG_LITTLE_ENDIAN 1
-    #elif __BIG_ENDIAN__ || _BIG_ENDIAN
-        #define PCG_LITTLE_ENDIAN 0
-    #elif __x86_64 || __x86_64__ || _M_X64 || __i386 || __i386__ || _M_IX86 || _M_ARM || _M_ARM64
-        #define PCG_LITTLE_ENDIAN 1
-    #elif __powerpc__ || __POWERPC__ || __ppc__ || __PPC__ \
-          || __m68k__ || __mc68000__
-        #define PCG_LITTLE_ENDIAN 0
-    #else
-        #error Unable to determine target endianness
-    #endif
-#endif
-
-namespace pcg_extras {
-
-// Recent versions of GCC have intrinsics we can use to quickly calculate
-// the number of leading and trailing zeros in a number.  If possible, we
-// use them, otherwise we fall back to old-fashioned bit twiddling to figure
-// them out.
-
-#ifndef PCG_BITCOUNT_T
-    typedef uint8_t bitcount_t;
-#else
-    typedef PCG_BITCOUNT_T bitcount_t;
-#endif
-
-/*
- * Provide some useful helper functions
- *      * flog2                 floor(log2(x))
- *      * trailingzeros         number of trailing zero bits
- */
-
-#if defined(__GNUC__)   // Any GNU-compatible compiler supporting C++11 has
-                        // some useful intrinsics we can use.
-
-inline bitcount_t flog2(uint32_t v)
-{
-    return 31 - __builtin_clz(v);
-}
-
-inline bitcount_t trailingzeros(uint32_t v)
-{
-    return __builtin_ctz(v);
-}
-
-inline bitcount_t flog2(uint64_t v)
-{
-#if UINT64_MAX == ULONG_MAX
-    return 63 - __builtin_clzl(v);
-#elif UINT64_MAX == ULLONG_MAX
-    return 63 - __builtin_clzll(v);
-#else
-    #error Cannot find a function for uint64_t
-#endif
-}
-
-inline bitcount_t trailingzeros(uint64_t v)
-{
-#if UINT64_MAX == ULONG_MAX
-    return __builtin_ctzl(v);
-#elif UINT64_MAX == ULLONG_MAX
-    return __builtin_ctzll(v);
-#else
-    #error Cannot find a function for uint64_t
-#endif
-}
-
-#elif defined(_MSC_VER)  // Use MSVC++ intrinsics
-
-#pragma intrinsic(_BitScanReverse, _BitScanForward)
-#if defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-#pragma intrinsic(_BitScanReverse64, _BitScanForward64)
-#endif
-
-inline bitcount_t flog2(uint32_t v)
-{
-    unsigned long i;
-    _BitScanReverse(&i, v);
-    return bitcount_t(i);
-}
-
-inline bitcount_t trailingzeros(uint32_t v)
-{
-    unsigned long i;
-    _BitScanForward(&i, v);
-    return bitcount_t(i);
-}
-
-inline bitcount_t flog2(uint64_t v)
-{
-#if defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-    unsigned long i;
-    _BitScanReverse64(&i, v);
-    return bitcount_t(i);
-#else
-    // 32-bit x86
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-    return high ? 32+flog2(high) : flog2(low);
-#endif
-}
-
-inline bitcount_t trailingzeros(uint64_t v)
-{
-#if defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-    unsigned long i;
-    _BitScanForward64(&i, v);
-    return bitcount_t(i);
-#else
-    // 32-bit x86
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-    return low ? trailingzeros(low) : trailingzeros(high)+32;
-#endif
-}
-
-#else                   // Otherwise, we fall back to bit twiddling
-                        // implementations
-
-inline bitcount_t flog2(uint32_t v)
-{
-    // Based on code by Eric Cole and Mark Dickinson, which appears at
-    // https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
-
-    static const uint8_t multiplyDeBruijnBitPos[32] = {
-      0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
-      8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
-    };
-
-    v |= v >> 1; // first round down to one less than a power of 2
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-
-    return multiplyDeBruijnBitPos[(uint32_t)(v * 0x07C4ACDDU) >> 27];
-}
-
-inline bitcount_t trailingzeros(uint32_t v)
-{
-    static const uint8_t multiplyDeBruijnBitPos[32] = {
-      0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
-      31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
-    };
-
-    return multiplyDeBruijnBitPos[((uint32_t)((v & -v) * 0x077CB531U)) >> 27];
-}
-
-inline bitcount_t flog2(uint64_t v)
-{
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-
-    return high ? 32+flog2(high) : flog2(low);
-}
-
-inline bitcount_t trailingzeros(uint64_t v)
-{
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-
-    return low ? trailingzeros(low) : trailingzeros(high)+32;
-}
-
-#endif
-
-inline bitcount_t flog2(uint8_t v)
-{
-    return flog2(uint32_t(v));
-}
-
-inline bitcount_t flog2(uint16_t v)
-{
-    return flog2(uint32_t(v));
-}
-
-#if __SIZEOF_INT128__
-inline bitcount_t flog2(__uint128_t v)
-{
-    uint64_t high = uint64_t(v >> 64);
-    uint64_t low  = uint64_t(v);
-
-    return high ? 64+flog2(high) : flog2(low);
-}
-#endif
-
-inline bitcount_t trailingzeros(uint8_t v)
-{
-    return trailingzeros(uint32_t(v));
-}
-
-inline bitcount_t trailingzeros(uint16_t v)
-{
-    return trailingzeros(uint32_t(v));
-}
-
-#if __SIZEOF_INT128__
-inline bitcount_t trailingzeros(__uint128_t v)
-{
-    uint64_t high = uint64_t(v >> 64);
-    uint64_t low  = uint64_t(v);
-    return low ? trailingzeros(low) : trailingzeros(high)+64;
-}
-#endif
-
-template <typename UInt>
-inline bitcount_t clog2(UInt v)
-{
-    return flog2(v) + ((v & (-v)) != v);
-}
-
-template <typename UInt>
-inline UInt addwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
-{
-    UInt half_result = y + carryin;
-    UInt result = x + half_result;
-    *carryout = (half_result < y) || (result < x);
-    return result;
-}
-
-template <typename UInt>
-inline UInt subwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
-{
-    UInt half_result = y + carryin;
-    UInt result = x - half_result;
-    *carryout = (half_result < y) || (result > x);
-    return result;
-}
-
-
-template <typename UInt, typename UIntX2>
-class uint_x4 {
-// private:
-    static constexpr unsigned int UINT_BITS = sizeof(UInt) * CHAR_BIT;
-public:
-    union {
-#if PCG_LITTLE_ENDIAN
-        struct {
-            UInt v0, v1, v2, v3;
-        } w;
-        struct {
-            UIntX2 v01, v23;
-        } d;
-#else
-        struct {
-            UInt v3, v2, v1, v0;
-        } w;
-        struct {
-            UIntX2 v23, v01;
-        } d;
-#endif
-        // For the array access versions, the code that uses the array
-        // must handle endian itself.  Yuck.
-        UInt wa[4];
-        UIntX2 da[2];
-    };
-
-public:
-    uint_x4() = default;
-
-    constexpr uint_x4(UInt v3, UInt v2, UInt v1, UInt v0)
-#if PCG_LITTLE_ENDIAN
-       : w{v0, v1, v2, v3}
-#else
-       : w{v3, v2, v1, v0}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    constexpr uint_x4(UIntX2 v23, UIntX2 v01)
-#if PCG_LITTLE_ENDIAN
-       : d{v01,v23}
-#else
-       : d{v23,v01}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    constexpr uint_x4(UIntX2 v01)
-#if PCG_LITTLE_ENDIAN
-       : d{v01, UIntX2(0)}
-#else
-       : d{UIntX2(0),v01}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    template<class Integral,
-             typename std::enable_if<(std::is_integral<Integral>::value
-                                      && sizeof(Integral) <= sizeof(UIntX2))
-                                    >::type* = nullptr>
-    constexpr uint_x4(Integral v01)
-#if PCG_LITTLE_ENDIAN
-       : d{UIntX2(v01), UIntX2(0)}
-#else
-       : d{UIntX2(0), UIntX2(v01)}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    explicit constexpr operator UIntX2() const
-    {
-        return d.v01;
-    }
-
-    template<class Integral,
-             typename std::enable_if<(std::is_integral<Integral>::value
-                                      && sizeof(Integral) <= sizeof(UIntX2))
-                                    >::type* = nullptr>
-    explicit constexpr operator Integral() const
-    {
-        return Integral(d.v01);
-    }
-
-    explicit constexpr operator bool() const
-    {
-        return d.v01 || d.v23;
-    }
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator*(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator*(const uint_x4<U,V>&, V);
-
-    template<typename U, typename V>
-    friend std::pair< uint_x4<U,V>,uint_x4<U,V> >
-        divmod(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator+(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator-(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator<<(const uint_x4<U,V>&, const bitcount_t shift);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator>>(const uint_x4<U,V>&, const bitcount_t shift);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator&(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator|(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator^(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator==(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator!=(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator<(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator<=(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator>(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator>=(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator~(const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator-(const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bitcount_t flog2(const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bitcount_t trailingzeros(const uint_x4<U,V>&);
-
-    uint_x4& operator*=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this * rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator*=(UIntX2 rhs)
-    {
-        uint_x4 result = *this * rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator/=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this / rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator%=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this % rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator+=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this + rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator-=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this - rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator&=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this & rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator|=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this | rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator^=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this ^ rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator>>=(bitcount_t shift)
-    {
-        uint_x4 result = *this >> shift;
-        return *this = result;
-    }
-
-    uint_x4& operator<<=(bitcount_t shift)
-    {
-        uint_x4 result = *this << shift;
-        return *this = result;
-    }
-
-};
-
-template<typename U, typename V>
-bitcount_t flog2(const uint_x4<U,V>& v)
-{
-#if PCG_LITTLE_ENDIAN
-    for (uint8_t i = 4; i !=0; /* dec in loop */) {
-        --i;
-#else
-    for (uint8_t i = 0; i < 4; ++i) {
-#endif
-        if (v.wa[i] == 0)
-             continue;
-        return flog2(v.wa[i]) + uint_x4<U,V>::UINT_BITS*i;
-    }
-    abort();
-}
-
-template<typename U, typename V>
-bitcount_t trailingzeros(const uint_x4<U,V>& v)
-{
-#if PCG_LITTLE_ENDIAN
-    for (uint8_t i = 0; i < 4; ++i) {
-#else
-    for (uint8_t i = 4; i !=0; /* dec in loop */) {
-        --i;
-#endif
-        if (v.wa[i] != 0)
-            return trailingzeros(v.wa[i]) + uint_x4<U,V>::UINT_BITS*i;
-    }
-    return uint_x4<U,V>::UINT_BITS*4;
-}
-
-template <typename UInt, typename UIntX2>
-std::pair< uint_x4<UInt,UIntX2>, uint_x4<UInt,UIntX2> >
-    divmod(const uint_x4<UInt,UIntX2>& orig_dividend,
-           const uint_x4<UInt,UIntX2>& divisor)
-{
-    // If the dividend is less than the divisor, the answer is always zero.
-    // This takes care of boundary cases like 0/x (which would otherwise be
-    // problematic because we can't take the log of zero.  (The boundary case
-    // of division by zero is undefined.)
-    if (orig_dividend < divisor)
-        return { uint_x4<UInt,UIntX2>(UIntX2(0)), orig_dividend };
-
-    auto dividend = orig_dividend;
-
-    auto log2_divisor  = flog2(divisor);
-    auto log2_dividend = flog2(dividend);
-    // assert(log2_dividend >= log2_divisor);
-    bitcount_t logdiff = log2_dividend - log2_divisor;
-
-    constexpr uint_x4<UInt,UIntX2> ONE(UIntX2(1));
-    if (logdiff == 0)
-        return { ONE, dividend - divisor };
-
-    // Now we change the log difference to
-    //  floor(log2(divisor)) - ceil(log2(dividend))
-    // to ensure that we *underestimate* the result.
-    logdiff -= 1;
-
-    uint_x4<UInt,UIntX2> quotient(UIntX2(0));
-
-    auto qfactor = ONE << logdiff;
-    auto factor  = divisor << logdiff;
-
-    do {
-        dividend -= factor;
-        quotient += qfactor;
-        while (dividend < factor) {
-            factor  >>= 1;
-            qfactor >>= 1;
-        }
-    } while (dividend >= divisor);
-
-    return { quotient, dividend };
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator/(const uint_x4<UInt,UIntX2>& dividend,
-                               const uint_x4<UInt,UIntX2>& divisor)
-{
-    return divmod(dividend, divisor).first;
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator%(const uint_x4<UInt,UIntX2>& dividend,
-                               const uint_x4<UInt,UIntX2>& divisor)
-{
-    return divmod(dividend, divisor).second;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator*(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    constexpr auto UINT_BITS = uint_x4<UInt,UIntX2>::UINT_BITS;
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    bool carryin = false;
-    bool carryout;
-    UIntX2 a0b0 = UIntX2(a.w.v0) * UIntX2(b.w.v0);
-    r.w.v0 = UInt(a0b0);
-    r.w.v1 = UInt(a0b0 >> UINT_BITS);
-
-    UIntX2 a1b0 = UIntX2(a.w.v1) * UIntX2(b.w.v0);
-    r.w.v2 = UInt(a1b0 >> UINT_BITS);
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a1b0), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a0b1 = UIntX2(a.w.v0) * UIntX2(b.w.v1);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a0b1 >> UINT_BITS), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    carryin = false;
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a0b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a1b1 = UIntX2(a.w.v1) * UIntX2(b.w.v1);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a1b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(a1b1 >> UINT_BITS), carryin, &carryout);
-
-    r.d.v23 += a.d.v01 * b.d.v23 + a.d.v23 * b.d.v01;
-
-    return r;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator*(const uint_x4<UInt,UIntX2>& a,
-                               UIntX2 b01)
-{
-    constexpr auto UINT_BITS = uint_x4<UInt,UIntX2>::UINT_BITS;
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    bool carryin = false;
-    bool carryout;
-    UIntX2 a0b0 = UIntX2(a.w.v0) * UIntX2(UInt(b01));
-    r.w.v0 = UInt(a0b0);
-    r.w.v1 = UInt(a0b0 >> UINT_BITS);
-
-    UIntX2 a1b0 = UIntX2(a.w.v1) * UIntX2(UInt(b01));
-    r.w.v2 = UInt(a1b0 >> UINT_BITS);
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a1b0), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a0b1 = UIntX2(a.w.v0) * UIntX2(b01 >> UINT_BITS);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a0b1 >> UINT_BITS), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    carryin = false;
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a0b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a1b1 = UIntX2(a.w.v1) * UIntX2(b01 >> UINT_BITS);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a1b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(a1b1 >> UINT_BITS), carryin, &carryout);
-
-    r.d.v23 += a.d.v23 * b01;
-
-    return r;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator+(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-
-    bool carryin = false;
-    bool carryout;
-    r.w.v0 = addwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
-    carryin = carryout;
-    r.w.v1 = addwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(a.w.v3, b.w.v3, carryin, &carryout);
-
-    return r;
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-
-    bool carryin = false;
-    bool carryout;
-    r.w.v0 = subwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
-    carryin = carryout;
-    r.w.v1 = subwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = subwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = subwithcarry(a.w.v3, b.w.v3, carryin, &carryout);
-
-    return r;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator&(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    return uint_x4<UInt,UIntX2>(a.d.v23 & b.d.v23, a.d.v01 & b.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator|(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    return uint_x4<UInt,UIntX2>(a.d.v23 | b.d.v23, a.d.v01 | b.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator^(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    return uint_x4<UInt,UIntX2>(a.d.v23 ^ b.d.v23, a.d.v01 ^ b.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator~(const uint_x4<UInt,UIntX2>& v)
-{
-    return uint_x4<UInt,UIntX2>(~v.d.v23, ~v.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& v)
-{
-    return uint_x4<UInt,UIntX2>(0UL,0UL) - v;
-}
-
-template <typename UInt, typename UIntX2>
-bool operator==(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return (a.d.v01 == b.d.v01) && (a.d.v23 == b.d.v23);
-}
-
-template <typename UInt, typename UIntX2>
-bool operator!=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return !operator==(a,b);
-}
-
-
-template <typename UInt, typename UIntX2>
-bool operator<(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return (a.d.v23 < b.d.v23)
-           || ((a.d.v23 == b.d.v23) && (a.d.v01 < b.d.v01));
-}
-
-template <typename UInt, typename UIntX2>
-bool operator>(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return operator<(b,a);
-}
-
-template <typename UInt, typename UIntX2>
-bool operator<=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return !(operator<(b,a));
-}
-
-template <typename UInt, typename UIntX2>
-bool operator>=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return !(operator<(a,b));
-}
-
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator<<(const uint_x4<UInt,UIntX2>& v,
-                                const bitcount_t shift)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    const bitcount_t bits    = uint_x4<UInt,UIntX2>::UINT_BITS;
-    const bitcount_t bitmask = bits - 1;
-    const bitcount_t shiftdiv = shift / bits;
-    const bitcount_t shiftmod = shift & bitmask;
-
-    if (shiftmod) {
-        UInt carryover = 0;
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#else
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#endif
-            r.wa[out] = (v.wa[in] << shiftmod) | carryover;
-            carryover = (v.wa[in] >> (bits - shiftmod));
-        }
-    } else {
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#else
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#endif
-            r.wa[out] = v.wa[in];
-        }
-    }
-
-    return r;
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator>>(const uint_x4<UInt,UIntX2>& v,
-                                const bitcount_t shift)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    const bitcount_t bits    = uint_x4<UInt,UIntX2>::UINT_BITS;
-    const bitcount_t bitmask = bits - 1;
-    const bitcount_t shiftdiv = shift / bits;
-    const bitcount_t shiftmod = shift & bitmask;
-
-    if (shiftmod) {
-        UInt carryover = 0;
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#else
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#endif
-            r.wa[out] = (v.wa[in] >> shiftmod) | carryover;
-            carryover = (v.wa[in] << (bits - shiftmod));
-        }
-    } else {
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#else
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#endif
-            r.wa[out] = v.wa[in];
-        }
-    }
-
-    return r;
-}
-
-} // namespace pcg_extras
-
-#endif // PCG_UINT128_HPP_INCLUDED
diff --git a/src/duckdb/third_party/re2/re2/bitmap256.cc b/src/duckdb/third_party/re2/re2/bitmap256.cc
deleted file mode 100644
index 92d14e7c9..000000000
--- a/src/duckdb/third_party/re2/re2/bitmap256.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2023 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "re2/bitmap256.h"
-
-#include <stdint.h>
-
-#include "util/util.h"
-#include "util/logging.h"
-
-namespace duckdb_re2 {
-
-int Bitmap256::FindNextSetBit(int c) const {
-  DCHECK_GE(c, 0);
-  DCHECK_LE(c, 255);
-
-  // Check the word that contains the bit. Mask out any lower bits.
-  int i = c / 64;
-  uint64_t word = words_[i] & (~uint64_t{0} << (c % 64));
-  if (word != 0)
-    return (i * 64) + FindLSBSet(word);
-
-  // Check any following words.
-  i++;
-  switch (i) {
-    case 1:
-      if (words_[1] != 0)
-        return (1 * 64) + FindLSBSet(words_[1]);
-      FALLTHROUGH_INTENDED;
-    case 2:
-      if (words_[2] != 0)
-        return (2 * 64) + FindLSBSet(words_[2]);
-      FALLTHROUGH_INTENDED;
-    case 3:
-      if (words_[3] != 0)
-        return (3 * 64) + FindLSBSet(words_[3]);
-      FALLTHROUGH_INTENDED;
-    default:
-      return -1;
-  }
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/bitmap256.h b/src/duckdb/third_party/re2/re2/bitmap256.h
deleted file mode 100644
index 3707090c4..000000000
--- a/src/duckdb/third_party/re2/re2/bitmap256.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_BITMAP256_H_
-#define RE2_BITMAP256_H_
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-#include <stdint.h>
-#include <string.h>
-
-#include "util/logging.h"
-
-namespace duckdb_re2 {
-
-class Bitmap256 {
- public:
-  Bitmap256() {
-    Clear();
-  }
-
-  // Clears all of the bits.
-  void Clear() {
-    memset(words_, 0, sizeof words_);
-  }
-
-  // Tests the bit with index c.
-  bool Test(int c) const {
-    DCHECK_GE(c, 0);
-    DCHECK_LE(c, 255);
-
-    return (words_[c / 64] & (uint64_t{1} << (c % 64))) != 0;
-  }
-
-  // Sets the bit with index c.
-  void Set(int c) {
-    DCHECK_GE(c, 0);
-    DCHECK_LE(c, 255);
-
-    words_[c / 64] |= (uint64_t{1} << (c % 64));
-  }
-
-  // Finds the next non-zero bit with index >= c.
-  // Returns -1 if no such bit exists.
-  int FindNextSetBit(int c) const;
-
- private:
-  // Finds the least significant non-zero bit in n.
-  static int FindLSBSet(uint64_t n) {
-    DCHECK_NE(n, 0);
-#if defined(__GNUC__)
-    return __builtin_ctzll(n);
-#elif defined(_MSC_VER) && defined(_M_X64)
-    unsigned long c;
-    _BitScanForward64(&c, n);
-    return static_cast<int>(c);
-#elif defined(_MSC_VER) && defined(_M_IX86)
-    unsigned long c;
-    if (static_cast<uint32_t>(n) != 0) {
-      _BitScanForward(&c, static_cast<uint32_t>(n));
-      return static_cast<int>(c);
-    } else {
-      _BitScanForward(&c, static_cast<uint32_t>(n >> 32));
-      return static_cast<int>(c) + 32;
-    }
-#else
-    int c = 63;
-    for (int shift = 1 << 5; shift != 0; shift >>= 1) {
-      uint64_t word = n << shift;
-      if (word != 0) {
-        n = word;
-        c -= shift;
-      }
-    }
-    return c;
-#endif
-  }
-
-  uint64_t words_[4];
-};
-
-}  // namespace re2
-
-#endif  // RE2_BITMAP256_H_
diff --git a/src/duckdb/third_party/re2/re2/bitstate.cc b/src/duckdb/third_party/re2/re2/bitstate.cc
deleted file mode 100644
index a7ef5d88a..000000000
--- a/src/duckdb/third_party/re2/re2/bitstate.cc
+++ /dev/null
@@ -1,385 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tested by search_test.cc, exhaustive_test.cc, tester.cc
-
-// Prog::SearchBitState is a regular expression search with submatch
-// tracking for small regular expressions and texts.  Similarly to
-// testing/backtrack.cc, it allocates a bitmap with (count of
-// lists) * (length of text) bits to make sure it never explores the
-// same (instruction list, character position) multiple times.  This
-// limits the search to run in time linear in the length of the text.
-//
-// Unlike testing/backtrack.cc, SearchBitState is not recursive
-// on the text.
-//
-// SearchBitState is a fast replacement for the NFA code on small
-// regexps and texts when SearchOnePass cannot be used.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <limits>
-#include <utility>
-
-#include "util/logging.h"
-#include "re2/pod_array.h"
-#include "re2/prog.h"
-#include "re2/regexp.h"
-
-namespace duckdb_re2 {
-
-struct Job {
-  int id;
-  int rle;  // run length encoding
-  const char* p;
-};
-
-class BitState {
- public:
-  explicit BitState(Prog* prog);
-
-  // The usual Search prototype.
-  // Can only call Search once per BitState.
-  bool Search(const StringPiece& text, const StringPiece& context,
-              bool anchored, bool longest,
-              StringPiece* submatch, int nsubmatch);
-
- private:
-  inline bool ShouldVisit(int id, const char* p);
-  void Push(int id, const char* p);
-  void GrowStack();
-  bool TrySearch(int id, const char* p);
-
-  // Search parameters
-  Prog* prog_;              // program being run
-  StringPiece text_;        // text being searched
-  StringPiece context_;     // greater context of text being searched
-  bool anchored_;           // whether search is anchored at text.begin()
-  bool longest_;            // whether search wants leftmost-longest match
-  bool endmatch_;           // whether match must end at text.end()
-  StringPiece* submatch_;   // submatches to fill in
-  int nsubmatch_;           //   # of submatches to fill in
-
-  // Search state
-  static constexpr int kVisitedBits = 64;
-  PODArray<uint64_t> visited_;  // bitmap: (list ID, char*) pairs visited
-  PODArray<const char*> cap_;   // capture registers
-  PODArray<Job> job_;           // stack of text positions to explore
-  int njob_;                    // stack size
-
-  BitState(const BitState&) = delete;
-  BitState& operator=(const BitState&) = delete;
-};
-
-BitState::BitState(Prog* prog)
-  : prog_(prog),
-    anchored_(false),
-    longest_(false),
-    endmatch_(false),
-    submatch_(NULL),
-    nsubmatch_(0),
-    njob_(0) {
-}
-
-// Given id, which *must* be a list head, we can look up its list ID.
-// Then the question is: Should the search visit the (list ID, p) pair?
-// If so, remember that it was visited so that the next time,
-// we don't repeat the visit.
-bool BitState::ShouldVisit(int id, const char* p) {
-  int n = prog_->list_heads()[id] * static_cast<int>(text_.size()+1) +
-          static_cast<int>(p-text_.data());
-  if (visited_[n/kVisitedBits] & (uint64_t{1} << (n & (kVisitedBits-1))))
-    return false;
-  visited_[n/kVisitedBits] |= uint64_t{1} << (n & (kVisitedBits-1));
-  return true;
-}
-
-// Grow the stack.
-void BitState::GrowStack() {
-  PODArray<Job> tmp(2*job_.size());
-  memmove(tmp.data(), job_.data(), njob_*sizeof job_[0]);
-  job_ = std::move(tmp);
-}
-
-// Push (id, p) onto the stack, growing it if necessary.
-void BitState::Push(int id, const char* p) {
-  if (njob_ >= job_.size()) {
-    GrowStack();
-    if (njob_ >= job_.size()) {
-      LOG(DFATAL) << "GrowStack() failed: "
-                  << "njob_ = " << njob_ << ", "
-                  << "job_.size() = " << job_.size();
-      return;
-    }
-  }
-
-  // If id < 0, it's undoing a Capture,
-  // so we mustn't interfere with that.
-  if (id >= 0 && njob_ > 0) {
-    Job* top = &job_[njob_-1];
-    if (id == top->id &&
-        p == top->p + top->rle + 1 &&
-        top->rle < std::numeric_limits<int>::max()) {
-      ++top->rle;
-      return;
-    }
-  }
-
-  Job* top = &job_[njob_++];
-  top->id = id;
-  top->rle = 0;
-  top->p = p;
-}
-
-// Try a search from instruction id0 in state p0.
-// Return whether it succeeded.
-bool BitState::TrySearch(int id0, const char* p0) {
-  bool matched = false;
-  const char* end = text_.data() + text_.size();
-  njob_ = 0;
-  // Push() no longer checks ShouldVisit(),
-  // so we must perform the check ourselves.
-  if (ShouldVisit(id0, p0))
-    Push(id0, p0);
-  while (njob_ > 0) {
-    // Pop job off stack.
-    --njob_;
-    int id = job_[njob_].id;
-    int& rle = job_[njob_].rle;
-    const char* p = job_[njob_].p;
-
-    if (id < 0) {
-      // Undo the Capture.
-      cap_[prog_->inst(-id)->cap()] = p;
-      continue;
-    }
-
-    if (rle > 0) {
-      p += rle;
-      // Revivify job on stack.
-      --rle;
-      ++njob_;
-    }
-
-  Loop:
-    // Visit id, p.
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "Unexpected opcode: " << ip->opcode();
-        return false;
-
-      case kInstFail:
-        break;
-
-      case kInstAltMatch:
-        if (ip->greedy(prog_)) {
-          // out1 is the Match instruction.
-          id = ip->out1();
-          p = end;
-          goto Loop;
-        }
-        if (longest_) {
-          // ip must be non-greedy...
-          // out is the Match instruction.
-          id = ip->out();
-          p = end;
-          goto Loop;
-        }
-        goto Next;
-
-      case kInstByteRange: {
-        int c = -1;
-        if (p < end)
-          c = *p & 0xFF;
-        if (!ip->Matches(c))
-          goto Next;
-
-        if (ip->hint() != 0)
-          Push(id+ip->hint(), p);  // try the next when we're done
-        id = ip->out();
-        p++;
-        goto CheckAndLoop;
-      }
-
-      case kInstCapture:
-        if (!ip->last())
-          Push(id+1, p);  // try the next when we're done
-
-        if (0 <= ip->cap() && ip->cap() < cap_.size()) {
-          // Capture p to register, but save old value first.
-          Push(-id, cap_[ip->cap()]);  // undo when we're done
-          cap_[ip->cap()] = p;
-        }
-
-        id = ip->out();
-        goto CheckAndLoop;
-
-      case kInstEmptyWidth:
-        if (ip->empty() & ~Prog::EmptyFlags(context_, p))
-          goto Next;
-
-        if (!ip->last())
-          Push(id+1, p);  // try the next when we're done
-        id = ip->out();
-        goto CheckAndLoop;
-
-      case kInstNop:
-        if (!ip->last())
-          Push(id+1, p);  // try the next when we're done
-        id = ip->out();
-
-      CheckAndLoop:
-        // Sanity check: id is the head of its list, which must
-        // be the case if id-1 is the last of *its* list. :)
-        DCHECK(id == 0 || prog_->inst(id-1)->last());
-        if (ShouldVisit(id, p))
-          goto Loop;
-        break;
-
-      case kInstMatch: {
-        if (endmatch_ && p != end)
-          goto Next;
-
-        // We found a match.  If the caller doesn't care
-        // where the match is, no point going further.
-        if (nsubmatch_ == 0)
-          return true;
-
-        // Record best match so far.
-        // Only need to check end point, because this entire
-        // call is only considering one start position.
-        matched = true;
-        cap_[1] = p;
-        if (submatch_[0].data() == NULL ||
-            (longest_ && p > submatch_[0].data() + submatch_[0].size())) {
-          for (int i = 0; i < nsubmatch_; i++)
-            submatch_[i] =
-                StringPiece(cap_[2 * i],
-                            static_cast<size_t>(cap_[2 * i + 1] - cap_[2 * i]));
-        }
-
-        // If going for first match, we're done.
-        if (!longest_)
-          return true;
-
-        // If we used the entire text, no longer match is possible.
-        if (p == end)
-          return true;
-
-        // Otherwise, continue on in hope of a longer match.
-        // Note the absence of the ShouldVisit() check here
-        // due to execution remaining in the same list.
-      Next:
-        if (!ip->last()) {
-          id++;
-          goto Loop;
-        }
-        break;
-      }
-    }
-  }
-  return matched;
-}
-
-// Search text (within context) for prog_.
-bool BitState::Search(const StringPiece& text, const StringPiece& context,
-                      bool anchored, bool longest,
-                      StringPiece* submatch, int nsubmatch) {
-  // Search parameters.
-  text_ = text;
-  context_ = context;
-  if (context_.data() == NULL)
-    context_ = text;
-  if (prog_->anchor_start() && BeginPtr(context_) != BeginPtr(text))
-    return false;
-  if (prog_->anchor_end() && EndPtr(context_) != EndPtr(text))
-    return false;
-  anchored_ = anchored || prog_->anchor_start();
-  longest_ = longest || prog_->anchor_end();
-  endmatch_ = prog_->anchor_end();
-  submatch_ = submatch;
-  nsubmatch_ = nsubmatch;
-  for (int i = 0; i < nsubmatch_; i++)
-    submatch_[i] = StringPiece();
-
-  // Allocate scratch space.
-  int nvisited = prog_->list_count() * static_cast<int>(text.size()+1);
-  nvisited = (nvisited + kVisitedBits-1) / kVisitedBits;
-  visited_ = PODArray<uint64_t>(nvisited);
-  memset(visited_.data(), 0, nvisited*sizeof visited_[0]);
-
-  int ncap = 2*nsubmatch;
-  if (ncap < 2)
-    ncap = 2;
-  cap_ = PODArray<const char*>(ncap);
-  memset(cap_.data(), 0, ncap*sizeof cap_[0]);
-
-  // When sizeof(Job) == 16, we start with a nice round 1KiB. :)
-  job_ = PODArray<Job>(64);
-
-  // Anchored search must start at text.begin().
-  if (anchored_) {
-    cap_[0] = text.data();
-    return TrySearch(prog_->start(), text.data());
-  }
-
-  // Unanchored search, starting from each possible text position.
-  // Notice that we have to try the empty string at the end of
-  // the text, so the loop condition is p <= text.end(), not p < text.end().
-  // This looks like it's quadratic in the size of the text,
-  // but we are not clearing visited_ between calls to TrySearch,
-  // so no work is duplicated and it ends up still being linear.
-  const char* etext = text.data() + text.size();
-  for (const char* p = text.data(); p <= etext; p++) {
-    // Try to use prefix accel (e.g. memchr) to skip ahead.
-    if (p < etext && prog_->can_prefix_accel()) {
-      p = reinterpret_cast<const char*>(prog_->PrefixAccel(p, etext - p));
-      if (p == NULL)
-        p = etext;
-    }
-
-    cap_[0] = p;
-    if (TrySearch(prog_->start(), p))  // Match must be leftmost; done.
-      return true;
-    // Avoid invoking undefined behavior (arithmetic on a null pointer)
-    // by simply not continuing the loop.
-    if (p == NULL)
-      break;
-  }
-  return false;
-}
-
-// Bit-state search.
-bool Prog::SearchBitState(const StringPiece& text,
-                          const StringPiece& context,
-                          Anchor anchor,
-                          MatchKind kind,
-                          StringPiece* match,
-                          int nmatch) {
-  // If full match, we ask for an anchored longest match
-  // and then check that match[0] == text.
-  // So make sure match[0] exists.
-  StringPiece sp0;
-  if (kind == kFullMatch) {
-    anchor = kAnchored;
-    if (nmatch < 1) {
-      match = &sp0;
-      nmatch = 1;
-    }
-  }
-
-  // Run the search.
-  BitState b(this);
-  bool anchored = anchor == kAnchored;
-  bool longest = kind != kFirstMatch;
-  if (!b.Search(text, context, anchored, longest, match, nmatch))
-    return false;
-  if (kind == kFullMatch && EndPtr(match[0]) != EndPtr(text))
-    return false;
-  return true;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/compile.cc b/src/duckdb/third_party/re2/re2/compile.cc
deleted file mode 100644
index cb03d8d4a..000000000
--- a/src/duckdb/third_party/re2/re2/compile.cc
+++ /dev/null
@@ -1,1261 +0,0 @@
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Compile regular expression to Prog.
-//
-// Prog and Inst are defined in prog.h.
-// This file's external interface is just Regexp::CompileToProg.
-// The Compiler class defined in this file is private.
-
-#include <stdint.h>
-#include <string.h>
-#include <unordered_map>
-#include <utility>
-
-#include "util/logging.h"
-#include "util/utf.h"
-#include "re2/pod_array.h"
-#include "re2/prog.h"
-#include "re2/re2.h"
-#include "re2/regexp.h"
-#include "re2/walker-inl.h"
-
-namespace duckdb_re2 {
-
-// List of pointers to Inst* that need to be filled in (patched).
-// Because the Inst* haven't been filled in yet,
-// we can use the Inst* word to hold the list's "next" pointer.
-// It's kind of sleazy, but it works well in practice.
-// See http://swtch.com/~rsc/regexp/regexp1.html for inspiration.
-//
-// Because the out and out1 fields in Inst are no longer pointers,
-// we can't use pointers directly here either.  Instead, head refers
-// to inst_[head>>1].out (head&1 == 0) or inst_[head>>1].out1 (head&1 == 1).
-// head == 0 represents the NULL list.  This is okay because instruction #0
-// is always the fail instruction, which never appears on a list.
-struct PatchList {
-  // Returns patch list containing just p.
-  static PatchList Mk(uint32_t p) {
-    return {p, p};
-  }
-
-  // Patches all the entries on l to have value p.
-  // Caller must not ever use patch list again.
-  static void Patch(Prog::Inst* inst0, PatchList l, uint32_t p) {
-    while (l.head != 0) {
-      Prog::Inst* ip = &inst0[l.head>>1];
-      if (l.head&1) {
-        l.head = ip->out1();
-        ip->out1_ = p;
-      } else {
-        l.head = ip->out();
-        ip->set_out(p);
-      }
-    }
-  }
-
-  // Appends two patch lists and returns result.
-  static PatchList Append(Prog::Inst* inst0, PatchList l1, PatchList l2) {
-    if (l1.head == 0)
-      return l2;
-    if (l2.head == 0)
-      return l1;
-    Prog::Inst* ip = &inst0[l1.tail>>1];
-    if (l1.tail&1)
-      ip->out1_ = l2.head;
-    else
-      ip->set_out(l2.head);
-    return {l1.head, l2.tail};
-  }
-
-  uint32_t head;
-  uint32_t tail;  // for constant-time append
-};
-
-static const PatchList kNullPatchList = {0, 0};
-
-// Compiled program fragment.
-struct Frag {
-  uint32_t begin;
-  PatchList end;
-  bool nullable;
-
-  Frag() : begin(0), end(kNullPatchList), nullable(false) {}
-  Frag(uint32_t begin, PatchList end, bool nullable)
-      : begin(begin), end(end), nullable(nullable) {}
-};
-
-// Input encodings.
-enum Encoding {
-  kEncodingUTF8 = 1,  // UTF-8 (0-10FFFF)
-  kEncodingLatin1,    // Latin-1 (0-FF)
-};
-
-class Compiler : public Regexp::Walker<Frag> {
- public:
-  explicit Compiler();
-  ~Compiler();
-
-  // Compiles Regexp to a new Prog.
-  // Caller is responsible for deleting Prog when finished with it.
-  // If reversed is true, compiles for walking over the input
-  // string backward (reverses all concatenations).
-  static Prog *Compile(Regexp* re, bool reversed, int64_t max_mem);
-
-  // Compiles alternation of all the re to a new Prog.
-  // Each re has a match with an id equal to its index in the vector.
-  static Prog* CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem);
-
-  // Interface for Regexp::Walker, which helps traverse the Regexp.
-  // The walk is purely post-recursive: given the machines for the
-  // children, PostVisit combines them to create the machine for
-  // the current node.  The child_args are Frags.
-  // The Compiler traverses the Regexp parse tree, visiting
-  // each node in depth-first order.  It invokes PreVisit before
-  // visiting the node's children and PostVisit after visiting
-  // the children.
-  Frag PreVisit(Regexp* re, Frag parent_arg, bool* stop);
-  Frag PostVisit(Regexp* re, Frag parent_arg, Frag pre_arg, Frag* child_args,
-                 int nchild_args);
-  Frag ShortVisit(Regexp* re, Frag parent_arg);
-  Frag Copy(Frag arg);
-
-  // Given fragment a, returns a+ or a+?; a* or a*?; a? or a??
-  Frag Plus(Frag a, bool nongreedy);
-  Frag Star(Frag a, bool nongreedy);
-  Frag Quest(Frag a, bool nongreedy);
-
-  // Given fragment a, returns (a) capturing as \n.
-  Frag Capture(Frag a, int n);
-
-  // Given fragments a and b, returns ab; a|b
-  Frag Cat(Frag a, Frag b);
-  Frag Alt(Frag a, Frag b);
-
-  // Returns a fragment that can't match anything.
-  Frag NoMatch();
-
-  // Returns a fragment that matches the empty string.
-  Frag Match(int32_t id);
-
-  // Returns a no-op fragment.
-  Frag Nop();
-
-  // Returns a fragment matching the byte range lo-hi.
-  Frag ByteRange(int lo, int hi, bool foldcase);
-
-  // Returns a fragment matching an empty-width special op.
-  Frag EmptyWidth(EmptyOp op);
-
-  // Adds n instructions to the program.
-  // Returns the index of the first one.
-  // Returns -1 if no more instructions are available.
-  int AllocInst(int n);
-
-  // Rune range compiler.
-
-  // Begins a new alternation.
-  void BeginRange();
-
-  // Adds a fragment matching the rune range lo-hi.
-  void AddRuneRange(Rune lo, Rune hi, bool foldcase);
-  void AddRuneRangeLatin1(Rune lo, Rune hi, bool foldcase);
-  void AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase);
-  void Add_80_10ffff();
-
-  // New suffix that matches the byte range lo-hi, then goes to next.
-  int UncachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase, int next);
-  int CachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase, int next);
-
-  // Returns true iff the suffix is cached.
-  bool IsCachedRuneByteSuffix(int id);
-
-  // Adds a suffix to alternation.
-  void AddSuffix(int id);
-
-  // Adds a suffix to the trie starting from the given root node.
-  // Returns zero iff allocating an instruction fails. Otherwise, returns
-  // the current root node, which might be different from what was given.
-  int AddSuffixRecursive(int root, int id);
-
-  // Finds the trie node for the given suffix. Returns a Frag in order to
-  // distinguish between pointing at the root node directly (end.head == 0)
-  // and pointing at an Alt's out1 or out (end.head&1 == 1 or 0, respectively).
-  Frag FindByteRange(int root, int id);
-
-  // Compares two ByteRanges and returns true iff they are equal.
-  bool ByteRangeEqual(int id1, int id2);
-
-  // Returns the alternation of all the added suffixes.
-  Frag EndRange();
-
-  // Single rune.
-  Frag Literal(Rune r, bool foldcase);
-
-  void Setup(Regexp::ParseFlags flags, int64_t max_mem, RE2::Anchor anchor);
-  Prog* Finish(Regexp* re);
-
-  // Returns .* where dot = any byte
-  Frag DotStar();
-
- private:
-  Prog* prog_;         // Program being built.
-  bool failed_;        // Did we give up compiling?
-  Encoding encoding_;  // Input encoding
-  bool reversed_;      // Should program run backward over text?
-
-  PODArray<Prog::Inst> inst_;
-  int ninst_;          // Number of instructions used.
-  int max_ninst_;      // Maximum number of instructions.
-
-  int64_t max_mem_;    // Total memory budget.
-
-  std::unordered_map<uint64_t, int> rune_cache_;
-  Frag rune_range_;
-
-  RE2::Anchor anchor_;  // anchor mode for RE2::Set
-
-  Compiler(const Compiler&) = delete;
-  Compiler& operator=(const Compiler&) = delete;
-};
-
-Compiler::Compiler() {
-  prog_ = new Prog();
-  failed_ = false;
-  encoding_ = kEncodingUTF8;
-  reversed_ = false;
-  ninst_ = 0;
-  max_ninst_ = 1;  // make AllocInst for fail instruction okay
-  max_mem_ = 0;
-  int fail = AllocInst(1);
-  inst_[fail].InitFail();
-  max_ninst_ = 0;  // Caller must change
-}
-
-Compiler::~Compiler() {
-  delete prog_;
-}
-
-int Compiler::AllocInst(int n) {
-  if (failed_ || ninst_ + n > max_ninst_) {
-    failed_ = true;
-    return -1;
-  }
-
-  if (ninst_ + n > inst_.size()) {
-    int cap = inst_.size();
-    if (cap == 0)
-      cap = 8;
-    while (ninst_ + n > cap)
-      cap *= 2;
-    PODArray<Prog::Inst> inst(cap);
-    if (inst_.data() != NULL)
-      memmove(inst.data(), inst_.data(), ninst_*sizeof inst_[0]);
-    memset(inst.data() + ninst_, 0, (cap - ninst_)*sizeof inst_[0]);
-    inst_ = std::move(inst);
-  }
-  int id = ninst_;
-  ninst_ += n;
-  return id;
-}
-
-// These routines are somewhat hard to visualize in text --
-// see http://swtch.com/~rsc/regexp/regexp1.html for
-// pictures explaining what is going on here.
-
-// Returns an unmatchable fragment.
-Frag Compiler::NoMatch() {
-  return Frag();
-}
-
-// Is a an unmatchable fragment?
-static bool IsNoMatch(Frag a) {
-  return a.begin == 0;
-}
-
-// Given fragments a and b, returns fragment for ab.
-Frag Compiler::Cat(Frag a, Frag b) {
-  if (IsNoMatch(a) || IsNoMatch(b))
-    return NoMatch();
-
-  // Elide no-op.
-  Prog::Inst* begin = &inst_[a.begin];
-  if (begin->opcode() == kInstNop &&
-      a.end.head == (a.begin << 1) &&
-      begin->out() == 0) {
-    // in case refs to a somewhere
-    PatchList::Patch(inst_.data(), a.end, b.begin);
-    return b;
-  }
-
-  // To run backward over string, reverse all concatenations.
-  if (reversed_) {
-    PatchList::Patch(inst_.data(), b.end, a.begin);
-    return Frag(b.begin, a.end, b.nullable && a.nullable);
-  }
-
-  PatchList::Patch(inst_.data(), a.end, b.begin);
-  return Frag(a.begin, b.end, a.nullable && b.nullable);
-}
-
-// Given fragments for a and b, returns fragment for a|b.
-Frag Compiler::Alt(Frag a, Frag b) {
-  // Special case for convenience in loops.
-  if (IsNoMatch(a))
-    return b;
-  if (IsNoMatch(b))
-    return a;
-
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-
-  inst_[id].InitAlt(a.begin, b.begin);
-  return Frag(id, PatchList::Append(inst_.data(), a.end, b.end),
-              a.nullable || b.nullable);
-}
-
-// When capturing submatches in like-Perl mode, a kOpAlt Inst
-// treats out_ as the first choice, out1_ as the second.
-//
-// For *, +, and ?, if out_ causes another repetition,
-// then the operator is greedy.  If out1_ is the repetition
-// (and out_ moves forward), then the operator is non-greedy.
-
-// Given a fragment for a, returns a fragment for a+ or a+? (if nongreedy)
-Frag Compiler::Plus(Frag a, bool nongreedy) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  PatchList pl;
-  if (nongreedy) {
-    inst_[id].InitAlt(0, a.begin);
-    pl = PatchList::Mk(id << 1);
-  } else {
-    inst_[id].InitAlt(a.begin, 0);
-    pl = PatchList::Mk((id << 1) | 1);
-  }
-  PatchList::Patch(inst_.data(), a.end, id);
-  return Frag(a.begin, pl, a.nullable);
-}
-
-// Given a fragment for a, returns a fragment for a* or a*? (if nongreedy)
-Frag Compiler::Star(Frag a, bool nongreedy) {
-  // When the subexpression is nullable, one Alt isn't enough to guarantee
-  // correct priority ordering within the transitive closure. The simplest
-  // solution is to handle it as (a+)? instead, which adds the second Alt.
-  if (a.nullable)
-    return Quest(Plus(a, nongreedy), nongreedy);
-
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  PatchList pl;
-  if (nongreedy) {
-    inst_[id].InitAlt(0, a.begin);
-    pl = PatchList::Mk(id << 1);
-  } else {
-    inst_[id].InitAlt(a.begin, 0);
-    pl = PatchList::Mk((id << 1) | 1);
-  }
-  PatchList::Patch(inst_.data(), a.end, id);
-  return Frag(id, pl, true);
-}
-
-// Given a fragment for a, returns a fragment for a? or a?? (if nongreedy)
-Frag Compiler::Quest(Frag a, bool nongreedy) {
-  if (IsNoMatch(a))
-    return Nop();
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  PatchList pl;
-  if (nongreedy) {
-    inst_[id].InitAlt(0, a.begin);
-    pl = PatchList::Mk(id << 1);
-  } else {
-    inst_[id].InitAlt(a.begin, 0);
-    pl = PatchList::Mk((id << 1) | 1);
-  }
-  return Frag(id, PatchList::Append(inst_.data(), pl, a.end), true);
-}
-
-// Returns a fragment for the byte range lo-hi.
-Frag Compiler::ByteRange(int lo, int hi, bool foldcase) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitByteRange(lo, hi, foldcase, 0);
-  return Frag(id, PatchList::Mk(id << 1), false);
-}
-
-// Returns a no-op fragment.  Sometimes unavoidable.
-Frag Compiler::Nop() {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitNop(0);
-  return Frag(id, PatchList::Mk(id << 1), true);
-}
-
-// Returns a fragment that signals a match.
-Frag Compiler::Match(int32_t match_id) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitMatch(match_id);
-  return Frag(id, kNullPatchList, false);
-}
-
-// Returns a fragment matching a particular empty-width op (like ^ or $)
-Frag Compiler::EmptyWidth(EmptyOp empty) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitEmptyWidth(empty, 0);
-  return Frag(id, PatchList::Mk(id << 1), true);
-}
-
-// Given a fragment a, returns a fragment with capturing parens around a.
-Frag Compiler::Capture(Frag a, int n) {
-  if (IsNoMatch(a))
-    return NoMatch();
-  int id = AllocInst(2);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitCapture(2*n, a.begin);
-  inst_[id+1].InitCapture(2*n+1, 0);
-  PatchList::Patch(inst_.data(), a.end, id+1);
-
-  return Frag(id, PatchList::Mk((id+1) << 1), a.nullable);
-}
-
-// A Rune is a name for a Unicode code point.
-// Returns maximum rune encoded by UTF-8 sequence of length len.
-static int MaxRune(int len) {
-  int b;  // number of Rune bits in len-byte UTF-8 sequence (len < UTFmax)
-  if (len == 1)
-    b = 7;
-  else
-    b = 8-(len+1) + 6*(len-1);
-  return (1<<b) - 1;   // maximum Rune for b bits.
-}
-
-// The rune range compiler caches common suffix fragments,
-// which are very common in UTF-8 (e.g., [80-bf]).
-// The fragment suffixes are identified by their start
-// instructions.  NULL denotes the eventual end match.
-// The Frag accumulates in rune_range_.  Caching common
-// suffixes reduces the UTF-8 "." from 32 to 24 instructions,
-// and it reduces the corresponding one-pass NFA from 16 nodes to 8.
-
-void Compiler::BeginRange() {
-  rune_cache_.clear();
-  rune_range_.begin = 0;
-  rune_range_.end = kNullPatchList;
-}
-
-int Compiler::UncachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase,
-                                     int next) {
-  Frag f = ByteRange(lo, hi, foldcase);
-  if (next != 0) {
-    PatchList::Patch(inst_.data(), f.end, next);
-  } else {
-    rune_range_.end = PatchList::Append(inst_.data(), rune_range_.end, f.end);
-  }
-  return f.begin;
-}
-
-static uint64_t MakeRuneCacheKey(uint8_t lo, uint8_t hi, bool foldcase,
-                                 int next) {
-  return (uint64_t)next << 17 |
-         (uint64_t)lo   <<  9 |
-         (uint64_t)hi   <<  1 |
-         (uint64_t)foldcase;
-}
-
-int Compiler::CachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase,
-                                   int next) {
-  uint64_t key = MakeRuneCacheKey(lo, hi, foldcase, next);
-  std::unordered_map<uint64_t, int>::const_iterator it = rune_cache_.find(key);
-  if (it != rune_cache_.end())
-    return it->second;
-  int id = UncachedRuneByteSuffix(lo, hi, foldcase, next);
-  rune_cache_[key] = id;
-  return id;
-}
-
-bool Compiler::IsCachedRuneByteSuffix(int id) {
-  uint8_t lo = inst_[id].byte_range.lo_;
-  uint8_t hi = inst_[id].byte_range.hi_;
-  bool foldcase = inst_[id].foldcase() != 0;
-  int next = inst_[id].out();
-
-  uint64_t key = MakeRuneCacheKey(lo, hi, foldcase, next);
-  return rune_cache_.find(key) != rune_cache_.end();
-}
-
-void Compiler::AddSuffix(int id) {
-  if (failed_)
-    return;
-
-  if (rune_range_.begin == 0) {
-    rune_range_.begin = id;
-    return;
-  }
-
-  if (encoding_ == kEncodingUTF8) {
-    // Build a trie in order to reduce fanout.
-    rune_range_.begin = AddSuffixRecursive(rune_range_.begin, id);
-    return;
-  }
-
-  int alt = AllocInst(1);
-  if (alt < 0) {
-    rune_range_.begin = 0;
-    return;
-  }
-  inst_[alt].InitAlt(rune_range_.begin, id);
-  rune_range_.begin = alt;
-}
-
-int Compiler::AddSuffixRecursive(int root, int id) {
-  DCHECK(inst_[root].opcode() == kInstAlt ||
-         inst_[root].opcode() == kInstByteRange);
-
-  Frag f = FindByteRange(root, id);
-  if (IsNoMatch(f)) {
-    int alt = AllocInst(1);
-    if (alt < 0)
-      return 0;
-    inst_[alt].InitAlt(root, id);
-    return alt;
-  }
-
-  int br;
-  if (f.end.head == 0)
-    br = root;
-  else if (f.end.head&1)
-    br = inst_[f.begin].out1();
-  else
-    br = inst_[f.begin].out();
-
-  if (IsCachedRuneByteSuffix(br)) {
-    // We can't fiddle with cached suffixes, so make a clone of the head.
-    int byterange = AllocInst(1);
-    if (byterange < 0)
-      return 0;
-    inst_[byterange].InitByteRange(inst_[br].lo(), inst_[br].hi(),
-                                   inst_[br].foldcase(), inst_[br].out());
-
-    // Ensure that the parent points to the clone, not to the original.
-    // Note that this could leave the head unreachable except via the cache.
-    br = byterange;
-    if (f.end.head == 0)
-      root = br;
-    else if (f.end.head&1)
-      inst_[f.begin].out1_ = br;
-    else
-      inst_[f.begin].set_out(br);
-  }
-
-  int out = inst_[id].out();
-  if (!IsCachedRuneByteSuffix(id)) {
-    // The head should be the instruction most recently allocated, so free it
-    // instead of leaving it unreachable.
-    DCHECK_EQ(id, ninst_-1);
-    inst_[id].out_opcode_ = 0;
-    inst_[id].out1_ = 0;
-    ninst_--;
-  }
-
-  out = AddSuffixRecursive(inst_[br].out(), out);
-  if (out == 0)
-    return 0;
-
-  inst_[br].set_out(out);
-  return root;
-}
-
-bool Compiler::ByteRangeEqual(int id1, int id2) {
-  return inst_[id1].lo() == inst_[id2].lo() &&
-         inst_[id1].hi() == inst_[id2].hi() &&
-         inst_[id1].foldcase() == inst_[id2].foldcase();
-}
-
-Frag Compiler::FindByteRange(int root, int id) {
-  if (inst_[root].opcode() == kInstByteRange) {
-    if (ByteRangeEqual(root, id))
-      return Frag(root, kNullPatchList, false);
-    else
-      return NoMatch();
-  }
-
-  while (inst_[root].opcode() == kInstAlt) {
-    int out1 = inst_[root].out1();
-    if (ByteRangeEqual(out1, id))
-      return Frag(root, PatchList::Mk((root << 1) | 1), false);
-
-    // CharClass is a sorted list of ranges, so if out1 of the root Alt wasn't
-    // what we're looking for, then we can stop immediately. Unfortunately, we
-    // can't short-circuit the search in reverse mode.
-    if (!reversed_)
-      return NoMatch();
-
-    int out = inst_[root].out();
-    if (inst_[out].opcode() == kInstAlt)
-      root = out;
-    else if (ByteRangeEqual(out, id))
-      return Frag(root, PatchList::Mk(root << 1), false);
-    else
-      return NoMatch();
-  }
-
-  LOG(DFATAL) << "should never happen";
-  return NoMatch();
-}
-
-Frag Compiler::EndRange() {
-  return rune_range_;
-}
-
-// Converts rune range lo-hi into a fragment that recognizes
-// the bytes that would make up those runes in the current
-// encoding (Latin 1 or UTF-8).
-// This lets the machine work byte-by-byte even when
-// using multibyte encodings.
-
-void Compiler::AddRuneRange(Rune lo, Rune hi, bool foldcase) {
-  switch (encoding_) {
-    default:
-    case kEncodingUTF8:
-      AddRuneRangeUTF8(lo, hi, foldcase);
-      break;
-    case kEncodingLatin1:
-      AddRuneRangeLatin1(lo, hi, foldcase);
-      break;
-  }
-}
-
-void Compiler::AddRuneRangeLatin1(Rune lo, Rune hi, bool foldcase) {
-  // Latin-1 is easy: runes *are* bytes.
-  if (lo > hi || lo > 0xFF)
-    return;
-  if (hi > 0xFF)
-    hi = 0xFF;
-  AddSuffix(UncachedRuneByteSuffix(static_cast<uint8_t>(lo),
-                                   static_cast<uint8_t>(hi), foldcase, 0));
-}
-
-void Compiler::Add_80_10ffff() {
-  // The 80-10FFFF (Runeself-Runemax) rune range occurs frequently enough
-  // (for example, for /./ and /[^a-z]/) that it is worth simplifying: by
-  // permitting overlong encodings in E0 and F0 sequences and code points
-  // over 10FFFF in F4 sequences, the size of the bytecode and the number
-  // of equivalence classes are reduced significantly.
-  int id;
-  if (reversed_) {
-    // Prefix factoring matters, but we don't have to handle it here
-    // because the rune range trie logic takes care of that already.
-    id = UncachedRuneByteSuffix(0xC2, 0xDF, false, 0);
-    id = UncachedRuneByteSuffix(0x80, 0xBF, false, id);
-    AddSuffix(id);
-
-    id = UncachedRuneByteSuffix(0xE0, 0xEF, false, 0);
-    id = UncachedRuneByteSuffix(0x80, 0xBF, false, id);
-    id = UncachedRuneByteSuffix(0x80, 0xBF, false, id);
-    AddSuffix(id);
-
-    id = UncachedRuneByteSuffix(0xF0, 0xF4, false, 0);
-    id = UncachedRuneByteSuffix(0x80, 0xBF, false, id);
-    id = UncachedRuneByteSuffix(0x80, 0xBF, false, id);
-    id = UncachedRuneByteSuffix(0x80, 0xBF, false, id);
-    AddSuffix(id);
-  } else {
-    // Suffix factoring matters - and we do have to handle it here.
-    int cont1 = UncachedRuneByteSuffix(0x80, 0xBF, false, 0);
-    id = UncachedRuneByteSuffix(0xC2, 0xDF, false, cont1);
-    AddSuffix(id);
-
-    int cont2 = UncachedRuneByteSuffix(0x80, 0xBF, false, cont1);
-    id = UncachedRuneByteSuffix(0xE0, 0xEF, false, cont2);
-    AddSuffix(id);
-
-    int cont3 = UncachedRuneByteSuffix(0x80, 0xBF, false, cont2);
-    id = UncachedRuneByteSuffix(0xF0, 0xF4, false, cont3);
-    AddSuffix(id);
-  }
-}
-
-void Compiler::AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase) {
-  if (lo > hi)
-    return;
-
-  // Pick off 80-10FFFF as a common special case.
-  if (lo == 0x80 && hi == 0x10ffff) {
-    Add_80_10ffff();
-    return;
-  }
-
-  // Split range into same-length sized ranges.
-  for (int i = 1; i < UTFmax; i++) {
-    Rune max = MaxRune(i);
-    if (lo <= max && max < hi) {
-      AddRuneRangeUTF8(lo, max, foldcase);
-      AddRuneRangeUTF8(max+1, hi, foldcase);
-      return;
-    }
-  }
-
-  // ASCII range is always a special case.
-  if (hi < Runeself) {
-    AddSuffix(UncachedRuneByteSuffix(static_cast<uint8_t>(lo),
-                                     static_cast<uint8_t>(hi), foldcase, 0));
-    return;
-  }
-
-  // Split range into sections that agree on leading bytes.
-  for (int i = 1; i < UTFmax; i++) {
-    uint32_t m = (1<<(6*i)) - 1;  // last i bytes of a UTF-8 sequence
-    if ((lo & ~m) != (hi & ~m)) {
-      if ((lo & m) != 0) {
-        AddRuneRangeUTF8(lo, lo|m, foldcase);
-        AddRuneRangeUTF8((lo|m)+1, hi, foldcase);
-        return;
-      }
-      if ((hi & m) != m) {
-        AddRuneRangeUTF8(lo, (hi&~m)-1, foldcase);
-        AddRuneRangeUTF8(hi&~m, hi, foldcase);
-        return;
-      }
-    }
-  }
-
-  // Finally.  Generate byte matching equivalent for lo-hi.
-  uint8_t ulo[UTFmax], uhi[UTFmax];
-  int n = runetochar(reinterpret_cast<char*>(ulo), &lo);
-  int m = runetochar(reinterpret_cast<char*>(uhi), &hi);
-  (void)m;  // USED(m)
-  DCHECK_EQ(n, m);
-
-  // The logic below encodes this thinking:
-  //
-  // 1. When we have built the whole suffix, we know that it cannot
-  // possibly be a suffix of anything longer: in forward mode, nothing
-  // else can occur before the leading byte; in reverse mode, nothing
-  // else can occur after the last continuation byte or else the leading
-  // byte would have to change. Thus, there is no benefit to caching
-  // the first byte of the suffix whereas there is a cost involved in
-  // cloning it if it begins a common prefix, which is fairly likely.
-  //
-  // 2. Conversely, the last byte of the suffix cannot possibly be a
-  // prefix of anything because next == 0, so we will never want to
-  // clone it, but it is fairly likely to be a common suffix. Perhaps
-  // more so in reverse mode than in forward mode because the former is
-  // "converging" towards lower entropy, but caching is still worthwhile
-  // for the latter in cases such as 80-BF.
-  //
-  // 3. Handling the bytes between the first and the last is less
-  // straightforward and, again, the approach depends on whether we are
-  // "converging" towards lower entropy: in forward mode, a single byte
-  // is unlikely to be part of a common suffix whereas a byte range
-  // is more likely so; in reverse mode, a byte range is unlikely to
-  // be part of a common suffix whereas a single byte is more likely
-  // so. The same benefit versus cost argument applies here.
-  int id = 0;
-  if (reversed_) {
-    for (int i = 0; i < n; i++) {
-      // In reverse UTF-8 mode: cache the leading byte; don't cache the last
-      // continuation byte; cache anything else iff it's a single byte (XX-XX).
-      if (i == 0 || (ulo[i] == uhi[i] && i != n-1))
-        id = CachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-      else
-        id = UncachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-    }
-  } else {
-    for (int i = n-1; i >= 0; i--) {
-      // In forward UTF-8 mode: don't cache the leading byte; cache the last
-      // continuation byte; cache anything else iff it's a byte range (XX-YY).
-      if (i == n-1 || (ulo[i] < uhi[i] && i != 0))
-        id = CachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-      else
-        id = UncachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-    }
-  }
-  AddSuffix(id);
-}
-
-// Should not be called.
-Frag Compiler::Copy(Frag arg) {
-  // We're using WalkExponential; there should be no copying.
-  failed_ = true;
-  LOG(DFATAL) << "Compiler::Copy called!";
-  return NoMatch();
-}
-
-// Visits a node quickly; called once WalkExponential has
-// decided to cut this walk short.
-Frag Compiler::ShortVisit(Regexp* re, Frag) {
-  failed_ = true;
-  return NoMatch();
-}
-
-// Called before traversing a node's children during the walk.
-Frag Compiler::PreVisit(Regexp* re, Frag, bool* stop) {
-  // Cut off walk if we've already failed.
-  if (failed_)
-    *stop = true;
-
-  return Frag();  // not used by caller
-}
-
-Frag Compiler::Literal(Rune r, bool foldcase) {
-  switch (encoding_) {
-    default:
-      return Frag();
-
-    case kEncodingLatin1:
-      return ByteRange(r, r, foldcase);
-
-    case kEncodingUTF8: {
-      if (r < Runeself)  // Make common case fast.
-        return ByteRange(r, r, foldcase);
-      uint8_t buf[UTFmax];
-      int n = runetochar(reinterpret_cast<char*>(buf), &r);
-      Frag f = ByteRange((uint8_t)buf[0], buf[0], false);
-      for (int i = 1; i < n; i++)
-        f = Cat(f, ByteRange((uint8_t)buf[i], buf[i], false));
-      return f;
-    }
-  }
-}
-
-// Called after traversing the node's children during the walk.
-// Given their frags, build and return the frag for this re.
-Frag Compiler::PostVisit(Regexp* re, Frag, Frag, Frag* child_frags,
-                         int nchild_frags) {
-  // If a child failed, don't bother going forward, especially
-  // since the child_frags might contain Frags with NULLs in them.
-  if (failed_)
-    return NoMatch();
-
-  // Given the child fragments, return the fragment for this node.
-  switch (re->op()) {
-    case kRegexpRepeat:
-      // Should not see; code at bottom of function will print error
-      break;
-
-    case kRegexpNoMatch:
-      return NoMatch();
-
-    case kRegexpEmptyMatch:
-      return Nop();
-
-    case kRegexpHaveMatch: {
-      Frag f = Match(re->match_id());
-      if (anchor_ == RE2::ANCHOR_BOTH) {
-        // Append \z or else the subexpression will effectively be unanchored.
-        // Complemented by the UNANCHORED case in CompileSet().
-        f = Cat(EmptyWidth(kEmptyEndText), f);
-      }
-      return f;
-    }
-
-    case kRegexpConcat: {
-      Frag f = child_frags[0];
-      for (int i = 1; i < nchild_frags; i++)
-        f = Cat(f, child_frags[i]);
-      return f;
-    }
-
-    case kRegexpAlternate: {
-      Frag f = child_frags[0];
-      for (int i = 1; i < nchild_frags; i++)
-        f = Alt(f, child_frags[i]);
-      return f;
-    }
-
-    case kRegexpStar:
-      return Star(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
-
-    case kRegexpPlus:
-      return Plus(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
-
-    case kRegexpQuest:
-      return Quest(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
-
-    case kRegexpLiteral:
-      return Literal(re->rune(), (re->parse_flags()&Regexp::FoldCase) != 0);
-
-    case kRegexpLiteralString: {
-      // Concatenation of literals.
-      if (re->nrunes() == 0)
-        return Nop();
-      Frag f;
-      for (int i = 0; i < re->nrunes(); i++) {
-        Frag f1 = Literal(re->runes()[i],
-                          (re->parse_flags()&Regexp::FoldCase) != 0);
-        if (i == 0)
-          f = f1;
-        else
-          f = Cat(f, f1);
-      }
-      return f;
-    }
-
-    case kRegexpAnyChar:
-      BeginRange();
-      AddRuneRange(0, Runemax, false);
-      return EndRange();
-
-    case kRegexpAnyByte:
-      return ByteRange(0x00, 0xFF, false);
-
-    case kRegexpCharClass: {
-      CharClass* cc = re->cc();
-      if (cc->empty()) {
-        // This can't happen.
-        failed_ = true;
-        LOG(DFATAL) << "No ranges in char class";
-        return NoMatch();
-      }
-
-      // ASCII case-folding optimization: if the char class
-      // behaves the same on A-Z as it does on a-z,
-      // discard any ranges wholly contained in A-Z
-      // and mark the other ranges as foldascii.
-      // This reduces the size of a program for
-      // (?i)abc from 3 insts per letter to 1 per letter.
-      bool foldascii = cc->FoldsASCII();
-
-      // Character class is just a big OR of the different
-      // character ranges in the class.
-      BeginRange();
-      for (CharClass::iterator i = cc->begin(); i != cc->end(); ++i) {
-        // ASCII case-folding optimization (see above).
-        if (foldascii && 'A' <= i->lo && i->hi <= 'Z')
-          continue;
-
-        // If this range contains all of A-Za-z or none of it,
-        // the fold flag is unnecessary; don't bother.
-        bool fold = foldascii;
-        if ((i->lo <= 'A' && 'z' <= i->hi) || i->hi < 'A' || 'z' < i->lo ||
-            ('Z' < i->lo && i->hi < 'a'))
-          fold = false;
-
-        AddRuneRange(i->lo, i->hi, fold);
-      }
-      return EndRange();
-    }
-
-    case kRegexpCapture:
-      // If this is a non-capturing parenthesis -- (?:foo) --
-      // just use the inner expression.
-      if (re->cap() < 0)
-        return child_frags[0];
-      return Capture(child_frags[0], re->cap());
-
-    case kRegexpBeginLine:
-      return EmptyWidth(reversed_ ? kEmptyEndLine : kEmptyBeginLine);
-
-    case kRegexpEndLine:
-      return EmptyWidth(reversed_ ? kEmptyBeginLine : kEmptyEndLine);
-
-    case kRegexpBeginText:
-      return EmptyWidth(reversed_ ? kEmptyEndText : kEmptyBeginText);
-
-    case kRegexpEndText:
-      return EmptyWidth(reversed_ ? kEmptyBeginText : kEmptyEndText);
-
-    case kRegexpWordBoundary:
-      return EmptyWidth(kEmptyWordBoundary);
-
-    case kRegexpNoWordBoundary:
-      return EmptyWidth(kEmptyNonWordBoundary);
-  }
-  failed_ = true;
-  LOG(DFATAL) << "Missing case in Compiler: " << re->op();
-  return NoMatch();
-}
-
-// Is this regexp required to start at the beginning of the text?
-// Only approximate; can return false for complicated regexps like (\Aa|\Ab),
-// but handles (\A(a|b)).  Could use the Walker to write a more exact one.
-static bool IsAnchorStart(Regexp** pre, int depth) {
-  Regexp* re = *pre;
-  Regexp* sub;
-  // The depth limit makes sure that we don't overflow
-  // the stack on a deeply nested regexp.  As the comment
-  // above says, IsAnchorStart is conservative, so returning
-  // a false negative is okay.  The exact limit is somewhat arbitrary.
-  if (re == NULL || depth >= 4)
-    return false;
-  switch (re->op()) {
-    default:
-      break;
-    case kRegexpConcat:
-      if (re->nsub() > 0) {
-        sub = re->sub()[0]->Incref();
-        if (IsAnchorStart(&sub, depth+1)) {
-          PODArray<Regexp*> subcopy(re->nsub());
-          subcopy[0] = sub;  // already have reference
-          for (int i = 1; i < re->nsub(); i++)
-            subcopy[i] = re->sub()[i]->Incref();
-          *pre = Regexp::Concat(subcopy.data(), re->nsub(), re->parse_flags());
-          re->Decref();
-          return true;
-        }
-        sub->Decref();
-      }
-      break;
-    case kRegexpCapture:
-      sub = re->sub()[0]->Incref();
-      if (IsAnchorStart(&sub, depth+1)) {
-        *pre = Regexp::Capture(sub, re->parse_flags(), re->cap());
-        re->Decref();
-        return true;
-      }
-      sub->Decref();
-      break;
-    case kRegexpBeginText:
-      *pre = Regexp::LiteralString(NULL, 0, re->parse_flags());
-      re->Decref();
-      return true;
-  }
-  return false;
-}
-
-// Is this regexp required to start at the end of the text?
-// Only approximate; can return false for complicated regexps like (a\z|b\z),
-// but handles ((a|b)\z).  Could use the Walker to write a more exact one.
-static bool IsAnchorEnd(Regexp** pre, int depth) {
-  Regexp* re = *pre;
-  Regexp* sub;
-  // The depth limit makes sure that we don't overflow
-  // the stack on a deeply nested regexp.  As the comment
-  // above says, IsAnchorEnd is conservative, so returning
-  // a false negative is okay.  The exact limit is somewhat arbitrary.
-  if (re == NULL || depth >= 4)
-    return false;
-  switch (re->op()) {
-    default:
-      break;
-    case kRegexpConcat:
-      if (re->nsub() > 0) {
-        sub = re->sub()[re->nsub() - 1]->Incref();
-        if (IsAnchorEnd(&sub, depth+1)) {
-          PODArray<Regexp*> subcopy(re->nsub());
-          subcopy[re->nsub() - 1] = sub;  // already have reference
-          for (int i = 0; i < re->nsub() - 1; i++)
-            subcopy[i] = re->sub()[i]->Incref();
-          *pre = Regexp::Concat(subcopy.data(), re->nsub(), re->parse_flags());
-          re->Decref();
-          return true;
-        }
-        sub->Decref();
-      }
-      break;
-    case kRegexpCapture:
-      sub = re->sub()[0]->Incref();
-      if (IsAnchorEnd(&sub, depth+1)) {
-        *pre = Regexp::Capture(sub, re->parse_flags(), re->cap());
-        re->Decref();
-        return true;
-      }
-      sub->Decref();
-      break;
-    case kRegexpEndText:
-      *pre = Regexp::LiteralString(NULL, 0, re->parse_flags());
-      re->Decref();
-      return true;
-  }
-  return false;
-}
-
-void Compiler::Setup(Regexp::ParseFlags flags, int64_t max_mem,
-                     RE2::Anchor anchor) {
-  if (flags & Regexp::Latin1)
-    encoding_ = kEncodingLatin1;
-  max_mem_ = max_mem;
-  if (max_mem <= 0) {
-    max_ninst_ = 100000;  // more than enough
-  } else if (static_cast<size_t>(max_mem) <= sizeof(Prog)) {
-    // No room for anything.
-    max_ninst_ = 0;
-  } else {
-    int64_t m = (max_mem - sizeof(Prog)) / sizeof(Prog::Inst);
-    // Limit instruction count so that inst->id() fits nicely in an int.
-    // SparseArray also assumes that the indices (inst->id()) are ints.
-    // The call to WalkExponential uses 2*max_ninst_ below,
-    // and other places in the code use 2 or 3 * prog->size().
-    // Limiting to 2^24 should avoid overflow in those places.
-    // (The point of allowing more than 32 bits of memory is to
-    // have plenty of room for the DFA states, not to use it up
-    // on the program.)
-    if (m >= 1<<24)
-      m = 1<<24;
-    // Inst imposes its own limit (currently bigger than 2^24 but be safe).
-    if (m > Prog::Inst::kMaxInst)
-      m = Prog::Inst::kMaxInst;
-    max_ninst_ = static_cast<int>(m);
-  }
-  anchor_ = anchor;
-}
-
-// Compiles re, returning program.
-// Caller is responsible for deleting prog_.
-// If reversed is true, compiles a program that expects
-// to run over the input string backward (reverses all concatenations).
-// The reversed flag is also recorded in the returned program.
-Prog* Compiler::Compile(Regexp* re, bool reversed, int64_t max_mem) {
-  Compiler c;
-  c.Setup(re->parse_flags(), max_mem, RE2::UNANCHORED /* unused */);
-  c.reversed_ = reversed;
-
-  // Simplify to remove things like counted repetitions
-  // and character classes like \d.
-  Regexp* sre = re->Simplify();
-  if (sre == NULL)
-    return NULL;
-
-  // Record whether prog is anchored, removing the anchors.
-  // (They get in the way of other optimizations.)
-  bool is_anchor_start = IsAnchorStart(&sre, 0);
-  bool is_anchor_end = IsAnchorEnd(&sre, 0);
-
-  // Generate fragment for entire regexp.
-  Frag all = c.WalkExponential(sre, Frag(), 2*c.max_ninst_);
-  sre->Decref();
-  if (c.failed_)
-    return NULL;
-
-  // Success!  Finish by putting Match node at end, and record start.
-  // Turn off c.reversed_ (if it is set) to force the remaining concatenations
-  // to behave normally.
-  c.reversed_ = false;
-  all = c.Cat(all, c.Match(0));
-
-  c.prog_->set_reversed(reversed);
-  if (c.prog_->reversed()) {
-    c.prog_->set_anchor_start(is_anchor_end);
-    c.prog_->set_anchor_end(is_anchor_start);
-  } else {
-    c.prog_->set_anchor_start(is_anchor_start);
-    c.prog_->set_anchor_end(is_anchor_end);
-  }
-
-  c.prog_->set_start(all.begin);
-  if (!c.prog_->anchor_start()) {
-    // Also create unanchored version, which starts with a .*? loop.
-    all = c.Cat(c.DotStar(), all);
-  }
-  c.prog_->set_start_unanchored(all.begin);
-
-  // Hand ownership of prog_ to caller.
-  return c.Finish(re);
-}
-
-Prog* Compiler::Finish(Regexp* re) {
-  if (failed_)
-    return NULL;
-
-  if (prog_->start() == 0 && prog_->start_unanchored() == 0) {
-    // No possible matches; keep Fail instruction only.
-    ninst_ = 1;
-  }
-
-  // Hand off the array to Prog.
-  prog_->inst_ = std::move(inst_);
-  prog_->size_ = ninst_;
-
-  prog_->Optimize();
-  prog_->Flatten();
-  prog_->ComputeByteMap();
-
-  if (!prog_->reversed()) {
-    std::string prefix;
-    bool prefix_foldcase;
-    if (re->RequiredPrefixForAccel(&prefix, &prefix_foldcase))
-      prog_->ConfigurePrefixAccel(prefix, prefix_foldcase);
-  }
-
-  // Record remaining memory for DFA.
-  if (max_mem_ <= 0) {
-    prog_->set_dfa_mem(1<<20);
-  } else {
-    int64_t m = max_mem_ - sizeof(Prog);
-    m -= prog_->size_*sizeof(Prog::Inst);  // account for inst_
-    if (prog_->CanBitState())
-      m -= prog_->size_*sizeof(uint16_t);  // account for list_heads_
-    if (m < 0)
-      m = 0;
-    prog_->set_dfa_mem(m);
-  }
-
-  Prog* p = prog_;
-  prog_ = NULL;
-  return p;
-}
-
-// Converts Regexp to Prog.
-Prog* Regexp::CompileToProg(int64_t max_mem) {
-  return Compiler::Compile(this, false, max_mem);
-}
-
-Prog* Regexp::CompileToReverseProg(int64_t max_mem) {
-  return Compiler::Compile(this, true, max_mem);
-}
-
-Frag Compiler::DotStar() {
-  return Star(ByteRange(0x00, 0xff, false), true);
-}
-
-// Compiles RE set to Prog.
-Prog* Compiler::CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem) {
-  Compiler c;
-  c.Setup(re->parse_flags(), max_mem, anchor);
-
-  Regexp* sre = re->Simplify();
-  if (sre == NULL)
-    return NULL;
-
-  Frag all = c.WalkExponential(sre, Frag(), 2*c.max_ninst_);
-  sre->Decref();
-  if (c.failed_)
-    return NULL;
-
-  c.prog_->set_anchor_start(true);
-  c.prog_->set_anchor_end(true);
-
-  if (anchor == RE2::UNANCHORED) {
-    // Prepend .* or else the expression will effectively be anchored.
-    // Complemented by the ANCHOR_BOTH case in PostVisit().
-    all = c.Cat(c.DotStar(), all);
-  }
-  c.prog_->set_start(all.begin);
-  c.prog_->set_start_unanchored(all.begin);
-
-  Prog* prog = c.Finish(re);
-  if (prog == NULL)
-    return NULL;
-
-  // Make sure DFA has enough memory to operate,
-  // since we're not going to fall back to the NFA.
-  bool dfa_failed = false;
-  StringPiece sp = "hello, world";
-  prog->SearchDFA(sp, sp, Prog::kAnchored, Prog::kManyMatch,
-                  NULL, &dfa_failed, NULL);
-  if (dfa_failed) {
-    delete prog;
-    return NULL;
-  }
-
-  return prog;
-}
-
-Prog* Prog::CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem) {
-  return Compiler::CompileSet(re, anchor, max_mem);
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/dfa.cc b/src/duckdb/third_party/re2/re2/dfa.cc
deleted file mode 100644
index 7793f8f56..000000000
--- a/src/duckdb/third_party/re2/re2/dfa.cc
+++ /dev/null
@@ -1,2072 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// A DFA (deterministic finite automaton)-based regular expression search.
-//
-// The DFA search has two main parts: the construction of the automaton,
-// which is represented by a graph of State structures, and the execution
-// of the automaton over a given input string.
-//
-// The basic idea is that the State graph is constructed so that the
-// execution can simply start with a state s, and then for each byte c in
-// the input string, execute "s = s->next[c]", checking at each point whether
-// the current s represents a matching state.
-//
-// The simple explanation just given does convey the essence of this code,
-// but it omits the details of how the State graph gets constructed as well
-// as some performance-driven optimizations to the execution of the automaton.
-// All these details are explained in the comments for the code following
-// the definition of class DFA.
-//
-// See http://swtch.com/~rsc/regexp/ for a very bare-bones equivalent.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <algorithm>
-#include <atomic>
-#include <deque>
-#include <mutex>
-#include <new>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "util/logging.h"
-#include "util/mix.h"
-#include "util/mutex.h"
-#include "util/strutil.h"
-#include "re2/pod_array.h"
-#include "re2/prog.h"
-#include "re2/re2.h"
-#include "re2/sparse_set.h"
-#include "re2/stringpiece.h"
-
-// Silence "zero-sized array in struct/union" warning for DFA::State::next_.
-#ifdef _MSC_VER
-#pragma warning(disable: 4200)
-#endif
-
-namespace duckdb_re2 {
-
-// Controls whether the DFA should bail out early if the NFA would be faster.
-static bool dfa_should_bail_when_slow = true;
-
-void Prog::TESTING_ONLY_set_dfa_should_bail_when_slow(bool b) {
-  dfa_should_bail_when_slow = b;
-}
-
-// A DFA implementation of a regular expression program.
-// Since this is entirely a forward declaration mandated by C++,
-// some of the comments here are better understood after reading
-// the comments in the sections that follow the DFA definition.
-class DFA {
- public:
-  DFA(Prog* prog, Prog::MatchKind kind, int64_t max_mem);
-  ~DFA();
-  bool ok() const { return !init_failed_; }
-  Prog::MatchKind kind() { return kind_; }
-
-  // Searches for the regular expression in text, which is considered
-  // as a subsection of context for the purposes of interpreting flags
-  // like ^ and $ and \A and \z.
-  // Returns whether a match was found.
-  // If a match is found, sets *ep to the end point of the best match in text.
-  // If "anchored", the match must begin at the start of text.
-  // If "want_earliest_match", the match that ends first is used, not
-  //   necessarily the best one.
-  // If "run_forward" is true, the DFA runs from text.begin() to text.end().
-  //   If it is false, the DFA runs from text.end() to text.begin(),
-  //   returning the leftmost end of the match instead of the rightmost one.
-  // If the DFA cannot complete the search (for example, if it is out of
-  //   memory), it sets *failed and returns false.
-  bool Search(const StringPiece& text, const StringPiece& context,
-              bool anchored, bool want_earliest_match, bool run_forward,
-              bool* failed, const char** ep, SparseSet* matches);
-
-  // Builds out all states for the entire DFA.
-  // If cb is not empty, it receives one callback per state built.
-  // Returns the number of states built.
-  // FOR TESTING OR EXPERIMENTAL PURPOSES ONLY.
-  int BuildAllStates(const Prog::DFAStateCallback& cb);
-
-  // Computes min and max for matching strings.  Won't return strings
-  // bigger than maxlen.
-  bool PossibleMatchRange(std::string* min, std::string* max, int maxlen);
-
-  // These data structures are logically private, but C++ makes it too
-  // difficult to mark them as such.
-  class RWLocker;
-  class StateSaver;
-  class Workq;
-
-  // A single DFA state.  The DFA is represented as a graph of these
-  // States, linked by the next_ pointers.  If in state s and reading
-  // byte c, the next state should be s->next_[c].
-  struct State {
-    inline bool IsMatch() const { return (flag_ & kFlagMatch) != 0; }
-
-    int* inst_;         // Instruction pointers in the state.
-    int ninst_;         // # of inst_ pointers.
-    uint32_t flag_;     // Empty string bitfield flags in effect on the way
-                        // into this state, along with kFlagMatch if this
-                        // is a matching state.
-
-	// fixes from https://github.com/girishji/re2/commit/80b212f289c4ef75408b1510b9fc85e6cb9a447c
-    std::atomic<State*> *next_;    // Outgoing arrows from State,
-
-                        // one per input byte class
-  };
-
-  enum {
-    kByteEndText = 256,         // imaginary byte at end of text
-
-    kFlagEmptyMask = 0xFF,      // State.flag_: bits holding kEmptyXXX flags
-    kFlagMatch = 0x0100,        // State.flag_: this is a matching state
-    kFlagLastWord = 0x0200,     // State.flag_: last byte was a word char
-    kFlagNeedShift = 16,        // needed kEmpty bits are or'ed in shifted left
-  };
-
-  struct StateHash {
-    size_t operator()(const State* a) const {
-      DCHECK(a != NULL);
-      HashMix mix(a->flag_);
-      for (int i = 0; i < a->ninst_; i++)
-        mix.Mix(a->inst_[i]);
-      mix.Mix(0);
-      return mix.get();
-    }
-  };
-
-  struct StateEqual {
-    bool operator()(const State* a, const State* b) const {
-      DCHECK(a != NULL);
-      DCHECK(b != NULL);
-      if (a == b)
-        return true;
-      if (a->flag_ != b->flag_)
-        return false;
-      if (a->ninst_ != b->ninst_)
-        return false;
-      for (int i = 0; i < a->ninst_; i++)
-        if (a->inst_[i] != b->inst_[i])
-          return false;
-      return true;
-    }
-  };
-
-  typedef std::unordered_set<State*, StateHash, StateEqual> StateSet;
-
- private:
-  // Make it easier to swap in a scalable reader-writer mutex.
-  using CacheMutex = Mutex;
-
-  enum {
-    // Indices into start_ for unanchored searches.
-    // Add kStartAnchored for anchored searches.
-    kStartBeginText = 0,          // text at beginning of context
-    kStartBeginLine = 2,          // text at beginning of line
-    kStartAfterWordChar = 4,      // text follows a word character
-    kStartAfterNonWordChar = 6,   // text follows non-word character
-    kMaxStart = 8,
-
-    kStartAnchored = 1,
-  };
-
-  // Resets the DFA State cache, flushing all saved State* information.
-  // Releases and reacquires cache_mutex_ via cache_lock, so any
-  // State* existing before the call are not valid after the call.
-  // Use a StateSaver to preserve important states across the call.
-  // cache_mutex_.r <= L < mutex_
-  // After: cache_mutex_.w <= L < mutex_
-  void ResetCache(RWLocker* cache_lock);
-
-  // Looks up and returns the State corresponding to a Workq.
-  // L >= mutex_
-  State* WorkqToCachedState(Workq* q, Workq* mq, uint32_t flag);
-
-  // Looks up and returns a State matching the inst, ninst, and flag.
-  // L >= mutex_
-  State* CachedState(int* inst, int ninst, uint32_t flag);
-
-  // Clear the cache entirely.
-  // Must hold cache_mutex_.w or be in destructor.
-  void ClearCache();
-
-  // Converts a State into a Workq: the opposite of WorkqToCachedState.
-  // L >= mutex_
-  void StateToWorkq(State* s, Workq* q);
-
-  // Runs a State on a given byte, returning the next state.
-  State* RunStateOnByteUnlocked(State*, int);  // cache_mutex_.r <= L < mutex_
-  State* RunStateOnByte(State*, int);          // L >= mutex_
-
-  // Runs a Workq on a given byte followed by a set of empty-string flags,
-  // producing a new Workq in nq.  If a match instruction is encountered,
-  // sets *ismatch to true.
-  // L >= mutex_
-  void RunWorkqOnByte(Workq* q, Workq* nq,
-                      int c, uint32_t flag, bool* ismatch);
-
-  // Runs a Workq on a set of empty-string flags, producing a new Workq in nq.
-  // L >= mutex_
-  void RunWorkqOnEmptyString(Workq* q, Workq* nq, uint32_t flag);
-
-  // Adds the instruction id to the Workq, following empty arrows
-  // according to flag.
-  // L >= mutex_
-  void AddToQueue(Workq* q, int id, uint32_t flag);
-
-  // For debugging, returns a text representation of State.
-  static std::string DumpState(State* state);
-
-  // For debugging, returns a text representation of a Workq.
-  static std::string DumpWorkq(Workq* q);
-
-  // Search parameters
-  struct SearchParams {
-    SearchParams(const StringPiece& text, const StringPiece& context,
-                 RWLocker* cache_lock)
-      : text(text),
-        context(context),
-        anchored(false),
-        can_prefix_accel(false),
-        want_earliest_match(false),
-        run_forward(false),
-        start(NULL),
-        cache_lock(cache_lock),
-        failed(false),
-        ep(NULL),
-        matches(NULL) {}
-
-    StringPiece text;
-    StringPiece context;
-    bool anchored;
-    bool can_prefix_accel;
-    bool want_earliest_match;
-    bool run_forward;
-    State* start;
-    RWLocker* cache_lock;
-    bool failed;     // "out" parameter: whether search gave up
-    const char* ep;  // "out" parameter: end pointer for match
-    SparseSet* matches;
-
-   private:
-    SearchParams(const SearchParams&) = delete;
-    SearchParams& operator=(const SearchParams&) = delete;
-  };
-
-  // Before each search, the parameters to Search are analyzed by
-  // AnalyzeSearch to determine the state in which to start.
-  struct StartInfo {
-    StartInfo() : start(NULL) {}
-    std::atomic<State*> start;
-  };
-
-  // Fills in params->start and params->can_prefix_accel using
-  // the other search parameters.  Returns true on success,
-  // false on failure.
-  // cache_mutex_.r <= L < mutex_
-  bool AnalyzeSearch(SearchParams* params);
-  bool AnalyzeSearchHelper(SearchParams* params, StartInfo* info,
-                           uint32_t flags);
-
-  // The generic search loop, inlined to create specialized versions.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  template <bool can_prefix_accel,
-            bool want_earliest_match,
-            bool run_forward>
-  inline bool InlinedSearchLoop(SearchParams* params);
-
-  // The specialized versions of InlinedSearchLoop.  The three letters
-  // at the ends of the name denote the true/false values used as the
-  // last three parameters of InlinedSearchLoop.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  bool SearchFFF(SearchParams* params);
-  bool SearchFFT(SearchParams* params);
-  bool SearchFTF(SearchParams* params);
-  bool SearchFTT(SearchParams* params);
-  bool SearchTFF(SearchParams* params);
-  bool SearchTFT(SearchParams* params);
-  bool SearchTTF(SearchParams* params);
-  bool SearchTTT(SearchParams* params);
-
-  // The main search loop: calls an appropriate specialized version of
-  // InlinedSearchLoop.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  bool FastSearchLoop(SearchParams* params);
-
-
-  // Looks up bytes in bytemap_ but handles case c == kByteEndText too.
-  int ByteMap(int c) {
-    if (c == kByteEndText)
-      return prog_->bytemap_range();
-    return prog_->bytemap()[c];
-  }
-
-  // Constant after initialization.
-  Prog* prog_;              // The regular expression program to run.
-  Prog::MatchKind kind_;    // The kind of DFA.
-  bool init_failed_;        // initialization failed (out of memory)
-
-  Mutex mutex_;  // mutex_ >= cache_mutex_.r
-
-  // Scratch areas, protected by mutex_.
-  Workq* q0_;             // Two pre-allocated work queues.
-  Workq* q1_;
-  PODArray<int> stack_;   // Pre-allocated stack for AddToQueue
-
-  // State* cache.  Many threads use and add to the cache simultaneously,
-  // holding cache_mutex_ for reading and mutex_ (above) when adding.
-  // If the cache fills and needs to be discarded, the discarding is done
-  // while holding cache_mutex_ for writing, to avoid interrupting other
-  // readers.  Any State* pointers are only valid while cache_mutex_
-  // is held.
-  CacheMutex cache_mutex_;
-  int64_t mem_budget_;     // Total memory budget for all States.
-  int64_t state_budget_;   // Amount of memory remaining for new States.
-  StateSet state_cache_;   // All States computed so far.
-  StartInfo start_[kMaxStart];
-
-  DFA(const DFA&) = delete;
-  DFA& operator=(const DFA&) = delete;
-};
-
-// Shorthand for casting to uint8_t*.
-static inline const uint8_t* BytePtr(const void* v) {
-  return reinterpret_cast<const uint8_t*>(v);
-}
-
-// Work queues
-
-// Marks separate thread groups of different priority
-// in the work queue when in leftmost-longest matching mode.
-//#define Mark (-1)
-constexpr auto Mark = -1;
-
-
-// Separates the match IDs from the instructions in inst_.
-// Used only for "many match" DFA states.
-//#define MatchSep (-2)
-constexpr auto MatchSep = -2;
-
-// Internally, the DFA uses a sparse array of
-// program instruction pointers as a work queue.
-// In leftmost longest mode, marks separate sections
-// of workq that started executing at different
-// locations in the string (earlier locations first).
-class DFA::Workq : public SparseSet {
- public:
-  // Constructor: n is number of normal slots, maxmark number of mark slots.
-  Workq(int n, int maxmark) :
-    SparseSet(n+maxmark),
-    n_(n),
-    maxmark_(maxmark),
-    nextmark_(n),
-    last_was_mark_(true) {
-  }
-
-  bool is_mark(int i) { return i >= n_; }
-
-  int maxmark() { return maxmark_; }
-
-  void clear() {
-    SparseSet::clear();
-    nextmark_ = n_;
-  }
-
-  void mark() {
-    if (last_was_mark_)
-      return;
-    last_was_mark_ = false;
-    SparseSet::insert_new(nextmark_++);
-  }
-
-  int size() {
-    return n_ + maxmark_;
-  }
-
-  void insert(int id) {
-    if (contains(id))
-      return;
-    insert_new(id);
-  }
-
-  void insert_new(int id) {
-    last_was_mark_ = false;
-    SparseSet::insert_new(id);
-  }
-
- private:
-  int n_;                // size excluding marks
-  int maxmark_;          // maximum number of marks
-  int nextmark_;         // id of next mark
-  bool last_was_mark_;   // last inserted was mark
-
-  Workq(const Workq&) = delete;
-  Workq& operator=(const Workq&) = delete;
-};
-
-DFA::DFA(Prog* prog, Prog::MatchKind kind, int64_t max_mem)
-  : prog_(prog),
-    kind_(kind),
-    init_failed_(false),
-    q0_(NULL),
-    q1_(NULL),
-    mem_budget_(max_mem) {
-  int nmark = 0;
-  if (kind_ == Prog::kLongestMatch)
-    nmark = prog_->size();
-  // See DFA::AddToQueue() for why this is so.
-  int nstack = prog_->inst_count(kInstCapture) +
-               prog_->inst_count(kInstEmptyWidth) +
-               prog_->inst_count(kInstNop) +
-               nmark + 1;  // + 1 for start inst
-
-  // Account for space needed for DFA, q0, q1, stack.
-  mem_budget_ -= sizeof(DFA);
-  mem_budget_ -= (prog_->size() + nmark) *
-                 (sizeof(int)+sizeof(int)) * 2;  // q0, q1
-  mem_budget_ -= nstack * sizeof(int);  // stack
-  if (mem_budget_ < 0) {
-    init_failed_ = true;
-    return;
-  }
-
-  state_budget_ = mem_budget_;
-
-  // Make sure there is a reasonable amount of working room left.
-  // At minimum, the search requires room for two states in order
-  // to limp along, restarting frequently.  We'll get better performance
-  // if there is room for a larger number of states, say 20.
-  // Note that a state stores list heads only, so we use the program
-  // list count for the upper bound, not the program size.
-  int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-  int64_t one_state = sizeof(State) + nnext*sizeof(std::atomic<State*>) +
-                      (prog_->list_count()+nmark)*sizeof(int);
-  if (state_budget_ < 20*one_state) {
-    init_failed_ = true;
-    return;
-  }
-
-  q0_ = new Workq(prog_->size(), nmark);
-  q1_ = new Workq(prog_->size(), nmark);
-  stack_ = PODArray<int>(nstack);
-}
-
-DFA::~DFA() {
-  delete q0_;
-  delete q1_;
-  ClearCache();
-}
-
-// In the DFA state graph, s->next[c] == NULL means that the
-// state has not yet been computed and needs to be.  We need
-// a different special value to signal that s->next[c] is a
-// state that can never lead to a match (and thus the search
-// can be called off).  Hence DeadState.
-#define DeadState reinterpret_cast<State*>(1)
-
-// Signals that the rest of the string matches no matter what it is.
-#define FullMatchState reinterpret_cast<State*>(2)
-
-#define SpecialStateMax FullMatchState
-
-// Debugging printouts
-
-// For debugging, returns a string representation of the work queue.
-std::string DFA::DumpWorkq(Workq* q) {
-  std::string s;
-  const char* sep = "";
-  for (Workq::iterator it = q->begin(); it != q->end(); ++it) {
-    if (q->is_mark(*it)) {
-      s += "|";
-      sep = "";
-    } else {
-      s += StringPrintf("%s%d", sep, *it);
-      sep = ",";
-    }
-  }
-  return s;
-}
-
-// For debugging, returns a string representation of the state.
-std::string DFA::DumpState(State* state) {
-  if (state == NULL)
-    return "_";
-  if (state == DeadState)
-    return "X";
-  if (state == FullMatchState)
-    return "*";
-  std::string s;
-  const char* sep = "";
-  s += StringPrintf("(%p)", state);
-  for (int i = 0; i < state->ninst_; i++) {
-    if (state->inst_[i] == Mark) {
-      s += "|";
-      sep = "";
-    } else if (state->inst_[i] == MatchSep) {
-      s += "||";
-      sep = "";
-    } else {
-      s += StringPrintf("%s%d", sep, state->inst_[i]);
-      sep = ",";
-    }
-  }
-  s += StringPrintf(" flag=%#x", state->flag_);
-  return s;
-}
-
-//////////////////////////////////////////////////////////////////////
-//
-// DFA state graph construction.
-//
-// The DFA state graph is a heavily-linked collection of State* structures.
-// The state_cache_ is a set of all the State structures ever allocated,
-// so that if the same state is reached by two different paths,
-// the same State structure can be used.  This reduces allocation
-// requirements and also avoids duplication of effort across the two
-// identical states.
-//
-// A State is defined by an ordered list of instruction ids and a flag word.
-//
-// The choice of an ordered list of instructions differs from a typical
-// textbook DFA implementation, which would use an unordered set.
-// Textbook descriptions, however, only care about whether
-// the DFA matches, not where it matches in the text.  To decide where the
-// DFA matches, we need to mimic the behavior of the dominant backtracking
-// implementations like PCRE, which try one possible regular expression
-// execution, then another, then another, stopping when one of them succeeds.
-// The DFA execution tries these many executions in parallel, representing
-// each by an instruction id.  These pointers are ordered in the State.inst_
-// list in the same order that the executions would happen in a backtracking
-// search: if a match is found during execution of inst_[2], inst_[i] for i>=3
-// can be discarded.
-//
-// Textbooks also typically do not consider context-aware empty string operators
-// like ^ or $.  These are handled by the flag word, which specifies the set
-// of empty-string operators that should be matched when executing at the
-// current text position.  These flag bits are defined in prog.h.
-// The flag word also contains two DFA-specific bits: kFlagMatch if the state
-// is a matching state (one that reached a kInstMatch in the program)
-// and kFlagLastWord if the last processed byte was a word character, for the
-// implementation of \B and \b.
-//
-// The flag word also contains, shifted up 16 bits, the bits looked for by
-// any kInstEmptyWidth instructions in the state.  These provide a useful
-// summary indicating when new flags might be useful.
-//
-// The permanent representation of a State's instruction ids is just an array,
-// but while a state is being analyzed, these instruction ids are represented
-// as a Workq, which is an array that allows iteration in insertion order.
-
-// NOTE(rsc): The choice of State construction determines whether the DFA
-// mimics backtracking implementations (so-called leftmost first matching) or
-// traditional DFA implementations (so-called leftmost longest matching as
-// prescribed by POSIX).  This implementation chooses to mimic the
-// backtracking implementations, because we want to replace PCRE.  To get
-// POSIX behavior, the states would need to be considered not as a simple
-// ordered list of instruction ids, but as a list of unordered sets of instruction
-// ids.  A match by a state in one set would inhibit the running of sets
-// farther down the list but not other instruction ids in the same set.  Each
-// set would correspond to matches beginning at a given point in the string.
-// This is implemented by separating different sets with Mark pointers.
-
-// Looks in the State cache for a State matching q, flag.
-// If one is found, returns it.  If one is not found, allocates one,
-// inserts it in the cache, and returns it.
-// If mq is not null, MatchSep and the match IDs in mq will be appended
-// to the State.
-DFA::State* DFA::WorkqToCachedState(Workq* q, Workq* mq, uint32_t flag) {
-  //mutex_.AssertHeld();
-
-  // Construct array of instruction ids for the new state.
-  // Only ByteRange, EmptyWidth, and Match instructions are useful to keep:
-  // those are the only operators with any effect in
-  // RunWorkqOnEmptyString or RunWorkqOnByte.
-  PODArray<int> inst(q->size());
-  int n = 0;
-  uint32_t needflags = 0;  // flags needed by kInstEmptyWidth instructions
-  bool sawmatch = false;   // whether queue contains guaranteed kInstMatch
-  bool sawmark = false;    // whether queue contains a Mark
-
-  for (Workq::iterator it = q->begin(); it != q->end(); ++it) {
-    int id = *it;
-    if (sawmatch && (kind_ == Prog::kFirstMatch || q->is_mark(id)))
-      break;
-    if (q->is_mark(id)) {
-      if (n > 0 && inst[n-1] != Mark) {
-        sawmark = true;
-        inst[n++] = Mark;
-      }
-      continue;
-    }
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      case kInstAltMatch:
-        // This state will continue to a match no matter what
-        // the rest of the input is.  If it is the highest priority match
-        // being considered, return the special FullMatchState
-        // to indicate that it's all matches from here out.
-        if (kind_ != Prog::kManyMatch &&
-            (kind_ != Prog::kFirstMatch ||
-             (it == q->begin() && ip->greedy(prog_))) &&
-            (kind_ != Prog::kLongestMatch || !sawmark) &&
-            (flag & kFlagMatch)) {
-          return FullMatchState;
-        }
-        FALLTHROUGH_INTENDED;
-      default:
-        // Record iff id is the head of its list, which must
-        // be the case if id-1 is the last of *its* list. :)
-        if (prog_->inst(id-1)->last())
-          inst[n++] = *it;
-        if (ip->opcode() == kInstEmptyWidth)
-          needflags |= ip->empty();
-        if (ip->opcode() == kInstMatch && !prog_->anchor_end())
-          sawmatch = true;
-        break;
-    }
-  }
-  DCHECK_LE(n, q->size());
-  if (n > 0 && inst[n-1] == Mark)
-    n--;
-
-  // If there are no empty-width instructions waiting to execute,
-  // then the extra flag bits will not be used, so there is no
-  // point in saving them.  (Discarding them reduces the number
-  // of distinct states.)
-  if (needflags == 0)
-    flag &= kFlagMatch;
-
-  // NOTE(rsc): The code above cannot do flag &= needflags,
-  // because if the right flags were present to pass the current
-  // kInstEmptyWidth instructions, new kInstEmptyWidth instructions
-  // might be reached that in turn need different flags.
-  // The only sure thing is that if there are no kInstEmptyWidth
-  // instructions at all, no flags will be needed.
-  // We could do the extra work to figure out the full set of
-  // possibly needed flags by exploring past the kInstEmptyWidth
-  // instructions, but the check above -- are any flags needed
-  // at all? -- handles the most common case.  More fine-grained
-  // analysis can only be justified by measurements showing that
-  // too many redundant states are being allocated.
-
-  // If there are no Insts in the list, it's a dead state,
-  // which is useful to signal with a special pointer so that
-  // the execution loop can stop early.  This is only okay
-  // if the state is *not* a matching state.
-  if (n == 0 && flag == 0) {
-    return DeadState;
-  }
-
-  // If we're in longest match mode, the state is a sequence of
-  // unordered state sets separated by Marks.  Sort each set
-  // to canonicalize, to reduce the number of distinct sets stored.
-  if (kind_ == Prog::kLongestMatch) {
-    int* ip = inst.data();
-    int* ep = ip + n;
-    while (ip < ep) {
-      int* markp = ip;
-      while (markp < ep && *markp != Mark)
-        markp++;
-      std::sort(ip, markp);
-      if (markp < ep)
-        markp++;
-      ip = markp;
-    }
-  }
-
-  // If we're in many match mode, canonicalize for similar reasons:
-  // we have an unordered set of states (i.e. we don't have Marks)
-  // and sorting will reduce the number of distinct sets stored.
-  if (kind_ == Prog::kManyMatch) {
-    int* ip = inst.data();
-    int* ep = ip + n;
-    std::sort(ip, ep);
-  }
-
-  // Append MatchSep and the match IDs in mq if necessary.
-  if (mq != NULL) {
-    inst[n++] = MatchSep;
-    for (Workq::iterator i = mq->begin(); i != mq->end(); ++i) {
-      int id = *i;
-      Prog::Inst* ip = prog_->inst(id);
-      if (ip->opcode() == kInstMatch)
-        inst[n++] = ip->match_id();
-    }
-  }
-
-  // Save the needed empty-width flags in the top bits for use later.
-  flag |= needflags << kFlagNeedShift;
-
-  State* state = CachedState(inst.data(), n, flag);
-  return state;
-}
-
-// Looks in the State cache for a State matching inst, ninst, flag.
-// If one is found, returns it.  If one is not found, allocates one,
-// inserts it in the cache, and returns it.
-DFA::State* DFA::CachedState(int* inst, int ninst, uint32_t flag) {
-  //mutex_.AssertHeld();
-
-  // Look in the cache for a pre-existing state.
-  // We have to initialise the struct like this because otherwise
-  // MSVC will complain about the flexible array member. :(
-  State state;
-  state.inst_ = inst;
-  state.ninst_ = ninst;
-  state.flag_ = flag;
-  StateSet::iterator it = state_cache_.find(&state);
-  if (it != state_cache_.end()) {
-    return *it;
-  }
-
-  // Must have enough memory for new state.
-  // In addition to what we're going to allocate,
-  // the state cache hash table seems to incur about 40 bytes per
-  // State*, empirically.
-  const int kStateCacheOverhead = 40;
-  int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-  int mem = sizeof(State) + nnext*sizeof(std::atomic<State*>) +
-            ninst*sizeof(int);
-  if (mem_budget_ < mem + kStateCacheOverhead) {
-    mem_budget_ = -1;
-    return NULL;
-  }
-  mem_budget_ -= mem + kStateCacheOverhead;
-
-  // Allocate new state along with room for next_ and inst_.
-  char* space = std::allocator<char>().allocate(mem);
-  State* s = new (space) State;
-  s->next_ =  new (space + sizeof(State)) std::atomic<State*>[nnext];
-  // Work around a unfortunate bug in older versions of libstdc++.
-  // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64658)
-  for (int i = 0; i < nnext; i++)
-    (void) new (s->next_ + i) std::atomic<State*>(NULL);
-  s->inst_ = new (s->next_ + nnext) int[ninst];
-  memmove(s->inst_, inst, ninst*sizeof s->inst_[0]);
-  s->ninst_ = ninst;
-  s->flag_ = flag;
-  // Put state in cache and return it.
-  state_cache_.insert(s);
-  return s;
-}
-
-// Clear the cache.  Must hold cache_mutex_.w or be in destructor.
-void DFA::ClearCache() {
-  StateSet::iterator begin = state_cache_.begin();
-  StateSet::iterator end = state_cache_.end();
-  while (begin != end) {
-    StateSet::iterator tmp = begin;
-    ++begin;
-    // Deallocate the blob of memory that we allocated in DFA::CachedState().
-    // We recompute mem in order to benefit from sized delete where possible.
-    int ninst = (*tmp)->ninst_;
-    int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-    int mem = sizeof(State) + nnext*sizeof(std::atomic<State*>) +
-              ninst*sizeof(int);
-    std::allocator<char>().deallocate(reinterpret_cast<char*>(*tmp), mem);
-  }
-  state_cache_.clear();
-}
-
-// Copies insts in state s to the work queue q.
-void DFA::StateToWorkq(State* s, Workq* q) {
-  q->clear();
-  for (int i = 0; i < s->ninst_; i++) {
-    if (s->inst_[i] == Mark) {
-      q->mark();
-    } else if (s->inst_[i] == MatchSep) {
-      // Nothing after this is an instruction!
-      break;
-    } else {
-      // Explore from the head of the list.
-      AddToQueue(q, s->inst_[i], s->flag_ & kFlagEmptyMask);
-    }
-  }
-}
-
-// Adds ip to the work queue, following empty arrows according to flag.
-void DFA::AddToQueue(Workq* q, int id, uint32_t flag) {
-
-  // Use stack_ to hold our stack of instructions yet to process.
-  // It was preallocated as follows:
-  //   one entry per Capture;
-  //   one entry per EmptyWidth; and
-  //   one entry per Nop.
-  // This reflects the maximum number of stack pushes that each can
-  // perform. (Each instruction can be processed at most once.)
-  // When using marks, we also added nmark == prog_->size().
-  // (Otherwise, nmark == 0.)
-  int* stk = stack_.data();
-  int nstk = 0;
-
-  stk[nstk++] = id;
-  while (nstk > 0) {
-    DCHECK_LE(nstk, stack_.size());
-    id = stk[--nstk];
-
-  Loop:
-    if (id == Mark) {
-      q->mark();
-      continue;
-    }
-
-    if (id == 0)
-      continue;
-
-    // If ip is already on the queue, nothing to do.
-    // Otherwise add it.  We don't actually keep all the
-    // ones that get added, but adding all of them here
-    // increases the likelihood of q->contains(id),
-    // reducing the amount of duplicated work.
-    if (q->contains(id))
-      continue;
-    q->insert_new(id);
-
-    // Process instruction.
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstByteRange:  // just save these on the queue
-      case kInstMatch:
-        if (ip->last())
-          break;
-        id = id+1;
-        goto Loop;
-
-      case kInstCapture:    // DFA treats captures as no-ops.
-      case kInstNop:
-        if (!ip->last())
-          stk[nstk++] = id+1;
-
-        // If this instruction is the [00-FF]* loop at the beginning of
-        // a leftmost-longest unanchored search, separate with a Mark so
-        // that future threads (which will start farther to the right in
-        // the input string) are lower priority than current threads.
-        if (ip->opcode() == kInstNop && q->maxmark() > 0 &&
-            id == prog_->start_unanchored() && id != prog_->start())
-          stk[nstk++] = Mark;
-        id = ip->out();
-        goto Loop;
-
-      case kInstAltMatch:
-        DCHECK(!ip->last());
-        id = id+1;
-        goto Loop;
-
-      case kInstEmptyWidth:
-        if (!ip->last())
-          stk[nstk++] = id+1;
-
-        // Continue on if we have all the right flag bits.
-        if (ip->empty() & ~flag)
-          break;
-        id = ip->out();
-        goto Loop;
-    }
-  }
-}
-
-// Running of work queues.  In the work queue, order matters:
-// the queue is sorted in priority order.  If instruction i comes before j,
-// then the instructions that i produces during the run must come before
-// the ones that j produces.  In order to keep this invariant, all the
-// work queue runners have to take an old queue to process and then
-// also a new queue to fill in.  It's not acceptable to add to the end of
-// an existing queue, because new instructions will not end up in the
-// correct position.
-
-// Runs the work queue, processing the empty strings indicated by flag.
-// For example, flag == kEmptyBeginLine|kEmptyEndLine means to match
-// both ^ and $.  It is important that callers pass all flags at once:
-// processing both ^ and $ is not the same as first processing only ^
-// and then processing only $.  Doing the two-step sequence won't match
-// ^$^$^$ but processing ^ and $ simultaneously will (and is the behavior
-// exhibited by existing implementations).
-void DFA::RunWorkqOnEmptyString(Workq* oldq, Workq* newq, uint32_t flag) {
-  newq->clear();
-  for (Workq::iterator i = oldq->begin(); i != oldq->end(); ++i) {
-    if (oldq->is_mark(*i))
-      AddToQueue(newq, Mark, flag);
-    else
-      AddToQueue(newq, *i, flag);
-  }
-}
-
-// Runs the work queue, processing the single byte c followed by any empty
-// strings indicated by flag.  For example, c == 'a' and flag == kEmptyEndLine,
-// means to match c$.  Sets the bool *ismatch to true if the end of the
-// regular expression program has been reached (the regexp has matched).
-void DFA::RunWorkqOnByte(Workq* oldq, Workq* newq,
-                         int c, uint32_t flag, bool* ismatch) {
-  //mutex_.AssertHeld();
-
-  newq->clear();
-  for (Workq::iterator i = oldq->begin(); i != oldq->end(); ++i) {
-    if (oldq->is_mark(*i)) {
-      if (*ismatch)
-        return;
-      newq->mark();
-      continue;
-    }
-    int id = *i;
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstFail:        // never succeeds
-      case kInstCapture:     // already followed
-      case kInstNop:         // already followed
-      case kInstAltMatch:    // already followed
-      case kInstEmptyWidth:  // already followed
-        break;
-
-      case kInstByteRange:   // can follow if c is in range
-        if (!ip->Matches(c))
-          break;
-        AddToQueue(newq, ip->out(), flag);
-        if (ip->hint() != 0) {
-          // We have a hint, but we must cancel out the
-          // increment that will occur after the break.
-          i += ip->hint() - 1;
-        } else {
-          // We have no hint, so we must find the end
-          // of the current list and then skip to it.
-          Prog::Inst* ip0 = ip;
-          while (!ip->last())
-            ++ip;
-          i += ip - ip0;
-        }
-        break;
-
-      case kInstMatch:
-        if (prog_->anchor_end() && c != kByteEndText &&
-            kind_ != Prog::kManyMatch)
-          break;
-        *ismatch = true;
-        if (kind_ == Prog::kFirstMatch) {
-          // Can stop processing work queue since we found a match.
-          return;
-        }
-        break;
-    }
-  }
-
-}
-
-// Processes input byte c in state, returning new state.
-// Caller does not hold mutex.
-DFA::State* DFA::RunStateOnByteUnlocked(State* state, int c) {
-  // Keep only one RunStateOnByte going
-  // even if the DFA is being run by multiple threads.
-  MutexLock l(&mutex_);
-  return RunStateOnByte(state, c);
-}
-
-// Processes input byte c in state, returning new state.
-DFA::State* DFA::RunStateOnByte(State* state, int c) {
-  //mutex_.AssertHeld();
-
-  if (state <= SpecialStateMax) {
-    if (state == FullMatchState) {
-      // It is convenient for routines like PossibleMatchRange
-      // if we implement RunStateOnByte for FullMatchState:
-      // once you get into this state you never get out,
-      // so it's pretty easy.
-      return FullMatchState;
-    }
-    if (state == DeadState) {
-      LOG(DFATAL) << "DeadState in RunStateOnByte";
-      return NULL;
-    }
-    if (state == NULL) {
-      LOG(DFATAL) << "NULL state in RunStateOnByte";
-      return NULL;
-    }
-    LOG(DFATAL) << "Unexpected special state in RunStateOnByte";
-    return NULL;
-  }
-
-  // If someone else already computed this, return it.
-  State* ns = state->next_[ByteMap(c)].load(std::memory_order_relaxed);
-  if (ns != NULL)
-    return ns;
-
-  // Convert state into Workq.
-  StateToWorkq(state, q0_);
-
-  // Flags marking the kinds of empty-width things (^ $ etc)
-  // around this byte.  Before the byte we have the flags recorded
-  // in the State structure itself.  After the byte we have
-  // nothing yet (but that will change: read on).
-  uint32_t needflag = state->flag_ >> kFlagNeedShift;
-  uint32_t beforeflag = state->flag_ & kFlagEmptyMask;
-  uint32_t oldbeforeflag = beforeflag;
-  uint32_t afterflag = 0;
-
-  if (c == '\n') {
-    // Insert implicit $ and ^ around \n
-    beforeflag |= kEmptyEndLine;
-    afterflag |= kEmptyBeginLine;
-  }
-
-  if (c == kByteEndText) {
-    // Insert implicit $ and \z before the fake "end text" byte.
-    beforeflag |= kEmptyEndLine | kEmptyEndText;
-  }
-
-  // The state flag kFlagLastWord says whether the last
-  // byte processed was a word character.  Use that info to
-  // insert empty-width (non-)word boundaries.
-  bool islastword = (state->flag_ & kFlagLastWord) != 0;
-  bool isword = c != kByteEndText && Prog::IsWordChar(static_cast<uint8_t>(c));
-  if (isword == islastword)
-    beforeflag |= kEmptyNonWordBoundary;
-  else
-    beforeflag |= kEmptyWordBoundary;
-
-  // Okay, finally ready to run.
-  // Only useful to rerun on empty string if there are new, useful flags.
-  if (beforeflag & ~oldbeforeflag & needflag) {
-    RunWorkqOnEmptyString(q0_, q1_, beforeflag);
-    using std::swap;
-    swap(q0_, q1_);
-  }
-  bool ismatch = false;
-  RunWorkqOnByte(q0_, q1_, c, afterflag, &ismatch);
-  using std::swap;
-  swap(q0_, q1_);
-
-  // Save afterflag along with ismatch and isword in new state.
-  uint32_t flag = afterflag;
-  if (ismatch)
-    flag |= kFlagMatch;
-  if (isword)
-    flag |= kFlagLastWord;
-
-  if (ismatch && kind_ == Prog::kManyMatch)
-    ns = WorkqToCachedState(q0_, q1_, flag);
-  else
-    ns = WorkqToCachedState(q0_, NULL, flag);
-
-  // Flush ns before linking to it.
-  // Write barrier before updating state->next_ so that the
-  // main search loop can proceed without any locking, for speed.
-  // (Otherwise it would need one mutex operation per input byte.)
-  state->next_[ByteMap(c)].store(ns, std::memory_order_release);
-  return ns;
-}
-
-
-//////////////////////////////////////////////////////////////////////
-// DFA cache reset.
-
-// Reader-writer lock helper.
-//
-// The DFA uses a reader-writer mutex to protect the state graph itself.
-// Traversing the state graph requires holding the mutex for reading,
-// and discarding the state graph and starting over requires holding the
-// lock for writing.  If a search needs to expand the graph but is out
-// of memory, it will need to drop its read lock and then acquire the
-// write lock.  Since it cannot then atomically downgrade from write lock
-// to read lock, it runs the rest of the search holding the write lock.
-// (This probably helps avoid repeated contention, but really the decision
-// is forced by the Mutex interface.)  It's a bit complicated to keep
-// track of whether the lock is held for reading or writing and thread
-// that through the search, so instead we encapsulate it in the RWLocker
-// and pass that around.
-
-class DFA::RWLocker {
- public:
-  explicit RWLocker(CacheMutex* mu);
-  ~RWLocker();
-
-  // If the lock is only held for reading right now,
-  // drop the read lock and re-acquire for writing.
-  // Subsequent calls to LockForWriting are no-ops.
-  // Notice that the lock is *released* temporarily.
-  void LockForWriting();
-
- private:
-  CacheMutex* mu_;
-  bool writing_;
-
-  RWLocker(const RWLocker&) = delete;
-  RWLocker& operator=(const RWLocker&) = delete;
-};
-
-DFA::RWLocker::RWLocker(CacheMutex* mu) : mu_(mu), writing_(false) {
-  mu_->ReaderLock();
-}
-
-// This function is marked as NO_THREAD_SAFETY_ANALYSIS because
-// the annotations don't support lock upgrade.
-void DFA::RWLocker::LockForWriting() NO_THREAD_SAFETY_ANALYSIS {
-  if (!writing_) {
-    mu_->ReaderUnlock();
-    mu_->WriterLock();
-    writing_ = true;
-  }
-}
-
-DFA::RWLocker::~RWLocker() {
-  if (!writing_)
-    mu_->ReaderUnlock();
-  else
-    mu_->WriterUnlock();
-}
-
-
-// When the DFA's State cache fills, we discard all the states in the
-// cache and start over.  Many threads can be using and adding to the
-// cache at the same time, so we synchronize using the cache_mutex_
-// to keep from stepping on other threads.  Specifically, all the
-// threads using the current cache hold cache_mutex_ for reading.
-// When a thread decides to flush the cache, it drops cache_mutex_
-// and then re-acquires it for writing.  That ensures there are no
-// other threads accessing the cache anymore.  The rest of the search
-// runs holding cache_mutex_ for writing, avoiding any contention
-// with or cache pollution caused by other threads.
-
-void DFA::ResetCache(RWLocker* cache_lock) {
-  // Re-acquire the cache_mutex_ for writing (exclusive use).
-  cache_lock->LockForWriting();
-
-  hooks::GetDFAStateCacheResetHook()({
-      state_budget_,
-      state_cache_.size(),
-  });
-
-  // Clear the cache, reset the memory budget.
-  for (int i = 0; i < kMaxStart; i++)
-    start_[i].start.store(NULL, std::memory_order_relaxed);
-  ClearCache();
-  mem_budget_ = state_budget_;
-}
-
-// Typically, a couple States do need to be preserved across a cache
-// reset, like the State at the current point in the search.
-// The StateSaver class helps keep States across cache resets.
-// It makes a copy of the state's guts outside the cache (before the reset)
-// and then can be asked, after the reset, to recreate the State
-// in the new cache.  For example, in a DFA method ("this" is a DFA):
-//
-//   StateSaver saver(this, s);
-//   ResetCache(cache_lock);
-//   s = saver.Restore();
-//
-// The saver should always have room in the cache to re-create the state,
-// because resetting the cache locks out all other threads, and the cache
-// is known to have room for at least a couple states (otherwise the DFA
-// constructor fails).
-
-class DFA::StateSaver {
- public:
-  explicit StateSaver(DFA* dfa, State* state);
-  ~StateSaver();
-
-  // Recreates and returns a state equivalent to the
-  // original state passed to the constructor.
-  // Returns NULL if the cache has filled, but
-  // since the DFA guarantees to have room in the cache
-  // for a couple states, should never return NULL
-  // if used right after ResetCache.
-  State* Restore();
-
- private:
-  DFA* dfa_;         // the DFA to use
-  int* inst_;        // saved info from State
-  int ninst_;
-  uint32_t flag_;
-  bool is_special_;  // whether original state was special
-  State* special_;   // if is_special_, the original state
-
-  StateSaver(const StateSaver&) = delete;
-  StateSaver& operator=(const StateSaver&) = delete;
-};
-
-DFA::StateSaver::StateSaver(DFA* dfa, State* state) {
-  dfa_ = dfa;
-  if (state <= SpecialStateMax) {
-    inst_ = NULL;
-    ninst_ = 0;
-    flag_ = 0;
-    is_special_ = true;
-    special_ = state;
-    return;
-  }
-  is_special_ = false;
-  special_ = NULL;
-  flag_ = state->flag_;
-  ninst_ = state->ninst_;
-  inst_ = new int[ninst_];
-  memmove(inst_, state->inst_, ninst_*sizeof inst_[0]);
-}
-
-DFA::StateSaver::~StateSaver() {
-  if (!is_special_)
-    delete[] inst_;
-}
-
-DFA::State* DFA::StateSaver::Restore() {
-  if (is_special_)
-    return special_;
-  MutexLock l(&dfa_->mutex_);
-  State* s = dfa_->CachedState(inst_, ninst_, flag_);
-  if (s == NULL)
-    LOG(DFATAL) << "StateSaver failed to restore state.";
-  return s;
-}
-
-
-//////////////////////////////////////////////////////////////////////
-//
-// DFA execution.
-//
-// The basic search loop is easy: start in a state s and then for each
-// byte c in the input, s = s->next[c].
-//
-// This simple description omits a few efficiency-driven complications.
-//
-// First, the State graph is constructed incrementally: it is possible
-// that s->next[c] is null, indicating that that state has not been
-// fully explored.  In this case, RunStateOnByte must be invoked to
-// determine the next state, which is cached in s->next[c] to save
-// future effort.  An alternative reason for s->next[c] to be null is
-// that the DFA has reached a so-called "dead state", in which any match
-// is no longer possible.  In this case RunStateOnByte will return NULL
-// and the processing of the string can stop early.
-//
-// Second, a 256-element pointer array for s->next_ makes each State
-// quite large (2kB on 64-bit machines).  Instead, dfa->bytemap_[]
-// maps from bytes to "byte classes" and then next_ only needs to have
-// as many pointers as there are byte classes.  A byte class is simply a
-// range of bytes that the regexp never distinguishes between.
-// A regexp looking for a[abc] would have four byte ranges -- 0 to 'a'-1,
-// 'a', 'b' to 'c', and 'c' to 0xFF.  The bytemap slows us a little bit
-// but in exchange we typically cut the size of a State (and thus our
-// memory footprint) by about 5-10x.  The comments still refer to
-// s->next[c] for simplicity, but code should refer to s->next_[bytemap_[c]].
-//
-// Third, it is common for a DFA for an unanchored match to begin in a
-// state in which only one particular byte value can take the DFA to a
-// different state.  That is, s->next[c] != s for only one c.  In this
-// situation, the DFA can do better than executing the simple loop.
-// Instead, it can call memchr to search very quickly for the byte c.
-// Whether the start state has this property is determined during a
-// pre-compilation pass and the "can_prefix_accel" argument is set.
-//
-// Fourth, the desired behavior is to search for the leftmost-best match
-// (approximately, the same one that Perl would find), which is not
-// necessarily the match ending earliest in the string.  Each time a
-// match is found, it must be noted, but the DFA must continue on in
-// hope of finding a higher-priority match.  In some cases, the caller only
-// cares whether there is any match at all, not which one is found.
-// The "want_earliest_match" flag causes the search to stop at the first
-// match found.
-//
-// Fifth, one algorithm that uses the DFA needs it to run over the
-// input string backward, beginning at the end and ending at the beginning.
-// Passing false for the "run_forward" flag causes the DFA to run backward.
-//
-// The checks for these last three cases, which in a naive implementation
-// would be performed once per input byte, slow the general loop enough
-// to merit specialized versions of the search loop for each of the
-// eight possible settings of the three booleans.  Rather than write
-// eight different functions, we write one general implementation and then
-// inline it to create the specialized ones.
-//
-// Note that matches are delayed by one byte, to make it easier to
-// accomodate match conditions depending on the next input byte (like $ and \b).
-// When s->next[c]->IsMatch(), it means that there is a match ending just
-// *before* byte c.
-
-// The generic search loop.  Searches text for a match, returning
-// the pointer to the end of the chosen match, or NULL if no match.
-// The bools are equal to the same-named variables in params, but
-// making them function arguments lets the inliner specialize
-// this function to each combination (see two paragraphs above).
-template <bool can_prefix_accel,
-          bool want_earliest_match,
-          bool run_forward>
-inline bool DFA::InlinedSearchLoop(SearchParams* params) {
-  State* start = params->start;
-  const uint8_t* bp = BytePtr(params->text.data());  // start of text
-  const uint8_t* p = bp;                             // text scanning point
-  const uint8_t* ep = BytePtr(params->text.data() +
-                              params->text.size());  // end of text
-  const uint8_t* resetp = NULL;                      // p at last cache reset
-  if (!run_forward) {
-    using std::swap;
-    swap(p, ep);
-  }
-
-  const uint8_t* bytemap = prog_->bytemap();
-  const uint8_t* lastmatch = NULL;   // most recent matching position in text
-  bool matched = false;
-
-  State* s = start;
-
-  if (s->IsMatch()) {
-    matched = true;
-    lastmatch = p;
-    if (params->matches != NULL && kind_ == Prog::kManyMatch) {
-      for (int i = s->ninst_ - 1; i >= 0; i--) {
-        int id = s->inst_[i];
-        if (id == MatchSep)
-          break;
-        params->matches->insert(id);
-      }
-    }
-    if (want_earliest_match) {
-      params->ep = reinterpret_cast<const char*>(lastmatch);
-      return true;
-    }
-  }
-
-  while (p != ep) {
-
-    if (can_prefix_accel && s == start) {
-      // In start state, only way out is to find the prefix,
-      // so we use prefix accel (e.g. memchr) to skip ahead.
-      // If not found, we can skip to the end of the string.
-      p = BytePtr(prog_->PrefixAccel(p, ep - p));
-      if (p == NULL) {
-        p = ep;
-        break;
-      }
-    }
-
-    int c;
-    if (run_forward)
-      c = *p++;
-    else
-      c = *--p;
-
-    // Note that multiple threads might be consulting
-    // s->next_[bytemap[c]] simultaneously.
-    // RunStateOnByte takes care of the appropriate locking,
-    // including a memory barrier so that the unlocked access
-    // (sometimes known as "double-checked locking") is safe.
-    // The alternative would be either one DFA per thread
-    // or one mutex operation per input byte.
-    //
-    // ns == DeadState means the state is known to be dead
-    // (no more matches are possible).
-    // ns == NULL means the state has not yet been computed
-    // (need to call RunStateOnByteUnlocked).
-    // RunStateOnByte returns ns == NULL if it is out of memory.
-    // ns == FullMatchState means the rest of the string matches.
-    //
-    // Okay to use bytemap[] not ByteMap() here, because
-    // c is known to be an actual byte and not kByteEndText.
-
-    State* ns = s->next_[bytemap[c]].load(std::memory_order_acquire);
-    if (ns == NULL) {
-      ns = RunStateOnByteUnlocked(s, c);
-      if (ns == NULL) {
-        // After we reset the cache, we hold cache_mutex exclusively,
-        // so if resetp != NULL, it means we filled the DFA state
-        // cache with this search alone (without any other threads).
-        // Benchmarks show that doing a state computation on every
-        // byte runs at about 0.2 MB/s, while the NFA (nfa.cc) can do the
-        // same at about 2 MB/s.  Unless we're processing an average
-        // of 10 bytes per state computation, fail so that RE2 can
-        // fall back to the NFA.  However, RE2::Set cannot fall back,
-        // so we just have to keep on keeping on in that case.
-        if (dfa_should_bail_when_slow && resetp != NULL &&
-            static_cast<size_t>(p - resetp) < 10*state_cache_.size() &&
-            kind_ != Prog::kManyMatch) {
-          params->failed = true;
-          return false;
-        }
-        resetp = p;
-
-        // Prepare to save start and s across the reset.
-        StateSaver save_start(this, start);
-        StateSaver save_s(this, s);
-
-        // Discard all the States in the cache.
-        ResetCache(params->cache_lock);
-
-        // Restore start and s so we can continue.
-        if ((start = save_start.Restore()) == NULL ||
-            (s = save_s.Restore()) == NULL) {
-          // Restore already did LOG(DFATAL).
-          params->failed = true;
-          return false;
-        }
-        ns = RunStateOnByteUnlocked(s, c);
-        if (ns == NULL) {
-          LOG(DFATAL) << "RunStateOnByteUnlocked failed after ResetCache";
-          params->failed = true;
-          return false;
-        }
-      }
-    }
-    if (ns <= SpecialStateMax) {
-      if (ns == DeadState) {
-        params->ep = reinterpret_cast<const char*>(lastmatch);
-        return matched;
-      }
-      // FullMatchState
-      params->ep = reinterpret_cast<const char*>(ep);
-      return true;
-    }
-
-    s = ns;
-    if (s->IsMatch()) {
-      matched = true;
-      // The DFA notices the match one byte late,
-      // so adjust p before using it in the match.
-      if (run_forward)
-        lastmatch = p - 1;
-      else
-        lastmatch = p + 1;
-      if (params->matches != NULL && kind_ == Prog::kManyMatch) {
-        for (int i = s->ninst_ - 1; i >= 0; i--) {
-          int id = s->inst_[i];
-          if (id == MatchSep)
-            break;
-          params->matches->insert(id);
-        }
-      }
-      if (want_earliest_match) {
-        params->ep = reinterpret_cast<const char*>(lastmatch);
-        return true;
-      }
-    }
-  }
-
-  // Process one more byte to see if it triggers a match.
-  // (Remember, matches are delayed one byte.)
-
-  int lastbyte;
-  if (run_forward) {
-    if (EndPtr(params->text) == EndPtr(params->context))
-      lastbyte = kByteEndText;
-    else
-      lastbyte = EndPtr(params->text)[0] & 0xFF;
-  } else {
-    if (BeginPtr(params->text) == BeginPtr(params->context))
-      lastbyte = kByteEndText;
-    else
-      lastbyte = BeginPtr(params->text)[-1] & 0xFF;
-  }
-
-  State* ns = s->next_[ByteMap(lastbyte)].load(std::memory_order_acquire);
-  if (ns == NULL) {
-    ns = RunStateOnByteUnlocked(s, lastbyte);
-    if (ns == NULL) {
-      StateSaver save_s(this, s);
-      ResetCache(params->cache_lock);
-      if ((s = save_s.Restore()) == NULL) {
-        params->failed = true;
-        return false;
-      }
-      ns = RunStateOnByteUnlocked(s, lastbyte);
-      if (ns == NULL) {
-        LOG(DFATAL) << "RunStateOnByteUnlocked failed after Reset";
-        params->failed = true;
-        return false;
-      }
-    }
-  }
-  if (ns <= SpecialStateMax) {
-    if (ns == DeadState) {
-      params->ep = reinterpret_cast<const char*>(lastmatch);
-      return matched;
-    }
-    // FullMatchState
-    params->ep = reinterpret_cast<const char*>(ep);
-    return true;
-  }
-
-  s = ns;
-  if (s->IsMatch()) {
-    matched = true;
-    lastmatch = p;
-    if (params->matches != NULL && kind_ == Prog::kManyMatch) {
-      for (int i = s->ninst_ - 1; i >= 0; i--) {
-        int id = s->inst_[i];
-        if (id == MatchSep)
-          break;
-        params->matches->insert(id);
-      }
-    }
-  }
-
-  params->ep = reinterpret_cast<const char*>(lastmatch);
-  return matched;
-}
-
-// Inline specializations of the general loop.
-bool DFA::SearchFFF(SearchParams* params) {
-  return InlinedSearchLoop<false, false, false>(params);
-}
-bool DFA::SearchFFT(SearchParams* params) {
-  return InlinedSearchLoop<false, false, true>(params);
-}
-bool DFA::SearchFTF(SearchParams* params) {
-  return InlinedSearchLoop<false, true, false>(params);
-}
-bool DFA::SearchFTT(SearchParams* params) {
-  return InlinedSearchLoop<false, true, true>(params);
-}
-bool DFA::SearchTFF(SearchParams* params) {
-  return InlinedSearchLoop<true, false, false>(params);
-}
-bool DFA::SearchTFT(SearchParams* params) {
-  return InlinedSearchLoop<true, false, true>(params);
-}
-bool DFA::SearchTTF(SearchParams* params) {
-  return InlinedSearchLoop<true, true, false>(params);
-}
-bool DFA::SearchTTT(SearchParams* params) {
-  return InlinedSearchLoop<true, true, true>(params);
-}
-
-// For performance, calls the appropriate specialized version
-// of InlinedSearchLoop.
-bool DFA::FastSearchLoop(SearchParams* params) {
-  // Because the methods are private, the Searches array
-  // cannot be declared at top level.
-  static bool (DFA::*Searches[])(SearchParams*) = {
-    &DFA::SearchFFF,
-    &DFA::SearchFFT,
-    &DFA::SearchFTF,
-    &DFA::SearchFTT,
-    &DFA::SearchTFF,
-    &DFA::SearchTFT,
-    &DFA::SearchTTF,
-    &DFA::SearchTTT,
-  };
-
-  int index = 4 * params->can_prefix_accel +
-              2 * params->want_earliest_match +
-              1 * params->run_forward;
-  return (this->*Searches[index])(params);
-}
-
-
-// The discussion of DFA execution above ignored the question of how
-// to determine the initial state for the search loop.  There are two
-// factors that influence the choice of start state.
-//
-// The first factor is whether the search is anchored or not.
-// The regexp program (Prog*) itself has
-// two different entry points: one for anchored searches and one for
-// unanchored searches.  (The unanchored version starts with a leading ".*?"
-// and then jumps to the anchored one.)
-//
-// The second factor is where text appears in the larger context, which
-// determines which empty-string operators can be matched at the beginning
-// of execution.  If text is at the very beginning of context, \A and ^ match.
-// Otherwise if text is at the beginning of a line, then ^ matches.
-// Otherwise it matters whether the character before text is a word character
-// or a non-word character.
-//
-// The two cases (unanchored vs not) and four cases (empty-string flags)
-// combine to make the eight cases recorded in the DFA's begin_text_[2],
-// begin_line_[2], after_wordchar_[2], and after_nonwordchar_[2] cached
-// StartInfos.  The start state for each is filled in the first time it
-// is used for an actual search.
-
-// Examines text, context, and anchored to determine the right start
-// state for the DFA search loop.  Fills in params and returns true on success.
-// Returns false on failure.
-bool DFA::AnalyzeSearch(SearchParams* params) {
-  const StringPiece& text = params->text;
-  const StringPiece& context = params->context;
-
-  // Sanity check: make sure that text lies within context.
-  if (BeginPtr(text) < BeginPtr(context) || EndPtr(text) > EndPtr(context)) {
-    LOG(DFATAL) << "context does not contain text";
-    params->start = DeadState;
-    return true;
-  }
-
-  // Determine correct search type.
-  int start;
-  uint32_t flags;
-  if (params->run_forward) {
-    if (BeginPtr(text) == BeginPtr(context)) {
-      start = kStartBeginText;
-      flags = kEmptyBeginText|kEmptyBeginLine;
-    } else if (BeginPtr(text)[-1] == '\n') {
-      start = kStartBeginLine;
-      flags = kEmptyBeginLine;
-    } else if (Prog::IsWordChar(BeginPtr(text)[-1] & 0xFF)) {
-      start = kStartAfterWordChar;
-      flags = kFlagLastWord;
-    } else {
-      start = kStartAfterNonWordChar;
-      flags = 0;
-    }
-  } else {
-    if (EndPtr(text) == EndPtr(context)) {
-      start = kStartBeginText;
-      flags = kEmptyBeginText|kEmptyBeginLine;
-    } else if (EndPtr(text)[0] == '\n') {
-      start = kStartBeginLine;
-      flags = kEmptyBeginLine;
-    } else if (Prog::IsWordChar(EndPtr(text)[0] & 0xFF)) {
-      start = kStartAfterWordChar;
-      flags = kFlagLastWord;
-    } else {
-      start = kStartAfterNonWordChar;
-      flags = 0;
-    }
-  }
-  if (params->anchored)
-    start |= kStartAnchored;
-  StartInfo* info = &start_[start];
-
-  // Try once without cache_lock for writing.
-  // Try again after resetting the cache
-  // (ResetCache will relock cache_lock for writing).
-  if (!AnalyzeSearchHelper(params, info, flags)) {
-    ResetCache(params->cache_lock);
-    if (!AnalyzeSearchHelper(params, info, flags)) {
-      params->failed = true;
-      LOG(DFATAL) << "Failed to analyze start state.";
-      return false;
-    }
-  }
-
-  params->start = info->start.load(std::memory_order_acquire);
-
-  // Even if we could prefix accel, we cannot do so when anchored and,
-  // less obviously, we cannot do so when we are going to need flags.
-  // This trick works only when there is a single byte that leads to a
-  // different state!
-  if (prog_->can_prefix_accel() &&
-      !params->anchored &&
-      params->start > SpecialStateMax &&
-      params->start->flag_ >> kFlagNeedShift == 0)
-    params->can_prefix_accel = true;
-
-  return true;
-}
-
-// Fills in info if needed.  Returns true on success, false on failure.
-bool DFA::AnalyzeSearchHelper(SearchParams* params, StartInfo* info,
-                              uint32_t flags) {
-  // Quick check.
-  State* start = info->start.load(std::memory_order_acquire);
-  if (start != NULL)
-    return true;
-
-  MutexLock l(&mutex_);
-  start = info->start.load(std::memory_order_relaxed);
-  if (start != NULL)
-    return true;
-
-  q0_->clear();
-  AddToQueue(q0_,
-             params->anchored ? prog_->start() : prog_->start_unanchored(),
-             flags);
-  start = WorkqToCachedState(q0_, NULL, flags);
-  if (start == NULL)
-    return false;
-
-  // Synchronize with "quick check" above.
-  info->start.store(start, std::memory_order_release);
-  return true;
-}
-
-// The actual DFA search: calls AnalyzeSearch and then FastSearchLoop.
-bool DFA::Search(const StringPiece& text,
-                 const StringPiece& context,
-                 bool anchored,
-                 bool want_earliest_match,
-                 bool run_forward,
-                 bool* failed,
-                 const char** epp,
-                 SparseSet* matches) {
-  *epp = NULL;
-  if (!ok()) {
-    *failed = true;
-    return false;
-  }
-  *failed = false;
-
-  RWLocker l(&cache_mutex_);
-  SearchParams params(text, context, &l);
-  params.anchored = anchored;
-  params.want_earliest_match = want_earliest_match;
-  params.run_forward = run_forward;
-  params.matches = matches;
-
-  if (!AnalyzeSearch(&params)) {
-    *failed = true;
-    return false;
-  }
-  if (params.start == DeadState)
-    return false;
-  if (params.start == FullMatchState) {
-    if (run_forward == want_earliest_match)
-      *epp = text.data();
-    else
-      *epp = text.data() + text.size();
-    return true;
-  }
-  bool ret = FastSearchLoop(&params);
-  if (params.failed) {
-    *failed = true;
-    return false;
-  }
-  *epp = params.ep;
-  return ret;
-}
-
-DFA* Prog::GetDFA(MatchKind kind) {
-  // For a forward DFA, half the memory goes to each DFA.
-  // However, if it is a "many match" DFA, then there is
-  // no counterpart with which the memory must be shared.
-  //
-  // For a reverse DFA, all the memory goes to the
-  // "longest match" DFA, because RE2 never does reverse
-  // "first match" searches.
-  if (kind == kFirstMatch) {
-    std::call_once(dfa_first_once_, [](Prog* prog) {
-      prog->dfa_first_ = new DFA(prog, kFirstMatch, prog->dfa_mem_ / 2);
-    }, this);
-    return dfa_first_;
-  } else if (kind == kManyMatch) {
-    std::call_once(dfa_first_once_, [](Prog* prog) {
-      prog->dfa_first_ = new DFA(prog, kManyMatch, prog->dfa_mem_);
-    }, this);
-    return dfa_first_;
-  } else {
-    std::call_once(dfa_longest_once_, [](Prog* prog) {
-      if (!prog->reversed_)
-        prog->dfa_longest_ = new DFA(prog, kLongestMatch, prog->dfa_mem_ / 2);
-      else
-        prog->dfa_longest_ = new DFA(prog, kLongestMatch, prog->dfa_mem_);
-    }, this);
-    return dfa_longest_;
-  }
-}
-
-void Prog::DeleteDFA(DFA* dfa) {
-  delete dfa;
-}
-
-// Executes the regexp program to search in text,
-// which itself is inside the larger context.  (As a convenience,
-// passing a NULL context is equivalent to passing text.)
-// Returns true if a match is found, false if not.
-// If a match is found, fills in match0->end() to point at the end of the match
-// and sets match0->begin() to text.begin(), since the DFA can't track
-// where the match actually began.
-//
-// This is the only external interface (class DFA only exists in this file).
-//
-bool Prog::SearchDFA(const StringPiece& text, const StringPiece& const_context,
-                     Anchor anchor, MatchKind kind, StringPiece* match0,
-                     bool* failed, SparseSet* matches) {
-  *failed = false;
-
-  StringPiece context = const_context;
-  if (context.data() == NULL)
-    context = text;
-  bool caret = anchor_start();
-  bool dollar = anchor_end();
-  if (reversed_) {
-    using std::swap;
-    swap(caret, dollar);
-  }
-  if (caret && BeginPtr(context) != BeginPtr(text))
-    return false;
-  if (dollar && EndPtr(context) != EndPtr(text))
-    return false;
-
-  // Handle full match by running an anchored longest match
-  // and then checking if it covers all of text.
-  bool anchored = anchor == kAnchored || anchor_start() || kind == kFullMatch;
-  bool endmatch = false;
-  if (kind == kManyMatch) {
-    // This is split out in order to avoid clobbering kind.
-  } else if (kind == kFullMatch || anchor_end()) {
-    endmatch = true;
-    kind = kLongestMatch;
-  }
-
-  // If the caller doesn't care where the match is (just whether one exists),
-  // then we can stop at the very first match we find, the so-called
-  // "earliest match".
-  bool want_earliest_match = false;
-  if (kind == kManyMatch) {
-    // This is split out in order to avoid clobbering kind.
-    if (matches == NULL) {
-      want_earliest_match = true;
-    }
-  } else if (match0 == NULL && !endmatch) {
-    want_earliest_match = true;
-    kind = kLongestMatch;
-  }
-
-  DFA* dfa = GetDFA(kind);
-  const char* ep;
-  bool matched = dfa->Search(text, context, anchored,
-                             want_earliest_match, !reversed_,
-                             failed, &ep, matches);
-  if (*failed) {
-    hooks::GetDFASearchFailureHook()({
-        // Nothing yet...
-    });
-    return false;
-  }
-  if (!matched)
-    return false;
-  if (endmatch && ep != (reversed_ ? text.data() : text.data() + text.size()))
-    return false;
-
-  // If caller cares, record the boundary of the match.
-  // We only know where it ends, so use the boundary of text
-  // as the beginning.
-  if (match0) {
-    if (reversed_)
-      *match0 =
-          StringPiece(ep, static_cast<size_t>(text.data() + text.size() - ep));
-    else
-      *match0 =
-          StringPiece(text.data(), static_cast<size_t>(ep - text.data()));
-  }
-  return true;
-}
-
-// Build out all states in DFA.  Returns number of states.
-int DFA::BuildAllStates(const Prog::DFAStateCallback& cb) {
-  if (!ok())
-    return 0;
-
-  // Pick out start state for unanchored search
-  // at beginning of text.
-  RWLocker l(&cache_mutex_);
-  SearchParams params(StringPiece(), StringPiece(), &l);
-  params.anchored = false;
-  if (!AnalyzeSearch(&params) ||
-      params.start == NULL ||
-      params.start == DeadState)
-    return 0;
-
-  // Add start state to work queue.
-  // Note that any State* that we handle here must point into the cache,
-  // so we can simply depend on pointer-as-a-number hashing and equality.
-  std::unordered_map<State*, int> m;
-  std::deque<State*> q;
-  m.emplace(params.start, static_cast<int>(m.size()));
-  q.push_back(params.start);
-
-  // Compute the input bytes needed to cover all of the next pointers.
-  int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-  std::vector<int> input(nnext);
-  for (int c = 0; c < 256; c++) {
-    int b = prog_->bytemap()[c];
-    while (c < 256-1 && prog_->bytemap()[c+1] == b)
-      c++;
-    input[b] = c;
-  }
-  input[prog_->bytemap_range()] = kByteEndText;
-
-  // Scratch space for the output.
-  std::vector<int> output(nnext);
-
-  // Flood to expand every state.
-  bool oom = false;
-  while (!q.empty()) {
-    State* s = q.front();
-    q.pop_front();
-    for (int c : input) {
-      State* ns = RunStateOnByteUnlocked(s, c);
-      if (ns == NULL) {
-        oom = true;
-        break;
-      }
-      if (ns == DeadState) {
-        output[ByteMap(c)] = -1;
-        continue;
-      }
-      if (m.find(ns) == m.end()) {
-        m.emplace(ns, static_cast<int>(m.size()));
-        q.push_back(ns);
-      }
-      output[ByteMap(c)] = m[ns];
-    }
-    if (cb)
-      cb(oom ? NULL : output.data(),
-         s == FullMatchState || s->IsMatch());
-    if (oom)
-      break;
-  }
-
-  return static_cast<int>(m.size());
-}
-
-// Build out all states in DFA for kind.  Returns number of states.
-int Prog::BuildEntireDFA(MatchKind kind, const DFAStateCallback& cb) {
-  return GetDFA(kind)->BuildAllStates(cb);
-}
-
-// Computes min and max for matching string.
-// Won't return strings bigger than maxlen.
-bool DFA::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {
-  if (!ok())
-    return false;
-
-  // NOTE: if future users of PossibleMatchRange want more precision when
-  // presented with infinitely repeated elements, consider making this a
-  // parameter to PossibleMatchRange.
-  static int kMaxEltRepetitions = 0;
-
-  // Keep track of the number of times we've visited states previously. We only
-  // revisit a given state if it's part of a repeated group, so if the value
-  // portion of the map tuple exceeds kMaxEltRepetitions we bail out and set
-  // |*max| to |PrefixSuccessor(*max)|.
-  //
-  // Also note that previously_visited_states[UnseenStatePtr] will, in the STL
-  // tradition, implicitly insert a '0' value at first use. We take advantage
-  // of that property below.
-  std::unordered_map<State*, int> previously_visited_states;
-
-  // Pick out start state for anchored search at beginning of text.
-  RWLocker l(&cache_mutex_);
-  SearchParams params(StringPiece(), StringPiece(), &l);
-  params.anchored = true;
-  if (!AnalyzeSearch(&params))
-    return false;
-  if (params.start == DeadState) {  // No matching strings
-    *min = "";
-    *max = "";
-    return true;
-  }
-  if (params.start == FullMatchState)  // Every string matches: no max
-    return false;
-
-  // The DFA is essentially a big graph rooted at params.start,
-  // and paths in the graph correspond to accepted strings.
-  // Each node in the graph has potentially 256+1 arrows
-  // coming out, one for each byte plus the magic end of
-  // text character kByteEndText.
-
-  // To find the smallest possible prefix of an accepted
-  // string, we just walk the graph preferring to follow
-  // arrows with the lowest bytes possible.  To find the
-  // largest possible prefix, we follow the largest bytes
-  // possible.
-
-  // The test for whether there is an arrow from s on byte j is
-  //    ns = RunStateOnByteUnlocked(s, j);
-  //    if (ns == NULL)
-  //      return false;
-  //    if (ns != DeadState && ns->ninst > 0)
-  // The RunStateOnByteUnlocked call asks the DFA to build out the graph.
-  // It returns NULL only if the DFA has run out of memory,
-  // in which case we can't be sure of anything.
-  // The second check sees whether there was graph built
-  // and whether it is interesting graph.  Nodes might have
-  // ns->ninst == 0 if they exist only to represent the fact
-  // that a match was found on the previous byte.
-
-  // Build minimum prefix.
-  State* s = params.start;
-  min->clear();
-  MutexLock lock(&mutex_);
-  for (int i = 0; i < maxlen; i++) {
-    if (previously_visited_states[s] > kMaxEltRepetitions)
-      break;
-    previously_visited_states[s]++;
-
-    // Stop if min is a match.
-    State* ns = RunStateOnByte(s, kByteEndText);
-    if (ns == NULL)  // DFA out of memory
-      return false;
-    if (ns != DeadState && (ns == FullMatchState || ns->IsMatch()))
-      break;
-
-    // Try to extend the string with low bytes.
-    bool extended = false;
-    for (int j = 0; j < 256; j++) {
-      ns = RunStateOnByte(s, j);
-      if (ns == NULL)  // DFA out of memory
-        return false;
-      if (ns == FullMatchState ||
-          (ns > SpecialStateMax && ns->ninst_ > 0)) {
-        extended = true;
-        min->append(1, static_cast<char>(j));
-        s = ns;
-        break;
-      }
-    }
-    if (!extended)
-      break;
-  }
-
-  // Build maximum prefix.
-  previously_visited_states.clear();
-  s = params.start;
-  max->clear();
-  for (int i = 0; i < maxlen; i++) {
-    if (previously_visited_states[s] > kMaxEltRepetitions)
-      break;
-    previously_visited_states[s] += 1;
-
-    // Try to extend the string with high bytes.
-    bool extended = false;
-    for (int j = 255; j >= 0; j--) {
-      State* ns = RunStateOnByte(s, j);
-      if (ns == NULL)
-        return false;
-      if (ns == FullMatchState ||
-          (ns > SpecialStateMax && ns->ninst_ > 0)) {
-        extended = true;
-        max->append(1, static_cast<char>(j));
-        s = ns;
-        break;
-      }
-    }
-    if (!extended) {
-      // Done, no need for PrefixSuccessor.
-      return true;
-    }
-  }
-
-  // Stopped while still adding to *max - round aaaaaaaaaa... to aaaa...b
-  PrefixSuccessor(max);
-
-  // If there are no bytes left, we have no way to say "there is no maximum
-  // string".  We could make the interface more complicated and be able to
-  // return "there is no maximum but here is a minimum", but that seems like
-  // overkill -- the most common no-max case is all possible strings, so not
-  // telling the caller that the empty string is the minimum match isn't a
-  // great loss.
-  if (max->empty())
-    return false;
-
-  return true;
-}
-
-// PossibleMatchRange for a Prog.
-bool Prog::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {
-  // Have to use dfa_longest_ to get all strings for full matches.
-  // For example, (a|aa) never matches aa in first-match mode.
-  return GetDFA(kLongestMatch)->PossibleMatchRange(min, max, maxlen);
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/filtered_re2.cc b/src/duckdb/third_party/re2/re2/filtered_re2.cc
deleted file mode 100644
index 80a36f78a..000000000
--- a/src/duckdb/third_party/re2/re2/filtered_re2.cc
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "re2/filtered_re2.h"
-
-#include <stddef.h>
-#include <string>
-#include <utility>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "re2/prefilter.h"
-#include "re2/prefilter_tree.h"
-
-namespace duckdb_re2 {
-
-FilteredRE2::FilteredRE2()
-    : compiled_(false),
-      prefilter_tree_(new PrefilterTree()) {
-}
-
-FilteredRE2::FilteredRE2(int min_atom_len)
-    : compiled_(false),
-      prefilter_tree_(new PrefilterTree(min_atom_len)) {
-}
-
-FilteredRE2::~FilteredRE2() {
-  for (size_t i = 0; i < re2_vec_.size(); i++)
-    delete re2_vec_[i];
-}
-
-FilteredRE2::FilteredRE2(FilteredRE2&& other)
-    : re2_vec_(std::move(other.re2_vec_)),
-      compiled_(other.compiled_),
-      prefilter_tree_(std::move(other.prefilter_tree_)) {
-  other.re2_vec_.clear();
-  other.re2_vec_.shrink_to_fit();
-  other.compiled_ = false;
-  other.prefilter_tree_.reset(new PrefilterTree());
-}
-
-FilteredRE2& FilteredRE2::operator=(FilteredRE2&& other) {
-  this->~FilteredRE2();
-  (void) new (this) FilteredRE2(std::move(other));
-  return *this;
-}
-
-RE2::ErrorCode FilteredRE2::Add(const StringPiece& pattern,
-                                const RE2::Options& options, int* id) {
-  RE2* re = new RE2(pattern, options);
-  RE2::ErrorCode code = re->error_code();
-
-  if (!re->ok()) {
-    if (options.log_errors()) {
-      LOG(ERROR) << "Couldn't compile regular expression, skipping: "
-                 << pattern << " due to error " << re->error();
-    }
-    delete re;
-  } else {
-    *id = static_cast<int>(re2_vec_.size());
-    re2_vec_.push_back(re);
-  }
-
-  return code;
-}
-
-void FilteredRE2::Compile(std::vector<std::string>* atoms) {
-  if (compiled_) {
-    LOG(ERROR) << "Compile called already.";
-    return;
-  }
-
-  if (re2_vec_.empty()) {
-    LOG(ERROR) << "Compile called before Add.";
-    return;
-  }
-
-  for (size_t i = 0; i < re2_vec_.size(); i++) {
-    Prefilter* prefilter = Prefilter::FromRE2(re2_vec_[i]);
-    prefilter_tree_->Add(prefilter);
-  }
-  atoms->clear();
-  prefilter_tree_->Compile(atoms);
-  compiled_ = true;
-}
-
-int FilteredRE2::SlowFirstMatch(const StringPiece& text) const {
-  for (size_t i = 0; i < re2_vec_.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[i]))
-      return static_cast<int>(i);
-  return -1;
-}
-
-int FilteredRE2::FirstMatch(const StringPiece& text,
-                            const std::vector<int>& atoms) const {
-  if (!compiled_) {
-    LOG(DFATAL) << "FirstMatch called before Compile.";
-    return -1;
-  }
-  std::vector<int> regexps;
-  prefilter_tree_->RegexpsGivenStrings(atoms, &regexps);
-  for (size_t i = 0; i < regexps.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[regexps[i]]))
-      return regexps[i];
-  return -1;
-}
-
-bool FilteredRE2::AllMatches(
-    const StringPiece& text,
-    const std::vector<int>& atoms,
-    std::vector<int>* matching_regexps) const {
-  matching_regexps->clear();
-  std::vector<int> regexps;
-  prefilter_tree_->RegexpsGivenStrings(atoms, &regexps);
-  for (size_t i = 0; i < regexps.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[regexps[i]]))
-      matching_regexps->push_back(regexps[i]);
-  return !matching_regexps->empty();
-}
-
-void FilteredRE2::AllPotentials(
-    const std::vector<int>& atoms,
-    std::vector<int>* potential_regexps) const {
-  prefilter_tree_->RegexpsGivenStrings(atoms, potential_regexps);
-}
-
-void FilteredRE2::RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                                      std::vector<int>* passed_regexps) {
-  prefilter_tree_->RegexpsGivenStrings(matched_atoms, passed_regexps);
-}
-
-void FilteredRE2::PrintPrefilter(int regexpid) {
-  prefilter_tree_->PrintPrefilter(regexpid);
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/filtered_re2.h b/src/duckdb/third_party/re2/re2/filtered_re2.h
deleted file mode 100644
index 36f7c5858..000000000
--- a/src/duckdb/third_party/re2/re2/filtered_re2.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_FILTERED_RE2_H_
-#define RE2_FILTERED_RE2_H_
-
-// The class FilteredRE2 is used as a wrapper to multiple RE2 regexps.
-// It provides a prefilter mechanism that helps in cutting down the
-// number of regexps that need to be actually searched.
-//
-// By design, it does not include a string matching engine. This is to
-// allow the user of the class to use their favorite string matching
-// engine. The overall flow is: Add all the regexps using Add, then
-// Compile the FilteredRE2. Compile returns strings that need to be
-// matched. Note that the returned strings are lowercased and distinct.
-// For applying regexps to a search text, the caller does the string
-// matching using the returned strings. When doing the string match,
-// note that the caller has to do that in a case-insensitive way or
-// on a lowercased version of the search text. Then call FirstMatch
-// or AllMatches with a vector of indices of strings that were found
-// in the text to get the actual regexp matches.
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "re2/re2.h"
-
-namespace duckdb_re2 {
-
-class PrefilterTree;
-
-class FilteredRE2 {
- public:
-  FilteredRE2();
-  explicit FilteredRE2(int min_atom_len);
-  ~FilteredRE2();
-
-  // Not copyable.
-  FilteredRE2(const FilteredRE2&) = delete;
-  FilteredRE2& operator=(const FilteredRE2&) = delete;
-  // Movable.
-  FilteredRE2(FilteredRE2&& other);
-  FilteredRE2& operator=(FilteredRE2&& other);
-
-  // Uses RE2 constructor to create a RE2 object (re). Returns
-  // re->error_code(). If error_code is other than NoError, then re is
-  // deleted and not added to re2_vec_.
-  RE2::ErrorCode Add(const StringPiece& pattern,
-                     const RE2::Options& options,
-                     int* id);
-
-  // Prepares the regexps added by Add for filtering.  Returns a set
-  // of strings that the caller should check for in candidate texts.
-  // The returned strings are lowercased and distinct. When doing
-  // string matching, it should be performed in a case-insensitive
-  // way or the search text should be lowercased first.  Call after
-  // all Add calls are done.
-  void Compile(std::vector<std::string>* strings_to_match);
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Can be called prior to Compile.
-  // Does not do any filtering: simply tries to Match the
-  // regexps in a loop.
-  int SlowFirstMatch(const StringPiece& text) const;
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Compile has to be called before
-  // calling this.
-  int FirstMatch(const StringPiece& text,
-                 const std::vector<int>& atoms) const;
-
-  // Returns the indices of all matching regexps, after first clearing
-  // matched_regexps.
-  bool AllMatches(const StringPiece& text,
-                  const std::vector<int>& atoms,
-                  std::vector<int>* matching_regexps) const;
-
-  // Returns the indices of all potentially matching regexps after first
-  // clearing potential_regexps.
-  // A regexp is potentially matching if it passes the filter.
-  // If a regexp passes the filter it may still not match.
-  // A regexp that does not pass the filter is guaranteed to not match.
-  void AllPotentials(const std::vector<int>& atoms,
-                     std::vector<int>* potential_regexps) const;
-
-  // The number of regexps added.
-  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
-
-  // Get the individual RE2 objects.
-  const RE2& GetRE2(int regexpid) const { return *re2_vec_[regexpid]; }
-
- private:
-  // Print prefilter.
-  void PrintPrefilter(int regexpid);
-
-  // Useful for testing and debugging.
-  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                           std::vector<int>* passed_regexps);
-
-  // All the regexps in the FilteredRE2.
-  std::vector<RE2*> re2_vec_;
-
-  // Has the FilteredRE2 been compiled using Compile()
-  bool compiled_;
-
-  // An AND-OR tree of string atoms used for filtering regexps.
-  std::unique_ptr<PrefilterTree> prefilter_tree_;
-};
-
-}  // namespace re2
-
-#endif  // RE2_FILTERED_RE2_H_
diff --git a/src/duckdb/third_party/re2/re2/mimics_pcre.cc b/src/duckdb/third_party/re2/re2/mimics_pcre.cc
deleted file mode 100644
index 49a798bb4..000000000
--- a/src/duckdb/third_party/re2/re2/mimics_pcre.cc
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Determine whether this library should match PCRE exactly
-// for a particular Regexp.  (If so, the testing framework can
-// check that it does.)
-//
-// This library matches PCRE except in these cases:
-//   * the regexp contains a repetition of an empty string,
-//     like (a*)* or (a*)+.  In this case, PCRE will treat
-//     the repetition sequence as ending with an empty string,
-//     while this library does not.
-//   * Perl and PCRE differ on whether \v matches \n.
-//     For historical reasons, this library implements the Perl behavior.
-//   * Perl and PCRE allow $ in one-line mode to match either the very
-//     end of the text or just before a \n at the end of the text.
-//     This library requires it to match only the end of the text.
-//   * Similarly, Perl and PCRE do not allow ^ in multi-line mode to
-//     match the end of the text if the last character is a \n.
-//     This library does allow it.
-//
-// Regexp::MimicsPCRE checks for any of these conditions.
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "re2/regexp.h"
-#include "re2/walker-inl.h"
-
-namespace duckdb_re2 {
-
-// Returns whether re might match an empty string.
-static bool CanBeEmptyString(Regexp *re);
-
-// Walker class to compute whether library handles a regexp
-// exactly as PCRE would.  See comment at top for conditions.
-
-class PCREWalker : public Regexp::Walker<bool> {
- public:
-  PCREWalker() {}
-
-  virtual bool PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                         bool* child_args, int nchild_args);
-
-  virtual bool ShortVisit(Regexp* re, bool a) {
-    // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    LOG(DFATAL) << "PCREWalker::ShortVisit called";
-#endif
-    return a;
-  }
-
- private:
-  PCREWalker(const PCREWalker&) = delete;
-  PCREWalker& operator=(const PCREWalker&) = delete;
-};
-
-// Called after visiting each of re's children and accumulating
-// the return values in child_args.  So child_args contains whether
-// this library mimics PCRE for those subexpressions.
-bool PCREWalker::PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                           bool* child_args, int nchild_args) {
-  // If children failed, so do we.
-  for (int i = 0; i < nchild_args; i++)
-    if (!child_args[i])
-      return false;
-
-  // Otherwise look for other reasons to fail.
-  switch (re->op()) {
-    // Look for repeated empty string.
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-      if (CanBeEmptyString(re->sub()[0]))
-        return false;
-      break;
-    case kRegexpRepeat:
-      if (re->max() == -1 && CanBeEmptyString(re->sub()[0]))
-        return false;
-      break;
-
-    // Look for \v
-    case kRegexpLiteral:
-      if (re->rune() == '\v')
-        return false;
-      break;
-
-    // Look for $ in single-line mode.
-    case kRegexpEndText:
-    case kRegexpEmptyMatch:
-      if (re->parse_flags() & Regexp::WasDollar)
-        return false;
-      break;
-
-    // Look for ^ in multi-line mode.
-    case kRegexpBeginLine:
-      // No condition: in single-line mode ^ becomes kRegexpBeginText.
-      return false;
-
-    default:
-      break;
-  }
-
-  // Not proven guilty.
-  return true;
-}
-
-// Returns whether this regexp's behavior will mimic PCRE's exactly.
-bool Regexp::MimicsPCRE() {
-  PCREWalker w;
-  return w.Walk(this, true);
-}
-
-
-// Walker class to compute whether a Regexp can match an empty string.
-// It is okay to overestimate.  For example, \b\B cannot match an empty
-// string, because \b and \B are mutually exclusive, but this isn't
-// that smart and will say it can.  Spurious empty strings
-// will reduce the number of regexps we sanity check against PCRE,
-// but they won't break anything.
-
-class EmptyStringWalker : public Regexp::Walker<bool> {
- public:
-  EmptyStringWalker() {}
-
-  virtual bool PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                         bool* child_args, int nchild_args);
-
-  virtual bool ShortVisit(Regexp* re, bool a) {
-    // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    LOG(DFATAL) << "EmptyStringWalker::ShortVisit called";
-#endif
-    return a;
-  }
-
- private:
-  EmptyStringWalker(const EmptyStringWalker&) = delete;
-  EmptyStringWalker& operator=(const EmptyStringWalker&) = delete;
-};
-
-// Called after visiting re's children.  child_args contains the return
-// value from each of the children's PostVisits (i.e., whether each child
-// can match an empty string).  Returns whether this clause can match an
-// empty string.
-bool EmptyStringWalker::PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                                  bool* child_args, int nchild_args) {
-  switch (re->op()) {
-    case kRegexpNoMatch:               // never empty
-    case kRegexpLiteral:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpCharClass:
-    case kRegexpLiteralString:
-      return false;
-
-    case kRegexpEmptyMatch:            // always empty
-    case kRegexpBeginLine:             // always empty, when they match
-    case kRegexpEndLine:
-    case kRegexpNoWordBoundary:
-    case kRegexpWordBoundary:
-    case kRegexpBeginText:
-    case kRegexpEndText:
-    case kRegexpStar:                  // can always be empty
-    case kRegexpQuest:
-    case kRegexpHaveMatch:
-      return true;
-
-    case kRegexpConcat:                // can be empty if all children can
-      for (int i = 0; i < nchild_args; i++)
-        if (!child_args[i])
-          return false;
-      return true;
-
-    case kRegexpAlternate:             // can be empty if any child can
-      for (int i = 0; i < nchild_args; i++)
-        if (child_args[i])
-          return true;
-      return false;
-
-    case kRegexpPlus:                  // can be empty if the child can
-    case kRegexpCapture:
-      return child_args[0];
-
-    case kRegexpRepeat:                // can be empty if child can or is x{0}
-      return child_args[0] || re->min() == 0;
-  }
-  return false;
-}
-
-// Returns whether re can match an empty string.
-static bool CanBeEmptyString(Regexp* re) {
-  EmptyStringWalker w;
-  return w.Walk(re, true);
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/nfa.cc b/src/duckdb/third_party/re2/re2/nfa.cc
deleted file mode 100644
index 17f3e01e5..000000000
--- a/src/duckdb/third_party/re2/re2/nfa.cc
+++ /dev/null
@@ -1,674 +0,0 @@
-// Copyright 2006-2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tested by search_test.cc.
-//
-// Prog::SearchNFA, an NFA search.
-// This is an actual NFA like the theorists talk about,
-// not the pseudo-NFA found in backtracking regexp implementations.
-//
-// IMPLEMENTATION
-//
-// This algorithm is a variant of one that appeared in Rob Pike's sam editor,
-// which is a variant of the one described in Thompson's 1968 CACM paper.
-// See http://swtch.com/~rsc/regexp/ for various history.  The main feature
-// over the DFA implementation is that it tracks submatch boundaries.
-//
-// When the choice of submatch boundaries is ambiguous, this particular
-// implementation makes the same choices that traditional backtracking
-// implementations (in particular, Perl and PCRE) do.
-// Note that unlike in Perl and PCRE, this algorithm *cannot* take exponential
-// time in the length of the input.
-//
-// Like Thompson's original machine and like the DFA implementation, this
-// implementation notices a match only once it is one byte past it.
-
-#include <stdio.h>
-#include <string.h>
-#include <algorithm>
-#include <deque>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "re2/pod_array.h"
-#include "re2/prog.h"
-#include "re2/regexp.h"
-#include "re2/sparse_array.h"
-#include "re2/sparse_set.h"
-
-namespace duckdb_re2 {
-
-class NFA {
- public:
-  NFA(Prog* prog);
-  ~NFA();
-
-  // Searches for a matching string.
-  //   * If anchored is true, only considers matches starting at offset.
-  //     Otherwise finds lefmost match at or after offset.
-  //   * If longest is true, returns the longest match starting
-  //     at the chosen start point.  Otherwise returns the so-called
-  //     left-biased match, the one traditional backtracking engines
-  //     (like Perl and PCRE) find.
-  // Records submatch boundaries in submatch[1..nsubmatch-1].
-  // Submatch[0] is the entire match.  When there is a choice in
-  // which text matches each subexpression, the submatch boundaries
-  // are chosen to match what a backtracking implementation would choose.
-  bool Search(const StringPiece& text, const StringPiece& context,
-              bool anchored, bool longest,
-              StringPiece* submatch, int nsubmatch);
-
- private:
-  struct Thread {
-    union {
-      int ref;
-      Thread* next;  // when on free list
-    };
-    const char** capture;
-  };
-
-  // State for explicit stack in AddToThreadq.
-  struct AddState {
-    int id;     // Inst to process
-    Thread* t;  // if not null, set t0 = t before processing id
-  };
-
-  // Threadq is a list of threads.  The list is sorted by the order
-  // in which Perl would explore that particular state -- the earlier
-  // choices appear earlier in the list.
-  typedef SparseArray<Thread*> Threadq;
-
-  inline Thread* AllocThread();
-  inline Thread* Incref(Thread* t);
-  inline void Decref(Thread* t);
-
-  // Follows all empty arrows from id0 and enqueues all the states reached.
-  // Enqueues only the ByteRange instructions that match byte c.
-  // context is used (with p) for evaluating empty-width specials.
-  // p is the current input position, and t0 is the current thread.
-  void AddToThreadq(Threadq* q, int id0, int c, const StringPiece& context,
-                    const char* p, Thread* t0);
-
-  // Run runq on byte c, appending new states to nextq.
-  // Updates matched_ and match_ as new, better matches are found.
-  // context is used (with p) for evaluating empty-width specials.
-  // p is the position of byte c in the input string for AddToThreadq;
-  // p-1 will be used when processing Match instructions.
-  // Frees all the threads on runq.
-  // If there is a shortcut to the end, returns that shortcut.
-  int Step(Threadq* runq, Threadq* nextq, int c, const StringPiece& context,
-           const char* p);
-
-  // Returns text version of capture information, for debugging.
-  std::string FormatCapture(const char** capture);
-
-  void CopyCapture(const char** dst, const char** src) {
-    memmove(dst, src, ncapture_*sizeof src[0]);
-  }
-
-  Prog* prog_;                // underlying program
-  int start_;                 // start instruction in program
-  int ncapture_;              // number of submatches to track
-  bool longest_;              // whether searching for longest match
-  bool endmatch_;             // whether match must end at text.end()
-  const char* btext_;         // beginning of text (for FormatSubmatch)
-  const char* etext_;         // end of text (for endmatch_)
-  Threadq q0_, q1_;           // pre-allocated for Search.
-  PODArray<AddState> stack_;  // pre-allocated for AddToThreadq
-  std::deque<Thread> arena_;  // thread arena
-  Thread* freelist_;          // thread freelist
-  const char** match_;        // best match so far
-  bool matched_;              // any match so far?
-
-  NFA(const NFA&) = delete;
-  NFA& operator=(const NFA&) = delete;
-};
-
-NFA::NFA(Prog* prog) {
-  prog_ = prog;
-  start_ = prog_->start();
-  ncapture_ = 0;
-  longest_ = false;
-  endmatch_ = false;
-  btext_ = NULL;
-  etext_ = NULL;
-  q0_.resize(prog_->size());
-  q1_.resize(prog_->size());
-  // See NFA::AddToThreadq() for why this is so.
-  int nstack = 2*prog_->inst_count(kInstCapture) +
-               prog_->inst_count(kInstEmptyWidth) +
-               prog_->inst_count(kInstNop) + 1;  // + 1 for start inst
-  stack_ = PODArray<AddState>(nstack);
-  freelist_ = NULL;
-  match_ = NULL;
-  matched_ = false;
-}
-
-NFA::~NFA() {
-  delete[] match_;
-  for (const Thread& t : arena_)
-    delete[] t.capture;
-}
-
-NFA::Thread* NFA::AllocThread() {
-  Thread* t = freelist_;
-  if (t != NULL) {
-    freelist_ = t->next;
-    t->ref = 1;
-    // We don't need to touch t->capture because
-    // the caller will immediately overwrite it.
-    return t;
-  }
-  arena_.emplace_back();
-  t = &arena_.back();
-  t->ref = 1;
-  t->capture = new const char*[ncapture_];
-  return t;
-}
-
-NFA::Thread* NFA::Incref(Thread* t) {
-  DCHECK(t != NULL);
-  t->ref++;
-  return t;
-}
-
-void NFA::Decref(Thread* t) {
-  DCHECK(t != NULL);
-  t->ref--;
-  if (t->ref > 0)
-    return;
-  DCHECK_EQ(t->ref, 0);
-  t->next = freelist_;
-  freelist_ = t;
-}
-
-// Follows all empty arrows from id0 and enqueues all the states reached.
-// Enqueues only the ByteRange instructions that match byte c.
-// context is used (with p) for evaluating empty-width specials.
-// p is the current input position, and t0 is the current thread.
-void NFA::AddToThreadq(Threadq* q, int id0, int c, const StringPiece& context,
-                       const char* p, Thread* t0) {
-  if (id0 == 0)
-    return;
-
-  // Use stack_ to hold our stack of instructions yet to process.
-  // It was preallocated as follows:
-  //   two entries per Capture;
-  //   one entry per EmptyWidth; and
-  //   one entry per Nop.
-  // This reflects the maximum number of stack pushes that each can
-  // perform. (Each instruction can be processed at most once.)
-  AddState* stk = stack_.data();
-  int nstk = 0;
-
-  stk[nstk++] = {id0, NULL};
-  while (nstk > 0) {
-    DCHECK_LE(nstk, stack_.size());
-    AddState a = stk[--nstk];
-
-  Loop:
-    if (a.t != NULL) {
-      // t0 was a thread that we allocated and copied in order to
-      // record the capture, so we must now decref it.
-      Decref(t0);
-      t0 = a.t;
-    }
-
-    int id = a.id;
-    if (id == 0)
-      continue;
-    if (q->has_index(id)) {
-      continue;
-    }
-
-    // Create entry in q no matter what.  We might fill it in below,
-    // or we might not.  Even if not, it is necessary to have it,
-    // so that we don't revisit id0 during the recursion.
-    q->set_new(id, NULL);
-    Thread** tp = &q->get_existing(id);
-    int j;
-    Thread* t;
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-    default:
-      LOG(DFATAL) << "unhandled " << ip->opcode() << " in AddToThreadq";
-      break;
-
-    case kInstFail:
-      break;
-
-    case kInstAltMatch:
-      // Save state; will pick up at next byte.
-      t = Incref(t0);
-      *tp = t;
-
-      DCHECK(!ip->last());
-      a = {id+1, NULL};
-      goto Loop;
-
-    case kInstNop:
-      if (!ip->last())
-        stk[nstk++] = {id+1, NULL};
-
-      // Continue on.
-      a = {ip->out(), NULL};
-      goto Loop;
-
-    case kInstCapture:
-      if (!ip->last())
-        stk[nstk++] = {id+1, NULL};
-
-      if ((j=ip->cap()) < ncapture_) {
-        // Push a dummy whose only job is to restore t0
-        // once we finish exploring this possibility.
-        stk[nstk++] = {0, t0};
-
-        // Record capture.
-        t = AllocThread();
-        CopyCapture(t->capture, t0->capture);
-        t->capture[j] = p;
-        t0 = t;
-      }
-      a = {ip->out(), NULL};
-      goto Loop;
-
-    case kInstByteRange:
-      if (!ip->Matches(c))
-        goto Next;
-
-      // Save state; will pick up at next byte.
-      t = Incref(t0);
-      *tp = t;
-
-      if (ip->hint() == 0)
-        break;
-      a = {id+ip->hint(), NULL};
-      goto Loop;
-
-    case kInstMatch:
-      // Save state; will pick up at next byte.
-      t = Incref(t0);
-      *tp = t;
-
-    Next:
-      if (ip->last())
-        break;
-      a = {id+1, NULL};
-      goto Loop;
-
-    case kInstEmptyWidth:
-      if (!ip->last())
-        stk[nstk++] = {id+1, NULL};
-
-      // Continue on if we have all the right flag bits.
-      if (ip->empty() & ~Prog::EmptyFlags(context, p))
-        break;
-      a = {ip->out(), NULL};
-      goto Loop;
-    }
-  }
-}
-
-// Run runq on byte c, appending new states to nextq.
-// Updates matched_ and match_ as new, better matches are found.
-// context is used (with p) for evaluating empty-width specials.
-// p is the position of byte c in the input string for AddToThreadq;
-// p-1 will be used when processing Match instructions.
-// Frees all the threads on runq.
-// If there is a shortcut to the end, returns that shortcut.
-int NFA::Step(Threadq* runq, Threadq* nextq, int c, const StringPiece& context,
-              const char* p) {
-  nextq->clear();
-
-  for (Threadq::iterator i = runq->begin(); i != runq->end(); ++i) {
-    Thread* t = i->value();
-    if (t == NULL)
-      continue;
-
-    if (longest_) {
-      // Can skip any threads started after our current best match.
-      if (matched_ && match_[0] < t->capture[0]) {
-        Decref(t);
-        continue;
-      }
-    }
-
-    int id = i->index();
-    Prog::Inst* ip = prog_->inst(id);
-
-    switch (ip->opcode()) {
-      default:
-        // Should only see the values handled below.
-        LOG(DFATAL) << "Unhandled " << ip->opcode() << " in step";
-        break;
-
-      case kInstByteRange:
-        AddToThreadq(nextq, ip->out(), c, context, p, t);
-        break;
-
-      case kInstAltMatch:
-        if (i != runq->begin())
-          break;
-        // The match is ours if we want it.
-        if (ip->greedy(prog_) || longest_) {
-          CopyCapture(match_, t->capture);
-          matched_ = true;
-
-          Decref(t);
-          for (++i; i != runq->end(); ++i) {
-            if (i->value() != NULL)
-              Decref(i->value());
-          }
-          runq->clear();
-          if (ip->greedy(prog_))
-            return ip->out1();
-          return ip->out();
-        }
-        break;
-
-      case kInstMatch: {
-        // Avoid invoking undefined behavior (arithmetic on a null pointer)
-        // by storing p instead of p-1. (What would the latter even mean?!)
-        // This complements the special case in NFA::Search().
-        if (p == NULL) {
-          CopyCapture(match_, t->capture);
-          match_[1] = p;
-          matched_ = true;
-          break;
-        }
-
-        if (endmatch_ && p-1 != etext_)
-          break;
-
-        if (longest_) {
-          // Leftmost-longest mode: save this match only if
-          // it is either farther to the left or at the same
-          // point but longer than an existing match.
-          if (!matched_ || t->capture[0] < match_[0] ||
-              (t->capture[0] == match_[0] && p-1 > match_[1])) {
-            CopyCapture(match_, t->capture);
-            match_[1] = p-1;
-            matched_ = true;
-          }
-        } else {
-          // Leftmost-biased mode: this match is by definition
-          // better than what we've already found (see next line).
-          CopyCapture(match_, t->capture);
-          match_[1] = p-1;
-          matched_ = true;
-
-          // Cut off the threads that can only find matches
-          // worse than the one we just found: don't run the
-          // rest of the current Threadq.
-          Decref(t);
-          for (++i; i != runq->end(); ++i) {
-            if (i->value() != NULL)
-              Decref(i->value());
-          }
-          runq->clear();
-          return 0;
-        }
-        break;
-      }
-    }
-    Decref(t);
-  }
-  runq->clear();
-  return 0;
-}
-
-std::string NFA::FormatCapture(const char** capture) {
-  std::string s;
-  for (int i = 0; i < ncapture_; i+=2) {
-    if (capture[i] == NULL)
-      s += "(?,?)";
-    else if (capture[i+1] == NULL)
-      s += StringPrintf("(%td,?)",
-                        capture[i] - btext_);
-    else
-      s += StringPrintf("(%td,%td)",
-                        capture[i] - btext_,
-                        capture[i+1] - btext_);
-  }
-  return s;
-}
-
-bool NFA::Search(const StringPiece& text, const StringPiece& const_context,
-            bool anchored, bool longest,
-            StringPiece* submatch, int nsubmatch) {
-  if (start_ == 0)
-    return false;
-
-  StringPiece context = const_context;
-  if (context.data() == NULL)
-    context = text;
-
-  // Sanity check: make sure that text lies within context.
-  if (BeginPtr(text) < BeginPtr(context) || EndPtr(text) > EndPtr(context)) {
-    LOG(DFATAL) << "context does not contain text";
-    return false;
-  }
-
-  if (prog_->anchor_start() && BeginPtr(context) != BeginPtr(text))
-    return false;
-  if (prog_->anchor_end() && EndPtr(context) != EndPtr(text))
-    return false;
-  anchored |= prog_->anchor_start();
-  if (prog_->anchor_end()) {
-    longest = true;
-    endmatch_ = true;
-  }
-
-  if (nsubmatch < 0) {
-    LOG(DFATAL) << "Bad args: nsubmatch=" << nsubmatch;
-    return false;
-  }
-
-  // Save search parameters.
-  ncapture_ = 2*nsubmatch;
-  longest_ = longest;
-
-  if (nsubmatch == 0) {
-    // We need to maintain match[0], both to distinguish the
-    // longest match (if longest is true) and also to tell
-    // whether we've seen any matches at all.
-    ncapture_ = 2;
-  }
-
-  match_ = new const char*[ncapture_];
-  memset(match_, 0, ncapture_*sizeof match_[0]);
-  matched_ = false;
-
-  // For debugging prints.
-  btext_ = context.data();
-  // For convenience.
-  etext_ = text.data() + text.size();
-
-  // Set up search.
-  Threadq* runq = &q0_;
-  Threadq* nextq = &q1_;
-  runq->clear();
-  nextq->clear();
-
-  // Loop over the text, stepping the machine.
-  for (const char* p = text.data();; p++) {
-    // This is a no-op the first time around the loop because runq is empty.
-    int id = Step(runq, nextq, p < etext_ ? p[0] & 0xFF : -1, context, p);
-    DCHECK_EQ(runq->size(), 0);
-    using std::swap;
-    swap(nextq, runq);
-    nextq->clear();
-    if (id != 0) {
-      // We're done: full match ahead.
-      p = etext_;
-      for (;;) {
-        Prog::Inst* ip = prog_->inst(id);
-        switch (ip->opcode()) {
-          default:
-            LOG(DFATAL) << "Unexpected opcode in short circuit: " << ip->opcode();
-            break;
-
-          case kInstCapture:
-            if (ip->cap() < ncapture_)
-              match_[ip->cap()] = p;
-            id = ip->out();
-            continue;
-
-          case kInstNop:
-            id = ip->out();
-            continue;
-
-          case kInstMatch:
-            match_[1] = p;
-            matched_ = true;
-            break;
-        }
-        break;
-      }
-      break;
-    }
-
-    if (p > etext_)
-      break;
-
-    // Start a new thread if there have not been any matches.
-    // (No point in starting a new thread if there have been
-    // matches, since it would be to the right of the match
-    // we already found.)
-    if (!matched_ && (!anchored || p == text.data())) {
-      // Try to use prefix accel (e.g. memchr) to skip ahead.
-      // The search must be unanchored and there must be zero
-      // possible matches already.
-      if (!anchored && runq->size() == 0 &&
-          p < etext_ && prog_->can_prefix_accel()) {
-        p = reinterpret_cast<const char*>(prog_->PrefixAccel(p, etext_ - p));
-        if (p == NULL)
-          p = etext_;
-      }
-
-      Thread* t = AllocThread();
-      CopyCapture(t->capture, match_);
-      t->capture[0] = p;
-      AddToThreadq(runq, start_, p < etext_ ? p[0] & 0xFF : -1, context, p,
-                   t);
-      Decref(t);
-    }
-
-    // If all the threads have died, stop early.
-    if (runq->size() == 0) {
-      break;
-    }
-
-    // Avoid invoking undefined behavior (arithmetic on a null pointer)
-    // by simply not continuing the loop.
-    // This complements the special case in NFA::Step().
-    if (p == NULL) {
-      (void) Step(runq, nextq, -1, context, p);
-      DCHECK_EQ(runq->size(), 0);
-      using std::swap;
-      swap(nextq, runq);
-      nextq->clear();
-      break;
-    }
-  }
-
-  for (Threadq::iterator i = runq->begin(); i != runq->end(); ++i) {
-    if (i->value() != NULL)
-      Decref(i->value());
-  }
-
-  if (matched_) {
-    for (int i = 0; i < nsubmatch; i++)
-      submatch[i] =
-          StringPiece(match_[2 * i],
-                      static_cast<size_t>(match_[2 * i + 1] - match_[2 * i]));
-    return true;
-  }
-  return false;
-}
-
-bool
-Prog::SearchNFA(const StringPiece& text, const StringPiece& context,
-                Anchor anchor, MatchKind kind,
-                StringPiece* match, int nmatch) {
-
-  NFA nfa(this);
-  StringPiece sp;
-  if (kind == kFullMatch) {
-    anchor = kAnchored;
-    if (nmatch == 0) {
-      match = &sp;
-      nmatch = 1;
-    }
-  }
-  if (!nfa.Search(text, context, anchor == kAnchored, kind != kFirstMatch, match, nmatch))
-    return false;
-  if (kind == kFullMatch && EndPtr(match[0]) != EndPtr(text))
-    return false;
-  return true;
-}
-
-// For each instruction i in the program reachable from the start, compute the
-// number of instructions reachable from i by following only empty transitions
-// and record that count as fanout[i].
-//
-// fanout holds the results and is also the work queue for the outer iteration.
-// reachable holds the reached nodes for the inner iteration.
-void Prog::Fanout(SparseArray<int>* fanout) {
-  DCHECK_EQ(fanout->max_size(), size());
-  SparseSet reachable(size());
-  fanout->clear();
-  fanout->set_new(start(), 0);
-  for (SparseArray<int>::iterator i = fanout->begin(); i != fanout->end(); ++i) {
-    int* count = &i->value();
-    reachable.clear();
-    reachable.insert(i->index());
-    for (SparseSet::iterator j = reachable.begin(); j != reachable.end(); ++j) {
-      int id = *j;
-      Prog::Inst* ip = inst(id);
-      switch (ip->opcode()) {
-        default:
-          LOG(DFATAL) << "unhandled " << ip->opcode() << " in Prog::Fanout()";
-          break;
-
-        case kInstByteRange:
-          if (!ip->last())
-            reachable.insert(id+1);
-
-          (*count)++;
-          if (!fanout->has_index(ip->out())) {
-            fanout->set_new(ip->out(), 0);
-          }
-          break;
-
-        case kInstAltMatch:
-          DCHECK(!ip->last());
-          reachable.insert(id+1);
-          break;
-
-        case kInstCapture:
-        case kInstEmptyWidth:
-        case kInstNop:
-          if (!ip->last())
-            reachable.insert(id+1);
-
-          reachable.insert(ip->out());
-          break;
-
-        case kInstMatch:
-          if (!ip->last())
-            reachable.insert(id+1);
-          break;
-
-        case kInstFail:
-          break;
-      }
-    }
-  }
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/onepass.cc b/src/duckdb/third_party/re2/re2/onepass.cc
deleted file mode 100644
index f2a620e28..000000000
--- a/src/duckdb/third_party/re2/re2/onepass.cc
+++ /dev/null
@@ -1,577 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tested by search_test.cc.
-//
-// Prog::SearchOnePass is an efficient implementation of
-// regular expression search with submatch tracking for
-// what I call "one-pass regular expressions".  (An alternate
-// name might be "backtracking-free regular expressions".)
-//
-// One-pass regular expressions have the property that
-// at each input byte during an anchored match, there may be
-// multiple alternatives but only one can proceed for any
-// given input byte.
-//
-// For example, the regexp /x*yx*/ is one-pass: you read
-// x's until a y, then you read the y, then you keep reading x's.
-// At no point do you have to guess what to do or back up
-// and try a different guess.
-//
-// On the other hand, /x*x/ is not one-pass: when you're
-// looking at an input "x", it's not clear whether you should
-// use it to extend the x* or as the final x.
-//
-// More examples: /([^ ]*) (.*)/ is one-pass; /(.*) (.*)/ is not.
-// /(\d+)-(\d+)/ is one-pass; /(\d+).(\d+)/ is not.
-//
-// A simple intuition for identifying one-pass regular expressions
-// is that it's always immediately obvious when a repetition ends.
-// It must also be immediately obvious which branch of an | to take:
-//
-// /x(y|z)/ is one-pass, but /(xy|xz)/ is not.
-//
-// The NFA-based search in nfa.cc does some bookkeeping to
-// avoid the need for backtracking and its associated exponential blowup.
-// But if we have a one-pass regular expression, there is no
-// possibility of backtracking, so there is no need for the
-// extra bookkeeping.  Hence, this code.
-//
-// On a one-pass regular expression, the NFA code in nfa.cc
-// runs at about 1/20 of the backtracking-based PCRE speed.
-// In contrast, the code in this file runs at about the same
-// speed as PCRE.
-//
-// One-pass regular expressions get used a lot when RE is
-// used for parsing simple strings, so it pays off to
-// notice them and handle them efficiently.
-//
-// See also Anne Brüggemann-Klein and Derick Wood,
-// "One-unambiguous regular languages", Information and Computation 142(2).
-
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "util/utf.h"
-#include "re2/pod_array.h"
-#include "re2/prog.h"
-#include "re2/sparse_set.h"
-#include "re2/stringpiece.h"
-
-// Silence "zero-sized array in struct/union" warning for OneState::action.
-#ifdef _MSC_VER
-#pragma warning(disable: 4200)
-#endif
-
-namespace duckdb_re2 {
-
-// The key insight behind this implementation is that the
-// non-determinism in an NFA for a one-pass regular expression
-// is contained.  To explain what that means, first a
-// refresher about what regular expression programs look like
-// and how the usual NFA execution runs.
-//
-// In a regular expression program, only the kInstByteRange
-// instruction processes an input byte c and moves on to the
-// next byte in the string (it does so if c is in the given range).
-// The kInstByteRange instructions correspond to literal characters
-// and character classes in the regular expression.
-//
-// The kInstAlt instructions are used as wiring to connect the
-// kInstByteRange instructions together in interesting ways when
-// implementing | + and *.
-// The kInstAlt instruction forks execution, like a goto that
-// jumps to ip->out() and ip->out1() in parallel.  Each of the
-// resulting computation paths is called a thread.
-//
-// The other instructions -- kInstEmptyWidth, kInstMatch, kInstCapture --
-// are interesting in their own right but like kInstAlt they don't
-// advance the input pointer.  Only kInstByteRange does.
-//
-// The automaton execution in nfa.cc runs all the possible
-// threads of execution in lock-step over the input.  To process
-// a particular byte, each thread gets run until it either dies
-// or finds a kInstByteRange instruction matching the byte.
-// If the latter happens, the thread stops just past the
-// kInstByteRange instruction (at ip->out()) and waits for
-// the other threads to finish processing the input byte.
-// Then, once all the threads have processed that input byte,
-// the whole process repeats.  The kInstAlt state instruction
-// might create new threads during input processing, but no
-// matter what, all the threads stop after a kInstByteRange
-// and wait for the other threads to "catch up".
-// Running in lock step like this ensures that the NFA reads
-// the input string only once.
-//
-// Each thread maintains its own set of capture registers
-// (the string positions at which it executed the kInstCapture
-// instructions corresponding to capturing parentheses in the
-// regular expression).  Repeated copying of the capture registers
-// is the main performance bottleneck in the NFA implementation.
-//
-// A regular expression program is "one-pass" if, no matter what
-// the input string, there is only one thread that makes it
-// past a kInstByteRange instruction at each input byte.  This means
-// that there is in some sense only one active thread throughout
-// the execution.  Other threads might be created during the
-// processing of an input byte, but they are ephemeral: only one
-// thread is left to start processing the next input byte.
-// This is what I meant above when I said the non-determinism
-// was "contained".
-//
-// To execute a one-pass regular expression program, we can build
-// a DFA (no non-determinism) that has at most as many states as
-// the NFA (compare this to the possibly exponential number of states
-// in the general case).  Each state records, for each possible
-// input byte, the next state along with the conditions required
-// before entering that state -- empty-width flags that must be true
-// and capture operations that must be performed.  It also records
-// whether a set of conditions required to finish a match at that
-// point in the input rather than process the next byte.
-
-// A state in the one-pass NFA - just an array of actions indexed
-// by the bytemap_[] of the next input byte.  (The bytemap
-// maps next input bytes into equivalence classes, to reduce
-// the memory footprint.)
-struct OneState {
-  uint32_t matchcond;   // conditions to match right now.
-  uint32_t action[256];
-};
-
-// The uint32_t conditions in the action are a combination of
-// condition and capture bits and the next state.  The bottom 16 bits
-// are the condition and capture bits, and the top 16 are the index of
-// the next state.
-//
-// Bits 0-5 are the empty-width flags from prog.h.
-// Bit 6 is kMatchWins, which means the match takes
-// priority over moving to next in a first-match search.
-// The remaining bits mark capture registers that should
-// be set to the current input position.  The capture bits
-// start at index 2, since the search loop can take care of
-// cap[0], cap[1] (the overall match position).
-// That means we can handle up to 5 capturing parens: $1 through $4, plus $0.
-// No input position can satisfy both kEmptyWordBoundary
-// and kEmptyNonWordBoundary, so we can use that as a sentinel
-// instead of needing an extra bit.
-
-static const int    kIndexShift   = 16;  // number of bits below index
-static const int    kEmptyShift   = 6;   // number of empty flags in prog.h
-static const int    kRealCapShift = kEmptyShift + 1;
-static const int    kRealMaxCap   = (kIndexShift - kRealCapShift) / 2 * 2;
-
-// Parameters used to skip over cap[0], cap[1].
-static const int    kCapShift     = kRealCapShift - 2;
-static const int    kMaxCap       = kRealMaxCap + 2;
-
-static const uint32_t kMatchWins  = 1 << kEmptyShift;
-static const uint32_t kCapMask    = ((1 << kRealMaxCap) - 1) << kRealCapShift;
-
-static const uint32_t kImpossible = kEmptyWordBoundary | kEmptyNonWordBoundary;
-
-// Check, at compile time, that prog.h agrees with math above.
-// This function is never called.
-void OnePass_Checks() {
-  static_assert((1<<kEmptyShift)-1 == kEmptyAllFlags,
-                "kEmptyShift disagrees with kEmptyAllFlags");
-  // kMaxCap counts pointers, kMaxOnePassCapture counts pairs.
-  static_assert(kMaxCap == Prog::kMaxOnePassCapture*2,
-                "kMaxCap disagrees with kMaxOnePassCapture");
-}
-
-static bool Satisfy(uint32_t cond, const StringPiece& context, const char* p) {
-  uint32_t satisfied = Prog::EmptyFlags(context, p);
-  if (cond & kEmptyAllFlags & ~satisfied)
-    return false;
-  return true;
-}
-
-// Apply the capture bits in cond, saving p to the appropriate
-// locations in cap[].
-static void ApplyCaptures(uint32_t cond, const char* p,
-                          const char** cap, int ncap) {
-  for (int i = 2; i < ncap; i++)
-    if (cond & (1 << kCapShift << i))
-      cap[i] = p;
-}
-
-// Computes the OneState* for the given nodeindex.
-static inline OneState* IndexToNode(uint8_t* nodes, int statesize,
-                                    int nodeindex) {
-  return reinterpret_cast<OneState*>(nodes + statesize*nodeindex);
-}
-
-bool Prog::SearchOnePass(const StringPiece& text,
-                         const StringPiece& const_context,
-                         Anchor anchor, MatchKind kind,
-                         StringPiece* match, int nmatch) {
-  if (anchor != kAnchored && kind != kFullMatch) {
-    LOG(DFATAL) << "Cannot use SearchOnePass for unanchored matches.";
-    return false;
-  }
-
-  // Make sure we have at least cap[1],
-  // because we use it to tell if we matched.
-  int ncap = 2*nmatch;
-  if (ncap < 2)
-    ncap = 2;
-
-  const char* cap[kMaxCap];
-  for (int i = 0; i < ncap; i++)
-    cap[i] = NULL;
-
-  const char* matchcap[kMaxCap];
-  for (int i = 0; i < ncap; i++)
-    matchcap[i] = NULL;
-
-  StringPiece context = const_context;
-  if (context.data() == NULL)
-    context = text;
-  if (anchor_start() && BeginPtr(context) != BeginPtr(text))
-    return false;
-  if (anchor_end() && EndPtr(context) != EndPtr(text))
-    return false;
-  if (anchor_end())
-    kind = kFullMatch;
-
-  uint8_t* nodes = onepass_nodes_.data();
-  int statesize = sizeof(uint32_t) + bytemap_range()*sizeof(uint32_t);
-
-  // start() is always mapped to the zeroth OneState.
-  OneState* state = IndexToNode(nodes, statesize, 0);
-  uint8_t* bytemap = bytemap_;
-  const char* bp = text.data();
-  const char* ep = text.data() + text.size();
-  const char* p;
-  bool matched = false;
-  matchcap[0] = bp;
-  cap[0] = bp;
-  uint32_t nextmatchcond = state->matchcond;
-  for (p = bp; p < ep; p++) {
-    int c = bytemap[*p & 0xFF];
-    uint32_t matchcond = nextmatchcond;
-    uint32_t cond = state->action[c];
-
-    // Determine whether we can reach act->next.
-    // If so, advance state and nextmatchcond.
-    if ((cond & kEmptyAllFlags) == 0 || Satisfy(cond, context, p)) {
-      uint32_t nextindex = cond >> kIndexShift;
-      state = IndexToNode(nodes, statesize, nextindex);
-      nextmatchcond = state->matchcond;
-    } else {
-      state = NULL;
-      nextmatchcond = kImpossible;
-    }
-
-    // This code section is carefully tuned.
-    // The goto sequence is about 10% faster than the
-    // obvious rewrite as a large if statement in the
-    // ASCIIMatchRE2 and DotMatchRE2 benchmarks.
-
-    // Saving the match capture registers is expensive.
-    // Is this intermediate match worth thinking about?
-
-    // Not if we want a full match.
-    if (kind == kFullMatch)
-      goto skipmatch;
-
-    // Not if it's impossible.
-    if (matchcond == kImpossible)
-      goto skipmatch;
-
-    // Not if the possible match is beaten by the certain
-    // match at the next byte.  When this test is useless
-    // (e.g., HTTPPartialMatchRE2) it slows the loop by
-    // about 10%, but when it avoids work (e.g., DotMatchRE2),
-    // it cuts the loop execution by about 45%.
-    if ((cond & kMatchWins) == 0 && (nextmatchcond & kEmptyAllFlags) == 0)
-      goto skipmatch;
-
-    // Finally, the match conditions must be satisfied.
-    if ((matchcond & kEmptyAllFlags) == 0 || Satisfy(matchcond, context, p)) {
-      for (int i = 2; i < 2*nmatch; i++)
-        matchcap[i] = cap[i];
-      if (nmatch > 1 && (matchcond & kCapMask))
-        ApplyCaptures(matchcond, p, matchcap, ncap);
-      matchcap[1] = p;
-      matched = true;
-
-      // If we're in longest match mode, we have to keep
-      // going and see if we find a longer match.
-      // In first match mode, we can stop if the match
-      // takes priority over the next state for this input byte.
-      // That bit is per-input byte and thus in cond, not matchcond.
-      if (kind == kFirstMatch && (cond & kMatchWins))
-        goto done;
-    }
-
-  skipmatch:
-    if (state == NULL)
-      goto done;
-    if ((cond & kCapMask) && nmatch > 1)
-      ApplyCaptures(cond, p, cap, ncap);
-  }
-
-  // Look for match at end of input.
-  {
-    uint32_t matchcond = state->matchcond;
-    if (matchcond != kImpossible &&
-        ((matchcond & kEmptyAllFlags) == 0 || Satisfy(matchcond, context, p))) {
-      if (nmatch > 1 && (matchcond & kCapMask))
-        ApplyCaptures(matchcond, p, cap, ncap);
-      for (int i = 2; i < ncap; i++)
-        matchcap[i] = cap[i];
-      matchcap[1] = p;
-      matched = true;
-    }
-  }
-
-done:
-  if (!matched)
-    return false;
-  for (int i = 0; i < nmatch; i++)
-    match[i] =
-        StringPiece(matchcap[2 * i],
-                    static_cast<size_t>(matchcap[2 * i + 1] - matchcap[2 * i]));
-  return true;
-}
-
-
-// Analysis to determine whether a given regexp program is one-pass.
-
-// If ip is not on workq, adds ip to work queue and returns true.
-// If ip is already on work queue, does nothing and returns false.
-// If ip is NULL, does nothing and returns true (pretends to add it).
-typedef SparseSet Instq;
-static bool AddQ(Instq *q, int id) {
-  if (id == 0)
-    return true;
-  if (q->contains(id))
-    return false;
-  q->insert(id);
-  return true;
-}
-
-struct InstCond {
-  int id;
-  uint32_t cond;
-};
-
-// Returns whether this is a one-pass program; that is,
-// returns whether it is safe to use SearchOnePass on this program.
-// These conditions must be true for any instruction ip:
-//
-//   (1) for any other Inst nip, there is at most one input-free
-//       path from ip to nip.
-//   (2) there is at most one kInstByte instruction reachable from
-//       ip that matches any particular byte c.
-//   (3) there is at most one input-free path from ip to a kInstMatch
-//       instruction.
-//
-// This is actually just a conservative approximation: it might
-// return false when the answer is true, when kInstEmptyWidth
-// instructions are involved.
-// Constructs and saves corresponding one-pass NFA on success.
-bool Prog::IsOnePass() {
-  if (did_onepass_)
-    return onepass_nodes_.data() != NULL;
-  did_onepass_ = true;
-
-  if (start() == 0)  // no match
-    return false;
-
-  // Steal memory for the one-pass NFA from the overall DFA budget.
-  // Willing to use at most 1/4 of the DFA budget (heuristic).
-  // Limit max node count to 65000 as a conservative estimate to
-  // avoid overflowing 16-bit node index in encoding.
-  int maxnodes = 2 + inst_count(kInstByteRange);
-  int statesize = sizeof(uint32_t) + bytemap_range()*sizeof(uint32_t);
-  if (maxnodes >= 65000 || dfa_mem_ / 4 / statesize < maxnodes)
-    return false;
-
-  // Flood the graph starting at the start state, and check
-  // that in each reachable state, each possible byte leads
-  // to a unique next state.
-  int stacksize = inst_count(kInstCapture) +
-                  inst_count(kInstEmptyWidth) +
-                  inst_count(kInstNop) + 1;  // + 1 for start inst
-  PODArray<InstCond> stack(stacksize);
-
-  int size = this->size();
-  PODArray<int> nodebyid(size);  // indexed by ip
-  memset(nodebyid.data(), 0xFF, size*sizeof nodebyid[0]);
-
-  // Originally, nodes was a uint8_t[maxnodes*statesize], but that was
-  // unnecessarily optimistic: why allocate a large amount of memory
-  // upfront for a large program when it is unlikely to be one-pass?
-  std::vector<uint8_t> nodes;
-
-  Instq tovisit(size), workq(size);
-  AddQ(&tovisit, start());
-  nodebyid[start()] = 0;
-  int nalloc = 1;
-  nodes.insert(nodes.end(), statesize, 0);
-  for (Instq::iterator it = tovisit.begin(); it != tovisit.end(); ++it) {
-    int id = *it;
-    int nodeindex = nodebyid[id];
-    OneState* node = IndexToNode(nodes.data(), statesize, nodeindex);
-
-    // Flood graph using manual stack, filling in actions as found.
-    // Default is none.
-    for (int b = 0; b < bytemap_range_; b++)
-      node->action[b] = kImpossible;
-    node->matchcond = kImpossible;
-
-    workq.clear();
-    bool matched = false;
-    int nstack = 0;
-    stack[nstack].id = id;
-    stack[nstack++].cond = 0;
-    while (nstack > 0) {
-      int id = stack[--nstack].id;
-      uint32_t cond = stack[nstack].cond;
-
-    Loop:
-      Prog::Inst* ip = inst(id);
-      switch (ip->opcode()) {
-        default:
-          LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-          break;
-
-        case kInstAltMatch:
-          // TODO(rsc): Ignoring kInstAltMatch optimization.
-          // Should implement it in this engine, but it's subtle.
-          DCHECK(!ip->last());
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, id+1))
-            goto fail;
-          id = id+1;
-          goto Loop;
-
-        case kInstByteRange: {
-          int nextindex = nodebyid[ip->out()];
-          if (nextindex == -1) {
-            if (nalloc >= maxnodes) {
-              goto fail;
-            }
-            nextindex = nalloc;
-            AddQ(&tovisit, ip->out());
-            nodebyid[ip->out()] = nalloc;
-            nalloc++;
-            nodes.insert(nodes.end(), statesize, 0);
-            // Update node because it might have been invalidated.
-            node = IndexToNode(nodes.data(), statesize, nodeindex);
-          }
-          for (int c = ip->lo(); c <= ip->hi(); c++) {
-            int b = bytemap_[c];
-            // Skip any bytes immediately after c that are also in b.
-            while (c < 256-1 && bytemap_[c+1] == b)
-              c++;
-            uint32_t act = node->action[b];
-            uint32_t newact = (nextindex << kIndexShift) | cond;
-            if (matched)
-              newact |= kMatchWins;
-            if ((act & kImpossible) == kImpossible) {
-              node->action[b] = newact;
-            } else if (act != newact) {
-              goto fail;
-            }
-          }
-          if (ip->foldcase()) {
-            Rune lo = std::max<Rune>(ip->lo(), 'a') + 'A' - 'a';
-            Rune hi = std::min<Rune>(ip->hi(), 'z') + 'A' - 'a';
-            for (int c = lo; c <= hi; c++) {
-              int b = bytemap_[c];
-              // Skip any bytes immediately after c that are also in b.
-              while (c < 256-1 && bytemap_[c+1] == b)
-                c++;
-              uint32_t act = node->action[b];
-              uint32_t newact = (nextindex << kIndexShift) | cond;
-              if (matched)
-                newact |= kMatchWins;
-              if ((act & kImpossible) == kImpossible) {
-                node->action[b] = newact;
-              } else if (act != newact) {
-                goto fail;
-              }
-            }
-          }
-
-          if (ip->last())
-            break;
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, id+1))
-            goto fail;
-          id = id+1;
-          goto Loop;
-        }
-
-        case kInstCapture:
-        case kInstEmptyWidth:
-        case kInstNop:
-          if (!ip->last()) {
-            // If already on work queue, (1) is violated: bail out.
-            if (!AddQ(&workq, id+1))
-              goto fail;
-            stack[nstack].id = id+1;
-            stack[nstack++].cond = cond;
-          }
-
-          if (ip->opcode() == kInstCapture && ip->cap() < kMaxCap)
-            cond |= (1 << kCapShift) << ip->cap();
-          if (ip->opcode() == kInstEmptyWidth)
-            cond |= ip->empty();
-
-          // kInstCapture and kInstNop always proceed to ip->out().
-          // kInstEmptyWidth only sometimes proceeds to ip->out(),
-          // but as a conservative approximation we assume it always does.
-          // We could be a little more precise by looking at what c
-          // is, but that seems like overkill.
-
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, ip->out())) {
-            goto fail;
-          }
-          id = ip->out();
-          goto Loop;
-
-        case kInstMatch:
-          if (matched) {
-            // (3) is violated
-            goto fail;
-          }
-          matched = true;
-          node->matchcond = cond;
-
-          if (ip->last())
-            break;
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, id+1))
-            goto fail;
-          id = id+1;
-          goto Loop;
-
-        case kInstFail:
-          break;
-      }
-    }
-  }
-
-  dfa_mem_ -= nalloc*statesize;
-  onepass_nodes_ = PODArray<uint8_t>(nalloc*statesize);
-  memmove(onepass_nodes_.data(), nodes.data(), nalloc*statesize);
-  return true;
-
-fail:
-  return false;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/parse.cc b/src/duckdb/third_party/re2/re2/parse.cc
deleted file mode 100644
index 5b4ae3dbf..000000000
--- a/src/duckdb/third_party/re2/re2/parse.cc
+++ /dev/null
@@ -1,2481 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Regular expression parser.
-
-// The parser is a simple precedence-based parser with a
-// manual stack.  The parsing work is done by the methods
-// of the ParseState class.  The Regexp::Parse function is
-// essentially just a lexer that calls the ParseState method
-// for each token.
-
-// The parser recognizes POSIX extended regular expressions
-// excluding backreferences, collating elements, and collating
-// classes.  It also allows the empty string as a regular expression
-// and recognizes the Perl escape sequences \d, \s, \w, \D, \S, and \W.
-// See regexp.h for rationale.
-
-#include <ctype.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "util/utf.h"
-#include "re2/pod_array.h"
-#include "re2/regexp.h"
-#include "re2/stringpiece.h"
-#include "re2/unicode_casefold.h"
-#include "re2/unicode_groups.h"
-#include "re2/walker-inl.h"
-
-#if defined(RE2_USE_ICU)
-//#include "unicode/uniset.h"
-//#include "unicode/unistr.h"
-//#include "unicode/utypes.h"
-#endif
-
-namespace duckdb_re2 {
-
-// Controls the maximum repeat count permitted by the parser.
-static int maximum_repeat_count = 1000;
-
-void Regexp::FUZZING_ONLY_set_maximum_repeat_count(int i) {
-  maximum_repeat_count = i;
-}
-
-// Regular expression parse state.
-// The list of parsed regexps so far is maintained as a vector of
-// Regexp pointers called the stack.  Left parenthesis and vertical
-// bar markers are also placed on the stack, as Regexps with
-// non-standard opcodes.
-// Scanning a left parenthesis causes the parser to push a left parenthesis
-// marker on the stack.
-// Scanning a vertical bar causes the parser to pop the stack until it finds a
-// vertical bar or left parenthesis marker (not popping the marker),
-// concatenate all the popped results, and push them back on
-// the stack (DoConcatenation).
-// Scanning a right parenthesis causes the parser to act as though it
-// has seen a vertical bar, which then leaves the top of the stack in the
-// form LeftParen regexp VerticalBar regexp VerticalBar ... regexp VerticalBar.
-// The parser pops all this off the stack and creates an alternation of the
-// regexps (DoAlternation).
-
-class Regexp::ParseState {
- public:
-  ParseState(ParseFlags flags, const StringPiece& whole_regexp,
-             RegexpStatus* status);
-  ~ParseState();
-
-  ParseFlags flags() { return flags_; }
-  int rune_max() { return rune_max_; }
-
-  // Parse methods.  All public methods return a bool saying
-  // whether parsing should continue.  If a method returns
-  // false, it has set fields in *status_, and the parser
-  // should return NULL.
-
-  // Pushes the given regular expression onto the stack.
-  // Could check for too much memory used here.
-  bool PushRegexp(Regexp* re);
-
-  // Pushes the literal rune r onto the stack.
-  bool PushLiteral(Rune r);
-
-  // Pushes a regexp with the given op (and no args) onto the stack.
-  bool PushSimpleOp(RegexpOp op);
-
-  // Pushes a ^ onto the stack.
-  bool PushCaret();
-
-  // Pushes a \b (word == true) or \B (word == false) onto the stack.
-  bool PushWordBoundary(bool word);
-
-  // Pushes a $ onto the stack.
-  bool PushDollar();
-
-  // Pushes a . onto the stack
-  bool PushDot();
-
-  // Pushes a repeat operator regexp onto the stack.
-  // A valid argument for the operator must already be on the stack.
-  // s is the name of the operator, for use in error messages.
-  bool PushRepeatOp(RegexpOp op, const StringPiece& s, bool nongreedy);
-
-  // Pushes a repetition regexp onto the stack.
-  // A valid argument for the operator must already be on the stack.
-  bool PushRepetition(int min, int max, const StringPiece& s, bool nongreedy);
-
-  // Checks whether a particular regexp op is a marker.
-  bool IsMarker(RegexpOp op);
-
-  // Processes a left parenthesis in the input.
-  // Pushes a marker onto the stack.
-  bool DoLeftParen(const StringPiece& name);
-  bool DoLeftParenNoCapture();
-
-  // Processes a vertical bar in the input.
-  bool DoVerticalBar();
-
-  // Processes a right parenthesis in the input.
-  bool DoRightParen();
-
-  // Processes the end of input, returning the final regexp.
-  Regexp* DoFinish();
-
-  // Finishes the regexp if necessary, preparing it for use
-  // in a more complicated expression.
-  // If it is a CharClassBuilder, converts into a CharClass.
-  Regexp* FinishRegexp(Regexp*);
-
-  // These routines don't manipulate the parse stack
-  // directly, but they do need to look at flags_.
-  // ParseCharClass also manipulates the internals of Regexp
-  // while creating *out_re.
-
-  // Parse a character class into *out_re.
-  // Removes parsed text from s.
-  bool ParseCharClass(StringPiece* s, Regexp** out_re,
-                      RegexpStatus* status);
-
-  // Parse a character class character into *rp.
-  // Removes parsed text from s.
-  bool ParseCCCharacter(StringPiece* s, Rune *rp,
-                        const StringPiece& whole_class,
-                        RegexpStatus* status);
-
-  // Parse a character class range into rr.
-  // Removes parsed text from s.
-  bool ParseCCRange(StringPiece* s, RuneRange* rr,
-                    const StringPiece& whole_class,
-                    RegexpStatus* status);
-
-  // Parse a Perl flag set or non-capturing group from s.
-  bool ParsePerlFlags(StringPiece* s);
-
-
-  // Finishes the current concatenation,
-  // collapsing it into a single regexp on the stack.
-  void DoConcatenation();
-
-  // Finishes the current alternation,
-  // collapsing it to a single regexp on the stack.
-  void DoAlternation();
-
-  // Generalized DoAlternation/DoConcatenation.
-  void DoCollapse(RegexpOp op);
-
-  // Maybe concatenate Literals into LiteralString.
-  bool MaybeConcatString(int r, ParseFlags flags);
-
-private:
-  ParseFlags flags_;
-  StringPiece whole_regexp_;
-  RegexpStatus* status_;
-  Regexp* stacktop_;
-  int ncap_;  // number of capturing parens seen
-  int rune_max_;  // maximum char value for this encoding
-
-  ParseState(const ParseState&) = delete;
-  ParseState& operator=(const ParseState&) = delete;
-};
-
-// Pseudo-operators - only on parse stack.
-const RegexpOp kLeftParen = static_cast<RegexpOp>(kMaxRegexpOp+1);
-const RegexpOp kVerticalBar = static_cast<RegexpOp>(kMaxRegexpOp+2);
-
-Regexp::ParseState::ParseState(ParseFlags flags,
-                               const StringPiece& whole_regexp,
-                               RegexpStatus* status)
-  : flags_(flags), whole_regexp_(whole_regexp),
-    status_(status), stacktop_(NULL), ncap_(0) {
-  if (flags_ & Latin1)
-    rune_max_ = 0xFF;
-  else
-    rune_max_ = Runemax;
-}
-
-// Cleans up by freeing all the regexps on the stack.
-Regexp::ParseState::~ParseState() {
-  Regexp* next;
-  for (Regexp* re = stacktop_; re != NULL; re = next) {
-    next = re->down_;
-    re->down_ = NULL;
-    if (re->op() == kLeftParen)
-      delete re->arguments.capture.name_;
-    re->Decref();
-  }
-}
-
-// Finishes the regexp if necessary, preparing it for use in
-// a more complex expression.
-// If it is a CharClassBuilder, converts into a CharClass.
-Regexp* Regexp::ParseState::FinishRegexp(Regexp* re) {
-  if (re == NULL)
-    return NULL;
-  re->down_ = NULL;
-
-  if (re->op_ == kRegexpCharClass && re->arguments.char_class.ccb_ != NULL) {
-    CharClassBuilder* ccb = re->arguments.char_class.ccb_;
-    re->arguments.char_class.ccb_ = NULL;
-    re->arguments.char_class.cc_ = ccb->GetCharClass();
-    delete ccb;
-  }
-
-  return re;
-}
-
-// Pushes the given regular expression onto the stack.
-// Could check for too much memory used here.
-bool Regexp::ParseState::PushRegexp(Regexp* re) {
-  MaybeConcatString(-1, NoParseFlags);
-
-  // Special case: a character class of one character is just
-  // a literal.  This is a common idiom for escaping
-  // single characters (e.g., [.] instead of \.), and some
-  // analysis does better with fewer character classes.
-  // Similarly, [Aa] can be rewritten as a literal A with ASCII case folding.
-  if (re->op_ == kRegexpCharClass && re->arguments.char_class.ccb_ != NULL) {
-    re->arguments.char_class.ccb_->RemoveAbove(rune_max_);
-    if (re->arguments.char_class.ccb_->size() == 1) {
-      Rune r = re->arguments.char_class.ccb_->begin()->lo;
-      re->Decref();
-      re = new Regexp(kRegexpLiteral, flags_);
-      re->arguments.rune_ = r;
-    } else if (re->arguments.char_class.ccb_->size() == 2) {
-      Rune r = re->arguments.char_class.ccb_->begin()->lo;
-      if ('A' <= r && r <= 'Z' && re->arguments.char_class.ccb_->Contains(r + 'a' - 'A')) {
-        re->Decref();
-        re = new Regexp(kRegexpLiteral, flags_ | FoldCase);
-        re->arguments.rune_ = r + 'a' - 'A';
-      }
-    }
-  }
-
-  if (!IsMarker(re->op()))
-    re->simple_ = re->ComputeSimple();
-  re->down_ = stacktop_;
-  stacktop_ = re;
-  return true;
-}
-
-// Searches the case folding tables and returns the CaseFold* that contains r.
-// If there isn't one, returns the CaseFold* with smallest f->lo bigger than r.
-// If there isn't one, returns NULL.
-const CaseFold* LookupCaseFold(const CaseFold *f, int n, Rune r) {
-  const CaseFold* ef = f + n;
-
-  // Binary search for entry containing r.
-  while (n > 0) {
-    int m = n/2;
-    if (f[m].lo <= r && r <= f[m].hi)
-      return &f[m];
-    if (r < f[m].lo) {
-      n = m;
-    } else {
-      f += m+1;
-      n -= m+1;
-    }
-  }
-
-  // There is no entry that contains r, but f points
-  // where it would have been.  Unless f points at
-  // the end of the array, it points at the next entry
-  // after r.
-  if (f < ef)
-    return f;
-
-  // No entry contains r; no entry contains runes > r.
-  return NULL;
-}
-
-// Returns the result of applying the fold f to the rune r.
-Rune ApplyFold(const CaseFold *f, Rune r) {
-  switch (f->delta) {
-    default:
-      return r + f->delta;
-
-    case EvenOddSkip:  // even <-> odd but only applies to every other
-      if ((r - f->lo) % 2)
-        return r;
-      FALLTHROUGH_INTENDED;
-    case EvenOdd:  // even <-> odd
-      if (r%2 == 0)
-        return r + 1;
-      return r - 1;
-
-    case OddEvenSkip:  // odd <-> even but only applies to every other
-      if ((r - f->lo) % 2)
-        return r;
-      FALLTHROUGH_INTENDED;
-    case OddEven:  // odd <-> even
-      if (r%2 == 1)
-        return r + 1;
-      return r - 1;
-  }
-}
-
-// Returns the next Rune in r's folding cycle (see unicode_casefold.h).
-// Examples:
-//   CycleFoldRune('A') = 'a'
-//   CycleFoldRune('a') = 'A'
-//
-//   CycleFoldRune('K') = 'k'
-//   CycleFoldRune('k') = 0x212A (Kelvin)
-//   CycleFoldRune(0x212A) = 'K'
-//
-//   CycleFoldRune('?') = '?'
-Rune CycleFoldRune(Rune r) {
-  const CaseFold* f = LookupCaseFold(unicode_casefold, num_unicode_casefold, r);
-  if (f == NULL || r < f->lo)
-    return r;
-  return ApplyFold(f, r);
-}
-
-// Add lo-hi to the class, along with their fold-equivalent characters.
-// If lo-hi is already in the class, assume that the fold-equivalent
-// chars are there too, so there's no work to do.
-static void AddFoldedRange(CharClassBuilder* cc, Rune lo, Rune hi, int depth) {
-  // AddFoldedRange calls itself recursively for each rune in the fold cycle.
-  // Most folding cycles are small: there aren't any bigger than four in the
-  // current Unicode tables.  make_unicode_casefold.py checks that
-  // the cycles are not too long, and we double-check here using depth.
-  if (depth > 10) {
-    LOG(DFATAL) << "AddFoldedRange recurses too much.";
-    return;
-  }
-
-  if (!cc->AddRange(lo, hi))  // lo-hi was already there? we're done
-    return;
-
-  while (lo <= hi) {
-    const CaseFold* f = LookupCaseFold(unicode_casefold, num_unicode_casefold, lo);
-    if (f == NULL)  // lo has no fold, nor does anything above lo
-      break;
-    if (lo < f->lo) {  // lo has no fold; next rune with a fold is f->lo
-      lo = f->lo;
-      continue;
-    }
-
-    // Add in the result of folding the range lo - f->hi
-    // and that range's fold, recursively.
-    Rune lo1 = lo;
-    Rune hi1 = std::min<Rune>(hi, f->hi);
-    switch (f->delta) {
-      default:
-        lo1 += f->delta;
-        hi1 += f->delta;
-        break;
-      case EvenOdd:
-        if (lo1%2 == 1)
-          lo1--;
-        if (hi1%2 == 0)
-          hi1++;
-        break;
-      case OddEven:
-        if (lo1%2 == 0)
-          lo1--;
-        if (hi1%2 == 1)
-          hi1++;
-        break;
-    }
-    AddFoldedRange(cc, lo1, hi1, depth+1);
-
-    // Pick up where this fold left off.
-    lo = f->hi + 1;
-  }
-}
-
-// Pushes the literal rune r onto the stack.
-bool Regexp::ParseState::PushLiteral(Rune r) {
-  // Do case folding if needed.
-  if ((flags_ & FoldCase) && CycleFoldRune(r) != r) {
-    Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-    re->arguments.char_class.ccb_ = new CharClassBuilder;
-    Rune r1 = r;
-    do {
-      if (!(flags_ & NeverNL) || r != '\n') {
-        re->arguments.char_class.ccb_->AddRange(r, r);
-      }
-      r = CycleFoldRune(r);
-    } while (r != r1);
-    return PushRegexp(re);
-  }
-
-  // Exclude newline if applicable.
-  if ((flags_ & NeverNL) && r == '\n')
-    return PushRegexp(new Regexp(kRegexpNoMatch, flags_));
-
-  // No fancy stuff worked.  Ordinary literal.
-  if (MaybeConcatString(r, flags_))
-    return true;
-
-  Regexp* re = new Regexp(kRegexpLiteral, flags_);
-  re->arguments.rune_ = r;
-  return PushRegexp(re);
-}
-
-// Pushes a ^ onto the stack.
-bool Regexp::ParseState::PushCaret() {
-  if (flags_ & OneLine) {
-    return PushSimpleOp(kRegexpBeginText);
-  }
-  return PushSimpleOp(kRegexpBeginLine);
-}
-
-// Pushes a \b or \B onto the stack.
-bool Regexp::ParseState::PushWordBoundary(bool word) {
-  if (word)
-    return PushSimpleOp(kRegexpWordBoundary);
-  return PushSimpleOp(kRegexpNoWordBoundary);
-}
-
-// Pushes a $ onto the stack.
-bool Regexp::ParseState::PushDollar() {
-  if (flags_ & OneLine) {
-    // Clumsy marker so that MimicsPCRE() can tell whether
-    // this kRegexpEndText was a $ and not a \z.
-    Regexp::ParseFlags oflags = flags_;
-    flags_ = flags_ | WasDollar;
-    bool ret = PushSimpleOp(kRegexpEndText);
-    flags_ = oflags;
-    return ret;
-  }
-  return PushSimpleOp(kRegexpEndLine);
-}
-
-// Pushes a . onto the stack.
-bool Regexp::ParseState::PushDot() {
-  if ((flags_ & DotNL) && !(flags_ & NeverNL))
-    return PushSimpleOp(kRegexpAnyChar);
-  // Rewrite . into [^\n]
-  Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-  re->arguments.char_class.ccb_ = new CharClassBuilder;
-  re->arguments.char_class.ccb_->AddRange(0, '\n' - 1);
-  re->arguments.char_class.ccb_->AddRange('\n' + 1, rune_max_);
-  return PushRegexp(re);
-}
-
-// Pushes a regexp with the given op (and no args) onto the stack.
-bool Regexp::ParseState::PushSimpleOp(RegexpOp op) {
-  Regexp* re = new Regexp(op, flags_);
-  return PushRegexp(re);
-}
-
-// Pushes a repeat operator regexp onto the stack.
-// A valid argument for the operator must already be on the stack.
-// The char c is the name of the operator, for use in error messages.
-bool Regexp::ParseState::PushRepeatOp(RegexpOp op, const StringPiece& s,
-                                      bool nongreedy) {
-  if (stacktop_ == NULL || IsMarker(stacktop_->op())) {
-    status_->set_code(kRegexpRepeatArgument);
-    status_->set_error_arg(s);
-    return false;
-  }
-  Regexp::ParseFlags fl = flags_;
-  if (nongreedy)
-    fl = fl ^ NonGreedy;
-
-  // Squash **, ++ and ??. Regexp::Star() et al. handle this too, but
-  // they're mostly for use during simplification, not during parsing.
-  if (op == stacktop_->op() && fl == stacktop_->parse_flags())
-    return true;
-
-  // Squash *+, *?, +*, +?, ?* and ?+. They all squash to *, so because
-  // op is a repeat, we just have to check that stacktop_->op() is too,
-  // then adjust stacktop_.
-  if ((stacktop_->op() == kRegexpStar ||
-       stacktop_->op() == kRegexpPlus ||
-       stacktop_->op() == kRegexpQuest) &&
-      fl == stacktop_->parse_flags()) {
-    stacktop_->op_ = kRegexpStar;
-    return true;
-  }
-
-  Regexp* re = new Regexp(op, fl);
-  re->AllocSub(1);
-  re->down_ = stacktop_->down_;
-  re->sub()[0] = FinishRegexp(stacktop_);
-  re->simple_ = re->ComputeSimple();
-  stacktop_ = re;
-  return true;
-}
-
-// RepetitionWalker reports whether the repetition regexp is valid.
-// Valid means that the combination of the top-level repetition
-// and any inner repetitions does not exceed n copies of the
-// innermost thing.
-// This rewalks the regexp tree and is called for every repetition,
-// so we have to worry about inducing quadratic behavior in the parser.
-// We avoid this by only using RepetitionWalker when min or max >= 2.
-// In that case the depth of any >= 2 nesting can only get to 9 without
-// triggering a parse error, so each subtree can only be rewalked 9 times.
-class RepetitionWalker : public Regexp::Walker<int> {
- public:
-  RepetitionWalker() {}
-  virtual int PreVisit(Regexp* re, int parent_arg, bool* stop);
-  virtual int PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                        int* child_args, int nchild_args);
-  virtual int ShortVisit(Regexp* re, int parent_arg);
-
- private:
-  RepetitionWalker(const RepetitionWalker&) = delete;
-  RepetitionWalker& operator=(const RepetitionWalker&) = delete;
-};
-
-int RepetitionWalker::PreVisit(Regexp* re, int parent_arg, bool* stop) {
-  int arg = parent_arg;
-  if (re->op() == kRegexpRepeat) {
-    int m = re->max();
-    if (m < 0) {
-      m = re->min();
-    }
-    if (m > 0) {
-      arg /= m;
-    }
-  }
-  return arg;
-}
-
-int RepetitionWalker::PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                                int* child_args, int nchild_args) {
-  int arg = pre_arg;
-  for (int i = 0; i < nchild_args; i++) {
-    if (child_args[i] < arg) {
-      arg = child_args[i];
-    }
-  }
-  return arg;
-}
-
-int RepetitionWalker::ShortVisit(Regexp* re, int parent_arg) {
-  // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  LOG(DFATAL) << "RepetitionWalker::ShortVisit called";
-#endif
-  return 0;
-}
-
-// Pushes a repetition regexp onto the stack.
-// A valid argument for the operator must already be on the stack.
-bool Regexp::ParseState::PushRepetition(int min, int max,
-                                        const StringPiece& s,
-                                        bool nongreedy) {
-  if ((max != -1 && max < min) ||
-      min > maximum_repeat_count ||
-      max > maximum_repeat_count) {
-    status_->set_code(kRegexpRepeatSize);
-    status_->set_error_arg(s);
-    return false;
-  }
-  if (stacktop_ == NULL || IsMarker(stacktop_->op())) {
-    status_->set_code(kRegexpRepeatArgument);
-    status_->set_error_arg(s);
-    return false;
-  }
-  Regexp::ParseFlags fl = flags_;
-  if (nongreedy)
-    fl = fl ^ NonGreedy;
-  Regexp* re = new Regexp(kRegexpRepeat, fl);
-  re->arguments.repeat.min_ = min;
-  re->arguments.repeat.max_ = max;
-  re->AllocSub(1);
-  re->down_ = stacktop_->down_;
-  re->sub()[0] = FinishRegexp(stacktop_);
-  re->simple_ = re->ComputeSimple();
-  stacktop_ = re;
-  if (min >= 2 || max >= 2) {
-    RepetitionWalker w;
-    if (w.Walk(stacktop_, maximum_repeat_count) == 0) {
-      status_->set_code(kRegexpRepeatSize);
-      status_->set_error_arg(s);
-      return false;
-    }
-  }
-  return true;
-}
-
-// Checks whether a particular regexp op is a marker.
-bool Regexp::ParseState::IsMarker(RegexpOp op) {
-  return op >= kLeftParen;
-}
-
-// Processes a left parenthesis in the input.
-// Pushes a marker onto the stack.
-bool Regexp::ParseState::DoLeftParen(const StringPiece& name) {
-  Regexp* re = new Regexp(kLeftParen, flags_);
-  re->arguments.capture.cap_ = ++ncap_;
-  if (name.data() != NULL)
-    re->arguments.capture.name_ = new std::string(name);
-  return PushRegexp(re);
-}
-
-// Pushes a non-capturing marker onto the stack.
-bool Regexp::ParseState::DoLeftParenNoCapture() {
-  Regexp* re = new Regexp(kLeftParen, flags_);
-  re->arguments.capture.cap_ = -1;
-  return PushRegexp(re);
-}
-
-// Processes a vertical bar in the input.
-bool Regexp::ParseState::DoVerticalBar() {
-  MaybeConcatString(-1, NoParseFlags);
-  DoConcatenation();
-
-  // Below the vertical bar is a list to alternate.
-  // Above the vertical bar is a list to concatenate.
-  // We just did the concatenation, so either swap
-  // the result below the vertical bar or push a new
-  // vertical bar on the stack.
-  Regexp* r1;
-  Regexp* r2;
-  if ((r1 = stacktop_) != NULL &&
-      (r2 = r1->down_) != NULL &&
-      r2->op() == kVerticalBar) {
-    Regexp* r3;
-    if ((r3 = r2->down_) != NULL &&
-        (r1->op() == kRegexpAnyChar || r3->op() == kRegexpAnyChar)) {
-      // AnyChar is above or below the vertical bar. Let it subsume
-      // the other when the other is Literal, CharClass or AnyChar.
-      if (r3->op() == kRegexpAnyChar &&
-          (r1->op() == kRegexpLiteral ||
-           r1->op() == kRegexpCharClass ||
-           r1->op() == kRegexpAnyChar)) {
-        // Discard r1.
-        stacktop_ = r2;
-        r1->Decref();
-        return true;
-      }
-      if (r1->op() == kRegexpAnyChar &&
-          (r3->op() == kRegexpLiteral ||
-           r3->op() == kRegexpCharClass ||
-           r3->op() == kRegexpAnyChar)) {
-        // Rearrange the stack and discard r3.
-        r1->down_ = r3->down_;
-        r2->down_ = r1;
-        stacktop_ = r2;
-        r3->Decref();
-        return true;
-      }
-    }
-    // Swap r1 below vertical bar (r2).
-    r1->down_ = r2->down_;
-    r2->down_ = r1;
-    stacktop_ = r2;
-    return true;
-  }
-  return PushSimpleOp(kVerticalBar);
-}
-
-// Processes a right parenthesis in the input.
-bool Regexp::ParseState::DoRightParen() {
-  // Finish the current concatenation and alternation.
-  DoAlternation();
-
-  // The stack should be: LeftParen regexp
-  // Remove the LeftParen, leaving the regexp,
-  // parenthesized.
-  Regexp* r1;
-  Regexp* r2;
-  if ((r1 = stacktop_) == NULL ||
-      (r2 = r1->down_) == NULL ||
-      r2->op() != kLeftParen) {
-    status_->set_code(kRegexpUnexpectedParen);
-    status_->set_error_arg(whole_regexp_);
-    return false;
-  }
-
-  // Pop off r1, r2.  Will Decref or reuse below.
-  stacktop_ = r2->down_;
-
-  // Restore flags from when paren opened.
-  Regexp* re = r2;
-  flags_ = re->parse_flags();
-
-  // Rewrite LeftParen as capture if needed.
-  if (re->arguments.capture.cap_ > 0) {
-    re->op_ = kRegexpCapture;
-    // re->cap_ is already set
-    re->AllocSub(1);
-    re->sub()[0] = FinishRegexp(r1);
-    re->simple_ = re->ComputeSimple();
-  } else {
-    re->Decref();
-    re = r1;
-  }
-  return PushRegexp(re);
-}
-
-// Processes the end of input, returning the final regexp.
-Regexp* Regexp::ParseState::DoFinish() {
-  DoAlternation();
-  Regexp* re = stacktop_;
-  if (re != NULL && re->down_ != NULL) {
-    status_->set_code(kRegexpMissingParen);
-    status_->set_error_arg(whole_regexp_);
-    return NULL;
-  }
-  stacktop_ = NULL;
-  return FinishRegexp(re);
-}
-
-// Returns the leading regexp that re starts with.
-// The returned Regexp* points into a piece of re,
-// so it must not be used after the caller calls re->Decref().
-Regexp* Regexp::LeadingRegexp(Regexp* re) {
-  if (re->op() == kRegexpEmptyMatch)
-    return NULL;
-  if (re->op() == kRegexpConcat && re->nsub() >= 2) {
-    Regexp** sub = re->sub();
-    if (sub[0]->op() == kRegexpEmptyMatch)
-      return NULL;
-    return sub[0];
-  }
-  return re;
-}
-
-// Removes LeadingRegexp(re) from re and returns what's left.
-// Consumes the reference to re and may edit it in place.
-// If caller wants to hold on to LeadingRegexp(re),
-// must have already Incref'ed it.
-Regexp* Regexp::RemoveLeadingRegexp(Regexp* re) {
-  if (re->op() == kRegexpEmptyMatch)
-    return re;
-  if (re->op() == kRegexpConcat && re->nsub() >= 2) {
-    Regexp** sub = re->sub();
-    if (sub[0]->op() == kRegexpEmptyMatch)
-      return re;
-    sub[0]->Decref();
-    sub[0] = NULL;
-    if (re->nsub() == 2) {
-      // Collapse concatenation to single regexp.
-      Regexp* nre = sub[1];
-      sub[1] = NULL;
-      re->Decref();
-      return nre;
-    }
-    // 3 or more -> 2 or more.
-    re->nsub_--;
-    memmove(sub, sub + 1, re->nsub_ * sizeof sub[0]);
-    return re;
-  }
-  Regexp::ParseFlags pf = re->parse_flags();
-  re->Decref();
-  return new Regexp(kRegexpEmptyMatch, pf);
-}
-
-// Returns the leading string that re starts with.
-// The returned Rune* points into a piece of re,
-// so it must not be used after the caller calls re->Decref().
-Rune* Regexp::LeadingString(Regexp* re, int *nrune,
-                            Regexp::ParseFlags *flags) {
-  while (re->op() == kRegexpConcat && re->nsub() > 0)
-    re = re->sub()[0];
-
-  *flags = static_cast<Regexp::ParseFlags>(re->parse_flags_ & Regexp::FoldCase);
-
-  if (re->op() == kRegexpLiteral) {
-    *nrune = 1;
-    return &re->arguments.rune_;
-  }
-
-  if (re->op() == kRegexpLiteralString) {
-    *nrune = re->arguments.literal_string.nrunes_;
-    return re->arguments.literal_string.runes_;
-  }
-
-  *nrune = 0;
-  return NULL;
-}
-
-// Removes the first n leading runes from the beginning of re.
-// Edits re in place.
-void Regexp::RemoveLeadingString(Regexp* re, int n) {
-  // Chase down concats to find first string.
-  // For regexps generated by parser, nested concats are
-  // flattened except when doing so would overflow the 16-bit
-  // limit on the size of a concatenation, so we should never
-  // see more than two here.
-  Regexp* stk[4];
-  size_t d = 0;
-  while (re->op() == kRegexpConcat) {
-    if (d < arraysize(stk))
-      stk[d++] = re;
-    re = re->sub()[0];
-  }
-
-  // Remove leading string from re.
-  if (re->op() == kRegexpLiteral) {
-    re->arguments.rune_ = 0;
-    re->op_ = kRegexpEmptyMatch;
-  } else if (re->op() == kRegexpLiteralString) {
-    if (n >= re->arguments.literal_string.nrunes_) {
-      delete[] re->arguments.literal_string.runes_;
-      re->arguments.literal_string.runes_ = NULL;
-      re->arguments.literal_string.nrunes_ = 0;
-      re->op_ = kRegexpEmptyMatch;
-    } else if (n == re->arguments.literal_string.nrunes_ - 1) {
-      Rune rune = re->arguments.literal_string.runes_[re->arguments.literal_string.nrunes_ - 1];
-      delete[] re->arguments.literal_string.runes_;
-      re->arguments.literal_string.runes_ = NULL;
-      re->arguments.literal_string.nrunes_ = 0;
-      re->arguments.rune_ = rune;
-      re->op_ = kRegexpLiteral;
-    } else {
-      re->arguments.literal_string.nrunes_ -= n;
-      memmove(re->arguments.literal_string.runes_, re->arguments.literal_string.runes_ + n, re->arguments.literal_string.nrunes_ * sizeof re->arguments.literal_string.runes_[0]);
-    }
-  }
-
-  // If re is now empty, concatenations might simplify too.
-  while (d > 0) {
-    re = stk[--d];
-    Regexp** sub = re->sub();
-    if (sub[0]->op() == kRegexpEmptyMatch) {
-      sub[0]->Decref();
-      sub[0] = NULL;
-      // Delete first element of concat.
-      switch (re->nsub()) {
-        case 0:
-        case 1:
-          // Impossible.
-          LOG(DFATAL) << "Concat of " << re->nsub();
-          re->submany_ = NULL;
-          re->op_ = kRegexpEmptyMatch;
-          break;
-
-        case 2: {
-          // Replace re with sub[1].
-          Regexp* old = sub[1];
-          sub[1] = NULL;
-          re->Swap(old);
-          old->Decref();
-          break;
-        }
-
-        default:
-          // Slide down.
-          re->nsub_--;
-          memmove(sub, sub + 1, re->nsub_ * sizeof sub[0]);
-          break;
-      }
-    }
-  }
-}
-
-// In the context of factoring alternations, a Splice is: a factored prefix or
-// merged character class computed by one iteration of one round of factoring;
-// the span of subexpressions of the alternation to be "spliced" (i.e. removed
-// and replaced); and, for a factored prefix, the number of suffixes after any
-// factoring that might have subsequently been performed on them. For a merged
-// character class, there are no suffixes, of course, so the field is ignored.
-struct Splice {
-  Splice(Regexp* prefix, Regexp** sub, int nsub)
-      : prefix(prefix),
-        sub(sub),
-        nsub(nsub),
-        nsuffix(-1) {}
-
-  Regexp* prefix;
-  Regexp** sub;
-  int nsub;
-  int nsuffix;
-};
-
-// Named so because it is used to implement an explicit stack, a Frame is: the
-// span of subexpressions of the alternation to be factored; the current round
-// of factoring; any Splices computed; and, for a factored prefix, an iterator
-// to the next Splice to be factored (i.e. in another Frame) because suffixes.
-struct Frame {
-  Frame(Regexp** sub, int nsub)
-      : sub(sub),
-        nsub(nsub),
-        round(0) {}
-
-  Regexp** sub;
-  int nsub;
-  int round;
-  std::vector<Splice> splices;
-  int spliceidx;
-};
-
-// Bundled into a class for friend access to Regexp without needing to declare
-// (or define) Splice in regexp.h.
-class FactorAlternationImpl {
- public:
-  static void Round1(Regexp** sub, int nsub,
-                     Regexp::ParseFlags flags,
-                     std::vector<Splice>* splices);
-  static void Round2(Regexp** sub, int nsub,
-                     Regexp::ParseFlags flags,
-                     std::vector<Splice>* splices);
-  static void Round3(Regexp** sub, int nsub,
-                     Regexp::ParseFlags flags,
-                     std::vector<Splice>* splices);
-};
-
-// Factors common prefixes from alternation.
-// For example,
-//     ABC|ABD|AEF|BCX|BCY
-// simplifies to
-//     A(B(C|D)|EF)|BC(X|Y)
-// and thence to
-//     A(B[CD]|EF)|BC[XY]
-//
-// Rewrites sub to contain simplified list to alternate and returns
-// the new length of sub.  Adjusts reference counts accordingly
-// (incoming sub[i] decremented, outgoing sub[i] incremented).
-int Regexp::FactorAlternation(Regexp** sub, int nsub, ParseFlags flags) {
-  std::vector<Frame> stk;
-  stk.emplace_back(sub, nsub);
-
-  for (;;) {
-    auto& sub = stk.back().sub;
-    auto& nsub = stk.back().nsub;
-    auto& round = stk.back().round;
-    auto& splices = stk.back().splices;
-    auto& spliceidx = stk.back().spliceidx;
-
-    if (splices.empty()) {
-      // Advance to the next round of factoring. Note that this covers
-      // the initialised state: when splices is empty and round is 0.
-      round++;
-    } else if (spliceidx < static_cast<int>(splices.size())) {
-      // We have at least one more Splice to factor. Recurse logically.
-      stk.emplace_back(splices[spliceidx].sub, splices[spliceidx].nsub);
-      continue;
-    } else {
-      // We have no more Splices to factor. Apply them.
-      auto iter = splices.begin();
-      int out = 0;
-      for (int i = 0; i < nsub; ) {
-        // Copy until we reach where the next Splice begins.
-        while (sub + i < iter->sub)
-          sub[out++] = sub[i++];
-        switch (round) {
-          case 1:
-          case 2: {
-            // Assemble the Splice prefix and the suffixes.
-            Regexp* re[2];
-            re[0] = iter->prefix;
-            re[1] = Regexp::AlternateNoFactor(iter->sub, iter->nsuffix, flags);
-            sub[out++] = Regexp::Concat(re, 2, flags);
-            i += iter->nsub;
-            break;
-          }
-          case 3:
-            // Just use the Splice prefix.
-            sub[out++] = iter->prefix;
-            i += iter->nsub;
-            break;
-          default:
-            LOG(DFATAL) << "unknown round: " << round;
-            break;
-        }
-        // If we are done, copy until the end of sub.
-        if (++iter == splices.end()) {
-          while (i < nsub)
-            sub[out++] = sub[i++];
-        }
-      }
-      splices.clear();
-      nsub = out;
-      // Advance to the next round of factoring.
-      round++;
-    }
-
-    switch (round) {
-      case 1:
-        FactorAlternationImpl::Round1(sub, nsub, flags, &splices);
-        break;
-      case 2:
-        FactorAlternationImpl::Round2(sub, nsub, flags, &splices);
-        break;
-      case 3:
-        FactorAlternationImpl::Round3(sub, nsub, flags, &splices);
-        break;
-      case 4:
-        if (stk.size() == 1) {
-          // We are at the top of the stack. Just return.
-          return nsub;
-        } else {
-          // Pop the stack and set the number of suffixes.
-          // (Note that references will be invalidated!)
-          int nsuffix = nsub;
-          stk.pop_back();
-          stk.back().splices[stk.back().spliceidx].nsuffix = nsuffix;
-          ++stk.back().spliceidx;
-          continue;
-        }
-      default:
-        LOG(DFATAL) << "unknown round: " << round;
-        break;
-    }
-
-    // Set spliceidx depending on whether we have Splices to factor.
-    if (splices.empty() || round == 3) {
-      spliceidx = static_cast<int>(splices.size());
-    } else {
-      spliceidx = 0;
-    }
-  }
-}
-
-void FactorAlternationImpl::Round1(Regexp** sub, int nsub,
-                                   Regexp::ParseFlags flags,
-                                   std::vector<Splice>* splices) {
-  // Round 1: Factor out common literal prefixes.
-  int start = 0;
-  Rune* rune = NULL;
-  int nrune = 0;
-  Regexp::ParseFlags runeflags = Regexp::NoParseFlags;
-  for (int i = 0; i <= nsub; i++) {
-    // Invariant: sub[start:i] consists of regexps that all
-    // begin with rune[0:nrune].
-    Rune* rune_i = NULL;
-    int nrune_i = 0;
-    Regexp::ParseFlags runeflags_i = Regexp::NoParseFlags;
-    if (i < nsub) {
-      rune_i = Regexp::LeadingString(sub[i], &nrune_i, &runeflags_i);
-      if (runeflags_i == runeflags) {
-        int same = 0;
-        while (same < nrune && same < nrune_i && rune[same] == rune_i[same])
-          same++;
-        if (same > 0) {
-          // Matches at least one rune in current range.  Keep going around.
-          nrune = same;
-          continue;
-        }
-      }
-    }
-
-    // Found end of a run with common leading literal string:
-    // sub[start:i] all begin with rune[0:nrune],
-    // but sub[i] does not even begin with rune[0].
-    if (i == start) {
-      // Nothing to do - first iteration.
-    } else if (i == start+1) {
-      // Just one: don't bother factoring.
-    } else {
-      Regexp* prefix = Regexp::LiteralString(rune, nrune, runeflags);
-      for (int j = start; j < i; j++)
-        Regexp::RemoveLeadingString(sub[j], nrune);
-      splices->emplace_back(prefix, sub + start, i - start);
-    }
-
-    // Prepare for next iteration (if there is one).
-    if (i < nsub) {
-      start = i;
-      rune = rune_i;
-      nrune = nrune_i;
-      runeflags = runeflags_i;
-    }
-  }
-}
-
-void FactorAlternationImpl::Round2(Regexp** sub, int nsub,
-                                   Regexp::ParseFlags flags,
-                                   std::vector<Splice>* splices) {
-  // Round 2: Factor out common simple prefixes,
-  // just the first piece of each concatenation.
-  // This will be good enough a lot of the time.
-  //
-  // Complex subexpressions (e.g. involving quantifiers)
-  // are not safe to factor because that collapses their
-  // distinct paths through the automaton, which affects
-  // correctness in some cases.
-  int start = 0;
-  Regexp* first = NULL;
-  for (int i = 0; i <= nsub; i++) {
-    // Invariant: sub[start:i] consists of regexps that all
-    // begin with first.
-    Regexp* first_i = NULL;
-    if (i < nsub) {
-      first_i = Regexp::LeadingRegexp(sub[i]);
-      if (first != NULL &&
-          // first must be an empty-width op
-          // OR a char class, any char or any byte
-          // OR a fixed repeat of a literal, char class, any char or any byte.
-          (first->op() == kRegexpBeginLine ||
-           first->op() == kRegexpEndLine ||
-           first->op() == kRegexpWordBoundary ||
-           first->op() == kRegexpNoWordBoundary ||
-           first->op() == kRegexpBeginText ||
-           first->op() == kRegexpEndText ||
-           first->op() == kRegexpCharClass ||
-           first->op() == kRegexpAnyChar ||
-           first->op() == kRegexpAnyByte ||
-           (first->op() == kRegexpRepeat &&
-            first->min() == first->max() &&
-            (first->sub()[0]->op() == kRegexpLiteral ||
-             first->sub()[0]->op() == kRegexpCharClass ||
-             first->sub()[0]->op() == kRegexpAnyChar ||
-             first->sub()[0]->op() == kRegexpAnyByte))) &&
-          Regexp::Equal(first, first_i))
-        continue;
-    }
-
-    // Found end of a run with common leading regexp:
-    // sub[start:i] all begin with first,
-    // but sub[i] does not.
-    if (i == start) {
-      // Nothing to do - first iteration.
-    } else if (i == start+1) {
-      // Just one: don't bother factoring.
-    } else {
-      Regexp* prefix = first->Incref();
-      for (int j = start; j < i; j++)
-        sub[j] = Regexp::RemoveLeadingRegexp(sub[j]);
-      splices->emplace_back(prefix, sub + start, i - start);
-    }
-
-    // Prepare for next iteration (if there is one).
-    if (i < nsub) {
-      start = i;
-      first = first_i;
-    }
-  }
-}
-
-void FactorAlternationImpl::Round3(Regexp** sub, int nsub,
-                                   Regexp::ParseFlags flags,
-                                   std::vector<Splice>* splices) {
-  // Round 3: Merge runs of literals and/or character classes.
-  int start = 0;
-  Regexp* first = NULL;
-  for (int i = 0; i <= nsub; i++) {
-    // Invariant: sub[start:i] consists of regexps that all
-    // are either literals (i.e. runes) or character classes.
-    Regexp* first_i = NULL;
-    if (i < nsub) {
-      first_i = sub[i];
-      if (first != NULL &&
-          (first->op() == kRegexpLiteral ||
-           first->op() == kRegexpCharClass) &&
-          (first_i->op() == kRegexpLiteral ||
-           first_i->op() == kRegexpCharClass))
-        continue;
-    }
-
-    // Found end of a run of Literal/CharClass:
-    // sub[start:i] all are either one or the other,
-    // but sub[i] is not.
-    if (i == start) {
-      // Nothing to do - first iteration.
-    } else if (i == start+1) {
-      // Just one: don't bother factoring.
-    } else {
-      CharClassBuilder ccb;
-      for (int j = start; j < i; j++) {
-        Regexp* re = sub[j];
-        if (re->op() == kRegexpCharClass) {
-          CharClass* cc = re->cc();
-          for (CharClass::iterator it = cc->begin(); it != cc->end(); ++it)
-            ccb.AddRange(it->lo, it->hi);
-        } else if (re->op() == kRegexpLiteral) {
-          ccb.AddRangeFlags(re->rune(), re->rune(), re->parse_flags());
-        } else {
-          LOG(DFATAL) << "RE2: unexpected op: " << re->op() << " "
-                      << re->ToString();
-        }
-        re->Decref();
-      }
-      Regexp* re = Regexp::NewCharClass(ccb.GetCharClass(), flags);
-      splices->emplace_back(re, sub + start, i - start);
-    }
-
-    // Prepare for next iteration (if there is one).
-    if (i < nsub) {
-      start = i;
-      first = first_i;
-    }
-  }
-}
-
-// Collapse the regexps on top of the stack, down to the
-// first marker, into a new op node (op == kRegexpAlternate
-// or op == kRegexpConcat).
-void Regexp::ParseState::DoCollapse(RegexpOp op) {
-  // Scan backward to marker, counting children of composite.
-  int n = 0;
-  Regexp* next = NULL;
-  Regexp* sub;
-  for (sub = stacktop_; sub != NULL && !IsMarker(sub->op()); sub = next) {
-    next = sub->down_;
-    if (sub->op_ == op)
-      n += sub->nsub_;
-    else
-      n++;
-  }
-
-  // If there's just one child, leave it alone.
-  // (Concat of one thing is that one thing; alternate of one thing is same.)
-  if (stacktop_ != NULL && stacktop_->down_ == next)
-    return;
-
-  // Construct op (alternation or concatenation), flattening op of op.
-  PODArray<Regexp*> subs(n);
-  next = NULL;
-  int i = n;
-  for (sub = stacktop_; sub != NULL && !IsMarker(sub->op()); sub = next) {
-    next = sub->down_;
-    if (sub->op_ == op) {
-      Regexp** sub_subs = sub->sub();
-      for (int k = sub->nsub_ - 1; k >= 0; k--)
-        subs[--i] = sub_subs[k]->Incref();
-      sub->Decref();
-    } else {
-      subs[--i] = FinishRegexp(sub);
-    }
-  }
-
-  Regexp* re = ConcatOrAlternate(op, subs.data(), n, flags_, true);
-  re->simple_ = re->ComputeSimple();
-  re->down_ = next;
-  stacktop_ = re;
-}
-
-// Finishes the current concatenation,
-// collapsing it into a single regexp on the stack.
-void Regexp::ParseState::DoConcatenation() {
-  Regexp* r1 = stacktop_;
-  if (r1 == NULL || IsMarker(r1->op())) {
-    // empty concatenation is special case
-    Regexp* re = new Regexp(kRegexpEmptyMatch, flags_);
-    PushRegexp(re);
-  }
-  DoCollapse(kRegexpConcat);
-}
-
-// Finishes the current alternation,
-// collapsing it to a single regexp on the stack.
-void Regexp::ParseState::DoAlternation() {
-  DoVerticalBar();
-  // Now stack top is kVerticalBar.
-  Regexp* r1 = stacktop_;
-  stacktop_ = r1->down_;
-  r1->Decref();
-  DoCollapse(kRegexpAlternate);
-}
-
-// Incremental conversion of concatenated literals into strings.
-// If top two elements on stack are both literal or string,
-// collapse into single string.
-// Don't walk down the stack -- the parser calls this frequently
-// enough that below the bottom two is known to be collapsed.
-// Only called when another regexp is about to be pushed
-// on the stack, so that the topmost literal is not being considered.
-// (Otherwise ab* would turn into (ab)*.)
-// If r >= 0, consider pushing a literal r on the stack.
-// Return whether that happened.
-bool Regexp::ParseState::MaybeConcatString(int r, ParseFlags flags) {
-  Regexp* re1;
-  Regexp* re2;
-  if ((re1 = stacktop_) == NULL || (re2 = re1->down_) == NULL)
-    return false;
-
-  if (re1->op_ != kRegexpLiteral && re1->op_ != kRegexpLiteralString)
-    return false;
-  if (re2->op_ != kRegexpLiteral && re2->op_ != kRegexpLiteralString)
-    return false;
-  if ((re1->parse_flags_ & FoldCase) != (re2->parse_flags_ & FoldCase))
-    return false;
-
-  if (re2->op_ == kRegexpLiteral) {
-    // convert into string
-    Rune rune = re2->arguments.rune_;
-    re2->op_ = kRegexpLiteralString;
-    re2->arguments.literal_string.nrunes_ = 0;
-    re2->arguments.literal_string.runes_ = NULL;
-    re2->AddRuneToString(rune);
-  }
-
-  // push re1 into re2.
-  if (re1->op_ == kRegexpLiteral) {
-    re2->AddRuneToString(re1->arguments.rune_);
-  } else {
-    for (int i = 0; i < re1->arguments.literal_string.nrunes_; i++)
-      re2->AddRuneToString(re1->arguments.literal_string.runes_[i]);
-    re1->arguments.literal_string.nrunes_ = 0;
-    delete[] re1->arguments.literal_string.runes_;
-    re1->arguments.literal_string.runes_ = NULL;
-  }
-
-  // reuse re1 if possible
-  if (r >= 0) {
-    re1->op_ = kRegexpLiteral;
-    re1->arguments.rune_ = r;
-    re1->parse_flags_ = static_cast<uint16_t>(flags);
-    return true;
-  }
-
-  stacktop_ = re2;
-  re1->Decref();
-  return false;
-}
-
-// Lexing routines.
-
-// Parses a decimal integer, storing it in *np.
-// Sets *s to span the remainder of the string.
-static bool ParseInteger(StringPiece* s, int* np) {
-  if (s->empty() || !isdigit((*s)[0] & 0xFF))
-    return false;
-  // Disallow leading zeros.
-  if (s->size() >= 2 && (*s)[0] == '0' && isdigit((*s)[1] & 0xFF))
-    return false;
-  int n = 0;
-  int c;
-  while (!s->empty() && isdigit(c = (*s)[0] & 0xFF)) {
-    // Avoid overflow.
-    if (n >= 100000000)
-      return false;
-    n = n*10 + c - '0';
-    s->remove_prefix(1);  // digit
-  }
-  *np = n;
-  return true;
-}
-
-// Parses a repetition suffix like {1,2} or {2} or {2,}.
-// Sets *s to span the remainder of the string on success.
-// Sets *lo and *hi to the given range.
-// In the case of {2,}, the high number is unbounded;
-// sets *hi to -1 to signify this.
-// {,2} is NOT a valid suffix.
-// The Maybe in the name signifies that the regexp parse
-// doesn't fail even if ParseRepetition does, so the StringPiece
-// s must NOT be edited unless MaybeParseRepetition returns true.
-static bool MaybeParseRepetition(StringPiece* sp, int* lo, int* hi) {
-  StringPiece s = *sp;
-  if (s.empty() || s[0] != '{')
-    return false;
-  s.remove_prefix(1);  // '{'
-  if (!ParseInteger(&s, lo))
-    return false;
-  if (s.empty())
-    return false;
-  if (s[0] == ',') {
-    s.remove_prefix(1);  // ','
-    if (s.empty())
-      return false;
-    if (s[0] == '}') {
-      // {2,} means at least 2
-      *hi = -1;
-    } else {
-      // {2,4} means 2, 3, or 4.
-      if (!ParseInteger(&s, hi))
-        return false;
-    }
-  } else {
-    // {2} means exactly two
-    *hi = *lo;
-  }
-  if (s.empty() || s[0] != '}')
-    return false;
-  s.remove_prefix(1);  // '}'
-  *sp = s;
-  return true;
-}
-
-// Removes the next Rune from the StringPiece and stores it in *r.
-// Returns number of bytes removed from sp.
-// Behaves as though there is a terminating NUL at the end of sp.
-// Argument order is backwards from usual Google style
-// but consistent with chartorune.
-static int StringPieceToRune(Rune *r, StringPiece *sp, RegexpStatus* status) {
-  // fullrune() takes int, not size_t. However, it just looks
-  // at the leading byte and treats any length >= 4 the same.
-  if (fullrune(sp->data(), static_cast<int>(std::min(size_t{4}, sp->size())))) {
-    int n = chartorune(r, sp->data());
-    // Some copies of chartorune have a bug that accepts
-    // encodings of values in (10FFFF, 1FFFFF] as valid.
-    // Those values break the character class algorithm,
-    // which assumes Runemax is the largest rune.
-    if (*r > Runemax) {
-      n = 1;
-      *r = Runeerror;
-    }
-    if (!(n == 1 && *r == Runeerror)) {  // no decoding error
-      sp->remove_prefix(n);
-      return n;
-    }
-  }
-
-  if (status != NULL) {
-    status->set_code(kRegexpBadUTF8);
-    status->set_error_arg(StringPiece());
-  }
-  return -1;
-}
-
-// Returns whether name is valid UTF-8.
-// If not, sets status to kRegexpBadUTF8.
-static bool IsValidUTF8(const StringPiece& s, RegexpStatus* status) {
-  StringPiece t = s;
-  Rune r;
-  while (!t.empty()) {
-    if (StringPieceToRune(&r, &t, status) < 0)
-      return false;
-  }
-  return true;
-}
-
-// Is c a hex digit?
-static int IsHex(int c) {
-  return ('0' <= c && c <= '9') ||
-         ('A' <= c && c <= 'F') ||
-         ('a' <= c && c <= 'f');
-}
-
-// Convert hex digit to value.
-static int UnHex(int c) {
-  if ('0' <= c && c <= '9')
-    return c - '0';
-  if ('A' <= c && c <= 'F')
-    return c - 'A' + 10;
-  if ('a' <= c && c <= 'f')
-    return c - 'a' + 10;
-  LOG(DFATAL) << "Bad hex digit " << c;
-  return 0;
-}
-
-// Parse an escape sequence (e.g., \n, \{).
-// Sets *s to span the remainder of the string.
-// Sets *rp to the named character.
-static bool ParseEscape(StringPiece* s, Rune* rp,
-                        RegexpStatus* status, int rune_max) {
-  const char* begin = s->data();
-  if (s->empty() || (*s)[0] != '\\') {
-    // Should not happen - caller always checks.
-    status->set_code(kRegexpInternalError);
-    status->set_error_arg(StringPiece());
-    return false;
-  }
-  if (s->size() == 1) {
-    status->set_code(kRegexpTrailingBackslash);
-    status->set_error_arg(StringPiece());
-    return false;
-  }
-  Rune c, c1;
-  s->remove_prefix(1);  // backslash
-  if (StringPieceToRune(&c, s, status) < 0)
-    return false;
-  int code;
-  switch (c) {
-    default:
-      if (c < Runeself && !isalpha(c) && !isdigit(c)) {
-        // Escaped non-word characters are always themselves.
-        // PCRE is not quite so rigorous: it accepts things like
-        // \q, but we don't.  We once rejected \_, but too many
-        // programs and people insist on using it, so allow \_.
-        *rp = c;
-        return true;
-      }
-      goto BadEscape;
-
-    // Octal escapes.
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-      // Single non-zero octal digit is a backreference; not supported.
-      if (s->empty() || (*s)[0] < '0' || (*s)[0] > '7')
-        goto BadEscape;
-      FALLTHROUGH_INTENDED;
-    case '0':
-      // consume up to three octal digits; already have one.
-      code = c - '0';
-      if (!s->empty() && '0' <= (c = (*s)[0]) && c <= '7') {
-        code = code * 8 + c - '0';
-        s->remove_prefix(1);  // digit
-        if (!s->empty()) {
-          c = (*s)[0];
-          if ('0' <= c && c <= '7') {
-            code = code * 8 + c - '0';
-            s->remove_prefix(1);  // digit
-          }
-        }
-      }
-      if (code > rune_max)
-        goto BadEscape;
-      *rp = code;
-      return true;
-
-    // Hexadecimal escapes
-    case 'x':
-      if (s->empty())
-        goto BadEscape;
-      if (StringPieceToRune(&c, s, status) < 0)
-        return false;
-      if (c == '{') {
-        // Any number of digits in braces.
-        // Update n as we consume the string, so that
-        // the whole thing gets shown in the error message.
-        // Perl accepts any text at all; it ignores all text
-        // after the first non-hex digit.  We require only hex digits,
-        // and at least one.
-        if (StringPieceToRune(&c, s, status) < 0)
-          return false;
-        int nhex = 0;
-        code = 0;
-        while (IsHex(c)) {
-          nhex++;
-          code = code * 16 + UnHex(c);
-          if (code > rune_max)
-            goto BadEscape;
-          if (s->empty())
-            goto BadEscape;
-          if (StringPieceToRune(&c, s, status) < 0)
-            return false;
-        }
-        if (c != '}' || nhex == 0)
-          goto BadEscape;
-        *rp = code;
-        return true;
-      }
-      // Easy case: two hex digits.
-      if (s->empty())
-        goto BadEscape;
-      if (StringPieceToRune(&c1, s, status) < 0)
-        return false;
-      if (!IsHex(c) || !IsHex(c1))
-        goto BadEscape;
-      *rp = UnHex(c) * 16 + UnHex(c1);
-      return true;
-
-    // C escapes.
-    case 'n':
-      *rp = '\n';
-      return true;
-    case 'r':
-      *rp = '\r';
-      return true;
-    case 't':
-      *rp = '\t';
-      return true;
-
-    // Less common C escapes.
-    case 'a':
-      *rp = '\a';
-      return true;
-    case 'f':
-      *rp = '\f';
-      return true;
-    case 'v':
-      *rp = '\v';
-      return true;
-
-    // This code is disabled to avoid misparsing
-    // the Perl word-boundary \b as a backspace
-    // when in POSIX regexp mode.  Surprisingly,
-    // in Perl, \b means word-boundary but [\b]
-    // means backspace.  We don't support that:
-    // if you want a backspace embed a literal
-    // backspace character or use \x08.
-    //
-    // case 'b':
-    //   *rp = '\b';
-    //   return true;
-  }
-
-BadEscape:
-  // Unrecognized escape sequence.
-  status->set_code(kRegexpBadEscape);
-  status->set_error_arg(
-      StringPiece(begin, static_cast<size_t>(s->data() - begin)));
-  return false;
-}
-
-// Add a range to the character class, but exclude newline if asked.
-// Also handle case folding.
-void CharClassBuilder::AddRangeFlags(
-    Rune lo, Rune hi, Regexp::ParseFlags parse_flags) {
-
-  // Take out \n if the flags say so.
-  bool cutnl = !(parse_flags & Regexp::ClassNL) ||
-               (parse_flags & Regexp::NeverNL);
-  if (cutnl && lo <= '\n' && '\n' <= hi) {
-    if (lo < '\n')
-      AddRangeFlags(lo, '\n' - 1, parse_flags);
-    if (hi > '\n')
-      AddRangeFlags('\n' + 1, hi, parse_flags);
-    return;
-  }
-
-  // If folding case, add fold-equivalent characters too.
-  if (parse_flags & Regexp::FoldCase)
-    AddFoldedRange(this, lo, hi, 0);
-  else
-    AddRange(lo, hi);
-}
-
-// Look for a group with the given name.
-static const UGroup* LookupGroup(const StringPiece& name,
-                                 const UGroup *groups, int ngroups) {
-  // Simple name lookup.
-  for (int i = 0; i < ngroups; i++)
-    if (StringPiece(groups[i].name) == name)
-      return &groups[i];
-  return NULL;
-}
-
-// Look for a POSIX group with the given name (e.g., "[:^alpha:]")
-static const UGroup* LookupPosixGroup(const StringPiece& name) {
-  return LookupGroup(name, posix_groups, num_posix_groups);
-}
-
-static const UGroup* LookupPerlGroup(const StringPiece& name) {
-  return LookupGroup(name, perl_groups, num_perl_groups);
-}
-
-#if !defined(RE2_USE_ICU)
-// Fake UGroup containing all Runes
-static URange16 any16[] = { { 0, 65535 } };
-static URange32 any32[] = { { 65536, Runemax } };
-static UGroup anygroup = { "Any", +1, any16, 1, any32, 1 };
-
-// Look for a Unicode group with the given name (e.g., "Han")
-static const UGroup* LookupUnicodeGroup(const StringPiece& name) {
-  // Special case: "Any" means any.
-  if (name == StringPiece("Any"))
-    return &anygroup;
-  return LookupGroup(name, unicode_groups, num_unicode_groups);
-}
-#endif
-
-// Add a UGroup or its negation to the character class.
-static void AddUGroup(CharClassBuilder *cc, const UGroup *g, int sign,
-                      Regexp::ParseFlags parse_flags) {
-  if (sign == +1) {
-    for (int i = 0; i < g->nr16; i++) {
-      cc->AddRangeFlags(g->r16[i].lo, g->r16[i].hi, parse_flags);
-    }
-    for (int i = 0; i < g->nr32; i++) {
-      cc->AddRangeFlags(g->r32[i].lo, g->r32[i].hi, parse_flags);
-    }
-  } else {
-    if (parse_flags & Regexp::FoldCase) {
-      // Normally adding a case-folded group means
-      // adding all the extra fold-equivalent runes too.
-      // But if we're adding the negation of the group,
-      // we have to exclude all the runes that are fold-equivalent
-      // to what's already missing.  Too hard, so do in two steps.
-      CharClassBuilder ccb1;
-      AddUGroup(&ccb1, g, +1, parse_flags);
-      // If the flags say to take out \n, put it in, so that negating will take it out.
-      // Normally AddRangeFlags does this, but we're bypassing AddRangeFlags.
-      bool cutnl = !(parse_flags & Regexp::ClassNL) ||
-                   (parse_flags & Regexp::NeverNL);
-      if (cutnl) {
-        ccb1.AddRange('\n', '\n');
-      }
-      ccb1.Negate();
-      cc->AddCharClass(&ccb1);
-      return;
-    }
-    int next = 0;
-    for (int i = 0; i < g->nr16; i++) {
-      if (next < g->r16[i].lo)
-        cc->AddRangeFlags(next, g->r16[i].lo - 1, parse_flags);
-      next = g->r16[i].hi + 1;
-    }
-    for (int i = 0; i < g->nr32; i++) {
-      if (next < g->r32[i].lo)
-        cc->AddRangeFlags(next, g->r32[i].lo - 1, parse_flags);
-      next = g->r32[i].hi + 1;
-    }
-    if (next <= Runemax)
-      cc->AddRangeFlags(next, Runemax, parse_flags);
-  }
-}
-
-// Maybe parse a Perl character class escape sequence.
-// Only recognizes the Perl character classes (\d \s \w \D \S \W),
-// not the Perl empty-string classes (\b \B \A \Z \z).
-// On success, sets *s to span the remainder of the string
-// and returns the corresponding UGroup.
-// The StringPiece must *NOT* be edited unless the call succeeds.
-const UGroup* MaybeParsePerlCCEscape(StringPiece* s, Regexp::ParseFlags parse_flags) {
-  if (!(parse_flags & Regexp::PerlClasses))
-    return NULL;
-  if (s->size() < 2 || (*s)[0] != '\\')
-    return NULL;
-  // Could use StringPieceToRune, but there aren't
-  // any non-ASCII Perl group names.
-  StringPiece name(s->data(), 2);
-  const UGroup *g = LookupPerlGroup(name);
-  if (g == NULL)
-    return NULL;
-  s->remove_prefix(name.size());
-  return g;
-}
-
-enum ParseStatus {
-  kParseOk,  // Did some parsing.
-  kParseError,  // Found an error.
-  kParseNothing,  // Decided not to parse.
-};
-
-// Maybe parses a Unicode character group like \p{Han} or \P{Han}
-// (the latter is a negated group).
-ParseStatus ParseUnicodeGroup(StringPiece* s, Regexp::ParseFlags parse_flags,
-                              CharClassBuilder *cc,
-                              RegexpStatus* status) {
-  // Decide whether to parse.
-  if (!(parse_flags & Regexp::UnicodeGroups))
-    return kParseNothing;
-  if (s->size() < 2 || (*s)[0] != '\\')
-    return kParseNothing;
-  Rune c = (*s)[1];
-  if (c != 'p' && c != 'P')
-    return kParseNothing;
-
-  // Committed to parse.  Results:
-  int sign = +1;  // -1 = negated char class
-  if (c == 'P')
-    sign = -sign;
-  StringPiece seq = *s;  // \p{Han} or \pL
-  StringPiece name;  // Han or L
-  s->remove_prefix(2);  // '\\', 'p'
-
-  if (!StringPieceToRune(&c, s, status))
-    return kParseError;
-  if (c != '{') {
-    // Name is the bit of string we just skipped over for c.
-    const char* p = seq.data() + 2;
-    name = StringPiece(p, static_cast<size_t>(s->data() - p));
-  } else {
-    // Name is in braces. Look for closing }
-    size_t end = s->find('}', 0);
-    if (end == StringPiece::npos) {
-      if (!IsValidUTF8(seq, status))
-        return kParseError;
-      status->set_code(kRegexpBadCharRange);
-      status->set_error_arg(seq);
-      return kParseError;
-    }
-    name = StringPiece(s->data(), end);  // without '}'
-    s->remove_prefix(end + 1);  // with '}'
-    if (!IsValidUTF8(name, status))
-      return kParseError;
-  }
-
-  // Chop seq where s now begins.
-  seq = StringPiece(seq.data(), static_cast<size_t>(s->data() - seq.data()));
-
-  if (!name.empty() && name[0] == '^') {
-    sign = -sign;
-    name.remove_prefix(1);  // '^'
-  }
-
-#if !defined(RE2_USE_ICU)
-  // Look up the group in the RE2 Unicode data.
-  const UGroup *g = LookupUnicodeGroup(name);
-  if (g == NULL) {
-    status->set_code(kRegexpBadCharRange);
-    status->set_error_arg(seq);
-    return kParseError;
-  }
-
-  AddUGroup(cc, g, sign, parse_flags);
-#else
-  // Look up the group in the ICU Unicode data. Because ICU provides full
-  // Unicode properties support, this could be more than a lookup by name.
-  ::icu::UnicodeString ustr = ::icu::UnicodeString::fromUTF8(
-      std::string("\\p{") + std::string(name) + std::string("}"));
-  UErrorCode uerr = U_ZERO_ERROR;
-  ::icu::UnicodeSet uset(ustr, uerr);
-  if (U_FAILURE(uerr)) {
-    status->set_code(kRegexpBadCharRange);
-    status->set_error_arg(seq);
-    return kParseError;
-  }
-
-  // Convert the UnicodeSet to a URange32 and UGroup that we can add.
-  int nr = uset.getRangeCount();
-  PODArray<URange32> r(nr);
-  for (int i = 0; i < nr; i++) {
-    r[i].lo = uset.getRangeStart(i);
-    r[i].hi = uset.getRangeEnd(i);
-  }
-  UGroup g = {"", +1, 0, 0, r.data(), nr};
-  AddUGroup(cc, &g, sign, parse_flags);
-#endif
-
-  return kParseOk;
-}
-
-// Parses a character class name like [:alnum:].
-// Sets *s to span the remainder of the string.
-// Adds the ranges corresponding to the class to ranges.
-static ParseStatus ParseCCName(StringPiece* s, Regexp::ParseFlags parse_flags,
-                               CharClassBuilder *cc,
-                               RegexpStatus* status) {
-  // Check begins with [:
-  const char* p = s->data();
-  const char* ep = s->data() + s->size();
-  if (ep - p < 2 || p[0] != '[' || p[1] != ':')
-    return kParseNothing;
-
-  // Look for closing :].
-  const char* q;
-  for (q = p+2; q <= ep-2 && (*q != ':' || *(q+1) != ']'); q++)
-    ;
-
-  // If no closing :], then ignore.
-  if (q > ep-2)
-    return kParseNothing;
-
-  // Got it.  Check that it's valid.
-  q += 2;
-  StringPiece name(p, static_cast<size_t>(q - p));
-
-  const UGroup *g = LookupPosixGroup(name);
-  if (g == NULL) {
-    status->set_code(kRegexpBadCharRange);
-    status->set_error_arg(name);
-    return kParseError;
-  }
-
-  s->remove_prefix(name.size());
-  AddUGroup(cc, g, g->sign, parse_flags);
-  return kParseOk;
-}
-
-// Parses a character inside a character class.
-// There are fewer special characters here than in the rest of the regexp.
-// Sets *s to span the remainder of the string.
-// Sets *rp to the character.
-bool Regexp::ParseState::ParseCCCharacter(StringPiece* s, Rune *rp,
-                                          const StringPiece& whole_class,
-                                          RegexpStatus* status) {
-  if (s->empty()) {
-    status->set_code(kRegexpMissingBracket);
-    status->set_error_arg(whole_class);
-    return false;
-  }
-
-  // Allow regular escape sequences even though
-  // many need not be escaped in this context.
-  if ((*s)[0] == '\\')
-    return ParseEscape(s, rp, status, rune_max_);
-
-  // Otherwise take the next rune.
-  return StringPieceToRune(rp, s, status) >= 0;
-}
-
-// Parses a character class character, or, if the character
-// is followed by a hyphen, parses a character class range.
-// For single characters, rr->lo == rr->hi.
-// Sets *s to span the remainder of the string.
-// Sets *rp to the character.
-bool Regexp::ParseState::ParseCCRange(StringPiece* s, RuneRange* rr,
-                                      const StringPiece& whole_class,
-                                      RegexpStatus* status) {
-  StringPiece os = *s;
-  if (!ParseCCCharacter(s, &rr->lo, whole_class, status))
-    return false;
-  // [a-] means (a|-), so check for final ].
-  if (s->size() >= 2 && (*s)[0] == '-' && (*s)[1] != ']') {
-    s->remove_prefix(1);  // '-'
-    if (!ParseCCCharacter(s, &rr->hi, whole_class, status))
-      return false;
-    if (rr->hi < rr->lo) {
-      status->set_code(kRegexpBadCharRange);
-      status->set_error_arg(
-          StringPiece(os.data(), static_cast<size_t>(s->data() - os.data())));
-      return false;
-    }
-  } else {
-    rr->hi = rr->lo;
-  }
-  return true;
-}
-
-// Parses a possibly-negated character class expression like [^abx-z[:digit:]].
-// Sets *s to span the remainder of the string.
-// Sets *out_re to the regexp for the class.
-bool Regexp::ParseState::ParseCharClass(StringPiece* s,
-                                        Regexp** out_re,
-                                        RegexpStatus* status) {
-  StringPiece whole_class = *s;
-  if (s->empty() || (*s)[0] != '[') {
-    // Caller checked this.
-    status->set_code(kRegexpInternalError);
-    status->set_error_arg(StringPiece());
-    return false;
-  }
-  bool negated = false;
-  Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-  re->arguments.char_class.ccb_ = new CharClassBuilder;
-  s->remove_prefix(1);  // '['
-  if (!s->empty() && (*s)[0] == '^') {
-    s->remove_prefix(1);  // '^'
-    negated = true;
-    if (!(flags_ & ClassNL) || (flags_ & NeverNL)) {
-      // If NL can't match implicitly, then pretend
-      // negated classes include a leading \n.
-      re->arguments.char_class.ccb_->AddRange('\n', '\n');
-    }
-  }
-  bool first = true;  // ] is okay as first char in class
-  while (!s->empty() && ((*s)[0] != ']' || first)) {
-    // - is only okay unescaped as first or last in class.
-    // Except that Perl allows - anywhere.
-    if ((*s)[0] == '-' && !first && !(flags_&PerlX) &&
-        (s->size() == 1 || (*s)[1] != ']')) {
-      StringPiece t = *s;
-      t.remove_prefix(1);  // '-'
-      Rune r;
-      int n = StringPieceToRune(&r, &t, status);
-      if (n < 0) {
-        re->Decref();
-        return false;
-      }
-      status->set_code(kRegexpBadCharRange);
-      status->set_error_arg(StringPiece(s->data(), 1+n));
-      re->Decref();
-      return false;
-    }
-    first = false;
-
-    // Look for [:alnum:] etc.
-    if (s->size() > 2 && (*s)[0] == '[' && (*s)[1] == ':') {
-      switch (ParseCCName(s, flags_, re->arguments.char_class.ccb_, status)) {
-        case kParseOk:
-          continue;
-        case kParseError:
-          re->Decref();
-          return false;
-        case kParseNothing:
-          break;
-      }
-    }
-
-    // Look for Unicode character group like \p{Han}
-    if (s->size() > 2 &&
-        (*s)[0] == '\\' &&
-        ((*s)[1] == 'p' || (*s)[1] == 'P')) {
-      switch (ParseUnicodeGroup(s, flags_, re->arguments.char_class.ccb_, status)) {
-        case kParseOk:
-          continue;
-        case kParseError:
-          re->Decref();
-          return false;
-        case kParseNothing:
-          break;
-      }
-    }
-
-    // Look for Perl character class symbols (extension).
-    const UGroup *g = MaybeParsePerlCCEscape(s, flags_);
-    if (g != NULL) {
-      AddUGroup(re->arguments.char_class.ccb_, g, g->sign, flags_);
-      continue;
-    }
-
-    // Otherwise assume single character or simple range.
-    RuneRange rr;
-    if (!ParseCCRange(s, &rr, whole_class, status)) {
-      re->Decref();
-      return false;
-    }
-    // AddRangeFlags is usually called in response to a class like
-    // \p{Foo} or [[:foo:]]; for those, it filters \n out unless
-    // Regexp::ClassNL is set.  In an explicit range or singleton
-    // like we just parsed, we do not filter \n out, so set ClassNL
-    // in the flags.
-    re->arguments.char_class.ccb_->AddRangeFlags(rr.lo, rr.hi, flags_ | Regexp::ClassNL);
-  }
-  if (s->empty()) {
-    status->set_code(kRegexpMissingBracket);
-    status->set_error_arg(whole_class);
-    re->Decref();
-    return false;
-  }
-  s->remove_prefix(1);  // ']'
-
-  if (negated)
-    re->arguments.char_class.ccb_->Negate();
-
-  *out_re = re;
-  return true;
-}
-
-// Returns whether name is a valid capture name.
-static bool IsValidCaptureName(const StringPiece& name) {
-  if (name.empty())
-    return false;
-
-  // Historically, we effectively used [0-9A-Za-z_]+ to validate; that
-  // followed Python 2 except for not restricting the first character.
-  // As of Python 3, Unicode characters beyond ASCII are also allowed;
-  // accordingly, we permit the Lu, Ll, Lt, Lm, Lo, Nl, Mn, Mc, Nd and
-  // Pc categories, but again without restricting the first character.
-  // Also, Unicode normalization (e.g. NFKC) isn't performed: Python 3
-  // performs it for identifiers, but seemingly not for capture names;
-  // if they start doing that for capture names, we won't follow suit.
-  static const CharClass* const cc = []() {
-    CharClassBuilder ccb;
-    for (StringPiece group :
-         {"Lu", "Ll", "Lt", "Lm", "Lo", "Nl", "Mn", "Mc", "Nd", "Pc"})
-      AddUGroup(&ccb, LookupGroup(group, unicode_groups, num_unicode_groups),
-                +1, Regexp::NoParseFlags);
-    return ccb.GetCharClass();
-  }();
-
-  StringPiece t = name;
-  Rune r;
-  while (!t.empty()) {
-    if (StringPieceToRune(&r, &t, NULL) < 0)
-      return false;
-    if (cc->Contains(r))
-      continue;
-    return false;
-  }
-  return true;
-}
-
-// Parses a Perl flag setting or non-capturing group or both,
-// like (?i) or (?: or (?i:.  Removes from s, updates parse state.
-// The caller must check that s begins with "(?".
-// Returns true on success.  If the Perl flag is not
-// well-formed or not supported, sets status_ and returns false.
-bool Regexp::ParseState::ParsePerlFlags(StringPiece* s) {
-  StringPiece t = *s;
-
-  // Caller is supposed to check this.
-  if (!(flags_ & PerlX) || t.size() < 2 || t[0] != '(' || t[1] != '?') {
-    status_->set_code(kRegexpInternalError);
-    LOG(DFATAL) << "Bad call to ParseState::ParsePerlFlags";
-    return false;
-  }
-
-  t.remove_prefix(2);  // "(?"
-
-  // Check for named captures, first introduced in Python's regexp library.
-  // As usual, there are three slightly different syntaxes:
-  //
-  //   (?P<name>expr)   the original, introduced by Python
-  //   (?<name>expr)    the .NET alteration, adopted by Perl 5.10
-  //   (?'name'expr)    another .NET alteration, adopted by Perl 5.10
-  //
-  // Perl 5.10 gave in and implemented the Python version too,
-  // but they claim that the last two are the preferred forms.
-  // PCRE and languages based on it (specifically, PHP and Ruby)
-  // support all three as well.  EcmaScript 4 uses only the Python form.
-  //
-  // In both the open source world (via Code Search) and the
-  // Google source tree, (?P<expr>name) is the dominant form,
-  // so that's the one we implement.  One is enough.
-  if (t.size() > 2 && t[0] == 'P' && t[1] == '<') {
-    // Pull out name.
-    size_t end = t.find('>', 2);
-    if (end == StringPiece::npos) {
-      if (!IsValidUTF8(*s, status_))
-        return false;
-      status_->set_code(kRegexpBadNamedCapture);
-      status_->set_error_arg(*s);
-      return false;
-    }
-
-    // t is "P<name>...", t[end] == '>'
-    StringPiece capture(t.data()-2, end+3);  // "(?P<name>"
-    StringPiece name(t.data()+2, end-2);     // "name"
-    if (!IsValidUTF8(name, status_))
-      return false;
-    if (!IsValidCaptureName(name)) {
-      status_->set_code(kRegexpBadNamedCapture);
-      status_->set_error_arg(capture);
-      return false;
-    }
-
-    if (!DoLeftParen(name)) {
-      // DoLeftParen's failure set status_.
-      return false;
-    }
-
-    s->remove_prefix(
-        static_cast<size_t>(capture.data() + capture.size() - s->data()));
-    return true;
-  }
-
-  bool negated = false;
-  bool sawflags = false;
-  int nflags = flags_;
-  Rune c;
-  for (bool done = false; !done; ) {
-    if (t.empty())
-      goto BadPerlOp;
-    if (StringPieceToRune(&c, &t, status_) < 0)
-      return false;
-    switch (c) {
-      default:
-        goto BadPerlOp;
-
-      // Parse flags.
-      case 'i':
-        sawflags = true;
-        if (negated)
-          nflags &= ~FoldCase;
-        else
-          nflags |= FoldCase;
-        break;
-
-      case 'm':  // opposite of our OneLine
-        sawflags = true;
-        if (negated)
-          nflags |= OneLine;
-        else
-          nflags &= ~OneLine;
-        break;
-
-      case 's':
-        sawflags = true;
-        if (negated)
-          nflags &= ~DotNL;
-        else
-          nflags |= DotNL;
-        break;
-
-      case 'U':
-        sawflags = true;
-        if (negated)
-          nflags &= ~NonGreedy;
-        else
-          nflags |= NonGreedy;
-        break;
-
-      // Negation
-      case '-':
-        if (negated)
-          goto BadPerlOp;
-        negated = true;
-        sawflags = false;
-        break;
-
-      // Open new group.
-      case ':':
-        if (!DoLeftParenNoCapture()) {
-          // DoLeftParenNoCapture's failure set status_.
-          return false;
-        }
-        done = true;
-        break;
-
-      // Finish flags.
-      case ')':
-        done = true;
-        break;
-    }
-  }
-
-  if (negated && !sawflags)
-    goto BadPerlOp;
-
-  flags_ = static_cast<Regexp::ParseFlags>(nflags);
-  *s = t;
-  return true;
-
-BadPerlOp:
-  status_->set_code(kRegexpBadPerlOp);
-  status_->set_error_arg(
-      StringPiece(s->data(), static_cast<size_t>(t.data() - s->data())));
-  return false;
-}
-
-// Converts latin1 (assumed to be encoded as Latin1 bytes)
-// into UTF8 encoding in string.
-// Can't use EncodingUtils::EncodeLatin1AsUTF8 because it is
-// deprecated and because it rejects code points 0x80-0x9F.
-void ConvertLatin1ToUTF8(const StringPiece& latin1, std::string* utf) {
-  char buf[UTFmax];
-
-  utf->clear();
-  for (size_t i = 0; i < latin1.size(); i++) {
-    Rune r = latin1[i] & 0xFF;
-    int n = runetochar(buf, &r);
-    utf->append(buf, n);
-  }
-}
-
-// Parses the regular expression given by s,
-// returning the corresponding Regexp tree.
-// The caller must Decref the return value when done with it.
-// Returns NULL on error.
-Regexp* Regexp::Parse(const StringPiece& s, ParseFlags global_flags,
-                      RegexpStatus* status) {
-  // Make status non-NULL (easier on everyone else).
-  RegexpStatus xstatus;
-  if (status == NULL)
-    status = &xstatus;
-
-  ParseState ps(global_flags, s, status);
-  StringPiece t = s;
-
-  // Convert regexp to UTF-8 (easier on the rest of the parser).
-  if (global_flags & Latin1) {
-    std::string* tmp = new std::string;
-    ConvertLatin1ToUTF8(t, tmp);
-    status->set_tmp(tmp);
-    t = *tmp;
-  }
-
-  if (global_flags & Literal) {
-    // Special parse loop for literal string.
-    while (!t.empty()) {
-      Rune r;
-      if (StringPieceToRune(&r, &t, status) < 0)
-        return NULL;
-      if (!ps.PushLiteral(r))
-        return NULL;
-    }
-    return ps.DoFinish();
-  }
-
-  StringPiece lastunary = StringPiece();
-  while (!t.empty()) {
-    StringPiece isunary = StringPiece();
-    switch (t[0]) {
-      default: {
-        Rune r;
-        if (StringPieceToRune(&r, &t, status) < 0)
-          return NULL;
-        if (!ps.PushLiteral(r))
-          return NULL;
-        break;
-      }
-
-      case '(':
-        // "(?" introduces Perl escape.
-        if ((ps.flags() & PerlX) && (t.size() >= 2 && t[1] == '?')) {
-          // Flag changes and non-capturing groups.
-          if (!ps.ParsePerlFlags(&t))
-            return NULL;
-          break;
-        }
-        if (ps.flags() & NeverCapture) {
-          if (!ps.DoLeftParenNoCapture())
-            return NULL;
-        } else {
-          if (!ps.DoLeftParen(StringPiece()))
-            return NULL;
-        }
-        t.remove_prefix(1);  // '('
-        break;
-
-      case '|':
-        if (!ps.DoVerticalBar())
-          return NULL;
-        t.remove_prefix(1);  // '|'
-        break;
-
-      case ')':
-        if (!ps.DoRightParen())
-          return NULL;
-        t.remove_prefix(1);  // ')'
-        break;
-
-      case '^':  // Beginning of line.
-        if (!ps.PushCaret())
-          return NULL;
-        t.remove_prefix(1);  // '^'
-        break;
-
-      case '$':  // End of line.
-        if (!ps.PushDollar())
-          return NULL;
-        t.remove_prefix(1);  // '$'
-        break;
-
-      case '.':  // Any character (possibly except newline).
-        if (!ps.PushDot())
-          return NULL;
-        t.remove_prefix(1);  // '.'
-        break;
-
-      case '[': {  // Character class.
-        Regexp* re;
-        if (!ps.ParseCharClass(&t, &re, status))
-          return NULL;
-        if (!ps.PushRegexp(re))
-          return NULL;
-        break;
-      }
-
-      case '*': {  // Zero or more.
-        RegexpOp op;
-        op = kRegexpStar;
-        goto Rep;
-      case '+':  // One or more.
-        op = kRegexpPlus;
-        goto Rep;
-      case '?':  // Zero or one.
-        op = kRegexpQuest;
-        goto Rep;
-      Rep:
-        StringPiece opstr = t;
-        bool nongreedy = false;
-        t.remove_prefix(1);  // '*' or '+' or '?'
-        if (ps.flags() & PerlX) {
-          if (!t.empty() && t[0] == '?') {
-            nongreedy = true;
-            t.remove_prefix(1);  // '?'
-          }
-          if (!lastunary.empty()) {
-            // In Perl it is not allowed to stack repetition operators:
-            //   a** is a syntax error, not a double-star.
-            // (and a++ means something else entirely, which we don't support!)
-            status->set_code(kRegexpRepeatOp);
-            status->set_error_arg(StringPiece(
-                lastunary.data(),
-                static_cast<size_t>(t.data() - lastunary.data())));
-            return NULL;
-          }
-        }
-        opstr = StringPiece(opstr.data(),
-                            static_cast<size_t>(t.data() - opstr.data()));
-        if (!ps.PushRepeatOp(op, opstr, nongreedy))
-          return NULL;
-        isunary = opstr;
-        break;
-      }
-
-      case '{': {  // Counted repetition.
-        int lo, hi;
-        StringPiece opstr = t;
-        if (!MaybeParseRepetition(&t, &lo, &hi)) {
-          // Treat like a literal.
-          if (!ps.PushLiteral('{'))
-            return NULL;
-          t.remove_prefix(1);  // '{'
-          break;
-        }
-        bool nongreedy = false;
-        if (ps.flags() & PerlX) {
-          if (!t.empty() && t[0] == '?') {
-            nongreedy = true;
-            t.remove_prefix(1);  // '?'
-          }
-          if (!lastunary.empty()) {
-            // Not allowed to stack repetition operators.
-            status->set_code(kRegexpRepeatOp);
-            status->set_error_arg(StringPiece(
-                lastunary.data(),
-                static_cast<size_t>(t.data() - lastunary.data())));
-            return NULL;
-          }
-        }
-        opstr = StringPiece(opstr.data(),
-                            static_cast<size_t>(t.data() - opstr.data()));
-        if (!ps.PushRepetition(lo, hi, opstr, nongreedy))
-          return NULL;
-        isunary = opstr;
-        break;
-      }
-
-      case '\\': {  // Escaped character or Perl sequence.
-        // \b and \B: word boundary or not
-        if ((ps.flags() & Regexp::PerlB) &&
-            t.size() >= 2 && (t[1] == 'b' || t[1] == 'B')) {
-          if (!ps.PushWordBoundary(t[1] == 'b'))
-            return NULL;
-          t.remove_prefix(2);  // '\\', 'b'
-          break;
-        }
-
-        if ((ps.flags() & Regexp::PerlX) && t.size() >= 2) {
-          if (t[1] == 'A') {
-            if (!ps.PushSimpleOp(kRegexpBeginText))
-              return NULL;
-            t.remove_prefix(2);  // '\\', 'A'
-            break;
-          }
-          if (t[1] == 'z') {
-            if (!ps.PushSimpleOp(kRegexpEndText))
-              return NULL;
-            t.remove_prefix(2);  // '\\', 'z'
-            break;
-          }
-          // Do not recognize \Z, because this library can't
-          // implement the exact Perl/PCRE semantics.
-          // (This library treats "(?-m)$" as \z, even though
-          // in Perl and PCRE it is equivalent to \Z.)
-
-          if (t[1] == 'C') {  // \C: any byte [sic]
-            if (!ps.PushSimpleOp(kRegexpAnyByte))
-              return NULL;
-            t.remove_prefix(2);  // '\\', 'C'
-            break;
-          }
-
-          if (t[1] == 'Q') {  // \Q ... \E: the ... is always literals
-            t.remove_prefix(2);  // '\\', 'Q'
-            while (!t.empty()) {
-              if (t.size() >= 2 && t[0] == '\\' && t[1] == 'E') {
-                t.remove_prefix(2);  // '\\', 'E'
-                break;
-              }
-              Rune r;
-              if (StringPieceToRune(&r, &t, status) < 0)
-                return NULL;
-              if (!ps.PushLiteral(r))
-                return NULL;
-            }
-            break;
-          }
-        }
-
-        if (t.size() >= 2 && (t[1] == 'p' || t[1] == 'P')) {
-          Regexp* re = new Regexp(kRegexpCharClass, ps.flags() & ~FoldCase);
-          re->arguments.char_class.ccb_ = new CharClassBuilder;
-          switch (ParseUnicodeGroup(&t, ps.flags(), re->arguments.char_class.ccb_, status)) {
-            case kParseOk:
-              if (!ps.PushRegexp(re))
-                return NULL;
-              goto Break2;
-            case kParseError:
-              re->Decref();
-              return NULL;
-            case kParseNothing:
-              re->Decref();
-              break;
-          }
-        }
-
-        const UGroup *g = MaybeParsePerlCCEscape(&t, ps.flags());
-        if (g != NULL) {
-          Regexp* re = new Regexp(kRegexpCharClass, ps.flags() & ~FoldCase);
-          re->arguments.char_class.ccb_ = new CharClassBuilder;
-          AddUGroup(re->arguments.char_class.ccb_, g, g->sign, ps.flags());
-          if (!ps.PushRegexp(re))
-            return NULL;
-          break;
-        }
-
-        Rune r;
-        if (!ParseEscape(&t, &r, status, ps.rune_max()))
-          return NULL;
-        if (!ps.PushLiteral(r))
-          return NULL;
-        break;
-      }
-    }
-  Break2:
-    lastunary = isunary;
-  }
-  return ps.DoFinish();
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/perl_groups.cc b/src/duckdb/third_party/re2/re2/perl_groups.cc
deleted file mode 100644
index 97778ae15..000000000
--- a/src/duckdb/third_party/re2/re2/perl_groups.cc
+++ /dev/null
@@ -1,119 +0,0 @@
-// GENERATED BY make_perl_groups.pl; DO NOT EDIT.
-// make_perl_groups.pl >perl_groups.cc
-
-#include "re2/unicode_groups.h"
-
-namespace duckdb_re2 {
-
-static const URange16 code1[] = {  /* \d */
-	{ 0x30, 0x39 },
-};
-static const URange16 code2[] = {  /* \s */
-	{ 0x9, 0xa },
-	{ 0xc, 0xd },
-	{ 0x20, 0x20 },
-};
-static const URange16 code3[] = {  /* \w */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x5a },
-	{ 0x5f, 0x5f },
-	{ 0x61, 0x7a },
-};
-const UGroup perl_groups[] = {
-	{ "\\d", +1, code1, 1, 0, 0 },
-	{ "\\D", -1, code1, 1, 0, 0 },
-	{ "\\s", +1, code2, 3, 0, 0 },
-	{ "\\S", -1, code2, 3, 0, 0 },
-	{ "\\w", +1, code3, 4, 0, 0 },
-	{ "\\W", -1, code3, 4, 0, 0 },
-};
-const int num_perl_groups = 6;
-static const URange16 code4[] = {  /* [:alnum:] */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x5a },
-	{ 0x61, 0x7a },
-};
-static const URange16 code5[] = {  /* [:alpha:] */
-	{ 0x41, 0x5a },
-	{ 0x61, 0x7a },
-};
-static const URange16 code6[] = {  /* [:ascii:] */
-	{ 0x0, 0x7f },
-};
-static const URange16 code7[] = {  /* [:blank:] */
-	{ 0x9, 0x9 },
-	{ 0x20, 0x20 },
-};
-static const URange16 code8[] = {  /* [:cntrl:] */
-	{ 0x0, 0x1f },
-	{ 0x7f, 0x7f },
-};
-static const URange16 code9[] = {  /* [:digit:] */
-	{ 0x30, 0x39 },
-};
-static const URange16 code10[] = {  /* [:graph:] */
-	{ 0x21, 0x7e },
-};
-static const URange16 code11[] = {  /* [:lower:] */
-	{ 0x61, 0x7a },
-};
-static const URange16 code12[] = {  /* [:print:] */
-	{ 0x20, 0x7e },
-};
-static const URange16 code13[] = {  /* [:punct:] */
-	{ 0x21, 0x2f },
-	{ 0x3a, 0x40 },
-	{ 0x5b, 0x60 },
-	{ 0x7b, 0x7e },
-};
-static const URange16 code14[] = {  /* [:space:] */
-	{ 0x9, 0xd },
-	{ 0x20, 0x20 },
-};
-static const URange16 code15[] = {  /* [:upper:] */
-	{ 0x41, 0x5a },
-};
-static const URange16 code16[] = {  /* [:word:] */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x5a },
-	{ 0x5f, 0x5f },
-	{ 0x61, 0x7a },
-};
-static const URange16 code17[] = {  /* [:xdigit:] */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x46 },
-	{ 0x61, 0x66 },
-};
-const UGroup posix_groups[] = {
-	{ "[:alnum:]", +1, code4, 3, 0, 0 },
-	{ "[:^alnum:]", -1, code4, 3, 0, 0 },
-	{ "[:alpha:]", +1, code5, 2, 0, 0 },
-	{ "[:^alpha:]", -1, code5, 2, 0, 0 },
-	{ "[:ascii:]", +1, code6, 1, 0, 0 },
-	{ "[:^ascii:]", -1, code6, 1, 0, 0 },
-	{ "[:blank:]", +1, code7, 2, 0, 0 },
-	{ "[:^blank:]", -1, code7, 2, 0, 0 },
-	{ "[:cntrl:]", +1, code8, 2, 0, 0 },
-	{ "[:^cntrl:]", -1, code8, 2, 0, 0 },
-	{ "[:digit:]", +1, code9, 1, 0, 0 },
-	{ "[:^digit:]", -1, code9, 1, 0, 0 },
-	{ "[:graph:]", +1, code10, 1, 0, 0 },
-	{ "[:^graph:]", -1, code10, 1, 0, 0 },
-	{ "[:lower:]", +1, code11, 1, 0, 0 },
-	{ "[:^lower:]", -1, code11, 1, 0, 0 },
-	{ "[:print:]", +1, code12, 1, 0, 0 },
-	{ "[:^print:]", -1, code12, 1, 0, 0 },
-	{ "[:punct:]", +1, code13, 4, 0, 0 },
-	{ "[:^punct:]", -1, code13, 4, 0, 0 },
-	{ "[:space:]", +1, code14, 2, 0, 0 },
-	{ "[:^space:]", -1, code14, 2, 0, 0 },
-	{ "[:upper:]", +1, code15, 1, 0, 0 },
-	{ "[:^upper:]", -1, code15, 1, 0, 0 },
-	{ "[:word:]", +1, code16, 4, 0, 0 },
-	{ "[:^word:]", -1, code16, 4, 0, 0 },
-	{ "[:xdigit:]", +1, code17, 3, 0, 0 },
-	{ "[:^xdigit:]", -1, code17, 3, 0, 0 },
-};
-const int num_posix_groups = 28;
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/pod_array.h b/src/duckdb/third_party/re2/re2/pod_array.h
deleted file mode 100644
index 4f311e78e..000000000
--- a/src/duckdb/third_party/re2/re2/pod_array.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2018 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_POD_ARRAY_H_
-#define RE2_POD_ARRAY_H_
-
-#include <memory>
-#include <type_traits>
-
-namespace duckdb_re2 {
-
-template <typename T>
-class PODArray {
- public:
-  static_assert(std::is_trivial<T>::value && std::is_standard_layout<T>::value,
-                "T must be POD");
-
-  PODArray()
-      : ptr_() {}
-  explicit PODArray(int len)
-      : ptr_(std::allocator<T>().allocate(len), Deleter(len)) {}
-
-  T* data() const {
-    return ptr_.get();
-  }
-
-  int size() const {
-    return ptr_.get_deleter().len_;
-  }
-
-  T& operator[](int pos) const {
-    return ptr_[pos];
-  }
-
- private:
-  struct Deleter {
-    Deleter()
-        : len_(0) {}
-    explicit Deleter(int len)
-        : len_(len) {}
-
-    void operator()(T* ptr) const {
-      std::allocator<T>().deallocate(ptr, len_);
-    }
-
-    int len_;
-  };
-
-  std::unique_ptr<T[], Deleter> ptr_;
-};
-
-}  // namespace re2
-
-#endif  // RE2_POD_ARRAY_H_
diff --git a/src/duckdb/third_party/re2/re2/prefilter.cc b/src/duckdb/third_party/re2/re2/prefilter.cc
deleted file mode 100644
index d5543b080..000000000
--- a/src/duckdb/third_party/re2/re2/prefilter.cc
+++ /dev/null
@@ -1,692 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "re2/prefilter.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "util/utf.h"
-#include "re2/re2.h"
-#include "re2/unicode_casefold.h"
-#include "re2/walker-inl.h"
-
-namespace duckdb_re2 {
-
-// Initializes a Prefilter, allocating subs_ as necessary.
-Prefilter::Prefilter(Op op) {
-  op_ = op;
-  subs_ = NULL;
-  if (op_ == AND || op_ == OR)
-    subs_ = new std::vector<Prefilter*>;
-}
-
-// Destroys a Prefilter.
-Prefilter::~Prefilter() {
-  if (subs_) {
-    for (size_t i = 0; i < subs_->size(); i++)
-      delete (*subs_)[i];
-    delete subs_;
-    subs_ = NULL;
-  }
-}
-
-// Simplify if the node is an empty Or or And.
-Prefilter* Prefilter::Simplify() {
-  if (op_ != AND && op_ != OR) {
-    return this;
-  }
-
-  // Nothing left in the AND/OR.
-  if (subs_->empty()) {
-    if (op_ == AND)
-      op_ = ALL;  // AND of nothing is true
-    else
-      op_ = NONE;  // OR of nothing is false
-
-    return this;
-  }
-
-  // Just one subnode: throw away wrapper.
-  if (subs_->size() == 1) {
-    Prefilter* a = (*subs_)[0];
-    subs_->clear();
-    delete this;
-    return a->Simplify();
-  }
-
-  return this;
-}
-
-// Combines two Prefilters together to create an "op" (AND or OR).
-// The passed Prefilters will be part of the returned Prefilter or deleted.
-// Does lots of work to avoid creating unnecessarily complicated structures.
-Prefilter* Prefilter::AndOr(Op op, Prefilter* a, Prefilter* b) {
-  // If a, b can be rewritten as op, do so.
-  a = a->Simplify();
-  b = b->Simplify();
-
-  // Canonicalize: a->op <= b->op.
-  if (a->op() > b->op()) {
-    Prefilter* t = a;
-    a = b;
-    b = t;
-  }
-
-  // Trivial cases.
-  //    ALL AND b = b
-  //    NONE OR b = b
-  //    ALL OR b   = ALL
-  //    NONE AND b = NONE
-  // Don't need to look at b, because of canonicalization above.
-  // ALL and NONE are smallest opcodes.
-  if (a->op() == ALL || a->op() == NONE) {
-    if ((a->op() == ALL && op == AND) ||
-        (a->op() == NONE && op == OR)) {
-      delete a;
-      return b;
-    } else {
-      delete b;
-      return a;
-    }
-  }
-
-  // If a and b match op, merge their contents.
-  if (a->op() == op && b->op() == op) {
-    for (size_t i = 0; i < b->subs()->size(); i++) {
-      Prefilter* bb = (*b->subs())[i];
-      a->subs()->push_back(bb);
-    }
-    b->subs()->clear();
-    delete b;
-    return a;
-  }
-
-  // If a already has the same op as the op that is under construction
-  // add in b (similarly if b already has the same op, add in a).
-  if (b->op() == op) {
-    Prefilter* t = a;
-    a = b;
-    b = t;
-  }
-  if (a->op() == op) {
-    a->subs()->push_back(b);
-    return a;
-  }
-
-  // Otherwise just return the op.
-  Prefilter* c = new Prefilter(op);
-  c->subs()->push_back(a);
-  c->subs()->push_back(b);
-  return c;
-}
-
-Prefilter* Prefilter::And(Prefilter* a, Prefilter* b) {
-  return AndOr(AND, a, b);
-}
-
-Prefilter* Prefilter::Or(Prefilter* a, Prefilter* b) {
-  return AndOr(OR, a, b);
-}
-
-void Prefilter::SimplifyStringSet(SSet* ss) {
-  // Now make sure that the strings aren't redundant.  For example, if
-  // we know "ab" is a required string, then it doesn't help at all to
-  // know that "abc" is also a required string, so delete "abc". This
-  // is because, when we are performing a string search to filter
-  // regexps, matching "ab" will already allow this regexp to be a
-  // candidate for match, so further matching "abc" is redundant.
-  // Note that we must ignore "" because find() would find it at the
-  // start of everything and thus we would end up erasing everything.
-  //
-  // The SSet sorts strings by length, then lexicographically. Note that
-  // smaller strings appear first and all strings must be unique. These
-  // observations let us skip string comparisons when possible.
-  SSIter i = ss->begin();
-  if (i != ss->end() && i->empty()) {
-    ++i;
-  }
-  for (; i != ss->end(); ++i) {
-    SSIter j = i;
-    ++j;
-    while (j != ss->end()) {
-      if (j->size() > i->size() && j->find(*i) != std::string::npos) {
-        j = ss->erase(j);
-        continue;
-      }
-      ++j;
-    }
-  }
-}
-
-Prefilter* Prefilter::OrStrings(SSet* ss) {
-  Prefilter* or_prefilter = new Prefilter(NONE);
-  SimplifyStringSet(ss);
-  for (SSIter i = ss->begin(); i != ss->end(); ++i)
-    or_prefilter = Or(or_prefilter, FromString(*i));
-  return or_prefilter;
-}
-
-static Rune ToLowerRune(Rune r) {
-  if (r < Runeself) {
-    if ('A' <= r && r <= 'Z')
-      r += 'a' - 'A';
-    return r;
-  }
-
-  const CaseFold *f = LookupCaseFold(unicode_tolower, num_unicode_tolower, r);
-  if (f == NULL || r < f->lo)
-    return r;
-  return ApplyFold(f, r);
-}
-
-static Rune ToLowerRuneLatin1(Rune r) {
-  if ('A' <= r && r <= 'Z')
-    r += 'a' - 'A';
-  return r;
-}
-
-Prefilter* Prefilter::FromString(const std::string& str) {
-  Prefilter* m = new Prefilter(Prefilter::ATOM);
-  m->atom_ = str;
-  return m;
-}
-
-// Information about a regexp used during computation of Prefilter.
-// Can be thought of as information about the set of strings matching
-// the given regular expression.
-class Prefilter::Info {
- public:
-  Info();
-  ~Info();
-
-  // More constructors.  They delete their Info* arguments.
-  static Info* Alt(Info* a, Info* b);
-  static Info* Concat(Info* a, Info* b);
-  static Info* And(Info* a, Info* b);
-  static Info* Star(Info* a);
-  static Info* Plus(Info* a);
-  static Info* Quest(Info* a);
-  static Info* EmptyString();
-  static Info* NoMatch();
-  static Info* AnyCharOrAnyByte();
-  static Info* CClass(CharClass* cc, bool latin1);
-  static Info* Literal(Rune r);
-  static Info* LiteralLatin1(Rune r);
-  static Info* AnyMatch();
-
-  // Format Info as a string.
-  std::string ToString();
-
-  // Caller takes ownership of the Prefilter.
-  Prefilter* TakeMatch();
-
-  SSet& exact() { return exact_; }
-
-  bool is_exact() const { return is_exact_; }
-
-  class Walker;
-
- private:
-  SSet exact_;
-
-  // When is_exact_ is true, the strings that match
-  // are placed in exact_. When it is no longer an exact
-  // set of strings that match this RE, then is_exact_
-  // is false and the match_ contains the required match
-  // criteria.
-  bool is_exact_;
-
-  // Accumulated Prefilter query that any
-  // match for this regexp is guaranteed to match.
-  Prefilter* match_;
-};
-
-
-Prefilter::Info::Info()
-  : is_exact_(false),
-    match_(NULL) {
-}
-
-Prefilter::Info::~Info() {
-  delete match_;
-}
-
-Prefilter* Prefilter::Info::TakeMatch() {
-  if (is_exact_) {
-    match_ = Prefilter::OrStrings(&exact_);
-    is_exact_ = false;
-  }
-  Prefilter* m = match_;
-  match_ = NULL;
-  return m;
-}
-
-// Format a Info in string form.
-std::string Prefilter::Info::ToString() {
-  if (is_exact_) {
-    int n = 0;
-    std::string s;
-    for (SSIter i = exact_.begin(); i != exact_.end(); ++i) {
-      if (n++ > 0)
-        s += ",";
-      s += *i;
-    }
-    return s;
-  }
-
-  if (match_)
-    return match_->DebugString();
-
-  return "";
-}
-
-void Prefilter::CrossProduct(const SSet& a, const SSet& b, SSet* dst) {
-  for (ConstSSIter i = a.begin(); i != a.end(); ++i)
-    for (ConstSSIter j = b.begin(); j != b.end(); ++j)
-      dst->insert(*i + *j);
-}
-
-// Concats a and b. Requires that both are exact sets.
-// Forms an exact set that is a crossproduct of a and b.
-Prefilter::Info* Prefilter::Info::Concat(Info* a, Info* b) {
-  if (a == NULL)
-    return b;
-  DCHECK(a->is_exact_);
-  DCHECK(b && b->is_exact_);
-  Info *ab = new Info();
-
-  CrossProduct(a->exact_, b->exact_, &ab->exact_);
-  ab->is_exact_ = true;
-
-  delete a;
-  delete b;
-  return ab;
-}
-
-// Constructs an inexact Info for ab given a and b.
-// Used only when a or b is not exact or when the
-// exact cross product is likely to be too big.
-Prefilter::Info* Prefilter::Info::And(Info* a, Info* b) {
-  if (a == NULL)
-    return b;
-  if (b == NULL)
-    return a;
-
-  Info *ab = new Info();
-
-  ab->match_ = Prefilter::And(a->TakeMatch(), b->TakeMatch());
-  ab->is_exact_ = false;
-  delete a;
-  delete b;
-  return ab;
-}
-
-// Constructs Info for a|b given a and b.
-Prefilter::Info* Prefilter::Info::Alt(Info* a, Info* b) {
-  Info *ab = new Info();
-
-  if (a->is_exact_ && b->is_exact_) {
-    // Avoid string copies by moving the larger exact_ set into
-    // ab directly, then merge in the smaller set.
-    if (a->exact_.size() < b->exact_.size()) {
-      using std::swap;
-      swap(a, b);
-    }
-    ab->exact_ = std::move(a->exact_);
-    ab->exact_.insert(b->exact_.begin(), b->exact_.end());
-    ab->is_exact_ = true;
-  } else {
-    // Either a or b has is_exact_ = false. If the other
-    // one has is_exact_ = true, we move it to match_ and
-    // then create a OR of a,b. The resulting Info has
-    // is_exact_ = false.
-    ab->match_ = Prefilter::Or(a->TakeMatch(), b->TakeMatch());
-    ab->is_exact_ = false;
-  }
-
-  delete a;
-  delete b;
-  return ab;
-}
-
-// Constructs Info for a? given a.
-Prefilter::Info* Prefilter::Info::Quest(Info *a) {
-  Info *ab = new Info();
-
-  ab->is_exact_ = false;
-  ab->match_ = new Prefilter(ALL);
-  delete a;
-  return ab;
-}
-
-// Constructs Info for a* given a.
-// Same as a? -- not much to do.
-Prefilter::Info* Prefilter::Info::Star(Info *a) {
-  return Quest(a);
-}
-
-// Constructs Info for a+ given a. If a was exact set, it isn't
-// anymore.
-Prefilter::Info* Prefilter::Info::Plus(Info *a) {
-  Info *ab = new Info();
-
-  ab->match_ = a->TakeMatch();
-  ab->is_exact_ = false;
-
-  delete a;
-  return ab;
-}
-
-static std::string RuneToString(Rune r) {
-  char buf[UTFmax];
-  int n = runetochar(buf, &r);
-  return std::string(buf, n);
-}
-
-static std::string RuneToStringLatin1(Rune r) {
-  char c = r & 0xff;
-  return std::string(&c, 1);
-}
-
-// Constructs Info for literal rune.
-Prefilter::Info* Prefilter::Info::Literal(Rune r) {
-  Info* info = new Info();
-  info->exact_.insert(RuneToString(ToLowerRune(r)));
-  info->is_exact_ = true;
-  return info;
-}
-
-// Constructs Info for literal rune for Latin1 encoded string.
-Prefilter::Info* Prefilter::Info::LiteralLatin1(Rune r) {
-  Info* info = new Info();
-  info->exact_.insert(RuneToStringLatin1(ToLowerRuneLatin1(r)));
-  info->is_exact_ = true;
-  return info;
-}
-
-// Constructs Info for dot (any character) or \C (any byte).
-Prefilter::Info* Prefilter::Info::AnyCharOrAnyByte() {
-  Prefilter::Info* info = new Prefilter::Info();
-  info->match_ = new Prefilter(ALL);
-  return info;
-}
-
-// Constructs Prefilter::Info for no possible match.
-Prefilter::Info* Prefilter::Info::NoMatch() {
-  Prefilter::Info* info = new Prefilter::Info();
-  info->match_ = new Prefilter(NONE);
-  return info;
-}
-
-// Constructs Prefilter::Info for any possible match.
-// This Prefilter::Info is valid for any regular expression,
-// since it makes no assertions whatsoever about the
-// strings being matched.
-Prefilter::Info* Prefilter::Info::AnyMatch() {
-  Prefilter::Info *info = new Prefilter::Info();
-  info->match_ = new Prefilter(ALL);
-  return info;
-}
-
-// Constructs Prefilter::Info for just the empty string.
-Prefilter::Info* Prefilter::Info::EmptyString() {
-  Prefilter::Info* info = new Prefilter::Info();
-  info->is_exact_ = true;
-  info->exact_.insert("");
-  return info;
-}
-
-// Constructs Prefilter::Info for a character class.
-typedef CharClass::iterator CCIter;
-Prefilter::Info* Prefilter::Info::CClass(CharClass *cc,
-                                         bool latin1) {
-
-  // If the class is too large, it's okay to overestimate.
-  if (cc->size() > 10)
-    return AnyCharOrAnyByte();
-
-  Prefilter::Info *a = new Prefilter::Info();
-  for (CCIter i = cc->begin(); i != cc->end(); ++i)
-    for (Rune r = i->lo; r <= i->hi; r++) {
-      if (latin1) {
-        a->exact_.insert(RuneToStringLatin1(ToLowerRuneLatin1(r)));
-      } else {
-        a->exact_.insert(RuneToString(ToLowerRune(r)));
-      }
-    }
-
-
-  a->is_exact_ = true;
-  return a;
-}
-
-class Prefilter::Info::Walker : public Regexp::Walker<Prefilter::Info*> {
- public:
-  Walker(bool latin1) : latin1_(latin1) {}
-
-  virtual Info* PostVisit(
-      Regexp* re, Info* parent_arg,
-      Info* pre_arg,
-      Info** child_args, int nchild_args);
-
-  virtual Info* ShortVisit(
-      Regexp* re,
-      Info* parent_arg);
-
-  bool latin1() { return latin1_; }
- private:
-  bool latin1_;
-
-  Walker(const Walker&) = delete;
-  Walker& operator=(const Walker&) = delete;
-};
-
-Prefilter::Info* Prefilter::BuildInfo(Regexp* re) {
-  bool latin1 = (re->parse_flags() & Regexp::Latin1) != 0;
-  Prefilter::Info::Walker w(latin1);
-  Prefilter::Info* info = w.WalkExponential(re, NULL, 100000);
-
-  if (w.stopped_early()) {
-    delete info;
-    return NULL;
-  }
-
-  return info;
-}
-
-Prefilter::Info* Prefilter::Info::Walker::ShortVisit(
-    Regexp* re, Prefilter::Info* parent_arg) {
-  return AnyMatch();
-}
-
-// Constructs the Prefilter::Info for the given regular expression.
-// Assumes re is simplified.
-Prefilter::Info* Prefilter::Info::Walker::PostVisit(
-    Regexp* re, Prefilter::Info* parent_arg,
-    Prefilter::Info* pre_arg, Prefilter::Info** child_args,
-    int nchild_args) {
-  Prefilter::Info *info;
-  switch (re->op()) {
-    default:
-    case kRegexpRepeat:
-      info = EmptyString();
-      LOG(DFATAL) << "Bad regexp op " << re->op();
-      break;
-
-    case kRegexpNoMatch:
-      info = NoMatch();
-      break;
-
-    // These ops match the empty string:
-    case kRegexpEmptyMatch:      // anywhere
-    case kRegexpBeginLine:       // at beginning of line
-    case kRegexpEndLine:         // at end of line
-    case kRegexpBeginText:       // at beginning of text
-    case kRegexpEndText:         // at end of text
-    case kRegexpWordBoundary:    // at word boundary
-    case kRegexpNoWordBoundary:  // not at word boundary
-      info = EmptyString();
-      break;
-
-    case kRegexpLiteral:
-      if (latin1()) {
-        info = LiteralLatin1(re->rune());
-      }
-      else {
-        info = Literal(re->rune());
-      }
-      break;
-
-    case kRegexpLiteralString:
-      if (re->nrunes() == 0) {
-        info = NoMatch();
-        break;
-      }
-      if (latin1()) {
-        info = LiteralLatin1(re->runes()[0]);
-        for (int i = 1; i < re->nrunes(); i++) {
-          info = Concat(info, LiteralLatin1(re->runes()[i]));
-        }
-      } else {
-        info = Literal(re->runes()[0]);
-        for (int i = 1; i < re->nrunes(); i++) {
-          info = Concat(info, Literal(re->runes()[i]));
-        }
-      }
-      break;
-
-    case kRegexpConcat: {
-      // Accumulate in info.
-      // Exact is concat of recent contiguous exact nodes.
-      info = NULL;
-      Info* exact = NULL;
-      for (int i = 0; i < nchild_args; i++) {
-        Info* ci = child_args[i];  // child info
-        if (!ci->is_exact() ||
-            (exact && ci->exact().size() * exact->exact().size() > 16)) {
-          // Exact run is over.
-          info = And(info, exact);
-          exact = NULL;
-          // Add this child's info.
-          info = And(info, ci);
-        } else {
-          // Append to exact run.
-          exact = Concat(exact, ci);
-        }
-      }
-      info = And(info, exact);
-    }
-      break;
-
-    case kRegexpAlternate:
-      info = child_args[0];
-      for (int i = 1; i < nchild_args; i++)
-        info = Alt(info, child_args[i]);
-      break;
-
-    case kRegexpStar:
-      info = Star(child_args[0]);
-      break;
-
-    case kRegexpQuest:
-      info = Quest(child_args[0]);
-      break;
-
-    case kRegexpPlus:
-      info = Plus(child_args[0]);
-      break;
-
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-      // Claim nothing, except that it's not empty.
-      info = AnyCharOrAnyByte();
-      break;
-
-    case kRegexpCharClass:
-      info = CClass(re->cc(), latin1());
-      break;
-
-    case kRegexpCapture:
-      // These don't affect the set of matching strings.
-      info = child_args[0];
-      break;
-  }
-
-  return info;
-}
-
-
-Prefilter* Prefilter::FromRegexp(Regexp* re) {
-  if (re == NULL)
-    return NULL;
-
-  Regexp* simple = re->Simplify();
-  if (simple == NULL)
-    return NULL;
-
-  Prefilter::Info* info = BuildInfo(simple);
-  simple->Decref();
-  if (info == NULL)
-    return NULL;
-
-  Prefilter* m = info->TakeMatch();
-  delete info;
-  return m;
-}
-
-std::string Prefilter::DebugString() const {
-  switch (op_) {
-    default:
-      LOG(DFATAL) << "Bad op in Prefilter::DebugString: " << op_;
-      return StringPrintf("op%d", op_);
-    case NONE:
-      return "*no-matches*";
-    case ATOM:
-      return atom_;
-    case ALL:
-      return "";
-    case AND: {
-      std::string s = "";
-      for (size_t i = 0; i < subs_->size(); i++) {
-        if (i > 0)
-          s += " ";
-        Prefilter* sub = (*subs_)[i];
-        s += sub ? sub->DebugString() : "<nil>";
-      }
-      return s;
-    }
-    case OR: {
-      std::string s = "(";
-      for (size_t i = 0; i < subs_->size(); i++) {
-        if (i > 0)
-          s += "|";
-        Prefilter* sub = (*subs_)[i];
-        s += sub ? sub->DebugString() : "<nil>";
-      }
-      s += ")";
-      return s;
-    }
-  }
-}
-
-Prefilter* Prefilter::FromRE2(const RE2* re2) {
-  if (re2 == NULL)
-    return NULL;
-
-  Regexp* regexp = re2->Regexp();
-  if (regexp == NULL)
-    return NULL;
-
-  return FromRegexp(regexp);
-}
-
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/prefilter.h b/src/duckdb/third_party/re2/re2/prefilter.h
deleted file mode 100644
index 4eb8ef83d..000000000
--- a/src/duckdb/third_party/re2/re2/prefilter.h
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_PREFILTER_H_
-#define RE2_PREFILTER_H_
-
-// Prefilter is the class used to extract string guards from regexps.
-// Rather than using Prefilter class directly, use FilteredRE2.
-// See filtered_re2.h
-
-#include <set>
-#include <string>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-
-namespace duckdb_re2 {
-
-class RE2;
-
-class Regexp;
-
-class Prefilter {
-  // Instead of using Prefilter directly, use FilteredRE2; see filtered_re2.h
- public:
-  enum Op {
-    ALL = 0,  // Everything matches
-    NONE,  // Nothing matches
-    ATOM,  // The string atom() must match
-    AND,   // All in subs() must match
-    OR,   // One of subs() must match
-  };
-
-  explicit Prefilter(Op op);
-  ~Prefilter();
-
-  Op op() { return op_; }
-  const std::string& atom() const { return atom_; }
-  void set_unique_id(int id) { unique_id_ = id; }
-  int unique_id() const { return unique_id_; }
-
-  // The children of the Prefilter node.
-  std::vector<Prefilter*>* subs() {
-    DCHECK(op_ == AND || op_ == OR);
-    return subs_;
-  }
-
-  // Set the children vector. Prefilter takes ownership of subs and
-  // subs_ will be deleted when Prefilter is deleted.
-  void set_subs(std::vector<Prefilter*>* subs) { subs_ = subs; }
-
-  // Given a RE2, return a Prefilter. The caller takes ownership of
-  // the Prefilter and should deallocate it. Returns NULL if Prefilter
-  // cannot be formed.
-  static Prefilter* FromRE2(const RE2* re2);
-
-  // Returns a readable debug string of the prefilter.
-  std::string DebugString() const;
-
- private:
-  // A comparator used to store exact strings. We compare by length,
-  // then lexicographically. This ordering makes it easier to reduce the
-  // set of strings in SimplifyStringSet.
-  struct LengthThenLex {
-    bool operator()(const std::string& a, const std::string& b) const {
-       return (a.size() < b.size()) || (a.size() == b.size() && a < b);
-    }
-  };
-
-  class Info;
-
-  using SSet = std::set<std::string, LengthThenLex>;
-  using SSIter = SSet::iterator;
-  using ConstSSIter = SSet::const_iterator;
-
-  // Combines two prefilters together to create an AND. The passed
-  // Prefilters will be part of the returned Prefilter or deleted.
-  static Prefilter* And(Prefilter* a, Prefilter* b);
-
-  // Combines two prefilters together to create an OR. The passed
-  // Prefilters will be part of the returned Prefilter or deleted.
-  static Prefilter* Or(Prefilter* a, Prefilter* b);
-
-  // Generalized And/Or
-  static Prefilter* AndOr(Op op, Prefilter* a, Prefilter* b);
-
-  static Prefilter* FromRegexp(Regexp* a);
-
-  static Prefilter* FromString(const std::string& str);
-
-  static Prefilter* OrStrings(SSet* ss);
-
-  static Info* BuildInfo(Regexp* re);
-
-  Prefilter* Simplify();
-
-  // Removes redundant strings from the set. A string is redundant if
-  // any of the other strings appear as a substring. The empty string
-  // is a special case, which is ignored.
-  static void SimplifyStringSet(SSet* ss);
-
-  // Adds the cross-product of a and b to dst.
-  // (For each string i in a and j in b, add i+j.)
-  static void CrossProduct(const SSet& a, const SSet& b, SSet* dst);
-
-  // Kind of Prefilter.
-  Op op_;
-
-  // Sub-matches for AND or OR Prefilter.
-  std::vector<Prefilter*>* subs_;
-
-  // Actual string to match in leaf node.
-  std::string atom_;
-
-  // If different prefilters have the same string atom, or if they are
-  // structurally the same (e.g., OR of same atom strings) they are
-  // considered the same unique nodes. This is the id for each unique
-  // node. This field is populated with a unique id for every node,
-  // and -1 for duplicate nodes.
-  int unique_id_;
-
-  Prefilter(const Prefilter&) = delete;
-  Prefilter& operator=(const Prefilter&) = delete;
-};
-
-}  // namespace re2
-
-#endif  // RE2_PREFILTER_H_
diff --git a/src/duckdb/third_party/re2/re2/prefilter_tree.cc b/src/duckdb/third_party/re2/re2/prefilter_tree.cc
deleted file mode 100644
index 533918b9a..000000000
--- a/src/duckdb/third_party/re2/re2/prefilter_tree.cc
+++ /dev/null
@@ -1,388 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "re2/prefilter_tree.h"
-
-#include <stddef.h>
-#include <algorithm>
-#include <cmath>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "re2/prefilter.h"
-#include "re2/re2.h"
-
-namespace duckdb_re2 {
-
-PrefilterTree::PrefilterTree()
-    : compiled_(false),
-      min_atom_len_(3) {
-}
-
-PrefilterTree::PrefilterTree(int min_atom_len)
-    : compiled_(false),
-      min_atom_len_(min_atom_len) {
-}
-
-PrefilterTree::~PrefilterTree() {
-  for (size_t i = 0; i < prefilter_vec_.size(); i++)
-    delete prefilter_vec_[i];
-}
-
-void PrefilterTree::Add(Prefilter* prefilter) {
-  if (compiled_) {
-    LOG(DFATAL) << "Add called after Compile.";
-    return;
-  }
-  if (prefilter != NULL && !KeepNode(prefilter)) {
-    delete prefilter;
-    prefilter = NULL;
-  }
-
-  prefilter_vec_.push_back(prefilter);
-}
-
-void PrefilterTree::Compile(std::vector<std::string>* atom_vec) {
-  if (compiled_) {
-    LOG(DFATAL) << "Compile called already.";
-    return;
-  }
-
-  // Some legacy users of PrefilterTree call Compile() before
-  // adding any regexps and expect Compile() to have no effect.
-  if (prefilter_vec_.empty())
-    return;
-
-  compiled_ = true;
-
-  NodeMap nodes;
-  AssignUniqueIds(&nodes, atom_vec);
-}
-
-Prefilter* PrefilterTree::CanonicalNode(NodeMap* nodes, Prefilter* node) {
-  std::string node_string = NodeString(node);
-  NodeMap::iterator iter = nodes->find(node_string);
-  if (iter == nodes->end())
-    return NULL;
-  return (*iter).second;
-}
-
-std::string PrefilterTree::NodeString(Prefilter* node) const {
-  // Adding the operation disambiguates AND/OR/atom nodes.
-  std::string s = StringPrintf("%d", node->op()) + ":";
-  if (node->op() == Prefilter::ATOM) {
-    s += node->atom();
-  } else {
-    for (size_t i = 0; i < node->subs()->size(); i++) {
-      if (i > 0)
-        s += ',';
-      s += StringPrintf("%d", (*node->subs())[i]->unique_id());
-    }
-  }
-  return s;
-}
-
-bool PrefilterTree::KeepNode(Prefilter* node) const {
-  if (node == NULL)
-    return false;
-
-  switch (node->op()) {
-    default:
-      LOG(DFATAL) << "Unexpected op in KeepNode: " << node->op();
-      return false;
-
-    case Prefilter::ALL:
-    case Prefilter::NONE:
-      return false;
-
-    case Prefilter::ATOM:
-      return node->atom().size() >= static_cast<size_t>(min_atom_len_);
-
-    case Prefilter::AND: {
-      int j = 0;
-      std::vector<Prefilter*>* subs = node->subs();
-      for (size_t i = 0; i < subs->size(); i++)
-        if (KeepNode((*subs)[i]))
-          (*subs)[j++] = (*subs)[i];
-        else
-          delete (*subs)[i];
-
-      subs->resize(j);
-      return j > 0;
-    }
-
-    case Prefilter::OR:
-      for (size_t i = 0; i < node->subs()->size(); i++)
-        if (!KeepNode((*node->subs())[i]))
-          return false;
-      return true;
-  }
-}
-
-void PrefilterTree::AssignUniqueIds(NodeMap* nodes,
-                                    std::vector<std::string>* atom_vec) {
-  atom_vec->clear();
-
-  // Build vector of all filter nodes, sorted topologically
-  // from top to bottom in v.
-  std::vector<Prefilter*> v;
-
-  // Add the top level nodes of each regexp prefilter.
-  for (size_t i = 0; i < prefilter_vec_.size(); i++) {
-    Prefilter* f = prefilter_vec_[i];
-    if (f == NULL)
-      unfiltered_.push_back(static_cast<int>(i));
-
-    // We push NULL also on to v, so that we maintain the
-    // mapping of index==regexpid for level=0 prefilter nodes.
-    v.push_back(f);
-  }
-
-  // Now add all the descendant nodes.
-  for (size_t i = 0; i < v.size(); i++) {
-    Prefilter* f = v[i];
-    if (f == NULL)
-      continue;
-    if (f->op() == Prefilter::AND || f->op() == Prefilter::OR) {
-      const std::vector<Prefilter*>& subs = *f->subs();
-      for (size_t j = 0; j < subs.size(); j++)
-        v.push_back(subs[j]);
-    }
-  }
-
-  // Identify unique nodes.
-  int unique_id = 0;
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter *node = v[i];
-    if (node == NULL)
-      continue;
-    node->set_unique_id(-1);
-    Prefilter* canonical = CanonicalNode(nodes, node);
-    if (canonical == NULL) {
-      // Any further nodes that have the same node string
-      // will find this node as the canonical node.
-      nodes->emplace(NodeString(node), node);
-      if (node->op() == Prefilter::ATOM) {
-        atom_vec->push_back(node->atom());
-        atom_index_to_id_.push_back(unique_id);
-      }
-      node->set_unique_id(unique_id++);
-    } else {
-      node->set_unique_id(canonical->unique_id());
-    }
-  }
-  entries_.resize(unique_id);
-
-  // Fill the entries.
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter* prefilter = v[i];
-    if (prefilter == NULL)
-      continue;
-    if (CanonicalNode(nodes, prefilter) != prefilter)
-      continue;
-    int id = prefilter->unique_id();
-    switch (prefilter->op()) {
-      default:
-        LOG(DFATAL) << "Unexpected op: " << prefilter->op();
-        return;
-
-      case Prefilter::ATOM:
-        entries_[id].propagate_up_at_count = 1;
-        break;
-
-      case Prefilter::OR:
-      case Prefilter::AND: {
-        // For each child, we append our id to the child's list of
-        // parent ids... unless we happen to have done so already.
-        // The number of appends is the number of unique children,
-        // which allows correct upward propagation from AND nodes.
-        int up_count = 0;
-        for (size_t j = 0; j < prefilter->subs()->size(); j++) {
-          int child_id = (*prefilter->subs())[j]->unique_id();
-          std::vector<int>& parents = entries_[child_id].parents;
-          if (parents.empty() || parents.back() != id) {
-            parents.push_back(id);
-            up_count++;
-          }
-        }
-        entries_[id].propagate_up_at_count =
-            prefilter->op() == Prefilter::AND ? up_count : 1;
-        break;
-      }
-    }
-  }
-
-  // For top level nodes, populate regexp id.
-  for (size_t i = 0; i < prefilter_vec_.size(); i++) {
-    if (prefilter_vec_[i] == NULL)
-      continue;
-    int id = CanonicalNode(nodes, prefilter_vec_[i])->unique_id();
-    DCHECK_LE(0, id);
-    Entry* entry = &entries_[id];
-    entry->regexps.push_back(static_cast<int>(i));
-  }
-
-  // Lastly, using probability-based heuristics, we identify nodes
-  // that trigger too many parents and then we try to prune edges.
-  // We use logarithms below to avoid the likelihood of underflow.
-  double log_num_regexps = std::log(prefilter_vec_.size() - unfiltered_.size());
-  // Hoisted this above the loop so that we don't thrash the heap.
-  std::vector<std::pair<size_t, int>> entries_by_num_edges;
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter* prefilter = v[i];
-    // Pruning applies only to AND nodes because it "just" reduces
-    // precision; applied to OR nodes, it would break correctness.
-    if (prefilter == NULL || prefilter->op() != Prefilter::AND)
-      continue;
-    if (CanonicalNode(nodes, prefilter) != prefilter)
-      continue;
-    int id = prefilter->unique_id();
-
-    // Sort the current node's children by the numbers of parents.
-    entries_by_num_edges.clear();
-    for (size_t j = 0; j < prefilter->subs()->size(); j++) {
-      int child_id = (*prefilter->subs())[j]->unique_id();
-      const std::vector<int>& parents = entries_[child_id].parents;
-      entries_by_num_edges.emplace_back(parents.size(), child_id);
-    }
-    std::stable_sort(entries_by_num_edges.begin(), entries_by_num_edges.end());
-
-    // A running estimate of how many regexps will be triggered by
-    // pruning the remaining children's edges to the current node.
-    // Our nominal target is one, so the threshold is log(1) == 0;
-    // pruning occurs iff the child has more than nine edges left.
-    double log_num_triggered = log_num_regexps;
-    for (const auto& pair : entries_by_num_edges) {
-      int child_id = pair.second;
-      std::vector<int>& parents = entries_[child_id].parents;
-      if (log_num_triggered > 0.) {
-        log_num_triggered += std::log(parents.size());
-        log_num_triggered -= log_num_regexps;
-      } else if (parents.size() > 9) {
-        auto it = std::find(parents.begin(), parents.end(), id);
-        if (it != parents.end()) {
-          parents.erase(it);
-          entries_[id].propagate_up_at_count--;
-        }
-      }
-    }
-  }
-}
-
-// Functions for triggering during search.
-void PrefilterTree::RegexpsGivenStrings(
-    const std::vector<int>& matched_atoms,
-    std::vector<int>* regexps) const {
-  regexps->clear();
-  if (!compiled_) {
-    // Some legacy users of PrefilterTree call Compile() before
-    // adding any regexps and expect Compile() to have no effect.
-    // This kludge is a counterpart to that kludge.
-    if (prefilter_vec_.empty())
-      return;
-
-    LOG(ERROR) << "RegexpsGivenStrings called before Compile.";
-    for (size_t i = 0; i < prefilter_vec_.size(); i++)
-      regexps->push_back(static_cast<int>(i));
-  } else {
-    IntMap regexps_map(static_cast<int>(prefilter_vec_.size()));
-    std::vector<int> matched_atom_ids;
-    for (size_t j = 0; j < matched_atoms.size(); j++)
-      matched_atom_ids.push_back(atom_index_to_id_[matched_atoms[j]]);
-    PropagateMatch(matched_atom_ids, &regexps_map);
-    for (IntMap::iterator it = regexps_map.begin();
-         it != regexps_map.end();
-         ++it)
-      regexps->push_back(it->index());
-
-    regexps->insert(regexps->end(), unfiltered_.begin(), unfiltered_.end());
-  }
-  std::sort(regexps->begin(), regexps->end());
-}
-
-void PrefilterTree::PropagateMatch(const std::vector<int>& atom_ids,
-                                   IntMap* regexps) const {
-  IntMap count(static_cast<int>(entries_.size()));
-  IntMap work(static_cast<int>(entries_.size()));
-  for (size_t i = 0; i < atom_ids.size(); i++)
-    work.set(atom_ids[i], 1);
-  for (IntMap::iterator it = work.begin(); it != work.end(); ++it) {
-    const Entry& entry = entries_[it->index()];
-    // Record regexps triggered.
-    for (size_t i = 0; i < entry.regexps.size(); i++)
-      regexps->set(entry.regexps[i], 1);
-    int c;
-    // Pass trigger up to parents.
-    for (int j : entry.parents) {
-      const Entry& parent = entries_[j];
-      // Delay until all the children have succeeded.
-      if (parent.propagate_up_at_count > 1) {
-        if (count.has_index(j)) {
-          c = count.get_existing(j) + 1;
-          count.set_existing(j, c);
-        } else {
-          c = 1;
-          count.set_new(j, c);
-        }
-        if (c < parent.propagate_up_at_count)
-          continue;
-      }
-      // Trigger the parent.
-      work.set(j, 1);
-    }
-  }
-}
-
-// Debugging help.
-void PrefilterTree::PrintPrefilter(int regexpid) {
-  LOG(ERROR) << DebugNodeString(prefilter_vec_[regexpid]);
-}
-
-void PrefilterTree::PrintDebugInfo(NodeMap* nodes) {
-  LOG(ERROR) << "#Unique Atoms: " << atom_index_to_id_.size();
-  LOG(ERROR) << "#Unique Nodes: " << entries_.size();
-
-  for (size_t i = 0; i < entries_.size(); i++) {
-    const std::vector<int>& parents = entries_[i].parents;
-    const std::vector<int>& regexps = entries_[i].regexps;
-    LOG(ERROR) << "EntryId: " << i
-               << " N: " << parents.size() << " R: " << regexps.size();
-    for (int parent : parents)
-      LOG(ERROR) << parent;
-  }
-  LOG(ERROR) << "Map:";
-  for (NodeMap::const_iterator iter = nodes->begin();
-       iter != nodes->end(); ++iter)
-    LOG(ERROR) << "NodeId: " << (*iter).second->unique_id()
-               << " Str: " << (*iter).first;
-}
-
-std::string PrefilterTree::DebugNodeString(Prefilter* node) const {
-  std::string node_string = "";
-  if (node->op() == Prefilter::ATOM) {
-    DCHECK(!node->atom().empty());
-    node_string += node->atom();
-  } else {
-    // Adding the operation disambiguates AND and OR nodes.
-    node_string +=  node->op() == Prefilter::AND ? "AND" : "OR";
-    node_string += "(";
-    for (size_t i = 0; i < node->subs()->size(); i++) {
-      if (i > 0)
-        node_string += ',';
-      node_string += StringPrintf("%d", (*node->subs())[i]->unique_id());
-      node_string += ":";
-      node_string += DebugNodeString((*node->subs())[i]);
-    }
-    node_string += ")";
-  }
-  return node_string;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/prefilter_tree.h b/src/duckdb/third_party/re2/re2/prefilter_tree.h
deleted file mode 100644
index 12624a837..000000000
--- a/src/duckdb/third_party/re2/re2/prefilter_tree.h
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_PREFILTER_TREE_H_
-#define RE2_PREFILTER_TREE_H_
-
-// The PrefilterTree class is used to form an AND-OR tree of strings
-// that would trigger each regexp. The 'prefilter' of each regexp is
-// added to PrefilterTree, and then PrefilterTree is used to find all
-// the unique strings across the prefilters. During search, by using
-// matches from a string matching engine, PrefilterTree deduces the
-// set of regexps that are to be triggered. The 'string matching
-// engine' itself is outside of this class, and the caller can use any
-// favorite engine. PrefilterTree provides a set of strings (called
-// atoms) that the user of this class should use to do the string
-// matching.
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "util/util.h"
-#include "re2/prefilter.h"
-#include "re2/sparse_array.h"
-
-namespace duckdb_re2 {
-
-class PrefilterTree {
- public:
-  PrefilterTree();
-  explicit PrefilterTree(int min_atom_len);
-  ~PrefilterTree();
-
-  // Adds the prefilter for the next regexp. Note that we assume that
-  // Add called sequentially for all regexps. All Add calls
-  // must precede Compile.
-  void Add(Prefilter* prefilter);
-
-  // The Compile returns a vector of string in atom_vec.
-  // Call this after all the prefilters are added through Add.
-  // No calls to Add after Compile are allowed.
-  // The caller should use the returned set of strings to do string matching.
-  // Each time a string matches, the corresponding index then has to be
-  // and passed to RegexpsGivenStrings below.
-  void Compile(std::vector<std::string>* atom_vec);
-
-  // Given the indices of the atoms that matched, returns the indexes
-  // of regexps that should be searched.  The matched_atoms should
-  // contain all the ids of string atoms that were found to match the
-  // content. The caller can use any string match engine to perform
-  // this function. This function is thread safe.
-  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                           std::vector<int>* regexps) const;
-
-  // Print debug prefilter. Also prints unique ids associated with
-  // nodes of the prefilter of the regexp.
-  void PrintPrefilter(int regexpid);
-
- private:
-  typedef SparseArray<int> IntMap;
-  // TODO(junyer): Use std::unordered_set<Prefilter*> instead?
-  // It should be trivial to get rid of the stringification...
-  typedef std::map<std::string, Prefilter*> NodeMap;
-
-  // Each unique node has a corresponding Entry that helps in
-  // passing the matching trigger information along the tree.
-  struct Entry {
-   public:
-    // How many children should match before this node triggers the
-    // parent. For an atom and an OR node, this is 1 and for an AND
-    // node, it is the number of unique children.
-    int propagate_up_at_count;
-
-    // When this node is ready to trigger the parent, what are the indices
-    // of the parent nodes to trigger. The reason there may be more than
-    // one is because of sharing. For example (abc | def) and (xyz | def)
-    // are two different nodes, but they share the atom 'def'. So when
-    // 'def' matches, it triggers two parents, corresponding to the two
-    // different OR nodes.
-    std::vector<int> parents;
-
-    // When this node is ready to trigger the parent, what are the
-    // regexps that are triggered.
-    std::vector<int> regexps;
-  };
-
-  // Returns true if the prefilter node should be kept.
-  bool KeepNode(Prefilter* node) const;
-
-  // This function assigns unique ids to various parts of the
-  // prefilter, by looking at if these nodes are already in the
-  // PrefilterTree.
-  void AssignUniqueIds(NodeMap* nodes, std::vector<std::string>* atom_vec);
-
-  // Given the matching atoms, find the regexps to be triggered.
-  void PropagateMatch(const std::vector<int>& atom_ids,
-                      IntMap* regexps) const;
-
-  // Returns the prefilter node that has the same NodeString as this
-  // node. For the canonical node, returns node.
-  Prefilter* CanonicalNode(NodeMap* nodes, Prefilter* node);
-
-  // A string that uniquely identifies the node. Assumes that the
-  // children of node has already been assigned unique ids.
-  std::string NodeString(Prefilter* node) const;
-
-  // Recursively constructs a readable prefilter string.
-  std::string DebugNodeString(Prefilter* node) const;
-
-  // Used for debugging.
-  void PrintDebugInfo(NodeMap* nodes);
-
-  // These are all the nodes formed by Compile. Essentially, there is
-  // one node for each unique atom and each unique AND/OR node.
-  std::vector<Entry> entries_;
-
-  // indices of regexps that always pass through the filter (since we
-  // found no required literals in these regexps).
-  std::vector<int> unfiltered_;
-
-  // vector of Prefilter for all regexps.
-  std::vector<Prefilter*> prefilter_vec_;
-
-  // Atom index in returned strings to entry id mapping.
-  std::vector<int> atom_index_to_id_;
-
-  // Has the prefilter tree been compiled.
-  bool compiled_;
-
-  // Strings less than this length are not stored as atoms.
-  const int min_atom_len_;
-
-  PrefilterTree(const PrefilterTree&) = delete;
-  PrefilterTree& operator=(const PrefilterTree&) = delete;
-};
-
-}  // namespace
-
-#endif  // RE2_PREFILTER_TREE_H_
diff --git a/src/duckdb/third_party/re2/re2/prog.cc b/src/duckdb/third_party/re2/re2/prog.cc
deleted file mode 100644
index 716b6f3ee..000000000
--- a/src/duckdb/third_party/re2/re2/prog.cc
+++ /dev/null
@@ -1,1175 +0,0 @@
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Compiled regular expression representation.
-// Tested by compile_test.cc
-
-#include "re2/prog.h"
-
-#if defined(__AVX2__)
-#include <immintrin.h>
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-#endif
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "re2/bitmap256.h"
-#include "re2/stringpiece.h"
-
-namespace duckdb_re2 {
-
-// Constructors per Inst opcode
-
-void Prog::Inst::InitAlt(uint32_t out, uint32_t out1) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstAlt);
-  out1_ = out1;
-}
-
-void Prog::Inst::InitByteRange(int lo, int hi, int foldcase, uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstByteRange);
-  byte_range.lo_ = lo & 0xFF;
-  byte_range.hi_ = hi & 0xFF;
-  byte_range.hint_foldcase_ = foldcase&1;
-}
-
-void Prog::Inst::InitCapture(int cap, uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstCapture);
-  cap_ = cap;
-}
-
-void Prog::Inst::InitEmptyWidth(EmptyOp empty, uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstEmptyWidth);
-  empty_ = empty;
-}
-
-void Prog::Inst::InitMatch(int32_t id) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_opcode(kInstMatch);
-  match_id_ = id;
-}
-
-void Prog::Inst::InitNop(uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_opcode(kInstNop);
-}
-
-void Prog::Inst::InitFail() {
-  DCHECK_EQ(out_opcode_, 0);
-  set_opcode(kInstFail);
-}
-
-std::string Prog::Inst::Dump() {
-  switch (opcode()) {
-    default:
-      return StringPrintf("opcode %d", static_cast<int>(opcode()));
-
-    case kInstAlt:
-      return StringPrintf("alt -> %d | %d", out(), out1_);
-
-    case kInstAltMatch:
-      return StringPrintf("altmatch -> %d | %d", out(), out1_);
-
-    case kInstByteRange:
-      return StringPrintf("byte%s [%02x-%02x] %d -> %d",
-                          foldcase() ? "/i" : "",
-		                    byte_range.lo_, byte_range.hi_, hint(), out());
-
-    case kInstCapture:
-      return StringPrintf("capture %d -> %d", cap_, out());
-
-    case kInstEmptyWidth:
-      return StringPrintf("emptywidth %#x -> %d",
-                          static_cast<int>(empty_), out());
-
-    case kInstMatch:
-      return StringPrintf("match! %d", match_id());
-
-    case kInstNop:
-      return StringPrintf("nop -> %d", out());
-
-    case kInstFail:
-      return StringPrintf("fail");
-  }
-}
-
-Prog::Prog()
-  : anchor_start_(false),
-    anchor_end_(false),
-    reversed_(false),
-    did_flatten_(false),
-    did_onepass_(false),
-    start_(0),
-    start_unanchored_(0),
-    size_(0),
-    bytemap_range_(0),
-    prefix_foldcase_(false),
-    prefix_size_(0),
-    list_count_(0),
-    bit_state_text_max_size_(0),
-    dfa_mem_(0),
-    dfa_first_(NULL),
-    dfa_longest_(NULL) {
-}
-
-Prog::~Prog() {
-  DeleteDFA(dfa_longest_);
-  DeleteDFA(dfa_first_);
-  if (prefix_foldcase_)
-    delete[] prefix_dfa_;
-}
-
-typedef SparseSet Workq;
-
-static inline void AddToQueue(Workq* q, int id) {
-  if (id != 0)
-    q->insert(id);
-}
-
-static std::string ProgToString(Prog* prog, Workq* q) {
-  std::string s;
-  for (Workq::iterator i = q->begin(); i != q->end(); ++i) {
-    int id = *i;
-    Prog::Inst* ip = prog->inst(id);
-    s += StringPrintf("%d. %s\n", id, ip->Dump().c_str());
-    AddToQueue(q, ip->out());
-    if (ip->opcode() == kInstAlt || ip->opcode() == kInstAltMatch)
-      AddToQueue(q, ip->out1());
-  }
-  return s;
-}
-
-static std::string FlattenedProgToString(Prog* prog, int start) {
-  std::string s;
-  for (int id = start; id < prog->size(); id++) {
-    Prog::Inst* ip = prog->inst(id);
-    if (ip->last())
-      s += StringPrintf("%d. %s\n", id, ip->Dump().c_str());
-    else
-      s += StringPrintf("%d+ %s\n", id, ip->Dump().c_str());
-  }
-  return s;
-}
-
-std::string Prog::Dump() {
-  if (did_flatten_)
-    return FlattenedProgToString(this, start_);
-
-  Workq q(size_);
-  AddToQueue(&q, start_);
-  return ProgToString(this, &q);
-}
-
-std::string Prog::DumpUnanchored() {
-  if (did_flatten_)
-    return FlattenedProgToString(this, start_unanchored_);
-
-  Workq q(size_);
-  AddToQueue(&q, start_unanchored_);
-  return ProgToString(this, &q);
-}
-
-std::string Prog::DumpByteMap() {
-  std::string map;
-  for (int c = 0; c < 256; c++) {
-    int b = bytemap_[c];
-    int lo = c;
-    while (c < 256-1 && bytemap_[c+1] == b)
-      c++;
-    int hi = c;
-    map += StringPrintf("[%02x-%02x] -> %d\n", lo, hi, b);
-  }
-  return map;
-}
-
-// Is ip a guaranteed match at end of text, perhaps after some capturing?
-static bool IsMatch(Prog* prog, Prog::Inst* ip) {
-  for (;;) {
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "Unexpected opcode in IsMatch: " << ip->opcode();
-        return false;
-
-      case kInstAlt:
-      case kInstAltMatch:
-      case kInstByteRange:
-      case kInstFail:
-      case kInstEmptyWidth:
-        return false;
-
-      case kInstCapture:
-      case kInstNop:
-        ip = prog->inst(ip->out());
-        break;
-
-      case kInstMatch:
-        return true;
-    }
-  }
-}
-
-// Peep-hole optimizer.
-void Prog::Optimize() {
-  Workq q(size_);
-
-  // Eliminate nops.  Most are taken out during compilation
-  // but a few are hard to avoid.
-  q.clear();
-  AddToQueue(&q, start_);
-  for (Workq::iterator i = q.begin(); i != q.end(); ++i) {
-    int id = *i;
-
-    Inst* ip = inst(id);
-    int j = ip->out();
-    Inst* jp;
-    while (j != 0 && (jp=inst(j))->opcode() == kInstNop) {
-      j = jp->out();
-    }
-    ip->set_out(j);
-    AddToQueue(&q, ip->out());
-
-    if (ip->opcode() == kInstAlt) {
-      j = ip->out1();
-      while (j != 0 && (jp=inst(j))->opcode() == kInstNop) {
-        j = jp->out();
-      }
-      ip->out1_ = j;
-      AddToQueue(&q, ip->out1());
-    }
-  }
-
-  // Insert kInstAltMatch instructions
-  // Look for
-  //   ip: Alt -> j | k
-  //	  j: ByteRange [00-FF] -> ip
-  //    k: Match
-  // or the reverse (the above is the greedy one).
-  // Rewrite Alt to AltMatch.
-  q.clear();
-  AddToQueue(&q, start_);
-  for (Workq::iterator i = q.begin(); i != q.end(); ++i) {
-    int id = *i;
-    Inst* ip = inst(id);
-    AddToQueue(&q, ip->out());
-    if (ip->opcode() == kInstAlt)
-      AddToQueue(&q, ip->out1());
-
-    if (ip->opcode() == kInstAlt) {
-      Inst* j = inst(ip->out());
-      Inst* k = inst(ip->out1());
-      if (j->opcode() == kInstByteRange && j->out() == id &&
-          j->lo() == 0x00 && j->hi() == 0xFF &&
-          IsMatch(this, k)) {
-        ip->set_opcode(kInstAltMatch);
-        continue;
-      }
-      if (IsMatch(this, j) &&
-          k->opcode() == kInstByteRange && k->out() == id &&
-          k->lo() == 0x00 && k->hi() == 0xFF) {
-        ip->set_opcode(kInstAltMatch);
-      }
-    }
-  }
-}
-
-uint32_t Prog::EmptyFlags(const StringPiece& text, const char* p) {
-  int flags = 0;
-
-  // ^ and \A
-  if (p == text.data())
-    flags |= kEmptyBeginText | kEmptyBeginLine;
-  else if (p[-1] == '\n')
-    flags |= kEmptyBeginLine;
-
-  // $ and \z
-  if (p == text.data() + text.size())
-    flags |= kEmptyEndText | kEmptyEndLine;
-  else if (p < text.data() + text.size() && p[0] == '\n')
-    flags |= kEmptyEndLine;
-
-  // \b and \B
-  if (p == text.data() && p == text.data() + text.size()) {
-    // no word boundary here
-  } else if (p == text.data()) {
-    if (IsWordChar(p[0]))
-      flags |= kEmptyWordBoundary;
-  } else if (p == text.data() + text.size()) {
-    if (IsWordChar(p[-1]))
-      flags |= kEmptyWordBoundary;
-  } else {
-    if (IsWordChar(p[-1]) != IsWordChar(p[0]))
-      flags |= kEmptyWordBoundary;
-  }
-  if (!(flags & kEmptyWordBoundary))
-    flags |= kEmptyNonWordBoundary;
-
-  return flags;
-}
-
-// ByteMapBuilder implements a coloring algorithm.
-//
-// The first phase is a series of "mark and merge" batches: we mark one or more
-// [lo-hi] ranges, then merge them into our internal state. Batching is not for
-// performance; rather, it means that the ranges are treated indistinguishably.
-//
-// Internally, the ranges are represented using a bitmap that stores the splits
-// and a vector that stores the colors; both of them are indexed by the ranges'
-// last bytes. Thus, in order to merge a [lo-hi] range, we split at lo-1 and at
-// hi (if not already split), then recolor each range in between. The color map
-// (i.e. from the old color to the new color) is maintained for the lifetime of
-// the batch and so underpins this somewhat obscure approach to set operations.
-//
-// The second phase builds the bytemap from our internal state: we recolor each
-// range, then store the new color (which is now the byte class) in each of the
-// corresponding array elements. Finally, we output the number of byte classes.
-class ByteMapBuilder {
- public:
-  ByteMapBuilder() {
-    // Initial state: the [0-255] range has color 256.
-    // This will avoid problems during the second phase,
-    // in which we assign byte classes numbered from 0.
-    splits_.Set(255);
-    colors_[255] = 256;
-    nextcolor_ = 257;
-  }
-
-  void Mark(int lo, int hi);
-  void Merge();
-  void Build(uint8_t* bytemap, int* bytemap_range);
-
- private:
-  int Recolor(int oldcolor);
-
-  Bitmap256 splits_;
-  int colors_[256];
-  int nextcolor_;
-  std::vector<std::pair<int, int>> colormap_;
-  std::vector<std::pair<int, int>> ranges_;
-
-  ByteMapBuilder(const ByteMapBuilder&) = delete;
-  ByteMapBuilder& operator=(const ByteMapBuilder&) = delete;
-};
-
-void ByteMapBuilder::Mark(int lo, int hi) {
-  DCHECK_GE(lo, 0);
-  DCHECK_GE(hi, 0);
-  DCHECK_LE(lo, 255);
-  DCHECK_LE(hi, 255);
-  DCHECK_LE(lo, hi);
-
-  // Ignore any [0-255] ranges. They cause us to recolor every range, which
-  // has no effect on the eventual result and is therefore a waste of time.
-  if (lo == 0 && hi == 255)
-    return;
-
-  ranges_.emplace_back(lo, hi);
-}
-
-void ByteMapBuilder::Merge() {
-  for (std::vector<std::pair<int, int>>::const_iterator it = ranges_.begin();
-       it != ranges_.end();
-       ++it) {
-    int lo = it->first-1;
-    int hi = it->second;
-
-    if (0 <= lo && !splits_.Test(lo)) {
-      splits_.Set(lo);
-      int next = splits_.FindNextSetBit(lo+1);
-      colors_[lo] = colors_[next];
-    }
-    if (!splits_.Test(hi)) {
-      splits_.Set(hi);
-      int next = splits_.FindNextSetBit(hi+1);
-      colors_[hi] = colors_[next];
-    }
-
-    int c = lo+1;
-    while (c < 256) {
-      int next = splits_.FindNextSetBit(c);
-      colors_[next] = Recolor(colors_[next]);
-      if (next == hi)
-        break;
-      c = next+1;
-    }
-  }
-  colormap_.clear();
-  ranges_.clear();
-}
-
-void ByteMapBuilder::Build(uint8_t* bytemap, int* bytemap_range) {
-  // Assign byte classes numbered from 0.
-  nextcolor_ = 0;
-
-  int c = 0;
-  while (c < 256) {
-    int next = splits_.FindNextSetBit(c);
-    uint8_t b = static_cast<uint8_t>(Recolor(colors_[next]));
-    while (c <= next) {
-      bytemap[c] = b;
-      c++;
-    }
-  }
-
-  *bytemap_range = nextcolor_;
-}
-
-int ByteMapBuilder::Recolor(int oldcolor) {
-  // Yes, this is a linear search. There can be at most 256
-  // colors and there will typically be far fewer than that.
-  // Also, we need to consider keys *and* values in order to
-  // avoid recoloring a given range more than once per batch.
-  std::vector<std::pair<int, int>>::const_iterator it =
-      std::find_if(colormap_.begin(), colormap_.end(),
-                   [=](const std::pair<int, int>& kv) -> bool {
-                     return kv.first == oldcolor || kv.second == oldcolor;
-                   });
-  if (it != colormap_.end())
-    return it->second;
-  int newcolor = nextcolor_;
-  nextcolor_++;
-  colormap_.emplace_back(oldcolor, newcolor);
-  return newcolor;
-}
-
-void Prog::ComputeByteMap() {
-  // Fill in bytemap with byte classes for the program.
-  // Ranges of bytes that are treated indistinguishably
-  // will be mapped to a single byte class.
-  ByteMapBuilder builder;
-
-  // Don't repeat the work for ^ and $.
-  bool marked_line_boundaries = false;
-  // Don't repeat the work for \b and \B.
-  bool marked_word_boundaries = false;
-
-  for (int id = 0; id < size(); id++) {
-    Inst* ip = inst(id);
-    if (ip->opcode() == kInstByteRange) {
-      int lo = ip->lo();
-      int hi = ip->hi();
-      builder.Mark(lo, hi);
-      if (ip->foldcase() && lo <= 'z' && hi >= 'a') {
-        int foldlo = lo;
-        int foldhi = hi;
-        if (foldlo < 'a')
-          foldlo = 'a';
-        if (foldhi > 'z')
-          foldhi = 'z';
-        if (foldlo <= foldhi) {
-          foldlo += 'A' - 'a';
-          foldhi += 'A' - 'a';
-          builder.Mark(foldlo, foldhi);
-        }
-      }
-      // If this Inst is not the last Inst in its list AND the next Inst is
-      // also a ByteRange AND the Insts have the same out, defer the merge.
-      if (!ip->last() &&
-          inst(id+1)->opcode() == kInstByteRange &&
-          ip->out() == inst(id+1)->out())
-        continue;
-      builder.Merge();
-    } else if (ip->opcode() == kInstEmptyWidth) {
-      if (ip->empty() & (kEmptyBeginLine|kEmptyEndLine) &&
-          !marked_line_boundaries) {
-        builder.Mark('\n', '\n');
-        builder.Merge();
-        marked_line_boundaries = true;
-      }
-      if (ip->empty() & (kEmptyWordBoundary|kEmptyNonWordBoundary) &&
-          !marked_word_boundaries) {
-        // We require two batches here: the first for ranges that are word
-        // characters, the second for ranges that are not word characters.
-        for (bool isword : {true, false}) {
-          int j;
-          for (int i = 0; i < 256; i = j) {
-            for (j = i + 1; j < 256 &&
-                            Prog::IsWordChar(static_cast<uint8_t>(i)) ==
-                                Prog::IsWordChar(static_cast<uint8_t>(j));
-                 j++)
-              ;
-            if (Prog::IsWordChar(static_cast<uint8_t>(i)) == isword)
-              builder.Mark(i, j - 1);
-          }
-          builder.Merge();
-        }
-        marked_word_boundaries = true;
-      }
-    }
-  }
-
-  builder.Build(bytemap_, &bytemap_range_);
-
-  if ((0)) {  // For debugging, use trivial bytemap.
-    LOG(ERROR) << "Using trivial bytemap.";
-    for (int i = 0; i < 256; i++)
-      bytemap_[i] = static_cast<uint8_t>(i);
-    bytemap_range_ = 256;
-  }
-}
-
-// Prog::Flatten() implements a graph rewriting algorithm.
-//
-// The overall process is similar to epsilon removal, but retains some epsilon
-// transitions: those from Capture and EmptyWidth instructions; and those from
-// nullable subexpressions. (The latter avoids quadratic blowup in transitions
-// in the worst case.) It might be best thought of as Alt instruction elision.
-//
-// In conceptual terms, it divides the Prog into "trees" of instructions, then
-// traverses the "trees" in order to produce "lists" of instructions. A "tree"
-// is one or more instructions that grow from one "root" instruction to one or
-// more "leaf" instructions; if a "tree" has exactly one instruction, then the
-// "root" is also the "leaf". In most cases, a "root" is the successor of some
-// "leaf" (i.e. the "leaf" instruction's out() returns the "root" instruction)
-// and is considered a "successor root". A "leaf" can be a ByteRange, Capture,
-// EmptyWidth or Match instruction. However, this is insufficient for handling
-// nested nullable subexpressions correctly, so in some cases, a "root" is the
-// dominator of the instructions reachable from some "successor root" (i.e. it
-// has an unreachable predecessor) and is considered a "dominator root". Since
-// only Alt instructions can be "dominator roots" (other instructions would be
-// "leaves"), only Alt instructions are required to be marked as predecessors.
-//
-// Dividing the Prog into "trees" comprises two passes: marking the "successor
-// roots" and the predecessors; and marking the "dominator roots". Sorting the
-// "successor roots" by their bytecode offsets enables iteration in order from
-// greatest to least during the second pass; by working backwards in this case
-// and flooding the graph no further than "leaves" and already marked "roots",
-// it becomes possible to mark "dominator roots" without doing excessive work.
-//
-// Traversing the "trees" is just iterating over the "roots" in order of their
-// marking and flooding the graph no further than "leaves" and "roots". When a
-// "leaf" is reached, the instruction is copied with its successor remapped to
-// its "root" number. When a "root" is reached, a Nop instruction is generated
-// with its successor remapped similarly. As each "list" is produced, its last
-// instruction is marked as such. After all of the "lists" have been produced,
-// a pass over their instructions remaps their successors to bytecode offsets.
-void Prog::Flatten() {
-  if (did_flatten_)
-    return;
-  did_flatten_ = true;
-
-  // Scratch structures. It's important that these are reused by functions
-  // that we call in loops because they would thrash the heap otherwise.
-  SparseSet reachable(size());
-  std::vector<int> stk;
-  stk.reserve(size());
-
-  // First pass: Marks "successor roots" and predecessors.
-  // Builds the mapping from inst-ids to root-ids.
-  SparseArray<int> rootmap(size());
-  SparseArray<int> predmap(size());
-  std::vector<std::vector<int>> predvec;
-  MarkSuccessors(&rootmap, &predmap, &predvec, &reachable, &stk);
-
-  // Second pass: Marks "dominator roots".
-  SparseArray<int> sorted(rootmap);
-  std::sort(sorted.begin(), sorted.end(), sorted.less);
-  for (SparseArray<int>::const_iterator i = sorted.end() - 1;
-       i != sorted.begin();
-       --i) {
-    if (i->index() != start_unanchored() && i->index() != start())
-      MarkDominator(i->index(), &rootmap, &predmap, &predvec, &reachable, &stk);
-  }
-
-  // Third pass: Emits "lists". Remaps outs to root-ids.
-  // Builds the mapping from root-ids to flat-ids.
-  std::vector<int> flatmap(rootmap.size());
-  std::vector<Inst> flat;
-  flat.reserve(size());
-  for (SparseArray<int>::const_iterator i = rootmap.begin();
-       i != rootmap.end();
-       ++i) {
-    flatmap[i->value()] = static_cast<int>(flat.size());
-    EmitList(i->index(), &rootmap, &flat, &reachable, &stk);
-    flat.back().set_last();
-    // We have the bounds of the "list", so this is the
-    // most convenient point at which to compute hints.
-    ComputeHints(&flat, flatmap[i->value()], static_cast<int>(flat.size()));
-  }
-
-  list_count_ = static_cast<int>(flatmap.size());
-  for (int i = 0; i < kNumInst; i++)
-    inst_count_[i] = 0;
-
-  // Fourth pass: Remaps outs to flat-ids.
-  // Counts instructions by opcode.
-  for (int id = 0; id < static_cast<int>(flat.size()); id++) {
-    Inst* ip = &flat[id];
-    if (ip->opcode() != kInstAltMatch)  // handled in EmitList()
-      ip->set_out(flatmap[ip->out()]);
-    inst_count_[ip->opcode()]++;
-  }
-
-#if !defined(NDEBUG)
-  // Address a `-Wunused-but-set-variable' warning from Clang 13.x.
-  size_t total = 0;
-  for (int i = 0; i < kNumInst; i++)
-    total += inst_count_[i];
-  CHECK_EQ(total, flat.size());
-#endif
-
-  // Remap start_unanchored and start.
-  if (start_unanchored() == 0) {
-    DCHECK_EQ(start(), 0);
-  } else if (start_unanchored() == start()) {
-    set_start_unanchored(flatmap[1]);
-    set_start(flatmap[1]);
-  } else {
-    set_start_unanchored(flatmap[1]);
-    set_start(flatmap[2]);
-  }
-
-  // Finally, replace the old instructions with the new instructions.
-  size_ = static_cast<int>(flat.size());
-  inst_ = PODArray<Inst>(size_);
-  memmove(inst_.data(), flat.data(), size_*sizeof inst_[0]);
-
-  // Populate the list heads for BitState.
-  // 512 instructions limits the memory footprint to 1KiB.
-  if (size_ <= 512) {
-    list_heads_ = PODArray<uint16_t>(size_);
-    // 0xFF makes it more obvious if we try to look up a non-head.
-    memset(list_heads_.data(), 0xFF, size_*sizeof list_heads_[0]);
-    for (int i = 0; i < list_count_; ++i)
-      list_heads_[flatmap[i]] = i;
-  }
-
-  // BitState allocates a bitmap of size list_count_ * (text.size()+1)
-  // for tracking pairs of possibilities that it has already explored.
-  const size_t kBitStateBitmapMaxSize = 256*1024;  // max size in bits
-  bit_state_text_max_size_ = kBitStateBitmapMaxSize / list_count_ - 1;
-}
-
-void Prog::MarkSuccessors(SparseArray<int>* rootmap,
-                          SparseArray<int>* predmap,
-                          std::vector<std::vector<int>>* predvec,
-                          SparseSet* reachable, std::vector<int>* stk) {
-  // Mark the kInstFail instruction.
-  rootmap->set_new(0, rootmap->size());
-
-  // Mark the start_unanchored and start instructions.
-  if (!rootmap->has_index(start_unanchored()))
-    rootmap->set_new(start_unanchored(), rootmap->size());
-  if (!rootmap->has_index(start()))
-    rootmap->set_new(start(), rootmap->size());
-
-  reachable->clear();
-  stk->clear();
-  stk->push_back(start_unanchored());
-  while (!stk->empty()) {
-    int id = stk->back();
-    stk->pop_back();
-  Loop:
-    if (reachable->contains(id))
-      continue;
-    reachable->insert_new(id);
-
-    Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstAltMatch:
-      case kInstAlt:
-        // Mark this instruction as a predecessor of each out.
-        for (int out : {ip->out(), ip->out1()}) {
-          if (!predmap->has_index(out)) {
-            predmap->set_new(out, static_cast<int>(predvec->size()));
-            predvec->emplace_back();
-          }
-          (*predvec)[predmap->get_existing(out)].emplace_back(id);
-        }
-        stk->push_back(ip->out1());
-        id = ip->out();
-        goto Loop;
-
-      case kInstByteRange:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        // Mark the out of this instruction as a "root".
-        if (!rootmap->has_index(ip->out()))
-          rootmap->set_new(ip->out(), rootmap->size());
-        id = ip->out();
-        goto Loop;
-
-      case kInstNop:
-        id = ip->out();
-        goto Loop;
-
-      case kInstMatch:
-      case kInstFail:
-        break;
-    }
-  }
-}
-
-void Prog::MarkDominator(int root, SparseArray<int>* rootmap,
-                         SparseArray<int>* predmap,
-                         std::vector<std::vector<int>>* predvec,
-                         SparseSet* reachable, std::vector<int>* stk) {
-  reachable->clear();
-  stk->clear();
-  stk->push_back(root);
-  while (!stk->empty()) {
-    int id = stk->back();
-    stk->pop_back();
-  Loop:
-    if (reachable->contains(id))
-      continue;
-    reachable->insert_new(id);
-
-    if (id != root && rootmap->has_index(id)) {
-      // We reached another "tree" via epsilon transition.
-      continue;
-    }
-
-    Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstAltMatch:
-      case kInstAlt:
-        stk->push_back(ip->out1());
-        id = ip->out();
-        goto Loop;
-
-      case kInstByteRange:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        break;
-
-      case kInstNop:
-        id = ip->out();
-        goto Loop;
-
-      case kInstMatch:
-      case kInstFail:
-        break;
-    }
-  }
-
-  for (SparseSet::const_iterator i = reachable->begin();
-       i != reachable->end();
-       ++i) {
-    int id = *i;
-    if (predmap->has_index(id)) {
-      for (int pred : (*predvec)[predmap->get_existing(id)]) {
-        if (!reachable->contains(pred)) {
-          // id has a predecessor that cannot be reached from root!
-          // Therefore, id must be a "root" too - mark it as such.
-          if (!rootmap->has_index(id))
-            rootmap->set_new(id, rootmap->size());
-        }
-      }
-    }
-  }
-}
-
-void Prog::EmitList(int root, SparseArray<int>* rootmap,
-                    std::vector<Inst>* flat,
-                    SparseSet* reachable, std::vector<int>* stk) {
-  reachable->clear();
-  stk->clear();
-  stk->push_back(root);
-  while (!stk->empty()) {
-    int id = stk->back();
-    stk->pop_back();
-  Loop:
-    if (reachable->contains(id))
-      continue;
-    reachable->insert_new(id);
-
-    if (id != root && rootmap->has_index(id)) {
-      // We reached another "tree" via epsilon transition. Emit a kInstNop
-      // instruction so that the Prog does not become quadratically larger.
-      flat->emplace_back();
-      flat->back().set_opcode(kInstNop);
-      flat->back().set_out(rootmap->get_existing(id));
-      continue;
-    }
-
-    Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstAltMatch:
-        flat->emplace_back();
-        flat->back().set_opcode(kInstAltMatch);
-        flat->back().set_out(static_cast<int>(flat->size()));
-        flat->back().out1_ = static_cast<uint32_t>(flat->size())+1;
-        FALLTHROUGH_INTENDED;
-
-      case kInstAlt:
-        stk->push_back(ip->out1());
-        id = ip->out();
-        goto Loop;
-
-      case kInstByteRange:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        flat->emplace_back();
-        memmove(&flat->back(), ip, sizeof *ip);
-        flat->back().set_out(rootmap->get_existing(ip->out()));
-        break;
-
-      case kInstNop:
-        id = ip->out();
-        goto Loop;
-
-      case kInstMatch:
-      case kInstFail:
-        flat->emplace_back();
-        memmove(&flat->back(), ip, sizeof *ip);
-        break;
-    }
-  }
-}
-
-// For each ByteRange instruction in [begin, end), computes a hint to execution
-// engines: the delta to the next instruction (in flat) worth exploring iff the
-// current instruction matched.
-//
-// Implements a coloring algorithm related to ByteMapBuilder, but in this case,
-// colors are instructions and recoloring ranges precisely identifies conflicts
-// between instructions. Iterating backwards over [begin, end) is guaranteed to
-// identify the nearest conflict (if any) with only linear complexity.
-void Prog::ComputeHints(std::vector<Inst>* flat, int begin, int end) {
-  Bitmap256 splits;
-  int colors[256];
-
-  bool dirty = false;
-  for (int id = end; id >= begin; --id) {
-    if (id == end ||
-        (*flat)[id].opcode() != kInstByteRange) {
-      if (dirty) {
-        dirty = false;
-        splits.Clear();
-      }
-      splits.Set(255);
-      colors[255] = id;
-      // At this point, the [0-255] range is colored with id.
-      // Thus, hints cannot point beyond id; and if id == end,
-      // hints that would have pointed to id will be 0 instead.
-      continue;
-    }
-    dirty = true;
-
-    // We recolor the [lo-hi] range with id. Note that first ratchets backwards
-    // from end to the nearest conflict (if any) during recoloring.
-    int first = end;
-    auto Recolor = [&](int lo, int hi) {
-      // Like ByteMapBuilder, we split at lo-1 and at hi.
-      --lo;
-
-      if (0 <= lo && !splits.Test(lo)) {
-        splits.Set(lo);
-        int next = splits.FindNextSetBit(lo+1);
-        colors[lo] = colors[next];
-      }
-      if (!splits.Test(hi)) {
-        splits.Set(hi);
-        int next = splits.FindNextSetBit(hi+1);
-        colors[hi] = colors[next];
-      }
-
-      int c = lo+1;
-      while (c < 256) {
-        int next = splits.FindNextSetBit(c);
-        // Ratchet backwards...
-        first = std::min(first, colors[next]);
-        // Recolor with id - because it's the new nearest conflict!
-        colors[next] = id;
-        if (next == hi)
-          break;
-        c = next+1;
-      }
-    };
-
-    Inst* ip = &(*flat)[id];
-    int lo = ip->lo();
-    int hi = ip->hi();
-    Recolor(lo, hi);
-    if (ip->foldcase() && lo <= 'z' && hi >= 'a') {
-      int foldlo = lo;
-      int foldhi = hi;
-      if (foldlo < 'a')
-        foldlo = 'a';
-      if (foldhi > 'z')
-        foldhi = 'z';
-      if (foldlo <= foldhi) {
-        foldlo += 'A' - 'a';
-        foldhi += 'A' - 'a';
-        Recolor(foldlo, foldhi);
-      }
-    }
-
-    if (first != end) {
-      uint16_t hint = static_cast<uint16_t>(std::min(first - id, 32767));
-      ip->byte_range.hint_foldcase_ |= hint<<1;
-    }
-  }
-}
-
-// The final state will always be this, which frees up a register for the hot
-// loop and thus avoids the spilling that can occur when building with Clang.
-static const size_t kShiftDFAFinal = 9;
-
-// This function takes the prefix as std::string (i.e. not const std::string&
-// as normal) because it's going to clobber it, so a temporary is convenient.
-static uint64_t* BuildShiftDFA(std::string prefix) {
-  // This constant is for convenience now and also for correctness later when
-  // we clobber the prefix, but still need to know how long it was initially.
-  const size_t size = prefix.size();
-
-  // Construct the NFA.
-  // The table is indexed by input byte; each element is a bitfield of states
-  // reachable by the input byte. Given a bitfield of the current states, the
-  // bitfield of states reachable from those is - for this specific purpose -
-  // always ((ncurr << 1) | 1). Intersecting the reachability bitfields gives
-  // the bitfield of the next states reached by stepping over the input byte.
-  // Credits for this technique: the Hyperscan paper by Geoff Langdale et al.
-  uint16_t nfa[256]{};
-  for (size_t i = 0; i < size; ++i) {
-    uint8_t b = prefix[i];
-    nfa[b] |= 1 << (i+1);
-  }
-  // This is the `\C*?` for unanchored search.
-  for (int b = 0; b < 256; ++b)
-    nfa[b] |= 1;
-
-  // This maps from DFA state to NFA states; the reverse mapping is used when
-  // recording transitions and gets implemented with plain old linear search.
-  // The "Shift DFA" technique limits this to ten states when using uint64_t;
-  // to allow for the initial state, we use at most nine bytes of the prefix.
-  // That same limit is also why uint16_t is sufficient for the NFA bitfield.
-  uint16_t states[kShiftDFAFinal+1]{};
-  states[0] = 1;
-  for (size_t dcurr = 0; dcurr < size; ++dcurr) {
-    uint8_t b = prefix[dcurr];
-    uint16_t ncurr = states[dcurr];
-    uint16_t nnext = nfa[b] & ((ncurr << 1) | 1);
-    size_t dnext = dcurr+1;
-    if (dnext == size)
-      dnext = kShiftDFAFinal;
-    states[dnext] = nnext;
-  }
-
-  // Sort and unique the bytes of the prefix to avoid repeating work while we
-  // record transitions. This clobbers the prefix, but it's no longer needed.
-  std::sort(prefix.begin(), prefix.end());
-  prefix.erase(std::unique(prefix.begin(), prefix.end()), prefix.end());
-
-  // Construct the DFA.
-  // The table is indexed by input byte; each element is effectively a packed
-  // array of uint6_t; each array value will be multiplied by six in order to
-  // avoid having to do so later in the hot loop as well as masking/shifting.
-  // Credits for this technique: "Shift-based DFAs" on GitHub by Per Vognsen.
-  uint64_t* dfa = new uint64_t[256]{};
-  // Record a transition from each state for each of the bytes of the prefix.
-  // Note that all other input bytes go back to the initial state by default.
-  for (size_t dcurr = 0; dcurr < size; ++dcurr) {
-    for (uint8_t b : prefix) {
-      uint16_t ncurr = states[dcurr];
-      uint16_t nnext = nfa[b] & ((ncurr << 1) | 1);
-      size_t dnext = 0;
-      while (states[dnext] != nnext)
-        ++dnext;
-      dfa[b] |= static_cast<uint64_t>(dnext * 6) << (dcurr * 6);
-      // Convert ASCII letters to uppercase and record the extra transitions.
-      // Note that ASCII letters are guaranteed to be lowercase at this point
-      // because that's how the parser normalises them. #FunFact: 'k' and 's'
-      // match U+212A and U+017F, respectively, so they won't occur here when
-      // using UTF-8 encoding because the parser will emit character classes.
-      if ('a' <= b && b <= 'z') {
-        b -= 'a' - 'A';
-        dfa[b] |= static_cast<uint64_t>(dnext * 6) << (dcurr * 6);
-      }
-    }
-  }
-  // This lets the final state "saturate", which will matter for performance:
-  // in the hot loop, we check for a match only at the end of each iteration,
-  // so we must keep signalling the match until we get around to checking it.
-  for (int b = 0; b < 256; ++b)
-    dfa[b] |= static_cast<uint64_t>(kShiftDFAFinal * 6) << (kShiftDFAFinal * 6);
-
-  return dfa;
-}
-
-void Prog::ConfigurePrefixAccel(const std::string& prefix,
-                                bool prefix_foldcase) {
-  prefix_foldcase_ = prefix_foldcase;
-  prefix_size_ = prefix.size();
-  if (prefix_foldcase_) {
-    // Use PrefixAccel_ShiftDFA().
-    // ... and no more than nine bytes of the prefix. (See above for details.)
-    prefix_size_ = std::min(prefix_size_, kShiftDFAFinal);
-    prefix_dfa_ = BuildShiftDFA(prefix.substr(0, prefix_size_));
-  } else if (prefix_size_ != 1) {
-    // Use PrefixAccel_FrontAndBack().
-    prefix_front_back.prefix_front_ = prefix.front();
-	prefix_front_back.prefix_back_ = prefix.back();
-  } else {
-    // Use memchr(3).
-	prefix_front_back.prefix_front_ = prefix.front();
-  }
-}
-
-const void* Prog::PrefixAccel_ShiftDFA(const void* data, size_t size) {
-  if (size < prefix_size_)
-    return NULL;
-
-  uint64_t curr = 0;
-
-  // At the time of writing, rough benchmarks on a Broadwell machine showed
-  // that this unroll factor (i.e. eight) achieves a speedup factor of two.
-  if (size >= 8) {
-    const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
-    const uint8_t* endp = p + (size&~7);
-    do {
-      uint8_t b0 = p[0];
-      uint8_t b1 = p[1];
-      uint8_t b2 = p[2];
-      uint8_t b3 = p[3];
-      uint8_t b4 = p[4];
-      uint8_t b5 = p[5];
-      uint8_t b6 = p[6];
-      uint8_t b7 = p[7];
-
-      uint64_t next0 = prefix_dfa_[b0];
-      uint64_t next1 = prefix_dfa_[b1];
-      uint64_t next2 = prefix_dfa_[b2];
-      uint64_t next3 = prefix_dfa_[b3];
-      uint64_t next4 = prefix_dfa_[b4];
-      uint64_t next5 = prefix_dfa_[b5];
-      uint64_t next6 = prefix_dfa_[b6];
-      uint64_t next7 = prefix_dfa_[b7];
-
-      uint64_t curr0 = next0 >> (curr  & 63);
-      uint64_t curr1 = next1 >> (curr0 & 63);
-      uint64_t curr2 = next2 >> (curr1 & 63);
-      uint64_t curr3 = next3 >> (curr2 & 63);
-      uint64_t curr4 = next4 >> (curr3 & 63);
-      uint64_t curr5 = next5 >> (curr4 & 63);
-      uint64_t curr6 = next6 >> (curr5 & 63);
-      uint64_t curr7 = next7 >> (curr6 & 63);
-
-      if ((curr7 & 63) == kShiftDFAFinal * 6) {
-        // At the time of writing, using the same masking subexpressions from
-        // the preceding lines caused Clang to clutter the hot loop computing
-        // them - even though they aren't actually needed for shifting! Hence
-        // these rewritten conditions, which achieve a speedup factor of two.
-        if (((curr7-curr0) & 63) == 0) return p+1-prefix_size_;
-        if (((curr7-curr1) & 63) == 0) return p+2-prefix_size_;
-        if (((curr7-curr2) & 63) == 0) return p+3-prefix_size_;
-        if (((curr7-curr3) & 63) == 0) return p+4-prefix_size_;
-        if (((curr7-curr4) & 63) == 0) return p+5-prefix_size_;
-        if (((curr7-curr5) & 63) == 0) return p+6-prefix_size_;
-        if (((curr7-curr6) & 63) == 0) return p+7-prefix_size_;
-        if (((curr7-curr7) & 63) == 0) return p+8-prefix_size_;
-      }
-
-      curr = curr7;
-      p += 8;
-    } while (p != endp);
-    data = p;
-    size = size&7;
-  }
-
-  const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
-  const uint8_t* endp = p + size;
-  while (p != endp) {
-    uint8_t b = *p++;
-    uint64_t next = prefix_dfa_[b];
-    curr = next >> (curr & 63);
-    if ((curr & 63) == kShiftDFAFinal * 6)
-      return p-prefix_size_;
-  }
-  return NULL;
-}
-
-#if defined(__AVX2__)
-// Finds the least significant non-zero bit in n.
-static int FindLSBSet(uint32_t n) {
-  DCHECK_NE(n, 0);
-#if defined(__GNUC__)
-  return __builtin_ctz(n);
-#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
-  unsigned long c;
-  _BitScanForward(&c, n);
-  return static_cast<int>(c);
-#else
-  int c = 31;
-  for (int shift = 1 << 4; shift != 0; shift >>= 1) {
-    uint32_t word = n << shift;
-    if (word != 0) {
-      n = word;
-      c -= shift;
-    }
-  }
-  return c;
-#endif
-}
-#endif
-
-const void* Prog::PrefixAccel_FrontAndBack(const void* data, size_t size) {
-  DCHECK_GE(prefix_size_, 2);
-  if (size < prefix_size_)
-    return NULL;
-  // Don't bother searching the last prefix_size_-1 bytes for prefix_front_.
-  // This also means that probing for prefix_back_ doesn't go out of bounds.
-  size -= prefix_size_-1;
-
-#if defined(__AVX2__)
-  // Use AVX2 to look for prefix_front_ and prefix_back_ 32 bytes at a time.
-  if (size >= sizeof(__m256i)) {
-    const __m256i* fp = reinterpret_cast<const __m256i*>(
-        reinterpret_cast<const char*>(data));
-    const __m256i* bp = reinterpret_cast<const __m256i*>(
-        reinterpret_cast<const char*>(data) + prefix_size_-1);
-    const __m256i* endfp = fp + size/sizeof(__m256i);
-    const __m256i f_set1 = _mm256_set1_epi8(prefix_front_back.prefix_front_);
-    const __m256i b_set1 = _mm256_set1_epi8(prefix_front_back.prefix_back_);
-    do {
-      const __m256i f_loadu = _mm256_loadu_si256(fp++);
-      const __m256i b_loadu = _mm256_loadu_si256(bp++);
-      const __m256i f_cmpeq = _mm256_cmpeq_epi8(f_set1, f_loadu);
-      const __m256i b_cmpeq = _mm256_cmpeq_epi8(b_set1, b_loadu);
-      const int fb_testz = _mm256_testz_si256(f_cmpeq, b_cmpeq);
-      if (fb_testz == 0) {  // ZF: 1 means zero, 0 means non-zero.
-        const __m256i fb_and = _mm256_and_si256(f_cmpeq, b_cmpeq);
-        const int fb_movemask = _mm256_movemask_epi8(fb_and);
-        const int fb_ctz = FindLSBSet(fb_movemask);
-        return reinterpret_cast<const char*>(fp-1) + fb_ctz;
-      }
-    } while (fp != endfp);
-    data = fp;
-    size = size%sizeof(__m256i);
-  }
-#endif
-
-  const char* p0 = reinterpret_cast<const char*>(data);
-  for (const char* p = p0;; p++) {
-    DCHECK_GE(size, static_cast<size_t>(p-p0));
-    p = reinterpret_cast<const char*>(memchr(p, prefix_front_back.prefix_front_, size - (p-p0)));
-    if (p == NULL || p[prefix_size_-1] == prefix_front_back.prefix_back_)
-      return p;
-  }
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/prog.h b/src/duckdb/third_party/re2/re2/prog.h
deleted file mode 100644
index 4d2d3680d..000000000
--- a/src/duckdb/third_party/re2/re2/prog.h
+++ /dev/null
@@ -1,472 +0,0 @@
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_PROG_H_
-#define RE2_PROG_H_
-
-// Compiled representation of regular expressions.
-// See regexp.h for the Regexp class, which represents a regular
-// expression symbolically.
-
-#include <stdint.h>
-#include <functional>
-#include <mutex>
-#include <string>
-#include <vector>
-#include <type_traits>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "re2/pod_array.h"
-#include "re2/re2.h"
-#include "re2/sparse_array.h"
-#include "re2/sparse_set.h"
-
-// For CRAN
-#  pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
-#  pragma clang diagnostic ignored "-Wnested-anon-types"
-// For CRAN
-
-namespace duckdb_re2 {
-
-// Opcodes for Inst
-enum InstOp {
-  kInstAlt = 0,      // choose between out_ and out1_
-  kInstAltMatch,     // Alt: out_ is [00-FF] and back, out1_ is match; or vice versa.
-  kInstByteRange,    // next (possible case-folded) byte must be in [lo_, hi_]
-  kInstCapture,      // capturing parenthesis number cap_
-  kInstEmptyWidth,   // empty-width special (^ $ ...); bit(s) set in empty_
-  kInstMatch,        // found a match!
-  kInstNop,          // no-op; occasionally unavoidable
-  kInstFail,         // never match; occasionally unavoidable
-  kNumInst,
-};
-
-// Bit flags for empty-width specials
-enum EmptyOp {
-  kEmptyBeginLine        = 1<<0,      // ^ - beginning of line
-  kEmptyEndLine          = 1<<1,      // $ - end of line
-  kEmptyBeginText        = 1<<2,      // \A - beginning of text
-  kEmptyEndText          = 1<<3,      // \z - end of text
-  kEmptyWordBoundary     = 1<<4,      // \b - word boundary
-  kEmptyNonWordBoundary  = 1<<5,      // \B - not \b
-  kEmptyAllFlags         = (1<<6)-1,
-};
-
-class DFA;
-class Regexp;
-
-// Compiled form of regexp program.
-class Prog {
- public:
-  Prog();
-  ~Prog();
-
-  // Single instruction in regexp program.
-  class Inst {
-   public:
-    // See the assertion below for why this is so.
-    Inst() = default;
-
-    // Copyable.
-    Inst(const Inst&) = default;
-    Inst& operator=(const Inst&) = default;
-
-    // Constructors per opcode
-    void InitAlt(uint32_t out, uint32_t out1);
-    void InitByteRange(int lo, int hi, int foldcase, uint32_t out);
-    void InitCapture(int cap, uint32_t out);
-    void InitEmptyWidth(EmptyOp empty, uint32_t out);
-    void InitMatch(int id);
-    void InitNop(uint32_t out);
-    void InitFail();
-
-    // Getters
-    int id(Prog* p) { return static_cast<int>(this - p->inst_.data()); }
-    InstOp opcode() { return static_cast<InstOp>(out_opcode_&7); }
-    int last()      { return (out_opcode_>>3)&1; }
-    int out()       { return out_opcode_>>4; }
-    int out1()      { DCHECK(opcode() == kInstAlt || opcode() == kInstAltMatch); return out1_; }
-    int cap()       { DCHECK_EQ(opcode(), kInstCapture); return cap_; }
-    int lo()        { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.lo_; }
-    int hi()        { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.hi_; }
-    int foldcase()  { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.hint_foldcase_&1; }
-    int hint()      { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.hint_foldcase_>>1; }
-    int match_id()  { DCHECK_EQ(opcode(), kInstMatch); return match_id_; }
-    EmptyOp empty() { DCHECK_EQ(opcode(), kInstEmptyWidth); return empty_; }
-
-    bool greedy(Prog* p) {
-      DCHECK_EQ(opcode(), kInstAltMatch);
-      return p->inst(out())->opcode() == kInstByteRange ||
-             (p->inst(out())->opcode() == kInstNop &&
-              p->inst(p->inst(out())->out())->opcode() == kInstByteRange);
-    }
-
-    // Does this inst (an kInstByteRange) match c?
-    inline bool Matches(int c) {
-      DCHECK_EQ(opcode(), kInstByteRange);
-      if (foldcase() && 'A' <= c && c <= 'Z')
-        c += 'a' - 'A';
-      return byte_range.lo_ <= c && c <= byte_range.hi_;
-    }
-
-    // Returns string representation for debugging.
-    std::string Dump();
-
-    // Maximum instruction id.
-    // (Must fit in out_opcode_. PatchList/last steal another bit.)
-    static const int kMaxInst = (1<<28) - 1;
-
-   private:
-    void set_opcode(InstOp opcode) {
-      out_opcode_ = (out()<<4) | (last()<<3) | opcode;
-    }
-
-    void set_last() {
-      out_opcode_ = (out()<<4) | (1<<3) | opcode();
-    }
-
-    void set_out(int out) {
-      out_opcode_ = (out<<4) | (last()<<3) | opcode();
-    }
-
-    void set_out_opcode(int out, InstOp opcode) {
-      out_opcode_ = (out<<4) | (last()<<3) | opcode;
-    }
-
-    uint32_t out_opcode_;  // 28 bits: out, 1 bit: last, 3 (low) bits: opcode
-    union {                // additional instruction arguments:
-      uint32_t out1_;      // opcode == kInstAlt
-                           //   alternate next instruction
-
-      int32_t cap_;        // opcode == kInstCapture
-                           //   Index of capture register (holds text
-                           //   position recorded by capturing parentheses).
-                           //   For \n (the submatch for the nth parentheses),
-                           //   the left parenthesis captures into register 2*n
-                           //   and the right one captures into register 2*n+1.
-
-      int32_t match_id_;   // opcode == kInstMatch
-                           //   Match ID to identify this match (for duckdb_re2::Set).
-
-      struct {             // opcode == kInstByteRange
-        uint8_t lo_;       //   byte range is lo_-hi_ inclusive
-        uint8_t hi_;       //
-        uint16_t hint_foldcase_;  // 15 bits: hint, 1 (low) bit: foldcase
-                           //   hint to execution engines: the delta to the
-                           //   next instruction (in the current list) worth
-                           //   exploring iff this instruction matched; 0
-                           //   means there are no remaining possibilities,
-                           //   which is most likely for character classes.
-                           //   foldcase: A-Z -> a-z before checking range.
-      } byte_range;
-
-      EmptyOp empty_;       // opcode == kInstEmptyWidth
-                            //   empty_ is bitwise OR of kEmpty* flags above.
-    };
-
-    friend class Compiler;
-    friend struct PatchList;
-    friend class Prog;
-  };
-
-  // Inst must be trivial so that we can freely clear it with memset(3).
-  // Arrays of Inst are initialised by copying the initial elements with
-  // memmove(3) and then clearing any remaining elements with memset(3).
-  static_assert(std::is_trivial<Inst>::value, "Inst must be trivial");
-
-  // Whether to anchor the search.
-  enum Anchor {
-    kUnanchored,  // match anywhere
-    kAnchored,    // match only starting at beginning of text
-  };
-
-  // Kind of match to look for (for anchor != kFullMatch)
-  //
-  // kLongestMatch mode finds the overall longest
-  // match but still makes its submatch choices the way
-  // Perl would, not in the way prescribed by POSIX.
-  // The POSIX rules are much more expensive to implement,
-  // and no one has needed them.
-  //
-  // kFullMatch is not strictly necessary -- we could use
-  // kLongestMatch and then check the length of the match -- but
-  // the matching code can run faster if it knows to consider only
-  // full matches.
-  enum MatchKind {
-    kFirstMatch,     // like Perl, PCRE
-    kLongestMatch,   // like egrep or POSIX
-    kFullMatch,      // match only entire text; implies anchor==kAnchored
-    kManyMatch       // for SearchDFA, records set of matches
-  };
-
-  Inst *inst(int id) { return &inst_[id]; }
-  int start() { return start_; }
-  void set_start(int start) { start_ = start; }
-  int start_unanchored() { return start_unanchored_; }
-  void set_start_unanchored(int start) { start_unanchored_ = start; }
-  int size() { return size_; }
-  bool reversed() { return reversed_; }
-  void set_reversed(bool reversed) { reversed_ = reversed; }
-  int list_count() { return list_count_; }
-  int inst_count(InstOp op) { return inst_count_[op]; }
-  uint16_t* list_heads() { return list_heads_.data(); }
-  size_t bit_state_text_max_size() { return bit_state_text_max_size_; }
-  int64_t dfa_mem() { return dfa_mem_; }
-  void set_dfa_mem(int64_t dfa_mem) { dfa_mem_ = dfa_mem; }
-  bool anchor_start() { return anchor_start_; }
-  void set_anchor_start(bool b) { anchor_start_ = b; }
-  bool anchor_end() { return anchor_end_; }
-  void set_anchor_end(bool b) { anchor_end_ = b; }
-  int bytemap_range() { return bytemap_range_; }
-  const uint8_t* bytemap() { return bytemap_; }
-  bool can_prefix_accel() { return prefix_size_ != 0; }
-
-  // Accelerates to the first likely occurrence of the prefix.
-  // Returns a pointer to the first byte or NULL if not found.
-  const void* PrefixAccel(const void* data, size_t size) {
-    DCHECK(can_prefix_accel());
-    if (prefix_foldcase_) {
-      return PrefixAccel_ShiftDFA(data, size);
-    } else if (prefix_size_ != 1) {
-      return PrefixAccel_FrontAndBack(data, size);
-    } else {
-      return memchr(data, prefix_front_back.prefix_front_, size);
-    }
-  }
-
-  // Configures prefix accel using the analysis performed during compilation.
-  void ConfigurePrefixAccel(const std::string& prefix, bool prefix_foldcase);
-
-  // An implementation of prefix accel that uses prefix_dfa_ to perform
-  // case-insensitive search.
-  const void* PrefixAccel_ShiftDFA(const void* data, size_t size);
-
-  // An implementation of prefix accel that looks for prefix_front_ and
-  // prefix_back_ to return fewer false positives than memchr(3) alone.
-  const void* PrefixAccel_FrontAndBack(const void* data, size_t size);
-
-  // Returns string representation of program for debugging.
-  std::string Dump();
-  std::string DumpUnanchored();
-  std::string DumpByteMap();
-
-  // Returns the set of kEmpty flags that are in effect at
-  // position p within context.
-  static uint32_t EmptyFlags(const StringPiece& context, const char* p);
-
-  // Returns whether byte c is a word character: ASCII only.
-  // Used by the implementation of \b and \B.
-  // This is not right for Unicode, but:
-  //   - it's hard to get right in a byte-at-a-time matching world
-  //     (the DFA has only one-byte lookahead).
-  //   - even if the lookahead were possible, the Progs would be huge.
-  // This crude approximation is the same one PCRE uses.
-  static bool IsWordChar(uint8_t c) {
-    return ('A' <= c && c <= 'Z') ||
-           ('a' <= c && c <= 'z') ||
-           ('0' <= c && c <= '9') ||
-           c == '_';
-  }
-
-  // Execution engines.  They all search for the regexp (run the prog)
-  // in text, which is in the larger context (used for ^ $ \b etc).
-  // Anchor and kind control the kind of search.
-  // Returns true if match found, false if not.
-  // If match found, fills match[0..nmatch-1] with submatch info.
-  // match[0] is overall match, match[1] is first set of parens, etc.
-  // If a particular submatch is not matched during the regexp match,
-  // it is set to NULL.
-  //
-  // Matching text == StringPiece(NULL, 0) is treated as any other empty
-  // string, but note that on return, it will not be possible to distinguish
-  // submatches that matched that empty string from submatches that didn't
-  // match anything.  Either way, match[i] == NULL.
-
-  // Search using NFA: can find submatches but kind of slow.
-  bool SearchNFA(const StringPiece& text, const StringPiece& context,
-                 Anchor anchor, MatchKind kind,
-                 StringPiece* match, int nmatch);
-
-  // Search using DFA: much faster than NFA but only finds
-  // end of match and can use a lot more memory.
-  // Returns whether a match was found.
-  // If the DFA runs out of memory, sets *failed to true and returns false.
-  // If matches != NULL and kind == kManyMatch and there is a match,
-  // SearchDFA fills matches with the match IDs of the final matching state.
-  bool SearchDFA(const StringPiece& text, const StringPiece& context,
-                 Anchor anchor, MatchKind kind, StringPiece* match0,
-                 bool* failed, SparseSet* matches);
-
-  // The callback issued after building each DFA state with BuildEntireDFA().
-  // If next is null, then the memory budget has been exhausted and building
-  // will halt. Otherwise, the state has been built and next points to an array
-  // of bytemap_range()+1 slots holding the next states as per the bytemap and
-  // kByteEndText. The number of the state is implied by the callback sequence:
-  // the first callback is for state 0, the second callback is for state 1, ...
-  // match indicates whether the state is a matching state.
-  using DFAStateCallback = std::function<void(const int* next, bool match)>;
-
-  // Build the entire DFA for the given match kind.
-  // Usually the DFA is built out incrementally, as needed, which
-  // avoids lots of unnecessary work.
-  // If cb is not empty, it receives one callback per state built.
-  // Returns the number of states built.
-  // FOR TESTING OR EXPERIMENTAL PURPOSES ONLY.
-  int BuildEntireDFA(MatchKind kind, const DFAStateCallback& cb);
-
-  // Compute bytemap.
-  void ComputeByteMap();
-
-  // Run peep-hole optimizer on program.
-  void Optimize();
-
-  // One-pass NFA: only correct if IsOnePass() is true,
-  // but much faster than NFA (competitive with PCRE)
-  // for those expressions.
-  bool IsOnePass();
-  bool SearchOnePass(const StringPiece& text, const StringPiece& context,
-                     Anchor anchor, MatchKind kind,
-                     StringPiece* match, int nmatch);
-
-  // Bit-state backtracking.  Fast on small cases but uses memory
-  // proportional to the product of the list count and the text size.
-  bool CanBitState() { return list_heads_.data() != NULL; }
-  bool SearchBitState(const StringPiece& text, const StringPiece& context,
-                      Anchor anchor, MatchKind kind,
-                      StringPiece* match, int nmatch);
-
-  static const int kMaxOnePassCapture = 5;  // $0 through $4
-
-  // Backtracking search: the gold standard against which the other
-  // implementations are checked.  FOR TESTING ONLY.
-  // It allocates a ton of memory to avoid running forever.
-  // It is also recursive, so can't use in production (will overflow stacks).
-  // The name "Unsafe" here is supposed to be a flag that
-  // you should not be using this function.
-  bool UnsafeSearchBacktrack(const StringPiece& text,
-                             const StringPiece& context,
-                             Anchor anchor, MatchKind kind,
-                             StringPiece* match, int nmatch);
-
-  // Computes range for any strings matching regexp. The min and max can in
-  // some cases be arbitrarily precise, so the caller gets to specify the
-  // maximum desired length of string returned.
-  //
-  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
-  // string s that is an anchored match for this regexp satisfies
-  //   min <= s && s <= max.
-  //
-  // Note that PossibleMatchRange() will only consider the first copy of an
-  // infinitely repeated element (i.e., any regexp element followed by a '*' or
-  // '+' operator). Regexps with "{N}" constructions are not affected, as those
-  // do not compile down to infinite repetitions.
-  //
-  // Returns true on success, false on error.
-  bool PossibleMatchRange(std::string* min, std::string* max, int maxlen);
-
-  // Outputs the program fanout into the given sparse array.
-  void Fanout(SparseArray<int>* fanout);
-
-  // Compiles a collection of regexps to Prog.  Each regexp will have
-  // its own Match instruction recording the index in the output vector.
-  static Prog* CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem);
-
-  // Flattens the Prog from "tree" form to "list" form. This is an in-place
-  // operation in the sense that the old instructions are lost.
-  void Flatten();
-
-  // Walks the Prog; the "successor roots" or predecessors of the reachable
-  // instructions are marked in rootmap or predmap/predvec, respectively.
-  // reachable and stk are preallocated scratch structures.
-  void MarkSuccessors(SparseArray<int>* rootmap,
-                      SparseArray<int>* predmap,
-                      std::vector<std::vector<int>>* predvec,
-                      SparseSet* reachable, std::vector<int>* stk);
-
-  // Walks the Prog from the given "root" instruction; the "dominator root"
-  // of the reachable instructions (if such exists) is marked in rootmap.
-  // reachable and stk are preallocated scratch structures.
-  void MarkDominator(int root, SparseArray<int>* rootmap,
-                     SparseArray<int>* predmap,
-                     std::vector<std::vector<int>>* predvec,
-                     SparseSet* reachable, std::vector<int>* stk);
-
-  // Walks the Prog from the given "root" instruction; the reachable
-  // instructions are emitted in "list" form and appended to flat.
-  // reachable and stk are preallocated scratch structures.
-  void EmitList(int root, SparseArray<int>* rootmap,
-                std::vector<Inst>* flat,
-                SparseSet* reachable, std::vector<int>* stk);
-
-  // Computes hints for ByteRange instructions in [begin, end).
-  void ComputeHints(std::vector<Inst>* flat, int begin, int end);
-
-  // Controls whether the DFA should bail out early if the NFA would be faster.
-  // FOR TESTING ONLY.
-  static void TESTING_ONLY_set_dfa_should_bail_when_slow(bool b);
-
- private:
-  friend class Compiler;
-
-  DFA* GetDFA(MatchKind kind);
-  void DeleteDFA(DFA* dfa);
-
-  bool anchor_start_;       // regexp has explicit start anchor
-  bool anchor_end_;         // regexp has explicit end anchor
-  bool reversed_;           // whether program runs backward over input
-  bool did_flatten_;        // has Flatten been called?
-  bool did_onepass_;        // has IsOnePass been called?
-
-  int start_;               // entry point for program
-  int start_unanchored_;    // unanchored entry point for program
-  int size_;                // number of instructions
-  int bytemap_range_;       // bytemap_[x] < bytemap_range_
-
-  bool prefix_foldcase_;    // whether prefix is case-insensitive
-  size_t prefix_size_;      // size of prefix (0 if no prefix)
-  union {
-    uint64_t* prefix_dfa_;  // "Shift DFA" for prefix
-    struct {
-      int prefix_front_;    // first byte of prefix
-      int prefix_back_;     // last byte of prefix
-    } prefix_front_back;
-  };
-
-  int list_count_;                  // count of lists (see above)
-  int inst_count_[kNumInst];        // count of instructions by opcode
-  PODArray<uint16_t> list_heads_;   // sparse array enumerating list heads
-                                    // not populated if size_ is overly large
-  size_t bit_state_text_max_size_;  // upper bound (inclusive) on text.size()
-
-  PODArray<Inst> inst_;              // pointer to instruction array
-  PODArray<uint8_t> onepass_nodes_;  // data for OnePass nodes
-
-  int64_t dfa_mem_;         // Maximum memory for DFAs.
-  DFA* dfa_first_;          // DFA cached for kFirstMatch/kManyMatch
-  DFA* dfa_longest_;        // DFA cached for kLongestMatch/kFullMatch
-
-  uint8_t bytemap_[256];    // map from input bytes to byte classes
-
-  std::once_flag dfa_first_once_;
-  std::once_flag dfa_longest_once_;
-
-  Prog(const Prog&) = delete;
-  Prog& operator=(const Prog&) = delete;
-};
-
-// std::string_view in MSVC has iterators that aren't just pointers and
-// that don't allow comparisons between different objects - not even if
-// those objects are views into the same string! Thus, we provide these
-// conversion functions for convenience.
-static inline const char* BeginPtr(const StringPiece& s) {
-  return s.data();
-}
-static inline const char* EndPtr(const StringPiece& s) {
-  return s.data() + s.size();
-}
-
-}  // namespace re2
-
-#endif  // RE2_PROG_H_
diff --git a/src/duckdb/third_party/re2/re2/re2.cc b/src/duckdb/third_party/re2/re2/re2.cc
deleted file mode 100644
index 17e9df02e..000000000
--- a/src/duckdb/third_party/re2/re2/re2.cc
+++ /dev/null
@@ -1,1356 +0,0 @@
-// Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Regular expression interface RE2.
-//
-// Originally the PCRE C++ wrapper, but adapted to use
-// the new automata-based regular expression engines.
-
-#include "re2/re2.h"
-
-#include <assert.h>
-#include <ctype.h>
-#include <errno.h>
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <algorithm>
-#include <atomic>
-#include <iterator>
-#include <mutex>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "util/utf.h"
-#include "re2/prog.h"
-#include "re2/regexp.h"
-#include "re2/sparse_array.h"
-
-namespace duckdb_re2 {
-
-// Controls the maximum count permitted by GlobalReplace(); -1 is unlimited.
-static int maximum_global_replace_count = -1;
-
-void RE2::FUZZING_ONLY_set_maximum_global_replace_count(int i) {
-  maximum_global_replace_count = i;
-}
-
-// Maximum number of args we can set
-static const int kMaxArgs = 16;
-static const int kVecSize = 1+kMaxArgs;
-
-const int RE2::Options::kDefaultMaxMem;  // initialized in re2.h
-
-RE2::Options::Options(RE2::CannedOptions opt)
-  : max_mem_(kDefaultMaxMem),
-    encoding_(opt == RE2::Latin1 ? EncodingLatin1 : EncodingUTF8),
-    posix_syntax_(opt == RE2::POSIX),
-    longest_match_(opt == RE2::POSIX),
-    log_errors_(opt != RE2::Quiet),
-    literal_(false),
-    never_nl_(false),
-    dot_nl_(false),
-    never_capture_(false),
-    case_sensitive_(true),
-    perl_classes_(false),
-    word_boundary_(false),
-    one_line_(false) {
-}
-
-// Empty objects for use as const references.
-// Statically allocating the storage and then
-// lazily constructing the objects (in a once
-// in RE2::Init()) avoids global constructors
-// and the false positives (thanks, Valgrind)
-// about memory leaks at program termination.
-struct EmptyStorage {
-  std::string empty_string;
-  std::map<std::string, int> empty_named_groups;
-  std::map<int, std::string> empty_group_names;
-};
-alignas(EmptyStorage) static char empty_storage[sizeof(EmptyStorage)];
-
-static inline std::string* empty_string() {
-  return &reinterpret_cast<EmptyStorage*>(empty_storage)->empty_string;
-}
-
-static inline std::map<std::string, int>* empty_named_groups() {
-  return &reinterpret_cast<EmptyStorage*>(empty_storage)->empty_named_groups;
-}
-
-static inline std::map<int, std::string>* empty_group_names() {
-  return &reinterpret_cast<EmptyStorage*>(empty_storage)->empty_group_names;
-}
-
-// Converts from Regexp error code to RE2 error code.
-// Maybe some day they will diverge.  In any event, this
-// hides the existence of Regexp from RE2 users.
-static RE2::ErrorCode RegexpErrorToRE2(duckdb_re2::RegexpStatusCode code) {
-  switch (code) {
-    case duckdb_re2::kRegexpSuccess:
-      return RE2::NoError;
-    case duckdb_re2::kRegexpInternalError:
-      return RE2::ErrorInternal;
-    case duckdb_re2::kRegexpBadEscape:
-      return RE2::ErrorBadEscape;
-    case duckdb_re2::kRegexpBadCharClass:
-      return RE2::ErrorBadCharClass;
-    case duckdb_re2::kRegexpBadCharRange:
-      return RE2::ErrorBadCharRange;
-    case duckdb_re2::kRegexpMissingBracket:
-      return RE2::ErrorMissingBracket;
-    case duckdb_re2::kRegexpMissingParen:
-      return RE2::ErrorMissingParen;
-    case duckdb_re2::kRegexpUnexpectedParen:
-      return RE2::ErrorUnexpectedParen;
-    case duckdb_re2::kRegexpTrailingBackslash:
-      return RE2::ErrorTrailingBackslash;
-    case duckdb_re2::kRegexpRepeatArgument:
-      return RE2::ErrorRepeatArgument;
-    case duckdb_re2::kRegexpRepeatSize:
-      return RE2::ErrorRepeatSize;
-    case duckdb_re2::kRegexpRepeatOp:
-      return RE2::ErrorRepeatOp;
-    case duckdb_re2::kRegexpBadPerlOp:
-      return RE2::ErrorBadPerlOp;
-    case duckdb_re2::kRegexpBadUTF8:
-      return RE2::ErrorBadUTF8;
-    case duckdb_re2::kRegexpBadNamedCapture:
-      return RE2::ErrorBadNamedCapture;
-  }
-  return RE2::ErrorInternal;
-}
-
-static std::string trunc(const StringPiece& pattern) {
-  if (pattern.size() < 100)
-    return std::string(pattern);
-  return std::string(pattern.substr(0, 100)) + "...";
-}
-
-
-RE2::RE2(const char* pattern) {
-  Init(pattern, DefaultOptions);
-}
-
-RE2::RE2(const std::string& pattern) {
-  Init(pattern, DefaultOptions);
-}
-
-RE2::RE2(const StringPiece& pattern) {
-  Init(pattern, DefaultOptions);
-}
-
-RE2::RE2(const StringPiece& pattern, const Options& options) {
-  Init(pattern, options);
-}
-
-int RE2::Options::ParseFlags() const {
-  int flags = Regexp::ClassNL;
-  switch (encoding()) {
-    default:
-      if (log_errors())
-        LOG(ERROR) << "Unknown encoding " << encoding();
-      break;
-    case RE2::Options::EncodingUTF8:
-      break;
-    case RE2::Options::EncodingLatin1:
-      flags |= Regexp::Latin1;
-      break;
-  }
-
-  if (!posix_syntax())
-    flags |= Regexp::LikePerl;
-
-  if (literal())
-    flags |= Regexp::Literal;
-
-  if (never_nl())
-    flags |= Regexp::NeverNL;
-
-  if (dot_nl())
-    flags |= Regexp::DotNL;
-
-  if (never_capture())
-    flags |= Regexp::NeverCapture;
-
-  if (!case_sensitive())
-    flags |= Regexp::FoldCase;
-
-  if (perl_classes())
-    flags |= Regexp::PerlClasses;
-
-  if (word_boundary())
-    flags |= Regexp::PerlB;
-
-  if (one_line())
-    flags |= Regexp::OneLine;
-
-  return flags;
-}
-
-void RE2::Init(const StringPiece& pattern, const Options& options) {
-  static std::once_flag empty_once;
-  std::call_once(empty_once, []() {
-    (void) new (empty_storage) EmptyStorage;
-  });
-
-  pattern_ = new std::string(pattern);
-  options_.Copy(options);
-  entire_regexp_ = NULL;
-  suffix_regexp_ = NULL;
-  error_ = empty_string();
-  error_arg_ = empty_string();
-
-  num_captures_ = -1;
-  error_code_ = NoError;
-  longest_match_ = options_.longest_match();
-  is_one_pass_ = false;
-  prefix_foldcase_ = false;
-  prefix_.clear();
-  prog_ = NULL;
-
-  rprog_ = NULL;
-  named_groups_ = NULL;
-  group_names_ = NULL;
-
-  RegexpStatus status;
-  entire_regexp_ = Regexp::Parse(
-    *pattern_,
-    static_cast<Regexp::ParseFlags>(options_.ParseFlags()),
-    &status);
-  if (entire_regexp_ == NULL) {
-    if (options_.log_errors()) {
-      LOG(ERROR) << "Error parsing '" << trunc(*pattern_) << "': "
-                 << status.Text();
-    }
-    error_ = new std::string(status.Text());
-    error_code_ = RegexpErrorToRE2(status.code());
-    error_arg_ = new std::string(status.error_arg());
-    return;
-  }
-
-  bool foldcase;
-  duckdb_re2::Regexp* suffix;
-  if (entire_regexp_->RequiredPrefix(&prefix_, &foldcase, &suffix)) {
-    prefix_foldcase_ = foldcase;
-    suffix_regexp_ = suffix;
-  }
-  else {
-    suffix_regexp_ = entire_regexp_->Incref();
-  }
-
-  // Two thirds of the memory goes to the forward Prog,
-  // one third to the reverse prog, because the forward
-  // Prog has two DFAs but the reverse prog has one.
-  prog_ = suffix_regexp_->CompileToProg(options_.max_mem()*2/3);
-  if (prog_ == NULL) {
-    if (options_.log_errors())
-      LOG(ERROR) << "Error compiling '" << trunc(*pattern_) << "'";
-    error_ = new std::string("pattern too large - compile failed");
-    error_code_ = RE2::ErrorPatternTooLarge;
-    return;
-  }
-
-  // We used to compute this lazily, but it's used during the
-  // typical control flow for a match call, so we now compute
-  // it eagerly, which avoids the overhead of std::once_flag.
-  num_captures_ = suffix_regexp_->NumCaptures();
-
-  // Could delay this until the first match call that
-  // cares about submatch information, but the one-pass
-  // machine's memory gets cut from the DFA memory budget,
-  // and that is harder to do if the DFA has already
-  // been built.
-  is_one_pass_ = prog_->IsOnePass();
-}
-
-// Returns rprog_, computing it if needed.
-duckdb_re2::Prog* RE2::ReverseProg() const {
-  std::call_once(rprog_once_, [](const RE2* re) {
-    re->rprog_ =
-        re->suffix_regexp_->CompileToReverseProg(re->options_.max_mem() / 3);
-    if (re->rprog_ == NULL) {
-      if (re->options_.log_errors())
-        LOG(ERROR) << "Error reverse compiling '" << trunc(*re->pattern_)
-                   << "'";
-      // We no longer touch error_ and error_code_ because failing to compile
-      // the reverse Prog is not a showstopper: falling back to NFA execution
-      // is fine. More importantly, an RE2 object is supposed to be logically
-      // immutable: whatever ok() would have returned after Init() completed,
-      // it should continue to return that no matter what ReverseProg() does.
-    }
-  }, this);
-  return rprog_;
-}
-
-RE2::~RE2() {
-  if (group_names_ != empty_group_names())
-    delete group_names_;
-  if (named_groups_ != empty_named_groups())
-    delete named_groups_;
-  delete rprog_;
-  delete prog_;
-  if (error_arg_ != empty_string())
-    delete error_arg_;
-  if (error_ != empty_string())
-    delete error_;
-  if (suffix_regexp_)
-    suffix_regexp_->Decref();
-  if (entire_regexp_)
-    entire_regexp_->Decref();
-  delete pattern_;
-}
-
-int RE2::ProgramSize() const {
-  if (prog_ == NULL)
-    return -1;
-  return prog_->size();
-}
-
-int RE2::ReverseProgramSize() const {
-  if (prog_ == NULL)
-    return -1;
-  Prog* prog = ReverseProg();
-  if (prog == NULL)
-    return -1;
-  return prog->size();
-}
-
-// Finds the most significant non-zero bit in n.
-static int FindMSBSet(uint32_t n) {
-  DCHECK_NE(n, 0);
-#if defined(__GNUC__)
-  return 31 ^ __builtin_clz(n);
-#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
-  unsigned long c;
-  _BitScanReverse(&c, n);
-  return static_cast<int>(c);
-#else
-  int c = 0;
-  for (int shift = 1 << 4; shift != 0; shift >>= 1) {
-    uint32_t word = n >> shift;
-    if (word != 0) {
-      n = word;
-      c += shift;
-    }
-  }
-  return c;
-#endif
-}
-
-static int Fanout(Prog* prog, std::vector<int>* histogram) {
-  SparseArray<int> fanout(prog->size());
-  prog->Fanout(&fanout);
-  int data[32] = {};
-  int size = 0;
-  for (SparseArray<int>::iterator i = fanout.begin(); i != fanout.end(); ++i) {
-    if (i->value() == 0)
-      continue;
-    uint32_t value = i->value();
-    int bucket = FindMSBSet(value);
-    bucket += value & (value-1) ? 1 : 0;
-    ++data[bucket];
-    size = std::max(size, bucket+1);
-  }
-  if (histogram != NULL)
-    histogram->assign(data, data+size);
-  return size-1;
-}
-
-int RE2::ProgramFanout(std::vector<int>* histogram) const {
-  if (prog_ == NULL)
-    return -1;
-  return Fanout(prog_, histogram);
-}
-
-int RE2::ReverseProgramFanout(std::vector<int>* histogram) const {
-  if (prog_ == NULL)
-    return -1;
-  Prog* prog = ReverseProg();
-  if (prog == NULL)
-    return -1;
-  return Fanout(prog, histogram);
-}
-
-// Returns named_groups_, computing it if needed.
-const std::map<std::string, int>& RE2::NamedCapturingGroups() const {
-  std::call_once(named_groups_once_, [](const RE2* re) {
-    if (re->suffix_regexp_ != NULL)
-      re->named_groups_ = re->suffix_regexp_->NamedCaptures();
-    if (re->named_groups_ == NULL)
-      re->named_groups_ = empty_named_groups();
-  }, this);
-  return *named_groups_;
-}
-
-// Returns group_names_, computing it if needed.
-const std::map<int, std::string>& RE2::CapturingGroupNames() const {
-  std::call_once(group_names_once_, [](const RE2* re) {
-    if (re->suffix_regexp_ != NULL)
-      re->group_names_ = re->suffix_regexp_->CaptureNames();
-    if (re->group_names_ == NULL)
-      re->group_names_ = empty_group_names();
-  }, this);
-  return *group_names_;
-}
-
-/***** Convenience interfaces *****/
-
-bool RE2::FullMatchN(const StringPiece& text, const RE2& re,
-                     const Arg* const args[], int n) {
-  return re.DoMatch(text, ANCHOR_BOTH, NULL, args, n);
-}
-
-bool RE2::PartialMatchN(const StringPiece& text, const RE2& re,
-                        const Arg* const args[], int n) {
-  return re.DoMatch(text, UNANCHORED, NULL, args, n);
-}
-
-bool RE2::ConsumeN(StringPiece* input, const RE2& re,
-                   const Arg* const args[], int n) {
-  size_t consumed;
-  if (re.DoMatch(*input, ANCHOR_START, &consumed, args, n)) {
-    input->remove_prefix(consumed);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool RE2::FindAndConsumeN(StringPiece* input, const RE2& re,
-                          const Arg* const args[], int n) {
-  size_t consumed;
-  if (re.DoMatch(*input, UNANCHORED, &consumed, args, n)) {
-    input->remove_prefix(consumed);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool RE2::Replace(std::string* str,
-                  const RE2& re,
-                  const StringPiece& rewrite) {
-  StringPiece vec[kVecSize];
-  int nvec = 1 + MaxSubmatch(rewrite);
-  if (nvec > 1 + re.NumberOfCapturingGroups())
-    return false;
-  if (nvec > static_cast<int>(arraysize(vec)))
-    return false;
-  if (!re.Match(*str, 0, str->size(), UNANCHORED, vec, nvec))
-    return false;
-
-  std::string s;
-  if (!re.Rewrite(&s, rewrite, vec, nvec))
-    return false;
-
-  assert(vec[0].data() >= str->data());
-  assert(vec[0].data() + vec[0].size() <= str->data() + str->size());
-  str->replace(vec[0].data() - str->data(), vec[0].size(), s);
-  return true;
-}
-
-int RE2::GlobalReplace(std::string* str,
-                       const RE2& re,
-                       const StringPiece& rewrite) {
-  StringPiece vec[kVecSize];
-  int nvec = 1 + MaxSubmatch(rewrite);
-  if (nvec > 1 + re.NumberOfCapturingGroups())
-    return false;
-  if (nvec > static_cast<int>(arraysize(vec)))
-    return false;
-
-  const char* p = str->data();
-  const char* ep = p + str->size();
-  const char* lastend = NULL;
-  std::string out;
-  int count = 0;
-  while (p <= ep) {
-    if (maximum_global_replace_count != -1 &&
-        count >= maximum_global_replace_count)
-      break;
-    if (!re.Match(*str, static_cast<size_t>(p - str->data()),
-                  str->size(), UNANCHORED, vec, nvec))
-      break;
-    if (p < vec[0].data())
-      out.append(p, vec[0].data() - p);
-    if (vec[0].data() == lastend && vec[0].empty()) {
-      // Disallow empty match at end of last match: skip ahead.
-      //
-      // fullrune() takes int, not ptrdiff_t. However, it just looks
-      // at the leading byte and treats any length >= 4 the same.
-      if (re.options().encoding() == RE2::Options::EncodingUTF8 &&
-          fullrune(p, static_cast<int>(std::min(ptrdiff_t{4}, ep - p)))) {
-        // re is in UTF-8 mode and there is enough left of str
-        // to allow us to advance by up to UTFmax bytes.
-        Rune r;
-        int n = chartorune(&r, p);
-        // Some copies of chartorune have a bug that accepts
-        // encodings of values in (10FFFF, 1FFFFF] as valid.
-        if (r > Runemax) {
-          n = 1;
-          r = Runeerror;
-        }
-        if (!(n == 1 && r == Runeerror)) {  // no decoding error
-          out.append(p, n);
-          p += n;
-          continue;
-        }
-      }
-      // Most likely, re is in Latin-1 mode. If it is in UTF-8 mode,
-      // we fell through from above and the GIGO principle applies.
-      if (p < ep)
-        out.append(p, 1);
-      p++;
-      continue;
-    }
-    re.Rewrite(&out, rewrite, vec, nvec);
-    p = vec[0].data() + vec[0].size();
-    lastend = p;
-    count++;
-  }
-
-  if (count == 0)
-    return 0;
-
-  if (p < ep)
-    out.append(p, ep - p);
-  using std::swap;
-  swap(out, *str);
-  return count;
-}
-
-bool RE2::Extract(const StringPiece& text,
-                  const RE2& re,
-                  const StringPiece& rewrite,
-                  std::string* out) {
-  StringPiece vec[kVecSize];
-  int nvec = 1 + MaxSubmatch(rewrite);
-  if (nvec > 1 + re.NumberOfCapturingGroups())
-    return false;
-  if (nvec > static_cast<int>(arraysize(vec)))
-    return false;
-  if (!re.Match(text, 0, text.size(), UNANCHORED, vec, nvec))
-    return false;
-
-  out->clear();
-  return re.Rewrite(out, rewrite, vec, nvec);
-}
-
-std::string RE2::QuoteMeta(const StringPiece& unquoted) {
-  std::string result;
-  result.reserve(unquoted.size() << 1);
-
-  // Escape any ascii character not in [A-Za-z_0-9].
-  //
-  // Note that it's legal to escape a character even if it has no
-  // special meaning in a regular expression -- so this function does
-  // that.  (This also makes it identical to the perl function of the
-  // same name except for the null-character special case;
-  // see `perldoc -f quotemeta`.)
-  for (size_t ii = 0; ii < unquoted.size(); ++ii) {
-    // Note that using 'isalnum' here raises the benchmark time from
-    // 32ns to 58ns:
-    if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') &&
-        (unquoted[ii] < 'A' || unquoted[ii] > 'Z') &&
-        (unquoted[ii] < '0' || unquoted[ii] > '9') &&
-        unquoted[ii] != '_' &&
-        // If this is the part of a UTF8 or Latin1 character, we need
-        // to copy this byte without escaping.  Experimentally this is
-        // what works correctly with the regexp library.
-        !(unquoted[ii] & 128)) {
-      if (unquoted[ii] == '\0') {  // Special handling for null chars.
-        // Note that this special handling is not strictly required for RE2,
-        // but this quoting is required for other regexp libraries such as
-        // PCRE.
-        // Can't use "\\0" since the next character might be a digit.
-        result += "\\x00";
-        continue;
-      }
-      result += '\\';
-    }
-    result += unquoted[ii];
-  }
-
-  return result;
-}
-
-bool RE2::PossibleMatchRange(std::string* min, std::string* max,
-                             int maxlen) const {
-  if (prog_ == NULL)
-    return false;
-
-  int n = static_cast<int>(prefix_.size());
-  if (n > maxlen)
-    n = maxlen;
-
-  // Determine initial min max from prefix_ literal.
-  *min = prefix_.substr(0, n);
-  *max = prefix_.substr(0, n);
-  if (prefix_foldcase_) {
-    // prefix is ASCII lowercase; change *min to uppercase.
-    for (int i = 0; i < n; i++) {
-      char& c = (*min)[i];
-      if ('a' <= c && c <= 'z')
-        c += 'A' - 'a';
-    }
-  }
-
-  // Add to prefix min max using PossibleMatchRange on regexp.
-  std::string dmin, dmax;
-  maxlen -= n;
-  if (maxlen > 0 && prog_->PossibleMatchRange(&dmin, &dmax, maxlen)) {
-    min->append(dmin);
-    max->append(dmax);
-  } else if (!max->empty()) {
-    // prog_->PossibleMatchRange has failed us,
-    // but we still have useful information from prefix_.
-    // Round up *max to allow any possible suffix.
-    PrefixSuccessor(max);
-  } else {
-    // Nothing useful.
-    *min = "";
-    *max = "";
-    return false;
-  }
-
-  return true;
-}
-
-// Avoid possible locale nonsense in standard strcasecmp.
-// The string a is known to be all lowercase.
-static int ascii_strcasecmp(const char* a, const char* b, size_t len) {
-  const char* ae = a + len;
-
-  for (; a < ae; a++, b++) {
-    uint8_t x = *a;
-    uint8_t y = *b;
-    if ('A' <= y && y <= 'Z')
-      y += 'a' - 'A';
-    if (x != y)
-      return x - y;
-  }
-  return 0;
-}
-
-
-/***** Actual matching and rewriting code *****/
-
-bool RE2::Match(const StringPiece& text,
-                size_t startpos,
-                size_t endpos,
-                Anchor re_anchor,
-                StringPiece* submatch,
-                int nsubmatch) const {
-  if (!ok()) {
-    if (options_.log_errors())
-      LOG(ERROR) << "Invalid RE2: " << *error_;
-    return false;
-  }
-
-  if (startpos > endpos || endpos > text.size()) {
-    if (options_.log_errors())
-      LOG(ERROR) << "RE2: invalid startpos, endpos pair. ["
-                 << "startpos: " << startpos << ", "
-                 << "endpos: " << endpos << ", "
-                 << "text size: " << text.size() << "]";
-    return false;
-  }
-
-  StringPiece subtext = text;
-  subtext.remove_prefix(startpos);
-  subtext.remove_suffix(text.size() - endpos);
-
-  // Use DFAs to find exact location of match, filter out non-matches.
-
-  // Don't ask for the location if we won't use it.
-  // SearchDFA can do extra optimizations in that case.
-  StringPiece match;
-  StringPiece* matchp = &match;
-  if (nsubmatch == 0)
-    matchp = NULL;
-
-  int ncap = 1 + NumberOfCapturingGroups();
-  if (ncap > nsubmatch)
-    ncap = nsubmatch;
-
-  // If the regexp is anchored explicitly, must not be in middle of text.
-  if (prog_->anchor_start() && startpos != 0)
-    return false;
-  if (prog_->anchor_end() && endpos != text.size())
-    return false;
-
-  // If the regexp is anchored explicitly, update re_anchor
-  // so that we can potentially fall into a faster case below.
-  if (prog_->anchor_start() && prog_->anchor_end())
-    re_anchor = ANCHOR_BOTH;
-  else if (prog_->anchor_start() && re_anchor != ANCHOR_BOTH)
-    re_anchor = ANCHOR_START;
-
-  // Check for the required prefix, if any.
-  size_t prefixlen = 0;
-  if (!prefix_.empty()) {
-    if (startpos != 0)
-      return false;
-    prefixlen = prefix_.size();
-    if (prefixlen > subtext.size())
-      return false;
-    if (prefix_foldcase_) {
-      if (ascii_strcasecmp(&prefix_[0], subtext.data(), prefixlen) != 0)
-        return false;
-    } else {
-      if (memcmp(&prefix_[0], subtext.data(), prefixlen) != 0)
-        return false;
-    }
-    subtext.remove_prefix(prefixlen);
-    // If there is a required prefix, the anchor must be at least ANCHOR_START.
-    if (re_anchor != ANCHOR_BOTH)
-      re_anchor = ANCHOR_START;
-  }
-
-  Prog::Anchor anchor = Prog::kUnanchored;
-  Prog::MatchKind kind =
-      longest_match_ ? Prog::kLongestMatch : Prog::kFirstMatch;
-
-  bool can_one_pass = is_one_pass_ && ncap <= Prog::kMaxOnePassCapture;
-  bool can_bit_state = prog_->CanBitState();
-  size_t bit_state_text_max_size = prog_->bit_state_text_max_size();
-
-#ifdef RE2_HAVE_THREAD_LOCAL
-  hooks::context = this;
-#endif
-  bool dfa_failed = false;
-  bool skipped_test = false;
-  switch (re_anchor) {
-    default:
-      LOG(DFATAL) << "Unexpected re_anchor value: " << re_anchor;
-      return false;
-
-    case UNANCHORED: {
-      if (prog_->anchor_end()) {
-        // This is a very special case: we don't need the forward DFA because
-        // we already know where the match must end! Instead, the reverse DFA
-        // can say whether there is a match and (optionally) where it starts.
-        Prog* prog = ReverseProg();
-        if (prog == NULL) {
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        if (!prog->SearchDFA(subtext, text, Prog::kAnchored,
-                             Prog::kLongestMatch, matchp, &dfa_failed, NULL)) {
-          if (dfa_failed) {
-            if (options_.log_errors())
-              LOG(ERROR) << "DFA out of memory: "
-                         << "pattern length " << pattern_->size() << ", "
-                         << "program size " << prog->size() << ", "
-                         << "list count " << prog->list_count() << ", "
-                         << "bytemap range " << prog->bytemap_range();
-            // Fall back to NFA below.
-            skipped_test = true;
-            break;
-          }
-          return false;
-        }
-        if (matchp == NULL)  // Matched.  Don't care where.
-          return true;
-        break;
-      }
-
-      if (!prog_->SearchDFA(subtext, text, anchor, kind,
-                            matchp, &dfa_failed, NULL)) {
-        if (dfa_failed) {
-          if (options_.log_errors())
-            LOG(ERROR) << "DFA out of memory: "
-                       << "pattern length " << pattern_->size() << ", "
-                       << "program size " << prog_->size() << ", "
-                       << "list count " << prog_->list_count() << ", "
-                       << "bytemap range " << prog_->bytemap_range();
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        return false;
-      }
-      if (matchp == NULL)  // Matched.  Don't care where.
-        return true;
-      // SearchDFA set match.end() but didn't know where the
-      // match started.  Run the regexp backward from match.end()
-      // to find the longest possible match -- that's where it started.
-      Prog* prog = ReverseProg();
-      if (prog == NULL) {
-        // Fall back to NFA below.
-        skipped_test = true;
-        break;
-      }
-      if (!prog->SearchDFA(match, text, Prog::kAnchored,
-                           Prog::kLongestMatch, &match, &dfa_failed, NULL)) {
-        if (dfa_failed) {
-          if (options_.log_errors())
-            LOG(ERROR) << "DFA out of memory: "
-                       << "pattern length " << pattern_->size() << ", "
-                       << "program size " << prog->size() << ", "
-                       << "list count " << prog->list_count() << ", "
-                       << "bytemap range " << prog->bytemap_range();
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        if (options_.log_errors())
-          LOG(ERROR) << "SearchDFA inconsistency";
-        return false;
-      }
-      break;
-    }
-
-    case ANCHOR_BOTH:
-    case ANCHOR_START:
-      if (re_anchor == ANCHOR_BOTH)
-        kind = Prog::kFullMatch;
-      anchor = Prog::kAnchored;
-
-      // If only a small amount of text and need submatch
-      // information anyway and we're going to use OnePass or BitState
-      // to get it, we might as well not even bother with the DFA:
-      // OnePass or BitState will be fast enough.
-      // On tiny texts, OnePass outruns even the DFA, and
-      // it doesn't have the shared state and occasional mutex that
-      // the DFA does.
-      if (can_one_pass && text.size() <= 4096 &&
-          (ncap > 1 || text.size() <= 16)) {
-        skipped_test = true;
-        break;
-      }
-      if (can_bit_state && text.size() <= bit_state_text_max_size &&
-          ncap > 1) {
-        skipped_test = true;
-        break;
-      }
-      if (!prog_->SearchDFA(subtext, text, anchor, kind,
-                            &match, &dfa_failed, NULL)) {
-        if (dfa_failed) {
-          if (options_.log_errors())
-            LOG(ERROR) << "DFA out of memory: "
-                       << "pattern length " << pattern_->size() << ", "
-                       << "program size " << prog_->size() << ", "
-                       << "list count " << prog_->list_count() << ", "
-                       << "bytemap range " << prog_->bytemap_range();
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        return false;
-      }
-      break;
-  }
-
-  if (!skipped_test && ncap <= 1) {
-    // We know exactly where it matches.  That's enough.
-    if (ncap == 1)
-      submatch[0] = match;
-  } else {
-    StringPiece subtext1;
-    if (skipped_test) {
-      // DFA ran out of memory or was skipped:
-      // need to search in entire original text.
-      subtext1 = subtext;
-    } else {
-      // DFA found the exact match location:
-      // let NFA run an anchored, full match search
-      // to find submatch locations.
-      subtext1 = match;
-      anchor = Prog::kAnchored;
-      kind = Prog::kFullMatch;
-    }
-
-    if (can_one_pass && anchor != Prog::kUnanchored) {
-      if (!prog_->SearchOnePass(subtext1, text, anchor, kind, submatch, ncap)) {
-        if (!skipped_test && options_.log_errors())
-          LOG(ERROR) << "SearchOnePass inconsistency";
-        return false;
-      }
-    } else if (can_bit_state && subtext1.size() <= bit_state_text_max_size) {
-      if (!prog_->SearchBitState(subtext1, text, anchor,
-                                 kind, submatch, ncap)) {
-        if (!skipped_test && options_.log_errors())
-          LOG(ERROR) << "SearchBitState inconsistency";
-        return false;
-      }
-    } else {
-      if (!prog_->SearchNFA(subtext1, text, anchor, kind, submatch, ncap)) {
-        if (!skipped_test && options_.log_errors())
-          LOG(ERROR) << "SearchNFA inconsistency";
-        return false;
-      }
-    }
-  }
-
-  // Adjust overall match for required prefix that we stripped off.
-  if (prefixlen > 0 && nsubmatch > 0)
-    submatch[0] = StringPiece(submatch[0].data() - prefixlen,
-                              submatch[0].size() + prefixlen);
-
-  // Zero submatches that don't exist in the regexp.
-  for (int i = ncap; i < nsubmatch; i++)
-    submatch[i] = StringPiece();
-  return true;
-}
-
-// Internal matcher - like Match() but takes Args not StringPieces.
-bool RE2::DoMatch(const StringPiece& text,
-                  Anchor re_anchor,
-                  size_t* consumed,
-                  const Arg* const* args,
-                  int n) const {
-  if (!ok()) {
-    if (options_.log_errors())
-      LOG(ERROR) << "Invalid RE2: " << *error_;
-    return false;
-  }
-
-  if (NumberOfCapturingGroups() < n) {
-    // RE has fewer capturing groups than number of Arg pointers passed in.
-    return false;
-  }
-
-  // Count number of capture groups needed.
-  int nvec;
-  if (n == 0 && consumed == NULL)
-    nvec = 0;
-  else
-    nvec = n+1;
-
-  StringPiece* vec;
-  StringPiece stkvec[kVecSize];
-  StringPiece* heapvec = NULL;
-
-  if (nvec <= static_cast<int>(arraysize(stkvec))) {
-    vec = stkvec;
-  } else {
-    vec = new StringPiece[nvec];
-    heapvec = vec;
-  }
-
-  if (!Match(text, 0, text.size(), re_anchor, vec, nvec)) {
-    delete[] heapvec;
-    return false;
-  }
-
-  if (consumed != NULL)
-    *consumed = static_cast<size_t>(EndPtr(vec[0]) - BeginPtr(text));
-
-  if (n == 0 || args == NULL) {
-    // We are not interested in results
-    delete[] heapvec;
-    return true;
-  }
-
-  // If we got here, we must have matched the whole pattern.
-  for (int i = 0; i < n; i++) {
-    const StringPiece& s = vec[i+1];
-    if (!args[i]->Parse(s.data(), s.size())) {
-      // TODO: Should we indicate what the error was?
-      delete[] heapvec;
-      return false;
-    }
-  }
-
-  delete[] heapvec;
-  return true;
-}
-
-// Checks that the rewrite string is well-formed with respect to this
-// regular expression.
-bool RE2::CheckRewriteString(const StringPiece& rewrite,
-                             std::string* error) const {
-  int max_token = -1;
-  for (const char *s = rewrite.data(), *end = s + rewrite.size();
-       s < end; s++) {
-    int c = *s;
-    if (c != '\\') {
-      continue;
-    }
-    if (++s == end) {
-      *error = "Rewrite schema error: '\\' not allowed at end.";
-      return false;
-    }
-    c = *s;
-    if (c == '\\') {
-      continue;
-    }
-    if (!isdigit(c)) {
-      *error = "Rewrite schema error: "
-               "'\\' must be followed by a digit or '\\'.";
-      return false;
-    }
-    int n = (c - '0');
-    if (max_token < n) {
-      max_token = n;
-    }
-  }
-
-  if (max_token > NumberOfCapturingGroups()) {
-    *error = StringPrintf(
-        "Rewrite schema requests %d matches, but the regexp only has %d "
-        "parenthesized subexpressions.",
-        max_token, NumberOfCapturingGroups());
-    return false;
-  }
-  return true;
-}
-
-// Returns the maximum submatch needed for the rewrite to be done by Replace().
-// E.g. if rewrite == "foo \\2,\\1", returns 2.
-int RE2::MaxSubmatch(const StringPiece& rewrite) {
-  int max = 0;
-  for (const char *s = rewrite.data(), *end = s + rewrite.size();
-       s < end; s++) {
-    if (*s == '\\') {
-      s++;
-      int c = (s < end) ? *s : -1;
-      if (isdigit(c)) {
-        int n = (c - '0');
-        if (n > max)
-          max = n;
-      }
-    }
-  }
-  return max;
-}
-
-// Append the "rewrite" string, with backslash subsitutions from "vec",
-// to string "out".
-bool RE2::Rewrite(std::string* out,
-                  const StringPiece& rewrite,
-                  const StringPiece* vec,
-                  int veclen) const {
-  for (const char *s = rewrite.data(), *end = s + rewrite.size();
-       s < end; s++) {
-    if (*s != '\\') {
-      out->push_back(*s);
-      continue;
-    }
-    s++;
-    int c = (s < end) ? *s : -1;
-    if (isdigit(c)) {
-      int n = (c - '0');
-      if (n >= veclen) {
-        if (options_.log_errors()) {
-          LOG(ERROR) << "invalid substitution \\" << n
-                     << " from " << veclen << " groups";
-        }
-        return false;
-      }
-      StringPiece snip = vec[n];
-      if (!snip.empty())
-        out->append(snip.data(), snip.size());
-    } else if (c == '\\') {
-      out->push_back('\\');
-    } else {
-      if (options_.log_errors())
-        LOG(ERROR) << "invalid rewrite pattern: " << rewrite.data();
-      return false;
-    }
-  }
-  return true;
-}
-
-/***** Parsers for various types *****/
-
-namespace re2_internal {
-
-template <>
-bool Parse(const char* str, size_t n, void* dest) {
-  // We fail if somebody asked us to store into a non-NULL void* pointer
-  return (dest == NULL);
-}
-
-template <>
-bool Parse(const char* str, size_t n, std::string* dest) {
-  if (dest == NULL) return true;
-  dest->assign(str, n);
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, StringPiece* dest) {
-  if (dest == NULL) return true;
-  *dest = StringPiece(str, n);
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, char* dest) {
-  if (n != 1) return false;
-  if (dest == NULL) return true;
-  *dest = str[0];
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, signed char* dest) {
-  if (n != 1) return false;
-  if (dest == NULL) return true;
-  *dest = str[0];
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, unsigned char* dest) {
-  if (n != 1) return false;
-  if (dest == NULL) return true;
-  *dest = str[0];
-  return true;
-}
-
-// Largest number spec that we are willing to parse
-static const int kMaxNumberLength = 32;
-
-// REQUIRES "buf" must have length at least nbuf.
-// Copies "str" into "buf" and null-terminates.
-// Overwrites *np with the new length.
-static const char* TerminateNumber(char* buf, size_t nbuf, const char* str,
-                                   size_t* np, bool accept_spaces) {
-  size_t n = *np;
-  if (n == 0) return "";
-  if (n > 0 && isspace(*str)) {
-    // We are less forgiving than the strtoxxx() routines and do not
-    // allow leading spaces. We do allow leading spaces for floats.
-    if (!accept_spaces) {
-      return "";
-    }
-    while (n > 0 && isspace(*str)) {
-      n--;
-      str++;
-    }
-  }
-
-  // Although buf has a fixed maximum size, we can still handle
-  // arbitrarily large integers correctly by omitting leading zeros.
-  // (Numbers that are still too long will be out of range.)
-  // Before deciding whether str is too long,
-  // remove leading zeros with s/000+/00/.
-  // Leaving the leading two zeros in place means that
-  // we don't change 0000x123 (invalid) into 0x123 (valid).
-  // Skip over leading - before replacing.
-  bool neg = false;
-  if (n >= 1 && str[0] == '-') {
-    neg = true;
-    n--;
-    str++;
-  }
-
-  if (n >= 3 && str[0] == '0' && str[1] == '0') {
-    while (n >= 3 && str[2] == '0') {
-      n--;
-      str++;
-    }
-  }
-
-  if (neg) {  // make room in buf for -
-    n++;
-    str--;
-  }
-
-  if (n > nbuf-1) return "";
-
-  memmove(buf, str, n);
-  if (neg) {
-    buf[0] = '-';
-  }
-  buf[n] = '\0';
-  *np = n;
-  return buf;
-}
-
-template <>
-bool Parse(const char* str, size_t n, float* dest) {
-  if (n == 0) return false;
-  static const int kMaxLength = 200;
-  char buf[kMaxLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, true);
-  char* end;
-  errno = 0;
-  float r = strtof(str, &end);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *dest = r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, double* dest) {
-  if (n == 0) return false;
-  static const int kMaxLength = 200;
-  char buf[kMaxLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, true);
-  char* end;
-  errno = 0;
-  double r = strtod(str, &end);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *dest = r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, long* dest, int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  char* end;
-  errno = 0;
-  long r = strtol(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *dest = r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, unsigned long* dest, int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  if (str[0] == '-') {
-    // strtoul() will silently accept negative numbers and parse
-    // them.  This module is more strict and treats them as errors.
-    return false;
-  }
-
-  char* end;
-  errno = 0;
-  unsigned long r = strtoul(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *dest = r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, short* dest, int radix) {
-  long r;
-  if (!Parse(str, n, &r, radix)) return false;  // Could not parse
-  if ((short)r != r) return false;              // Out of range
-  if (dest == NULL) return true;
-  *dest = (short)r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, unsigned short* dest, int radix) {
-  unsigned long r;
-  if (!Parse(str, n, &r, radix)) return false;  // Could not parse
-  if ((unsigned short)r != r) return false;     // Out of range
-  if (dest == NULL) return true;
-  *dest = (unsigned short)r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, int* dest, int radix) {
-  long r;
-  if (!Parse(str, n, &r, radix)) return false;  // Could not parse
-  if ((int)r != r) return false;                // Out of range
-  if (dest == NULL) return true;
-  *dest = (int)r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, unsigned int* dest, int radix) {
-  unsigned long r;
-  if (!Parse(str, n, &r, radix)) return false;  // Could not parse
-  if ((unsigned int)r != r) return false;       // Out of range
-  if (dest == NULL) return true;
-  *dest = (unsigned int)r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, long long* dest, int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  char* end;
-  errno = 0;
-  long long r = strtoll(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *dest = r;
-  return true;
-}
-
-template <>
-bool Parse(const char* str, size_t n, unsigned long long* dest, int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  if (str[0] == '-') {
-    // strtoull() will silently accept negative numbers and parse
-    // them.  This module is more strict and treats them as errors.
-    return false;
-  }
-  char* end;
-  errno = 0;
-  unsigned long long r = strtoull(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *dest = r;
-  return true;
-}
-
-}  // namespace re2_internal
-
-namespace hooks {
-
-#ifdef RE2_HAVE_THREAD_LOCAL
-thread_local const RE2* context = NULL;
-#endif
-
-template <typename T>
-union Hook {
-  void Store(T* cb) { cb_.store(cb, std::memory_order_release); }
-  T* Load() const { return cb_.load(std::memory_order_acquire); }
-
-#if !defined(__clang__) && defined(_MSC_VER)
-  // Citing https://github.com/protocolbuffers/protobuf/pull/4777 as precedent,
-  // this is a gross hack to make std::atomic<T*> constant-initialized on MSVC.
-  static_assert(ATOMIC_POINTER_LOCK_FREE == 2,
-                "std::atomic<T*> must be always lock-free");
-  T* cb_for_constinit_;
-#endif
-
-  std::atomic<T*> cb_;
-};
-
-template <typename T>
-static void DoNothing(const T&) {}
-
-#define DEFINE_HOOK(type, name)                                       \
-  static Hook<type##Callback> name##_hook = {{&DoNothing<type>}};     \
-  void Set##type##Hook(type##Callback* cb) { name##_hook.Store(cb); } \
-  type##Callback* Get##type##Hook() { return name##_hook.Load(); }
-
-DEFINE_HOOK(DFAStateCacheReset, dfa_state_cache_reset)
-DEFINE_HOOK(DFASearchFailure, dfa_search_failure)
-
-#undef DEFINE_HOOK
-
-}  // namespace hooks
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/re2.h b/src/duckdb/third_party/re2/re2/re2.h
deleted file mode 100644
index da4df537e..000000000
--- a/src/duckdb/third_party/re2/re2/re2.h
+++ /dev/null
@@ -1,1031 +0,0 @@
-// Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_RE2_H_
-#define RE2_RE2_H_
-
-// C++ interface to the re2 regular-expression library.
-// RE2 supports Perl-style regular expressions (with extensions like
-// \d, \w, \s, ...).
-//
-// -----------------------------------------------------------------------
-// REGEXP SYNTAX:
-//
-// This module uses the re2 library and hence supports
-// its syntax for regular expressions, which is similar to Perl's with
-// some of the more complicated things thrown away.  In particular,
-// backreferences and generalized assertions are not available, nor is \Z.
-//
-// See https://github.com/google/re2/wiki/Syntax for the syntax
-// supported by RE2, and a comparison with PCRE and PERL regexps.
-//
-// For those not familiar with Perl's regular expressions,
-// here are some examples of the most commonly used extensions:
-//
-//   "hello (\\w+) world"  -- \w matches a "word" character
-//   "version (\\d+)"      -- \d matches a digit
-//   "hello\\s+world"      -- \s matches any whitespace character
-//   "\\b(\\w+)\\b"        -- \b matches non-empty string at word boundary
-//   "(?i)hello"           -- (?i) turns on case-insensitive matching
-//   "/\\*(.*?)\\*/"       -- .*? matches . minimum no. of times possible
-//
-// The double backslashes are needed when writing C++ string literals.
-// However, they should NOT be used when writing C++11 raw string literals:
-//
-//   R"(hello (\w+) world)"  -- \w matches a "word" character
-//   R"(version (\d+))"      -- \d matches a digit
-//   R"(hello\s+world)"      -- \s matches any whitespace character
-//   R"(\b(\w+)\b)"          -- \b matches non-empty string at word boundary
-//   R"((?i)hello)"          -- (?i) turns on case-insensitive matching
-//   R"(/\*(.*?)\*/)"        -- .*? matches . minimum no. of times possible
-//
-// When using UTF-8 encoding, case-insensitive matching will perform
-// simple case folding, not full case folding.
-//
-// -----------------------------------------------------------------------
-// MATCHING INTERFACE:
-//
-// The "FullMatch" operation checks that supplied text matches a
-// supplied pattern exactly.
-//
-// Example: successful match
-//    CHECK(RE2::FullMatch("hello", "h.*o"));
-//
-// Example: unsuccessful match (requires full match):
-//    CHECK(!RE2::FullMatch("hello", "e"));
-//
-// -----------------------------------------------------------------------
-// UTF-8 AND THE MATCHING INTERFACE:
-//
-// By default, the pattern and input text are interpreted as UTF-8.
-// The RE2::Latin1 option causes them to be interpreted as Latin-1.
-//
-// Example:
-//    CHECK(RE2::FullMatch(utf8_string, RE2(utf8_pattern)));
-//    CHECK(RE2::FullMatch(latin1_string, RE2(latin1_pattern, RE2::Latin1)));
-//
-// -----------------------------------------------------------------------
-// SUBMATCH EXTRACTION:
-//
-// You can supply extra pointer arguments to extract submatches.
-// On match failure, none of the pointees will have been modified.
-// On match success, the submatches will be converted (as necessary) and
-// their values will be assigned to their pointees until all conversions
-// have succeeded or one conversion has failed.
-// On conversion failure, the pointees will be in an indeterminate state
-// because the caller has no way of knowing which conversion failed.
-// However, conversion cannot fail for types like string and StringPiece
-// that do not inspect the submatch contents. Hence, in the common case
-// where all of the pointees are of such types, failure is always due to
-// match failure and thus none of the pointees will have been modified.
-//
-// Example: extracts "ruby" into "s" and 1234 into "i"
-//    int i;
-//    std::string s;
-//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i));
-//
-// Example: fails because string cannot be stored in integer
-//    CHECK(!RE2::FullMatch("ruby", "(.*)", &i));
-//
-// Example: fails because there aren't enough sub-patterns
-//    CHECK(!RE2::FullMatch("ruby:1234", "\\w+:\\d+", &s));
-//
-// Example: does not try to extract any extra sub-patterns
-//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s));
-//
-// Example: does not try to extract into NULL
-//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", NULL, &i));
-//
-// Example: integer overflow causes failure
-//    CHECK(!RE2::FullMatch("ruby:1234567891234", "\\w+:(\\d+)", &i));
-//
-// NOTE(rsc): Asking for submatches slows successful matches quite a bit.
-// This may get a little faster in the future, but right now is slower
-// than PCRE.  On the other hand, failed matches run *very* fast (faster
-// than PCRE), as do matches without submatch extraction.
-//
-// -----------------------------------------------------------------------
-// PARTIAL MATCHES
-//
-// You can use the "PartialMatch" operation when you want the pattern
-// to match any substring of the text.
-//
-// Example: simple search for a string:
-//      CHECK(RE2::PartialMatch("hello", "ell"));
-//
-// Example: find first number in a string
-//      int number;
-//      CHECK(RE2::PartialMatch("x*100 + 20", "(\\d+)", &number));
-//      CHECK_EQ(number, 100);
-//
-// -----------------------------------------------------------------------
-// PRE-COMPILED REGULAR EXPRESSIONS
-//
-// RE2 makes it easy to use any string as a regular expression, without
-// requiring a separate compilation step.
-//
-// If speed is of the essence, you can create a pre-compiled "RE2"
-// object from the pattern and use it multiple times.  If you do so,
-// you can typically parse text faster than with sscanf.
-//
-// Example: precompile pattern for faster matching:
-//    RE2 pattern("h.*o");
-//    while (ReadLine(&str)) {
-//      if (RE2::FullMatch(str, pattern)) ...;
-//    }
-//
-// -----------------------------------------------------------------------
-// SCANNING TEXT INCREMENTALLY
-//
-// The "Consume" operation may be useful if you want to repeatedly
-// match regular expressions at the front of a string and skip over
-// them as they match.  This requires use of the "StringPiece" type,
-// which represents a sub-range of a real string.
-//
-// Example: read lines of the form "var = value" from a string.
-//      std::string contents = ...;     // Fill string somehow
-//      StringPiece input(contents);    // Wrap a StringPiece around it
-//
-//      std::string var;
-//      int value;
-//      while (RE2::Consume(&input, "(\\w+) = (\\d+)\n", &var, &value)) {
-//        ...;
-//      }
-//
-// Each successful call to "Consume" will set "var/value", and also
-// advance "input" so it points past the matched text.  Note that if the
-// regular expression matches an empty string, input will advance
-// by 0 bytes.  If the regular expression being used might match
-// an empty string, the loop body must check for this case and either
-// advance the string or break out of the loop.
-//
-// The "FindAndConsume" operation is similar to "Consume" but does not
-// anchor your match at the beginning of the string.  For example, you
-// could extract all words from a string by repeatedly calling
-//     RE2::FindAndConsume(&input, "(\\w+)", &word)
-//
-// -----------------------------------------------------------------------
-// USING VARIABLE NUMBER OF ARGUMENTS
-//
-// The above operations require you to know the number of arguments
-// when you write the code.  This is not always possible or easy (for
-// example, the regular expression may be calculated at run time).
-// You can use the "N" version of the operations when the number of
-// match arguments are determined at run time.
-//
-// Example:
-//   const RE2::Arg* args[10];
-//   int n;
-//   // ... populate args with pointers to RE2::Arg values ...
-//   // ... set n to the number of RE2::Arg objects ...
-//   bool match = RE2::FullMatchN(input, pattern, args, n);
-//
-// The last statement is equivalent to
-//
-//   bool match = RE2::FullMatch(input, pattern,
-//                               *args[0], *args[1], ..., *args[n - 1]);
-//
-// -----------------------------------------------------------------------
-// PARSING HEX/OCTAL/C-RADIX NUMBERS
-//
-// By default, if you pass a pointer to a numeric value, the
-// corresponding text is interpreted as a base-10 number.  You can
-// instead wrap the pointer with a call to one of the operators Hex(),
-// Octal(), or CRadix() to interpret the text in another base.  The
-// CRadix operator interprets C-style "0" (base-8) and "0x" (base-16)
-// prefixes, but defaults to base-10.
-//
-// Example:
-//   int a, b, c, d;
-//   CHECK(RE2::FullMatch("100 40 0100 0x40", "(.*) (.*) (.*) (.*)",
-//         RE2::Octal(&a), RE2::Hex(&b), RE2::CRadix(&c), RE2::CRadix(&d));
-// will leave 64 in a, b, c, and d.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <algorithm>
-#include <map>
-#include <mutex>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-#include "re2/stringpiece.h"
-
-namespace duckdb_re2 {
-class Prog;
-class Regexp;
-}  // namespace re2
-
-namespace duckdb_re2 {
-
-// Interface for regular expression matching.  Also corresponds to a
-// pre-compiled regular expression.  An "RE2" object is safe for
-// concurrent use by multiple threads.
-class RE2 {
- public:
-  // We convert user-passed pointers into special Arg objects
-  class Arg;
-  class Options;
-
-  // Defined in set.h.
-  class Set;
-
-  enum ErrorCode {
-    NoError = 0,
-
-    // Unexpected error
-    ErrorInternal,
-
-    // Parse errors
-    ErrorBadEscape,          // bad escape sequence
-    ErrorBadCharClass,       // bad character class
-    ErrorBadCharRange,       // bad character class range
-    ErrorMissingBracket,     // missing closing ]
-    ErrorMissingParen,       // missing closing )
-    ErrorUnexpectedParen,    // unexpected closing )
-    ErrorTrailingBackslash,  // trailing \ at end of regexp
-    ErrorRepeatArgument,     // repeat argument missing, e.g. "*"
-    ErrorRepeatSize,         // bad repetition argument
-    ErrorRepeatOp,           // bad repetition operator
-    ErrorBadPerlOp,          // bad perl operator
-    ErrorBadUTF8,            // invalid UTF-8 in regexp
-    ErrorBadNamedCapture,    // bad named capture group
-    ErrorPatternTooLarge     // pattern too large (compile failed)
-  };
-
-  // Predefined common options.
-  // If you need more complicated things, instantiate
-  // an Option class, possibly passing one of these to
-  // the Option constructor, change the settings, and pass that
-  // Option class to the RE2 constructor.
-  enum CannedOptions {
-    DefaultOptions = 0,
-    Latin1, // treat input as Latin-1 (default UTF-8)
-    POSIX, // POSIX syntax, leftmost-longest match
-    Quiet // do not log about regexp parse errors
-  };
-
-  // Need to have the const char* and const std::string& forms for implicit
-  // conversions when passing string literals to FullMatch and PartialMatch.
-  // Otherwise the StringPiece form would be sufficient.
-  RE2(const char* pattern);
-  RE2(const std::string& pattern);
-  RE2(const StringPiece& pattern);
-  RE2(const StringPiece& pattern, const Options& options);
-  ~RE2();
-
-  // Not copyable.
-  // RE2 objects are expensive. You should probably use std::shared_ptr<RE2>
-  // instead. If you really must copy, RE2(first.pattern(), first.options())
-  // effectively does so: it produces a second object that mimics the first.
-  RE2(const RE2&) = delete;
-  RE2& operator=(const RE2&) = delete;
-  // Not movable.
-  // RE2 objects are thread-safe and logically immutable. You should probably
-  // use std::unique_ptr<RE2> instead. Otherwise, consider std::deque<RE2> if
-  // direct emplacement into a container is desired. If you really must move,
-  // be prepared to submit a design document along with your feature request.
-  RE2(RE2&&) = delete;
-  RE2& operator=(RE2&&) = delete;
-
-  // Returns whether RE2 was created properly.
-  bool ok() const { return error_code() == NoError; }
-
-  // The string specification for this RE2.  E.g.
-  //   RE2 re("ab*c?d+");
-  //   re.pattern();    // "ab*c?d+"
-  const std::string& pattern() const { return *pattern_; }
-
-  // If RE2 could not be created properly, returns an error string.
-  // Else returns the empty string.
-  const std::string& error() const { return *error_; }
-
-  // If RE2 could not be created properly, returns an error code.
-  // Else returns RE2::NoError (== 0).
-  ErrorCode error_code() const { return error_code_; }
-
-  // If RE2 could not be created properly, returns the offending
-  // portion of the regexp.
-  const std::string& error_arg() const { return *error_arg_; }
-
-  // Returns the program size, a very approximate measure of a regexp's "cost".
-  // Larger numbers are more expensive than smaller numbers.
-  int ProgramSize() const;
-  int ReverseProgramSize() const;
-
-  // If histogram is not null, outputs the program fanout
-  // as a histogram bucketed by powers of 2.
-  // Returns the number of the largest non-empty bucket.
-  int ProgramFanout(std::vector<int>* histogram) const;
-  int ReverseProgramFanout(std::vector<int>* histogram) const;
-
-  // Returns the underlying Regexp; not for general use.
-  // Returns entire_regexp_ so that callers don't need
-  // to know about prefix_ and prefix_foldcase_.
-  duckdb_re2::Regexp* Regexp() const { return entire_regexp_; }
-
-  /***** The array-based matching interface ******/
-
-  // The functions here have names ending in 'N' and are used to implement
-  // the functions whose names are the prefix before the 'N'. It is sometimes
-  // useful to invoke them directly, but the syntax is awkward, so the 'N'-less
-  // versions should be preferred.
-  static bool FullMatchN(const StringPiece& text, const RE2& re,
-                         const Arg* const args[], int n);
-  static bool PartialMatchN(const StringPiece& text, const RE2& re,
-                            const Arg* const args[], int n);
-  static bool ConsumeN(StringPiece* input, const RE2& re,
-                       const Arg* const args[], int n);
-  static bool FindAndConsumeN(StringPiece* input, const RE2& re,
-                              const Arg* const args[], int n);
-
- private:
-  template <typename F, typename SP>
-  static inline bool Apply(F f, SP sp, const RE2& re) {
-    return f(sp, re, NULL, 0);
-  }
-
-  template <typename F, typename SP, typename... A>
-  static inline bool Apply(F f, SP sp, const RE2& re, const A&... a) {
-    const Arg* const args[] = {&a...};
-    const int n = sizeof...(a);
-    return f(sp, re, args, n);
-  }
-
- public:
-  // In order to allow FullMatch() et al. to be called with a varying number
-  // of arguments of varying types, we use two layers of variadic templates.
-  // The first layer constructs the temporary Arg objects. The second layer
-  // (above) constructs the array of pointers to the temporary Arg objects.
-
-  /***** The useful part: the matching interface *****/
-
-  // Matches "text" against "re".  If pointer arguments are
-  // supplied, copies matched sub-patterns into them.
-  //
-  // You can pass in a "const char*" or a "std::string" for "text".
-  // You can pass in a "const char*" or a "std::string" or a "RE2" for "re".
-  //
-  // The provided pointer arguments can be pointers to any scalar numeric
-  // type, or one of:
-  //    std::string     (matched piece is copied to string)
-  //    StringPiece     (StringPiece is mutated to point to matched piece)
-  //    T               (where "bool T::ParseFrom(const char*, size_t)" exists)
-  //    (void*)NULL     (the corresponding matched sub-pattern is not copied)
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" fully - from the beginning to the end of "text".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  //
-  // CAVEAT: An optional sub-pattern that does not exist in the
-  // matched string is assigned the empty string.  Therefore, the
-  // following will return false (because the empty string is not a
-  // valid number):
-  //    int number;
-  //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
-  template <typename... A>
-  static bool FullMatch(const StringPiece& text, const RE2& re, A&&... a) {
-    return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch(), except that "re" is allowed to match a substring
-  // of "text".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" partially - for some substring of "text".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool PartialMatch(const StringPiece& text, const RE2& re, A&&... a) {
-    return Apply(PartialMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch() and PartialMatch(), except that "re" has to match
-  // a prefix of the text, and "input" is advanced past the matched
-  // text.  Note: "input" is modified iff this routine returns true
-  // and "re" matched a non-empty substring of "input".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "input" matches "re" partially - for some prefix of "input".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool Consume(StringPiece* input, const RE2& re, A&&... a) {
-    return Apply(ConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like Consume(), but does not anchor the match at the beginning of
-  // the text.  That is, "re" need not start its match at the beginning
-  // of "input".  For example, "FindAndConsume(s, "(\\w+)", &word)" finds
-  // the next word in "s" and stores it in "word".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "input" matches "re" partially - for some substring of "input".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool FindAndConsume(StringPiece* input, const RE2& re, A&&... a) {
-    return Apply(FindAndConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Replace the first match of "re" in "str" with "rewrite".
-  // Within "rewrite", backslash-escaped digits (\1 to \9) can be
-  // used to insert text matching corresponding parenthesized group
-  // from the pattern.  \0 in "rewrite" refers to the entire matching
-  // text.  E.g.,
-  //
-  //   std::string s = "yabba dabba doo";
-  //   CHECK(RE2::Replace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dabba doo"
-  //
-  // Returns true if the pattern matches and a replacement occurs,
-  // false otherwise.
-  static bool Replace(std::string* str,
-                      const RE2& re,
-                      const StringPiece& rewrite);
-
-  // Like Replace(), except replaces successive non-overlapping occurrences
-  // of the pattern in the string with the rewrite. E.g.
-  //
-  //   std::string s = "yabba dabba doo";
-  //   CHECK(RE2::GlobalReplace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dada doo"
-  // Replacements are not subject to re-matching.
-  //
-  // Because GlobalReplace only replaces non-overlapping matches,
-  // replacing "ana" within "banana" makes only one replacement, not two.
-  //
-  // Returns the number of replacements made.
-  static int GlobalReplace(std::string* str,
-                           const RE2& re,
-                           const StringPiece& rewrite);
-
-  // Like Replace, except that if the pattern matches, "rewrite"
-  // is copied into "out" with substitutions.  The non-matching
-  // portions of "text" are ignored.
-  //
-  // Returns true iff a match occurred and the extraction happened
-  // successfully;  if no match occurs, the string is left unaffected.
-  //
-  // REQUIRES: "text" must not alias any part of "*out".
-  static bool Extract(const StringPiece& text,
-                      const RE2& re,
-                      const StringPiece& rewrite,
-                      std::string* out);
-
-  // Escapes all potentially meaningful regexp characters in
-  // 'unquoted'.  The returned string, used as a regular expression,
-  // will match exactly the original string.  For example,
-  //           1.5-2.0?
-  // may become:
-  //           1\.5\-2\.0\?
-  static std::string QuoteMeta(const StringPiece& unquoted);
-
-  // Computes range for any strings matching regexp. The min and max can in
-  // some cases be arbitrarily precise, so the caller gets to specify the
-  // maximum desired length of string returned.
-  //
-  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
-  // string s that is an anchored match for this regexp satisfies
-  //   min <= s && s <= max.
-  //
-  // Note that PossibleMatchRange() will only consider the first copy of an
-  // infinitely repeated element (i.e., any regexp element followed by a '*' or
-  // '+' operator). Regexps with "{N}" constructions are not affected, as those
-  // do not compile down to infinite repetitions.
-  //
-  // Returns true on success, false on error.
-  bool PossibleMatchRange(std::string* min, std::string* max,
-                          int maxlen) const;
-
-  // Generic matching interface
-
-  // Type of match.
-  enum Anchor {
-    UNANCHORED,         // No anchoring
-    ANCHOR_START,       // Anchor at start only
-    ANCHOR_BOTH         // Anchor at start and end
-  };
-
-  // Return the number of capturing subpatterns, or -1 if the
-  // regexp wasn't valid on construction.  The overall match ($0)
-  // does not count: if the regexp is "(a)(b)", returns 2.
-  int NumberOfCapturingGroups() const { return num_captures_; }
-
-  // Return a map from names to capturing indices.
-  // The map records the index of the leftmost group
-  // with the given name.
-  // Only valid until the re is deleted.
-  const std::map<std::string, int>& NamedCapturingGroups() const;
-
-  // Return a map from capturing indices to names.
-  // The map has no entries for unnamed groups.
-  // Only valid until the re is deleted.
-  const std::map<int, std::string>& CapturingGroupNames() const;
-
-  // General matching routine.
-  // Match against text starting at offset startpos
-  // and stopping the search at offset endpos.
-  // Returns true if match found, false if not.
-  // On a successful match, fills in submatch[] (up to nsubmatch entries)
-  // with information about submatches.
-  // I.e. matching RE2("(foo)|(bar)baz") on "barbazbla" will return true, with
-  // submatch[0] = "barbaz", submatch[1].data() = NULL, submatch[2] = "bar",
-  // submatch[3].data() = NULL, ..., up to submatch[nsubmatch-1].data() = NULL.
-  // Caveat: submatch[] may be clobbered even on match failure.
-  //
-  // Don't ask for more match information than you will use:
-  // runs much faster with nsubmatch == 1 than nsubmatch > 1, and
-  // runs even faster if nsubmatch == 0.
-  // Doesn't make sense to use nsubmatch > 1 + NumberOfCapturingGroups(),
-  // but will be handled correctly.
-  //
-  // Passing text == StringPiece(NULL, 0) will be handled like any other
-  // empty string, but note that on return, it will not be possible to tell
-  // whether submatch i matched the empty string or did not match:
-  // either way, submatch[i].data() == NULL.
-  bool Match(const StringPiece& text,
-             size_t startpos,
-             size_t endpos,
-             Anchor re_anchor,
-             StringPiece* submatch,
-             int nsubmatch) const;
-
-  // Check that the given rewrite string is suitable for use with this
-  // regular expression.  It checks that:
-  //   * The regular expression has enough parenthesized subexpressions
-  //     to satisfy all of the \N tokens in rewrite
-  //   * The rewrite string doesn't have any syntax errors.  E.g.,
-  //     '\' followed by anything other than a digit or '\'.
-  // A true return value guarantees that Replace() and Extract() won't
-  // fail because of a bad rewrite string.
-  bool CheckRewriteString(const StringPiece& rewrite,
-                          std::string* error) const;
-
-  // Returns the maximum submatch needed for the rewrite to be done by
-  // Replace(). E.g. if rewrite == "foo \\2,\\1", returns 2.
-  static int MaxSubmatch(const StringPiece& rewrite);
-
-  // Append the "rewrite" string, with backslash subsitutions from "vec",
-  // to string "out".
-  // Returns true on success.  This method can fail because of a malformed
-  // rewrite string.  CheckRewriteString guarantees that the rewrite will
-  // be sucessful.
-  bool Rewrite(std::string* out,
-               const StringPiece& rewrite,
-               const StringPiece* vec,
-               int veclen) const;
-
-  // Constructor options
-  class Options {
-   public:
-    // The options are (defaults in parentheses):
-    //
-    //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
-    //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
-    //   longest_match    (false) search for longest match, not first match
-    //   log_errors       (true)  log syntax and execution errors to ERROR
-    //   max_mem          (see below)  approx. max memory footprint of RE2
-    //   literal          (false) interpret string as literal, not regexp
-    //   never_nl         (false) never match \n, even if it is in regexp
-    //   dot_nl           (false) dot matches everything including new line
-    //   never_capture    (false) parse all parens as non-capturing
-    //   case_sensitive   (true)  match is case-sensitive (regexp can override
-    //                              with (?i) unless in posix_syntax mode)
-    //
-    // The following options are only consulted when posix_syntax == true.
-    // When posix_syntax == false, these features are always enabled and
-    // cannot be turned off; to perform multi-line matching in that case,
-    // begin the regexp with (?m).
-    //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
-    //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
-    //   one_line         (false) ^ and $ only match beginning and end of text
-    //
-    // The max_mem option controls how much memory can be used
-    // to hold the compiled form of the regexp (the Prog) and
-    // its cached DFA graphs.  Code Search placed limits on the number
-    // of Prog instructions and DFA states: 10,000 for both.
-    // In RE2, those limits would translate to about 240 KB per Prog
-    // and perhaps 2.5 MB per DFA (DFA state sizes vary by regexp; RE2 does a
-    // better job of keeping them small than Code Search did).
-    // Each RE2 has two Progs (one forward, one reverse), and each Prog
-    // can have two DFAs (one first match, one longest match).
-    // That makes 4 DFAs:
-    //
-    //   forward, first-match    - used for UNANCHORED or ANCHOR_START searches
-    //                               if opt.longest_match() == false
-    //   forward, longest-match  - used for all ANCHOR_BOTH searches,
-    //                               and the other two kinds if
-    //                               opt.longest_match() == true
-    //   reverse, first-match    - never used
-    //   reverse, longest-match  - used as second phase for unanchored searches
-    //
-    // The RE2 memory budget is statically divided between the two
-    // Progs and then the DFAs: two thirds to the forward Prog
-    // and one third to the reverse Prog.  The forward Prog gives half
-    // of what it has left over to each of its DFAs.  The reverse Prog
-    // gives it all to its longest-match DFA.
-    //
-    // Once a DFA fills its budget, it flushes its cache and starts over.
-    // If this happens too often, RE2 falls back on the NFA implementation.
-
-    // For now, make the default budget something close to Code Search.
-    static const int kDefaultMaxMem = 8<<20;
-
-    enum Encoding {
-      EncodingUTF8 = 1,
-      EncodingLatin1
-    };
-
-    Options() :
-      max_mem_(kDefaultMaxMem),
-      encoding_(EncodingUTF8),
-      posix_syntax_(false),
-      longest_match_(false),
-      log_errors_(true),
-      literal_(false),
-      never_nl_(false),
-      dot_nl_(false),
-      never_capture_(false),
-      case_sensitive_(true),
-      perl_classes_(false),
-      word_boundary_(false),
-      one_line_(false) {
-    }
-
-    /*implicit*/ Options(CannedOptions);
-
-    int64_t max_mem() const { return max_mem_; }
-    void set_max_mem(int64_t m) { max_mem_ = m; }
-
-    Encoding encoding() const { return encoding_; }
-    void set_encoding(Encoding encoding) { encoding_ = encoding; }
-
-    bool posix_syntax() const { return posix_syntax_; }
-    void set_posix_syntax(bool b) { posix_syntax_ = b; }
-
-    bool longest_match() const { return longest_match_; }
-    void set_longest_match(bool b) { longest_match_ = b; }
-
-    bool log_errors() const { return log_errors_; }
-    void set_log_errors(bool b) { log_errors_ = b; }
-
-    bool literal() const { return literal_; }
-    void set_literal(bool b) { literal_ = b; }
-
-    bool never_nl() const { return never_nl_; }
-    void set_never_nl(bool b) { never_nl_ = b; }
-
-    bool dot_nl() const { return dot_nl_; }
-    void set_dot_nl(bool b) { dot_nl_ = b; }
-
-    bool never_capture() const { return never_capture_; }
-    void set_never_capture(bool b) { never_capture_ = b; }
-
-    bool case_sensitive() const { return case_sensitive_; }
-    void set_case_sensitive(bool b) { case_sensitive_ = b; }
-
-    bool perl_classes() const { return perl_classes_; }
-    void set_perl_classes(bool b) { perl_classes_ = b; }
-
-    bool word_boundary() const { return word_boundary_; }
-    void set_word_boundary(bool b) { word_boundary_ = b; }
-
-    bool one_line() const { return one_line_; }
-    void set_one_line(bool b) { one_line_ = b; }
-
-    void Copy(const Options& src) {
-      *this = src;
-    }
-
-    int ParseFlags() const;
-
-   private:
-    int64_t max_mem_;
-    Encoding encoding_;
-    bool posix_syntax_;
-    bool longest_match_;
-    bool log_errors_;
-    bool literal_;
-    bool never_nl_;
-    bool dot_nl_;
-    bool never_capture_;
-    bool case_sensitive_;
-    bool perl_classes_;
-    bool word_boundary_;
-    bool one_line_;
-  };
-
-  // Returns the options set in the constructor.
-  const Options& options() const { return options_; }
-
-  // Argument converters; see below.
-  template <typename T>
-  static Arg CRadix(T* ptr);
-  template <typename T>
-  static Arg Hex(T* ptr);
-  template <typename T>
-  static Arg Octal(T* ptr);
-
-  // Controls the maximum count permitted by GlobalReplace(); -1 is unlimited.
-  // FOR FUZZING ONLY.
-  static void FUZZING_ONLY_set_maximum_global_replace_count(int i);
-
- private:
-  void Init(const StringPiece& pattern, const Options& options);
-
-  bool DoMatch(const StringPiece& text,
-               Anchor re_anchor,
-               size_t* consumed,
-               const Arg* const args[],
-               int n) const;
-
-  duckdb_re2::Prog* ReverseProg() const;
-
-  // First cache line is relatively cold fields.
-  const std::string* pattern_;    // string regular expression
-  Options options_;               // option flags
-  duckdb_re2::Regexp* entire_regexp_;    // parsed regular expression
-  duckdb_re2::Regexp* suffix_regexp_;    // parsed regular expression, prefix_ removed
-  const std::string* error_;      // error indicator (or points to empty string)
-  const std::string* error_arg_;  // fragment of regexp showing error (or ditto)
-
-  // Second cache line is relatively hot fields.
-  // These are ordered oddly to pack everything.
-  int num_captures_;              // number of capturing groups
-  ErrorCode error_code_ : 29;     // error code (29 bits is more than enough)
-  bool longest_match_ : 1;        // cached copy of options_.longest_match()
-  bool is_one_pass_ : 1;          // can use prog_->SearchOnePass?
-  bool prefix_foldcase_ : 1;      // prefix_ is ASCII case-insensitive
-  std::string prefix_;            // required prefix (before suffix_regexp_)
-  duckdb_re2::Prog* prog_;               // compiled program for regexp
-
-  // Reverse Prog for DFA execution only
-  mutable duckdb_re2::Prog* rprog_;
-  // Map from capture names to indices
-  mutable const std::map<std::string, int>* named_groups_;
-  // Map from capture indices to names
-  mutable const std::map<int, std::string>* group_names_;
-
-  mutable std::once_flag rprog_once_;
-  mutable std::once_flag named_groups_once_;
-  mutable std::once_flag group_names_once_;
-};
-
-/***** Implementation details *****/
-
-namespace re2_internal {
-
-// Types for which the 3-ary Parse() function template has specializations.
-template <typename T> struct Parse3ary : public std::false_type {};
-template <> struct Parse3ary<void> : public std::true_type {};
-template <> struct Parse3ary<std::string> : public std::true_type {};
-template <> struct Parse3ary<StringPiece> : public std::true_type {};
-template <> struct Parse3ary<char> : public std::true_type {};
-template <> struct Parse3ary<signed char> : public std::true_type {};
-template <> struct Parse3ary<unsigned char> : public std::true_type {};
-template <> struct Parse3ary<float> : public std::true_type {};
-template <> struct Parse3ary<double> : public std::true_type {};
-
-template <typename T>
-bool Parse(const char* str, size_t n, T* dest);
-
-// Types for which the 4-ary Parse() function template has specializations.
-template <typename T> struct Parse4ary : public std::false_type {};
-template <> struct Parse4ary<long> : public std::true_type {};
-template <> struct Parse4ary<unsigned long> : public std::true_type {};
-template <> struct Parse4ary<short> : public std::true_type {};
-template <> struct Parse4ary<unsigned short> : public std::true_type {};
-template <> struct Parse4ary<int> : public std::true_type {};
-template <> struct Parse4ary<unsigned int> : public std::true_type {};
-template <> struct Parse4ary<long long> : public std::true_type {};
-template <> struct Parse4ary<unsigned long long> : public std::true_type {};
-
-template <typename T>
-bool Parse(const char* str, size_t n, T* dest, int radix);
-
-}  // namespace re2_internal
-
-class RE2::Arg {
- private:
-  template <typename T>
-  using CanParse3ary = typename std::enable_if<
-      re2_internal::Parse3ary<T>::value,
-      int>::type;
-
-  template <typename T>
-  using CanParse4ary = typename std::enable_if<
-      re2_internal::Parse4ary<T>::value,
-      int>::type;
-
-#if !defined(_MSC_VER)
-  template <typename T>
-  using CanParseFrom = typename std::enable_if<
-      std::is_member_function_pointer<
-          decltype(static_cast<bool (T::*)(const char*, size_t)>(
-              &T::ParseFrom))>::value,
-      int>::type;
-#endif
-
- public:
-  Arg() : Arg(nullptr) {}
-  Arg(std::nullptr_t ptr) : arg_(ptr), parser_(DoNothing) {}
-
-  template <typename T, CanParse3ary<T> = 0>
-  Arg(T* ptr) : arg_(ptr), parser_(DoParse3ary<T>) {}
-
-  template <typename T, CanParse4ary<T> = 0>
-  Arg(T* ptr) : arg_(ptr), parser_(DoParse4ary<T>) {}
-
-#if !defined(_MSC_VER)
-  template <typename T, CanParseFrom<T> = 0>
-  Arg(T* ptr) : arg_(ptr), parser_(DoParseFrom<T>) {}
-#endif
-
-  typedef bool (*Parser)(const char* str, size_t n, void* dest);
-
-  template <typename T>
-  Arg(T* ptr, Parser parser) : arg_(ptr), parser_(parser) {}
-
-  bool Parse(const char* str, size_t n) const {
-    return (*parser_)(str, n, arg_);
-  }
-
- private:
-  static bool DoNothing(const char* /*str*/, size_t /*n*/, void* /*dest*/) {
-    return true;
-  }
-
-  template <typename T>
-  static bool DoParse3ary(const char* str, size_t n, void* dest) {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest));
-  }
-
-  template <typename T>
-  static bool DoParse4ary(const char* str, size_t n, void* dest) {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 10);
-  }
-
-#if !defined(_MSC_VER)
-  template <typename T>
-  static bool DoParseFrom(const char* str, size_t n, void* dest) {
-    if (dest == NULL) return true;
-    return reinterpret_cast<T*>(dest)->ParseFrom(str, n);
-  }
-#endif
-
-  void*         arg_;
-  Parser        parser_;
-};
-
-template <typename T>
-inline RE2::Arg RE2::CRadix(T* ptr) {
-  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 0);
-  });
-}
-
-template <typename T>
-inline RE2::Arg RE2::Hex(T* ptr) {
-  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 16);
-  });
-}
-
-template <typename T>
-inline RE2::Arg RE2::Octal(T* ptr) {
-  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 8);
-  });
-}
-
-// Silence warnings about missing initializers for members of LazyRE2.
-#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 6
-// #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-// Helper for writing global or static RE2s safely.
-// Write
-//     static LazyRE2 re = {".*"};
-// and then use *re instead of writing
-//     static RE2 re(".*");
-// The former is more careful about multithreaded
-// situations than the latter.
-//
-// N.B. This class never deletes the RE2 object that
-// it constructs: that's a feature, so that it can be used
-// for global and function static variables.
-class LazyRE2 {
- private:
-  struct NoArg {};
-
- public:
-  typedef RE2 element_type;  // support std::pointer_traits
-
-  // Constructor omitted to preserve braced initialization in C++98.
-
-  // Pretend to be a pointer to Type (never NULL due to on-demand creation):
-  RE2& operator*() const { return *get(); }
-  RE2* operator->() const { return get(); }
-
-  // Named accessor/initializer:
-  RE2* get() const {
-    std::call_once(once_, &LazyRE2::Init, this);
-    return ptr_;
-  }
-
-  // All data fields must be public to support {"foo"} initialization.
-  const char* pattern_;
-  RE2::CannedOptions options_;
-  NoArg barrier_against_excess_initializers_;
-
-  mutable RE2* ptr_;
-  mutable std::once_flag once_;
-
- private:
-  static void Init(const LazyRE2* lazy_re2) {
-    lazy_re2->ptr_ = new RE2(lazy_re2->pattern_, lazy_re2->options_);
-  }
-
-  void operator=(const LazyRE2&);  // disallowed
-};
-
-namespace hooks {
-
-// Most platforms support thread_local. Older versions of iOS don't support
-// thread_local, but for the sake of brevity, we lump together all versions
-// of Apple platforms that aren't macOS. If an iOS application really needs
-// the context pointee someday, we can get more specific then...
-//
-// As per https://github.com/google/re2/issues/325, thread_local support in
-// MinGW seems to be buggy. (FWIW, Abseil folks also avoid it.)
-#define RE2_HAVE_THREAD_LOCAL
-#if (defined(__APPLE__) && !(defined(TARGET_OS_OSX) && TARGET_OS_OSX)) || defined(__MINGW32__)
-#undef RE2_HAVE_THREAD_LOCAL
-#endif
-
-// A hook must not make any assumptions regarding the lifetime of the context
-// pointee beyond the current invocation of the hook. Pointers and references
-// obtained via the context pointee should be considered invalidated when the
-// hook returns. Hence, any data about the context pointee (e.g. its pattern)
-// would have to be copied in order for it to be kept for an indefinite time.
-//
-// A hook must not use RE2 for matching. Control flow reentering RE2::Match()
-// could result in infinite mutual recursion. To discourage that possibility,
-// RE2 will not maintain the context pointer correctly when used in that way.
-#ifdef RE2_HAVE_THREAD_LOCAL
-extern thread_local const RE2* context;
-#endif
-
-struct DFAStateCacheReset {
-  int64_t state_budget;
-  size_t state_cache_size;
-};
-
-struct DFASearchFailure {
-  // Nothing yet...
-};
-
-#define DECLARE_HOOK(type)                  \
-  using type##Callback = void(const type&); \
-  void Set##type##Hook(type##Callback* cb); \
-  type##Callback* Get##type##Hook();
-
-DECLARE_HOOK(DFAStateCacheReset)
-DECLARE_HOOK(DFASearchFailure)
-
-#undef DECLARE_HOOK
-
-}  // namespace hooks
-
-}  // namespace re2
-
-using duckdb_re2::RE2;
-using duckdb_re2::LazyRE2;
-
-#endif  // RE2_RE2_H_
diff --git a/src/duckdb/third_party/re2/re2/regexp.cc b/src/duckdb/third_party/re2/re2/regexp.cc
deleted file mode 100644
index 9bd8ac54b..000000000
--- a/src/duckdb/third_party/re2/re2/regexp.cc
+++ /dev/null
@@ -1,1003 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Regular expression representation.
-// Tested by parse_test.cc
-
-#include "re2/regexp.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <map>
-#include <mutex>
-#include <string>
-#include <vector>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/mutex.h"
-#include "util/utf.h"
-#include "re2/pod_array.h"
-#include "re2/stringpiece.h"
-#include "re2/walker-inl.h"
-
-#ifdef min
-#undef min
-#endif
-#ifdef max
-#undef max
-#endif
-
-namespace duckdb_re2 {
-
-// Constructor.  Allocates vectors as appropriate for operator.
-Regexp::Regexp(RegexpOp op, ParseFlags parse_flags)
-  : op_(static_cast<uint8_t>(op)),
-    simple_(false),
-    parse_flags_(static_cast<uint16_t>(parse_flags)),
-    ref_(1),
-    nsub_(0),
-    down_(NULL) {
-  subone_ = NULL;
-  memset(arguments.the_union_, 0, sizeof arguments.the_union_);
-}
-
-// Destructor.  Assumes already cleaned up children.
-// Private: use Decref() instead of delete to destroy Regexps.
-// Can't call Decref on the sub-Regexps here because
-// that could cause arbitrarily deep recursion, so
-// required Decref() to have handled them for us.
-Regexp::~Regexp() {
-  if (nsub_ > 0)
-    LOG(DFATAL) << "Regexp not destroyed.";
-
-  switch (op_) {
-    default:
-      break;
-    case kRegexpCapture:
-      delete arguments.capture.name_;
-      break;
-    case kRegexpLiteralString:
-      delete[] arguments.literal_string.runes_;
-      break;
-    case kRegexpCharClass:
-      if (arguments.char_class.cc_)
-		  arguments.char_class.cc_->Delete();
-      delete arguments.char_class.ccb_;
-      break;
-  }
-}
-
-// If it's possible to destroy this regexp without recurring,
-// do so and return true.  Else return false.
-bool Regexp::QuickDestroy() {
-  if (nsub_ == 0) {
-    delete this;
-    return true;
-  }
-  return false;
-}
-
-// Similar to EmptyStorage in re2.cc.
-struct RefStorage {
-  Mutex ref_mutex;
-  std::map<Regexp*, int> ref_map;
-};
-alignas(RefStorage) static char ref_storage[sizeof(RefStorage)];
-
-static inline Mutex* ref_mutex() {
-  return &reinterpret_cast<RefStorage*>(ref_storage)->ref_mutex;
-}
-
-static inline std::map<Regexp*, int>* ref_map() {
-  return &reinterpret_cast<RefStorage*>(ref_storage)->ref_map;
-}
-
-int Regexp::Ref() {
-  if (ref_ < kMaxRef)
-    return ref_;
-
-  MutexLock l(ref_mutex());
-  return (*ref_map())[this];
-}
-
-// Increments reference count, returns object as convenience.
-Regexp* Regexp::Incref() {
-  if (ref_ >= kMaxRef-1) {
-    static std::once_flag ref_once;
-    std::call_once(ref_once, []() {
-      (void) new (ref_storage) RefStorage;
-    });
-
-    // Store ref count in overflow map.
-    MutexLock l(ref_mutex());
-    if (ref_ == kMaxRef) {
-      // already overflowed
-      (*ref_map())[this]++;
-    } else {
-      // overflowing now
-      (*ref_map())[this] = kMaxRef;
-      ref_ = kMaxRef;
-    }
-    return this;
-  }
-
-  ref_++;
-  return this;
-}
-
-// Decrements reference count and deletes this object if count reaches 0.
-void Regexp::Decref() {
-  if (ref_ == kMaxRef) {
-    // Ref count is stored in overflow map.
-    MutexLock l(ref_mutex());
-    int r = (*ref_map())[this] - 1;
-    if (r < kMaxRef) {
-      ref_ = static_cast<uint16_t>(r);
-      ref_map()->erase(this);
-    } else {
-      (*ref_map())[this] = r;
-    }
-    return;
-  }
-  ref_--;
-  if (ref_ == 0)
-    Destroy();
-}
-
-// Deletes this object; ref count has count reached 0.
-void Regexp::Destroy() {
-  if (QuickDestroy())
-    return;
-
-  // Handle recursive Destroy with explicit stack
-  // to avoid arbitrarily deep recursion on process stack [sigh].
-  down_ = NULL;
-  Regexp* stack = this;
-  while (stack != NULL) {
-    Regexp* re = stack;
-    stack = re->down_;
-    if (re->ref_ != 0)
-      LOG(DFATAL) << "Bad reference count " << re->ref_;
-    if (re->nsub_ > 0) {
-      Regexp** subs = re->sub();
-      for (int i = 0; i < re->nsub_; i++) {
-        Regexp* sub = subs[i];
-        if (sub == NULL)
-          continue;
-        if (sub->ref_ == kMaxRef)
-          sub->Decref();
-        else
-          --sub->ref_;
-        if (sub->ref_ == 0 && !sub->QuickDestroy()) {
-          sub->down_ = stack;
-          stack = sub;
-        }
-      }
-      if (re->nsub_ > 1)
-        delete[] subs;
-      re->nsub_ = 0;
-    }
-    delete re;
-  }
-}
-
-void Regexp::AddRuneToString(Rune r) {
-  DCHECK(op_ == kRegexpLiteralString);
-  if (arguments.literal_string.nrunes_ == 0) {
-    // start with 8
-	arguments.literal_string.runes_ = new Rune[8];
-  } else if (arguments.literal_string.nrunes_ >= 8 && (arguments.literal_string.nrunes_ & (arguments.literal_string.nrunes_ - 1)) == 0) {
-    // double on powers of two
-    Rune *old = arguments.literal_string.runes_;
-	arguments.literal_string.runes_ = new Rune[arguments.literal_string.nrunes_ * 2];
-    for (int i = 0; i < arguments.literal_string.nrunes_; i++)
-		arguments.literal_string.runes_[i] = old[i];
-    delete[] old;
-  }
-
-  arguments.literal_string.runes_[arguments.literal_string.nrunes_++] = r;
-}
-
-Regexp* Regexp::HaveMatch(int match_id, ParseFlags flags) {
-  Regexp* re = new Regexp(kRegexpHaveMatch, flags);
-  re->arguments.match_id_ = match_id;
-  return re;
-}
-
-Regexp* Regexp::StarPlusOrQuest(RegexpOp op, Regexp* sub, ParseFlags flags) {
-  // Squash **, ++ and ??.
-  if (op == sub->op() && flags == sub->parse_flags())
-    return sub;
-
-  // Squash *+, *?, +*, +?, ?* and ?+. They all squash to *, so because
-  // op is Star/Plus/Quest, we just have to check that sub->op() is too.
-  if ((sub->op() == kRegexpStar ||
-       sub->op() == kRegexpPlus ||
-       sub->op() == kRegexpQuest) &&
-      flags == sub->parse_flags()) {
-    // If sub is Star, no need to rewrite it.
-    if (sub->op() == kRegexpStar)
-      return sub;
-
-    // Rewrite sub to Star.
-    Regexp* re = new Regexp(kRegexpStar, flags);
-    re->AllocSub(1);
-    re->sub()[0] = sub->sub()[0]->Incref();
-    sub->Decref();  // We didn't consume the reference after all.
-    return re;
-  }
-
-  Regexp* re = new Regexp(op, flags);
-  re->AllocSub(1);
-  re->sub()[0] = sub;
-  return re;
-}
-
-Regexp* Regexp::Plus(Regexp* sub, ParseFlags flags) {
-  return StarPlusOrQuest(kRegexpPlus, sub, flags);
-}
-
-Regexp* Regexp::Star(Regexp* sub, ParseFlags flags) {
-  return StarPlusOrQuest(kRegexpStar, sub, flags);
-}
-
-Regexp* Regexp::Quest(Regexp* sub, ParseFlags flags) {
-  return StarPlusOrQuest(kRegexpQuest, sub, flags);
-}
-
-Regexp* Regexp::ConcatOrAlternate(RegexpOp op, Regexp** sub, int nsub,
-                                  ParseFlags flags, bool can_factor) {
-  if (nsub == 1)
-    return sub[0];
-
-  if (nsub == 0) {
-    if (op == kRegexpAlternate)
-      return new Regexp(kRegexpNoMatch, flags);
-    else
-      return new Regexp(kRegexpEmptyMatch, flags);
-  }
-
-  PODArray<Regexp*> subcopy;
-  if (op == kRegexpAlternate && can_factor) {
-    // Going to edit sub; make a copy so we don't step on caller.
-    subcopy = PODArray<Regexp*>(nsub);
-    memmove(subcopy.data(), sub, nsub * sizeof sub[0]);
-    sub = subcopy.data();
-    nsub = FactorAlternation(sub, nsub, flags);
-    if (nsub == 1) {
-      Regexp* re = sub[0];
-      return re;
-    }
-  }
-
-  if (nsub > kMaxNsub) {
-    // Too many subexpressions to fit in a single Regexp.
-    // Make a two-level tree.  Two levels gets us to 65535^2.
-    int nbigsub = (nsub+kMaxNsub-1)/kMaxNsub;
-    Regexp* re = new Regexp(op, flags);
-    re->AllocSub(nbigsub);
-    Regexp** subs = re->sub();
-    for (int i = 0; i < nbigsub - 1; i++)
-      subs[i] = ConcatOrAlternate(op, sub+i*kMaxNsub, kMaxNsub, flags, false);
-    subs[nbigsub - 1] = ConcatOrAlternate(op, sub+(nbigsub-1)*kMaxNsub,
-                                          nsub - (nbigsub-1)*kMaxNsub, flags,
-                                          false);
-    return re;
-  }
-
-  Regexp* re = new Regexp(op, flags);
-  re->AllocSub(nsub);
-  Regexp** subs = re->sub();
-  for (int i = 0; i < nsub; i++)
-    subs[i] = sub[i];
-  return re;
-}
-
-Regexp* Regexp::Concat(Regexp** sub, int nsub, ParseFlags flags) {
-  return ConcatOrAlternate(kRegexpConcat, sub, nsub, flags, false);
-}
-
-Regexp* Regexp::Alternate(Regexp** sub, int nsub, ParseFlags flags) {
-  return ConcatOrAlternate(kRegexpAlternate, sub, nsub, flags, true);
-}
-
-Regexp* Regexp::AlternateNoFactor(Regexp** sub, int nsub, ParseFlags flags) {
-  return ConcatOrAlternate(kRegexpAlternate, sub, nsub, flags, false);
-}
-
-Regexp* Regexp::Capture(Regexp* sub, ParseFlags flags, int cap) {
-  Regexp* re = new Regexp(kRegexpCapture, flags);
-  re->AllocSub(1);
-  re->sub()[0] = sub;
-  re->arguments.capture.cap_ = cap;
-  return re;
-}
-
-Regexp* Regexp::Repeat(Regexp* sub, ParseFlags flags, int min, int max) {
-  Regexp* re = new Regexp(kRegexpRepeat, flags);
-  re->AllocSub(1);
-  re->sub()[0] = sub;
-  re->arguments.repeat.min_ = min;
-  re->arguments.repeat.max_ = max;
-  return re;
-}
-
-Regexp* Regexp::NewLiteral(Rune rune, ParseFlags flags) {
-  Regexp* re = new Regexp(kRegexpLiteral, flags);
-  re->arguments.rune_ = rune;
-  return re;
-}
-
-Regexp* Regexp::LiteralString(Rune* runes, int nrunes, ParseFlags flags) {
-  if (nrunes <= 0)
-    return new Regexp(kRegexpEmptyMatch, flags);
-  if (nrunes == 1)
-    return NewLiteral(runes[0], flags);
-  Regexp* re = new Regexp(kRegexpLiteralString, flags);
-  for (int i = 0; i < nrunes; i++)
-    re->AddRuneToString(runes[i]);
-  return re;
-}
-
-Regexp* Regexp::NewCharClass(CharClass* cc, ParseFlags flags) {
-  Regexp* re = new Regexp(kRegexpCharClass, flags);
-  re->arguments.char_class.cc_ = cc;
-  return re;
-}
-
-void Regexp::Swap(Regexp* that) {
-  // Regexp is not trivially copyable, so we cannot freely copy it with
-  // memmove(3), but swapping objects like so is safe for our purposes.
-  char tmp[sizeof *this];
-  void* vthis = reinterpret_cast<void*>(this);
-  void* vthat = reinterpret_cast<void*>(that);
-  memmove(tmp, vthis, sizeof *this);
-  memmove(vthis, vthat, sizeof *this);
-  memmove(vthat, tmp, sizeof *this);
-}
-
-// Tests equality of all top-level structure but not subregexps.
-static bool TopEqual(Regexp* a, Regexp* b) {
-  if (a->op() != b->op())
-    return false;
-
-  switch (a->op()) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpBeginText:
-      return true;
-
-    case kRegexpEndText:
-      // The parse flags remember whether it's \z or (?-m:$),
-      // which matters when testing against PCRE.
-      return ((a->parse_flags() ^ b->parse_flags()) & Regexp::WasDollar) == 0;
-
-    case kRegexpLiteral:
-      return a->rune() == b->rune() &&
-             ((a->parse_flags() ^ b->parse_flags()) & Regexp::FoldCase) == 0;
-
-    case kRegexpLiteralString:
-      return a->nrunes() == b->nrunes() &&
-             ((a->parse_flags() ^ b->parse_flags()) & Regexp::FoldCase) == 0 &&
-             memcmp(a->runes(), b->runes(),
-                    a->nrunes() * sizeof a->runes()[0]) == 0;
-
-    case kRegexpAlternate:
-    case kRegexpConcat:
-      return a->nsub() == b->nsub();
-
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-      return ((a->parse_flags() ^ b->parse_flags()) & Regexp::NonGreedy) == 0;
-
-    case kRegexpRepeat:
-      return ((a->parse_flags() ^ b->parse_flags()) & Regexp::NonGreedy) == 0 &&
-             a->min() == b->min() &&
-             a->max() == b->max();
-
-    case kRegexpCapture:
-      return a->cap() == b->cap() && a->name() == b->name();
-
-    case kRegexpHaveMatch:
-      return a->match_id() == b->match_id();
-
-    case kRegexpCharClass: {
-      CharClass* acc = a->cc();
-      CharClass* bcc = b->cc();
-      return acc->size() == bcc->size() &&
-             acc->end() - acc->begin() == bcc->end() - bcc->begin() &&
-             memcmp(acc->begin(), bcc->begin(),
-                    (acc->end() - acc->begin()) * sizeof acc->begin()[0]) == 0;
-    }
-  }
-
-  LOG(DFATAL) << "Unexpected op in Regexp::Equal: " << a->op();
-  return 0;
-}
-
-bool Regexp::Equal(Regexp* a, Regexp* b) {
-  if (a == NULL || b == NULL)
-    return a == b;
-
-  if (!TopEqual(a, b))
-    return false;
-
-  // Fast path:
-  // return without allocating vector if there are no subregexps.
-  switch (a->op()) {
-    case kRegexpAlternate:
-    case kRegexpConcat:
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-    case kRegexpRepeat:
-    case kRegexpCapture:
-      break;
-
-    default:
-      return true;
-  }
-
-  // Committed to doing real work.
-  // The stack (vector) has pairs of regexps waiting to
-  // be compared.  The regexps are only equal if
-  // all the pairs end up being equal.
-  std::vector<Regexp*> stk;
-
-  for (;;) {
-    // Invariant: TopEqual(a, b) == true.
-    Regexp* a2;
-    Regexp* b2;
-    switch (a->op()) {
-      default:
-        break;
-      case kRegexpAlternate:
-      case kRegexpConcat:
-        for (int i = 0; i < a->nsub(); i++) {
-          a2 = a->sub()[i];
-          b2 = b->sub()[i];
-          if (!TopEqual(a2, b2))
-            return false;
-          stk.push_back(a2);
-          stk.push_back(b2);
-        }
-        break;
-
-      case kRegexpStar:
-      case kRegexpPlus:
-      case kRegexpQuest:
-      case kRegexpRepeat:
-      case kRegexpCapture:
-        a2 = a->sub()[0];
-        b2 = b->sub()[0];
-        if (!TopEqual(a2, b2))
-          return false;
-        // Really:
-        //   stk.push_back(a2);
-        //   stk.push_back(b2);
-        //   break;
-        // but faster to assign directly and loop.
-        a = a2;
-        b = b2;
-        continue;
-    }
-
-    size_t n = stk.size();
-    if (n == 0)
-      break;
-
-    DCHECK_GE(n, 2);
-    a = stk[n-2];
-    b = stk[n-1];
-    stk.resize(n-2);
-  }
-
-  return true;
-}
-
-// Keep in sync with enum RegexpStatusCode in regexp.h
-static const char *kErrorStrings[] = {
-  "no error",
-  "unexpected error",
-  "invalid escape sequence",
-  "invalid character class",
-  "invalid character class range",
-  "missing ]",
-  "missing )",
-  "unexpected )",
-  "trailing \\",
-  "no argument for repetition operator",
-  "invalid repetition size",
-  "bad repetition operator",
-  "invalid perl operator",
-  "invalid UTF-8",
-  "invalid named capture group",
-};
-
-std::string RegexpStatus::CodeText(enum RegexpStatusCode code) {
-  if (code < 0 || code >= arraysize(kErrorStrings))
-    code = kRegexpInternalError;
-  return kErrorStrings[code];
-}
-
-std::string RegexpStatus::Text() const {
-  if (error_arg_.empty())
-    return CodeText(code_);
-  std::string s;
-  s.append(CodeText(code_));
-  s.append(": ");
-  s.append(error_arg_.data(), error_arg_.size());
-  return s;
-}
-
-void RegexpStatus::Copy(const RegexpStatus& status) {
-  code_ = status.code_;
-  error_arg_ = status.error_arg_;
-}
-
-typedef int Ignored;  // Walker<void> doesn't exist
-
-// Walker subclass to count capturing parens in regexp.
-class NumCapturesWalker : public Regexp::Walker<Ignored> {
- public:
-  NumCapturesWalker() : ncapture_(0) {}
-  int ncapture() { return ncapture_; }
-
-  virtual Ignored PreVisit(Regexp* re, Ignored ignored, bool* stop) {
-    if (re->op() == kRegexpCapture)
-      ncapture_++;
-    return ignored;
-  }
-
-  virtual Ignored ShortVisit(Regexp* re, Ignored ignored) {
-    // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    LOG(DFATAL) << "NumCapturesWalker::ShortVisit called";
-#endif
-    return ignored;
-  }
-
- private:
-  int ncapture_;
-
-  NumCapturesWalker(const NumCapturesWalker&) = delete;
-  NumCapturesWalker& operator=(const NumCapturesWalker&) = delete;
-};
-
-int Regexp::NumCaptures() {
-  NumCapturesWalker w;
-  w.Walk(this, 0);
-  return w.ncapture();
-}
-
-// Walker class to build map of named capture groups and their indices.
-class NamedCapturesWalker : public Regexp::Walker<Ignored> {
- public:
-  NamedCapturesWalker() : map_(NULL) {}
-  ~NamedCapturesWalker() { delete map_; }
-
-  std::map<std::string, int>* TakeMap() {
-    std::map<std::string, int>* m = map_;
-    map_ = NULL;
-    return m;
-  }
-
-  virtual Ignored PreVisit(Regexp* re, Ignored ignored, bool* stop) {
-    if (re->op() == kRegexpCapture && re->name() != NULL) {
-      // Allocate map once we find a name.
-      if (map_ == NULL)
-        map_ = new std::map<std::string, int>;
-
-      // Record first occurrence of each name.
-      // (The rule is that if you have the same name
-      // multiple times, only the leftmost one counts.)
-      map_->insert({*re->name(), re->cap()});
-    }
-    return ignored;
-  }
-
-  virtual Ignored ShortVisit(Regexp* re, Ignored ignored) {
-    // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    LOG(DFATAL) << "NamedCapturesWalker::ShortVisit called";
-#endif
-    return ignored;
-  }
-
- private:
-  std::map<std::string, int>* map_;
-
-  NamedCapturesWalker(const NamedCapturesWalker&) = delete;
-  NamedCapturesWalker& operator=(const NamedCapturesWalker&) = delete;
-};
-
-std::map<std::string, int>* Regexp::NamedCaptures() {
-  NamedCapturesWalker w;
-  w.Walk(this, 0);
-  return w.TakeMap();
-}
-
-// Walker class to build map from capture group indices to their names.
-class CaptureNamesWalker : public Regexp::Walker<Ignored> {
- public:
-  CaptureNamesWalker() : map_(NULL) {}
-  ~CaptureNamesWalker() { delete map_; }
-
-  std::map<int, std::string>* TakeMap() {
-    std::map<int, std::string>* m = map_;
-    map_ = NULL;
-    return m;
-  }
-
-  virtual Ignored PreVisit(Regexp* re, Ignored ignored, bool* stop) {
-    if (re->op() == kRegexpCapture && re->name() != NULL) {
-      // Allocate map once we find a name.
-      if (map_ == NULL)
-        map_ = new std::map<int, std::string>;
-
-      (*map_)[re->cap()] = *re->name();
-    }
-    return ignored;
-  }
-
-  virtual Ignored ShortVisit(Regexp* re, Ignored ignored) {
-    // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    LOG(DFATAL) << "CaptureNamesWalker::ShortVisit called";
-#endif
-    return ignored;
-  }
-
- private:
-  std::map<int, std::string>* map_;
-
-  CaptureNamesWalker(const CaptureNamesWalker&) = delete;
-  CaptureNamesWalker& operator=(const CaptureNamesWalker&) = delete;
-};
-
-std::map<int, std::string>* Regexp::CaptureNames() {
-  CaptureNamesWalker w;
-  w.Walk(this, 0);
-  return w.TakeMap();
-}
-
-void ConvertRunesToBytes(bool latin1, Rune* runes, int nrunes,
-                         std::string* bytes) {
-  if (latin1) {
-    bytes->resize(nrunes);
-    for (int i = 0; i < nrunes; i++)
-      (*bytes)[i] = static_cast<char>(runes[i]);
-  } else {
-    bytes->resize(nrunes * UTFmax);  // worst case
-    char* p = &(*bytes)[0];
-    for (int i = 0; i < nrunes; i++)
-      p += runetochar(p, &runes[i]);
-    bytes->resize(p - &(*bytes)[0]);
-    bytes->shrink_to_fit();
-  }
-}
-
-// Determines whether regexp matches must be anchored
-// with a fixed string prefix.  If so, returns the prefix and
-// the regexp that remains after the prefix.  The prefix might
-// be ASCII case-insensitive.
-bool Regexp::RequiredPrefix(std::string* prefix, bool* foldcase,
-                            Regexp** suffix) {
-  prefix->clear();
-  *foldcase = false;
-  *suffix = NULL;
-
-  // No need for a walker: the regexp must be of the form
-  // 1. some number of ^ anchors
-  // 2. a literal char or string
-  // 3. the rest
-  if (op_ != kRegexpConcat)
-    return false;
-  int i = 0;
-  while (i < nsub_ && sub()[i]->op_ == kRegexpBeginText)
-    i++;
-  if (i == 0 || i >= nsub_)
-    return false;
-  Regexp* re = sub()[i];
-  if (re->op_ != kRegexpLiteral &&
-      re->op_ != kRegexpLiteralString)
-    return false;
-  i++;
-  if (i < nsub_) {
-    for (int j = i; j < nsub_; j++)
-      sub()[j]->Incref();
-    *suffix = Concat(sub() + i, nsub_ - i, parse_flags());
-  } else {
-    *suffix = new Regexp(kRegexpEmptyMatch, parse_flags());
-  }
-
-  bool latin1 = (re->parse_flags() & Latin1) != 0;
-  Rune* runes = re->op_ == kRegexpLiteral ? &re->arguments.rune_ : re->arguments.literal_string.runes_;
-  int nrunes = re->op_ == kRegexpLiteral ? 1 : re->arguments.literal_string.nrunes_;
-  ConvertRunesToBytes(latin1, runes, nrunes, prefix);
-  *foldcase = (re->parse_flags() & FoldCase) != 0;
-  return true;
-}
-
-// Determines whether regexp matches must be unanchored
-// with a fixed string prefix.  If so, returns the prefix.
-// The prefix might be ASCII case-insensitive.
-bool Regexp::RequiredPrefixForAccel(std::string* prefix, bool* foldcase) {
-  prefix->clear();
-  *foldcase = false;
-
-  // No need for a walker: the regexp must either begin with or be
-  // a literal char or string. We "see through" capturing groups,
-  // but make no effort to glue multiple prefix fragments together.
-  Regexp* re = op_ == kRegexpConcat && nsub_ > 0 ? sub()[0] : this;
-  while (re->op_ == kRegexpCapture) {
-    re = re->sub()[0];
-    if (re->op_ == kRegexpConcat && re->nsub_ > 0)
-      re = re->sub()[0];
-  }
-  if (re->op_ != kRegexpLiteral &&
-      re->op_ != kRegexpLiteralString)
-    return false;
-
-  bool latin1 = (re->parse_flags() & Latin1) != 0;
-  Rune* runes = re->op_ == kRegexpLiteral ? &re->arguments.rune_ : re->arguments.literal_string.runes_;
-  int nrunes = re->op_ == kRegexpLiteral ? 1 : re->arguments.literal_string.nrunes_;
-  ConvertRunesToBytes(latin1, runes, nrunes, prefix);
-  *foldcase = (re->parse_flags() & FoldCase) != 0;
-  return true;
-}
-
-// Character class builder is a balanced binary tree (STL set)
-// containing non-overlapping, non-abutting RuneRanges.
-// The less-than operator used in the tree treats two
-// ranges as equal if they overlap at all, so that
-// lookups for a particular Rune are possible.
-
-CharClassBuilder::CharClassBuilder() {
-  nrunes_ = 0;
-  upper_ = 0;
-  lower_ = 0;
-}
-
-// Add lo-hi to the class; return whether class got bigger.
-bool CharClassBuilder::AddRange(Rune lo, Rune hi) {
-  if (hi < lo)
-    return false;
-
-  if (lo <= 'z' && hi >= 'A') {
-    // Overlaps some alpha, maybe not all.
-    // Update bitmaps telling which ASCII letters are in the set.
-    Rune lo1 = std::max<Rune>(lo, 'A');
-    Rune hi1 = std::min<Rune>(hi, 'Z');
-    if (lo1 <= hi1)
-      upper_ |= ((1 << (hi1 - lo1 + 1)) - 1) << (lo1 - 'A');
-
-    lo1 = std::max<Rune>(lo, 'a');
-    hi1 = std::min<Rune>(hi, 'z');
-    if (lo1 <= hi1)
-      lower_ |= ((1 << (hi1 - lo1 + 1)) - 1) << (lo1 - 'a');
-  }
-
-  {  // Check whether lo, hi is already in the class.
-    iterator it = ranges_.find(RuneRange(lo, lo));
-    if (it != end() && it->lo <= lo && hi <= it->hi)
-      return false;
-  }
-
-  // Look for a range abutting lo on the left.
-  // If it exists, take it out and increase our range.
-  if (lo > 0) {
-    iterator it = ranges_.find(RuneRange(lo-1, lo-1));
-    if (it != end()) {
-      lo = it->lo;
-      if (it->hi > hi)
-        hi = it->hi;
-      nrunes_ -= it->hi - it->lo + 1;
-      ranges_.erase(it);
-    }
-  }
-
-  // Look for a range abutting hi on the right.
-  // If it exists, take it out and increase our range.
-  if (hi < Runemax) {
-    iterator it = ranges_.find(RuneRange(hi+1, hi+1));
-    if (it != end()) {
-      hi = it->hi;
-      nrunes_ -= it->hi - it->lo + 1;
-      ranges_.erase(it);
-    }
-  }
-
-  // Look for ranges between lo and hi.  Take them out.
-  // This is only safe because the set has no overlapping ranges.
-  // We've already removed any ranges abutting lo and hi, so
-  // any that overlap [lo, hi] must be contained within it.
-  for (;;) {
-    iterator it = ranges_.find(RuneRange(lo, hi));
-    if (it == end())
-      break;
-    nrunes_ -= it->hi - it->lo + 1;
-    ranges_.erase(it);
-  }
-
-  // Finally, add [lo, hi].
-  nrunes_ += hi - lo + 1;
-  ranges_.insert(RuneRange(lo, hi));
-  return true;
-}
-
-void CharClassBuilder::AddCharClass(CharClassBuilder *cc) {
-  for (iterator it = cc->begin(); it != cc->end(); ++it)
-    AddRange(it->lo, it->hi);
-}
-
-bool CharClassBuilder::Contains(Rune r) {
-  return ranges_.find(RuneRange(r, r)) != end();
-}
-
-// Does the character class behave the same on A-Z as on a-z?
-bool CharClassBuilder::FoldsASCII() {
-  return ((upper_ ^ lower_) & AlphaMask) == 0;
-}
-
-CharClassBuilder* CharClassBuilder::Copy() {
-  CharClassBuilder* cc = new CharClassBuilder;
-  for (iterator it = begin(); it != end(); ++it)
-    cc->ranges_.insert(RuneRange(it->lo, it->hi));
-  cc->upper_ = upper_;
-  cc->lower_ = lower_;
-  cc->nrunes_ = nrunes_;
-  return cc;
-}
-
-
-
-void CharClassBuilder::RemoveAbove(Rune r) {
-  if (r >= Runemax)
-    return;
-
-  if (r < 'z') {
-    if (r < 'a')
-      lower_ = 0;
-    else
-      lower_ &= AlphaMask >> ('z' - r);
-  }
-
-  if (r < 'Z') {
-    if (r < 'A')
-      upper_ = 0;
-    else
-      upper_ &= AlphaMask >> ('Z' - r);
-  }
-
-  for (;;) {
-
-    iterator it = ranges_.find(RuneRange(r + 1, Runemax));
-    if (it == end())
-      break;
-    RuneRange rr = *it;
-    ranges_.erase(it);
-    nrunes_ -= rr.hi - rr.lo + 1;
-    if (rr.lo <= r) {
-      rr.hi = r;
-      ranges_.insert(rr);
-      nrunes_ += rr.hi - rr.lo + 1;
-    }
-  }
-}
-
-void CharClassBuilder::Negate() {
-  // Build up negation and then copy in.
-  // Could edit ranges in place, but C++ won't let me.
-  std::vector<RuneRange> v;
-  v.reserve(ranges_.size() + 1);
-
-  // In negation, first range begins at 0, unless
-  // the current class begins at 0.
-  iterator it = begin();
-  if (it == end()) {
-    v.push_back(RuneRange(0, Runemax));
-  } else {
-    int nextlo = 0;
-    if (it->lo == 0) {
-      nextlo = it->hi + 1;
-      ++it;
-    }
-    for (; it != end(); ++it) {
-      v.push_back(RuneRange(nextlo, it->lo - 1));
-      nextlo = it->hi + 1;
-    }
-    if (nextlo <= Runemax)
-      v.push_back(RuneRange(nextlo, Runemax));
-  }
-
-  ranges_.clear();
-  for (size_t i = 0; i < v.size(); i++)
-    ranges_.insert(v[i]);
-
-  upper_ = AlphaMask & ~upper_;
-  lower_ = AlphaMask & ~lower_;
-  nrunes_ = Runemax+1 - nrunes_;
-}
-
-// Character class is a sorted list of ranges.
-// The ranges are allocated in the same block as the header,
-// necessitating a special allocator and Delete method.
-
-CharClass* CharClass::New(size_t maxranges) {
-  CharClass* cc;
-  uint8_t* data = new uint8_t[sizeof *cc + maxranges*sizeof cc->ranges_[0]];
-  cc = reinterpret_cast<CharClass*>(data);
-  cc->ranges_ = reinterpret_cast<RuneRange*>(data + sizeof *cc);
-  cc->nranges_ = 0;
-  cc->folds_ascii_ = false;
-  cc->nrunes_ = 0;
-  return cc;
-}
-
-void CharClass::Delete() {
-  uint8_t* data = reinterpret_cast<uint8_t*>(this);
-  delete[] data;
-}
-
-CharClass* CharClass::Negate() {
-  CharClass* cc = CharClass::New(static_cast<size_t>(nranges_+1));
-  cc->folds_ascii_ = folds_ascii_;
-  cc->nrunes_ = Runemax + 1 - nrunes_;
-  int n = 0;
-  int nextlo = 0;
-  for (CharClass::iterator it = begin(); it != end(); ++it) {
-    if (it->lo == nextlo) {
-      nextlo = it->hi + 1;
-    } else {
-      cc->ranges_[n++] = RuneRange(nextlo, it->lo - 1);
-      nextlo = it->hi + 1;
-    }
-  }
-  if (nextlo <= Runemax)
-    cc->ranges_[n++] = RuneRange(nextlo, Runemax);
-  cc->nranges_ = n;
-  return cc;
-}
-
-bool CharClass::Contains(Rune r) const {
-  RuneRange* rr = ranges_;
-  int n = nranges_;
-  while (n > 0) {
-    int m = n/2;
-    if (rr[m].hi < r) {
-      rr += m+1;
-      n -= m+1;
-    } else if (r < rr[m].lo) {
-      n = m;
-    } else {  // rr[m].lo <= r && r <= rr[m].hi
-      return true;
-    }
-  }
-  return false;
-}
-
-CharClass* CharClassBuilder::GetCharClass() {
-  CharClass* cc = CharClass::New(ranges_.size());
-  int n = 0;
-  for (iterator it = begin(); it != end(); ++it)
-    cc->ranges_[n++] = *it;
-  cc->nranges_ = n;
-  DCHECK_LE(n, static_cast<int>(ranges_.size()));
-  cc->nrunes_ = nrunes_;
-  cc->folds_ascii_ = FoldsASCII();
-  return cc;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/regexp.h b/src/duckdb/third_party/re2/re2/regexp.h
deleted file mode 100644
index d3ff96298..000000000
--- a/src/duckdb/third_party/re2/re2/regexp.h
+++ /dev/null
@@ -1,665 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_REGEXP_H_
-#define RE2_REGEXP_H_
-
-// --- SPONSORED LINK --------------------------------------------------
-// If you want to use this library for regular expression matching,
-// you should use re2/re2.h, which provides a class RE2 that
-// mimics the PCRE interface provided by PCRE's C++ wrappers.
-// This header describes the low-level interface used to implement RE2
-// and may change in backwards-incompatible ways from time to time.
-// In contrast, RE2's interface will not.
-// ---------------------------------------------------------------------
-
-// Regular expression library: parsing, execution, and manipulation
-// of regular expressions.
-//
-// Any operation that traverses the Regexp structures should be written
-// using Regexp::Walker (see walker-inl.h), not recursively, because deeply nested
-// regular expressions such as x++++++++++++++++++++... might cause recursive
-// traversals to overflow the stack.
-//
-// It is the caller's responsibility to provide appropriate mutual exclusion
-// around manipulation of the regexps.  RE2 does this.
-//
-// PARSING
-//
-// Regexp::Parse parses regular expressions encoded in UTF-8.
-// The default syntax is POSIX extended regular expressions,
-// with the following changes:
-//
-//   1.  Backreferences (optional in POSIX EREs) are not supported.
-//         (Supporting them precludes the use of DFA-based
-//          matching engines.)
-//
-//   2.  Collating elements and collation classes are not supported.
-//         (No one has needed or wanted them.)
-//
-// The exact syntax accepted can be modified by passing flags to
-// Regexp::Parse.  In particular, many of the basic Perl additions
-// are available.  The flags are documented below (search for LikePerl).
-//
-// If parsed with the flag Regexp::Latin1, both the regular expression
-// and the input to the matching routines are assumed to be encoded in
-// Latin-1, not UTF-8.
-//
-// EXECUTION
-//
-// Once Regexp has parsed a regular expression, it provides methods
-// to search text using that regular expression.  These methods are
-// implemented via calling out to other regular expression libraries.
-// (Let's call them the sublibraries.)
-//
-// To call a sublibrary, Regexp does not simply prepare a
-// string version of the regular expression and hand it to the
-// sublibrary.  Instead, Regexp prepares, from its own parsed form, the
-// corresponding internal representation used by the sublibrary.
-// This has the drawback of needing to know the internal representation
-// used by the sublibrary, but it has two important benefits:
-//
-//   1. The syntax and meaning of regular expressions is guaranteed
-//      to be that used by Regexp's parser, not the syntax expected
-//      by the sublibrary.  Regexp might accept a restricted or
-//      expanded syntax for regular expressions as compared with
-//      the sublibrary.  As long as Regexp can translate from its
-//      internal form into the sublibrary's, clients need not know
-//      exactly which sublibrary they are using.
-//
-//   2. The sublibrary parsers are bypassed.  For whatever reason,
-//      sublibrary regular expression parsers often have security
-//      problems.  For example, plan9grep's regular expression parser
-//      has a buffer overflow in its handling of large character
-//      classes, and PCRE's parser has had buffer overflow problems
-//      in the past.  Security-team requires sandboxing of sublibrary
-//      regular expression parsers.  Avoiding the sublibrary parsers
-//      avoids the sandbox.
-//
-// The execution methods we use now are provided by the compiled form,
-// Prog, described in prog.h
-//
-// MANIPULATION
-//
-// Unlike other regular expression libraries, Regexp makes its parsed
-// form accessible to clients, so that client code can analyze the
-// parsed regular expressions.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <map>
-#include <set>
-#include <string>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/utf.h"
-#include "re2/stringpiece.h"
-
-namespace duckdb_re2 {
-
-// Keep in sync with string list kOpcodeNames[] in testing/dump.cc
-enum RegexpOp {
-  // Matches no strings.
-  kRegexpNoMatch = 1,
-
-  // Matches empty string.
-  kRegexpEmptyMatch,
-
-  // Matches rune_.
-  kRegexpLiteral,
-
-  // Matches runes_.
-  kRegexpLiteralString,
-
-  // Matches concatenation of sub_[0..nsub-1].
-  kRegexpConcat,
-  // Matches union of sub_[0..nsub-1].
-  kRegexpAlternate,
-
-  // Matches sub_[0] zero or more times.
-  kRegexpStar,
-  // Matches sub_[0] one or more times.
-  kRegexpPlus,
-  // Matches sub_[0] zero or one times.
-  kRegexpQuest,
-
-  // Matches sub_[0] at least min_ times, at most max_ times.
-  // max_ == -1 means no upper limit.
-  kRegexpRepeat,
-
-  // Parenthesized (capturing) subexpression.  Index is cap_.
-  // Optionally, capturing name is name_.
-  kRegexpCapture,
-
-  // Matches any character.
-  kRegexpAnyChar,
-
-  // Matches any byte [sic].
-  kRegexpAnyByte,
-
-  // Matches empty string at beginning of line.
-  kRegexpBeginLine,
-  // Matches empty string at end of line.
-  kRegexpEndLine,
-
-  // Matches word boundary "\b".
-  kRegexpWordBoundary,
-  // Matches not-a-word boundary "\B".
-  kRegexpNoWordBoundary,
-
-  // Matches empty string at beginning of text.
-  kRegexpBeginText,
-  // Matches empty string at end of text.
-  kRegexpEndText,
-
-  // Matches character class given by cc_.
-  kRegexpCharClass,
-
-  // Forces match of entire expression right now,
-  // with match ID match_id_ (used by RE2::Set).
-  kRegexpHaveMatch,
-
-  kMaxRegexpOp = kRegexpHaveMatch,
-};
-
-// Keep in sync with string list in regexp.cc
-enum RegexpStatusCode {
-  // No error
-  kRegexpSuccess = 0,
-
-  // Unexpected error
-  kRegexpInternalError,
-
-  // Parse errors
-  kRegexpBadEscape,          // bad escape sequence
-  kRegexpBadCharClass,       // bad character class
-  kRegexpBadCharRange,       // bad character class range
-  kRegexpMissingBracket,     // missing closing ]
-  kRegexpMissingParen,       // missing closing )
-  kRegexpUnexpectedParen,    // unexpected closing )
-  kRegexpTrailingBackslash,  // at end of regexp
-  kRegexpRepeatArgument,     // repeat argument missing, e.g. "*"
-  kRegexpRepeatSize,         // bad repetition argument
-  kRegexpRepeatOp,           // bad repetition operator
-  kRegexpBadPerlOp,          // bad perl operator
-  kRegexpBadUTF8,            // invalid UTF-8 in regexp
-  kRegexpBadNamedCapture,    // bad named capture
-};
-
-// Error status for certain operations.
-class RegexpStatus {
- public:
-  RegexpStatus() : code_(kRegexpSuccess), tmp_(NULL) {}
-  ~RegexpStatus() { delete tmp_; }
-
-  void set_code(RegexpStatusCode code) { code_ = code; }
-  void set_error_arg(const StringPiece& error_arg) { error_arg_ = error_arg; }
-  void set_tmp(std::string* tmp) { delete tmp_; tmp_ = tmp; }
-  RegexpStatusCode code() const { return code_; }
-  const StringPiece& error_arg() const { return error_arg_; }
-  bool ok() const { return code() == kRegexpSuccess; }
-
-  // Copies state from status.
-  void Copy(const RegexpStatus& status);
-
-  // Returns text equivalent of code, e.g.:
-  //   "Bad character class"
-  static std::string CodeText(RegexpStatusCode code);
-
-  // Returns text describing error, e.g.:
-  //   "Bad character class: [z-a]"
-  std::string Text() const;
-
- private:
-  RegexpStatusCode code_;  // Kind of error
-  StringPiece error_arg_;  // Piece of regexp containing syntax error.
-  std::string* tmp_;       // Temporary storage, possibly where error_arg_ is.
-
-  RegexpStatus(const RegexpStatus&) = delete;
-  RegexpStatus& operator=(const RegexpStatus&) = delete;
-};
-
-// Compiled form; see prog.h
-class Prog;
-
-struct RuneRange {
-  RuneRange() : lo(0), hi(0) { }
-  RuneRange(int l, int h) : lo(l), hi(h) { }
-  Rune lo;
-  Rune hi;
-};
-
-// Less-than on RuneRanges treats a == b if they overlap at all.
-// This lets us look in a set to find the range covering a particular Rune.
-struct RuneRangeLess {
-  bool operator()(const RuneRange& a, const RuneRange& b) const {
-    return a.hi < b.lo;
-  }
-};
-
-class CharClassBuilder;
-
-class CharClass {
- public:
-  void Delete();
-
-  typedef RuneRange* iterator;
-  iterator begin() { return ranges_; }
-  iterator end() { return ranges_ + nranges_; }
-
-  int size() { return nrunes_; }
-  bool empty() { return nrunes_ == 0; }
-  bool full() { return nrunes_ == Runemax+1; }
-  bool FoldsASCII() { return folds_ascii_; }
-
-  bool Contains(Rune r) const;
-  CharClass* Negate();
-
- private:
-  CharClass();  // not implemented
-  ~CharClass();  // not implemented
-  static CharClass* New(size_t maxranges);
-
-  friend class CharClassBuilder;
-
-  bool folds_ascii_;
-  int nrunes_;
-  RuneRange *ranges_;
-  int nranges_;
-
-  CharClass(const CharClass&) = delete;
-  CharClass& operator=(const CharClass&) = delete;
-};
-
-class Regexp {
- public:
-
-  // Flags for parsing.  Can be ORed together.
-  enum ParseFlags {
-    NoParseFlags  = 0,
-    FoldCase      = 1<<0,   // Fold case during matching (case-insensitive).
-    Literal       = 1<<1,   // Treat s as literal string instead of a regexp.
-    ClassNL       = 1<<2,   // Allow char classes like [^a-z] and \D and \s
-                            // and [[:space:]] to match newline.
-    DotNL         = 1<<3,   // Allow . to match newline.
-    MatchNL       = ClassNL | DotNL,
-    OneLine       = 1<<4,   // Treat ^ and $ as only matching at beginning and
-                            // end of text, not around embedded newlines.
-                            // (Perl's default)
-    Latin1        = 1<<5,   // Regexp and text are in Latin1, not UTF-8.
-    NonGreedy     = 1<<6,   // Repetition operators are non-greedy by default.
-    PerlClasses   = 1<<7,   // Allow Perl character classes like \d.
-    PerlB         = 1<<8,   // Allow Perl's \b and \B.
-    PerlX         = 1<<9,   // Perl extensions:
-                            //   non-capturing parens - (?: )
-                            //   non-greedy operators - *? +? ?? {}?
-                            //   flag edits - (?i) (?-i) (?i: )
-                            //     i - FoldCase
-                            //     m - !OneLine
-                            //     s - DotNL
-                            //     U - NonGreedy
-                            //   line ends: \A \z
-                            //   \Q and \E to disable/enable metacharacters
-                            //   (?P<name>expr) for named captures
-                            //   \C to match any single byte
-    UnicodeGroups = 1<<10,  // Allow \p{Han} for Unicode Han group
-                            //   and \P{Han} for its negation.
-    NeverNL       = 1<<11,  // Never match NL, even if the regexp mentions
-                            //   it explicitly.
-    NeverCapture  = 1<<12,  // Parse all parens as non-capturing.
-
-    // As close to Perl as we can get.
-    LikePerl      = ClassNL | OneLine | PerlClasses | PerlB | PerlX |
-                    UnicodeGroups,
-
-    // Internal use only.
-    WasDollar     = 1<<13,  // on kRegexpEndText: was $ in regexp text
-    AllParseFlags = (1<<14)-1,
-  };
-
-  // Get.  No set, Regexps are logically immutable once created.
-  RegexpOp op() { return static_cast<RegexpOp>(op_); }
-  int nsub() { return nsub_; }
-  bool simple() { return simple_ != 0; }
-  ParseFlags parse_flags() { return static_cast<ParseFlags>(parse_flags_); }
-  int Ref();  // For testing.
-
-  Regexp** sub() {
-    if(nsub_ <= 1)
-      return &subone_;
-    else
-      return submany_;
-  }
-
-  int min() { DCHECK_EQ(op_, kRegexpRepeat); return arguments.repeat.min_; }
-  int max() { DCHECK_EQ(op_, kRegexpRepeat); return arguments.repeat.max_; }
-  Rune rune() { DCHECK_EQ(op_, kRegexpLiteral); return arguments.rune_; }
-  CharClass* cc() { DCHECK_EQ(op_, kRegexpCharClass); return arguments.char_class.cc_; }
-  int cap() { DCHECK_EQ(op_, kRegexpCapture); return arguments.capture.cap_; }
-  const std::string* name() { DCHECK_EQ(op_, kRegexpCapture); return arguments.capture.name_; }
-  Rune* runes() { DCHECK_EQ(op_, kRegexpLiteralString); return arguments.literal_string.runes_; }
-  int nrunes() { DCHECK_EQ(op_, kRegexpLiteralString); return arguments.literal_string.nrunes_; }
-  int match_id() { DCHECK_EQ(op_, kRegexpHaveMatch); return arguments.match_id_; }
-
-  // Increments reference count, returns object as convenience.
-  Regexp* Incref();
-
-  // Decrements reference count and deletes this object if count reaches 0.
-  void Decref();
-
-  // Parses string s to produce regular expression, returned.
-  // Caller must release return value with re->Decref().
-  // On failure, sets *status (if status != NULL) and returns NULL.
-  static Regexp* Parse(const StringPiece& s, ParseFlags flags,
-                       RegexpStatus* status);
-
-  // Returns a _new_ simplified version of the current regexp.
-  // Does not edit the current regexp.
-  // Caller must release return value with re->Decref().
-  // Simplified means that counted repetition has been rewritten
-  // into simpler terms and all Perl/POSIX features have been
-  // removed.  The result will capture exactly the same
-  // subexpressions the original did, unless formatted with ToString.
-  Regexp* Simplify();
-  friend class CoalesceWalker;
-  friend class SimplifyWalker;
-
-  // Parses the regexp src and then simplifies it and sets *dst to the
-  // string representation of the simplified form.  Returns true on success.
-  // Returns false and sets *status (if status != NULL) on parse error.
-  static bool SimplifyRegexp(const StringPiece& src, ParseFlags flags,
-                             std::string* dst, RegexpStatus* status);
-
-  // Returns the number of capturing groups in the regexp.
-  int NumCaptures();
-  friend class NumCapturesWalker;
-
-  // Returns a map from names to capturing group indices,
-  // or NULL if the regexp contains no named capture groups.
-  // The caller is responsible for deleting the map.
-  std::map<std::string, int>* NamedCaptures();
-
-  // Returns a map from capturing group indices to capturing group
-  // names or NULL if the regexp contains no named capture groups. The
-  // caller is responsible for deleting the map.
-  std::map<int, std::string>* CaptureNames();
-
-  // Returns a string representation of the current regexp,
-  // using as few parentheses as possible.
-  std::string ToString();
-
-  // Convenience functions.  They consume the passed reference,
-  // so in many cases you should use, e.g., Plus(re->Incref(), flags).
-  // They do not consume allocated arrays like subs or runes.
-  static Regexp* Plus(Regexp* sub, ParseFlags flags);
-  static Regexp* Star(Regexp* sub, ParseFlags flags);
-  static Regexp* Quest(Regexp* sub, ParseFlags flags);
-  static Regexp* Concat(Regexp** subs, int nsubs, ParseFlags flags);
-  static Regexp* Alternate(Regexp** subs, int nsubs, ParseFlags flags);
-  static Regexp* Capture(Regexp* sub, ParseFlags flags, int cap);
-  static Regexp* Repeat(Regexp* sub, ParseFlags flags, int min, int max);
-  static Regexp* NewLiteral(Rune rune, ParseFlags flags);
-  static Regexp* NewCharClass(CharClass* cc, ParseFlags flags);
-  static Regexp* LiteralString(Rune* runes, int nrunes, ParseFlags flags);
-  static Regexp* HaveMatch(int match_id, ParseFlags flags);
-
-  // Like Alternate but does not factor out common prefixes.
-  static Regexp* AlternateNoFactor(Regexp** subs, int nsubs, ParseFlags flags);
-
-  // Debugging function.  Returns string format for regexp
-  // that makes structure clear.  Does NOT use regexp syntax.
-  std::string Dump();
-
-  // Helper traversal class, defined fully in walker-inl.h.
-  template<typename T> class Walker;
-
-  // Compile to Prog.  See prog.h
-  // Reverse prog expects to be run over text backward.
-  // Construction and execution of prog will
-  // stay within approximately max_mem bytes of memory.
-  // If max_mem <= 0, a reasonable default is used.
-  Prog* CompileToProg(int64_t max_mem);
-  Prog* CompileToReverseProg(int64_t max_mem);
-
-  // Whether to expect this library to find exactly the same answer as PCRE
-  // when running this regexp.  Most regexps do mimic PCRE exactly, but a few
-  // obscure cases behave differently.  Technically this is more a property
-  // of the Prog than the Regexp, but the computation is much easier to do
-  // on the Regexp.  See mimics_pcre.cc for the exact conditions.
-  bool MimicsPCRE();
-
-  // Benchmarking function.
-  void NullWalk();
-
-  // Whether every match of this regexp must be anchored and
-  // begin with a non-empty fixed string (perhaps after ASCII
-  // case-folding).  If so, returns the prefix and the sub-regexp that
-  // follows it.
-  // Callers should expect *prefix, *foldcase and *suffix to be "zeroed"
-  // regardless of the return value.
-  bool RequiredPrefix(std::string* prefix, bool* foldcase,
-                      Regexp** suffix);
-
-  // Whether every match of this regexp must be unanchored and
-  // begin with a non-empty fixed string (perhaps after ASCII
-  // case-folding).  If so, returns the prefix.
-  // Callers should expect *prefix and *foldcase to be "zeroed"
-  // regardless of the return value.
-  bool RequiredPrefixForAccel(std::string* prefix, bool* foldcase);
-
-  // Controls the maximum repeat count permitted by the parser.
-  // FOR FUZZING ONLY.
-  static void FUZZING_ONLY_set_maximum_repeat_count(int i);
-
- private:
-  // Constructor allocates vectors as appropriate for operator.
-  explicit Regexp(RegexpOp op, ParseFlags parse_flags);
-
-  // Use Decref() instead of delete to release Regexps.
-  // This is private to catch deletes at compile time.
-  ~Regexp();
-  void Destroy();
-  bool QuickDestroy();
-
-  // Helpers for Parse.  Listed here so they can edit Regexps.
-  class ParseState;
-
-  friend class ParseState;
-  friend bool ParseCharClass(StringPiece* s, Regexp** out_re,
-                             RegexpStatus* status);
-
-  // Helper for testing [sic].
-  friend bool RegexpEqualTestingOnly(Regexp*, Regexp*);
-
-  // Computes whether Regexp is already simple.
-  bool ComputeSimple();
-
-  // Constructor that generates a Star, Plus or Quest,
-  // squashing the pair if sub is also a Star, Plus or Quest.
-  static Regexp* StarPlusOrQuest(RegexpOp op, Regexp* sub, ParseFlags flags);
-
-  // Constructor that generates a concatenation or alternation,
-  // enforcing the limit on the number of subexpressions for
-  // a particular Regexp.
-  static Regexp* ConcatOrAlternate(RegexpOp op, Regexp** subs, int nsubs,
-                                   ParseFlags flags, bool can_factor);
-
-  // Returns the leading string that re starts with.
-  // The returned Rune* points into a piece of re,
-  // so it must not be used after the caller calls re->Decref().
-  static Rune* LeadingString(Regexp* re, int* nrune, ParseFlags* flags);
-
-  // Removes the first n leading runes from the beginning of re.
-  // Edits re in place.
-  static void RemoveLeadingString(Regexp* re, int n);
-
-  // Returns the leading regexp in re's top-level concatenation.
-  // The returned Regexp* points at re or a sub-expression of re,
-  // so it must not be used after the caller calls re->Decref().
-  static Regexp* LeadingRegexp(Regexp* re);
-
-  // Removes LeadingRegexp(re) from re and returns the remainder.
-  // Might edit re in place.
-  static Regexp* RemoveLeadingRegexp(Regexp* re);
-
-  // Simplifies an alternation of literal strings by factoring out
-  // common prefixes.
-  static int FactorAlternation(Regexp** sub, int nsub, ParseFlags flags);
-  friend class FactorAlternationImpl;
-
-  // Is a == b?  Only efficient on regexps that have not been through
-  // Simplify yet - the expansion of a kRegexpRepeat will make this
-  // take a long time.  Do not call on such regexps, hence private.
-  static bool Equal(Regexp* a, Regexp* b);
-
-  // Allocate space for n sub-regexps.
-  void AllocSub(int n) {
-    DCHECK(n >= 0 && static_cast<uint16_t>(n) == n);
-    if (n > 1)
-      submany_ = new Regexp*[n];
-    nsub_ = static_cast<uint16_t>(n);
-  }
-
-  // Add Rune to LiteralString
-  void AddRuneToString(Rune r);
-
-  // Swaps this with that, in place.
-  void Swap(Regexp *that);
-
-  // Operator.  See description of operators above.
-  // uint8_t instead of RegexpOp to control space usage.
-  uint8_t op_;
-
-  // Is this regexp structure already simple
-  // (has it been returned by Simplify)?
-  // uint8_t instead of bool to control space usage.
-  uint8_t simple_;
-
-  // Flags saved from parsing and used during execution.
-  // (Only FoldCase is used.)
-  // uint16_t instead of ParseFlags to control space usage.
-  uint16_t parse_flags_;
-
-  // Reference count.  Exists so that SimplifyRegexp can build
-  // regexp structures that are dags rather than trees to avoid
-  // exponential blowup in space requirements.
-  // uint16_t to control space usage.
-  // The standard regexp routines will never generate a
-  // ref greater than the maximum repeat count (kMaxRepeat),
-  // but even so, Incref and Decref consult an overflow map
-  // when ref_ reaches kMaxRef.
-  uint16_t ref_;
-  static const uint16_t kMaxRef = 0xffff;
-
-  // Subexpressions.
-  // uint16_t to control space usage.
-  // Concat and Alternate handle larger numbers of subexpressions
-  // by building concatenation or alternation trees.
-  // Other routines should call Concat or Alternate instead of
-  // filling in sub() by hand.
-  uint16_t nsub_;
-  static const uint16_t kMaxNsub = 0xffff;
-  union {
-    Regexp** submany_;  // if nsub_ > 1
-    Regexp* subone_;  // if nsub_ == 1
-  };
-
-  // Extra space for parse and teardown stacks.
-  Regexp* down_;
-
-  // Arguments to operator.  See description of operators above.
-  union {
-    struct {  // Repeat
-      int max_;
-      int min_;
-    } repeat;
-    struct {  // Capture
-      int cap_;
-      std::string* name_;
-    } capture;
-    struct {  // LiteralString
-      int nrunes_;
-      Rune* runes_;
-    } literal_string;
-    struct {  // CharClass
-      // These two could be in separate union members,
-      // but it wouldn't save any space (there are other two-word structs)
-      // and keeping them separate avoids confusion during parsing.
-      CharClass* cc_;
-      CharClassBuilder* ccb_;
-    } char_class;
-    Rune rune_;  // Literal
-    int match_id_;  // HaveMatch
-    void *the_union_[2];  // as big as any other element, for memset
-  } arguments;
-
-  Regexp(const Regexp&) = delete;
-  Regexp& operator=(const Regexp&) = delete;
-};
-
-// Character class set: contains non-overlapping, non-abutting RuneRanges.
-typedef std::set<RuneRange, RuneRangeLess> RuneRangeSet;
-
-class CharClassBuilder {
- public:
-  CharClassBuilder();
-
-  typedef RuneRangeSet::iterator iterator;
-  iterator begin() { return ranges_.begin(); }
-  iterator end() { return ranges_.end(); }
-
-  int size() { return nrunes_; }
-  bool empty() { return nrunes_ == 0; }
-  bool full() { return nrunes_ == Runemax+1; }
-
-  bool Contains(Rune r);
-  bool FoldsASCII();
-  bool AddRange(Rune lo, Rune hi);  // returns whether class changed
-  CharClassBuilder* Copy();
-  void AddCharClass(CharClassBuilder* cc);
-  void Negate();
-  void RemoveAbove(Rune r);
-  CharClass* GetCharClass();
-  void AddRangeFlags(Rune lo, Rune hi, Regexp::ParseFlags parse_flags);
-
- private:
-  static const uint32_t AlphaMask = (1<<26) - 1;
-  uint32_t upper_;  // bitmap of A-Z
-  uint32_t lower_;  // bitmap of a-z
-  int nrunes_;
-  RuneRangeSet ranges_;
-
-  CharClassBuilder(const CharClassBuilder&) = delete;
-  CharClassBuilder& operator=(const CharClassBuilder&) = delete;
-};
-
-// Bitwise ops on ParseFlags produce ParseFlags.
-inline Regexp::ParseFlags operator|(Regexp::ParseFlags a,
-                                    Regexp::ParseFlags b) {
-  return static_cast<Regexp::ParseFlags>(
-      static_cast<int>(a) | static_cast<int>(b));
-}
-
-inline Regexp::ParseFlags operator^(Regexp::ParseFlags a,
-                                    Regexp::ParseFlags b) {
-  return static_cast<Regexp::ParseFlags>(
-      static_cast<int>(a) ^ static_cast<int>(b));
-}
-
-inline Regexp::ParseFlags operator&(Regexp::ParseFlags a,
-                                    Regexp::ParseFlags b) {
-  return static_cast<Regexp::ParseFlags>(
-      static_cast<int>(a) & static_cast<int>(b));
-}
-
-inline Regexp::ParseFlags operator~(Regexp::ParseFlags a) {
-  // Attempting to produce a value out of enum's range has undefined behaviour.
-  return static_cast<Regexp::ParseFlags>(
-      ~static_cast<int>(a) & static_cast<int>(Regexp::AllParseFlags));
-}
-
-}  // namespace re2
-
-#endif  // RE2_REGEXP_H_
diff --git a/src/duckdb/third_party/re2/re2/set.cc b/src/duckdb/third_party/re2/re2/set.cc
deleted file mode 100644
index 8977c6a5b..000000000
--- a/src/duckdb/third_party/re2/re2/set.cc
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright 2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "re2/set.h"
-
-#include <stddef.h>
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "re2/pod_array.h"
-#include "re2/prog.h"
-#include "re2/re2.h"
-#include "re2/regexp.h"
-#include "re2/stringpiece.h"
-
-namespace duckdb_re2 {
-
-RE2::Set::Set(const RE2::Options& options, RE2::Anchor anchor)
-    : options_(options),
-      anchor_(anchor),
-      compiled_(false),
-      size_(0) {
-  options_.set_never_capture(true);  // might unblock some optimisations
-}
-
-RE2::Set::~Set() {
-  for (size_t i = 0; i < elem_.size(); i++)
-    elem_[i].second->Decref();
-}
-
-RE2::Set::Set(Set&& other)
-    : options_(other.options_),
-      anchor_(other.anchor_),
-      elem_(std::move(other.elem_)),
-      compiled_(other.compiled_),
-      size_(other.size_),
-      prog_(std::move(other.prog_)) {
-  other.elem_.clear();
-  other.elem_.shrink_to_fit();
-  other.compiled_ = false;
-  other.size_ = 0;
-  other.prog_.reset();
-}
-
-RE2::Set& RE2::Set::operator=(Set&& other) {
-  this->~Set();
-  (void) new (this) Set(std::move(other));
-  return *this;
-}
-
-int RE2::Set::Add(const StringPiece& pattern, std::string* error) {
-  if (compiled_) {
-    LOG(DFATAL) << "RE2::Set::Add() called after compiling";
-    return -1;
-  }
-
-  Regexp::ParseFlags pf = static_cast<Regexp::ParseFlags>(
-    options_.ParseFlags());
-  RegexpStatus status;
-  duckdb_re2::Regexp* re = Regexp::Parse(pattern, pf, &status);
-  if (re == NULL) {
-    if (error != NULL)
-      *error = status.Text();
-    if (options_.log_errors())
-      LOG(ERROR) << "Error parsing '" << pattern << "': " << status.Text();
-    return -1;
-  }
-
-  // Concatenate with match index and push on vector.
-  int n = static_cast<int>(elem_.size());
-  duckdb_re2::Regexp* m = duckdb_re2::Regexp::HaveMatch(n, pf);
-  if (re->op() == kRegexpConcat) {
-    int nsub = re->nsub();
-    PODArray<duckdb_re2::Regexp*> sub(nsub + 1);
-    for (int i = 0; i < nsub; i++)
-      sub[i] = re->sub()[i]->Incref();
-    sub[nsub] = m;
-    re->Decref();
-    re = duckdb_re2::Regexp::Concat(sub.data(), nsub + 1, pf);
-  } else {
-    duckdb_re2::Regexp* sub[2];
-    sub[0] = re;
-    sub[1] = m;
-    re = duckdb_re2::Regexp::Concat(sub, 2, pf);
-  }
-  elem_.emplace_back(std::string(pattern), re);
-  return n;
-}
-
-bool RE2::Set::Compile() {
-  if (compiled_) {
-    LOG(DFATAL) << "RE2::Set::Compile() called more than once";
-    return false;
-  }
-  compiled_ = true;
-  size_ = static_cast<int>(elem_.size());
-
-  // Sort the elements by their patterns. This is good enough for now
-  // until we have a Regexp comparison function. (Maybe someday...)
-  std::sort(elem_.begin(), elem_.end(),
-            [](const Elem& a, const Elem& b) -> bool {
-              return a.first < b.first;
-            });
-
-  PODArray<duckdb_re2::Regexp*> sub(size_);
-  for (int i = 0; i < size_; i++)
-    sub[i] = elem_[i].second;
-  elem_.clear();
-  elem_.shrink_to_fit();
-
-  Regexp::ParseFlags pf = static_cast<Regexp::ParseFlags>(
-    options_.ParseFlags());
-  duckdb_re2::Regexp* re = duckdb_re2::Regexp::Alternate(sub.data(), size_, pf);
-
-  prog_.reset(Prog::CompileSet(re, anchor_, options_.max_mem()));
-  re->Decref();
-  return prog_ != nullptr;
-}
-
-bool RE2::Set::Match(const StringPiece& text, std::vector<int>* v) const {
-  return Match(text, v, NULL);
-}
-
-bool RE2::Set::Match(const StringPiece& text, std::vector<int>* v,
-                     ErrorInfo* error_info) const {
-  if (!compiled_) {
-    if (error_info != NULL)
-      error_info->kind = kNotCompiled;
-    LOG(DFATAL) << "RE2::Set::Match() called before compiling";
-    return false;
-  }
-#ifdef RE2_HAVE_THREAD_LOCAL
-  hooks::context = NULL;
-#endif
-  bool dfa_failed = false;
-  std::unique_ptr<SparseSet> matches;
-  if (v != NULL) {
-    matches.reset(new SparseSet(size_));
-    v->clear();
-  }
-  bool ret = prog_->SearchDFA(text, text, Prog::kAnchored, Prog::kManyMatch,
-                              NULL, &dfa_failed, matches.get());
-  if (dfa_failed) {
-    if (options_.log_errors())
-      LOG(ERROR) << "DFA out of memory: "
-                 << "program size " << prog_->size() << ", "
-                 << "list count " << prog_->list_count() << ", "
-                 << "bytemap range " << prog_->bytemap_range();
-    if (error_info != NULL)
-      error_info->kind = kOutOfMemory;
-    return false;
-  }
-  if (ret == false) {
-    if (error_info != NULL)
-      error_info->kind = kNoError;
-    return false;
-  }
-  if (v != NULL) {
-    if (matches->empty()) {
-      if (error_info != NULL)
-        error_info->kind = kInconsistent;
-      LOG(DFATAL) << "RE2::Set::Match() matched, but no matches returned?!";
-      return false;
-    }
-    v->assign(matches->begin(), matches->end());
-  }
-  if (error_info != NULL)
-    error_info->kind = kNoError;
-  return true;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/set.h b/src/duckdb/third_party/re2/re2/set.h
deleted file mode 100644
index d357eb1ac..000000000
--- a/src/duckdb/third_party/re2/re2/set.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SET_H_
-#define RE2_SET_H_
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "re2/re2.h"
-
-namespace duckdb_re2 {
-class Prog;
-class Regexp;
-}  // namespace re2
-
-namespace duckdb_re2 {
-
-// An RE2::Set represents a collection of regexps that can
-// be searched for simultaneously.
-class RE2::Set {
- public:
-  enum ErrorKind {
-    kNoError = 0,
-    kNotCompiled,   // The set is not compiled.
-    kOutOfMemory,   // The DFA ran out of memory.
-    kInconsistent,  // The result is inconsistent. This should never happen.
-  };
-
-  struct ErrorInfo {
-    ErrorKind kind;
-  };
-
-  Set(const RE2::Options& options, RE2::Anchor anchor);
-  ~Set();
-
-  // Not copyable.
-  Set(const Set&) = delete;
-  Set& operator=(const Set&) = delete;
-  // Movable.
-  Set(Set&& other);
-  Set& operator=(Set&& other);
-
-  // Adds pattern to the set using the options passed to the constructor.
-  // Returns the index that will identify the regexp in the output of Match(),
-  // or -1 if the regexp cannot be parsed.
-  // Indices are assigned in sequential order starting from 0.
-  // Errors do not increment the index; if error is not NULL, *error will hold
-  // the error message from the parser.
-  int Add(const StringPiece& pattern, std::string* error);
-
-  // Compiles the set in preparation for matching.
-  // Returns false if the compiler runs out of memory.
-  // Add() must not be called again after Compile().
-  // Compile() must be called before Match().
-  bool Compile();
-
-  // Returns true if text matches at least one of the regexps in the set.
-  // Fills v (if not NULL) with the indices of the matching regexps.
-  // Callers must not expect v to be sorted.
-  bool Match(const StringPiece& text, std::vector<int>* v) const;
-
-  // As above, but populates error_info (if not NULL) when none of the regexps
-  // in the set matched. This can inform callers when DFA execution fails, for
-  // example, because they might wish to handle that case differently.
-  bool Match(const StringPiece& text, std::vector<int>* v,
-             ErrorInfo* error_info) const;
-
- private:
-  typedef std::pair<std::string, duckdb_re2::Regexp*> Elem;
-
-  RE2::Options options_;
-  RE2::Anchor anchor_;
-  std::vector<Elem> elem_;
-  bool compiled_;
-  int size_;
-  std::unique_ptr<duckdb_re2::Prog> prog_;
-};
-
-}  // namespace re2
-
-#endif  // RE2_SET_H_
diff --git a/src/duckdb/third_party/re2/re2/simplify.cc b/src/duckdb/third_party/re2/re2/simplify.cc
deleted file mode 100644
index 7a4894903..000000000
--- a/src/duckdb/third_party/re2/re2/simplify.cc
+++ /dev/null
@@ -1,665 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Rewrite POSIX and other features in re
-// to use simple extended regular expression features.
-// Also sort and simplify character classes.
-
-#include <string>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/utf.h"
-#include "re2/pod_array.h"
-#include "re2/regexp.h"
-#include "re2/walker-inl.h"
-
-namespace duckdb_re2 {
-
-// Parses the regexp src and then simplifies it and sets *dst to the
-// string representation of the simplified form.  Returns true on success.
-// Returns false and sets *error (if error != NULL) on error.
-bool Regexp::SimplifyRegexp(const StringPiece& src, ParseFlags flags,
-                            std::string* dst, RegexpStatus* status) {
-  Regexp* re = Parse(src, flags, status);
-  if (re == NULL)
-    return false;
-  Regexp* sre = re->Simplify();
-  re->Decref();
-  if (sre == NULL) {
-    if (status) {
-      status->set_code(kRegexpInternalError);
-      status->set_error_arg(src);
-    }
-    return false;
-  }
-  *dst = sre->ToString();
-  sre->Decref();
-  return true;
-}
-
-// Assuming the simple_ flags on the children are accurate,
-// is this Regexp* simple?
-bool Regexp::ComputeSimple() {
-  Regexp** subs;
-  switch (op_) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpLiteral:
-    case kRegexpLiteralString:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpBeginText:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpEndText:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpHaveMatch:
-      return true;
-    case kRegexpConcat:
-    case kRegexpAlternate:
-      // These are simple as long as the subpieces are simple.
-      subs = sub();
-      for (int i = 0; i < nsub_; i++)
-        if (!subs[i]->simple())
-          return false;
-      return true;
-    case kRegexpCharClass:
-      // Simple as long as the char class is not empty, not full.
-      if (arguments.char_class.ccb_ != NULL)
-        return !arguments.char_class.ccb_->empty() && !arguments.char_class.ccb_->full();
-      return !arguments.char_class.cc_->empty() && !arguments.char_class.cc_->full();
-    case kRegexpCapture:
-      subs = sub();
-      return subs[0]->simple();
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-      subs = sub();
-      if (!subs[0]->simple())
-        return false;
-      switch (subs[0]->op_) {
-        case kRegexpStar:
-        case kRegexpPlus:
-        case kRegexpQuest:
-        case kRegexpEmptyMatch:
-        case kRegexpNoMatch:
-          return false;
-        default:
-          break;
-      }
-      return true;
-    case kRegexpRepeat:
-      return false;
-  }
-  LOG(DFATAL) << "Case not handled in ComputeSimple: " << op_;
-  return false;
-}
-
-// Walker subclass used by Simplify.
-// Coalesces runs of star/plus/quest/repeat of the same literal along with any
-// occurrences of that literal into repeats of that literal. It also works for
-// char classes, any char and any byte.
-// PostVisit creates the coalesced result, which should then be simplified.
-class CoalesceWalker : public Regexp::Walker<Regexp*> {
- public:
-  CoalesceWalker() {}
-  virtual Regexp* PostVisit(Regexp* re, Regexp* parent_arg, Regexp* pre_arg,
-                            Regexp** child_args, int nchild_args);
-  virtual Regexp* Copy(Regexp* re);
-  virtual Regexp* ShortVisit(Regexp* re, Regexp* parent_arg);
-
- private:
-  // These functions are declared inside CoalesceWalker so that
-  // they can edit the private fields of the Regexps they construct.
-
-  // Returns true if r1 and r2 can be coalesced. In particular, ensures that
-  // the parse flags are consistent. (They will not be checked again later.)
-  static bool CanCoalesce(Regexp* r1, Regexp* r2);
-
-  // Coalesces *r1ptr and *r2ptr. In most cases, the array elements afterwards
-  // will be empty match and the coalesced op. In other cases, where part of a
-  // literal string was removed to be coalesced, the array elements afterwards
-  // will be the coalesced op and the remainder of the literal string.
-  static void DoCoalesce(Regexp** r1ptr, Regexp** r2ptr);
-
-  CoalesceWalker(const CoalesceWalker&) = delete;
-  CoalesceWalker& operator=(const CoalesceWalker&) = delete;
-};
-
-// Walker subclass used by Simplify.
-// The simplify walk is purely post-recursive: given the simplified children,
-// PostVisit creates the simplified result.
-// The child_args are simplified Regexp*s.
-class SimplifyWalker : public Regexp::Walker<Regexp*> {
- public:
-  SimplifyWalker() {}
-  virtual Regexp* PreVisit(Regexp* re, Regexp* parent_arg, bool* stop);
-  virtual Regexp* PostVisit(Regexp* re, Regexp* parent_arg, Regexp* pre_arg,
-                            Regexp** child_args, int nchild_args);
-  virtual Regexp* Copy(Regexp* re);
-  virtual Regexp* ShortVisit(Regexp* re, Regexp* parent_arg);
-
- private:
-  // These functions are declared inside SimplifyWalker so that
-  // they can edit the private fields of the Regexps they construct.
-
-  // Creates a concatenation of two Regexp, consuming refs to re1 and re2.
-  // Caller must Decref return value when done with it.
-  static Regexp* Concat2(Regexp* re1, Regexp* re2, Regexp::ParseFlags flags);
-
-  // Simplifies the expression re{min,max} in terms of *, +, and ?.
-  // Returns a new regexp.  Does not edit re.  Does not consume reference to re.
-  // Caller must Decref return value when done with it.
-  static Regexp* SimplifyRepeat(Regexp* re, int min, int max,
-                                Regexp::ParseFlags parse_flags);
-
-  // Simplifies a character class by expanding any named classes
-  // into rune ranges.  Does not edit re.  Does not consume ref to re.
-  // Caller must Decref return value when done with it.
-  static Regexp* SimplifyCharClass(Regexp* re);
-
-  SimplifyWalker(const SimplifyWalker&) = delete;
-  SimplifyWalker& operator=(const SimplifyWalker&) = delete;
-};
-
-// Simplifies a regular expression, returning a new regexp.
-// The new regexp uses traditional Unix egrep features only,
-// plus the Perl (?:) non-capturing parentheses.
-// Otherwise, no POSIX or Perl additions.  The new regexp
-// captures exactly the same subexpressions (with the same indices)
-// as the original.
-// Does not edit current object.
-// Caller must Decref() return value when done with it.
-
-Regexp* Regexp::Simplify() {
-  CoalesceWalker cw;
-  Regexp* cre = cw.Walk(this, NULL);
-  if (cre == NULL)
-    return NULL;
-  if (cw.stopped_early()) {
-    cre->Decref();
-    return NULL;
-  }
-  SimplifyWalker sw;
-  Regexp* sre = sw.Walk(cre, NULL);
-  cre->Decref();
-  if (sre == NULL)
-    return NULL;
-  if (sw.stopped_early()) {
-    sre->Decref();
-    return NULL;
-  }
-  return sre;
-}
-
-#define Simplify DontCallSimplify  // Avoid accidental recursion
-
-// Utility function for PostVisit implementations that compares re->sub() with
-// child_args to determine whether any child_args changed. In the common case,
-// where nothing changed, calls Decref() for all child_args and returns false,
-// so PostVisit must return re->Incref(). Otherwise, returns true.
-static bool ChildArgsChanged(Regexp* re, Regexp** child_args) {
-  for (int i = 0; i < re->nsub(); i++) {
-    Regexp* sub = re->sub()[i];
-    Regexp* newsub = child_args[i];
-    if (newsub != sub)
-      return true;
-  }
-  for (int i = 0; i < re->nsub(); i++) {
-    Regexp* newsub = child_args[i];
-    newsub->Decref();
-  }
-  return false;
-}
-
-Regexp* CoalesceWalker::Copy(Regexp* re) {
-  return re->Incref();
-}
-
-Regexp* CoalesceWalker::ShortVisit(Regexp* re, Regexp* parent_arg) {
-  // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  LOG(DFATAL) << "CoalesceWalker::ShortVisit called";
-#endif
-  return re->Incref();
-}
-
-Regexp* CoalesceWalker::PostVisit(Regexp* re,
-                                  Regexp* parent_arg,
-                                  Regexp* pre_arg,
-                                  Regexp** child_args,
-                                  int nchild_args) {
-  if (re->nsub() == 0)
-    return re->Incref();
-
-  if (re->op() != kRegexpConcat) {
-    if (!ChildArgsChanged(re, child_args))
-      return re->Incref();
-
-    // Something changed. Build a new op.
-    Regexp* nre = new Regexp(re->op(), re->parse_flags());
-    nre->AllocSub(re->nsub());
-    Regexp** nre_subs = nre->sub();
-    for (int i = 0; i < re->nsub(); i++)
-      nre_subs[i] = child_args[i];
-    // Repeats and Captures have additional data that must be copied.
-    if (re->op() == kRegexpRepeat) {
-      nre->arguments.repeat.min_ = re->min();
-      nre->arguments.repeat.max_ = re->max();
-    } else if (re->op() == kRegexpCapture) {
-      nre->arguments.capture.cap_ = re->cap();
-    }
-    return nre;
-  }
-
-  bool can_coalesce = false;
-  for (int i = 0; i < re->nsub(); i++) {
-    if (i+1 < re->nsub() &&
-        CanCoalesce(child_args[i], child_args[i+1])) {
-      can_coalesce = true;
-      break;
-    }
-  }
-  if (!can_coalesce) {
-    if (!ChildArgsChanged(re, child_args))
-      return re->Incref();
-
-    // Something changed. Build a new op.
-    Regexp* nre = new Regexp(re->op(), re->parse_flags());
-    nre->AllocSub(re->nsub());
-    Regexp** nre_subs = nre->sub();
-    for (int i = 0; i < re->nsub(); i++)
-      nre_subs[i] = child_args[i];
-    return nre;
-  }
-
-  for (int i = 0; i < re->nsub(); i++) {
-    if (i+1 < re->nsub() &&
-        CanCoalesce(child_args[i], child_args[i+1]))
-      DoCoalesce(&child_args[i], &child_args[i+1]);
-  }
-  // Determine how many empty matches were left by DoCoalesce.
-  int n = 0;
-  for (int i = n; i < re->nsub(); i++) {
-    if (child_args[i]->op() == kRegexpEmptyMatch)
-      n++;
-  }
-  // Build a new op.
-  Regexp* nre = new Regexp(re->op(), re->parse_flags());
-  nre->AllocSub(re->nsub() - n);
-  Regexp** nre_subs = nre->sub();
-  for (int i = 0, j = 0; i < re->nsub(); i++) {
-    if (child_args[i]->op() == kRegexpEmptyMatch) {
-      child_args[i]->Decref();
-      continue;
-    }
-    nre_subs[j] = child_args[i];
-    j++;
-  }
-  return nre;
-}
-
-bool CoalesceWalker::CanCoalesce(Regexp* r1, Regexp* r2) {
-  // r1 must be a star/plus/quest/repeat of a literal, char class, any char or
-  // any byte.
-  if ((r1->op() == kRegexpStar ||
-       r1->op() == kRegexpPlus ||
-       r1->op() == kRegexpQuest ||
-       r1->op() == kRegexpRepeat) &&
-      (r1->sub()[0]->op() == kRegexpLiteral ||
-       r1->sub()[0]->op() == kRegexpCharClass ||
-       r1->sub()[0]->op() == kRegexpAnyChar ||
-       r1->sub()[0]->op() == kRegexpAnyByte)) {
-    // r2 must be a star/plus/quest/repeat of the same literal, char class,
-    // any char or any byte.
-    if ((r2->op() == kRegexpStar ||
-         r2->op() == kRegexpPlus ||
-         r2->op() == kRegexpQuest ||
-         r2->op() == kRegexpRepeat) &&
-        Regexp::Equal(r1->sub()[0], r2->sub()[0]) &&
-        // The parse flags must be consistent.
-        ((r1->parse_flags() & Regexp::NonGreedy) ==
-         (r2->parse_flags() & Regexp::NonGreedy))) {
-      return true;
-    }
-    // ... OR an occurrence of that literal, char class, any char or any byte
-    if (Regexp::Equal(r1->sub()[0], r2)) {
-      return true;
-    }
-    // ... OR a literal string that begins with that literal.
-    if (r1->sub()[0]->op() == kRegexpLiteral &&
-        r2->op() == kRegexpLiteralString &&
-        r2->runes()[0] == r1->sub()[0]->rune() &&
-        // The parse flags must be consistent.
-        ((r1->sub()[0]->parse_flags() & Regexp::FoldCase) ==
-         (r2->parse_flags() & Regexp::FoldCase))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void CoalesceWalker::DoCoalesce(Regexp** r1ptr, Regexp** r2ptr) {
-  Regexp* r1 = *r1ptr;
-  Regexp* r2 = *r2ptr;
-
-  Regexp* nre = Regexp::Repeat(
-      r1->sub()[0]->Incref(), r1->parse_flags(), 0, 0);
-
-  switch (r1->op()) {
-    case kRegexpStar:
-      nre->arguments.repeat.min_ = 0;
-      nre->arguments.repeat.max_ = -1;
-      break;
-
-    case kRegexpPlus:
-      nre->arguments.repeat.min_ = 1;
-      nre->arguments.repeat.max_ = -1;
-      break;
-
-    case kRegexpQuest:
-      nre->arguments.repeat.min_ = 0;
-      nre->arguments.repeat.max_ = 1;
-      break;
-
-    case kRegexpRepeat:
-      nre->arguments.repeat.min_ = r1->min();
-      nre->arguments.repeat.max_ = r1->max();
-      break;
-
-    default:
-      nre->Decref();
-      LOG(DFATAL) << "DoCoalesce failed: r1->op() is " << r1->op();
-      return;
-  }
-
-  switch (r2->op()) {
-    case kRegexpStar:
-      nre->arguments.repeat.max_ = -1;
-      goto LeaveEmpty;
-
-    case kRegexpPlus:
-      nre->arguments.repeat.min_++;
-      nre->arguments.repeat.max_ = -1;
-      goto LeaveEmpty;
-
-    case kRegexpQuest:
-      if (nre->max() != -1)
-        nre->arguments.repeat.max_++;
-      goto LeaveEmpty;
-
-    case kRegexpRepeat:
-      nre->arguments.repeat.min_ += r2->min();
-      if (r2->max() == -1)
-        nre->arguments.repeat.max_ = -1;
-      else if (nre->max() != -1)
-        nre->arguments.repeat.max_ += r2->max();
-      goto LeaveEmpty;
-
-    case kRegexpLiteral:
-    case kRegexpCharClass:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-      nre->arguments.repeat.min_++;
-      if (nre->max() != -1)
-        nre->arguments.repeat.max_++;
-      goto LeaveEmpty;
-
-    LeaveEmpty:
-      *r1ptr = new Regexp(kRegexpEmptyMatch, Regexp::NoParseFlags);
-      *r2ptr = nre;
-      break;
-
-    case kRegexpLiteralString: {
-      Rune r = r1->sub()[0]->rune();
-      // Determine how much of the literal string is removed.
-      // We know that we have at least one rune. :)
-      int n = 1;
-      while (n < r2->nrunes() && r2->runes()[n] == r)
-        n++;
-      nre->arguments.repeat.min_ += n;
-      if (nre->max() != -1)
-        nre->arguments.repeat.max_ += n;
-      if (n == r2->nrunes())
-        goto LeaveEmpty;
-      *r1ptr = nre;
-      *r2ptr = Regexp::LiteralString(
-          &r2->runes()[n], r2->nrunes() - n, r2->parse_flags());
-      break;
-    }
-
-    default:
-      nre->Decref();
-      LOG(DFATAL) << "DoCoalesce failed: r2->op() is " << r2->op();
-      return;
-  }
-
-  r1->Decref();
-  r2->Decref();
-}
-
-Regexp* SimplifyWalker::Copy(Regexp* re) {
-  return re->Incref();
-}
-
-Regexp* SimplifyWalker::ShortVisit(Regexp* re, Regexp* parent_arg) {
-  // Should never be called: we use Walk(), not WalkExponential().
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  LOG(DFATAL) << "SimplifyWalker::ShortVisit called";
-#endif
-  return re->Incref();
-}
-
-Regexp* SimplifyWalker::PreVisit(Regexp* re, Regexp* parent_arg, bool* stop) {
-  if (re->simple()) {
-    *stop = true;
-    return re->Incref();
-  }
-  return NULL;
-}
-
-Regexp* SimplifyWalker::PostVisit(Regexp* re,
-                                  Regexp* parent_arg,
-                                  Regexp* pre_arg,
-                                  Regexp** child_args,
-                                  int nchild_args) {
-  switch (re->op()) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpLiteral:
-    case kRegexpLiteralString:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpBeginText:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpEndText:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpHaveMatch:
-      // All these are always simple.
-      re->simple_ = true;
-      return re->Incref();
-
-    case kRegexpConcat:
-    case kRegexpAlternate: {
-      // These are simple as long as the subpieces are simple.
-      if (!ChildArgsChanged(re, child_args)) {
-        re->simple_ = true;
-        return re->Incref();
-      }
-      Regexp* nre = new Regexp(re->op(), re->parse_flags());
-      nre->AllocSub(re->nsub());
-      Regexp** nre_subs = nre->sub();
-      for (int i = 0; i < re->nsub(); i++)
-        nre_subs[i] = child_args[i];
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpCapture: {
-      Regexp* newsub = child_args[0];
-      if (newsub == re->sub()[0]) {
-        newsub->Decref();
-        re->simple_ = true;
-        return re->Incref();
-      }
-      Regexp* nre = new Regexp(kRegexpCapture, re->parse_flags());
-      nre->AllocSub(1);
-      nre->sub()[0] = newsub;
-      nre->arguments.capture.cap_ = re->cap();
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest: {
-      Regexp* newsub = child_args[0];
-      // Special case: repeat the empty string as much as
-      // you want, but it's still the empty string.
-      if (newsub->op() == kRegexpEmptyMatch)
-        return newsub;
-
-      // These are simple as long as the subpiece is simple.
-      if (newsub == re->sub()[0]) {
-        newsub->Decref();
-        re->simple_ = true;
-        return re->Incref();
-      }
-
-      // These are also idempotent if flags are constant.
-      if (re->op() == newsub->op() &&
-          re->parse_flags() == newsub->parse_flags())
-        return newsub;
-
-      Regexp* nre = new Regexp(re->op(), re->parse_flags());
-      nre->AllocSub(1);
-      nre->sub()[0] = newsub;
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpRepeat: {
-      Regexp* newsub = child_args[0];
-      // Special case: repeat the empty string as much as
-      // you want, but it's still the empty string.
-      if (newsub->op() == kRegexpEmptyMatch)
-        return newsub;
-
-      Regexp* nre = SimplifyRepeat(newsub, re->arguments.repeat.min_, re->arguments.repeat.max_,
-                                   re->parse_flags());
-      newsub->Decref();
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpCharClass: {
-      Regexp* nre = SimplifyCharClass(re);
-      nre->simple_ = true;
-      return nre;
-    }
-  }
-
-  LOG(ERROR) << "Simplify case not handled: " << re->op();
-  return re->Incref();
-}
-
-// Creates a concatenation of two Regexp, consuming refs to re1 and re2.
-// Returns a new Regexp, handing the ref to the caller.
-Regexp* SimplifyWalker::Concat2(Regexp* re1, Regexp* re2,
-                                Regexp::ParseFlags parse_flags) {
-  Regexp* re = new Regexp(kRegexpConcat, parse_flags);
-  re->AllocSub(2);
-  Regexp** subs = re->sub();
-  subs[0] = re1;
-  subs[1] = re2;
-  return re;
-}
-
-// Simplifies the expression re{min,max} in terms of *, +, and ?.
-// Returns a new regexp.  Does not edit re.  Does not consume reference to re.
-// Caller must Decref return value when done with it.
-// The result will *not* necessarily have the right capturing parens
-// if you call ToString() and re-parse it: (x){2} becomes (x)(x),
-// but in the Regexp* representation, both (x) are marked as $1.
-Regexp* SimplifyWalker::SimplifyRepeat(Regexp* re, int min, int max,
-                                       Regexp::ParseFlags f) {
-  // x{n,} means at least n matches of x.
-  if (max == -1) {
-    // Special case: x{0,} is x*
-    if (min == 0)
-      return Regexp::Star(re->Incref(), f);
-
-    // Special case: x{1,} is x+
-    if (min == 1)
-      return Regexp::Plus(re->Incref(), f);
-
-    // General case: x{4,} is xxxx+
-    PODArray<Regexp*> nre_subs(min);
-    for (int i = 0; i < min-1; i++)
-      nre_subs[i] = re->Incref();
-    nre_subs[min-1] = Regexp::Plus(re->Incref(), f);
-    return Regexp::Concat(nre_subs.data(), min, f);
-  }
-
-  // Special case: (x){0} matches only empty string.
-  if (min == 0 && max == 0)
-    return new Regexp(kRegexpEmptyMatch, f);
-
-  // Special case: x{1} is just x.
-  if (min == 1 && max == 1)
-    return re->Incref();
-
-  // General case: x{n,m} means n copies of x and m copies of x?.
-  // The machine will do less work if we nest the final m copies,
-  // so that x{2,5} = xx(x(x(x)?)?)?
-
-  // Build leading prefix: xx.  Capturing only on the last one.
-  Regexp* nre = NULL;
-  if (min > 0) {
-    PODArray<Regexp*> nre_subs(min);
-    for (int i = 0; i < min; i++)
-      nre_subs[i] = re->Incref();
-    nre = Regexp::Concat(nre_subs.data(), min, f);
-  }
-
-  // Build and attach suffix: (x(x(x)?)?)?
-  if (max > min) {
-    Regexp* suf = Regexp::Quest(re->Incref(), f);
-    for (int i = min+1; i < max; i++)
-      suf = Regexp::Quest(Concat2(re->Incref(), suf, f), f);
-    if (nre == NULL)
-      nre = suf;
-    else
-      nre = Concat2(nre, suf, f);
-  }
-
-  if (nre == NULL) {
-    // Some degenerate case, like min > max, or min < max < 0.
-    // This shouldn't happen, because the parser rejects such regexps.
-    LOG(DFATAL) << "Malformed repeat " << re->ToString() << " " << min << " " << max;
-    return new Regexp(kRegexpNoMatch, f);
-  }
-
-  return nre;
-}
-
-// Simplifies a character class.
-// Caller must Decref return value when done with it.
-Regexp* SimplifyWalker::SimplifyCharClass(Regexp* re) {
-  CharClass* cc = re->cc();
-
-  // Special cases
-  if (cc->empty())
-    return new Regexp(kRegexpNoMatch, re->parse_flags());
-  if (cc->full())
-    return new Regexp(kRegexpAnyChar, re->parse_flags());
-
-  return re->Incref();
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/sparse_array.h b/src/duckdb/third_party/re2/re2/sparse_array.h
deleted file mode 100644
index 5ff5bb21e..000000000
--- a/src/duckdb/third_party/re2/re2/sparse_array.h
+++ /dev/null
@@ -1,392 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SPARSE_ARRAY_H_
-#define RE2_SPARSE_ARRAY_H_
-
-// DESCRIPTION
-//
-// SparseArray<T>(m) is a map from integers in [0, m) to T values.
-// It requires (sizeof(T)+sizeof(int))*m memory, but it provides
-// fast iteration through the elements in the array and fast clearing
-// of the array.  The array has a concept of certain elements being
-// uninitialized (having no value).
-//
-// Insertion and deletion are constant time operations.
-//
-// Allocating the array is a constant time operation
-// when memory allocation is a constant time operation.
-//
-// Clearing the array is a constant time operation (unusual!).
-//
-// Iterating through the array is an O(n) operation, where n
-// is the number of items in the array (not O(m)).
-//
-// The array iterator visits entries in the order they were first
-// inserted into the array.  It is safe to add items to the array while
-// using an iterator: the iterator will visit indices added to the array
-// during the iteration, but will not re-visit indices whose values
-// change after visiting.  Thus SparseArray can be a convenient
-// implementation of a work queue.
-//
-// The SparseArray implementation is NOT thread-safe.  It is up to the
-// caller to make sure only one thread is accessing the array.  (Typically
-// these arrays are temporary values and used in situations where speed is
-// important.)
-//
-// The SparseArray interface does not present all the usual STL bells and
-// whistles.
-//
-// Implemented with reference to Briggs & Torczon, An Efficient
-// Representation for Sparse Sets, ACM Letters on Programming Languages
-// and Systems, Volume 2, Issue 1-4 (March-Dec.  1993), pp.  59-69.
-//
-// Briggs & Torczon popularized this technique, but it had been known
-// long before their paper.  They point out that Aho, Hopcroft, and
-// Ullman's 1974 Design and Analysis of Computer Algorithms and Bentley's
-// 1986 Programming Pearls both hint at the technique in exercises to the
-// reader (in Aho & Hopcroft, exercise 2.12; in Bentley, column 1
-// exercise 8).
-//
-// Briggs & Torczon describe a sparse set implementation.  I have
-// trivially generalized it to create a sparse array (actually the original
-// target of the AHU and Bentley exercises).
-
-// IMPLEMENTATION
-//
-// SparseArray is an array dense_ and an array sparse_ of identical size.
-// At any point, the number of elements in the sparse array is size_.
-//
-// The array dense_ contains the size_ elements in the sparse array (with
-// their indices),
-// in the order that the elements were first inserted.  This array is dense:
-// the size_ pairs are dense_[0] through dense_[size_-1].
-//
-// The array sparse_ maps from indices in [0,m) to indices in [0,size_).
-// For indices present in the array, dense_[sparse_[i]].index_ == i.
-// For indices not present in the array, sparse_ can contain any value at all,
-// perhaps outside the range [0, size_) but perhaps not.
-//
-// The lax requirement on sparse_ values makes clearing the array very easy:
-// set size_ to 0.  Lookups are slightly more complicated.
-// An index i has a value in the array if and only if:
-//   sparse_[i] is in [0, size_) AND
-//   dense_[sparse_[i]].index_ == i.
-// If both these properties hold, only then it is safe to refer to
-//   dense_[sparse_[i]].value_
-// as the value associated with index i.
-//
-// To insert a new entry, set sparse_[i] to size_,
-// initialize dense_[size_], and then increment size_.
-//
-// To make the sparse array as efficient as possible for non-primitive types,
-// elements may or may not be destroyed when they are deleted from the sparse
-// array through a call to resize(). They immediately become inaccessible, but
-// they are only guaranteed to be destroyed when the SparseArray destructor is
-// called.
-//
-// A moved-from SparseArray will be empty.
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#include <assert.h>
-#include <stdint.h>
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "re2/pod_array.h"
-
-namespace duckdb_re2 {
-
-template<typename Value>
-class SparseArray {
- public:
-  SparseArray();
-  explicit SparseArray(int max_size);
-  ~SparseArray();
-
-  // IndexValue pairs: exposed in SparseArray::iterator.
-  class IndexValue;
-
-  typedef IndexValue* iterator;
-  typedef const IndexValue* const_iterator;
-
-  SparseArray(const SparseArray& src);
-  SparseArray(SparseArray&& src);
-
-  SparseArray& operator=(const SparseArray& src);
-  SparseArray& operator=(SparseArray&& src);
-
-  // Return the number of entries in the array.
-  int size() const {
-    return size_;
-  }
-
-  // Indicate whether the array is empty.
-  int empty() const {
-    return size_ == 0;
-  }
-
-  // Iterate over the array.
-  iterator begin() {
-    return dense_.data();
-  }
-  iterator end() {
-    return dense_.data() + size_;
-  }
-
-  const_iterator begin() const {
-    return dense_.data();
-  }
-  const_iterator end() const {
-    return dense_.data() + size_;
-  }
-
-  // Change the maximum size of the array.
-  // Invalidates all iterators.
-  void resize(int new_max_size);
-
-  // Return the maximum size of the array.
-  // Indices can be in the range [0, max_size).
-  int max_size() const {
-    if (dense_.data() != NULL)
-      return dense_.size();
-    else
-      return 0;
-  }
-
-  // Clear the array.
-  void clear() {
-    size_ = 0;
-  }
-
-  // Check whether index i is in the array.
-  bool has_index(int i) const;
-
-  // Comparison function for sorting.
-  // Can sort the sparse array so that future iterations
-  // will visit indices in increasing order using
-  // std::sort(arr.begin(), arr.end(), arr.less);
-  static bool less(const IndexValue& a, const IndexValue& b);
-
- public:
-  // Set the value at index i to v.
-  iterator set(int i, const Value& v) {
-    return SetInternal(true, i, v);
-  }
-
-  // Set the value at new index i to v.
-  // Fast but unsafe: only use if has_index(i) is false.
-  iterator set_new(int i, const Value& v) {
-    return SetInternal(false, i, v);
-  }
-
-  // Set the value at index i to v.
-  // Fast but unsafe: only use if has_index(i) is true.
-  iterator set_existing(int i, const Value& v) {
-    return SetExistingInternal(i, v);
-  }
-
-  // Get the value at index i.
-  // Fast but unsafe: only use if has_index(i) is true.
-  Value& get_existing(int i) {
-    assert(has_index(i));
-    return dense_[sparse_[i]].value_;
-  }
-  const Value& get_existing(int i) const {
-    assert(has_index(i));
-    return dense_[sparse_[i]].value_;
-  }
-
- private:
-  iterator SetInternal(bool allow_existing, int i, const Value& v) {
-    DebugCheckInvariants();
-    if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-      assert(false && "illegal index");
-      // Semantically, end() would be better here, but we already know
-      // the user did something stupid, so begin() insulates them from
-      // dereferencing an invalid pointer.
-      return begin();
-    }
-    if (!allow_existing) {
-      assert(!has_index(i));
-      create_index(i);
-    } else {
-      if (!has_index(i))
-        create_index(i);
-    }
-    return SetExistingInternal(i, v);
-  }
-
-  iterator SetExistingInternal(int i, const Value& v) {
-    DebugCheckInvariants();
-    assert(has_index(i));
-    dense_[sparse_[i]].value_ = v;
-    DebugCheckInvariants();
-    return dense_.data() + sparse_[i];
-  }
-
-  // Add the index i to the array.
-  // Only use if has_index(i) is known to be false.
-  // Since it doesn't set the value associated with i,
-  // this function is private, only intended as a helper
-  // for other methods.
-  void create_index(int i);
-
-  // In debug mode, verify that some invariant properties of the class
-  // are being maintained. This is called at the end of the constructor
-  // and at the beginning and end of all public non-const member functions.
-  void DebugCheckInvariants() const;
-
-  // Initializes memory for elements [min, max).
-  void MaybeInitializeMemory(int min, int max) {
-#if __has_feature(memory_sanitizer)
-    __msan_unpoison(sparse_.data() + min, (max - min) * sizeof sparse_[0]);
-#elif defined(RE2_ON_VALGRIND)
-    for (int i = min; i < max; i++) {
-      sparse_[i] = 0xababababU;
-    }
-#endif
-  }
-
-  int size_ = 0;
-  PODArray<int> sparse_;
-  PODArray<IndexValue> dense_;
-};
-
-template<typename Value>
-SparseArray<Value>::SparseArray() = default;
-
-template<typename Value>
-SparseArray<Value>::SparseArray(const SparseArray& src)
-    : size_(src.size_),
-      sparse_(src.max_size()),
-      dense_(src.max_size()) {
-  std::copy_n(src.sparse_.data(), src.max_size(), sparse_.data());
-  std::copy_n(src.dense_.data(), src.max_size(), dense_.data());
-}
-
-template<typename Value>
-SparseArray<Value>::SparseArray(SparseArray&& src)
-    : size_(src.size_),
-      sparse_(std::move(src.sparse_)),
-      dense_(std::move(src.dense_)) {
-  src.size_ = 0;
-}
-
-template<typename Value>
-SparseArray<Value>& SparseArray<Value>::operator=(const SparseArray& src) {
-  // Construct these first for exception safety.
-  PODArray<int> a(src.max_size());
-  PODArray<IndexValue> b(src.max_size());
-
-  size_ = src.size_;
-  sparse_ = std::move(a);
-  dense_ = std::move(b);
-  std::copy_n(src.sparse_.data(), src.max_size(), sparse_.data());
-  std::copy_n(src.dense_.data(), src.max_size(), dense_.data());
-  return *this;
-}
-
-template<typename Value>
-SparseArray<Value>& SparseArray<Value>::operator=(SparseArray&& src) {
-  size_ = src.size_;
-  sparse_ = std::move(src.sparse_);
-  dense_ = std::move(src.dense_);
-  src.size_ = 0;
-  return *this;
-}
-
-// IndexValue pairs: exposed in SparseArray::iterator.
-template<typename Value>
-class SparseArray<Value>::IndexValue {
- public:
-  int index() const { return index_; }
-  Value& value() { return value_; }
-  const Value& value() const { return value_; }
-
- private:
-  friend class SparseArray;
-  int index_;
-  Value value_;
-};
-
-// Change the maximum size of the array.
-// Invalidates all iterators.
-template<typename Value>
-void SparseArray<Value>::resize(int new_max_size) {
-  DebugCheckInvariants();
-  if (new_max_size > max_size()) {
-    const int old_max_size = max_size();
-
-    // Construct these first for exception safety.
-    PODArray<int> a(new_max_size);
-    PODArray<IndexValue> b(new_max_size);
-
-    std::copy_n(sparse_.data(), old_max_size, a.data());
-    std::copy_n(dense_.data(), old_max_size, b.data());
-
-    sparse_ = std::move(a);
-    dense_ = std::move(b);
-
-    MaybeInitializeMemory(old_max_size, new_max_size);
-  }
-  if (size_ > new_max_size)
-    size_ = new_max_size;
-  DebugCheckInvariants();
-}
-
-// Check whether index i is in the array.
-template<typename Value>
-bool SparseArray<Value>::has_index(int i) const {
-  assert(i >= 0);
-  assert(i < max_size());
-  if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-    return false;
-  }
-  // Unsigned comparison avoids checking sparse_[i] < 0.
-  return (uint32_t)sparse_[i] < (uint32_t)size_ &&
-         dense_[sparse_[i]].index_ == i;
-}
-
-template<typename Value>
-void SparseArray<Value>::create_index(int i) {
-  assert(!has_index(i));
-  assert(size_ < max_size());
-  sparse_[i] = size_;
-  dense_[size_].index_ = i;
-  size_++;
-}
-
-template<typename Value> SparseArray<Value>::SparseArray(int max_size) :
-    sparse_(max_size), dense_(max_size) {
-  MaybeInitializeMemory(size_, max_size);
-  DebugCheckInvariants();
-}
-
-template<typename Value> SparseArray<Value>::~SparseArray() {
-  DebugCheckInvariants();
-}
-
-template<typename Value> void SparseArray<Value>::DebugCheckInvariants() const {
-  assert(0 <= size_);
-  assert(size_ <= max_size());
-}
-
-// Comparison function for sorting.
-template<typename Value> bool SparseArray<Value>::less(const IndexValue& a,
-                                                       const IndexValue& b) {
-  return a.index_ < b.index_;
-}
-
-}  // namespace re2
-
-#endif  // RE2_SPARSE_ARRAY_H_
diff --git a/src/duckdb/third_party/re2/re2/sparse_set.h b/src/duckdb/third_party/re2/re2/sparse_set.h
deleted file mode 100644
index 320b320d0..000000000
--- a/src/duckdb/third_party/re2/re2/sparse_set.h
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SPARSE_SET_H_
-#define RE2_SPARSE_SET_H_
-
-// DESCRIPTION
-//
-// SparseSet(m) is a set of integers in [0, m).
-// It requires sizeof(int)*m memory, but it provides
-// fast iteration through the elements in the set and fast clearing
-// of the set.
-//
-// Insertion and deletion are constant time operations.
-//
-// Allocating the set is a constant time operation
-// when memory allocation is a constant time operation.
-//
-// Clearing the set is a constant time operation (unusual!).
-//
-// Iterating through the set is an O(n) operation, where n
-// is the number of items in the set (not O(m)).
-//
-// The set iterator visits entries in the order they were first
-// inserted into the set.  It is safe to add items to the set while
-// using an iterator: the iterator will visit indices added to the set
-// during the iteration, but will not re-visit indices whose values
-// change after visiting.  Thus SparseSet can be a convenient
-// implementation of a work queue.
-//
-// The SparseSet implementation is NOT thread-safe.  It is up to the
-// caller to make sure only one thread is accessing the set.  (Typically
-// these sets are temporary values and used in situations where speed is
-// important.)
-//
-// The SparseSet interface does not present all the usual STL bells and
-// whistles.
-//
-// Implemented with reference to Briggs & Torczon, An Efficient
-// Representation for Sparse Sets, ACM Letters on Programming Languages
-// and Systems, Volume 2, Issue 1-4 (March-Dec.  1993), pp.  59-69.
-//
-// This is a specialization of sparse array; see sparse_array.h.
-
-// IMPLEMENTATION
-//
-// See sparse_array.h for implementation details.
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#include <assert.h>
-#include <stdint.h>
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "re2/pod_array.h"
-
-namespace duckdb_re2 {
-
-template<typename Value>
-class SparseSetT {
- public:
-  SparseSetT();
-  explicit SparseSetT(int max_size);
-  ~SparseSetT();
-
-  typedef int* iterator;
-  typedef const int* const_iterator;
-
-  // Return the number of entries in the set.
-  int size() const {
-    return size_;
-  }
-
-  // Indicate whether the set is empty.
-  int empty() const {
-    return size_ == 0;
-  }
-
-  // Iterate over the set.
-  iterator begin() {
-    return dense_.data();
-  }
-  iterator end() {
-    return dense_.data() + size_;
-  }
-
-  const_iterator begin() const {
-    return dense_.data();
-  }
-  const_iterator end() const {
-    return dense_.data() + size_;
-  }
-
-  // Change the maximum size of the set.
-  // Invalidates all iterators.
-  void resize(int new_max_size);
-
-  // Return the maximum size of the set.
-  // Indices can be in the range [0, max_size).
-  int max_size() const {
-    if (dense_.data() != NULL)
-      return dense_.size();
-    else
-      return 0;
-  }
-
-  // Clear the set.
-  void clear() {
-    size_ = 0;
-  }
-
-  // Check whether index i is in the set.
-  bool contains(int i) const;
-
-  // Comparison function for sorting.
-  // Can sort the sparse set so that future iterations
-  // will visit indices in increasing order using
-  // std::sort(arr.begin(), arr.end(), arr.less);
-  static bool less(int a, int b);
-
- public:
-  // Insert index i into the set.
-  iterator insert(int i) {
-    return InsertInternal(true, i);
-  }
-
-  // Insert index i into the set.
-  // Fast but unsafe: only use if contains(i) is false.
-  iterator insert_new(int i) {
-    return InsertInternal(false, i);
-  }
-
- private:
-  iterator InsertInternal(bool allow_existing, int i) {
-    DebugCheckInvariants();
-    if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-      assert(false && "illegal index");
-      // Semantically, end() would be better here, but we already know
-      // the user did something stupid, so begin() insulates them from
-      // dereferencing an invalid pointer.
-      return begin();
-    }
-    if (!allow_existing) {
-      assert(!contains(i));
-      create_index(i);
-    } else {
-      if (!contains(i))
-        create_index(i);
-    }
-    DebugCheckInvariants();
-    return dense_.data() + sparse_[i];
-  }
-
-  // Add the index i to the set.
-  // Only use if contains(i) is known to be false.
-  // This function is private, only intended as a helper
-  // for other methods.
-  void create_index(int i);
-
-  // In debug mode, verify that some invariant properties of the class
-  // are being maintained. This is called at the end of the constructor
-  // and at the beginning and end of all public non-const member functions.
-  void DebugCheckInvariants() const;
-
-  // Initializes memory for elements [min, max).
-  void MaybeInitializeMemory(int min, int max) {
-#if __has_feature(memory_sanitizer)
-    __msan_unpoison(sparse_.data() + min, (max - min) * sizeof sparse_[0]);
-#elif defined(RE2_ON_VALGRIND)
-    for (int i = min; i < max; i++) {
-      sparse_[i] = 0xababababU;
-    }
-#endif
-  }
-
-  int size_ = 0;
-  PODArray<int> sparse_;
-  PODArray<int> dense_;
-};
-
-template<typename Value>
-SparseSetT<Value>::SparseSetT() = default;
-
-// Change the maximum size of the set.
-// Invalidates all iterators.
-template<typename Value>
-void SparseSetT<Value>::resize(int new_max_size) {
-  DebugCheckInvariants();
-  if (new_max_size > max_size()) {
-    const int old_max_size = max_size();
-
-    // Construct these first for exception safety.
-    PODArray<int> a(new_max_size);
-    PODArray<int> b(new_max_size);
-
-    std::copy_n(sparse_.data(), old_max_size, a.data());
-    std::copy_n(dense_.data(), old_max_size, b.data());
-
-    sparse_ = std::move(a);
-    dense_ = std::move(b);
-
-    MaybeInitializeMemory(old_max_size, new_max_size);
-  }
-  if (size_ > new_max_size)
-    size_ = new_max_size;
-  DebugCheckInvariants();
-}
-
-// Check whether index i is in the set.
-template<typename Value>
-bool SparseSetT<Value>::contains(int i) const {
-  assert(i >= 0);
-  assert(i < max_size());
-  if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-    return false;
-  }
-  // Unsigned comparison avoids checking sparse_[i] < 0.
-  return (uint32_t)sparse_[i] < (uint32_t)size_ &&
-         dense_[sparse_[i]] == i;
-}
-
-template<typename Value>
-void SparseSetT<Value>::create_index(int i) {
-  assert(!contains(i));
-  assert(size_ < max_size());
-  sparse_[i] = size_;
-  dense_[size_] = i;
-  size_++;
-}
-
-template<typename Value> SparseSetT<Value>::SparseSetT(int max_size) :
-    sparse_(max_size), dense_(max_size) {
-  MaybeInitializeMemory(size_, max_size);
-  DebugCheckInvariants();
-}
-
-template<typename Value> SparseSetT<Value>::~SparseSetT() {
-  DebugCheckInvariants();
-}
-
-template<typename Value> void SparseSetT<Value>::DebugCheckInvariants() const {
-  assert(0 <= size_);
-  assert(size_ <= max_size());
-}
-
-// Comparison function for sorting.
-template<typename Value> bool SparseSetT<Value>::less(int a, int b) {
-  return a < b;
-}
-
-typedef SparseSetT<void> SparseSet;
-
-}  // namespace re2
-
-#endif  // RE2_SPARSE_SET_H_
diff --git a/src/duckdb/third_party/re2/re2/stringpiece.cc b/src/duckdb/third_party/re2/re2/stringpiece.cc
deleted file mode 100644
index f38c91e9b..000000000
--- a/src/duckdb/third_party/re2/re2/stringpiece.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2004 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "re2/stringpiece.h"
-
-#include <ostream>
-
-#include "util/util.h"
-
-namespace duckdb_re2 {
-
-const StringPiece::size_type StringPiece::npos;  // initialized in stringpiece.h
-
-StringPiece::size_type StringPiece::copy(char* buf, size_type n,
-                                         size_type pos) const {
-  size_type ret = std::min(size_ - pos, n);
-  memcpy(buf, data_ + pos, ret);
-  return ret;
-}
-
-StringPiece StringPiece::substr(size_type pos, size_type n) const {
-  if (pos > size_) pos = size_;
-  if (n > size_ - pos) n = size_ - pos;
-  return StringPiece(data_ + pos, n);
-}
-
-StringPiece::size_type StringPiece::find(const StringPiece& s,
-                                         size_type pos) const {
-  if (pos > size_) return npos;
-  const_pointer result = std::search(data_ + pos, data_ + size_,
-                                     s.data_, s.data_ + s.size_);
-  size_type xpos = result - data_;
-  return xpos + s.size_ <= size_ ? xpos : npos;
-}
-
-StringPiece::size_type StringPiece::find(char c, size_type pos) const {
-  if (size_ <= 0 || pos >= size_) return npos;
-  const_pointer result = std::find(data_ + pos, data_ + size_, c);
-  return result != data_ + size_ ? result - data_ : npos;
-}
-
-StringPiece::size_type StringPiece::rfind(const StringPiece& s,
-                                          size_type pos) const {
-  if (size_ < s.size_) return npos;
-  if (s.size_ == 0) return std::min(size_, pos);
-  const_pointer last = data_ + std::min(size_ - s.size_, pos) + s.size_;
-  const_pointer result = std::find_end(data_, last, s.data_, s.data_ + s.size_);
-  return result != last ? result - data_ : npos;
-}
-
-StringPiece::size_type StringPiece::rfind(char c, size_type pos) const {
-  if (size_ <= 0) return npos;
-  for (size_t i = std::min(pos + 1, size_); i != 0;) {
-    if (data_[--i] == c) return i;
-  }
-  return npos;
-}
-
-std::ostream& operator<<(std::ostream& o, const StringPiece& p) {
-  o.write(p.data(), p.size());
-  return o;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/stringpiece.h b/src/duckdb/third_party/re2/re2/stringpiece.h
deleted file mode 100644
index 9a64617e4..000000000
--- a/src/duckdb/third_party/re2/re2/stringpiece.h
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright 2001-2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_STRINGPIECE_H_
-#define RE2_STRINGPIECE_H_
-
-#ifdef min
-#undef min
-#endif
-
-// A string-like object that points to a sized piece of memory.
-//
-// Functions or methods may use const StringPiece& parameters to accept either
-// a "const char*" or a "string" value that will be implicitly converted to
-// a StringPiece.  The implicit conversion means that it is often appropriate
-// to include this .h file in other files rather than forward-declaring
-// StringPiece as would be appropriate for most other Google classes.
-//
-// Systematic usage of StringPiece is encouraged as it will reduce unnecessary
-// conversions from "const char*" to "string" and back again.
-//
-//
-// Arghh!  I wish C++ literals were "string".
-
-#include <stddef.h>
-#include <string.h>
-#include <algorithm>
-#include <iosfwd>
-#include <iterator>
-#include <string>
-#ifdef __cpp_lib_string_view
-#include <string_view>
-#endif
-
-namespace duckdb_re2 {
-
-class StringPiece {
- public:
-  typedef std::char_traits<char> traits_type;
-  typedef char value_type;
-  typedef char* pointer;
-  typedef const char* const_pointer;
-  typedef char& reference;
-  typedef const char& const_reference;
-  typedef const char* const_iterator;
-  typedef const_iterator iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef const_reverse_iterator reverse_iterator;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  static const size_type npos = static_cast<size_type>(-1);
-
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected.
-  StringPiece()
-      : data_(NULL), size_(0) {}
-#ifdef __cpp_lib_string_view
-  StringPiece(const std::string_view& str)
-      : data_(str.data()), size_(str.size()) {}
-#endif
-  StringPiece(const std::string& str)
-      : data_(str.data()), size_(str.size()) {}
-  StringPiece(const char* str)
-      : data_(str), size_(str == NULL ? 0 : strlen(str)) {}
-  StringPiece(const char* str, size_type len)
-      : data_(str), size_(len) {}
-
-  const_iterator begin() const { return data_; }
-  const_iterator end() const { return data_ + size_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(data_ + size_);
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(data_);
-  }
-
-  size_type size() const { return size_; }
-  size_type length() const { return size_; }
-  bool empty() const { return size_ == 0; }
-
-  const_reference operator[](size_type i) const { return data_[i]; }
-  const_pointer data() const { return data_; }
-
-  void remove_prefix(size_type n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_type n) {
-    size_ -= n;
-  }
-
-  void set(const char* str) {
-    data_ = str;
-    size_ = str == NULL ? 0 : strlen(str);
-  }
-
-  void set(const char* str, size_type len) {
-    data_ = str;
-    size_ = len;
-  }
-
-#ifdef __cpp_lib_string_view
-  // Converts to `std::basic_string_view`.
-  operator std::basic_string_view<char, traits_type>() const {
-    if (!data_) return {};
-    return std::basic_string_view<char, traits_type>(data_, size_);
-  }
-#endif
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data_) return {};
-    return std::basic_string<char, traits_type, A>(data_, size_);
-  }
-
-  std::string as_string() const {
-    return std::string(data_, size_);
-  }
-
-  // We also define ToString() here, since many other string-like
-  // interfaces name the routine that converts to a C++ string
-  // "ToString", and it's confusing to have the method that does that
-  // for a StringPiece be called "as_string()".  We also leave the
-  // "as_string()" method defined here for existing code.
-  std::string ToString() const {
-    return std::string(data_, size_);
-  }
-
-  void CopyToString(std::string* target) const {
-    target->assign(data_, size_);
-  }
-
-  void AppendToString(std::string* target) const {
-    target->append(data_, size_);
-  }
-
-  size_type copy(char* buf, size_type n, size_type pos = 0) const;
-  StringPiece substr(size_type pos = 0, size_type n = npos) const;
-
-  int compare(const StringPiece& x) const {
-    size_type min_size = std::min(size(), x.size());
-    if (min_size > 0) {
-      int r = memcmp(data(), x.data(), min_size);
-      if (r < 0) return -1;
-      if (r > 0) return 1;
-    }
-    if (size() < x.size()) return -1;
-    if (size() > x.size()) return 1;
-    return 0;
-  }
-
-  // Does "this" start with "x"?
-  bool starts_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
-  }
-
-  // Does "this" end with "x"?
-  bool ends_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() &&
-            memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
-  }
-
-  bool contains(const StringPiece& s) const {
-    return find(s) != npos;
-  }
-
-  size_type find(const StringPiece& s, size_type pos = 0) const;
-  size_type find(char c, size_type pos = 0) const;
-  size_type rfind(const StringPiece& s, size_type pos = npos) const;
-  size_type rfind(char c, size_type pos = npos) const;
-
- private:
-  const_pointer data_;
-  size_type size_;
-};
-
-inline bool operator==(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type len = x.size();
-  if (len != y.size()) return false;
-  return x.data() == y.data() || len == 0 ||
-         memcmp(x.data(), y.data(), len) == 0;
-}
-
-inline bool operator!=(const StringPiece& x, const StringPiece& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type min_size = std::min(x.size(), y.size());
-  int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool operator>(const StringPiece& x, const StringPiece& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece& x, const StringPiece& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece& x, const StringPiece& y) {
-  return !(x < y);
-}
-
-// Allow StringPiece to be logged.
-std::ostream& operator<<(std::ostream& o, const StringPiece& p);
-
-}  // namespace re2
-
-#endif  // RE2_STRINGPIECE_H_
diff --git a/src/duckdb/third_party/re2/re2/tostring.cc b/src/duckdb/third_party/re2/re2/tostring.cc
deleted file mode 100644
index fea60880c..000000000
--- a/src/duckdb/third_party/re2/re2/tostring.cc
+++ /dev/null
@@ -1,351 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Format a regular expression structure as a string.
-// Tested by parse_test.cc
-
-#include <string.h>
-#include <string>
-
-#include "util/util.h"
-#include "util/logging.h"
-#include "util/strutil.h"
-#include "util/utf.h"
-#include "re2/regexp.h"
-#include "re2/walker-inl.h"
-
-namespace duckdb_re2 {
-
-enum {
-  PrecAtom,
-  PrecUnary,
-  PrecConcat,
-  PrecAlternate,
-  PrecEmpty,
-  PrecParen,
-  PrecToplevel,
-};
-
-// Helper function.  See description below.
-static void AppendCCRange(std::string* t, Rune lo, Rune hi);
-
-// Walker to generate string in s_.
-// The arg pointers are actually integers giving the
-// context precedence.
-// The child_args are always NULL.
-class ToStringWalker : public Regexp::Walker<int> {
- public:
-  explicit ToStringWalker(std::string* t) : t_(t) {}
-
-  virtual int PreVisit(Regexp* re, int parent_arg, bool* stop);
-  virtual int PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                        int* child_args, int nchild_args);
-  virtual int ShortVisit(Regexp* re, int parent_arg) {
-    return 0;
-  }
-
- private:
-  std::string* t_;  // The string the walker appends to.
-
-  ToStringWalker(const ToStringWalker&) = delete;
-  ToStringWalker& operator=(const ToStringWalker&) = delete;
-};
-
-std::string Regexp::ToString() {
-  std::string t;
-  ToStringWalker w(&t);
-  w.WalkExponential(this, PrecToplevel, 100000);
-  if (w.stopped_early())
-    t += " [truncated]";
-  return t;
-}
-
-#define ToString DontCallToString  // Avoid accidental recursion.
-
-// Visits re before children are processed.
-// Appends ( if needed and passes new precedence to children.
-int ToStringWalker::PreVisit(Regexp* re, int parent_arg, bool* stop) {
-  int prec = parent_arg;
-  int nprec = PrecAtom;
-
-  switch (re->op()) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpLiteral:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpBeginText:
-    case kRegexpEndText:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpCharClass:
-    case kRegexpHaveMatch:
-      nprec = PrecAtom;
-      break;
-
-    case kRegexpConcat:
-    case kRegexpLiteralString:
-      if (prec < PrecConcat)
-        t_->append("(?:");
-      nprec = PrecConcat;
-      break;
-
-    case kRegexpAlternate:
-      if (prec < PrecAlternate)
-        t_->append("(?:");
-      nprec = PrecAlternate;
-      break;
-
-    case kRegexpCapture:
-      t_->append("(");
-      if (re->cap() == 0)
-        LOG(DFATAL) << "kRegexpCapture cap() == 0";
-      if (re->name()) {
-        t_->append("?P<");
-        t_->append(*re->name());
-        t_->append(">");
-      }
-      nprec = PrecParen;
-      break;
-
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-    case kRegexpRepeat:
-      if (prec < PrecUnary)
-        t_->append("(?:");
-      // The subprecedence here is PrecAtom instead of PrecUnary
-      // because PCRE treats two unary ops in a row as a parse error.
-      nprec = PrecAtom;
-      break;
-  }
-
-  return nprec;
-}
-
-static void AppendLiteral(std::string *t, Rune r, bool foldcase) {
-  if (r != 0 && r < 0x80 && strchr("(){}[]*+?|.^$\\", r)) {
-    t->append(1, '\\');
-    t->append(1, static_cast<char>(r));
-  } else if (foldcase && 'a' <= r && r <= 'z') {
-    r -= 'a' - 'A';
-    t->append(1, '[');
-    t->append(1, static_cast<char>(r));
-    t->append(1, static_cast<char>(r) + 'a' - 'A');
-    t->append(1, ']');
-  } else {
-    AppendCCRange(t, r, r);
-  }
-}
-
-// Visits re after children are processed.
-// For childless regexps, all the work is done here.
-// For regexps with children, append any unary suffixes or ).
-int ToStringWalker::PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                              int* child_args, int nchild_args) {
-  int prec = parent_arg;
-  switch (re->op()) {
-    case kRegexpNoMatch:
-      // There's no simple symbol for "no match", but
-      // [^0-Runemax] excludes everything.
-      t_->append("[^\\x00-\\x{10ffff}]");
-      break;
-
-    case kRegexpEmptyMatch:
-      // Append (?:) to make empty string visible,
-      // unless this is already being parenthesized.
-      if (prec < PrecEmpty)
-        t_->append("(?:)");
-      break;
-
-    case kRegexpLiteral:
-      AppendLiteral(t_, re->rune(),
-                    (re->parse_flags() & Regexp::FoldCase) != 0);
-      break;
-
-    case kRegexpLiteralString:
-      for (int i = 0; i < re->nrunes(); i++)
-        AppendLiteral(t_, re->runes()[i],
-                      (re->parse_flags() & Regexp::FoldCase) != 0);
-      if (prec < PrecConcat)
-        t_->append(")");
-      break;
-
-    case kRegexpConcat:
-      if (prec < PrecConcat)
-        t_->append(")");
-      break;
-
-    case kRegexpAlternate:
-      // Clumsy but workable: the children all appended |
-      // at the end of their strings, so just remove the last one.
-      if ((*t_)[t_->size()-1] == '|')
-        t_->erase(t_->size()-1);
-      else
-        LOG(DFATAL) << "Bad final char: " << t_;
-      if (prec < PrecAlternate)
-        t_->append(")");
-      break;
-
-    case kRegexpStar:
-      t_->append("*");
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpPlus:
-      t_->append("+");
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpQuest:
-      t_->append("?");
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpRepeat:
-      if (re->max() == -1)
-        t_->append(StringPrintf("{%d,}", re->min()));
-      else if (re->min() == re->max())
-        t_->append(StringPrintf("{%d}", re->min()));
-      else
-        t_->append(StringPrintf("{%d,%d}", re->min(), re->max()));
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpAnyChar:
-      t_->append(".");
-      break;
-
-    case kRegexpAnyByte:
-      t_->append("\\C");
-      break;
-
-    case kRegexpBeginLine:
-      t_->append("^");
-      break;
-
-    case kRegexpEndLine:
-      t_->append("$");
-      break;
-
-    case kRegexpBeginText:
-      t_->append("(?-m:^)");
-      break;
-
-    case kRegexpEndText:
-      if (re->parse_flags() & Regexp::WasDollar)
-        t_->append("(?-m:$)");
-      else
-        t_->append("\\z");
-      break;
-
-    case kRegexpWordBoundary:
-      t_->append("\\b");
-      break;
-
-    case kRegexpNoWordBoundary:
-      t_->append("\\B");
-      break;
-
-    case kRegexpCharClass: {
-      if (re->cc()->size() == 0) {
-        t_->append("[^\\x00-\\x{10ffff}]");
-        break;
-      }
-      t_->append("[");
-      // Heuristic: show class as negated if it contains the
-      // non-character 0xFFFE and yet somehow isn't full.
-      CharClass* cc = re->cc();
-      if (cc->Contains(0xFFFE) && !cc->full()) {
-        cc = cc->Negate();
-        t_->append("^");
-      }
-      for (CharClass::iterator i = cc->begin(); i != cc->end(); ++i)
-        AppendCCRange(t_, i->lo, i->hi);
-      if (cc != re->cc())
-        cc->Delete();
-      t_->append("]");
-      break;
-    }
-
-    case kRegexpCapture:
-      t_->append(")");
-      break;
-
-    case kRegexpHaveMatch:
-      // There's no syntax accepted by the parser to generate
-      // this node (it is generated by RE2::Set) so make something
-      // up that is readable but won't compile.
-      t_->append(StringPrintf("(?HaveMatch:%d)", re->match_id()));
-      break;
-  }
-
-  // If the parent is an alternation, append the | for it.
-  if (prec == PrecAlternate)
-    t_->append("|");
-
-  return 0;
-}
-
-// Appends a rune for use in a character class to the string t.
-static void AppendCCChar(std::string* t, Rune r) {
-  if (0x20 <= r && r <= 0x7E) {
-    if (strchr("[]^-\\", r))
-      t->append("\\");
-    t->append(1, static_cast<char>(r));
-    return;
-  }
-  switch (r) {
-    default:
-      break;
-
-    case '\r':
-      t->append("\\r");
-      return;
-
-    case '\t':
-      t->append("\\t");
-      return;
-
-    case '\n':
-      t->append("\\n");
-      return;
-
-    case '\f':
-      t->append("\\f");
-      return;
-  }
-
-  if (r < 0x100) {
-    *t += StringPrintf("\\x%02x", static_cast<int>(r));
-    return;
-  }
-  *t += StringPrintf("\\x{%x}", static_cast<int>(r));
-}
-
-static void AppendCCRange(std::string* t, Rune lo, Rune hi) {
-  if (lo > hi)
-    return;
-  AppendCCChar(t, lo);
-  if (lo < hi) {
-    t->append("-");
-    AppendCCChar(t, hi);
-  }
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/re2/unicode_casefold.cc b/src/duckdb/third_party/re2/re2/unicode_casefold.cc
deleted file mode 100644
index d5f7ac218..000000000
--- a/src/duckdb/third_party/re2/re2/unicode_casefold.cc
+++ /dev/null
@@ -1,596 +0,0 @@
-
-// GENERATED BY make_unicode_casefold.py; DO NOT EDIT.
-// make_unicode_casefold.py >unicode_casefold.cc
-
-#include "re2/unicode_casefold.h"
-
-namespace duckdb_re2 {
-
-
-// 1424 groups, 2878 pairs, 367 ranges
-const CaseFold unicode_casefold[] = {
-	{ 65, 90, 32 },
-	{ 97, 106, -32 },
-	{ 107, 107, 8383 },
-	{ 108, 114, -32 },
-	{ 115, 115, 268 },
-	{ 116, 122, -32 },
-	{ 181, 181, 743 },
-	{ 192, 214, 32 },
-	{ 216, 222, 32 },
-	{ 223, 223, 7615 },
-	{ 224, 228, -32 },
-	{ 229, 229, 8262 },
-	{ 230, 246, -32 },
-	{ 248, 254, -32 },
-	{ 255, 255, 121 },
-	{ 256, 303, EvenOdd },
-	{ 306, 311, EvenOdd },
-	{ 313, 328, OddEven },
-	{ 330, 375, EvenOdd },
-	{ 376, 376, -121 },
-	{ 377, 382, OddEven },
-	{ 383, 383, -300 },
-	{ 384, 384, 195 },
-	{ 385, 385, 210 },
-	{ 386, 389, EvenOdd },
-	{ 390, 390, 206 },
-	{ 391, 392, OddEven },
-	{ 393, 394, 205 },
-	{ 395, 396, OddEven },
-	{ 398, 398, 79 },
-	{ 399, 399, 202 },
-	{ 400, 400, 203 },
-	{ 401, 402, OddEven },
-	{ 403, 403, 205 },
-	{ 404, 404, 207 },
-	{ 405, 405, 97 },
-	{ 406, 406, 211 },
-	{ 407, 407, 209 },
-	{ 408, 409, EvenOdd },
-	{ 410, 410, 163 },
-	{ 412, 412, 211 },
-	{ 413, 413, 213 },
-	{ 414, 414, 130 },
-	{ 415, 415, 214 },
-	{ 416, 421, EvenOdd },
-	{ 422, 422, 218 },
-	{ 423, 424, OddEven },
-	{ 425, 425, 218 },
-	{ 428, 429, EvenOdd },
-	{ 430, 430, 218 },
-	{ 431, 432, OddEven },
-	{ 433, 434, 217 },
-	{ 435, 438, OddEven },
-	{ 439, 439, 219 },
-	{ 440, 441, EvenOdd },
-	{ 444, 445, EvenOdd },
-	{ 447, 447, 56 },
-	{ 452, 452, EvenOdd },
-	{ 453, 453, OddEven },
-	{ 454, 454, -2 },
-	{ 455, 455, OddEven },
-	{ 456, 456, EvenOdd },
-	{ 457, 457, -2 },
-	{ 458, 458, EvenOdd },
-	{ 459, 459, OddEven },
-	{ 460, 460, -2 },
-	{ 461, 476, OddEven },
-	{ 477, 477, -79 },
-	{ 478, 495, EvenOdd },
-	{ 497, 497, OddEven },
-	{ 498, 498, EvenOdd },
-	{ 499, 499, -2 },
-	{ 500, 501, EvenOdd },
-	{ 502, 502, -97 },
-	{ 503, 503, -56 },
-	{ 504, 543, EvenOdd },
-	{ 544, 544, -130 },
-	{ 546, 563, EvenOdd },
-	{ 570, 570, 10795 },
-	{ 571, 572, OddEven },
-	{ 573, 573, -163 },
-	{ 574, 574, 10792 },
-	{ 575, 576, 10815 },
-	{ 577, 578, OddEven },
-	{ 579, 579, -195 },
-	{ 580, 580, 69 },
-	{ 581, 581, 71 },
-	{ 582, 591, EvenOdd },
-	{ 592, 592, 10783 },
-	{ 593, 593, 10780 },
-	{ 594, 594, 10782 },
-	{ 595, 595, -210 },
-	{ 596, 596, -206 },
-	{ 598, 599, -205 },
-	{ 601, 601, -202 },
-	{ 603, 603, -203 },
-	{ 604, 604, 42319 },
-	{ 608, 608, -205 },
-	{ 609, 609, 42315 },
-	{ 611, 611, -207 },
-	{ 613, 613, 42280 },
-	{ 614, 614, 42308 },
-	{ 616, 616, -209 },
-	{ 617, 617, -211 },
-	{ 618, 618, 42308 },
-	{ 619, 619, 10743 },
-	{ 620, 620, 42305 },
-	{ 623, 623, -211 },
-	{ 625, 625, 10749 },
-	{ 626, 626, -213 },
-	{ 629, 629, -214 },
-	{ 637, 637, 10727 },
-	{ 640, 640, -218 },
-	{ 642, 642, 42307 },
-	{ 643, 643, -218 },
-	{ 647, 647, 42282 },
-	{ 648, 648, -218 },
-	{ 649, 649, -69 },
-	{ 650, 651, -217 },
-	{ 652, 652, -71 },
-	{ 658, 658, -219 },
-	{ 669, 669, 42261 },
-	{ 670, 670, 42258 },
-	{ 837, 837, 84 },
-	{ 880, 883, EvenOdd },
-	{ 886, 887, EvenOdd },
-	{ 891, 893, 130 },
-	{ 895, 895, 116 },
-	{ 902, 902, 38 },
-	{ 904, 906, 37 },
-	{ 908, 908, 64 },
-	{ 910, 911, 63 },
-	{ 913, 929, 32 },
-	{ 931, 931, 31 },
-	{ 932, 939, 32 },
-	{ 940, 940, -38 },
-	{ 941, 943, -37 },
-	{ 945, 945, -32 },
-	{ 946, 946, 30 },
-	{ 947, 948, -32 },
-	{ 949, 949, 64 },
-	{ 950, 951, -32 },
-	{ 952, 952, 25 },
-	{ 953, 953, 7173 },
-	{ 954, 954, 54 },
-	{ 955, 955, -32 },
-	{ 956, 956, -775 },
-	{ 957, 959, -32 },
-	{ 960, 960, 22 },
-	{ 961, 961, 48 },
-	{ 962, 962, EvenOdd },
-	{ 963, 965, -32 },
-	{ 966, 966, 15 },
-	{ 967, 968, -32 },
-	{ 969, 969, 7517 },
-	{ 970, 971, -32 },
-	{ 972, 972, -64 },
-	{ 973, 974, -63 },
-	{ 975, 975, 8 },
-	{ 976, 976, -62 },
-	{ 977, 977, 35 },
-	{ 981, 981, -47 },
-	{ 982, 982, -54 },
-	{ 983, 983, -8 },
-	{ 984, 1007, EvenOdd },
-	{ 1008, 1008, -86 },
-	{ 1009, 1009, -80 },
-	{ 1010, 1010, 7 },
-	{ 1011, 1011, -116 },
-	{ 1012, 1012, -92 },
-	{ 1013, 1013, -96 },
-	{ 1015, 1016, OddEven },
-	{ 1017, 1017, -7 },
-	{ 1018, 1019, EvenOdd },
-	{ 1021, 1023, -130 },
-	{ 1024, 1039, 80 },
-	{ 1040, 1071, 32 },
-	{ 1072, 1073, -32 },
-	{ 1074, 1074, 6222 },
-	{ 1075, 1075, -32 },
-	{ 1076, 1076, 6221 },
-	{ 1077, 1085, -32 },
-	{ 1086, 1086, 6212 },
-	{ 1087, 1088, -32 },
-	{ 1089, 1090, 6210 },
-	{ 1091, 1097, -32 },
-	{ 1098, 1098, 6204 },
-	{ 1099, 1103, -32 },
-	{ 1104, 1119, -80 },
-	{ 1120, 1122, EvenOdd },
-	{ 1123, 1123, 6180 },
-	{ 1124, 1153, EvenOdd },
-	{ 1162, 1215, EvenOdd },
-	{ 1216, 1216, 15 },
-	{ 1217, 1230, OddEven },
-	{ 1231, 1231, -15 },
-	{ 1232, 1327, EvenOdd },
-	{ 1329, 1366, 48 },
-	{ 1377, 1414, -48 },
-	{ 4256, 4293, 7264 },
-	{ 4295, 4295, 7264 },
-	{ 4301, 4301, 7264 },
-	{ 4304, 4346, 3008 },
-	{ 4349, 4351, 3008 },
-	{ 5024, 5103, 38864 },
-	{ 5104, 5109, 8 },
-	{ 5112, 5117, -8 },
-	{ 7296, 7296, -6254 },
-	{ 7297, 7297, -6253 },
-	{ 7298, 7298, -6244 },
-	{ 7299, 7299, -6242 },
-	{ 7300, 7300, EvenOdd },
-	{ 7301, 7301, -6243 },
-	{ 7302, 7302, -6236 },
-	{ 7303, 7303, -6181 },
-	{ 7304, 7304, 35266 },
-	{ 7312, 7354, -3008 },
-	{ 7357, 7359, -3008 },
-	{ 7545, 7545, 35332 },
-	{ 7549, 7549, 3814 },
-	{ 7566, 7566, 35384 },
-	{ 7680, 7776, EvenOdd },
-	{ 7777, 7777, 58 },
-	{ 7778, 7829, EvenOdd },
-	{ 7835, 7835, -59 },
-	{ 7838, 7838, -7615 },
-	{ 7840, 7935, EvenOdd },
-	{ 7936, 7943, 8 },
-	{ 7944, 7951, -8 },
-	{ 7952, 7957, 8 },
-	{ 7960, 7965, -8 },
-	{ 7968, 7975, 8 },
-	{ 7976, 7983, -8 },
-	{ 7984, 7991, 8 },
-	{ 7992, 7999, -8 },
-	{ 8000, 8005, 8 },
-	{ 8008, 8013, -8 },
-	{ 8017, 8017, 8 },
-	{ 8019, 8019, 8 },
-	{ 8021, 8021, 8 },
-	{ 8023, 8023, 8 },
-	{ 8025, 8025, -8 },
-	{ 8027, 8027, -8 },
-	{ 8029, 8029, -8 },
-	{ 8031, 8031, -8 },
-	{ 8032, 8039, 8 },
-	{ 8040, 8047, -8 },
-	{ 8048, 8049, 74 },
-	{ 8050, 8053, 86 },
-	{ 8054, 8055, 100 },
-	{ 8056, 8057, 128 },
-	{ 8058, 8059, 112 },
-	{ 8060, 8061, 126 },
-	{ 8064, 8071, 8 },
-	{ 8072, 8079, -8 },
-	{ 8080, 8087, 8 },
-	{ 8088, 8095, -8 },
-	{ 8096, 8103, 8 },
-	{ 8104, 8111, -8 },
-	{ 8112, 8113, 8 },
-	{ 8115, 8115, 9 },
-	{ 8120, 8121, -8 },
-	{ 8122, 8123, -74 },
-	{ 8124, 8124, -9 },
-	{ 8126, 8126, -7289 },
-	{ 8131, 8131, 9 },
-	{ 8136, 8139, -86 },
-	{ 8140, 8140, -9 },
-	{ 8144, 8145, 8 },
-	{ 8152, 8153, -8 },
-	{ 8154, 8155, -100 },
-	{ 8160, 8161, 8 },
-	{ 8165, 8165, 7 },
-	{ 8168, 8169, -8 },
-	{ 8170, 8171, -112 },
-	{ 8172, 8172, -7 },
-	{ 8179, 8179, 9 },
-	{ 8184, 8185, -128 },
-	{ 8186, 8187, -126 },
-	{ 8188, 8188, -9 },
-	{ 8486, 8486, -7549 },
-	{ 8490, 8490, -8415 },
-	{ 8491, 8491, -8294 },
-	{ 8498, 8498, 28 },
-	{ 8526, 8526, -28 },
-	{ 8544, 8559, 16 },
-	{ 8560, 8575, -16 },
-	{ 8579, 8580, OddEven },
-	{ 9398, 9423, 26 },
-	{ 9424, 9449, -26 },
-	{ 11264, 11311, 48 },
-	{ 11312, 11359, -48 },
-	{ 11360, 11361, EvenOdd },
-	{ 11362, 11362, -10743 },
-	{ 11363, 11363, -3814 },
-	{ 11364, 11364, -10727 },
-	{ 11365, 11365, -10795 },
-	{ 11366, 11366, -10792 },
-	{ 11367, 11372, OddEven },
-	{ 11373, 11373, -10780 },
-	{ 11374, 11374, -10749 },
-	{ 11375, 11375, -10783 },
-	{ 11376, 11376, -10782 },
-	{ 11378, 11379, EvenOdd },
-	{ 11381, 11382, OddEven },
-	{ 11390, 11391, -10815 },
-	{ 11392, 11491, EvenOdd },
-	{ 11499, 11502, OddEven },
-	{ 11506, 11507, EvenOdd },
-	{ 11520, 11557, -7264 },
-	{ 11559, 11559, -7264 },
-	{ 11565, 11565, -7264 },
-	{ 42560, 42570, EvenOdd },
-	{ 42571, 42571, -35267 },
-	{ 42572, 42605, EvenOdd },
-	{ 42624, 42651, EvenOdd },
-	{ 42786, 42799, EvenOdd },
-	{ 42802, 42863, EvenOdd },
-	{ 42873, 42876, OddEven },
-	{ 42877, 42877, -35332 },
-	{ 42878, 42887, EvenOdd },
-	{ 42891, 42892, OddEven },
-	{ 42893, 42893, -42280 },
-	{ 42896, 42899, EvenOdd },
-	{ 42900, 42900, 48 },
-	{ 42902, 42921, EvenOdd },
-	{ 42922, 42922, -42308 },
-	{ 42923, 42923, -42319 },
-	{ 42924, 42924, -42315 },
-	{ 42925, 42925, -42305 },
-	{ 42926, 42926, -42308 },
-	{ 42928, 42928, -42258 },
-	{ 42929, 42929, -42282 },
-	{ 42930, 42930, -42261 },
-	{ 42931, 42931, 928 },
-	{ 42932, 42947, EvenOdd },
-	{ 42948, 42948, -48 },
-	{ 42949, 42949, -42307 },
-	{ 42950, 42950, -35384 },
-	{ 42951, 42954, OddEven },
-	{ 42960, 42961, EvenOdd },
-	{ 42966, 42969, EvenOdd },
-	{ 42997, 42998, OddEven },
-	{ 43859, 43859, -928 },
-	{ 43888, 43967, -38864 },
-	{ 65313, 65338, 32 },
-	{ 65345, 65370, -32 },
-	{ 66560, 66599, 40 },
-	{ 66600, 66639, -40 },
-	{ 66736, 66771, 40 },
-	{ 66776, 66811, -40 },
-	{ 66928, 66938, 39 },
-	{ 66940, 66954, 39 },
-	{ 66956, 66962, 39 },
-	{ 66964, 66965, 39 },
-	{ 66967, 66977, -39 },
-	{ 66979, 66993, -39 },
-	{ 66995, 67001, -39 },
-	{ 67003, 67004, -39 },
-	{ 68736, 68786, 64 },
-	{ 68800, 68850, -64 },
-	{ 71840, 71871, 32 },
-	{ 71872, 71903, -32 },
-	{ 93760, 93791, 32 },
-	{ 93792, 93823, -32 },
-	{ 125184, 125217, 34 },
-	{ 125218, 125251, -34 },
-};
-const int num_unicode_casefold = 367;
-
-// 1424 groups, 1454 pairs, 205 ranges
-const CaseFold unicode_tolower[] = {
-	{ 65, 90, 32 },
-	{ 181, 181, 775 },
-	{ 192, 214, 32 },
-	{ 216, 222, 32 },
-	{ 256, 302, EvenOddSkip },
-	{ 306, 310, EvenOddSkip },
-	{ 313, 327, OddEvenSkip },
-	{ 330, 374, EvenOddSkip },
-	{ 376, 376, -121 },
-	{ 377, 381, OddEvenSkip },
-	{ 383, 383, -268 },
-	{ 385, 385, 210 },
-	{ 386, 388, EvenOddSkip },
-	{ 390, 390, 206 },
-	{ 391, 391, OddEven },
-	{ 393, 394, 205 },
-	{ 395, 395, OddEven },
-	{ 398, 398, 79 },
-	{ 399, 399, 202 },
-	{ 400, 400, 203 },
-	{ 401, 401, OddEven },
-	{ 403, 403, 205 },
-	{ 404, 404, 207 },
-	{ 406, 406, 211 },
-	{ 407, 407, 209 },
-	{ 408, 408, EvenOdd },
-	{ 412, 412, 211 },
-	{ 413, 413, 213 },
-	{ 415, 415, 214 },
-	{ 416, 420, EvenOddSkip },
-	{ 422, 422, 218 },
-	{ 423, 423, OddEven },
-	{ 425, 425, 218 },
-	{ 428, 428, EvenOdd },
-	{ 430, 430, 218 },
-	{ 431, 431, OddEven },
-	{ 433, 434, 217 },
-	{ 435, 437, OddEvenSkip },
-	{ 439, 439, 219 },
-	{ 440, 440, EvenOdd },
-	{ 444, 444, EvenOdd },
-	{ 452, 452, 2 },
-	{ 453, 453, OddEven },
-	{ 455, 455, 2 },
-	{ 456, 456, EvenOdd },
-	{ 458, 458, 2 },
-	{ 459, 475, OddEvenSkip },
-	{ 478, 494, EvenOddSkip },
-	{ 497, 497, 2 },
-	{ 498, 500, EvenOddSkip },
-	{ 502, 502, -97 },
-	{ 503, 503, -56 },
-	{ 504, 542, EvenOddSkip },
-	{ 544, 544, -130 },
-	{ 546, 562, EvenOddSkip },
-	{ 570, 570, 10795 },
-	{ 571, 571, OddEven },
-	{ 573, 573, -163 },
-	{ 574, 574, 10792 },
-	{ 577, 577, OddEven },
-	{ 579, 579, -195 },
-	{ 580, 580, 69 },
-	{ 581, 581, 71 },
-	{ 582, 590, EvenOddSkip },
-	{ 837, 837, 116 },
-	{ 880, 882, EvenOddSkip },
-	{ 886, 886, EvenOdd },
-	{ 895, 895, 116 },
-	{ 902, 902, 38 },
-	{ 904, 906, 37 },
-	{ 908, 908, 64 },
-	{ 910, 911, 63 },
-	{ 913, 929, 32 },
-	{ 931, 939, 32 },
-	{ 962, 962, EvenOdd },
-	{ 975, 975, 8 },
-	{ 976, 976, -30 },
-	{ 977, 977, -25 },
-	{ 981, 981, -15 },
-	{ 982, 982, -22 },
-	{ 984, 1006, EvenOddSkip },
-	{ 1008, 1008, -54 },
-	{ 1009, 1009, -48 },
-	{ 1012, 1012, -60 },
-	{ 1013, 1013, -64 },
-	{ 1015, 1015, OddEven },
-	{ 1017, 1017, -7 },
-	{ 1018, 1018, EvenOdd },
-	{ 1021, 1023, -130 },
-	{ 1024, 1039, 80 },
-	{ 1040, 1071, 32 },
-	{ 1120, 1152, EvenOddSkip },
-	{ 1162, 1214, EvenOddSkip },
-	{ 1216, 1216, 15 },
-	{ 1217, 1229, OddEvenSkip },
-	{ 1232, 1326, EvenOddSkip },
-	{ 1329, 1366, 48 },
-	{ 4256, 4293, 7264 },
-	{ 4295, 4295, 7264 },
-	{ 4301, 4301, 7264 },
-	{ 5112, 5117, -8 },
-	{ 7296, 7296, -6222 },
-	{ 7297, 7297, -6221 },
-	{ 7298, 7298, -6212 },
-	{ 7299, 7300, -6210 },
-	{ 7301, 7301, -6211 },
-	{ 7302, 7302, -6204 },
-	{ 7303, 7303, -6180 },
-	{ 7304, 7304, 35267 },
-	{ 7312, 7354, -3008 },
-	{ 7357, 7359, -3008 },
-	{ 7680, 7828, EvenOddSkip },
-	{ 7835, 7835, -58 },
-	{ 7838, 7838, -7615 },
-	{ 7840, 7934, EvenOddSkip },
-	{ 7944, 7951, -8 },
-	{ 7960, 7965, -8 },
-	{ 7976, 7983, -8 },
-	{ 7992, 7999, -8 },
-	{ 8008, 8013, -8 },
-	{ 8025, 8025, -8 },
-	{ 8027, 8027, -8 },
-	{ 8029, 8029, -8 },
-	{ 8031, 8031, -8 },
-	{ 8040, 8047, -8 },
-	{ 8072, 8079, -8 },
-	{ 8088, 8095, -8 },
-	{ 8104, 8111, -8 },
-	{ 8120, 8121, -8 },
-	{ 8122, 8123, -74 },
-	{ 8124, 8124, -9 },
-	{ 8126, 8126, -7173 },
-	{ 8136, 8139, -86 },
-	{ 8140, 8140, -9 },
-	{ 8152, 8153, -8 },
-	{ 8154, 8155, -100 },
-	{ 8168, 8169, -8 },
-	{ 8170, 8171, -112 },
-	{ 8172, 8172, -7 },
-	{ 8184, 8185, -128 },
-	{ 8186, 8187, -126 },
-	{ 8188, 8188, -9 },
-	{ 8486, 8486, -7517 },
-	{ 8490, 8490, -8383 },
-	{ 8491, 8491, -8262 },
-	{ 8498, 8498, 28 },
-	{ 8544, 8559, 16 },
-	{ 8579, 8579, OddEven },
-	{ 9398, 9423, 26 },
-	{ 11264, 11311, 48 },
-	{ 11360, 11360, EvenOdd },
-	{ 11362, 11362, -10743 },
-	{ 11363, 11363, -3814 },
-	{ 11364, 11364, -10727 },
-	{ 11367, 11371, OddEvenSkip },
-	{ 11373, 11373, -10780 },
-	{ 11374, 11374, -10749 },
-	{ 11375, 11375, -10783 },
-	{ 11376, 11376, -10782 },
-	{ 11378, 11378, EvenOdd },
-	{ 11381, 11381, OddEven },
-	{ 11390, 11391, -10815 },
-	{ 11392, 11490, EvenOddSkip },
-	{ 11499, 11501, OddEvenSkip },
-	{ 11506, 11506, EvenOdd },
-	{ 42560, 42604, EvenOddSkip },
-	{ 42624, 42650, EvenOddSkip },
-	{ 42786, 42798, EvenOddSkip },
-	{ 42802, 42862, EvenOddSkip },
-	{ 42873, 42875, OddEvenSkip },
-	{ 42877, 42877, -35332 },
-	{ 42878, 42886, EvenOddSkip },
-	{ 42891, 42891, OddEven },
-	{ 42893, 42893, -42280 },
-	{ 42896, 42898, EvenOddSkip },
-	{ 42902, 42920, EvenOddSkip },
-	{ 42922, 42922, -42308 },
-	{ 42923, 42923, -42319 },
-	{ 42924, 42924, -42315 },
-	{ 42925, 42925, -42305 },
-	{ 42926, 42926, -42308 },
-	{ 42928, 42928, -42258 },
-	{ 42929, 42929, -42282 },
-	{ 42930, 42930, -42261 },
-	{ 42931, 42931, 928 },
-	{ 42932, 42946, EvenOddSkip },
-	{ 42948, 42948, -48 },
-	{ 42949, 42949, -42307 },
-	{ 42950, 42950, -35384 },
-	{ 42951, 42953, OddEvenSkip },
-	{ 42960, 42960, EvenOdd },
-	{ 42966, 42968, EvenOddSkip },
-	{ 42997, 42997, OddEven },
-	{ 43888, 43967, -38864 },
-	{ 65313, 65338, 32 },
-	{ 66560, 66599, 40 },
-	{ 66736, 66771, 40 },
-	{ 66928, 66938, 39 },
-	{ 66940, 66954, 39 },
-	{ 66956, 66962, 39 },
-	{ 66964, 66965, 39 },
-	{ 68736, 68786, 64 },
-	{ 71840, 71871, 32 },
-	{ 93760, 93791, 32 },
-	{ 125184, 125217, 34 },
-};
-const int num_unicode_tolower = 205;
-
-
-
-} // namespace re2
-
-
diff --git a/src/duckdb/third_party/re2/re2/unicode_casefold.h b/src/duckdb/third_party/re2/re2/unicode_casefold.h
deleted file mode 100644
index 25a399cd0..000000000
--- a/src/duckdb/third_party/re2/re2/unicode_casefold.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_UNICODE_CASEFOLD_H_
-#define RE2_UNICODE_CASEFOLD_H_
-
-// Unicode case folding tables.
-
-// The Unicode case folding tables encode the mapping from one Unicode point
-// to the next largest Unicode point with equivalent folding.  The largest
-// point wraps back to the first.  For example, the tables map:
-//
-//     'A' -> 'a'
-//     'a' -> 'A'
-//
-//     'K' -> 'k'
-//     'k' -> 'K'  (Kelvin symbol)
-//     'K' -> 'K'
-//
-// Like everything Unicode, these tables are big.  If we represent the table
-// as a sorted list of uint32_t pairs, it has 2049 entries and is 16 kB.
-// Most table entries look like the ones around them:
-// 'A' maps to 'A'+32, 'B' maps to 'B'+32, etc.
-// Instead of listing all the pairs explicitly, we make a list of ranges
-// and deltas, so that the table entries for 'A' through 'Z' can be represented
-// as a single entry { 'A', 'Z', +32 }.
-//
-// In addition to blocks that map to each other (A-Z mapping to a-z)
-// there are blocks of pairs that individually map to each other
-// (for example, 0100<->0101, 0102<->0103, 0104<->0105, ...).
-// For those, the special delta value EvenOdd marks even/odd pairs
-// (if even, add 1; if odd, subtract 1), and OddEven marks odd/even pairs.
-//
-// In this form, the table has 274 entries, about 3kB.  If we were to split
-// the table into one for 16-bit codes and an overflow table for larger ones,
-// we could get it down to about 1.5kB, but that's not worth the complexity.
-//
-// The grouped form also allows for efficient fold range calculations
-// rather than looping one character at a time.
-
-#include <stdint.h>
-
-#include "util/util.h"
-#include "util/utf.h"
-
-namespace duckdb_re2 {
-
-enum {
-  EvenOdd = 1,
-  OddEven = -1,
-  EvenOddSkip = 1<<30,
-  OddEvenSkip,
-};
-
-struct CaseFold {
-  Rune lo;
-  Rune hi;
-  int32_t delta;
-};
-
-extern const CaseFold unicode_casefold[];
-extern const int num_unicode_casefold;
-
-extern const CaseFold unicode_tolower[];
-extern const int num_unicode_tolower;
-
-// Returns the CaseFold* in the tables that contains rune.
-// If rune is not in the tables, returns the first CaseFold* after rune.
-// If rune is larger than any value in the tables, returns NULL.
-extern const CaseFold* LookupCaseFold(const CaseFold*, int, Rune rune);
-
-// Returns the result of applying the fold f to the rune r.
-extern Rune ApplyFold(const CaseFold *f, Rune r);
-
-}  // namespace re2
-
-#endif  // RE2_UNICODE_CASEFOLD_H_
diff --git a/src/duckdb/third_party/re2/re2/unicode_groups.cc b/src/duckdb/third_party/re2/re2/unicode_groups.cc
deleted file mode 100644
index f37daaec2..000000000
--- a/src/duckdb/third_party/re2/re2/unicode_groups.cc
+++ /dev/null
@@ -1,6512 +0,0 @@
-
-// GENERATED BY make_unicode_groups.py; DO NOT EDIT.
-// make_unicode_groups.py >unicode_groups.cc
-
-#include "re2/unicode_groups.h"
-
-namespace duckdb_re2 {
-
-
-static const URange16 C_range16[] = {
-	{ 0, 31 },
-	{ 127, 159 },
-	{ 173, 173 },
-	{ 1536, 1541 },
-	{ 1564, 1564 },
-	{ 1757, 1757 },
-	{ 1807, 1807 },
-	{ 2192, 2193 },
-	{ 2274, 2274 },
-	{ 6158, 6158 },
-	{ 8203, 8207 },
-	{ 8234, 8238 },
-	{ 8288, 8292 },
-	{ 8294, 8303 },
-	{ 55296, 63743 },
-	{ 65279, 65279 },
-	{ 65529, 65531 },
-};
-static const URange32 C_range32[] = {
-	{ 69821, 69821 },
-	{ 69837, 69837 },
-	{ 78896, 78911 },
-	{ 113824, 113827 },
-	{ 119155, 119162 },
-	{ 917505, 917505 },
-	{ 917536, 917631 },
-	{ 983040, 1048573 },
-	{ 1048576, 1114109 },
-};
-static const URange16 Cc_range16[] = {
-	{ 0, 31 },
-	{ 127, 159 },
-};
-static const URange16 Cf_range16[] = {
-	{ 173, 173 },
-	{ 1536, 1541 },
-	{ 1564, 1564 },
-	{ 1757, 1757 },
-	{ 1807, 1807 },
-	{ 2192, 2193 },
-	{ 2274, 2274 },
-	{ 6158, 6158 },
-	{ 8203, 8207 },
-	{ 8234, 8238 },
-	{ 8288, 8292 },
-	{ 8294, 8303 },
-	{ 65279, 65279 },
-	{ 65529, 65531 },
-};
-static const URange32 Cf_range32[] = {
-	{ 69821, 69821 },
-	{ 69837, 69837 },
-	{ 78896, 78911 },
-	{ 113824, 113827 },
-	{ 119155, 119162 },
-	{ 917505, 917505 },
-	{ 917536, 917631 },
-};
-static const URange16 Co_range16[] = {
-	{ 57344, 63743 },
-};
-static const URange32 Co_range32[] = {
-	{ 983040, 1048573 },
-	{ 1048576, 1114109 },
-};
-static const URange16 Cs_range16[] = {
-	{ 55296, 57343 },
-};
-static const URange16 L_range16[] = {
-	{ 65, 90 },
-	{ 97, 122 },
-	{ 170, 170 },
-	{ 181, 181 },
-	{ 186, 186 },
-	{ 192, 214 },
-	{ 216, 246 },
-	{ 248, 705 },
-	{ 710, 721 },
-	{ 736, 740 },
-	{ 748, 748 },
-	{ 750, 750 },
-	{ 880, 884 },
-	{ 886, 887 },
-	{ 890, 893 },
-	{ 895, 895 },
-	{ 902, 902 },
-	{ 904, 906 },
-	{ 908, 908 },
-	{ 910, 929 },
-	{ 931, 1013 },
-	{ 1015, 1153 },
-	{ 1162, 1327 },
-	{ 1329, 1366 },
-	{ 1369, 1369 },
-	{ 1376, 1416 },
-	{ 1488, 1514 },
-	{ 1519, 1522 },
-	{ 1568, 1610 },
-	{ 1646, 1647 },
-	{ 1649, 1747 },
-	{ 1749, 1749 },
-	{ 1765, 1766 },
-	{ 1774, 1775 },
-	{ 1786, 1788 },
-	{ 1791, 1791 },
-	{ 1808, 1808 },
-	{ 1810, 1839 },
-	{ 1869, 1957 },
-	{ 1969, 1969 },
-	{ 1994, 2026 },
-	{ 2036, 2037 },
-	{ 2042, 2042 },
-	{ 2048, 2069 },
-	{ 2074, 2074 },
-	{ 2084, 2084 },
-	{ 2088, 2088 },
-	{ 2112, 2136 },
-	{ 2144, 2154 },
-	{ 2160, 2183 },
-	{ 2185, 2190 },
-	{ 2208, 2249 },
-	{ 2308, 2361 },
-	{ 2365, 2365 },
-	{ 2384, 2384 },
-	{ 2392, 2401 },
-	{ 2417, 2432 },
-	{ 2437, 2444 },
-	{ 2447, 2448 },
-	{ 2451, 2472 },
-	{ 2474, 2480 },
-	{ 2482, 2482 },
-	{ 2486, 2489 },
-	{ 2493, 2493 },
-	{ 2510, 2510 },
-	{ 2524, 2525 },
-	{ 2527, 2529 },
-	{ 2544, 2545 },
-	{ 2556, 2556 },
-	{ 2565, 2570 },
-	{ 2575, 2576 },
-	{ 2579, 2600 },
-	{ 2602, 2608 },
-	{ 2610, 2611 },
-	{ 2613, 2614 },
-	{ 2616, 2617 },
-	{ 2649, 2652 },
-	{ 2654, 2654 },
-	{ 2674, 2676 },
-	{ 2693, 2701 },
-	{ 2703, 2705 },
-	{ 2707, 2728 },
-	{ 2730, 2736 },
-	{ 2738, 2739 },
-	{ 2741, 2745 },
-	{ 2749, 2749 },
-	{ 2768, 2768 },
-	{ 2784, 2785 },
-	{ 2809, 2809 },
-	{ 2821, 2828 },
-	{ 2831, 2832 },
-	{ 2835, 2856 },
-	{ 2858, 2864 },
-	{ 2866, 2867 },
-	{ 2869, 2873 },
-	{ 2877, 2877 },
-	{ 2908, 2909 },
-	{ 2911, 2913 },
-	{ 2929, 2929 },
-	{ 2947, 2947 },
-	{ 2949, 2954 },
-	{ 2958, 2960 },
-	{ 2962, 2965 },
-	{ 2969, 2970 },
-	{ 2972, 2972 },
-	{ 2974, 2975 },
-	{ 2979, 2980 },
-	{ 2984, 2986 },
-	{ 2990, 3001 },
-	{ 3024, 3024 },
-	{ 3077, 3084 },
-	{ 3086, 3088 },
-	{ 3090, 3112 },
-	{ 3114, 3129 },
-	{ 3133, 3133 },
-	{ 3160, 3162 },
-	{ 3165, 3165 },
-	{ 3168, 3169 },
-	{ 3200, 3200 },
-	{ 3205, 3212 },
-	{ 3214, 3216 },
-	{ 3218, 3240 },
-	{ 3242, 3251 },
-	{ 3253, 3257 },
-	{ 3261, 3261 },
-	{ 3293, 3294 },
-	{ 3296, 3297 },
-	{ 3313, 3314 },
-	{ 3332, 3340 },
-	{ 3342, 3344 },
-	{ 3346, 3386 },
-	{ 3389, 3389 },
-	{ 3406, 3406 },
-	{ 3412, 3414 },
-	{ 3423, 3425 },
-	{ 3450, 3455 },
-	{ 3461, 3478 },
-	{ 3482, 3505 },
-	{ 3507, 3515 },
-	{ 3517, 3517 },
-	{ 3520, 3526 },
-	{ 3585, 3632 },
-	{ 3634, 3635 },
-	{ 3648, 3654 },
-	{ 3713, 3714 },
-	{ 3716, 3716 },
-	{ 3718, 3722 },
-	{ 3724, 3747 },
-	{ 3749, 3749 },
-	{ 3751, 3760 },
-	{ 3762, 3763 },
-	{ 3773, 3773 },
-	{ 3776, 3780 },
-	{ 3782, 3782 },
-	{ 3804, 3807 },
-	{ 3840, 3840 },
-	{ 3904, 3911 },
-	{ 3913, 3948 },
-	{ 3976, 3980 },
-	{ 4096, 4138 },
-	{ 4159, 4159 },
-	{ 4176, 4181 },
-	{ 4186, 4189 },
-	{ 4193, 4193 },
-	{ 4197, 4198 },
-	{ 4206, 4208 },
-	{ 4213, 4225 },
-	{ 4238, 4238 },
-	{ 4256, 4293 },
-	{ 4295, 4295 },
-	{ 4301, 4301 },
-	{ 4304, 4346 },
-	{ 4348, 4680 },
-	{ 4682, 4685 },
-	{ 4688, 4694 },
-	{ 4696, 4696 },
-	{ 4698, 4701 },
-	{ 4704, 4744 },
-	{ 4746, 4749 },
-	{ 4752, 4784 },
-	{ 4786, 4789 },
-	{ 4792, 4798 },
-	{ 4800, 4800 },
-	{ 4802, 4805 },
-	{ 4808, 4822 },
-	{ 4824, 4880 },
-	{ 4882, 4885 },
-	{ 4888, 4954 },
-	{ 4992, 5007 },
-	{ 5024, 5109 },
-	{ 5112, 5117 },
-	{ 5121, 5740 },
-	{ 5743, 5759 },
-	{ 5761, 5786 },
-	{ 5792, 5866 },
-	{ 5873, 5880 },
-	{ 5888, 5905 },
-	{ 5919, 5937 },
-	{ 5952, 5969 },
-	{ 5984, 5996 },
-	{ 5998, 6000 },
-	{ 6016, 6067 },
-	{ 6103, 6103 },
-	{ 6108, 6108 },
-	{ 6176, 6264 },
-	{ 6272, 6276 },
-	{ 6279, 6312 },
-	{ 6314, 6314 },
-	{ 6320, 6389 },
-	{ 6400, 6430 },
-	{ 6480, 6509 },
-	{ 6512, 6516 },
-	{ 6528, 6571 },
-	{ 6576, 6601 },
-	{ 6656, 6678 },
-	{ 6688, 6740 },
-	{ 6823, 6823 },
-	{ 6917, 6963 },
-	{ 6981, 6988 },
-	{ 7043, 7072 },
-	{ 7086, 7087 },
-	{ 7098, 7141 },
-	{ 7168, 7203 },
-	{ 7245, 7247 },
-	{ 7258, 7293 },
-	{ 7296, 7304 },
-	{ 7312, 7354 },
-	{ 7357, 7359 },
-	{ 7401, 7404 },
-	{ 7406, 7411 },
-	{ 7413, 7414 },
-	{ 7418, 7418 },
-	{ 7424, 7615 },
-	{ 7680, 7957 },
-	{ 7960, 7965 },
-	{ 7968, 8005 },
-	{ 8008, 8013 },
-	{ 8016, 8023 },
-	{ 8025, 8025 },
-	{ 8027, 8027 },
-	{ 8029, 8029 },
-	{ 8031, 8061 },
-	{ 8064, 8116 },
-	{ 8118, 8124 },
-	{ 8126, 8126 },
-	{ 8130, 8132 },
-	{ 8134, 8140 },
-	{ 8144, 8147 },
-	{ 8150, 8155 },
-	{ 8160, 8172 },
-	{ 8178, 8180 },
-	{ 8182, 8188 },
-	{ 8305, 8305 },
-	{ 8319, 8319 },
-	{ 8336, 8348 },
-	{ 8450, 8450 },
-	{ 8455, 8455 },
-	{ 8458, 8467 },
-	{ 8469, 8469 },
-	{ 8473, 8477 },
-	{ 8484, 8484 },
-	{ 8486, 8486 },
-	{ 8488, 8488 },
-	{ 8490, 8493 },
-	{ 8495, 8505 },
-	{ 8508, 8511 },
-	{ 8517, 8521 },
-	{ 8526, 8526 },
-	{ 8579, 8580 },
-	{ 11264, 11492 },
-	{ 11499, 11502 },
-	{ 11506, 11507 },
-	{ 11520, 11557 },
-	{ 11559, 11559 },
-	{ 11565, 11565 },
-	{ 11568, 11623 },
-	{ 11631, 11631 },
-	{ 11648, 11670 },
-	{ 11680, 11686 },
-	{ 11688, 11694 },
-	{ 11696, 11702 },
-	{ 11704, 11710 },
-	{ 11712, 11718 },
-	{ 11720, 11726 },
-	{ 11728, 11734 },
-	{ 11736, 11742 },
-	{ 11823, 11823 },
-	{ 12293, 12294 },
-	{ 12337, 12341 },
-	{ 12347, 12348 },
-	{ 12353, 12438 },
-	{ 12445, 12447 },
-	{ 12449, 12538 },
-	{ 12540, 12543 },
-	{ 12549, 12591 },
-	{ 12593, 12686 },
-	{ 12704, 12735 },
-	{ 12784, 12799 },
-	{ 13312, 19903 },
-	{ 19968, 42124 },
-	{ 42192, 42237 },
-	{ 42240, 42508 },
-	{ 42512, 42527 },
-	{ 42538, 42539 },
-	{ 42560, 42606 },
-	{ 42623, 42653 },
-	{ 42656, 42725 },
-	{ 42775, 42783 },
-	{ 42786, 42888 },
-	{ 42891, 42954 },
-	{ 42960, 42961 },
-	{ 42963, 42963 },
-	{ 42965, 42969 },
-	{ 42994, 43009 },
-	{ 43011, 43013 },
-	{ 43015, 43018 },
-	{ 43020, 43042 },
-	{ 43072, 43123 },
-	{ 43138, 43187 },
-	{ 43250, 43255 },
-	{ 43259, 43259 },
-	{ 43261, 43262 },
-	{ 43274, 43301 },
-	{ 43312, 43334 },
-	{ 43360, 43388 },
-	{ 43396, 43442 },
-	{ 43471, 43471 },
-	{ 43488, 43492 },
-	{ 43494, 43503 },
-	{ 43514, 43518 },
-	{ 43520, 43560 },
-	{ 43584, 43586 },
-	{ 43588, 43595 },
-	{ 43616, 43638 },
-	{ 43642, 43642 },
-	{ 43646, 43695 },
-	{ 43697, 43697 },
-	{ 43701, 43702 },
-	{ 43705, 43709 },
-	{ 43712, 43712 },
-	{ 43714, 43714 },
-	{ 43739, 43741 },
-	{ 43744, 43754 },
-	{ 43762, 43764 },
-	{ 43777, 43782 },
-	{ 43785, 43790 },
-	{ 43793, 43798 },
-	{ 43808, 43814 },
-	{ 43816, 43822 },
-	{ 43824, 43866 },
-	{ 43868, 43881 },
-	{ 43888, 44002 },
-	{ 44032, 55203 },
-	{ 55216, 55238 },
-	{ 55243, 55291 },
-	{ 63744, 64109 },
-	{ 64112, 64217 },
-	{ 64256, 64262 },
-	{ 64275, 64279 },
-	{ 64285, 64285 },
-	{ 64287, 64296 },
-	{ 64298, 64310 },
-	{ 64312, 64316 },
-	{ 64318, 64318 },
-	{ 64320, 64321 },
-	{ 64323, 64324 },
-	{ 64326, 64433 },
-	{ 64467, 64829 },
-	{ 64848, 64911 },
-	{ 64914, 64967 },
-	{ 65008, 65019 },
-	{ 65136, 65140 },
-	{ 65142, 65276 },
-	{ 65313, 65338 },
-	{ 65345, 65370 },
-	{ 65382, 65470 },
-	{ 65474, 65479 },
-	{ 65482, 65487 },
-	{ 65490, 65495 },
-	{ 65498, 65500 },
-};
-static const URange32 L_range32[] = {
-	{ 65536, 65547 },
-	{ 65549, 65574 },
-	{ 65576, 65594 },
-	{ 65596, 65597 },
-	{ 65599, 65613 },
-	{ 65616, 65629 },
-	{ 65664, 65786 },
-	{ 66176, 66204 },
-	{ 66208, 66256 },
-	{ 66304, 66335 },
-	{ 66349, 66368 },
-	{ 66370, 66377 },
-	{ 66384, 66421 },
-	{ 66432, 66461 },
-	{ 66464, 66499 },
-	{ 66504, 66511 },
-	{ 66560, 66717 },
-	{ 66736, 66771 },
-	{ 66776, 66811 },
-	{ 66816, 66855 },
-	{ 66864, 66915 },
-	{ 66928, 66938 },
-	{ 66940, 66954 },
-	{ 66956, 66962 },
-	{ 66964, 66965 },
-	{ 66967, 66977 },
-	{ 66979, 66993 },
-	{ 66995, 67001 },
-	{ 67003, 67004 },
-	{ 67072, 67382 },
-	{ 67392, 67413 },
-	{ 67424, 67431 },
-	{ 67456, 67461 },
-	{ 67463, 67504 },
-	{ 67506, 67514 },
-	{ 67584, 67589 },
-	{ 67592, 67592 },
-	{ 67594, 67637 },
-	{ 67639, 67640 },
-	{ 67644, 67644 },
-	{ 67647, 67669 },
-	{ 67680, 67702 },
-	{ 67712, 67742 },
-	{ 67808, 67826 },
-	{ 67828, 67829 },
-	{ 67840, 67861 },
-	{ 67872, 67897 },
-	{ 67968, 68023 },
-	{ 68030, 68031 },
-	{ 68096, 68096 },
-	{ 68112, 68115 },
-	{ 68117, 68119 },
-	{ 68121, 68149 },
-	{ 68192, 68220 },
-	{ 68224, 68252 },
-	{ 68288, 68295 },
-	{ 68297, 68324 },
-	{ 68352, 68405 },
-	{ 68416, 68437 },
-	{ 68448, 68466 },
-	{ 68480, 68497 },
-	{ 68608, 68680 },
-	{ 68736, 68786 },
-	{ 68800, 68850 },
-	{ 68864, 68899 },
-	{ 69248, 69289 },
-	{ 69296, 69297 },
-	{ 69376, 69404 },
-	{ 69415, 69415 },
-	{ 69424, 69445 },
-	{ 69488, 69505 },
-	{ 69552, 69572 },
-	{ 69600, 69622 },
-	{ 69635, 69687 },
-	{ 69745, 69746 },
-	{ 69749, 69749 },
-	{ 69763, 69807 },
-	{ 69840, 69864 },
-	{ 69891, 69926 },
-	{ 69956, 69956 },
-	{ 69959, 69959 },
-	{ 69968, 70002 },
-	{ 70006, 70006 },
-	{ 70019, 70066 },
-	{ 70081, 70084 },
-	{ 70106, 70106 },
-	{ 70108, 70108 },
-	{ 70144, 70161 },
-	{ 70163, 70187 },
-	{ 70207, 70208 },
-	{ 70272, 70278 },
-	{ 70280, 70280 },
-	{ 70282, 70285 },
-	{ 70287, 70301 },
-	{ 70303, 70312 },
-	{ 70320, 70366 },
-	{ 70405, 70412 },
-	{ 70415, 70416 },
-	{ 70419, 70440 },
-	{ 70442, 70448 },
-	{ 70450, 70451 },
-	{ 70453, 70457 },
-	{ 70461, 70461 },
-	{ 70480, 70480 },
-	{ 70493, 70497 },
-	{ 70656, 70708 },
-	{ 70727, 70730 },
-	{ 70751, 70753 },
-	{ 70784, 70831 },
-	{ 70852, 70853 },
-	{ 70855, 70855 },
-	{ 71040, 71086 },
-	{ 71128, 71131 },
-	{ 71168, 71215 },
-	{ 71236, 71236 },
-	{ 71296, 71338 },
-	{ 71352, 71352 },
-	{ 71424, 71450 },
-	{ 71488, 71494 },
-	{ 71680, 71723 },
-	{ 71840, 71903 },
-	{ 71935, 71942 },
-	{ 71945, 71945 },
-	{ 71948, 71955 },
-	{ 71957, 71958 },
-	{ 71960, 71983 },
-	{ 71999, 71999 },
-	{ 72001, 72001 },
-	{ 72096, 72103 },
-	{ 72106, 72144 },
-	{ 72161, 72161 },
-	{ 72163, 72163 },
-	{ 72192, 72192 },
-	{ 72203, 72242 },
-	{ 72250, 72250 },
-	{ 72272, 72272 },
-	{ 72284, 72329 },
-	{ 72349, 72349 },
-	{ 72368, 72440 },
-	{ 72704, 72712 },
-	{ 72714, 72750 },
-	{ 72768, 72768 },
-	{ 72818, 72847 },
-	{ 72960, 72966 },
-	{ 72968, 72969 },
-	{ 72971, 73008 },
-	{ 73030, 73030 },
-	{ 73056, 73061 },
-	{ 73063, 73064 },
-	{ 73066, 73097 },
-	{ 73112, 73112 },
-	{ 73440, 73458 },
-	{ 73474, 73474 },
-	{ 73476, 73488 },
-	{ 73490, 73523 },
-	{ 73648, 73648 },
-	{ 73728, 74649 },
-	{ 74880, 75075 },
-	{ 77712, 77808 },
-	{ 77824, 78895 },
-	{ 78913, 78918 },
-	{ 82944, 83526 },
-	{ 92160, 92728 },
-	{ 92736, 92766 },
-	{ 92784, 92862 },
-	{ 92880, 92909 },
-	{ 92928, 92975 },
-	{ 92992, 92995 },
-	{ 93027, 93047 },
-	{ 93053, 93071 },
-	{ 93760, 93823 },
-	{ 93952, 94026 },
-	{ 94032, 94032 },
-	{ 94099, 94111 },
-	{ 94176, 94177 },
-	{ 94179, 94179 },
-	{ 94208, 100343 },
-	{ 100352, 101589 },
-	{ 101632, 101640 },
-	{ 110576, 110579 },
-	{ 110581, 110587 },
-	{ 110589, 110590 },
-	{ 110592, 110882 },
-	{ 110898, 110898 },
-	{ 110928, 110930 },
-	{ 110933, 110933 },
-	{ 110948, 110951 },
-	{ 110960, 111355 },
-	{ 113664, 113770 },
-	{ 113776, 113788 },
-	{ 113792, 113800 },
-	{ 113808, 113817 },
-	{ 119808, 119892 },
-	{ 119894, 119964 },
-	{ 119966, 119967 },
-	{ 119970, 119970 },
-	{ 119973, 119974 },
-	{ 119977, 119980 },
-	{ 119982, 119993 },
-	{ 119995, 119995 },
-	{ 119997, 120003 },
-	{ 120005, 120069 },
-	{ 120071, 120074 },
-	{ 120077, 120084 },
-	{ 120086, 120092 },
-	{ 120094, 120121 },
-	{ 120123, 120126 },
-	{ 120128, 120132 },
-	{ 120134, 120134 },
-	{ 120138, 120144 },
-	{ 120146, 120485 },
-	{ 120488, 120512 },
-	{ 120514, 120538 },
-	{ 120540, 120570 },
-	{ 120572, 120596 },
-	{ 120598, 120628 },
-	{ 120630, 120654 },
-	{ 120656, 120686 },
-	{ 120688, 120712 },
-	{ 120714, 120744 },
-	{ 120746, 120770 },
-	{ 120772, 120779 },
-	{ 122624, 122654 },
-	{ 122661, 122666 },
-	{ 122928, 122989 },
-	{ 123136, 123180 },
-	{ 123191, 123197 },
-	{ 123214, 123214 },
-	{ 123536, 123565 },
-	{ 123584, 123627 },
-	{ 124112, 124139 },
-	{ 124896, 124902 },
-	{ 124904, 124907 },
-	{ 124909, 124910 },
-	{ 124912, 124926 },
-	{ 124928, 125124 },
-	{ 125184, 125251 },
-	{ 125259, 125259 },
-	{ 126464, 126467 },
-	{ 126469, 126495 },
-	{ 126497, 126498 },
-	{ 126500, 126500 },
-	{ 126503, 126503 },
-	{ 126505, 126514 },
-	{ 126516, 126519 },
-	{ 126521, 126521 },
-	{ 126523, 126523 },
-	{ 126530, 126530 },
-	{ 126535, 126535 },
-	{ 126537, 126537 },
-	{ 126539, 126539 },
-	{ 126541, 126543 },
-	{ 126545, 126546 },
-	{ 126548, 126548 },
-	{ 126551, 126551 },
-	{ 126553, 126553 },
-	{ 126555, 126555 },
-	{ 126557, 126557 },
-	{ 126559, 126559 },
-	{ 126561, 126562 },
-	{ 126564, 126564 },
-	{ 126567, 126570 },
-	{ 126572, 126578 },
-	{ 126580, 126583 },
-	{ 126585, 126588 },
-	{ 126590, 126590 },
-	{ 126592, 126601 },
-	{ 126603, 126619 },
-	{ 126625, 126627 },
-	{ 126629, 126633 },
-	{ 126635, 126651 },
-	{ 131072, 173791 },
-	{ 173824, 177977 },
-	{ 177984, 178205 },
-	{ 178208, 183969 },
-	{ 183984, 191456 },
-	{ 194560, 195101 },
-	{ 196608, 201546 },
-	{ 201552, 205743 },
-};
-static const URange16 Ll_range16[] = {
-	{ 97, 122 },
-	{ 181, 181 },
-	{ 223, 246 },
-	{ 248, 255 },
-	{ 257, 257 },
-	{ 259, 259 },
-	{ 261, 261 },
-	{ 263, 263 },
-	{ 265, 265 },
-	{ 267, 267 },
-	{ 269, 269 },
-	{ 271, 271 },
-	{ 273, 273 },
-	{ 275, 275 },
-	{ 277, 277 },
-	{ 279, 279 },
-	{ 281, 281 },
-	{ 283, 283 },
-	{ 285, 285 },
-	{ 287, 287 },
-	{ 289, 289 },
-	{ 291, 291 },
-	{ 293, 293 },
-	{ 295, 295 },
-	{ 297, 297 },
-	{ 299, 299 },
-	{ 301, 301 },
-	{ 303, 303 },
-	{ 305, 305 },
-	{ 307, 307 },
-	{ 309, 309 },
-	{ 311, 312 },
-	{ 314, 314 },
-	{ 316, 316 },
-	{ 318, 318 },
-	{ 320, 320 },
-	{ 322, 322 },
-	{ 324, 324 },
-	{ 326, 326 },
-	{ 328, 329 },
-	{ 331, 331 },
-	{ 333, 333 },
-	{ 335, 335 },
-	{ 337, 337 },
-	{ 339, 339 },
-	{ 341, 341 },
-	{ 343, 343 },
-	{ 345, 345 },
-	{ 347, 347 },
-	{ 349, 349 },
-	{ 351, 351 },
-	{ 353, 353 },
-	{ 355, 355 },
-	{ 357, 357 },
-	{ 359, 359 },
-	{ 361, 361 },
-	{ 363, 363 },
-	{ 365, 365 },
-	{ 367, 367 },
-	{ 369, 369 },
-	{ 371, 371 },
-	{ 373, 373 },
-	{ 375, 375 },
-	{ 378, 378 },
-	{ 380, 380 },
-	{ 382, 384 },
-	{ 387, 387 },
-	{ 389, 389 },
-	{ 392, 392 },
-	{ 396, 397 },
-	{ 402, 402 },
-	{ 405, 405 },
-	{ 409, 411 },
-	{ 414, 414 },
-	{ 417, 417 },
-	{ 419, 419 },
-	{ 421, 421 },
-	{ 424, 424 },
-	{ 426, 427 },
-	{ 429, 429 },
-	{ 432, 432 },
-	{ 436, 436 },
-	{ 438, 438 },
-	{ 441, 442 },
-	{ 445, 447 },
-	{ 454, 454 },
-	{ 457, 457 },
-	{ 460, 460 },
-	{ 462, 462 },
-	{ 464, 464 },
-	{ 466, 466 },
-	{ 468, 468 },
-	{ 470, 470 },
-	{ 472, 472 },
-	{ 474, 474 },
-	{ 476, 477 },
-	{ 479, 479 },
-	{ 481, 481 },
-	{ 483, 483 },
-	{ 485, 485 },
-	{ 487, 487 },
-	{ 489, 489 },
-	{ 491, 491 },
-	{ 493, 493 },
-	{ 495, 496 },
-	{ 499, 499 },
-	{ 501, 501 },
-	{ 505, 505 },
-	{ 507, 507 },
-	{ 509, 509 },
-	{ 511, 511 },
-	{ 513, 513 },
-	{ 515, 515 },
-	{ 517, 517 },
-	{ 519, 519 },
-	{ 521, 521 },
-	{ 523, 523 },
-	{ 525, 525 },
-	{ 527, 527 },
-	{ 529, 529 },
-	{ 531, 531 },
-	{ 533, 533 },
-	{ 535, 535 },
-	{ 537, 537 },
-	{ 539, 539 },
-	{ 541, 541 },
-	{ 543, 543 },
-	{ 545, 545 },
-	{ 547, 547 },
-	{ 549, 549 },
-	{ 551, 551 },
-	{ 553, 553 },
-	{ 555, 555 },
-	{ 557, 557 },
-	{ 559, 559 },
-	{ 561, 561 },
-	{ 563, 569 },
-	{ 572, 572 },
-	{ 575, 576 },
-	{ 578, 578 },
-	{ 583, 583 },
-	{ 585, 585 },
-	{ 587, 587 },
-	{ 589, 589 },
-	{ 591, 659 },
-	{ 661, 687 },
-	{ 881, 881 },
-	{ 883, 883 },
-	{ 887, 887 },
-	{ 891, 893 },
-	{ 912, 912 },
-	{ 940, 974 },
-	{ 976, 977 },
-	{ 981, 983 },
-	{ 985, 985 },
-	{ 987, 987 },
-	{ 989, 989 },
-	{ 991, 991 },
-	{ 993, 993 },
-	{ 995, 995 },
-	{ 997, 997 },
-	{ 999, 999 },
-	{ 1001, 1001 },
-	{ 1003, 1003 },
-	{ 1005, 1005 },
-	{ 1007, 1011 },
-	{ 1013, 1013 },
-	{ 1016, 1016 },
-	{ 1019, 1020 },
-	{ 1072, 1119 },
-	{ 1121, 1121 },
-	{ 1123, 1123 },
-	{ 1125, 1125 },
-	{ 1127, 1127 },
-	{ 1129, 1129 },
-	{ 1131, 1131 },
-	{ 1133, 1133 },
-	{ 1135, 1135 },
-	{ 1137, 1137 },
-	{ 1139, 1139 },
-	{ 1141, 1141 },
-	{ 1143, 1143 },
-	{ 1145, 1145 },
-	{ 1147, 1147 },
-	{ 1149, 1149 },
-	{ 1151, 1151 },
-	{ 1153, 1153 },
-	{ 1163, 1163 },
-	{ 1165, 1165 },
-	{ 1167, 1167 },
-	{ 1169, 1169 },
-	{ 1171, 1171 },
-	{ 1173, 1173 },
-	{ 1175, 1175 },
-	{ 1177, 1177 },
-	{ 1179, 1179 },
-	{ 1181, 1181 },
-	{ 1183, 1183 },
-	{ 1185, 1185 },
-	{ 1187, 1187 },
-	{ 1189, 1189 },
-	{ 1191, 1191 },
-	{ 1193, 1193 },
-	{ 1195, 1195 },
-	{ 1197, 1197 },
-	{ 1199, 1199 },
-	{ 1201, 1201 },
-	{ 1203, 1203 },
-	{ 1205, 1205 },
-	{ 1207, 1207 },
-	{ 1209, 1209 },
-	{ 1211, 1211 },
-	{ 1213, 1213 },
-	{ 1215, 1215 },
-	{ 1218, 1218 },
-	{ 1220, 1220 },
-	{ 1222, 1222 },
-	{ 1224, 1224 },
-	{ 1226, 1226 },
-	{ 1228, 1228 },
-	{ 1230, 1231 },
-	{ 1233, 1233 },
-	{ 1235, 1235 },
-	{ 1237, 1237 },
-	{ 1239, 1239 },
-	{ 1241, 1241 },
-	{ 1243, 1243 },
-	{ 1245, 1245 },
-	{ 1247, 1247 },
-	{ 1249, 1249 },
-	{ 1251, 1251 },
-	{ 1253, 1253 },
-	{ 1255, 1255 },
-	{ 1257, 1257 },
-	{ 1259, 1259 },
-	{ 1261, 1261 },
-	{ 1263, 1263 },
-	{ 1265, 1265 },
-	{ 1267, 1267 },
-	{ 1269, 1269 },
-	{ 1271, 1271 },
-	{ 1273, 1273 },
-	{ 1275, 1275 },
-	{ 1277, 1277 },
-	{ 1279, 1279 },
-	{ 1281, 1281 },
-	{ 1283, 1283 },
-	{ 1285, 1285 },
-	{ 1287, 1287 },
-	{ 1289, 1289 },
-	{ 1291, 1291 },
-	{ 1293, 1293 },
-	{ 1295, 1295 },
-	{ 1297, 1297 },
-	{ 1299, 1299 },
-	{ 1301, 1301 },
-	{ 1303, 1303 },
-	{ 1305, 1305 },
-	{ 1307, 1307 },
-	{ 1309, 1309 },
-	{ 1311, 1311 },
-	{ 1313, 1313 },
-	{ 1315, 1315 },
-	{ 1317, 1317 },
-	{ 1319, 1319 },
-	{ 1321, 1321 },
-	{ 1323, 1323 },
-	{ 1325, 1325 },
-	{ 1327, 1327 },
-	{ 1376, 1416 },
-	{ 4304, 4346 },
-	{ 4349, 4351 },
-	{ 5112, 5117 },
-	{ 7296, 7304 },
-	{ 7424, 7467 },
-	{ 7531, 7543 },
-	{ 7545, 7578 },
-	{ 7681, 7681 },
-	{ 7683, 7683 },
-	{ 7685, 7685 },
-	{ 7687, 7687 },
-	{ 7689, 7689 },
-	{ 7691, 7691 },
-	{ 7693, 7693 },
-	{ 7695, 7695 },
-	{ 7697, 7697 },
-	{ 7699, 7699 },
-	{ 7701, 7701 },
-	{ 7703, 7703 },
-	{ 7705, 7705 },
-	{ 7707, 7707 },
-	{ 7709, 7709 },
-	{ 7711, 7711 },
-	{ 7713, 7713 },
-	{ 7715, 7715 },
-	{ 7717, 7717 },
-	{ 7719, 7719 },
-	{ 7721, 7721 },
-	{ 7723, 7723 },
-	{ 7725, 7725 },
-	{ 7727, 7727 },
-	{ 7729, 7729 },
-	{ 7731, 7731 },
-	{ 7733, 7733 },
-	{ 7735, 7735 },
-	{ 7737, 7737 },
-	{ 7739, 7739 },
-	{ 7741, 7741 },
-	{ 7743, 7743 },
-	{ 7745, 7745 },
-	{ 7747, 7747 },
-	{ 7749, 7749 },
-	{ 7751, 7751 },
-	{ 7753, 7753 },
-	{ 7755, 7755 },
-	{ 7757, 7757 },
-	{ 7759, 7759 },
-	{ 7761, 7761 },
-	{ 7763, 7763 },
-	{ 7765, 7765 },
-	{ 7767, 7767 },
-	{ 7769, 7769 },
-	{ 7771, 7771 },
-	{ 7773, 7773 },
-	{ 7775, 7775 },
-	{ 7777, 7777 },
-	{ 7779, 7779 },
-	{ 7781, 7781 },
-	{ 7783, 7783 },
-	{ 7785, 7785 },
-	{ 7787, 7787 },
-	{ 7789, 7789 },
-	{ 7791, 7791 },
-	{ 7793, 7793 },
-	{ 7795, 7795 },
-	{ 7797, 7797 },
-	{ 7799, 7799 },
-	{ 7801, 7801 },
-	{ 7803, 7803 },
-	{ 7805, 7805 },
-	{ 7807, 7807 },
-	{ 7809, 7809 },
-	{ 7811, 7811 },
-	{ 7813, 7813 },
-	{ 7815, 7815 },
-	{ 7817, 7817 },
-	{ 7819, 7819 },
-	{ 7821, 7821 },
-	{ 7823, 7823 },
-	{ 7825, 7825 },
-	{ 7827, 7827 },
-	{ 7829, 7837 },
-	{ 7839, 7839 },
-	{ 7841, 7841 },
-	{ 7843, 7843 },
-	{ 7845, 7845 },
-	{ 7847, 7847 },
-	{ 7849, 7849 },
-	{ 7851, 7851 },
-	{ 7853, 7853 },
-	{ 7855, 7855 },
-	{ 7857, 7857 },
-	{ 7859, 7859 },
-	{ 7861, 7861 },
-	{ 7863, 7863 },
-	{ 7865, 7865 },
-	{ 7867, 7867 },
-	{ 7869, 7869 },
-	{ 7871, 7871 },
-	{ 7873, 7873 },
-	{ 7875, 7875 },
-	{ 7877, 7877 },
-	{ 7879, 7879 },
-	{ 7881, 7881 },
-	{ 7883, 7883 },
-	{ 7885, 7885 },
-	{ 7887, 7887 },
-	{ 7889, 7889 },
-	{ 7891, 7891 },
-	{ 7893, 7893 },
-	{ 7895, 7895 },
-	{ 7897, 7897 },
-	{ 7899, 7899 },
-	{ 7901, 7901 },
-	{ 7903, 7903 },
-	{ 7905, 7905 },
-	{ 7907, 7907 },
-	{ 7909, 7909 },
-	{ 7911, 7911 },
-	{ 7913, 7913 },
-	{ 7915, 7915 },
-	{ 7917, 7917 },
-	{ 7919, 7919 },
-	{ 7921, 7921 },
-	{ 7923, 7923 },
-	{ 7925, 7925 },
-	{ 7927, 7927 },
-	{ 7929, 7929 },
-	{ 7931, 7931 },
-	{ 7933, 7933 },
-	{ 7935, 7943 },
-	{ 7952, 7957 },
-	{ 7968, 7975 },
-	{ 7984, 7991 },
-	{ 8000, 8005 },
-	{ 8016, 8023 },
-	{ 8032, 8039 },
-	{ 8048, 8061 },
-	{ 8064, 8071 },
-	{ 8080, 8087 },
-	{ 8096, 8103 },
-	{ 8112, 8116 },
-	{ 8118, 8119 },
-	{ 8126, 8126 },
-	{ 8130, 8132 },
-	{ 8134, 8135 },
-	{ 8144, 8147 },
-	{ 8150, 8151 },
-	{ 8160, 8167 },
-	{ 8178, 8180 },
-	{ 8182, 8183 },
-	{ 8458, 8458 },
-	{ 8462, 8463 },
-	{ 8467, 8467 },
-	{ 8495, 8495 },
-	{ 8500, 8500 },
-	{ 8505, 8505 },
-	{ 8508, 8509 },
-	{ 8518, 8521 },
-	{ 8526, 8526 },
-	{ 8580, 8580 },
-	{ 11312, 11359 },
-	{ 11361, 11361 },
-	{ 11365, 11366 },
-	{ 11368, 11368 },
-	{ 11370, 11370 },
-	{ 11372, 11372 },
-	{ 11377, 11377 },
-	{ 11379, 11380 },
-	{ 11382, 11387 },
-	{ 11393, 11393 },
-	{ 11395, 11395 },
-	{ 11397, 11397 },
-	{ 11399, 11399 },
-	{ 11401, 11401 },
-	{ 11403, 11403 },
-	{ 11405, 11405 },
-	{ 11407, 11407 },
-	{ 11409, 11409 },
-	{ 11411, 11411 },
-	{ 11413, 11413 },
-	{ 11415, 11415 },
-	{ 11417, 11417 },
-	{ 11419, 11419 },
-	{ 11421, 11421 },
-	{ 11423, 11423 },
-	{ 11425, 11425 },
-	{ 11427, 11427 },
-	{ 11429, 11429 },
-	{ 11431, 11431 },
-	{ 11433, 11433 },
-	{ 11435, 11435 },
-	{ 11437, 11437 },
-	{ 11439, 11439 },
-	{ 11441, 11441 },
-	{ 11443, 11443 },
-	{ 11445, 11445 },
-	{ 11447, 11447 },
-	{ 11449, 11449 },
-	{ 11451, 11451 },
-	{ 11453, 11453 },
-	{ 11455, 11455 },
-	{ 11457, 11457 },
-	{ 11459, 11459 },
-	{ 11461, 11461 },
-	{ 11463, 11463 },
-	{ 11465, 11465 },
-	{ 11467, 11467 },
-	{ 11469, 11469 },
-	{ 11471, 11471 },
-	{ 11473, 11473 },
-	{ 11475, 11475 },
-	{ 11477, 11477 },
-	{ 11479, 11479 },
-	{ 11481, 11481 },
-	{ 11483, 11483 },
-	{ 11485, 11485 },
-	{ 11487, 11487 },
-	{ 11489, 11489 },
-	{ 11491, 11492 },
-	{ 11500, 11500 },
-	{ 11502, 11502 },
-	{ 11507, 11507 },
-	{ 11520, 11557 },
-	{ 11559, 11559 },
-	{ 11565, 11565 },
-	{ 42561, 42561 },
-	{ 42563, 42563 },
-	{ 42565, 42565 },
-	{ 42567, 42567 },
-	{ 42569, 42569 },
-	{ 42571, 42571 },
-	{ 42573, 42573 },
-	{ 42575, 42575 },
-	{ 42577, 42577 },
-	{ 42579, 42579 },
-	{ 42581, 42581 },
-	{ 42583, 42583 },
-	{ 42585, 42585 },
-	{ 42587, 42587 },
-	{ 42589, 42589 },
-	{ 42591, 42591 },
-	{ 42593, 42593 },
-	{ 42595, 42595 },
-	{ 42597, 42597 },
-	{ 42599, 42599 },
-	{ 42601, 42601 },
-	{ 42603, 42603 },
-	{ 42605, 42605 },
-	{ 42625, 42625 },
-	{ 42627, 42627 },
-	{ 42629, 42629 },
-	{ 42631, 42631 },
-	{ 42633, 42633 },
-	{ 42635, 42635 },
-	{ 42637, 42637 },
-	{ 42639, 42639 },
-	{ 42641, 42641 },
-	{ 42643, 42643 },
-	{ 42645, 42645 },
-	{ 42647, 42647 },
-	{ 42649, 42649 },
-	{ 42651, 42651 },
-	{ 42787, 42787 },
-	{ 42789, 42789 },
-	{ 42791, 42791 },
-	{ 42793, 42793 },
-	{ 42795, 42795 },
-	{ 42797, 42797 },
-	{ 42799, 42801 },
-	{ 42803, 42803 },
-	{ 42805, 42805 },
-	{ 42807, 42807 },
-	{ 42809, 42809 },
-	{ 42811, 42811 },
-	{ 42813, 42813 },
-	{ 42815, 42815 },
-	{ 42817, 42817 },
-	{ 42819, 42819 },
-	{ 42821, 42821 },
-	{ 42823, 42823 },
-	{ 42825, 42825 },
-	{ 42827, 42827 },
-	{ 42829, 42829 },
-	{ 42831, 42831 },
-	{ 42833, 42833 },
-	{ 42835, 42835 },
-	{ 42837, 42837 },
-	{ 42839, 42839 },
-	{ 42841, 42841 },
-	{ 42843, 42843 },
-	{ 42845, 42845 },
-	{ 42847, 42847 },
-	{ 42849, 42849 },
-	{ 42851, 42851 },
-	{ 42853, 42853 },
-	{ 42855, 42855 },
-	{ 42857, 42857 },
-	{ 42859, 42859 },
-	{ 42861, 42861 },
-	{ 42863, 42863 },
-	{ 42865, 42872 },
-	{ 42874, 42874 },
-	{ 42876, 42876 },
-	{ 42879, 42879 },
-	{ 42881, 42881 },
-	{ 42883, 42883 },
-	{ 42885, 42885 },
-	{ 42887, 42887 },
-	{ 42892, 42892 },
-	{ 42894, 42894 },
-	{ 42897, 42897 },
-	{ 42899, 42901 },
-	{ 42903, 42903 },
-	{ 42905, 42905 },
-	{ 42907, 42907 },
-	{ 42909, 42909 },
-	{ 42911, 42911 },
-	{ 42913, 42913 },
-	{ 42915, 42915 },
-	{ 42917, 42917 },
-	{ 42919, 42919 },
-	{ 42921, 42921 },
-	{ 42927, 42927 },
-	{ 42933, 42933 },
-	{ 42935, 42935 },
-	{ 42937, 42937 },
-	{ 42939, 42939 },
-	{ 42941, 42941 },
-	{ 42943, 42943 },
-	{ 42945, 42945 },
-	{ 42947, 42947 },
-	{ 42952, 42952 },
-	{ 42954, 42954 },
-	{ 42961, 42961 },
-	{ 42963, 42963 },
-	{ 42965, 42965 },
-	{ 42967, 42967 },
-	{ 42969, 42969 },
-	{ 42998, 42998 },
-	{ 43002, 43002 },
-	{ 43824, 43866 },
-	{ 43872, 43880 },
-	{ 43888, 43967 },
-	{ 64256, 64262 },
-	{ 64275, 64279 },
-	{ 65345, 65370 },
-};
-static const URange32 Ll_range32[] = {
-	{ 66600, 66639 },
-	{ 66776, 66811 },
-	{ 66967, 66977 },
-	{ 66979, 66993 },
-	{ 66995, 67001 },
-	{ 67003, 67004 },
-	{ 68800, 68850 },
-	{ 71872, 71903 },
-	{ 93792, 93823 },
-	{ 119834, 119859 },
-	{ 119886, 119892 },
-	{ 119894, 119911 },
-	{ 119938, 119963 },
-	{ 119990, 119993 },
-	{ 119995, 119995 },
-	{ 119997, 120003 },
-	{ 120005, 120015 },
-	{ 120042, 120067 },
-	{ 120094, 120119 },
-	{ 120146, 120171 },
-	{ 120198, 120223 },
-	{ 120250, 120275 },
-	{ 120302, 120327 },
-	{ 120354, 120379 },
-	{ 120406, 120431 },
-	{ 120458, 120485 },
-	{ 120514, 120538 },
-	{ 120540, 120545 },
-	{ 120572, 120596 },
-	{ 120598, 120603 },
-	{ 120630, 120654 },
-	{ 120656, 120661 },
-	{ 120688, 120712 },
-	{ 120714, 120719 },
-	{ 120746, 120770 },
-	{ 120772, 120777 },
-	{ 120779, 120779 },
-	{ 122624, 122633 },
-	{ 122635, 122654 },
-	{ 122661, 122666 },
-	{ 125218, 125251 },
-};
-static const URange16 Lm_range16[] = {
-	{ 688, 705 },
-	{ 710, 721 },
-	{ 736, 740 },
-	{ 748, 748 },
-	{ 750, 750 },
-	{ 884, 884 },
-	{ 890, 890 },
-	{ 1369, 1369 },
-	{ 1600, 1600 },
-	{ 1765, 1766 },
-	{ 2036, 2037 },
-	{ 2042, 2042 },
-	{ 2074, 2074 },
-	{ 2084, 2084 },
-	{ 2088, 2088 },
-	{ 2249, 2249 },
-	{ 2417, 2417 },
-	{ 3654, 3654 },
-	{ 3782, 3782 },
-	{ 4348, 4348 },
-	{ 6103, 6103 },
-	{ 6211, 6211 },
-	{ 6823, 6823 },
-	{ 7288, 7293 },
-	{ 7468, 7530 },
-	{ 7544, 7544 },
-	{ 7579, 7615 },
-	{ 8305, 8305 },
-	{ 8319, 8319 },
-	{ 8336, 8348 },
-	{ 11388, 11389 },
-	{ 11631, 11631 },
-	{ 11823, 11823 },
-	{ 12293, 12293 },
-	{ 12337, 12341 },
-	{ 12347, 12347 },
-	{ 12445, 12446 },
-	{ 12540, 12542 },
-	{ 40981, 40981 },
-	{ 42232, 42237 },
-	{ 42508, 42508 },
-	{ 42623, 42623 },
-	{ 42652, 42653 },
-	{ 42775, 42783 },
-	{ 42864, 42864 },
-	{ 42888, 42888 },
-	{ 42994, 42996 },
-	{ 43000, 43001 },
-	{ 43471, 43471 },
-	{ 43494, 43494 },
-	{ 43632, 43632 },
-	{ 43741, 43741 },
-	{ 43763, 43764 },
-	{ 43868, 43871 },
-	{ 43881, 43881 },
-	{ 65392, 65392 },
-	{ 65438, 65439 },
-};
-static const URange32 Lm_range32[] = {
-	{ 67456, 67461 },
-	{ 67463, 67504 },
-	{ 67506, 67514 },
-	{ 92992, 92995 },
-	{ 94099, 94111 },
-	{ 94176, 94177 },
-	{ 94179, 94179 },
-	{ 110576, 110579 },
-	{ 110581, 110587 },
-	{ 110589, 110590 },
-	{ 122928, 122989 },
-	{ 123191, 123197 },
-	{ 124139, 124139 },
-	{ 125259, 125259 },
-};
-static const URange16 Lo_range16[] = {
-	{ 170, 170 },
-	{ 186, 186 },
-	{ 443, 443 },
-	{ 448, 451 },
-	{ 660, 660 },
-	{ 1488, 1514 },
-	{ 1519, 1522 },
-	{ 1568, 1599 },
-	{ 1601, 1610 },
-	{ 1646, 1647 },
-	{ 1649, 1747 },
-	{ 1749, 1749 },
-	{ 1774, 1775 },
-	{ 1786, 1788 },
-	{ 1791, 1791 },
-	{ 1808, 1808 },
-	{ 1810, 1839 },
-	{ 1869, 1957 },
-	{ 1969, 1969 },
-	{ 1994, 2026 },
-	{ 2048, 2069 },
-	{ 2112, 2136 },
-	{ 2144, 2154 },
-	{ 2160, 2183 },
-	{ 2185, 2190 },
-	{ 2208, 2248 },
-	{ 2308, 2361 },
-	{ 2365, 2365 },
-	{ 2384, 2384 },
-	{ 2392, 2401 },
-	{ 2418, 2432 },
-	{ 2437, 2444 },
-	{ 2447, 2448 },
-	{ 2451, 2472 },
-	{ 2474, 2480 },
-	{ 2482, 2482 },
-	{ 2486, 2489 },
-	{ 2493, 2493 },
-	{ 2510, 2510 },
-	{ 2524, 2525 },
-	{ 2527, 2529 },
-	{ 2544, 2545 },
-	{ 2556, 2556 },
-	{ 2565, 2570 },
-	{ 2575, 2576 },
-	{ 2579, 2600 },
-	{ 2602, 2608 },
-	{ 2610, 2611 },
-	{ 2613, 2614 },
-	{ 2616, 2617 },
-	{ 2649, 2652 },
-	{ 2654, 2654 },
-	{ 2674, 2676 },
-	{ 2693, 2701 },
-	{ 2703, 2705 },
-	{ 2707, 2728 },
-	{ 2730, 2736 },
-	{ 2738, 2739 },
-	{ 2741, 2745 },
-	{ 2749, 2749 },
-	{ 2768, 2768 },
-	{ 2784, 2785 },
-	{ 2809, 2809 },
-	{ 2821, 2828 },
-	{ 2831, 2832 },
-	{ 2835, 2856 },
-	{ 2858, 2864 },
-	{ 2866, 2867 },
-	{ 2869, 2873 },
-	{ 2877, 2877 },
-	{ 2908, 2909 },
-	{ 2911, 2913 },
-	{ 2929, 2929 },
-	{ 2947, 2947 },
-	{ 2949, 2954 },
-	{ 2958, 2960 },
-	{ 2962, 2965 },
-	{ 2969, 2970 },
-	{ 2972, 2972 },
-	{ 2974, 2975 },
-	{ 2979, 2980 },
-	{ 2984, 2986 },
-	{ 2990, 3001 },
-	{ 3024, 3024 },
-	{ 3077, 3084 },
-	{ 3086, 3088 },
-	{ 3090, 3112 },
-	{ 3114, 3129 },
-	{ 3133, 3133 },
-	{ 3160, 3162 },
-	{ 3165, 3165 },
-	{ 3168, 3169 },
-	{ 3200, 3200 },
-	{ 3205, 3212 },
-	{ 3214, 3216 },
-	{ 3218, 3240 },
-	{ 3242, 3251 },
-	{ 3253, 3257 },
-	{ 3261, 3261 },
-	{ 3293, 3294 },
-	{ 3296, 3297 },
-	{ 3313, 3314 },
-	{ 3332, 3340 },
-	{ 3342, 3344 },
-	{ 3346, 3386 },
-	{ 3389, 3389 },
-	{ 3406, 3406 },
-	{ 3412, 3414 },
-	{ 3423, 3425 },
-	{ 3450, 3455 },
-	{ 3461, 3478 },
-	{ 3482, 3505 },
-	{ 3507, 3515 },
-	{ 3517, 3517 },
-	{ 3520, 3526 },
-	{ 3585, 3632 },
-	{ 3634, 3635 },
-	{ 3648, 3653 },
-	{ 3713, 3714 },
-	{ 3716, 3716 },
-	{ 3718, 3722 },
-	{ 3724, 3747 },
-	{ 3749, 3749 },
-	{ 3751, 3760 },
-	{ 3762, 3763 },
-	{ 3773, 3773 },
-	{ 3776, 3780 },
-	{ 3804, 3807 },
-	{ 3840, 3840 },
-	{ 3904, 3911 },
-	{ 3913, 3948 },
-	{ 3976, 3980 },
-	{ 4096, 4138 },
-	{ 4159, 4159 },
-	{ 4176, 4181 },
-	{ 4186, 4189 },
-	{ 4193, 4193 },
-	{ 4197, 4198 },
-	{ 4206, 4208 },
-	{ 4213, 4225 },
-	{ 4238, 4238 },
-	{ 4352, 4680 },
-	{ 4682, 4685 },
-	{ 4688, 4694 },
-	{ 4696, 4696 },
-	{ 4698, 4701 },
-	{ 4704, 4744 },
-	{ 4746, 4749 },
-	{ 4752, 4784 },
-	{ 4786, 4789 },
-	{ 4792, 4798 },
-	{ 4800, 4800 },
-	{ 4802, 4805 },
-	{ 4808, 4822 },
-	{ 4824, 4880 },
-	{ 4882, 4885 },
-	{ 4888, 4954 },
-	{ 4992, 5007 },
-	{ 5121, 5740 },
-	{ 5743, 5759 },
-	{ 5761, 5786 },
-	{ 5792, 5866 },
-	{ 5873, 5880 },
-	{ 5888, 5905 },
-	{ 5919, 5937 },
-	{ 5952, 5969 },
-	{ 5984, 5996 },
-	{ 5998, 6000 },
-	{ 6016, 6067 },
-	{ 6108, 6108 },
-	{ 6176, 6210 },
-	{ 6212, 6264 },
-	{ 6272, 6276 },
-	{ 6279, 6312 },
-	{ 6314, 6314 },
-	{ 6320, 6389 },
-	{ 6400, 6430 },
-	{ 6480, 6509 },
-	{ 6512, 6516 },
-	{ 6528, 6571 },
-	{ 6576, 6601 },
-	{ 6656, 6678 },
-	{ 6688, 6740 },
-	{ 6917, 6963 },
-	{ 6981, 6988 },
-	{ 7043, 7072 },
-	{ 7086, 7087 },
-	{ 7098, 7141 },
-	{ 7168, 7203 },
-	{ 7245, 7247 },
-	{ 7258, 7287 },
-	{ 7401, 7404 },
-	{ 7406, 7411 },
-	{ 7413, 7414 },
-	{ 7418, 7418 },
-	{ 8501, 8504 },
-	{ 11568, 11623 },
-	{ 11648, 11670 },
-	{ 11680, 11686 },
-	{ 11688, 11694 },
-	{ 11696, 11702 },
-	{ 11704, 11710 },
-	{ 11712, 11718 },
-	{ 11720, 11726 },
-	{ 11728, 11734 },
-	{ 11736, 11742 },
-	{ 12294, 12294 },
-	{ 12348, 12348 },
-	{ 12353, 12438 },
-	{ 12447, 12447 },
-	{ 12449, 12538 },
-	{ 12543, 12543 },
-	{ 12549, 12591 },
-	{ 12593, 12686 },
-	{ 12704, 12735 },
-	{ 12784, 12799 },
-	{ 13312, 19903 },
-	{ 19968, 40980 },
-	{ 40982, 42124 },
-	{ 42192, 42231 },
-	{ 42240, 42507 },
-	{ 42512, 42527 },
-	{ 42538, 42539 },
-	{ 42606, 42606 },
-	{ 42656, 42725 },
-	{ 42895, 42895 },
-	{ 42999, 42999 },
-	{ 43003, 43009 },
-	{ 43011, 43013 },
-	{ 43015, 43018 },
-	{ 43020, 43042 },
-	{ 43072, 43123 },
-	{ 43138, 43187 },
-	{ 43250, 43255 },
-	{ 43259, 43259 },
-	{ 43261, 43262 },
-	{ 43274, 43301 },
-	{ 43312, 43334 },
-	{ 43360, 43388 },
-	{ 43396, 43442 },
-	{ 43488, 43492 },
-	{ 43495, 43503 },
-	{ 43514, 43518 },
-	{ 43520, 43560 },
-	{ 43584, 43586 },
-	{ 43588, 43595 },
-	{ 43616, 43631 },
-	{ 43633, 43638 },
-	{ 43642, 43642 },
-	{ 43646, 43695 },
-	{ 43697, 43697 },
-	{ 43701, 43702 },
-	{ 43705, 43709 },
-	{ 43712, 43712 },
-	{ 43714, 43714 },
-	{ 43739, 43740 },
-	{ 43744, 43754 },
-	{ 43762, 43762 },
-	{ 43777, 43782 },
-	{ 43785, 43790 },
-	{ 43793, 43798 },
-	{ 43808, 43814 },
-	{ 43816, 43822 },
-	{ 43968, 44002 },
-	{ 44032, 55203 },
-	{ 55216, 55238 },
-	{ 55243, 55291 },
-	{ 63744, 64109 },
-	{ 64112, 64217 },
-	{ 64285, 64285 },
-	{ 64287, 64296 },
-	{ 64298, 64310 },
-	{ 64312, 64316 },
-	{ 64318, 64318 },
-	{ 64320, 64321 },
-	{ 64323, 64324 },
-	{ 64326, 64433 },
-	{ 64467, 64829 },
-	{ 64848, 64911 },
-	{ 64914, 64967 },
-	{ 65008, 65019 },
-	{ 65136, 65140 },
-	{ 65142, 65276 },
-	{ 65382, 65391 },
-	{ 65393, 65437 },
-	{ 65440, 65470 },
-	{ 65474, 65479 },
-	{ 65482, 65487 },
-	{ 65490, 65495 },
-	{ 65498, 65500 },
-};
-static const URange32 Lo_range32[] = {
-	{ 65536, 65547 },
-	{ 65549, 65574 },
-	{ 65576, 65594 },
-	{ 65596, 65597 },
-	{ 65599, 65613 },
-	{ 65616, 65629 },
-	{ 65664, 65786 },
-	{ 66176, 66204 },
-	{ 66208, 66256 },
-	{ 66304, 66335 },
-	{ 66349, 66368 },
-	{ 66370, 66377 },
-	{ 66384, 66421 },
-	{ 66432, 66461 },
-	{ 66464, 66499 },
-	{ 66504, 66511 },
-	{ 66640, 66717 },
-	{ 66816, 66855 },
-	{ 66864, 66915 },
-	{ 67072, 67382 },
-	{ 67392, 67413 },
-	{ 67424, 67431 },
-	{ 67584, 67589 },
-	{ 67592, 67592 },
-	{ 67594, 67637 },
-	{ 67639, 67640 },
-	{ 67644, 67644 },
-	{ 67647, 67669 },
-	{ 67680, 67702 },
-	{ 67712, 67742 },
-	{ 67808, 67826 },
-	{ 67828, 67829 },
-	{ 67840, 67861 },
-	{ 67872, 67897 },
-	{ 67968, 68023 },
-	{ 68030, 68031 },
-	{ 68096, 68096 },
-	{ 68112, 68115 },
-	{ 68117, 68119 },
-	{ 68121, 68149 },
-	{ 68192, 68220 },
-	{ 68224, 68252 },
-	{ 68288, 68295 },
-	{ 68297, 68324 },
-	{ 68352, 68405 },
-	{ 68416, 68437 },
-	{ 68448, 68466 },
-	{ 68480, 68497 },
-	{ 68608, 68680 },
-	{ 68864, 68899 },
-	{ 69248, 69289 },
-	{ 69296, 69297 },
-	{ 69376, 69404 },
-	{ 69415, 69415 },
-	{ 69424, 69445 },
-	{ 69488, 69505 },
-	{ 69552, 69572 },
-	{ 69600, 69622 },
-	{ 69635, 69687 },
-	{ 69745, 69746 },
-	{ 69749, 69749 },
-	{ 69763, 69807 },
-	{ 69840, 69864 },
-	{ 69891, 69926 },
-	{ 69956, 69956 },
-	{ 69959, 69959 },
-	{ 69968, 70002 },
-	{ 70006, 70006 },
-	{ 70019, 70066 },
-	{ 70081, 70084 },
-	{ 70106, 70106 },
-	{ 70108, 70108 },
-	{ 70144, 70161 },
-	{ 70163, 70187 },
-	{ 70207, 70208 },
-	{ 70272, 70278 },
-	{ 70280, 70280 },
-	{ 70282, 70285 },
-	{ 70287, 70301 },
-	{ 70303, 70312 },
-	{ 70320, 70366 },
-	{ 70405, 70412 },
-	{ 70415, 70416 },
-	{ 70419, 70440 },
-	{ 70442, 70448 },
-	{ 70450, 70451 },
-	{ 70453, 70457 },
-	{ 70461, 70461 },
-	{ 70480, 70480 },
-	{ 70493, 70497 },
-	{ 70656, 70708 },
-	{ 70727, 70730 },
-	{ 70751, 70753 },
-	{ 70784, 70831 },
-	{ 70852, 70853 },
-	{ 70855, 70855 },
-	{ 71040, 71086 },
-	{ 71128, 71131 },
-	{ 71168, 71215 },
-	{ 71236, 71236 },
-	{ 71296, 71338 },
-	{ 71352, 71352 },
-	{ 71424, 71450 },
-	{ 71488, 71494 },
-	{ 71680, 71723 },
-	{ 71935, 71942 },
-	{ 71945, 71945 },
-	{ 71948, 71955 },
-	{ 71957, 71958 },
-	{ 71960, 71983 },
-	{ 71999, 71999 },
-	{ 72001, 72001 },
-	{ 72096, 72103 },
-	{ 72106, 72144 },
-	{ 72161, 72161 },
-	{ 72163, 72163 },
-	{ 72192, 72192 },
-	{ 72203, 72242 },
-	{ 72250, 72250 },
-	{ 72272, 72272 },
-	{ 72284, 72329 },
-	{ 72349, 72349 },
-	{ 72368, 72440 },
-	{ 72704, 72712 },
-	{ 72714, 72750 },
-	{ 72768, 72768 },
-	{ 72818, 72847 },
-	{ 72960, 72966 },
-	{ 72968, 72969 },
-	{ 72971, 73008 },
-	{ 73030, 73030 },
-	{ 73056, 73061 },
-	{ 73063, 73064 },
-	{ 73066, 73097 },
-	{ 73112, 73112 },
-	{ 73440, 73458 },
-	{ 73474, 73474 },
-	{ 73476, 73488 },
-	{ 73490, 73523 },
-	{ 73648, 73648 },
-	{ 73728, 74649 },
-	{ 74880, 75075 },
-	{ 77712, 77808 },
-	{ 77824, 78895 },
-	{ 78913, 78918 },
-	{ 82944, 83526 },
-	{ 92160, 92728 },
-	{ 92736, 92766 },
-	{ 92784, 92862 },
-	{ 92880, 92909 },
-	{ 92928, 92975 },
-	{ 93027, 93047 },
-	{ 93053, 93071 },
-	{ 93952, 94026 },
-	{ 94032, 94032 },
-	{ 94208, 100343 },
-	{ 100352, 101589 },
-	{ 101632, 101640 },
-	{ 110592, 110882 },
-	{ 110898, 110898 },
-	{ 110928, 110930 },
-	{ 110933, 110933 },
-	{ 110948, 110951 },
-	{ 110960, 111355 },
-	{ 113664, 113770 },
-	{ 113776, 113788 },
-	{ 113792, 113800 },
-	{ 113808, 113817 },
-	{ 122634, 122634 },
-	{ 123136, 123180 },
-	{ 123214, 123214 },
-	{ 123536, 123565 },
-	{ 123584, 123627 },
-	{ 124112, 124138 },
-	{ 124896, 124902 },
-	{ 124904, 124907 },
-	{ 124909, 124910 },
-	{ 124912, 124926 },
-	{ 124928, 125124 },
-	{ 126464, 126467 },
-	{ 126469, 126495 },
-	{ 126497, 126498 },
-	{ 126500, 126500 },
-	{ 126503, 126503 },
-	{ 126505, 126514 },
-	{ 126516, 126519 },
-	{ 126521, 126521 },
-	{ 126523, 126523 },
-	{ 126530, 126530 },
-	{ 126535, 126535 },
-	{ 126537, 126537 },
-	{ 126539, 126539 },
-	{ 126541, 126543 },
-	{ 126545, 126546 },
-	{ 126548, 126548 },
-	{ 126551, 126551 },
-	{ 126553, 126553 },
-	{ 126555, 126555 },
-	{ 126557, 126557 },
-	{ 126559, 126559 },
-	{ 126561, 126562 },
-	{ 126564, 126564 },
-	{ 126567, 126570 },
-	{ 126572, 126578 },
-	{ 126580, 126583 },
-	{ 126585, 126588 },
-	{ 126590, 126590 },
-	{ 126592, 126601 },
-	{ 126603, 126619 },
-	{ 126625, 126627 },
-	{ 126629, 126633 },
-	{ 126635, 126651 },
-	{ 131072, 173791 },
-	{ 173824, 177977 },
-	{ 177984, 178205 },
-	{ 178208, 183969 },
-	{ 183984, 191456 },
-	{ 194560, 195101 },
-	{ 196608, 201546 },
-	{ 201552, 205743 },
-};
-static const URange16 Lt_range16[] = {
-	{ 453, 453 },
-	{ 456, 456 },
-	{ 459, 459 },
-	{ 498, 498 },
-	{ 8072, 8079 },
-	{ 8088, 8095 },
-	{ 8104, 8111 },
-	{ 8124, 8124 },
-	{ 8140, 8140 },
-	{ 8188, 8188 },
-};
-static const URange16 Lu_range16[] = {
-	{ 65, 90 },
-	{ 192, 214 },
-	{ 216, 222 },
-	{ 256, 256 },
-	{ 258, 258 },
-	{ 260, 260 },
-	{ 262, 262 },
-	{ 264, 264 },
-	{ 266, 266 },
-	{ 268, 268 },
-	{ 270, 270 },
-	{ 272, 272 },
-	{ 274, 274 },
-	{ 276, 276 },
-	{ 278, 278 },
-	{ 280, 280 },
-	{ 282, 282 },
-	{ 284, 284 },
-	{ 286, 286 },
-	{ 288, 288 },
-	{ 290, 290 },
-	{ 292, 292 },
-	{ 294, 294 },
-	{ 296, 296 },
-	{ 298, 298 },
-	{ 300, 300 },
-	{ 302, 302 },
-	{ 304, 304 },
-	{ 306, 306 },
-	{ 308, 308 },
-	{ 310, 310 },
-	{ 313, 313 },
-	{ 315, 315 },
-	{ 317, 317 },
-	{ 319, 319 },
-	{ 321, 321 },
-	{ 323, 323 },
-	{ 325, 325 },
-	{ 327, 327 },
-	{ 330, 330 },
-	{ 332, 332 },
-	{ 334, 334 },
-	{ 336, 336 },
-	{ 338, 338 },
-	{ 340, 340 },
-	{ 342, 342 },
-	{ 344, 344 },
-	{ 346, 346 },
-	{ 348, 348 },
-	{ 350, 350 },
-	{ 352, 352 },
-	{ 354, 354 },
-	{ 356, 356 },
-	{ 358, 358 },
-	{ 360, 360 },
-	{ 362, 362 },
-	{ 364, 364 },
-	{ 366, 366 },
-	{ 368, 368 },
-	{ 370, 370 },
-	{ 372, 372 },
-	{ 374, 374 },
-	{ 376, 377 },
-	{ 379, 379 },
-	{ 381, 381 },
-	{ 385, 386 },
-	{ 388, 388 },
-	{ 390, 391 },
-	{ 393, 395 },
-	{ 398, 401 },
-	{ 403, 404 },
-	{ 406, 408 },
-	{ 412, 413 },
-	{ 415, 416 },
-	{ 418, 418 },
-	{ 420, 420 },
-	{ 422, 423 },
-	{ 425, 425 },
-	{ 428, 428 },
-	{ 430, 431 },
-	{ 433, 435 },
-	{ 437, 437 },
-	{ 439, 440 },
-	{ 444, 444 },
-	{ 452, 452 },
-	{ 455, 455 },
-	{ 458, 458 },
-	{ 461, 461 },
-	{ 463, 463 },
-	{ 465, 465 },
-	{ 467, 467 },
-	{ 469, 469 },
-	{ 471, 471 },
-	{ 473, 473 },
-	{ 475, 475 },
-	{ 478, 478 },
-	{ 480, 480 },
-	{ 482, 482 },
-	{ 484, 484 },
-	{ 486, 486 },
-	{ 488, 488 },
-	{ 490, 490 },
-	{ 492, 492 },
-	{ 494, 494 },
-	{ 497, 497 },
-	{ 500, 500 },
-	{ 502, 504 },
-	{ 506, 506 },
-	{ 508, 508 },
-	{ 510, 510 },
-	{ 512, 512 },
-	{ 514, 514 },
-	{ 516, 516 },
-	{ 518, 518 },
-	{ 520, 520 },
-	{ 522, 522 },
-	{ 524, 524 },
-	{ 526, 526 },
-	{ 528, 528 },
-	{ 530, 530 },
-	{ 532, 532 },
-	{ 534, 534 },
-	{ 536, 536 },
-	{ 538, 538 },
-	{ 540, 540 },
-	{ 542, 542 },
-	{ 544, 544 },
-	{ 546, 546 },
-	{ 548, 548 },
-	{ 550, 550 },
-	{ 552, 552 },
-	{ 554, 554 },
-	{ 556, 556 },
-	{ 558, 558 },
-	{ 560, 560 },
-	{ 562, 562 },
-	{ 570, 571 },
-	{ 573, 574 },
-	{ 577, 577 },
-	{ 579, 582 },
-	{ 584, 584 },
-	{ 586, 586 },
-	{ 588, 588 },
-	{ 590, 590 },
-	{ 880, 880 },
-	{ 882, 882 },
-	{ 886, 886 },
-	{ 895, 895 },
-	{ 902, 902 },
-	{ 904, 906 },
-	{ 908, 908 },
-	{ 910, 911 },
-	{ 913, 929 },
-	{ 931, 939 },
-	{ 975, 975 },
-	{ 978, 980 },
-	{ 984, 984 },
-	{ 986, 986 },
-	{ 988, 988 },
-	{ 990, 990 },
-	{ 992, 992 },
-	{ 994, 994 },
-	{ 996, 996 },
-	{ 998, 998 },
-	{ 1000, 1000 },
-	{ 1002, 1002 },
-	{ 1004, 1004 },
-	{ 1006, 1006 },
-	{ 1012, 1012 },
-	{ 1015, 1015 },
-	{ 1017, 1018 },
-	{ 1021, 1071 },
-	{ 1120, 1120 },
-	{ 1122, 1122 },
-	{ 1124, 1124 },
-	{ 1126, 1126 },
-	{ 1128, 1128 },
-	{ 1130, 1130 },
-	{ 1132, 1132 },
-	{ 1134, 1134 },
-	{ 1136, 1136 },
-	{ 1138, 1138 },
-	{ 1140, 1140 },
-	{ 1142, 1142 },
-	{ 1144, 1144 },
-	{ 1146, 1146 },
-	{ 1148, 1148 },
-	{ 1150, 1150 },
-	{ 1152, 1152 },
-	{ 1162, 1162 },
-	{ 1164, 1164 },
-	{ 1166, 1166 },
-	{ 1168, 1168 },
-	{ 1170, 1170 },
-	{ 1172, 1172 },
-	{ 1174, 1174 },
-	{ 1176, 1176 },
-	{ 1178, 1178 },
-	{ 1180, 1180 },
-	{ 1182, 1182 },
-	{ 1184, 1184 },
-	{ 1186, 1186 },
-	{ 1188, 1188 },
-	{ 1190, 1190 },
-	{ 1192, 1192 },
-	{ 1194, 1194 },
-	{ 1196, 1196 },
-	{ 1198, 1198 },
-	{ 1200, 1200 },
-	{ 1202, 1202 },
-	{ 1204, 1204 },
-	{ 1206, 1206 },
-	{ 1208, 1208 },
-	{ 1210, 1210 },
-	{ 1212, 1212 },
-	{ 1214, 1214 },
-	{ 1216, 1217 },
-	{ 1219, 1219 },
-	{ 1221, 1221 },
-	{ 1223, 1223 },
-	{ 1225, 1225 },
-	{ 1227, 1227 },
-	{ 1229, 1229 },
-	{ 1232, 1232 },
-	{ 1234, 1234 },
-	{ 1236, 1236 },
-	{ 1238, 1238 },
-	{ 1240, 1240 },
-	{ 1242, 1242 },
-	{ 1244, 1244 },
-	{ 1246, 1246 },
-	{ 1248, 1248 },
-	{ 1250, 1250 },
-	{ 1252, 1252 },
-	{ 1254, 1254 },
-	{ 1256, 1256 },
-	{ 1258, 1258 },
-	{ 1260, 1260 },
-	{ 1262, 1262 },
-	{ 1264, 1264 },
-	{ 1266, 1266 },
-	{ 1268, 1268 },
-	{ 1270, 1270 },
-	{ 1272, 1272 },
-	{ 1274, 1274 },
-	{ 1276, 1276 },
-	{ 1278, 1278 },
-	{ 1280, 1280 },
-	{ 1282, 1282 },
-	{ 1284, 1284 },
-	{ 1286, 1286 },
-	{ 1288, 1288 },
-	{ 1290, 1290 },
-	{ 1292, 1292 },
-	{ 1294, 1294 },
-	{ 1296, 1296 },
-	{ 1298, 1298 },
-	{ 1300, 1300 },
-	{ 1302, 1302 },
-	{ 1304, 1304 },
-	{ 1306, 1306 },
-	{ 1308, 1308 },
-	{ 1310, 1310 },
-	{ 1312, 1312 },
-	{ 1314, 1314 },
-	{ 1316, 1316 },
-	{ 1318, 1318 },
-	{ 1320, 1320 },
-	{ 1322, 1322 },
-	{ 1324, 1324 },
-	{ 1326, 1326 },
-	{ 1329, 1366 },
-	{ 4256, 4293 },
-	{ 4295, 4295 },
-	{ 4301, 4301 },
-	{ 5024, 5109 },
-	{ 7312, 7354 },
-	{ 7357, 7359 },
-	{ 7680, 7680 },
-	{ 7682, 7682 },
-	{ 7684, 7684 },
-	{ 7686, 7686 },
-	{ 7688, 7688 },
-	{ 7690, 7690 },
-	{ 7692, 7692 },
-	{ 7694, 7694 },
-	{ 7696, 7696 },
-	{ 7698, 7698 },
-	{ 7700, 7700 },
-	{ 7702, 7702 },
-	{ 7704, 7704 },
-	{ 7706, 7706 },
-	{ 7708, 7708 },
-	{ 7710, 7710 },
-	{ 7712, 7712 },
-	{ 7714, 7714 },
-	{ 7716, 7716 },
-	{ 7718, 7718 },
-	{ 7720, 7720 },
-	{ 7722, 7722 },
-	{ 7724, 7724 },
-	{ 7726, 7726 },
-	{ 7728, 7728 },
-	{ 7730, 7730 },
-	{ 7732, 7732 },
-	{ 7734, 7734 },
-	{ 7736, 7736 },
-	{ 7738, 7738 },
-	{ 7740, 7740 },
-	{ 7742, 7742 },
-	{ 7744, 7744 },
-	{ 7746, 7746 },
-	{ 7748, 7748 },
-	{ 7750, 7750 },
-	{ 7752, 7752 },
-	{ 7754, 7754 },
-	{ 7756, 7756 },
-	{ 7758, 7758 },
-	{ 7760, 7760 },
-	{ 7762, 7762 },
-	{ 7764, 7764 },
-	{ 7766, 7766 },
-	{ 7768, 7768 },
-	{ 7770, 7770 },
-	{ 7772, 7772 },
-	{ 7774, 7774 },
-	{ 7776, 7776 },
-	{ 7778, 7778 },
-	{ 7780, 7780 },
-	{ 7782, 7782 },
-	{ 7784, 7784 },
-	{ 7786, 7786 },
-	{ 7788, 7788 },
-	{ 7790, 7790 },
-	{ 7792, 7792 },
-	{ 7794, 7794 },
-	{ 7796, 7796 },
-	{ 7798, 7798 },
-	{ 7800, 7800 },
-	{ 7802, 7802 },
-	{ 7804, 7804 },
-	{ 7806, 7806 },
-	{ 7808, 7808 },
-	{ 7810, 7810 },
-	{ 7812, 7812 },
-	{ 7814, 7814 },
-	{ 7816, 7816 },
-	{ 7818, 7818 },
-	{ 7820, 7820 },
-	{ 7822, 7822 },
-	{ 7824, 7824 },
-	{ 7826, 7826 },
-	{ 7828, 7828 },
-	{ 7838, 7838 },
-	{ 7840, 7840 },
-	{ 7842, 7842 },
-	{ 7844, 7844 },
-	{ 7846, 7846 },
-	{ 7848, 7848 },
-	{ 7850, 7850 },
-	{ 7852, 7852 },
-	{ 7854, 7854 },
-	{ 7856, 7856 },
-	{ 7858, 7858 },
-	{ 7860, 7860 },
-	{ 7862, 7862 },
-	{ 7864, 7864 },
-	{ 7866, 7866 },
-	{ 7868, 7868 },
-	{ 7870, 7870 },
-	{ 7872, 7872 },
-	{ 7874, 7874 },
-	{ 7876, 7876 },
-	{ 7878, 7878 },
-	{ 7880, 7880 },
-	{ 7882, 7882 },
-	{ 7884, 7884 },
-	{ 7886, 7886 },
-	{ 7888, 7888 },
-	{ 7890, 7890 },
-	{ 7892, 7892 },
-	{ 7894, 7894 },
-	{ 7896, 7896 },
-	{ 7898, 7898 },
-	{ 7900, 7900 },
-	{ 7902, 7902 },
-	{ 7904, 7904 },
-	{ 7906, 7906 },
-	{ 7908, 7908 },
-	{ 7910, 7910 },
-	{ 7912, 7912 },
-	{ 7914, 7914 },
-	{ 7916, 7916 },
-	{ 7918, 7918 },
-	{ 7920, 7920 },
-	{ 7922, 7922 },
-	{ 7924, 7924 },
-	{ 7926, 7926 },
-	{ 7928, 7928 },
-	{ 7930, 7930 },
-	{ 7932, 7932 },
-	{ 7934, 7934 },
-	{ 7944, 7951 },
-	{ 7960, 7965 },
-	{ 7976, 7983 },
-	{ 7992, 7999 },
-	{ 8008, 8013 },
-	{ 8025, 8025 },
-	{ 8027, 8027 },
-	{ 8029, 8029 },
-	{ 8031, 8031 },
-	{ 8040, 8047 },
-	{ 8120, 8123 },
-	{ 8136, 8139 },
-	{ 8152, 8155 },
-	{ 8168, 8172 },
-	{ 8184, 8187 },
-	{ 8450, 8450 },
-	{ 8455, 8455 },
-	{ 8459, 8461 },
-	{ 8464, 8466 },
-	{ 8469, 8469 },
-	{ 8473, 8477 },
-	{ 8484, 8484 },
-	{ 8486, 8486 },
-	{ 8488, 8488 },
-	{ 8490, 8493 },
-	{ 8496, 8499 },
-	{ 8510, 8511 },
-	{ 8517, 8517 },
-	{ 8579, 8579 },
-	{ 11264, 11311 },
-	{ 11360, 11360 },
-	{ 11362, 11364 },
-	{ 11367, 11367 },
-	{ 11369, 11369 },
-	{ 11371, 11371 },
-	{ 11373, 11376 },
-	{ 11378, 11378 },
-	{ 11381, 11381 },
-	{ 11390, 11392 },
-	{ 11394, 11394 },
-	{ 11396, 11396 },
-	{ 11398, 11398 },
-	{ 11400, 11400 },
-	{ 11402, 11402 },
-	{ 11404, 11404 },
-	{ 11406, 11406 },
-	{ 11408, 11408 },
-	{ 11410, 11410 },
-	{ 11412, 11412 },
-	{ 11414, 11414 },
-	{ 11416, 11416 },
-	{ 11418, 11418 },
-	{ 11420, 11420 },
-	{ 11422, 11422 },
-	{ 11424, 11424 },
-	{ 11426, 11426 },
-	{ 11428, 11428 },
-	{ 11430, 11430 },
-	{ 11432, 11432 },
-	{ 11434, 11434 },
-	{ 11436, 11436 },
-	{ 11438, 11438 },
-	{ 11440, 11440 },
-	{ 11442, 11442 },
-	{ 11444, 11444 },
-	{ 11446, 11446 },
-	{ 11448, 11448 },
-	{ 11450, 11450 },
-	{ 11452, 11452 },
-	{ 11454, 11454 },
-	{ 11456, 11456 },
-	{ 11458, 11458 },
-	{ 11460, 11460 },
-	{ 11462, 11462 },
-	{ 11464, 11464 },
-	{ 11466, 11466 },
-	{ 11468, 11468 },
-	{ 11470, 11470 },
-	{ 11472, 11472 },
-	{ 11474, 11474 },
-	{ 11476, 11476 },
-	{ 11478, 11478 },
-	{ 11480, 11480 },
-	{ 11482, 11482 },
-	{ 11484, 11484 },
-	{ 11486, 11486 },
-	{ 11488, 11488 },
-	{ 11490, 11490 },
-	{ 11499, 11499 },
-	{ 11501, 11501 },
-	{ 11506, 11506 },
-	{ 42560, 42560 },
-	{ 42562, 42562 },
-	{ 42564, 42564 },
-	{ 42566, 42566 },
-	{ 42568, 42568 },
-	{ 42570, 42570 },
-	{ 42572, 42572 },
-	{ 42574, 42574 },
-	{ 42576, 42576 },
-	{ 42578, 42578 },
-	{ 42580, 42580 },
-	{ 42582, 42582 },
-	{ 42584, 42584 },
-	{ 42586, 42586 },
-	{ 42588, 42588 },
-	{ 42590, 42590 },
-	{ 42592, 42592 },
-	{ 42594, 42594 },
-	{ 42596, 42596 },
-	{ 42598, 42598 },
-	{ 42600, 42600 },
-	{ 42602, 42602 },
-	{ 42604, 42604 },
-	{ 42624, 42624 },
-	{ 42626, 42626 },
-	{ 42628, 42628 },
-	{ 42630, 42630 },
-	{ 42632, 42632 },
-	{ 42634, 42634 },
-	{ 42636, 42636 },
-	{ 42638, 42638 },
-	{ 42640, 42640 },
-	{ 42642, 42642 },
-	{ 42644, 42644 },
-	{ 42646, 42646 },
-	{ 42648, 42648 },
-	{ 42650, 42650 },
-	{ 42786, 42786 },
-	{ 42788, 42788 },
-	{ 42790, 42790 },
-	{ 42792, 42792 },
-	{ 42794, 42794 },
-	{ 42796, 42796 },
-	{ 42798, 42798 },
-	{ 42802, 42802 },
-	{ 42804, 42804 },
-	{ 42806, 42806 },
-	{ 42808, 42808 },
-	{ 42810, 42810 },
-	{ 42812, 42812 },
-	{ 42814, 42814 },
-	{ 42816, 42816 },
-	{ 42818, 42818 },
-	{ 42820, 42820 },
-	{ 42822, 42822 },
-	{ 42824, 42824 },
-	{ 42826, 42826 },
-	{ 42828, 42828 },
-	{ 42830, 42830 },
-	{ 42832, 42832 },
-	{ 42834, 42834 },
-	{ 42836, 42836 },
-	{ 42838, 42838 },
-	{ 42840, 42840 },
-	{ 42842, 42842 },
-	{ 42844, 42844 },
-	{ 42846, 42846 },
-	{ 42848, 42848 },
-	{ 42850, 42850 },
-	{ 42852, 42852 },
-	{ 42854, 42854 },
-	{ 42856, 42856 },
-	{ 42858, 42858 },
-	{ 42860, 42860 },
-	{ 42862, 42862 },
-	{ 42873, 42873 },
-	{ 42875, 42875 },
-	{ 42877, 42878 },
-	{ 42880, 42880 },
-	{ 42882, 42882 },
-	{ 42884, 42884 },
-	{ 42886, 42886 },
-	{ 42891, 42891 },
-	{ 42893, 42893 },
-	{ 42896, 42896 },
-	{ 42898, 42898 },
-	{ 42902, 42902 },
-	{ 42904, 42904 },
-	{ 42906, 42906 },
-	{ 42908, 42908 },
-	{ 42910, 42910 },
-	{ 42912, 42912 },
-	{ 42914, 42914 },
-	{ 42916, 42916 },
-	{ 42918, 42918 },
-	{ 42920, 42920 },
-	{ 42922, 42926 },
-	{ 42928, 42932 },
-	{ 42934, 42934 },
-	{ 42936, 42936 },
-	{ 42938, 42938 },
-	{ 42940, 42940 },
-	{ 42942, 42942 },
-	{ 42944, 42944 },
-	{ 42946, 42946 },
-	{ 42948, 42951 },
-	{ 42953, 42953 },
-	{ 42960, 42960 },
-	{ 42966, 42966 },
-	{ 42968, 42968 },
-	{ 42997, 42997 },
-	{ 65313, 65338 },
-};
-static const URange32 Lu_range32[] = {
-	{ 66560, 66599 },
-	{ 66736, 66771 },
-	{ 66928, 66938 },
-	{ 66940, 66954 },
-	{ 66956, 66962 },
-	{ 66964, 66965 },
-	{ 68736, 68786 },
-	{ 71840, 71871 },
-	{ 93760, 93791 },
-	{ 119808, 119833 },
-	{ 119860, 119885 },
-	{ 119912, 119937 },
-	{ 119964, 119964 },
-	{ 119966, 119967 },
-	{ 119970, 119970 },
-	{ 119973, 119974 },
-	{ 119977, 119980 },
-	{ 119982, 119989 },
-	{ 120016, 120041 },
-	{ 120068, 120069 },
-	{ 120071, 120074 },
-	{ 120077, 120084 },
-	{ 120086, 120092 },
-	{ 120120, 120121 },
-	{ 120123, 120126 },
-	{ 120128, 120132 },
-	{ 120134, 120134 },
-	{ 120138, 120144 },
-	{ 120172, 120197 },
-	{ 120224, 120249 },
-	{ 120276, 120301 },
-	{ 120328, 120353 },
-	{ 120380, 120405 },
-	{ 120432, 120457 },
-	{ 120488, 120512 },
-	{ 120546, 120570 },
-	{ 120604, 120628 },
-	{ 120662, 120686 },
-	{ 120720, 120744 },
-	{ 120778, 120778 },
-	{ 125184, 125217 },
-};
-static const URange16 M_range16[] = {
-	{ 768, 879 },
-	{ 1155, 1161 },
-	{ 1425, 1469 },
-	{ 1471, 1471 },
-	{ 1473, 1474 },
-	{ 1476, 1477 },
-	{ 1479, 1479 },
-	{ 1552, 1562 },
-	{ 1611, 1631 },
-	{ 1648, 1648 },
-	{ 1750, 1756 },
-	{ 1759, 1764 },
-	{ 1767, 1768 },
-	{ 1770, 1773 },
-	{ 1809, 1809 },
-	{ 1840, 1866 },
-	{ 1958, 1968 },
-	{ 2027, 2035 },
-	{ 2045, 2045 },
-	{ 2070, 2073 },
-	{ 2075, 2083 },
-	{ 2085, 2087 },
-	{ 2089, 2093 },
-	{ 2137, 2139 },
-	{ 2200, 2207 },
-	{ 2250, 2273 },
-	{ 2275, 2307 },
-	{ 2362, 2364 },
-	{ 2366, 2383 },
-	{ 2385, 2391 },
-	{ 2402, 2403 },
-	{ 2433, 2435 },
-	{ 2492, 2492 },
-	{ 2494, 2500 },
-	{ 2503, 2504 },
-	{ 2507, 2509 },
-	{ 2519, 2519 },
-	{ 2530, 2531 },
-	{ 2558, 2558 },
-	{ 2561, 2563 },
-	{ 2620, 2620 },
-	{ 2622, 2626 },
-	{ 2631, 2632 },
-	{ 2635, 2637 },
-	{ 2641, 2641 },
-	{ 2672, 2673 },
-	{ 2677, 2677 },
-	{ 2689, 2691 },
-	{ 2748, 2748 },
-	{ 2750, 2757 },
-	{ 2759, 2761 },
-	{ 2763, 2765 },
-	{ 2786, 2787 },
-	{ 2810, 2815 },
-	{ 2817, 2819 },
-	{ 2876, 2876 },
-	{ 2878, 2884 },
-	{ 2887, 2888 },
-	{ 2891, 2893 },
-	{ 2901, 2903 },
-	{ 2914, 2915 },
-	{ 2946, 2946 },
-	{ 3006, 3010 },
-	{ 3014, 3016 },
-	{ 3018, 3021 },
-	{ 3031, 3031 },
-	{ 3072, 3076 },
-	{ 3132, 3132 },
-	{ 3134, 3140 },
-	{ 3142, 3144 },
-	{ 3146, 3149 },
-	{ 3157, 3158 },
-	{ 3170, 3171 },
-	{ 3201, 3203 },
-	{ 3260, 3260 },
-	{ 3262, 3268 },
-	{ 3270, 3272 },
-	{ 3274, 3277 },
-	{ 3285, 3286 },
-	{ 3298, 3299 },
-	{ 3315, 3315 },
-	{ 3328, 3331 },
-	{ 3387, 3388 },
-	{ 3390, 3396 },
-	{ 3398, 3400 },
-	{ 3402, 3405 },
-	{ 3415, 3415 },
-	{ 3426, 3427 },
-	{ 3457, 3459 },
-	{ 3530, 3530 },
-	{ 3535, 3540 },
-	{ 3542, 3542 },
-	{ 3544, 3551 },
-	{ 3570, 3571 },
-	{ 3633, 3633 },
-	{ 3636, 3642 },
-	{ 3655, 3662 },
-	{ 3761, 3761 },
-	{ 3764, 3772 },
-	{ 3784, 3790 },
-	{ 3864, 3865 },
-	{ 3893, 3893 },
-	{ 3895, 3895 },
-	{ 3897, 3897 },
-	{ 3902, 3903 },
-	{ 3953, 3972 },
-	{ 3974, 3975 },
-	{ 3981, 3991 },
-	{ 3993, 4028 },
-	{ 4038, 4038 },
-	{ 4139, 4158 },
-	{ 4182, 4185 },
-	{ 4190, 4192 },
-	{ 4194, 4196 },
-	{ 4199, 4205 },
-	{ 4209, 4212 },
-	{ 4226, 4237 },
-	{ 4239, 4239 },
-	{ 4250, 4253 },
-	{ 4957, 4959 },
-	{ 5906, 5909 },
-	{ 5938, 5940 },
-	{ 5970, 5971 },
-	{ 6002, 6003 },
-	{ 6068, 6099 },
-	{ 6109, 6109 },
-	{ 6155, 6157 },
-	{ 6159, 6159 },
-	{ 6277, 6278 },
-	{ 6313, 6313 },
-	{ 6432, 6443 },
-	{ 6448, 6459 },
-	{ 6679, 6683 },
-	{ 6741, 6750 },
-	{ 6752, 6780 },
-	{ 6783, 6783 },
-	{ 6832, 6862 },
-	{ 6912, 6916 },
-	{ 6964, 6980 },
-	{ 7019, 7027 },
-	{ 7040, 7042 },
-	{ 7073, 7085 },
-	{ 7142, 7155 },
-	{ 7204, 7223 },
-	{ 7376, 7378 },
-	{ 7380, 7400 },
-	{ 7405, 7405 },
-	{ 7412, 7412 },
-	{ 7415, 7417 },
-	{ 7616, 7679 },
-	{ 8400, 8432 },
-	{ 11503, 11505 },
-	{ 11647, 11647 },
-	{ 11744, 11775 },
-	{ 12330, 12335 },
-	{ 12441, 12442 },
-	{ 42607, 42610 },
-	{ 42612, 42621 },
-	{ 42654, 42655 },
-	{ 42736, 42737 },
-	{ 43010, 43010 },
-	{ 43014, 43014 },
-	{ 43019, 43019 },
-	{ 43043, 43047 },
-	{ 43052, 43052 },
-	{ 43136, 43137 },
-	{ 43188, 43205 },
-	{ 43232, 43249 },
-	{ 43263, 43263 },
-	{ 43302, 43309 },
-	{ 43335, 43347 },
-	{ 43392, 43395 },
-	{ 43443, 43456 },
-	{ 43493, 43493 },
-	{ 43561, 43574 },
-	{ 43587, 43587 },
-	{ 43596, 43597 },
-	{ 43643, 43645 },
-	{ 43696, 43696 },
-	{ 43698, 43700 },
-	{ 43703, 43704 },
-	{ 43710, 43711 },
-	{ 43713, 43713 },
-	{ 43755, 43759 },
-	{ 43765, 43766 },
-	{ 44003, 44010 },
-	{ 44012, 44013 },
-	{ 64286, 64286 },
-	{ 65024, 65039 },
-	{ 65056, 65071 },
-};
-static const URange32 M_range32[] = {
-	{ 66045, 66045 },
-	{ 66272, 66272 },
-	{ 66422, 66426 },
-	{ 68097, 68099 },
-	{ 68101, 68102 },
-	{ 68108, 68111 },
-	{ 68152, 68154 },
-	{ 68159, 68159 },
-	{ 68325, 68326 },
-	{ 68900, 68903 },
-	{ 69291, 69292 },
-	{ 69373, 69375 },
-	{ 69446, 69456 },
-	{ 69506, 69509 },
-	{ 69632, 69634 },
-	{ 69688, 69702 },
-	{ 69744, 69744 },
-	{ 69747, 69748 },
-	{ 69759, 69762 },
-	{ 69808, 69818 },
-	{ 69826, 69826 },
-	{ 69888, 69890 },
-	{ 69927, 69940 },
-	{ 69957, 69958 },
-	{ 70003, 70003 },
-	{ 70016, 70018 },
-	{ 70067, 70080 },
-	{ 70089, 70092 },
-	{ 70094, 70095 },
-	{ 70188, 70199 },
-	{ 70206, 70206 },
-	{ 70209, 70209 },
-	{ 70367, 70378 },
-	{ 70400, 70403 },
-	{ 70459, 70460 },
-	{ 70462, 70468 },
-	{ 70471, 70472 },
-	{ 70475, 70477 },
-	{ 70487, 70487 },
-	{ 70498, 70499 },
-	{ 70502, 70508 },
-	{ 70512, 70516 },
-	{ 70709, 70726 },
-	{ 70750, 70750 },
-	{ 70832, 70851 },
-	{ 71087, 71093 },
-	{ 71096, 71104 },
-	{ 71132, 71133 },
-	{ 71216, 71232 },
-	{ 71339, 71351 },
-	{ 71453, 71467 },
-	{ 71724, 71738 },
-	{ 71984, 71989 },
-	{ 71991, 71992 },
-	{ 71995, 71998 },
-	{ 72000, 72000 },
-	{ 72002, 72003 },
-	{ 72145, 72151 },
-	{ 72154, 72160 },
-	{ 72164, 72164 },
-	{ 72193, 72202 },
-	{ 72243, 72249 },
-	{ 72251, 72254 },
-	{ 72263, 72263 },
-	{ 72273, 72283 },
-	{ 72330, 72345 },
-	{ 72751, 72758 },
-	{ 72760, 72767 },
-	{ 72850, 72871 },
-	{ 72873, 72886 },
-	{ 73009, 73014 },
-	{ 73018, 73018 },
-	{ 73020, 73021 },
-	{ 73023, 73029 },
-	{ 73031, 73031 },
-	{ 73098, 73102 },
-	{ 73104, 73105 },
-	{ 73107, 73111 },
-	{ 73459, 73462 },
-	{ 73472, 73473 },
-	{ 73475, 73475 },
-	{ 73524, 73530 },
-	{ 73534, 73538 },
-	{ 78912, 78912 },
-	{ 78919, 78933 },
-	{ 92912, 92916 },
-	{ 92976, 92982 },
-	{ 94031, 94031 },
-	{ 94033, 94087 },
-	{ 94095, 94098 },
-	{ 94180, 94180 },
-	{ 94192, 94193 },
-	{ 113821, 113822 },
-	{ 118528, 118573 },
-	{ 118576, 118598 },
-	{ 119141, 119145 },
-	{ 119149, 119154 },
-	{ 119163, 119170 },
-	{ 119173, 119179 },
-	{ 119210, 119213 },
-	{ 119362, 119364 },
-	{ 121344, 121398 },
-	{ 121403, 121452 },
-	{ 121461, 121461 },
-	{ 121476, 121476 },
-	{ 121499, 121503 },
-	{ 121505, 121519 },
-	{ 122880, 122886 },
-	{ 122888, 122904 },
-	{ 122907, 122913 },
-	{ 122915, 122916 },
-	{ 122918, 122922 },
-	{ 123023, 123023 },
-	{ 123184, 123190 },
-	{ 123566, 123566 },
-	{ 123628, 123631 },
-	{ 124140, 124143 },
-	{ 125136, 125142 },
-	{ 125252, 125258 },
-	{ 917760, 917999 },
-};
-static const URange16 Mc_range16[] = {
-	{ 2307, 2307 },
-	{ 2363, 2363 },
-	{ 2366, 2368 },
-	{ 2377, 2380 },
-	{ 2382, 2383 },
-	{ 2434, 2435 },
-	{ 2494, 2496 },
-	{ 2503, 2504 },
-	{ 2507, 2508 },
-	{ 2519, 2519 },
-	{ 2563, 2563 },
-	{ 2622, 2624 },
-	{ 2691, 2691 },
-	{ 2750, 2752 },
-	{ 2761, 2761 },
-	{ 2763, 2764 },
-	{ 2818, 2819 },
-	{ 2878, 2878 },
-	{ 2880, 2880 },
-	{ 2887, 2888 },
-	{ 2891, 2892 },
-	{ 2903, 2903 },
-	{ 3006, 3007 },
-	{ 3009, 3010 },
-	{ 3014, 3016 },
-	{ 3018, 3020 },
-	{ 3031, 3031 },
-	{ 3073, 3075 },
-	{ 3137, 3140 },
-	{ 3202, 3203 },
-	{ 3262, 3262 },
-	{ 3264, 3268 },
-	{ 3271, 3272 },
-	{ 3274, 3275 },
-	{ 3285, 3286 },
-	{ 3315, 3315 },
-	{ 3330, 3331 },
-	{ 3390, 3392 },
-	{ 3398, 3400 },
-	{ 3402, 3404 },
-	{ 3415, 3415 },
-	{ 3458, 3459 },
-	{ 3535, 3537 },
-	{ 3544, 3551 },
-	{ 3570, 3571 },
-	{ 3902, 3903 },
-	{ 3967, 3967 },
-	{ 4139, 4140 },
-	{ 4145, 4145 },
-	{ 4152, 4152 },
-	{ 4155, 4156 },
-	{ 4182, 4183 },
-	{ 4194, 4196 },
-	{ 4199, 4205 },
-	{ 4227, 4228 },
-	{ 4231, 4236 },
-	{ 4239, 4239 },
-	{ 4250, 4252 },
-	{ 5909, 5909 },
-	{ 5940, 5940 },
-	{ 6070, 6070 },
-	{ 6078, 6085 },
-	{ 6087, 6088 },
-	{ 6435, 6438 },
-	{ 6441, 6443 },
-	{ 6448, 6449 },
-	{ 6451, 6456 },
-	{ 6681, 6682 },
-	{ 6741, 6741 },
-	{ 6743, 6743 },
-	{ 6753, 6753 },
-	{ 6755, 6756 },
-	{ 6765, 6770 },
-	{ 6916, 6916 },
-	{ 6965, 6965 },
-	{ 6971, 6971 },
-	{ 6973, 6977 },
-	{ 6979, 6980 },
-	{ 7042, 7042 },
-	{ 7073, 7073 },
-	{ 7078, 7079 },
-	{ 7082, 7082 },
-	{ 7143, 7143 },
-	{ 7146, 7148 },
-	{ 7150, 7150 },
-	{ 7154, 7155 },
-	{ 7204, 7211 },
-	{ 7220, 7221 },
-	{ 7393, 7393 },
-	{ 7415, 7415 },
-	{ 12334, 12335 },
-	{ 43043, 43044 },
-	{ 43047, 43047 },
-	{ 43136, 43137 },
-	{ 43188, 43203 },
-	{ 43346, 43347 },
-	{ 43395, 43395 },
-	{ 43444, 43445 },
-	{ 43450, 43451 },
-	{ 43454, 43456 },
-	{ 43567, 43568 },
-	{ 43571, 43572 },
-	{ 43597, 43597 },
-	{ 43643, 43643 },
-	{ 43645, 43645 },
-	{ 43755, 43755 },
-	{ 43758, 43759 },
-	{ 43765, 43765 },
-	{ 44003, 44004 },
-	{ 44006, 44007 },
-	{ 44009, 44010 },
-	{ 44012, 44012 },
-};
-static const URange32 Mc_range32[] = {
-	{ 69632, 69632 },
-	{ 69634, 69634 },
-	{ 69762, 69762 },
-	{ 69808, 69810 },
-	{ 69815, 69816 },
-	{ 69932, 69932 },
-	{ 69957, 69958 },
-	{ 70018, 70018 },
-	{ 70067, 70069 },
-	{ 70079, 70080 },
-	{ 70094, 70094 },
-	{ 70188, 70190 },
-	{ 70194, 70195 },
-	{ 70197, 70197 },
-	{ 70368, 70370 },
-	{ 70402, 70403 },
-	{ 70462, 70463 },
-	{ 70465, 70468 },
-	{ 70471, 70472 },
-	{ 70475, 70477 },
-	{ 70487, 70487 },
-	{ 70498, 70499 },
-	{ 70709, 70711 },
-	{ 70720, 70721 },
-	{ 70725, 70725 },
-	{ 70832, 70834 },
-	{ 70841, 70841 },
-	{ 70843, 70846 },
-	{ 70849, 70849 },
-	{ 71087, 71089 },
-	{ 71096, 71099 },
-	{ 71102, 71102 },
-	{ 71216, 71218 },
-	{ 71227, 71228 },
-	{ 71230, 71230 },
-	{ 71340, 71340 },
-	{ 71342, 71343 },
-	{ 71350, 71350 },
-	{ 71456, 71457 },
-	{ 71462, 71462 },
-	{ 71724, 71726 },
-	{ 71736, 71736 },
-	{ 71984, 71989 },
-	{ 71991, 71992 },
-	{ 71997, 71997 },
-	{ 72000, 72000 },
-	{ 72002, 72002 },
-	{ 72145, 72147 },
-	{ 72156, 72159 },
-	{ 72164, 72164 },
-	{ 72249, 72249 },
-	{ 72279, 72280 },
-	{ 72343, 72343 },
-	{ 72751, 72751 },
-	{ 72766, 72766 },
-	{ 72873, 72873 },
-	{ 72881, 72881 },
-	{ 72884, 72884 },
-	{ 73098, 73102 },
-	{ 73107, 73108 },
-	{ 73110, 73110 },
-	{ 73461, 73462 },
-	{ 73475, 73475 },
-	{ 73524, 73525 },
-	{ 73534, 73535 },
-	{ 73537, 73537 },
-	{ 94033, 94087 },
-	{ 94192, 94193 },
-	{ 119141, 119142 },
-	{ 119149, 119154 },
-};
-static const URange16 Me_range16[] = {
-	{ 1160, 1161 },
-	{ 6846, 6846 },
-	{ 8413, 8416 },
-	{ 8418, 8420 },
-	{ 42608, 42610 },
-};
-static const URange16 Mn_range16[] = {
-	{ 768, 879 },
-	{ 1155, 1159 },
-	{ 1425, 1469 },
-	{ 1471, 1471 },
-	{ 1473, 1474 },
-	{ 1476, 1477 },
-	{ 1479, 1479 },
-	{ 1552, 1562 },
-	{ 1611, 1631 },
-	{ 1648, 1648 },
-	{ 1750, 1756 },
-	{ 1759, 1764 },
-	{ 1767, 1768 },
-	{ 1770, 1773 },
-	{ 1809, 1809 },
-	{ 1840, 1866 },
-	{ 1958, 1968 },
-	{ 2027, 2035 },
-	{ 2045, 2045 },
-	{ 2070, 2073 },
-	{ 2075, 2083 },
-	{ 2085, 2087 },
-	{ 2089, 2093 },
-	{ 2137, 2139 },
-	{ 2200, 2207 },
-	{ 2250, 2273 },
-	{ 2275, 2306 },
-	{ 2362, 2362 },
-	{ 2364, 2364 },
-	{ 2369, 2376 },
-	{ 2381, 2381 },
-	{ 2385, 2391 },
-	{ 2402, 2403 },
-	{ 2433, 2433 },
-	{ 2492, 2492 },
-	{ 2497, 2500 },
-	{ 2509, 2509 },
-	{ 2530, 2531 },
-	{ 2558, 2558 },
-	{ 2561, 2562 },
-	{ 2620, 2620 },
-	{ 2625, 2626 },
-	{ 2631, 2632 },
-	{ 2635, 2637 },
-	{ 2641, 2641 },
-	{ 2672, 2673 },
-	{ 2677, 2677 },
-	{ 2689, 2690 },
-	{ 2748, 2748 },
-	{ 2753, 2757 },
-	{ 2759, 2760 },
-	{ 2765, 2765 },
-	{ 2786, 2787 },
-	{ 2810, 2815 },
-	{ 2817, 2817 },
-	{ 2876, 2876 },
-	{ 2879, 2879 },
-	{ 2881, 2884 },
-	{ 2893, 2893 },
-	{ 2901, 2902 },
-	{ 2914, 2915 },
-	{ 2946, 2946 },
-	{ 3008, 3008 },
-	{ 3021, 3021 },
-	{ 3072, 3072 },
-	{ 3076, 3076 },
-	{ 3132, 3132 },
-	{ 3134, 3136 },
-	{ 3142, 3144 },
-	{ 3146, 3149 },
-	{ 3157, 3158 },
-	{ 3170, 3171 },
-	{ 3201, 3201 },
-	{ 3260, 3260 },
-	{ 3263, 3263 },
-	{ 3270, 3270 },
-	{ 3276, 3277 },
-	{ 3298, 3299 },
-	{ 3328, 3329 },
-	{ 3387, 3388 },
-	{ 3393, 3396 },
-	{ 3405, 3405 },
-	{ 3426, 3427 },
-	{ 3457, 3457 },
-	{ 3530, 3530 },
-	{ 3538, 3540 },
-	{ 3542, 3542 },
-	{ 3633, 3633 },
-	{ 3636, 3642 },
-	{ 3655, 3662 },
-	{ 3761, 3761 },
-	{ 3764, 3772 },
-	{ 3784, 3790 },
-	{ 3864, 3865 },
-	{ 3893, 3893 },
-	{ 3895, 3895 },
-	{ 3897, 3897 },
-	{ 3953, 3966 },
-	{ 3968, 3972 },
-	{ 3974, 3975 },
-	{ 3981, 3991 },
-	{ 3993, 4028 },
-	{ 4038, 4038 },
-	{ 4141, 4144 },
-	{ 4146, 4151 },
-	{ 4153, 4154 },
-	{ 4157, 4158 },
-	{ 4184, 4185 },
-	{ 4190, 4192 },
-	{ 4209, 4212 },
-	{ 4226, 4226 },
-	{ 4229, 4230 },
-	{ 4237, 4237 },
-	{ 4253, 4253 },
-	{ 4957, 4959 },
-	{ 5906, 5908 },
-	{ 5938, 5939 },
-	{ 5970, 5971 },
-	{ 6002, 6003 },
-	{ 6068, 6069 },
-	{ 6071, 6077 },
-	{ 6086, 6086 },
-	{ 6089, 6099 },
-	{ 6109, 6109 },
-	{ 6155, 6157 },
-	{ 6159, 6159 },
-	{ 6277, 6278 },
-	{ 6313, 6313 },
-	{ 6432, 6434 },
-	{ 6439, 6440 },
-	{ 6450, 6450 },
-	{ 6457, 6459 },
-	{ 6679, 6680 },
-	{ 6683, 6683 },
-	{ 6742, 6742 },
-	{ 6744, 6750 },
-	{ 6752, 6752 },
-	{ 6754, 6754 },
-	{ 6757, 6764 },
-	{ 6771, 6780 },
-	{ 6783, 6783 },
-	{ 6832, 6845 },
-	{ 6847, 6862 },
-	{ 6912, 6915 },
-	{ 6964, 6964 },
-	{ 6966, 6970 },
-	{ 6972, 6972 },
-	{ 6978, 6978 },
-	{ 7019, 7027 },
-	{ 7040, 7041 },
-	{ 7074, 7077 },
-	{ 7080, 7081 },
-	{ 7083, 7085 },
-	{ 7142, 7142 },
-	{ 7144, 7145 },
-	{ 7149, 7149 },
-	{ 7151, 7153 },
-	{ 7212, 7219 },
-	{ 7222, 7223 },
-	{ 7376, 7378 },
-	{ 7380, 7392 },
-	{ 7394, 7400 },
-	{ 7405, 7405 },
-	{ 7412, 7412 },
-	{ 7416, 7417 },
-	{ 7616, 7679 },
-	{ 8400, 8412 },
-	{ 8417, 8417 },
-	{ 8421, 8432 },
-	{ 11503, 11505 },
-	{ 11647, 11647 },
-	{ 11744, 11775 },
-	{ 12330, 12333 },
-	{ 12441, 12442 },
-	{ 42607, 42607 },
-	{ 42612, 42621 },
-	{ 42654, 42655 },
-	{ 42736, 42737 },
-	{ 43010, 43010 },
-	{ 43014, 43014 },
-	{ 43019, 43019 },
-	{ 43045, 43046 },
-	{ 43052, 43052 },
-	{ 43204, 43205 },
-	{ 43232, 43249 },
-	{ 43263, 43263 },
-	{ 43302, 43309 },
-	{ 43335, 43345 },
-	{ 43392, 43394 },
-	{ 43443, 43443 },
-	{ 43446, 43449 },
-	{ 43452, 43453 },
-	{ 43493, 43493 },
-	{ 43561, 43566 },
-	{ 43569, 43570 },
-	{ 43573, 43574 },
-	{ 43587, 43587 },
-	{ 43596, 43596 },
-	{ 43644, 43644 },
-	{ 43696, 43696 },
-	{ 43698, 43700 },
-	{ 43703, 43704 },
-	{ 43710, 43711 },
-	{ 43713, 43713 },
-	{ 43756, 43757 },
-	{ 43766, 43766 },
-	{ 44005, 44005 },
-	{ 44008, 44008 },
-	{ 44013, 44013 },
-	{ 64286, 64286 },
-	{ 65024, 65039 },
-	{ 65056, 65071 },
-};
-static const URange32 Mn_range32[] = {
-	{ 66045, 66045 },
-	{ 66272, 66272 },
-	{ 66422, 66426 },
-	{ 68097, 68099 },
-	{ 68101, 68102 },
-	{ 68108, 68111 },
-	{ 68152, 68154 },
-	{ 68159, 68159 },
-	{ 68325, 68326 },
-	{ 68900, 68903 },
-	{ 69291, 69292 },
-	{ 69373, 69375 },
-	{ 69446, 69456 },
-	{ 69506, 69509 },
-	{ 69633, 69633 },
-	{ 69688, 69702 },
-	{ 69744, 69744 },
-	{ 69747, 69748 },
-	{ 69759, 69761 },
-	{ 69811, 69814 },
-	{ 69817, 69818 },
-	{ 69826, 69826 },
-	{ 69888, 69890 },
-	{ 69927, 69931 },
-	{ 69933, 69940 },
-	{ 70003, 70003 },
-	{ 70016, 70017 },
-	{ 70070, 70078 },
-	{ 70089, 70092 },
-	{ 70095, 70095 },
-	{ 70191, 70193 },
-	{ 70196, 70196 },
-	{ 70198, 70199 },
-	{ 70206, 70206 },
-	{ 70209, 70209 },
-	{ 70367, 70367 },
-	{ 70371, 70378 },
-	{ 70400, 70401 },
-	{ 70459, 70460 },
-	{ 70464, 70464 },
-	{ 70502, 70508 },
-	{ 70512, 70516 },
-	{ 70712, 70719 },
-	{ 70722, 70724 },
-	{ 70726, 70726 },
-	{ 70750, 70750 },
-	{ 70835, 70840 },
-	{ 70842, 70842 },
-	{ 70847, 70848 },
-	{ 70850, 70851 },
-	{ 71090, 71093 },
-	{ 71100, 71101 },
-	{ 71103, 71104 },
-	{ 71132, 71133 },
-	{ 71219, 71226 },
-	{ 71229, 71229 },
-	{ 71231, 71232 },
-	{ 71339, 71339 },
-	{ 71341, 71341 },
-	{ 71344, 71349 },
-	{ 71351, 71351 },
-	{ 71453, 71455 },
-	{ 71458, 71461 },
-	{ 71463, 71467 },
-	{ 71727, 71735 },
-	{ 71737, 71738 },
-	{ 71995, 71996 },
-	{ 71998, 71998 },
-	{ 72003, 72003 },
-	{ 72148, 72151 },
-	{ 72154, 72155 },
-	{ 72160, 72160 },
-	{ 72193, 72202 },
-	{ 72243, 72248 },
-	{ 72251, 72254 },
-	{ 72263, 72263 },
-	{ 72273, 72278 },
-	{ 72281, 72283 },
-	{ 72330, 72342 },
-	{ 72344, 72345 },
-	{ 72752, 72758 },
-	{ 72760, 72765 },
-	{ 72767, 72767 },
-	{ 72850, 72871 },
-	{ 72874, 72880 },
-	{ 72882, 72883 },
-	{ 72885, 72886 },
-	{ 73009, 73014 },
-	{ 73018, 73018 },
-	{ 73020, 73021 },
-	{ 73023, 73029 },
-	{ 73031, 73031 },
-	{ 73104, 73105 },
-	{ 73109, 73109 },
-	{ 73111, 73111 },
-	{ 73459, 73460 },
-	{ 73472, 73473 },
-	{ 73526, 73530 },
-	{ 73536, 73536 },
-	{ 73538, 73538 },
-	{ 78912, 78912 },
-	{ 78919, 78933 },
-	{ 92912, 92916 },
-	{ 92976, 92982 },
-	{ 94031, 94031 },
-	{ 94095, 94098 },
-	{ 94180, 94180 },
-	{ 113821, 113822 },
-	{ 118528, 118573 },
-	{ 118576, 118598 },
-	{ 119143, 119145 },
-	{ 119163, 119170 },
-	{ 119173, 119179 },
-	{ 119210, 119213 },
-	{ 119362, 119364 },
-	{ 121344, 121398 },
-	{ 121403, 121452 },
-	{ 121461, 121461 },
-	{ 121476, 121476 },
-	{ 121499, 121503 },
-	{ 121505, 121519 },
-	{ 122880, 122886 },
-	{ 122888, 122904 },
-	{ 122907, 122913 },
-	{ 122915, 122916 },
-	{ 122918, 122922 },
-	{ 123023, 123023 },
-	{ 123184, 123190 },
-	{ 123566, 123566 },
-	{ 123628, 123631 },
-	{ 124140, 124143 },
-	{ 125136, 125142 },
-	{ 125252, 125258 },
-	{ 917760, 917999 },
-};
-static const URange16 N_range16[] = {
-	{ 48, 57 },
-	{ 178, 179 },
-	{ 185, 185 },
-	{ 188, 190 },
-	{ 1632, 1641 },
-	{ 1776, 1785 },
-	{ 1984, 1993 },
-	{ 2406, 2415 },
-	{ 2534, 2543 },
-	{ 2548, 2553 },
-	{ 2662, 2671 },
-	{ 2790, 2799 },
-	{ 2918, 2927 },
-	{ 2930, 2935 },
-	{ 3046, 3058 },
-	{ 3174, 3183 },
-	{ 3192, 3198 },
-	{ 3302, 3311 },
-	{ 3416, 3422 },
-	{ 3430, 3448 },
-	{ 3558, 3567 },
-	{ 3664, 3673 },
-	{ 3792, 3801 },
-	{ 3872, 3891 },
-	{ 4160, 4169 },
-	{ 4240, 4249 },
-	{ 4969, 4988 },
-	{ 5870, 5872 },
-	{ 6112, 6121 },
-	{ 6128, 6137 },
-	{ 6160, 6169 },
-	{ 6470, 6479 },
-	{ 6608, 6618 },
-	{ 6784, 6793 },
-	{ 6800, 6809 },
-	{ 6992, 7001 },
-	{ 7088, 7097 },
-	{ 7232, 7241 },
-	{ 7248, 7257 },
-	{ 8304, 8304 },
-	{ 8308, 8313 },
-	{ 8320, 8329 },
-	{ 8528, 8578 },
-	{ 8581, 8585 },
-	{ 9312, 9371 },
-	{ 9450, 9471 },
-	{ 10102, 10131 },
-	{ 11517, 11517 },
-	{ 12295, 12295 },
-	{ 12321, 12329 },
-	{ 12344, 12346 },
-	{ 12690, 12693 },
-	{ 12832, 12841 },
-	{ 12872, 12879 },
-	{ 12881, 12895 },
-	{ 12928, 12937 },
-	{ 12977, 12991 },
-	{ 42528, 42537 },
-	{ 42726, 42735 },
-	{ 43056, 43061 },
-	{ 43216, 43225 },
-	{ 43264, 43273 },
-	{ 43472, 43481 },
-	{ 43504, 43513 },
-	{ 43600, 43609 },
-	{ 44016, 44025 },
-	{ 65296, 65305 },
-};
-static const URange32 N_range32[] = {
-	{ 65799, 65843 },
-	{ 65856, 65912 },
-	{ 65930, 65931 },
-	{ 66273, 66299 },
-	{ 66336, 66339 },
-	{ 66369, 66369 },
-	{ 66378, 66378 },
-	{ 66513, 66517 },
-	{ 66720, 66729 },
-	{ 67672, 67679 },
-	{ 67705, 67711 },
-	{ 67751, 67759 },
-	{ 67835, 67839 },
-	{ 67862, 67867 },
-	{ 68028, 68029 },
-	{ 68032, 68047 },
-	{ 68050, 68095 },
-	{ 68160, 68168 },
-	{ 68221, 68222 },
-	{ 68253, 68255 },
-	{ 68331, 68335 },
-	{ 68440, 68447 },
-	{ 68472, 68479 },
-	{ 68521, 68527 },
-	{ 68858, 68863 },
-	{ 68912, 68921 },
-	{ 69216, 69246 },
-	{ 69405, 69414 },
-	{ 69457, 69460 },
-	{ 69573, 69579 },
-	{ 69714, 69743 },
-	{ 69872, 69881 },
-	{ 69942, 69951 },
-	{ 70096, 70105 },
-	{ 70113, 70132 },
-	{ 70384, 70393 },
-	{ 70736, 70745 },
-	{ 70864, 70873 },
-	{ 71248, 71257 },
-	{ 71360, 71369 },
-	{ 71472, 71483 },
-	{ 71904, 71922 },
-	{ 72016, 72025 },
-	{ 72784, 72812 },
-	{ 73040, 73049 },
-	{ 73120, 73129 },
-	{ 73552, 73561 },
-	{ 73664, 73684 },
-	{ 74752, 74862 },
-	{ 92768, 92777 },
-	{ 92864, 92873 },
-	{ 93008, 93017 },
-	{ 93019, 93025 },
-	{ 93824, 93846 },
-	{ 119488, 119507 },
-	{ 119520, 119539 },
-	{ 119648, 119672 },
-	{ 120782, 120831 },
-	{ 123200, 123209 },
-	{ 123632, 123641 },
-	{ 124144, 124153 },
-	{ 125127, 125135 },
-	{ 125264, 125273 },
-	{ 126065, 126123 },
-	{ 126125, 126127 },
-	{ 126129, 126132 },
-	{ 126209, 126253 },
-	{ 126255, 126269 },
-	{ 127232, 127244 },
-	{ 130032, 130041 },
-};
-static const URange16 Nd_range16[] = {
-	{ 48, 57 },
-	{ 1632, 1641 },
-	{ 1776, 1785 },
-	{ 1984, 1993 },
-	{ 2406, 2415 },
-	{ 2534, 2543 },
-	{ 2662, 2671 },
-	{ 2790, 2799 },
-	{ 2918, 2927 },
-	{ 3046, 3055 },
-	{ 3174, 3183 },
-	{ 3302, 3311 },
-	{ 3430, 3439 },
-	{ 3558, 3567 },
-	{ 3664, 3673 },
-	{ 3792, 3801 },
-	{ 3872, 3881 },
-	{ 4160, 4169 },
-	{ 4240, 4249 },
-	{ 6112, 6121 },
-	{ 6160, 6169 },
-	{ 6470, 6479 },
-	{ 6608, 6617 },
-	{ 6784, 6793 },
-	{ 6800, 6809 },
-	{ 6992, 7001 },
-	{ 7088, 7097 },
-	{ 7232, 7241 },
-	{ 7248, 7257 },
-	{ 42528, 42537 },
-	{ 43216, 43225 },
-	{ 43264, 43273 },
-	{ 43472, 43481 },
-	{ 43504, 43513 },
-	{ 43600, 43609 },
-	{ 44016, 44025 },
-	{ 65296, 65305 },
-};
-static const URange32 Nd_range32[] = {
-	{ 66720, 66729 },
-	{ 68912, 68921 },
-	{ 69734, 69743 },
-	{ 69872, 69881 },
-	{ 69942, 69951 },
-	{ 70096, 70105 },
-	{ 70384, 70393 },
-	{ 70736, 70745 },
-	{ 70864, 70873 },
-	{ 71248, 71257 },
-	{ 71360, 71369 },
-	{ 71472, 71481 },
-	{ 71904, 71913 },
-	{ 72016, 72025 },
-	{ 72784, 72793 },
-	{ 73040, 73049 },
-	{ 73120, 73129 },
-	{ 73552, 73561 },
-	{ 92768, 92777 },
-	{ 92864, 92873 },
-	{ 93008, 93017 },
-	{ 120782, 120831 },
-	{ 123200, 123209 },
-	{ 123632, 123641 },
-	{ 124144, 124153 },
-	{ 125264, 125273 },
-	{ 130032, 130041 },
-};
-static const URange16 Nl_range16[] = {
-	{ 5870, 5872 },
-	{ 8544, 8578 },
-	{ 8581, 8584 },
-	{ 12295, 12295 },
-	{ 12321, 12329 },
-	{ 12344, 12346 },
-	{ 42726, 42735 },
-};
-static const URange32 Nl_range32[] = {
-	{ 65856, 65908 },
-	{ 66369, 66369 },
-	{ 66378, 66378 },
-	{ 66513, 66517 },
-	{ 74752, 74862 },
-};
-static const URange16 No_range16[] = {
-	{ 178, 179 },
-	{ 185, 185 },
-	{ 188, 190 },
-	{ 2548, 2553 },
-	{ 2930, 2935 },
-	{ 3056, 3058 },
-	{ 3192, 3198 },
-	{ 3416, 3422 },
-	{ 3440, 3448 },
-	{ 3882, 3891 },
-	{ 4969, 4988 },
-	{ 6128, 6137 },
-	{ 6618, 6618 },
-	{ 8304, 8304 },
-	{ 8308, 8313 },
-	{ 8320, 8329 },
-	{ 8528, 8543 },
-	{ 8585, 8585 },
-	{ 9312, 9371 },
-	{ 9450, 9471 },
-	{ 10102, 10131 },
-	{ 11517, 11517 },
-	{ 12690, 12693 },
-	{ 12832, 12841 },
-	{ 12872, 12879 },
-	{ 12881, 12895 },
-	{ 12928, 12937 },
-	{ 12977, 12991 },
-	{ 43056, 43061 },
-};
-static const URange32 No_range32[] = {
-	{ 65799, 65843 },
-	{ 65909, 65912 },
-	{ 65930, 65931 },
-	{ 66273, 66299 },
-	{ 66336, 66339 },
-	{ 67672, 67679 },
-	{ 67705, 67711 },
-	{ 67751, 67759 },
-	{ 67835, 67839 },
-	{ 67862, 67867 },
-	{ 68028, 68029 },
-	{ 68032, 68047 },
-	{ 68050, 68095 },
-	{ 68160, 68168 },
-	{ 68221, 68222 },
-	{ 68253, 68255 },
-	{ 68331, 68335 },
-	{ 68440, 68447 },
-	{ 68472, 68479 },
-	{ 68521, 68527 },
-	{ 68858, 68863 },
-	{ 69216, 69246 },
-	{ 69405, 69414 },
-	{ 69457, 69460 },
-	{ 69573, 69579 },
-	{ 69714, 69733 },
-	{ 70113, 70132 },
-	{ 71482, 71483 },
-	{ 71914, 71922 },
-	{ 72794, 72812 },
-	{ 73664, 73684 },
-	{ 93019, 93025 },
-	{ 93824, 93846 },
-	{ 119488, 119507 },
-	{ 119520, 119539 },
-	{ 119648, 119672 },
-	{ 125127, 125135 },
-	{ 126065, 126123 },
-	{ 126125, 126127 },
-	{ 126129, 126132 },
-	{ 126209, 126253 },
-	{ 126255, 126269 },
-	{ 127232, 127244 },
-};
-static const URange16 P_range16[] = {
-	{ 33, 35 },
-	{ 37, 42 },
-	{ 44, 47 },
-	{ 58, 59 },
-	{ 63, 64 },
-	{ 91, 93 },
-	{ 95, 95 },
-	{ 123, 123 },
-	{ 125, 125 },
-	{ 161, 161 },
-	{ 167, 167 },
-	{ 171, 171 },
-	{ 182, 183 },
-	{ 187, 187 },
-	{ 191, 191 },
-	{ 894, 894 },
-	{ 903, 903 },
-	{ 1370, 1375 },
-	{ 1417, 1418 },
-	{ 1470, 1470 },
-	{ 1472, 1472 },
-	{ 1475, 1475 },
-	{ 1478, 1478 },
-	{ 1523, 1524 },
-	{ 1545, 1546 },
-	{ 1548, 1549 },
-	{ 1563, 1563 },
-	{ 1565, 1567 },
-	{ 1642, 1645 },
-	{ 1748, 1748 },
-	{ 1792, 1805 },
-	{ 2039, 2041 },
-	{ 2096, 2110 },
-	{ 2142, 2142 },
-	{ 2404, 2405 },
-	{ 2416, 2416 },
-	{ 2557, 2557 },
-	{ 2678, 2678 },
-	{ 2800, 2800 },
-	{ 3191, 3191 },
-	{ 3204, 3204 },
-	{ 3572, 3572 },
-	{ 3663, 3663 },
-	{ 3674, 3675 },
-	{ 3844, 3858 },
-	{ 3860, 3860 },
-	{ 3898, 3901 },
-	{ 3973, 3973 },
-	{ 4048, 4052 },
-	{ 4057, 4058 },
-	{ 4170, 4175 },
-	{ 4347, 4347 },
-	{ 4960, 4968 },
-	{ 5120, 5120 },
-	{ 5742, 5742 },
-	{ 5787, 5788 },
-	{ 5867, 5869 },
-	{ 5941, 5942 },
-	{ 6100, 6102 },
-	{ 6104, 6106 },
-	{ 6144, 6154 },
-	{ 6468, 6469 },
-	{ 6686, 6687 },
-	{ 6816, 6822 },
-	{ 6824, 6829 },
-	{ 7002, 7008 },
-	{ 7037, 7038 },
-	{ 7164, 7167 },
-	{ 7227, 7231 },
-	{ 7294, 7295 },
-	{ 7360, 7367 },
-	{ 7379, 7379 },
-	{ 8208, 8231 },
-	{ 8240, 8259 },
-	{ 8261, 8273 },
-	{ 8275, 8286 },
-	{ 8317, 8318 },
-	{ 8333, 8334 },
-	{ 8968, 8971 },
-	{ 9001, 9002 },
-	{ 10088, 10101 },
-	{ 10181, 10182 },
-	{ 10214, 10223 },
-	{ 10627, 10648 },
-	{ 10712, 10715 },
-	{ 10748, 10749 },
-	{ 11513, 11516 },
-	{ 11518, 11519 },
-	{ 11632, 11632 },
-	{ 11776, 11822 },
-	{ 11824, 11855 },
-	{ 11858, 11869 },
-	{ 12289, 12291 },
-	{ 12296, 12305 },
-	{ 12308, 12319 },
-	{ 12336, 12336 },
-	{ 12349, 12349 },
-	{ 12448, 12448 },
-	{ 12539, 12539 },
-	{ 42238, 42239 },
-	{ 42509, 42511 },
-	{ 42611, 42611 },
-	{ 42622, 42622 },
-	{ 42738, 42743 },
-	{ 43124, 43127 },
-	{ 43214, 43215 },
-	{ 43256, 43258 },
-	{ 43260, 43260 },
-	{ 43310, 43311 },
-	{ 43359, 43359 },
-	{ 43457, 43469 },
-	{ 43486, 43487 },
-	{ 43612, 43615 },
-	{ 43742, 43743 },
-	{ 43760, 43761 },
-	{ 44011, 44011 },
-	{ 64830, 64831 },
-	{ 65040, 65049 },
-	{ 65072, 65106 },
-	{ 65108, 65121 },
-	{ 65123, 65123 },
-	{ 65128, 65128 },
-	{ 65130, 65131 },
-	{ 65281, 65283 },
-	{ 65285, 65290 },
-	{ 65292, 65295 },
-	{ 65306, 65307 },
-	{ 65311, 65312 },
-	{ 65339, 65341 },
-	{ 65343, 65343 },
-	{ 65371, 65371 },
-	{ 65373, 65373 },
-	{ 65375, 65381 },
-};
-static const URange32 P_range32[] = {
-	{ 65792, 65794 },
-	{ 66463, 66463 },
-	{ 66512, 66512 },
-	{ 66927, 66927 },
-	{ 67671, 67671 },
-	{ 67871, 67871 },
-	{ 67903, 67903 },
-	{ 68176, 68184 },
-	{ 68223, 68223 },
-	{ 68336, 68342 },
-	{ 68409, 68415 },
-	{ 68505, 68508 },
-	{ 69293, 69293 },
-	{ 69461, 69465 },
-	{ 69510, 69513 },
-	{ 69703, 69709 },
-	{ 69819, 69820 },
-	{ 69822, 69825 },
-	{ 69952, 69955 },
-	{ 70004, 70005 },
-	{ 70085, 70088 },
-	{ 70093, 70093 },
-	{ 70107, 70107 },
-	{ 70109, 70111 },
-	{ 70200, 70205 },
-	{ 70313, 70313 },
-	{ 70731, 70735 },
-	{ 70746, 70747 },
-	{ 70749, 70749 },
-	{ 70854, 70854 },
-	{ 71105, 71127 },
-	{ 71233, 71235 },
-	{ 71264, 71276 },
-	{ 71353, 71353 },
-	{ 71484, 71486 },
-	{ 71739, 71739 },
-	{ 72004, 72006 },
-	{ 72162, 72162 },
-	{ 72255, 72262 },
-	{ 72346, 72348 },
-	{ 72350, 72354 },
-	{ 72448, 72457 },
-	{ 72769, 72773 },
-	{ 72816, 72817 },
-	{ 73463, 73464 },
-	{ 73539, 73551 },
-	{ 73727, 73727 },
-	{ 74864, 74868 },
-	{ 77809, 77810 },
-	{ 92782, 92783 },
-	{ 92917, 92917 },
-	{ 92983, 92987 },
-	{ 92996, 92996 },
-	{ 93847, 93850 },
-	{ 94178, 94178 },
-	{ 113823, 113823 },
-	{ 121479, 121483 },
-	{ 125278, 125279 },
-};
-static const URange16 Pc_range16[] = {
-	{ 95, 95 },
-	{ 8255, 8256 },
-	{ 8276, 8276 },
-	{ 65075, 65076 },
-	{ 65101, 65103 },
-	{ 65343, 65343 },
-};
-static const URange16 Pd_range16[] = {
-	{ 45, 45 },
-	{ 1418, 1418 },
-	{ 1470, 1470 },
-	{ 5120, 5120 },
-	{ 6150, 6150 },
-	{ 8208, 8213 },
-	{ 11799, 11799 },
-	{ 11802, 11802 },
-	{ 11834, 11835 },
-	{ 11840, 11840 },
-	{ 11869, 11869 },
-	{ 12316, 12316 },
-	{ 12336, 12336 },
-	{ 12448, 12448 },
-	{ 65073, 65074 },
-	{ 65112, 65112 },
-	{ 65123, 65123 },
-	{ 65293, 65293 },
-};
-static const URange32 Pd_range32[] = {
-	{ 69293, 69293 },
-};
-static const URange16 Pe_range16[] = {
-	{ 41, 41 },
-	{ 93, 93 },
-	{ 125, 125 },
-	{ 3899, 3899 },
-	{ 3901, 3901 },
-	{ 5788, 5788 },
-	{ 8262, 8262 },
-	{ 8318, 8318 },
-	{ 8334, 8334 },
-	{ 8969, 8969 },
-	{ 8971, 8971 },
-	{ 9002, 9002 },
-	{ 10089, 10089 },
-	{ 10091, 10091 },
-	{ 10093, 10093 },
-	{ 10095, 10095 },
-	{ 10097, 10097 },
-	{ 10099, 10099 },
-	{ 10101, 10101 },
-	{ 10182, 10182 },
-	{ 10215, 10215 },
-	{ 10217, 10217 },
-	{ 10219, 10219 },
-	{ 10221, 10221 },
-	{ 10223, 10223 },
-	{ 10628, 10628 },
-	{ 10630, 10630 },
-	{ 10632, 10632 },
-	{ 10634, 10634 },
-	{ 10636, 10636 },
-	{ 10638, 10638 },
-	{ 10640, 10640 },
-	{ 10642, 10642 },
-	{ 10644, 10644 },
-	{ 10646, 10646 },
-	{ 10648, 10648 },
-	{ 10713, 10713 },
-	{ 10715, 10715 },
-	{ 10749, 10749 },
-	{ 11811, 11811 },
-	{ 11813, 11813 },
-	{ 11815, 11815 },
-	{ 11817, 11817 },
-	{ 11862, 11862 },
-	{ 11864, 11864 },
-	{ 11866, 11866 },
-	{ 11868, 11868 },
-	{ 12297, 12297 },
-	{ 12299, 12299 },
-	{ 12301, 12301 },
-	{ 12303, 12303 },
-	{ 12305, 12305 },
-	{ 12309, 12309 },
-	{ 12311, 12311 },
-	{ 12313, 12313 },
-	{ 12315, 12315 },
-	{ 12318, 12319 },
-	{ 64830, 64830 },
-	{ 65048, 65048 },
-	{ 65078, 65078 },
-	{ 65080, 65080 },
-	{ 65082, 65082 },
-	{ 65084, 65084 },
-	{ 65086, 65086 },
-	{ 65088, 65088 },
-	{ 65090, 65090 },
-	{ 65092, 65092 },
-	{ 65096, 65096 },
-	{ 65114, 65114 },
-	{ 65116, 65116 },
-	{ 65118, 65118 },
-	{ 65289, 65289 },
-	{ 65341, 65341 },
-	{ 65373, 65373 },
-	{ 65376, 65376 },
-	{ 65379, 65379 },
-};
-static const URange16 Pf_range16[] = {
-	{ 187, 187 },
-	{ 8217, 8217 },
-	{ 8221, 8221 },
-	{ 8250, 8250 },
-	{ 11779, 11779 },
-	{ 11781, 11781 },
-	{ 11786, 11786 },
-	{ 11789, 11789 },
-	{ 11805, 11805 },
-	{ 11809, 11809 },
-};
-static const URange16 Pi_range16[] = {
-	{ 171, 171 },
-	{ 8216, 8216 },
-	{ 8219, 8220 },
-	{ 8223, 8223 },
-	{ 8249, 8249 },
-	{ 11778, 11778 },
-	{ 11780, 11780 },
-	{ 11785, 11785 },
-	{ 11788, 11788 },
-	{ 11804, 11804 },
-	{ 11808, 11808 },
-};
-static const URange16 Po_range16[] = {
-	{ 33, 35 },
-	{ 37, 39 },
-	{ 42, 42 },
-	{ 44, 44 },
-	{ 46, 47 },
-	{ 58, 59 },
-	{ 63, 64 },
-	{ 92, 92 },
-	{ 161, 161 },
-	{ 167, 167 },
-	{ 182, 183 },
-	{ 191, 191 },
-	{ 894, 894 },
-	{ 903, 903 },
-	{ 1370, 1375 },
-	{ 1417, 1417 },
-	{ 1472, 1472 },
-	{ 1475, 1475 },
-	{ 1478, 1478 },
-	{ 1523, 1524 },
-	{ 1545, 1546 },
-	{ 1548, 1549 },
-	{ 1563, 1563 },
-	{ 1565, 1567 },
-	{ 1642, 1645 },
-	{ 1748, 1748 },
-	{ 1792, 1805 },
-	{ 2039, 2041 },
-	{ 2096, 2110 },
-	{ 2142, 2142 },
-	{ 2404, 2405 },
-	{ 2416, 2416 },
-	{ 2557, 2557 },
-	{ 2678, 2678 },
-	{ 2800, 2800 },
-	{ 3191, 3191 },
-	{ 3204, 3204 },
-	{ 3572, 3572 },
-	{ 3663, 3663 },
-	{ 3674, 3675 },
-	{ 3844, 3858 },
-	{ 3860, 3860 },
-	{ 3973, 3973 },
-	{ 4048, 4052 },
-	{ 4057, 4058 },
-	{ 4170, 4175 },
-	{ 4347, 4347 },
-	{ 4960, 4968 },
-	{ 5742, 5742 },
-	{ 5867, 5869 },
-	{ 5941, 5942 },
-	{ 6100, 6102 },
-	{ 6104, 6106 },
-	{ 6144, 6149 },
-	{ 6151, 6154 },
-	{ 6468, 6469 },
-	{ 6686, 6687 },
-	{ 6816, 6822 },
-	{ 6824, 6829 },
-	{ 7002, 7008 },
-	{ 7037, 7038 },
-	{ 7164, 7167 },
-	{ 7227, 7231 },
-	{ 7294, 7295 },
-	{ 7360, 7367 },
-	{ 7379, 7379 },
-	{ 8214, 8215 },
-	{ 8224, 8231 },
-	{ 8240, 8248 },
-	{ 8251, 8254 },
-	{ 8257, 8259 },
-	{ 8263, 8273 },
-	{ 8275, 8275 },
-	{ 8277, 8286 },
-	{ 11513, 11516 },
-	{ 11518, 11519 },
-	{ 11632, 11632 },
-	{ 11776, 11777 },
-	{ 11782, 11784 },
-	{ 11787, 11787 },
-	{ 11790, 11798 },
-	{ 11800, 11801 },
-	{ 11803, 11803 },
-	{ 11806, 11807 },
-	{ 11818, 11822 },
-	{ 11824, 11833 },
-	{ 11836, 11839 },
-	{ 11841, 11841 },
-	{ 11843, 11855 },
-	{ 11858, 11860 },
-	{ 12289, 12291 },
-	{ 12349, 12349 },
-	{ 12539, 12539 },
-	{ 42238, 42239 },
-	{ 42509, 42511 },
-	{ 42611, 42611 },
-	{ 42622, 42622 },
-	{ 42738, 42743 },
-	{ 43124, 43127 },
-	{ 43214, 43215 },
-	{ 43256, 43258 },
-	{ 43260, 43260 },
-	{ 43310, 43311 },
-	{ 43359, 43359 },
-	{ 43457, 43469 },
-	{ 43486, 43487 },
-	{ 43612, 43615 },
-	{ 43742, 43743 },
-	{ 43760, 43761 },
-	{ 44011, 44011 },
-	{ 65040, 65046 },
-	{ 65049, 65049 },
-	{ 65072, 65072 },
-	{ 65093, 65094 },
-	{ 65097, 65100 },
-	{ 65104, 65106 },
-	{ 65108, 65111 },
-	{ 65119, 65121 },
-	{ 65128, 65128 },
-	{ 65130, 65131 },
-	{ 65281, 65283 },
-	{ 65285, 65287 },
-	{ 65290, 65290 },
-	{ 65292, 65292 },
-	{ 65294, 65295 },
-	{ 65306, 65307 },
-	{ 65311, 65312 },
-	{ 65340, 65340 },
-	{ 65377, 65377 },
-	{ 65380, 65381 },
-};
-static const URange32 Po_range32[] = {
-	{ 65792, 65794 },
-	{ 66463, 66463 },
-	{ 66512, 66512 },
-	{ 66927, 66927 },
-	{ 67671, 67671 },
-	{ 67871, 67871 },
-	{ 67903, 67903 },
-	{ 68176, 68184 },
-	{ 68223, 68223 },
-	{ 68336, 68342 },
-	{ 68409, 68415 },
-	{ 68505, 68508 },
-	{ 69461, 69465 },
-	{ 69510, 69513 },
-	{ 69703, 69709 },
-	{ 69819, 69820 },
-	{ 69822, 69825 },
-	{ 69952, 69955 },
-	{ 70004, 70005 },
-	{ 70085, 70088 },
-	{ 70093, 70093 },
-	{ 70107, 70107 },
-	{ 70109, 70111 },
-	{ 70200, 70205 },
-	{ 70313, 70313 },
-	{ 70731, 70735 },
-	{ 70746, 70747 },
-	{ 70749, 70749 },
-	{ 70854, 70854 },
-	{ 71105, 71127 },
-	{ 71233, 71235 },
-	{ 71264, 71276 },
-	{ 71353, 71353 },
-	{ 71484, 71486 },
-	{ 71739, 71739 },
-	{ 72004, 72006 },
-	{ 72162, 72162 },
-	{ 72255, 72262 },
-	{ 72346, 72348 },
-	{ 72350, 72354 },
-	{ 72448, 72457 },
-	{ 72769, 72773 },
-	{ 72816, 72817 },
-	{ 73463, 73464 },
-	{ 73539, 73551 },
-	{ 73727, 73727 },
-	{ 74864, 74868 },
-	{ 77809, 77810 },
-	{ 92782, 92783 },
-	{ 92917, 92917 },
-	{ 92983, 92987 },
-	{ 92996, 92996 },
-	{ 93847, 93850 },
-	{ 94178, 94178 },
-	{ 113823, 113823 },
-	{ 121479, 121483 },
-	{ 125278, 125279 },
-};
-static const URange16 Ps_range16[] = {
-	{ 40, 40 },
-	{ 91, 91 },
-	{ 123, 123 },
-	{ 3898, 3898 },
-	{ 3900, 3900 },
-	{ 5787, 5787 },
-	{ 8218, 8218 },
-	{ 8222, 8222 },
-	{ 8261, 8261 },
-	{ 8317, 8317 },
-	{ 8333, 8333 },
-	{ 8968, 8968 },
-	{ 8970, 8970 },
-	{ 9001, 9001 },
-	{ 10088, 10088 },
-	{ 10090, 10090 },
-	{ 10092, 10092 },
-	{ 10094, 10094 },
-	{ 10096, 10096 },
-	{ 10098, 10098 },
-	{ 10100, 10100 },
-	{ 10181, 10181 },
-	{ 10214, 10214 },
-	{ 10216, 10216 },
-	{ 10218, 10218 },
-	{ 10220, 10220 },
-	{ 10222, 10222 },
-	{ 10627, 10627 },
-	{ 10629, 10629 },
-	{ 10631, 10631 },
-	{ 10633, 10633 },
-	{ 10635, 10635 },
-	{ 10637, 10637 },
-	{ 10639, 10639 },
-	{ 10641, 10641 },
-	{ 10643, 10643 },
-	{ 10645, 10645 },
-	{ 10647, 10647 },
-	{ 10712, 10712 },
-	{ 10714, 10714 },
-	{ 10748, 10748 },
-	{ 11810, 11810 },
-	{ 11812, 11812 },
-	{ 11814, 11814 },
-	{ 11816, 11816 },
-	{ 11842, 11842 },
-	{ 11861, 11861 },
-	{ 11863, 11863 },
-	{ 11865, 11865 },
-	{ 11867, 11867 },
-	{ 12296, 12296 },
-	{ 12298, 12298 },
-	{ 12300, 12300 },
-	{ 12302, 12302 },
-	{ 12304, 12304 },
-	{ 12308, 12308 },
-	{ 12310, 12310 },
-	{ 12312, 12312 },
-	{ 12314, 12314 },
-	{ 12317, 12317 },
-	{ 64831, 64831 },
-	{ 65047, 65047 },
-	{ 65077, 65077 },
-	{ 65079, 65079 },
-	{ 65081, 65081 },
-	{ 65083, 65083 },
-	{ 65085, 65085 },
-	{ 65087, 65087 },
-	{ 65089, 65089 },
-	{ 65091, 65091 },
-	{ 65095, 65095 },
-	{ 65113, 65113 },
-	{ 65115, 65115 },
-	{ 65117, 65117 },
-	{ 65288, 65288 },
-	{ 65339, 65339 },
-	{ 65371, 65371 },
-	{ 65375, 65375 },
-	{ 65378, 65378 },
-};
-static const URange16 S_range16[] = {
-	{ 36, 36 },
-	{ 43, 43 },
-	{ 60, 62 },
-	{ 94, 94 },
-	{ 96, 96 },
-	{ 124, 124 },
-	{ 126, 126 },
-	{ 162, 166 },
-	{ 168, 169 },
-	{ 172, 172 },
-	{ 174, 177 },
-	{ 180, 180 },
-	{ 184, 184 },
-	{ 215, 215 },
-	{ 247, 247 },
-	{ 706, 709 },
-	{ 722, 735 },
-	{ 741, 747 },
-	{ 749, 749 },
-	{ 751, 767 },
-	{ 885, 885 },
-	{ 900, 901 },
-	{ 1014, 1014 },
-	{ 1154, 1154 },
-	{ 1421, 1423 },
-	{ 1542, 1544 },
-	{ 1547, 1547 },
-	{ 1550, 1551 },
-	{ 1758, 1758 },
-	{ 1769, 1769 },
-	{ 1789, 1790 },
-	{ 2038, 2038 },
-	{ 2046, 2047 },
-	{ 2184, 2184 },
-	{ 2546, 2547 },
-	{ 2554, 2555 },
-	{ 2801, 2801 },
-	{ 2928, 2928 },
-	{ 3059, 3066 },
-	{ 3199, 3199 },
-	{ 3407, 3407 },
-	{ 3449, 3449 },
-	{ 3647, 3647 },
-	{ 3841, 3843 },
-	{ 3859, 3859 },
-	{ 3861, 3863 },
-	{ 3866, 3871 },
-	{ 3892, 3892 },
-	{ 3894, 3894 },
-	{ 3896, 3896 },
-	{ 4030, 4037 },
-	{ 4039, 4044 },
-	{ 4046, 4047 },
-	{ 4053, 4056 },
-	{ 4254, 4255 },
-	{ 5008, 5017 },
-	{ 5741, 5741 },
-	{ 6107, 6107 },
-	{ 6464, 6464 },
-	{ 6622, 6655 },
-	{ 7009, 7018 },
-	{ 7028, 7036 },
-	{ 8125, 8125 },
-	{ 8127, 8129 },
-	{ 8141, 8143 },
-	{ 8157, 8159 },
-	{ 8173, 8175 },
-	{ 8189, 8190 },
-	{ 8260, 8260 },
-	{ 8274, 8274 },
-	{ 8314, 8316 },
-	{ 8330, 8332 },
-	{ 8352, 8384 },
-	{ 8448, 8449 },
-	{ 8451, 8454 },
-	{ 8456, 8457 },
-	{ 8468, 8468 },
-	{ 8470, 8472 },
-	{ 8478, 8483 },
-	{ 8485, 8485 },
-	{ 8487, 8487 },
-	{ 8489, 8489 },
-	{ 8494, 8494 },
-	{ 8506, 8507 },
-	{ 8512, 8516 },
-	{ 8522, 8525 },
-	{ 8527, 8527 },
-	{ 8586, 8587 },
-	{ 8592, 8967 },
-	{ 8972, 9000 },
-	{ 9003, 9254 },
-	{ 9280, 9290 },
-	{ 9372, 9449 },
-	{ 9472, 10087 },
-	{ 10132, 10180 },
-	{ 10183, 10213 },
-	{ 10224, 10626 },
-	{ 10649, 10711 },
-	{ 10716, 10747 },
-	{ 10750, 11123 },
-	{ 11126, 11157 },
-	{ 11159, 11263 },
-	{ 11493, 11498 },
-	{ 11856, 11857 },
-	{ 11904, 11929 },
-	{ 11931, 12019 },
-	{ 12032, 12245 },
-	{ 12272, 12283 },
-	{ 12292, 12292 },
-	{ 12306, 12307 },
-	{ 12320, 12320 },
-	{ 12342, 12343 },
-	{ 12350, 12351 },
-	{ 12443, 12444 },
-	{ 12688, 12689 },
-	{ 12694, 12703 },
-	{ 12736, 12771 },
-	{ 12800, 12830 },
-	{ 12842, 12871 },
-	{ 12880, 12880 },
-	{ 12896, 12927 },
-	{ 12938, 12976 },
-	{ 12992, 13311 },
-	{ 19904, 19967 },
-	{ 42128, 42182 },
-	{ 42752, 42774 },
-	{ 42784, 42785 },
-	{ 42889, 42890 },
-	{ 43048, 43051 },
-	{ 43062, 43065 },
-	{ 43639, 43641 },
-	{ 43867, 43867 },
-	{ 43882, 43883 },
-	{ 64297, 64297 },
-	{ 64434, 64450 },
-	{ 64832, 64847 },
-	{ 64975, 64975 },
-	{ 65020, 65023 },
-	{ 65122, 65122 },
-	{ 65124, 65126 },
-	{ 65129, 65129 },
-	{ 65284, 65284 },
-	{ 65291, 65291 },
-	{ 65308, 65310 },
-	{ 65342, 65342 },
-	{ 65344, 65344 },
-	{ 65372, 65372 },
-	{ 65374, 65374 },
-	{ 65504, 65510 },
-	{ 65512, 65518 },
-	{ 65532, 65533 },
-};
-static const URange32 S_range32[] = {
-	{ 65847, 65855 },
-	{ 65913, 65929 },
-	{ 65932, 65934 },
-	{ 65936, 65948 },
-	{ 65952, 65952 },
-	{ 66000, 66044 },
-	{ 67703, 67704 },
-	{ 68296, 68296 },
-	{ 71487, 71487 },
-	{ 73685, 73713 },
-	{ 92988, 92991 },
-	{ 92997, 92997 },
-	{ 113820, 113820 },
-	{ 118608, 118723 },
-	{ 118784, 119029 },
-	{ 119040, 119078 },
-	{ 119081, 119140 },
-	{ 119146, 119148 },
-	{ 119171, 119172 },
-	{ 119180, 119209 },
-	{ 119214, 119274 },
-	{ 119296, 119361 },
-	{ 119365, 119365 },
-	{ 119552, 119638 },
-	{ 120513, 120513 },
-	{ 120539, 120539 },
-	{ 120571, 120571 },
-	{ 120597, 120597 },
-	{ 120629, 120629 },
-	{ 120655, 120655 },
-	{ 120687, 120687 },
-	{ 120713, 120713 },
-	{ 120745, 120745 },
-	{ 120771, 120771 },
-	{ 120832, 121343 },
-	{ 121399, 121402 },
-	{ 121453, 121460 },
-	{ 121462, 121475 },
-	{ 121477, 121478 },
-	{ 123215, 123215 },
-	{ 123647, 123647 },
-	{ 126124, 126124 },
-	{ 126128, 126128 },
-	{ 126254, 126254 },
-	{ 126704, 126705 },
-	{ 126976, 127019 },
-	{ 127024, 127123 },
-	{ 127136, 127150 },
-	{ 127153, 127167 },
-	{ 127169, 127183 },
-	{ 127185, 127221 },
-	{ 127245, 127405 },
-	{ 127462, 127490 },
-	{ 127504, 127547 },
-	{ 127552, 127560 },
-	{ 127568, 127569 },
-	{ 127584, 127589 },
-	{ 127744, 128727 },
-	{ 128732, 128748 },
-	{ 128752, 128764 },
-	{ 128768, 128886 },
-	{ 128891, 128985 },
-	{ 128992, 129003 },
-	{ 129008, 129008 },
-	{ 129024, 129035 },
-	{ 129040, 129095 },
-	{ 129104, 129113 },
-	{ 129120, 129159 },
-	{ 129168, 129197 },
-	{ 129200, 129201 },
-	{ 129280, 129619 },
-	{ 129632, 129645 },
-	{ 129648, 129660 },
-	{ 129664, 129672 },
-	{ 129680, 129725 },
-	{ 129727, 129733 },
-	{ 129742, 129755 },
-	{ 129760, 129768 },
-	{ 129776, 129784 },
-	{ 129792, 129938 },
-	{ 129940, 129994 },
-};
-static const URange16 Sc_range16[] = {
-	{ 36, 36 },
-	{ 162, 165 },
-	{ 1423, 1423 },
-	{ 1547, 1547 },
-	{ 2046, 2047 },
-	{ 2546, 2547 },
-	{ 2555, 2555 },
-	{ 2801, 2801 },
-	{ 3065, 3065 },
-	{ 3647, 3647 },
-	{ 6107, 6107 },
-	{ 8352, 8384 },
-	{ 43064, 43064 },
-	{ 65020, 65020 },
-	{ 65129, 65129 },
-	{ 65284, 65284 },
-	{ 65504, 65505 },
-	{ 65509, 65510 },
-};
-static const URange32 Sc_range32[] = {
-	{ 73693, 73696 },
-	{ 123647, 123647 },
-	{ 126128, 126128 },
-};
-static const URange16 Sk_range16[] = {
-	{ 94, 94 },
-	{ 96, 96 },
-	{ 168, 168 },
-	{ 175, 175 },
-	{ 180, 180 },
-	{ 184, 184 },
-	{ 706, 709 },
-	{ 722, 735 },
-	{ 741, 747 },
-	{ 749, 749 },
-	{ 751, 767 },
-	{ 885, 885 },
-	{ 900, 901 },
-	{ 2184, 2184 },
-	{ 8125, 8125 },
-	{ 8127, 8129 },
-	{ 8141, 8143 },
-	{ 8157, 8159 },
-	{ 8173, 8175 },
-	{ 8189, 8190 },
-	{ 12443, 12444 },
-	{ 42752, 42774 },
-	{ 42784, 42785 },
-	{ 42889, 42890 },
-	{ 43867, 43867 },
-	{ 43882, 43883 },
-	{ 64434, 64450 },
-	{ 65342, 65342 },
-	{ 65344, 65344 },
-	{ 65507, 65507 },
-};
-static const URange32 Sk_range32[] = {
-	{ 127995, 127999 },
-};
-static const URange16 Sm_range16[] = {
-	{ 43, 43 },
-	{ 60, 62 },
-	{ 124, 124 },
-	{ 126, 126 },
-	{ 172, 172 },
-	{ 177, 177 },
-	{ 215, 215 },
-	{ 247, 247 },
-	{ 1014, 1014 },
-	{ 1542, 1544 },
-	{ 8260, 8260 },
-	{ 8274, 8274 },
-	{ 8314, 8316 },
-	{ 8330, 8332 },
-	{ 8472, 8472 },
-	{ 8512, 8516 },
-	{ 8523, 8523 },
-	{ 8592, 8596 },
-	{ 8602, 8603 },
-	{ 8608, 8608 },
-	{ 8611, 8611 },
-	{ 8614, 8614 },
-	{ 8622, 8622 },
-	{ 8654, 8655 },
-	{ 8658, 8658 },
-	{ 8660, 8660 },
-	{ 8692, 8959 },
-	{ 8992, 8993 },
-	{ 9084, 9084 },
-	{ 9115, 9139 },
-	{ 9180, 9185 },
-	{ 9655, 9655 },
-	{ 9665, 9665 },
-	{ 9720, 9727 },
-	{ 9839, 9839 },
-	{ 10176, 10180 },
-	{ 10183, 10213 },
-	{ 10224, 10239 },
-	{ 10496, 10626 },
-	{ 10649, 10711 },
-	{ 10716, 10747 },
-	{ 10750, 11007 },
-	{ 11056, 11076 },
-	{ 11079, 11084 },
-	{ 64297, 64297 },
-	{ 65122, 65122 },
-	{ 65124, 65126 },
-	{ 65291, 65291 },
-	{ 65308, 65310 },
-	{ 65372, 65372 },
-	{ 65374, 65374 },
-	{ 65506, 65506 },
-	{ 65513, 65516 },
-};
-static const URange32 Sm_range32[] = {
-	{ 120513, 120513 },
-	{ 120539, 120539 },
-	{ 120571, 120571 },
-	{ 120597, 120597 },
-	{ 120629, 120629 },
-	{ 120655, 120655 },
-	{ 120687, 120687 },
-	{ 120713, 120713 },
-	{ 120745, 120745 },
-	{ 120771, 120771 },
-	{ 126704, 126705 },
-};
-static const URange16 So_range16[] = {
-	{ 166, 166 },
-	{ 169, 169 },
-	{ 174, 174 },
-	{ 176, 176 },
-	{ 1154, 1154 },
-	{ 1421, 1422 },
-	{ 1550, 1551 },
-	{ 1758, 1758 },
-	{ 1769, 1769 },
-	{ 1789, 1790 },
-	{ 2038, 2038 },
-	{ 2554, 2554 },
-	{ 2928, 2928 },
-	{ 3059, 3064 },
-	{ 3066, 3066 },
-	{ 3199, 3199 },
-	{ 3407, 3407 },
-	{ 3449, 3449 },
-	{ 3841, 3843 },
-	{ 3859, 3859 },
-	{ 3861, 3863 },
-	{ 3866, 3871 },
-	{ 3892, 3892 },
-	{ 3894, 3894 },
-	{ 3896, 3896 },
-	{ 4030, 4037 },
-	{ 4039, 4044 },
-	{ 4046, 4047 },
-	{ 4053, 4056 },
-	{ 4254, 4255 },
-	{ 5008, 5017 },
-	{ 5741, 5741 },
-	{ 6464, 6464 },
-	{ 6622, 6655 },
-	{ 7009, 7018 },
-	{ 7028, 7036 },
-	{ 8448, 8449 },
-	{ 8451, 8454 },
-	{ 8456, 8457 },
-	{ 8468, 8468 },
-	{ 8470, 8471 },
-	{ 8478, 8483 },
-	{ 8485, 8485 },
-	{ 8487, 8487 },
-	{ 8489, 8489 },
-	{ 8494, 8494 },
-	{ 8506, 8507 },
-	{ 8522, 8522 },
-	{ 8524, 8525 },
-	{ 8527, 8527 },
-	{ 8586, 8587 },
-	{ 8597, 8601 },
-	{ 8604, 8607 },
-	{ 8609, 8610 },
-	{ 8612, 8613 },
-	{ 8615, 8621 },
-	{ 8623, 8653 },
-	{ 8656, 8657 },
-	{ 8659, 8659 },
-	{ 8661, 8691 },
-	{ 8960, 8967 },
-	{ 8972, 8991 },
-	{ 8994, 9000 },
-	{ 9003, 9083 },
-	{ 9085, 9114 },
-	{ 9140, 9179 },
-	{ 9186, 9254 },
-	{ 9280, 9290 },
-	{ 9372, 9449 },
-	{ 9472, 9654 },
-	{ 9656, 9664 },
-	{ 9666, 9719 },
-	{ 9728, 9838 },
-	{ 9840, 10087 },
-	{ 10132, 10175 },
-	{ 10240, 10495 },
-	{ 11008, 11055 },
-	{ 11077, 11078 },
-	{ 11085, 11123 },
-	{ 11126, 11157 },
-	{ 11159, 11263 },
-	{ 11493, 11498 },
-	{ 11856, 11857 },
-	{ 11904, 11929 },
-	{ 11931, 12019 },
-	{ 12032, 12245 },
-	{ 12272, 12283 },
-	{ 12292, 12292 },
-	{ 12306, 12307 },
-	{ 12320, 12320 },
-	{ 12342, 12343 },
-	{ 12350, 12351 },
-	{ 12688, 12689 },
-	{ 12694, 12703 },
-	{ 12736, 12771 },
-	{ 12800, 12830 },
-	{ 12842, 12871 },
-	{ 12880, 12880 },
-	{ 12896, 12927 },
-	{ 12938, 12976 },
-	{ 12992, 13311 },
-	{ 19904, 19967 },
-	{ 42128, 42182 },
-	{ 43048, 43051 },
-	{ 43062, 43063 },
-	{ 43065, 43065 },
-	{ 43639, 43641 },
-	{ 64832, 64847 },
-	{ 64975, 64975 },
-	{ 65021, 65023 },
-	{ 65508, 65508 },
-	{ 65512, 65512 },
-	{ 65517, 65518 },
-	{ 65532, 65533 },
-};
-static const URange32 So_range32[] = {
-	{ 65847, 65855 },
-	{ 65913, 65929 },
-	{ 65932, 65934 },
-	{ 65936, 65948 },
-	{ 65952, 65952 },
-	{ 66000, 66044 },
-	{ 67703, 67704 },
-	{ 68296, 68296 },
-	{ 71487, 71487 },
-	{ 73685, 73692 },
-	{ 73697, 73713 },
-	{ 92988, 92991 },
-	{ 92997, 92997 },
-	{ 113820, 113820 },
-	{ 118608, 118723 },
-	{ 118784, 119029 },
-	{ 119040, 119078 },
-	{ 119081, 119140 },
-	{ 119146, 119148 },
-	{ 119171, 119172 },
-	{ 119180, 119209 },
-	{ 119214, 119274 },
-	{ 119296, 119361 },
-	{ 119365, 119365 },
-	{ 119552, 119638 },
-	{ 120832, 121343 },
-	{ 121399, 121402 },
-	{ 121453, 121460 },
-	{ 121462, 121475 },
-	{ 121477, 121478 },
-	{ 123215, 123215 },
-	{ 126124, 126124 },
-	{ 126254, 126254 },
-	{ 126976, 127019 },
-	{ 127024, 127123 },
-	{ 127136, 127150 },
-	{ 127153, 127167 },
-	{ 127169, 127183 },
-	{ 127185, 127221 },
-	{ 127245, 127405 },
-	{ 127462, 127490 },
-	{ 127504, 127547 },
-	{ 127552, 127560 },
-	{ 127568, 127569 },
-	{ 127584, 127589 },
-	{ 127744, 127994 },
-	{ 128000, 128727 },
-	{ 128732, 128748 },
-	{ 128752, 128764 },
-	{ 128768, 128886 },
-	{ 128891, 128985 },
-	{ 128992, 129003 },
-	{ 129008, 129008 },
-	{ 129024, 129035 },
-	{ 129040, 129095 },
-	{ 129104, 129113 },
-	{ 129120, 129159 },
-	{ 129168, 129197 },
-	{ 129200, 129201 },
-	{ 129280, 129619 },
-	{ 129632, 129645 },
-	{ 129648, 129660 },
-	{ 129664, 129672 },
-	{ 129680, 129725 },
-	{ 129727, 129733 },
-	{ 129742, 129755 },
-	{ 129760, 129768 },
-	{ 129776, 129784 },
-	{ 129792, 129938 },
-	{ 129940, 129994 },
-};
-static const URange16 Z_range16[] = {
-	{ 32, 32 },
-	{ 160, 160 },
-	{ 5760, 5760 },
-	{ 8192, 8202 },
-	{ 8232, 8233 },
-	{ 8239, 8239 },
-	{ 8287, 8287 },
-	{ 12288, 12288 },
-};
-static const URange16 Zl_range16[] = {
-	{ 8232, 8232 },
-};
-static const URange16 Zp_range16[] = {
-	{ 8233, 8233 },
-};
-static const URange16 Zs_range16[] = {
-	{ 32, 32 },
-	{ 160, 160 },
-	{ 5760, 5760 },
-	{ 8192, 8202 },
-	{ 8239, 8239 },
-	{ 8287, 8287 },
-	{ 12288, 12288 },
-};
-static const URange32 Adlam_range32[] = {
-	{ 125184, 125259 },
-	{ 125264, 125273 },
-	{ 125278, 125279 },
-};
-static const URange32 Ahom_range32[] = {
-	{ 71424, 71450 },
-	{ 71453, 71467 },
-	{ 71472, 71494 },
-};
-static const URange32 Anatolian_Hieroglyphs_range32[] = {
-	{ 82944, 83526 },
-};
-static const URange16 Arabic_range16[] = {
-	{ 1536, 1540 },
-	{ 1542, 1547 },
-	{ 1549, 1562 },
-	{ 1564, 1566 },
-	{ 1568, 1599 },
-	{ 1601, 1610 },
-	{ 1622, 1647 },
-	{ 1649, 1756 },
-	{ 1758, 1791 },
-	{ 1872, 1919 },
-	{ 2160, 2190 },
-	{ 2192, 2193 },
-	{ 2200, 2273 },
-	{ 2275, 2303 },
-	{ 64336, 64450 },
-	{ 64467, 64829 },
-	{ 64832, 64911 },
-	{ 64914, 64967 },
-	{ 64975, 64975 },
-	{ 65008, 65023 },
-	{ 65136, 65140 },
-	{ 65142, 65276 },
-};
-static const URange32 Arabic_range32[] = {
-	{ 69216, 69246 },
-	{ 69373, 69375 },
-	{ 126464, 126467 },
-	{ 126469, 126495 },
-	{ 126497, 126498 },
-	{ 126500, 126500 },
-	{ 126503, 126503 },
-	{ 126505, 126514 },
-	{ 126516, 126519 },
-	{ 126521, 126521 },
-	{ 126523, 126523 },
-	{ 126530, 126530 },
-	{ 126535, 126535 },
-	{ 126537, 126537 },
-	{ 126539, 126539 },
-	{ 126541, 126543 },
-	{ 126545, 126546 },
-	{ 126548, 126548 },
-	{ 126551, 126551 },
-	{ 126553, 126553 },
-	{ 126555, 126555 },
-	{ 126557, 126557 },
-	{ 126559, 126559 },
-	{ 126561, 126562 },
-	{ 126564, 126564 },
-	{ 126567, 126570 },
-	{ 126572, 126578 },
-	{ 126580, 126583 },
-	{ 126585, 126588 },
-	{ 126590, 126590 },
-	{ 126592, 126601 },
-	{ 126603, 126619 },
-	{ 126625, 126627 },
-	{ 126629, 126633 },
-	{ 126635, 126651 },
-	{ 126704, 126705 },
-};
-static const URange16 Armenian_range16[] = {
-	{ 1329, 1366 },
-	{ 1369, 1418 },
-	{ 1421, 1423 },
-	{ 64275, 64279 },
-};
-static const URange32 Avestan_range32[] = {
-	{ 68352, 68405 },
-	{ 68409, 68415 },
-};
-static const URange16 Balinese_range16[] = {
-	{ 6912, 6988 },
-	{ 6992, 7038 },
-};
-static const URange16 Bamum_range16[] = {
-	{ 42656, 42743 },
-};
-static const URange32 Bamum_range32[] = {
-	{ 92160, 92728 },
-};
-static const URange32 Bassa_Vah_range32[] = {
-	{ 92880, 92909 },
-	{ 92912, 92917 },
-};
-static const URange16 Batak_range16[] = {
-	{ 7104, 7155 },
-	{ 7164, 7167 },
-};
-static const URange16 Bengali_range16[] = {
-	{ 2432, 2435 },
-	{ 2437, 2444 },
-	{ 2447, 2448 },
-	{ 2451, 2472 },
-	{ 2474, 2480 },
-	{ 2482, 2482 },
-	{ 2486, 2489 },
-	{ 2492, 2500 },
-	{ 2503, 2504 },
-	{ 2507, 2510 },
-	{ 2519, 2519 },
-	{ 2524, 2525 },
-	{ 2527, 2531 },
-	{ 2534, 2558 },
-};
-static const URange32 Bhaiksuki_range32[] = {
-	{ 72704, 72712 },
-	{ 72714, 72758 },
-	{ 72760, 72773 },
-	{ 72784, 72812 },
-};
-static const URange16 Bopomofo_range16[] = {
-	{ 746, 747 },
-	{ 12549, 12591 },
-	{ 12704, 12735 },
-};
-static const URange32 Brahmi_range32[] = {
-	{ 69632, 69709 },
-	{ 69714, 69749 },
-	{ 69759, 69759 },
-};
-static const URange16 Braille_range16[] = {
-	{ 10240, 10495 },
-};
-static const URange16 Buginese_range16[] = {
-	{ 6656, 6683 },
-	{ 6686, 6687 },
-};
-static const URange16 Buhid_range16[] = {
-	{ 5952, 5971 },
-};
-static const URange16 Canadian_Aboriginal_range16[] = {
-	{ 5120, 5759 },
-	{ 6320, 6389 },
-};
-static const URange32 Canadian_Aboriginal_range32[] = {
-	{ 72368, 72383 },
-};
-static const URange32 Carian_range32[] = {
-	{ 66208, 66256 },
-};
-static const URange32 Caucasian_Albanian_range32[] = {
-	{ 66864, 66915 },
-	{ 66927, 66927 },
-};
-static const URange32 Chakma_range32[] = {
-	{ 69888, 69940 },
-	{ 69942, 69959 },
-};
-static const URange16 Cham_range16[] = {
-	{ 43520, 43574 },
-	{ 43584, 43597 },
-	{ 43600, 43609 },
-	{ 43612, 43615 },
-};
-static const URange16 Cherokee_range16[] = {
-	{ 5024, 5109 },
-	{ 5112, 5117 },
-	{ 43888, 43967 },
-};
-static const URange32 Chorasmian_range32[] = {
-	{ 69552, 69579 },
-};
-static const URange16 Common_range16[] = {
-	{ 0, 64 },
-	{ 91, 96 },
-	{ 123, 169 },
-	{ 171, 185 },
-	{ 187, 191 },
-	{ 215, 215 },
-	{ 247, 247 },
-	{ 697, 735 },
-	{ 741, 745 },
-	{ 748, 767 },
-	{ 884, 884 },
-	{ 894, 894 },
-	{ 901, 901 },
-	{ 903, 903 },
-	{ 1541, 1541 },
-	{ 1548, 1548 },
-	{ 1563, 1563 },
-	{ 1567, 1567 },
-	{ 1600, 1600 },
-	{ 1757, 1757 },
-	{ 2274, 2274 },
-	{ 2404, 2405 },
-	{ 3647, 3647 },
-	{ 4053, 4056 },
-	{ 4347, 4347 },
-	{ 5867, 5869 },
-	{ 5941, 5942 },
-	{ 6146, 6147 },
-	{ 6149, 6149 },
-	{ 7379, 7379 },
-	{ 7393, 7393 },
-	{ 7401, 7404 },
-	{ 7406, 7411 },
-	{ 7413, 7415 },
-	{ 7418, 7418 },
-	{ 8192, 8203 },
-	{ 8206, 8292 },
-	{ 8294, 8304 },
-	{ 8308, 8318 },
-	{ 8320, 8334 },
-	{ 8352, 8384 },
-	{ 8448, 8485 },
-	{ 8487, 8489 },
-	{ 8492, 8497 },
-	{ 8499, 8525 },
-	{ 8527, 8543 },
-	{ 8585, 8587 },
-	{ 8592, 9254 },
-	{ 9280, 9290 },
-	{ 9312, 10239 },
-	{ 10496, 11123 },
-	{ 11126, 11157 },
-	{ 11159, 11263 },
-	{ 11776, 11869 },
-	{ 12272, 12283 },
-	{ 12288, 12292 },
-	{ 12294, 12294 },
-	{ 12296, 12320 },
-	{ 12336, 12343 },
-	{ 12348, 12351 },
-	{ 12443, 12444 },
-	{ 12448, 12448 },
-	{ 12539, 12540 },
-	{ 12688, 12703 },
-	{ 12736, 12771 },
-	{ 12832, 12895 },
-	{ 12927, 13007 },
-	{ 13055, 13055 },
-	{ 13144, 13311 },
-	{ 19904, 19967 },
-	{ 42752, 42785 },
-	{ 42888, 42890 },
-	{ 43056, 43065 },
-	{ 43310, 43310 },
-	{ 43471, 43471 },
-	{ 43867, 43867 },
-	{ 43882, 43883 },
-	{ 64830, 64831 },
-	{ 65040, 65049 },
-	{ 65072, 65106 },
-	{ 65108, 65126 },
-	{ 65128, 65131 },
-	{ 65279, 65279 },
-	{ 65281, 65312 },
-	{ 65339, 65344 },
-	{ 65371, 65381 },
-	{ 65392, 65392 },
-	{ 65438, 65439 },
-	{ 65504, 65510 },
-	{ 65512, 65518 },
-	{ 65529, 65533 },
-};
-static const URange32 Common_range32[] = {
-	{ 65792, 65794 },
-	{ 65799, 65843 },
-	{ 65847, 65855 },
-	{ 65936, 65948 },
-	{ 66000, 66044 },
-	{ 66273, 66299 },
-	{ 113824, 113827 },
-	{ 118608, 118723 },
-	{ 118784, 119029 },
-	{ 119040, 119078 },
-	{ 119081, 119142 },
-	{ 119146, 119162 },
-	{ 119171, 119172 },
-	{ 119180, 119209 },
-	{ 119214, 119274 },
-	{ 119488, 119507 },
-	{ 119520, 119539 },
-	{ 119552, 119638 },
-	{ 119648, 119672 },
-	{ 119808, 119892 },
-	{ 119894, 119964 },
-	{ 119966, 119967 },
-	{ 119970, 119970 },
-	{ 119973, 119974 },
-	{ 119977, 119980 },
-	{ 119982, 119993 },
-	{ 119995, 119995 },
-	{ 119997, 120003 },
-	{ 120005, 120069 },
-	{ 120071, 120074 },
-	{ 120077, 120084 },
-	{ 120086, 120092 },
-	{ 120094, 120121 },
-	{ 120123, 120126 },
-	{ 120128, 120132 },
-	{ 120134, 120134 },
-	{ 120138, 120144 },
-	{ 120146, 120485 },
-	{ 120488, 120779 },
-	{ 120782, 120831 },
-	{ 126065, 126132 },
-	{ 126209, 126269 },
-	{ 126976, 127019 },
-	{ 127024, 127123 },
-	{ 127136, 127150 },
-	{ 127153, 127167 },
-	{ 127169, 127183 },
-	{ 127185, 127221 },
-	{ 127232, 127405 },
-	{ 127462, 127487 },
-	{ 127489, 127490 },
-	{ 127504, 127547 },
-	{ 127552, 127560 },
-	{ 127568, 127569 },
-	{ 127584, 127589 },
-	{ 127744, 128727 },
-	{ 128732, 128748 },
-	{ 128752, 128764 },
-	{ 128768, 128886 },
-	{ 128891, 128985 },
-	{ 128992, 129003 },
-	{ 129008, 129008 },
-	{ 129024, 129035 },
-	{ 129040, 129095 },
-	{ 129104, 129113 },
-	{ 129120, 129159 },
-	{ 129168, 129197 },
-	{ 129200, 129201 },
-	{ 129280, 129619 },
-	{ 129632, 129645 },
-	{ 129648, 129660 },
-	{ 129664, 129672 },
-	{ 129680, 129725 },
-	{ 129727, 129733 },
-	{ 129742, 129755 },
-	{ 129760, 129768 },
-	{ 129776, 129784 },
-	{ 129792, 129938 },
-	{ 129940, 129994 },
-	{ 130032, 130041 },
-	{ 917505, 917505 },
-	{ 917536, 917631 },
-};
-static const URange16 Coptic_range16[] = {
-	{ 994, 1007 },
-	{ 11392, 11507 },
-	{ 11513, 11519 },
-};
-static const URange32 Cuneiform_range32[] = {
-	{ 73728, 74649 },
-	{ 74752, 74862 },
-	{ 74864, 74868 },
-	{ 74880, 75075 },
-};
-static const URange32 Cypriot_range32[] = {
-	{ 67584, 67589 },
-	{ 67592, 67592 },
-	{ 67594, 67637 },
-	{ 67639, 67640 },
-	{ 67644, 67644 },
-	{ 67647, 67647 },
-};
-static const URange32 Cypro_Minoan_range32[] = {
-	{ 77712, 77810 },
-};
-static const URange16 Cyrillic_range16[] = {
-	{ 1024, 1156 },
-	{ 1159, 1327 },
-	{ 7296, 7304 },
-	{ 7467, 7467 },
-	{ 7544, 7544 },
-	{ 11744, 11775 },
-	{ 42560, 42655 },
-	{ 65070, 65071 },
-};
-static const URange32 Cyrillic_range32[] = {
-	{ 122928, 122989 },
-	{ 123023, 123023 },
-};
-static const URange32 Deseret_range32[] = {
-	{ 66560, 66639 },
-};
-static const URange16 Devanagari_range16[] = {
-	{ 2304, 2384 },
-	{ 2389, 2403 },
-	{ 2406, 2431 },
-	{ 43232, 43263 },
-};
-static const URange32 Devanagari_range32[] = {
-	{ 72448, 72457 },
-};
-static const URange32 Dives_Akuru_range32[] = {
-	{ 71936, 71942 },
-	{ 71945, 71945 },
-	{ 71948, 71955 },
-	{ 71957, 71958 },
-	{ 71960, 71989 },
-	{ 71991, 71992 },
-	{ 71995, 72006 },
-	{ 72016, 72025 },
-};
-static const URange32 Dogra_range32[] = {
-	{ 71680, 71739 },
-};
-static const URange32 Duployan_range32[] = {
-	{ 113664, 113770 },
-	{ 113776, 113788 },
-	{ 113792, 113800 },
-	{ 113808, 113817 },
-	{ 113820, 113823 },
-};
-static const URange32 Egyptian_Hieroglyphs_range32[] = {
-	{ 77824, 78933 },
-};
-static const URange32 Elbasan_range32[] = {
-	{ 66816, 66855 },
-};
-static const URange32 Elymaic_range32[] = {
-	{ 69600, 69622 },
-};
-static const URange16 Ethiopic_range16[] = {
-	{ 4608, 4680 },
-	{ 4682, 4685 },
-	{ 4688, 4694 },
-	{ 4696, 4696 },
-	{ 4698, 4701 },
-	{ 4704, 4744 },
-	{ 4746, 4749 },
-	{ 4752, 4784 },
-	{ 4786, 4789 },
-	{ 4792, 4798 },
-	{ 4800, 4800 },
-	{ 4802, 4805 },
-	{ 4808, 4822 },
-	{ 4824, 4880 },
-	{ 4882, 4885 },
-	{ 4888, 4954 },
-	{ 4957, 4988 },
-	{ 4992, 5017 },
-	{ 11648, 11670 },
-	{ 11680, 11686 },
-	{ 11688, 11694 },
-	{ 11696, 11702 },
-	{ 11704, 11710 },
-	{ 11712, 11718 },
-	{ 11720, 11726 },
-	{ 11728, 11734 },
-	{ 11736, 11742 },
-	{ 43777, 43782 },
-	{ 43785, 43790 },
-	{ 43793, 43798 },
-	{ 43808, 43814 },
-	{ 43816, 43822 },
-};
-static const URange32 Ethiopic_range32[] = {
-	{ 124896, 124902 },
-	{ 124904, 124907 },
-	{ 124909, 124910 },
-	{ 124912, 124926 },
-};
-static const URange16 Georgian_range16[] = {
-	{ 4256, 4293 },
-	{ 4295, 4295 },
-	{ 4301, 4301 },
-	{ 4304, 4346 },
-	{ 4348, 4351 },
-	{ 7312, 7354 },
-	{ 7357, 7359 },
-	{ 11520, 11557 },
-	{ 11559, 11559 },
-	{ 11565, 11565 },
-};
-static const URange16 Glagolitic_range16[] = {
-	{ 11264, 11359 },
-};
-static const URange32 Glagolitic_range32[] = {
-	{ 122880, 122886 },
-	{ 122888, 122904 },
-	{ 122907, 122913 },
-	{ 122915, 122916 },
-	{ 122918, 122922 },
-};
-static const URange32 Gothic_range32[] = {
-	{ 66352, 66378 },
-};
-static const URange32 Grantha_range32[] = {
-	{ 70400, 70403 },
-	{ 70405, 70412 },
-	{ 70415, 70416 },
-	{ 70419, 70440 },
-	{ 70442, 70448 },
-	{ 70450, 70451 },
-	{ 70453, 70457 },
-	{ 70460, 70468 },
-	{ 70471, 70472 },
-	{ 70475, 70477 },
-	{ 70480, 70480 },
-	{ 70487, 70487 },
-	{ 70493, 70499 },
-	{ 70502, 70508 },
-	{ 70512, 70516 },
-};
-static const URange16 Greek_range16[] = {
-	{ 880, 883 },
-	{ 885, 887 },
-	{ 890, 893 },
-	{ 895, 895 },
-	{ 900, 900 },
-	{ 902, 902 },
-	{ 904, 906 },
-	{ 908, 908 },
-	{ 910, 929 },
-	{ 931, 993 },
-	{ 1008, 1023 },
-	{ 7462, 7466 },
-	{ 7517, 7521 },
-	{ 7526, 7530 },
-	{ 7615, 7615 },
-	{ 7936, 7957 },
-	{ 7960, 7965 },
-	{ 7968, 8005 },
-	{ 8008, 8013 },
-	{ 8016, 8023 },
-	{ 8025, 8025 },
-	{ 8027, 8027 },
-	{ 8029, 8029 },
-	{ 8031, 8061 },
-	{ 8064, 8116 },
-	{ 8118, 8132 },
-	{ 8134, 8147 },
-	{ 8150, 8155 },
-	{ 8157, 8175 },
-	{ 8178, 8180 },
-	{ 8182, 8190 },
-	{ 8486, 8486 },
-	{ 43877, 43877 },
-};
-static const URange32 Greek_range32[] = {
-	{ 65856, 65934 },
-	{ 65952, 65952 },
-	{ 119296, 119365 },
-};
-static const URange16 Gujarati_range16[] = {
-	{ 2689, 2691 },
-	{ 2693, 2701 },
-	{ 2703, 2705 },
-	{ 2707, 2728 },
-	{ 2730, 2736 },
-	{ 2738, 2739 },
-	{ 2741, 2745 },
-	{ 2748, 2757 },
-	{ 2759, 2761 },
-	{ 2763, 2765 },
-	{ 2768, 2768 },
-	{ 2784, 2787 },
-	{ 2790, 2801 },
-	{ 2809, 2815 },
-};
-static const URange32 Gunjala_Gondi_range32[] = {
-	{ 73056, 73061 },
-	{ 73063, 73064 },
-	{ 73066, 73102 },
-	{ 73104, 73105 },
-	{ 73107, 73112 },
-	{ 73120, 73129 },
-};
-static const URange16 Gurmukhi_range16[] = {
-	{ 2561, 2563 },
-	{ 2565, 2570 },
-	{ 2575, 2576 },
-	{ 2579, 2600 },
-	{ 2602, 2608 },
-	{ 2610, 2611 },
-	{ 2613, 2614 },
-	{ 2616, 2617 },
-	{ 2620, 2620 },
-	{ 2622, 2626 },
-	{ 2631, 2632 },
-	{ 2635, 2637 },
-	{ 2641, 2641 },
-	{ 2649, 2652 },
-	{ 2654, 2654 },
-	{ 2662, 2678 },
-};
-static const URange16 Han_range16[] = {
-	{ 11904, 11929 },
-	{ 11931, 12019 },
-	{ 12032, 12245 },
-	{ 12293, 12293 },
-	{ 12295, 12295 },
-	{ 12321, 12329 },
-	{ 12344, 12347 },
-	{ 13312, 19903 },
-	{ 19968, 40959 },
-	{ 63744, 64109 },
-	{ 64112, 64217 },
-};
-static const URange32 Han_range32[] = {
-	{ 94178, 94179 },
-	{ 94192, 94193 },
-	{ 131072, 173791 },
-	{ 173824, 177977 },
-	{ 177984, 178205 },
-	{ 178208, 183969 },
-	{ 183984, 191456 },
-	{ 194560, 195101 },
-	{ 196608, 201546 },
-	{ 201552, 205743 },
-};
-static const URange16 Hangul_range16[] = {
-	{ 4352, 4607 },
-	{ 12334, 12335 },
-	{ 12593, 12686 },
-	{ 12800, 12830 },
-	{ 12896, 12926 },
-	{ 43360, 43388 },
-	{ 44032, 55203 },
-	{ 55216, 55238 },
-	{ 55243, 55291 },
-	{ 65440, 65470 },
-	{ 65474, 65479 },
-	{ 65482, 65487 },
-	{ 65490, 65495 },
-	{ 65498, 65500 },
-};
-static const URange32 Hanifi_Rohingya_range32[] = {
-	{ 68864, 68903 },
-	{ 68912, 68921 },
-};
-static const URange16 Hanunoo_range16[] = {
-	{ 5920, 5940 },
-};
-static const URange32 Hatran_range32[] = {
-	{ 67808, 67826 },
-	{ 67828, 67829 },
-	{ 67835, 67839 },
-};
-static const URange16 Hebrew_range16[] = {
-	{ 1425, 1479 },
-	{ 1488, 1514 },
-	{ 1519, 1524 },
-	{ 64285, 64310 },
-	{ 64312, 64316 },
-	{ 64318, 64318 },
-	{ 64320, 64321 },
-	{ 64323, 64324 },
-	{ 64326, 64335 },
-};
-static const URange16 Hiragana_range16[] = {
-	{ 12353, 12438 },
-	{ 12445, 12447 },
-};
-static const URange32 Hiragana_range32[] = {
-	{ 110593, 110879 },
-	{ 110898, 110898 },
-	{ 110928, 110930 },
-	{ 127488, 127488 },
-};
-static const URange32 Imperial_Aramaic_range32[] = {
-	{ 67648, 67669 },
-	{ 67671, 67679 },
-};
-static const URange16 Inherited_range16[] = {
-	{ 768, 879 },
-	{ 1157, 1158 },
-	{ 1611, 1621 },
-	{ 1648, 1648 },
-	{ 2385, 2388 },
-	{ 6832, 6862 },
-	{ 7376, 7378 },
-	{ 7380, 7392 },
-	{ 7394, 7400 },
-	{ 7405, 7405 },
-	{ 7412, 7412 },
-	{ 7416, 7417 },
-	{ 7616, 7679 },
-	{ 8204, 8205 },
-	{ 8400, 8432 },
-	{ 12330, 12333 },
-	{ 12441, 12442 },
-	{ 65024, 65039 },
-	{ 65056, 65069 },
-};
-static const URange32 Inherited_range32[] = {
-	{ 66045, 66045 },
-	{ 66272, 66272 },
-	{ 70459, 70459 },
-	{ 118528, 118573 },
-	{ 118576, 118598 },
-	{ 119143, 119145 },
-	{ 119163, 119170 },
-	{ 119173, 119179 },
-	{ 119210, 119213 },
-	{ 917760, 917999 },
-};
-static const URange32 Inscriptional_Pahlavi_range32[] = {
-	{ 68448, 68466 },
-	{ 68472, 68479 },
-};
-static const URange32 Inscriptional_Parthian_range32[] = {
-	{ 68416, 68437 },
-	{ 68440, 68447 },
-};
-static const URange16 Javanese_range16[] = {
-	{ 43392, 43469 },
-	{ 43472, 43481 },
-	{ 43486, 43487 },
-};
-static const URange32 Kaithi_range32[] = {
-	{ 69760, 69826 },
-	{ 69837, 69837 },
-};
-static const URange16 Kannada_range16[] = {
-	{ 3200, 3212 },
-	{ 3214, 3216 },
-	{ 3218, 3240 },
-	{ 3242, 3251 },
-	{ 3253, 3257 },
-	{ 3260, 3268 },
-	{ 3270, 3272 },
-	{ 3274, 3277 },
-	{ 3285, 3286 },
-	{ 3293, 3294 },
-	{ 3296, 3299 },
-	{ 3302, 3311 },
-	{ 3313, 3315 },
-};
-static const URange16 Katakana_range16[] = {
-	{ 12449, 12538 },
-	{ 12541, 12543 },
-	{ 12784, 12799 },
-	{ 13008, 13054 },
-	{ 13056, 13143 },
-	{ 65382, 65391 },
-	{ 65393, 65437 },
-};
-static const URange32 Katakana_range32[] = {
-	{ 110576, 110579 },
-	{ 110581, 110587 },
-	{ 110589, 110590 },
-	{ 110592, 110592 },
-	{ 110880, 110882 },
-	{ 110933, 110933 },
-	{ 110948, 110951 },
-};
-static const URange32 Kawi_range32[] = {
-	{ 73472, 73488 },
-	{ 73490, 73530 },
-	{ 73534, 73561 },
-};
-static const URange16 Kayah_Li_range16[] = {
-	{ 43264, 43309 },
-	{ 43311, 43311 },
-};
-static const URange32 Kharoshthi_range32[] = {
-	{ 68096, 68099 },
-	{ 68101, 68102 },
-	{ 68108, 68115 },
-	{ 68117, 68119 },
-	{ 68121, 68149 },
-	{ 68152, 68154 },
-	{ 68159, 68168 },
-	{ 68176, 68184 },
-};
-static const URange32 Khitan_Small_Script_range32[] = {
-	{ 94180, 94180 },
-	{ 101120, 101589 },
-};
-static const URange16 Khmer_range16[] = {
-	{ 6016, 6109 },
-	{ 6112, 6121 },
-	{ 6128, 6137 },
-	{ 6624, 6655 },
-};
-static const URange32 Khojki_range32[] = {
-	{ 70144, 70161 },
-	{ 70163, 70209 },
-};
-static const URange32 Khudawadi_range32[] = {
-	{ 70320, 70378 },
-	{ 70384, 70393 },
-};
-static const URange16 Lao_range16[] = {
-	{ 3713, 3714 },
-	{ 3716, 3716 },
-	{ 3718, 3722 },
-	{ 3724, 3747 },
-	{ 3749, 3749 },
-	{ 3751, 3773 },
-	{ 3776, 3780 },
-	{ 3782, 3782 },
-	{ 3784, 3790 },
-	{ 3792, 3801 },
-	{ 3804, 3807 },
-};
-static const URange16 Latin_range16[] = {
-	{ 65, 90 },
-	{ 97, 122 },
-	{ 170, 170 },
-	{ 186, 186 },
-	{ 192, 214 },
-	{ 216, 246 },
-	{ 248, 696 },
-	{ 736, 740 },
-	{ 7424, 7461 },
-	{ 7468, 7516 },
-	{ 7522, 7525 },
-	{ 7531, 7543 },
-	{ 7545, 7614 },
-	{ 7680, 7935 },
-	{ 8305, 8305 },
-	{ 8319, 8319 },
-	{ 8336, 8348 },
-	{ 8490, 8491 },
-	{ 8498, 8498 },
-	{ 8526, 8526 },
-	{ 8544, 8584 },
-	{ 11360, 11391 },
-	{ 42786, 42887 },
-	{ 42891, 42954 },
-	{ 42960, 42961 },
-	{ 42963, 42963 },
-	{ 42965, 42969 },
-	{ 42994, 43007 },
-	{ 43824, 43866 },
-	{ 43868, 43876 },
-	{ 43878, 43881 },
-	{ 64256, 64262 },
-	{ 65313, 65338 },
-	{ 65345, 65370 },
-};
-static const URange32 Latin_range32[] = {
-	{ 67456, 67461 },
-	{ 67463, 67504 },
-	{ 67506, 67514 },
-	{ 122624, 122654 },
-	{ 122661, 122666 },
-};
-static const URange16 Lepcha_range16[] = {
-	{ 7168, 7223 },
-	{ 7227, 7241 },
-	{ 7245, 7247 },
-};
-static const URange16 Limbu_range16[] = {
-	{ 6400, 6430 },
-	{ 6432, 6443 },
-	{ 6448, 6459 },
-	{ 6464, 6464 },
-	{ 6468, 6479 },
-};
-static const URange32 Linear_A_range32[] = {
-	{ 67072, 67382 },
-	{ 67392, 67413 },
-	{ 67424, 67431 },
-};
-static const URange32 Linear_B_range32[] = {
-	{ 65536, 65547 },
-	{ 65549, 65574 },
-	{ 65576, 65594 },
-	{ 65596, 65597 },
-	{ 65599, 65613 },
-	{ 65616, 65629 },
-	{ 65664, 65786 },
-};
-static const URange16 Lisu_range16[] = {
-	{ 42192, 42239 },
-};
-static const URange32 Lisu_range32[] = {
-	{ 73648, 73648 },
-};
-static const URange32 Lycian_range32[] = {
-	{ 66176, 66204 },
-};
-static const URange32 Lydian_range32[] = {
-	{ 67872, 67897 },
-	{ 67903, 67903 },
-};
-static const URange32 Mahajani_range32[] = {
-	{ 69968, 70006 },
-};
-static const URange32 Makasar_range32[] = {
-	{ 73440, 73464 },
-};
-static const URange16 Malayalam_range16[] = {
-	{ 3328, 3340 },
-	{ 3342, 3344 },
-	{ 3346, 3396 },
-	{ 3398, 3400 },
-	{ 3402, 3407 },
-	{ 3412, 3427 },
-	{ 3430, 3455 },
-};
-static const URange16 Mandaic_range16[] = {
-	{ 2112, 2139 },
-	{ 2142, 2142 },
-};
-static const URange32 Manichaean_range32[] = {
-	{ 68288, 68326 },
-	{ 68331, 68342 },
-};
-static const URange32 Marchen_range32[] = {
-	{ 72816, 72847 },
-	{ 72850, 72871 },
-	{ 72873, 72886 },
-};
-static const URange32 Masaram_Gondi_range32[] = {
-	{ 72960, 72966 },
-	{ 72968, 72969 },
-	{ 72971, 73014 },
-	{ 73018, 73018 },
-	{ 73020, 73021 },
-	{ 73023, 73031 },
-	{ 73040, 73049 },
-};
-static const URange32 Medefaidrin_range32[] = {
-	{ 93760, 93850 },
-};
-static const URange16 Meetei_Mayek_range16[] = {
-	{ 43744, 43766 },
-	{ 43968, 44013 },
-	{ 44016, 44025 },
-};
-static const URange32 Mende_Kikakui_range32[] = {
-	{ 124928, 125124 },
-	{ 125127, 125142 },
-};
-static const URange32 Meroitic_Cursive_range32[] = {
-	{ 68000, 68023 },
-	{ 68028, 68047 },
-	{ 68050, 68095 },
-};
-static const URange32 Meroitic_Hieroglyphs_range32[] = {
-	{ 67968, 67999 },
-};
-static const URange32 Miao_range32[] = {
-	{ 93952, 94026 },
-	{ 94031, 94087 },
-	{ 94095, 94111 },
-};
-static const URange32 Modi_range32[] = {
-	{ 71168, 71236 },
-	{ 71248, 71257 },
-};
-static const URange16 Mongolian_range16[] = {
-	{ 6144, 6145 },
-	{ 6148, 6148 },
-	{ 6150, 6169 },
-	{ 6176, 6264 },
-	{ 6272, 6314 },
-};
-static const URange32 Mongolian_range32[] = {
-	{ 71264, 71276 },
-};
-static const URange32 Mro_range32[] = {
-	{ 92736, 92766 },
-	{ 92768, 92777 },
-	{ 92782, 92783 },
-};
-static const URange32 Multani_range32[] = {
-	{ 70272, 70278 },
-	{ 70280, 70280 },
-	{ 70282, 70285 },
-	{ 70287, 70301 },
-	{ 70303, 70313 },
-};
-static const URange16 Myanmar_range16[] = {
-	{ 4096, 4255 },
-	{ 43488, 43518 },
-	{ 43616, 43647 },
-};
-static const URange32 Nabataean_range32[] = {
-	{ 67712, 67742 },
-	{ 67751, 67759 },
-};
-static const URange32 Nag_Mundari_range32[] = {
-	{ 124112, 124153 },
-};
-static const URange32 Nandinagari_range32[] = {
-	{ 72096, 72103 },
-	{ 72106, 72151 },
-	{ 72154, 72164 },
-};
-static const URange16 New_Tai_Lue_range16[] = {
-	{ 6528, 6571 },
-	{ 6576, 6601 },
-	{ 6608, 6618 },
-	{ 6622, 6623 },
-};
-static const URange32 Newa_range32[] = {
-	{ 70656, 70747 },
-	{ 70749, 70753 },
-};
-static const URange16 Nko_range16[] = {
-	{ 1984, 2042 },
-	{ 2045, 2047 },
-};
-static const URange32 Nushu_range32[] = {
-	{ 94177, 94177 },
-	{ 110960, 111355 },
-};
-static const URange32 Nyiakeng_Puachue_Hmong_range32[] = {
-	{ 123136, 123180 },
-	{ 123184, 123197 },
-	{ 123200, 123209 },
-	{ 123214, 123215 },
-};
-static const URange16 Ogham_range16[] = {
-	{ 5760, 5788 },
-};
-static const URange16 Ol_Chiki_range16[] = {
-	{ 7248, 7295 },
-};
-static const URange32 Old_Hungarian_range32[] = {
-	{ 68736, 68786 },
-	{ 68800, 68850 },
-	{ 68858, 68863 },
-};
-static const URange32 Old_Italic_range32[] = {
-	{ 66304, 66339 },
-	{ 66349, 66351 },
-};
-static const URange32 Old_North_Arabian_range32[] = {
-	{ 68224, 68255 },
-};
-static const URange32 Old_Permic_range32[] = {
-	{ 66384, 66426 },
-};
-static const URange32 Old_Persian_range32[] = {
-	{ 66464, 66499 },
-	{ 66504, 66517 },
-};
-static const URange32 Old_Sogdian_range32[] = {
-	{ 69376, 69415 },
-};
-static const URange32 Old_South_Arabian_range32[] = {
-	{ 68192, 68223 },
-};
-static const URange32 Old_Turkic_range32[] = {
-	{ 68608, 68680 },
-};
-static const URange32 Old_Uyghur_range32[] = {
-	{ 69488, 69513 },
-};
-static const URange16 Oriya_range16[] = {
-	{ 2817, 2819 },
-	{ 2821, 2828 },
-	{ 2831, 2832 },
-	{ 2835, 2856 },
-	{ 2858, 2864 },
-	{ 2866, 2867 },
-	{ 2869, 2873 },
-	{ 2876, 2884 },
-	{ 2887, 2888 },
-	{ 2891, 2893 },
-	{ 2901, 2903 },
-	{ 2908, 2909 },
-	{ 2911, 2915 },
-	{ 2918, 2935 },
-};
-static const URange32 Osage_range32[] = {
-	{ 66736, 66771 },
-	{ 66776, 66811 },
-};
-static const URange32 Osmanya_range32[] = {
-	{ 66688, 66717 },
-	{ 66720, 66729 },
-};
-static const URange32 Pahawh_Hmong_range32[] = {
-	{ 92928, 92997 },
-	{ 93008, 93017 },
-	{ 93019, 93025 },
-	{ 93027, 93047 },
-	{ 93053, 93071 },
-};
-static const URange32 Palmyrene_range32[] = {
-	{ 67680, 67711 },
-};
-static const URange32 Pau_Cin_Hau_range32[] = {
-	{ 72384, 72440 },
-};
-static const URange16 Phags_Pa_range16[] = {
-	{ 43072, 43127 },
-};
-static const URange32 Phoenician_range32[] = {
-	{ 67840, 67867 },
-	{ 67871, 67871 },
-};
-static const URange32 Psalter_Pahlavi_range32[] = {
-	{ 68480, 68497 },
-	{ 68505, 68508 },
-	{ 68521, 68527 },
-};
-static const URange16 Rejang_range16[] = {
-	{ 43312, 43347 },
-	{ 43359, 43359 },
-};
-static const URange16 Runic_range16[] = {
-	{ 5792, 5866 },
-	{ 5870, 5880 },
-};
-static const URange16 Samaritan_range16[] = {
-	{ 2048, 2093 },
-	{ 2096, 2110 },
-};
-static const URange16 Saurashtra_range16[] = {
-	{ 43136, 43205 },
-	{ 43214, 43225 },
-};
-static const URange32 Sharada_range32[] = {
-	{ 70016, 70111 },
-};
-static const URange32 Shavian_range32[] = {
-	{ 66640, 66687 },
-};
-static const URange32 Siddham_range32[] = {
-	{ 71040, 71093 },
-	{ 71096, 71133 },
-};
-static const URange32 SignWriting_range32[] = {
-	{ 120832, 121483 },
-	{ 121499, 121503 },
-	{ 121505, 121519 },
-};
-static const URange16 Sinhala_range16[] = {
-	{ 3457, 3459 },
-	{ 3461, 3478 },
-	{ 3482, 3505 },
-	{ 3507, 3515 },
-	{ 3517, 3517 },
-	{ 3520, 3526 },
-	{ 3530, 3530 },
-	{ 3535, 3540 },
-	{ 3542, 3542 },
-	{ 3544, 3551 },
-	{ 3558, 3567 },
-	{ 3570, 3572 },
-};
-static const URange32 Sinhala_range32[] = {
-	{ 70113, 70132 },
-};
-static const URange32 Sogdian_range32[] = {
-	{ 69424, 69465 },
-};
-static const URange32 Sora_Sompeng_range32[] = {
-	{ 69840, 69864 },
-	{ 69872, 69881 },
-};
-static const URange32 Soyombo_range32[] = {
-	{ 72272, 72354 },
-};
-static const URange16 Sundanese_range16[] = {
-	{ 7040, 7103 },
-	{ 7360, 7367 },
-};
-static const URange16 Syloti_Nagri_range16[] = {
-	{ 43008, 43052 },
-};
-static const URange16 Syriac_range16[] = {
-	{ 1792, 1805 },
-	{ 1807, 1866 },
-	{ 1869, 1871 },
-	{ 2144, 2154 },
-};
-static const URange16 Tagalog_range16[] = {
-	{ 5888, 5909 },
-	{ 5919, 5919 },
-};
-static const URange16 Tagbanwa_range16[] = {
-	{ 5984, 5996 },
-	{ 5998, 6000 },
-	{ 6002, 6003 },
-};
-static const URange16 Tai_Le_range16[] = {
-	{ 6480, 6509 },
-	{ 6512, 6516 },
-};
-static const URange16 Tai_Tham_range16[] = {
-	{ 6688, 6750 },
-	{ 6752, 6780 },
-	{ 6783, 6793 },
-	{ 6800, 6809 },
-	{ 6816, 6829 },
-};
-static const URange16 Tai_Viet_range16[] = {
-	{ 43648, 43714 },
-	{ 43739, 43743 },
-};
-static const URange32 Takri_range32[] = {
-	{ 71296, 71353 },
-	{ 71360, 71369 },
-};
-static const URange16 Tamil_range16[] = {
-	{ 2946, 2947 },
-	{ 2949, 2954 },
-	{ 2958, 2960 },
-	{ 2962, 2965 },
-	{ 2969, 2970 },
-	{ 2972, 2972 },
-	{ 2974, 2975 },
-	{ 2979, 2980 },
-	{ 2984, 2986 },
-	{ 2990, 3001 },
-	{ 3006, 3010 },
-	{ 3014, 3016 },
-	{ 3018, 3021 },
-	{ 3024, 3024 },
-	{ 3031, 3031 },
-	{ 3046, 3066 },
-};
-static const URange32 Tamil_range32[] = {
-	{ 73664, 73713 },
-	{ 73727, 73727 },
-};
-static const URange32 Tangsa_range32[] = {
-	{ 92784, 92862 },
-	{ 92864, 92873 },
-};
-static const URange32 Tangut_range32[] = {
-	{ 94176, 94176 },
-	{ 94208, 100343 },
-	{ 100352, 101119 },
-	{ 101632, 101640 },
-};
-static const URange16 Telugu_range16[] = {
-	{ 3072, 3084 },
-	{ 3086, 3088 },
-	{ 3090, 3112 },
-	{ 3114, 3129 },
-	{ 3132, 3140 },
-	{ 3142, 3144 },
-	{ 3146, 3149 },
-	{ 3157, 3158 },
-	{ 3160, 3162 },
-	{ 3165, 3165 },
-	{ 3168, 3171 },
-	{ 3174, 3183 },
-	{ 3191, 3199 },
-};
-static const URange16 Thaana_range16[] = {
-	{ 1920, 1969 },
-};
-static const URange16 Thai_range16[] = {
-	{ 3585, 3642 },
-	{ 3648, 3675 },
-};
-static const URange16 Tibetan_range16[] = {
-	{ 3840, 3911 },
-	{ 3913, 3948 },
-	{ 3953, 3991 },
-	{ 3993, 4028 },
-	{ 4030, 4044 },
-	{ 4046, 4052 },
-	{ 4057, 4058 },
-};
-static const URange16 Tifinagh_range16[] = {
-	{ 11568, 11623 },
-	{ 11631, 11632 },
-	{ 11647, 11647 },
-};
-static const URange32 Tirhuta_range32[] = {
-	{ 70784, 70855 },
-	{ 70864, 70873 },
-};
-static const URange32 Toto_range32[] = {
-	{ 123536, 123566 },
-};
-static const URange32 Ugaritic_range32[] = {
-	{ 66432, 66461 },
-	{ 66463, 66463 },
-};
-static const URange16 Vai_range16[] = {
-	{ 42240, 42539 },
-};
-static const URange32 Vithkuqi_range32[] = {
-	{ 66928, 66938 },
-	{ 66940, 66954 },
-	{ 66956, 66962 },
-	{ 66964, 66965 },
-	{ 66967, 66977 },
-	{ 66979, 66993 },
-	{ 66995, 67001 },
-	{ 67003, 67004 },
-};
-static const URange32 Wancho_range32[] = {
-	{ 123584, 123641 },
-	{ 123647, 123647 },
-};
-static const URange32 Warang_Citi_range32[] = {
-	{ 71840, 71922 },
-	{ 71935, 71935 },
-};
-static const URange32 Yezidi_range32[] = {
-	{ 69248, 69289 },
-	{ 69291, 69293 },
-	{ 69296, 69297 },
-};
-static const URange16 Yi_range16[] = {
-	{ 40960, 42124 },
-	{ 42128, 42182 },
-};
-static const URange32 Zanabazar_Square_range32[] = {
-	{ 72192, 72263 },
-};
-// 4040 16-bit ranges, 1775 32-bit ranges
-const UGroup unicode_groups[] = {
-	{ "Adlam", +1, 0, 0, Adlam_range32, 3 },
-	{ "Ahom", +1, 0, 0, Ahom_range32, 3 },
-	{ "Anatolian_Hieroglyphs", +1, 0, 0, Anatolian_Hieroglyphs_range32, 1 },
-	{ "Arabic", +1, Arabic_range16, 22, Arabic_range32, 36 },
-	{ "Armenian", +1, Armenian_range16, 4, 0, 0 },
-	{ "Avestan", +1, 0, 0, Avestan_range32, 2 },
-	{ "Balinese", +1, Balinese_range16, 2, 0, 0 },
-	{ "Bamum", +1, Bamum_range16, 1, Bamum_range32, 1 },
-	{ "Bassa_Vah", +1, 0, 0, Bassa_Vah_range32, 2 },
-	{ "Batak", +1, Batak_range16, 2, 0, 0 },
-	{ "Bengali", +1, Bengali_range16, 14, 0, 0 },
-	{ "Bhaiksuki", +1, 0, 0, Bhaiksuki_range32, 4 },
-	{ "Bopomofo", +1, Bopomofo_range16, 3, 0, 0 },
-	{ "Brahmi", +1, 0, 0, Brahmi_range32, 3 },
-	{ "Braille", +1, Braille_range16, 1, 0, 0 },
-	{ "Buginese", +1, Buginese_range16, 2, 0, 0 },
-	{ "Buhid", +1, Buhid_range16, 1, 0, 0 },
-	{ "C", +1, C_range16, 17, C_range32, 9 },
-	{ "Canadian_Aboriginal", +1, Canadian_Aboriginal_range16, 2, Canadian_Aboriginal_range32, 1 },
-	{ "Carian", +1, 0, 0, Carian_range32, 1 },
-	{ "Caucasian_Albanian", +1, 0, 0, Caucasian_Albanian_range32, 2 },
-	{ "Cc", +1, Cc_range16, 2, 0, 0 },
-	{ "Cf", +1, Cf_range16, 14, Cf_range32, 7 },
-	{ "Chakma", +1, 0, 0, Chakma_range32, 2 },
-	{ "Cham", +1, Cham_range16, 4, 0, 0 },
-	{ "Cherokee", +1, Cherokee_range16, 3, 0, 0 },
-	{ "Chorasmian", +1, 0, 0, Chorasmian_range32, 1 },
-	{ "Co", +1, Co_range16, 1, Co_range32, 2 },
-	{ "Common", +1, Common_range16, 91, Common_range32, 82 },
-	{ "Coptic", +1, Coptic_range16, 3, 0, 0 },
-	{ "Cs", +1, Cs_range16, 1, 0, 0 },
-	{ "Cuneiform", +1, 0, 0, Cuneiform_range32, 4 },
-	{ "Cypriot", +1, 0, 0, Cypriot_range32, 6 },
-	{ "Cypro_Minoan", +1, 0, 0, Cypro_Minoan_range32, 1 },
-	{ "Cyrillic", +1, Cyrillic_range16, 8, Cyrillic_range32, 2 },
-	{ "Deseret", +1, 0, 0, Deseret_range32, 1 },
-	{ "Devanagari", +1, Devanagari_range16, 4, Devanagari_range32, 1 },
-	{ "Dives_Akuru", +1, 0, 0, Dives_Akuru_range32, 8 },
-	{ "Dogra", +1, 0, 0, Dogra_range32, 1 },
-	{ "Duployan", +1, 0, 0, Duployan_range32, 5 },
-	{ "Egyptian_Hieroglyphs", +1, 0, 0, Egyptian_Hieroglyphs_range32, 1 },
-	{ "Elbasan", +1, 0, 0, Elbasan_range32, 1 },
-	{ "Elymaic", +1, 0, 0, Elymaic_range32, 1 },
-	{ "Ethiopic", +1, Ethiopic_range16, 32, Ethiopic_range32, 4 },
-	{ "Georgian", +1, Georgian_range16, 10, 0, 0 },
-	{ "Glagolitic", +1, Glagolitic_range16, 1, Glagolitic_range32, 5 },
-	{ "Gothic", +1, 0, 0, Gothic_range32, 1 },
-	{ "Grantha", +1, 0, 0, Grantha_range32, 15 },
-	{ "Greek", +1, Greek_range16, 33, Greek_range32, 3 },
-	{ "Gujarati", +1, Gujarati_range16, 14, 0, 0 },
-	{ "Gunjala_Gondi", +1, 0, 0, Gunjala_Gondi_range32, 6 },
-	{ "Gurmukhi", +1, Gurmukhi_range16, 16, 0, 0 },
-	{ "Han", +1, Han_range16, 11, Han_range32, 10 },
-	{ "Hangul", +1, Hangul_range16, 14, 0, 0 },
-	{ "Hanifi_Rohingya", +1, 0, 0, Hanifi_Rohingya_range32, 2 },
-	{ "Hanunoo", +1, Hanunoo_range16, 1, 0, 0 },
-	{ "Hatran", +1, 0, 0, Hatran_range32, 3 },
-	{ "Hebrew", +1, Hebrew_range16, 9, 0, 0 },
-	{ "Hiragana", +1, Hiragana_range16, 2, Hiragana_range32, 4 },
-	{ "Imperial_Aramaic", +1, 0, 0, Imperial_Aramaic_range32, 2 },
-	{ "Inherited", +1, Inherited_range16, 19, Inherited_range32, 10 },
-	{ "Inscriptional_Pahlavi", +1, 0, 0, Inscriptional_Pahlavi_range32, 2 },
-	{ "Inscriptional_Parthian", +1, 0, 0, Inscriptional_Parthian_range32, 2 },
-	{ "Javanese", +1, Javanese_range16, 3, 0, 0 },
-	{ "Kaithi", +1, 0, 0, Kaithi_range32, 2 },
-	{ "Kannada", +1, Kannada_range16, 13, 0, 0 },
-	{ "Katakana", +1, Katakana_range16, 7, Katakana_range32, 7 },
-	{ "Kawi", +1, 0, 0, Kawi_range32, 3 },
-	{ "Kayah_Li", +1, Kayah_Li_range16, 2, 0, 0 },
-	{ "Kharoshthi", +1, 0, 0, Kharoshthi_range32, 8 },
-	{ "Khitan_Small_Script", +1, 0, 0, Khitan_Small_Script_range32, 2 },
-	{ "Khmer", +1, Khmer_range16, 4, 0, 0 },
-	{ "Khojki", +1, 0, 0, Khojki_range32, 2 },
-	{ "Khudawadi", +1, 0, 0, Khudawadi_range32, 2 },
-	{ "L", +1, L_range16, 380, L_range32, 279 },
-	{ "Lao", +1, Lao_range16, 11, 0, 0 },
-	{ "Latin", +1, Latin_range16, 34, Latin_range32, 5 },
-	{ "Lepcha", +1, Lepcha_range16, 3, 0, 0 },
-	{ "Limbu", +1, Limbu_range16, 5, 0, 0 },
-	{ "Linear_A", +1, 0, 0, Linear_A_range32, 3 },
-	{ "Linear_B", +1, 0, 0, Linear_B_range32, 7 },
-	{ "Lisu", +1, Lisu_range16, 1, Lisu_range32, 1 },
-	{ "Ll", +1, Ll_range16, 617, Ll_range32, 41 },
-	{ "Lm", +1, Lm_range16, 57, Lm_range32, 14 },
-	{ "Lo", +1, Lo_range16, 290, Lo_range32, 220 },
-	{ "Lt", +1, Lt_range16, 10, 0, 0 },
-	{ "Lu", +1, Lu_range16, 605, Lu_range32, 41 },
-	{ "Lycian", +1, 0, 0, Lycian_range32, 1 },
-	{ "Lydian", +1, 0, 0, Lydian_range32, 2 },
-	{ "M", +1, M_range16, 190, M_range32, 120 },
-	{ "Mahajani", +1, 0, 0, Mahajani_range32, 1 },
-	{ "Makasar", +1, 0, 0, Makasar_range32, 1 },
-	{ "Malayalam", +1, Malayalam_range16, 7, 0, 0 },
-	{ "Mandaic", +1, Mandaic_range16, 2, 0, 0 },
-	{ "Manichaean", +1, 0, 0, Manichaean_range32, 2 },
-	{ "Marchen", +1, 0, 0, Marchen_range32, 3 },
-	{ "Masaram_Gondi", +1, 0, 0, Masaram_Gondi_range32, 7 },
-	{ "Mc", +1, Mc_range16, 112, Mc_range32, 70 },
-	{ "Me", +1, Me_range16, 5, 0, 0 },
-	{ "Medefaidrin", +1, 0, 0, Medefaidrin_range32, 1 },
-	{ "Meetei_Mayek", +1, Meetei_Mayek_range16, 3, 0, 0 },
-	{ "Mende_Kikakui", +1, 0, 0, Mende_Kikakui_range32, 2 },
-	{ "Meroitic_Cursive", +1, 0, 0, Meroitic_Cursive_range32, 3 },
-	{ "Meroitic_Hieroglyphs", +1, 0, 0, Meroitic_Hieroglyphs_range32, 1 },
-	{ "Miao", +1, 0, 0, Miao_range32, 3 },
-	{ "Mn", +1, Mn_range16, 212, Mn_range32, 134 },
-	{ "Modi", +1, 0, 0, Modi_range32, 2 },
-	{ "Mongolian", +1, Mongolian_range16, 5, Mongolian_range32, 1 },
-	{ "Mro", +1, 0, 0, Mro_range32, 3 },
-	{ "Multani", +1, 0, 0, Multani_range32, 5 },
-	{ "Myanmar", +1, Myanmar_range16, 3, 0, 0 },
-	{ "N", +1, N_range16, 67, N_range32, 70 },
-	{ "Nabataean", +1, 0, 0, Nabataean_range32, 2 },
-	{ "Nag_Mundari", +1, 0, 0, Nag_Mundari_range32, 1 },
-	{ "Nandinagari", +1, 0, 0, Nandinagari_range32, 3 },
-	{ "Nd", +1, Nd_range16, 37, Nd_range32, 27 },
-	{ "New_Tai_Lue", +1, New_Tai_Lue_range16, 4, 0, 0 },
-	{ "Newa", +1, 0, 0, Newa_range32, 2 },
-	{ "Nko", +1, Nko_range16, 2, 0, 0 },
-	{ "Nl", +1, Nl_range16, 7, Nl_range32, 5 },
-	{ "No", +1, No_range16, 29, No_range32, 43 },
-	{ "Nushu", +1, 0, 0, Nushu_range32, 2 },
-	{ "Nyiakeng_Puachue_Hmong", +1, 0, 0, Nyiakeng_Puachue_Hmong_range32, 4 },
-	{ "Ogham", +1, Ogham_range16, 1, 0, 0 },
-	{ "Ol_Chiki", +1, Ol_Chiki_range16, 1, 0, 0 },
-	{ "Old_Hungarian", +1, 0, 0, Old_Hungarian_range32, 3 },
-	{ "Old_Italic", +1, 0, 0, Old_Italic_range32, 2 },
-	{ "Old_North_Arabian", +1, 0, 0, Old_North_Arabian_range32, 1 },
-	{ "Old_Permic", +1, 0, 0, Old_Permic_range32, 1 },
-	{ "Old_Persian", +1, 0, 0, Old_Persian_range32, 2 },
-	{ "Old_Sogdian", +1, 0, 0, Old_Sogdian_range32, 1 },
-	{ "Old_South_Arabian", +1, 0, 0, Old_South_Arabian_range32, 1 },
-	{ "Old_Turkic", +1, 0, 0, Old_Turkic_range32, 1 },
-	{ "Old_Uyghur", +1, 0, 0, Old_Uyghur_range32, 1 },
-	{ "Oriya", +1, Oriya_range16, 14, 0, 0 },
-	{ "Osage", +1, 0, 0, Osage_range32, 2 },
-	{ "Osmanya", +1, 0, 0, Osmanya_range32, 2 },
-	{ "P", +1, P_range16, 133, P_range32, 58 },
-	{ "Pahawh_Hmong", +1, 0, 0, Pahawh_Hmong_range32, 5 },
-	{ "Palmyrene", +1, 0, 0, Palmyrene_range32, 1 },
-	{ "Pau_Cin_Hau", +1, 0, 0, Pau_Cin_Hau_range32, 1 },
-	{ "Pc", +1, Pc_range16, 6, 0, 0 },
-	{ "Pd", +1, Pd_range16, 18, Pd_range32, 1 },
-	{ "Pe", +1, Pe_range16, 76, 0, 0 },
-	{ "Pf", +1, Pf_range16, 10, 0, 0 },
-	{ "Phags_Pa", +1, Phags_Pa_range16, 1, 0, 0 },
-	{ "Phoenician", +1, 0, 0, Phoenician_range32, 2 },
-	{ "Pi", +1, Pi_range16, 11, 0, 0 },
-	{ "Po", +1, Po_range16, 130, Po_range32, 57 },
-	{ "Ps", +1, Ps_range16, 79, 0, 0 },
-	{ "Psalter_Pahlavi", +1, 0, 0, Psalter_Pahlavi_range32, 3 },
-	{ "Rejang", +1, Rejang_range16, 2, 0, 0 },
-	{ "Runic", +1, Runic_range16, 2, 0, 0 },
-	{ "S", +1, S_range16, 151, S_range32, 81 },
-	{ "Samaritan", +1, Samaritan_range16, 2, 0, 0 },
-	{ "Saurashtra", +1, Saurashtra_range16, 2, 0, 0 },
-	{ "Sc", +1, Sc_range16, 18, Sc_range32, 3 },
-	{ "Sharada", +1, 0, 0, Sharada_range32, 1 },
-	{ "Shavian", +1, 0, 0, Shavian_range32, 1 },
-	{ "Siddham", +1, 0, 0, Siddham_range32, 2 },
-	{ "SignWriting", +1, 0, 0, SignWriting_range32, 3 },
-	{ "Sinhala", +1, Sinhala_range16, 12, Sinhala_range32, 1 },
-	{ "Sk", +1, Sk_range16, 30, Sk_range32, 1 },
-	{ "Sm", +1, Sm_range16, 53, Sm_range32, 11 },
-	{ "So", +1, So_range16, 114, So_range32, 70 },
-	{ "Sogdian", +1, 0, 0, Sogdian_range32, 1 },
-	{ "Sora_Sompeng", +1, 0, 0, Sora_Sompeng_range32, 2 },
-	{ "Soyombo", +1, 0, 0, Soyombo_range32, 1 },
-	{ "Sundanese", +1, Sundanese_range16, 2, 0, 0 },
-	{ "Syloti_Nagri", +1, Syloti_Nagri_range16, 1, 0, 0 },
-	{ "Syriac", +1, Syriac_range16, 4, 0, 0 },
-	{ "Tagalog", +1, Tagalog_range16, 2, 0, 0 },
-	{ "Tagbanwa", +1, Tagbanwa_range16, 3, 0, 0 },
-	{ "Tai_Le", +1, Tai_Le_range16, 2, 0, 0 },
-	{ "Tai_Tham", +1, Tai_Tham_range16, 5, 0, 0 },
-	{ "Tai_Viet", +1, Tai_Viet_range16, 2, 0, 0 },
-	{ "Takri", +1, 0, 0, Takri_range32, 2 },
-	{ "Tamil", +1, Tamil_range16, 16, Tamil_range32, 2 },
-	{ "Tangsa", +1, 0, 0, Tangsa_range32, 2 },
-	{ "Tangut", +1, 0, 0, Tangut_range32, 4 },
-	{ "Telugu", +1, Telugu_range16, 13, 0, 0 },
-	{ "Thaana", +1, Thaana_range16, 1, 0, 0 },
-	{ "Thai", +1, Thai_range16, 2, 0, 0 },
-	{ "Tibetan", +1, Tibetan_range16, 7, 0, 0 },
-	{ "Tifinagh", +1, Tifinagh_range16, 3, 0, 0 },
-	{ "Tirhuta", +1, 0, 0, Tirhuta_range32, 2 },
-	{ "Toto", +1, 0, 0, Toto_range32, 1 },
-	{ "Ugaritic", +1, 0, 0, Ugaritic_range32, 2 },
-	{ "Vai", +1, Vai_range16, 1, 0, 0 },
-	{ "Vithkuqi", +1, 0, 0, Vithkuqi_range32, 8 },
-	{ "Wancho", +1, 0, 0, Wancho_range32, 2 },
-	{ "Warang_Citi", +1, 0, 0, Warang_Citi_range32, 2 },
-	{ "Yezidi", +1, 0, 0, Yezidi_range32, 3 },
-	{ "Yi", +1, Yi_range16, 2, 0, 0 },
-	{ "Z", +1, Z_range16, 8, 0, 0 },
-	{ "Zanabazar_Square", +1, 0, 0, Zanabazar_Square_range32, 1 },
-	{ "Zl", +1, Zl_range16, 1, 0, 0 },
-	{ "Zp", +1, Zp_range16, 1, 0, 0 },
-	{ "Zs", +1, Zs_range16, 7, 0, 0 },
-};
-const int num_unicode_groups = 199;
-
-
-}  // namespace re2
-
-
diff --git a/src/duckdb/third_party/re2/re2/unicode_groups.h b/src/duckdb/third_party/re2/re2/unicode_groups.h
deleted file mode 100644
index 56069c6dc..000000000
--- a/src/duckdb/third_party/re2/re2/unicode_groups.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_UNICODE_GROUPS_H_
-#define RE2_UNICODE_GROUPS_H_
-
-// Unicode character groups.
-
-// The codes get split into ranges of 16-bit codes
-// and ranges of 32-bit codes.  It would be simpler
-// to use only 32-bit ranges, but these tables are large
-// enough to warrant extra care.
-//
-// Using just 32-bit ranges gives 27 kB of data.
-// Adding 16-bit ranges gives 18 kB of data.
-// Adding an extra table of 16-bit singletons would reduce
-// to 16.5 kB of data but make the data harder to use;
-// we don't bother.
-
-#include <stdint.h>
-
-#include "util/util.h"
-#include "util/utf.h"
-
-namespace duckdb_re2 {
-
-struct URange16
-{
-  uint16_t lo;
-  uint16_t hi;
-};
-
-struct URange32
-{
-  Rune lo;
-  Rune hi;
-};
-
-struct UGroup
-{
-  const char *name;
-  int sign;  // +1 for [abc], -1 for [^abc]
-  const URange16 *r16;
-  int nr16;
-  const URange32 *r32;
-  int nr32;
-};
-
-// Named by property or script name (e.g., "Nd", "N", "Han").
-// Negated groups are not included.
-extern const UGroup unicode_groups[];
-extern const int num_unicode_groups;
-
-// Named by POSIX name (e.g., "[:alpha:]", "[:^lower:]").
-// Negated groups are included.
-extern const UGroup posix_groups[];
-extern const int num_posix_groups;
-
-// Named by Perl name (e.g., "\\d", "\\D").
-// Negated groups are included.
-extern const UGroup perl_groups[];
-extern const int num_perl_groups;
-
-}  // namespace re2
-
-#endif  // RE2_UNICODE_GROUPS_H_
diff --git a/src/duckdb/third_party/re2/re2/walker-inl.h b/src/duckdb/third_party/re2/re2/walker-inl.h
deleted file mode 100644
index 635c0583b..000000000
--- a/src/duckdb/third_party/re2/re2/walker-inl.h
+++ /dev/null
@@ -1,251 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_WALKER_INL_H_
-#define RE2_WALKER_INL_H_
-
-// Helper class for traversing Regexps without recursion.
-// Clients should declare their own subclasses that override
-// the PreVisit and PostVisit methods, which are called before
-// and after visiting the subexpressions.
-
-// Not quite the Visitor pattern, because (among other things)
-// the Visitor pattern is recursive.
-
-#include <stack>
-
-#include "util/logging.h"
-#include "re2/regexp.h"
-
-// For CRAN
-#  pragma clang diagnostic ignored "-Wdtor-name"
-// For CRAN
-
-namespace duckdb_re2 {
-
-template<typename T> struct WalkState;
-
-template<typename T> class Regexp::Walker {
- public:
-  Walker();
-  virtual ~Walker();
-
-  // Virtual method called before visiting re's children.
-  // PreVisit passes ownership of its return value to its caller.
-  // The Arg* that PreVisit returns will be passed to PostVisit as pre_arg
-  // and passed to the child PreVisits and PostVisits as parent_arg.
-  // At the top-most Regexp, parent_arg is arg passed to walk.
-  // If PreVisit sets *stop to true, the walk does not recurse
-  // into the children.  Instead it behaves as though the return
-  // value from PreVisit is the return value from PostVisit.
-  // The default PreVisit returns parent_arg.
-  virtual T PreVisit(Regexp* re, T parent_arg, bool* stop);
-
-  // Virtual method called after visiting re's children.
-  // The pre_arg is the T that PreVisit returned.
-  // The child_args is a vector of the T that the child PostVisits returned.
-  // PostVisit takes ownership of pre_arg.
-  // PostVisit takes ownership of the Ts
-  // in *child_args, but not the vector itself.
-  // PostVisit passes ownership of its return value
-  // to its caller.
-  // The default PostVisit simply returns pre_arg.
-  virtual T PostVisit(Regexp* re, T parent_arg, T pre_arg,
-                      T* child_args, int nchild_args);
-
-  // Virtual method called to copy a T,
-  // when Walk notices that more than one child is the same re.
-  virtual T Copy(T arg);
-
-  // Virtual method called to do a "quick visit" of the re,
-  // but not its children.  Only called once the visit budget
-  // has been used up and we're trying to abort the walk
-  // as quickly as possible.  Should return a value that
-  // makes sense for the parent PostVisits still to be run.
-  // This function is (hopefully) only called by
-  // WalkExponential, but must be implemented by all clients,
-  // just in case.
-  virtual T ShortVisit(Regexp* re, T parent_arg) = 0;
-
-  // Walks over a regular expression.
-  // Top_arg is passed as parent_arg to PreVisit and PostVisit of re.
-  // Returns the T returned by PostVisit on re.
-  T Walk(Regexp* re, T top_arg);
-
-  // Like Walk, but doesn't use Copy.  This can lead to
-  // exponential runtimes on cross-linked Regexps like the
-  // ones generated by Simplify.  To help limit this,
-  // at most max_visits nodes will be visited and then
-  // the walk will be cut off early.
-  // If the walk *is* cut off early, ShortVisit(re)
-  // will be called on regexps that cannot be fully
-  // visited rather than calling PreVisit/PostVisit.
-  T WalkExponential(Regexp* re, T top_arg, int max_visits);
-
-  // Clears the stack.  Should never be necessary, since
-  // Walk always enters and exits with an empty stack.
-  // Logs DFATAL if stack is not already clear.
-  void Reset();
-
-  // Returns whether walk was cut off.
-  bool stopped_early() { return stopped_early_; }
-
- private:
-  // Walk state for the entire traversal.
-  std::stack<WalkState<T>> stack_;
-  bool stopped_early_;
-  int max_visits_;
-
-  T WalkInternal(Regexp* re, T top_arg, bool use_copy);
-
-  Walker(const Walker&) = delete;
-  Walker& operator=(const Walker&) = delete;
-};
-
-template<typename T> T Regexp::Walker<T>::PreVisit(Regexp* re,
-                                                   T parent_arg,
-                                                   bool* stop) {
-  return parent_arg;
-}
-
-template<typename T> T Regexp::Walker<T>::PostVisit(Regexp* re,
-                                                    T parent_arg,
-                                                    T pre_arg,
-                                                    T* child_args,
-                                                    int nchild_args) {
-  return pre_arg;
-}
-
-template<typename T> T Regexp::Walker<T>::Copy(T arg) {
-  return arg;
-}
-
-// State about a single level in the traversal.
-template<typename T> struct WalkState {
-  WalkState(Regexp* re, T parent)
-    : re(re),
-      n(-1),
-      parent_arg(parent),
-      child_args(NULL) { }
-
-  Regexp* re;  // The regexp
-  int n;  // The index of the next child to process; -1 means need to PreVisit
-  T parent_arg;  // Accumulated arguments.
-  T pre_arg;
-  T child_arg;  // One-element buffer for child_args.
-  T* child_args;
-};
-
-template<typename T> Regexp::Walker<T>::Walker() {
-  stopped_early_ = false;
-}
-
-template<typename T> Regexp::Walker<T>::~Walker() {
-  Reset();
-}
-
-// Clears the stack.  Should never be necessary, since
-// Walk always enters and exits with an empty stack.
-// Logs DFATAL if stack is not already clear.
-template<typename T> void Regexp::Walker<T>::Reset() {
-  if (!stack_.empty()) {
-    LOG(DFATAL) << "Stack not empty.";
-    while (!stack_.empty()) {
-      if (stack_.top().re->nsub_ > 1)
-        delete[] stack_.top().child_args;
-      stack_.pop();
-    }
-  }
-}
-
-template<typename T> T Regexp::Walker<T>::WalkInternal(Regexp* re, T top_arg,
-                                                       bool use_copy) {
-  Reset();
-
-  if (re == NULL) {
-    LOG(DFATAL) << "Walk NULL";
-    return top_arg;
-  }
-
-  stack_.push(WalkState<T>(re, top_arg));
-
-  WalkState<T>* s;
-  for (;;) {
-    T t;
-    s = &stack_.top();
-    re = s->re;
-    switch (s->n) {
-      case -1: {
-        if (--max_visits_ < 0) {
-          stopped_early_ = true;
-          t = ShortVisit(re, s->parent_arg);
-          break;
-        }
-        bool stop = false;
-        s->pre_arg = PreVisit(re, s->parent_arg, &stop);
-        if (stop) {
-          t = s->pre_arg;
-          break;
-        }
-        s->n = 0;
-        s->child_args = NULL;
-        if (re->nsub_ == 1)
-          s->child_args = &s->child_arg;
-        else if (re->nsub_ > 1)
-          s->child_args = new T[re->nsub_];
-        FALLTHROUGH_INTENDED;
-      }
-      default: {
-        if (re->nsub_ > 0) {
-          Regexp** sub = re->sub();
-          if (s->n < re->nsub_) {
-            if (use_copy && s->n > 0 && sub[s->n - 1] == sub[s->n]) {
-              s->child_args[s->n] = Copy(s->child_args[s->n - 1]);
-              s->n++;
-            } else {
-              stack_.push(WalkState<T>(sub[s->n], s->pre_arg));
-            }
-            continue;
-          }
-        }
-
-        t = PostVisit(re, s->parent_arg, s->pre_arg, s->child_args, s->n);
-        if (re->nsub_ > 1)
-          delete[] s->child_args;
-        break;
-      }
-    }
-
-    // We've finished stack_.top().
-    // Update next guy down.
-    stack_.pop();
-    if (stack_.empty())
-      return t;
-    s = &stack_.top();
-    if (s->child_args != NULL)
-      s->child_args[s->n] = t;
-    else
-      s->child_arg = t;
-    s->n++;
-  }
-}
-
-template<typename T> T Regexp::Walker<T>::Walk(Regexp* re, T top_arg) {
-  // Without the exponential walking behavior,
-  // this budget should be more than enough for any
-  // regexp, and yet not enough to get us in trouble
-  // as far as CPU time.
-  max_visits_ = 1000000;
-  return WalkInternal(re, top_arg, true);
-}
-
-template<typename T> T Regexp::Walker<T>::WalkExponential(Regexp* re, T top_arg,
-                                                          int max_visits) {
-  max_visits_ = max_visits;
-  return WalkInternal(re, top_arg, false);
-}
-
-}  // namespace re2
-
-#endif  // RE2_WALKER_INL_H_
diff --git a/src/duckdb/third_party/re2/util/logging.h b/src/duckdb/third_party/re2/util/logging.h
deleted file mode 100644
index 787d68a95..000000000
--- a/src/duckdb/third_party/re2/util/logging.h
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_LOGGING_H_
-#define UTIL_LOGGING_H_
-
-// Simplified version of Google's logging.
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ostream>
-#include <sstream>
-#include <stdexcept>
-
-#include "util/util.h"
-
-// Debug-only checking.
-#define DCHECK(condition) assert(condition)
-#define DCHECK_EQ(val1, val2) assert((val1) == (val2))
-#define DCHECK_NE(val1, val2) assert((val1) != (val2))
-#define DCHECK_LE(val1, val2) assert((val1) <= (val2))
-#define DCHECK_LT(val1, val2) assert((val1) < (val2))
-#define DCHECK_GE(val1, val2) assert((val1) >= (val2))
-#define DCHECK_GT(val1, val2) assert((val1) > (val2))
-
-// Always-on checking
-#define CHECK(x)	if(x){}else LogMessageFatal(__FILE__, __LINE__).stream() << "Check failed: " #x
-#define CHECK_LT(x, y)	CHECK((x) < (y))
-#define CHECK_GT(x, y)	CHECK((x) > (y))
-#define CHECK_LE(x, y)	CHECK((x) <= (y))
-#define CHECK_GE(x, y)	CHECK((x) >= (y))
-#define CHECK_EQ(x, y)	CHECK((x) == (y))
-#define CHECK_NE(x, y)	CHECK((x) != (y))
-
-#define LOG_INFO LogMessage(__FILE__, __LINE__)
-#define LOG_WARNING LogMessage(__FILE__, __LINE__)
-#define LOG_ERROR LogMessage(__FILE__, __LINE__)
-#define LOG_FATAL LogMessageFatal(__FILE__, __LINE__)
-#define LOG_QFATAL LOG_FATAL
-
-// It seems that one of the Windows header files defines ERROR as 0.
-#ifdef _WIN32
-#define LOG_0 LOG_INFO
-#endif
-
-#ifdef NDEBUG
-#define LOG_DFATAL LOG_ERROR
-#else
-#define LOG_DFATAL LOG_FATAL
-#endif
-
-#define LOG(severity) LOG_ ## severity.stream()
-
-#define VLOG(x) if((x)>0){}else LOG_INFO.stream()
-
-class LogMessage {
- public:
-  LogMessage(const char* file, int line)
-      : flushed_(false) {
-//    stream() << file << ":" << line << ": ";
-  }
-  void Flush() {
-//    stream() << "\n";
-//    std::string s = str_.str();
-//    size_t n = s.size();
-//    if (fwrite(s.data(), 1, n, stderr) < n) {}  // shut up gcc
-//    flushed_ = true;
-  }
-  ~LogMessage() {
-    if (!flushed_) {
-      Flush();
-    }
-  }
-  std::ostream& stream() { return str_; }
-
- private:
-  bool flushed_;
-  std::ostringstream str_;
-
-  LogMessage(const LogMessage&) = delete;
-  LogMessage& operator=(const LogMessage&) = delete;
-};
-
-// Silence "destructor never returns" warning for ~LogMessageFatal().
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4722)
-#endif
-
-class LogMessageFatal : public LogMessage {
- public:
-  LogMessageFatal(const char* file, int line)
-      : LogMessage(file, line) {
-	  throw std::runtime_error("RE2 Fatal Error");
-  }
-  ~LogMessageFatal() {
-    Flush();
-  }
- private:
-  LogMessageFatal(const LogMessageFatal&) = delete;
-  LogMessageFatal& operator=(const LogMessageFatal&) = delete;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif  // UTIL_LOGGING_H_
diff --git a/src/duckdb/third_party/re2/util/mix.h b/src/duckdb/third_party/re2/util/mix.h
deleted file mode 100644
index 2b889e5f5..000000000
--- a/src/duckdb/third_party/re2/util/mix.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MIX_H_
-#define UTIL_MIX_H_
-
-#include <stddef.h>
-#include <limits>
-
-namespace duckdb_re2 {
-
-// Silence "truncation of constant value" warning for kMul in 32-bit mode.
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4309)
-#endif
-
-class HashMix {
- public:
-  HashMix() : hash_(1) {}
-  explicit HashMix(size_t val) : hash_(val + 83) {}
-  void Mix(size_t val) {
-    static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL);
-    hash_ *= kMul;
-    hash_ = ((hash_ << 19) |
-             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) + val;
-  }
-  size_t get() const { return hash_; }
- private:
-  size_t hash_;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-}  // namespace re2
-
-#endif  // UTIL_MIX_H_
diff --git a/src/duckdb/third_party/re2/util/mutex.h b/src/duckdb/third_party/re2/util/mutex.h
deleted file mode 100644
index a3d262d33..000000000
--- a/src/duckdb/third_party/re2/util/mutex.h
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MUTEX_H_
-#define UTIL_MUTEX_H_
-
-/*
- * A simple mutex wrapper, supporting locks and read-write locks.
- * You should assume the locks are *not* re-entrant.
- */
-
-#ifdef RE2_NO_THREADS
-#include <assert.h>
-#define MUTEX_IS_LOCK_COUNTER
-#else
-#ifdef _WIN32
-// Requires Windows Vista or Windows Server 2008 at minimum.
-#include <windows.h>
-#if defined(WINVER) && WINVER >= 0x0600
-#define MUTEX_IS_WIN32_SRWLOCK
-#endif
-#else
-#ifndef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 200809L
-#endif
-#include <unistd.h>
-#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0
-#define MUTEX_IS_PTHREAD_RWLOCK
-#endif
-#endif
-#endif
-
-#if defined(MUTEX_IS_LOCK_COUNTER)
-typedef int MutexType;
-#elif defined(MUTEX_IS_WIN32_SRWLOCK)
-typedef SRWLOCK MutexType;
-#elif defined(MUTEX_IS_PTHREAD_RWLOCK)
-#include <stdexcept>
-#include <pthread.h>
-#include <stdlib.h>
-typedef pthread_rwlock_t MutexType;
-#else
-#include <shared_mutex>
-typedef std::shared_mutex MutexType;
-#endif
-
-namespace duckdb_re2 {
-
-class Mutex {
- public:
-  inline Mutex();
-  inline ~Mutex();
-  inline void Lock();    // Block if needed until free then acquire exclusively
-  inline void Unlock();  // Release a lock acquired via Lock()
-  // Note that on systems that don't support read-write locks, these may
-  // be implemented as synonyms to Lock() and Unlock().  So you can use
-  // these for efficiency, but don't use them anyplace where being able
-  // to do shared reads is necessary to avoid deadlock.
-  inline void ReaderLock();   // Block until free or shared then acquire a share
-  inline void ReaderUnlock(); // Release a read share of this Mutex
-  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock
-  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
-
- private:
-  MutexType mutex_;
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  Mutex(Mutex *ignored);
-
-  Mutex(const Mutex&) = delete;
-  Mutex& operator=(const Mutex&) = delete;
-};
-
-#if defined(MUTEX_IS_LOCK_COUNTER)
-
-Mutex::Mutex()             : mutex_(0) { }
-Mutex::~Mutex()            { assert(mutex_ == 0); }
-void Mutex::Lock()         { assert(--mutex_ == -1); }
-void Mutex::Unlock()       { assert(mutex_++ == -1); }
-void Mutex::ReaderLock()   { assert(++mutex_ > 0); }
-void Mutex::ReaderUnlock() { assert(mutex_-- > 0); }
-
-#elif defined(MUTEX_IS_WIN32_SRWLOCK)
-
-Mutex::Mutex()             : mutex_(SRWLOCK_INIT) { }
-Mutex::~Mutex()            { }
-void Mutex::Lock()         { AcquireSRWLockExclusive(&mutex_); }
-void Mutex::Unlock()       { ReleaseSRWLockExclusive(&mutex_); }
-void Mutex::ReaderLock()   { AcquireSRWLockShared(&mutex_); }
-void Mutex::ReaderUnlock() { ReleaseSRWLockShared(&mutex_); }
-
-#elif defined(MUTEX_IS_PTHREAD_RWLOCK)
-
-#define SAFE_PTHREAD(fncall)    \
-  do {                          \
-    if ((fncall) != 0) throw std::runtime_error("RE2 pthread failure"); \
-  } while (0);
-
-Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); }
-Mutex::~Mutex()            { pthread_rwlock_destroy(&mutex_); }
-void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); }
-void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); }
-void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-
-#undef SAFE_PTHREAD
-
-#else
-
-Mutex::Mutex()             { }
-Mutex::~Mutex()            { }
-void Mutex::Lock()         { mutex_.lock(); }
-void Mutex::Unlock()       { mutex_.unlock(); }
-void Mutex::ReaderLock()   { mutex_.lock_shared(); }
-void Mutex::ReaderUnlock() { mutex_.unlock_shared(); }
-
-#endif
-
-// --------------------------------------------------------------------------
-// Some helper classes
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class MutexLock {
- public:
-  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
-  ~MutexLock() { mu_->Unlock(); }
- private:
-  Mutex * const mu_;
-
-  MutexLock(const MutexLock&) = delete;
-  MutexLock& operator=(const MutexLock&) = delete;
-};
-
-// ReaderMutexLock and WriterMutexLock do the same, for rwlocks
-class ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
-  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
- private:
-  Mutex * const mu_;
-
-  ReaderMutexLock(const ReaderMutexLock&) = delete;
-  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
-};
-
-class WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
-  ~WriterMutexLock() { mu_->WriterUnlock(); }
- private:
-  Mutex * const mu_;
-
-  WriterMutexLock(const WriterMutexLock&) = delete;
-  WriterMutexLock& operator=(const WriterMutexLock&) = delete;
-};
-
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) static_assert(false, "MutexLock declaration missing variable name")
-#define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name")
-#define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name")
-
-}  // namespace re2
-
-#endif  // UTIL_MUTEX_H_
diff --git a/src/duckdb/third_party/re2/util/rune.cc b/src/duckdb/third_party/re2/util/rune.cc
deleted file mode 100644
index 04a22852c..000000000
--- a/src/duckdb/third_party/re2/util/rune.cc
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * The authors of this software are Rob Pike and Ken Thompson.
- *              Copyright (c) 2002 by Lucent Technologies.
- * Permission to use, copy, modify, and distribute this software for any
- * purpose without fee is hereby granted, provided that this entire notice
- * is included in all copies of any software which is or includes a copy
- * or modification of this software and in all copies of the supporting
- * documentation for such software.
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- */
-
-#include <stdarg.h>
-#include <string.h>
-
-#include "util/utf.h"
-
-namespace duckdb_re2 {
-
-enum
-{
-	Bit1	= 7,
-	Bitx	= 6,
-	Bit2	= 5,
-	Bit3	= 4,
-	Bit4	= 3,
-	Bit5	= 2, 
-
-	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
-	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
-	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
-	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
-	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
-	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */
-
-	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
-	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
-	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
-	Rune4	= (1<<(Bit4+3*Bitx))-1,
-                                        /* 0001 1111 1111 1111 1111 1111 */
-
-	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
-	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
-
-	Bad	= Runeerror,
-};
-
-int
-chartorune(Rune *rune, const char *str)
-{
-	int c, c1, c2, c3;
-	Rune l;
-
-	/*
-	 * one character sequence
-	 *	00000-0007F => T1
-	 */
-	c = *(unsigned char*)str;
-	if(c < Tx) {
-		*rune = c;
-		return 1;
-	}
-
-	/*
-	 * two character sequence
-	 *	0080-07FF => T2 Tx
-	 */
-	c1 = *(unsigned char*)(str+1) ^ Tx;
-	if(c1 & Testx)
-		goto bad;
-	if(c < T3) {
-		if(c < T2)
-			goto bad;
-		l = ((c << Bitx) | c1) & Rune2;
-		if(l <= Rune1)
-			goto bad;
-		*rune = l;
-		return 2;
-	}
-
-	/*
-	 * three character sequence
-	 *	0800-FFFF => T3 Tx Tx
-	 */
-	c2 = *(unsigned char*)(str+2) ^ Tx;
-	if(c2 & Testx)
-		goto bad;
-	if(c < T4) {
-		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
-		if(l <= Rune2)
-			goto bad;
-		*rune = l;
-		return 3;
-	}
-
-	/*
-	 * four character sequence (21-bit value)
-	 *	10000-1FFFFF => T4 Tx Tx Tx
-	 */
-	c3 = *(unsigned char*)(str+3) ^ Tx;
-	if (c3 & Testx)
-		goto bad;
-	if (c < T5) {
-		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
-		if (l <= Rune3)
-			goto bad;
-		*rune = l;
-		return 4;
-	}
-
-	/*
-	 * Support for 5-byte or longer UTF-8 would go here, but
-	 * since we don't have that, we'll just fall through to bad.
-	 */
-
-	/*
-	 * bad decoding
-	 */
-bad:
-	*rune = Bad;
-	return 1;
-}
-
-int
-runetochar(char *str, const Rune *rune)
-{
-	/* Runes are signed, so convert to unsigned for range check. */
-	unsigned int c;
-
-	/*
-	 * one character sequence
-	 *	00000-0007F => 00-7F
-	 */
-	c = *rune;
-	if(c <= Rune1) {
-		str[0] = static_cast<char>(c);
-		return 1;
-	}
-
-	/*
-	 * two character sequence
-	 *	0080-07FF => T2 Tx
-	 */
-	if(c <= Rune2) {
-		str[0] = T2 | static_cast<char>(c >> 1*Bitx);
-		str[1] = Tx | (c & Maskx);
-		return 2;
-	}
-
-	/*
-	 * If the Rune is out of range, convert it to the error rune.
-	 * Do this test here because the error rune encodes to three bytes.
-	 * Doing it earlier would duplicate work, since an out of range
-	 * Rune wouldn't have fit in one or two bytes.
-	 */
-	if (c > Runemax)
-		c = Runeerror;
-
-	/*
-	 * three character sequence
-	 *	0800-FFFF => T3 Tx Tx
-	 */
-	if (c <= Rune3) {
-		str[0] = T3 | static_cast<char>(c >> 2*Bitx);
-		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
-		str[2] = Tx | (c & Maskx);
-		return 3;
-	}
-
-	/*
-	 * four character sequence (21-bit value)
-	 *     10000-1FFFFF => T4 Tx Tx Tx
-	 */
-	str[0] = T4 | static_cast<char>(c >> 3*Bitx);
-	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
-	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
-	str[3] = Tx | (c & Maskx);
-	return 4;
-}
-
-int
-runelen(Rune rune)
-{
-	char str[10];
-
-	return runetochar(str, &rune);
-}
-
-int
-fullrune(const char *str, int n)
-{
-	if (n > 0) {
-		int c = *(unsigned char*)str;
-		if (c < Tx)
-			return 1;
-		if (n > 1) {
-			if (c < T3)
-				return 1;
-			if (n > 2) {
-				if (c < T4 || n > 3)
-					return 1;
-			}
-		}
-	}
-	return 0;
-}
-
-
-int
-utflen(const char *s)
-{
-	int c;
-	int n;
-	Rune rune;
-
-	n = 0;
-	for(;;) {
-		c = *(unsigned char*)s;
-		if(c < Runeself) {
-			if(c == 0)
-				return n;
-			s++;
-		} else
-			s += chartorune(&rune, s);
-		n++;
-	}
-	return 0;
-}
-
-char*
-utfrune(const char *s, Rune c)
-{
-	int c1;
-	Rune r;
-	int n;
-
-	if(c < Runesync)		/* not part of utf sequence */
-		return strchr((char*)s, c);
-
-	for(;;) {
-		c1 = *(unsigned char*)s;
-		if(c1 < Runeself) {	/* one byte rune */
-			if(c1 == 0)
-				return 0;
-			if(c1 == c)
-				return (char*)s;
-			s++;
-			continue;
-		}
-		n = chartorune(&r, s);
-		if(r == c)
-			return (char*)s;
-		s += n;
-	}
-	return 0;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/util/strutil.cc b/src/duckdb/third_party/re2/util/strutil.cc
deleted file mode 100644
index 54c05a1b5..000000000
--- a/src/duckdb/third_party/re2/util/strutil.cc
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 1999-2005 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "util/strutil.h"
-
-#ifdef _WIN32
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#endif
-
-namespace duckdb_re2 {
-
-// ----------------------------------------------------------------------
-// CEscapeString()
-//    Copies 'src' to 'dest', escaping dangerous characters using
-//    C-style escape sequences.  'src' and 'dest' should not overlap.
-//    Returns the number of bytes written to 'dest' (not including the \0)
-//    or (size_t)-1 if there was insufficient space.
-// ----------------------------------------------------------------------
-static size_t CEscapeString(const char* src, size_t src_len,
-                            char* dest, size_t dest_len) {
-  const char* src_end = src + src_len;
-  size_t used = 0;
-
-  for (; src < src_end; src++) {
-    if (dest_len - used < 2)   // space for two-character escape
-      return (size_t)-1;
-
-    unsigned char c = *src;
-    switch (c) {
-      case '\n': dest[used++] = '\\'; dest[used++] = 'n';  break;
-      case '\r': dest[used++] = '\\'; dest[used++] = 'r';  break;
-      case '\t': dest[used++] = '\\'; dest[used++] = 't';  break;
-      case '\"': dest[used++] = '\\'; dest[used++] = '\"'; break;
-      case '\'': dest[used++] = '\\'; dest[used++] = '\''; break;
-      case '\\': dest[used++] = '\\'; dest[used++] = '\\'; break;
-      default:
-        // Note that if we emit \xNN and the src character after that is a hex
-        // digit then that digit must be escaped too to prevent it being
-        // interpreted as part of the character code by C.
-        if (c < ' ' || c > '~') {
-          if (dest_len - used < 5)   // space for four-character escape + \0
-            return (size_t)-1;
-          snprintf(dest + used, 5, "\\%03o", c);
-          used += 4;
-        } else {
-          dest[used++] = c; break;
-        }
-    }
-  }
-
-  if (dest_len - used < 1)   // make sure that there is room for \0
-    return (size_t)-1;
-
-  dest[used] = '\0';   // doesn't count towards return value though
-  return used;
-}
-
-// ----------------------------------------------------------------------
-// CEscape()
-//    Copies 'src' to result, escaping dangerous characters using
-//    C-style escape sequences.  'src' and 'dest' should not overlap.
-// ----------------------------------------------------------------------
-std::string CEscape(const StringPiece& src) {
-  const size_t dest_len = src.size() * 4 + 1; // Maximum possible expansion
-  char* dest = new char[dest_len];
-  const size_t used = CEscapeString(src.data(), src.size(),
-                                    dest, dest_len);
-  std::string s = std::string(dest, used);
-  delete[] dest;
-  return s;
-}
-
-void PrefixSuccessor(std::string* prefix) {
-  // We can increment the last character in the string and be done
-  // unless that character is 255, in which case we have to erase the
-  // last character and increment the previous character, unless that
-  // is 255, etc. If the string is empty or consists entirely of
-  // 255's, we just return the empty string.
-  while (!prefix->empty()) {
-    char& c = prefix->back();
-    if (c == '\xff') {  // char literal avoids signed/unsigned.
-      prefix->pop_back();
-    } else {
-      ++c;
-      break;
-    }
-  }
-}
-
-static void StringAppendV(std::string* dst, const char* format, va_list ap) {
-  // First try with a small fixed size buffer
-  char space[1024];
-
-  // It's possible for methods that use a va_list to invalidate
-  // the data in it upon use.  The fix is to make a copy
-  // of the structure before using it and use that copy instead.
-  va_list backup_ap;
-  va_copy(backup_ap, ap);
-  int result = vsnprintf(space, sizeof(space), format, backup_ap);
-  va_end(backup_ap);
-
-  if ((result >= 0) && (static_cast<size_t>(result) < sizeof(space))) {
-    // It fit
-    dst->append(space, result);
-    return;
-  }
-
-  // Repeatedly increase buffer size until it fits
-  int length = sizeof(space);
-  while (true) {
-    if (result < 0) {
-      // Older behavior: just try doubling the buffer size
-      length *= 2;
-    } else {
-      // We need exactly "result+1" characters
-      length = result+1;
-    }
-    char* buf = new char[length];
-
-    // Restore the va_list before we use it again
-    va_copy(backup_ap, ap);
-    result = vsnprintf(buf, length, format, backup_ap);
-    va_end(backup_ap);
-
-    if ((result >= 0) && (result < length)) {
-      // It fit
-      dst->append(buf, result);
-      delete[] buf;
-      return;
-    }
-    delete[] buf;
-  }
-}
-
-std::string StringPrintf(const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  std::string result;
-  StringAppendV(&result, format, ap);
-  va_end(ap);
-  return result;
-}
-
-}  // namespace re2
diff --git a/src/duckdb/third_party/re2/util/strutil.h b/src/duckdb/third_party/re2/util/strutil.h
deleted file mode 100644
index fa64d0b37..000000000
--- a/src/duckdb/third_party/re2/util/strutil.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_STRUTIL_H_
-#define UTIL_STRUTIL_H_
-
-#include <string>
-
-#include "re2/stringpiece.h"
-#include "util/util.h"
-
-namespace duckdb_re2 {
-
-std::string CEscape(const StringPiece& src);
-void PrefixSuccessor(std::string* prefix);
-std::string StringPrintf(const char* format, ...);
-
-}  // namespace re2
-
-#endif  // UTIL_STRUTIL_H_
diff --git a/src/duckdb/third_party/re2/util/utf.h b/src/duckdb/third_party/re2/util/utf.h
deleted file mode 100644
index 6d7bc0834..000000000
--- a/src/duckdb/third_party/re2/util/utf.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * The authors of this software are Rob Pike and Ken Thompson.
- *              Copyright (c) 2002 by Lucent Technologies.
- * Permission to use, copy, modify, and distribute this software for any
- * purpose without fee is hereby granted, provided that this entire notice
- * is included in all copies of any software which is or includes a copy
- * or modification of this software and in all copies of the supporting
- * documentation for such software.
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- * This file and rune.cc have been converted to compile as C++ code
- * in name space re2.
- */
-
-#ifndef UTIL_UTF_H_
-#define UTIL_UTF_H_
-
-#include <stdint.h>
-
-namespace duckdb_re2 {
-
-typedef signed int Rune;	/* Code-point values in Unicode 4.0 are 21 bits wide.*/
-
-enum
-{
-  UTFmax	= 4,		/* maximum bytes per rune */
-  Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
-  Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
-  Runeerror	= 0xFFFD,	/* decoding error in UTF */
-  Runemax	= 0x10FFFF,	/* maximum rune value */
-};
-
-int runetochar(char* s, const Rune* r);
-int chartorune(Rune* r, const char* s);
-int fullrune(const char* s, int n);
-int utflen(const char* s);
-char* utfrune(const char*, Rune);
-
-}  // namespace re2
-
-#endif  // UTIL_UTF_H_
diff --git a/src/duckdb/third_party/re2/util/util.h b/src/duckdb/third_party/re2/util/util.h
deleted file mode 100644
index 56e46c1a3..000000000
--- a/src/duckdb/third_party/re2/util/util.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_UTIL_H_
-#define UTIL_UTIL_H_
-
-#define arraysize(array) (sizeof(array)/sizeof((array)[0]))
-
-#ifndef ATTRIBUTE_NORETURN
-#if defined(__GNUC__)
-#define ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define ATTRIBUTE_NORETURN
-#endif
-#endif
-
-#ifndef ATTRIBUTE_UNUSED
-#if defined(__GNUC__)
-#define ATTRIBUTE_UNUSED __attribute__((unused))
-#else
-#define ATTRIBUTE_UNUSED
-#endif
-#endif
-
-#ifndef FALLTHROUGH_INTENDED
-#if defined(__clang__)
-#define FALLTHROUGH_INTENDED [[clang::fallthrough]]
-#elif defined(__GNUC__) && __GNUC__ >= 7
-#define FALLTHROUGH_INTENDED [[gnu::fallthrough]]
-#else
-#define FALLTHROUGH_INTENDED do {} while (0)
-#endif
-#endif
-
-#ifndef NO_THREAD_SAFETY_ANALYSIS
-#define NO_THREAD_SAFETY_ANALYSIS
-#endif
-
-#endif  // UTIL_UTIL_H_
diff --git a/src/duckdb/third_party/skiplist/HeadNode.h b/src/duckdb/third_party/skiplist/HeadNode.h
deleted file mode 100644
index 36cd866a4..000000000
--- a/src/duckdb/third_party/skiplist/HeadNode.h
+++ /dev/null
@@ -1,934 +0,0 @@
-/**
- * @file
- *
- * Project: skiplist
- *
- * Created by Paul Ross on 03/12/2015.
- *
- * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
- *
- * @code
- * MIT License
- *
- * Copyright (c) 2017-2023 Paul Ross
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * @endcode
- */
-
-#ifndef SkipList_HeadNode_h
-#define SkipList_HeadNode_h
-
-#include <functional>
-//#ifdef SKIPLIST_THREAD_SUPPORT
-//    #include <mutex>
-//#endif
-#include <vector>
-
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-#include <sstream>
-#endif // INCLUDE_METHODS_THAT_USE_STREAMS
-
-#include "IntegrityEnums.h"
-
-/** HeadNode
- *
- * @brief A HeadNode is a skip list. This is the single node leading to all other content Nodes.
- *
- * Example:
- *
- * @code
- *      OrderedStructs::SkipList::HeadNode<double> sl;
- *      for (int i = 0; i < 100; ++i) {
- *          sl.insert(i * 22.0 / 7.0);
- *      }
- *      sl.size(); // 100
- *      sl.at(50); // Value of 50 pi
- *      sl.remove(sl.at(50)); // Remove 50 pi
- * @endcode
- *
- * Created by Paul Ross on 03/12/2015.
- *
- * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- */
-template <typename T, typename _Compare=std::less<T>>
-class HeadNode {
-public:
-    /**
-     * Constructor for and Empty Skip List.
-     *
-     * @param cmp The comparison function for comparing Node values.
-     */
-    HeadNode(_Compare cmp=_Compare()) : _count(0), _compare(cmp), _pool(cmp) {
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-        _dot_file_subgraph = 0;
-#endif
-    }
-    // Const methods
-    //
-    // Returns true if the value is present in the skip list.
-    bool has(const T &value) const;
-    // Returns the value at the index in the skip list.
-    // Will throw an OrderedStructs::SkipList::IndexError if index out of range.
-    const T &at(size_t index) const;
-    // Find the value at index and write count values to dest.
-    // Will throw a SkipList::IndexError if any index out of range.
-    // This is useful for rolling median on even length lists where
-    // the caller might want to implement the mean of two values.
-    void at(size_t index, size_t count, std::vector<T> &dest) const;
-    // Computes index of the first occurrence of a value
-    // Will throw a ValueError if the value does not exist in the skip list
-    size_t index(const T& value) const;
-    // Number of values in the skip list.
-    size_t size() const;
-    // Non-const methods
-    //
-    // Insert a value.
-    void insert(const T &value);
-    // Remove a value and return it.
-    // Will throw a ValueError is value not present.
-    T remove(const T &value);
-
-    // Const methods that are mostly used for debugging and visualisation.
-    //
-    // Number of linked lists that are in the skip list.
-    size_t height() const;
-    // Number of linked lists that the node at index has.
-    // Will throw a SkipList::IndexError if idx out of range.
-    size_t height(size_t idx) const;
-    // The skip width of the node at index has.
-    // May throw a SkipList::IndexError
-    size_t width(size_t idx, size_t level) const;
-
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-    void dotFile(std::ostream &os) const;
-    void dotFileFinalise(std::ostream &os) const;
-#endif // INCLUDE_METHODS_THAT_USE_STREAMS
-
-    // Returns non-zero if the integrity of this data structure is compromised
-    // This is a thorough but expensive check!
-    IntegrityCheck lacksIntegrity() const;
-    // Estimate of the number of bytes used by the skip list
-    size_t size_of() const;
-    virtual ~HeadNode();
-
-protected:
-    void _adjRemoveRefs(size_t level, Node<T, _Compare> *pNode);
-    const Node<T, _Compare> *_nodeAt(size_t idx) const;
-
-protected:
-    // Standardised way of throwing a ValueError
-    void _throwValueErrorNotFound(const T &value) const;
-    void _throwIfValueDoesNotCompare(const T &value) const;
-    // Internal integrity checks
-    IntegrityCheck _lacksIntegrityCyclicReferences() const;
-    IntegrityCheck _lacksIntegrityWidthAccumulation() const;
-    IntegrityCheck _lacksIntegrityNodeReferencesNotInList() const;
-    IntegrityCheck _lacksIntegrityOrder() const;
-protected:
-    /// Number of nodes in the list.
-    size_t _count;
-    /// My node references, the size of this is the largest height in the list
-    SwappableNodeRefStack<T, _Compare> _nodeRefs;
-    /// Comparison function.
-    _Compare _compare;
-    typename Node<T, _Compare>::_Pool _pool;
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-    /// Used to count how many sub-graphs have been plotted
-    mutable size_t _dot_file_subgraph;
-#endif
-
-private:
-    /// Prevent cctor and operator=
-    HeadNode(const HeadNode &that);
-    HeadNode &operator=(const HeadNode &that) const;
-};
-
-/**
- * Returns true if the value is present in the skip list.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param value Value to check if it is in the Skip List.
- * @return true if in the Skip List.
- */
-template <typename T, typename _Compare>
-bool HeadNode<T, _Compare>::has(const T &value) const {
-    _throwIfValueDoesNotCompare(value);
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    for (size_t l = _nodeRefs.height(); l-- > 0;) {
-        assert(_nodeRefs[l].pNode);
-        if (_nodeRefs[l].pNode->has(value)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * Returns the value at a particular index.
- * Will throw an OrderedStructs::SkipList::IndexError if index out of range.
- *
- * If @ref SKIPLIST_THREAD_SUPPORT is defined this will block.
- *
- * See _throw_exceeds_size() that does the throw.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param index The index.
- * @return The value at that index.
- */
-template <typename T, typename _Compare>
-const T &HeadNode<T, _Compare>::at(size_t index) const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    const Node<T, _Compare> *pNode = _nodeAt(index);
-    assert(pNode);
-    return pNode->value();
-}
-
-/**
- * Find the count number of value starting at index and write them to dest.
- *
- * Will throw a OrderedStructs::SkipList::IndexError if any index out of range.
- *
- * This is useful for rolling median on even length lists where the caller might want to implement the mean of two
- * values.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param index The index.
- * @param count The number of values to retrieve.
- * @param dest The vector of values
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::at(size_t index, size_t count,
-                               std::vector<T> &dest) const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    dest.clear();
-    const Node<T, _Compare> *pNode = _nodeAt(index);
-    // _nodeAt will (should) throw an IndexError so this
-    // assert should always be true
-    assert(pNode);
-    while (count) {
-        if (! pNode) {
-            _throw_exceeds_size(_count);
-        }
-        dest.push_back(pNode->value());
-        pNode = pNode->next();
-        --count;
-    }
-}
-
-/**
- * Computes index of the first occurrence of a value
- * Will throw a OrderedStructs::SkipList::ValueError if the value does not exist in the skip list
- * Will throw a OrderedStructs::SkipList::FailedComparison if the value is not comparable.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param value The value to search for.
- * @return
- */
-template <typename T, typename _Compare>
-size_t HeadNode<T, _Compare>::index(const T& value) const {
-    _throwIfValueDoesNotCompare(value);
-    size_t idx;
-
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    for (size_t l = _nodeRefs.height(); l-- > 0;) {
-        assert(_nodeRefs[l].pNode);
-        if (_nodeRefs[l].pNode->index(value, idx, l)) {
-            idx += _nodeRefs[l].width;
-            assert(idx > 0);
-            return idx - 1;
-        }
-    }
-    _throwValueErrorNotFound(value);
-    return 0;
-}
-
-/**
- * Return the number of values in the Skip List.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return The number of values in the Skip List.
- */
-template <typename T, typename _Compare>
-size_t HeadNode<T, _Compare>::size() const {
-    return _count;
-}
-
-template <typename T, typename _Compare>
-size_t HeadNode<T, _Compare>::height() const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    size_t val = _nodeRefs.height();
-    return val;
-}
-
-/**
- * Return the number of linked lists that the node at index has.
- *
- * Will throw a OrderedStructs::SkipList::IndexError if the index out of range.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param idx The index of the Skip List node.
- * @return The number of linked lists that the node at the index has.
- */
-template <typename T, typename _Compare>
-size_t HeadNode<T, _Compare>::height(size_t idx) const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    const Node<T, _Compare> *pNode = _nodeAt(idx);
-    assert(pNode);
-    return pNode->height();
-}
-
-/**
- * The skip width of the Node at index has at the given level.
- * Will throw an IndexError if the index is out of range.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param idx The index.
- * @param level The level.
- * @return Width of Node.
- */
-template <typename T, typename _Compare>
-size_t HeadNode<T, _Compare>::width(size_t idx, size_t level) const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    // Will throw if out of range.
-    const Node<T, _Compare> *pNode = _nodeAt(idx);
-    assert(pNode);
-    if (level >= pNode->height()) {
-        _throw_exceeds_size(pNode->height());
-    }
-    return pNode->nodeRefs()[level].width;
-}
-
-/**
- * Find the Node at the given index.
- * Will throw an IndexError if the index is out of range.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param idx The index.
- * @return The Node.
- */
-template <typename T, typename _Compare>
-const Node<T, _Compare> *HeadNode<T, _Compare>::_nodeAt(size_t idx) const {
-    if (idx < _count) {
-        for (size_t l = _nodeRefs.height(); l-- > 0;) {
-            if (_nodeRefs[l].pNode && _nodeRefs[l].width <= idx + 1) {
-                size_t new_index = idx + 1 - _nodeRefs[l].width;
-                const Node<T, _Compare> *pNode = _nodeRefs[l].pNode->at(new_index);
-                if (pNode) {
-                    return pNode;
-                }
-            }
-        }
-    }
-    assert(idx >= _count);
-    _throw_exceeds_size(_count);
-    // Should not get here as _throw_exceeds_size() will always throw.
-    return NULL;
-}
-
-/**
- * Insert a value.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param value
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::insert(const T &value) {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#ifdef SKIPLIST_THREAD_SUPPORT_TRACE
-    std::cout << "HeadNode insert() thread: " << std::this_thread::get_id() << std::endl;
-#endif
-#endif
-    Node<T, _Compare> *pNode = nullptr;
-    size_t level = _nodeRefs.height();
-
-    _throwIfValueDoesNotCompare(value);
-    while (level-- > 0) {
-        assert(_nodeRefs[level].pNode);
-        pNode = _nodeRefs[level].pNode->insert(value);
-        if (pNode) {
-            break;
-        }
-    }
-    if (! pNode) {
-        pNode = _pool.Allocate(value);
-        level = 0;
-    }
-    assert(pNode);
-    SwappableNodeRefStack<T, _Compare> &thatRefs = pNode->nodeRefs();
-    if (thatRefs.canSwap()) {
-        // Expand this to that
-        while (_nodeRefs.height() < thatRefs.height()) {
-            _nodeRefs.push_back(nullptr, _count + 1);
-        }
-        if (level < thatRefs.swapLevel()) {
-            // Happens when we were originally, say 3 high (max height of any
-            // previously seen node). Then a node is created
-            // say 5 high. In that case this will be at level 2 and
-            // thatRefs.swapLevel() will be 3
-            assert(level + 1 == thatRefs.swapLevel());
-            thatRefs[thatRefs.swapLevel()].width += _nodeRefs[level].width;
-            ++level;
-        }
-        // Now swap
-        while (level < _nodeRefs.height() && thatRefs.canSwap()) {
-            assert(thatRefs.canSwap());
-            assert(level == thatRefs.swapLevel());
-            _nodeRefs[level].width -= thatRefs[level].width - 1;
-            thatRefs.swap(_nodeRefs);
-            if (thatRefs.canSwap()) {
-                assert(thatRefs[thatRefs.swapLevel()].width == 0);
-                thatRefs[thatRefs.swapLevel()].width = _nodeRefs[level].width;
-            }
-            ++level;
-        }
-        // Check all references swapped
-        assert(! thatRefs.canSwap());
-        // Check that all 'this' pointers created on construction have been moved
-        assert(thatRefs.noNodePointerMatches(pNode));
-    }
-    if (level < thatRefs.swapLevel()) {
-        // Happens when we are, say 5 high then a node is created
-        // and consumed by the next node say 3 high. In that case this will be
-        // at level 2 and thatRefs.swapLevel() will be 3
-        assert(level + 1 == thatRefs.swapLevel());
-        ++level;
-    }
-    // Increment my widths as my references are now going over the top of
-    // pNode.
-    while (level < _nodeRefs.height() && level >= thatRefs.height()) {
-        _nodeRefs[level++].width += 1;
-    }
-    ++_count;
-#ifdef SKIPLIST_THREAD_SUPPORT
-#ifdef SKIPLIST_THREAD_SUPPORT_TRACE
-    std::cout << "HeadNode insert() thread: " << std::this_thread::get_id() << " DONE" << std::endl;
-#endif
-#endif
-}
-
-/**
- * Adjust references >= level for removal of the node pNode.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param level Current level.
- * @param pNode Node to swap references with.
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::_adjRemoveRefs(size_t level,
-                                           Node<T, _Compare> *pNode) {
-    assert(pNode);
-    SwappableNodeRefStack<T, _Compare> &thatRefs = pNode->nodeRefs();
-
-    // Swap all remaining levels
-    // This assertion checks that if swapping can take place we must be at the
-    // same level.
-    assert(! thatRefs.canSwap() || level == thatRefs.swapLevel());
-    while (level < _nodeRefs.height() && thatRefs.canSwap()) {
-        assert(level == thatRefs.swapLevel());
-        // Compute the new width for the new node
-        thatRefs[level].width += _nodeRefs[level].width - 1;
-        thatRefs.swap(_nodeRefs);
-        ++level;
-        if (! thatRefs.canSwap()) {
-            break;
-        }
-    }
-    assert(! thatRefs.canSwap());
-    // Decrement my widths as my references are now going over the top of
-    // pNode.
-    while (level < _nodeRefs.height()) {
-        _nodeRefs[level++].width -= 1;
-    }
-    // Decrement my stack while top has a NULL pointer.
-    while (_nodeRefs.height() && ! _nodeRefs[_nodeRefs.height() - 1].pNode) {
-        _nodeRefs.pop_back();
-    }
-}
-
-/**
- * Remove a Node with a value.
- * May throw a ValueError if the value is not found.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param value The value in the Node to remove.
- * @return The value removed.
- */
-template <typename T, typename _Compare>
-T HeadNode<T, _Compare>::remove(const T &value) {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#ifdef SKIPLIST_THREAD_SUPPORT_TRACE
-    std::cout << "HeadNode remove() thread: " << std::this_thread::get_id() << std::endl;
-#endif
-#endif
-    Node<T, _Compare> *pNode = nullptr;
-    size_t level;
-
-    _throwIfValueDoesNotCompare(value);
-    for (level = _nodeRefs.height(); level-- > 0;) {
-        assert(_nodeRefs[level].pNode);
-        pNode = _nodeRefs[level].pNode->remove(level, value);
-        if (pNode) {
-            break;
-        }
-    }
-    if (! pNode) {
-        _throwValueErrorNotFound(value);
-    }
-    // Take swap level as some swaps will have been dealt with by the remove() above.
-    _adjRemoveRefs(pNode->nodeRefs().swapLevel(), pNode);
-    --_count;
-    T ret_val = _pool.Release(pNode);
-#ifdef SKIPLIST_THREAD_SUPPORT_TRACE
-    std::cout << "HeadNode remove() thread: " << std::this_thread::get_id() << " DONE" << std::endl;
-#endif
-    return ret_val;
-}
-
-/**
- * Throw a ValueError in a consistent fashion.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param value The value to put into the ValueError.
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::_throwValueErrorNotFound(const T &value) const {
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-    std::ostringstream oss;
-    oss << "Value " << value << " not found.";
-    std::string err_msg = oss.str();
-#else
-    std::string err_msg = "Value not found.";
-#endif
-    throw ValueError(err_msg);
-}
-
-/**
- * Checks that the value == value.
- * This will throw a FailedComparison if that is not the case, for example NaN.
- *
- * @note
- * The Node class is (should be) not directly accessible by the user so we can just assert(value == value) in Node.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param value
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::_throwIfValueDoesNotCompare(const T &value) const {
-    if (value != value) {
-        throw FailedComparison(
-            "Can not work with something that does not compare equal to itself.");
-    }
-}
-
-/**
- * This tests that at every level >= 0 the sequence of node pointers
- * at that level does not contain a cyclic reference.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck HeadNode<T, _Compare>::_lacksIntegrityCyclicReferences() const {
-    assert(_nodeRefs.height());
-    // Check for cyclic references at each level
-    for (size_t level = 0; level < _nodeRefs.height(); ++level) {
-        Node<T, _Compare> *p1 = _nodeRefs[level].pNode;
-        Node<T, _Compare> *p2 = _nodeRefs[level].pNode;
-        while (p1 && p2) {
-            p1 = p1->nodeRefs()[level].pNode;
-            if (p2->nodeRefs()[level].pNode) {
-                p2 = p2->nodeRefs()[level].pNode->nodeRefs()[level].pNode;
-            } else {
-                p2 = nullptr;
-            }
-            if (p1 && p2 && p1 == p2) {
-                return HEADNODE_DETECTS_CYCLIC_REFERENCE;
-            }
-        }
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * This tests that at every level > 0 the node to node width is the same
- * as the accumulated node to node widths at level - 1.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck HeadNode<T, _Compare>::_lacksIntegrityWidthAccumulation() const {
-    assert(_nodeRefs.height());
-    for (size_t level = 1; level < _nodeRefs.height(); ++level) {
-        const Node<T, _Compare> *pl = _nodeRefs[level].pNode;
-        const Node<T, _Compare> *pl_1 = _nodeRefs[level - 1].pNode;
-        assert(pl && pl_1); // No nulls allowed in HeadNode
-        size_t wl = _nodeRefs[level].width;
-        size_t wl_1 = _nodeRefs[level - 1].width;
-        while (true) {
-            while (pl != pl_1) {
-                assert(pl_1); // Could only happen if a lower reference was NULL and the higher non-NULL.
-                wl_1 += pl_1->width(level - 1);
-                pl_1 = pl_1->pNode(level - 1);
-            }
-            if (wl != wl_1) {
-                return HEADNODE_LEVEL_WIDTHS_MISMATCH;
-            }
-            if (pl == nullptr && pl_1 == nullptr) {
-                break;
-            }
-            wl = pl->width(level);
-            wl_1 = pl_1->width(level - 1);
-            pl = pl->pNode(level);
-            pl_1 = pl_1->pNode(level - 1);
-        }
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * This tests the integrity of each Node.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck HeadNode<T, _Compare>::_lacksIntegrityNodeReferencesNotInList() const {
-    assert(_nodeRefs.height());
-
-    IntegrityCheck result;
-    std::set<const Node<T, _Compare>*> nodeSet;
-    const Node<T, _Compare> *pNode = _nodeRefs[0].pNode;
-    assert(pNode);
-
-    // First gather all nodes, slightly awkward code here is so that
-    // NULL is always included.
-    nodeSet.insert(pNode);
-    do {
-        pNode = pNode->next();
-        nodeSet.insert(pNode);
-    } while (pNode);
-    assert(nodeSet.size() == _count + 1); // All nodes plus NULL
-    // Then test each node does not have pointers that are not in nodeSet
-    pNode = _nodeRefs[0].pNode;
-    while (pNode) {
-        result = pNode->lacksIntegrityRefsInSet(nodeSet);
-        if (result) {
-            return result;
-        }
-        pNode = pNode->next();
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * Integrity check. Traverse the lowest level and check that the ordering
- * is correct according to the compare function. The HeadNode checks that the
- * Node(s) have correctly applied the compare function.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck HeadNode<T, _Compare>::_lacksIntegrityOrder() const {
-    if (_nodeRefs.height()) {
-        // Traverse the lowest level list iteratively deleting as we go
-        // Doing this recursivley could be expensive as we are at level 0.
-        const Node<T, _Compare> *node = _nodeRefs[0].pNode;
-        const Node<T, _Compare> *next;
-        while (node) {
-            next = node->next();
-            if (next && _compare(next->value(), node->value())) {
-                return HEADNODE_DETECTS_OUT_OF_ORDER;
-            }
-            node = next;
-        }
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * Full integrity check.
- * This calls the other integrity check functions.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck HeadNode<T, _Compare>::lacksIntegrity() const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    if (_nodeRefs.height()) {
-        IntegrityCheck result = _nodeRefs.lacksIntegrity();
-        if (result) {
-            return result;
-        }
-        if (! _nodeRefs.noNodePointerMatches(nullptr)) {
-            return HEADNODE_CONTAINS_NULL;
-        }
-        // Check all nodes for integrity
-        const Node<T, _Compare> *pNode = _nodeRefs[0].pNode;
-        while (pNode) {
-            result = pNode->lacksIntegrity(_nodeRefs.height());
-            if (result) {
-                return result;
-            }
-            pNode = pNode->next();
-        }
-        // Check count against total number of nodes
-        pNode = _nodeRefs[0].pNode;
-        size_t total = 0;
-        while (pNode) {
-            total += pNode->nodeRefs()[0].width;
-            pNode = pNode->next();
-        }
-        if (total != _count) {
-            return HEADNODE_COUNT_MISMATCH;
-        }
-        result = _lacksIntegrityWidthAccumulation();
-        if (result) {
-            return result;
-        }
-        result = _lacksIntegrityCyclicReferences();
-        if (result) {
-            return result;
-        }
-        result = _lacksIntegrityNodeReferencesNotInList();
-        if (result) {
-            return result;
-        }
-        result = _lacksIntegrityOrder();
-        if (result) {
-            return result;
-        }
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * Returns an estimate of the memory usage of an instance.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @return The size of the memory estimate.
- */
-template <typename T, typename _Compare>
-size_t HeadNode<T, _Compare>::size_of() const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    // sizeof(*this) includes the size of _nodeRefs but _nodeRefs.size_of()
-    // includes sizeof(_nodeRefs) so we need to subtract to avoid double counting
-    size_t ret_val = sizeof(*this) + _nodeRefs.size_of() - sizeof(_nodeRefs);
-    if (_nodeRefs.height()) {
-        const Node<T, _Compare> *node = _nodeRefs[0].pNode;
-        while (node) {
-            ret_val += node->size_of();
-            node = node->next();
-        }
-    }
-    return ret_val;
-}
-
-/**
- * Destructor.
- * This deletes all Nodes.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- */
-template <typename T, typename _Compare>
-HeadNode<T, _Compare>::~HeadNode() {
-    // Hmm could this deadlock?
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    if (_nodeRefs.height()) {
-        // Traverse the lowest level list iteratively deleting as we go
-        // Doing this recursivley could be expensive as we are at level 0.
-        const Node<T, _Compare> *node = _nodeRefs[0].pNode;
-        const Node<T, _Compare> *next;
-        while (node) {
-            next = node->next();
-            delete node;
-            --_count;
-            node = next;
-        }
-    }
-    assert(_count == 0);
-}
-
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-
-/**
- * Create a DOT file of the internal representation.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param os Where to write the DOT file.
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::dotFile(std::ostream &os) const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    if (_dot_file_subgraph == 0) {
-        os << "digraph SkipList {" << std::endl;
-        os << "label = \"SkipList.\"" << std::endl;
-        os << "graph [rankdir = \"LR\"];" << std::endl;
-        os << "node [fontsize = \"12\" shape = \"ellipse\"];" << std::endl;
-        os << "edge [];" << std::endl;
-        os << std::endl;
-    }
-    os << "subgraph cluster" << _dot_file_subgraph << " {" << std::endl;
-    os << "style=dashed" << std::endl;
-    os << "label=\"Skip list iteration " << _dot_file_subgraph << "\"" << std::endl;
-    os << std::endl;
-    os << "\"HeadNode" << _dot_file_subgraph;
-    os << "\" [" << std::endl;
-    os << "label = \"";
-    // Write out the fields
-    if (_nodeRefs.height()) {
-        for (size_t level = _nodeRefs.height(); level-- > 0;) {
-            os << "{ " << _nodeRefs[level].width << " | ";
-            os << "<f" << level + 1 << "> ";
-            os << std::hex << _nodeRefs[level].pNode << std::dec;
-            os << "}";
-            if (level > 0) {
-                os << " | ";
-            }
-        }
-    } else {
-        os << "Empty HeadNode";
-    }
-    os << "\"" << std::endl;
-    os << "shape = \"record\"" << std::endl;
-    os << "];" << std::endl;
-    // Edges for head node
-    for (size_t level = 0; level < _nodeRefs.height(); ++level) {
-        os << "\"HeadNode";
-        os << _dot_file_subgraph;
-        os << "\":f" << level + 1 << " -> ";
-        _nodeRefs[level].pNode->writeNode(os, _dot_file_subgraph);
-        os << ":w" << level + 1 << " [];" << std::endl;
-    }
-    os << std::endl;
-    // Now all nodes via level 0, if non-empty
-    if (_nodeRefs.height()) {
-        Node<T, _Compare> *pNode = this->_nodeRefs[0].pNode;
-        pNode->dotFile(os, _dot_file_subgraph);
-    }
-    os << std::endl;
-    // NULL, the sentinal node
-    if (_nodeRefs.height()) {
-        os << "\"node";
-        os << _dot_file_subgraph;
-        os << "0x0\" [label = \"";
-        for (size_t level = _nodeRefs.height(); level-- > 0;) {
-            os << "<w" << level + 1 << "> NULL";
-            if (level) {
-                os << " | ";
-            }
-        }
-        os << "\" shape = \"record\"];" << std::endl;
-    }
-    // End: "subgraph cluster1 {"
-    os << "}" << std::endl;
-    os << std::endl;
-    _dot_file_subgraph += 1;
-}
-
-/**
- * Finalise the DOT file of the internal representation.
- *
- * @tparam T Type of the values in the Skip List.
- * @tparam _Compare Compare function.
- * @param os Where to write the DOT file.
- */
-template <typename T, typename _Compare>
-void HeadNode<T, _Compare>::dotFileFinalise(std::ostream &os) const {
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::lock_guard<std::mutex> lock(gSkipListMutex);
-#endif
-    if (_dot_file_subgraph > 0) {
-        // Link the nodes together with an invisible node.
-        //    node0 [shape=record, label = "<f0> | <f1> | <f2> | <f3> | <f4> | <f5> | <f6> | <f7> | <f8> | ",
-        //           style=invis,
-        //           width=0.01];
-        os << "node0 [shape=record, label = \"";
-        for (size_t i = 0; i < _dot_file_subgraph; ++i) {
-            os << "<f" << i << "> | ";
-        }
-        os << "\", style=invis, width=0.01];" << std::endl;
-        // Now:
-        //    node0:f0 -> HeadNode [style=invis];
-        //    node0:f1 -> HeadNode1 [style=invis];
-        for (size_t i = 0; i < _dot_file_subgraph; ++i) {
-            os << "node0:f" << i << " -> HeadNode" << i;
-            os << " [style=invis];" << std::endl;
-        }
-        _dot_file_subgraph = 0;
-    }
-    os << "}" << std::endl;
-}
-
-#endif // INCLUDE_METHODS_THAT_USE_STREAMS
-
-/************************** END: HeadNode *******************************/
-
-#endif // SkipList_HeadNode_h
diff --git a/src/duckdb/third_party/skiplist/IntegrityEnums.h b/src/duckdb/third_party/skiplist/IntegrityEnums.h
deleted file mode 100644
index 143d0a3e7..000000000
--- a/src/duckdb/third_party/skiplist/IntegrityEnums.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef SkipList_IntegrityEnums_h
-#define SkipList_IntegrityEnums_h
-
-/**
- * @file
- *
- * Project: skiplist
- *
- * Integrity codes for structures in this code.
- *
- * Created by Paul Ross on 11/12/2015.
- *
- * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
- *
- * @code
- * MIT License
- *
- * Copyright (c) 2015-2023 Paul Ross
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * @endcode
- */
-
-/**
- * Various integrity codes for structures in this code.
- */
-enum IntegrityCheck {
-    INTEGRITY_SUCCESS = 0,
-    // SwappableNodeRefStack integrity checks
-    NODEREFS_WIDTH_ZERO_NOT_UNITY = 100,
-    NODEREFS_WIDTH_DECREASING,
-    // Node integrity checks
-    NODE_HEIGHT_ZERO = 200,
-    NODE_HEIGHT_EXCEEDS_HEADNODE,
-    NODE_NON_NULL_AFTER_NULL,
-    NODE_SELF_REFERENCE,
-    NODE_REFERENCES_NOT_IN_GLOBAL_SET,
-    // HeadNode integrity checks
-    HEADNODE_CONTAINS_NULL = 300,
-    HEADNODE_COUNT_MISMATCH,
-    HEADNODE_LEVEL_WIDTHS_MISMATCH,
-    HEADNODE_DETECTS_CYCLIC_REFERENCE,
-    HEADNODE_DETECTS_OUT_OF_ORDER,
-};
-
-#endif
diff --git a/src/duckdb/third_party/skiplist/Node.h b/src/duckdb/third_party/skiplist/Node.h
deleted file mode 100644
index 28a0aed89..000000000
--- a/src/duckdb/third_party/skiplist/Node.h
+++ /dev/null
@@ -1,641 +0,0 @@
-/**
- * @file
- *
- * Project: skiplist
- *
- * Concurrency Tests.
- *
- * Created by Paul Ross on 03/12/2015.
- *
- * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
- *
- * @code
- * MIT License
- *
- * Copyright (c) 2015-2023 Paul Ross
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * @endcode
- */
-
-#ifndef SkipList_Node_h
-#define SkipList_Node_h
-
-#include "IntegrityEnums.h"
-
-#if __cplusplus < 201103L
-#define nullptr NULL
-#endif
-
-/**************************** Node *********************************/
-
-/**
- * @brief A single node in a Skip List containing a value and references to other downstream Node objects.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- */
-template <typename T, typename _Compare>
-class Node {
-public:
-	struct _Pool {
-		explicit _Pool(_Compare _cmp) : _compare(_cmp), cache(nullptr) {
-		}
-		~_Pool() {
-			delete cache;
-		}
-		Node *Allocate(const T &value) {
-			if (cache) {
-				Node *result = cache;
-				cache = nullptr;
-				result->Initialize(value);
-				return result;
-			}
-
-			return new Node(value, _compare, *this);
-		}
-
-		T Release(Node *pNode) {
-			T result = pNode->value();
-			std::swap(pNode, cache);
-			delete pNode;
-			return result;
-		}
-
-		_Compare _compare;
-		Node* cache;
-		pcg32_fast prng;
-	};
-
-    Node(const T &value, _Compare _cmp, _Pool &pool);
-    // Const methods
-    //
-    /// Returns the node value
-    const T &value() const { return _value; }
-    // Returns true if the value is present in the skip list from this node onwards.
-    bool has(const T &value) const;
-    // Returns the value at the index in the skip list from this node onwards.
-    // Will return nullptr is not found.
-    const Node<T, _Compare> *at(size_t idx) const;
-    // Computes index of the first occurrence of a value
-    bool index(const T& value, size_t &idx, size_t level) const;
-    /// Number of linked lists that this node engages in, minimum 1.
-    size_t height() const { return _nodeRefs.height(); }
-    // Return the pointer to the next node at level 0
-    const Node<T, _Compare> *next() const;
-    // Return the width at given level.
-    size_t width(size_t level) const;
-    // Return the node pointer at given level, only used for HeadNode
-    // integrity checks.
-    const Node<T, _Compare> *pNode(size_t level) const;
-
-    // Non-const methods
-    /// Get a reference to the node references
-    SwappableNodeRefStack<T, _Compare> &nodeRefs() { return _nodeRefs; }
-    /// Get a reference to the node references
-    const SwappableNodeRefStack<T, _Compare> &nodeRefs() const { return _nodeRefs; }
-    // Insert a node
-    Node<T, _Compare> *insert(const T &value);
-    // Remove a node
-    Node<T, _Compare> *remove(size_t call_level, const T &value);
-    // An estimate of the number of bytes used by this node
-    size_t size_of() const;
-
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-    void dotFile(std::ostream &os, size_t suffix = 0) const;
-    void writeNode(std::ostream &os, size_t suffix = 0) const;
-#endif // INCLUDE_METHODS_THAT_USE_STREAMS
-
-    // Integrity checks, returns non-zero on failure
-    IntegrityCheck lacksIntegrity(size_t headnode_height) const;
-    IntegrityCheck lacksIntegrityRefsInSet(const std::set<const Node<T, _Compare>*> &nodeSet) const;
-
-protected:
-    Node<T, _Compare> *_adjRemoveRefs(size_t level, Node<T, _Compare> *pNode);
-
-	void Initialize(const T &value) {
-		_value = value;
-		_nodeRefs.clear();
-		do {
-			_nodeRefs.push_back(this, _nodeRefs.height() ? 0 : 1);
-		} while (_pool.prng() < _pool.prng.max() / 2);
-	}
-
-protected:
-    T _value;
-    SwappableNodeRefStack<T, _Compare> _nodeRefs;
-    // Comparison function
-    _Compare _compare;
-    _Pool &_pool;
-private:
-    // Prevent cctor and operator=
-    Node(const Node &that);
-    Node &operator=(const Node &that) const;
-};
-
-/**
- * Constructor.
- * This also creates a SwappableNodeRefStack of random height by tossing a virtual coin.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param value The value of the Node.
- * @param _cmp The comparison function.
- */
-template <typename T, typename _Compare>
-Node<T, _Compare>::Node(const T &value, _Compare _cmp, _Pool &pool) : \
-    _value(value), _compare(_cmp), _pool(pool) {
-    Initialize(value);
-}
-
-/**
- * Returns true if the value is present in the skip list from this node onwards.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param value The value to look for.
- * @return true if the value is present in the skip list from this node onwards.
- */
-template <typename T, typename _Compare>
-bool Node<T, _Compare>::has(const T &value) const {
-    assert(_nodeRefs.height());
-    assert(value == value); // value can not be NaN for example
-    // Effectively: if (value > _value) {
-    if (_compare(_value, value)) {
-        for (size_t l = _nodeRefs.height(); l-- > 0;) {
-            if (_nodeRefs[l].pNode && _nodeRefs[l].pNode->has(value)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    // Effectively: return value == _value; // false if value smaller
-    return !_compare(value, _value) && !_compare(_value, value);
-}
-
-/**
- * Return a pointer to the n'th node.
- * Start (or continue) from the highest level, drop down a level if not found.
- * Return nullptr if not found at level 0.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param idx The index from hereon. If zero return this.
- * @return Pointer to the Node or nullptr.
- */
-template <typename T, typename _Compare>
-const Node<T, _Compare> *Node<T, _Compare>::at(size_t idx) const {
-    assert(_nodeRefs.height());
-    if (idx == 0) {
-        return this;
-    }
-    for (size_t l = _nodeRefs.height(); l-- > 0;) {
-        if (_nodeRefs[l].pNode && _nodeRefs[l].width <= idx) {
-            return _nodeRefs[l].pNode->at(idx - _nodeRefs[l].width);
-        }
-    }
-    return nullptr;
-}
-
-/**
- * Computes index of the first occurrence of a value.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param value The value to find.
- * @param idx The current index, this will be updated.
- * @param level The current level to search from.
- * @return true if found, false otherwise.
- */
-template <typename T, typename _Compare>
-bool Node<T, _Compare>::index(const T& value, size_t &idx, size_t level) const {
-    assert(_nodeRefs.height());
-    assert(value == value); // value can not be NaN for example
-    assert(level < _nodeRefs.height());
-    // Search has overshot, try again at a lower level.
-    //if (_value > value) {
-    if (_compare(value, _value)) {
-        return false;
-    }
-    // First check if we match but we have been approached at a high level
-    // as there may be an earlier node of the same value but with fewer
-    // node references. In that case this search has to fail and try at a
-    // lower level.
-    // If however the level is 0 and we match then set the idx to 0 to mark us.
-    // Effectively: if (_value == value) {
-    if (!_compare(value, _value) && !_compare(_value, value)) {
-        if (level > 0) {
-            return false;
-        }
-        idx = 0;
-        return true;
-    }
-    // Now work our way down
-    // NOTE: We initialise l as level + 1 because l-- > 0 will decrement it to
-    // the correct initial value
-    for (size_t l = level + 1; l-- > 0;) {
-        assert(l < _nodeRefs.height());
-        if (_nodeRefs[l].pNode && _nodeRefs[l].pNode->index(value, idx, l)) {
-            idx += _nodeRefs[l].width;
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * Return the pointer to the next node at level 0.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @return The next node at level 0.
- */
-template <typename T, typename _Compare>
-const Node<T, _Compare> *Node<T, _Compare>::next() const {
-    assert(_nodeRefs.height());
-    return _nodeRefs[0].pNode;
-}
-
-/**
- * Return the width at given level.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param level The requested level.
- * @return The width.
- */
-template <typename T, typename _Compare>
-size_t Node<T, _Compare>::width(size_t level) const {
-    assert(level < _nodeRefs.height());
-    return _nodeRefs[level].width;
-}
-
-/**
- * Return the node pointer at given level, only used for HeadNode integrity checks.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param level The requested level.
- * @return The Node.
- */
-template <typename T, typename _Compare>
-const Node<T, _Compare> *Node<T, _Compare>::pNode(size_t level) const {
-    assert(level < _nodeRefs.height());
-    return _nodeRefs[level].pNode;
-}
-
-/**
- * Insert a new node with a value.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param value The value of the Node to insert.
- * @return Pointer to the new Node or nullptr on failure.
- */
-template <typename T, typename _Compare>
-Node<T, _Compare> *Node<T, _Compare>::insert(const T &value) {
-    assert(_nodeRefs.height());
-    assert(_nodeRefs.noNodePointerMatches(this));
-    assert(! _nodeRefs.canSwap());
-    assert(value == value); // NaN check for double
-
-    // Effectively: if (value < _value) {
-    if (_compare(value, _value)) {
-        return nullptr;
-    }
-    // Recursive search for where to put the node
-    Node<T, _Compare> *pNode = nullptr;
-    size_t level = _nodeRefs.height();
-    // Effectively: if (value >= _value) {
-    if (! _compare(value, _value)) {
-        for (level = _nodeRefs.height(); level-- > 0;) {
-            if (_nodeRefs[level].pNode) {
-                pNode = _nodeRefs[level].pNode->insert(value);
-                if (pNode) {
-                    break;
-                }
-            }
-        }
-    }
-    // Effectively: if (! pNode && value >= _value) {
-    if (! pNode && !_compare(value, _value)) {
-        // Insert new node here
-        pNode = _pool.Allocate(value);
-        level = 0;
-    }
-    assert(pNode); // Should never get here unless a NaN has slipped through
-    // Adjust references by marching up and recursing back.
-    SwappableNodeRefStack<T, _Compare> &thatRefs = pNode->_nodeRefs;
-    if (! thatRefs.canSwap()) {
-        // Have an existing node or new node that is all swapped.
-        // All I need to do is adjust my overshooting nodes and return
-        // this for the caller to do the same.
-        level = thatRefs.height();
-        while (level < _nodeRefs.height()) {
-            _nodeRefs[level].width += 1;
-            ++level;
-        }
-        // The caller just has to increment its references that overshoot this
-        assert(! _nodeRefs.canSwap());
-        return this;
-    }
-    // March upwards
-    if (level < thatRefs.swapLevel()) {
-        assert(level == thatRefs.swapLevel() - 1);
-        // This will happen when say a 3 high node, A, finds a 2 high
-        // node, B, that creates a new 2+ high node. A will be at
-        // level 1 and the new node will have swapLevel == 2 after
-        // B has swapped.
-        // Add the level to the accumulator at the next level
-        thatRefs[thatRefs.swapLevel()].width += _nodeRefs[level].width;
-        ++level;
-    }
-    size_t min_height = std::min(_nodeRefs.height(), thatRefs.height());
-    while (level < min_height) {
-        assert(thatRefs.canSwap());
-        assert(level == thatRefs.swapLevel());
-        assert(level < thatRefs.height());
-        assert(_nodeRefs[level].width > 0);
-        assert(thatRefs[level].width > 0);
-        _nodeRefs[level].width -= thatRefs[level].width - 1;
-        assert(_nodeRefs[level].width > 0);
-        thatRefs.swap(_nodeRefs);
-        if (thatRefs.canSwap()) {
-            assert(thatRefs[thatRefs.swapLevel()].width == 0);
-            thatRefs[thatRefs.swapLevel()].width = _nodeRefs[level].width;
-        }
-        ++level;
-    }
-    // Upwards march complete, now recurse back ('left').
-    if (! thatRefs.canSwap()) {
-        // All done with pNode locally.
-        assert(level == thatRefs.height());
-        assert(thatRefs.height() <= _nodeRefs.height());
-        assert(level == thatRefs.swapLevel());
-        // Adjust my overshooting nodes
-        while (level < _nodeRefs.height()) {
-            _nodeRefs[level].width += 1;
-            ++level;
-        }
-        // The caller just has to increment its references that overshoot this
-        assert(! _nodeRefs.canSwap());
-        pNode = this;
-    }
-    return pNode;
-}
-
-/**
- * Adjust the Node references.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param level The level of the caller's node.
- * @param pNode The Node to swap references with.
- * @return The Node with swapped references.
- */
-template <typename T, typename _Compare>
-Node<T, _Compare> *Node<T, _Compare>::_adjRemoveRefs(size_t level, Node<T, _Compare> *pNode) {
-    assert(pNode);
-    SwappableNodeRefStack<T, _Compare> &thatRefs = pNode->_nodeRefs;
-
-    assert(pNode != this);
-    if (level < thatRefs.swapLevel()) {
-        assert(level == thatRefs.swapLevel() - 1);
-        ++level;
-    }
-    if (thatRefs.canSwap()) {
-        assert(level == thatRefs.swapLevel());
-        while (level < _nodeRefs.height() && thatRefs.canSwap()) {
-            assert(level == thatRefs.swapLevel());
-            // Compute the new width for the new node
-            thatRefs[level].width += _nodeRefs[level].width - 1;
-            thatRefs.swap(_nodeRefs);
-            ++level;
-        }
-        assert(thatRefs.canSwap() || thatRefs.allNodePointerMatch(pNode));
-    }
-    // Decrement my widths as my refs are over the top of the missing pNode.
-    while (level < _nodeRefs.height()) {
-        _nodeRefs[level].width -= 1;
-        ++level;
-        thatRefs.incSwapLevel();
-    }
-    assert(! _nodeRefs.canSwap());
-    return pNode;
-}
-
-/**
- * Remove a Node with the given value to be removed.
- * The return value must be deleted, the other Nodes have been adjusted as required.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param call_level Level the caller Node is at.
- * @param value Value of the detached Node to remove.
- * @return A pointer to the Node to be free'd or nullptr on failure.
- */
-template <typename T, typename _Compare>
-Node<T, _Compare> *Node<T, _Compare>::remove(size_t call_level,
-                         const T &value) {
-    assert(_nodeRefs.height());
-    assert(_nodeRefs.noNodePointerMatches(this));
-
-    Node<T, _Compare> *pNode = nullptr;
-    // Effectively: if (value >= _value) {
-    if (!_compare(value, _value)) {
-        for (size_t level = call_level + 1; level-- > 0;) {
-            if (_nodeRefs[level].pNode) {
-                // Make progress to the right
-                pNode = _nodeRefs[level].pNode->remove(level, value);
-                if (pNode) {
-                    return _adjRemoveRefs(level, pNode);
-                }
-            }
-            // Make progress down
-        }
-    }
-    if (! pNode) { // Base case
-        // We only admit to being the node to remove if the caller is
-        // approaching us from level 0. It is entirely likely that
-        // the same (or an other) caller can see us at a higher level
-        // but the recursion stack will not have been set up in the correct
-        // step wise fashion so that the lower level references will
-        // not be swapped.
-        // Effectively: if (call_level == 0 && value == _value) {
-        if (call_level == 0 && !_compare(value, _value) && !_compare(_value, value)) {
-            _nodeRefs.resetSwapLevel();
-            return this;
-        }
-    }
-    assert(pNode == nullptr);
-    return nullptr;
-}
-
-/*
- * This checks the internal consistency of a Node. It returns 0
- * if successful, non-zero on error. The tests are:
- *
- * - Height must be >= 1
- * - Height must not exceed HeadNode height.
- * - NULL pointer must not have a non-NULL above them.
- * - Node pointers must not be self-referential.
- */
-/**
- * This checks the internal consistency of a Node. It returns 0
- * if successful, non-zero on error. The tests are:
- *
- * - Height must be >= 1
- * - Height must not exceed HeadNode height.
- * - NULL pointer must not have a non-NULL above them.
- * - Node pointers must not be self-referential.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param headnode_height Height of HeadNode.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck Node<T, _Compare>::lacksIntegrity(size_t headnode_height) const {
-    IntegrityCheck result = _nodeRefs.lacksIntegrity();
-    if (result) {
-        return result;
-    }
-    if (_nodeRefs.height() == 0) {
-        return NODE_HEIGHT_ZERO;
-    }
-    if (_nodeRefs.height() > headnode_height) {
-        return NODE_HEIGHT_EXCEEDS_HEADNODE;
-    }
-    // Test: All nodes above a nullprt must be nullptr
-    size_t level = 0;
-    while (level < _nodeRefs.height()) {
-        if (! _nodeRefs[level].pNode) {
-            break;
-        }
-        ++level;
-    }
-    while (level < _nodeRefs.height()) {
-        if (_nodeRefs[level].pNode) {
-            return NODE_NON_NULL_AFTER_NULL;
-        }
-        ++level;
-    }
-    // No reference should be to self.
-    if (! _nodeRefs.noNodePointerMatches(this)) {
-        return NODE_SELF_REFERENCE;
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * Checks that this Node is in the set held by the HeadNode.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param nodeSet Set of Nodes held by the HeadNode.
- * @return An IntegrityCheck enum.
- */
-template <typename T, typename _Compare>
-IntegrityCheck Node<T, _Compare>::lacksIntegrityRefsInSet(const std::set<const Node<T, _Compare>*> &nodeSet) const {
-    size_t level = 0;
-    while (level < _nodeRefs.height()) {
-        if (nodeSet.count(_nodeRefs[level].pNode) == 0) {
-            return NODE_REFERENCES_NOT_IN_GLOBAL_SET;
-        }
-        ++level;
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * Returns an estimate of the memory usage of an instance.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @return The memory estimate of this Node.
- */
-template <typename T, typename _Compare>
-size_t Node<T, _Compare>::size_of() const {
-    // sizeof(*this) includes the size of _nodeRefs but _nodeRefs.size_of()
-    // includes sizeof(_nodeRefs) so we need to subtract to avoid double counting
-    return sizeof(*this) + _nodeRefs.size_of() - sizeof(_nodeRefs);
-}
-
-
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-
-/**
- * Writes out this Node address.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param os Where to write.
- * @param suffix The suffix (node number).
- */
-template <typename T, typename _Compare>
-void Node<T, _Compare>::writeNode(std::ostream &os, size_t suffix) const {
-    os << "\"node";
-    os << suffix;
-    os << std::hex << this << std::dec << "\"";
-}
-
-/**
- * Writes out a fragment of a DOT file representing this Node.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param os Wheere to write.
- * @param suffix The node number.
- */
-template <typename T, typename _Compare>
-void Node<T, _Compare>::dotFile(std::ostream &os, size_t suffix) const {
-    assert(_nodeRefs.height());
-    writeNode(os, suffix);
-    os << " [" << std::endl;
-    os << "label = \"";
-    for (size_t level = _nodeRefs.height(); level-- > 0;) {
-        os << " { <w" << level + 1 << "> " << _nodeRefs[level].width;
-        os << " | <f" << level + 1 << "> ";
-        os << std::hex << _nodeRefs[level].pNode << std::dec;
-        os << " }";
-        os << " |";
-    }
-    os << " <f0> " << _value << "\"" << std::endl;
-    os << "shape = \"record\"" << std::endl;
-    os << "];" << std::endl;
-    // Now edges
-    for (size_t level = 0; level < _nodeRefs.height(); ++level) {
-        writeNode(os, suffix);
-        os << ":f" << level + 1 << " -> ";
-        _nodeRefs[level].pNode->writeNode(os, suffix);
-        //        writeNode(os, suffix);
-        //        os << ":f" << i + 1 << " [];" << std::endl;
-        os << ":w" << level + 1 << " [];" << std::endl;
-    }
-    assert(_nodeRefs.height());
-    if (_nodeRefs[0].pNode) {
-        _nodeRefs[0].pNode->dotFile(os, suffix);
-    }
-}
-
-#endif // INCLUDE_METHODS_THAT_USE_STREAMS
-
-/************************** END: Node *******************************/
-
-#endif // SkipList_Node_h
diff --git a/src/duckdb/third_party/skiplist/NodeRefs.h b/src/duckdb/third_party/skiplist/NodeRefs.h
deleted file mode 100644
index 839752e43..000000000
--- a/src/duckdb/third_party/skiplist/NodeRefs.h
+++ /dev/null
@@ -1,251 +0,0 @@
-//
-//  NodeRefs.h
-//  SkipList
-//
-//  Created by Paul Ross on 03/12/2015.
-//  Copyright (c) 2017 Paul Ross. All rights reserved.
-//
-
-#ifndef SkipList_NodeRefs_h
-#define SkipList_NodeRefs_h
-
-#include "IntegrityEnums.h"
-
-/// Forward reference
-template<typename T, typename _Compare>
-class Node;
-
-/**
- * @brief A PoD struct that contains a pointer to a Node and a width that represents the coarser linked list span to the
- * next Node.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- */
-template<typename T, typename _Compare=std::less<T> >
-struct NodeRef {
-    Node<T, _Compare> *pNode;
-    size_t width;
-};
-
-/******************** SwappableNodeRefStack **********************/
-
-/**
- * @brief Class that represents a stack of references to other nodes.
- *
- * Each reference is a NodeRef so a pointer to a Node and a width.
- * This just does simple bookkeeping on this stack.
- *
- * It also facilitates swapping references with another SwappableNodeRefStack when inserting or removing a Node.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- */
-template<typename T, typename _Compare>
-class SwappableNodeRefStack {
-public:
-    /**
-     * Constructor. Initialises the swap level to 0.
-     */
-    SwappableNodeRefStack() : _swapLevel(0) {}
-
-    // Const methods
-    // -------------
-    // Subscript read/write
-    const NodeRef<T, _Compare> &operator[](size_t level) const;
-
-    NodeRef<T, _Compare> &operator[](size_t level);
-
-    /// Number of nodes referenced.
-    size_t height() const {
-        return _nodes.size();
-    }
-
-    /// The current swap level
-    size_t swapLevel() const { return _swapLevel; }
-
-    /// true if a swap can take place <tt>_swapLevel < height()</tt>
-    bool canSwap() const { return _swapLevel < height(); }
-
-    // Returns true if there is no record of p in my data that
-    // could lead to circular references
-    bool noNodePointerMatches(const Node<T, _Compare> *p) const;
-
-    // Returns true if all pointers in my data are equal to p.
-    bool allNodePointerMatch(const Node<T, _Compare> *p) const;
-
-    // Non-const methods
-    // -----------------
-    /// Add a new reference
-    void push_back(Node<T, _Compare> *p, size_t w) {
-        struct NodeRef<T, _Compare> val = {p, w};
-        _nodes.push_back(val);
-    }
-
-    /// Remove top reference
-    void pop_back() {
-        _nodes.pop_back();
-    }
-
-    // Swap reference at current swap level with another SwappableNodeRefStack
-    void swap(SwappableNodeRefStack<T, _Compare> &val);
-
-    /// Reset the swap level (for example before starting a remove).
-    void resetSwapLevel() { _swapLevel = 0; }
-
-    /// Increment the swap level.
-    /// This is used when removing nodes where the parent node can record to what level it has made its adjustments
-    /// so the grand parent knows where to start.
-    ///
-    /// For this reason the _swapLevel can easily be <tt>>= _nodes.size()</tt>.
-    void incSwapLevel() { ++_swapLevel; }
-
-    IntegrityCheck lacksIntegrity() const;
-
-    // Returns an estimate of the memory usage of an instance
-    size_t size_of() const;
-
-	// Resets to the construction state
-	void clear() { _swapLevel = 0; _nodes.clear(); }
-
-protected:
-    /// Stack of NodeRef node references.
-    std::vector<struct NodeRef<T, _Compare> > _nodes;
-    /// The current swap level.
-    size_t _swapLevel;
-
-private:
-    /// Prevent cctor
-    SwappableNodeRefStack(const SwappableNodeRefStack &that);
-
-    /// Prevent operator=
-    SwappableNodeRefStack &operator=(const SwappableNodeRefStack &that) const;
-};
-
-/**
- * The readable NodeRef at the given level.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param level The level.
- * @return A reference to the Node.
- */
-template<typename T, typename _Compare>
-const NodeRef<T, _Compare> &SwappableNodeRefStack<T, _Compare>::operator[](size_t level) const {
-    // NOTE: No bounds checking on vector::operator[], so this assert will do
-    assert(level < _nodes.size());
-    return _nodes[level];
-}
-
-/**
- * The writeable NodeRef at the given level.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param level The level.
- * @return A reference to the Node.
- */
-template<typename T, typename _Compare>
-NodeRef<T, _Compare> &SwappableNodeRefStack<T, _Compare>::operator[](size_t level) {
-    // NOTE: No bounds checking on vector::operator[], so this assert will do
-    assert(level < _nodes.size());
-    return _nodes[level];
-}
-
-/**
- * Whether all node references are swapped.
- * Should be true after an insert operation.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param p The Node.
- * @return true if all the Node references are swapped (none are referring to the given Node).
- */
-template<typename T, typename _Compare>
-bool SwappableNodeRefStack<T, _Compare>::noNodePointerMatches(const Node<T, _Compare> *p) const {
-    for (size_t level = height(); level-- > 0;) {
-        if (p == _nodes[level].pNode) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/**
- * Returns true if all pointers in my data are equal to p.
- * Should be true after a remove operation.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param p The Node.
- * @return true if all the Node references are un-swapped (all are referring to the given Node).
- */
-template<typename T, typename _Compare>
-bool SwappableNodeRefStack<T, _Compare>::allNodePointerMatch(const Node<T, _Compare> *p) const {
-    for (size_t level = height(); level-- > 0;) {
-        if (p != _nodes[level].pNode) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/**
- * Swap references with another SwappableNodeRefStack at the current swap level.
- * This also increments the swap level.
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @param val The SwappableNodeRefStack.
- */
-template<typename T, typename _Compare>
-void SwappableNodeRefStack<T, _Compare>::swap(SwappableNodeRefStack<T, _Compare> &val) {
-    assert(_swapLevel < height());
-    NodeRef<T, _Compare> temp = val[_swapLevel];
-    val[_swapLevel] = _nodes[_swapLevel];
-    _nodes[_swapLevel] = temp;
-    ++_swapLevel;
-}
-
-/**
- * This checks the internal consistency of the object. It returns
- * INTEGRITY_SUCCESS [0] if successful or non-zero on error.
- * The tests are:
- *
- * - Widths must all be >= 1
- * - Widths must be weakly increasing with increasing level
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @return An IntegrityCheck enum.
- */
-template<typename T, typename _Compare>
-IntegrityCheck SwappableNodeRefStack<T, _Compare>::lacksIntegrity() const {
-    if (height()) {
-        if (_nodes[0].width != 1) {
-            return NODEREFS_WIDTH_ZERO_NOT_UNITY;
-        }
-        for (size_t level = 1; level < height(); ++level) {
-            if (_nodes[level].width < _nodes[level - 1].width) {
-                return NODEREFS_WIDTH_DECREASING;
-            }
-        }
-    }
-    return INTEGRITY_SUCCESS;
-}
-
-/**
- * Returns an estimate of the memory usage of an instance
- *
- * @tparam T The type of the Skip List Node values.
- * @tparam _Compare A comparison function for type T.
- * @return The memory estimate.
- */
-template<typename T, typename _Compare>
-size_t SwappableNodeRefStack<T, _Compare>::size_of() const {
-    return sizeof(*this) + _nodes.capacity() * sizeof(struct NodeRef<T>);
-}
-
-/********************* END: SwappableNodeRefStack ****************************/
-
-#endif // SkipList_NodeRefs_h
diff --git a/src/duckdb/third_party/skiplist/RollingMedian.h b/src/duckdb/third_party/skiplist/RollingMedian.h
deleted file mode 100644
index 604a1f221..000000000
--- a/src/duckdb/third_party/skiplist/RollingMedian.h
+++ /dev/null
@@ -1,202 +0,0 @@
-#ifndef __SkipList__RollingMedian__
-#define __SkipList__RollingMedian__
-
-/**
- * @file
- *
- * Project: skiplist
- *
- * Rolling Median.
- *
- * Created by Paul Ross on 18/12/2015.
- *
- * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
- *
- * @code
- * MIT License
- *
- * Copyright (c) 2015-2023 Paul Ross
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * @endcode
- */
-
-#include <stdlib.h>
-
-#include "SkipList.h"
-
-namespace OrderedStructs {
-    /**
-     * @brief Namespace for the C++ Rolling Median.
-     */
-    namespace RollingMedian {
-
-/**
- * Error codes.
- */
-        enum RollingMedianResult {
-            ROLLING_MEDIAN_SUCCESS = 0,
-            ROLLING_MEDIAN_SOURCE_STRIDE,
-            ROLLING_MEDIAN_DESTINATION_STRIDE,
-            ROLLING_MEDIAN_WIN_LENGTH,
-        };
-
-/**
- * Return an error code.
- */
-#define ROLLING_MEDIAN_ERROR_CHECK                      \
-    do {                                                \
-        if (src_stride == 0) {                          \
-            return ROLLING_MEDIAN_SOURCE_STRIDE;        \
-        }                                               \
-        if (dest_stride == 0) {                         \
-            return ROLLING_MEDIAN_DESTINATION_STRIDE;   \
-        }                                               \
-        if (win_length == 0) {                          \
-            return ROLLING_MEDIAN_WIN_LENGTH;           \
-        }                                               \
-    } while (0)
-
-/* Helpers for the destination memory area.
- * Iterating through the destination to see the replaced values is done thus:
- *
- * for (int i = 0;
- *      i < RollingMedian::dest_size(COUNT, WIN_LENGTH, DEST_STRIDE);
- *      i += DEST_STRIDE) {
- *    ...
- * }
- */
-
-/**
- * Returns the size of the destination array for a rolling median on an array
- * of count values with a window of win_length and a destination stride.
- *
- * @param count Number of input values.
- * @param win_length Window length.
- * @return Number of destination values.
- */
-        size_t dest_count(size_t count, size_t win_length) {
-            return 1 + count - win_length;
-        }
-
-/**
- * Returns the size of the destination array for a rolling median on an array
- * of count values with a window of win_length and a destination stride.
- *
- * @param count Number of input values.
- * @param win_length Window length.
- * @param dest_stride The destination stride given a 2D array.
- * @return Size of destination array.
- */
-        size_t dest_size(size_t count,
-                         size_t win_length,
-                         size_t dest_stride) {
-            return dest_count(count, win_length) * dest_stride;
-        }
-
-/**
- * Rolling median where only the odd mid-index is considered.
- * If the win_length is even then (win_length - 1) / 2 value is used.
- * See even_odd_index() for a different treatment of even lengths.
- * This is valid for all types T.
- * It is up to the caller to ensure that there is enough space in dest for
- * the results, use dest_size() for this.
- *
- * @tparam T Type of the value(s).
- * @param src Source array of values.
- * @param src_stride Source stride for 2D arrays.
- * @param count Number of input values.
- * @param win_length Window length.
- * @param dest The destination array.
- * @param dest_stride The destination stride given a 2D array.
- * @return The result of the Rolling Median operation as a RollingMedianResult enum.
- */
-        template<typename T>
-        RollingMedianResult odd_index(const T *src, size_t src_stride,
-                                      size_t count, size_t win_length,
-                                      T *dest, size_t dest_stride) {
-            SkipList::HeadNode<T> sl;
-            const T *tail = src;
-
-            ROLLING_MEDIAN_ERROR_CHECK;
-            for (size_t i = 0; i < count; ++i) {
-                sl.insert(*src);
-                if (i + 1 >= win_length) {
-                    *dest = sl.at(win_length / 2);
-                    dest += dest_stride;
-                    sl.remove(*tail);
-                    tail += src_stride;
-                }
-                src += src_stride;
-            }
-            return ROLLING_MEDIAN_SUCCESS;
-        }
-
-/*
- */
-/**
- * Rolling median where the mean of adjacent values is used
- * when the window size is even length.
- * This requires T / 2 to be meaningful.
- * It is up to the caller to ensure that there is enough space in dest for
- * the results, use dest_size() for this.
- *
- * @tparam T Type of the value(s).
- * @param src Source array of values.
- * @param src_stride Source stride for 2D arrays.
- * @param count Number of input values.
- * @param win_length Window length.
- * @param dest The destination array.
- * @param dest_stride The destination stride given a 2D array.
- * @return The result of the Rolling Median operation as a RollingMedianResult enum.
- */
-        template<typename T>
-        RollingMedianResult even_odd_index(const T *src, size_t src_stride,
-                                           size_t count, size_t win_length,
-                                           T *dest, size_t dest_stride) {
-            if (win_length % 2 == 1) {
-                return odd_index(src, src_stride,
-                                 count, win_length,
-                                 dest, dest_stride);
-            } else {
-                ROLLING_MEDIAN_ERROR_CHECK;
-                SkipList::HeadNode<T> sl;
-                std::vector<T> buffer;
-
-                const T *tail = src;
-                for (size_t i = 0; i < count; ++i) {
-                    sl.insert(*src);
-                    if (i + 1 >= win_length) {
-                        sl.at((win_length - 1) / 2, 2, buffer);
-                        assert(buffer.size() == 2);
-                        *dest = buffer[0] / 2 + buffer[1] / 2;
-                        dest += dest_stride;
-                        sl.remove(*tail);
-                        tail += src_stride;
-                    }
-                    src += src_stride;
-                }
-            }
-            return ROLLING_MEDIAN_SUCCESS;
-        }
-
-    } // namespace RollingMedian
-} // namespace OrderedStructs
-
-#endif /* defined(__SkipList__RollingMedian__) */
diff --git a/src/duckdb/third_party/skiplist/SkipList.cpp b/src/duckdb/third_party/skiplist/SkipList.cpp
deleted file mode 100644
index b53affd25..000000000
--- a/src/duckdb/third_party/skiplist/SkipList.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-//  SkipList.cpp
-//  SkipList
-//
-//  Created by Paul Ross on 19/12/2015.
-//  Copyright (c) 2017 Paul Ross. All rights reserved.
-//
-
-#include <cstdlib>
-#ifdef SKIPLIST_THREAD_SUPPORT
-#include <mutex>
-#endif
-#include <string>
-
-#include "SkipList.h"
-
-namespace duckdb_skiplistlib {
-namespace skip_list {
-
-// This throws an IndexError when the index value >= size.
-// If possible the error will have an informative message.
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-void _throw_exceeds_size(size_t index) {
-    std::ostringstream oss;
-    oss << "Index out of range 0 <= index < " << index;
-    std::string err_msg = oss.str();
-#else
-void _throw_exceeds_size(size_t /* index */) {
-    std::string err_msg = "Index out of range.";
-#endif
-    throw IndexError(err_msg);
-}
-
-#ifdef SKIPLIST_THREAD_SUPPORT
-    std::mutex gSkipListMutex;
-#endif
-
-
-} // namespace SkipList
-} // namespace OrderedStructs
diff --git a/src/duckdb/third_party/skiplist/SkipList.h b/src/duckdb/third_party/skiplist/SkipList.h
deleted file mode 100644
index 5b015acc3..000000000
--- a/src/duckdb/third_party/skiplist/SkipList.h
+++ /dev/null
@@ -1,548 +0,0 @@
-#ifndef __SkipList__SkipList__
-#define __SkipList__SkipList__
-
-/**
- * @file
- *
- * Project: skiplist
- *
- * Created by Paul Ross on 15/11/2015.
- *
- * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
- *
- * @code
- * MIT License
- *
- * Copyright (c) 2017-2023 Paul Ross
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * @endcode
- */
-
-/** @mainpage
- *
- * General
- * =======
- * This is a generic skip list implementation for any type T.
- * There only restriction on the size of this skip list is the available memory.
- *
- * A skip list is a singly linked list of ordered nodes with a series of other, coarser, lists that reference a subset
- * of nodes in order.
- * 'Level' is an size_t that specifies the coarseness of the linked list, level 0 is the linked list to every node.
- *
- * Typically:
- * - The list at level 1 links (ideally) to every other node.
- * - The list at level 2 links (ideally) to every fourth node and so on.
- *
- * In general the list at level n links (ideally) to every 2**n node.
- *
- * These additional lists allow rapid location, insertion and removal of nodes.
- * These lists are created and updated in a probabilistic manner and this is achieved at node creation time by tossing a
- * virtual coin.
- * These lists are not explicit, they are implied by the references between Nodes at a particular level.
- *
- * Skip lists are alternatives to balanced trees for operations such as a rolling median.
- * The disadvantages of skip lists are:
-    - Less space efficient than balanced trees (see 'Space Complexity' below).
-    - performance is similar to balanced trees except finding the mid-point which is @c O(log(N)) for a skip list
-        compared with @c O(1) for a balanced tree.
- *
- * The advantages claimed for skip lists are:
-    - The insert() and remove() logic is simpler (I do not subscribe to this).
- *
- * Examples of Usage
- * =================
- *
- * C++
- * ---
- * @code
- * #include "SkipList.h"
- *
- * OrderedStructs::SkipList::HeadNode<double> sl;
- *
- * sl.insert(42.0);
- * sl.insert(21.0);
- * sl.insert(84.0);
- * sl.has(42.0) // true
- * sl.size() // 3
- * sl.at(1) // 42.0
- * @endcode
- *
- * Python
- * ------
- * @code
- * import orderedstructs
- *
- * sl = orderedstructs.SkipList(float)
- * sl.insert(42.0)
- * sl.insert(21.0)
- * sl.insert(84.0)
- * sl.has(42.0) # True
- * sl.size() # 3
- * sl.at(1) # 42.0
- * @endcode
- *
- * Design
- * ======
- *
- * This skip list design has the coarser lists implemented as optional additional links between the nodes themselves.
- * The drawing below shows a well formed skip list with a head node ('HED') linked to the ordered nodes A to H.
- *
- * @code
- *
- | 5 E |------------------------------------->| 4 0 |---------------------------->| NULL |
- | 1 A |->| 2 C |---------->| 2 E |---------->| 2 G |---------->| 2 0 |---------->| NULL |
- | 1 A |->| 1 B |->| 1 C |->| 1 D |->| 1 E |->| 1 F |->| 1 G |->| 1 H |->| 1 0 |->| NULL |
- | HED |  |  A  |  |  B  |  |  C  |  |  D  |  |  E  |  |  F  |  |  G  |  |  H  |
- * @endcode
- *
- * Each node has a stack of values that consist of a 'width' and a reference to another node (or NULL).
- * At the lowest level is a singly linked list and all widths are 1.
- * At level 1 the links are (ideally) to every other node and at level 2 the links are (ideally) to every fourth node.
- * The 'widths' at each node/level specify how many level 0 nodes the node reference skips over.
- * The widths are used to rapidly index into the skip list starting from the highest level and working down.
- *
- * To understand how the skip list is maintained, consider insertion; before inserting node 'E' the skip list would look
- * like this:
- *
- * @code
- *
- | 1 A |->| 2 C |---------->| 3 G |------------------->| 2 0 |---------->| NULL |
- | 1 A |->| 1 B |->| 1 C |->| 1 D |->| 1 F |->| 1 G |->| 1 H |->| 1 0 |->| NULL |
- | HED |  |  A  |  |  B  |  |  C  |  |  D  |  |  F  |  |  G  |  |  H  |
- *
- * @endcode
- *
- * Inserting 'E' means:
- * - Finding where 'E' should be inserted (after 'D').
- * - Creating node 'E' with a random height (heads/heads/tails so 3 high).
- * - Updating 'D' to refer to 'E' at level 0.
- * - Updating 'C' to refer to 'E' at level 1 and decreasing C's width to 2, increasing 'E' width at level 1 to 2.
- * - Expanding HED to level 2 with a reference to 'E' and a width of 5.
- * - Updating 'E' with a reference to NULL and a width of 4.
- *
- * Recursive Search for the Node Position
- * --------------------------------------
- * The first two operations are done by a recursive search.
- * This creates the chain HED[1], A[1], C[1], C[0], D[0] thus E will be created at level 0 and inserted after D.
- *
- * Node Creation
- * -------------
- * Node E is created with a stack containing a single pointer to the next node F.
- * Then a virtual coin is tossed, for each 'head' and extra NULL reference is added to the stack.
- * If a 'tail' is thrown the stack is complete.
- * In the example above when creating Node E we have encountered tosses of 'head', 'head', 'tail'.
- *
- * Recursive Unwinding
- * -------------------
- * The remaining operations are done as recursion unwinds:
- *
- * - D[0] and C[0] update E[1] with their cumulative width (2).
- * - C[1] adds 1 to width (a new node is inserted) then subtracts E[1].
- * - Then C[1]/E[1] are swapped so that the pointers and widths are correct.
- * - And so on until HED is reached, in this case a new level is added and HED[2] swapped with E[2].
- *
- * A similar procedure will be followed, in reverse, when removing E to restore the state of the skip list to the
- * picture above.
- *
- * Algorithms
- * ==========
- * There doesn't seem to be much literature that I could find about the algorithms used for a skip list so these have
- * all been invented here.
- *
- * In these descriptions:
- *
- * - 'right' is used to mean move to a higher ordinal node.
- * - 'left' means to move to a lower ordinal node.
- * - 'up' means to move to a coarser grained list, 'top' is the highest.
- * - 'down' means to move to a finer grained list, 'bottom' is the level 0.
- *
- * has(T &val) const;
- * ------------------
- * This returns true/false is the skip list has the value val.
- * Starting at the highest possible level search rightwards until a larger value is encountered, then drop down.
- * At level 0 return true if the Node value is the supplied value.
- * This is @c O(log(N)) for well formed skip lists.
- *
- * at(size_t index) const;
- * -----------------------
- * This returns the value of type T at the given index.
- * The algorithm is similar to has(T &val) but the search moves rightwards if the width is less than the index and
- * decrementing the index by the width.
- *
- * If progress can not be made to the right, drop down a level.
- * If the index is 0 return the node value.
- * This is @c O(log(N)) for well formed skip lists.
- *
- * insert(T &val)
- * --------------
- * Finding the place to insert a node follows the has(T &val) algorithm to find the place in the skip list to create a
- * new node.
- * A duplicate value is inserted after any existing duplicate values.
- *
- * - All nodes are inserted at level 0 even if the insertion point can be seen at a higher level.
- * - The search for an insertion location creates a recursion stack that, when unwound, updates the traversed nodes
- *      <tt>{width, Node<T>*}</tt> data.
- * - Once an insert position is found a Node is created whose height is determined by repeatedly tossing a virtual coin
- *      until a 'tails' is thrown.
- * - This node initially has all node references to be to itself (this), and the widths set to 1 for level 0 and 0 for
- *      the remaining levels, they will be used to sum the widths at one level down.
- * - On recursion ('left') each node adds its width to the new node at the level above the current level.
- * - On moving up a level the current node swaps its width and node pointer with the new node at that new level.
- *
- * remove(T &val)
- * --------------
- *
- * If there are duplicate values the last one is removed first, this is for symmetry with insert().
- * Essentially this is the same as insert() but once the node is found the insert() updating algorithm is reversed and
- * the node deleted.
- *
- * Code Layout
- * ===========
- * There are three classes defined in their own .h files and these are all included into the SkipList.h file.
- *
- * The classes are:
- *
- * <tt>SwappableNodeRefStack</tt>
- *
- * This is simple bookkeeping class that has a vector of <tt>[{skip_width, Node<T>*}, ...]</tt>.
- * This vector can be expanded or contracted at will.
- * Both HeadNode and Node classes have one of these to manage their references.
- *
- * <tt>Node</tt>
- *
- * This represents a single value in the skip list.
- * The height of a Node is determined at construction by tossing a virtual coin, this determines how many coarser
- * lists this node participates in.
- * A Node has a SwappableNodeRefStack object and a value of type T.
- *
- * <tt>HeadNode</tt>
- *
- * There is one of these per skip list and this provides the API to the entire skip list.
- * The height of the HeadNode expands and contracts as required when Nodes are inserted or removed (it is the height
- * of the highest Node).
- * A HeadNode has a SwappableNodeRefStack object and an independently maintained count of the number of Node objects
- * in the skip list.
- *
- * A Node and HeadNode have specialised methods such as has(), at(), insert(), remove() that traverse the skip lis
- * recursively.
- *
- * Other Files of Significance
- * ---------------------------
- * SkipList.cpp exposes the random number generator (rand()) and seeder (srand()) so that they can be accessed
- * CPython for deterministic testing.
- *
- * cSkipList.h and cSkipList.cpp contains a CPython module with a SkipList implementation for a number of builtin
- * Python types.
- *
- * IntegrityEnums.h has definitions of error codes that can be created by the skip list integrity checking functions.
- *
- * Code Idioms
- * ===========
- *
- * Prevent Copying
- * ---------------
- * Copying operations are (mostly) prohibited for performance reasons.
- * The only class that allows copying is struct NodeRef that contains fundamental types.
- * All other classes declare their copying operation private and unimplemented (rather than using C++11 delete) for
- * compatibility with older compilers.
- *
- * Reverse Loop of Unsigned int
- * ----------------------------
- * In a lot of the code we have to count down from some value to 0
- * with a size_t (an unsigned integer type) The idiom used is this:
- *
- * @code
- *
- *  for (size_t l = height(); l-- > 0;) {
- *      // ...
- *  }
- *
- * @endcode
- *
- * The "l-- > 0" means test l against 0 then decrement it.
- * l will thus start at the value height() - 1 down to 0 then exit the loop.
- *
- * @note If l is declared before the loop it will have the maximum value of a size_t unless a break statement is
- * encountered.
- *
- * Roads not Travelled
- * ===================
- * Certain designs were not explored, here they are and why.
- *
- * Key/Value Implementation
- * ------------------------
- * Skip lists are commonly used for key/value dictionaries. Given things
- * like map<T> or unorderedmap<T> I see no reason why a SkipList should be used
- * as an alternative.
- *
- * Adversarial Users
- * -----------------
- * If the user knows the behaviour of the random number generator it is possible that they can change the order of
- * insertion to create a poor distribution of nodes which will make operations tend to O(N) rather than O(log(N)).
- *
- * Probability != 0.5
- * ------------------
- * This implementation uses a fair coin to decide the height of the node.
- *
- * Some literature suggests other values such as p = 0.25 might be more efficient.
- * Some experiments seem to show that this is the case with this implementation.
- * Here are some results when using a vector of 1 million doubles and a sliding window of 101 where each value is
- * inserted and removed and the cental value recovered:
- *
- * @code
- *
-    Probability calculation        p    Time compared to p = 0.5
-     rand() < RAND_MAX / 16;    0.0625   90%
-     rand() < RAND_MAX / 8;     0.125    83%
-     rand() < RAND_MAX / 4;     0.25     80%
-     rand() < RAND_MAX / 2;     0.5     100%
-     rand() > RAND_MAX / 4;     0.75    143%
-     rand() > RAND_MAX / 8;     0.875   201%
- *
- * @endcode
- *
- * Optimisation: Re-index Nodes on Complete Traversal
- * --------------------------------------------------
- *
- * @todo Re-index Nodes on Complete Traversal ???
- *
- * Optimisation: Reuse removed nodes for insert()
- * ----------------------------------------------
- * @todo Reuse removed nodes for insert() ???
- *
- * Reference Counting
- * ------------------
- * Some time (and particularly space) improvement could be obtained by reference counting nodes so that duplicate
- * values could be eliminated.
- * Since the primary use case for this skip list is for computing the rolling median of doubles the chances of
- * duplicates are slim.
- * For int, long and string there is a higher probability so reference counting might be implemented in the future if
- * these types become commonly used.
- *
- * Use and Array of <tt>{skip_width, Node<T>*}</tt> rather than a vector
- * ----------------------------------------------------------------------
- *
- * Less space would be used for each Node if the SwappableNodeRefStack used a dynamically allocated array of
- * <tt>[{skip_width, Node<T>*}, ...]</tt> rather than a vector.
- *
- * Performance
- * ===========
- *
- * Reference platform: Macbook Pro, 13" running OS X 10.9.5. LLVM version 6.0 targeting x86_64-apple-darwin13.4.0
- * Compiled with -Os (small fast).
- *
- * Performance of at() and has()
- * -----------------------------
- *
- * Performance is O(log(N)) where N is the position in the skip list.
- *
- * On the reference platform this tests as t = 200 log2(N) in nanoseconds for skip lists of doubles.
- * This factor of 200 can be between 70 and 500 for the same data but different indices because of the probabilistic
- * nature of a skip list.
- * For example finding the mid value of 1M doubles takes 3 to 4 microseconds.
- *
- * @note
- * On Linux RHEL5 with -O3 this is much faster with t = 12 log2(N)
- * [main.cpp perf_at_in_one_million(), main.cpp perf_has_in_one_million()]
- *
- * Performance of insert() and remove()
- * ------------------------------------
- * A test that inserts then removes a single value in an empty list takes 440 nanoseconds (around 2.3 million per
- * second).
- * This should be fast as the search space is small.
- *
- * @note
- * Linux RHEL5 with -O3 this is 4.2 million per second. [main.cpp perf_single_insert_remove()]
- *
- * A test that inserts 1M doubles into a skip list (no removal) takes 0.9 seconds (around 1.1 million per second).
- *
- * @note
- * Linux RHEL5 with -O3 this is similar. [main.cpp perf_large_skiplist_ins_only()]
- *
- * A test that inserts 1M doubles into a skip list then removes all of them takes 1.0 seconds (around 1 million per second).
- *
- * @note
- * Linux RHEL5 with -O3 this is similar. [main.cpp perf_large_skiplist_ins_rem()]
- *
- * A test that creates a skip list of 1M doubles then times how long it takes to insert and remove a value at the
- * mid-point takes 1.03 microseconds per item (around 1 million per second).
- *
- * @note
- * Linux RHEL5 with -O3 this is around 0.8 million per second. [main.cpp perf_single_ins_rem_middle()]
- *
- * A test that creates a skip list of 1M doubles then times how long it takes to insert a value, find the value at the
- * mid point then remove that value (using insert()/at()/remove()) takes 1.2 microseconds per item (around 0.84 million
- * per second).
- *
- * @note
- * Linux RHEL5 with -O3 this is around 0.7 million per second. [main.cpp perf_single_ins_at_rem_middle()]
- *
- * Performance of a rolling median
- * -------------------------------
- * On the reference platform a rolling median (using insert()/at()/remove()) on 1M random values takes about 0.93
- * seconds.
- *
- * @note
- * Linux RHEL5 with -O3 this is about 0.7 seconds.
- * [main.cpp perf_1m_median_values(), main.cpp perf_1m_medians_1000_vectors(), main.cpp perf_simulate_real_use()]
- *
- * The window size makes little difference, a rolling median on 1m items with a window size of 1 takes 0.491 seconds,
- * with a window size of 524288 it takes 1.03 seconds.
- *
- * @note
- * Linux RHEL5 with -O3 this is about 0.5 seconds. [main.cpp perf_roll_med_odd_index_wins()]
- *
- * Space Complexity
- * ----------------
- * Given:
- *
- * - t = sizeof(T) ~ typ. 8 bytes for a double
- * - v = sizeof(std::vector<struct NodeRef<T>>) ~ typ. 32 bytes
- * - p = sizeof(Node<T>*) ~ typ. 8 bytes
- * - e = sizeof(struct NodeRef<T>) ~ typ. 8 + p = 16 bytes
- *
- * Then each node: is t + v bytes.
- *
- * Linked list at level 0 is e bytes per node.
- *
- * Linked list at level 1 is, typically, e / 2 bytes per node and so on.
- *
- * So the totality of linked lists is about 2e bytes per node.
- *
- * The total is N * (t + v + 2 * e) which for T as a double is typically 72 bytes per item.
- *
- * In practice this has been measured on the reference platform as a bit larger at 86.0 Mb for 1024*1024 doubles.
- *
- ***************** END: SkipList Documentation *****************/
-
-/// Defined if you want the SkipList to have methods that can output
-/// to stream (for debugging for example).
-/// Defining this will mean that classes grow methods that use streams.
-/// Undef this if you want a smaller binary in production as using streams
-/// adds typically around 30kb to the binary.
-/// However you may loose useful information such as formatted
-/// exception messages with extra data.
-//#define INCLUDE_METHODS_THAT_USE_STREAMS
-#undef INCLUDE_METHODS_THAT_USE_STREAMS
-
-#include <functional>
-#include <vector>
-#include <set> // Used for HeadNode::_lacksIntegrityNodeReferencesNotInList()
-#include <string> // Used for class Exception
-#include "pcg_random.hpp"
-
-#ifdef DEBUG
-#include <cassert>
-#else
-#ifndef assert
-#define assert(x)
-#endif
-#endif // DEBUG
-
-#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
-
-#include <iostream>
-#include <sstream>
-
-#endif // INCLUDE_METHODS_THAT_USE_STREAMS
-
-//#define SKIPLIST_THREAD_SUPPORT
-//#define SKIPLIST_THREAD_SUPPORT_TRACE
-
-#ifdef SKIPLIST_THREAD_SUPPORT
-#ifdef SKIPLIST_THREAD_SUPPORT_TRACE
-#include <thread>
-#endif
-#include <mutex>
-#endif
-
-/**
- * @brief Namespace for all the C++ ordered structures.
- */
-namespace duckdb_skiplistlib {
-    /**
-     * @brief Namespace for the C++ Slip List.
-     */
-    namespace skip_list {
-
-/************************ Exceptions ****************************/
-
-/**
- * @brief Base exception class for all exceptions in the OrderedStructs::SkipList namespace.
- */
-        class Exception : public std::exception {
-        public:
-            explicit Exception(const std::string &in_msg) : msg(in_msg) {}
-
-            const std::string &message() const { return msg; }
-
-            virtual ~Exception() throw() {}
-
-        protected:
-            std::string msg;
-        };
-
-/**
- * @brief Specialised exception case for an index out of range error.
- */
-        class IndexError : public Exception {
-        public:
-            explicit IndexError(const std::string &in_msg) : Exception(in_msg) {}
-        };
-
-/**
- * @brief Specialised exception for an value error where the given value does not exist in the Skip List.
- */
-        class ValueError : public Exception {
-        public:
-            explicit ValueError(const std::string &in_msg) : Exception(in_msg) {}
-        };
-
-/** @brief Specialised exception used for NaN detection where value != value (example NaNs). */
-        class FailedComparison : public Exception {
-        public:
-            explicit FailedComparison(const std::string &in_msg) : Exception(in_msg) {}
-        };
-
-/**
- * This throws an IndexError when the index value >= the size of Skip List.
- * If @ref INCLUDE_METHODS_THAT_USE_STREAMS is defined then the error will have an informative message.
- *
- * @param index The out of range index.
- */
-        void _throw_exceeds_size(size_t index);
-
-/************************ END: Exceptions ****************************/
-
-#ifdef SKIPLIST_THREAD_SUPPORT
-        /**
-         * Mutex used in a multi-threaded environment.
-         */
-        extern std::mutex gSkipListMutex;
-#endif
-
-#include "NodeRefs.h"
-#include "Node.h"
-#include "HeadNode.h"
-
-    } // namespace skip_list
-} // namespace duckdb_skiplistlib
-
-#endif /* defined(__SkipList__SkipList__) */
diff --git a/src/duckdb/third_party/snappy/snappy-internal.h b/src/duckdb/third_party/snappy/snappy-internal.h
deleted file mode 100644
index 651e34099..000000000
--- a/src/duckdb/third_party/snappy/snappy-internal.h
+++ /dev/null
@@ -1,647 +0,0 @@
-// Copyright 2008 Google Inc. All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-//
-// Internals shared between the Snappy implementation and its unittest.
-
-#ifndef THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_
-#define THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#include <utility>
-
-#include "snappy-stubs-internal.h"
-
-#if SNAPPY_HAVE_SSSE3
-// Please do not replace with <x86intrin.h> or with headers that assume more
-// advanced SSE versions without checking with all the OWNERS.
-#include <emmintrin.h>
-#include <tmmintrin.h>
-#endif
-
-#if SNAPPY_HAVE_NEON
-#include <arm_neon.h>
-#endif
-
-#if SNAPPY_HAVE_SSSE3 || SNAPPY_HAVE_NEON
-#define SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE 1
-#else
-#define SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE 0
-#endif
-
-namespace duckdb_snappy {
-namespace internal {
-
-#if SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-#if SNAPPY_HAVE_SSSE3
-using V128 = __m128i;
-#elif SNAPPY_HAVE_NEON
-using V128 = uint8x16_t;
-#endif
-
-// Load 128 bits of integer data. `src` must be 16-byte aligned.
-inline V128 V128_Load(const V128* src);
-
-// Load 128 bits of integer data. `src` does not need to be aligned.
-inline V128 V128_LoadU(const V128* src);
-
-// Store 128 bits of integer data. `dst` does not need to be aligned.
-inline void V128_StoreU(V128* dst, V128 val);
-
-// Shuffle packed 8-bit integers using a shuffle mask.
-// Each packed integer in the shuffle mask must be in [0,16).
-inline V128 V128_Shuffle(V128 input, V128 shuffle_mask);
-
-// Constructs V128 with 16 chars |c|.
-inline V128 V128_DupChar(char c);
-
-#if SNAPPY_HAVE_SSSE3
-inline V128 V128_Load(const V128* src) { return _mm_load_si128(src); }
-
-inline V128 V128_LoadU(const V128* src) { return _mm_loadu_si128(src); }
-
-inline void V128_StoreU(V128* dst, V128 val) { _mm_storeu_si128(dst, val); }
-
-inline V128 V128_Shuffle(V128 input, V128 shuffle_mask) {
-  return _mm_shuffle_epi8(input, shuffle_mask);
-}
-
-inline V128 V128_DupChar(char c) { return _mm_set1_epi8(c); }
-
-#elif SNAPPY_HAVE_NEON
-inline V128 V128_Load(const V128* src) {
-  return vld1q_u8(reinterpret_cast<const uint8_t*>(src));
-}
-
-inline V128 V128_LoadU(const V128* src) {
-  return vld1q_u8(reinterpret_cast<const uint8_t*>(src));
-}
-
-inline void V128_StoreU(V128* dst, V128 val) {
-  vst1q_u8(reinterpret_cast<uint8_t*>(dst), val);
-}
-
-inline V128 V128_Shuffle(V128 input, V128 shuffle_mask) {
-  assert(vminvq_u8(shuffle_mask) >= 0 && vmaxvq_u8(shuffle_mask) <= 15);
-  return vqtbl1q_u8(input, shuffle_mask);
-}
-
-inline V128 V128_DupChar(char c) { return vdupq_n_u8(c); }
-#endif
-#endif  // SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-
-// Working memory performs a single allocation to hold all scratch space
-// required for compression.
-class WorkingMemory {
- public:
-  explicit WorkingMemory(size_t input_size);
-  ~WorkingMemory();
-
-  // Allocates and clears a hash table using memory in "*this",
-  // stores the number of buckets in "*table_size" and returns a pointer to
-  // the base of the hash table.
-  uint16_t* GetHashTable(size_t fragment_size, int* table_size) const;
-  char* GetScratchInput() const { return input_; }
-  char* GetScratchOutput() const { return output_; }
-
- private:
-  char* mem_;        // the allocated memory, never nullptr
-  size_t size_;      // the size of the allocated memory, never 0
-  uint16_t* table_;  // the pointer to the hashtable
-  char* input_;      // the pointer to the input scratch buffer
-  char* output_;     // the pointer to the output scratch buffer
-
-  // No copying
-  WorkingMemory(const WorkingMemory&);
-  void operator=(const WorkingMemory&);
-};
-
-// Flat array compression that does not emit the "uncompressed length"
-// prefix. Compresses "input" string to the "*op" buffer.
-//
-// REQUIRES: "input_length <= kBlockSize"
-// REQUIRES: "op" points to an array of memory that is at least
-// "MaxCompressedLength(input_length)" in size.
-// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-// REQUIRES: "table_size" is a power of two
-//
-// Returns an "end" pointer into "op" buffer.
-// "end - op" is the compressed size of "input".
-char* CompressFragment(const char* input,
-                       size_t input_length,
-                       char* op,
-                       uint16_t* table,
-                       const int table_size);
-
-// Find the largest n such that
-//
-//   s1[0,n-1] == s2[0,n-1]
-//   and n <= (s2_limit - s2).
-//
-// Return make_pair(n, n < 8).
-// Does not read *s2_limit or beyond.
-// Does not read *(s1 + (s2_limit - s2)) or beyond.
-// Requires that s2_limit >= s2.
-//
-// In addition populate *data with the next 5 bytes from the end of the match.
-// This is only done if 8 bytes are available (s2_limit - s2 >= 8). The point is
-// that on some arch's this can be done faster in this routine than subsequent
-// loading from s2 + n.
-//
-// Separate implementation for 64-bit, little-endian cpus.
-#if !SNAPPY_IS_BIG_ENDIAN && \
-    (defined(__x86_64__) || defined(_M_X64) || defined(ARCH_PPC) || \
-     defined(ARCH_ARM))
-static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
-                                                      const char* s2,
-                                                      const char* s2_limit,
-                                                      uint64_t* data) {
-  assert(s2_limit >= s2);
-  size_t matched = 0;
-
-  // This block isn't necessary for correctness; we could just start looping
-  // immediately.  As an optimization though, it is useful.  It creates some not
-  // uncommon code paths that determine, without extra effort, whether the match
-  // length is less than 8.  In short, we are hoping to avoid a conditional
-  // branch, and perhaps get better code layout from the C++ compiler.
-  if (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 16)) {
-    uint64_t a1 = UNALIGNED_LOAD64(s1);
-    uint64_t a2 = UNALIGNED_LOAD64(s2);
-    if (SNAPPY_PREDICT_TRUE(a1 != a2)) {
-      // This code is critical for performance. The reason is that it determines
-      // how much to advance `ip` (s2). This obviously depends on both the loads
-      // from the `candidate` (s1) and `ip`. Furthermore the next `candidate`
-      // depends on the advanced `ip` calculated here through a load, hash and
-      // new candidate hash lookup (a lot of cycles). This makes s1 (ie.
-      // `candidate`) the variable that limits throughput. This is the reason we
-      // go through hoops to have this function update `data` for the next iter.
-      // The straightforward code would use *data, given by
-      //
-      // *data = UNALIGNED_LOAD64(s2 + matched_bytes) (Latency of 5 cycles),
-      //
-      // as input for the hash table lookup to find next candidate. However
-      // this forces the load on the data dependency chain of s1, because
-      // matched_bytes directly depends on s1. However matched_bytes is 0..7, so
-      // we can also calculate *data by
-      //
-      // *data = AlignRight(UNALIGNED_LOAD64(s2), UNALIGNED_LOAD64(s2 + 8),
-      //                    matched_bytes);
-      //
-      // The loads do not depend on s1 anymore and are thus off the bottleneck.
-      // The straightforward implementation on x86_64 would be to use
-      //
-      // shrd rax, rdx, cl  (cl being matched_bytes * 8)
-      //
-      // unfortunately shrd with a variable shift has a 4 cycle latency. So this
-      // only wins 1 cycle. The BMI2 shrx instruction is a 1 cycle variable
-      // shift instruction but can only shift 64 bits. If we focus on just
-      // obtaining the least significant 4 bytes, we can obtain this by
-      //
-      // *data = ConditionalMove(matched_bytes < 4, UNALIGNED_LOAD64(s2),
-      //     UNALIGNED_LOAD64(s2 + 4) >> ((matched_bytes & 3) * 8);
-      //
-      // Writen like above this is not a big win, the conditional move would be
-      // a cmp followed by a cmov (2 cycles) followed by a shift (1 cycle).
-      // However matched_bytes < 4 is equal to
-      // static_cast<uint32_t>(xorval) != 0. Writen that way, the conditional
-      // move (2 cycles) can execute in parallel with FindLSBSetNonZero64
-      // (tzcnt), which takes 3 cycles.
-      uint64_t xorval = a1 ^ a2;
-      int shift = Bits::FindLSBSetNonZero64(xorval);
-      size_t matched_bytes = shift >> 3;
-      uint64_t a3 = UNALIGNED_LOAD64(s2 + 4);
-#ifndef __x86_64__
-      a2 = static_cast<uint32_t>(xorval) == 0 ? a3 : a2;
-#else
-      // Ideally this would just be
-      //
-      // a2 = static_cast<uint32_t>(xorval) == 0 ? a3 : a2;
-      //
-      // However clang correctly infers that the above statement participates on
-      // a critical data dependency chain and thus, unfortunately, refuses to
-      // use a conditional move (it's tuned to cut data dependencies). In this
-      // case there is a longer parallel chain anyway AND this will be fairly
-      // unpredictable.
-      asm("testl %k2, %k2\n\t"
-          "cmovzq %1, %0\n\t"
-          : "+r"(a2)
-          : "r"(a3), "r"(xorval)
-          : "cc");
-#endif
-      *data = a2 >> (shift & (3 * 8));
-      return std::pair<size_t, bool>(matched_bytes, true);
-    } else {
-      matched = 8;
-      s2 += 8;
-    }
-  }
-  SNAPPY_PREFETCH(s1 + 64);
-  SNAPPY_PREFETCH(s2 + 64);
-
-  // Find out how long the match is. We loop over the data 64 bits at a
-  // time until we find a 64-bit block that doesn't match; then we find
-  // the first non-matching bit and use that to calculate the total
-  // length of the match.
-  while (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 16)) {
-    uint64_t a1 = UNALIGNED_LOAD64(s1 + matched);
-    uint64_t a2 = UNALIGNED_LOAD64(s2);
-    if (a1 == a2) {
-      s2 += 8;
-      matched += 8;
-    } else {
-      uint64_t xorval = a1 ^ a2;
-      int shift = Bits::FindLSBSetNonZero64(xorval);
-      size_t matched_bytes = shift >> 3;
-      uint64_t a3 = UNALIGNED_LOAD64(s2 + 4);
-#ifndef __x86_64__
-      a2 = static_cast<uint32_t>(xorval) == 0 ? a3 : a2;
-#else
-      asm("testl %k2, %k2\n\t"
-          "cmovzq %1, %0\n\t"
-          : "+r"(a2)
-          : "r"(a3), "r"(xorval)
-          : "cc");
-#endif
-      *data = a2 >> (shift & (3 * 8));
-      matched += matched_bytes;
-      assert(matched >= 8);
-      return std::pair<size_t, bool>(matched, false);
-    }
-  }
-  while (SNAPPY_PREDICT_TRUE(s2 < s2_limit)) {
-    if (s1[matched] == *s2) {
-      ++s2;
-      ++matched;
-    } else {
-      if (s2 <= s2_limit - 8) {
-        *data = UNALIGNED_LOAD64(s2);
-      }
-      return std::pair<size_t, bool>(matched, matched < 8);
-    }
-  }
-  return std::pair<size_t, bool>(matched, matched < 8);
-}
-#else
-static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
-                                                      const char* s2,
-                                                      const char* s2_limit,
-                                                      uint64_t* data) {
-  // Implementation based on the x86-64 version, above.
-  assert(s2_limit >= s2);
-  int matched = 0;
-
-  while (s2 <= s2_limit - 4 &&
-         UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) {
-    s2 += 4;
-    matched += 4;
-  }
-  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) {
-    uint32_t x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched);
-    int matching_bits = Bits::FindLSBSetNonZero(x);
-    matched += matching_bits >> 3;
-    s2 += matching_bits >> 3;
-  } else {
-    while ((s2 < s2_limit) && (s1[matched] == *s2)) {
-      ++s2;
-      ++matched;
-    }
-  }
-  if (s2 <= s2_limit - 8) *data = LittleEndian::Load64(s2);
-  return std::pair<size_t, bool>(matched, matched < 8);
-}
-#endif
-
-static inline size_t FindMatchLengthPlain(const char* s1, const char* s2,
-                                          const char* s2_limit) {
-  // Implementation based on the x86-64 version, above.
-  assert(s2_limit >= s2);
-  int matched = 0;
-
-  while (s2 <= s2_limit - 8 &&
-         UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched)) {
-    s2 += 8;
-    matched += 8;
-  }
-  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 8) {
-    uint64_t x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched);
-    int matching_bits = Bits::FindLSBSetNonZero64(x);
-    matched += matching_bits >> 3;
-    s2 += matching_bits >> 3;
-  } else {
-    while ((s2 < s2_limit) && (s1[matched] == *s2)) {
-      ++s2;
-      ++matched;
-    }
-  }
-  return matched;
-}
-
-// Lookup tables for decompression code.  Give --snappy_dump_decompression_table
-// to the unit test to recompute char_table.
-
-enum {
-  LITERAL = 0,
-  COPY_1_BYTE_OFFSET = 1,  // 3 bit length + 3 bits of offset in opcode
-  COPY_2_BYTE_OFFSET = 2,
-  COPY_4_BYTE_OFFSET = 3
-};
-static const int kMaximumTagLength = 5;  // COPY_4_BYTE_OFFSET plus the actual offset.
-
-// Data stored per entry in lookup table:
-//      Range   Bits-used       Description
-//      ------------------------------------
-//      1..64   0..7            Literal/copy length encoded in opcode byte
-//      0..7    8..10           Copy offset encoded in opcode byte / 256
-//      0..4    11..13          Extra bytes after opcode
-//
-// We use eight bits for the length even though 7 would have sufficed
-// because of efficiency reasons:
-//      (1) Extracting a byte is faster than a bit-field
-//      (2) It properly aligns copy offset so we do not need a <<8
-static constexpr uint16_t char_table[256] = {
-    // clang-format off
-  0x0001, 0x0804, 0x1001, 0x2001, 0x0002, 0x0805, 0x1002, 0x2002,
-  0x0003, 0x0806, 0x1003, 0x2003, 0x0004, 0x0807, 0x1004, 0x2004,
-  0x0005, 0x0808, 0x1005, 0x2005, 0x0006, 0x0809, 0x1006, 0x2006,
-  0x0007, 0x080a, 0x1007, 0x2007, 0x0008, 0x080b, 0x1008, 0x2008,
-  0x0009, 0x0904, 0x1009, 0x2009, 0x000a, 0x0905, 0x100a, 0x200a,
-  0x000b, 0x0906, 0x100b, 0x200b, 0x000c, 0x0907, 0x100c, 0x200c,
-  0x000d, 0x0908, 0x100d, 0x200d, 0x000e, 0x0909, 0x100e, 0x200e,
-  0x000f, 0x090a, 0x100f, 0x200f, 0x0010, 0x090b, 0x1010, 0x2010,
-  0x0011, 0x0a04, 0x1011, 0x2011, 0x0012, 0x0a05, 0x1012, 0x2012,
-  0x0013, 0x0a06, 0x1013, 0x2013, 0x0014, 0x0a07, 0x1014, 0x2014,
-  0x0015, 0x0a08, 0x1015, 0x2015, 0x0016, 0x0a09, 0x1016, 0x2016,
-  0x0017, 0x0a0a, 0x1017, 0x2017, 0x0018, 0x0a0b, 0x1018, 0x2018,
-  0x0019, 0x0b04, 0x1019, 0x2019, 0x001a, 0x0b05, 0x101a, 0x201a,
-  0x001b, 0x0b06, 0x101b, 0x201b, 0x001c, 0x0b07, 0x101c, 0x201c,
-  0x001d, 0x0b08, 0x101d, 0x201d, 0x001e, 0x0b09, 0x101e, 0x201e,
-  0x001f, 0x0b0a, 0x101f, 0x201f, 0x0020, 0x0b0b, 0x1020, 0x2020,
-  0x0021, 0x0c04, 0x1021, 0x2021, 0x0022, 0x0c05, 0x1022, 0x2022,
-  0x0023, 0x0c06, 0x1023, 0x2023, 0x0024, 0x0c07, 0x1024, 0x2024,
-  0x0025, 0x0c08, 0x1025, 0x2025, 0x0026, 0x0c09, 0x1026, 0x2026,
-  0x0027, 0x0c0a, 0x1027, 0x2027, 0x0028, 0x0c0b, 0x1028, 0x2028,
-  0x0029, 0x0d04, 0x1029, 0x2029, 0x002a, 0x0d05, 0x102a, 0x202a,
-  0x002b, 0x0d06, 0x102b, 0x202b, 0x002c, 0x0d07, 0x102c, 0x202c,
-  0x002d, 0x0d08, 0x102d, 0x202d, 0x002e, 0x0d09, 0x102e, 0x202e,
-  0x002f, 0x0d0a, 0x102f, 0x202f, 0x0030, 0x0d0b, 0x1030, 0x2030,
-  0x0031, 0x0e04, 0x1031, 0x2031, 0x0032, 0x0e05, 0x1032, 0x2032,
-  0x0033, 0x0e06, 0x1033, 0x2033, 0x0034, 0x0e07, 0x1034, 0x2034,
-  0x0035, 0x0e08, 0x1035, 0x2035, 0x0036, 0x0e09, 0x1036, 0x2036,
-  0x0037, 0x0e0a, 0x1037, 0x2037, 0x0038, 0x0e0b, 0x1038, 0x2038,
-  0x0039, 0x0f04, 0x1039, 0x2039, 0x003a, 0x0f05, 0x103a, 0x203a,
-  0x003b, 0x0f06, 0x103b, 0x203b, 0x003c, 0x0f07, 0x103c, 0x203c,
-  0x0801, 0x0f08, 0x103d, 0x203d, 0x1001, 0x0f09, 0x103e, 0x203e,
-  0x1801, 0x0f0a, 0x103f, 0x203f, 0x2001, 0x0f0b, 0x1040, 0x2040,
-    // clang-format on
-};
-
-}  // end namespace internal
-}  // end namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#include "snappy-stubs-internal.h"
-
-namespace duckdb_snappy {
-namespace internal {
-
-// Working memory performs a single allocation to hold all scratch space
-// required for compression.
-class WorkingMemory {
- public:
-  explicit WorkingMemory(size_t input_size);
-  ~WorkingMemory();
-
-  // Allocates and clears a hash table using memory in "*this",
-  // stores the number of buckets in "*table_size" and returns a pointer to
-  // the base of the hash table.
-  uint16* GetHashTable(size_t fragment_size, int* table_size) const;
-  char* GetScratchInput() const { return input_; }
-  char* GetScratchOutput() const { return output_; }
-
- private:
-  char* mem_;      // the allocated memory, never nullptr
-  size_t size_;    // the size of the allocated memory, never 0
-  uint16* table_;  // the pointer to the hashtable
-  char* input_;    // the pointer to the input scratch buffer
-  char* output_;   // the pointer to the output scratch buffer
-
-  // No copying
-  WorkingMemory(const WorkingMemory&);
-  void operator=(const WorkingMemory&);
-};
-
-// Flat array compression that does not emit the "uncompressed length"
-// prefix. Compresses "input" string to the "*op" buffer.
-//
-// REQUIRES: "input_length <= kBlockSize"
-// REQUIRES: "op" points to an array of memory that is at least
-// "MaxCompressedLength(input_length)" in size.
-// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-// REQUIRES: "table_size" is a power of two
-//
-// Returns an "end" pointer into "op" buffer.
-// "end - op" is the compressed size of "input".
-char* CompressFragment(const char* input,
-                       size_t input_length,
-                       char* op,
-                       uint16* table,
-                       const int table_size);
-
-// Find the largest n such that
-//
-//   s1[0,n-1] == s2[0,n-1]
-//   and n <= (s2_limit - s2).
-//
-// Return make_pair(n, n < 8).
-// Does not read *s2_limit or beyond.
-// Does not read *(s1 + (s2_limit - s2)) or beyond.
-// Requires that s2_limit >= s2.
-//
-// Separate implementation for 64-bit, little-endian cpus.
-#if !defined(SNAPPY_IS_BIG_ENDIAN) && \
-    (defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM))
-static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
-                                                      const char* s2,
-                                                      const char* s2_limit) {
-  assert(s2_limit >= s2);
-  size_t matched = 0;
-
-  // This block isn't necessary for correctness; we could just start looping
-  // immediately.  As an optimization though, it is useful.  It creates some not
-  // uncommon code paths that determine, without extra effort, whether the match
-  // length is less than 8.  In short, we are hoping to avoid a conditional
-  // branch, and perhaps get better code layout from the C++ compiler.
-  if (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 8)) {
-    uint64 a1 = UNALIGNED_LOAD64(s1);
-    uint64 a2 = UNALIGNED_LOAD64(s2);
-    if (a1 != a2) {
-      return std::pair<size_t, bool>(Bits::FindLSBSetNonZero64(a1 ^ a2) >> 3,
-                                     true);
-    } else {
-      matched = 8;
-      s2 += 8;
-    }
-  }
-
-  // Find out how long the match is. We loop over the data 64 bits at a
-  // time until we find a 64-bit block that doesn't match; then we find
-  // the first non-matching bit and use that to calculate the total
-  // length of the match.
-  while (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 8)) {
-    if (UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched)) {
-      s2 += 8;
-      matched += 8;
-    } else {
-      uint64 x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched);
-      int matching_bits = Bits::FindLSBSetNonZero64(x);
-      matched += matching_bits >> 3;
-      assert(matched >= 8);
-      return std::pair<size_t, bool>(matched, false);
-    }
-  }
-  while (SNAPPY_PREDICT_TRUE(s2 < s2_limit)) {
-    if (s1[matched] == *s2) {
-      ++s2;
-      ++matched;
-    } else {
-      return std::pair<size_t, bool>(matched, matched < 8);
-    }
-  }
-  return std::pair<size_t, bool>(matched, matched < 8);
-}
-#else
-static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
-                                                      const char* s2,
-                                                      const char* s2_limit) {
-  // Implementation based on the x86-64 version, above.
-  assert(s2_limit >= s2);
-  int matched = 0;
-
-  while (s2 <= s2_limit - 4 &&
-         UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) {
-    s2 += 4;
-    matched += 4;
-  }
-  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) {
-    uint32 x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched);
-    int matching_bits = Bits::FindLSBSetNonZero(x);
-    matched += matching_bits >> 3;
-  } else {
-    while ((s2 < s2_limit) && (s1[matched] == *s2)) {
-      ++s2;
-      ++matched;
-    }
-  }
-  return std::pair<size_t, bool>(matched, matched < 8);
-}
-#endif
-
-// Lookup tables for decompression code.  Give --snappy_dump_decompression_table
-// to the unit test to recompute char_table.
-
-enum {
-  LITERAL = 0,
-  COPY_1_BYTE_OFFSET = 1,  // 3 bit length + 3 bits of offset in opcode
-  COPY_2_BYTE_OFFSET = 2,
-  COPY_4_BYTE_OFFSET = 3
-};
-static const int kMaximumTagLength = 5;  // COPY_4_BYTE_OFFSET plus the actual offset.
-
-// Data stored per entry in lookup table:
-//      Range   Bits-used       Description
-//      ------------------------------------
-//      1..64   0..7            Literal/copy length encoded in opcode byte
-//      0..7    8..10           Copy offset encoded in opcode byte / 256
-//      0..4    11..13          Extra bytes after opcode
-//
-// We use eight bits for the length even though 7 would have sufficed
-// because of efficiency reasons:
-//      (1) Extracting a byte is faster than a bit-field
-//      (2) It properly aligns copy offset so we do not need a <<8
-static const uint16 char_table[256] = {
-  0x0001, 0x0804, 0x1001, 0x2001, 0x0002, 0x0805, 0x1002, 0x2002,
-  0x0003, 0x0806, 0x1003, 0x2003, 0x0004, 0x0807, 0x1004, 0x2004,
-  0x0005, 0x0808, 0x1005, 0x2005, 0x0006, 0x0809, 0x1006, 0x2006,
-  0x0007, 0x080a, 0x1007, 0x2007, 0x0008, 0x080b, 0x1008, 0x2008,
-  0x0009, 0x0904, 0x1009, 0x2009, 0x000a, 0x0905, 0x100a, 0x200a,
-  0x000b, 0x0906, 0x100b, 0x200b, 0x000c, 0x0907, 0x100c, 0x200c,
-  0x000d, 0x0908, 0x100d, 0x200d, 0x000e, 0x0909, 0x100e, 0x200e,
-  0x000f, 0x090a, 0x100f, 0x200f, 0x0010, 0x090b, 0x1010, 0x2010,
-  0x0011, 0x0a04, 0x1011, 0x2011, 0x0012, 0x0a05, 0x1012, 0x2012,
-  0x0013, 0x0a06, 0x1013, 0x2013, 0x0014, 0x0a07, 0x1014, 0x2014,
-  0x0015, 0x0a08, 0x1015, 0x2015, 0x0016, 0x0a09, 0x1016, 0x2016,
-  0x0017, 0x0a0a, 0x1017, 0x2017, 0x0018, 0x0a0b, 0x1018, 0x2018,
-  0x0019, 0x0b04, 0x1019, 0x2019, 0x001a, 0x0b05, 0x101a, 0x201a,
-  0x001b, 0x0b06, 0x101b, 0x201b, 0x001c, 0x0b07, 0x101c, 0x201c,
-  0x001d, 0x0b08, 0x101d, 0x201d, 0x001e, 0x0b09, 0x101e, 0x201e,
-  0x001f, 0x0b0a, 0x101f, 0x201f, 0x0020, 0x0b0b, 0x1020, 0x2020,
-  0x0021, 0x0c04, 0x1021, 0x2021, 0x0022, 0x0c05, 0x1022, 0x2022,
-  0x0023, 0x0c06, 0x1023, 0x2023, 0x0024, 0x0c07, 0x1024, 0x2024,
-  0x0025, 0x0c08, 0x1025, 0x2025, 0x0026, 0x0c09, 0x1026, 0x2026,
-  0x0027, 0x0c0a, 0x1027, 0x2027, 0x0028, 0x0c0b, 0x1028, 0x2028,
-  0x0029, 0x0d04, 0x1029, 0x2029, 0x002a, 0x0d05, 0x102a, 0x202a,
-  0x002b, 0x0d06, 0x102b, 0x202b, 0x002c, 0x0d07, 0x102c, 0x202c,
-  0x002d, 0x0d08, 0x102d, 0x202d, 0x002e, 0x0d09, 0x102e, 0x202e,
-  0x002f, 0x0d0a, 0x102f, 0x202f, 0x0030, 0x0d0b, 0x1030, 0x2030,
-  0x0031, 0x0e04, 0x1031, 0x2031, 0x0032, 0x0e05, 0x1032, 0x2032,
-  0x0033, 0x0e06, 0x1033, 0x2033, 0x0034, 0x0e07, 0x1034, 0x2034,
-  0x0035, 0x0e08, 0x1035, 0x2035, 0x0036, 0x0e09, 0x1036, 0x2036,
-  0x0037, 0x0e0a, 0x1037, 0x2037, 0x0038, 0x0e0b, 0x1038, 0x2038,
-  0x0039, 0x0f04, 0x1039, 0x2039, 0x003a, 0x0f05, 0x103a, 0x203a,
-  0x003b, 0x0f06, 0x103b, 0x203b, 0x003c, 0x0f07, 0x103c, 0x203c,
-  0x0801, 0x0f08, 0x103d, 0x203d, 0x1001, 0x0f09, 0x103e, 0x203e,
-  0x1801, 0x0f0a, 0x103f, 0x203f, 0x2001, 0x0f0b, 0x1040, 0x2040
-};
-
-}  // end namespace internal
-
-
-// The size of a compression block. Note that many parts of the compression
-// code assumes that kBlockSize <= 65536; in particular, the hash table
-// can only store 16-bit offsets, and EmitCopy() also assumes the offset
-// is 65535 bytes or less. Note also that if you change this, it will
-// affect the framing format (see framing_format.txt).
-//
-// Note that there might be older data around that is compressed with larger
-// block sizes, so the decompression code should not rely on the
-// non-existence of long backreferences.
-static const int kBlockLog = 16;
-static const size_t kBlockSize = 1 << kBlockLog;
-
-static const int kMaxHashTableBits = 14;
-static const size_t kMaxHashTableSize = 1 << kMaxHashTableBits;
-
-
-}  // end namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
-
-#endif  // THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_
diff --git a/src/duckdb/third_party/snappy/snappy-sinksource.cc b/src/duckdb/third_party/snappy/snappy-sinksource.cc
deleted file mode 100644
index 9dc605ca0..000000000
--- a/src/duckdb/third_party/snappy/snappy-sinksource.cc
+++ /dev/null
@@ -1,206 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#include <stddef.h>
-#include <cstring>
-
-#include "snappy-sinksource.h"
-
-namespace duckdb_snappy {
-
-Source::~Source() = default;
-
-Sink::~Sink() = default;
-
-char* Sink::GetAppendBuffer(size_t length, char* scratch) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)length;
-
-  return scratch;
-}
-
-char* Sink::GetAppendBufferVariable(
-      size_t min_size, size_t desired_size_hint, char* scratch,
-      size_t scratch_size, size_t* allocated_size) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)min_size;
-  (void)desired_size_hint;
-
-  *allocated_size = scratch_size;
-  return scratch;
-}
-
-void Sink::AppendAndTakeOwnership(
-    char* bytes, size_t n,
-    void (*deleter)(void*, const char*, size_t),
-    void *deleter_arg) {
-  Append(bytes, n);
-  (*deleter)(deleter_arg, bytes, n);
-}
-
-ByteArraySource::~ByteArraySource() = default;
-
-size_t ByteArraySource::Available() const { return left_; }
-
-const char* ByteArraySource::Peek(size_t* len) {
-  *len = left_;
-  return ptr_;
-}
-
-void ByteArraySource::Skip(size_t n) {
-  left_ -= n;
-  ptr_ += n;
-}
-
-UncheckedByteArraySink::~UncheckedByteArraySink() { }
-
-void UncheckedByteArraySink::Append(const char* data, size_t n) {
-  // Do no copying if the caller filled in the result of GetAppendBuffer()
-  if (data != dest_) {
-    std::memcpy(dest_, data, n);
-  }
-  dest_ += n;
-}
-
-char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)len;
-  (void)scratch;
-
-  return dest_;
-}
-
-void UncheckedByteArraySink::AppendAndTakeOwnership(
-    char* bytes, size_t n,
-    void (*deleter)(void*, const char*, size_t),
-    void *deleter_arg) {
-  if (bytes != dest_) {
-    std::memcpy(dest_, bytes, n);
-    (*deleter)(deleter_arg, bytes, n);
-  }
-  dest_ += n;
-}
-
-char* UncheckedByteArraySink::GetAppendBufferVariable(
-      size_t min_size, size_t desired_size_hint, char* scratch,
-      size_t scratch_size, size_t* allocated_size) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)min_size;
-  (void)scratch;
-  (void)scratch_size;
-
-  *allocated_size = desired_size_hint;
-  return dest_;
-}
-
-}  // namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#include <string.h>
-
-#include "snappy-sinksource.h"
-
-namespace duckdb_snappy {
-
-Source::~Source() { }
-
-Sink::~Sink() { }
-
-char* Sink::GetAppendBuffer(size_t length, char* scratch) {
-	return scratch;
-}
-
-char* Sink::GetAppendBufferVariable(
-	  size_t min_size, size_t desired_size_hint, char* scratch,
-	  size_t scratch_size, size_t* allocated_size) {
-	*allocated_size = scratch_size;
-	return scratch;
-}
-
-void Sink::AppendAndTakeOwnership(
-	char* bytes, size_t n,
-	void (*deleter)(void*, const char*, size_t),
-	void *deleter_arg) {
-	Append(bytes, n);
-	(*deleter)(deleter_arg, bytes, n);
-}
-
-ByteArraySource::~ByteArraySource() { }
-
-size_t ByteArraySource::Available() const { return left_; }
-
-const char* ByteArraySource::Peek(size_t* len) {
-	*len = left_;
-	return ptr_;
-}
-
-void ByteArraySource::Skip(size_t n) {
-	left_ -= n;
-	ptr_ += n;
-}
-
-UncheckedByteArraySink::~UncheckedByteArraySink() { }
-
-void UncheckedByteArraySink::Append(const char* data, size_t n) {
-	// Do no copying if the caller filled in the result of GetAppendBuffer()
-	if (data != dest_) {
-		memcpy(dest_, data, n);
-	}
-	dest_ += n;
-}
-
-char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {
-	return dest_;
-}
-
-void UncheckedByteArraySink::AppendAndTakeOwnership(
-	char* data, size_t n,
-	void (*deleter)(void*, const char*, size_t),
-	void *deleter_arg) {
-	if (data != dest_) {
-		memcpy(dest_, data, n);
-		(*deleter)(deleter_arg, data, n);
-	}
-	dest_ += n;
-}
-
-char* UncheckedByteArraySink::GetAppendBufferVariable(
-	  size_t min_size, size_t desired_size_hint, char* scratch,
-	  size_t scratch_size, size_t* allocated_size) {
-	*allocated_size = desired_size_hint;
-	return dest_;
-}
-
-}  // namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
diff --git a/src/duckdb/third_party/snappy/snappy-sinksource.h b/src/duckdb/third_party/snappy/snappy-sinksource.h
deleted file mode 100644
index 2dddb9d45..000000000
--- a/src/duckdb/third_party/snappy/snappy-sinksource.h
+++ /dev/null
@@ -1,340 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-
-#ifndef THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_
-#define THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#include <stddef.h>
-
-namespace duckdb_snappy {
-
-// A Sink is an interface that consumes a sequence of bytes.
-class Sink {
- public:
-  Sink() { }
-  virtual ~Sink();
-
-  // Append "bytes[0,n-1]" to this.
-  virtual void Append(const char* bytes, size_t n) = 0;
-
-  // Returns a writable buffer of the specified length for appending.
-  // May return a pointer to the caller-owned scratch buffer which
-  // must have at least the indicated length.  The returned buffer is
-  // only valid until the next operation on this Sink.
-  //
-  // After writing at most "length" bytes, call Append() with the
-  // pointer returned from this function and the number of bytes
-  // written.  Many Append() implementations will avoid copying
-  // bytes if this function returned an internal buffer.
-  //
-  // If a non-scratch buffer is returned, the caller may only pass a
-  // prefix of it to Append().  That is, it is not correct to pass an
-  // interior pointer of the returned array to Append().
-  //
-  // The default implementation always returns the scratch buffer.
-  virtual char* GetAppendBuffer(size_t length, char* scratch);
-
-  // For higher performance, Sink implementations can provide custom
-  // AppendAndTakeOwnership() and GetAppendBufferVariable() methods.
-  // These methods can reduce the number of copies done during
-  // compression/decompression.
-
-  // Append "bytes[0,n-1] to the sink. Takes ownership of "bytes"
-  // and calls the deleter function as (*deleter)(deleter_arg, bytes, n)
-  // to free the buffer. deleter function must be non NULL.
-  //
-  // The default implementation just calls Append and frees "bytes".
-  // Other implementations may avoid a copy while appending the buffer.
-  virtual void AppendAndTakeOwnership(
-      char* bytes, size_t n, void (*deleter)(void*, const char*, size_t),
-      void *deleter_arg);
-
-  // Returns a writable buffer for appending and writes the buffer's capacity to
-  // *allocated_size. Guarantees *allocated_size >= min_size.
-  // May return a pointer to the caller-owned scratch buffer which must have
-  // scratch_size >= min_size.
-  //
-  // The returned buffer is only valid until the next operation
-  // on this ByteSink.
-  //
-  // After writing at most *allocated_size bytes, call Append() with the
-  // pointer returned from this function and the number of bytes written.
-  // Many Append() implementations will avoid copying bytes if this function
-  // returned an internal buffer.
-  //
-  // If the sink implementation allocates or reallocates an internal buffer,
-  // it should use the desired_size_hint if appropriate. If a caller cannot
-  // provide a reasonable guess at the desired capacity, it should set
-  // desired_size_hint = 0.
-  //
-  // If a non-scratch buffer is returned, the caller may only pass
-  // a prefix to it to Append(). That is, it is not correct to pass an
-  // interior pointer to Append().
-  //
-  // The default implementation always returns the scratch buffer.
-  virtual char* GetAppendBufferVariable(
-      size_t min_size, size_t desired_size_hint, char* scratch,
-      size_t scratch_size, size_t* allocated_size);
-
- private:
-  // No copying
-  Sink(const Sink&);
-  void operator=(const Sink&);
-};
-
-// A Source is an interface that yields a sequence of bytes
-class Source {
- public:
-  Source() { }
-  virtual ~Source();
-
-  // Return the number of bytes left to read from the source
-  virtual size_t Available() const = 0;
-
-  // Peek at the next flat region of the source.  Does not reposition
-  // the source.  The returned region is empty iff Available()==0.
-  //
-  // Returns a pointer to the beginning of the region and store its
-  // length in *len.
-  //
-  // The returned region is valid until the next call to Skip() or
-  // until this object is destroyed, whichever occurs first.
-  //
-  // The returned region may be larger than Available() (for example
-  // if this ByteSource is a view on a substring of a larger source).
-  // The caller is responsible for ensuring that it only reads the
-  // Available() bytes.
-  virtual const char* Peek(size_t* len) = 0;
-
-  // Skip the next n bytes.  Invalidates any buffer returned by
-  // a previous call to Peek().
-  // REQUIRES: Available() >= n
-  virtual void Skip(size_t n) = 0;
-
- private:
-  // No copying
-  Source(const Source&);
-  void operator=(const Source&);
-};
-
-// A Source implementation that yields the contents of a flat array
-class ByteArraySource : public Source {
- public:
-  ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { }
-  ~ByteArraySource() override;
-  size_t Available() const override;
-  const char* Peek(size_t* len) override;
-  void Skip(size_t n) override;
- private:
-  const char* ptr_;
-  size_t left_;
-};
-
-// A Sink implementation that writes to a flat array without any bound checks.
-class UncheckedByteArraySink : public Sink {
- public:
-  explicit UncheckedByteArraySink(char* dest) : dest_(dest) { }
-  ~UncheckedByteArraySink() override;
-  void Append(const char* data, size_t n) override;
-  char* GetAppendBuffer(size_t len, char* scratch) override;
-  char* GetAppendBufferVariable(
-      size_t min_size, size_t desired_size_hint, char* scratch,
-      size_t scratch_size, size_t* allocated_size) override;
-  void AppendAndTakeOwnership(
-      char* bytes, size_t n, void (*deleter)(void*, const char*, size_t),
-      void *deleter_arg) override;
-
-  // Return the current output pointer so that a caller can see how
-  // many bytes were produced.
-  // Note: this is not a Sink method.
-  char* CurrentDestination() const { return dest_; }
- private:
-  char* dest_;
-};
-
-}  // namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#include <stddef.h>
-
-namespace duckdb_snappy {
-
-// A Sink is an interface that consumes a sequence of bytes.
-class Sink {
- public:
-  Sink() { }
-  virtual ~Sink();
-
-  // Append "bytes[0,n-1]" to this.
-  virtual void Append(const char* bytes, size_t n) = 0;
-
-  // Returns a writable buffer of the specified length for appending.
-  // May return a pointer to the caller-owned scratch buffer which
-  // must have at least the indicated length.  The returned buffer is
-  // only valid until the next operation on this Sink.
-  //
-  // After writing at most "length" bytes, call Append() with the
-  // pointer returned from this function and the number of bytes
-  // written.  Many Append() implementations will avoid copying
-  // bytes if this function returned an internal buffer.
-  //
-  // If a non-scratch buffer is returned, the caller may only pass a
-  // prefix of it to Append().  That is, it is not correct to pass an
-  // interior pointer of the returned array to Append().
-  //
-  // The default implementation always returns the scratch buffer.
-  virtual char* GetAppendBuffer(size_t length, char* scratch);
-
-  // For higher performance, Sink implementations can provide custom
-  // AppendAndTakeOwnership() and GetAppendBufferVariable() methods.
-  // These methods can reduce the number of copies done during
-  // compression/decompression.
-
-  // Append "bytes[0,n-1] to the sink. Takes ownership of "bytes"
-  // and calls the deleter function as (*deleter)(deleter_arg, bytes, n)
-  // to free the buffer. deleter function must be non NULL.
-  //
-  // The default implementation just calls Append and frees "bytes".
-  // Other implementations may avoid a copy while appending the buffer.
-  virtual void AppendAndTakeOwnership(
-      char* bytes, size_t n, void (*deleter)(void*, const char*, size_t),
-      void *deleter_arg);
-
-  // Returns a writable buffer for appending and writes the buffer's capacity to
-  // *allocated_size. Guarantees *allocated_size >= min_size.
-  // May return a pointer to the caller-owned scratch buffer which must have
-  // scratch_size >= min_size.
-  //
-  // The returned buffer is only valid until the next operation
-  // on this ByteSink.
-  //
-  // After writing at most *allocated_size bytes, call Append() with the
-  // pointer returned from this function and the number of bytes written.
-  // Many Append() implementations will avoid copying bytes if this function
-  // returned an internal buffer.
-  //
-  // If the sink implementation allocates or reallocates an internal buffer,
-  // it should use the desired_size_hint if appropriate. If a caller cannot
-  // provide a reasonable guess at the desired capacity, it should set
-  // desired_size_hint = 0.
-  //
-  // If a non-scratch buffer is returned, the caller may only pass
-  // a prefix to it to Append(). That is, it is not correct to pass an
-  // interior pointer to Append().
-  //
-  // The default implementation always returns the scratch buffer.
-  virtual char* GetAppendBufferVariable(
-      size_t min_size, size_t desired_size_hint, char* scratch,
-      size_t scratch_size, size_t* allocated_size);
-
- private:
-  // No copying
-  Sink(const Sink&);
-  void operator=(const Sink&);
-};
-
-// A Source is an interface that yields a sequence of bytes
-class Source {
- public:
-  Source() { }
-  virtual ~Source();
-
-  // Return the number of bytes left to read from the source
-  virtual size_t Available() const = 0;
-
-  // Peek at the next flat region of the source.  Does not reposition
-  // the source.  The returned region is empty iff Available()==0.
-  //
-  // Returns a pointer to the beginning of the region and store its
-  // length in *len.
-  //
-  // The returned region is valid until the next call to Skip() or
-  // until this object is destroyed, whichever occurs first.
-  //
-  // The returned region may be larger than Available() (for example
-  // if this ByteSource is a view on a substring of a larger source).
-  // The caller is responsible for ensuring that it only reads the
-  // Available() bytes.
-  virtual const char* Peek(size_t* len) = 0;
-
-  // Skip the next n bytes.  Invalidates any buffer returned by
-  // a previous call to Peek().
-  // REQUIRES: Available() >= n
-  virtual void Skip(size_t n) = 0;
-
- private:
-  // No copying
-  Source(const Source&);
-  void operator=(const Source&);
-};
-
-// A Source implementation that yields the contents of a flat array
-class ByteArraySource : public Source {
- public:
-  ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { }
-  virtual ~ByteArraySource();
-  virtual size_t Available() const;
-  virtual const char* Peek(size_t* len);
-  virtual void Skip(size_t n);
- private:
-  const char* ptr_;
-  size_t left_;
-};
-
-// A Sink implementation that writes to a flat array without any bound checks.
-class UncheckedByteArraySink : public Sink {
- public:
-  explicit UncheckedByteArraySink(char* dest) : dest_(dest) { }
-  virtual ~UncheckedByteArraySink();
-  virtual void Append(const char* data, size_t n);
-  virtual char* GetAppendBuffer(size_t len, char* scratch);
-  virtual char* GetAppendBufferVariable(
-      size_t min_size, size_t desired_size_hint, char* scratch,
-      size_t scratch_size, size_t* allocated_size);
-  virtual void AppendAndTakeOwnership(
-      char* bytes, size_t n, void (*deleter)(void*, const char*, size_t),
-      void *deleter_arg);
-
-  // Return the current output pointer so that a caller can see how
-  // many bytes were produced.
-  // Note: this is not a Sink method.
-  char* CurrentDestination() const { return dest_; }
- private:
-  char* dest_;
-};
-
-}  // namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
-
-#endif  // THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_
diff --git a/src/duckdb/third_party/snappy/snappy-stubs-internal.h b/src/duckdb/third_party/snappy/snappy-stubs-internal.h
deleted file mode 100644
index d2426a74c..000000000
--- a/src/duckdb/third_party/snappy/snappy-stubs-internal.h
+++ /dev/null
@@ -1,1026 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-//
-// Various stubs for the open-source version of Snappy.
-
-#ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
-#define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
-
-// DuckDB - LNK: define here instead of in CMake
-#ifdef __GNUC__
-#define HAVE_BUILTIN_EXPECT 1
-#define HAVE_BUILTIN_CTZ 1
-#define HAVE_BUILTIN_PREFETCH 1
-#endif
-
-// These should always be available on aarch64, but sadly not on iOS/Android
-// #if defined(__aarch64__)
-// #define SNAPPY_HAVE_NEON 1
-// #define SNAPPY_HAVE_NEON_CRC32 1
-// #endif
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#if HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdint.h>
-
-#include <cassert>
-#include <cstdlib>
-#include <cstring>
-#include <limits>
-#include <string>
-
-#if HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#endif  // defined(_MSC_VER)
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#define SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-    __msan_unpoison((address), (size))
-#else
-#define SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) /* empty */
-#endif  // __has_feature(memory_sanitizer)
-
-#include "snappy-stubs-public.h"
-
-// Used to enable 64-bit optimized versions of some routines.
-#if defined(__PPC64__) || defined(__powerpc64__)
-#define ARCH_PPC 1
-#elif defined(__aarch64__) || defined(_M_ARM64)
-#define ARCH_ARM 1
-#endif
-
-// Needed by OS X, among others.
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-// The size of an array, if known at compile-time.
-// Will give unexpected results if used on a pointer.
-// We undefine it first, since some compilers already have a definition.
-#ifdef ARRAYSIZE
-#undef ARRAYSIZE
-#endif
-#define ARRAYSIZE(a) int{sizeof(a) / sizeof(*(a))}
-
-// Static prediction hints.
-#if HAVE_BUILTIN_EXPECT
-#define SNAPPY_PREDICT_FALSE(x) (__builtin_expect(x, 0))
-#define SNAPPY_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
-#else
-#define SNAPPY_PREDICT_FALSE(x) x
-#define SNAPPY_PREDICT_TRUE(x) x
-#endif  // HAVE_BUILTIN_EXPECT
-
-// Inlining hints.
-#if HAVE_ATTRIBUTE_ALWAYS_INLINE
-#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-#else
-#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-#endif  // HAVE_ATTRIBUTE_ALWAYS_INLINE
-
-#if HAVE_BUILTIN_PREFETCH
-#define SNAPPY_PREFETCH(ptr) __builtin_prefetch(ptr, 0, 3)
-#else
-#define SNAPPY_PREFETCH(ptr) (void)(ptr)
-#endif
-
-// Stubbed version of ABSL_FLAG.
-//
-// In the open source version, flags can only be changed at compile time.
-#define SNAPPY_FLAG(flag_type, flag_name, default_value, help) \
-  flag_type FLAGS_ ## flag_name = default_value
-
-namespace duckdb_snappy {
-
-// Stubbed version of absl::GetFlag().
-template <typename T>
-inline T GetFlag(T flag) { return flag; }
-
-static const uint32_t kuint32max = std::numeric_limits<uint32_t>::max();
-static const int64_t kint64max = std::numeric_limits<int64_t>::max();
-
-// Potentially unaligned loads and stores.
-
-inline uint16_t UNALIGNED_LOAD16(const void *p) {
-  // Compiles to a single movzx/ldrh on clang/gcc/msvc.
-  uint16_t v;
-  std::memcpy(&v, p, sizeof(v));
-  return v;
-}
-
-inline uint32_t UNALIGNED_LOAD32(const void *p) {
-  // Compiles to a single mov/ldr on clang/gcc/msvc.
-  uint32_t v;
-  std::memcpy(&v, p, sizeof(v));
-  return v;
-}
-
-inline uint64_t UNALIGNED_LOAD64(const void *p) {
-  // Compiles to a single mov/ldr on clang/gcc/msvc.
-  uint64_t v;
-  std::memcpy(&v, p, sizeof(v));
-  return v;
-}
-
-inline void UNALIGNED_STORE16(void *p, uint16_t v) {
-  // Compiles to a single mov/strh on clang/gcc/msvc.
-  std::memcpy(p, &v, sizeof(v));
-}
-
-inline void UNALIGNED_STORE32(void *p, uint32_t v) {
-  // Compiles to a single mov/str on clang/gcc/msvc.
-  std::memcpy(p, &v, sizeof(v));
-}
-
-inline void UNALIGNED_STORE64(void *p, uint64_t v) {
-  // Compiles to a single mov/str on clang/gcc/msvc.
-  std::memcpy(p, &v, sizeof(v));
-}
-
-// Convert to little-endian storage, opposite of network format.
-// Convert x from host to little endian: x = LittleEndian.FromHost(x);
-// convert x from little endian to host: x = LittleEndian.ToHost(x);
-//
-//  Store values into unaligned memory converting to little endian order:
-//    LittleEndian.Store16(p, x);
-//
-//  Load unaligned values stored in little endian converting to host order:
-//    x = LittleEndian.Load16(p);
-class LittleEndian {
- public:
-  // Functions to do unaligned loads and stores in little-endian order.
-  static inline uint16_t Load16(const void *ptr) {
-    // Compiles to a single mov/str on recent clang and gcc.
-#if SNAPPY_IS_BIG_ENDIAN
-    const uint8_t* const buffer = reinterpret_cast<const uint8_t*>(ptr);
-    return (static_cast<uint16_t>(buffer[0])) |
-            (static_cast<uint16_t>(buffer[1]) << 8);
-#else
-    // memcpy() turns into a single instruction early in the optimization
-    // pipeline (relatively to a series of byte accesses). So, using memcpy
-    // instead of byte accesses may lead to better decisions in more stages of
-    // the optimization pipeline.
-    uint16_t value;
-    std::memcpy(&value, ptr, 2);
-    return value;
-#endif
-  }
-
-  static inline uint32_t Load32(const void *ptr) {
-    // Compiles to a single mov/str on recent clang and gcc.
-#if SNAPPY_IS_BIG_ENDIAN
-    const uint8_t* const buffer = reinterpret_cast<const uint8_t*>(ptr);
-    return (static_cast<uint32_t>(buffer[0])) |
-            (static_cast<uint32_t>(buffer[1]) << 8) |
-            (static_cast<uint32_t>(buffer[2]) << 16) |
-            (static_cast<uint32_t>(buffer[3]) << 24);
-#else
-    // See Load16() for the rationale of using memcpy().
-    uint32_t value;
-    std::memcpy(&value, ptr, 4);
-    return value;
-#endif
-  }
-
-  static inline uint64_t Load64(const void *ptr) {
-    // Compiles to a single mov/str on recent clang and gcc.
-#if SNAPPY_IS_BIG_ENDIAN
-    const uint8_t* const buffer = reinterpret_cast<const uint8_t*>(ptr);
-    return (static_cast<uint64_t>(buffer[0])) |
-            (static_cast<uint64_t>(buffer[1]) << 8) |
-            (static_cast<uint64_t>(buffer[2]) << 16) |
-            (static_cast<uint64_t>(buffer[3]) << 24) |
-            (static_cast<uint64_t>(buffer[4]) << 32) |
-            (static_cast<uint64_t>(buffer[5]) << 40) |
-            (static_cast<uint64_t>(buffer[6]) << 48) |
-            (static_cast<uint64_t>(buffer[7]) << 56);
-#else
-    // See Load16() for the rationale of using memcpy().
-    uint64_t value;
-    std::memcpy(&value, ptr, 8);
-    return value;
-#endif
-  }
-
-  static inline void Store16(void *dst, uint16_t value) {
-    // Compiles to a single mov/str on recent clang and gcc.
-#if SNAPPY_IS_BIG_ENDIAN
-    uint8_t* const buffer = reinterpret_cast<uint8_t*>(dst);
-    buffer[0] = static_cast<uint8_t>(value);
-    buffer[1] = static_cast<uint8_t>(value >> 8);
-#else
-    // See Load16() for the rationale of using memcpy().
-    std::memcpy(dst, &value, 2);
-#endif
-  }
-
-  static void Store32(void *dst, uint32_t value) {
-    // Compiles to a single mov/str on recent clang and gcc.
-#if SNAPPY_IS_BIG_ENDIAN
-    uint8_t* const buffer = reinterpret_cast<uint8_t*>(dst);
-    buffer[0] = static_cast<uint8_t>(value);
-    buffer[1] = static_cast<uint8_t>(value >> 8);
-    buffer[2] = static_cast<uint8_t>(value >> 16);
-    buffer[3] = static_cast<uint8_t>(value >> 24);
-#else
-    // See Load16() for the rationale of using memcpy().
-    std::memcpy(dst, &value, 4);
-#endif
-  }
-
-  static void Store64(void* dst, uint64_t value) {
-    // Compiles to a single mov/str on recent clang and gcc.
-#if SNAPPY_IS_BIG_ENDIAN
-    uint8_t* const buffer = reinterpret_cast<uint8_t*>(dst);
-    buffer[0] = static_cast<uint8_t>(value);
-    buffer[1] = static_cast<uint8_t>(value >> 8);
-    buffer[2] = static_cast<uint8_t>(value >> 16);
-    buffer[3] = static_cast<uint8_t>(value >> 24);
-    buffer[4] = static_cast<uint8_t>(value >> 32);
-    buffer[5] = static_cast<uint8_t>(value >> 40);
-    buffer[6] = static_cast<uint8_t>(value >> 48);
-    buffer[7] = static_cast<uint8_t>(value >> 56);
-#else
-    // See Load16() for the rationale of using memcpy().
-    std::memcpy(dst, &value, 8);
-#endif
-  }
-
-  static inline constexpr bool IsLittleEndian() {
-#if SNAPPY_IS_BIG_ENDIAN
-    return false;
-#else
-    return true;
-#endif  // SNAPPY_IS_BIG_ENDIAN
-  }
-};
-
-// Some bit-manipulation functions.
-class Bits {
- public:
-  // Return floor(log2(n)) for positive integer n.
-  static int Log2FloorNonZero(uint32_t n);
-
-  // Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
-  static int Log2Floor(uint32_t n);
-
-  // Return the first set least / most significant bit, 0-indexed.  Returns an
-  // undefined value if n == 0.  FindLSBSetNonZero() is similar to ffs() except
-  // that it's 0-indexed.
-  static int FindLSBSetNonZero(uint32_t n);
-
-  static int FindLSBSetNonZero64(uint64_t n);
-
- private:
-  // No copying
-  Bits(const Bits&);
-  void operator=(const Bits&);
-};
-
-#if HAVE_BUILTIN_CTZ
-
-inline int Bits::Log2FloorNonZero(uint32_t n) {
-  assert(n != 0);
-  // (31 ^ x) is equivalent to (31 - x) for x in [0, 31]. An easy proof
-  // represents subtraction in base 2 and observes that there's no carry.
-  //
-  // GCC and Clang represent __builtin_clz on x86 as 31 ^ _bit_scan_reverse(x).
-  // Using "31 ^" here instead of "31 -" allows the optimizer to strip the
-  // function body down to _bit_scan_reverse(x).
-  return 31 ^ __builtin_clz(n);
-}
-
-inline int Bits::Log2Floor(uint32_t n) {
-  return (n == 0) ? -1 : Bits::Log2FloorNonZero(n);
-}
-
-inline int Bits::FindLSBSetNonZero(uint32_t n) {
-  assert(n != 0);
-  return __builtin_ctz(n);
-}
-
-#elif defined(_MSC_VER)
-
-inline int Bits::Log2FloorNonZero(uint32_t n) {
-  assert(n != 0);
-  // NOLINTNEXTLINE(runtime/int): The MSVC intrinsic demands unsigned long.
-  unsigned long where;
-  _BitScanReverse(&where, n);
-  return static_cast<int>(where);
-}
-
-inline int Bits::Log2Floor(uint32_t n) {
-  // NOLINTNEXTLINE(runtime/int): The MSVC intrinsic demands unsigned long.
-  unsigned long where;
-  if (_BitScanReverse(&where, n))
-    return static_cast<int>(where);
-  return -1;
-}
-
-inline int Bits::FindLSBSetNonZero(uint32_t n) {
-  assert(n != 0);
-  // NOLINTNEXTLINE(runtime/int): The MSVC intrinsic demands unsigned long.
-  unsigned long where;
-  if (_BitScanForward(&where, n))
-    return static_cast<int>(where);
-  return 32;
-}
-
-#else  // Portable versions.
-
-inline int Bits::Log2FloorNonZero(uint32_t n) {
-  assert(n != 0);
-
-  int log = 0;
-  uint32_t value = n;
-  for (int i = 4; i >= 0; --i) {
-    int shift = (1 << i);
-    uint32_t x = value >> shift;
-    if (x != 0) {
-      value = x;
-      log += shift;
-    }
-  }
-  assert(value == 1);
-  return log;
-}
-
-inline int Bits::Log2Floor(uint32_t n) {
-  return (n == 0) ? -1 : Bits::Log2FloorNonZero(n);
-}
-
-inline int Bits::FindLSBSetNonZero(uint32_t n) {
-  assert(n != 0);
-
-  int rc = 31;
-  for (int i = 4, shift = 1 << 4; i >= 0; --i) {
-    const uint32_t x = n << shift;
-    if (x != 0) {
-      n = x;
-      rc -= shift;
-    }
-    shift >>= 1;
-  }
-  return rc;
-}
-
-#endif  // End portable versions.
-
-#if HAVE_BUILTIN_CTZ
-
-inline int Bits::FindLSBSetNonZero64(uint64_t n) {
-  assert(n != 0);
-  return __builtin_ctzll(n);
-}
-
-#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
-// _BitScanForward64() is only available on x64 and ARM64.
-
-inline int Bits::FindLSBSetNonZero64(uint64_t n) {
-  assert(n != 0);
-  // NOLINTNEXTLINE(runtime/int): The MSVC intrinsic demands unsigned long.
-  unsigned long where;
-  if (_BitScanForward64(&where, n))
-    return static_cast<int>(where);
-  return 64;
-}
-
-#else  // Portable version.
-
-// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero().
-inline int Bits::FindLSBSetNonZero64(uint64_t n) {
-  assert(n != 0);
-
-  const uint32_t bottombits = static_cast<uint32_t>(n);
-  if (bottombits == 0) {
-    // Bottom bits are zero, so scan the top bits.
-    return 32 + FindLSBSetNonZero(static_cast<uint32_t>(n >> 32));
-  } else {
-    return FindLSBSetNonZero(bottombits);
-  }
-}
-
-#endif  // HAVE_BUILTIN_CTZ
-
-// Variable-length integer encoding.
-class Varint {
- public:
-  // Maximum lengths of varint encoding of uint32_t.
-  static const int kMax32 = 5;
-
-  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
-  // Never reads a character at or beyond limit.  If a valid/terminated varint32
-  // was found in the range, stores it in *OUTPUT and returns a pointer just
-  // past the last byte of the varint32. Else returns NULL.  On success,
-  // "result <= limit".
-  static const char* Parse32WithLimit(const char* ptr, const char* limit,
-                                      uint32_t* OUTPUT);
-
-  // REQUIRES   "ptr" points to a buffer of length sufficient to hold "v".
-  // EFFECTS    Encodes "v" into "ptr" and returns a pointer to the
-  //            byte just past the last encoded byte.
-  static char* Encode32(char* ptr, uint32_t v);
-
-  // EFFECTS    Appends the varint representation of "value" to "*s".
-  static void Append32(std::string* s, uint32_t value);
-};
-
-inline const char* Varint::Parse32WithLimit(const char* p,
-                                            const char* l,
-                                            uint32_t* OUTPUT) {
-  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
-  const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
-  uint32_t b, result;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result = b & 127;          if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
-  return NULL;       // Value is too long to be a varint32
- done:
-  *OUTPUT = result;
-  return reinterpret_cast<const char*>(ptr);
-}
-
-inline char* Varint::Encode32(char* sptr, uint32_t v) {
-  // Operate on characters as unsigneds
-  uint8_t* ptr = reinterpret_cast<uint8_t*>(sptr);
-  static const uint8_t B = 128;
-  if (v < (1 << 7)) {
-    *(ptr++) = static_cast<uint8_t>(v);
-  } else if (v < (1 << 14)) {
-    *(ptr++) = static_cast<uint8_t>(v | B);
-    *(ptr++) = static_cast<uint8_t>(v >> 7);
-  } else if (v < (1 << 21)) {
-    *(ptr++) = static_cast<uint8_t>(v | B);
-    *(ptr++) = static_cast<uint8_t>((v >> 7) | B);
-    *(ptr++) = static_cast<uint8_t>(v >> 14);
-  } else if (v < (1 << 28)) {
-    *(ptr++) = static_cast<uint8_t>(v | B);
-    *(ptr++) = static_cast<uint8_t>((v >> 7) | B);
-    *(ptr++) = static_cast<uint8_t>((v >> 14) | B);
-    *(ptr++) = static_cast<uint8_t>(v >> 21);
-  } else {
-    *(ptr++) = static_cast<uint8_t>(v | B);
-    *(ptr++) = static_cast<uint8_t>((v>>7) | B);
-    *(ptr++) = static_cast<uint8_t>((v>>14) | B);
-    *(ptr++) = static_cast<uint8_t>((v>>21) | B);
-    *(ptr++) = static_cast<uint8_t>(v >> 28);
-  }
-  return reinterpret_cast<char*>(ptr);
-}
-
-// If you know the internal layout of the std::string in use, you can
-// replace this function with one that resizes the string without
-// filling the new space with zeros (if applicable) --
-// it will be non-portable but faster.
-inline void STLStringResizeUninitialized(std::string* s, size_t new_size) {
-  s->resize(new_size);
-}
-
-// Return a mutable char* pointing to a string's internal buffer,
-// which may not be null-terminated. Writing through this pointer will
-// modify the string.
-//
-// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
-// next call to a string method that invalidates iterators.
-//
-// As of 2006-04, there is no standard-blessed way of getting a
-// mutable reference to a string's internal buffer. However, issue 530
-// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530)
-// proposes this as the method. It will officially be part of the standard
-// for C++0x. This should already work on all current implementations.
-inline char* string_as_array(std::string* str) {
-  return str->empty() ? NULL : &*str->begin();
-}
-
-}  // namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <string>
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#endif  // defined(_MSC_VER)
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#define SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-    __msan_unpoison((address), (size))
-#else
-#define SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) /* empty */
-#endif  // __has_feature(memory_sanitizer)
-
-#include "snappy-stubs-public.h"
-
-#if defined(__x86_64__)
-
-// Enable 64-bit optimized versions of some routines.
-#define ARCH_K8 1
-
-#elif defined(__ppc64__)
-
-#define ARCH_PPC 1
-
-#elif defined(__aarch64__)
-
-#define ARCH_ARM 1
-
-#endif
-
-// Needed by OS X, among others.
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-// The size of an array, if known at compile-time.
-// Will give unexpected results if used on a pointer.
-// We undefine it first, since some compilers already have a definition.
-#ifdef ARRAYSIZE
-#undef ARRAYSIZE
-#endif
-#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
-
-// Static prediction hints.
-#ifdef HAVE_BUILTIN_EXPECT
-#define SNAPPY_PREDICT_FALSE(x) (__builtin_expect(x, 0))
-#define SNAPPY_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
-#else
-#define SNAPPY_PREDICT_FALSE(x) x
-#define SNAPPY_PREDICT_TRUE(x) x
-#endif
-
-// This is only used for recomputing the tag byte table used during
-// decompression; for simplicity we just remove it from the open-source
-// version (anyone who wants to regenerate it can just do the call
-// themselves within main()).
-#define DEFINE_bool(flag_name, default_value, description) \
-  bool FLAGS_ ## flag_name = default_value
-#define DECLARE_bool(flag_name) \
-  extern bool FLAGS_ ## flag_name
-
-namespace duckdb_snappy {
-
-//static const uint32 kuint32max = static_cast<uint32>(0xFFFFFFFF);
-//static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL);
-
-
-// HM: Always use aligned load to keep ourselves out of trouble. Sorry.
-
-inline uint16 UNALIGNED_LOAD16(const void *p) {
-  uint16 t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint32 UNALIGNED_LOAD32(const void *p) {
-  uint32 t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint64 UNALIGNED_LOAD64(const void *p) {
-  uint64 t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline void UNALIGNED_STORE16(void *p, uint16 v) {
-  memcpy(p, &v, sizeof v);
-}
-
-inline void UNALIGNED_STORE32(void *p, uint32 v) {
-  memcpy(p, &v, sizeof v);
-}
-
-inline void UNALIGNED_STORE64(void *p, uint64 v) {
-  memcpy(p, &v, sizeof v);
-}
-
-
-// The following guarantees declaration of the byte swap functions.
-#if defined(SNAPPY_IS_BIG_ENDIAN)
-
-#ifdef HAVE_SYS_BYTEORDER_H
-#include <sys/byteorder.h>
-#endif
-
-#ifdef HAVE_SYS_ENDIAN_H
-#include <sys/endian.h>
-#endif
-
-#ifdef _MSC_VER
-#include <stdlib.h>
-#define bswap_16(x) _byteswap_ushort(x)
-#define bswap_32(x) _byteswap_ulong(x)
-#define bswap_64(x) _byteswap_uint64(x)
-
-#elif defined(__APPLE__)
-// Mac OS X / Darwin features
-#include <libkern/OSByteOrder.h>
-#define bswap_16(x) OSSwapInt16(x)
-#define bswap_32(x) OSSwapInt32(x)
-#define bswap_64(x) OSSwapInt64(x)
-
-#elif defined(HAVE_BYTESWAP_H)
-#include <byteswap.h>
-
-#elif defined(bswap32)
-// FreeBSD defines bswap{16,32,64} in <sys/endian.h> (already #included).
-#define bswap_16(x) bswap16(x)
-#define bswap_32(x) bswap32(x)
-#define bswap_64(x) bswap64(x)
-
-#elif defined(BSWAP_64)
-// Solaris 10 defines BSWAP_{16,32,64} in <sys/byteorder.h> (already #included).
-#define bswap_16(x) BSWAP_16(x)
-#define bswap_32(x) BSWAP_32(x)
-#define bswap_64(x) BSWAP_64(x)
-
-#else
-
-inline uint16 bswap_16(uint16 x) {
-  return (x << 8) | (x >> 8);
-}
-
-inline uint32 bswap_32(uint32 x) {
-  x = ((x & 0xff00ff00UL) >> 8) | ((x & 0x00ff00ffUL) << 8);
-  return (x >> 16) | (x << 16);
-}
-
-inline uint64 bswap_64(uint64 x) {
-  x = ((x & 0xff00ff00ff00ff00ULL) >> 8) | ((x & 0x00ff00ff00ff00ffULL) << 8);
-  x = ((x & 0xffff0000ffff0000ULL) >> 16) | ((x & 0x0000ffff0000ffffULL) << 16);
-  return (x >> 32) | (x << 32);
-}
-
-#endif
-
-#endif  // defined(SNAPPY_IS_BIG_ENDIAN)
-
-// Convert to little-endian storage, opposite of network format.
-// Convert x from host to little endian: x = LittleEndian.FromHost(x);
-// convert x from little endian to host: x = LittleEndian.ToHost(x);
-//
-//  Store values into unaligned memory converting to little endian order:
-//    LittleEndian.Store16(p, x);
-//
-//  Load unaligned values stored in little endian converting to host order:
-//    x = LittleEndian.Load16(p);
-class LittleEndian {
- public:
-  // Conversion functions.
-#if defined(SNAPPY_IS_BIG_ENDIAN)
-
-  static uint16 FromHost16(uint16 x) { return bswap_16(x); }
-  static uint16 ToHost16(uint16 x) { return bswap_16(x); }
-
-  static uint32 FromHost32(uint32 x) { return bswap_32(x); }
-  static uint32 ToHost32(uint32 x) { return bswap_32(x); }
-
-  static bool IsLittleEndian() { return false; }
-
-#else  // !defined(SNAPPY_IS_BIG_ENDIAN)
-
-  static uint16 FromHost16(uint16 x) { return x; }
-  static uint16 ToHost16(uint16 x) { return x; }
-
-  static uint32 FromHost32(uint32 x) { return x; }
-  static uint32 ToHost32(uint32 x) { return x; }
-
-  static bool IsLittleEndian() { return true; }
-
-#endif  // !defined(SNAPPY_IS_BIG_ENDIAN)
-
-  // Functions to do unaligned loads and stores in little-endian order.
-  static uint16 Load16(const void *p) {
-    return ToHost16(UNALIGNED_LOAD16(p));
-  }
-
-  static void Store16(void *p, uint16 v) {
-    UNALIGNED_STORE16(p, FromHost16(v));
-  }
-
-  static uint32 Load32(const void *p) {
-    return ToHost32(UNALIGNED_LOAD32(p));
-  }
-
-  static void Store32(void *p, uint32 v) {
-    UNALIGNED_STORE32(p, FromHost32(v));
-  }
-};
-
-// Some bit-manipulation functions.
-class Bits {
- public:
-  // Return floor(log2(n)) for positive integer n.
-  static int Log2FloorNonZero(uint32 n);
-
-  // Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
-  static int Log2Floor(uint32 n);
-
-  // Return the first set least / most significant bit, 0-indexed.  Returns an
-  // undefined value if n == 0.  FindLSBSetNonZero() is similar to ffs() except
-  // that it's 0-indexed.
-  static int FindLSBSetNonZero(uint32 n);
-
-#if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-  static int FindLSBSetNonZero64(uint64 n);
-#endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-
- private:
-  // No copying
-  Bits(const Bits&);
-  void operator=(const Bits&);
-};
-
-#ifdef HAVE_BUILTIN_CTZ
-
-inline int Bits::Log2FloorNonZero(uint32 n) {
-  assert(n != 0);
-  // (31 ^ x) is equivalent to (31 - x) for x in [0, 31]. An easy proof
-  // represents subtraction in base 2 and observes that there's no carry.
-  //
-  // GCC and Clang represent __builtin_clz on x86 as 31 ^ _bit_scan_reverse(x).
-  // Using "31 ^" here instead of "31 -" allows the optimizer to strip the
-  // function body down to _bit_scan_reverse(x).
-  return 31 ^ __builtin_clz(n);
-}
-
-inline int Bits::Log2Floor(uint32 n) {
-  return (n == 0) ? -1 : Bits::Log2FloorNonZero(n);
-}
-
-inline int Bits::FindLSBSetNonZero(uint32 n) {
-  assert(n != 0);
-  return __builtin_ctz(n);
-}
-
-#if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-inline int Bits::FindLSBSetNonZero64(uint64 n) {
-  assert(n != 0);
-  return __builtin_ctzll(n);
-}
-#endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-
-#elif defined(_MSC_VER)
-
-inline int Bits::Log2FloorNonZero(uint32 n) {
-  assert(n != 0);
-  unsigned long where;
-  _BitScanReverse(&where, n);
-  return static_cast<int>(where);
-}
-
-inline int Bits::Log2Floor(uint32 n) {
-  unsigned long where;
-  if (_BitScanReverse(&where, n))
-    return static_cast<int>(where);
-  return -1;
-}
-
-inline int Bits::FindLSBSetNonZero(uint32 n) {
-  assert(n != 0);
-  unsigned long where;
-  if (_BitScanForward(&where, n))
-    return static_cast<int>(where);
-  return 32;
-}
-
-#if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-inline int Bits::FindLSBSetNonZero64(uint64 n) {
-  assert(n != 0);
-  unsigned long where;
-  if (_BitScanForward64(&where, n))
-    return static_cast<int>(where);
-  return 64;
-}
-#endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-
-#else  // Portable versions.
-
-inline int Bits::Log2FloorNonZero(uint32 n) {
-  assert(n != 0);
-
-  int log = 0;
-  uint32 value = n;
-  for (int i = 4; i >= 0; --i) {
-    int shift = (1 << i);
-    uint32 x = value >> shift;
-    if (x != 0) {
-      value = x;
-      log += shift;
-    }
-  }
-  assert(value == 1);
-  return log;
-}
-
-inline int Bits::Log2Floor(uint32 n) {
-  return (n == 0) ? -1 : Bits::Log2FloorNonZero(n);
-}
-
-inline int Bits::FindLSBSetNonZero(uint32 n) {
-  assert(n != 0);
-
-  int rc = 31;
-  for (int i = 4, shift = 1 << 4; i >= 0; --i) {
-    const uint32 x = n << shift;
-    if (x != 0) {
-      n = x;
-      rc -= shift;
-    }
-    shift >>= 1;
-  }
-  return rc;
-}
-
-#if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero().
-inline int Bits::FindLSBSetNonZero64(uint64 n) {
-  assert(n != 0);
-
-  const uint32 bottombits = static_cast<uint32>(n);
-  if (bottombits == 0) {
-    // Bottom bits are zero, so scan in top bits
-    return 32 + FindLSBSetNonZero(static_cast<uint32>(n >> 32));
-  } else {
-    return FindLSBSetNonZero(bottombits);
-  }
-}
-#endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-
-#endif  // End portable versions.
-
-// Variable-length integer encoding.
-class Varint {
- public:
-  // Maximum lengths of varint encoding of uint32.
-  static const int kMax32 = 5;
-
-  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
-  // Never reads a character at or beyond limit.  If a valid/terminated varint32
-  // was found in the range, stores it in *OUTPUT and returns a pointer just
-  // past the last byte of the varint32. Else returns NULL.  On success,
-  // "result <= limit".
-  static const char* Parse32WithLimit(const char* ptr, const char* limit,
-                                      uint32* OUTPUT);
-
-  // REQUIRES   "ptr" points to a buffer of length sufficient to hold "v".
-  // EFFECTS    Encodes "v" into "ptr" and returns a pointer to the
-  //            byte just past the last encoded byte.
-  static char* Encode32(char* ptr, uint32 v);
-
-  // EFFECTS    Appends the varint representation of "value" to "*s".
-  static void Append32(string* s, uint32 value);
-};
-
-inline const char* Varint::Parse32WithLimit(const char* p,
-                                            const char* l,
-                                            uint32* OUTPUT) {
-  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
-  const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
-  uint32 b, result;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result = b & 127;          if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
-  if (ptr >= limit) return NULL;
-  b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
-  return NULL;       // Value is too long to be a varint32
- done:
-  *OUTPUT = result;
-  return reinterpret_cast<const char*>(ptr);
-}
-
-inline char* Varint::Encode32(char* sptr, uint32 v) {
-  // Operate on characters as unsigneds
-  unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
-  static const int B = 128;
-  if (v < (1<<7)) {
-    *(ptr++) = v;
-  } else if (v < (1<<14)) {
-    *(ptr++) = v | B;
-    *(ptr++) = v>>7;
-  } else if (v < (1<<21)) {
-    *(ptr++) = v | B;
-    *(ptr++) = (v>>7) | B;
-    *(ptr++) = v>>14;
-  } else if (v < (1<<28)) {
-    *(ptr++) = v | B;
-    *(ptr++) = (v>>7) | B;
-    *(ptr++) = (v>>14) | B;
-    *(ptr++) = v>>21;
-  } else {
-    *(ptr++) = v | B;
-    *(ptr++) = (v>>7) | B;
-    *(ptr++) = (v>>14) | B;
-    *(ptr++) = (v>>21) | B;
-    *(ptr++) = v>>28;
-  }
-  return reinterpret_cast<char*>(ptr);
-}
-
-// If you know the internal layout of the std::string in use, you can
-// replace this function with one that resizes the string without
-// filling the new space with zeros (if applicable) --
-// it will be non-portable but faster.
-inline void STLStringResizeUninitialized(string* s, size_t new_size) {
-  s->resize(new_size);
-}
-
-// Return a mutable char* pointing to a string's internal buffer,
-// which may not be null-terminated. Writing through this pointer will
-// modify the string.
-//
-// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
-// next call to a string method that invalidates iterators.
-//
-// As of 2006-04, there is no standard-blessed way of getting a
-// mutable reference to a string's internal buffer. However, issue 530
-// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530)
-// proposes this as the method. It will officially be part of the standard
-// for C++0x. This should already work on all current implementations.
-inline char* string_as_array(string* str) {
-  return str->empty() ? NULL : &*str->begin();
-}
-
-}  // namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
-
-#endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
diff --git a/src/duckdb/third_party/snappy/snappy-stubs-public.h b/src/duckdb/third_party/snappy/snappy-stubs-public.h
deleted file mode 100644
index afaca195f..000000000
--- a/src/duckdb/third_party/snappy/snappy-stubs-public.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-//
-// Various type stubs for the open-source version of Snappy.
-//
-// This file cannot include config.h, as it is included from snappy.h,
-// which is a public header. Instead, snappy-stubs-public.h is generated by
-// from snappy-stubs-public.h.in at configure time.
-
-#ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
-#define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#include <cstddef>
-
-#ifndef _WIN32  // HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif  // HAVE_SYS_UIO_H
-
-#define SNAPPY_MAJOR 1
-#define SNAPPY_MINOR 2
-#define SNAPPY_PATCHLEVEL 1
-#define SNAPPY_VERSION \
-    ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
-
-namespace duckdb_snappy {
-
-#ifdef _WIN32  // !HAVE_SYS_UIO_H
-// Windows does not have an iovec type, yet the concept is universally useful.
-// It is simple to define it ourselves, so we put it inside our own namespace.
-struct iovec {
-  void* iov_base;
-  size_t iov_len;
-};
-#endif  // !HAVE_SYS_UIO_H
-
-}  // namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
-#ifndef _WIN32  // HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif  // HAVE_SYS_UIO_H
-
-#define SNAPPY_MAJOR 1
-#define SNAPPY_MINOR 1
-#define SNAPPY_PATCHLEVEL 7
-#define SNAPPY_VERSION \
-((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
-
-namespace duckdb_snappy {
-
-using int8 = std::int8_t;
-using uint8 = std::uint8_t;
-using int16 = std::int16_t;
-using uint16 = std::uint16_t;
-using int32 = std::int32_t;
-using uint32 = std::uint32_t;
-using int64 = std::int64_t;
-using uint64 = std::uint64_t;
-
-using string = std::string;
-
-#ifdef _WIN32  // !HAVE_SYS_UIO_H
-// Windows does not have an iovec type, yet the concept is universally useful.
-// It is simple to define it ourselves, so we put it inside our own namespace.
-struct iovec {
-  void* iov_base;
-  size_t iov_len;
-};
-#endif  // !HAVE_SYS_UIO_H
-
-}  // namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
-
-#endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
diff --git a/src/duckdb/third_party/snappy/snappy.cc b/src/duckdb/third_party/snappy/snappy.cc
deleted file mode 100644
index f3ebe0664..000000000
--- a/src/duckdb/third_party/snappy/snappy.cc
+++ /dev/null
@@ -1,4288 +0,0 @@
-// Copyright 2005 Google Inc. All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#include "snappy-internal.h"
-#include "snappy-sinksource.h"
-#include "snappy.h"
-#if !defined(SNAPPY_HAVE_BMI2)
-// __BMI2__ is defined by GCC and Clang. Visual Studio doesn't target BMI2
-// specifically, but it does define __AVX2__ when AVX2 support is available.
-// Fortunately, AVX2 was introduced in Haswell, just like BMI2.
-//
-// BMI2 is not defined as a subset of AVX2 (unlike SSSE3 and AVX above). So,
-// GCC and Clang can build code with AVX2 enabled but BMI2 disabled, in which
-// case issuing BMI2 instructions results in a compiler error.
-#if defined(__BMI2__) || (defined(_MSC_VER) && defined(__AVX2__))
-#define SNAPPY_HAVE_BMI2 1
-#else
-#define SNAPPY_HAVE_BMI2 0
-#endif
-#endif  // !defined(SNAPPY_HAVE_BMI2)
-
-#if !defined(SNAPPY_HAVE_X86_CRC32)
-#if defined(__SSE4_2__)
-#define SNAPPY_HAVE_X86_CRC32 1
-#else
-#define SNAPPY_HAVE_X86_CRC32 0
-#endif
-#endif  // !defined(SNAPPY_HAVE_X86_CRC32)
-
-#if !defined(SNAPPY_HAVE_NEON_CRC32)
-#if SNAPPY_HAVE_NEON && defined(__ARM_FEATURE_CRC32)
-#define SNAPPY_HAVE_NEON_CRC32 1
-#else
-#define SNAPPY_HAVE_NEON_CRC32 0
-#endif
-#endif  // !defined(SNAPPY_HAVE_NEON_CRC32)
-
-#if SNAPPY_HAVE_BMI2 || SNAPPY_HAVE_X86_CRC32
-// Please do not replace with <x86intrin.h>. or with headers that assume more
-// advanced SSE versions without checking with all the OWNERS.
-#include <immintrin.h>
-#elif SNAPPY_HAVE_NEON_CRC32
-#include <arm_acle.h>
-#endif
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace duckdb_snappy {
-
-namespace {
-
-// The amount of slop bytes writers are using for unconditional copies.
-constexpr int kSlopBytes = 64;
-
-using internal::char_table;
-using internal::COPY_1_BYTE_OFFSET;
-using internal::COPY_2_BYTE_OFFSET;
-using internal::COPY_4_BYTE_OFFSET;
-using internal::kMaximumTagLength;
-using internal::LITERAL;
-#if SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-using internal::V128;
-using internal::V128_Load;
-using internal::V128_LoadU;
-using internal::V128_Shuffle;
-using internal::V128_StoreU;
-using internal::V128_DupChar;
-#endif
-
-// We translate the information encoded in a tag through a lookup table to a
-// format that requires fewer instructions to decode. Effectively we store
-// the length minus the tag part of the offset. The lowest significant byte
-// thus stores the length. While total length - offset is given by
-// entry - ExtractOffset(type). The nice thing is that the subtraction
-// immediately sets the flags for the necessary check that offset >= length.
-// This folds the cmp with sub. We engineer the long literals and copy-4 to
-// always fail this check, so their presence doesn't affect the fast path.
-// To prevent literals from triggering the guard against offset < length (offset
-// does not apply to literals) the table is giving them a spurious offset of
-// 256.
-inline constexpr int16_t MakeEntry(int16_t len, int16_t offset) {
-  return len - (offset << 8);
-}
-
-inline constexpr int16_t LengthMinusOffset(int data, int type) {
-  return type == 3   ? 0xFF                    // copy-4 (or type == 3)
-         : type == 2 ? MakeEntry(data + 1, 0)  // copy-2
-         : type == 1 ? MakeEntry((data & 7) + 4, data >> 3)  // copy-1
-         : data < 60 ? MakeEntry(data + 1, 1)  // note spurious offset.
-                     : 0xFF;                   // long literal
-}
-
-inline constexpr int16_t LengthMinusOffset(uint8_t tag) {
-  return LengthMinusOffset(tag >> 2, tag & 3);
-}
-
-template <size_t... Ints>
-struct index_sequence {};
-
-template <std::size_t N, size_t... Is>
-struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};
-
-template <size_t... Is>
-struct make_index_sequence<0, Is...> : index_sequence<Is...> {};
-
-template <size_t... seq>
-constexpr std::array<int16_t, 256> MakeTable(index_sequence<seq...>) {
-  return std::array<int16_t, 256>{LengthMinusOffset(seq)...};
-}
-
-alignas(64) const std::array<int16_t, 256> kLengthMinusOffset =
-    MakeTable(make_index_sequence<256>{});
-
-// Given a table of uint16_t whose size is mask / 2 + 1, return a pointer to the
-// relevant entry, if any, for the given bytes.  Any hash function will do,
-// but a good hash function reduces the number of collisions and thus yields
-// better compression for compressible input.
-//
-// REQUIRES: mask is 2 * (table_size - 1), and table_size is a power of two.
-inline uint16_t* TableEntry(uint16_t* table, uint32_t bytes, uint32_t mask) {
-  // Our choice is quicker-and-dirtier than the typical hash function;
-  // empirically, that seems beneficial.  The upper bits of kMagic * bytes are a
-  // higher-quality hash than the lower bits, so when using kMagic * bytes we
-  // also shift right to get a higher-quality end result.  There's no similar
-  // issue with a CRC because all of the output bits of a CRC are equally good
-  // "hashes." So, a CPU instruction for CRC, if available, tends to be a good
-  // choice.
-#if SNAPPY_HAVE_NEON_CRC32
-  // We use mask as the second arg to the CRC function, as it's about to
-  // be used anyway; it'd be equally correct to use 0 or some constant.
-  // Mathematically, _mm_crc32_u32 (or similar) is a function of the
-  // xor of its arguments.
-  const uint32_t hash = __crc32cw(bytes, mask);
-#elif SNAPPY_HAVE_X86_CRC32
-  const uint32_t hash = _mm_crc32_u32(bytes, mask);
-#else
-  constexpr uint32_t kMagic = 0x1e35a7bd;
-  const uint32_t hash = (kMagic * bytes) >> (31 - kMaxHashTableBits);
-#endif
-  return reinterpret_cast<uint16_t*>(reinterpret_cast<uintptr_t>(table) +
-                                     (hash & mask));
-}
-
-inline uint16_t* TableEntry4ByteMatch(uint16_t* table, uint32_t bytes,
-                                      uint32_t mask) {
-  constexpr uint32_t kMagic = 2654435761U;
-  const uint32_t hash = (kMagic * bytes) >> (32 - kMaxHashTableBits);
-  return reinterpret_cast<uint16_t*>(reinterpret_cast<uintptr_t>(table) +
-                                     (hash & mask));
-}
-
-inline uint16_t* TableEntry8ByteMatch(uint16_t* table, uint64_t bytes,
-                                      uint32_t mask) {
-  constexpr uint64_t kMagic = 58295818150454627ULL;
-  const uint32_t hash = (kMagic * bytes) >> (64 - kMaxHashTableBits);
-  return reinterpret_cast<uint16_t*>(reinterpret_cast<uintptr_t>(table) +
-                                     (hash & mask));
-}
-
-}  // namespace
-
-size_t MaxCompressedLength(size_t source_bytes) {
-  // Compressed data can be defined as:
-  //    compressed := item* literal*
-  //    item       := literal* copy
-  //
-  // The trailing literal sequence has a space blowup of at most 62/60
-  // since a literal of length 60 needs one tag byte + one extra byte
-  // for length information.
-  //
-  // Item blowup is trickier to measure.  Suppose the "copy" op copies
-  // 4 bytes of data.  Because of a special check in the encoding code,
-  // we produce a 4-byte copy only if the offset is < 65536.  Therefore
-  // the copy op takes 3 bytes to encode, and this type of item leads
-  // to at most the 62/60 blowup for representing literals.
-  //
-  // Suppose the "copy" op copies 5 bytes of data.  If the offset is big
-  // enough, it will take 5 bytes to encode the copy op.  Therefore the
-  // worst case here is a one-byte literal followed by a five-byte copy.
-  // I.e., 6 bytes of input turn into 7 bytes of "compressed" data.
-  //
-  // This last factor dominates the blowup, so the final estimate is:
-  return 32 + source_bytes + source_bytes / 6;
-}
-
-namespace {
-
-void UnalignedCopy64(const void* src, void* dst) {
-  char tmp[8];
-  std::memcpy(tmp, src, 8);
-  std::memcpy(dst, tmp, 8);
-}
-
-void UnalignedCopy128(const void* src, void* dst) {
-  // std::memcpy() gets vectorized when the appropriate compiler options are
-  // used. For example, x86 compilers targeting SSE2+ will optimize to an SSE2
-  // load and store.
-  char tmp[16];
-  std::memcpy(tmp, src, 16);
-  std::memcpy(dst, tmp, 16);
-}
-
-template <bool use_16bytes_chunk>
-inline void ConditionalUnalignedCopy128(const char* src, char* dst) {
-  if (use_16bytes_chunk) {
-    UnalignedCopy128(src, dst);
-  } else {
-    UnalignedCopy64(src, dst);
-    UnalignedCopy64(src + 8, dst + 8);
-  }
-}
-
-// Copy [src, src+(op_limit-op)) to [op, (op_limit-op)) a byte at a time. Used
-// for handling COPY operations where the input and output regions may overlap.
-// For example, suppose:
-//    src       == "ab"
-//    op        == src + 2
-//    op_limit  == op + 20
-// After IncrementalCopySlow(src, op, op_limit), the result will have eleven
-// copies of "ab"
-//    ababababababababababab
-// Note that this does not match the semantics of either std::memcpy() or
-// std::memmove().
-inline char* IncrementalCopySlow(const char* src, char* op,
-                                 char* const op_limit) {
-  // TODO: Remove pragma when LLVM is aware this
-  // function is only called in cold regions and when cold regions don't get
-  // vectorized or unrolled.
-#ifdef __clang__
-#pragma clang loop unroll(disable)
-#endif
-  while (op < op_limit) {
-    *op++ = *src++;
-  }
-  return op_limit;
-}
-
-#if SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-
-// Computes the bytes for shuffle control mask (please read comments on
-// 'pattern_generation_masks' as well) for the given index_offset and
-// pattern_size. For example, when the 'offset' is 6, it will generate a
-// repeating pattern of size 6. So, the first 16 byte indexes will correspond to
-// the pattern-bytes {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3} and the
-// next 16 byte indexes will correspond to the pattern-bytes {4, 5, 0, 1, 2, 3,
-// 4, 5, 0, 1, 2, 3, 4, 5, 0, 1}. These byte index sequences are generated by
-// calling MakePatternMaskBytes(0, 6, index_sequence<16>()) and
-// MakePatternMaskBytes(16, 6, index_sequence<16>()) respectively.
-template <size_t... indexes>
-inline constexpr std::array<char, sizeof...(indexes)> MakePatternMaskBytes(
-    int index_offset, int pattern_size, index_sequence<indexes...>) {
-  return {static_cast<char>((index_offset + indexes) % pattern_size)...};
-}
-
-// Computes the shuffle control mask bytes array for given pattern-sizes and
-// returns an array.
-template <size_t... pattern_sizes_minus_one>
-inline constexpr std::array<std::array<char, sizeof(V128)>,
-                            sizeof...(pattern_sizes_minus_one)>
-MakePatternMaskBytesTable(int index_offset,
-                          index_sequence<pattern_sizes_minus_one...>) {
-  return {
-      MakePatternMaskBytes(index_offset, pattern_sizes_minus_one + 1,
-                           make_index_sequence</*indexes=*/sizeof(V128)>())...};
-}
-
-// This is an array of shuffle control masks that can be used as the source
-// operand for PSHUFB to permute the contents of the destination XMM register
-// into a repeating byte pattern.
-alignas(16) constexpr std::array<std::array<char, sizeof(V128)>,
-                                 16> pattern_generation_masks =
-    MakePatternMaskBytesTable(
-        /*index_offset=*/0,
-        /*pattern_sizes_minus_one=*/make_index_sequence<16>());
-
-// Similar to 'pattern_generation_masks', this table is used to "rotate" the
-// pattern so that we can copy the *next 16 bytes* consistent with the pattern.
-// Basically, pattern_reshuffle_masks is a continuation of
-// pattern_generation_masks. It follows that, pattern_reshuffle_masks is same as
-// pattern_generation_masks for offsets 1, 2, 4, 8 and 16.
-alignas(16) constexpr std::array<std::array<char, sizeof(V128)>,
-                                 16> pattern_reshuffle_masks =
-    MakePatternMaskBytesTable(
-        /*index_offset=*/16,
-        /*pattern_sizes_minus_one=*/make_index_sequence<16>());
-
-SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-static inline V128 LoadPattern(const char* src, const size_t pattern_size) {
-  V128 generation_mask = V128_Load(reinterpret_cast<const V128*>(
-      pattern_generation_masks[pattern_size - 1].data()));
-  // Uninitialized bytes are masked out by the shuffle mask.
-  // TODO: remove annotation and macro defs once MSan is fixed.
-  SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(src + pattern_size, 16 - pattern_size);
-  return V128_Shuffle(V128_LoadU(reinterpret_cast<const V128*>(src)),
-                      generation_mask);
-}
-
-SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-static inline std::pair<V128 /* pattern */, V128 /* reshuffle_mask */>
-LoadPatternAndReshuffleMask(const char* src, const size_t pattern_size) {
-  V128 pattern = LoadPattern(src, pattern_size);
-
-  // This mask will generate the next 16 bytes in-place. Doing so enables us to
-  // write data by at most 4 V128_StoreU.
-  //
-  // For example, suppose pattern is:        abcdefabcdefabcd
-  // Shuffling with this mask will generate: efabcdefabcdefab
-  // Shuffling again will generate:          cdefabcdefabcdef
-  V128 reshuffle_mask = V128_Load(reinterpret_cast<const V128*>(
-      pattern_reshuffle_masks[pattern_size - 1].data()));
-  return {pattern, reshuffle_mask};
-}
-
-#endif  // SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-
-// Fallback for when we need to copy while extending the pattern, for example
-// copying 10 bytes from 3 positions back abc -> abcabcabcabca.
-//
-// REQUIRES: [dst - offset, dst + 64) is a valid address range.
-SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-static inline bool Copy64BytesWithPatternExtension(char* dst, size_t offset) {
-#if SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-  if (SNAPPY_PREDICT_TRUE(offset <= 16)) {
-    switch (offset) {
-      case 0:
-        return false;
-      case 1: {
-        // TODO: Ideally we should memset, move back once the
-        // codegen issues are fixed.
-        V128 pattern = V128_DupChar(dst[-1]);
-        for (int i = 0; i < 4; i++) {
-          V128_StoreU(reinterpret_cast<V128*>(dst + 16 * i), pattern);
-        }
-        return true;
-      }
-      case 2:
-      case 4:
-      case 8:
-      case 16: {
-        V128 pattern = LoadPattern(dst - offset, offset);
-        for (int i = 0; i < 4; i++) {
-          V128_StoreU(reinterpret_cast<V128*>(dst + 16 * i), pattern);
-        }
-        return true;
-      }
-      default: {
-        auto pattern_and_reshuffle_mask =
-            LoadPatternAndReshuffleMask(dst - offset, offset);
-        V128 pattern = pattern_and_reshuffle_mask.first;
-        V128 reshuffle_mask = pattern_and_reshuffle_mask.second;
-        for (int i = 0; i < 4; i++) {
-          V128_StoreU(reinterpret_cast<V128*>(dst + 16 * i), pattern);
-          pattern = V128_Shuffle(pattern, reshuffle_mask);
-        }
-        return true;
-      }
-    }
-  }
-#else
-  if (SNAPPY_PREDICT_TRUE(offset < 16)) {
-    if (SNAPPY_PREDICT_FALSE(offset == 0)) return false;
-    // Extend the pattern to the first 16 bytes.
-    // The simpler formulation of `dst[i - offset]` induces undefined behavior.
-    for (int i = 0; i < 16; i++) dst[i] = (dst - offset)[i];
-    // Find a multiple of pattern >= 16.
-    static std::array<uint8_t, 16> pattern_sizes = []() {
-      std::array<uint8_t, 16> res;
-      for (int i = 1; i < 16; i++) res[i] = (16 / i + 1) * i;
-      return res;
-    }();
-    offset = pattern_sizes[offset];
-    for (int i = 1; i < 4; i++) {
-      std::memcpy(dst + i * 16, dst + i * 16 - offset, 16);
-    }
-    return true;
-  }
-#endif  // SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-
-  // Very rare.
-  for (int i = 0; i < 4; i++) {
-    std::memcpy(dst + i * 16, dst + i * 16 - offset, 16);
-  }
-  return true;
-}
-
-// Copy [src, src+(op_limit-op)) to [op, op_limit) but faster than
-// IncrementalCopySlow. buf_limit is the address past the end of the writable
-// region of the buffer.
-inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
-                             char* const buf_limit) {
-#if SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-  constexpr int big_pattern_size_lower_bound = 16;
-#else
-  constexpr int big_pattern_size_lower_bound = 8;
-#endif
-
-  // Terminology:
-  //
-  // slop = buf_limit - op
-  // pat  = op - src
-  // len  = op_limit - op
-  assert(src < op);
-  assert(op < op_limit);
-  assert(op_limit <= buf_limit);
-  // NOTE: The copy tags use 3 or 6 bits to store the copy length, so len <= 64.
-  assert(op_limit - op <= 64);
-  // NOTE: In practice the compressor always emits len >= 4, so it is ok to
-  // assume that to optimize this function, but this is not guaranteed by the
-  // compression format, so we have to also handle len < 4 in case the input
-  // does not satisfy these conditions.
-
-  size_t pattern_size = op - src;
-  // The cases are split into different branches to allow the branch predictor,
-  // FDO, and static prediction hints to work better. For each input we list the
-  // ratio of invocations that match each condition.
-  //
-  // input        slop < 16   pat < 8  len > 16
-  // ------------------------------------------
-  // html|html4|cp   0%         1.01%    27.73%
-  // urls            0%         0.88%    14.79%
-  // jpg             0%        64.29%     7.14%
-  // pdf             0%         2.56%    58.06%
-  // txt[1-4]        0%         0.23%     0.97%
-  // pb              0%         0.96%    13.88%
-  // bin             0.01%     22.27%    41.17%
-  //
-  // It is very rare that we don't have enough slop for doing block copies. It
-  // is also rare that we need to expand a pattern. Small patterns are common
-  // for incompressible formats and for those we are plenty fast already.
-  // Lengths are normally not greater than 16 but they vary depending on the
-  // input. In general if we always predict len <= 16 it would be an ok
-  // prediction.
-  //
-  // In order to be fast we want a pattern >= 16 bytes (or 8 bytes in non-SSE)
-  // and an unrolled loop copying 1x 16 bytes (or 2x 8 bytes in non-SSE) at a
-  // time.
-
-  // Handle the uncommon case where pattern is less than 16 (or 8 in non-SSE)
-  // bytes.
-  if (pattern_size < big_pattern_size_lower_bound) {
-#if SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-    // Load the first eight bytes into an 128-bit XMM register, then use PSHUFB
-    // to permute the register's contents in-place into a repeating sequence of
-    // the first "pattern_size" bytes.
-    // For example, suppose:
-    //    src       == "abc"
-    //    op        == op + 3
-    // After V128_Shuffle(), "pattern" will have five copies of "abc"
-    // followed by one byte of slop: abcabcabcabcabca.
-    //
-    // The non-SSE fallback implementation suffers from store-forwarding stalls
-    // because its loads and stores partly overlap. By expanding the pattern
-    // in-place, we avoid the penalty.
-
-    // Typically, the op_limit is the gating factor so try to simplify the loop
-    // based on that.
-    if (SNAPPY_PREDICT_TRUE(op_limit <= buf_limit - 15)) {
-      auto pattern_and_reshuffle_mask =
-          LoadPatternAndReshuffleMask(src, pattern_size);
-      V128 pattern = pattern_and_reshuffle_mask.first;
-      V128 reshuffle_mask = pattern_and_reshuffle_mask.second;
-
-      // There is at least one, and at most four 16-byte blocks. Writing four
-      // conditionals instead of a loop allows FDO to layout the code with
-      // respect to the actual probabilities of each length.
-      // TODO: Replace with loop with trip count hint.
-      V128_StoreU(reinterpret_cast<V128*>(op), pattern);
-
-      if (op + 16 < op_limit) {
-        pattern = V128_Shuffle(pattern, reshuffle_mask);
-        V128_StoreU(reinterpret_cast<V128*>(op + 16), pattern);
-      }
-      if (op + 32 < op_limit) {
-        pattern = V128_Shuffle(pattern, reshuffle_mask);
-        V128_StoreU(reinterpret_cast<V128*>(op + 32), pattern);
-      }
-      if (op + 48 < op_limit) {
-        pattern = V128_Shuffle(pattern, reshuffle_mask);
-        V128_StoreU(reinterpret_cast<V128*>(op + 48), pattern);
-      }
-      return op_limit;
-    }
-    char* const op_end = buf_limit - 15;
-    if (SNAPPY_PREDICT_TRUE(op < op_end)) {
-      auto pattern_and_reshuffle_mask =
-          LoadPatternAndReshuffleMask(src, pattern_size);
-      V128 pattern = pattern_and_reshuffle_mask.first;
-      V128 reshuffle_mask = pattern_and_reshuffle_mask.second;
-
-      // This code path is relatively cold however so we save code size
-      // by avoiding unrolling and vectorizing.
-      //
-      // TODO: Remove pragma when when cold regions don't get
-      // vectorized or unrolled.
-#ifdef __clang__
-#pragma clang loop unroll(disable)
-#endif
-      do {
-        V128_StoreU(reinterpret_cast<V128*>(op), pattern);
-        pattern = V128_Shuffle(pattern, reshuffle_mask);
-        op += 16;
-      } while (SNAPPY_PREDICT_TRUE(op < op_end));
-    }
-    return IncrementalCopySlow(op - pattern_size, op, op_limit);
-#else   // !SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-    // If plenty of buffer space remains, expand the pattern to at least 8
-    // bytes. The way the following loop is written, we need 8 bytes of buffer
-    // space if pattern_size >= 4, 11 bytes if pattern_size is 1 or 3, and 10
-    // bytes if pattern_size is 2.  Precisely encoding that is probably not
-    // worthwhile; instead, invoke the slow path if we cannot write 11 bytes
-    // (because 11 are required in the worst case).
-    if (SNAPPY_PREDICT_TRUE(op <= buf_limit - 11)) {
-      while (pattern_size < 8) {
-        UnalignedCopy64(src, op);
-        op += pattern_size;
-        pattern_size *= 2;
-      }
-      if (SNAPPY_PREDICT_TRUE(op >= op_limit)) return op_limit;
-    } else {
-      return IncrementalCopySlow(src, op, op_limit);
-    }
-#endif  // SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
-  }
-  assert(pattern_size >= big_pattern_size_lower_bound);
-  constexpr bool use_16bytes_chunk = big_pattern_size_lower_bound == 16;
-
-  // Copy 1x 16 bytes (or 2x 8 bytes in non-SSE) at a time. Because op - src can
-  // be < 16 in non-SSE, a single UnalignedCopy128 might overwrite data in op.
-  // UnalignedCopy64 is safe because expanding the pattern to at least 8 bytes
-  // guarantees that op - src >= 8.
-  //
-  // Typically, the op_limit is the gating factor so try to simplify the loop
-  // based on that.
-  if (SNAPPY_PREDICT_TRUE(op_limit <= buf_limit - 15)) {
-    // There is at least one, and at most four 16-byte blocks. Writing four
-    // conditionals instead of a loop allows FDO to layout the code with respect
-    // to the actual probabilities of each length.
-    // TODO: Replace with loop with trip count hint.
-    ConditionalUnalignedCopy128<use_16bytes_chunk>(src, op);
-    if (op + 16 < op_limit) {
-      ConditionalUnalignedCopy128<use_16bytes_chunk>(src + 16, op + 16);
-    }
-    if (op + 32 < op_limit) {
-      ConditionalUnalignedCopy128<use_16bytes_chunk>(src + 32, op + 32);
-    }
-    if (op + 48 < op_limit) {
-      ConditionalUnalignedCopy128<use_16bytes_chunk>(src + 48, op + 48);
-    }
-    return op_limit;
-  }
-
-  // Fall back to doing as much as we can with the available slop in the
-  // buffer. This code path is relatively cold however so we save code size by
-  // avoiding unrolling and vectorizing.
-  //
-  // TODO: Remove pragma when when cold regions don't get vectorized
-  // or unrolled.
-#ifdef __clang__
-#pragma clang loop unroll(disable)
-#endif
-  for (char* op_end = buf_limit - 16; op < op_end; op += 16, src += 16) {
-    ConditionalUnalignedCopy128<use_16bytes_chunk>(src, op);
-  }
-  if (op >= op_limit) return op_limit;
-
-  // We only take this branch if we didn't have enough slop and we can do a
-  // single 8 byte copy.
-  if (SNAPPY_PREDICT_FALSE(op <= buf_limit - 8)) {
-    UnalignedCopy64(src, op);
-    src += 8;
-    op += 8;
-  }
-  return IncrementalCopySlow(src, op, op_limit);
-}
-
-}  // namespace
-
-template <bool allow_fast_path>
-static inline char* EmitLiteral(char* op, const char* literal, int len) {
-  // The vast majority of copies are below 16 bytes, for which a
-  // call to std::memcpy() is overkill. This fast path can sometimes
-  // copy up to 15 bytes too much, but that is okay in the
-  // main loop, since we have a bit to go on for both sides:
-  //
-  //   - The input will always have kInputMarginBytes = 15 extra
-  //     available bytes, as long as we're in the main loop, and
-  //     if not, allow_fast_path = false.
-  //   - The output will always have 32 spare bytes (see
-  //     MaxCompressedLength).
-  assert(len > 0);  // Zero-length literals are disallowed
-  int n = len - 1;
-  if (allow_fast_path && len <= 16) {
-    // Fits in tag byte
-    *op++ = LITERAL | (n << 2);
-
-    UnalignedCopy128(literal, op);
-    return op + len;
-  }
-
-  if (n < 60) {
-    // Fits in tag byte
-    *op++ = LITERAL | (n << 2);
-  } else {
-    int count = (Bits::Log2Floor(n) >> 3) + 1;
-    assert(count >= 1);
-    assert(count <= 4);
-    *op++ = LITERAL | ((59 + count) << 2);
-    // Encode in upcoming bytes.
-    // Write 4 bytes, though we may care about only 1 of them. The output buffer
-    // is guaranteed to have at least 3 more spaces left as 'len >= 61' holds
-    // here and there is a std::memcpy() of size 'len' below.
-    LittleEndian::Store32(op, n);
-    op += count;
-  }
-  // When allow_fast_path is true, we can overwrite up to 16 bytes.
-  if (allow_fast_path) {
-    char* destination = op;
-    const char* source = literal;
-    const char* end = destination + len;
-    do {
-      std::memcpy(destination, source, 16);
-      destination += 16;
-      source += 16;
-    } while (destination < end);
-  } else {
-    std::memcpy(op, literal, len);
-  }
-  return op + len;
-}
-
-template <bool len_less_than_12>
-static inline char* EmitCopyAtMost64(char* op, size_t offset, size_t len) {
-  assert(len <= 64);
-  assert(len >= 4);
-  assert(offset < 65536);
-  assert(len_less_than_12 == (len < 12));
-
-  if (len_less_than_12) {
-    uint32_t u = (len << 2) + (offset << 8);
-    uint32_t copy1 = COPY_1_BYTE_OFFSET - (4 << 2) + ((offset >> 3) & 0xe0);
-    uint32_t copy2 = COPY_2_BYTE_OFFSET - (1 << 2);
-    // It turns out that offset < 2048 is a difficult to predict branch.
-    // `perf record` shows this is the highest percentage of branch misses in
-    // benchmarks. This code produces branch free code, the data dependency
-    // chain that bottlenecks the throughput is so long that a few extra
-    // instructions are completely free (IPC << 6 because of data deps).
-    u += offset < 2048 ? copy1 : copy2;
-    LittleEndian::Store32(op, u);
-    op += offset < 2048 ? 2 : 3;
-  } else {
-    // Write 4 bytes, though we only care about 3 of them.  The output buffer
-    // is required to have some slack, so the extra byte won't overrun it.
-    uint32_t u = COPY_2_BYTE_OFFSET + ((len - 1) << 2) + (offset << 8);
-    LittleEndian::Store32(op, u);
-    op += 3;
-  }
-  return op;
-}
-
-template <bool len_less_than_12>
-static inline char* EmitCopy(char* op, size_t offset, size_t len) {
-  assert(len_less_than_12 == (len < 12));
-  if (len_less_than_12) {
-    return EmitCopyAtMost64</*len_less_than_12=*/true>(op, offset, len);
-  } else {
-    // A special case for len <= 64 might help, but so far measurements suggest
-    // it's in the noise.
-
-    // Emit 64 byte copies but make sure to keep at least four bytes reserved.
-    while (SNAPPY_PREDICT_FALSE(len >= 68)) {
-      op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, 64);
-      len -= 64;
-    }
-
-    // One or two copies will now finish the job.
-    if (len > 64) {
-      op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, 60);
-      len -= 60;
-    }
-
-    // Emit remainder.
-    if (len < 12) {
-      op = EmitCopyAtMost64</*len_less_than_12=*/true>(op, offset, len);
-    } else {
-      op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, len);
-    }
-    return op;
-  }
-}
-
-bool GetUncompressedLength(const char* start, size_t n, size_t* result) {
-  uint32_t v = 0;
-  const char* limit = start + n;
-  if (Varint::Parse32WithLimit(start, limit, &v) != NULL) {
-    *result = v;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-namespace {
-uint32_t CalculateTableSize(uint32_t input_size) {
-  static_assert(
-      kMaxHashTableSize >= kMinHashTableSize,
-      "kMaxHashTableSize should be greater or equal to kMinHashTableSize.");
-  if (input_size > kMaxHashTableSize) {
-    return kMaxHashTableSize;
-  }
-  if (input_size < kMinHashTableSize) {
-    return kMinHashTableSize;
-  }
-  // This is equivalent to Log2Ceiling(input_size), assuming input_size > 1.
-  // 2 << Log2Floor(x - 1) is equivalent to 1 << (1 + Log2Floor(x - 1)).
-  return 2u << Bits::Log2Floor(input_size - 1);
-}
-}  // namespace
-
-namespace internal {
-WorkingMemory::WorkingMemory(size_t input_size) {
-  const size_t max_fragment_size = std::min(input_size, kBlockSize);
-  const size_t table_size = CalculateTableSize(max_fragment_size);
-  size_ = table_size * sizeof(*table_) + max_fragment_size +
-          MaxCompressedLength(max_fragment_size);
-  mem_ = std::allocator<char>().allocate(size_);
-  table_ = reinterpret_cast<uint16_t*>(mem_);
-  input_ = mem_ + table_size * sizeof(*table_);
-  output_ = input_ + max_fragment_size;
-}
-
-WorkingMemory::~WorkingMemory() {
-  std::allocator<char>().deallocate(mem_, size_);
-}
-
-uint16_t* WorkingMemory::GetHashTable(size_t fragment_size,
-                                      int* table_size) const {
-  const size_t htsize = CalculateTableSize(fragment_size);
-  memset(table_, 0, htsize * sizeof(*table_));
-  *table_size = htsize;
-  return table_;
-}
-}  // end namespace internal
-
-// Flat array compression that does not emit the "uncompressed length"
-// prefix. Compresses "input" string to the "*op" buffer.
-//
-// REQUIRES: "input" is at most "kBlockSize" bytes long.
-// REQUIRES: "op" points to an array of memory that is at least
-// "MaxCompressedLength(input.size())" in size.
-// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-// REQUIRES: "table_size" is a power of two
-//
-// Returns an "end" pointer into "op" buffer.
-// "end - op" is the compressed size of "input".
-namespace internal {
-char* CompressFragment(const char* input, size_t input_size, char* op,
-                       uint16_t* table, const int table_size) {
-  // "ip" is the input pointer, and "op" is the output pointer.
-  const char* ip = input;
-  assert(input_size <= kBlockSize);
-  assert((table_size & (table_size - 1)) == 0);  // table must be power of two
-  const uint32_t mask = 2 * (table_size - 1);
-  const char* ip_end = input + input_size;
-  const char* base_ip = ip;
-
-  const size_t kInputMarginBytes = 15;
-  if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) {
-    const char* ip_limit = input + input_size - kInputMarginBytes;
-
-    for (uint32_t preload = LittleEndian::Load32(ip + 1);;) {
-      // Bytes in [next_emit, ip) will be emitted as literal bytes.  Or
-      // [next_emit, ip_end) after the main loop.
-      const char* next_emit = ip++;
-      uint64_t data = LittleEndian::Load64(ip);
-      // The body of this loop calls EmitLiteral once and then EmitCopy one or
-      // more times.  (The exception is that when we're close to exhausting
-      // the input we goto emit_remainder.)
-      //
-      // In the first iteration of this loop we're just starting, so
-      // there's nothing to copy, so calling EmitLiteral once is
-      // necessary.  And we only start a new iteration when the
-      // current iteration has determined that a call to EmitLiteral will
-      // precede the next call to EmitCopy (if any).
-      //
-      // Step 1: Scan forward in the input looking for a 4-byte-long match.
-      // If we get close to exhausting the input then goto emit_remainder.
-      //
-      // Heuristic match skipping: If 32 bytes are scanned with no matches
-      // found, start looking only at every other byte. If 32 more bytes are
-      // scanned (or skipped), look at every third byte, etc.. When a match is
-      // found, immediately go back to looking at every byte. This is a small
-      // loss (~5% performance, ~0.1% density) for compressible data due to more
-      // bookkeeping, but for non-compressible data (such as JPEG) it's a huge
-      // win since the compressor quickly "realizes" the data is incompressible
-      // and doesn't bother looking for matches everywhere.
-      //
-      // The "skip" variable keeps track of how many bytes there are since the
-      // last match; dividing it by 32 (ie. right-shifting by five) gives the
-      // number of bytes to move ahead for each iteration.
-      uint32_t skip = 32;
-
-      const char* candidate;
-      if (ip_limit - ip >= 16) {
-        auto delta = ip - base_ip;
-        for (int j = 0; j < 4; ++j) {
-          for (int k = 0; k < 4; ++k) {
-            int i = 4 * j + k;
-            // These for-loops are meant to be unrolled. So we can freely
-            // special case the first iteration to use the value already
-            // loaded in preload.
-            uint32_t dword = i == 0 ? preload : static_cast<uint32_t>(data);
-            assert(dword == LittleEndian::Load32(ip + i));
-            uint16_t* table_entry = TableEntry(table, dword, mask);
-            candidate = base_ip + *table_entry;
-            assert(candidate >= base_ip);
-            assert(candidate < ip + i);
-            *table_entry = delta + i;
-            if (SNAPPY_PREDICT_FALSE(LittleEndian::Load32(candidate) == dword)) {
-              *op = LITERAL | (i << 2);
-              UnalignedCopy128(next_emit, op + 1);
-              ip += i;
-              op = op + i + 2;
-              goto emit_match;
-            }
-            data >>= 8;
-          }
-          data = LittleEndian::Load64(ip + 4 * j + 4);
-        }
-        ip += 16;
-        skip += 16;
-      }
-      while (true) {
-        assert(static_cast<uint32_t>(data) == LittleEndian::Load32(ip));
-        uint16_t* table_entry = TableEntry(table, data, mask);
-        uint32_t bytes_between_hash_lookups = skip >> 5;
-        skip += bytes_between_hash_lookups;
-        const char* next_ip = ip + bytes_between_hash_lookups;
-        if (SNAPPY_PREDICT_FALSE(next_ip > ip_limit)) {
-          ip = next_emit;
-          goto emit_remainder;
-        }
-        candidate = base_ip + *table_entry;
-        assert(candidate >= base_ip);
-        assert(candidate < ip);
-
-        *table_entry = ip - base_ip;
-        if (SNAPPY_PREDICT_FALSE(static_cast<uint32_t>(data) ==
-                                LittleEndian::Load32(candidate))) {
-          break;
-        }
-        data = LittleEndian::Load32(next_ip);
-        ip = next_ip;
-      }
-
-      // Step 2: A 4-byte match has been found.  We'll later see if more
-      // than 4 bytes match.  But, prior to the match, input
-      // bytes [next_emit, ip) are unmatched.  Emit them as "literal bytes."
-      assert(next_emit + 16 <= ip_end);
-      op = EmitLiteral</*allow_fast_path=*/true>(op, next_emit, ip - next_emit);
-
-      // Step 3: Call EmitCopy, and then see if another EmitCopy could
-      // be our next move.  Repeat until we find no match for the
-      // input immediately after what was consumed by the last EmitCopy call.
-      //
-      // If we exit this loop normally then we need to call EmitLiteral next,
-      // though we don't yet know how big the literal will be.  We handle that
-      // by proceeding to the next iteration of the main loop.  We also can exit
-      // this loop via goto if we get close to exhausting the input.
-    emit_match:
-      do {
-        // We have a 4-byte match at ip, and no need to emit any
-        // "literal bytes" prior to ip.
-        const char* base = ip;
-        std::pair<size_t, bool> p =
-            FindMatchLength(candidate + 4, ip + 4, ip_end, &data);
-        size_t matched = 4 + p.first;
-        ip += matched;
-        size_t offset = base - candidate;
-        assert(0 == memcmp(base, candidate, matched));
-        if (p.second) {
-          op = EmitCopy</*len_less_than_12=*/true>(op, offset, matched);
-        } else {
-          op = EmitCopy</*len_less_than_12=*/false>(op, offset, matched);
-        }
-        if (SNAPPY_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        // Expect 5 bytes to match
-        assert((data & 0xFFFFFFFFFF) ==
-               (LittleEndian::Load64(ip) & 0xFFFFFFFFFF));
-        // We are now looking for a 4-byte match again.  We read
-        // table[Hash(ip, mask)] for that.  To improve compression,
-        // we also update table[Hash(ip - 1, mask)] and table[Hash(ip, mask)].
-        *TableEntry(table, LittleEndian::Load32(ip - 1), mask) =
-            ip - base_ip - 1;
-        uint16_t* table_entry = TableEntry(table, data, mask);
-        candidate = base_ip + *table_entry;
-        *table_entry = ip - base_ip;
-        // Measurements on the benchmarks have shown the following probabilities
-        // for the loop to exit (ie. avg. number of iterations is reciprocal).
-        // BM_Flat/6  txt1    p = 0.3-0.4
-        // BM_Flat/7  txt2    p = 0.35
-        // BM_Flat/8  txt3    p = 0.3-0.4
-        // BM_Flat/9  txt3    p = 0.34-0.4
-        // BM_Flat/10 pb      p = 0.4
-        // BM_Flat/11 gaviota p = 0.1
-        // BM_Flat/12 cp      p = 0.5
-        // BM_Flat/13 c       p = 0.3
-      } while (static_cast<uint32_t>(data) == LittleEndian::Load32(candidate));
-      // Because the least significant 5 bytes matched, we can utilize data
-      // for the next iteration.
-      preload = data >> 8;
-    }
-  }
-
-emit_remainder:
-  // Emit the remaining bytes as a literal
-  if (ip < ip_end) {
-    op = EmitLiteral</*allow_fast_path=*/false>(op, ip, ip_end - ip);
-  }
-
-  return op;
-}
-
-char* CompressFragmentDoubleHash(const char* input, size_t input_size, char* op,
-                                 uint16_t* table, const int table_size,
-                                 uint16_t* table2, const int table_size2) {
-  (void)table_size2;
-  assert(table_size == table_size2);
-  // "ip" is the input pointer, and "op" is the output pointer.
-  const char* ip = input;
-  assert(input_size <= kBlockSize);
-  assert((table_size & (table_size - 1)) == 0);  // table must be power of two
-  const uint32_t mask = 2 * (table_size - 1);
-  const char* ip_end = input + input_size;
-  const char* base_ip = ip;
-
-  const size_t kInputMarginBytes = 15;
-  if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) {
-    const char* ip_limit = input + input_size - kInputMarginBytes;
-
-    for (;;) {
-      const char* next_emit = ip++;
-      uint64_t data = LittleEndian::Load64(ip);
-      uint32_t skip = 512;
-
-      const char* candidate;
-      uint32_t candidate_length;
-      while (true) {
-        assert(static_cast<uint32_t>(data) == LittleEndian::Load32(ip));
-        uint16_t* table_entry2 = TableEntry8ByteMatch(table2, data, mask);
-        uint32_t bytes_between_hash_lookups = skip >> 9;
-        skip++;
-        const char* next_ip = ip + bytes_between_hash_lookups;
-        if (SNAPPY_PREDICT_FALSE(next_ip > ip_limit)) {
-          ip = next_emit;
-          goto emit_remainder;
-        }
-        candidate = base_ip + *table_entry2;
-        assert(candidate >= base_ip);
-        assert(candidate < ip);
-
-        *table_entry2 = ip - base_ip;
-        if (SNAPPY_PREDICT_FALSE(static_cast<uint32_t>(data) ==
-                                LittleEndian::Load32(candidate))) {
-          candidate_length =
-              FindMatchLengthPlain(candidate + 4, ip + 4, ip_end) + 4;
-          break;
-        }
-
-        uint16_t* table_entry = TableEntry4ByteMatch(table, data, mask);
-        candidate = base_ip + *table_entry;
-        assert(candidate >= base_ip);
-        assert(candidate < ip);
-
-        *table_entry = ip - base_ip;
-        if (SNAPPY_PREDICT_FALSE(static_cast<uint32_t>(data) ==
-                                LittleEndian::Load32(candidate))) {
-          candidate_length =
-              FindMatchLengthPlain(candidate + 4, ip + 4, ip_end) + 4;
-          table_entry2 =
-              TableEntry8ByteMatch(table2, LittleEndian::Load64(ip + 1), mask);
-          auto candidate2 = base_ip + *table_entry2;
-          size_t candidate_length2 =
-              FindMatchLengthPlain(candidate2, ip + 1, ip_end);
-          if (candidate_length2 > candidate_length) {
-            *table_entry2 = ip - base_ip;
-            candidate = candidate2;
-            candidate_length = candidate_length2;
-            ++ip;
-          }
-          break;
-        }
-        data = LittleEndian::Load64(next_ip);
-        ip = next_ip;
-      }
-      // Backtrack to the point it matches fully.
-      while (ip > next_emit && candidate > base_ip &&
-             *(ip - 1) == *(candidate - 1)) {
-        --ip;
-        --candidate;
-        ++candidate_length;
-      }
-      *TableEntry8ByteMatch(table2, LittleEndian::Load64(ip + 1), mask) =
-          ip - base_ip + 1;
-      *TableEntry8ByteMatch(table2, LittleEndian::Load64(ip + 2), mask) =
-          ip - base_ip + 2;
-      *TableEntry4ByteMatch(table, LittleEndian::Load32(ip + 1), mask) =
-          ip - base_ip + 1;
-      // Step 2: A 4-byte or 8-byte match has been found.
-      // We'll later see if more than 4 bytes match.  But, prior to the match,
-      // input bytes [next_emit, ip) are unmatched.  Emit them as
-      // "literal bytes."
-      assert(next_emit + 16 <= ip_end);
-      if (ip - next_emit > 0) {
-        op = EmitLiteral</*allow_fast_path=*/true>(op, next_emit,
-                                                   ip - next_emit);
-      }
-      // Step 3: Call EmitCopy, and then see if another EmitCopy could
-      // be our next move.  Repeat until we find no match for the
-      // input immediately after what was consumed by the last EmitCopy call.
-      //
-      // If we exit this loop normally then we need to call EmitLiteral next,
-      // though we don't yet know how big the literal will be.  We handle that
-      // by proceeding to the next iteration of the main loop.  We also can exit
-      // this loop via goto if we get close to exhausting the input.
-      do {
-        // We have a 4-byte match at ip, and no need to emit any
-        // "literal bytes" prior to ip.
-        const char* base = ip;
-        ip += candidate_length;
-        size_t offset = base - candidate;
-        if (candidate_length < 12) {
-          op =
-              EmitCopy</*len_less_than_12=*/true>(op, offset, candidate_length);
-        } else {
-          op = EmitCopy</*len_less_than_12=*/false>(op, offset,
-                                                    candidate_length);
-        }
-        if (SNAPPY_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        // We are now looking for a 4-byte match again.  We read
-        // table[Hash(ip, mask)] for that. To improve compression,
-        // we also update several previous table entries.
-        if (ip - base_ip > 7) {
-          *TableEntry8ByteMatch(table2, LittleEndian::Load64(ip - 7), mask) =
-              ip - base_ip - 7;
-          *TableEntry8ByteMatch(table2, LittleEndian::Load64(ip - 4), mask) =
-              ip - base_ip - 4;
-        }
-        *TableEntry8ByteMatch(table2, LittleEndian::Load64(ip - 3), mask) =
-            ip - base_ip - 3;
-        *TableEntry8ByteMatch(table2, LittleEndian::Load64(ip - 2), mask) =
-            ip - base_ip - 2;
-        *TableEntry4ByteMatch(table, LittleEndian::Load32(ip - 2), mask) =
-            ip - base_ip - 2;
-        *TableEntry4ByteMatch(table, LittleEndian::Load32(ip - 1), mask) =
-            ip - base_ip - 1;
-
-        uint16_t* table_entry =
-            TableEntry8ByteMatch(table2, LittleEndian::Load64(ip), mask);
-        candidate = base_ip + *table_entry;
-        *table_entry = ip - base_ip;
-        if (LittleEndian::Load32(ip) == LittleEndian::Load32(candidate)) {
-          candidate_length =
-              FindMatchLengthPlain(candidate + 4, ip + 4, ip_end) + 4;
-          continue;
-        }
-        table_entry =
-            TableEntry4ByteMatch(table, LittleEndian::Load32(ip), mask);
-        candidate = base_ip + *table_entry;
-        *table_entry = ip - base_ip;
-        if (LittleEndian::Load32(ip) == LittleEndian::Load32(candidate)) {
-          candidate_length =
-              FindMatchLengthPlain(candidate + 4, ip + 4, ip_end) + 4;
-          continue;
-        }
-        break;
-      } while (true);
-    }
-  }
-
-emit_remainder:
-  // Emit the remaining bytes as a literal
-  if (ip < ip_end) {
-    op = EmitLiteral</*allow_fast_path=*/false>(op, ip, ip_end - ip);
-  }
-
-  return op;
-}
-}  // end namespace internal
-
-static inline void Report(int token, const char *algorithm, size_t
-compressed_size, size_t uncompressed_size) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)token;
-  (void)algorithm;
-  (void)compressed_size;
-  (void)uncompressed_size;
-}
-
-// Signature of output types needed by decompression code.
-// The decompression code is templatized on a type that obeys this
-// signature so that we do not pay virtual function call overhead in
-// the middle of a tight decompression loop.
-//
-// class DecompressionWriter {
-//  public:
-//   // Called before decompression
-//   void SetExpectedLength(size_t length);
-//
-//   // For performance a writer may choose to donate the cursor variable to the
-//   // decompression function. The decompression will inject it in all its
-//   // function calls to the writer. Keeping the important output cursor as a
-//   // function local stack variable allows the compiler to keep it in
-//   // register, which greatly aids performance by avoiding loads and stores of
-//   // this variable in the fast path loop iterations.
-//   T GetOutputPtr() const;
-//
-//   // At end of decompression the loop donates the ownership of the cursor
-//   // variable back to the writer by calling this function.
-//   void SetOutputPtr(T op);
-//
-//   // Called after decompression
-//   bool CheckLength() const;
-//
-//   // Called repeatedly during decompression
-//   // Each function get a pointer to the op (output pointer), that the writer
-//   // can use and update. Note it's important that these functions get fully
-//   // inlined so that no actual address of the local variable needs to be
-//   // taken.
-//   bool Append(const char* ip, size_t length, T* op);
-//   bool AppendFromSelf(uint32_t offset, size_t length, T* op);
-//
-//   // The rules for how TryFastAppend differs from Append are somewhat
-//   // convoluted:
-//   //
-//   //  - TryFastAppend is allowed to decline (return false) at any
-//   //    time, for any reason -- just "return false" would be
-//   //    a perfectly legal implementation of TryFastAppend.
-//   //    The intention is for TryFastAppend to allow a fast path
-//   //    in the common case of a small append.
-//   //  - TryFastAppend is allowed to read up to <available> bytes
-//   //    from the input buffer, whereas Append is allowed to read
-//   //    <length>. However, if it returns true, it must leave
-//   //    at least five (kMaximumTagLength) bytes in the input buffer
-//   //    afterwards, so that there is always enough space to read the
-//   //    next tag without checking for a refill.
-//   //  - TryFastAppend must always return decline (return false)
-//   //    if <length> is 61 or more, as in this case the literal length is not
-//   //    decoded fully. In practice, this should not be a big problem,
-//   //    as it is unlikely that one would implement a fast path accepting
-//   //    this much data.
-//   //
-//   bool TryFastAppend(const char* ip, size_t available, size_t length, T* op);
-// };
-
-static inline uint32_t ExtractLowBytes(const uint32_t& v, int n) {
-  assert(n >= 0);
-  assert(n <= 4);
-#if SNAPPY_HAVE_BMI2
-  return _bzhi_u32(v, 8 * n);
-#else
-  // This needs to be wider than uint32_t otherwise `mask << 32` will be
-  // undefined.
-  uint64_t mask = 0xffffffff;
-  return v & ~(mask << (8 * n));
-#endif
-}
-
-static inline bool LeftShiftOverflows(uint8_t value, uint32_t shift) {
-  assert(shift < 32);
-  static const uint8_t masks[] = {
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
-      0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe};
-  return (value & masks[shift]) != 0;
-}
-
-inline bool Copy64BytesWithPatternExtension(ptrdiff_t dst, size_t offset) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)dst;
-  return offset != 0;
-}
-
-// Copies between size bytes and 64 bytes from src to dest.  size cannot exceed
-// 64.  More than size bytes, but never exceeding 64, might be copied if doing
-// so gives better performance.  [src, src + size) must not overlap with
-// [dst, dst + size), but [src, src + 64) may overlap with [dst, dst + 64).
-void MemCopy64(char* dst, const void* src, size_t size) {
-  // Always copy this many bytes.  If that's below size then copy the full 64.
-  constexpr int kShortMemCopy = 32;
-
-  assert(size <= 64);
-  assert(std::less_equal<const void*>()(static_cast<const char*>(src) + size,
-                                        dst) ||
-         std::less_equal<const void*>()(dst + size, src));
-
-  // We know that src and dst are at least size bytes apart. However, because we
-  // might copy more than size bytes the copy still might overlap past size.
-  // E.g. if src and dst appear consecutively in memory (src + size >= dst).
-  // TODO: Investigate wider copies on other platforms.
-#if defined(__x86_64__) && defined(__AVX__)
-  assert(kShortMemCopy <= 32);
-  __m256i data = _mm256_lddqu_si256(static_cast<const __m256i *>(src));
-  _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst), data);
-  // Profiling shows that nearly all copies are short.
-  if (SNAPPY_PREDICT_FALSE(size > kShortMemCopy)) {
-    data = _mm256_lddqu_si256(static_cast<const __m256i *>(src) + 1);
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst) + 1, data);
-  }
-#else
-  std::memmove(dst, src, kShortMemCopy);
-  // Profiling shows that nearly all copies are short.
-  if (SNAPPY_PREDICT_FALSE(size > kShortMemCopy)) {
-    std::memmove(dst + kShortMemCopy,
-                 static_cast<const uint8_t*>(src) + kShortMemCopy,
-                 64 - kShortMemCopy);
-  }
-#endif
-}
-
-void MemCopy64(ptrdiff_t dst, const void* src, size_t size) {
-  // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-  (void)dst;
-  (void)src;
-  (void)size;
-}
-
-void ClearDeferred(const void** deferred_src, size_t* deferred_length,
-                   uint8_t* safe_source) {
-  *deferred_src = safe_source;
-  *deferred_length = 0;
-}
-
-void DeferMemCopy(const void** deferred_src, size_t* deferred_length,
-                  const void* src, size_t length) {
-  *deferred_src = src;
-  *deferred_length = length;
-}
-
-SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-inline size_t AdvanceToNextTagARMOptimized(const uint8_t** ip_p, size_t* tag) {
-  const uint8_t*& ip = *ip_p;
-  // This section is crucial for the throughput of the decompression loop.
-  // The latency of an iteration is fundamentally constrained by the
-  // following data chain on ip.
-  // ip -> c = Load(ip) -> delta1 = (c & 3)        -> ip += delta1 or delta2
-  //                       delta2 = ((c >> 2) + 1)    ip++
-  // This is different from X86 optimizations because ARM has conditional add
-  // instruction (csinc) and it removes several register moves.
-  const size_t tag_type = *tag & 3;
-  const bool is_literal = (tag_type == 0);
-  if (is_literal) {
-    size_t next_literal_tag = (*tag >> 2) + 1;
-    *tag = ip[next_literal_tag];
-    ip += next_literal_tag + 1;
-  } else {
-    *tag = ip[tag_type];
-    ip += tag_type + 1;
-  }
-  return tag_type;
-}
-
-SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-inline size_t AdvanceToNextTagX86Optimized(const uint8_t** ip_p, size_t* tag) {
-  const uint8_t*& ip = *ip_p;
-  // This section is crucial for the throughput of the decompression loop.
-  // The latency of an iteration is fundamentally constrained by the
-  // following data chain on ip.
-  // ip -> c = Load(ip) -> ip1 = ip + 1 + (c & 3) -> ip = ip1 or ip2
-  //                       ip2 = ip + 2 + (c >> 2)
-  // This amounts to 8 cycles.
-  // 5 (load) + 1 (c & 3) + 1 (lea ip1, [ip + (c & 3) + 1]) + 1 (cmov)
-  size_t literal_len = *tag >> 2;
-  size_t tag_type = *tag;
-  bool is_literal;
-#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__)
-  // TODO clang misses the fact that the (c & 3) already correctly
-  // sets the zero flag.
-  asm("and $3, %k[tag_type]\n\t"
-      : [tag_type] "+r"(tag_type), "=@ccz"(is_literal)
-      :: "cc");
-#else
-  tag_type &= 3;
-  is_literal = (tag_type == 0);
-#endif
-  // TODO
-  // This is code is subtle. Loading the values first and then cmov has less
-  // latency then cmov ip and then load. However clang would move the loads
-  // in an optimization phase, volatile prevents this transformation.
-  // Note that we have enough slop bytes (64) that the loads are always valid.
-  size_t tag_literal =
-      static_cast<const volatile uint8_t*>(ip)[1 + literal_len];
-  size_t tag_copy = static_cast<const volatile uint8_t*>(ip)[tag_type];
-  *tag = is_literal ? tag_literal : tag_copy;
-  const uint8_t* ip_copy = ip + 1 + tag_type;
-  const uint8_t* ip_literal = ip + 2 + literal_len;
-  ip = is_literal ? ip_literal : ip_copy;
-#if defined(__GNUC__) && defined(__x86_64__)
-  // TODO Clang is "optimizing" zero-extension (a totally free
-  // operation) this means that after the cmov of tag, it emits another movzb
-  // tag, byte(tag). It really matters as it's on the core chain. This dummy
-  // asm, persuades clang to do the zero-extension at the load (it's automatic)
-  // removing the expensive movzb.
-  asm("" ::"r"(tag_copy));
-#endif
-  return tag_type;
-}
-
-// Extract the offset for copy-1 and copy-2 returns 0 for literals or copy-4.
-inline uint32_t ExtractOffset(uint32_t val, size_t tag_type) {
-  // For x86 non-static storage works better. For ARM static storage is better.
-  // TODO: Once the array is recognized as a register, improve the
-  // readability for x86.
-#if defined(__x86_64__)
-  constexpr uint64_t kExtractMasksCombined = 0x0000FFFF00FF0000ull;
-  uint16_t result;
-  memcpy(&result,
-         reinterpret_cast<const char*>(&kExtractMasksCombined) + 2 * tag_type,
-         sizeof(result));
-  return val & result;
-#elif defined(__aarch64__)
-  constexpr uint64_t kExtractMasksCombined = 0x0000FFFF00FF0000ull;
-  return val & static_cast<uint32_t>(
-      (kExtractMasksCombined >> (tag_type * 16)) & 0xFFFF);
-#else
-  static constexpr uint32_t kExtractMasks[4] = {0, 0xFF, 0xFFFF, 0};
-  return val & kExtractMasks[tag_type];
-#endif
-};
-
-// Core decompression loop, when there is enough data available.
-// Decompresses the input buffer [ip, ip_limit) into the output buffer
-// [op, op_limit_min_slop). Returning when either we are too close to the end
-// of the input buffer, or we exceed op_limit_min_slop or when a exceptional
-// tag is encountered (literal of length > 60) or a copy-4.
-// Returns {ip, op} at the points it stopped decoding.
-// TODO This function probably does not need to be inlined, as it
-// should decode large chunks at a time. This allows runtime dispatch to
-// implementations based on CPU capability (BMI2 / perhaps 32 / 64 byte memcpy).
-template <typename T>
-std::pair<const uint8_t*, ptrdiff_t> DecompressBranchless(
-    const uint8_t* ip, const uint8_t* ip_limit, ptrdiff_t op, T op_base,
-    ptrdiff_t op_limit_min_slop) {
-  // If deferred_src is invalid point it here.
-  uint8_t safe_source[64];
-  const void* deferred_src;
-  size_t deferred_length;
-  ClearDeferred(&deferred_src, &deferred_length, safe_source);
-
-  // We unroll the inner loop twice so we need twice the spare room.
-  op_limit_min_slop -= kSlopBytes;
-  if (2 * (kSlopBytes + 1) < ip_limit - ip && op < op_limit_min_slop) {
-    const uint8_t* const ip_limit_min_slop = ip_limit - 2 * kSlopBytes - 1;
-    ip++;
-    // ip points just past the tag and we are touching at maximum kSlopBytes
-    // in an iteration.
-    size_t tag = ip[-1];
-#if defined(__clang__) && defined(__aarch64__)
-    // Workaround for https://bugs.llvm.org/show_bug.cgi?id=51317
-    // when loading 1 byte, clang for aarch64 doesn't realize that it(ldrb)
-    // comes with free zero-extension, so clang generates another
-    // 'and xn, xm, 0xff' before it use that as the offset. This 'and' is
-    // redundant and can be removed by adding this dummy asm, which gives
-    // clang a hint that we're doing the zero-extension at the load.
-    asm("" ::"r"(tag));
-#endif
-    do {
-      // The throughput is limited by instructions, unrolling the inner loop
-      // twice reduces the amount of instructions checking limits and also
-      // leads to reduced mov's.
-
-      SNAPPY_PREFETCH(ip + 128);
-      for (int i = 0; i < 2; i++) {
-        const uint8_t* old_ip = ip;
-        assert(tag == ip[-1]);
-        // For literals tag_type = 0, hence we will always obtain 0 from
-        // ExtractLowBytes. For literals offset will thus be kLiteralOffset.
-        ptrdiff_t len_minus_offset = kLengthMinusOffset[tag];
-        uint32_t next;
-#if defined(__aarch64__)
-        size_t tag_type = AdvanceToNextTagARMOptimized(&ip, &tag);
-        // We never need more than 16 bits. Doing a Load16 allows the compiler
-        // to elide the masking operation in ExtractOffset.
-        next = LittleEndian::Load16(old_ip);
-#else
-        size_t tag_type = AdvanceToNextTagX86Optimized(&ip, &tag);
-        next = LittleEndian::Load32(old_ip);
-#endif
-        size_t len = len_minus_offset & 0xFF;
-        ptrdiff_t extracted = ExtractOffset(next, tag_type);
-        ptrdiff_t len_min_offset = len_minus_offset - extracted;
-        if (SNAPPY_PREDICT_FALSE(len_minus_offset > extracted)) {
-          if (SNAPPY_PREDICT_FALSE(len & 0x80)) {
-            // Exceptional case (long literal or copy 4).
-            // Actually doing the copy here is negatively impacting the main
-            // loop due to compiler incorrectly allocating a register for
-            // this fallback. Hence we just break.
-          break_loop:
-            ip = old_ip;
-            goto exit;
-          }
-          // Only copy-1 or copy-2 tags can get here.
-          assert(tag_type == 1 || tag_type == 2);
-          std::ptrdiff_t delta = (op + deferred_length) + len_min_offset - len;
-          // Guard against copies before the buffer start.
-          // Execute any deferred MemCopy since we write to dst here.
-          MemCopy64(op_base + op, deferred_src, deferred_length);
-          op += deferred_length;
-          ClearDeferred(&deferred_src, &deferred_length, safe_source);
-          if (SNAPPY_PREDICT_FALSE(delta < 0 ||
-                                  !Copy64BytesWithPatternExtension(
-                                      op_base + op, len - len_min_offset))) {
-            goto break_loop;
-          }
-          // We aren't deferring this copy so add length right away.
-          op += len;
-          continue;
-        }
-        std::ptrdiff_t delta = (op + deferred_length) + len_min_offset - len;
-        if (SNAPPY_PREDICT_FALSE(delta < 0)) {
-          // Due to the spurious offset in literals have this will trigger
-          // at the start of a block when op is still smaller than 256.
-          if (tag_type != 0) goto break_loop;
-          MemCopy64(op_base + op, deferred_src, deferred_length);
-          op += deferred_length;
-          DeferMemCopy(&deferred_src, &deferred_length, old_ip, len);
-          continue;
-        }
-
-        // For copies we need to copy from op_base + delta, for literals
-        // we need to copy from ip instead of from the stream.
-        const void* from =
-            tag_type ? reinterpret_cast<void*>(op_base + delta) : old_ip;
-        MemCopy64(op_base + op, deferred_src, deferred_length);
-        op += deferred_length;
-        DeferMemCopy(&deferred_src, &deferred_length, from, len);
-      }
-    } while (ip < ip_limit_min_slop &&
-             static_cast<ptrdiff_t>(op + deferred_length) < op_limit_min_slop);
-  exit:
-    ip--;
-    assert(ip <= ip_limit);
-  }
-  // If we deferred a copy then we can perform.  If we are up to date then we
-  // might not have enough slop bytes and could run past the end.
-  if (deferred_length) {
-    MemCopy64(op_base + op, deferred_src, deferred_length);
-    op += deferred_length;
-    ClearDeferred(&deferred_src, &deferred_length, safe_source);
-  }
-  return {ip, op};
-}
-
-// Helper class for decompression
-class SnappyDecompressor {
- private:
-  Source* reader_;        // Underlying source of bytes to decompress
-  const char* ip_;        // Points to next buffered byte
-  const char* ip_limit_;  // Points just past buffered bytes
-  // If ip < ip_limit_min_maxtaglen_ it's safe to read kMaxTagLength from
-  // buffer.
-  const char* ip_limit_min_maxtaglen_;
-  uint32_t peeked_;                  // Bytes peeked from reader (need to skip)
-  bool eof_;                         // Hit end of input without an error?
-  char scratch_[kMaximumTagLength];  // See RefillTag().
-
-  // Ensure that all of the tag metadata for the next tag is available
-  // in [ip_..ip_limit_-1].  Also ensures that [ip,ip+4] is readable even
-  // if (ip_limit_ - ip_ < 5).
-  //
-  // Returns true on success, false on error or end of input.
-  bool RefillTag();
-
-  void ResetLimit(const char* ip) {
-    ip_limit_min_maxtaglen_ =
-        ip_limit_ - std::min<ptrdiff_t>(ip_limit_ - ip, kMaximumTagLength - 1);
-  }
-
- public:
-  explicit SnappyDecompressor(Source* reader)
-      : reader_(reader), ip_(NULL), ip_limit_(NULL), peeked_(0), eof_(false) {}
-
-  ~SnappyDecompressor() {
-    // Advance past any bytes we peeked at from the reader
-    reader_->Skip(peeked_);
-  }
-
-  // Returns true iff we have hit the end of the input without an error.
-  bool eof() const { return eof_; }
-
-  // Read the uncompressed length stored at the start of the compressed data.
-  // On success, stores the length in *result and returns true.
-  // On failure, returns false.
-  bool ReadUncompressedLength(uint32_t* result) {
-    assert(ip_ == NULL);  // Must not have read anything yet
-    // Length is encoded in 1..5 bytes
-    *result = 0;
-    uint32_t shift = 0;
-    while (true) {
-      if (shift >= 32) return false;
-      size_t n;
-      const char* ip = reader_->Peek(&n);
-      if (n == 0) return false;
-      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip));
-      reader_->Skip(1);
-      uint32_t val = c & 0x7f;
-      if (LeftShiftOverflows(static_cast<uint8_t>(val), shift)) return false;
-      *result |= val << shift;
-      if (c < 128) {
-        break;
-      }
-      shift += 7;
-    }
-    return true;
-  }
-
-  // Process the next item found in the input.
-  // Returns true if successful, false on error or end of input.
-  template <class Writer>
-#if defined(__GNUC__) && defined(__x86_64__)
-  __attribute__((aligned(32)))
-#endif
-  void
-  DecompressAllTags(Writer* writer) {
-    const char* ip = ip_;
-    ResetLimit(ip);
-    auto op = writer->GetOutputPtr();
-    // We could have put this refill fragment only at the beginning of the loop.
-    // However, duplicating it at the end of each branch gives the compiler more
-    // scope to optimize the <ip_limit_ - ip> expression based on the local
-    // context, which overall increases speed.
-#define MAYBE_REFILL()                                      \
-  if (SNAPPY_PREDICT_FALSE(ip >= ip_limit_min_maxtaglen_)) { \
-    ip_ = ip;                                               \
-    if (SNAPPY_PREDICT_FALSE(!RefillTag())) goto exit;       \
-    ip = ip_;                                               \
-    ResetLimit(ip);                                         \
-  }                                                         \
-  preload = static_cast<uint8_t>(*ip)
-
-    // At the start of the for loop below the least significant byte of preload
-    // contains the tag.
-    uint32_t preload;
-    MAYBE_REFILL();
-    for (;;) {
-      {
-        ptrdiff_t op_limit_min_slop;
-        auto op_base = writer->GetBase(&op_limit_min_slop);
-        if (op_base) {
-          auto res =
-              DecompressBranchless(reinterpret_cast<const uint8_t*>(ip),
-                                   reinterpret_cast<const uint8_t*>(ip_limit_),
-                                   op - op_base, op_base, op_limit_min_slop);
-          ip = reinterpret_cast<const char*>(res.first);
-          op = op_base + res.second;
-          MAYBE_REFILL();
-        }
-      }
-      const uint8_t c = static_cast<uint8_t>(preload);
-      ip++;
-
-      // Ratio of iterations that have LITERAL vs non-LITERAL for different
-      // inputs.
-      //
-      // input          LITERAL  NON_LITERAL
-      // -----------------------------------
-      // html|html4|cp   23%        77%
-      // urls            36%        64%
-      // jpg             47%        53%
-      // pdf             19%        81%
-      // txt[1-4]        25%        75%
-      // pb              24%        76%
-      // bin             24%        76%
-      if (SNAPPY_PREDICT_FALSE((c & 0x3) == LITERAL)) {
-        size_t literal_length = (c >> 2) + 1u;
-        if (writer->TryFastAppend(ip, ip_limit_ - ip, literal_length, &op)) {
-          assert(literal_length < 61);
-          ip += literal_length;
-          // NOTE: There is no MAYBE_REFILL() here, as TryFastAppend()
-          // will not return true unless there's already at least five spare
-          // bytes in addition to the literal.
-          preload = static_cast<uint8_t>(*ip);
-          continue;
-        }
-        if (SNAPPY_PREDICT_FALSE(literal_length >= 61)) {
-          // Long literal.
-          const size_t literal_length_length = literal_length - 60;
-          literal_length =
-              ExtractLowBytes(LittleEndian::Load32(ip), literal_length_length) +
-              1;
-          ip += literal_length_length;
-        }
-
-        size_t avail = ip_limit_ - ip;
-        while (avail < literal_length) {
-          if (!writer->Append(ip, avail, &op)) goto exit;
-          literal_length -= avail;
-          reader_->Skip(peeked_);
-          size_t n;
-          ip = reader_->Peek(&n);
-          avail = n;
-          peeked_ = avail;
-          if (avail == 0) goto exit;
-          ip_limit_ = ip + avail;
-          ResetLimit(ip);
-        }
-        if (!writer->Append(ip, literal_length, &op)) goto exit;
-        ip += literal_length;
-        MAYBE_REFILL();
-      } else {
-        if (SNAPPY_PREDICT_FALSE((c & 3) == COPY_4_BYTE_OFFSET)) {
-          const size_t copy_offset = LittleEndian::Load32(ip);
-          const size_t length = (c >> 2) + 1;
-          ip += 4;
-
-          if (!writer->AppendFromSelf(copy_offset, length, &op)) goto exit;
-        } else {
-          const ptrdiff_t entry = kLengthMinusOffset[c];
-          preload = LittleEndian::Load32(ip);
-          const uint32_t trailer = ExtractLowBytes(preload, c & 3);
-          const uint32_t length = entry & 0xff;
-          assert(length > 0);
-
-          // copy_offset/256 is encoded in bits 8..10.  By just fetching
-          // those bits, we get copy_offset (since the bit-field starts at
-          // bit 8).
-          const uint32_t copy_offset = trailer - entry + length;
-          if (!writer->AppendFromSelf(copy_offset, length, &op)) goto exit;
-
-          ip += (c & 3);
-          // By using the result of the previous load we reduce the critical
-          // dependency chain of ip to 4 cycles.
-          preload >>= (c & 3) * 8;
-          if (ip < ip_limit_min_maxtaglen_) continue;
-        }
-        MAYBE_REFILL();
-      }
-    }
-#undef MAYBE_REFILL
-  exit:
-    writer->SetOutputPtr(op);
-  }
-};
-
-constexpr uint32_t CalculateNeeded(uint8_t tag) {
-  return ((tag & 3) == 0 && tag >= (60 * 4))
-             ? (tag >> 2) - 58
-             : (0x05030201 >> ((tag * 8) & 31)) & 0xFF;
-}
-
-#if __cplusplus >= 201402L
-constexpr bool VerifyCalculateNeeded() {
-  for (int i = 0; i < 1; i++) {
-    if (CalculateNeeded(i) != (char_table[i] >> 11) + 1) return false;
-  }
-  return true;
-}
-
-// Make sure CalculateNeeded is correct by verifying it against the established
-// table encoding the number of added bytes needed.
-static_assert(VerifyCalculateNeeded(), "");
-#endif  // c++14
-
-bool SnappyDecompressor::RefillTag() {
-  const char* ip = ip_;
-  if (ip == ip_limit_) {
-    // Fetch a new fragment from the reader
-    reader_->Skip(peeked_);  // All peeked bytes are used up
-    size_t n;
-    ip = reader_->Peek(&n);
-    peeked_ = n;
-    eof_ = (n == 0);
-    if (eof_) return false;
-    ip_limit_ = ip + n;
-  }
-
-  // Read the tag character
-  assert(ip < ip_limit_);
-  const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip));
-  // At this point make sure that the data for the next tag is consecutive.
-  // For copy 1 this means the next 2 bytes (tag and 1 byte offset)
-  // For copy 2 the next 3 bytes (tag and 2 byte offset)
-  // For copy 4 the next 5 bytes (tag and 4 byte offset)
-  // For all small literals we only need 1 byte buf for literals 60...63 the
-  // length is encoded in 1...4 extra bytes.
-  const uint32_t needed = CalculateNeeded(c);
-  assert(needed <= sizeof(scratch_));
-
-  // Read more bytes from reader if needed
-  uint32_t nbuf = ip_limit_ - ip;
-  if (nbuf < needed) {
-    // Stitch together bytes from ip and reader to form the word
-    // contents.  We store the needed bytes in "scratch_".  They
-    // will be consumed immediately by the caller since we do not
-    // read more than we need.
-    std::memmove(scratch_, ip, nbuf);
-    reader_->Skip(peeked_);  // All peeked bytes are used up
-    peeked_ = 0;
-    while (nbuf < needed) {
-      size_t length;
-      const char* src = reader_->Peek(&length);
-      if (length == 0) return false;
-      uint32_t to_add = std::min<uint32_t>(needed - nbuf, length);
-      std::memcpy(scratch_ + nbuf, src, to_add);
-      nbuf += to_add;
-      reader_->Skip(to_add);
-    }
-    assert(nbuf == needed);
-    ip_ = scratch_;
-    ip_limit_ = scratch_ + needed;
-  } else if (nbuf < kMaximumTagLength) {
-    // Have enough bytes, but move into scratch_ so that we do not
-    // read past end of input
-    std::memmove(scratch_, ip, nbuf);
-    reader_->Skip(peeked_);  // All peeked bytes are used up
-    peeked_ = 0;
-    ip_ = scratch_;
-    ip_limit_ = scratch_ + nbuf;
-  } else {
-    // Pass pointer to buffer returned by reader_.
-    ip_ = ip;
-  }
-  return true;
-}
-
-template <typename Writer>
-static bool InternalUncompress(Source* r, Writer* writer) {
-  // Read the uncompressed length from the front of the compressed input
-  SnappyDecompressor decompressor(r);
-  uint32_t uncompressed_len = 0;
-  if (!decompressor.ReadUncompressedLength(&uncompressed_len)) return false;
-
-  return InternalUncompressAllTags(&decompressor, writer, r->Available(),
-                                   uncompressed_len);
-}
-
-template <typename Writer>
-static bool InternalUncompressAllTags(SnappyDecompressor* decompressor,
-                                      Writer* writer, uint32_t compressed_len,
-                                      uint32_t uncompressed_len) {
-    int token = 0;
-  Report(token, "snappy_uncompress", compressed_len, uncompressed_len);
-
-  writer->SetExpectedLength(uncompressed_len);
-
-  // Process the entire input
-  decompressor->DecompressAllTags(writer);
-  writer->Flush();
-  return (decompressor->eof() && writer->CheckLength());
-}
-
-bool GetUncompressedLength(Source* source, uint32_t* result) {
-  SnappyDecompressor decompressor(source);
-  return decompressor.ReadUncompressedLength(result);
-}
-
-size_t Compress(Source* reader, Sink* writer) {
-  return Compress(reader, writer, CompressionOptions{});
-}
-
-size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
-  assert(options.level == 1 || options.level == 2);
-  int token = 0;
-  size_t written = 0;
-  size_t N = reader->Available();
-  const size_t uncompressed_size = N;
-  char ulength[Varint::kMax32];
-  char* p = Varint::Encode32(ulength, N);
-  writer->Append(ulength, p - ulength);
-  written += (p - ulength);
-
-  internal::WorkingMemory wmem(N);
-
-  while (N > 0) {
-    // Get next block to compress (without copying if possible)
-    size_t fragment_size;
-    const char* fragment = reader->Peek(&fragment_size);
-    assert(fragment_size != 0);  // premature end of input
-    const size_t num_to_read = std::min(N, kBlockSize);
-    size_t bytes_read = fragment_size;
-
-    size_t pending_advance = 0;
-    if (bytes_read >= num_to_read) {
-      // Buffer returned by reader is large enough
-      pending_advance = num_to_read;
-      fragment_size = num_to_read;
-    } else {
-      char* scratch = wmem.GetScratchInput();
-      std::memcpy(scratch, fragment, bytes_read);
-      reader->Skip(bytes_read);
-
-      while (bytes_read < num_to_read) {
-        fragment = reader->Peek(&fragment_size);
-        size_t n = std::min<size_t>(fragment_size, num_to_read - bytes_read);
-        std::memcpy(scratch + bytes_read, fragment, n);
-        bytes_read += n;
-        reader->Skip(n);
-      }
-      assert(bytes_read == num_to_read);
-      fragment = scratch;
-      fragment_size = num_to_read;
-    }
-    assert(fragment_size == num_to_read);
-
-    // Get encoding table for compression
-    int table_size;
-    uint16_t* table = wmem.GetHashTable(num_to_read, &table_size);
-
-    // Compress input_fragment and append to dest
-    int max_output = MaxCompressedLength(num_to_read);
-
-    // Since we encode kBlockSize regions followed by a region
-    // which is <= kBlockSize in length, a previously allocated
-    // scratch_output[] region is big enough for this iteration.
-    // Need a scratch buffer for the output, in case the byte sink doesn't
-    // have room for us directly.
-    char* dest = writer->GetAppendBuffer(max_output, wmem.GetScratchOutput());
-    char* end = nullptr;
-    if (options.level == 1) {
-      end = internal::CompressFragment(fragment, fragment_size, dest, table,
-                                       table_size);
-    } else if (options.level == 2) {
-      end = internal::CompressFragmentDoubleHash(
-          fragment, fragment_size, dest, table, table_size >> 1,
-          table + (table_size >> 1), table_size >> 1);
-    }
-    writer->Append(dest, end - dest);
-    written += (end - dest);
-
-    N -= num_to_read;
-    reader->Skip(pending_advance);
-  }
-
-  Report(token, "snappy_compress", written, uncompressed_size);
-  return written;
-}
-
-// -----------------------------------------------------------------------
-// IOVec interfaces
-// -----------------------------------------------------------------------
-
-// A `Source` implementation that yields the contents of an `iovec` array. Note
-// that `total_size` is the total number of bytes to be read from the elements
-// of `iov` (_not_ the total number of elements in `iov`).
-class SnappyIOVecReader : public Source {
- public:
-  SnappyIOVecReader(const struct iovec* iov, size_t total_size)
-      : curr_iov_(iov),
-        curr_pos_(total_size > 0 ? reinterpret_cast<const char*>(iov->iov_base)
-                                 : nullptr),
-        curr_size_remaining_(total_size > 0 ? iov->iov_len : 0),
-        total_size_remaining_(total_size) {
-    // Skip empty leading `iovec`s.
-    if (total_size > 0 && curr_size_remaining_ == 0) Advance();
-  }
-
-  ~SnappyIOVecReader() override = default;
-
-  size_t Available() const override { return total_size_remaining_; }
-
-  const char* Peek(size_t* len) override {
-    *len = curr_size_remaining_;
-    return curr_pos_;
-  }
-
-  void Skip(size_t n) override {
-    while (n >= curr_size_remaining_ && n > 0) {
-      n -= curr_size_remaining_;
-      Advance();
-    }
-    curr_size_remaining_ -= n;
-    total_size_remaining_ -= n;
-    curr_pos_ += n;
-  }
-
- private:
-  // Advances to the next nonempty `iovec` and updates related variables.
-  void Advance() {
-    do {
-      assert(total_size_remaining_ >= curr_size_remaining_);
-      total_size_remaining_ -= curr_size_remaining_;
-      if (total_size_remaining_ == 0) {
-        curr_pos_ = nullptr;
-        curr_size_remaining_ = 0;
-        return;
-      }
-      ++curr_iov_;
-      curr_pos_ = reinterpret_cast<const char*>(curr_iov_->iov_base);
-      curr_size_remaining_ = curr_iov_->iov_len;
-    } while (curr_size_remaining_ == 0);
-  }
-
-  // The `iovec` currently being read.
-  const struct iovec* curr_iov_;
-  // The location in `curr_iov_` currently being read.
-  const char* curr_pos_;
-  // The amount of unread data in `curr_iov_`.
-  size_t curr_size_remaining_;
-  // The amount of unread data in the entire input array.
-  size_t total_size_remaining_;
-};
-
-// A type that writes to an iovec.
-// Note that this is not a "ByteSink", but a type that matches the
-// Writer template argument to SnappyDecompressor::DecompressAllTags().
-class SnappyIOVecWriter {
- private:
-  // output_iov_end_ is set to iov + count and used to determine when
-  // the end of the iovs is reached.
-  const struct iovec* output_iov_end_;
-
-#if !defined(NDEBUG)
-  const struct iovec* output_iov_;
-#endif  // !defined(NDEBUG)
-
-  // Current iov that is being written into.
-  const struct iovec* curr_iov_;
-
-  // Pointer to current iov's write location.
-  char* curr_iov_output_;
-
-  // Remaining bytes to write into curr_iov_output.
-  size_t curr_iov_remaining_;
-
-  // Total bytes decompressed into output_iov_ so far.
-  size_t total_written_;
-
-  // Maximum number of bytes that will be decompressed into output_iov_.
-  size_t output_limit_;
-
-  static inline char* GetIOVecPointer(const struct iovec* iov, size_t offset) {
-    return reinterpret_cast<char*>(iov->iov_base) + offset;
-  }
-
- public:
-  // Does not take ownership of iov. iov must be valid during the
-  // entire lifetime of the SnappyIOVecWriter.
-  inline SnappyIOVecWriter(const struct iovec* iov, size_t iov_count)
-      : output_iov_end_(iov + iov_count),
-#if !defined(NDEBUG)
-        output_iov_(iov),
-#endif  // !defined(NDEBUG)
-        curr_iov_(iov),
-        curr_iov_output_(iov_count ? reinterpret_cast<char*>(iov->iov_base)
-                                   : nullptr),
-        curr_iov_remaining_(iov_count ? iov->iov_len : 0),
-        total_written_(0),
-        output_limit_(-1) {
-  }
-
-  inline void SetExpectedLength(size_t len) { output_limit_ = len; }
-
-  inline bool CheckLength() const { return total_written_ == output_limit_; }
-
-  inline bool Append(const char* ip, size_t len, char**) {
-    if (total_written_ + len > output_limit_) {
-      return false;
-    }
-
-    return AppendNoCheck(ip, len);
-  }
-
-  char* GetOutputPtr() { return nullptr; }
-  char* GetBase(ptrdiff_t*) { return nullptr; }
-  void SetOutputPtr(char* op) {
-    // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-    (void)op;
-  }
-
-  inline bool AppendNoCheck(const char* ip, size_t len) {
-    while (len > 0) {
-      if (curr_iov_remaining_ == 0) {
-        // This iovec is full. Go to the next one.
-        if (curr_iov_ + 1 >= output_iov_end_) {
-          return false;
-        }
-        ++curr_iov_;
-        curr_iov_output_ = reinterpret_cast<char*>(curr_iov_->iov_base);
-        curr_iov_remaining_ = curr_iov_->iov_len;
-      }
-
-      const size_t to_write = std::min(len, curr_iov_remaining_);
-      std::memcpy(curr_iov_output_, ip, to_write);
-      curr_iov_output_ += to_write;
-      curr_iov_remaining_ -= to_write;
-      total_written_ += to_write;
-      ip += to_write;
-      len -= to_write;
-    }
-
-    return true;
-  }
-
-  inline bool TryFastAppend(const char* ip, size_t available, size_t len,
-                            char**) {
-    const size_t space_left = output_limit_ - total_written_;
-    if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16 &&
-        curr_iov_remaining_ >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations.
-      UnalignedCopy128(ip, curr_iov_output_);
-      curr_iov_output_ += len;
-      curr_iov_remaining_ -= len;
-      total_written_ += len;
-      return true;
-    }
-
-    return false;
-  }
-
-  inline bool AppendFromSelf(size_t offset, size_t len, char**) {
-    // See SnappyArrayWriter::AppendFromSelf for an explanation of
-    // the "offset - 1u" trick.
-    if (offset - 1u >= total_written_) {
-      return false;
-    }
-    const size_t space_left = output_limit_ - total_written_;
-    if (len > space_left) {
-      return false;
-    }
-
-    // Locate the iovec from which we need to start the copy.
-    const iovec* from_iov = curr_iov_;
-    size_t from_iov_offset = curr_iov_->iov_len - curr_iov_remaining_;
-    while (offset > 0) {
-      if (from_iov_offset >= offset) {
-        from_iov_offset -= offset;
-        break;
-      }
-
-      offset -= from_iov_offset;
-      --from_iov;
-#if !defined(NDEBUG)
-      assert(from_iov >= output_iov_);
-#endif  // !defined(NDEBUG)
-      from_iov_offset = from_iov->iov_len;
-    }
-
-    // Copy <len> bytes starting from the iovec pointed to by from_iov_index to
-    // the current iovec.
-    while (len > 0) {
-      assert(from_iov <= curr_iov_);
-      if (from_iov != curr_iov_) {
-        const size_t to_copy =
-            std::min(from_iov->iov_len - from_iov_offset, len);
-        AppendNoCheck(GetIOVecPointer(from_iov, from_iov_offset), to_copy);
-        len -= to_copy;
-        if (len > 0) {
-          ++from_iov;
-          from_iov_offset = 0;
-        }
-      } else {
-        size_t to_copy = curr_iov_remaining_;
-        if (to_copy == 0) {
-          // This iovec is full. Go to the next one.
-          if (curr_iov_ + 1 >= output_iov_end_) {
-            return false;
-          }
-          ++curr_iov_;
-          curr_iov_output_ = reinterpret_cast<char*>(curr_iov_->iov_base);
-          curr_iov_remaining_ = curr_iov_->iov_len;
-          continue;
-        }
-        if (to_copy > len) {
-          to_copy = len;
-        }
-        assert(to_copy > 0);
-
-        IncrementalCopy(GetIOVecPointer(from_iov, from_iov_offset),
-                        curr_iov_output_, curr_iov_output_ + to_copy,
-                        curr_iov_output_ + curr_iov_remaining_);
-        curr_iov_output_ += to_copy;
-        curr_iov_remaining_ -= to_copy;
-        from_iov_offset += to_copy;
-        total_written_ += to_copy;
-        len -= to_copy;
-      }
-    }
-
-    return true;
-  }
-
-  inline void Flush() {}
-};
-
-bool RawUncompressToIOVec(const char* compressed, size_t compressed_length,
-                          const struct iovec* iov, size_t iov_cnt) {
-  ByteArraySource reader(compressed, compressed_length);
-  return RawUncompressToIOVec(&reader, iov, iov_cnt);
-}
-
-bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
-                          size_t iov_cnt) {
-  SnappyIOVecWriter output(iov, iov_cnt);
-  return InternalUncompress(compressed, &output);
-}
-
-// -----------------------------------------------------------------------
-// Flat array interfaces
-// -----------------------------------------------------------------------
-
-// A type that writes to a flat array.
-// Note that this is not a "ByteSink", but a type that matches the
-// Writer template argument to SnappyDecompressor::DecompressAllTags().
-class SnappyArrayWriter {
- private:
-  char* base_;
-  char* op_;
-  char* op_limit_;
-  // If op < op_limit_min_slop_ then it's safe to unconditionally write
-  // kSlopBytes starting at op.
-  char* op_limit_min_slop_;
-
- public:
-  inline explicit SnappyArrayWriter(char* dst)
-      : base_(dst),
-        op_(dst),
-        op_limit_(dst),
-        op_limit_min_slop_(dst) {}  // Safe default see invariant.
-
-  inline void SetExpectedLength(size_t len) {
-    op_limit_ = op_ + len;
-    // Prevent pointer from being past the buffer.
-    op_limit_min_slop_ = op_limit_ - std::min<size_t>(kSlopBytes - 1, len);
-  }
-
-  inline bool CheckLength() const { return op_ == op_limit_; }
-
-  char* GetOutputPtr() { return op_; }
-  char* GetBase(ptrdiff_t* op_limit_min_slop) {
-    *op_limit_min_slop = op_limit_min_slop_ - base_;
-    return base_;
-  }
-  void SetOutputPtr(char* op) { op_ = op; }
-
-  inline bool Append(const char* ip, size_t len, char** op_p) {
-    char* op = *op_p;
-    const size_t space_left = op_limit_ - op;
-    if (space_left < len) return false;
-    std::memcpy(op, ip, len);
-    *op_p = op + len;
-    return true;
-  }
-
-  inline bool TryFastAppend(const char* ip, size_t available, size_t len,
-                            char** op_p) {
-    char* op = *op_p;
-    const size_t space_left = op_limit_ - op;
-    if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations.
-      UnalignedCopy128(ip, op);
-      *op_p = op + len;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  SNAPPY_ATTRIBUTE_ALWAYS_INLINE
-  inline bool AppendFromSelf(size_t offset, size_t len, char** op_p) {
-    assert(len > 0);
-    char* const op = *op_p;
-    assert(op >= base_);
-    char* const op_end = op + len;
-
-    // Check if we try to append from before the start of the buffer.
-    if (SNAPPY_PREDICT_FALSE(static_cast<size_t>(op - base_) < offset))
-      return false;
-
-    if (SNAPPY_PREDICT_FALSE((kSlopBytes < 64 && len > kSlopBytes) ||
-                            op >= op_limit_min_slop_ || offset < len)) {
-      if (op_end > op_limit_ || offset == 0) return false;
-      *op_p = IncrementalCopy(op - offset, op, op_end, op_limit_);
-      return true;
-    }
-    std::memmove(op, op - offset, kSlopBytes);
-    *op_p = op_end;
-    return true;
-  }
-  inline size_t Produced() const {
-    assert(op_ >= base_);
-    return op_ - base_;
-  }
-  inline void Flush() {}
-};
-
-bool RawUncompress(const char* compressed, size_t compressed_length,
-                   char* uncompressed) {
-  ByteArraySource reader(compressed, compressed_length);
-  return RawUncompress(&reader, uncompressed);
-}
-
-bool RawUncompress(Source* compressed, char* uncompressed) {
-  SnappyArrayWriter output(uncompressed);
-  return InternalUncompress(compressed, &output);
-}
-
-bool Uncompress(const char* compressed, size_t compressed_length,
-                std::string* uncompressed) {
-  size_t ulength;
-  if (!GetUncompressedLength(compressed, compressed_length, &ulength)) {
-    return false;
-  }
-  // On 32-bit builds: max_size() < kuint32max.  Check for that instead
-  // of crashing (e.g., consider externally specified compressed data).
-  if (ulength > uncompressed->max_size()) {
-    return false;
-  }
-  STLStringResizeUninitialized(uncompressed, ulength);
-  return RawUncompress(compressed, compressed_length,
-                       string_as_array(uncompressed));
-}
-
-// A Writer that drops everything on the floor and just does validation
-class SnappyDecompressionValidator {
- private:
-  size_t expected_;
-  size_t produced_;
-
- public:
-  inline SnappyDecompressionValidator() : expected_(0), produced_(0) {}
-  inline void SetExpectedLength(size_t len) { expected_ = len; }
-  size_t GetOutputPtr() { return produced_; }
-  size_t GetBase(ptrdiff_t* op_limit_min_slop) {
-    *op_limit_min_slop = std::numeric_limits<ptrdiff_t>::max() - kSlopBytes + 1;
-    return 1;
-  }
-  void SetOutputPtr(size_t op) { produced_ = op; }
-  inline bool CheckLength() const { return expected_ == produced_; }
-  inline bool Append(const char* ip, size_t len, size_t* produced) {
-    // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-    (void)ip;
-
-    *produced += len;
-    return *produced <= expected_;
-  }
-  inline bool TryFastAppend(const char* ip, size_t available, size_t length,
-                            size_t* produced) {
-    // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-    (void)ip;
-    (void)available;
-    (void)length;
-    (void)produced;
-
-    return false;
-  }
-  inline bool AppendFromSelf(size_t offset, size_t len, size_t* produced) {
-    // See SnappyArrayWriter::AppendFromSelf for an explanation of
-    // the "offset - 1u" trick.
-    if (*produced <= offset - 1u) return false;
-    *produced += len;
-    return *produced <= expected_;
-  }
-  inline void Flush() {}
-};
-
-bool IsValidCompressedBuffer(const char* compressed, size_t compressed_length) {
-  ByteArraySource reader(compressed, compressed_length);
-  SnappyDecompressionValidator writer;
-  return InternalUncompress(&reader, &writer);
-}
-
-bool IsValidCompressed(Source* compressed) {
-  SnappyDecompressionValidator writer;
-  return InternalUncompress(compressed, &writer);
-}
-
-void RawCompress(const char* input, size_t input_length, char* compressed,
-                 size_t* compressed_length) {
-  RawCompress(input, input_length, compressed, compressed_length,
-              CompressionOptions{});
-}
-
-void RawCompress(const char* input, size_t input_length, char* compressed,
-                 size_t* compressed_length, CompressionOptions options) {
-  ByteArraySource reader(input, input_length);
-  UncheckedByteArraySink writer(compressed);
-  Compress(&reader, &writer, options);
-
-  // Compute how many bytes were added
-  *compressed_length = (writer.CurrentDestination() - compressed);
-}
-
-void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
-                          char* compressed, size_t* compressed_length) {
-  RawCompressFromIOVec(iov, uncompressed_length, compressed, compressed_length,
-                       CompressionOptions{});
-}
-
-void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
-                          char* compressed, size_t* compressed_length,
-                          CompressionOptions options) {
-  SnappyIOVecReader reader(iov, uncompressed_length);
-  UncheckedByteArraySink writer(compressed);
-  Compress(&reader, &writer, options);
-
-  // Compute how many bytes were added.
-  *compressed_length = writer.CurrentDestination() - compressed;
-}
-
-size_t Compress(const char* input, size_t input_length,
-                std::string* compressed) {
-  return Compress(input, input_length, compressed, CompressionOptions{});
-}
-
-size_t Compress(const char* input, size_t input_length, std::string* compressed,
-                CompressionOptions options) {
-  // Pre-grow the buffer to the max length of the compressed output
-  STLStringResizeUninitialized(compressed, MaxCompressedLength(input_length));
-
-  size_t compressed_length;
-  RawCompress(input, input_length, string_as_array(compressed),
-              &compressed_length, options);
-  compressed->erase(compressed_length);
-  return compressed_length;
-}
-
-size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
-                         std::string* compressed) {
-  return CompressFromIOVec(iov, iov_cnt, compressed, CompressionOptions{});
-}
-
-size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
-                         std::string* compressed, CompressionOptions options) {
-  // Compute the number of bytes to be compressed.
-  size_t uncompressed_length = 0;
-  for (size_t i = 0; i < iov_cnt; ++i) {
-    uncompressed_length += iov[i].iov_len;
-  }
-
-  // Pre-grow the buffer to the max length of the compressed output.
-  STLStringResizeUninitialized(compressed, MaxCompressedLength(
-      uncompressed_length));
-
-  size_t compressed_length;
-  RawCompressFromIOVec(iov, uncompressed_length, string_as_array(compressed),
-                       &compressed_length, options);
-  compressed->erase(compressed_length);
-  return compressed_length;
-}
-
-// -----------------------------------------------------------------------
-// Sink interface
-// -----------------------------------------------------------------------
-
-// A type that decompresses into a Sink. The template parameter
-// Allocator must export one method "char* Allocate(int size);", which
-// allocates a buffer of "size" and appends that to the destination.
-template <typename Allocator>
-class SnappyScatteredWriter {
-  Allocator allocator_;
-
-  // We need random access into the data generated so far.  Therefore
-  // we keep track of all of the generated data as an array of blocks.
-  // All of the blocks except the last have length kBlockSize.
-  std::vector<char*> blocks_;
-  size_t expected_;
-
-  // Total size of all fully generated blocks so far
-  size_t full_size_;
-
-  // Pointer into current output block
-  char* op_base_;   // Base of output block
-  char* op_ptr_;    // Pointer to next unfilled byte in block
-  char* op_limit_;  // Pointer just past block
-  // If op < op_limit_min_slop_ then it's safe to unconditionally write
-  // kSlopBytes starting at op.
-  char* op_limit_min_slop_;
-
-  inline size_t Size() const { return full_size_ + (op_ptr_ - op_base_); }
-
-  bool SlowAppend(const char* ip, size_t len);
-  bool SlowAppendFromSelf(size_t offset, size_t len);
-
- public:
-  inline explicit SnappyScatteredWriter(const Allocator& allocator)
-      : allocator_(allocator),
-        full_size_(0),
-        op_base_(NULL),
-        op_ptr_(NULL),
-        op_limit_(NULL),
-        op_limit_min_slop_(NULL) {}
-  char* GetOutputPtr() { return op_ptr_; }
-  char* GetBase(ptrdiff_t* op_limit_min_slop) {
-    *op_limit_min_slop = op_limit_min_slop_ - op_base_;
-    return op_base_;
-  }
-  void SetOutputPtr(char* op) { op_ptr_ = op; }
-
-  inline void SetExpectedLength(size_t len) {
-    assert(blocks_.empty());
-    expected_ = len;
-  }
-
-  inline bool CheckLength() const { return Size() == expected_; }
-
-  // Return the number of bytes actually uncompressed so far
-  inline size_t Produced() const { return Size(); }
-
-  inline bool Append(const char* ip, size_t len, char** op_p) {
-    char* op = *op_p;
-    size_t avail = op_limit_ - op;
-    if (len <= avail) {
-      // Fast path
-      std::memcpy(op, ip, len);
-      *op_p = op + len;
-      return true;
-    } else {
-      op_ptr_ = op;
-      bool res = SlowAppend(ip, len);
-      *op_p = op_ptr_;
-      return res;
-    }
-  }
-
-  inline bool TryFastAppend(const char* ip, size_t available, size_t length,
-                            char** op_p) {
-    char* op = *op_p;
-    const int space_left = op_limit_ - op;
-    if (length <= 16 && available >= 16 + kMaximumTagLength &&
-        space_left >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations.
-      UnalignedCopy128(ip, op);
-      *op_p = op + length;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  inline bool AppendFromSelf(size_t offset, size_t len, char** op_p) {
-    char* op = *op_p;
-    assert(op >= op_base_);
-    // Check if we try to append from before the start of the buffer.
-    if (SNAPPY_PREDICT_FALSE((kSlopBytes < 64 && len > kSlopBytes) ||
-                            static_cast<size_t>(op - op_base_) < offset ||
-                            op >= op_limit_min_slop_ || offset < len)) {
-      if (offset == 0) return false;
-      if (SNAPPY_PREDICT_FALSE(static_cast<size_t>(op - op_base_) < offset ||
-                              op + len > op_limit_)) {
-        op_ptr_ = op;
-        bool res = SlowAppendFromSelf(offset, len);
-        *op_p = op_ptr_;
-        return res;
-      }
-      *op_p = IncrementalCopy(op - offset, op, op + len, op_limit_);
-      return true;
-    }
-    // Fast path
-    char* const op_end = op + len;
-    std::memmove(op, op - offset, kSlopBytes);
-    *op_p = op_end;
-    return true;
-  }
-
-  // Called at the end of the decompress. We ask the allocator
-  // write all blocks to the sink.
-  inline void Flush() { allocator_.Flush(Produced()); }
-};
-
-template <typename Allocator>
-bool SnappyScatteredWriter<Allocator>::SlowAppend(const char* ip, size_t len) {
-  size_t avail = op_limit_ - op_ptr_;
-  while (len > avail) {
-    // Completely fill this block
-    std::memcpy(op_ptr_, ip, avail);
-    op_ptr_ += avail;
-    assert(op_limit_ - op_ptr_ == 0);
-    full_size_ += (op_ptr_ - op_base_);
-    len -= avail;
-    ip += avail;
-
-    // Bounds check
-    if (full_size_ + len > expected_) return false;
-
-    // Make new block
-    size_t bsize = std::min<size_t>(kBlockSize, expected_ - full_size_);
-    op_base_ = allocator_.Allocate(bsize);
-    op_ptr_ = op_base_;
-    op_limit_ = op_base_ + bsize;
-    op_limit_min_slop_ = op_limit_ - std::min<size_t>(kSlopBytes - 1, bsize);
-
-    blocks_.push_back(op_base_);
-    avail = bsize;
-  }
-
-  std::memcpy(op_ptr_, ip, len);
-  op_ptr_ += len;
-  return true;
-}
-
-template <typename Allocator>
-bool SnappyScatteredWriter<Allocator>::SlowAppendFromSelf(size_t offset,
-                                                         size_t len) {
-  // Overflow check
-  // See SnappyArrayWriter::AppendFromSelf for an explanation of
-  // the "offset - 1u" trick.
-  const size_t cur = Size();
-  if (offset - 1u >= cur) return false;
-  if (expected_ - cur < len) return false;
-
-  // Currently we shouldn't ever hit this path because Compress() chops the
-  // input into blocks and does not create cross-block copies. However, it is
-  // nice if we do not rely on that, since we can get better compression if we
-  // allow cross-block copies and thus might want to change the compressor in
-  // the future.
-  // TODO Replace this with a properly optimized path. This is not
-  // triggered right now. But this is so super slow, that it would regress
-  // performance unacceptably if triggered.
-  size_t src = cur - offset;
-  char* op = op_ptr_;
-  while (len-- > 0) {
-    char c = blocks_[src >> kBlockLog][src & (kBlockSize - 1)];
-    if (!Append(&c, 1, &op)) {
-      op_ptr_ = op;
-      return false;
-    }
-    src++;
-  }
-  op_ptr_ = op;
-  return true;
-}
-
-class SnappySinkAllocator {
- public:
-  explicit SnappySinkAllocator(Sink* dest) : dest_(dest) {}
-
-  char* Allocate(int size) {
-    Datablock block(new char[size], size);
-    blocks_.push_back(block);
-    return block.data;
-  }
-
-  // We flush only at the end, because the writer wants
-  // random access to the blocks and once we hand the
-  // block over to the sink, we can't access it anymore.
-  // Also we don't write more than has been actually written
-  // to the blocks.
-  void Flush(size_t size) {
-    size_t size_written = 0;
-    for (Datablock& block : blocks_) {
-      size_t block_size = std::min<size_t>(block.size, size - size_written);
-      dest_->AppendAndTakeOwnership(block.data, block_size,
-                                    &SnappySinkAllocator::Deleter, NULL);
-      size_written += block_size;
-    }
-    blocks_.clear();
-  }
-
- private:
-  struct Datablock {
-    char* data;
-    size_t size;
-    Datablock(char* p, size_t s) : data(p), size(s) {}
-  };
-
-  static void Deleter(void* arg, const char* bytes, size_t size) {
-    // TODO: Switch to [[maybe_unused]] when we can assume C++17.
-    (void)arg;
-    (void)size;
-
-    delete[] bytes;
-  }
-
-  Sink* dest_;
-  std::vector<Datablock> blocks_;
-
-  // Note: copying this object is allowed
-};
-
-size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed) {
-  SnappySinkAllocator allocator(uncompressed);
-  SnappyScatteredWriter<SnappySinkAllocator> writer(allocator);
-  InternalUncompress(compressed, &writer);
-  return writer.Produced();
-}
-
-bool Uncompress(Source* compressed, Sink* uncompressed) {
-  // Read the uncompressed length from the front of the compressed input
-  SnappyDecompressor decompressor(compressed);
-  uint32_t uncompressed_len = 0;
-  if (!decompressor.ReadUncompressedLength(&uncompressed_len)) {
-    return false;
-  }
-
-  char c;
-  size_t allocated_size;
-  char* buf = uncompressed->GetAppendBufferVariable(1, uncompressed_len, &c, 1,
-                                                    &allocated_size);
-
-  const size_t compressed_len = compressed->Available();
-  // If we can get a flat buffer, then use it, otherwise do block by block
-  // uncompression
-  if (allocated_size >= uncompressed_len) {
-    SnappyArrayWriter writer(buf);
-    bool result = InternalUncompressAllTags(&decompressor, &writer,
-                                            compressed_len, uncompressed_len);
-    uncompressed->Append(buf, writer.Produced());
-    return result;
-  } else {
-    SnappySinkAllocator allocator(uncompressed);
-    SnappyScatteredWriter<SnappySinkAllocator> writer(allocator);
-    return InternalUncompressAllTags(&decompressor, &writer, compressed_len,
-                                     uncompressed_len);
-  }
-}
-
-}  // namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#include "snappy.h"
-#include "snappy-internal.h"
-#include "snappy-sinksource.h"
-
-#if !defined(SNAPPY_HAVE_SSSE3)
-// __SSSE3__ is defined by GCC and Clang. Visual Studio doesn't target SIMD
-// support between SSE2 and AVX (so SSSE3 instructions require AVX support), and
-// defines __AVX__ when AVX support is available.
-#if defined(__SSSE3__) || defined(__AVX__)
-#define SNAPPY_HAVE_SSSE3 1
-#else
-#define SNAPPY_HAVE_SSSE3 0
-#endif
-#endif  // !defined(SNAPPY_HAVE_SSSE3)
-
-#if !defined(SNAPPY_HAVE_BMI2)
-// __BMI2__ is defined by GCC and Clang. Visual Studio doesn't target BMI2
-// specifically, but it does define __AVX2__ when AVX2 support is available.
-// Fortunately, AVX2 was introduced in Haswell, just like BMI2.
-//
-// BMI2 is not defined as a subset of AVX2 (unlike SSSE3 and AVX above). So,
-// GCC and Clang can build code with AVX2 enabled but BMI2 disabled, in which
-// case issuing BMI2 instructions results in a compiler error.
-#if defined(__BMI2__) || (defined(_MSC_VER) && defined(__AVX2__))
-#define SNAPPY_HAVE_BMI2 1
-#else
-#define SNAPPY_HAVE_BMI2 0
-#endif
-#endif  // !defined(SNAPPY_HAVE_BMI2)
-
-#if SNAPPY_HAVE_SSSE3
-// Please do not replace with <x86intrin.h>. or with headers that assume more
-// advanced SSE versions without checking with all the OWNERS.
-#include <tmmintrin.h>
-#endif
-
-#if SNAPPY_HAVE_BMI2
-// Please do not replace with <x86intrin.h>. or with headers that assume more
-// advanced SSE versions without checking with all the OWNERS.
-#include <immintrin.h>
-#endif
-
-#include <stdio.h>
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-namespace duckdb_snappy {
-
-using internal::COPY_1_BYTE_OFFSET;
-using internal::COPY_2_BYTE_OFFSET;
-using internal::LITERAL;
-using internal::char_table;
-using internal::kMaximumTagLength;
-
-// Any hash function will produce a valid compressed bitstream, but a good
-// hash function reduces the number of collisions and thus yields better
-// compression for compressible input, and more speed for incompressible
-// input. Of course, it doesn't hurt if the hash function is reasonably fast
-// either, as it gets called a lot.
-static inline uint32 HashBytes(uint32 bytes, int shift) {
-  uint32 kMul = 0x1e35a7bd;
-  return (bytes * kMul) >> shift;
-}
-static inline uint32 Hash(const char* p, int shift) {
-  return HashBytes(UNALIGNED_LOAD32(p), shift);
-}
-
-size_t MaxCompressedLength(size_t source_len) {
-  // Compressed data can be defined as:
-  //    compressed := item* literal*
-  //    item       := literal* copy
-  //
-  // The trailing literal sequence has a space blowup of at most 62/60
-  // since a literal of length 60 needs one tag byte + one extra byte
-  // for length information.
-  //
-  // Item blowup is trickier to measure.  Suppose the "copy" op copies
-  // 4 bytes of data.  Because of a special check in the encoding code,
-  // we produce a 4-byte copy only if the offset is < 65536.  Therefore
-  // the copy op takes 3 bytes to encode, and this type of item leads
-  // to at most the 62/60 blowup for representing literals.
-  //
-  // Suppose the "copy" op copies 5 bytes of data.  If the offset is big
-  // enough, it will take 5 bytes to encode the copy op.  Therefore the
-  // worst case here is a one-byte literal followed by a five-byte copy.
-  // I.e., 6 bytes of input turn into 7 bytes of "compressed" data.
-  //
-  // This last factor dominates the blowup, so the final estimate is:
-  return 32 + source_len + source_len/6;
-}
-
-namespace {
-
-void UnalignedCopy64(const void* src, void* dst) {
-  char tmp[8];
-  memcpy(tmp, src, 8);
-  memcpy(dst, tmp, 8);
-}
-
-void UnalignedCopy128(const void* src, void* dst) {
-  // memcpy gets vectorized when the appropriate compiler options are used.
-  // For example, x86 compilers targeting SSE2+ will optimize to an SSE2 load
-  // and store.
-  char tmp[16];
-  memcpy(tmp, src, 16);
-  memcpy(dst, tmp, 16);
-}
-
-// Copy [src, src+(op_limit-op)) to [op, (op_limit-op)) a byte at a time. Used
-// for handling COPY operations where the input and output regions may overlap.
-// For example, suppose:
-//    src       == "ab"
-//    op        == src + 2
-//    op_limit  == op + 20
-// After IncrementalCopySlow(src, op, op_limit), the result will have eleven
-// copies of "ab"
-//    ababababababababababab
-// Note that this does not match the semantics of either memcpy() or memmove().
-inline char* IncrementalCopySlow(const char* src, char* op,
-                                 char* const op_limit) {
-  // TODO: Remove pragma when LLVM is aware this
-  // function is only called in cold regions and when cold regions don't get
-  // vectorized or unrolled.
-#ifdef __clang__
-#pragma clang loop unroll(disable)
-#endif
-  while (op < op_limit) {
-    *op++ = *src++;
-  }
-  return op_limit;
-}
-
-#if SNAPPY_HAVE_SSSE3
-
-// This is a table of shuffle control masks that can be used as the source
-// operand for PSHUFB to permute the contents of the destination XMM register
-// into a repeating byte pattern.
-alignas(16) const char pshufb_fill_patterns[7][16] = {
-  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-  {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1},
-  {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0},
-  {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3},
-  {0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0},
-  {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3},
-  {0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1},
-};
-
-#endif  // SNAPPY_HAVE_SSSE3
-
-// Copy [src, src+(op_limit-op)) to [op, (op_limit-op)) but faster than
-// IncrementalCopySlow. buf_limit is the address past the end of the writable
-// region of the buffer.
-inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
-                             char* const buf_limit) {
-  // Terminology:
-  //
-  // slop = buf_limit - op
-  // pat  = op - src
-  // len  = limit - op
-  assert(src < op);
-  assert(op <= op_limit);
-  assert(op_limit <= buf_limit);
-  // NOTE: The compressor always emits 4 <= len <= 64. It is ok to assume that
-  // to optimize this function but we have to also handle other cases in case
-  // the input does not satisfy these conditions.
-
-  size_t pattern_size = op - src;
-  // The cases are split into different branches to allow the branch predictor,
-  // FDO, and static prediction hints to work better. For each input we list the
-  // ratio of invocations that match each condition.
-  //
-  // input        slop < 16   pat < 8  len > 16
-  // ------------------------------------------
-  // html|html4|cp   0%         1.01%    27.73%
-  // urls            0%         0.88%    14.79%
-  // jpg             0%        64.29%     7.14%
-  // pdf             0%         2.56%    58.06%
-  // txt[1-4]        0%         0.23%     0.97%
-  // pb              0%         0.96%    13.88%
-  // bin             0.01%     22.27%    41.17%
-  //
-  // It is very rare that we don't have enough slop for doing block copies. It
-  // is also rare that we need to expand a pattern. Small patterns are common
-  // for incompressible formats and for those we are plenty fast already.
-  // Lengths are normally not greater than 16 but they vary depending on the
-  // input. In general if we always predict len <= 16 it would be an ok
-  // prediction.
-  //
-  // In order to be fast we want a pattern >= 8 bytes and an unrolled loop
-  // copying 2x 8 bytes at a time.
-
-  // Handle the uncommon case where pattern is less than 8 bytes.
-  if (SNAPPY_PREDICT_FALSE(pattern_size < 8)) {
-#if SNAPPY_HAVE_SSSE3
-    // Load the first eight bytes into an 128-bit XMM register, then use PSHUFB
-    // to permute the register's contents in-place into a repeating sequence of
-    // the first "pattern_size" bytes.
-    // For example, suppose:
-    //    src       == "abc"
-    //    op        == op + 3
-    // After _mm_shuffle_epi8(), "pattern" will have five copies of "abc"
-    // followed by one byte of slop: abcabcabcabcabca.
-    //
-    // The non-SSE fallback implementation suffers from store-forwarding stalls
-    // because its loads and stores partly overlap. By expanding the pattern
-    // in-place, we avoid the penalty.
-    if (SNAPPY_PREDICT_TRUE(op <= buf_limit - 16)) {
-      const __m128i shuffle_mask = _mm_load_si128(
-          reinterpret_cast<const __m128i*>(pshufb_fill_patterns)
-          + pattern_size - 1);
-      const __m128i pattern = _mm_shuffle_epi8(
-          _mm_loadl_epi64(reinterpret_cast<const __m128i*>(src)), shuffle_mask);
-      // Uninitialized bytes are masked out by the shuffle mask.
-      // TODO: remove annotation and macro defs once MSan is fixed.
-      SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(&pattern, sizeof(pattern));
-      pattern_size *= 16 / pattern_size;
-      char* op_end = std::min(op_limit, buf_limit - 15);
-      while (op < op_end) {
-        _mm_storeu_si128(reinterpret_cast<__m128i*>(op), pattern);
-        op += pattern_size;
-      }
-      if (SNAPPY_PREDICT_TRUE(op >= op_limit)) return op_limit;
-    }
-    return IncrementalCopySlow(src, op, op_limit);
-#else  // !SNAPPY_HAVE_SSSE3
-    // If plenty of buffer space remains, expand the pattern to at least 8
-    // bytes. The way the following loop is written, we need 8 bytes of buffer
-    // space if pattern_size >= 4, 11 bytes if pattern_size is 1 or 3, and 10
-    // bytes if pattern_size is 2.  Precisely encoding that is probably not
-    // worthwhile; instead, invoke the slow path if we cannot write 11 bytes
-    // (because 11 are required in the worst case).
-    if (SNAPPY_PREDICT_TRUE(op <= buf_limit - 11)) {
-      while (pattern_size < 8) {
-        UnalignedCopy64(src, op);
-        op += pattern_size;
-        pattern_size *= 2;
-      }
-      if (SNAPPY_PREDICT_TRUE(op >= op_limit)) return op_limit;
-    } else {
-      return IncrementalCopySlow(src, op, op_limit);
-    }
-#endif  // SNAPPY_HAVE_SSSE3
-  }
-  assert(pattern_size >= 8);
-
-  // Copy 2x 8 bytes at a time. Because op - src can be < 16, a single
-  // UnalignedCopy128 might overwrite data in op. UnalignedCopy64 is safe
-  // because expanding the pattern to at least 8 bytes guarantees that
-  // op - src >= 8.
-  //
-  // Typically, the op_limit is the gating factor so try to simplify the loop
-  // based on that.
-  if (SNAPPY_PREDICT_TRUE(op_limit <= buf_limit - 16)) {
-    // Factor the displacement from op to the source into a variable. This helps
-    // simplify the loop below by only varying the op pointer which we need to
-    // test for the end. Note that this was done after carefully examining the
-    // generated code to allow the addressing modes in the loop below to
-    // maximize micro-op fusion where possible on modern Intel processors. The
-    // generated code should be checked carefully for new processors or with
-    // major changes to the compiler.
-    // TODO: Simplify this code when the compiler reliably produces
-    // the correct x86 instruction sequence.
-    ptrdiff_t op_to_src = src - op;
-
-    // The trip count of this loop is not large and so unrolling will only hurt
-    // code size without helping performance.
-    //
-    // TODO: Replace with loop trip count hint.
-#ifdef __clang__
-#pragma clang loop unroll(disable)
-#endif
-    do {
-      UnalignedCopy64(op + op_to_src, op);
-      UnalignedCopy64(op + op_to_src + 8, op + 8);
-      op += 16;
-    } while (op < op_limit);
-    return op_limit;
-  }
-
-  // Fall back to doing as much as we can with the available slop in the
-  // buffer. This code path is relatively cold however so we save code size by
-  // avoiding unrolling and vectorizing.
-  //
-  // TODO: Remove pragma when when cold regions don't get vectorized
-  // or unrolled.
-#ifdef __clang__
-#pragma clang loop unroll(disable)
-#endif
-  for (char *op_end = buf_limit - 16; op < op_end; op += 16, src += 16) {
-    UnalignedCopy64(src, op);
-    UnalignedCopy64(src + 8, op + 8);
-  }
-  if (op >= op_limit)
-    return op_limit;
-
-  // We only take this branch if we didn't have enough slop and we can do a
-  // single 8 byte copy.
-  if (SNAPPY_PREDICT_FALSE(op <= buf_limit - 8)) {
-    UnalignedCopy64(src, op);
-    src += 8;
-    op += 8;
-  }
-  return IncrementalCopySlow(src, op, op_limit);
-}
-
-}  // namespace
-
-template <bool allow_fast_path>
-static inline char* EmitLiteral(char* op,
-                                const char* literal,
-                                int len) {
-  // The vast majority of copies are below 16 bytes, for which a
-  // call to memcpy is overkill. This fast path can sometimes
-  // copy up to 15 bytes too much, but that is okay in the
-  // main loop, since we have a bit to go on for both sides:
-  //
-  //   - The input will always have kInputMarginBytes = 15 extra
-  //     available bytes, as long as we're in the main loop, and
-  //     if not, allow_fast_path = false.
-  //   - The output will always have 32 spare bytes (see
-  //     MaxCompressedLength).
-  assert(len > 0);      // Zero-length literals are disallowed
-  int n = len - 1;
-  if (allow_fast_path && len <= 16) {
-    // Fits in tag byte
-    *op++ = LITERAL | (n << 2);
-
-    UnalignedCopy128(literal, op);
-    return op + len;
-  }
-
-  if (n < 60) {
-    // Fits in tag byte
-    *op++ = LITERAL | (n << 2);
-  } else {
-    int count = (Bits::Log2Floor(n) >> 3) + 1;
-    assert(count >= 1);
-    assert(count <= 4);
-    *op++ = LITERAL | ((59 + count) << 2);
-    // Encode in upcoming bytes.
-    // Write 4 bytes, though we may care about only 1 of them. The output buffer
-    // is guaranteed to have at least 3 more spaces left as 'len >= 61' holds
-    // here and there is a memcpy of size 'len' below.
-    LittleEndian::Store32(op, n);
-    op += count;
-  }
-  memcpy(op, literal, len);
-  return op + len;
-}
-
-template <bool len_less_than_12>
-static inline char* EmitCopyAtMost64(char* op, size_t offset, size_t len) {
-  assert(len <= 64);
-  assert(len >= 4);
-  assert(offset < 65536);
-  assert(len_less_than_12 == (len < 12));
-
-  if (len_less_than_12 && SNAPPY_PREDICT_TRUE(offset < 2048)) {
-    // offset fits in 11 bits.  The 3 highest go in the top of the first byte,
-    // and the rest go in the second byte.
-    *op++ = COPY_1_BYTE_OFFSET + ((len - 4) << 2) + ((offset >> 3) & 0xe0);
-    *op++ = offset & 0xff;
-  } else {
-    // Write 4 bytes, though we only care about 3 of them.  The output buffer
-    // is required to have some slack, so the extra byte won't overrun it.
-    uint32 u = COPY_2_BYTE_OFFSET + ((len - 1) << 2) + (offset << 8);
-    LittleEndian::Store32(op, u);
-    op += 3;
-  }
-  return op;
-}
-
-template <bool len_less_than_12>
-static inline char* EmitCopy(char* op, size_t offset, size_t len) {
-  assert(len_less_than_12 == (len < 12));
-  if (len_less_than_12) {
-    return EmitCopyAtMost64</*len_less_than_12=*/true>(op, offset, len);
-  } else {
-    // A special case for len <= 64 might help, but so far measurements suggest
-    // it's in the noise.
-
-    // Emit 64 byte copies but make sure to keep at least four bytes reserved.
-    while (SNAPPY_PREDICT_FALSE(len >= 68)) {
-      op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, 64);
-      len -= 64;
-    }
-
-    // One or two copies will now finish the job.
-    if (len > 64) {
-      op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, 60);
-      len -= 60;
-    }
-
-    // Emit remainder.
-    if (len < 12) {
-      op = EmitCopyAtMost64</*len_less_than_12=*/true>(op, offset, len);
-    } else {
-      op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, len);
-    }
-    return op;
-  }
-}
-
-bool GetUncompressedLength(const char* start, size_t n, size_t* result) {
-  uint32 v = 0;
-  const char* limit = start + n;
-  if (Varint::Parse32WithLimit(start, limit, &v) != NULL) {
-    *result = v;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-namespace {
-uint32 CalculateTableSize(uint32 input_size) {
-  assert(kMaxHashTableSize >= 256);
-  if (input_size > kMaxHashTableSize) {
-    return kMaxHashTableSize;
-  }
-  if (input_size < 256) {
-    return 256;
-  }
-  // This is equivalent to Log2Ceiling(input_size), assuming input_size > 1.
-  // 2 << Log2Floor(x - 1) is equivalent to 1 << (1 + Log2Floor(x - 1)).
-  return 2u << Bits::Log2Floor(input_size - 1);
-}
-}  // namespace
-
-namespace internal {
-WorkingMemory::WorkingMemory(size_t input_size) {
-  const size_t max_fragment_size = std::min(input_size, kBlockSize);
-  const size_t table_size = CalculateTableSize(max_fragment_size);
-  size_ = table_size * sizeof(*table_) + max_fragment_size +
-          MaxCompressedLength(max_fragment_size);
-  mem_ = std::allocator<char>().allocate(size_);
-  table_ = reinterpret_cast<uint16*>(mem_);
-  input_ = mem_ + table_size * sizeof(*table_);
-  output_ = input_ + max_fragment_size;
-}
-
-WorkingMemory::~WorkingMemory() {
-  std::allocator<char>().deallocate(mem_, size_);
-}
-
-uint16* WorkingMemory::GetHashTable(size_t fragment_size,
-                                    int* table_size) const {
-  const size_t htsize = CalculateTableSize(fragment_size);
-  memset(table_, 0, htsize * sizeof(*table_));
-  *table_size = htsize;
-  return table_;
-}
-}  // end namespace internal
-
-// For 0 <= offset <= 4, GetUint32AtOffset(GetEightBytesAt(p), offset) will
-// equal UNALIGNED_LOAD32(p + offset).  Motivation: On x86-64 hardware we have
-// empirically found that overlapping loads such as
-//  UNALIGNED_LOAD32(p) ... UNALIGNED_LOAD32(p+1) ... UNALIGNED_LOAD32(p+2)
-// are slower than UNALIGNED_LOAD64(p) followed by shifts and casts to uint32.
-//
-// We have different versions for 64- and 32-bit; ideally we would avoid the
-// two functions and just inline the UNALIGNED_LOAD64 call into
-// GetUint32AtOffset, but GCC (at least not as of 4.6) is seemingly not clever
-// enough to avoid loading the value multiple times then. For 64-bit, the load
-// is done when GetEightBytesAt() is called, whereas for 32-bit, the load is
-// done at GetUint32AtOffset() time.
-
-#ifdef ARCH_K8
-
-typedef uint64 EightBytesReference;
-
-static inline EightBytesReference GetEightBytesAt(const char* ptr) {
-  return UNALIGNED_LOAD64(ptr);
-}
-
-static inline uint32 GetUint32AtOffset(uint64 v, int offset) {
-  assert(offset >= 0);
-  assert(offset <= 4);
-  return v >> (LittleEndian::IsLittleEndian() ? 8 * offset : 32 - 8 * offset);
-}
-
-#else
-
-typedef const char* EightBytesReference;
-
-static inline EightBytesReference GetEightBytesAt(const char* ptr) {
-  return ptr;
-}
-
-static inline uint32 GetUint32AtOffset(const char* v, int offset) {
-  assert(offset >= 0);
-  assert(offset <= 4);
-  return UNALIGNED_LOAD32(v + offset);
-}
-
-#endif
-
-// Flat array compression that does not emit the "uncompressed length"
-// prefix. Compresses "input" string to the "*op" buffer.
-//
-// REQUIRES: "input" is at most "kBlockSize" bytes long.
-// REQUIRES: "op" points to an array of memory that is at least
-// "MaxCompressedLength(input.size())" in size.
-// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-// REQUIRES: "table_size" is a power of two
-//
-// Returns an "end" pointer into "op" buffer.
-// "end - op" is the compressed size of "input".
-namespace internal {
-char* CompressFragment(const char* input,
-                       size_t input_size,
-                       char* op,
-                       uint16* table,
-                       const int table_size) {
-  // "ip" is the input pointer, and "op" is the output pointer.
-  const char* ip = input;
-  assert(input_size <= kBlockSize);
-  assert((table_size & (table_size - 1)) == 0);  // table must be power of two
-  const int shift = 32 - Bits::Log2Floor(table_size);
-  // assert(static_cast<int>(kuint32max >> shift) == table_size - 1);
-  const char* ip_end = input + input_size;
-  const char* base_ip = ip;
-  // Bytes in [next_emit, ip) will be emitted as literal bytes.  Or
-  // [next_emit, ip_end) after the main loop.
-  const char* next_emit = ip;
-
-  const size_t kInputMarginBytes = 15;
-  if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) {
-    const char* ip_limit = input + input_size - kInputMarginBytes;
-
-    for (uint32 next_hash = Hash(++ip, shift); ; ) {
-      assert(next_emit < ip);
-      // The body of this loop calls EmitLiteral once and then EmitCopy one or
-      // more times.  (The exception is that when we're close to exhausting
-      // the input we goto emit_remainder.)
-      //
-      // In the first iteration of this loop we're just starting, so
-      // there's nothing to copy, so calling EmitLiteral once is
-      // necessary.  And we only start a new iteration when the
-      // current iteration has determined that a call to EmitLiteral will
-      // precede the next call to EmitCopy (if any).
-      //
-      // Step 1: Scan forward in the input looking for a 4-byte-long match.
-      // If we get close to exhausting the input then goto emit_remainder.
-      //
-      // Heuristic match skipping: If 32 bytes are scanned with no matches
-      // found, start looking only at every other byte. If 32 more bytes are
-      // scanned (or skipped), look at every third byte, etc.. When a match is
-      // found, immediately go back to looking at every byte. This is a small
-      // loss (~5% performance, ~0.1% density) for compressible data due to more
-      // bookkeeping, but for non-compressible data (such as JPEG) it's a huge
-      // win since the compressor quickly "realizes" the data is incompressible
-      // and doesn't bother looking for matches everywhere.
-      //
-      // The "skip" variable keeps track of how many bytes there are since the
-      // last match; dividing it by 32 (ie. right-shifting by five) gives the
-      // number of bytes to move ahead for each iteration.
-      uint32 skip = 32;
-
-      const char* next_ip = ip;
-      const char* candidate;
-      do {
-        ip = next_ip;
-        uint32 hash = next_hash;
-        assert(hash == Hash(ip, shift));
-        uint32 bytes_between_hash_lookups = skip >> 5;
-        skip += bytes_between_hash_lookups;
-        next_ip = ip + bytes_between_hash_lookups;
-        if (SNAPPY_PREDICT_FALSE(next_ip > ip_limit)) {
-          goto emit_remainder;
-        }
-        next_hash = Hash(next_ip, shift);
-        candidate = base_ip + table[hash];
-        assert(candidate >= base_ip);
-        assert(candidate < ip);
-
-        table[hash] = ip - base_ip;
-      } while (SNAPPY_PREDICT_TRUE(UNALIGNED_LOAD32(ip) !=
-                                 UNALIGNED_LOAD32(candidate)));
-
-      // Step 2: A 4-byte match has been found.  We'll later see if more
-      // than 4 bytes match.  But, prior to the match, input
-      // bytes [next_emit, ip) are unmatched.  Emit them as "literal bytes."
-      assert(next_emit + 16 <= ip_end);
-      op = EmitLiteral</*allow_fast_path=*/true>(op, next_emit, ip - next_emit);
-
-      // Step 3: Call EmitCopy, and then see if another EmitCopy could
-      // be our next move.  Repeat until we find no match for the
-      // input immediately after what was consumed by the last EmitCopy call.
-      //
-      // If we exit this loop normally then we need to call EmitLiteral next,
-      // though we don't yet know how big the literal will be.  We handle that
-      // by proceeding to the next iteration of the main loop.  We also can exit
-      // this loop via goto if we get close to exhausting the input.
-      EightBytesReference input_bytes;
-      uint32 candidate_bytes = 0;
-
-      do {
-        // We have a 4-byte match at ip, and no need to emit any
-        // "literal bytes" prior to ip.
-        const char* base = ip;
-        std::pair<size_t, bool> p =
-            FindMatchLength(candidate + 4, ip + 4, ip_end);
-        size_t matched = 4 + p.first;
-        ip += matched;
-        size_t offset = base - candidate;
-        assert(0 == memcmp(base, candidate, matched));
-        if (p.second) {
-          op = EmitCopy</*len_less_than_12=*/true>(op, offset, matched);
-        } else {
-          op = EmitCopy</*len_less_than_12=*/false>(op, offset, matched);
-        }
-        next_emit = ip;
-        if (SNAPPY_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder;
-        }
-        // We are now looking for a 4-byte match again.  We read
-        // table[Hash(ip, shift)] for that.  To improve compression,
-        // we also update table[Hash(ip - 1, shift)] and table[Hash(ip, shift)].
-        input_bytes = GetEightBytesAt(ip - 1);
-        uint32 prev_hash = HashBytes(GetUint32AtOffset(input_bytes, 0), shift);
-        table[prev_hash] = ip - base_ip - 1;
-        uint32 cur_hash = HashBytes(GetUint32AtOffset(input_bytes, 1), shift);
-        candidate = base_ip + table[cur_hash];
-        candidate_bytes = UNALIGNED_LOAD32(candidate);
-        table[cur_hash] = ip - base_ip;
-      } while (GetUint32AtOffset(input_bytes, 1) == candidate_bytes);
-
-      next_hash = HashBytes(GetUint32AtOffset(input_bytes, 2), shift);
-      ++ip;
-    }
-  }
-
- emit_remainder:
-  // Emit the remaining bytes as a literal
-  if (next_emit < ip_end) {
-    op = EmitLiteral</*allow_fast_path=*/false>(op, next_emit,
-                                                ip_end - next_emit);
-  }
-
-  return op;
-}
-}  // end namespace internal
-
-// Called back at avery compression call to trace parameters and sizes.
-static inline void Report(const char *algorithm, size_t compressed_size,
-                          size_t uncompressed_size) {}
-
-// Signature of output types needed by decompression code.
-// The decompression code is templatized on a type that obeys this
-// signature so that we do not pay virtual function call overhead in
-// the middle of a tight decompression loop.
-//
-// class DecompressionWriter {
-//  public:
-//   // Called before decompression
-//   void SetExpectedLength(size_t length);
-//
-//   // Called after decompression
-//   bool CheckLength() const;
-//
-//   // Called repeatedly during decompression
-//   bool Append(const char* ip, size_t length);
-//   bool AppendFromSelf(uint32 offset, size_t length);
-//
-//   // The rules for how TryFastAppend differs from Append are somewhat
-//   // convoluted:
-//   //
-//   //  - TryFastAppend is allowed to decline (return false) at any
-//   //    time, for any reason -- just "return false" would be
-//   //    a perfectly legal implementation of TryFastAppend.
-//   //    The intention is for TryFastAppend to allow a fast path
-//   //    in the common case of a small append.
-//   //  - TryFastAppend is allowed to read up to <available> bytes
-//   //    from the input buffer, whereas Append is allowed to read
-//   //    <length>. However, if it returns true, it must leave
-//   //    at least five (kMaximumTagLength) bytes in the input buffer
-//   //    afterwards, so that there is always enough space to read the
-//   //    next tag without checking for a refill.
-//   //  - TryFastAppend must always return decline (return false)
-//   //    if <length> is 61 or more, as in this case the literal length is not
-//   //    decoded fully. In practice, this should not be a big problem,
-//   //    as it is unlikely that one would implement a fast path accepting
-//   //    this much data.
-//   //
-//   bool TryFastAppend(const char* ip, size_t available, size_t length);
-// };
-
-static inline uint32 ExtractLowBytes(uint32 v, int n) {
-  assert(n >= 0);
-  assert(n <= 4);
-#if SNAPPY_HAVE_BMI2
-  return _bzhi_u32(v, 8 * n);
-#else
-  // This needs to be wider than uint32 otherwise `mask << 32` will be
-  // undefined.
-  uint64 mask = 0xffffffff;
-  return v & ~(mask << (8 * n));
-#endif
-}
-
-static inline bool LeftShiftOverflows(uint8 value, uint32 shift) {
-  assert(shift < 32);
-  static const uint8 masks[] = {
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
-      0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe};
-  return (value & masks[shift]) != 0;
-}
-
-// Helper class for decompression
-class SnappyDecompressor {
- private:
-  Source*       reader_;         // Underlying source of bytes to decompress
-  const char*   ip_;             // Points to next buffered byte
-  const char*   ip_limit_;       // Points just past buffered bytes
-  uint32        peeked_;         // Bytes peeked from reader (need to skip)
-  bool          eof_;            // Hit end of input without an error?
-  char          scratch_[kMaximumTagLength];  // See RefillTag().
-
-  // Ensure that all of the tag metadata for the next tag is available
-  // in [ip_..ip_limit_-1].  Also ensures that [ip,ip+4] is readable even
-  // if (ip_limit_ - ip_ < 5).
-  //
-  // Returns true on success, false on error or end of input.
-  bool RefillTag();
-
- public:
-  explicit SnappyDecompressor(Source* reader)
-      : reader_(reader),
-        ip_(NULL),
-        ip_limit_(NULL),
-        peeked_(0),
-        eof_(false) {
-  }
-
-  ~SnappyDecompressor() {
-    // Advance past any bytes we peeked at from the reader
-    reader_->Skip(peeked_);
-  }
-
-  // Returns true iff we have hit the end of the input without an error.
-  bool eof() const {
-    return eof_;
-  }
-
-  // Read the uncompressed length stored at the start of the compressed data.
-  // On success, stores the length in *result and returns true.
-  // On failure, returns false.
-  bool ReadUncompressedLength(uint32* result) {
-    assert(ip_ == NULL);       // Must not have read anything yet
-    // Length is encoded in 1..5 bytes
-    *result = 0;
-    uint32 shift = 0;
-    while (true) {
-      if (shift >= 32) return false;
-      size_t n;
-      const char* ip = reader_->Peek(&n);
-      if (n == 0) return false;
-      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip));
-      reader_->Skip(1);
-      uint32 val = c & 0x7f;
-      if (LeftShiftOverflows(static_cast<uint8>(val), shift)) return false;
-      *result |= val << shift;
-      if (c < 128) {
-        break;
-      }
-      shift += 7;
-    }
-    return true;
-  }
-
-  // Process the next item found in the input.
-  // Returns true if successful, false on error or end of input.
-  template <class Writer>
-#if defined(__GNUC__) && defined(__x86_64__)
-  __attribute__((aligned(32)))
-#endif
-  void DecompressAllTags(Writer* writer) {
-    // In x86, pad the function body to start 16 bytes later. This function has
-    // a couple of hotspots that are highly sensitive to alignment: we have
-    // observed regressions by more than 20% in some metrics just by moving the
-    // exact same code to a different position in the benchmark binary.
-    //
-    // Putting this code on a 32-byte-aligned boundary + 16 bytes makes us hit
-    // the "lucky" case consistently. Unfortunately, this is a very brittle
-    // workaround, and future differences in code generation may reintroduce
-    // this regression. If you experience a big, difficult to explain, benchmark
-    // performance regression here, first try removing this hack.
-#if defined(__GNUC__) && defined(__x86_64__)
-    // Two 8-byte "NOP DWORD ptr [EAX + EAX*1 + 00000000H]" instructions.
-    asm(".byte 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
-    asm(".byte 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
-#endif
-
-    const char* ip = ip_;
-    // We could have put this refill fragment only at the beginning of the loop.
-    // However, duplicating it at the end of each branch gives the compiler more
-    // scope to optimize the <ip_limit_ - ip> expression based on the local
-    // context, which overall increases speed.
-    #define MAYBE_REFILL() \
-        if (ip_limit_ - ip < kMaximumTagLength) { \
-          ip_ = ip; \
-          if (!RefillTag()) return; \
-          ip = ip_; \
-        }
-
-    MAYBE_REFILL();
-    for ( ;; ) {
-      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip++));
-
-      // Ratio of iterations that have LITERAL vs non-LITERAL for different
-      // inputs.
-      //
-      // input          LITERAL  NON_LITERAL
-      // -----------------------------------
-      // html|html4|cp   23%        77%
-      // urls            36%        64%
-      // jpg             47%        53%
-      // pdf             19%        81%
-      // txt[1-4]        25%        75%
-      // pb              24%        76%
-      // bin             24%        76%
-      if (SNAPPY_PREDICT_FALSE((c & 0x3) == LITERAL)) {
-        size_t literal_length = (c >> 2) + 1u;
-        if (writer->TryFastAppend(ip, ip_limit_ - ip, literal_length)) {
-          assert(literal_length < 61);
-          ip += literal_length;
-          // NOTE: There is no MAYBE_REFILL() here, as TryFastAppend()
-          // will not return true unless there's already at least five spare
-          // bytes in addition to the literal.
-          continue;
-        }
-        if (SNAPPY_PREDICT_FALSE(literal_length >= 61)) {
-          // Long literal.
-          const size_t literal_length_length = literal_length - 60;
-          literal_length =
-              ExtractLowBytes(LittleEndian::Load32(ip), literal_length_length) +
-              1;
-          ip += literal_length_length;
-        }
-
-        size_t avail = ip_limit_ - ip;
-        while (avail < literal_length) {
-          if (!writer->Append(ip, avail)) return;
-          literal_length -= avail;
-          reader_->Skip(peeked_);
-          size_t n;
-          ip = reader_->Peek(&n);
-          avail = n;
-          peeked_ = avail;
-          if (avail == 0) return;  // Premature end of input
-          ip_limit_ = ip + avail;
-        }
-        if (!writer->Append(ip, literal_length)) {
-          return;
-        }
-        ip += literal_length;
-        MAYBE_REFILL();
-      } else {
-        const size_t entry = char_table[c];
-        const size_t trailer =
-            ExtractLowBytes(LittleEndian::Load32(ip), entry >> 11);
-        const size_t length = entry & 0xff;
-        ip += entry >> 11;
-
-        // copy_offset/256 is encoded in bits 8..10.  By just fetching
-        // those bits, we get copy_offset (since the bit-field starts at
-        // bit 8).
-        const size_t copy_offset = entry & 0x700;
-        if (!writer->AppendFromSelf(copy_offset + trailer, length)) {
-          return;
-        }
-        MAYBE_REFILL();
-      }
-    }
-
-#undef MAYBE_REFILL
-  }
-};
-
-bool SnappyDecompressor::RefillTag() {
-  const char* ip = ip_;
-  if (ip == ip_limit_) {
-    // Fetch a new fragment from the reader
-    reader_->Skip(peeked_);   // All peeked bytes are used up
-    size_t n;
-    ip = reader_->Peek(&n);
-    peeked_ = n;
-    eof_ = (n == 0);
-    if (eof_) return false;
-    ip_limit_ = ip + n;
-  }
-
-  // Read the tag character
-  assert(ip < ip_limit_);
-  const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip));
-  const uint32 entry = char_table[c];
-  const uint32 needed = (entry >> 11) + 1;  // +1 byte for 'c'
-  assert(needed <= sizeof(scratch_));
-
-  // Read more bytes from reader if needed
-  uint32 nbuf = ip_limit_ - ip;
-  if (nbuf < needed) {
-    // Stitch together bytes from ip and reader to form the word
-    // contents.  We store the needed bytes in "scratch_".  They
-    // will be consumed immediately by the caller since we do not
-    // read more than we need.
-    memmove(scratch_, ip, nbuf);
-    reader_->Skip(peeked_);  // All peeked bytes are used up
-    peeked_ = 0;
-    while (nbuf < needed) {
-      size_t length;
-      const char* src = reader_->Peek(&length);
-      if (length == 0) return false;
-      uint32 to_add = std::min<uint32>(needed - nbuf, length);
-      memcpy(scratch_ + nbuf, src, to_add);
-      nbuf += to_add;
-      reader_->Skip(to_add);
-    }
-    assert(nbuf == needed);
-    ip_ = scratch_;
-    ip_limit_ = scratch_ + needed;
-  } else if (nbuf < kMaximumTagLength) {
-    // Have enough bytes, but move into scratch_ so that we do not
-    // read past end of input
-    memmove(scratch_, ip, nbuf);
-    reader_->Skip(peeked_);  // All peeked bytes are used up
-    peeked_ = 0;
-    ip_ = scratch_;
-    ip_limit_ = scratch_ + nbuf;
-  } else {
-    // Pass pointer to buffer returned by reader_.
-    ip_ = ip;
-  }
-  return true;
-}
-
-template <typename Writer>
-static bool InternalUncompress(Source* r, Writer* writer) {
-  // Read the uncompressed length from the front of the compressed input
-  SnappyDecompressor decompressor(r);
-  uint32 uncompressed_len = 0;
-  if (!decompressor.ReadUncompressedLength(&uncompressed_len)) return false;
-
-  return InternalUncompressAllTags(&decompressor, writer, r->Available(),
-                                   uncompressed_len);
-}
-
-template <typename Writer>
-static bool InternalUncompressAllTags(SnappyDecompressor* decompressor,
-                                      Writer* writer,
-                                      uint32 compressed_len,
-                                      uint32 uncompressed_len) {
-  Report("snappy_uncompress", compressed_len, uncompressed_len);
-
-  writer->SetExpectedLength(uncompressed_len);
-
-  // Process the entire input
-  decompressor->DecompressAllTags(writer);
-  writer->Flush();
-  return (decompressor->eof() && writer->CheckLength());
-}
-
-bool GetUncompressedLength(Source* source, uint32* result) {
-  SnappyDecompressor decompressor(source);
-  return decompressor.ReadUncompressedLength(result);
-}
-
-size_t Compress(Source* reader, Sink* writer) {
-  size_t written = 0;
-  size_t N = reader->Available();
-  const size_t uncompressed_size = N;
-  char ulength[Varint::kMax32];
-  char* p = Varint::Encode32(ulength, N);
-  writer->Append(ulength, p-ulength);
-  written += (p - ulength);
-
-  internal::WorkingMemory wmem(N);
-
-  while (N > 0) {
-    // Get next block to compress (without copying if possible)
-    size_t fragment_size;
-    const char* fragment = reader->Peek(&fragment_size);
-    assert(fragment_size != 0);  // premature end of input
-    const size_t num_to_read = std::min(N, kBlockSize);
-    size_t bytes_read = fragment_size;
-
-    size_t pending_advance = 0;
-    if (bytes_read >= num_to_read) {
-      // Buffer returned by reader is large enough
-      pending_advance = num_to_read;
-      fragment_size = num_to_read;
-    } else {
-      char* scratch = wmem.GetScratchInput();
-      memcpy(scratch, fragment, bytes_read);
-      reader->Skip(bytes_read);
-
-      while (bytes_read < num_to_read) {
-        fragment = reader->Peek(&fragment_size);
-        size_t n = std::min<size_t>(fragment_size, num_to_read - bytes_read);
-        memcpy(scratch + bytes_read, fragment, n);
-        bytes_read += n;
-        reader->Skip(n);
-      }
-      assert(bytes_read == num_to_read);
-      fragment = scratch;
-      fragment_size = num_to_read;
-    }
-    assert(fragment_size == num_to_read);
-
-    // Get encoding table for compression
-    int table_size;
-    uint16* table = wmem.GetHashTable(num_to_read, &table_size);
-
-    // Compress input_fragment and append to dest
-    const int max_output = MaxCompressedLength(num_to_read);
-
-    // Need a scratch buffer for the output, in case the byte sink doesn't
-    // have room for us directly.
-
-    // Since we encode kBlockSize regions followed by a region
-    // which is <= kBlockSize in length, a previously allocated
-    // scratch_output[] region is big enough for this iteration.
-    char* dest = writer->GetAppendBuffer(max_output, wmem.GetScratchOutput());
-    char* end = internal::CompressFragment(fragment, fragment_size, dest, table,
-                                           table_size);
-    writer->Append(dest, end - dest);
-    written += (end - dest);
-
-    N -= num_to_read;
-    reader->Skip(pending_advance);
-  }
-
-  Report("snappy_compress", written, uncompressed_size);
-
-  return written;
-}
-
-// -----------------------------------------------------------------------
-// IOVec interfaces
-// -----------------------------------------------------------------------
-
-// A type that writes to an iovec.
-// Note that this is not a "ByteSink", but a type that matches the
-// Writer template argument to SnappyDecompressor::DecompressAllTags().
-class SnappyIOVecWriter {
- private:
-  // output_iov_end_ is set to iov + count and used to determine when
-  // the end of the iovs is reached.
-  const struct iovec* output_iov_end_;
-
-#if !defined(NDEBUG)
-  const struct iovec* output_iov_;
-#endif  // !defined(NDEBUG)
-
-  // Current iov that is being written into.
-  const struct iovec* curr_iov_;
-
-  // Pointer to current iov's write location.
-  char* curr_iov_output_;
-
-  // Remaining bytes to write into curr_iov_output.
-  size_t curr_iov_remaining_;
-
-  // Total bytes decompressed into output_iov_ so far.
-  size_t total_written_;
-
-  // Maximum number of bytes that will be decompressed into output_iov_.
-  size_t output_limit_;
-
-  static inline char* GetIOVecPointer(const struct iovec* iov, size_t offset) {
-    return reinterpret_cast<char*>(iov->iov_base) + offset;
-  }
-
- public:
-  // Does not take ownership of iov. iov must be valid during the
-  // entire lifetime of the SnappyIOVecWriter.
-  inline SnappyIOVecWriter(const struct iovec* iov, size_t iov_count)
-      : output_iov_end_(iov + iov_count),
-#if !defined(NDEBUG)
-        output_iov_(iov),
-#endif  // !defined(NDEBUG)
-        curr_iov_(iov),
-        curr_iov_output_(iov_count ? reinterpret_cast<char*>(iov->iov_base)
-                                   : nullptr),
-        curr_iov_remaining_(iov_count ? iov->iov_len : 0),
-        total_written_(0),
-        output_limit_(-1) {}
-
-  inline void SetExpectedLength(size_t len) {
-    output_limit_ = len;
-  }
-
-  inline bool CheckLength() const {
-    return total_written_ == output_limit_;
-  }
-
-  inline bool Append(const char* ip, size_t len) {
-    if (total_written_ + len > output_limit_) {
-      return false;
-    }
-
-    return AppendNoCheck(ip, len);
-  }
-
-  inline bool AppendNoCheck(const char* ip, size_t len) {
-    while (len > 0) {
-      if (curr_iov_remaining_ == 0) {
-        // This iovec is full. Go to the next one.
-        if (curr_iov_ + 1 >= output_iov_end_) {
-          return false;
-        }
-        ++curr_iov_;
-        curr_iov_output_ = reinterpret_cast<char*>(curr_iov_->iov_base);
-        curr_iov_remaining_ = curr_iov_->iov_len;
-      }
-
-      const size_t to_write = std::min(len, curr_iov_remaining_);
-      memcpy(curr_iov_output_, ip, to_write);
-      curr_iov_output_ += to_write;
-      curr_iov_remaining_ -= to_write;
-      total_written_ += to_write;
-      ip += to_write;
-      len -= to_write;
-    }
-
-    return true;
-  }
-
-  inline bool TryFastAppend(const char* ip, size_t available, size_t len) {
-    const size_t space_left = output_limit_ - total_written_;
-    if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16 &&
-        curr_iov_remaining_ >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations.
-      UnalignedCopy128(ip, curr_iov_output_);
-      curr_iov_output_ += len;
-      curr_iov_remaining_ -= len;
-      total_written_ += len;
-      return true;
-    }
-
-    return false;
-  }
-
-  inline bool AppendFromSelf(size_t offset, size_t len) {
-    // See SnappyArrayWriter::AppendFromSelf for an explanation of
-    // the "offset - 1u" trick.
-    if (offset - 1u >= total_written_) {
-      return false;
-    }
-    const size_t space_left = output_limit_ - total_written_;
-    if (len > space_left) {
-      return false;
-    }
-
-    // Locate the iovec from which we need to start the copy.
-    const iovec* from_iov = curr_iov_;
-    size_t from_iov_offset = curr_iov_->iov_len - curr_iov_remaining_;
-    while (offset > 0) {
-      if (from_iov_offset >= offset) {
-        from_iov_offset -= offset;
-        break;
-      }
-
-      offset -= from_iov_offset;
-      --from_iov;
-#if !defined(NDEBUG)
-      assert(from_iov >= output_iov_);
-#endif  // !defined(NDEBUG)
-      from_iov_offset = from_iov->iov_len;
-    }
-
-    // Copy <len> bytes starting from the iovec pointed to by from_iov_index to
-    // the current iovec.
-    while (len > 0) {
-      assert(from_iov <= curr_iov_);
-      if (from_iov != curr_iov_) {
-        const size_t to_copy =
-            std::min((unsigned long)(from_iov->iov_len - from_iov_offset), (unsigned long)len);
-        AppendNoCheck(GetIOVecPointer(from_iov, from_iov_offset), to_copy);
-        len -= to_copy;
-        if (len > 0) {
-          ++from_iov;
-          from_iov_offset = 0;
-        }
-      } else {
-        size_t to_copy = curr_iov_remaining_;
-        if (to_copy == 0) {
-          // This iovec is full. Go to the next one.
-          if (curr_iov_ + 1 >= output_iov_end_) {
-            return false;
-          }
-          ++curr_iov_;
-          curr_iov_output_ = reinterpret_cast<char*>(curr_iov_->iov_base);
-          curr_iov_remaining_ = curr_iov_->iov_len;
-          continue;
-        }
-        if (to_copy > len) {
-          to_copy = len;
-        }
-
-        IncrementalCopy(GetIOVecPointer(from_iov, from_iov_offset),
-                        curr_iov_output_, curr_iov_output_ + to_copy,
-                        curr_iov_output_ + curr_iov_remaining_);
-        curr_iov_output_ += to_copy;
-        curr_iov_remaining_ -= to_copy;
-        from_iov_offset += to_copy;
-        total_written_ += to_copy;
-        len -= to_copy;
-      }
-    }
-
-    return true;
-  }
-
-  inline void Flush() {}
-};
-
-bool RawUncompressToIOVec(const char* compressed, size_t compressed_length,
-                          const struct iovec* iov, size_t iov_cnt) {
-  ByteArraySource reader(compressed, compressed_length);
-  return RawUncompressToIOVec(&reader, iov, iov_cnt);
-}
-
-bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
-                          size_t iov_cnt) {
-  SnappyIOVecWriter output(iov, iov_cnt);
-  return InternalUncompress(compressed, &output);
-}
-
-// -----------------------------------------------------------------------
-// Flat array interfaces
-// -----------------------------------------------------------------------
-
-// A type that writes to a flat array.
-// Note that this is not a "ByteSink", but a type that matches the
-// Writer template argument to SnappyDecompressor::DecompressAllTags().
-class SnappyArrayWriter {
- private:
-  char* base_;
-  char* op_;
-  char* op_limit_;
-
- public:
-  inline explicit SnappyArrayWriter(char* dst)
-      : base_(dst),
-        op_(dst),
-        op_limit_(dst) {
-  }
-
-  inline void SetExpectedLength(size_t len) {
-    op_limit_ = op_ + len;
-  }
-
-  inline bool CheckLength() const {
-    return op_ == op_limit_;
-  }
-
-  inline bool Append(const char* ip, size_t len) {
-    char* op = op_;
-    const size_t space_left = op_limit_ - op;
-    if (space_left < len) {
-      return false;
-    }
-    memcpy(op, ip, len);
-    op_ = op + len;
-    return true;
-  }
-
-  inline bool TryFastAppend(const char* ip, size_t available, size_t len) {
-    char* op = op_;
-    const size_t space_left = op_limit_ - op;
-    if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations.
-      UnalignedCopy128(ip, op);
-      op_ = op + len;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  inline bool AppendFromSelf(size_t offset, size_t len) {
-    char* const op_end = op_ + len;
-
-    // Check if we try to append from before the start of the buffer.
-    // Normally this would just be a check for "produced < offset",
-    // but "produced <= offset - 1u" is equivalent for every case
-    // except the one where offset==0, where the right side will wrap around
-    // to a very big number. This is convenient, as offset==0 is another
-    // invalid case that we also want to catch, so that we do not go
-    // into an infinite loop.
-    if (Produced() <= offset - 1u || op_end > op_limit_) return false;
-    op_ = IncrementalCopy(op_ - offset, op_, op_end, op_limit_);
-
-    return true;
-  }
-  inline size_t Produced() const {
-    assert(op_ >= base_);
-    return op_ - base_;
-  }
-  inline void Flush() {}
-};
-
-bool RawUncompress(const char* compressed, size_t n, char* uncompressed) {
-  ByteArraySource reader(compressed, n);
-  return RawUncompress(&reader, uncompressed);
-}
-
-bool RawUncompress(Source* compressed, char* uncompressed) {
-  SnappyArrayWriter output(uncompressed);
-  return InternalUncompress(compressed, &output);
-}
-
-bool Uncompress(const char* compressed, size_t n, string* uncompressed) {
-  size_t ulength;
-  if (!GetUncompressedLength(compressed, n, &ulength)) {
-    return false;
-  }
-  // On 32-bit builds: max_size() < kuint32max.  Check for that instead
-  // of crashing (e.g., consider externally specified compressed data).
-  if (ulength > uncompressed->max_size()) {
-    return false;
-  }
-  STLStringResizeUninitialized(uncompressed, ulength);
-  return RawUncompress(compressed, n, string_as_array(uncompressed));
-}
-
-// A Writer that drops everything on the floor and just does validation
-class SnappyDecompressionValidator {
- private:
-  size_t expected_;
-  size_t produced_;
-
- public:
-  inline SnappyDecompressionValidator() : expected_(0), produced_(0) { }
-  inline void SetExpectedLength(size_t len) {
-    expected_ = len;
-  }
-  inline bool CheckLength() const {
-    return expected_ == produced_;
-  }
-  inline bool Append(const char* ip, size_t len) {
-    produced_ += len;
-    return produced_ <= expected_;
-  }
-  inline bool TryFastAppend(const char* ip, size_t available, size_t length) {
-    return false;
-  }
-  inline bool AppendFromSelf(size_t offset, size_t len) {
-    // See SnappyArrayWriter::AppendFromSelf for an explanation of
-    // the "offset - 1u" trick.
-    if (produced_ <= offset - 1u) return false;
-    produced_ += len;
-    return produced_ <= expected_;
-  }
-  inline void Flush() {}
-};
-
-bool IsValidCompressedBuffer(const char* compressed, size_t n) {
-  ByteArraySource reader(compressed, n);
-  SnappyDecompressionValidator writer;
-  return InternalUncompress(&reader, &writer);
-}
-
-bool IsValidCompressed(Source* compressed) {
-  SnappyDecompressionValidator writer;
-  return InternalUncompress(compressed, &writer);
-}
-
-void RawCompress(const char* input,
-                 size_t input_length,
-                 char* compressed,
-                 size_t* compressed_length) {
-  ByteArraySource reader(input, input_length);
-  UncheckedByteArraySink writer(compressed);
-  Compress(&reader, &writer);
-
-  // Compute how many bytes were added
-  *compressed_length = (writer.CurrentDestination() - compressed);
-}
-
-size_t Compress(const char* input, size_t input_length, string* compressed) {
-  // Pre-grow the buffer to the max length of the compressed output
-  STLStringResizeUninitialized(compressed, MaxCompressedLength(input_length));
-
-  size_t compressed_length;
-  RawCompress(input, input_length, string_as_array(compressed),
-              &compressed_length);
-  compressed->resize(compressed_length);
-  return compressed_length;
-}
-
-// -----------------------------------------------------------------------
-// Sink interface
-// -----------------------------------------------------------------------
-
-// A type that decompresses into a Sink. The template parameter
-// Allocator must export one method "char* Allocate(int size);", which
-// allocates a buffer of "size" and appends that to the destination.
-template <typename Allocator>
-class SnappyScatteredWriter {
-  Allocator allocator_;
-
-  // We need random access into the data generated so far.  Therefore
-  // we keep track of all of the generated data as an array of blocks.
-  // All of the blocks except the last have length kBlockSize.
-  std::vector<char*> blocks_;
-  size_t expected_;
-
-  // Total size of all fully generated blocks so far
-  size_t full_size_;
-
-  // Pointer into current output block
-  char* op_base_;       // Base of output block
-  char* op_ptr_;        // Pointer to next unfilled byte in block
-  char* op_limit_;      // Pointer just past block
-
-  inline size_t Size() const {
-    return full_size_ + (op_ptr_ - op_base_);
-  }
-
-  bool SlowAppend(const char* ip, size_t len);
-  bool SlowAppendFromSelf(size_t offset, size_t len);
-
- public:
-  inline explicit SnappyScatteredWriter(const Allocator& allocator)
-      : allocator_(allocator),
-        full_size_(0),
-        op_base_(NULL),
-        op_ptr_(NULL),
-        op_limit_(NULL) {
-  }
-
-  inline void SetExpectedLength(size_t len) {
-    assert(blocks_.empty());
-    expected_ = len;
-  }
-
-  inline bool CheckLength() const {
-    return Size() == expected_;
-  }
-
-  // Return the number of bytes actually uncompressed so far
-  inline size_t Produced() const {
-    return Size();
-  }
-
-  inline bool Append(const char* ip, size_t len) {
-    size_t avail = op_limit_ - op_ptr_;
-    if (len <= avail) {
-      // Fast path
-      memcpy(op_ptr_, ip, len);
-      op_ptr_ += len;
-      return true;
-    } else {
-      return SlowAppend(ip, len);
-    }
-  }
-
-  inline bool TryFastAppend(const char* ip, size_t available, size_t length) {
-    char* op = op_ptr_;
-    const int space_left = op_limit_ - op;
-    if (length <= 16 && available >= 16 + kMaximumTagLength &&
-        space_left >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations.
-      UnalignedCopy128(ip, op);
-      op_ptr_ = op + length;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  inline bool AppendFromSelf(size_t offset, size_t len) {
-    char* const op_end = op_ptr_ + len;
-    // See SnappyArrayWriter::AppendFromSelf for an explanation of
-    // the "offset - 1u" trick.
-    if (SNAPPY_PREDICT_TRUE(offset - 1u < (size_t)(op_ptr_ - op_base_) &&
-                          op_end <= op_limit_)) {
-      // Fast path: src and dst in current block.
-      op_ptr_ = IncrementalCopy(op_ptr_ - offset, op_ptr_, op_end, op_limit_);
-      return true;
-    }
-    return SlowAppendFromSelf(offset, len);
-  }
-
-  // Called at the end of the decompress. We ask the allocator
-  // write all blocks to the sink.
-  inline void Flush() { allocator_.Flush(Produced()); }
-};
-
-template<typename Allocator>
-bool SnappyScatteredWriter<Allocator>::SlowAppend(const char* ip, size_t len) {
-  size_t avail = op_limit_ - op_ptr_;
-  while (len > avail) {
-    // Completely fill this block
-    memcpy(op_ptr_, ip, avail);
-    op_ptr_ += avail;
-    assert(op_limit_ - op_ptr_ == 0);
-    full_size_ += (op_ptr_ - op_base_);
-    len -= avail;
-    ip += avail;
-
-    // Bounds check
-    if (full_size_ + len > expected_) {
-      return false;
-    }
-
-    // Make new block
-    size_t bsize = std::min<size_t>(kBlockSize, expected_ - full_size_);
-    op_base_ = allocator_.Allocate(bsize);
-    op_ptr_ = op_base_;
-    op_limit_ = op_base_ + bsize;
-    blocks_.push_back(op_base_);
-    avail = bsize;
-  }
-
-  memcpy(op_ptr_, ip, len);
-  op_ptr_ += len;
-  return true;
-}
-
-template<typename Allocator>
-bool SnappyScatteredWriter<Allocator>::SlowAppendFromSelf(size_t offset,
-                                                         size_t len) {
-  // Overflow check
-  // See SnappyArrayWriter::AppendFromSelf for an explanation of
-  // the "offset - 1u" trick.
-  const size_t cur = Size();
-  if (offset - 1u >= cur) return false;
-  if (expected_ - cur < len) return false;
-
-  // Currently we shouldn't ever hit this path because Compress() chops the
-  // input into blocks and does not create cross-block copies. However, it is
-  // nice if we do not rely on that, since we can get better compression if we
-  // allow cross-block copies and thus might want to change the compressor in
-  // the future.
-  size_t src = cur - offset;
-  while (len-- > 0) {
-    char c = blocks_[src >> kBlockLog][src & (kBlockSize-1)];
-    Append(&c, 1);
-    src++;
-  }
-  return true;
-}
-
-class SnappySinkAllocator {
- public:
-  explicit SnappySinkAllocator(Sink* dest): dest_(dest) {}
-  ~SnappySinkAllocator() {}
-
-  char* Allocate(int size) {
-    Datablock block(new char[size], size);
-    blocks_.push_back(block);
-    return block.data;
-  }
-
-  // We flush only at the end, because the writer wants
-  // random access to the blocks and once we hand the
-  // block over to the sink, we can't access it anymore.
-  // Also we don't write more than has been actually written
-  // to the blocks.
-  void Flush(size_t size) {
-    size_t size_written = 0;
-    size_t block_size;
-    for (size_t i = 0; i < blocks_.size(); ++i) {
-      block_size = std::min<size_t>(blocks_[i].size, size - size_written);
-      dest_->AppendAndTakeOwnership(blocks_[i].data, block_size,
-                                    &SnappySinkAllocator::Deleter, NULL);
-      size_written += block_size;
-    }
-    blocks_.clear();
-  }
-
- private:
-  struct Datablock {
-    char* data;
-    size_t size;
-    Datablock(char* p, size_t s) : data(p), size(s) {}
-  };
-
-  static void Deleter(void* arg, const char* bytes, size_t size) {
-    delete[] bytes;
-  }
-
-  Sink* dest_;
-  std::vector<Datablock> blocks_;
-
-  // Note: copying this object is allowed
-};
-
-size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed) {
-  SnappySinkAllocator allocator(uncompressed);
-  SnappyScatteredWriter<SnappySinkAllocator> writer(allocator);
-  InternalUncompress(compressed, &writer);
-  return writer.Produced();
-}
-
-bool Uncompress(Source* compressed, Sink* uncompressed) {
-  // Read the uncompressed length from the front of the compressed input
-  SnappyDecompressor decompressor(compressed);
-  uint32 uncompressed_len = 0;
-  if (!decompressor.ReadUncompressedLength(&uncompressed_len)) {
-    return false;
-  }
-
-  char c;
-  size_t allocated_size;
-  char* buf = uncompressed->GetAppendBufferVariable(
-      1, uncompressed_len, &c, 1, &allocated_size);
-
-  const size_t compressed_len = compressed->Available();
-  // If we can get a flat buffer, then use it, otherwise do block by block
-  // uncompression
-  if (allocated_size >= uncompressed_len) {
-    SnappyArrayWriter writer(buf);
-    bool result = InternalUncompressAllTags(&decompressor, &writer,
-                                            compressed_len, uncompressed_len);
-    uncompressed->Append(buf, writer.Produced());
-    return result;
-  } else {
-    SnappySinkAllocator allocator(uncompressed);
-    SnappyScatteredWriter<SnappySinkAllocator> writer(allocator);
-    return InternalUncompressAllTags(&decompressor, &writer, compressed_len,
-                                     uncompressed_len);
-  }
-}
-
-}  // namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
diff --git a/src/duckdb/third_party/snappy/snappy.h b/src/duckdb/third_party/snappy/snappy.h
deleted file mode 100644
index cda77a7d6..000000000
--- a/src/duckdb/third_party/snappy/snappy.h
+++ /dev/null
@@ -1,412 +0,0 @@
-// Copyright 2005 and onwards Google Inc.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN 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.
-//
-// A light-weight compression algorithm.  It is designed for speed of
-// compression and decompression, rather than for the utmost in space
-// savings.
-//
-// For getting better compression ratios when you are compressing data
-// with long repeated sequences or compressing data that is similar to
-// other data, while still compressing fast, you might look at first
-// using BMDiff and then compressing the output of BMDiff with
-// Snappy.
-
-#ifndef THIRD_PARTY_SNAPPY_SNAPPY_H__
-#define THIRD_PARTY_SNAPPY_SNAPPY_H__
-
-#include "snappy_version.hpp"
-
-#if SNAPPY_NEW_VERSION
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "snappy-stubs-public.h"
-
-namespace duckdb_snappy {
-  class Source;
-  class Sink;
-
-  struct CompressionOptions {
-    // Compression level.
-    // Level 1 is the fastest
-    // Level 2 is a little slower but provides better compression. Level 2 is
-    // **EXPERIMENTAL** for the time being. It might happen that we decide to
-    // fall back to level 1 in the future.
-    // Levels 3+ are currently not supported. We plan to support levels up to
-    // 9 in the future.
-    // If you played with other compression algorithms, level 1 is equivalent to
-    // fast mode (level 1) of LZ4, level 2 is equivalent to LZ4's level 2 mode
-    // and compresses somewhere around zstd:-3 and zstd:-2 but generally with
-    // faster decompression speeds than snappy:1 and zstd:-3.
-    int level = DefaultCompressionLevel();
-
-    constexpr CompressionOptions() = default;
-    constexpr CompressionOptions(int compression_level)
-        : level(compression_level) {}
-    static constexpr int MinCompressionLevel() { return 1; }
-    static constexpr int MaxCompressionLevel() { return 2; }
-    static constexpr int DefaultCompressionLevel() { return 1; }
-  };
-
-  // ------------------------------------------------------------------------
-  // Generic compression/decompression routines.
-  // ------------------------------------------------------------------------
-
-  // Compress the bytes read from "*reader" and append to "*writer". Return the
-  // number of bytes written.
-  // First version is to preserve ABI.
-  size_t Compress(Source* reader, Sink* writer);
-  size_t Compress(Source* reader, Sink* writer,
-                  CompressionOptions options);
-
-  // Find the uncompressed length of the given stream, as given by the header.
-  // Note that the true length could deviate from this; the stream could e.g.
-  // be truncated.
-  //
-  // Also note that this leaves "*source" in a state that is unsuitable for
-  // further operations, such as RawUncompress(). You will need to rewind
-  // or recreate the source yourself before attempting any further calls.
-  bool GetUncompressedLength(Source* source, uint32_t* result);
-
-  // ------------------------------------------------------------------------
-  // Higher-level string based routines (should be sufficient for most users)
-  // ------------------------------------------------------------------------
-
-  // Sets "*compressed" to the compressed version of "input[0..input_length-1]".
-  // Original contents of *compressed are lost.
-  //
-  // REQUIRES: "input[]" is not an alias of "*compressed".
-  // First version is to preserve ABI.
-  size_t Compress(const char* input, size_t input_length,
-                  std::string* compressed);
-  size_t Compress(const char* input, size_t input_length,
-                  std::string* compressed, CompressionOptions options);
-
-  // Same as `Compress` above but taking an `iovec` array as input. Note that
-  // this function preprocesses the inputs to compute the sum of
-  // `iov[0..iov_cnt-1].iov_len` before reading. To avoid this, use
-  // `RawCompressFromIOVec` below.
-  // First version is to preserve ABI.
-  size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
-                           std::string* compressed);
-  size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
-                           std::string* compressed,
-                           CompressionOptions options);
-
-  // Decompresses "compressed[0..compressed_length-1]" to "*uncompressed".
-  // Original contents of "*uncompressed" are lost.
-  //
-  // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
-  //
-  // returns false if the message is corrupted and could not be decompressed
-  bool Uncompress(const char* compressed, size_t compressed_length,
-                  std::string* uncompressed);
-
-  // Decompresses "compressed" to "*uncompressed".
-  //
-  // returns false if the message is corrupted and could not be decompressed
-  bool Uncompress(Source* compressed, Sink* uncompressed);
-
-  // This routine uncompresses as much of the "compressed" as possible
-  // into sink.  It returns the number of valid bytes added to sink
-  // (extra invalid bytes may have been added due to errors; the caller
-  // should ignore those). The emitted data typically has length
-  // GetUncompressedLength(), but may be shorter if an error is
-  // encountered.
-  size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed);
-
-  // ------------------------------------------------------------------------
-  // Lower-level character array based routines.  May be useful for
-  // efficiency reasons in certain circumstances.
-  // ------------------------------------------------------------------------
-
-  // REQUIRES: "compressed" must point to an area of memory that is at
-  // least "MaxCompressedLength(input_length)" bytes in length.
-  //
-  // Takes the data stored in "input[0..input_length]" and stores
-  // it in the array pointed to by "compressed".
-  //
-  // "*compressed_length" is set to the length of the compressed output.
-  //
-  // Example:
-  //    char* output = new char[snappy::MaxCompressedLength(input_length)];
-  //    size_t output_length;
-  //    RawCompress(input, input_length, output, &output_length);
-  //    ... Process(output, output_length) ...
-  //    delete [] output;
-  void RawCompress(const char* input, size_t input_length, char* compressed,
-                   size_t* compressed_length);
-  void RawCompress(const char* input, size_t input_length, char* compressed,
-                   size_t* compressed_length, CompressionOptions options);
-
-  // Same as `RawCompress` above but taking an `iovec` array as input. Note that
-  // `uncompressed_length` is the total number of bytes to be read from the
-  // elements of `iov` (_not_ the number of elements in `iov`).
-  void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
-                            char* compressed, size_t* compressed_length);
-  void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
-                            char* compressed, size_t* compressed_length,
-                            CompressionOptions options);
-
-  // Given data in "compressed[0..compressed_length-1]" generated by
-  // calling the Snappy::Compress routine, this routine
-  // stores the uncompressed data to
-  //    uncompressed[0..GetUncompressedLength(compressed)-1]
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompress(const char* compressed, size_t compressed_length,
-                     char* uncompressed);
-
-  // Given data from the byte source 'compressed' generated by calling
-  // the Snappy::Compress routine, this routine stores the uncompressed
-  // data to
-  //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1]
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompress(Source* compressed, char* uncompressed);
-
-  // Given data in "compressed[0..compressed_length-1]" generated by
-  // calling the Snappy::Compress routine, this routine
-  // stores the uncompressed data to the iovec "iov". The number of physical
-  // buffers in "iov" is given by iov_cnt and their cumulative size
-  // must be at least GetUncompressedLength(compressed). The individual buffers
-  // in "iov" must not overlap with each other.
-  //
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompressToIOVec(const char* compressed, size_t compressed_length,
-                            const struct iovec* iov, size_t iov_cnt);
-
-  // Given data from the byte source 'compressed' generated by calling
-  // the Snappy::Compress routine, this routine stores the uncompressed
-  // data to the iovec "iov". The number of physical
-  // buffers in "iov" is given by iov_cnt and their cumulative size
-  // must be at least GetUncompressedLength(compressed). The individual buffers
-  // in "iov" must not overlap with each other.
-  //
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
-                            size_t iov_cnt);
-
-  // Returns the maximal size of the compressed representation of
-  // input data that is "source_bytes" bytes in length;
-  size_t MaxCompressedLength(size_t source_bytes);
-
-  // REQUIRES: "compressed[]" was produced by RawCompress() or Compress()
-  // Returns true and stores the length of the uncompressed data in
-  // *result normally.  Returns false on parsing error.
-  // This operation takes O(1) time.
-  bool GetUncompressedLength(const char* compressed, size_t compressed_length,
-                             size_t* result);
-
-  // Returns true iff the contents of "compressed[]" can be uncompressed
-  // successfully.  Does not return the uncompressed data.  Takes
-  // time proportional to compressed_length, but is usually at least
-  // a factor of four faster than actual decompression.
-  bool IsValidCompressedBuffer(const char* compressed,
-                               size_t compressed_length);
-
-  // Returns true iff the contents of "compressed" can be uncompressed
-  // successfully.  Does not return the uncompressed data.  Takes
-  // time proportional to *compressed length, but is usually at least
-  // a factor of four faster than actual decompression.
-  // On success, consumes all of *compressed.  On failure, consumes an
-  // unspecified prefix of *compressed.
-  bool IsValidCompressed(Source* compressed);
-
-  // The size of a compression block. Note that many parts of the compression
-  // code assumes that kBlockSize <= 65536; in particular, the hash table
-  // can only store 16-bit offsets, and EmitCopy() also assumes the offset
-  // is 65535 bytes or less. Note also that if you change this, it will
-  // affect the framing format (see framing_format.txt).
-  //
-  // Note that there might be older data around that is compressed with larger
-  // block sizes, so the decompression code should not rely on the
-  // non-existence of long backreferences.
-  static constexpr int kBlockLog = 16;
-  static constexpr size_t kBlockSize = 1 << kBlockLog;
-
-  static constexpr int kMinHashTableBits = 8;
-  static constexpr size_t kMinHashTableSize = 1 << kMinHashTableBits;
-
-  static constexpr int kMaxHashTableBits = 15;
-  static constexpr size_t kMaxHashTableSize = 1 << kMaxHashTableBits;
-}  // end namespace duckdb_snappy
-
-#else // #if SNAPPY_NEW_VERSION
-
-#include <cstddef>
-#include <string>
-
-#include "snappy-stubs-public.h"
-
-namespace duckdb_snappy {
-  class Source;
-  class Sink;
-
-  // ------------------------------------------------------------------------
-  // Generic compression/decompression routines.
-  // ------------------------------------------------------------------------
-
-  // Compress the bytes read from "*source" and append to "*sink". Return the
-  // number of bytes written.
-  size_t Compress(Source* source, Sink* sink);
-
-  // Find the uncompressed length of the given stream, as given by the header.
-  // Note that the true length could deviate from this; the stream could e.g.
-  // be truncated.
-  //
-  // Also note that this leaves "*source" in a state that is unsuitable for
-  // further operations, such as RawUncompress(). You will need to rewind
-  // or recreate the source yourself before attempting any further calls.
-  bool GetUncompressedLength(Source* source, uint32* result);
-
-  // ------------------------------------------------------------------------
-  // Higher-level string based routines (should be sufficient for most users)
-  // ------------------------------------------------------------------------
-
-  // Sets "*output" to the compressed version of "input[0,input_length-1]".
-  // Original contents of *output are lost.
-  //
-  // REQUIRES: "input[]" is not an alias of "*output".
-  size_t Compress(const char* input, size_t input_length, string* output);
-
-  // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed".
-  // Original contents of "*uncompressed" are lost.
-  //
-  // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
-  //
-  // returns false if the message is corrupted and could not be decompressed
-  bool Uncompress(const char* compressed, size_t compressed_length,
-                  string* uncompressed);
-
-  // Decompresses "compressed" to "*uncompressed".
-  //
-  // returns false if the message is corrupted and could not be decompressed
-  bool Uncompress(Source* compressed, Sink* uncompressed);
-
-  // This routine uncompresses as much of the "compressed" as possible
-  // into sink.  It returns the number of valid bytes added to sink
-  // (extra invalid bytes may have been added due to errors; the caller
-  // should ignore those). The emitted data typically has length
-  // GetUncompressedLength(), but may be shorter if an error is
-  // encountered.
-  size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed);
-
-  // ------------------------------------------------------------------------
-  // Lower-level character array based routines.  May be useful for
-  // efficiency reasons in certain circumstances.
-  // ------------------------------------------------------------------------
-
-  // REQUIRES: "compressed" must point to an area of memory that is at
-  // least "MaxCompressedLength(input_length)" bytes in length.
-  //
-  // Takes the data stored in "input[0..input_length]" and stores
-  // it in the array pointed to by "compressed".
-  //
-  // "*compressed_length" is set to the length of the compressed output.
-  //
-  // Example:
-  //    char* output = new char[snappy::MaxCompressedLength(input_length)];
-  //    size_t output_length;
-  //    RawCompress(input, input_length, output, &output_length);
-  //    ... Process(output, output_length) ...
-  //    delete [] output;
-  void RawCompress(const char* input,
-                   size_t input_length,
-                   char* compressed,
-                   size_t* compressed_length);
-
-  // Given data in "compressed[0..compressed_length-1]" generated by
-  // calling the Snappy::Compress routine, this routine
-  // stores the uncompressed data to
-  //    uncompressed[0..GetUncompressedLength(compressed)-1]
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompress(const char* compressed, size_t compressed_length,
-                     char* uncompressed);
-
-  // Given data from the byte source 'compressed' generated by calling
-  // the Snappy::Compress routine, this routine stores the uncompressed
-  // data to
-  //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1]
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompress(Source* compressed, char* uncompressed);
-
-  // Given data in "compressed[0..compressed_length-1]" generated by
-  // calling the Snappy::Compress routine, this routine
-  // stores the uncompressed data to the iovec "iov". The number of physical
-  // buffers in "iov" is given by iov_cnt and their cumulative size
-  // must be at least GetUncompressedLength(compressed). The individual buffers
-  // in "iov" must not overlap with each other.
-  //
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompressToIOVec(const char* compressed, size_t compressed_length,
-                            const struct iovec* iov, size_t iov_cnt);
-
-  // Given data from the byte source 'compressed' generated by calling
-  // the Snappy::Compress routine, this routine stores the uncompressed
-  // data to the iovec "iov". The number of physical
-  // buffers in "iov" is given by iov_cnt and their cumulative size
-  // must be at least GetUncompressedLength(compressed). The individual buffers
-  // in "iov" must not overlap with each other.
-  //
-  // returns false if the message is corrupted and could not be decrypted
-  bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
-                            size_t iov_cnt);
-
-  // Returns the maximal size of the compressed representation of
-  // input data that is "source_bytes" bytes in length;
-  size_t MaxCompressedLength(size_t source_bytes);
-
-  // REQUIRES: "compressed[]" was produced by RawCompress() or Compress()
-  // Returns true and stores the length of the uncompressed data in
-  // *result normally.  Returns false on parsing error.
-  // This operation takes O(1) time.
-  bool GetUncompressedLength(const char* compressed, size_t compressed_length,
-                             size_t* result);
-
-  // Returns true iff the contents of "compressed[]" can be uncompressed
-  // successfully.  Does not return the uncompressed data.  Takes
-  // time proportional to compressed_length, but is usually at least
-  // a factor of four faster than actual decompression.
-  bool IsValidCompressedBuffer(const char* compressed,
-                               size_t compressed_length);
-
-  // Returns true iff the contents of "compressed" can be uncompressed
-  // successfully.  Does not return the uncompressed data.  Takes
-  // time proportional to *compressed length, but is usually at least
-  // a factor of four faster than actual decompression.
-  // On success, consumes all of *compressed.  On failure, consumes an
-  // unspecified prefix of *compressed.
-  bool IsValidCompressed(Source* compressed);
-
-}  // end namespace duckdb_snappy
-
-#endif  // #if SNAPPY_NEW_VERSION # else
-
-#endif  // THIRD_PARTY_SNAPPY_SNAPPY_H__
diff --git a/src/duckdb/third_party/snappy/snappy_version.hpp b/src/duckdb/third_party/snappy/snappy_version.hpp
deleted file mode 100644
index ef8b48b31..000000000
--- a/src/duckdb/third_party/snappy/snappy_version.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-//! The new version of snappy is much faster when compiled with clang, but slower when compiled with GCC
-//! For DuckDB, we default to the old version if the compiler is not clang
-#ifndef SNAPPY_NEW_VERSION
-#ifdef __clang__
-#define SNAPPY_NEW_VERSION true
-#else
-#define SNAPPY_NEW_VERSION false
-#endif
-#endif
diff --git a/src/duckdb/third_party/tdigest/t_digest.hpp b/src/duckdb/third_party/tdigest/t_digest.hpp
deleted file mode 100644
index a25668c08..000000000
--- a/src/duckdb/third_party/tdigest/t_digest.hpp
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
- * Licensed to Derrick R. Burns under one or more
- * contributor license agreements.  See the NOTICES file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <cfloat>
-#include <cmath>
-#include <queue>
-#include <utility>
-#include <vector>
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-
-namespace duckdb_tdigest {
-
-using Value = double;
-using Weight = double;
-using Index = size_t;
-
-const size_t kHighWater = 40000;
-const double pi = 3.14159265358979323846;
-class Centroid {
-public:
-	Centroid() : Centroid(0.0, 0.0) {
-	}
-
-	Centroid(Value mean, Weight weight) : mean_(mean), weight_(weight) {
-	}
-
-	inline Value mean() const noexcept {
-		return mean_;
-	}
-
-	inline Weight weight() const noexcept {
-		return weight_;
-	}
-
-	inline void add(const Centroid &c) {
-		//    CHECK_GT(c.weight_, 0);
-		if (weight_ != 0.0) {
-			weight_ += c.weight_;
-			mean_ += c.weight_ * (c.mean_ - mean_) / weight_;
-		} else {
-			weight_ = c.weight_;
-			mean_ = c.mean_;
-		}
-	}
-
-private:
-	Value mean_ = 0;
-	Weight weight_ = 0;
-};
-
-struct CentroidList {
-	explicit CentroidList(const std::vector<Centroid> &s) : iter(s.cbegin()), end(s.cend()) {
-	}
-	std::vector<Centroid>::const_iterator iter;
-	std::vector<Centroid>::const_iterator end;
-
-	bool advance() {
-		return ++iter != end;
-	}
-};
-
-class CentroidListComparator {
-public:
-	CentroidListComparator() {
-	}
-
-	bool operator()(const CentroidList &left, const CentroidList &right) const {
-		return left.iter->mean() > right.iter->mean();
-	}
-};
-
-using CentroidListQueue = std::priority_queue<CentroidList, std::vector<CentroidList>, CentroidListComparator>;
-
-struct CentroidComparator {
-	bool operator()(const Centroid &a, const Centroid &b) const {
-		return a.mean() < b.mean();
-	}
-};
-
-class TDigest {
-	class TDigestComparator {
-	public:
-		TDigestComparator() {
-		}
-
-		bool operator()(const TDigest *left, const TDigest *right) const {
-			return left->totalSize() > right->totalSize();
-		}
-	};
-
-	using TDigestQueue = std::priority_queue<const TDigest *, std::vector<const TDigest *>, TDigestComparator>;
-
-public:
-	TDigest() : TDigest(1000) {
-	}
-
-	explicit TDigest(Value compression) : TDigest(compression, 0) {
-	}
-
-	TDigest(Value compression, Index bufferSize) : TDigest(compression, bufferSize, 0) {
-	}
-
-	TDigest(Value compression, Index unmergedSize, Index mergedSize)
-	    : compression_(compression), maxProcessed_(processedSize(mergedSize, compression)),
-	      maxUnprocessed_(unprocessedSize(unmergedSize, compression)) {
-		processed_.reserve(maxProcessed_);
-		unprocessed_.reserve(maxUnprocessed_ + 1);
-	}
-
-	TDigest(std::vector<Centroid> &&processed, std::vector<Centroid> &&unprocessed, Value compression,
-	        Index unmergedSize, Index mergedSize)
-	    : TDigest(compression, unmergedSize, mergedSize) {
-		processed_ = std::move(processed);
-		unprocessed_ = std::move(unprocessed);
-
-		processedWeight_ = weight(processed_);
-		unprocessedWeight_ = weight(unprocessed_);
-		if (!processed_.empty()) {
-			min_ = std::min(min_, processed_[0].mean());
-			max_ = std::max(max_, (processed_.cend() - 1)->mean());
-		}
-		updateCumulative();
-	}
-
-	static Weight weight(std::vector<Centroid> &centroids) noexcept {
-		Weight w = 0.0;
-		for (auto centroid : centroids) {
-			w += centroid.weight();
-		}
-		return w;
-	}
-
-	TDigest &operator=(TDigest &&o) {
-		compression_ = o.compression_;
-		maxProcessed_ = o.maxProcessed_;
-		maxUnprocessed_ = o.maxUnprocessed_;
-		processedWeight_ = o.processedWeight_;
-		unprocessedWeight_ = o.unprocessedWeight_;
-		processed_ = std::move(o.processed_);
-		unprocessed_ = std::move(o.unprocessed_);
-		cumulative_ = std::move(o.cumulative_);
-		min_ = o.min_;
-		max_ = o.max_;
-		return *this;
-	}
-
-	TDigest(TDigest &&o)
-	    : TDigest(std::move(o.processed_), std::move(o.unprocessed_), o.compression_, o.maxUnprocessed_,
-	              o.maxProcessed_) {
-	}
-
-	static inline Index processedSize(Index size, Value compression) noexcept {
-		return (size == 0) ? static_cast<Index>(2 * std::ceil(compression)) : size;
-	}
-
-	static inline Index unprocessedSize(Index size, Value compression) noexcept {
-		return (size == 0) ? static_cast<Index>(8 * std::ceil(compression)) : size;
-	}
-
-	// merge in another t-digest
-	inline void merge(const TDigest *other) {
-		std::vector<const TDigest *> others {other};
-		add(others.cbegin(), others.cend());
-	}
-
-	const std::vector<Centroid> &processed() const {
-		return processed_;
-	}
-
-	const std::vector<Centroid> &unprocessed() const {
-		return unprocessed_;
-	}
-
-	Index maxUnprocessed() const {
-		return maxUnprocessed_;
-	}
-
-	Index maxProcessed() const {
-		return maxProcessed_;
-	}
-
-	inline void add(std::vector<const TDigest *> digests) {
-		add(digests.cbegin(), digests.cend());
-	}
-
-	// merge in a vector of tdigests in the most efficient manner possible
-	// in constant space
-	// works for any value of kHighWater
-	void add(std::vector<const TDigest *>::const_iterator iter, std::vector<const TDigest *>::const_iterator end) {
-		if (iter != end) {
-			auto size = std::distance(iter, end);
-			TDigestQueue pq(TDigestComparator {});
-			for (; iter != end; iter++) {
-				pq.push((*iter));
-			}
-			std::vector<const TDigest *> batch;
-			batch.reserve(size_t(size));
-
-			size_t totalSize = 0;
-			while (!pq.empty()) {
-				auto td = pq.top();
-				batch.push_back(td);
-				pq.pop();
-				totalSize += td->totalSize();
-				if (totalSize >= kHighWater || pq.empty()) {
-					mergeProcessed(batch);
-					mergeUnprocessed(batch);
-					processIfNecessary();
-					batch.clear();
-					totalSize = 0;
-				}
-			}
-			updateCumulative();
-		}
-	}
-
-	Weight processedWeight() const {
-		return processedWeight_;
-	}
-
-	Weight unprocessedWeight() const {
-		return unprocessedWeight_;
-	}
-
-	bool haveUnprocessed() const {
-		return unprocessed_.size() > 0;
-	}
-
-	size_t totalSize() const {
-		return processed_.size() + unprocessed_.size();
-	}
-
-	long totalWeight() const {
-		return static_cast<long>(processedWeight_ + unprocessedWeight_);
-	}
-
-	// return the cdf on the t-digest
-	Value cdf(Value x) {
-		if (haveUnprocessed() || isDirty()) {
-			process();
-		}
-		return cdfProcessed(x);
-	}
-
-	bool isDirty() {
-		return processed_.size() > maxProcessed_ || unprocessed_.size() > maxUnprocessed_;
-	}
-
-	// return the cdf on the processed values
-	Value cdfProcessed(Value x) const {
-		if (processed_.empty()) {
-			// no data to examin_e
-
-			return 0.0;
-		} else if (processed_.size() == 1) {
-			// exactly one centroid, should have max_==min_
-			auto width = max_ - min_;
-			if (x < min_) {
-				return 0.0;
-			} else if (x > max_) {
-				return 1.0;
-			} else if (x - min_ <= width) {
-				// min_ and max_ are too close together to do any viable interpolation
-				return 0.5;
-			} else {
-				// interpolate if somehow we have weight > 0 and max_ != min_
-				return (x - min_) / (max_ - min_);
-			}
-		} else {
-			auto n = processed_.size();
-			if (x <= min_) {
-				return 0;
-			}
-
-			if (x >= max_) {
-				return 1;
-			}
-
-			// check for the left tail
-			if (x <= mean(0)) {
-
-				// note that this is different than mean(0) > min_ ... this guarantees interpolation works
-				if (mean(0) - min_ > 0) {
-					return (x - min_) / (mean(0) - min_) * weight(0) / processedWeight_ / 2.0;
-				} else {
-					return 0;
-				}
-			}
-
-			// and the right tail
-			if (x >= mean(n - 1)) {
-				if (max_ - mean(n - 1) > 0) {
-					return 1.0 - (max_ - x) / (max_ - mean(n - 1)) * weight(n - 1) / processedWeight_ / 2.0;
-				} else {
-					return 1;
-				}
-			}
-
-			CentroidComparator cc;
-			auto iter = std::upper_bound(processed_.cbegin(), processed_.cend(), Centroid(x, 0), cc);
-
-			auto i = size_t(std::distance(processed_.cbegin(), iter));
-			auto z1 = x - (iter - 1)->mean();
-			auto z2 = (iter)->mean() - x;
-			return weightedAverage(cumulative_[i - 1], z2, cumulative_[i], z1) / processedWeight_;
-		}
-	}
-
-	// this returns a quantile on the t-digest
-	Value quantile(Value q) {
-		if (haveUnprocessed() || isDirty()) {
-			process();
-		}
-		return quantileProcessed(q);
-	}
-
-	// this returns a quantile on the currently processed values without changing the t-digest
-	// the value will not represent the unprocessed values
-	Value quantileProcessed(Value q) const {
-		if (q < 0 || q > 1) {
-			return NAN;
-		}
-
-		if (processed_.size() == 0) {
-			// no sorted means no data, no way to get a quantile
-			return NAN;
-		} else if (processed_.size() == 1) {
-			// with one data point, all quantiles lead to Rome
-
-			return mean(0);
-		}
-
-		// we know that there are at least two sorted now
-		auto n = processed_.size();
-
-		// if values were stored in a sorted array, index would be the offset we are Weighterested in
-		const auto index = q * processedWeight_;
-
-		// at the boundaries, we return min_ or max_
-		if (index <= weight(0) / 2.0) {
-			return min_ + 2.0 * index / weight(0) * (mean(0) - min_);
-		}
-
-		auto iter = std::lower_bound(cumulative_.cbegin(), cumulative_.cend(), index);
-
-		if (iter + 1 != cumulative_.cend()) {
-			auto i = size_t(std::distance(cumulative_.cbegin(), iter));
-			auto z1 = index - *(iter - 1);
-			auto z2 = *(iter)-index;
-			// LOG(INFO) << "z2 " << z2 << " index " << index << " z1 " << z1;
-			return weightedAverage(mean(i - 1), z2, mean(i), z1);
-		}
-		auto z1 = index - processedWeight_ - weight(n - 1) / 2.0;
-		auto z2 = weight(n - 1) / 2 - z1;
-		return weightedAverage(mean(n - 1), z1, max_, z2);
-	}
-
-	Value compression() const {
-		return compression_;
-	}
-
-	void add(Value x) {
-		add(x, 1);
-	}
-
-	inline void compress() {
-		process();
-	}
-
-	// add a single centroid to the unprocessed vector, processing previously unprocessed sorted if our limit has
-	// been reached.
-	inline bool add(Value x, Weight w) {
-		if (std::isnan(x)) {
-			return false;
-		}
-		unprocessed_.push_back(Centroid(x, w));
-		unprocessedWeight_ += w;
-		processIfNecessary();
-		return true;
-	}
-
-	inline void add(std::vector<Centroid>::const_iterator iter, std::vector<Centroid>::const_iterator end) {
-		while (iter != end) {
-			const size_t diff = size_t(std::distance(iter, end));
-			const size_t room = maxUnprocessed_ - unprocessed_.size();
-			auto mid = iter + int64_t(std::min(diff, room));
-			while (iter != mid) {
-				unprocessed_.push_back(*(iter++));
-			}
-			if (unprocessed_.size() >= maxUnprocessed_) {
-				process();
-			}
-		}
-	}
-
-private:
-	Value compression_;
-
-	Value min_ = std::numeric_limits<Value>::max();
-
-	Value max_ = std::numeric_limits<Value>::min();
-
-	Index maxProcessed_;
-
-	Index maxUnprocessed_;
-
-	Value processedWeight_ = 0.0;
-
-	Value unprocessedWeight_ = 0.0;
-
-	std::vector<Centroid> processed_;
-
-	std::vector<Centroid> unprocessed_;
-
-	std::vector<Weight> cumulative_;
-
-	// return mean of i-th centroid
-	inline Value mean(size_t i) const noexcept {
-		return processed_[i].mean();
-	}
-
-	// return weight of i-th centroid
-	inline Weight weight(size_t i) const noexcept {
-		return processed_[i].weight();
-	}
-
-	// append all unprocessed centroids into current unprocessed vector
-	void mergeUnprocessed(const std::vector<const TDigest *> &tdigests) {
-		if (tdigests.size() == 0) {
-			return;
-		}
-
-		size_t total = unprocessed_.size();
-		for (auto &td : tdigests) {
-			total += td->unprocessed_.size();
-		}
-
-		unprocessed_.reserve(total);
-		for (auto &td : tdigests) {
-			unprocessed_.insert(unprocessed_.end(), td->unprocessed_.cbegin(), td->unprocessed_.cend());
-			unprocessedWeight_ += td->unprocessedWeight_;
-		}
-	}
-
-	// merge all processed centroids together into a single sorted vector
-	void mergeProcessed(const std::vector<const TDigest *> &tdigests) {
-		if (tdigests.size() == 0) {
-			return;
-		}
-
-		size_t total = 0;
-		CentroidListQueue pq(CentroidListComparator {});
-		for (auto &td : tdigests) {
-			auto &sorted = td->processed_;
-			auto size = sorted.size();
-			if (size > 0) {
-				pq.push(CentroidList(sorted));
-				total += size;
-				processedWeight_ += td->processedWeight_;
-			}
-		}
-		if (total == 0) {
-			return;
-		}
-
-		if (processed_.size() > 0) {
-			pq.push(CentroidList(processed_));
-			total += processed_.size();
-		}
-
-		std::vector<Centroid> sorted;
-		sorted.reserve(total);
-
-		while (!pq.empty()) {
-			auto best = pq.top();
-			pq.pop();
-			sorted.push_back(*(best.iter));
-			if (best.advance()) {
-				pq.push(best);
-			}
-		}
-		processed_ = std::move(sorted);
-		if (processed_.size() > 0) {
-			min_ = std::min(min_, processed_[0].mean());
-			max_ = std::max(max_, (processed_.cend() - 1)->mean());
-		}
-	}
-
-	inline void processIfNecessary() {
-		if (isDirty()) {
-			process();
-		}
-	}
-
-	void updateCumulative() {
-		const auto n = processed_.size();
-		cumulative_.clear();
-		cumulative_.reserve(n + 1);
-		auto previous = 0.0;
-		for (Index i = 0; i < n; i++) {
-			auto current = weight(i);
-			auto halfCurrent = current / 2.0;
-			cumulative_.push_back(previous + halfCurrent);
-			previous = previous + current;
-		}
-		cumulative_.push_back(previous);
-	}
-
-	// merges unprocessed_ centroids and processed_ centroids together and processes them
-	// when complete, unprocessed_ will be empty and processed_ will have at most maxProcessed_ centroids
-	inline void process() {
-		CentroidComparator cc;
-		std::sort(unprocessed_.begin(), unprocessed_.end(), cc);
-		auto count = unprocessed_.size();
-		unprocessed_.insert(unprocessed_.end(), processed_.cbegin(), processed_.cend());
-		std::inplace_merge(unprocessed_.begin(), unprocessed_.begin() + int64_t(count), unprocessed_.end(), cc);
-
-		processedWeight_ += unprocessedWeight_;
-		unprocessedWeight_ = 0;
-		processed_.clear();
-
-		processed_.push_back(unprocessed_[0]);
-		Weight wSoFar = unprocessed_[0].weight();
-		Weight wLimit = processedWeight_ * integratedQ(1.0);
-
-		auto end = unprocessed_.end();
-		for (auto iter = unprocessed_.cbegin() + 1; iter < end; iter++) {
-			auto &centroid = *iter;
-			Weight projectedW = wSoFar + centroid.weight();
-			if (projectedW <= wLimit) {
-				wSoFar = projectedW;
-				(processed_.end() - 1)->add(centroid);
-			} else {
-				auto k1 = integratedLocation(wSoFar / processedWeight_);
-				wLimit = processedWeight_ * integratedQ(k1 + 1.0);
-				wSoFar += centroid.weight();
-				processed_.emplace_back(centroid);
-			}
-		}
-		unprocessed_.clear();
-		min_ = std::min(min_, processed_[0].mean());
-		max_ = std::max(max_, (processed_.cend() - 1)->mean());
-		updateCumulative();
-	}
-
-	inline size_t checkWeights() {
-		return checkWeights(processed_, processedWeight_);
-	}
-
-	size_t checkWeights(const std::vector<Centroid> &sorted, Value total) {
-		size_t badWeight = 0;
-		auto k1 = 0.0;
-		auto q = 0.0;
-		for (auto iter = sorted.cbegin(); iter != sorted.cend(); iter++) {
-			auto w = iter->weight();
-			auto dq = w / total;
-			auto k2 = integratedLocation(q + dq);
-			if (k2 - k1 > 1 && w != 1) {
-				badWeight++;
-			}
-			if (k2 - k1 > 1.5 && w != 1) {
-				badWeight++;
-			}
-			q += dq;
-			k1 = k2;
-		}
-
-		return badWeight;
-	}
-
-	/**
-	 * Converts a quantile into a centroid scale value.  The centroid scale is nomin_ally
-	 * the number k of the centroid that a quantile point q should belong to.  Due to
-	 * round-offs, however, we can't align things perfectly without splitting points
-	 * and sorted.  We don't want to do that, so we have to allow for offsets.
-	 * In the end, the criterion is that any quantile range that spans a centroid
-	 * scale range more than one should be split across more than one centroid if
-	 * possible.  This won't be possible if the quantile range refers to a single point
-	 * or an already existing centroid.
-	 * <p/>
-	 * This mapping is steep near q=0 or q=1 so each centroid there will correspond to
-	 * less q range.  Near q=0.5, the mapping is flatter so that sorted there will
-	 * represent a larger chunk of quantiles.
-	 *
-	 * @param q The quantile scale value to be mapped.
-	 * @return The centroid scale value corresponding to q.
-	 */
-	inline Value integratedLocation(Value q) const {
-		return compression_ * (std::asin(2.0 * q - 1.0) + pi / 2) / pi;
-	}
-
-	inline Value integratedQ(Value k) const {
-		return (std::sin(std::min(k, compression_) * pi / compression_ - pi / 2) + 1) / 2;
-	}
-
-	/**
-	 * Same as {@link #weightedAverageSorted(Value, Value, Value, Value)} but flips
-	 * the order of the variables if <code>x2</code> is greater than
-	 * <code>x1</code>.
-	 */
-	static Value weightedAverage(Value x1, Value w1, Value x2, Value w2) {
-		return (x1 <= x2) ? weightedAverageSorted(x1, w1, x2, w2) : weightedAverageSorted(x2, w2, x1, w1);
-	}
-
-	/**
-	 * Compute the weighted average between <code>x1</code> with a weight of
-	 * <code>w1</code> and <code>x2</code> with a weight of <code>w2</code>.
-	 * This expects <code>x1</code> to be less than or equal to <code>x2</code>
-	 * and is guaranteed to return a number between <code>x1</code> and
-	 * <code>x2</code>.
-	 */
-	static Value weightedAverageSorted(Value x1, Value w1, Value x2, Value w2) {
-		const Value x = (x1 * w1 + x2 * w2) / (w1 + w2);
-		return std::max(x1, std::min(x, x2));
-	}
-
-	static Value interpolate(Value x, Value x0, Value x1) {
-		return (x - x0) / (x1 - x0);
-	}
-
-	/**
-	 * Computes an interpolated value of a quantile that is between two sorted.
-	 *
-	 * Index is the quantile desired multiplied by the total number of samples - 1.
-	 *
-	 * @param index              Denormalized quantile desired
-	 * @param previousIndex      The denormalized quantile corresponding to the center of the previous centroid.
-	 * @param nextIndex          The denormalized quantile corresponding to the center of the following centroid.
-	 * @param previousMean       The mean of the previous centroid.
-	 * @param nextMean           The mean of the following centroid.
-	 * @return  The interpolated mean.
-	 */
-	static Value quantile(Value index, Value previousIndex, Value nextIndex, Value previousMean, Value nextMean) {
-		const auto delta = nextIndex - previousIndex;
-		const auto previousWeight = (nextIndex - index) / delta;
-		const auto nextWeight = (index - previousIndex) / delta;
-		return previousMean * previousWeight + nextMean * nextWeight;
-	}
-};
-
-} // namespace tdigest
diff --git a/src/duckdb/third_party/thrift/thrift/TApplicationException.h b/src/duckdb/third_party/thrift/thrift/TApplicationException.h
deleted file mode 100644
index f64d51043..000000000
--- a/src/duckdb/third_party/thrift/thrift/TApplicationException.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TAPPLICATIONEXCEPTION_H_
-#define _DUCKDB_THRIFT_TAPPLICATIONEXCEPTION_H_ 1
-
-#include "thrift/Thrift.h"
-
-namespace duckdb_apache {
-namespace thrift {
-
-namespace protocol {
-class TProtocol;
-}
-
-class TApplicationException : public TException {
-public:
-  /**
-   * Error codes for the various types of exceptions.
-   */
-  enum TApplicationExceptionType {
-    UNKNOWN = 0,
-    UNKNOWN_METHOD = 1,
-    INVALID_MESSAGE_TYPE = 2,
-    WRONG_METHOD_NAME = 3,
-    BAD_SEQUENCE_ID = 4,
-    MISSING_RESULT = 5,
-    INTERNAL_ERROR = 6,
-    PROTOCOL_ERROR = 7,
-    INVALID_TRANSFORM = 8,
-    INVALID_PROTOCOL = 9,
-    UNSUPPORTED_CLIENT_TYPE = 10
-  };
-
-  TApplicationException() : TException(), type_(UNKNOWN) {}
-
-  TApplicationException(TApplicationExceptionType type) : TException(), type_(type) {}
-
-  TApplicationException(const std::string& message) : TException(message), type_(UNKNOWN) {}
-
-  TApplicationException(TApplicationExceptionType type, const std::string& message)
-    : TException(message), type_(type) {}
-
-  ~TApplicationException() noexcept override = default;
-
-  /**
-   * Returns an error code that provides information about the type of error
-   * that has occurred.
-   *
-   * @return Error code
-   */
-  TApplicationExceptionType getType() const { return type_; }
-
-  const char* what() const noexcept override {
-    if (message_.empty()) {
-      switch (type_) {
-      case UNKNOWN:
-        return "TApplicationException: Unknown application exception";
-      case UNKNOWN_METHOD:
-        return "TApplicationException: Unknown method";
-      case INVALID_MESSAGE_TYPE:
-        return "TApplicationException: Invalid message type";
-      case WRONG_METHOD_NAME:
-        return "TApplicationException: Wrong method name";
-      case BAD_SEQUENCE_ID:
-        return "TApplicationException: Bad sequence identifier";
-      case MISSING_RESULT:
-        return "TApplicationException: Missing result";
-      case INTERNAL_ERROR:
-        return "TApplicationException: Internal error";
-      case PROTOCOL_ERROR:
-        return "TApplicationException: Protocol error";
-      case INVALID_TRANSFORM:
-        return "TApplicationException: Invalid transform";
-      case INVALID_PROTOCOL:
-        return "TApplicationException: Invalid protocol";
-      case UNSUPPORTED_CLIENT_TYPE:
-        return "TApplicationException: Unsupported client type";
-      default:
-        return "TApplicationException: (Invalid exception type)";
-      };
-    } else {
-      return message_.c_str();
-    }
-  }
-
-protected:
-  /**
-   * Error code
-   */
-  TApplicationExceptionType type_;
-};
-}
-} // duckdb_apache::thrift
-
-#endif // #ifndef _DUCKDB_THRIFT_TAPPLICATIONEXCEPTION_H_
diff --git a/src/duckdb/third_party/thrift/thrift/TBase.h b/src/duckdb/third_party/thrift/thrift/TBase.h
deleted file mode 100644
index 5b8cf493d..000000000
--- a/src/duckdb/third_party/thrift/thrift/TBase.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TBASE_H_
-#define _DUCKDB_THRIFT_TBASE_H_ 1
-
-#include "thrift/Thrift.h"
-#include "thrift/protocol/TProtocol.h"
-
-namespace duckdb_apache {
-namespace thrift {
-
-class TBase {
-public:
-  virtual ~TBase() = default;
-  virtual uint32_t read(protocol::TProtocol* iprot) = 0;
-  virtual uint32_t write(protocol::TProtocol* oprot) const = 0;
-};
-}
-} // duckdb_apache::thrift
-
-#endif // #ifndef _DUCKDB_THRIFT_TBASE_H_
diff --git a/src/duckdb/third_party/thrift/thrift/TLogging.h b/src/duckdb/third_party/thrift/thrift/TLogging.h
deleted file mode 100644
index 1f888e963..000000000
--- a/src/duckdb/third_party/thrift/thrift/TLogging.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TLOGGING_H_
-#define _DUCKDB_THRIFT_TLOGGING_H_ 1
-
-#include "thrift/thrift-config.h"
-
-/**
- * Contains utility macros for debugging and logging.
- *
- */
-
-#include <time.h>
-
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#endif
-
-/**
- * T_GLOBAL_DEBUGGING_LEVEL = 0: all debugging turned off, debug macros undefined
- * T_GLOBAL_DEBUGGING_LEVEL = 1: all debugging turned on
- */
-#define T_GLOBAL_DEBUGGING_LEVEL 0
-
-/**
- * T_GLOBAL_LOGGING_LEVEL = 0: all logging turned off, logging macros undefined
- * T_GLOBAL_LOGGING_LEVEL = 1: all logging turned on
- */
-#define T_GLOBAL_LOGGING_LEVEL 0
-
-/**
- * Standard wrapper around fprintf what will prefix the file name and line
- * number to the line. Uses T_GLOBAL_DEBUGGING_LEVEL to control whether it is
- * turned on or off.
- *
- * @param format_string
- */
-#if T_GLOBAL_DEBUGGING_LEVEL > 0
-#define T_DEBUG(format_string, ...)                                                                \
-  if (T_GLOBAL_DEBUGGING_LEVEL > 0) {                                                              \
-    fprintf(stderr, "[%s,%d] " format_string " \n", __FILE__, __LINE__, ##__VA_ARGS__);            \
-  }
-#else
-#define T_DEBUG(format_string, ...)
-#endif
-
-/**
- * analogous to T_DEBUG but also prints the time
- *
- * @param string  format_string input: printf style format string
- */
-#if T_GLOBAL_DEBUGGING_LEVEL > 0
-#define T_DEBUG_T(format_string, ...)                                                              \
-  {                                                                                                \
-    if (T_GLOBAL_DEBUGGING_LEVEL > 0) {                                                            \
-      time_t now;                                                                                  \
-      char dbgtime[26];                                                                            \
-      time(&now);                                                                                  \
-      THRIFT_CTIME_R(&now, dbgtime);                                                               \
-      dbgtime[24] = '\0';                                                                          \
-      fprintf(stderr,                                                                              \
-              "[%s,%d] [%s] " format_string " \n",                                                 \
-              __FILE__,                                                                            \
-              __LINE__,                                                                            \
-              dbgtime,                                                                             \
-              ##__VA_ARGS__);                                                                      \
-    }                                                                                              \
-  }
-#else
-#define T_DEBUG_T(format_string, ...)
-#endif
-
-
-
-
-
-/**
- * Log input message
- *
- * @param string  format_string input: printf style format string
- */
-#if T_GLOBAL_LOGGING_LEVEL > 0
-#define T_LOG_OPER(format_string, ...)                                                             \
-  {                                                                                                \
-    if (T_GLOBAL_LOGGING_LEVEL > 0) {                                                              \
-      time_t now;                                                                                  \
-      char dbgtime[26];                                                                            \
-      time(&now);                                                                                  \
-      THRIFT_CTIME_R(&now, dbgtime);                                                               \
-      dbgtime[24] = '\0';                                                                          \
-      fprintf(stderr, "[%s] " format_string " \n", dbgtime, ##__VA_ARGS__);                        \
-    }                                                                                              \
-  }
-#else
-#define T_LOG_OPER(format_string, ...)
-#endif
-
-/**
- * T_GLOBAL_DEBUG_VIRTUAL = 0 or unset: normal operation,
- *                                      virtual call debug messages disabled
- * T_GLOBAL_DEBUG_VIRTUAL = 1:          log a debug messages whenever an
- *                                      avoidable virtual call is made
- * T_GLOBAL_DEBUG_VIRTUAL = 2:          record detailed info that can be
- *                                      printed by calling
- *                                      duckdb_apache::thrift::profile_print_info()
- */
-#if T_GLOBAL_DEBUG_VIRTUAL > 1
-#define T_VIRTUAL_CALL() ::duckdb_apache::thrift::profile_virtual_call(typeid(*this))
-#define T_GENERIC_PROTOCOL(template_class, generic_prot, specific_prot)                            \
-  do {                                                                                             \
-    if (!(specific_prot)) {                                                                        \
-      ::duckdb_apache::thrift::profile_generic_protocol(typeid(*template_class), typeid(*generic_prot));  \
-    }                                                                                              \
-  } while (0)
-#elif T_GLOBAL_DEBUG_VIRTUAL == 1
-#define T_VIRTUAL_CALL() fprintf(stderr, "[%s,%d] virtual call\n", __FILE__, __LINE__)
-#define T_GENERIC_PROTOCOL(template_class, generic_prot, specific_prot)                            \
-  do {                                                                                             \
-    if (!(specific_prot)) {                                                                        \
-      fprintf(stderr, "[%s,%d] failed to cast to specific protocol type\n", __FILE__, __LINE__);   \
-    }                                                                                              \
-  } while (0)
-#else
-#define T_VIRTUAL_CALL()
-#define T_GENERIC_PROTOCOL(template_class, generic_prot, specific_prot)
-#endif
-
-#endif // #ifndef _DUCKDB_THRIFT_TLOGGING_H_
diff --git a/src/duckdb/third_party/thrift/thrift/TToString.h b/src/duckdb/third_party/thrift/thrift/TToString.h
deleted file mode 100644
index 38227012a..000000000
--- a/src/duckdb/third_party/thrift/thrift/TToString.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TOSTRING_H_
-#define _DUCKDB_THRIFT_TOSTRING_H_ 1
-
-#include <cmath>
-#include <limits>
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb_apache {
-namespace thrift {
-
-template <typename T>
-std::string to_string(const T& t) {
-  std::ostringstream o;
-  o << t;
-  return o.str();
-}
-
-// TODO: replace the computations below with std::numeric_limits::max_digits10 once C++11
-// is enabled.
-inline std::string to_string(const float& t) {
-  std::ostringstream o;
-  o.precision(static_cast<std::streamsize>(std::ceil(static_cast<double>(std::numeric_limits<float>::digits * std::log10(2.0f) + 1))));
-  o << t;
-  return o.str();
-}
-
-inline std::string to_string(const double& t) {
-  std::ostringstream o;
-  o.precision(static_cast<std::streamsize>(std::ceil(static_cast<double>(std::numeric_limits<double>::digits * std::log10(2.0f) + 1))));
-  o << t;
-  return o.str();
-}
-
-inline std::string to_string(const long double& t) {
-  std::ostringstream o;
-  o.precision(static_cast<std::streamsize>(std::ceil(static_cast<double>(std::numeric_limits<long double>::digits * std::log10(2.0f) + 1))));
-  o << t;
-  return o.str();
-}
-
-template <typename K, typename V>
-std::string to_string(const std::map<K, V>& m);
-
-template <typename T>
-std::string to_string(const std::set<T>& s);
-
-template <typename T>
-std::string to_string(const duckdb::vector<T>& t);
-
-template <typename K, typename V>
-std::string to_string(const typename std::pair<K, V>& v) {
-  std::ostringstream o;
-  o << to_string(v.first) << ": " << to_string(v.second);
-  return o.str();
-}
-
-template <typename T>
-std::string to_string(const T& beg, const T& end) {
-  std::ostringstream o;
-  for (T it = beg; it != end; ++it) {
-    if (it != beg)
-      o << ", ";
-    o << to_string(*it);
-  }
-  return o.str();
-}
-
-template <typename T>
-std::string to_string(const duckdb::vector<T>& t) {
-  std::ostringstream o;
-  o << "[" << to_string(t.begin(), t.end()) << "]";
-  return o.str();
-}
-
-template <typename K, typename V>
-std::string to_string(const std::map<K, V>& m) {
-  std::ostringstream o;
-  o << "{" << to_string(m.begin(), m.end()) << "}";
-  return o.str();
-}
-
-template <typename T>
-std::string to_string(const std::set<T>& s) {
-  std::ostringstream o;
-  o << "{" << to_string(s.begin(), s.end()) << "}";
-  return o.str();
-}
-}
-} // duckdb_apache::thrift
-
-#endif // _DUCKDB_THRIFT_TOSTRING_H_
diff --git a/src/duckdb/third_party/thrift/thrift/Thrift.h b/src/duckdb/third_party/thrift/thrift/Thrift.h
deleted file mode 100644
index e9315f785..000000000
--- a/src/duckdb/third_party/thrift/thrift/Thrift.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_THRIFT_H_
-#define _DUCKDB_THRIFT_THRIFT_H_ 1
-
-#include "thrift/transport/PlatformSocket.h"
-
-#include "thrift/thrift-config.h"
-
-#include <stdio.h>
-#include <assert.h>
-
-#include <sys/types.h>
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-#include <string>
-#include <map>
-#include <list>
-#include <set>
-#include <vector>
-#include <exception>
-#include <typeinfo>
-#include <cstddef>
-
-#include "thrift/TLogging.h"
-//#include <thrift/TOutput.h>
-
-#define THRIFT_UNUSED_VARIABLE(x) ((void)(x))
-
-namespace duckdb_apache {
-namespace thrift {
-
-class TEnumIterator {
-public:
-  using value_type = std::pair<int, const char*>;
-  using difference_type = std::ptrdiff_t;
-  using pointer = value_type*;
-  using reference = value_type&;
-  using iterator_category = std::forward_iterator_tag;
-
-  TEnumIterator(int n, int* enums, const char** names)
-    : ii_(0), n_(n), enums_(enums), names_(names) {}
-
-  int operator++() { return ++ii_; }
-
-  bool operator!=(const TEnumIterator& end) {
-    THRIFT_UNUSED_VARIABLE(end);
-    assert(end.n_ == -1);
-    return (ii_ != n_);
-  }
-
-  std::pair<int, const char*> operator*() const { return std::make_pair(enums_[ii_], names_[ii_]); }
-
-private:
-  int ii_;
-  const int n_;
-  int* enums_;
-  const char** names_;
-};
-
-class TException : public std::exception {
-public:
-  TException() : message_() {}
-
-  TException(const std::string& message) : message_(message) {}
-
-  ~TException() noexcept override = default;
-
-  const char* what() const noexcept override {
-    if (message_.empty()) {
-      return "Default TException.";
-    } else {
-      return message_.c_str();
-    }
-  }
-
-protected:
-  std::string message_;
-};
-
-class TDelayedException {
-public:
-  template <class E>
-  static TDelayedException* delayException(const E& e);
-  virtual void throw_it() = 0;
-  virtual ~TDelayedException() = default;
-};
-
-template <class E>
-class TExceptionWrapper : public TDelayedException {
-public:
-  TExceptionWrapper(const E& e) : e_(e) {}
-  void throw_it() override {
-    E temp(e_);
-    delete this;
-    throw temp;
-  }
-
-private:
-  E e_;
-};
-
-template <class E>
-TDelayedException* TDelayedException::delayException(const E& e) {
-  return new TExceptionWrapper<E>(e);
-}
-
-#if T_GLOBAL_DEBUG_VIRTUAL > 1
-void profile_virtual_call(const std::type_info& info);
-void profile_generic_protocol(const std::type_info& template_type, const std::type_info& prot_type);
-void profile_print_info(FILE* f);
-void profile_print_info();
-void profile_write_pprof(FILE* gen_calls_f, FILE* virtual_calls_f);
-#endif
-}
-} // duckdb_apache::thrift
-
-#endif // #ifndef _DUCKDB_THRIFT_THRIFT_H_
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.h b/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.h
deleted file mode 100644
index e250076a8..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.h
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_PROTOCOL_TCOMPACTPROTOCOL_H_
-#define _DUCKDB_THRIFT_PROTOCOL_TCOMPACTPROTOCOL_H_ 1
-
-#include "thrift/protocol/TVirtualProtocol.h"
-
-#include <stack>
-#include <memory>
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-
-/**
- * C++ Implementation of the Compact Protocol as described in THRIFT-110
- */
-template <class Transport_>
-class TCompactProtocolT : public TVirtualProtocol<TCompactProtocolT<Transport_> > {
-public:
-  static const int8_t PROTOCOL_ID = (int8_t)0x82u;
-  static const int8_t VERSION_N = 1;
-  static const int8_t VERSION_MASK = 0x1f;       // 0001 1111
-
-protected:
-  static const int8_t TYPE_MASK = (int8_t)0xE0u; // 1110 0000
-  static const int8_t TYPE_BITS = 0x07;          // 0000 0111
-  static const int32_t TYPE_SHIFT_AMOUNT = 5;
-
-  Transport_* trans_;
-
-  /**
-   * (Writing) If we encounter a boolean field begin, save the TField here
-   * so it can have the value incorporated.
-   */
-  struct {
-    const char* name;
-    TType fieldType;
-    int16_t fieldId;
-  } booleanField_;
-
-  /**
-   * (Reading) If we read a field header, and it's a boolean field, save
-   * the boolean value here so that readBool can use it.
-   */
-  struct {
-    bool hasBoolValue;
-    bool boolValue;
-  } boolValue_;
-
-  /**
-   * Used to keep track of the last field for the current and previous structs,
-   * so we can do the delta stuff.
-   */
-
-  std::stack<int16_t> lastField_;
-  int16_t lastFieldId_;
-
-public:
-  TCompactProtocolT(std::shared_ptr<Transport_> trans)
-    : TVirtualProtocol<TCompactProtocolT<Transport_> >(trans),
-      trans_(trans.get()),
-      lastFieldId_(0),
-      string_limit_(0),
-      string_buf_(nullptr),
-      string_buf_size_(0),
-      container_limit_(0) {
-    booleanField_.name = nullptr;
-    boolValue_.hasBoolValue = false;
-  }
-
-  TCompactProtocolT(std::shared_ptr<Transport_> trans,
-                    int32_t string_limit,
-                    int32_t container_limit)
-    : TVirtualProtocol<TCompactProtocolT<Transport_> >(trans),
-      trans_(trans.get()),
-      lastFieldId_(0),
-      string_limit_(string_limit),
-      string_buf_(nullptr),
-      string_buf_size_(0),
-      container_limit_(container_limit) {
-    booleanField_.name = nullptr;
-    boolValue_.hasBoolValue = false;
-  }
-
-  ~TCompactProtocolT() override { free(string_buf_); }
-
-  /**
-   * Writing functions
-   */
-
-  virtual uint32_t writeMessageBegin(const std::string& name,
-                                     const TMessageType messageType,
-                                     const int32_t seqid);
-
-  uint32_t writeStructBegin(const char* name);
-
-  uint32_t writeStructEnd();
-
-  uint32_t writeFieldBegin(const char* name, const TType fieldType, const int16_t fieldId);
-
-  uint32_t writeFieldStop();
-
-  uint32_t writeListBegin(const TType elemType, const uint32_t size);
-
-  uint32_t writeSetBegin(const TType elemType, const uint32_t size);
-
-  virtual uint32_t writeMapBegin(const TType keyType, const TType valType, const uint32_t size);
-
-  uint32_t writeBool(const bool value);
-
-  uint32_t writeByte(const int8_t byte);
-
-  uint32_t writeI16(const int16_t i16);
-
-  uint32_t writeI32(const int32_t i32);
-
-  uint32_t writeI64(const int64_t i64);
-
-  uint32_t writeDouble(const double dub);
-
-  uint32_t writeString(const std::string& str);
-
-  uint32_t writeBinary(const std::string& str);
-
-  /**
-  * These methods are called by structs, but don't actually have any wired
-  * output or purpose
-  */
-  virtual uint32_t writeMessageEnd() { return 0; }
-  uint32_t writeMapEnd() { return 0; }
-  uint32_t writeListEnd() { return 0; }
-  uint32_t writeSetEnd() { return 0; }
-  uint32_t writeFieldEnd() { return 0; }
-
-protected:
-  int32_t writeFieldBeginInternal(const char* name,
-                                  const TType fieldType,
-                                  const int16_t fieldId,
-                                  int8_t typeOverride);
-  uint32_t writeCollectionBegin(const TType elemType, int32_t size);
-  uint32_t writeVarint32(uint32_t n);
-  uint32_t writeVarint64(uint64_t n);
-  uint64_t i64ToZigzag(const int64_t l);
-  uint32_t i32ToZigzag(const int32_t n);
-  inline int8_t getCompactType(const TType ttype);
-
-public:
-  uint32_t readMessageBegin(std::string& name, TMessageType& messageType, int32_t& seqid);
-
-  uint32_t readStructBegin(std::string& name);
-
-  uint32_t readStructEnd();
-
-  uint32_t readFieldBegin(std::string& name, TType& fieldType, int16_t& fieldId);
-
-  uint32_t readMapBegin(TType& keyType, TType& valType, uint32_t& size);
-
-  uint32_t readListBegin(TType& elemType, uint32_t& size);
-
-  uint32_t readSetBegin(TType& elemType, uint32_t& size);
-
-  uint32_t readBool(bool& value);
-  // Provide the default readBool() implementation for std::vector<bool>
-  using TVirtualProtocol<TCompactProtocolT<Transport_> >::readBool;
-
-  uint32_t readByte(int8_t& byte);
-
-  uint32_t readI16(int16_t& i16);
-
-  uint32_t readI32(int32_t& i32);
-
-  uint32_t readI64(int64_t& i64);
-
-  uint32_t readDouble(double& dub);
-
-  uint32_t readString(std::string& str);
-
-  uint32_t readBinary(std::string& str);
-
-  /*
-   *These methods are here for the struct to call, but don't have any wire
-   * encoding.
-   */
-  uint32_t readMessageEnd() { return 0; }
-  uint32_t readFieldEnd() { return 0; }
-  uint32_t readMapEnd() { return 0; }
-  uint32_t readListEnd() { return 0; }
-  uint32_t readSetEnd() { return 0; }
-
-protected:
-  uint32_t readVarint32(int32_t& i32);
-  uint32_t readVarint64(int64_t& i64);
-  int32_t zigzagToI32(uint32_t n);
-  int64_t zigzagToI64(uint64_t n);
-  TType getTType(int8_t type);
-
-  // Buffer for reading strings, save for the lifetime of the protocol to
-  // avoid memory churn allocating memory on every string read
-  int32_t string_limit_;
-  uint8_t* string_buf_;
-  int32_t string_buf_size_;
-  int32_t container_limit_;
-};
-
-typedef TCompactProtocolT<TTransport> TCompactProtocol;
-
-/**
- * Constructs compact protocol handlers
- */
-template <class Transport_>
-class TCompactProtocolFactoryT : public TProtocolFactory {
-public:
-  TCompactProtocolFactoryT() : string_limit_(0), container_limit_(0) {}
-
-  TCompactProtocolFactoryT(int32_t string_limit, int32_t container_limit)
-    : string_limit_(string_limit), container_limit_(container_limit) {}
-
-  ~TCompactProtocolFactoryT() override = default;
-
-  void setStringSizeLimit(int32_t string_limit) { string_limit_ = string_limit; }
-
-  void setContainerSizeLimit(int32_t container_limit) { container_limit_ = container_limit; }
-
-  std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) override {
-    std::shared_ptr<Transport_> specific_trans = std::static_pointer_cast<Transport_>(trans);
-    TProtocol* prot;
-    if (specific_trans) {
-      prot = new TCompactProtocolT<Transport_>(specific_trans, string_limit_, container_limit_);
-    } else {
-      prot = new TCompactProtocol(trans, string_limit_, container_limit_);
-    }
-
-    return std::shared_ptr<TProtocol>(prot);
-  }
-
-private:
-  int32_t string_limit_;
-  int32_t container_limit_;
-};
-
-typedef TCompactProtocolFactoryT<TTransport> TCompactProtocolFactory;
-}
-}
-} // duckdb_apache::thrift::protocol
-
-#include "thrift/protocol/TCompactProtocol.tcc"
-
-#endif
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.tcc b/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.tcc
deleted file mode 100644
index e22e7214a..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.tcc
+++ /dev/null
@@ -1,826 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-#ifndef _DUCKDB_THRIFT_PROTOCOL_TCOMPACTPROTOCOL_TCC_
-#define _DUCKDB_THRIFT_PROTOCOL_TCOMPACTPROTOCOL_TCC_ 1
-
-#include <limits>
-
-/*
- * TCompactProtocol::i*ToZigzag depend on the fact that the right shift
- * operator on a signed integer is an arithmetic (sign-extending) shift.
- * If this is not the case, the current implementation will not work.
- * If anyone encounters this error, we can try to figure out the best
- * way to implement an arithmetic right shift on their platform.
- */
-#if !defined(SIGNED_RIGHT_SHIFT_IS) || !defined(ARITHMETIC_RIGHT_SHIFT)
-# error "Unable to determine the behavior of a signed right shift"
-#endif
-#if SIGNED_RIGHT_SHIFT_IS != ARITHMETIC_RIGHT_SHIFT
-# error "TCompactProtocol currently only works if a signed right shift is arithmetic"
-#endif
-
-#ifndef UNLIKELY
-#ifdef __GNUC__
-#define UNLIKELY(val) (__builtin_expect((val), 0))
-#else
-#define UNLIKELY(val) (val)
-#endif
-#endif
-
-namespace duckdb_apache { namespace thrift { namespace protocol {
-
-namespace detail { namespace compact {
-
-enum Types {
-  CT_STOP           = 0x00,
-  CT_BOOLEAN_TRUE   = 0x01,
-  CT_BOOLEAN_FALSE  = 0x02,
-  CT_BYTE           = 0x03,
-  CT_I16            = 0x04,
-  CT_I32            = 0x05,
-  CT_I64            = 0x06,
-  CT_DOUBLE         = 0x07,
-  CT_BINARY         = 0x08,
-  CT_LIST           = 0x09,
-  CT_SET            = 0x0A,
-  CT_MAP            = 0x0B,
-  CT_STRUCT         = 0x0C
-};
-
-const int8_t TTypeToCType[16] = {
-  CT_STOP, // T_STOP
-  0, // unused
-  CT_BOOLEAN_TRUE, // T_BOOL
-  CT_BYTE, // T_BYTE
-  CT_DOUBLE, // T_DOUBLE
-  0, // unused
-  CT_I16, // T_I16
-  0, // unused
-  CT_I32, // T_I32
-  0, // unused
-  CT_I64, // T_I64
-  CT_BINARY, // T_STRING
-  CT_STRUCT, // T_STRUCT
-  CT_MAP, // T_MAP
-  CT_SET, // T_SET
-  CT_LIST, // T_LIST
-};
-
-}} // end detail::compact namespace
-
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeMessageBegin(
-    const std::string& name,
-    const TMessageType messageType,
-    const int32_t seqid) {
-  uint32_t wsize = 0;
-  wsize += writeByte(PROTOCOL_ID);
-  wsize += writeByte((VERSION_N & VERSION_MASK) | (((int32_t)messageType << TYPE_SHIFT_AMOUNT) & TYPE_MASK));
-  wsize += writeVarint32(seqid);
-  wsize += writeString(name);
-  return wsize;
-}
-
-/**
- * Write a field header containing the field id and field type. If the
- * difference between the current field id and the last one is small (< 15),
- * then the field id will be encoded in the 4 MSB as a delta. Otherwise, the
- * field id will follow the type header as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeFieldBegin(const char* name,
-                                                        const TType fieldType,
-                                                        const int16_t fieldId) {
-  if (fieldType == T_BOOL) {
-    booleanField_.name = name;
-    booleanField_.fieldType = fieldType;
-    booleanField_.fieldId = fieldId;
-  } else {
-    return writeFieldBeginInternal(name, fieldType, fieldId, -1);
-  }
-  return 0;
-}
-
-/**
- * Write the STOP symbol so we know there are no more fields in this struct.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeFieldStop() {
-  return writeByte(T_STOP);
-}
-
-/**
- * Write a struct begin. This doesn't actually put anything on the wire. We
- * use it as an opportunity to put special placeholder markers on the field
- * stack so we can get the field id deltas correct.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeStructBegin(const char* name) {
-  (void) name;
-  lastField_.push(lastFieldId_);
-  lastFieldId_ = 0;
-  return 0;
-}
-
-/**
- * Write a struct end. This doesn't actually put anything on the wire. We use
- * this as an opportunity to pop the last field from the current struct off
- * of the field stack.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeStructEnd() {
-  lastFieldId_ = lastField_.top();
-  lastField_.pop();
-  return 0;
-}
-
-/**
- * Write a List header.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeListBegin(const TType elemType,
-                                                       const uint32_t size) {
-  return writeCollectionBegin(elemType, size);
-}
-
-/**
- * Write a set header.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeSetBegin(const TType elemType,
-                                                      const uint32_t size) {
-  return writeCollectionBegin(elemType, size);
-}
-
-/**
- * Write a map header. If the map is empty, omit the key and value type
- * headers, as we don't need any additional information to skip it.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeMapBegin(const TType keyType,
-                                                      const TType valType,
-                                                      const uint32_t size) {
-  uint32_t wsize = 0;
-
-  if (size == 0) {
-    wsize += writeByte(0);
-  } else {
-    wsize += writeVarint32(size);
-    wsize += writeByte(getCompactType(keyType) << 4 | getCompactType(valType));
-  }
-  return wsize;
-}
-
-/**
- * Write a boolean value. Potentially, this could be a boolean field, in
- * which case the field header info isn't written yet. If so, decide what the
- * right type header is for the value and then write the field header.
- * Otherwise, write a single byte.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeBool(const bool value) {
-  uint32_t wsize = 0;
-
-  if (booleanField_.name != NULL) {
-    // we haven't written the field header yet
-    wsize
-      += writeFieldBeginInternal(booleanField_.name,
-                                 booleanField_.fieldType,
-                                 booleanField_.fieldId,
-                                 static_cast<int8_t>(value
-                                                     ? detail::compact::CT_BOOLEAN_TRUE
-                                                     : detail::compact::CT_BOOLEAN_FALSE));
-    booleanField_.name = NULL;
-  } else {
-    // we're not part of a field, so just write the value
-    wsize
-      += writeByte(static_cast<int8_t>(value
-                                       ? detail::compact::CT_BOOLEAN_TRUE
-                                       : detail::compact::CT_BOOLEAN_FALSE));
-  }
-  return wsize;
-}
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeByte(const int8_t byte) {
-  trans_->write((uint8_t*)&byte, 1);
-  return 1;
-}
-
-/**
- * Write an i16 as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeI16(const int16_t i16) {
-  return writeVarint32(i32ToZigzag(i16));
-}
-
-/**
- * Write an i32 as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeI32(const int32_t i32) {
-  return writeVarint32(i32ToZigzag(i32));
-}
-
-/**
- * Write an i64 as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeI64(const int64_t i64) {
-  return writeVarint64(i64ToZigzag(i64));
-}
-
-/**
- * Write a double to the wire as 8 bytes.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeDouble(const double dub) {
-  //BOOST_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t));
-  //BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559);
-
-  uint64_t bits = bitwise_cast<uint64_t>(dub);
-  bits = THRIFT_htolell(bits);
-  trans_->write((uint8_t*)&bits, 8);
-  return 8;
-}
-
-/**
- * Write a string to the wire with a varint size preceding.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeString(const std::string& str) {
-  return writeBinary(str);
-}
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeBinary(const std::string& str) {
-  if(str.size() > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  uint32_t ssize = static_cast<uint32_t>(str.size());
-  uint32_t wsize = writeVarint32(ssize) ;
-  // checking ssize + wsize > uint_max, but we don't want to overflow while checking for overflows.
-  // transforming the check to ssize > uint_max - wsize
-  if(ssize > (std::numeric_limits<uint32_t>::max)() - wsize)
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  wsize += ssize;
-  trans_->write((uint8_t*)str.data(), ssize);
-  return wsize;
-}
-
-//
-// Internal Writing methods
-//
-
-/**
- * The workhorse of writeFieldBegin. It has the option of doing a
- * 'type override' of the type header. This is used specifically in the
- * boolean field case.
- */
-template <class Transport_>
-int32_t TCompactProtocolT<Transport_>::writeFieldBeginInternal(
-    const char* name,
-    const TType fieldType,
-    const int16_t fieldId,
-    int8_t typeOverride) {
-  (void) name;
-  uint32_t wsize = 0;
-
-  // if there's a type override, use that.
-  int8_t typeToWrite = (typeOverride == -1 ? getCompactType(fieldType) : typeOverride);
-
-  // check if we can use delta encoding for the field id
-  if (fieldId > lastFieldId_ && fieldId - lastFieldId_ <= 15) {
-    // write them together
-    wsize += writeByte(static_cast<int8_t>((fieldId - lastFieldId_)
-                                           << 4 | typeToWrite));
-  } else {
-    // write them separate
-    wsize += writeByte(typeToWrite);
-    wsize += writeI16(fieldId);
-  }
-
-  lastFieldId_ = fieldId;
-  return wsize;
-}
-
-/**
- * Abstract method for writing the start of lists and sets. List and sets on
- * the wire differ only by the type indicator.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeCollectionBegin(const TType elemType,
-                                                             int32_t size) {
-  uint32_t wsize = 0;
-  if (size <= 14) {
-    wsize += writeByte(static_cast<int8_t>(size
-                                           << 4 | getCompactType(elemType)));
-  } else {
-    wsize += writeByte(0xf0 | getCompactType(elemType));
-    wsize += writeVarint32(size);
-  }
-  return wsize;
-}
-
-/**
- * Write an i32 as a varint. Results in 1-5 bytes on the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeVarint32(uint32_t n) {
-  uint8_t buf[5];
-  uint32_t wsize = 0;
-
-  while (true) {
-    if ((n & ~0x7F) == 0) {
-      buf[wsize++] = (int8_t)n;
-      break;
-    } else {
-      buf[wsize++] = (int8_t)((n & 0x7F) | 0x80);
-      n >>= 7;
-    }
-  }
-  trans_->write(buf, wsize);
-  return wsize;
-}
-
-/**
- * Write an i64 as a varint. Results in 1-10 bytes on the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeVarint64(uint64_t n) {
-  uint8_t buf[10];
-  uint32_t wsize = 0;
-
-  while (true) {
-    if ((n & ~0x7FL) == 0) {
-      buf[wsize++] = (int8_t)n;
-      break;
-    } else {
-      buf[wsize++] = (int8_t)((n & 0x7F) | 0x80);
-      n >>= 7;
-    }
-  }
-  trans_->write(buf, wsize);
-  return wsize;
-}
-
-/**
- * Convert l into a zigzag long. This allows negative numbers to be
- * represented compactly as a varint.
- */
-template <class Transport_>
-uint64_t TCompactProtocolT<Transport_>::i64ToZigzag(const int64_t l) {
-  return (static_cast<uint64_t>(l) << 1) ^ (l >> 63);
-}
-
-/**
- * Convert n into a zigzag int. This allows negative numbers to be
- * represented compactly as a varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::i32ToZigzag(const int32_t n) {
-  return (static_cast<uint32_t>(n) << 1) ^ (n >> 31);
-}
-
-/**
- * Given a TType value, find the appropriate detail::compact::Types value
- */
-template <class Transport_>
-int8_t TCompactProtocolT<Transport_>::getCompactType(const TType ttype) {
-  return detail::compact::TTypeToCType[ttype];
-}
-
-//
-// Reading Methods
-//
-
-/**
- * Read a message header.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readMessageBegin(
-    std::string& name,
-    TMessageType& messageType,
-    int32_t& seqid) {
-  uint32_t rsize = 0;
-  int8_t protocolId;
-  int8_t versionAndType;
-  int8_t version;
-
-  rsize += readByte(protocolId);
-  if (protocolId != PROTOCOL_ID) {
-    throw TProtocolException(TProtocolException::BAD_VERSION, "Bad protocol identifier");
-  }
-
-  rsize += readByte(versionAndType);
-  version = (int8_t)(versionAndType & VERSION_MASK);
-  if (version != VERSION_N) {
-    throw TProtocolException(TProtocolException::BAD_VERSION, "Bad protocol version");
-  }
-
-  messageType = (TMessageType)((versionAndType >> TYPE_SHIFT_AMOUNT) & TYPE_BITS);
-  rsize += readVarint32(seqid);
-  rsize += readString(name);
-
-  return rsize;
-}
-
-/**
- * Read a struct begin. There's nothing on the wire for this, but it is our
- * opportunity to push a new struct begin marker on the field stack.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readStructBegin(std::string& name) {
-  name = "";
-  lastField_.push(lastFieldId_);
-  lastFieldId_ = 0;
-  return 0;
-}
-
-/**
- * Doesn't actually consume any wire data, just removes the last field for
- * this struct from the field stack.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readStructEnd() {
-  lastFieldId_ = lastField_.top();
-  lastField_.pop();
-  return 0;
-}
-
-/**
- * Read a field header off the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readFieldBegin(std::string& name,
-                                                       TType& fieldType,
-                                                       int16_t& fieldId) {
-  (void) name;
-  uint32_t rsize = 0;
-  int8_t byte;
-  int8_t type;
-
-  rsize += readByte(byte);
-  type = (byte & 0x0f);
-
-  // if it's a stop, then we can return immediately, as the struct is over.
-  if (type == T_STOP) {
-    fieldType = T_STOP;
-    fieldId = 0;
-    return rsize;
-  }
-
-  // mask off the 4 MSB of the type header. it could contain a field id delta.
-  int16_t modifier = (int16_t)(((uint8_t)byte & 0xf0) >> 4);
-  if (modifier == 0) {
-    // not a delta, look ahead for the zigzag varint field id.
-    rsize += readI16(fieldId);
-  } else {
-    fieldId = (int16_t)(lastFieldId_ + modifier);
-  }
-  fieldType = getTType(type);
-
-  // if this happens to be a boolean field, the value is encoded in the type
-  if (type == detail::compact::CT_BOOLEAN_TRUE ||
-      type == detail::compact::CT_BOOLEAN_FALSE) {
-    // save the boolean value in a special instance variable.
-    boolValue_.hasBoolValue = true;
-    boolValue_.boolValue =
-      (type == detail::compact::CT_BOOLEAN_TRUE ? true : false);
-  }
-
-  // push the new field onto the field stack so we can keep the deltas going.
-  lastFieldId_ = fieldId;
-  return rsize;
-}
-
-/**
- * Read a map header off the wire. If the size is zero, skip reading the key
- * and value type. This means that 0-length maps will yield TMaps without the
- * "correct" types.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readMapBegin(TType& keyType,
-                                                     TType& valType,
-                                                     uint32_t& size) {
-  uint32_t rsize = 0;
-  int8_t kvType = 0;
-  int32_t msize = 0;
-
-  rsize += readVarint32(msize);
-  if (msize != 0)
-    rsize += readByte(kvType);
-
-  if (msize < 0) {
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && msize > container_limit_) {
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-
-  keyType = getTType((int8_t)((uint8_t)kvType >> 4));
-  valType = getTType((int8_t)((uint8_t)kvType & 0xf));
-  size = (uint32_t)msize;
-
-  return rsize;
-}
-
-/**
- * Read a list header off the wire. If the list size is 0-14, the size will
- * be packed into the element type header. If it's a longer list, the 4 MSB
- * of the element type header will be 0xF, and a varint will follow with the
- * true size.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readListBegin(TType& elemType,
-                                                      uint32_t& size) {
-  int8_t size_and_type;
-  uint32_t rsize = 0;
-  int32_t lsize;
-
-  rsize += readByte(size_and_type);
-
-  lsize = ((uint8_t)size_and_type >> 4) & 0x0f;
-  if (lsize == 15) {
-    rsize += readVarint32(lsize);
-  }
-
-  if (lsize < 0) {
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && lsize > container_limit_) {
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-
-  elemType = getTType((int8_t)(size_and_type & 0x0f));
-  size = (uint32_t)lsize;
-
-  return rsize;
-}
-
-/**
- * Read a set header off the wire. If the set size is 0-14, the size will
- * be packed into the element type header. If it's a longer set, the 4 MSB
- * of the element type header will be 0xF, and a varint will follow with the
- * true size.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readSetBegin(TType& elemType,
-                                                     uint32_t& size) {
-  return readListBegin(elemType, size);
-}
-
-/**
- * Read a boolean off the wire. If this is a boolean field, the value should
- * already have been read during readFieldBegin, so we'll just consume the
- * pre-stored value. Otherwise, read a byte.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readBool(bool& value) {
-  if (boolValue_.hasBoolValue == true) {
-    value = boolValue_.boolValue;
-    boolValue_.hasBoolValue = false;
-    return 0;
-  } else {
-    int8_t val;
-    readByte(val);
-    value = (val == detail::compact::CT_BOOLEAN_TRUE);
-    return 1;
-  }
-}
-
-/**
- * Read a single byte off the wire. Nothing interesting here.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readByte(int8_t& byte) {
-  uint8_t b[1];
-  trans_->readAll(b, 1);
-  byte = *(int8_t*)b;
-  return 1;
-}
-
-/**
- * Read an i16 from the wire as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readI16(int16_t& i16) {
-  int32_t value;
-  uint32_t rsize = readVarint32(value);
-  i16 = (int16_t)zigzagToI32(value);
-  return rsize;
-}
-
-/**
- * Read an i32 from the wire as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readI32(int32_t& i32) {
-  int32_t value;
-  uint32_t rsize = readVarint32(value);
-  i32 = zigzagToI32(value);
-  return rsize;
-}
-
-/**
- * Read an i64 from the wire as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readI64(int64_t& i64) {
-  int64_t value;
-  uint32_t rsize = readVarint64(value);
-  i64 = zigzagToI64(value);
-  return rsize;
-}
-
-/**
- * No magic here - just read a double off the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readDouble(double& dub) {
-  //BOOST_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t));
-  //BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559);
-
-  union {
-    uint64_t bits;
-    uint8_t b[8];
-  } u;
-  trans_->readAll(u.b, 8);
-  u.bits = THRIFT_letohll(u.bits);
-  dub = bitwise_cast<double>(u.bits);
-  return 8;
-}
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readString(std::string& str) {
-  return readBinary(str);
-}
-
-/**
- * Read a byte[] from the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readBinary(std::string& str) {
-  int32_t rsize = 0;
-  int32_t size;
-
-  rsize += readVarint32(size);
-  // Catch empty string case
-  if (size == 0) {
-    str = "";
-    return rsize;
-  }
-
-  // Catch error cases
-  if (size < 0) {
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  }
-  if (string_limit_ > 0 && size > string_limit_) {
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-
-  // Use the heap here to prevent stack overflow for v. large strings
-  if (size > string_buf_size_ || string_buf_ == NULL) {
-    void* new_string_buf = std::realloc(string_buf_, (uint32_t)size);
-    if (new_string_buf == NULL) {
-      throw std::bad_alloc();
-    }
-    string_buf_ = (uint8_t*)new_string_buf;
-    string_buf_size_ = size;
-  }
-  trans_->readAll(string_buf_, size);
-  str.assign((char*)string_buf_, size);
-
-  return rsize + (uint32_t)size;
-}
-
-/**
- * Read an i32 from the wire as a varint. The MSB of each byte is set
- * if there is another byte to follow. This can read up to 5 bytes.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readVarint32(int32_t& i32) {
-  int64_t val;
-  uint32_t rsize = readVarint64(val);
-  i32 = (int32_t)val;
-  return rsize;
-}
-
-/**
- * Read an i64 from the wire as a proper varint. The MSB of each byte is set
- * if there is another byte to follow. This can read up to 10 bytes.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readVarint64(int64_t& i64) {
-  uint32_t rsize = 0;
-  uint64_t val = 0;
-  int shift = 0;
-  uint8_t buf[10];  // 64 bits / (7 bits/byte) = 10 bytes.
-  uint32_t buf_size = sizeof(buf);
-  const uint8_t* borrowed = trans_->borrow(buf, &buf_size);
-
-  // Fast path.
-  if (borrowed != NULL) {
-    while (true) {
-      uint8_t byte = borrowed[rsize];
-      rsize++;
-      val |= (uint64_t)(byte & 0x7f) << shift;
-      shift += 7;
-      if (!(byte & 0x80)) {
-        i64 = val;
-        trans_->consume(rsize);
-        return rsize;
-      }
-      // Have to check for invalid data so we don't crash.
-      if (UNLIKELY(rsize == sizeof(buf))) {
-        throw TProtocolException(TProtocolException::INVALID_DATA, "Variable-length int over 10 bytes.");
-      }
-    }
-  }
-
-  // Slow path.
-  else {
-    while (true) {
-      uint8_t byte;
-      rsize += trans_->readAll(&byte, 1);
-      val |= (uint64_t)(byte & 0x7f) << shift;
-      shift += 7;
-      if (!(byte & 0x80)) {
-        i64 = val;
-        return rsize;
-      }
-      // Might as well check for invalid data on the slow path too.
-      if (UNLIKELY(rsize >= sizeof(buf))) {
-        throw TProtocolException(TProtocolException::INVALID_DATA, "Variable-length int over 10 bytes.");
-      }
-    }
-  }
-}
-
-/**
- * Convert from zigzag int to int.
- */
-template <class Transport_>
-int32_t TCompactProtocolT<Transport_>::zigzagToI32(uint32_t n) {
-  return (n >> 1) ^ static_cast<uint32_t>(-static_cast<int32_t>(n & 1));
-}
-
-/**
- * Convert from zigzag long to long.
- */
-template <class Transport_>
-int64_t TCompactProtocolT<Transport_>::zigzagToI64(uint64_t n) {
-  return (n >> 1) ^ static_cast<uint64_t>(-static_cast<int64_t>(n & 1));
-}
-
-template <class Transport_>
-TType TCompactProtocolT<Transport_>::getTType(int8_t type) {
-  switch (type) {
-    case T_STOP:
-      return T_STOP;
-    case detail::compact::CT_BOOLEAN_FALSE:
-    case detail::compact::CT_BOOLEAN_TRUE:
-      return T_BOOL;
-    case detail::compact::CT_BYTE:
-      return T_BYTE;
-    case detail::compact::CT_I16:
-      return T_I16;
-    case detail::compact::CT_I32:
-      return T_I32;
-    case detail::compact::CT_I64:
-      return T_I64;
-    case detail::compact::CT_DOUBLE:
-      return T_DOUBLE;
-    case detail::compact::CT_BINARY:
-      return T_STRING;
-    case detail::compact::CT_LIST:
-      return T_LIST;
-    case detail::compact::CT_SET:
-      return T_SET;
-    case detail::compact::CT_MAP:
-      return T_MAP;
-    case detail::compact::CT_STRUCT:
-      return T_STRUCT;
-    default:
-      throw TException(std::string("don't know what type: ") + (char)type);
-  }
-}
-
-}}} // duckdb_apache::thrift::protocol
-
-#endif // _DUCKDB_THRIFT_PROTOCOL_TCOMPACTPROTOCOL_TCC_
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp b/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp
deleted file mode 100644
index d70f5634c..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "thrift/protocol/TProtocol.h"
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-
-TProtocol::~TProtocol() = default;
-uint32_t TProtocol::skip_virt(TType type) {
-  return ::duckdb_apache::thrift::protocol::skip(*this, type);
-}
-
-TProtocolFactory::~TProtocolFactory() = default;
-
-}}} // duckdb_apache::thrift::protocol
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.h b/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.h
deleted file mode 100644
index 517aceb75..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.h
+++ /dev/null
@@ -1,766 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_PROTOCOL_TPROTOCOL_H_
-#define _DUCKDB_THRIFT_PROTOCOL_TPROTOCOL_H_ 1
-
-#ifdef _WIN32
-// Need to come before any Windows.h includes
-#include <winsock2.h>
-#endif
-
-#include "thrift/transport/TTransport.h"
-#include "thrift/protocol/TProtocolException.h"
-
-#include <memory>
-
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
-#include <sys/types.h>
-#include <string>
-#include <map>
-#include "duckdb/common/vector.hpp"
-#include <climits>
-
-// Use this to get around strict aliasing rules.
-// For example, uint64_t i = bitwise_cast<uint64_t>(returns_double());
-// The most obvious implementation is to just cast a pointer,
-// but that doesn't work.
-// For a pretty in-depth explanation of the problem, see
-// http://cellperformance.beyond3d.com/articles/2006/06/understanding-strict-aliasing.html
-namespace duckdb_apache { namespace thrift {
-template <typename To, typename From>
-static inline To bitwise_cast(From from) {
-	static_assert(sizeof(From) == sizeof(To), "sizeof(From) == sizeof(To)");
-
-	// BAD!!!  These are all broken with -O2.
-	// return *reinterpret_cast<To*>(&from);  // BAD!!!
-	// return *static_cast<To*>(static_cast<void*>(&from));  // BAD!!!
-	// return *(To*)(void*)&from;  // BAD!!!
-
-	// Super clean and paritally blessed by section 3.9 of the standard.
-	// unsigned char c[sizeof(from)];
-	// memcpy(c, &from, sizeof(from));
-	// To to;
-	// memcpy(&to, c, sizeof(c));
-	// return to;
-
-	// Slightly more questionable.
-	// Same code emitted by GCC.
-	// To to;
-	// memcpy(&to, &from, sizeof(from));
-	// return to;
-
-	// Technically undefined, but almost universally supported,
-	// and the most efficient implementation.
-	union {
-		From f;
-		To t;
-	} u;
-	u.f = from;
-	return u.t;
-}
-}} // namespace duckdb_apache::thrift
-
-
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-
-#ifndef __THRIFT_BYTE_ORDER
-# if defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
-#  define __THRIFT_BYTE_ORDER BYTE_ORDER
-#  define __THRIFT_LITTLE_ENDIAN LITTLE_ENDIAN
-#  define __THRIFT_BIG_ENDIAN BIG_ENDIAN
-# else
-//#  include <boost/predef/other/endian.h>
-#  if BOOST_ENDIAN_BIG_BYTE
-#    define __THRIFT_BYTE_ORDER 4321
-#    define __THRIFT_LITTLE_ENDIAN 0
-#    define __THRIFT_BIG_ENDIAN __THRIFT_BYTE_ORDER
-#  elif BOOST_ENDIAN_LITTLE_BYTE
-#    define __THRIFT_BYTE_ORDER 1234
-#    define __THRIFT_LITTLE_ENDIAN __THRIFT_BYTE_ORDER
-#    define __THRIFT_BIG_ENDIAN 0
-#  endif
-#  ifdef BOOST_LITTLE_ENDIAN
-#  else
-#  endif
-# endif
-#endif
-
-#if __THRIFT_BYTE_ORDER == __THRIFT_BIG_ENDIAN
-# if !defined(THRIFT_ntohll)
-#  define THRIFT_ntohll(n) (n)
-#  define THRIFT_htonll(n) (n)
-# endif
-# if defined(__GNUC__) && defined(__GLIBC__)
-#  include <byteswap.h>
-#  define THRIFT_htolell(n) bswap_64(n)
-#  define THRIFT_letohll(n) bswap_64(n)
-#  define THRIFT_htolel(n) bswap_32(n)
-#  define THRIFT_letohl(n) bswap_32(n)
-#  define THRIFT_htoles(n) bswap_16(n)
-#  define THRIFT_letohs(n) bswap_16(n)
-# else /* GNUC & GLIBC */
-#  define bswap_64(n) \
-      ( (((n) & 0xff00000000000000ull) >> 56) \
-      | (((n) & 0x00ff000000000000ull) >> 40) \
-      | (((n) & 0x0000ff0000000000ull) >> 24) \
-      | (((n) & 0x000000ff00000000ull) >> 8)  \
-      | (((n) & 0x00000000ff000000ull) << 8)  \
-      | (((n) & 0x0000000000ff0000ull) << 24) \
-      | (((n) & 0x000000000000ff00ull) << 40) \
-      | (((n) & 0x00000000000000ffull) << 56) )
-#  define bswap_32(n) \
-      ( (((n) & 0xff000000ul) >> 24) \
-      | (((n) & 0x00ff0000ul) >> 8)  \
-      | (((n) & 0x0000ff00ul) << 8)  \
-      | (((n) & 0x000000fful) << 24) )
-#  define bswap_16(n) \
-      ( (((n) & ((unsigned short)0xff00ul)) >> 8)  \
-      | (((n) & ((unsigned short)0x00fful)) << 8)  )
-#  define THRIFT_htolell(n) bswap_64(n)
-#  define THRIFT_letohll(n) bswap_64(n)
-#  define THRIFT_htolel(n) bswap_32(n)
-#  define THRIFT_letohl(n) bswap_32(n)
-#  define THRIFT_htoles(n) bswap_16(n)
-#  define THRIFT_letohs(n) bswap_16(n)
-# endif /* GNUC & GLIBC */
-#elif __THRIFT_BYTE_ORDER == __THRIFT_LITTLE_ENDIAN
-#  define THRIFT_htolell(n) (n)
-#  define THRIFT_letohll(n) (n)
-#  define THRIFT_htolel(n) (n)
-#  define THRIFT_letohl(n) (n)
-#  define THRIFT_htoles(n) (n)
-#  define THRIFT_letohs(n) (n)
-# if defined(__GNUC__) && defined(__GLIBC__)
-#  include <byteswap.h>
-#  define THRIFT_ntohll(n) bswap_64(n)
-#  define THRIFT_htonll(n) bswap_64(n)
-# elif defined(_MSC_VER) /* Microsoft Visual C++ */
-#  define THRIFT_ntohll(n) ( _byteswap_uint64((uint64_t)n) )
-#  define THRIFT_htonll(n) ( _byteswap_uint64((uint64_t)n) )
-# elif !defined(THRIFT_ntohll) /* Not GNUC/GLIBC or MSVC */
-#  define THRIFT_ntohll(n) ( (((uint64_t)ntohl((uint32_t)n)) << 32) + ntohl((uint32_t)(n >> 32)) )
-#  define THRIFT_htonll(n) ( (((uint64_t)htonl((uint32_t)n)) << 32) + htonl((uint32_t)(n >> 32)) )
-# endif /* GNUC/GLIBC or MSVC or something else */
-#else /* __THRIFT_BYTE_ORDER */
-# error "Can't define THRIFT_htonll or THRIFT_ntohll!"
-#endif
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-
-using duckdb_apache::thrift::transport::TTransport;
-
-/**
- * Enumerated definition of the types that the Thrift protocol supports.
- * Take special note of the T_END type which is used specifically to mark
- * the end of a sequence of fields.
- */
-enum TType {
-  T_STOP       = 0,
-  T_VOID       = 1,
-  T_BOOL       = 2,
-  T_BYTE       = 3,
-  T_I08        = 3,
-  T_I16        = 6,
-  T_I32        = 8,
-  T_U64        = 9,
-  T_I64        = 10,
-  T_DOUBLE     = 4,
-  T_STRING     = 11,
-  T_UTF7       = 11,
-  T_STRUCT     = 12,
-  T_MAP        = 13,
-  T_SET        = 14,
-  T_LIST       = 15,
-  T_UTF8       = 16,
-  T_UTF16      = 17
-};
-
-/**
- * Enumerated definition of the message types that the Thrift protocol
- * supports.
- */
-enum TMessageType {
-  T_CALL       = 1,
-  T_REPLY      = 2,
-  T_EXCEPTION  = 3,
-  T_ONEWAY     = 4
-};
-
-static const uint32_t DEFAULT_RECURSION_LIMIT = 64;
-
-/**
- * Abstract class for a thrift protocol driver. These are all the methods that
- * a protocol must implement. Essentially, there must be some way of reading
- * and writing all the base types, plus a mechanism for writing out structs
- * with indexed fields.
- *
- * TProtocol objects should not be shared across multiple encoding contexts,
- * as they may need to maintain internal state in some protocols (i.e. XML).
- * Note that is is acceptable for the TProtocol module to do its own internal
- * buffered reads/writes to the underlying TTransport where appropriate (i.e.
- * when parsing an input XML stream, reading should be batched rather than
- * looking ahead character by character for a close tag).
- *
- */
-class TProtocol {
-public:
-  virtual ~TProtocol();
-
-  /**
-   * Writing functions.
-   */
-
-  virtual uint32_t writeMessageBegin_virt(const std::string& name,
-                                          const TMessageType messageType,
-                                          const int32_t seqid) = 0;
-
-  virtual uint32_t writeMessageEnd_virt() = 0;
-
-  virtual uint32_t writeStructBegin_virt(const char* name) = 0;
-
-  virtual uint32_t writeStructEnd_virt() = 0;
-
-  virtual uint32_t writeFieldBegin_virt(const char* name,
-                                        const TType fieldType,
-                                        const int16_t fieldId) = 0;
-
-  virtual uint32_t writeFieldEnd_virt() = 0;
-
-  virtual uint32_t writeFieldStop_virt() = 0;
-
-  virtual uint32_t writeMapBegin_virt(const TType keyType, const TType valType, const uint32_t size)
-      = 0;
-
-  virtual uint32_t writeMapEnd_virt() = 0;
-
-  virtual uint32_t writeListBegin_virt(const TType elemType, const uint32_t size) = 0;
-
-  virtual uint32_t writeListEnd_virt() = 0;
-
-  virtual uint32_t writeSetBegin_virt(const TType elemType, const uint32_t size) = 0;
-
-  virtual uint32_t writeSetEnd_virt() = 0;
-
-  virtual uint32_t writeBool_virt(const bool value) = 0;
-
-  virtual uint32_t writeByte_virt(const int8_t byte) = 0;
-
-  virtual uint32_t writeI16_virt(const int16_t i16) = 0;
-
-  virtual uint32_t writeI32_virt(const int32_t i32) = 0;
-
-  virtual uint32_t writeI64_virt(const int64_t i64) = 0;
-
-  virtual uint32_t writeDouble_virt(const double dub) = 0;
-
-  virtual uint32_t writeString_virt(const std::string& str) = 0;
-
-  virtual uint32_t writeBinary_virt(const std::string& str) = 0;
-
-  uint32_t writeMessageBegin(const std::string& name,
-                             const TMessageType messageType,
-                             const int32_t seqid) {
-    T_VIRTUAL_CALL();
-    return writeMessageBegin_virt(name, messageType, seqid);
-  }
-
-  uint32_t writeMessageEnd() {
-    T_VIRTUAL_CALL();
-    return writeMessageEnd_virt();
-  }
-
-  uint32_t writeStructBegin(const char* name) {
-    T_VIRTUAL_CALL();
-    return writeStructBegin_virt(name);
-  }
-
-  uint32_t writeStructEnd() {
-    T_VIRTUAL_CALL();
-    return writeStructEnd_virt();
-  }
-
-  uint32_t writeFieldBegin(const char* name, const TType fieldType, const int16_t fieldId) {
-    T_VIRTUAL_CALL();
-    return writeFieldBegin_virt(name, fieldType, fieldId);
-  }
-
-  uint32_t writeFieldEnd() {
-    T_VIRTUAL_CALL();
-    return writeFieldEnd_virt();
-  }
-
-  uint32_t writeFieldStop() {
-    T_VIRTUAL_CALL();
-    return writeFieldStop_virt();
-  }
-
-  uint32_t writeMapBegin(const TType keyType, const TType valType, const uint32_t size) {
-    T_VIRTUAL_CALL();
-    return writeMapBegin_virt(keyType, valType, size);
-  }
-
-  uint32_t writeMapEnd() {
-    T_VIRTUAL_CALL();
-    return writeMapEnd_virt();
-  }
-
-  uint32_t writeListBegin(const TType elemType, const uint32_t size) {
-    T_VIRTUAL_CALL();
-    return writeListBegin_virt(elemType, size);
-  }
-
-  uint32_t writeListEnd() {
-    T_VIRTUAL_CALL();
-    return writeListEnd_virt();
-  }
-
-  uint32_t writeSetBegin(const TType elemType, const uint32_t size) {
-    T_VIRTUAL_CALL();
-    return writeSetBegin_virt(elemType, size);
-  }
-
-  uint32_t writeSetEnd() {
-    T_VIRTUAL_CALL();
-    return writeSetEnd_virt();
-  }
-
-  uint32_t writeBool(const bool value) {
-    T_VIRTUAL_CALL();
-    return writeBool_virt(value);
-  }
-
-  uint32_t writeByte(const int8_t byte) {
-    T_VIRTUAL_CALL();
-    return writeByte_virt(byte);
-  }
-
-  uint32_t writeI16(const int16_t i16) {
-    T_VIRTUAL_CALL();
-    return writeI16_virt(i16);
-  }
-
-  uint32_t writeI32(const int32_t i32) {
-    T_VIRTUAL_CALL();
-    return writeI32_virt(i32);
-  }
-
-  uint32_t writeI64(const int64_t i64) {
-    T_VIRTUAL_CALL();
-    return writeI64_virt(i64);
-  }
-
-  uint32_t writeDouble(const double dub) {
-    T_VIRTUAL_CALL();
-    return writeDouble_virt(dub);
-  }
-
-  uint32_t writeString(const std::string& str) {
-    T_VIRTUAL_CALL();
-    return writeString_virt(str);
-  }
-
-  uint32_t writeBinary(const std::string& str) {
-    T_VIRTUAL_CALL();
-    return writeBinary_virt(str);
-  }
-
-  /**
-   * Reading functions
-   */
-
-  virtual uint32_t readMessageBegin_virt(std::string& name,
-                                         TMessageType& messageType,
-                                         int32_t& seqid) = 0;
-
-  virtual uint32_t readMessageEnd_virt() = 0;
-
-  virtual uint32_t readStructBegin_virt(std::string& name) = 0;
-
-  virtual uint32_t readStructEnd_virt() = 0;
-
-  virtual uint32_t readFieldBegin_virt(std::string& name, TType& fieldType, int16_t& fieldId) = 0;
-
-  virtual uint32_t readFieldEnd_virt() = 0;
-
-  virtual uint32_t readMapBegin_virt(TType& keyType, TType& valType, uint32_t& size) = 0;
-
-  virtual uint32_t readMapEnd_virt() = 0;
-
-  virtual uint32_t readListBegin_virt(TType& elemType, uint32_t& size) = 0;
-
-  virtual uint32_t readListEnd_virt() = 0;
-
-  virtual uint32_t readSetBegin_virt(TType& elemType, uint32_t& size) = 0;
-
-  virtual uint32_t readSetEnd_virt() = 0;
-
-  virtual uint32_t readBool_virt(bool& value) = 0;
-
-  virtual uint32_t readBool_virt(std::vector<bool>::reference value) = 0;
-
-  virtual uint32_t readByte_virt(int8_t& byte) = 0;
-
-  virtual uint32_t readI16_virt(int16_t& i16) = 0;
-
-  virtual uint32_t readI32_virt(int32_t& i32) = 0;
-
-  virtual uint32_t readI64_virt(int64_t& i64) = 0;
-
-  virtual uint32_t readDouble_virt(double& dub) = 0;
-
-  virtual uint32_t readString_virt(std::string& str) = 0;
-
-  virtual uint32_t readBinary_virt(std::string& str) = 0;
-
-  uint32_t readMessageBegin(std::string& name, TMessageType& messageType, int32_t& seqid) {
-    T_VIRTUAL_CALL();
-    return readMessageBegin_virt(name, messageType, seqid);
-  }
-
-  uint32_t readMessageEnd() {
-    T_VIRTUAL_CALL();
-    return readMessageEnd_virt();
-  }
-
-  uint32_t readStructBegin(std::string& name) {
-    T_VIRTUAL_CALL();
-    return readStructBegin_virt(name);
-  }
-
-  uint32_t readStructEnd() {
-    T_VIRTUAL_CALL();
-    return readStructEnd_virt();
-  }
-
-  uint32_t readFieldBegin(std::string& name, TType& fieldType, int16_t& fieldId) {
-    T_VIRTUAL_CALL();
-    return readFieldBegin_virt(name, fieldType, fieldId);
-  }
-
-  uint32_t readFieldEnd() {
-    T_VIRTUAL_CALL();
-    return readFieldEnd_virt();
-  }
-
-  uint32_t readMapBegin(TType& keyType, TType& valType, uint32_t& size) {
-    T_VIRTUAL_CALL();
-    return readMapBegin_virt(keyType, valType, size);
-  }
-
-  uint32_t readMapEnd() {
-    T_VIRTUAL_CALL();
-    return readMapEnd_virt();
-  }
-
-  uint32_t readListBegin(TType& elemType, uint32_t& size) {
-    T_VIRTUAL_CALL();
-    return readListBegin_virt(elemType, size);
-  }
-
-  uint32_t readListEnd() {
-    T_VIRTUAL_CALL();
-    return readListEnd_virt();
-  }
-
-  uint32_t readSetBegin(TType& elemType, uint32_t& size) {
-    T_VIRTUAL_CALL();
-    return readSetBegin_virt(elemType, size);
-  }
-
-  uint32_t readSetEnd() {
-    T_VIRTUAL_CALL();
-    return readSetEnd_virt();
-  }
-
-  uint32_t readBool(bool& value) {
-    T_VIRTUAL_CALL();
-    return readBool_virt(value);
-  }
-
-  uint32_t readByte(int8_t& byte) {
-    T_VIRTUAL_CALL();
-    return readByte_virt(byte);
-  }
-
-  uint32_t readI16(int16_t& i16) {
-    T_VIRTUAL_CALL();
-    return readI16_virt(i16);
-  }
-
-  uint32_t readI32(int32_t& i32) {
-    T_VIRTUAL_CALL();
-    return readI32_virt(i32);
-  }
-
-  uint32_t readI64(int64_t& i64) {
-    T_VIRTUAL_CALL();
-    return readI64_virt(i64);
-  }
-
-  uint32_t readDouble(double& dub) {
-    T_VIRTUAL_CALL();
-    return readDouble_virt(dub);
-  }
-
-  uint32_t readString(std::string& str) {
-    T_VIRTUAL_CALL();
-    return readString_virt(str);
-  }
-
-  uint32_t readBinary(std::string& str) {
-    T_VIRTUAL_CALL();
-    return readBinary_virt(str);
-  }
-
-  /*
-   * std::vector is specialized for bool, and its elements are individual bits
-   * rather than bools.   We need to define a different version of readBool()
-   * to work with std::vector<bool>.
-   */
-  uint32_t readBool(std::vector<bool>::reference value) {
-    T_VIRTUAL_CALL();
-    return readBool_virt(value);
-  }
-
-  /**
-   * Method to arbitrarily skip over data.
-   */
-  uint32_t skip(TType type) {
-    T_VIRTUAL_CALL();
-    return skip_virt(type);
-  }
-  virtual uint32_t skip_virt(TType type);
-
-  inline std::shared_ptr<TTransport> getTransport() { return ptrans_; }
-
-  // TODO: remove these two calls, they are for backwards
-  // compatibility
-  inline std::shared_ptr<TTransport> getInputTransport() { return ptrans_; }
-  inline std::shared_ptr<TTransport> getOutputTransport() { return ptrans_; }
-
-  // input and output recursion depth are kept separate so that one protocol
-  // can be used concurrently for both input and output.
-  void incrementInputRecursionDepth() {
-    if (recursion_limit_ < ++input_recursion_depth_) {
-      throw TProtocolException(TProtocolException::DEPTH_LIMIT);
-    }
-  }
-  void decrementInputRecursionDepth() { --input_recursion_depth_; }
-
-  void incrementOutputRecursionDepth() {
-    if (recursion_limit_ < ++output_recursion_depth_) {
-      throw TProtocolException(TProtocolException::DEPTH_LIMIT);
-    }
-  }
-  void decrementOutputRecursionDepth() { --output_recursion_depth_; }
-
-  uint32_t getRecursionLimit() const {return recursion_limit_;}
-  void setRecurisionLimit(uint32_t depth) {recursion_limit_ = depth;}
-
-protected:
-  TProtocol(std::shared_ptr<TTransport> ptrans)
-    : ptrans_(ptrans), input_recursion_depth_(0), output_recursion_depth_(0), recursion_limit_(DEFAULT_RECURSION_LIMIT)
-  {}
-
-  std::shared_ptr<TTransport> ptrans_;
-
-private:
-  TProtocol() = default;
-  uint32_t input_recursion_depth_;
-  uint32_t output_recursion_depth_;
-  uint32_t recursion_limit_;
-};
-
-/**
- * Constructs input and output protocol objects given transports.
- */
-class TProtocolFactory {
-public:
-  TProtocolFactory() = default;
-
-  virtual ~TProtocolFactory();
-
-  virtual std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) = 0;
-  virtual std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> inTrans,
-               std::shared_ptr<TTransport> outTrans) {
-    (void)outTrans;
-    return getProtocol(inTrans);
-  }
-};
-
-/**
- * Dummy protocol class.
- *
- * This class does nothing, and should never be instantiated.
- * It is used only by the generator code.
- */
-class TDummyProtocol : public TProtocol {};
-
-
-// HM: this is sub-optimal since it creates a depencency even for memory-only struct
-//// This is the default / legacy choice
-//struct TNetworkBigEndian
-//{
-//  static uint16_t toWire16(uint16_t x)   {return htons(x);}
-//  static uint32_t toWire32(uint32_t x)   {return htonl(x);}
-//  static uint64_t toWire64(uint64_t x)   {return THRIFT_htonll(x);}
-//  static uint16_t fromWire16(uint16_t x) {return ntohs(x);}
-//  static uint32_t fromWire32(uint32_t x) {return ntohl(x);}
-//  static uint64_t fromWire64(uint64_t x) {return THRIFT_ntohll(x);}
-//};
-//
-//// On most systems, this will be a bit faster than TNetworkBigEndian
-//struct TNetworkLittleEndian
-//{
-//  static uint16_t toWire16(uint16_t x)   {return THRIFT_htoles(x);}
-//  static uint32_t toWire32(uint32_t x)   {return THRIFT_htolel(x);}
-//  static uint64_t toWire64(uint64_t x)   {return THRIFT_htolell(x);}
-//  static uint16_t fromWire16(uint16_t x) {return THRIFT_letohs(x);}
-//  static uint32_t fromWire32(uint32_t x) {return THRIFT_letohl(x);}
-//  static uint64_t fromWire64(uint64_t x) {return THRIFT_letohll(x);}
-//};
-
-struct TOutputRecursionTracker {
-  TProtocol &prot_;
-  TOutputRecursionTracker(TProtocol &prot) : prot_(prot) {
-    prot_.incrementOutputRecursionDepth();
-  }
-  ~TOutputRecursionTracker() {
-    prot_.decrementOutputRecursionDepth();
-  }
-};
-
-struct TInputRecursionTracker {
-  TProtocol &prot_;
-  TInputRecursionTracker(TProtocol &prot) : prot_(prot) {
-    prot_.incrementInputRecursionDepth();
-  }
-  ~TInputRecursionTracker() {
-    prot_.decrementInputRecursionDepth();
-  }
-};
-
-/**
- * Helper template for implementing TProtocol::skip().
- *
- * Templatized to avoid having to make virtual function calls.
- */
-template <class Protocol_>
-uint32_t skip(Protocol_& prot, TType type) {
-  TInputRecursionTracker tracker(prot);
-
-  switch (type) {
-  case T_BOOL: {
-    bool boolv;
-    return prot.readBool(boolv);
-  }
-  case T_BYTE: {
-    int8_t bytev = 0;
-    return prot.readByte(bytev);
-  }
-  case T_I16: {
-    int16_t i16;
-    return prot.readI16(i16);
-  }
-  case T_I32: {
-    int32_t i32;
-    return prot.readI32(i32);
-  }
-  case T_I64: {
-    int64_t i64;
-    return prot.readI64(i64);
-  }
-  case T_DOUBLE: {
-    double dub;
-    return prot.readDouble(dub);
-  }
-  case T_STRING: {
-    std::string str;
-    return prot.readBinary(str);
-  }
-  case T_STRUCT: {
-    uint32_t result = 0;
-    std::string name;
-    int16_t fid;
-    TType ftype;
-    result += prot.readStructBegin(name);
-    while (true) {
-      result += prot.readFieldBegin(name, ftype, fid);
-      if (ftype == T_STOP) {
-        break;
-      }
-      result += skip(prot, ftype);
-      result += prot.readFieldEnd();
-    }
-    result += prot.readStructEnd();
-    return result;
-  }
-  case T_MAP: {
-    uint32_t result = 0;
-    TType keyType;
-    TType valType;
-    uint32_t i, size;
-    result += prot.readMapBegin(keyType, valType, size);
-    for (i = 0; i < size; i++) {
-      result += skip(prot, keyType);
-      result += skip(prot, valType);
-    }
-    result += prot.readMapEnd();
-    return result;
-  }
-  case T_SET: {
-    uint32_t result = 0;
-    TType elemType;
-    uint32_t i, size;
-    result += prot.readSetBegin(elemType, size);
-    for (i = 0; i < size; i++) {
-      result += skip(prot, elemType);
-    }
-    result += prot.readSetEnd();
-    return result;
-  }
-  case T_LIST: {
-    uint32_t result = 0;
-    TType elemType;
-    uint32_t i, size;
-    result += prot.readListBegin(elemType, size);
-    for (i = 0; i < size; i++) {
-      result += skip(prot, elemType);
-    }
-    result += prot.readListEnd();
-    return result;
-  }
-  default:
-    break;
-  }
-
-  throw TProtocolException(TProtocolException::INVALID_DATA,
-                           "invalid TType");
-}
-
-}}} // duckdb_apache::thrift::protocol
-
-#endif // #define _DUCKDB_THRIFT_PROTOCOL_TPROTOCOL_H_ 1
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TProtocolDecorator.h b/src/duckdb/third_party/thrift/thrift/protocol/TProtocolDecorator.h
deleted file mode 100644
index 637377011..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TProtocolDecorator.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef THRIFT_TPROTOCOLDECORATOR_H_
-#define THRIFT_TPROTOCOLDECORATOR_H_ 1
-
-#include "thrift/protocol/TProtocol.h"
-#include <memory>
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-using std::shared_ptr;
-
-/**
- * <code>TProtocolDecorator</code> forwards all requests to an enclosed
- * <code>TProtocol</code> instance, providing a way to author concise
- * concrete decorator subclasses.
- *
- * <p>See p.175 of Design Patterns (by Gamma et al.)</p>
- *
- * @see duckdb_apache::thrift::protocol::TMultiplexedProtocol
- */
-class TProtocolDecorator : public TProtocol {
-public:
-  ~TProtocolDecorator() override = default;
-
-  // Desc: Initializes the protocol decorator object.
-  TProtocolDecorator(shared_ptr<TProtocol> proto)
-    : TProtocol(proto->getTransport()), protocol(proto) {}
-
-  uint32_t writeMessageBegin_virt(const std::string& name,
-                                          const TMessageType messageType,
-                                          const int32_t seqid) override {
-    return protocol->writeMessageBegin(name, messageType, seqid);
-  }
-  uint32_t writeMessageEnd_virt() override { return protocol->writeMessageEnd(); }
-  uint32_t writeStructBegin_virt(const char* name) override {
-    return protocol->writeStructBegin(name);
-  }
-  uint32_t writeStructEnd_virt() override { return protocol->writeStructEnd(); }
-
-  uint32_t writeFieldBegin_virt(const char* name,
-                                        const TType fieldType,
-                                        const int16_t fieldId) override {
-    return protocol->writeFieldBegin(name, fieldType, fieldId);
-  }
-
-  uint32_t writeFieldEnd_virt() override { return protocol->writeFieldEnd(); }
-  uint32_t writeFieldStop_virt() override { return protocol->writeFieldStop(); }
-
-  uint32_t writeMapBegin_virt(const TType keyType,
-                                      const TType valType,
-                                      const uint32_t size) override {
-    return protocol->writeMapBegin(keyType, valType, size);
-  }
-
-  uint32_t writeMapEnd_virt() override { return protocol->writeMapEnd(); }
-
-  uint32_t writeListBegin_virt(const TType elemType, const uint32_t size) override {
-    return protocol->writeListBegin(elemType, size);
-  }
-  uint32_t writeListEnd_virt() override { return protocol->writeListEnd(); }
-
-  uint32_t writeSetBegin_virt(const TType elemType, const uint32_t size) override {
-    return protocol->writeSetBegin(elemType, size);
-  }
-  uint32_t writeSetEnd_virt() override { return protocol->writeSetEnd(); }
-
-  uint32_t writeBool_virt(const bool value) override { return protocol->writeBool(value); }
-  uint32_t writeByte_virt(const int8_t byte) override { return protocol->writeByte(byte); }
-  uint32_t writeI16_virt(const int16_t i16) override { return protocol->writeI16(i16); }
-  uint32_t writeI32_virt(const int32_t i32) override { return protocol->writeI32(i32); }
-  uint32_t writeI64_virt(const int64_t i64) override { return protocol->writeI64(i64); }
-
-  uint32_t writeDouble_virt(const double dub) override { return protocol->writeDouble(dub); }
-  uint32_t writeString_virt(const std::string& str) override { return protocol->writeString(str); }
-  uint32_t writeBinary_virt(const std::string& str) override { return protocol->writeBinary(str); }
-
-  uint32_t readMessageBegin_virt(std::string& name,
-                                         TMessageType& messageType,
-                                         int32_t& seqid) override {
-    return protocol->readMessageBegin(name, messageType, seqid);
-  }
-  uint32_t readMessageEnd_virt() override { return protocol->readMessageEnd(); }
-
-  uint32_t readStructBegin_virt(std::string& name) override {
-    return protocol->readStructBegin(name);
-  }
-  uint32_t readStructEnd_virt() override { return protocol->readStructEnd(); }
-
-  uint32_t readFieldBegin_virt(std::string& name, TType& fieldType, int16_t& fieldId) override {
-    return protocol->readFieldBegin(name, fieldType, fieldId);
-  }
-  uint32_t readFieldEnd_virt() override { return protocol->readFieldEnd(); }
-
-  uint32_t readMapBegin_virt(TType& keyType, TType& valType, uint32_t& size) override {
-    return protocol->readMapBegin(keyType, valType, size);
-  }
-  uint32_t readMapEnd_virt() override { return protocol->readMapEnd(); }
-
-  uint32_t readListBegin_virt(TType& elemType, uint32_t& size) override {
-    return protocol->readListBegin(elemType, size);
-  }
-  uint32_t readListEnd_virt() override { return protocol->readListEnd(); }
-
-  uint32_t readSetBegin_virt(TType& elemType, uint32_t& size) override {
-    return protocol->readSetBegin(elemType, size);
-  }
-  uint32_t readSetEnd_virt() override { return protocol->readSetEnd(); }
-
-  uint32_t readBool_virt(bool& value) override { return protocol->readBool(value); }
-  uint32_t readBool_virt(duckdb::vector<bool>::reference value) override {
-    return protocol->readBool(value);
-  }
-
-  uint32_t readByte_virt(int8_t& byte) override { return protocol->readByte(byte); }
-
-  uint32_t readI16_virt(int16_t& i16) override { return protocol->readI16(i16); }
-  uint32_t readI32_virt(int32_t& i32) override { return protocol->readI32(i32); }
-  uint32_t readI64_virt(int64_t& i64) override { return protocol->readI64(i64); }
-
-  uint32_t readDouble_virt(double& dub) override { return protocol->readDouble(dub); }
-
-  uint32_t readString_virt(std::string& str) override { return protocol->readString(str); }
-  uint32_t readBinary_virt(std::string& str) override { return protocol->readBinary(str); }
-
-private:
-  shared_ptr<TProtocol> protocol;
-};
-}
-}
-}
-
-#endif // THRIFT_TPROTOCOLDECORATOR_H_
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TProtocolException.h b/src/duckdb/third_party/thrift/thrift/protocol/TProtocolException.h
deleted file mode 100644
index 1f4b963c2..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TProtocolException.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_PROTOCOL_TPROTOCOLEXCEPTION_H_
-#define _DUCKDB_THRIFT_PROTOCOL_TPROTOCOLEXCEPTION_H_ 1
-
-#include <string>
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-
-/**
- * Class to encapsulate all the possible types of protocol errors that may
- * occur in various protocol systems. This provides a sort of generic
- * wrapper around the vague UNIX E_ error codes that lets a common code
- * base of error handling to be used for various types of protocols, i.e.
- * pipes etc.
- *
- */
-class TProtocolException : public duckdb_apache::thrift::TException {
-public:
-  /**
-   * Error codes for the various types of exceptions.
-   */
-  enum TProtocolExceptionType {
-    UNKNOWN = 0,
-    INVALID_DATA = 1,
-    NEGATIVE_SIZE = 2,
-    SIZE_LIMIT = 3,
-    BAD_VERSION = 4,
-    NOT_IMPLEMENTED = 5,
-    DEPTH_LIMIT = 6
-  };
-
-  TProtocolException() : duckdb_apache::thrift::TException(), type_(UNKNOWN) {}
-
-  TProtocolException(TProtocolExceptionType type) : duckdb_apache::thrift::TException(), type_(type) {}
-
-  TProtocolException(const std::string& message)
-    : duckdb_apache::thrift::TException(message), type_(UNKNOWN) {}
-
-  TProtocolException(TProtocolExceptionType type, const std::string& message)
-    : duckdb_apache::thrift::TException(message), type_(type) {}
-
-  ~TProtocolException() noexcept override = default;
-
-  /**
-   * Returns an error code that provides information about the type of error
-   * that has occurred.
-   *
-   * @return Error code
-   */
-  TProtocolExceptionType getType() const { return type_; }
-
-  const char* what() const noexcept override {
-    if (message_.empty()) {
-      switch (type_) {
-      case UNKNOWN:
-        return "TProtocolException: Unknown protocol exception";
-      case INVALID_DATA:
-        return "TProtocolException: Invalid data";
-      case NEGATIVE_SIZE:
-        return "TProtocolException: Negative size";
-      case SIZE_LIMIT:
-        return "TProtocolException: Exceeded size limit";
-      case BAD_VERSION:
-        return "TProtocolException: Invalid version";
-      case NOT_IMPLEMENTED:
-        return "TProtocolException: Not implemented";
-      default:
-        return "TProtocolException: (Invalid exception type)";
-      }
-    } else {
-      return message_.c_str();
-    }
-  }
-
-protected:
-  /**
-   * Error code
-   */
-  TProtocolExceptionType type_;
-};
-}
-}
-} // duckdb_apache::thrift::protocol
-
-#endif // #ifndef _DUCKDB_THRIFT_PROTOCOL_TPROTOCOLEXCEPTION_H_
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TProtocolTypes.h b/src/duckdb/third_party/thrift/thrift/protocol/TProtocolTypes.h
deleted file mode 100644
index 4eaedd9d1..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TProtocolTypes.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef THRIFT_PROTOCOL_TPROTOCOLTYPES_H_
-#define THRIFT_PROTOCOL_TPROTOCOLTYPES_H_ 1
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-
-enum PROTOCOL_TYPES {
-  T_BINARY_PROTOCOL = 0,
-  T_JSON_PROTOCOL = 1,
-  T_COMPACT_PROTOCOL = 2,
-};
-}
-}
-} // duckdb_apache::thrift::protocol
-
-#endif // #define _THRIFT_PROTOCOL_TPROTOCOLTYPES_H_ 1
diff --git a/src/duckdb/third_party/thrift/thrift/protocol/TVirtualProtocol.h b/src/duckdb/third_party/thrift/thrift/protocol/TVirtualProtocol.h
deleted file mode 100644
index 81c34c642..000000000
--- a/src/duckdb/third_party/thrift/thrift/protocol/TVirtualProtocol.h
+++ /dev/null
@@ -1,514 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_
-#define _DUCKDB_THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_ 1
-
-#include "thrift/protocol/TProtocol.h"
-#include "duckdb/common/vector.hpp"
-
-namespace duckdb_apache {
-namespace thrift {
-namespace protocol {
-
-using duckdb_apache::thrift::transport::TTransport;
-
-/**
- * Helper class that provides default implementations of TProtocol methods.
- *
- * This class provides default implementations of the non-virtual TProtocol
- * methods.  It exists primarily so TVirtualProtocol can derive from it.  It
- * prevents TVirtualProtocol methods from causing infinite recursion if the
- * non-virtual methods are not overridden by the TVirtualProtocol subclass.
- *
- * You probably don't want to use this class directly.  Use TVirtualProtocol
- * instead.
- */
-class TProtocolDefaults : public TProtocol {
-public:
-  uint32_t readMessageBegin(std::string& name, TMessageType& messageType, int32_t& seqid) {
-    (void)name;
-    (void)messageType;
-    (void)seqid;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readMessageEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readStructBegin(std::string& name) {
-    (void)name;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readStructEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readFieldBegin(std::string& name, TType& fieldType, int16_t& fieldId) {
-    (void)name;
-    (void)fieldType;
-    (void)fieldId;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readFieldEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readMapBegin(TType& keyType, TType& valType, uint32_t& size) {
-    (void)keyType;
-    (void)valType;
-    (void)size;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readMapEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readListBegin(TType& elemType, uint32_t& size) {
-    (void)elemType;
-    (void)size;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readListEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readSetBegin(TType& elemType, uint32_t& size) {
-    (void)elemType;
-    (void)size;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readSetEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readBool(bool& value) {
-    (void)value;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readBool(duckdb::vector<bool>::reference value) {
-    (void)value;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readByte(int8_t& byte) {
-    (void)byte;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readI16(int16_t& i16) {
-    (void)i16;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readI32(int32_t& i32) {
-    (void)i32;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readI64(int64_t& i64) {
-    (void)i64;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readDouble(double& dub) {
-    (void)dub;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readString(std::string& str) {
-    (void)str;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t readBinary(std::string& str) {
-    (void)str;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support reading (yet).");
-  }
-
-  uint32_t writeMessageBegin(const std::string& name,
-                             const TMessageType messageType,
-                             const int32_t seqid) {
-    (void)name;
-    (void)messageType;
-    (void)seqid;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeMessageEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeStructBegin(const char* name) {
-    (void)name;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeStructEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeFieldBegin(const char* name, const TType fieldType, const int16_t fieldId) {
-    (void)name;
-    (void)fieldType;
-    (void)fieldId;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeFieldEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeFieldStop() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeMapBegin(const TType keyType, const TType valType, const uint32_t size) {
-    (void)keyType;
-    (void)valType;
-    (void)size;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeMapEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeListBegin(const TType elemType, const uint32_t size) {
-    (void)elemType;
-    (void)size;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeListEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeSetBegin(const TType elemType, const uint32_t size) {
-    (void)elemType;
-    (void)size;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeSetEnd() {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeBool(const bool value) {
-    (void)value;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeByte(const int8_t byte) {
-    (void)byte;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeI16(const int16_t i16) {
-    (void)i16;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeI32(const int32_t i32) {
-    (void)i32;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeI64(const int64_t i64) {
-    (void)i64;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeDouble(const double dub) {
-    (void)dub;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeString(const std::string& str) {
-    (void)str;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t writeBinary(const std::string& str) {
-    (void)str;
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "this protocol does not support writing (yet).");
-  }
-
-  uint32_t skip(TType type) { return ::duckdb_apache::thrift::protocol::skip(*this, type); }
-
-protected:
-  TProtocolDefaults(std::shared_ptr<TTransport> ptrans) : TProtocol(ptrans) {}
-};
-
-/**
- * Concrete TProtocol classes should inherit from TVirtualProtocol
- * so they don't have to manually override virtual methods.
- */
-template <class Protocol_, class Super_ = TProtocolDefaults>
-class TVirtualProtocol : public Super_ {
-public:
-  /**
-   * Writing functions.
-   */
-
-  uint32_t writeMessageBegin_virt(const std::string& name,
-                                          const TMessageType messageType,
-                                          const int32_t seqid) override {
-    return static_cast<Protocol_*>(this)->writeMessageBegin(name, messageType, seqid);
-  }
-
-  uint32_t writeMessageEnd_virt() override {
-    return static_cast<Protocol_*>(this)->writeMessageEnd();
-  }
-
-  uint32_t writeStructBegin_virt(const char* name) override {
-    return static_cast<Protocol_*>(this)->writeStructBegin(name);
-  }
-
-  uint32_t writeStructEnd_virt() override { return static_cast<Protocol_*>(this)->writeStructEnd(); }
-
-  uint32_t writeFieldBegin_virt(const char* name,
-                                        const TType fieldType,
-                                        const int16_t fieldId) override {
-    return static_cast<Protocol_*>(this)->writeFieldBegin(name, fieldType, fieldId);
-  }
-
-  uint32_t writeFieldEnd_virt() override { return static_cast<Protocol_*>(this)->writeFieldEnd(); }
-
-  uint32_t writeFieldStop_virt() override { return static_cast<Protocol_*>(this)->writeFieldStop(); }
-
-  uint32_t writeMapBegin_virt(const TType keyType,
-                                      const TType valType,
-                                      const uint32_t size) override {
-    return static_cast<Protocol_*>(this)->writeMapBegin(keyType, valType, size);
-  }
-
-  uint32_t writeMapEnd_virt() override { return static_cast<Protocol_*>(this)->writeMapEnd(); }
-
-  uint32_t writeListBegin_virt(const TType elemType, const uint32_t size) override {
-    return static_cast<Protocol_*>(this)->writeListBegin(elemType, size);
-  }
-
-  uint32_t writeListEnd_virt() override { return static_cast<Protocol_*>(this)->writeListEnd(); }
-
-  uint32_t writeSetBegin_virt(const TType elemType, const uint32_t size) override {
-    return static_cast<Protocol_*>(this)->writeSetBegin(elemType, size);
-  }
-
-  uint32_t writeSetEnd_virt() override { return static_cast<Protocol_*>(this)->writeSetEnd(); }
-
-  uint32_t writeBool_virt(const bool value) override {
-    return static_cast<Protocol_*>(this)->writeBool(value);
-  }
-
-  uint32_t writeByte_virt(const int8_t byte) override {
-    return static_cast<Protocol_*>(this)->writeByte(byte);
-  }
-
-  uint32_t writeI16_virt(const int16_t i16) override {
-    return static_cast<Protocol_*>(this)->writeI16(i16);
-  }
-
-  uint32_t writeI32_virt(const int32_t i32) override {
-    return static_cast<Protocol_*>(this)->writeI32(i32);
-  }
-
-  uint32_t writeI64_virt(const int64_t i64) override {
-    return static_cast<Protocol_*>(this)->writeI64(i64);
-  }
-
-  uint32_t writeDouble_virt(const double dub) override {
-    return static_cast<Protocol_*>(this)->writeDouble(dub);
-  }
-
-  uint32_t writeString_virt(const std::string& str) override {
-    return static_cast<Protocol_*>(this)->writeString(str);
-  }
-
-  uint32_t writeBinary_virt(const std::string& str) override {
-    return static_cast<Protocol_*>(this)->writeBinary(str);
-  }
-
-  /**
-   * Reading functions
-   */
-
-  uint32_t readMessageBegin_virt(std::string& name,
-                                         TMessageType& messageType,
-                                         int32_t& seqid) override {
-    return static_cast<Protocol_*>(this)->readMessageBegin(name, messageType, seqid);
-  }
-
-  uint32_t readMessageEnd_virt() override { return static_cast<Protocol_*>(this)->readMessageEnd(); }
-
-  uint32_t readStructBegin_virt(std::string& name) override {
-    return static_cast<Protocol_*>(this)->readStructBegin(name);
-  }
-
-  uint32_t readStructEnd_virt() override { return static_cast<Protocol_*>(this)->readStructEnd(); }
-
-  uint32_t readFieldBegin_virt(std::string& name, TType& fieldType, int16_t& fieldId) override {
-    return static_cast<Protocol_*>(this)->readFieldBegin(name, fieldType, fieldId);
-  }
-
-  uint32_t readFieldEnd_virt() override { return static_cast<Protocol_*>(this)->readFieldEnd(); }
-
-  uint32_t readMapBegin_virt(TType& keyType, TType& valType, uint32_t& size) override {
-    return static_cast<Protocol_*>(this)->readMapBegin(keyType, valType, size);
-  }
-
-  uint32_t readMapEnd_virt() override { return static_cast<Protocol_*>(this)->readMapEnd(); }
-
-  uint32_t readListBegin_virt(TType& elemType, uint32_t& size) override {
-    return static_cast<Protocol_*>(this)->readListBegin(elemType, size);
-  }
-
-  uint32_t readListEnd_virt() override { return static_cast<Protocol_*>(this)->readListEnd(); }
-
-  uint32_t readSetBegin_virt(TType& elemType, uint32_t& size) override {
-    return static_cast<Protocol_*>(this)->readSetBegin(elemType, size);
-  }
-
-  uint32_t readSetEnd_virt() override { return static_cast<Protocol_*>(this)->readSetEnd(); }
-
-  uint32_t readBool_virt(bool& value) override {
-    return static_cast<Protocol_*>(this)->readBool(value);
-  }
-
-  uint32_t readBool_virt(duckdb::vector<bool>::reference value) override {
-    return static_cast<Protocol_*>(this)->readBool(value);
-  }
-
-  uint32_t readByte_virt(int8_t& byte) override {
-    return static_cast<Protocol_*>(this)->readByte(byte);
-  }
-
-  uint32_t readI16_virt(int16_t& i16) override {
-    return static_cast<Protocol_*>(this)->readI16(i16);
-  }
-
-  uint32_t readI32_virt(int32_t& i32) override {
-    return static_cast<Protocol_*>(this)->readI32(i32);
-  }
-
-  uint32_t readI64_virt(int64_t& i64) override {
-    return static_cast<Protocol_*>(this)->readI64(i64);
-  }
-
-  uint32_t readDouble_virt(double& dub) override {
-    return static_cast<Protocol_*>(this)->readDouble(dub);
-  }
-
-  uint32_t readString_virt(std::string& str) override {
-    return static_cast<Protocol_*>(this)->readString(str);
-  }
-
-  uint32_t readBinary_virt(std::string& str) override {
-    return static_cast<Protocol_*>(this)->readBinary(str);
-  }
-
-  uint32_t skip_virt(TType type) override { return static_cast<Protocol_*>(this)->skip(type); }
-
-  /*
-   * Provide a default skip() implementation that uses non-virtual read
-   * methods.
-   *
-   * Note: subclasses that use TVirtualProtocol to derive from another protocol
-   * implementation (i.e., not TProtocolDefaults) should beware that this may
-   * override any non-default skip() implementation provided by the parent
-   * transport class.  They may need to explicitly redefine skip() to call the
-   * correct parent implementation, if desired.
-   */
-  uint32_t skip(TType type) {
-    auto* const prot = static_cast<Protocol_*>(this);
-    return ::duckdb_apache::thrift::protocol::skip(*prot, type);
-  }
-
-  /*
-   * Provide a default readBool() implementation for use with
-   * duckdb::vector<bool>, that behaves the same as reading into a normal bool.
-   *
-   * Subclasses can override this if desired, but there normally shouldn't
-   * be a need to.
-   */
-  uint32_t readBool(duckdb::vector<bool>::reference value) {
-    bool b = false;
-    uint32_t ret = static_cast<Protocol_*>(this)->readBool(b);
-    value = b;
-    return ret;
-  }
-  using Super_::readBool; // so we don't hide readBool(bool&)
-
-protected:
-  TVirtualProtocol(std::shared_ptr<TTransport> ptrans) : Super_(ptrans) {}
-};
-}
-}
-} // duckdb_apache::thrift::protocol
-
-#endif // #define _DUCKDB_THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_ 1
diff --git a/src/duckdb/third_party/thrift/thrift/stdcxx.h b/src/duckdb/third_party/thrift/thrift/stdcxx.h
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/duckdb/third_party/thrift/thrift/thrift-config.h b/src/duckdb/third_party/thrift/thrift/thrift-config.h
deleted file mode 100644
index 33fdfd39a..000000000
--- a/src/duckdb/third_party/thrift/thrift/thrift-config.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef THRIFT_CONFIG_H
-#define THRIFT_CONFIG_H
-
-
-#ifdef _WIN32
-#if defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-#define ARITHMETIC_RIGHT_SHIFT 1
-#define SIGNED_RIGHT_SHIFT_IS 1
-#endif
-#else
-#define SIGNED_RIGHT_SHIFT_IS  1
-#define ARITHMETIC_RIGHT_SHIFT 1
-#endif
-
-#endif
diff --git a/src/duckdb/third_party/thrift/thrift/thrift_export.h b/src/duckdb/third_party/thrift/thrift/thrift_export.h
deleted file mode 100644
index f5c059fb7..000000000
--- a/src/duckdb/third_party/thrift/thrift/thrift_export.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef THRIFT_EXPORT_H
-#define THRIFT_EXPORT_H
-
-#ifdef THRIFT_STATIC_DEFINE
-#  define THRIFT_EXPORT
-#elif defined(_MSC_VER )
-#  ifndef THRIFT_EXPORT
-#    ifdef thrift_EXPORTS
-          /* We are building this library */
-#      define THRIFT_EXPORT __declspec(dllexport)
-#    else
-          /* We are using this library */
-#      define THRIFT_EXPORT __declspec(dllimport)
-#    endif
-#  endif
-#else
-#  define THRIFT_EXPORT
-#endif
-
-#endif /* THRIFT_EXPORT_H */
diff --git a/src/duckdb/third_party/thrift/thrift/transport/PlatformSocket.h b/src/duckdb/third_party/thrift/thrift/transport/PlatformSocket.h
deleted file mode 100644
index c1b0c55ca..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/PlatformSocket.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-// clang-format off
-
-#ifndef _DUCKDB_THRIFT_TRANSPORT_PLATFORM_SOCKET_H_
-#  define _DUCKDB_THRIFT_TRANSPORT_PLATFORM_SOCKET_H_
-
-#ifdef _WIN32
-#ifdef _WINSOCKAPI_
-#undef _WINSOCKAPI_
-#endif
-#  include <winsock2.h>
-#  define THRIFT_GET_SOCKET_ERROR ::WSAGetLastError()
-#  define THRIFT_ERRNO (*_errno())
-#  define THRIFT_EINPROGRESS WSAEINPROGRESS
-#  define THRIFT_EAGAIN WSAEWOULDBLOCK
-#  define THRIFT_EINTR WSAEINTR
-#  define THRIFT_ECONNRESET WSAECONNRESET
-#  define THRIFT_ENOTCONN WSAENOTCONN
-#  define THRIFT_ETIMEDOUT WSAETIMEDOUT
-#  define THRIFT_EWOULDBLOCK WSAEWOULDBLOCK
-#  define THRIFT_EPIPE WSAECONNRESET
-#  define THRIFT_NO_SOCKET_CACHING SO_EXCLUSIVEADDRUSE
-#  define THRIFT_SOCKET SOCKET
-#  define THRIFT_INVALID_SOCKET INVALID_SOCKET
-#  define THRIFT_SOCKETPAIR thrift_socketpair
-#  define THRIFT_FCNTL thrift_fcntl
-#  define THRIFT_O_NONBLOCK 1
-#  define THRIFT_F_GETFL 0
-#  define THRIFT_F_SETFL 1
-#  define THRIFT_GETTIMEOFDAY thrift_gettimeofday
-#  define THRIFT_CLOSESOCKET closesocket
-#  define THRIFT_CLOSE _close
-#  define THRIFT_OPEN _open
-#  define THRIFT_FTRUNCATE _chsize_s
-#  define THRIFT_FSYNC _commit
-#  define THRIFT_LSEEK _lseek
-#  define THRIFT_WRITE _write
-#  define THRIFT_READ _read
-#  define THRIFT_IOCTL_SOCKET ioctlsocket
-#  define THRIFT_IOCTL_SOCKET_NUM_BYTES_TYPE u_long
-#  define THRIFT_FSTAT _fstat
-#  define THRIFT_STAT _stat
-#  ifdef _WIN32_WCE
-#    define THRIFT_GAI_STRERROR(...) thrift_wstr2str(gai_strerrorW(__VA_ARGS__))
-#  else
-#    define THRIFT_GAI_STRERROR gai_strerrorA
-#  endif
-#  define THRIFT_SSIZET ptrdiff_t
-#  if (_MSC_VER < 1900)
-#    define THRIFT_SNPRINTF _snprintf
-#  else
-#    define THRIFT_SNPRINTF snprintf
-#  endif
-#  define THRIFT_SLEEP_SEC thrift_sleep
-#  define THRIFT_SLEEP_USEC thrift_usleep
-#  define THRIFT_TIMESPEC thrift_timespec
-#  define THRIFT_CTIME_R thrift_ctime_r
-#  define THRIFT_POLL thrift_poll
-#  if WINVER <= 0x0502 //XP, Server2003
-#    define THRIFT_POLLFD  thrift_pollfd
-#    define THRIFT_POLLIN  0x0300
-#    define THRIFT_POLLOUT 0x0010
-#  else //Vista, Win7...
-#    define THRIFT_POLLFD  pollfd
-#    define THRIFT_POLLIN  POLLIN
-#    define THRIFT_POLLOUT POLLOUT
-#  endif //WINVER
-#  define THRIFT_SHUT_RDWR SD_BOTH
-#  if !defined(AI_ADDRCONFIG)
-#    define AI_ADDRCONFIG 0x00000400
-#  endif
-#else //not _WIN32
-#  include <errno.h>
-#  define THRIFT_GET_SOCKET_ERROR errno
-#  define THRIFT_ERRNO errno
-#  define THRIFT_EINTR       EINTR
-#  define THRIFT_EINPROGRESS EINPROGRESS
-#  define THRIFT_ECONNRESET  ECONNRESET
-#  define THRIFT_ENOTCONN    ENOTCONN
-#  define THRIFT_ETIMEDOUT   ETIMEDOUT
-#  define THRIFT_EWOULDBLOCK EWOULDBLOCK
-#  define THRIFT_EAGAIN      EAGAIN
-#  define THRIFT_EPIPE       EPIPE
-#  define THRIFT_NO_SOCKET_CACHING SO_REUSEADDR
-#  define THRIFT_SOCKET int
-#  define THRIFT_INVALID_SOCKET (-1)
-#  define THRIFT_SOCKETPAIR socketpair
-#  define THRIFT_FCNTL fcntl
-#  define THRIFT_O_NONBLOCK O_NONBLOCK
-#  define THRIFT_F_GETFL F_GETFL
-#  define THRIFT_F_SETFL F_SETFL
-#  define THRIFT_GETTIMEOFDAY gettimeofday
-#  define THRIFT_CLOSESOCKET close
-#  define THRIFT_CLOSE close
-#  define THRIFT_OPEN open
-#  define THRIFT_FTRUNCATE ftruncate
-#  define THRIFT_FSYNC fsync
-#  define THRIFT_LSEEK lseek
-#  define THRIFT_WRITE write
-#  define THRIFT_READ read
-#  define THRIFT_IOCTL_SOCKET ioctl
-#  define THRIFT_IOCTL_SOCKET_NUM_BYTES_TYPE int
-#  define THRIFT_STAT stat
-#  define THRIFT_FSTAT fstat
-#  define THRIFT_GAI_STRERROR gai_strerror
-#  define THRIFT_SSIZET ssize_t
-#  define THRIFT_SNPRINTF snprintf
-#  define THRIFT_SLEEP_SEC sleep
-#  define THRIFT_SLEEP_USEC usleep
-#  define THRIFT_TIMESPEC timespec
-#  define THRIFT_CTIME_R ctime_r
-#  define THRIFT_POLL poll
-#  define THRIFT_POLLFD  pollfd
-#  define THRIFT_POLLIN  POLLIN
-#  define THRIFT_POLLOUT POLLOUT
-#  define THRIFT_SHUT_RDWR SHUT_RDWR
-#endif
-
-#endif // _DUCKDB_THRIFT_TRANSPORT_PLATFORM_SOCKET_H_
diff --git a/src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp b/src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp
deleted file mode 100644
index 2b0e470d5..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <cassert>
-#include <algorithm>
-#include "thrift/thrift_export.h"
-
-#include "thrift/transport/TBufferTransports.h"
-
-using std::string;
-
-namespace duckdb_apache {
-namespace thrift {
-namespace transport {
-
-
-
-
-void TMemoryBuffer::computeRead(uint32_t len, uint8_t** out_start, uint32_t* out_give) {
-  // Correct rBound_ so we can use the fast path in the future.
-  rBound_ = wBase_;
-
-  // Decide how much to give.
-  uint32_t give = (std::min)(len, available_read());
-
-  *out_start = rBase_;
-  *out_give = give;
-
-  // Preincrement rBase_ so the caller doesn't have to.
-  rBase_ += give;
-}
-
-uint32_t TMemoryBuffer::readSlow(uint8_t* buf, uint32_t len) {
-  uint8_t* start;
-  uint32_t give;
-  computeRead(len, &start, &give);
-
-  // Copy into the provided buffer.
-  memcpy(buf, start, give);
-
-  return give;
-}
-
-uint32_t TMemoryBuffer::readAppendToString(std::string& str, uint32_t len) {
-  // Don't get some stupid assertion failure.
-  if (buffer_ == nullptr) {
-    return 0;
-  }
-
-  uint8_t* start;
-  uint32_t give;
-  computeRead(len, &start, &give);
-
-  // Append to the provided string.
-  str.append((char*)start, give);
-
-  return give;
-}
-
-void TMemoryBuffer::ensureCanWrite(uint32_t len) {
-  // Check available space
-  uint32_t avail = available_write();
-  if (len <= avail) {
-    return;
-  }
-
-  if (!owner_) {
-    throw TTransportException("Insufficient space in external MemoryBuffer");
-  }
-
-  // Grow the buffer as necessary.
-  uint64_t new_size = bufferSize_;
-  while (len > avail) {
-    new_size = new_size > 0 ? new_size * 2 : 1;
-    if (new_size > maxBufferSize_) {
-      throw TTransportException(TTransportException::BAD_ARGS,
-                                "Internal buffer size overflow");
-    }
-    avail = available_write() + (static_cast<uint32_t>(new_size) - bufferSize_);
-  }
-
-  // Allocate into a new pointer so we don't bork ours if it fails.
-  auto* new_buffer = static_cast<uint8_t*>(std::realloc(buffer_, new_size));
-  if (new_buffer == nullptr) {
-    throw std::bad_alloc();
-  }
-
-  rBase_ = new_buffer + (rBase_ - buffer_);
-  rBound_ = new_buffer + (rBound_ - buffer_);
-  wBase_ = new_buffer + (wBase_ - buffer_);
-  wBound_ = new_buffer + new_size;
-  buffer_ = new_buffer;
-  bufferSize_ = static_cast<uint32_t>(new_size);
-}
-
-void TMemoryBuffer::writeSlow(const uint8_t* buf, uint32_t len) {
-  ensureCanWrite(len);
-
-  // Copy into the buffer and increment wBase_.
-  memcpy(wBase_, buf, len);
-  wBase_ += len;
-}
-
-void TMemoryBuffer::wroteBytes(uint32_t len) {
-  uint32_t avail = available_write();
-  if (len > avail) {
-    throw TTransportException("Client wrote more bytes than size of buffer.");
-  }
-  wBase_ += len;
-}
-
-const uint8_t* TMemoryBuffer::borrowSlow(uint8_t* buf, uint32_t* len) {
-  (void)buf;
-  rBound_ = wBase_;
-  if (available_read() >= *len) {
-    *len = available_read();
-    return rBase_;
-  }
-  return nullptr;
-}
-}
-}
-} // duckdb_apache::thrift::transport
diff --git a/src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.h b/src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.h
deleted file mode 100644
index 9381f3892..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.h
+++ /dev/null
@@ -1,488 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TRANSPORT_TBUFFERTRANSPORTS_H_
-#define _DUCKDB_THRIFT_TRANSPORT_TBUFFERTRANSPORTS_H_ 1
-
-#include <cstdlib>
-#include <cstddef>
-#include <cstring>
-#include <limits>
-
-#include "thrift/transport/TTransport.h"
-#include "thrift/transport/TVirtualTransport.h"
-
-#ifdef __GNUC__
-#define TDB_LIKELY(val) (__builtin_expect((val), 1))
-#define TDB_UNLIKELY(val) (__builtin_expect((val), 0))
-#else
-#define TDB_LIKELY(val) (val)
-#define TDB_UNLIKELY(val) (val)
-#endif
-
-namespace duckdb_apache {
-namespace thrift {
-namespace transport {
-
-/**
- * Base class for all transports that use read/write buffers for performance.
- *
- * TBufferBase is designed to implement the fast-path "memcpy" style
- * operations that work in the common case.  It does so with small and
- * (eventually) nonvirtual, inlinable methods.  TBufferBase is an abstract
- * class.  Subclasses are expected to define the "slow path" operations
- * that have to be done when the buffers are full or empty.
- *
- */
-class TBufferBase : public TVirtualTransport<TBufferBase> {
-
-public:
-  /**
-   * Fast-path read.
-   *
-   * When we have enough data buffered to fulfill the read, we can satisfy it
-   * with a single memcpy, then adjust our internal pointers.  If the buffer
-   * is empty, we call out to our slow path, implemented by a subclass.
-   * This method is meant to eventually be nonvirtual and inlinable.
-   */
-  uint32_t read(uint8_t* buf, uint32_t len) {
-    uint8_t* new_rBase = rBase_ + len;
-    if (TDB_LIKELY(new_rBase <= rBound_)) {
-      std::memcpy(buf, rBase_, len);
-      rBase_ = new_rBase;
-      return len;
-    }
-    return readSlow(buf, len);
-  }
-
-  /**
-   * Shortcutted version of readAll.
-   */
-  uint32_t readAll(uint8_t* buf, uint32_t len) {
-    uint8_t* new_rBase = rBase_ + len;
-    if (TDB_LIKELY(new_rBase <= rBound_)) {
-      std::memcpy(buf, rBase_, len);
-      rBase_ = new_rBase;
-      return len;
-    }
-    return duckdb_apache::thrift::transport::readAll(*this, buf, len);
-  }
-
-  /**
-   * Fast-path write.
-   *
-   * When we have enough empty space in our buffer to accommodate the write, we
-   * can satisfy it with a single memcpy, then adjust our internal pointers.
-   * If the buffer is full, we call out to our slow path, implemented by a
-   * subclass.  This method is meant to eventually be nonvirtual and
-   * inlinable.
-   */
-  void write(const uint8_t* buf, uint32_t len) {
-    uint8_t* new_wBase = wBase_ + len;
-    if (TDB_LIKELY(new_wBase <= wBound_)) {
-      std::memcpy(wBase_, buf, len);
-      wBase_ = new_wBase;
-      return;
-    }
-    writeSlow(buf, len);
-  }
-
-  /**
-   * Fast-path borrow.  A lot like the fast-path read.
-   */
-  const uint8_t* borrow(uint8_t* buf, uint32_t* len) {
-    if (TDB_LIKELY(static_cast<ptrdiff_t>(*len) <= rBound_ - rBase_)) {
-      // With strict aliasing, writing to len shouldn't force us to
-      // refetch rBase_ from memory.  TODO(dreiss): Verify this.
-      *len = static_cast<uint32_t>(rBound_ - rBase_);
-      return rBase_;
-    }
-    return borrowSlow(buf, len);
-  }
-
-  /**
-   * Consume doesn't require a slow path.
-   */
-  void consume(uint32_t len) {
-    if (TDB_LIKELY(static_cast<ptrdiff_t>(len) <= rBound_ - rBase_)) {
-      rBase_ += len;
-    } else {
-      throw TTransportException(TTransportException::BAD_ARGS, "consume did not follow a borrow.");
-    }
-  }
-
-protected:
-  /// Slow path read.
-  virtual uint32_t readSlow(uint8_t* buf, uint32_t len) = 0;
-
-  /// Slow path write.
-  virtual void writeSlow(const uint8_t* buf, uint32_t len) = 0;
-
-  /**
-   * Slow path borrow.
-   *
-   * POSTCONDITION: return == NULL || rBound_ - rBase_ >= *len
-   */
-  virtual const uint8_t* borrowSlow(uint8_t* buf, uint32_t* len) = 0;
-
-  /**
-   * Trivial constructor.
-   *
-   * Initialize pointers safely.  Constructing is not a very
-   * performance-sensitive operation, so it is okay to just leave it to
-   * the concrete class to set up pointers correctly.
-   */
-  TBufferBase() : rBase_(nullptr), rBound_(nullptr), wBase_(nullptr), wBound_(nullptr) {}
-
-  /// Convenience mutator for setting the read buffer.
-  void setReadBuffer(uint8_t* buf, uint32_t len) {
-    rBase_ = buf;
-    rBound_ = buf + len;
-  }
-
-  /// Convenience mutator for setting the write buffer.
-  void setWriteBuffer(uint8_t* buf, uint32_t len) {
-    wBase_ = buf;
-    wBound_ = buf + len;
-  }
-
-  ~TBufferBase() override = default;
-
-  /// Reads begin here.
-  uint8_t* rBase_;
-  /// Reads may extend to just before here.
-  uint8_t* rBound_;
-
-  /// Writes begin here.
-  uint8_t* wBase_;
-  /// Writes may extend to just before here.
-  uint8_t* wBound_;
-};
-
-
-/**
- * A memory buffer is a transport that simply reads from and writes to an
- * in memory buffer. Anytime you call write on it, the data is simply placed
- * into a buffer, and anytime you call read, data is read from that buffer.
- *
- * The buffers are allocated using C constructs malloc,realloc, and the size
- * doubles as necessary.  We've considered using scoped
- *
- */
-class TMemoryBuffer : public TVirtualTransport<TMemoryBuffer, TBufferBase> {
-private:
-  // Common initialization done by all constructors.
-  void initCommon(uint8_t* buf, uint32_t size, bool owner, uint32_t wPos) {
-
-    maxBufferSize_ = (std::numeric_limits<uint32_t>::max)();
-
-    if (buf == nullptr && size != 0) {
-      assert(owner);
-      buf = (uint8_t*)std::malloc(size);
-      if (buf == nullptr) {
-	throw std::bad_alloc();
-      }
-    }
-
-    buffer_ = buf;
-    bufferSize_ = size;
-
-    rBase_ = buffer_;
-    rBound_ = buffer_ + wPos;
-    // TODO(dreiss): Investigate NULL-ing this if !owner.
-    wBase_ = buffer_ + wPos;
-    wBound_ = buffer_ + bufferSize_;
-
-    owner_ = owner;
-
-    // rBound_ is really an artifact.  In principle, it should always be
-    // equal to wBase_.  We update it in a few places (computeRead, etc.).
-  }
-
-public:
-  static const uint32_t defaultSize = 1024;
-
-  /**
-   * This enum specifies how a TMemoryBuffer should treat
-   * memory passed to it via constructors or resetBuffer.
-   *
-   * OBSERVE:
-   *   TMemoryBuffer will simply store a pointer to the memory.
-   *   It is the callers responsibility to ensure that the pointer
-   *   remains valid for the lifetime of the TMemoryBuffer,
-   *   and that it is properly cleaned up.
-   *   Note that no data can be written to observed buffers.
-   *
-   * COPY:
-   *   TMemoryBuffer will make an internal copy of the buffer.
-   *   The caller has no responsibilities.
-   *
-   * TAKE_OWNERSHIP:
-   *   TMemoryBuffer will become the "owner" of the buffer,
-   *   and will be responsible for freeing it.
-   *   The membory must have been allocated with malloc.
-   */
-  enum MemoryPolicy { OBSERVE = 1, COPY = 2, TAKE_OWNERSHIP = 3 };
-
-  /**
-   * Construct a TMemoryBuffer with a default-sized buffer,
-   * owned by the TMemoryBuffer object.
-   */
-  TMemoryBuffer() { initCommon(nullptr, defaultSize, true, 0); }
-
-  /**
-   * Construct a TMemoryBuffer with a buffer of a specified size,
-   * owned by the TMemoryBuffer object.
-   *
-   * @param sz  The initial size of the buffer.
-   */
-  TMemoryBuffer(uint32_t sz) { initCommon(nullptr, sz, true, 0); }
-
-  /**
-   * Construct a TMemoryBuffer with buf as its initial contents.
-   *
-   * @param buf    The initial contents of the buffer.
-   *               Note that, while buf is a non-const pointer,
-   *               TMemoryBuffer will not write to it if policy == OBSERVE,
-   *               so it is safe to const_cast<uint8_t*>(whatever).
-   * @param sz     The size of @c buf.
-   * @param policy See @link MemoryPolicy @endlink .
-   */
-  TMemoryBuffer(uint8_t* buf, uint32_t sz, MemoryPolicy policy = OBSERVE) {
-    if (buf == nullptr && sz != 0) {
-      throw TTransportException(TTransportException::BAD_ARGS,
-                                "TMemoryBuffer given null buffer with non-zero size.");
-    }
-
-    switch (policy) {
-    case OBSERVE:
-    case TAKE_OWNERSHIP:
-      initCommon(buf, sz, policy == TAKE_OWNERSHIP, sz);
-      break;
-    case COPY:
-      initCommon(nullptr, sz, true, 0);
-      this->write(buf, sz);
-      break;
-    default:
-      throw TTransportException(TTransportException::BAD_ARGS,
-                                "Invalid MemoryPolicy for TMemoryBuffer");
-    }
-  }
-
-  ~TMemoryBuffer() override {
-    if (owner_) {
-      std::free(buffer_);
-    }
-  }
-
-  bool isOpen() const override { return true; }
-
-  bool peek() override { return (rBase_ < wBase_); }
-
-  void open() override {}
-
-  void close() override {}
-
-  // TODO(dreiss): Make bufPtr const.
-  void getBuffer(uint8_t** bufPtr, uint32_t* sz) {
-    *bufPtr = rBase_;
-    *sz = static_cast<uint32_t>(wBase_ - rBase_);
-  }
-
-  std::string getBufferAsString() {
-    if (buffer_ == nullptr) {
-      return "";
-    }
-    uint8_t* buf;
-    uint32_t sz;
-    getBuffer(&buf, &sz);
-    return std::string((char*)buf, (std::string::size_type)sz);
-  }
-
-  void appendBufferToString(std::string& str) {
-    if (buffer_ == nullptr) {
-      return;
-    }
-    uint8_t* buf;
-    uint32_t sz;
-    getBuffer(&buf, &sz);
-    str.append((char*)buf, sz);
-  }
-
-  void resetBuffer() {
-    rBase_ = buffer_;
-    rBound_ = buffer_;
-    wBase_ = buffer_;
-    // It isn't safe to write into a buffer we don't own.
-    if (!owner_) {
-      wBound_ = wBase_;
-      bufferSize_ = 0;
-    }
-  }
-
-  /// See constructor documentation.
-  void resetBuffer(uint8_t* buf, uint32_t sz, MemoryPolicy policy = OBSERVE) {
-    // Use a variant of the copy-and-swap trick for assignment operators.
-    // This is sub-optimal in terms of performance for two reasons:
-    //   1/ The constructing and swapping of the (small) values
-    //      in the temporary object takes some time, and is not necessary.
-    //   2/ If policy == COPY, we allocate the new buffer before
-    //      freeing the old one, precluding the possibility of
-    //      reusing that memory.
-    // I doubt that either of these problems could be optimized away,
-    // but the second is probably no a common case, and the first is minor.
-    // I don't expect resetBuffer to be a common operation, so I'm willing to
-    // bite the performance bullet to make the method this simple.
-
-    // Construct the new buffer.
-    TMemoryBuffer new_buffer(buf, sz, policy);
-    // Move it into ourself.
-    this->swap(new_buffer);
-    // Our old self gets destroyed.
-  }
-
-  /// See constructor documentation.
-  void resetBuffer(uint32_t sz) {
-    // Construct the new buffer.
-    TMemoryBuffer new_buffer(sz);
-    // Move it into ourself.
-    this->swap(new_buffer);
-    // Our old self gets destroyed.
-  }
-
-  std::string readAsString(uint32_t len) {
-    std::string str;
-    (void)readAppendToString(str, len);
-    return str;
-  }
-
-  uint32_t readAppendToString(std::string& str, uint32_t len);
-
-  // return number of bytes read
-  uint32_t readEnd() override {
-    // This cast should be safe, because buffer_'s size is a uint32_t
-    auto bytes = static_cast<uint32_t>(rBase_ - buffer_);
-    if (rBase_ == wBase_) {
-      resetBuffer();
-    }
-    return bytes;
-  }
-
-  // Return number of bytes written
-  uint32_t writeEnd() override {
-    // This cast should be safe, because buffer_'s size is a uint32_t
-    return static_cast<uint32_t>(wBase_ - buffer_);
-  }
-
-  uint32_t available_read() const {
-    // Remember, wBase_ is the real rBound_.
-    return static_cast<uint32_t>(wBase_ - rBase_);
-  }
-
-  uint32_t available_write() const { return static_cast<uint32_t>(wBound_ - wBase_); }
-
-  // Returns a pointer to where the client can write data to append to
-  // the TMemoryBuffer, and ensures the buffer is big enough to accommodate a
-  // write of the provided length.  The returned pointer is very convenient for
-  // passing to read(), recv(), or similar. You must call wroteBytes() as soon
-  // as data is written or the buffer will not be aware that data has changed.
-  uint8_t* getWritePtr(uint32_t len) {
-    ensureCanWrite(len);
-    return wBase_;
-  }
-
-  // Informs the buffer that the client has written 'len' bytes into storage
-  // that had been provided by getWritePtr().
-  void wroteBytes(uint32_t len);
-
-  /*
-   * TVirtualTransport provides a default implementation of readAll().
-   * We want to use the TBufferBase version instead.
-   */
-  uint32_t readAll(uint8_t* buf, uint32_t len) { return TBufferBase::readAll(buf, len); }
-
-  //! \brief Get the current buffer size
-  //! \returns the current buffer size
-  uint32_t getBufferSize() const {
-    return bufferSize_;
-  }
-
-  //! \brief Get the current maximum buffer size
-  //! \returns the current maximum buffer size
-  uint32_t getMaxBufferSize() const {
-    return maxBufferSize_;
-  }
-
-  //! \brief Change the maximum buffer size
-  //! \param[in]  maxSize  the new maximum buffer size allowed to grow to
-  //! \throws  TTransportException(BAD_ARGS) if maxSize is less than the current buffer size
-  void setMaxBufferSize(uint32_t maxSize) {
-    if (maxSize < bufferSize_) {
-      throw TTransportException(TTransportException::BAD_ARGS,
-                                "Maximum buffer size would be less than current buffer size");
-    }
-    maxBufferSize_ = maxSize;
-  }
-
-protected:
-  void swap(TMemoryBuffer& that) {
-    using std::swap;
-    swap(buffer_, that.buffer_);
-    swap(bufferSize_, that.bufferSize_);
-
-    swap(rBase_, that.rBase_);
-    swap(rBound_, that.rBound_);
-    swap(wBase_, that.wBase_);
-    swap(wBound_, that.wBound_);
-
-    swap(owner_, that.owner_);
-  }
-
-  // Make sure there's at least 'len' bytes available for writing.
-  void ensureCanWrite(uint32_t len);
-
-  // Compute the position and available data for reading.
-  void computeRead(uint32_t len, uint8_t** out_start, uint32_t* out_give);
-
-  uint32_t readSlow(uint8_t* buf, uint32_t len) override;
-
-  void writeSlow(const uint8_t* buf, uint32_t len) override;
-
-  const uint8_t* borrowSlow(uint8_t* buf, uint32_t* len) override;
-
-  // Data buffer
-  uint8_t* buffer_;
-
-  // Allocated buffer size
-  uint32_t bufferSize_;
-
-  // Maximum allowed size
-  uint32_t maxBufferSize_;
-
-  // Is this object the owner of the buffer?
-  bool owner_;
-
-  // Don't forget to update constrctors, initCommon, and swap if
-  // you add new members.
-};
-}
-}
-} // duckdb_apache::thrift::transport
-
-#endif // #ifndef _DUCKDB_THRIFT_TRANSPORT_TBUFFERTRANSPORTS_H_
diff --git a/src/duckdb/third_party/thrift/thrift/transport/TTransport.h b/src/duckdb/third_party/thrift/thrift/transport/TTransport.h
deleted file mode 100644
index 8d5d86b16..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/TTransport.h
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TRANSPORT_TTRANSPORT_H_
-#define _DUCKDB_THRIFT_TRANSPORT_TTRANSPORT_H_ 1
-
-#include "thrift/Thrift.h"
-#include "thrift/transport/TTransportException.h"
-#include <memory>
-#include <string>
-
-namespace duckdb_apache {
-namespace thrift {
-namespace transport {
-
-/**
- * Helper template to hoist readAll implementation out of TTransport
- */
-template <class Transport_>
-uint32_t readAll(Transport_& trans, uint8_t* buf, uint32_t len) {
-  uint32_t have = 0;
-  uint32_t get = 0;
-
-  while (have < len) {
-    get = trans.read(buf + have, len - have);
-    if (get <= 0) {
-      throw TTransportException(TTransportException::END_OF_FILE, "No more data to read.");
-    }
-    have += get;
-  }
-
-  return have;
-}
-
-/**
- * Generic interface for a method of transporting data. A TTransport may be
- * capable of either reading or writing, but not necessarily both.
- *
- */
-class TTransport {
-public:
-  /**
-   * Virtual deconstructor.
-   */
-  virtual ~TTransport() = default;
-
-  /**
-   * Whether this transport is open.
-   */
-  virtual bool isOpen() const { return false; }
-
-  /**
-   * Tests whether there is more data to read or if the remote side is
-   * still open. By default this is true whenever the transport is open,
-   * but implementations should add logic to test for this condition where
-   * possible (i.e. on a socket).
-   * This is used by a server to check if it should listen for another
-   * request.
-   */
-  virtual bool peek() { return isOpen(); }
-
-  /**
-   * Opens the transport for communications.
-   *
-   * @return bool Whether the transport was successfully opened
-   * @throws TTransportException if opening failed
-   */
-  virtual void open() {
-    throw TTransportException(TTransportException::NOT_OPEN, "Cannot open base TTransport.");
-  }
-
-  /**
-   * Closes the transport.
-   */
-  virtual void close() {
-    throw TTransportException(TTransportException::NOT_OPEN, "Cannot close base TTransport.");
-  }
-
-  /**
-   * Attempt to read up to the specified number of bytes into the string.
-   *
-   * @param buf  Reference to the location to write the data
-   * @param len  How many bytes to read
-   * @return How many bytes were actually read
-   * @throws TTransportException If an error occurs
-   */
-  uint32_t read(uint8_t* buf, uint32_t len) {
-    T_VIRTUAL_CALL();
-    return read_virt(buf, len);
-  }
-  virtual uint32_t read_virt(uint8_t* /* buf */, uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot read.");
-  }
-
-  /**
-   * Reads the given amount of data in its entirety no matter what.
-   *
-   * @param s     Reference to location for read data
-   * @param len   How many bytes to read
-   * @return How many bytes read, which must be equal to size
-   * @throws TTransportException If insufficient data was read
-   */
-  uint32_t readAll(uint8_t* buf, uint32_t len) {
-    T_VIRTUAL_CALL();
-    return readAll_virt(buf, len);
-  }
-  virtual uint32_t readAll_virt(uint8_t* buf, uint32_t len) {
-    return duckdb_apache::thrift::transport::readAll(*this, buf, len);
-  }
-
-  /**
-   * Called when read is completed.
-   * This can be over-ridden to perform a transport-specific action
-   * e.g. logging the request to a file
-   *
-   * @return number of bytes read if available, 0 otherwise.
-   */
-  virtual uint32_t readEnd() {
-    // default behaviour is to do nothing
-    return 0;
-  }
-
-  /**
-   * Writes the string in its entirety to the buffer.
-   *
-   * Note: You must call flush() to ensure the data is actually written,
-   * and available to be read back in the future.  Destroying a TTransport
-   * object does not automatically flush pending data--if you destroy a
-   * TTransport object with written but unflushed data, that data may be
-   * discarded.
-   *
-   * @param buf  The data to write out
-   * @throws TTransportException if an error occurs
-   */
-  void write(const uint8_t* buf, uint32_t len) {
-    T_VIRTUAL_CALL();
-    write_virt(buf, len);
-  }
-  virtual void write_virt(const uint8_t* /* buf */, uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot write.");
-  }
-
-  /**
-   * Called when write is completed.
-   * This can be over-ridden to perform a transport-specific action
-   * at the end of a request.
-   *
-   * @return number of bytes written if available, 0 otherwise
-   */
-  virtual uint32_t writeEnd() {
-    // default behaviour is to do nothing
-    return 0;
-  }
-
-  /**
-   * Flushes any pending data to be written. Typically used with buffered
-   * transport mechanisms.
-   *
-   * @throws TTransportException if an error occurs
-   */
-  virtual void flush() {
-    // default behaviour is to do nothing
-  }
-
-  /**
-   * Attempts to return a pointer to \c len bytes, possibly copied into \c buf.
-   * Does not consume the bytes read (i.e.: a later read will return the same
-   * data).  This method is meant to support protocols that need to read
-   * variable-length fields.  They can attempt to borrow the maximum amount of
-   * data that they will need, then consume (see next method) what they
-   * actually use.  Some transports will not support this method and others
-   * will fail occasionally, so protocols must be prepared to use read if
-   * borrow fails.
-   *
-   * @oaram buf  A buffer where the data can be stored if needed.
-   *             If borrow doesn't return buf, then the contents of
-   *             buf after the call are undefined.  This parameter may be
-   *             NULL to indicate that the caller is not supplying storage,
-   *             but would like a pointer into an internal buffer, if
-   *             available.
-   * @param len  *len should initially contain the number of bytes to borrow.
-   *             If borrow succeeds, *len will contain the number of bytes
-   *             available in the returned pointer.  This will be at least
-   *             what was requested, but may be more if borrow returns
-   *             a pointer to an internal buffer, rather than buf.
-   *             If borrow fails, the contents of *len are undefined.
-   * @return If the borrow succeeds, return a pointer to the borrowed data.
-   *         This might be equal to \c buf, or it might be a pointer into
-   *         the transport's internal buffers.
-   * @throws TTransportException if an error occurs
-   */
-  const uint8_t* borrow(uint8_t* buf, uint32_t* len) {
-    T_VIRTUAL_CALL();
-    return borrow_virt(buf, len);
-  }
-  virtual const uint8_t* borrow_virt(uint8_t* /* buf */, uint32_t* /* len */) { return nullptr; }
-
-  /**
-   * Remove len bytes from the transport.  This should always follow a borrow
-   * of at least len bytes, and should always succeed.
-   * TODO(dreiss): Is there any transport that could borrow but fail to
-   * consume, or that would require a buffer to dump the consumed data?
-   *
-   * @param len  How many bytes to consume
-   * @throws TTransportException If an error occurs
-   */
-  void consume(uint32_t len) {
-    T_VIRTUAL_CALL();
-    consume_virt(len);
-  }
-  virtual void consume_virt(uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot consume.");
-  }
-
-  /**
-   * Returns the origin of the transports call. The value depends on the
-   * transport used. An IP based transport for example will return the
-   * IP address of the client making the request.
-   * If the transport doesn't know the origin Unknown is returned.
-   *
-   * The returned value can be used in a log message for example
-   */
-  virtual const std::string getOrigin() const { return "Unknown"; }
-
-protected:
-  /**
-   * Simple constructor.
-   */
-  TTransport() = default;
-};
-
-/**
- * Generic factory class to make an input and output transport out of a
- * source transport. Commonly used inside servers to make input and output
- * streams out of raw clients.
- *
- */
-class TTransportFactory {
-public:
-  TTransportFactory() = default;
-
-  virtual ~TTransportFactory() = default;
-
-  /**
-   * Default implementation does nothing, just returns the transport given.
-   */
-  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
-    return trans;
-  }
-};
-}
-}
-} // duckdb_apache::thrift::transport
-
-#endif // #ifndef _DUCKDB_THRIFT_TRANSPORT_TTRANSPORT_H_
diff --git a/src/duckdb/third_party/thrift/thrift/transport/TTransportException.cpp b/src/duckdb/third_party/thrift/thrift/transport/TTransportException.cpp
deleted file mode 100644
index de7431cc9..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/TTransportException.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "thrift/transport/TTransportException.h"
-#include <cstring>
-
-#include "thrift/thrift-config.h"
-
-using std::string;
-
-namespace duckdb_apache {
-namespace thrift {
-namespace transport {
-
-const char* TTransportException::what() const noexcept {
-  if (message_.empty()) {
-    switch (type_) {
-    case UNKNOWN:
-      return "TTransportException: Unknown transport exception";
-    case NOT_OPEN:
-      return "TTransportException: Transport not open";
-    case TIMED_OUT:
-      return "TTransportException: Timed out";
-    case END_OF_FILE:
-      return "TTransportException: End of file";
-    case INTERRUPTED:
-      return "TTransportException: Interrupted";
-    case BAD_ARGS:
-      return "TTransportException: Invalid arguments";
-    case CORRUPTED_DATA:
-      return "TTransportException: Corrupted Data";
-    case INTERNAL_ERROR:
-      return "TTransportException: Internal error";
-    default:
-      return "TTransportException: (Invalid exception type)";
-    }
-  } else {
-    return message_.c_str();
-  }
-}
-}
-}
-} // duckdb_apache::thrift::transport
diff --git a/src/duckdb/third_party/thrift/thrift/transport/TTransportException.h b/src/duckdb/third_party/thrift/thrift/transport/TTransportException.h
deleted file mode 100644
index 1cfafa543..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/TTransportException.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TRANSPORT_TTRANSPORTEXCEPTION_H_
-#define _DUCKDB_THRIFT_TRANSPORT_TTRANSPORTEXCEPTION_H_ 1
-
-#include <string>
-#include "thrift/Thrift.h"
-
-namespace duckdb_apache {
-namespace thrift {
-namespace transport {
-
-/**
- * Class to encapsulate all the possible types of transport errors that may
- * occur in various transport systems. This provides a sort of generic
- * wrapper around the vague UNIX E_ error codes that lets a common code
- * base of error handling to be used for various types of transports, i.e.
- * pipes etc.
- *
- */
-class TTransportException : public duckdb_apache::thrift::TException {
-public:
-  /**
-   * Error codes for the various types of exceptions.
-   */
-  enum TTransportExceptionType {
-    UNKNOWN = 0,
-    NOT_OPEN = 1,
-    TIMED_OUT = 2,
-    END_OF_FILE = 3,
-    INTERRUPTED = 4,
-    BAD_ARGS = 5,
-    CORRUPTED_DATA = 6,
-    INTERNAL_ERROR = 7
-  };
-
-  TTransportException() : duckdb_apache::thrift::TException(), type_(UNKNOWN) {}
-
-  TTransportException(TTransportExceptionType type) : duckdb_apache::thrift::TException(), type_(type) {}
-
-  TTransportException(const std::string& message)
-    : duckdb_apache::thrift::TException(message), type_(UNKNOWN) {}
-
-  TTransportException(TTransportExceptionType type, const std::string& message)
-    : duckdb_apache::thrift::TException(message), type_(type) {}
-
-  TTransportException(TTransportExceptionType type, const std::string& message, int errno_copy)
-    : duckdb_apache::thrift::TException(message), type_(type) {}
-
-  ~TTransportException() noexcept override = default;
-
-  /**
-   * Returns an error code that provides information about the type of error
-   * that has occurred.
-   *
-   * @return Error code
-   */
-  TTransportExceptionType getType() const noexcept { return type_; }
-
-  const char* what() const noexcept override;
-
-protected:
-  /** Just like strerror_r but returns a C++ string object. */
-  std::string strerror_s(int errno_copy);
-
-  /** Error code */
-  TTransportExceptionType type_;
-};
-
-///**
-// * Legacy code in transport implementations have overflow issues
-// * that need to be enforced.
-// */
-//template <typename To, typename From> To safe_numeric_cast(From i) {
-//  try {
-//    return boost::numeric_cast<To>(i);
-//  }
-//  catch (const std::bad_cast& bc) {
-//    throw TTransportException(TTransportException::CORRUPTED_DATA,
-//                              bc.what());
-//  }
-//}
-
-}
-}
-} // duckdb_apache::thrift::transport
-
-#endif // #ifndef _DUCKDB_THRIFT_TRANSPORT_TTRANSPORTEXCEPTION_H_
diff --git a/src/duckdb/third_party/thrift/thrift/transport/TVirtualTransport.h b/src/duckdb/third_party/thrift/thrift/transport/TVirtualTransport.h
deleted file mode 100644
index 3d70695a2..000000000
--- a/src/duckdb/third_party/thrift/thrift/transport/TVirtualTransport.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _DUCKDB_THRIFT_TRANSPORT_TVIRTUALTRANSPORT_H_
-#define _DUCKDB_THRIFT_TRANSPORT_TVIRTUALTRANSPORT_H_ 1
-
-#include "thrift/transport/TTransport.h"
-
-namespace duckdb_apache {
-namespace thrift {
-namespace transport {
-
-/**
- * Helper class that provides default implementations of TTransport methods.
- *
- * This class provides default implementations of read(), readAll(), write(),
- * borrow() and consume().
- *
- * In the TTransport base class, each of these methods simply invokes its
- * virtual counterpart.  This class overrides them to always perform the
- * default behavior, without a virtual function call.
- *
- * The primary purpose of this class is to serve as a base class for
- * TVirtualTransport, and prevent infinite recursion if one of its subclasses
- * does not override the TTransport implementation of these methods.  (Since
- * TVirtualTransport::read_virt() calls read(), and TTransport::read() calls
- * read_virt().)
- */
-class TTransportDefaults : public TTransport {
-public:
-  /*
-   * TTransport *_virt() methods provide reasonable default implementations.
-   * Invoke them non-virtually.
-   */
-  uint32_t read(uint8_t* buf, uint32_t len) { return this->TTransport::read_virt(buf, len); }
-  uint32_t readAll(uint8_t* buf, uint32_t len) { return this->TTransport::readAll_virt(buf, len); }
-  void write(const uint8_t* buf, uint32_t len) { this->TTransport::write_virt(buf, len); }
-  const uint8_t* borrow(uint8_t* buf, uint32_t* len) {
-    return this->TTransport::borrow_virt(buf, len);
-  }
-  void consume(uint32_t len) { this->TTransport::consume_virt(len); }
-
-protected:
-  TTransportDefaults() = default;
-};
-
-/**
- * Helper class to provide polymorphism for subclasses of TTransport.
- *
- * This class implements *_virt() methods of TTransport, to call the
- * non-virtual versions of these functions in the proper subclass.
- *
- * To define your own transport class using TVirtualTransport:
- * 1) Derive your subclass from TVirtualTransport<your class>
- *    e.g:  class MyTransport : public TVirtualTransport<MyTransport> {
- * 2) Provide your own implementations of read(), readAll(), etc.
- *    These methods should be non-virtual.
- *
- * Transport implementations that need to use virtual inheritance when
- * inheriting from TTransport cannot use TVirtualTransport.
- *
- * @author Chad Walters <chad@powerset.com>
- */
-template <class Transport_, class Super_ = TTransportDefaults>
-class TVirtualTransport : public Super_ {
-public:
-  /*
-   * Implementations of the *_virt() functions, to call the subclass's
-   * non-virtual implementation function.
-   */
-  uint32_t read_virt(uint8_t* buf, uint32_t len) override {
-    return static_cast<Transport_*>(this)->read(buf, len);
-  }
-
-  uint32_t readAll_virt(uint8_t* buf, uint32_t len) override {
-    return static_cast<Transport_*>(this)->readAll(buf, len);
-  }
-
-  void write_virt(const uint8_t* buf, uint32_t len) override {
-    static_cast<Transport_*>(this)->write(buf, len);
-  }
-
-  const uint8_t* borrow_virt(uint8_t* buf, uint32_t* len) override {
-    return static_cast<Transport_*>(this)->borrow(buf, len);
-  }
-
-  void consume_virt(uint32_t len) override { static_cast<Transport_*>(this)->consume(len); }
-
-  /*
-   * Provide a default readAll() implementation that invokes
-   * read() non-virtually.
-   *
-   * Note: subclasses that use TVirtualTransport to derive from another
-   * transport implementation (i.e., not TTransportDefaults) should beware that
-   * this may override any non-default readAll() implementation provided by
-   * the parent transport class.  They may need to redefine readAll() to call
-   * the correct parent implementation, if desired.
-   */
-  uint32_t readAll(uint8_t* buf, uint32_t len) {
-    auto* trans = static_cast<Transport_*>(this);
-    return ::duckdb_apache::thrift::transport::readAll(*trans, buf, len);
-  }
-
-protected:
-  TVirtualTransport() = default;
-
-  /*
-   * Templatized constructors, to allow arguments to be passed to the Super_
-   * constructor.  Currently we only support 0, 1, or 2 arguments, but
-   * additional versions can be added as needed.
-   */
-  template <typename Arg_>
-  TVirtualTransport(Arg_ const& arg)
-    : Super_(arg) {}
-
-  template <typename Arg1_, typename Arg2_>
-  TVirtualTransport(Arg1_ const& a1, Arg2_ const& a2)
-    : Super_(a1, a2) {}
-};
-}
-}
-} // duckdb_apache::thrift::transport
-
-#endif // #ifndef _DUCKDB_THRIFT_TRANSPORT_TVIRTUALTRANSPORT_H_
diff --git a/src/duckdb/third_party/utf8proc/include/utf8proc.hpp b/src/duckdb/third_party/utf8proc/include/utf8proc.hpp
deleted file mode 100644
index 5d66c15d3..000000000
--- a/src/duckdb/third_party/utf8proc/include/utf8proc.hpp
+++ /dev/null
@@ -1,727 +0,0 @@
-/*
- * Copyright (c) 2014-2021 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors.
- * Copyright (c) 2009 Public Software Group e. V., Berlin, Germany
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-
-/**
- * @mainpage
- *
- * utf8proc is a free/open-source (MIT/expat licensed) C library
- * providing Unicode normalization, case-folding, and other operations
- * for strings in the UTF-8 encoding, supporting up-to-date Unicode versions.
- * See the utf8proc home page (http://julialang.org/utf8proc/)
- * for downloads and other information, or the source code on github
- * (https://github.com/JuliaLang/utf8proc).
- *
- * For the utf8proc API documentation, see: @ref utf8proc.h
- *
- * The features of utf8proc include:
- *
- * - Transformation of strings (utf8proc_map()) to:
- *    - decompose (@ref UTF8PROC_DECOMPOSE) or compose (@ref UTF8PROC_COMPOSE) Unicode combining characters (http://en.wikipedia.org/wiki/Combining_character)
- *    - canonicalize Unicode compatibility characters (@ref UTF8PROC_COMPAT)
- *    - strip "ignorable" (@ref UTF8PROC_IGNORE) characters, control characters (@ref UTF8PROC_STRIPCC), or combining characters such as accents (@ref UTF8PROC_STRIPMARK)
- *    - case-folding (@ref UTF8PROC_CASEFOLD)
- * - Unicode normalization: utf8proc_NFD(), utf8proc_NFC(), utf8proc_NFKD(), utf8proc_NFKC()
- * - Detecting grapheme boundaries (utf8proc_grapheme_break() and @ref UTF8PROC_CHARBOUND)
- * - Character-width computation: utf8proc_charwidth()
- * - Classification of characters by Unicode category: utf8proc_category() and utf8proc_category_string()
- * - Encode (utf8proc_encode_char()) and decode (utf8proc_iterate()) Unicode codepoints to/from UTF-8.
- */
-
-/** @file */
-
-#ifndef UTF8PROC_H
-#define UTF8PROC_H
-
-/** @name API version
- *
- * The utf8proc API version MAJOR.MINOR.PATCH, following
- * semantic-versioning rules (http://semver.org) based on API
- * compatibility.
- *
- * This is also returned at runtime by utf8proc_version(); however, the
- * runtime version may append a string like "-dev" to the version number
- * for prerelease versions.
- *
- * @note The shared-library version number in the Makefile
- *       (and CMakeLists.txt, and MANIFEST) may be different,
- *       being based on ABI compatibility rather than API compatibility.
- */
-/** @{ */
-/** The MAJOR version number (increased when backwards API compatibility is broken). */
-#define UTF8PROC_VERSION_MAJOR 2
-/** The MINOR version number (increased when new functionality is added in a backwards-compatible manner). */
-#define UTF8PROC_VERSION_MINOR 9
-/** The PATCH version (increased for fixes that do not change the API). */
-#define UTF8PROC_VERSION_PATCH 0
-/** @} */
-
-#include <stdlib.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1800
-// MSVC prior to 2013 lacked stdbool.h and stdint.h
-typedef signed char utf8proc_int8_t;
-typedef unsigned char utf8proc_uint8_t;
-typedef short utf8proc_int16_t;
-typedef unsigned short utf8proc_uint16_t;
-typedef int utf8proc_int32_t;
-typedef unsigned int utf8proc_uint32_t;
-#  ifdef _WIN64
-typedef __int64 utf8proc_ssize_t;
-typedef unsigned __int64 utf8proc_size_t;
-#  else
-typedef int utf8proc_ssize_t;
-typedef unsigned int utf8proc_size_t;
-#  endif
-#  ifndef __cplusplus
-// emulate C99 bool
-typedef unsigned char utf8proc_bool;
-#    ifndef __bool_true_false_are_defined
-#      define false 0
-#      define true 1
-#      define __bool_true_false_are_defined 1
-#    endif
-#  else
-typedef bool utf8proc_bool;
-#  endif
-#else
-#  include <stddef.h>
-#  include <stdbool.h>
-#  include <stdint.h>
-typedef int8_t utf8proc_int8_t;
-typedef uint8_t utf8proc_uint8_t;
-typedef int16_t utf8proc_int16_t;
-typedef uint16_t utf8proc_uint16_t;
-typedef int32_t utf8proc_int32_t;
-typedef uint32_t utf8proc_uint32_t;
-typedef size_t utf8proc_size_t;
-typedef ptrdiff_t utf8proc_ssize_t;
-typedef bool utf8proc_bool;
-#endif
-#include <limits.h>
-
-#  define UTF8PROC_DLLEXPORT
-
-namespace duckdb {
-
-/**
- * Option flags used by several functions in the library.
- */
-typedef enum {
-  /** The given UTF-8 input is NULL terminated. */
-  UTF8PROC_NULLTERM  = (1<<0),
-  /** Unicode Versioning Stability has to be respected. */
-  UTF8PROC_STABLE    = (1<<1),
-  /** Compatibility decomposition (i.e. formatting information is lost). */
-  UTF8PROC_COMPAT    = (1<<2),
-  /** Return a result with decomposed characters. */
-  UTF8PROC_COMPOSE   = (1<<3),
-  /** Return a result with decomposed characters. */
-  UTF8PROC_DECOMPOSE = (1<<4),
-  /** Strip "default ignorable characters" such as SOFT-HYPHEN or ZERO-WIDTH-SPACE. */
-  UTF8PROC_IGNORE    = (1<<5),
-  /** Return an error, if the input contains unassigned codepoints. */
-  UTF8PROC_REJECTNA  = (1<<6),
-  /**
-   * Indicating that NLF-sequences (LF, CRLF, CR, NEL) are representing a
-   * line break, and should be converted to the codepoint for line
-   * separation (LS).
-   */
-  UTF8PROC_NLF2LS    = (1<<7),
-  /**
-   * Indicating that NLF-sequences are representing a paragraph break, and
-   * should be converted to the codepoint for paragraph separation
-   * (PS).
-   */
-  UTF8PROC_NLF2PS    = (1<<8),
-  /** Indicating that the meaning of NLF-sequences is unknown. */
-  UTF8PROC_NLF2LF    = (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS),
-  /** Strips and/or convers control characters.
-   *
-   * NLF-sequences are transformed into space, except if one of the
-   * NLF2LS/PS/LF options is given. HorizontalTab (HT) and FormFeed (FF)
-   * are treated as a NLF-sequence in this case.  All other control
-   * characters are simply removed.
-   */
-  UTF8PROC_STRIPCC   = (1<<9),
-  /**
-   * Performs unicode case folding, to be able to do a case-insensitive
-   * string comparison.
-   */
-  UTF8PROC_CASEFOLD  = (1<<10),
-  /**
-   * Inserts 0xFF bytes at the beginning of each sequence which is
-   * representing a single grapheme cluster (see UAX#29).
-   */
-  UTF8PROC_CHARBOUND = (1<<11),
-  /** Lumps certain characters together.
-   *
-   * E.g. HYPHEN U+2010 and MINUS U+2212 to ASCII "-". See lump.md for details.
-   *
-   * If NLF2LF is set, this includes a transformation of paragraph and
-   * line separators to ASCII line-feed (LF).
-   */
-  UTF8PROC_LUMP      = (1<<12),
-  /** Strips all character markings.
-   *
-   * This includes non-spacing, spacing and enclosing (i.e. accents).
-   * @note This option works only with @ref UTF8PROC_COMPOSE or
-   *       @ref UTF8PROC_DECOMPOSE
-   */
-  UTF8PROC_STRIPMARK = (1<<13),
-  /**
-   * Strip unassigned codepoints.
-   */
-  UTF8PROC_STRIPNA    = (1<<14),
-} utf8proc_option_t;
-
-/** @name Error codes
- * Error codes being returned by almost all functions.
- */
-/** @{ */
-/** Memory could not be allocated. */
-#define UTF8PROC_ERROR_NOMEM -1
-/** The given string is too long to be processed. */
-#define UTF8PROC_ERROR_OVERFLOW -2
-/** The given string is not a legal UTF-8 string. */
-#define UTF8PROC_ERROR_INVALIDUTF8 -3
-/** The @ref UTF8PROC_REJECTNA flag was set and an unassigned codepoint was found. */
-#define UTF8PROC_ERROR_NOTASSIGNED -4
-/** Invalid options have been used. */
-#define UTF8PROC_ERROR_INVALIDOPTS -5
-/** @} */
-
-/* @name Types */
-
-/** Holds the value of a property. */
-typedef utf8proc_int16_t utf8proc_propval_t;
-
-/** Struct containing information about a codepoint. */
-typedef struct utf8proc_property_struct {
-  /**
-   * Unicode category.
-   * @see utf8proc_category_t.
-   */
-  utf8proc_propval_t category;
-  utf8proc_propval_t combining_class;
-  /**
-   * Bidirectional class.
-   * @see utf8proc_bidi_class_t.
-   */
-  utf8proc_propval_t bidi_class;
-  /**
-   * @anchor Decomposition type.
-   * @see utf8proc_decomp_type_t.
-   */
-  utf8proc_propval_t decomp_type;
-  utf8proc_uint16_t decomp_seqindex;
-  utf8proc_uint16_t casefold_seqindex;
-  utf8proc_uint16_t uppercase_seqindex;
-  utf8proc_uint16_t lowercase_seqindex;
-  utf8proc_uint16_t titlecase_seqindex;
-  utf8proc_uint16_t comb_index;
-  unsigned bidi_mirrored:1;
-  unsigned comp_exclusion:1;
-  /**
-   * Can this codepoint be ignored?
-   *
-   * Used by utf8proc_decompose_char() when @ref UTF8PROC_IGNORE is
-   * passed as an option.
-   */
-  unsigned ignorable:1;
-  unsigned control_boundary:1;
-  /** The width of the codepoint. */
-  unsigned charwidth:2;
-  unsigned pad:2;
-  /**
-   * Boundclass.
-   * @see utf8proc_boundclass_t.
-   */
-  unsigned boundclass:6;
-  unsigned indic_conjunct_break:2;
-} utf8proc_property_t;
-
-/** Unicode categories. */
-typedef enum {
-  UTF8PROC_CATEGORY_CN  = 0, /**< Other, not assigned */
-  UTF8PROC_CATEGORY_LU  = 1, /**< Letter, uppercase */
-  UTF8PROC_CATEGORY_LL  = 2, /**< Letter, lowercase */
-  UTF8PROC_CATEGORY_LT  = 3, /**< Letter, titlecase */
-  UTF8PROC_CATEGORY_LM  = 4, /**< Letter, modifier */
-  UTF8PROC_CATEGORY_LO  = 5, /**< Letter, other */
-  UTF8PROC_CATEGORY_MN  = 6, /**< Mark, nonspacing */
-  UTF8PROC_CATEGORY_MC  = 7, /**< Mark, spacing combining */
-  UTF8PROC_CATEGORY_ME  = 8, /**< Mark, enclosing */
-  UTF8PROC_CATEGORY_ND  = 9, /**< Number, decimal digit */
-  UTF8PROC_CATEGORY_NL = 10, /**< Number, letter */
-  UTF8PROC_CATEGORY_NO = 11, /**< Number, other */
-  UTF8PROC_CATEGORY_PC = 12, /**< Punctuation, connector */
-  UTF8PROC_CATEGORY_PD = 13, /**< Punctuation, dash */
-  UTF8PROC_CATEGORY_PS = 14, /**< Punctuation, open */
-  UTF8PROC_CATEGORY_PE = 15, /**< Punctuation, close */
-  UTF8PROC_CATEGORY_PI = 16, /**< Punctuation, initial quote */
-  UTF8PROC_CATEGORY_PF = 17, /**< Punctuation, final quote */
-  UTF8PROC_CATEGORY_PO = 18, /**< Punctuation, other */
-  UTF8PROC_CATEGORY_SM = 19, /**< Symbol, math */
-  UTF8PROC_CATEGORY_SC = 20, /**< Symbol, currency */
-  UTF8PROC_CATEGORY_SK = 21, /**< Symbol, modifier */
-  UTF8PROC_CATEGORY_SO = 22, /**< Symbol, other */
-  UTF8PROC_CATEGORY_ZS = 23, /**< Separator, space */
-  UTF8PROC_CATEGORY_ZL = 24, /**< Separator, line */
-  UTF8PROC_CATEGORY_ZP = 25, /**< Separator, paragraph */
-  UTF8PROC_CATEGORY_CC = 26, /**< Other, control */
-  UTF8PROC_CATEGORY_CF = 27, /**< Other, format */
-  UTF8PROC_CATEGORY_CS = 28, /**< Other, surrogate */
-  UTF8PROC_CATEGORY_CO = 29, /**< Other, private use */
-} utf8proc_category_t;
-
-/** Bidirectional character classes. */
-typedef enum {
-  UTF8PROC_BIDI_CLASS_L     = 1, /**< Left-to-Right */
-  UTF8PROC_BIDI_CLASS_LRE   = 2, /**< Left-to-Right Embedding */
-  UTF8PROC_BIDI_CLASS_LRO   = 3, /**< Left-to-Right Override */
-  UTF8PROC_BIDI_CLASS_R     = 4, /**< Right-to-Left */
-  UTF8PROC_BIDI_CLASS_AL    = 5, /**< Right-to-Left Arabic */
-  UTF8PROC_BIDI_CLASS_RLE   = 6, /**< Right-to-Left Embedding */
-  UTF8PROC_BIDI_CLASS_RLO   = 7, /**< Right-to-Left Override */
-  UTF8PROC_BIDI_CLASS_PDF   = 8, /**< Pop Directional Format */
-  UTF8PROC_BIDI_CLASS_EN    = 9, /**< European Number */
-  UTF8PROC_BIDI_CLASS_ES   = 10, /**< European Separator */
-  UTF8PROC_BIDI_CLASS_ET   = 11, /**< European Number Terminator */
-  UTF8PROC_BIDI_CLASS_AN   = 12, /**< Arabic Number */
-  UTF8PROC_BIDI_CLASS_CS   = 13, /**< Common Number Separator */
-  UTF8PROC_BIDI_CLASS_NSM  = 14, /**< Nonspacing Mark */
-  UTF8PROC_BIDI_CLASS_BN   = 15, /**< Boundary Neutral */
-  UTF8PROC_BIDI_CLASS_B    = 16, /**< Paragraph Separator */
-  UTF8PROC_BIDI_CLASS_S    = 17, /**< Segment Separator */
-  UTF8PROC_BIDI_CLASS_WS   = 18, /**< Whitespace */
-  UTF8PROC_BIDI_CLASS_ON   = 19, /**< Other Neutrals */
-  UTF8PROC_BIDI_CLASS_LRI  = 20, /**< Left-to-Right Isolate */
-  UTF8PROC_BIDI_CLASS_RLI  = 21, /**< Right-to-Left Isolate */
-  UTF8PROC_BIDI_CLASS_FSI  = 22, /**< First Strong Isolate */
-  UTF8PROC_BIDI_CLASS_PDI  = 23, /**< Pop Directional Isolate */
-} utf8proc_bidi_class_t;
-
-/** Decomposition type. */
-typedef enum {
-  UTF8PROC_DECOMP_TYPE_FONT      = 1, /**< Font */
-  UTF8PROC_DECOMP_TYPE_NOBREAK   = 2, /**< Nobreak */
-  UTF8PROC_DECOMP_TYPE_INITIAL   = 3, /**< Initial */
-  UTF8PROC_DECOMP_TYPE_MEDIAL    = 4, /**< Medial */
-  UTF8PROC_DECOMP_TYPE_FINAL     = 5, /**< Final */
-  UTF8PROC_DECOMP_TYPE_ISOLATED  = 6, /**< Isolated */
-  UTF8PROC_DECOMP_TYPE_CIRCLE    = 7, /**< Circle */
-  UTF8PROC_DECOMP_TYPE_SUPER     = 8, /**< Super */
-  UTF8PROC_DECOMP_TYPE_SUB       = 9, /**< Sub */
-  UTF8PROC_DECOMP_TYPE_VERTICAL = 10, /**< Vertical */
-  UTF8PROC_DECOMP_TYPE_WIDE     = 11, /**< Wide */
-  UTF8PROC_DECOMP_TYPE_NARROW   = 12, /**< Narrow */
-  UTF8PROC_DECOMP_TYPE_SMALL    = 13, /**< Small */
-  UTF8PROC_DECOMP_TYPE_SQUARE   = 14, /**< Square */
-  UTF8PROC_DECOMP_TYPE_FRACTION = 15, /**< Fraction */
-  UTF8PROC_DECOMP_TYPE_COMPAT   = 16, /**< Compat */
-} utf8proc_decomp_type_t;
-
-/** Boundclass property. (TR29) */
-typedef enum {
-  UTF8PROC_BOUNDCLASS_START              =  0, /**< Start */
-  UTF8PROC_BOUNDCLASS_OTHER              =  1, /**< Other */
-  UTF8PROC_BOUNDCLASS_CR                 =  2, /**< Cr */
-  UTF8PROC_BOUNDCLASS_LF                 =  3, /**< Lf */
-  UTF8PROC_BOUNDCLASS_CONTROL            =  4, /**< Control */
-  UTF8PROC_BOUNDCLASS_EXTEND             =  5, /**< Extend */
-  UTF8PROC_BOUNDCLASS_L                  =  6, /**< L */
-  UTF8PROC_BOUNDCLASS_V                  =  7, /**< V */
-  UTF8PROC_BOUNDCLASS_T                  =  8, /**< T */
-  UTF8PROC_BOUNDCLASS_LV                 =  9, /**< Lv */
-  UTF8PROC_BOUNDCLASS_LVT                = 10, /**< Lvt */
-  UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR = 11, /**< Regional indicator */
-  UTF8PROC_BOUNDCLASS_SPACINGMARK        = 12, /**< Spacingmark */
-  UTF8PROC_BOUNDCLASS_PREPEND            = 13, /**< Prepend */
-  UTF8PROC_BOUNDCLASS_ZWJ                = 14, /**< Zero Width Joiner */
-
-  /* the following are no longer used in Unicode 11, but we keep
-     the constants here for backward compatibility */
-  UTF8PROC_BOUNDCLASS_E_BASE             = 15, /**< Emoji Base */
-  UTF8PROC_BOUNDCLASS_E_MODIFIER         = 16, /**< Emoji Modifier */
-  UTF8PROC_BOUNDCLASS_GLUE_AFTER_ZWJ     = 17, /**< Glue_After_ZWJ */
-  UTF8PROC_BOUNDCLASS_E_BASE_GAZ         = 18, /**< E_BASE + GLUE_AFTER_ZJW */
-
-  /* the Extended_Pictographic property is used in the Unicode 11
-     grapheme-boundary rules, so we store it in the boundclass field */
-  UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC = 19,
-  UTF8PROC_BOUNDCLASS_E_ZWG = 20, /* UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC + ZWJ */
-} utf8proc_boundclass_t;
-
-/** Indic_Conjunct_Break property. (TR44) */
-typedef enum {
-  UTF8PROC_INDIC_CONJUNCT_BREAK_NONE = 0,
-  UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER = 1,
-  UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT = 2,
-  UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND = 3,
-} utf8proc_indic_conjunct_break_t;
-
-/**
- * Function pointer type passed to utf8proc_map_custom() and
- * utf8proc_decompose_custom(), which is used to specify a user-defined
- * mapping of codepoints to be applied in conjunction with other mappings.
- */
-typedef utf8proc_int32_t (*utf8proc_custom_func)(utf8proc_int32_t codepoint, void *data);
-
-/**
- * Array containing the byte lengths of a UTF-8 encoded codepoint based
- * on the first byte.
- */
-UTF8PROC_DLLEXPORT extern const utf8proc_int8_t utf8proc_utf8class[256];
-
-/**
- * Returns the utf8proc API version as a string MAJOR.MINOR.PATCH
- * (http://semver.org format), possibly with a "-dev" suffix for
- * development versions.
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_version(void);
-
-/**
- * Returns the utf8proc supported Unicode version as a string MAJOR.MINOR.PATCH.
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_unicode_version(void);
-
-/**
- * Returns an informative error string for the given utf8proc error code
- * (e.g. the error codes returned by utf8proc_map()).
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode);
-
-/**
- * Reads a single codepoint from the UTF-8 sequence being pointed to by `str`.
- * The maximum number of bytes read is `strlen`, unless `strlen` is
- * negative (in which case up to 4 bytes are read).
- *
- * If a valid codepoint could be read, it is stored in the variable
- * pointed to by `codepoint_ref`, otherwise that variable will be set to -1.
- * In case of success, the number of bytes read is returned; otherwise, a
- * negative error code is returned.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_iterate(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_int32_t *codepoint_ref);
-
-/**
- * Check if a codepoint is valid (regardless of whether it has been
- * assigned a value by the current Unicode standard).
- *
- * @return 1 if the given `codepoint` is valid and otherwise return 0.
- */
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_codepoint_valid(utf8proc_int32_t codepoint);
-
-/**
- * Encodes the codepoint as an UTF-8 string in the byte array pointed
- * to by `dst`. This array must be at least 4 bytes long.
- *
- * In case of success the number of bytes written is returned, and
- * otherwise 0 is returned.
- *
- * This function does not check whether `codepoint` is valid Unicode.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_encode_char(utf8proc_int32_t codepoint, utf8proc_uint8_t *dst);
-
-/**
- * Look up the properties for a given codepoint.
- *
- * @param codepoint The Unicode codepoint.
- *
- * @returns
- * A pointer to a (constant) struct containing information about
- * the codepoint.
- * @par
- * If the codepoint is unassigned or invalid, a pointer to a special struct is
- * returned in which `category` is 0 (@ref UTF8PROC_CATEGORY_CN).
- */
-UTF8PROC_DLLEXPORT const utf8proc_property_t *utf8proc_get_property(utf8proc_int32_t codepoint);
-
-/** Decompose a codepoint into an array of codepoints.
- *
- * @param codepoint the codepoint.
- * @param dst the destination buffer.
- * @param bufsize the size of the destination buffer.
- * @param options one or more of the following flags:
- * - @ref UTF8PROC_REJECTNA  - return an error `codepoint` is unassigned
- * - @ref UTF8PROC_IGNORE    - strip "default ignorable" codepoints
- * - @ref UTF8PROC_CASEFOLD  - apply Unicode casefolding
- * - @ref UTF8PROC_COMPAT    - replace certain codepoints with their
- *                             compatibility decomposition
- * - @ref UTF8PROC_CHARBOUND - insert 0xFF bytes before each grapheme cluster
- * - @ref UTF8PROC_LUMP      - lump certain different codepoints together
- * - @ref UTF8PROC_STRIPMARK - remove all character marks
- * - @ref UTF8PROC_STRIPNA   - remove unassigned codepoints
- * @param last_boundclass
- * Pointer to an integer variable containing
- * the previous codepoint's (boundclass + indic_conjunct_break << 1) if the @ref UTF8PROC_CHARBOUND
- * option is used.  If the string is being processed in order, this can be initialized to 0 for
- * the beginning of the string, and is thereafter updated automatically.  Otherwise, this parameter is ignored.
- *
- * @return
- * In case of success, the number of codepoints written is returned; in case
- * of an error, a negative error code is returned (utf8proc_errmsg()).
- * @par
- * If the number of written codepoints would be bigger than `bufsize`, the
- * required buffer size is returned, while the buffer will be overwritten with
- * undefined data.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char(
-  utf8proc_int32_t codepoint, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize,
-  utf8proc_option_t options, int *last_boundclass
-);
-
-/**
- * The same as utf8proc_decompose_char(), but acts on a whole UTF-8
- * string and orders the decomposed sequences correctly.
- *
- * If the @ref UTF8PROC_NULLTERM flag in `options` is set, processing
- * will be stopped, when a NULL byte is encountered, otherwise `strlen`
- * bytes are processed.  The result (in the form of 32-bit unicode
- * codepoints) is written into the buffer being pointed to by
- * `buffer` (which must contain at least `bufsize` entries).  In case of
- * success, the number of codepoints written is returned; in case of an
- * error, a negative error code is returned (utf8proc_errmsg()).
- * See utf8proc_decompose_custom() to supply additional transformations.
- *
- * If the number of written codepoints would be bigger than `bufsize`, the
- * required buffer size is returned, while the buffer will be overwritten with
- * undefined data.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-  utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options
-);
-
-/**
- * The same as utf8proc_decompose(), but also takes a `custom_func` mapping function
- * that is called on each codepoint in `str` before any other transformations
- * (along with a `custom_data` pointer that is passed through to `custom_func`).
- * The `custom_func` argument is ignored if it is `NULL`.  See also utf8proc_map_custom().
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-  utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options,
-  utf8proc_custom_func custom_func, void *custom_data
-);
-
-/**
- * Normalizes the sequence of `length` codepoints pointed to by `buffer`
- * in-place (i.e., the result is also stored in `buffer`).
- *
- * @param buffer the (native-endian UTF-32) unicode codepoints to re-encode.
- * @param length the length (in codepoints) of the buffer.
- * @param options a bitwise or (`|`) of one or more of the following flags:
- * - @ref UTF8PROC_NLF2LS  - convert LF, CRLF, CR and NEL into LS
- * - @ref UTF8PROC_NLF2PS  - convert LF, CRLF, CR and NEL into PS
- * - @ref UTF8PROC_NLF2LF  - convert LF, CRLF, CR and NEL into LF
- * - @ref UTF8PROC_STRIPCC - strip or convert all non-affected control characters
- * - @ref UTF8PROC_COMPOSE - try to combine decomposed codepoints into composite
- *                           codepoints
- * - @ref UTF8PROC_STABLE  - prohibit combining characters that would violate
- *                           the unicode versioning stability
- *
- * @return
- * In case of success, the length (in codepoints) of the normalized UTF-32 string is
- * returned; otherwise, a negative error code is returned (utf8proc_errmsg()).
- *
- * @warning The entries of the array pointed to by `str` have to be in the
- *          range `0x0000` to `0x10FFFF`. Otherwise, the program might crash!
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_normalize_utf32(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options);
-
-/**
- * Reencodes the sequence of `length` codepoints pointed to by `buffer`
- * UTF-8 data in-place (i.e., the result is also stored in `buffer`).
- * Can optionally normalize the UTF-32 sequence prior to UTF-8 conversion.
- *
- * @param buffer the (native-endian UTF-32) unicode codepoints to re-encode.
- * @param length the length (in codepoints) of the buffer.
- * @param options a bitwise or (`|`) of one or more of the following flags:
- * - @ref UTF8PROC_NLF2LS  - convert LF, CRLF, CR and NEL into LS
- * - @ref UTF8PROC_NLF2PS  - convert LF, CRLF, CR and NEL into PS
- * - @ref UTF8PROC_NLF2LF  - convert LF, CRLF, CR and NEL into LF
- * - @ref UTF8PROC_STRIPCC - strip or convert all non-affected control characters
- * - @ref UTF8PROC_COMPOSE - try to combine decomposed codepoints into composite
- *                           codepoints
- * - @ref UTF8PROC_STABLE  - prohibit combining characters that would violate
- *                           the unicode versioning stability
- * - @ref UTF8PROC_CHARBOUND - insert 0xFF bytes before each grapheme cluster
- *
- * @return
- * In case of success, the length (in bytes) of the resulting nul-terminated
- * UTF-8 string is returned; otherwise, a negative error code is returned
- * (utf8proc_errmsg()).
- *
- * @warning The amount of free space pointed to by `buffer` must
- *          exceed the amount of the input data by one byte, and the
- *          entries of the array pointed to by `str` have to be in the
- *          range `0x0000` to `0x10FFFF`. Otherwise, the program might crash!
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_reencode(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options);
-
-/**
- * Given a pair of consecutive codepoints, return whether a grapheme break is
- * permitted between them (as defined by the extended grapheme clusters in UAX#29).
- *
- * @param codepoint1 The first codepoint.
- * @param codepoint2 The second codepoint, occurring consecutively after `codepoint1`.
- * @param state Beginning with Version 29 (Unicode 9.0.0), this algorithm requires
- *              state to break graphemes. This state can be passed in as a pointer
- *              in the `state` argument and should initially be set to 0. If the
- *              state is not passed in (i.e. a null pointer is passed), UAX#29 rules
- *              GB10/12/13 which require this state will not be applied, essentially
- *              matching the rules in Unicode 8.0.0.
- *
- * @warning If the state parameter is used, `utf8proc_grapheme_break_stateful` must
- *          be called IN ORDER on ALL potential breaks in a string.  However, it
- *          is safe to reset the state to zero after a grapheme break.
- */
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful(
-    utf8proc_int32_t codepoint1, utf8proc_int32_t codepoint2, utf8proc_int32_t *state);
-
-/**
- * Same as utf8proc_grapheme_break_stateful(), except without support for the
- * Unicode 9 additions to the algorithm. Supported for legacy reasons.
- */
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break(
-    utf8proc_int32_t codepoint1, utf8proc_int32_t codepoint2);
-
-
-/**
- * Given a codepoint `c`, return the codepoint of the corresponding
- * lower-case character, if any; otherwise (if there is no lower-case
- * variant, or if `c` is not a valid codepoint) return `c`.
- */
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_tolower(utf8proc_int32_t c);
-
-/**
- * Given a codepoint `c`, return the codepoint of the corresponding
- * upper-case character, if any; otherwise (if there is no upper-case
- * variant, or if `c` is not a valid codepoint) return `c`.
- */
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_toupper(utf8proc_int32_t c);
-
-/**
- * Given a codepoint `c`, return the codepoint of the corresponding
- * title-case character, if any; otherwise (if there is no title-case
- * variant, or if `c` is not a valid codepoint) return `c`.
- */
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c);
-
-/**
- * Given a codepoint `c`, return `1` if the codepoint corresponds to a lower-case character
- * and `0` otherwise.
- */
-UTF8PROC_DLLEXPORT int utf8proc_islower(utf8proc_int32_t c);
-
-/**
- * Given a codepoint `c`, return `1` if the codepoint corresponds to an upper-case character
- * and `0` otherwise.
- */
-UTF8PROC_DLLEXPORT int utf8proc_isupper(utf8proc_int32_t c);
-
-/**
- * Given a codepoint, return a character width analogous to `wcwidth(codepoint)`,
- * except that a width of 0 is returned for non-printable codepoints
- * instead of -1 as in `wcwidth`.
- *
- * @note
- * If you want to check for particular types of non-printable characters,
- * (analogous to `isprint` or `iscntrl`), use utf8proc_category(). */
-UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t codepoint);
-
-/**
- * Return the Unicode category for the codepoint (one of the
- * @ref utf8proc_category_t constants.)
- */
-UTF8PROC_DLLEXPORT utf8proc_category_t utf8proc_category(utf8proc_int32_t codepoint);
-
-/**
- * Return the two-letter (nul-terminated) Unicode category string for
- * the codepoint (e.g. `"Lu"` or `"Co"`).
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t codepoint);
-
-/**
- * Maps the given UTF-8 string pointed to by `str` to a new UTF-8
- * string, allocated dynamically by `malloc` and returned via `dstptr`.
- *
- * If the @ref UTF8PROC_NULLTERM flag in the `options` field is set,
- * the length is determined by a NULL terminator, otherwise the
- * parameter `strlen` is evaluated to determine the string length, but
- * in any case the result will be NULL terminated (though it might
- * contain NULL characters with the string if `str` contained NULL
- * characters). Other flags in the `options` field are passed to the
- * functions defined above, and regarded as described.  See also
- * utf8proc_map_custom() to supply a custom codepoint transformation.
- *
- * In case of success the length of the new string is returned,
- * otherwise a negative error code is returned.
- *
- * @note The memory of the new UTF-8 string will have been allocated
- * with `malloc`, and should therefore be deallocated with `free`.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options
-);
-
-/**
- * Like utf8proc_map(), but also takes a `custom_func` mapping function
- * that is called on each codepoint in `str` before any other transformations
- * (along with a `custom_data` pointer that is passed through to `custom_func`).
- * The `custom_func` argument is ignored if it is `NULL`.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options,
-  utf8proc_custom_func custom_func, void *custom_data
-);
-
-/** @name Unicode normalization
- *
- * Returns a pointer to newly allocated memory of a NFD, NFC, NFKD, NFKC or
- * NFKC_Casefold normalized version of the null-terminated string `str`.  These
- * are shortcuts to calling utf8proc_map() with @ref UTF8PROC_NULLTERM
- * combined with @ref UTF8PROC_STABLE and flags indicating the normalization.
- */
-/** @{ */
-/** NFD normalization (@ref UTF8PROC_DECOMPOSE). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen);
-/** NFC normalization (@ref UTF8PROC_COMPOSE). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen);
-/** remove accents from a string */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen);
-/** NFKD normalization (@ref UTF8PROC_DECOMPOSE and @ref UTF8PROC_COMPAT). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen);
-/** NFKC normalization (@ref UTF8PROC_COMPOSE and @ref UTF8PROC_COMPAT). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen);
-/**
- * NFKC_Casefold normalization (@ref UTF8PROC_COMPOSE and @ref UTF8PROC_COMPAT
- * and @ref UTF8PROC_CASEFOLD and @ref UTF8PROC_IGNORE).
- **/
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen);
-/** @} */
-
-}
-
-#endif
diff --git a/src/duckdb/third_party/utf8proc/include/utf8proc_wrapper.hpp b/src/duckdb/third_party/utf8proc/include/utf8proc_wrapper.hpp
deleted file mode 100644
index 75c9480c2..000000000
--- a/src/duckdb/third_party/utf8proc/include/utf8proc_wrapper.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// utf8proc_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <string>
-#include <cassert>
-#include <cstring>
-#include <cstdint>
-
-namespace duckdb {
-class GraphemeIterator;
-
-enum class UnicodeType { INVALID, ASCII, UNICODE };
-enum class UnicodeInvalidReason { BYTE_MISMATCH, INVALID_UNICODE };
-
-class Utf8Proc {
-public:
-	//! Distinguishes ASCII, Valid UTF8 and Invalid UTF8 strings
-	static UnicodeType Analyze(const char *s, size_t len, UnicodeInvalidReason *invalid_reason = nullptr, size_t *invalid_pos = nullptr);
-	//! Performs UTF NFC normalization of string, return value needs to be free'd
-	static char* Normalize(const char* s, size_t len);
-	//! Returns whether or not the UTF8 string is valid
-	static bool IsValid(const char *s, size_t len);
-	//! Makes Invalid Unicode valid by replacing invalid parts with a given character
-	static void MakeValid(char *s, size_t len, char special_flag = '?');
-	//! Returns the position (in bytes) of the next grapheme cluster
-	static size_t NextGraphemeCluster(const char *s, size_t len, size_t pos);
-	//! Returns the position (in bytes) of the previous grapheme cluster
-	static size_t PreviousGraphemeCluster(const char *s, size_t len, size_t pos);
-
-	//! Transform a codepoint to utf8 and writes it to "c", sets "sz" to the size of the codepoint
-	static bool CodepointToUtf8(int cp, int &sz, char *c);
-	//! Returns the codepoint length in bytes when encoded in UTF8
-	static int CodepointLength(int cp);
-	//! Transform a UTF8 string to a codepoint; returns the codepoint and writes the length of the codepoint (in UTF8) to sz
-	static int32_t UTF8ToCodepoint(const char *c, int &sz);
-	//! Returns the render width of a single character in a string
-	static size_t RenderWidth(const char *s, size_t len, size_t pos);
-	static size_t RenderWidth(const std::string &str);
-
-	static int32_t CodepointToUpper(int32_t codepoint);
-	static int32_t CodepointToLower(int32_t codepoint);
-
-	//! Constructs a class that can be iterated over to fetch grapheme clusters in a string
-	static GraphemeIterator GraphemeClusters(const char *s, size_t len);
-
-	//! Returns the number of grapheme clusters in a string
-	static size_t GraphemeCount(const char *s, size_t len);
-
-
-};
-
-struct GraphemeCluster {
-	size_t start;
-	size_t end;
-};
-
-class GraphemeIterator {
-public:
-	GraphemeIterator(const char *s, size_t len);
-
-private:
-	const char *s;
-	size_t len;
-
-private:
-	class GraphemeClusterIterator {
-	public:
-		GraphemeClusterIterator(const char *s, size_t len);
-
-		const char *s;
-		size_t len;
-		GraphemeCluster cluster;
-
-	public:
-		void Next();
-		void SetInvalid();
-		bool IsInvalid() const;
-
-		GraphemeClusterIterator &operator++();
-		bool operator!=(const GraphemeClusterIterator &other) const;
-		GraphemeCluster operator*() const;
-	};
-
-public:
-	GraphemeClusterIterator begin() { // NOLINT: match stl API
-		return GraphemeClusterIterator(s, len);
-	}
-	GraphemeClusterIterator end() { // NOLINT: match stl API
-		return GraphemeClusterIterator(nullptr, 0);
-	}
-};
-
-
-}
diff --git a/src/duckdb/third_party/utf8proc/utf8proc.cpp b/src/duckdb/third_party/utf8proc/utf8proc.cpp
deleted file mode 100644
index bfea42744..000000000
--- a/src/duckdb/third_party/utf8proc/utf8proc.cpp
+++ /dev/null
@@ -1,825 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil -*- */
-/*
- *  Copyright (c) 2014-2021 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors.
- *  Copyright (c) 2009 Public Software Group e. V., Berlin, Germany
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a
- *  copy of this software and associated documentation files (the "Software"),
- *  to deal in the Software without restriction, including without limitation
- *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
- *  and/or sell copies of the Software, and to permit persons to whom the
- *  Software is furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in
- *  all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- *  DEALINGS IN THE SOFTWARE.
- */
-
-/*
- *  This library contains derived data from a modified version of the
- *  Unicode data files.
- *
- *  The original data files are available at
- *  https://www.unicode.org/Public/UNIDATA/
- *
- *  Please notice the copyright statement in the file "utf8proc_data.c".
- */
-
-
-/*
- *  File name:    utf8proc.c
- *
- *  Description:
- *  Implementation of libutf8proc.
- */
-
-
-#include "utf8proc.hpp"
-
-namespace duckdb {
-#ifndef SSIZE_MAX
-#define SSIZE_MAX ((size_t)SIZE_MAX/2)
-#endif
-#ifndef UINT16_MAX
-#  define UINT16_MAX 65535U
-#endif
-
-#include "utf8proc_data.cpp"
-
-
-UTF8PROC_DLLEXPORT const utf8proc_int8_t utf8proc_utf8class[256] = {
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-#define UTF8PROC_HANGUL_SBASE 0xAC00
-#define UTF8PROC_HANGUL_LBASE 0x1100
-#define UTF8PROC_HANGUL_VBASE 0x1161
-#define UTF8PROC_HANGUL_TBASE 0x11A7
-#define UTF8PROC_HANGUL_LCOUNT 19
-#define UTF8PROC_HANGUL_VCOUNT 21
-#define UTF8PROC_HANGUL_TCOUNT 28
-#define UTF8PROC_HANGUL_NCOUNT 588
-#define UTF8PROC_HANGUL_SCOUNT 11172
-/* END is exclusive */
-#define UTF8PROC_HANGUL_L_START  0x1100
-#define UTF8PROC_HANGUL_L_END    0x115A
-#define UTF8PROC_HANGUL_L_FILLER 0x115F
-#define UTF8PROC_HANGUL_V_START  0x1160
-#define UTF8PROC_HANGUL_V_END    0x11A3
-#define UTF8PROC_HANGUL_T_START  0x11A8
-#define UTF8PROC_HANGUL_T_END    0x11FA
-#define UTF8PROC_HANGUL_S_START  0xAC00
-#define UTF8PROC_HANGUL_S_END    0xD7A4
-
-/* Should follow semantic-versioning rules (semver.org) based on API
-   compatibility.  (Note that the shared-library version number will
-   be different, being based on ABI compatibility.): */
-#define STRINGIZEx(x) #x
-#define STRINGIZE(x) STRINGIZEx(x)
-UTF8PROC_DLLEXPORT const char *utf8proc_version(void) {
-  return STRINGIZE(UTF8PROC_VERSION_MAJOR) "." STRINGIZE(UTF8PROC_VERSION_MINOR) "." STRINGIZE(UTF8PROC_VERSION_PATCH) "";
-}
-
-UTF8PROC_DLLEXPORT const char *utf8proc_unicode_version(void) {
-  return "15.1.0";
-}
-
-UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode) {
-  switch (errcode) {
-    case UTF8PROC_ERROR_NOMEM:
-      return "Memory for processing UTF-8 data could not be allocated.";
-    case UTF8PROC_ERROR_OVERFLOW:
-      return "UTF-8 string is too long to be processed.";
-    case UTF8PROC_ERROR_INVALIDUTF8:
-      return "Invalid UTF-8 string";
-    case UTF8PROC_ERROR_NOTASSIGNED:
-      return "Unassigned Unicode code point found in UTF-8 string.";
-    case UTF8PROC_ERROR_INVALIDOPTS:
-      return "Invalid options for UTF-8 processing chosen.";
-    default:
-      return "An unknown error occurred while processing UTF-8 data.";
-  }
-}
-
-#define utf_cont(ch)  (((ch) & 0xc0) == 0x80)
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_iterate(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_int32_t *dst
-) {
-  utf8proc_int32_t uc;
-  const utf8proc_uint8_t *end;
-
-  *dst = -1;
-  if (!strlen) return 0;
-  end = str + ((strlen < 0) ? 4 : strlen);
-  uc = *str++;
-  if (uc < 0x80) {
-    *dst = uc;
-    return 1;
-  }
-  // Must be between 0xc2 and 0xf4 inclusive to be valid
-  if ((utf8proc_uint32_t)(uc - 0xc2) > (0xf4-0xc2)) return UTF8PROC_ERROR_INVALIDUTF8;
-  if (uc < 0xe0) {         // 2-byte sequence
-    // Must have valid continuation character
-    if (str >= end || !utf_cont(*str)) return UTF8PROC_ERROR_INVALIDUTF8;
-    *dst = ((uc & 0x1f)<<6) | (*str & 0x3f);
-    return 2;
-  }
-  if (uc < 0xf0) {        // 3-byte sequence
-    if ((str + 1 >= end) || !utf_cont(*str) || !utf_cont(str[1]))
-      return UTF8PROC_ERROR_INVALIDUTF8;
-    // Check for surrogate chars
-    if (uc == 0xed && *str > 0x9f)
-      return UTF8PROC_ERROR_INVALIDUTF8;
-    uc = ((uc & 0xf)<<12) | ((*str & 0x3f)<<6) | (str[1] & 0x3f);
-    if (uc < 0x800)
-      return UTF8PROC_ERROR_INVALIDUTF8;
-    *dst = uc;
-    return 3;
-  }
-  // 4-byte sequence
-  // Must have 3 valid continuation characters
-  if ((str + 2 >= end) || !utf_cont(*str) || !utf_cont(str[1]) || !utf_cont(str[2]))
-    return UTF8PROC_ERROR_INVALIDUTF8;
-  // Make sure in correct range (0x10000 - 0x10ffff)
-  if (uc == 0xf0) {
-    if (*str < 0x90) return UTF8PROC_ERROR_INVALIDUTF8;
-  } else if (uc == 0xf4) {
-    if (*str > 0x8f) return UTF8PROC_ERROR_INVALIDUTF8;
-  }
-  *dst = ((uc & 7)<<18) | ((*str & 0x3f)<<12) | ((str[1] & 0x3f)<<6) | (str[2] & 0x3f);
-  return 4;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_codepoint_valid(utf8proc_int32_t uc) {
-  return (((utf8proc_uint32_t)uc)-0xd800 > 0x07ff) && ((utf8proc_uint32_t)uc < 0x110000);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) {
-  if (uc < 0x00) {
-    return 0;
-  } else if (uc < 0x80) {
-    dst[0] = (utf8proc_uint8_t) uc;
-    return 1;
-  } else if (uc < 0x800) {
-    dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6));
-    dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-    return 2;
-    // Note: we allow encoding 0xd800-0xdfff here, so as not to change
-    // the API, however, these are actually invalid in UTF-8
-  } else if (uc < 0x10000) {
-    dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12));
-    dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-    dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-    return 3;
-  } else if (uc < 0x110000) {
-    dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18));
-    dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F));
-    dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-    dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-    return 4;
-  } else return 0;
-}
-
-/* internal version used for inserting 0xff bytes between graphemes */
-static utf8proc_ssize_t charbound_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) {
-  if (uc < 0x00) {
-    if (uc == -1) { /* internal value used for grapheme breaks */
-      dst[0] = (utf8proc_uint8_t)0xFF;
-      return 1;
-    }
-    return 0;
-  } else if (uc < 0x80) {
-    dst[0] = (utf8proc_uint8_t)uc;
-    return 1;
-  } else if (uc < 0x800) {
-    dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6));
-    dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-    return 2;
-  } else if (uc < 0x10000) {
-    dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12));
-    dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-    dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-    return 3;
-  } else if (uc < 0x110000) {
-    dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18));
-    dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F));
-    dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-    dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-    return 4;
-  } else return 0;
-}
-
-/* internal "unsafe" version that does not check whether uc is in range */
-static const utf8proc_property_t *unsafe_get_property(utf8proc_int32_t uc) {
-  /* ASSERT: uc >= 0 && uc < 0x110000 */
-  return utf8proc_properties + (
-    utf8proc_stage2table[
-      utf8proc_stage1table[uc >> 8] + (uc & 0xFF)
-    ]
-  );
-}
-
-UTF8PROC_DLLEXPORT const utf8proc_property_t *utf8proc_get_property(utf8proc_int32_t uc) {
-  return uc < 0 || uc >= 0x110000 ? utf8proc_properties : unsafe_get_property(uc);
-}
-
-/* return whether there is a grapheme break between boundclasses lbc and tbc
-   (according to the definition of extended grapheme clusters)
-
-  Rule numbering refers to TR29 Version 29 (Unicode 9.0.0):
-  http://www.unicode.org/reports/tr29/tr29-29.html
-
-  CAVEATS:
-   Please note that evaluation of GB10 (grapheme breaks between emoji zwj sequences)
-   and GB 12/13 (regional indicator code points) require knowledge of previous characters
-   and are thus not handled by this function. This may result in an incorrect break before
-   an E_Modifier class codepoint and an incorrectly missing break between two
-   REGIONAL_INDICATOR class code points if such support does not exist in the caller.
-
-   See the special support in grapheme_break_extended, for required bookkeeping by the caller.
-*/
-static utf8proc_bool grapheme_break_simple(int lbc, int tbc) {
-  return
-    (lbc == UTF8PROC_BOUNDCLASS_START) ? true :       // GB1
-    (lbc == UTF8PROC_BOUNDCLASS_CR &&                 // GB3
-     tbc == UTF8PROC_BOUNDCLASS_LF) ? false :         // ---
-    (lbc >= UTF8PROC_BOUNDCLASS_CR && lbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true :  // GB4
-    (tbc >= UTF8PROC_BOUNDCLASS_CR && tbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true :  // GB5
-    (lbc == UTF8PROC_BOUNDCLASS_L &&                  // GB6
-     (tbc == UTF8PROC_BOUNDCLASS_L ||                 // ---
-      tbc == UTF8PROC_BOUNDCLASS_V ||                 // ---
-      tbc == UTF8PROC_BOUNDCLASS_LV ||                // ---
-      tbc == UTF8PROC_BOUNDCLASS_LVT)) ? false :      // ---
-    ((lbc == UTF8PROC_BOUNDCLASS_LV ||                // GB7
-      lbc == UTF8PROC_BOUNDCLASS_V) &&                // ---
-     (tbc == UTF8PROC_BOUNDCLASS_V ||                 // ---
-      tbc == UTF8PROC_BOUNDCLASS_T)) ? false :        // ---
-    ((lbc == UTF8PROC_BOUNDCLASS_LVT ||               // GB8
-      lbc == UTF8PROC_BOUNDCLASS_T) &&                // ---
-     tbc == UTF8PROC_BOUNDCLASS_T) ? false :          // ---
-    (tbc == UTF8PROC_BOUNDCLASS_EXTEND ||             // GB9
-     tbc == UTF8PROC_BOUNDCLASS_ZWJ ||                // ---
-     tbc == UTF8PROC_BOUNDCLASS_SPACINGMARK ||        // GB9a
-     lbc == UTF8PROC_BOUNDCLASS_PREPEND) ? false :    // GB9b
-    (lbc == UTF8PROC_BOUNDCLASS_E_ZWG &&              // GB11 (requires additional handling below)
-     tbc == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) ? false : // ----
-    (lbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR &&          // GB12/13 (requires additional handling below)
-     tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) ? false :  // ----
-    true; // GB999
-}
-
-static utf8proc_bool grapheme_break_extended(int lbc, int tbc, int licb, int ticb, utf8proc_int32_t *state)
-{
-  if (state) {
-    int state_bc, state_icb; /* boundclass and indic_conjunct_break state */
-    if (*state == 0) { /* state initialization */
-      state_bc = lbc;
-      state_icb = licb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT ? licb : UTF8PROC_INDIC_CONJUNCT_BREAK_NONE;
-    }
-    else { /* lbc and licb are already encoded in *state */
-      state_bc = *state & 0xff;  // 1st byte of state is bound class
-      state_icb = *state >> 8;   // 2nd byte of state is indic conjunct break
-    }
-
-    utf8proc_bool break_permitted = grapheme_break_simple(state_bc, tbc) &&
-       !(state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER
-        && ticb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT); // GB9c
-
-    // Special support for GB9c.  Don't break between two consonants
-    // separated 1+ linker characters and 0+ extend characters in any order.
-    // After a consonant, we enter LINKER state after at least one linker.
-    if (ticb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT
-        || state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT
-        || state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND)
-      state_icb = ticb;
-    else if (state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER)
-      state_icb = ticb == UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND ?
-                  UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER : ticb;
-
-    // Special support for GB 12/13 made possible by GB999. After two RI
-    // class codepoints we want to force a break. Do this by resetting the
-    // second RI's bound class to UTF8PROC_BOUNDCLASS_OTHER, to force a break
-    // after that character according to GB999 (unless of course such a break is
-    // forbidden by a different rule such as GB9).
-    if (state_bc == tbc && tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR)
-      state_bc = UTF8PROC_BOUNDCLASS_OTHER;
-    // Special support for GB11 (emoji extend* zwj / emoji)
-    else if (state_bc == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) {
-      if (tbc == UTF8PROC_BOUNDCLASS_EXTEND) // fold EXTEND codepoints into emoji
-        state_bc = UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC;
-      else if (tbc == UTF8PROC_BOUNDCLASS_ZWJ)
-        state_bc = UTF8PROC_BOUNDCLASS_E_ZWG; // state to record emoji+zwg combo
-      else
-        state_bc = tbc;
-    }
-    else
-      state_bc = tbc;
-
-    *state = state_bc + (state_icb << 8);
-    return break_permitted;
-  }
-  else
-    return grapheme_break_simple(lbc, tbc);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful(
-    utf8proc_int32_t c1, utf8proc_int32_t c2, utf8proc_int32_t *state) {
-
-  const utf8proc_property_t *p1 = utf8proc_get_property(c1);
-  const utf8proc_property_t *p2 = utf8proc_get_property(c2);
-  return grapheme_break_extended(p1->boundclass,
-                                 p2->boundclass,
-                                 p1->indic_conjunct_break,
-                                 p2->indic_conjunct_break,
-                                 state);
-}
-
-
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break(
-    utf8proc_int32_t c1, utf8proc_int32_t c2) {
-  return utf8proc_grapheme_break_stateful(c1, c2, NULL);
-}
-
-static utf8proc_int32_t seqindex_decode_entry(const utf8proc_uint16_t **entry)
-{
-  utf8proc_int32_t entry_cp = **entry;
-  if ((entry_cp & 0xF800) == 0xD800) {
-    *entry = *entry + 1;
-    entry_cp = ((entry_cp & 0x03FF) << 10) | (**entry & 0x03FF);
-    entry_cp += 0x10000;
-  }
-  return entry_cp;
-}
-
-static utf8proc_int32_t seqindex_decode_index(const utf8proc_uint32_t seqindex)
-{
-  const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex];
-  return seqindex_decode_entry(&entry);
-}
-
-static utf8proc_ssize_t seqindex_write_char_decomposed(utf8proc_uint16_t seqindex, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) {
-  utf8proc_ssize_t written = 0;
-  const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex & 0x3FFF];
-  int len = seqindex >> 14;
-  if (len >= 3) {
-    len = *entry;
-    entry++;
-  }
-  for (; len >= 0; entry++, len--) {
-    utf8proc_int32_t entry_cp = seqindex_decode_entry(&entry);
-
-    written += utf8proc_decompose_char(entry_cp, dst ? dst+written : nullptr,
-      (bufsize > written) ? (bufsize - written) : 0, options,
-    last_boundclass);
-    if (written < 0) return UTF8PROC_ERROR_OVERFLOW;
-  }
-  return written;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_tolower(utf8proc_int32_t c)
-{
-  utf8proc_int32_t cl = utf8proc_get_property(c)->lowercase_seqindex;
-  return cl != UINT16_MAX ? seqindex_decode_index((utf8proc_uint32_t)cl) : c;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_toupper(utf8proc_int32_t c)
-{
-  utf8proc_int32_t cu = utf8proc_get_property(c)->uppercase_seqindex;
-  return cu != UINT16_MAX ? seqindex_decode_index((utf8proc_uint32_t)cu) : c;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c)
-{
-  utf8proc_int32_t cu = utf8proc_get_property(c)->titlecase_seqindex;
-  return cu != UINT16_MAX ? seqindex_decode_index((utf8proc_uint32_t)cu) : c;
-}
-
-UTF8PROC_DLLEXPORT int utf8proc_islower(utf8proc_int32_t c)
-{
-  const utf8proc_property_t *p = utf8proc_get_property(c);
-  return p->lowercase_seqindex != p->uppercase_seqindex && p->lowercase_seqindex == UINT16_MAX;
-}
-
-UTF8PROC_DLLEXPORT int utf8proc_isupper(utf8proc_int32_t c)
-{
-  const utf8proc_property_t *p = utf8proc_get_property(c);
-  return p->lowercase_seqindex != p->uppercase_seqindex && p->uppercase_seqindex == UINT16_MAX && p->category != UTF8PROC_CATEGORY_LT;
-}
-
-/* return a character width analogous to wcwidth (except portable and
-   hopefully less buggy than most system wcwidth functions). */
-UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t c) {
-  return utf8proc_get_property(c)->charwidth;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_category_t utf8proc_category(utf8proc_int32_t c) {
-  return (utf8proc_category_t) utf8proc_get_property(c)->category;
-}
-
-UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t c) {
-  static const char s[][3] = {"Cn","Lu","Ll","Lt","Lm","Lo","Mn","Mc","Me","Nd","Nl","No","Pc","Pd","Ps","Pe","Pi","Pf","Po","Sm","Sc","Sk","So","Zs","Zl","Zp","Cc","Cf","Cs","Co"};
-  return s[utf8proc_category(c)];
-}
-
-#define utf8proc_decompose_lump(replacement_uc) \
-return utf8proc_decompose_char((replacement_uc), dst, bufsize, \
-(utf8proc_option_t)(options & ~(unsigned int)UTF8PROC_LUMP), last_boundclass)
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char(utf8proc_int32_t uc, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) {
-  const utf8proc_property_t *property;
-  utf8proc_propval_t category;
-  utf8proc_int32_t hangul_sindex;
-  if (uc < 0 || uc >= 0x110000) return UTF8PROC_ERROR_NOTASSIGNED;
-  property = unsafe_get_property(uc);
-  category = property->category;
-  hangul_sindex = uc - UTF8PROC_HANGUL_SBASE;
-  if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) {
-    if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT) {
-      utf8proc_int32_t hangul_tindex;
-      if (bufsize >= 1) {
-        dst[0] = UTF8PROC_HANGUL_LBASE +
-          hangul_sindex / UTF8PROC_HANGUL_NCOUNT;
-        if (bufsize >= 2) dst[1] = UTF8PROC_HANGUL_VBASE +
-          (hangul_sindex % UTF8PROC_HANGUL_NCOUNT) / UTF8PROC_HANGUL_TCOUNT;
-      }
-      hangul_tindex = hangul_sindex % UTF8PROC_HANGUL_TCOUNT;
-      if (!hangul_tindex) return 2;
-      if (bufsize >= 3) dst[2] = UTF8PROC_HANGUL_TBASE + hangul_tindex;
-      return 3;
-    }
-  }
-  if (options & UTF8PROC_REJECTNA) {
-    if (!category) return UTF8PROC_ERROR_NOTASSIGNED;
-  }
-  if (options & UTF8PROC_IGNORE) {
-    if (property->ignorable) return 0;
-  }
-  if (options & UTF8PROC_STRIPNA) {
-    if (!category) return 0;
-  }
-  if (options & UTF8PROC_LUMP) {
-    if (category == UTF8PROC_CATEGORY_ZS) utf8proc_decompose_lump(0x0020);
-    if (uc == 0x2018 || uc == 0x2019 || uc == 0x02BC || uc == 0x02C8)
-      utf8proc_decompose_lump(0x0027);
-    if (category == UTF8PROC_CATEGORY_PD || uc == 0x2212)
-      utf8proc_decompose_lump(0x002D);
-    if (uc == 0x2044 || uc == 0x2215) utf8proc_decompose_lump(0x002F);
-    if (uc == 0x2236) utf8proc_decompose_lump(0x003A);
-    if (uc == 0x2039 || uc == 0x2329 || uc == 0x3008)
-      utf8proc_decompose_lump(0x003C);
-    if (uc == 0x203A || uc == 0x232A || uc == 0x3009)
-      utf8proc_decompose_lump(0x003E);
-    if (uc == 0x2216) utf8proc_decompose_lump(0x005C);
-    if (uc == 0x02C4 || uc == 0x02C6 || uc == 0x2038 || uc == 0x2303)
-      utf8proc_decompose_lump(0x005E);
-    if (category == UTF8PROC_CATEGORY_PC || uc == 0x02CD)
-      utf8proc_decompose_lump(0x005F);
-    if (uc == 0x02CB) utf8proc_decompose_lump(0x0060);
-    if (uc == 0x2223) utf8proc_decompose_lump(0x007C);
-    if (uc == 0x223C) utf8proc_decompose_lump(0x007E);
-    if ((options & UTF8PROC_NLF2LS) && (options & UTF8PROC_NLF2PS)) {
-      if (category == UTF8PROC_CATEGORY_ZL ||
-          category == UTF8PROC_CATEGORY_ZP)
-        utf8proc_decompose_lump(0x000A);
-    }
-  }
-  if (options & UTF8PROC_STRIPMARK) {
-    if (category == UTF8PROC_CATEGORY_MN ||
-      category == UTF8PROC_CATEGORY_MC ||
-      category == UTF8PROC_CATEGORY_ME) return 0;
-  }
-  if (options & UTF8PROC_CASEFOLD) {
-    if (property->casefold_seqindex != UINT16_MAX) {
-      return seqindex_write_char_decomposed(property->casefold_seqindex, dst, bufsize, options, last_boundclass);
-    }
-  }
-  if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) {
-    if (property->decomp_seqindex != UINT16_MAX &&
-        (!property->decomp_type || (options & UTF8PROC_COMPAT))) {
-      return seqindex_write_char_decomposed(property->decomp_seqindex, dst, bufsize, options, last_boundclass);
-        }
-  }
-  if (options & UTF8PROC_CHARBOUND) {
-    utf8proc_bool boundary;
-    boundary = grapheme_break_extended(0, property->boundclass, 0, property->indic_conjunct_break,
-                                       last_boundclass);
-    if (boundary) {
-      if (bufsize >= 1) dst[0] = -1; /* sentinel value for grapheme break */
-      if (bufsize >= 2) dst[1] = uc;
-      return 2;
-    }
-  }
-  if (bufsize >= 1) *dst = uc;
-  return 1;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-  utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options
-) {
-  return utf8proc_decompose_custom(str, strlen, buffer, bufsize, options, NULL, NULL);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-  utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options,
-  utf8proc_custom_func custom_func, void *custom_data
-) {
-  /* strlen will be ignored, if UTF8PROC_NULLTERM is set in options */
-  utf8proc_ssize_t wpos = 0;
-  if ((options & UTF8PROC_COMPOSE) && (options & UTF8PROC_DECOMPOSE))
-    return UTF8PROC_ERROR_INVALIDOPTS;
-  if ((options & UTF8PROC_STRIPMARK) &&
-      !(options & UTF8PROC_COMPOSE) && !(options & UTF8PROC_DECOMPOSE))
-    return UTF8PROC_ERROR_INVALIDOPTS;
-  {
-    utf8proc_int32_t uc;
-    utf8proc_ssize_t rpos = 0;
-    utf8proc_ssize_t decomp_result;
-    int boundclass = UTF8PROC_BOUNDCLASS_START;
-    while (1) {
-      if (options & UTF8PROC_NULLTERM) {
-        rpos += utf8proc_iterate(str + rpos, -1, &uc);
-        /* checking of return value is not necessary,
-           as 'uc' is < 0 in case of error */
-        if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8;
-        if (rpos < 0) return UTF8PROC_ERROR_OVERFLOW;
-        if (uc == 0) break;
-      } else {
-        if (rpos >= strlen) break;
-        rpos += utf8proc_iterate(str + rpos, strlen - rpos, &uc);
-        if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8;
-      }
-      if (custom_func != NULL) {
-        uc = custom_func(uc, custom_data);   /* user-specified custom mapping */
-      }
-      decomp_result = utf8proc_decompose_char(
-        uc, buffer ? buffer + wpos : nullptr, (bufsize > wpos) ? (bufsize - wpos) : 0, options,
-        &boundclass
-      );
-      if (decomp_result < 0) return decomp_result;
-      wpos += decomp_result;
-      /* prohibiting integer overflows due to too long strings: */
-      if (wpos < 0 ||
-          wpos > (utf8proc_ssize_t)(SSIZE_MAX/sizeof(utf8proc_int32_t)/2))
-        return UTF8PROC_ERROR_OVERFLOW;
-    }
-  }
-  if ((options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) && bufsize >= wpos) {
-    utf8proc_ssize_t pos = 0;
-    while (pos < wpos-1) {
-      utf8proc_int32_t uc1, uc2;
-      const utf8proc_property_t *property1, *property2;
-      uc1 = buffer[pos];
-      uc2 = buffer[pos+1];
-      property1 = unsafe_get_property(uc1);
-      property2 = unsafe_get_property(uc2);
-      if (property1->combining_class > property2->combining_class &&
-          property2->combining_class > 0) {
-        buffer[pos] = uc2;
-        buffer[pos+1] = uc1;
-        if (pos > 0) pos--; else pos++;
-          } else {
-            pos++;
-          }
-    }
-  }
-  return wpos;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_normalize_utf32(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options) {
-  /* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored */
-  if (options & (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS | UTF8PROC_STRIPCC)) {
-    utf8proc_ssize_t rpos;
-    utf8proc_ssize_t wpos = 0;
-    utf8proc_int32_t uc;
-    for (rpos = 0; rpos < length; rpos++) {
-      uc = buffer[rpos];
-      if (uc == 0x000D && rpos < length-1 && buffer[rpos+1] == 0x000A) rpos++;
-      if (uc == 0x000A || uc == 0x000D || uc == 0x0085 ||
-          ((options & UTF8PROC_STRIPCC) && (uc == 0x000B || uc == 0x000C))) {
-        if (options & UTF8PROC_NLF2LS) {
-          if (options & UTF8PROC_NLF2PS) {
-            buffer[wpos++] = 0x000A;
-          } else {
-            buffer[wpos++] = 0x2028;
-          }
-        } else {
-          if (options & UTF8PROC_NLF2PS) {
-            buffer[wpos++] = 0x2029;
-          } else {
-            buffer[wpos++] = 0x0020;
-          }
-        }
-          } else if ((options & UTF8PROC_STRIPCC) &&
-              (uc < 0x0020 || (uc >= 0x007F && uc < 0x00A0))) {
-            if (uc == 0x0009) buffer[wpos++] = 0x0020;
-              } else {
-                buffer[wpos++] = uc;
-              }
-    }
-    length = wpos;
-  }
-  if (options & UTF8PROC_COMPOSE) {
-    utf8proc_int32_t *starter = NULL;
-    utf8proc_int32_t current_char;
-    const utf8proc_property_t *starter_property = NULL, *current_property;
-    utf8proc_propval_t max_combining_class = -1;
-    utf8proc_ssize_t rpos;
-    utf8proc_ssize_t wpos = 0;
-    utf8proc_int32_t composition;
-    for (rpos = 0; rpos < length; rpos++) {
-      current_char = buffer[rpos];
-      current_property = unsafe_get_property(current_char);
-      if (starter && current_property->combining_class > max_combining_class) {
-        /* combination perhaps possible */
-        utf8proc_int32_t hangul_lindex;
-        utf8proc_int32_t hangul_sindex;
-        hangul_lindex = *starter - UTF8PROC_HANGUL_LBASE;
-        if (hangul_lindex >= 0 && hangul_lindex < UTF8PROC_HANGUL_LCOUNT) {
-          utf8proc_int32_t hangul_vindex;
-          hangul_vindex = current_char - UTF8PROC_HANGUL_VBASE;
-          if (hangul_vindex >= 0 && hangul_vindex < UTF8PROC_HANGUL_VCOUNT) {
-            *starter = UTF8PROC_HANGUL_SBASE +
-              (hangul_lindex * UTF8PROC_HANGUL_VCOUNT + hangul_vindex) *
-              UTF8PROC_HANGUL_TCOUNT;
-            starter_property = NULL;
-            continue;
-          }
-        }
-        hangul_sindex = *starter - UTF8PROC_HANGUL_SBASE;
-        if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT &&
-            (hangul_sindex % UTF8PROC_HANGUL_TCOUNT) == 0) {
-          utf8proc_int32_t hangul_tindex;
-          hangul_tindex = current_char - UTF8PROC_HANGUL_TBASE;
-          if (hangul_tindex >= 0 && hangul_tindex < UTF8PROC_HANGUL_TCOUNT) {
-            *starter += hangul_tindex;
-            starter_property = NULL;
-            continue;
-          }
-            }
-        if (!starter_property) {
-          starter_property = unsafe_get_property(*starter);
-        }
-        if (starter_property->comb_index < 0x8000 &&
-            current_property->comb_index != UINT16_MAX &&
-            current_property->comb_index >= 0x8000) {
-          int sidx = starter_property->comb_index;
-          int idx = current_property->comb_index & 0x3FFF;
-          if (idx >= utf8proc_combinations[sidx] && idx <= utf8proc_combinations[sidx + 1] ) {
-            idx += sidx + 2 - utf8proc_combinations[sidx];
-            if (current_property->comb_index & 0x4000) {
-              composition = (utf8proc_combinations[idx] << 16) | utf8proc_combinations[idx+1];
-            } else
-              composition = utf8proc_combinations[idx];
-
-            if (composition > 0 && (!(options & UTF8PROC_STABLE) ||
-                !(unsafe_get_property(composition)->comp_exclusion))) {
-              *starter = composition;
-              starter_property = NULL;
-              continue;
-                }
-          }
-            }
-      }
-      buffer[wpos] = current_char;
-      if (current_property->combining_class) {
-        if (current_property->combining_class > max_combining_class) {
-          max_combining_class = current_property->combining_class;
-        }
-      } else {
-        starter = buffer + wpos;
-        starter_property = NULL;
-        max_combining_class = -1;
-      }
-      wpos++;
-    }
-    length = wpos;
-  }
-  return length;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_reencode(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options) {
-  /* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored
-     ASSERT: 'buffer' has one spare byte of free space at the end! */
-  length = utf8proc_normalize_utf32(buffer, length, options);
-  if (length < 0) return length;
-  {
-    utf8proc_ssize_t rpos, wpos = 0;
-    utf8proc_int32_t uc;
-    if (options & UTF8PROC_CHARBOUND) {
-      for (rpos = 0; rpos < length; rpos++) {
-        uc = buffer[rpos];
-        wpos += charbound_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos);
-      }
-    } else {
-      for (rpos = 0; rpos < length; rpos++) {
-        uc = buffer[rpos];
-        wpos += utf8proc_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos);
-      }
-    }
-    ((utf8proc_uint8_t *)buffer)[wpos] = 0;
-    return wpos;
-  }
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options
-) {
-  return utf8proc_map_custom(str, strlen, dstptr, options, NULL, NULL);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options,
-  utf8proc_custom_func custom_func, void *custom_data
-) {
-  utf8proc_int32_t *buffer;
-  utf8proc_ssize_t result;
-  *dstptr = NULL;
-  result = utf8proc_decompose_custom(str, strlen, NULL, 0, options, custom_func, custom_data);
-  if (result < 0) return result;
-  buffer = (utf8proc_int32_t *) malloc(((utf8proc_size_t)result) * sizeof(utf8proc_int32_t) + 1);
-  if (!buffer) return UTF8PROC_ERROR_NOMEM;
-  result = utf8proc_decompose_custom(str, strlen, buffer, result, options, custom_func, custom_data);
-  if (result < 0) {
-    free(buffer);
-    return result;
-  }
-  result = utf8proc_reencode(buffer, result, options);
-  if (result < 0) {
-    free(buffer);
-    return result;
-  }
-  {
-    utf8proc_int32_t *newptr;
-    newptr = (utf8proc_int32_t *) realloc(buffer, (size_t)result+1);
-    if (newptr) buffer = newptr;
-  }
-  *dstptr = (utf8proc_uint8_t *)buffer;
-  return result;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) {
-  utf8proc_uint8_t *retval;
-  utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE |
-    UTF8PROC_DECOMPOSE));
-  return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) {
-  utf8proc_uint8_t *retval;
-  utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE |
-    UTF8PROC_COMPOSE));
-  return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) {
-  utf8proc_uint8_t *retval;
-  utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE |
-    UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT));
-  return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_COMPOSE | UTF8PROC_STRIPMARK));
-	return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) {
-  utf8proc_uint8_t *retval;
-  utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE |
-    UTF8PROC_COMPOSE | UTF8PROC_COMPAT));
-  return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) {
-  utf8proc_uint8_t *retval;
-  utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE |
-    UTF8PROC_COMPOSE | UTF8PROC_COMPAT | UTF8PROC_CASEFOLD | UTF8PROC_IGNORE));
-  return retval;
-}
-
-}
diff --git a/src/duckdb/third_party/utf8proc/utf8proc_data.cpp b/src/duckdb/third_party/utf8proc/utf8proc_data.cpp
deleted file mode 100644
index f2b0f5ce9..000000000
--- a/src/duckdb/third_party/utf8proc/utf8proc_data.cpp
+++ /dev/null
@@ -1,16960 +0,0 @@
-static const utf8proc_uint16_t utf8proc_sequences[] = {
-  97, 98, 99, 100, 101, 102, 103, 
-  104, 105, 106, 107, 108, 109, 110, 111, 
-  112, 113, 114, 115, 116, 117, 118, 119, 
-  120, 121, 122, 65, 66, 67, 68, 69, 
-  70, 71, 72, 73, 74, 75, 76, 77, 
-  78, 79, 80, 81, 82, 83, 84, 85, 
-  86, 87, 88, 89, 90, 32, 32, 776, 
-  170, 32, 772, 50, 51, 32, 769, 956, 
-  924, 32, 807, 49, 186, 49, 8260, 52, 
-  49, 8260, 50, 51, 8260, 52, 65, 768, 
-  224, 65, 769, 225, 65, 770, 226, 65, 
-  771, 227, 65, 776, 228, 65, 778, 229, 
-  230, 67, 807, 231, 69, 768, 232, 69, 
-  769, 233, 69, 770, 234, 69, 776, 235, 
-  73, 768, 236, 73, 769, 237, 73, 770, 
-  238, 73, 776, 239, 240, 78, 771, 241, 
-  79, 768, 242, 79, 769, 243, 79, 770, 
-  244, 79, 771, 245, 79, 776, 246, 248, 
-  85, 768, 249, 85, 769, 250, 85, 770, 
-  251, 85, 776, 252, 89, 769, 253, 254, 
-  115, 115, 7838, 97, 768, 192, 97, 769, 
-  193, 97, 770, 194, 97, 771, 195, 97, 
-  776, 196, 97, 778, 197, 198, 99, 807, 
-  199, 101, 768, 200, 101, 769, 201, 101, 
-  770, 202, 101, 776, 203, 105, 768, 204, 
-  105, 769, 205, 105, 770, 206, 105, 776, 
-  207, 208, 110, 771, 209, 111, 768, 210, 
-  111, 769, 211, 111, 770, 212, 111, 771, 
-  213, 111, 776, 214, 216, 117, 768, 217, 
-  117, 769, 218, 117, 770, 219, 117, 776, 
-  220, 121, 769, 221, 222, 121, 776, 376, 
-  65, 772, 257, 97, 772, 256, 65, 774, 
-  259, 97, 774, 258, 65, 808, 261, 97, 
-  808, 260, 67, 769, 263, 99, 769, 262, 
-  67, 770, 265, 99, 770, 264, 67, 775, 
-  267, 99, 775, 266, 67, 780, 269, 99, 
-  780, 268, 68, 780, 271, 100, 780, 270, 
-  273, 272, 69, 772, 275, 101, 772, 274, 
-  69, 774, 277, 101, 774, 276, 69, 775, 
-  279, 101, 775, 278, 69, 808, 281, 101, 
-  808, 280, 69, 780, 283, 101, 780, 282, 
-  71, 770, 285, 103, 770, 284, 71, 774, 
-  287, 103, 774, 286, 71, 775, 289, 103, 
-  775, 288, 71, 807, 291, 103, 807, 290, 
-  72, 770, 293, 104, 770, 292, 295, 294, 
-  73, 771, 297, 105, 771, 296, 73, 772, 
-  299, 105, 772, 298, 73, 774, 301, 105, 
-  774, 300, 73, 808, 303, 105, 808, 302, 
-  73, 775, 105, 775, 73, 74, 307, 105, 
-  106, 306, 74, 770, 309, 106, 770, 308, 
-  75, 807, 311, 107, 807, 310, 312, 76, 
-  769, 314, 108, 769, 313, 76, 807, 316, 
-  108, 807, 315, 76, 780, 318, 108, 780, 
-  317, 76, 183, 320, 108, 183, 319, 322, 
-  321, 78, 769, 324, 110, 769, 323, 78, 
-  807, 326, 110, 807, 325, 78, 780, 328, 
-  110, 780, 327, 700, 110, 329, 331, 330, 
-  79, 772, 333, 111, 772, 332, 79, 774, 
-  335, 111, 774, 334, 79, 779, 337, 111, 
-  779, 336, 339, 338, 82, 769, 341, 114, 
-  769, 340, 82, 807, 343, 114, 807, 342, 
-  82, 780, 345, 114, 780, 344, 83, 769, 
-  347, 115, 769, 346, 83, 770, 349, 115, 
-  770, 348, 83, 807, 351, 115, 807, 350, 
-  83, 780, 353, 115, 780, 352, 84, 807, 
-  355, 116, 807, 354, 84, 780, 357, 116, 
-  780, 356, 359, 358, 85, 771, 361, 117, 
-  771, 360, 85, 772, 363, 117, 772, 362, 
-  85, 774, 365, 117, 774, 364, 85, 778, 
-  367, 117, 778, 366, 85, 779, 369, 117, 
-  779, 368, 85, 808, 371, 117, 808, 370, 
-  87, 770, 373, 119, 770, 372, 89, 770, 
-  375, 121, 770, 374, 89, 776, 255, 90, 
-  769, 378, 122, 769, 377, 90, 775, 380, 
-  122, 775, 379, 90, 780, 382, 122, 780, 
-  381, 579, 595, 387, 386, 389, 388, 596, 
-  392, 391, 598, 599, 396, 395, 397, 477, 
-  601, 603, 402, 401, 608, 611, 502, 617, 
-  616, 409, 408, 573, 411, 623, 626, 544, 
-  629, 79, 795, 417, 111, 795, 416, 419, 
-  418, 421, 420, 640, 424, 423, 643, 426, 
-  427, 429, 428, 648, 85, 795, 432, 117, 
-  795, 431, 650, 651, 436, 435, 438, 437, 
-  658, 441, 440, 442, 445, 444, 446, 503, 
-  68, 381, 454, 453, 68, 382, 452, 100, 
-  382, 76, 74, 457, 456, 76, 106, 455, 
-  108, 106, 78, 74, 460, 459, 78, 106, 
-  458, 110, 106, 65, 780, 462, 97, 780, 
-  461, 73, 780, 464, 105, 780, 463, 79, 
-  780, 466, 111, 780, 465, 85, 780, 468, 
-  117, 780, 467, 220, 772, 470, 252, 772, 
-  469, 220, 769, 472, 252, 769, 471, 220, 
-  780, 474, 252, 780, 473, 220, 768, 476, 
-  252, 768, 475, 398, 196, 772, 479, 228, 
-  772, 478, 550, 772, 481, 551, 772, 480, 
-  198, 772, 483, 230, 772, 482, 485, 484, 
-  71, 780, 487, 103, 780, 486, 75, 780, 
-  489, 107, 780, 488, 79, 808, 491, 111, 
-  808, 490, 490, 772, 493, 491, 772, 492, 
-  439, 780, 495, 658, 780, 494, 106, 780, 
-  496, 68, 90, 499, 498, 68, 122, 497, 
-  100, 122, 71, 769, 501, 103, 769, 500, 
-  405, 447, 78, 768, 505, 110, 768, 504, 
-  197, 769, 507, 229, 769, 506, 198, 769, 
-  509, 230, 769, 508, 216, 769, 511, 248, 
-  769, 510, 65, 783, 513, 97, 783, 512, 
-  65, 785, 515, 97, 785, 514, 69, 783, 
-  517, 101, 783, 516, 69, 785, 519, 101, 
-  785, 518, 73, 783, 521, 105, 783, 520, 
-  73, 785, 523, 105, 785, 522, 79, 783, 
-  525, 111, 783, 524, 79, 785, 527, 111, 
-  785, 526, 82, 783, 529, 114, 783, 528, 
-  82, 785, 531, 114, 785, 530, 85, 783, 
-  533, 117, 783, 532, 85, 785, 535, 117, 
-  785, 534, 83, 806, 537, 115, 806, 536, 
-  84, 806, 539, 116, 806, 538, 541, 540, 
-  72, 780, 543, 104, 780, 542, 414, 545, 
-  547, 546, 549, 548, 65, 775, 551, 97, 
-  775, 550, 69, 807, 553, 101, 807, 552, 
-  214, 772, 555, 246, 772, 554, 213, 772, 
-  557, 245, 772, 556, 79, 775, 559, 111, 
-  775, 558, 558, 772, 561, 559, 772, 560, 
-  89, 772, 563, 121, 772, 562, 564, 565, 
-  566, 567, 568, 569, 11365, 572, 571, 410, 
-  11366, 11390, 11391, 578, 577, 384, 649, 652, 
-  583, 582, 585, 584, 587, 586, 589, 588, 
-  591, 590, 11375, 11373, 11376, 385, 390, 597, 
-  393, 394, 600, 399, 602, 400, 42923, 605, 
-  606, 607, 403, 42924, 610, 404, 612, 42893, 
-  42922, 615, 407, 406, 42926, 11362, 42925, 621, 
-  622, 412, 624, 11374, 413, 627, 628, 415, 
-  630, 631, 632, 633, 634, 635, 636, 11364, 
-  638, 639, 422, 641, 42949, 425, 644, 645, 
-  646, 42929, 430, 580, 433, 434, 581, 653, 
-  654, 655, 656, 657, 439, 659, 661, 662, 
-  663, 664, 665, 666, 667, 668, 42930, 42928, 
-  671, 672, 673, 674, 675, 676, 677, 678, 
-  679, 680, 681, 682, 683, 684, 685, 686, 
-  687, 688, 614, 689, 690, 691, 692, 693, 
-  694, 695, 696, 704, 705, 32, 774, 32, 
-  775, 32, 778, 32, 808, 32, 771, 32, 
-  779, 736, 737, 738, 739, 740, 768, 769, 
-  787, 776, 769, 953, 921, 881, 880, 883, 
-  882, 697, 887, 886, 32, 837, 890, 1021, 
-  1022, 1023, 59, 1011, 168, 769, 913, 769, 
-  940, 183, 917, 769, 941, 919, 769, 942, 
-  921, 769, 943, 927, 769, 972, 933, 769, 
-  973, 937, 769, 974, 970, 769, 953, 776, 
-  769, 912, 945, 946, 947, 948, 949, 950, 
-  951, 952, 954, 955, 957, 958, 959, 960, 
-  961, 963, 964, 965, 966, 967, 968, 969, 
-  921, 776, 970, 933, 776, 971, 945, 769, 
-  902, 949, 769, 904, 951, 769, 905, 953, 
-  769, 906, 971, 769, 965, 776, 769, 944, 
-  913, 914, 915, 916, 917, 918, 919, 920, 
-  922, 923, 925, 926, 927, 928, 929, 931, 
-  932, 933, 934, 935, 936, 937, 953, 776, 
-  938, 965, 776, 939, 959, 769, 908, 965, 
-  769, 910, 969, 769, 911, 983, 978, 978, 
-  769, 979, 978, 776, 980, 975, 985, 984, 
-  987, 986, 989, 988, 991, 990, 993, 992, 
-  995, 994, 997, 996, 999, 998, 1001, 1000, 
-  1003, 1002, 1005, 1004, 1007, 1006, 962, 1017, 
-  895, 1016, 1015, 1010, 1019, 1018, 1020, 891, 
-  892, 893, 1045, 768, 1104, 1045, 776, 1105, 
-  1106, 1043, 769, 1107, 1108, 1109, 1110, 1030, 
-  776, 1111, 1112, 1113, 1114, 1115, 1050, 769, 
-  1116, 1048, 768, 1117, 1059, 774, 1118, 1119, 
-  1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 
-  1080, 1048, 774, 1081, 1082, 1083, 1084, 1085, 
-  1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 
-  1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 
-  1102, 1103, 1040, 1041, 1042, 1043, 1044, 1045, 
-  1046, 1047, 1048, 1080, 774, 1049, 1050, 1051, 
-  1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 
-  1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 
-  1068, 1069, 1070, 1071, 1077, 768, 1024, 1077, 
-  776, 1025, 1026, 1075, 769, 1027, 1028, 1029, 
-  1030, 1110, 776, 1031, 1032, 1033, 1034, 1035, 
-  1082, 769, 1036, 1080, 768, 1037, 1091, 774, 
-  1038, 1039, 1121, 1120, 1123, 1122, 1125, 1124, 
-  1127, 1126, 1129, 1128, 1131, 1130, 1133, 1132, 
-  1135, 1134, 1137, 1136, 1139, 1138, 1141, 1140, 
-  1140, 783, 1143, 1141, 783, 1142, 1145, 1144, 
-  1147, 1146, 1149, 1148, 1151, 1150, 1153, 1152, 
-  1163, 1162, 1165, 1164, 1167, 1166, 1169, 1168, 
-  1171, 1170, 1173, 1172, 1175, 1174, 1177, 1176, 
-  1179, 1178, 1181, 1180, 1183, 1182, 1185, 1184, 
-  1187, 1186, 1189, 1188, 1191, 1190, 1193, 1192, 
-  1195, 1194, 1197, 1196, 1199, 1198, 1201, 1200, 
-  1203, 1202, 1205, 1204, 1207, 1206, 1209, 1208, 
-  1211, 1210, 1213, 1212, 1215, 1214, 1231, 1046, 
-  774, 1218, 1078, 774, 1217, 1220, 1219, 1222, 
-  1221, 1224, 1223, 1226, 1225, 1228, 1227, 1230, 
-  1229, 1216, 1040, 774, 1233, 1072, 774, 1232, 
-  1040, 776, 1235, 1072, 776, 1234, 1237, 1236, 
-  1045, 774, 1239, 1077, 774, 1238, 1241, 1240, 
-  1240, 776, 1243, 1241, 776, 1242, 1046, 776, 
-  1245, 1078, 776, 1244, 1047, 776, 1247, 1079, 
-  776, 1246, 1249, 1248, 1048, 772, 1251, 1080, 
-  772, 1250, 1048, 776, 1253, 1080, 776, 1252, 
-  1054, 776, 1255, 1086, 776, 1254, 1257, 1256, 
-  1256, 776, 1259, 1257, 776, 1258, 1069, 776, 
-  1261, 1101, 776, 1260, 1059, 772, 1263, 1091, 
-  772, 1262, 1059, 776, 1265, 1091, 776, 1264, 
-  1059, 779, 1267, 1091, 779, 1266, 1063, 776, 
-  1269, 1095, 776, 1268, 1271, 1270, 1067, 776, 
-  1273, 1099, 776, 1272, 1275, 1274, 1277, 1276, 
-  1279, 1278, 1281, 1280, 1283, 1282, 1285, 1284, 
-  1287, 1286, 1289, 1288, 1291, 1290, 1293, 1292, 
-  1295, 1294, 1297, 1296, 1299, 1298, 1301, 1300, 
-  1303, 1302, 1305, 1304, 1307, 1306, 1309, 1308, 
-  1311, 1310, 1313, 1312, 1315, 1314, 1317, 1316, 
-  1319, 1318, 1321, 1320, 1323, 1322, 1325, 1324, 
-  1327, 1326, 1377, 1378, 1379, 1380, 1381, 1382, 
-  1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 
-  1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 
-  1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 
-  1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 
-  1376, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 
-  1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 
-  1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 
-  1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 
-  1360, 1361, 1362, 1363, 1364, 1365, 1366, 1381, 
-  1410, 1415, 1416, 1575, 1619, 1575, 1620, 1608, 
-  1620, 1575, 1621, 1610, 1620, 1575, 1652, 1608, 
-  1652, 1735, 1652, 1610, 1652, 1749, 1620, 1729, 
-  1620, 1746, 1620, 2344, 2364, 2352, 2364, 2355, 
-  2364, 2325, 2364, 2326, 2364, 2327, 2364, 2332, 
-  2364, 2337, 2364, 2338, 2364, 2347, 2364, 2351, 
-  2364, 2503, 2494, 2503, 2519, 2465, 2492, 2466, 
-  2492, 2479, 2492, 2610, 2620, 2616, 2620, 2582, 
-  2620, 2583, 2620, 2588, 2620, 2603, 2620, 2887, 
-  2902, 2887, 2878, 2887, 2903, 2849, 2876, 2850, 
-  2876, 2962, 3031, 3014, 3006, 3015, 3006, 3014, 
-  3031, 3142, 3158, 3263, 3285, 3270, 3285, 3270, 
-  3286, 3270, 3266, 3274, 3285, 3398, 3390, 3399, 
-  3390, 3398, 3415, 3545, 3530, 3545, 3535, 3548, 
-  3530, 3545, 3551, 3661, 3634, 3789, 3762, 3755, 
-  3737, 3755, 3745, 3851, 3906, 4023, 3916, 4023, 
-  3921, 4023, 3926, 4023, 3931, 4023, 3904, 4021, 
-  3953, 3954, 3953, 3956, 4018, 3968, 4018, 3969, 
-  4019, 3968, 4019, 3969, 3953, 3968, 3986, 4023, 
-  3996, 4023, 4001, 4023, 4006, 4023, 4011, 4023, 
-  3984, 4021, 4133, 4142, 11520, 11521, 11522, 11523, 
-  11524, 11525, 11526, 11527, 11528, 11529, 11530, 11531, 
-  11532, 11533, 11534, 11535, 11536, 11537, 11538, 11539, 
-  11540, 11541, 11542, 11543, 11544, 11545, 11546, 11547, 
-  11548, 11549, 11550, 11551, 11552, 11553, 11554, 11555, 
-  11556, 11557, 11559, 11565, 7312, 4304, 7313, 4305, 
-  7314, 4306, 7315, 4307, 7316, 4308, 7317, 4309, 
-  7318, 4310, 7319, 4311, 7320, 4312, 7321, 4313, 
-  7322, 4314, 7323, 4315, 7324, 4316, 7325, 4317, 
-  7326, 4318, 7327, 4319, 7328, 4320, 7329, 4321, 
-  7330, 4322, 7331, 4323, 7332, 4324, 7333, 4325, 
-  7334, 4326, 7335, 4327, 7336, 4328, 7337, 4329, 
-  7338, 4330, 7339, 4331, 7340, 4332, 7341, 4333, 
-  7342, 4334, 7343, 4335, 7344, 4336, 7345, 4337, 
-  7346, 4338, 7347, 4339, 7348, 4340, 7349, 4341, 
-  7350, 4342, 7351, 4343, 7352, 4344, 7353, 4345, 
-  7354, 4346, 4348, 7357, 4349, 7358, 4350, 7359, 
-  4351, 43888, 43889, 43890, 43891, 43892, 43893, 43894, 
-  43895, 43896, 43897, 43898, 43899, 43900, 43901, 43902, 
-  43903, 43904, 43905, 43906, 43907, 43908, 43909, 43910, 
-  43911, 43912, 43913, 43914, 43915, 43916, 43917, 43918, 
-  43919, 43920, 43921, 43922, 43923, 43924, 43925, 43926, 
-  43927, 43928, 43929, 43930, 43931, 43932, 43933, 43934, 
-  43935, 43936, 43937, 43938, 43939, 43940, 43941, 43942, 
-  43943, 43944, 43945, 43946, 43947, 43948, 43949, 43950, 
-  43951, 43952, 43953, 43954, 43955, 43956, 43957, 43958, 
-  43959, 43960, 43961, 43962, 43963, 43964, 43965, 43966, 
-  43967, 5112, 5113, 5114, 5115, 5116, 5117, 5104, 
-  5105, 5106, 5107, 5108, 5109, 6917, 6965, 6919, 
-  6965, 6921, 6965, 6923, 6965, 6925, 6965, 6929, 
-  6965, 6970, 6965, 6972, 6965, 6974, 6965, 6975, 
-  6965, 6978, 6965, 42571, 42570, 7424, 7425, 7426, 
-  7427, 7428, 7429, 7430, 7431, 7432, 7433, 7434, 
-  7435, 7436, 7437, 7438, 7439, 7440, 7441, 7442, 
-  7443, 7444, 7445, 7446, 7447, 7448, 7449, 7450, 
-  7451, 7452, 7453, 7454, 7455, 7456, 7457, 7458, 
-  7459, 7460, 7461, 7462, 7463, 7464, 7465, 7466, 
-  7467, 7468, 7469, 7470, 7471, 7472, 7473, 7474, 
-  7475, 7476, 7477, 7478, 7479, 7480, 7481, 7482, 
-  7483, 7484, 7485, 7486, 7487, 7488, 7489, 7490, 
-  7491, 592, 7492, 593, 7493, 7494, 7495, 7496, 
-  7497, 7498, 7499, 604, 7500, 7501, 7502, 7503, 
-  7504, 7505, 7506, 7507, 7508, 7509, 7510, 7511, 
-  7512, 7513, 7514, 7515, 7516, 7517, 7518, 7519, 
-  7520, 7521, 7522, 7523, 7524, 7525, 7526, 7527, 
-  7528, 7529, 7530, 7531, 7532, 7533, 7534, 7535, 
-  7536, 7537, 7538, 7539, 7540, 7541, 7542, 7543, 
-  7544, 42877, 7546, 7547, 7548, 11363, 7550, 7551, 
-  7552, 7553, 7554, 7555, 7556, 7557, 7558, 7559, 
-  7560, 7561, 7562, 7563, 7564, 7565, 42950, 7567, 
-  7568, 7569, 7570, 7571, 7572, 7573, 7574, 7575, 
-  7576, 7577, 7578, 594, 7579, 7580, 7581, 7582, 
-  7583, 7584, 7585, 609, 7586, 613, 7587, 7588, 
-  7589, 618, 7590, 7591, 669, 7592, 7593, 7594, 
-  7595, 625, 7596, 7597, 7598, 7599, 7600, 7601, 
-  7602, 642, 7603, 7604, 7605, 7606, 7607, 7608, 
-  7609, 7610, 7611, 7612, 7613, 7614, 7615, 65, 
-  805, 7681, 97, 805, 7680, 66, 775, 7683, 
-  98, 775, 7682, 66, 803, 7685, 98, 803, 
-  7684, 66, 817, 7687, 98, 817, 7686, 199, 
-  769, 7689, 231, 769, 7688, 68, 775, 7691, 
-  100, 775, 7690, 68, 803, 7693, 100, 803, 
-  7692, 68, 817, 7695, 100, 817, 7694, 68, 
-  807, 7697, 100, 807, 7696, 68, 813, 7699, 
-  100, 813, 7698, 274, 768, 7701, 275, 768, 
-  7700, 274, 769, 7703, 275, 769, 7702, 69, 
-  813, 7705, 101, 813, 7704, 69, 816, 7707, 
-  101, 816, 7706, 552, 774, 7709, 553, 774, 
-  7708, 70, 775, 7711, 102, 775, 7710, 71, 
-  772, 7713, 103, 772, 7712, 72, 775, 7715, 
-  104, 775, 7714, 72, 803, 7717, 104, 803, 
-  7716, 72, 776, 7719, 104, 776, 7718, 72, 
-  807, 7721, 104, 807, 7720, 72, 814, 7723, 
-  104, 814, 7722, 73, 816, 7725, 105, 816, 
-  7724, 207, 769, 7727, 239, 769, 7726, 75, 
-  769, 7729, 107, 769, 7728, 75, 803, 7731, 
-  107, 803, 7730, 75, 817, 7733, 107, 817, 
-  7732, 76, 803, 7735, 108, 803, 7734, 7734, 
-  772, 7737, 7735, 772, 7736, 76, 817, 7739, 
-  108, 817, 7738, 76, 813, 7741, 108, 813, 
-  7740, 77, 769, 7743, 109, 769, 7742, 77, 
-  775, 7745, 109, 775, 7744, 77, 803, 7747, 
-  109, 803, 7746, 78, 775, 7749, 110, 775, 
-  7748, 78, 803, 7751, 110, 803, 7750, 78, 
-  817, 7753, 110, 817, 7752, 78, 813, 7755, 
-  110, 813, 7754, 213, 769, 7757, 245, 769, 
-  7756, 213, 776, 7759, 245, 776, 7758, 332, 
-  768, 7761, 333, 768, 7760, 332, 769, 7763, 
-  333, 769, 7762, 80, 769, 7765, 112, 769, 
-  7764, 80, 775, 7767, 112, 775, 7766, 82, 
-  775, 7769, 114, 775, 7768, 82, 803, 7771, 
-  114, 803, 7770, 7770, 772, 7773, 7771, 772, 
-  7772, 82, 817, 7775, 114, 817, 7774, 83, 
-  775, 7777, 115, 775, 7776, 83, 803, 7779, 
-  115, 803, 7778, 346, 775, 7781, 347, 775, 
-  7780, 352, 775, 7783, 353, 775, 7782, 7778, 
-  775, 7785, 7779, 775, 7784, 84, 775, 7787, 
-  116, 775, 7786, 84, 803, 7789, 116, 803, 
-  7788, 84, 817, 7791, 116, 817, 7790, 84, 
-  813, 7793, 116, 813, 7792, 85, 804, 7795, 
-  117, 804, 7794, 85, 816, 7797, 117, 816, 
-  7796, 85, 813, 7799, 117, 813, 7798, 360, 
-  769, 7801, 361, 769, 7800, 362, 776, 7803, 
-  363, 776, 7802, 86, 771, 7805, 118, 771, 
-  7804, 86, 803, 7807, 118, 803, 7806, 87, 
-  768, 7809, 119, 768, 7808, 87, 769, 7811, 
-  119, 769, 7810, 87, 776, 7813, 119, 776, 
-  7812, 87, 775, 7815, 119, 775, 7814, 87, 
-  803, 7817, 119, 803, 7816, 88, 775, 7819, 
-  120, 775, 7818, 88, 776, 7821, 120, 776, 
-  7820, 89, 775, 7823, 121, 775, 7822, 90, 
-  770, 7825, 122, 770, 7824, 90, 803, 7827, 
-  122, 803, 7826, 90, 817, 7829, 122, 817, 
-  7828, 104, 817, 7830, 116, 776, 7831, 119, 
-  778, 7832, 121, 778, 7833, 97, 702, 7834, 
-  383, 775, 7836, 7837, 223, 7839, 65, 803, 
-  7841, 97, 803, 7840, 65, 777, 7843, 97, 
-  777, 7842, 194, 769, 7845, 226, 769, 7844, 
-  194, 768, 7847, 226, 768, 7846, 194, 777, 
-  7849, 226, 777, 7848, 194, 771, 7851, 226, 
-  771, 7850, 7840, 770, 7853, 7841, 770, 7852, 
-  258, 769, 7855, 259, 769, 7854, 258, 768, 
-  7857, 259, 768, 7856, 258, 777, 7859, 259, 
-  777, 7858, 258, 771, 7861, 259, 771, 7860, 
-  7840, 774, 7863, 7841, 774, 7862, 69, 803, 
-  7865, 101, 803, 7864, 69, 777, 7867, 101, 
-  777, 7866, 69, 771, 7869, 101, 771, 7868, 
-  202, 769, 7871, 234, 769, 7870, 202, 768, 
-  7873, 234, 768, 7872, 202, 777, 7875, 234, 
-  777, 7874, 202, 771, 7877, 234, 771, 7876, 
-  7864, 770, 7879, 7865, 770, 7878, 73, 777, 
-  7881, 105, 777, 7880, 73, 803, 7883, 105, 
-  803, 7882, 79, 803, 7885, 111, 803, 7884, 
-  79, 777, 7887, 111, 777, 7886, 212, 769, 
-  7889, 244, 769, 7888, 212, 768, 7891, 244, 
-  768, 7890, 212, 777, 7893, 244, 777, 7892, 
-  212, 771, 7895, 244, 771, 7894, 7884, 770, 
-  7897, 7885, 770, 7896, 416, 769, 7899, 417, 
-  769, 7898, 416, 768, 7901, 417, 768, 7900, 
-  416, 777, 7903, 417, 777, 7902, 416, 771, 
-  7905, 417, 771, 7904, 416, 803, 7907, 417, 
-  803, 7906, 85, 803, 7909, 117, 803, 7908, 
-  85, 777, 7911, 117, 777, 7910, 431, 769, 
-  7913, 432, 769, 7912, 431, 768, 7915, 432, 
-  768, 7914, 431, 777, 7917, 432, 777, 7916, 
-  431, 771, 7919, 432, 771, 7918, 431, 803, 
-  7921, 432, 803, 7920, 89, 768, 7923, 121, 
-  768, 7922, 89, 803, 7925, 121, 803, 7924, 
-  89, 777, 7927, 121, 777, 7926, 89, 771, 
-  7929, 121, 771, 7928, 7931, 7930, 7933, 7932, 
-  7935, 7934, 945, 787, 7944, 945, 788, 7945, 
-  7936, 768, 7946, 7937, 768, 7947, 7936, 769, 
-  7948, 7937, 769, 7949, 7936, 834, 7950, 7937, 
-  834, 7951, 913, 787, 7936, 913, 788, 7937, 
-  7944, 768, 7938, 7945, 768, 7939, 7944, 769, 
-  7940, 7945, 769, 7941, 7944, 834, 7942, 7945, 
-  834, 7943, 949, 787, 7960, 949, 788, 7961, 
-  7952, 768, 7962, 7953, 768, 7963, 7952, 769, 
-  7964, 7953, 769, 7965, 917, 787, 7952, 917, 
-  788, 7953, 7960, 768, 7954, 7961, 768, 7955, 
-  7960, 769, 7956, 7961, 769, 7957, 951, 787, 
-  7976, 951, 788, 7977, 7968, 768, 7978, 7969, 
-  768, 7979, 7968, 769, 7980, 7969, 769, 7981, 
-  7968, 834, 7982, 7969, 834, 7983, 919, 787, 
-  7968, 919, 788, 7969, 7976, 768, 7970, 7977, 
-  768, 7971, 7976, 769, 7972, 7977, 769, 7973, 
-  7976, 834, 7974, 7977, 834, 7975, 953, 787, 
-  7992, 953, 788, 7993, 7984, 768, 7994, 7985, 
-  768, 7995, 7984, 769, 7996, 7985, 769, 7997, 
-  7984, 834, 7998, 7985, 834, 7999, 921, 787, 
-  7984, 921, 788, 7985, 7992, 768, 7986, 7993, 
-  768, 7987, 7992, 769, 7988, 7993, 769, 7989, 
-  7992, 834, 7990, 7993, 834, 7991, 959, 787, 
-  8008, 959, 788, 8009, 8000, 768, 8010, 8001, 
-  768, 8011, 8000, 769, 8012, 8001, 769, 8013, 
-  927, 787, 8000, 927, 788, 8001, 8008, 768, 
-  8002, 8009, 768, 8003, 8008, 769, 8004, 8009, 
-  769, 8005, 965, 787, 8016, 965, 788, 8025, 
-  8016, 768, 965, 787, 768, 8018, 8017, 768, 
-  8027, 8016, 769, 965, 787, 769, 8020, 8017, 
-  769, 8029, 8016, 834, 965, 787, 834, 8022, 
-  8017, 834, 8031, 933, 788, 8017, 8025, 768, 
-  8019, 8025, 769, 8021, 8025, 834, 8023, 969, 
-  787, 8040, 969, 788, 8041, 8032, 768, 8042, 
-  8033, 768, 8043, 8032, 769, 8044, 8033, 769, 
-  8045, 8032, 834, 8046, 8033, 834, 8047, 937, 
-  787, 8032, 937, 788, 8033, 8040, 768, 8034, 
-  8041, 768, 8035, 8040, 769, 8036, 8041, 769, 
-  8037, 8040, 834, 8038, 8041, 834, 8039, 945, 
-  768, 8122, 8123, 949, 768, 8136, 8137, 951, 
-  768, 8138, 8139, 953, 768, 8154, 8155, 959, 
-  768, 8184, 8185, 965, 768, 8170, 8171, 969, 
-  768, 8186, 8187, 7936, 837, 7936, 953, 8072, 
-  7937, 837, 7937, 953, 8073, 7938, 837, 7938, 
-  953, 8074, 7939, 837, 7939, 953, 8075, 7940, 
-  837, 7940, 953, 8076, 7941, 837, 7941, 953, 
-  8077, 7942, 837, 7942, 953, 8078, 7943, 837, 
-  7943, 953, 8079, 7944, 837, 8064, 7945, 837, 
-  8065, 7946, 837, 8066, 7947, 837, 8067, 7948, 
-  837, 8068, 7949, 837, 8069, 7950, 837, 8070, 
-  7951, 837, 8071, 7968, 837, 7968, 953, 8088, 
-  7969, 837, 7969, 953, 8089, 7970, 837, 7970, 
-  953, 8090, 7971, 837, 7971, 953, 8091, 7972, 
-  837, 7972, 953, 8092, 7973, 837, 7973, 953, 
-  8093, 7974, 837, 7974, 953, 8094, 7975, 837, 
-  7975, 953, 8095, 7976, 837, 8080, 7977, 837, 
-  8081, 7978, 837, 8082, 7979, 837, 8083, 7980, 
-  837, 8084, 7981, 837, 8085, 7982, 837, 8086, 
-  7983, 837, 8087, 8032, 837, 8032, 953, 8104, 
-  8033, 837, 8033, 953, 8105, 8034, 837, 8034, 
-  953, 8106, 8035, 837, 8035, 953, 8107, 8036, 
-  837, 8036, 953, 8108, 8037, 837, 8037, 953, 
-  8109, 8038, 837, 8038, 953, 8110, 8039, 837, 
-  8039, 953, 8111, 8040, 837, 8096, 8041, 837, 
-  8097, 8042, 837, 8098, 8043, 837, 8099, 8044, 
-  837, 8100, 8045, 837, 8101, 8046, 837, 8102, 
-  8047, 837, 8103, 945, 774, 8120, 945, 772, 
-  8121, 8048, 837, 8048, 953, 8114, 945, 837, 
-  945, 953, 8124, 940, 837, 940, 953, 8116, 
-  945, 834, 8118, 8118, 837, 945, 834, 953, 
-  8119, 913, 774, 8112, 913, 772, 8113, 913, 
-  768, 8048, 8049, 913, 837, 8115, 32, 787, 
-  32, 834, 168, 834, 8052, 837, 8052, 953, 
-  8130, 951, 837, 951, 953, 8140, 942, 837, 
-  942, 953, 8132, 951, 834, 8134, 8134, 837, 
-  951, 834, 953, 8135, 917, 768, 8050, 8051, 
-  919, 768, 8052, 8053, 919, 837, 8131, 8127, 
-  768, 8127, 769, 8127, 834, 953, 774, 8152, 
-  953, 772, 8153, 970, 768, 953, 776, 768, 
-  8146, 8147, 953, 834, 8150, 970, 834, 953, 
-  776, 834, 8151, 921, 774, 8144, 921, 772, 
-  8145, 921, 768, 8054, 8055, 8190, 768, 8190, 
-  769, 8190, 834, 965, 774, 8168, 965, 772, 
-  8169, 971, 768, 965, 776, 768, 8162, 8163, 
-  961, 787, 8164, 961, 788, 8172, 965, 834, 
-  8166, 971, 834, 965, 776, 834, 8167, 933, 
-  774, 8160, 933, 772, 8161, 933, 768, 8058, 
-  8059, 929, 788, 8165, 168, 768, 901, 96, 
-  8060, 837, 8060, 953, 8178, 969, 837, 969, 
-  953, 8188, 974, 837, 974, 953, 8180, 969, 
-  834, 8182, 8182, 837, 969, 834, 953, 8183, 
-  927, 768, 8056, 8057, 937, 768, 8060, 8061, 
-  937, 837, 8179, 180, 32, 788, 8194, 8195, 
-  8208, 32, 819, 46, 46, 46, 46, 46, 
-  46, 8242, 8242, 8242, 8242, 8242, 8245, 8245, 
-  8245, 8245, 8245, 33, 33, 32, 773, 63, 
-  63, 63, 33, 33, 63, 3, 8242, 8242, 
-  8242, 8242, 48, 8305, 52, 53, 54, 55, 
-  56, 57, 43, 8722, 61, 40, 41, 8319, 
-  8336, 8337, 8338, 8339, 8340, 8341, 8342, 8343, 
-  8344, 8345, 8346, 8347, 8348, 82, 115, 97, 
-  47, 99, 97, 47, 115, 8450, 176, 67, 
-  99, 47, 111, 99, 47, 117, 8455, 176, 
-  70, 8458, 8459, 8460, 8461, 8462, 8463, 8464, 
-  8465, 8466, 8467, 8469, 78, 111, 8473, 8474, 
-  8475, 8476, 8477, 83, 77, 84, 69, 76, 
-  84, 77, 8484, 8488, 8492, 8493, 8495, 8496, 
-  8497, 8526, 8499, 8500, 1488, 1489, 1490, 1491, 
-  8505, 70, 65, 88, 8508, 8509, 8510, 8511, 
-  8721, 8517, 8518, 8519, 8520, 8521, 8498, 49, 
-  8260, 55, 49, 8260, 57, 3, 49, 8260, 
-  49, 48, 49, 8260, 51, 50, 8260, 51, 
-  49, 8260, 53, 50, 8260, 53, 51, 8260, 
-  53, 52, 8260, 53, 49, 8260, 54, 53, 
-  8260, 54, 49, 8260, 56, 51, 8260, 56, 
-  53, 8260, 56, 55, 8260, 56, 49, 8260, 
-  8560, 73, 73, 8561, 73, 73, 73, 8562, 
-  73, 86, 8563, 8564, 86, 73, 8565, 86, 
-  73, 73, 8566, 3, 86, 73, 73, 73, 
-  8567, 73, 88, 8568, 8569, 88, 73, 8570, 
-  88, 73, 73, 8571, 8572, 8573, 8574, 8575, 
-  8544, 105, 105, 8545, 105, 105, 105, 8546, 
-  105, 118, 8547, 8548, 118, 105, 8549, 118, 
-  105, 105, 8550, 3, 118, 105, 105, 105, 
-  8551, 105, 120, 8552, 8553, 120, 105, 8554, 
-  120, 105, 105, 8555, 8556, 8557, 8558, 8559, 
-  8580, 8579, 48, 8260, 51, 8592, 824, 8594, 
-  824, 8596, 824, 8656, 824, 8660, 824, 8658, 
-  824, 8707, 824, 8712, 824, 8715, 824, 8739, 
-  824, 8741, 824, 8747, 8747, 8747, 8747, 8747, 
-  8750, 8750, 8750, 8750, 8750, 8764, 824, 8771, 
-  824, 8773, 824, 8776, 824, 61, 824, 8801, 
-  824, 8781, 824, 60, 824, 62, 824, 8804, 
-  824, 8805, 824, 8818, 824, 8819, 824, 8822, 
-  824, 8823, 824, 8826, 824, 8827, 824, 8834, 
-  824, 8835, 824, 8838, 824, 8839, 824, 8866, 
-  824, 8872, 824, 8873, 824, 8875, 824, 8828, 
-  824, 8829, 824, 8849, 824, 8850, 824, 8882, 
-  824, 8883, 824, 8884, 824, 8885, 824, 12296, 
-  12297, 49, 48, 49, 49, 49, 50, 49, 
-  51, 49, 52, 49, 53, 49, 54, 49, 
-  55, 49, 56, 49, 57, 50, 48, 40, 
-  49, 41, 40, 50, 41, 40, 51, 41, 
-  40, 52, 41, 40, 53, 41, 40, 54, 
-  41, 40, 55, 41, 40, 56, 41, 40, 
-  57, 41, 3, 40, 49, 48, 41, 3, 
-  40, 49, 49, 41, 3, 40, 49, 50, 
-  41, 3, 40, 49, 51, 41, 3, 40, 
-  49, 52, 41, 3, 40, 49, 53, 41, 
-  3, 40, 49, 54, 41, 3, 40, 49, 
-  55, 41, 3, 40, 49, 56, 41, 3, 
-  40, 49, 57, 41, 3, 40, 50, 48, 
-  41, 49, 46, 50, 46, 51, 46, 52, 
-  46, 53, 46, 54, 46, 55, 46, 56, 
-  46, 57, 46, 49, 48, 46, 49, 49, 
-  46, 49, 50, 46, 49, 51, 46, 49, 
-  52, 46, 49, 53, 46, 49, 54, 46, 
-  49, 55, 46, 49, 56, 46, 49, 57, 
-  46, 50, 48, 46, 40, 97, 41, 40, 
-  98, 41, 40, 99, 41, 40, 100, 41, 
-  40, 101, 41, 40, 102, 41, 40, 103, 
-  41, 40, 104, 41, 40, 105, 41, 40, 
-  106, 41, 40, 107, 41, 40, 108, 41, 
-  40, 109, 41, 40, 110, 41, 40, 111, 
-  41, 40, 112, 41, 40, 113, 41, 40, 
-  114, 41, 40, 115, 41, 40, 116, 41, 
-  40, 117, 41, 40, 118, 41, 40, 119, 
-  41, 40, 120, 41, 40, 121, 41, 40, 
-  122, 41, 9424, 9425, 9426, 9427, 9428, 9429, 
-  9430, 9431, 9432, 9433, 9434, 9435, 9436, 9437, 
-  9438, 9439, 9440, 9441, 9442, 9443, 9444, 9445, 
-  9446, 9447, 9448, 9449, 9398, 9399, 9400, 9401, 
-  9402, 9403, 9404, 9405, 9406, 9407, 9408, 9409, 
-  9410, 9411, 9412, 9413, 9414, 9415, 9416, 9417, 
-  9418, 9419, 9420, 9421, 9422, 9423, 3, 8747, 
-  8747, 8747, 8747, 58, 58, 61, 61, 61, 
-  61, 61, 61, 10973, 824, 11312, 11313, 11314, 
-  11315, 11316, 11317, 11318, 11319, 11320, 11321, 11322, 
-  11323, 11324, 11325, 11326, 11327, 11328, 11329, 11330, 
-  11331, 11332, 11333, 11334, 11335, 11336, 11337, 11338, 
-  11339, 11340, 11341, 11342, 11343, 11344, 11345, 11346, 
-  11347, 11348, 11349, 11350, 11351, 11352, 11353, 11354, 
-  11355, 11356, 11357, 11358, 11359, 11264, 11265, 11266, 
-  11267, 11268, 11269, 11270, 11271, 11272, 11273, 11274, 
-  11275, 11276, 11277, 11278, 11279, 11280, 11281, 11282, 
-  11283, 11284, 11285, 11286, 11287, 11288, 11289, 11290, 
-  11291, 11292, 11293, 11294, 11295, 11296, 11297, 11298, 
-  11299, 11300, 11301, 11302, 11303, 11304, 11305, 11306, 
-  11307, 11308, 11309, 11310, 11311, 11361, 11360, 619, 
-  7549, 637, 570, 574, 11368, 11367, 11370, 11369, 
-  11372, 11371, 11377, 11379, 11378, 11380, 11382, 11381, 
-  11383, 11384, 11385, 11386, 11387, 11388, 11389, 575, 
-  576, 11393, 11392, 11395, 11394, 11397, 11396, 11399, 
-  11398, 11401, 11400, 11403, 11402, 11405, 11404, 11407, 
-  11406, 11409, 11408, 11411, 11410, 11413, 11412, 11415, 
-  11414, 11417, 11416, 11419, 11418, 11421, 11420, 11423, 
-  11422, 11425, 11424, 11427, 11426, 11429, 11428, 11431, 
-  11430, 11433, 11432, 11435, 11434, 11437, 11436, 11439, 
-  11438, 11441, 11440, 11443, 11442, 11445, 11444, 11447, 
-  11446, 11449, 11448, 11451, 11450, 11453, 11452, 11455, 
-  11454, 11457, 11456, 11459, 11458, 11461, 11460, 11463, 
-  11462, 11465, 11464, 11467, 11466, 11469, 11468, 11471, 
-  11470, 11473, 11472, 11475, 11474, 11477, 11476, 11479, 
-  11478, 11481, 11480, 11483, 11482, 11485, 11484, 11487, 
-  11486, 11489, 11488, 11491, 11490, 11492, 11500, 11499, 
-  11502, 11501, 11507, 11506, 4256, 4257, 4258, 4259, 
-  4260, 4261, 4262, 4263, 4264, 4265, 4266, 4267, 
-  4268, 4269, 4270, 4271, 4272, 4273, 4274, 4275, 
-  4276, 4277, 4278, 4279, 4280, 4281, 4282, 4283, 
-  4284, 4285, 4286, 4287, 4288, 4289, 4290, 4291, 
-  4292, 4293, 4295, 4301, 11617, 27597, 40863, 19968, 
-  20008, 20022, 20031, 20057, 20101, 20108, 20128, 20154, 
-  20799, 20837, 20843, 20866, 20886, 20907, 20960, 20981, 
-  20992, 21147, 21241, 21269, 21274, 21304, 21313, 21340, 
-  21353, 21378, 21430, 21448, 21475, 22231, 22303, 22763, 
-  22786, 22794, 22805, 22823, 22899, 23376, 23424, 23544, 
-  23567, 23586, 23608, 23662, 23665, 24027, 24037, 24049, 
-  24062, 24178, 24186, 24191, 24308, 24318, 24331, 24339, 
-  24400, 24417, 24435, 24515, 25096, 25142, 25163, 25903, 
-  25908, 25991, 26007, 26020, 26041, 26080, 26085, 26352, 
-  26376, 26408, 27424, 27490, 27513, 27571, 27595, 27604, 
-  27611, 27663, 27668, 27700, 28779, 29226, 29238, 29243, 
-  29247, 29255, 29273, 29275, 29356, 29572, 29577, 29916, 
-  29926, 29976, 29983, 29992, 30000, 30091, 30098, 30326, 
-  30333, 30382, 30399, 30446, 30683, 30690, 30707, 31034, 
-  31160, 31166, 31348, 31435, 31481, 31859, 31992, 32566, 
-  32593, 32650, 32701, 32769, 32780, 32786, 32819, 32895, 
-  32905, 33251, 33258, 33267, 33276, 33292, 33307, 33311, 
-  33390, 33394, 33400, 34381, 34411, 34880, 34892, 34915, 
-  35198, 35211, 35282, 35328, 35895, 35910, 35925, 35960, 
-  35997, 36196, 36208, 36275, 36523, 36554, 36763, 36784, 
-  36789, 37009, 37193, 37318, 37324, 37329, 38263, 38272, 
-  38428, 38582, 38585, 38632, 38737, 38750, 38754, 38761, 
-  38859, 38893, 38899, 38913, 39080, 39131, 39135, 39318, 
-  39321, 39340, 39592, 39640, 39647, 39717, 39727, 39730, 
-  39740, 39770, 40165, 40565, 40575, 40613, 40635, 40643, 
-  40653, 40657, 40697, 40701, 40718, 40723, 40736, 40763, 
-  40778, 40786, 40845, 40860, 40864, 12306, 21316, 21317, 
-  12363, 12441, 12365, 12441, 12367, 12441, 12369, 12441, 
-  12371, 12441, 12373, 12441, 12375, 12441, 12377, 12441, 
-  12379, 12441, 12381, 12441, 12383, 12441, 12385, 12441, 
-  12388, 12441, 12390, 12441, 12392, 12441, 12399, 12441, 
-  12399, 12442, 12402, 12441, 12402, 12442, 12405, 12441, 
-  12405, 12442, 12408, 12441, 12408, 12442, 12411, 12441, 
-  12411, 12442, 12358, 12441, 32, 12441, 32, 12442, 
-  12445, 12441, 12424, 12426, 12459, 12441, 12461, 12441, 
-  12463, 12441, 12465, 12441, 12467, 12441, 12469, 12441, 
-  12471, 12441, 12473, 12441, 12475, 12441, 12477, 12441, 
-  12479, 12441, 12481, 12441, 12484, 12441, 12486, 12441, 
-  12488, 12441, 12495, 12441, 12495, 12442, 12498, 12441, 
-  12498, 12442, 12501, 12441, 12501, 12442, 12504, 12441, 
-  12504, 12442, 12507, 12441, 12507, 12442, 12454, 12441, 
-  12527, 12441, 12528, 12441, 12529, 12441, 12530, 12441, 
-  12541, 12441, 12467, 12488, 4352, 4353, 4522, 4354, 
-  4524, 4525, 4355, 4356, 4357, 4528, 4529, 4530, 
-  4531, 4532, 4533, 4378, 4358, 4359, 4360, 4385, 
-  4361, 4362, 4363, 4364, 4365, 4366, 4367, 4368, 
-  4369, 4370, 4449, 4450, 4451, 4452, 4453, 4454, 
-  4455, 4456, 4457, 4458, 4459, 4460, 4461, 4462, 
-  4463, 4464, 4465, 4466, 4467, 4468, 4469, 4448, 
-  4372, 4373, 4551, 4552, 4556, 4558, 4563, 4567, 
-  4569, 4380, 4573, 4575, 4381, 4382, 4384, 4386, 
-  4387, 4391, 4393, 4395, 4396, 4397, 4398, 4399, 
-  4402, 4406, 4416, 4423, 4428, 4593, 4594, 4439, 
-  4440, 4441, 4484, 4485, 4488, 4497, 4498, 4500, 
-  4510, 4513, 19977, 22235, 19978, 20013, 19979, 30002, 
-  19993, 19969, 22825, 22320, 40, 4352, 41, 40, 
-  4354, 41, 40, 4355, 41, 40, 4357, 41, 
-  40, 4358, 41, 40, 4359, 41, 40, 4361, 
-  41, 40, 4363, 41, 40, 4364, 41, 40, 
-  4366, 41, 40, 4367, 41, 40, 4368, 41, 
-  40, 4369, 41, 40, 4370, 41, 3, 40, 
-  4352, 4449, 41, 3, 40, 4354, 4449, 41, 
-  3, 40, 4355, 4449, 41, 3, 40, 4357, 
-  4449, 41, 3, 40, 4358, 4449, 41, 3, 
-  40, 4359, 4449, 41, 3, 40, 4361, 4449, 
-  41, 3, 40, 4363, 4449, 41, 3, 40, 
-  4364, 4449, 41, 3, 40, 4366, 4449, 41, 
-  3, 40, 4367, 4449, 41, 3, 40, 4368, 
-  4449, 41, 3, 40, 4369, 4449, 41, 3, 
-  40, 4370, 4449, 41, 3, 40, 4364, 4462, 
-  41, 6, 40, 4363, 4457, 4364, 4453, 4523, 
-  41, 5, 40, 4363, 4457, 4370, 4462, 41, 
-  40, 19968, 41, 40, 20108, 41, 40, 19977, 
-  41, 40, 22235, 41, 40, 20116, 41, 40, 
-  20845, 41, 40, 19971, 41, 40, 20843, 41, 
-  40, 20061, 41, 40, 21313, 41, 40, 26376, 
-  41, 40, 28779, 41, 40, 27700, 41, 40, 
-  26408, 41, 40, 37329, 41, 40, 22303, 41, 
-  40, 26085, 41, 40, 26666, 41, 40, 26377, 
-  41, 40, 31038, 41, 40, 21517, 41, 40, 
-  29305, 41, 40, 36001, 41, 40, 31069, 41, 
-  40, 21172, 41, 40, 20195, 41, 40, 21628, 
-  41, 40, 23398, 41, 40, 30435, 41, 40, 
-  20225, 41, 40, 36039, 41, 40, 21332, 41, 
-  40, 31085, 41, 40, 20241, 41, 40, 33258, 
-  41, 40, 33267, 41, 21839, 24188, 31631, 80, 
-  84, 69, 50, 49, 50, 50, 50, 51, 
-  50, 52, 50, 53, 50, 54, 50, 55, 
-  50, 56, 50, 57, 51, 48, 51, 49, 
-  51, 50, 51, 51, 51, 52, 51, 53, 
-  4352, 4449, 4354, 4449, 4355, 4449, 4357, 4449, 
-  4358, 4449, 4359, 4449, 4361, 4449, 4363, 4449, 
-  4364, 4449, 4366, 4449, 4367, 4449, 4368, 4449, 
-  4369, 4449, 4370, 4449, 4, 4366, 4449, 4535, 
-  4352, 4457, 3, 4364, 4462, 4363, 4468, 4363, 
-  4462, 20116, 20845, 19971, 20061, 26666, 26377, 31038, 
-  21517, 29305, 36001, 31069, 21172, 31192, 30007, 36969, 
-  20778, 21360, 27880, 38917, 20241, 20889, 27491, 24038, 
-  21491, 21307, 23447, 23398, 30435, 20225, 36039, 21332, 
-  22812, 51, 54, 51, 55, 51, 56, 51, 
-  57, 52, 48, 52, 49, 52, 50, 52, 
-  51, 52, 52, 52, 53, 52, 54, 52, 
-  55, 52, 56, 52, 57, 53, 48, 49, 
-  26376, 50, 26376, 51, 26376, 52, 26376, 53, 
-  26376, 54, 26376, 55, 26376, 56, 26376, 57, 
-  26376, 49, 48, 26376, 49, 49, 26376, 49, 
-  50, 26376, 72, 103, 101, 114, 103, 101, 
-  86, 76, 84, 68, 12450, 12452, 12454, 12456, 
-  12458, 12459, 12461, 12463, 12465, 12467, 12469, 12471, 
-  12473, 12475, 12477, 12479, 12481, 12484, 12486, 12488, 
-  12490, 12491, 12492, 12493, 12494, 12495, 12498, 12501, 
-  12504, 12507, 12510, 12511, 12512, 12513, 12514, 12516, 
-  12518, 12520, 12521, 12522, 12523, 12524, 12525, 12527, 
-  12528, 12529, 12530, 20196, 21644, 3, 12450, 12497, 
-  12540, 12488, 3, 12450, 12523, 12501, 12449, 3, 
-  12450, 12531, 12506, 12450, 12450, 12540, 12523, 3, 
-  12452, 12491, 12531, 12464, 12452, 12531, 12481, 12454, 
-  12457, 12531, 4, 12456, 12473, 12463, 12540, 12489, 
-  3, 12456, 12540, 12459, 12540, 12458, 12531, 12473, 
-  12458, 12540, 12512, 12459, 12452, 12522, 3, 12459, 
-  12521, 12483, 12488, 3, 12459, 12525, 12522, 12540, 
-  12460, 12525, 12531, 12460, 12531, 12510, 12462, 12460, 
-  12462, 12491, 12540, 3, 12461, 12517, 12522, 12540, 
-  3, 12462, 12523, 12480, 12540, 12461, 12525, 4, 
-  12461, 12525, 12464, 12521, 12512, 5, 12461, 12525, 
-  12513, 12540, 12488, 12523, 4, 12461, 12525, 12527, 
-  12483, 12488, 12464, 12521, 12512, 4, 12464, 12521, 
-  12512, 12488, 12531, 4, 12463, 12523, 12476, 12452, 
-  12525, 3, 12463, 12525, 12540, 12493, 12465, 12540, 
-  12473, 12467, 12523, 12490, 12467, 12540, 12509, 3, 
-  12469, 12452, 12463, 12523, 4, 12469, 12531, 12481, 
-  12540, 12512, 3, 12471, 12522, 12531, 12464, 12475, 
-  12531, 12481, 12475, 12531, 12488, 12480, 12540, 12473, 
-  12487, 12471, 12489, 12523, 12488, 12531, 12490, 12494, 
-  12494, 12483, 12488, 12495, 12452, 12484, 4, 12497, 
-  12540, 12475, 12531, 12488, 12497, 12540, 12484, 3, 
-  12496, 12540, 12524, 12523, 4, 12500, 12450, 12473, 
-  12488, 12523, 12500, 12463, 12523, 12500, 12467, 12499, 
-  12523, 4, 12501, 12449, 12521, 12483, 12489, 3, 
-  12501, 12451, 12540, 12488, 4, 12502, 12483, 12471, 
-  12455, 12523, 12501, 12521, 12531, 4, 12504, 12463, 
-  12479, 12540, 12523, 12506, 12477, 12506, 12491, 12498, 
-  12504, 12523, 12484, 12506, 12531, 12473, 12506, 12540, 
-  12472, 12505, 12540, 12479, 3, 12509, 12452, 12531, 
-  12488, 12508, 12523, 12488, 12507, 12531, 12509, 12531, 
-  12489, 12507, 12540, 12523, 12507, 12540, 12531, 3, 
-  12510, 12452, 12463, 12525, 12510, 12452, 12523, 12510, 
-  12483, 12495, 12510, 12523, 12463, 4, 12510, 12531, 
-  12471, 12519, 12531, 3, 12511, 12463, 12525, 12531, 
-  12511, 12522, 4, 12511, 12522, 12496, 12540, 12523, 
-  12513, 12460, 3, 12513, 12460, 12488, 12531, 3, 
-  12513, 12540, 12488, 12523, 12516, 12540, 12489, 12516, 
-  12540, 12523, 12518, 12450, 12531, 3, 12522, 12483, 
-  12488, 12523, 12522, 12521, 12523, 12500, 12540, 3, 
-  12523, 12540, 12502, 12523, 12524, 12512, 4, 12524, 
-  12531, 12488, 12466, 12531, 12527, 12483, 12488, 48, 
-  28857, 49, 28857, 50, 28857, 51, 28857, 52, 
-  28857, 53, 28857, 54, 28857, 55, 28857, 56, 
-  28857, 57, 28857, 49, 48, 28857, 49, 49, 
-  28857, 49, 50, 28857, 49, 51, 28857, 49, 
-  52, 28857, 49, 53, 28857, 49, 54, 28857, 
-  49, 55, 28857, 49, 56, 28857, 49, 57, 
-  28857, 50, 48, 28857, 50, 49, 28857, 50, 
-  50, 28857, 50, 51, 28857, 50, 52, 28857, 
-  104, 80, 97, 100, 97, 65, 85, 98, 
-  97, 114, 111, 86, 112, 99, 100, 109, 
-  100, 109, 178, 100, 109, 179, 73, 85, 
-  24179, 25104, 26157, 21644, 22823, 27491, 26126, 27835, 
-  3, 26666, 24335, 20250, 31038, 112, 65, 110, 
-  65, 956, 65, 109, 65, 107, 65, 75, 
-  66, 77, 66, 71, 66, 99, 97, 108, 
-  3, 107, 99, 97, 108, 112, 70, 110, 
-  70, 956, 70, 956, 103, 109, 103, 107, 
-  103, 72, 122, 107, 72, 122, 77, 72, 
-  122, 71, 72, 122, 84, 72, 122, 956, 
-  8467, 109, 8467, 100, 8467, 107, 8467, 102, 
-  109, 110, 109, 956, 109, 109, 109, 99, 
-  109, 107, 109, 109, 109, 178, 99, 109, 
-  178, 109, 178, 107, 109, 178, 109, 109, 
-  179, 99, 109, 179, 109, 179, 107, 109, 
-  179, 109, 8725, 115, 3, 109, 8725, 115, 
-  178, 80, 97, 107, 80, 97, 77, 80, 
-  97, 71, 80, 97, 114, 97, 100, 4, 
-  114, 97, 100, 8725, 115, 5, 114, 97, 
-  100, 8725, 115, 178, 112, 115, 110, 115, 
-  956, 115, 109, 115, 112, 86, 110, 86, 
-  956, 86, 109, 86, 107, 86, 77, 86, 
-  112, 87, 110, 87, 956, 87, 109, 87, 
-  107, 87, 77, 87, 107, 937, 77, 937, 
-  3, 97, 46, 109, 46, 66, 113, 99, 
-  99, 99, 100, 3, 67, 8725, 107, 103, 
-  67, 111, 46, 100, 66, 71, 121, 104, 
-  97, 72, 80, 105, 110, 75, 75, 75, 
-  77, 107, 116, 108, 109, 108, 110, 108, 
-  111, 103, 108, 120, 109, 98, 109, 105, 
-  108, 109, 111, 108, 80, 72, 3, 112, 
-  46, 109, 46, 80, 80, 77, 80, 82, 
-  115, 114, 83, 118, 87, 98, 86, 8725, 
-  109, 65, 8725, 109, 49, 26085, 50, 26085, 
-  51, 26085, 52, 26085, 53, 26085, 54, 26085, 
-  55, 26085, 56, 26085, 57, 26085, 49, 48, 
-  26085, 49, 49, 26085, 49, 50, 26085, 49, 
-  51, 26085, 49, 52, 26085, 49, 53, 26085, 
-  49, 54, 26085, 49, 55, 26085, 49, 56, 
-  26085, 49, 57, 26085, 50, 48, 26085, 50, 
-  49, 26085, 50, 50, 26085, 50, 51, 26085, 
-  50, 52, 26085, 50, 53, 26085, 50, 54, 
-  26085, 50, 55, 26085, 50, 56, 26085, 50, 
-  57, 26085, 51, 48, 26085, 51, 49, 26085, 
-  103, 97, 108, 42561, 42560, 42563, 42562, 42565, 
-  42564, 42567, 42566, 42569, 42568, 42573, 42572, 42575, 
-  42574, 42577, 42576, 42579, 42578, 42581, 42580, 42583, 
-  42582, 42585, 42584, 42587, 42586, 42589, 42588, 42591, 
-  42590, 42593, 42592, 42595, 42594, 42597, 42596, 42599, 
-  42598, 42601, 42600, 42603, 42602, 42605, 42604, 42625, 
-  42624, 42627, 42626, 42629, 42628, 42631, 42630, 42633, 
-  42632, 42635, 42634, 42637, 42636, 42639, 42638, 42641, 
-  42640, 42643, 42642, 42645, 42644, 42647, 42646, 42649, 
-  42648, 42651, 42650, 42652, 42653, 42787, 42786, 42789, 
-  42788, 42791, 42790, 42793, 42792, 42795, 42794, 42797, 
-  42796, 42799, 42798, 42800, 42801, 42803, 42802, 42805, 
-  42804, 42807, 42806, 42809, 42808, 42811, 42810, 42813, 
-  42812, 42815, 42814, 42817, 42816, 42819, 42818, 42821, 
-  42820, 42823, 42822, 42825, 42824, 42827, 42826, 42829, 
-  42828, 42831, 42830, 42833, 42832, 42835, 42834, 42837, 
-  42836, 42839, 42838, 42841, 42840, 42843, 42842, 42845, 
-  42844, 42847, 42846, 42849, 42848, 42851, 42850, 42853, 
-  42852, 42855, 42854, 42857, 42856, 42859, 42858, 42861, 
-  42860, 42863, 42862, 42864, 42865, 42866, 42867, 42868, 
-  42869, 42870, 42871, 42872, 42874, 42873, 42876, 42875, 
-  7545, 42879, 42878, 42881, 42880, 42883, 42882, 42885, 
-  42884, 42887, 42886, 42892, 42891, 42894, 42897, 42896, 
-  42899, 42898, 42948, 42901, 42903, 42902, 42905, 42904, 
-  42907, 42906, 42909, 42908, 42911, 42910, 42913, 42912, 
-  42915, 42914, 42917, 42916, 42919, 42918, 42921, 42920, 
-  620, 42927, 670, 647, 43859, 42933, 42932, 42935, 
-  42934, 42937, 42936, 42939, 42938, 42941, 42940, 42943, 
-  42942, 42945, 42944, 42947, 42946, 42900, 7566, 42952, 
-  42951, 42954, 42953, 42961, 42960, 42963, 42965, 42967, 
-  42966, 42969, 42968, 42994, 42995, 42996, 42998, 42997, 
-  43000, 43001, 43002, 43824, 43825, 43826, 43827, 43828, 
-  43829, 43830, 43831, 43832, 43833, 43834, 43835, 43836, 
-  43837, 43838, 43839, 43840, 43841, 43842, 43843, 43844, 
-  43845, 43846, 43847, 43848, 43849, 43850, 43851, 43852, 
-  43853, 43854, 43855, 43856, 43857, 43858, 42931, 43860, 
-  43861, 43862, 43863, 43864, 43865, 43866, 43868, 43869, 
-  43870, 43871, 43872, 43873, 43874, 43875, 43876, 43877, 
-  43878, 43879, 43880, 43881, 5024, 5025, 5026, 5027, 
-  5028, 5029, 5030, 5031, 5032, 5033, 5034, 5035, 
-  5036, 5037, 5038, 5039, 5040, 5041, 5042, 5043, 
-  5044, 5045, 5046, 5047, 5048, 5049, 5050, 5051, 
-  5052, 5053, 5054, 5055, 5056, 5057, 5058, 5059, 
-  5060, 5061, 5062, 5063, 5064, 5065, 5066, 5067, 
-  5068, 5069, 5070, 5071, 5072, 5073, 5074, 5075, 
-  5076, 5077, 5078, 5079, 5080, 5081, 5082, 5083, 
-  5084, 5085, 5086, 5087, 5088, 5089, 5090, 5091, 
-  5092, 5093, 5094, 5095, 5096, 5097, 5098, 5099, 
-  5100, 5101, 5102, 5103, 35912, 26356, 36040, 28369, 
-  20018, 21477, 22865, 21895, 22856, 25078, 30313, 32645, 
-  34367, 34746, 35064, 37007, 27138, 27931, 28889, 29662, 
-  33853, 37226, 39409, 20098, 21365, 27396, 29211, 34349, 
-  40478, 23888, 28651, 34253, 35172, 25289, 33240, 34847, 
-  24266, 26391, 28010, 29436, 37070, 20358, 20919, 21214, 
-  25796, 27347, 29200, 30439, 34310, 34396, 36335, 38706, 
-  39791, 40442, 30860, 31103, 32160, 33737, 37636, 35542, 
-  22751, 24324, 31840, 32894, 29282, 30922, 36034, 38647, 
-  22744, 23650, 27155, 28122, 28431, 32047, 32311, 38475, 
-  21202, 32907, 20956, 20940, 31260, 32190, 33777, 38517, 
-  35712, 25295, 35582, 20025, 23527, 24594, 29575, 30064, 
-  21271, 30971, 20415, 24489, 19981, 27852, 25976, 32034, 
-  21443, 22622, 30465, 33865, 35498, 27578, 27784, 25342, 
-  33509, 25504, 30053, 20142, 20841, 20937, 26753, 31975, 
-  33391, 35538, 37327, 21237, 21570, 24300, 26053, 28670, 
-  31018, 38317, 39530, 40599, 40654, 26310, 27511, 36706, 
-  24180, 24976, 25088, 25754, 28451, 29001, 29833, 31178, 
-  32244, 32879, 36646, 34030, 36899, 37706, 21015, 21155, 
-  21693, 28872, 35010, 24265, 24565, 25467, 27566, 31806, 
-  29557, 20196, 22265, 23994, 24604, 29618, 29801, 32666, 
-  32838, 37428, 38646, 38728, 38936, 20363, 31150, 37300, 
-  38584, 24801, 20102, 20698, 23534, 23615, 26009, 29134, 
-  30274, 34044, 36988, 26248, 38446, 21129, 26491, 26611, 
-  27969, 28316, 29705, 30041, 30827, 32016, 39006, 25134, 
-  38520, 20523, 23833, 28138, 36650, 24459, 24900, 26647, 
-  38534, 21033, 21519, 23653, 26131, 26446, 26792, 27877, 
-  29702, 30178, 32633, 35023, 35041, 38626, 21311, 28346, 
-  21533, 29136, 29848, 34298, 38563, 40023, 40607, 26519, 
-  28107, 33256, 31520, 31890, 29376, 28825, 35672, 20160, 
-  33590, 21050, 20999, 24230, 25299, 31958, 23429, 27934, 
-  26292, 36667, 38477, 24275, 20800, 21952, 22618, 26228, 
-  20958, 29482, 30410, 31036, 31070, 31077, 31119, 38742, 
-  31934, 34322, 35576, 36920, 37117, 39151, 39164, 39208, 
-  40372, 37086, 38583, 20398, 20711, 20813, 21193, 21220, 
-  21329, 21917, 22022, 22120, 22592, 22696, 23652, 24724, 
-  24936, 24974, 25074, 25935, 26082, 26257, 26757, 28023, 
-  28186, 28450, 29038, 29227, 29730, 30865, 31049, 31048, 
-  31056, 31062, 31117, 31118, 31296, 31361, 31680, 32265, 
-  32321, 32626, 32773, 33261, 33401, 33879, 35088, 35222, 
-  35585, 35641, 36051, 36104, 36790, 38627, 38911, 38971, 
-  24693, 55376, 57070, 33304, 20006, 20917, 20840, 20352, 
-  20805, 20864, 21191, 21242, 21845, 21913, 21986, 22707, 
-  22852, 22868, 23138, 23336, 24274, 24281, 24425, 24493, 
-  24792, 24910, 24840, 24928, 25140, 25540, 25628, 25682, 
-  25942, 26395, 26454, 28379, 28363, 28702, 30631, 29237, 
-  29359, 29809, 29958, 30011, 30237, 30239, 30427, 30452, 
-  30538, 30528, 30924, 31409, 31867, 32091, 32574, 33618, 
-  33775, 34681, 35137, 35206, 35519, 35531, 35565, 35722, 
-  36664, 36978, 37273, 37494, 38524, 38875, 38923, 39698, 
-  55370, 56394, 55370, 56388, 55372, 57301, 15261, 16408, 
-  16441, 55380, 56905, 55383, 56528, 55391, 57043, 40771, 
-  40846, 102, 102, 64256, 102, 105, 64257, 102, 
-  108, 64258, 102, 102, 105, 64259, 102, 102, 
-  108, 64260, 383, 116, 115, 116, 64261, 64262, 
-  1396, 1398, 64275, 1396, 1381, 64276, 1396, 1387, 
-  64277, 1406, 1398, 64278, 1396, 1389, 64279, 1497, 
-  1460, 1522, 1463, 1506, 1492, 1499, 1500, 1501, 
-  1512, 1514, 1513, 1473, 1513, 1474, 64329, 1473, 
-  64329, 1474, 1488, 1463, 1488, 1464, 1488, 1468, 
-  1489, 1468, 1490, 1468, 1491, 1468, 1492, 1468, 
-  1493, 1468, 1494, 1468, 1496, 1468, 1497, 1468, 
-  1498, 1468, 1499, 1468, 1500, 1468, 1502, 1468, 
-  1504, 1468, 1505, 1468, 1507, 1468, 1508, 1468, 
-  1510, 1468, 1511, 1468, 1512, 1468, 1513, 1468, 
-  1514, 1468, 1493, 1465, 1489, 1471, 1499, 1471, 
-  1508, 1471, 1488, 1500, 1649, 1659, 1662, 1664, 
-  1658, 1663, 1657, 1700, 1702, 1668, 1667, 1670, 
-  1671, 1677, 1676, 1678, 1672, 1688, 1681, 1705, 
-  1711, 1715, 1713, 1722, 1723, 1728, 1729, 1726, 
-  1746, 1747, 1709, 1735, 1734, 1736, 1655, 1739, 
-  1733, 1737, 1744, 1609, 1574, 1575, 1574, 1749, 
-  1574, 1608, 1574, 1735, 1574, 1734, 1574, 1736, 
-  1574, 1744, 1574, 1609, 1740, 1574, 1580, 1574, 
-  1581, 1574, 1605, 1574, 1610, 1576, 1580, 1576, 
-  1581, 1576, 1582, 1576, 1605, 1576, 1609, 1576, 
-  1610, 1578, 1580, 1578, 1581, 1578, 1582, 1578, 
-  1605, 1578, 1609, 1578, 1610, 1579, 1580, 1579, 
-  1605, 1579, 1609, 1579, 1610, 1580, 1581, 1580, 
-  1605, 1581, 1580, 1581, 1605, 1582, 1580, 1582, 
-  1581, 1582, 1605, 1587, 1580, 1587, 1581, 1587, 
-  1582, 1587, 1605, 1589, 1581, 1589, 1605, 1590, 
-  1580, 1590, 1581, 1590, 1582, 1590, 1605, 1591, 
-  1581, 1591, 1605, 1592, 1605, 1593, 1580, 1593, 
-  1605, 1594, 1580, 1594, 1605, 1601, 1580, 1601, 
-  1581, 1601, 1582, 1601, 1605, 1601, 1609, 1601, 
-  1610, 1602, 1581, 1602, 1605, 1602, 1609, 1602, 
-  1610, 1603, 1575, 1603, 1580, 1603, 1581, 1603, 
-  1582, 1603, 1604, 1603, 1605, 1603, 1609, 1603, 
-  1610, 1604, 1580, 1604, 1581, 1604, 1582, 1604, 
-  1605, 1604, 1609, 1604, 1610, 1605, 1580, 1605, 
-  1581, 1605, 1582, 1605, 1605, 1605, 1609, 1605, 
-  1610, 1606, 1580, 1606, 1581, 1606, 1582, 1606, 
-  1605, 1606, 1609, 1606, 1610, 1607, 1580, 1607, 
-  1605, 1607, 1609, 1607, 1610, 1610, 1580, 1610, 
-  1581, 1610, 1582, 1610, 1605, 1610, 1609, 1610, 
-  1610, 1584, 1648, 1585, 1648, 1609, 1648, 32, 
-  1612, 1617, 32, 1613, 1617, 32, 1614, 1617, 
-  32, 1615, 1617, 32, 1616, 1617, 32, 1617, 
-  1648, 1574, 1585, 1574, 1586, 1574, 1606, 1576, 
-  1585, 1576, 1586, 1576, 1606, 1578, 1585, 1578, 
-  1586, 1578, 1606, 1579, 1585, 1579, 1586, 1579, 
-  1606, 1605, 1575, 1606, 1585, 1606, 1586, 1606, 
-  1606, 1610, 1585, 1610, 1586, 1610, 1606, 1574, 
-  1582, 1574, 1607, 1576, 1607, 1578, 1607, 1589, 
-  1582, 1604, 1607, 1606, 1607, 1607, 1648, 1610, 
-  1607, 1579, 1607, 1587, 1607, 1588, 1605, 1588, 
-  1607, 1600, 1614, 1617, 1600, 1615, 1617, 1600, 
-  1616, 1617, 1591, 1609, 1591, 1610, 1593, 1609, 
-  1593, 1610, 1594, 1609, 1594, 1610, 1587, 1609, 
-  1587, 1610, 1588, 1609, 1588, 1610, 1581, 1609, 
-  1581, 1610, 1580, 1609, 1580, 1610, 1582, 1609, 
-  1582, 1610, 1589, 1609, 1589, 1610, 1590, 1609, 
-  1590, 1610, 1588, 1580, 1588, 1581, 1588, 1582, 
-  1588, 1585, 1587, 1585, 1589, 1585, 1590, 1585, 
-  1575, 1611, 1578, 1580, 1605, 1578, 1581, 1580, 
-  1578, 1581, 1605, 1578, 1582, 1605, 1578, 1605, 
-  1580, 1578, 1605, 1581, 1578, 1605, 1582, 1580, 
-  1605, 1581, 1581, 1605, 1610, 1581, 1605, 1609, 
-  1587, 1581, 1580, 1587, 1580, 1581, 1587, 1580, 
-  1609, 1587, 1605, 1581, 1587, 1605, 1580, 1587, 
-  1605, 1605, 1589, 1581, 1581, 1589, 1605, 1605, 
-  1588, 1581, 1605, 1588, 1580, 1610, 1588, 1605, 
-  1582, 1588, 1605, 1605, 1590, 1581, 1609, 1590, 
-  1582, 1605, 1591, 1605, 1581, 1591, 1605, 1605, 
-  1591, 1605, 1610, 1593, 1580, 1605, 1593, 1605, 
-  1605, 1593, 1605, 1609, 1594, 1605, 1605, 1594, 
-  1605, 1610, 1594, 1605, 1609, 1601, 1582, 1605, 
-  1602, 1605, 1581, 1602, 1605, 1605, 1604, 1581, 
-  1605, 1604, 1581, 1610, 1604, 1581, 1609, 1604, 
-  1580, 1580, 1604, 1582, 1605, 1604, 1605, 1581, 
-  1605, 1581, 1580, 1605, 1581, 1605, 1605, 1581, 
-  1610, 1605, 1580, 1581, 1605, 1580, 1605, 1605, 
-  1582, 1580, 1605, 1582, 1605, 1605, 1580, 1582, 
-  1607, 1605, 1580, 1607, 1605, 1605, 1606, 1581, 
-  1605, 1606, 1581, 1609, 1606, 1580, 1605, 1606, 
-  1580, 1609, 1606, 1605, 1610, 1606, 1605, 1609, 
-  1610, 1605, 1605, 1576, 1582, 1610, 1578, 1580, 
-  1610, 1578, 1580, 1609, 1578, 1582, 1610, 1578, 
-  1582, 1609, 1578, 1605, 1610, 1578, 1605, 1609, 
-  1580, 1605, 1610, 1580, 1581, 1609, 1580, 1605, 
-  1609, 1587, 1582, 1609, 1589, 1581, 1610, 1588, 
-  1581, 1610, 1590, 1581, 1610, 1604, 1580, 1610, 
-  1604, 1605, 1610, 1610, 1581, 1610, 1610, 1580, 
-  1610, 1610, 1605, 1610, 1605, 1605, 1610, 1602, 
-  1605, 1610, 1606, 1581, 1610, 1593, 1605, 1610, 
-  1603, 1605, 1610, 1606, 1580, 1581, 1605, 1582, 
-  1610, 1604, 1580, 1605, 1603, 1605, 1605, 1580, 
-  1581, 1610, 1581, 1580, 1610, 1605, 1580, 1610, 
-  1601, 1605, 1610, 1576, 1581, 1610, 1587, 1582, 
-  1610, 1606, 1580, 1610, 1589, 1604, 1746, 1602, 
-  1604, 1746, 3, 1575, 1604, 1604, 1607, 3, 
-  1575, 1603, 1576, 1585, 3, 1605, 1581, 1605, 
-  1583, 3, 1589, 1604, 1593, 1605, 3, 1585, 
-  1587, 1608, 1604, 3, 1593, 1604, 1610, 1607, 
-  3, 1608, 1587, 1604, 1605, 1589, 1604, 1609, 
-  17, 1589, 1604, 1609, 32, 1575, 1604, 1604, 
-  1607, 32, 1593, 1604, 1610, 1607, 32, 1608, 
-  1587, 1604, 1605, 7, 1580, 1604, 32, 1580, 
-  1604, 1575, 1604, 1607, 3, 1585, 1740, 1575, 
-  1604, 44, 12289, 12290, 58, 33, 63, 12310, 
-  12311, 8230, 8229, 8212, 8211, 95, 123, 125, 
-  12308, 12309, 12304, 12305, 12298, 12299, 12300, 12301, 
-  12302, 12303, 91, 93, 8254, 35, 38, 42, 
-  45, 60, 62, 92, 36, 37, 64, 32, 
-  1611, 1600, 1611, 32, 1612, 32, 1613, 32, 
-  1614, 1600, 1614, 32, 1615, 1600, 1615, 32, 
-  1616, 1600, 1616, 32, 1617, 1600, 1617, 32, 
-  1618, 1600, 1618, 1569, 1570, 1571, 1572, 1573, 
-  1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 
-  1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 
-  1590, 1591, 1592, 1593, 1594, 1601, 1602, 1603, 
-  1604, 1605, 1606, 1607, 1608, 1610, 1604, 1570, 
-  1604, 1571, 1604, 1573, 1604, 1575, 34, 39, 
-  47, 65345, 65346, 65347, 65348, 65349, 65350, 65351, 
-  65352, 65353, 65354, 65355, 65356, 65357, 65358, 65359, 
-  65360, 65361, 65362, 65363, 65364, 65365, 65366, 65367, 
-  65368, 65369, 65370, 94, 65313, 65314, 65315, 65316, 
-  65317, 65318, 65319, 65320, 65321, 65322, 65323, 65324, 
-  65325, 65326, 65327, 65328, 65329, 65330, 65331, 65332, 
-  65333, 65334, 65335, 65336, 65337, 65338, 124, 126, 
-  10629, 10630, 12539, 12449, 12451, 12453, 12455, 12457, 
-  12515, 12517, 12519, 12483, 12540, 12531, 12441, 12442, 
-  12644, 12593, 12594, 12595, 12596, 12597, 12598, 12599, 
-  12600, 12601, 12602, 12603, 12604, 12605, 12606, 12607, 
-  12608, 12609, 12610, 12611, 12612, 12613, 12614, 12615, 
-  12616, 12617, 12618, 12619, 12620, 12621, 12622, 12623, 
-  12624, 12625, 12626, 12627, 12628, 12629, 12630, 12631, 
-  12632, 12633, 12634, 12635, 12636, 12637, 12638, 12639, 
-  12640, 12641, 12642, 12643, 162, 163, 172, 175, 
-  166, 165, 8361, 9474, 8592, 8593, 8594, 8595, 
-  9632, 9675, 55297, 56360, 55297, 56361, 55297, 56362, 
-  55297, 56363, 55297, 56364, 55297, 56365, 55297, 56366, 
-  55297, 56367, 55297, 56368, 55297, 56369, 55297, 56370, 
-  55297, 56371, 55297, 56372, 55297, 56373, 55297, 56374, 
-  55297, 56375, 55297, 56376, 55297, 56377, 55297, 56378, 
-  55297, 56379, 55297, 56380, 55297, 56381, 55297, 56382, 
-  55297, 56383, 55297, 56384, 55297, 56385, 55297, 56386, 
-  55297, 56387, 55297, 56388, 55297, 56389, 55297, 56390, 
-  55297, 56391, 55297, 56392, 55297, 56393, 55297, 56394, 
-  55297, 56395, 55297, 56396, 55297, 56397, 55297, 56398, 
-  55297, 56399, 55297, 56320, 55297, 56321, 55297, 56322, 
-  55297, 56323, 55297, 56324, 55297, 56325, 55297, 56326, 
-  55297, 56327, 55297, 56328, 55297, 56329, 55297, 56330, 
-  55297, 56331, 55297, 56332, 55297, 56333, 55297, 56334, 
-  55297, 56335, 55297, 56336, 55297, 56337, 55297, 56338, 
-  55297, 56339, 55297, 56340, 55297, 56341, 55297, 56342, 
-  55297, 56343, 55297, 56344, 55297, 56345, 55297, 56346, 
-  55297, 56347, 55297, 56348, 55297, 56349, 55297, 56350, 
-  55297, 56351, 55297, 56352, 55297, 56353, 55297, 56354, 
-  55297, 56355, 55297, 56356, 55297, 56357, 55297, 56358, 
-  55297, 56359, 55297, 56536, 55297, 56537, 55297, 56538, 
-  55297, 56539, 55297, 56540, 55297, 56541, 55297, 56542, 
-  55297, 56543, 55297, 56544, 55297, 56545, 55297, 56546, 
-  55297, 56547, 55297, 56548, 55297, 56549, 55297, 56550, 
-  55297, 56551, 55297, 56552, 55297, 56553, 55297, 56554, 
-  55297, 56555, 55297, 56556, 55297, 56557, 55297, 56558, 
-  55297, 56559, 55297, 56560, 55297, 56561, 55297, 56562, 
-  55297, 56563, 55297, 56564, 55297, 56565, 55297, 56566, 
-  55297, 56567, 55297, 56568, 55297, 56569, 55297, 56570, 
-  55297, 56571, 55297, 56496, 55297, 56497, 55297, 56498, 
-  55297, 56499, 55297, 56500, 55297, 56501, 55297, 56502, 
-  55297, 56503, 55297, 56504, 55297, 56505, 55297, 56506, 
-  55297, 56507, 55297, 56508, 55297, 56509, 55297, 56510, 
-  55297, 56511, 55297, 56512, 55297, 56513, 55297, 56514, 
-  55297, 56515, 55297, 56516, 55297, 56517, 55297, 56518, 
-  55297, 56519, 55297, 56520, 55297, 56521, 55297, 56522, 
-  55297, 56523, 55297, 56524, 55297, 56525, 55297, 56526, 
-  55297, 56527, 55297, 56528, 55297, 56529, 55297, 56530, 
-  55297, 56531, 55297, 56727, 55297, 56728, 55297, 56729, 
-  55297, 56730, 55297, 56731, 55297, 56732, 55297, 56733, 
-  55297, 56734, 55297, 56735, 55297, 56736, 55297, 56737, 
-  55297, 56739, 55297, 56740, 55297, 56741, 55297, 56742, 
-  55297, 56743, 55297, 56744, 55297, 56745, 55297, 56746, 
-  55297, 56747, 55297, 56748, 55297, 56749, 55297, 56750, 
-  55297, 56751, 55297, 56752, 55297, 56753, 55297, 56755, 
-  55297, 56756, 55297, 56757, 55297, 56758, 55297, 56759, 
-  55297, 56760, 55297, 56761, 55297, 56763, 55297, 56764, 
-  55297, 56688, 55297, 56689, 55297, 56690, 55297, 56691, 
-  55297, 56692, 55297, 56693, 55297, 56694, 55297, 56695, 
-  55297, 56696, 55297, 56697, 55297, 56698, 55297, 56700, 
-  55297, 56701, 55297, 56702, 55297, 56703, 55297, 56704, 
-  55297, 56705, 55297, 56706, 55297, 56707, 55297, 56708, 
-  55297, 56709, 55297, 56710, 55297, 56711, 55297, 56712, 
-  55297, 56713, 55297, 56714, 55297, 56716, 55297, 56717, 
-  55297, 56718, 55297, 56719, 55297, 56720, 55297, 56721, 
-  55297, 56722, 55297, 56724, 55297, 56725, 55297, 57216, 
-  720, 721, 55297, 57219, 55297, 57220, 55297, 57221, 
-  55297, 57223, 55297, 57224, 55297, 57225, 55297, 57226, 
-  55297, 57227, 55297, 57228, 55297, 57229, 55297, 57230, 
-  55297, 57231, 55297, 57232, 55297, 57233, 55297, 57234, 
-  55297, 57235, 55297, 57236, 55297, 57237, 55297, 57238, 
-  55297, 57239, 55297, 57240, 55297, 57241, 55297, 57242, 
-  55297, 57243, 55351, 57092, 55297, 57244, 55297, 57245, 
-  55297, 57246, 55351, 57093, 55297, 57247, 55297, 57248, 
-  55351, 57094, 55297, 57249, 55297, 57250, 55297, 57251, 
-  55297, 57252, 55297, 57253, 55297, 57254, 55351, 57096, 
-  55297, 57255, 55297, 57256, 55297, 57257, 55297, 57258, 
-  55297, 57259, 55297, 57260, 55297, 57261, 55297, 57262, 
-  55297, 57263, 55297, 57264, 55297, 57266, 55297, 57267, 
-  55297, 57268, 55297, 57269, 448, 55297, 57270, 449, 
-  55297, 57271, 450, 55297, 57272, 55351, 57098, 55297, 
-  57273, 55351, 57118, 55297, 57274, 55299, 56512, 55299, 
-  56513, 55299, 56514, 55299, 56515, 55299, 56516, 55299, 
-  56517, 55299, 56518, 55299, 56519, 55299, 56520, 55299, 
-  56521, 55299, 56522, 55299, 56523, 55299, 56524, 55299, 
-  56525, 55299, 56526, 55299, 56527, 55299, 56528, 55299, 
-  56529, 55299, 56530, 55299, 56531, 55299, 56532, 55299, 
-  56533, 55299, 56534, 55299, 56535, 55299, 56536, 55299, 
-  56537, 55299, 56538, 55299, 56539, 55299, 56540, 55299, 
-  56541, 55299, 56542, 55299, 56543, 55299, 56544, 55299, 
-  56545, 55299, 56546, 55299, 56547, 55299, 56548, 55299, 
-  56549, 55299, 56550, 55299, 56551, 55299, 56552, 55299, 
-  56553, 55299, 56554, 55299, 56555, 55299, 56556, 55299, 
-  56557, 55299, 56558, 55299, 56559, 55299, 56560, 55299, 
-  56561, 55299, 56562, 55299, 56448, 55299, 56449, 55299, 
-  56450, 55299, 56451, 55299, 56452, 55299, 56453, 55299, 
-  56454, 55299, 56455, 55299, 56456, 55299, 56457, 55299, 
-  56458, 55299, 56459, 55299, 56460, 55299, 56461, 55299, 
-  56462, 55299, 56463, 55299, 56464, 55299, 56465, 55299, 
-  56466, 55299, 56467, 55299, 56468, 55299, 56469, 55299, 
-  56470, 55299, 56471, 55299, 56472, 55299, 56473, 55299, 
-  56474, 55299, 56475, 55299, 56476, 55299, 56477, 55299, 
-  56478, 55299, 56479, 55299, 56480, 55299, 56481, 55299, 
-  56482, 55299, 56483, 55299, 56484, 55299, 56485, 55299, 
-  56486, 55299, 56487, 55299, 56488, 55299, 56489, 55299, 
-  56490, 55299, 56491, 55299, 56492, 55299, 56493, 55299, 
-  56494, 55299, 56495, 55299, 56496, 55299, 56497, 55299, 
-  56498, 55300, 56473, 55300, 56506, 55300, 56475, 55300, 
-  56506, 55300, 56485, 55300, 56506, 55300, 56625, 55300, 
-  56615, 55300, 56626, 55300, 56615, 55300, 57159, 55300, 
-  57150, 55300, 57159, 55300, 57175, 55301, 56505, 55301, 
-  56506, 55301, 56505, 55301, 56496, 55301, 56505, 55301, 
-  56509, 55301, 56760, 55301, 56751, 55301, 56761, 55301, 
-  56751, 55302, 56512, 55302, 56513, 55302, 56514, 55302, 
-  56515, 55302, 56516, 55302, 56517, 55302, 56518, 55302, 
-  56519, 55302, 56520, 55302, 56521, 55302, 56522, 55302, 
-  56523, 55302, 56524, 55302, 56525, 55302, 56526, 55302, 
-  56527, 55302, 56528, 55302, 56529, 55302, 56530, 55302, 
-  56531, 55302, 56532, 55302, 56533, 55302, 56534, 55302, 
-  56535, 55302, 56536, 55302, 56537, 55302, 56538, 55302, 
-  56539, 55302, 56540, 55302, 56541, 55302, 56542, 55302, 
-  56543, 55302, 56480, 55302, 56481, 55302, 56482, 55302, 
-  56483, 55302, 56484, 55302, 56485, 55302, 56486, 55302, 
-  56487, 55302, 56488, 55302, 56489, 55302, 56490, 55302, 
-  56491, 55302, 56492, 55302, 56493, 55302, 56494, 55302, 
-  56495, 55302, 56496, 55302, 56497, 55302, 56498, 55302, 
-  56499, 55302, 56500, 55302, 56501, 55302, 56502, 55302, 
-  56503, 55302, 56504, 55302, 56505, 55302, 56506, 55302, 
-  56507, 55302, 56508, 55302, 56509, 55302, 56510, 55302, 
-  56511, 55302, 56629, 55302, 56624, 55323, 56928, 55323, 
-  56929, 55323, 56930, 55323, 56931, 55323, 56932, 55323, 
-  56933, 55323, 56934, 55323, 56935, 55323, 56936, 55323, 
-  56937, 55323, 56938, 55323, 56939, 55323, 56940, 55323, 
-  56941, 55323, 56942, 55323, 56943, 55323, 56944, 55323, 
-  56945, 55323, 56946, 55323, 56947, 55323, 56948, 55323, 
-  56949, 55323, 56950, 55323, 56951, 55323, 56952, 55323, 
-  56953, 55323, 56954, 55323, 56955, 55323, 56956, 55323, 
-  56957, 55323, 56958, 55323, 56959, 55323, 56896, 55323, 
-  56897, 55323, 56898, 55323, 56899, 55323, 56900, 55323, 
-  56901, 55323, 56902, 55323, 56903, 55323, 56904, 55323, 
-  56905, 55323, 56906, 55323, 56907, 55323, 56908, 55323, 
-  56909, 55323, 56910, 55323, 56911, 55323, 56912, 55323, 
-  56913, 55323, 56914, 55323, 56915, 55323, 56916, 55323, 
-  56917, 55323, 56918, 55323, 56919, 55323, 56920, 55323, 
-  56921, 55323, 56922, 55323, 56923, 55323, 56924, 55323, 
-  56925, 55323, 56926, 55323, 56927, 55348, 56663, 55348, 
-  56677, 55348, 56664, 55348, 56677, 55348, 56671, 55348, 
-  56686, 55348, 56671, 55348, 56687, 55348, 56671, 55348, 
-  56688, 55348, 56671, 55348, 56689, 55348, 56671, 55348, 
-  56690, 55348, 56761, 55348, 56677, 55348, 56762, 55348, 
-  56677, 55348, 56763, 55348, 56686, 55348, 56764, 55348, 
-  56686, 55348, 56763, 55348, 56687, 55348, 56764, 55348, 
-  56687, 55349, 56320, 55349, 56321, 55349, 56322, 55349, 
-  56323, 55349, 56324, 55349, 56325, 55349, 56326, 55349, 
-  56327, 55349, 56328, 55349, 56329, 55349, 56330, 55349, 
-  56331, 55349, 56332, 55349, 56333, 55349, 56334, 55349, 
-  56335, 55349, 56336, 55349, 56337, 55349, 56338, 55349, 
-  56339, 55349, 56340, 55349, 56341, 55349, 56342, 55349, 
-  56343, 55349, 56344, 55349, 56345, 55349, 56346, 55349, 
-  56347, 55349, 56348, 55349, 56349, 55349, 56350, 55349, 
-  56351, 55349, 56352, 55349, 56353, 55349, 56354, 55349, 
-  56355, 55349, 56356, 55349, 56357, 55349, 56358, 55349, 
-  56359, 55349, 56360, 55349, 56361, 55349, 56362, 55349, 
-  56363, 55349, 56364, 55349, 56365, 55349, 56366, 55349, 
-  56367, 55349, 56368, 55349, 56369, 55349, 56370, 55349, 
-  56371, 55349, 56372, 55349, 56373, 55349, 56374, 55349, 
-  56375, 55349, 56376, 55349, 56377, 55349, 56378, 55349, 
-  56379, 55349, 56380, 55349, 56381, 55349, 56382, 55349, 
-  56383, 55349, 56384, 55349, 56385, 55349, 56386, 55349, 
-  56387, 55349, 56388, 55349, 56389, 55349, 56390, 55349, 
-  56391, 55349, 56392, 55349, 56393, 55349, 56394, 55349, 
-  56395, 55349, 56396, 55349, 56397, 55349, 56398, 55349, 
-  56399, 55349, 56400, 55349, 56401, 55349, 56402, 55349, 
-  56403, 55349, 56404, 55349, 56406, 55349, 56407, 55349, 
-  56408, 55349, 56409, 55349, 56410, 55349, 56411, 55349, 
-  56412, 55349, 56413, 55349, 56414, 55349, 56415, 55349, 
-  56416, 55349, 56417, 55349, 56418, 55349, 56419, 55349, 
-  56420, 55349, 56421, 55349, 56422, 55349, 56423, 55349, 
-  56424, 55349, 56425, 55349, 56426, 55349, 56427, 55349, 
-  56428, 55349, 56429, 55349, 56430, 55349, 56431, 55349, 
-  56432, 55349, 56433, 55349, 56434, 55349, 56435, 55349, 
-  56436, 55349, 56437, 55349, 56438, 55349, 56439, 55349, 
-  56440, 55349, 56441, 55349, 56442, 55349, 56443, 55349, 
-  56444, 55349, 56445, 55349, 56446, 55349, 56447, 55349, 
-  56448, 55349, 56449, 55349, 56450, 55349, 56451, 55349, 
-  56452, 55349, 56453, 55349, 56454, 55349, 56455, 55349, 
-  56456, 55349, 56457, 55349, 56458, 55349, 56459, 55349, 
-  56460, 55349, 56461, 55349, 56462, 55349, 56463, 55349, 
-  56464, 55349, 56465, 55349, 56466, 55349, 56467, 55349, 
-  56468, 55349, 56469, 55349, 56470, 55349, 56471, 55349, 
-  56472, 55349, 56473, 55349, 56474, 55349, 56475, 55349, 
-  56476, 55349, 56478, 55349, 56479, 55349, 56482, 55349, 
-  56485, 55349, 56486, 55349, 56489, 55349, 56490, 55349, 
-  56491, 55349, 56492, 55349, 56494, 55349, 56495, 55349, 
-  56496, 55349, 56497, 55349, 56498, 55349, 56499, 55349, 
-  56500, 55349, 56501, 55349, 56502, 55349, 56503, 55349, 
-  56504, 55349, 56505, 55349, 56507, 55349, 56509, 55349, 
-  56510, 55349, 56511, 55349, 56512, 55349, 56513, 55349, 
-  56514, 55349, 56515, 55349, 56517, 55349, 56518, 55349, 
-  56519, 55349, 56520, 55349, 56521, 55349, 56522, 55349, 
-  56523, 55349, 56524, 55349, 56525, 55349, 56526, 55349, 
-  56527, 55349, 56528, 55349, 56529, 55349, 56530, 55349, 
-  56531, 55349, 56532, 55349, 56533, 55349, 56534, 55349, 
-  56535, 55349, 56536, 55349, 56537, 55349, 56538, 55349, 
-  56539, 55349, 56540, 55349, 56541, 55349, 56542, 55349, 
-  56543, 55349, 56544, 55349, 56545, 55349, 56546, 55349, 
-  56547, 55349, 56548, 55349, 56549, 55349, 56550, 55349, 
-  56551, 55349, 56552, 55349, 56553, 55349, 56554, 55349, 
-  56555, 55349, 56556, 55349, 56557, 55349, 56558, 55349, 
-  56559, 55349, 56560, 55349, 56561, 55349, 56562, 55349, 
-  56563, 55349, 56564, 55349, 56565, 55349, 56566, 55349, 
-  56567, 55349, 56568, 55349, 56569, 55349, 56570, 55349, 
-  56571, 55349, 56572, 55349, 56573, 55349, 56574, 55349, 
-  56575, 55349, 56576, 55349, 56577, 55349, 56578, 55349, 
-  56579, 55349, 56580, 55349, 56581, 55349, 56583, 55349, 
-  56584, 55349, 56585, 55349, 56586, 55349, 56589, 55349, 
-  56590, 55349, 56591, 55349, 56592, 55349, 56593, 55349, 
-  56594, 55349, 56595, 55349, 56596, 55349, 56598, 55349, 
-  56599, 55349, 56600, 55349, 56601, 55349, 56602, 55349, 
-  56603, 55349, 56604, 55349, 56606, 55349, 56607, 55349, 
-  56608, 55349, 56609, 55349, 56610, 55349, 56611, 55349, 
-  56612, 55349, 56613, 55349, 56614, 55349, 56615, 55349, 
-  56616, 55349, 56617, 55349, 56618, 55349, 56619, 55349, 
-  56620, 55349, 56621, 55349, 56622, 55349, 56623, 55349, 
-  56624, 55349, 56625, 55349, 56626, 55349, 56627, 55349, 
-  56628, 55349, 56629, 55349, 56630, 55349, 56631, 55349, 
-  56632, 55349, 56633, 55349, 56635, 55349, 56636, 55349, 
-  56637, 55349, 56638, 55349, 56640, 55349, 56641, 55349, 
-  56642, 55349, 56643, 55349, 56644, 55349, 56646, 55349, 
-  56650, 55349, 56651, 55349, 56652, 55349, 56653, 55349, 
-  56654, 55349, 56655, 55349, 56656, 55349, 56658, 55349, 
-  56659, 55349, 56660, 55349, 56661, 55349, 56662, 55349, 
-  56663, 55349, 56664, 55349, 56665, 55349, 56666, 55349, 
-  56667, 55349, 56668, 55349, 56669, 55349, 56670, 55349, 
-  56671, 55349, 56672, 55349, 56673, 55349, 56674, 55349, 
-  56675, 55349, 56676, 55349, 56677, 55349, 56678, 55349, 
-  56679, 55349, 56680, 55349, 56681, 55349, 56682, 55349, 
-  56683, 55349, 56684, 55349, 56685, 55349, 56686, 55349, 
-  56687, 55349, 56688, 55349, 56689, 55349, 56690, 55349, 
-  56691, 55349, 56692, 55349, 56693, 55349, 56694, 55349, 
-  56695, 55349, 56696, 55349, 56697, 55349, 56698, 55349, 
-  56699, 55349, 56700, 55349, 56701, 55349, 56702, 55349, 
-  56703, 55349, 56704, 55349, 56705, 55349, 56706, 55349, 
-  56707, 55349, 56708, 55349, 56709, 55349, 56710, 55349, 
-  56711, 55349, 56712, 55349, 56713, 55349, 56714, 55349, 
-  56715, 55349, 56716, 55349, 56717, 55349, 56718, 55349, 
-  56719, 55349, 56720, 55349, 56721, 55349, 56722, 55349, 
-  56723, 55349, 56724, 55349, 56725, 55349, 56726, 55349, 
-  56727, 55349, 56728, 55349, 56729, 55349, 56730, 55349, 
-  56731, 55349, 56732, 55349, 56733, 55349, 56734, 55349, 
-  56735, 55349, 56736, 55349, 56737, 55349, 56738, 55349, 
-  56739, 55349, 56740, 55349, 56741, 55349, 56742, 55349, 
-  56743, 55349, 56744, 55349, 56745, 55349, 56746, 55349, 
-  56747, 55349, 56748, 55349, 56749, 55349, 56750, 55349, 
-  56751, 55349, 56752, 55349, 56753, 55349, 56754, 55349, 
-  56755, 55349, 56756, 55349, 56757, 55349, 56758, 55349, 
-  56759, 55349, 56760, 55349, 56761, 55349, 56762, 55349, 
-  56763, 55349, 56764, 55349, 56765, 55349, 56766, 55349, 
-  56767, 55349, 56768, 55349, 56769, 55349, 56770, 55349, 
-  56771, 55349, 56772, 55349, 56773, 55349, 56774, 55349, 
-  56775, 55349, 56776, 55349, 56777, 55349, 56778, 55349, 
-  56779, 55349, 56780, 55349, 56781, 55349, 56782, 55349, 
-  56783, 55349, 56784, 55349, 56785, 55349, 56786, 55349, 
-  56787, 55349, 56788, 55349, 56789, 55349, 56790, 55349, 
-  56791, 55349, 56792, 55349, 56793, 55349, 56794, 55349, 
-  56795, 55349, 56796, 55349, 56797, 55349, 56798, 55349, 
-  56799, 55349, 56800, 55349, 56801, 55349, 56802, 55349, 
-  56803, 55349, 56804, 55349, 56805, 55349, 56806, 55349, 
-  56807, 55349, 56808, 55349, 56809, 55349, 56810, 55349, 
-  56811, 55349, 56812, 55349, 56813, 55349, 56814, 55349, 
-  56815, 55349, 56816, 55349, 56817, 55349, 56818, 55349, 
-  56819, 55349, 56820, 55349, 56821, 55349, 56822, 55349, 
-  56823, 55349, 56824, 55349, 56825, 55349, 56826, 55349, 
-  56827, 55349, 56828, 55349, 56829, 55349, 56830, 55349, 
-  56831, 55349, 56832, 55349, 56833, 55349, 56834, 55349, 
-  56835, 55349, 56836, 55349, 56837, 55349, 56838, 55349, 
-  56839, 55349, 56840, 55349, 56841, 55349, 56842, 55349, 
-  56843, 55349, 56844, 55349, 56845, 55349, 56846, 55349, 
-  56847, 55349, 56848, 55349, 56849, 55349, 56850, 55349, 
-  56851, 55349, 56852, 55349, 56853, 55349, 56854, 55349, 
-  56855, 55349, 56856, 55349, 56857, 55349, 56858, 55349, 
-  56859, 55349, 56860, 55349, 56861, 55349, 56862, 55349, 
-  56863, 55349, 56864, 55349, 56865, 55349, 56866, 55349, 
-  56867, 55349, 56868, 55349, 56869, 55349, 56870, 55349, 
-  56871, 55349, 56872, 55349, 56873, 55349, 56874, 55349, 
-  56875, 55349, 56876, 55349, 56877, 55349, 56878, 55349, 
-  56879, 55349, 56880, 55349, 56881, 55349, 56882, 55349, 
-  56883, 55349, 56884, 55349, 56885, 55349, 56886, 55349, 
-  56887, 55349, 56888, 55349, 56889, 55349, 56890, 55349, 
-  56891, 55349, 56892, 55349, 56893, 55349, 56894, 55349, 
-  56895, 55349, 56896, 55349, 56897, 55349, 56898, 55349, 
-  56899, 55349, 56900, 55349, 56901, 55349, 56902, 55349, 
-  56903, 55349, 56904, 55349, 56905, 55349, 56906, 55349, 
-  56907, 55349, 56908, 55349, 56909, 55349, 56910, 55349, 
-  56911, 55349, 56912, 55349, 56913, 55349, 56914, 55349, 
-  56915, 55349, 56916, 55349, 56917, 55349, 56918, 55349, 
-  56919, 55349, 56920, 55349, 56921, 55349, 56922, 55349, 
-  56923, 55349, 56924, 55349, 56925, 55349, 56926, 55349, 
-  56927, 55349, 56928, 55349, 56929, 55349, 56930, 55349, 
-  56931, 55349, 56932, 55349, 56933, 55349, 56934, 55349, 
-  56935, 55349, 56936, 55349, 56937, 55349, 56938, 55349, 
-  56939, 55349, 56940, 55349, 56941, 55349, 56942, 55349, 
-  56943, 55349, 56944, 55349, 56945, 55349, 56946, 55349, 
-  56947, 55349, 56948, 55349, 56949, 55349, 56950, 55349, 
-  56951, 55349, 56952, 55349, 56953, 55349, 56954, 55349, 
-  56955, 55349, 56956, 55349, 56957, 55349, 56958, 55349, 
-  56959, 55349, 56960, 55349, 56961, 55349, 56962, 55349, 
-  56963, 55349, 56964, 55349, 56965, 55349, 56966, 55349, 
-  56967, 55349, 56968, 55349, 56969, 55349, 56970, 55349, 
-  56971, 55349, 56972, 55349, 56973, 55349, 56974, 55349, 
-  56975, 55349, 56976, 55349, 56977, 55349, 56978, 55349, 
-  56979, 55349, 56980, 55349, 56981, 55349, 56982, 55349, 
-  56983, 55349, 56984, 55349, 56985, 55349, 56986, 55349, 
-  56987, 55349, 56988, 55349, 56989, 55349, 56990, 55349, 
-  56991, 55349, 56992, 55349, 56993, 55349, 56994, 55349, 
-  56995, 305, 55349, 56996, 55349, 56997, 55349, 57000, 
-  55349, 57001, 55349, 57002, 55349, 57003, 55349, 57004, 
-  55349, 57005, 55349, 57006, 55349, 57007, 55349, 57008, 
-  55349, 57009, 55349, 57010, 55349, 57011, 55349, 57012, 
-  55349, 57013, 55349, 57014, 55349, 57015, 55349, 57016, 
-  1012, 55349, 57017, 55349, 57018, 55349, 57019, 55349, 
-  57020, 55349, 57021, 55349, 57022, 55349, 57023, 55349, 
-  57024, 8711, 55349, 57026, 55349, 57027, 55349, 57028, 
-  55349, 57029, 55349, 57030, 55349, 57031, 55349, 57032, 
-  55349, 57033, 55349, 57034, 55349, 57035, 55349, 57036, 
-  55349, 57037, 55349, 57038, 55349, 57039, 55349, 57040, 
-  55349, 57041, 55349, 57042, 55349, 57043, 55349, 57044, 
-  55349, 57045, 55349, 57046, 55349, 57047, 55349, 57048, 
-  55349, 57049, 55349, 57050, 8706, 1013, 55349, 57052, 
-  977, 55349, 57053, 1008, 55349, 57054, 981, 55349, 
-  57055, 1009, 55349, 57056, 982, 55349, 57057, 55349, 
-  57058, 55349, 57059, 55349, 57060, 55349, 57061, 55349, 
-  57062, 55349, 57063, 55349, 57064, 55349, 57065, 55349, 
-  57066, 55349, 57067, 55349, 57068, 55349, 57069, 55349, 
-  57070, 55349, 57071, 55349, 57072, 55349, 57073, 55349, 
-  57074, 55349, 57075, 55349, 57076, 55349, 57077, 55349, 
-  57078, 55349, 57079, 55349, 57080, 55349, 57081, 55349, 
-  57082, 55349, 57084, 55349, 57085, 55349, 57086, 55349, 
-  57087, 55349, 57088, 55349, 57089, 55349, 57090, 55349, 
-  57091, 55349, 57092, 55349, 57093, 55349, 57094, 55349, 
-  57095, 55349, 57096, 55349, 57097, 55349, 57098, 55349, 
-  57099, 55349, 57100, 55349, 57101, 55349, 57102, 55349, 
-  57103, 55349, 57104, 55349, 57105, 55349, 57106, 55349, 
-  57107, 55349, 57108, 55349, 57110, 55349, 57111, 55349, 
-  57112, 55349, 57113, 55349, 57114, 55349, 57115, 55349, 
-  57116, 55349, 57117, 55349, 57118, 55349, 57119, 55349, 
-  57120, 55349, 57121, 55349, 57122, 55349, 57123, 55349, 
-  57124, 55349, 57125, 55349, 57126, 55349, 57127, 55349, 
-  57128, 55349, 57129, 55349, 57130, 55349, 57131, 55349, 
-  57132, 55349, 57133, 55349, 57134, 55349, 57135, 55349, 
-  57136, 55349, 57137, 55349, 57138, 55349, 57139, 55349, 
-  57140, 55349, 57142, 55349, 57143, 55349, 57144, 55349, 
-  57145, 55349, 57146, 55349, 57147, 55349, 57148, 55349, 
-  57149, 55349, 57150, 55349, 57151, 55349, 57152, 55349, 
-  57153, 55349, 57154, 55349, 57155, 55349, 57156, 55349, 
-  57157, 55349, 57158, 55349, 57159, 55349, 57160, 55349, 
-  57161, 55349, 57162, 55349, 57163, 55349, 57164, 55349, 
-  57165, 55349, 57166, 55349, 57168, 55349, 57169, 55349, 
-  57170, 55349, 57171, 55349, 57172, 55349, 57173, 55349, 
-  57174, 55349, 57175, 55349, 57176, 55349, 57177, 55349, 
-  57178, 55349, 57179, 55349, 57180, 55349, 57181, 55349, 
-  57182, 55349, 57183, 55349, 57184, 55349, 57185, 55349, 
-  57186, 55349, 57187, 55349, 57188, 55349, 57189, 55349, 
-  57190, 55349, 57191, 55349, 57192, 55349, 57193, 55349, 
-  57194, 55349, 57195, 55349, 57196, 55349, 57197, 55349, 
-  57198, 55349, 57200, 55349, 57201, 55349, 57202, 55349, 
-  57203, 55349, 57204, 55349, 57205, 55349, 57206, 55349, 
-  57207, 55349, 57208, 55349, 57209, 55349, 57210, 55349, 
-  57211, 55349, 57212, 55349, 57213, 55349, 57214, 55349, 
-  57215, 55349, 57216, 55349, 57217, 55349, 57218, 55349, 
-  57219, 55349, 57220, 55349, 57221, 55349, 57222, 55349, 
-  57223, 55349, 57224, 55349, 57226, 55349, 57227, 55349, 
-  57228, 55349, 57229, 55349, 57230, 55349, 57231, 55349, 
-  57232, 55349, 57233, 55349, 57234, 55349, 57235, 55349, 
-  57236, 55349, 57237, 55349, 57238, 55349, 57239, 55349, 
-  57240, 55349, 57241, 55349, 57242, 55349, 57243, 55349, 
-  57244, 55349, 57245, 55349, 57246, 55349, 57247, 55349, 
-  57248, 55349, 57249, 55349, 57250, 55349, 57251, 55349, 
-  57252, 55349, 57253, 55349, 57254, 55349, 57255, 55349, 
-  57256, 55349, 57258, 55349, 57259, 55349, 57260, 55349, 
-  57261, 55349, 57262, 55349, 57263, 55349, 57264, 55349, 
-  57265, 55349, 57266, 55349, 57267, 55349, 57268, 55349, 
-  57269, 55349, 57270, 55349, 57271, 55349, 57272, 55349, 
-  57273, 55349, 57274, 55349, 57275, 55349, 57276, 55349, 
-  57277, 55349, 57278, 55349, 57279, 55349, 57280, 55349, 
-  57281, 55349, 57282, 55349, 57284, 55349, 57285, 55349, 
-  57286, 55349, 57287, 55349, 57288, 55349, 57289, 55349, 
-  57290, 55349, 57291, 55351, 57088, 55351, 57089, 55351, 
-  57090, 55351, 57091, 55351, 57095, 55351, 57097, 55351, 
-  57099, 55351, 57100, 55351, 57101, 55351, 57102, 55351, 
-  57103, 55351, 57104, 55351, 57105, 55351, 57106, 55351, 
-  57107, 55351, 57108, 55351, 57109, 55351, 57110, 55351, 
-  57111, 55351, 57112, 55351, 57113, 55351, 57114, 55351, 
-  57115, 55351, 57116, 55351, 57117, 55351, 57125, 55351, 
-  57126, 55351, 57127, 55351, 57128, 55351, 57129, 55351, 
-  57130, 55352, 56368, 55352, 56369, 55352, 56370, 55352, 
-  56371, 55352, 56372, 55352, 56373, 55352, 56374, 55352, 
-  56375, 55352, 56376, 55352, 56377, 55352, 56378, 55352, 
-  56379, 55352, 56380, 55352, 56381, 55352, 56382, 55352, 
-  56383, 55352, 56384, 55352, 56385, 55352, 56386, 55352, 
-  56387, 55352, 56388, 55352, 56389, 55352, 56390, 55352, 
-  56391, 55352, 56392, 55352, 56393, 55352, 56394, 55352, 
-  56395, 55352, 56396, 55352, 56397, 55352, 56398, 55352, 
-  56399, 55352, 56400, 55352, 56401, 55352, 56402, 55352, 
-  56403, 55352, 56404, 55352, 56405, 55352, 56406, 55352, 
-  56407, 55352, 56408, 55352, 56409, 55352, 56410, 55352, 
-  56411, 55352, 56412, 55352, 56413, 55352, 56414, 55352, 
-  56415, 55352, 56416, 55352, 56417, 55352, 56418, 55352, 
-  56419, 55352, 56420, 55352, 56421, 55352, 56422, 55352, 
-  56423, 55352, 56424, 55352, 56425, 55352, 56426, 55352, 
-  56427, 55352, 56428, 55352, 56429, 55354, 56610, 55354, 
-  56611, 55354, 56612, 55354, 56613, 55354, 56614, 55354, 
-  56615, 55354, 56616, 55354, 56617, 55354, 56618, 55354, 
-  56619, 55354, 56620, 55354, 56621, 55354, 56622, 55354, 
-  56623, 55354, 56624, 55354, 56625, 55354, 56626, 55354, 
-  56627, 55354, 56628, 55354, 56629, 55354, 56630, 55354, 
-  56631, 55354, 56632, 55354, 56633, 55354, 56634, 55354, 
-  56635, 55354, 56636, 55354, 56637, 55354, 56638, 55354, 
-  56639, 55354, 56640, 55354, 56641, 55354, 56642, 55354, 
-  56643, 55354, 56576, 55354, 56577, 55354, 56578, 55354, 
-  56579, 55354, 56580, 55354, 56581, 55354, 56582, 55354, 
-  56583, 55354, 56584, 55354, 56585, 55354, 56586, 55354, 
-  56587, 55354, 56588, 55354, 56589, 55354, 56590, 55354, 
-  56591, 55354, 56592, 55354, 56593, 55354, 56594, 55354, 
-  56595, 55354, 56596, 55354, 56597, 55354, 56598, 55354, 
-  56599, 55354, 56600, 55354, 56601, 55354, 56602, 55354, 
-  56603, 55354, 56604, 55354, 56605, 55354, 56606, 55354, 
-  56607, 55354, 56608, 55354, 56609, 1646, 1697, 1647, 
-  48, 46, 48, 44, 49, 44, 50, 44, 
-  51, 44, 52, 44, 53, 44, 54, 44, 
-  55, 44, 56, 44, 57, 44, 40, 65, 
-  41, 40, 66, 41, 40, 67, 41, 40, 
-  68, 41, 40, 69, 41, 40, 70, 41, 
-  40, 71, 41, 40, 72, 41, 40, 73, 
-  41, 40, 74, 41, 40, 75, 41, 40, 
-  76, 41, 40, 77, 41, 40, 78, 41, 
-  40, 79, 41, 40, 80, 41, 40, 81, 
-  41, 40, 82, 41, 40, 83, 41, 40, 
-  84, 41, 40, 85, 41, 40, 86, 41, 
-  40, 87, 41, 40, 88, 41, 40, 89, 
-  41, 40, 90, 41, 12308, 83, 12309, 67, 
-  68, 87, 90, 55356, 56624, 55356, 56625, 55356, 
-  56626, 55356, 56627, 55356, 56628, 55356, 56629, 55356, 
-  56630, 55356, 56631, 55356, 56632, 55356, 56633, 55356, 
-  56634, 55356, 56635, 55356, 56636, 55356, 56637, 55356, 
-  56638, 55356, 56639, 55356, 56640, 55356, 56641, 55356, 
-  56642, 55356, 56643, 55356, 56644, 55356, 56645, 55356, 
-  56646, 55356, 56647, 55356, 56648, 55356, 56649, 72, 
-  86, 83, 68, 83, 83, 80, 80, 86, 
-  87, 67, 55356, 56656, 55356, 56657, 55356, 56658, 
-  55356, 56659, 55356, 56660, 55356, 56661, 55356, 56662, 
-  55356, 56663, 55356, 56664, 55356, 56665, 55356, 56666, 
-  55356, 56667, 55356, 56668, 55356, 56669, 55356, 56670, 
-  55356, 56671, 55356, 56672, 55356, 56673, 55356, 56674, 
-  55356, 56675, 55356, 56676, 55356, 56677, 55356, 56678, 
-  55356, 56679, 55356, 56680, 55356, 56681, 77, 67, 
-  77, 68, 77, 82, 55356, 56688, 55356, 56689, 
-  55356, 56690, 55356, 56691, 55356, 56692, 55356, 56693, 
-  55356, 56694, 55356, 56695, 55356, 56696, 55356, 56697, 
-  55356, 56698, 55356, 56699, 55356, 56700, 55356, 56701, 
-  55356, 56702, 55356, 56703, 55356, 56704, 55356, 56705, 
-  55356, 56706, 55356, 56707, 55356, 56708, 55356, 56709, 
-  55356, 56710, 55356, 56711, 55356, 56712, 55356, 56713, 
-  68, 74, 12411, 12363, 12467, 12467, 23383, 21452, 
-  12487, 22810, 35299, 20132, 26144, 28961, 21069, 24460, 
-  20877, 26032, 21021, 32066, 36009, 22768, 21561, 28436, 
-  25237, 25429, 36938, 25351, 25171, 31105, 31354, 21512, 
-  28288, 30003, 21106, 21942, 37197, 12308, 26412, 12309, 
-  12308, 19977, 12309, 12308, 20108, 12309, 12308, 23433, 
-  12309, 12308, 28857, 12309, 12308, 25171, 12309, 12308, 
-  30423, 12309, 12308, 21213, 12309, 12308, 25943, 12309, 
-  24471, 21487, 20029, 20024, 20033, 55360, 56610, 20320, 
-  20411, 20482, 20602, 20633, 20687, 13470, 55361, 56890, 
-  20820, 20836, 20855, 55361, 56604, 13497, 20839, 55361, 
-  56651, 20887, 20900, 20172, 20908, 55396, 56799, 20995, 
-  13535, 21051, 21062, 21111, 13589, 21253, 21254, 21321, 
-  21338, 21363, 21373, 21375, 55362, 56876, 28784, 21450, 
-  21471, 55362, 57187, 21483, 21489, 21510, 21662, 21560, 
-  21576, 21608, 21666, 21750, 21776, 21843, 21859, 21892, 
-  21931, 21939, 21954, 22294, 22295, 22097, 22132, 22766, 
-  22478, 22516, 22541, 22411, 22578, 22577, 22700, 55365, 
-  56548, 22770, 22775, 22790, 22818, 22882, 55365, 57000, 
-  55365, 57066, 23020, 23067, 23079, 23000, 23142, 14062, 
-  14076, 23304, 23358, 55366, 56776, 23491, 23512, 23539, 
-  55366, 57112, 23551, 23558, 24403, 14209, 23648, 23744, 
-  23693, 55367, 56804, 23875, 55367, 56806, 23918, 23915, 
-  23932, 24033, 24034, 14383, 24061, 24104, 24125, 24169, 
-  14434, 55368, 56707, 14460, 24240, 24243, 24246, 55400, 
-  57234, 55368, 57137, 33281, 24354, 14535, 55372, 57016, 
-  55384, 56794, 24418, 24427, 14563, 24474, 24525, 24535, 
-  24569, 24705, 14650, 14620, 55369, 57044, 24775, 24904, 
-  24908, 24954, 25010, 24996, 25007, 25054, 25104, 25115, 
-  25181, 25265, 25300, 25424, 55370, 57100, 25405, 25340, 
-  25448, 25475, 25572, 55370, 57329, 25634, 25541, 25513, 
-  14894, 25705, 25726, 25757, 25719, 14956, 25964, 55372, 
-  56330, 26083, 26360, 26185, 15129, 15112, 15076, 20882, 
-  20885, 26368, 26268, 32941, 17369, 26401, 26462, 26451, 
-  55372, 57283, 15177, 26618, 26501, 26706, 55373, 56429, 
-  26766, 26655, 26900, 26946, 27043, 27114, 27304, 55373, 
-  56995, 27355, 15384, 27425, 55374, 56487, 27476, 15438, 
-  27506, 27551, 27579, 55374, 56973, 55367, 56587, 55374, 
-  57082, 27726, 55375, 56508, 27839, 27853, 27751, 27926, 
-  27966, 28009, 28024, 28037, 55375, 56606, 27956, 28207, 
-  28270, 15667, 28359, 55375, 57041, 28153, 28526, 55375, 
-  57182, 55375, 57230, 28614, 28729, 28699, 15766, 28746, 
-  28797, 28791, 28845, 55361, 56613, 28997, 55376, 56931, 
-  29084, 55376, 57259, 29224, 29264, 55377, 56840, 29312, 
-  29333, 55377, 57141, 55378, 56340, 29562, 29579, 16044, 
-  29605, 16056, 29767, 29788, 29829, 29898, 16155, 29988, 
-  55379, 56374, 30014, 55379, 56466, 55368, 56735, 30224, 
-  55379, 57249, 55379, 57272, 55380, 56388, 16380, 16392, 
-  55380, 56563, 55380, 56562, 55380, 56601, 55380, 56627, 
-  30494, 30495, 30603, 16454, 16534, 55381, 56349, 30798, 
-  16611, 55381, 56870, 55381, 56986, 55381, 57029, 31211, 
-  16687, 31306, 31311, 55382, 56700, 55382, 56999, 31470, 
-  16898, 55382, 57259, 31686, 31689, 16935, 55383, 56448, 
-  31954, 17056, 31976, 31971, 32000, 55383, 57222, 32099, 
-  17153, 32199, 32258, 32325, 17204, 55384, 56872, 55384, 
-  56903, 17241, 55384, 57049, 32634, 55384, 57150, 32661, 
-  32762, 55385, 56538, 55385, 56611, 32864, 55385, 56744, 
-  32880, 55372, 57183, 17365, 32946, 33027, 17419, 33086, 
-  23221, 55385, 57255, 55385, 57269, 55372, 57235, 55372, 
-  57244, 33284, 36766, 17515, 33425, 33419, 33437, 21171, 
-  33457, 33459, 33469, 33510, 55386, 57148, 33565, 33635, 
-  33709, 33571, 33725, 33767, 33619, 33738, 33740, 33756, 
-  55387, 56374, 55387, 56683, 55387, 56533, 17707, 34033, 
-  34035, 34070, 55388, 57290, 34148, 55387, 57132, 17757, 
-  17761, 55387, 57265, 55388, 56530, 17771, 34384, 34407, 
-  34409, 34473, 34440, 34574, 34530, 34600, 34667, 34694, 
-  17879, 34785, 34817, 17913, 34912, 55389, 56935, 35031, 
-  35038, 17973, 35066, 13499, 55390, 56494, 55390, 56678, 
-  18110, 18119, 35488, 55391, 56488, 36011, 36033, 36123, 
-  36215, 55391, 57135, 55362, 56324, 36299, 36284, 36336, 
-  55362, 56542, 36564, 55393, 56786, 55393, 56813, 37012, 
-  37105, 37137, 55393, 57134, 37147, 37432, 37591, 37592, 
-  37500, 37881, 37909, 55394, 57338, 38283, 18837, 38327, 
-  55395, 56695, 18918, 38595, 23986, 38691, 55396, 56645, 
-  55396, 56858, 19054, 19062, 38880, 55397, 56330, 19122, 
-  55397, 56470, 38953, 55397, 56758, 39138, 19251, 39209, 
-  39335, 39362, 39422, 19406, 55398, 57136, 40000, 40189, 
-  19662, 19693, 40295, 55400, 56526, 19704, 55400, 56581, 
-  55400, 56846, 55400, 56977, 19798, 40702, 40709, 40719, 
-  40726, 55401, 56832, };
-
-static const utf8proc_uint16_t utf8proc_stage1table[] = {
-  0, 256, 512, 768, 1024, 1280, 1536, 
-  1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584, 
-  3840, 4096, 4352, 4608, 4864, 5120, 5376, 5632, 
-  5888, 6144, 6400, 6656, 6912, 7168, 7424, 7680, 
-  7936, 8192, 8448, 8704, 8960, 9216, 9472, 9728, 
-  9984, 10240, 10496, 10752, 11008, 11264, 11520, 11776, 
-  12032, 12288, 12544, 12800, 13056, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13568, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13824, 13312, 13312, 13312, 14080, 5376, 14336, 
-  14592, 14848, 15104, 15360, 15616, 15872, 16128, 16384, 
-  16640, 16896, 17152, 17408, 15872, 16128, 16384, 16640, 
-  16896, 17152, 17408, 15872, 16128, 16384, 16640, 16896, 
-  17152, 17408, 15872, 16128, 16384, 16640, 16896, 17152, 
-  17408, 15872, 16128, 16384, 16640, 16896, 17152, 17408, 
-  15872, 16128, 16384, 16640, 16896, 17152, 17408, 15872, 
-  17664, 17920, 17920, 17920, 17920, 17920, 17920, 17920, 
-  17920, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18432, 18688, 18944, 19200, 19456, 19712, 
-  19968, 20224, 20480, 20736, 20992, 21248, 21504, 5376, 
-  21760, 22016, 22272, 22528, 22784, 23040, 23296, 23552, 
-  23808, 24064, 24320, 24576, 24832, 25088, 25344, 25600, 
-  25856, 26112, 26368, 26624, 26880, 27136, 27392, 27648, 
-  27904, 5376, 5376, 5376, 28160, 28416, 28672, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  29184, 5376, 5376, 5376, 5376, 29440, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 5376, 5376, 29696, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 5376, 5376, 29952, 30208, 28928, 28928, 30464, 
-  30720, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  30976, 13312, 13312, 13312, 13312, 31232, 31488, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  31744, 13312, 32000, 32256, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 32512, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  32768, 33024, 33280, 33536, 33792, 34048, 34304, 34560, 
-  34816, 10240, 10240, 35072, 28928, 28928, 28928, 28928, 
-  35328, 35584, 35840, 36096, 28928, 36352, 28928, 28928, 
-  36608, 36864, 37120, 28928, 28928, 37376, 37632, 37888, 
-  28928, 38144, 38400, 38656, 38912, 39168, 39424, 39680, 
-  39936, 40192, 40448, 40704, 40960, 28928, 28928, 28928, 
-  28928, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 41216, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  41472, 41728, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 41984, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 42240, 13312, 13312, 42496, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 42752, 43008, 43264, 28928, 28928, 28928, 28928, 
-  28928, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 43520, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 43776, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 44032, 44288, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, 
-  28928, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  44544, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  44544, };
-
-static const utf8proc_uint16_t utf8proc_stage2table[] = {
-  1, 1, 1, 1, 1, 1, 1, 
-  1, 1, 2, 3, 2, 4, 5, 1, 
-  1, 1, 1, 1, 1, 1, 1, 1, 
-  1, 1, 1, 1, 1, 6, 6, 6, 
-  2, 7, 8, 8, 9, 10, 9, 8, 
-  8, 11, 12, 8, 13, 14, 15, 14, 
-  14, 16, 16, 16, 16, 16, 16, 16, 
-  16, 16, 16, 14, 8, 17, 18, 19, 
-  8, 8, 20, 21, 22, 23, 24, 25, 
-  26, 27, 28, 29, 30, 31, 32, 33, 
-  34, 35, 36, 37, 38, 39, 40, 41, 
-  42, 43, 44, 45, 11, 8, 12, 46, 
-  47, 46, 48, 49, 50, 51, 52, 53, 
-  54, 55, 56, 57, 58, 59, 60, 61, 
-  62, 63, 64, 65, 66, 67, 68, 69, 
-  70, 71, 72, 73, 11, 74, 12, 74, 
-  1, 1, 1, 1, 1, 1, 6, 1, 
-  1, 1, 1, 1, 1, 1, 1, 1, 
-  1, 1, 1, 1, 1, 1, 1, 1, 
-  1, 1, 1, 1, 1, 1, 1, 1, 
-  1, 75, 8, 10, 10, 10, 10, 76, 
-  8, 77, 78, 79, 80, 74, 81, 78, 
-  82, 83, 84, 85, 86, 87, 88, 8, 
-  8, 89, 90, 91, 92, 93, 94, 95, 
-  8, 96, 97, 98, 99, 100, 101, 102, 
-  103, 104, 105, 106, 107, 108, 109, 110, 
-  111, 112, 113, 114, 115, 116, 117, 118, 
-  74, 119, 120, 121, 122, 123, 124, 125, 
-  126, 127, 128, 129, 130, 131, 132, 133, 
-  134, 135, 136, 137, 138, 139, 140, 141, 
-  142, 143, 144, 145, 146, 147, 148, 149, 
-  74, 150, 151, 152, 153, 154, 155, 156, 
-  157, 158, 159, 160, 161, 162, 163, 164, 
-  165, 166, 167, 168, 169, 170, 171, 172, 
-  173, 174, 175, 176, 177, 178, 179, 180, 
-  181, 182, 183, 184, 185, 186, 187, 188, 
-  189, 190, 191, 192, 193, 194, 195, 196, 
-  197, 198, 199, 200, 201, 202, 203, 204, 
-  205, 206, 207, 208, 209, 210, 211, 212, 
-  213, 214, 215, 216, 217, 218, 219, 220, 
-  221, 222, 223, 224, 225, 226, 227, 228, 
-  229, 230, 231, 232, 233, 234, 235, 236, 
-  237, 238, 239, 240, 241, 242, 243, 244, 
-  245, 246, 247, 248, 249, 250, 251, 252, 
-  253, 254, 255, 256, 257, 258, 259, 260, 
-  261, 262, 263, 264, 265, 266, 267, 268, 
-  269, 270, 271, 272, 273, 274, 275, 276, 
-  277, 278, 279, 280, 281, 282, 283, 284, 
-  285, 286, 287, 288, 289, 290, 291, 292, 
-  293, 294, 295, 296, 297, 298, 299, 300, 
-  301, 302, 303, 304, 305, 306, 307, 308, 
-  309, 310, 311, 312, 313, 314, 315, 316, 
-  317, 318, 319, 320, 321, 322, 323, 324, 
-  325, 326, 327, 328, 329, 330, 331, 332, 
-  333, 334, 335, 336, 337, 338, 339, 340, 
-  341, 342, 343, 344, 345, 346, 347, 348, 
-  349, 345, 345, 345, 345, 350, 351, 352, 
-  353, 354, 355, 356, 357, 358, 359, 360, 
-  361, 362, 363, 364, 365, 366, 367, 368, 
-  369, 370, 371, 372, 373, 374, 375, 376, 
-  377, 378, 379, 380, 381, 382, 383, 384, 
-  385, 386, 387, 388, 389, 390, 391, 392, 
-  393, 394, 395, 396, 397, 398, 399, 400, 
-  401, 402, 403, 404, 405, 406, 407, 408, 
-  409, 410, 411, 412, 413, 414, 415, 416, 
-  417, 418, 419, 420, 421, 422, 423, 424, 
-  425, 426, 427, 428, 429, 430, 431, 432, 
-  433, 434, 435, 436, 437, 438, 439, 440, 
-  441, 442, 443, 444, 445, 446, 447, 448, 
-  449, 450, 451, 452, 453, 454, 455, 456, 
-  457, 458, 459, 460, 461, 462, 463, 464, 
-  465, 466, 467, 468, 469, 470, 471, 472, 
-  473, 474, 475, 476, 477, 478, 479, 480, 
-  481, 482, 483, 484, 485, 486, 487, 488, 
-  489, 490, 491, 492, 493, 494, 495, 496, 
-  497, 498, 499, 500, 501, 502, 503, 504, 
-  505, 506, 507, 508, 509, 510, 511, 512, 
-  513, 514, 515, 516, 517, 518, 519, 520, 
-  521, 522, 523, 524, 525, 526, 527, 528, 
-  529, 530, 531, 532, 533, 534, 535, 536, 
-  537, 538, 539, 540, 541, 542, 543, 544, 
-  545, 546, 547, 548, 549, 550, 551, 552, 
-  553, 554, 555, 556, 557, 345, 558, 559, 
-  560, 561, 562, 563, 564, 565, 566, 567, 
-  568, 569, 570, 571, 572, 573, 574, 575, 
-  576, 577, 578, 579, 580, 581, 582, 583, 
-  584, 585, 586, 587, 588, 589, 590, 591, 
-  592, 593, 594, 594, 595, 595, 595, 595, 
-  595, 596, 597, 46, 46, 46, 46, 594, 
-  594, 594, 594, 594, 594, 594, 594, 594, 
-  594, 595, 595, 46, 46, 46, 46, 46, 
-  46, 598, 599, 600, 601, 602, 603, 46, 
-  46, 604, 605, 606, 607, 608, 46, 46, 
-  46, 46, 46, 46, 46, 594, 46, 595, 
-  46, 46, 46, 46, 46, 46, 46, 46, 
-  46, 46, 46, 46, 46, 46, 46, 46, 
-  46, 609, 610, 611, 612, 613, 614, 615, 
-  616, 617, 618, 619, 620, 621, 614, 614, 
-  622, 614, 623, 614, 624, 625, 626, 627, 
-  627, 627, 627, 626, 628, 627, 627, 627, 
-  627, 627, 629, 629, 630, 631, 632, 633, 
-  634, 635, 627, 627, 627, 627, 636, 637, 
-  627, 638, 639, 627, 627, 640, 640, 640, 
-  640, 641, 627, 627, 627, 627, 614, 614, 
-  614, 642, 643, 644, 645, 646, 647, 614, 
-  627, 627, 627, 614, 614, 614, 627, 627, 
-  648, 614, 614, 614, 627, 627, 627, 627, 
-  614, 626, 627, 627, 614, 649, 650, 650, 
-  649, 650, 650, 649, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 651, 652, 653, 654, 655, 46, 656, 
-  657, 0, 0, 658, 659, 660, 661, 662, 
-  663, 0, 0, 0, 0, 87, 664, 665, 
-  666, 667, 668, 669, 0, 670, 0, 671, 
-  672, 673, 674, 675, 676, 677, 678, 679, 
-  680, 681, 682, 683, 684, 685, 686, 687, 
-  688, 689, 690, 0, 691, 692, 693, 694, 
-  695, 696, 697, 698, 699, 700, 701, 702, 
-  703, 704, 705, 706, 707, 708, 709, 710, 
-  711, 712, 713, 714, 715, 716, 717, 718, 
-  719, 720, 721, 722, 723, 724, 725, 726, 
-  727, 728, 729, 730, 731, 732, 733, 734, 
-  735, 736, 737, 738, 739, 740, 741, 742, 
-  743, 744, 745, 746, 747, 748, 749, 750, 
-  751, 752, 753, 754, 755, 756, 757, 758, 
-  759, 760, 761, 762, 763, 764, 765, 766, 
-  767, 768, 769, 770, 771, 772, 773, 74, 
-  774, 775, 776, 777, 778, 779, 780, 781, 
-  782, 783, 784, 785, 786, 787, 788, 789, 
-  790, 791, 792, 793, 794, 795, 796, 797, 
-  798, 799, 800, 801, 802, 803, 804, 805, 
-  806, 807, 808, 809, 810, 811, 812, 813, 
-  814, 815, 816, 817, 818, 819, 820, 821, 
-  822, 823, 824, 825, 826, 827, 828, 829, 
-  830, 831, 832, 833, 834, 835, 836, 837, 
-  838, 839, 840, 841, 842, 843, 844, 845, 
-  846, 847, 848, 849, 850, 851, 852, 853, 
-  854, 855, 856, 857, 858, 859, 860, 861, 
-  862, 863, 864, 865, 866, 867, 868, 869, 
-  870, 871, 872, 873, 874, 875, 876, 877, 
-  878, 879, 880, 881, 882, 883, 884, 885, 
-  886, 887, 888, 889, 890, 891, 892, 893, 
-  894, 895, 896, 897, 898, 899, 900, 901, 
-  902, 903, 904, 905, 906, 907, 908, 909, 
-  910, 911, 912, 913, 614, 614, 614, 614, 
-  614, 914, 914, 915, 916, 917, 918, 919, 
-  920, 921, 922, 923, 924, 925, 926, 927, 
-  928, 929, 930, 931, 932, 933, 934, 935, 
-  936, 937, 938, 939, 940, 941, 942, 943, 
-  944, 945, 946, 947, 948, 949, 950, 951, 
-  952, 953, 954, 955, 956, 957, 958, 959, 
-  960, 961, 962, 963, 964, 965, 966, 967, 
-  968, 969, 970, 971, 972, 973, 974, 975, 
-  976, 977, 978, 979, 980, 981, 982, 983, 
-  984, 985, 986, 987, 988, 989, 990, 991, 
-  992, 993, 994, 995, 996, 997, 998, 999, 
-  1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 
-  1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 
-  1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 
-  1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 
-  1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 
-  1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 
-  1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 
-  1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 
-  1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 
-  1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 
-  1080, 0, 1081, 1082, 1083, 1084, 1085, 1086, 
-  1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 
-  1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 
-  1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 
-  1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 
-  0, 0, 595, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 
-  1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 
-  1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 
-  1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 
-  1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 
-  1159, 1160, 1119, 1161, 0, 0, 76, 76, 
-  10, 0, 627, 614, 614, 614, 614, 627, 
-  614, 614, 614, 1162, 627, 614, 614, 614, 
-  614, 614, 614, 627, 627, 627, 627, 627, 
-  627, 614, 614, 627, 614, 614, 1162, 1163, 
-  614, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 
-  1171, 1172, 1173, 1173, 1174, 1175, 1176, 1177, 
-  1178, 1179, 1180, 1181, 1179, 614, 627, 1179, 
-  1172, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 0, 0, 0, 0, 
-  1182, 1182, 1182, 1182, 1179, 1179, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1183, 1183, 1183, 1183, 1183, 1183, 74, 
-  74, 1184, 9, 9, 1185, 14, 1186, 76, 
-  76, 614, 614, 614, 614, 614, 614, 614, 
-  614, 1187, 1188, 1189, 1186, 1190, 1186, 1186, 
-  1186, 1191, 1191, 1192, 1193, 1194, 1195, 1196, 
-  1197, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1198, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1199, 1191, 1200, 1201, 1202, 1203, 1187, 
-  1188, 1189, 1204, 1205, 1206, 1207, 1208, 627, 
-  614, 614, 614, 614, 614, 627, 614, 614, 
-  627, 1209, 1209, 1209, 1209, 1209, 1209, 1209, 
-  1209, 1209, 1209, 9, 1210, 1210, 1186, 1191, 
-  1191, 1211, 1191, 1191, 1191, 1191, 1212, 1213, 
-  1214, 1215, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1216, 1217, 1218, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1219, 1220, 1186, 1221, 614, 
-  614, 614, 614, 614, 614, 614, 1183, 76, 
-  614, 614, 614, 614, 627, 614, 1198, 1198, 
-  614, 614, 76, 627, 614, 614, 627, 1191, 
-  1191, 16, 16, 16, 16, 16, 16, 16, 
-  16, 16, 16, 1191, 1191, 1191, 1222, 1222, 
-  1191, 1186, 1186, 1186, 1186, 1186, 1186, 1186, 
-  1186, 1186, 1186, 1186, 1186, 1186, 1186, 0, 
-  1223, 1191, 1224, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 614, 627, 614, 614, 627, 614, 614, 
-  627, 627, 627, 614, 627, 627, 614, 627, 
-  614, 614, 614, 627, 614, 627, 614, 627, 
-  614, 627, 614, 614, 0, 0, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1191, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1226, 1226, 1226, 1226, 1226, 1226, 1226, 
-  1226, 1226, 1226, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 614, 614, 614, 614, 
-  614, 614, 614, 627, 614, 1227, 1227, 76, 
-  8, 8, 8, 1227, 0, 0, 627, 1228, 
-  1228, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 614, 
-  614, 614, 614, 1227, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 1227, 614, 614, 
-  614, 1227, 614, 614, 614, 614, 614, 0, 
-  0, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 
-  1179, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 627, 627, 627, 0, 0, 1179, 
-  0, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 0, 0, 0, 0, 
-  0, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1229, 1191, 1191, 1191, 1191, 1191, 1191, 
-  0, 1183, 1183, 0, 0, 0, 0, 0, 
-  0, 614, 627, 627, 627, 614, 614, 614, 
-  614, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1198, 614, 614, 614, 614, 614, 
-  627, 627, 627, 627, 627, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 1183, 627, 614, 614, 627, 
-  614, 614, 627, 614, 614, 614, 627, 627, 
-  627, 1201, 1202, 1203, 614, 614, 614, 627, 
-  614, 614, 627, 627, 614, 614, 614, 614, 
-  614, 1225, 1225, 1225, 1230, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1232, 1233, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1234, 1235, 1231, 1236, 1237, 1231, 1231, 
-  1231, 1231, 1231, 1225, 1230, 1238, 345, 1230, 
-  1230, 1230, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1230, 1230, 1230, 1230, 1239, 1230, 
-  1230, 345, 614, 627, 614, 614, 1225, 1225, 
-  1225, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 
-  1247, 345, 345, 1225, 1225, 1119, 1119, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1119, 595, 345, 345, 345, 345, 345, 
-  345, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 345, 1225, 1230, 1230, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  345, 345, 0, 0, 345, 345, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 0, 0, 0, 1231, 
-  1231, 1231, 1231, 0, 0, 1249, 345, 1250, 
-  1230, 1230, 1225, 1225, 1225, 1225, 0, 0, 
-  1251, 1230, 0, 0, 1252, 1253, 1239, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1254, 0, 0, 0, 0, 1255, 1256, 0, 
-  1257, 345, 345, 1225, 1225, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1231, 1231, 10, 10, 1258, 1258, 1258, 
-  1258, 1258, 1258, 913, 10, 345, 1119, 614, 
-  0, 0, 1225, 1225, 1230, 0, 345, 345, 
-  345, 345, 345, 345, 0, 0, 0, 0, 
-  345, 345, 0, 0, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 1259, 0, 345, 1260, 
-  0, 345, 345, 0, 0, 1249, 0, 1230, 
-  1230, 1230, 1225, 1225, 0, 0, 0, 0, 
-  1225, 1225, 0, 0, 1225, 1225, 1261, 0, 
-  0, 0, 1225, 0, 0, 0, 0, 0, 
-  0, 0, 1262, 1263, 1264, 345, 0, 1265, 
-  0, 0, 0, 0, 0, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1225, 1225, 345, 345, 345, 1225, 1119, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 1225, 1225, 1230, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  345, 345, 345, 0, 345, 345, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 1231, 0, 1231, 1231, 
-  1231, 1231, 1231, 0, 0, 1249, 345, 1230, 
-  1230, 1230, 1225, 1225, 1225, 1225, 1225, 0, 
-  1225, 1225, 1230, 0, 1230, 1230, 1239, 0, 
-  0, 345, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 1225, 1225, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1119, 10, 0, 0, 0, 0, 0, 
-  0, 0, 1231, 1225, 1225, 1225, 1225, 1225, 
-  1225, 0, 1225, 1230, 1230, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  345, 345, 0, 0, 345, 345, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 1231, 0, 1231, 1231, 
-  1231, 1231, 1231, 0, 0, 1249, 345, 1266, 
-  1225, 1230, 1225, 1225, 1225, 1225, 0, 0, 
-  1267, 1268, 0, 0, 1269, 1270, 1239, 0, 
-  0, 0, 0, 0, 0, 0, 1225, 1271, 
-  1272, 0, 0, 0, 0, 1273, 1274, 0, 
-  1231, 345, 345, 1225, 1225, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 913, 1231, 1258, 1258, 1258, 1258, 1258, 
-  1258, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 1225, 345, 0, 345, 345, 
-  345, 345, 345, 345, 0, 0, 0, 345, 
-  345, 345, 0, 1275, 345, 1276, 345, 0, 
-  0, 0, 345, 345, 0, 345, 0, 345, 
-  345, 0, 0, 0, 345, 345, 0, 0, 
-  0, 345, 345, 345, 0, 0, 0, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 0, 0, 0, 0, 1277, 
-  1230, 1225, 1230, 1230, 0, 0, 0, 1278, 
-  1279, 1230, 0, 1280, 1281, 1282, 1261, 0, 
-  0, 345, 0, 0, 0, 0, 0, 0, 
-  1283, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1258, 1258, 1258, 76, 76, 76, 76, 
-  76, 76, 10, 76, 0, 0, 0, 0, 
-  0, 1225, 1230, 1230, 1230, 1225, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 345, 
-  345, 345, 0, 345, 345, 345, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 0, 0, 1249, 345, 1225, 
-  1225, 1225, 1230, 1230, 1230, 1230, 0, 1284, 
-  1225, 1285, 0, 1225, 1225, 1225, 1239, 0, 
-  0, 0, 0, 0, 0, 0, 1286, 1287, 
-  0, 1231, 1231, 1231, 0, 0, 345, 0, 
-  0, 345, 345, 1225, 1225, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 0, 0, 0, 0, 0, 0, 0, 
-  1119, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  913, 345, 1225, 1230, 1230, 1119, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 345, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 345, 345, 
-  345, 345, 345, 0, 0, 1249, 345, 1230, 
-  1289, 1290, 1230, 1291, 1230, 1230, 0, 1292, 
-  1293, 1294, 0, 1295, 1296, 1225, 1261, 0, 
-  0, 0, 0, 0, 0, 0, 1297, 1298, 
-  0, 0, 0, 0, 0, 0, 345, 345, 
-  0, 345, 345, 1225, 1225, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 0, 345, 345, 1230, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1225, 1225, 1230, 1230, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 345, 
-  345, 345, 0, 345, 345, 345, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, 
-  1231, 1231, 1231, 1231, 1299, 1299, 345, 1300, 
-  1230, 1230, 1225, 1225, 1225, 1225, 0, 1301, 
-  1302, 1230, 0, 1303, 1304, 1305, 1239, 1306, 
-  913, 0, 0, 0, 0, 345, 345, 345, 
-  1307, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  345, 345, 345, 1225, 1225, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 913, 345, 345, 345, 345, 345, 
-  345, 0, 1225, 1230, 1230, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 0, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 1308, 0, 0, 0, 0, 
-  1309, 1230, 1230, 1225, 1225, 1225, 0, 1225, 
-  0, 1230, 1310, 1311, 1230, 1312, 1313, 1314, 
-  1315, 0, 0, 0, 0, 0, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 0, 0, 1230, 1230, 1119, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1225, 345, 1316, 1225, 1225, 1225, 
-  1225, 1317, 1317, 1299, 0, 0, 0, 0, 
-  10, 345, 345, 345, 345, 345, 345, 595, 
-  1225, 1318, 1318, 1318, 1318, 1225, 1225, 1225, 
-  1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1119, 1119, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 345, 345, 0, 345, 0, 345, 
-  345, 345, 345, 345, 0, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 345, 0, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1225, 345, 1319, 1225, 1225, 1225, 
-  1225, 1320, 1320, 1299, 1225, 1225, 345, 0, 
-  0, 345, 345, 345, 345, 345, 0, 595, 
-  0, 1321, 1321, 1321, 1321, 1225, 1225, 1225, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 1322, 1323, 345, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 913, 913, 913, 1119, 1119, 1119, 
-  1119, 1119, 1119, 1119, 1119, 1324, 1119, 1119, 
-  1119, 1119, 1119, 1119, 913, 1119, 913, 913, 
-  913, 627, 627, 913, 913, 913, 913, 913, 
-  913, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 913, 627, 913, 
-  627, 913, 1325, 11, 12, 11, 12, 1230, 
-  1230, 345, 345, 345, 1326, 345, 345, 345, 
-  345, 0, 345, 345, 345, 345, 1327, 345, 
-  345, 345, 345, 1328, 345, 345, 345, 345, 
-  1329, 345, 345, 345, 345, 1330, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1331, 345, 345, 345, 0, 0, 
-  0, 0, 1332, 1333, 1334, 1335, 1336, 1337, 
-  1338, 1339, 1340, 1333, 1333, 1333, 1333, 1225, 
-  1230, 1333, 1341, 614, 614, 1299, 1119, 614, 
-  614, 345, 345, 345, 345, 345, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1342, 1225, 1225, 1225, 
-  1225, 0, 1225, 1225, 1225, 1225, 1343, 1225, 
-  1225, 1225, 1225, 1344, 1225, 1225, 1225, 1225, 
-  1345, 1225, 1225, 1225, 1225, 1346, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1347, 1225, 1225, 1225, 0, 913, 
-  913, 913, 913, 913, 913, 913, 913, 627, 
-  913, 913, 913, 913, 913, 913, 0, 913, 
-  913, 1119, 1119, 1119, 1119, 1119, 913, 913, 
-  913, 913, 1119, 1119, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 1348, 1349, 
-  345, 345, 345, 345, 1350, 1350, 1225, 1351, 
-  1225, 1225, 1230, 1225, 1225, 1225, 1225, 1225, 
-  1249, 1350, 1299, 1299, 1230, 1230, 1225, 1225, 
-  345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1119, 1119, 1119, 1119, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 1230, 
-  1230, 1225, 1225, 345, 345, 345, 345, 1225, 
-  1225, 1225, 345, 1350, 1350, 1350, 345, 345, 
-  1350, 1350, 1350, 1350, 1350, 1350, 1350, 345, 
-  345, 345, 1225, 1225, 1225, 1225, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 1225, 1350, 1230, 1225, 1225, 
-  1350, 1350, 1350, 1350, 1350, 1350, 627, 345, 
-  1350, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1350, 1350, 1350, 1225, 913, 
-  913, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 
-  1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 
-  1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 
-  1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 
-  1383, 1384, 1385, 1386, 1387, 1388, 1389, 0, 
-  1390, 0, 0, 0, 0, 0, 1391, 0, 
-  0, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 
-  1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 
-  1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 
-  1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 
-  1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 
-  1431, 1432, 1433, 1434, 1119, 1435, 1436, 1437, 
-  1438, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1440, 1441, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 0, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 0, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 0, 0, 614, 614, 
-  614, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1119, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 0, 0, 0, 0, 0, 
-  0, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 
-  1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 
-  1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 
-  1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 
-  1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 
-  1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 
-  1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 
-  1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 
-  1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 
-  1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 
-  1523, 1524, 1525, 1526, 1527, 1528, 1529, 0, 
-  0, 1530, 1531, 1532, 1533, 1534, 1535, 0, 
-  0, 1161, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 913, 1119, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 7, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 11, 12, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1119, 1119, 1119, 1536, 
-  1536, 1536, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 1225, 1225, 1299, 1537, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 1225, 1225, 1537, 1119, 1119, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 1225, 1225, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 345, 
-  345, 345, 0, 1225, 1225, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 648, 648, 1230, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1225, 
-  1230, 1230, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1299, 1225, 1119, 1119, 1119, 
-  595, 1119, 1119, 1119, 10, 345, 614, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 0, 0, 0, 0, 0, 
-  0, 8, 8, 8, 8, 8, 8, 1161, 
-  8, 8, 8, 8, 648, 648, 648, 1538, 
-  648, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 595, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 1225, 1225, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1163, 345, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 1225, 1225, 1225, 1230, 1230, 1230, 1230, 
-  1225, 1225, 1230, 1230, 1230, 0, 0, 0, 
-  0, 1230, 1230, 1225, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1162, 614, 627, 0, 0, 0, 
-  0, 76, 0, 0, 0, 8, 8, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1258, 0, 0, 0, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  614, 627, 1230, 1230, 1225, 0, 0, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 1230, 1225, 
-  1230, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  0, 1299, 1350, 1225, 1350, 1350, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1225, 1225, 614, 614, 
-  614, 614, 614, 614, 614, 614, 0, 0, 
-  627, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  595, 1119, 1119, 1119, 1119, 1119, 1119, 0, 
-  0, 614, 614, 614, 614, 614, 627, 627, 
-  627, 627, 627, 627, 614, 614, 627, 914, 
-  627, 627, 614, 614, 627, 627, 614, 614, 
-  614, 614, 614, 627, 614, 614, 614, 614, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1225, 1225, 1225, 1225, 1230, 1539, 1540, 
-  1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 
-  345, 345, 1549, 1550, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1249, 1551, 1225, 
-  1225, 1225, 1225, 1552, 1553, 1554, 1555, 1556, 
-  1557, 1558, 1559, 1560, 1561, 1537, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1119, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 614, 627, 614, 614, 
-  614, 614, 614, 614, 614, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 1119, 1119, 
-  0, 1225, 1225, 1230, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1230, 1225, 1225, 1225, 1225, 1230, 
-  1230, 1225, 1225, 1537, 1299, 1225, 1225, 345, 
-  345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 1249, 
-  1230, 1225, 1225, 1230, 1230, 1230, 1225, 1230, 
-  1225, 1225, 1225, 1537, 1537, 0, 0, 0, 
-  0, 0, 0, 0, 0, 1119, 1119, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1230, 1230, 1225, 
-  1249, 0, 0, 0, 1119, 1119, 1119, 1119, 
-  1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 345, 345, 
-  345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 595, 595, 595, 595, 595, 595, 1119, 
-  1119, 1562, 1563, 1564, 1565, 1566, 1566, 1567, 
-  1568, 1569, 0, 0, 0, 0, 0, 0, 
-  0, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 
-  1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 
-  1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 
-  1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 
-  1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 
-  1609, 1610, 1611, 1612, 0, 0, 1613, 1614, 
-  1615, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 0, 0, 0, 0, 0, 0, 0, 
-  0, 614, 614, 614, 1119, 640, 627, 627, 
-  627, 627, 627, 614, 614, 627, 627, 627, 
-  627, 614, 1230, 640, 640, 640, 640, 640, 
-  640, 640, 345, 345, 345, 345, 627, 345, 
-  345, 345, 345, 345, 345, 614, 345, 345, 
-  1230, 614, 614, 345, 0, 0, 0, 0, 
-  0, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 
-  1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 
-  1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 
-  1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 
-  1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 
-  1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 
-  1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 
-  1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 
-  1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 
-  1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 
-  1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 
-  1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 
-  1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 
-  1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 
-  1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 
-  1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 
-  1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 
-  1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 
-  1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 
-  1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 
-  1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 
-  1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 
-  1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 
-  1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 
-  1807, 614, 614, 627, 614, 614, 614, 614, 
-  614, 614, 614, 627, 614, 614, 650, 1808, 
-  627, 629, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 626, 
-  1163, 1163, 627, 1809, 614, 649, 627, 614, 
-  627, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 
-  1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 
-  1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 
-  1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 
-  1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 
-  1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 
-  1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
-  1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 
-  1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 
-  1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 
-  1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 
-  1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 
-  1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 
-  1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 
-  1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 
-  1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 
-  1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 
-  1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 
-  1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 
-  1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 
-  1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 
-  1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 
-  1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 
-  1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 
-  2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 
-  2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 
-  2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 
-  2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 
-  2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 
-  2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 
-  2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 
-  2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 
-  2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 
-  2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 
-  2081, 2082, 2083, 2084, 2085, 2086, 2087, 0, 
-  0, 2088, 2089, 2090, 2091, 2092, 2093, 0, 
-  0, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 
-  2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 
-  2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 
-  2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 
-  2125, 2126, 2127, 2128, 2129, 2130, 2131, 0, 
-  0, 2132, 2133, 2134, 2135, 2136, 2137, 0, 
-  0, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 
-  2145, 0, 2146, 0, 2147, 0, 2148, 0, 
-  2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 
-  2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 
-  2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 
-  2173, 2174, 2175, 2176, 2177, 2178, 2179, 0, 
-  0, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 
-  2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 
-  2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 
-  2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 
-  2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 
-  2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 
-  2227, 2228, 2229, 2230, 2231, 2232, 0, 2233, 
-  2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 
-  2242, 2243, 2244, 2245, 2246, 2247, 0, 2248, 
-  2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 
-  2257, 2258, 2259, 2260, 2261, 0, 0, 2262, 
-  2263, 2264, 2265, 2266, 2267, 0, 2268, 2269, 
-  2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 
-  2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, 
-  2286, 0, 0, 2287, 2288, 2289, 0, 2290, 
-  2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 
-  0, 2299, 2300, 2301, 2301, 2301, 2301, 2301, 
-  2302, 2301, 2301, 2301, 1538, 2303, 2304, 2305, 
-  2306, 1161, 2307, 1161, 1161, 1161, 1161, 8, 
-  2308, 2309, 2310, 2311, 2309, 2309, 2310, 2311, 
-  2309, 8, 8, 8, 8, 2312, 2313, 2314, 
-  8, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 
-  75, 9, 9, 9, 2322, 2323, 8, 2324, 
-  2325, 8, 80, 92, 8, 2326, 8, 2327, 
-  47, 47, 8, 8, 8, 2328, 11, 12, 
-  2329, 2330, 2331, 8, 8, 8, 8, 8, 
-  8, 8, 8, 74, 8, 47, 8, 8, 
-  2332, 8, 8, 8, 8, 8, 8, 8, 
-  2301, 1538, 1538, 1538, 1538, 1538, 0, 2333, 
-  2334, 2335, 2336, 1538, 1538, 1538, 1538, 1538, 
-  1538, 2337, 2338, 0, 0, 2339, 2340, 2341, 
-  2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 
-  2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 
-  2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 
-  0, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 
-  2373, 2374, 2375, 2376, 2377, 2378, 0, 0, 
-  0, 10, 10, 10, 10, 10, 10, 10, 
-  10, 2379, 10, 10, 10, 10, 10, 10, 
-  10, 10, 10, 10, 10, 10, 10, 10, 
-  10, 10, 10, 10, 10, 10, 10, 10, 
-  10, 10, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 614, 614, 640, 640, 614, 614, 614, 
-  614, 640, 640, 640, 614, 614, 914, 914, 
-  914, 914, 614, 914, 914, 914, 640, 640, 
-  614, 627, 614, 640, 640, 627, 627, 627, 
-  627, 614, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2380, 2381, 2382, 2383, 76, 2384, 2385, 
-  2386, 76, 2387, 2388, 2389, 2390, 2391, 2392, 
-  2393, 2394, 2395, 2396, 2397, 76, 2398, 2399, 
-  76, 74, 2400, 2401, 2402, 2403, 2404, 76, 
-  76, 2405, 2406, 2407, 76, 2408, 76, 2409, 
-  76, 2410, 76, 2411, 2412, 2413, 2414, 83, 
-  2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 
-  2423, 2424, 2425, 76, 2426, 2427, 2428, 2429, 
-  2430, 2431, 74, 74, 74, 74, 2432, 2433, 
-  2434, 2435, 2436, 76, 74, 76, 76, 2437, 
-  913, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 
-  2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 
-  2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 
-  2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 
-  2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, 
-  2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 
-  2485, 1536, 1536, 1536, 2486, 2487, 1536, 1536, 
-  1536, 1536, 2488, 76, 76, 0, 0, 0, 
-  0, 2489, 74, 2490, 74, 2491, 78, 78, 
-  78, 78, 78, 2492, 2493, 76, 76, 76, 
-  76, 74, 76, 76, 74, 76, 76, 74, 
-  76, 76, 78, 78, 76, 76, 76, 2494, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 2495, 2496, 
-  2497, 2498, 76, 2499, 76, 2500, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 2501, 2501, 2502, 2503, 74, 74, 
-  74, 2504, 2505, 2501, 2506, 2507, 2501, 74, 
-  74, 74, 2501, 13, 84, 74, 2501, 2501, 
-  74, 74, 74, 2501, 2501, 2501, 2501, 74, 
-  2501, 2501, 2501, 2501, 2508, 2509, 2510, 2511, 
-  74, 74, 74, 74, 2501, 2512, 2513, 2501, 
-  2514, 2515, 2501, 2501, 2501, 74, 74, 74, 
-  74, 74, 2501, 74, 2501, 2516, 2501, 2501, 
-  2501, 2501, 2517, 2501, 2518, 2519, 2520, 2501, 
-  2521, 2522, 2523, 2501, 2501, 2501, 2524, 74, 
-  74, 74, 74, 2501, 2501, 2501, 2501, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  2501, 2525, 2526, 2527, 74, 2528, 2529, 2501, 
-  2501, 2501, 2501, 2501, 2501, 74, 2530, 2531, 
-  2532, 2533, 2534, 2535, 2536, 2537, 2538, 2539, 
-  2540, 2541, 2542, 2543, 2544, 2545, 2546, 2501, 
-  2501, 2547, 2548, 2549, 2550, 2551, 2552, 2553, 
-  2554, 2555, 2556, 2501, 2501, 2501, 74, 74, 
-  2501, 2501, 2557, 2558, 74, 74, 74, 74, 
-  74, 2501, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 2559, 2501, 74, 74, 2501, 
-  2501, 2560, 2561, 2501, 2562, 2563, 2564, 2565, 
-  2566, 2501, 2501, 2567, 2568, 2569, 2570, 2501, 
-  2501, 2501, 74, 74, 74, 74, 74, 2501, 
-  2501, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 2501, 2501, 2501, 2501, 2501, 74, 
-  74, 2501, 2501, 74, 74, 74, 74, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2571, 2572, 2573, 2574, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2575, 2576, 2577, 2578, 74, 
-  74, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 76, 76, 76, 76, 76, 76, 76, 
-  76, 11, 12, 11, 12, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 2579, 2579, 76, 76, 76, 
-  76, 2501, 2501, 76, 76, 76, 76, 76, 
-  76, 78, 2580, 2581, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 76, 74, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 78, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 913, 76, 
-  76, 76, 76, 76, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  78, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 74, 74, 74, 
-  74, 74, 74, 76, 76, 76, 76, 76, 
-  76, 76, 2579, 2579, 2579, 2579, 78, 78, 
-  78, 2579, 78, 78, 2579, 76, 76, 76, 
-  76, 78, 78, 78, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2582, 2583, 2584, 2585, 2586, 2587, 2588, 
-  2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, 
-  2597, 2598, 2599, 2600, 2601, 2602, 2603, 2604, 
-  2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 
-  2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, 
-  2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 
-  2629, 2630, 2631, 2632, 2633, 2634, 2635, 2636, 
-  2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, 
-  2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, 
-  2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 
-  2661, 2662, 2663, 2664, 2665, 2666, 2667, 2668, 
-  2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 
-  2677, 2678, 2679, 2680, 2681, 2682, 2683, 2684, 
-  2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 
-  2693, 2694, 2695, 2696, 2697, 2698, 2699, 2700, 
-  2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 
-  2709, 2710, 2711, 2712, 2713, 2714, 2715, 2716, 
-  2717, 2718, 2719, 2720, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 78, 78, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 78, 
-  74, 76, 76, 76, 76, 76, 76, 76, 
-  76, 78, 74, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 74, 74, 74, 2721, 2721, 2722, 2722, 
-  74, 78, 78, 78, 78, 78, 78, 76, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 76, 2579, 2579, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  2721, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  2579, 78, 78, 78, 78, 78, 78, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 78, 78, 78, 2579, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 2579, 78, 78, 78, 78, 78, 
-  78, 78, 78, 2579, 2579, 2723, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 2579, 2579, 
-  78, 78, 78, 78, 78, 2579, 2579, 78, 
-  78, 78, 78, 78, 78, 78, 78, 2579, 
-  78, 78, 78, 78, 78, 2579, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 2579, 78, 78, 78, 78, 
-  78, 78, 78, 2579, 2579, 78, 2579, 78, 
-  78, 78, 78, 2579, 78, 78, 2579, 78, 
-  78, 78, 78, 78, 78, 78, 2579, 76, 
-  76, 78, 78, 2579, 2579, 78, 78, 78, 
-  78, 78, 78, 78, 76, 78, 76, 78, 
-  76, 76, 76, 76, 76, 76, 78, 76, 
-  76, 76, 78, 76, 76, 76, 76, 76, 
-  76, 2579, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 78, 78, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 78, 76, 76, 
-  78, 76, 76, 76, 76, 2579, 76, 2579, 
-  76, 76, 76, 76, 2579, 2579, 2579, 76, 
-  2579, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 78, 78, 78, 78, 
-  78, 11, 12, 11, 12, 11, 12, 11, 
-  12, 11, 12, 11, 12, 11, 12, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 76, 2579, 2579, 
-  2579, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 78, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 2579, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  2579, 2501, 74, 74, 2501, 2501, 11, 12, 
-  74, 2501, 2501, 74, 2501, 2501, 2501, 74, 
-  74, 74, 74, 74, 2501, 2501, 2501, 2501, 
-  74, 74, 74, 74, 74, 2501, 2501, 2501, 
-  74, 74, 74, 2501, 2501, 2501, 2501, 11, 
-  12, 11, 12, 11, 12, 11, 12, 11, 
-  12, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 2721, 2721, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 11, 12, 11, 12, 
-  11, 12, 11, 12, 11, 12, 11, 12, 
-  11, 12, 11, 12, 11, 12, 11, 12, 
-  11, 12, 74, 74, 2501, 2501, 2501, 2501, 
-  2501, 2501, 74, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 74, 74, 74, 74, 74, 74, 74, 
-  74, 2501, 74, 74, 74, 74, 74, 74, 
-  74, 2501, 2501, 2501, 2501, 2501, 2501, 74, 
-  74, 74, 2501, 74, 74, 74, 74, 2501, 
-  2501, 2501, 2501, 2501, 74, 2501, 2501, 74, 
-  74, 11, 12, 11, 12, 2501, 74, 74, 
-  74, 74, 2501, 74, 2501, 2501, 2501, 74, 
-  74, 2501, 2501, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 2501, 2501, 2501, 
-  2501, 2501, 2501, 74, 74, 11, 12, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 2501, 2501, 2724, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 74, 2501, 
-  2501, 2501, 2501, 74, 74, 2501, 74, 2501, 
-  74, 74, 2501, 74, 2501, 2501, 2501, 2501, 
-  74, 74, 74, 74, 74, 2501, 2501, 74, 
-  74, 74, 74, 74, 74, 2501, 2501, 2501, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  2501, 2501, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 2501, 2501, 74, 
-  74, 74, 74, 2501, 2501, 2501, 2501, 74, 
-  2501, 2501, 74, 74, 2501, 2725, 2726, 2727, 
-  74, 74, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 74, 74, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 74, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, 
-  74, 74, 74, 74, 74, 2728, 2729, 2501, 
-  74, 74, 74, 2501, 2501, 2501, 2501, 2501, 
-  74, 74, 74, 74, 74, 2501, 2501, 2501, 
-  74, 74, 74, 74, 2501, 74, 74, 74, 
-  2501, 2501, 2501, 2501, 2501, 74, 2501, 74, 
-  74, 76, 76, 76, 76, 76, 78, 78, 
-  78, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 2579, 2579, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 74, 74, 
-  74, 74, 74, 74, 74, 74, 76, 76, 
-  74, 74, 74, 74, 74, 74, 76, 76, 
-  76, 2579, 76, 76, 76, 76, 2579, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 0, 0, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 0, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 2730, 
-  76, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 
-  2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, 
-  2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 
-  2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761, 
-  2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 
-  2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777, 
-  2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 
-  2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793, 
-  2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 
-  2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809, 
-  2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 
-  2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825, 
-  2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, 
-  2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, 
-  2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, 
-  2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857, 
-  2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 
-  2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873, 
-  2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 
-  2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889, 
-  2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 
-  2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905, 
-  2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 
-  2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, 
-  2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 
-  2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 
-  2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 
-  2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, 
-  2954, 2955, 2956, 2957, 2958, 2959, 76, 76, 
-  76, 76, 76, 76, 2960, 2961, 2962, 2963, 
-  614, 614, 614, 2964, 2965, 0, 0, 0, 
-  0, 0, 8, 8, 8, 8, 1288, 8, 
-  8, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 
-  2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 
-  2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988, 
-  2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 
-  2997, 2998, 2999, 3000, 3001, 3002, 3003, 0, 
-  3004, 0, 0, 0, 0, 0, 3005, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  3006, 1119, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1299, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 8, 8, 80, 92, 80, 92, 8, 
-  8, 8, 80, 92, 8, 80, 92, 8, 
-  8, 8, 8, 8, 8, 8, 8, 8, 
-  1161, 8, 8, 1161, 8, 80, 92, 8, 
-  8, 80, 92, 11, 12, 11, 12, 11, 
-  12, 11, 12, 8, 8, 8, 8, 8, 
-  594, 8, 8, 8, 8, 8, 8, 8, 
-  8, 8, 8, 1161, 1161, 8, 8, 8, 
-  8, 1161, 8, 2311, 8, 8, 8, 8, 
-  8, 8, 8, 8, 8, 8, 8, 8, 
-  8, 76, 76, 8, 8, 8, 11, 12, 
-  11, 12, 11, 12, 11, 12, 1161, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 0, 3007, 3007, 3007, 3007, 
-  3008, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3009, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 
-  3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 
-  3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 
-  3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 
-  3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 
-  3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 
-  3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 
-  3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, 
-  3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 
-  3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 
-  3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 
-  3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 
-  3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 
-  3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120, 
-  3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 
-  3129, 3130, 3131, 3132, 3133, 3134, 3135, 3136, 
-  3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, 
-  3145, 3146, 3147, 3148, 3149, 3150, 3151, 3152, 
-  3153, 3154, 3155, 3156, 3157, 3158, 3159, 3160, 
-  3161, 3162, 3163, 3164, 3165, 3166, 3167, 3168, 
-  3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 
-  3177, 3178, 3179, 3180, 3181, 3182, 3183, 3184, 
-  3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, 
-  3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, 
-  3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 
-  3209, 3210, 3211, 3212, 3213, 3214, 3215, 3216, 
-  3217, 3218, 3219, 3220, 3221, 3222, 3223, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3224, 3225, 3225, 3225, 3007, 3226, 3227, 
-  3228, 3229, 3230, 3229, 3230, 3229, 3230, 3229, 
-  3230, 3229, 3230, 3007, 3007, 3229, 3230, 3229, 
-  3230, 3229, 3230, 3229, 3230, 3231, 3232, 3233, 
-  3233, 3007, 3228, 3228, 3228, 3228, 3228, 3228, 
-  3228, 3228, 3228, 1809, 1163, 626, 1162, 3234, 
-  3234, 3235, 3226, 3226, 3226, 3226, 3226, 3236, 
-  3007, 3237, 3238, 3239, 3226, 3227, 3240, 3007, 
-  76, 0, 3227, 3227, 3227, 3227, 3227, 3241, 
-  3227, 3227, 3227, 3227, 3242, 3243, 3244, 3245, 
-  3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, 
-  3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, 
-  3262, 3263, 3264, 3265, 3227, 3266, 3267, 3268, 
-  3269, 3270, 3271, 3227, 3227, 3227, 3227, 3227, 
-  3272, 3273, 3274, 3275, 3276, 3277, 3278, 3279, 
-  3280, 3281, 3282, 3283, 3284, 3285, 3286, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3287, 3227, 3227, 
-  0, 0, 3288, 3289, 3290, 3291, 3292, 3293, 
-  3294, 3231, 3227, 3227, 3227, 3227, 3227, 3295, 
-  3227, 3227, 3227, 3227, 3296, 3297, 3298, 3299, 
-  3300, 3301, 3302, 3303, 3304, 3305, 3306, 3307, 
-  3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, 
-  3316, 3317, 3318, 3319, 3227, 3320, 3321, 3322, 
-  3323, 3324, 3325, 3227, 3227, 3227, 3227, 3227, 
-  3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 
-  3334, 3335, 3336, 3337, 3338, 3339, 3340, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3341, 3342, 3343, 3344, 3227, 3345, 3227, 3227, 
-  3346, 3347, 3348, 3349, 3225, 3226, 3350, 3351, 
-  3352, 0, 0, 0, 0, 0, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 0, 3353, 3354, 3355, 3356, 3357, 3358, 
-  3359, 3360, 3361, 3362, 3363, 3364, 3365, 3366, 
-  3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374, 
-  3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, 
-  3383, 3384, 3385, 3386, 3387, 3388, 3389, 3390, 
-  3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 
-  3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406, 
-  3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 
-  3415, 3416, 3417, 3418, 3419, 3420, 3421, 3422, 
-  3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 
-  3431, 3432, 3433, 3434, 3435, 3436, 3437, 3438, 
-  3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 
-  0, 3447, 3447, 3448, 3449, 3450, 3451, 3452, 
-  3453, 3454, 3455, 3456, 3457, 3458, 3459, 3460, 
-  3461, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  3007, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3462, 3463, 3464, 3465, 3466, 3467, 3468, 
-  3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476, 
-  3477, 3478, 3479, 3480, 3481, 3482, 3483, 3484, 
-  3485, 3486, 3487, 3488, 3489, 3490, 3491, 3492, 
-  0, 3493, 3494, 3495, 3496, 3497, 3498, 3499, 
-  3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 
-  3508, 3509, 3510, 3511, 3512, 3513, 3514, 3515, 
-  3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 
-  3524, 3525, 3526, 3527, 3528, 3529, 3530, 3531, 
-  3532, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 3533, 3534, 3535, 3536, 3537, 3538, 3539, 
-  3540, 3541, 3542, 3543, 3544, 3545, 3546, 3547, 
-  3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555, 
-  3556, 3557, 3558, 3559, 3560, 3561, 3562, 3563, 
-  3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 
-  3572, 3573, 3574, 3575, 3576, 3577, 3578, 3579, 
-  3447, 3580, 3581, 3582, 3583, 3584, 3585, 3586, 
-  3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 
-  3595, 3596, 3597, 3598, 3599, 3600, 3601, 3602, 
-  3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 
-  3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618, 
-  3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 
-  3627, 3628, 3629, 3630, 3631, 3632, 3633, 3634, 
-  3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642, 
-  3643, 3644, 3645, 3646, 3647, 3648, 3649, 3650, 
-  3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 
-  3659, 3660, 3661, 3662, 3663, 3664, 3665, 3666, 
-  3667, 3668, 3669, 3670, 3671, 3672, 3673, 3674, 
-  3675, 3676, 3677, 3678, 3679, 3680, 3681, 3682, 
-  3683, 3684, 3685, 3686, 3687, 3688, 3689, 3690, 
-  3691, 3692, 3693, 3694, 3695, 3696, 3697, 3698, 
-  3699, 3700, 3701, 3702, 3703, 3704, 3705, 3706, 
-  3707, 3708, 3709, 3710, 3711, 3712, 3713, 3714, 
-  3715, 3716, 3717, 3718, 3719, 3720, 3721, 3722, 
-  3723, 3724, 3725, 3726, 3727, 3728, 3729, 3730, 
-  3731, 3732, 3733, 3734, 3735, 3736, 3737, 3738, 
-  3739, 3740, 3741, 3742, 3743, 3744, 3745, 3746, 
-  3747, 3748, 3749, 3750, 3751, 3752, 3753, 3754, 
-  3755, 3756, 3757, 3758, 3759, 3760, 3761, 3762, 
-  3763, 3764, 3765, 3766, 3767, 3768, 3769, 3770, 
-  3771, 3772, 3773, 3774, 3775, 3776, 3777, 3778, 
-  3779, 3780, 3781, 3782, 3783, 3784, 3785, 3786, 
-  3787, 3788, 3789, 3790, 3791, 3792, 3793, 3794, 
-  3795, 3796, 3797, 3798, 3799, 3800, 3801, 3802, 
-  3803, 3804, 3805, 3806, 3807, 3808, 3809, 3810, 
-  3811, 3812, 3813, 3814, 3815, 3816, 3817, 3818, 
-  3819, 3820, 3821, 3822, 3823, 3824, 3825, 3826, 
-  3827, 3828, 3829, 3830, 3831, 3832, 3833, 3834, 
-  3835, 3836, 3837, 3838, 3839, 3840, 3841, 3842, 
-  3843, 3844, 3845, 3846, 3847, 3848, 3849, 3850, 
-  3851, 3852, 3853, 3854, 3855, 3856, 3857, 3858, 
-  3859, 3860, 3861, 3862, 3863, 3864, 3865, 3866, 
-  3867, 3868, 3869, 3870, 3871, 3872, 3873, 3874, 
-  3875, 3876, 3877, 3878, 3879, 3880, 3881, 3882, 
-  3883, 3884, 3885, 3886, 3887, 3888, 3889, 3890, 
-  3891, 3892, 3893, 3894, 3895, 3896, 3897, 3898, 
-  3899, 3900, 3901, 3902, 3903, 3904, 3905, 3906, 
-  3907, 3908, 3909, 3910, 3911, 3912, 3913, 3914, 
-  3915, 3916, 3917, 3918, 3919, 3920, 3921, 3922, 
-  3923, 3924, 3925, 3926, 3927, 3928, 3929, 3930, 
-  3931, 3932, 3933, 3934, 3935, 3936, 3937, 3938, 
-  3939, 3940, 3941, 3942, 3943, 3944, 3945, 3946, 
-  3947, 3948, 3949, 3950, 3951, 3952, 3953, 3954, 
-  3955, 3956, 3957, 3958, 3959, 3960, 3961, 3962, 
-  3963, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3226, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 0, 0, 
-  0, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 595, 595, 595, 595, 595, 595, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 595, 8, 8, 
-  8, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 345, 345, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3964, 3965, 3966, 3967, 3968, 3969, 3970, 
-  3971, 3972, 3973, 3974, 3975, 3976, 3977, 3978, 
-  3979, 3980, 3981, 3982, 3983, 3984, 3985, 3986, 
-  3987, 3988, 3989, 3990, 3991, 3992, 3993, 3994, 
-  3995, 3996, 3997, 3998, 3999, 4000, 4001, 4002, 
-  4003, 4004, 4005, 4006, 4007, 4008, 4009, 345, 
-  614, 914, 914, 914, 8, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 8, 
-  594, 4010, 4011, 4012, 4013, 4014, 4015, 4016, 
-  4017, 4018, 4019, 4020, 4021, 4022, 4023, 4024, 
-  4025, 4026, 4027, 4028, 4029, 4030, 4031, 4032, 
-  4033, 4034, 4035, 4036, 4037, 4038, 4039, 614, 
-  614, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 614, 614, 1119, 1119, 1119, 1119, 1119, 
-  1119, 0, 0, 0, 0, 0, 0, 0, 
-  0, 46, 46, 46, 46, 46, 46, 46, 
-  46, 46, 46, 46, 46, 46, 46, 46, 
-  46, 46, 46, 46, 46, 46, 46, 46, 
-  594, 594, 594, 594, 594, 594, 594, 594, 
-  594, 46, 46, 4040, 4041, 4042, 4043, 4044, 
-  4045, 4046, 4047, 4048, 4049, 4050, 4051, 4052, 
-  4053, 4054, 4055, 4056, 4057, 4058, 4059, 4060, 
-  4061, 4062, 4063, 4064, 4065, 4066, 4067, 4068, 
-  4069, 4070, 4071, 4072, 4073, 4074, 4075, 4076, 
-  4077, 4078, 4079, 4080, 4081, 4082, 4083, 4084, 
-  4085, 4086, 4087, 4088, 4089, 4090, 4091, 4092, 
-  4093, 4094, 4095, 4096, 4097, 4098, 4099, 4100, 
-  4101, 4102, 4103, 4104, 4105, 4106, 4107, 4108, 
-  4109, 4110, 4111, 4112, 4113, 4114, 4115, 4116, 
-  4117, 4118, 4119, 4120, 4121, 4122, 4123, 4124, 
-  4125, 4126, 4127, 4128, 4129, 4130, 4131, 4132, 
-  4133, 4134, 4135, 4136, 4137, 4138, 4139, 4140, 
-  4141, 594, 4142, 4142, 4143, 4144, 4145, 4146, 
-  345, 4147, 4148, 4149, 4150, 4151, 4152, 4153, 
-  4154, 4155, 4156, 4157, 4158, 4159, 4160, 4161, 
-  4162, 4163, 4164, 4165, 4166, 4167, 4168, 4169, 
-  4170, 4171, 4172, 4173, 4174, 4175, 4176, 4177, 
-  4178, 4179, 4180, 4181, 4182, 4183, 4184, 4185, 
-  4186, 4187, 4188, 4189, 4190, 4191, 4192, 4193, 
-  4194, 4195, 4196, 4197, 4198, 4199, 4200, 4201, 
-  4202, 4203, 4204, 4205, 0, 0, 0, 0, 
-  0, 4206, 4207, 0, 4208, 0, 4209, 4210, 
-  4211, 4212, 4213, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 4214, 4215, 4216, 4217, 4218, 
-  345, 4219, 4220, 4221, 345, 345, 345, 345, 
-  345, 345, 345, 1225, 345, 345, 345, 1261, 
-  345, 345, 345, 345, 1225, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1230, 1230, 1225, 1225, 
-  1230, 76, 76, 76, 76, 1299, 0, 0, 
-  0, 1258, 1258, 1258, 1258, 1258, 1258, 913, 
-  913, 10, 83, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 8, 8, 8, 
-  8, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1230, 1230, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1261, 1225, 0, 
-  0, 0, 0, 0, 0, 0, 0, 1119, 
-  1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 345, 345, 345, 345, 345, 
-  345, 1119, 1119, 1119, 345, 1119, 345, 345, 
-  1225, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 1225, 
-  1225, 1225, 1225, 1225, 627, 627, 627, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1230, 1537, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1119, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 
-  1439, 1439, 1439, 1439, 1439, 1439, 0, 0, 
-  0, 1225, 1225, 1225, 1230, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1249, 1230, 1230, 1225, 
-  1225, 1225, 1225, 1230, 1230, 1225, 1225, 1230, 
-  1230, 1537, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1119, 1119, 1119, 1119, 1119, 1119, 0, 
-  595, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 1119, 
-  1119, 345, 345, 345, 345, 345, 1225, 595, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1230, 1230, 1225, 1225, 1230, 1230, 1225, 1225, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 1225, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1225, 1230, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 1119, 1119, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 595, 345, 345, 345, 345, 345, 345, 
-  913, 913, 913, 345, 1350, 1225, 1350, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 614, 345, 614, 614, 627, 345, 345, 
-  614, 614, 345, 345, 345, 345, 345, 614, 
-  614, 345, 614, 345, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 345, 345, 595, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1230, 1225, 1225, 1230, 
-  1230, 1119, 1119, 345, 595, 595, 1230, 1299, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 345, 345, 345, 345, 345, 345, 
-  0, 0, 345, 345, 345, 345, 345, 345, 
-  0, 0, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 4222, 4223, 4224, 4225, 4226, 4227, 4228, 
-  4229, 4230, 4231, 4232, 4233, 4234, 4235, 4236, 
-  4237, 4238, 4239, 4240, 4241, 4242, 4243, 4244, 
-  4245, 4246, 4247, 4248, 4249, 4250, 4251, 4252, 
-  4253, 4254, 4255, 4256, 4257, 4258, 4259, 4260, 
-  4261, 4262, 4263, 4264, 4142, 4265, 4266, 4267, 
-  4268, 4269, 4270, 4271, 4272, 4273, 4274, 4275, 
-  4276, 4277, 4278, 46, 46, 0, 0, 0, 
-  0, 4279, 4280, 4281, 4282, 4283, 4284, 4285, 
-  4286, 4287, 4288, 4289, 4290, 4291, 4292, 4293, 
-  4294, 4295, 4296, 4297, 4298, 4299, 4300, 4301, 
-  4302, 4303, 4304, 4305, 4306, 4307, 4308, 4309, 
-  4310, 4311, 4312, 4313, 4314, 4315, 4316, 4317, 
-  4318, 4319, 4320, 4321, 4322, 4323, 4324, 4325, 
-  4326, 4327, 4328, 4329, 4330, 4331, 4332, 4333, 
-  4334, 4335, 4336, 4337, 4338, 4339, 4340, 4341, 
-  4342, 4343, 4344, 4345, 4346, 4347, 4348, 4349, 
-  4350, 4351, 4352, 4353, 4354, 4355, 4356, 4357, 
-  4358, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1230, 1230, 1225, 1230, 
-  1230, 1225, 1230, 1230, 1119, 1230, 1299, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, 
-  4360, 4360, 4360, 4360, 4360, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, 
-  0, 0, 0, 0, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, 
-  1443, 1443, 1443, 1443, 1443, 0, 0, 0, 
-  0, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, 
-  4361, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4363, 4364, 4365, 4366, 4367, 4368, 4369, 
-  4370, 4370, 4371, 4372, 4373, 4374, 4375, 4376, 
-  4377, 4378, 4379, 4380, 4381, 4382, 4383, 4384, 
-  4385, 4386, 4387, 4388, 4389, 4390, 4391, 4392, 
-  4393, 4394, 4395, 4396, 4397, 4398, 4399, 4400, 
-  4401, 4402, 4403, 4404, 4405, 4406, 4407, 4408, 
-  4409, 4410, 4411, 4412, 4413, 4414, 4415, 4416, 
-  4417, 4418, 4419, 4420, 4421, 4422, 4423, 4424, 
-  4425, 4426, 4427, 4428, 4429, 4430, 4431, 4432, 
-  4433, 4434, 4435, 4436, 4437, 4438, 4439, 4440, 
-  4441, 4442, 4443, 4444, 4445, 4446, 4447, 4448, 
-  4449, 4450, 4451, 4452, 4453, 4382, 4454, 4455, 
-  4456, 4457, 4458, 4459, 4460, 4461, 4462, 4463, 
-  4464, 4465, 4466, 4467, 4468, 4469, 4470, 4471, 
-  4472, 4473, 4474, 4475, 4476, 4477, 4478, 4479, 
-  4480, 4481, 4482, 4483, 4484, 4485, 4486, 4487, 
-  4488, 4489, 4490, 4491, 4492, 4493, 4494, 4495, 
-  4496, 4497, 4498, 4499, 4500, 4501, 4502, 4503, 
-  4504, 4505, 4506, 4507, 4508, 4509, 4510, 4511, 
-  4512, 4513, 4514, 4515, 4516, 4517, 4518, 4519, 
-  4520, 4521, 4472, 4522, 4523, 4524, 4525, 4526, 
-  4527, 4528, 4529, 4456, 4530, 4531, 4532, 4533, 
-  4534, 4535, 4536, 4537, 4538, 4539, 4540, 4541, 
-  4542, 4543, 4544, 4545, 4546, 4547, 4548, 4549, 
-  4382, 4550, 4551, 4552, 4553, 4554, 4555, 4556, 
-  4557, 4558, 4559, 4560, 4561, 4562, 4563, 4564, 
-  4565, 4566, 4567, 4568, 4569, 4570, 4571, 4572, 
-  4573, 4574, 4575, 4576, 4458, 4577, 4578, 4579, 
-  4580, 4581, 4582, 4583, 4584, 4585, 4586, 4587, 
-  4588, 4589, 4590, 4591, 4592, 4593, 4594, 4595, 
-  4596, 4597, 4598, 4599, 4600, 4601, 4602, 4603, 
-  4604, 4605, 4606, 4607, 4608, 4609, 4610, 4611, 
-  4612, 4613, 4614, 4615, 4616, 4617, 4618, 4619, 
-  4620, 4621, 4622, 4623, 4624, 4625, 4626, 3227, 
-  3227, 4627, 3227, 4628, 3227, 3227, 4629, 4630, 
-  4631, 4632, 4633, 4634, 4635, 4636, 4637, 4638, 
-  3227, 4639, 3227, 4640, 3227, 3227, 4641, 4642, 
-  3227, 3227, 3227, 4643, 4644, 4645, 4646, 4647, 
-  4648, 4649, 4650, 4651, 4652, 4653, 4654, 4655, 
-  4656, 4657, 4658, 4659, 4660, 4661, 4662, 4663, 
-  4664, 4665, 4666, 4667, 4668, 4669, 4670, 4671, 
-  4672, 4673, 4674, 4675, 4676, 4677, 4678, 4679, 
-  4680, 4681, 4682, 4683, 4684, 4685, 4686, 4687, 
-  4511, 4688, 4689, 4690, 4691, 4692, 4693, 4693, 
-  4694, 4695, 4696, 4697, 4698, 4699, 4700, 4701, 
-  4641, 4702, 4703, 4704, 4705, 4706, 4707, 0, 
-  0, 4708, 4709, 4710, 4711, 4712, 4713, 4714, 
-  4715, 4655, 4716, 4717, 4718, 4627, 4719, 4720, 
-  4721, 4722, 4723, 4724, 4725, 4726, 4727, 4728, 
-  4729, 4730, 4664, 4731, 4665, 4732, 4733, 4734, 
-  4735, 4736, 4628, 4403, 4737, 4738, 4739, 4473, 
-  4560, 4740, 4741, 4672, 4742, 4673, 4743, 4744, 
-  4745, 4630, 4746, 4747, 4748, 4749, 4750, 4631, 
-  4751, 4752, 4753, 4754, 4755, 4756, 4687, 4757, 
-  4758, 4511, 4759, 4691, 4760, 4761, 4762, 4763, 
-  4764, 4696, 4765, 4640, 4766, 4697, 4454, 4767, 
-  4698, 4768, 4700, 4769, 4770, 4771, 4772, 4773, 
-  4702, 4636, 4774, 4703, 4775, 4704, 4776, 4370, 
-  4777, 4778, 4779, 4780, 4781, 4782, 4783, 4784, 
-  4785, 4786, 4787, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 4788, 4789, 4790, 4791, 4792, 4793, 4794, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 4795, 4796, 4797, 4798, 
-  4799, 0, 0, 0, 0, 0, 4800, 4801, 
-  4802, 4803, 4804, 4805, 4806, 4807, 4808, 4809, 
-  4810, 4811, 4812, 4813, 4814, 4815, 4816, 4817, 
-  4818, 4819, 4820, 4821, 4822, 4823, 4824, 4825, 
-  0, 4826, 4827, 4828, 4829, 4830, 0, 4831, 
-  0, 4832, 4833, 0, 4834, 4835, 0, 4836, 
-  4837, 4838, 4839, 4840, 4841, 4842, 4843, 4844, 
-  4845, 4846, 4847, 4848, 4849, 4850, 4851, 4852, 
-  4853, 4854, 4855, 4856, 4857, 4858, 4859, 4860, 
-  4861, 4862, 4863, 4864, 4865, 4866, 4867, 4868, 
-  4869, 4870, 4871, 4872, 4873, 4874, 4875, 4876, 
-  4877, 4878, 4879, 4880, 4881, 4882, 4883, 4884, 
-  4885, 4886, 4887, 4888, 4889, 4890, 4891, 4892, 
-  4893, 4894, 4895, 4896, 4897, 4898, 4899, 4900, 
-  4901, 4902, 4903, 4904, 4905, 4906, 4907, 4908, 
-  4909, 4910, 4911, 4912, 4913, 4914, 4915, 4916, 
-  4917, 4918, 4919, 4920, 4921, 4922, 4923, 4924, 
-  4925, 4926, 4927, 4928, 4929, 4930, 4931, 4932, 
-  4933, 4934, 4935, 4936, 4937, 4938, 4939, 4940, 
-  4941, 4942, 4943, 1229, 1229, 1229, 1229, 1229, 
-  1229, 1229, 1229, 1229, 1229, 1229, 1229, 1229, 
-  1229, 1229, 1229, 1229, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 4944, 4945, 4946, 4947, 
-  4948, 4949, 4950, 4951, 4952, 4953, 4954, 4955, 
-  4956, 4957, 4958, 4959, 4960, 4961, 4962, 4963, 
-  4964, 4965, 4966, 4967, 4968, 4969, 4970, 4971, 
-  4972, 4973, 4974, 4975, 4976, 4977, 4978, 4979, 
-  4980, 4981, 4982, 4983, 4984, 4985, 4986, 4987, 
-  4988, 4989, 4990, 4991, 4982, 4992, 4993, 4994, 
-  4995, 4996, 4997, 4998, 4999, 5000, 5001, 5002, 
-  5003, 5004, 5005, 5006, 5007, 5008, 5009, 5010, 
-  5011, 5012, 5013, 5014, 5015, 5016, 5017, 5018, 
-  5019, 5020, 5021, 5022, 5023, 5024, 5025, 5026, 
-  5027, 5028, 5029, 5030, 5031, 5032, 5033, 5034, 
-  5035, 5036, 5037, 5038, 5039, 5040, 5041, 5042, 
-  5043, 5044, 5045, 5046, 5047, 5048, 5049, 5050, 
-  5051, 5052, 5053, 5054, 5055, 5056, 5057, 5058, 
-  5059, 5060, 5061, 5062, 5063, 5064, 5065, 5066, 
-  5067, 5068, 5069, 5070, 5071, 5072, 5073, 5074, 
-  5075, 5076, 5077, 5078, 5079, 5080, 5081, 5082, 
-  5083, 5084, 5085, 5086, 5087, 5088, 5089, 5090, 
-  5091, 4983, 5092, 5093, 5094, 5095, 5096, 5097, 
-  5098, 5099, 5100, 5101, 5102, 5103, 5104, 5105, 
-  5106, 5107, 5108, 5109, 5110, 5111, 5112, 5113, 
-  5114, 5115, 5116, 5117, 5118, 5119, 5120, 5121, 
-  5122, 5123, 5124, 5125, 5126, 5127, 5128, 5129, 
-  5130, 5131, 5132, 5133, 5134, 5135, 5136, 5137, 
-  5138, 5139, 5140, 5141, 5142, 5143, 5144, 5145, 
-  5146, 5147, 5148, 5149, 5150, 5151, 5152, 5153, 
-  5154, 5155, 5156, 5157, 5158, 5159, 5160, 5161, 
-  5162, 5163, 5164, 5165, 5166, 5167, 5168, 5169, 
-  5170, 5171, 5172, 5173, 5174, 5175, 5176, 5177, 
-  5178, 5179, 5180, 5181, 5182, 5183, 5184, 5185, 
-  5186, 5187, 5188, 5189, 5190, 5191, 5192, 5193, 
-  5194, 5195, 5196, 5197, 5198, 5199, 5200, 5201, 
-  5202, 5203, 5204, 5205, 5206, 5207, 5208, 5209, 
-  5210, 5211, 5212, 5213, 5214, 5215, 5216, 5217, 
-  5218, 5219, 5220, 5221, 5222, 5223, 5224, 5225, 
-  5226, 5227, 5228, 5229, 5230, 5231, 5232, 5233, 
-  5234, 5235, 5236, 5237, 5238, 5239, 5240, 5241, 
-  5242, 5243, 5244, 5245, 5246, 5247, 5248, 5249, 
-  5250, 5251, 5252, 5253, 5254, 5255, 5256, 5257, 
-  5258, 5259, 5260, 5261, 5262, 5263, 5264, 5265, 
-  5266, 5267, 5268, 5269, 5270, 5271, 5272, 5273, 
-  5274, 5275, 5276, 5277, 5278, 5279, 5280, 5281, 
-  5282, 5283, 5284, 5285, 5286, 5287, 5288, 5289, 
-  5290, 5291, 5292, 5293, 5294, 5295, 5296, 5297, 
-  5298, 5299, 5300, 5301, 5302, 5303, 5304, 5305, 
-  2311, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 5306, 5307, 5308, 5309, 5310, 5311, 5312, 
-  5313, 5314, 5315, 5316, 5317, 5318, 5319, 5320, 
-  5321, 5322, 5323, 5324, 5325, 5326, 5327, 5328, 
-  5329, 5330, 5331, 5332, 5333, 5334, 5335, 5336, 
-  5337, 5338, 5339, 5340, 5341, 5342, 5343, 5344, 
-  5345, 5346, 5347, 5348, 5349, 5350, 5351, 5352, 
-  5353, 5354, 5355, 5356, 5357, 5358, 5359, 5360, 
-  5361, 5362, 5363, 5364, 5365, 5366, 5367, 5368, 
-  5369, 0, 0, 5370, 5371, 5372, 5373, 5374, 
-  5375, 5376, 5377, 5378, 5379, 5380, 5381, 5382, 
-  5383, 5384, 5385, 5386, 5387, 5388, 5389, 5390, 
-  5391, 5392, 5393, 5394, 5395, 5396, 5397, 5398, 
-  5399, 5400, 5401, 5402, 5403, 5404, 5405, 5406, 
-  5407, 5408, 5409, 5410, 5411, 5412, 5413, 5414, 
-  5415, 5416, 5417, 5418, 5419, 5420, 5421, 5422, 
-  5423, 0, 0, 0, 0, 0, 0, 0, 
-  76, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5424, 5425, 5426, 5427, 5428, 5429, 5430, 
-  5431, 5432, 5433, 5434, 5435, 5436, 76, 76, 
-  76, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 5437, 5438, 5439, 5440, 5441, 5442, 5443, 
-  5444, 5445, 5446, 0, 0, 0, 0, 0, 
-  0, 614, 614, 614, 614, 614, 614, 614, 
-  627, 627, 627, 627, 627, 627, 627, 614, 
-  614, 5447, 5448, 5449, 5450, 5450, 5451, 5452, 
-  5453, 5454, 5455, 5456, 5457, 5458, 5459, 5460, 
-  5461, 5462, 5463, 5464, 5465, 5466, 3225, 3225, 
-  5467, 5468, 5469, 5469, 5469, 5469, 5470, 5470, 
-  5470, 5471, 5472, 5473, 0, 5474, 5475, 5476, 
-  5477, 5478, 5479, 5480, 5481, 5482, 5483, 5484, 
-  5485, 5486, 5487, 5488, 5489, 5490, 5491, 5492, 
-  0, 5493, 5494, 5495, 5496, 0, 0, 0, 
-  0, 5497, 5498, 5499, 1191, 5500, 0, 5501, 
-  5502, 5503, 5504, 5505, 5506, 5507, 5508, 5509, 
-  5510, 5511, 5512, 5513, 5514, 5515, 5516, 5517, 
-  5518, 5519, 5520, 5521, 5522, 5523, 5524, 5525, 
-  5526, 5527, 5528, 5529, 5530, 5531, 5532, 5533, 
-  5534, 5535, 5536, 5537, 5538, 5539, 5540, 5541, 
-  5542, 5543, 5544, 5545, 5546, 5547, 5548, 5549, 
-  5550, 5551, 5552, 5553, 5554, 5555, 5556, 5557, 
-  5558, 5559, 5560, 5561, 5562, 5563, 5564, 5565, 
-  5566, 5567, 5568, 5569, 5570, 5571, 5572, 5573, 
-  5574, 5575, 5576, 5577, 5578, 5579, 5580, 5581, 
-  5582, 5583, 5584, 5585, 5586, 5587, 5588, 5589, 
-  5590, 5591, 5592, 5593, 5594, 5595, 5596, 5597, 
-  5598, 5599, 5600, 5601, 5602, 5603, 5604, 5605, 
-  5606, 5607, 5608, 5609, 5610, 5611, 5612, 5613, 
-  5614, 5615, 5616, 5617, 5618, 5619, 5620, 5621, 
-  5622, 5623, 5624, 5625, 5626, 5627, 5628, 5629, 
-  5630, 5631, 5632, 5633, 5634, 5635, 0, 0, 
-  1538, 0, 5636, 5637, 5638, 5639, 5640, 5641, 
-  5642, 5643, 5644, 5645, 5646, 5647, 5648, 5649, 
-  5650, 5651, 5652, 5653, 5654, 5655, 5656, 5657, 
-  5658, 5659, 5660, 5661, 5662, 5663, 5664, 5665, 
-  5666, 5667, 5668, 5669, 5670, 5671, 5672, 5673, 
-  5674, 5675, 5676, 5677, 5678, 5679, 5680, 5681, 
-  5682, 5683, 5684, 5685, 5686, 5687, 5688, 5689, 
-  5690, 5691, 5692, 5693, 5694, 5695, 5696, 5697, 
-  5698, 5699, 5700, 5701, 5702, 5703, 5704, 5705, 
-  5706, 5707, 5708, 5709, 5710, 5711, 5712, 5713, 
-  5714, 5715, 5716, 5717, 5718, 5719, 5720, 5721, 
-  5722, 5723, 5724, 5725, 5726, 5727, 5728, 5729, 
-  5730, 5731, 5732, 5733, 5734, 5735, 5736, 5737, 
-  5738, 5739, 5740, 5741, 5742, 5743, 5744, 5745, 
-  5746, 5747, 5748, 5749, 5750, 5751, 5752, 5753, 
-  5754, 5755, 5756, 5757, 5758, 5759, 5760, 5761, 
-  5762, 5763, 5764, 5765, 5766, 5767, 5768, 5769, 
-  5770, 5771, 5772, 5773, 5774, 5775, 5776, 5777, 
-  5778, 5779, 5780, 5781, 5782, 5783, 5784, 5785, 
-  5786, 5787, 5788, 5789, 5790, 5791, 5792, 5793, 
-  5794, 5795, 5796, 5797, 5798, 5799, 5800, 5801, 
-  5802, 5803, 5804, 5805, 5806, 5807, 5808, 5809, 
-  5810, 5811, 5812, 5813, 5814, 5815, 5816, 5817, 
-  5818, 5819, 5820, 5821, 5822, 5823, 5824, 5825, 
-  0, 0, 0, 5826, 5827, 5828, 5829, 5830, 
-  5831, 0, 0, 5832, 5833, 5834, 5835, 5836, 
-  5837, 0, 0, 5838, 5839, 5840, 5841, 5842, 
-  5843, 0, 0, 5844, 5845, 5846, 0, 0, 
-  0, 5847, 5848, 5849, 5850, 5851, 5852, 5853, 
-  0, 5854, 5855, 5856, 5857, 5858, 5859, 5860, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 5861, 5861, 5861, 76, 76, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 0, 345, 345, 0, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 0, 0, 0, 0, 
-  0, 1119, 8, 1119, 0, 0, 0, 0, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 0, 0, 0, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 5862, 5862, 5862, 5862, 5862, 5862, 5862, 
-  5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, 
-  5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, 
-  5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, 
-  5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, 
-  5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, 
-  5862, 5862, 5862, 5862, 5862, 5862, 1288, 1288, 
-  1288, 1288, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 1288, 1288, 76, 913, 913, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 0, 0, 
-  0, 76, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 627, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 627, 5863, 5863, 5863, 5863, 5863, 5863, 
-  5863, 5863, 5863, 5863, 5863, 5863, 5863, 5863, 
-  5863, 5863, 5863, 5863, 5863, 5863, 5863, 5863, 
-  5863, 5863, 5863, 5863, 5863, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 1258, 1258, 1258, 1258, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1536, 345, 345, 345, 345, 345, 
-  345, 345, 345, 1536, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 614, 
-  614, 614, 614, 614, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 1119, 1536, 1536, 1536, 1536, 1536, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5864, 5865, 5866, 5867, 5868, 5869, 5870, 
-  5871, 5872, 5873, 5874, 5875, 5876, 5877, 5878, 
-  5879, 5880, 5881, 5882, 5883, 5884, 5885, 5886, 
-  5887, 5888, 5889, 5890, 5891, 5892, 5893, 5894, 
-  5895, 5896, 5897, 5898, 5899, 5900, 5901, 5902, 
-  5903, 5904, 5905, 5906, 5907, 5908, 5909, 5910, 
-  5911, 5912, 5913, 5914, 5915, 5916, 5917, 5918, 
-  5919, 5920, 5921, 5922, 5923, 5924, 5925, 5926, 
-  5927, 5928, 5929, 5930, 5931, 5932, 5933, 5934, 
-  5935, 5936, 5937, 5938, 5939, 5940, 5941, 5942, 
-  5943, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 5944, 5945, 5946, 5947, 5948, 5949, 5950, 
-  5951, 5952, 5953, 5954, 5955, 5956, 5957, 5958, 
-  5959, 5960, 5961, 5962, 5963, 5964, 5965, 5966, 
-  5967, 5968, 5969, 5970, 5971, 5972, 5973, 5974, 
-  5975, 5976, 5977, 5978, 5979, 0, 0, 0, 
-  0, 5980, 5981, 5982, 5983, 5984, 5985, 5986, 
-  5987, 5988, 5989, 5990, 5991, 5992, 5993, 5994, 
-  5995, 5996, 5997, 5998, 5999, 6000, 6001, 6002, 
-  6003, 6004, 6005, 6006, 6007, 6008, 6009, 6010, 
-  6011, 6012, 6013, 6014, 6015, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1119, 6016, 6017, 6018, 6019, 6020, 6021, 6022, 
-  6023, 6024, 6025, 6026, 0, 6027, 6028, 6029, 
-  6030, 6031, 6032, 6033, 6034, 6035, 6036, 6037, 
-  6038, 6039, 6040, 6041, 0, 6042, 6043, 6044, 
-  6045, 6046, 6047, 6048, 0, 6049, 6050, 0, 
-  6051, 6052, 6053, 6054, 6055, 6056, 6057, 6058, 
-  6059, 6060, 6061, 0, 6062, 6063, 6064, 6065, 
-  6066, 6067, 6068, 6069, 6070, 6071, 6072, 6073, 
-  6074, 6075, 6076, 0, 6077, 6078, 6079, 6080, 
-  6081, 6082, 6083, 0, 6084, 6085, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6086, 6087, 6088, 6089, 6090, 6091, 0, 
-  6092, 6093, 6094, 6095, 6096, 6097, 6098, 6099, 
-  6100, 6101, 6102, 6103, 6104, 6105, 6106, 6107, 
-  6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, 
-  6116, 6117, 6118, 6119, 6120, 6121, 6122, 6123, 
-  6124, 6125, 6126, 6127, 6128, 6129, 6130, 6131, 
-  6132, 6133, 0, 6134, 6135, 6136, 6137, 6138, 
-  6139, 6140, 6141, 6142, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 0, 
-  0, 1182, 0, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, 
-  1182, 1182, 0, 0, 0, 1182, 0, 0, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, 
-  1179, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  6144, 6144, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 0, 1182, 1182, 0, 
-  0, 0, 0, 0, 6143, 6143, 6143, 6143, 
-  6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 6143, 
-  6143, 6143, 6143, 6143, 6143, 0, 0, 0, 
-  8, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 0, 0, 0, 0, 0, 
-  1179, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 0, 0, 0, 0, 6143, 6143, 1182, 
-  1182, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 0, 0, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 1182, 1225, 1225, 1225, 0, 1225, 1225, 
-  0, 0, 0, 0, 0, 1225, 627, 1225, 
-  614, 1182, 1182, 1182, 1182, 0, 1182, 1182, 
-  1182, 0, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, 
-  0, 614, 640, 627, 0, 0, 0, 0, 
-  1299, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 6143, 0, 0, 0, 0, 0, 0, 
-  0, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 
-  1179, 1179, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, 
-  1179, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, 
-  6143, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 6144, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 614, 627, 
-  0, 0, 0, 0, 6143, 6143, 6143, 6143, 
-  6143, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, 
-  0, 0, 8, 8, 8, 8, 8, 8, 
-  8, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, 
-  0, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 0, 0, 0, 0, 
-  0, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 0, 0, 0, 0, 0, 
-  0, 0, 1179, 1179, 1179, 1179, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6145, 6146, 6147, 6148, 6149, 6150, 6151, 
-  6152, 6153, 6154, 6155, 6156, 6157, 6158, 6159, 
-  6160, 6161, 6162, 6163, 6164, 6165, 6166, 6167, 
-  6168, 6169, 6170, 6171, 6172, 6173, 6174, 6175, 
-  6176, 6177, 6178, 6179, 6180, 6181, 6182, 6183, 
-  6184, 6185, 6186, 6187, 6188, 6189, 6190, 6191, 
-  6192, 6193, 6194, 6195, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6196, 6197, 6198, 6199, 6200, 6201, 6202, 
-  6203, 6204, 6205, 6206, 6207, 6208, 6209, 6210, 
-  6211, 6212, 6213, 6214, 6215, 6216, 6217, 6218, 
-  6219, 6220, 6221, 6222, 6223, 6224, 6225, 6226, 
-  6227, 6228, 6229, 6230, 6231, 6232, 6233, 6234, 
-  6235, 6236, 6237, 6238, 6239, 6240, 6241, 6242, 
-  6243, 6244, 6245, 6246, 0, 0, 0, 0, 
-  0, 0, 0, 6143, 6143, 6143, 6143, 6143, 
-  6143, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 614, 614, 614, 
-  614, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1209, 1209, 1209, 1209, 1209, 1209, 1209, 
-  1209, 1209, 1209, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6247, 6247, 6247, 6247, 6247, 6247, 6247, 
-  6247, 6247, 6247, 6247, 6247, 6247, 6247, 6247, 
-  6247, 6247, 6247, 6247, 6247, 6247, 6247, 6247, 
-  6247, 6247, 6247, 6247, 6247, 6247, 6247, 6247, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 0, 614, 614, 1177, 0, 
-  0, 1182, 1182, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 627, 627, 
-  627, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  1182, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 
-  1191, 1191, 1191, 1191, 1191, 1191, 1191, 627, 
-  627, 614, 614, 614, 627, 614, 627, 627, 
-  627, 627, 6248, 6248, 6248, 6248, 1186, 1186, 
-  1186, 1186, 1186, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 614, 627, 614, 627, 1179, 
-  1179, 1179, 1179, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, 
-  6143, 6143, 6143, 6143, 6143, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1230, 1225, 1230, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1261, 
-  1119, 1119, 1119, 1119, 1119, 1119, 1119, 0, 
-  0, 0, 0, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, 
-  1288, 1288, 1288, 1288, 1288, 1288, 1288, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1299, 345, 345, 1225, 1225, 345, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1299, 1225, 1225, 1230, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 6249, 6250, 6251, 6252, 345, 345, 
-  345, 345, 345, 345, 345, 345, 6253, 345, 
-  345, 345, 345, 345, 6254, 345, 345, 345, 
-  345, 1230, 1230, 1230, 1225, 1225, 1225, 1225, 
-  1230, 1230, 1261, 6255, 1119, 1119, 6256, 1119, 
-  1119, 1119, 1119, 1225, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 6256, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 614, 614, 614, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  6257, 1225, 1225, 1225, 1225, 1230, 1225, 6258, 
-  6259, 1225, 6260, 6261, 1299, 1299, 0, 1248, 
-  1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1119, 1119, 1119, 1119, 345, 1230, 1230, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1249, 1119, 1119, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1225, 1225, 1230, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1230, 1230, 1230, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1230, 1537, 345, 1306, 1306, 345, 1119, 1119, 
-  1119, 1119, 1225, 1249, 1225, 1225, 1119, 1230, 
-  1225, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 345, 1119, 345, 1119, 1119, 
-  1119, 0, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 0, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1230, 1230, 1230, 
-  1225, 1225, 1225, 1230, 1230, 1225, 1537, 1249, 
-  1225, 1119, 1119, 1119, 1119, 1119, 1119, 1225, 
-  345, 345, 1225, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 0, 345, 345, 345, 345, 0, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1119, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  1225, 1230, 1230, 1230, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1249, 1299, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 1225, 1225, 1230, 1230, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  345, 345, 0, 0, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 0, 345, 345, 
-  345, 345, 345, 0, 1249, 1249, 345, 6262, 
-  1230, 1225, 1230, 1230, 1230, 1230, 0, 0, 
-  6263, 1230, 0, 0, 6264, 6265, 1537, 0, 
-  0, 345, 0, 0, 0, 0, 0, 0, 
-  6266, 0, 0, 0, 0, 0, 345, 345, 
-  345, 345, 345, 1230, 1230, 0, 0, 614, 
-  614, 614, 614, 614, 614, 614, 0, 0, 
-  0, 614, 614, 614, 614, 614, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 1230, 1230, 
-  1230, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1230, 1230, 1261, 1225, 1225, 1230, 1249, 
-  345, 345, 345, 345, 1119, 1119, 1119, 1119, 
-  1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1119, 1119, 0, 1119, 614, 
-  345, 345, 345, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 6267, 1230, 1230, 1225, 1225, 1225, 1225, 
-  1225, 1225, 6268, 6269, 6270, 6271, 6272, 6273, 
-  1225, 1225, 1230, 1261, 1249, 345, 345, 1119, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  6274, 1230, 1230, 1225, 1225, 1225, 1225, 0, 
-  0, 6275, 6276, 6277, 6278, 1225, 1225, 1230, 
-  1261, 1249, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 345, 345, 345, 345, 1225, 1225, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 1230, 1230, 1230, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1230, 1230, 1225, 1230, 
-  1261, 1225, 1119, 1119, 1119, 345, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 8, 8, 8, 8, 8, 8, 8, 
-  8, 8, 8, 8, 8, 8, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1225, 1230, 1225, 1230, 
-  1230, 1225, 1225, 1225, 1225, 1225, 1225, 1537, 
-  1249, 345, 1119, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 0, 0, 1225, 1225, 
-  1225, 1350, 1350, 1225, 1225, 1225, 1225, 1230, 
-  1225, 1225, 1225, 1225, 1299, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1258, 1258, 1119, 1119, 1119, 
-  913, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1230, 1230, 1230, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1230, 1261, 1249, 1119, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6279, 6280, 6281, 6282, 6283, 6284, 6285, 
-  6286, 6287, 6288, 6289, 6290, 6291, 6292, 6293, 
-  6294, 6295, 6296, 6297, 6298, 6299, 6300, 6301, 
-  6302, 6303, 6304, 6305, 6306, 6307, 6308, 6309, 
-  6310, 6311, 6312, 6313, 6314, 6315, 6316, 6317, 
-  6318, 6319, 6320, 6321, 6322, 6323, 6324, 6325, 
-  6326, 6327, 6328, 6329, 6330, 6331, 6332, 6333, 
-  6334, 6335, 6336, 6337, 6338, 6339, 6340, 6341, 
-  6342, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 345, 0, 0, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 6343, 1230, 1230, 1230, 1230, 6344, 0, 
-  1230, 6345, 0, 0, 1225, 1225, 1537, 1299, 
-  1306, 1230, 1306, 1230, 1249, 1119, 1119, 1119, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1230, 1230, 1230, 1225, 1225, 1225, 
-  1225, 0, 0, 1225, 1225, 1230, 1230, 1230, 
-  1230, 1261, 345, 1119, 345, 1230, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 1225, 1225, 1225, 1225, 1225, 1225, 
-  6346, 6346, 1225, 1225, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1225, 1299, 1225, 1225, 
-  1225, 1225, 1230, 1306, 1225, 1225, 1225, 1225, 
-  1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1299, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1230, 1230, 1225, 1225, 1225, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1306, 1306, 1306, 
-  1306, 1306, 1306, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1230, 1225, 1299, 1119, 1119, 1119, 345, 1119, 
-  1119, 1119, 1119, 1119, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1119, 1119, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  1230, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  0, 1225, 1225, 1225, 1225, 1225, 1225, 1230, 
-  6347, 345, 1119, 1119, 1119, 1119, 1119, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 0, 0, 
-  0, 1119, 1119, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 0, 1230, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1230, 1225, 1225, 1230, 1225, 1225, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 0, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1225, 1225, 1225, 1225, 1225, 1225, 
-  0, 0, 0, 1225, 0, 1225, 1225, 0, 
-  1225, 1225, 1225, 1249, 1225, 1299, 1299, 1306, 
-  1225, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 0, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 1230, 1230, 1230, 1230, 1230, 
-  0, 1225, 1225, 0, 1230, 1230, 1225, 1230, 
-  1299, 345, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 1225, 1225, 1230, 1230, 
-  1119, 1119, 0, 0, 0, 0, 0, 0, 
-  0, 1225, 1225, 1306, 1230, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 1230, 1230, 1225, 
-  1225, 1225, 1225, 1225, 0, 0, 0, 1230, 
-  1230, 1225, 1537, 1299, 1119, 1119, 1119, 1119, 
-  1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 
-  1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 76, 76, 
-  76, 76, 76, 76, 76, 76, 10, 10, 
-  10, 10, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, 
-  0, 1119, 1119, 1119, 1119, 1119, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 1119, 1119, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 6348, 6348, 6348, 6348, 6348, 6348, 6348, 
-  6348, 6348, 6348, 6348, 6348, 6348, 6348, 6348, 
-  6348, 1225, 345, 345, 345, 345, 345, 345, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 1119, 
-  1119, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 0, 
-  0, 640, 640, 640, 640, 640, 1119, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 614, 614, 614, 614, 614, 614, 614, 
-  1119, 1119, 1119, 1119, 1119, 913, 913, 913, 
-  913, 595, 595, 595, 595, 1119, 913, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 0, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 0, 0, 0, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6349, 6350, 6351, 6352, 6353, 6354, 6355, 
-  6356, 6357, 6358, 6359, 6360, 6361, 6362, 6363, 
-  6364, 6365, 6366, 6367, 6368, 6369, 6370, 6371, 
-  6372, 6373, 6374, 6375, 6376, 6377, 6378, 6379, 
-  6380, 6381, 6382, 6383, 6384, 6385, 6386, 6387, 
-  6388, 6389, 6390, 6391, 6392, 6393, 6394, 6395, 
-  6396, 6397, 6398, 6399, 6400, 6401, 6402, 6403, 
-  6404, 6405, 6406, 6407, 6408, 6409, 6410, 6411, 
-  6412, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1119, 1119, 1119, 1119, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 0, 0, 0, 0, 
-  1225, 345, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 
-  1230, 0, 0, 0, 0, 0, 0, 0, 
-  1225, 1225, 1225, 1225, 595, 595, 595, 595, 
-  595, 595, 595, 595, 595, 595, 595, 595, 
-  595, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3226, 3226, 3225, 3226, 1225, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6413, 6413, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3226, 3226, 3226, 3226, 0, 3226, 3226, 
-  3226, 3226, 3226, 3226, 3226, 0, 3226, 3226, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 3227, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 0, 0, 3227, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 3227, 3227, 3227, 
-  3227, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 0, 0, 913, 1225, 640, 
-  1119, 1538, 1538, 1538, 1538, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 0, 
-  0, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  0, 0, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  6414, 6415, 913, 913, 913, 913, 913, 6416, 
-  6417, 6418, 6419, 6420, 6421, 6422, 6423, 6424, 
-  640, 640, 640, 913, 913, 913, 6425, 6426, 
-  6427, 6428, 6429, 6430, 1538, 1538, 1538, 1538, 
-  1538, 1538, 1538, 1538, 627, 627, 627, 627, 
-  627, 627, 627, 627, 913, 913, 614, 614, 
-  614, 614, 614, 627, 627, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 614, 614, 614, 614, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 6431, 6432, 6433, 6434, 6435, 6436, 
-  6437, 6438, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 76, 76, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 614, 614, 614, 76, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 
-  1258, 1258, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6439, 6440, 6441, 6442, 6443, 6444, 6445, 
-  6446, 6447, 6448, 6449, 6450, 6451, 6452, 6453, 
-  6454, 6455, 6456, 6457, 6458, 6459, 6460, 6461, 
-  6462, 6463, 6464, 6465, 6466, 6467, 6468, 6469, 
-  6470, 6471, 6472, 6473, 6474, 6475, 6476, 6477, 
-  6478, 6479, 6480, 6481, 6482, 6483, 6484, 6485, 
-  6486, 6487, 6488, 6489, 6490, 6491, 6492, 6493, 
-  6494, 6495, 6496, 6497, 6498, 6499, 6500, 6501, 
-  6502, 6503, 6504, 6505, 6506, 6507, 6508, 6509, 
-  6510, 6511, 6512, 6513, 6514, 6515, 6516, 6517, 
-  6518, 6519, 6520, 6521, 6522, 6523, 0, 6524, 
-  6525, 6526, 6527, 6528, 6529, 6530, 6531, 6532, 
-  6533, 6534, 6535, 6536, 6537, 6538, 6539, 6540, 
-  6541, 6542, 6543, 6544, 6545, 6546, 6547, 6548, 
-  6549, 6550, 6551, 6552, 6553, 6554, 6555, 6556, 
-  6557, 6558, 6559, 6560, 6561, 6562, 6563, 6564, 
-  6565, 6566, 6567, 6568, 6569, 6570, 6571, 6572, 
-  6573, 6574, 6575, 6576, 6577, 6578, 6579, 6580, 
-  6581, 6582, 6583, 6584, 6585, 6586, 6587, 6588, 
-  6589, 6590, 6591, 6592, 6593, 6594, 0, 6595, 
-  6596, 0, 0, 6597, 0, 0, 6598, 6599, 
-  0, 0, 6600, 6601, 6602, 6603, 0, 6604, 
-  6605, 6606, 6607, 6608, 6609, 6610, 6611, 6612, 
-  6613, 6614, 6615, 0, 6616, 0, 6617, 6618, 
-  6619, 6620, 6621, 6622, 6623, 0, 6624, 6625, 
-  6626, 6627, 6628, 6629, 6630, 6631, 6632, 6633, 
-  6634, 6635, 6636, 6637, 6638, 6639, 6640, 6641, 
-  6642, 6643, 6644, 6645, 6646, 6647, 6648, 6649, 
-  6650, 6651, 6652, 6653, 6654, 6655, 6656, 6657, 
-  6658, 6659, 6660, 6661, 6662, 6663, 6664, 6665, 
-  6666, 6667, 6668, 6669, 6670, 6671, 6672, 6673, 
-  6674, 6675, 6676, 6677, 6678, 6679, 6680, 6681, 
-  6682, 6683, 6684, 6685, 6686, 6687, 6688, 0, 
-  6689, 6690, 6691, 6692, 0, 0, 6693, 6694, 
-  6695, 6696, 6697, 6698, 6699, 6700, 0, 6701, 
-  6702, 6703, 6704, 6705, 6706, 6707, 0, 6708, 
-  6709, 6710, 6711, 6712, 6713, 6714, 6715, 6716, 
-  6717, 6718, 6719, 6720, 6721, 6722, 6723, 6724, 
-  6725, 6726, 6727, 6728, 6729, 6730, 6731, 6732, 
-  6733, 6734, 6735, 0, 6736, 6737, 6738, 6739, 
-  0, 6740, 6741, 6742, 6743, 6744, 0, 6745, 
-  0, 0, 0, 6746, 6747, 6748, 6749, 6750, 
-  6751, 6752, 0, 6753, 6754, 6755, 6756, 6757, 
-  6758, 6759, 6760, 6761, 6762, 6763, 6764, 6765, 
-  6766, 6767, 6768, 6769, 6770, 6771, 6772, 6773, 
-  6774, 6775, 6776, 6777, 6778, 6779, 6780, 6781, 
-  6782, 6783, 6784, 6785, 6786, 6787, 6788, 6789, 
-  6790, 6791, 6792, 6793, 6794, 6795, 6796, 6797, 
-  6798, 6799, 6800, 6801, 6802, 6803, 6804, 6805, 
-  6806, 6807, 6808, 6809, 6810, 6811, 6812, 6813, 
-  6814, 6815, 6816, 6817, 6818, 6819, 6820, 6821, 
-  6822, 6823, 6824, 6825, 6826, 6827, 6828, 6829, 
-  6830, 6831, 6832, 6833, 6834, 6835, 6836, 6837, 
-  6838, 6839, 6840, 6841, 6842, 6843, 6844, 6845, 
-  6846, 6847, 6848, 6849, 6850, 6851, 6852, 6853, 
-  6854, 6855, 6856, 6857, 6858, 6859, 6860, 6861, 
-  6862, 6863, 6864, 6865, 6866, 6867, 6868, 6869, 
-  6870, 6871, 6872, 6873, 6874, 6875, 6876, 6877, 
-  6878, 6879, 6880, 6881, 6882, 6883, 6884, 6885, 
-  6886, 6887, 6888, 6889, 6890, 6891, 6892, 6893, 
-  6894, 6895, 6896, 6897, 6898, 6899, 6900, 6901, 
-  6902, 6903, 6904, 6905, 6906, 6907, 6908, 6909, 
-  6910, 6911, 6912, 6913, 6914, 6915, 6916, 6917, 
-  6918, 6919, 6920, 6921, 6922, 6923, 6924, 6925, 
-  6926, 6927, 6928, 6929, 6930, 6931, 6932, 6933, 
-  6934, 6935, 6936, 6937, 6938, 6939, 6940, 6941, 
-  6942, 6943, 6944, 6945, 6946, 6947, 6948, 6949, 
-  6950, 6951, 6952, 6953, 6954, 6955, 6956, 6957, 
-  6958, 6959, 6960, 6961, 6962, 6963, 6964, 6965, 
-  6966, 6967, 6968, 6969, 6970, 6971, 6972, 6973, 
-  6974, 6975, 6976, 6977, 6978, 6979, 6980, 6981, 
-  6982, 6983, 6984, 6985, 6986, 6987, 6988, 6989, 
-  6990, 6991, 6992, 6993, 6994, 6995, 6996, 6997, 
-  6998, 6999, 7000, 7001, 7002, 7003, 7004, 7005, 
-  7006, 7007, 7008, 7009, 7010, 7011, 7012, 7013, 
-  7014, 7015, 7016, 7017, 7018, 7019, 7020, 7021, 
-  7022, 7023, 7024, 7025, 7026, 7027, 7028, 7029, 
-  7030, 7031, 7032, 7033, 7034, 7035, 7036, 7037, 
-  7038, 7039, 7040, 7041, 7042, 7043, 7044, 7045, 
-  7046, 7047, 7048, 7049, 7050, 7051, 7052, 7053, 
-  7054, 7055, 7056, 7057, 7058, 7059, 7060, 7061, 
-  7062, 7063, 7064, 7065, 7066, 7067, 7068, 7069, 
-  7070, 7071, 7072, 7073, 7074, 7075, 7076, 7077, 
-  7078, 7079, 7080, 7081, 7082, 7083, 7084, 7085, 
-  7086, 7087, 7088, 7089, 7090, 7091, 7092, 0, 
-  0, 7093, 7094, 7095, 7096, 7097, 7098, 7099, 
-  7100, 7101, 7102, 7103, 7104, 7105, 7106, 7107, 
-  7108, 7109, 7110, 7111, 7112, 7113, 7114, 7115, 
-  7116, 7117, 7118, 7119, 7120, 7121, 7122, 7123, 
-  7124, 7125, 7126, 7127, 7128, 7129, 7130, 7131, 
-  7132, 7133, 7134, 7135, 7136, 7137, 7138, 7139, 
-  7140, 7141, 7142, 7143, 7144, 7145, 7146, 7147, 
-  7148, 7149, 7150, 7151, 7152, 7153, 7154, 7155, 
-  7156, 7157, 7158, 7159, 7160, 7161, 7162, 7163, 
-  7164, 7165, 7166, 7167, 7168, 7169, 7170, 7171, 
-  7172, 7173, 7174, 7175, 7118, 7176, 7177, 7178, 
-  7179, 7180, 7181, 7182, 7183, 7184, 7185, 7186, 
-  7187, 7188, 7189, 7190, 7191, 7192, 7193, 7194, 
-  7195, 7196, 7197, 7198, 7199, 7200, 7144, 7201, 
-  7202, 7203, 7204, 7205, 7206, 7207, 7208, 7209, 
-  7210, 7211, 7212, 7213, 7214, 7215, 7216, 7217, 
-  7218, 7219, 7220, 7221, 7222, 7223, 7224, 7225, 
-  7226, 7227, 7228, 7229, 7230, 7231, 7118, 7232, 
-  7233, 7234, 7235, 7236, 7237, 7238, 7239, 7240, 
-  7241, 7242, 7243, 7244, 7245, 7246, 7247, 7248, 
-  7249, 7250, 7251, 7252, 7253, 7254, 7255, 7256, 
-  7144, 7257, 7258, 7259, 7260, 7261, 7262, 7263, 
-  7264, 7265, 7266, 7267, 7268, 7269, 7270, 7271, 
-  7272, 7273, 7274, 7275, 7276, 7277, 7278, 7279, 
-  7280, 7281, 7282, 7283, 7284, 7285, 7286, 7287, 
-  7118, 7288, 7289, 7290, 7291, 7292, 7293, 7294, 
-  7295, 7296, 7297, 7298, 7299, 7300, 7301, 7302, 
-  7303, 7304, 7305, 7306, 7307, 7308, 7309, 7310, 
-  7311, 7312, 7144, 7313, 7314, 7315, 7316, 7317, 
-  7318, 7319, 7320, 7321, 7322, 7323, 7324, 7325, 
-  7326, 7327, 7328, 7329, 7330, 7331, 7332, 7333, 
-  7334, 7335, 7336, 7337, 7338, 7339, 7340, 7341, 
-  7342, 7343, 7118, 7344, 7345, 7346, 7347, 7348, 
-  7349, 7350, 7351, 7352, 7353, 7354, 7355, 7356, 
-  7357, 7358, 7359, 7360, 7361, 7362, 7363, 7364, 
-  7365, 7366, 7367, 7368, 7144, 7369, 7370, 7371, 
-  7372, 7373, 7374, 7375, 7376, 0, 0, 7377, 
-  7378, 7379, 7380, 7381, 7382, 7383, 7384, 7385, 
-  7386, 7377, 7378, 7379, 7380, 7381, 7382, 7383, 
-  7384, 7385, 7386, 7377, 7378, 7379, 7380, 7381, 
-  7382, 7383, 7384, 7385, 7386, 7377, 7378, 7379, 
-  7380, 7381, 7382, 7383, 7384, 7385, 7386, 7377, 
-  7378, 7379, 7380, 7381, 7382, 7383, 7384, 7385, 
-  7386, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  913, 913, 913, 913, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 913, 913, 
-  913, 913, 913, 913, 913, 913, 1225, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 1225, 913, 913, 
-  1119, 1119, 1119, 1119, 1119, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 1225, 1225, 1225, 1225, 
-  1225, 0, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 
-  1225, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7387, 7388, 7389, 7390, 7391, 7392, 7393, 
-  7394, 7395, 7396, 345, 7397, 7398, 7399, 7400, 
-  7401, 7402, 7403, 7404, 7405, 7406, 7407, 7408, 
-  7409, 7410, 7411, 7412, 7413, 7414, 7415, 7416, 
-  0, 0, 0, 0, 0, 0, 7417, 7418, 
-  7419, 7420, 7421, 7422, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 614, 614, 614, 614, 614, 614, 614, 
-  0, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 614, 614, 614, 614, 614, 614, 
-  614, 614, 0, 0, 614, 614, 614, 614, 
-  614, 614, 614, 0, 614, 614, 0, 614, 
-  614, 614, 614, 614, 0, 0, 0, 0, 
-  0, 7423, 7424, 7425, 7426, 7427, 7428, 7429, 
-  7430, 7431, 7432, 7433, 7434, 7435, 7436, 7437, 
-  7438, 7439, 7440, 7441, 7442, 7443, 7444, 7445, 
-  7446, 7447, 7448, 7449, 7450, 7451, 7452, 7453, 
-  7454, 7455, 7456, 7457, 7458, 7459, 7460, 7461, 
-  7462, 7463, 7464, 7465, 7466, 7467, 7468, 7469, 
-  7470, 7471, 7472, 7473, 7474, 7475, 7476, 7477, 
-  7478, 7479, 7480, 7481, 7482, 7483, 7484, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  614, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 0, 0, 
-  0, 614, 614, 614, 614, 614, 614, 614, 
-  595, 595, 595, 595, 595, 595, 595, 0, 
-  0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 345, 
-  913, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 614, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 614, 614, 614, 
-  614, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  10, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 595, 626, 626, 627, 
-  614, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 
-  1248, 1248, 1248, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  0, 345, 345, 345, 345, 0, 345, 345, 
-  0, 345, 345, 345, 345, 345, 345, 345, 
-  345, 345, 345, 345, 345, 345, 345, 345, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 0, 0, 
-  6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, 
-  6143, 627, 627, 627, 627, 627, 627, 627, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7485, 7486, 7487, 7488, 7489, 7490, 7491, 
-  7492, 7493, 7494, 7495, 7496, 7497, 7498, 7499, 
-  7500, 7501, 7502, 7503, 7504, 7505, 7506, 7507, 
-  7508, 7509, 7510, 7511, 7512, 7513, 7514, 7515, 
-  7516, 7517, 7518, 7519, 7520, 7521, 7522, 7523, 
-  7524, 7525, 7526, 7527, 7528, 7529, 7530, 7531, 
-  7532, 7533, 7534, 7535, 7536, 7537, 7538, 7539, 
-  7540, 7541, 7542, 7543, 7544, 7545, 7546, 7547, 
-  7548, 7549, 7550, 7551, 7552, 614, 614, 614, 
-  614, 614, 614, 1249, 1227, 0, 0, 0, 
-  0, 1226, 1226, 1226, 1226, 1226, 1226, 1226, 
-  1226, 1226, 1226, 0, 0, 0, 0, 1179, 
-  1179, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 1222, 6248, 6248, 
-  6248, 1185, 6248, 6248, 6248, 6248, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 1222, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, 
-  6248, 6248, 6248, 6248, 6248, 6248, 6248, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7553, 7554, 7555, 7556, 0, 7557, 7558, 
-  7559, 7560, 7561, 7562, 7563, 7564, 7565, 7566, 
-  7567, 7568, 7569, 7570, 7571, 7572, 7573, 7574, 
-  7575, 7576, 7577, 7578, 7579, 7580, 7581, 7582, 
-  7583, 0, 7554, 7555, 0, 7584, 0, 0, 
-  7559, 0, 7561, 7562, 7563, 7564, 7565, 7566, 
-  7567, 7568, 7569, 7570, 0, 7572, 7573, 7574, 
-  7575, 0, 7577, 0, 7579, 0, 0, 0, 
-  0, 0, 0, 7555, 0, 0, 0, 0, 
-  7559, 0, 7561, 0, 7563, 0, 7565, 7566, 
-  7567, 0, 7569, 7570, 0, 7572, 0, 0, 
-  7575, 0, 7577, 0, 7579, 0, 7581, 0, 
-  7583, 0, 7554, 7555, 0, 7584, 0, 0, 
-  7559, 7560, 7561, 7562, 0, 7564, 7565, 7566, 
-  7567, 7568, 7569, 7570, 0, 7572, 7573, 7574, 
-  7575, 0, 7577, 7578, 7579, 7580, 0, 7582, 
-  0, 7553, 7554, 7555, 7556, 7584, 7557, 7558, 
-  7559, 7560, 7561, 0, 7563, 7564, 7565, 7566, 
-  7567, 7568, 7569, 7570, 7571, 7572, 7573, 7574, 
-  7575, 7576, 7577, 7578, 7579, 0, 0, 0, 
-  0, 0, 7554, 7555, 7556, 0, 7557, 7558, 
-  7559, 7560, 7561, 0, 7563, 7564, 7565, 7566, 
-  7567, 7568, 7569, 7570, 7571, 7572, 7573, 7574, 
-  7575, 7576, 7577, 7578, 7579, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 74, 74, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 78, 78, 78, 78, 2579, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 0, 0, 0, 
-  0, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  0, 0, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 0, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  2579, 0, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7585, 7586, 7587, 7588, 7589, 7590, 7591, 
-  7592, 7593, 7594, 7595, 1288, 1288, 78, 78, 
-  78, 7596, 7597, 7598, 7599, 7600, 7601, 7602, 
-  7603, 7604, 7605, 7606, 7607, 7608, 7609, 7610, 
-  7611, 7612, 7613, 7614, 7615, 7616, 7617, 7618, 
-  7619, 7620, 7621, 7622, 7623, 7624, 7625, 7626, 
-  78, 7627, 7628, 7629, 7630, 7631, 7632, 7633, 
-  7634, 7635, 7636, 7637, 7638, 7639, 7640, 7641, 
-  7642, 7643, 7644, 7645, 7646, 7647, 7648, 7649, 
-  7650, 7651, 7652, 7653, 7654, 7655, 7656, 7657, 
-  7658, 7659, 7660, 7661, 7662, 7663, 7664, 7665, 
-  7666, 7667, 7668, 7669, 7670, 7671, 7672, 7673, 
-  7674, 7675, 7676, 7677, 7678, 7679, 7680, 7681, 
-  7682, 7683, 7684, 7685, 7686, 7687, 78, 78, 
-  78, 7688, 7689, 7690, 7691, 7692, 7693, 7694, 
-  7695, 7696, 7697, 7698, 7699, 7700, 7701, 7702, 
-  7703, 7704, 7705, 7706, 7707, 7708, 7709, 7710, 
-  7711, 7712, 7713, 913, 913, 913, 913, 7714, 
-  913, 7715, 7714, 7714, 7714, 7714, 7714, 7714, 
-  7714, 7714, 7714, 7714, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 913, 913, 
-  913, 913, 913, 913, 913, 913, 78, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7716, 
-  7716, 7716, 7716, 7716, 7716, 7716, 7716, 7716, 
-  7716, 7716, 7716, 7716, 7716, 7716, 7716, 7716, 
-  7716, 7716, 7716, 7716, 7716, 7716, 7716, 7716, 
-  7716, 7717, 7718, 7719, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7720, 7721, 7722, 7723, 7724, 7725, 7726, 
-  7727, 7728, 7729, 7730, 7731, 7732, 7733, 7734, 
-  7735, 7736, 7737, 7738, 7739, 7740, 7741, 7742, 
-  7743, 7744, 7745, 7746, 7747, 7748, 7749, 7750, 
-  7751, 7752, 7753, 7754, 7755, 7756, 7757, 7758, 
-  7759, 7760, 7761, 7762, 7763, 0, 0, 0, 
-  0, 7764, 7765, 7766, 7767, 7768, 7769, 7770, 
-  7771, 7772, 0, 0, 0, 0, 0, 0, 
-  0, 7773, 7774, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 78, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 78, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 78, 78, 78, 78, 
-  2579, 2579, 2579, 2579, 2579, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 78, 78, 78, 2579, 78, 78, 
-  78, 2579, 2579, 2579, 7775, 7775, 7775, 7775, 
-  7775, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  78, 2579, 78, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 78, 78, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 76, 
-  76, 76, 76, 76, 76, 76, 76, 78, 
-  78, 78, 78, 78, 2579, 2579, 2579, 2579, 
-  78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 2579, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 2579, 2579, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 2579, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 78, 
-  78, 78, 78, 78, 78, 2579, 78, 78, 
-  78, 2579, 2579, 2579, 78, 78, 2579, 2579, 
-  2579, 0, 0, 0, 0, 2579, 2579, 2579, 
-  2579, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 2579, 2579, 0, 0, 
-  0, 78, 78, 78, 78, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 78, 78, 78, 
-  0, 0, 0, 0, 78, 78, 78, 78, 
-  78, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 78, 78, 
-  78, 78, 78, 0, 0, 0, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 0, 0, 0, 
-  0, 2579, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 0, 
-  0, 78, 78, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 76, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 76, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 78, 78, 78, 78, 78, 78, 78, 
-  78, 78, 78, 78, 78, 78, 78, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 0, 0, 0, 0, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 0, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 0, 
-  0, 0, 0, 0, 0, 0, 0, 2579, 
-  2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 2579, 2579, 2579, 0, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 0, 0, 0, 0, 0, 0, 
-  0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, 
-  2579, 2579, 0, 0, 0, 0, 0, 0, 
-  0, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 0, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 76, 76, 76, 76, 
-  76, 76, 76, 76, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7377, 7378, 7379, 7380, 7381, 7382, 7383, 
-  7384, 7385, 7386, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7776, 7777, 7778, 7779, 7780, 4649, 7781, 
-  7782, 7783, 7784, 4650, 7785, 7786, 7787, 4651, 
-  7788, 7789, 7790, 7791, 7792, 7793, 7794, 7795, 
-  7796, 7797, 7798, 7799, 4709, 7800, 7801, 7802, 
-  7803, 7804, 7805, 7806, 7807, 7808, 4714, 4652, 
-  4653, 4715, 7809, 7810, 4460, 7811, 4654, 7812, 
-  7813, 7814, 7815, 7815, 7815, 7816, 7817, 7818, 
-  7819, 7820, 7821, 7822, 7823, 7824, 7825, 7826, 
-  7827, 7828, 7829, 7830, 7831, 7832, 7833, 7833, 
-  4717, 7834, 7835, 7836, 7837, 4656, 7838, 7839, 
-  7840, 4613, 7841, 7842, 7843, 7844, 7845, 7846, 
-  7847, 7848, 7849, 7850, 7851, 7852, 7853, 7854, 
-  7855, 7856, 7857, 7858, 7859, 7860, 7861, 7862, 
-  7863, 7864, 7865, 7866, 7866, 7867, 7868, 7869, 
-  4456, 7870, 7871, 7872, 7873, 7874, 7875, 7876, 
-  7877, 4661, 7878, 7879, 7880, 7881, 7882, 7883, 
-  7884, 7885, 7886, 7887, 7888, 7889, 7890, 7891, 
-  7892, 7893, 7894, 7895, 7896, 7897, 7898, 4402, 
-  7899, 7900, 7901, 7901, 7902, 7903, 7903, 7904, 
-  7905, 7906, 7907, 7908, 7909, 7910, 7911, 7912, 
-  7913, 7914, 7915, 7916, 4662, 7917, 7918, 7919, 
-  7920, 4729, 7920, 7921, 4664, 7922, 7923, 7924, 
-  7925, 4665, 4375, 7926, 7927, 7928, 7929, 7930, 
-  7931, 7932, 7933, 7934, 7935, 7936, 7937, 7938, 
-  7939, 7940, 7941, 7942, 7943, 7944, 7945, 7946, 
-  7947, 4666, 7948, 7949, 7950, 7951, 7952, 7953, 
-  4668, 7954, 7955, 7956, 7957, 7958, 7959, 7960, 
-  7961, 4403, 4737, 7962, 7963, 7964, 7965, 7966, 
-  7967, 7968, 7969, 4669, 7970, 7971, 7972, 7973, 
-  4780, 7974, 7975, 7976, 7977, 7978, 7979, 7980, 
-  7981, 7982, 7983, 7984, 7985, 7986, 4473, 7987, 
-  7988, 7989, 7990, 7991, 7992, 7993, 7994, 7995, 
-  7996, 7997, 4670, 4560, 7998, 7999, 8000, 8001, 
-  8002, 8003, 8004, 8005, 4741, 8006, 8007, 8008, 
-  8009, 8010, 8011, 8012, 8013, 4742, 8014, 8015, 
-  8016, 8017, 8018, 8019, 8020, 8021, 8022, 8023, 
-  8024, 8025, 4744, 8026, 8027, 8028, 8029, 8030, 
-  8031, 8032, 8033, 8034, 8035, 8036, 8036, 8037, 
-  8038, 4746, 8039, 8040, 8041, 8042, 8043, 8044, 
-  8045, 4459, 8046, 8047, 8048, 8049, 8050, 8051, 
-  8052, 4752, 8053, 8054, 8055, 8056, 8057, 8058, 
-  8058, 4753, 4782, 8059, 8060, 8061, 8062, 8063, 
-  4421, 4755, 8064, 8065, 4681, 8066, 8067, 4635, 
-  8068, 8069, 4685, 8070, 8071, 8072, 8073, 8073, 
-  8074, 8075, 8076, 8077, 8078, 8079, 8080, 8081, 
-  8082, 8083, 8084, 8085, 8086, 8087, 8088, 8089, 
-  8090, 8091, 8092, 8093, 8094, 8095, 8096, 8097, 
-  8098, 8099, 8100, 4691, 8101, 8102, 8103, 8104, 
-  8105, 8106, 8107, 8108, 8109, 8110, 8111, 8112, 
-  8113, 8114, 8115, 8116, 7902, 8117, 8118, 8119, 
-  8120, 8121, 8122, 8123, 8124, 8125, 8126, 8127, 
-  8128, 4477, 8129, 8130, 8131, 8132, 8133, 8134, 
-  4694, 8135, 8136, 8137, 8138, 8139, 8140, 8141, 
-  8142, 8143, 8144, 8145, 8146, 8147, 8148, 8149, 
-  8150, 8151, 8152, 8153, 8154, 4416, 8155, 8156, 
-  8157, 8158, 8159, 8160, 4762, 8161, 8162, 8163, 
-  8164, 8165, 8166, 8167, 8168, 8169, 8170, 8171, 
-  8172, 8173, 8174, 8175, 8176, 8177, 8178, 8179, 
-  8180, 4767, 4768, 8181, 8182, 8183, 8184, 8185, 
-  8186, 8187, 8188, 8189, 8190, 8191, 8192, 8193, 
-  4769, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 
-  8201, 8202, 8203, 8204, 8205, 8206, 8207, 8208, 
-  8209, 8210, 8211, 8212, 8213, 8214, 8215, 8216, 
-  8217, 8218, 8219, 8220, 8221, 8222, 8223, 4775, 
-  4775, 8224, 8225, 8226, 8227, 8228, 8229, 8230, 
-  8231, 8232, 8233, 4776, 8234, 8235, 8236, 8237, 
-  8238, 8239, 8240, 8241, 8242, 8243, 8244, 8245, 
-  8246, 8247, 8248, 8249, 8250, 8251, 8252, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 0, 0, 0, 0, 
-  0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, 
-  3227, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 1538, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, 
-  8253, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 648, 648, 648, 648, 648, 648, 648, 
-  648, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, 
-  4362, 4362, 4362, 4362, 4362, 4362, 4362, 0, 
-  0, };
-
-static const utf8proc_property_t utf8proc_properties[] = {
-  {0, 0, 0, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX,  false,false,false,false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_S, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_LF, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CR, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5093, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5084, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5096, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1, UINT16_MAX, 1, UINT16_MAX, 2784, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2, UINT16_MAX, 2, UINT16_MAX, 49, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3, UINT16_MAX, 3, UINT16_MAX, 704, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4, UINT16_MAX, 4, UINT16_MAX, 62, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5, UINT16_MAX, 5, UINT16_MAX, 2872, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6, UINT16_MAX, 6, UINT16_MAX, 782, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7, UINT16_MAX, 7, UINT16_MAX, 808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8, UINT16_MAX, 8, UINT16_MAX, 111, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9, UINT16_MAX, 9, UINT16_MAX, 898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 10, UINT16_MAX, 10, UINT16_MAX, 913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 11, UINT16_MAX, 11, UINT16_MAX, 999, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 12, UINT16_MAX, 12, UINT16_MAX, 2890, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 13, UINT16_MAX, 13, UINT16_MAX, 160, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 14, UINT16_MAX, 14, UINT16_MAX, 205, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 15, UINT16_MAX, 15, UINT16_MAX, 2982, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16, UINT16_MAX, 16, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 17, UINT16_MAX, 17, UINT16_MAX, 1087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 18, UINT16_MAX, 18, UINT16_MAX, 1173, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 19, UINT16_MAX, 19, UINT16_MAX, 1257, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 20, UINT16_MAX, 20, UINT16_MAX, 254, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 21, UINT16_MAX, 21, UINT16_MAX, 3042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 22, UINT16_MAX, 22, UINT16_MAX, 1337, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 23, UINT16_MAX, 23, UINT16_MAX, 3122, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 24, UINT16_MAX, 24, UINT16_MAX, 303, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 25, UINT16_MAX, 25, UINT16_MAX, 1423, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 26, UINT16_MAX, 26, 352, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 27, UINT16_MAX, 27, 2818, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 28, UINT16_MAX, 28, 401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 29, UINT16_MAX, 29, 743, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 30, UINT16_MAX, 30, 414, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 31, UINT16_MAX, 31, 2875, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 32, UINT16_MAX, 32, 795, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 33, UINT16_MAX, 33, 853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 34, UINT16_MAX, 34, 463, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 35, UINT16_MAX, 35, 901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 36, UINT16_MAX, 36, 956, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 37, UINT16_MAX, 37, 1043, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 38, UINT16_MAX, 38, 2932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 39, UINT16_MAX, 39, 512, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 40, UINT16_MAX, 40, 557, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 41, UINT16_MAX, 41, 2994, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 42, UINT16_MAX, 42, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 43, UINT16_MAX, 43, 1130, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 44, UINT16_MAX, 44, 1215, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 45, UINT16_MAX, 45, 1296, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 46, UINT16_MAX, 46, 606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 47, UINT16_MAX, 47, 3082, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 48, UINT16_MAX, 48, 1380, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 49, UINT16_MAX, 49, 3131, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 50, UINT16_MAX, 50, 655, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 51, UINT16_MAX, 51, 1466, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_NOBREAK, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 1621, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, 55, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 1, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 62, 62, 63, UINT16_MAX, 63, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, 67, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 32836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 32839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 32842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16461, 79, UINT16_MAX, 79, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16464, 82, UINT16_MAX, 82, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16467, 85, UINT16_MAX, 85, UINT16_MAX, 3143, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16470, 88, UINT16_MAX, 88, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16473, 91, UINT16_MAX, 91, UINT16_MAX, 1537, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16476, 94, UINT16_MAX, 94, UINT16_MAX, 1579, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 95, UINT16_MAX, 95, UINT16_MAX, 1549, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16480, 98, UINT16_MAX, 98, UINT16_MAX, 2852, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16483, 101, UINT16_MAX, 101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16486, 104, UINT16_MAX, 104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16489, 107, UINT16_MAX, 107, UINT16_MAX, 3357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16492, 110, UINT16_MAX, 110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16495, 113, UINT16_MAX, 113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16498, 116, UINT16_MAX, 116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16501, 119, UINT16_MAX, 119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16504, 122, UINT16_MAX, 122, UINT16_MAX, 2878, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 123, UINT16_MAX, 123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16508, 126, UINT16_MAX, 126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16511, 129, UINT16_MAX, 129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16514, 132, UINT16_MAX, 132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16517, 135, UINT16_MAX, 135, UINT16_MAX, 3461, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16520, 138, UINT16_MAX, 138, UINT16_MAX, 1597, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16523, 141, UINT16_MAX, 141, UINT16_MAX, 1591, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 142, UINT16_MAX, 142, UINT16_MAX, 1585, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16527, 145, UINT16_MAX, 145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16530, 148, UINT16_MAX, 148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16533, 151, UINT16_MAX, 151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16536, 154, UINT16_MAX, 154, UINT16_MAX, 1509, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16539, 157, UINT16_MAX, 157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 158, UINT16_MAX, 158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16543, 161, UINT16_MAX, 161, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16546, UINT16_MAX, 164, UINT16_MAX, 164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16549, UINT16_MAX, 167, UINT16_MAX, 167, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16552, UINT16_MAX, 170, UINT16_MAX, 170, 3192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16555, UINT16_MAX, 173, UINT16_MAX, 173, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16558, UINT16_MAX, 176, UINT16_MAX, 176, 1540, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16561, UINT16_MAX, 179, UINT16_MAX, 179, 1582, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 180, UINT16_MAX, 180, 1558, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16565, UINT16_MAX, 183, UINT16_MAX, 183, 2855, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16568, UINT16_MAX, 186, UINT16_MAX, 186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16571, UINT16_MAX, 189, UINT16_MAX, 189, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16574, UINT16_MAX, 192, UINT16_MAX, 192, 3406, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16577, UINT16_MAX, 195, UINT16_MAX, 195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16580, UINT16_MAX, 198, UINT16_MAX, 198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16583, UINT16_MAX, 201, UINT16_MAX, 201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16586, UINT16_MAX, 204, UINT16_MAX, 204, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16589, UINT16_MAX, 207, UINT16_MAX, 207, 2881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 208, UINT16_MAX, 208, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16593, UINT16_MAX, 211, UINT16_MAX, 211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16596, UINT16_MAX, 214, UINT16_MAX, 214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16599, UINT16_MAX, 217, UINT16_MAX, 217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16602, UINT16_MAX, 220, UINT16_MAX, 220, 3510, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16605, UINT16_MAX, 223, UINT16_MAX, 223, 1606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16608, UINT16_MAX, 226, UINT16_MAX, 226, 1594, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 227, UINT16_MAX, 227, 1588, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16612, UINT16_MAX, 230, UINT16_MAX, 230, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16615, UINT16_MAX, 233, UINT16_MAX, 233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16618, UINT16_MAX, 236, UINT16_MAX, 236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16621, UINT16_MAX, 239, UINT16_MAX, 239, 1523, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16624, UINT16_MAX, 242, UINT16_MAX, 242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 243, UINT16_MAX, 243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16628, UINT16_MAX, 246, UINT16_MAX, 246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16631, 249, UINT16_MAX, 249, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16634, UINT16_MAX, 252, UINT16_MAX, 252, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16637, 255, UINT16_MAX, 255, UINT16_MAX, 3259, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16640, UINT16_MAX, 258, UINT16_MAX, 258, 3308, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16643, 261, UINT16_MAX, 261, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16646, UINT16_MAX, 264, UINT16_MAX, 264, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16649, 267, UINT16_MAX, 267, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16652, UINT16_MAX, 270, UINT16_MAX, 270, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16655, 273, UINT16_MAX, 273, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16658, UINT16_MAX, 276, UINT16_MAX, 276, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16661, 279, UINT16_MAX, 279, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16664, UINT16_MAX, 282, UINT16_MAX, 282, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16667, 285, UINT16_MAX, 285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16670, UINT16_MAX, 288, UINT16_MAX, 288, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16673, 291, UINT16_MAX, 291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16676, UINT16_MAX, 294, UINT16_MAX, 294, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 295, UINT16_MAX, 295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 296, UINT16_MAX, 296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16681, 299, UINT16_MAX, 299, UINT16_MAX, 2858, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16684, UINT16_MAX, 302, UINT16_MAX, 302, 2862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16687, 305, UINT16_MAX, 305, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16690, UINT16_MAX, 308, UINT16_MAX, 308, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16693, 311, UINT16_MAX, 311, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16696, UINT16_MAX, 314, UINT16_MAX, 314, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16699, 317, UINT16_MAX, 317, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16702, UINT16_MAX, 320, UINT16_MAX, 320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16705, 323, UINT16_MAX, 323, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16708, UINT16_MAX, 326, UINT16_MAX, 326, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16711, 329, UINT16_MAX, 329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16714, UINT16_MAX, 332, UINT16_MAX, 332, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16717, 335, UINT16_MAX, 335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16720, UINT16_MAX, 338, UINT16_MAX, 338, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16723, 341, UINT16_MAX, 341, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16726, UINT16_MAX, 344, UINT16_MAX, 344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16729, 347, UINT16_MAX, 347, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16732, UINT16_MAX, 350, UINT16_MAX, 350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16735, 353, UINT16_MAX, 353, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16738, UINT16_MAX, 356, UINT16_MAX, 356, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 357, UINT16_MAX, 357, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 358, UINT16_MAX, 358, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16743, 361, UINT16_MAX, 361, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16746, UINT16_MAX, 364, UINT16_MAX, 364, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16749, 367, UINT16_MAX, 367, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16752, UINT16_MAX, 370, UINT16_MAX, 370, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16755, 373, UINT16_MAX, 373, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16758, UINT16_MAX, 376, UINT16_MAX, 376, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16761, 379, UINT16_MAX, 379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16764, UINT16_MAX, 382, UINT16_MAX, 382, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16767, 16769, UINT16_MAX, 8, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 34, UINT16_MAX, 34, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16771, 389, UINT16_MAX, 389, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16774, UINT16_MAX, 392, UINT16_MAX, 392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16777, 395, UINT16_MAX, 395, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16780, UINT16_MAX, 398, UINT16_MAX, 398, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16783, 401, UINT16_MAX, 401, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16786, UINT16_MAX, 404, UINT16_MAX, 404, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 405, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16790, 408, UINT16_MAX, 408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16793, UINT16_MAX, 411, UINT16_MAX, 411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16796, 414, UINT16_MAX, 414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16799, UINT16_MAX, 417, UINT16_MAX, 417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16802, 420, UINT16_MAX, 420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16805, UINT16_MAX, 423, UINT16_MAX, 423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16808, 426, UINT16_MAX, 426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16811, UINT16_MAX, 429, UINT16_MAX, 429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 430, UINT16_MAX, 430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 431, UINT16_MAX, 431, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16816, 434, UINT16_MAX, 434, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16819, UINT16_MAX, 437, UINT16_MAX, 437, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16822, 440, UINT16_MAX, 440, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16825, UINT16_MAX, 443, UINT16_MAX, 443, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16828, 446, UINT16_MAX, 446, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16831, UINT16_MAX, 449, UINT16_MAX, 449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16834, 16834, 452, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 453, UINT16_MAX, 453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 454, UINT16_MAX, 454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16839, 457, UINT16_MAX, 457, UINT16_MAX, 2974, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16842, UINT16_MAX, 460, UINT16_MAX, 460, 2978, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16845, 463, UINT16_MAX, 463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16848, UINT16_MAX, 466, UINT16_MAX, 466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16851, 469, UINT16_MAX, 469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16854, UINT16_MAX, 472, UINT16_MAX, 472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 473, UINT16_MAX, 473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 474, UINT16_MAX, 474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16859, 477, UINT16_MAX, 477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16862, UINT16_MAX, 480, UINT16_MAX, 480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16865, 483, UINT16_MAX, 483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16868, UINT16_MAX, 486, UINT16_MAX, 486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16871, 489, UINT16_MAX, 489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16874, UINT16_MAX, 492, UINT16_MAX, 492, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16877, 495, UINT16_MAX, 495, UINT16_MAX, 3012, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16880, UINT16_MAX, 498, UINT16_MAX, 498, 3015, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16883, 501, UINT16_MAX, 501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16886, UINT16_MAX, 504, UINT16_MAX, 504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16889, 507, UINT16_MAX, 507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16892, UINT16_MAX, 510, UINT16_MAX, 510, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16895, 513, UINT16_MAX, 513, UINT16_MAX, 3018, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16898, UINT16_MAX, 516, UINT16_MAX, 516, 3021, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16901, 519, UINT16_MAX, 519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16904, UINT16_MAX, 522, UINT16_MAX, 522, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16907, 525, UINT16_MAX, 525, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16910, UINT16_MAX, 528, UINT16_MAX, 528, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 529, UINT16_MAX, 529, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 530, UINT16_MAX, 530, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16915, 533, UINT16_MAX, 533, UINT16_MAX, 3030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16918, UINT16_MAX, 536, UINT16_MAX, 536, 3033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16921, 539, UINT16_MAX, 539, UINT16_MAX, 3036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16924, UINT16_MAX, 542, UINT16_MAX, 542, 3039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16927, 545, UINT16_MAX, 545, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16930, UINT16_MAX, 548, UINT16_MAX, 548, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16933, 551, UINT16_MAX, 551, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16936, UINT16_MAX, 554, UINT16_MAX, 554, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16939, 557, UINT16_MAX, 557, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16942, UINT16_MAX, 560, UINT16_MAX, 560, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16945, 563, UINT16_MAX, 563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16948, UINT16_MAX, 566, UINT16_MAX, 566, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16951, 569, UINT16_MAX, 569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16954, UINT16_MAX, 572, UINT16_MAX, 572, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16957, 575, UINT16_MAX, 575, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16960, UINT16_MAX, 578, UINT16_MAX, 578, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16963, 581, UINT16_MAX, 581, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16966, 584, UINT16_MAX, 584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16969, UINT16_MAX, 587, UINT16_MAX, 587, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16972, 590, UINT16_MAX, 590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16975, UINT16_MAX, 593, UINT16_MAX, 593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16978, 596, UINT16_MAX, 596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16981, UINT16_MAX, 599, UINT16_MAX, 599, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18, 18, 44, UINT16_MAX, 44, 3140, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 600, UINT16_MAX, 600, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 601, UINT16_MAX, 601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 602, UINT16_MAX, 602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 603, UINT16_MAX, 603, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 604, UINT16_MAX, 604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 605, UINT16_MAX, 605, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 606, UINT16_MAX, 606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 607, UINT16_MAX, 607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 608, UINT16_MAX, 608, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 609, UINT16_MAX, 609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 610, UINT16_MAX, 610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 611, UINT16_MAX, 611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 612, UINT16_MAX, 612, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 613, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 614, UINT16_MAX, 614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 615, UINT16_MAX, 615, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 616, UINT16_MAX, 616, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 617, UINT16_MAX, 617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 618, UINT16_MAX, 618, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 619, UINT16_MAX, 619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 620, UINT16_MAX, 620, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 621, UINT16_MAX, 621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 622, UINT16_MAX, 622, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 623, UINT16_MAX, 623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 624, UINT16_MAX, 624, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 625, UINT16_MAX, 625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 626, UINT16_MAX, 626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 627, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 628, UINT16_MAX, 628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 629, UINT16_MAX, 629, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 630, UINT16_MAX, 630, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 631, UINT16_MAX, 631, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17016, 634, UINT16_MAX, 634, UINT16_MAX, 3565, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17019, UINT16_MAX, 637, UINT16_MAX, 637, 3614, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 638, UINT16_MAX, 638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 639, UINT16_MAX, 639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 640, UINT16_MAX, 640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 641, UINT16_MAX, 641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 642, UINT16_MAX, 642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 643, UINT16_MAX, 643, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 644, UINT16_MAX, 644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 645, UINT16_MAX, 645, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 646, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 647, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 648, UINT16_MAX, 648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 649, UINT16_MAX, 649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 650, UINT16_MAX, 650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17035, 653, UINT16_MAX, 653, UINT16_MAX, 3663, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17038, UINT16_MAX, 656, UINT16_MAX, 656, 3712, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 657, UINT16_MAX, 657, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 658, UINT16_MAX, 658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 659, UINT16_MAX, 659, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 660, UINT16_MAX, 660, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 661, UINT16_MAX, 661, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 662, UINT16_MAX, 662, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 663, UINT16_MAX, 663, UINT16_MAX, 1573, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 664, UINT16_MAX, 664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 665, UINT16_MAX, 665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 666, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 667, UINT16_MAX, 667, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 668, UINT16_MAX, 668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 669, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 670, UINT16_MAX, 670, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17055, 673, UINT16_MAX, 673, 674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17059, 673, 677, 673, 674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17062, UINT16_MAX, 677, UINT16_MAX, 674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17064, 682, UINT16_MAX, 682, 683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17068, 682, 686, 682, 683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17071, UINT16_MAX, 686, UINT16_MAX, 683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17073, 691, UINT16_MAX, 691, 692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17077, 691, 695, 691, 692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17080, UINT16_MAX, 695, UINT16_MAX, 692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17082, 700, UINT16_MAX, 700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17085, UINT16_MAX, 703, UINT16_MAX, 703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17088, 706, UINT16_MAX, 706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17091, UINT16_MAX, 709, UINT16_MAX, 709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17094, 712, UINT16_MAX, 712, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17097, UINT16_MAX, 715, UINT16_MAX, 715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17100, 718, UINT16_MAX, 718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17103, UINT16_MAX, 721, UINT16_MAX, 721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17106, 724, UINT16_MAX, 724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17109, UINT16_MAX, 727, UINT16_MAX, 727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17112, 730, UINT16_MAX, 730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17115, UINT16_MAX, 733, UINT16_MAX, 733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17118, 736, UINT16_MAX, 736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17121, UINT16_MAX, 739, UINT16_MAX, 739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17124, 742, UINT16_MAX, 742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17127, UINT16_MAX, 745, UINT16_MAX, 745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 746, UINT16_MAX, 746, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17131, 749, UINT16_MAX, 749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17134, UINT16_MAX, 752, UINT16_MAX, 752, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17137, 755, UINT16_MAX, 755, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17140, UINT16_MAX, 758, UINT16_MAX, 758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17143, 761, UINT16_MAX, 761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17146, UINT16_MAX, 764, UINT16_MAX, 764, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 765, UINT16_MAX, 765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 766, UINT16_MAX, 766, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17151, 769, UINT16_MAX, 769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17154, UINT16_MAX, 772, UINT16_MAX, 772, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17157, 775, UINT16_MAX, 775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17160, UINT16_MAX, 778, UINT16_MAX, 778, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17163, 781, UINT16_MAX, 781, UINT16_MAX, 1567, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17166, UINT16_MAX, 784, UINT16_MAX, 784, 1570, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17169, 787, UINT16_MAX, 787, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17172, UINT16_MAX, 790, UINT16_MAX, 790, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17175, 793, UINT16_MAX, 793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17178, UINT16_MAX, 796, UINT16_MAX, 796, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17181, 17181, 799, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17184, 802, UINT16_MAX, 802, 803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17188, 802, 806, 802, 803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17191, UINT16_MAX, 806, UINT16_MAX, 803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17193, 811, UINT16_MAX, 811, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17196, UINT16_MAX, 814, UINT16_MAX, 814, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 815, UINT16_MAX, 815, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 816, UINT16_MAX, 816, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17201, 819, UINT16_MAX, 819, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17204, UINT16_MAX, 822, UINT16_MAX, 822, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17207, 825, UINT16_MAX, 825, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17210, UINT16_MAX, 828, UINT16_MAX, 828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17213, 831, UINT16_MAX, 831, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17216, UINT16_MAX, 834, UINT16_MAX, 834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17219, 837, UINT16_MAX, 837, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17222, UINT16_MAX, 840, UINT16_MAX, 840, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17225, 843, UINT16_MAX, 843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17228, UINT16_MAX, 846, UINT16_MAX, 846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17231, 849, UINT16_MAX, 849, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17234, UINT16_MAX, 852, UINT16_MAX, 852, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17237, 855, UINT16_MAX, 855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17240, UINT16_MAX, 858, UINT16_MAX, 858, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17243, 861, UINT16_MAX, 861, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17246, UINT16_MAX, 864, UINT16_MAX, 864, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17249, 867, UINT16_MAX, 867, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17252, UINT16_MAX, 870, UINT16_MAX, 870, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17255, 873, UINT16_MAX, 873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17258, UINT16_MAX, 876, UINT16_MAX, 876, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17261, 879, UINT16_MAX, 879, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17264, UINT16_MAX, 882, UINT16_MAX, 882, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17267, 885, UINT16_MAX, 885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17270, UINT16_MAX, 888, UINT16_MAX, 888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17273, 891, UINT16_MAX, 891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17276, UINT16_MAX, 894, UINT16_MAX, 894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17279, 897, UINT16_MAX, 897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17282, UINT16_MAX, 900, UINT16_MAX, 900, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17285, 903, UINT16_MAX, 903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17288, UINT16_MAX, 906, UINT16_MAX, 906, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17291, 909, UINT16_MAX, 909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17294, UINT16_MAX, 912, UINT16_MAX, 912, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17297, 915, UINT16_MAX, 915, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17300, UINT16_MAX, 918, UINT16_MAX, 918, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17303, 921, UINT16_MAX, 921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17306, UINT16_MAX, 924, UINT16_MAX, 924, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 925, UINT16_MAX, 925, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 926, UINT16_MAX, 926, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17311, 929, UINT16_MAX, 929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17314, UINT16_MAX, 932, UINT16_MAX, 932, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 933, UINT16_MAX, 933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 934, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 935, UINT16_MAX, 935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 936, UINT16_MAX, 936, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 937, UINT16_MAX, 937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 938, UINT16_MAX, 938, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17323, 941, UINT16_MAX, 941, UINT16_MAX, 1543, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17326, UINT16_MAX, 944, UINT16_MAX, 944, 1546, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17329, 947, UINT16_MAX, 947, UINT16_MAX, 2866, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17332, UINT16_MAX, 950, UINT16_MAX, 950, 2869, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17335, 953, UINT16_MAX, 953, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17338, UINT16_MAX, 956, UINT16_MAX, 956, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17341, 959, UINT16_MAX, 959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17344, UINT16_MAX, 962, UINT16_MAX, 962, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17347, 965, UINT16_MAX, 965, UINT16_MAX, 1615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17350, UINT16_MAX, 968, UINT16_MAX, 968, 1618, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17353, 971, UINT16_MAX, 971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17356, UINT16_MAX, 974, UINT16_MAX, 974, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17359, 977, UINT16_MAX, 977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17362, UINT16_MAX, 980, UINT16_MAX, 980, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 981, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 982, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 983, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 984, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 985, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 986, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 987, UINT16_MAX, 987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 988, UINT16_MAX, 988, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 989, UINT16_MAX, 989, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 990, UINT16_MAX, 990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 991, UINT16_MAX, 991, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 992, UINT16_MAX, 992, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 993, UINT16_MAX, 993, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 994, UINT16_MAX, 994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 995, UINT16_MAX, 995, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 996, UINT16_MAX, 996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 997, UINT16_MAX, 997, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 998, UINT16_MAX, 998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 999, UINT16_MAX, 999, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1000, UINT16_MAX, 1000, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1001, UINT16_MAX, 1001, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1002, UINT16_MAX, 1002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1003, UINT16_MAX, 1003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1004, UINT16_MAX, 1004, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1005, UINT16_MAX, 1005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1006, UINT16_MAX, 1006, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1007, UINT16_MAX, 1007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1008, UINT16_MAX, 1008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1009, UINT16_MAX, 1009, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1010, UINT16_MAX, 1010, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1011, UINT16_MAX, 1011, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1012, UINT16_MAX, 1012, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1013, UINT16_MAX, 1013, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1014, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1015, UINT16_MAX, 1015, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1016, UINT16_MAX, 1016, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1017, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1018, UINT16_MAX, 1018, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1019, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1020, UINT16_MAX, 1020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1021, UINT16_MAX, 1021, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1022, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1023, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1024, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1025, UINT16_MAX, 1025, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1026, UINT16_MAX, 1026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1027, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1028, UINT16_MAX, 1028, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1029, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1030, UINT16_MAX, 1030, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1031, UINT16_MAX, 1031, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1032, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1033, UINT16_MAX, 1033, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1034, UINT16_MAX, 1034, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1035, UINT16_MAX, 1035, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1036, UINT16_MAX, 1036, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1037, UINT16_MAX, 1037, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1038, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1039, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1040, UINT16_MAX, 1040, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1041, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1042, UINT16_MAX, 1042, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1043, UINT16_MAX, 1043, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1044, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1045, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1046, UINT16_MAX, 1046, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1047, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1048, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1049, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1050, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1051, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1052, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1053, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1054, UINT16_MAX, 1054, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1055, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1056, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1057, UINT16_MAX, 1057, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1058, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1059, UINT16_MAX, 1059, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1060, UINT16_MAX, 1060, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1061, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1062, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1063, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1064, UINT16_MAX, 1064, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1065, UINT16_MAX, 1065, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1066, UINT16_MAX, 1066, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1067, UINT16_MAX, 1067, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1068, UINT16_MAX, 1068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1069, UINT16_MAX, 1069, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1070, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1071, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1072, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1073, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1074, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1075, UINT16_MAX, 1075, 1576, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1076, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1077, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1078, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1079, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1080, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1081, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1082, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1083, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1084, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1085, UINT16_MAX, 1085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1086, UINT16_MAX, 1086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1087, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1088, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1089, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1090, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1091, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1092, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1093, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1094, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1095, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1096, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1097, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1098, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1099, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1100, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1101, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1102, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1103, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 7, UINT16_MAX, 1104, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1105, UINT16_MAX, 1106, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 9, UINT16_MAX, 1107, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 17, UINT16_MAX, 1108, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1050, UINT16_MAX, 1109, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1052, UINT16_MAX, 1110, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1058, UINT16_MAX, 1111, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 22, UINT16_MAX, 1112, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 24, UINT16_MAX, 1113, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1114, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1115, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 620, UINT16_MAX, 1128, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 11, UINT16_MAX, 1129, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 18, UINT16_MAX, 1130, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 23, UINT16_MAX, 1131, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1077, UINT16_MAX, 1132, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32768, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32770, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32771, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32776, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32814, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32773, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32780, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32779, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32782, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32783, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32815, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32816, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 232, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32808, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32813, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32807, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32784, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32774, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32777, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32810, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32812, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32811, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32809, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32819, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 1133, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 1134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32817, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 1135, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 17520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 240, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, 1138, 1139, UINT16_MAX, 1139, 32818, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 233, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 234, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1140, UINT16_MAX, 1140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1141, UINT16_MAX, 1141, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1142, UINT16_MAX, 1142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1143, UINT16_MAX, 1143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 1144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1145, UINT16_MAX, 1145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1146, UINT16_MAX, 1146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17531, UINT16_MAX, 1149, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1150, UINT16_MAX, 1150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1151, UINT16_MAX, 1151, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1152, UINT16_MAX, 1152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1154, UINT16_MAX, 1154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 17539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17541, 1159, UINT16_MAX, 1159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 1160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17545, 1163, UINT16_MAX, 1163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17548, 1166, UINT16_MAX, 1166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17551, 1169, UINT16_MAX, 1169, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17554, 1172, UINT16_MAX, 1172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17557, 1175, UINT16_MAX, 1175, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17560, 1178, UINT16_MAX, 1178, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17563, 33949, 1184, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1185, UINT16_MAX, 1185, UINT16_MAX, 1673, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1186, UINT16_MAX, 1186, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1187, UINT16_MAX, 1187, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1188, UINT16_MAX, 1188, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1189, UINT16_MAX, 1189, UINT16_MAX, 1726, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1190, UINT16_MAX, 1190, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1191, UINT16_MAX, 1191, UINT16_MAX, 1777, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1192, UINT16_MAX, 1192, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1138, UINT16_MAX, 1138, UINT16_MAX, 1830, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1193, UINT16_MAX, 1193, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1194, UINT16_MAX, 1194, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 62, UINT16_MAX, 62, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1195, UINT16_MAX, 1195, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1196, UINT16_MAX, 1196, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1197, UINT16_MAX, 1197, UINT16_MAX, 1881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1198, UINT16_MAX, 1198, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1199, UINT16_MAX, 1199, UINT16_MAX, 5027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1200, UINT16_MAX, 1200, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1201, UINT16_MAX, 1201, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1202, UINT16_MAX, 1202, UINT16_MAX, 1932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1203, UINT16_MAX, 1203, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1204, UINT16_MAX, 1204, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1205, UINT16_MAX, 1205, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1206, UINT16_MAX, 1206, UINT16_MAX, 1983, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17591, 1209, UINT16_MAX, 1209, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17594, 1212, UINT16_MAX, 1212, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17597, UINT16_MAX, 1215, UINT16_MAX, 1215, 4904, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17600, UINT16_MAX, 1218, UINT16_MAX, 1218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17603, UINT16_MAX, 1221, UINT16_MAX, 1221, 4913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17606, UINT16_MAX, 1224, UINT16_MAX, 1224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17609, 33995, 1230, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1231, UINT16_MAX, 1231, 2088, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1232, UINT16_MAX, 1232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1233, UINT16_MAX, 1233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1234, UINT16_MAX, 1234, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1235, UINT16_MAX, 1235, 2141, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1236, UINT16_MAX, 1236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1237, UINT16_MAX, 1237, 2192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1238, UINT16_MAX, 1238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1139, UINT16_MAX, 1139, 2245, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1239, UINT16_MAX, 1239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1240, UINT16_MAX, 1240, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 63, UINT16_MAX, 63, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1241, UINT16_MAX, 1241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1242, UINT16_MAX, 1242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1243, UINT16_MAX, 1243, 2401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1244, UINT16_MAX, 1244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1245, UINT16_MAX, 1245, 5023, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1200, 1246, UINT16_MAX, 1246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1246, UINT16_MAX, 1246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1247, UINT16_MAX, 1247, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1248, UINT16_MAX, 1248, 2349, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1249, UINT16_MAX, 1249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1250, UINT16_MAX, 1250, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1251, UINT16_MAX, 1251, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1252, UINT16_MAX, 1252, 2452, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17637, UINT16_MAX, 1255, UINT16_MAX, 1255, 2036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17640, UINT16_MAX, 1258, UINT16_MAX, 1258, 2297, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17643, UINT16_MAX, 1261, UINT16_MAX, 1261, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17646, UINT16_MAX, 1264, UINT16_MAX, 1264, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17649, UINT16_MAX, 1267, UINT16_MAX, 1267, 5033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1268, UINT16_MAX, 1268, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1186, 1186, 1232, UINT16_MAX, 1232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1192, 1192, 1238, UINT16_MAX, 1238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1248, UINT16_MAX, UINT16_MAX, 1269, UINT16_MAX, 2505, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17654, UINT16_MAX, UINT16_MAX, 1272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17657, UINT16_MAX, UINT16_MAX, 1275, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1203, 1203, 1249, UINT16_MAX, 1249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1198, 1198, 1244, UINT16_MAX, 1244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1276, UINT16_MAX, 1276, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1277, UINT16_MAX, 1277, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1278, UINT16_MAX, 1278, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1279, UINT16_MAX, 1279, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1280, UINT16_MAX, 1280, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1281, UINT16_MAX, 1281, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1282, UINT16_MAX, 1282, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1283, UINT16_MAX, 1283, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1284, UINT16_MAX, 1284, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1285, UINT16_MAX, 1285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1286, UINT16_MAX, 1286, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1287, UINT16_MAX, 1287, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1288, UINT16_MAX, 1288, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1289, UINT16_MAX, 1289, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1290, UINT16_MAX, 1290, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1291, UINT16_MAX, 1291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1292, UINT16_MAX, 1292, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1293, UINT16_MAX, 1293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1294, UINT16_MAX, 1294, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1295, UINT16_MAX, 1295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1296, UINT16_MAX, 1296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1297, UINT16_MAX, 1297, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1298, UINT16_MAX, 1298, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1299, UINT16_MAX, 1299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1300, UINT16_MAX, 1300, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1193, 1193, 1239, UINT16_MAX, 1239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1199, 1199, 1245, UINT16_MAX, 1245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1301, UINT16_MAX, 1302, UINT16_MAX, 1302, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1303, UINT16_MAX, 1303, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1238, 1192, UINT16_MAX, 1192, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1189, 1189, 1235, UINT16_MAX, 1235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1304, UINT16_MAX, 1304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1305, UINT16_MAX, 1305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1246, 1306, UINT16_MAX, 1306, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1307, UINT16_MAX, 1307, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1308, UINT16_MAX, 1308, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1309, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1310, UINT16_MAX, 1310, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1311, UINT16_MAX, 1311, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1312, UINT16_MAX, 1312, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17697, 1315, UINT16_MAX, 1315, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17700, 1318, UINT16_MAX, 1318, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1319, UINT16_MAX, 1319, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17704, 1322, UINT16_MAX, 1322, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1323, UINT16_MAX, 1323, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1324, UINT16_MAX, 1324, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1325, UINT16_MAX, 1325, UINT16_MAX, 2525, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17710, 1328, UINT16_MAX, 1328, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1329, UINT16_MAX, 1329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1330, UINT16_MAX, 1330, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1331, UINT16_MAX, 1331, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1332, UINT16_MAX, 1332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17717, 1335, UINT16_MAX, 1335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17720, 1338, UINT16_MAX, 1338, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17723, 1341, UINT16_MAX, 1341, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1342, UINT16_MAX, 1342, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1343, UINT16_MAX, 1343, UINT16_MAX, 2615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1344, UINT16_MAX, 1344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1345, UINT16_MAX, 1345, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1346, UINT16_MAX, 1346, UINT16_MAX, 2522, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1347, UINT16_MAX, 1347, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1348, UINT16_MAX, 1348, UINT16_MAX, 2511, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1349, UINT16_MAX, 1349, UINT16_MAX, 2601, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1350, UINT16_MAX, 1350, UINT16_MAX, 2635, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1351, UINT16_MAX, 1351, UINT16_MAX, 2531, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17736, 1354, UINT16_MAX, 1354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1355, UINT16_MAX, 1355, UINT16_MAX, 2528, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1356, UINT16_MAX, 1356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1357, UINT16_MAX, 1357, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1358, UINT16_MAX, 1358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1359, UINT16_MAX, 1359, UINT16_MAX, 2641, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1360, UINT16_MAX, 1360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1361, UINT16_MAX, 1361, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1362, UINT16_MAX, 1362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1363, UINT16_MAX, 1363, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1364, UINT16_MAX, 1364, UINT16_MAX, 2542, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1365, UINT16_MAX, 1365, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1366, UINT16_MAX, 1366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1367, UINT16_MAX, 1367, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1368, UINT16_MAX, 1368, UINT16_MAX, 2659, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1369, UINT16_MAX, 1369, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1370, UINT16_MAX, 1370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1371, UINT16_MAX, 1371, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1372, UINT16_MAX, 1372, UINT16_MAX, 2665, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1373, UINT16_MAX, 1373, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1374, UINT16_MAX, 1374, UINT16_MAX, 2653, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1375, UINT16_MAX, 1375, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1376, UINT16_MAX, 1376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1377, UINT16_MAX, 1377, 2622, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1378, UINT16_MAX, 1378, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1379, UINT16_MAX, 1379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1380, UINT16_MAX, 1380, 2575, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1381, UINT16_MAX, 1381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1382, UINT16_MAX, 1382, 2564, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1383, UINT16_MAX, 1383, 2608, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1384, UINT16_MAX, 1384, 2638, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1385, UINT16_MAX, 1385, 2553, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17770, UINT16_MAX, 1388, UINT16_MAX, 1388, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1389, UINT16_MAX, 1389, 2581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1390, UINT16_MAX, 1390, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1391, UINT16_MAX, 1391, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1392, UINT16_MAX, 1392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1393, UINT16_MAX, 1393, 2644, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1394, UINT16_MAX, 1394, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1395, UINT16_MAX, 1395, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1396, UINT16_MAX, 1396, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1397, UINT16_MAX, 1397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1398, UINT16_MAX, 1398, 2584, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1399, UINT16_MAX, 1399, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1400, UINT16_MAX, 1400, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1401, UINT16_MAX, 1401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1402, UINT16_MAX, 1402, 2662, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1403, UINT16_MAX, 1403, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1404, UINT16_MAX, 1404, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1405, UINT16_MAX, 1405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1406, UINT16_MAX, 1406, 2668, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1407, UINT16_MAX, 1407, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1408, UINT16_MAX, 1408, 2656, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1409, UINT16_MAX, 1409, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1410, UINT16_MAX, 1410, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17795, UINT16_MAX, 1413, UINT16_MAX, 1413, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17798, UINT16_MAX, 1416, UINT16_MAX, 1416, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1417, UINT16_MAX, 1417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17802, UINT16_MAX, 1420, UINT16_MAX, 1420, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1421, UINT16_MAX, 1421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1422, UINT16_MAX, 1422, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1423, UINT16_MAX, 1423, 2578, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17808, UINT16_MAX, 1426, UINT16_MAX, 1426, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1427, UINT16_MAX, 1427, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1428, UINT16_MAX, 1428, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1429, UINT16_MAX, 1429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1430, UINT16_MAX, 1430, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17815, UINT16_MAX, 1433, UINT16_MAX, 1433, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17818, UINT16_MAX, 1436, UINT16_MAX, 1436, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17821, UINT16_MAX, 1439, UINT16_MAX, 1439, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1440, UINT16_MAX, 1440, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1441, UINT16_MAX, 1441, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1442, UINT16_MAX, 1442, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1443, UINT16_MAX, 1443, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1444, UINT16_MAX, 1444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1445, UINT16_MAX, 1445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1446, UINT16_MAX, 1446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1447, UINT16_MAX, 1447, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1448, UINT16_MAX, 1448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1449, UINT16_MAX, 1449, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1450, UINT16_MAX, 1450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1451, UINT16_MAX, 1451, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1452, UINT16_MAX, 1452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1453, UINT16_MAX, 1453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1454, UINT16_MAX, 1454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1455, UINT16_MAX, 1455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1456, UINT16_MAX, 1456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1457, UINT16_MAX, 1457, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1458, UINT16_MAX, 1458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1459, UINT16_MAX, 1459, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1460, UINT16_MAX, 1460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1461, UINT16_MAX, 1461, UINT16_MAX, 2595, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1462, UINT16_MAX, 1462, 2598, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17847, 1465, UINT16_MAX, 1465, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17850, UINT16_MAX, 1468, UINT16_MAX, 1468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1469, UINT16_MAX, 1469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1470, UINT16_MAX, 1470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1471, UINT16_MAX, 1471, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1472, UINT16_MAX, 1472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1473, UINT16_MAX, 1473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1474, UINT16_MAX, 1474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1475, UINT16_MAX, 1475, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1476, UINT16_MAX, 1476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1477, UINT16_MAX, 1477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1478, UINT16_MAX, 1478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ME, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1479, UINT16_MAX, 1479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1480, UINT16_MAX, 1480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1481, UINT16_MAX, 1481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1482, UINT16_MAX, 1482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1483, UINT16_MAX, 1483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1484, UINT16_MAX, 1484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1485, UINT16_MAX, 1485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1486, UINT16_MAX, 1486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1487, UINT16_MAX, 1487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1488, UINT16_MAX, 1488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1489, UINT16_MAX, 1489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1490, UINT16_MAX, 1490, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1491, UINT16_MAX, 1491, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1492, UINT16_MAX, 1492, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1493, UINT16_MAX, 1493, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1494, UINT16_MAX, 1494, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1495, UINT16_MAX, 1495, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1496, UINT16_MAX, 1496, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1497, UINT16_MAX, 1497, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1498, UINT16_MAX, 1498, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1499, UINT16_MAX, 1499, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1500, UINT16_MAX, 1500, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1501, UINT16_MAX, 1501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1502, UINT16_MAX, 1502, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1503, UINT16_MAX, 1503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1504, UINT16_MAX, 1504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1505, UINT16_MAX, 1505, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1506, UINT16_MAX, 1506, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1507, UINT16_MAX, 1507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1508, UINT16_MAX, 1508, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1509, UINT16_MAX, 1509, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1510, UINT16_MAX, 1510, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1511, UINT16_MAX, 1511, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1512, UINT16_MAX, 1512, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1513, UINT16_MAX, 1513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1514, UINT16_MAX, 1514, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1515, UINT16_MAX, 1515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1516, UINT16_MAX, 1516, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1517, UINT16_MAX, 1517, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1518, UINT16_MAX, 1518, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1519, UINT16_MAX, 1519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1520, UINT16_MAX, 1520, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1521, UINT16_MAX, 1521, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1522, UINT16_MAX, 1522, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1523, UINT16_MAX, 1523, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1524, UINT16_MAX, 1524, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1525, UINT16_MAX, 1525, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1526, UINT16_MAX, 1526, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1527, UINT16_MAX, 1527, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1528, UINT16_MAX, 1528, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1529, UINT16_MAX, 1529, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1530, UINT16_MAX, 1530, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1531, UINT16_MAX, 1531, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1532, UINT16_MAX, 1532, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1533, UINT16_MAX, 1533, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17918, 1536, UINT16_MAX, 1536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17921, UINT16_MAX, 1539, UINT16_MAX, 1539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1540, UINT16_MAX, 1540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1541, UINT16_MAX, 1541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1542, UINT16_MAX, 1542, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1543, UINT16_MAX, 1543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1544, UINT16_MAX, 1544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1545, UINT16_MAX, 1545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1546, UINT16_MAX, 1546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1547, UINT16_MAX, 1547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1548, UINT16_MAX, 1548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1549, UINT16_MAX, 1549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1550, UINT16_MAX, 1550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1551, UINT16_MAX, 1551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1552, UINT16_MAX, 1552, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17937, 1555, UINT16_MAX, 1555, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17940, UINT16_MAX, 1558, UINT16_MAX, 1558, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17943, 1561, UINT16_MAX, 1561, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17946, UINT16_MAX, 1564, UINT16_MAX, 1564, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1565, UINT16_MAX, 1565, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1566, UINT16_MAX, 1566, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17951, 1569, UINT16_MAX, 1569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17954, UINT16_MAX, 1572, UINT16_MAX, 1572, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1573, UINT16_MAX, 1573, UINT16_MAX, 2629, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1574, UINT16_MAX, 1574, 2632, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17959, 1577, UINT16_MAX, 1577, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17962, UINT16_MAX, 1580, UINT16_MAX, 1580, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17965, 1583, UINT16_MAX, 1583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17968, UINT16_MAX, 1586, UINT16_MAX, 1586, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17971, 1589, UINT16_MAX, 1589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17974, UINT16_MAX, 1592, UINT16_MAX, 1592, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1593, UINT16_MAX, 1593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1594, UINT16_MAX, 1594, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17979, 1597, UINT16_MAX, 1597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17982, UINT16_MAX, 1600, UINT16_MAX, 1600, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17985, 1603, UINT16_MAX, 1603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17988, UINT16_MAX, 1606, UINT16_MAX, 1606, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17991, 1609, UINT16_MAX, 1609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17994, UINT16_MAX, 1612, UINT16_MAX, 1612, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1613, UINT16_MAX, 1613, UINT16_MAX, 2647, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1614, UINT16_MAX, 1614, 2650, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17999, 1617, UINT16_MAX, 1617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18002, UINT16_MAX, 1620, UINT16_MAX, 1620, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18005, 1623, UINT16_MAX, 1623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18008, UINT16_MAX, 1626, UINT16_MAX, 1626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18011, 1629, UINT16_MAX, 1629, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18014, UINT16_MAX, 1632, UINT16_MAX, 1632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18017, 1635, UINT16_MAX, 1635, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18020, UINT16_MAX, 1638, UINT16_MAX, 1638, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18023, 1641, UINT16_MAX, 1641, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18026, UINT16_MAX, 1644, UINT16_MAX, 1644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18029, 1647, UINT16_MAX, 1647, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18032, UINT16_MAX, 1650, UINT16_MAX, 1650, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1651, UINT16_MAX, 1651, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1652, UINT16_MAX, 1652, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18037, 1655, UINT16_MAX, 1655, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18040, UINT16_MAX, 1658, UINT16_MAX, 1658, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1659, UINT16_MAX, 1659, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1660, UINT16_MAX, 1660, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1661, UINT16_MAX, 1661, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1662, UINT16_MAX, 1662, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1663, UINT16_MAX, 1663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1664, UINT16_MAX, 1664, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1665, UINT16_MAX, 1665, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1666, UINT16_MAX, 1666, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1667, UINT16_MAX, 1667, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1668, UINT16_MAX, 1668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1669, UINT16_MAX, 1669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1670, UINT16_MAX, 1670, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1671, UINT16_MAX, 1671, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1672, UINT16_MAX, 1672, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1673, UINT16_MAX, 1673, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1674, UINT16_MAX, 1674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1675, UINT16_MAX, 1675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1676, UINT16_MAX, 1676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1677, UINT16_MAX, 1677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1678, UINT16_MAX, 1678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1679, UINT16_MAX, 1679, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1680, UINT16_MAX, 1680, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1681, UINT16_MAX, 1681, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1682, UINT16_MAX, 1682, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1683, UINT16_MAX, 1683, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1684, UINT16_MAX, 1684, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1685, UINT16_MAX, 1685, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1686, UINT16_MAX, 1686, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1687, UINT16_MAX, 1687, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1688, UINT16_MAX, 1688, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1689, UINT16_MAX, 1689, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1690, UINT16_MAX, 1690, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1691, UINT16_MAX, 1691, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1692, UINT16_MAX, 1692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1693, UINT16_MAX, 1693, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1694, UINT16_MAX, 1694, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1695, UINT16_MAX, 1695, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1696, UINT16_MAX, 1696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1697, UINT16_MAX, 1697, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1698, UINT16_MAX, 1698, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1699, UINT16_MAX, 1699, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1700, UINT16_MAX, 1700, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1701, UINT16_MAX, 1701, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1702, UINT16_MAX, 1702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1703, UINT16_MAX, 1703, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1704, UINT16_MAX, 1704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1705, UINT16_MAX, 1705, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1706, UINT16_MAX, 1706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1707, UINT16_MAX, 1707, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1708, UINT16_MAX, 1708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1709, UINT16_MAX, 1709, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1710, UINT16_MAX, 1710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1711, UINT16_MAX, 1711, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1712, UINT16_MAX, 1712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1713, UINT16_MAX, 1713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1714, UINT16_MAX, 1714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1715, UINT16_MAX, 1715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1716, UINT16_MAX, 1716, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1717, UINT16_MAX, 1717, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1718, UINT16_MAX, 1718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1719, UINT16_MAX, 1719, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1720, UINT16_MAX, 1720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1721, UINT16_MAX, 1721, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1722, UINT16_MAX, 1722, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1723, UINT16_MAX, 1723, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1724, UINT16_MAX, 1724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1725, UINT16_MAX, 1725, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1726, UINT16_MAX, 1726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1727, UINT16_MAX, 1727, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1728, UINT16_MAX, 1728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1729, UINT16_MAX, 1729, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1730, UINT16_MAX, 1730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1731, UINT16_MAX, 1731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1732, UINT16_MAX, 1732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1733, UINT16_MAX, 1733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1734, UINT16_MAX, 1734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1735, UINT16_MAX, 1735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1736, UINT16_MAX, 1736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1737, UINT16_MAX, 1737, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1738, UINT16_MAX, 1738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1739, UINT16_MAX, 1739, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1740, UINT16_MAX, 1740, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1741, UINT16_MAX, 1741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1742, UINT16_MAX, 1742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1743, UINT16_MAX, 1743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1744, UINT16_MAX, 1744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1745, UINT16_MAX, 1745, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1746, UINT16_MAX, 1746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1747, UINT16_MAX, 1747, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1748, UINT16_MAX, 1748, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1749, UINT16_MAX, 1749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1750, UINT16_MAX, 1750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1751, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1752, UINT16_MAX, 1752, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1753, UINT16_MAX, 1753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1754, UINT16_MAX, 1754, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1755, UINT16_MAX, 1755, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1756, UINT16_MAX, 1756, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1757, UINT16_MAX, 1757, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1758, UINT16_MAX, 1758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1759, UINT16_MAX, 1759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1760, UINT16_MAX, 1760, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1761, UINT16_MAX, 1761, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1762, UINT16_MAX, 1762, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1763, UINT16_MAX, 1763, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1764, UINT16_MAX, 1764, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1765, UINT16_MAX, 1765, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1766, UINT16_MAX, 1766, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1767, UINT16_MAX, 1767, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1768, UINT16_MAX, 1768, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1769, UINT16_MAX, 1769, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1770, UINT16_MAX, 1770, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1771, UINT16_MAX, 1771, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1772, UINT16_MAX, 1772, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1773, UINT16_MAX, 1773, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1774, UINT16_MAX, 1774, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1775, UINT16_MAX, 1775, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1776, UINT16_MAX, 1776, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1777, UINT16_MAX, 1777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1778, UINT16_MAX, 1778, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1779, UINT16_MAX, 1779, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1780, UINT16_MAX, 1780, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1781, UINT16_MAX, 1781, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1782, UINT16_MAX, 1782, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1783, UINT16_MAX, 1783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1784, UINT16_MAX, 1784, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1785, UINT16_MAX, 1785, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1786, UINT16_MAX, 1786, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1787, UINT16_MAX, 1787, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1788, UINT16_MAX, 1788, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1789, UINT16_MAX, 1789, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18174, 18174, 1792, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1793, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 222, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 228, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 10, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 11, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 12, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 13, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 14, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 15, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 16, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 17, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 18, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 19, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 20, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 21, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 22, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 23, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 24, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 25, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 30, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 31, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 32, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2671, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2676, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2679, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 27, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 28, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 29, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 33, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 34, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32785, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32786, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32787, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 35, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2685, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2688, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2682, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 36, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2691, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2694, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2697, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32788, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32789, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2700, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32790, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32792, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2704, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32791, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32793, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2709, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32795, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2712, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2716, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32794, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2719, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 84, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 91, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32796, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2722, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32799, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2725, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2730, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32797, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32798, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32800, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2733, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2737, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32801, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32802, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32803, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2740, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2745, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32804, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 103, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 107, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 118, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 122, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NOBREAK, 1914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 129, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 130, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 132, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 18317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 18321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2748, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32805, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1955, UINT16_MAX, 1955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1956, UINT16_MAX, 1956, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1957, UINT16_MAX, 1957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1958, UINT16_MAX, 1958, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1959, UINT16_MAX, 1959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1960, UINT16_MAX, 1960, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1961, UINT16_MAX, 1961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1962, UINT16_MAX, 1962, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1963, UINT16_MAX, 1963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1964, UINT16_MAX, 1964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1965, UINT16_MAX, 1965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1966, UINT16_MAX, 1966, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1967, UINT16_MAX, 1967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1968, UINT16_MAX, 1968, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1969, UINT16_MAX, 1969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1970, UINT16_MAX, 1970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1971, UINT16_MAX, 1971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1972, UINT16_MAX, 1972, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1973, UINT16_MAX, 1973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1974, UINT16_MAX, 1974, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1975, UINT16_MAX, 1975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1976, UINT16_MAX, 1976, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1977, UINT16_MAX, 1977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1978, UINT16_MAX, 1978, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1979, UINT16_MAX, 1979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1980, UINT16_MAX, 1980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1981, UINT16_MAX, 1981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1982, UINT16_MAX, 1982, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1983, UINT16_MAX, 1983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1984, UINT16_MAX, 1984, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1985, UINT16_MAX, 1985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1986, UINT16_MAX, 1986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1987, UINT16_MAX, 1987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1988, UINT16_MAX, 1988, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1989, UINT16_MAX, 1989, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1990, UINT16_MAX, 1990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1991, UINT16_MAX, 1991, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1992, UINT16_MAX, 1992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1993, UINT16_MAX, 1993, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1994, UINT16_MAX, 1994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1995, UINT16_MAX, 1996, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1997, UINT16_MAX, 1998, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1999, UINT16_MAX, 2000, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2001, UINT16_MAX, 2002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2003, UINT16_MAX, 2004, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2005, UINT16_MAX, 2006, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2007, UINT16_MAX, 2008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2009, UINT16_MAX, 2010, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2011, UINT16_MAX, 2012, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2013, UINT16_MAX, 2014, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2015, UINT16_MAX, 2016, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2017, UINT16_MAX, 2018, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2019, UINT16_MAX, 2020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2021, UINT16_MAX, 2022, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2023, UINT16_MAX, 2024, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2025, UINT16_MAX, 2026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2027, UINT16_MAX, 2028, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2029, UINT16_MAX, 2030, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2031, UINT16_MAX, 2032, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2033, UINT16_MAX, 2034, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2035, UINT16_MAX, 2036, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2037, UINT16_MAX, 2038, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2039, UINT16_MAX, 2040, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2041, UINT16_MAX, 2042, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2043, UINT16_MAX, 2044, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2045, UINT16_MAX, 2046, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2047, UINT16_MAX, 2048, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2049, UINT16_MAX, 2050, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2051, UINT16_MAX, 2052, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2053, UINT16_MAX, 2054, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2055, UINT16_MAX, 2056, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2057, UINT16_MAX, 2058, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2059, UINT16_MAX, 2060, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2061, UINT16_MAX, 2062, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2063, UINT16_MAX, 2064, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2065, UINT16_MAX, 2066, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2067, UINT16_MAX, 2068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2069, UINT16_MAX, 2070, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2071, UINT16_MAX, 2072, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2073, UINT16_MAX, 2074, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2075, UINT16_MAX, 2076, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2077, UINT16_MAX, 2078, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2079, UINT16_MAX, 2080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2020, UINT16_MAX, 2081, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2082, UINT16_MAX, 2083, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2084, UINT16_MAX, 2085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2086, UINT16_MAX, 2087, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_L, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_L, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_V, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_V, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_T, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2091, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2098, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2099, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2102, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2109, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2111, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2112, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2121, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2127, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2133, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2136, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2138, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2141, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2144, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2146, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2161, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2164, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2165, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2167, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2168, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2169, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2170, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2171, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2173, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2174, 2174, UINT16_MAX, 2174, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2175, 2175, UINT16_MAX, 2175, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2176, 2176, UINT16_MAX, 2176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2177, 2177, UINT16_MAX, 2177, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2178, 2178, UINT16_MAX, 2178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2179, 2179, UINT16_MAX, 2179, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2751, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2754, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2757, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2760, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2763, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2766, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32806, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1345, 1379, UINT16_MAX, 1379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1347, 1381, UINT16_MAX, 1381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1359, 1393, UINT16_MAX, 1393, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1362, 1396, UINT16_MAX, 1396, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1363, 1397, UINT16_MAX, 1397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1371, 1405, UINT16_MAX, 1405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1443, 1444, UINT16_MAX, 1444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2202, 2203, UINT16_MAX, 2203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1996, UINT16_MAX, 1996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1998, UINT16_MAX, 1998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2000, UINT16_MAX, 2000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2002, UINT16_MAX, 2002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2004, UINT16_MAX, 2004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2006, UINT16_MAX, 2006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2008, UINT16_MAX, 2008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2010, UINT16_MAX, 2010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2012, UINT16_MAX, 2012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2014, UINT16_MAX, 2014, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2016, UINT16_MAX, 2016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2018, UINT16_MAX, 2018, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2020, UINT16_MAX, 2020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2022, UINT16_MAX, 2022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2024, UINT16_MAX, 2024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2026, UINT16_MAX, 2026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2028, UINT16_MAX, 2028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2030, UINT16_MAX, 2030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2032, UINT16_MAX, 2032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2034, UINT16_MAX, 2034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2036, UINT16_MAX, 2036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2038, UINT16_MAX, 2038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2040, UINT16_MAX, 2040, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2042, UINT16_MAX, 2042, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2044, UINT16_MAX, 2044, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2046, UINT16_MAX, 2046, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2048, UINT16_MAX, 2048, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2050, UINT16_MAX, 2050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2052, UINT16_MAX, 2052, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2054, UINT16_MAX, 2054, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2056, UINT16_MAX, 2056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2058, UINT16_MAX, 2058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2060, UINT16_MAX, 2060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2062, UINT16_MAX, 2062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2064, UINT16_MAX, 2064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2066, UINT16_MAX, 2066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2068, UINT16_MAX, 2068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2070, UINT16_MAX, 2070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2072, UINT16_MAX, 2072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2074, UINT16_MAX, 2074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2076, UINT16_MAX, 2076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2078, UINT16_MAX, 2078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2080, UINT16_MAX, 2080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2083, UINT16_MAX, 2083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2085, UINT16_MAX, 2085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2087, UINT16_MAX, 2087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2204, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2205, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2206, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2207, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2208, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2209, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2210, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2211, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2212, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2213, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2214, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2215, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2216, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2217, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2218, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2219, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2220, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2221, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2222, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2223, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2224, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2225, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2226, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2227, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2228, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2229, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2230, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2231, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2232, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2233, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2234, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2235, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2236, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2237, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2238, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2239, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2240, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2241, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2242, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2243, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2244, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2245, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2246, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2247, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 26, UINT16_MAX, 2248, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 180, UINT16_MAX, 2249, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 27, UINT16_MAX, 2250, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2251, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 29, UINT16_MAX, 2252, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 30, UINT16_MAX, 2253, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 746, UINT16_MAX, 2254, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 32, UINT16_MAX, 2255, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 33, UINT16_MAX, 2256, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 34, UINT16_MAX, 2257, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 35, UINT16_MAX, 2258, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 36, UINT16_MAX, 2259, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 37, UINT16_MAX, 2260, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 38, UINT16_MAX, 2261, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 39, UINT16_MAX, 2262, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2263, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 40, UINT16_MAX, 2264, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 936, UINT16_MAX, 2265, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 41, UINT16_MAX, 2266, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 43, UINT16_MAX, 2267, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 45, UINT16_MAX, 2268, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 46, UINT16_MAX, 2269, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 48, UINT16_MAX, 2270, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, 2271, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2272, UINT16_MAX, 2273, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2274, UINT16_MAX, 2275, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2206, UINT16_MAX, 2276, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1, UINT16_MAX, 2277, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3, UINT16_MAX, 2278, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4, UINT16_MAX, 2279, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 615, UINT16_MAX, 2280, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 616, UINT16_MAX, 2281, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2282, UINT16_MAX, 2283, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6, UINT16_MAX, 2284, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2285, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 10, UINT16_MAX, 2286, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 12, UINT16_MAX, 2287, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 453, UINT16_MAX, 2288, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, 2289, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 606, UINT16_MAX, 2290, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2226, UINT16_MAX, 2291, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2227, UINT16_MAX, 2292, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 15, UINT16_MAX, 2293, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 19, UINT16_MAX, 2294, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 20, UINT16_MAX, 2295, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2233, UINT16_MAX, 2296, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 628, UINT16_MAX, 2297, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 21, UINT16_MAX, 2298, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2241, UINT16_MAX, 2299, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1186, UINT16_MAX, 2300, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1187, UINT16_MAX, 2301, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1188, UINT16_MAX, 2302, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1203, UINT16_MAX, 2303, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1204, UINT16_MAX, 2304, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 8, UINT16_MAX, 2305, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 17, UINT16_MAX, 2306, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 20, UINT16_MAX, 2307, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 21, UINT16_MAX, 2308, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1186, UINT16_MAX, 2309, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1187, UINT16_MAX, 2310, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1199, UINT16_MAX, 2311, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1203, UINT16_MAX, 2312, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1204, UINT16_MAX, 2313, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2315, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2316, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2317, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2318, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2319, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2321, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2322, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2323, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2325, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2326, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1358, UINT16_MAX, 2327, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2328, UINT16_MAX, 2328, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2329, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2330, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2331, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2332, UINT16_MAX, 2332, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2333, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2334, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2335, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2336, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2337, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2338, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2339, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2340, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2341, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2342, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2343, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2344, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2345, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2346, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2347, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2348, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2349, UINT16_MAX, 2349, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2350, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2351, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2352, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2353, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2354, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2355, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2356, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2357, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2358, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2359, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2360, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2361, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2362, UINT16_MAX, 2363, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2, UINT16_MAX, 2364, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1014, UINT16_MAX, 2365, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 123, UINT16_MAX, 2366, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2282, UINT16_MAX, 2367, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5, UINT16_MAX, 2368, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1024, UINT16_MAX, 2369, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2370, UINT16_MAX, 2371, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2372, UINT16_MAX, 2373, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 623, UINT16_MAX, 2374, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 622, UINT16_MAX, 2375, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2376, UINT16_MAX, 2377, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2330, UINT16_MAX, 2378, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2379, UINT16_MAX, 2380, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1038, UINT16_MAX, 2381, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2340, UINT16_MAX, 2382, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1087, UINT16_MAX, 2383, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2384, UINT16_MAX, 2385, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1041, UINT16_MAX, 2386, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 629, UINT16_MAX, 2387, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1044, UINT16_MAX, 2388, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1045, UINT16_MAX, 2389, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 631, UINT16_MAX, 2390, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1049, UINT16_MAX, 2391, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2392, UINT16_MAX, 2393, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 645, UINT16_MAX, 2394, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 647, UINT16_MAX, 2395, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 997, UINT16_MAX, 2396, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 657, UINT16_MAX, 2397, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2232, UINT16_MAX, 2398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 658, UINT16_MAX, 2399, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 998, UINT16_MAX, 2400, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 25, UINT16_MAX, 2401, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1073, UINT16_MAX, 2402, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1074, UINT16_MAX, 2403, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 663, UINT16_MAX, 2404, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1192, UINT16_MAX, 2405, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 214, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 218, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18790, 2408, UINT16_MAX, 2408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18793, UINT16_MAX, 2411, UINT16_MAX, 2411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18796, 2414, UINT16_MAX, 2414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18799, UINT16_MAX, 2417, UINT16_MAX, 2417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18802, 2420, UINT16_MAX, 2420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18805, UINT16_MAX, 2423, UINT16_MAX, 2423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18808, 2426, UINT16_MAX, 2426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18811, UINT16_MAX, 2429, UINT16_MAX, 2429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18814, 2432, UINT16_MAX, 2432, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18817, UINT16_MAX, 2435, UINT16_MAX, 2435, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18820, 2438, UINT16_MAX, 2438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18823, UINT16_MAX, 2441, UINT16_MAX, 2441, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18826, 2444, UINT16_MAX, 2444, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18829, UINT16_MAX, 2447, UINT16_MAX, 2447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18832, 2450, UINT16_MAX, 2450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18835, UINT16_MAX, 2453, UINT16_MAX, 2453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18838, 2456, UINT16_MAX, 2456, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18841, UINT16_MAX, 2459, UINT16_MAX, 2459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18844, 2462, UINT16_MAX, 2462, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18847, UINT16_MAX, 2465, UINT16_MAX, 2465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18850, 2468, UINT16_MAX, 2468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18853, UINT16_MAX, 2471, UINT16_MAX, 2471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18856, 2474, UINT16_MAX, 2474, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18859, UINT16_MAX, 2477, UINT16_MAX, 2477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18862, 2480, UINT16_MAX, 2480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18865, UINT16_MAX, 2483, UINT16_MAX, 2483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18868, 2486, UINT16_MAX, 2486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18871, UINT16_MAX, 2489, UINT16_MAX, 2489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18874, 2492, UINT16_MAX, 2492, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18877, UINT16_MAX, 2495, UINT16_MAX, 2495, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18880, 2498, UINT16_MAX, 2498, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18883, UINT16_MAX, 2501, UINT16_MAX, 2501, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18886, 2504, UINT16_MAX, 2504, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18889, UINT16_MAX, 2507, UINT16_MAX, 2507, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18892, 2510, UINT16_MAX, 2510, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18895, UINT16_MAX, 2513, UINT16_MAX, 2513, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18898, 2516, UINT16_MAX, 2516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18901, UINT16_MAX, 2519, UINT16_MAX, 2519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18904, 2522, UINT16_MAX, 2522, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18907, UINT16_MAX, 2525, UINT16_MAX, 2525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18910, 2528, UINT16_MAX, 2528, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18913, UINT16_MAX, 2531, UINT16_MAX, 2531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18916, 2534, UINT16_MAX, 2534, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18919, UINT16_MAX, 2537, UINT16_MAX, 2537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18922, 2540, UINT16_MAX, 2540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18925, UINT16_MAX, 2543, UINT16_MAX, 2543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18928, 2546, UINT16_MAX, 2546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18931, UINT16_MAX, 2549, UINT16_MAX, 2549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18934, 2552, UINT16_MAX, 2552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18937, UINT16_MAX, 2555, UINT16_MAX, 2555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18940, 2558, UINT16_MAX, 2558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18943, UINT16_MAX, 2561, UINT16_MAX, 2561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18946, 2564, UINT16_MAX, 2564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18949, UINT16_MAX, 2567, UINT16_MAX, 2567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18952, 2570, UINT16_MAX, 2570, UINT16_MAX, 2884, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18955, UINT16_MAX, 2573, UINT16_MAX, 2573, 2887, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18958, 2576, UINT16_MAX, 2576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18961, UINT16_MAX, 2579, UINT16_MAX, 2579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18964, 2582, UINT16_MAX, 2582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18967, UINT16_MAX, 2585, UINT16_MAX, 2585, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18970, 2588, UINT16_MAX, 2588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18973, UINT16_MAX, 2591, UINT16_MAX, 2591, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18976, 2594, UINT16_MAX, 2594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18979, UINT16_MAX, 2597, UINT16_MAX, 2597, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18982, 2600, UINT16_MAX, 2600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18985, UINT16_MAX, 2603, UINT16_MAX, 2603, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18988, 2606, UINT16_MAX, 2606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18991, UINT16_MAX, 2609, UINT16_MAX, 2609, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18994, 2612, UINT16_MAX, 2612, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18997, UINT16_MAX, 2615, UINT16_MAX, 2615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19000, 2618, UINT16_MAX, 2618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19003, UINT16_MAX, 2621, UINT16_MAX, 2621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19006, 2624, UINT16_MAX, 2624, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19009, UINT16_MAX, 2627, UINT16_MAX, 2627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19012, 2630, UINT16_MAX, 2630, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19015, UINT16_MAX, 2633, UINT16_MAX, 2633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19018, 2636, UINT16_MAX, 2636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19021, UINT16_MAX, 2639, UINT16_MAX, 2639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19024, 2642, UINT16_MAX, 2642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19027, UINT16_MAX, 2645, UINT16_MAX, 2645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19030, 2648, UINT16_MAX, 2648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19033, UINT16_MAX, 2651, UINT16_MAX, 2651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19036, 2654, UINT16_MAX, 2654, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19039, UINT16_MAX, 2657, UINT16_MAX, 2657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19042, 2660, UINT16_MAX, 2660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19045, UINT16_MAX, 2663, UINT16_MAX, 2663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19048, 2666, UINT16_MAX, 2666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19051, UINT16_MAX, 2669, UINT16_MAX, 2669, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19054, 2672, UINT16_MAX, 2672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19057, UINT16_MAX, 2675, UINT16_MAX, 2675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19060, 2678, UINT16_MAX, 2678, UINT16_MAX, 3006, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19063, UINT16_MAX, 2681, UINT16_MAX, 2681, 3009, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19066, 2684, UINT16_MAX, 2684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19069, UINT16_MAX, 2687, UINT16_MAX, 2687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19072, 2690, UINT16_MAX, 2690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19075, UINT16_MAX, 2693, UINT16_MAX, 2693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19078, 2696, UINT16_MAX, 2696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19081, UINT16_MAX, 2699, UINT16_MAX, 2699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19084, 2702, UINT16_MAX, 2702, UINT16_MAX, 3024, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19087, UINT16_MAX, 2705, UINT16_MAX, 2705, 3027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19090, 2708, UINT16_MAX, 2708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19093, UINT16_MAX, 2711, UINT16_MAX, 2711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19096, 2714, UINT16_MAX, 2714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19099, UINT16_MAX, 2717, UINT16_MAX, 2717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19102, 2720, UINT16_MAX, 2720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19105, UINT16_MAX, 2723, UINT16_MAX, 2723, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19108, 2726, UINT16_MAX, 2726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19111, UINT16_MAX, 2729, UINT16_MAX, 2729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19114, 2732, UINT16_MAX, 2732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19117, UINT16_MAX, 2735, UINT16_MAX, 2735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19120, 2738, UINT16_MAX, 2738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19123, UINT16_MAX, 2741, UINT16_MAX, 2741, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19126, 2744, UINT16_MAX, 2744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19129, UINT16_MAX, 2747, UINT16_MAX, 2747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19132, 2750, UINT16_MAX, 2750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19135, UINT16_MAX, 2753, UINT16_MAX, 2753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19138, 2756, UINT16_MAX, 2756, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19141, UINT16_MAX, 2759, UINT16_MAX, 2759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19144, 2762, UINT16_MAX, 2762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19147, UINT16_MAX, 2765, UINT16_MAX, 2765, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19150, 2768, UINT16_MAX, 2768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19153, UINT16_MAX, 2771, UINT16_MAX, 2771, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19156, 2774, UINT16_MAX, 2774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19159, UINT16_MAX, 2777, UINT16_MAX, 2777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19162, 2780, UINT16_MAX, 2780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19165, UINT16_MAX, 2783, UINT16_MAX, 2783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19168, 2786, UINT16_MAX, 2786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19171, UINT16_MAX, 2789, UINT16_MAX, 2789, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19174, 2792, UINT16_MAX, 2792, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19177, UINT16_MAX, 2795, UINT16_MAX, 2795, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19180, 2798, UINT16_MAX, 2798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19183, UINT16_MAX, 2801, UINT16_MAX, 2801, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19186, 2804, UINT16_MAX, 2804, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19189, UINT16_MAX, 2807, UINT16_MAX, 2807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19192, 2810, UINT16_MAX, 2810, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19195, UINT16_MAX, 2813, UINT16_MAX, 2813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19198, 2816, UINT16_MAX, 2816, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19201, UINT16_MAX, 2819, UINT16_MAX, 2819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19204, 2822, UINT16_MAX, 2822, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19207, UINT16_MAX, 2825, UINT16_MAX, 2825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19210, 2828, UINT16_MAX, 2828, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19213, UINT16_MAX, 2831, UINT16_MAX, 2831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19216, 2834, UINT16_MAX, 2834, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19219, UINT16_MAX, 2837, UINT16_MAX, 2837, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19222, 2840, UINT16_MAX, 2840, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19225, UINT16_MAX, 2843, UINT16_MAX, 2843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19228, 2846, UINT16_MAX, 2846, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19231, UINT16_MAX, 2849, UINT16_MAX, 2849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19234, 2852, UINT16_MAX, 2852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19237, UINT16_MAX, 2855, UINT16_MAX, 2855, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19240, 19240, 2858, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19243, 19243, 2861, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19246, 19246, 2864, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19249, 19249, 2867, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19252, 19252, 2870, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19255, 2696, 2699, UINT16_MAX, 2699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2873, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2874, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16543, UINT16_MAX, 2875, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2876, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19261, 2879, UINT16_MAX, 2879, UINT16_MAX, 3241, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19264, UINT16_MAX, 2882, UINT16_MAX, 2882, 3250, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19267, 2885, UINT16_MAX, 2885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19270, UINT16_MAX, 2888, UINT16_MAX, 2888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19273, 2891, UINT16_MAX, 2891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19276, UINT16_MAX, 2894, UINT16_MAX, 2894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19279, 2897, UINT16_MAX, 2897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19282, UINT16_MAX, 2900, UINT16_MAX, 2900, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19285, 2903, UINT16_MAX, 2903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19288, UINT16_MAX, 2906, UINT16_MAX, 2906, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19291, 2909, UINT16_MAX, 2909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19294, UINT16_MAX, 2912, UINT16_MAX, 2912, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19297, 2915, UINT16_MAX, 2915, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19300, UINT16_MAX, 2918, UINT16_MAX, 2918, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19303, 2921, UINT16_MAX, 2921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19306, UINT16_MAX, 2924, UINT16_MAX, 2924, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19309, 2927, UINT16_MAX, 2927, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19312, UINT16_MAX, 2930, UINT16_MAX, 2930, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19315, 2933, UINT16_MAX, 2933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19318, UINT16_MAX, 2936, UINT16_MAX, 2936, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19321, 2939, UINT16_MAX, 2939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19324, UINT16_MAX, 2942, UINT16_MAX, 2942, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19327, 2945, UINT16_MAX, 2945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19330, UINT16_MAX, 2948, UINT16_MAX, 2948, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19333, 2951, UINT16_MAX, 2951, UINT16_MAX, 3455, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19336, UINT16_MAX, 2954, UINT16_MAX, 2954, 3458, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19339, 2957, UINT16_MAX, 2957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19342, UINT16_MAX, 2960, UINT16_MAX, 2960, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19345, 2963, UINT16_MAX, 2963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19348, UINT16_MAX, 2966, UINT16_MAX, 2966, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19351, 2969, UINT16_MAX, 2969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19354, UINT16_MAX, 2972, UINT16_MAX, 2972, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19357, 2975, UINT16_MAX, 2975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19360, UINT16_MAX, 2978, UINT16_MAX, 2978, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19363, 2981, UINT16_MAX, 2981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19366, UINT16_MAX, 2984, UINT16_MAX, 2984, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19369, 2987, UINT16_MAX, 2987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19372, UINT16_MAX, 2990, UINT16_MAX, 2990, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19375, 2993, UINT16_MAX, 2993, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19378, UINT16_MAX, 2996, UINT16_MAX, 2996, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19381, 2999, UINT16_MAX, 2999, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19384, UINT16_MAX, 3002, UINT16_MAX, 3002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19387, 3005, UINT16_MAX, 3005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19390, UINT16_MAX, 3008, UINT16_MAX, 3008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19393, 3011, UINT16_MAX, 3011, UINT16_MAX, 3559, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19396, UINT16_MAX, 3014, UINT16_MAX, 3014, 3562, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19399, 3017, UINT16_MAX, 3017, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19402, UINT16_MAX, 3020, UINT16_MAX, 3020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19405, 3023, UINT16_MAX, 3023, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19408, UINT16_MAX, 3026, UINT16_MAX, 3026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19411, 3029, UINT16_MAX, 3029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19414, UINT16_MAX, 3032, UINT16_MAX, 3032, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19417, 3035, UINT16_MAX, 3035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19420, UINT16_MAX, 3038, UINT16_MAX, 3038, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19423, 3041, UINT16_MAX, 3041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19426, UINT16_MAX, 3044, UINT16_MAX, 3044, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19429, 3047, UINT16_MAX, 3047, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19432, UINT16_MAX, 3050, UINT16_MAX, 3050, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19435, 3053, UINT16_MAX, 3053, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19438, UINT16_MAX, 3056, UINT16_MAX, 3056, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19441, 3059, UINT16_MAX, 3059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19444, UINT16_MAX, 3062, UINT16_MAX, 3062, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19447, 3065, UINT16_MAX, 3065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19450, UINT16_MAX, 3068, UINT16_MAX, 3068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19453, 3071, UINT16_MAX, 3071, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19456, UINT16_MAX, 3074, UINT16_MAX, 3074, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19459, 3077, UINT16_MAX, 3077, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19462, UINT16_MAX, 3080, UINT16_MAX, 3080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19465, 3083, UINT16_MAX, 3083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19468, UINT16_MAX, 3086, UINT16_MAX, 3086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19471, 3089, UINT16_MAX, 3089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19474, UINT16_MAX, 3092, UINT16_MAX, 3092, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19477, 3095, UINT16_MAX, 3095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19480, UINT16_MAX, 3098, UINT16_MAX, 3098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19483, 3101, UINT16_MAX, 3101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19486, UINT16_MAX, 3104, UINT16_MAX, 3104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19489, 3107, UINT16_MAX, 3107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19492, UINT16_MAX, 3110, UINT16_MAX, 3110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19495, 3113, UINT16_MAX, 3113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19498, UINT16_MAX, 3116, UINT16_MAX, 3116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19501, 3119, UINT16_MAX, 3119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19504, UINT16_MAX, 3122, UINT16_MAX, 3122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19507, 3125, UINT16_MAX, 3125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19510, UINT16_MAX, 3128, UINT16_MAX, 3128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19513, 3131, UINT16_MAX, 3131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19516, UINT16_MAX, 3134, UINT16_MAX, 3134, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19519, 3137, UINT16_MAX, 3137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19522, UINT16_MAX, 3140, UINT16_MAX, 3140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19525, 3143, UINT16_MAX, 3143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19528, UINT16_MAX, 3146, UINT16_MAX, 3146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3147, UINT16_MAX, 3147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3148, UINT16_MAX, 3148, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3149, UINT16_MAX, 3149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3150, UINT16_MAX, 3150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3151, UINT16_MAX, 3151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3152, UINT16_MAX, 3152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19537, UINT16_MAX, 3155, UINT16_MAX, 3155, 3761, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19540, UINT16_MAX, 3158, UINT16_MAX, 3158, 3814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19543, UINT16_MAX, 3161, UINT16_MAX, 3161, 4793, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19546, UINT16_MAX, 3164, UINT16_MAX, 3164, 4796, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19549, UINT16_MAX, 3167, UINT16_MAX, 3167, 4799, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19552, UINT16_MAX, 3170, UINT16_MAX, 3170, 4802, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19555, UINT16_MAX, 3173, UINT16_MAX, 3173, 4805, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19558, UINT16_MAX, 3176, UINT16_MAX, 3176, 4808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19561, 3179, UINT16_MAX, 3179, UINT16_MAX, 3867, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19564, 3182, UINT16_MAX, 3182, UINT16_MAX, 3920, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19567, 3185, UINT16_MAX, 3185, UINT16_MAX, 4811, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19570, 3188, UINT16_MAX, 3188, UINT16_MAX, 4814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19573, 3191, UINT16_MAX, 3191, UINT16_MAX, 4817, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19576, 3194, UINT16_MAX, 3194, UINT16_MAX, 4820, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19579, 3197, UINT16_MAX, 3197, UINT16_MAX, 4823, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19582, 3200, UINT16_MAX, 3200, UINT16_MAX, 4826, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19585, UINT16_MAX, 3203, UINT16_MAX, 3203, 3973, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19588, UINT16_MAX, 3206, UINT16_MAX, 3206, 3977, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19591, UINT16_MAX, 3209, UINT16_MAX, 3209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19594, UINT16_MAX, 3212, UINT16_MAX, 3212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19597, UINT16_MAX, 3215, UINT16_MAX, 3215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19600, UINT16_MAX, 3218, UINT16_MAX, 3218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19603, 3221, UINT16_MAX, 3221, UINT16_MAX, 3981, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19606, 3224, UINT16_MAX, 3224, UINT16_MAX, 3985, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19609, 3227, UINT16_MAX, 3227, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19612, 3230, UINT16_MAX, 3230, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19615, 3233, UINT16_MAX, 3233, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19618, 3236, UINT16_MAX, 3236, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19621, UINT16_MAX, 3239, UINT16_MAX, 3239, 3989, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19624, UINT16_MAX, 3242, UINT16_MAX, 3242, 4042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19627, UINT16_MAX, 3245, UINT16_MAX, 3245, 4829, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19630, UINT16_MAX, 3248, UINT16_MAX, 3248, 4832, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19633, UINT16_MAX, 3251, UINT16_MAX, 3251, 4835, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19636, UINT16_MAX, 3254, UINT16_MAX, 3254, 4838, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19639, UINT16_MAX, 3257, UINT16_MAX, 3257, 4841, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19642, UINT16_MAX, 3260, UINT16_MAX, 3260, 4844, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19645, 3263, UINT16_MAX, 3263, UINT16_MAX, 4095, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19648, 3266, UINT16_MAX, 3266, UINT16_MAX, 4148, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19651, 3269, UINT16_MAX, 3269, UINT16_MAX, 4847, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19654, 3272, UINT16_MAX, 3272, UINT16_MAX, 4850, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19657, 3275, UINT16_MAX, 3275, UINT16_MAX, 4853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19660, 3278, UINT16_MAX, 3278, UINT16_MAX, 4856, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19663, 3281, UINT16_MAX, 3281, UINT16_MAX, 4859, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19666, 3284, UINT16_MAX, 3284, UINT16_MAX, 4862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19669, UINT16_MAX, 3287, UINT16_MAX, 3287, 4201, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19672, UINT16_MAX, 3290, UINT16_MAX, 3290, 4253, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19675, UINT16_MAX, 3293, UINT16_MAX, 3293, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19678, UINT16_MAX, 3296, UINT16_MAX, 3296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19681, UINT16_MAX, 3299, UINT16_MAX, 3299, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19684, UINT16_MAX, 3302, UINT16_MAX, 3302, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19687, UINT16_MAX, 3305, UINT16_MAX, 3305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19690, UINT16_MAX, 3308, UINT16_MAX, 3308, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19693, 3311, UINT16_MAX, 3311, UINT16_MAX, 4305, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19696, 3314, UINT16_MAX, 3314, UINT16_MAX, 4357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19699, 3317, UINT16_MAX, 3317, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19702, 3320, UINT16_MAX, 3320, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19705, 3323, UINT16_MAX, 3323, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19708, 3326, UINT16_MAX, 3326, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19711, 3329, UINT16_MAX, 3329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19714, 3332, UINT16_MAX, 3332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19717, UINT16_MAX, 3335, UINT16_MAX, 3335, 4409, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19720, UINT16_MAX, 3338, UINT16_MAX, 3338, 4413, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19723, UINT16_MAX, 3341, UINT16_MAX, 3341, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19726, UINT16_MAX, 3344, UINT16_MAX, 3344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19729, UINT16_MAX, 3347, UINT16_MAX, 3347, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19732, UINT16_MAX, 3350, UINT16_MAX, 3350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19735, 3353, UINT16_MAX, 3353, UINT16_MAX, 4417, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19738, 3356, UINT16_MAX, 3356, UINT16_MAX, 4421, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19741, 3359, UINT16_MAX, 3359, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19744, 3362, UINT16_MAX, 3362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19747, 3365, UINT16_MAX, 3365, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19750, 3368, UINT16_MAX, 3368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19753, 19753, 3371, UINT16_MAX, UINT16_MAX, 4425, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19756, UINT16_MAX, 3374, UINT16_MAX, 3374, 4477, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19759, 36145, 3380, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19765, UINT16_MAX, 3383, UINT16_MAX, 3383, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19768, 36154, 3389, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19774, UINT16_MAX, 3392, UINT16_MAX, 3392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19777, 36163, 3398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19783, UINT16_MAX, 3401, UINT16_MAX, 3401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19786, 3404, UINT16_MAX, 3404, UINT16_MAX, 4529, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19789, 3407, UINT16_MAX, 3407, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19792, 3410, UINT16_MAX, 3410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19795, 3413, UINT16_MAX, 3413, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19798, UINT16_MAX, 3416, UINT16_MAX, 3416, 4581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19801, UINT16_MAX, 3419, UINT16_MAX, 3419, 4634, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19804, UINT16_MAX, 3422, UINT16_MAX, 3422, 4865, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19807, UINT16_MAX, 3425, UINT16_MAX, 3425, 4868, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19810, UINT16_MAX, 3428, UINT16_MAX, 3428, 4871, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19813, UINT16_MAX, 3431, UINT16_MAX, 3431, 4874, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19816, UINT16_MAX, 3434, UINT16_MAX, 3434, 4877, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19819, UINT16_MAX, 3437, UINT16_MAX, 3437, 4880, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19822, 3440, UINT16_MAX, 3440, UINT16_MAX, 4687, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19825, 3443, UINT16_MAX, 3443, UINT16_MAX, 4740, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19828, 3446, UINT16_MAX, 3446, UINT16_MAX, 4883, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19831, 3449, UINT16_MAX, 3449, UINT16_MAX, 4886, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19834, 3452, UINT16_MAX, 3452, UINT16_MAX, 4889, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19837, 3455, UINT16_MAX, 3455, UINT16_MAX, 4892, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19840, 3458, UINT16_MAX, 3458, UINT16_MAX, 4895, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19843, 3461, UINT16_MAX, 3461, UINT16_MAX, 4898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19846, UINT16_MAX, 3464, UINT16_MAX, 3464, 4901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1159, UINT16_MAX, 3465, UINT16_MAX, 3465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19850, UINT16_MAX, 3468, UINT16_MAX, 3468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1163, UINT16_MAX, 3469, UINT16_MAX, 3469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19854, UINT16_MAX, 3472, UINT16_MAX, 3472, 4910, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1166, UINT16_MAX, 3473, UINT16_MAX, 3473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19858, UINT16_MAX, 3476, UINT16_MAX, 3476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1169, UINT16_MAX, 3477, UINT16_MAX, 3477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19862, UINT16_MAX, 3480, UINT16_MAX, 3480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1172, UINT16_MAX, 3481, UINT16_MAX, 3481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19866, UINT16_MAX, 3484, UINT16_MAX, 3484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1175, UINT16_MAX, 3485, UINT16_MAX, 3485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19870, UINT16_MAX, 3488, UINT16_MAX, 3488, 5030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1178, UINT16_MAX, 3489, UINT16_MAX, 3489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19874, 19876, 3494, UINT16_MAX, 3494, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19879, 19881, 3499, UINT16_MAX, 3499, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19884, 19886, 3504, UINT16_MAX, 3504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19889, 19891, 3509, UINT16_MAX, 3509, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19894, 19896, 3514, UINT16_MAX, 3514, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19899, 19901, 3519, UINT16_MAX, 3519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19904, 19906, 3524, UINT16_MAX, 3524, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19909, 19911, 3529, UINT16_MAX, 3529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19914, 19876, UINT16_MAX, 3532, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19917, 19881, UINT16_MAX, 3535, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19920, 19886, UINT16_MAX, 3538, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19923, 19891, UINT16_MAX, 3541, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19926, 19896, UINT16_MAX, 3544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19929, 19901, UINT16_MAX, 3547, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19932, 19906, UINT16_MAX, 3550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19935, 19911, UINT16_MAX, 3553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19938, 19940, 3558, UINT16_MAX, 3558, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19943, 19945, 3563, UINT16_MAX, 3563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19948, 19950, 3568, UINT16_MAX, 3568, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19953, 19955, 3573, UINT16_MAX, 3573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19958, 19960, 3578, UINT16_MAX, 3578, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19963, 19965, 3583, UINT16_MAX, 3583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19968, 19970, 3588, UINT16_MAX, 3588, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19973, 19975, 3593, UINT16_MAX, 3593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19978, 19940, UINT16_MAX, 3596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19981, 19945, UINT16_MAX, 3599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19984, 19950, UINT16_MAX, 3602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19987, 19955, UINT16_MAX, 3605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19990, 19960, UINT16_MAX, 3608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19993, 19965, UINT16_MAX, 3611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19996, 19970, UINT16_MAX, 3614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19999, 19975, UINT16_MAX, 3617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20002, 20004, 3622, UINT16_MAX, 3622, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20007, 20009, 3627, UINT16_MAX, 3627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20012, 20014, 3632, UINT16_MAX, 3632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20017, 20019, 3637, UINT16_MAX, 3637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20022, 20024, 3642, UINT16_MAX, 3642, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20027, 20029, 3647, UINT16_MAX, 3647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20032, 20034, 3652, UINT16_MAX, 3652, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20037, 20039, 3657, UINT16_MAX, 3657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20042, 20004, UINT16_MAX, 3660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20045, 20009, UINT16_MAX, 3663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20048, 20014, UINT16_MAX, 3666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20051, 20019, UINT16_MAX, 3669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20054, 20024, UINT16_MAX, 3672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20057, 20029, UINT16_MAX, 3675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20060, 20034, UINT16_MAX, 3678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20063, 20039, UINT16_MAX, 3681, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20066, UINT16_MAX, 3684, UINT16_MAX, 3684, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20069, UINT16_MAX, 3687, UINT16_MAX, 3687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20072, 20074, 3692, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20077, 20079, 3697, UINT16_MAX, 3697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20082, 20084, 3702, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20087, 20087, 3705, UINT16_MAX, UINT16_MAX, 4907, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20090, 36476, 3711, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20096, 3714, UINT16_MAX, 3714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20099, 3717, UINT16_MAX, 3717, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20102, 3720, UINT16_MAX, 3720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1215, 3721, UINT16_MAX, 3721, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20106, 20079, UINT16_MAX, 3724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1138, 1138, 1139, UINT16_MAX, 1139, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4919, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20115, 20117, 3735, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20120, 20122, 3740, UINT16_MAX, 3740, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20125, 20127, 3745, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20130, 20130, 3748, UINT16_MAX, UINT16_MAX, 4916, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20133, 36519, 3754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20139, 3757, UINT16_MAX, 3757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1218, 3758, UINT16_MAX, 3758, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20143, 3761, UINT16_MAX, 3761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1221, 3762, UINT16_MAX, 3762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20147, 20122, UINT16_MAX, 3765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20156, UINT16_MAX, 3774, UINT16_MAX, 3774, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20159, UINT16_MAX, 3777, UINT16_MAX, 3777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20162, 36548, 3783, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1184, 33949, 3784, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20169, 20169, 3787, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20172, 36558, 3793, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20178, 3796, UINT16_MAX, 3796, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20181, 3799, UINT16_MAX, 3799, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20184, 3802, UINT16_MAX, 3802, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1224, 3803, UINT16_MAX, 3803, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20194, UINT16_MAX, 3812, UINT16_MAX, 3812, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20197, UINT16_MAX, 3815, UINT16_MAX, 3815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20200, 36586, 3821, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1230, 33995, 3822, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20207, 20207, 3825, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20210, UINT16_MAX, 3828, UINT16_MAX, 3828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20213, 20213, 3831, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20216, 36602, 3837, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20222, 3840, UINT16_MAX, 3840, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20225, 3843, UINT16_MAX, 3843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20228, 3846, UINT16_MAX, 3846, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1264, 3847, UINT16_MAX, 3847, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20232, 3850, UINT16_MAX, 3850, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20239, 20241, 3859, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20244, 20246, 3864, UINT16_MAX, 3864, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20249, 20251, 3869, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20254, 20254, 3872, UINT16_MAX, UINT16_MAX, 5036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20257, 36643, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20263, 3881, UINT16_MAX, 3881, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1261, 3882, UINT16_MAX, 3882, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20267, 3885, UINT16_MAX, 3885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1267, 3886, UINT16_MAX, 3886, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20271, 20246, UINT16_MAX, 3889, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4971, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 3893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 3894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_COMPAT, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_NOBREAK, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_ZWJ, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NOBREAK, 3895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZL, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZP, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDF, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 20288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 36674, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_FSI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8, UINT16_MAX, 3930, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 3938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 13, UINT16_MAX, 3942, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 3938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 0, UINT16_MAX, 3943, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 4, UINT16_MAX, 3944, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 14, UINT16_MAX, 3945, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 23, UINT16_MAX, 3946, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 615, UINT16_MAX, 3947, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 7, UINT16_MAX, 3948, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 10, UINT16_MAX, 3949, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 11, UINT16_MAX, 3950, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 12, UINT16_MAX, 3951, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 13, UINT16_MAX, 3952, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 15, UINT16_MAX, 3953, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 18, UINT16_MAX, 3954, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 19, UINT16_MAX, 3955, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 20340, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 3964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1020, UINT16_MAX, UINT16_MAX, 3973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 3976, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 3977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 3978, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 3979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 3980, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 357, UINT16_MAX, 3981, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 3982, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 3983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 3984, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 3985, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 3986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 3989, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 3990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 3991, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 3992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 3993, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 20378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 20383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 4001, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1252, 1206, UINT16_MAX, 1206, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 4002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 36, 10, UINT16_MAX, 10, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 179, 94, UINT16_MAX, 94, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 4003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 4004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 4005, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 4006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 4007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4008, UINT16_MAX, 4008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 4009, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 4010, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 4015, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 4019, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 4020, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 4021, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 4022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 4023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 4024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 4025, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 4026, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 4027, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 4028, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4029, UINT16_MAX, 4029, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 53188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36824, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36833, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 20461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 34, 4079, UINT16_MAX, 4079, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20464, 4082, UINT16_MAX, 4082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36851, 4086, UINT16_MAX, 4086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20471, 4089, UINT16_MAX, 4089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 47, 4090, UINT16_MAX, 4090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20475, 4093, UINT16_MAX, 4093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36862, 4097, UINT16_MAX, 4097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 53250, 4103, UINT16_MAX, 4103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20488, 4106, UINT16_MAX, 4106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 49, 4107, UINT16_MAX, 4107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20492, 4110, UINT16_MAX, 4110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36879, 4114, UINT16_MAX, 4114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37, 4115, UINT16_MAX, 4115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28, 4116, UINT16_MAX, 4116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 29, 4117, UINT16_MAX, 4117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38, 4118, UINT16_MAX, 4118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8, UINT16_MAX, 4119, UINT16_MAX, 4119, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20504, UINT16_MAX, 4122, UINT16_MAX, 4122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36891, UINT16_MAX, 4126, UINT16_MAX, 4126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20511, UINT16_MAX, 4129, UINT16_MAX, 4129, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21, UINT16_MAX, 4130, UINT16_MAX, 4130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20515, UINT16_MAX, 4133, UINT16_MAX, 4133, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36902, UINT16_MAX, 4137, UINT16_MAX, 4137, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 53290, UINT16_MAX, 4143, UINT16_MAX, 4143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20528, UINT16_MAX, 4146, UINT16_MAX, 4146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23, UINT16_MAX, 4147, UINT16_MAX, 4147, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20532, UINT16_MAX, 4150, UINT16_MAX, 4150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36919, UINT16_MAX, 4154, UINT16_MAX, 4154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11, UINT16_MAX, 4155, UINT16_MAX, 4155, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2, UINT16_MAX, 4156, UINT16_MAX, 4156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3, UINT16_MAX, 4157, UINT16_MAX, 4157, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12, UINT16_MAX, 4158, UINT16_MAX, 4158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4159, UINT16_MAX, 4159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4160, UINT16_MAX, 4160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5045, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5048, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5054, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5051, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5057, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5060, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5063, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5066, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5069, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5072, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5075, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5078, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5081, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5090, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5099, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5102, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5105, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5108, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5111, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5114, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5117, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5120, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5147, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5150, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5123, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5126, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5129, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5132, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5153, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5156, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5135, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5138, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5141, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5144, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5159, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5162, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5165, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5168, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, 4262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, 4263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 26, 4497, UINT16_MAX, 4497, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 27, 4498, UINT16_MAX, 4498, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28, 4499, UINT16_MAX, 4499, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 29, 4500, UINT16_MAX, 4500, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 30, 4501, UINT16_MAX, 4501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 31, 4502, UINT16_MAX, 4502, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 32, 4503, UINT16_MAX, 4503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 33, 4504, UINT16_MAX, 4504, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 34, 4505, UINT16_MAX, 4505, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 35, 4506, UINT16_MAX, 4506, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 36, 4507, UINT16_MAX, 4507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 37, 4508, UINT16_MAX, 4508, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 38, 4509, UINT16_MAX, 4509, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 39, 4510, UINT16_MAX, 4510, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 40, 4511, UINT16_MAX, 4511, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 41, 4512, UINT16_MAX, 4512, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 42, 4513, UINT16_MAX, 4513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 43, 4514, UINT16_MAX, 4514, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 44, 4515, UINT16_MAX, 4515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 45, 4516, UINT16_MAX, 4516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 46, 4517, UINT16_MAX, 4517, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 47, 4518, UINT16_MAX, 4518, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 48, 4519, UINT16_MAX, 4519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 49, 4520, UINT16_MAX, 4520, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 50, 4521, UINT16_MAX, 4521, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 51, 4522, UINT16_MAX, 4522, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 0, UINT16_MAX, 4523, UINT16_MAX, 4523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1, UINT16_MAX, 4524, UINT16_MAX, 4524, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2, UINT16_MAX, 4525, UINT16_MAX, 4525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3, UINT16_MAX, 4526, UINT16_MAX, 4526, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4, UINT16_MAX, 4527, UINT16_MAX, 4527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5, UINT16_MAX, 4528, UINT16_MAX, 4528, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 6, UINT16_MAX, 4529, UINT16_MAX, 4529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7, UINT16_MAX, 4530, UINT16_MAX, 4530, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 8, UINT16_MAX, 4531, UINT16_MAX, 4531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 9, UINT16_MAX, 4532, UINT16_MAX, 4532, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 10, UINT16_MAX, 4533, UINT16_MAX, 4533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 11, UINT16_MAX, 4534, UINT16_MAX, 4534, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12, UINT16_MAX, 4535, UINT16_MAX, 4535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 13, UINT16_MAX, 4536, UINT16_MAX, 4536, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 14, UINT16_MAX, 4537, UINT16_MAX, 4537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15, UINT16_MAX, 4538, UINT16_MAX, 4538, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 16, UINT16_MAX, 4539, UINT16_MAX, 4539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 17, UINT16_MAX, 4540, UINT16_MAX, 4540, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 18, UINT16_MAX, 4541, UINT16_MAX, 4541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 19, UINT16_MAX, 4542, UINT16_MAX, 4542, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 20, UINT16_MAX, 4543, UINT16_MAX, 4543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21, UINT16_MAX, 4544, UINT16_MAX, 4544, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 22, UINT16_MAX, 4545, UINT16_MAX, 4545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 23, UINT16_MAX, 4546, UINT16_MAX, 4546, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 24, UINT16_MAX, 4547, UINT16_MAX, 4547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 25, UINT16_MAX, 4548, UINT16_MAX, 4548, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5171, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4564, UINT16_MAX, 4564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4565, UINT16_MAX, 4565, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4566, UINT16_MAX, 4566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4567, UINT16_MAX, 4567, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4568, UINT16_MAX, 4568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4569, UINT16_MAX, 4569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4570, UINT16_MAX, 4570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4571, UINT16_MAX, 4571, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4572, UINT16_MAX, 4572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4573, UINT16_MAX, 4573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4574, UINT16_MAX, 4574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4575, UINT16_MAX, 4575, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4576, UINT16_MAX, 4576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4577, UINT16_MAX, 4577, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4578, UINT16_MAX, 4578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4579, UINT16_MAX, 4579, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4580, UINT16_MAX, 4580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4581, UINT16_MAX, 4581, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4582, UINT16_MAX, 4582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4583, UINT16_MAX, 4583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4584, UINT16_MAX, 4584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4585, UINT16_MAX, 4585, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4586, UINT16_MAX, 4586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4587, UINT16_MAX, 4587, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4588, UINT16_MAX, 4588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4589, UINT16_MAX, 4589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4590, UINT16_MAX, 4590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4591, UINT16_MAX, 4591, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4592, UINT16_MAX, 4592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4593, UINT16_MAX, 4593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4594, UINT16_MAX, 4594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4595, UINT16_MAX, 4595, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4596, UINT16_MAX, 4596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4597, UINT16_MAX, 4597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4598, UINT16_MAX, 4598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4599, UINT16_MAX, 4599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4600, UINT16_MAX, 4600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4601, UINT16_MAX, 4601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4602, UINT16_MAX, 4602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4603, UINT16_MAX, 4603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4604, UINT16_MAX, 4604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4605, UINT16_MAX, 4605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4606, UINT16_MAX, 4606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4607, UINT16_MAX, 4607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4608, UINT16_MAX, 4608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4609, UINT16_MAX, 4609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4610, UINT16_MAX, 4610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4611, UINT16_MAX, 4611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4612, UINT16_MAX, 4612, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4613, UINT16_MAX, 4613, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4614, UINT16_MAX, 4614, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4615, UINT16_MAX, 4615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4616, UINT16_MAX, 4616, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4617, UINT16_MAX, 4617, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4618, UINT16_MAX, 4618, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4619, UINT16_MAX, 4619, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4620, UINT16_MAX, 4620, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4621, UINT16_MAX, 4621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4622, UINT16_MAX, 4622, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4623, UINT16_MAX, 4623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4624, UINT16_MAX, 4624, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4625, UINT16_MAX, 4625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4626, UINT16_MAX, 4626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4627, UINT16_MAX, 4627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4628, UINT16_MAX, 4628, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4629, UINT16_MAX, 4629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4630, UINT16_MAX, 4630, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4631, UINT16_MAX, 4631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4632, UINT16_MAX, 4632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4633, UINT16_MAX, 4633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4634, UINT16_MAX, 4634, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4635, UINT16_MAX, 4635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4636, UINT16_MAX, 4636, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4637, UINT16_MAX, 4637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4638, UINT16_MAX, 4638, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4639, UINT16_MAX, 4639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4640, UINT16_MAX, 4640, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4641, UINT16_MAX, 4641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4642, UINT16_MAX, 4642, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4643, UINT16_MAX, 4643, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4644, UINT16_MAX, 4644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4645, UINT16_MAX, 4645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4646, UINT16_MAX, 4646, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4647, UINT16_MAX, 4647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4648, UINT16_MAX, 4648, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4649, UINT16_MAX, 4649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4650, UINT16_MAX, 4650, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4651, UINT16_MAX, 4651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4652, UINT16_MAX, 4652, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4653, UINT16_MAX, 4653, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4654, UINT16_MAX, 4654, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4655, UINT16_MAX, 4655, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4656, UINT16_MAX, 4656, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4657, UINT16_MAX, 4657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4658, UINT16_MAX, 4658, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4659, UINT16_MAX, 4659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4660, UINT16_MAX, 4660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4661, UINT16_MAX, 4661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4662, UINT16_MAX, 4662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4663, UINT16_MAX, 4663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4664, UINT16_MAX, 4664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4665, UINT16_MAX, 4665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4666, UINT16_MAX, 4666, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4667, UINT16_MAX, 4667, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4668, UINT16_MAX, 4668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4669, UINT16_MAX, 4669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4670, UINT16_MAX, 4670, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4671, UINT16_MAX, 4671, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4672, UINT16_MAX, 4672, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2274, UINT16_MAX, 2274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2384, UINT16_MAX, 2384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2272, UINT16_MAX, 2272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2362, UINT16_MAX, 2362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4673, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4674, UINT16_MAX, 4674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4675, UINT16_MAX, 4675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4676, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4677, UINT16_MAX, 4677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4678, UINT16_MAX, 4678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4679, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4680, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4681, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4682, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4683, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 9, UINT16_MAX, 4684, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 47, UINT16_MAX, 4685, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4686, UINT16_MAX, 4686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4687, UINT16_MAX, 4687, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4688, UINT16_MAX, 4688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4689, UINT16_MAX, 4689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4690, UINT16_MAX, 4690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4691, UINT16_MAX, 4691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4692, UINT16_MAX, 4692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4693, UINT16_MAX, 4693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4694, UINT16_MAX, 4694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4695, UINT16_MAX, 4695, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4696, UINT16_MAX, 4696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4697, UINT16_MAX, 4697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4698, UINT16_MAX, 4698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4699, UINT16_MAX, 4699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4700, UINT16_MAX, 4700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4701, UINT16_MAX, 4701, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4702, UINT16_MAX, 4702, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4703, UINT16_MAX, 4703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4704, UINT16_MAX, 4704, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4705, UINT16_MAX, 4705, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4706, UINT16_MAX, 4706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4707, UINT16_MAX, 4707, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4708, UINT16_MAX, 4708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4709, UINT16_MAX, 4709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4710, UINT16_MAX, 4710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4711, UINT16_MAX, 4711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4712, UINT16_MAX, 4712, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4713, UINT16_MAX, 4713, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4714, UINT16_MAX, 4714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4715, UINT16_MAX, 4715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4716, UINT16_MAX, 4716, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4717, UINT16_MAX, 4717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4718, UINT16_MAX, 4718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4719, UINT16_MAX, 4719, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4720, UINT16_MAX, 4720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4721, UINT16_MAX, 4721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4722, UINT16_MAX, 4722, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4723, UINT16_MAX, 4723, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4724, UINT16_MAX, 4724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4725, UINT16_MAX, 4725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4726, UINT16_MAX, 4726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4727, UINT16_MAX, 4727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4728, UINT16_MAX, 4728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4729, UINT16_MAX, 4729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4730, UINT16_MAX, 4730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4731, UINT16_MAX, 4731, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4732, UINT16_MAX, 4732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4733, UINT16_MAX, 4733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4734, UINT16_MAX, 4734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4735, UINT16_MAX, 4735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4736, UINT16_MAX, 4736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4737, UINT16_MAX, 4737, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4738, UINT16_MAX, 4738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4739, UINT16_MAX, 4739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4740, UINT16_MAX, 4740, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4741, UINT16_MAX, 4741, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4742, UINT16_MAX, 4742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4743, UINT16_MAX, 4743, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4744, UINT16_MAX, 4744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4745, UINT16_MAX, 4745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4746, UINT16_MAX, 4746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4747, UINT16_MAX, 4747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4748, UINT16_MAX, 4748, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4749, UINT16_MAX, 4749, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4750, UINT16_MAX, 4750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4751, UINT16_MAX, 4751, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4752, UINT16_MAX, 4752, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4753, UINT16_MAX, 4753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4754, UINT16_MAX, 4754, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4755, UINT16_MAX, 4755, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4756, UINT16_MAX, 4756, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4757, UINT16_MAX, 4757, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4758, UINT16_MAX, 4758, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4759, UINT16_MAX, 4759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4760, UINT16_MAX, 4760, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4761, UINT16_MAX, 4761, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4762, UINT16_MAX, 4762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4763, UINT16_MAX, 4763, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4764, UINT16_MAX, 4764, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4765, UINT16_MAX, 4765, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4766, UINT16_MAX, 4766, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4767, UINT16_MAX, 4767, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4768, UINT16_MAX, 4768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4769, UINT16_MAX, 4769, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4770, UINT16_MAX, 4770, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4771, UINT16_MAX, 4771, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4772, UINT16_MAX, 4772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4773, UINT16_MAX, 4773, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4774, UINT16_MAX, 4774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4775, UINT16_MAX, 4775, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4776, UINT16_MAX, 4776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4777, UINT16_MAX, 4777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4778, UINT16_MAX, 4778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4779, UINT16_MAX, 4779, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4780, UINT16_MAX, 4780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4781, UINT16_MAX, 4781, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4782, UINT16_MAX, 4782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4783, UINT16_MAX, 4783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4784, UINT16_MAX, 4784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4785, UINT16_MAX, 4785, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4786, UINT16_MAX, 4786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4787, UINT16_MAX, 4787, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4788, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4789, UINT16_MAX, 4789, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4790, UINT16_MAX, 4790, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4791, UINT16_MAX, 4791, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4792, UINT16_MAX, 4792, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4793, UINT16_MAX, 4793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4794, UINT16_MAX, 4794, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4795, UINT16_MAX, 4795, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4796, UINT16_MAX, 4796, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4797, UINT16_MAX, 4797, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4798, UINT16_MAX, 4798, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4799, UINT16_MAX, 4799, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4800, UINT16_MAX, 4800, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4801, UINT16_MAX, 4801, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4802, UINT16_MAX, 4802, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4803, UINT16_MAX, 4803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4804, UINT16_MAX, 4804, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4805, UINT16_MAX, 4805, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4806, UINT16_MAX, 4806, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4807, UINT16_MAX, 4807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4808, UINT16_MAX, 4808, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4809, UINT16_MAX, 4809, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4810, UINT16_MAX, 4810, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4811, UINT16_MAX, 4811, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4812, UINT16_MAX, 4812, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4813, UINT16_MAX, 4813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4814, UINT16_MAX, 4814, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4815, UINT16_MAX, 4815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4816, UINT16_MAX, 4816, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4817, UINT16_MAX, 4817, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4818, UINT16_MAX, 4818, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4819, UINT16_MAX, 4819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4820, UINT16_MAX, 4820, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4821, UINT16_MAX, 4821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4822, UINT16_MAX, 4822, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4823, UINT16_MAX, 4823, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4824, UINT16_MAX, 4824, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4825, UINT16_MAX, 4825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4826, UINT16_MAX, 4826, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4827, UINT16_MAX, 4827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4828, UINT16_MAX, 4828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4829, UINT16_MAX, 4829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4830, UINT16_MAX, 4830, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4831, UINT16_MAX, 4831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4832, UINT16_MAX, 4832, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4833, UINT16_MAX, 4833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4834, UINT16_MAX, 4834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4877, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4887, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4889, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4973, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4977, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4979, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5019, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5025, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5027, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5031, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5039, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5047, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_WIDE, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 224, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5239, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5174, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5177, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5180, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5183, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5186, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5189, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5192, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5195, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5198, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5201, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5204, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5207, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5210, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5213, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5216, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5219, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5223, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5227, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5231, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5235, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32820, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32821, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 21491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 21493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5242, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 21495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 21497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5310, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5245, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5248, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5251, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5254, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5257, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5260, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5263, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5266, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5269, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5272, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5275, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5278, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5281, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5284, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5287, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5290, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5294, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5298, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5302, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5306, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5313, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5316, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5319, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5322, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5325, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 21559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 21561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38087, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 54552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 54560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 54739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 54745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5727, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38682, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55083, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55107, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55139, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38877, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38889, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22727, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39135, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 39189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 39192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22811, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22817, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22823, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 39279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6514, UINT16_MAX, 6514, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6515, UINT16_MAX, 6515, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6516, UINT16_MAX, 6516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6517, UINT16_MAX, 6517, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6518, UINT16_MAX, 6518, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6519, UINT16_MAX, 6519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6520, UINT16_MAX, 6520, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6521, UINT16_MAX, 6521, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6522, UINT16_MAX, 6522, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6523, UINT16_MAX, 6523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2202, UINT16_MAX, 2202, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2203, UINT16_MAX, 2203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6524, UINT16_MAX, 6524, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6525, UINT16_MAX, 6525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6526, UINT16_MAX, 6526, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6527, UINT16_MAX, 6527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6528, UINT16_MAX, 6528, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6529, UINT16_MAX, 6529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6530, UINT16_MAX, 6530, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6531, UINT16_MAX, 6531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6532, UINT16_MAX, 6532, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6533, UINT16_MAX, 6533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6534, UINT16_MAX, 6534, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6535, UINT16_MAX, 6535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6536, UINT16_MAX, 6536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6537, UINT16_MAX, 6537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6538, UINT16_MAX, 6538, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6539, UINT16_MAX, 6539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6540, UINT16_MAX, 6540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6541, UINT16_MAX, 6541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6542, UINT16_MAX, 6542, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6543, UINT16_MAX, 6543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6544, UINT16_MAX, 6544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6545, UINT16_MAX, 6545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6546, UINT16_MAX, 6546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6547, UINT16_MAX, 6547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6548, UINT16_MAX, 6548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6549, UINT16_MAX, 6549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6550, UINT16_MAX, 6550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6551, UINT16_MAX, 6551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6552, UINT16_MAX, 6552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6553, UINT16_MAX, 6553, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6554, UINT16_MAX, 6554, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6555, UINT16_MAX, 6555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6556, UINT16_MAX, 6556, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6557, UINT16_MAX, 6557, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6558, UINT16_MAX, 6558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6559, UINT16_MAX, 6559, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6560, UINT16_MAX, 6560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6561, UINT16_MAX, 6561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6562, UINT16_MAX, 6562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6563, UINT16_MAX, 6563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6564, UINT16_MAX, 6564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6565, UINT16_MAX, 6565, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6566, UINT16_MAX, 6566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6567, UINT16_MAX, 6567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6568, UINT16_MAX, 6568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6569, UINT16_MAX, 6569, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6570, UINT16_MAX, 6570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6571, UINT16_MAX, 6571, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6572, UINT16_MAX, 6572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6573, UINT16_MAX, 6573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6574, UINT16_MAX, 6574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6575, UINT16_MAX, 6575, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6576, UINT16_MAX, 6576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6577, UINT16_MAX, 6577, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6578, UINT16_MAX, 6578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6579, UINT16_MAX, 6579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6580, UINT16_MAX, 6580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6581, UINT16_MAX, 6581, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6582, UINT16_MAX, 6582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6583, UINT16_MAX, 6583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6584, UINT16_MAX, 6584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6585, UINT16_MAX, 6585, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1371, UINT16_MAX, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1373, UINT16_MAX, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6588, UINT16_MAX, 6588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6589, UINT16_MAX, 6589, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6590, UINT16_MAX, 6590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6591, UINT16_MAX, 6591, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6592, UINT16_MAX, 6592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6593, UINT16_MAX, 6593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6594, UINT16_MAX, 6594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6595, UINT16_MAX, 6595, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6596, UINT16_MAX, 6596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6597, UINT16_MAX, 6597, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6598, UINT16_MAX, 6598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6599, UINT16_MAX, 6599, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6600, UINT16_MAX, 6600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6601, UINT16_MAX, 6601, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6604, UINT16_MAX, 6604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6605, UINT16_MAX, 6605, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6606, UINT16_MAX, 6606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6607, UINT16_MAX, 6607, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6608, UINT16_MAX, 6608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6609, UINT16_MAX, 6609, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6610, UINT16_MAX, 6610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6611, UINT16_MAX, 6611, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6612, UINT16_MAX, 6612, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6613, UINT16_MAX, 6613, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6614, UINT16_MAX, 6614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6615, UINT16_MAX, 6615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6616, UINT16_MAX, 6616, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6617, UINT16_MAX, 6617, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6618, UINT16_MAX, 6618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6619, UINT16_MAX, 6619, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6620, UINT16_MAX, 6620, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6621, UINT16_MAX, 6621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6622, UINT16_MAX, 6622, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6623, UINT16_MAX, 6623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6624, UINT16_MAX, 6624, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6625, UINT16_MAX, 6625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6626, UINT16_MAX, 6626, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6627, UINT16_MAX, 6627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6628, UINT16_MAX, 6628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6629, UINT16_MAX, 6629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6630, UINT16_MAX, 6630, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6631, UINT16_MAX, 6631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6632, UINT16_MAX, 6632, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6633, UINT16_MAX, 6633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6634, UINT16_MAX, 6634, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6635, UINT16_MAX, 6635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6636, UINT16_MAX, 6636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6637, UINT16_MAX, 6637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6638, UINT16_MAX, 6638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6639, UINT16_MAX, 6639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6640, UINT16_MAX, 6640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6641, UINT16_MAX, 6641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6642, UINT16_MAX, 6642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6643, UINT16_MAX, 6643, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6644, UINT16_MAX, 6644, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6645, UINT16_MAX, 6645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6646, UINT16_MAX, 6646, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6647, UINT16_MAX, 6647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6648, UINT16_MAX, 6648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6649, UINT16_MAX, 6649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6650, UINT16_MAX, 6650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6651, UINT16_MAX, 6651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6652, UINT16_MAX, 6652, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6653, UINT16_MAX, 6653, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6654, UINT16_MAX, 6654, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6655, UINT16_MAX, 6655, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6656, UINT16_MAX, 6656, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6657, UINT16_MAX, 6657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6658, UINT16_MAX, 6658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6659, UINT16_MAX, 6659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6660, UINT16_MAX, 6660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6661, UINT16_MAX, 6661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6662, UINT16_MAX, 6662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6663, UINT16_MAX, 6663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6664, UINT16_MAX, 6664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6665, UINT16_MAX, 6665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6664, UINT16_MAX, 6666, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6667, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6668, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6669, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6670, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6671, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6672, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6673, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6674, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6675, UINT16_MAX, 6675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6676, UINT16_MAX, 6676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6677, UINT16_MAX, 6677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6678, UINT16_MAX, 6678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6679, UINT16_MAX, 6679, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6680, UINT16_MAX, 6680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6681, UINT16_MAX, 6681, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6682, UINT16_MAX, 6682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6683, UINT16_MAX, 6683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6684, UINT16_MAX, 6684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6685, UINT16_MAX, 6685, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6686, UINT16_MAX, 6686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6687, UINT16_MAX, 6687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6688, UINT16_MAX, 6688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6689, UINT16_MAX, 6689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6690, UINT16_MAX, 6690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6691, UINT16_MAX, 6691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2372, UINT16_MAX, 2372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6692, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6693, UINT16_MAX, 6693, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6694, UINT16_MAX, 6694, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6695, UINT16_MAX, 6695, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6696, UINT16_MAX, 6696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6697, UINT16_MAX, 6697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6698, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6699, UINT16_MAX, 6699, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6700, UINT16_MAX, 6700, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6701, UINT16_MAX, 6701, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6702, UINT16_MAX, 6702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6703, UINT16_MAX, 6703, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6704, UINT16_MAX, 6704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6705, UINT16_MAX, 6705, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6706, UINT16_MAX, 6706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6707, UINT16_MAX, 6707, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6708, UINT16_MAX, 6708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6709, UINT16_MAX, 6709, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6710, UINT16_MAX, 6710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6711, UINT16_MAX, 6711, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6712, UINT16_MAX, 6712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6713, UINT16_MAX, 6713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6714, UINT16_MAX, 6714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6715, UINT16_MAX, 6715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6716, UINT16_MAX, 6716, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6717, UINT16_MAX, 6717, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6718, UINT16_MAX, 6718, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1105, UINT16_MAX, 1105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2282, UINT16_MAX, 2282, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2370, UINT16_MAX, 2370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6719, UINT16_MAX, 6719, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2376, UINT16_MAX, 2376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6720, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6721, UINT16_MAX, 6721, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6722, UINT16_MAX, 6722, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2379, UINT16_MAX, 2379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6723, UINT16_MAX, 6723, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6724, UINT16_MAX, 6724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6725, UINT16_MAX, 6725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6726, UINT16_MAX, 6726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6727, UINT16_MAX, 6727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6728, UINT16_MAX, 6728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6729, UINT16_MAX, 6729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6730, UINT16_MAX, 6730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6731, UINT16_MAX, 6731, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6732, UINT16_MAX, 6732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6733, UINT16_MAX, 6733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6734, UINT16_MAX, 6734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6735, UINT16_MAX, 6735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6736, UINT16_MAX, 6736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6737, UINT16_MAX, 6737, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6738, UINT16_MAX, 6738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6739, UINT16_MAX, 6739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6740, UINT16_MAX, 6740, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2392, UINT16_MAX, 2392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6741, UINT16_MAX, 6741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6742, UINT16_MAX, 6742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6743, UINT16_MAX, 6743, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6744, UINT16_MAX, 6744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6745, UINT16_MAX, 6745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6746, UINT16_MAX, 6746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6747, UINT16_MAX, 6747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6748, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6749, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6750, UINT16_MAX, 6750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6751, UINT16_MAX, 6751, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6752, UINT16_MAX, 6752, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6753, UINT16_MAX, 6753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 28, UINT16_MAX, 6754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 31, UINT16_MAX, 6755, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 42, UINT16_MAX, 6756, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6757, UINT16_MAX, 6757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6758, UINT16_MAX, 6758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 358, UINT16_MAX, 6759, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 473, UINT16_MAX, 6760, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6761, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6762, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6763, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6764, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6765, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6766, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6767, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6768, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6769, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6770, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6771, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6772, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6773, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6774, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6775, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6776, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6777, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6778, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6779, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6780, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6781, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6782, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6783, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6784, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6785, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6786, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6787, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6788, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6789, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6790, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6791, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6792, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6793, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6794, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6795, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6796, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6797, UINT16_MAX, 6797, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6798, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6799, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6800, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6801, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6802, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6803, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6804, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6592, UINT16_MAX, 6805, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6769, UINT16_MAX, 6806, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4662, UINT16_MAX, 6807, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6796, UINT16_MAX, 6808, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6809, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6810, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6811, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6812, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6813, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6814, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6815, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6816, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6817, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1070, UINT16_MAX, 6818, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6819, 6819, UINT16_MAX, 6819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6820, 6820, UINT16_MAX, 6820, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6821, 6821, UINT16_MAX, 6821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6822, 6822, UINT16_MAX, 6822, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6823, 6823, UINT16_MAX, 6823, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6824, 6824, UINT16_MAX, 6824, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6825, 6825, UINT16_MAX, 6825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6826, 6826, UINT16_MAX, 6826, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6827, 6827, UINT16_MAX, 6827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6828, 6828, UINT16_MAX, 6828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6829, 6829, UINT16_MAX, 6829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6830, 6830, UINT16_MAX, 6830, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6831, 6831, UINT16_MAX, 6831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6832, 6832, UINT16_MAX, 6832, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6833, 6833, UINT16_MAX, 6833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6834, 6834, UINT16_MAX, 6834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6835, 6835, UINT16_MAX, 6835, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6836, 6836, UINT16_MAX, 6836, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6837, 6837, UINT16_MAX, 6837, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6838, 6838, UINT16_MAX, 6838, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6839, 6839, UINT16_MAX, 6839, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6840, 6840, UINT16_MAX, 6840, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6841, 6841, UINT16_MAX, 6841, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6842, 6842, UINT16_MAX, 6842, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6843, 6843, UINT16_MAX, 6843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6844, 6844, UINT16_MAX, 6844, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6845, 6845, UINT16_MAX, 6845, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6846, 6846, UINT16_MAX, 6846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6847, 6847, UINT16_MAX, 6847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6848, 6848, UINT16_MAX, 6848, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6849, 6849, UINT16_MAX, 6849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6850, 6850, UINT16_MAX, 6850, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6851, 6851, UINT16_MAX, 6851, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6852, 6852, UINT16_MAX, 6852, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6853, 6853, UINT16_MAX, 6853, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6854, 6854, UINT16_MAX, 6854, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6855, 6855, UINT16_MAX, 6855, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6856, 6856, UINT16_MAX, 6856, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6857, 6857, UINT16_MAX, 6857, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6858, 6858, UINT16_MAX, 6858, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6859, 6859, UINT16_MAX, 6859, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6860, 6860, UINT16_MAX, 6860, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6861, 6861, UINT16_MAX, 6861, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6862, 6862, UINT16_MAX, 6862, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6863, 6863, UINT16_MAX, 6863, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6864, 6864, UINT16_MAX, 6864, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6865, 6865, UINT16_MAX, 6865, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6866, 6866, UINT16_MAX, 6866, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6867, 6867, UINT16_MAX, 6867, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6868, 6868, UINT16_MAX, 6868, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6869, 6869, UINT16_MAX, 6869, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6870, 6870, UINT16_MAX, 6870, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6871, 6871, UINT16_MAX, 6871, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6872, 6872, UINT16_MAX, 6872, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6873, 6873, UINT16_MAX, 6873, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6874, 6874, UINT16_MAX, 6874, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6875, 6875, UINT16_MAX, 6875, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6876, 6876, UINT16_MAX, 6876, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6877, 6877, UINT16_MAX, 6877, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6878, 6878, UINT16_MAX, 6878, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6879, 6879, UINT16_MAX, 6879, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6880, 6880, UINT16_MAX, 6880, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6881, 6881, UINT16_MAX, 6881, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6882, 6882, UINT16_MAX, 6882, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6883, 6883, UINT16_MAX, 6883, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6884, 6884, UINT16_MAX, 6884, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6885, 6885, UINT16_MAX, 6885, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6886, 6886, UINT16_MAX, 6886, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6887, 6887, UINT16_MAX, 6887, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6888, 6888, UINT16_MAX, 6888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6889, 6889, UINT16_MAX, 6889, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6890, 6890, UINT16_MAX, 6890, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6891, 6891, UINT16_MAX, 6891, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6892, 6892, UINT16_MAX, 6892, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6893, 6893, UINT16_MAX, 6893, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6894, 6894, UINT16_MAX, 6894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6895, 6895, UINT16_MAX, 6895, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6896, 6896, UINT16_MAX, 6896, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6897, 6897, UINT16_MAX, 6897, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6898, 6898, UINT16_MAX, 6898, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LV, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LVT, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CS, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6973, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6977, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6979, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7019, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7025, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7027, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7031, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7039, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7047, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7059, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7065, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7071, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7077, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7079, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7083, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7085, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7087, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7089, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7091, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7093, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7095, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7097, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7099, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7101, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7103, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7105, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7107, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7115, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7117, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7119, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7121, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7125, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7127, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7129, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7131, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7133, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7135, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7137, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7139, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7141, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7143, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7156, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23696, 23696, 7314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23699, 23699, 7317, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23702, 23702, 7320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 40089, 40089, 7324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 40093, 40093, 7328, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23713, 23715, 7333, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23715, 23715, 7334, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23719, 23719, 7337, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23722, 23722, 7340, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23725, 23725, 7343, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23728, 23728, 7346, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23731, 23731, 7349, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 26, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 4011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 4014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_FONT, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23751, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23757, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23761, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23805, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_COMPAT, 23809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 40520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 40523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 40526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40831, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 4262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 4263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 8176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 3898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 8179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 8204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 8207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 8211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 8212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 8176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 8207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 3898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 8287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 8179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 26, 8288, UINT16_MAX, 8288, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 27, 8289, UINT16_MAX, 8289, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 28, 8290, UINT16_MAX, 8290, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 29, 8291, UINT16_MAX, 8291, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 30, 8292, UINT16_MAX, 8292, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 31, 8293, UINT16_MAX, 8293, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 32, 8294, UINT16_MAX, 8294, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 33, 8295, UINT16_MAX, 8295, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 34, 8296, UINT16_MAX, 8296, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 35, 8297, UINT16_MAX, 8297, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 36, 8298, UINT16_MAX, 8298, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 37, 8299, UINT16_MAX, 8299, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 38, 8300, UINT16_MAX, 8300, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 39, 8301, UINT16_MAX, 8301, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 40, 8302, UINT16_MAX, 8302, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 41, 8303, UINT16_MAX, 8303, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 42, 8304, UINT16_MAX, 8304, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 43, 8305, UINT16_MAX, 8305, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 44, 8306, UINT16_MAX, 8306, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 45, 8307, UINT16_MAX, 8307, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 46, 8308, UINT16_MAX, 8308, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 47, 8309, UINT16_MAX, 8309, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 48, 8310, UINT16_MAX, 8310, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 49, 8311, UINT16_MAX, 8311, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 50, 8312, UINT16_MAX, 8312, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 51, 8313, UINT16_MAX, 8313, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 0, UINT16_MAX, 8315, UINT16_MAX, 8315, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1, UINT16_MAX, 8316, UINT16_MAX, 8316, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2, UINT16_MAX, 8317, UINT16_MAX, 8317, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3, UINT16_MAX, 8318, UINT16_MAX, 8318, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 4, UINT16_MAX, 8319, UINT16_MAX, 8319, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 5, UINT16_MAX, 8320, UINT16_MAX, 8320, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 6, UINT16_MAX, 8321, UINT16_MAX, 8321, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 7, UINT16_MAX, 8322, UINT16_MAX, 8322, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 8, UINT16_MAX, 8323, UINT16_MAX, 8323, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 9, UINT16_MAX, 8324, UINT16_MAX, 8324, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 10, UINT16_MAX, 8325, UINT16_MAX, 8325, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 11, UINT16_MAX, 8326, UINT16_MAX, 8326, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 12, UINT16_MAX, 8327, UINT16_MAX, 8327, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 13, UINT16_MAX, 8328, UINT16_MAX, 8328, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 14, UINT16_MAX, 8329, UINT16_MAX, 8329, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 15, UINT16_MAX, 8330, UINT16_MAX, 8330, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 16, UINT16_MAX, 8331, UINT16_MAX, 8331, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 17, UINT16_MAX, 8332, UINT16_MAX, 8332, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 18, UINT16_MAX, 8333, UINT16_MAX, 8333, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 19, UINT16_MAX, 8334, UINT16_MAX, 8334, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 20, UINT16_MAX, 8335, UINT16_MAX, 8335, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 21, UINT16_MAX, 8336, UINT16_MAX, 8336, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 22, UINT16_MAX, 8337, UINT16_MAX, 8337, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 23, UINT16_MAX, 8338, UINT16_MAX, 8338, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 24, UINT16_MAX, 8339, UINT16_MAX, 8339, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 25, UINT16_MAX, 8340, UINT16_MAX, 8340, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8342, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8344, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8348, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8351, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5727, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8367, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8368, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8370, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8372, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8375, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8382, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8384, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8387, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8388, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8391, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8394, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8397, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8400, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8401, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8403, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8406, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8421, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8424, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8425, UINT16_MAX, 8425, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8427, UINT16_MAX, 8427, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8429, UINT16_MAX, 8429, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8431, UINT16_MAX, 8431, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8433, UINT16_MAX, 8433, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8435, UINT16_MAX, 8435, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8437, UINT16_MAX, 8437, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8439, UINT16_MAX, 8439, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8441, UINT16_MAX, 8441, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8443, UINT16_MAX, 8443, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8445, UINT16_MAX, 8445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8447, UINT16_MAX, 8447, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8449, UINT16_MAX, 8449, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8451, UINT16_MAX, 8451, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8453, UINT16_MAX, 8453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8455, UINT16_MAX, 8455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8457, UINT16_MAX, 8457, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8459, UINT16_MAX, 8459, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8461, UINT16_MAX, 8461, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8463, UINT16_MAX, 8463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8465, UINT16_MAX, 8465, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8467, UINT16_MAX, 8467, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8469, UINT16_MAX, 8469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8471, UINT16_MAX, 8471, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8473, UINT16_MAX, 8473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8475, UINT16_MAX, 8475, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8477, UINT16_MAX, 8477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8479, UINT16_MAX, 8479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8481, UINT16_MAX, 8481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8483, UINT16_MAX, 8483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8485, UINT16_MAX, 8485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8487, UINT16_MAX, 8487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8489, UINT16_MAX, 8489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8491, UINT16_MAX, 8491, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8493, UINT16_MAX, 8493, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8495, UINT16_MAX, 8495, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8497, UINT16_MAX, 8497, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8499, UINT16_MAX, 8499, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8501, UINT16_MAX, 8501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8503, UINT16_MAX, 8503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8505, UINT16_MAX, 8505, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8507, UINT16_MAX, 8507, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8509, UINT16_MAX, 8509, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8511, UINT16_MAX, 8511, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8513, UINT16_MAX, 8513, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8515, UINT16_MAX, 8515, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8517, UINT16_MAX, 8517, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8519, UINT16_MAX, 8519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8521, UINT16_MAX, 8521, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8523, UINT16_MAX, 8523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8525, UINT16_MAX, 8525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8527, UINT16_MAX, 8527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8529, UINT16_MAX, 8529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8531, UINT16_MAX, 8531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8533, UINT16_MAX, 8533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8535, UINT16_MAX, 8535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8537, UINT16_MAX, 8537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8539, UINT16_MAX, 8539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8541, UINT16_MAX, 8541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8543, UINT16_MAX, 8543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8545, UINT16_MAX, 8545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8547, UINT16_MAX, 8547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8549, UINT16_MAX, 8549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8551, UINT16_MAX, 8551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8553, UINT16_MAX, 8553, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8555, UINT16_MAX, 8555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8557, UINT16_MAX, 8557, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8559, UINT16_MAX, 8559, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8561, UINT16_MAX, 8561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8563, UINT16_MAX, 8563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8565, UINT16_MAX, 8565, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8567, UINT16_MAX, 8567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8569, UINT16_MAX, 8569, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8571, UINT16_MAX, 8571, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8573, UINT16_MAX, 8573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8575, UINT16_MAX, 8575, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8577, UINT16_MAX, 8577, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8579, UINT16_MAX, 8579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8581, UINT16_MAX, 8581, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8583, UINT16_MAX, 8583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8585, UINT16_MAX, 8585, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8587, UINT16_MAX, 8587, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8589, UINT16_MAX, 8589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8591, UINT16_MAX, 8591, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8593, UINT16_MAX, 8593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8595, UINT16_MAX, 8595, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8597, UINT16_MAX, 8597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8599, UINT16_MAX, 8599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8601, UINT16_MAX, 8601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8603, UINT16_MAX, 8603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8605, UINT16_MAX, 8605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8607, UINT16_MAX, 8607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8609, UINT16_MAX, 8609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8611, UINT16_MAX, 8611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8613, UINT16_MAX, 8613, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8615, UINT16_MAX, 8615, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8617, UINT16_MAX, 8617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8619, UINT16_MAX, 8619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8621, UINT16_MAX, 8621, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8623, UINT16_MAX, 8623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8625, UINT16_MAX, 8625, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8627, UINT16_MAX, 8627, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8629, UINT16_MAX, 8629, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8631, UINT16_MAX, 8631, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8633, UINT16_MAX, 8633, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8635, UINT16_MAX, 8635, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8637, UINT16_MAX, 8637, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8639, UINT16_MAX, 8639, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8641, UINT16_MAX, 8641, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8643, UINT16_MAX, 8643, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8645, UINT16_MAX, 8645, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8647, UINT16_MAX, 8647, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8649, UINT16_MAX, 8649, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8651, UINT16_MAX, 8651, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8653, UINT16_MAX, 8653, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8655, UINT16_MAX, 8655, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8657, UINT16_MAX, 8657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8659, UINT16_MAX, 8659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8661, UINT16_MAX, 8661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8663, UINT16_MAX, 8663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8665, UINT16_MAX, 8665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8667, UINT16_MAX, 8667, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8669, UINT16_MAX, 8669, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8671, UINT16_MAX, 8671, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8673, UINT16_MAX, 8673, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8675, UINT16_MAX, 8675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8677, UINT16_MAX, 8677, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8679, UINT16_MAX, 8679, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8681, UINT16_MAX, 8681, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8683, UINT16_MAX, 8683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8685, UINT16_MAX, 8685, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8687, UINT16_MAX, 8687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8689, UINT16_MAX, 8689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8691, UINT16_MAX, 8691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8693, UINT16_MAX, 8693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8695, UINT16_MAX, 8695, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8697, UINT16_MAX, 8697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8699, UINT16_MAX, 8699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8701, UINT16_MAX, 8701, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8703, UINT16_MAX, 8703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8705, UINT16_MAX, 8705, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8707, UINT16_MAX, 8707, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8709, UINT16_MAX, 8709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8711, UINT16_MAX, 8711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8713, UINT16_MAX, 8713, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8715, UINT16_MAX, 8715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8717, UINT16_MAX, 8717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8719, UINT16_MAX, 8719, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8721, UINT16_MAX, 8721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8723, UINT16_MAX, 8723, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8725, UINT16_MAX, 8725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8727, UINT16_MAX, 8727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8729, UINT16_MAX, 8729, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8731, UINT16_MAX, 8731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8733, UINT16_MAX, 8733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8735, UINT16_MAX, 8735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8737, UINT16_MAX, 8737, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8739, UINT16_MAX, 8739, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8741, UINT16_MAX, 8741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8743, UINT16_MAX, 8743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8745, UINT16_MAX, 8745, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8747, UINT16_MAX, 8747, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8749, UINT16_MAX, 8749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8751, UINT16_MAX, 8751, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8753, UINT16_MAX, 8753, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8755, UINT16_MAX, 8755, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8757, UINT16_MAX, 8757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8759, UINT16_MAX, 8759, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8761, UINT16_MAX, 8761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8763, UINT16_MAX, 8763, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8765, UINT16_MAX, 8765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8767, UINT16_MAX, 8767, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8769, UINT16_MAX, 8769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8771, UINT16_MAX, 8771, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8773, UINT16_MAX, 8773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8775, UINT16_MAX, 8775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8777, UINT16_MAX, 8777, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8779, UINT16_MAX, 8779, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8781, UINT16_MAX, 8781, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8783, UINT16_MAX, 8783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8785, UINT16_MAX, 8785, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8787, UINT16_MAX, 8787, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8789, UINT16_MAX, 8789, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8791, UINT16_MAX, 8791, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8793, UINT16_MAX, 8793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8795, UINT16_MAX, 8795, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8797, UINT16_MAX, 8797, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8799, UINT16_MAX, 8799, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8801, UINT16_MAX, 8801, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8803, UINT16_MAX, 8803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8805, UINT16_MAX, 8805, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8807, UINT16_MAX, 8807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8809, UINT16_MAX, 8809, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8811, UINT16_MAX, 8811, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8813, UINT16_MAX, 8813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8815, UINT16_MAX, 8815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8817, UINT16_MAX, 8817, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8819, UINT16_MAX, 8819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8821, UINT16_MAX, 8821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8823, UINT16_MAX, 8823, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8825, UINT16_MAX, 8825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8827, UINT16_MAX, 8827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8829, UINT16_MAX, 8829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8831, UINT16_MAX, 8831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8833, UINT16_MAX, 8833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8835, UINT16_MAX, 8835, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8837, UINT16_MAX, 8837, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8839, UINT16_MAX, 8839, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8841, UINT16_MAX, 8841, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8843, UINT16_MAX, 8843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8845, UINT16_MAX, 8845, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8847, UINT16_MAX, 8847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8849, UINT16_MAX, 8849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8851, UINT16_MAX, 8851, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8853, UINT16_MAX, 8853, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8855, UINT16_MAX, 8855, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8857, UINT16_MAX, 8857, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8859, UINT16_MAX, 8859, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8861, UINT16_MAX, 8861, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8863, UINT16_MAX, 8863, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8865, UINT16_MAX, 8865, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8867, UINT16_MAX, 8867, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8869, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 95, UINT16_MAX, 8873, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1081, UINT16_MAX, 8875, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 601, UINT16_MAX, 8877, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1091, UINT16_MAX, 8879, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6815, UINT16_MAX, 8881, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1093, UINT16_MAX, 8883, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1092, UINT16_MAX, 8885, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 609, UINT16_MAX, 8887, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 610, UINT16_MAX, 8889, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2352, UINT16_MAX, 8891, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1017, UINT16_MAX, 8893, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1023, UINT16_MAX, 8895, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1097, UINT16_MAX, 8897, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1029, UINT16_MAX, 8899, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1027, UINT16_MAX, 8901, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 619, UINT16_MAX, 8903, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1083, UINT16_MAX, 8905, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 357, UINT16_MAX, 8907, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1084, UINT16_MAX, 8909, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1032, UINT16_MAX, 8911, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1061, UINT16_MAX, 8913, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1098, UINT16_MAX, 8915, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1099, UINT16_MAX, 8917, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6719, UINT16_MAX, 8919, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8921, UINT16_MAX, 8923, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6692, UINT16_MAX, 8925, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1039, UINT16_MAX, 8927, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8929, UINT16_MAX, 8931, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1071, UINT16_MAX, 8933, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8935, UINT16_MAX, 8937, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 142, UINT16_MAX, 8939, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1047, UINT16_MAX, 8941, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1048, UINT16_MAX, 8943, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 16, UINT16_MAX, 8945, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1051, UINT16_MAX, 8947, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8949, UINT16_MAX, 8951, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4664, UINT16_MAX, 8953, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1055, UINT16_MAX, 8955, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 642, UINT16_MAX, 8957, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1096, UINT16_MAX, 8959, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1094, UINT16_MAX, 8961, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6816, UINT16_MAX, 8963, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1095, UINT16_MAX, 8965, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 650, UINT16_MAX, 8967, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4673, UINT16_MAX, 8969, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1072, UINT16_MAX, 8971, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1089, UINT16_MAX, 8973, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1090, UINT16_MAX, 8975, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1080, UINT16_MAX, 8977, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8979, UINT16_MAX, 8980, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8982, UINT16_MAX, 8983, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8985, UINT16_MAX, 8986, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8988, UINT16_MAX, 8990, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8992, UINT16_MAX, 8994, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 8996, UINT16_MAX, 8996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 8998, UINT16_MAX, 8998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9000, UINT16_MAX, 9000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9002, UINT16_MAX, 9002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9004, UINT16_MAX, 9004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9006, UINT16_MAX, 9006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9008, UINT16_MAX, 9008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9010, UINT16_MAX, 9010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9012, UINT16_MAX, 9012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9014, UINT16_MAX, 9014, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9016, UINT16_MAX, 9016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9018, UINT16_MAX, 9018, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9020, UINT16_MAX, 9020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9022, UINT16_MAX, 9022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9024, UINT16_MAX, 9024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9026, UINT16_MAX, 9026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9028, UINT16_MAX, 9028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9030, UINT16_MAX, 9030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9032, UINT16_MAX, 9032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9034, UINT16_MAX, 9034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9036, UINT16_MAX, 9036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9038, UINT16_MAX, 9038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9040, UINT16_MAX, 9040, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9042, UINT16_MAX, 9042, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9044, UINT16_MAX, 9044, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9046, UINT16_MAX, 9046, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9048, UINT16_MAX, 9048, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9050, UINT16_MAX, 9050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9052, UINT16_MAX, 9052, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9054, UINT16_MAX, 9054, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9056, UINT16_MAX, 9056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9058, UINT16_MAX, 9058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9060, UINT16_MAX, 9060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9062, UINT16_MAX, 9062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9064, UINT16_MAX, 9064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9066, UINT16_MAX, 9066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9068, UINT16_MAX, 9068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9070, UINT16_MAX, 9070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9072, UINT16_MAX, 9072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9074, UINT16_MAX, 9074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9076, UINT16_MAX, 9076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9078, UINT16_MAX, 9078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9080, UINT16_MAX, 9080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9082, UINT16_MAX, 9082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9084, UINT16_MAX, 9084, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9086, UINT16_MAX, 9086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9088, UINT16_MAX, 9088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9090, UINT16_MAX, 9090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9092, UINT16_MAX, 9092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9094, UINT16_MAX, 9094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9096, UINT16_MAX, 9096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9098, UINT16_MAX, 9098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9100, UINT16_MAX, 9100, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9102, UINT16_MAX, 9102, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9104, UINT16_MAX, 9104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9106, UINT16_MAX, 9106, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9108, UINT16_MAX, 9108, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9110, UINT16_MAX, 9110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9112, UINT16_MAX, 9112, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9114, UINT16_MAX, 9114, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9116, UINT16_MAX, 9116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9118, UINT16_MAX, 9118, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9120, UINT16_MAX, 9120, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9122, UINT16_MAX, 9122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9124, UINT16_MAX, 9124, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9126, UINT16_MAX, 9126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9128, UINT16_MAX, 9128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9130, UINT16_MAX, 9130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9132, UINT16_MAX, 9132, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9134, UINT16_MAX, 9134, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9136, UINT16_MAX, 9136, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9138, UINT16_MAX, 9138, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9140, UINT16_MAX, 9140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9142, UINT16_MAX, 9142, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9144, UINT16_MAX, 9144, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9146, UINT16_MAX, 9146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9148, UINT16_MAX, 9148, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9150, UINT16_MAX, 9150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9152, UINT16_MAX, 9152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9154, UINT16_MAX, 9154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9156, UINT16_MAX, 9156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9158, UINT16_MAX, 9158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9160, UINT16_MAX, 9160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9162, UINT16_MAX, 9162, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9164, UINT16_MAX, 9164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9166, UINT16_MAX, 9166, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9168, UINT16_MAX, 9168, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9170, UINT16_MAX, 9170, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9172, UINT16_MAX, 9172, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9174, UINT16_MAX, 9174, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9176, UINT16_MAX, 9176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9178, UINT16_MAX, 9178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9180, UINT16_MAX, 9180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9182, UINT16_MAX, 9182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9184, UINT16_MAX, 9184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9186, UINT16_MAX, 9186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9188, UINT16_MAX, 9188, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9190, UINT16_MAX, 9190, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9192, UINT16_MAX, 9192, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9194, UINT16_MAX, 9194, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9196, UINT16_MAX, 9196, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9198, UINT16_MAX, 9198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5328, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5332, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5336, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49206, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49208, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 25596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 25600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5340, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5344, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49210, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5348, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49212, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49216, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5354, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49214, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49218, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49220, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5362, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5366, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9248, UINT16_MAX, 9248, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9250, UINT16_MAX, 9250, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9252, UINT16_MAX, 9252, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9254, UINT16_MAX, 9254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9256, UINT16_MAX, 9256, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9258, UINT16_MAX, 9258, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9260, UINT16_MAX, 9260, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9262, UINT16_MAX, 9262, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9264, UINT16_MAX, 9264, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9266, UINT16_MAX, 9266, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9268, UINT16_MAX, 9268, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9270, UINT16_MAX, 9270, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9272, UINT16_MAX, 9272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9274, UINT16_MAX, 9274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9276, UINT16_MAX, 9276, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9278, UINT16_MAX, 9278, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9280, UINT16_MAX, 9280, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9282, UINT16_MAX, 9282, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9284, UINT16_MAX, 9284, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9286, UINT16_MAX, 9286, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9288, UINT16_MAX, 9288, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9290, UINT16_MAX, 9290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9292, UINT16_MAX, 9292, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9294, UINT16_MAX, 9294, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9296, UINT16_MAX, 9296, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9298, UINT16_MAX, 9298, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9300, UINT16_MAX, 9300, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9302, UINT16_MAX, 9302, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9304, UINT16_MAX, 9304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9306, UINT16_MAX, 9306, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9308, UINT16_MAX, 9308, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9310, UINT16_MAX, 9310, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9312, UINT16_MAX, 9312, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9314, UINT16_MAX, 9314, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9316, UINT16_MAX, 9316, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9318, UINT16_MAX, 9318, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9320, UINT16_MAX, 9320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9322, UINT16_MAX, 9322, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9324, UINT16_MAX, 9324, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9326, UINT16_MAX, 9326, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9328, UINT16_MAX, 9328, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9330, UINT16_MAX, 9330, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9332, UINT16_MAX, 9332, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9334, UINT16_MAX, 9334, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9336, UINT16_MAX, 9336, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9338, UINT16_MAX, 9338, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9340, UINT16_MAX, 9340, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9342, UINT16_MAX, 9342, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9344, UINT16_MAX, 9344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9346, UINT16_MAX, 9346, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9348, UINT16_MAX, 9348, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9350, UINT16_MAX, 9350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9352, UINT16_MAX, 9352, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9354, UINT16_MAX, 9354, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9356, UINT16_MAX, 9356, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9358, UINT16_MAX, 9358, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9360, UINT16_MAX, 9360, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9362, UINT16_MAX, 9362, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9364, UINT16_MAX, 9364, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9366, UINT16_MAX, 9366, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9368, UINT16_MAX, 9368, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9370, UINT16_MAX, 9370, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9372, UINT16_MAX, 9372, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9374, UINT16_MAX, 9374, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49222, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5370, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9380, UINT16_MAX, 9380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9382, UINT16_MAX, 9382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9384, UINT16_MAX, 9384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9386, UINT16_MAX, 9386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9388, UINT16_MAX, 9388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9390, UINT16_MAX, 9390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9392, UINT16_MAX, 9392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9394, UINT16_MAX, 9394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9396, UINT16_MAX, 9396, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9398, UINT16_MAX, 9398, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9400, UINT16_MAX, 9400, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9402, UINT16_MAX, 9402, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9404, UINT16_MAX, 9404, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9406, UINT16_MAX, 9406, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9408, UINT16_MAX, 9408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9410, UINT16_MAX, 9410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9412, UINT16_MAX, 9412, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9414, UINT16_MAX, 9414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9416, UINT16_MAX, 9416, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9418, UINT16_MAX, 9418, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9420, UINT16_MAX, 9420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9422, UINT16_MAX, 9422, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9424, UINT16_MAX, 9424, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9426, UINT16_MAX, 9426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9428, UINT16_MAX, 9428, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9430, UINT16_MAX, 9430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9432, UINT16_MAX, 9432, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9434, UINT16_MAX, 9434, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9436, UINT16_MAX, 9436, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9438, UINT16_MAX, 9438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9440, UINT16_MAX, 9440, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9442, UINT16_MAX, 9442, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9444, UINT16_MAX, 9444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9446, UINT16_MAX, 9446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9448, UINT16_MAX, 9448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9450, UINT16_MAX, 9450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9452, UINT16_MAX, 9452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9454, UINT16_MAX, 9454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9456, UINT16_MAX, 9456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9458, UINT16_MAX, 9458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9460, UINT16_MAX, 9460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9462, UINT16_MAX, 9462, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9464, UINT16_MAX, 9464, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9466, UINT16_MAX, 9466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9468, UINT16_MAX, 9468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9470, UINT16_MAX, 9470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9472, UINT16_MAX, 9472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9474, UINT16_MAX, 9474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9476, UINT16_MAX, 9476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9478, UINT16_MAX, 9478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9480, UINT16_MAX, 9480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9482, UINT16_MAX, 9482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9484, UINT16_MAX, 9484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9486, UINT16_MAX, 9486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9488, UINT16_MAX, 9488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9490, UINT16_MAX, 9490, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9492, UINT16_MAX, 9492, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9494, UINT16_MAX, 9494, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9496, UINT16_MAX, 9496, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9498, UINT16_MAX, 9498, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9500, UINT16_MAX, 9500, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9502, UINT16_MAX, 9502, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9504, UINT16_MAX, 9504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9506, UINT16_MAX, 9506, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 6, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5374, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5378, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5382, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49224, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 226, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49226, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49228, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49230, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49232, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49234, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5394, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5398, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5402, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5408, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9612, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9614, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9616, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9618, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 9620, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9622, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 9624, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 9626, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9628, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9630, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9632, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9634, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9636, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9638, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 9640, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9642, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9644, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9646, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9648, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9650, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9652, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9654, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9656, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9658, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9660, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9662, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9676, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9702, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9704, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9712, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9716, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9718, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9720, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9722, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 9724, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9726, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 9728, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9730, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9732, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9734, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9736, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9738, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9740, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 9742, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9744, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9746, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9748, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9750, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9752, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9756, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9758, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9760, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9762, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9764, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9766, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9770, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9788, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9790, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9792, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9794, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9796, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9800, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9802, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9804, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9806, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9810, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9812, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9814, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9816, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9818, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9820, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9822, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9824, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 9826, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9828, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 9830, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 9832, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9834, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9836, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9838, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9840, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9842, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9844, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 9846, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9848, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9850, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9852, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9854, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9856, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9858, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9860, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9862, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9864, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9866, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9868, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9870, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9872, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9874, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9876, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9878, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9880, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9882, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9884, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9886, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9888, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9890, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9892, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9894, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9896, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9898, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9900, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9902, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9906, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9908, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9910, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9912, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9914, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 9916, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9918, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9920, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9922, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9924, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9926, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9928, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9930, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9932, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9934, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9936, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9938, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9940, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9942, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9944, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9946, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9948, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9950, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9952, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9954, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9956, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9958, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9960, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9962, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9966, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9968, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9972, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9974, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9976, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9978, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9982, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9984, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9988, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10004, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10006, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10008, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10010, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10012, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10014, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10016, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10018, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10020, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10022, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10024, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10026, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10028, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10030, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10032, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10034, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10036, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10038, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10040, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10042, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10044, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10046, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10048, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10050, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10052, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10054, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10084, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10098, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10100, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10102, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10104, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10106, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10108, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10110, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10112, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10114, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10116, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10118, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10120, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10122, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10124, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10126, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10128, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10130, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10132, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10134, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10136, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10138, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10140, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10142, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10144, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10146, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10148, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10164, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10168, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10170, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10174, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10176, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10178, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10180, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10182, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10184, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10186, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10188, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10190, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10192, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10194, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10196, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10198, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10200, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10202, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10204, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10206, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10208, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10210, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10212, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10214, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10216, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10218, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10220, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10222, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10224, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10226, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10228, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10230, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10232, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10234, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10236, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10238, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10240, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10242, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10244, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10246, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10248, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10250, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10252, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10256, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10258, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10260, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10262, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10264, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10266, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10268, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10270, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10276, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10278, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10280, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10282, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10284, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10286, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10288, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10292, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10294, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10296, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10298, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10300, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10302, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10304, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10306, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10308, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10310, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10312, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10316, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10318, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10322, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10326, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10328, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10330, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10332, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10334, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10336, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10338, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10340, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10342, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10346, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10348, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10352, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10364, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10378, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10396, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10400, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10402, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10404, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10406, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10408, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10410, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10412, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10414, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10416, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10418, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10420, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10422, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10424, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10426, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10428, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10430, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10432, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10434, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10436, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10438, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10440, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10442, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10444, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10446, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10448, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10452, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10454, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10456, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10458, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10460, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10462, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10464, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10466, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10470, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10472, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10474, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10476, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10478, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10482, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10484, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10488, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10490, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10492, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10494, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10496, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10498, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10500, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10502, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10504, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10506, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10508, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10510, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10512, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10514, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10516, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10518, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10520, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10522, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10524, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10526, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10528, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10530, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10532, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10534, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10536, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10538, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10540, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10542, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10544, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10546, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10548, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10550, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10554, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10556, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10604, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10606, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10608, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10610, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10612, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10614, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10616, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10618, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10620, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10622, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10624, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10626, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10628, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10630, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10632, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10634, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10636, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10638, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10640, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10642, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10644, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10646, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10648, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10650, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10652, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10654, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10656, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10676, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10702, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10704, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10708, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10710, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10712, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10714, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10716, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10718, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10720, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10722, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10724, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10726, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10728, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10730, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10732, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10734, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10736, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10738, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10740, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10742, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10744, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10746, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10748, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10750, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10752, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10756, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10758, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10760, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10764, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10766, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10770, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10788, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10790, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10792, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10794, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10796, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10800, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10802, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10804, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10806, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10810, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10812, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10814, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10816, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10818, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10820, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10822, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10824, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10826, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10828, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10830, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10832, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10834, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10836, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10838, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10840, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10842, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10844, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10846, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10848, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10850, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10852, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10854, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10856, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10858, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10860, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10862, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10864, UINT16_MAX, 10865, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 984, UINT16_MAX, 10867, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 10869, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 10871, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 10873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 10875, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 10877, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 10879, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 10881, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 10883, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 10885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 10887, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 10889, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 10891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 10893, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 10895, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 10897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 10899, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 10901, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 10904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 10906, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 10908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 10910, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 10912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 10914, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 10916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 10918, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 10921, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 10923, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 10925, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 10927, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 10929, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 10931, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 10933, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 10935, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 10937, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 10939, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 10941, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 10943, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 10945, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 10947, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 10949, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 10951, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 10953, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 10955, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 10957, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 10959, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 10961, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 10963, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 10965, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 10967, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 10969, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 10971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 10973, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 10976, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 10979, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 10982, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 10985, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 10988, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 10990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 10992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 10994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 10996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 10998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11014, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11018, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11040, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11042, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11044, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11046, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11048, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11050, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11052, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11054, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11056, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11058, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11060, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11062, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11064, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11066, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11068, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11070, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11072, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11074, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11076, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11078, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11080, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11082, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11084, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11086, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11088, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11090, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11092, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11094, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11096, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11098, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11100, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 11102, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 11104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 11106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 11108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 11110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11112, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11136, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11138, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11144, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11146, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11152, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11154, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11156, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11158, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11160, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11162, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11164, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11166, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11168, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11170, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11172, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11174, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11176, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11178, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11180, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11182, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11184, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11186, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11188, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11190, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11192, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11194, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11196, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11198, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11200, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11202, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11204, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11206, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11208, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11210, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11212, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 11214, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 11216, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 11218, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 11220, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 11222, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11224, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11226, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11228, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11230, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11232, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11234, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11236, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11238, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11240, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11242, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11244, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11246, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11248, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11250, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11252, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11256, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11258, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11260, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11262, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11264, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11266, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11268, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11270, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11272, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11274, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11276, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11278, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11280, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11282, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11284, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11286, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11288, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11290, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11292, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11294, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11296, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11298, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11300, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11302, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11304, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11306, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11308, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11310, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11312, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11316, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11318, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11322, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 11326, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 11328, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 11330, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 11332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 11334, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11336, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11338, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11340, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11342, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11346, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11348, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11352, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11364, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11376, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11378, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11380, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11382, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11384, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11386, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11388, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11390, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11392, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11394, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11396, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11400, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11402, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11404, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11406, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11408, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11410, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11412, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11414, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11416, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11418, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11420, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11422, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11424, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11426, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11428, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11430, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11432, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11434, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11436, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1282, UINT16_MAX, UINT16_MAX, 11438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1281, UINT16_MAX, 11440, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11442, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11444, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11446, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11448, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8921, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8929, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8935, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11450, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8949, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11452, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11454, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11456, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11458, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11460, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11462, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11464, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11466, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11468, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11470, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11472, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11474, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11476, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11478, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11480, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11482, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11484, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11486, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11488, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11490, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8992, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11492, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11494, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11496, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11498, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11500, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11502, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1343, UINT16_MAX, 11504, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1344, UINT16_MAX, 11506, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1345, UINT16_MAX, 11508, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1346, UINT16_MAX, 11510, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1347, UINT16_MAX, 11512, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1348, UINT16_MAX, 11514, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1349, UINT16_MAX, 11516, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1350, UINT16_MAX, 11518, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1351, UINT16_MAX, 11520, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1355, UINT16_MAX, 11522, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1356, UINT16_MAX, 11524, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1357, UINT16_MAX, 11526, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1359, UINT16_MAX, 11528, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1360, UINT16_MAX, 11530, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1361, UINT16_MAX, 11532, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1362, UINT16_MAX, 11534, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1363, UINT16_MAX, 11536, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1364, UINT16_MAX, 11538, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1365, UINT16_MAX, 11540, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1366, UINT16_MAX, 11542, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1367, UINT16_MAX, 11544, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1368, UINT16_MAX, 11546, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1369, UINT16_MAX, 11548, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1372, UINT16_MAX, 11550, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1374, UINT16_MAX, 11552, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1375, UINT16_MAX, 11554, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6566, UINT16_MAX, 11556, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1573, UINT16_MAX, 11558, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1325, UINT16_MAX, 11560, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1329, UINT16_MAX, 11562, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1613, UINT16_MAX, 11564, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1515, UINT16_MAX, 11566, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1533, UINT16_MAX, 11568, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1343, UINT16_MAX, 11570, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1344, UINT16_MAX, 11572, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1345, UINT16_MAX, 11574, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1346, UINT16_MAX, 11576, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1347, UINT16_MAX, 11578, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1348, UINT16_MAX, 11580, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1349, UINT16_MAX, 11582, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1350, UINT16_MAX, 11584, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1351, UINT16_MAX, 11586, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1355, UINT16_MAX, 11588, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1356, UINT16_MAX, 11590, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1359, UINT16_MAX, 11592, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1360, UINT16_MAX, 11594, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1362, UINT16_MAX, 11596, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1364, UINT16_MAX, 11598, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1365, UINT16_MAX, 11600, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1366, UINT16_MAX, 11602, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1367, UINT16_MAX, 11604, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1368, UINT16_MAX, 11606, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1369, UINT16_MAX, 11608, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1371, UINT16_MAX, 11610, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1372, UINT16_MAX, 11612, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1485, UINT16_MAX, 11614, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1325, UINT16_MAX, 11616, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1324, UINT16_MAX, 11618, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1342, UINT16_MAX, 11620, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1511, UINT16_MAX, 11622, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6528, UINT16_MAX, 11624, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1517, UINT16_MAX, 11626, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11628, UINT16_MAX, 11628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11630, UINT16_MAX, 11630, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11632, UINT16_MAX, 11632, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11634, UINT16_MAX, 11634, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11636, UINT16_MAX, 11636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11638, UINT16_MAX, 11638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11640, UINT16_MAX, 11640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11642, UINT16_MAX, 11642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11644, UINT16_MAX, 11644, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11646, UINT16_MAX, 11646, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11648, UINT16_MAX, 11648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11650, UINT16_MAX, 11650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11652, UINT16_MAX, 11652, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11654, UINT16_MAX, 11654, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11656, UINT16_MAX, 11656, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11658, UINT16_MAX, 11658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11660, UINT16_MAX, 11660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11662, UINT16_MAX, 11662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11664, UINT16_MAX, 11664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11666, UINT16_MAX, 11666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11668, UINT16_MAX, 11668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11670, UINT16_MAX, 11670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11672, UINT16_MAX, 11672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11674, UINT16_MAX, 11674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11676, UINT16_MAX, 11676, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11678, UINT16_MAX, 11678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11680, UINT16_MAX, 11680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11682, UINT16_MAX, 11682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11684, UINT16_MAX, 11684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11686, UINT16_MAX, 11686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11688, UINT16_MAX, 11688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11690, UINT16_MAX, 11690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11692, UINT16_MAX, 11692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11694, UINT16_MAX, 11694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11696, UINT16_MAX, 11696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11698, UINT16_MAX, 11698, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11700, UINT16_MAX, 11700, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11702, UINT16_MAX, 11702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11704, UINT16_MAX, 11704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11706, UINT16_MAX, 11706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11708, UINT16_MAX, 11708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11710, UINT16_MAX, 11710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11712, UINT16_MAX, 11712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11714, UINT16_MAX, 11714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11716, UINT16_MAX, 11716, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11718, UINT16_MAX, 11718, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11720, UINT16_MAX, 11720, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11722, UINT16_MAX, 11722, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11724, UINT16_MAX, 11724, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11726, UINT16_MAX, 11726, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11728, UINT16_MAX, 11728, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11730, UINT16_MAX, 11730, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11732, UINT16_MAX, 11732, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11734, UINT16_MAX, 11734, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11736, UINT16_MAX, 11736, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11738, UINT16_MAX, 11738, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11740, UINT16_MAX, 11740, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11742, UINT16_MAX, 11742, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11744, UINT16_MAX, 11744, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11746, UINT16_MAX, 11746, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11748, UINT16_MAX, 11748, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11750, UINT16_MAX, 11750, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11752, UINT16_MAX, 11752, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11754, UINT16_MAX, 11754, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11756, UINT16_MAX, 11756, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11758, UINT16_MAX, 11758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11760, UINT16_MAX, 11760, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11762, UINT16_MAX, 11762, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 11764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 11765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 11766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 43, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 26, UINT16_MAX, UINT16_MAX, 11874, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 27, UINT16_MAX, UINT16_MAX, 11876, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28, UINT16_MAX, UINT16_MAX, 11878, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29, UINT16_MAX, UINT16_MAX, 11880, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 30, UINT16_MAX, UINT16_MAX, 11882, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 31, UINT16_MAX, UINT16_MAX, 11884, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 32, UINT16_MAX, UINT16_MAX, 11886, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 33, UINT16_MAX, UINT16_MAX, 11888, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 34, UINT16_MAX, UINT16_MAX, 11890, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 35, UINT16_MAX, UINT16_MAX, 11892, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 36, UINT16_MAX, UINT16_MAX, 11894, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37, UINT16_MAX, UINT16_MAX, 11896, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38, UINT16_MAX, UINT16_MAX, 11898, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39, UINT16_MAX, UINT16_MAX, 11900, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 40, UINT16_MAX, UINT16_MAX, 11902, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 41, UINT16_MAX, UINT16_MAX, 11904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 42, UINT16_MAX, UINT16_MAX, 11906, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 43, UINT16_MAX, UINT16_MAX, 11908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 44, UINT16_MAX, UINT16_MAX, 11910, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 45, UINT16_MAX, UINT16_MAX, 11912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 46, UINT16_MAX, UINT16_MAX, 11914, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 47, UINT16_MAX, UINT16_MAX, 11916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 48, UINT16_MAX, UINT16_MAX, 11918, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 49, UINT16_MAX, UINT16_MAX, 11920, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 50, UINT16_MAX, UINT16_MAX, 11922, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 51, UINT16_MAX, UINT16_MAX, 11924, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 44700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11941, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11943, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11947, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11949, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11951, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11953, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 28373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 28375, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 28377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11995, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11997, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11999, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12001, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12009, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12011, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12013, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12015, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12017, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12019, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12021, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12023, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12025, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12027, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12031, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12033, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12037, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12039, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12043, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12059, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7077, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12065, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12071, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12077, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12079, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12083, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12115, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12119, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12121, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12125, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12127, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12129, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12133, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12137, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12139, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12143, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12330, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12332, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12334, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12336, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12338, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12342, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12344, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12348, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12367, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12368, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12370, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12372, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12382, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12384, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12388, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12391, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12394, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12400, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12406, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12671, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12673, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12676, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12677, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12680, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
-};
-
-static const utf8proc_uint16_t utf8proc_combinations[] = {
-  0, 46, 192, 193, 194, 195, 196, 197, 0, 
-  256, 258, 260, 550, 461, 0, 0, 512, 
-  514, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7680, 7840, 0, 0, 0, 0, 0, 7842, 
-1, 11, 
-  262, 264, 0, 0, 0, 199, 0, 0, 
-  0, 266, 268, 
-0, 46, 200, 201, 202, 7868, 203, 
-  0, 552, 274, 276, 280, 278, 282, 0, 
-  0, 516, 518, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7864, 0, 7704, 7706, 0, 
-  0, 7866, 
-0, 46, 204, 205, 206, 296, 207, 0, 
-  0, 298, 300, 302, 304, 463, 0, 0, 
-  520, 522, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7882, 0, 0, 7724, 0, 0, 
-  7880, 
-0, 42, 504, 323, 0, 209, 0, 0, 325, 
-  0, 0, 0, 7748, 327, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7750, 7752, 7754, 
-0, 46, 210, 211, 212, 213, 
-  214, 0, 0, 332, 334, 490, 558, 465, 
-  336, 416, 524, 526, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7884, 0, 0, 0, 
-  0, 0, 7886, 
-0, 46, 217, 218, 219, 360, 220, 
-  366, 0, 362, 364, 370, 0, 467, 368, 
-  431, 532, 534, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7908, 0, 7798, 7796, 0, 
-  7794, 7910, 
-0, 46, 7922, 221, 374, 7928, 376, 0, 
-  0, 562, 0, 0, 7822, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7924, 0, 0, 0, 0, 0, 
-  7926, 
-0, 46, 224, 225, 226, 227, 228, 229, 0, 
-  257, 259, 261, 551, 462, 0, 0, 513, 
-  515, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7681, 7841, 0, 0, 0, 0, 0, 7843, 
-1, 11, 
-  263, 265, 0, 0, 0, 231, 0, 0, 
-  0, 267, 269, 
-0, 46, 232, 233, 234, 7869, 235, 
-  0, 553, 275, 277, 281, 279, 283, 0, 
-  0, 517, 519, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7865, 0, 7705, 7707, 0, 
-  0, 7867, 
-0, 46, 236, 237, 238, 297, 239, 0, 
-  0, 299, 301, 303, 0, 464, 0, 0, 
-  521, 523, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7883, 0, 0, 7725, 0, 0, 
-  7881, 
-0, 42, 505, 324, 0, 241, 0, 0, 326, 
-  0, 0, 0, 7749, 328, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7751, 7753, 7755, 
-0, 46, 242, 243, 244, 245, 
-  246, 0, 0, 333, 335, 491, 559, 466, 
-  337, 417, 525, 527, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7885, 0, 0, 0, 
-  0, 0, 7887, 
-0, 46, 249, 250, 251, 361, 252, 
-  367, 0, 363, 365, 371, 0, 468, 369, 
-  432, 533, 535, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7909, 0, 7799, 7797, 0, 
-  7795, 7911, 
-0, 46, 7923, 253, 375, 7929, 255, 7833, 
-  0, 563, 0, 0, 7823, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7925, 0, 0, 0, 0, 0, 
-  7927, 
-6, 42, 7696, 0, 0, 0, 7690, 270, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7692, 7694, 7698, 
-6, 42, 7697, 0, 
-  0, 0, 7691, 271, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7693, 7695, 7699, 
-1, 11, 500, 284, 0, 0, 0, 
-  290, 7712, 286, 0, 288, 486, 
-1, 11, 501, 285, 
-  0, 0, 0, 291, 7713, 287, 0, 289, 
-  487, 
-2, 44, 292, 0, 7718, 0, 7720, 0, 0, 
-  0, 7714, 542, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7716, 
-  0, 0, 0, 7722, 
-2, 44, 293, 0, 7719, 0, 
-  7721, 0, 0, 0, 7715, 543, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7717, 7830, 0, 0, 7723, 
-2, 2, 308, 
-2, 11, 
-  309, 0, 0, 0, 0, 0, 0, 0, 
-  0, 496, 
-1, 41, 7728, 0, 0, 0, 0, 310, 
-  0, 0, 0, 0, 488, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7730, 7732, 
-1, 41, 7729, 0, 0, 0, 0, 
-  311, 0, 0, 0, 0, 489, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7731, 7733, 
-1, 42, 313, 0, 0, 0, 
-  0, 315, 0, 0, 0, 0, 317, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7734, 7738, 7740, 
-1, 42, 314, 0, 
-  0, 0, 0, 316, 0, 0, 0, 0, 
-  318, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7735, 7739, 7741, 
-1, 41, 
-  340, 0, 0, 0, 0, 342, 0, 0, 
-  0, 7768, 344, 0, 0, 528, 530, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7770, 
-  7774, 
-1, 41, 341, 0, 0, 0, 0, 343, 0, 
-  0, 0, 7769, 345, 0, 0, 529, 531, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7771, 7775, 
-1, 40, 346, 348, 0, 0, 0, 350, 
-  0, 0, 0, 7776, 352, 0, 0, 0, 
-  0, 536, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7778, 
-1, 40, 347, 349, 0, 0, 0, 351, 
-  0, 0, 0, 7777, 353, 0, 0, 0, 
-  0, 537, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7779, 
-6, 42, 354, 0, 0, 0, 7786, 356, 
-  0, 0, 0, 0, 538, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7788, 7790, 7792, 
-4, 42, 7831, 
-  0, 355, 0, 0, 0, 7787, 357, 0, 
-  0, 0, 0, 539, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7789, 7791, 7793, 
-0, 40, 7808, 7810, 
-  372, 0, 7812, 0, 0, 0, 0, 0, 
-  7814, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7816, 
-0, 40, 7809, 
-  7811, 373, 0, 7813, 7832, 0, 0, 0, 
-  0, 7815, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7817, 
-1, 41, 
-  377, 7824, 0, 0, 0, 0, 0, 0, 
-  0, 379, 381, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7826, 
-  7828, 
-1, 41, 378, 7825, 0, 0, 0, 0, 0, 
-  0, 0, 380, 382, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7827, 7829, 
-0, 11, 475, 471, 0, 0, 0, 0, 
-  0, 469, 0, 0, 0, 473, 
-0, 11, 476, 472, 
-  0, 0, 0, 0, 0, 470, 0, 0, 
-  0, 474, 
-7, 7, 478, 
-7, 7, 479, 
-7, 7, 480, 
-7, 7, 481, 
-1, 7, 508, 0, 
-  0, 0, 0, 0, 482, 
-1, 7, 509, 0, 0, 
-  0, 0, 0, 483, 
-7, 7, 492, 
-7, 7, 493, 
-11, 11, 494, 
-11, 11, 495, 
-1, 1, 
-  506, 
-1, 1, 507, 
-1, 1, 510, 
-1, 1, 511, 
-7, 7, 554, 
-7, 7, 555, 
-1, 7, 7756, 0, 
-  0, 7758, 0, 0, 556, 
-1, 7, 7757, 0, 0, 
-  7759, 0, 0, 557, 
-7, 7, 560, 
-7, 7, 561, 
-0, 49, 8173, 901, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 8129, 
-0, 50, 
-  8122, 902, 0, 0, 0, 0, 0, 8121, 
-  8120, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7944, 
-  7945, 0, 8124, 
-0, 48, 8136, 904, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7960, 7961, 
-0, 50, 8138, 905, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7976, 7977, 0, 8140, 
-0, 48, 8154, 
-  906, 0, 0, 938, 0, 0, 8153, 8152, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7992, 7993, 
-0, 48, 
-  8184, 908, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 8008, 
-  8009, 
-0, 48, 8170, 910, 0, 0, 939, 0, 0, 
-  8169, 8168, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8025, 
-0, 50, 8186, 911, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8040, 8041, 0, 8188, 
-0, 49, 8146, 912, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 8151, 
-0, 50, 8048, 
-  940, 0, 0, 0, 0, 0, 8113, 8112, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7936, 7937, 
-  8118, 8115, 
-0, 48, 8050, 941, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7952, 7953, 
-0, 50, 8052, 942, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7968, 7969, 8134, 8131, 
-0, 49, 8054, 943, 
-  0, 0, 970, 0, 0, 8145, 8144, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7984, 7985, 8150, 
-0, 49, 
-  8162, 944, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8167, 
-0, 49, 8058, 973, 0, 0, 971, 0, 
-  0, 8161, 8160, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8016, 8017, 8166, 
-0, 48, 8056, 972, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 8000, 8001, 
-0, 50, 8060, 974, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 8032, 8033, 8182, 8179, 
-1, 4, 
-  979, 0, 0, 980, 
-0, 8, 1024, 0, 0, 0, 
-  1025, 0, 0, 0, 1238, 
-1, 1, 1027, 
-4, 4, 1031, 
-1, 1, 1036, 
-0, 8, 
-  1037, 0, 0, 0, 1252, 0, 0, 1250, 
-  1049, 
-4, 12, 1264, 0, 0, 1262, 1038, 0, 0, 
-  0, 1266, 
-0, 8, 1117, 0, 0, 0, 1253, 0, 
-  0, 1251, 1081, 
-0, 8, 1104, 0, 0, 0, 1105, 
-  0, 0, 0, 1239, 
-1, 1, 1107, 
-4, 4, 1111, 
-1, 1, 1116, 
-4, 12, 1265, 
-  0, 0, 1263, 1118, 0, 0, 0, 1267, 
-14, 14, 
-  1142, 
-14, 14, 1143, 
-4, 8, 1244, 0, 0, 0, 1217, 
-4, 8, 1245, 
-  0, 0, 0, 1218, 
-4, 8, 1234, 0, 0, 0, 
-  1232, 
-4, 8, 1235, 0, 0, 0, 1233, 
-4, 4, 1242, 
-4, 4, 1243, 
-4, 4, 
-  1246, 
-4, 4, 1247, 
-4, 4, 1254, 
-4, 4, 1255, 
-4, 4, 1258, 
-4, 4, 1259, 
-4, 4, 1260, 
-4, 4, 1261, 
-4, 4, 
-  1268, 
-4, 4, 1269, 
-4, 4, 1272, 
-4, 4, 1273, 
-17, 19, 1570, 1571, 1573, 
-18, 18, 1572, 
-18, 18, 
-  1574, 
-18, 18, 1728, 
-18, 18, 1730, 
-18, 18, 1747, 
-20, 20, 2345, 
-20, 20, 2353, 
-20, 20, 2356, 
-21, 22, 2507, 
-  2508, 
-23, 25, 2888, 2891, 2892, 
-26, 26, 2964, 
-26, 27, 3020, 3018, 
-27, 27, 3019, 
-28, 28, 
-  3144, 
-29, 29, 3264, 
-29, 31, 3271, 3272, 3274, 
-29, 29, 3275, 
-32, 33, 3402, 3404, 
-32, 32, 
-  3403, 
-34, 36, 3546, 3548, 3550, 
-34, 34, 3549, 
-37, 37, 4134, 
-38, 38, 6918, 
-38, 38, 6920, 
-38, 38, 
-  6922, 
-38, 38, 6924, 
-38, 38, 6926, 
-38, 38, 6930, 
-38, 38, 6971, 
-38, 38, 6973, 
-38, 38, 6976, 
-38, 38, 6977, 
-38, 38, 
-  6979, 
-10, 41, 7682, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7684, 
-  7686, 
-10, 41, 7683, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7685, 
-  7687, 
-1, 1, 7688, 
-1, 1, 7689, 
-0, 1, 7700, 7702, 
-0, 1, 7701, 7703, 
-8, 8, 7708, 
-8, 8, 
-  7709, 
-10, 10, 7710, 
-10, 10, 7711, 
-1, 1, 7726, 
-1, 1, 7727, 
-7, 7, 7736, 
-7, 7, 7737, 
-1, 40, 7742, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7744, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7746, 
-1, 40, 7743, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7745, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7747, 
-0, 1, 7760, 
-  7762, 
-0, 1, 7761, 7763, 
-1, 10, 7764, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7766, 
-1, 10, 7765, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7767, 
-7, 7, 7772, 
-7, 7, 
-  7773, 
-10, 10, 7780, 
-10, 10, 7781, 
-10, 10, 7782, 
-10, 10, 7783, 
-10, 10, 7784, 
-10, 10, 7785, 
-1, 1, 7800, 
-1, 1, 
-  7801, 
-4, 4, 7802, 
-4, 4, 7803, 
-3, 40, 7804, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7806, 
-3, 40, 7805, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7807, 
-4, 10, 7820, 
-  0, 0, 0, 0, 0, 7818, 
-4, 10, 7821, 0, 
-  0, 0, 0, 0, 7819, 
-10, 10, 7835, 
-0, 46, 7846, 7844, 
-  0, 7850, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7848, 
-0, 46, 7847, 7845, 0, 
-  7851, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7849, 
-2, 8, 7852, 0, 0, 0, 
-  0, 0, 7862, 
-2, 8, 7853, 0, 0, 0, 0, 
-  0, 7863, 
-0, 46, 7856, 7854, 0, 7860, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7858, 
-0, 46, 7857, 7855, 0, 7861, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7859, 
-0, 46, 
-  7872, 7870, 0, 7876, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7874, 
-0, 46, 7873, 
-  7871, 0, 7877, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7875, 
-2, 2, 7878, 
-2, 2, 7879, 
-0, 46, 
-  7890, 7888, 0, 7894, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7892, 
-0, 46, 7891, 
-  7889, 0, 7895, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7893, 
-2, 2, 7896, 
-2, 2, 7897, 
-0, 46, 
-  7900, 7898, 0, 7904, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7906, 0, 0, 0, 0, 0, 7902, 
-0, 46, 7901, 
-  7899, 0, 7905, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7907, 
-  0, 0, 0, 0, 0, 7903, 
-0, 46, 7914, 7912, 
-  0, 7918, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7920, 0, 
-  0, 0, 0, 0, 7916, 
-0, 46, 7915, 7913, 0, 
-  7919, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7921, 0, 0, 
-  0, 0, 0, 7917, 
-0, 50, 7938, 7940, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7942, 8064, 
-0, 50, 7939, 
-  7941, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7943, 8065, 
-0, 50, 7946, 7948, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7950, 8072, 
-0, 50, 7947, 7949, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7951, 8073, 
-0, 1, 
-  7954, 7956, 
-0, 1, 7955, 7957, 
-0, 1, 7962, 7964, 
-0, 1, 7963, 7965, 
-0, 50, 
-  7970, 7972, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7974, 8080, 
-0, 50, 7971, 7973, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7975, 8081, 
-0, 50, 7978, 7980, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7982, 
-  8088, 
-0, 50, 7979, 7981, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7983, 8089, 
-0, 49, 7986, 7988, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7990, 
-0, 49, 7987, 7989, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7991, 
-0, 49, 
-  7994, 7996, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7998, 
-0, 49, 7995, 7997, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7999, 
-0, 1, 8002, 8004, 
-0, 1, 8003, 8005, 
-0, 1, 
-  8010, 8012, 
-0, 1, 8011, 8013, 
-0, 49, 8018, 8020, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 8022, 
-0, 49, 8019, 8021, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 8023, 
-0, 49, 
-  8027, 8029, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8031, 
-0, 50, 8034, 8036, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 8038, 8096, 
-0, 50, 8035, 8037, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 8039, 8097, 
-0, 50, 
-  8042, 8044, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8046, 8104, 
-0, 50, 8043, 8045, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 8047, 8105, 
-50, 50, 8066, 
-50, 50, 8067, 
-50, 50, 
-  8068, 
-50, 50, 8069, 
-50, 50, 8070, 
-50, 50, 8071, 
-50, 50, 8074, 
-50, 50, 8075, 
-50, 50, 8076, 
-50, 50, 8077, 
-50, 50, 
-  8078, 
-50, 50, 8079, 
-50, 50, 8082, 
-50, 50, 8083, 
-50, 50, 8084, 
-50, 50, 8085, 
-50, 50, 8086, 
-50, 50, 8087, 
-50, 50, 
-  8090, 
-50, 50, 8091, 
-50, 50, 8092, 
-50, 50, 8093, 
-50, 50, 8094, 
-50, 50, 8095, 
-50, 50, 8098, 
-50, 50, 8099, 
-50, 50, 
-  8100, 
-50, 50, 8101, 
-50, 50, 8102, 
-50, 50, 8103, 
-50, 50, 8106, 
-50, 50, 8107, 
-50, 50, 8108, 
-50, 50, 8109, 
-50, 50, 
-  8110, 
-50, 50, 8111, 
-50, 50, 8114, 
-50, 50, 8116, 
-50, 50, 8119, 
-50, 50, 8130, 
-50, 50, 8132, 
-50, 50, 8135, 
-0, 49, 
-  8141, 8142, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8143, 
-0, 49, 8157, 8158, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 8159, 
-47, 48, 8164, 8165, 
-48, 48, 8172, 
-50, 50, 8178, 
-50, 50, 
-  8180, 
-50, 50, 8183, 
-51, 51, 8602, 
-51, 51, 8603, 
-51, 51, 8622, 
-51, 51, 8653, 
-51, 51, 8654, 
-51, 51, 8655, 
-51, 51, 
-  8708, 
-51, 51, 8713, 
-51, 51, 8716, 
-51, 51, 8740, 
-51, 51, 8742, 
-51, 51, 8769, 
-51, 51, 8772, 
-51, 51, 8775, 
-51, 51, 
-  8777, 
-51, 51, 8800, 
-51, 51, 8802, 
-51, 51, 8813, 
-51, 51, 8814, 
-51, 51, 8815, 
-51, 51, 8816, 
-51, 51, 8817, 
-51, 51, 
-  8820, 
-51, 51, 8821, 
-51, 51, 8824, 
-51, 51, 8825, 
-51, 51, 8832, 
-51, 51, 8833, 
-51, 51, 8836, 
-51, 51, 8837, 
-51, 51, 
-  8840, 
-51, 51, 8841, 
-51, 51, 8876, 
-51, 51, 8877, 
-51, 51, 8878, 
-51, 51, 8879, 
-51, 51, 8928, 
-51, 51, 8929, 
-51, 51, 
-  8930, 
-51, 51, 8931, 
-51, 51, 8938, 
-51, 51, 8939, 
-51, 51, 8940, 
-51, 51, 8941, 
-51, 51, 10972, 
-52, 52, 12364, 
-52, 52, 
-  12366, 
-52, 52, 12368, 
-52, 52, 12370, 
-52, 52, 12372, 
-52, 52, 12374, 
-52, 52, 12376, 
-52, 52, 12378, 
-52, 52, 12380, 
-52, 52, 
-  12382, 
-52, 52, 12384, 
-52, 52, 12386, 
-52, 52, 12389, 
-52, 52, 12391, 
-52, 52, 12393, 
-52, 53, 12400, 12401, 
-52, 53, 
-  12403, 12404, 
-52, 53, 12406, 12407, 
-52, 53, 12409, 12410, 
-52, 53, 12412, 12413, 
-52, 52, 
-  12436, 
-52, 52, 12446, 
-52, 52, 12460, 
-52, 52, 12462, 
-52, 52, 12464, 
-52, 52, 12466, 
-52, 52, 12468, 
-52, 52, 12470, 
-52, 52, 
-  12472, 
-52, 52, 12474, 
-52, 52, 12476, 
-52, 52, 12478, 
-52, 52, 12480, 
-52, 52, 12482, 
-52, 52, 12485, 
-52, 52, 12487, 
-52, 52, 
-  12489, 
-52, 53, 12496, 12497, 
-52, 53, 12499, 12500, 
-52, 53, 12502, 12503, 
-52, 53, 12505, 
-  12506, 
-52, 53, 12508, 12509, 
-52, 52, 12532, 
-52, 52, 12535, 
-52, 52, 12536, 
-52, 52, 12537, 
-52, 52, 12538, 
-52, 52, 
-  12542, 
-54, 55, 1, 4250, 
-54, 55, 1, 4252, 
-54, 55, 1, 4267, 
-56, 57, 1, 4398, 
-56, 57, 1, 4399, 
-58, 61, 1, 4939, 1, 4940, 
-62, 67, 
-  1, 5307, 1, 5308, 1, 5310, 
-68, 69, 1, 5562, 
-68, 69, 1, 5563, 
-70, 71, 1, 6456, 
-72, 73, 1, 53598, 
-72, 73, 1, 53599, 
-74, 83, 
-  1, 53600, 1, 53601, 1, 53602, 1, 53603, 1, 53604, 
-72, 73, 1, 53691, 
-72, 73, 1, 53692, 
-74, 77, 1, 53693, 
-  1, 53695, 
-74, 77, 1, 53694, 1, 53696, 
-};
-
diff --git a/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp b/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp
deleted file mode 100644
index 40db1d609..000000000
--- a/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp
+++ /dev/null
@@ -1,356 +0,0 @@
-#include "utf8proc_wrapper.hpp"
-#include "utf8proc.hpp"
-#include "duckdb/common/assert.hpp"
-#include "duckdb/common/exception.hpp"
-
-using namespace std;
-
-namespace duckdb {
-
-// This function efficiently checks if a string is valid UTF8.
-// It was originally written by Sjoerd Mullender.
-
-// Here is the table that makes it work:
-
-// B 		= Number of Bytes in UTF8 encoding
-// C_MIN 	= First Unicode code point
-// C_MAX 	= Last Unicode code point
-// B1 		= First Byte Prefix
-
-// 	B	C_MIN		C_MAX		B1
-//	1	U+000000	U+00007F		0xxxxxxx
-//	2	U+000080	U+0007FF		110xxxxx
-//	3	U+000800	U+00FFFF		1110xxxx
-//	4	U+010000	U+10FFFF		11110xxx
-
-static void AssignInvalidUTF8Reason(UnicodeInvalidReason *invalid_reason, size_t *invalid_pos, size_t pos,
-                                    UnicodeInvalidReason reason) {
-	if (invalid_reason) {
-		*invalid_reason = reason;
-	}
-	if (invalid_pos) {
-		*invalid_pos = pos;
-	}
-}
-
-template <const int nextra_bytes, const int mask>
-static inline UnicodeType UTF8ExtraByteLoop(const int first_pos_seq, int utf8char, size_t &i, const char *s,
-                                            const size_t len, UnicodeInvalidReason *invalid_reason,
-                                            size_t *invalid_pos) {
-	if ((len - i) < (nextra_bytes + 1)) {
-		/* incomplete byte sequence */
-		AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::BYTE_MISMATCH);
-		return UnicodeType::INVALID;
-	}
-	for (size_t j = 0; j < nextra_bytes; j++) {
-		int c = (int)s[++i];
-		/* now validate the extra bytes */
-		if ((c & 0xC0) != 0x80) {
-			/* extra byte is not in the format 10xxxxxx */
-			AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::BYTE_MISMATCH);
-			return UnicodeType::INVALID;
-		}
-		utf8char = (utf8char << 6) | (c & 0x3F);
-	}
-	if ((utf8char & mask) == 0) {
-		/* invalid UTF-8 codepoint, not shortest possible */
-		AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::INVALID_UNICODE);
-		return UnicodeType::INVALID;
-	}
-	if (utf8char > 0x10FFFF) {
-		/* value not representable by Unicode */
-		AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::INVALID_UNICODE);
-		return UnicodeType::INVALID;
-	}
-	if ((utf8char & 0x1FFF800) == 0xD800) {
-		/* Unicode characters from U+D800 to U+DFFF are surrogate characters used by UTF-16 which are invalid in UTF-8
-		 */
-		AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::INVALID_UNICODE);
-		return UnicodeType::INVALID;
-	}
-	return UnicodeType::UNICODE;
-}
-
-UnicodeType Utf8Proc::Analyze(const char *s, size_t len, UnicodeInvalidReason *invalid_reason, size_t *invalid_pos) {
-	UnicodeType type = UnicodeType::ASCII;
-
-	for (size_t i = 0; i < len; i++) {
-		int c = (int)s[i];
-
-		if ((c & 0x80) == 0) {
-			continue;
-		}
-		int first_pos_seq = i;
-
-		if ((c & 0xE0) == 0xC0) {
-			/* 2 byte sequence */
-			int utf8char = c & 0x1F;
-			type = UTF8ExtraByteLoop<1, 0x000780>(first_pos_seq, utf8char, i, s, len, invalid_reason, invalid_pos);
-		} else if ((c & 0xF0) == 0xE0) {
-			/* 3 byte sequence */
-			int utf8char = c & 0x0F;
-			type = UTF8ExtraByteLoop<2, 0x00F800>(first_pos_seq, utf8char, i, s, len, invalid_reason, invalid_pos);
-		} else if ((c & 0xF8) == 0xF0) {
-			/* 4 byte sequence */
-			int utf8char = c & 0x07;
-			type = UTF8ExtraByteLoop<3, 0x1F0000>(first_pos_seq, utf8char, i, s, len, invalid_reason, invalid_pos);
-		} else {
-			/* invalid UTF-8 start byte */
-			AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::BYTE_MISMATCH);
-			return UnicodeType::INVALID;
-		}
-		if (type == UnicodeType::INVALID) {
-			return type;
-		}
-	}
-	return type;
-}
-
-void Utf8Proc::MakeValid(char *s, size_t len, char special_flag) {
-	D_ASSERT(special_flag <= 127);
-	UnicodeType type = UnicodeType::ASCII;
-	for (size_t i = 0; i < len; i++) {
-		int c = (int)s[i];
-		if ((c & 0x80) == 0) {
-			continue;
-		}
-		int first_pos_seq = i;
-		if ((c & 0xE0) == 0xC0) {
-			/* 2 byte sequence */
-			int utf8char = c & 0x1F;
-			type = UTF8ExtraByteLoop<1, 0x000780>(first_pos_seq, utf8char, i, s, len, nullptr, nullptr);
-		} else if ((c & 0xF0) == 0xE0) {
-			/* 3 byte sequence */
-			int utf8char = c & 0x0F;
-			type = UTF8ExtraByteLoop<2, 0x00F800>(first_pos_seq, utf8char, i, s, len, nullptr, nullptr);
-		} else if ((c & 0xF8) == 0xF0) {
-			/* 4 byte sequence */
-			int utf8char = c & 0x07;
-			type = UTF8ExtraByteLoop<3, 0x1F0000>(first_pos_seq, utf8char, i, s, len, nullptr, nullptr);
-		} else {
-			/* invalid UTF-8 start byte */
-			s[i] = special_flag; // Rewrite invalid byte
-		}
-		if (type == UnicodeType::INVALID) {
-			for (size_t j = first_pos_seq; j <= i; j++) {
-				s[j] = special_flag; // Rewrite each byte of the invalid sequence
-			}
-			type = UnicodeType::ASCII;
-		}
-	}
-	D_ASSERT(Utf8Proc::IsValid(s, len));
-}
-
-char *Utf8Proc::Normalize(const char *s, size_t len) {
-	assert(s);
-	assert(Utf8Proc::Analyze(s, len) != UnicodeType::INVALID);
-	return (char *)utf8proc_NFC((const utf8proc_uint8_t *)s, len);
-}
-
-bool Utf8Proc::IsValid(const char *s, size_t len) {
-	return Utf8Proc::Analyze(s, len) != UnicodeType::INVALID;
-}
-
-size_t Utf8Proc::NextGraphemeCluster(const char *s, size_t len, size_t cpos) {
-	int sz;
-	auto prev_codepoint = Utf8Proc::UTF8ToCodepoint(s + cpos, sz);
-	utf8proc_int32_t state = 0;
-	while (true) {
-		cpos += sz;
-		if (cpos >= len) {
-			return cpos;
-		}
-		auto next_codepoint = Utf8Proc::UTF8ToCodepoint(s + cpos, sz);
-		if (utf8proc_grapheme_break_stateful(prev_codepoint, next_codepoint, &state)) {
-			// found a grapheme break here
-			return cpos;
-		}
-		// not a grapheme break, move on to next codepoint
-		prev_codepoint = next_codepoint;
-	}
-}
-
-size_t Utf8Proc::GraphemeCount(const char *input_data, size_t input_size) {
-	size_t num_characters = 0;
-	for (auto cluster : Utf8Proc::GraphemeClusters(input_data, input_size)) {
-		(void)cluster;
-		num_characters++;
-	}
-	return num_characters;
-}
-
-int32_t Utf8Proc::CodepointToUpper(int32_t codepoint) {
-	return utf8proc_toupper(codepoint);
-}
-
-int32_t Utf8Proc::CodepointToLower(int32_t codepoint) {
-	return utf8proc_tolower(codepoint);
-}
-
-GraphemeIterator::GraphemeIterator(const char *s, size_t len) : s(s), len(len) {
-}
-
-GraphemeIterator Utf8Proc::GraphemeClusters(const char *s, size_t len) {
-	return GraphemeIterator(s, len);
-}
-
-GraphemeIterator::GraphemeClusterIterator::GraphemeClusterIterator(const char *s_p, size_t len_p) : s(s_p), len(len_p) {
-	if (s) {
-		cluster.start = 0;
-		cluster.end = 0;
-		Next();
-	} else {
-		SetInvalid();
-	}
-}
-
-void GraphemeIterator::GraphemeClusterIterator::SetInvalid() {
-	s = nullptr;
-	len = 0;
-	cluster.start = 0;
-	cluster.end = 0;
-}
-
-bool GraphemeIterator::GraphemeClusterIterator::IsInvalid() const {
-	return !s;
-}
-
-void GraphemeIterator::GraphemeClusterIterator::Next() {
-	if (IsInvalid()) {
-		throw std::runtime_error("Grapheme cluster out of bounds!");
-	}
-	if (cluster.end >= len) {
-		// out of bounds
-		SetInvalid();
-		return;
-	}
-	size_t next_pos = Utf8Proc::NextGraphemeCluster(s, len, cluster.end);
-	cluster.start = cluster.end;
-	cluster.end = next_pos;
-}
-
-GraphemeIterator::GraphemeClusterIterator &GraphemeIterator::GraphemeClusterIterator::operator++() {
-	Next();
-	return *this;
-}
-bool GraphemeIterator::GraphemeClusterIterator::operator!=(const GraphemeClusterIterator &other) const {
-	return !(len == other.len && s == other.s && cluster.start == other.cluster.start &&
-	         cluster.end == other.cluster.end);
-}
-
-GraphemeCluster GraphemeIterator::GraphemeClusterIterator::operator*() const {
-	if (IsInvalid()) {
-		throw std::runtime_error("Grapheme cluster out of bounds!");
-	}
-	return cluster;
-}
-
-size_t Utf8Proc::PreviousGraphemeCluster(const char *s, size_t len, size_t cpos) {
-	if (!Utf8Proc::IsValid(s, len)) {
-		return cpos - 1;
-	}
-	size_t current_pos = 0;
-	while (true) {
-		size_t new_pos = NextGraphemeCluster(s, len, current_pos);
-		if (new_pos <= current_pos || new_pos >= cpos) {
-			return current_pos;
-		}
-		current_pos = new_pos;
-	}
-}
-
-bool Utf8Proc::CodepointToUtf8(int cp, int &sz, char *c) {
-	if (cp <= 0x7F) {
-		sz = 1;
-		c[0] = cp;
-	} else if (cp <= 0x7FF) {
-		sz = 2;
-		c[0] = (cp >> 6) + 192;
-		c[1] = (cp & 63) + 128;
-	} else if (0xd800 <= cp && cp <= 0xdfff) {
-		sz = -1;
-		// invalid block of utf
-		return false;
-	} else if (cp <= 0xFFFF) {
-		sz = 3;
-		c[0] = (cp >> 12) + 224;
-		c[1] = ((cp >> 6) & 63) + 128;
-		c[2] = (cp & 63) + 128;
-	} else if (cp <= 0x10FFFF) {
-		sz = 4;
-		c[0] = (cp >> 18) + 240;
-		c[1] = ((cp >> 12) & 63) + 128;
-		c[2] = ((cp >> 6) & 63) + 128;
-		c[3] = (cp & 63) + 128;
-	} else {
-		sz = -1;
-		return false;
-	}
-	return true;
-}
-
-int Utf8Proc::CodepointLength(int cp) {
-	if (cp <= 0x7F) {
-		return 1;
-	} else if (cp <= 0x7FF) {
-		return 2;
-	} else if (0xd800 <= cp && cp <= 0xdfff) {
-		return -1;
-	} else if (cp <= 0xFFFF) {
-		return 3;
-	} else if (cp <= 0x10FFFF) {
-		return 4;
-	}
-	return -1;
-}
-
-int32_t Utf8Proc::UTF8ToCodepoint(const char *u_input, int &sz) {
-	// from http://www.zedwood.com/article/cpp-utf8-char-to-codepoint
-	auto u = reinterpret_cast<const unsigned char *>(u_input);
-	unsigned char u0 = u[0];
-	if (u0 <= 127) {
-		sz = 1;
-		return u0;
-	}
-	unsigned char u1 = u[1];
-	if (u0 >= 192 && u0 <= 223) {
-		sz = 2;
-		return (u0 - 192) * 64 + (u1 - 128);
-	}
-	if (u[0] == 0xed && (u[1] & 0xa0) == 0xa0) {
-		return -1; // code points, 0xd800 to 0xdfff
-	}
-	unsigned char u2 = u[2];
-	if (u0 >= 224 && u0 <= 239) {
-		sz = 3;
-		return (u0 - 224) * 4096 + (u1 - 128) * 64 + (u2 - 128);
-	}
-	unsigned char u3 = u[3];
-	if (u0 >= 240 && u0 <= 247) {
-		sz = 4;
-		return (u0 - 240) * 262144 + (u1 - 128) * 4096 + (u2 - 128) * 64 + (u3 - 128);
-	}
-	return -1;
-}
-
-size_t Utf8Proc::RenderWidth(const char *s, size_t len, size_t pos) {
-	int sz;
-	auto codepoint = Utf8Proc::UTF8ToCodepoint(s + pos, sz);
-	auto properties = duckdb::utf8proc_get_property(codepoint);
-	return properties->charwidth;
-}
-
-size_t Utf8Proc::RenderWidth(const std::string &str) {
-	size_t render_width = 0;
-	size_t pos = 0;
-	while (pos < str.size()) {
-		int sz;
-		auto codepoint = Utf8Proc::UTF8ToCodepoint(str.c_str() + pos, sz);
-		auto properties = duckdb::utf8proc_get_property(codepoint);
-		render_width += properties->charwidth;
-		pos += sz;
-	}
-	return render_width;
-}
-
-} // namespace duckdb
diff --git a/src/duckdb/third_party/yyjson/include/yyjson.hpp b/src/duckdb/third_party/yyjson/include/yyjson.hpp
deleted file mode 100644
index 69898d150..000000000
--- a/src/duckdb/third_party/yyjson/include/yyjson.hpp
+++ /dev/null
@@ -1,7930 +0,0 @@
-/*==============================================================================
- Copyright (c) 2020 YaoYuan <ibireme@gmail.com>
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- *============================================================================*/
-
-/** 
- @file yyjson.h
- @date 2019-03-09
- @author YaoYuan
- */
-
-#ifndef DUCKDB_YYJSON_H
-#define DUCKDB_YYJSON_H
-
-
-
-/*==============================================================================
- * Header Files
- *============================================================================*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <limits.h>
-#include <string.h>
-#include <float.h>
-
-#include "duckdb/common/fast_mem.hpp"
-
-namespace duckdb_yyjson {
-
-/*==============================================================================
- * Compile-time Options
- *============================================================================*/
-
-/*
- Define as 1 to disable JSON reader if JSON parsing is not required.
- 
- This will disable these functions at compile-time:
-    - yyjson_read()
-    - yyjson_read_opts()
-    - yyjson_read_file()
-    - yyjson_read_number()
-    - yyjson_mut_read_number()
- 
- This will reduce the binary size by about 60%.
- */
-#ifndef YYJSON_DISABLE_READER
-#endif
-
-/*
- Define as 1 to disable JSON writer if JSON serialization is not required.
- 
- This will disable these functions at compile-time:
-    - yyjson_write()
-    - yyjson_write_file()
-    - yyjson_write_opts()
-    - yyjson_val_write()
-    - yyjson_val_write_file()
-    - yyjson_val_write_opts()
-    - yyjson_mut_write()
-    - yyjson_mut_write_file()
-    - yyjson_mut_write_opts()
-    - yyjson_mut_val_write()
-    - yyjson_mut_val_write_file()
-    - yyjson_mut_val_write_opts()
- 
- This will reduce the binary size by about 30%.
- */
-#ifndef YYJSON_DISABLE_WRITER
-#endif
-
-/*
- Define as 1 to disable JSON Pointer, JSON Patch and JSON Merge Patch supports.
- 
- This will disable these functions at compile-time:
-    - yyjson_ptr_xxx()
-    - yyjson_mut_ptr_xxx()
-    - yyjson_doc_ptr_xxx()
-    - yyjson_mut_doc_ptr_xxx()
-    - yyjson_patch()
-    - yyjson_mut_patch()
-    - yyjson_merge_patch()
-    - yyjson_mut_merge_patch()
- */
-#ifndef YYJSON_DISABLE_UTILS
-#endif
-
-/*
- Define as 1 to disable the fast floating-point number conversion in yyjson,
- and use libc's `strtod/snprintf` instead.
- 
- This will reduce the binary size by about 30%, but significantly slow down the
- floating-point read/write speed.
- */
-#ifndef YYJSON_DISABLE_FAST_FP_CONV
-#endif
-
-/*
- Define as 1 to disable non-standard JSON support at compile-time:
-    - Reading and writing inf/nan literal, such as `NaN`, `-Infinity`.
-    - Single line and multiple line comments.
-    - Single trailing comma at the end of an object or array.
-    - Invalid unicode in string value.
- 
- This will also invalidate these run-time options:
-    - YYJSON_READ_ALLOW_INF_AND_NAN
-    - YYJSON_READ_ALLOW_COMMENTS
-    - YYJSON_READ_ALLOW_TRAILING_COMMAS
-    - YYJSON_READ_ALLOW_INVALID_UNICODE
-    - YYJSON_WRITE_ALLOW_INF_AND_NAN
-    - YYJSON_WRITE_ALLOW_INVALID_UNICODE
- 
- This will reduce the binary size by about 10%, and speed up the reading and
- writing speed by about 2% to 6%.
- */
-#ifndef YYJSON_DISABLE_NON_STANDARD
-#endif
-
-/*
- Define as 1 to disable UTF-8 validation at compile time.
- 
- If all input strings are guaranteed to be valid UTF-8 encoding (for example,
- some language's String object has already validated the encoding), using this
- flag can avoid redundant UTF-8 validation in yyjson.
- 
- This flag can speed up the reading and writing speed of non-ASCII encoded
- strings by about 3% to 7%.
- 
- Note: If this flag is used while passing in illegal UTF-8 strings, the
- following errors may occur:
- - Escaped characters may be ignored when parsing JSON strings.
- - Ending quotes may be ignored when parsing JSON strings, causing the string
-   to be concatenated to the next value.
- - When accessing `yyjson_mut_val` for serialization, the string ending may be
-   accessed out of bounds, causing a segmentation fault.
- */
-#ifndef YYJSON_DISABLE_UTF8_VALIDATION
-#endif
-
-/*
- Define as 1 to indicate that the target architecture does not support unaligned
- memory access. Please refer to the comments in the C file for details.
- */
-#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-#endif
-
-/* Define as 1 to export symbols when building this library as Windows DLL. */
-#ifndef YYJSON_EXPORTS
-#endif
-
-/* Define as 1 to import symbols when using this library as Windows DLL. */
-#ifndef YYJSON_IMPORTS
-#endif
-
-/* Define as 1 to include <stdint.h> for compiler which doesn't support C99. */
-#ifndef YYJSON_HAS_STDINT_H
-#endif
-
-/* Define as 1 to include <stdbool.h> for compiler which doesn't support C99. */
-#ifndef YYJSON_HAS_STDBOOL_H
-#endif
-
-
-
-/*==============================================================================
- * Compiler Macros
- *============================================================================*/
-
-/** compiler version (MSVC) */
-#ifdef _MSC_VER
-#   define YYJSON_MSC_VER _MSC_VER
-#else
-#   define YYJSON_MSC_VER 0
-#endif
-
-/** compiler version (GCC) */
-#ifdef __GNUC__
-#   define YYJSON_GCC_VER __GNUC__
-#   if defined(__GNUC_PATCHLEVEL__)
-#       define yyjson_gcc_available(major, minor, patch) \
-            ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) \
-            >= (major * 10000 + minor * 100 + patch))
-#   else
-#       define yyjson_gcc_available(major, minor, patch) \
-            ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) \
-            >= (major * 10000 + minor * 100 + patch))
-#   endif
-#else
-#   define YYJSON_GCC_VER 0
-#   define yyjson_gcc_available(major, minor, patch) 0
-#endif
-
-/** real gcc check */
-#if !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__ICC) && \
-    defined(__GNUC__)
-#   define YYJSON_IS_REAL_GCC 1
-#else
-#   define YYJSON_IS_REAL_GCC 0
-#endif
-
-/** C version (STDC) */
-#if defined(__STDC__) && (__STDC__ >= 1) && defined(__STDC_VERSION__)
-#   define YYJSON_STDC_VER __STDC_VERSION__
-#else
-#   define YYJSON_STDC_VER 0
-#endif
-
-/** C++ version */
-#if defined(__cplusplus)
-#   define YYJSON_CPP_VER __cplusplus
-#else
-#   define YYJSON_CPP_VER 0
-#endif
-
-/** compiler builtin check (since gcc 10.0, clang 2.6, icc 2021) */
-#ifndef yyjson_has_builtin
-#   ifdef __has_builtin
-#       define yyjson_has_builtin(x) __has_builtin(x)
-#   else
-#       define yyjson_has_builtin(x) 0
-#   endif
-#endif
-
-/** compiler attribute check (since gcc 5.0, clang 2.9, icc 17) */
-#ifndef yyjson_has_attribute
-#   ifdef __has_attribute
-#       define yyjson_has_attribute(x) __has_attribute(x)
-#   else
-#       define yyjson_has_attribute(x) 0
-#   endif
-#endif
-
-/** compiler feature check (since clang 2.6, icc 17) */
-#ifndef yyjson_has_feature
-#   ifdef __has_feature
-#       define yyjson_has_feature(x) __has_feature(x)
-#   else
-#       define yyjson_has_feature(x) 0
-#   endif
-#endif
-
-/** include check (since gcc 5.0, clang 2.7, icc 16, msvc 2017 15.3) */
-#ifndef yyjson_has_include
-#   ifdef __has_include
-#       define yyjson_has_include(x) __has_include(x)
-#   else
-#       define yyjson_has_include(x) 0
-#   endif
-#endif
-
-/** inline for compiler */
-#ifndef yyjson_inline
-#   if YYJSON_MSC_VER >= 1200
-#       define yyjson_inline __forceinline
-#   elif defined(_MSC_VER)
-#       define yyjson_inline __inline
-#   elif yyjson_has_attribute(always_inline) || YYJSON_GCC_VER >= 4
-#       define yyjson_inline __inline__ __attribute__((always_inline))
-#   elif defined(__clang__) || defined(__GNUC__)
-#       define yyjson_inline __inline__
-#   elif defined(__cplusplus) || YYJSON_STDC_VER >= 199901L
-#       define yyjson_inline inline
-#   else
-#       define yyjson_inline
-#   endif
-#endif
-
-/** noinline for compiler */
-#ifndef yyjson_noinline
-#   if YYJSON_MSC_VER >= 1400
-#       define yyjson_noinline __declspec(noinline)
-#   elif yyjson_has_attribute(noinline) || YYJSON_GCC_VER >= 4
-#       define yyjson_noinline __attribute__((noinline))
-#   else
-#       define yyjson_noinline
-#   endif
-#endif
-
-/** align for compiler */
-#ifndef yyjson_align
-#   if YYJSON_MSC_VER >= 1300
-#       define yyjson_align(x) __declspec(align(x))
-#   elif yyjson_has_attribute(aligned) || defined(__GNUC__)
-#       define yyjson_align(x) __attribute__((aligned(x)))
-#   elif YYJSON_CPP_VER >= 201103L
-#       define yyjson_align(x) alignas(x)
-#   else
-#       define yyjson_align(x)
-#   endif
-#endif
-
-/** likely for compiler */
-#ifndef yyjson_likely
-#   if yyjson_has_builtin(__builtin_expect) || \
-    (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
-#       define yyjson_likely(expr) __builtin_expect(!!(expr), 1)
-#   else
-#       define yyjson_likely(expr) (expr)
-#   endif
-#endif
-
-/** unlikely for compiler */
-#ifndef yyjson_unlikely
-#   if yyjson_has_builtin(__builtin_expect) || \
-    (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
-#       define yyjson_unlikely(expr) __builtin_expect(!!(expr), 0)
-#   else
-#       define yyjson_unlikely(expr) (expr)
-#   endif
-#endif
-
-/** compile-time constant check for compiler */
-#ifndef yyjson_constant_p
-#   if yyjson_has_builtin(__builtin_constant_p) || (YYJSON_GCC_VER >= 3)
-#       define YYJSON_HAS_CONSTANT_P 1
-#       define yyjson_constant_p(value) __builtin_constant_p(value)
-#   else
-#       define YYJSON_HAS_CONSTANT_P 0
-#       define yyjson_constant_p(value) 0
-#   endif
-#endif
-
-/** deprecate warning */
-#ifndef yyjson_deprecated
-#   if YYJSON_MSC_VER >= 1400
-#       define yyjson_deprecated(msg) __declspec(deprecated(msg))
-#   elif yyjson_has_feature(attribute_deprecated_with_message) || \
-        (YYJSON_GCC_VER > 4 || (YYJSON_GCC_VER == 4 && __GNUC_MINOR__ >= 5))
-#       define yyjson_deprecated(msg) __attribute__((deprecated(msg)))
-#   elif YYJSON_GCC_VER >= 3
-#       define yyjson_deprecated(msg) __attribute__((deprecated))
-#   else
-#       define yyjson_deprecated(msg)
-#   endif
-#endif
-
-/** function export */
-#ifndef yyjson_api
-#   if defined(_WIN32)
-#       if defined(YYJSON_EXPORTS) && YYJSON_EXPORTS
-#           define yyjson_api __declspec(dllexport)
-#       elif defined(YYJSON_IMPORTS) && YYJSON_IMPORTS
-#           define yyjson_api __declspec(dllimport)
-#       else
-#           define yyjson_api
-#       endif
-#   elif yyjson_has_attribute(visibility) || YYJSON_GCC_VER >= 4
-#       define yyjson_api __attribute__((visibility("default")))
-#   else
-#       define yyjson_api
-#   endif
-#endif
-
-/** inline function export */
-#ifndef yyjson_api_inline
-#   define yyjson_api_inline static yyjson_inline
-#endif
-
-/** stdint (C89 compatible) */
-#if (defined(YYJSON_HAS_STDINT_H) && YYJSON_HAS_STDINT_H) || \
-    YYJSON_MSC_VER >= 1600 || YYJSON_STDC_VER >= 199901L || \
-    defined(_STDINT_H) || defined(_STDINT_H_) || \
-    defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || \
-    yyjson_has_include(<stdint.h>)
-#   include <stdint.h>
-#elif defined(_MSC_VER)
-#   if _MSC_VER < 1300
-        typedef signed char         int8_t;
-        typedef signed short        int16_t;
-        typedef signed int          int32_t;
-        typedef unsigned char       uint8_t;
-        typedef unsigned short      uint16_t;
-        typedef unsigned int        uint32_t;
-        typedef signed __int64      int64_t;
-        typedef unsigned __int64    uint64_t;
-#   else
-        typedef signed __int8       int8_t;
-        typedef signed __int16      int16_t;
-        typedef signed __int32      int32_t;
-        typedef unsigned __int8     uint8_t;
-        typedef unsigned __int16    uint16_t;
-        typedef unsigned __int32    uint32_t;
-        typedef signed __int64      int64_t;
-        typedef unsigned __int64    uint64_t;
-#   endif
-#else
-#   if UCHAR_MAX == 0xFFU
-        typedef signed char     int8_t;
-        typedef unsigned char   uint8_t;
-#   else
-#       error cannot find 8-bit integer type
-#   endif
-#   if USHRT_MAX == 0xFFFFU
-        typedef unsigned short  uint16_t;
-        typedef signed short    int16_t;
-#   elif UINT_MAX == 0xFFFFU
-        typedef unsigned int    uint16_t;
-        typedef signed int      int16_t;
-#   else
-#       error cannot find 16-bit integer type
-#   endif
-#   if UINT_MAX == 0xFFFFFFFFUL
-        typedef unsigned int    uint32_t;
-        typedef signed int      int32_t;
-#   elif ULONG_MAX == 0xFFFFFFFFUL
-        typedef unsigned long   uint32_t;
-        typedef signed long     int32_t;
-#   elif USHRT_MAX == 0xFFFFFFFFUL
-        typedef unsigned short  uint32_t;
-        typedef signed short    int32_t;
-#   else
-#       error cannot find 32-bit integer type
-#   endif
-#   if defined(__INT64_TYPE__) && defined(__UINT64_TYPE__)
-        typedef __INT64_TYPE__  int64_t;
-        typedef __UINT64_TYPE__ uint64_t;
-#   elif defined(__GNUC__) || defined(__clang__)
-#       if !defined(_SYS_TYPES_H) && !defined(__int8_t_defined)
-        __extension__ typedef long long             int64_t;
-#       endif
-        __extension__ typedef unsigned long long    uint64_t;
-#   elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \
-        defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-        typedef long long           int64_t;
-        typedef unsigned long long  uint64_t;
-#   elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \
-        defined(__WATCOM_INT64__) || defined (__alpha) || defined (__DECC)
-        typedef __int64             int64_t;
-        typedef unsigned __int64    uint64_t;
-#   else
-#       error cannot find 64-bit integer type
-#   endif
-#endif
-
-/** stdbool (C89 compatible) */
-#if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) || \
-    (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__)) || \
-    YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L
-#   include <stdbool.h>
-#elif !defined(__bool_true_false_are_defined)
-#   define __bool_true_false_are_defined 1
-#   if defined(__cplusplus)
-#       if defined(__GNUC__) && !defined(__STRICT_ANSI__)
-#           define _Bool bool
-#           if __cplusplus < 201103L
-#               define bool bool
-#               define false false
-#               define true true
-#           endif
-#       endif
-#   else
-#       define bool unsigned char
-#       define true 1
-#       define false 0
-#   endif
-#endif
-
-/** char bit check */
-#if defined(CHAR_BIT)
-#   if CHAR_BIT != 8
-#       error non 8-bit char is not supported
-#   endif
-#endif
-
-/**
- Microsoft Visual C++ 6.0 doesn't support converting number from u64 to f64:
- error C2520: conversion from unsigned __int64 to double not implemented.
- */
-#ifndef YYJSON_U64_TO_F64_NO_IMPL
-#   if (0 < YYJSON_MSC_VER) && (YYJSON_MSC_VER <= 1200)
-#       define YYJSON_U64_TO_F64_NO_IMPL 1
-#   else
-#       define YYJSON_U64_TO_F64_NO_IMPL 0
-#   endif
-#endif
-
-
-
-/*==============================================================================
- * Compile Hint Begin
- *============================================================================*/
-
-/* extern "C" begin */
-#ifdef __cplusplus
-// extern "C" {
-#endif
-
-/* warning suppress begin */
-#if defined(__clang__)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wunused-const-variable"
-#   pragma clang diagnostic ignored "-Wunused-function"
-#   pragma clang diagnostic ignored "-Wunused-parameter"
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic push
-#   endif
-#   pragma GCC diagnostic ignored "-Wunused-const-variable"
-#   pragma GCC diagnostic ignored "-Wunused-function"
-#   pragma GCC diagnostic ignored "-Wunused-parameter"
-#elif defined(_MSC_VER)
-#   pragma warning(push)
-#   pragma warning(disable:4800) /* 'int': forcing value to 'true' or 'false' */
-#endif
-
-
-
-/*==============================================================================
- * Version
- *============================================================================*/
-
-/** The major version of yyjson. */
-#define YYJSON_VERSION_MAJOR  0
-
-/** The minor version of yyjson. */
-#define YYJSON_VERSION_MINOR  9
-
-/** The patch version of yyjson. */
-#define YYJSON_VERSION_PATCH  0
-
-/** The version of yyjson in hex: `(major << 16) | (minor << 8) | (patch)`. */
-#define YYJSON_VERSION_HEX    0x000900
-
-/** The version string of yyjson. */
-#define YYJSON_VERSION_STRING "0.9.0"
-
-/** The version of yyjson in hex, same as `YYJSON_VERSION_HEX`. */
-yyjson_api uint32_t yyjson_version(void);
-
-
-
-/*==============================================================================
- * JSON Types
- *============================================================================*/
-
-/** Type of a JSON value (3 bit). */
-typedef uint8_t yyjson_type;
-/** No type, invalid. */
-#define YYJSON_TYPE_NONE        ((uint8_t)0)        /* _____000 */
-/** Raw string type, no subtype. */
-#define YYJSON_TYPE_RAW         ((uint8_t)1)        /* _____001 */
-/** Null type: `null` literal, no subtype. */
-#define YYJSON_TYPE_NULL        ((uint8_t)2)        /* _____010 */
-/** Boolean type, subtype: TRUE, FALSE. */
-#define YYJSON_TYPE_BOOL        ((uint8_t)3)        /* _____011 */
-/** Number type, subtype: UINT, SINT, REAL. */
-#define YYJSON_TYPE_NUM         ((uint8_t)4)        /* _____100 */
-/** String type, subtype: NONE, NOESC. */
-#define YYJSON_TYPE_STR         ((uint8_t)5)        /* _____101 */
-/** Array type, no subtype. */
-#define YYJSON_TYPE_ARR         ((uint8_t)6)        /* _____110 */
-/** Object type, no subtype. */
-#define YYJSON_TYPE_OBJ         ((uint8_t)7)        /* _____111 */
-
-/** Subtype of a JSON value (2 bit). */
-typedef uint8_t yyjson_subtype;
-/** No subtype. */
-#define YYJSON_SUBTYPE_NONE     ((uint8_t)(0 << 3)) /* ___00___ */
-/** False subtype: `false` literal. */
-#define YYJSON_SUBTYPE_FALSE    ((uint8_t)(0 << 3)) /* ___00___ */
-/** True subtype: `true` literal. */
-#define YYJSON_SUBTYPE_TRUE     ((uint8_t)(1 << 3)) /* ___01___ */
-/** Unsigned integer subtype: `uint64_t`. */
-#define YYJSON_SUBTYPE_UINT     ((uint8_t)(0 << 3)) /* ___00___ */
-/** Signed integer subtype: `int64_t`. */
-#define YYJSON_SUBTYPE_SINT     ((uint8_t)(1 << 3)) /* ___01___ */
-/** Real number subtype: `double`. */
-#define YYJSON_SUBTYPE_REAL     ((uint8_t)(2 << 3)) /* ___10___ */
-/** String that do not need to be escaped for writing (internal use). */
-#define YYJSON_SUBTYPE_NOESC    ((uint8_t)(1 << 3)) /* ___01___ */
-
-/** The mask used to extract the type of a JSON value. */
-#define YYJSON_TYPE_MASK        ((uint8_t)0x07)     /* _____111 */
-/** The number of bits used by the type. */
-#define YYJSON_TYPE_BIT         ((uint8_t)3)
-/** The mask used to extract the subtype of a JSON value. */
-#define YYJSON_SUBTYPE_MASK     ((uint8_t)0x18)     /* ___11___ */
-/** The number of bits used by the subtype. */
-#define YYJSON_SUBTYPE_BIT      ((uint8_t)2)
-/** The mask used to extract the reserved bits of a JSON value. */
-#define YYJSON_RESERVED_MASK    ((uint8_t)0xE0)     /* 111_____ */
-/** The number of reserved bits. */
-#define YYJSON_RESERVED_BIT     ((uint8_t)3)
-/** The mask used to extract the tag of a JSON value. */
-#define YYJSON_TAG_MASK         ((uint8_t)0xFF)     /* 11111111 */
-/** The number of bits used by the tag. */
-#define YYJSON_TAG_BIT          ((uint8_t)8)
-
-/** Padding size for JSON reader. */
-#define YYJSON_PADDING_SIZE     4
-
-
-
-/*==============================================================================
- * Allocator
- *============================================================================*/
-
-/**
- A memory allocator.
- 
- Typically you don't need to use it, unless you want to customize your own
- memory allocator.
- */
-typedef struct yyjson_alc {
-    /** Same as libc's malloc(size), should not be NULL. */
-    void *(*malloc)(void *ctx, size_t size);
-    /** Same as libc's realloc(ptr, size), should not be NULL. */
-    void *(*realloc)(void *ctx, void *ptr, size_t old_size, size_t size);
-    /** Same as libc's free(ptr), should not be NULL. */
-    void (*free)(void *ctx, void *ptr);
-    /** A context for malloc/realloc/free, can be NULL. */
-    void *ctx;
-} yyjson_alc;
-
-/**
- A pool allocator uses fixed length pre-allocated memory.
- 
- This allocator may be used to avoid malloc/realloc calls. The pre-allocated 
- memory should be held by the caller. The maximum amount of memory required to
- read a JSON can be calculated using the `yyjson_read_max_memory_usage()`
- function, but the amount of memory required to write a JSON cannot be directly 
- calculated.
- 
- This is not a general-purpose allocator. It is designed to handle a single JSON
- data at a time. If it is used for overly complex memory tasks, such as parsing
- multiple JSON documents using the same allocator but releasing only a few of
- them, it may cause memory fragmentation, resulting in performance degradation
- and memory waste.
- 
- @param alc The allocator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
-    If `buf` or `size` is invalid, this will be set to an empty allocator.
- @param buf The buffer memory for this allocator.
-    If this parameter is NULL, the function will fail and return false.
- @param size The size of `buf`, in bytes.
-    If this parameter is less than 8 words (32/64 bytes on 32/64-bit OS), the
-    function will fail and return false.
- @return true if the `alc` has been successfully initialized.
- 
- @par Example
- @code
-    // parse JSON with stack memory
-    char buf[1024];
-    yyjson_alc alc;
-    yyjson_alc_pool_init(&alc, buf, 1024);
-    
-    const char *json = "{\"name\":\"Helvetica\",\"size\":16}"
-    yyjson_doc *doc = yyjson_read_opts(json, strlen(json), 0, &alc, NULL);
-    // the memory of `doc` is on the stack
- @endcode
- 
- @warning This Allocator is not thread-safe.
- */
-yyjson_api bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, size_t size);
-
-/**
- A dynamic allocator.
- 
- This allocator has a similar usage to the pool allocator above. However, when
- there is not enough memory, this allocator will dynamically request more memory
- using libc's `malloc` function, and frees it all at once when it is destroyed.
- 
- @return A new dynamic allocator, or NULL if memory allocation failed.
- @note The returned value should be freed with `yyjson_alc_dyn_free()`.
- 
- @warning This Allocator is not thread-safe.
- */
-yyjson_api yyjson_alc *yyjson_alc_dyn_new(void);
-
-/**
- Free a dynamic allocator which is created by `yyjson_alc_dyn_new()`.
- @param alc The dynamic allocator to be destroyed.
- */
-yyjson_api void yyjson_alc_dyn_free(yyjson_alc *alc);
-
-
-
-/*==============================================================================
- * JSON Structure
- *============================================================================*/
-
-/**
- An immutable document for reading JSON.
- This document holds memory for all its JSON values and strings. When it is no
- longer used, the user should call `yyjson_doc_free()` to free its memory.
- */
-typedef struct yyjson_doc yyjson_doc;
-
-/**
- An immutable value for reading JSON.
- A JSON Value has the same lifetime as its document. The memory is held by its
- document and and cannot be freed alone.
- */
-typedef struct yyjson_val yyjson_val;
-
-/**
- A mutable document for building JSON.
- This document holds memory for all its JSON values and strings. When it is no
- longer used, the user should call `yyjson_mut_doc_free()` to free its memory.
- */
-typedef struct yyjson_mut_doc yyjson_mut_doc;
-
-/**
- A mutable value for building JSON.
- A JSON Value has the same lifetime as its document. The memory is held by its
- document and and cannot be freed alone.
- */
-typedef struct yyjson_mut_val yyjson_mut_val;
-
-
-
-/*==============================================================================
- * JSON Reader API
- *============================================================================*/
-
-/** Run-time options for JSON reader. */
-typedef uint32_t yyjson_read_flag;
-
-/** Default option (RFC 8259 compliant):
-    - Read positive integer as uint64_t.
-    - Read negative integer as int64_t.
-    - Read floating-point number as double with round-to-nearest mode.
-    - Read integer which cannot fit in uint64_t or int64_t as double.
-    - Report error if double number is infinity.
-    - Report error if string contains invalid UTF-8 character or BOM.
-    - Report error on trailing commas, comments, inf and nan literals. */
-static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0;
-
-/** Read the input data in-situ.
-    This option allows the reader to modify and use input data to store string
-    values, which can increase reading speed slightly.
-    The caller should hold the input data before free the document.
-    The input data must be padded by at least `YYJSON_PADDING_SIZE` bytes.
-    For example: `[1,2]` should be `[1,2]\0\0\0\0`, input length should be 5. */
-static const yyjson_read_flag YYJSON_READ_INSITU                = 1 << 0;
-
-/** Stop when done instead of issuing an error if there's additional content
-    after a JSON document. This option may be used to parse small pieces of JSON
-    in larger data, such as `NDJSON`. */
-static const yyjson_read_flag YYJSON_READ_STOP_WHEN_DONE        = 1 << 1;
-
-/** Allow single trailing comma at the end of an object or array,
-    such as `[1,2,3,]`, `{"a":1,"b":2,}` (non-standard). */
-static const yyjson_read_flag YYJSON_READ_ALLOW_TRAILING_COMMAS = 1 << 2;
-
-/** Allow C-style single line and multiple line comments (non-standard). */
-static const yyjson_read_flag YYJSON_READ_ALLOW_COMMENTS        = 1 << 3;
-
-/** Allow inf/nan number and literal, case-insensitive,
-    such as 1e999, NaN, inf, -Infinity (non-standard). */
-static const yyjson_read_flag YYJSON_READ_ALLOW_INF_AND_NAN     = 1 << 4;
-
-/** Read all numbers as raw strings (value with `YYJSON_TYPE_RAW` type),
-    inf/nan literal is also read as raw with `ALLOW_INF_AND_NAN` flag. */
-static const yyjson_read_flag YYJSON_READ_NUMBER_AS_RAW         = 1 << 5;
-
-/** Allow reading invalid unicode when parsing string values (non-standard).
-    Invalid characters will be allowed to appear in the string values, but
-    invalid escape sequences will still be reported as errors.
-    This flag does not affect the performance of correctly encoded strings.
-    
-    @warning Strings in JSON values may contain incorrect encoding when this
-    option is used, you need to handle these strings carefully to avoid security
-    risks. */
-static const yyjson_read_flag YYJSON_READ_ALLOW_INVALID_UNICODE = 1 << 6;
-
-/** Read big numbers as raw strings. These big numbers include integers that
-    cannot be represented by `int64_t` and `uint64_t`, and floating-point
-    numbers that cannot be represented by finite `double`.
-    The flag will be overridden by `YYJSON_READ_NUMBER_AS_RAW` flag. */
-static const yyjson_read_flag YYJSON_READ_BIGNUM_AS_RAW         = 1 << 7;
-
-
-
-/** Result code for JSON reader. */
-typedef uint32_t yyjson_read_code;
-
-/** Success, no error. */
-static const yyjson_read_code YYJSON_READ_SUCCESS                       = 0;
-
-/** Invalid parameter, such as NULL input string or 0 input length. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_PARAMETER       = 1;
-
-/** Memory allocation failure occurs. */
-static const yyjson_read_code YYJSON_READ_ERROR_MEMORY_ALLOCATION       = 2;
-
-/** Input JSON string is empty. */
-static const yyjson_read_code YYJSON_READ_ERROR_EMPTY_CONTENT           = 3;
-
-/** Unexpected content after document, such as `[123]abc`. */
-static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CONTENT      = 4;
-
-/** Unexpected ending, such as `[123`. */
-static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_END          = 5;
-
-/** Unexpected character inside the document, such as `[abc]`. */
-static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CHARACTER    = 6;
-
-/** Invalid JSON structure, such as `[1,]`. */
-static const yyjson_read_code YYJSON_READ_ERROR_JSON_STRUCTURE          = 7;
-
-/** Invalid comment, such as unclosed multi-line comment. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_COMMENT         = 8;
-
-/** Invalid number, such as `123.e12`, `000`. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_NUMBER          = 9;
-
-/** Invalid string, such as invalid escaped character inside a string. */
-static const yyjson_read_code YYJSON_READ_ERROR_INVALID_STRING          = 10;
-
-/** Invalid JSON literal, such as `truu`. */
-static const yyjson_read_code YYJSON_READ_ERROR_LITERAL                 = 11;
-
-/** Failed to open a file. */
-static const yyjson_read_code YYJSON_READ_ERROR_FILE_OPEN               = 12;
-
-/** Failed to read a file. */
-static const yyjson_read_code YYJSON_READ_ERROR_FILE_READ               = 13;
-
-/** Error information for JSON reader. */
-typedef struct yyjson_read_err {
-    /** Error code, see `yyjson_read_code` for all possible values. */
-    yyjson_read_code code;
-    /** Error message, constant, no need to free (NULL if success). */
-    const char *msg;
-    /** Error byte position for input data (0 if success). */
-    size_t pos;
-} yyjson_read_err;
-
-
-
-/**
- Read JSON with options.
- 
- This function is thread-safe when:
- 1. The `dat` is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param dat The JSON data (UTF-8 without BOM), null-terminator is not required.
-    If this parameter is NULL, the function will fail and return NULL.
-    The `dat` will not be modified without the flag `YYJSON_READ_INSITU`, so you
-    can pass a `const char *` string and case it to `char *` if you don't use
-    the `YYJSON_READ_INSITU` flag.
- @param len The length of JSON data in bytes.
-    If this parameter is 0, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON reader.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
- */
-yyjson_api yyjson_doc *yyjson_read_opts(char *dat,
-                                        size_t len,
-                                        yyjson_read_flag flg,
-                                        const yyjson_alc *alc,
-                                        yyjson_read_err *err);
-
-/**
- Read a JSON file.
- 
- This function is thread-safe when:
- 1. The file is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON reader.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to read.
- */
-yyjson_api yyjson_doc *yyjson_read_file(const char *path,
-                                        yyjson_read_flag flg,
-                                        const yyjson_alc *alc,
-                                        yyjson_read_err *err);
-
-/**
- Read JSON from a file pointer.
- 
- @param fp The file pointer.
-    The data will be read from the current position of the FILE to the end.
-    If this fp is NULL or invalid, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON reader.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to read.
- */
-yyjson_api yyjson_doc *yyjson_read_fp(FILE *fp,
-                                      yyjson_read_flag flg,
-                                      const yyjson_alc *alc,
-                                      yyjson_read_err *err);
-
-/**
- Read a JSON string.
- 
- This function is thread-safe.
- 
- @param dat The JSON data (UTF-8 without BOM), null-terminator is not required.
-    If this parameter is NULL, the function will fail and return NULL.
- @param len The length of JSON data in bytes.
-    If this parameter is 0, the function will fail and return NULL.
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @return A new JSON document, or NULL if an error occurs.
-    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
- */
-yyjson_api_inline yyjson_doc *yyjson_read(const char *dat,
-                                          size_t len,
-                                          yyjson_read_flag flg) {
-    flg &= ~YYJSON_READ_INSITU; /* const string cannot be modified */
-    return yyjson_read_opts((char *)(void *)(size_t)(const void *)dat,
-                            len, flg, NULL, NULL);
-}
-
-/**
- Returns the size of maximum memory usage to read a JSON data.
- 
- You may use this value to avoid malloc() or calloc() call inside the reader
- to get better performance, or read multiple JSON with one piece of memory.
- 
- @param len The length of JSON data in bytes.
- @param flg The JSON read options.
- @return The maximum memory size to read this JSON, or 0 if overflow.
- 
- @par Example
- @code
-    // read multiple JSON with same pre-allocated memory
-    
-    char *dat1, *dat2, *dat3; // JSON data
-    size_t len1, len2, len3; // JSON length
-    size_t max_len = MAX(len1, MAX(len2, len3));
-    yyjson_doc *doc;
-    
-    // use one allocator for multiple JSON
-    size_t size = yyjson_read_max_memory_usage(max_len, 0);
-    void *buf = malloc(size);
-    yyjson_alc alc;
-    yyjson_alc_pool_init(&alc, buf, size);
-    
-    // no more alloc() or realloc() call during reading
-    doc = yyjson_read_opts(dat1, len1, 0, &alc, NULL);
-    yyjson_doc_free(doc);
-    doc = yyjson_read_opts(dat2, len2, 0, &alc, NULL);
-    yyjson_doc_free(doc);
-    doc = yyjson_read_opts(dat3, len3, 0, &alc, NULL);
-    yyjson_doc_free(doc);
-    
-    free(buf);
- @endcode
- @see yyjson_alc_pool_init()
- */
-yyjson_api_inline size_t yyjson_read_max_memory_usage(size_t len,
-                                                      yyjson_read_flag flg) {
-    /*
-     1. The max value count is (json_size / 2 + 1),
-        for example: "[1,2,3,4]" size is 9, value count is 5.
-     2. Some broken JSON may cost more memory during reading, but fail at end,
-        for example: "[[[[[[[[".
-     3. yyjson use 16 bytes per value, see struct yyjson_val.
-     4. yyjson use dynamic memory with a growth factor of 1.5.
-     
-     The max memory size is (json_size / 2 * 16 * 1.5 + padding).
-     */
-    size_t mul = (size_t)12 + !(flg & YYJSON_READ_INSITU);
-    size_t pad = 256;
-    size_t max = (size_t)(~(size_t)0);
-    if (flg & YYJSON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len;
-    if (len >= (max - pad - mul) / mul) return 0;
-    return len * mul + pad;
-}
-
-/**
- Read a JSON number.
-
- This function is thread-safe when data is not modified by other threads.
-
- @param dat The JSON data (UTF-8 without BOM), null-terminator is required.
-    If this parameter is NULL, the function will fail and return NULL.
- @param val The output value where result is stored.
-    If this parameter is NULL, the function will fail and return NULL.
-    The value will hold either UINT or SINT or REAL number;
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
-    Supports `YYJSON_READ_NUMBER_AS_RAW` and `YYJSON_READ_ALLOW_INF_AND_NAN`.
- @param alc The memory allocator used for long number.
-    It is only used when the built-in floating point reader is disabled.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return If successful, a pointer to the character after the last character
-    used in the conversion, NULL if an error occurs.
- */
-yyjson_api const char *yyjson_read_number(const char *dat,
-                                          yyjson_val *val,
-                                          yyjson_read_flag flg,
-                                          const yyjson_alc *alc,
-                                          yyjson_read_err *err);
-
-/**
- Read a JSON number.
-
- This function is thread-safe when data is not modified by other threads.
-
- @param dat The JSON data (UTF-8 without BOM), null-terminator is required.
-    If this parameter is NULL, the function will fail and return NULL.
- @param val The output value where result is stored.
-    If this parameter is NULL, the function will fail and return NULL.
-    The value will hold either UINT or SINT or REAL number;
- @param flg The JSON read options.
-    Multiple options can be combined with `|` operator. 0 means no options.
-    Supports `YYJSON_READ_NUMBER_AS_RAW` and `YYJSON_READ_ALLOW_INF_AND_NAN`.
- @param alc The memory allocator used for long number.
-    It is only used when the built-in floating point reader is disabled.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return If successful, a pointer to the character after the last character
-    used in the conversion, NULL if an error occurs.
- */
-yyjson_api_inline const char *yyjson_mut_read_number(const char *dat,
-                                                     yyjson_mut_val *val,
-                                                     yyjson_read_flag flg,
-                                                     const yyjson_alc *alc,
-                                                     yyjson_read_err *err) {
-    return yyjson_read_number(dat, (yyjson_val *)val, flg, alc, err);
-}
-
-
-/*==============================================================================
- * JSON Writer API
- *============================================================================*/
-
-/** Run-time options for JSON writer. */
-typedef uint32_t yyjson_write_flag;
-
-/** Default option:
-    - Write JSON minify.
-    - Report error on inf or nan number.
-    - Report error on invalid UTF-8 string.
-    - Do not escape unicode or slash. */
-static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0;
-
-/** Write JSON pretty with 4 space indent. */
-static const yyjson_write_flag YYJSON_WRITE_PRETTY                  = 1 << 0;
-
-/** Escape unicode as `uXXXX`, make the output ASCII only. */
-static const yyjson_write_flag YYJSON_WRITE_ESCAPE_UNICODE          = 1 << 1;
-
-/** Escape '/' as '\/'. */
-static const yyjson_write_flag YYJSON_WRITE_ESCAPE_SLASHES          = 1 << 2;
-
-/** Write inf and nan number as 'Infinity' and 'NaN' literal (non-standard). */
-static const yyjson_write_flag YYJSON_WRITE_ALLOW_INF_AND_NAN       = 1 << 3;
-
-/** Write inf and nan number as null literal.
-    This flag will override `YYJSON_WRITE_ALLOW_INF_AND_NAN` flag. */
-static const yyjson_write_flag YYJSON_WRITE_INF_AND_NAN_AS_NULL     = 1 << 4;
-
-/** Allow invalid unicode when encoding string values (non-standard).
-    Invalid characters in string value will be copied byte by byte.
-    If `YYJSON_WRITE_ESCAPE_UNICODE` flag is also set, invalid character will be
-    escaped as `U+FFFD` (replacement character).
-    This flag does not affect the performance of correctly encoded strings. */
-static const yyjson_write_flag YYJSON_WRITE_ALLOW_INVALID_UNICODE   = 1 << 5;
-
-/** Write JSON pretty with 2 space indent.
-    This flag will override `YYJSON_WRITE_PRETTY` flag. */
-static const yyjson_write_flag YYJSON_WRITE_PRETTY_TWO_SPACES       = 1 << 6;
-
-/** Adds a newline character `\n` at the end of the JSON.
-    This can be helpful for text editors or NDJSON. */
-static const yyjson_write_flag YYJSON_WRITE_NEWLINE_AT_END          = 1 << 7;
-
-
-
-/** Result code for JSON writer */
-typedef uint32_t yyjson_write_code;
-
-/** Success, no error. */
-static const yyjson_write_code YYJSON_WRITE_SUCCESS                     = 0;
-
-/** Invalid parameter, such as NULL document. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_PARAMETER     = 1;
-
-/** Memory allocation failure occurs. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_MEMORY_ALLOCATION     = 2;
-
-/** Invalid value type in JSON document. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_VALUE_TYPE    = 3;
-
-/** NaN or Infinity number occurs. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_NAN_OR_INF            = 4;
-
-/** Failed to open a file. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_OPEN             = 5;
-
-/** Failed to write a file. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_WRITE            = 6;
-
-/** Invalid unicode in string. */
-static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_STRING        = 7;
-
-/** Error information for JSON writer. */
-typedef struct yyjson_write_err {
-    /** Error code, see `yyjson_write_code` for all possible values. */
-    yyjson_write_code code;
-    /** Error message, constant, no need to free (NULL if success). */
-    const char *msg;
-} yyjson_write_err;
-
-
-
-/*==============================================================================
- * JSON Document Writer API
- *============================================================================*/
-
-/**
- Write a document to JSON string with options.
- 
- This function is thread-safe when:
- The `alc` is thread-safe or NULL.
- 
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_write_opts(const yyjson_doc *doc,
-                                   yyjson_write_flag flg,
-                                   const yyjson_alc *alc,
-                                   size_t *len,
-                                   yyjson_write_err *err);
-
-/**
- Write a document to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `alc` is thread-safe or NULL.
-
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_write_file(const char *path,
-                                  const yyjson_doc *doc,
-                                  yyjson_write_flag flg,
-                                  const yyjson_alc *alc,
-                                  yyjson_write_err *err);
-
-/**
- Write a document to file pointer with options.
- 
- @param fp The file pointer.
-    The data will be written to the current position of the file.
-    If this fp is NULL or invalid, the function will fail and return false.
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_write_fp(FILE *fp,
-                                const yyjson_doc *doc,
-                                yyjson_write_flag flg,
-                                const yyjson_alc *alc,
-                                yyjson_write_err *err);
-
-/**
- Write a document to JSON string.
- 
- This function is thread-safe.
- 
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_write(const yyjson_doc *doc,
-                                     yyjson_write_flag flg,
-                                     size_t *len) {
-    return yyjson_write_opts(doc, flg, NULL, len, NULL);
-}
-
-
-
-/**
- Write a document to JSON string with options.
- 
- This function is thread-safe when:
- 1. The `doc` is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
-
- @param doc The mutable JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
-                                       yyjson_write_flag flg,
-                                       const yyjson_alc *alc,
-                                       size_t *len,
-                                       yyjson_write_err *err);
-
-/**
- Write a document to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `doc` is not modified by other threads.
- 3. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param doc The mutable JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_mut_write_file(const char *path,
-                                      const yyjson_mut_doc *doc,
-                                      yyjson_write_flag flg,
-                                      const yyjson_alc *alc,
-                                      yyjson_write_err *err);
-
-/**
- Write a document to file pointer with options.
- 
- @param fp The file pointer.
-    The data will be written to the current position of the file.
-    If this fp is NULL or invalid, the function will fail and return false.
- @param doc The mutable JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_mut_write_fp(FILE *fp,
-                                    const yyjson_mut_doc *doc,
-                                    yyjson_write_flag flg,
-                                    const yyjson_alc *alc,
-                                    yyjson_write_err *err);
-
-/**
- Write a document to JSON string.
- 
- This function is thread-safe when:
- The `doc` is not modified by other threads.
- 
- @param doc The JSON document.
-    If this doc is NULL or has no root, the function will fail and return false.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_mut_write(const yyjson_mut_doc *doc,
-                                         yyjson_write_flag flg,
-                                         size_t *len) {
-    return yyjson_mut_write_opts(doc, flg, NULL, len, NULL);
-}
-
-
-
-/*==============================================================================
- * JSON Value Writer API
- *============================================================================*/
-
-/**
- Write a value to JSON string with options.
- 
- This function is thread-safe when:
- The `alc` is thread-safe or NULL.
- 
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_val_write_opts(const yyjson_val *val,
-                                       yyjson_write_flag flg,
-                                       const yyjson_alc *alc,
-                                       size_t *len,
-                                       yyjson_write_err *err);
-
-/**
- Write a value to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_val_write_file(const char *path,
-                                      const yyjson_val *val,
-                                      yyjson_write_flag flg,
-                                      const yyjson_alc *alc,
-                                      yyjson_write_err *err);
-
-/**
- Write a value to file pointer with options.
- 
- @param fp The file pointer.
-    The data will be written to the current position of the file.
-    If this path is NULL or invalid, the function will fail and return false.
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_val_write_fp(FILE *fp,
-                                    const yyjson_val *val,
-                                    yyjson_write_flag flg,
-                                    const yyjson_alc *alc,
-                                    yyjson_write_err *err);
-
-/**
- Write a value to JSON string.
- 
- This function is thread-safe.
- 
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_val_write(const yyjson_val *val,
-                                         yyjson_write_flag flg,
-                                         size_t *len) {
-    return yyjson_val_write_opts(val, flg, NULL, len, NULL);
-}
-
-/**
- Write a value to JSON string with options.
- 
- This function is thread-safe when:
- 1. The `val` is not modified by other threads.
- 2. The `alc` is thread-safe or NULL.
- 
- @param val The mutable JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return  A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free() or alc->free().
- */
-yyjson_api char *yyjson_mut_val_write_opts(const yyjson_mut_val *val,
-                                           yyjson_write_flag flg,
-                                           const yyjson_alc *alc,
-                                           size_t *len,
-                                           yyjson_write_err *err);
-
-/**
- Write a value to JSON file with options.
- 
- This function is thread-safe when:
- 1. The file is not accessed by other threads.
- 2. The `val` is not modified by other threads.
- 3. The `alc` is thread-safe or NULL.
- 
- @param path The JSON file's path.
-    If this path is NULL or invalid, the function will fail and return false.
-    If this file is not empty, the content will be discarded.
- @param val The mutable JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_mut_val_write_file(const char *path,
-                                          const yyjson_mut_val *val,
-                                          yyjson_write_flag flg,
-                                          const yyjson_alc *alc,
-                                          yyjson_write_err *err);
-
-/**
- Write a value to JSON file with options.
- 
- @param fp The file pointer.
-    The data will be written to the current position of the file.
-    If this path is NULL or invalid, the function will fail and return false.
- @param val The mutable JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param alc The memory allocator used by JSON writer.
-    Pass NULL to use the libc's default allocator.
- @param err A pointer to receive error information.
-    Pass NULL if you don't need error information.
- @return true if successful, false if an error occurs.
- 
- @warning On 32-bit operating system, files larger than 2GB may fail to write.
- */
-yyjson_api bool yyjson_mut_val_write_fp(FILE *fp,
-                                        const yyjson_mut_val *val,
-                                        yyjson_write_flag flg,
-                                        const yyjson_alc *alc,
-                                        yyjson_write_err *err);
-
-/**
- Write a value to JSON string.
- 
- This function is thread-safe when:
- The `val` is not modified by other threads.
- 
- @param val The JSON root value.
-    If this parameter is NULL, the function will fail and return NULL.
- @param flg The JSON write options.
-    Multiple options can be combined with `|` operator. 0 means no options.
- @param len A pointer to receive output length in bytes (not including the
-    null-terminator). Pass NULL if you don't need length information.
- @return A new JSON string, or NULL if an error occurs.
-    This string is encoded as UTF-8 with a null-terminator.
-    When it's no longer needed, it should be freed with free().
- */
-yyjson_api_inline char *yyjson_mut_val_write(const yyjson_mut_val *val,
-                                             yyjson_write_flag flg,
-                                             size_t *len) {
-    return yyjson_mut_val_write_opts(val, flg, NULL, len, NULL);
-}
-
-
-
-/*==============================================================================
- * JSON Document API
- *============================================================================*/
-
-/** Returns the root value of this JSON document.
-    Returns NULL if `doc` is NULL. */
-yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc);
-
-/** Returns read size of input JSON data.
-    Returns 0 if `doc` is NULL.
-    For example: the read size of `[1,2,3]` is 7 bytes.  */
-yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc);
-
-/** Returns total value count in this JSON document.
-    Returns 0 if `doc` is NULL.
-    For example: the value count of `[1,2,3]` is 4. */
-yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc);
-
-/** Release the JSON document and free the memory.
-    After calling this function, the `doc` and all values from the `doc` are no
-    longer available. This function will do nothing if the `doc` is NULL. */
-yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc);
-
-
-
-/*==============================================================================
- * JSON Value Type API
- *============================================================================*/
-
-/** Returns whether the JSON value is raw.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_raw(yyjson_val *val);
-
-/** Returns whether the JSON value is `null`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_null(yyjson_val *val);
-
-/** Returns whether the JSON value is `true`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_true(yyjson_val *val);
-
-/** Returns whether the JSON value is `false`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_false(yyjson_val *val);
-
-/** Returns whether the JSON value is bool (true/false).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_bool(yyjson_val *val);
-
-/** Returns whether the JSON value is unsigned integer (uint64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_uint(yyjson_val *val);
-
-/** Returns whether the JSON value is signed integer (int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_sint(yyjson_val *val);
-
-/** Returns whether the JSON value is integer (uint64_t/int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_int(yyjson_val *val);
-
-/** Returns whether the JSON value is real number (double).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_real(yyjson_val *val);
-
-/** Returns whether the JSON value is number (uint64_t/int64_t/double).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_num(yyjson_val *val);
-
-/** Returns whether the JSON value is string.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_str(yyjson_val *val);
-
-/** Returns whether the JSON value is array.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_arr(yyjson_val *val);
-
-/** Returns whether the JSON value is object.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_obj(yyjson_val *val);
-
-/** Returns whether the JSON value is container (array/object).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val);
-
-
-
-/*==============================================================================
- * JSON Value Content API
- *============================================================================*/
-
-/** Returns the JSON value's type.
-    Returns YYJSON_TYPE_NONE if `val` is NULL. */
-yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val);
-
-/** Returns the JSON value's subtype.
-    Returns YYJSON_SUBTYPE_NONE if `val` is NULL. */
-yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val);
-
-/** Returns the JSON value's tag.
-    Returns 0 if `val` is NULL. */
-yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val);
-
-/** Returns the JSON value's type description.
-    The return value should be one of these strings: "raw", "null", "string",
-    "array", "object", "true", "false", "uint", "sint", "real", "unknown". */
-yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val);
-
-/** Returns the content if the value is raw.
-    Returns NULL if `val` is NULL or type is not raw. */
-yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val);
-
-/** Returns the content if the value is bool.
-    Returns NULL if `val` is NULL or type is not bool. */
-yyjson_api_inline bool yyjson_get_bool(yyjson_val *val);
-
-/** Returns the content and cast to uint64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val);
-
-/** Returns the content and cast to int64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val);
-
-/** Returns the content and cast to int.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int yyjson_get_int(yyjson_val *val);
-
-/** Returns the content if the value is real number, or 0.0 on error.
-    Returns 0.0 if `val` is NULL or type is not real(double). */
-yyjson_api_inline double yyjson_get_real(yyjson_val *val);
-
-/** Returns the content and typecast to `double` if the value is number.
-    Returns 0.0 if `val` is NULL or type is not number(uint/sint/real). */
-yyjson_api_inline double yyjson_get_num(yyjson_val *val);
-
-/** Returns the content if the value is string.
-    Returns NULL if `val` is NULL or type is not string. */
-yyjson_api_inline const char *yyjson_get_str(yyjson_val *val);
-
-/** Returns the content length (string length, array size, object size.
-    Returns 0 if `val` is NULL or type is not string/array/object. */
-yyjson_api_inline size_t yyjson_get_len(yyjson_val *val);
-
-/** Returns whether the JSON value is equals to a string.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str);
-
-/** Returns whether the JSON value is equals to a string.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str,
-                                          size_t len);
-
-/** Returns whether two JSON values are equal (deep compare).
-    Returns false if input is NULL.
-    @note the result may be inaccurate if object has duplicate keys.
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs);
-
-/** Set the value to raw.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_raw(yyjson_val *val,
-                                      const char *raw, size_t len);
-
-/** Set the value to null.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_null(yyjson_val *val);
-
-/** Set the value to bool.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_bool(yyjson_val *val, bool num);
-
-/** Set the value to uint.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_uint(yyjson_val *val, uint64_t num);
-
-/** Set the value to sint.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num);
-
-/** Set the value to int.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num);
-
-/** Set the value to real.
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_real(yyjson_val *val, double num);
-
-/** Set the value to string (null-terminated).
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_str(yyjson_val *val, const char *str);
-
-/** Set the value to string (with length).
-    Returns false if input is NULL or `val` is object or array.
-    @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_strn(yyjson_val *val,
-                                       const char *str, size_t len);
-
-
-
-/*==============================================================================
- * JSON Array API
- *============================================================================*/
-
-/** Returns the number of elements in this array.
-    Returns 0 if `arr` is NULL or type is not array. */
-yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr);
-
-/** Returns the element at the specified position in this array.
-    Returns NULL if array is NULL/empty or the index is out of bounds.
-    @warning This function takes a linear search time if array is not flat.
-        For example: `[1,{},3]` is flat, `[1,[2],3]` is not flat. */
-yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx);
-
-/** Returns the first element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array. */
-yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr);
-
-/** Returns the last element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array.
-    @warning This function takes a linear search time if array is not flat.
-        For example: `[1,{},3]` is flat, `[1,[2],3]` is not flat.*/
-yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr);
-
-
-
-/*==============================================================================
- * JSON Array Iterator API
- *============================================================================*/
-
-/**
- A JSON array iterator.
- 
- @par Example
- @code
-    yyjson_val *val;
-    yyjson_arr_iter iter = yyjson_arr_iter_with(arr);
-    while ((val = yyjson_arr_iter_next(&iter))) {
-        your_func(val);
-    }
- @endcode
- */
-typedef struct yyjson_arr_iter {
-    size_t idx; /**< next value's index */
-    size_t max; /**< maximum index (arr.size) */
-    yyjson_val *cur; /**< next value */
-} yyjson_arr_iter;
-
-/**
- Initialize an iterator for this array.
- 
- @param arr The array to be iterated over.
-    If this parameter is NULL or not an array, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr,
-                                            yyjson_arr_iter *iter);
-
-/**
- Create an iterator with an array , same as `yyjson_arr_iter_init()`.
- 
- @param arr The array to be iterated over.
-    If this parameter is NULL or not an array, an empty iterator will returned.
- @return A new iterator for the array.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline yyjson_arr_iter yyjson_arr_iter_with(yyjson_val *arr);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter);
-
-/**
- Returns the next element in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter);
-
-/**
- Macro for iterating over an array.
- It works like iterator, but with a more intuitive API.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_val *val;
-    yyjson_arr_foreach(arr, idx, max, val) {
-        your_func(idx, val);
-    }
- @endcode
- */
-#define yyjson_arr_foreach(arr, idx, max, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_arr_size(arr), \
-        (val) = yyjson_arr_get_first(arr); \
-        (idx) < (max); \
-        (idx)++, \
-        (val) = unsafe_yyjson_get_next(val))
-
-
-
-/*==============================================================================
- * JSON Object API
- *============================================================================*/
-
-/** Returns the number of key-value pairs in this object.
-    Returns 0 if `obj` is NULL or type is not object. */
-yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a null-terminated UTF-8 string.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj, const char *key);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a UTF-8 string, null-terminator is not required.
-    The `key_len` should be the length of the key, in bytes.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj, const char *key,
-                                              size_t key_len);
-
-
-
-/*==============================================================================
- * JSON Object Iterator API
- *============================================================================*/
-
-/**
- A JSON object iterator.
- 
- @par Example
- @code
-    yyjson_val *key, *val;
-    yyjson_obj_iter iter = yyjson_obj_iter_with(obj);
-    while ((key = yyjson_obj_iter_next(&iter))) {
-        val = yyjson_obj_iter_get_val(key);
-        your_func(key, val);
-    }
- @endcode
- 
- If the ordering of the keys is known at compile-time, you can use this method
- to speed up value lookups:
- @code
-    // {"k1":1, "k2": 3, "k3": 3}
-    yyjson_val *key, *val;
-    yyjson_obj_iter iter = yyjson_obj_iter_with(obj);
-    yyjson_val *v1 = yyjson_obj_iter_get(&iter, "k1");
-    yyjson_val *v3 = yyjson_obj_iter_get(&iter, "k3");
- @endcode
- @see yyjson_obj_iter_get() and yyjson_obj_iter_getn()
- */
-typedef struct yyjson_obj_iter {
-    size_t idx; /**< next key's index */
-    size_t max; /**< maximum key index (obj.size) */
-    yyjson_val *cur; /**< next key */
-    yyjson_val *obj; /**< the object being iterated */
-} yyjson_obj_iter;
-
-/**
- Initialize an iterator for this object.
- 
- @param obj The object to be iterated over.
-    If this parameter is NULL or not an object, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj,
-                                            yyjson_obj_iter *iter);
-
-/**
- Create an iterator with an object, same as `yyjson_obj_iter_init()`.
- 
- @param obj The object to be iterated over.
-    If this parameter is NULL or not an object, an empty iterator will returned.
- @return A new iterator for the object.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline yyjson_obj_iter yyjson_obj_iter_with(yyjson_val *obj);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter);
-
-/**
- Returns the next key in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter);
-
-/**
- Returns the value for key inside the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key);
-
-/**
- Iterates to a specified key and returns the value.
- 
- This function does the same thing as `yyjson_obj_get()`, but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string with null-terminator.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter,
-                                                  const char *key);
-
-/**
- Iterates to a specified key and returns the value.
-
- This function does the same thing as `yyjson_obj_getn()`, but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string, null-terminator is not required.
- @param key_len The the length of `key`, in bytes.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter,
-                                                   const char *key,
-                                                   size_t key_len);
-
-/**
- Macro for iterating over an object.
- It works like iterator, but with a more intuitive API.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_val *key, *val;
-    yyjson_obj_foreach(obj, idx, max, key, val) {
-        your_func(key, val);
-    }
- @endcode
- */
-#define yyjson_obj_foreach(obj, idx, max, key, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_obj_size(obj), \
-        (key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, \
-        (val) = (key) + 1; \
-        (idx) < (max); \
-        (idx)++, \
-        (key) = unsafe_yyjson_get_next(val), \
-        (val) = (key) + 1)
-
-
-
-/*==============================================================================
- * Mutable JSON Document API
- *============================================================================*/
-
-/** Returns the root value of this JSON document.
-    Returns NULL if `doc` is NULL. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc);
-
-/** Sets the root value of this JSON document.
-    Pass NULL to clear root value of the document. */
-yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *root);
-
-/**
- Set the string pool size for a mutable document.
- This function does not allocate memory immediately, but uses the size when
- the next memory allocation is needed.
- 
- If the caller knows the approximate bytes of strings that the document needs to
- store (e.g. copy string with `yyjson_mut_strcpy` function), setting a larger
- size can avoid multiple memory allocations and improve performance.
- 
- @param doc The mutable document.
- @param len The desired string pool size in bytes (total string length).
- @return true if successful, false if size is 0 or overflow.
- */
-yyjson_api bool yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc *doc,
-                                                 size_t len);
-
-/**
- Set the value pool size for a mutable document.
- This function does not allocate memory immediately, but uses the size when
- the next memory allocation is needed.
- 
- If the caller knows the approximate number of values that the document needs to
- store (e.g. create new value with `yyjson_mut_xxx` functions), setting a larger
- size can avoid multiple memory allocations and improve performance.
- 
- @param doc The mutable document.
- @param count The desired value pool size (number of `yyjson_mut_val`).
- @return true if successful, false if size is 0 or overflow.
- */
-yyjson_api bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc,
-                                                 size_t count);
-
-/** Release the JSON document and free the memory.
-    After calling this function, the `doc` and all values from the `doc` are no
-    longer available. This function will do nothing if the `doc` is NULL.  */
-yyjson_api void yyjson_mut_doc_free(yyjson_mut_doc *doc);
-
-/** Creates and returns a new mutable JSON document, returns NULL on error.
-    If allocator is NULL, the default allocator will be used. */
-yyjson_api yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc);
-
-/** Copies and returns a new mutable document from input, returns NULL on error.
-    This makes a `deep-copy` on the immutable document.
-    If allocator is NULL, the default allocator will be used.
-    @note `imut_doc` -> `mut_doc`. */
-yyjson_api yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc,
-                                               const yyjson_alc *alc);
-
-/** Copies and returns a new mutable document from input, returns NULL on error.
-    This makes a `deep-copy` on the mutable document.
-    If allocator is NULL, the default allocator will be used.
-    @note `mut_doc` -> `mut_doc`. */
-yyjson_api yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc,
-                                                   const yyjson_alc *alc);
-
-/** Copies and returns a new mutable value from input, returns NULL on error.
-    This makes a `deep-copy` on the immutable value.
-    The memory was managed by mutable document.
-    @note `imut_val` -> `mut_val`. */
-yyjson_api yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *doc,
-                                               yyjson_val *val);
-
-/** Copies and returns a new mutable value from input, returns NULL on error.
-    This makes a `deep-copy` on the mutable value.
-    The memory was managed by mutable document.
-    @note `mut_val` -> `mut_val`.
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc,
-                                                   yyjson_mut_val *val);
-
-/** Copies and returns a new immutable document from input,
-    returns NULL on error. This makes a `deep-copy` on the mutable document.
-    The returned document should be freed with `yyjson_doc_free()`.
-    @note `mut_doc` -> `imut_doc`.
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api yyjson_doc *yyjson_mut_doc_imut_copy(yyjson_mut_doc *doc,
-                                                const yyjson_alc *alc);
-
-/** Copies and returns a new immutable document from input,
-    returns NULL on error. This makes a `deep-copy` on the mutable value.
-    The returned document should be freed with `yyjson_doc_free()`.
-    @note `mut_val` -> `imut_doc`.
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api yyjson_doc *yyjson_mut_val_imut_copy(yyjson_mut_val *val,
-                                                const yyjson_alc *alc);
-
-
-
-/*==============================================================================
- * Mutable JSON Value Type API
- *============================================================================*/
-
-/** Returns whether the JSON value is raw.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is `null`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is `true`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is `false`.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is bool (true/false).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is unsigned integer (uint64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is signed integer (int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is integer (uint64_t/int64_t).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is real number (double).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is number (uint/sint/real).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is string.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is array.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is object.
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is container (array/object).
-    Returns false if `val` is NULL. */
-yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val);
-
-
-
-/*==============================================================================
- * Mutable JSON Value Content API
- *============================================================================*/
-
-/** Returns the JSON value's type.
-    Returns `YYJSON_TYPE_NONE` if `val` is NULL. */
-yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val);
-
-/** Returns the JSON value's subtype.
-    Returns `YYJSON_SUBTYPE_NONE` if `val` is NULL. */
-yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val);
-
-/** Returns the JSON value's tag.
-    Returns 0 if `val` is NULL. */
-yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val);
-
-/** Returns the JSON value's type description.
-    The return value should be one of these strings: "raw", "null", "string",
-    "array", "object", "true", "false", "uint", "sint", "real", "unknown". */
-yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val);
-
-/** Returns the content if the value is raw.
-    Returns NULL if `val` is NULL or type is not raw. */
-yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val);
-
-/** Returns the content if the value is bool.
-    Returns NULL if `val` is NULL or type is not bool. */
-yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val);
-
-/** Returns the content and cast to uint64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val);
-
-/** Returns the content and cast to int64_t.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val);
-
-/** Returns the content and cast to int.
-    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
-yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val);
-
-/** Returns the content if the value is real number.
-    Returns 0.0 if `val` is NULL or type is not real(double). */
-yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val);
-
-/** Returns the content and typecast to `double` if the value is number.
-    Returns 0.0 if `val` is NULL or type is not number(uint/sint/real). */
-yyjson_api_inline double yyjson_mut_get_num(yyjson_mut_val *val);
-
-/** Returns the content if the value is string.
-    Returns NULL if `val` is NULL or type is not string. */
-yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val);
-
-/** Returns the content length (string length, array size, object size.
-    Returns 0 if `val` is NULL or type is not string/array/object. */
-yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val);
-
-/** Returns whether the JSON value is equals to a string.
-    The `str` should be a null-terminated UTF-8 string.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val,
-                                             const char *str);
-
-/** Returns whether the JSON value is equals to a string.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    Returns false if input is NULL or type is not string. */
-yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val,
-                                              const char *str, size_t len);
-
-/** Returns whether two JSON values are equal (deep compare).
-    Returns false if input is NULL.
-    @note the result may be inaccurate if object has duplicate keys.
-    @warning This function is recursive and may cause a stack overflow
-        if the object level is too deep. */
-yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs,
-                                         yyjson_mut_val *rhs);
-
-/** Set the value to raw.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val *val,
-                                          const char *raw, size_t len);
-
-/** Set the value to null.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val *val);
-
-/** Set the value to bool.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val *val, bool num);
-
-/** Set the value to uint.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val *val, uint64_t num);
-
-/** Set the value to sint.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num);
-
-/** Set the value to int.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num);
-
-/** Set the value to real.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val *val, double num);
-
-/** Set the value to string (null-terminated).
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val *val, const char *str);
-
-/** Set the value to string (with length).
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val *val,
-                                           const char *str, size_t len);
-
-/** Set the value to array.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val *val);
-
-/** Set the value to array.
-    Returns false if input is NULL.
-    @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val *val);
-
-
-
-/*==============================================================================
- * Mutable JSON Value Creation API
- *============================================================================*/
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc,
-                                                 const char *str);
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len);
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc,
-                                                    const char *str);
-
-/** Creates and returns a raw value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len);
-
-/** Creates and returns a null value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc);
-
-/** Creates and returns a true value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc);
-
-/** Creates and returns a false value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc);
-
-/** Creates and returns a bool value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
-                                                  bool val);
-
-/** Creates and returns an unsigned integer value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc,
-                                                  uint64_t num);
-
-/** Creates and returns a signed integer value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc,
-                                                  int64_t num);
-
-/** Creates and returns a signed integer value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc,
-                                                 int64_t num);
-
-/** Creates and returns an real number value, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc,
-                                                  double num);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc,
-                                                 const char *str);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    @warning The input string is not copied, you should keep this string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a null-terminated UTF-8 string.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc,
-                                                    const char *str);
-
-/** Creates and returns a string value, returns NULL on error.
-    The `str` should be a UTF-8 string, null-terminator is not required.
-    The input string is copied and held by the document. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len);
-
-
-
-/*==============================================================================
- * Mutable JSON Array API
- *============================================================================*/
-
-/** Returns the number of elements in this array.
-    Returns 0 if `arr` is NULL or type is not array. */
-yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr);
-
-/** Returns the element at the specified position in this array.
-    Returns NULL if array is NULL/empty or the index is out of bounds.
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr,
-                                                     size_t idx);
-
-/** Returns the first element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(yyjson_mut_val *arr);
-
-/** Returns the last element of this array.
-    Returns NULL if `arr` is NULL/empty or type is not array. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(yyjson_mut_val *arr);
-
-
-
-/*==============================================================================
- * Mutable JSON Array Iterator API
- *============================================================================*/
-
-/**
- A mutable JSON array iterator.
- 
- @warning You should not modify the array while iterating over it, but you can
-    use `yyjson_mut_arr_iter_remove()` to remove current value.
- 
- @par Example
- @code
-    yyjson_mut_val *val;
-    yyjson_mut_arr_iter iter = yyjson_mut_arr_iter_with(arr);
-    while ((val = yyjson_mut_arr_iter_next(&iter))) {
-        your_func(val);
-        if (your_val_is_unused(val)) {
-            yyjson_mut_arr_iter_remove(&iter);
-        }
-    }
- @endcode
- */
-typedef struct yyjson_mut_arr_iter {
-    size_t idx; /**< next value's index */
-    size_t max; /**< maximum index (arr.size) */
-    yyjson_mut_val *cur; /**< current value */
-    yyjson_mut_val *pre; /**< previous value */
-    yyjson_mut_val *arr; /**< the array being iterated */
-} yyjson_mut_arr_iter;
-
-/**
- Initialize an iterator for this array.
- 
- @param arr The array to be iterated over.
-    If this parameter is NULL or not an array, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr,
-    yyjson_mut_arr_iter *iter);
-
-/**
- Create an iterator with an array , same as `yyjson_mut_arr_iter_init()`.
- 
- @param arr The array to be iterated over.
-    If this parameter is NULL or not an array, an empty iterator will returned.
- @return A new iterator for the array.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with(
-    yyjson_mut_val *arr);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_mut_arr_iter_has_next(
-    yyjson_mut_arr_iter *iter);
-
-/**
- Returns the next element in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next(
-    yyjson_mut_arr_iter *iter);
-
-/**
- Removes and returns current element in the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove(
-    yyjson_mut_arr_iter *iter);
-
-/**
- Macro for iterating over an array.
- It works like iterator, but with a more intuitive API.
- 
- @warning You should not modify the array while iterating over it.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_mut_val *val;
-    yyjson_mut_arr_foreach(arr, idx, max, val) {
-        your_func(idx, val);
-    }
- @endcode
- */
-#define yyjson_mut_arr_foreach(arr, idx, max, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_mut_arr_size(arr), \
-        (val) = yyjson_mut_arr_get_first(arr); \
-        (idx) < (max); \
-        (idx)++, \
-        (val) = (val)->next)
-
-
-
-/*==============================================================================
- * Mutable JSON Array Creation API
- *============================================================================*/
-
-/**
- Creates and returns an empty mutable array.
- @param doc A mutable document, used for memory allocation only.
- @return The new array. NULL if input is NULL or memory allocation failed.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc);
-
-/**
- Creates and returns a new mutable array with the given boolean values.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of boolean values.
- @param count The value count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const bool vals[3] = { true, false, true };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_bool(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
-    yyjson_mut_doc *doc, const bool *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given sint numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of sint numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int64_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint64_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given real numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of real numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const double vals[3] = { 0.1, 0.2, 0.3 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_real(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real(
-    yyjson_mut_doc *doc, const double *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int8 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int8 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int8_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint8(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8(
-    yyjson_mut_doc *doc, const int8_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int16 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int16 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int16_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint16(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16(
-    yyjson_mut_doc *doc, const int16_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int32 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int32 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int32_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint32(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32(
-    yyjson_mut_doc *doc, const int32_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given int64 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of int64 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const int64_t vals[3] = { -1, 0, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint8 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint8 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint8_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint8(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8(
-    yyjson_mut_doc *doc, const uint8_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint16 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint16 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint16_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint16(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16(
-    yyjson_mut_doc *doc, const uint16_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint32 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint32 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const uint32_t vals[3] = { 0, 1, 0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_uint32(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32(
-    yyjson_mut_doc *doc, const uint32_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given uint64 numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of uint64 numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-     const uint64_t vals[3] = { 0, 1, 0 };
-     yyjson_mut_val *arr = yyjson_mut_arr_with_uint64(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given float numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of float numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const float vals[3] = { -1.0f, 0.0f, 1.0f };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_float(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float(
-    yyjson_mut_doc *doc, const float *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given double numbers.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of double numbers.
- @param count The number count. If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const double vals[3] = { -1.0, 0.0, 1.0 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_double(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double(
-    yyjson_mut_doc *doc, const double *vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings, these strings
- will not be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 null-terminator strings.
-    If this array contains NULL, the function will fail and return NULL.
- @param count The number of values in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @warning The input strings are not copied, you should keep these strings
-    unmodified for the lifetime of this JSON document. If these strings will be
-    modified, you should use `yyjson_mut_arr_with_strcpy()` instead.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "b", "c" };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_str(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str(
-    yyjson_mut_doc *doc, const char **vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings and string
- lengths, these strings will not be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 strings, null-terminator is not required.
-    If this array contains NULL, the function will fail and return NULL.
- @param lens A C array of string lengths, in bytes.
- @param count The number of strings in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @warning The input strings are not copied, you should keep these strings
-    unmodified for the lifetime of this JSON document. If these strings will be
-    modified, you should use `yyjson_mut_arr_with_strncpy()` instead.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "bb", "c" };
-    const size_t lens[3] = { 1, 2, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings, these strings
- will be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 null-terminator strings.
-    If this array contains NULL, the function will fail and return NULL.
- @param count The number of values in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "b", "c" };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_strcpy(doc, vals, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy(
-    yyjson_mut_doc *doc, const char **vals, size_t count);
-
-/**
- Creates and returns a new mutable array with the given strings and string
- lengths, these strings will be copied.
- 
- @param doc A mutable document, used for memory allocation only.
-    If this parameter is NULL, the function will fail and return NULL.
- @param vals A C array of UTF-8 strings, null-terminator is not required.
-    If this array contains NULL, the function will fail and return NULL.
- @param lens A C array of string lengths, in bytes.
- @param count The number of strings in `vals`.
-    If this value is 0, an empty array will return.
- @return The new array. NULL if input is invalid or memory allocation failed.
- 
- @par Example
- @code
-    const char *vals[3] = { "a", "bb", "c" };
-    const size_t lens[3] = { 1, 2, 1 };
-    yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification API
- *============================================================================*/
-
-/**
- Inserts a value into an array at a given index.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @param idx The index to which to insert the new value.
-    Returns false if the index is out of range.
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val, size_t idx);
-
-/**
- Inserts a value at the end of the array.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val);
-
-/**
- Inserts a value at the head of the array.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @return    Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val);
-
-/**
- Replaces a value at index and returns old value.
- @param arr The array to which the value is to be replaced.
-    Returns false if it is NULL or not an array.
- @param idx The index to which to replace the value.
-    Returns false if the index is out of range.
- @param val The new value to replace. Returns false if it is NULL.
- @return Old value, or NULL on error.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr,
-                                                         size_t idx,
-                                                         yyjson_mut_val *val);
-
-/**
- Removes and returns a value at index.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @param idx The index from which to remove the value.
-    Returns false if the index is out of range.
- @return Old value, or NULL on error.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr,
-                                                        size_t idx);
-
-/**
- Removes and returns the first value in this array.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @return The first value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first(
-    yyjson_mut_val *arr);
-
-/**
- Removes and returns the last value in this array.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @return The last value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last(
-    yyjson_mut_val *arr);
-
-/**
- Removes all values within a specified range in the array.
- @param arr The array from which the value is to be removed.
-    Returns false if it is NULL or not an array.
- @param idx The start index of the range (0 is the first).
- @param len The number of items in the range (can be 0).
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr,
-                                                   size_t idx, size_t len);
-
-/**
- Removes all values in this array.
- @param arr The array from which all of the values are to be removed.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr);
-
-/**
- Rotates values in this array for the given number of times.
- For example: `[1,2,3,4,5]` rotate 2 is `[3,4,5,1,2]`.
- @param arr The array to be rotated.
- @param idx Index (or times) to rotate.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr,
-                                             size_t idx);
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification Convenience API
- *============================================================================*/
-
-/**
- Adds a value at the end of the array.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The value to be inserted. Returns false if it is NULL.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val);
-
-/**
- Adds a `null` value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr);
-
-/**
- Adds a `true` value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr);
-
-/**
- Adds a `false` value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *arr);
-
-/**
- Adds a bool value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param val The bool value to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               bool val);
-
-/**
- Adds an unsigned integer value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               uint64_t num);
-
-/**
- Adds a signed integer value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               int64_t num);
-
-/**
- Adds a integer value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              int64_t num);
-
-/**
- Adds a double value at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param num The number to be added.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               double num);
-
-/**
- Adds a string value at the end of the array (no copy).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A null-terminated UTF-8 string.
- @return Whether successful.
- @warning The input string is not copied, you should keep this string unmodified
-    for the lifetime of this JSON document.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              const char *str);
-
-/**
- Adds a string value at the end of the array (no copy).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A UTF-8 string, null-terminator is not required.
- @param len The length of the string, in bytes.
- @return Whether successful.
- @warning The input string is not copied, you should keep this string unmodified
-    for the lifetime of this JSON document.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               const char *str,
-                                               size_t len);
-
-/**
- Adds a string value at the end of the array (copied).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A null-terminated UTF-8 string.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *arr,
-                                                 const char *str);
-
-/**
- Adds a string value at the end of the array (copied).
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @param str A UTF-8 string, null-terminator is not required.
- @param len The length of the string, in bytes.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *arr,
-                                                  const char *str,
-                                                  size_t len);
-
-/**
- Creates and adds a new array at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return The new array, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr);
-
-/**
- Creates and adds a new object at the end of the array.
- @param doc The `doc` is only used for memory allocation.
- @param arr The array to which the value is to be inserted.
-    Returns false if it is NULL or not an array.
- @return The new object, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr);
-
-
-
-/*==============================================================================
- * Mutable JSON Object API
- *============================================================================*/
-
-/** Returns the number of key-value pairs in this object.
-    Returns 0 if `obj` is NULL or type is not object. */
-yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a null-terminated UTF-8 string.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj,
-                                                     const char *key);
-
-/** Returns the value to which the specified key is mapped.
-    Returns NULL if this object contains no mapping for the key.
-    Returns NULL if `obj/key` is NULL, or type is not object.
-    
-    The `key` should be a UTF-8 string, null-terminator is not required.
-    The `key_len` should be the length of the key, in bytes.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj,
-                                                      const char *key,
-                                                      size_t key_len);
-
-
-
-/*==============================================================================
- * Mutable JSON Object Iterator API
- *============================================================================*/
-
-/**
- A mutable JSON object iterator.
- 
- @warning You should not modify the object while iterating over it, but you can
-    use `yyjson_mut_obj_iter_remove()` to remove current value.
- 
- @par Example
- @code
-    yyjson_mut_val *key, *val;
-    yyjson_mut_obj_iter iter = yyjson_mut_obj_iter_with(obj);
-    while ((key = yyjson_mut_obj_iter_next(&iter))) {
-        val = yyjson_mut_obj_iter_get_val(key);
-        your_func(key, val);
-        if (your_val_is_unused(key, val)) {
-            yyjson_mut_obj_iter_remove(&iter);
-        }
-    }
- @endcode
- 
- If the ordering of the keys is known at compile-time, you can use this method
- to speed up value lookups:
- @code
-    // {"k1":1, "k2": 3, "k3": 3}
-    yyjson_mut_val *key, *val;
-    yyjson_mut_obj_iter iter = yyjson_mut_obj_iter_with(obj);
-    yyjson_mut_val *v1 = yyjson_mut_obj_iter_get(&iter, "k1");
-    yyjson_mut_val *v3 = yyjson_mut_obj_iter_get(&iter, "k3");
- @endcode
- @see `yyjson_mut_obj_iter_get()` and `yyjson_mut_obj_iter_getn()`
- */
-typedef struct yyjson_mut_obj_iter {
-    size_t idx; /**< next key's index */
-    size_t max; /**< maximum key index (obj.size) */
-    yyjson_mut_val *cur; /**< current key */
-    yyjson_mut_val *pre; /**< previous key */
-    yyjson_mut_val *obj; /**< the object being iterated */
-} yyjson_mut_obj_iter;
-
-/**
- Initialize an iterator for this object.
- 
- @param obj The object to be iterated over.
-    If this parameter is NULL or not an array, `iter` will be set to empty.
- @param iter The iterator to be initialized.
-    If this parameter is NULL, the function will fail and return false.
- @return true if the `iter` has been successfully initialized.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj,
-    yyjson_mut_obj_iter *iter);
-
-/**
- Create an iterator with an object, same as `yyjson_obj_iter_init()`.
- 
- @param obj The object to be iterated over.
-    If this parameter is NULL or not an object, an empty iterator will returned.
- @return A new iterator for the object.
- 
- @note The iterator does not need to be destroyed.
- */
-yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with(
-    yyjson_mut_val *obj);
-
-/**
- Returns whether the iteration has more elements.
- If `iter` is NULL, this function will return false.
- */
-yyjson_api_inline bool yyjson_mut_obj_iter_has_next(
-    yyjson_mut_obj_iter *iter);
-
-/**
- Returns the next key in the iteration, or NULL on end.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next(
-    yyjson_mut_obj_iter *iter);
-
-/**
- Returns the value for key inside the iteration.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val(
-    yyjson_mut_val *key);
-
-/**
- Removes current key-value pair in the iteration, returns the removed value.
- If `iter` is NULL, this function will return NULL.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove(
-    yyjson_mut_obj_iter *iter);
-
-/**
- Iterates to a specified key and returns the value.
- 
- This function does the same thing as `yyjson_mut_obj_get()`, but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string with null-terminator.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get(
-    yyjson_mut_obj_iter *iter, const char *key);
-
-/**
- Iterates to a specified key and returns the value.
- 
- This function does the same thing as `yyjson_mut_obj_getn()` but is much faster
- if the ordering of the keys is known at compile-time and you are using the same
- order to look up the values. If the key exists in this object, then the
- iterator will stop at the next key, otherwise the iterator will not change and
- NULL is returned.
- 
- @param iter The object iterator, should not be NULL.
- @param key The key, should be a UTF-8 string, null-terminator is not required.
- @param key_len The the length of `key`, in bytes.
- @return The value to which the specified key is mapped.
-    NULL if this object contains no mapping for the key or input is invalid.
- 
- @warning This function takes a linear search time if the key is not nearby.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn(
-    yyjson_mut_obj_iter *iter, const char *key, size_t key_len);
-
-/**
- Macro for iterating over an object.
- It works like iterator, but with a more intuitive API.
- 
- @warning You should not modify the object while iterating over it.
- 
- @par Example
- @code
-    size_t idx, max;
-    yyjson_val *key, *val;
-    yyjson_obj_foreach(obj, idx, max, key, val) {
-        your_func(key, val);
-    }
- @endcode
- */
-#define yyjson_mut_obj_foreach(obj, idx, max, key, val) \
-    for ((idx) = 0, \
-        (max) = yyjson_mut_obj_size(obj), \
-        (key) = (max) ? ((yyjson_mut_val *)(obj)->uni.ptr)->next->next : NULL, \
-        (val) = (key) ? (key)->next : NULL; \
-        (idx) < (max); \
-        (idx)++, \
-        (key) = (val)->next, \
-        (val) = (key)->next)
-
-
-
-/*==============================================================================
- * Mutable JSON Object Creation API
- *============================================================================*/
-
-/** Creates and returns a mutable object, returns NULL on error. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc);
-
-/**
- Creates and returns a mutable object with keys and values, returns NULL on
- error. The keys and values are not copied. The strings should be a
- null-terminated UTF-8 string.
- 
- @warning The input string is not copied, you should keep this string
-    unmodified for the lifetime of this JSON document.
- 
- @par Example
- @code
-    const char *keys[2] = { "id", "name" };
-    const char *vals[2] = { "01", "Harry" };
-    yyjson_mut_val *obj = yyjson_mut_obj_with_str(doc, keys, vals, 2);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc,
-                                                          const char **keys,
-                                                          const char **vals,
-                                                          size_t count);
-
-/**
- Creates and returns a mutable object with key-value pairs and pair count,
- returns NULL on error. The keys and values are not copied. The strings should
- be a null-terminated UTF-8 string.
- 
- @warning The input string is not copied, you should keep this string
-    unmodified for the lifetime of this JSON document.
- 
- @par Example
- @code
-    const char *kv_pairs[4] = { "id", "01", "name", "Harry" };
-    yyjson_mut_val *obj = yyjson_mut_obj_with_kv(doc, kv_pairs, 2);
- @endcode
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc,
-                                                         const char **kv_pairs,
-                                                         size_t pair_count);
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification API
- *============================================================================*/
-
-/**
- Adds a key-value pair at the end of the object.
- This function allows duplicated key in one object.
- @param obj The object to which the new key-value pair is to be added.
- @param key The key, should be a string which is created by `yyjson_mut_str()`,
-    `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`.
- @param val The value to add to the object.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val);
-/**
- Sets a key-value pair at the end of the object.
- This function may remove all key-value pairs for the given key before add.
- @param obj The object to which the new key-value pair is to be added.
- @param key The key, should be a string which is created by `yyjson_mut_str()`,
-    `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`.
- @param val The value to add to the object. If this value is null, the behavior
-    is same as `yyjson_mut_obj_remove()`.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val);
-
-/**
- Inserts a key-value pair to the object at the given position.
- This function allows duplicated key in one object.
- @param obj The object to which the new key-value pair is to be added.
- @param key The key, should be a string which is created by `yyjson_mut_str()`,
-    `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`.
- @param val The value to add to the object.
- @param idx The index to which to insert the new pair.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj,
-                                             yyjson_mut_val *key,
-                                             yyjson_mut_val *val,
-                                             size_t idx);
-
-/**
- Removes all key-value pair from the object with given key.
- @param obj The object from which the key-value pair is to be removed.
- @param key The key, should be a string value.
- @return The first matched value, or NULL if no matched value.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj,
-                                                        yyjson_mut_val *key);
-
-/**
- Removes all key-value pair from the object with given key.
- @param obj The object from which the key-value pair is to be removed.
- @param key The key, should be a UTF-8 string with null-terminator.
- @return The first matched value, or NULL if no matched value.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key(
-    yyjson_mut_val *obj, const char *key);
-
-/**
- Removes all key-value pair from the object with given key.
- @param obj The object from which the key-value pair is to be removed.
- @param key The key, should be a UTF-8 string, null-terminator is not required.
- @param key_len The length of the key.
- @return The first matched value, or NULL if no matched value.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn(
-    yyjson_mut_val *obj, const char *key, size_t key_len);
-
-/**
- Removes all key-value pairs in this object.
- @param obj The object from which all of the values are to be removed.
- @return Whether successful.
- */
-yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj);
-
-/**
- Replaces value from the object with given key.
- If the key is not exist, or the value is NULL, it will fail.
- @param obj The object to which the value is to be replaced.
- @param key The key, should be a string value.
- @param val The value to replace into the object.
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj,
-                                              yyjson_mut_val *key,
-                                              yyjson_mut_val *val);
-
-/**
- Rotates key-value pairs in the object for the given number of times.
- For example: `{"a":1,"b":2,"c":3,"d":4}` rotate 1 is
- `{"b":2,"c":3,"d":4,"a":1}`.
- @param obj The object to be rotated.
- @param idx Index (or times) to rotate.
- @return Whether successful.
- @warning This function takes a linear search time.
- */
-yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj,
-                                             size_t idx);
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification Convenience API
- *============================================================================*/
-
-/** Adds a `null` value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key);
-
-/** Adds a `true` value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key);
-
-/** Adds a `false` value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *obj,
-                                                const char *key);
-
-/** Adds a bool value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, bool val);
-
-/** Adds an unsigned integer value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, uint64_t val);
-
-/** Adds a signed integer value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, int64_t val);
-
-/** Adds an int value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *key, int64_t val);
-
-/** Adds a double value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key, double val);
-
-/** Adds a string value at the end of the object.
-    The `key` and `val` should be null-terminated UTF-8 strings.
-    This function allows duplicated key in one object.
-    
-    @warning The key/value strings are not copied, you should keep these strings
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *key, const char *val);
-
-/** Adds a string value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    The `val` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `val`, in bytes.
-    This function allows duplicated key in one object.
-    
-    @warning The key/value strings are not copied, you should keep these strings
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *key,
-                                               const char *val, size_t len);
-
-/** Adds a string value at the end of the object.
-    The `key` and `val` should be null-terminated UTF-8 strings.
-    The value string is copied.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *obj,
-                                                 const char *key,
-                                                 const char *val);
-
-/** Adds a string value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    The `val` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the `val`, in bytes.
-    This function allows duplicated key in one object.
-    
-    @warning The key strings are not copied, you should keep these strings
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *obj,
-                                                  const char *key,
-                                                  const char *val, size_t len);
-
-/**
- Creates and adds a new array to the target object.
- The `key` should be a null-terminated UTF-8 string.
- This function allows duplicated key in one object.
- 
- @warning The key string is not copied, you should keep these strings
-          unmodified for the lifetime of this JSON document.
- @return The new array, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_add_arr(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *obj,
-                                                         const char *key);
-
-/**
- Creates and adds a new object to the target object.
- The `key` should be a null-terminated UTF-8 string.
- This function allows duplicated key in one object.
- 
- @warning The key string is not copied, you should keep these strings
-          unmodified for the lifetime of this JSON document.
- @return The new object, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_add_obj(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *obj,
-                                                         const char *key);
-
-/** Adds a JSON value at the end of the object.
-    The `key` should be a null-terminated UTF-8 string.
-    This function allows duplicated key in one object.
-    
-    @warning The key string is not copied, you should keep the string
-        unmodified for the lifetime of this JSON document. */
-yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *key,
-                                              yyjson_mut_val *val);
-
-/** Removes all key-value pairs for the given key.
-    Returns the first value to which the specified key is mapped or NULL if this
-    object contains no mapping for the key.
-    The `key` should be a null-terminated UTF-8 string.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(
-    yyjson_mut_val *obj, const char *key);
-
-/** Removes all key-value pairs for the given key.
-    Returns the first value to which the specified key is mapped or NULL if this
-    object contains no mapping for the key.
-    The `key` should be a UTF-8 string, null-terminator is not required.
-    The `len` should be the length of the key, in bytes.
-    
-    @warning This function takes a linear search time. */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn(
-    yyjson_mut_val *obj, const char *key, size_t len);
-
-/** Replaces all matching keys with the new key.
-    Returns true if at least one key was renamed.
-    The `key` and `new_key` should be a null-terminated UTF-8 string.
-    The `new_key` is copied and held by doc.
-    
-    @warning This function takes a linear search time.
-    If `new_key` already exists, it will cause duplicate keys.
- */
-yyjson_api_inline bool yyjson_mut_obj_rename_key(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *obj,
-                                                 const char *key,
-                                                 const char *new_key);
-
-/** Replaces all matching keys with the new key.
-    Returns true if at least one key was renamed.
-    The `key` and `new_key` should be a UTF-8 string,
-    null-terminator is not required. The `new_key` is copied and held by doc.
-    
-    @warning This function takes a linear search time.
-    If `new_key` already exists, it will cause duplicate keys.
- */
-yyjson_api_inline bool yyjson_mut_obj_rename_keyn(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *obj,
-                                                  const char *key,
-                                                  size_t len,
-                                                  const char *new_key,
-                                                  size_t new_len);
-
-
-
-/*==============================================================================
- * JSON Pointer API (RFC 6901)
- * https://tools.ietf.org/html/rfc6901
- *============================================================================*/
-
-/** JSON Pointer error code. */
-typedef uint32_t yyjson_ptr_code;
-
-/** No JSON pointer error. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_NONE = 0;
-
-/** Invalid input parameter, such as NULL input. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_PARAMETER = 1;
-
-/** JSON pointer syntax error, such as invalid escape, token no prefix. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_SYNTAX = 2;
-
-/** JSON pointer resolve failed, such as index out of range, key not found. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_RESOLVE = 3;
-
-/** Document's root is NULL, but it is required for the function call. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_NULL_ROOT = 4;
-
-/** Cannot set root as the target is not a document. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_SET_ROOT = 5;
-
-/** The memory allocation failed and a new value could not be created. */
-static const yyjson_ptr_code YYJSON_PTR_ERR_MEMORY_ALLOCATION = 6;
-
-/** Error information for JSON pointer. */
-typedef struct yyjson_ptr_err {
-    /** Error code, see `yyjson_ptr_code` for all possible values. */
-    yyjson_ptr_code code;
-    /** Error message, constant, no need to free (NULL if no error). */
-    const char *msg;
-    /** Error byte position for input JSON pointer (0 if no error). */
-    size_t pos;
-} yyjson_ptr_err;
-
-/**
- A context for JSON pointer operation.
- 
- This struct stores the context of JSON Pointer operation result. The struct
- can be used with three helper functions: `ctx_append()`, `ctx_replace()`, and
- `ctx_remove()`, which perform the corresponding operations on the container
- without re-parsing the JSON Pointer.
- 
- For example:
- @code
-    // doc before: {"a":[0,1,null]}
-    // ptr: "/a/2"
-    val = yyjson_mut_doc_ptr_getx(doc, ptr, strlen(ptr), &ctx, &err);
-    if (yyjson_is_null(val)) {
-        yyjson_ptr_ctx_remove(&ctx);
-    }
-    // doc after: {"a":[0,1]}
- @endcode
- */
-typedef struct yyjson_ptr_ctx {
-    /**
-     The container (parent) of the target value. It can be either an array or
-     an object. If the target location has no value, but all its parent
-     containers exist, and the target location can be used to insert a new
-     value, then `ctn` is the parent container of the target location.
-     Otherwise, `ctn` is NULL.
-     */
-    yyjson_mut_val *ctn;
-    /**
-     The previous sibling of the target value. It can be either a value in an
-     array or a key in an object. As the container is a `circular linked list`
-     of elements, `pre` is the previous node of the target value. If the
-     operation is `add` or `set`, then `pre` is the previous node of the new
-     value, not the original target value. If the target value does not exist,
-     `pre` is NULL.
-     */
-    yyjson_mut_val *pre;
-    /**
-     The removed value if the operation is `set`, `replace` or `remove`. It can
-     be used to restore the original state of the document if needed.
-     */
-    yyjson_mut_val *old;
-} yyjson_ptr_ctx;
-
-/**
- Get value by a JSON Pointer.
- @param doc The JSON document to be queried.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @return The value referenced by the JSON pointer.
-    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_val *yyjson_doc_ptr_get(yyjson_doc *doc,
-                                                 const char *ptr);
-
-/**
- Get value by a JSON Pointer.
- @param doc The JSON document to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @return The value referenced by the JSON pointer.
-    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_val *yyjson_doc_ptr_getn(yyjson_doc *doc,
-                                                  const char *ptr, size_t len);
-
-/**
- Get value by a JSON Pointer.
- @param doc The JSON document to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The value referenced by the JSON pointer.
-    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_val *yyjson_doc_ptr_getx(yyjson_doc *doc,
-                                                  const char *ptr, size_t len,
-                                                  yyjson_ptr_err *err);
-
-/**
- Get value by a JSON Pointer.
- @param val The JSON value to be queried.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @return The value referenced by the JSON pointer.
-    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_val *yyjson_ptr_get(yyjson_val *val,
-                                             const char *ptr);
-
-/**
- Get value by a JSON Pointer.
- @param val The JSON value to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @return The value referenced by the JSON pointer.
-    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_val *yyjson_ptr_getn(yyjson_val *val,
-                                              const char *ptr, size_t len);
-
-/**
- Get value by a JSON Pointer.
- @param val The JSON value to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The value referenced by the JSON pointer.
-    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_val *yyjson_ptr_getx(yyjson_val *val,
-                                              const char *ptr, size_t len,
-                                              yyjson_ptr_err *err);
-
-/**
- Get value by a JSON Pointer.
- @param doc The JSON document to be queried.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @return The value referenced by the JSON pointer.
-    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_get(yyjson_mut_doc *doc,
-                                                         const char *ptr);
-
-/**
- Get value by a JSON Pointer.
- @param doc The JSON document to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @return The value referenced by the JSON pointer.
-    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getn(yyjson_mut_doc *doc,
-                                                          const char *ptr,
-                                                          size_t len);
-
-/**
- Get value by a JSON Pointer.
- @param doc The JSON document to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The value referenced by the JSON pointer.
-    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getx(yyjson_mut_doc *doc,
-                                                          const char *ptr,
-                                                          size_t len,
-                                                          yyjson_ptr_ctx *ctx,
-                                                          yyjson_ptr_err *err);
-
-/**
- Get value by a JSON Pointer.
- @param val The JSON value to be queried.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @return The value referenced by the JSON pointer.
-    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_get(yyjson_mut_val *val,
-                                                     const char *ptr);
-
-/**
- Get value by a JSON Pointer.
- @param val The JSON value to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @return The value referenced by the JSON pointer.
-    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getn(yyjson_mut_val *val,
-                                                      const char *ptr,
-                                                      size_t len);
-
-/**
- Get value by a JSON Pointer.
- @param val The JSON value to be queried.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The value referenced by the JSON pointer.
-    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getx(yyjson_mut_val *val,
-                                                      const char *ptr,
-                                                      size_t len,
-                                                      yyjson_ptr_ctx *ctx,
-                                                      yyjson_ptr_err *err);
-
-/**
- Add (insert) value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @param new_val The value to be added.
- @return true if JSON pointer is valid and new value is added, false otherwise.
- @note The parent nodes will be created if they do not exist.
- */
-yyjson_api_inline bool yyjson_mut_doc_ptr_add(yyjson_mut_doc *doc,
-                                              const char *ptr,
-                                              yyjson_mut_val *new_val);
-
-/**
- Add (insert) value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The value to be added.
- @return true if JSON pointer is valid and new value is added, false otherwise.
- @note The parent nodes will be created if they do not exist.
- */
-yyjson_api_inline bool yyjson_mut_doc_ptr_addn(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val);
-
-/**
- Add (insert) value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The value to be added.
- @param create_parent Whether to create parent nodes if not exist.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return true if JSON pointer is valid and new value is added, false otherwise.
- */
-yyjson_api_inline bool yyjson_mut_doc_ptr_addx(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val,
-                                               bool create_parent,
-                                               yyjson_ptr_ctx *ctx,
-                                               yyjson_ptr_err *err);
-
-/**
- Add (insert) value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @param doc Only used to create new values when needed.
- @param new_val The value to be added.
- @return true if JSON pointer is valid and new value is added, false otherwise.
- @note The parent nodes will be created if they do not exist.
- */
-yyjson_api_inline bool yyjson_mut_ptr_add(yyjson_mut_val *val,
-                                          const char *ptr,
-                                          yyjson_mut_val *new_val,
-                                          yyjson_mut_doc *doc);
-
-/**
- Add (insert) value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param doc Only used to create new values when needed.
- @param new_val The value to be added.
- @return true if JSON pointer is valid and new value is added, false otherwise.
- @note The parent nodes will be created if they do not exist.
- */
-yyjson_api_inline bool yyjson_mut_ptr_addn(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc);
-
-/**
- Add (insert) value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param doc Only used to create new values when needed.
- @param new_val The value to be added.
- @param create_parent Whether to create parent nodes if not exist.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return true if JSON pointer is valid and new value is added, false otherwise.
- */
-yyjson_api_inline bool yyjson_mut_ptr_addx(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc,
-                                           bool create_parent,
-                                           yyjson_ptr_ctx *ctx,
-                                           yyjson_ptr_err *err);
-
-/**
- Set value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @param new_val The value to be set, pass NULL to remove.
- @return true if JSON pointer is valid and new value is set, false otherwise.
- @note The parent nodes will be created if they do not exist.
-    If the target value already exists, it will be replaced by the new value.
- */
-yyjson_api_inline bool yyjson_mut_doc_ptr_set(yyjson_mut_doc *doc,
-                                              const char *ptr,
-                                              yyjson_mut_val *new_val);
-
-/**
- Set value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The value to be set, pass NULL to remove.
- @return true if JSON pointer is valid and new value is set, false otherwise.
- @note The parent nodes will be created if they do not exist.
-    If the target value already exists, it will be replaced by the new value.
- */
-yyjson_api_inline bool yyjson_mut_doc_ptr_setn(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val);
-
-/**
- Set value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The value to be set, pass NULL to remove.
- @param create_parent Whether to create parent nodes if not exist.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return true if JSON pointer is valid and new value is set, false otherwise.
- @note If the target value already exists, it will be replaced by the new value.
- */
-yyjson_api_inline bool yyjson_mut_doc_ptr_setx(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val,
-                                               bool create_parent,
-                                               yyjson_ptr_ctx *ctx,
-                                               yyjson_ptr_err *err);
-
-/**
- Set value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @param new_val The value to be set, pass NULL to remove.
- @param doc Only used to create new values when needed.
- @return true if JSON pointer is valid and new value is set, false otherwise.
- @note The parent nodes will be created if they do not exist.
-    If the target value already exists, it will be replaced by the new value.
- */
-yyjson_api_inline bool yyjson_mut_ptr_set(yyjson_mut_val *val,
-                                          const char *ptr,
-                                          yyjson_mut_val *new_val,
-                                          yyjson_mut_doc *doc);
-
-/**
- Set value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The value to be set, pass NULL to remove.
- @param doc Only used to create new values when needed.
- @return true if JSON pointer is valid and new value is set, false otherwise.
- @note The parent nodes will be created if they do not exist.
-    If the target value already exists, it will be replaced by the new value.
- */
-yyjson_api_inline bool yyjson_mut_ptr_setn(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc);
-
-/**
- Set value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The value to be set, pass NULL to remove.
- @param doc Only used to create new values when needed.
- @param create_parent Whether to create parent nodes if not exist.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return true if JSON pointer is valid and new value is set, false otherwise.
- @note If the target value already exists, it will be replaced by the new value.
- */
-yyjson_api_inline bool yyjson_mut_ptr_setx(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc,
-                                           bool create_parent,
-                                           yyjson_ptr_ctx *ctx,
-                                           yyjson_ptr_err *err);
-
-/**
- Replace value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @param new_val The new value to replace the old one.
- @return The old value that was replaced, or NULL if not found.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replace(
-    yyjson_mut_doc *doc, const char *ptr, yyjson_mut_val *new_val);
-
-/**
- Replace value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The new value to replace the old one.
- @return The old value that was replaced, or NULL if not found.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacen(
-    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val);
-
-/**
- Replace value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The new value to replace the old one.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The old value that was replaced, or NULL if not found.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacex(
-    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
-
-/**
- Replace value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @param new_val The new value to replace the old one.
- @return The old value that was replaced, or NULL if not found.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replace(
-    yyjson_mut_val *val, const char *ptr, yyjson_mut_val *new_val);
-
-/**
- Replace value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The new value to replace the old one.
- @return The old value that was replaced, or NULL if not found.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacen(
-    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val);
-
-/**
- Replace value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param new_val The new value to replace the old one.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The old value that was replaced, or NULL if not found.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacex(
-    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
-
-/**
- Remove value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @return The removed value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_remove(
-    yyjson_mut_doc *doc, const char *ptr);
-
-/**
- Remove value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @return The removed value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removen(
-    yyjson_mut_doc *doc, const char *ptr, size_t len);
-
-/**
- Remove value by a JSON pointer.
- @param doc The target JSON document.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The removed value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removex(
-    yyjson_mut_doc *doc, const char *ptr, size_t len,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
-
-/**
- Remove value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8 with null-terminator).
- @return The removed value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_remove(yyjson_mut_val *val,
-                                                        const char *ptr);
-
-/**
- Remove value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @return The removed value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removen(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         size_t len);
-
-/**
- Remove value by a JSON pointer.
- @param val The target JSON value.
- @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
- @param len The length of `ptr` in bytes.
- @param ctx A pointer to store the result context, or NULL if not needed.
- @param err A pointer to store the error information, or NULL if not needed.
- @return The removed value, or NULL on error.
- */
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removex(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         size_t len,
-                                                         yyjson_ptr_ctx *ctx,
-                                                         yyjson_ptr_err *err);
-
-/**
- Append value by JSON pointer context.
- @param ctx The context from the `yyjson_mut_ptr_xxx()` calls.
- @param key New key if `ctx->ctn` is object, or NULL if `ctx->ctn` is array.
- @param val New value to be added.
- @return true on success or false on fail.
- */
-yyjson_api_inline bool yyjson_ptr_ctx_append(yyjson_ptr_ctx *ctx,
-                                             yyjson_mut_val *key,
-                                             yyjson_mut_val *val);
-
-/**
- Replace value by JSON pointer context.
- @param ctx The context from the `yyjson_mut_ptr_xxx()` calls.
- @param val New value to be replaced.
- @return true on success or false on fail.
- @note If success, the old value will be returned via `ctx->old`.
- */
-yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx *ctx,
-                                              yyjson_mut_val *val);
-
-/**
- Remove value by JSON pointer context.
- @param ctx The context from the `yyjson_mut_ptr_xxx()` calls.
- @return true on success or false on fail.
- @note If success, the old value will be returned via `ctx->old`.
- */
-yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx *ctx);
-
-
-
-/*==============================================================================
- * JSON Patch API (RFC 6902)
- * https://tools.ietf.org/html/rfc6902
- *============================================================================*/
-
-/** Result code for JSON patch. */
-typedef uint32_t yyjson_patch_code;
-
-/** Success, no error. */
-static const yyjson_patch_code YYJSON_PATCH_SUCCESS = 0;
-
-/** Invalid parameter, such as NULL input or non-array patch. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_PARAMETER = 1;
-
-/** Memory allocation failure occurs. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_MEMORY_ALLOCATION = 2;
-
-/** JSON patch operation is not object type. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_OPERATION = 3;
-
-/** JSON patch operation is missing a required key. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_MISSING_KEY = 4;
-
-/** JSON patch operation member is invalid. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_MEMBER = 5;
-
-/** JSON patch operation `test` not equal. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_EQUAL = 6;
-
-/** JSON patch operation failed on JSON pointer. */
-static const yyjson_patch_code YYJSON_PATCH_ERROR_POINTER = 7;
-
-/** Error information for JSON patch. */
-typedef struct yyjson_patch_err {
-    /** Error code, see `yyjson_patch_code` for all possible values. */
-    yyjson_patch_code code;
-    /** Index of the error operation (0 if no error). */
-    size_t idx;
-    /** Error message, constant, no need to free (NULL if no error). */
-    const char *msg;
-    /** JSON pointer error if `code == YYJSON_PATCH_ERROR_POINTER`. */
-    yyjson_ptr_err ptr;
-} yyjson_patch_err;
-
-/**
- Creates and returns a patched JSON value (RFC 6902).
- The memory of the returned value is allocated by the `doc`.
- The `err` is used to receive error information, pass NULL if not needed.
- Returns NULL if the patch could not be applied.
- */
-yyjson_api yyjson_mut_val *yyjson_patch(yyjson_mut_doc *doc,
-                                        yyjson_val *orig,
-                                        yyjson_val *patch,
-                                        yyjson_patch_err *err);
-
-/**
- Creates and returns a patched JSON value (RFC 6902).
- The memory of the returned value is allocated by the `doc`.
- The `err` is used to receive error information, pass NULL if not needed.
- Returns NULL if the patch could not be applied.
- */
-yyjson_api yyjson_mut_val *yyjson_mut_patch(yyjson_mut_doc *doc,
-                                            yyjson_mut_val *orig,
-                                            yyjson_mut_val *patch,
-                                            yyjson_patch_err *err);
-
-
-
-/*==============================================================================
- * JSON Merge-Patch API (RFC 7386)
- * https://tools.ietf.org/html/rfc7386
- *============================================================================*/
-
-/**
- Creates and returns a merge-patched JSON value (RFC 7386).
- The memory of the returned value is allocated by the `doc`.
- Returns NULL if the patch could not be applied.
-
- @warning This function is recursive and may cause a stack overflow if the
-    object level is too deep.
- */
-yyjson_api yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc,
-                                              yyjson_val *orig,
-                                              yyjson_val *patch);
-
-/**
- Creates and returns a merge-patched JSON value (RFC 7386).
- The memory of the returned value is allocated by the `doc`.
- Returns NULL if the patch could not be applied.
-
- @warning This function is recursive and may cause a stack overflow if the
-    object level is too deep.
- */
-yyjson_api yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *orig,
-                                                  yyjson_mut_val *patch);
-
-
-
-/*==============================================================================
- * JSON Structure (Implementation)
- *============================================================================*/
-
-/** Payload of a JSON value (8 bytes). */
-typedef union yyjson_val_uni {
-    uint64_t    u64;
-    int64_t     i64;
-    double      f64;
-    const char *str;
-    void       *ptr;
-    size_t      ofs;
-} yyjson_val_uni;
-
-/**
- Immutable JSON value, 16 bytes.
- */
-struct yyjson_val {
-    uint64_t tag; /**< type, subtype and length */
-    yyjson_val_uni uni; /**< payload */
-};
-
-struct yyjson_doc {
-    /** Root value of the document (nonnull). */
-    yyjson_val *root;
-    /** Allocator used by document (nonnull). */
-    yyjson_alc alc;
-    /** The total number of bytes read when parsing JSON (nonzero). */
-    size_t dat_read;
-    /** The total number of value read when parsing JSON (nonzero). */
-    size_t val_read;
-    /** The string pool used by JSON values (nullable). */
-    char *str_pool;
-};
-
-
-
-/*==============================================================================
- * Unsafe JSON Value API (Implementation)
- *============================================================================*/
-
-/*
- Whether the string does not need to be escaped for serialization.
- This function is used to optimize the writing speed of small constant strings.
- This function works only if the compiler can evaluate it at compile time.
- 
- Clang supports it since v8.0,
-    earlier versions do not support constant_p(strlen) and return false.
- GCC supports it since at least v4.4,
-    earlier versions may compile it as run-time instructions.
- ICC supports it since at least v16,
-    earlier versions are uncertain.
- 
- @param str The C string.
- @param len The returnd value from strlen(str).
- */
-yyjson_api_inline bool unsafe_yyjson_is_str_noesc(const char *str, size_t len) {
-#if YYJSON_HAS_CONSTANT_P && \
-    (!YYJSON_IS_REAL_GCC || yyjson_gcc_available(4, 4, 0))
-    if (yyjson_constant_p(len) && len <= 32) {
-        /*
-         Same as the following loop:
-         
-         for (size_t i = 0; i < len; i++) {
-             char c = str[i];
-             if (c < ' ' || c > '~' || c == '"' || c == '\\') return false;
-         }
-         
-         GCC evaluates it at compile time only if the string length is within 17
-         and -O3 (which turns on the -fpeel-loops flag) is used.
-         So the loop is unrolled for GCC.
-         */
-#       define yyjson_repeat32_incr(x) \
-            x(0)  x(1)  x(2)  x(3)  x(4)  x(5)  x(6)  x(7)  \
-            x(8)  x(9)  x(10) x(11) x(12) x(13) x(14) x(15) \
-            x(16) x(17) x(18) x(19) x(20) x(21) x(22) x(23) \
-            x(24) x(25) x(26) x(27) x(28) x(29) x(30) x(31)
-#       define yyjson_check_char_noesc(i) \
-            if (i < len) { \
-                char c = str[i]; \
-                if (c < ' ' || c > '~' || c == '"' || c == '\\') return false; }
-        yyjson_repeat32_incr(yyjson_check_char_noesc)
-#       undef yyjson_repeat32_incr
-#       undef yyjson_check_char_noesc
-        return true;
-    }
-#else
-    (void)str;
-    (void)len;
-#endif
-    return false;
-}
-
-yyjson_api_inline yyjson_type unsafe_yyjson_get_type(void *val) {
-    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
-    return (yyjson_type)(tag & YYJSON_TYPE_MASK);
-}
-
-yyjson_api_inline yyjson_subtype unsafe_yyjson_get_subtype(void *val) {
-    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
-    return (yyjson_subtype)(tag & YYJSON_SUBTYPE_MASK);
-}
-
-yyjson_api_inline uint8_t unsafe_yyjson_get_tag(void *val) {
-    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
-    return (uint8_t)(tag & YYJSON_TAG_MASK);
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_raw(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_RAW;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_null(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NULL;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_bool(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_BOOL;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_num(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NUM;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_str(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_STR;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_arr(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_ARR;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_obj(void *val) {
-    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_OBJ;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_ctn(void *val) {
-    uint8_t mask = YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ;
-    return (unsafe_yyjson_get_tag(val) & mask) == mask;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_uint(void *val) {
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_sint(void *val) {
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_int(void *val) {
-    const uint8_t mask = YYJSON_TAG_MASK & (~YYJSON_SUBTYPE_SINT);
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-    return (unsafe_yyjson_get_tag(val) & mask) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_real(void *val) {
-    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_true(void *val) {
-    const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_is_false(void *val) {
-    const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-    return unsafe_yyjson_get_tag(val) == patt;
-}
-
-yyjson_api_inline bool unsafe_yyjson_arr_is_flat(yyjson_val *val) {
-    size_t ofs = val->uni.ofs;
-    size_t len = (size_t)(val->tag >> YYJSON_TAG_BIT);
-    return len * sizeof(yyjson_val) + sizeof(yyjson_val) == ofs;
-}
-
-yyjson_api_inline const char *unsafe_yyjson_get_raw(void *val) {
-    return ((yyjson_val *)val)->uni.str;
-}
-
-yyjson_api_inline bool unsafe_yyjson_get_bool(void *val) {
-    uint8_t tag = unsafe_yyjson_get_tag(val);
-    return (bool)((tag & YYJSON_SUBTYPE_MASK) >> YYJSON_TYPE_BIT);
-}
-
-yyjson_api_inline uint64_t unsafe_yyjson_get_uint(void *val) {
-    return ((yyjson_val *)val)->uni.u64;
-}
-
-yyjson_api_inline int64_t unsafe_yyjson_get_sint(void *val) {
-    return ((yyjson_val *)val)->uni.i64;
-}
-
-yyjson_api_inline int unsafe_yyjson_get_int(void *val) {
-    return (int)((yyjson_val *)val)->uni.i64;
-}
-
-yyjson_api_inline double unsafe_yyjson_get_real(void *val) {
-    return ((yyjson_val *)val)->uni.f64;
-}
-
-yyjson_api_inline double unsafe_yyjson_get_num(void *val) {
-    uint8_t tag = unsafe_yyjson_get_tag(val);
-    if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL)) {
-        return ((yyjson_val *)val)->uni.f64;
-    } else if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT)) {
-        return (double)((yyjson_val *)val)->uni.i64;
-    } else if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT)) {
-#if YYJSON_U64_TO_F64_NO_IMPL
-        uint64_t msb = ((uint64_t)1) << 63;
-        uint64_t num = ((yyjson_val *)val)->uni.u64;
-        if ((num & msb) == 0) {
-            return (double)(int64_t)num;
-        } else {
-            return ((double)(int64_t)((num >> 1) | (num & 1))) * (double)2.0;
-        }
-#else
-        return (double)((yyjson_val *)val)->uni.u64;
-#endif
-    }
-    return 0.0;
-}
-
-yyjson_api_inline const char *unsafe_yyjson_get_str(void *val) {
-    return ((yyjson_val *)val)->uni.str;
-}
-
-yyjson_api_inline size_t unsafe_yyjson_get_len(void *val) {
-    return (size_t)(((yyjson_val *)val)->tag >> YYJSON_TAG_BIT);
-}
-
-yyjson_api_inline yyjson_val *unsafe_yyjson_get_first(yyjson_val *ctn) {
-    return ctn + 1;
-}
-
-yyjson_api_inline yyjson_val *unsafe_yyjson_get_next(yyjson_val *val) {
-    bool is_ctn = unsafe_yyjson_is_ctn(val);
-    size_t ctn_ofs = val->uni.ofs;
-    size_t ofs = (is_ctn ? ctn_ofs : sizeof(yyjson_val));
-    return (yyjson_val *)(void *)((uint8_t *)val + ofs);
-}
-
-yyjson_api_inline bool unsafe_yyjson_equals_strn(void *val, const char *str,
-                                                 size_t len) {
-    return unsafe_yyjson_get_len(val) == len &&
-           memcmp(((yyjson_val *)val)->uni.str, str, len) == 0;
-}
-
-yyjson_api_inline bool unsafe_yyjson_equals_str(void *val, const char *str) {
-    return unsafe_yyjson_equals_strn(val, str, strlen(str));
-}
-
-yyjson_api_inline void unsafe_yyjson_set_type(void *val, yyjson_type type,
-                                              yyjson_subtype subtype) {
-    uint8_t tag = (type | subtype);
-    uint64_t new_tag = ((yyjson_val *)val)->tag;
-    new_tag = (new_tag & (~(uint64_t)YYJSON_TAG_MASK)) | (uint64_t)tag;
-    ((yyjson_val *)val)->tag = new_tag;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_len(void *val, size_t len) {
-    uint64_t tag = ((yyjson_val *)val)->tag & YYJSON_TAG_MASK;
-    tag |= (uint64_t)len << YYJSON_TAG_BIT;
-    ((yyjson_val *)val)->tag = tag;
-}
-
-yyjson_api_inline void unsafe_yyjson_inc_len(void *val) {
-    uint64_t tag = ((yyjson_val *)val)->tag;
-    tag += (uint64_t)(1 << YYJSON_TAG_BIT);
-    ((yyjson_val *)val)->tag = tag;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_raw(void *val, const char *raw,
-                                             size_t len) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_RAW, YYJSON_SUBTYPE_NONE);
-    unsafe_yyjson_set_len(val, len);
-    ((yyjson_val *)val)->uni.str = raw;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_null(void *val) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_NULL, YYJSON_SUBTYPE_NONE);
-    unsafe_yyjson_set_len(val, 0);
-}
-
-yyjson_api_inline void unsafe_yyjson_set_bool(void *val, bool num) {
-    yyjson_subtype subtype = num ? YYJSON_SUBTYPE_TRUE : YYJSON_SUBTYPE_FALSE;
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_BOOL, subtype);
-    unsafe_yyjson_set_len(val, 0);
-}
-
-yyjson_api_inline void unsafe_yyjson_set_uint(void *val, uint64_t num) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_UINT);
-    unsafe_yyjson_set_len(val, 0);
-    ((yyjson_val *)val)->uni.u64 = num;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_sint(void *val, int64_t num) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_SINT);
-    unsafe_yyjson_set_len(val, 0);
-    ((yyjson_val *)val)->uni.i64 = num;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_real(void *val, double num) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_REAL);
-    unsafe_yyjson_set_len(val, 0);
-    ((yyjson_val *)val)->uni.f64 = num;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_str(void *val, const char *str) {
-    size_t len = strlen(str);
-    bool noesc = unsafe_yyjson_is_str_noesc(str, len);
-    yyjson_subtype sub = noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE;
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, sub);
-    unsafe_yyjson_set_len(val, len);
-    ((yyjson_val *)val)->uni.str = str;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_strn(void *val, const char *str,
-                                              size_t len) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, YYJSON_SUBTYPE_NONE);
-    unsafe_yyjson_set_len(val, len);
-    ((yyjson_val *)val)->uni.str = str;
-}
-
-yyjson_api_inline void unsafe_yyjson_set_arr(void *val, size_t size) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_ARR, YYJSON_SUBTYPE_NONE);
-    unsafe_yyjson_set_len(val, size);
-}
-
-yyjson_api_inline void unsafe_yyjson_set_obj(void *val, size_t size) {
-    unsafe_yyjson_set_type(val, YYJSON_TYPE_OBJ, YYJSON_SUBTYPE_NONE);
-    unsafe_yyjson_set_len(val, size);
-}
-
-
-
-/*==============================================================================
- * JSON Document API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc) {
-    return doc ? doc->root : NULL;
-}
-
-yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc) {
-    return doc ? doc->dat_read : 0;
-}
-
-yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc) {
-    return doc ? doc->val_read : 0;
-}
-
-yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc) {
-    if (doc) {
-        yyjson_alc alc = doc->alc;
-        memset(&doc->alc, 0, sizeof(alc));
-        if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
-        alc.free(alc.ctx, doc);
-    }
-}
-
-
-
-/*==============================================================================
- * JSON Value Type API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_is_raw(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_raw(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_null(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_null(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_true(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_true(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_false(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_false(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_bool(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_bool(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_uint(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_uint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_sint(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_sint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_int(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_int(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_real(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_real(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_num(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_num(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_str(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_str(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_arr(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_arr(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_obj(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_obj(val) : false;
-}
-
-yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val) {
-    return val ? unsafe_yyjson_is_ctn(val) : false;
-}
-
-
-
-/*==============================================================================
- * JSON Value Content API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_type(val) : YYJSON_TYPE_NONE;
-}
-
-yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_subtype(val) : YYJSON_SUBTYPE_NONE;
-}
-
-yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_tag(val) : 0;
-}
-
-yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val) {
-    switch (yyjson_get_tag(val)) {
-        case YYJSON_TYPE_RAW  | YYJSON_SUBTYPE_NONE:  return "raw";
-        case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:  return "null";
-        case YYJSON_TYPE_STR  | YYJSON_SUBTYPE_NONE:  return "string";
-        case YYJSON_TYPE_STR  | YYJSON_SUBTYPE_NOESC: return "string";
-        case YYJSON_TYPE_ARR  | YYJSON_SUBTYPE_NONE:  return "array";
-        case YYJSON_TYPE_OBJ  | YYJSON_SUBTYPE_NONE:  return "object";
-        case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE:  return "true";
-        case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE: return "false";
-        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_UINT:  return "uint";
-        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_SINT:  return "sint";
-        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_REAL:  return "real";
-        default:                                      return "unknown";
-    }
-}
-
-yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val) {
-    return yyjson_is_raw(val) ? unsafe_yyjson_get_raw(val) : NULL;
-}
-
-yyjson_api_inline bool yyjson_get_bool(yyjson_val *val) {
-    return yyjson_is_bool(val) ? unsafe_yyjson_get_bool(val) : false;
-}
-
-yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val) {
-    return yyjson_is_int(val) ? unsafe_yyjson_get_uint(val) : 0;
-}
-
-yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val) {
-    return yyjson_is_int(val) ? unsafe_yyjson_get_sint(val) : 0;
-}
-
-yyjson_api_inline int yyjson_get_int(yyjson_val *val) {
-    return yyjson_is_int(val) ? unsafe_yyjson_get_int(val) : 0;
-}
-
-yyjson_api_inline double yyjson_get_real(yyjson_val *val) {
-    return yyjson_is_real(val) ? unsafe_yyjson_get_real(val) : 0.0;
-}
-
-yyjson_api_inline double yyjson_get_num(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_num(val) : 0.0;
-}
-
-yyjson_api_inline const char *yyjson_get_str(yyjson_val *val) {
-    return yyjson_is_str(val) ? unsafe_yyjson_get_str(val) : NULL;
-}
-
-yyjson_api_inline size_t yyjson_get_len(yyjson_val *val) {
-    return val ? unsafe_yyjson_get_len(val) : 0;
-}
-
-yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str) {
-    if (yyjson_likely(val && str)) {
-        return unsafe_yyjson_is_str(val) &&
-               unsafe_yyjson_equals_str(val, str);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str,
-                                          size_t len) {
-    if (yyjson_likely(val && str)) {
-        return unsafe_yyjson_is_str(val) &&
-               unsafe_yyjson_equals_strn(val, str, len);
-    }
-    return false;
-}
-
-yyjson_api bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs);
-
-yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) {
-    if (yyjson_unlikely(!lhs || !rhs)) return false;
-    return unsafe_yyjson_equals(lhs, rhs);
-}
-
-yyjson_api_inline bool yyjson_set_raw(yyjson_val *val,
-                                      const char *raw, size_t len) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_raw(val, raw, len);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_null(yyjson_val *val) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_null(val);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_bool(yyjson_val *val, bool num) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_bool(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_uint(yyjson_val *val, uint64_t num) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_uint(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_sint(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_sint(val, (int64_t)num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_real(yyjson_val *val, double num) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_real(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_str(yyjson_val *val, const char *str) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    if (yyjson_unlikely(!str)) return false;
-    unsafe_yyjson_set_str(val, str);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_set_strn(yyjson_val *val,
-                                       const char *str, size_t len) {
-    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    if (yyjson_unlikely(!str)) return false;
-    unsafe_yyjson_set_strn(val, str, len);
-    return true;
-}
-
-
-
-/*==============================================================================
- * JSON Array API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr) {
-    return yyjson_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx) {
-    if (yyjson_likely(yyjson_is_arr(arr))) {
-        if (yyjson_likely(unsafe_yyjson_get_len(arr) > idx)) {
-            yyjson_val *val = unsafe_yyjson_get_first(arr);
-            if (unsafe_yyjson_arr_is_flat(arr)) {
-                return val + idx;
-            } else {
-                while (idx-- > 0) val = unsafe_yyjson_get_next(val);
-                return val;
-            }
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr) {
-    if (yyjson_likely(yyjson_is_arr(arr))) {
-        if (yyjson_likely(unsafe_yyjson_get_len(arr) > 0)) {
-            return unsafe_yyjson_get_first(arr);
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr) {
-    if (yyjson_likely(yyjson_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(len > 0)) {
-            yyjson_val *val = unsafe_yyjson_get_first(arr);
-            if (unsafe_yyjson_arr_is_flat(arr)) {
-                return val + (len - 1);
-            } else {
-                while (len-- > 1) val = unsafe_yyjson_get_next(val);
-                return val;
-            }
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Array Iterator API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr,
-                                            yyjson_arr_iter *iter) {
-    if (yyjson_likely(yyjson_is_arr(arr) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(arr);
-        iter->cur = unsafe_yyjson_get_first(arr);
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_arr_iter));
-    return false;
-}
-
-yyjson_api_inline yyjson_arr_iter yyjson_arr_iter_with(yyjson_val *arr) {
-    yyjson_arr_iter iter;
-    yyjson_arr_iter_init(arr, &iter);
-    return iter;
-}
-
-yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter) {
-    yyjson_val *val;
-    if (iter && iter->idx < iter->max) {
-        val = iter->cur;
-        iter->cur = unsafe_yyjson_get_next(val);
-        iter->idx++;
-        return val;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Object API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj) {
-    return yyjson_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj,
-                                             const char *key) {
-    return yyjson_obj_getn(obj, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj,
-                                              const char *_key,
-                                              size_t key_len) {
-    if (yyjson_likely(yyjson_is_obj(obj) && _key)) {
-        size_t len = unsafe_yyjson_get_len(obj);
-        yyjson_val *key = unsafe_yyjson_get_first(obj);
-        while (len-- > 0) {
-            if (unsafe_yyjson_equals_strn(key, _key, key_len)) return key + 1;
-            key = unsafe_yyjson_get_next(key + 1);
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Object Iterator API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj,
-                                            yyjson_obj_iter *iter) {
-    if (yyjson_likely(yyjson_is_obj(obj) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(obj);
-        iter->cur = unsafe_yyjson_get_first(obj);
-        iter->obj = obj;
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_obj_iter));
-    return false;
-}
-
-yyjson_api_inline yyjson_obj_iter yyjson_obj_iter_with(yyjson_val *obj) {
-    yyjson_obj_iter iter;
-    yyjson_obj_iter_init(obj, &iter);
-    return iter;
-}
-
-yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter) {
-    if (iter && iter->idx < iter->max) {
-        yyjson_val *key = iter->cur;
-        iter->idx++;
-        iter->cur = unsafe_yyjson_get_next(key + 1);
-        return key;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key) {
-    return key ? key + 1 : NULL;
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter,
-                                                  const char *key) {
-    return yyjson_obj_iter_getn(iter, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter,
-                                                   const char *key,
-                                                   size_t key_len) {
-    if (iter && key) {
-        size_t idx = iter->idx;
-        size_t max = iter->max;
-        yyjson_val *cur = iter->cur;
-        if (yyjson_unlikely(idx == max)) {
-            idx = 0;
-            cur = unsafe_yyjson_get_first(iter->obj);
-        }
-        while (idx++ < max) {
-            yyjson_val *next = unsafe_yyjson_get_next(cur + 1);
-            if (unsafe_yyjson_equals_strn(cur, key, key_len)) {
-                iter->idx = idx;
-                iter->cur = next;
-                return cur + 1;
-            }
-            cur = next;
-            if (idx == iter->max && iter->idx < iter->max) {
-                idx = 0;
-                max = iter->idx;
-                cur = unsafe_yyjson_get_first(iter->obj);
-            }
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Structure (Implementation)
- *============================================================================*/
-
-/**
- Mutable JSON value, 24 bytes.
- The 'tag' and 'uni' field is same as immutable value.
- The 'next' field links all elements inside the container to be a cycle.
- */
-struct yyjson_mut_val {
-    uint64_t tag; /**< type, subtype and length */
-    yyjson_val_uni uni; /**< payload */
-    yyjson_mut_val *next; /**< the next value in circular linked list */
-};
-
-/**
- A memory chunk in string memory pool.
- */
-typedef struct yyjson_str_chunk {
-    struct yyjson_str_chunk *next; /* next chunk linked list */
-    size_t chunk_size; /* chunk size in bytes */
-    /* char str[]; flexible array member */
-} yyjson_str_chunk;
-
-/**
- A memory pool to hold all strings in a mutable document.
- */
-typedef struct yyjson_str_pool {
-    char *cur; /* cursor inside current chunk */
-    char *end; /* the end of current chunk */
-    size_t chunk_size; /* chunk size in bytes while creating new chunk */
-    size_t chunk_size_max; /* maximum chunk size in bytes */
-    yyjson_str_chunk *chunks; /* a linked list of chunks, nullable */
-} yyjson_str_pool;
-
-/**
- A memory chunk in value memory pool.
- `sizeof(yyjson_val_chunk)` should not larger than `sizeof(yyjson_mut_val)`.
- */
-typedef struct yyjson_val_chunk {
-    struct yyjson_val_chunk *next; /* next chunk linked list */
-    size_t chunk_size; /* chunk size in bytes */
-    /* char pad[sizeof(yyjson_mut_val) - sizeof(yyjson_val_chunk)]; padding */
-    /* yyjson_mut_val vals[]; flexible array member */
-} yyjson_val_chunk;
-
-/**
- A memory pool to hold all values in a mutable document.
- */
-typedef struct yyjson_val_pool {
-    yyjson_mut_val *cur; /* cursor inside current chunk */
-    yyjson_mut_val *end; /* the end of current chunk */
-    size_t chunk_size; /* chunk size in bytes while creating new chunk */
-    size_t chunk_size_max; /* maximum chunk size in bytes */
-    yyjson_val_chunk *chunks; /* a linked list of chunks, nullable */
-} yyjson_val_pool;
-
-struct yyjson_mut_doc {
-    yyjson_mut_val *root; /**< root value of the JSON document, nullable */
-    yyjson_alc alc; /**< a valid allocator, nonnull */
-    yyjson_str_pool str_pool; /**< string memory pool */
-    yyjson_val_pool val_pool; /**< value memory pool */
-};
-
-/* Ensures the capacity to at least equal to the specified byte length. */
-yyjson_api bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool,
-                                            const yyjson_alc *alc,
-                                            size_t len);
-
-/* Ensures the capacity to at least equal to the specified value count. */
-yyjson_api bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool,
-                                            const yyjson_alc *alc,
-                                            size_t count);
-
-/* Allocate memory for string. */
-yyjson_api_inline char *unsafe_yyjson_mut_str_alc(yyjson_mut_doc *doc,
-                                                  size_t len) {
-    char *mem;
-    const yyjson_alc *alc = &doc->alc;
-    yyjson_str_pool *pool = &doc->str_pool;
-    if (yyjson_unlikely((size_t)(pool->end - pool->cur) <= len)) {
-        if (yyjson_unlikely(!unsafe_yyjson_str_pool_grow(pool, alc, len + 1))) {
-            return NULL;
-        }
-    }
-    mem = pool->cur;
-    pool->cur = mem + len + 1;
-    return mem;
-}
-
-yyjson_api_inline char *unsafe_yyjson_mut_strncpy(yyjson_mut_doc *doc,
-                                                  const char *str, size_t len) {
-    char *mem = unsafe_yyjson_mut_str_alc(doc, len);
-    if (yyjson_unlikely(!mem)) return NULL;
-    memcpy((void *)mem, (const void *)str, len);
-    mem[len] = '\0';
-    return mem;
-}
-
-yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_val(yyjson_mut_doc *doc,
-                                                        size_t count) {
-    yyjson_mut_val *val;
-    yyjson_alc *alc = &doc->alc;
-    yyjson_val_pool *pool = &doc->val_pool;
-    if (yyjson_unlikely((size_t)(pool->end - pool->cur) < count)) {
-        if (yyjson_unlikely(!unsafe_yyjson_val_pool_grow(pool, alc, count))) {
-            return NULL;
-        }
-    }
-    val = pool->cur;
-    pool->cur += count;
-    return val;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Document API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc) {
-    return doc ? doc->root : NULL;
-}
-
-yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *root) {
-    if (doc) doc->root = root;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Value Type API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_raw(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_null(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_true(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_false(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_bool(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_uint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_sint(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_int(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_real(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_num(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_str(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_arr(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_obj(val) : false;
-}
-
-yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val) {
-    return val ? unsafe_yyjson_is_ctn(val) : false;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Value Content API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val) {
-    return yyjson_get_type((yyjson_val *)val);
-}
-
-yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val) {
-    return yyjson_get_subtype((yyjson_val *)val);
-}
-
-yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val) {
-    return yyjson_get_tag((yyjson_val *)val);
-}
-
-yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val) {
-    return yyjson_get_type_desc((yyjson_val *)val);
-}
-
-yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val) {
-    return yyjson_get_raw((yyjson_val *)val);
-}
-
-yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val) {
-    return yyjson_get_bool((yyjson_val *)val);
-}
-
-yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val) {
-    return yyjson_get_uint((yyjson_val *)val);
-}
-
-yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val) {
-    return yyjson_get_sint((yyjson_val *)val);
-}
-
-yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val) {
-    return yyjson_get_int((yyjson_val *)val);
-}
-
-yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val) {
-    return yyjson_get_real((yyjson_val *)val);
-}
-
-yyjson_api_inline double yyjson_mut_get_num(yyjson_mut_val *val) {
-    return yyjson_get_num((yyjson_val *)val);
-}
-
-yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val) {
-    return yyjson_get_str((yyjson_val *)val);
-}
-
-yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val) {
-    return yyjson_get_len((yyjson_val *)val);
-}
-
-yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val,
-                                             const char *str) {
-    return yyjson_equals_str((yyjson_val *)val, str);
-}
-
-yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val,
-                                              const char *str, size_t len) {
-    return yyjson_equals_strn((yyjson_val *)val, str, len);
-}
-
-yyjson_api bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs,
-                                         yyjson_mut_val *rhs);
-
-yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs,
-                                         yyjson_mut_val *rhs) {
-    if (yyjson_unlikely(!lhs || !rhs)) return false;
-    return unsafe_yyjson_mut_equals(lhs, rhs);
-}
-
-yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val *val,
-                                          const char *raw, size_t len) {
-    if (yyjson_unlikely(!val || !raw)) return false;
-    unsafe_yyjson_set_raw(val, raw, len);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val *val) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_null(val);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val *val, bool num) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_bool(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val *val, uint64_t num) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_uint(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_sint(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_sint(val, (int64_t)num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val *val, double num) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_real(val, num);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val *val,
-                                          const char *str) {
-    if (yyjson_unlikely(!val || !str)) return false;
-    unsafe_yyjson_set_str(val, str);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val *val,
-                                           const char *str, size_t len) {
-    if (yyjson_unlikely(!val || !str)) return false;
-    unsafe_yyjson_set_strn(val, str, len);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val *val) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_arr(val, 0);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val *val) {
-    if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_obj(val, 0);
-    return true;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Value Creation API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc,
-                                                 const char *str) {
-    if (yyjson_likely(str)) return yyjson_mut_rawn(doc, str, strlen(str));
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc,
-                                                    const char *str) {
-    if (yyjson_likely(str)) return yyjson_mut_rawncpy(doc, str, strlen(str));
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_likely(val && new_str)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = new_str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
-                                                  bool _val) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            _val = !!_val;
-            val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc,
-                                                  uint64_t num) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-            val->uni.u64 = num;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc,
-                                                  int64_t num) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-            val->uni.i64 = num;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc,
-                                                 int64_t num) {
-    return yyjson_mut_sint(doc, num);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc,
-                                                  double num) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-            val->uni.f64 = num;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc,
-                                                 const char *str) {
-    if (yyjson_likely(doc && str)) {
-        size_t len = strlen(str);
-        bool noesc = unsafe_yyjson_is_str_noesc(str, len);
-        yyjson_subtype sub = noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE;
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) |
-                        (uint64_t)(YYJSON_TYPE_STR | sub);
-            val->uni.str = str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc,
-                                                  const char *str,
-                                                  size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            val->uni.str = str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc,
-                                                    const char *str) {
-    if (yyjson_likely(doc && str)) {
-        size_t len = strlen(str);
-        bool noesc = unsafe_yyjson_is_str_noesc(str, len);
-        yyjson_subtype sub = noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE;
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_likely(val && new_str)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) |
-                        (uint64_t)(YYJSON_TYPE_STR | sub);
-            val->uni.str = new_str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc,
-                                                     const char *str,
-                                                     size_t len) {
-    if (yyjson_likely(doc && str)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_likely(val && new_str)) {
-            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            val->uni.str = new_str;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr) {
-    return yyjson_mut_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr,
-                                                     size_t idx) {
-    if (yyjson_likely(idx < yyjson_mut_arr_size(arr))) {
-        yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr;
-        while (idx-- > 0) val = val->next;
-        return val->next;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
-        return ((yyjson_mut_val *)arr->uni.ptr)->next;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
-        return ((yyjson_mut_val *)arr->uni.ptr);
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array Iterator API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr,
-                                                yyjson_mut_arr_iter *iter) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(arr);
-        iter->cur = iter->max ? (yyjson_mut_val *)arr->uni.ptr : NULL;
-        iter->pre = NULL;
-        iter->arr = arr;
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_mut_arr_iter));
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with(
-    yyjson_mut_val *arr) {
-    yyjson_mut_arr_iter iter;
-    yyjson_mut_arr_iter_init(arr, &iter);
-    return iter;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next(
-    yyjson_mut_arr_iter *iter) {
-    if (iter && iter->idx < iter->max) {
-        yyjson_mut_val *val = iter->cur;
-        iter->pre = val;
-        iter->cur = val->next;
-        iter->idx++;
-        return iter->cur;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove(
-    yyjson_mut_arr_iter *iter) {
-    if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
-        yyjson_mut_val *prev = iter->pre;
-        yyjson_mut_val *cur = iter->cur;
-        yyjson_mut_val *next = cur->next;
-        if (yyjson_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev;
-        iter->idx--;
-        iter->max--;
-        unsafe_yyjson_set_len(iter->arr, iter->max);
-        prev->next = next;
-        iter->cur = next;
-        return cur;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array Creation API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-#define yyjson_mut_arr_with_func(func) \
-    if (yyjson_likely(doc && ((0 < count && count < \
-        (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || count == 0))) { \
-        yyjson_mut_val *arr = unsafe_yyjson_mut_val(doc, 1 + count); \
-        if (yyjson_likely(arr)) { \
-            arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; \
-            if (count > 0) { \
-                size_t i; \
-                for (i = 0; i < count; i++) { \
-                    yyjson_mut_val *val = arr + i + 1; \
-                    func \
-                    val->next = val + 1; \
-                } \
-                arr[count].next = arr + 1; \
-                arr->uni.ptr = arr + count; \
-            } \
-            return arr; \
-        } \
-    } \
-    return NULL
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
-    yyjson_mut_doc *doc, const bool *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        bool _val = !!vals[i];
-        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count) {
-    return yyjson_mut_arr_with_sint64(doc, vals, count);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count) {
-    return yyjson_mut_arr_with_uint64(doc, vals, count);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real(
-    yyjson_mut_doc *doc, const double *vals, size_t count) {
-    return yyjson_mut_arr_with_double(doc, vals, count);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8(
-    yyjson_mut_doc *doc, const int8_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = (int64_t)vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16(
-    yyjson_mut_doc *doc, const int16_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32(
-    yyjson_mut_doc *doc, const int32_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64(
-    yyjson_mut_doc *doc, const int64_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8(
-    yyjson_mut_doc *doc, const uint8_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16(
-    yyjson_mut_doc *doc, const uint16_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32(
-    yyjson_mut_doc *doc, const uint32_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64(
-    yyjson_mut_doc *doc, const uint64_t *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float(
-    yyjson_mut_doc *doc, const float *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-        val->uni.f64 = (double)vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double(
-    yyjson_mut_doc *doc, const double *vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-        val->uni.f64 = vals[i];
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str(
-    yyjson_mut_doc *doc, const char **vals, size_t count) {
-    yyjson_mut_arr_with_func({
-        uint64_t len = (uint64_t)strlen(vals[i]);
-        val->tag = (len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = vals[i];
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
-    if (yyjson_unlikely(count > 0 && !lens)) return NULL;
-    yyjson_mut_arr_with_func({
-        val->tag = ((uint64_t)lens[i] << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = vals[i];
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy(
-    yyjson_mut_doc *doc, const char **vals, size_t count) {
-    size_t len;
-    const char *str;
-    yyjson_mut_arr_with_func({
-        str = vals[i];
-        if (!str) return NULL;
-        len = strlen(str);
-        val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy(
-    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
-    size_t len;
-    const char *str;
-    if (yyjson_unlikely(count > 0 && !lens)) return NULL;
-    yyjson_mut_arr_with_func({
-        str = vals[i];
-        len = lens[i];
-        val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
-        if (yyjson_unlikely(!val->uni.str)) return NULL;
-    });
-}
-
-#undef yyjson_mut_arr_with_func
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val, size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(idx <= len)) {
-            unsafe_yyjson_set_len(arr, len + 1);
-            if (len == 0) {
-                val->next = val;
-                arr->uni.ptr = val;
-            } else {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                yyjson_mut_val *next = prev->next;
-                if (idx == len) {
-                    prev->next = val;
-                    val->next = next;
-                    arr->uni.ptr = val;
-                } else {
-                    while (idx-- > 0) {
-                        prev = next;
-                        next = next->next;
-                    }
-                    prev->next = val;
-                    val->next = next;
-                }
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr,
-                                             yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        unsafe_yyjson_set_len(arr, len + 1);
-        if (len == 0) {
-            val->next = val;
-        } else {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            prev->next = val;
-            val->next = next;
-        }
-        arr->uni.ptr = val;
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        unsafe_yyjson_set_len(arr, len + 1);
-        if (len == 0) {
-            val->next = val;
-            arr->uni.ptr = val;
-        } else {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            prev->next = val;
-            val->next = next;
-        }
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr,
-                                                         size_t idx,
-                                                         yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(idx < len)) {
-            if (yyjson_likely(len > 1)) {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                yyjson_mut_val *next = prev->next;
-                while (idx-- > 0) {
-                    prev = next;
-                    next = next->next;
-                }
-                prev->next = val;
-                val->next = next->next;
-                if ((void *)next == arr->uni.ptr) arr->uni.ptr = val;
-                return next;
-            } else {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                val->next = val;
-                arr->uni.ptr = val;
-                return prev;
-            }
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr,
-                                                        size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(idx < len)) {
-            unsafe_yyjson_set_len(arr, len - 1);
-            if (yyjson_likely(len > 1)) {
-                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-                yyjson_mut_val *next = prev->next;
-                while (idx-- > 0) {
-                    prev = next;
-                    next = next->next;
-                }
-                prev->next = next->next;
-                if ((void *)next == arr->uni.ptr) arr->uni.ptr = prev;
-                return next;
-            } else {
-                return ((yyjson_mut_val *)arr->uni.ptr);
-            }
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (len > 1) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            prev->next = next->next;
-            unsafe_yyjson_set_len(arr, len - 1);
-            return next;
-        } else if (len == 1) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            unsafe_yyjson_set_len(arr, 0);
-            return prev;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last(
-    yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_likely(len > 1)) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            yyjson_mut_val *next = prev->next;
-            unsafe_yyjson_set_len(arr, len - 1);
-            while (--len > 0) prev = prev->next;
-            prev->next = next;
-            next = (yyjson_mut_val *)arr->uni.ptr;
-            arr->uni.ptr = prev;
-            return next;
-        } else if (len == 1) {
-            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
-            unsafe_yyjson_set_len(arr, 0);
-            return prev;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr,
-                                                   size_t _idx, size_t _len) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *prev, *next;
-        bool tail_removed;
-        size_t len = unsafe_yyjson_get_len(arr);
-        if (yyjson_unlikely(_idx + _len > len)) return false;
-        if (yyjson_unlikely(_len == 0)) return true;
-        unsafe_yyjson_set_len(arr, len - _len);
-        if (yyjson_unlikely(len == _len)) return true;
-        tail_removed = (_idx + _len == len);
-        prev = ((yyjson_mut_val *)arr->uni.ptr);
-        while (_idx-- > 0) prev = prev->next;
-        next = prev->next;
-        while (_len-- > 0) next = next->next;
-        prev->next = next;
-        if (yyjson_unlikely(tail_removed)) arr->uni.ptr = prev;
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
-        unsafe_yyjson_set_len(arr, 0);
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr,
-                                             size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_arr(arr) &&
-                      unsafe_yyjson_get_len(arr) > idx)) {
-        yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr;
-        while (idx-- > 0) val = val->next;
-        arr->uni.ptr = (void *)val;
-        return true;
-    }
-    return false;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Array Modification Convenience API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr,
-                                              yyjson_mut_val *val) {
-    return yyjson_mut_arr_append(arr, val);
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_null(doc);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_true(doc);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_false(doc);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               bool _val) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_bool(doc, _val);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               uint64_t num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_uint(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               int64_t num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_sint(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              int64_t num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_sint(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               double num) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_real(doc, num);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *arr,
-                                              const char *str) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_str(doc, str);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *arr,
-                                               const char *str, size_t len) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_strn(doc, str, len);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *arr,
-                                                 const char *str) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_strcpy(doc, str);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *arr,
-                                                  const char *str, size_t len) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_strncpy(doc, str, len);
-        return yyjson_mut_arr_append(arr, val);
-    }
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_arr(doc);
-        return yyjson_mut_arr_append(arr, val) ? val : NULL;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *arr) {
-    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
-        yyjson_mut_val *val = yyjson_mut_obj(doc);
-        return yyjson_mut_arr_append(arr, val) ? val : NULL;
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj) {
-    return yyjson_mut_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj,
-                                                     const char *key) {
-    return yyjson_mut_obj_getn(obj, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj,
-                                                      const char *_key,
-                                                      size_t key_len) {
-    size_t len = yyjson_mut_obj_size(obj);
-    if (yyjson_likely(len && _key)) {
-        yyjson_mut_val *key = ((yyjson_mut_val *)obj->uni.ptr)->next->next;
-        while (len-- > 0) {
-            if (unsafe_yyjson_equals_strn(key, _key, key_len)) return key->next;
-            key = key->next->next;
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Iterator API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj,
-                                                yyjson_mut_obj_iter *iter) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && iter)) {
-        iter->idx = 0;
-        iter->max = unsafe_yyjson_get_len(obj);
-        iter->cur = iter->max ? (yyjson_mut_val *)obj->uni.ptr : NULL;
-        iter->pre = NULL;
-        iter->obj = obj;
-        return true;
-    }
-    if (iter) memset(iter, 0, sizeof(yyjson_mut_obj_iter));
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with(
-    yyjson_mut_val *obj) {
-    yyjson_mut_obj_iter iter;
-    yyjson_mut_obj_iter_init(obj, &iter);
-    return iter;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter *iter) {
-    return iter ? iter->idx < iter->max : false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next(
-    yyjson_mut_obj_iter *iter) {
-    if (iter && iter->idx < iter->max) {
-        yyjson_mut_val *key = iter->cur;
-        iter->pre = key;
-        iter->cur = key->next->next;
-        iter->idx++;
-        return iter->cur;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val(
-    yyjson_mut_val *key) {
-    return key ? key->next : NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove(
-    yyjson_mut_obj_iter *iter) {
-    if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
-        yyjson_mut_val *prev = iter->pre;
-        yyjson_mut_val *cur = iter->cur;
-        yyjson_mut_val *next = cur->next->next;
-        if (yyjson_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev;
-        iter->idx--;
-        iter->max--;
-        unsafe_yyjson_set_len(iter->obj, iter->max);
-        prev->next->next = next;
-        iter->cur = prev;
-        return cur->next;
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get(
-    yyjson_mut_obj_iter *iter, const char *key) {
-    return yyjson_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn(
-    yyjson_mut_obj_iter *iter, const char *key, size_t key_len) {
-    if (iter && key) {
-        size_t idx = 0;
-        size_t max = iter->max;
-        yyjson_mut_val *pre, *cur = iter->cur;
-        while (idx++ < max) {
-            pre = cur;
-            cur = cur->next->next;
-            if (unsafe_yyjson_equals_strn(cur, key, key_len)) {
-                iter->idx += idx;
-                if (iter->idx > max) iter->idx -= max + 1;
-                iter->pre = pre;
-                iter->cur = cur;
-                return cur->next;
-            }
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Creation API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc) {
-    if (yyjson_likely(doc)) {
-        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
-        if (yyjson_likely(val)) {
-            val->tag = YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE;
-            return val;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc,
-                                                          const char **keys,
-                                                          const char **vals,
-                                                          size_t count) {
-    if (yyjson_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) {
-        yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
-        if (yyjson_likely(obj)) {
-            obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ;
-            if (count > 0) {
-                size_t i;
-                for (i = 0; i < count; i++) {
-                    yyjson_mut_val *key = obj + (i * 2 + 1);
-                    yyjson_mut_val *val = obj + (i * 2 + 2);
-                    uint64_t key_len = (uint64_t)strlen(keys[i]);
-                    uint64_t val_len = (uint64_t)strlen(vals[i]);
-                    key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    key->uni.str = keys[i];
-                    val->uni.str = vals[i];
-                    key->next = val;
-                    val->next = val + 1;
-                }
-                obj[count * 2].next = obj + 1;
-                obj->uni.ptr = obj + (count * 2 - 1);
-            }
-            return obj;
-        }
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc,
-                                                         const char **pairs,
-                                                         size_t count) {
-    if (yyjson_likely(doc && ((count > 0 && pairs) || (count == 0)))) {
-        yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
-        if (yyjson_likely(obj)) {
-            obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ;
-            if (count > 0) {
-                size_t i;
-                for (i = 0; i < count; i++) {
-                    yyjson_mut_val *key = obj + (i * 2 + 1);
-                    yyjson_mut_val *val = obj + (i * 2 + 2);
-                    const char *key_str = pairs[i * 2 + 0];
-                    const char *val_str = pairs[i * 2 + 1];
-                    uint64_t key_len = (uint64_t)strlen(key_str);
-                    uint64_t val_len = (uint64_t)strlen(val_str);
-                    key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-                    key->uni.str = key_str;
-                    val->uni.str = val_str;
-                    key->next = val;
-                    val->next = val + 1;
-                }
-                obj[count * 2].next = obj + 1;
-                obj->uni.ptr = obj + (count * 2 - 1);
-            }
-            return obj;
-        }
-    }
-    return NULL;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification API (Implementation)
- *============================================================================*/
-
-yyjson_api_inline void unsafe_yyjson_mut_obj_add(yyjson_mut_val *obj,
-                                                 yyjson_mut_val *key,
-                                                 yyjson_mut_val *val,
-                                                 size_t len) {
-    if (yyjson_likely(len)) {
-        yyjson_mut_val *prev_val = ((yyjson_mut_val *)obj->uni.ptr)->next;
-        yyjson_mut_val *next_key = prev_val->next;
-        prev_val->next = key;
-        val->next = next_key;
-    } else {
-        val->next = key;
-    }
-    key->next = val;
-    obj->uni.ptr = (void *)key;
-    unsafe_yyjson_set_len(obj, len + 1);
-}
-
-yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_obj_remove(
-    yyjson_mut_val *obj, const char *key, size_t key_len) {
-    size_t obj_len = unsafe_yyjson_get_len(obj);
-    if (obj_len) {
-        yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr;
-        yyjson_mut_val *cur_key = pre_key->next->next;
-        yyjson_mut_val *removed_item = NULL;
-        size_t i;
-        for (i = 0; i < obj_len; i++) {
-            if (unsafe_yyjson_equals_strn(cur_key, key, key_len)) {
-                if (!removed_item) removed_item = cur_key->next;
-                cur_key = cur_key->next->next;
-                pre_key->next->next = cur_key;
-                if (i + 1 == obj_len) obj->uni.ptr = pre_key;
-                i--;
-                obj_len--;
-            } else {
-                pre_key = cur_key;
-                cur_key = cur_key->next->next;
-            }
-        }
-        unsafe_yyjson_set_len(obj, obj_len);
-        return removed_item;
-    } else {
-        return NULL;
-    }
-}
-
-yyjson_api_inline bool unsafe_yyjson_mut_obj_replace(yyjson_mut_val *obj,
-                                                     yyjson_mut_val *key,
-                                                     yyjson_mut_val *val) {
-    size_t key_len = unsafe_yyjson_get_len(key);
-    size_t obj_len = unsafe_yyjson_get_len(obj);
-    if (obj_len) {
-        yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr;
-        yyjson_mut_val *cur_key = pre_key->next->next;
-        size_t i;
-        for (i = 0; i < obj_len; i++) {
-            if (unsafe_yyjson_equals_strn(cur_key, key->uni.str, key_len)) {
-                cur_key->next->tag = val->tag;
-                cur_key->next->uni.u64 = val->uni.u64;
-                return true;
-            } else {
-                cur_key = cur_key->next->next;
-            }
-        }
-    }
-    return false;
-}
-
-yyjson_api_inline void unsafe_yyjson_mut_obj_rotate(yyjson_mut_val *obj,
-                                                    size_t idx) {
-    yyjson_mut_val *key = (yyjson_mut_val *)obj->uni.ptr;
-    while (idx-- > 0) key = key->next->next;
-    obj->uni.ptr = (void *)key;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key) && val)) {
-        unsafe_yyjson_mut_obj_add(obj, key, val, unsafe_yyjson_get_len(obj));
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj,
-                                          yyjson_mut_val *key,
-                                          yyjson_mut_val *val) {
-    bool replaced = false;
-    size_t key_len;
-    yyjson_mut_obj_iter iter;
-    yyjson_mut_val *cur_key;
-    if (yyjson_unlikely(!yyjson_mut_is_obj(obj) ||
-                        !yyjson_mut_is_str(key))) return false;
-    key_len = unsafe_yyjson_get_len(key);
-    yyjson_mut_obj_iter_init(obj, &iter);
-    while ((cur_key = yyjson_mut_obj_iter_next(&iter)) != 0) {
-        if (unsafe_yyjson_equals_strn(cur_key, key->uni.str, key_len)) {
-            if (!replaced && val) {
-                replaced = true;
-                val->next = cur_key->next->next;
-                cur_key->next = val;
-            } else {
-                yyjson_mut_obj_iter_remove(&iter);
-            }
-        }
-    }
-    if (!replaced && val) unsafe_yyjson_mut_obj_add(obj, key, val, iter.max);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj,
-                                             yyjson_mut_val *key,
-                                             yyjson_mut_val *val,
-                                             size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key) && val)) {
-        size_t len = unsafe_yyjson_get_len(obj);
-        if (yyjson_likely(len >= idx)) {
-            if (len > idx) {
-                void *ptr = obj->uni.ptr;
-                unsafe_yyjson_mut_obj_rotate(obj, idx);
-                unsafe_yyjson_mut_obj_add(obj, key, val, len);
-                obj->uni.ptr = ptr;
-            } else {
-                unsafe_yyjson_mut_obj_add(obj, key, val, len);
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj,
-    yyjson_mut_val *key) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key))) {
-        return unsafe_yyjson_mut_obj_remove(obj, key->uni.str,
-                                            unsafe_yyjson_get_len(key));
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key(
-    yyjson_mut_val *obj, const char *key) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
-        size_t key_len = strlen(key);
-        return unsafe_yyjson_mut_obj_remove(obj, key, key_len);
-    }
-    return NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn(
-    yyjson_mut_val *obj, const char *key, size_t key_len) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
-        return unsafe_yyjson_mut_obj_remove(obj, key, key_len);
-    }
-    return NULL;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj))) {
-        unsafe_yyjson_set_len(obj, 0);
-        return true;
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj,
-                                              yyjson_mut_val *key,
-                                              yyjson_mut_val *val) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      yyjson_mut_is_str(key) && val)) {
-        return unsafe_yyjson_mut_obj_replace(obj, key, val);
-    }
-    return false;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj,
-                                             size_t idx) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
-                      unsafe_yyjson_get_len(obj) > idx)) {
-        unsafe_yyjson_mut_obj_rotate(obj, idx);
-        return true;
-    }
-    return false;
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Object Modification Convenience API (Implementation)
- *============================================================================*/
-
-#define yyjson_mut_obj_add_func(func) \
-    if (yyjson_likely(doc && yyjson_mut_is_obj(obj) && _key)) { \
-        yyjson_mut_val *key = unsafe_yyjson_mut_val(doc, 2); \
-        if (yyjson_likely(key)) { \
-            size_t len = unsafe_yyjson_get_len(obj); \
-            yyjson_mut_val *val = key + 1; \
-            size_t key_len = strlen(_key); \
-            bool noesc = unsafe_yyjson_is_str_noesc(_key, key_len); \
-            key->tag = YYJSON_TYPE_STR; \
-            key->tag |= noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; \
-            key->tag |= (uint64_t)strlen(_key) << YYJSON_TAG_BIT; \
-            key->uni.str = _key; \
-            func \
-            unsafe_yyjson_mut_obj_add(obj, key, val, len); \
-            return true; \
-        } \
-    } \
-    return false
-
-yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc,
-                                                yyjson_mut_val *obj,
-                                                const char *_key) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               bool _val) {
-    yyjson_mut_obj_add_func({
-        _val = !!_val;
-        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3);
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               uint64_t _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
-        val->uni.u64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               int64_t _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *_key,
-                                              int64_t _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
-        val->uni.i64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               double _val) {
-    yyjson_mut_obj_add_func({
-        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-        val->uni.f64 = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *_key,
-                                              const char *_val) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        size_t val_len = strlen(_val);
-        bool val_noesc = unsafe_yyjson_is_str_noesc(_val, val_len);
-        val->tag = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->tag |= val_noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE;
-        val->uni.str = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc,
-                                               yyjson_mut_val *obj,
-                                               const char *_key,
-                                               const char *_val,
-                                               size_t _len) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = _val;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *obj,
-                                                 const char *_key,
-                                                 const char *_val) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        size_t _len = strlen(_val);
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
-        if (yyjson_unlikely(!val->uni.str)) return false;
-        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    });
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *obj,
-                                                  const char *_key,
-                                                  const char *_val,
-                                                  size_t _len) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
-        if (yyjson_unlikely(!val->uni.str)) return false;
-        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_add_arr(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *obj,
-                                                         const char *_key) {
-    yyjson_mut_val *key = yyjson_mut_str(doc, _key);
-    yyjson_mut_val *val = yyjson_mut_arr(doc);
-    return yyjson_mut_obj_add(obj, key, val) ? val : NULL;
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_add_obj(yyjson_mut_doc *doc,
-                                                         yyjson_mut_val *obj,
-                                                         const char *_key) {
-    yyjson_mut_val *key = yyjson_mut_str(doc, _key);
-    yyjson_mut_val *val = yyjson_mut_obj(doc);
-    return yyjson_mut_obj_add(obj, key, val) ? val : NULL;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc,
-                                              yyjson_mut_val *obj,
-                                              const char *_key,
-                                              yyjson_mut_val *_val) {
-    if (yyjson_unlikely(!_val)) return false;
-    yyjson_mut_obj_add_func({
-        val = _val;
-    });
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(yyjson_mut_val *obj,
-                                                            const char *key) {
-    return yyjson_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn(
-    yyjson_mut_val *obj, const char *_key, size_t _len) {
-    if (yyjson_likely(yyjson_mut_is_obj(obj) && _key)) {
-        yyjson_mut_val *key;
-        yyjson_mut_obj_iter iter;
-        yyjson_mut_val *val_removed = NULL;
-        yyjson_mut_obj_iter_init(obj, &iter);
-        while ((key = yyjson_mut_obj_iter_next(&iter)) != NULL) {
-            if (unsafe_yyjson_equals_strn(key, _key, _len)) {
-                if (!val_removed) val_removed = key->next;
-                yyjson_mut_obj_iter_remove(&iter);
-            }
-        }
-        return val_removed;
-    }
-    return NULL;
-}
-
-yyjson_api_inline bool yyjson_mut_obj_rename_key(yyjson_mut_doc *doc,
-                                                 yyjson_mut_val *obj,
-                                                 const char *key,
-                                                 const char *new_key) {
-    if (!key || !new_key) return false;
-    return yyjson_mut_obj_rename_keyn(doc, obj, key, strlen(key),
-                                      new_key, strlen(new_key));
-}
-
-yyjson_api_inline bool yyjson_mut_obj_rename_keyn(yyjson_mut_doc *doc,
-                                                  yyjson_mut_val *obj,
-                                                  const char *key,
-                                                  size_t len,
-                                                  const char *new_key,
-                                                  size_t new_len) {
-    char *cpy_key = NULL;
-    yyjson_mut_val *old_key;
-    yyjson_mut_obj_iter iter;
-    if (!doc || !obj || !key || !new_key) return false;
-    yyjson_mut_obj_iter_init(obj, &iter);
-    while ((old_key = yyjson_mut_obj_iter_next(&iter))) {
-        if (unsafe_yyjson_equals_strn((void *)old_key, key, len)) {
-            if (!cpy_key) {
-                cpy_key = unsafe_yyjson_mut_strncpy(doc, new_key, new_len);
-                if (!cpy_key) return false;
-            }
-            yyjson_mut_set_strn(old_key, cpy_key, new_len);
-        }
-    }
-    return cpy_key != NULL;
-}
-
-
-
-/*==============================================================================
- * JSON Pointer API (Implementation)
- *============================================================================*/
-
-#define yyjson_ptr_set_err(_code, _msg) do { \
-    if (err) { \
-        err->code = YYJSON_PTR_ERR_##_code; \
-        err->msg = _msg; \
-        err->pos = 0; \
-    } \
-} while(false)
-
-/* require: val != NULL, *ptr == '/', len > 0 */
-yyjson_api yyjson_val *unsafe_yyjson_ptr_getx(yyjson_val *val,
-                                              const char *ptr, size_t len,
-                                              yyjson_ptr_err *err);
-
-/* require: val != NULL, *ptr == '/', len > 0 */
-yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_getx(yyjson_mut_val *val,
-                                                      const char *ptr,
-                                                      size_t len,
-                                                      yyjson_ptr_ctx *ctx,
-                                                      yyjson_ptr_err *err);
-
-/* require: val/new_val/doc != NULL, *ptr == '/', len > 0 */
-yyjson_api bool unsafe_yyjson_mut_ptr_putx(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc,
-                                           bool create_parent, bool insert_new,
-                                           yyjson_ptr_ctx *ctx,
-                                           yyjson_ptr_err *err);
-
-/* require: val/err != NULL, *ptr == '/', len > 0 */
-yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_replacex(
-    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
-
-/* require: val/err != NULL, *ptr == '/', len > 0 */
-yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_removex(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         size_t len,
-                                                         yyjson_ptr_ctx *ctx,
-                                                         yyjson_ptr_err *err);
-
-yyjson_api_inline yyjson_val *yyjson_doc_ptr_get(yyjson_doc *doc,
-                                                 const char *ptr) {
-    if (yyjson_unlikely(!ptr)) return NULL;
-    return yyjson_doc_ptr_getn(doc, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_val *yyjson_doc_ptr_getn(yyjson_doc *doc,
-                                                  const char *ptr, size_t len) {
-    return yyjson_doc_ptr_getx(doc, ptr, len, NULL);
-}
-
-yyjson_api_inline yyjson_val *yyjson_doc_ptr_getx(yyjson_doc *doc,
-                                                  const char *ptr, size_t len,
-                                                  yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (yyjson_unlikely(!doc || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(!doc->root)) {
-        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        return doc->root;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_ptr_getx(doc->root, ptr, len, err);
-}
-
-yyjson_api_inline yyjson_val *yyjson_ptr_get(yyjson_val *val,
-                                             const char *ptr) {
-    if (yyjson_unlikely(!ptr)) return NULL;
-    return yyjson_ptr_getn(val, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_val *yyjson_ptr_getn(yyjson_val *val,
-                                              const char *ptr, size_t len) {
-    return yyjson_ptr_getx(val, ptr, len, NULL);
-}
-
-yyjson_api_inline yyjson_val *yyjson_ptr_getx(yyjson_val *val,
-                                              const char *ptr, size_t len,
-                                              yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (yyjson_unlikely(!val || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        return val;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_ptr_getx(val, ptr, len, err);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_get(yyjson_mut_doc *doc,
-                                                         const char *ptr) {
-    if (!ptr) return NULL;
-    return yyjson_mut_doc_ptr_getn(doc, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getn(yyjson_mut_doc *doc,
-                                                          const char *ptr,
-                                                          size_t len) {
-    return yyjson_mut_doc_ptr_getx(doc, ptr, len, NULL, NULL);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getx(yyjson_mut_doc *doc,
-                                                          const char *ptr,
-                                                          size_t len,
-                                                          yyjson_ptr_ctx *ctx,
-                                                          yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!doc || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(!doc->root)) {
-        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        return doc->root;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_mut_ptr_getx(doc->root, ptr, len, ctx, err);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_get(yyjson_mut_val *val,
-                                                     const char *ptr) {
-    if (!ptr) return NULL;
-    return yyjson_mut_ptr_getn(val, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getn(yyjson_mut_val *val,
-                                                      const char *ptr,
-                                                      size_t len) {
-    return yyjson_mut_ptr_getx(val, ptr, len, NULL, NULL);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getx(yyjson_mut_val *val,
-                                                      const char *ptr,
-                                                      size_t len,
-                                                      yyjson_ptr_ctx *ctx,
-                                                      yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!val || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        return val;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err);
-}
-
-yyjson_api_inline bool yyjson_mut_doc_ptr_add(yyjson_mut_doc *doc,
-                                              const char *ptr,
-                                              yyjson_mut_val *new_val) {
-    if (yyjson_unlikely(!ptr)) return false;
-    return yyjson_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val);
-}
-
-yyjson_api_inline bool yyjson_mut_doc_ptr_addn(yyjson_mut_doc *doc,
-                                               const char *ptr,
-                                               size_t len,
-                                               yyjson_mut_val *new_val) {
-    return yyjson_mut_doc_ptr_addx(doc, ptr, len, new_val, true, NULL, NULL);
-}
-
-yyjson_api_inline bool yyjson_mut_doc_ptr_addx(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val,
-                                               bool create_parent,
-                                               yyjson_ptr_ctx *ctx,
-                                               yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!doc || !ptr || !new_val)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return false;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        if (doc->root) {
-            yyjson_ptr_set_err(SET_ROOT, "cannot set document's root");
-            return false;
-        } else {
-            doc->root = new_val;
-            return true;
-        }
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return false;
-    }
-    if (yyjson_unlikely(!doc->root && !create_parent)) {
-        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
-        return false;
-    }
-    if (yyjson_unlikely(!doc->root)) {
-        yyjson_mut_val *root = yyjson_mut_obj(doc);
-        if (yyjson_unlikely(!root)) {
-            yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
-            return false;
-        }
-        if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc,
-                                       create_parent, true, ctx, err)) {
-            doc->root = root;
-            return true;
-        }
-        return false;
-    }
-    return unsafe_yyjson_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
-                                      create_parent, true, ctx, err);
-}
-
-yyjson_api_inline bool yyjson_mut_ptr_add(yyjson_mut_val *val,
-                                          const char *ptr,
-                                          yyjson_mut_val *new_val,
-                                          yyjson_mut_doc *doc) {
-    if (yyjson_unlikely(!ptr)) return false;
-    return yyjson_mut_ptr_addn(val, ptr, strlen(ptr), new_val, doc);
-}
-
-yyjson_api_inline bool yyjson_mut_ptr_addn(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc) {
-    return yyjson_mut_ptr_addx(val, ptr, len, new_val, doc, true, NULL, NULL);
-}
-
-yyjson_api_inline bool yyjson_mut_ptr_addx(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc,
-                                           bool create_parent,
-                                           yyjson_ptr_ctx *ctx,
-                                           yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!val || !ptr || !new_val || !doc)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return false;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
-        return false;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return false;
-    }
-    return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val,
-                                       doc, create_parent, true, ctx, err);
-}
-
-yyjson_api_inline bool yyjson_mut_doc_ptr_set(yyjson_mut_doc *doc,
-                                              const char *ptr,
-                                              yyjson_mut_val *new_val) {
-    if (yyjson_unlikely(!ptr)) return false;
-    return yyjson_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val);
-}
-
-yyjson_api_inline bool yyjson_mut_doc_ptr_setn(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val) {
-    return yyjson_mut_doc_ptr_setx(doc, ptr, len, new_val, true, NULL, NULL);
-}
-
-yyjson_api_inline bool yyjson_mut_doc_ptr_setx(yyjson_mut_doc *doc,
-                                               const char *ptr, size_t len,
-                                               yyjson_mut_val *new_val,
-                                               bool create_parent,
-                                               yyjson_ptr_ctx *ctx,
-                                               yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!doc || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return false;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        if (ctx) ctx->old = doc->root;
-        doc->root = new_val;
-        return true;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return false;
-    }
-    if (!new_val) {
-        if (!doc->root) {
-            yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved");
-            return false;
-        }
-        return !!unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err);
-    }
-    if (yyjson_unlikely(!doc->root && !create_parent)) {
-        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
-        return false;
-    }
-    if (yyjson_unlikely(!doc->root)) {
-        yyjson_mut_val *root = yyjson_mut_obj(doc);
-        if (yyjson_unlikely(!root)) {
-            yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
-            return false;
-        }
-        if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc,
-                                       create_parent, false, ctx, err)) {
-            doc->root = root;
-            return true;
-        }
-        return false;
-    }
-    return unsafe_yyjson_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
-                                      create_parent, false, ctx, err);
-}
-
-yyjson_api_inline bool yyjson_mut_ptr_set(yyjson_mut_val *val,
-                                          const char *ptr,
-                                          yyjson_mut_val *new_val,
-                                          yyjson_mut_doc *doc) {
-    if (yyjson_unlikely(!ptr)) return false;
-    return yyjson_mut_ptr_setn(val, ptr, strlen(ptr), new_val, doc);
-}
-
-yyjson_api_inline bool yyjson_mut_ptr_setn(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc) {
-    return yyjson_mut_ptr_setx(val, ptr, len, new_val, doc, true, NULL, NULL);
-}
-
-yyjson_api_inline bool yyjson_mut_ptr_setx(yyjson_mut_val *val,
-                                           const char *ptr, size_t len,
-                                           yyjson_mut_val *new_val,
-                                           yyjson_mut_doc *doc,
-                                           bool create_parent,
-                                           yyjson_ptr_ctx *ctx,
-                                           yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!val || !ptr || !doc)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return false;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
-        return false;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return false;
-    }
-    if (!new_val) {
-        return !!unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err);
-    }
-    return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val, doc,
-                                      create_parent, false, ctx, err);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replace(
-    yyjson_mut_doc *doc, const char *ptr, yyjson_mut_val *new_val) {
-    if (!ptr) return NULL;
-    return yyjson_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacen(
-    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val) {
-    return yyjson_mut_doc_ptr_replacex(doc, ptr, len, new_val, NULL, NULL);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacex(
-    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
-    
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!doc || !ptr || !new_val)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        yyjson_mut_val *root = doc->root;
-        if (yyjson_unlikely(!root)) {
-            yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved");
-            return NULL;
-        }
-        if (ctx) ctx->old = root;
-        doc->root = new_val;
-        return root;
-    }
-    if (yyjson_unlikely(!doc->root)) {
-        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_mut_ptr_replacex(doc->root, ptr, len, new_val,
-                                          ctx, err);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replace(
-    yyjson_mut_val *val, const char *ptr, yyjson_mut_val *new_val) {
-    if (!ptr) return NULL;
-    return yyjson_mut_ptr_replacen(val, ptr, strlen(ptr), new_val);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacen(
-    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val) {
-    return yyjson_mut_ptr_replacex(val, ptr, len, new_val, NULL, NULL);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacex(
-    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
-    
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!val || !ptr || !new_val)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
-        return NULL;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_mut_ptr_replacex(val, ptr, len, new_val, ctx, err);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_remove(
-    yyjson_mut_doc *doc, const char *ptr) {
-    if (!ptr) return NULL;
-    return yyjson_mut_doc_ptr_removen(doc, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removen(
-    yyjson_mut_doc *doc, const char *ptr, size_t len) {
-    return yyjson_mut_doc_ptr_removex(doc, ptr, len, NULL, NULL);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removex(
-    yyjson_mut_doc *doc, const char *ptr, size_t len,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
-    
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!doc || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(!doc->root)) {
-        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        yyjson_mut_val *root = doc->root;
-        if (ctx) ctx->old = root;
-        doc->root = NULL;
-        return root;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_remove(yyjson_mut_val *val,
-                                                        const char *ptr) {
-    if (!ptr) return NULL;
-    return yyjson_mut_ptr_removen(val, ptr, strlen(ptr));
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removen(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         size_t len) {
-    return yyjson_mut_ptr_removex(val, ptr, len, NULL, NULL);
-}
-
-yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removex(yyjson_mut_val *val,
-                                                         const char *ptr,
-                                                         size_t len,
-                                                         yyjson_ptr_ctx *ctx,
-                                                         yyjson_ptr_err *err) {
-    yyjson_ptr_set_err(NONE, NULL);
-    if (ctx) memset(ctx, 0, sizeof(*ctx));
-    
-    if (yyjson_unlikely(!val || !ptr)) {
-        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
-        return NULL;
-    }
-    if (yyjson_unlikely(len == 0)) {
-        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
-        return NULL;
-    }
-    if (yyjson_unlikely(*ptr != '/')) {
-        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
-        return NULL;
-    }
-    return unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err);
-}
-
-yyjson_api_inline bool yyjson_ptr_ctx_append(yyjson_ptr_ctx *ctx,
-                                             yyjson_mut_val *key,
-                                             yyjson_mut_val *val) {
-    yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
-    if (!ctx || !ctx->ctn || !val) return false;
-    ctn = ctx->ctn;
-    
-    if (yyjson_mut_is_obj(ctn)) {
-        if (!key) return false;
-        key->next = val;
-        pre_key = ctx->pre;
-        if (unsafe_yyjson_get_len(ctn) == 0) {
-            val->next = key;
-            ctn->uni.ptr = key;
-            ctx->pre = key;
-        } else if (!pre_key) {
-            pre_key = (yyjson_mut_val *)ctn->uni.ptr;
-            pre_val = pre_key->next;
-            val->next = pre_val->next;
-            pre_val->next = key;
-            ctn->uni.ptr = key;
-            ctx->pre = pre_key;
-        } else {
-            cur_key = pre_key->next->next;
-            cur_val = cur_key->next;
-            val->next = cur_val->next;
-            cur_val->next = key;
-            if (ctn->uni.ptr == cur_key) ctn->uni.ptr = key;
-            ctx->pre = cur_key;
-        }
-    } else {
-        pre_val = ctx->pre;
-        if (unsafe_yyjson_get_len(ctn) == 0) {
-            val->next = val;
-            ctn->uni.ptr = val;
-            ctx->pre = val;
-        } else if (!pre_val) {
-            pre_val = (yyjson_mut_val *)ctn->uni.ptr;
-            val->next = pre_val->next;
-            pre_val->next = val;
-            ctn->uni.ptr = val;
-            ctx->pre = pre_val;
-        } else {
-            cur_val = pre_val->next;
-            val->next = cur_val->next;
-            cur_val->next = val;
-            if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
-            ctx->pre = cur_val;
-        }
-    }
-    unsafe_yyjson_inc_len(ctn);
-    return true;
-}
-
-yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx *ctx,
-                                              yyjson_mut_val *val) {
-    yyjson_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val;
-    if (!ctx || !ctx->ctn || !ctx->pre || !val) return false;
-    ctn = ctx->ctn;
-    if (yyjson_mut_is_obj(ctn)) {
-        pre_key = ctx->pre;
-        pre_val = pre_key->next;
-        cur_key = pre_val->next;
-        cur_val = cur_key->next;
-        /* replace current value */
-        cur_key->next = val;
-        val->next = cur_val->next;
-        ctx->old = cur_val;
-    } else {
-        pre_val = ctx->pre;
-        cur_val = pre_val->next;
-        /* replace current value */
-        if (pre_val != cur_val) {
-            val->next = cur_val->next;
-            pre_val->next = val;
-            if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
-        } else {
-            val->next = val;
-            ctn->uni.ptr = val;
-            ctx->pre = val;
-        }
-        ctx->old = cur_val;
-    }
-    return true;
-}
-
-yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx *ctx) {
-    yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
-    size_t len;
-    if (!ctx || !ctx->ctn || !ctx->pre) return false;
-    ctn = ctx->ctn;
-    if (yyjson_mut_is_obj(ctn)) {
-        pre_key = ctx->pre;
-        pre_val = pre_key->next;
-        cur_key = pre_val->next;
-        cur_val = cur_key->next;
-        /* remove current key-value */
-        pre_val->next = cur_val->next;
-        if (ctn->uni.ptr == cur_key) ctn->uni.ptr = pre_key;
-        ctx->pre = NULL;
-        ctx->old = cur_val;
-    } else {
-        pre_val = ctx->pre;
-        cur_val = pre_val->next;
-        /* remove current key-value */
-        pre_val->next = cur_val->next;
-        if (ctn->uni.ptr == cur_val) ctn->uni.ptr = pre_val;
-        ctx->pre = NULL;
-        ctx->old = cur_val;
-    }
-    len = unsafe_yyjson_get_len(ctn) - 1;
-    if (len == 0) ctn->uni.ptr = NULL;
-    unsafe_yyjson_set_len(ctn, len);
-    return true;
-}
-
-#undef yyjson_ptr_set_err
-
-
-
-/*==============================================================================
- * JSON Value at Pointer API (Implementation)
- *============================================================================*/
-
-/**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type bool.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
- */
-yyjson_api_inline bool yyjson_ptr_get_bool(
-    yyjson_val *root, const char *ptr, bool *value) {
-    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_bool(val)) {
-        *value = unsafe_yyjson_get_bool(val);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-/**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is an integer
- that fits in `uint64_t`. Returns true if successful, otherwise false.
- */
-yyjson_api_inline bool yyjson_ptr_get_uint(
-    yyjson_val *root, const char *ptr, uint64_t *value) {
-    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && val) {
-        uint64_t ret = val->uni.u64;
-        if (unsafe_yyjson_is_uint(val) ||
-            (unsafe_yyjson_is_sint(val) && !(ret >> 63))) {
-            *value = ret;
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is an integer
- that fits in `int64_t`. Returns true if successful, otherwise false.
- */
-yyjson_api_inline bool yyjson_ptr_get_sint(
-    yyjson_val *root, const char *ptr, int64_t *value) {
-    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && val) {
-        int64_t ret = val->uni.i64;
-        if (unsafe_yyjson_is_sint(val) ||
-            (unsafe_yyjson_is_uint(val) && ret >= 0)) {
-            *value = ret;
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type real.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
- */
-yyjson_api_inline bool yyjson_ptr_get_real(
-    yyjson_val *root, const char *ptr, double *value) {
-    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_real(val)) {
-        *value = unsafe_yyjson_get_real(val);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-/**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint,
- uint or real.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
- */
-yyjson_api_inline bool yyjson_ptr_get_num(
-    yyjson_val *root, const char *ptr, double *value) {
-    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_num(val)) {
-        *value = unsafe_yyjson_get_num(val);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-/**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type string.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
- */
-yyjson_api_inline bool yyjson_ptr_get_str(
-    yyjson_val *root, const char *ptr, const char **value) {
-    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_str(val)) {
-        *value = unsafe_yyjson_get_str(val);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-
-
-/*==============================================================================
- * Deprecated
- *============================================================================*/
-
-/** @deprecated renamed to `yyjson_doc_ptr_get` */
-yyjson_deprecated("renamed to yyjson_doc_ptr_get")
-yyjson_api_inline yyjson_val *yyjson_doc_get_pointer(yyjson_doc *doc,
-                                                     const char *ptr) {
-    return yyjson_doc_ptr_get(doc, ptr);
-}
-
-/** @deprecated renamed to `yyjson_doc_ptr_getn` */
-yyjson_deprecated("renamed to yyjson_doc_ptr_getn")
-yyjson_api_inline yyjson_val *yyjson_doc_get_pointern(yyjson_doc *doc,
-                                                      const char *ptr,
-                                                      size_t len) {
-    return yyjson_doc_ptr_getn(doc, ptr, len);
-}
-
-/** @deprecated renamed to `yyjson_mut_doc_ptr_get` */
-yyjson_deprecated("renamed to yyjson_mut_doc_ptr_get")
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointer(
-    yyjson_mut_doc *doc, const char *ptr) {
-    return yyjson_mut_doc_ptr_get(doc, ptr);
-}
-
-/** @deprecated renamed to `yyjson_mut_doc_ptr_getn` */
-yyjson_deprecated("renamed to yyjson_mut_doc_ptr_getn")
-yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointern(
-    yyjson_mut_doc *doc, const char *ptr, size_t len) {
-    return yyjson_mut_doc_ptr_getn(doc, ptr, len);
-}
-
-/** @deprecated renamed to `yyjson_ptr_get` */
-yyjson_deprecated("renamed to yyjson_ptr_get")
-yyjson_api_inline yyjson_val *yyjson_get_pointer(yyjson_val *val,
-                                                 const char *ptr) {
-    return yyjson_ptr_get(val, ptr);
-}
-
-/** @deprecated renamed to `yyjson_ptr_getn` */
-yyjson_deprecated("renamed to yyjson_ptr_getn")
-yyjson_api_inline yyjson_val *yyjson_get_pointern(yyjson_val *val,
-                                                  const char *ptr,
-                                                  size_t len) {
-    return yyjson_ptr_getn(val, ptr, len);
-}
-
-/** @deprecated renamed to `yyjson_mut_ptr_get` */
-yyjson_deprecated("renamed to yyjson_mut_ptr_get")
-yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointer(yyjson_mut_val *val,
-                                                         const char *ptr) {
-    return yyjson_mut_ptr_get(val, ptr);
-}
-
-/** @deprecated renamed to `yyjson_mut_ptr_getn` */
-yyjson_deprecated("renamed to yyjson_mut_ptr_getn")
-yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointern(yyjson_mut_val *val,
-                                                          const char *ptr,
-                                                          size_t len) {
-    return yyjson_mut_ptr_getn(val, ptr, len);
-}
-
-/** @deprecated renamed to `yyjson_mut_ptr_getn` */
-yyjson_deprecated("renamed to unsafe_yyjson_ptr_getn")
-yyjson_api_inline yyjson_val *unsafe_yyjson_get_pointer(yyjson_val *val,
-                                                        const char *ptr,
-                                                        size_t len) {
-    yyjson_ptr_err err;
-    return unsafe_yyjson_ptr_getx(val, ptr, len, &err);
-}
-
-/** @deprecated renamed to `unsafe_yyjson_mut_ptr_getx` */
-yyjson_deprecated("renamed to unsafe_yyjson_mut_ptr_getx")
-yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_get_pointer(
-    yyjson_mut_val *val, const char *ptr, size_t len) {
-    yyjson_ptr_err err;
-    return unsafe_yyjson_mut_ptr_getx(val, ptr, len, NULL, &err);
-}
-
-
-
-/*==============================================================================
- * Compiler Hint End
- *============================================================================*/
-
-#if defined(__clang__)
-#   pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic pop
-#   endif
-#elif defined(_MSC_VER)
-#   pragma warning(pop)
-#endif /* warning suppress end */
-
-#ifdef __cplusplus
-// }
-#endif /* extern "C" end */
-
-} // namespace duckdb_yyjson
-
-#endif /* DUCKDB_YYJSON_H */
diff --git a/src/duckdb/third_party/yyjson/yyjson.cpp b/src/duckdb/third_party/yyjson/yyjson.cpp
deleted file mode 100644
index d8df196fd..000000000
--- a/src/duckdb/third_party/yyjson/yyjson.cpp
+++ /dev/null
@@ -1,9490 +0,0 @@
-/*==============================================================================
- Copyright (c) 2020 YaoYuan <ibireme@gmail.com>
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- *============================================================================*/
-
-#include "yyjson.hpp"
-#include <math.h>
-
-namespace duckdb_yyjson {
-
-/*==============================================================================
- * Warning Suppress
- *============================================================================*/
-
-/* warning suppress begin */
-#if defined(__clang__)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wunused-function"
-#   pragma clang diagnostic ignored "-Wunused-parameter"
-#   pragma clang diagnostic ignored "-Wunused-label"
-#   pragma clang diagnostic ignored "-Wunused-macros"
-#   pragma clang diagnostic ignored "-Wunused-variable"
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic push
-#   endif
-#   pragma GCC diagnostic ignored "-Wunused-function"
-#   pragma GCC diagnostic ignored "-Wunused-parameter"
-#   pragma GCC diagnostic ignored "-Wunused-label"
-#   pragma GCC diagnostic ignored "-Wunused-macros"
-#elif defined(_MSC_VER)
-#   pragma warning(push)
-#   pragma warning(disable:4100) /* unreferenced formal parameter */
-#   pragma warning(disable:4101) /* unreferenced variable */
-#   pragma warning(disable:4102) /* unreferenced label */
-#   pragma warning(disable:4127) /* conditional expression is constant */
-#   pragma warning(disable:4706) /* assignment within conditional expression */
-#endif
-
-
-
-/*==============================================================================
- * Version
- *============================================================================*/
-
-uint32_t yyjson_version(void) {
-    return YYJSON_VERSION_HEX;
-}
-
-
-
-/*==============================================================================
- * Flags
- *============================================================================*/
-
-/* msvc intrinsic */
-#if YYJSON_MSC_VER >= 1400
-#   include <intrin.h>
-#   if defined(_M_AMD64) || defined(_M_ARM64)
-#       define MSC_HAS_BIT_SCAN_64 1
-#       pragma intrinsic(_BitScanForward64)
-#       pragma intrinsic(_BitScanReverse64)
-#   else
-#       define MSC_HAS_BIT_SCAN_64 0
-#   endif
-#   if defined(_M_AMD64) || defined(_M_ARM64) || \
-        defined(_M_IX86) || defined(_M_ARM)
-#       define MSC_HAS_BIT_SCAN 1
-#       pragma intrinsic(_BitScanForward)
-#       pragma intrinsic(_BitScanReverse)
-#   else
-#       define MSC_HAS_BIT_SCAN 0
-#   endif
-#   if defined(_M_AMD64)
-#       define MSC_HAS_UMUL128 1
-#       pragma intrinsic(_umul128)
-#   else
-#       define MSC_HAS_UMUL128 0
-#   endif
-#else
-#   define MSC_HAS_BIT_SCAN_64 0
-#   define MSC_HAS_BIT_SCAN 0
-#   define MSC_HAS_UMUL128 0
-#endif
-
-/* gcc builtin */
-#if yyjson_has_builtin(__builtin_clzll) || yyjson_gcc_available(3, 4, 0)
-#   define GCC_HAS_CLZLL 1
-#else
-#   define GCC_HAS_CLZLL 0
-#endif
-
-#if yyjson_has_builtin(__builtin_ctzll) || yyjson_gcc_available(3, 4, 0)
-#   define GCC_HAS_CTZLL 1
-#else
-#   define GCC_HAS_CTZLL 0
-#endif
-
-/* int128 type */
-#if defined(__SIZEOF_INT128__) && (__SIZEOF_INT128__ == 16) && \
-    (defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER))
-#    define YYJSON_HAS_INT128 1
-#else
-#    define YYJSON_HAS_INT128 0
-#endif
-
-/* IEEE 754 floating-point binary representation */
-#if defined(__STDC_IEC_559__) || defined(__STDC_IEC_60559_BFP__)
-#   define YYJSON_HAS_IEEE_754 1
-#elif (FLT_RADIX == 2) && (DBL_MANT_DIG == 53) && (DBL_DIG == 15) && \
-     (DBL_MIN_EXP == -1021) && (DBL_MAX_EXP == 1024) && \
-     (DBL_MIN_10_EXP == -307) && (DBL_MAX_10_EXP == 308)
-#   define YYJSON_HAS_IEEE_754 1
-#else
-#   define YYJSON_HAS_IEEE_754 0
-#endif
-
-/*
- Correct rounding in double number computations.
-
- On the x86 architecture, some compilers may use x87 FPU instructions for
- floating-point arithmetic. The x87 FPU loads all floating point number as
- 80-bit double-extended precision internally, then rounds the result to original
- precision, which may produce inaccurate results. For a more detailed
- explanation, see the paper: https://arxiv.org/abs/cs/0701192
-
- Here are some examples of double precision calculation error:
-
-     2877.0 / 1e6   == 0.002877,  but x87 returns 0.0028770000000000002
-     43683.0 * 1e21 == 4.3683e25, but x87 returns 4.3683000000000004e25
-
- Here are some examples of compiler flags to generate x87 instructions on x86:
-
-     clang -m32 -mno-sse
-     gcc/icc -m32 -mfpmath=387
-     msvc /arch:SSE or /arch:IA32
-
- If we are sure that there's no similar error described above, we can define the
- YYJSON_DOUBLE_MATH_CORRECT as 1 to enable the fast path calculation. This is
- not an accurate detection, it's just try to avoid the error at compile-time.
- An accurate detection can be done at run-time:
-
-     bool is_double_math_correct(void) {
-         volatile double r = 43683.0;
-         r *= 1e21;
-         return r == 4.3683e25;
-     }
-
- See also: utils.h in https://github.com/google/double-conversion/
- */
-#if !defined(FLT_EVAL_METHOD) && defined(__FLT_EVAL_METHOD__)
-#    define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
-#endif
-
-#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0 && FLT_EVAL_METHOD != 1
-#    define YYJSON_DOUBLE_MATH_CORRECT 0
-#elif defined(i386) || defined(__i386) || defined(__i386__) || \
-    defined(_X86_) || defined(__X86__) || defined(_M_IX86) || \
-    defined(__I86__) || defined(__IA32__) || defined(__THW_INTEL)
-#   if (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP == 2) || \
-        (defined(__SSE2_MATH__) && __SSE2_MATH__)
-#       define YYJSON_DOUBLE_MATH_CORRECT 1
-#   else
-#       define YYJSON_DOUBLE_MATH_CORRECT 0
-#   endif
-#elif defined(__mc68000__) || defined(__pnacl__) || defined(__native_client__)
-#   define YYJSON_DOUBLE_MATH_CORRECT 0
-#else
-#   define YYJSON_DOUBLE_MATH_CORRECT 1
-#endif
-
-/* endian */
-#if yyjson_has_include(<sys/types.h>)
-#    include <sys/types.h> /* POSIX */
-#endif
-#if yyjson_has_include(<endian.h>)
-#    include <endian.h> /* Linux */
-#elif yyjson_has_include(<sys/endian.h>)
-#    include <sys/endian.h> /* BSD, Android */
-#elif yyjson_has_include(<machine/endian.h>)
-#    include <machine/endian.h> /* BSD, Darwin */
-#endif
-
-#define YYJSON_BIG_ENDIAN       4321
-#define YYJSON_LITTLE_ENDIAN    1234
-
-#if defined(BYTE_ORDER) && BYTE_ORDER
-#   if defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)
-#       define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-#   elif defined(LITTLE_ENDIAN) && (BYTE_ORDER == LITTLE_ENDIAN)
-#       define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-#   endif
-
-#elif defined(__BYTE_ORDER) && __BYTE_ORDER
-#   if defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN)
-#       define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-#   elif defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN)
-#       define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-#   endif
-
-#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__
-#   if defined(__ORDER_BIG_ENDIAN__) && \
-        (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#       define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-#   elif defined(__ORDER_LITTLE_ENDIAN__) && \
-        (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#       define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-#   endif
-
-#elif (defined(__LITTLE_ENDIAN__) && __LITTLE_ENDIAN__ == 1) || \
-    defined(__i386) || defined(__i386__) || \
-    defined(_X86_) || defined(__X86__) || \
-    defined(_M_IX86) || defined(__THW_INTEL__) || \
-    defined(__x86_64) || defined(__x86_64__) || \
-    defined(__amd64) || defined(__amd64__) || \
-    defined(_M_AMD64) || defined(_M_X64) || \
-    defined(_M_ARM) || defined(_M_ARM64) || \
-    defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || \
-    defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || \
-    defined(__EMSCRIPTEN__) || defined(__wasm__) || \
-    defined(__loongarch__)
-#   define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN
-
-#elif (defined(__BIG_ENDIAN__) && __BIG_ENDIAN__ == 1) || \
-    defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \
-    defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) || \
-    defined(__or1k__) || defined(__OR1K__)
-#   define YYJSON_ENDIAN YYJSON_BIG_ENDIAN
-
-#else
-#   define YYJSON_ENDIAN 0 /* unknown endian, detect at run-time */
-#endif
-
-/*
- This macro controls how yyjson handles unaligned memory accesses.
-
- By default, yyjson uses `memcpy()` for memory copying. This takes advantage of
- the compiler's automatic optimizations to generate unaligned memory access
- instructions when the target architecture supports it.
-
- However, for some older compilers or architectures where `memcpy()` isn't
- optimized well and may generate unnecessary function calls, consider defining
- this macro as 1. In such cases, yyjson switches to manual byte-by-byte access,
- potentially improving performance. An example of the generated assembly code on
- the ARM platform can be found here: https://godbolt.org/z/334jjhxPT
-
- As this flag has already been enabled for some common architectures in the
- following code, users typically don't need to manually specify it. If users are
- unsure about it, please review the generated assembly code or perform actual
- benchmark to make an informed decision.
- */
-#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-#   if defined(__ia64) || defined(_IA64) || defined(__IA64__) ||  \
-        defined(__ia64__) || defined(_M_IA64) || defined(__itanium__)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* Itanium */
-#   elif (defined(__arm__) || defined(__arm64__) || defined(__aarch64__)) && \
-        (defined(__GNUC__) || defined(__clang__)) && \
-        (!defined(__ARM_FEATURE_UNALIGNED) || !__ARM_FEATURE_UNALIGNED)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* ARM */
-#   elif defined(__sparc) || defined(__sparc__)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* SPARC */
-#   elif defined(__mips) || defined(__mips__) || defined(__MIPS__)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* MIPS */
-#   elif defined(__m68k__) || defined(M68000)
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* M68K */
-#   else
-#       define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 0
-#   endif
-#endif
-
-/*
- Estimated initial ratio of the JSON data (data_size / value_count).
- For example:
-
-    data:        {"id":12345678,"name":"Harry"}
-    data_size:   30
-    value_count: 5
-    ratio:       6
-
- yyjson uses dynamic memory with a growth factor of 1.5 when reading and writing
- JSON, the ratios below are used to determine the initial memory size.
-
- A too large ratio will waste memory, and a too small ratio will cause multiple
- memory growths and degrade performance. Currently, these ratios are generated
- with some commonly used JSON datasets.
- */
-#define YYJSON_READER_ESTIMATED_PRETTY_RATIO 16
-#define YYJSON_READER_ESTIMATED_MINIFY_RATIO 6
-#define YYJSON_WRITER_ESTIMATED_PRETTY_RATIO 32
-#define YYJSON_WRITER_ESTIMATED_MINIFY_RATIO 18
-
-/* The initial and maximum size of the memory pool's chunk in yyjson_mut_doc. */
-#define YYJSON_MUT_DOC_STR_POOL_INIT_SIZE   0x100
-#define YYJSON_MUT_DOC_STR_POOL_MAX_SIZE    0x10000000
-#define YYJSON_MUT_DOC_VAL_POOL_INIT_SIZE   (0x10 * sizeof(yyjson_mut_val))
-#define YYJSON_MUT_DOC_VAL_POOL_MAX_SIZE    (0x1000000 * sizeof(yyjson_mut_val))
-
-/* The minimum size of the dynamic allocator's chunk. */
-#define YYJSON_ALC_DYN_MIN_SIZE             0x1000
-
-/* Default value for compile-time options. */
-#ifndef YYJSON_DISABLE_READER
-#define YYJSON_DISABLE_READER 0
-#endif
-#ifndef YYJSON_DISABLE_WRITER
-#define YYJSON_DISABLE_WRITER 0
-#endif
-#ifndef YYJSON_DISABLE_UTILS
-#define YYJSON_DISABLE_UTILS 0
-#endif
-#ifndef YYJSON_DISABLE_FAST_FP_CONV
-#define YYJSON_DISABLE_FAST_FP_CONV 0
-#endif
-#ifndef YYJSON_DISABLE_NON_STANDARD
-#define YYJSON_DISABLE_NON_STANDARD 0
-#endif
-#ifndef YYJSON_DISABLE_UTF8_VALIDATION
-#define YYJSON_DISABLE_UTF8_VALIDATION 0
-#endif
-
-
-
-/*==============================================================================
- * Macros
- *============================================================================*/
-
-/* Macros used for loop unrolling and other purpose. */
-#define repeat2(x)  { x x }
-#define repeat3(x)  { x x x }
-#define repeat4(x)  { x x x x }
-#define repeat8(x)  { x x x x x x x x }
-#define repeat16(x) { x x x x x x x x x x x x x x x x }
-
-#define repeat2_incr(x)   { x(0)  x(1) }
-#define repeat4_incr(x)   { x(0)  x(1)  x(2)  x(3) }
-#define repeat8_incr(x)   { x(0)  x(1)  x(2)  x(3)  x(4)  x(5)  x(6)  x(7)  }
-#define repeat16_incr(x)  { x(0)  x(1)  x(2)  x(3)  x(4)  x(5)  x(6)  x(7)  \
-                            x(8)  x(9)  x(10) x(11) x(12) x(13) x(14) x(15) }
-
-#define repeat_in_1_18(x) { x(1)  x(2)  x(3)  x(4)  x(5)  x(6)  x(7)  x(8)  \
-                            x(9)  x(10) x(11) x(12) x(13) x(14) x(15) x(16) \
-                            x(17) x(18) }
-
-/* Macros used to provide branch prediction information for compiler. */
-#undef  likely
-#define likely(x)       yyjson_likely(x)
-#undef  unlikely
-#define unlikely(x)     yyjson_unlikely(x)
-
-/* Macros used to provide inline information for compiler. */
-#undef  static_inline
-#define static_inline   static yyjson_inline
-#undef  static_noinline
-#define static_noinline static yyjson_noinline
-
-/* Macros for min and max. */
-#undef  yyjson_min
-#define yyjson_min(x, y) ((x) < (y) ? (x) : (y))
-#undef  yyjson_max
-#define yyjson_max(x, y) ((x) > (y) ? (x) : (y))
-
-/* Used to write u64 literal for C89 which doesn't support "ULL" suffix. */
-#undef  U64
-#define U64(hi, lo) ((((u64)hi##UL) << 32U) + lo##UL)
-
-/* Used to cast away (remove) const qualifier. */
-#define constcast(type) (type)(void *)(size_t)(const void *)
-
-/* flag test */
-#define has_read_flag(_flag) unlikely(read_flag_eq(flg, YYJSON_READ_##_flag))
-#define has_write_flag(_flag) unlikely(write_flag_eq(flg, YYJSON_WRITE_##_flag))
-
-static_inline bool read_flag_eq(yyjson_read_flag flg, yyjson_read_flag chk) {
-#if YYJSON_DISABLE_NON_STANDARD
-    if (chk == YYJSON_READ_ALLOW_INF_AND_NAN ||
-        chk == YYJSON_READ_ALLOW_COMMENTS ||
-        chk == YYJSON_READ_ALLOW_TRAILING_COMMAS ||
-        chk == YYJSON_READ_ALLOW_INVALID_UNICODE)
-        return false; /* this should be evaluated at compile-time */
-#endif
-    return (flg & chk) != 0;
-}
-
-static_inline bool write_flag_eq(yyjson_write_flag flg, yyjson_write_flag chk) {
-#if YYJSON_DISABLE_NON_STANDARD
-    if (chk == YYJSON_WRITE_ALLOW_INF_AND_NAN ||
-        chk == YYJSON_WRITE_ALLOW_INVALID_UNICODE)
-        return false; /* this should be evaluated at compile-time */
-#endif
-    return (flg & chk) != 0;
-}
-
-
-
-/*==============================================================================
- * Integer Constants
- *============================================================================*/
-
-/* U64 constant values */
-#undef  U64_MAX
-#define U64_MAX         U64(0xFFFFFFFF, 0xFFFFFFFF)
-#undef  I64_MAX
-#define I64_MAX         U64(0x7FFFFFFF, 0xFFFFFFFF)
-#undef  USIZE_MAX
-#define USIZE_MAX       ((usize)(~(usize)0))
-
-/* Maximum number of digits for reading u32/u64/usize safety (not overflow). */
-#undef  U32_SAFE_DIG
-#define U32_SAFE_DIG    9   /* u32 max is 4294967295, 10 digits */
-#undef  U64_SAFE_DIG
-#define U64_SAFE_DIG    19  /* u64 max is 18446744073709551615, 20 digits */
-#undef  USIZE_SAFE_DIG
-#define USIZE_SAFE_DIG  (sizeof(usize) == 8 ? U64_SAFE_DIG : U32_SAFE_DIG)
-
-
-
-/*==============================================================================
- * IEEE-754 Double Number Constants
- *============================================================================*/
-
-/* Inf raw value (positive) */
-#define F64_RAW_INF U64(0x7FF00000, 0x00000000)
-
-/* NaN raw value (quiet NaN, no payload, no sign) */
-#if defined(__hppa__) || (defined(__mips__) && !defined(__mips_nan2008))
-#define F64_RAW_NAN U64(0x7FF7FFFF, 0xFFFFFFFF)
-#else
-#define F64_RAW_NAN U64(0x7FF80000, 0x00000000)
-#endif
-
-/* double number bits */
-#define F64_BITS 64
-
-/* double number exponent part bits */
-#define F64_EXP_BITS 11
-
-/* double number significand part bits */
-#define F64_SIG_BITS 52
-
-/* double number significand part bits (with 1 hidden bit) */
-#define F64_SIG_FULL_BITS 53
-
-/* double number significand bit mask */
-#define F64_SIG_MASK U64(0x000FFFFF, 0xFFFFFFFF)
-
-/* double number exponent bit mask */
-#define F64_EXP_MASK U64(0x7FF00000, 0x00000000)
-
-/* double number exponent bias */
-#define F64_EXP_BIAS 1023
-
-/* double number significant digits count in decimal */
-#define F64_DEC_DIG 17
-
-/* max significant digits count in decimal when reading double number */
-#define F64_MAX_DEC_DIG 768
-
-/* maximum decimal power of double number (1.7976931348623157e308) */
-#define F64_MAX_DEC_EXP 308
-
-/* minimum decimal power of double number (4.9406564584124654e-324) */
-#define F64_MIN_DEC_EXP (-324)
-
-/* maximum binary power of double number */
-#define F64_MAX_BIN_EXP 1024
-
-/* minimum binary power of double number */
-#define F64_MIN_BIN_EXP (-1021)
-
-
-
-/*==============================================================================
- * Types
- *============================================================================*/
-
-/** Type define for primitive types. */
-typedef float       f32;
-typedef double      f64;
-typedef int8_t      i8;
-typedef uint8_t     u8;
-typedef int16_t     i16;
-typedef uint16_t    u16;
-typedef int32_t     i32;
-typedef uint32_t    u32;
-typedef int64_t     i64;
-typedef uint64_t    u64;
-typedef size_t      usize;
-
-/** 128-bit integer, used by floating-point number reader and writer. */
-#if YYJSON_HAS_INT128
-__extension__ typedef __int128          i128;
-__extension__ typedef unsigned __int128 u128;
-#endif
-
-/** 16/32/64-bit vector */
-typedef struct v16 { char c[2]; } v16;
-typedef struct v32 { char c[4]; } v32;
-typedef struct v64 { char c[8]; } v64;
-
-/** 16/32/64-bit vector union */
-typedef union v16_uni { v16 v; u16 u; } v16_uni;
-typedef union v32_uni { v32 v; u32 u; } v32_uni;
-typedef union v64_uni { v64 v; u64 u; } v64_uni;
-
-
-
-/*==============================================================================
- * Load/Store Utils
- *============================================================================*/
-
-#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
-
-#define byte_move_idx(x) ((char *)dst)[x] = ((const char *)src)[x];
-
-static_inline void byte_copy_2(void *dst, const void *src) {
-    repeat2_incr(byte_move_idx)
-}
-
-static_inline void byte_copy_4(void *dst, const void *src) {
-    repeat4_incr(byte_move_idx)
-}
-
-static_inline void byte_copy_8(void *dst, const void *src) {
-    repeat8_incr(byte_move_idx)
-}
-
-static_inline void byte_copy_16(void *dst, const void *src) {
-    repeat16_incr(byte_move_idx)
-}
-
-static_inline void byte_move_2(void *dst, const void *src) {
-    repeat2_incr(byte_move_idx)
-}
-
-static_inline void byte_move_4(void *dst, const void *src) {
-    repeat4_incr(byte_move_idx)
-}
-
-static_inline void byte_move_8(void *dst, const void *src) {
-    repeat8_incr(byte_move_idx)
-}
-
-static_inline void byte_move_16(void *dst, const void *src) {
-    repeat16_incr(byte_move_idx)
-}
-
-static_inline bool byte_match_2(void *buf, const char *pat) {
-    return
-    ((char *)buf)[0] == ((const char *)pat)[0] &&
-    ((char *)buf)[1] == ((const char *)pat)[1];
-}
-
-static_inline bool byte_match_4(void *buf, const char *pat) {
-    return
-    ((char *)buf)[0] == ((const char *)pat)[0] &&
-    ((char *)buf)[1] == ((const char *)pat)[1] &&
-    ((char *)buf)[2] == ((const char *)pat)[2] &&
-    ((char *)buf)[3] == ((const char *)pat)[3];
-}
-
-static_inline u16 byte_load_2(const void *src) {
-    v16_uni uni;
-    uni.v.c[0] = ((const char *)src)[0];
-    uni.v.c[1] = ((const char *)src)[1];
-    return uni.u;
-}
-
-static_inline u32 byte_load_3(const void *src) {
-    v32_uni uni;
-    uni.v.c[0] = ((const char *)src)[0];
-    uni.v.c[1] = ((const char *)src)[1];
-    uni.v.c[2] = ((const char *)src)[2];
-    uni.v.c[3] = 0;
-    return uni.u;
-}
-
-static_inline u32 byte_load_4(const void *src) {
-    v32_uni uni;
-    uni.v.c[0] = ((const char *)src)[0];
-    uni.v.c[1] = ((const char *)src)[1];
-    uni.v.c[2] = ((const char *)src)[2];
-    uni.v.c[3] = ((const char *)src)[3];
-    return uni.u;
-}
-
-#undef byte_move_expr
-
-#else
-
-static_inline void byte_copy_2(void *dst, const void *src) {
-    memcpy(dst, src, 2);
-}
-
-static_inline void byte_copy_4(void *dst, const void *src) {
-    memcpy(dst, src, 4);
-}
-
-static_inline void byte_copy_8(void *dst, const void *src) {
-    memcpy(dst, src, 8);
-}
-
-static_inline void byte_copy_16(void *dst, const void *src) {
-    memcpy(dst, src, 16);
-}
-
-static_inline void byte_move_2(void *dst, const void *src) {
-    u16 tmp;
-    memcpy(&tmp, src, 2);
-    memcpy(dst, &tmp, 2);
-}
-
-static_inline void byte_move_4(void *dst, const void *src) {
-    u32 tmp;
-    memcpy(&tmp, src, 4);
-    memcpy(dst, &tmp, 4);
-}
-
-static_inline void byte_move_8(void *dst, const void *src) {
-    u64 tmp;
-    memcpy(&tmp, src, 8);
-    memcpy(dst, &tmp, 8);
-}
-
-static_inline void byte_move_16(void *dst, const void *src) {
-    char *pdst = (char *)dst;
-    const char *psrc = (const char *)src;
-    u64 tmp1, tmp2;
-    memcpy(&tmp1, psrc, 8);
-    memcpy(&tmp2, psrc + 8, 8);
-    memcpy(pdst, &tmp1, 8);
-    memcpy(pdst + 8, &tmp2, 8);
-}
-
-static_inline bool byte_match_2(void *buf, const char *pat) {
-    v16_uni u1, u2;
-    memcpy(&u1, buf, 2);
-    memcpy(&u2, pat, 2);
-    return u1.u == u2.u;
-}
-
-static_inline bool byte_match_4(void *buf, const char *pat) {
-    v32_uni u1, u2;
-    memcpy(&u1, buf, 4);
-    memcpy(&u2, pat, 4);
-    return u1.u == u2.u;
-}
-
-static_inline u16 byte_load_2(const void *src) {
-    v16_uni uni;
-    memcpy(&uni, src, 2);
-    return uni.u;
-}
-
-static_inline u32 byte_load_3(const void *src) {
-    v32_uni uni;
-    memcpy(&uni, src, 2);
-    uni.v.c[2] = ((const char *)src)[2];
-    uni.v.c[3] = 0;
-    return uni.u;
-}
-
-static_inline u32 byte_load_4(const void *src) {
-    v32_uni uni;
-    memcpy(&uni, src, 4);
-    return uni.u;
-}
-
-#endif
-
-
-
-/*==============================================================================
- * Number Utils
- * These functions are used to detect and convert NaN and Inf numbers.
- *============================================================================*/
-
-/** Convert raw binary to double. */
-static_inline f64 f64_from_raw(u64 u) {
-    /* use memcpy to avoid violating the strict aliasing rule */
-    f64 f;
-    memcpy(&f, &u, 8);
-    return f;
-}
-
-/** Convert double to raw binary. */
-static_inline u64 f64_to_raw(f64 f) {
-    /* use memcpy to avoid violating the strict aliasing rule */
-    u64 u;
-    memcpy(&u, &f, 8);
-    return u;
-}
-
-/** Get raw 'infinity' with sign. */
-static_inline u64 f64_raw_get_inf(bool sign) {
-#if YYJSON_HAS_IEEE_754
-    return F64_RAW_INF | ((u64)sign << 63);
-#elif defined(INFINITY)
-    return f64_to_raw(sign ? -INFINITY : INFINITY);
-#else
-    return f64_to_raw(sign ? -HUGE_VAL : HUGE_VAL);
-#endif
-}
-
-/** Get raw 'nan' with sign. */
-static_inline u64 f64_raw_get_nan(bool sign) {
-#if YYJSON_HAS_IEEE_754
-    return F64_RAW_NAN | ((u64)sign << 63);
-#elif defined(NAN)
-    return f64_to_raw(sign ? (f64)-NAN : (f64)NAN);
-#else
-    return f64_to_raw((sign ? -0.0 : 0.0) / 0.0);
-#endif
-}
-
-/**
- Convert normalized u64 (highest bit is 1) to f64.
-
- Some compiler (such as Microsoft Visual C++ 6.0) do not support converting
- number from u64 to f64. This function will first convert u64 to i64 and then
- to f64, with `to nearest` rounding mode.
- */
-static_inline f64 normalized_u64_to_f64(u64 val) {
-#if YYJSON_U64_TO_F64_NO_IMPL
-    i64 sig = (i64)((val >> 1) | (val & 1));
-    return ((f64)sig) * (f64)2.0;
-#else
-    return (f64)val;
-#endif
-}
-
-
-
-/*==============================================================================
- * Size Utils
- * These functions are used for memory allocation.
- *============================================================================*/
-
-/** Returns whether the size is overflow after increment. */
-static_inline bool size_add_is_overflow(usize size, usize add) {
-    return size > (size + add);
-}
-
-/** Returns whether the size is power of 2 (size should not be 0). */
-static_inline bool size_is_pow2(usize size) {
-    return (size & (size - 1)) == 0;
-}
-
-/** Align size upwards (may overflow). */
-static_inline usize size_align_up(usize size, usize align) {
-    if (size_is_pow2(align)) {
-        return (size + (align - 1)) & ~(align - 1);
-    } else {
-        return size + align - (size + align - 1) % align - 1;
-    }
-}
-
-/** Align size downwards. */
-static_inline usize size_align_down(usize size, usize align) {
-    if (size_is_pow2(align)) {
-        return size & ~(align - 1);
-    } else {
-        return size - (size % align);
-    }
-}
-
-/** Align address upwards (may overflow). */
-static_inline void *mem_align_up(void *mem, usize align) {
-    usize size;
-    memcpy(&size, &mem, sizeof(usize));
-    size = size_align_up(size, align);
-    memcpy(&mem, &size, sizeof(usize));
-    return mem;
-}
-
-
-
-/*==============================================================================
- * Bits Utils
- * These functions are used by the floating-point number reader and writer.
- *============================================================================*/
-
-/** Returns the number of leading 0-bits in value (input should not be 0). */
-static_inline u32 u64_lz_bits(u64 v) {
-#if GCC_HAS_CLZLL
-    return (u32)__builtin_clzll(v);
-#elif MSC_HAS_BIT_SCAN_64
-    unsigned long r;
-    _BitScanReverse64(&r, v);
-    return (u32)63 - (u32)r;
-#elif MSC_HAS_BIT_SCAN
-    unsigned long hi, lo;
-    bool hi_set = _BitScanReverse(&hi, (u32)(v >> 32)) != 0;
-    _BitScanReverse(&lo, (u32)v);
-    hi |= 32;
-    return (u32)63 - (u32)(hi_set ? hi : lo);
-#else
-    /*
-     branchless, use de Bruijn sequences
-     see: https://www.chessprogramming.org/BitScan
-     */
-    const u8 table[64] = {
-        63, 16, 62,  7, 15, 36, 61,  3,  6, 14, 22, 26, 35, 47, 60,  2,
-         9,  5, 28, 11, 13, 21, 42, 19, 25, 31, 34, 40, 46, 52, 59,  1,
-        17,  8, 37,  4, 23, 27, 48, 10, 29, 12, 43, 20, 32, 41, 53, 18,
-        38, 24, 49, 30, 44, 33, 54, 39, 50, 45, 55, 51, 56, 57, 58,  0
-    };
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    v |= v >> 32;
-    return table[(v * U64(0x03F79D71, 0xB4CB0A89)) >> 58];
-#endif
-}
-
-/** Returns the number of trailing 0-bits in value (input should not be 0). */
-static_inline u32 u64_tz_bits(u64 v) {
-#if GCC_HAS_CTZLL
-    return (u32)__builtin_ctzll(v);
-#elif MSC_HAS_BIT_SCAN_64
-    unsigned long r;
-    _BitScanForward64(&r, v);
-    return (u32)r;
-#elif MSC_HAS_BIT_SCAN
-    unsigned long lo, hi;
-    bool lo_set = _BitScanForward(&lo, (u32)(v)) != 0;
-    _BitScanForward(&hi, (u32)(v >> 32));
-    hi += 32;
-    return lo_set ? lo : hi;
-#else
-    /*
-     branchless, use de Bruijn sequences
-     see: https://www.chessprogramming.org/BitScan
-     */
-    const u8 table[64] = {
-         0,  1,  2, 53,  3,  7, 54, 27,  4, 38, 41,  8, 34, 55, 48, 28,
-        62,  5, 39, 46, 44, 42, 22,  9, 24, 35, 59, 56, 49, 18, 29, 11,
-        63, 52,  6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
-        51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
-    };
-    return table[((v & (~v + 1)) * U64(0x022FDD63, 0xCC95386D)) >> 58];
-#endif
-}
-
-
-
-/*==============================================================================
- * 128-bit Integer Utils
- * These functions are used by the floating-point number reader and writer.
- *============================================================================*/
-
-/** Multiplies two 64-bit unsigned integers (a * b),
-    returns the 128-bit result as 'hi' and 'lo'. */
-static_inline void u128_mul(u64 a, u64 b, u64 *hi, u64 *lo) {
-#if YYJSON_HAS_INT128
-    u128 m = (u128)a * b;
-    *hi = (u64)(m >> 64);
-    *lo = (u64)(m);
-#elif MSC_HAS_UMUL128
-    *lo = _umul128(a, b, hi);
-#else
-    u32 a0 = (u32)(a), a1 = (u32)(a >> 32);
-    u32 b0 = (u32)(b), b1 = (u32)(b >> 32);
-    u64 p00 = (u64)a0 * b0, p01 = (u64)a0 * b1;
-    u64 p10 = (u64)a1 * b0, p11 = (u64)a1 * b1;
-    u64 m0 = p01 + (p00 >> 32);
-    u32 m00 = (u32)(m0), m01 = (u32)(m0 >> 32);
-    u64 m1 = p10 + m00;
-    u32 m10 = (u32)(m1), m11 = (u32)(m1 >> 32);
-    *hi = p11 + m01 + m11;
-    *lo = ((u64)m10 << 32) | (u32)p00;
-#endif
-}
-
-/** Multiplies two 64-bit unsigned integers and add a value (a * b + c),
-    returns the 128-bit result as 'hi' and 'lo'. */
-static_inline void u128_mul_add(u64 a, u64 b, u64 c, u64 *hi, u64 *lo) {
-#if YYJSON_HAS_INT128
-    u128 m = (u128)a * b + c;
-    *hi = (u64)(m >> 64);
-    *lo = (u64)(m);
-#else
-    u64 h, l, t;
-    u128_mul(a, b, &h, &l);
-    t = l + c;
-    h += (u64)(((t < l) | (t < c)));
-    *hi = h;
-    *lo = t;
-#endif
-}
-
-
-
-/*==============================================================================
- * File Utils
- * These functions are used to read and write JSON files.
- *============================================================================*/
-
-#define YYJSON_FOPEN_EXT
-#if !defined(_MSC_VER) && defined(__GLIBC__) && defined(__GLIBC_PREREQ)
-#   if __GLIBC_PREREQ(2, 7)
-#       undef YYJSON_FOPEN_EXT
-#       define YYJSON_FOPEN_EXT "e" /* glibc extension to enable O_CLOEXEC */
-#   endif
-#endif
-
-static_inline FILE *fopen_safe(const char *path, const char *mode) {
-#if YYJSON_MSC_VER >= 1400
-    FILE *file = NULL;
-    if (fopen_s(&file, path, mode) != 0) return NULL;
-    return file;
-#else
-    return fopen(path, mode);
-#endif
-}
-
-static_inline FILE *fopen_readonly(const char *path) {
-    return fopen_safe(path, "rb" YYJSON_FOPEN_EXT);
-}
-
-static_inline FILE *fopen_writeonly(const char *path) {
-    return fopen_safe(path, "wb" YYJSON_FOPEN_EXT);
-}
-
-static_inline usize fread_safe(void *buf, usize size, FILE *file) {
-#if YYJSON_MSC_VER >= 1400
-    return fread_s(buf, size, 1, size, file);
-#else
-    return fread(buf, 1, size, file);
-#endif
-}
-
-
-
-/*==============================================================================
- * Default Memory Allocator
- * This is a simple libc memory allocator wrapper.
- *============================================================================*/
-
-static void *default_malloc(void *ctx, usize size) {
-    return malloc(size);
-}
-
-static void *default_realloc(void *ctx, void *ptr, usize old_size, usize size) {
-    return realloc(ptr, size);
-}
-
-static void default_free(void *ctx, void *ptr) {
-    free(ptr);
-}
-
-static const yyjson_alc YYJSON_DEFAULT_ALC = {
-    default_malloc,
-    default_realloc,
-    default_free,
-    NULL
-};
-
-
-
-/*==============================================================================
- * Null Memory Allocator
- *
- * This allocator is just a placeholder to ensure that the internal
- * malloc/realloc/free function pointers are not null.
- *============================================================================*/
-
-static void *null_malloc(void *ctx, usize size) {
-    return NULL;
-}
-
-static void *null_realloc(void *ctx, void *ptr, usize old_size, usize size) {
-    return NULL;
-}
-
-static void null_free(void *ctx, void *ptr) {
-    return;
-}
-
-static const yyjson_alc YYJSON_NULL_ALC = {
-    null_malloc,
-    null_realloc,
-    null_free,
-    NULL
-};
-
-
-
-/*==============================================================================
- * Pool Memory Allocator
- *
- * This allocator is initialized with a fixed-size buffer.
- * The buffer is split into multiple memory chunks for memory allocation.
- *============================================================================*/
-
-/** memory chunk header */
-typedef struct pool_chunk {
-    usize size; /* chunk memory size, include chunk header */
-    struct pool_chunk *next; /* linked list, nullable */
-    /* char mem[]; flexible array member */
-} pool_chunk;
-
-/** allocator ctx header */
-typedef struct pool_ctx {
-    usize size; /* total memory size, include ctx header */
-    pool_chunk *free_list; /* linked list, nullable */
-    /* pool_chunk chunks[]; flexible array member */
-} pool_ctx;
-
-/** align up the input size to chunk size */
-static_inline void pool_size_align(usize *size) {
-    *size = size_align_up(*size, sizeof(pool_chunk)) + sizeof(pool_chunk);
-}
-
-static void *pool_malloc(void *ctx_ptr, usize size) {
-    /* assert(size != 0) */
-    pool_ctx *ctx = (pool_ctx *)ctx_ptr;
-    pool_chunk *next, *prev = NULL, *cur = ctx->free_list;
-
-    if (unlikely(size >= ctx->size)) return NULL;
-    pool_size_align(&size);
-
-    while (cur) {
-        if (cur->size < size) {
-            /* not enough space, try next chunk */
-            prev = cur;
-            cur = cur->next;
-            continue;
-        }
-        if (cur->size >= size + sizeof(pool_chunk) * 2) {
-            /* too much space, split this chunk */
-            next = (pool_chunk *)(void *)((u8 *)cur + size);
-            next->size = cur->size - size;
-            next->next = cur->next;
-            cur->size = size;
-        } else {
-            /* just enough space, use whole chunk */
-            next = cur->next;
-        }
-        if (prev) prev->next = next;
-        else ctx->free_list = next;
-        return (void *)(cur + 1);
-    }
-    return NULL;
-}
-
-static void pool_free(void *ctx_ptr, void *ptr) {
-    /* assert(ptr != NULL) */
-    pool_ctx *ctx = (pool_ctx *)ctx_ptr;
-    pool_chunk *cur = ((pool_chunk *)ptr) - 1;
-    pool_chunk *prev = NULL, *next = ctx->free_list;
-
-    while (next && next < cur) {
-        prev = next;
-        next = next->next;
-    }
-    if (prev) prev->next = cur;
-    else ctx->free_list = cur;
-    cur->next = next;
-
-    if (next && ((u8 *)cur + cur->size) == (u8 *)next) {
-        /* merge cur to higher chunk */
-        cur->size += next->size;
-        cur->next = next->next;
-    }
-    if (prev && ((u8 *)prev + prev->size) == (u8 *)cur) {
-        /* merge cur to lower chunk */
-        prev->size += cur->size;
-        prev->next = cur->next;
-    }
-}
-
-static void *pool_realloc(void *ctx_ptr, void *ptr,
-                          usize old_size, usize size) {
-    /* assert(ptr != NULL && size != 0 && old_size < size) */
-    pool_ctx *ctx = (pool_ctx *)ctx_ptr;
-    pool_chunk *cur = ((pool_chunk *)ptr) - 1, *prev, *next, *tmp;
-
-    /* check size */
-    if (unlikely(size >= ctx->size)) return NULL;
-    pool_size_align(&old_size);
-    pool_size_align(&size);
-    if (unlikely(old_size == size)) return ptr;
-
-    /* find next and prev chunk */
-    prev = NULL;
-    next = ctx->free_list;
-    while (next && next < cur) {
-        prev = next;
-        next = next->next;
-    }
-
-    if ((u8 *)cur + cur->size == (u8 *)next && cur->size + next->size >= size) {
-        /* merge to higher chunk if they are contiguous */
-        usize free_size = cur->size + next->size - size;
-        if (free_size > sizeof(pool_chunk) * 2) {
-            tmp = (pool_chunk *)(void *)((u8 *)cur + size);
-            if (prev) prev->next = tmp;
-            else ctx->free_list = tmp;
-            tmp->next = next->next;
-            tmp->size = free_size;
-            cur->size = size;
-        } else {
-            if (prev) prev->next = next->next;
-            else ctx->free_list = next->next;
-            cur->size += next->size;
-        }
-        return ptr;
-    } else {
-        /* fallback to malloc and memcpy */
-        void *new_ptr = pool_malloc(ctx_ptr, size - sizeof(pool_chunk));
-        if (new_ptr) {
-            memcpy(new_ptr, ptr, cur->size - sizeof(pool_chunk));
-            pool_free(ctx_ptr, ptr);
-        }
-        return new_ptr;
-    }
-}
-
-bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, usize size) {
-    pool_chunk *chunk;
-    pool_ctx *ctx;
-
-    if (unlikely(!alc)) return false;
-    *alc = YYJSON_NULL_ALC;
-    if (size < sizeof(pool_ctx) * 4) return false;
-    ctx = (pool_ctx *)mem_align_up(buf, sizeof(pool_ctx));
-    if (unlikely(!ctx)) return false;
-    size -= (usize)((u8 *)ctx - (u8 *)buf);
-    size = size_align_down(size, sizeof(pool_ctx));
-
-    chunk = (pool_chunk *)(ctx + 1);
-    chunk->size = size - sizeof(pool_ctx);
-    chunk->next = NULL;
-    ctx->size = size;
-    ctx->free_list = chunk;
-
-    alc->malloc = pool_malloc;
-    alc->realloc = pool_realloc;
-    alc->free = pool_free;
-    alc->ctx = (void *)ctx;
-    return true;
-}
-
-
-
-/*==============================================================================
- * Dynamic Memory Allocator
- *
- * This allocator allocates memory on demand and does not immediately release
- * unused memory. Instead, it places the unused memory into a freelist for
- * potential reuse in the future. It is only when the entire allocator is
- * destroyed that all previously allocated memory is released at once.
- *============================================================================*/
-
-/** memory chunk header */
-typedef struct dyn_chunk {
-    usize size; /* chunk size, include header */
-    struct dyn_chunk *next;
-    /* char mem[]; flexible array member */
-} dyn_chunk;
-
-/** allocator ctx header */
-typedef struct {
-    dyn_chunk free_list; /* dummy header, sorted from small to large */
-    dyn_chunk used_list; /* dummy header */
-} dyn_ctx;
-
-/** align up the input size to chunk size */
-static_inline bool dyn_size_align(usize *size) {
-    usize alc_size = *size + sizeof(dyn_chunk);
-    alc_size = size_align_up(alc_size, YYJSON_ALC_DYN_MIN_SIZE);
-    if (unlikely(alc_size < *size)) return false; /* overflow */
-    *size = alc_size;
-    return true;
-}
-
-/** remove a chunk from list (the chunk must already be in the list) */
-static_inline void dyn_chunk_list_remove(dyn_chunk *list, dyn_chunk *chunk) {
-    dyn_chunk *prev = list, *cur;
-    for (cur = prev->next; cur; cur = cur->next) {
-        if (cur == chunk) {
-            prev->next = cur->next;
-            cur->next = NULL;
-            return;
-        }
-        prev = cur;
-    }
-}
-
-/** add a chunk to list header (the chunk must not be in the list) */
-static_inline void dyn_chunk_list_add(dyn_chunk *list, dyn_chunk *chunk) {
-    chunk->next = list->next;
-    list->next = chunk;
-}
-
-static void *dyn_malloc(void *ctx_ptr, usize size) {
-    /* assert(size != 0) */
-    const yyjson_alc def = YYJSON_DEFAULT_ALC;
-    dyn_ctx *ctx = (dyn_ctx *)ctx_ptr;
-    dyn_chunk *chunk, *prev, *next;
-    if (unlikely(!dyn_size_align(&size))) return NULL;
-
-    /* freelist is empty, create new chunk */
-    if (!ctx->free_list.next) {
-        chunk = (dyn_chunk *)def.malloc(def.ctx, size);
-        if (unlikely(!chunk)) return NULL;
-        chunk->size = size;
-        chunk->next = NULL;
-        dyn_chunk_list_add(&ctx->used_list, chunk);
-        return (void *)(chunk + 1);
-    }
-
-    /* find a large enough chunk, or resize the largest chunk */
-    prev = &ctx->free_list;
-    while (true) {
-        chunk = prev->next;
-        if (chunk->size >= size) { /* enough size, reuse this chunk */
-            prev->next = chunk->next;
-            dyn_chunk_list_add(&ctx->used_list, chunk);
-            return (void *)(chunk + 1);
-        }
-        if (!chunk->next) { /* resize the largest chunk */
-            chunk = (dyn_chunk *)def.realloc(def.ctx, chunk, chunk->size, size);
-            if (unlikely(!chunk)) return NULL;
-            prev->next = NULL;
-            chunk->size = size;
-            dyn_chunk_list_add(&ctx->used_list, chunk);
-            return (void *)(chunk + 1);
-        }
-        prev = chunk;
-    }
-}
-
-static void *dyn_realloc(void *ctx_ptr, void *ptr,
-                          usize old_size, usize size) {
-    /* assert(ptr != NULL && size != 0 && old_size < size) */
-    const yyjson_alc def = YYJSON_DEFAULT_ALC;
-    dyn_ctx *ctx = (dyn_ctx *)ctx_ptr;
-    dyn_chunk *prev, *next, *new_chunk;
-    dyn_chunk *chunk = (dyn_chunk *)ptr - 1;
-    if (unlikely(!dyn_size_align(&size))) return NULL;
-    if (chunk->size >= size) return ptr;
-
-    dyn_chunk_list_remove(&ctx->used_list, chunk);
-    new_chunk = (dyn_chunk *)def.realloc(def.ctx, chunk, chunk->size, size);
-    if (likely(new_chunk)) {
-        new_chunk->size = size;
-        chunk = new_chunk;
-    }
-    dyn_chunk_list_add(&ctx->used_list, chunk);
-    return new_chunk ? (void *)(new_chunk + 1) : NULL;
-}
-
-static void dyn_free(void *ctx_ptr, void *ptr) {
-    /* assert(ptr != NULL) */
-    dyn_ctx *ctx = (dyn_ctx *)ctx_ptr;
-    dyn_chunk *chunk = (dyn_chunk *)ptr - 1, *prev;
-
-    dyn_chunk_list_remove(&ctx->used_list, chunk);
-    for (prev = &ctx->free_list; prev; prev = prev->next) {
-        if (!prev->next || prev->next->size >= chunk->size) {
-            chunk->next = prev->next;
-            prev->next = chunk;
-            break;
-        }
-    }
-}
-
-yyjson_alc *yyjson_alc_dyn_new(void) {
-    const yyjson_alc def = YYJSON_DEFAULT_ALC;
-    usize hdr_len = sizeof(yyjson_alc) + sizeof(dyn_ctx);
-    yyjson_alc *alc = (yyjson_alc *)def.malloc(def.ctx, hdr_len);
-    dyn_ctx *ctx = (dyn_ctx *)(void *)(alc + 1);
-    if (unlikely(!alc)) return NULL;
-    alc->malloc = dyn_malloc;
-    alc->realloc = dyn_realloc;
-    alc->free = dyn_free;
-    alc->ctx = alc + 1;
-    memset(ctx, 0, sizeof(*ctx));
-    return alc;
-}
-
-void yyjson_alc_dyn_free(yyjson_alc *alc) {
-    const yyjson_alc def = YYJSON_DEFAULT_ALC;
-    dyn_ctx *ctx = (dyn_ctx *)(void *)(alc + 1);
-    dyn_chunk *chunk, *next;
-    if (unlikely(!alc)) return;
-    for (chunk = ctx->free_list.next; chunk; chunk = next) {
-        next = chunk->next;
-        def.free(def.ctx, chunk);
-    }
-    for (chunk = ctx->used_list.next; chunk; chunk = next) {
-        next = chunk->next;
-        def.free(def.ctx, chunk);
-    }
-    def.free(def.ctx, alc);
-}
-
-
-
-/*==============================================================================
- * JSON document and value
- *============================================================================*/
-
-static_inline void unsafe_yyjson_str_pool_release(yyjson_str_pool *pool,
-                                                  yyjson_alc *alc) {
-    yyjson_str_chunk *chunk = pool->chunks, *next;
-    while (chunk) {
-        next = chunk->next;
-        alc->free(alc->ctx, chunk);
-        chunk = next;
-    }
-}
-
-static_inline void unsafe_yyjson_val_pool_release(yyjson_val_pool *pool,
-                                                  yyjson_alc *alc) {
-    yyjson_val_chunk *chunk = pool->chunks, *next;
-    while (chunk) {
-        next = chunk->next;
-        alc->free(alc->ctx, chunk);
-        chunk = next;
-    }
-}
-
-bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool,
-                                 const yyjson_alc *alc, usize len) {
-    yyjson_str_chunk *chunk;
-    usize size, max_len;
-
-    /* create a new chunk */
-    max_len = USIZE_MAX - sizeof(yyjson_str_chunk);
-    if (unlikely(len > max_len)) return false;
-    size = len + sizeof(yyjson_str_chunk);
-    size = yyjson_max(pool->chunk_size, size);
-    chunk = (yyjson_str_chunk *)alc->malloc(alc->ctx, size);
-    if (unlikely(!chunk)) return false;
-
-    /* insert the new chunk as the head of the linked list */
-    chunk->next = pool->chunks;
-    chunk->chunk_size = size;
-    pool->chunks = chunk;
-    pool->cur = (char *)chunk + sizeof(yyjson_str_chunk);
-    pool->end = (char *)chunk + size;
-
-    /* the next chunk is twice the size of the current one */
-    size = yyjson_min(pool->chunk_size * 2, pool->chunk_size_max);
-    if (size < pool->chunk_size) size = pool->chunk_size_max; /* overflow */
-    pool->chunk_size = size;
-    return true;
-}
-
-bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool,
-                                 const yyjson_alc *alc, usize count) {
-    yyjson_val_chunk *chunk;
-    usize size, max_count;
-
-    /* create a new chunk */
-    max_count = USIZE_MAX / sizeof(yyjson_mut_val) - 1;
-    if (unlikely(count > max_count)) return false;
-    size = (count + 1) * sizeof(yyjson_mut_val);
-    size = yyjson_max(pool->chunk_size, size);
-    chunk = (yyjson_val_chunk *)alc->malloc(alc->ctx, size);
-    if (unlikely(!chunk)) return false;
-
-    /* insert the new chunk as the head of the linked list */
-    chunk->next = pool->chunks;
-    chunk->chunk_size = size;
-    pool->chunks = chunk;
-    pool->cur = (yyjson_mut_val *)(void *)((u8 *)chunk) + 1;
-    pool->end = (yyjson_mut_val *)(void *)((u8 *)chunk + size);
-
-    /* the next chunk is twice the size of the current one */
-    size = yyjson_min(pool->chunk_size * 2, pool->chunk_size_max);
-    if (size < pool->chunk_size) size = pool->chunk_size_max; /* overflow */
-    pool->chunk_size = size;
-    return true;
-}
-
-bool yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc *doc, size_t len) {
-    usize max_size = USIZE_MAX - sizeof(yyjson_str_chunk);
-    if (!doc || !len || len > max_size) return false;
-    doc->str_pool.chunk_size = len + sizeof(yyjson_str_chunk);
-    return true;
-}
-
-bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc, size_t count) {
-    usize max_count = USIZE_MAX / sizeof(yyjson_mut_val) - 1;
-    if (!doc || !count || count > max_count) return false;
-    doc->val_pool.chunk_size = (count + 1) * sizeof(yyjson_mut_val);
-    return true;
-}
-
-void yyjson_mut_doc_free(yyjson_mut_doc *doc) {
-    if (doc) {
-        yyjson_alc alc = doc->alc;
-        memset(&doc->alc, 0, sizeof(alc));
-        unsafe_yyjson_str_pool_release(&doc->str_pool, &alc);
-        unsafe_yyjson_val_pool_release(&doc->val_pool, &alc);
-        alc.free(alc.ctx, doc);
-    }
-}
-
-yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc) {
-    yyjson_mut_doc *doc;
-    if (!alc) alc = &YYJSON_DEFAULT_ALC;
-    doc = (yyjson_mut_doc *)alc->malloc(alc->ctx, sizeof(yyjson_mut_doc));
-    if (!doc) return NULL;
-    memset(doc, 0, sizeof(yyjson_mut_doc));
-
-    doc->alc = *alc;
-    doc->str_pool.chunk_size = YYJSON_MUT_DOC_STR_POOL_INIT_SIZE;
-    doc->str_pool.chunk_size_max = YYJSON_MUT_DOC_STR_POOL_MAX_SIZE;
-    doc->val_pool.chunk_size = YYJSON_MUT_DOC_VAL_POOL_INIT_SIZE;
-    doc->val_pool.chunk_size_max = YYJSON_MUT_DOC_VAL_POOL_MAX_SIZE;
-    return doc;
-}
-
-yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc, const yyjson_alc *alc) {
-    yyjson_mut_doc *m_doc;
-    yyjson_mut_val *m_val;
-
-    if (!doc || !doc->root) return NULL;
-    m_doc = yyjson_mut_doc_new(alc);
-    if (!m_doc) return NULL;
-    m_val = yyjson_val_mut_copy(m_doc, doc->root);
-    if (!m_val) {
-        yyjson_mut_doc_free(m_doc);
-        return NULL;
-    }
-    yyjson_mut_doc_set_root(m_doc, m_val);
-    return m_doc;
-}
-
-yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc,
-                                        const yyjson_alc *alc) {
-    yyjson_mut_doc *m_doc;
-    yyjson_mut_val *m_val;
-
-    if (!doc) return NULL;
-    if (!doc->root) return yyjson_mut_doc_new(alc);
-
-    m_doc = yyjson_mut_doc_new(alc);
-    if (!m_doc) return NULL;
-    m_val = yyjson_mut_val_mut_copy(m_doc, doc->root);
-    if (!m_val) {
-        yyjson_mut_doc_free(m_doc);
-        return NULL;
-    }
-    yyjson_mut_doc_set_root(m_doc, m_val);
-    return m_doc;
-}
-
-yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *m_doc,
-                                    yyjson_val *i_vals) {
-    /*
-     The immutable object or array stores all sub-values in a contiguous memory,
-     We copy them to another contiguous memory as mutable values,
-     then reconnect the mutable values with the original relationship.
-     */
-    usize i_vals_len;
-    yyjson_mut_val *m_vals, *m_val;
-    yyjson_val *i_val, *i_end;
-
-    if (!m_doc || !i_vals) return NULL;
-    i_end = unsafe_yyjson_get_next(i_vals);
-    i_vals_len = (usize)(unsafe_yyjson_get_next(i_vals) - i_vals);
-    m_vals = unsafe_yyjson_mut_val(m_doc, i_vals_len);
-    if (!m_vals) return NULL;
-    i_val = i_vals;
-    m_val = m_vals;
-
-    for (; i_val < i_end; i_val++, m_val++) {
-        yyjson_type type = unsafe_yyjson_get_type(i_val);
-        m_val->tag = i_val->tag;
-        m_val->uni.u64 = i_val->uni.u64;
-        if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) {
-            const char *str = i_val->uni.str;
-            usize str_len = unsafe_yyjson_get_len(i_val);
-            m_val->uni.str = unsafe_yyjson_mut_strncpy(m_doc, str, str_len);
-            if (!m_val->uni.str) return NULL;
-        } else if (type == YYJSON_TYPE_ARR) {
-            usize len = unsafe_yyjson_get_len(i_val);
-            if (len > 0) {
-                yyjson_val *ii_val = i_val + 1, *ii_next;
-                yyjson_mut_val *mm_val = m_val + 1, *mm_ctn = m_val, *mm_next;
-                while (len-- > 1) {
-                    ii_next = unsafe_yyjson_get_next(ii_val);
-                    mm_next = mm_val + (ii_next - ii_val);
-                    mm_val->next = mm_next;
-                    ii_val = ii_next;
-                    mm_val = mm_next;
-                }
-                mm_val->next = mm_ctn + 1;
-                mm_ctn->uni.ptr = mm_val;
-            }
-        } else if (type == YYJSON_TYPE_OBJ) {
-            usize len = unsafe_yyjson_get_len(i_val);
-            if (len > 0) {
-                yyjson_val *ii_key = i_val + 1, *ii_nextkey;
-                yyjson_mut_val *mm_key = m_val + 1, *mm_ctn = m_val;
-                yyjson_mut_val *mm_nextkey;
-                while (len-- > 1) {
-                    ii_nextkey = unsafe_yyjson_get_next(ii_key + 1);
-                    mm_nextkey = mm_key + (ii_nextkey - ii_key);
-                    mm_key->next = mm_key + 1;
-                    mm_key->next->next = mm_nextkey;
-                    ii_key = ii_nextkey;
-                    mm_key = mm_nextkey;
-                }
-                mm_key->next = mm_key + 1;
-                mm_key->next->next = mm_ctn + 1;
-                mm_ctn->uni.ptr = mm_key;
-            }
-        }
-    }
-
-    return m_vals;
-}
-
-static yyjson_mut_val *unsafe_yyjson_mut_val_mut_copy(yyjson_mut_doc *m_doc,
-                                                      yyjson_mut_val *m_vals) {
-    /*
-     The mutable object or array stores all sub-values in a circular linked
-     list, so we can traverse them in the same loop. The traversal starts from
-     the last item, continues with the first item in a list, and ends with the
-     second to last item, which needs to be linked to the last item to close the
-     circle.
-     */
-    yyjson_mut_val *m_val = unsafe_yyjson_mut_val(m_doc, 1);
-    if (unlikely(!m_val)) return NULL;
-    m_val->tag = m_vals->tag;
-
-    switch (unsafe_yyjson_get_type(m_vals)) {
-        case YYJSON_TYPE_OBJ:
-        case YYJSON_TYPE_ARR:
-            if (unsafe_yyjson_get_len(m_vals) > 0) {
-                yyjson_mut_val *last = (yyjson_mut_val *)m_vals->uni.ptr;
-                yyjson_mut_val *next = last->next, *prev;
-                prev = unsafe_yyjson_mut_val_mut_copy(m_doc, last);
-                if (!prev) return NULL;
-                m_val->uni.ptr = (void *)prev;
-                while (next != last) {
-                    prev->next = unsafe_yyjson_mut_val_mut_copy(m_doc, next);
-                    if (!prev->next) return NULL;
-                    prev = prev->next;
-                    next = next->next;
-                }
-                prev->next = (yyjson_mut_val *)m_val->uni.ptr;
-            }
-            break;
-
-        case YYJSON_TYPE_RAW:
-        case YYJSON_TYPE_STR: {
-            const char *str = m_vals->uni.str;
-            usize str_len = unsafe_yyjson_get_len(m_vals);
-            m_val->uni.str = unsafe_yyjson_mut_strncpy(m_doc, str, str_len);
-            if (!m_val->uni.str) return NULL;
-            break;
-        }
-
-        default:
-            m_val->uni = m_vals->uni;
-            break;
-    }
-
-    return m_val;
-}
-
-yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc,
-                                        yyjson_mut_val *val) {
-    if (doc && val) return unsafe_yyjson_mut_val_mut_copy(doc, val);
-    return NULL;
-}
-
-/* Count the number of values and the total length of the strings. */
-static void yyjson_mut_stat(yyjson_mut_val *val,
-                            usize *val_sum, usize *str_sum) {
-    yyjson_type type = unsafe_yyjson_get_type(val);
-    *val_sum += 1;
-    if (type == YYJSON_TYPE_ARR || type == YYJSON_TYPE_OBJ) {
-        yyjson_mut_val *child = (yyjson_mut_val *)val->uni.ptr;
-        usize len = unsafe_yyjson_get_len(val), i;
-        len <<= (u8)(type == YYJSON_TYPE_OBJ);
-        *val_sum += len;
-        for (i = 0; i < len; i++) {
-            yyjson_type stype = unsafe_yyjson_get_type(child);
-            if (stype == YYJSON_TYPE_STR || stype == YYJSON_TYPE_RAW) {
-                *str_sum += unsafe_yyjson_get_len(child) + 1;
-            } else if (stype == YYJSON_TYPE_ARR || stype == YYJSON_TYPE_OBJ) {
-                yyjson_mut_stat(child, val_sum, str_sum);
-                *val_sum -= 1;
-            }
-            child = child->next;
-        }
-    } else if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) {
-        *str_sum += unsafe_yyjson_get_len(val) + 1;
-    }
-}
-
-/* Copy mutable values to immutable value pool. */
-static usize yyjson_imut_copy(yyjson_val **val_ptr, char **buf_ptr,
-                              yyjson_mut_val *mval) {
-    yyjson_val *val = *val_ptr;
-    yyjson_type type = unsafe_yyjson_get_type(mval);
-    if (type == YYJSON_TYPE_ARR || type == YYJSON_TYPE_OBJ) {
-        yyjson_mut_val *child = (yyjson_mut_val *)mval->uni.ptr;
-        usize len = unsafe_yyjson_get_len(mval), i;
-        usize val_sum = 1;
-        if (type == YYJSON_TYPE_OBJ) {
-            if (len) child = child->next->next;
-            len <<= 1;
-        } else {
-            if (len) child = child->next;
-        }
-        *val_ptr = val + 1;
-        for (i = 0; i < len; i++) {
-            val_sum += yyjson_imut_copy(val_ptr, buf_ptr, child);
-            child = child->next;
-        }
-        val->tag = mval->tag;
-        val->uni.ofs = val_sum * sizeof(yyjson_val);
-        return val_sum;
-    } else if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) {
-        char *buf = *buf_ptr;
-        usize len = unsafe_yyjson_get_len(mval);
-        memcpy((void *)buf, (const void *)mval->uni.str, len);
-        buf[len] = '\0';
-        val->tag = mval->tag;
-        val->uni.str = buf;
-        *val_ptr = val + 1;
-        *buf_ptr = buf + len + 1;
-        return 1;
-    } else {
-        val->tag = mval->tag;
-        val->uni = mval->uni;
-        *val_ptr = val + 1;
-        return 1;
-    }
-}
-
-yyjson_doc *yyjson_mut_doc_imut_copy(yyjson_mut_doc *mdoc,
-                                     const yyjson_alc *alc) {
-    if (!mdoc) return NULL;
-    return yyjson_mut_val_imut_copy(mdoc->root, alc);
-}
-
-yyjson_doc *yyjson_mut_val_imut_copy(yyjson_mut_val *mval,
-                                     const yyjson_alc *alc) {
-    usize val_num = 0, str_sum = 0, hdr_size, buf_size;
-    yyjson_doc *doc = NULL;
-    yyjson_val *val_hdr = NULL;
-
-    /* This value should be NULL here. Setting a non-null value suppresses
-       warning from the clang analyzer. */
-    char *str_hdr = (char *)(void *)&str_sum;
-    if (!mval) return NULL;
-    if (!alc) alc = &YYJSON_DEFAULT_ALC;
-
-    /* traverse the input value to get pool size */
-    yyjson_mut_stat(mval, &val_num, &str_sum);
-
-    /* create doc and val pool */
-    hdr_size = size_align_up(sizeof(yyjson_doc), sizeof(yyjson_val));
-    buf_size = hdr_size + val_num * sizeof(yyjson_val);
-    doc = (yyjson_doc *)alc->malloc(alc->ctx, buf_size);
-    if (!doc) return NULL;
-    memset(doc, 0, sizeof(yyjson_doc));
-    val_hdr = (yyjson_val *)(void *)((char *)(void *)doc + hdr_size);
-    doc->root = val_hdr;
-    doc->alc = *alc;
-
-    /* create str pool */
-    if (str_sum > 0) {
-        str_hdr = (char *)alc->malloc(alc->ctx, str_sum);
-        doc->str_pool = str_hdr;
-        if (!str_hdr) {
-            alc->free(alc->ctx, (void *)doc);
-            return NULL;
-        }
-    }
-
-    /* copy vals and strs */
-    doc->val_read = yyjson_imut_copy(&val_hdr, &str_hdr, mval);
-    doc->dat_read = str_sum + 1;
-    return doc;
-}
-
-static_inline bool unsafe_yyjson_num_equals(void *lhs, void *rhs) {
-    yyjson_val_uni *luni = &((yyjson_val *)lhs)->uni;
-    yyjson_val_uni *runi = &((yyjson_val *)rhs)->uni;
-    yyjson_subtype lt = unsafe_yyjson_get_subtype(lhs);
-    yyjson_subtype rt = unsafe_yyjson_get_subtype(rhs);
-    if (lt == rt) return luni->u64 == runi->u64;
-    if (lt == YYJSON_SUBTYPE_SINT && rt == YYJSON_SUBTYPE_UINT) {
-        return luni->i64 >= 0 && luni->u64 == runi->u64;
-    }
-    if (lt == YYJSON_SUBTYPE_UINT && rt == YYJSON_SUBTYPE_SINT) {
-        return runi->i64 >= 0 && luni->u64 == runi->u64;
-    }
-    return false;
-}
-
-static_inline bool unsafe_yyjson_str_equals(void *lhs, void *rhs) {
-    usize len = unsafe_yyjson_get_len(lhs);
-    if (len != unsafe_yyjson_get_len(rhs)) return false;
-    return !memcmp(unsafe_yyjson_get_str(lhs),
-                   unsafe_yyjson_get_str(rhs), len);
-}
-
-bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) {
-    yyjson_type type = unsafe_yyjson_get_type(lhs);
-    if (type != unsafe_yyjson_get_type(rhs)) return false;
-
-    switch (type) {
-        case YYJSON_TYPE_OBJ: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                yyjson_obj_iter iter;
-                yyjson_obj_iter_init(rhs, &iter);
-                lhs = unsafe_yyjson_get_first(lhs);
-                while (len-- > 0) {
-                    rhs = yyjson_obj_iter_getn(&iter, lhs->uni.str,
-                                               unsafe_yyjson_get_len(lhs));
-                    if (!rhs) return false;
-                    if (!unsafe_yyjson_equals(lhs + 1, rhs)) return false;
-                    lhs = unsafe_yyjson_get_next(lhs + 1);
-                }
-            }
-            /* yyjson allows duplicate keys, so the check may be inaccurate */
-            return true;
-        }
-
-        case YYJSON_TYPE_ARR: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                lhs = unsafe_yyjson_get_first(lhs);
-                rhs = unsafe_yyjson_get_first(rhs);
-                while (len-- > 0) {
-                    if (!unsafe_yyjson_equals(lhs, rhs)) return false;
-                    lhs = unsafe_yyjson_get_next(lhs);
-                    rhs = unsafe_yyjson_get_next(rhs);
-                }
-            }
-            return true;
-        }
-
-        case YYJSON_TYPE_NUM:
-            return unsafe_yyjson_num_equals(lhs, rhs);
-
-        case YYJSON_TYPE_RAW:
-        case YYJSON_TYPE_STR:
-            return unsafe_yyjson_str_equals(lhs, rhs);
-
-        case YYJSON_TYPE_NULL:
-        case YYJSON_TYPE_BOOL:
-            return lhs->tag == rhs->tag;
-
-        default:
-            return false;
-    }
-}
-
-bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs, yyjson_mut_val *rhs) {
-    yyjson_type type = unsafe_yyjson_get_type(lhs);
-    if (type != unsafe_yyjson_get_type(rhs)) return false;
-
-    switch (type) {
-        case YYJSON_TYPE_OBJ: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                yyjson_mut_obj_iter iter;
-                yyjson_mut_obj_iter_init(rhs, &iter);
-                lhs = (yyjson_mut_val *)lhs->uni.ptr;
-                while (len-- > 0) {
-                    rhs = yyjson_mut_obj_iter_getn(&iter, lhs->uni.str,
-                                                   unsafe_yyjson_get_len(lhs));
-                    if (!rhs) return false;
-                    if (!unsafe_yyjson_mut_equals(lhs->next, rhs)) return false;
-                    lhs = lhs->next->next;
-                }
-            }
-            /* yyjson allows duplicate keys, so the check may be inaccurate */
-            return true;
-        }
-
-        case YYJSON_TYPE_ARR: {
-            usize len = unsafe_yyjson_get_len(lhs);
-            if (len != unsafe_yyjson_get_len(rhs)) return false;
-            if (len > 0) {
-                lhs = (yyjson_mut_val *)lhs->uni.ptr;
-                rhs = (yyjson_mut_val *)rhs->uni.ptr;
-                while (len-- > 0) {
-                    if (!unsafe_yyjson_mut_equals(lhs, rhs)) return false;
-                    lhs = lhs->next;
-                    rhs = rhs->next;
-                }
-            }
-            return true;
-        }
-
-        case YYJSON_TYPE_NUM:
-            return unsafe_yyjson_num_equals(lhs, rhs);
-
-        case YYJSON_TYPE_RAW:
-        case YYJSON_TYPE_STR:
-            return unsafe_yyjson_str_equals(lhs, rhs);
-
-        case YYJSON_TYPE_NULL:
-        case YYJSON_TYPE_BOOL:
-            return lhs->tag == rhs->tag;
-
-        default:
-            return false;
-    }
-}
-
-
-
-#if !YYJSON_DISABLE_UTILS
-
-/*==============================================================================
- * JSON Pointer API (RFC 6901)
- *============================================================================*/
-
-/**
- Get a token from JSON pointer string.
- @param ptr [in,out]
-                in:  string that points to current token prefix `/`
-                out: string that points to next token prefix `/`, or string end
- @param end [in] end of the entire JSON Pointer string
- @param len [out] unescaped token length
- @param esc [out] number of escaped characters in this token
- @return head of the token, or NULL if syntax error
- */
-static_inline const char *ptr_next_token(const char **ptr, const char *end,
-                                         usize *len, usize *esc) {
-    const char *hdr = *ptr + 1;
-    const char *cur = hdr;
-    /* skip unescaped characters */
-    while (cur < end && *cur != '/' && *cur != '~') cur++;
-    if (likely(cur == end || *cur != '~')) {
-        /* no escaped characters, return */
-        *ptr = cur;
-        *len = (usize)(cur - hdr);
-        *esc = 0;
-        return hdr;
-    } else {
-        /* handle escaped characters */
-        usize esc_num = 0;
-        while (cur < end && *cur != '/') {
-            if (*cur++ == '~') {
-                if (cur == end || (*cur != '0' && *cur != '1')) {
-                    *ptr = cur - 1;
-                    return NULL;
-                }
-                esc_num++;
-            }
-        }
-        *ptr = cur;
-        *len = (usize)(cur - hdr) - esc_num;
-        *esc = esc_num;
-        return hdr;
-    }
-}
-
-/**
- Convert token string to index.
- @param cur [in]  token head
- @param len [in]  token length
- @param idx [out] the index number, or USIZE_MAX if token is '-'
- @return true if token is a valid array index
- */
-static_inline bool ptr_token_to_idx(const char *cur, usize len, usize *idx) {
-    const char *end = cur + len;
-    usize num = 0, add;
-    if (unlikely(len == 0 || len > USIZE_SAFE_DIG)) return false;
-    if (*cur == '0') {
-        if (unlikely(len > 1)) return false;
-        *idx = 0;
-        return true;
-    }
-    if (*cur == '-') {
-        if (unlikely(len > 1)) return false;
-        *idx = USIZE_MAX;
-        return true;
-    }
-    for (; cur < end && (add = (usize)((u8)*cur - (u8)'0')) <= 9; cur++) {
-        num = num * 10 + add;
-    }
-    if (unlikely(num == 0 || cur < end)) return false;
-    *idx = num;
-    return true;
-}
-
-/**
- Compare JSON key with token.
- @param key a string key (yyjson_val or yyjson_mut_val)
- @param token a JSON pointer token
- @param len unescaped token length
- @param esc number of escaped characters in this token
- @return true if `str` is equals to `token`
- */
-static_inline bool ptr_token_eq(void *key,
-                                const char *token, usize len, usize esc) {
-    yyjson_val *val = (yyjson_val *)key;
-    if (unsafe_yyjson_get_len(val) != len) return false;
-    if (likely(!esc)) {
-        return memcmp(val->uni.str, token, len) == 0;
-    } else {
-        const char *str = val->uni.str;
-        for (; len-- > 0; token++, str++) {
-            if (*token == '~') {
-                if (*str != (*++token == '0' ? '~' : '/')) return false;
-            } else {
-                if (*str != *token) return false;
-            }
-        }
-        return true;
-    }
-}
-
-/**
- Get a value from array by token.
- @param arr   an array, should not be NULL or non-array type
- @param token a JSON pointer token
- @param len   unescaped token length
- @param esc   number of escaped characters in this token
- @return value at index, or NULL if token is not index or index is out of range
- */
-static_inline yyjson_val *ptr_arr_get(yyjson_val *arr, const char *token,
-                                      usize len, usize esc) {
-    yyjson_val *val = unsafe_yyjson_get_first(arr);
-    usize num = unsafe_yyjson_get_len(arr), idx = 0;
-    if (unlikely(num == 0)) return NULL;
-    if (unlikely(!ptr_token_to_idx(token, len, &idx))) return NULL;
-    if (unlikely(idx >= num)) return NULL;
-    if (unsafe_yyjson_arr_is_flat(arr)) {
-        return val + idx;
-    } else {
-        while (idx-- > 0) val = unsafe_yyjson_get_next(val);
-        return val;
-    }
-}
-
-/**
- Get a value from object by token.
- @param obj   [in] an object, should not be NULL or non-object type
- @param token [in] a JSON pointer token
- @param len   [in] unescaped token length
- @param esc   [in] number of escaped characters in this token
- @return value associated with the token, or NULL if no value
- */
-static_inline yyjson_val *ptr_obj_get(yyjson_val *obj, const char *token,
-                                      usize len, usize esc) {
-    yyjson_val *key = unsafe_yyjson_get_first(obj);
-    usize num = unsafe_yyjson_get_len(obj);
-    if (unlikely(num == 0)) return NULL;
-    for (; num > 0; num--, key = unsafe_yyjson_get_next(key + 1)) {
-        if (ptr_token_eq(key, token, len, esc)) return key + 1;
-    }
-    return NULL;
-}
-
-/**
- Get a value from array by token.
- @param arr   [in] an array, should not be NULL or non-array type
- @param token [in] a JSON pointer token
- @param len   [in] unescaped token length
- @param esc   [in] number of escaped characters in this token
- @param pre   [out] previous (sibling) value of the returned value
- @param last  [out] whether index is last
- @return value at index, or NULL if token is not index or index is out of range
- */
-static_inline yyjson_mut_val *ptr_mut_arr_get(yyjson_mut_val *arr,
-                                              const char *token,
-                                              usize len, usize esc,
-                                              yyjson_mut_val **pre,
-                                              bool *last) {
-    yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr; /* last (tail) */
-    usize num = unsafe_yyjson_get_len(arr), idx;
-    if (last) *last = false;
-    if (pre) *pre = NULL;
-    if (unlikely(num == 0)) {
-        if (last && len == 1 && (*token == '0' || *token == '-')) *last = true;
-        return NULL;
-    }
-    if (unlikely(!ptr_token_to_idx(token, len, &idx))) return NULL;
-    if (last) *last = (idx == num || idx == USIZE_MAX);
-    if (unlikely(idx >= num)) return NULL;
-    while (idx-- > 0) val = val->next;
-    *pre = val;
-    return val->next;
-}
-
-/**
- Get a value from object by token.
- @param obj   [in] an object, should not be NULL or non-object type
- @param token [in] a JSON pointer token
- @param len   [in] unescaped token length
- @param esc   [in] number of escaped characters in this token
- @param pre   [out] previous (sibling) key of the returned value's key
- @return value associated with the token, or NULL if no value
- */
-static_inline yyjson_mut_val *ptr_mut_obj_get(yyjson_mut_val *obj,
-                                              const char *token,
-                                              usize len, usize esc,
-                                              yyjson_mut_val **pre) {
-    yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr, *key;
-    usize num = unsafe_yyjson_get_len(obj);
-    if (pre) *pre = NULL;
-    if (unlikely(num == 0)) return NULL;
-    for (; num > 0; num--, pre_key = key) {
-        key = pre_key->next->next;
-        if (ptr_token_eq(key, token, len, esc)) {
-            *pre = pre_key;
-            return key->next;
-        }
-    }
-    return NULL;
-}
-
-/**
- Create a string value with JSON pointer token.
- @param token [in] a JSON pointer token
- @param len   [in] unescaped token length
- @param esc   [in] number of escaped characters in this token
- @param doc   [in] used for memory allocation when creating value
- @return new string value, or NULL if memory allocation failed
- */
-static_inline yyjson_mut_val *ptr_new_key(const char *token,
-                                          usize len, usize esc,
-                                          yyjson_mut_doc *doc) {
-    const char *src = token;
-    if (likely(!esc)) {
-        return yyjson_mut_strncpy(doc, src, len);
-    } else {
-        const char *end = src + len + esc;
-        char *dst = unsafe_yyjson_mut_str_alc(doc, len + esc);
-        char *str = dst;
-        if (unlikely(!dst)) return NULL;
-        for (; src < end; src++, dst++) {
-            if (*src != '~') *dst = *src;
-            else *dst = (*++src == '0' ? '~' : '/');
-        }
-        *dst = '\0';
-        return yyjson_mut_strn(doc, str, len);
-    }
-}
-
-/* macros for yyjson_ptr */
-#define return_err(_ret, _code, _pos, _msg) do { \
-    if (err) { \
-        err->code = YYJSON_PTR_ERR_##_code; \
-        err->msg = _msg; \
-        err->pos = (usize)(_pos); \
-    } \
-    return _ret; \
-} while (false)
-
-#define return_err_resolve(_ret, _pos) \
-    return_err(_ret, RESOLVE, _pos, "JSON pointer cannot be resolved")
-#define return_err_syntax(_ret, _pos) \
-    return_err(_ret, SYNTAX, _pos, "invalid escaped character")
-#define return_err_alloc(_ret) \
-    return_err(_ret, MEMORY_ALLOCATION, 0, "failed to create value")
-
-yyjson_val *unsafe_yyjson_ptr_getx(yyjson_val *val,
-                                   const char *ptr, size_t ptr_len,
-                                   yyjson_ptr_err *err) {
-
-    const char *hdr = ptr, *end = ptr + ptr_len, *token;
-    usize len, esc;
-    yyjson_type type;
-
-    while (true) {
-        token = ptr_next_token(&ptr, end, &len, &esc);
-        if (unlikely(!token)) return_err_syntax(NULL, ptr - hdr);
-        type = unsafe_yyjson_get_type(val);
-        if (type == YYJSON_TYPE_OBJ) {
-            val = ptr_obj_get(val, token, len, esc);
-        } else if (type == YYJSON_TYPE_ARR) {
-            val = ptr_arr_get(val, token, len, esc);
-        } else {
-            val = NULL;
-        }
-        if (!val) return_err_resolve(NULL, token - hdr);
-        if (ptr == end) return val;
-    }
-}
-
-yyjson_mut_val *unsafe_yyjson_mut_ptr_getx(yyjson_mut_val *val,
-                                           const char *ptr,
-                                           size_t ptr_len,
-                                           yyjson_ptr_ctx *ctx,
-                                           yyjson_ptr_err *err) {
-
-    const char *hdr = ptr, *end = ptr + ptr_len, *token;
-    usize len, esc;
-    yyjson_mut_val *ctn, *pre = NULL;
-    yyjson_type type;
-    bool idx_is_last = false;
-
-    while (true) {
-        token = ptr_next_token(&ptr, end, &len, &esc);
-        if (unlikely(!token)) return_err_syntax(NULL, ptr - hdr);
-        ctn = val;
-        type = unsafe_yyjson_get_type(val);
-        if (type == YYJSON_TYPE_OBJ) {
-            val = ptr_mut_obj_get(val, token, len, esc, &pre);
-        } else if (type == YYJSON_TYPE_ARR) {
-            val = ptr_mut_arr_get(val, token, len, esc, &pre, &idx_is_last);
-        } else {
-            val = NULL;
-        }
-        if (ctx && (ptr == end)) {
-            if (type == YYJSON_TYPE_OBJ ||
-                (type == YYJSON_TYPE_ARR && (val || idx_is_last))) {
-                ctx->ctn = ctn;
-                ctx->pre = pre;
-            }
-        }
-        if (!val) return_err_resolve(NULL, token - hdr);
-        if (ptr == end) return val;
-    }
-}
-
-bool unsafe_yyjson_mut_ptr_putx(yyjson_mut_val *val,
-                                const char *ptr, size_t ptr_len,
-                                yyjson_mut_val *new_val,
-                                yyjson_mut_doc *doc,
-                                bool create_parent, bool insert_new,
-                                yyjson_ptr_ctx *ctx,
-                                yyjson_ptr_err *err) {
-
-    const char *hdr = ptr, *end = ptr + ptr_len, *token;
-    usize token_len, esc, ctn_len;
-    yyjson_mut_val *ctn, *key, *pre = NULL;
-    yyjson_mut_val *sep_ctn = NULL, *sep_key = NULL, *sep_val = NULL;
-    yyjson_type ctn_type;
-    bool idx_is_last = false;
-
-    /* skip exist parent nodes */
-    while (true) {
-        token = ptr_next_token(&ptr, end, &token_len, &esc);
-        if (unlikely(!token)) return_err_syntax(false, ptr - hdr);
-        ctn = val;
-        ctn_type = unsafe_yyjson_get_type(ctn);
-        if (ctn_type == YYJSON_TYPE_OBJ) {
-            val = ptr_mut_obj_get(ctn, token, token_len, esc, &pre);
-        } else if (ctn_type == YYJSON_TYPE_ARR) {
-            val = ptr_mut_arr_get(ctn, token, token_len, esc, &pre,
-                                  &idx_is_last);
-        } else return_err_resolve(false, token - hdr);
-        if (!val) break;
-        if (ptr == end) break; /* is last token */
-    }
-
-    /* create parent nodes if not exist */
-    if (unlikely(ptr != end)) { /* not last token */
-        if (!create_parent) return_err_resolve(false, token - hdr);
-
-        /* add value at last index if container is array */
-        if (ctn_type == YYJSON_TYPE_ARR) {
-            if (!idx_is_last || !insert_new) {
-                return_err_resolve(false, token - hdr);
-            }
-            val = yyjson_mut_obj(doc);
-            if (!val) return_err_alloc(false);
-
-            /* delay attaching until all operations are completed */
-            sep_ctn = ctn;
-            sep_key = NULL;
-            sep_val = val;
-
-            /* move to next token */
-            ctn = val;
-            val = NULL;
-            ctn_type = YYJSON_TYPE_OBJ;
-            token = ptr_next_token(&ptr, end, &token_len, &esc);
-            if (unlikely(!token)) return_err_resolve(false, token - hdr);
-        }
-
-        /* container is object, create parent nodes */
-        while (ptr != end) { /* not last token */
-            key = ptr_new_key(token, token_len, esc, doc);
-            if (!key) return_err_alloc(false);
-            val = yyjson_mut_obj(doc);
-            if (!val) return_err_alloc(false);
-
-            /* delay attaching until all operations are completed */
-            if (!sep_ctn) {
-                sep_ctn = ctn;
-                sep_key = key;
-                sep_val = val;
-            } else {
-                yyjson_mut_obj_add(ctn, key, val);
-            }
-
-            /* move to next token */
-            ctn = val;
-            val = NULL;
-            token = ptr_next_token(&ptr, end, &token_len, &esc);
-            if (unlikely(!token)) return_err_syntax(false, ptr - hdr);
-        }
-    }
-
-    /* JSON pointer is resolved, insert or replace target value */
-    ctn_len = unsafe_yyjson_get_len(ctn);
-    if (ctn_type == YYJSON_TYPE_OBJ) {
-        if (ctx) ctx->ctn = ctn;
-        if (!val || insert_new) {
-            /* insert new key-value pair */
-            key = ptr_new_key(token, token_len, esc, doc);
-            if (unlikely(!key)) return_err_alloc(false);
-            if (ctx) ctx->pre = ctn_len ? (yyjson_mut_val *)ctn->uni.ptr : key;
-            unsafe_yyjson_mut_obj_add(ctn, key, new_val, ctn_len);
-        } else {
-            /* replace exist value */
-            key = pre->next->next;
-            if (ctx) ctx->pre = pre;
-            if (ctx) ctx->old = val;
-            yyjson_mut_obj_put(ctn, key, new_val);
-        }
-    } else {
-        /* array */
-        if (ctx && (val || idx_is_last)) ctx->ctn = ctn;
-        if (insert_new) {
-            /* append new value */
-            if (val) {
-                pre->next = new_val;
-                new_val->next = val;
-                if (ctx) ctx->pre = pre;
-                unsafe_yyjson_set_len(ctn, ctn_len + 1);
-            } else if (idx_is_last) {
-                if (ctx) ctx->pre = ctn_len ?
-                    (yyjson_mut_val *)ctn->uni.ptr : new_val;
-                yyjson_mut_arr_append(ctn, new_val);
-            } else {
-                return_err_resolve(false, token - hdr);
-            }
-        } else {
-            /* replace exist value */
-            if (!val) return_err_resolve(false, token - hdr);
-            if (ctn_len > 1) {
-                new_val->next = val->next;
-                pre->next = new_val;
-                if (ctn->uni.ptr == val) ctn->uni.ptr = new_val;
-            } else {
-                new_val->next = new_val;
-                ctn->uni.ptr = new_val;
-                pre = new_val;
-            }
-            if (ctx) ctx->pre = pre;
-            if (ctx) ctx->old = val;
-        }
-    }
-
-    /* all operations are completed, attach the new components to the target */
-    if (unlikely(sep_ctn)) {
-        if (sep_key) yyjson_mut_obj_add(sep_ctn, sep_key, sep_val);
-        else yyjson_mut_arr_append(sep_ctn, sep_val);
-    }
-    return true;
-}
-
-yyjson_mut_val *unsafe_yyjson_mut_ptr_replacex(
-    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
-    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
-
-    yyjson_mut_val *cur_val;
-    yyjson_ptr_ctx cur_ctx;
-    memset(&cur_ctx, 0, sizeof(cur_ctx));
-    if (!ctx) ctx = &cur_ctx;
-    cur_val = unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err);
-    if (!cur_val) return NULL;
-
-    if (yyjson_mut_is_obj(ctx->ctn)) {
-        yyjson_mut_val *key = ctx->pre->next->next;
-        yyjson_mut_obj_put(ctx->ctn, key, new_val);
-    } else {
-        yyjson_ptr_ctx_replace(ctx, new_val);
-    }
-    ctx->old = cur_val;
-    return cur_val;
-}
-
-yyjson_mut_val *unsafe_yyjson_mut_ptr_removex(yyjson_mut_val *val,
-                                              const char *ptr,
-                                              size_t len,
-                                              yyjson_ptr_ctx *ctx,
-                                              yyjson_ptr_err *err) {
-    yyjson_mut_val *cur_val;
-    yyjson_ptr_ctx cur_ctx;
-    memset(&cur_ctx, 0, sizeof(cur_ctx));
-    if (!ctx) ctx = &cur_ctx;
-    cur_val = unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err);
-    if (cur_val) {
-        if (yyjson_mut_is_obj(ctx->ctn)) {
-            yyjson_mut_val *key = ctx->pre->next->next;
-            yyjson_mut_obj_put(ctx->ctn, key, NULL);
-        } else {
-            yyjson_ptr_ctx_remove(ctx);
-        }
-        ctx->pre = NULL;
-        ctx->old = cur_val;
-    }
-    return cur_val;
-}
-
-/* macros for yyjson_ptr */
-#undef return_err
-#undef return_err_resolve
-#undef return_err_syntax
-#undef return_err_alloc
-
-
-
-/*==============================================================================
- * JSON Patch API (RFC 6902)
- *============================================================================*/
-
-/* JSON Patch operation */
-typedef enum patch_op {
-    PATCH_OP_ADD,       /* path, value */
-    PATCH_OP_REMOVE,    /* path */
-    PATCH_OP_REPLACE,   /* path, value */
-    PATCH_OP_MOVE,      /* from, path */
-    PATCH_OP_COPY,      /* from, path */
-    PATCH_OP_TEST,      /* path, value */
-    PATCH_OP_NONE       /* invalid */
-} patch_op;
-
-static patch_op patch_op_get(yyjson_val *op) {
-    const char *str = op->uni.str;
-    switch (unsafe_yyjson_get_len(op)) {
-        case 3:
-            if (!memcmp(str, "add", 3)) return PATCH_OP_ADD;
-            return PATCH_OP_NONE;
-        case 4:
-            if (!memcmp(str, "move", 4)) return PATCH_OP_MOVE;
-            if (!memcmp(str, "copy", 4)) return PATCH_OP_COPY;
-            if (!memcmp(str, "test", 4)) return PATCH_OP_TEST;
-            return PATCH_OP_NONE;
-        case 6:
-            if (!memcmp(str, "remove", 6)) return PATCH_OP_REMOVE;
-            return PATCH_OP_NONE;
-        case 7:
-            if (!memcmp(str, "replace", 7)) return PATCH_OP_REPLACE;
-            return PATCH_OP_NONE;
-        default:
-            return PATCH_OP_NONE;
-    }
-}
-
-/* macros for yyjson_patch */
-#define return_err(_code, _msg) do { \
-    if (err->ptr.code == YYJSON_PTR_ERR_MEMORY_ALLOCATION) { \
-        err->code = YYJSON_PATCH_ERROR_MEMORY_ALLOCATION; \
-        err->msg = _msg; \
-        memset(&err->ptr, 0, sizeof(yyjson_ptr_err)); \
-    } else { \
-        err->code = YYJSON_PATCH_ERROR_##_code; \
-        err->msg = _msg; \
-        err->idx = iter.idx ? iter.idx - 1 : 0; \
-    } \
-    return NULL; \
-} while (false)
-
-#define return_err_copy() \
-    return_err(MEMORY_ALLOCATION, "failed to copy value")
-#define return_err_key(_key) \
-    return_err(MISSING_KEY, "missing key " _key)
-#define return_err_val(_key) \
-    return_err(INVALID_MEMBER, "invalid member " _key)
-
-#define ptr_get(_ptr) yyjson_mut_ptr_getx( \
-    root, _ptr->uni.str, _ptr##_len, NULL, &err->ptr)
-#define ptr_add(_ptr, _val) yyjson_mut_ptr_addx( \
-    root, _ptr->uni.str, _ptr##_len, _val, doc, false, NULL, &err->ptr)
-#define ptr_remove(_ptr) yyjson_mut_ptr_removex( \
-    root, _ptr->uni.str, _ptr##_len, NULL, &err->ptr)
-#define ptr_replace(_ptr, _val)yyjson_mut_ptr_replacex( \
-    root, _ptr->uni.str, _ptr##_len, _val, NULL, &err->ptr)
-
-yyjson_mut_val *yyjson_patch(yyjson_mut_doc *doc,
-                             yyjson_val *orig,
-                             yyjson_val *patch,
-                             yyjson_patch_err *err) {
-
-    yyjson_mut_val *root;
-    yyjson_val *obj;
-    yyjson_arr_iter iter;
-    yyjson_patch_err err_tmp;
-    if (!err) err = &err_tmp;
-    memset(err, 0, sizeof(*err));
-    memset(&iter, 0, sizeof(iter));
-
-    if (unlikely(!doc || !orig || !patch)) {
-        return_err(INVALID_PARAMETER, "input parameter is NULL");
-    }
-    if (unlikely(!yyjson_is_arr(patch))) {
-        return_err(INVALID_PARAMETER, "input patch is not array");
-    }
-    root = yyjson_val_mut_copy(doc, orig);
-    if (unlikely(!root)) return_err_copy();
-
-    /* iterate through the patch array */
-    yyjson_arr_iter_init(patch, &iter);
-    while ((obj = yyjson_arr_iter_next(&iter))) {
-        patch_op op_enum;
-        yyjson_val *op, *path, *from = NULL, *value;
-        yyjson_mut_val *val = NULL, *test;
-        usize path_len, from_len = 0;
-        if (unlikely(!unsafe_yyjson_is_obj(obj))) {
-            return_err(INVALID_OPERATION, "JSON patch operation is not object");
-        }
-
-        /* get required member: op */
-        op = yyjson_obj_get(obj, "op");
-        if (unlikely(!op)) return_err_key("`op`");
-        if (unlikely(!yyjson_is_str(op))) return_err_val("`op`");
-        op_enum = patch_op_get(op);
-
-        /* get required member: path */
-        path = yyjson_obj_get(obj, "path");
-        if (unlikely(!path)) return_err_key("`path`");
-        if (unlikely(!yyjson_is_str(path))) return_err_val("`path`");
-        path_len = unsafe_yyjson_get_len(path);
-
-        /* get required member: value, from */
-        switch ((int)op_enum) {
-            case PATCH_OP_ADD: case PATCH_OP_REPLACE: case PATCH_OP_TEST:
-                value = yyjson_obj_get(obj, "value");
-                if (unlikely(!value)) return_err_key("`value`");
-                val = yyjson_val_mut_copy(doc, value);
-                if (unlikely(!val)) return_err_copy();
-                break;
-            case PATCH_OP_MOVE: case PATCH_OP_COPY:
-                from = yyjson_obj_get(obj, "from");
-                if (unlikely(!from)) return_err_key("`from`");
-                if (unlikely(!yyjson_is_str(from))) return_err_val("`from`");
-                from_len = unsafe_yyjson_get_len(from);
-                break;
-            default:
-                break;
-        }
-
-        /* perform an operation */
-        switch ((int)op_enum) {
-            case PATCH_OP_ADD: /* add(path, val) */
-                if (unlikely(path_len == 0)) { root = val; break; }
-                if (unlikely(!ptr_add(path, val))) {
-                    return_err(POINTER, "failed to add `path`");
-                }
-                break;
-            case PATCH_OP_REMOVE: /* remove(path) */
-                if (unlikely(!ptr_remove(path))) {
-                    return_err(POINTER, "failed to remove `path`");
-                }
-                break;
-            case PATCH_OP_REPLACE: /* replace(path, val) */
-                if (unlikely(path_len == 0)) { root = val; break; }
-                if (unlikely(!ptr_replace(path, val))) {
-                    return_err(POINTER, "failed to replace `path`");
-                }
-                break;
-            case PATCH_OP_MOVE: /* val = remove(from), add(path, val) */
-                if (unlikely(from_len == 0 && path_len == 0)) break;
-                val = ptr_remove(from);
-                if (unlikely(!val)) {
-                    return_err(POINTER, "failed to remove `from`");
-                }
-                if (unlikely(path_len == 0)) { root = val; break; }
-                if (unlikely(!ptr_add(path, val))) {
-                    return_err(POINTER, "failed to add `path`");
-                }
-                break;
-            case PATCH_OP_COPY: /* val = get(from).copy, add(path, val) */
-                val = ptr_get(from);
-                if (unlikely(!val)) {
-                    return_err(POINTER, "failed to get `from`");
-                }
-                if (unlikely(path_len == 0)) { root = val; break; }
-                val = yyjson_mut_val_mut_copy(doc, val);
-                if (unlikely(!val)) return_err_copy();
-                if (unlikely(!ptr_add(path, val))) {
-                    return_err(POINTER, "failed to add `path`");
-                }
-                break;
-            case PATCH_OP_TEST: /* test = get(path), test.eq(val) */
-                test = ptr_get(path);
-                if (unlikely(!test)) {
-                    return_err(POINTER, "failed to get `path`");
-                }
-                if (unlikely(!yyjson_mut_equals(val, test))) {
-                    return_err(EQUAL, "failed to test equal");
-                }
-                break;
-            default:
-                return_err(INVALID_MEMBER, "unsupported `op`");
-        }
-    }
-    return root;
-}
-
-yyjson_mut_val *yyjson_mut_patch(yyjson_mut_doc *doc,
-                                 yyjson_mut_val *orig,
-                                 yyjson_mut_val *patch,
-                                 yyjson_patch_err *err) {
-    yyjson_mut_val *root, *obj;
-    yyjson_mut_arr_iter iter;
-    yyjson_patch_err err_tmp;
-    if (!err) err = &err_tmp;
-    memset(err, 0, sizeof(*err));
-    memset(&iter, 0, sizeof(iter));
-
-    if (unlikely(!doc || !orig || !patch)) {
-        return_err(INVALID_PARAMETER, "input parameter is NULL");
-    }
-    if (unlikely(!yyjson_mut_is_arr(patch))) {
-        return_err(INVALID_PARAMETER, "input patch is not array");
-    }
-    root = yyjson_mut_val_mut_copy(doc, orig);
-    if (unlikely(!root)) return_err_copy();
-
-    /* iterate through the patch array */
-    yyjson_mut_arr_iter_init(patch, &iter);
-    while ((obj = yyjson_mut_arr_iter_next(&iter))) {
-        patch_op op_enum;
-        yyjson_mut_val *op, *path, *from = NULL, *value;
-        yyjson_mut_val *val = NULL, *test;
-        usize path_len, from_len = 0;
-        if (!unsafe_yyjson_is_obj(obj)) {
-            return_err(INVALID_OPERATION, "JSON patch operation is not object");
-        }
-
-        /* get required member: op */
-        op = yyjson_mut_obj_get(obj, "op");
-        if (unlikely(!op)) return_err_key("`op`");
-        if (unlikely(!yyjson_mut_is_str(op))) return_err_val("`op`");
-        op_enum = patch_op_get((yyjson_val *)(void *)op);
-
-        /* get required member: path */
-        path = yyjson_mut_obj_get(obj, "path");
-        if (unlikely(!path)) return_err_key("`path`");
-        if (unlikely(!yyjson_mut_is_str(path))) return_err_val("`path`");
-        path_len = unsafe_yyjson_get_len(path);
-
-        /* get required member: value, from */
-        switch ((int)op_enum) {
-            case PATCH_OP_ADD: case PATCH_OP_REPLACE: case PATCH_OP_TEST:
-                value = yyjson_mut_obj_get(obj, "value");
-                if (unlikely(!value)) return_err_key("`value`");
-                val = yyjson_mut_val_mut_copy(doc, value);
-                if (unlikely(!val)) return_err_copy();
-                break;
-            case PATCH_OP_MOVE: case PATCH_OP_COPY:
-                from = yyjson_mut_obj_get(obj, "from");
-                if (unlikely(!from)) return_err_key("`from`");
-                if (unlikely(!yyjson_mut_is_str(from))) {
-                    return_err_val("`from`");
-                }
-                from_len = unsafe_yyjson_get_len(from);
-                break;
-            default:
-                break;
-        }
-
-        /* perform an operation */
-        switch ((int)op_enum) {
-            case PATCH_OP_ADD: /* add(path, val) */
-                if (unlikely(path_len == 0)) { root = val; break; }
-                if (unlikely(!ptr_add(path, val))) {
-                    return_err(POINTER, "failed to add `path`");
-                }
-                break;
-            case PATCH_OP_REMOVE: /* remove(path) */
-                if (unlikely(!ptr_remove(path))) {
-                    return_err(POINTER, "failed to remove `path`");
-                }
-                break;
-            case PATCH_OP_REPLACE: /* replace(path, val) */
-                if (unlikely(path_len == 0)) { root = val; break; }
-                if (unlikely(!ptr_replace(path, val))) {
-                    return_err(POINTER, "failed to replace `path`");
-                }
-                break;
-            case PATCH_OP_MOVE: /* val = remove(from), add(path, val) */
-                if (unlikely(from_len == 0 && path_len == 0)) break;
-                val = ptr_remove(from);
-                if (unlikely(!val)) {
-                    return_err(POINTER, "failed to remove `from`");
-                }
-                if (unlikely(path_len == 0)) { root = val; break; }
-                if (unlikely(!ptr_add(path, val))) {
-                    return_err(POINTER, "failed to add `path`");
-                }
-                break;
-            case PATCH_OP_COPY: /* val = get(from).copy, add(path, val) */
-                val = ptr_get(from);
-                if (unlikely(!val)) {
-                    return_err(POINTER, "failed to get `from`");
-                }
-                if (unlikely(path_len == 0)) { root = val; break; }
-                val = yyjson_mut_val_mut_copy(doc, val);
-                if (unlikely(!val)) return_err_copy();
-                if (unlikely(!ptr_add(path, val))) {
-                    return_err(POINTER, "failed to add `path`");
-                }
-                break;
-            case PATCH_OP_TEST: /* test = get(path), test.eq(val) */
-                test = ptr_get(path);
-                if (unlikely(!test)) {
-                    return_err(POINTER, "failed to get `path`");
-                }
-                if (unlikely(!yyjson_mut_equals(val, test))) {
-                    return_err(EQUAL, "failed to test equal");
-                }
-                break;
-            default:
-                return_err(INVALID_MEMBER, "unsupported `op`");
-        }
-    }
-    return root;
-}
-
-/* macros for yyjson_patch */
-#undef return_err
-#undef return_err_copy
-#undef return_err_key
-#undef return_err_val
-#undef ptr_get
-#undef ptr_add
-#undef ptr_remove
-#undef ptr_replace
-
-
-
-/*==============================================================================
- * JSON Merge-Patch API (RFC 7386)
- *============================================================================*/
-
-yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc,
-                                   yyjson_val *orig,
-                                   yyjson_val *patch) {
-    usize idx, max;
-    yyjson_val *key, *orig_val, *patch_val, local_orig;
-    yyjson_mut_val *builder, *mut_key, *mut_val, *merged_val;
-
-    if (unlikely(!yyjson_is_obj(patch))) {
-        return yyjson_val_mut_copy(doc, patch);
-    }
-
-    builder = yyjson_mut_obj(doc);
-    if (unlikely(!builder)) return NULL;
-
-    memset(&local_orig, 0, sizeof(local_orig));
-    if (!yyjson_is_obj(orig)) {
-        orig = &local_orig;
-        orig->tag = builder->tag;
-        orig->uni = builder->uni;
-    }
-
-    /* If orig is contributing, copy any items not modified by the patch */
-    if (orig != &local_orig) {
-        yyjson_obj_foreach(orig, idx, max, key, orig_val) {
-            patch_val = yyjson_obj_getn(patch,
-                                        unsafe_yyjson_get_str(key),
-                                        unsafe_yyjson_get_len(key));
-            if (!patch_val) {
-                mut_key = yyjson_val_mut_copy(doc, key);
-                mut_val = yyjson_val_mut_copy(doc, orig_val);
-                if (!yyjson_mut_obj_add(builder, mut_key, mut_val)) return NULL;
-            }
-        }
-    }
-
-    /* Merge items modified by the patch. */
-    yyjson_obj_foreach(patch, idx, max, key, patch_val) {
-        /* null indicates the field is removed. */
-        if (unsafe_yyjson_is_null(patch_val)) {
-            continue;
-        }
-        mut_key = yyjson_val_mut_copy(doc, key);
-        orig_val = yyjson_obj_getn(orig,
-                                   unsafe_yyjson_get_str(key),
-                                   unsafe_yyjson_get_len(key));
-        merged_val = yyjson_merge_patch(doc, orig_val, patch_val);
-        if (!yyjson_mut_obj_add(builder, mut_key, merged_val)) return NULL;
-    }
-
-    return builder;
-}
-
-yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc,
-                                       yyjson_mut_val *orig,
-                                       yyjson_mut_val *patch) {
-    usize idx, max;
-    yyjson_mut_val *key, *orig_val, *patch_val, local_orig;
-    yyjson_mut_val *builder, *mut_key, *mut_val, *merged_val;
-
-    if (unlikely(!yyjson_mut_is_obj(patch))) {
-        return yyjson_mut_val_mut_copy(doc, patch);
-    }
-
-    builder = yyjson_mut_obj(doc);
-    if (unlikely(!builder)) return NULL;
-
-    memset(&local_orig, 0, sizeof(local_orig));
-    if (!yyjson_mut_is_obj(orig)) {
-        orig = &local_orig;
-        orig->tag = builder->tag;
-        orig->uni = builder->uni;
-    }
-
-    /* If orig is contributing, copy any items not modified by the patch */
-    if (orig != &local_orig) {
-        yyjson_mut_obj_foreach(orig, idx, max, key, orig_val) {
-            patch_val = yyjson_mut_obj_getn(patch,
-                                            unsafe_yyjson_get_str(key),
-                                            unsafe_yyjson_get_len(key));
-            if (!patch_val) {
-                mut_key = yyjson_mut_val_mut_copy(doc, key);
-                mut_val = yyjson_mut_val_mut_copy(doc, orig_val);
-                if (!yyjson_mut_obj_add(builder, mut_key, mut_val)) return NULL;
-            }
-        }
-    }
-
-    /* Merge items modified by the patch. */
-    yyjson_mut_obj_foreach(patch, idx, max, key, patch_val) {
-        /* null indicates the field is removed. */
-        if (unsafe_yyjson_is_null(patch_val)) {
-            continue;
-        }
-        mut_key = yyjson_mut_val_mut_copy(doc, key);
-        orig_val = yyjson_mut_obj_getn(orig,
-                                       unsafe_yyjson_get_str(key),
-                                       unsafe_yyjson_get_len(key));
-        merged_val = yyjson_mut_merge_patch(doc, orig_val, patch_val);
-        if (!yyjson_mut_obj_add(builder, mut_key, merged_val)) return NULL;
-    }
-
-    return builder;
-}
-
-#endif /* YYJSON_DISABLE_UTILS */
-
-
-
-/*==============================================================================
- * Power10 Lookup Table
- * These data are used by the floating-point number reader and writer.
- *============================================================================*/
-
-#if (!YYJSON_DISABLE_READER || !YYJSON_DISABLE_WRITER) && \
-    (!YYJSON_DISABLE_FAST_FP_CONV)
-
-/** Minimum decimal exponent in pow10_sig_table. */
-#define POW10_SIG_TABLE_MIN_EXP -343
-
-/** Maximum decimal exponent in pow10_sig_table. */
-#define POW10_SIG_TABLE_MAX_EXP 324
-
-/** Minimum exact decimal exponent in pow10_sig_table */
-#define POW10_SIG_TABLE_MIN_EXACT_EXP 0
-
-/** Maximum exact decimal exponent in pow10_sig_table */
-#define POW10_SIG_TABLE_MAX_EXACT_EXP 55
-
-/** Normalized significant 128 bits of pow10, no rounded up (size: 10.4KB).
-    This lookup table is used by both the double number reader and writer.
-    (generate with misc/make_tables.c) */
-static const u64 pow10_sig_table[] = {
-    U64(0xBF29DCAB, 0xA82FDEAE), U64(0x7432EE87, 0x3880FC33), /* ~= 10^-343 */
-    U64(0xEEF453D6, 0x923BD65A), U64(0x113FAA29, 0x06A13B3F), /* ~= 10^-342 */
-    U64(0x9558B466, 0x1B6565F8), U64(0x4AC7CA59, 0xA424C507), /* ~= 10^-341 */
-    U64(0xBAAEE17F, 0xA23EBF76), U64(0x5D79BCF0, 0x0D2DF649), /* ~= 10^-340 */
-    U64(0xE95A99DF, 0x8ACE6F53), U64(0xF4D82C2C, 0x107973DC), /* ~= 10^-339 */
-    U64(0x91D8A02B, 0xB6C10594), U64(0x79071B9B, 0x8A4BE869), /* ~= 10^-338 */
-    U64(0xB64EC836, 0xA47146F9), U64(0x9748E282, 0x6CDEE284), /* ~= 10^-337 */
-    U64(0xE3E27A44, 0x4D8D98B7), U64(0xFD1B1B23, 0x08169B25), /* ~= 10^-336 */
-    U64(0x8E6D8C6A, 0xB0787F72), U64(0xFE30F0F5, 0xE50E20F7), /* ~= 10^-335 */
-    U64(0xB208EF85, 0x5C969F4F), U64(0xBDBD2D33, 0x5E51A935), /* ~= 10^-334 */
-    U64(0xDE8B2B66, 0xB3BC4723), U64(0xAD2C7880, 0x35E61382), /* ~= 10^-333 */
-    U64(0x8B16FB20, 0x3055AC76), U64(0x4C3BCB50, 0x21AFCC31), /* ~= 10^-332 */
-    U64(0xADDCB9E8, 0x3C6B1793), U64(0xDF4ABE24, 0x2A1BBF3D), /* ~= 10^-331 */
-    U64(0xD953E862, 0x4B85DD78), U64(0xD71D6DAD, 0x34A2AF0D), /* ~= 10^-330 */
-    U64(0x87D4713D, 0x6F33AA6B), U64(0x8672648C, 0x40E5AD68), /* ~= 10^-329 */
-    U64(0xA9C98D8C, 0xCB009506), U64(0x680EFDAF, 0x511F18C2), /* ~= 10^-328 */
-    U64(0xD43BF0EF, 0xFDC0BA48), U64(0x0212BD1B, 0x2566DEF2), /* ~= 10^-327 */
-    U64(0x84A57695, 0xFE98746D), U64(0x014BB630, 0xF7604B57), /* ~= 10^-326 */
-    U64(0xA5CED43B, 0x7E3E9188), U64(0x419EA3BD, 0x35385E2D), /* ~= 10^-325 */
-    U64(0xCF42894A, 0x5DCE35EA), U64(0x52064CAC, 0x828675B9), /* ~= 10^-324 */
-    U64(0x818995CE, 0x7AA0E1B2), U64(0x7343EFEB, 0xD1940993), /* ~= 10^-323 */
-    U64(0xA1EBFB42, 0x19491A1F), U64(0x1014EBE6, 0xC5F90BF8), /* ~= 10^-322 */
-    U64(0xCA66FA12, 0x9F9B60A6), U64(0xD41A26E0, 0x77774EF6), /* ~= 10^-321 */
-    U64(0xFD00B897, 0x478238D0), U64(0x8920B098, 0x955522B4), /* ~= 10^-320 */
-    U64(0x9E20735E, 0x8CB16382), U64(0x55B46E5F, 0x5D5535B0), /* ~= 10^-319 */
-    U64(0xC5A89036, 0x2FDDBC62), U64(0xEB2189F7, 0x34AA831D), /* ~= 10^-318 */
-    U64(0xF712B443, 0xBBD52B7B), U64(0xA5E9EC75, 0x01D523E4), /* ~= 10^-317 */
-    U64(0x9A6BB0AA, 0x55653B2D), U64(0x47B233C9, 0x2125366E), /* ~= 10^-316 */
-    U64(0xC1069CD4, 0xEABE89F8), U64(0x999EC0BB, 0x696E840A), /* ~= 10^-315 */
-    U64(0xF148440A, 0x256E2C76), U64(0xC00670EA, 0x43CA250D), /* ~= 10^-314 */
-    U64(0x96CD2A86, 0x5764DBCA), U64(0x38040692, 0x6A5E5728), /* ~= 10^-313 */
-    U64(0xBC807527, 0xED3E12BC), U64(0xC6050837, 0x04F5ECF2), /* ~= 10^-312 */
-    U64(0xEBA09271, 0xE88D976B), U64(0xF7864A44, 0xC633682E), /* ~= 10^-311 */
-    U64(0x93445B87, 0x31587EA3), U64(0x7AB3EE6A, 0xFBE0211D), /* ~= 10^-310 */
-    U64(0xB8157268, 0xFDAE9E4C), U64(0x5960EA05, 0xBAD82964), /* ~= 10^-309 */
-    U64(0xE61ACF03, 0x3D1A45DF), U64(0x6FB92487, 0x298E33BD), /* ~= 10^-308 */
-    U64(0x8FD0C162, 0x06306BAB), U64(0xA5D3B6D4, 0x79F8E056), /* ~= 10^-307 */
-    U64(0xB3C4F1BA, 0x87BC8696), U64(0x8F48A489, 0x9877186C), /* ~= 10^-306 */
-    U64(0xE0B62E29, 0x29ABA83C), U64(0x331ACDAB, 0xFE94DE87), /* ~= 10^-305 */
-    U64(0x8C71DCD9, 0xBA0B4925), U64(0x9FF0C08B, 0x7F1D0B14), /* ~= 10^-304 */
-    U64(0xAF8E5410, 0x288E1B6F), U64(0x07ECF0AE, 0x5EE44DD9), /* ~= 10^-303 */
-    U64(0xDB71E914, 0x32B1A24A), U64(0xC9E82CD9, 0xF69D6150), /* ~= 10^-302 */
-    U64(0x892731AC, 0x9FAF056E), U64(0xBE311C08, 0x3A225CD2), /* ~= 10^-301 */
-    U64(0xAB70FE17, 0xC79AC6CA), U64(0x6DBD630A, 0x48AAF406), /* ~= 10^-300 */
-    U64(0xD64D3D9D, 0xB981787D), U64(0x092CBBCC, 0xDAD5B108), /* ~= 10^-299 */
-    U64(0x85F04682, 0x93F0EB4E), U64(0x25BBF560, 0x08C58EA5), /* ~= 10^-298 */
-    U64(0xA76C5823, 0x38ED2621), U64(0xAF2AF2B8, 0x0AF6F24E), /* ~= 10^-297 */
-    U64(0xD1476E2C, 0x07286FAA), U64(0x1AF5AF66, 0x0DB4AEE1), /* ~= 10^-296 */
-    U64(0x82CCA4DB, 0x847945CA), U64(0x50D98D9F, 0xC890ED4D), /* ~= 10^-295 */
-    U64(0xA37FCE12, 0x6597973C), U64(0xE50FF107, 0xBAB528A0), /* ~= 10^-294 */
-    U64(0xCC5FC196, 0xFEFD7D0C), U64(0x1E53ED49, 0xA96272C8), /* ~= 10^-293 */
-    U64(0xFF77B1FC, 0xBEBCDC4F), U64(0x25E8E89C, 0x13BB0F7A), /* ~= 10^-292 */
-    U64(0x9FAACF3D, 0xF73609B1), U64(0x77B19161, 0x8C54E9AC), /* ~= 10^-291 */
-    U64(0xC795830D, 0x75038C1D), U64(0xD59DF5B9, 0xEF6A2417), /* ~= 10^-290 */
-    U64(0xF97AE3D0, 0xD2446F25), U64(0x4B057328, 0x6B44AD1D), /* ~= 10^-289 */
-    U64(0x9BECCE62, 0x836AC577), U64(0x4EE367F9, 0x430AEC32), /* ~= 10^-288 */
-    U64(0xC2E801FB, 0x244576D5), U64(0x229C41F7, 0x93CDA73F), /* ~= 10^-287 */
-    U64(0xF3A20279, 0xED56D48A), U64(0x6B435275, 0x78C1110F), /* ~= 10^-286 */
-    U64(0x9845418C, 0x345644D6), U64(0x830A1389, 0x6B78AAA9), /* ~= 10^-285 */
-    U64(0xBE5691EF, 0x416BD60C), U64(0x23CC986B, 0xC656D553), /* ~= 10^-284 */
-    U64(0xEDEC366B, 0x11C6CB8F), U64(0x2CBFBE86, 0xB7EC8AA8), /* ~= 10^-283 */
-    U64(0x94B3A202, 0xEB1C3F39), U64(0x7BF7D714, 0x32F3D6A9), /* ~= 10^-282 */
-    U64(0xB9E08A83, 0xA5E34F07), U64(0xDAF5CCD9, 0x3FB0CC53), /* ~= 10^-281 */
-    U64(0xE858AD24, 0x8F5C22C9), U64(0xD1B3400F, 0x8F9CFF68), /* ~= 10^-280 */
-    U64(0x91376C36, 0xD99995BE), U64(0x23100809, 0xB9C21FA1), /* ~= 10^-279 */
-    U64(0xB5854744, 0x8FFFFB2D), U64(0xABD40A0C, 0x2832A78A), /* ~= 10^-278 */
-    U64(0xE2E69915, 0xB3FFF9F9), U64(0x16C90C8F, 0x323F516C), /* ~= 10^-277 */
-    U64(0x8DD01FAD, 0x907FFC3B), U64(0xAE3DA7D9, 0x7F6792E3), /* ~= 10^-276 */
-    U64(0xB1442798, 0xF49FFB4A), U64(0x99CD11CF, 0xDF41779C), /* ~= 10^-275 */
-    U64(0xDD95317F, 0x31C7FA1D), U64(0x40405643, 0xD711D583), /* ~= 10^-274 */
-    U64(0x8A7D3EEF, 0x7F1CFC52), U64(0x482835EA, 0x666B2572), /* ~= 10^-273 */
-    U64(0xAD1C8EAB, 0x5EE43B66), U64(0xDA324365, 0x0005EECF), /* ~= 10^-272 */
-    U64(0xD863B256, 0x369D4A40), U64(0x90BED43E, 0x40076A82), /* ~= 10^-271 */
-    U64(0x873E4F75, 0xE2224E68), U64(0x5A7744A6, 0xE804A291), /* ~= 10^-270 */
-    U64(0xA90DE353, 0x5AAAE202), U64(0x711515D0, 0xA205CB36), /* ~= 10^-269 */
-    U64(0xD3515C28, 0x31559A83), U64(0x0D5A5B44, 0xCA873E03), /* ~= 10^-268 */
-    U64(0x8412D999, 0x1ED58091), U64(0xE858790A, 0xFE9486C2), /* ~= 10^-267 */
-    U64(0xA5178FFF, 0x668AE0B6), U64(0x626E974D, 0xBE39A872), /* ~= 10^-266 */
-    U64(0xCE5D73FF, 0x402D98E3), U64(0xFB0A3D21, 0x2DC8128F), /* ~= 10^-265 */
-    U64(0x80FA687F, 0x881C7F8E), U64(0x7CE66634, 0xBC9D0B99), /* ~= 10^-264 */
-    U64(0xA139029F, 0x6A239F72), U64(0x1C1FFFC1, 0xEBC44E80), /* ~= 10^-263 */
-    U64(0xC9874347, 0x44AC874E), U64(0xA327FFB2, 0x66B56220), /* ~= 10^-262 */
-    U64(0xFBE91419, 0x15D7A922), U64(0x4BF1FF9F, 0x0062BAA8), /* ~= 10^-261 */
-    U64(0x9D71AC8F, 0xADA6C9B5), U64(0x6F773FC3, 0x603DB4A9), /* ~= 10^-260 */
-    U64(0xC4CE17B3, 0x99107C22), U64(0xCB550FB4, 0x384D21D3), /* ~= 10^-259 */
-    U64(0xF6019DA0, 0x7F549B2B), U64(0x7E2A53A1, 0x46606A48), /* ~= 10^-258 */
-    U64(0x99C10284, 0x4F94E0FB), U64(0x2EDA7444, 0xCBFC426D), /* ~= 10^-257 */
-    U64(0xC0314325, 0x637A1939), U64(0xFA911155, 0xFEFB5308), /* ~= 10^-256 */
-    U64(0xF03D93EE, 0xBC589F88), U64(0x793555AB, 0x7EBA27CA), /* ~= 10^-255 */
-    U64(0x96267C75, 0x35B763B5), U64(0x4BC1558B, 0x2F3458DE), /* ~= 10^-254 */
-    U64(0xBBB01B92, 0x83253CA2), U64(0x9EB1AAED, 0xFB016F16), /* ~= 10^-253 */
-    U64(0xEA9C2277, 0x23EE8BCB), U64(0x465E15A9, 0x79C1CADC), /* ~= 10^-252 */
-    U64(0x92A1958A, 0x7675175F), U64(0x0BFACD89, 0xEC191EC9), /* ~= 10^-251 */
-    U64(0xB749FAED, 0x14125D36), U64(0xCEF980EC, 0x671F667B), /* ~= 10^-250 */
-    U64(0xE51C79A8, 0x5916F484), U64(0x82B7E127, 0x80E7401A), /* ~= 10^-249 */
-    U64(0x8F31CC09, 0x37AE58D2), U64(0xD1B2ECB8, 0xB0908810), /* ~= 10^-248 */
-    U64(0xB2FE3F0B, 0x8599EF07), U64(0x861FA7E6, 0xDCB4AA15), /* ~= 10^-247 */
-    U64(0xDFBDCECE, 0x67006AC9), U64(0x67A791E0, 0x93E1D49A), /* ~= 10^-246 */
-    U64(0x8BD6A141, 0x006042BD), U64(0xE0C8BB2C, 0x5C6D24E0), /* ~= 10^-245 */
-    U64(0xAECC4991, 0x4078536D), U64(0x58FAE9F7, 0x73886E18), /* ~= 10^-244 */
-    U64(0xDA7F5BF5, 0x90966848), U64(0xAF39A475, 0x506A899E), /* ~= 10^-243 */
-    U64(0x888F9979, 0x7A5E012D), U64(0x6D8406C9, 0x52429603), /* ~= 10^-242 */
-    U64(0xAAB37FD7, 0xD8F58178), U64(0xC8E5087B, 0xA6D33B83), /* ~= 10^-241 */
-    U64(0xD5605FCD, 0xCF32E1D6), U64(0xFB1E4A9A, 0x90880A64), /* ~= 10^-240 */
-    U64(0x855C3BE0, 0xA17FCD26), U64(0x5CF2EEA0, 0x9A55067F), /* ~= 10^-239 */
-    U64(0xA6B34AD8, 0xC9DFC06F), U64(0xF42FAA48, 0xC0EA481E), /* ~= 10^-238 */
-    U64(0xD0601D8E, 0xFC57B08B), U64(0xF13B94DA, 0xF124DA26), /* ~= 10^-237 */
-    U64(0x823C1279, 0x5DB6CE57), U64(0x76C53D08, 0xD6B70858), /* ~= 10^-236 */
-    U64(0xA2CB1717, 0xB52481ED), U64(0x54768C4B, 0x0C64CA6E), /* ~= 10^-235 */
-    U64(0xCB7DDCDD, 0xA26DA268), U64(0xA9942F5D, 0xCF7DFD09), /* ~= 10^-234 */
-    U64(0xFE5D5415, 0x0B090B02), U64(0xD3F93B35, 0x435D7C4C), /* ~= 10^-233 */
-    U64(0x9EFA548D, 0x26E5A6E1), U64(0xC47BC501, 0x4A1A6DAF), /* ~= 10^-232 */
-    U64(0xC6B8E9B0, 0x709F109A), U64(0x359AB641, 0x9CA1091B), /* ~= 10^-231 */
-    U64(0xF867241C, 0x8CC6D4C0), U64(0xC30163D2, 0x03C94B62), /* ~= 10^-230 */
-    U64(0x9B407691, 0xD7FC44F8), U64(0x79E0DE63, 0x425DCF1D), /* ~= 10^-229 */
-    U64(0xC2109436, 0x4DFB5636), U64(0x985915FC, 0x12F542E4), /* ~= 10^-228 */
-    U64(0xF294B943, 0xE17A2BC4), U64(0x3E6F5B7B, 0x17B2939D), /* ~= 10^-227 */
-    U64(0x979CF3CA, 0x6CEC5B5A), U64(0xA705992C, 0xEECF9C42), /* ~= 10^-226 */
-    U64(0xBD8430BD, 0x08277231), U64(0x50C6FF78, 0x2A838353), /* ~= 10^-225 */
-    U64(0xECE53CEC, 0x4A314EBD), U64(0xA4F8BF56, 0x35246428), /* ~= 10^-224 */
-    U64(0x940F4613, 0xAE5ED136), U64(0x871B7795, 0xE136BE99), /* ~= 10^-223 */
-    U64(0xB9131798, 0x99F68584), U64(0x28E2557B, 0x59846E3F), /* ~= 10^-222 */
-    U64(0xE757DD7E, 0xC07426E5), U64(0x331AEADA, 0x2FE589CF), /* ~= 10^-221 */
-    U64(0x9096EA6F, 0x3848984F), U64(0x3FF0D2C8, 0x5DEF7621), /* ~= 10^-220 */
-    U64(0xB4BCA50B, 0x065ABE63), U64(0x0FED077A, 0x756B53A9), /* ~= 10^-219 */
-    U64(0xE1EBCE4D, 0xC7F16DFB), U64(0xD3E84959, 0x12C62894), /* ~= 10^-218 */
-    U64(0x8D3360F0, 0x9CF6E4BD), U64(0x64712DD7, 0xABBBD95C), /* ~= 10^-217 */
-    U64(0xB080392C, 0xC4349DEC), U64(0xBD8D794D, 0x96AACFB3), /* ~= 10^-216 */
-    U64(0xDCA04777, 0xF541C567), U64(0xECF0D7A0, 0xFC5583A0), /* ~= 10^-215 */
-    U64(0x89E42CAA, 0xF9491B60), U64(0xF41686C4, 0x9DB57244), /* ~= 10^-214 */
-    U64(0xAC5D37D5, 0xB79B6239), U64(0x311C2875, 0xC522CED5), /* ~= 10^-213 */
-    U64(0xD77485CB, 0x25823AC7), U64(0x7D633293, 0x366B828B), /* ~= 10^-212 */
-    U64(0x86A8D39E, 0xF77164BC), U64(0xAE5DFF9C, 0x02033197), /* ~= 10^-211 */
-    U64(0xA8530886, 0xB54DBDEB), U64(0xD9F57F83, 0x0283FDFC), /* ~= 10^-210 */
-    U64(0xD267CAA8, 0x62A12D66), U64(0xD072DF63, 0xC324FD7B), /* ~= 10^-209 */
-    U64(0x8380DEA9, 0x3DA4BC60), U64(0x4247CB9E, 0x59F71E6D), /* ~= 10^-208 */
-    U64(0xA4611653, 0x8D0DEB78), U64(0x52D9BE85, 0xF074E608), /* ~= 10^-207 */
-    U64(0xCD795BE8, 0x70516656), U64(0x67902E27, 0x6C921F8B), /* ~= 10^-206 */
-    U64(0x806BD971, 0x4632DFF6), U64(0x00BA1CD8, 0xA3DB53B6), /* ~= 10^-205 */
-    U64(0xA086CFCD, 0x97BF97F3), U64(0x80E8A40E, 0xCCD228A4), /* ~= 10^-204 */
-    U64(0xC8A883C0, 0xFDAF7DF0), U64(0x6122CD12, 0x8006B2CD), /* ~= 10^-203 */
-    U64(0xFAD2A4B1, 0x3D1B5D6C), U64(0x796B8057, 0x20085F81), /* ~= 10^-202 */
-    U64(0x9CC3A6EE, 0xC6311A63), U64(0xCBE33036, 0x74053BB0), /* ~= 10^-201 */
-    U64(0xC3F490AA, 0x77BD60FC), U64(0xBEDBFC44, 0x11068A9C), /* ~= 10^-200 */
-    U64(0xF4F1B4D5, 0x15ACB93B), U64(0xEE92FB55, 0x15482D44), /* ~= 10^-199 */
-    U64(0x99171105, 0x2D8BF3C5), U64(0x751BDD15, 0x2D4D1C4A), /* ~= 10^-198 */
-    U64(0xBF5CD546, 0x78EEF0B6), U64(0xD262D45A, 0x78A0635D), /* ~= 10^-197 */
-    U64(0xEF340A98, 0x172AACE4), U64(0x86FB8971, 0x16C87C34), /* ~= 10^-196 */
-    U64(0x9580869F, 0x0E7AAC0E), U64(0xD45D35E6, 0xAE3D4DA0), /* ~= 10^-195 */
-    U64(0xBAE0A846, 0xD2195712), U64(0x89748360, 0x59CCA109), /* ~= 10^-194 */
-    U64(0xE998D258, 0x869FACD7), U64(0x2BD1A438, 0x703FC94B), /* ~= 10^-193 */
-    U64(0x91FF8377, 0x5423CC06), U64(0x7B6306A3, 0x4627DDCF), /* ~= 10^-192 */
-    U64(0xB67F6455, 0x292CBF08), U64(0x1A3BC84C, 0x17B1D542), /* ~= 10^-191 */
-    U64(0xE41F3D6A, 0x7377EECA), U64(0x20CABA5F, 0x1D9E4A93), /* ~= 10^-190 */
-    U64(0x8E938662, 0x882AF53E), U64(0x547EB47B, 0x7282EE9C), /* ~= 10^-189 */
-    U64(0xB23867FB, 0x2A35B28D), U64(0xE99E619A, 0x4F23AA43), /* ~= 10^-188 */
-    U64(0xDEC681F9, 0xF4C31F31), U64(0x6405FA00, 0xE2EC94D4), /* ~= 10^-187 */
-    U64(0x8B3C113C, 0x38F9F37E), U64(0xDE83BC40, 0x8DD3DD04), /* ~= 10^-186 */
-    U64(0xAE0B158B, 0x4738705E), U64(0x9624AB50, 0xB148D445), /* ~= 10^-185 */
-    U64(0xD98DDAEE, 0x19068C76), U64(0x3BADD624, 0xDD9B0957), /* ~= 10^-184 */
-    U64(0x87F8A8D4, 0xCFA417C9), U64(0xE54CA5D7, 0x0A80E5D6), /* ~= 10^-183 */
-    U64(0xA9F6D30A, 0x038D1DBC), U64(0x5E9FCF4C, 0xCD211F4C), /* ~= 10^-182 */
-    U64(0xD47487CC, 0x8470652B), U64(0x7647C320, 0x0069671F), /* ~= 10^-181 */
-    U64(0x84C8D4DF, 0xD2C63F3B), U64(0x29ECD9F4, 0x0041E073), /* ~= 10^-180 */
-    U64(0xA5FB0A17, 0xC777CF09), U64(0xF4681071, 0x00525890), /* ~= 10^-179 */
-    U64(0xCF79CC9D, 0xB955C2CC), U64(0x7182148D, 0x4066EEB4), /* ~= 10^-178 */
-    U64(0x81AC1FE2, 0x93D599BF), U64(0xC6F14CD8, 0x48405530), /* ~= 10^-177 */
-    U64(0xA21727DB, 0x38CB002F), U64(0xB8ADA00E, 0x5A506A7C), /* ~= 10^-176 */
-    U64(0xCA9CF1D2, 0x06FDC03B), U64(0xA6D90811, 0xF0E4851C), /* ~= 10^-175 */
-    U64(0xFD442E46, 0x88BD304A), U64(0x908F4A16, 0x6D1DA663), /* ~= 10^-174 */
-    U64(0x9E4A9CEC, 0x15763E2E), U64(0x9A598E4E, 0x043287FE), /* ~= 10^-173 */
-    U64(0xC5DD4427, 0x1AD3CDBA), U64(0x40EFF1E1, 0x853F29FD), /* ~= 10^-172 */
-    U64(0xF7549530, 0xE188C128), U64(0xD12BEE59, 0xE68EF47C), /* ~= 10^-171 */
-    U64(0x9A94DD3E, 0x8CF578B9), U64(0x82BB74F8, 0x301958CE), /* ~= 10^-170 */
-    U64(0xC13A148E, 0x3032D6E7), U64(0xE36A5236, 0x3C1FAF01), /* ~= 10^-169 */
-    U64(0xF18899B1, 0xBC3F8CA1), U64(0xDC44E6C3, 0xCB279AC1), /* ~= 10^-168 */
-    U64(0x96F5600F, 0x15A7B7E5), U64(0x29AB103A, 0x5EF8C0B9), /* ~= 10^-167 */
-    U64(0xBCB2B812, 0xDB11A5DE), U64(0x7415D448, 0xF6B6F0E7), /* ~= 10^-166 */
-    U64(0xEBDF6617, 0x91D60F56), U64(0x111B495B, 0x3464AD21), /* ~= 10^-165 */
-    U64(0x936B9FCE, 0xBB25C995), U64(0xCAB10DD9, 0x00BEEC34), /* ~= 10^-164 */
-    U64(0xB84687C2, 0x69EF3BFB), U64(0x3D5D514F, 0x40EEA742), /* ~= 10^-163 */
-    U64(0xE65829B3, 0x046B0AFA), U64(0x0CB4A5A3, 0x112A5112), /* ~= 10^-162 */
-    U64(0x8FF71A0F, 0xE2C2E6DC), U64(0x47F0E785, 0xEABA72AB), /* ~= 10^-161 */
-    U64(0xB3F4E093, 0xDB73A093), U64(0x59ED2167, 0x65690F56), /* ~= 10^-160 */
-    U64(0xE0F218B8, 0xD25088B8), U64(0x306869C1, 0x3EC3532C), /* ~= 10^-159 */
-    U64(0x8C974F73, 0x83725573), U64(0x1E414218, 0xC73A13FB), /* ~= 10^-158 */
-    U64(0xAFBD2350, 0x644EEACF), U64(0xE5D1929E, 0xF90898FA), /* ~= 10^-157 */
-    U64(0xDBAC6C24, 0x7D62A583), U64(0xDF45F746, 0xB74ABF39), /* ~= 10^-156 */
-    U64(0x894BC396, 0xCE5DA772), U64(0x6B8BBA8C, 0x328EB783), /* ~= 10^-155 */
-    U64(0xAB9EB47C, 0x81F5114F), U64(0x066EA92F, 0x3F326564), /* ~= 10^-154 */
-    U64(0xD686619B, 0xA27255A2), U64(0xC80A537B, 0x0EFEFEBD), /* ~= 10^-153 */
-    U64(0x8613FD01, 0x45877585), U64(0xBD06742C, 0xE95F5F36), /* ~= 10^-152 */
-    U64(0xA798FC41, 0x96E952E7), U64(0x2C481138, 0x23B73704), /* ~= 10^-151 */
-    U64(0xD17F3B51, 0xFCA3A7A0), U64(0xF75A1586, 0x2CA504C5), /* ~= 10^-150 */
-    U64(0x82EF8513, 0x3DE648C4), U64(0x9A984D73, 0xDBE722FB), /* ~= 10^-149 */
-    U64(0xA3AB6658, 0x0D5FDAF5), U64(0xC13E60D0, 0xD2E0EBBA), /* ~= 10^-148 */
-    U64(0xCC963FEE, 0x10B7D1B3), U64(0x318DF905, 0x079926A8), /* ~= 10^-147 */
-    U64(0xFFBBCFE9, 0x94E5C61F), U64(0xFDF17746, 0x497F7052), /* ~= 10^-146 */
-    U64(0x9FD561F1, 0xFD0F9BD3), U64(0xFEB6EA8B, 0xEDEFA633), /* ~= 10^-145 */
-    U64(0xC7CABA6E, 0x7C5382C8), U64(0xFE64A52E, 0xE96B8FC0), /* ~= 10^-144 */
-    U64(0xF9BD690A, 0x1B68637B), U64(0x3DFDCE7A, 0xA3C673B0), /* ~= 10^-143 */
-    U64(0x9C1661A6, 0x51213E2D), U64(0x06BEA10C, 0xA65C084E), /* ~= 10^-142 */
-    U64(0xC31BFA0F, 0xE5698DB8), U64(0x486E494F, 0xCFF30A62), /* ~= 10^-141 */
-    U64(0xF3E2F893, 0xDEC3F126), U64(0x5A89DBA3, 0xC3EFCCFA), /* ~= 10^-140 */
-    U64(0x986DDB5C, 0x6B3A76B7), U64(0xF8962946, 0x5A75E01C), /* ~= 10^-139 */
-    U64(0xBE895233, 0x86091465), U64(0xF6BBB397, 0xF1135823), /* ~= 10^-138 */
-    U64(0xEE2BA6C0, 0x678B597F), U64(0x746AA07D, 0xED582E2C), /* ~= 10^-137 */
-    U64(0x94DB4838, 0x40B717EF), U64(0xA8C2A44E, 0xB4571CDC), /* ~= 10^-136 */
-    U64(0xBA121A46, 0x50E4DDEB), U64(0x92F34D62, 0x616CE413), /* ~= 10^-135 */
-    U64(0xE896A0D7, 0xE51E1566), U64(0x77B020BA, 0xF9C81D17), /* ~= 10^-134 */
-    U64(0x915E2486, 0xEF32CD60), U64(0x0ACE1474, 0xDC1D122E), /* ~= 10^-133 */
-    U64(0xB5B5ADA8, 0xAAFF80B8), U64(0x0D819992, 0x132456BA), /* ~= 10^-132 */
-    U64(0xE3231912, 0xD5BF60E6), U64(0x10E1FFF6, 0x97ED6C69), /* ~= 10^-131 */
-    U64(0x8DF5EFAB, 0xC5979C8F), U64(0xCA8D3FFA, 0x1EF463C1), /* ~= 10^-130 */
-    U64(0xB1736B96, 0xB6FD83B3), U64(0xBD308FF8, 0xA6B17CB2), /* ~= 10^-129 */
-    U64(0xDDD0467C, 0x64BCE4A0), U64(0xAC7CB3F6, 0xD05DDBDE), /* ~= 10^-128 */
-    U64(0x8AA22C0D, 0xBEF60EE4), U64(0x6BCDF07A, 0x423AA96B), /* ~= 10^-127 */
-    U64(0xAD4AB711, 0x2EB3929D), U64(0x86C16C98, 0xD2C953C6), /* ~= 10^-126 */
-    U64(0xD89D64D5, 0x7A607744), U64(0xE871C7BF, 0x077BA8B7), /* ~= 10^-125 */
-    U64(0x87625F05, 0x6C7C4A8B), U64(0x11471CD7, 0x64AD4972), /* ~= 10^-124 */
-    U64(0xA93AF6C6, 0xC79B5D2D), U64(0xD598E40D, 0x3DD89BCF), /* ~= 10^-123 */
-    U64(0xD389B478, 0x79823479), U64(0x4AFF1D10, 0x8D4EC2C3), /* ~= 10^-122 */
-    U64(0x843610CB, 0x4BF160CB), U64(0xCEDF722A, 0x585139BA), /* ~= 10^-121 */
-    U64(0xA54394FE, 0x1EEDB8FE), U64(0xC2974EB4, 0xEE658828), /* ~= 10^-120 */
-    U64(0xCE947A3D, 0xA6A9273E), U64(0x733D2262, 0x29FEEA32), /* ~= 10^-119 */
-    U64(0x811CCC66, 0x8829B887), U64(0x0806357D, 0x5A3F525F), /* ~= 10^-118 */
-    U64(0xA163FF80, 0x2A3426A8), U64(0xCA07C2DC, 0xB0CF26F7), /* ~= 10^-117 */
-    U64(0xC9BCFF60, 0x34C13052), U64(0xFC89B393, 0xDD02F0B5), /* ~= 10^-116 */
-    U64(0xFC2C3F38, 0x41F17C67), U64(0xBBAC2078, 0xD443ACE2), /* ~= 10^-115 */
-    U64(0x9D9BA783, 0x2936EDC0), U64(0xD54B944B, 0x84AA4C0D), /* ~= 10^-114 */
-    U64(0xC5029163, 0xF384A931), U64(0x0A9E795E, 0x65D4DF11), /* ~= 10^-113 */
-    U64(0xF64335BC, 0xF065D37D), U64(0x4D4617B5, 0xFF4A16D5), /* ~= 10^-112 */
-    U64(0x99EA0196, 0x163FA42E), U64(0x504BCED1, 0xBF8E4E45), /* ~= 10^-111 */
-    U64(0xC06481FB, 0x9BCF8D39), U64(0xE45EC286, 0x2F71E1D6), /* ~= 10^-110 */
-    U64(0xF07DA27A, 0x82C37088), U64(0x5D767327, 0xBB4E5A4C), /* ~= 10^-109 */
-    U64(0x964E858C, 0x91BA2655), U64(0x3A6A07F8, 0xD510F86F), /* ~= 10^-108 */
-    U64(0xBBE226EF, 0xB628AFEA), U64(0x890489F7, 0x0A55368B), /* ~= 10^-107 */
-    U64(0xEADAB0AB, 0xA3B2DBE5), U64(0x2B45AC74, 0xCCEA842E), /* ~= 10^-106 */
-    U64(0x92C8AE6B, 0x464FC96F), U64(0x3B0B8BC9, 0x0012929D), /* ~= 10^-105 */
-    U64(0xB77ADA06, 0x17E3BBCB), U64(0x09CE6EBB, 0x40173744), /* ~= 10^-104 */
-    U64(0xE5599087, 0x9DDCAABD), U64(0xCC420A6A, 0x101D0515), /* ~= 10^-103 */
-    U64(0x8F57FA54, 0xC2A9EAB6), U64(0x9FA94682, 0x4A12232D), /* ~= 10^-102 */
-    U64(0xB32DF8E9, 0xF3546564), U64(0x47939822, 0xDC96ABF9), /* ~= 10^-101 */
-    U64(0xDFF97724, 0x70297EBD), U64(0x59787E2B, 0x93BC56F7), /* ~= 10^-100 */
-    U64(0x8BFBEA76, 0xC619EF36), U64(0x57EB4EDB, 0x3C55B65A), /* ~= 10^-99 */
-    U64(0xAEFAE514, 0x77A06B03), U64(0xEDE62292, 0x0B6B23F1), /* ~= 10^-98 */
-    U64(0xDAB99E59, 0x958885C4), U64(0xE95FAB36, 0x8E45ECED), /* ~= 10^-97 */
-    U64(0x88B402F7, 0xFD75539B), U64(0x11DBCB02, 0x18EBB414), /* ~= 10^-96 */
-    U64(0xAAE103B5, 0xFCD2A881), U64(0xD652BDC2, 0x9F26A119), /* ~= 10^-95 */
-    U64(0xD59944A3, 0x7C0752A2), U64(0x4BE76D33, 0x46F0495F), /* ~= 10^-94 */
-    U64(0x857FCAE6, 0x2D8493A5), U64(0x6F70A440, 0x0C562DDB), /* ~= 10^-93 */
-    U64(0xA6DFBD9F, 0xB8E5B88E), U64(0xCB4CCD50, 0x0F6BB952), /* ~= 10^-92 */
-    U64(0xD097AD07, 0xA71F26B2), U64(0x7E2000A4, 0x1346A7A7), /* ~= 10^-91 */
-    U64(0x825ECC24, 0xC873782F), U64(0x8ED40066, 0x8C0C28C8), /* ~= 10^-90 */
-    U64(0xA2F67F2D, 0xFA90563B), U64(0x72890080, 0x2F0F32FA), /* ~= 10^-89 */
-    U64(0xCBB41EF9, 0x79346BCA), U64(0x4F2B40A0, 0x3AD2FFB9), /* ~= 10^-88 */
-    U64(0xFEA126B7, 0xD78186BC), U64(0xE2F610C8, 0x4987BFA8), /* ~= 10^-87 */
-    U64(0x9F24B832, 0xE6B0F436), U64(0x0DD9CA7D, 0x2DF4D7C9), /* ~= 10^-86 */
-    U64(0xC6EDE63F, 0xA05D3143), U64(0x91503D1C, 0x79720DBB), /* ~= 10^-85 */
-    U64(0xF8A95FCF, 0x88747D94), U64(0x75A44C63, 0x97CE912A), /* ~= 10^-84 */
-    U64(0x9B69DBE1, 0xB548CE7C), U64(0xC986AFBE, 0x3EE11ABA), /* ~= 10^-83 */
-    U64(0xC24452DA, 0x229B021B), U64(0xFBE85BAD, 0xCE996168), /* ~= 10^-82 */
-    U64(0xF2D56790, 0xAB41C2A2), U64(0xFAE27299, 0x423FB9C3), /* ~= 10^-81 */
-    U64(0x97C560BA, 0x6B0919A5), U64(0xDCCD879F, 0xC967D41A), /* ~= 10^-80 */
-    U64(0xBDB6B8E9, 0x05CB600F), U64(0x5400E987, 0xBBC1C920), /* ~= 10^-79 */
-    U64(0xED246723, 0x473E3813), U64(0x290123E9, 0xAAB23B68), /* ~= 10^-78 */
-    U64(0x9436C076, 0x0C86E30B), U64(0xF9A0B672, 0x0AAF6521), /* ~= 10^-77 */
-    U64(0xB9447093, 0x8FA89BCE), U64(0xF808E40E, 0x8D5B3E69), /* ~= 10^-76 */
-    U64(0xE7958CB8, 0x7392C2C2), U64(0xB60B1D12, 0x30B20E04), /* ~= 10^-75 */
-    U64(0x90BD77F3, 0x483BB9B9), U64(0xB1C6F22B, 0x5E6F48C2), /* ~= 10^-74 */
-    U64(0xB4ECD5F0, 0x1A4AA828), U64(0x1E38AEB6, 0x360B1AF3), /* ~= 10^-73 */
-    U64(0xE2280B6C, 0x20DD5232), U64(0x25C6DA63, 0xC38DE1B0), /* ~= 10^-72 */
-    U64(0x8D590723, 0x948A535F), U64(0x579C487E, 0x5A38AD0E), /* ~= 10^-71 */
-    U64(0xB0AF48EC, 0x79ACE837), U64(0x2D835A9D, 0xF0C6D851), /* ~= 10^-70 */
-    U64(0xDCDB1B27, 0x98182244), U64(0xF8E43145, 0x6CF88E65), /* ~= 10^-69 */
-    U64(0x8A08F0F8, 0xBF0F156B), U64(0x1B8E9ECB, 0x641B58FF), /* ~= 10^-68 */
-    U64(0xAC8B2D36, 0xEED2DAC5), U64(0xE272467E, 0x3D222F3F), /* ~= 10^-67 */
-    U64(0xD7ADF884, 0xAA879177), U64(0x5B0ED81D, 0xCC6ABB0F), /* ~= 10^-66 */
-    U64(0x86CCBB52, 0xEA94BAEA), U64(0x98E94712, 0x9FC2B4E9), /* ~= 10^-65 */
-    U64(0xA87FEA27, 0xA539E9A5), U64(0x3F2398D7, 0x47B36224), /* ~= 10^-64 */
-    U64(0xD29FE4B1, 0x8E88640E), U64(0x8EEC7F0D, 0x19A03AAD), /* ~= 10^-63 */
-    U64(0x83A3EEEE, 0xF9153E89), U64(0x1953CF68, 0x300424AC), /* ~= 10^-62 */
-    U64(0xA48CEAAA, 0xB75A8E2B), U64(0x5FA8C342, 0x3C052DD7), /* ~= 10^-61 */
-    U64(0xCDB02555, 0x653131B6), U64(0x3792F412, 0xCB06794D), /* ~= 10^-60 */
-    U64(0x808E1755, 0x5F3EBF11), U64(0xE2BBD88B, 0xBEE40BD0), /* ~= 10^-59 */
-    U64(0xA0B19D2A, 0xB70E6ED6), U64(0x5B6ACEAE, 0xAE9D0EC4), /* ~= 10^-58 */
-    U64(0xC8DE0475, 0x64D20A8B), U64(0xF245825A, 0x5A445275), /* ~= 10^-57 */
-    U64(0xFB158592, 0xBE068D2E), U64(0xEED6E2F0, 0xF0D56712), /* ~= 10^-56 */
-    U64(0x9CED737B, 0xB6C4183D), U64(0x55464DD6, 0x9685606B), /* ~= 10^-55 */
-    U64(0xC428D05A, 0xA4751E4C), U64(0xAA97E14C, 0x3C26B886), /* ~= 10^-54 */
-    U64(0xF5330471, 0x4D9265DF), U64(0xD53DD99F, 0x4B3066A8), /* ~= 10^-53 */
-    U64(0x993FE2C6, 0xD07B7FAB), U64(0xE546A803, 0x8EFE4029), /* ~= 10^-52 */
-    U64(0xBF8FDB78, 0x849A5F96), U64(0xDE985204, 0x72BDD033), /* ~= 10^-51 */
-    U64(0xEF73D256, 0xA5C0F77C), U64(0x963E6685, 0x8F6D4440), /* ~= 10^-50 */
-    U64(0x95A86376, 0x27989AAD), U64(0xDDE70013, 0x79A44AA8), /* ~= 10^-49 */
-    U64(0xBB127C53, 0xB17EC159), U64(0x5560C018, 0x580D5D52), /* ~= 10^-48 */
-    U64(0xE9D71B68, 0x9DDE71AF), U64(0xAAB8F01E, 0x6E10B4A6), /* ~= 10^-47 */
-    U64(0x92267121, 0x62AB070D), U64(0xCAB39613, 0x04CA70E8), /* ~= 10^-46 */
-    U64(0xB6B00D69, 0xBB55C8D1), U64(0x3D607B97, 0xC5FD0D22), /* ~= 10^-45 */
-    U64(0xE45C10C4, 0x2A2B3B05), U64(0x8CB89A7D, 0xB77C506A), /* ~= 10^-44 */
-    U64(0x8EB98A7A, 0x9A5B04E3), U64(0x77F3608E, 0x92ADB242), /* ~= 10^-43 */
-    U64(0xB267ED19, 0x40F1C61C), U64(0x55F038B2, 0x37591ED3), /* ~= 10^-42 */
-    U64(0xDF01E85F, 0x912E37A3), U64(0x6B6C46DE, 0xC52F6688), /* ~= 10^-41 */
-    U64(0x8B61313B, 0xBABCE2C6), U64(0x2323AC4B, 0x3B3DA015), /* ~= 10^-40 */
-    U64(0xAE397D8A, 0xA96C1B77), U64(0xABEC975E, 0x0A0D081A), /* ~= 10^-39 */
-    U64(0xD9C7DCED, 0x53C72255), U64(0x96E7BD35, 0x8C904A21), /* ~= 10^-38 */
-    U64(0x881CEA14, 0x545C7575), U64(0x7E50D641, 0x77DA2E54), /* ~= 10^-37 */
-    U64(0xAA242499, 0x697392D2), U64(0xDDE50BD1, 0xD5D0B9E9), /* ~= 10^-36 */
-    U64(0xD4AD2DBF, 0xC3D07787), U64(0x955E4EC6, 0x4B44E864), /* ~= 10^-35 */
-    U64(0x84EC3C97, 0xDA624AB4), U64(0xBD5AF13B, 0xEF0B113E), /* ~= 10^-34 */
-    U64(0xA6274BBD, 0xD0FADD61), U64(0xECB1AD8A, 0xEACDD58E), /* ~= 10^-33 */
-    U64(0xCFB11EAD, 0x453994BA), U64(0x67DE18ED, 0xA5814AF2), /* ~= 10^-32 */
-    U64(0x81CEB32C, 0x4B43FCF4), U64(0x80EACF94, 0x8770CED7), /* ~= 10^-31 */
-    U64(0xA2425FF7, 0x5E14FC31), U64(0xA1258379, 0xA94D028D), /* ~= 10^-30 */
-    U64(0xCAD2F7F5, 0x359A3B3E), U64(0x096EE458, 0x13A04330), /* ~= 10^-29 */
-    U64(0xFD87B5F2, 0x8300CA0D), U64(0x8BCA9D6E, 0x188853FC), /* ~= 10^-28 */
-    U64(0x9E74D1B7, 0x91E07E48), U64(0x775EA264, 0xCF55347D), /* ~= 10^-27 */
-    U64(0xC6120625, 0x76589DDA), U64(0x95364AFE, 0x032A819D), /* ~= 10^-26 */
-    U64(0xF79687AE, 0xD3EEC551), U64(0x3A83DDBD, 0x83F52204), /* ~= 10^-25 */
-    U64(0x9ABE14CD, 0x44753B52), U64(0xC4926A96, 0x72793542), /* ~= 10^-24 */
-    U64(0xC16D9A00, 0x95928A27), U64(0x75B7053C, 0x0F178293), /* ~= 10^-23 */
-    U64(0xF1C90080, 0xBAF72CB1), U64(0x5324C68B, 0x12DD6338), /* ~= 10^-22 */
-    U64(0x971DA050, 0x74DA7BEE), U64(0xD3F6FC16, 0xEBCA5E03), /* ~= 10^-21 */
-    U64(0xBCE50864, 0x92111AEA), U64(0x88F4BB1C, 0xA6BCF584), /* ~= 10^-20 */
-    U64(0xEC1E4A7D, 0xB69561A5), U64(0x2B31E9E3, 0xD06C32E5), /* ~= 10^-19 */
-    U64(0x9392EE8E, 0x921D5D07), U64(0x3AFF322E, 0x62439FCF), /* ~= 10^-18 */
-    U64(0xB877AA32, 0x36A4B449), U64(0x09BEFEB9, 0xFAD487C2), /* ~= 10^-17 */
-    U64(0xE69594BE, 0xC44DE15B), U64(0x4C2EBE68, 0x7989A9B3), /* ~= 10^-16 */
-    U64(0x901D7CF7, 0x3AB0ACD9), U64(0x0F9D3701, 0x4BF60A10), /* ~= 10^-15 */
-    U64(0xB424DC35, 0x095CD80F), U64(0x538484C1, 0x9EF38C94), /* ~= 10^-14 */
-    U64(0xE12E1342, 0x4BB40E13), U64(0x2865A5F2, 0x06B06FB9), /* ~= 10^-13 */
-    U64(0x8CBCCC09, 0x6F5088CB), U64(0xF93F87B7, 0x442E45D3), /* ~= 10^-12 */
-    U64(0xAFEBFF0B, 0xCB24AAFE), U64(0xF78F69A5, 0x1539D748), /* ~= 10^-11 */
-    U64(0xDBE6FECE, 0xBDEDD5BE), U64(0xB573440E, 0x5A884D1B), /* ~= 10^-10 */
-    U64(0x89705F41, 0x36B4A597), U64(0x31680A88, 0xF8953030), /* ~= 10^-9 */
-    U64(0xABCC7711, 0x8461CEFC), U64(0xFDC20D2B, 0x36BA7C3D), /* ~= 10^-8 */
-    U64(0xD6BF94D5, 0xE57A42BC), U64(0x3D329076, 0x04691B4C), /* ~= 10^-7 */
-    U64(0x8637BD05, 0xAF6C69B5), U64(0xA63F9A49, 0xC2C1B10F), /* ~= 10^-6 */
-    U64(0xA7C5AC47, 0x1B478423), U64(0x0FCF80DC, 0x33721D53), /* ~= 10^-5 */
-    U64(0xD1B71758, 0xE219652B), U64(0xD3C36113, 0x404EA4A8), /* ~= 10^-4 */
-    U64(0x83126E97, 0x8D4FDF3B), U64(0x645A1CAC, 0x083126E9), /* ~= 10^-3 */
-    U64(0xA3D70A3D, 0x70A3D70A), U64(0x3D70A3D7, 0x0A3D70A3), /* ~= 10^-2 */
-    U64(0xCCCCCCCC, 0xCCCCCCCC), U64(0xCCCCCCCC, 0xCCCCCCCC), /* ~= 10^-1 */
-    U64(0x80000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^0 */
-    U64(0xA0000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^1 */
-    U64(0xC8000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^2 */
-    U64(0xFA000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^3 */
-    U64(0x9C400000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^4 */
-    U64(0xC3500000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^5 */
-    U64(0xF4240000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^6 */
-    U64(0x98968000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^7 */
-    U64(0xBEBC2000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^8 */
-    U64(0xEE6B2800, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^9 */
-    U64(0x9502F900, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^10 */
-    U64(0xBA43B740, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^11 */
-    U64(0xE8D4A510, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^12 */
-    U64(0x9184E72A, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^13 */
-    U64(0xB5E620F4, 0x80000000), U64(0x00000000, 0x00000000), /* == 10^14 */
-    U64(0xE35FA931, 0xA0000000), U64(0x00000000, 0x00000000), /* == 10^15 */
-    U64(0x8E1BC9BF, 0x04000000), U64(0x00000000, 0x00000000), /* == 10^16 */
-    U64(0xB1A2BC2E, 0xC5000000), U64(0x00000000, 0x00000000), /* == 10^17 */
-    U64(0xDE0B6B3A, 0x76400000), U64(0x00000000, 0x00000000), /* == 10^18 */
-    U64(0x8AC72304, 0x89E80000), U64(0x00000000, 0x00000000), /* == 10^19 */
-    U64(0xAD78EBC5, 0xAC620000), U64(0x00000000, 0x00000000), /* == 10^20 */
-    U64(0xD8D726B7, 0x177A8000), U64(0x00000000, 0x00000000), /* == 10^21 */
-    U64(0x87867832, 0x6EAC9000), U64(0x00000000, 0x00000000), /* == 10^22 */
-    U64(0xA968163F, 0x0A57B400), U64(0x00000000, 0x00000000), /* == 10^23 */
-    U64(0xD3C21BCE, 0xCCEDA100), U64(0x00000000, 0x00000000), /* == 10^24 */
-    U64(0x84595161, 0x401484A0), U64(0x00000000, 0x00000000), /* == 10^25 */
-    U64(0xA56FA5B9, 0x9019A5C8), U64(0x00000000, 0x00000000), /* == 10^26 */
-    U64(0xCECB8F27, 0xF4200F3A), U64(0x00000000, 0x00000000), /* == 10^27 */
-    U64(0x813F3978, 0xF8940984), U64(0x40000000, 0x00000000), /* == 10^28 */
-    U64(0xA18F07D7, 0x36B90BE5), U64(0x50000000, 0x00000000), /* == 10^29 */
-    U64(0xC9F2C9CD, 0x04674EDE), U64(0xA4000000, 0x00000000), /* == 10^30 */
-    U64(0xFC6F7C40, 0x45812296), U64(0x4D000000, 0x00000000), /* == 10^31 */
-    U64(0x9DC5ADA8, 0x2B70B59D), U64(0xF0200000, 0x00000000), /* == 10^32 */
-    U64(0xC5371912, 0x364CE305), U64(0x6C280000, 0x00000000), /* == 10^33 */
-    U64(0xF684DF56, 0xC3E01BC6), U64(0xC7320000, 0x00000000), /* == 10^34 */
-    U64(0x9A130B96, 0x3A6C115C), U64(0x3C7F4000, 0x00000000), /* == 10^35 */
-    U64(0xC097CE7B, 0xC90715B3), U64(0x4B9F1000, 0x00000000), /* == 10^36 */
-    U64(0xF0BDC21A, 0xBB48DB20), U64(0x1E86D400, 0x00000000), /* == 10^37 */
-    U64(0x96769950, 0xB50D88F4), U64(0x13144480, 0x00000000), /* == 10^38 */
-    U64(0xBC143FA4, 0xE250EB31), U64(0x17D955A0, 0x00000000), /* == 10^39 */
-    U64(0xEB194F8E, 0x1AE525FD), U64(0x5DCFAB08, 0x00000000), /* == 10^40 */
-    U64(0x92EFD1B8, 0xD0CF37BE), U64(0x5AA1CAE5, 0x00000000), /* == 10^41 */
-    U64(0xB7ABC627, 0x050305AD), U64(0xF14A3D9E, 0x40000000), /* == 10^42 */
-    U64(0xE596B7B0, 0xC643C719), U64(0x6D9CCD05, 0xD0000000), /* == 10^43 */
-    U64(0x8F7E32CE, 0x7BEA5C6F), U64(0xE4820023, 0xA2000000), /* == 10^44 */
-    U64(0xB35DBF82, 0x1AE4F38B), U64(0xDDA2802C, 0x8A800000), /* == 10^45 */
-    U64(0xE0352F62, 0xA19E306E), U64(0xD50B2037, 0xAD200000), /* == 10^46 */
-    U64(0x8C213D9D, 0xA502DE45), U64(0x4526F422, 0xCC340000), /* == 10^47 */
-    U64(0xAF298D05, 0x0E4395D6), U64(0x9670B12B, 0x7F410000), /* == 10^48 */
-    U64(0xDAF3F046, 0x51D47B4C), U64(0x3C0CDD76, 0x5F114000), /* == 10^49 */
-    U64(0x88D8762B, 0xF324CD0F), U64(0xA5880A69, 0xFB6AC800), /* == 10^50 */
-    U64(0xAB0E93B6, 0xEFEE0053), U64(0x8EEA0D04, 0x7A457A00), /* == 10^51 */
-    U64(0xD5D238A4, 0xABE98068), U64(0x72A49045, 0x98D6D880), /* == 10^52 */
-    U64(0x85A36366, 0xEB71F041), U64(0x47A6DA2B, 0x7F864750), /* == 10^53 */
-    U64(0xA70C3C40, 0xA64E6C51), U64(0x999090B6, 0x5F67D924), /* == 10^54 */
-    U64(0xD0CF4B50, 0xCFE20765), U64(0xFFF4B4E3, 0xF741CF6D), /* == 10^55 */
-    U64(0x82818F12, 0x81ED449F), U64(0xBFF8F10E, 0x7A8921A4), /* ~= 10^56 */
-    U64(0xA321F2D7, 0x226895C7), U64(0xAFF72D52, 0x192B6A0D), /* ~= 10^57 */
-    U64(0xCBEA6F8C, 0xEB02BB39), U64(0x9BF4F8A6, 0x9F764490), /* ~= 10^58 */
-    U64(0xFEE50B70, 0x25C36A08), U64(0x02F236D0, 0x4753D5B4), /* ~= 10^59 */
-    U64(0x9F4F2726, 0x179A2245), U64(0x01D76242, 0x2C946590), /* ~= 10^60 */
-    U64(0xC722F0EF, 0x9D80AAD6), U64(0x424D3AD2, 0xB7B97EF5), /* ~= 10^61 */
-    U64(0xF8EBAD2B, 0x84E0D58B), U64(0xD2E08987, 0x65A7DEB2), /* ~= 10^62 */
-    U64(0x9B934C3B, 0x330C8577), U64(0x63CC55F4, 0x9F88EB2F), /* ~= 10^63 */
-    U64(0xC2781F49, 0xFFCFA6D5), U64(0x3CBF6B71, 0xC76B25FB), /* ~= 10^64 */
-    U64(0xF316271C, 0x7FC3908A), U64(0x8BEF464E, 0x3945EF7A), /* ~= 10^65 */
-    U64(0x97EDD871, 0xCFDA3A56), U64(0x97758BF0, 0xE3CBB5AC), /* ~= 10^66 */
-    U64(0xBDE94E8E, 0x43D0C8EC), U64(0x3D52EEED, 0x1CBEA317), /* ~= 10^67 */
-    U64(0xED63A231, 0xD4C4FB27), U64(0x4CA7AAA8, 0x63EE4BDD), /* ~= 10^68 */
-    U64(0x945E455F, 0x24FB1CF8), U64(0x8FE8CAA9, 0x3E74EF6A), /* ~= 10^69 */
-    U64(0xB975D6B6, 0xEE39E436), U64(0xB3E2FD53, 0x8E122B44), /* ~= 10^70 */
-    U64(0xE7D34C64, 0xA9C85D44), U64(0x60DBBCA8, 0x7196B616), /* ~= 10^71 */
-    U64(0x90E40FBE, 0xEA1D3A4A), U64(0xBC8955E9, 0x46FE31CD), /* ~= 10^72 */
-    U64(0xB51D13AE, 0xA4A488DD), U64(0x6BABAB63, 0x98BDBE41), /* ~= 10^73 */
-    U64(0xE264589A, 0x4DCDAB14), U64(0xC696963C, 0x7EED2DD1), /* ~= 10^74 */
-    U64(0x8D7EB760, 0x70A08AEC), U64(0xFC1E1DE5, 0xCF543CA2), /* ~= 10^75 */
-    U64(0xB0DE6538, 0x8CC8ADA8), U64(0x3B25A55F, 0x43294BCB), /* ~= 10^76 */
-    U64(0xDD15FE86, 0xAFFAD912), U64(0x49EF0EB7, 0x13F39EBE), /* ~= 10^77 */
-    U64(0x8A2DBF14, 0x2DFCC7AB), U64(0x6E356932, 0x6C784337), /* ~= 10^78 */
-    U64(0xACB92ED9, 0x397BF996), U64(0x49C2C37F, 0x07965404), /* ~= 10^79 */
-    U64(0xD7E77A8F, 0x87DAF7FB), U64(0xDC33745E, 0xC97BE906), /* ~= 10^80 */
-    U64(0x86F0AC99, 0xB4E8DAFD), U64(0x69A028BB, 0x3DED71A3), /* ~= 10^81 */
-    U64(0xA8ACD7C0, 0x222311BC), U64(0xC40832EA, 0x0D68CE0C), /* ~= 10^82 */
-    U64(0xD2D80DB0, 0x2AABD62B), U64(0xF50A3FA4, 0x90C30190), /* ~= 10^83 */
-    U64(0x83C7088E, 0x1AAB65DB), U64(0x792667C6, 0xDA79E0FA), /* ~= 10^84 */
-    U64(0xA4B8CAB1, 0xA1563F52), U64(0x577001B8, 0x91185938), /* ~= 10^85 */
-    U64(0xCDE6FD5E, 0x09ABCF26), U64(0xED4C0226, 0xB55E6F86), /* ~= 10^86 */
-    U64(0x80B05E5A, 0xC60B6178), U64(0x544F8158, 0x315B05B4), /* ~= 10^87 */
-    U64(0xA0DC75F1, 0x778E39D6), U64(0x696361AE, 0x3DB1C721), /* ~= 10^88 */
-    U64(0xC913936D, 0xD571C84C), U64(0x03BC3A19, 0xCD1E38E9), /* ~= 10^89 */
-    U64(0xFB587849, 0x4ACE3A5F), U64(0x04AB48A0, 0x4065C723), /* ~= 10^90 */
-    U64(0x9D174B2D, 0xCEC0E47B), U64(0x62EB0D64, 0x283F9C76), /* ~= 10^91 */
-    U64(0xC45D1DF9, 0x42711D9A), U64(0x3BA5D0BD, 0x324F8394), /* ~= 10^92 */
-    U64(0xF5746577, 0x930D6500), U64(0xCA8F44EC, 0x7EE36479), /* ~= 10^93 */
-    U64(0x9968BF6A, 0xBBE85F20), U64(0x7E998B13, 0xCF4E1ECB), /* ~= 10^94 */
-    U64(0xBFC2EF45, 0x6AE276E8), U64(0x9E3FEDD8, 0xC321A67E), /* ~= 10^95 */
-    U64(0xEFB3AB16, 0xC59B14A2), U64(0xC5CFE94E, 0xF3EA101E), /* ~= 10^96 */
-    U64(0x95D04AEE, 0x3B80ECE5), U64(0xBBA1F1D1, 0x58724A12), /* ~= 10^97 */
-    U64(0xBB445DA9, 0xCA61281F), U64(0x2A8A6E45, 0xAE8EDC97), /* ~= 10^98 */
-    U64(0xEA157514, 0x3CF97226), U64(0xF52D09D7, 0x1A3293BD), /* ~= 10^99 */
-    U64(0x924D692C, 0xA61BE758), U64(0x593C2626, 0x705F9C56), /* ~= 10^100 */
-    U64(0xB6E0C377, 0xCFA2E12E), U64(0x6F8B2FB0, 0x0C77836C), /* ~= 10^101 */
-    U64(0xE498F455, 0xC38B997A), U64(0x0B6DFB9C, 0x0F956447), /* ~= 10^102 */
-    U64(0x8EDF98B5, 0x9A373FEC), U64(0x4724BD41, 0x89BD5EAC), /* ~= 10^103 */
-    U64(0xB2977EE3, 0x00C50FE7), U64(0x58EDEC91, 0xEC2CB657), /* ~= 10^104 */
-    U64(0xDF3D5E9B, 0xC0F653E1), U64(0x2F2967B6, 0x6737E3ED), /* ~= 10^105 */
-    U64(0x8B865B21, 0x5899F46C), U64(0xBD79E0D2, 0x0082EE74), /* ~= 10^106 */
-    U64(0xAE67F1E9, 0xAEC07187), U64(0xECD85906, 0x80A3AA11), /* ~= 10^107 */
-    U64(0xDA01EE64, 0x1A708DE9), U64(0xE80E6F48, 0x20CC9495), /* ~= 10^108 */
-    U64(0x884134FE, 0x908658B2), U64(0x3109058D, 0x147FDCDD), /* ~= 10^109 */
-    U64(0xAA51823E, 0x34A7EEDE), U64(0xBD4B46F0, 0x599FD415), /* ~= 10^110 */
-    U64(0xD4E5E2CD, 0xC1D1EA96), U64(0x6C9E18AC, 0x7007C91A), /* ~= 10^111 */
-    U64(0x850FADC0, 0x9923329E), U64(0x03E2CF6B, 0xC604DDB0), /* ~= 10^112 */
-    U64(0xA6539930, 0xBF6BFF45), U64(0x84DB8346, 0xB786151C), /* ~= 10^113 */
-    U64(0xCFE87F7C, 0xEF46FF16), U64(0xE6126418, 0x65679A63), /* ~= 10^114 */
-    U64(0x81F14FAE, 0x158C5F6E), U64(0x4FCB7E8F, 0x3F60C07E), /* ~= 10^115 */
-    U64(0xA26DA399, 0x9AEF7749), U64(0xE3BE5E33, 0x0F38F09D), /* ~= 10^116 */
-    U64(0xCB090C80, 0x01AB551C), U64(0x5CADF5BF, 0xD3072CC5), /* ~= 10^117 */
-    U64(0xFDCB4FA0, 0x02162A63), U64(0x73D9732F, 0xC7C8F7F6), /* ~= 10^118 */
-    U64(0x9E9F11C4, 0x014DDA7E), U64(0x2867E7FD, 0xDCDD9AFA), /* ~= 10^119 */
-    U64(0xC646D635, 0x01A1511D), U64(0xB281E1FD, 0x541501B8), /* ~= 10^120 */
-    U64(0xF7D88BC2, 0x4209A565), U64(0x1F225A7C, 0xA91A4226), /* ~= 10^121 */
-    U64(0x9AE75759, 0x6946075F), U64(0x3375788D, 0xE9B06958), /* ~= 10^122 */
-    U64(0xC1A12D2F, 0xC3978937), U64(0x0052D6B1, 0x641C83AE), /* ~= 10^123 */
-    U64(0xF209787B, 0xB47D6B84), U64(0xC0678C5D, 0xBD23A49A), /* ~= 10^124 */
-    U64(0x9745EB4D, 0x50CE6332), U64(0xF840B7BA, 0x963646E0), /* ~= 10^125 */
-    U64(0xBD176620, 0xA501FBFF), U64(0xB650E5A9, 0x3BC3D898), /* ~= 10^126 */
-    U64(0xEC5D3FA8, 0xCE427AFF), U64(0xA3E51F13, 0x8AB4CEBE), /* ~= 10^127 */
-    U64(0x93BA47C9, 0x80E98CDF), U64(0xC66F336C, 0x36B10137), /* ~= 10^128 */
-    U64(0xB8A8D9BB, 0xE123F017), U64(0xB80B0047, 0x445D4184), /* ~= 10^129 */
-    U64(0xE6D3102A, 0xD96CEC1D), U64(0xA60DC059, 0x157491E5), /* ~= 10^130 */
-    U64(0x9043EA1A, 0xC7E41392), U64(0x87C89837, 0xAD68DB2F), /* ~= 10^131 */
-    U64(0xB454E4A1, 0x79DD1877), U64(0x29BABE45, 0x98C311FB), /* ~= 10^132 */
-    U64(0xE16A1DC9, 0xD8545E94), U64(0xF4296DD6, 0xFEF3D67A), /* ~= 10^133 */
-    U64(0x8CE2529E, 0x2734BB1D), U64(0x1899E4A6, 0x5F58660C), /* ~= 10^134 */
-    U64(0xB01AE745, 0xB101E9E4), U64(0x5EC05DCF, 0xF72E7F8F), /* ~= 10^135 */
-    U64(0xDC21A117, 0x1D42645D), U64(0x76707543, 0xF4FA1F73), /* ~= 10^136 */
-    U64(0x899504AE, 0x72497EBA), U64(0x6A06494A, 0x791C53A8), /* ~= 10^137 */
-    U64(0xABFA45DA, 0x0EDBDE69), U64(0x0487DB9D, 0x17636892), /* ~= 10^138 */
-    U64(0xD6F8D750, 0x9292D603), U64(0x45A9D284, 0x5D3C42B6), /* ~= 10^139 */
-    U64(0x865B8692, 0x5B9BC5C2), U64(0x0B8A2392, 0xBA45A9B2), /* ~= 10^140 */
-    U64(0xA7F26836, 0xF282B732), U64(0x8E6CAC77, 0x68D7141E), /* ~= 10^141 */
-    U64(0xD1EF0244, 0xAF2364FF), U64(0x3207D795, 0x430CD926), /* ~= 10^142 */
-    U64(0x8335616A, 0xED761F1F), U64(0x7F44E6BD, 0x49E807B8), /* ~= 10^143 */
-    U64(0xA402B9C5, 0xA8D3A6E7), U64(0x5F16206C, 0x9C6209A6), /* ~= 10^144 */
-    U64(0xCD036837, 0x130890A1), U64(0x36DBA887, 0xC37A8C0F), /* ~= 10^145 */
-    U64(0x80222122, 0x6BE55A64), U64(0xC2494954, 0xDA2C9789), /* ~= 10^146 */
-    U64(0xA02AA96B, 0x06DEB0FD), U64(0xF2DB9BAA, 0x10B7BD6C), /* ~= 10^147 */
-    U64(0xC83553C5, 0xC8965D3D), U64(0x6F928294, 0x94E5ACC7), /* ~= 10^148 */
-    U64(0xFA42A8B7, 0x3ABBF48C), U64(0xCB772339, 0xBA1F17F9), /* ~= 10^149 */
-    U64(0x9C69A972, 0x84B578D7), U64(0xFF2A7604, 0x14536EFB), /* ~= 10^150 */
-    U64(0xC38413CF, 0x25E2D70D), U64(0xFEF51385, 0x19684ABA), /* ~= 10^151 */
-    U64(0xF46518C2, 0xEF5B8CD1), U64(0x7EB25866, 0x5FC25D69), /* ~= 10^152 */
-    U64(0x98BF2F79, 0xD5993802), U64(0xEF2F773F, 0xFBD97A61), /* ~= 10^153 */
-    U64(0xBEEEFB58, 0x4AFF8603), U64(0xAAFB550F, 0xFACFD8FA), /* ~= 10^154 */
-    U64(0xEEAABA2E, 0x5DBF6784), U64(0x95BA2A53, 0xF983CF38), /* ~= 10^155 */
-    U64(0x952AB45C, 0xFA97A0B2), U64(0xDD945A74, 0x7BF26183), /* ~= 10^156 */
-    U64(0xBA756174, 0x393D88DF), U64(0x94F97111, 0x9AEEF9E4), /* ~= 10^157 */
-    U64(0xE912B9D1, 0x478CEB17), U64(0x7A37CD56, 0x01AAB85D), /* ~= 10^158 */
-    U64(0x91ABB422, 0xCCB812EE), U64(0xAC62E055, 0xC10AB33A), /* ~= 10^159 */
-    U64(0xB616A12B, 0x7FE617AA), U64(0x577B986B, 0x314D6009), /* ~= 10^160 */
-    U64(0xE39C4976, 0x5FDF9D94), U64(0xED5A7E85, 0xFDA0B80B), /* ~= 10^161 */
-    U64(0x8E41ADE9, 0xFBEBC27D), U64(0x14588F13, 0xBE847307), /* ~= 10^162 */
-    U64(0xB1D21964, 0x7AE6B31C), U64(0x596EB2D8, 0xAE258FC8), /* ~= 10^163 */
-    U64(0xDE469FBD, 0x99A05FE3), U64(0x6FCA5F8E, 0xD9AEF3BB), /* ~= 10^164 */
-    U64(0x8AEC23D6, 0x80043BEE), U64(0x25DE7BB9, 0x480D5854), /* ~= 10^165 */
-    U64(0xADA72CCC, 0x20054AE9), U64(0xAF561AA7, 0x9A10AE6A), /* ~= 10^166 */
-    U64(0xD910F7FF, 0x28069DA4), U64(0x1B2BA151, 0x8094DA04), /* ~= 10^167 */
-    U64(0x87AA9AFF, 0x79042286), U64(0x90FB44D2, 0xF05D0842), /* ~= 10^168 */
-    U64(0xA99541BF, 0x57452B28), U64(0x353A1607, 0xAC744A53), /* ~= 10^169 */
-    U64(0xD3FA922F, 0x2D1675F2), U64(0x42889B89, 0x97915CE8), /* ~= 10^170 */
-    U64(0x847C9B5D, 0x7C2E09B7), U64(0x69956135, 0xFEBADA11), /* ~= 10^171 */
-    U64(0xA59BC234, 0xDB398C25), U64(0x43FAB983, 0x7E699095), /* ~= 10^172 */
-    U64(0xCF02B2C2, 0x1207EF2E), U64(0x94F967E4, 0x5E03F4BB), /* ~= 10^173 */
-    U64(0x8161AFB9, 0x4B44F57D), U64(0x1D1BE0EE, 0xBAC278F5), /* ~= 10^174 */
-    U64(0xA1BA1BA7, 0x9E1632DC), U64(0x6462D92A, 0x69731732), /* ~= 10^175 */
-    U64(0xCA28A291, 0x859BBF93), U64(0x7D7B8F75, 0x03CFDCFE), /* ~= 10^176 */
-    U64(0xFCB2CB35, 0xE702AF78), U64(0x5CDA7352, 0x44C3D43E), /* ~= 10^177 */
-    U64(0x9DEFBF01, 0xB061ADAB), U64(0x3A088813, 0x6AFA64A7), /* ~= 10^178 */
-    U64(0xC56BAEC2, 0x1C7A1916), U64(0x088AAA18, 0x45B8FDD0), /* ~= 10^179 */
-    U64(0xF6C69A72, 0xA3989F5B), U64(0x8AAD549E, 0x57273D45), /* ~= 10^180 */
-    U64(0x9A3C2087, 0xA63F6399), U64(0x36AC54E2, 0xF678864B), /* ~= 10^181 */
-    U64(0xC0CB28A9, 0x8FCF3C7F), U64(0x84576A1B, 0xB416A7DD), /* ~= 10^182 */
-    U64(0xF0FDF2D3, 0xF3C30B9F), U64(0x656D44A2, 0xA11C51D5), /* ~= 10^183 */
-    U64(0x969EB7C4, 0x7859E743), U64(0x9F644AE5, 0xA4B1B325), /* ~= 10^184 */
-    U64(0xBC4665B5, 0x96706114), U64(0x873D5D9F, 0x0DDE1FEE), /* ~= 10^185 */
-    U64(0xEB57FF22, 0xFC0C7959), U64(0xA90CB506, 0xD155A7EA), /* ~= 10^186 */
-    U64(0x9316FF75, 0xDD87CBD8), U64(0x09A7F124, 0x42D588F2), /* ~= 10^187 */
-    U64(0xB7DCBF53, 0x54E9BECE), U64(0x0C11ED6D, 0x538AEB2F), /* ~= 10^188 */
-    U64(0xE5D3EF28, 0x2A242E81), U64(0x8F1668C8, 0xA86DA5FA), /* ~= 10^189 */
-    U64(0x8FA47579, 0x1A569D10), U64(0xF96E017D, 0x694487BC), /* ~= 10^190 */
-    U64(0xB38D92D7, 0x60EC4455), U64(0x37C981DC, 0xC395A9AC), /* ~= 10^191 */
-    U64(0xE070F78D, 0x3927556A), U64(0x85BBE253, 0xF47B1417), /* ~= 10^192 */
-    U64(0x8C469AB8, 0x43B89562), U64(0x93956D74, 0x78CCEC8E), /* ~= 10^193 */
-    U64(0xAF584166, 0x54A6BABB), U64(0x387AC8D1, 0x970027B2), /* ~= 10^194 */
-    U64(0xDB2E51BF, 0xE9D0696A), U64(0x06997B05, 0xFCC0319E), /* ~= 10^195 */
-    U64(0x88FCF317, 0xF22241E2), U64(0x441FECE3, 0xBDF81F03), /* ~= 10^196 */
-    U64(0xAB3C2FDD, 0xEEAAD25A), U64(0xD527E81C, 0xAD7626C3), /* ~= 10^197 */
-    U64(0xD60B3BD5, 0x6A5586F1), U64(0x8A71E223, 0xD8D3B074), /* ~= 10^198 */
-    U64(0x85C70565, 0x62757456), U64(0xF6872D56, 0x67844E49), /* ~= 10^199 */
-    U64(0xA738C6BE, 0xBB12D16C), U64(0xB428F8AC, 0x016561DB), /* ~= 10^200 */
-    U64(0xD106F86E, 0x69D785C7), U64(0xE13336D7, 0x01BEBA52), /* ~= 10^201 */
-    U64(0x82A45B45, 0x0226B39C), U64(0xECC00246, 0x61173473), /* ~= 10^202 */
-    U64(0xA34D7216, 0x42B06084), U64(0x27F002D7, 0xF95D0190), /* ~= 10^203 */
-    U64(0xCC20CE9B, 0xD35C78A5), U64(0x31EC038D, 0xF7B441F4), /* ~= 10^204 */
-    U64(0xFF290242, 0xC83396CE), U64(0x7E670471, 0x75A15271), /* ~= 10^205 */
-    U64(0x9F79A169, 0xBD203E41), U64(0x0F0062C6, 0xE984D386), /* ~= 10^206 */
-    U64(0xC75809C4, 0x2C684DD1), U64(0x52C07B78, 0xA3E60868), /* ~= 10^207 */
-    U64(0xF92E0C35, 0x37826145), U64(0xA7709A56, 0xCCDF8A82), /* ~= 10^208 */
-    U64(0x9BBCC7A1, 0x42B17CCB), U64(0x88A66076, 0x400BB691), /* ~= 10^209 */
-    U64(0xC2ABF989, 0x935DDBFE), U64(0x6ACFF893, 0xD00EA435), /* ~= 10^210 */
-    U64(0xF356F7EB, 0xF83552FE), U64(0x0583F6B8, 0xC4124D43), /* ~= 10^211 */
-    U64(0x98165AF3, 0x7B2153DE), U64(0xC3727A33, 0x7A8B704A), /* ~= 10^212 */
-    U64(0xBE1BF1B0, 0x59E9A8D6), U64(0x744F18C0, 0x592E4C5C), /* ~= 10^213 */
-    U64(0xEDA2EE1C, 0x7064130C), U64(0x1162DEF0, 0x6F79DF73), /* ~= 10^214 */
-    U64(0x9485D4D1, 0xC63E8BE7), U64(0x8ADDCB56, 0x45AC2BA8), /* ~= 10^215 */
-    U64(0xB9A74A06, 0x37CE2EE1), U64(0x6D953E2B, 0xD7173692), /* ~= 10^216 */
-    U64(0xE8111C87, 0xC5C1BA99), U64(0xC8FA8DB6, 0xCCDD0437), /* ~= 10^217 */
-    U64(0x910AB1D4, 0xDB9914A0), U64(0x1D9C9892, 0x400A22A2), /* ~= 10^218 */
-    U64(0xB54D5E4A, 0x127F59C8), U64(0x2503BEB6, 0xD00CAB4B), /* ~= 10^219 */
-    U64(0xE2A0B5DC, 0x971F303A), U64(0x2E44AE64, 0x840FD61D), /* ~= 10^220 */
-    U64(0x8DA471A9, 0xDE737E24), U64(0x5CEAECFE, 0xD289E5D2), /* ~= 10^221 */
-    U64(0xB10D8E14, 0x56105DAD), U64(0x7425A83E, 0x872C5F47), /* ~= 10^222 */
-    U64(0xDD50F199, 0x6B947518), U64(0xD12F124E, 0x28F77719), /* ~= 10^223 */
-    U64(0x8A5296FF, 0xE33CC92F), U64(0x82BD6B70, 0xD99AAA6F), /* ~= 10^224 */
-    U64(0xACE73CBF, 0xDC0BFB7B), U64(0x636CC64D, 0x1001550B), /* ~= 10^225 */
-    U64(0xD8210BEF, 0xD30EFA5A), U64(0x3C47F7E0, 0x5401AA4E), /* ~= 10^226 */
-    U64(0x8714A775, 0xE3E95C78), U64(0x65ACFAEC, 0x34810A71), /* ~= 10^227 */
-    U64(0xA8D9D153, 0x5CE3B396), U64(0x7F1839A7, 0x41A14D0D), /* ~= 10^228 */
-    U64(0xD31045A8, 0x341CA07C), U64(0x1EDE4811, 0x1209A050), /* ~= 10^229 */
-    U64(0x83EA2B89, 0x2091E44D), U64(0x934AED0A, 0xAB460432), /* ~= 10^230 */
-    U64(0xA4E4B66B, 0x68B65D60), U64(0xF81DA84D, 0x5617853F), /* ~= 10^231 */
-    U64(0xCE1DE406, 0x42E3F4B9), U64(0x36251260, 0xAB9D668E), /* ~= 10^232 */
-    U64(0x80D2AE83, 0xE9CE78F3), U64(0xC1D72B7C, 0x6B426019), /* ~= 10^233 */
-    U64(0xA1075A24, 0xE4421730), U64(0xB24CF65B, 0x8612F81F), /* ~= 10^234 */
-    U64(0xC94930AE, 0x1D529CFC), U64(0xDEE033F2, 0x6797B627), /* ~= 10^235 */
-    U64(0xFB9B7CD9, 0xA4A7443C), U64(0x169840EF, 0x017DA3B1), /* ~= 10^236 */
-    U64(0x9D412E08, 0x06E88AA5), U64(0x8E1F2895, 0x60EE864E), /* ~= 10^237 */
-    U64(0xC491798A, 0x08A2AD4E), U64(0xF1A6F2BA, 0xB92A27E2), /* ~= 10^238 */
-    U64(0xF5B5D7EC, 0x8ACB58A2), U64(0xAE10AF69, 0x6774B1DB), /* ~= 10^239 */
-    U64(0x9991A6F3, 0xD6BF1765), U64(0xACCA6DA1, 0xE0A8EF29), /* ~= 10^240 */
-    U64(0xBFF610B0, 0xCC6EDD3F), U64(0x17FD090A, 0x58D32AF3), /* ~= 10^241 */
-    U64(0xEFF394DC, 0xFF8A948E), U64(0xDDFC4B4C, 0xEF07F5B0), /* ~= 10^242 */
-    U64(0x95F83D0A, 0x1FB69CD9), U64(0x4ABDAF10, 0x1564F98E), /* ~= 10^243 */
-    U64(0xBB764C4C, 0xA7A4440F), U64(0x9D6D1AD4, 0x1ABE37F1), /* ~= 10^244 */
-    U64(0xEA53DF5F, 0xD18D5513), U64(0x84C86189, 0x216DC5ED), /* ~= 10^245 */
-    U64(0x92746B9B, 0xE2F8552C), U64(0x32FD3CF5, 0xB4E49BB4), /* ~= 10^246 */
-    U64(0xB7118682, 0xDBB66A77), U64(0x3FBC8C33, 0x221DC2A1), /* ~= 10^247 */
-    U64(0xE4D5E823, 0x92A40515), U64(0x0FABAF3F, 0xEAA5334A), /* ~= 10^248 */
-    U64(0x8F05B116, 0x3BA6832D), U64(0x29CB4D87, 0xF2A7400E), /* ~= 10^249 */
-    U64(0xB2C71D5B, 0xCA9023F8), U64(0x743E20E9, 0xEF511012), /* ~= 10^250 */
-    U64(0xDF78E4B2, 0xBD342CF6), U64(0x914DA924, 0x6B255416), /* ~= 10^251 */
-    U64(0x8BAB8EEF, 0xB6409C1A), U64(0x1AD089B6, 0xC2F7548E), /* ~= 10^252 */
-    U64(0xAE9672AB, 0xA3D0C320), U64(0xA184AC24, 0x73B529B1), /* ~= 10^253 */
-    U64(0xDA3C0F56, 0x8CC4F3E8), U64(0xC9E5D72D, 0x90A2741E), /* ~= 10^254 */
-    U64(0x88658996, 0x17FB1871), U64(0x7E2FA67C, 0x7A658892), /* ~= 10^255 */
-    U64(0xAA7EEBFB, 0x9DF9DE8D), U64(0xDDBB901B, 0x98FEEAB7), /* ~= 10^256 */
-    U64(0xD51EA6FA, 0x85785631), U64(0x552A7422, 0x7F3EA565), /* ~= 10^257 */
-    U64(0x8533285C, 0x936B35DE), U64(0xD53A8895, 0x8F87275F), /* ~= 10^258 */
-    U64(0xA67FF273, 0xB8460356), U64(0x8A892ABA, 0xF368F137), /* ~= 10^259 */
-    U64(0xD01FEF10, 0xA657842C), U64(0x2D2B7569, 0xB0432D85), /* ~= 10^260 */
-    U64(0x8213F56A, 0x67F6B29B), U64(0x9C3B2962, 0x0E29FC73), /* ~= 10^261 */
-    U64(0xA298F2C5, 0x01F45F42), U64(0x8349F3BA, 0x91B47B8F), /* ~= 10^262 */
-    U64(0xCB3F2F76, 0x42717713), U64(0x241C70A9, 0x36219A73), /* ~= 10^263 */
-    U64(0xFE0EFB53, 0xD30DD4D7), U64(0xED238CD3, 0x83AA0110), /* ~= 10^264 */
-    U64(0x9EC95D14, 0x63E8A506), U64(0xF4363804, 0x324A40AA), /* ~= 10^265 */
-    U64(0xC67BB459, 0x7CE2CE48), U64(0xB143C605, 0x3EDCD0D5), /* ~= 10^266 */
-    U64(0xF81AA16F, 0xDC1B81DA), U64(0xDD94B786, 0x8E94050A), /* ~= 10^267 */
-    U64(0x9B10A4E5, 0xE9913128), U64(0xCA7CF2B4, 0x191C8326), /* ~= 10^268 */
-    U64(0xC1D4CE1F, 0x63F57D72), U64(0xFD1C2F61, 0x1F63A3F0), /* ~= 10^269 */
-    U64(0xF24A01A7, 0x3CF2DCCF), U64(0xBC633B39, 0x673C8CEC), /* ~= 10^270 */
-    U64(0x976E4108, 0x8617CA01), U64(0xD5BE0503, 0xE085D813), /* ~= 10^271 */
-    U64(0xBD49D14A, 0xA79DBC82), U64(0x4B2D8644, 0xD8A74E18), /* ~= 10^272 */
-    U64(0xEC9C459D, 0x51852BA2), U64(0xDDF8E7D6, 0x0ED1219E), /* ~= 10^273 */
-    U64(0x93E1AB82, 0x52F33B45), U64(0xCABB90E5, 0xC942B503), /* ~= 10^274 */
-    U64(0xB8DA1662, 0xE7B00A17), U64(0x3D6A751F, 0x3B936243), /* ~= 10^275 */
-    U64(0xE7109BFB, 0xA19C0C9D), U64(0x0CC51267, 0x0A783AD4), /* ~= 10^276 */
-    U64(0x906A617D, 0x450187E2), U64(0x27FB2B80, 0x668B24C5), /* ~= 10^277 */
-    U64(0xB484F9DC, 0x9641E9DA), U64(0xB1F9F660, 0x802DEDF6), /* ~= 10^278 */
-    U64(0xE1A63853, 0xBBD26451), U64(0x5E7873F8, 0xA0396973), /* ~= 10^279 */
-    U64(0x8D07E334, 0x55637EB2), U64(0xDB0B487B, 0x6423E1E8), /* ~= 10^280 */
-    U64(0xB049DC01, 0x6ABC5E5F), U64(0x91CE1A9A, 0x3D2CDA62), /* ~= 10^281 */
-    U64(0xDC5C5301, 0xC56B75F7), U64(0x7641A140, 0xCC7810FB), /* ~= 10^282 */
-    U64(0x89B9B3E1, 0x1B6329BA), U64(0xA9E904C8, 0x7FCB0A9D), /* ~= 10^283 */
-    U64(0xAC2820D9, 0x623BF429), U64(0x546345FA, 0x9FBDCD44), /* ~= 10^284 */
-    U64(0xD732290F, 0xBACAF133), U64(0xA97C1779, 0x47AD4095), /* ~= 10^285 */
-    U64(0x867F59A9, 0xD4BED6C0), U64(0x49ED8EAB, 0xCCCC485D), /* ~= 10^286 */
-    U64(0xA81F3014, 0x49EE8C70), U64(0x5C68F256, 0xBFFF5A74), /* ~= 10^287 */
-    U64(0xD226FC19, 0x5C6A2F8C), U64(0x73832EEC, 0x6FFF3111), /* ~= 10^288 */
-    U64(0x83585D8F, 0xD9C25DB7), U64(0xC831FD53, 0xC5FF7EAB), /* ~= 10^289 */
-    U64(0xA42E74F3, 0xD032F525), U64(0xBA3E7CA8, 0xB77F5E55), /* ~= 10^290 */
-    U64(0xCD3A1230, 0xC43FB26F), U64(0x28CE1BD2, 0xE55F35EB), /* ~= 10^291 */
-    U64(0x80444B5E, 0x7AA7CF85), U64(0x7980D163, 0xCF5B81B3), /* ~= 10^292 */
-    U64(0xA0555E36, 0x1951C366), U64(0xD7E105BC, 0xC332621F), /* ~= 10^293 */
-    U64(0xC86AB5C3, 0x9FA63440), U64(0x8DD9472B, 0xF3FEFAA7), /* ~= 10^294 */
-    U64(0xFA856334, 0x878FC150), U64(0xB14F98F6, 0xF0FEB951), /* ~= 10^295 */
-    U64(0x9C935E00, 0xD4B9D8D2), U64(0x6ED1BF9A, 0x569F33D3), /* ~= 10^296 */
-    U64(0xC3B83581, 0x09E84F07), U64(0x0A862F80, 0xEC4700C8), /* ~= 10^297 */
-    U64(0xF4A642E1, 0x4C6262C8), U64(0xCD27BB61, 0x2758C0FA), /* ~= 10^298 */
-    U64(0x98E7E9CC, 0xCFBD7DBD), U64(0x8038D51C, 0xB897789C), /* ~= 10^299 */
-    U64(0xBF21E440, 0x03ACDD2C), U64(0xE0470A63, 0xE6BD56C3), /* ~= 10^300 */
-    U64(0xEEEA5D50, 0x04981478), U64(0x1858CCFC, 0xE06CAC74), /* ~= 10^301 */
-    U64(0x95527A52, 0x02DF0CCB), U64(0x0F37801E, 0x0C43EBC8), /* ~= 10^302 */
-    U64(0xBAA718E6, 0x8396CFFD), U64(0xD3056025, 0x8F54E6BA), /* ~= 10^303 */
-    U64(0xE950DF20, 0x247C83FD), U64(0x47C6B82E, 0xF32A2069), /* ~= 10^304 */
-    U64(0x91D28B74, 0x16CDD27E), U64(0x4CDC331D, 0x57FA5441), /* ~= 10^305 */
-    U64(0xB6472E51, 0x1C81471D), U64(0xE0133FE4, 0xADF8E952), /* ~= 10^306 */
-    U64(0xE3D8F9E5, 0x63A198E5), U64(0x58180FDD, 0xD97723A6), /* ~= 10^307 */
-    U64(0x8E679C2F, 0x5E44FF8F), U64(0x570F09EA, 0xA7EA7648), /* ~= 10^308 */
-    U64(0xB201833B, 0x35D63F73), U64(0x2CD2CC65, 0x51E513DA), /* ~= 10^309 */
-    U64(0xDE81E40A, 0x034BCF4F), U64(0xF8077F7E, 0xA65E58D1), /* ~= 10^310 */
-    U64(0x8B112E86, 0x420F6191), U64(0xFB04AFAF, 0x27FAF782), /* ~= 10^311 */
-    U64(0xADD57A27, 0xD29339F6), U64(0x79C5DB9A, 0xF1F9B563), /* ~= 10^312 */
-    U64(0xD94AD8B1, 0xC7380874), U64(0x18375281, 0xAE7822BC), /* ~= 10^313 */
-    U64(0x87CEC76F, 0x1C830548), U64(0x8F229391, 0x0D0B15B5), /* ~= 10^314 */
-    U64(0xA9C2794A, 0xE3A3C69A), U64(0xB2EB3875, 0x504DDB22), /* ~= 10^315 */
-    U64(0xD433179D, 0x9C8CB841), U64(0x5FA60692, 0xA46151EB), /* ~= 10^316 */
-    U64(0x849FEEC2, 0x81D7F328), U64(0xDBC7C41B, 0xA6BCD333), /* ~= 10^317 */
-    U64(0xA5C7EA73, 0x224DEFF3), U64(0x12B9B522, 0x906C0800), /* ~= 10^318 */
-    U64(0xCF39E50F, 0xEAE16BEF), U64(0xD768226B, 0x34870A00), /* ~= 10^319 */
-    U64(0x81842F29, 0xF2CCE375), U64(0xE6A11583, 0x00D46640), /* ~= 10^320 */
-    U64(0xA1E53AF4, 0x6F801C53), U64(0x60495AE3, 0xC1097FD0), /* ~= 10^321 */
-    U64(0xCA5E89B1, 0x8B602368), U64(0x385BB19C, 0xB14BDFC4), /* ~= 10^322 */
-    U64(0xFCF62C1D, 0xEE382C42), U64(0x46729E03, 0xDD9ED7B5), /* ~= 10^323 */
-    U64(0x9E19DB92, 0xB4E31BA9), U64(0x6C07A2C2, 0x6A8346D1)  /* ~= 10^324 */
-};
-
-/**
- Get the cached pow10 value from pow10_sig_table.
- @param exp10 The exponent of pow(10, e). This value must in range
-              POW10_SIG_TABLE_MIN_EXP to POW10_SIG_TABLE_MAX_EXP.
- @param hi    The highest 64 bits of pow(10, e).
- @param lo    The lower 64 bits after `hi`.
- */
-static_inline void pow10_table_get_sig(i32 exp10, u64 *hi, u64 *lo) {
-    i32 idx = exp10 - (POW10_SIG_TABLE_MIN_EXP);
-    *hi = pow10_sig_table[idx * 2];
-    *lo = pow10_sig_table[idx * 2 + 1];
-}
-
-/**
- Get the exponent (base 2) for highest 64 bits significand in pow10_sig_table.
- */
-static_inline void pow10_table_get_exp(i32 exp10, i32 *exp2) {
-    /* e2 = floor(log2(pow(10, e))) - 64 + 1 */
-    /*    = floor(e * log2(10) - 63)         */
-    *exp2 = (exp10 * 217706 - 4128768) >> 16;
-}
-
-#endif
-
-
-
-/*==============================================================================
- * JSON Character Matcher
- *============================================================================*/
-
-/** Character type */
-typedef u8 char_type;
-
-/** Whitespace character: ' ', '\\t', '\\n', '\\r'. */
-static const char_type CHAR_TYPE_SPACE      = 1 << 0;
-
-/** Number character: '-', [0-9]. */
-static const char_type CHAR_TYPE_NUMBER     = 1 << 1;
-
-/** JSON Escaped character: '"', '\', [0x00-0x1F]. */
-static const char_type CHAR_TYPE_ESC_ASCII  = 1 << 2;
-
-/** Non-ASCII character: [0x80-0xFF]. */
-static const char_type CHAR_TYPE_NON_ASCII  = 1 << 3;
-
-/** JSON container character: '{', '['. */
-static const char_type CHAR_TYPE_CONTAINER  = 1 << 4;
-
-/** Comment character: '/'. */
-static const char_type CHAR_TYPE_COMMENT    = 1 << 5;
-
-/** Line end character: '\\n', '\\r', '\0'. */
-static const char_type CHAR_TYPE_LINE_END   = 1 << 6;
-
-/** Hexadecimal numeric character: [0-9a-fA-F]. */
-static const char_type CHAR_TYPE_HEX        = 1 << 7;
-
-/** Character type table (generate with misc/make_tables.c) */
-static const char_type char_table[256] = {
-    0x44, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-    0x04, 0x05, 0x45, 0x04, 0x04, 0x45, 0x04, 0x04,
-    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-    0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x20,
-    0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
-    0x82, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x00,
-    0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
-};
-
-/** Match a character with specified type. */
-static_inline bool char_is_type(u8 c, char_type type) {
-    return (char_table[c] & type) != 0;
-}
-
-/** Match a whitespace: ' ', '\\t', '\\n', '\\r'. */
-static_inline bool char_is_space(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_SPACE);
-}
-
-/** Match a whitespace or comment: ' ', '\\t', '\\n', '\\r', '/'. */
-static_inline bool char_is_space_or_comment(u8 c) {
-    return char_is_type(c, (char_type)(CHAR_TYPE_SPACE | CHAR_TYPE_COMMENT));
-}
-
-/** Match a JSON number: '-', [0-9]. */
-static_inline bool char_is_number(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_NUMBER);
-}
-
-/** Match a JSON container: '{', '['. */
-static_inline bool char_is_container(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_CONTAINER);
-}
-
-/** Match a stop character in ASCII string: '"', '\', [0x00-0x1F,0x80-0xFF]. */
-static_inline bool char_is_ascii_stop(u8 c) {
-    return char_is_type(c, (char_type)(CHAR_TYPE_ESC_ASCII |
-                                       CHAR_TYPE_NON_ASCII));
-}
-
-/** Match a line end character: '\\n', '\\r', '\0'. */
-static_inline bool char_is_line_end(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_LINE_END);
-}
-
-/** Match a hexadecimal numeric character: [0-9a-fA-F]. */
-static_inline bool char_is_hex(u8 c) {
-    return char_is_type(c, (char_type)CHAR_TYPE_HEX);
-}
-
-
-
-/*==============================================================================
- * Digit Character Matcher
- *============================================================================*/
-
-/** Digit type */
-typedef u8 digi_type;
-
-/** Digit: '0'. */
-static const digi_type DIGI_TYPE_ZERO       = 1 << 0;
-
-/** Digit: [1-9]. */
-static const digi_type DIGI_TYPE_NONZERO    = 1 << 1;
-
-/** Plus sign (positive): '+'. */
-static const digi_type DIGI_TYPE_POS        = 1 << 2;
-
-/** Minus sign (negative): '-'. */
-static const digi_type DIGI_TYPE_NEG        = 1 << 3;
-
-/** Decimal point: '.' */
-static const digi_type DIGI_TYPE_DOT        = 1 << 4;
-
-/** Exponent sign: 'e, 'E'. */
-static const digi_type DIGI_TYPE_EXP        = 1 << 5;
-
-/** Digit type table (generate with misc/make_tables.c) */
-static const digi_type digi_table[256] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x10, 0x00,
-    0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-    0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-/** Match a character with specified type. */
-static_inline bool digi_is_type(u8 d, digi_type type) {
-    return (digi_table[d] & type) != 0;
-}
-
-/** Match a sign: '+', '-' */
-static_inline bool digi_is_sign(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_POS | DIGI_TYPE_NEG));
-}
-
-/** Match a none zero digit: [1-9] */
-static_inline bool digi_is_nonzero(u8 d) {
-    return digi_is_type(d, (digi_type)DIGI_TYPE_NONZERO);
-}
-
-/** Match a digit: [0-9] */
-static_inline bool digi_is_digit(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO));
-}
-
-/** Match an exponent sign: 'e', 'E'. */
-static_inline bool digi_is_exp(u8 d) {
-    return digi_is_type(d, (digi_type)DIGI_TYPE_EXP);
-}
-
-/** Match a floating point indicator: '.', 'e', 'E'. */
-static_inline bool digi_is_fp(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_DOT | DIGI_TYPE_EXP));
-}
-
-/** Match a digit or floating point indicator: [0-9], '.', 'e', 'E'. */
-static_inline bool digi_is_digit_or_fp(u8 d) {
-    return digi_is_type(d, (digi_type)(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO |
-                                       DIGI_TYPE_DOT | DIGI_TYPE_EXP));
-}
-
-
-
-#if !YYJSON_DISABLE_READER
-
-/*==============================================================================
- * Hex Character Reader
- * This function is used by JSON reader to read escaped characters.
- *============================================================================*/
-
-/**
- This table is used to convert 4 hex character sequence to a number.
- A valid hex character [0-9A-Fa-f] will mapped to it's raw number [0x00, 0x0F],
- an invalid hex character will mapped to [0xF0].
- (generate with misc/make_tables.c)
- */
-static const u8 hex_conv_table[256] = {
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-    0x08, 0x09, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0
-};
-
-/**
- Scans an escaped character sequence as a UTF-16 code unit (branchless).
- e.g. "\\u005C" should pass "005C" as `cur`.
-
- This requires the string has 4-byte zero padding.
- */
-static_inline bool read_hex_u16(const u8 *cur, u16 *val) {
-    u16 c0, c1, c2, c3, t0, t1;
-    c0 = hex_conv_table[cur[0]];
-    c1 = hex_conv_table[cur[1]];
-    c2 = hex_conv_table[cur[2]];
-    c3 = hex_conv_table[cur[3]];
-    t0 = (u16)((c0 << 8) | c2);
-    t1 = (u16)((c1 << 8) | c3);
-    *val = (u16)((t0 << 4) | t1);
-    return ((t0 | t1) & (u16)0xF0F0) == 0;
-}
-
-
-
-/*==============================================================================
- * JSON Reader Utils
- * These functions are used by JSON reader to read literals and comments.
- *============================================================================*/
-
-/** Read 'true' literal, '*cur' should be 't'. */
-static_inline bool read_true(u8 **ptr, yyjson_val *val) {
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if (likely(byte_match_4(cur, "true"))) {
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-        *end = cur + 4;
-        return true;
-    }
-    return false;
-}
-
-/** Read 'false' literal, '*cur' should be 'f'. */
-static_inline bool read_false(u8 **ptr, yyjson_val *val) {
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if (likely(byte_match_4(cur + 1, "alse"))) {
-        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-        *end = cur + 5;
-        return true;
-    }
-    return false;
-}
-
-/** Read 'null' literal, '*cur' should be 'n'. */
-static_inline bool read_null(u8 **ptr, yyjson_val *val) {
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if (likely(byte_match_4(cur, "null"))) {
-        val->tag = YYJSON_TYPE_NULL;
-        *end = cur + 4;
-        return true;
-    }
-    return false;
-}
-
-/** Read 'Inf' or 'Infinity' literal (ignoring case). */
-static_inline bool read_inf(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) {
-    u8 *hdr = *ptr - sign;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if ((cur[0] == 'I' || cur[0] == 'i') &&
-        (cur[1] == 'N' || cur[1] == 'n') &&
-        (cur[2] == 'F' || cur[2] == 'f')) {
-        if ((cur[3] == 'I' || cur[3] == 'i') &&
-            (cur[4] == 'N' || cur[4] == 'n') &&
-            (cur[5] == 'I' || cur[5] == 'i') &&
-            (cur[6] == 'T' || cur[6] == 't') &&
-            (cur[7] == 'Y' || cur[7] == 'y')) {
-            cur += 8;
-        } else {
-            cur += 3;
-        }
-        *end = cur;
-        if (pre) {
-            /* add null-terminator for previous raw string */
-            if (*pre) **pre = '\0';
-            *pre = cur;
-            val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = (const char *)hdr;
-        } else {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-            val->uni.u64 = f64_raw_get_inf(sign);
-        }
-        return true;
-    }
-    return false;
-}
-
-/** Read 'NaN' literal (ignoring case). */
-static_inline bool read_nan(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) {
-    u8 *hdr = *ptr - sign;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    if ((cur[0] == 'N' || cur[0] == 'n') &&
-        (cur[1] == 'A' || cur[1] == 'a') &&
-        (cur[2] == 'N' || cur[2] == 'n')) {
-        cur += 3;
-        *end = cur;
-        if (pre) {
-            /* add null-terminator for previous raw string */
-            if (*pre) **pre = '\0';
-            *pre = cur;
-            val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
-            val->uni.str = (const char *)hdr;
-        } else {
-            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-            val->uni.u64 = f64_raw_get_nan(sign);
-        }
-        return true;
-    }
-    return false;
-}
-
-/** Read 'Inf', 'Infinity' or 'NaN' literal (ignoring case). */
-static_inline bool read_inf_or_nan(bool sign, u8 **ptr, u8 **pre,
-                                   yyjson_val *val) {
-    if (read_inf(sign, ptr, pre, val)) return true;
-    if (read_nan(sign, ptr, pre, val)) return true;
-    return false;
-}
-
-/** Read a JSON number as raw string. */
-static_noinline bool read_number_raw(u8 **ptr,
-                                     u8 **pre,
-                                     yyjson_read_flag flg,
-                                     yyjson_val *val,
-                                     const char **msg) {
-
-#define return_err(_pos, _msg) do { \
-    *msg = _msg; \
-    *end = _pos; \
-    return false; \
-} while (false)
-
-#define return_raw() do { \
-    val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \
-    val->uni.str = (const char *)hdr; \
-    *pre = cur; *end = cur; return true; \
-} while (false)
-
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-
-    /* add null-terminator for previous raw string */
-    if (*pre) **pre = '\0';
-
-    /* skip sign */
-    cur += (*cur == '-');
-
-    /* read first digit, check leading zero */
-    if (unlikely(!digi_is_digit(*cur))) {
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_inf_or_nan(*hdr == '-', &cur, pre, val)) return_raw();
-        }
-        return_err(cur, "no digit after minus sign");
-    }
-
-    /* read integral part */
-    if (*cur == '0') {
-        cur++;
-        if (unlikely(digi_is_digit(*cur))) {
-            return_err(cur - 1, "number with leading zero is not allowed");
-        }
-        if (!digi_is_fp(*cur)) return_raw();
-    } else {
-        while (digi_is_digit(*cur)) cur++;
-        if (!digi_is_fp(*cur)) return_raw();
-    }
-
-    /* read fraction part */
-    if (*cur == '.') {
-        cur++;
-        if (!digi_is_digit(*cur++)) {
-            return_err(cur, "no digit after decimal point");
-        }
-        while (digi_is_digit(*cur)) cur++;
-    }
-
-    /* read exponent part */
-    if (digi_is_exp(*cur)) {
-        cur += 1 + digi_is_sign(cur[1]);
-        if (!digi_is_digit(*cur++)) {
-            return_err(cur, "no digit after exponent sign");
-        }
-        while (digi_is_digit(*cur)) cur++;
-    }
-
-    return_raw();
-
-#undef return_err
-#undef return_raw
-}
-
-/**
- Skips spaces and comments as many as possible.
-
- It will return false in these cases:
-    1. No character is skipped. The 'end' pointer is set as input cursor.
-    2. A multiline comment is not closed. The 'end' pointer is set as the head
-       of this comment block.
- */
-static_noinline bool skip_spaces_and_comments(u8 **ptr) {
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    while (true) {
-        if (byte_match_2(cur, "/*")) {
-            hdr = cur;
-            cur += 2;
-            while (true) {
-                if (byte_match_2(cur, "*/")) {
-                    cur += 2;
-                    break;
-                }
-                if (*cur == 0) {
-                    *end = hdr;
-                    return false;
-                }
-                cur++;
-            }
-            continue;
-        }
-        if (byte_match_2(cur, "//")) {
-            cur += 2;
-            while (!char_is_line_end(*cur)) cur++;
-            continue;
-        }
-        if (char_is_space(*cur)) {
-            cur += 1;
-            while (char_is_space(*cur)) cur++;
-            continue;
-        }
-        break;
-    }
-    *end = cur;
-    return hdr != cur;
-}
-
-/**
- Check truncated string.
- Returns true if `cur` match `str` but is truncated.
- */
-static_inline bool is_truncated_str(u8 *cur, u8 *end,
-                                    const char *str,
-                                    bool case_sensitive) {
-    usize len = strlen(str);
-    if (cur + len <= end || end <= cur) return false;
-    if (case_sensitive) {
-        return memcmp(cur, str, (usize)(end - cur)) == 0;
-    }
-    for (; cur < end; cur++, str++) {
-        if ((*cur != (u8)*str) && (*cur != (u8)*str - 'a' + 'A')) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/**
- Check truncated JSON on parsing errors.
- Returns true if the input is valid but truncated.
- */
-static_noinline bool is_truncated_end(u8 *hdr, u8 *cur, u8 *end,
-                                      yyjson_read_code code,
-                                      yyjson_read_flag flg) {
-    if (cur >= end) return true;
-    if (code == YYJSON_READ_ERROR_LITERAL) {
-        if (is_truncated_str(cur, end, "true", true) ||
-            is_truncated_str(cur, end, "false", true) ||
-            is_truncated_str(cur, end, "null", true)) {
-            return true;
-        }
-    }
-    if (code == YYJSON_READ_ERROR_UNEXPECTED_CHARACTER ||
-        code == YYJSON_READ_ERROR_INVALID_NUMBER ||
-        code == YYJSON_READ_ERROR_LITERAL) {
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (*cur == '-') cur++;
-            if (is_truncated_str(cur, end, "infinity", false) ||
-                is_truncated_str(cur, end, "nan", false)) {
-                return true;
-            }
-        }
-    }
-    if (code == YYJSON_READ_ERROR_UNEXPECTED_CONTENT) {
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (hdr + 3 <= cur &&
-                is_truncated_str(cur - 3, end, "infinity", false)) {
-                return true; /* e.g. infin would be read as inf + in */
-            }
-        }
-    }
-    if (code == YYJSON_READ_ERROR_INVALID_STRING) {
-        usize len = (usize)(end - cur);
-
-        /* unicode escape sequence */
-        if (*cur == '\\') {
-            if (len == 1) return true;
-            if (len <= 5) {
-                if (*++cur != 'u') return false;
-                for (++cur; cur < end; cur++) {
-                    if (!char_is_hex(*cur)) return false;
-                }
-                return true;
-            }
-            return false;
-        }
-
-        /* 2 to 4 bytes UTF-8, see `read_string()` for details. */
-        if (*cur & 0x80) {
-            u8 c0 = cur[0], c1 = cur[1], c2 = cur[2];
-            if (len == 1) {
-                /* 2 bytes UTF-8, truncated */
-                if ((c0 & 0xE0) == 0xC0 && (c0 & 0x1E) != 0x00) return true;
-                /* 3 bytes UTF-8, truncated */
-                if ((c0 & 0xF0) == 0xE0) return true;
-                /* 4 bytes UTF-8, truncated */
-                if ((c0 & 0xF8) == 0xF0 && (c0 & 0x07) <= 0x04) return true;
-            }
-            if (len == 2) {
-                /* 3 bytes UTF-8, truncated */
-                if ((c0 & 0xF0) == 0xE0 &&
-                    (c1 & 0xC0) == 0x80) {
-                    u8 pat = (u8)(((c0 & 0x0F) << 1) | ((c1 & 0x20) >> 5));
-                    return 0x01 <= pat && pat != 0x1B;
-                }
-                /* 4 bytes UTF-8, truncated */
-                if ((c0 & 0xF8) == 0xF0 &&
-                    (c1 & 0xC0) == 0x80) {
-                    u8 pat = (u8)(((c0 & 0x07) << 2) | ((c1 & 0x30) >> 4));
-                    return 0x01 <= pat && pat <= 0x10;
-                }
-            }
-            if (len == 3) {
-                /* 4 bytes UTF-8, truncated */
-                if ((c0 & 0xF8) == 0xF0 &&
-                    (c1 & 0xC0) == 0x80 &&
-                    (c2 & 0xC0) == 0x80) {
-                    u8 pat = (u8)(((c0 & 0x07) << 2) | ((c1 & 0x30) >> 4));
-                    return 0x01 <= pat && pat <= 0x10;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-
-
-#if YYJSON_HAS_IEEE_754 && !YYJSON_DISABLE_FAST_FP_CONV /* FP_READER */
-
-/*==============================================================================
- * BigInt For Floating Point Number Reader
- *
- * The bigint algorithm is used by floating-point number reader to get correctly
- * rounded result for numbers with lots of digits. This part of code is rarely
- * used for common numbers.
- *============================================================================*/
-
-/** Maximum exponent of exact pow10 */
-#define U64_POW10_MAX_EXP 19
-
-/** Table: [ 10^0, ..., 10^19 ] (generate with misc/make_tables.c) */
-static const u64 u64_pow10_table[U64_POW10_MAX_EXP + 1] = {
-    U64(0x00000000, 0x00000001), U64(0x00000000, 0x0000000A),
-    U64(0x00000000, 0x00000064), U64(0x00000000, 0x000003E8),
-    U64(0x00000000, 0x00002710), U64(0x00000000, 0x000186A0),
-    U64(0x00000000, 0x000F4240), U64(0x00000000, 0x00989680),
-    U64(0x00000000, 0x05F5E100), U64(0x00000000, 0x3B9ACA00),
-    U64(0x00000002, 0x540BE400), U64(0x00000017, 0x4876E800),
-    U64(0x000000E8, 0xD4A51000), U64(0x00000918, 0x4E72A000),
-    U64(0x00005AF3, 0x107A4000), U64(0x00038D7E, 0xA4C68000),
-    U64(0x002386F2, 0x6FC10000), U64(0x01634578, 0x5D8A0000),
-    U64(0x0DE0B6B3, 0xA7640000), U64(0x8AC72304, 0x89E80000)
-};
-
-/** Maximum numbers of chunks used by a bigint (58 is enough here). */
-#define BIGINT_MAX_CHUNKS 64
-
-/** Unsigned arbitrarily large integer */
-typedef struct bigint {
-    u32 used; /* used chunks count, should not be 0 */
-    u64 bits[BIGINT_MAX_CHUNKS]; /* chunks */
-} bigint;
-
-/**
- Evaluate 'big += val'.
- @param big A big number (can be 0).
- @param val An unsigned integer (can be 0).
- */
-static_inline void bigint_add_u64(bigint *big, u64 val) {
-    u32 idx, max;
-    u64 num = big->bits[0];
-    u64 add = num + val;
-    big->bits[0] = add;
-    if (likely((add >= num) || (add >= val))) return;
-    for ((void)(idx = 1), max = big->used; idx < max; idx++) {
-        if (likely(big->bits[idx] != U64_MAX)) {
-            big->bits[idx] += 1;
-            return;
-        }
-        big->bits[idx] = 0;
-    }
-    big->bits[big->used++] = 1;
-}
-
-/**
- Evaluate 'big *= val'.
- @param big A big number (can be 0).
- @param val An unsigned integer (cannot be 0).
- */
-static_inline void bigint_mul_u64(bigint *big, u64 val) {
-    u32 idx = 0, max = big->used;
-    u64 hi, lo, carry = 0;
-    for (; idx < max; idx++) {
-        if (big->bits[idx]) break;
-    }
-    for (; idx < max; idx++) {
-        u128_mul_add(big->bits[idx], val, carry, &hi, &lo);
-        big->bits[idx] = lo;
-        carry = hi;
-    }
-    if (carry) big->bits[big->used++] = carry;
-}
-
-/**
- Evaluate 'big *= 2^exp'.
- @param big A big number (can be 0).
- @param exp An exponent integer (can be 0).
- */
-static_inline void bigint_mul_pow2(bigint *big, u32 exp) {
-    u32 shft = exp % 64;
-    u32 move = exp / 64;
-    u32 idx = big->used;
-    if (unlikely(shft == 0)) {
-        for (; idx > 0; idx--) {
-            big->bits[idx + move - 1] = big->bits[idx - 1];
-        }
-        big->used += move;
-        while (move) big->bits[--move] = 0;
-    } else {
-        big->bits[idx] = 0;
-        for (; idx > 0; idx--) {
-            u64 num = big->bits[idx] << shft;
-            num |= big->bits[idx - 1] >> (64 - shft);
-            big->bits[idx + move] = num;
-        }
-        big->bits[move] = big->bits[0] << shft;
-        big->used += move + (big->bits[big->used + move] > 0);
-        while (move) big->bits[--move] = 0;
-    }
-}
-
-/**
- Evaluate 'big *= 10^exp'.
- @param big A big number (can be 0).
- @param exp An exponent integer (cannot be 0).
- */
-static_inline void bigint_mul_pow10(bigint *big, i32 exp) {
-    for (; exp >= U64_POW10_MAX_EXP; exp -= U64_POW10_MAX_EXP) {
-        bigint_mul_u64(big, u64_pow10_table[U64_POW10_MAX_EXP]);
-    }
-    if (exp) {
-        bigint_mul_u64(big, u64_pow10_table[exp]);
-    }
-}
-
-/**
- Compare two bigint.
- @return -1 if 'a < b', +1 if 'a > b', 0 if 'a == b'.
- */
-static_inline i32 bigint_cmp(bigint *a, bigint *b) {
-    u32 idx = a->used;
-    if (a->used < b->used) return -1;
-    if (a->used > b->used) return +1;
-    while (idx-- > 0) {
-        u64 av = a->bits[idx];
-        u64 bv = b->bits[idx];
-        if (av < bv) return -1;
-        if (av > bv) return +1;
-    }
-    return 0;
-}
-
-/**
- Evaluate 'big = val'.
- @param big A big number (can be 0).
- @param val An unsigned integer (can be 0).
- */
-static_inline void bigint_set_u64(bigint *big, u64 val) {
-    big->used = 1;
-    big->bits[0] = val;
-}
-
-/** Set a bigint with floating point number string. */
-static_noinline void bigint_set_buf(bigint *big, u64 sig, i32 *exp,
-                                    u8 *sig_cut, u8 *sig_end, u8 *dot_pos) {
-
-    if (unlikely(!sig_cut)) {
-        /* no digit cut, set significant part only */
-        bigint_set_u64(big, sig);
-        return;
-
-    } else {
-        /* some digits were cut, read them from 'sig_cut' to 'sig_end' */
-        u8 *hdr = sig_cut;
-        u8 *cur = hdr;
-        u32 len = 0;
-        u64 val = 0;
-        bool dig_big_cut = false;
-        bool has_dot = (hdr < dot_pos) & (dot_pos < sig_end);
-        u32 dig_len_total = U64_SAFE_DIG + (u32)(sig_end - hdr) - has_dot;
-
-        sig -= (*sig_cut >= '5'); /* sig was rounded before */
-        if (dig_len_total > F64_MAX_DEC_DIG) {
-            dig_big_cut = true;
-            sig_end -= dig_len_total - (F64_MAX_DEC_DIG + 1);
-            sig_end -= (dot_pos + 1 == sig_end);
-            dig_len_total = (F64_MAX_DEC_DIG + 1);
-        }
-        *exp -= (i32)dig_len_total - U64_SAFE_DIG;
-
-        big->used = 1;
-        big->bits[0] = sig;
-        while (cur < sig_end) {
-            if (likely(cur != dot_pos)) {
-                val = val * 10 + (u8)(*cur++ - '0');
-                len++;
-                if (unlikely(cur == sig_end && dig_big_cut)) {
-                    /* The last digit must be non-zero,    */
-                    /* set it to '1' for correct rounding. */
-                    val = val - (val % 10) + 1;
-                }
-                if (len == U64_SAFE_DIG || cur == sig_end) {
-                    bigint_mul_pow10(big, (i32)len);
-                    bigint_add_u64(big, val);
-                    val = 0;
-                    len = 0;
-                }
-            } else {
-                cur++;
-            }
-        }
-    }
-}
-
-
-
-/*==============================================================================
- * Diy Floating Point
- *============================================================================*/
-
-/** "Do It Yourself Floating Point" struct. */
-typedef struct diy_fp {
-    u64 sig; /* significand */
-    i32 exp; /* exponent, base 2 */
-    i32 pad; /* padding, useless */
-} diy_fp;
-
-/** Get cached rounded diy_fp with pow(10, e) The input value must in range
-    [POW10_SIG_TABLE_MIN_EXP, POW10_SIG_TABLE_MAX_EXP]. */
-static_inline diy_fp diy_fp_get_cached_pow10(i32 exp10) {
-    diy_fp fp;
-    u64 sig_ext;
-    pow10_table_get_sig(exp10, &fp.sig, &sig_ext);
-    pow10_table_get_exp(exp10, &fp.exp);
-    fp.sig += (sig_ext >> 63);
-    return fp;
-}
-
-/** Returns fp * fp2. */
-static_inline diy_fp diy_fp_mul(diy_fp fp, diy_fp fp2) {
-    u64 hi, lo;
-    u128_mul(fp.sig, fp2.sig, &hi, &lo);
-    fp.sig = hi + (lo >> 63);
-    fp.exp += fp2.exp + 64;
-    return fp;
-}
-
-/** Convert diy_fp to IEEE-754 raw value. */
-static_inline u64 diy_fp_to_ieee_raw(diy_fp fp) {
-    u64 sig = fp.sig;
-    i32 exp = fp.exp;
-    u32 lz_bits;
-    if (unlikely(fp.sig == 0)) return 0;
-
-    lz_bits = u64_lz_bits(sig);
-    sig <<= lz_bits;
-    sig >>= F64_BITS - F64_SIG_FULL_BITS;
-    exp -= (i32)lz_bits;
-    exp += F64_BITS - F64_SIG_FULL_BITS;
-    exp += F64_SIG_BITS;
-
-    if (unlikely(exp >= F64_MAX_BIN_EXP)) {
-        /* overflow */
-        return F64_RAW_INF;
-    } else if (likely(exp >= F64_MIN_BIN_EXP - 1)) {
-        /* normal */
-        exp += F64_EXP_BIAS;
-        return ((u64)exp << F64_SIG_BITS) | (sig & F64_SIG_MASK);
-    } else if (likely(exp >= F64_MIN_BIN_EXP - F64_SIG_FULL_BITS)) {
-        /* subnormal */
-        return sig >> (F64_MIN_BIN_EXP - exp - 1);
-    } else {
-        /* underflow */
-        return 0;
-    }
-}
-
-
-
-/*==============================================================================
- * JSON Number Reader (IEEE-754)
- *============================================================================*/
-
-/** Maximum exact pow10 exponent for double value. */
-#define F64_POW10_EXP_MAX_EXACT 22
-
-/** Cached pow10 table. */
-static const f64 f64_pow10_table[] = {
-    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12,
-    1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
-};
-
-/**
- Read a JSON number.
-
- 1. This function assume that the floating-point number is in IEEE-754 format.
- 2. This function support uint64/int64/double number. If an integer number
-    cannot fit in uint64/int64, it will returns as a double number. If a double
-    number is infinite, the return value is based on flag.
- 3. This function (with inline attribute) may generate a lot of instructions.
- */
-static_inline bool read_number(u8 **ptr,
-                               u8 **pre,
-                               yyjson_read_flag flg,
-                               yyjson_val *val,
-                               const char **msg) {
-
-#define return_err(_pos, _msg) do { \
-    *msg = _msg; \
-    *end = _pos; \
-    return false; \
-} while (false)
-
-#define return_0() do { \
-    val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); \
-    val->uni.u64 = 0; \
-    *end = cur; return true; \
-} while (false)
-
-#define return_i64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); \
-    val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); \
-    *end = cur; return true; \
-} while (false)
-
-#define return_f64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); \
-    *end = cur; return true; \
-} while (false)
-
-#define return_f64_bin(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.u64 = ((u64)sign << 63) | (u64)(_v); \
-    *end = cur; return true; \
-} while (false)
-
-#define return_inf() do { \
-    if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); \
-    if (has_read_flag(ALLOW_INF_AND_NAN)) return_f64_bin(F64_RAW_INF); \
-    else return_err(hdr, "number is infinity when parsed as double"); \
-} while (false)
-
-#define return_raw() do { \
-    if (*pre) **pre = '\0'; /* add null-terminator for previous raw string */ \
-    val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \
-    val->uni.str = (const char *)hdr; \
-    *pre = cur; *end = cur; return true; \
-} while (false)
-
-    u8 *sig_cut = NULL; /* significant part cutting position for long number */
-    u8 *sig_end = NULL; /* significant part ending position */
-    u8 *dot_pos = NULL; /* decimal point position */
-
-    u64 sig = 0; /* significant part of the number */
-    i32 exp = 0; /* exponent part of the number */
-
-    bool exp_sign; /* temporary exponent sign from literal part */
-    i64 exp_sig = 0; /* temporary exponent number from significant part */
-    i64 exp_lit = 0; /* temporary exponent number from exponent literal part */
-    u64 num; /* temporary number for reading */
-    u8 *tmp; /* temporary cursor for reading */
-
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    bool sign;
-
-    /* read number as raw string if has `YYJSON_READ_NUMBER_AS_RAW` flag */
-    if (unlikely(pre && !has_read_flag(BIGNUM_AS_RAW))) {
-        return read_number_raw(ptr, pre, flg, val, msg);
-    }
-
-    sign = (*hdr == '-');
-    cur += sign;
-
-    /* begin with a leading zero or non-digit */
-    if (unlikely(!digi_is_nonzero(*cur))) { /* 0 or non-digit char */
-        if (unlikely(*cur != '0')) { /* non-digit char */
-            if (has_read_flag(ALLOW_INF_AND_NAN)) {
-                if (read_inf_or_nan(sign, &cur, pre, val)) {
-                    *end = cur;
-                    return true;
-                }
-            }
-            return_err(cur, "no digit after minus sign");
-        }
-        /* begin with 0 */
-        if (likely(!digi_is_digit_or_fp(*++cur))) return_0();
-        if (likely(*cur == '.')) {
-            dot_pos = cur++;
-            if (unlikely(!digi_is_digit(*cur))) {
-                return_err(cur, "no digit after decimal point");
-            }
-            while (unlikely(*cur == '0')) cur++;
-            if (likely(digi_is_digit(*cur))) {
-                /* first non-zero digit after decimal point */
-                sig = (u64)(*cur - '0'); /* read first digit */
-                cur--;
-                goto digi_frac_1; /* continue read fraction part */
-            }
-        }
-        if (unlikely(digi_is_digit(*cur))) {
-            return_err(cur - 1, "number with leading zero is not allowed");
-        }
-        if (unlikely(digi_is_exp(*cur))) { /* 0 with any exponent is still 0 */
-            cur += (usize)1 + digi_is_sign(cur[1]);
-            if (unlikely(!digi_is_digit(*cur))) {
-                return_err(cur, "no digit after exponent sign");
-            }
-            while (digi_is_digit(*++cur));
-        }
-        return_f64_bin(0);
-    }
-
-    /* begin with non-zero digit */
-    sig = (u64)(*cur - '0');
-
-    /*
-     Read integral part, same as the following code.
-
-         for (int i = 1; i <= 18; i++) {
-            num = cur[i] - '0';
-            if (num <= 9) sig = num + sig * 10;
-            else goto digi_sepr_i;
-         }
-     */
-#define expr_intg(i) \
-    if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; \
-    else { goto digi_sepr_##i; }
-    repeat_in_1_18(expr_intg)
-#undef expr_intg
-
-
-    cur += 19; /* skip continuous 19 digits */
-    if (!digi_is_digit_or_fp(*cur)) {
-        /* this number is an integer consisting of 19 digits */
-        if (sign && (sig > ((u64)1 << 63))) { /* overflow */
-            if (has_read_flag(BIGNUM_AS_RAW)) return_raw();
-            return_f64(normalized_u64_to_f64(sig));
-        }
-        return_i64(sig);
-    }
-    goto digi_intg_more; /* read more digits in integral part */
-
-
-    /* process first non-digit character */
-#define expr_sepr(i) \
-    digi_sepr_##i: \
-    if (likely(!digi_is_fp(cur[i]))) { cur += i; return_i64(sig); } \
-    dot_pos = cur + i; \
-    if (likely(cur[i] == '.')) goto digi_frac_##i; \
-    cur += i; sig_end = cur; goto digi_exp_more;
-    repeat_in_1_18(expr_sepr)
-#undef expr_sepr
-
-
-    /* read fraction part */
-#define expr_frac(i) \
-    digi_frac_##i: \
-    if (likely((num = (u64)(cur[i + 1] - (u8)'0')) <= 9)) \
-        sig = num + sig * 10; \
-    else { goto digi_stop_##i; }
-    repeat_in_1_18(expr_frac)
-#undef expr_frac
-
-    cur += 20; /* skip 19 digits and 1 decimal point */
-    if (!digi_is_digit(*cur)) goto digi_frac_end; /* fraction part end */
-    goto digi_frac_more; /* read more digits in fraction part */
-
-
-    /* significant part end */
-#define expr_stop(i) \
-    digi_stop_##i: \
-    cur += i + 1; \
-    goto digi_frac_end;
-    repeat_in_1_18(expr_stop)
-#undef expr_stop
-
-
-    /* read more digits in integral part */
-digi_intg_more:
-    if (digi_is_digit(*cur)) {
-        if (!digi_is_digit_or_fp(cur[1])) {
-            /* this number is an integer consisting of 20 digits */
-            num = (u64)(*cur - '0');
-            if ((sig < (U64_MAX / 10)) ||
-                (sig == (U64_MAX / 10) && num <= (U64_MAX % 10))) {
-                sig = num + sig * 10;
-                cur++;
-                /* convert to double if overflow */
-                if (sign) {
-                    if (has_read_flag(BIGNUM_AS_RAW)) return_raw();
-                    return_f64(normalized_u64_to_f64(sig));
-                }
-                return_i64(sig);
-            }
-        }
-    }
-
-    if (digi_is_exp(*cur)) {
-        dot_pos = cur;
-        goto digi_exp_more;
-    }
-
-    if (*cur == '.') {
-        dot_pos = cur++;
-        if (!digi_is_digit(*cur)) {
-            return_err(cur, "no digit after decimal point");
-        }
-    }
-
-
-    /* read more digits in fraction part */
-digi_frac_more:
-    sig_cut = cur; /* too large to fit in u64, excess digits need to be cut */
-    sig += (*cur >= '5'); /* round */
-    while (digi_is_digit(*++cur));
-    if (!dot_pos) {
-        if (!digi_is_fp(*cur) && has_read_flag(BIGNUM_AS_RAW)) {
-            return_raw(); /* it's a large integer */
-        }
-        dot_pos = cur;
-        if (*cur == '.') {
-            if (!digi_is_digit(*++cur)) {
-                return_err(cur, "no digit after decimal point");
-            }
-            while (digi_is_digit(*cur)) cur++;
-        }
-    }
-    exp_sig = (i64)(dot_pos - sig_cut);
-    exp_sig += (dot_pos < sig_cut);
-
-    /* ignore trailing zeros */
-    tmp = cur - 1;
-    while (*tmp == '0' || *tmp == '.') tmp--;
-    if (tmp < sig_cut) {
-        sig_cut = NULL;
-    } else {
-        sig_end = cur;
-    }
-
-    if (digi_is_exp(*cur)) goto digi_exp_more;
-    goto digi_exp_finish;
-
-
-    /* fraction part end */
-digi_frac_end:
-    if (unlikely(dot_pos + 1 == cur)) {
-        return_err(cur, "no digit after decimal point");
-    }
-    sig_end = cur;
-    exp_sig = -(i64)((u64)(cur - dot_pos) - 1);
-    if (likely(!digi_is_exp(*cur))) {
-        if (unlikely(exp_sig < F64_MIN_DEC_EXP - 19)) {
-            return_f64_bin(0); /* underflow */
-        }
-        exp = (i32)exp_sig;
-        goto digi_finish;
-    } else {
-        goto digi_exp_more;
-    }
-
-
-    /* read exponent part */
-digi_exp_more:
-    exp_sign = (*++cur == '-');
-    cur += digi_is_sign(*cur);
-    if (unlikely(!digi_is_digit(*cur))) {
-        return_err(cur, "no digit after exponent sign");
-    }
-    while (*cur == '0') cur++;
-
-    /* read exponent literal */
-    tmp = cur;
-    while (digi_is_digit(*cur)) {
-        exp_lit = (i64)((u8)(*cur++ - '0') + (u64)exp_lit * 10);
-    }
-    if (unlikely(cur - tmp >= U64_SAFE_DIG)) {
-        if (exp_sign) {
-            return_f64_bin(0); /* underflow */
-        } else {
-            return_inf(); /* overflow */
-        }
-    }
-    exp_sig += exp_sign ? -exp_lit : exp_lit;
-
-
-    /* validate exponent value */
-digi_exp_finish:
-    if (unlikely(exp_sig < F64_MIN_DEC_EXP - 19)) {
-        return_f64_bin(0); /* underflow */
-    }
-    if (unlikely(exp_sig > F64_MAX_DEC_EXP)) {
-        return_inf(); /* overflow */
-    }
-    exp = (i32)exp_sig;
-
-
-    /* all digit read finished */
-digi_finish:
-
-    /*
-     Fast path 1:
-
-     1. The floating-point number calculation should be accurate, see the
-        comments of macro `YYJSON_DOUBLE_MATH_CORRECT`.
-     2. Correct rounding should be performed (fegetround() == FE_TONEAREST).
-     3. The input of floating point number calculation does not lose precision,
-        which means: 64 - leading_zero(input) - trailing_zero(input) < 53.
-
-     We don't check all available inputs here, because that would make the code
-     more complicated, and not friendly to branch predictor.
-     */
-#if YYJSON_DOUBLE_MATH_CORRECT
-    if (sig < ((u64)1 << 53) &&
-        exp >= -F64_POW10_EXP_MAX_EXACT &&
-        exp <= +F64_POW10_EXP_MAX_EXACT) {
-        f64 dbl = (f64)sig;
-        if (exp < 0) {
-            dbl /= f64_pow10_table[-exp];
-        } else {
-            dbl *= f64_pow10_table[+exp];
-        }
-        return_f64(dbl);
-    }
-#endif
-
-    /*
-     Fast path 2:
-
-     To keep it simple, we only accept normal number here,
-     let the slow path to handle subnormal and infinity number.
-     */
-    if (likely(!sig_cut &&
-               exp > -F64_MAX_DEC_EXP + 1 &&
-               exp < +F64_MAX_DEC_EXP - 20)) {
-        /*
-         The result value is exactly equal to (sig * 10^exp),
-         the exponent part (10^exp) can be converted to (sig2 * 2^exp2).
-
-         The sig2 can be an infinite length number, only the highest 128 bits
-         is cached in the pow10_sig_table.
-
-         Now we have these bits:
-         sig1 (normalized 64bit)        : aaaaaaaa
-         sig2 (higher 64bit)            : bbbbbbbb
-         sig2_ext (lower 64bit)         : cccccccc
-         sig2_cut (extra unknown bits)  : dddddddddddd....
-
-         And the calculation process is:
-         ----------------------------------------
-                 aaaaaaaa *
-                 bbbbbbbbccccccccdddddddddddd....
-         ----------------------------------------
-         abababababababab +
-                 acacacacacacacac +
-                         adadadadadadadadadad....
-         ----------------------------------------
-         [hi____][lo____] +
-                 [hi2___][lo2___] +
-                         [unknown___________....]
-         ----------------------------------------
-
-         The addition with carry may affect higher bits, but if there is a 0
-         in higher bits, the bits higher than 0 will not be affected.
-
-         `lo2` + `unknown` may get a carry bit and may affect `hi2`, the max
-         value of `hi2` is 0xFFFFFFFFFFFFFFFE, so `hi2` will not overflow.
-
-         `lo` + `hi2` may also get a carry bit and may affect `hi`, but only
-         the highest significant 53 bits of `hi` is needed. If there is a 0
-         in the lower bits of `hi`, then all the following bits can be dropped.
-
-         To convert the result to IEEE-754 double number, we need to perform
-         correct rounding:
-         1. if bit 54 is 0, round down,
-         2. if bit 54 is 1 and any bit beyond bit 54 is 1, round up,
-         3. if bit 54 is 1 and all bits beyond bit 54 are 0, round to even,
-            as the extra bits is unknown, this case will not be handled here.
-         */
-
-        u64 raw;
-        u64 sig1, sig2, sig2_ext, hi, lo, hi2, lo2, add, bits;
-        i32 exp2;
-        u32 lz;
-        bool exact = false, carry, round_up;
-
-        /* convert (10^exp) to (sig2 * 2^exp2) */
-        pow10_table_get_sig(exp, &sig2, &sig2_ext);
-        pow10_table_get_exp(exp, &exp2);
-
-        /* normalize and multiply */
-        lz = u64_lz_bits(sig);
-        sig1 = sig << lz;
-        exp2 -= (i32)lz;
-        u128_mul(sig1, sig2, &hi, &lo);
-
-        /*
-         The `hi` is in range [0x4000000000000000, 0xFFFFFFFFFFFFFFFE],
-         To get normalized value, `hi` should be shifted to the left by 0 or 1.
-
-         The highest significant 53 bits is used by IEEE-754 double number,
-         and the bit 54 is used to detect rounding direction.
-
-         The lowest (64 - 54 - 1) bits is used to check whether it contains 0.
-         */
-        bits = hi & (((u64)1 << (64 - 54 - 1)) - 1);
-        if (bits - 1 < (((u64)1 << (64 - 54 - 1)) - 2)) {
-            /*
-             (bits != 0 && bits != 0x1FF) => (bits - 1 < 0x1FF - 1)
-             The `bits` is not zero, so we don't need to check `round to even`
-             case. The `bits` contains bit `0`, so we can drop the extra bits
-             after `0`.
-             */
-            exact = true;
-
-        } else {
-            /*
-             (bits == 0 || bits == 0x1FF)
-             The `bits` is filled with all `0` or all `1`, so we need to check
-             lower bits with another 64-bit multiplication.
-             */
-            u128_mul(sig1, sig2_ext, &hi2, &lo2);
-
-            add = lo + hi2;
-            if (add + 1 > (u64)1) {
-                /*
-                 (add != 0 && add != U64_MAX) => (add + 1 > 1)
-                 The `add` is not zero, so we don't need to check `round to
-                 even` case. The `add` contains bit `0`, so we can drop the
-                 extra bits after `0`. The `hi` cannot be U64_MAX, so it will
-                 not overflow.
-                 */
-                carry = add < lo || add < hi2;
-                hi += carry;
-                exact = true;
-            }
-        }
-
-        if (exact) {
-            /* normalize */
-            lz = hi < ((u64)1 << 63);
-            hi <<= lz;
-            exp2 -= (i32)lz;
-            exp2 += 64;
-
-            /* test the bit 54 and get rounding direction */
-            round_up = (hi & ((u64)1 << (64 - 54))) > (u64)0;
-            hi += (round_up ? ((u64)1 << (64 - 54)) : (u64)0);
-
-            /* test overflow */
-            if (hi < ((u64)1 << (64 - 54))) {
-                hi = ((u64)1 << 63);
-                exp2 += 1;
-            }
-
-            /* This is a normal number, convert it to IEEE-754 format. */
-            hi >>= F64_BITS - F64_SIG_FULL_BITS;
-            exp2 += F64_BITS - F64_SIG_FULL_BITS + F64_SIG_BITS;
-            exp2 += F64_EXP_BIAS;
-            raw = ((u64)exp2 << F64_SIG_BITS) | (hi & F64_SIG_MASK);
-            return_f64_bin(raw);
-        }
-    }
-
-    /*
-     Slow path: read double number exactly with diyfp.
-     1. Use cached diyfp to get an approximation value.
-     2. Use bigcomp to check the approximation value if needed.
-
-     This algorithm refers to google's double-conversion project:
-     https://github.com/google/double-conversion
-     */
-    {
-        const i32 ERR_ULP_LOG = 3;
-        const i32 ERR_ULP = 1 << ERR_ULP_LOG;
-        const i32 ERR_CACHED_POW = ERR_ULP / 2;
-        const i32 ERR_MUL_FIXED = ERR_ULP / 2;
-        const i32 DIY_SIG_BITS = 64;
-        const i32 EXP_BIAS = F64_EXP_BIAS + F64_SIG_BITS;
-        const i32 EXP_SUBNORMAL = -EXP_BIAS + 1;
-
-        u64 fp_err;
-        u32 bits;
-        i32 order_of_magnitude;
-        i32 effective_significand_size;
-        i32 precision_digits_count;
-        u64 precision_bits;
-        u64 half_way;
-
-        u64 raw;
-        diy_fp fp, fp_upper;
-        bigint big_full, big_comp;
-        i32 cmp;
-
-        fp.sig = sig;
-        fp.exp = 0;
-        fp_err = sig_cut ? (u64)(ERR_ULP / 2) : (u64)0;
-
-        /* normalize */
-        bits = u64_lz_bits(fp.sig);
-        fp.sig <<= bits;
-        fp.exp -= (i32)bits;
-        fp_err <<= bits;
-
-        /* multiply and add error */
-        fp = diy_fp_mul(fp, diy_fp_get_cached_pow10(exp));
-        fp_err += (u64)ERR_CACHED_POW + (fp_err != 0) + (u64)ERR_MUL_FIXED;
-
-        /* normalize */
-        bits = u64_lz_bits(fp.sig);
-        fp.sig <<= bits;
-        fp.exp -= (i32)bits;
-        fp_err <<= bits;
-
-        /* effective significand */
-        order_of_magnitude = DIY_SIG_BITS + fp.exp;
-        if (likely(order_of_magnitude >= EXP_SUBNORMAL + F64_SIG_FULL_BITS)) {
-            effective_significand_size = F64_SIG_FULL_BITS;
-        } else if (order_of_magnitude <= EXP_SUBNORMAL) {
-            effective_significand_size = 0;
-        } else {
-            effective_significand_size = order_of_magnitude - EXP_SUBNORMAL;
-        }
-
-        /* precision digits count */
-        precision_digits_count = DIY_SIG_BITS - effective_significand_size;
-        if (unlikely(precision_digits_count + ERR_ULP_LOG >= DIY_SIG_BITS)) {
-            i32 shr = (precision_digits_count + ERR_ULP_LOG) - DIY_SIG_BITS + 1;
-            fp.sig >>= shr;
-            fp.exp += shr;
-            fp_err = (fp_err >> shr) + 1 + (u32)ERR_ULP;
-            precision_digits_count -= shr;
-        }
-
-        /* half way */
-        precision_bits = fp.sig & (((u64)1 << precision_digits_count) - 1);
-        precision_bits *= (u32)ERR_ULP;
-        half_way = (u64)1 << (precision_digits_count - 1);
-        half_way *= (u32)ERR_ULP;
-
-        /* rounding */
-        fp.sig >>= precision_digits_count;
-        fp.sig += (precision_bits >= half_way + fp_err);
-        fp.exp += precision_digits_count;
-
-        /* get IEEE double raw value */
-        raw = diy_fp_to_ieee_raw(fp);
-        if (unlikely(raw == F64_RAW_INF)) return_inf();
-        if (likely(precision_bits <= half_way - fp_err ||
-                   precision_bits >= half_way + fp_err)) {
-            return_f64_bin(raw); /* number is accurate */
-        }
-        /* now the number is the correct value, or the next lower value */
-
-        /* upper boundary */
-        if (raw & F64_EXP_MASK) {
-            fp_upper.sig = (raw & F64_SIG_MASK) + ((u64)1 << F64_SIG_BITS);
-            fp_upper.exp = (i32)((raw & F64_EXP_MASK) >> F64_SIG_BITS);
-        } else {
-            fp_upper.sig = (raw & F64_SIG_MASK);
-            fp_upper.exp = 1;
-        }
-        fp_upper.exp -= F64_EXP_BIAS + F64_SIG_BITS;
-        fp_upper.sig <<= 1;
-        fp_upper.exp -= 1;
-        fp_upper.sig += 1; /* add half ulp */
-
-        /* compare with bigint */
-        bigint_set_buf(&big_full, sig, &exp, sig_cut, sig_end, dot_pos);
-        bigint_set_u64(&big_comp, fp_upper.sig);
-        if (exp >= 0) {
-            bigint_mul_pow10(&big_full, +exp);
-        } else {
-            bigint_mul_pow10(&big_comp, -exp);
-        }
-        if (fp_upper.exp > 0) {
-            bigint_mul_pow2(&big_comp, (u32)+fp_upper.exp);
-        } else {
-            bigint_mul_pow2(&big_full, (u32)-fp_upper.exp);
-        }
-        cmp = bigint_cmp(&big_full, &big_comp);
-        if (likely(cmp != 0)) {
-            /* round down or round up */
-            raw += (cmp > 0);
-        } else {
-            /* falls midway, round to even */
-            raw += (raw & 1);
-        }
-
-        if (unlikely(raw == F64_RAW_INF)) return_inf();
-        return_f64_bin(raw);
-    }
-
-#undef return_err
-#undef return_inf
-#undef return_0
-#undef return_i64
-#undef return_f64
-#undef return_f64_bin
-#undef return_raw
-}
-
-
-
-#else /* FP_READER */
-
-/**
- Read a JSON number.
- This is a fallback function if the custom number reader is disabled.
- This function use libc's strtod() to read floating-point number.
- */
-static_inline bool read_number(u8 **ptr,
-                               u8 **pre,
-                               yyjson_read_flag flg,
-                               yyjson_val *val,
-                               const char **msg) {
-
-#define return_err(_pos, _msg) do { \
-    *msg = _msg; \
-    *end = _pos; \
-    return false; \
-} while (false)
-
-#define return_0() do { \
-    val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); \
-    val->uni.u64 = 0; \
-    *end = cur; return true; \
-} while (false)
-
-#define return_i64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); \
-    val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); \
-    *end = cur; return true; \
-} while (false)
-
-#define return_f64(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); \
-    *end = cur; return true; \
-} while (false)
-
-#define return_f64_bin(_v) do { \
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \
-    val->uni.u64 = ((u64)sign << 63) | (u64)(_v); \
-    *end = cur; return true; \
-} while (false)
-
-#define return_inf() do { \
-    if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); \
-    if (has_read_flag(ALLOW_INF_AND_NAN)) return_f64_bin(F64_RAW_INF); \
-    else return_err(hdr, "number is infinity when parsed as double"); \
-} while (false)
-
-#define return_raw() do { \
-    if (*pre) **pre = '\0'; /* add null-terminator for previous raw string */ \
-    val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \
-    val->uni.str = (const char *)hdr; \
-    *pre = cur; *end = cur; return true; \
-} while (false)
-
-    u64 sig, num;
-    u8 *hdr = *ptr;
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    u8 *dot = NULL;
-    u8 *f64_end = NULL;
-    bool sign;
-
-    /* read number as raw string if has `YYJSON_READ_NUMBER_AS_RAW` flag */
-    if (unlikely(pre && !has_read_flag(BIGNUM_AS_RAW))) {
-        return read_number_raw(ptr, pre, flg, val, msg);
-    }
-
-    sign = (*hdr == '-');
-    cur += sign;
-    sig = (u8)(*cur - '0');
-
-    /* read first digit, check leading zero */
-    if (unlikely(!digi_is_digit(*cur))) {
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_inf_or_nan(sign, &cur, pre, val)) {
-                *end = cur;
-                return true;
-            }
-        }
-        return_err(cur, "no digit after minus sign");
-    }
-    if (*cur == '0') {
-        cur++;
-        if (unlikely(digi_is_digit(*cur))) {
-            return_err(cur - 1, "number with leading zero is not allowed");
-        }
-        if (!digi_is_fp(*cur)) return_0();
-        goto read_double;
-    }
-
-    /* read continuous digits, up to 19 characters */
-#define expr_intg(i) \
-    if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; \
-    else { cur += i; goto intg_end; }
-    repeat_in_1_18(expr_intg)
-#undef expr_intg
-
-    /* here are 19 continuous digits, skip them */
-    cur += 19;
-    if (digi_is_digit(cur[0]) && !digi_is_digit_or_fp(cur[1])) {
-        /* this number is an integer consisting of 20 digits */
-        num = (u8)(*cur - '0');
-        if ((sig < (U64_MAX / 10)) ||
-            (sig == (U64_MAX / 10) && num <= (U64_MAX % 10))) {
-            sig = num + sig * 10;
-            cur++;
-            if (sign) {
-                if (has_read_flag(BIGNUM_AS_RAW)) return_raw();
-                return_f64(normalized_u64_to_f64(sig));
-            }
-            return_i64(sig);
-        }
-    }
-
-intg_end:
-    /* continuous digits ended */
-    if (!digi_is_digit_or_fp(*cur)) {
-        /* this number is an integer consisting of 1 to 19 digits */
-        if (sign && (sig > ((u64)1 << 63))) {
-            if (has_read_flag(BIGNUM_AS_RAW)) return_raw();
-            return_f64(normalized_u64_to_f64(sig));
-        }
-        return_i64(sig);
-    }
-
-read_double:
-    /* this number should be read as double */
-    while (digi_is_digit(*cur)) cur++;
-    if (!digi_is_fp(*cur) && has_read_flag(BIGNUM_AS_RAW)) {
-        return_raw(); /* it's a large integer */
-    }
-    if (*cur == '.') {
-        /* skip fraction part */
-        dot = cur;
-        cur++;
-        if (!digi_is_digit(*cur)) {
-            return_err(cur, "no digit after decimal point");
-        }
-        cur++;
-        while (digi_is_digit(*cur)) cur++;
-    }
-    if (digi_is_exp(*cur)) {
-        /* skip exponent part */
-        cur += 1 + digi_is_sign(cur[1]);
-        if (!digi_is_digit(*cur)) {
-            return_err(cur, "no digit after exponent sign");
-        }
-        cur++;
-        while (digi_is_digit(*cur)) cur++;
-    }
-
-    /*
-     libc's strtod() is used to parse the floating-point number.
-
-     Note that the decimal point character used by strtod() is locale-dependent,
-     and the rounding direction may affected by fesetround().
-
-     For currently known locales, (en, zh, ja, ko, am, he, hi) use '.' as the
-     decimal point, while other locales use ',' as the decimal point.
-
-     Here strtod() is called twice for different locales, but if another thread
-     happens calls setlocale() between two strtod(), parsing may still fail.
-     */
-    val->uni.f64 = strtod((const char *)hdr, (char **)&f64_end);
-    if (unlikely(f64_end != cur)) {
-        /* replace '.' with ',' for locale */
-        bool cut = (*cur == ',');
-        if (cut) *cur = ' ';
-        if (dot) *dot = ',';
-        val->uni.f64 = strtod((const char *)hdr, (char **)&f64_end);
-        /* restore ',' to '.' */
-        if (cut) *cur = ',';
-        if (dot) *dot = '.';
-        if (unlikely(f64_end != cur)) {
-            return_err(hdr, "strtod() failed to parse the number");
-        }
-    }
-    if (unlikely(val->uni.f64 >= HUGE_VAL || val->uni.f64 <= -HUGE_VAL)) {
-        return_inf();
-    }
-    val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
-    *end = cur;
-    return true;
-
-#undef return_err
-#undef return_0
-#undef return_i64
-#undef return_f64
-#undef return_f64_bin
-#undef return_inf
-#undef return_raw
-}
-
-#endif /* FP_READER */
-
-
-
-/*==============================================================================
- * JSON String Reader
- *============================================================================*/
-
-/**
- Read a JSON string.
- @param ptr The head pointer of string before '"' prefix (inout).
- @param lst JSON last position.
- @param inv Allow invalid unicode.
- @param val The string value to be written.
- @param msg The error message pointer.
- @return Whether success.
- */
-static_inline bool read_string(u8 **ptr,
-                               u8 *lst,
-                               bool inv,
-                               yyjson_val *val,
-                               const char **msg) {
-    /*
-     Each unicode code point is encoded as 1 to 4 bytes in UTF-8 encoding,
-     we use 4-byte mask and pattern value to validate UTF-8 byte sequence,
-     this requires the input data to have 4-byte zero padding.
-     ---------------------------------------------------
-     1 byte
-     unicode range [U+0000, U+007F]
-     unicode min   [.......0]
-     unicode max   [.1111111]
-     bit pattern   [0.......]
-     ---------------------------------------------------
-     2 byte
-     unicode range [U+0080, U+07FF]
-     unicode min   [......10 ..000000]
-     unicode max   [...11111 ..111111]
-     bit require   [...xxxx. ........] (1E 00)
-     bit mask      [xxx..... xx......] (E0 C0)
-     bit pattern   [110..... 10......] (C0 80)
-     ---------------------------------------------------
-     3 byte
-     unicode range [U+0800, U+FFFF]
-     unicode min   [........ ..100000 ..000000]
-     unicode max   [....1111 ..111111 ..111111]
-     bit require   [....xxxx ..x..... ........] (0F 20 00)
-     bit mask      [xxxx.... xx...... xx......] (F0 C0 C0)
-     bit pattern   [1110.... 10...... 10......] (E0 80 80)
-     ---------------------------------------------------
-     3 byte invalid (reserved for surrogate halves)
-     unicode range [U+D800, U+DFFF]
-     unicode min   [....1101 ..100000 ..000000]
-     unicode max   [....1101 ..111111 ..111111]
-     bit mask      [....xxxx ..x..... ........] (0F 20 00)
-     bit pattern   [....1101 ..1..... ........] (0D 20 00)
-     ---------------------------------------------------
-     4 byte
-     unicode range [U+10000, U+10FFFF]
-     unicode min   [........ ...10000 ..000000 ..000000]
-     unicode max   [.....100 ..001111 ..111111 ..111111]
-     bit require   [.....xxx ..xx.... ........ ........] (07 30 00 00)
-     bit mask      [xxxxx... xx...... xx...... xx......] (F8 C0 C0 C0)
-     bit pattern   [11110... 10...... 10...... 10......] (F0 80 80 80)
-     ---------------------------------------------------
-     */
-#if YYJSON_ENDIAN == YYJSON_BIG_ENDIAN
-    const u32 b1_mask = 0x80000000UL;
-    const u32 b1_patt = 0x00000000UL;
-    const u32 b2_mask = 0xE0C00000UL;
-    const u32 b2_patt = 0xC0800000UL;
-    const u32 b2_requ = 0x1E000000UL;
-    const u32 b3_mask = 0xF0C0C000UL;
-    const u32 b3_patt = 0xE0808000UL;
-    const u32 b3_requ = 0x0F200000UL;
-    const u32 b3_erro = 0x0D200000UL;
-    const u32 b4_mask = 0xF8C0C0C0UL;
-    const u32 b4_patt = 0xF0808080UL;
-    const u32 b4_requ = 0x07300000UL;
-    const u32 b4_err0 = 0x04000000UL;
-    const u32 b4_err1 = 0x03300000UL;
-#elif YYJSON_ENDIAN == YYJSON_LITTLE_ENDIAN
-    const u32 b1_mask = 0x00000080UL;
-    const u32 b1_patt = 0x00000000UL;
-    const u32 b2_mask = 0x0000C0E0UL;
-    const u32 b2_patt = 0x000080C0UL;
-    const u32 b2_requ = 0x0000001EUL;
-    const u32 b3_mask = 0x00C0C0F0UL;
-    const u32 b3_patt = 0x008080E0UL;
-    const u32 b3_requ = 0x0000200FUL;
-    const u32 b3_erro = 0x0000200DUL;
-    const u32 b4_mask = 0xC0C0C0F8UL;
-    const u32 b4_patt = 0x808080F0UL;
-    const u32 b4_requ = 0x00003007UL;
-    const u32 b4_err0 = 0x00000004UL;
-    const u32 b4_err1 = 0x00003003UL;
-#else
-    /* this should be evaluated at compile-time */
-    v32_uni b1_mask_uni = {{ 0x80, 0x00, 0x00, 0x00 }};
-    v32_uni b1_patt_uni = {{ 0x00, 0x00, 0x00, 0x00 }};
-    v32_uni b2_mask_uni = {{ 0xE0, 0xC0, 0x00, 0x00 }};
-    v32_uni b2_patt_uni = {{ 0xC0, 0x80, 0x00, 0x00 }};
-    v32_uni b2_requ_uni = {{ 0x1E, 0x00, 0x00, 0x00 }};
-    v32_uni b3_mask_uni = {{ 0xF0, 0xC0, 0xC0, 0x00 }};
-    v32_uni b3_patt_uni = {{ 0xE0, 0x80, 0x80, 0x00 }};
-    v32_uni b3_requ_uni = {{ 0x0F, 0x20, 0x00, 0x00 }};
-    v32_uni b3_erro_uni = {{ 0x0D, 0x20, 0x00, 0x00 }};
-    v32_uni b4_mask_uni = {{ 0xF8, 0xC0, 0xC0, 0xC0 }};
-    v32_uni b4_patt_uni = {{ 0xF0, 0x80, 0x80, 0x80 }};
-    v32_uni b4_requ_uni = {{ 0x07, 0x30, 0x00, 0x00 }};
-    v32_uni b4_err0_uni = {{ 0x04, 0x00, 0x00, 0x00 }};
-    v32_uni b4_err1_uni = {{ 0x03, 0x30, 0x00, 0x00 }};
-    u32 b1_mask = b1_mask_uni.u;
-    u32 b1_patt = b1_patt_uni.u;
-    u32 b2_mask = b2_mask_uni.u;
-    u32 b2_patt = b2_patt_uni.u;
-    u32 b2_requ = b2_requ_uni.u;
-    u32 b3_mask = b3_mask_uni.u;
-    u32 b3_patt = b3_patt_uni.u;
-    u32 b3_requ = b3_requ_uni.u;
-    u32 b3_erro = b3_erro_uni.u;
-    u32 b4_mask = b4_mask_uni.u;
-    u32 b4_patt = b4_patt_uni.u;
-    u32 b4_requ = b4_requ_uni.u;
-    u32 b4_err0 = b4_err0_uni.u;
-    u32 b4_err1 = b4_err1_uni.u;
-#endif
-
-#define is_valid_seq_1(uni) ( \
-    ((uni & b1_mask) == b1_patt) \
-)
-
-#define is_valid_seq_2(uni) ( \
-    ((uni & b2_mask) == b2_patt) && \
-    ((uni & b2_requ)) \
-)
-
-#define is_valid_seq_3(uni) ( \
-    ((uni & b3_mask) == b3_patt) && \
-    ((tmp = (uni & b3_requ))) && \
-    ((tmp != b3_erro)) \
-)
-
-#define is_valid_seq_4(uni) ( \
-    ((uni & b4_mask) == b4_patt) && \
-    ((tmp = (uni & b4_requ))) && \
-    ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \
-)
-
-#define return_err(_end, _msg) do { \
-    *msg = _msg; \
-    *end = _end; \
-    return false; \
-} while (false)
-
-    u8 *cur = *ptr;
-    u8 **end = ptr;
-    u8 *src = ++cur, *dst, *pos;
-    u16 hi, lo;
-    u32 uni, tmp;
-
-skip_ascii:
-    /* Most strings have no escaped characters, so we can jump them quickly. */
-
-skip_ascii_begin:
-    /*
-     We want to make loop unrolling, as shown in the following code. Some
-     compiler may not generate instructions as expected, so we rewrite it with
-     explicit goto statements. We hope the compiler can generate instructions
-     like this: https://godbolt.org/z/8vjsYq
-
-         while (true) repeat16({
-            if (likely(!(char_is_ascii_stop(*src)))) src++;
-            else break;
-         })
-     */
-#define expr_jump(i) \
-    if (likely(!char_is_ascii_stop(src[i]))) {} \
-    else goto skip_ascii_stop##i;
-
-#define expr_stop(i) \
-    skip_ascii_stop##i: \
-    src += i; \
-    goto skip_ascii_end;
-
-    repeat16_incr(expr_jump)
-    src += 16;
-    goto skip_ascii_begin;
-    repeat16_incr(expr_stop)
-
-#undef expr_jump
-#undef expr_stop
-
-skip_ascii_end:
-
-    /*
-     GCC may store src[i] in a register at each line of expr_jump(i) above.
-     These instructions are useless and will degrade performance.
-     This inline asm is a hint for gcc: "the memory has been modified,
-     do not cache it".
-
-     MSVC, Clang, ICC can generate expected instructions without this hint.
-     */
-#if YYJSON_IS_REAL_GCC
-    __asm__ volatile("":"=m"(*src));
-#endif
-    if (likely(*src == '"')) {
-        val->tag = ((u64)(src - cur) << YYJSON_TAG_BIT) |
-                    (u64)(YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC);
-        val->uni.str = (const char *)cur;
-        *src = '\0';
-        *end = src + 1;
-        return true;
-    }
-
-skip_utf8:
-    if (*src & 0x80) { /* non-ASCII character */
-        /*
-         Non-ASCII character appears here, which means that the text is likely
-         to be written in non-English or emoticons. According to some common
-         data set statistics, byte sequences of the same length may appear
-         consecutively. We process the byte sequences of the same length in each
-         loop, which is more friendly to branch prediction.
-         */
-        pos = src;
-#if YYJSON_DISABLE_UTF8_VALIDATION
-        while (true) repeat8({
-            if (likely((*src & 0xF0) == 0xE0)) src += 3;
-            else break;
-        })
-        if (*src < 0x80) goto skip_ascii;
-        while (true) repeat8({
-            if (likely((*src & 0xE0) == 0xC0)) src += 2;
-            else break;
-        })
-        while (true) repeat8({
-            if (likely((*src & 0xF8) == 0xF0)) src += 4;
-            else break;
-        })
-#else
-        uni = byte_load_4(src);
-        while (is_valid_seq_3(uni)) {
-            src += 3;
-            uni = byte_load_4(src);
-        }
-        if (is_valid_seq_1(uni)) goto skip_ascii;
-        while (is_valid_seq_2(uni)) {
-            src += 2;
-            uni = byte_load_4(src);
-        }
-        while (is_valid_seq_4(uni)) {
-            src += 4;
-            uni = byte_load_4(src);
-        }
-#endif
-        if (unlikely(pos == src)) {
-            if (!inv) return_err(src, "invalid UTF-8 encoding in string");
-            ++src;
-        }
-        goto skip_ascii;
-    }
-
-    /* The escape character appears, we need to copy it. */
-    dst = src;
-copy_escape:
-    if (likely(*src == '\\')) {
-        switch (*++src) {
-            case '"':  *dst++ = '"';  src++; break;
-            case '\\': *dst++ = '\\'; src++; break;
-            case '/':  *dst++ = '/';  src++; break;
-            case 'b':  *dst++ = '\b'; src++; break;
-            case 'f':  *dst++ = '\f'; src++; break;
-            case 'n':  *dst++ = '\n'; src++; break;
-            case 'r':  *dst++ = '\r'; src++; break;
-            case 't':  *dst++ = '\t'; src++; break;
-            case 'u':
-                if (unlikely(!read_hex_u16(++src, &hi))) {
-                    return_err(src - 2, "invalid escaped sequence in string");
-                }
-                src += 4;
-                if (likely((hi & 0xF800) != 0xD800)) {
-                    /* a BMP character */
-                    if (hi >= 0x800) {
-                        *dst++ = (u8)(0xE0 | (hi >> 12));
-                        *dst++ = (u8)(0x80 | ((hi >> 6) & 0x3F));
-                        *dst++ = (u8)(0x80 | (hi & 0x3F));
-                    } else if (hi >= 0x80) {
-                        *dst++ = (u8)(0xC0 | (hi >> 6));
-                        *dst++ = (u8)(0x80 | (hi & 0x3F));
-                    } else {
-                        *dst++ = (u8)hi;
-                    }
-                } else {
-                    /* a non-BMP character, represented as a surrogate pair */
-                    if (unlikely((hi & 0xFC00) != 0xD800)) {
-                        return_err(src - 6, "invalid high surrogate in string");
-                    }
-                    if (unlikely(!byte_match_2(src, "\\u"))) {
-                        return_err(src, "no low surrogate in string");
-                    }
-                    if (unlikely(!read_hex_u16(src + 2, &lo))) {
-                        return_err(src, "invalid escaped sequence in string");
-                    }
-                    if (unlikely((lo & 0xFC00) != 0xDC00)) {
-                        return_err(src, "invalid low surrogate in string");
-                    }
-                    uni = ((((u32)hi - 0xD800) << 10) |
-                            ((u32)lo - 0xDC00)) + 0x10000;
-                    *dst++ = (u8)(0xF0 | (uni >> 18));
-                    *dst++ = (u8)(0x80 | ((uni >> 12) & 0x3F));
-                    *dst++ = (u8)(0x80 | ((uni >> 6) & 0x3F));
-                    *dst++ = (u8)(0x80 | (uni & 0x3F));
-                    src += 6;
-                }
-                break;
-            default: return_err(src, "invalid escaped character in string");
-        }
-    } else if (likely(*src == '"')) {
-        val->tag = ((u64)(dst - cur) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-        val->uni.str = (const char *)cur;
-        *dst = '\0';
-        *end = src + 1;
-        return true;
-    } else {
-        if (!inv) return_err(src, "unexpected control character in string");
-        if (src >= lst) return_err(src, "unclosed string");
-        *dst++ = *src++;
-    }
-
-copy_ascii:
-    /*
-     Copy continuous ASCII, loop unrolling, same as the following code:
-
-         while (true) repeat16({
-            if (unlikely(char_is_ascii_stop(*src))) break;
-            *dst++ = *src++;
-         })
-     */
-#if YYJSON_IS_REAL_GCC
-#   define expr_jump(i) \
-    if (likely(!(char_is_ascii_stop(src[i])))) {} \
-    else { __asm__ volatile("":"=m"(src[i])); goto copy_ascii_stop_##i; }
-#else
-#   define expr_jump(i) \
-    if (likely(!(char_is_ascii_stop(src[i])))) {} \
-    else { goto copy_ascii_stop_##i; }
-#endif
-    repeat16_incr(expr_jump)
-#undef expr_jump
-
-    byte_move_16(dst, src);
-    src += 16;
-    dst += 16;
-    goto copy_ascii;
-
-    /*
-     The memory will be moved forward by at least 1 byte. So the `byte_move`
-     can be one byte more than needed to reduce the number of instructions.
-     */
-copy_ascii_stop_0:
-    goto copy_utf8;
-copy_ascii_stop_1:
-    byte_move_2(dst, src);
-    src += 1;
-    dst += 1;
-    goto copy_utf8;
-copy_ascii_stop_2:
-    byte_move_2(dst, src);
-    src += 2;
-    dst += 2;
-    goto copy_utf8;
-copy_ascii_stop_3:
-    byte_move_4(dst, src);
-    src += 3;
-    dst += 3;
-    goto copy_utf8;
-copy_ascii_stop_4:
-    byte_move_4(dst, src);
-    src += 4;
-    dst += 4;
-    goto copy_utf8;
-copy_ascii_stop_5:
-    byte_move_4(dst, src);
-    byte_move_2(dst + 4, src + 4);
-    src += 5;
-    dst += 5;
-    goto copy_utf8;
-copy_ascii_stop_6:
-    byte_move_4(dst, src);
-    byte_move_2(dst + 4, src + 4);
-    src += 6;
-    dst += 6;
-    goto copy_utf8;
-copy_ascii_stop_7:
-    byte_move_8(dst, src);
-    src += 7;
-    dst += 7;
-    goto copy_utf8;
-copy_ascii_stop_8:
-    byte_move_8(dst, src);
-    src += 8;
-    dst += 8;
-    goto copy_utf8;
-copy_ascii_stop_9:
-    byte_move_8(dst, src);
-    byte_move_2(dst + 8, src + 8);
-    src += 9;
-    dst += 9;
-    goto copy_utf8;
-copy_ascii_stop_10:
-    byte_move_8(dst, src);
-    byte_move_2(dst + 8, src + 8);
-    src += 10;
-    dst += 10;
-    goto copy_utf8;
-copy_ascii_stop_11:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    src += 11;
-    dst += 11;
-    goto copy_utf8;
-copy_ascii_stop_12:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    src += 12;
-    dst += 12;
-    goto copy_utf8;
-copy_ascii_stop_13:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    byte_move_2(dst + 12, src + 12);
-    src += 13;
-    dst += 13;
-    goto copy_utf8;
-copy_ascii_stop_14:
-    byte_move_8(dst, src);
-    byte_move_4(dst + 8, src + 8);
-    byte_move_2(dst + 12, src + 12);
-    src += 14;
-    dst += 14;
-    goto copy_utf8;
-copy_ascii_stop_15:
-    byte_move_16(dst, src);
-    src += 15;
-    dst += 15;
-    goto copy_utf8;
-
-copy_utf8:
-    if (*src & 0x80) { /* non-ASCII character */
-        pos = src;
-        uni = byte_load_4(src);
-#if YYJSON_DISABLE_UTF8_VALIDATION
-        while (true) repeat4({
-            if ((uni & b3_mask) == b3_patt) {
-                byte_copy_4(dst, &uni);
-                dst += 3;
-                src += 3;
-                uni = byte_load_4(src);
-            } else break;
-        })
-        if ((uni & b1_mask) == b1_patt) goto copy_ascii;
-        while (true) repeat4({
-            if ((uni & b2_mask) == b2_patt) {
-                byte_copy_2(dst, &uni);
-                dst += 2;
-                src += 2;
-                uni = byte_load_4(src);
-            } else break;
-        })
-        while (true) repeat4({
-            if ((uni & b4_mask) == b4_patt) {
-                byte_copy_4(dst, &uni);
-                dst += 4;
-                src += 4;
-                uni = byte_load_4(src);
-            } else break;
-        })
-#else
-        while (is_valid_seq_3(uni)) {
-            byte_copy_4(dst, &uni);
-            dst += 3;
-            src += 3;
-            uni = byte_load_4(src);
-        }
-        if (is_valid_seq_1(uni)) goto copy_ascii;
-        while (is_valid_seq_2(uni)) {
-            byte_copy_2(dst, &uni);
-            dst += 2;
-            src += 2;
-            uni = byte_load_4(src);
-        }
-        while (is_valid_seq_4(uni)) {
-            byte_copy_4(dst, &uni);
-            dst += 4;
-            src += 4;
-            uni = byte_load_4(src);
-        }
-#endif
-        if (unlikely(pos == src)) {
-            if (!inv) return_err(src, "invalid UTF-8 encoding in string");
-            goto copy_ascii_stop_1;
-        }
-        goto copy_ascii;
-    }
-    goto copy_escape;
-
-#undef return_err
-#undef is_valid_seq_1
-#undef is_valid_seq_2
-#undef is_valid_seq_3
-#undef is_valid_seq_4
-}
-
-
-
-/*==============================================================================
- * JSON Reader Implementation
- *
- * We use goto statements to build the finite state machine (FSM).
- * The FSM's state was held by program counter (PC) and the 'goto' make the
- * state transitions.
- *============================================================================*/
-
-/** Read single value JSON document. */
-static_noinline yyjson_doc *read_root_single(u8 *hdr,
-                                             u8 *cur,
-                                             u8 *end,
-                                             yyjson_alc alc,
-                                             yyjson_read_flag flg,
-                                             yyjson_read_err *err) {
-
-#define return_err(_pos, _code, _msg) do { \
-    if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { \
-        err->pos = (usize)(end - hdr); \
-        err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \
-        err->msg = "unexpected end of data"; \
-    } else { \
-        err->pos = (usize)(_pos - hdr); \
-        err->code = YYJSON_READ_ERROR_##_code; \
-        err->msg = _msg; \
-    } \
-    if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \
-    return NULL; \
-} while (false)
-
-    usize hdr_len; /* value count used by doc */
-    usize alc_num; /* value count capacity */
-    yyjson_val *val_hdr; /* the head of allocated values */
-    yyjson_val *val; /* current value */
-    yyjson_doc *doc; /* the JSON document, equals to val_hdr */
-    const char *msg; /* error message */
-
-    bool raw; /* read number as raw */
-    bool inv; /* allow invalid unicode */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-
-    hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
-    hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
-    alc_num = hdr_len + 1; /* single value */
-
-    val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_num * sizeof(yyjson_val));
-    if (unlikely(!val_hdr)) goto fail_alloc;
-    val = val_hdr + hdr_len;
-    raw = has_read_flag(NUMBER_AS_RAW) || has_read_flag(BIGNUM_AS_RAW);
-    inv = has_read_flag(ALLOW_INVALID_UNICODE) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-
-    if (char_is_number(*cur)) {
-        if (likely(read_number(&cur, pre, flg, val, &msg))) goto doc_end;
-        goto fail_number;
-    }
-    if (*cur == '"') {
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto doc_end;
-        goto fail_string;
-    }
-    if (*cur == 't') {
-        if (likely(read_true(&cur, val))) goto doc_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        if (likely(read_false(&cur, val))) goto doc_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        if (likely(read_null(&cur, val))) goto doc_end;
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_nan(false, &cur, pre, val)) goto doc_end;
-        }
-        goto fail_literal;
-    }
-    if (has_read_flag(ALLOW_INF_AND_NAN)) {
-        if (read_inf_or_nan(false, &cur, pre, val)) goto doc_end;
-    }
-    goto fail_character;
-
-doc_end:
-    /* check invalid contents after json document */
-    if (unlikely(cur < end) && !has_read_flag(STOP_WHEN_DONE)) {
-        if (has_read_flag(ALLOW_COMMENTS)) {
-            if (!skip_spaces_and_comments(&cur)) {
-                if (byte_match_2(cur, "/*")) goto fail_comment;
-            }
-        } else {
-            while (char_is_space(*cur)) cur++;
-        }
-        if (unlikely(cur < end)) goto fail_garbage;
-    }
-
-    if (pre && *pre) **pre = '\0';
-    doc = (yyjson_doc *)val_hdr;
-    doc->root = val_hdr + hdr_len;
-    doc->alc = alc;
-    doc->dat_read = (usize)(cur - hdr);
-    doc->val_read = 1;
-    doc->str_pool = has_read_flag(INSITU) ? NULL : (char *)hdr;
-    return doc;
-
-fail_string:
-    return_err(cur, INVALID_STRING, msg);
-fail_number:
-    return_err(cur, INVALID_NUMBER, msg);
-fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
-fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
-
-#undef return_err
-}
-
-/** Read JSON document (accept all style, but optimized for minify). */
-static_inline yyjson_doc *read_root_minify(u8 *hdr,
-                                           u8 *cur,
-                                           u8 *end,
-                                           yyjson_alc alc,
-                                           yyjson_read_flag flg,
-                                           yyjson_read_err *err) {
-
-#define return_err(_pos, _code, _msg) do { \
-    if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { \
-        err->pos = (usize)(end - hdr); \
-        err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \
-        err->msg = "unexpected end of data"; \
-    } else { \
-        err->pos = (usize)(_pos - hdr); \
-        err->code = YYJSON_READ_ERROR_##_code; \
-        err->msg = _msg; \
-    } \
-    if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \
-    return NULL; \
-} while (false)
-
-#define val_incr() do { \
-    val++; \
-    if (unlikely(val >= val_end)) { \
-        usize alc_old = alc_len; \
-        alc_len += alc_len / 2; \
-        if ((sizeof(usize) < 8) && (alc_len >= alc_max)) goto fail_alloc; \
-        val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, \
-            alc_old * sizeof(yyjson_val), \
-            alc_len * sizeof(yyjson_val)); \
-        if ((!val_tmp)) goto fail_alloc; \
-        val = val_tmp + (usize)(val - val_hdr); \
-        ctn = val_tmp + (usize)(ctn - val_hdr); \
-        val_hdr = val_tmp; \
-        val_end = val_tmp + (alc_len - 2); \
-    } \
-} while (false)
-
-    usize dat_len; /* data length in bytes, hint for allocator */
-    usize hdr_len; /* value count used by yyjson_doc */
-    usize alc_len; /* value count allocated */
-    usize alc_max; /* maximum value count for allocator */
-    usize ctn_len; /* the number of elements in current container */
-    yyjson_val *val_hdr; /* the head of allocated values */
-    yyjson_val *val_end; /* the end of allocated values */
-    yyjson_val *val_tmp; /* temporary pointer for realloc */
-    yyjson_val *val; /* current JSON value */
-    yyjson_val *ctn; /* current container */
-    yyjson_val *ctn_parent; /* parent of current container */
-    yyjson_doc *doc; /* the JSON document, equals to val_hdr */
-    const char *msg; /* error message */
-
-    bool raw; /* read number as raw */
-    bool inv; /* allow invalid unicode */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-
-    dat_len = has_read_flag(STOP_WHEN_DONE) ? 256 : (usize)(end - cur);
-    hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
-    hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
-    alc_max = USIZE_MAX / sizeof(yyjson_val);
-    alc_len = hdr_len + (dat_len / YYJSON_READER_ESTIMATED_MINIFY_RATIO) + 4;
-    alc_len = yyjson_min(alc_len, alc_max);
-
-    val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_len * sizeof(yyjson_val));
-    if (unlikely(!val_hdr)) goto fail_alloc;
-    val_end = val_hdr + (alc_len - 2); /* padding for key-value pair reading */
-    val = val_hdr + hdr_len;
-    ctn = val;
-    ctn_len = 0;
-    raw = has_read_flag(NUMBER_AS_RAW) || has_read_flag(BIGNUM_AS_RAW);
-    inv = has_read_flag(ALLOW_INVALID_UNICODE) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-
-    if (*cur++ == '{') {
-        ctn->tag = YYJSON_TYPE_OBJ;
-        ctn->uni.ofs = 0;
-        goto obj_key_begin;
-    } else {
-        ctn->tag = YYJSON_TYPE_ARR;
-        ctn->uni.ofs = 0;
-        goto arr_val_begin;
-    }
-
-arr_begin:
-    /* save current container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-
-    /* create a new array value, save parent container offset */
-    val_incr();
-    val->tag = YYJSON_TYPE_ARR;
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-
-    /* push the new array value as current container */
-    ctn = val;
-    ctn_len = 0;
-
-arr_val_begin:
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (char_is_number(*cur)) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_number(&cur, pre, flg, val, &msg))) goto arr_val_end;
-        goto fail_number;
-    }
-    if (*cur == '"') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto arr_val_end;
-        goto fail_string;
-    }
-    if (*cur == 't') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto arr_val_end;
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_nan(false, &cur, pre, val)) goto arr_val_end;
-        }
-        goto fail_literal;
-    }
-    if (*cur == ']') {
-        cur++;
-        if (likely(ctn_len == 0)) goto arr_end;
-        if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto arr_end;
-        while (*cur != ',') cur--;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_begin;
-    }
-    if (has_read_flag(ALLOW_INF_AND_NAN) &&
-        (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val_incr();
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end;
-        goto fail_character;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-arr_val_end:
-    if (*cur == ',') {
-        cur++;
-        goto arr_val_begin;
-    }
-    if (*cur == ']') {
-        cur++;
-        goto arr_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_end;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-arr_end:
-    /* get parent container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-
-    /* save the next sibling value offset */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = ((ctn_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-
-    /* pop parent as current container */
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-
-obj_begin:
-    /* push container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-    val_incr();
-    val->tag = YYJSON_TYPE_OBJ;
-    /* offset to the parent */
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-    ctn = val;
-    ctn_len = 0;
-
-obj_key_begin:
-    if (likely(*cur == '"')) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_key_end;
-        goto fail_string;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        if (likely(ctn_len == 0)) goto obj_end;
-        if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto obj_end;
-        while (*cur != ',') cur--;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_begin;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_key_end:
-    if (*cur == ':') {
-        cur++;
-        goto obj_val_begin;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_end;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_val_begin:
-    if (*cur == '"') {
-        val++;
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_val_end;
-        goto fail_string;
-    }
-    if (char_is_number(*cur)) {
-        val++;
-        ctn_len++;
-        if (likely(read_number(&cur, pre, flg, val, &msg))) goto obj_val_end;
-        goto fail_number;
-    }
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (*cur == 't') {
-        val++;
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val++;
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val++;
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto obj_val_end;
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_nan(false, &cur, pre, val)) goto obj_val_end;
-        }
-        goto fail_literal;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_begin;
-    }
-    if (has_read_flag(ALLOW_INF_AND_NAN) &&
-        (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val++;
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end;
-        goto fail_character;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_val_end:
-    if (likely(*cur == ',')) {
-        cur++;
-        goto obj_key_begin;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        goto obj_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_end;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_end:
-    /* pop container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-    /* point to the next value */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = (ctn_len << (YYJSON_TAG_BIT - 1)) | YYJSON_TYPE_OBJ;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-
-doc_end:
-    /* check invalid contents after json document */
-    if (unlikely(cur < end) && !has_read_flag(STOP_WHEN_DONE)) {
-        if (has_read_flag(ALLOW_COMMENTS)) {
-            skip_spaces_and_comments(&cur);
-            if (byte_match_2(cur, "/*")) goto fail_comment;
-        } else {
-            while (char_is_space(*cur)) cur++;
-        }
-        if (unlikely(cur < end)) goto fail_garbage;
-    }
-
-    if (pre && *pre) **pre = '\0';
-    doc = (yyjson_doc *)val_hdr;
-    doc->root = val_hdr + hdr_len;
-    doc->alc = alc;
-    doc->dat_read = (usize)(cur - hdr);
-    doc->val_read = (usize)((val - doc->root) + 1);
-    doc->str_pool = has_read_flag(INSITU) ? NULL : (char *)hdr;
-    return doc;
-
-fail_string:
-    return_err(cur, INVALID_STRING, msg);
-fail_number:
-    return_err(cur, INVALID_NUMBER, msg);
-fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_trailing_comma:
-    return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
-fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
-
-#undef val_incr
-#undef return_err
-}
-
-/** Read JSON document (accept all style, but optimized for pretty). */
-static_inline yyjson_doc *read_root_pretty(u8 *hdr,
-                                           u8 *cur,
-                                           u8 *end,
-                                           yyjson_alc alc,
-                                           yyjson_read_flag flg,
-                                           yyjson_read_err *err) {
-
-#define return_err(_pos, _code, _msg) do { \
-    if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { \
-        err->pos = (usize)(end - hdr); \
-        err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \
-        err->msg = "unexpected end of data"; \
-    } else { \
-        err->pos = (usize)(_pos - hdr); \
-        err->code = YYJSON_READ_ERROR_##_code; \
-        err->msg = _msg; \
-    } \
-    if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \
-    return NULL; \
-} while (false)
-
-#define val_incr() do { \
-    val++; \
-    if (unlikely(val >= val_end)) { \
-        usize alc_old = alc_len; \
-        alc_len += alc_len / 2; \
-        if ((sizeof(usize) < 8) && (alc_len >= alc_max)) goto fail_alloc; \
-        val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, \
-            alc_old * sizeof(yyjson_val), \
-            alc_len * sizeof(yyjson_val)); \
-        if ((!val_tmp)) goto fail_alloc; \
-        val = val_tmp + (usize)(val - val_hdr); \
-        ctn = val_tmp + (usize)(ctn - val_hdr); \
-        val_hdr = val_tmp; \
-        val_end = val_tmp + (alc_len - 2); \
-    } \
-} while (false)
-
-    usize dat_len; /* data length in bytes, hint for allocator */
-    usize hdr_len; /* value count used by yyjson_doc */
-    usize alc_len; /* value count allocated */
-    usize alc_max; /* maximum value count for allocator */
-    usize ctn_len; /* the number of elements in current container */
-    yyjson_val *val_hdr; /* the head of allocated values */
-    yyjson_val *val_end; /* the end of allocated values */
-    yyjson_val *val_tmp; /* temporary pointer for realloc */
-    yyjson_val *val; /* current JSON value */
-    yyjson_val *ctn; /* current container */
-    yyjson_val *ctn_parent; /* parent of current container */
-    yyjson_doc *doc; /* the JSON document, equals to val_hdr */
-    const char *msg; /* error message */
-
-    bool raw; /* read number as raw */
-    bool inv; /* allow invalid unicode */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-
-    dat_len = has_read_flag(STOP_WHEN_DONE) ? 256 : (usize)(end - cur);
-    hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
-    hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
-    alc_max = USIZE_MAX / sizeof(yyjson_val);
-    alc_len = hdr_len + (dat_len / YYJSON_READER_ESTIMATED_PRETTY_RATIO) + 4;
-    alc_len = yyjson_min(alc_len, alc_max);
-
-    val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_len * sizeof(yyjson_val));
-    if (unlikely(!val_hdr)) goto fail_alloc;
-    val_end = val_hdr + (alc_len - 2); /* padding for key-value pair reading */
-    val = val_hdr + hdr_len;
-    ctn = val;
-    ctn_len = 0;
-    raw = has_read_flag(NUMBER_AS_RAW) || has_read_flag(BIGNUM_AS_RAW);
-    inv = has_read_flag(ALLOW_INVALID_UNICODE) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-
-    if (*cur++ == '{') {
-        ctn->tag = YYJSON_TYPE_OBJ;
-        ctn->uni.ofs = 0;
-        if (*cur == '\n') cur++;
-        goto obj_key_begin;
-    } else {
-        ctn->tag = YYJSON_TYPE_ARR;
-        ctn->uni.ofs = 0;
-        if (*cur == '\n') cur++;
-        goto arr_val_begin;
-    }
-
-arr_begin:
-    /* save current container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-
-    /* create a new array value, save parent container offset */
-    val_incr();
-    val->tag = YYJSON_TYPE_ARR;
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-
-    /* push the new array value as current container */
-    ctn = val;
-    ctn_len = 0;
-    if (*cur == '\n') cur++;
-
-arr_val_begin:
-#if YYJSON_IS_REAL_GCC
-    while (true) repeat16({
-        if (byte_match_2(cur, "  ")) cur += 2;
-        else break;
-    })
-#else
-    while (true) repeat16({
-        if (likely(byte_match_2(cur, "  "))) cur += 2;
-        else break;
-    })
-#endif
-
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (char_is_number(*cur)) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_number(&cur, pre, flg, val, &msg))) goto arr_val_end;
-        goto fail_number;
-    }
-    if (*cur == '"') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto arr_val_end;
-        goto fail_string;
-    }
-    if (*cur == 't') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto arr_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val_incr();
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto arr_val_end;
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_nan(false, &cur, pre, val)) goto arr_val_end;
-        }
-        goto fail_literal;
-    }
-    if (*cur == ']') {
-        cur++;
-        if (likely(ctn_len == 0)) goto arr_end;
-        if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto arr_end;
-        while (*cur != ',') cur--;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_begin;
-    }
-    if (has_read_flag(ALLOW_INF_AND_NAN) &&
-        (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val_incr();
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end;
-        goto fail_character;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-arr_val_end:
-    if (byte_match_2(cur, ",\n")) {
-        cur += 2;
-        goto arr_val_begin;
-    }
-    if (*cur == ',') {
-        cur++;
-        goto arr_val_begin;
-    }
-    if (*cur == ']') {
-        cur++;
-        goto arr_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto arr_val_end;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto arr_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-arr_end:
-    /* get parent container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-
-    /* save the next sibling value offset */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = ((ctn_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-
-    /* pop parent as current container */
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if (*cur == '\n') cur++;
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-
-obj_begin:
-    /* push container */
-    ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
-               (ctn->tag & YYJSON_TAG_MASK);
-    val_incr();
-    val->tag = YYJSON_TYPE_OBJ;
-    /* offset to the parent */
-    val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn);
-    ctn = val;
-    ctn_len = 0;
-    if (*cur == '\n') cur++;
-
-obj_key_begin:
-#if YYJSON_IS_REAL_GCC
-    while (true) repeat16({
-        if (byte_match_2(cur, "  ")) cur += 2;
-        else break;
-    })
-#else
-    while (true) repeat16({
-        if (likely(byte_match_2(cur, "  "))) cur += 2;
-        else break;
-    })
-#endif
-    if (likely(*cur == '"')) {
-        val_incr();
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_key_end;
-        goto fail_string;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        if (likely(ctn_len == 0)) goto obj_end;
-        if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto obj_end;
-        while (*cur != ',') cur--;
-        goto fail_trailing_comma;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_begin;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_key_end:
-    if (byte_match_2(cur, ": ")) {
-        cur += 2;
-        goto obj_val_begin;
-    }
-    if (*cur == ':') {
-        cur++;
-        goto obj_val_begin;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_key_end;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_key_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_val_begin:
-    if (*cur == '"') {
-        val++;
-        ctn_len++;
-        if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_val_end;
-        goto fail_string;
-    }
-    if (char_is_number(*cur)) {
-        val++;
-        ctn_len++;
-        if (likely(read_number(&cur, pre, flg, val, &msg))) goto obj_val_end;
-        goto fail_number;
-    }
-    if (*cur == '{') {
-        cur++;
-        goto obj_begin;
-    }
-    if (*cur == '[') {
-        cur++;
-        goto arr_begin;
-    }
-    if (*cur == 't') {
-        val++;
-        ctn_len++;
-        if (likely(read_true(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'f') {
-        val++;
-        ctn_len++;
-        if (likely(read_false(&cur, val))) goto obj_val_end;
-        goto fail_literal;
-    }
-    if (*cur == 'n') {
-        val++;
-        ctn_len++;
-        if (likely(read_null(&cur, val))) goto obj_val_end;
-        if (has_read_flag(ALLOW_INF_AND_NAN)) {
-            if (read_nan(false, &cur, pre, val)) goto obj_val_end;
-        }
-        goto fail_literal;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_begin;
-    }
-    if (has_read_flag(ALLOW_INF_AND_NAN) &&
-        (*cur == 'i' || *cur == 'I' || *cur == 'N')) {
-        val++;
-        ctn_len++;
-        if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end;
-        goto fail_character;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_begin;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_val_end:
-    if (byte_match_2(cur, ",\n")) {
-        cur += 2;
-        goto obj_key_begin;
-    }
-    if (likely(*cur == ',')) {
-        cur++;
-        goto obj_key_begin;
-    }
-    if (likely(*cur == '}')) {
-        cur++;
-        goto obj_end;
-    }
-    if (char_is_space(*cur)) {
-        while (char_is_space(*++cur));
-        goto obj_val_end;
-    }
-    if (has_read_flag(ALLOW_COMMENTS)) {
-        if (skip_spaces_and_comments(&cur)) goto obj_val_end;
-        if (byte_match_2(cur, "/*")) goto fail_comment;
-    }
-    goto fail_character;
-
-obj_end:
-    /* pop container */
-    ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
-    /* point to the next value */
-    ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val);
-    ctn->tag = (ctn_len << (YYJSON_TAG_BIT - 1)) | YYJSON_TYPE_OBJ;
-    if (unlikely(ctn == ctn_parent)) goto doc_end;
-    ctn = ctn_parent;
-    ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT);
-    if (*cur == '\n') cur++;
-    if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) {
-        goto obj_val_end;
-    } else {
-        goto arr_val_end;
-    }
-
-doc_end:
-    /* check invalid contents after json document */
-    if (unlikely(cur < end) && !has_read_flag(STOP_WHEN_DONE)) {
-        if (has_read_flag(ALLOW_COMMENTS)) {
-            skip_spaces_and_comments(&cur);
-            if (byte_match_2(cur, "/*")) goto fail_comment;
-        } else {
-            while (char_is_space(*cur)) cur++;
-        }
-        if (unlikely(cur < end)) goto fail_garbage;
-    }
-
-    if (pre && *pre) **pre = '\0';
-    doc = (yyjson_doc *)val_hdr;
-    doc->root = val_hdr + hdr_len;
-    doc->alc = alc;
-    doc->dat_read = (usize)(cur - hdr);
-    doc->val_read = (usize)((val - val_hdr)) - hdr_len + 1;
-    doc->str_pool = has_read_flag(INSITU) ? NULL : (char *)hdr;
-    return doc;
-
-fail_string:
-    return_err(cur, INVALID_STRING, msg);
-fail_number:
-    return_err(cur, INVALID_NUMBER, msg);
-fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_trailing_comma:
-    return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
-fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
-
-#undef val_incr
-#undef return_err
-}
-
-
-
-/*==============================================================================
- * JSON Reader Entrance
- *============================================================================*/
-
-yyjson_doc *yyjson_read_opts(char *dat,
-                             usize len,
-                             yyjson_read_flag flg,
-                             const yyjson_alc *alc_ptr,
-                             yyjson_read_err *err) {
-
-#define return_err(_pos, _code, _msg) do { \
-    err->pos = (usize)(_pos); \
-    err->msg = _msg; \
-    err->code = YYJSON_READ_ERROR_##_code; \
-    if (!has_read_flag(INSITU) && hdr) alc.free(alc.ctx, (void *)hdr); \
-    return NULL; \
-} while (false)
-
-    yyjson_read_err dummy_err;
-    yyjson_alc alc;
-    yyjson_doc *doc;
-    u8 *hdr = NULL, *end, *cur;
-
-    /* validate input parameters */
-    if (!err) err = &dummy_err;
-    if (likely(!alc_ptr)) {
-        alc = YYJSON_DEFAULT_ALC;
-    } else {
-        alc = *alc_ptr;
-    }
-    if (unlikely(!dat)) {
-        return_err(0, INVALID_PARAMETER, "input data is NULL");
-    }
-    if (unlikely(!len)) {
-        return_err(0, INVALID_PARAMETER, "input length is 0");
-    }
-
-    /* add 4-byte zero padding for input data if necessary */
-    if (has_read_flag(INSITU)) {
-        hdr = (u8 *)dat;
-        end = (u8 *)dat + len;
-        cur = (u8 *)dat;
-    } else {
-        if (unlikely(len >= USIZE_MAX - YYJSON_PADDING_SIZE)) {
-            return_err(0, MEMORY_ALLOCATION, "memory allocation failed");
-        }
-        hdr = (u8 *)alc.malloc(alc.ctx, len + YYJSON_PADDING_SIZE);
-        if (unlikely(!hdr)) {
-            return_err(0, MEMORY_ALLOCATION, "memory allocation failed");
-        }
-        end = hdr + len;
-        cur = hdr;
-        memcpy(hdr, dat, len);
-        memset(end, 0, YYJSON_PADDING_SIZE);
-    }
-
-    /* skip empty contents before json document */
-    if (unlikely(char_is_space_or_comment(*cur))) {
-        if (has_read_flag(ALLOW_COMMENTS)) {
-            if (!skip_spaces_and_comments(&cur)) {
-                return_err(cur - hdr, INVALID_COMMENT,
-                           "unclosed multiline comment");
-            }
-        } else {
-            if (likely(char_is_space(*cur))) {
-                while (char_is_space(*++cur));
-            }
-        }
-        if (unlikely(cur >= end)) {
-            return_err(0, EMPTY_CONTENT, "input data is empty");
-        }
-    }
-
-    /* read json document */
-    if (likely(char_is_container(*cur))) {
-        if (char_is_space(cur[1]) && char_is_space(cur[2])) {
-            doc = read_root_pretty(hdr, cur, end, alc, flg, err);
-        } else {
-            doc = read_root_minify(hdr, cur, end, alc, flg, err);
-        }
-    } else {
-        doc = read_root_single(hdr, cur, end, alc, flg, err);
-    }
-
-    /* check result */
-    if (likely(doc)) {
-        memset(err, 0, sizeof(yyjson_read_err));
-    } else {
-        /* RFC 8259: JSON text MUST be encoded using UTF-8 */
-        if (err->pos == 0 && err->code != YYJSON_READ_ERROR_MEMORY_ALLOCATION) {
-            if ((hdr[0] == 0xEF && hdr[1] == 0xBB && hdr[2] == 0xBF)) {
-                err->msg = "byte order mark (BOM) is not supported";
-            } else if (len >= 4 &&
-                       ((hdr[0] == 0x00 && hdr[1] == 0x00 &&
-                         hdr[2] == 0xFE && hdr[3] == 0xFF) ||
-                        (hdr[0] == 0xFF && hdr[1] == 0xFE &&
-                         hdr[2] == 0x00 && hdr[3] == 0x00))) {
-                err->msg = "UTF-32 encoding is not supported";
-            } else if (len >= 2 &&
-                       ((hdr[0] == 0xFE && hdr[1] == 0xFF) ||
-                        (hdr[0] == 0xFF && hdr[1] == 0xFE))) {
-                err->msg = "UTF-16 encoding is not supported";
-            }
-        }
-        if (!has_read_flag(INSITU)) alc.free(alc.ctx, (void *)hdr);
-    }
-    return doc;
-
-#undef return_err
-}
-
-yyjson_doc *yyjson_read_file(const char *path,
-                             yyjson_read_flag flg,
-                             const yyjson_alc *alc_ptr,
-                             yyjson_read_err *err) {
-#define return_err(_code, _msg) do { \
-    err->pos = 0; \
-    err->msg = _msg; \
-    err->code = YYJSON_READ_ERROR_##_code; \
-    return NULL; \
-} while (false)
-
-    yyjson_read_err dummy_err;
-    yyjson_doc *doc;
-    FILE *file;
-
-    if (!err) err = &dummy_err;
-    if (unlikely(!path)) return_err(INVALID_PARAMETER, "input path is NULL");
-
-    file = fopen_readonly(path);
-    if (unlikely(!file)) return_err(FILE_OPEN, "file opening failed");
-
-    doc = yyjson_read_fp(file, flg, alc_ptr, err);
-    fclose(file);
-    return doc;
-
-#undef return_err
-}
-
-yyjson_doc *yyjson_read_fp(FILE *file,
-                           yyjson_read_flag flg,
-                           const yyjson_alc *alc_ptr,
-                           yyjson_read_err *err) {
-#define return_err(_code, _msg) do { \
-    err->pos = 0; \
-    err->msg = _msg; \
-    err->code = YYJSON_READ_ERROR_##_code; \
-    if (buf) alc.free(alc.ctx, buf); \
-    return NULL; \
-} while (false)
-
-    yyjson_read_err dummy_err;
-    yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
-    yyjson_doc *doc;
-
-    long file_size = 0, file_pos;
-    void *buf = NULL;
-    usize buf_size = 0;
-
-    /* validate input parameters */
-    if (!err) err = &dummy_err;
-    if (unlikely(!file)) return_err(INVALID_PARAMETER, "input file is NULL");
-
-    /* get current position */
-    file_pos = ftell(file);
-    if (file_pos != -1) {
-        /* get total file size, may fail */
-        if (fseek(file, 0, SEEK_END) == 0) file_size = ftell(file);
-        /* reset to original position, may fail */
-        if (fseek(file, file_pos, SEEK_SET) != 0) file_size = 0;
-        /* get file size from current postion to end */
-        if (file_size > 0) file_size -= file_pos;
-    }
-
-    /* read file */
-    if (file_size > 0) {
-        /* read the entire file in one call */
-        buf_size = (usize)file_size + YYJSON_PADDING_SIZE;
-        buf = alc.malloc(alc.ctx, buf_size);
-        if (buf == NULL) {
-            return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-        }
-        if (fread_safe(buf, (usize)file_size, file) != (usize)file_size) {
-            return_err(FILE_READ, "file reading failed");
-        }
-    } else {
-        /* failed to get file size, read it as a stream */
-        usize chunk_min = (usize)64;
-        usize chunk_max = (usize)512 * 1024 * 1024;
-        usize chunk_now = chunk_min;
-        usize read_size;
-        void *tmp;
-
-        buf_size = YYJSON_PADDING_SIZE;
-        while (true) {
-            if (buf_size + chunk_now < buf_size) { /* overflow */
-                return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-            }
-            buf_size += chunk_now;
-            if (!buf) {
-                buf = alc.malloc(alc.ctx, buf_size);
-                if (!buf) return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-            } else {
-                tmp = alc.realloc(alc.ctx, buf, buf_size - chunk_now, buf_size);
-                if (!tmp) return_err(MEMORY_ALLOCATION, "fail to alloc memory");
-                buf = tmp;
-            }
-            tmp = ((u8 *)buf) + buf_size - YYJSON_PADDING_SIZE - chunk_now;
-            read_size = fread_safe(tmp, chunk_now, file);
-            file_size += (long)read_size;
-            if (read_size != chunk_now) break;
-
-            chunk_now *= 2;
-            if (chunk_now > chunk_max) chunk_now = chunk_max;
-        }
-    }
-
-    /* read JSON */
-    memset((u8 *)buf + file_size, 0, YYJSON_PADDING_SIZE);
-    flg |= YYJSON_READ_INSITU;
-    doc = yyjson_read_opts((char *)buf, (usize)file_size, flg, &alc, err);
-    if (doc) {
-        doc->str_pool = (char *)buf;
-        return doc;
-    } else {
-        alc.free(alc.ctx, buf);
-        return NULL;
-    }
-
-#undef return_err
-}
-
-const char *yyjson_read_number(const char *dat,
-                               yyjson_val *val,
-                               yyjson_read_flag flg,
-                               const yyjson_alc *alc,
-                               yyjson_read_err *err) {
-#define return_err(_pos, _code, _msg) do { \
-    err->pos = _pos > hdr ? (usize)(_pos - hdr) : 0; \
-    err->msg = _msg; \
-    err->code = YYJSON_READ_ERROR_##_code; \
-    return NULL; \
-} while (false)
-
-    u8 *hdr = constcast(u8 *)dat, *cur = hdr;
-    bool raw; /* read number as raw */
-    u8 *raw_end; /* raw end for null-terminator */
-    u8 **pre; /* previous raw end pointer */
-    const char *msg;
-    yyjson_read_err dummy_err;
-
-#if !YYJSON_HAS_IEEE_754 || YYJSON_DISABLE_FAST_FP_CONV
-    u8 buf[128];
-    usize dat_len;
-#endif
-
-    if (!err) err = &dummy_err;
-    if (unlikely(!dat)) {
-        return_err(cur, INVALID_PARAMETER, "input data is NULL");
-    }
-    if (unlikely(!val)) {
-        return_err(cur, INVALID_PARAMETER, "output value is NULL");
-    }
-
-#if !YYJSON_HAS_IEEE_754 || YYJSON_DISABLE_FAST_FP_CONV
-    if (!alc) alc = &YYJSON_DEFAULT_ALC;
-    dat_len = strlen(dat);
-    if (dat_len < sizeof(buf)) {
-        memcpy(buf, dat, dat_len + 1);
-        hdr = buf;
-        cur = hdr;
-    } else {
-        hdr = (u8 *)alc->malloc(alc->ctx, dat_len + 1);
-        cur = hdr;
-        if (unlikely(!hdr)) {
-            return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-        }
-        memcpy(hdr, dat, dat_len + 1);
-    }
-    hdr[dat_len] = 0;
-#endif
-
-    raw = (flg & (YYJSON_READ_NUMBER_AS_RAW | YYJSON_READ_BIGNUM_AS_RAW)) != 0;
-    raw_end = NULL;
-    pre = raw ? &raw_end : NULL;
-
-#if !YYJSON_HAS_IEEE_754 || YYJSON_DISABLE_FAST_FP_CONV
-    if (!read_number(&cur, pre, flg, val, &msg)) {
-        if (dat_len >= sizeof(buf)) alc->free(alc->ctx, hdr);
-        return_err(cur, INVALID_NUMBER, msg);
-    }
-    if (dat_len >= sizeof(buf)) alc->free(alc->ctx, hdr);
-    if (yyjson_is_raw(val)) val->uni.str = dat;
-    return dat + (cur - hdr);
-#else
-    if (!read_number(&cur, pre, flg, val, &msg)) {
-        return_err(cur, INVALID_NUMBER, msg);
-    }
-    return (const char *)cur;
-#endif
-
-#undef return_err
-}
-
-#endif /* YYJSON_DISABLE_READER */
-
-
-
-#if !YYJSON_DISABLE_WRITER
-
-/*==============================================================================
- * Integer Writer
- *
- * The maximum value of uint32_t is 4294967295 (10 digits),
- * these digits are named as 'aabbccddee' here.
- *
- * Although most compilers may convert the "division by constant value" into
- * "multiply and shift", manual conversion can still help some compilers
- * generate fewer and better instructions.
- *
- * Reference:
- * Division by Invariant Integers using Multiplication, 1994.
- * https://gmplib.org/~tege/divcnst-pldi94.pdf
- * Improved division by invariant integers, 2011.
- * https://gmplib.org/~tege/division-paper.pdf
- *============================================================================*/
-
-/** Digit table from 00 to 99. */
-yyjson_align(2)
-static const char digit_table[200] = {
-    '0', '0', '0', '1', '0', '2', '0', '3', '0', '4',
-    '0', '5', '0', '6', '0', '7', '0', '8', '0', '9',
-    '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',
-    '1', '5', '1', '6', '1', '7', '1', '8', '1', '9',
-    '2', '0', '2', '1', '2', '2', '2', '3', '2', '4',
-    '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',
-    '3', '0', '3', '1', '3', '2', '3', '3', '3', '4',
-    '3', '5', '3', '6', '3', '7', '3', '8', '3', '9',
-    '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
-    '4', '5', '4', '6', '4', '7', '4', '8', '4', '9',
-    '5', '0', '5', '1', '5', '2', '5', '3', '5', '4',
-    '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',
-    '6', '0', '6', '1', '6', '2', '6', '3', '6', '4',
-    '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
-    '7', '0', '7', '1', '7', '2', '7', '3', '7', '4',
-    '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',
-    '8', '0', '8', '1', '8', '2', '8', '3', '8', '4',
-    '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
-    '9', '0', '9', '1', '9', '2', '9', '3', '9', '4',
-    '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'
-};
-
-static_inline u8 *write_u32_len_8(u32 val, u8 *buf) {
-    u32 aa, bb, cc, dd, aabb, ccdd;                 /* 8 digits: aabbccdd */
-    aabb = (u32)(((u64)val * 109951163) >> 40);     /* (val / 10000) */
-    ccdd = val - aabb * 10000;                      /* (val % 10000) */
-    aa = (aabb * 5243) >> 19;                       /* (aabb / 100) */
-    cc = (ccdd * 5243) >> 19;                       /* (ccdd / 100) */
-    bb = aabb - aa * 100;                           /* (aabb % 100) */
-    dd = ccdd - cc * 100;                           /* (ccdd % 100) */
-    byte_copy_2(buf + 0, digit_table + aa * 2);
-    byte_copy_2(buf + 2, digit_table + bb * 2);
-    byte_copy_2(buf + 4, digit_table + cc * 2);
-    byte_copy_2(buf + 6, digit_table + dd * 2);
-    return buf + 8;
-}
-
-static_inline u8 *write_u32_len_4(u32 val, u8 *buf) {
-    u32 aa, bb;                                     /* 4 digits: aabb */
-    aa = (val * 5243) >> 19;                        /* (val / 100) */
-    bb = val - aa * 100;                            /* (val % 100) */
-    byte_copy_2(buf + 0, digit_table + aa * 2);
-    byte_copy_2(buf + 2, digit_table + bb * 2);
-    return buf + 4;
-}
-
-static_inline u8 *write_u32_len_1_8(u32 val, u8 *buf) {
-    u32 aa, bb, cc, dd, aabb, bbcc, ccdd, lz;
-
-    if (val < 100) {                                /* 1-2 digits: aa */
-        lz = val < 10;                              /* leading zero: 0 or 1 */
-        byte_copy_2(buf + 0, digit_table + val * 2 + lz);
-        buf -= lz;
-        return buf + 2;
-
-    } else if (val < 10000) {                       /* 3-4 digits: aabb */
-        aa = (val * 5243) >> 19;                    /* (val / 100) */
-        bb = val - aa * 100;                        /* (val % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        byte_copy_2(buf + 0, digit_table + aa * 2 + lz);
-        buf -= lz;
-        byte_copy_2(buf + 2, digit_table + bb * 2);
-        return buf + 4;
-
-    } else if (val < 1000000) {                     /* 5-6 digits: aabbcc */
-        aa = (u32)(((u64)val * 429497) >> 32);      /* (val / 10000) */
-        bbcc = val - aa * 10000;                    /* (val % 10000) */
-        bb = (bbcc * 5243) >> 19;                   /* (bbcc / 100) */
-        cc = bbcc - bb * 100;                       /* (bbcc % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        byte_copy_2(buf + 0, digit_table + aa * 2 + lz);
-        buf -= lz;
-        byte_copy_2(buf + 2, digit_table + bb * 2);
-        byte_copy_2(buf + 4, digit_table + cc * 2);
-        return buf + 6;
-
-    } else {                                        /* 7-8 digits: aabbccdd */
-        aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */
-        ccdd = val - aabb * 10000;                  /* (val % 10000) */
-        aa = (aabb * 5243) >> 19;                   /* (aabb / 100) */
-        cc = (ccdd * 5243) >> 19;                   /* (ccdd / 100) */
-        bb = aabb - aa * 100;                       /* (aabb % 100) */
-        dd = ccdd - cc * 100;                       /* (ccdd % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        byte_copy_2(buf + 0, digit_table + aa * 2 + lz);
-        buf -= lz;
-        byte_copy_2(buf + 2, digit_table + bb * 2);
-        byte_copy_2(buf + 4, digit_table + cc * 2);
-        byte_copy_2(buf + 6, digit_table + dd * 2);
-        return buf + 8;
-    }
-}
-
-static_inline u8 *write_u64_len_5_8(u32 val, u8 *buf) {
-    u32 aa, bb, cc, dd, aabb, bbcc, ccdd, lz;
-
-    if (val < 1000000) {                            /* 5-6 digits: aabbcc */
-        aa = (u32)(((u64)val * 429497) >> 32);      /* (val / 10000) */
-        bbcc = val - aa * 10000;                    /* (val % 10000) */
-        bb = (bbcc * 5243) >> 19;                   /* (bbcc / 100) */
-        cc = bbcc - bb * 100;                       /* (bbcc % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        byte_copy_2(buf + 0, digit_table + aa * 2 + lz);
-        buf -= lz;
-        byte_copy_2(buf + 2, digit_table + bb * 2);
-        byte_copy_2(buf + 4, digit_table + cc * 2);
-        return buf + 6;
-
-    } else {                                        /* 7-8 digits: aabbccdd */
-        aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */
-        ccdd = val - aabb * 10000;                  /* (val % 10000) */
-        aa = (aabb * 5243) >> 19;                   /* (aabb / 100) */
-        cc = (ccdd * 5243) >> 19;                   /* (ccdd / 100) */
-        bb = aabb - aa * 100;                       /* (aabb % 100) */
-        dd = ccdd - cc * 100;                       /* (ccdd % 100) */
-        lz = aa < 10;                               /* leading zero: 0 or 1 */
-        byte_copy_2(buf + 0, digit_table + aa * 2 + lz);
-        buf -= lz;
-        byte_copy_2(buf + 2, digit_table + bb * 2);
-        byte_copy_2(buf + 4, digit_table + cc * 2);
-        byte_copy_2(buf + 6, digit_table + dd * 2);
-        return buf + 8;
-    }
-}
-
-static_inline u8 *write_u64(u64 val, u8 *buf) {
-    u64 tmp, hgh;
-    u32 mid, low;
-
-    if (val < 100000000) {                          /* 1-8 digits */
-        buf = write_u32_len_1_8((u32)val, buf);
-        return buf;
-
-    } else if (val < (u64)100000000 * 100000000) {  /* 9-16 digits */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        buf = write_u32_len_1_8((u32)hgh, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-
-    } else {                                        /* 17-20 digits */
-        tmp = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - tmp * 100000000);         /* (val % 100000000) */
-        hgh = (u32)(tmp / 10000);                   /* (tmp / 10000) */
-        mid = (u32)(tmp - hgh * 10000);             /* (tmp % 10000) */
-        buf = write_u64_len_5_8((u32)hgh, buf);
-        buf = write_u32_len_4(mid, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    }
-}
-
-
-
-/*==============================================================================
- * Number Writer
- *============================================================================*/
-
-#if YYJSON_HAS_IEEE_754 && !YYJSON_DISABLE_FAST_FP_CONV  /* FP_WRITER */
-
-/** Trailing zero count table for number 0 to 99.
-    (generate with misc/make_tables.c) */
-static const u8 dec_trailing_zero_table[] = {
-    2, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-/** Write an unsigned integer with a length of 1 to 16. */
-static_inline u8 *write_u64_len_1_to_16(u64 val, u8 *buf) {
-    u64 hgh;
-    u32 low;
-    if (val < 100000000) {                          /* 1-8 digits */
-        buf = write_u32_len_1_8((u32)val, buf);
-        return buf;
-    } else {                                        /* 9-16 digits */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        buf = write_u32_len_1_8((u32)hgh, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    }
-}
-
-/** Write an unsigned integer with a length of 1 to 17. */
-static_inline u8 *write_u64_len_1_to_17(u64 val, u8 *buf) {
-    u64 hgh;
-    u32 mid, low, one;
-    if (val >= (u64)100000000 * 10000000) {         /* len: 16 to 17 */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        one = (u32)(hgh / 100000000);               /* (hgh / 100000000) */
-        mid = (u32)(hgh - (u64)one * 100000000);    /* (hgh % 100000000) */
-        *buf = (u8)((u8)one + (u8)'0');
-        buf += one > 0;
-        buf = write_u32_len_8(mid, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    } else if (val >= (u64)100000000){              /* len: 9 to 15 */
-        hgh = val / 100000000;                      /* (val / 100000000) */
-        low = (u32)(val - hgh * 100000000);         /* (val % 100000000) */
-        buf = write_u32_len_1_8((u32)hgh, buf);
-        buf = write_u32_len_8(low, buf);
-        return buf;
-    } else { /* len: 1 to 8 */
-        buf = write_u32_len_1_8((u32)val, buf);
-        return buf;
-    }
-}
-
-/**
- Write an unsigned integer with a length of 15 to 17 with trailing zero trimmed.
- These digits are named as "aabbccddeeffgghhii" here.
- For example, input 1234567890123000, output "1234567890123".
- */
-static_inline u8 *write_u64_len_15_to_17_trim(u8 *buf, u64 sig) {
-    bool lz;                                        /* leading zero */
-    u32 tz1, tz2, tz;                               /* trailing zero */
-
-    u32 abbccddee = (u32)(sig / 100000000);
-    u32 ffgghhii = (u32)(sig - (u64)abbccddee * 100000000);
-    u32 abbcc = abbccddee / 10000;                  /* (abbccddee / 10000) */
-    u32 ddee = abbccddee - abbcc * 10000;           /* (abbccddee % 10000) */
-    u32 abb = (u32)(((u64)abbcc * 167773) >> 24);   /* (abbcc / 100) */
-    u32 a = (abb * 41) >> 12;                       /* (abb / 100) */
-    u32 bb = abb - a * 100;                         /* (abb % 100) */
-    u32 cc = abbcc - abb * 100;                     /* (abbcc % 100) */
-
-    /* write abbcc */
-    buf[0] = (u8)(a + '0');
-    buf += a > 0;
-    lz = bb < 10 && a == 0;
-    byte_copy_2(buf + 0, digit_table + bb * 2 + lz);
-    buf -= lz;
-    byte_copy_2(buf + 2, digit_table + cc * 2);
-
-    if (ffgghhii) {
-        u32 dd = (ddee * 5243) >> 19;               /* (ddee / 100) */
-        u32 ee = ddee - dd * 100;                   /* (ddee % 100) */
-        u32 ffgg = (u32)(((u64)ffgghhii * 109951163) >> 40); /* (val / 10000) */
-        u32 hhii = ffgghhii - ffgg * 10000;         /* (val % 10000) */
-        u32 ff = (ffgg * 5243) >> 19;               /* (aabb / 100) */
-        u32 gg = ffgg - ff * 100;                   /* (aabb % 100) */
-        byte_copy_2(buf + 4, digit_table + dd * 2);
-        byte_copy_2(buf + 6, digit_table + ee * 2);
-        byte_copy_2(buf + 8, digit_table + ff * 2);
-        byte_copy_2(buf + 10, digit_table + gg * 2);
-        if (hhii) {
-            u32 hh = (hhii * 5243) >> 19;           /* (ccdd / 100) */
-            u32 ii = hhii - hh * 100;               /* (ccdd % 100) */
-            byte_copy_2(buf + 12, digit_table + hh * 2);
-            byte_copy_2(buf + 14, digit_table + ii * 2);
-            tz1 = dec_trailing_zero_table[hh];
-            tz2 = dec_trailing_zero_table[ii];
-            tz = ii ? tz2 : (tz1 + 2);
-            buf += 16 - tz;
-            return buf;
-        } else {
-            tz1 = dec_trailing_zero_table[ff];
-            tz2 = dec_trailing_zero_table[gg];
-            tz = gg ? tz2 : (tz1 + 2);
-            buf += 12 - tz;
-            return buf;
-        }
-    } else {
-        if (ddee) {
-            u32 dd = (ddee * 5243) >> 19;           /* (ddee / 100) */
-            u32 ee = ddee - dd * 100;               /* (ddee % 100) */
-            byte_copy_2(buf + 4, digit_table + dd * 2);
-            byte_copy_2(buf + 6, digit_table + ee * 2);
-            tz1 = dec_trailing_zero_table[dd];
-            tz2 = dec_trailing_zero_table[ee];
-            tz = ee ? tz2 : (tz1 + 2);
-            buf += 8 - tz;
-            return buf;
-        } else {
-            tz1 = dec_trailing_zero_table[bb];
-            tz2 = dec_trailing_zero_table[cc];
-            tz = cc ? tz2 : (tz1 + tz2);
-            buf += 4 - tz;
-            return buf;
-        }
-    }
-}
-
-/** Write a signed integer in the range -324 to 308. */
-static_inline u8 *write_f64_exp(i32 exp, u8 *buf) {
-    buf[0] = '-';
-    buf += exp < 0;
-    exp = exp < 0 ? -exp : exp;
-    if (exp < 100) {
-        u32 lz = exp < 10;
-        byte_copy_2(buf + 0, digit_table + (u32)exp * 2 + lz);
-        return buf + 2 - lz;
-    } else {
-        u32 hi = ((u32)exp * 656) >> 16;            /* exp / 100 */
-        u32 lo = (u32)exp - hi * 100;               /* exp % 100 */
-        buf[0] = (u8)((u8)hi + (u8)'0');
-        byte_copy_2(buf + 1, digit_table + lo * 2);
-        return buf + 3;
-    }
-}
-
-/** Multiplies 128-bit integer and returns highest 64-bit rounded value. */
-static_inline u64 round_to_odd(u64 hi, u64 lo, u64 cp) {
-    u64 x_hi, x_lo, y_hi, y_lo;
-    u128_mul(cp, lo, &x_hi, &x_lo);
-    u128_mul_add(cp, hi, x_hi, &y_hi, &y_lo);
-    return y_hi | (y_lo > 1);
-}
-
-/**
- Convert double number from binary to decimal.
- The output significand is shortest decimal but may have trailing zeros.
-
- This function use the Schubfach algorithm:
- Raffaello Giulietti, The Schubfach way to render doubles (5th version), 2022.
- https://drive.google.com/file/d/1gp5xv4CAa78SVgCeWfGqqI4FfYYYuNFb
- https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-November/083536.html
- https://github.com/openjdk/jdk/pull/3402 (Java implementation)
- https://github.com/abolz/Drachennest (C++ implementation)
-
- See also:
- Dragonbox: A New Floating-Point Binary-to-Decimal Conversion Algorithm, 2022.
- https://github.com/jk-jeon/dragonbox/blob/master/other_files/Dragonbox.pdf
- https://github.com/jk-jeon/dragonbox
-
- @param sig_raw The raw value of significand in IEEE 754 format.
- @param exp_raw The raw value of exponent in IEEE 754 format.
- @param sig_bin The decoded value of significand in binary.
- @param exp_bin The decoded value of exponent in binary.
- @param sig_dec The output value of significand in decimal.
- @param exp_dec The output value of exponent in decimal.
- @warning The input double number should not be 0, inf, nan.
- */
-static_inline void f64_bin_to_dec(u64 sig_raw, u32 exp_raw,
-                                  u64 sig_bin, i32 exp_bin,
-                                  u64 *sig_dec, i32 *exp_dec) {
-
-    bool is_even, regular_spacing, u_inside, w_inside, round_up;
-    u64 s, sp, cb, cbl, cbr, vb, vbl, vbr, pow10hi, pow10lo, upper, lower, mid;
-    i32 k, h, exp10;
-
-    is_even = !(sig_bin & 1);
-    regular_spacing = (sig_raw == 0 && exp_raw > 1);
-
-    cbl = 4 * sig_bin - 2 + regular_spacing;
-    cb  = 4 * sig_bin;
-    cbr = 4 * sig_bin + 2;
-
-    /* exp_bin: [-1074, 971]                                                  */
-    /* k = regular_spacing ? floor(log10(pow(2, exp_bin)))                    */
-    /*                     : floor(log10(pow(2, exp_bin) * 3.0 / 4.0))        */
-    /*   = regular_spacing ? floor(exp_bin * log10(2))                        */
-    /*                     : floor(exp_bin * log10(2) + log10(3.0 / 4.0))     */
-    k = (i32)(exp_bin * 315653 - (regular_spacing ? 131237 : 0)) >> 20;
-
-    /* k: [-324, 292]                                                         */
-    /* h = exp_bin + floor(log2(pow(10, e)))                                  */
-    /*   = exp_bin + floor(log2(10) * e)                                      */
-    exp10 = -k;
-    h = exp_bin + ((exp10 * 217707) >> 16) + 1;
-
-    pow10_table_get_sig(exp10, &pow10hi, &pow10lo);
-    pow10lo += (exp10 < POW10_SIG_TABLE_MIN_EXACT_EXP ||
-                exp10 > POW10_SIG_TABLE_MAX_EXACT_EXP);
-    vbl = round_to_odd(pow10hi, pow10lo, cbl << h);
-    vb  = round_to_odd(pow10hi, pow10lo, cb  << h);
-    vbr = round_to_odd(pow10hi, pow10lo, cbr << h);
-
-    lower = vbl + !is_even;
-    upper = vbr - !is_even;
-
-    s = vb / 4;
-    if (s >= 10) {
-        sp = s / 10;
-        u_inside = (lower <= 40 * sp);
-        w_inside = (upper >= 40 * sp + 40);
-        if (u_inside != w_inside) {
-            *sig_dec = sp + w_inside;
-            *exp_dec = k + 1;
-            return;
-        }
-    }
-
-    u_inside = (lower <= 4 * s);
-    w_inside = (upper >= 4 * s + 4);
-
-    mid = 4 * s + 2;
-    round_up = (vb > mid) || (vb == mid && (s & 1) != 0);
-
-    *sig_dec = s + ((u_inside != w_inside) ? w_inside : round_up);
-    *exp_dec = k;
-}
-
-/**
- Write a double number (requires 32 bytes buffer).
-
- We follows the ECMAScript specification to print floating point numbers,
- but with the following changes:
- 1. Keep the negative sign of 0.0 to preserve input information.
- 2. Keep decimal point to indicate the number is floating point.
- 3. Remove positive sign of exponent part.
- */
-static_inline u8 *write_f64_raw(u8 *buf, u64 raw, yyjson_write_flag flg) {
-    u64 sig_bin, sig_dec, sig_raw;
-    i32 exp_bin, exp_dec, sig_len, dot_pos, i, max;
-    u32 exp_raw, hi, lo;
-    u8 *hdr, *num_hdr, *num_end, *dot_end;
-    bool sign;
-
-    /* decode raw bytes from IEEE-754 double format. */
-    sign = (bool)(raw >> (F64_BITS - 1));
-    sig_raw = raw & F64_SIG_MASK;
-    exp_raw = (u32)((raw & F64_EXP_MASK) >> F64_SIG_BITS);
-
-    /* return inf and nan */
-    if (unlikely(exp_raw == ((u32)1 << F64_EXP_BITS) - 1)) {
-        if (has_write_flag(INF_AND_NAN_AS_NULL)) {
-            byte_copy_4(buf, "null");
-            return buf + 4;
-        }
-        else if (has_write_flag(ALLOW_INF_AND_NAN)) {
-            if (sig_raw == 0) {
-                buf[0] = '-';
-                buf += sign;
-                byte_copy_8(buf, "Infinity");
-                buf += 8;
-                return buf;
-            } else {
-                byte_copy_4(buf, "NaN");
-                return buf + 3;
-            }
-        }
-        return NULL;
-    }
-
-    /* add sign for all finite double value, including 0.0 and inf */
-    buf[0] = '-';
-    buf += sign;
-    hdr = buf;
-
-    /* return zero */
-    if ((raw << 1) == 0) {
-        byte_copy_4(buf, "0.0");
-        buf += 3;
-        return buf;
-    }
-
-    if (likely(exp_raw != 0)) {
-        /* normal number */
-        sig_bin = sig_raw | ((u64)1 << F64_SIG_BITS);
-        exp_bin = (i32)exp_raw - F64_EXP_BIAS - F64_SIG_BITS;
-
-        /* fast path for small integer number without fraction */
-        if (-F64_SIG_BITS <= exp_bin && exp_bin <= 0) {
-            if (u64_tz_bits(sig_bin) >= (u32)-exp_bin) {
-                /* number is integer in range 1 to 0x1FFFFFFFFFFFFF */
-                sig_dec = sig_bin >> -exp_bin;
-                buf = write_u64_len_1_to_16(sig_dec, buf);
-                byte_copy_2(buf, ".0");
-                buf += 2;
-                return buf;
-            }
-        }
-
-        /* binary to decimal */
-        f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec);
-
-        /* the sig length is 15 to 17 */
-        sig_len = 17;
-        sig_len -= (sig_dec < (u64)100000000 * 100000000);
-        sig_len -= (sig_dec < (u64)100000000 * 10000000);
-
-        /* the decimal point position relative to the first digit */
-        dot_pos = sig_len + exp_dec;
-
-        if (-6 < dot_pos && dot_pos <= 21) {
-            /* no need to write exponent part */
-            if (dot_pos <= 0) {
-                /* dot before first digit */
-                /* such as 0.1234, 0.000001234 */
-                num_hdr = hdr + (2 - dot_pos);
-                num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-                hdr[0] = '0';
-                hdr[1] = '.';
-                hdr += 2;
-                max = -dot_pos;
-                for (i = 0; i < max; i++) hdr[i] = '0';
-                return num_end;
-            } else {
-                /* dot after first digit */
-                /* such as 1.234, 1234.0, 123400000000000000000.0 */
-                memset(hdr +  0, '0', 8);
-                memset(hdr +  8, '0', 8);
-                memset(hdr + 16, '0', 8);
-                num_hdr = hdr + 1;
-                num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-                for (i = 0; i < dot_pos; i++) hdr[i] = hdr[i + 1];
-                hdr[dot_pos] = '.';
-                dot_end = hdr + dot_pos + 2;
-                return dot_end < num_end ? num_end : dot_end;
-            }
-        } else {
-            /* write with scientific notation */
-            /* such as 1.234e56 */
-            u8 *end = write_u64_len_15_to_17_trim(buf + 1, sig_dec);
-            end -= (end == buf + 2); /* remove '.0', e.g. 2.0e34 -> 2e34 */
-            exp_dec += sig_len - 1;
-            hdr[0] = hdr[1];
-            hdr[1] = '.';
-            end[0] = 'e';
-            buf = write_f64_exp(exp_dec, end + 1);
-            return buf;
-        }
-
-    } else {
-        /* subnormal number */
-        sig_bin = sig_raw;
-        exp_bin = 1 - F64_EXP_BIAS - F64_SIG_BITS;
-
-        /* binary to decimal */
-        f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec);
-
-        /* write significand part */
-        buf = write_u64_len_1_to_17(sig_dec, buf + 1);
-        hdr[0] = hdr[1];
-        hdr[1] = '.';
-        do {
-            buf--;
-            exp_dec++;
-        } while (*buf == '0');
-        exp_dec += (i32)(buf - hdr - 2);
-        buf += (*buf != '.');
-        buf[0] = 'e';
-        buf++;
-
-        /* write exponent part */
-        buf[0] = '-';
-        buf++;
-        exp_dec = -exp_dec;
-        hi = ((u32)exp_dec * 656) >> 16; /* exp / 100 */
-        lo = (u32)exp_dec - hi * 100; /* exp % 100 */
-        buf[0] = (u8)((u8)hi + (u8)'0');
-        byte_copy_2(buf + 1, digit_table + lo * 2);
-        buf += 3;
-        return buf;
-    }
-}
-
-#else /* FP_WRITER */
-
-/** Write a double number (requires 32 bytes buffer). */
-static_inline u8 *write_f64_raw(u8 *buf, u64 raw, yyjson_write_flag flg) {
-    /*
-     For IEEE 754, `DBL_DECIMAL_DIG` is 17 for round-trip.
-     For non-IEEE formats, 17 is used to avoid buffer overflow,
-     round-trip is not guaranteed.
-     */
-#if defined(DBL_DECIMAL_DIG) && DBL_DECIMAL_DIG != 17
-    int dig = DBL_DECIMAL_DIG > 17 ? 17 : DBL_DECIMAL_DIG;
-#else
-    int dig = 17;
-#endif
-
-    /*
-     The snprintf() function is locale-dependent. For currently known locales,
-     (en, zh, ja, ko, am, he, hi) use '.' as the decimal point, while other
-     locales use ',' as the decimal point. we need to replace ',' with '.'
-     to avoid the locale setting.
-     */
-    f64 val = f64_from_raw(raw);
-#if YYJSON_MSC_VER >= 1400
-    int len = sprintf_s((char *)buf, 32, "%.*g", dig, val);
-#elif defined(snprintf) || (YYJSON_STDC_VER >= 199901L)
-    int len = snprintf((char *)buf, 32, "%.*g", dig, val);
-#else
-    int len = sprintf((char *)buf, "%.*g", dig, val);
-#endif
-
-    u8 *cur = buf;
-    if (unlikely(len < 1)) return NULL;
-    cur += (*cur == '-');
-    if (unlikely(!digi_is_digit(*cur))) {
-        /* nan, inf, or bad output */
-        if (has_write_flag(INF_AND_NAN_AS_NULL)) {
-            byte_copy_4(buf, "null");
-            return buf + 4;
-        }
-        else if (has_write_flag(ALLOW_INF_AND_NAN)) {
-            if (*cur == 'i') {
-                byte_copy_8(cur, "Infinity");
-                cur += 8;
-                return cur;
-            } else if (*cur == 'n') {
-                byte_copy_4(buf, "NaN");
-                return buf + 3;
-            }
-        }
-        return NULL;
-    } else {
-        /* finite number */
-        int i = 0;
-        bool fp = false;
-        for (; i < len; i++) {
-            if (buf[i] == ',') buf[i] = '.';
-            if (digi_is_fp((u8)buf[i])) fp = true;
-        }
-        if (!fp) {
-            buf[len++] = '.';
-            buf[len++] = '0';
-        }
-    }
-    return buf + len;
-}
-
-#endif /* FP_WRITER */
-
-/** Write a JSON number (requires 32 bytes buffer). */
-static_inline u8 *write_number(u8 *cur, yyjson_val *val,
-                               yyjson_write_flag flg) {
-    if (val->tag & YYJSON_SUBTYPE_REAL) {
-        u64 raw = val->uni.u64;
-        return write_f64_raw(cur, raw, flg);
-    } else {
-        u64 pos = val->uni.u64;
-        u64 neg = ~pos + 1;
-        usize sgn = ((val->tag & YYJSON_SUBTYPE_SINT) > 0) & ((i64)pos < 0);
-        *cur = '-';
-        return write_u64(sgn ? neg : pos, cur + sgn);
-    }
-}
-
-
-
-/*==============================================================================
- * String Writer
- *============================================================================*/
-
-/** Character encode type, if (type > CHAR_ENC_ERR_1) bytes = type / 2; */
-typedef u8 char_enc_type;
-#define CHAR_ENC_CPY_1  0 /* 1-byte UTF-8, copy. */
-#define CHAR_ENC_ERR_1  1 /* 1-byte UTF-8, error. */
-#define CHAR_ENC_ESC_A  2 /* 1-byte ASCII, escaped as '\x'. */
-#define CHAR_ENC_ESC_1  3 /* 1-byte UTF-8, escaped as '\uXXXX'. */
-#define CHAR_ENC_CPY_2  4 /* 2-byte UTF-8, copy. */
-#define CHAR_ENC_ESC_2  5 /* 2-byte UTF-8, escaped as '\uXXXX'. */
-#define CHAR_ENC_CPY_3  6 /* 3-byte UTF-8, copy. */
-#define CHAR_ENC_ESC_3  7 /* 3-byte UTF-8, escaped as '\uXXXX'. */
-#define CHAR_ENC_CPY_4  8 /* 4-byte UTF-8, copy. */
-#define CHAR_ENC_ESC_4  9 /* 4-byte UTF-8, escaped as '\uXXXX\uXXXX'. */
-
-/** Character encode type table: don't escape unicode, don't escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_cpy[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Character encode type table: don't escape unicode, escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_cpy_slash[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Character encode type table: escape unicode, don't escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_esc[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Character encode type table: escape unicode, escape '/'.
-    (generate with misc/make_tables.c) */
-static const char_enc_type enc_table_esc_slash[256] = {
-    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1
-};
-
-/** Escaped hex character table: ["00" "01" "02" ... "FD" "FE" "FF"].
-    (generate with misc/make_tables.c) */
-yyjson_align(2)
-static const u8 esc_hex_char_table[512] = {
-    '0', '0', '0', '1', '0', '2', '0', '3',
-    '0', '4', '0', '5', '0', '6', '0', '7',
-    '0', '8', '0', '9', '0', 'A', '0', 'B',
-    '0', 'C', '0', 'D', '0', 'E', '0', 'F',
-    '1', '0', '1', '1', '1', '2', '1', '3',
-    '1', '4', '1', '5', '1', '6', '1', '7',
-    '1', '8', '1', '9', '1', 'A', '1', 'B',
-    '1', 'C', '1', 'D', '1', 'E', '1', 'F',
-    '2', '0', '2', '1', '2', '2', '2', '3',
-    '2', '4', '2', '5', '2', '6', '2', '7',
-    '2', '8', '2', '9', '2', 'A', '2', 'B',
-    '2', 'C', '2', 'D', '2', 'E', '2', 'F',
-    '3', '0', '3', '1', '3', '2', '3', '3',
-    '3', '4', '3', '5', '3', '6', '3', '7',
-    '3', '8', '3', '9', '3', 'A', '3', 'B',
-    '3', 'C', '3', 'D', '3', 'E', '3', 'F',
-    '4', '0', '4', '1', '4', '2', '4', '3',
-    '4', '4', '4', '5', '4', '6', '4', '7',
-    '4', '8', '4', '9', '4', 'A', '4', 'B',
-    '4', 'C', '4', 'D', '4', 'E', '4', 'F',
-    '5', '0', '5', '1', '5', '2', '5', '3',
-    '5', '4', '5', '5', '5', '6', '5', '7',
-    '5', '8', '5', '9', '5', 'A', '5', 'B',
-    '5', 'C', '5', 'D', '5', 'E', '5', 'F',
-    '6', '0', '6', '1', '6', '2', '6', '3',
-    '6', '4', '6', '5', '6', '6', '6', '7',
-    '6', '8', '6', '9', '6', 'A', '6', 'B',
-    '6', 'C', '6', 'D', '6', 'E', '6', 'F',
-    '7', '0', '7', '1', '7', '2', '7', '3',
-    '7', '4', '7', '5', '7', '6', '7', '7',
-    '7', '8', '7', '9', '7', 'A', '7', 'B',
-    '7', 'C', '7', 'D', '7', 'E', '7', 'F',
-    '8', '0', '8', '1', '8', '2', '8', '3',
-    '8', '4', '8', '5', '8', '6', '8', '7',
-    '8', '8', '8', '9', '8', 'A', '8', 'B',
-    '8', 'C', '8', 'D', '8', 'E', '8', 'F',
-    '9', '0', '9', '1', '9', '2', '9', '3',
-    '9', '4', '9', '5', '9', '6', '9', '7',
-    '9', '8', '9', '9', '9', 'A', '9', 'B',
-    '9', 'C', '9', 'D', '9', 'E', '9', 'F',
-    'A', '0', 'A', '1', 'A', '2', 'A', '3',
-    'A', '4', 'A', '5', 'A', '6', 'A', '7',
-    'A', '8', 'A', '9', 'A', 'A', 'A', 'B',
-    'A', 'C', 'A', 'D', 'A', 'E', 'A', 'F',
-    'B', '0', 'B', '1', 'B', '2', 'B', '3',
-    'B', '4', 'B', '5', 'B', '6', 'B', '7',
-    'B', '8', 'B', '9', 'B', 'A', 'B', 'B',
-    'B', 'C', 'B', 'D', 'B', 'E', 'B', 'F',
-    'C', '0', 'C', '1', 'C', '2', 'C', '3',
-    'C', '4', 'C', '5', 'C', '6', 'C', '7',
-    'C', '8', 'C', '9', 'C', 'A', 'C', 'B',
-    'C', 'C', 'C', 'D', 'C', 'E', 'C', 'F',
-    'D', '0', 'D', '1', 'D', '2', 'D', '3',
-    'D', '4', 'D', '5', 'D', '6', 'D', '7',
-    'D', '8', 'D', '9', 'D', 'A', 'D', 'B',
-    'D', 'C', 'D', 'D', 'D', 'E', 'D', 'F',
-    'E', '0', 'E', '1', 'E', '2', 'E', '3',
-    'E', '4', 'E', '5', 'E', '6', 'E', '7',
-    'E', '8', 'E', '9', 'E', 'A', 'E', 'B',
-    'E', 'C', 'E', 'D', 'E', 'E', 'E', 'F',
-    'F', '0', 'F', '1', 'F', '2', 'F', '3',
-    'F', '4', 'F', '5', 'F', '6', 'F', '7',
-    'F', '8', 'F', '9', 'F', 'A', 'F', 'B',
-    'F', 'C', 'F', 'D', 'F', 'E', 'F', 'F'
-};
-
-/** Escaped single character table. (generate with misc/make_tables.c) */
-yyjson_align(2)
-static const u8 esc_single_char_table[512] = {
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    '\\', 'b', '\\', 't', '\\', 'n', ' ', ' ',
-    '\\', 'f', '\\', 'r', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', '\\', '"', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', '\\', '/',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    '\\', '\\', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '
-};
-
-/** Returns the encode table with options. */
-static_inline const char_enc_type *get_enc_table_with_flag(
-    yyjson_read_flag flg) {
-    if (has_write_flag(ESCAPE_UNICODE)) {
-        if (has_write_flag(ESCAPE_SLASHES)) {
-            return enc_table_esc_slash;
-        } else {
-            return enc_table_esc;
-        }
-    } else {
-        if (has_write_flag(ESCAPE_SLASHES)) {
-            return enc_table_cpy_slash;
-        } else {
-            return enc_table_cpy;
-        }
-    }
-}
-
-/** Write raw string. */
-static_inline u8 *write_raw(u8 *cur, const u8 *raw, usize raw_len) {
-    memcpy(cur, raw, raw_len);
-    return cur + raw_len;
-}
-
-/**
- Write string no-escape.
- @param cur Buffer cursor.
- @param str A UTF-8 string, null-terminator is not required.
- @param str_len Length of string in bytes.
- @return The buffer cursor after string.
- */
-static_inline u8 *write_string_noesc(u8 *cur, const u8 *str, usize str_len) {
-    *cur++ = '"';
-    while (str_len >= 16) {
-        byte_copy_16(cur, str);
-        cur += 16;
-        str += 16;
-        str_len -= 16;
-    }
-    while (str_len >= 4) {
-        byte_copy_4(cur, str);
-        cur += 4;
-        str += 4;
-        str_len -= 4;
-    }
-    while (str_len) {
-        *cur++ = *str++;
-        str_len -= 1;
-    }
-    *cur++ = '"';
-    return cur;
-}
-
-/**
- Write UTF-8 string (requires len * 6 + 2 bytes buffer).
- @param cur Buffer cursor.
- @param esc Escape unicode.
- @param inv Allow invalid unicode.
- @param str A UTF-8 string, null-terminator is not required.
- @param str_len Length of string in bytes.
- @param enc_table Encode type table for character.
- @return The buffer cursor after string, or NULL on invalid unicode.
- */
-static_inline u8 *write_string(u8 *cur, bool esc, bool inv,
-                               const u8 *str, usize str_len,
-                               const char_enc_type *enc_table) {
-
-    /* UTF-8 character mask and pattern, see `read_string()` for details. */
-#if YYJSON_ENDIAN == YYJSON_BIG_ENDIAN
-    const u16 b2_mask = 0xE0C0UL;
-    const u16 b2_patt = 0xC080UL;
-    const u16 b2_requ = 0x1E00UL;
-    const u32 b3_mask = 0xF0C0C000UL;
-    const u32 b3_patt = 0xE0808000UL;
-    const u32 b3_requ = 0x0F200000UL;
-    const u32 b3_erro = 0x0D200000UL;
-    const u32 b4_mask = 0xF8C0C0C0UL;
-    const u32 b4_patt = 0xF0808080UL;
-    const u32 b4_requ = 0x07300000UL;
-    const u32 b4_err0 = 0x04000000UL;
-    const u32 b4_err1 = 0x03300000UL;
-#elif YYJSON_ENDIAN == YYJSON_LITTLE_ENDIAN
-    const u16 b2_mask = 0xC0E0UL;
-    const u16 b2_patt = 0x80C0UL;
-    const u16 b2_requ = 0x001EUL;
-    const u32 b3_mask = 0x00C0C0F0UL;
-    const u32 b3_patt = 0x008080E0UL;
-    const u32 b3_requ = 0x0000200FUL;
-    const u32 b3_erro = 0x0000200DUL;
-    const u32 b4_mask = 0xC0C0C0F8UL;
-    const u32 b4_patt = 0x808080F0UL;
-    const u32 b4_requ = 0x00003007UL;
-    const u32 b4_err0 = 0x00000004UL;
-    const u32 b4_err1 = 0x00003003UL;
-#else
-    /* this should be evaluated at compile-time */
-    v16_uni b2_mask_uni = {{ 0xE0, 0xC0 }};
-    v16_uni b2_patt_uni = {{ 0xC0, 0x80 }};
-    v16_uni b2_requ_uni = {{ 0x1E, 0x00 }};
-    v32_uni b3_mask_uni = {{ 0xF0, 0xC0, 0xC0, 0x00 }};
-    v32_uni b3_patt_uni = {{ 0xE0, 0x80, 0x80, 0x00 }};
-    v32_uni b3_requ_uni = {{ 0x0F, 0x20, 0x00, 0x00 }};
-    v32_uni b3_erro_uni = {{ 0x0D, 0x20, 0x00, 0x00 }};
-    v32_uni b4_mask_uni = {{ 0xF8, 0xC0, 0xC0, 0xC0 }};
-    v32_uni b4_patt_uni = {{ 0xF0, 0x80, 0x80, 0x80 }};
-    v32_uni b4_requ_uni = {{ 0x07, 0x30, 0x00, 0x00 }};
-    v32_uni b4_err0_uni = {{ 0x04, 0x00, 0x00, 0x00 }};
-    v32_uni b4_err1_uni = {{ 0x03, 0x30, 0x00, 0x00 }};
-    u16 b2_mask = b2_mask_uni.u;
-    u16 b2_patt = b2_patt_uni.u;
-    u16 b2_requ = b2_requ_uni.u;
-    u32 b3_mask = b3_mask_uni.u;
-    u32 b3_patt = b3_patt_uni.u;
-    u32 b3_requ = b3_requ_uni.u;
-    u32 b3_erro = b3_erro_uni.u;
-    u32 b4_mask = b4_mask_uni.u;
-    u32 b4_patt = b4_patt_uni.u;
-    u32 b4_requ = b4_requ_uni.u;
-    u32 b4_err0 = b4_err0_uni.u;
-    u32 b4_err1 = b4_err1_uni.u;
-#endif
-
-#define is_valid_seq_2(uni) ( \
-    ((uni & b2_mask) == b2_patt) && \
-    ((uni & b2_requ)) \
-)
-
-#define is_valid_seq_3(uni) ( \
-    ((uni & b3_mask) == b3_patt) && \
-    ((tmp = (uni & b3_requ))) && \
-    ((tmp != b3_erro)) \
-)
-
-#define is_valid_seq_4(uni) ( \
-    ((uni & b4_mask) == b4_patt) && \
-    ((tmp = (uni & b4_requ))) && \
-    ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \
-)
-
-    /* The replacement character U+FFFD, used to indicate invalid character. */
-    const v32 rep = {{ 'F', 'F', 'F', 'D' }};
-    const v32 pre = {{ '\\', 'u', '0', '0' }};
-
-    const u8 *src = str;
-    const u8 *end = str + str_len;
-    *cur++ = '"';
-
-copy_ascii:
-    /*
-     Copy continuous ASCII, loop unrolling, same as the following code:
-
-         while (end > src) (
-            if (unlikely(enc_table[*src])) break;
-            *cur++ = *src++;
-         );
-     */
-#define expr_jump(i) \
-    if (unlikely(enc_table[src[i]])) goto stop_char_##i;
-
-#define expr_stop(i) \
-    stop_char_##i: \
-    memcpy(cur, src, i); \
-    cur += i; src += i; goto copy_utf8;
-
-    while (end - src >= 16) {
-        repeat16_incr(expr_jump)
-        byte_copy_16(cur, src);
-        cur += 16; src += 16;
-    }
-
-    while (end - src >= 4) {
-        repeat4_incr(expr_jump)
-        byte_copy_4(cur, src);
-        cur += 4; src += 4;
-    }
-
-    while (end > src) {
-        expr_jump(0)
-        *cur++ = *src++;
-    }
-
-    *cur++ = '"';
-    return cur;
-
-    repeat16_incr(expr_stop)
-
-#undef expr_jump
-#undef expr_stop
-
-copy_utf8:
-    if (unlikely(src + 4 > end)) {
-        if (end == src) goto copy_end;
-        if (end - src < enc_table[*src] / 2) goto err_one;
-    }
-    switch (enc_table[*src]) {
-        case CHAR_ENC_CPY_1: {
-            *cur++ = *src++;
-            goto copy_ascii;
-        }
-        case CHAR_ENC_CPY_2: {
-            u16 v;
-#if YYJSON_DISABLE_UTF8_VALIDATION
-            byte_copy_2(cur, src);
-#else
-            v = byte_load_2(src);
-            if (unlikely(!is_valid_seq_2(v))) goto err_cpy;
-            byte_copy_2(cur, src);
-#endif
-            cur += 2;
-            src += 2;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_CPY_3: {
-            u32 v, tmp;
-#if YYJSON_DISABLE_UTF8_VALIDATION
-            if (likely(src + 4 <= end)) {
-                byte_copy_4(cur, src);
-            } else {
-                byte_copy_2(cur, src);
-                cur[2] = src[2];
-            }
-#else
-            if (likely(src + 4 <= end)) {
-                v = byte_load_4(src);
-                if (unlikely(!is_valid_seq_3(v))) goto err_cpy;
-                byte_copy_4(cur, src);
-            } else {
-                v = byte_load_3(src);
-                if (unlikely(!is_valid_seq_3(v))) goto err_cpy;
-                byte_copy_4(cur, &v);
-            }
-#endif
-            cur += 3;
-            src += 3;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_CPY_4: {
-            u32 v, tmp;
-#if YYJSON_DISABLE_UTF8_VALIDATION
-            byte_copy_4(cur, src);
-#else
-            v = byte_load_4(src);
-            if (unlikely(!is_valid_seq_4(v))) goto err_cpy;
-            byte_copy_4(cur, src);
-#endif
-            cur += 4;
-            src += 4;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_A: {
-            byte_copy_2(cur, &esc_single_char_table[*src * 2]);
-            cur += 2;
-            src += 1;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_1: {
-            byte_copy_4(cur + 0, &pre);
-            byte_copy_2(cur + 4, &esc_hex_char_table[*src * 2]);
-            cur += 6;
-            src += 1;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_2: {
-            u16 u, v;
-#if !YYJSON_DISABLE_UTF8_VALIDATION
-            v = byte_load_2(src);
-            if (unlikely(!is_valid_seq_2(v))) goto err_esc;
-#endif
-            u = (u16)(((u16)(src[0] & 0x1F) << 6) |
-                      ((u16)(src[1] & 0x3F) << 0));
-            byte_copy_2(cur + 0, &pre);
-            byte_copy_2(cur + 2, &esc_hex_char_table[(u >> 8) * 2]);
-            byte_copy_2(cur + 4, &esc_hex_char_table[(u & 0xFF) * 2]);
-            cur += 6;
-            src += 2;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_3: {
-            u16 u;
-            u32 v, tmp;
-#if !YYJSON_DISABLE_UTF8_VALIDATION
-            v = byte_load_3(src);
-            if (unlikely(!is_valid_seq_3(v))) goto err_esc;
-#endif
-            u = (u16)(((u16)(src[0] & 0x0F) << 12) |
-                      ((u16)(src[1] & 0x3F) << 6) |
-                      ((u16)(src[2] & 0x3F) << 0));
-            byte_copy_2(cur + 0, &pre);
-            byte_copy_2(cur + 2, &esc_hex_char_table[(u >> 8) * 2]);
-            byte_copy_2(cur + 4, &esc_hex_char_table[(u & 0xFF) * 2]);
-            cur += 6;
-            src += 3;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ESC_4: {
-            u32 hi, lo, u, v, tmp;
-#if !YYJSON_DISABLE_UTF8_VALIDATION
-            v = byte_load_4(src);
-            if (unlikely(!is_valid_seq_4(v))) goto err_esc;
-#endif
-            u = ((u32)(src[0] & 0x07) << 18) |
-                ((u32)(src[1] & 0x3F) << 12) |
-                ((u32)(src[2] & 0x3F) << 6) |
-                ((u32)(src[3] & 0x3F) << 0);
-            u -= 0x10000;
-            hi = (u >> 10) + 0xD800;
-            lo = (u & 0x3FF) + 0xDC00;
-            byte_copy_2(cur + 0, &pre);
-            byte_copy_2(cur + 2, &esc_hex_char_table[(hi >> 8) * 2]);
-            byte_copy_2(cur + 4, &esc_hex_char_table[(hi & 0xFF) * 2]);
-            byte_copy_2(cur + 6, &pre);
-            byte_copy_2(cur + 8, &esc_hex_char_table[(lo >> 8) * 2]);
-            byte_copy_2(cur + 10, &esc_hex_char_table[(lo & 0xFF) * 2]);
-            cur += 12;
-            src += 4;
-            goto copy_utf8;
-        }
-        case CHAR_ENC_ERR_1: {
-            goto err_one;
-        }
-        default: break;
-    }
-
-copy_end:
-    *cur++ = '"';
-    return cur;
-
-err_one:
-    if (esc) goto err_esc;
-    else goto err_cpy;
-
-err_cpy:
-    if (!inv) return NULL;
-    *cur++ = *src++;
-    goto copy_utf8;
-
-err_esc:
-    if (!inv) return NULL;
-    byte_copy_2(cur + 0, &pre);
-    byte_copy_4(cur + 2, &rep);
-    cur += 6;
-    src += 1;
-    goto copy_utf8;
-
-#undef is_valid_seq_2
-#undef is_valid_seq_3
-#undef is_valid_seq_4
-}
-
-
-
-/*==============================================================================
- * Writer Utilities
- *============================================================================*/
-
-/** Write null (requires 8 bytes buffer). */
-static_inline u8 *write_null(u8 *cur) {
-    v64 v = {{ 'n', 'u', 'l', 'l', ',', '\n', 0, 0 }};
-    byte_copy_8(cur, &v);
-    return cur + 4;
-}
-
-/** Write bool (requires 8 bytes buffer). */
-static_inline u8 *write_bool(u8 *cur, bool val) {
-    v64 v0 = {{ 'f', 'a', 'l', 's', 'e', ',', '\n', 0 }};
-    v64 v1 = {{ 't', 'r', 'u', 'e', ',', '\n', 0, 0 }};
-    if (val) {
-        byte_copy_8(cur, &v1);
-    } else {
-        byte_copy_8(cur, &v0);
-    }
-    return cur + 5 - val;
-}
-
-/** Write indent (requires level x 4 bytes buffer).
-    Param spaces should not larger than 4. */
-static_inline u8 *write_indent(u8 *cur, usize level, usize spaces) {
-    while (level-- > 0) {
-        byte_copy_4(cur, "    ");
-        cur += spaces;
-    }
-    return cur;
-}
-
-/** Write data to file pointer. */
-static bool write_dat_to_fp(FILE *fp, u8 *dat, usize len,
-                            yyjson_write_err *err) {
-    if (fwrite(dat, len, 1, fp) != 1) {
-        err->msg = "file writing failed";
-        err->code = YYJSON_WRITE_ERROR_FILE_WRITE;
-        return false;
-    }
-    return true;
-}
-
-/** Write data to file. */
-static bool write_dat_to_file(const char *path, u8 *dat, usize len,
-                              yyjson_write_err *err) {
-
-#define return_err(_code, _msg) do { \
-    err->msg = _msg; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    if (file) fclose(file); \
-    return false; \
-} while (false)
-
-    FILE *file = fopen_writeonly(path);
-    if (file == NULL) {
-        return_err(FILE_OPEN, "file opening failed");
-    }
-    if (fwrite(dat, len, 1, file) != 1) {
-        return_err(FILE_WRITE, "file writing failed");
-    }
-    if (fclose(file) != 0) {
-        file = NULL;
-        return_err(FILE_WRITE, "file closing failed");
-    }
-    return true;
-
-#undef return_err
-}
-
-
-
-/*==============================================================================
- * JSON Writer Implementation
- *============================================================================*/
-
-typedef struct yyjson_write_ctx {
-    usize tag;
-} yyjson_write_ctx;
-
-static_inline void yyjson_write_ctx_set(yyjson_write_ctx *ctx,
-                                        usize size, bool is_obj) {
-    ctx->tag = (size << 1) | (usize)is_obj;
-}
-
-static_inline void yyjson_write_ctx_get(yyjson_write_ctx *ctx,
-                                        usize *size, bool *is_obj) {
-    usize tag = ctx->tag;
-    *size = tag >> 1;
-    *is_obj = (bool)(tag & 1);
-}
-
-/** Write single JSON value. */
-static_inline u8 *yyjson_write_single(yyjson_val *val,
-                                      yyjson_write_flag flg,
-                                      yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
-
-#define return_err(_code, _msg) do { \
-    if (hdr) alc.free(alc.ctx, (void *)hdr); \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    return NULL; \
-} while (false)
-
-#define incr_len(_len) do { \
-    hdr = (u8 *)alc.malloc(alc.ctx, _len); \
-    if (!hdr) goto fail_alloc; \
-    cur = hdr; \
-} while (false)
-
-#define check_str_len(_len) do { \
-    if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-
-    u8 *hdr = NULL, *cur;
-    usize str_len;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool cpy = (enc_table == enc_table_cpy);
-    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
-    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
-    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
-    const usize end_len = 2; /* '\n' and '\0' */
-
-    switch (unsafe_yyjson_get_type(val)) {
-        case YYJSON_TYPE_RAW:
-            str_len = unsafe_yyjson_get_len(val);
-            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-            check_str_len(str_len);
-            incr_len(str_len + end_len);
-            cur = write_raw(cur, str_ptr, str_len);
-            break;
-
-        case YYJSON_TYPE_STR:
-            str_len = unsafe_yyjson_get_len(val);
-            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-            check_str_len(str_len);
-            incr_len(str_len * 6 + 2 + end_len);
-            if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
-                cur = write_string_noesc(cur, str_ptr, str_len);
-            } else {
-                cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-                if (unlikely(!cur)) goto fail_str;
-            }
-            break;
-
-        case YYJSON_TYPE_NUM:
-            incr_len(32 + end_len);
-            cur = write_number(cur, val, flg);
-            if (unlikely(!cur)) goto fail_num;
-            break;
-
-        case YYJSON_TYPE_BOOL:
-            incr_len(8);
-            cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-            break;
-
-        case YYJSON_TYPE_NULL:
-            incr_len(8);
-            cur = write_null(cur);
-            break;
-
-        case YYJSON_TYPE_ARR:
-            incr_len(2 + end_len);
-            byte_copy_2(cur, "[]");
-            cur += 2;
-            break;
-
-        case YYJSON_TYPE_OBJ:
-            incr_len(2 + end_len);
-            byte_copy_2(cur, "{}");
-            cur += 2;
-            break;
-
-        default:
-            goto fail_type;
-    }
-
-    if (newline) *cur++ = '\n';
-    *cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    memset(err, 0, sizeof(yyjson_write_err));
-    return hdr;
-
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-
-#undef return_err
-#undef check_str_len
-#undef incr_len
-}
-
-/** Write JSON document minify.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_write_minify(const yyjson_val *root,
-                                      const yyjson_write_flag flg,
-                                      const yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
-
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); \
-        if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \
-            goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-
-#define check_str_len(_len) do { \
-    if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-
-    yyjson_val *val;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool cpy = (enc_table == enc_table_cpy);
-    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
-    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
-    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
-
-    alc_len = root->uni.ofs / sizeof(yyjson_val);
-    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_write_ctx *)(void *)end;
-
-doc_begin:
-    val = constcast(yyjson_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    val++;
-
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = ((u8)ctn_obj & (u8)~ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16);
-        if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
-            cur = write_string_noesc(cur, str_ptr, str_len);
-        } else {
-            cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-            if (unlikely(!cur)) goto fail_str;
-        }
-        *cur++ = is_key ? ':' : ',';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        incr_len(32);
-        cur = write_number(cur, val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        incr_len(16);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            val++;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        incr_len(16);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        incr_len(16);
-        cur = write_null(cur);
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 2);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        goto val_end;
-    }
-    goto fail_type;
-
-val_end:
-    val++;
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    goto val_begin;
-
-ctn_end:
-    cur--;
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    *cur++ = ',';
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    yyjson_write_ctx_get(ctx++, &ctn_len, &ctn_obj);
-    ctn_len--;
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-
-doc_end:
-    if (newline) {
-        incr_len(2);
-        *(cur - 1) = '\n';
-        cur++;
-    }
-    *--cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    memset(err, 0, sizeof(yyjson_write_err));
-    return hdr;
-
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-/** Write JSON document pretty.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_write_pretty(const yyjson_val *root,
-                                      const yyjson_write_flag flg,
-                                      const yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
-
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); \
-        if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \
-            goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-
-#define check_str_len(_len) do { \
-    if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-
-    yyjson_val *val;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key, no_indent;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len, level;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool cpy = (enc_table == enc_table_cpy);
-    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
-    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
-    usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4;
-    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
-
-    alc_len = root->uni.ofs / sizeof(yyjson_val);
-    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_write_ctx *)(void *)end;
-
-doc_begin:
-    val = constcast(yyjson_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    *cur++ = '\n';
-    val++;
-    level = 1;
-
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = (bool)((u8)ctn_obj & (u8)~ctn_len);
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
-            cur = write_string_noesc(cur, str_ptr, str_len);
-        } else {
-            cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-            if (unlikely(!cur)) goto fail_str;
-        }
-        *cur++ = is_key ? ':' : ',';
-        *cur++ = is_key ? ' ' : '\n';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(32 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        cur = write_number(cur, val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            incr_len(16 + (no_indent ? 0 : level * 4));
-            cur = write_indent(cur, no_indent ? 0 : level, spaces);
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            *cur++ = '\n';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            incr_len(32 + (no_indent ? 0 : level * 4));
-            yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            cur = write_indent(cur, no_indent ? 0 : level, spaces);
-            level++;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            *cur++ = '\n';
-            val++;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        cur = write_null(cur);
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 3);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    goto fail_type;
-
-val_end:
-    val++;
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    goto val_begin;
-
-ctn_end:
-    cur -= 2;
-    *cur++ = '\n';
-    incr_len(level * 4);
-    cur = write_indent(cur, --level, spaces);
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    yyjson_write_ctx_get(ctx++, &ctn_len, &ctn_obj);
-    ctn_len--;
-    *cur++ = ',';
-    *cur++ = '\n';
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-
-doc_end:
-    if (newline) {
-        incr_len(2);
-        *cur++ = '\n';
-    }
-    *cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    memset(err, 0, sizeof(yyjson_write_err));
-    return hdr;
-
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-char *yyjson_val_write_opts(const yyjson_val *val,
-                            yyjson_write_flag flg,
-                            const yyjson_alc *alc_ptr,
-                            usize *dat_len,
-                            yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    usize dummy_dat_len;
-    yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
-    yyjson_val *root = constcast(yyjson_val *)val;
-
-    err = err ? err : &dummy_err;
-    dat_len = dat_len ? dat_len : &dummy_dat_len;
-
-    if (unlikely(!root)) {
-        *dat_len = 0;
-        err->msg = "input JSON is NULL";
-        err->code = YYJSON_READ_ERROR_INVALID_PARAMETER;
-        return NULL;
-    }
-
-    if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) {
-        return (char *)yyjson_write_single(root, flg, alc, dat_len, err);
-    } else if (flg & (YYJSON_WRITE_PRETTY | YYJSON_WRITE_PRETTY_TWO_SPACES)) {
-        return (char *)yyjson_write_pretty(root, flg, alc, dat_len, err);
-    } else {
-        return (char *)yyjson_write_minify(root, flg, alc, dat_len, err);
-    }
-}
-
-char *yyjson_write_opts(const yyjson_doc *doc,
-                        yyjson_write_flag flg,
-                        const yyjson_alc *alc_ptr,
-                        usize *dat_len,
-                        yyjson_write_err *err) {
-    yyjson_val *root = doc ? doc->root : NULL;
-    return yyjson_val_write_opts(root, flg, alc_ptr, dat_len, err);
-}
-
-bool yyjson_val_write_file(const char *path,
-                           const yyjson_val *val,
-                           yyjson_write_flag flg,
-                           const yyjson_alc *alc_ptr,
-                           yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    u8 *dat;
-    usize dat_len = 0;
-    yyjson_val *root = constcast(yyjson_val *)val;
-    bool suc;
-
-    alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC;
-    err = err ? err : &dummy_err;
-    if (unlikely(!path || !*path)) {
-        err->msg = "input path is invalid";
-        err->code = YYJSON_READ_ERROR_INVALID_PARAMETER;
-        return false;
-    }
-
-    dat = (u8 *)yyjson_val_write_opts(root, flg, alc_ptr, &dat_len, err);
-    if (unlikely(!dat)) return false;
-    suc = write_dat_to_file(path, dat, dat_len, err);
-    alc_ptr->free(alc_ptr->ctx, dat);
-    return suc;
-}
-
-bool yyjson_val_write_fp(FILE *fp,
-                         const yyjson_val *val,
-                         yyjson_write_flag flg,
-                         const yyjson_alc *alc_ptr,
-                         yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    u8 *dat;
-    usize dat_len = 0;
-    yyjson_val *root = constcast(yyjson_val *)val;
-    bool suc;
-
-    alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC;
-    err = err ? err : &dummy_err;
-    if (unlikely(!fp)) {
-        err->msg = "input fp is invalid";
-        err->code = YYJSON_READ_ERROR_INVALID_PARAMETER;
-        return false;
-    }
-
-    dat = (u8 *)yyjson_val_write_opts(root, flg, alc_ptr, &dat_len, err);
-    if (unlikely(!dat)) return false;
-    suc = write_dat_to_fp(fp, dat, dat_len, err);
-    alc_ptr->free(alc_ptr->ctx, dat);
-    return suc;
-}
-
-bool yyjson_write_file(const char *path,
-                       const yyjson_doc *doc,
-                       yyjson_write_flag flg,
-                       const yyjson_alc *alc_ptr,
-                       yyjson_write_err *err) {
-    yyjson_val *root = doc ? doc->root : NULL;
-    return yyjson_val_write_file(path, root, flg, alc_ptr, err);
-}
-
-bool yyjson_write_fp(FILE *fp,
-                    const yyjson_doc *doc,
-                    yyjson_write_flag flg,
-                     const yyjson_alc *alc_ptr,
-                    yyjson_write_err *err) {
-    yyjson_val *root = doc ? doc->root : NULL;
-    return yyjson_val_write_fp(fp, root, flg, alc_ptr, err);
-}
-
-
-
-/*==============================================================================
- * Mutable JSON Writer Implementation
- *============================================================================*/
-
-typedef struct yyjson_mut_write_ctx {
-    usize tag;
-    yyjson_mut_val *ctn;
-} yyjson_mut_write_ctx;
-
-static_inline void yyjson_mut_write_ctx_set(yyjson_mut_write_ctx *ctx,
-                                            yyjson_mut_val *ctn,
-                                            usize size, bool is_obj) {
-    ctx->tag = (size << 1) | (usize)is_obj;
-    ctx->ctn = ctn;
-}
-
-static_inline void yyjson_mut_write_ctx_get(yyjson_mut_write_ctx *ctx,
-                                            yyjson_mut_val **ctn,
-                                            usize *size, bool *is_obj) {
-    usize tag = ctx->tag;
-    *size = tag >> 1;
-    *is_obj = (bool)(tag & 1);
-    *ctn = ctx->ctn;
-}
-
-/** Get the estimated number of values for the mutable JSON document. */
-static_inline usize yyjson_mut_doc_estimated_val_num(
-    const yyjson_mut_doc *doc) {
-    usize sum = 0;
-    yyjson_val_chunk *chunk = doc->val_pool.chunks;
-    while (chunk) {
-        sum += chunk->chunk_size / sizeof(yyjson_mut_val) - 1;
-        if (chunk == doc->val_pool.chunks) {
-            sum -= (usize)(doc->val_pool.end - doc->val_pool.cur);
-        }
-        chunk = chunk->next;
-    }
-    return sum;
-}
-
-/** Write single JSON value. */
-static_inline u8 *yyjson_mut_write_single(yyjson_mut_val *val,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-    return yyjson_write_single((yyjson_val *)val, flg, alc, dat_len, err);
-}
-
-/** Write JSON document minify.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root,
-                                          usize estimated_val_num,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); \
-        if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \
-            goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-
-#define check_str_len(_len) do { \
-    if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-
-    yyjson_mut_val *val, *ctn;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_mut_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool cpy = (enc_table == enc_table_cpy);
-    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
-    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
-    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
-
-    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_mut_write_ctx *)(void *)end;
-
-doc_begin:
-    val = constcast(yyjson_mut_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    ctn = val;
-    val = (yyjson_mut_val *)val->uni.ptr; /* tail */
-    val = ctn_obj ? val->next->next : val->next;
-
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = ((u8)ctn_obj & (u8)~ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16);
-        if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
-            cur = write_string_noesc(cur, str_ptr, str_len);
-        } else {
-            cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-            if (unlikely(!cur)) goto fail_str;
-        }
-        *cur++ = is_key ? ':' : ',';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        incr_len(32);
-        cur = write_number(cur, (yyjson_val *)val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        incr_len(16);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            ctn = val;
-            val = (yyjson_mut_val *)ctn->uni.ptr; /* tail */
-            val = ctn_obj ? val->next->next : val->next;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        incr_len(16);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        incr_len(16);
-        cur = write_null(cur);
-        cur++;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 2);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        goto val_end;
-    }
-    goto fail_type;
-
-val_end:
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    val = val->next;
-    goto val_begin;
-
-ctn_end:
-    cur--;
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    *cur++ = ',';
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    val = ctn->next;
-    yyjson_mut_write_ctx_get(ctx++, &ctn, &ctn_len, &ctn_obj);
-    ctn_len--;
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-
-doc_end:
-    if (newline) {
-        incr_len(2);
-        *(cur - 1) = '\n';
-        cur++;
-    }
-    *--cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    err->code = YYJSON_WRITE_SUCCESS;
-    err->msg = "success";
-    return hdr;
-
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-/** Write JSON document pretty.
-    The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root,
-                                          usize estimated_val_num,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-
-#define return_err(_code, _msg) do { \
-    *dat_len = 0; \
-    err->code = YYJSON_WRITE_ERROR_##_code; \
-    err->msg = _msg; \
-    if (hdr) alc.free(alc.ctx, hdr); \
-    return NULL; \
-} while (false)
-
-#define incr_len(_len) do { \
-    ext_len = (usize)(_len); \
-    if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \
-        alc_inc = yyjson_max(alc_len / 2, ext_len); \
-        alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); \
-        if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \
-            goto fail_alloc; \
-        alc_len += alc_inc; \
-        tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \
-        if (unlikely(!tmp)) goto fail_alloc; \
-        ctx_len = (usize)(end - (u8 *)ctx); \
-        ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \
-        memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \
-        ctx = ctx_tmp; \
-        cur = tmp + (cur - hdr); \
-        end = tmp + alc_len; \
-        hdr = tmp; \
-    } \
-} while (false)
-
-#define check_str_len(_len) do { \
-    if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \
-        goto fail_alloc; \
-} while (false)
-
-    yyjson_mut_val *val, *ctn;
-    yyjson_type val_type;
-    usize ctn_len, ctn_len_tmp;
-    bool ctn_obj, ctn_obj_tmp, is_key, no_indent;
-    u8 *hdr, *cur, *end, *tmp;
-    yyjson_mut_write_ctx *ctx, *ctx_tmp;
-    usize alc_len, alc_inc, ctx_len, ext_len, str_len, level;
-    const u8 *str_ptr;
-    const char_enc_type *enc_table = get_enc_table_with_flag(flg);
-    bool cpy = (enc_table == enc_table_cpy);
-    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
-    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
-    usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4;
-    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
-
-    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
-    cur = hdr;
-    end = hdr + alc_len;
-    ctx = (yyjson_mut_write_ctx *)(void *)end;
-
-doc_begin:
-    val = constcast(yyjson_mut_val *)root;
-    val_type = unsafe_yyjson_get_type(val);
-    ctn_obj = (val_type == YYJSON_TYPE_OBJ);
-    ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj;
-    *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-    *cur++ = '\n';
-    ctn = val;
-    val = (yyjson_mut_val *)val->uni.ptr; /* tail */
-    val = ctn_obj ? val->next->next : val->next;
-    level = 1;
-
-val_begin:
-    val_type = unsafe_yyjson_get_type(val);
-    if (val_type == YYJSON_TYPE_STR) {
-        is_key = (bool)((u8)ctn_obj & (u8)~ctn_len);
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len * 6 + 16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
-            cur = write_string_noesc(cur, str_ptr, str_len);
-        } else {
-            cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table);
-            if (unlikely(!cur)) goto fail_str;
-        }
-        *cur++ = is_key ? ':' : ',';
-        *cur++ = is_key ? ' ' : '\n';
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NUM) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(32 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        cur = write_number(cur, (yyjson_val *)val, flg);
-        if (unlikely(!cur)) goto fail_num;
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) ==
-                    (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        ctn_len_tmp = unsafe_yyjson_get_len(val);
-        ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        if (unlikely(ctn_len_tmp == 0)) {
-            /* write empty container */
-            incr_len(16 + (no_indent ? 0 : level * 4));
-            cur = write_indent(cur, no_indent ? 0 : level, spaces);
-            *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
-            *cur++ = ',';
-            *cur++ = '\n';
-            goto val_end;
-        } else {
-            /* push context, setup new container */
-            incr_len(32 + (no_indent ? 0 : level * 4));
-            yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj);
-            ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
-            ctn_obj = ctn_obj_tmp;
-            cur = write_indent(cur, no_indent ? 0 : level, spaces);
-            level++;
-            *cur++ = (u8)('[' | ((u8)ctn_obj << 5));
-            *cur++ = '\n';
-            ctn = val;
-            val = (yyjson_mut_val *)ctn->uni.ptr; /* tail */
-            val = ctn_obj ? val->next->next : val->next;
-            goto val_begin;
-        }
-    }
-    if (val_type == YYJSON_TYPE_BOOL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        cur = write_bool(cur, unsafe_yyjson_get_bool(val));
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_NULL) {
-        no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
-        incr_len(16 + (no_indent ? 0 : level * 4));
-        cur = write_indent(cur, no_indent ? 0 : level, spaces);
-        cur = write_null(cur);
-        cur += 2;
-        goto val_end;
-    }
-    if (val_type == YYJSON_TYPE_RAW) {
-        str_len = unsafe_yyjson_get_len(val);
-        str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
-        check_str_len(str_len);
-        incr_len(str_len + 3);
-        cur = write_raw(cur, str_ptr, str_len);
-        *cur++ = ',';
-        *cur++ = '\n';
-        goto val_end;
-    }
-    goto fail_type;
-
-val_end:
-    ctn_len--;
-    if (unlikely(ctn_len == 0)) goto ctn_end;
-    val = val->next;
-    goto val_begin;
-
-ctn_end:
-    cur -= 2;
-    *cur++ = '\n';
-    incr_len(level * 4);
-    cur = write_indent(cur, --level, spaces);
-    *cur++ = (u8)(']' | ((u8)ctn_obj << 5));
-    if (unlikely((u8 *)ctx >= end)) goto doc_end;
-    val = ctn->next;
-    yyjson_mut_write_ctx_get(ctx++, &ctn, &ctn_len, &ctn_obj);
-    ctn_len--;
-    *cur++ = ',';
-    *cur++ = '\n';
-    if (likely(ctn_len > 0)) {
-        goto val_begin;
-    } else {
-        goto ctn_end;
-    }
-
-doc_end:
-    if (newline) {
-        incr_len(2);
-        *cur++ = '\n';
-    }
-    *cur = '\0';
-    *dat_len = (usize)(cur - hdr);
-    err->code = YYJSON_WRITE_SUCCESS;
-    err->msg = "success";
-    return hdr;
-
-fail_alloc:
-    return_err(MEMORY_ALLOCATION, "memory allocation failed");
-fail_type:
-    return_err(INVALID_VALUE_TYPE, "invalid JSON value type");
-fail_num:
-    return_err(NAN_OR_INF, "nan or inf number is not allowed");
-fail_str:
-    return_err(INVALID_STRING, "invalid utf-8 encoding in string");
-
-#undef return_err
-#undef incr_len
-#undef check_str_len
-}
-
-static char *yyjson_mut_write_opts_impl(const yyjson_mut_val *val,
-                                        usize estimated_val_num,
-                                        yyjson_write_flag flg,
-                                        const yyjson_alc *alc_ptr,
-                                        usize *dat_len,
-                                        yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    usize dummy_dat_len;
-    yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
-    yyjson_mut_val *root = constcast(yyjson_mut_val *)val;
-
-    err = err ? err : &dummy_err;
-    dat_len = dat_len ? dat_len : &dummy_dat_len;
-
-    if (unlikely(!root)) {
-        *dat_len = 0;
-        err->msg = "input JSON is NULL";
-        err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
-        return NULL;
-    }
-
-    if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) {
-        return (char *)yyjson_mut_write_single(root, flg, alc, dat_len, err);
-    } else if (flg & (YYJSON_WRITE_PRETTY | YYJSON_WRITE_PRETTY_TWO_SPACES)) {
-        return (char *)yyjson_mut_write_pretty(root, estimated_val_num,
-                                               flg, alc, dat_len, err);
-    } else {
-        return (char *)yyjson_mut_write_minify(root, estimated_val_num,
-                                               flg, alc, dat_len, err);
-    }
-}
-
-char *yyjson_mut_val_write_opts(const yyjson_mut_val *val,
-                                yyjson_write_flag flg,
-                                const yyjson_alc *alc_ptr,
-                                usize *dat_len,
-                                yyjson_write_err *err) {
-    return yyjson_mut_write_opts_impl(val, 0, flg, alc_ptr, dat_len, err);
-}
-
-char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
-                            yyjson_write_flag flg,
-                            const yyjson_alc *alc_ptr,
-                            usize *dat_len,
-                            yyjson_write_err *err) {
-    yyjson_mut_val *root;
-    usize estimated_val_num;
-    if (likely(doc)) {
-        root = doc->root;
-        estimated_val_num = yyjson_mut_doc_estimated_val_num(doc);
-    } else {
-        root = NULL;
-        estimated_val_num = 0;
-    }
-    return yyjson_mut_write_opts_impl(root, estimated_val_num,
-                                      flg, alc_ptr, dat_len, err);
-}
-
-bool yyjson_mut_val_write_file(const char *path,
-                               const yyjson_mut_val *val,
-                               yyjson_write_flag flg,
-                               const yyjson_alc *alc_ptr,
-                               yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    u8 *dat;
-    usize dat_len = 0;
-    yyjson_mut_val *root = constcast(yyjson_mut_val *)val;
-    bool suc;
-
-    alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC;
-    err = err ? err : &dummy_err;
-    if (unlikely(!path || !*path)) {
-        err->msg = "input path is invalid";
-        err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
-        return false;
-    }
-
-    dat = (u8 *)yyjson_mut_val_write_opts(root, flg, alc_ptr, &dat_len, err);
-    if (unlikely(!dat)) return false;
-    suc = write_dat_to_file(path, dat, dat_len, err);
-    alc_ptr->free(alc_ptr->ctx, dat);
-    return suc;
-}
-
-bool yyjson_mut_val_write_fp(FILE *fp,
-                             const yyjson_mut_val *val,
-                             yyjson_write_flag flg,
-                             const yyjson_alc *alc_ptr,
-                             yyjson_write_err *err) {
-    yyjson_write_err dummy_err;
-    u8 *dat;
-    usize dat_len = 0;
-    yyjson_mut_val *root = constcast(yyjson_mut_val *)val;
-    bool suc;
-
-    alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC;
-    err = err ? err : &dummy_err;
-    if (unlikely(!fp)) {
-        err->msg = "input fp is invalid";
-        err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
-        return false;
-    }
-
-    dat = (u8 *)yyjson_mut_val_write_opts(root, flg, alc_ptr, &dat_len, err);
-    if (unlikely(!dat)) return false;
-    suc = write_dat_to_fp(fp, dat, dat_len, err);
-    alc_ptr->free(alc_ptr->ctx, dat);
-    return suc;
-}
-
-bool yyjson_mut_write_file(const char *path,
-                           const yyjson_mut_doc *doc,
-                           yyjson_write_flag flg,
-                           const yyjson_alc *alc_ptr,
-                           yyjson_write_err *err) {
-    yyjson_mut_val *root = doc ? doc->root : NULL;
-    return yyjson_mut_val_write_file(path, root, flg, alc_ptr, err);
-}
-
-bool yyjson_mut_write_fp(FILE *fp,
-                         const yyjson_mut_doc *doc,
-                         yyjson_write_flag flg,
-                         const yyjson_alc *alc_ptr,
-                         yyjson_write_err *err) {
-    yyjson_mut_val *root = doc ? doc->root : NULL;
-    return yyjson_mut_val_write_fp(fp, root, flg, alc_ptr, err);
-}
-
-#if defined(__clang__)
-#   pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#   pragma GCC diagnostic pop
-#   endif
-#elif defined(_MSC_VER)
-#   pragma warning(pop)
-#endif /* warning suppress end */
-
-#endif /* YYJSON_DISABLE_WRITER */
-
-} // namespace duckdb_yyjson
diff --git a/src/duckdb/third_party/zstd/common/debug.cpp b/src/duckdb/third_party/zstd/common/debug.cpp
deleted file mode 100644
index 01010e4eb..000000000
--- a/src/duckdb/third_party/zstd/common/debug.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/* ******************************************************************
- * debug
- * Part of FSE library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * You can contact the author at :
- * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-
-/*
- * This module only hosts one global variable
- * which can be used to dynamically influence the verbosity of traces,
- * such as DEBUGLOG and RAWLOG
- */
-
-#include "zstd/common/debug.h"
-
-#if !defined(ZSTD_LINUX_KERNEL) || (DEBUGLEVEL>=2)
-
-namespace duckdb_zstd {
-
-/* We only use this when DEBUGLEVEL>=2, but we get -Werror=pedantic errors if a
- * translation unit is empty. So remove this from Linux kernel builds, but
- * otherwise just leave it in.
- */
-int g_debuglevel = DEBUGLEVEL;
-
-} // namespace duckdb_zstd
-
-#endif
diff --git a/src/duckdb/third_party/zstd/common/entropy_common.cpp b/src/duckdb/third_party/zstd/common/entropy_common.cpp
deleted file mode 100644
index 9a33c2dfc..000000000
--- a/src/duckdb/third_party/zstd/common/entropy_common.cpp
+++ /dev/null
@@ -1,343 +0,0 @@
-/* ******************************************************************
- * Common functions of New Generation Entropy library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* *************************************
-*  Dependencies
-***************************************/
-#include "zstd/common/mem.h"
-#include "zstd/common/error_private.h"       /* ERR_*, ERROR */
-#define FSE_STATIC_LINKING_ONLY  /* FSE_MIN_TABLELOG */
-#include "zstd/common/fse.h"
-#include "zstd/common/huf.h"
-#include "zstd/common/bits.h"                /* ZSDT_highbit32, ZSTD_countTrailingZeros32 */
-
-namespace duckdb_zstd {
-
-/*===   Version   ===*/
-unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }
-
-
-/*===   Error Management   ===*/
-unsigned FSE_isError(size_t code) { return ERR_isError(code); }
-const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-unsigned HUF_isError(size_t code) { return ERR_isError(code); }
-const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/*-**************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-FORCE_INLINE_TEMPLATE
-size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
-                           const void* headerBuffer, size_t hbSize)
-{
-    const BYTE* const istart = (const BYTE*) headerBuffer;
-    const BYTE* const iend = istart + hbSize;
-    const BYTE* ip = istart;
-    int nbBits;
-    int remaining;
-    int threshold;
-    U32 bitStream;
-    int bitCount;
-    unsigned charnum = 0;
-    unsigned const maxSV1 = *maxSVPtr + 1;
-    int previous0 = 0;
-
-    if (hbSize < 8) {
-        /* This function only works when hbSize >= 8 */
-        char buffer[8] = {0};
-        ZSTD_memcpy(buffer, headerBuffer, hbSize);
-        {   size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr,
-                                                    buffer, sizeof(buffer));
-            if (FSE_isError(countSize)) return countSize;
-            if (countSize > hbSize) return ERROR(corruption_detected);
-            return countSize;
-    }   }
-    assert(hbSize >= 8);
-
-    /* init */
-    ZSTD_memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */
-    bitStream = MEM_readLE32(ip);
-    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
-    bitStream >>= 4;
-    bitCount = 4;
-    *tableLogPtr = nbBits;
-    remaining = (1<<nbBits)+1;
-    threshold = 1<<nbBits;
-    nbBits++;
-
-    for (;;) {
-        if (previous0) {
-            /* Count the number of repeats. Each time the
-             * 2-bit repeat code is 0b11 there is another
-             * repeat.
-             * Avoid UB by setting the high bit to 1.
-             */
-            int repeats = ZSTD_countTrailingZeros32(~bitStream | 0x80000000) >> 1;
-            while (repeats >= 12) {
-                charnum += 3 * 12;
-                if (LIKELY(ip <= iend-7)) {
-                    ip += 3;
-                } else {
-                    bitCount -= (int)(8 * (iend - 7 - ip));
-                    bitCount &= 31;
-                    ip = iend - 4;
-                }
-                bitStream = MEM_readLE32(ip) >> bitCount;
-                repeats = ZSTD_countTrailingZeros32(~bitStream | 0x80000000) >> 1;
-            }
-            charnum += 3 * repeats;
-            bitStream >>= 2 * repeats;
-            bitCount += 2 * repeats;
-
-            /* Add the final repeat which isn't 0b11. */
-            assert((bitStream & 3) < 3);
-            charnum += bitStream & 3;
-            bitCount += 2;
-
-            /* This is an error, but break and return an error
-             * at the end, because returning out of a loop makes
-             * it harder for the compiler to optimize.
-             */
-            if (charnum >= maxSV1) break;
-
-            /* We don't need to set the normalized count to 0
-             * because we already memset the whole buffer to 0.
-             */
-
-            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                assert((bitCount >> 3) <= 3); /* For first condition to work */
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
-                bitCount -= (int)(8 * (iend - 4 - ip));
-                bitCount &= 31;
-                ip = iend - 4;
-            }
-            bitStream = MEM_readLE32(ip) >> bitCount;
-        }
-        {
-            int const max = (2*threshold-1) - remaining;
-            int count;
-
-            if ((bitStream & (threshold-1)) < (U32)max) {
-                count = bitStream & (threshold-1);
-                bitCount += nbBits-1;
-            } else {
-                count = bitStream & (2*threshold-1);
-                if (count >= threshold) count -= max;
-                bitCount += nbBits;
-            }
-
-            count--;   /* extra accuracy */
-            /* When it matters (small blocks), this is a
-             * predictable branch, because we don't use -1.
-             */
-            if (count >= 0) {
-                remaining -= count;
-            } else {
-                assert(count == -1);
-                remaining += count;
-            }
-            normalizedCounter[charnum++] = (short)count;
-            previous0 = !count;
-
-            assert(threshold > 1);
-            if (remaining < threshold) {
-                /* This branch can be folded into the
-                 * threshold update condition because we
-                 * know that threshold > 1.
-                 */
-                if (remaining <= 1) break;
-                nbBits = ZSTD_highbit32(remaining) + 1;
-                threshold = 1 << (nbBits - 1);
-            }
-            if (charnum >= maxSV1) break;
-
-            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
-                bitCount -= (int)(8 * (iend - 4 - ip));
-                bitCount &= 31;
-                ip = iend - 4;
-            }
-            bitStream = MEM_readLE32(ip) >> bitCount;
-    }   }
-    if (remaining != 1) return ERROR(corruption_detected);
-    /* Only possible when there are too many zeros. */
-    if (charnum > maxSV1) return ERROR(maxSymbolValue_tooSmall);
-    if (bitCount > 32) return ERROR(corruption_detected);
-    *maxSVPtr = charnum-1;
-
-    ip += (bitCount+7)>>3;
-    return ip-istart;
-}
-
-/* Avoids the FORCE_INLINE of the _body() function. */
-static size_t FSE_readNCount_body_default(
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
-        const void* headerBuffer, size_t hbSize)
-{
-    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
-}
-
-#if DYNAMIC_BMI2
-BMI2_TARGET_ATTRIBUTE static size_t FSE_readNCount_body_bmi2(
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
-        const void* headerBuffer, size_t hbSize)
-{
-    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
-}
-#endif
-
-size_t FSE_readNCount_bmi2(
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
-        const void* headerBuffer, size_t hbSize, int bmi2)
-{
-#if DYNAMIC_BMI2
-    if (bmi2) {
-        return FSE_readNCount_body_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
-    }
-#endif
-    (void)bmi2;
-    return FSE_readNCount_body_default(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
-}
-
-size_t FSE_readNCount(
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
-        const void* headerBuffer, size_t hbSize)
-{
-    return FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, /* bmi2 */ 0);
-}
-
-
-/*! HUF_readStats() :
-    Read compact Huffman tree, saved by HUF_writeCTable().
-    `huffWeight` is destination buffer.
-    `rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32.
-    @return : size read from `src` , or an error Code .
-    Note : Needed by HUF_readCTable() and HUF_readDTableX?() .
-*/
-size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize)
-{
-    U32 wksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
-    return HUF_readStats_wksp(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, wksp, sizeof(wksp), /* flags */ 0);
-}
-
-FORCE_INLINE_TEMPLATE size_t
-HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                   U32* nbSymbolsPtr, U32* tableLogPtr,
-                   const void* src, size_t srcSize,
-                   void* workSpace, size_t wkspSize,
-                   int bmi2)
-{
-    U32 weightTotal;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize;
-    size_t oSize;
-
-    if (!srcSize) return ERROR(srcSize_wrong);
-    iSize = ip[0];
-    /* ZSTD_memset(huffWeight, 0, hwSize);   *//* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128) {  /* special header */
-        oSize = iSize - 127;
-        iSize = ((oSize+1)/2);
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        if (oSize >= hwSize) return ERROR(corruption_detected);
-        ip += 1;
-        {   U32 n;
-            for (n=0; n<oSize; n+=2) {
-                huffWeight[n]   = ip[n/2] >> 4;
-                huffWeight[n+1] = ip[n/2] & 15;
-    }   }   }
-    else  {   /* header compressed with FSE (normal case) */
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        /* max (hwSize-1) values decoded, as last one is implied */
-        oSize = FSE_decompress_wksp_bmi2(huffWeight, hwSize-1, ip+1, iSize, 6, workSpace, wkspSize, bmi2);
-        if (FSE_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
-    ZSTD_memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));
-    weightTotal = 0;
-    {   U32 n; for (n=0; n<oSize; n++) {
-            if (huffWeight[n] > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
-            rankStats[huffWeight[n]]++;
-            weightTotal += (1 << huffWeight[n]) >> 1;
-    }   }
-    if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* get last non-null symbol weight (implied, total must be 2^n) */
-    {   U32 const tableLog = ZSTD_highbit32(weightTotal) + 1;
-        if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
-        *tableLogPtr = tableLog;
-        /* determine last weight */
-        {   U32 const total = 1 << tableLog;
-            U32 const rest = total - weightTotal;
-            U32 const verif = 1 << ZSTD_highbit32(rest);
-            U32 const lastWeight = ZSTD_highbit32(rest) + 1;
-            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
-            huffWeight[oSize] = (BYTE)lastWeight;
-            rankStats[lastWeight]++;
-    }   }
-
-    /* check tree construction validity */
-    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
-
-    /* results */
-    *nbSymbolsPtr = (U32)(oSize+1);
-    return iSize+1;
-}
-
-/* Avoids the FORCE_INLINE of the _body() function. */
-static size_t HUF_readStats_body_default(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize,
-                     void* workSpace, size_t wkspSize)
-{
-    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 0);
-}
-
-#if DYNAMIC_BMI2
-static BMI2_TARGET_ATTRIBUTE size_t HUF_readStats_body_bmi2(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize,
-                     void* workSpace, size_t wkspSize)
-{
-    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 1);
-}
-#endif
-
-size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize,
-                     void* workSpace, size_t wkspSize,
-                     int flags)
-{
-#if DYNAMIC_BMI2
-    if (flags & HUF_flags_bmi2) {
-        return HUF_readStats_body_bmi2(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize);
-    }
-#endif
-    (void)flags;
-    return HUF_readStats_body_default(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/common/error_private.cpp b/src/duckdb/third_party/zstd/common/error_private.cpp
deleted file mode 100644
index c3ba4728b..000000000
--- a/src/duckdb/third_party/zstd/common/error_private.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* The purpose of this file is to have a single list of error strings embedded in binary */
-
-#include "zstd/common/error_private.h"
-
-namespace duckdb_zstd {
-
-const char* ERR_getErrorString(ERR_enum code)
-{
-#ifdef ZSTD_STRIP_ERROR_STRINGS
-    (void)code;
-    return "Error strings stripped";
-#else
-    static const char* const notErrorCode = "Unspecified error code";
-    switch( code )
-    {
-    case PREFIX(no_error): return "No error detected";
-    case PREFIX(GENERIC):  return "Error (generic)";
-    case PREFIX(prefix_unknown): return "Unknown frame descriptor";
-    case PREFIX(version_unsupported): return "Version not supported";
-    case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
-    case PREFIX(frameParameter_windowTooLarge): return "Frame requires too much memory for decoding";
-    case PREFIX(corruption_detected): return "Data corruption detected";
-    case PREFIX(checksum_wrong): return "Restored data doesn't match checksum";
-    case PREFIX(literals_headerWrong): return "Header of Literals' block doesn't respect format specification";
-    case PREFIX(parameter_unsupported): return "Unsupported parameter";
-    case PREFIX(parameter_combination_unsupported): return "Unsupported combination of parameters";
-    case PREFIX(parameter_outOfBound): return "Parameter is out of bound";
-    case PREFIX(init_missing): return "Context should be init first";
-    case PREFIX(memory_allocation): return "Allocation error : not enough memory";
-    case PREFIX(workSpace_tooSmall): return "workSpace buffer is not large enough";
-    case PREFIX(stage_wrong): return "Operation not authorized at current processing stage";
-    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
-    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
-    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
-    case PREFIX(stabilityCondition_notRespected): return "pledged buffer stability condition is not respected";
-    case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
-    case PREFIX(dictionary_wrong): return "Dictionary mismatch";
-    case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples";
-    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
-    case PREFIX(srcSize_wrong): return "Src size is incorrect";
-    case PREFIX(dstBuffer_null): return "Operation on NULL destination buffer";
-    case PREFIX(noForwardProgress_destFull): return "Operation made no progress over multiple calls, due to output buffer being full";
-    case PREFIX(noForwardProgress_inputEmpty): return "Operation made no progress over multiple calls, due to input being empty";
-        /* following error codes are not stable and may be removed or changed in a future version */
-    case PREFIX(frameIndex_tooLarge): return "Frame index is too large";
-    case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking";
-    case PREFIX(dstBuffer_wrong): return "Destination buffer is wrong";
-    case PREFIX(srcBuffer_wrong): return "Source buffer is wrong";
-    case PREFIX(sequenceProducer_failed): return "Block-level external sequence producer returned an error code";
-    case PREFIX(externalSequences_invalid): return "External sequences are not valid";
-    case PREFIX(maxCode):
-    default: return notErrorCode;
-    }
-#endif
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/common/fse_decompress.cpp b/src/duckdb/third_party/zstd/common/fse_decompress.cpp
deleted file mode 100644
index 9b6957409..000000000
--- a/src/duckdb/third_party/zstd/common/fse_decompress.cpp
+++ /dev/null
@@ -1,316 +0,0 @@
-/* ******************************************************************
- * FSE : Finite State Entropy decoder
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
-#include "zstd/common/debug.h"      /* assert */
-#include "zstd/common/bitstream.h"
-#include "zstd/common/compiler.h"
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-#include "zstd/common/error_private.h"
-#include "zstd/common/zstd_deps.h"  /* ZSTD_memcpy */
-#include "zstd/common/bits.h"       /* ZSTD_highbit32 */
-
-namespace duckdb_zstd {
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_isError ERR_isError
-#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Templates
-****************************************************************/
-/*
-  designed to be included
-  for type-specific functions (template emulation in C)
-  Objective is to write these functions only once, for improved maintenance
-*/
-
-/* safety checks */
-#ifndef FSE_FUNCTION_EXTENSION
-#  error "FSE_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSE_FUNCTION_TYPE
-#  error "FSE_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSE_CAT(X,Y) X##Y
-#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
-#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
-
-static size_t FSE_buildDTable_internal(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
-{
-    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
-    U16* symbolNext = (U16*)workSpace;
-    BYTE* spread = (BYTE*)(symbolNext + maxSymbolValue + 1);
-
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-    U32 highThreshold = tableSize-1;
-
-    /* Sanity Checks */
-    if (FSE_BUILD_DTABLE_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(maxSymbolValue_tooLarge);
-    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-
-    /* Init, lay down lowprob symbols */
-    {   FSE_DTableHeader DTableH;
-        DTableH.tableLog = (U16)tableLog;
-        DTableH.fastMode = 1;
-        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
-            U32 s;
-            for (s=0; s<maxSV1; s++) {
-                if (normalizedCounter[s]==-1) {
-                    tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
-                    symbolNext[s] = 1;
-                } else {
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
-                    symbolNext[s] = (U16)normalizedCounter[s];
-        }   }   }
-        ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
-    if (highThreshold == tableSize - 1) {
-        size_t const tableMask = tableSize-1;
-        size_t const step = FSE_TABLESTEP(tableSize);
-        /* First lay down the symbols in order.
-         * We use a uint64_t to lay down 8 bytes at a time. This reduces branch
-         * misses since small blocks generally have small table logs, so nearly
-         * all symbols have counts <= 8. We ensure we have 8 bytes at the end of
-         * our buffer to handle the over-write.
-         */
-        {   U64 const add = 0x0101010101010101ull;
-            size_t pos = 0;
-            U64 sv = 0;
-            U32 s;
-            for (s=0; s<maxSV1; ++s, sv += add) {
-                int i;
-                int const n = normalizedCounter[s];
-                MEM_write64(spread + pos, sv);
-                for (i = 8; i < n; i += 8) {
-                    MEM_write64(spread + pos + i, sv);
-                }
-                pos += (size_t)n;
-        }   }
-        /* Now we spread those positions across the table.
-         * The benefit of doing it in two stages is that we avoid the
-         * variable size inner loop, which caused lots of branch misses.
-         * Now we can run through all the positions without any branch misses.
-         * We unroll the loop twice, since that is what empirically worked best.
-         */
-        {
-            size_t position = 0;
-            size_t s;
-            size_t const unroll = 2;
-            assert(tableSize % unroll == 0); /* FSE_MIN_TABLELOG is 5 */
-            for (s = 0; s < (size_t)tableSize; s += unroll) {
-                size_t u;
-                for (u = 0; u < unroll; ++u) {
-                    size_t const uPosition = (position + (u * step)) & tableMask;
-                    tableDecode[uPosition].symbol = spread[s + u];
-                }
-                position = (position + (unroll * step)) & tableMask;
-            }
-            assert(position == 0);
-        }
-    } else {
-        U32 const tableMask = tableSize-1;
-        U32 const step = FSE_TABLESTEP(tableSize);
-        U32 s, position = 0;
-        for (s=0; s<maxSV1; s++) {
-            int i;
-            for (i=0; i<normalizedCounter[s]; i++) {
-                tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
-                position = (position + step) & tableMask;
-                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
-        }   }
-        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-    }
-
-    /* Build Decoding table */
-    {   U32 u;
-        for (u=0; u<tableSize; u++) {
-            FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
-            U32 const nextState = symbolNext[symbol]++;
-            tableDecode[u].nbBits = (BYTE) (tableLog - ZSTD_highbit32(nextState) );
-            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-    }   }
-
-    return 0;
-}
-
-size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
-{
-    return FSE_buildDTable_internal(dt, normalizedCounter, maxSymbolValue, tableLog, workSpace, wkspSize);
-}
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/*-*******************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-
-FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const FSE_DTable* dt, const unsigned fast)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-3;
-
-    BIT_DStream_t bitD;
-    FSE_DState_t state1;
-    FSE_DState_t state2;
-
-    /* Init */
-    CHECK_F(BIT_initDStream(&bitD, cSrc, cSrcSize));
-
-    FSE_initDState(&state1, &bitD, dt);
-    FSE_initDState(&state2, &bitD, dt);
-
-#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
-
-    /* 4 symbols per loop */
-    for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) & (op<olimit) ; op+=4) {
-        op[0] = FSE_GETSYMBOL(&state1);
-
-        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BIT_reloadDStream(&bitD);
-
-        op[1] = FSE_GETSYMBOL(&state2);
-
-        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
-
-        op[2] = FSE_GETSYMBOL(&state1);
-
-        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BIT_reloadDStream(&bitD);
-
-        op[3] = FSE_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
-    while (1) {
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-        *op++ = FSE_GETSYMBOL(&state1);
-        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
-            *op++ = FSE_GETSYMBOL(&state2);
-            break;
-        }
-
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-        *op++ = FSE_GETSYMBOL(&state2);
-        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
-            *op++ = FSE_GETSYMBOL(&state1);
-            break;
-    }   }
-
-    assert(op >= ostart);
-    return (size_t)(op-ostart);
-}
-
-typedef struct {
-    short ncount[FSE_MAX_SYMBOL_VALUE + 1];
-} FSE_DecompressWksp;
-
-
-FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
-        void* dst, size_t dstCapacity,
-        const void* cSrc, size_t cSrcSize,
-        unsigned maxLog, void* workSpace, size_t wkspSize,
-        int bmi2)
-{
-    const BYTE* const istart = (const BYTE*)cSrc;
-    const BYTE* ip = istart;
-    unsigned tableLog;
-    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
-    FSE_DecompressWksp* const wksp = (FSE_DecompressWksp*)workSpace;
-    size_t const dtablePos = sizeof(FSE_DecompressWksp) / sizeof(FSE_DTable);
-    FSE_DTable* const dtable = (FSE_DTable*)workSpace + dtablePos;
-
-    FSE_STATIC_ASSERT((FSE_MAX_SYMBOL_VALUE + 1) % 2 == 0);
-    if (wkspSize < sizeof(*wksp)) return ERROR(GENERIC);
-
-    /* correct offset to dtable depends on this property */
-    FSE_STATIC_ASSERT(sizeof(FSE_DecompressWksp) % sizeof(FSE_DTable) == 0);
-
-    /* normal FSE decoding mode */
-    {   size_t const NCountLength =
-            FSE_readNCount_bmi2(wksp->ncount, &maxSymbolValue, &tableLog, istart, cSrcSize, bmi2);
-        if (FSE_isError(NCountLength)) return NCountLength;
-        if (tableLog > maxLog) return ERROR(tableLog_tooLarge);
-        assert(NCountLength <= cSrcSize);
-        ip += NCountLength;
-        cSrcSize -= NCountLength;
-    }
-
-    if (FSE_DECOMPRESS_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(tableLog_tooLarge);
-    assert(sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog) <= wkspSize);
-    workSpace = (BYTE*)workSpace + sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog);
-    wkspSize -= sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog);
-
-    CHECK_F( FSE_buildDTable_internal(dtable, wksp->ncount, maxSymbolValue, tableLog, workSpace, wkspSize) );
-
-    {
-        const void* ptr = dtable;
-        const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;
-        const U32 fastMode = DTableH->fastMode;
-
-        /* select fast mode (static) */
-        if (fastMode) return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 1);
-        return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 0);
-    }
-}
-
-/* Avoids the FORCE_INLINE of the _body() function. */
-static size_t FSE_decompress_wksp_body_default(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
-{
-    return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 0);
-}
-
-#if DYNAMIC_BMI2
-BMI2_TARGET_ATTRIBUTE static size_t FSE_decompress_wksp_body_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
-{
-    return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 1);
-}
-#endif
-
-size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2)
-{
-#if DYNAMIC_BMI2
-    if (bmi2) {
-        return FSE_decompress_wksp_body_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);
-    }
-#endif
-    (void)bmi2;
-    return FSE_decompress_wksp_body_default(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);
-}
-
-#endif   /* FSE_COMMONDEFS_ONLY */
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/common/pool.cpp b/src/duckdb/third_party/zstd/common/pool.cpp
deleted file mode 100644
index 79df927e6..000000000
--- a/src/duckdb/third_party/zstd/common/pool.cpp
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-/* ======   Dependencies   ======= */
-#include "zstd/common/allocations.h"  /* ZSTD_customCalloc, ZSTD_customFree */
-#include "zstd/common/zstd_deps.h" /* size_t */
-#include "zstd/common/debug.h"     /* assert */
-#include "zstd/common/pool.h"
-
-/* ======   Compiler specifics   ====== */
-#if defined(_MSC_VER)
-#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */
-#endif
-
-
-#ifdef ZSTD_MULTITHREAD
-#include "zstd/common/threading.h"   /* pthread adaptation */
-#endif
-
-namespace duckdb_zstd {
-
-#ifdef ZSTD_MULTITHREAD
-
-/* A job is a function and an opaque argument */
-typedef struct POOL_job_s {
-    POOL_function function;
-    void *opaque;
-} POOL_job;
-
-struct POOL_ctx_s {
-    ZSTD_customMem customMem;
-    /* Keep track of the threads */
-    ZSTD_pthread_t* threads;
-    size_t threadCapacity;
-    size_t threadLimit;
-
-    /* The queue is a circular buffer */
-    POOL_job *queue;
-    size_t queueHead;
-    size_t queueTail;
-    size_t queueSize;
-
-    /* The number of threads working on jobs */
-    size_t numThreadsBusy;
-    /* Indicates if the queue is empty */
-    int queueEmpty;
-
-    /* The mutex protects the queue */
-    ZSTD_pthread_mutex_t queueMutex;
-    /* Condition variable for pushers to wait on when the queue is full */
-    ZSTD_pthread_cond_t queuePushCond;
-    /* Condition variables for poppers to wait on when the queue is empty */
-    ZSTD_pthread_cond_t queuePopCond;
-    /* Indicates if the queue is shutting down */
-    int shutdown;
-};
-
-/* POOL_thread() :
- * Work thread for the thread pool.
- * Waits for jobs and executes them.
- * @returns : NULL on failure else non-null.
- */
-static void* POOL_thread(void* opaque) {
-    POOL_ctx* const ctx = (POOL_ctx*)opaque;
-    if (!ctx) { return NULL; }
-    for (;;) {
-        /* Lock the mutex and wait for a non-empty queue or until shutdown */
-        ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-
-        while ( ctx->queueEmpty
-            || (ctx->numThreadsBusy >= ctx->threadLimit) ) {
-            if (ctx->shutdown) {
-                /* even if !queueEmpty, (possible if numThreadsBusy >= threadLimit),
-                 * a few threads will be shutdown while !queueEmpty,
-                 * but enough threads will remain active to finish the queue */
-                ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-                return opaque;
-            }
-            ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);
-        }
-        /* Pop a job off the queue */
-        {   POOL_job const job = ctx->queue[ctx->queueHead];
-            ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize;
-            ctx->numThreadsBusy++;
-            ctx->queueEmpty = (ctx->queueHead == ctx->queueTail);
-            /* Unlock the mutex, signal a pusher, and run the job */
-            ZSTD_pthread_cond_signal(&ctx->queuePushCond);
-            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-
-            job.function(job.opaque);
-
-            /* If the intended queue size was 0, signal after finishing job */
-            ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-            ctx->numThreadsBusy--;
-            ZSTD_pthread_cond_signal(&ctx->queuePushCond);
-            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-        }
-    }  /* for (;;) */
-    assert(0);  /* Unreachable */
-}
-
-/* ZSTD_createThreadPool() : public access point */
-POOL_ctx* ZSTD_createThreadPool(size_t numThreads) {
-    return POOL_create (numThreads, 0);
-}
-
-POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
-    return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
-}
-
-POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
-                               ZSTD_customMem customMem)
-{
-    POOL_ctx* ctx;
-    /* Check parameters */
-    if (!numThreads) { return NULL; }
-    /* Allocate the context and zero initialize */
-    ctx = (POOL_ctx*)ZSTD_customCalloc(sizeof(POOL_ctx), customMem);
-    if (!ctx) { return NULL; }
-    /* Initialize the job queue.
-     * It needs one extra space since one space is wasted to differentiate
-     * empty and full queues.
-     */
-    ctx->queueSize = queueSize + 1;
-    ctx->queue = (POOL_job*)ZSTD_customCalloc(ctx->queueSize * sizeof(POOL_job), customMem);
-    ctx->queueHead = 0;
-    ctx->queueTail = 0;
-    ctx->numThreadsBusy = 0;
-    ctx->queueEmpty = 1;
-    {
-        int error = 0;
-        error |= ZSTD_pthread_mutex_init(&ctx->queueMutex, NULL);
-        error |= ZSTD_pthread_cond_init(&ctx->queuePushCond, NULL);
-        error |= ZSTD_pthread_cond_init(&ctx->queuePopCond, NULL);
-        if (error) { POOL_free(ctx); return NULL; }
-    }
-    ctx->shutdown = 0;
-    /* Allocate space for the thread handles */
-    ctx->threads = (ZSTD_pthread_t*)ZSTD_customCalloc(numThreads * sizeof(ZSTD_pthread_t), customMem);
-    ctx->threadCapacity = 0;
-    ctx->customMem = customMem;
-    /* Check for errors */
-    if (!ctx->threads || !ctx->queue) { POOL_free(ctx); return NULL; }
-    /* Initialize the threads */
-    {   size_t i;
-        for (i = 0; i < numThreads; ++i) {
-            if (ZSTD_pthread_create(&ctx->threads[i], NULL, &POOL_thread, ctx)) {
-                ctx->threadCapacity = i;
-                POOL_free(ctx);
-                return NULL;
-        }   }
-        ctx->threadCapacity = numThreads;
-        ctx->threadLimit = numThreads;
-    }
-    return ctx;
-}
-
-/*! POOL_join() :
-    Shutdown the queue, wake any sleeping threads, and join all of the threads.
-*/
-static void POOL_join(POOL_ctx* ctx) {
-    /* Shut down the queue */
-    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-    ctx->shutdown = 1;
-    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-    /* Wake up sleeping threads */
-    ZSTD_pthread_cond_broadcast(&ctx->queuePushCond);
-    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
-    /* Join all of the threads */
-    {   size_t i;
-        for (i = 0; i < ctx->threadCapacity; ++i) {
-            ZSTD_pthread_join(ctx->threads[i]);  /* note : could fail */
-    }   }
-}
-
-void POOL_free(POOL_ctx *ctx) {
-    if (!ctx) { return; }
-    POOL_join(ctx);
-    ZSTD_pthread_mutex_destroy(&ctx->queueMutex);
-    ZSTD_pthread_cond_destroy(&ctx->queuePushCond);
-    ZSTD_pthread_cond_destroy(&ctx->queuePopCond);
-    ZSTD_customFree(ctx->queue, ctx->customMem);
-    ZSTD_customFree(ctx->threads, ctx->customMem);
-    ZSTD_customFree(ctx, ctx->customMem);
-}
-
-/*! POOL_joinJobs() :
- *  Waits for all queued jobs to finish executing.
- */
-void POOL_joinJobs(POOL_ctx* ctx) {
-    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-    while(!ctx->queueEmpty || ctx->numThreadsBusy > 0) {
-        ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);
-    }
-    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-}
-
-void ZSTD_freeThreadPool (ZSTD_threadPool* pool) {
-  POOL_free (pool);
-}
-
-size_t POOL_sizeof(const POOL_ctx* ctx) {
-    if (ctx==NULL) return 0;  /* supports sizeof NULL */
-    return sizeof(*ctx)
-        + ctx->queueSize * sizeof(POOL_job)
-        + ctx->threadCapacity * sizeof(ZSTD_pthread_t);
-}
-
-
-/* @return : 0 on success, 1 on error */
-static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
-{
-    if (numThreads <= ctx->threadCapacity) {
-        if (!numThreads) return 1;
-        ctx->threadLimit = numThreads;
-        return 0;
-    }
-    /* numThreads > threadCapacity */
-    {   ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_customCalloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);
-        if (!threadPool) return 1;
-        /* replace existing thread pool */
-        ZSTD_memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(ZSTD_pthread_t));
-        ZSTD_customFree(ctx->threads, ctx->customMem);
-        ctx->threads = threadPool;
-        /* Initialize additional threads */
-        {   size_t threadId;
-            for (threadId = ctx->threadCapacity; threadId < numThreads; ++threadId) {
-                if (ZSTD_pthread_create(&threadPool[threadId], NULL, &POOL_thread, ctx)) {
-                    ctx->threadCapacity = threadId;
-                    return 1;
-            }   }
-    }   }
-    /* successfully expanded */
-    ctx->threadCapacity = numThreads;
-    ctx->threadLimit = numThreads;
-    return 0;
-}
-
-/* @return : 0 on success, 1 on error */
-int POOL_resize(POOL_ctx* ctx, size_t numThreads)
-{
-    int result;
-    if (ctx==NULL) return 1;
-    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-    result = POOL_resize_internal(ctx, numThreads);
-    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
-    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-    return result;
-}
-
-/**
- * Returns 1 if the queue is full and 0 otherwise.
- *
- * When queueSize is 1 (pool was created with an intended queueSize of 0),
- * then a queue is empty if there is a thread free _and_ no job is waiting.
- */
-static int isQueueFull(POOL_ctx const* ctx) {
-    if (ctx->queueSize > 1) {
-        return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize);
-    } else {
-        return (ctx->numThreadsBusy == ctx->threadLimit) ||
-               !ctx->queueEmpty;
-    }
-}
-
-
-static void
-POOL_add_internal(POOL_ctx* ctx, POOL_function function, void *opaque)
-{
-    POOL_job job;
-    job.function = function;
-    job.opaque = opaque;
-    assert(ctx != NULL);
-    if (ctx->shutdown) return;
-
-    ctx->queueEmpty = 0;
-    ctx->queue[ctx->queueTail] = job;
-    ctx->queueTail = (ctx->queueTail + 1) % ctx->queueSize;
-    ZSTD_pthread_cond_signal(&ctx->queuePopCond);
-}
-
-void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque)
-{
-    assert(ctx != NULL);
-    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-    /* Wait until there is space in the queue for the new job */
-    while (isQueueFull(ctx) && (!ctx->shutdown)) {
-        ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);
-    }
-    POOL_add_internal(ctx, function, opaque);
-    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-}
-
-
-int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque)
-{
-    assert(ctx != NULL);
-    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-    if (isQueueFull(ctx)) {
-        ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-        return 0;
-    }
-    POOL_add_internal(ctx, function, opaque);
-    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-    return 1;
-}
-
-#else  /* ZSTD_MULTITHREAD  not defined */
-
-/* ========================== */
-/* No multi-threading support */
-/* ========================== */
-
-
-/* We don't need any data, but if it is empty, malloc() might return NULL. */
-struct POOL_ctx_s {
-    int dummy;
-};
-static POOL_ctx g_poolCtx;
-
-POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
-    return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
-}
-
-POOL_ctx*
-POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem)
-{
-    (void)numThreads;
-    (void)queueSize;
-    (void)customMem;
-    return &g_poolCtx;
-}
-
-void POOL_free(POOL_ctx* ctx) {
-    assert(!ctx || ctx == &g_poolCtx);
-    (void)ctx;
-}
-
-void POOL_joinJobs(POOL_ctx* ctx){
-    assert(!ctx || ctx == &g_poolCtx);
-    (void)ctx;
-}
-
-int POOL_resize(POOL_ctx* ctx, size_t numThreads) {
-    (void)ctx; (void)numThreads;
-    return 0;
-}
-
-void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) {
-    (void)ctx;
-    function(opaque);
-}
-
-int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) {
-    (void)ctx;
-    function(opaque);
-    return 1;
-}
-
-size_t POOL_sizeof(const POOL_ctx* ctx) {
-    if (ctx==NULL) return 0;  /* supports sizeof NULL */
-    assert(ctx == &g_poolCtx);
-    return sizeof(*ctx);
-}
-
-#endif  /* ZSTD_MULTITHREAD */
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/common/threading.cpp b/src/duckdb/third_party/zstd/common/threading.cpp
deleted file mode 100644
index 5c63f0af0..000000000
--- a/src/duckdb/third_party/zstd/common/threading.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-/**
- * Copyright (c) 2016 Tino Reichardt
- * All rights reserved.
- *
- * You can contact the author at:
- * - zstdmt source repository: https://github.com/mcmilk/zstdmt
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This file will hold wrapper for systems, which do not support pthreads
- */
-
-#include "zstd/common/threading.h"
-
-namespace duckdb_zstd {
-
-/* create fake symbol to avoid empty translation unit warning */
-int g_ZSTD_threading_useless_symbol;
-
-} // namespace duckdb_zstd
-
-#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
-
-/**
- * Windows minimalist Pthread Wrapper
- */
-
-
-/* ===  Dependencies  === */
-#include <process.h>
-#include <errno.h>
-
-namespace duckdb_zstd {
-
-/* ===  Implementation  === */
-
-typedef struct {
-    void* (*start_routine)(void*);
-    void* arg;
-    int initialized;
-    ZSTD_pthread_cond_t initialized_cond;
-    ZSTD_pthread_mutex_t initialized_mutex;
-} ZSTD_thread_params_t;
-
-static unsigned __stdcall worker(void *arg)
-{
-    void* (*start_routine)(void*);
-    void* thread_arg;
-
-    /* Initialized thread_arg and start_routine and signal main thread that we don't need it
-     * to wait any longer.
-     */
-    {
-        ZSTD_thread_params_t*  thread_param = (ZSTD_thread_params_t*)arg;
-        thread_arg = thread_param->arg;
-        start_routine = thread_param->start_routine;
-
-        /* Signal main thread that we are running and do not depend on its memory anymore */
-        ZSTD_pthread_mutex_lock(&thread_param->initialized_mutex);
-        thread_param->initialized = 1;
-        ZSTD_pthread_cond_signal(&thread_param->initialized_cond);
-        ZSTD_pthread_mutex_unlock(&thread_param->initialized_mutex);
-    }
-
-    start_routine(thread_arg);
-
-    return 0;
-}
-
-int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
-            void* (*start_routine) (void*), void* arg)
-{
-    ZSTD_thread_params_t thread_param;
-    (void)unused;
-
-    if (thread==NULL) return -1;
-    *thread = NULL;
-
-    thread_param.start_routine = start_routine;
-    thread_param.arg = arg;
-    thread_param.initialized = 0;
-
-    /* Setup thread initialization synchronization */
-    if(ZSTD_pthread_cond_init(&thread_param.initialized_cond, NULL)) {
-        /* Should never happen on Windows */
-        return -1;
-    }
-    if(ZSTD_pthread_mutex_init(&thread_param.initialized_mutex, NULL)) {
-        /* Should never happen on Windows */
-        ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
-        return -1;
-    }
-
-    /* Spawn thread */
-    *thread = (HANDLE)_beginthreadex(NULL, 0, worker, &thread_param, 0, NULL);
-    if (*thread==NULL) {
-        ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);
-        ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
-        return errno;
-    }
-
-    /* Wait for thread to be initialized */
-    ZSTD_pthread_mutex_lock(&thread_param.initialized_mutex);
-    while(!thread_param.initialized) {
-        ZSTD_pthread_cond_wait(&thread_param.initialized_cond, &thread_param.initialized_mutex);
-    }
-    ZSTD_pthread_mutex_unlock(&thread_param.initialized_mutex);
-    ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);
-    ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
-
-    return 0;
-}
-
-int ZSTD_pthread_join(ZSTD_pthread_t thread)
-{
-    DWORD result;
-
-    if (!thread) return 0;
-
-    result = WaitForSingleObject(thread, INFINITE);
-    CloseHandle(thread);
-
-    switch (result) {
-    case WAIT_OBJECT_0:
-        return 0;
-    case WAIT_ABANDONED:
-        return EINVAL;
-    default:
-        return GetLastError();
-    }
-}
-
-} // namespace duckdb_zstd
-
-#endif   /* ZSTD_MULTITHREAD */
-
-#if defined(ZSTD_MULTITHREAD) && DEBUGLEVEL >= 1 && !defined(_WIN32)
-
-#define ZSTD_DEPS_NEED_MALLOC
-#include "zstd/common/zstd_deps.h"
-
-namespace duckdb_zstd {
-
-int ZSTD_pthread_mutex_init(ZSTD_pthread_mutex_t* mutex, pthread_mutexattr_t const* attr)
-{
-    assert(mutex != NULL);
-    *mutex = (pthread_mutex_t*)ZSTD_malloc(sizeof(pthread_mutex_t));
-    if (!*mutex)
-        return 1;
-    return pthread_mutex_init(*mutex, attr);
-}
-
-int ZSTD_pthread_mutex_destroy(ZSTD_pthread_mutex_t* mutex)
-{
-    assert(mutex != NULL);
-    if (!*mutex)
-        return 0;
-    {
-        int const ret = pthread_mutex_destroy(*mutex);
-        ZSTD_free(*mutex);
-        return ret;
-    }
-}
-
-int ZSTD_pthread_cond_init(ZSTD_pthread_cond_t* cond, pthread_condattr_t const* attr)
-{
-    assert(cond != NULL);
-    *cond = (pthread_cond_t*)ZSTD_malloc(sizeof(pthread_cond_t));
-    if (!*cond)
-        return 1;
-    return pthread_cond_init(*cond, attr);
-}
-
-int ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond)
-{
-    assert(cond != NULL);
-    if (!*cond)
-        return 0;
-    {
-        int const ret = pthread_cond_destroy(*cond);
-        ZSTD_free(*cond);
-        return ret;
-    }
-}
-
-} // namespace duckdb_zstd
-
-#endif
diff --git a/src/duckdb/third_party/zstd/common/xxhash.cpp b/src/duckdb/third_party/zstd/common/xxhash.cpp
deleted file mode 100644
index fc4d18b2e..000000000
--- a/src/duckdb/third_party/zstd/common/xxhash.cpp
+++ /dev/null
@@ -1,863 +0,0 @@
-/*
- *  xxHash - Fast Hash algorithm
- *  Copyright (c) 2012-2020, Yann Collet, Facebook, Inc.
- *
- *  You can contact the author at :
- *  - xxHash homepage: http://www.xxhash.com
- *  - xxHash source repository : https://github.com/Cyan4973/xxHash
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-*/
-
-
-/* *************************************
-*  Tuning parameters
-***************************************/
-/*!XXH_FORCE_MEMORY_ACCESS :
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
- *            It can generate buggy code on targets which do not support unaligned memory accesses.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://stackoverflow.com/a/32095106/646947 for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define XXH_FORCE_MEMORY_ACCESS 2
-#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
-  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) || \
-  defined(__ICCARM__)
-#    define XXH_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*!XXH_ACCEPT_NULL_INPUT_POINTER :
- * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
- * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
- * By default, this option is disabled. To enable it, uncomment below define :
- */
-/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */
-
-/*!XXH_FORCE_NATIVE_FORMAT :
- * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
- * Results are therefore identical for little-endian and big-endian CPU.
- * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
- * Should endian-independence be of no importance for your application, you may set the #define below to 1,
- * to improve speed for Big-endian CPU.
- * This option has no impact on Little_Endian CPU.
- */
-#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */
-#  define XXH_FORCE_NATIVE_FORMAT 0
-#endif
-
-/*!XXH_FORCE_ALIGN_CHECK :
- * This is a minor performance trick, only useful with lots of very small keys.
- * It means : check for aligned/unaligned input.
- * The check costs one initial branch per hash; set to 0 when the input data
- * is guaranteed to be aligned.
- */
-#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
-#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#    define XXH_FORCE_ALIGN_CHECK 0
-#  else
-#    define XXH_FORCE_ALIGN_CHECK 1
-#  endif
-#endif
-
-
-/* *************************************
-*  Includes & Memory related functions
-***************************************/
-/* Modify the local functions below should you wish to use some other memory routines */
-/* for malloc(), free() */
-#include <stdlib.h>
-#include <stddef.h>     /* size_t */
-/* for memcpy() */
-#include <string.h>
-
-#include "zstd/common/xxhash.hpp"
-#include "zstd/common/xxhash_static.hpp"
-
-/* *************************************
-*  Compiler Specific Options
-***************************************/
-#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#  define INLINE_KEYWORD inline
-#else
-#  define INLINE_KEYWORD
-#endif
-
-#if defined(__GNUC__) || defined(__ICCARM__)
-#  define FORCE_INLINE_ATTR __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#  define FORCE_INLINE_ATTR __forceinline
-#else
-#  define FORCE_INLINE_ATTR
-#endif
-
-// DuckDB: prefixed with XXHASH_ to avoid name conflicts
-#define XXHASH_FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
-
-
-/* *************************************
-*  Basic Types
-***************************************/
-#ifndef MEM_MODULE
-# define MEM_MODULE
-# if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-    typedef uint8_t  BYTE;
-    typedef uint16_t U16;
-    typedef uint32_t U32;
-    typedef  int32_t S32;
-    typedef uint64_t U64;
-#  else
-    typedef unsigned char      BYTE;
-    typedef unsigned short     U16;
-    typedef unsigned int       U32;
-    typedef   signed int       S32;
-    typedef unsigned long long U64;   /* if your compiler doesn't support unsigned long long, replace by another 64-bit type here. Note that xxhash.h will also need to be updated. */
-#  endif
-#endif
-
-namespace duckdb_zstd {
-static void* XXH_malloc(size_t s) { return malloc(s); }
-static void  XXH_free  (void* p)  { free(p); }
-static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
-
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; }
-static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign;
-
-static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-static U64 XXH_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-
-static U32 XXH_read32(const void* memPtr)
-{
-    U32 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-static U64 XXH_read64(const void* memPtr)
-{
-    U64 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-} // namespace duckdb_zstd
-
-/* ****************************************
-*  Compiler-specific Functions and Macros
-******************************************/
-#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-
-/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
-#if defined(_MSC_VER)
-#  define XXH_rotl32(x,r) _rotl(x,r)
-#  define XXH_rotl64(x,r) _rotl64(x,r)
-#else
-#if defined(__ICCARM__)
-#  include <intrinsics.h>
-#  define XXH_rotl32(x,r) __ROR(x,(32 - r))
-#else
-#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
-#endif
-#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
-#endif
-
-namespace duckdb_zstd {
-
-#if defined(_MSC_VER)     /* Visual Studio */
-#  define XXH_swap32 _byteswap_ulong
-#  define XXH_swap64 _byteswap_uint64
-#elif GCC_VERSION >= 403
-#  define XXH_swap32 __builtin_bswap32
-#  define XXH_swap64 __builtin_bswap64
-#else
-static U32 XXH_swap32 (U32 x)
-{
-    return  ((x << 24) & 0xff000000 ) |
-            ((x <<  8) & 0x00ff0000 ) |
-            ((x >>  8) & 0x0000ff00 ) |
-            ((x >> 24) & 0x000000ff );
-}
-static U64 XXH_swap64 (U64 x)
-{
-    return  ((x << 56) & 0xff00000000000000ULL) |
-            ((x << 40) & 0x00ff000000000000ULL) |
-            ((x << 24) & 0x0000ff0000000000ULL) |
-            ((x << 8)  & 0x000000ff00000000ULL) |
-            ((x >> 8)  & 0x00000000ff000000ULL) |
-            ((x >> 24) & 0x0000000000ff0000ULL) |
-            ((x >> 40) & 0x000000000000ff00ULL) |
-            ((x >> 56) & 0x00000000000000ffULL);
-}
-#endif
-
-
-/* *************************************
-*  Architecture Macros
-***************************************/
-typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
-
-/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
-#ifndef XXH_CPU_LITTLE_ENDIAN
-    static const int g_one = 1;
-#   define XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))
-#endif
-
-
-/* ***************************
-*  Memory reads
-*****************************/
-typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
-
-XXHASH_FORCE_INLINE_TEMPLATE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
-}
-
-XXHASH_FORCE_INLINE_TEMPLATE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
-{
-    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
-}
-
-static U32 XXH_readBE32(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
-}
-
-XXHASH_FORCE_INLINE_TEMPLATE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
-}
-
-XXHASH_FORCE_INLINE_TEMPLATE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
-{
-    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
-}
-
-static U64 XXH_readBE64(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
-}
-
-
-/* *************************************
-*  Macros
-***************************************/
-#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }    /* use only *after* variable declarations */
-
-
-/* *************************************
-*  Constants
-***************************************/
-static const U32 PRIME32_1 = 2654435761U;
-static const U32 PRIME32_2 = 2246822519U;
-static const U32 PRIME32_3 = 3266489917U;
-static const U32 PRIME32_4 =  668265263U;
-static const U32 PRIME32_5 =  374761393U;
-
-static const U64 PRIME64_1 = 11400714785074694791ULL;
-static const U64 PRIME64_2 = 14029467366897019727ULL;
-static const U64 PRIME64_3 =  1609587929392839161ULL;
-static const U64 PRIME64_4 =  9650029242287828579ULL;
-static const U64 PRIME64_5 =  2870177450012600261ULL;
-
-XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
-
-
-/* **************************
-*  Utils
-****************************/
-XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* __restrict dstState, const XXH32_state_t* __restrict srcState)
-{
-    memcpy(dstState, srcState, sizeof(*dstState));
-}
-
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* __restrict dstState, const XXH64_state_t* __restrict srcState)
-{
-    memcpy(dstState, srcState, sizeof(*dstState));
-}
-
-
-/* ***************************
-*  Simple Hash Functions
-*****************************/
-
-static U32 XXH32_round(U32 seed, U32 input)
-{
-    seed += input * PRIME32_2;
-    seed  = XXH_rotl32(seed, 13);
-    seed *= PRIME32_1;
-    return seed;
-}
-
-XXHASH_FORCE_INLINE_TEMPLATE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* bEnd = p + len;
-    U32 h32;
-#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)16;
-    }
-#endif
-
-    if (len>=16) {
-        const BYTE* const limit = bEnd - 16;
-        U32 v1 = seed + PRIME32_1 + PRIME32_2;
-        U32 v2 = seed + PRIME32_2;
-        U32 v3 = seed + 0;
-        U32 v4 = seed - PRIME32_1;
-
-        do {
-            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
-            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
-            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
-            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
-        } while (p<=limit);
-
-        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
-    } else {
-        h32  = seed + PRIME32_5;
-    }
-
-    h32 += (U32) len;
-
-    while (p+4<=bEnd) {
-        h32 += XXH_get32bits(p) * PRIME32_3;
-        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h32 += (*p) * PRIME32_5;
-        h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
-        p++;
-    }
-
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-
-    return h32;
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH32_CREATESTATE_STATIC(state);
-    XXH32_reset(state, seed);
-    XXH32_update(state, input, len);
-    return XXH32_digest(state);
-#else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-
-static U64 XXH64_round(U64 acc, U64 input)
-{
-    acc += input * PRIME64_2;
-    acc  = XXH_rotl64(acc, 31);
-    acc *= PRIME64_1;
-    return acc;
-}
-
-static U64 XXH64_mergeRound(U64 acc, U64 val)
-{
-    val  = XXH64_round(0, val);
-    acc ^= val;
-    acc  = acc * PRIME64_1 + PRIME64_4;
-    return acc;
-}
-
-XXHASH_FORCE_INLINE_TEMPLATE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
-    U64 h64;
-#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)32;
-    }
-#endif
-
-    if (len>=32) {
-        const BYTE* const limit = bEnd - 32;
-        U64 v1 = seed + PRIME64_1 + PRIME64_2;
-        U64 v2 = seed + PRIME64_2;
-        U64 v3 = seed + 0;
-        U64 v4 = seed - PRIME64_1;
-
-        do {
-            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
-            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
-            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
-            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
-        } while (p<=limit);
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-
-    } else {
-        h64  = seed + PRIME64_5;
-    }
-
-    h64 += (U64) len;
-
-    while (p+8<=bEnd) {
-        U64 const k1 = XXH64_round(0, XXH_get64bits(p));
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-        p+=8;
-    }
-
-    if (p+4<=bEnd) {
-        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
-        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h64 ^= (*p) * PRIME64_5;
-        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
-        p++;
-    }
-
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-
-    return h64;
-}
-
-
-XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH64_CREATESTATE_STATIC(state);
-    XXH64_reset(state, seed);
-    XXH64_update(state, input, len);
-    return XXH64_digest(state);
-#else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-
-/* **************************************************
-*  Advanced Hash Functions
-****************************************************/
-
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
-{
-    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
-{
-    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-
-/*** Hash feed ***/
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
-{
-    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state)-4);   /* do not write into reserved, for future removal */
-    state.v1 = seed + PRIME32_1 + PRIME32_2;
-    state.v2 = seed + PRIME32_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME32_1;
-    memcpy(statePtr, &state, sizeof(state));
-    return XXH_OK;
-}
-
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
-{
-    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state)-8);   /* do not write into reserved, for future removal */
-    state.v1 = seed + PRIME64_1 + PRIME64_2;
-    state.v2 = seed + PRIME64_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME64_1;
-    memcpy(statePtr, &state, sizeof(state));
-    return XXH_OK;
-}
-
-
-XXHASH_FORCE_INLINE_TEMPLATE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (input==NULL) return XXH_ERROR;
-#endif
-
-    state->total_len_32 += (unsigned)len;
-    state->large_len |= (len>=16) | (state->total_len_32>=16);
-
-    if (state->memsize + len < 16)  {   /* fill in tmp buffer */
-        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
-        state->memsize += (unsigned)len;
-        return XXH_OK;
-    }
-
-    if (state->memsize) {   /* some data left from previous update */
-        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
-        {   const U32* p32 = state->mem32;
-            state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
-            state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
-            state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
-            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++;
-        }
-        p += 16-state->memsize;
-        state->memsize = 0;
-    }
-
-    if (p <= bEnd-16) {
-        const BYTE* const limit = bEnd - 16;
-        U32 v1 = state->v1;
-        U32 v2 = state->v2;
-        U32 v3 = state->v3;
-        U32 v4 = state->v4;
-
-        do {
-            v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
-            v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
-            v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
-            v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
-        } while (p<=limit);
-
-        state->v1 = v1;
-        state->v2 = v2;
-        state->v3 = v3;
-        state->v4 = v4;
-    }
-
-    if (p < bEnd) {
-        XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
-        state->memsize = (unsigned)(bEnd-p);
-    }
-
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-
-
-XXHASH_FORCE_INLINE_TEMPLATE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
-{
-    const BYTE * p = (const BYTE*)state->mem32;
-    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
-    U32 h32;
-
-    if (state->large_len) {
-        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
-    } else {
-        h32 = state->v3 /* == seed */ + PRIME32_5;
-    }
-
-    h32 += state->total_len_32;
-
-    while (p+4<=bEnd) {
-        h32 += XXH_readLE32(p, endian) * PRIME32_3;
-        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h32 += (*p) * PRIME32_5;
-        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
-        p++;
-    }
-
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-
-    return h32;
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH32_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-
-/* **** XXH64 **** */
-
-XXHASH_FORCE_INLINE_TEMPLATE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (input==NULL) return XXH_ERROR;
-#endif
-
-    state->total_len += len;
-
-    if (state->memsize + len < 32) {  /* fill in tmp buffer */
-        if (input != NULL) {
-            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
-        }
-        state->memsize += (U32)len;
-        return XXH_OK;
-    }
-
-    if (state->memsize) {   /* tmp buffer is full */
-        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
-        state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
-        state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
-        state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
-        state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
-        p += 32-state->memsize;
-        state->memsize = 0;
-    }
-
-    if (p+32 <= bEnd) {
-        const BYTE* const limit = bEnd - 32;
-        U64 v1 = state->v1;
-        U64 v2 = state->v2;
-        U64 v3 = state->v3;
-        U64 v4 = state->v4;
-
-        do {
-            v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
-            v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
-            v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
-            v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
-        } while (p<=limit);
-
-        state->v1 = v1;
-        state->v2 = v2;
-        state->v3 = v3;
-        state->v4 = v4;
-    }
-
-    if (p < bEnd) {
-        XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
-        state->memsize = (unsigned)(bEnd-p);
-    }
-
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-
-
-XXHASH_FORCE_INLINE_TEMPLATE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
-{
-    const BYTE * p = (const BYTE*)state->mem64;
-    const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
-    U64 h64;
-
-    if (state->total_len >= 32) {
-        U64 const v1 = state->v1;
-        U64 const v2 = state->v2;
-        U64 const v3 = state->v3;
-        U64 const v4 = state->v4;
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-    } else {
-        h64  = state->v3 + PRIME64_5;
-    }
-
-    h64 += (U64) state->total_len;
-
-    while (p+8<=bEnd) {
-        U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian));
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-        p+=8;
-    }
-
-    if (p+4<=bEnd) {
-        h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1;
-        h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h64 ^= (*p) * PRIME64_5;
-        h64  = XXH_rotl64(h64, 11) * PRIME64_1;
-        p++;
-    }
-
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-
-    return h64;
-}
-
-
-XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH64_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-/* **************************
-*  Canonical representation
-****************************/
-
-/*! Default XXH result types are basic unsigned 32 and 64 bits.
-*   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
-*   These functions allow transformation of hash result into and from its canonical format.
-*   This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs.
-*/
-
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
-{
-    return XXH_readBE32(src);
-}
-
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
-{
-    return XXH_readBE64(src);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/common/zstd_common.cpp b/src/duckdb/third_party/zstd/common/zstd_common.cpp
deleted file mode 100644
index e36727c0a..000000000
--- a/src/duckdb/third_party/zstd/common/zstd_common.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#define ZSTD_DEPS_NEED_MALLOC
-#include "zstd/common/error_private.h"
-#include "zstd/common/zstd_internal.h"
-
-namespace duckdb_zstd {
-
-/*-****************************************
-*  Version
-******************************************/
-unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; }
-
-const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
-
-
-/*-****************************************
-*  ZSTD Error Management
-******************************************/
-#undef ZSTD_isError   /* defined within zstd_internal.h */
-/*! ZSTD_isError() :
- *  tells if a return value is an error code
- *  symbol is required for external callers */
-unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
-
-/*! ZSTD_getErrorName() :
- *  provides error code string from function result (useful for debugging) */
-const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-/*! ZSTD_getError() :
- *  convert a `size_t` function result into a proper ZSTD_errorCode enum */
-ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
-
-/*! ZSTD_getErrorString() :
- *  provides error code string from enum */
-const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/fse_compress.cpp b/src/duckdb/third_party/zstd/compress/fse_compress.cpp
deleted file mode 100644
index 495377f9f..000000000
--- a/src/duckdb/third_party/zstd/compress/fse_compress.cpp
+++ /dev/null
@@ -1,628 +0,0 @@
-/* ******************************************************************
- * FSE : Finite State Entropy encoder
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* **************************************************************
-*  Includes
-****************************************************************/
-#include "zstd/common/compiler.h"
-#include "zstd/common/mem.h"        /* U32, U16, etc. */
-#include "zstd/common/debug.h"      /* assert, DEBUGLOG */
-#include "zstd/compress/hist.h"       /* HIST_count_wksp */
-#include "zstd/common/bitstream.h"
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-#include "zstd/common/error_private.h"
-#define ZSTD_DEPS_NEED_MALLOC
-#define ZSTD_DEPS_NEED_MATH64
-#include "zstd/common/zstd_deps.h"  /* ZSTD_memset */
-#include "zstd/common/bits.h" /* ZSTD_highbit32 */
-
-namespace duckdb_zstd {
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_isError ERR_isError
-
-
-/* **************************************************************
-*  Templates
-****************************************************************/
-/*
-  designed to be included
-  for type-specific functions (template emulation in C)
-  Objective is to write these functions only once, for improved maintenance
-*/
-
-/* safety checks */
-#ifndef FSE_FUNCTION_EXTENSION
-#  error "FSE_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSE_FUNCTION_TYPE
-#  error "FSE_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSE_CAT(X,Y) X##Y
-#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
-#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
-
-
-/* Function templates */
-
-/* FSE_buildCTable_wksp() :
- * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
- * wkspSize should be sized to handle worst case situation, which is `1<<max_tableLog * sizeof(FSE_FUNCTION_TYPE)`
- * workSpace must also be properly aligned with FSE_FUNCTION_TYPE requirements
- */
-size_t FSE_buildCTable_wksp(FSE_CTable* ct,
-                      const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
-                            void* workSpace, size_t wkspSize)
-{
-    U32 const tableSize = 1 << tableLog;
-    U32 const tableMask = tableSize - 1;
-    void* const ptr = ct;
-    U16* const tableU16 = ( (U16*) ptr) + 2;
-    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableLog ? tableSize>>1 : 1) ;
-    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
-    U32 const step = FSE_TABLESTEP(tableSize);
-    U32 const maxSV1 = maxSymbolValue+1;
-
-    U16* cumul = (U16*)workSpace;   /* size = maxSV1 */
-    FSE_FUNCTION_TYPE* const tableSymbol = (FSE_FUNCTION_TYPE*)(cumul + (maxSV1+1));  /* size = tableSize */
-
-    U32 highThreshold = tableSize-1;
-
-    assert(((size_t)workSpace & 1) == 0);  /* Must be 2 bytes-aligned */
-    if (FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSymbolValue, tableLog) > wkspSize) return ERROR(tableLog_tooLarge);
-    /* CTable header */
-    tableU16[-2] = (U16) tableLog;
-    tableU16[-1] = (U16) maxSymbolValue;
-    assert(tableLog < 16);   /* required for threshold strategy to work */
-
-    /* For explanations on how to distribute symbol values over the table :
-     * https://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
-
-     #ifdef __clang_analyzer__
-     ZSTD_memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize);   /* useless initialization, just to keep scan-build happy */
-     #endif
-
-    /* symbol start positions */
-    {   U32 u;
-        cumul[0] = 0;
-        for (u=1; u <= maxSV1; u++) {
-            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */
-                cumul[u] = cumul[u-1] + 1;
-                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
-            } else {
-                assert(normalizedCounter[u-1] >= 0);
-                cumul[u] = cumul[u-1] + (U16)normalizedCounter[u-1];
-                assert(cumul[u] >= cumul[u-1]);  /* no overflow */
-        }   }
-        cumul[maxSV1] = (U16)(tableSize+1);
-    }
-
-    /* Spread symbols */
-    if (highThreshold == tableSize - 1) {
-        /* Case for no low prob count symbols. Lay down 8 bytes at a time
-         * to reduce branch misses since we are operating on a small block
-         */
-        BYTE* const spread = tableSymbol + tableSize; /* size = tableSize + 8 (may write beyond tableSize) */
-        {   U64 const add = 0x0101010101010101ull;
-            size_t pos = 0;
-            U64 sv = 0;
-            U32 s;
-            for (s=0; s<maxSV1; ++s, sv += add) {
-                int i;
-                int const n = normalizedCounter[s];
-                MEM_write64(spread + pos, sv);
-                for (i = 8; i < n; i += 8) {
-                    MEM_write64(spread + pos + i, sv);
-                }
-                assert(n>=0);
-                pos += (size_t)n;
-            }
-        }
-        /* Spread symbols across the table. Lack of lowprob symbols means that
-         * we don't need variable sized inner loop, so we can unroll the loop and
-         * reduce branch misses.
-         */
-        {   size_t position = 0;
-            size_t s;
-            size_t const unroll = 2; /* Experimentally determined optimal unroll */
-            assert(tableSize % unroll == 0); /* FSE_MIN_TABLELOG is 5 */
-            for (s = 0; s < (size_t)tableSize; s += unroll) {
-                size_t u;
-                for (u = 0; u < unroll; ++u) {
-                    size_t const uPosition = (position + (u * step)) & tableMask;
-                    tableSymbol[uPosition] = spread[s + u];
-                }
-                position = (position + (unroll * step)) & tableMask;
-            }
-            assert(position == 0);   /* Must have initialized all positions */
-        }
-    } else {
-        U32 position = 0;
-        U32 symbol;
-        for (symbol=0; symbol<maxSV1; symbol++) {
-            int nbOccurrences;
-            int const freq = normalizedCounter[symbol];
-            for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) {
-                tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
-                position = (position + step) & tableMask;
-                while (position > highThreshold)
-                    position = (position + step) & tableMask;   /* Low proba area */
-        }   }
-        assert(position==0);  /* Must have initialized all positions */
-    }
-
-    /* Build table */
-    {   U32 u; for (u=0; u<tableSize; u++) {
-        FSE_FUNCTION_TYPE s = tableSymbol[u];   /* note : static analyzer may not understand tableSymbol is properly initialized */
-        tableU16[cumul[s]++] = (U16) (tableSize+u);   /* TableU16 : sorted by symbol order; gives next state value */
-    }   }
-
-    /* Build Symbol Transformation Table */
-    {   unsigned total = 0;
-        unsigned s;
-        for (s=0; s<=maxSymbolValue; s++) {
-            switch (normalizedCounter[s])
-            {
-            case  0:
-                /* filling nonetheless, for compatibility with FSE_getMaxNbBits() */
-                symbolTT[s].deltaNbBits = ((tableLog+1) << 16) - (1<<tableLog);
-                break;
-
-            case -1:
-            case  1:
-                symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog);
-                assert(total <= INT_MAX);
-                symbolTT[s].deltaFindState = (int)(total - 1);
-                total ++;
-                break;
-            default :
-                assert(normalizedCounter[s] > 1);
-                {   U32 const maxBitsOut = tableLog - ZSTD_highbit32 ((U32)normalizedCounter[s]-1);
-                    U32 const minStatePlus = (U32)normalizedCounter[s] << maxBitsOut;
-                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
-                    symbolTT[s].deltaFindState = (int)(total - (unsigned)normalizedCounter[s]);
-                    total +=  (unsigned)normalizedCounter[s];
-    }   }   }   }
-
-#if 0  /* debug : symbol costs */
-    DEBUGLOG(5, "\n --- table statistics : ");
-    {   U32 symbol;
-        for (symbol=0; symbol<=maxSymbolValue; symbol++) {
-            DEBUGLOG(5, "%3u: w=%3i,   maxBits=%u, fracBits=%.2f",
-                symbol, normalizedCounter[symbol],
-                FSE_getMaxNbBits(symbolTT, symbol),
-                (double)FSE_bitCost(symbolTT, tableLog, symbol, 8) / 256);
-    }   }
-#endif
-
-    return 0;
-}
-
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/*-**************************************************************
-*  FSE NCount encoding
-****************************************************************/
-size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
-{
-    size_t const maxHeaderSize = (((maxSymbolValue+1) * tableLog
-                                   + 4 /* bitCount initialized at 4 */
-                                   + 2 /* first two symbols may use one additional bit each */) / 8)
-                                   + 1 /* round up to whole nb bytes */
-                                   + 2 /* additional two bytes for bitstream flush */;
-    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */
-}
-
-static size_t
-FSE_writeNCount_generic (void* header, size_t headerBufferSize,
-                   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
-                         unsigned writeIsSafe)
-{
-    BYTE* const ostart = (BYTE*) header;
-    BYTE* out = ostart;
-    BYTE* const oend = ostart + headerBufferSize;
-    int nbBits;
-    const int tableSize = 1 << tableLog;
-    int remaining;
-    int threshold;
-    U32 bitStream = 0;
-    int bitCount = 0;
-    unsigned symbol = 0;
-    unsigned const alphabetSize = maxSymbolValue + 1;
-    int previousIs0 = 0;
-
-    /* Table Size */
-    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;
-    bitCount  += 4;
-
-    /* Init */
-    remaining = tableSize+1;   /* +1 for extra accuracy */
-    threshold = tableSize;
-    nbBits = (int)tableLog+1;
-
-    while ((symbol < alphabetSize) && (remaining>1)) {  /* stops at 1 */
-        if (previousIs0) {
-            unsigned start = symbol;
-            while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++;
-            if (symbol == alphabetSize) break;   /* incorrect distribution */
-            while (symbol >= start+24) {
-                start+=24;
-                bitStream += 0xFFFFU << bitCount;
-                if ((!writeIsSafe) && (out > oend-2))
-                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-                out[0] = (BYTE) bitStream;
-                out[1] = (BYTE)(bitStream>>8);
-                out+=2;
-                bitStream>>=16;
-            }
-            while (symbol >= start+3) {
-                start+=3;
-                bitStream += 3U << bitCount;
-                bitCount += 2;
-            }
-            bitStream += (symbol-start) << bitCount;
-            bitCount += 2;
-            if (bitCount>16) {
-                if ((!writeIsSafe) && (out > oend - 2))
-                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-                out[0] = (BYTE)bitStream;
-                out[1] = (BYTE)(bitStream>>8);
-                out += 2;
-                bitStream >>= 16;
-                bitCount -= 16;
-        }   }
-        {   int count = normalizedCounter[symbol++];
-            int const max = (2*threshold-1) - remaining;
-            remaining -= count < 0 ? -count : count;
-            count++;   /* +1 for extra accuracy */
-            if (count>=threshold)
-                count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
-            bitStream += (U32)count << bitCount;
-            bitCount  += nbBits;
-            bitCount  -= (count<max);
-            previousIs0  = (count==1);
-            if (remaining<1) return ERROR(GENERIC);
-            while (remaining<threshold) { nbBits--; threshold>>=1; }
-        }
-        if (bitCount>16) {
-            if ((!writeIsSafe) && (out > oend - 2))
-                return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-            out[0] = (BYTE)bitStream;
-            out[1] = (BYTE)(bitStream>>8);
-            out += 2;
-            bitStream >>= 16;
-            bitCount -= 16;
-    }   }
-
-    if (remaining != 1)
-        return ERROR(GENERIC);  /* incorrect normalized distribution */
-    assert(symbol <= alphabetSize);
-
-    /* flush remaining bitStream */
-    if ((!writeIsSafe) && (out > oend - 2))
-        return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-    out[0] = (BYTE)bitStream;
-    out[1] = (BYTE)(bitStream>>8);
-    out+= (bitCount+7) /8;
-
-    assert(out >= ostart);
-    return (size_t)(out-ostart);
-}
-
-
-size_t FSE_writeNCount (void* buffer, size_t bufferSize,
-                  const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */
-    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */
-
-    if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
-        return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);
-
-    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);
-}
-
-
-/*-**************************************************************
-*  FSE Compression Code
-****************************************************************/
-
-/* provides the minimum logSize to safely represent a distribution */
-static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)
-{
-    U32 minBitsSrc = ZSTD_highbit32((U32)(srcSize)) + 1;
-    U32 minBitsSymbols = ZSTD_highbit32(maxSymbolValue) + 2;
-    U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
-    assert(srcSize > 1); /* Not supported, RLE should be used instead */
-    return minBits;
-}
-
-unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
-{
-    U32 maxBitsSrc = ZSTD_highbit32((U32)(srcSize - 1)) - minus;
-    U32 tableLog = maxTableLog;
-    U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
-    assert(srcSize > 1); /* Not supported, RLE should be used instead */
-    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
-    if (maxBitsSrc < tableLog) tableLog = maxBitsSrc;   /* Accuracy can be reduced */
-    if (minBits > tableLog) tableLog = minBits;   /* Need a minimum to safely represent all symbol values */
-    if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;
-    if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;
-    return tableLog;
-}
-
-unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
-{
-    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);
-}
-
-/* Secondary normalization method.
-   To be used when primary method fails. */
-
-static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count, size_t total, U32 maxSymbolValue, short lowProbCount)
-{
-    short const NOT_YET_ASSIGNED = -2;
-    U32 s;
-    U32 distributed = 0;
-    U32 ToDistribute;
-
-    /* Init */
-    U32 const lowThreshold = (U32)(total >> tableLog);
-    U32 lowOne = (U32)((total * 3) >> (tableLog + 1));
-
-    for (s=0; s<=maxSymbolValue; s++) {
-        if (count[s] == 0) {
-            norm[s]=0;
-            continue;
-        }
-        if (count[s] <= lowThreshold) {
-            norm[s] = lowProbCount;
-            distributed++;
-            total -= count[s];
-            continue;
-        }
-        if (count[s] <= lowOne) {
-            norm[s] = 1;
-            distributed++;
-            total -= count[s];
-            continue;
-        }
-
-        norm[s]=NOT_YET_ASSIGNED;
-    }
-    ToDistribute = (1 << tableLog) - distributed;
-
-    if (ToDistribute == 0)
-        return 0;
-
-    if ((total / ToDistribute) > lowOne) {
-        /* risk of rounding to zero */
-        lowOne = (U32)((total * 3) / (ToDistribute * 2));
-        for (s=0; s<=maxSymbolValue; s++) {
-            if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) {
-                norm[s] = 1;
-                distributed++;
-                total -= count[s];
-                continue;
-        }   }
-        ToDistribute = (1 << tableLog) - distributed;
-    }
-
-    if (distributed == maxSymbolValue+1) {
-        /* all values are pretty poor;
-           probably incompressible data (should have already been detected);
-           find max, then give all remaining points to max */
-        U32 maxV = 0, maxC = 0;
-        for (s=0; s<=maxSymbolValue; s++)
-            if (count[s] > maxC) { maxV=s; maxC=count[s]; }
-        norm[maxV] += (short)ToDistribute;
-        return 0;
-    }
-
-    if (total == 0) {
-        /* all of the symbols were low enough for the lowOne or lowThreshold */
-        for (s=0; ToDistribute > 0; s = (s+1)%(maxSymbolValue+1))
-            if (norm[s] > 0) { ToDistribute--; norm[s]++; }
-        return 0;
-    }
-
-    {   U64 const vStepLog = 62 - tableLog;
-        U64 const mid = (1ULL << (vStepLog-1)) - 1;
-        U64 const rStep = ZSTD_div64((((U64)1<<vStepLog) * ToDistribute) + mid, (U32)total);   /* scale on remaining */
-        U64 tmpTotal = mid;
-        for (s=0; s<=maxSymbolValue; s++) {
-            if (norm[s]==NOT_YET_ASSIGNED) {
-                U64 const end = tmpTotal + (count[s] * rStep);
-                U32 const sStart = (U32)(tmpTotal >> vStepLog);
-                U32 const sEnd = (U32)(end >> vStepLog);
-                U32 const weight = sEnd - sStart;
-                if (weight < 1)
-                    return ERROR(GENERIC);
-                norm[s] = (short)weight;
-                tmpTotal = end;
-    }   }   }
-
-    return 0;
-}
-
-size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
-                           const unsigned* count, size_t total,
-                           unsigned maxSymbolValue, unsigned useLowProbCount)
-{
-    /* Sanity checks */
-    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
-    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported size */
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported size */
-    if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC);   /* Too small tableLog, compression potentially impossible */
-
-    {   static U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };
-        short const lowProbCount = useLowProbCount ? -1 : 1;
-        U64 const scale = 62 - tableLog;
-        U64 const step = ZSTD_div64((U64)1<<62, (U32)total);   /* <== here, one division ! */
-        U64 const vStep = 1ULL<<(scale-20);
-        int stillToDistribute = 1<<tableLog;
-        unsigned s;
-        unsigned largest=0;
-        short largestP=0;
-        U32 lowThreshold = (U32)(total >> tableLog);
-
-        for (s=0; s<=maxSymbolValue; s++) {
-            if (count[s] == total) return 0;   /* rle special case */
-            if (count[s] == 0) { normalizedCounter[s]=0; continue; }
-            if (count[s] <= lowThreshold) {
-                normalizedCounter[s] = lowProbCount;
-                stillToDistribute--;
-            } else {
-                short proba = (short)((count[s]*step) >> scale);
-                if (proba<8) {
-                    U64 restToBeat = vStep * rtbTable[proba];
-                    proba += (count[s]*step) - ((U64)proba<<scale) > restToBeat;
-                }
-                if (proba > largestP) { largestP=proba; largest=s; }
-                normalizedCounter[s] = proba;
-                stillToDistribute -= proba;
-        }   }
-        if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {
-            /* corner case, need another normalization method */
-            size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue, lowProbCount);
-            if (FSE_isError(errorCode)) return errorCode;
-        }
-        else normalizedCounter[largest] += (short)stillToDistribute;
-    }
-
-#if 0
-    {   /* Print Table (debug) */
-        U32 s;
-        U32 nTotal = 0;
-        for (s=0; s<=maxSymbolValue; s++)
-            RAWLOG(2, "%3i: %4i \n", s, normalizedCounter[s]);
-        for (s=0; s<=maxSymbolValue; s++)
-            nTotal += abs(normalizedCounter[s]);
-        if (nTotal != (1U<<tableLog))
-            RAWLOG(2, "Warning !!! Total == %u != %u !!!", nTotal, 1U<<tableLog);
-        getchar();
-    }
-#endif
-
-    return tableLog;
-}
-
-/* fake FSE_CTable, for rle input (always same symbol) */
-size_t FSE_buildCTable_rle (FSE_CTable* ct, BYTE symbolValue)
-{
-    void* ptr = ct;
-    U16* tableU16 = ( (U16*) ptr) + 2;
-    void* FSCTptr = (U32*)ptr + 2;
-    FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*) FSCTptr;
-
-    /* header */
-    tableU16[-2] = (U16) 0;
-    tableU16[-1] = (U16) symbolValue;
-
-    /* Build table */
-    tableU16[0] = 0;
-    tableU16[1] = 0;   /* just in case */
-
-    /* Build Symbol Transformation Table */
-    symbolTT[symbolValue].deltaNbBits = 0;
-    symbolTT[symbolValue].deltaFindState = 0;
-
-    return 0;
-}
-
-
-static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize,
-                           const void* src, size_t srcSize,
-                           const FSE_CTable* ct, const unsigned fast)
-{
-    const BYTE* const istart = (const BYTE*) src;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* ip=iend;
-
-    BIT_CStream_t bitC;
-    FSE_CState_t CState1, CState2;
-
-    /* init */
-    if (srcSize <= 2) return 0;
-    { size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
-      if (FSE_isError(initError)) return 0; /* not enough space available to write a bitstream */ }
-
-#define FSE_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
-
-    if (srcSize & 1) {
-        FSE_initCState2(&CState1, ct, *--ip);
-        FSE_initCState2(&CState2, ct, *--ip);
-        FSE_encodeSymbol(&bitC, &CState1, *--ip);
-        FSE_FLUSHBITS(&bitC);
-    } else {
-        FSE_initCState2(&CState2, ct, *--ip);
-        FSE_initCState2(&CState1, ct, *--ip);
-    }
-
-    /* join to mod 4 */
-    srcSize -= 2;
-    if ((sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) && (srcSize & 2)) {  /* test bit 2 */
-        FSE_encodeSymbol(&bitC, &CState2, *--ip);
-        FSE_encodeSymbol(&bitC, &CState1, *--ip);
-        FSE_FLUSHBITS(&bitC);
-    }
-
-    /* 2 or 4 encoding per loop */
-    while ( ip>istart ) {
-
-        FSE_encodeSymbol(&bitC, &CState2, *--ip);
-
-        if (sizeof(bitC.bitContainer)*8 < FSE_MAX_TABLELOG*2+7 )   /* this test must be static */
-            FSE_FLUSHBITS(&bitC);
-
-        FSE_encodeSymbol(&bitC, &CState1, *--ip);
-
-        if (sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) {  /* this test must be static */
-            FSE_encodeSymbol(&bitC, &CState2, *--ip);
-            FSE_encodeSymbol(&bitC, &CState1, *--ip);
-        }
-
-        FSE_FLUSHBITS(&bitC);
-    }
-
-    FSE_flushCState(&bitC, &CState2);
-    FSE_flushCState(&bitC, &CState1);
-    return BIT_closeCStream(&bitC);
-}
-
-size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
-                           const void* src, size_t srcSize,
-                           const FSE_CTable* ct)
-{
-    unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));
-
-    if (fast)
-        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);
-    else
-        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);
-}
-
-
-size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
-
-#endif   /* FSE_COMMONDEFS_ONLY */
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/hist.cpp b/src/duckdb/third_party/zstd/compress/hist.cpp
deleted file mode 100644
index 6b7f82c90..000000000
--- a/src/duckdb/third_party/zstd/compress/hist.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-/* ******************************************************************
- * hist : Histogram functions
- * part of Finite State Entropy project
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* --- dependencies --- */
-#include "zstd/common/mem.h"             /* U32, BYTE, etc. */
-#include "zstd/common/debug.h"           /* assert, DEBUGLOG */
-#include "zstd/common/error_private.h"   /* ERROR */
-#include "zstd/compress/hist.h"
-
-namespace duckdb_zstd {
-
-/* --- Error management --- */
-unsigned HIST_isError(size_t code) { return ERR_isError(code); }
-
-/*-**************************************************************
- *  Histogram functions
- ****************************************************************/
-unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
-                           const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* const end = ip + srcSize;
-    unsigned maxSymbolValue = *maxSymbolValuePtr;
-    unsigned largestCount=0;
-
-    ZSTD_memset(count, 0, (maxSymbolValue+1) * sizeof(*count));
-    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }
-
-    while (ip<end) {
-        assert(*ip <= maxSymbolValue);
-        count[*ip++]++;
-    }
-
-    while (!count[maxSymbolValue]) maxSymbolValue--;
-    *maxSymbolValuePtr = maxSymbolValue;
-
-    {   U32 s;
-        for (s=0; s<=maxSymbolValue; s++)
-            if (count[s] > largestCount) largestCount = count[s];
-    }
-
-    return largestCount;
-}
-
-typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;
-
-/* HIST_count_parallel_wksp() :
- * store histogram into 4 intermediate tables, recombined at the end.
- * this design makes better use of OoO cpus,
- * and is noticeably faster when some values are heavily repeated.
- * But it needs some additional workspace for intermediate tables.
- * `workSpace` must be a U32 table of size >= HIST_WKSP_SIZE_U32.
- * @return : largest histogram frequency,
- *           or an error code (notably when histogram's alphabet is larger than *maxSymbolValuePtr) */
-static size_t HIST_count_parallel_wksp(
-                                unsigned* count, unsigned* maxSymbolValuePtr,
-                                const void* source, size_t sourceSize,
-                                HIST_checkInput_e check,
-                                U32* const workSpace)
-{
-    const BYTE* ip = (const BYTE*)source;
-    const BYTE* const iend = ip+sourceSize;
-    size_t const countSize = (*maxSymbolValuePtr + 1) * sizeof(*count);
-    unsigned max=0;
-    U32* const Counting1 = workSpace;
-    U32* const Counting2 = Counting1 + 256;
-    U32* const Counting3 = Counting2 + 256;
-    U32* const Counting4 = Counting3 + 256;
-
-    /* safety checks */
-    assert(*maxSymbolValuePtr <= 255);
-    if (!sourceSize) {
-        ZSTD_memset(count, 0, countSize);
-        *maxSymbolValuePtr = 0;
-        return 0;
-    }
-    ZSTD_memset(workSpace, 0, 4*256*sizeof(unsigned));
-
-    /* by stripes of 16 bytes */
-    {   U32 cached = MEM_read32(ip); ip += 4;
-        while (ip < iend-15) {
-            U32 c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-        }
-        ip-=4;
-    }
-
-    /* finish last symbols */
-    while (ip<iend) Counting1[*ip++]++;
-
-    {   U32 s;
-        for (s=0; s<256; s++) {
-            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
-            if (Counting1[s] > max) max = Counting1[s];
-    }   }
-
-    {   unsigned maxSymbolValue = 255;
-        while (!Counting1[maxSymbolValue]) maxSymbolValue--;
-        if (check && maxSymbolValue > *maxSymbolValuePtr) return ERROR(maxSymbolValue_tooSmall);
-        *maxSymbolValuePtr = maxSymbolValue;
-        ZSTD_memmove(count, Counting1, countSize);   /* in case count & Counting1 are overlapping */
-    }
-    return (size_t)max;
-}
-
-/* HIST_countFast_wksp() :
- * Same as HIST_countFast(), but using an externally provided scratch buffer.
- * `workSpace` is a writable buffer which must be 4-bytes aligned,
- * `workSpaceSize` must be >= HIST_WKSP_SIZE
- */
-size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                          const void* source, size_t sourceSize,
-                          void* workSpace, size_t workSpaceSize)
-{
-    if (sourceSize < 1500) /* heuristic threshold */
-        return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
-    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
-    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
-    return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);
-}
-
-/* HIST_count_wksp() :
- * Same as HIST_count(), but using an externally provided scratch buffer.
- * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
-size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                       const void* source, size_t sourceSize,
-                       void* workSpace, size_t workSpaceSize)
-{
-    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
-    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
-    if (*maxSymbolValuePtr < 255)
-        return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);
-    *maxSymbolValuePtr = 255;
-    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);
-}
-
-#ifndef ZSTD_NO_UNUSED_FUNCTIONS
-/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */
-size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
-                     const void* source, size_t sourceSize)
-{
-    unsigned tmpCounters[HIST_WKSP_SIZE_U32];
-    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters, sizeof(tmpCounters));
-}
-
-size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
-                 const void* src, size_t srcSize)
-{
-    unsigned tmpCounters[HIST_WKSP_SIZE_U32];
-    return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters));
-}
-#endif
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/huf_compress.cpp b/src/duckdb/third_party/zstd/compress/huf_compress.cpp
deleted file mode 100644
index c0c783166..000000000
--- a/src/duckdb/third_party/zstd/compress/huf_compress.cpp
+++ /dev/null
@@ -1,1467 +0,0 @@
-/* ******************************************************************
- * Huffman encoder, part of New Generation Entropy library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#endif
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
-#include "zstd/common/zstd_deps.h"     /* ZSTD_memcpy, ZSTD_memset */
-#include "zstd/common/compiler.h"
-#include "zstd/common/bitstream.h"
-#include "zstd/compress/hist.h"
-#define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */
-#include "zstd/common/fse.h"        /* header compression */
-#include "zstd/common/huf.h"
-#include "zstd/common/error_private.h"
-#include "zstd/common/bits.h"       /* ZSTD_highbit32 */
-
-namespace duckdb_zstd {
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define HUF_isError ERR_isError
-#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Required declarations
-****************************************************************/
-typedef struct nodeElt_s {
-    U32 count;
-    U16 parent;
-    BYTE byte;
-    BYTE nbBits;
-} nodeElt;
-
-
-/* **************************************************************
-*  Debug Traces
-****************************************************************/
-
-#if DEBUGLEVEL >= 2
-
-static size_t showU32(const U32* arr, size_t size)
-{
-    size_t u;
-    for (u=0; u<size; u++) {
-        RAWLOG(6, " %u", arr[u]); (void)arr;
-    }
-    RAWLOG(6, " \n");
-    return size;
-}
-
-static size_t HUF_getNbBits(HUF_CElt elt);
-
-static size_t showCTableBits(const HUF_CElt* ctable, size_t size)
-{
-    size_t u;
-    for (u=0; u<size; u++) {
-        RAWLOG(6, " %zu", HUF_getNbBits(ctable[u])); (void)ctable;
-    }
-    RAWLOG(6, " \n");
-    return size;
-
-}
-
-static size_t showHNodeSymbols(const nodeElt* hnode, size_t size)
-{
-    size_t u;
-    for (u=0; u<size; u++) {
-        RAWLOG(6, " %u", hnode[u].byte); (void)hnode;
-    }
-    RAWLOG(6, " \n");
-    return size;
-}
-
-static size_t showHNodeBits(const nodeElt* hnode, size_t size)
-{
-    size_t u;
-    for (u=0; u<size; u++) {
-        RAWLOG(6, " %u", hnode[u].nbBits); (void)hnode;
-    }
-    RAWLOG(6, " \n");
-    return size;
-}
-
-#endif
-
-
-/* *******************************************************
-*  HUF : Huffman block compression
-*********************************************************/
-#define HUF_WORKSPACE_MAX_ALIGNMENT 8
-
-static void* HUF_alignUpWorkspace(void* workspace, size_t* workspaceSizePtr, size_t align)
-{
-    size_t const mask = align - 1;
-    size_t const rem = (size_t)workspace & mask;
-    size_t const add = (align - rem) & mask;
-    BYTE* const aligned = (BYTE*)workspace + add;
-    assert((align & (align - 1)) == 0); /* pow 2 */
-    assert(align <= HUF_WORKSPACE_MAX_ALIGNMENT);
-    if (*workspaceSizePtr >= add) {
-        assert(add < align);
-        assert(((size_t)aligned & mask) == 0);
-        *workspaceSizePtr -= add;
-        return aligned;
-    } else {
-        *workspaceSizePtr = 0;
-        return NULL;
-    }
-}
-
-
-/* HUF_compressWeights() :
- * Same as FSE_compress(), but dedicated to huff0's weights compression.
- * The use case needs much less stack memory.
- * Note : all elements within weightTable are supposed to be <= HUF_TABLELOG_MAX.
- */
-#define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6
-
-typedef struct {
-    FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)];
-    U32 scratchBuffer[FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(HUF_TABLELOG_MAX, MAX_FSE_TABLELOG_FOR_HUFF_HEADER)];
-    unsigned count[HUF_TABLELOG_MAX+1];
-    S16 norm[HUF_TABLELOG_MAX+1];
-} HUF_CompressWeightsWksp;
-
-static size_t
-HUF_compressWeights(void* dst, size_t dstSize,
-              const void* weightTable, size_t wtSize,
-                    void* workspace, size_t workspaceSize)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + dstSize;
-
-    unsigned maxSymbolValue = HUF_TABLELOG_MAX;
-    U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;
-    HUF_CompressWeightsWksp* wksp = (HUF_CompressWeightsWksp*)HUF_alignUpWorkspace(workspace, &workspaceSize, ZSTD_ALIGNOF(U32));
-
-    if (workspaceSize < sizeof(HUF_CompressWeightsWksp)) return ERROR(GENERIC);
-
-    /* init conditions */
-    if (wtSize <= 1) return 0;  /* Not compressible */
-
-    /* Scan input and build symbol stats */
-    {   unsigned const maxCount = HIST_count_simple(wksp->count, &maxSymbolValue, weightTable, wtSize);   /* never fails */
-        if (maxCount == wtSize) return 1;   /* only a single symbol in src : rle */
-        if (maxCount == 1) return 0;        /* each symbol present maximum once => not compressible */
-    }
-
-    tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue);
-    CHECK_F( FSE_normalizeCount(wksp->norm, tableLog, wksp->count, wtSize, maxSymbolValue, /* useLowProbCount */ 0) );
-
-    /* Write table description header */
-    {   CHECK_V_F(hSize, FSE_writeNCount(op, (size_t)(oend-op), wksp->norm, maxSymbolValue, tableLog) );
-        op += hSize;
-    }
-
-    /* Compress */
-    CHECK_F( FSE_buildCTable_wksp(wksp->CTable, wksp->norm, maxSymbolValue, tableLog, wksp->scratchBuffer, sizeof(wksp->scratchBuffer)) );
-    {   CHECK_V_F(cSize, FSE_compress_usingCTable(op, (size_t)(oend - op), weightTable, wtSize, wksp->CTable) );
-        if (cSize == 0) return 0;   /* not enough space for compressed data */
-        op += cSize;
-    }
-
-    return (size_t)(op-ostart);
-}
-
-static size_t HUF_getNbBits(HUF_CElt elt)
-{
-    return elt & 0xFF;
-}
-
-static size_t HUF_getNbBitsFast(HUF_CElt elt)
-{
-    return elt;
-}
-
-static size_t HUF_getValue(HUF_CElt elt)
-{
-    return elt & ~(size_t)0xFF;
-}
-
-static size_t HUF_getValueFast(HUF_CElt elt)
-{
-    return elt;
-}
-
-static void HUF_setNbBits(HUF_CElt* elt, size_t nbBits)
-{
-    assert(nbBits <= HUF_TABLELOG_ABSOLUTEMAX);
-    *elt = nbBits;
-}
-
-static void HUF_setValue(HUF_CElt* elt, size_t value)
-{
-    size_t const nbBits = HUF_getNbBits(*elt);
-    if (nbBits > 0) {
-        assert((value >> nbBits) == 0);
-        *elt |= value << (sizeof(HUF_CElt) * 8 - nbBits);
-    }
-}
-
-HUF_CTableHeader HUF_readCTableHeader(HUF_CElt const* ctable)
-{
-    HUF_CTableHeader header;
-    ZSTD_memcpy(&header, ctable, sizeof(header));
-    return header;
-}
-
-static void HUF_writeCTableHeader(HUF_CElt* ctable, U32 tableLog, U32 maxSymbolValue)
-{
-    HUF_CTableHeader header;
-    HUF_STATIC_ASSERT(sizeof(ctable[0]) == sizeof(header));
-    ZSTD_memset(&header, 0, sizeof(header));
-    assert(tableLog < 256);
-    header.tableLog = (BYTE)tableLog;
-    assert(maxSymbolValue < 256);
-    header.maxSymbolValue = (BYTE)maxSymbolValue;
-    ZSTD_memcpy(ctable, &header, sizeof(header));
-}
-
-typedef struct {
-    HUF_CompressWeightsWksp wksp;
-    BYTE bitsToWeight[HUF_TABLELOG_MAX + 1];   /* precomputed conversion table */
-    BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
-} HUF_WriteCTableWksp;
-
-size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize,
-                            const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog,
-                            void* workspace, size_t workspaceSize)
-{
-    HUF_CElt const* const ct = CTable + 1;
-    BYTE* op = (BYTE*)dst;
-    U32 n;
-    HUF_WriteCTableWksp* wksp = (HUF_WriteCTableWksp*)HUF_alignUpWorkspace(workspace, &workspaceSize, ZSTD_ALIGNOF(U32));
-
-    HUF_STATIC_ASSERT(HUF_CTABLE_WORKSPACE_SIZE >= sizeof(HUF_WriteCTableWksp));
-
-    assert(HUF_readCTableHeader(CTable).maxSymbolValue == maxSymbolValue);
-    assert(HUF_readCTableHeader(CTable).tableLog == huffLog);
-
-    /* check conditions */
-    if (workspaceSize < sizeof(HUF_WriteCTableWksp)) return ERROR(GENERIC);
-    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
-
-    /* convert to weight */
-    wksp->bitsToWeight[0] = 0;
-    for (n=1; n<huffLog+1; n++)
-        wksp->bitsToWeight[n] = (BYTE)(huffLog + 1 - n);
-    for (n=0; n<maxSymbolValue; n++)
-        wksp->huffWeight[n] = wksp->bitsToWeight[HUF_getNbBits(ct[n])];
-
-    /* attempt weights compression by FSE */
-    if (maxDstSize < 1) return ERROR(dstSize_tooSmall);
-    {   CHECK_V_F(hSize, HUF_compressWeights(op+1, maxDstSize-1, wksp->huffWeight, maxSymbolValue, &wksp->wksp, sizeof(wksp->wksp)) );
-        if ((hSize>1) & (hSize < maxSymbolValue/2)) {   /* FSE compressed */
-            op[0] = (BYTE)hSize;
-            return hSize+1;
-    }   }
-
-    /* write raw values as 4-bits (max : 15) */
-    if (maxSymbolValue > (256-128)) return ERROR(GENERIC);   /* should not happen : likely means source cannot be compressed */
-    if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */
-    op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1));
-    wksp->huffWeight[maxSymbolValue] = 0;   /* to be sure it doesn't cause msan issue in final combination */
-    for (n=0; n<maxSymbolValue; n+=2)
-        op[(n/2)+1] = (BYTE)((wksp->huffWeight[n] << 4) + wksp->huffWeight[n+1]);
-    return ((maxSymbolValue+1)/2) + 1;
-}
-
-
-size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* hasZeroWeights)
-{
-    BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];   /* init not required, even though some static analyzer may complain */
-    U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    U32 nbSymbols = 0;
-    HUF_CElt* const ct = CTable + 1;
-
-    /* get symbol weights */
-    CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));
-    *hasZeroWeights = (rankVal[0] > 0);
-
-    /* check result */
-    if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
-    if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall);
-
-    *maxSymbolValuePtr = nbSymbols - 1;
-
-    HUF_writeCTableHeader(CTable, tableLog, *maxSymbolValuePtr);
-
-    /* Prepare base value per rank */
-    {   U32 n, nextRankStart = 0;
-        for (n=1; n<=tableLog; n++) {
-            U32 curr = nextRankStart;
-            nextRankStart += (rankVal[n] << (n-1));
-            rankVal[n] = curr;
-    }   }
-
-    /* fill nbBits */
-    {   U32 n; for (n=0; n<nbSymbols; n++) {
-            const U32 w = huffWeight[n];
-            HUF_setNbBits(ct + n, (BYTE)(tableLog + 1 - w) & -(w != 0));
-    }   }
-
-    /* fill val */
-    {   U16 nbPerRank[HUF_TABLELOG_MAX+2]  = {0};  /* support w=0=>n=tableLog+1 */
-        U16 valPerRank[HUF_TABLELOG_MAX+2] = {0};
-        { U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[HUF_getNbBits(ct[n])]++; }
-        /* determine stating value per rank */
-        valPerRank[tableLog+1] = 0;   /* for w==0 */
-        {   U16 min = 0;
-            U32 n; for (n=tableLog; n>0; n--) {  /* start at n=tablelog <-> w=1 */
-                valPerRank[n] = min;     /* get starting value within each rank */
-                min += nbPerRank[n];
-                min >>= 1;
-        }   }
-        /* assign value within rank, symbol order */
-        { U32 n; for (n=0; n<nbSymbols; n++) HUF_setValue(ct + n, valPerRank[HUF_getNbBits(ct[n])]++); }
-    }
-
-    return readSize;
-}
-
-U32 HUF_getNbBitsFromCTable(HUF_CElt const* CTable, U32 symbolValue)
-{
-    const HUF_CElt* const ct = CTable + 1;
-    assert(symbolValue <= HUF_SYMBOLVALUE_MAX);
-    if (symbolValue > HUF_readCTableHeader(CTable).maxSymbolValue)
-        return 0;
-    return (U32)HUF_getNbBits(ct[symbolValue]);
-}
-
-
-/**
- * HUF_setMaxHeight():
- * Try to enforce @targetNbBits on the Huffman tree described in @huffNode.
- *
- * It attempts to convert all nodes with nbBits > @targetNbBits
- * to employ @targetNbBits instead. Then it adjusts the tree
- * so that it remains a valid canonical Huffman tree.
- *
- * @pre               The sum of the ranks of each symbol == 2^largestBits,
- *                    where largestBits == huffNode[lastNonNull].nbBits.
- * @post              The sum of the ranks of each symbol == 2^largestBits,
- *                    where largestBits is the return value (expected <= targetNbBits).
- *
- * @param huffNode    The Huffman tree modified in place to enforce targetNbBits.
- *                    It's presumed sorted, from most frequent to rarest symbol.
- * @param lastNonNull The symbol with the lowest count in the Huffman tree.
- * @param targetNbBits  The allowed number of bits, which the Huffman tree
- *                    may not respect. After this function the Huffman tree will
- *                    respect targetNbBits.
- * @return            The maximum number of bits of the Huffman tree after adjustment.
- */
-static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 targetNbBits)
-{
-    const U32 largestBits = huffNode[lastNonNull].nbBits;
-    /* early exit : no elt > targetNbBits, so the tree is already valid. */
-    if (largestBits <= targetNbBits) return largestBits;
-
-    DEBUGLOG(5, "HUF_setMaxHeight (targetNbBits = %u)", targetNbBits);
-
-    /* there are several too large elements (at least >= 2) */
-    {   int totalCost = 0;
-        const U32 baseCost = 1 << (largestBits - targetNbBits);
-        int n = (int)lastNonNull;
-
-        /* Adjust any ranks > targetNbBits to targetNbBits.
-         * Compute totalCost, which is how far the sum of the ranks is
-         * we are over 2^largestBits after adjust the offending ranks.
-         */
-        while (huffNode[n].nbBits > targetNbBits) {
-            totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits));
-            huffNode[n].nbBits = (BYTE)targetNbBits;
-            n--;
-        }
-        /* n stops at huffNode[n].nbBits <= targetNbBits */
-        assert(huffNode[n].nbBits <= targetNbBits);
-        /* n end at index of smallest symbol using < targetNbBits */
-        while (huffNode[n].nbBits == targetNbBits) --n;
-
-        /* renorm totalCost from 2^largestBits to 2^targetNbBits
-         * note : totalCost is necessarily a multiple of baseCost */
-        assert(((U32)totalCost & (baseCost - 1)) == 0);
-        totalCost >>= (largestBits - targetNbBits);
-        assert(totalCost > 0);
-
-        /* repay normalized cost */
-        {   U32 const noSymbol = 0xF0F0F0F0;
-            U32 rankLast[HUF_TABLELOG_MAX+2];
-
-            /* Get pos of last (smallest = lowest cum. count) symbol per rank */
-            ZSTD_memset(rankLast, 0xF0, sizeof(rankLast));
-            {   U32 currentNbBits = targetNbBits;
-                int pos;
-                for (pos=n ; pos >= 0; pos--) {
-                    if (huffNode[pos].nbBits >= currentNbBits) continue;
-                    currentNbBits = huffNode[pos].nbBits;   /* < targetNbBits */
-                    rankLast[targetNbBits-currentNbBits] = (U32)pos;
-            }   }
-
-            while (totalCost > 0) {
-                /* Try to reduce the next power of 2 above totalCost because we
-                 * gain back half the rank.
-                 */
-                U32 nBitsToDecrease = ZSTD_highbit32((U32)totalCost) + 1;
-                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {
-                    U32 const highPos = rankLast[nBitsToDecrease];
-                    U32 const lowPos = rankLast[nBitsToDecrease-1];
-                    if (highPos == noSymbol) continue;
-                    /* Decrease highPos if no symbols of lowPos or if it is
-                     * not cheaper to remove 2 lowPos than highPos.
-                     */
-                    if (lowPos == noSymbol) break;
-                    {   U32 const highTotal = huffNode[highPos].count;
-                        U32 const lowTotal = 2 * huffNode[lowPos].count;
-                        if (highTotal <= lowTotal) break;
-                }   }
-                /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */
-                assert(rankLast[nBitsToDecrease] != noSymbol || nBitsToDecrease == 1);
-                /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
-                while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))
-                    nBitsToDecrease++;
-                assert(rankLast[nBitsToDecrease] != noSymbol);
-                /* Increase the number of bits to gain back half the rank cost. */
-                totalCost -= 1 << (nBitsToDecrease-1);
-                huffNode[rankLast[nBitsToDecrease]].nbBits++;
-
-                /* Fix up the new rank.
-                 * If the new rank was empty, this symbol is now its smallest.
-                 * Otherwise, this symbol will be the largest in the new rank so no adjustment.
-                 */
-                if (rankLast[nBitsToDecrease-1] == noSymbol)
-                    rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];
-                /* Fix up the old rank.
-                 * If the symbol was at position 0, meaning it was the highest weight symbol in the tree,
-                 * it must be the only symbol in its rank, so the old rank now has no symbols.
-                 * Otherwise, since the Huffman nodes are sorted by count, the previous position is now
-                 * the smallest node in the rank. If the previous position belongs to a different rank,
-                 * then the rank is now empty.
-                 */
-                if (rankLast[nBitsToDecrease] == 0)    /* special case, reached largest symbol */
-                    rankLast[nBitsToDecrease] = noSymbol;
-                else {
-                    rankLast[nBitsToDecrease]--;
-                    if (huffNode[rankLast[nBitsToDecrease]].nbBits != targetNbBits-nBitsToDecrease)
-                        rankLast[nBitsToDecrease] = noSymbol;   /* this rank is now empty */
-                }
-            }   /* while (totalCost > 0) */
-
-            /* If we've removed too much weight, then we have to add it back.
-             * To avoid overshooting again, we only adjust the smallest rank.
-             * We take the largest nodes from the lowest rank 0 and move them
-             * to rank 1. There's guaranteed to be enough rank 0 symbols because
-             * TODO.
-             */
-            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */
-                /* special case : no rank 1 symbol (using targetNbBits-1);
-                 * let's create one from largest rank 0 (using targetNbBits).
-                 */
-                if (rankLast[1] == noSymbol) {
-                    while (huffNode[n].nbBits == targetNbBits) n--;
-                    huffNode[n+1].nbBits--;
-                    assert(n >= 0);
-                    rankLast[1] = (U32)(n+1);
-                    totalCost++;
-                    continue;
-                }
-                huffNode[ rankLast[1] + 1 ].nbBits--;
-                rankLast[1]++;
-                totalCost ++;
-            }
-        }   /* repay normalized cost */
-    }   /* there are several too large elements (at least >= 2) */
-
-    return targetNbBits;
-}
-
-typedef struct {
-    U16 base;
-    U16 curr;
-} rankPos;
-
-typedef nodeElt huffNodeTable[2 * (HUF_SYMBOLVALUE_MAX + 1)];
-
-/* Number of buckets available for HUF_sort() */
-#define RANK_POSITION_TABLE_SIZE 192
-
-typedef struct {
-  huffNodeTable huffNodeTbl;
-  rankPos rankPosition[RANK_POSITION_TABLE_SIZE];
-} HUF_buildCTable_wksp_tables;
-
-/* RANK_POSITION_DISTINCT_COUNT_CUTOFF == Cutoff point in HUF_sort() buckets for which we use log2 bucketing.
- * Strategy is to use as many buckets as possible for representing distinct
- * counts while using the remainder to represent all "large" counts.
- *
- * To satisfy this requirement for 192 buckets, we can do the following:
- * Let buckets 0-166 represent distinct counts of [0, 166]
- * Let buckets 166 to 192 represent all remaining counts up to RANK_POSITION_MAX_COUNT_LOG using log2 bucketing.
- */
-#define RANK_POSITION_MAX_COUNT_LOG 32
-#define RANK_POSITION_LOG_BUCKETS_BEGIN ((RANK_POSITION_TABLE_SIZE - 1) - RANK_POSITION_MAX_COUNT_LOG - 1 /* == 158 */)
-#define RANK_POSITION_DISTINCT_COUNT_CUTOFF (RANK_POSITION_LOG_BUCKETS_BEGIN + ZSTD_highbit32(RANK_POSITION_LOG_BUCKETS_BEGIN) /* == 166 */)
-
-/* Return the appropriate bucket index for a given count. See definition of
- * RANK_POSITION_DISTINCT_COUNT_CUTOFF for explanation of bucketing strategy.
- */
-static U32 HUF_getIndex(U32 const count) {
-    return (count < RANK_POSITION_DISTINCT_COUNT_CUTOFF)
-        ? count
-        : ZSTD_highbit32(count) + RANK_POSITION_LOG_BUCKETS_BEGIN;
-}
-
-/* Helper swap function for HUF_quickSortPartition() */
-static void HUF_swapNodes(nodeElt* a, nodeElt* b) {
-	nodeElt tmp = *a;
-	*a = *b;
-	*b = tmp;
-}
-
-/* Returns 0 if the huffNode array is not sorted by descending count */
-MEM_STATIC int HUF_isSorted(nodeElt huffNode[], U32 const maxSymbolValue1) {
-    U32 i;
-    for (i = 1; i < maxSymbolValue1; ++i) {
-        if (huffNode[i].count > huffNode[i-1].count) {
-            return 0;
-        }
-    }
-    return 1;
-}
-
-/* Insertion sort by descending order */
-HINT_INLINE void HUF_insertionSort(nodeElt huffNode[], int const low, int const high) {
-    int i;
-    int const size = high-low+1;
-    huffNode += low;
-    for (i = 1; i < size; ++i) {
-        nodeElt const key = huffNode[i];
-        int j = i - 1;
-        while (j >= 0 && huffNode[j].count < key.count) {
-            huffNode[j + 1] = huffNode[j];
-            j--;
-        }
-        huffNode[j + 1] = key;
-    }
-}
-
-/* Pivot helper function for quicksort. */
-static int HUF_quickSortPartition(nodeElt arr[], int const low, int const high) {
-    /* Simply select rightmost element as pivot. "Better" selectors like
-     * median-of-three don't experimentally appear to have any benefit.
-     */
-    U32 const pivot = arr[high].count;
-    int i = low - 1;
-    int j = low;
-    for ( ; j < high; j++) {
-        if (arr[j].count > pivot) {
-            i++;
-            HUF_swapNodes(&arr[i], &arr[j]);
-        }
-    }
-    HUF_swapNodes(&arr[i + 1], &arr[high]);
-    return i + 1;
-}
-
-/* Classic quicksort by descending with partially iterative calls
- * to reduce worst case callstack size.
- */
-static void HUF_simpleQuickSort(nodeElt arr[], int low, int high) {
-    int const kInsertionSortThreshold = 8;
-    if (high - low < kInsertionSortThreshold) {
-        HUF_insertionSort(arr, low, high);
-        return;
-    }
-    while (low < high) {
-        int const idx = HUF_quickSortPartition(arr, low, high);
-        if (idx - low < high - idx) {
-            HUF_simpleQuickSort(arr, low, idx - 1);
-            low = idx + 1;
-        } else {
-            HUF_simpleQuickSort(arr, idx + 1, high);
-            high = idx - 1;
-        }
-    }
-}
-
-/**
- * HUF_sort():
- * Sorts the symbols [0, maxSymbolValue] by count[symbol] in decreasing order.
- * This is a typical bucket sorting strategy that uses either quicksort or insertion sort to sort each bucket.
- *
- * @param[out] huffNode       Sorted symbols by decreasing count. Only members `.count` and `.byte` are filled.
- *                            Must have (maxSymbolValue + 1) entries.
- * @param[in]  count          Histogram of the symbols.
- * @param[in]  maxSymbolValue Maximum symbol value.
- * @param      rankPosition   This is a scratch workspace. Must have RANK_POSITION_TABLE_SIZE entries.
- */
-static void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSymbolValue, rankPos rankPosition[]) {
-    U32 n;
-    U32 const maxSymbolValue1 = maxSymbolValue+1;
-
-    /* Compute base and set curr to base.
-     * For symbol s let lowerRank = HUF_getIndex(count[n]) and rank = lowerRank + 1.
-     * See HUF_getIndex to see bucketing strategy.
-     * We attribute each symbol to lowerRank's base value, because we want to know where
-     * each rank begins in the output, so for rank R we want to count ranks R+1 and above.
-     */
-    ZSTD_memset(rankPosition, 0, sizeof(*rankPosition) * RANK_POSITION_TABLE_SIZE);
-    for (n = 0; n < maxSymbolValue1; ++n) {
-        U32 lowerRank = HUF_getIndex(count[n]);
-        assert(lowerRank < RANK_POSITION_TABLE_SIZE - 1);
-        rankPosition[lowerRank].base++;
-    }
-
-    assert(rankPosition[RANK_POSITION_TABLE_SIZE - 1].base == 0);
-    /* Set up the rankPosition table */
-    for (n = RANK_POSITION_TABLE_SIZE - 1; n > 0; --n) {
-        rankPosition[n-1].base += rankPosition[n].base;
-        rankPosition[n-1].curr = rankPosition[n-1].base;
-    }
-
-    /* Insert each symbol into their appropriate bucket, setting up rankPosition table. */
-    for (n = 0; n < maxSymbolValue1; ++n) {
-        U32 const c = count[n];
-        U32 const r = HUF_getIndex(c) + 1;
-        U32 const pos = rankPosition[r].curr++;
-        assert(pos < maxSymbolValue1);
-        huffNode[pos].count = c;
-        huffNode[pos].byte  = (BYTE)n;
-    }
-
-    /* Sort each bucket. */
-    for (n = RANK_POSITION_DISTINCT_COUNT_CUTOFF; n < RANK_POSITION_TABLE_SIZE - 1; ++n) {
-        int const bucketSize = rankPosition[n].curr - rankPosition[n].base;
-        U32 const bucketStartIdx = rankPosition[n].base;
-        if (bucketSize > 1) {
-            assert(bucketStartIdx < maxSymbolValue1);
-            HUF_simpleQuickSort(huffNode + bucketStartIdx, 0, bucketSize-1);
-        }
-    }
-
-    assert(HUF_isSorted(huffNode, maxSymbolValue1));
-}
-
-
-/** HUF_buildCTable_wksp() :
- *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
- *  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as sizeof(HUF_buildCTable_wksp_tables).
- */
-#define STARTNODE (HUF_SYMBOLVALUE_MAX+1)
-
-/* HUF_buildTree():
- * Takes the huffNode array sorted by HUF_sort() and builds an unlimited-depth Huffman tree.
- *
- * @param huffNode        The array sorted by HUF_sort(). Builds the Huffman tree in this array.
- * @param maxSymbolValue  The maximum symbol value.
- * @return                The smallest node in the Huffman tree (by count).
- */
-static int HUF_buildTree(nodeElt* huffNode, U32 maxSymbolValue)
-{
-    nodeElt* const huffNode0 = huffNode - 1;
-    int nonNullRank;
-    int lowS, lowN;
-    int nodeNb = STARTNODE;
-    int n, nodeRoot;
-    DEBUGLOG(5, "HUF_buildTree (alphabet size = %u)", maxSymbolValue + 1);
-    /* init for parents */
-    nonNullRank = (int)maxSymbolValue;
-    while(huffNode[nonNullRank].count == 0) nonNullRank--;
-    lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;
-    huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count;
-    huffNode[lowS].parent = huffNode[lowS-1].parent = (U16)nodeNb;
-    nodeNb++; lowS-=2;
-    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
-    huffNode0[0].count = (U32)(1U<<31);  /* fake entry, strong barrier */
-
-    /* create parents */
-    while (nodeNb <= nodeRoot) {
-        int const n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
-        int const n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
-        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;
-        huffNode[n1].parent = huffNode[n2].parent = (U16)nodeNb;
-        nodeNb++;
-    }
-
-    /* distribute weights (unlimited tree height) */
-    huffNode[nodeRoot].nbBits = 0;
-    for (n=nodeRoot-1; n>=STARTNODE; n--)
-        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
-    for (n=0; n<=nonNullRank; n++)
-        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
-
-    DEBUGLOG(6, "Initial distribution of bits completed (%zu sorted symbols)", showHNodeBits(huffNode, maxSymbolValue+1));
-
-    return nonNullRank;
-}
-
-/**
- * HUF_buildCTableFromTree():
- * Build the CTable given the Huffman tree in huffNode.
- *
- * @param[out] CTable         The output Huffman CTable.
- * @param      huffNode       The Huffman tree.
- * @param      nonNullRank    The last and smallest node in the Huffman tree.
- * @param      maxSymbolValue The maximum symbol value.
- * @param      maxNbBits      The exact maximum number of bits used in the Huffman tree.
- */
-static void HUF_buildCTableFromTree(HUF_CElt* CTable, nodeElt const* huffNode, int nonNullRank, U32 maxSymbolValue, U32 maxNbBits)
-{
-    HUF_CElt* const ct = CTable + 1;
-    /* fill result into ctable (val, nbBits) */
-    int n;
-    U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0};
-    U16 valPerRank[HUF_TABLELOG_MAX+1] = {0};
-    int const alphabetSize = (int)(maxSymbolValue + 1);
-    for (n=0; n<=nonNullRank; n++)
-        nbPerRank[huffNode[n].nbBits]++;
-    /* determine starting value per rank */
-    {   U16 min = 0;
-        for (n=(int)maxNbBits; n>0; n--) {
-            valPerRank[n] = min;      /* get starting value within each rank */
-            min += nbPerRank[n];
-            min >>= 1;
-    }   }
-    for (n=0; n<alphabetSize; n++)
-        HUF_setNbBits(ct + huffNode[n].byte, huffNode[n].nbBits);   /* push nbBits per symbol, symbol order */
-    for (n=0; n<alphabetSize; n++)
-        HUF_setValue(ct + n, valPerRank[HUF_getNbBits(ct[n])]++);   /* assign value within rank, symbol order */
-
-    HUF_writeCTableHeader(CTable, maxNbBits, maxSymbolValue);
-}
-
-size_t
-HUF_buildCTable_wksp(HUF_CElt* CTable, const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
-                     void* workSpace, size_t wkspSize)
-{
-    HUF_buildCTable_wksp_tables* const wksp_tables =
-        (HUF_buildCTable_wksp_tables*)HUF_alignUpWorkspace(workSpace, &wkspSize, ZSTD_ALIGNOF(U32));
-    nodeElt* const huffNode0 = wksp_tables->huffNodeTbl;
-    nodeElt* const huffNode = huffNode0+1;
-    int nonNullRank;
-
-    HUF_STATIC_ASSERT(HUF_CTABLE_WORKSPACE_SIZE == sizeof(HUF_buildCTable_wksp_tables));
-
-    DEBUGLOG(5, "HUF_buildCTable_wksp (alphabet size = %u)", maxSymbolValue+1);
-
-    /* safety checks */
-    if (wkspSize < sizeof(HUF_buildCTable_wksp_tables))
-        return ERROR(workSpace_tooSmall);
-    if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;
-    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX)
-        return ERROR(maxSymbolValue_tooLarge);
-    ZSTD_memset(huffNode0, 0, sizeof(huffNodeTable));
-
-    /* sort, decreasing order */
-    HUF_sort(huffNode, count, maxSymbolValue, wksp_tables->rankPosition);
-    DEBUGLOG(6, "sorted symbols completed (%zu symbols)", showHNodeSymbols(huffNode, maxSymbolValue+1));
-
-    /* build tree */
-    nonNullRank = HUF_buildTree(huffNode, maxSymbolValue);
-
-    /* determine and enforce maxTableLog */
-    maxNbBits = HUF_setMaxHeight(huffNode, (U32)nonNullRank, maxNbBits);
-    if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC);   /* check fit into table */
-
-    HUF_buildCTableFromTree(CTable, huffNode, nonNullRank, maxSymbolValue, maxNbBits);
-
-    return maxNbBits;
-}
-
-size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
-{
-    HUF_CElt const* ct = CTable + 1;
-    size_t nbBits = 0;
-    int s;
-    for (s = 0; s <= (int)maxSymbolValue; ++s) {
-        nbBits += HUF_getNbBits(ct[s]) * count[s];
-    }
-    return nbBits >> 3;
-}
-
-int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
-    HUF_CTableHeader header = HUF_readCTableHeader(CTable);
-    HUF_CElt const* ct = CTable + 1;
-    int bad = 0;
-    int s;
-
-    assert(header.tableLog <= HUF_TABLELOG_ABSOLUTEMAX);
-
-    if (header.maxSymbolValue < maxSymbolValue)
-        return 0;
-
-    for (s = 0; s <= (int)maxSymbolValue; ++s) {
-        bad |= (count[s] != 0) & (HUF_getNbBits(ct[s]) == 0);
-    }
-    return !bad;
-}
-
-size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
-
-/** HUF_CStream_t:
- * Huffman uses its own BIT_CStream_t implementation.
- * There are three major differences from BIT_CStream_t:
- *   1. HUF_addBits() takes a HUF_CElt (size_t) which is
- *      the pair (nbBits, value) in the format:
- *      format:
- *        - Bits [0, 4)            = nbBits
- *        - Bits [4, 64 - nbBits)  = 0
- *        - Bits [64 - nbBits, 64) = value
- *   2. The bitContainer is built from the upper bits and
- *      right shifted. E.g. to add a new value of N bits
- *      you right shift the bitContainer by N, then or in
- *      the new value into the N upper bits.
- *   3. The bitstream has two bit containers. You can add
- *      bits to the second container and merge them into
- *      the first container.
- */
-
-#define HUF_BITS_IN_CONTAINER (sizeof(size_t) * 8)
-
-typedef struct {
-    size_t bitContainer[2];
-    size_t bitPos[2];
-
-    BYTE* startPtr;
-    BYTE* ptr;
-    BYTE* endPtr;
-} HUF_CStream_t;
-
-/**! HUF_initCStream():
- * Initializes the bitstream.
- * @returns 0 or an error code.
- */
-static size_t HUF_initCStream(HUF_CStream_t* bitC,
-                                  void* startPtr, size_t dstCapacity)
-{
-    ZSTD_memset(bitC, 0, sizeof(*bitC));
-    bitC->startPtr = (BYTE*)startPtr;
-    bitC->ptr = bitC->startPtr;
-    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer[0]);
-    if (dstCapacity <= sizeof(bitC->bitContainer[0])) return ERROR(dstSize_tooSmall);
-    return 0;
-}
-
-/*! HUF_addBits():
- * Adds the symbol stored in HUF_CElt elt to the bitstream.
- *
- * @param elt   The element we're adding. This is a (nbBits, value) pair.
- *              See the HUF_CStream_t docs for the format.
- * @param idx   Insert into the bitstream at this idx.
- * @param kFast This is a template parameter. If the bitstream is guaranteed
- *              to have at least 4 unused bits after this call it may be 1,
- *              otherwise it must be 0. HUF_addBits() is faster when fast is set.
- */
-FORCE_INLINE_TEMPLATE void HUF_addBits(HUF_CStream_t* bitC, HUF_CElt elt, int idx, int kFast)
-{
-    assert(idx <= 1);
-    assert(HUF_getNbBits(elt) <= HUF_TABLELOG_ABSOLUTEMAX);
-    /* This is efficient on x86-64 with BMI2 because shrx
-     * only reads the low 6 bits of the register. The compiler
-     * knows this and elides the mask. When fast is set,
-     * every operation can use the same value loaded from elt.
-     */
-    bitC->bitContainer[idx] >>= HUF_getNbBits(elt);
-    bitC->bitContainer[idx] |= kFast ? HUF_getValueFast(elt) : HUF_getValue(elt);
-    /* We only read the low 8 bits of bitC->bitPos[idx] so it
-     * doesn't matter that the high bits have noise from the value.
-     */
-    bitC->bitPos[idx] += HUF_getNbBitsFast(elt);
-    assert((bitC->bitPos[idx] & 0xFF) <= HUF_BITS_IN_CONTAINER);
-    /* The last 4-bits of elt are dirty if fast is set,
-     * so we must not be overwriting bits that have already been
-     * inserted into the bit container.
-     */
-#if DEBUGLEVEL >= 1
-    {
-        size_t const nbBits = HUF_getNbBits(elt);
-        size_t const dirtyBits = nbBits == 0 ? 0 : ZSTD_highbit32((U32)nbBits) + 1;
-        (void)dirtyBits;
-        /* Middle bits are 0. */
-        assert(((elt >> dirtyBits) << (dirtyBits + nbBits)) == 0);
-        /* We didn't overwrite any bits in the bit container. */
-        assert(!kFast || (bitC->bitPos[idx] & 0xFF) <= HUF_BITS_IN_CONTAINER);
-        (void)dirtyBits;
-    }
-#endif
-}
-
-FORCE_INLINE_TEMPLATE void HUF_zeroIndex1(HUF_CStream_t* bitC)
-{
-    bitC->bitContainer[1] = 0;
-    bitC->bitPos[1] = 0;
-}
-
-/*! HUF_mergeIndex1() :
- * Merges the bit container @ index 1 into the bit container @ index 0
- * and zeros the bit container @ index 1.
- */
-FORCE_INLINE_TEMPLATE void HUF_mergeIndex1(HUF_CStream_t* bitC)
-{
-    assert((bitC->bitPos[1] & 0xFF) < HUF_BITS_IN_CONTAINER);
-    bitC->bitContainer[0] >>= (bitC->bitPos[1] & 0xFF);
-    bitC->bitContainer[0] |= bitC->bitContainer[1];
-    bitC->bitPos[0] += bitC->bitPos[1];
-    assert((bitC->bitPos[0] & 0xFF) <= HUF_BITS_IN_CONTAINER);
-}
-
-/*! HUF_flushBits() :
-* Flushes the bits in the bit container @ index 0.
-*
-* @post bitPos will be < 8.
-* @param kFast If kFast is set then we must know a-priori that
-*              the bit container will not overflow.
-*/
-FORCE_INLINE_TEMPLATE void HUF_flushBits(HUF_CStream_t* bitC, int kFast)
-{
-    /* The upper bits of bitPos are noisy, so we must mask by 0xFF. */
-    size_t const nbBits = bitC->bitPos[0] & 0xFF;
-    size_t const nbBytes = nbBits >> 3;
-    /* The top nbBits bits of bitContainer are the ones we need. */
-    size_t const bitContainer = bitC->bitContainer[0] >> (HUF_BITS_IN_CONTAINER - nbBits);
-    /* Mask bitPos to account for the bytes we consumed. */
-    bitC->bitPos[0] &= 7;
-    assert(nbBits > 0);
-    assert(nbBits <= sizeof(bitC->bitContainer[0]) * 8);
-    assert(bitC->ptr <= bitC->endPtr);
-    MEM_writeLEST(bitC->ptr, bitContainer);
-    bitC->ptr += nbBytes;
-    assert(!kFast || bitC->ptr <= bitC->endPtr);
-    if (!kFast && bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
-    /* bitContainer doesn't need to be modified because the leftover
-     * bits are already the top bitPos bits. And we don't care about
-     * noise in the lower values.
-     */
-}
-
-/*! HUF_endMark()
- * @returns The Huffman stream end mark: A 1-bit value = 1.
- */
-static HUF_CElt HUF_endMark(void)
-{
-    HUF_CElt endMark;
-    HUF_setNbBits(&endMark, 1);
-    HUF_setValue(&endMark, 1);
-    return endMark;
-}
-
-/*! HUF_closeCStream() :
- *  @return Size of CStream, in bytes,
- *          or 0 if it could not fit into dstBuffer */
-static size_t HUF_closeCStream(HUF_CStream_t* bitC)
-{
-    HUF_addBits(bitC, HUF_endMark(), /* idx */ 0, /* kFast */ 0);
-    HUF_flushBits(bitC, /* kFast */ 0);
-    {
-        size_t const nbBits = bitC->bitPos[0] & 0xFF;
-        if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */
-        return (size_t)(bitC->ptr - bitC->startPtr) + (nbBits > 0);
-    }
-}
-
-FORCE_INLINE_TEMPLATE void
-HUF_encodeSymbol(HUF_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable, int idx, int fast)
-{
-    HUF_addBits(bitCPtr, CTable[symbol], idx, fast);
-}
-
-FORCE_INLINE_TEMPLATE void
-HUF_compress1X_usingCTable_internal_body_loop(HUF_CStream_t* bitC,
-                                   const BYTE* ip, size_t srcSize,
-                                   const HUF_CElt* ct,
-                                   int kUnroll, int kFastFlush, int kLastFast)
-{
-    /* Join to kUnroll */
-    int n = (int)srcSize;
-    int rem = n % kUnroll;
-    if (rem > 0) {
-        for (; rem > 0; --rem) {
-            HUF_encodeSymbol(bitC, ip[--n], ct, 0, /* fast */ 0);
-        }
-        HUF_flushBits(bitC, kFastFlush);
-    }
-    assert(n % kUnroll == 0);
-
-    /* Join to 2 * kUnroll */
-    if (n % (2 * kUnroll)) {
-        int u;
-        for (u = 1; u < kUnroll; ++u) {
-            HUF_encodeSymbol(bitC, ip[n - u], ct, 0, 1);
-        }
-        HUF_encodeSymbol(bitC, ip[n - kUnroll], ct, 0, kLastFast);
-        HUF_flushBits(bitC, kFastFlush);
-        n -= kUnroll;
-    }
-    assert(n % (2 * kUnroll) == 0);
-
-    for (; n>0; n-= 2 * kUnroll) {
-        /* Encode kUnroll symbols into the bitstream @ index 0. */
-        int u;
-        for (u = 1; u < kUnroll; ++u) {
-            HUF_encodeSymbol(bitC, ip[n - u], ct, /* idx */ 0, /* fast */ 1);
-        }
-        HUF_encodeSymbol(bitC, ip[n - kUnroll], ct, /* idx */ 0, /* fast */ kLastFast);
-        HUF_flushBits(bitC, kFastFlush);
-        /* Encode kUnroll symbols into the bitstream @ index 1.
-         * This allows us to start filling the bit container
-         * without any data dependencies.
-         */
-        HUF_zeroIndex1(bitC);
-        for (u = 1; u < kUnroll; ++u) {
-            HUF_encodeSymbol(bitC, ip[n - kUnroll - u], ct, /* idx */ 1, /* fast */ 1);
-        }
-        HUF_encodeSymbol(bitC, ip[n - kUnroll - kUnroll], ct, /* idx */ 1, /* fast */ kLastFast);
-        /* Merge bitstream @ index 1 into the bitstream @ index 0 */
-        HUF_mergeIndex1(bitC);
-        HUF_flushBits(bitC, kFastFlush);
-    }
-    assert(n == 0);
-
-}
-
-/**
- * Returns a tight upper bound on the output space needed by Huffman
- * with 8 bytes buffer to handle over-writes. If the output is at least
- * this large we don't need to do bounds checks during Huffman encoding.
- */
-static size_t HUF_tightCompressBound(size_t srcSize, size_t tableLog)
-{
-    return ((srcSize * tableLog) >> 3) + 8;
-}
-
-
-FORCE_INLINE_TEMPLATE size_t
-HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
-                                   const void* src, size_t srcSize,
-                                   const HUF_CElt* CTable)
-{
-    U32 const tableLog = HUF_readCTableHeader(CTable).tableLog;
-    HUF_CElt const* ct = CTable + 1;
-    const BYTE* ip = (const BYTE*) src;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    HUF_CStream_t bitC;
-
-    /* init */
-    if (dstSize < 8) return 0;   /* not enough space to compress */
-    { BYTE* op = ostart;
-      size_t const initErr = HUF_initCStream(&bitC, op, (size_t)(oend-op));
-      if (HUF_isError(initErr)) return 0; }
-
-    if (dstSize < HUF_tightCompressBound(srcSize, (size_t)tableLog) || tableLog > 11)
-        HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ MEM_32bits() ? 2 : 4, /* kFast */ 0, /* kLastFast */ 0);
-    else {
-        if (MEM_32bits()) {
-            switch (tableLog) {
-            case 11:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 2, /* kFastFlush */ 1, /* kLastFast */ 0);
-                break;
-            case 10: ZSTD_FALLTHROUGH;
-            case 9: ZSTD_FALLTHROUGH;
-            case 8:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 2, /* kFastFlush */ 1, /* kLastFast */ 1);
-                break;
-            case 7: ZSTD_FALLTHROUGH;
-            default:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 3, /* kFastFlush */ 1, /* kLastFast */ 1);
-                break;
-            }
-        } else {
-            switch (tableLog) {
-            case 11:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 5, /* kFastFlush */ 1, /* kLastFast */ 0);
-                break;
-            case 10:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 5, /* kFastFlush */ 1, /* kLastFast */ 1);
-                break;
-            case 9:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 6, /* kFastFlush */ 1, /* kLastFast */ 0);
-                break;
-            case 8:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 7, /* kFastFlush */ 1, /* kLastFast */ 0);
-                break;
-            case 7:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 8, /* kFastFlush */ 1, /* kLastFast */ 0);
-                break;
-            case 6: ZSTD_FALLTHROUGH;
-            default:
-                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 9, /* kFastFlush */ 1, /* kLastFast */ 1);
-                break;
-            }
-        }
-    }
-    assert(bitC.ptr <= bitC.endPtr);
-
-    return HUF_closeCStream(&bitC);
-}
-
-#if DYNAMIC_BMI2
-
-static BMI2_TARGET_ATTRIBUTE size_t
-HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,
-                                   const void* src, size_t srcSize,
-                                   const HUF_CElt* CTable)
-{
-    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
-}
-
-static size_t
-HUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize,
-                                      const void* src, size_t srcSize,
-                                      const HUF_CElt* CTable)
-{
-    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
-}
-
-static size_t
-HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
-                              const void* src, size_t srcSize,
-                              const HUF_CElt* CTable, const int flags)
-{
-    if (flags & HUF_flags_bmi2) {
-        return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable);
-    }
-    return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable);
-}
-
-#else
-
-static size_t
-HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
-                              const void* src, size_t srcSize,
-                              const HUF_CElt* CTable, const int flags)
-{
-    (void)flags;
-    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
-}
-
-#endif
-
-size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags)
-{
-    return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags);
-}
-
-static size_t
-HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
-                              const void* src, size_t srcSize,
-                              const HUF_CElt* CTable, int flags)
-{
-    size_t const segmentSize = (srcSize+3)/4;   /* first 3 segments */
-    const BYTE* ip = (const BYTE*) src;
-    const BYTE* const iend = ip + srcSize;
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
-
-    if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */
-    if (srcSize < 12) return 0;   /* no saving possible : too small input */
-    op += 6;   /* jumpTable */
-
-    assert(op <= oend);
-    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, flags) );
-        if (cSize == 0 || cSize > 65535) return 0;
-        MEM_writeLE16(ostart, (U16)cSize);
-        op += cSize;
-    }
-
-    ip += segmentSize;
-    assert(op <= oend);
-    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, flags) );
-        if (cSize == 0 || cSize > 65535) return 0;
-        MEM_writeLE16(ostart+2, (U16)cSize);
-        op += cSize;
-    }
-
-    ip += segmentSize;
-    assert(op <= oend);
-    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, flags) );
-        if (cSize == 0 || cSize > 65535) return 0;
-        MEM_writeLE16(ostart+4, (U16)cSize);
-        op += cSize;
-    }
-
-    ip += segmentSize;
-    assert(op <= oend);
-    assert(ip <= iend);
-    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, (size_t)(iend-ip), CTable, flags) );
-        if (cSize == 0 || cSize > 65535) return 0;
-        op += cSize;
-    }
-
-    return (size_t)(op-ostart);
-}
-
-size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags)
-{
-    return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags);
-}
-
-typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;
-
-static size_t HUF_compressCTable_internal(
-                BYTE* const ostart, BYTE* op, BYTE* const oend,
-                const void* src, size_t srcSize,
-                HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int flags)
-{
-    size_t const cSize = (nbStreams==HUF_singleStream) ?
-                         HUF_compress1X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, flags) :
-                         HUF_compress4X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, flags);
-    if (HUF_isError(cSize)) { return cSize; }
-    if (cSize==0) { return 0; }   /* uncompressible */
-    op += cSize;
-    /* check compressibility */
-    assert(op >= ostart);
-    if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
-    return (size_t)(op-ostart);
-}
-
-typedef struct {
-    unsigned count[HUF_SYMBOLVALUE_MAX + 1];
-    HUF_CElt CTable[HUF_CTABLE_SIZE_ST(HUF_SYMBOLVALUE_MAX)];
-    union {
-        HUF_buildCTable_wksp_tables buildCTable_wksp;
-        HUF_WriteCTableWksp writeCTable_wksp;
-        U32 hist_wksp[HIST_WKSP_SIZE_U32];
-    } wksps;
-} HUF_compress_tables_t;
-
-#define SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE 4096
-#define SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO 10  /* Must be >= 2 */
-
-unsigned HUF_cardinality(const unsigned* count, unsigned maxSymbolValue)
-{
-    unsigned cardinality = 0;
-    unsigned i;
-
-    for (i = 0; i < maxSymbolValue + 1; i++) {
-        if (count[i] != 0) cardinality += 1;
-    }
-
-    return cardinality;
-}
-
-unsigned HUF_minTableLog(unsigned symbolCardinality)
-{
-    U32 minBitsSymbols = ZSTD_highbit32(symbolCardinality) + 1;
-    return minBitsSymbols;
-}
-
-unsigned HUF_optimalTableLog(
-            unsigned maxTableLog,
-            size_t srcSize,
-            unsigned maxSymbolValue,
-            void* workSpace, size_t wkspSize,
-            HUF_CElt* table,
-      const unsigned* count,
-            int flags)
-{
-    assert(srcSize > 1); /* Not supported, RLE should be used instead */
-    assert(wkspSize >= sizeof(HUF_buildCTable_wksp_tables));
-
-    if (!(flags & HUF_flags_optimalDepth)) {
-        /* cheap evaluation, based on FSE */
-        return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1);
-    }
-
-    {   BYTE* dst = (BYTE*)workSpace + sizeof(HUF_WriteCTableWksp);
-        size_t dstSize = wkspSize - sizeof(HUF_WriteCTableWksp);
-        size_t hSize, newSize;
-        const unsigned symbolCardinality = HUF_cardinality(count, maxSymbolValue);
-        const unsigned minTableLog = HUF_minTableLog(symbolCardinality);
-        size_t optSize = ((size_t) ~0) - 1;
-        unsigned optLog = maxTableLog, optLogGuess;
-
-        DEBUGLOG(6, "HUF_optimalTableLog: probing huf depth (srcSize=%zu)", srcSize);
-
-        /* Search until size increases */
-        for (optLogGuess = minTableLog; optLogGuess <= maxTableLog; optLogGuess++) {
-            DEBUGLOG(7, "checking for huffLog=%u", optLogGuess);
-
-            {   size_t maxBits = HUF_buildCTable_wksp(table, count, maxSymbolValue, optLogGuess, workSpace, wkspSize);
-                if (ERR_isError(maxBits)) continue;
-
-                if (maxBits < optLogGuess && optLogGuess > minTableLog) break;
-
-                hSize = HUF_writeCTable_wksp(dst, dstSize, table, maxSymbolValue, (U32)maxBits, workSpace, wkspSize);
-            }
-
-            if (ERR_isError(hSize)) continue;
-
-            newSize = HUF_estimateCompressedSize(table, count, maxSymbolValue) + hSize;
-
-            if (newSize > optSize + 1) {
-                break;
-            }
-
-            if (newSize < optSize) {
-                optSize = newSize;
-                optLog = optLogGuess;
-            }
-        }
-        assert(optLog <= HUF_TABLELOG_MAX);
-        return optLog;
-    }
-}
-
-/* HUF_compress_internal() :
- * `workSpace_align4` must be aligned on 4-bytes boundaries,
- * and occupies the same space as a table of HUF_WORKSPACE_SIZE_U64 unsigned */
-static size_t
-HUF_compress_internal (void* dst, size_t dstSize,
-                 const void* src, size_t srcSize,
-                       unsigned maxSymbolValue, unsigned huffLog,
-                       HUF_nbStreams_e nbStreams,
-                       void* workSpace, size_t wkspSize,
-                       HUF_CElt* oldHufTable, HUF_repeat* repeat, int flags)
-{
-    HUF_compress_tables_t* const table = (HUF_compress_tables_t*)HUF_alignUpWorkspace(workSpace, &wkspSize, ZSTD_ALIGNOF(size_t));
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
-
-    DEBUGLOG(5, "HUF_compress_internal (srcSize=%zu)", srcSize);
-    HUF_STATIC_ASSERT(sizeof(*table) + HUF_WORKSPACE_MAX_ALIGNMENT <= HUF_WORKSPACE_SIZE);
-
-    /* checks & inits */
-    if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall);
-    if (!srcSize) return 0;  /* Uncompressed */
-    if (!dstSize) return 0;  /* cannot fit anything within dst budget */
-    if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* current block size limit */
-    if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
-    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
-    if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
-    if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;
-
-    /* Heuristic : If old table is valid, use it for small inputs */
-    if ((flags & HUF_flags_preferRepeat) && repeat && *repeat == HUF_repeat_valid) {
-        return HUF_compressCTable_internal(ostart, op, oend,
-                                           src, srcSize,
-                                           nbStreams, oldHufTable, flags);
-    }
-
-    /* If uncompressible data is suspected, do a smaller sampling first */
-    DEBUG_STATIC_ASSERT(SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO >= 2);
-    if ((flags & HUF_flags_suspectUncompressible) && srcSize >= (SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE * SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO)) {
-        size_t largestTotal = 0;
-        DEBUGLOG(5, "input suspected incompressible : sampling to check");
-        {   unsigned maxSymbolValueBegin = maxSymbolValue;
-            CHECK_V_F(largestBegin, HIST_count_simple (table->count, &maxSymbolValueBegin, (const BYTE*)src, SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) );
-            largestTotal += largestBegin;
-        }
-        {   unsigned maxSymbolValueEnd = maxSymbolValue;
-            CHECK_V_F(largestEnd, HIST_count_simple (table->count, &maxSymbolValueEnd, (const BYTE*)src + srcSize - SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE, SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) );
-            largestTotal += largestEnd;
-        }
-        if (largestTotal <= ((2 * SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) >> 7)+4) return 0;   /* heuristic : probably not compressible enough */
-    }
-
-    /* Scan input and build symbol stats */
-    {   CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->wksps.hist_wksp, sizeof(table->wksps.hist_wksp)) );
-        if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */
-        if (largest <= (srcSize >> 7)+4) return 0;   /* heuristic : probably not compressible enough */
-    }
-    DEBUGLOG(6, "histogram detail completed (%zu symbols)", showU32(table->count, maxSymbolValue+1));
-
-    /* Check validity of previous table */
-    if ( repeat
-      && *repeat == HUF_repeat_check
-      && !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) {
-        *repeat = HUF_repeat_none;
-    }
-    /* Heuristic : use existing table for small inputs */
-    if ((flags & HUF_flags_preferRepeat) && repeat && *repeat != HUF_repeat_none) {
-        return HUF_compressCTable_internal(ostart, op, oend,
-                                           src, srcSize,
-                                           nbStreams, oldHufTable, flags);
-    }
-
-    /* Build Huffman Tree */
-    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue, &table->wksps, sizeof(table->wksps), table->CTable, table->count, flags);
-    {   size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
-                                            maxSymbolValue, huffLog,
-                                            &table->wksps.buildCTable_wksp, sizeof(table->wksps.buildCTable_wksp));
-        CHECK_F(maxBits);
-        huffLog = (U32)maxBits;
-        DEBUGLOG(6, "bit distribution completed (%zu symbols)", showCTableBits(table->CTable + 1, maxSymbolValue+1));
-    }
-
-    /* Write table description header */
-    {   CHECK_V_F(hSize, HUF_writeCTable_wksp(op, dstSize, table->CTable, maxSymbolValue, huffLog,
-                                              &table->wksps.writeCTable_wksp, sizeof(table->wksps.writeCTable_wksp)) );
-        /* Check if using previous huffman table is beneficial */
-        if (repeat && *repeat != HUF_repeat_none) {
-            size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue);
-            size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue);
-            if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {
-                return HUF_compressCTable_internal(ostart, op, oend,
-                                                   src, srcSize,
-                                                   nbStreams, oldHufTable, flags);
-        }   }
-
-        /* Use the new huffman table */
-        if (hSize + 12ul >= srcSize) { return 0; }
-        op += hSize;
-        if (repeat) { *repeat = HUF_repeat_none; }
-        if (oldHufTable)
-            ZSTD_memcpy(oldHufTable, table->CTable, sizeof(table->CTable));  /* Save new table */
-    }
-    return HUF_compressCTable_internal(ostart, op, oend,
-                                       src, srcSize,
-                                       nbStreams, table->CTable, flags);
-}
-
-size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
-                      const void* src, size_t srcSize,
-                      unsigned maxSymbolValue, unsigned huffLog,
-                      void* workSpace, size_t wkspSize,
-                      HUF_CElt* hufTable, HUF_repeat* repeat, int flags)
-{
-    DEBUGLOG(5, "HUF_compress1X_repeat (srcSize = %zu)", srcSize);
-    return HUF_compress_internal(dst, dstSize, src, srcSize,
-                                 maxSymbolValue, huffLog, HUF_singleStream,
-                                 workSpace, wkspSize, hufTable,
-                                 repeat, flags);
-}
-
-/* HUF_compress4X_repeat():
- * compress input using 4 streams.
- * consider skipping quickly
- * reuse an existing huffman compression table */
-size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
-                      const void* src, size_t srcSize,
-                      unsigned maxSymbolValue, unsigned huffLog,
-                      void* workSpace, size_t wkspSize,
-                      HUF_CElt* hufTable, HUF_repeat* repeat, int flags)
-{
-    DEBUGLOG(5, "HUF_compress4X_repeat (srcSize = %zu)", srcSize);
-    return HUF_compress_internal(dst, dstSize, src, srcSize,
-                                 maxSymbolValue, huffLog, HUF_fourStreams,
-                                 workSpace, wkspSize,
-                                 hufTable, repeat, flags);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_compress.cpp b/src/duckdb/third_party/zstd/compress/zstd_compress.cpp
deleted file mode 100644
index df5626e5f..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_compress.cpp
+++ /dev/null
@@ -1,7147 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zstd/common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
-#include "zstd/common/zstd_deps.h"  /* INT_MAX, ZSTD_memset, ZSTD_memcpy */
-#include "zstd/common/mem.h"
-#include "zstd/compress/hist.h"           /* HIST_countFast_wksp */
-#define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */
-#include "zstd/common/fse.h"
-#include "zstd/common/huf.h"
-#include "zstd/compress/zstd_compress_internal.h"
-#include "zstd/compress/zstd_compress_sequences.h"
-#include "zstd/compress/zstd_compress_literals.h"
-#include "zstd/compress/zstd_fast.h"
-#include "zstd/compress/zstd_double_fast.h"
-#include "zstd/compress/zstd_lazy.h"
-#include "zstd/compress/zstd_opt.h"
-#include "zstd/compress/zstd_ldm.h"
-#include "zstd/compress/zstd_compress_superblock.h"
-#include "zstd/common/bits.h"      /* ZSTD_highbit32, ZSTD_rotateRight_U64 */
-
-/* ***************************************************************
-*  Tuning parameters
-*****************************************************************/
-/*!
- * COMPRESS_HEAPMODE :
- * Select how default decompression function ZSTD_compress() allocates its context,
- * on stack (0, default), or into heap (1).
- * Note that functions with explicit context such as ZSTD_compressCCtx() are unaffected.
- */
-#ifndef ZSTD_COMPRESS_HEAPMODE
-#  define ZSTD_COMPRESS_HEAPMODE 0
-#endif
-
-/*!
- * ZSTD_HASHLOG3_MAX :
- * Maximum size of the hash table dedicated to find 3-bytes matches,
- * in log format, aka 17 => 1 << 17 == 128Ki positions.
- * This structure is only used in zstd_opt.
- * Since allocation is centralized for all strategies, it has to be known here.
- * The actual (selected) size of the hash table is then stored in ZSTD_matchState_t.hashLog3,
- * so that zstd_opt.c doesn't need to know about this constant.
- */
-#ifndef ZSTD_HASHLOG3_MAX
-#  define ZSTD_HASHLOG3_MAX 17
-#endif
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Helper functions
-***************************************/
-/* ZSTD_compressBound()
- * Note that the result from this function is only valid for
- * the one-pass compression functions.
- * When employing the streaming mode,
- * if flushes are frequently altering the size of blocks,
- * the overhead from block headers can make the compressed data larger
- * than the return value of ZSTD_compressBound().
- */
-size_t ZSTD_compressBound(size_t srcSize) {
-    size_t const r = ZSTD_COMPRESSBOUND(srcSize);
-    if (r==0) return ERROR(srcSize_wrong);
-    return r;
-}
-
-
-/*-*************************************
-*  Context memory management
-***************************************/
-struct ZSTD_CDict_s {
-    const void* dictContent;
-    size_t dictContentSize;
-    ZSTD_dictContentType_e dictContentType; /* The dictContentType the CDict was created with */
-    U32* entropyWorkspace; /* entropy workspace of HUF_WORKSPACE_SIZE bytes */
-    ZSTD_cwksp workspace;
-    ZSTD_matchState_t matchState;
-    ZSTD_compressedBlockState_t cBlockState;
-    ZSTD_customMem customMem;
-    U32 dictID;
-    int compressionLevel; /* 0 indicates that advanced API was used to select CDict params */
-    ZSTD_paramSwitch_e useRowMatchFinder; /* Indicates whether the CDict was created with params that would use
-                                           * row-based matchfinder. Unless the cdict is reloaded, we will use
-                                           * the same greedy/lazy matchfinder at compression time.
-                                           */
-};  /* typedef'd to ZSTD_CDict within "zstd.h" */
-
-ZSTD_CCtx* ZSTD_createCCtx(void)
-{
-    return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);
-}
-
-static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
-{
-    assert(cctx != NULL);
-    ZSTD_memset(cctx, 0, sizeof(*cctx));
-    cctx->customMem = memManager;
-    cctx->bmi2 = ZSTD_cpuSupportsBmi2();
-    {   size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);
-        assert(!ZSTD_isError(err));
-        (void)err;
-    }
-}
-
-ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
-{
-    ZSTD_STATIC_ASSERT(zcss_init==0);
-    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
-    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
-    {   ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_customMalloc(sizeof(ZSTD_CCtx), customMem);
-        if (!cctx) return NULL;
-        ZSTD_initCCtx(cctx, customMem);
-        return cctx;
-    }
-}
-
-ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)
-{
-    ZSTD_cwksp ws;
-    ZSTD_CCtx* cctx;
-    if (workspaceSize <= sizeof(ZSTD_CCtx)) return NULL;  /* minimum size */
-    if ((size_t)workspace & 7) return NULL;  /* must be 8-aligned */
-    ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc);
-
-    cctx = (ZSTD_CCtx*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CCtx));
-    if (cctx == NULL) return NULL;
-
-    ZSTD_memset(cctx, 0, sizeof(ZSTD_CCtx));
-    ZSTD_cwksp_move(&cctx->workspace, &ws);
-    cctx->staticSize = workspaceSize;
-
-    /* statically sized space. entropyWorkspace never moves (but prev/next block swap places) */
-    if (!ZSTD_cwksp_check_available(&cctx->workspace, ENTROPY_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t))) return NULL;
-    cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));
-    cctx->blockState.nextCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));
-    cctx->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cctx->workspace, ENTROPY_WORKSPACE_SIZE);
-    cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
-    return cctx;
-}
-
-/**
- * Clears and frees all of the dictionaries in the CCtx.
- */
-static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
-{
-    ZSTD_customFree(cctx->localDict.dictBuffer, cctx->customMem);
-    ZSTD_freeCDict(cctx->localDict.cdict);
-    ZSTD_memset(&cctx->localDict, 0, sizeof(cctx->localDict));
-    ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
-    cctx->cdict = NULL;
-}
-
-static size_t ZSTD_sizeof_localDict(ZSTD_localDict dict)
-{
-    size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0;
-    size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict);
-    return bufferSize + cdictSize;
-}
-
-static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)
-{
-    assert(cctx != NULL);
-    assert(cctx->staticSize == 0);
-    ZSTD_clearAllDicts(cctx);
-#ifdef ZSTD_MULTITHREAD
-    ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;
-#endif
-    ZSTD_cwksp_free(&cctx->workspace, cctx->customMem);
-}
-
-size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
-{
-    DEBUGLOG(3, "ZSTD_freeCCtx (address: %p)", (void*)cctx);
-    if (cctx==NULL) return 0;   /* support free on NULL */
-    RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
-                    "not compatible with static CCtx");
-    {   int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx);
-        ZSTD_freeCCtxContent(cctx);
-        if (!cctxInWorkspace) ZSTD_customFree(cctx, cctx->customMem);
-    }
-    return 0;
-}
-
-
-static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
-{
-#ifdef ZSTD_MULTITHREAD
-    return ZSTDMT_sizeof_CCtx(cctx->mtctx);
-#else
-    (void)cctx;
-    return 0;
-#endif
-}
-
-
-size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
-{
-    if (cctx==NULL) return 0;   /* support sizeof on NULL */
-    /* cctx may be in the workspace */
-    return (cctx->workspace.workspace == cctx ? 0 : sizeof(*cctx))
-           + ZSTD_cwksp_sizeof(&cctx->workspace)
-           + ZSTD_sizeof_localDict(cctx->localDict)
-           + ZSTD_sizeof_mtctx(cctx);
-}
-
-size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
-{
-    return ZSTD_sizeof_CCtx(zcs);  /* same object */
-}
-
-/* private API call, for dictBuilder only */
-const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); }
-
-/* Returns true if the strategy supports using a row based matchfinder */
-static int ZSTD_rowMatchFinderSupported(const ZSTD_strategy strategy) {
-    return (strategy >= ZSTD_greedy && strategy <= ZSTD_lazy2);
-}
-
-/* Returns true if the strategy and useRowMatchFinder mode indicate that we will use the row based matchfinder
- * for this compression.
- */
-static int ZSTD_rowMatchFinderUsed(const ZSTD_strategy strategy, const ZSTD_paramSwitch_e mode) {
-    assert(mode != ZSTD_ps_auto);
-    return ZSTD_rowMatchFinderSupported(strategy) && (mode == ZSTD_ps_enable);
-}
-
-/* Returns row matchfinder usage given an initial mode and cParams */
-static ZSTD_paramSwitch_e ZSTD_resolveRowMatchFinderMode(ZSTD_paramSwitch_e mode,
-                                                         const ZSTD_compressionParameters* const cParams) {
-#if defined(ZSTD_ARCH_X86_SSE2) || defined(ZSTD_ARCH_ARM_NEON)
-    int const kHasSIMD128 = 1;
-#else
-    int const kHasSIMD128 = 0;
-#endif
-    if (mode != ZSTD_ps_auto) return mode; /* if requested enabled, but no SIMD, we still will use row matchfinder */
-    mode = ZSTD_ps_disable;
-    if (!ZSTD_rowMatchFinderSupported(cParams->strategy)) return mode;
-    if (kHasSIMD128) {
-        if (cParams->windowLog > 14) mode = ZSTD_ps_enable;
-    } else {
-        if (cParams->windowLog > 17) mode = ZSTD_ps_enable;
-    }
-    return mode;
-}
-
-/* Returns block splitter usage (generally speaking, when using slower/stronger compression modes) */
-static ZSTD_paramSwitch_e ZSTD_resolveBlockSplitterMode(ZSTD_paramSwitch_e mode,
-                                                        const ZSTD_compressionParameters* const cParams) {
-    if (mode != ZSTD_ps_auto) return mode;
-    return (cParams->strategy >= ZSTD_btopt && cParams->windowLog >= 17) ? ZSTD_ps_enable : ZSTD_ps_disable;
-}
-
-/* Returns 1 if the arguments indicate that we should allocate a chainTable, 0 otherwise */
-static int ZSTD_allocateChainTable(const ZSTD_strategy strategy,
-                                   const ZSTD_paramSwitch_e useRowMatchFinder,
-                                   const U32 forDDSDict) {
-    assert(useRowMatchFinder != ZSTD_ps_auto);
-    /* We always should allocate a chaintable if we are allocating a matchstate for a DDS dictionary matchstate.
-     * We do not allocate a chaintable if we are using ZSTD_fast, or are using the row-based matchfinder.
-     */
-    return forDDSDict || ((strategy != ZSTD_fast) && !ZSTD_rowMatchFinderUsed(strategy, useRowMatchFinder));
-}
-
-/* Returns ZSTD_ps_enable if compression parameters are such that we should
- * enable long distance matching (wlog >= 27, strategy >= btopt).
- * Returns ZSTD_ps_disable otherwise.
- */
-static ZSTD_paramSwitch_e ZSTD_resolveEnableLdm(ZSTD_paramSwitch_e mode,
-                                 const ZSTD_compressionParameters* const cParams) {
-    if (mode != ZSTD_ps_auto) return mode;
-    return (cParams->strategy >= ZSTD_btopt && cParams->windowLog >= 27) ? ZSTD_ps_enable : ZSTD_ps_disable;
-}
-
-static int ZSTD_resolveExternalSequenceValidation(int mode) {
-    return mode;
-}
-
-/* Resolves maxBlockSize to the default if no value is present. */
-static size_t ZSTD_resolveMaxBlockSize(size_t maxBlockSize) {
-    if (maxBlockSize == 0) {
-        return ZSTD_BLOCKSIZE_MAX;
-    } else {
-        return maxBlockSize;
-    }
-}
-
-static ZSTD_paramSwitch_e ZSTD_resolveExternalRepcodeSearch(ZSTD_paramSwitch_e value, int cLevel) {
-    if (value != ZSTD_ps_auto) return value;
-    if (cLevel < 10) {
-        return ZSTD_ps_disable;
-    } else {
-        return ZSTD_ps_enable;
-    }
-}
-
-/* Returns 1 if compression parameters are such that CDict hashtable and chaintable indices are tagged.
- * If so, the tags need to be removed in ZSTD_resetCCtx_byCopyingCDict. */
-static int ZSTD_CDictIndicesAreTagged(const ZSTD_compressionParameters* const cParams) {
-    return cParams->strategy == ZSTD_fast || cParams->strategy == ZSTD_dfast;
-}
-
-static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(
-        ZSTD_compressionParameters cParams)
-{
-    ZSTD_CCtx_params cctxParams;
-    /* should not matter, as all cParams are presumed properly defined */
-    ZSTD_CCtxParams_init(&cctxParams, ZSTD_CLEVEL_DEFAULT);
-    cctxParams.cParams = cParams;
-
-    /* Adjust advanced params according to cParams */
-    cctxParams.ldmParams.enableLdm = ZSTD_resolveEnableLdm(cctxParams.ldmParams.enableLdm, &cParams);
-    if (cctxParams.ldmParams.enableLdm == ZSTD_ps_enable) {
-        ZSTD_ldm_adjustParameters(&cctxParams.ldmParams, &cParams);
-        assert(cctxParams.ldmParams.hashLog >= cctxParams.ldmParams.bucketSizeLog);
-        assert(cctxParams.ldmParams.hashRateLog < 32);
-    }
-    cctxParams.useBlockSplitter = ZSTD_resolveBlockSplitterMode(cctxParams.useBlockSplitter, &cParams);
-    cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);
-    cctxParams.validateSequences = ZSTD_resolveExternalSequenceValidation(cctxParams.validateSequences);
-    cctxParams.maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams.maxBlockSize);
-    cctxParams.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(cctxParams.searchForExternalRepcodes,
-                                                                             cctxParams.compressionLevel);
-    assert(!ZSTD_checkCParams(cParams));
-    return cctxParams;
-}
-
-static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(
-        ZSTD_customMem customMem)
-{
-    ZSTD_CCtx_params* params;
-    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
-    params = (ZSTD_CCtx_params*)ZSTD_customCalloc(
-            sizeof(ZSTD_CCtx_params), customMem);
-    if (!params) { return NULL; }
-    ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);
-    params->customMem = customMem;
-    return params;
-}
-
-ZSTD_CCtx_params* ZSTD_createCCtxParams(void)
-{
-    return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem);
-}
-
-size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params)
-{
-    if (params == NULL) { return 0; }
-    ZSTD_customFree(params, params->customMem);
-    return 0;
-}
-
-size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params)
-{
-    return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);
-}
-
-size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) {
-    RETURN_ERROR_IF(!cctxParams, GENERIC, "NULL pointer!");
-    ZSTD_memset(cctxParams, 0, sizeof(*cctxParams));
-    cctxParams->compressionLevel = compressionLevel;
-    cctxParams->fParams.contentSizeFlag = 1;
-    return 0;
-}
-
-#define ZSTD_NO_CLEVEL 0
-
-/**
- * Initializes `cctxParams` from `params` and `compressionLevel`.
- * @param compressionLevel If params are derived from a compression level then that compression level, otherwise ZSTD_NO_CLEVEL.
- */
-static void
-ZSTD_CCtxParams_init_internal(ZSTD_CCtx_params* cctxParams,
-                        const ZSTD_parameters* params,
-                              int compressionLevel)
-{
-    assert(!ZSTD_checkCParams(params->cParams));
-    ZSTD_memset(cctxParams, 0, sizeof(*cctxParams));
-    cctxParams->cParams = params->cParams;
-    cctxParams->fParams = params->fParams;
-    /* Should not matter, as all cParams are presumed properly defined.
-     * But, set it for tracing anyway.
-     */
-    cctxParams->compressionLevel = compressionLevel;
-    cctxParams->useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams->useRowMatchFinder, &params->cParams);
-    cctxParams->useBlockSplitter = ZSTD_resolveBlockSplitterMode(cctxParams->useBlockSplitter, &params->cParams);
-    cctxParams->ldmParams.enableLdm = ZSTD_resolveEnableLdm(cctxParams->ldmParams.enableLdm, &params->cParams);
-    cctxParams->validateSequences = ZSTD_resolveExternalSequenceValidation(cctxParams->validateSequences);
-    cctxParams->maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams->maxBlockSize);
-    cctxParams->searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(cctxParams->searchForExternalRepcodes, compressionLevel);
-    DEBUGLOG(4, "ZSTD_CCtxParams_init_internal: useRowMatchFinder=%d, useBlockSplitter=%d ldm=%d",
-                cctxParams->useRowMatchFinder, cctxParams->useBlockSplitter, cctxParams->ldmParams.enableLdm);
-}
-
-size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params)
-{
-    RETURN_ERROR_IF(!cctxParams, GENERIC, "NULL pointer!");
-    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
-    ZSTD_CCtxParams_init_internal(cctxParams, &params, ZSTD_NO_CLEVEL);
-    return 0;
-}
-
-/**
- * Sets cctxParams' cParams and fParams from params, but otherwise leaves them alone.
- * @param params Validated zstd parameters.
- */
-static void ZSTD_CCtxParams_setZstdParams(
-        ZSTD_CCtx_params* cctxParams, const ZSTD_parameters* params)
-{
-    assert(!ZSTD_checkCParams(params->cParams));
-    cctxParams->cParams = params->cParams;
-    cctxParams->fParams = params->fParams;
-    /* Should not matter, as all cParams are presumed properly defined.
-     * But, set it for tracing anyway.
-     */
-    cctxParams->compressionLevel = ZSTD_NO_CLEVEL;
-}
-
-ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
-{
-    ZSTD_bounds bounds = { 0, 0, 0 };
-
-    switch(param)
-    {
-    case ZSTD_c_compressionLevel:
-        bounds.lowerBound = ZSTD_minCLevel();
-        bounds.upperBound = ZSTD_maxCLevel();
-        return bounds;
-
-    case ZSTD_c_windowLog:
-        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
-        bounds.upperBound = ZSTD_WINDOWLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_hashLog:
-        bounds.lowerBound = ZSTD_HASHLOG_MIN;
-        bounds.upperBound = ZSTD_HASHLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_chainLog:
-        bounds.lowerBound = ZSTD_CHAINLOG_MIN;
-        bounds.upperBound = ZSTD_CHAINLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_searchLog:
-        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
-        bounds.upperBound = ZSTD_SEARCHLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_minMatch:
-        bounds.lowerBound = ZSTD_MINMATCH_MIN;
-        bounds.upperBound = ZSTD_MINMATCH_MAX;
-        return bounds;
-
-    case ZSTD_c_targetLength:
-        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
-        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
-        return bounds;
-
-    case ZSTD_c_strategy:
-        bounds.lowerBound = ZSTD_STRATEGY_MIN;
-        bounds.upperBound = ZSTD_STRATEGY_MAX;
-        return bounds;
-
-    case ZSTD_c_contentSizeFlag:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_checksumFlag:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_dictIDFlag:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_nbWorkers:
-        bounds.lowerBound = 0;
-#ifdef ZSTD_MULTITHREAD
-        bounds.upperBound = ZSTDMT_NBWORKERS_MAX;
-#else
-        bounds.upperBound = 0;
-#endif
-        return bounds;
-
-    case ZSTD_c_jobSize:
-        bounds.lowerBound = 0;
-#ifdef ZSTD_MULTITHREAD
-        bounds.upperBound = ZSTDMT_JOBSIZE_MAX;
-#else
-        bounds.upperBound = 0;
-#endif
-        return bounds;
-
-    case ZSTD_c_overlapLog:
-#ifdef ZSTD_MULTITHREAD
-        bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
-        bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
-#else
-        bounds.lowerBound = 0;
-        bounds.upperBound = 0;
-#endif
-        return bounds;
-
-    case ZSTD_c_enableDedicatedDictSearch:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_enableLongDistanceMatching:
-        bounds.lowerBound = (int)ZSTD_ps_auto;
-        bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
-    case ZSTD_c_ldmHashLog:
-        bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;
-        bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_ldmMinMatch:
-        bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;
-        bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;
-        return bounds;
-
-    case ZSTD_c_ldmBucketSizeLog:
-        bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;
-        bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;
-        return bounds;
-
-    case ZSTD_c_ldmHashRateLog:
-        bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;
-        bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;
-        return bounds;
-
-    /* experimental parameters */
-    case ZSTD_c_rsyncable:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_forceMaxWindow :
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_format:
-        ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
-        bounds.lowerBound = ZSTD_f_zstd1;
-        bounds.upperBound = ZSTD_f_zstd1_magicless;   /* note : how to ensure at compile time that this is the highest value enum ? */
-        return bounds;
-
-    case ZSTD_c_forceAttachDict:
-        ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceLoad);
-        bounds.lowerBound = ZSTD_dictDefaultAttach;
-        bounds.upperBound = ZSTD_dictForceLoad;       /* note : how to ensure at compile time that this is the highest value enum ? */
-        return bounds;
-
-    case ZSTD_c_literalCompressionMode:
-        ZSTD_STATIC_ASSERT(ZSTD_ps_auto < ZSTD_ps_enable && ZSTD_ps_enable < ZSTD_ps_disable);
-        bounds.lowerBound = (int)ZSTD_ps_auto;
-        bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
-    case ZSTD_c_targetCBlockSize:
-        bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;
-        bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;
-        return bounds;
-
-    case ZSTD_c_srcSizeHint:
-        bounds.lowerBound = ZSTD_SRCSIZEHINT_MIN;
-        bounds.upperBound = ZSTD_SRCSIZEHINT_MAX;
-        return bounds;
-
-    case ZSTD_c_stableInBuffer:
-    case ZSTD_c_stableOutBuffer:
-        bounds.lowerBound = (int)ZSTD_bm_buffered;
-        bounds.upperBound = (int)ZSTD_bm_stable;
-        return bounds;
-
-    case ZSTD_c_blockDelimiters:
-        bounds.lowerBound = (int)ZSTD_sf_noBlockDelimiters;
-        bounds.upperBound = (int)ZSTD_sf_explicitBlockDelimiters;
-        return bounds;
-
-    case ZSTD_c_validateSequences:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_useBlockSplitter:
-        bounds.lowerBound = (int)ZSTD_ps_auto;
-        bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
-    case ZSTD_c_useRowMatchFinder:
-        bounds.lowerBound = (int)ZSTD_ps_auto;
-        bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
-    case ZSTD_c_deterministicRefPrefix:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_prefetchCDictTables:
-        bounds.lowerBound = (int)ZSTD_ps_auto;
-        bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
-    case ZSTD_c_enableSeqProducerFallback:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_maxBlockSize:
-        bounds.lowerBound = ZSTD_BLOCKSIZE_MAX_MIN;
-        bounds.upperBound = ZSTD_BLOCKSIZE_MAX;
-        return bounds;
-
-    case ZSTD_c_searchForExternalRepcodes:
-        bounds.lowerBound = (int)ZSTD_ps_auto;
-        bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
-    default:
-        bounds.error = ERROR(parameter_unsupported);
-        return bounds;
-    }
-}
-
-/* ZSTD_cParam_clampBounds:
- * Clamps the value into the bounded range.
- */
-static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value)
-{
-    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
-    if (ZSTD_isError(bounds.error)) return bounds.error;
-    if (*value < bounds.lowerBound) *value = bounds.lowerBound;
-    if (*value > bounds.upperBound) *value = bounds.upperBound;
-    return 0;
-}
-
-#define BOUNDCHECK(cParam, val)                                       \
-    do {                                                              \
-        RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val),        \
-                        parameter_outOfBound, "Param out of bounds"); \
-    } while (0)
-
-
-static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
-{
-    switch(param)
-    {
-    case ZSTD_c_compressionLevel:
-    case ZSTD_c_hashLog:
-    case ZSTD_c_chainLog:
-    case ZSTD_c_searchLog:
-    case ZSTD_c_minMatch:
-    case ZSTD_c_targetLength:
-    case ZSTD_c_strategy:
-        return 1;
-
-    case ZSTD_c_format:
-    case ZSTD_c_windowLog:
-    case ZSTD_c_contentSizeFlag:
-    case ZSTD_c_checksumFlag:
-    case ZSTD_c_dictIDFlag:
-    case ZSTD_c_forceMaxWindow :
-    case ZSTD_c_nbWorkers:
-    case ZSTD_c_jobSize:
-    case ZSTD_c_overlapLog:
-    case ZSTD_c_rsyncable:
-    case ZSTD_c_enableDedicatedDictSearch:
-    case ZSTD_c_enableLongDistanceMatching:
-    case ZSTD_c_ldmHashLog:
-    case ZSTD_c_ldmMinMatch:
-    case ZSTD_c_ldmBucketSizeLog:
-    case ZSTD_c_ldmHashRateLog:
-    case ZSTD_c_forceAttachDict:
-    case ZSTD_c_literalCompressionMode:
-    case ZSTD_c_targetCBlockSize:
-    case ZSTD_c_srcSizeHint:
-    case ZSTD_c_stableInBuffer:
-    case ZSTD_c_stableOutBuffer:
-    case ZSTD_c_blockDelimiters:
-    case ZSTD_c_validateSequences:
-    case ZSTD_c_useBlockSplitter:
-    case ZSTD_c_useRowMatchFinder:
-    case ZSTD_c_deterministicRefPrefix:
-    case ZSTD_c_prefetchCDictTables:
-    case ZSTD_c_enableSeqProducerFallback:
-    case ZSTD_c_maxBlockSize:
-    case ZSTD_c_searchForExternalRepcodes:
-    default:
-        return 0;
-    }
-}
-
-size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
-{
-    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
-    if (cctx->streamStage != zcss_init) {
-        if (ZSTD_isUpdateAuthorized(param)) {
-            cctx->cParamsChanged = 1;
-        } else {
-            RETURN_ERROR(stage_wrong, "can only set params in cctx init stage");
-    }   }
-
-    switch(param)
-    {
-    case ZSTD_c_nbWorkers:
-        RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
-                        "MT not compatible with static alloc");
-        break;
-
-    case ZSTD_c_compressionLevel:
-    case ZSTD_c_windowLog:
-    case ZSTD_c_hashLog:
-    case ZSTD_c_chainLog:
-    case ZSTD_c_searchLog:
-    case ZSTD_c_minMatch:
-    case ZSTD_c_targetLength:
-    case ZSTD_c_strategy:
-    case ZSTD_c_ldmHashRateLog:
-    case ZSTD_c_format:
-    case ZSTD_c_contentSizeFlag:
-    case ZSTD_c_checksumFlag:
-    case ZSTD_c_dictIDFlag:
-    case ZSTD_c_forceMaxWindow:
-    case ZSTD_c_forceAttachDict:
-    case ZSTD_c_literalCompressionMode:
-    case ZSTD_c_jobSize:
-    case ZSTD_c_overlapLog:
-    case ZSTD_c_rsyncable:
-    case ZSTD_c_enableDedicatedDictSearch:
-    case ZSTD_c_enableLongDistanceMatching:
-    case ZSTD_c_ldmHashLog:
-    case ZSTD_c_ldmMinMatch:
-    case ZSTD_c_ldmBucketSizeLog:
-    case ZSTD_c_targetCBlockSize:
-    case ZSTD_c_srcSizeHint:
-    case ZSTD_c_stableInBuffer:
-    case ZSTD_c_stableOutBuffer:
-    case ZSTD_c_blockDelimiters:
-    case ZSTD_c_validateSequences:
-    case ZSTD_c_useBlockSplitter:
-    case ZSTD_c_useRowMatchFinder:
-    case ZSTD_c_deterministicRefPrefix:
-    case ZSTD_c_prefetchCDictTables:
-    case ZSTD_c_enableSeqProducerFallback:
-    case ZSTD_c_maxBlockSize:
-    case ZSTD_c_searchForExternalRepcodes:
-        break;
-
-    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
-    }
-    return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);
-}
-
-size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,
-                                    ZSTD_cParameter param, int value)
-{
-    DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value);
-    switch(param)
-    {
-    case ZSTD_c_format :
-        BOUNDCHECK(ZSTD_c_format, value);
-        CCtxParams->format = (ZSTD_format_e)value;
-        return (size_t)CCtxParams->format;
-
-    case ZSTD_c_compressionLevel : {
-        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
-        if (value == 0)
-            CCtxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT; /* 0 == default */
-        else
-            CCtxParams->compressionLevel = value;
-        if (CCtxParams->compressionLevel >= 0) return (size_t)CCtxParams->compressionLevel;
-        return 0;  /* return type (size_t) cannot represent negative values */
-    }
-
-    case ZSTD_c_windowLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_windowLog, value);
-        CCtxParams->cParams.windowLog = (U32)value;
-        return CCtxParams->cParams.windowLog;
-
-    case ZSTD_c_hashLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_hashLog, value);
-        CCtxParams->cParams.hashLog = (U32)value;
-        return CCtxParams->cParams.hashLog;
-
-    case ZSTD_c_chainLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_chainLog, value);
-        CCtxParams->cParams.chainLog = (U32)value;
-        return CCtxParams->cParams.chainLog;
-
-    case ZSTD_c_searchLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_searchLog, value);
-        CCtxParams->cParams.searchLog = (U32)value;
-        return (size_t)value;
-
-    case ZSTD_c_minMatch :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_minMatch, value);
-        CCtxParams->cParams.minMatch = (U32)value;
-        return CCtxParams->cParams.minMatch;
-
-    case ZSTD_c_targetLength :
-        BOUNDCHECK(ZSTD_c_targetLength, value);
-        CCtxParams->cParams.targetLength = (U32)value;
-        return CCtxParams->cParams.targetLength;
-
-    case ZSTD_c_strategy :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_strategy, value);
-        CCtxParams->cParams.strategy = (ZSTD_strategy)value;
-        return (size_t)CCtxParams->cParams.strategy;
-
-    case ZSTD_c_contentSizeFlag :
-        /* Content size written in frame header _when known_ (default:1) */
-        DEBUGLOG(4, "set content size flag = %u", (value!=0));
-        CCtxParams->fParams.contentSizeFlag = value != 0;
-        return (size_t)CCtxParams->fParams.contentSizeFlag;
-
-    case ZSTD_c_checksumFlag :
-        /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
-        CCtxParams->fParams.checksumFlag = value != 0;
-        return (size_t)CCtxParams->fParams.checksumFlag;
-
-    case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
-        DEBUGLOG(4, "set dictIDFlag = %u", (value!=0));
-        CCtxParams->fParams.noDictIDFlag = !value;
-        return !CCtxParams->fParams.noDictIDFlag;
-
-    case ZSTD_c_forceMaxWindow :
-        CCtxParams->forceWindow = (value != 0);
-        return (size_t)CCtxParams->forceWindow;
-
-    case ZSTD_c_forceAttachDict : {
-        const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;
-        BOUNDCHECK(ZSTD_c_forceAttachDict, (int)pref);
-        CCtxParams->attachDictPref = pref;
-        return CCtxParams->attachDictPref;
-    }
-
-    case ZSTD_c_literalCompressionMode : {
-        const ZSTD_paramSwitch_e lcm = (ZSTD_paramSwitch_e)value;
-        BOUNDCHECK(ZSTD_c_literalCompressionMode, (int)lcm);
-        CCtxParams->literalCompressionMode = lcm;
-        return CCtxParams->literalCompressionMode;
-    }
-
-    case ZSTD_c_nbWorkers :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
-#else
-        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
-        CCtxParams->nbWorkers = value;
-        return (size_t)(CCtxParams->nbWorkers);
-#endif
-
-    case ZSTD_c_jobSize :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
-#else
-        /* Adjust to the minimum non-default value. */
-        if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)
-            value = ZSTDMT_JOBSIZE_MIN;
-        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
-        assert(value >= 0);
-        CCtxParams->jobSize = value;
-        return CCtxParams->jobSize;
-#endif
-
-    case ZSTD_c_overlapLog :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
-#else
-        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), "");
-        CCtxParams->overlapLog = value;
-        return (size_t)CCtxParams->overlapLog;
-#endif
-
-    case ZSTD_c_rsyncable :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
-#else
-        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), "");
-        CCtxParams->rsyncable = value;
-        return (size_t)CCtxParams->rsyncable;
-#endif
-
-    case ZSTD_c_enableDedicatedDictSearch :
-        CCtxParams->enableDedicatedDictSearch = (value!=0);
-        return (size_t)CCtxParams->enableDedicatedDictSearch;
-
-    case ZSTD_c_enableLongDistanceMatching :
-        BOUNDCHECK(ZSTD_c_enableLongDistanceMatching, value);
-        CCtxParams->ldmParams.enableLdm = (ZSTD_paramSwitch_e)value;
-        return CCtxParams->ldmParams.enableLdm;
-
-    case ZSTD_c_ldmHashLog :
-        if (value!=0)   /* 0 ==> auto */
-            BOUNDCHECK(ZSTD_c_ldmHashLog, value);
-        CCtxParams->ldmParams.hashLog = (U32)value;
-        return CCtxParams->ldmParams.hashLog;
-
-    case ZSTD_c_ldmMinMatch :
-        if (value!=0)   /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_ldmMinMatch, value);
-        CCtxParams->ldmParams.minMatchLength = (U32)value;
-        return CCtxParams->ldmParams.minMatchLength;
-
-    case ZSTD_c_ldmBucketSizeLog :
-        if (value!=0)   /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);
-        CCtxParams->ldmParams.bucketSizeLog = (U32)value;
-        return CCtxParams->ldmParams.bucketSizeLog;
-
-    case ZSTD_c_ldmHashRateLog :
-        if (value!=0)   /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_ldmHashRateLog, value);
-        CCtxParams->ldmParams.hashRateLog = (U32)value;
-        return CCtxParams->ldmParams.hashRateLog;
-
-    case ZSTD_c_targetCBlockSize :
-        if (value!=0) {  /* 0 ==> default */
-            value = MAX(value, ZSTD_TARGETCBLOCKSIZE_MIN);
-            BOUNDCHECK(ZSTD_c_targetCBlockSize, value);
-        }
-        CCtxParams->targetCBlockSize = (U32)value;
-        return CCtxParams->targetCBlockSize;
-
-    case ZSTD_c_srcSizeHint :
-        if (value!=0)    /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_srcSizeHint, value);
-        CCtxParams->srcSizeHint = value;
-        return (size_t)CCtxParams->srcSizeHint;
-
-    case ZSTD_c_stableInBuffer:
-        BOUNDCHECK(ZSTD_c_stableInBuffer, value);
-        CCtxParams->inBufferMode = (ZSTD_bufferMode_e)value;
-        return CCtxParams->inBufferMode;
-
-    case ZSTD_c_stableOutBuffer:
-        BOUNDCHECK(ZSTD_c_stableOutBuffer, value);
-        CCtxParams->outBufferMode = (ZSTD_bufferMode_e)value;
-        return CCtxParams->outBufferMode;
-
-    case ZSTD_c_blockDelimiters:
-        BOUNDCHECK(ZSTD_c_blockDelimiters, value);
-        CCtxParams->blockDelimiters = (ZSTD_sequenceFormat_e)value;
-        return CCtxParams->blockDelimiters;
-
-    case ZSTD_c_validateSequences:
-        BOUNDCHECK(ZSTD_c_validateSequences, value);
-        CCtxParams->validateSequences = value;
-        return (size_t)CCtxParams->validateSequences;
-
-    case ZSTD_c_useBlockSplitter:
-        BOUNDCHECK(ZSTD_c_useBlockSplitter, value);
-        CCtxParams->useBlockSplitter = (ZSTD_paramSwitch_e)value;
-        return CCtxParams->useBlockSplitter;
-
-    case ZSTD_c_useRowMatchFinder:
-        BOUNDCHECK(ZSTD_c_useRowMatchFinder, value);
-        CCtxParams->useRowMatchFinder = (ZSTD_paramSwitch_e)value;
-        return CCtxParams->useRowMatchFinder;
-
-    case ZSTD_c_deterministicRefPrefix:
-        BOUNDCHECK(ZSTD_c_deterministicRefPrefix, value);
-        CCtxParams->deterministicRefPrefix = !!value;
-        return (size_t)CCtxParams->deterministicRefPrefix;
-
-    case ZSTD_c_prefetchCDictTables:
-        BOUNDCHECK(ZSTD_c_prefetchCDictTables, value);
-        CCtxParams->prefetchCDictTables = (ZSTD_paramSwitch_e)value;
-        return CCtxParams->prefetchCDictTables;
-
-    case ZSTD_c_enableSeqProducerFallback:
-        BOUNDCHECK(ZSTD_c_enableSeqProducerFallback, value);
-        CCtxParams->enableMatchFinderFallback = value;
-        return (size_t)CCtxParams->enableMatchFinderFallback;
-
-    case ZSTD_c_maxBlockSize:
-        if (value!=0)    /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_maxBlockSize, value);
-        CCtxParams->maxBlockSize = value;
-        return CCtxParams->maxBlockSize;
-
-    case ZSTD_c_searchForExternalRepcodes:
-        BOUNDCHECK(ZSTD_c_searchForExternalRepcodes, value);
-        CCtxParams->searchForExternalRepcodes = (ZSTD_paramSwitch_e)value;
-        return CCtxParams->searchForExternalRepcodes;
-
-    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
-    }
-}
-
-size_t ZSTD_CCtx_getParameter(ZSTD_CCtx const* cctx, ZSTD_cParameter param, int* value)
-{
-    return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value);
-}
-
-size_t ZSTD_CCtxParams_getParameter(
-        ZSTD_CCtx_params const* CCtxParams, ZSTD_cParameter param, int* value)
-{
-    switch(param)
-    {
-    case ZSTD_c_format :
-        *value = CCtxParams->format;
-        break;
-    case ZSTD_c_compressionLevel :
-        *value = CCtxParams->compressionLevel;
-        break;
-    case ZSTD_c_windowLog :
-        *value = (int)CCtxParams->cParams.windowLog;
-        break;
-    case ZSTD_c_hashLog :
-        *value = (int)CCtxParams->cParams.hashLog;
-        break;
-    case ZSTD_c_chainLog :
-        *value = (int)CCtxParams->cParams.chainLog;
-        break;
-    case ZSTD_c_searchLog :
-        *value = CCtxParams->cParams.searchLog;
-        break;
-    case ZSTD_c_minMatch :
-        *value = CCtxParams->cParams.minMatch;
-        break;
-    case ZSTD_c_targetLength :
-        *value = CCtxParams->cParams.targetLength;
-        break;
-    case ZSTD_c_strategy :
-        *value = (unsigned)CCtxParams->cParams.strategy;
-        break;
-    case ZSTD_c_contentSizeFlag :
-        *value = CCtxParams->fParams.contentSizeFlag;
-        break;
-    case ZSTD_c_checksumFlag :
-        *value = CCtxParams->fParams.checksumFlag;
-        break;
-    case ZSTD_c_dictIDFlag :
-        *value = !CCtxParams->fParams.noDictIDFlag;
-        break;
-    case ZSTD_c_forceMaxWindow :
-        *value = CCtxParams->forceWindow;
-        break;
-    case ZSTD_c_forceAttachDict :
-        *value = CCtxParams->attachDictPref;
-        break;
-    case ZSTD_c_literalCompressionMode :
-        *value = CCtxParams->literalCompressionMode;
-        break;
-    case ZSTD_c_nbWorkers :
-#ifndef ZSTD_MULTITHREAD
-        assert(CCtxParams->nbWorkers == 0);
-#endif
-        *value = CCtxParams->nbWorkers;
-        break;
-    case ZSTD_c_jobSize :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
-#else
-        assert(CCtxParams->jobSize <= INT_MAX);
-        *value = (int)CCtxParams->jobSize;
-        break;
-#endif
-    case ZSTD_c_overlapLog :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
-#else
-        *value = CCtxParams->overlapLog;
-        break;
-#endif
-    case ZSTD_c_rsyncable :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
-#else
-        *value = CCtxParams->rsyncable;
-        break;
-#endif
-    case ZSTD_c_enableDedicatedDictSearch :
-        *value = CCtxParams->enableDedicatedDictSearch;
-        break;
-    case ZSTD_c_enableLongDistanceMatching :
-        *value = CCtxParams->ldmParams.enableLdm;
-        break;
-    case ZSTD_c_ldmHashLog :
-        *value = CCtxParams->ldmParams.hashLog;
-        break;
-    case ZSTD_c_ldmMinMatch :
-        *value = CCtxParams->ldmParams.minMatchLength;
-        break;
-    case ZSTD_c_ldmBucketSizeLog :
-        *value = CCtxParams->ldmParams.bucketSizeLog;
-        break;
-    case ZSTD_c_ldmHashRateLog :
-        *value = CCtxParams->ldmParams.hashRateLog;
-        break;
-    case ZSTD_c_targetCBlockSize :
-        *value = (int)CCtxParams->targetCBlockSize;
-        break;
-    case ZSTD_c_srcSizeHint :
-        *value = (int)CCtxParams->srcSizeHint;
-        break;
-    case ZSTD_c_stableInBuffer :
-        *value = (int)CCtxParams->inBufferMode;
-        break;
-    case ZSTD_c_stableOutBuffer :
-        *value = (int)CCtxParams->outBufferMode;
-        break;
-    case ZSTD_c_blockDelimiters :
-        *value = (int)CCtxParams->blockDelimiters;
-        break;
-    case ZSTD_c_validateSequences :
-        *value = (int)CCtxParams->validateSequences;
-        break;
-    case ZSTD_c_useBlockSplitter :
-        *value = (int)CCtxParams->useBlockSplitter;
-        break;
-    case ZSTD_c_useRowMatchFinder :
-        *value = (int)CCtxParams->useRowMatchFinder;
-        break;
-    case ZSTD_c_deterministicRefPrefix:
-        *value = (int)CCtxParams->deterministicRefPrefix;
-        break;
-    case ZSTD_c_prefetchCDictTables:
-        *value = (int)CCtxParams->prefetchCDictTables;
-        break;
-    case ZSTD_c_enableSeqProducerFallback:
-        *value = CCtxParams->enableMatchFinderFallback;
-        break;
-    case ZSTD_c_maxBlockSize:
-        *value = (int)CCtxParams->maxBlockSize;
-        break;
-    case ZSTD_c_searchForExternalRepcodes:
-        *value = (int)CCtxParams->searchForExternalRepcodes;
-        break;
-    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
-    }
-    return 0;
-}
-
-/** ZSTD_CCtx_setParametersUsingCCtxParams() :
- *  just applies `params` into `cctx`
- *  no action is performed, parameters are merely stored.
- *  If ZSTDMT is enabled, parameters are pushed to cctx->mtctx.
- *    This is possible even if a compression is ongoing.
- *    In which case, new parameters will be applied on the fly, starting with next compression job.
- */
-size_t ZSTD_CCtx_setParametersUsingCCtxParams(
-        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
-{
-    DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams");
-    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                    "The context is in the wrong stage!");
-    RETURN_ERROR_IF(cctx->cdict, stage_wrong,
-                    "Can't override parameters with cdict attached (some must "
-                    "be inherited from the cdict).");
-
-    cctx->requestedParams = *params;
-    return 0;
-}
-
-size_t ZSTD_CCtx_setCParams(ZSTD_CCtx* cctx, ZSTD_compressionParameters cparams)
-{
-    ZSTD_STATIC_ASSERT(sizeof(cparams) == 7 * 4 /* all params are listed below */);
-    DEBUGLOG(4, "ZSTD_CCtx_setCParams");
-    /* only update if all parameters are valid */
-    FORWARD_IF_ERROR(ZSTD_checkCParams(cparams), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_windowLog, cparams.windowLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_chainLog, cparams.chainLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_hashLog, cparams.hashLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_searchLog, cparams.searchLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_minMatch, cparams.minMatch), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_targetLength, cparams.targetLength), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_strategy, cparams.strategy), "");
-    return 0;
-}
-
-size_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams)
-{
-    ZSTD_STATIC_ASSERT(sizeof(fparams) == 3 * 4 /* all params are listed below */);
-    DEBUGLOG(4, "ZSTD_CCtx_setFParams");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, fparams.contentSizeFlag != 0), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, fparams.checksumFlag != 0), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, fparams.noDictIDFlag == 0), "");
-    return 0;
-}
-
-size_t ZSTD_CCtx_setParams(ZSTD_CCtx* cctx, ZSTD_parameters params)
-{
-    DEBUGLOG(4, "ZSTD_CCtx_setParams");
-    /* First check cParams, because we want to update all or none. */
-    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
-    /* Next set fParams, because this could fail if the cctx isn't in init stage. */
-    FORWARD_IF_ERROR(ZSTD_CCtx_setFParams(cctx, params.fParams), "");
-    /* Finally set cParams, which should succeed. */
-    FORWARD_IF_ERROR(ZSTD_CCtx_setCParams(cctx, params.cParams), "");
-    return 0;
-}
-
-size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
-{
-    DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %llu bytes", pledgedSrcSize);
-    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                    "Can't set pledgedSrcSize when not in init stage.");
-    cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
-    return 0;
-}
-
-static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(
-        int const compressionLevel,
-        size_t const dictSize);
-static int ZSTD_dedicatedDictSearch_isSupported(
-        const ZSTD_compressionParameters* cParams);
-static void ZSTD_dedicatedDictSearch_revertCParams(
-        ZSTD_compressionParameters* cParams);
-
-/**
- * Initializes the local dictionary using requested parameters.
- * NOTE: Initialization does not employ the pledged src size,
- * because the dictionary may be used for multiple compressions.
- */
-static size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx)
-{
-    ZSTD_localDict* const dl = &cctx->localDict;
-    if (dl->dict == NULL) {
-        /* No local dictionary. */
-        assert(dl->dictBuffer == NULL);
-        assert(dl->cdict == NULL);
-        assert(dl->dictSize == 0);
-        return 0;
-    }
-    if (dl->cdict != NULL) {
-        /* Local dictionary already initialized. */
-        assert(cctx->cdict == dl->cdict);
-        return 0;
-    }
-    assert(dl->dictSize > 0);
-    assert(cctx->cdict == NULL);
-    assert(cctx->prefixDict.dict == NULL);
-
-    dl->cdict = ZSTD_createCDict_advanced2(
-            dl->dict,
-            dl->dictSize,
-            ZSTD_dlm_byRef,
-            dl->dictContentType,
-            &cctx->requestedParams,
-            cctx->customMem);
-    RETURN_ERROR_IF(!dl->cdict, memory_allocation, "ZSTD_createCDict_advanced failed");
-    cctx->cdict = dl->cdict;
-    return 0;
-}
-
-size_t ZSTD_CCtx_loadDictionary_advanced(
-        ZSTD_CCtx* cctx,
-        const void* dict, size_t dictSize,
-        ZSTD_dictLoadMethod_e dictLoadMethod,
-        ZSTD_dictContentType_e dictContentType)
-{
-    DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
-    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                    "Can't load a dictionary when cctx is not in init stage.");
-    ZSTD_clearAllDicts(cctx);  /* erase any previously set dictionary */
-    if (dict == NULL || dictSize == 0)  /* no dictionary */
-        return 0;
-    if (dictLoadMethod == ZSTD_dlm_byRef) {
-        cctx->localDict.dict = dict;
-    } else {
-        /* copy dictionary content inside CCtx to own its lifetime */
-        void* dictBuffer;
-        RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
-                        "static CCtx can't allocate for an internal copy of dictionary");
-        dictBuffer = ZSTD_customMalloc(dictSize, cctx->customMem);
-        RETURN_ERROR_IF(dictBuffer==NULL, memory_allocation,
-                        "allocation failed for dictionary content");
-        ZSTD_memcpy(dictBuffer, dict, dictSize);
-        cctx->localDict.dictBuffer = dictBuffer;  /* owned ptr to free */
-        cctx->localDict.dict = dictBuffer;        /* read-only reference */
-    }
-    cctx->localDict.dictSize = dictSize;
-    cctx->localDict.dictContentType = dictContentType;
-    return 0;
-}
-
-size_t ZSTD_CCtx_loadDictionary_byReference(
-      ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
-{
-    return ZSTD_CCtx_loadDictionary_advanced(
-            cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
-}
-
-size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
-{
-    return ZSTD_CCtx_loadDictionary_advanced(
-            cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
-}
-
-
-size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
-{
-    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                    "Can't ref a dict when ctx not in init stage.");
-    /* Free the existing local cdict (if any) to save memory. */
-    ZSTD_clearAllDicts(cctx);
-    cctx->cdict = cdict;
-    return 0;
-}
-
-size_t ZSTD_CCtx_refThreadPool(ZSTD_CCtx* cctx, ZSTD_threadPool* pool)
-{
-    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                    "Can't ref a pool when ctx not in init stage.");
-    cctx->pool = pool;
-    return 0;
-}
-
-size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize)
-{
-    return ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent);
-}
-
-size_t ZSTD_CCtx_refPrefix_advanced(
-        ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
-{
-    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                    "Can't ref a prefix when ctx not in init stage.");
-    ZSTD_clearAllDicts(cctx);
-    if (prefix != NULL && prefixSize > 0) {
-        cctx->prefixDict.dict = prefix;
-        cctx->prefixDict.dictSize = prefixSize;
-        cctx->prefixDict.dictContentType = dictContentType;
-    }
-    return 0;
-}
-
-/*! ZSTD_CCtx_reset() :
- *  Also dumps dictionary */
-size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
-{
-    if ( (reset == ZSTD_reset_session_only)
-      || (reset == ZSTD_reset_session_and_parameters) ) {
-        cctx->streamStage = zcss_init;
-        cctx->pledgedSrcSizePlusOne = 0;
-    }
-    if ( (reset == ZSTD_reset_parameters)
-      || (reset == ZSTD_reset_session_and_parameters) ) {
-        RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
-                        "Reset parameters is only possible during init stage.");
-        ZSTD_clearAllDicts(cctx);
-        return ZSTD_CCtxParams_reset(&cctx->requestedParams);
-    }
-    return 0;
-}
-
-
-/** ZSTD_checkCParams() :
-    control CParam values remain within authorized range.
-    @return : 0, or an error code if one value is beyond authorized range */
-size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
-{
-    BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
-    BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
-    BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
-    BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
-    BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
-    BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
-    BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy);
-    return 0;
-}
-
-/** ZSTD_clampCParams() :
- *  make CParam values within valid range.
- *  @return : valid CParams */
-static ZSTD_compressionParameters
-ZSTD_clampCParams(ZSTD_compressionParameters cParams)
-{
-#   define CLAMP_TYPE(cParam, val, type)                                      \
-        do {                                                                  \
-            ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \
-            if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \
-            else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
-        } while (0)
-#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
-    CLAMP(ZSTD_c_windowLog, cParams.windowLog);
-    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
-    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
-    CLAMP(ZSTD_c_searchLog, cParams.searchLog);
-    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
-    CLAMP(ZSTD_c_targetLength,cParams.targetLength);
-    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
-    return cParams;
-}
-
-/** ZSTD_cycleLog() :
- *  condition for correct operation : hashLog > 1 */
-U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
-{
-    U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
-    return hashLog - btScale;
-}
-
-/** ZSTD_dictAndWindowLog() :
- * Returns an adjusted window log that is large enough to fit the source and the dictionary.
- * The zstd format says that the entire dictionary is valid if one byte of the dictionary
- * is within the window. So the hashLog and chainLog should be large enough to reference both
- * the dictionary and the window. So we must use this adjusted dictAndWindowLog when downsizing
- * the hashLog and windowLog.
- * NOTE: srcSize must not be ZSTD_CONTENTSIZE_UNKNOWN.
- */
-static U32 ZSTD_dictAndWindowLog(U32 windowLog, U64 srcSize, U64 dictSize)
-{
-    const U64 maxWindowSize = 1ULL << ZSTD_WINDOWLOG_MAX;
-    /* No dictionary ==> No change */
-    if (dictSize == 0) {
-        return windowLog;
-    }
-    assert(windowLog <= ZSTD_WINDOWLOG_MAX);
-    assert(srcSize != ZSTD_CONTENTSIZE_UNKNOWN); /* Handled in ZSTD_adjustCParams_internal() */
-    {
-        U64 const windowSize = 1ULL << windowLog;
-        U64 const dictAndWindowSize = dictSize + windowSize;
-        /* If the window size is already large enough to fit both the source and the dictionary
-         * then just use the window size. Otherwise adjust so that it fits the dictionary and
-         * the window.
-         */
-        if (windowSize >= dictSize + srcSize) {
-            return windowLog; /* Window size large enough already */
-        } else if (dictAndWindowSize >= maxWindowSize) {
-            return ZSTD_WINDOWLOG_MAX; /* Larger than max window log */
-        } else  {
-            return ZSTD_highbit32((U32)dictAndWindowSize - 1) + 1;
-        }
-    }
-}
-
-/** ZSTD_adjustCParams_internal() :
- *  optimize `cPar` for a specified input (`srcSize` and `dictSize`).
- *  mostly downsize to reduce memory consumption and initialization latency.
- * `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known.
- * `mode` is the mode for parameter adjustment. See docs for `ZSTD_cParamMode_e`.
- *  note : `srcSize==0` means 0!
- *  condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */
-static ZSTD_compressionParameters
-ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
-                            unsigned long long srcSize,
-                            size_t dictSize,
-                            ZSTD_cParamMode_e mode,
-                            ZSTD_paramSwitch_e useRowMatchFinder)
-{
-    const U64 minSrcSize = 513; /* (1<<9) + 1 */
-    const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
-    assert(ZSTD_checkCParams(cPar)==0);
-
-    /* Cascade the selected strategy down to the next-highest one built into
-     * this binary. */
-#ifdef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_btultra2) {
-        cPar.strategy = ZSTD_btultra;
-    }
-    if (cPar.strategy == ZSTD_btultra) {
-        cPar.strategy = ZSTD_btopt;
-    }
-#endif
-#ifdef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_btopt) {
-        cPar.strategy = ZSTD_btlazy2;
-    }
-#endif
-#ifdef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_btlazy2) {
-        cPar.strategy = ZSTD_lazy2;
-    }
-#endif
-#ifdef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_lazy2) {
-        cPar.strategy = ZSTD_lazy;
-    }
-#endif
-#ifdef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_lazy) {
-        cPar.strategy = ZSTD_greedy;
-    }
-#endif
-#ifdef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_greedy) {
-        cPar.strategy = ZSTD_dfast;
-    }
-#endif
-#ifdef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR
-    if (cPar.strategy == ZSTD_dfast) {
-        cPar.strategy = ZSTD_fast;
-        cPar.targetLength = 0;
-    }
-#endif
-
-    switch (mode) {
-    case ZSTD_cpm_unknown:
-    case ZSTD_cpm_noAttachDict:
-        /* If we don't know the source size, don't make any
-         * assumptions about it. We will already have selected
-         * smaller parameters if a dictionary is in use.
-         */
-        break;
-    case ZSTD_cpm_createCDict:
-        /* Assume a small source size when creating a dictionary
-         * with an unknown source size.
-         */
-        if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)
-            srcSize = minSrcSize;
-        break;
-    case ZSTD_cpm_attachDict:
-        /* Dictionary has its own dedicated parameters which have
-         * already been selected. We are selecting parameters
-         * for only the source.
-         */
-        dictSize = 0;
-        break;
-    default:
-        assert(0);
-        break;
-    }
-
-    /* resize windowLog if input is small enough, to use less memory */
-    if ( (srcSize <= maxWindowResize)
-      && (dictSize <= maxWindowResize) )  {
-        U32 const tSize = (U32)(srcSize + dictSize);
-        static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
-        U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
-                            ZSTD_highbit32(tSize-1) + 1;
-        if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
-    }
-    if (srcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-        U32 const dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, (U64)srcSize, (U64)dictSize);
-        U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
-        if (cPar.hashLog > dictAndWindowLog+1) cPar.hashLog = dictAndWindowLog+1;
-        if (cycleLog > dictAndWindowLog)
-            cPar.chainLog -= (cycleLog - dictAndWindowLog);
-    }
-
-    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
-        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
-
-    /* We can't use more than 32 bits of hash in total, so that means that we require:
-     * (hashLog + 8) <= 32 && (chainLog + 8) <= 32
-     */
-    if (mode == ZSTD_cpm_createCDict && ZSTD_CDictIndicesAreTagged(&cPar)) {
-        U32 const maxShortCacheHashLog = 32 - ZSTD_SHORT_CACHE_TAG_BITS;
-        if (cPar.hashLog > maxShortCacheHashLog) {
-            cPar.hashLog = maxShortCacheHashLog;
-        }
-        if (cPar.chainLog > maxShortCacheHashLog) {
-            cPar.chainLog = maxShortCacheHashLog;
-        }
-    }
-
-
-    /* At this point, we aren't 100% sure if we are using the row match finder.
-     * Unless it is explicitly disabled, conservatively assume that it is enabled.
-     * In this case it will only be disabled for small sources, so shrinking the
-     * hash log a little bit shouldn't result in any ratio loss.
-     */
-    if (useRowMatchFinder == ZSTD_ps_auto)
-        useRowMatchFinder = ZSTD_ps_enable;
-
-    /* We can't hash more than 32-bits in total. So that means that we require:
-     * (hashLog - rowLog + 8) <= 32
-     */
-    if (ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder)) {
-        /* Switch to 32-entry rows if searchLog is 5 (or more) */
-        U32 const rowLog = BOUNDED(4, cPar.searchLog, 6);
-        U32 const maxRowHashLog = 32 - ZSTD_ROW_HASH_TAG_BITS;
-        U32 const maxHashLog = maxRowHashLog + rowLog;
-        assert(cPar.hashLog >= rowLog);
-        if (cPar.hashLog > maxHashLog) {
-            cPar.hashLog = maxHashLog;
-        }
-    }
-
-    return cPar;
-}
-
-ZSTD_compressionParameters
-ZSTD_adjustCParams(ZSTD_compressionParameters cPar,
-                   unsigned long long srcSize,
-                   size_t dictSize)
-{
-    cPar = ZSTD_clampCParams(cPar);   /* resulting cPar is necessarily valid (all parameters within range) */
-    if (srcSize == 0) srcSize = ZSTD_CONTENTSIZE_UNKNOWN;
-    return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize, ZSTD_cpm_unknown, ZSTD_ps_auto);
-}
-
-static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode);
-static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode);
-
-static void ZSTD_overrideCParams(
-              ZSTD_compressionParameters* cParams,
-        const ZSTD_compressionParameters* overrides)
-{
-    if (overrides->windowLog)    cParams->windowLog    = overrides->windowLog;
-    if (overrides->hashLog)      cParams->hashLog      = overrides->hashLog;
-    if (overrides->chainLog)     cParams->chainLog     = overrides->chainLog;
-    if (overrides->searchLog)    cParams->searchLog    = overrides->searchLog;
-    if (overrides->minMatch)     cParams->minMatch     = overrides->minMatch;
-    if (overrides->targetLength) cParams->targetLength = overrides->targetLength;
-    if (overrides->strategy)     cParams->strategy     = overrides->strategy;
-}
-
-ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
-        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
-{
-    ZSTD_compressionParameters cParams;
-    if (srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN && CCtxParams->srcSizeHint > 0) {
-      srcSizeHint = CCtxParams->srcSizeHint;
-    }
-    cParams = ZSTD_getCParams_internal(CCtxParams->compressionLevel, srcSizeHint, dictSize, mode);
-    if (CCtxParams->ldmParams.enableLdm == ZSTD_ps_enable) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
-    ZSTD_overrideCParams(&cParams, &CCtxParams->cParams);
-    assert(!ZSTD_checkCParams(cParams));
-    /* srcSizeHint == 0 means 0 */
-    return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize, mode, CCtxParams->useRowMatchFinder);
-}
-
-static size_t
-ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
-                       const ZSTD_paramSwitch_e useRowMatchFinder,
-                       const U32 enableDedicatedDictSearch,
-                       const U32 forCCtx)
-{
-    /* chain table size should be 0 for fast or row-hash strategies */
-    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)
-                                ? ((size_t)1 << cParams->chainLog)
-                                : 0;
-    size_t const hSize = ((size_t)1) << cParams->hashLog;
-    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
-    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
-    /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't
-     * surrounded by redzones in ASAN. */
-    size_t const tableSpace = chainSize * sizeof(U32)
-                            + hSize * sizeof(U32)
-                            + h3Size * sizeof(U32);
-    size_t const optPotentialSpace =
-        ZSTD_cwksp_aligned_alloc_size((MaxML+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned_alloc_size((MaxLL+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned_alloc_size((MaxOff+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned_alloc_size((1<<Litbits) * sizeof(U32))
-      + ZSTD_cwksp_aligned_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_match_t))
-      + ZSTD_cwksp_aligned_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_optimal_t));
-    size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
-                                            ? ZSTD_cwksp_aligned_alloc_size(hSize)
-                                            : 0;
-    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
-                                ? optPotentialSpace
-                                : 0;
-    size_t const slackSpace = ZSTD_cwksp_slack_space_required();
-
-    /* tables are guaranteed to be sized in multiples of 64 bytes (or 16 uint32_t) */
-    ZSTD_STATIC_ASSERT(ZSTD_HASHLOG_MIN >= 4 && ZSTD_WINDOWLOG_MIN >= 4 && ZSTD_CHAINLOG_MIN >= 4);
-    assert(useRowMatchFinder != ZSTD_ps_auto);
-
-    DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
-                (U32)chainSize, (U32)hSize, (U32)h3Size);
-    return tableSpace + optSpace + slackSpace + lazyAdditionalSpace;
-}
-
-/* Helper function for calculating memory requirements.
- * Gives a tighter bound than ZSTD_sequenceBound() by taking minMatch into account. */
-static size_t ZSTD_maxNbSeq(size_t blockSize, unsigned minMatch, int useSequenceProducer) {
-    U32 const divider = (minMatch==3 || useSequenceProducer) ? 3 : 4;
-    return blockSize / divider;
-}
-
-static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
-        const ZSTD_compressionParameters* cParams,
-        const ldmParams_t* ldmParams,
-        const int isStatic,
-        const ZSTD_paramSwitch_e useRowMatchFinder,
-        const size_t buffInSize,
-        const size_t buffOutSize,
-        const U64 pledgedSrcSize,
-        int useSequenceProducer,
-        size_t maxBlockSize)
-{
-    size_t const windowSize = (size_t) BOUNDED(1ULL, 1ULL << cParams->windowLog, pledgedSrcSize);
-    size_t const blockSize = MIN(ZSTD_resolveMaxBlockSize(maxBlockSize), windowSize);
-    size_t const maxNbSeq = ZSTD_maxNbSeq(blockSize, cParams->minMatch, useSequenceProducer);
-    size_t const tokenSpace = ZSTD_cwksp_alloc_size(WILDCOPY_OVERLENGTH + blockSize)
-                            + ZSTD_cwksp_aligned_alloc_size(maxNbSeq * sizeof(seqDef))
-                            + 3 * ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(BYTE));
-    size_t const entropySpace = ZSTD_cwksp_alloc_size(ENTROPY_WORKSPACE_SIZE);
-    size_t const blockStateSpace = 2 * ZSTD_cwksp_alloc_size(sizeof(ZSTD_compressedBlockState_t));
-    size_t const matchStateSize = ZSTD_sizeof_matchState(cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 0, /* forCCtx */ 1);
-
-    size_t const ldmSpace = ZSTD_ldm_getTableSize(*ldmParams);
-    size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(*ldmParams, blockSize);
-    size_t const ldmSeqSpace = ldmParams->enableLdm == ZSTD_ps_enable ?
-        ZSTD_cwksp_aligned_alloc_size(maxNbLdmSeq * sizeof(rawSeq)) : 0;
-
-
-    size_t const bufferSpace = ZSTD_cwksp_alloc_size(buffInSize)
-                             + ZSTD_cwksp_alloc_size(buffOutSize);
-
-    size_t const cctxSpace = isStatic ? ZSTD_cwksp_alloc_size(sizeof(ZSTD_CCtx)) : 0;
-
-    size_t const maxNbExternalSeq = ZSTD_sequenceBound(blockSize);
-    size_t const externalSeqSpace = useSequenceProducer
-        ? ZSTD_cwksp_aligned_alloc_size(maxNbExternalSeq * sizeof(ZSTD_Sequence))
-        : 0;
-
-    size_t const neededSpace =
-        cctxSpace +
-        entropySpace +
-        blockStateSpace +
-        ldmSpace +
-        ldmSeqSpace +
-        matchStateSize +
-        tokenSpace +
-        bufferSpace +
-        externalSeqSpace;
-
-    DEBUGLOG(5, "estimate workspace : %u", (U32)neededSpace);
-    return neededSpace;
-}
-
-size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
-{
-    ZSTD_compressionParameters const cParams =
-                ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
-    ZSTD_paramSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params->useRowMatchFinder,
-                                                                               &cParams);
-
-    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
-    /* estimateCCtxSize is for one-shot compression. So no buffers should
-     * be needed. However, we still allocate two 0-sized buffers, which can
-     * take space under ASAN. */
-    return ZSTD_estimateCCtxSize_usingCCtxParams_internal(
-        &cParams, &params->ldmParams, 1, useRowMatchFinder, 0, 0, ZSTD_CONTENTSIZE_UNKNOWN, ZSTD_hasExtSeqProd(params), params->maxBlockSize);
-}
-
-size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams)
-{
-    ZSTD_CCtx_params initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);
-    if (ZSTD_rowMatchFinderSupported(cParams.strategy)) {
-        /* Pick bigger of not using and using row-based matchfinder for greedy and lazy strategies */
-        size_t noRowCCtxSize;
-        size_t rowCCtxSize;
-        initialParams.useRowMatchFinder = ZSTD_ps_disable;
-        noRowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);
-        initialParams.useRowMatchFinder = ZSTD_ps_enable;
-        rowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);
-        return MAX(noRowCCtxSize, rowCCtxSize);
-    } else {
-        return ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);
-    }
-}
-
-static size_t ZSTD_estimateCCtxSize_internal(int compressionLevel)
-{
-    int tier = 0;
-    size_t largestSize = 0;
-    static const unsigned long long srcSizeTiers[4] = {16 KB, 128 KB, 256 KB, ZSTD_CONTENTSIZE_UNKNOWN};
-    for (; tier < 4; ++tier) {
-        /* Choose the set of cParams for a given level across all srcSizes that give the largest cctxSize */
-        ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeTiers[tier], 0, ZSTD_cpm_noAttachDict);
-        largestSize = MAX(ZSTD_estimateCCtxSize_usingCParams(cParams), largestSize);
-    }
-    return largestSize;
-}
-
-size_t ZSTD_estimateCCtxSize(int compressionLevel)
-{
-    int level;
-    size_t memBudget = 0;
-    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
-        /* Ensure monotonically increasing memory usage as compression level increases */
-        size_t const newMB = ZSTD_estimateCCtxSize_internal(level);
-        if (newMB > memBudget) memBudget = newMB;
-    }
-    return memBudget;
-}
-
-size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
-{
-    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
-    {   ZSTD_compressionParameters const cParams =
-                ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
-        size_t const blockSize = MIN(ZSTD_resolveMaxBlockSize(params->maxBlockSize), (size_t)1 << cParams.windowLog);
-        size_t const inBuffSize = (params->inBufferMode == ZSTD_bm_buffered)
-                ? ((size_t)1 << cParams.windowLog) + blockSize
-                : 0;
-        size_t const outBuffSize = (params->outBufferMode == ZSTD_bm_buffered)
-                ? ZSTD_compressBound(blockSize) + 1
-                : 0;
-        ZSTD_paramSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params->useRowMatchFinder, &params->cParams);
-
-        return ZSTD_estimateCCtxSize_usingCCtxParams_internal(
-            &cParams, &params->ldmParams, 1, useRowMatchFinder, inBuffSize, outBuffSize,
-            ZSTD_CONTENTSIZE_UNKNOWN, ZSTD_hasExtSeqProd(params), params->maxBlockSize);
-    }
-}
-
-size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
-{
-    ZSTD_CCtx_params initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);
-    if (ZSTD_rowMatchFinderSupported(cParams.strategy)) {
-        /* Pick bigger of not using and using row-based matchfinder for greedy and lazy strategies */
-        size_t noRowCCtxSize;
-        size_t rowCCtxSize;
-        initialParams.useRowMatchFinder = ZSTD_ps_disable;
-        noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
-        initialParams.useRowMatchFinder = ZSTD_ps_enable;
-        rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
-        return MAX(noRowCCtxSize, rowCCtxSize);
-    } else {
-        return ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
-    }
-}
-
-static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
-{
-    ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
-    return ZSTD_estimateCStreamSize_usingCParams(cParams);
-}
-
-size_t ZSTD_estimateCStreamSize(int compressionLevel)
-{
-    int level;
-    size_t memBudget = 0;
-    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
-        size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
-        if (newMB > memBudget) memBudget = newMB;
-    }
-    return memBudget;
-}
-
-/* ZSTD_getFrameProgression():
- * tells how much data has been consumed (input) and produced (output) for current frame.
- * able to count progression inside worker threads (non-blocking mode).
- */
-ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx)
-{
-#ifdef ZSTD_MULTITHREAD
-    if (cctx->appliedParams.nbWorkers > 0) {
-        return ZSTDMT_getFrameProgression(cctx->mtctx);
-    }
-#endif
-    {   ZSTD_frameProgression fp;
-        size_t const buffered = (cctx->inBuff == NULL) ? 0 :
-                                cctx->inBuffPos - cctx->inToCompress;
-        if (buffered) assert(cctx->inBuffPos >= cctx->inToCompress);
-        assert(buffered <= ZSTD_BLOCKSIZE_MAX);
-        fp.ingested = cctx->consumedSrcSize + buffered;
-        fp.consumed = cctx->consumedSrcSize;
-        fp.produced = cctx->producedCSize;
-        fp.flushed  = cctx->producedCSize;   /* simplified; some data might still be left within streaming output buffer */
-        fp.currentJobID = 0;
-        fp.nbActiveWorkers = 0;
-        return fp;
-}   }
-
-/*! ZSTD_toFlushNow()
- *  Only useful for multithreading scenarios currently (nbWorkers >= 1).
- */
-size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx)
-{
-#ifdef ZSTD_MULTITHREAD
-    if (cctx->appliedParams.nbWorkers > 0) {
-        return ZSTDMT_toFlushNow(cctx->mtctx);
-    }
-#endif
-    (void)cctx;
-    return 0;   /* over-simplification; could also check if context is currently running in streaming mode, and in which case, report how many bytes are left to be flushed within output buffer */
-}
-
-static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,
-                                    ZSTD_compressionParameters cParams2)
-{
-    (void)cParams1;
-    (void)cParams2;
-    assert(cParams1.windowLog    == cParams2.windowLog);
-    assert(cParams1.chainLog     == cParams2.chainLog);
-    assert(cParams1.hashLog      == cParams2.hashLog);
-    assert(cParams1.searchLog    == cParams2.searchLog);
-    assert(cParams1.minMatch     == cParams2.minMatch);
-    assert(cParams1.targetLength == cParams2.targetLength);
-    assert(cParams1.strategy     == cParams2.strategy);
-}
-
-void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs)
-{
-    int i;
-    for (i = 0; i < ZSTD_REP_NUM; ++i)
-        bs->rep[i] = repStartValue[i];
-    bs->entropy.huf.repeatMode = HUF_repeat_none;
-    bs->entropy.fse.offcode_repeatMode = FSE_repeat_none;
-    bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none;
-    bs->entropy.fse.litlength_repeatMode = FSE_repeat_none;
-}
-
-/*! ZSTD_invalidateMatchState()
- *  Invalidate all the matches in the match finder tables.
- *  Requires nextSrc and base to be set (can be NULL).
- */
-static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms)
-{
-    ZSTD_window_clear(&ms->window);
-
-    ms->nextToUpdate = ms->window.dictLimit;
-    ms->loadedDictEnd = 0;
-    ms->opt.litLengthSum = 0;  /* force reset of btopt stats */
-    ms->dictMatchState = NULL;
-}
-
-/**
- * Controls, for this matchState reset, whether the tables need to be cleared /
- * prepared for the coming compression (ZSTDcrp_makeClean), or whether the
- * tables can be left unclean (ZSTDcrp_leaveDirty), because we know that a
- * subsequent operation will overwrite the table space anyways (e.g., copying
- * the matchState contents in from a CDict).
- */
-typedef enum {
-    ZSTDcrp_makeClean,
-    ZSTDcrp_leaveDirty
-} ZSTD_compResetPolicy_e;
-
-/**
- * Controls, for this matchState reset, whether indexing can continue where it
- * left off (ZSTDirp_continue), or whether it needs to be restarted from zero
- * (ZSTDirp_reset).
- */
-typedef enum {
-    ZSTDirp_continue,
-    ZSTDirp_reset
-} ZSTD_indexResetPolicy_e;
-
-typedef enum {
-    ZSTD_resetTarget_CDict,
-    ZSTD_resetTarget_CCtx
-} ZSTD_resetTarget_e;
-
-/* Mixes bits in a 64 bits in a value, based on XXH3_rrmxmx */
-static U64 ZSTD_bitmix(U64 val, U64 len) {
-    val ^= ZSTD_rotateRight_U64(val, 49) ^ ZSTD_rotateRight_U64(val, 24);
-    val *= 0x9FB21C651E98DF25ULL;
-    val ^= (val >> 35) + len ;
-    val *= 0x9FB21C651E98DF25ULL;
-    return val ^ (val >> 28);
-}
-
-/* Mixes in the hashSalt and hashSaltEntropy to create a new hashSalt */
-static void ZSTD_advanceHashSalt(ZSTD_matchState_t* ms) {
-    ms->hashSalt = ZSTD_bitmix(ms->hashSalt, 8) ^ ZSTD_bitmix((U64) ms->hashSaltEntropy, 4);
-}
-
-static size_t
-ZSTD_reset_matchState(ZSTD_matchState_t* ms,
-                      ZSTD_cwksp* ws,
-                const ZSTD_compressionParameters* cParams,
-                const ZSTD_paramSwitch_e useRowMatchFinder,
-                const ZSTD_compResetPolicy_e crp,
-                const ZSTD_indexResetPolicy_e forceResetIndex,
-                const ZSTD_resetTarget_e forWho)
-{
-    /* disable chain table allocation for fast or row-based strategies */
-    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder,
-                                                     ms->dedicatedDictSearch && (forWho == ZSTD_resetTarget_CDict))
-                                ? ((size_t)1 << cParams->chainLog)
-                                : 0;
-    size_t const hSize = ((size_t)1) << cParams->hashLog;
-    U32    const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
-    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
-
-    DEBUGLOG(4, "reset indices : %u", forceResetIndex == ZSTDirp_reset);
-    assert(useRowMatchFinder != ZSTD_ps_auto);
-    if (forceResetIndex == ZSTDirp_reset) {
-        ZSTD_window_init(&ms->window);
-        ZSTD_cwksp_mark_tables_dirty(ws);
-    }
-
-    ms->hashLog3 = hashLog3;
-    ms->lazySkipping = 0;
-
-    ZSTD_invalidateMatchState(ms);
-
-    assert(!ZSTD_cwksp_reserve_failed(ws)); /* check that allocation hasn't already failed */
-
-    ZSTD_cwksp_clear_tables(ws);
-
-    DEBUGLOG(5, "reserving table space");
-    /* table Space */
-    ms->hashTable = (U32*)ZSTD_cwksp_reserve_table(ws, hSize * sizeof(U32));
-    ms->chainTable = (U32*)ZSTD_cwksp_reserve_table(ws, chainSize * sizeof(U32));
-    ms->hashTable3 = (U32*)ZSTD_cwksp_reserve_table(ws, h3Size * sizeof(U32));
-    RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,
-                    "failed a workspace allocation in ZSTD_reset_matchState");
-
-    DEBUGLOG(4, "reset table : %u", crp!=ZSTDcrp_leaveDirty);
-    if (crp!=ZSTDcrp_leaveDirty) {
-        /* reset tables only */
-        ZSTD_cwksp_clean_tables(ws);
-    }
-
-    if (ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)) {
-        /* Row match finder needs an additional table of hashes ("tags") */
-        size_t const tagTableSize = hSize;
-        /* We want to generate a new salt in case we reset a Cctx, but we always want to use
-         * 0 when we reset a Cdict */
-        if(forWho == ZSTD_resetTarget_CCtx) {
-            ms->tagTable = (BYTE*) ZSTD_cwksp_reserve_aligned_init_once(ws, tagTableSize);
-            ZSTD_advanceHashSalt(ms);
-        } else {
-            /* When we are not salting we want to always memset the memory */
-            ms->tagTable = (BYTE*) ZSTD_cwksp_reserve_aligned(ws, tagTableSize);
-            ZSTD_memset(ms->tagTable, 0, tagTableSize);
-            ms->hashSalt = 0;
-        }
-        {   /* Switch to 32-entry rows if searchLog is 5 (or more) */
-            U32 const rowLog = BOUNDED(4, cParams->searchLog, 6);
-            assert(cParams->hashLog >= rowLog);
-            ms->rowHashLog = cParams->hashLog - rowLog;
-        }
-    }
-
-    /* opt parser space */
-    if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {
-        DEBUGLOG(4, "reserving optimal parser space");
-        ms->opt.litFreq = (unsigned*)ZSTD_cwksp_reserve_aligned(ws, (1<<Litbits) * sizeof(unsigned));
-        ms->opt.litLengthFreq = (unsigned*)ZSTD_cwksp_reserve_aligned(ws, (MaxLL+1) * sizeof(unsigned));
-        ms->opt.matchLengthFreq = (unsigned*)ZSTD_cwksp_reserve_aligned(ws, (MaxML+1) * sizeof(unsigned));
-        ms->opt.offCodeFreq = (unsigned*)ZSTD_cwksp_reserve_aligned(ws, (MaxOff+1) * sizeof(unsigned));
-        ms->opt.matchTable = (ZSTD_match_t*)ZSTD_cwksp_reserve_aligned(ws, ZSTD_OPT_SIZE * sizeof(ZSTD_match_t));
-        ms->opt.priceTable = (ZSTD_optimal_t*)ZSTD_cwksp_reserve_aligned(ws, ZSTD_OPT_SIZE * sizeof(ZSTD_optimal_t));
-    }
-
-    ms->cParams = *cParams;
-
-    RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,
-                    "failed a workspace allocation in ZSTD_reset_matchState");
-    return 0;
-}
-
-/* ZSTD_indexTooCloseToMax() :
- * minor optimization : prefer memset() rather than reduceIndex()
- * which is measurably slow in some circumstances (reported for Visual Studio).
- * Works when re-using a context for a lot of smallish inputs :
- * if all inputs are smaller than ZSTD_INDEXOVERFLOW_MARGIN,
- * memset() will be triggered before reduceIndex().
- */
-#define ZSTD_INDEXOVERFLOW_MARGIN (16 MB)
-static int ZSTD_indexTooCloseToMax(ZSTD_window_t w)
-{
-    return (size_t)(w.nextSrc - w.base) > (ZSTD_CURRENT_MAX - ZSTD_INDEXOVERFLOW_MARGIN);
-}
-
-/** ZSTD_dictTooBig():
- * When dictionaries are larger than ZSTD_CHUNKSIZE_MAX they can't be loaded in
- * one go generically. So we ensure that in that case we reset the tables to zero,
- * so that we can load as much of the dictionary as possible.
- */
-static int ZSTD_dictTooBig(size_t const loadedDictSize)
-{
-    return loadedDictSize > ZSTD_CHUNKSIZE_MAX;
-}
-
-/*! ZSTD_resetCCtx_internal() :
- * @param loadedDictSize The size of the dictionary to be loaded
- * into the context, if any. If no dictionary is used, or the
- * dictionary is being attached / copied, then pass 0.
- * note : `params` are assumed fully validated at this stage.
- */
-static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
-                                      ZSTD_CCtx_params const* params,
-                                      U64 const pledgedSrcSize,
-                                      size_t const loadedDictSize,
-                                      ZSTD_compResetPolicy_e const crp,
-                                      ZSTD_buffered_policy_e const zbuff)
-{
-    ZSTD_cwksp* const ws = &zc->workspace;
-    DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u, useRowMatchFinder=%d useBlockSplitter=%d",
-                (U32)pledgedSrcSize, params->cParams.windowLog, (int)params->useRowMatchFinder, (int)params->useBlockSplitter);
-    assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
-
-    zc->isFirstBlock = 1;
-
-    /* Set applied params early so we can modify them for LDM,
-     * and point params at the applied params.
-     */
-    zc->appliedParams = *params;
-    params = &zc->appliedParams;
-
-    assert(params->useRowMatchFinder != ZSTD_ps_auto);
-    assert(params->useBlockSplitter != ZSTD_ps_auto);
-    assert(params->ldmParams.enableLdm != ZSTD_ps_auto);
-    assert(params->maxBlockSize != 0);
-    if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-        /* Adjust long distance matching parameters */
-        ZSTD_ldm_adjustParameters(&zc->appliedParams.ldmParams, &params->cParams);
-        assert(params->ldmParams.hashLog >= params->ldmParams.bucketSizeLog);
-        assert(params->ldmParams.hashRateLog < 32);
-    }
-
-    {   size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params->cParams.windowLog), pledgedSrcSize));
-        size_t const blockSize = MIN(params->maxBlockSize, windowSize);
-        size_t const maxNbSeq = ZSTD_maxNbSeq(blockSize, params->cParams.minMatch, ZSTD_hasExtSeqProd(params));
-        size_t const buffOutSize = (zbuff == ZSTDb_buffered && params->outBufferMode == ZSTD_bm_buffered)
-                ? ZSTD_compressBound(blockSize) + 1
-                : 0;
-        size_t const buffInSize = (zbuff == ZSTDb_buffered && params->inBufferMode == ZSTD_bm_buffered)
-                ? windowSize + blockSize
-                : 0;
-        size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize);
-
-        int const indexTooClose = ZSTD_indexTooCloseToMax(zc->blockState.matchState.window);
-        int const dictTooBig = ZSTD_dictTooBig(loadedDictSize);
-        ZSTD_indexResetPolicy_e needsIndexReset =
-            (indexTooClose || dictTooBig || !zc->initialized) ? ZSTDirp_reset : ZSTDirp_continue;
-
-        size_t const neededSpace =
-            ZSTD_estimateCCtxSize_usingCCtxParams_internal(
-                &params->cParams, &params->ldmParams, zc->staticSize != 0, params->useRowMatchFinder,
-                buffInSize, buffOutSize, pledgedSrcSize, ZSTD_hasExtSeqProd(params), params->maxBlockSize);
-
-        FORWARD_IF_ERROR(neededSpace, "cctx size estimate failed!");
-
-        if (!zc->staticSize) ZSTD_cwksp_bump_oversized_duration(ws, 0);
-
-        {   /* Check if workspace is large enough, alloc a new one if needed */
-            int const workspaceTooSmall = ZSTD_cwksp_sizeof(ws) < neededSpace;
-            int const workspaceWasteful = ZSTD_cwksp_check_wasteful(ws, neededSpace);
-            int resizeWorkspace = workspaceTooSmall || workspaceWasteful;
-            DEBUGLOG(4, "Need %zu B workspace", neededSpace);
-            DEBUGLOG(4, "windowSize: %zu - blockSize: %zu", windowSize, blockSize);
-
-            if (resizeWorkspace) {
-                DEBUGLOG(4, "Resize workspaceSize from %zuKB to %zuKB",
-                            ZSTD_cwksp_sizeof(ws) >> 10,
-                            neededSpace >> 10);
-
-                RETURN_ERROR_IF(zc->staticSize, memory_allocation, "static cctx : no resize");
-
-                needsIndexReset = ZSTDirp_reset;
-
-                ZSTD_cwksp_free(ws, zc->customMem);
-                FORWARD_IF_ERROR(ZSTD_cwksp_create(ws, neededSpace, zc->customMem), "");
-
-                DEBUGLOG(5, "reserving object space");
-                /* Statically sized space.
-                 * entropyWorkspace never moves,
-                 * though prev/next block swap places */
-                assert(ZSTD_cwksp_check_available(ws, 2 * sizeof(ZSTD_compressedBlockState_t)));
-                zc->blockState.prevCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));
-                RETURN_ERROR_IF(zc->blockState.prevCBlock == NULL, memory_allocation, "couldn't allocate prevCBlock");
-                zc->blockState.nextCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));
-                RETURN_ERROR_IF(zc->blockState.nextCBlock == NULL, memory_allocation, "couldn't allocate nextCBlock");
-                zc->entropyWorkspace = (U32*) ZSTD_cwksp_reserve_object(ws, ENTROPY_WORKSPACE_SIZE);
-                RETURN_ERROR_IF(zc->entropyWorkspace == NULL, memory_allocation, "couldn't allocate entropyWorkspace");
-        }   }
-
-        ZSTD_cwksp_clear(ws);
-
-        /* init params */
-        zc->blockState.matchState.cParams = params->cParams;
-        zc->blockState.matchState.prefetchCDictTables = params->prefetchCDictTables == ZSTD_ps_enable;
-        zc->pledgedSrcSizePlusOne = pledgedSrcSize+1;
-        zc->consumedSrcSize = 0;
-        zc->producedCSize = 0;
-        if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
-            zc->appliedParams.fParams.contentSizeFlag = 0;
-        DEBUGLOG(4, "pledged content size : %u ; flag : %u",
-            (unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);
-        zc->blockSize = blockSize;
-
-        XXH64_reset(&zc->xxhState, 0);
-        zc->stage = ZSTDcs_init;
-        zc->dictID = 0;
-        zc->dictContentSize = 0;
-
-        ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
-
-        FORWARD_IF_ERROR(ZSTD_reset_matchState(
-                &zc->blockState.matchState,
-                ws,
-                &params->cParams,
-                params->useRowMatchFinder,
-                crp,
-                needsIndexReset,
-                ZSTD_resetTarget_CCtx), "");
-
-        zc->seqStore.sequencesStart = (seqDef*)ZSTD_cwksp_reserve_aligned(ws, maxNbSeq * sizeof(seqDef));
-
-        /* ldm hash table */
-        if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-            /* TODO: avoid memset? */
-            size_t const ldmHSize = ((size_t)1) << params->ldmParams.hashLog;
-            zc->ldmState.hashTable = (ldmEntry_t*)ZSTD_cwksp_reserve_aligned(ws, ldmHSize * sizeof(ldmEntry_t));
-            ZSTD_memset(zc->ldmState.hashTable, 0, ldmHSize * sizeof(ldmEntry_t));
-            zc->ldmSequences = (rawSeq*)ZSTD_cwksp_reserve_aligned(ws, maxNbLdmSeq * sizeof(rawSeq));
-            zc->maxNbLdmSequences = maxNbLdmSeq;
-
-            ZSTD_window_init(&zc->ldmState.window);
-            zc->ldmState.loadedDictEnd = 0;
-        }
-
-        /* reserve space for block-level external sequences */
-        if (ZSTD_hasExtSeqProd(params)) {
-            size_t const maxNbExternalSeq = ZSTD_sequenceBound(blockSize);
-            zc->extSeqBufCapacity = maxNbExternalSeq;
-            zc->extSeqBuf =
-                (ZSTD_Sequence*)ZSTD_cwksp_reserve_aligned(ws, maxNbExternalSeq * sizeof(ZSTD_Sequence));
-        }
-
-        /* buffers */
-
-        /* ZSTD_wildcopy() is used to copy into the literals buffer,
-         * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.
-         */
-        zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + WILDCOPY_OVERLENGTH);
-        zc->seqStore.maxNbLit = blockSize;
-
-        zc->bufferedPolicy = zbuff;
-        zc->inBuffSize = buffInSize;
-        zc->inBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffInSize);
-        zc->outBuffSize = buffOutSize;
-        zc->outBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffOutSize);
-
-        /* ldm bucketOffsets table */
-        if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-            /* TODO: avoid memset? */
-            size_t const numBuckets =
-                  ((size_t)1) << (params->ldmParams.hashLog -
-                                  params->ldmParams.bucketSizeLog);
-            zc->ldmState.bucketOffsets = ZSTD_cwksp_reserve_buffer(ws, numBuckets);
-            ZSTD_memset(zc->ldmState.bucketOffsets, 0, numBuckets);
-        }
-
-        /* sequences storage */
-        ZSTD_referenceExternalSequences(zc, NULL, 0);
-        zc->seqStore.maxNbSeq = maxNbSeq;
-        zc->seqStore.llCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
-        zc->seqStore.mlCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
-        zc->seqStore.ofCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
-
-        DEBUGLOG(3, "wksp: finished allocating, %zd bytes remain available", ZSTD_cwksp_available_space(ws));
-        assert(ZSTD_cwksp_estimated_space_within_bounds(ws, neededSpace));
-
-        zc->initialized = 1;
-
-        return 0;
-    }
-}
-
-/* ZSTD_invalidateRepCodes() :
- * ensures next compression will not use repcodes from previous block.
- * Note : only works with regular variant;
- *        do not use with extDict variant ! */
-void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
-    int i;
-    for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0;
-    assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
-}
-
-/* These are the approximate sizes for each strategy past which copying the
- * dictionary tables into the working context is faster than using them
- * in-place.
- */
-static const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = {
-    8 KB,  /* unused */
-    8 KB,  /* ZSTD_fast */
-    16 KB, /* ZSTD_dfast */
-    32 KB, /* ZSTD_greedy */
-    32 KB, /* ZSTD_lazy */
-    32 KB, /* ZSTD_lazy2 */
-    32 KB, /* ZSTD_btlazy2 */
-    32 KB, /* ZSTD_btopt */
-    8 KB,  /* ZSTD_btultra */
-    8 KB   /* ZSTD_btultra2 */
-};
-
-static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
-                                 const ZSTD_CCtx_params* params,
-                                 U64 pledgedSrcSize)
-{
-    size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
-    int const dedicatedDictSearch = cdict->matchState.dedicatedDictSearch;
-    return dedicatedDictSearch
-        || ( ( pledgedSrcSize <= cutoff
-            || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
-            || params->attachDictPref == ZSTD_dictForceAttach )
-          && params->attachDictPref != ZSTD_dictForceCopy
-          && !params->forceWindow ); /* dictMatchState isn't correctly
-                                      * handled in _enforceMaxDist */
-}
-
-static size_t
-ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
-                        const ZSTD_CDict* cdict,
-                        ZSTD_CCtx_params params,
-                        U64 pledgedSrcSize,
-                        ZSTD_buffered_policy_e zbuff)
-{
-    DEBUGLOG(4, "ZSTD_resetCCtx_byAttachingCDict() pledgedSrcSize=%llu",
-                (unsigned long long)pledgedSrcSize);
-    {
-        ZSTD_compressionParameters adjusted_cdict_cParams = cdict->matchState.cParams;
-        unsigned const windowLog = params.cParams.windowLog;
-        assert(windowLog != 0);
-        /* Resize working context table params for input only, since the dict
-         * has its own tables. */
-        /* pledgedSrcSize == 0 means 0! */
-
-        if (cdict->matchState.dedicatedDictSearch) {
-            ZSTD_dedicatedDictSearch_revertCParams(&adjusted_cdict_cParams);
-        }
-
-        params.cParams = ZSTD_adjustCParams_internal(adjusted_cdict_cParams, pledgedSrcSize,
-                                                     cdict->dictContentSize, ZSTD_cpm_attachDict,
-                                                     params.useRowMatchFinder);
-        params.cParams.windowLog = windowLog;
-        params.useRowMatchFinder = cdict->useRowMatchFinder;    /* cdict overrides */
-        FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, &params, pledgedSrcSize,
-                                                 /* loadedDictSize */ 0,
-                                                 ZSTDcrp_makeClean, zbuff), "");
-        assert(cctx->appliedParams.cParams.strategy == adjusted_cdict_cParams.strategy);
-    }
-
-    {   const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc
-                                  - cdict->matchState.window.base);
-        const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit;
-        if (cdictLen == 0) {
-            /* don't even attach dictionaries with no contents */
-            DEBUGLOG(4, "skipping attaching empty dictionary");
-        } else {
-            DEBUGLOG(4, "attaching dictionary into context");
-            cctx->blockState.matchState.dictMatchState = &cdict->matchState;
-
-            /* prep working match state so dict matches never have negative indices
-             * when they are translated to the working context's index space. */
-            if (cctx->blockState.matchState.window.dictLimit < cdictEnd) {
-                cctx->blockState.matchState.window.nextSrc =
-                    cctx->blockState.matchState.window.base + cdictEnd;
-                ZSTD_window_clear(&cctx->blockState.matchState.window);
-            }
-            /* loadedDictEnd is expressed within the referential of the active context */
-            cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit;
-    }   }
-
-    cctx->dictID = cdict->dictID;
-    cctx->dictContentSize = cdict->dictContentSize;
-
-    /* copy block state */
-    ZSTD_memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));
-
-    return 0;
-}
-
-static void ZSTD_copyCDictTableIntoCCtx(U32* dst, U32 const* src, size_t tableSize,
-                                        ZSTD_compressionParameters const* cParams) {
-    if (ZSTD_CDictIndicesAreTagged(cParams)){
-        /* Remove tags from the CDict table if they are present.
-         * See docs on "short cache" in zstd_compress_internal.h for context. */
-        size_t i;
-        for (i = 0; i < tableSize; i++) {
-            U32 const taggedIndex = src[i];
-            U32 const index = taggedIndex >> ZSTD_SHORT_CACHE_TAG_BITS;
-            dst[i] = index;
-        }
-    } else {
-        ZSTD_memcpy(dst, src, tableSize * sizeof(U32));
-    }
-}
-
-static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
-                            const ZSTD_CDict* cdict,
-                            ZSTD_CCtx_params params,
-                            U64 pledgedSrcSize,
-                            ZSTD_buffered_policy_e zbuff)
-{
-    const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;
-
-    assert(!cdict->matchState.dedicatedDictSearch);
-    DEBUGLOG(4, "ZSTD_resetCCtx_byCopyingCDict() pledgedSrcSize=%llu",
-                (unsigned long long)pledgedSrcSize);
-
-    {   unsigned const windowLog = params.cParams.windowLog;
-        assert(windowLog != 0);
-        /* Copy only compression parameters related to tables. */
-        params.cParams = *cdict_cParams;
-        params.cParams.windowLog = windowLog;
-        params.useRowMatchFinder = cdict->useRowMatchFinder;
-        FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, &params, pledgedSrcSize,
-                                                 /* loadedDictSize */ 0,
-                                                 ZSTDcrp_leaveDirty, zbuff), "");
-        assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
-        assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog);
-        assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog);
-    }
-
-    ZSTD_cwksp_mark_tables_dirty(&cctx->workspace);
-    assert(params.useRowMatchFinder != ZSTD_ps_auto);
-
-    /* copy tables */
-    {   size_t const chainSize = ZSTD_allocateChainTable(cdict_cParams->strategy, cdict->useRowMatchFinder, 0 /* DDS guaranteed disabled */)
-                                                            ? ((size_t)1 << cdict_cParams->chainLog)
-                                                            : 0;
-        size_t const hSize =  (size_t)1 << cdict_cParams->hashLog;
-
-        ZSTD_copyCDictTableIntoCCtx(cctx->blockState.matchState.hashTable,
-                                cdict->matchState.hashTable,
-                                hSize, cdict_cParams);
-
-        /* Do not copy cdict's chainTable if cctx has parameters such that it would not use chainTable */
-        if (ZSTD_allocateChainTable(cctx->appliedParams.cParams.strategy, cctx->appliedParams.useRowMatchFinder, 0 /* forDDSDict */)) {
-            ZSTD_copyCDictTableIntoCCtx(cctx->blockState.matchState.chainTable,
-                                    cdict->matchState.chainTable,
-                                    chainSize, cdict_cParams);
-        }
-        /* copy tag table */
-        if (ZSTD_rowMatchFinderUsed(cdict_cParams->strategy, cdict->useRowMatchFinder)) {
-            size_t const tagTableSize = hSize;
-            ZSTD_memcpy(cctx->blockState.matchState.tagTable,
-                        cdict->matchState.tagTable,
-                        tagTableSize);
-            cctx->blockState.matchState.hashSalt = cdict->matchState.hashSalt;
-        }
-    }
-
-    /* Zero the hashTable3, since the cdict never fills it */
-    {   int const h3log = cctx->blockState.matchState.hashLog3;
-        size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;
-        assert(cdict->matchState.hashLog3 == 0);
-        ZSTD_memset(cctx->blockState.matchState.hashTable3, 0, h3Size * sizeof(U32));
-    }
-
-    ZSTD_cwksp_mark_tables_clean(&cctx->workspace);
-
-    /* copy dictionary offsets */
-    {   ZSTD_matchState_t const* srcMatchState = &cdict->matchState;
-        ZSTD_matchState_t* dstMatchState = &cctx->blockState.matchState;
-        dstMatchState->window       = srcMatchState->window;
-        dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
-        dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
-    }
-
-    cctx->dictID = cdict->dictID;
-    cctx->dictContentSize = cdict->dictContentSize;
-
-    /* copy block state */
-    ZSTD_memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));
-
-    return 0;
-}
-
-/* We have a choice between copying the dictionary context into the working
- * context, or referencing the dictionary context from the working context
- * in-place. We decide here which strategy to use. */
-static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx,
-                            const ZSTD_CDict* cdict,
-                            const ZSTD_CCtx_params* params,
-                            U64 pledgedSrcSize,
-                            ZSTD_buffered_policy_e zbuff)
-{
-
-    DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)",
-                (unsigned)pledgedSrcSize);
-
-    if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) {
-        return ZSTD_resetCCtx_byAttachingCDict(
-            cctx, cdict, *params, pledgedSrcSize, zbuff);
-    } else {
-        return ZSTD_resetCCtx_byCopyingCDict(
-            cctx, cdict, *params, pledgedSrcSize, zbuff);
-    }
-}
-
-/*! ZSTD_copyCCtx_internal() :
- *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
- *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
- *  The "context", in this case, refers to the hash and chain tables,
- *  entropy tables, and dictionary references.
- * `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx.
- * @return : 0, or an error code */
-static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
-                            const ZSTD_CCtx* srcCCtx,
-                            ZSTD_frameParameters fParams,
-                            U64 pledgedSrcSize,
-                            ZSTD_buffered_policy_e zbuff)
-{
-    RETURN_ERROR_IF(srcCCtx->stage!=ZSTDcs_init, stage_wrong,
-                    "Can't copy a ctx that's not in init stage.");
-    DEBUGLOG(5, "ZSTD_copyCCtx_internal");
-    ZSTD_memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));
-    {   ZSTD_CCtx_params params = dstCCtx->requestedParams;
-        /* Copy only compression parameters related to tables. */
-        params.cParams = srcCCtx->appliedParams.cParams;
-        assert(srcCCtx->appliedParams.useRowMatchFinder != ZSTD_ps_auto);
-        assert(srcCCtx->appliedParams.useBlockSplitter != ZSTD_ps_auto);
-        assert(srcCCtx->appliedParams.ldmParams.enableLdm != ZSTD_ps_auto);
-        params.useRowMatchFinder = srcCCtx->appliedParams.useRowMatchFinder;
-        params.useBlockSplitter = srcCCtx->appliedParams.useBlockSplitter;
-        params.ldmParams = srcCCtx->appliedParams.ldmParams;
-        params.fParams = fParams;
-        params.maxBlockSize = srcCCtx->appliedParams.maxBlockSize;
-        ZSTD_resetCCtx_internal(dstCCtx, &params, pledgedSrcSize,
-                                /* loadedDictSize */ 0,
-                                ZSTDcrp_leaveDirty, zbuff);
-        assert(dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog);
-        assert(dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy);
-        assert(dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog);
-        assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog);
-        assert(dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3);
-    }
-
-    ZSTD_cwksp_mark_tables_dirty(&dstCCtx->workspace);
-
-    /* copy tables */
-    {   size_t const chainSize = ZSTD_allocateChainTable(srcCCtx->appliedParams.cParams.strategy,
-                                                         srcCCtx->appliedParams.useRowMatchFinder,
-                                                         0 /* forDDSDict */)
-                                    ? ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog)
-                                    : 0;
-        size_t const hSize =  (size_t)1 << srcCCtx->appliedParams.cParams.hashLog;
-        int const h3log = srcCCtx->blockState.matchState.hashLog3;
-        size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;
-
-        ZSTD_memcpy(dstCCtx->blockState.matchState.hashTable,
-               srcCCtx->blockState.matchState.hashTable,
-               hSize * sizeof(U32));
-        ZSTD_memcpy(dstCCtx->blockState.matchState.chainTable,
-               srcCCtx->blockState.matchState.chainTable,
-               chainSize * sizeof(U32));
-        ZSTD_memcpy(dstCCtx->blockState.matchState.hashTable3,
-               srcCCtx->blockState.matchState.hashTable3,
-               h3Size * sizeof(U32));
-    }
-
-    ZSTD_cwksp_mark_tables_clean(&dstCCtx->workspace);
-
-    /* copy dictionary offsets */
-    {
-        const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState;
-        ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState;
-        dstMatchState->window       = srcMatchState->window;
-        dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
-        dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
-    }
-    dstCCtx->dictID = srcCCtx->dictID;
-    dstCCtx->dictContentSize = srcCCtx->dictContentSize;
-
-    /* copy block state */
-    ZSTD_memcpy(dstCCtx->blockState.prevCBlock, srcCCtx->blockState.prevCBlock, sizeof(*srcCCtx->blockState.prevCBlock));
-
-    return 0;
-}
-
-/*! ZSTD_copyCCtx() :
- *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
- *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
- *  pledgedSrcSize==0 means "unknown".
-*   @return : 0, or an error code */
-size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize)
-{
-    ZSTD_frameParameters fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
-    ZSTD_buffered_policy_e const zbuff = srcCCtx->bufferedPolicy;
-    ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);
-    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
-    fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);
-
-    return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx,
-                                fParams, pledgedSrcSize,
-                                zbuff);
-}
-
-
-#define ZSTD_ROWSIZE 16
-/*! ZSTD_reduceTable() :
- *  reduce table indexes by `reducerValue`, or squash to zero.
- *  PreserveMark preserves "unsorted mark" for btlazy2 strategy.
- *  It must be set to a clear 0/1 value, to remove branch during inlining.
- *  Presume table size is a multiple of ZSTD_ROWSIZE
- *  to help auto-vectorization */
-FORCE_INLINE_TEMPLATE void
-ZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerValue, int const preserveMark)
-{
-    int const nbRows = (int)size / ZSTD_ROWSIZE;
-    int cellNb = 0;
-    int rowNb;
-    /* Protect special index values < ZSTD_WINDOW_START_INDEX. */
-    U32 const reducerThreshold = reducerValue + ZSTD_WINDOW_START_INDEX;
-    assert((size & (ZSTD_ROWSIZE-1)) == 0);  /* multiple of ZSTD_ROWSIZE */
-    assert(size < (1U<<31));   /* can be casted to int */
-
-    for (rowNb=0 ; rowNb < nbRows ; rowNb++) {
-        int column;
-        for (column=0; column<ZSTD_ROWSIZE; column++) {
-            U32 newVal;
-            if (preserveMark && table[cellNb] == ZSTD_DUBT_UNSORTED_MARK) {
-                /* This write is pointless, but is required(?) for the compiler
-                 * to auto-vectorize the loop. */
-                newVal = ZSTD_DUBT_UNSORTED_MARK;
-            } else if (table[cellNb] < reducerThreshold) {
-                newVal = 0;
-            } else {
-                newVal = table[cellNb] - reducerValue;
-            }
-            table[cellNb] = newVal;
-            cellNb++;
-    }   }
-}
-
-static void ZSTD_reduceTable(U32* const table, U32 const size, U32 const reducerValue)
-{
-    ZSTD_reduceTable_internal(table, size, reducerValue, 0);
-}
-
-static void ZSTD_reduceTable_btlazy2(U32* const table, U32 const size, U32 const reducerValue)
-{
-    ZSTD_reduceTable_internal(table, size, reducerValue, 1);
-}
-
-/*! ZSTD_reduceIndex() :
-*   rescale all indexes to avoid future overflow (indexes are U32) */
-static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const U32 reducerValue)
-{
-    {   U32 const hSize = (U32)1 << params->cParams.hashLog;
-        ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);
-    }
-
-    if (ZSTD_allocateChainTable(params->cParams.strategy, params->useRowMatchFinder, (U32)ms->dedicatedDictSearch)) {
-        U32 const chainSize = (U32)1 << params->cParams.chainLog;
-        if (params->cParams.strategy == ZSTD_btlazy2)
-            ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue);
-        else
-            ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue);
-    }
-
-    if (ms->hashLog3) {
-        U32 const h3Size = (U32)1 << ms->hashLog3;
-        ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue);
-    }
-}
-
-
-/*-*******************************************************
-*  Block entropic compression
-*********************************************************/
-
-/* See doc/zstd_compression_format.md for detailed format description */
-
-int ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
-{
-    const seqDef* const sequences = seqStorePtr->sequencesStart;
-    BYTE* const llCodeTable = seqStorePtr->llCode;
-    BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    U32 u;
-    int longOffsets = 0;
-    assert(nbSeq <= seqStorePtr->maxNbSeq);
-    for (u=0; u<nbSeq; u++) {
-        U32 const llv = sequences[u].litLength;
-        U32 const ofCode = ZSTD_highbit32(sequences[u].offBase);
-        U32 const mlv = sequences[u].mlBase;
-        llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
-        ofCodeTable[u] = (BYTE)ofCode;
-        mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
-        assert(!(MEM_64bits() && ofCode >= STREAM_ACCUMULATOR_MIN));
-        if (MEM_32bits() && ofCode >= STREAM_ACCUMULATOR_MIN)
-            longOffsets = 1;
-    }
-    if (seqStorePtr->longLengthType==ZSTD_llt_literalLength)
-        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
-    if (seqStorePtr->longLengthType==ZSTD_llt_matchLength)
-        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
-    return longOffsets;
-}
-
-/* ZSTD_useTargetCBlockSize():
- * Returns if target compressed block size param is being used.
- * If used, compression will do best effort to make a compressed block size to be around targetCBlockSize.
- * Returns 1 if true, 0 otherwise. */
-static int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams)
-{
-    DEBUGLOG(5, "ZSTD_useTargetCBlockSize (targetCBlockSize=%zu)", cctxParams->targetCBlockSize);
-    return (cctxParams->targetCBlockSize != 0);
-}
-
-/* ZSTD_blockSplitterEnabled():
- * Returns if block splitting param is being used
- * If used, compression will do best effort to split a block in order to improve compression ratio.
- * At the time this function is called, the parameter must be finalized.
- * Returns 1 if true, 0 otherwise. */
-static int ZSTD_blockSplitterEnabled(ZSTD_CCtx_params* cctxParams)
-{
-    DEBUGLOG(5, "ZSTD_blockSplitterEnabled (useBlockSplitter=%d)", cctxParams->useBlockSplitter);
-    assert(cctxParams->useBlockSplitter != ZSTD_ps_auto);
-    return (cctxParams->useBlockSplitter == ZSTD_ps_enable);
-}
-
-/* Type returned by ZSTD_buildSequencesStatistics containing finalized symbol encoding types
- * and size of the sequences statistics
- */
-typedef struct {
-    U32 LLtype;
-    U32 Offtype;
-    U32 MLtype;
-    size_t size;
-    size_t lastCountSize; /* Accounts for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */
-    int longOffsets;
-} ZSTD_symbolEncodingTypeStats_t;
-
-/* ZSTD_buildSequencesStatistics():
- * Returns a ZSTD_symbolEncodingTypeStats_t, or a zstd error code in the `size` field.
- * Modifies `nextEntropy` to have the appropriate values as a side effect.
- * nbSeq must be greater than 0.
- *
- * entropyWkspSize must be of size at least ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1)*sizeof(U32)
- */
-static ZSTD_symbolEncodingTypeStats_t
-ZSTD_buildSequencesStatistics(
-                const seqStore_t* seqStorePtr, size_t nbSeq,
-                const ZSTD_fseCTables_t* prevEntropy, ZSTD_fseCTables_t* nextEntropy,
-                      BYTE* dst, const BYTE* const dstEnd,
-                      ZSTD_strategy strategy, unsigned* countWorkspace,
-                      void* entropyWorkspace, size_t entropyWkspSize)
-{
-    BYTE* const ostart = dst;
-    const BYTE* const oend = dstEnd;
-    BYTE* op = ostart;
-    FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable;
-    FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable;
-    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    const BYTE* const llCodeTable = seqStorePtr->llCode;
-    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    ZSTD_symbolEncodingTypeStats_t stats;
-
-    stats.lastCountSize = 0;
-    /* convert length/distances into codes */
-    stats.longOffsets = ZSTD_seqToCodes(seqStorePtr);
-    assert(op <= oend);
-    assert(nbSeq != 0); /* ZSTD_selectEncodingType() divides by nbSeq */
-    /* build CTable for Literal Lengths */
-    {   unsigned max = MaxLL;
-        size_t const mostFrequent = HIST_countFast_wksp(countWorkspace, &max, llCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */
-        DEBUGLOG(5, "Building LL table");
-        nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode;
-        stats.LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        LLFSELog, prevEntropy->litlengthCTable,
-                                        LL_defaultNorm, LL_defaultNormLog,
-                                        ZSTD_defaultAllowed, strategy);
-        assert(set_basic < set_compressed && set_rle < set_compressed);
-        assert(!(stats.LLtype < set_compressed && nextEntropy->litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_LitLength, LLFSELog, (symbolEncodingType_e)stats.LLtype,
-                countWorkspace, max, llCodeTable, nbSeq,
-                LL_defaultNorm, LL_defaultNormLog, MaxLL,
-                prevEntropy->litlengthCTable,
-                sizeof(prevEntropy->litlengthCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for LitLens failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.LLtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    /* build CTable for Offsets */
-    {   unsigned max = MaxOff;
-        size_t const mostFrequent = HIST_countFast_wksp(
-            countWorkspace, &max, ofCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);  /* can't fail */
-        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
-        ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
-        DEBUGLOG(5, "Building OF table");
-        nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode;
-        stats.Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        OffFSELog, prevEntropy->offcodeCTable,
-                                        OF_defaultNorm, OF_defaultNormLog,
-                                        defaultPolicy, strategy);
-        assert(!(stats.Offtype < set_compressed && nextEntropy->offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)stats.Offtype,
-                countWorkspace, max, ofCodeTable, nbSeq,
-                OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
-                prevEntropy->offcodeCTable,
-                sizeof(prevEntropy->offcodeCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for Offsets failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.Offtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    /* build CTable for MatchLengths */
-    {   unsigned max = MaxML;
-        size_t const mostFrequent = HIST_countFast_wksp(
-            countWorkspace, &max, mlCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */
-        DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
-        nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode;
-        stats.MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        MLFSELog, prevEntropy->matchlengthCTable,
-                                        ML_defaultNorm, ML_defaultNormLog,
-                                        ZSTD_defaultAllowed, strategy);
-        assert(!(stats.MLtype < set_compressed && nextEntropy->matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_MatchLength, MLFSELog, (symbolEncodingType_e)stats.MLtype,
-                countWorkspace, max, mlCodeTable, nbSeq,
-                ML_defaultNorm, ML_defaultNormLog, MaxML,
-                prevEntropy->matchlengthCTable,
-                sizeof(prevEntropy->matchlengthCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for MatchLengths failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.MLtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    stats.size = (size_t)(op-ostart);
-    return stats;
-}
-
-/* ZSTD_entropyCompressSeqStore_internal():
- * compresses both literals and sequences
- * Returns compressed size of block, or a zstd error.
- */
-#define SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO 20
-MEM_STATIC size_t
-ZSTD_entropyCompressSeqStore_internal(
-                        const seqStore_t* seqStorePtr,
-                        const ZSTD_entropyCTables_t* prevEntropy,
-                              ZSTD_entropyCTables_t* nextEntropy,
-                        const ZSTD_CCtx_params* cctxParams,
-                              void* dst, size_t dstCapacity,
-                              void* entropyWorkspace, size_t entropyWkspSize,
-                        const int bmi2)
-{
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
-    unsigned* count = (unsigned*)entropyWorkspace;
-    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
-    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
-    const seqDef* const sequences = seqStorePtr->sequencesStart;
-    const size_t nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    const BYTE* const llCodeTable = seqStorePtr->llCode;
-    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    size_t lastCountSize;
-    int longOffsets = 0;
-
-    entropyWorkspace = count + (MaxSeq + 1);
-    entropyWkspSize -= (MaxSeq + 1) * sizeof(*count);
-
-    DEBUGLOG(5, "ZSTD_entropyCompressSeqStore_internal (nbSeq=%zu, dstCapacity=%zu)", nbSeq, dstCapacity);
-    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
-    assert(entropyWkspSize >= HUF_WORKSPACE_SIZE);
-
-    /* Compress literals */
-    {   const BYTE* const literals = seqStorePtr->litStart;
-        size_t const numSequences = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-        size_t const numLiterals = (size_t)(seqStorePtr->lit - seqStorePtr->litStart);
-        /* Base suspicion of uncompressibility on ratio of literals to sequences */
-        unsigned const suspectUncompressible = (numSequences == 0) || (numLiterals / numSequences >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);
-        size_t const litSize = (size_t)(seqStorePtr->lit - literals);
-
-        size_t const cSize = ZSTD_compressLiterals(
-                                    op, dstCapacity,
-                                    literals, litSize,
-                                    entropyWorkspace, entropyWkspSize,
-                                    &prevEntropy->huf, &nextEntropy->huf,
-                                    cctxParams->cParams.strategy,
-                                    ZSTD_literalsCompressionIsDisabled(cctxParams),
-                                    suspectUncompressible, bmi2);
-        FORWARD_IF_ERROR(cSize, "ZSTD_compressLiterals failed");
-        assert(cSize <= dstCapacity);
-        op += cSize;
-    }
-
-    /* Sequences Header */
-    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
-                    dstSize_tooSmall, "Can't fit seq hdr in output buf!");
-    if (nbSeq < 128) {
-        *op++ = (BYTE)nbSeq;
-    } else if (nbSeq < LONGNBSEQ) {
-        op[0] = (BYTE)((nbSeq>>8) + 0x80);
-        op[1] = (BYTE)nbSeq;
-        op+=2;
-    } else {
-        op[0]=0xFF;
-        MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ));
-        op+=3;
-    }
-    assert(op <= oend);
-    if (nbSeq==0) {
-        /* Copy the old tables over as if we repeated them */
-        ZSTD_memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
-        return (size_t)(op - ostart);
-    }
-    {   BYTE* const seqHead = op++;
-        /* build stats for sequences */
-        const ZSTD_symbolEncodingTypeStats_t stats =
-                ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,
-                                             &prevEntropy->fse, &nextEntropy->fse,
-                                              op, oend,
-                                              strategy, count,
-                                              entropyWorkspace, entropyWkspSize);
-        FORWARD_IF_ERROR(stats.size, "ZSTD_buildSequencesStatistics failed!");
-        *seqHead = (BYTE)((stats.LLtype<<6) + (stats.Offtype<<4) + (stats.MLtype<<2));
-        lastCountSize = stats.lastCountSize;
-        op += stats.size;
-        longOffsets = stats.longOffsets;
-    }
-
-    {   size_t const bitstreamSize = ZSTD_encodeSequences(
-                                        op, (size_t)(oend - op),
-                                        CTable_MatchLength, mlCodeTable,
-                                        CTable_OffsetBits, ofCodeTable,
-                                        CTable_LitLength, llCodeTable,
-                                        sequences, nbSeq,
-                                        longOffsets, bmi2);
-        FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
-        op += bitstreamSize;
-        assert(op <= oend);
-        /* zstd versions <= 1.3.4 mistakenly report corruption when
-         * FSE_readNCount() receives a buffer < 4 bytes.
-         * Fixed by https://github.com/facebook/zstd/pull/1146.
-         * This can happen when the last set_compressed table present is 2
-         * bytes and the bitstream is only one byte.
-         * In this exceedingly rare case, we will simply emit an uncompressed
-         * block, since it isn't worth optimizing.
-         */
-        if (lastCountSize && (lastCountSize + bitstreamSize) < 4) {
-            /* lastCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
-            assert(lastCountSize + bitstreamSize == 3);
-            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
-                        "emitting an uncompressed block.");
-            return 0;
-        }
-    }
-
-    DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
-    return (size_t)(op - ostart);
-}
-
-MEM_STATIC size_t
-ZSTD_entropyCompressSeqStore(
-                    const seqStore_t* seqStorePtr,
-                    const ZSTD_entropyCTables_t* prevEntropy,
-                          ZSTD_entropyCTables_t* nextEntropy,
-                    const ZSTD_CCtx_params* cctxParams,
-                          void* dst, size_t dstCapacity,
-                          size_t srcSize,
-                          void* entropyWorkspace, size_t entropyWkspSize,
-                          int bmi2)
-{
-    size_t const cSize = ZSTD_entropyCompressSeqStore_internal(
-                            seqStorePtr, prevEntropy, nextEntropy, cctxParams,
-                            dst, dstCapacity,
-                            entropyWorkspace, entropyWkspSize, bmi2);
-    if (cSize == 0) return 0;
-    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
-     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
-     */
-    if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity)) {
-        DEBUGLOG(4, "not enough dstCapacity (%zu) for ZSTD_entropyCompressSeqStore_internal()=> do not compress block", dstCapacity);
-        return 0;  /* block not compressed */
-    }
-    FORWARD_IF_ERROR(cSize, "ZSTD_entropyCompressSeqStore_internal failed");
-
-    /* Check compressibility */
-    {   size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
-        if (cSize >= maxCSize) return 0;  /* block not compressed */
-    }
-    DEBUGLOG(5, "ZSTD_entropyCompressSeqStore() cSize: %zu", cSize);
-    /* libzstd decoder before  > v1.5.4 is not compatible with compressed blocks of size ZSTD_BLOCKSIZE_MAX exactly.
-     * This restriction is indirectly already fulfilled by respecting ZSTD_minGain() condition above.
-     */
-    assert(cSize < ZSTD_BLOCKSIZE_MAX);
-    return cSize;
-}
-
-/* ZSTD_selectBlockCompressor() :
- * Not static, but internal use only (used by long distance matcher)
- * assumption : strat is a valid strategy */
-ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramSwitch_e useRowMatchFinder, ZSTD_dictMode_e dictMode)
-{
-    static const ZSTD_blockCompressor blockCompressor[4][ZSTD_STRATEGY_MAX+1] = {
-        { ZSTD_compressBlock_fast  /* default for 0 */,
-          ZSTD_compressBlock_fast,
-          ZSTD_COMPRESSBLOCK_DOUBLEFAST,
-          ZSTD_COMPRESSBLOCK_GREEDY,
-          ZSTD_COMPRESSBLOCK_LAZY,
-          ZSTD_COMPRESSBLOCK_LAZY2,
-          ZSTD_COMPRESSBLOCK_BTLAZY2,
-          ZSTD_COMPRESSBLOCK_BTOPT,
-          ZSTD_COMPRESSBLOCK_BTULTRA,
-          ZSTD_COMPRESSBLOCK_BTULTRA2
-        },
-        { ZSTD_compressBlock_fast_extDict  /* default for 0 */,
-          ZSTD_compressBlock_fast_extDict,
-          ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT,
-          ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT,
-          ZSTD_COMPRESSBLOCK_LAZY_EXTDICT,
-          ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT,
-          ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT,
-          ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT,
-          ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT,
-          ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT
-        },
-        { ZSTD_compressBlock_fast_dictMatchState  /* default for 0 */,
-          ZSTD_compressBlock_fast_dictMatchState,
-          ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE,
-          ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE
-        },
-        { NULL  /* default for 0 */,
-          NULL,
-          NULL,
-          ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH,
-          ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH,
-          ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH,
-          NULL,
-          NULL,
-          NULL,
-          NULL }
-    };
-    ZSTD_blockCompressor selectedCompressor;
-    ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);
-
-    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
-    DEBUGLOG(4, "Selected block compressor: dictMode=%d strat=%d rowMatchfinder=%d", (int)dictMode, (int)strat, (int)useRowMatchFinder);
-    if (ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder)) {
-        static const ZSTD_blockCompressor rowBasedBlockCompressors[4][3] = {
-            {
-                ZSTD_COMPRESSBLOCK_GREEDY_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY2_ROW
-            },
-            {
-                ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW
-            },
-            {
-                ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW
-            },
-            {
-                ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW,
-                ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW
-            }
-        };
-        DEBUGLOG(4, "Selecting a row-based matchfinder");
-        assert(useRowMatchFinder != ZSTD_ps_auto);
-        selectedCompressor = rowBasedBlockCompressors[(int)dictMode][(int)strat - (int)ZSTD_greedy];
-    } else {
-        selectedCompressor = blockCompressor[(int)dictMode][(int)strat];
-    }
-    assert(selectedCompressor != NULL);
-    return selectedCompressor;
-}
-
-static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
-                                   const BYTE* anchor, size_t lastLLSize)
-{
-    ZSTD_memcpy(seqStorePtr->lit, anchor, lastLLSize);
-    seqStorePtr->lit += lastLLSize;
-}
-
-void ZSTD_resetSeqStore(seqStore_t* ssPtr)
-{
-    ssPtr->lit = ssPtr->litStart;
-    ssPtr->sequences = ssPtr->sequencesStart;
-    ssPtr->longLengthType = ZSTD_llt_none;
-}
-
-/* ZSTD_postProcessSequenceProducerResult() :
- * Validates and post-processes sequences obtained through the external matchfinder API:
- *   - Checks whether nbExternalSeqs represents an error condition.
- *   - Appends a block delimiter to outSeqs if one is not already present.
- *     See zstd.h for context regarding block delimiters.
- * Returns the number of sequences after post-processing, or an error code. */
-static size_t ZSTD_postProcessSequenceProducerResult(
-    ZSTD_Sequence* outSeqs, size_t nbExternalSeqs, size_t outSeqsCapacity, size_t srcSize
-) {
-    RETURN_ERROR_IF(
-        nbExternalSeqs > outSeqsCapacity,
-        sequenceProducer_failed,
-        "External sequence producer returned error code %lu",
-        (unsigned long)nbExternalSeqs
-    );
-
-    RETURN_ERROR_IF(
-        nbExternalSeqs == 0 && srcSize > 0,
-        sequenceProducer_failed,
-        "Got zero sequences from external sequence producer for a non-empty src buffer!"
-    );
-
-    if (srcSize == 0) {
-        ZSTD_memset(&outSeqs[0], 0, sizeof(ZSTD_Sequence));
-        return 1;
-    }
-
-    {
-        ZSTD_Sequence const lastSeq = outSeqs[nbExternalSeqs - 1];
-
-        /* We can return early if lastSeq is already a block delimiter. */
-        if (lastSeq.offset == 0 && lastSeq.matchLength == 0) {
-            return nbExternalSeqs;
-        }
-
-        /* This error condition is only possible if the external matchfinder
-         * produced an invalid parse, by definition of ZSTD_sequenceBound(). */
-        RETURN_ERROR_IF(
-            nbExternalSeqs == outSeqsCapacity,
-            sequenceProducer_failed,
-            "nbExternalSeqs == outSeqsCapacity but lastSeq is not a block delimiter!"
-        );
-
-        /* lastSeq is not a block delimiter, so we need to append one. */
-        ZSTD_memset(&outSeqs[nbExternalSeqs], 0, sizeof(ZSTD_Sequence));
-        return nbExternalSeqs + 1;
-    }
-}
-
-/* ZSTD_fastSequenceLengthSum() :
- * Returns sum(litLen) + sum(matchLen) + lastLits for *seqBuf*.
- * Similar to another function in zstd_compress.c (determine_blockSize),
- * except it doesn't check for a block delimiter to end summation.
- * Removing the early exit allows the compiler to auto-vectorize (https://godbolt.org/z/cY1cajz9P).
- * This function can be deleted and replaced by determine_blockSize after we resolve issue #3456. */
-static size_t ZSTD_fastSequenceLengthSum(ZSTD_Sequence const* seqBuf, size_t seqBufSize) {
-    size_t matchLenSum, litLenSum, i;
-    matchLenSum = 0;
-    litLenSum = 0;
-    for (i = 0; i < seqBufSize; i++) {
-        litLenSum += seqBuf[i].litLength;
-        matchLenSum += seqBuf[i].matchLength;
-    }
-    return litLenSum + matchLenSum;
-}
-
-typedef enum { ZSTDbss_compress, ZSTDbss_noCompress } ZSTD_buildSeqStore_e;
-
-static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
-{
-    ZSTD_matchState_t* const ms = &zc->blockState.matchState;
-    DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
-    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
-    /* Assert that we have correctly flushed the ctx params into the ms's copy */
-    ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
-    /* TODO: See 3090. We reduced MIN_CBLOCK_SIZE from 3 to 2 so to compensate we are adding
-     * additional 1. We need to revisit and change this logic to be more consistent */
-    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1+1) {
-        if (zc->appliedParams.cParams.strategy >= ZSTD_btopt) {
-            ZSTD_ldm_skipRawSeqStoreBytes(&zc->externSeqStore, srcSize);
-        } else {
-            ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
-        }
-        return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */
-    }
-    ZSTD_resetSeqStore(&(zc->seqStore));
-    /* required for optimal parser to read stats from dictionary */
-    ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;
-    /* tell the optimal parser how we expect to compress literals */
-    ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;
-    /* a gap between an attached dict and the current window is not safe,
-     * they must remain adjacent,
-     * and when that stops being the case, the dict must be unset */
-    assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);
-
-    /* limited update after a very long match */
-    {   const BYTE* const base = ms->window.base;
-        const BYTE* const istart = (const BYTE*)src;
-        const U32 curr = (U32)(istart-base);
-        if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1));   /* ensure no overflow */
-        if (curr > ms->nextToUpdate + 384)
-            ms->nextToUpdate = curr - MIN(192, (U32)(curr - ms->nextToUpdate - 384));
-    }
-
-    /* select and store sequences */
-    {   ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);
-        size_t lastLLSize;
-        {   int i;
-            for (i = 0; i < ZSTD_REP_NUM; ++i)
-                zc->blockState.nextCBlock->rep[i] = zc->blockState.prevCBlock->rep[i];
-        }
-        if (zc->externSeqStore.pos < zc->externSeqStore.size) {
-            assert(zc->appliedParams.ldmParams.enableLdm == ZSTD_ps_disable);
-
-            /* External matchfinder + LDM is technically possible, just not implemented yet.
-             * We need to revisit soon and implement it. */
-            RETURN_ERROR_IF(
-                ZSTD_hasExtSeqProd(&zc->appliedParams),
-                parameter_combination_unsupported,
-                "Long-distance matching with external sequence producer enabled is not currently supported."
-            );
-
-            /* Updates ldmSeqStore.pos */
-            lastLLSize =
-                ZSTD_ldm_blockCompress(&zc->externSeqStore,
-                                       ms, &zc->seqStore,
-                                       zc->blockState.nextCBlock->rep,
-                                       zc->appliedParams.useRowMatchFinder,
-                                       src, srcSize);
-            assert(zc->externSeqStore.pos <= zc->externSeqStore.size);
-        } else if (zc->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {
-            rawSeqStore_t ldmSeqStore = kNullRawSeqStore;
-
-            /* External matchfinder + LDM is technically possible, just not implemented yet.
-             * We need to revisit soon and implement it. */
-            RETURN_ERROR_IF(
-                ZSTD_hasExtSeqProd(&zc->appliedParams),
-                parameter_combination_unsupported,
-                "Long-distance matching with external sequence producer enabled is not currently supported."
-            );
-
-            ldmSeqStore.seq = zc->ldmSequences;
-            ldmSeqStore.capacity = zc->maxNbLdmSequences;
-            /* Updates ldmSeqStore.size */
-            FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,
-                                               &zc->appliedParams.ldmParams,
-                                               src, srcSize), "");
-            /* Updates ldmSeqStore.pos */
-            lastLLSize =
-                ZSTD_ldm_blockCompress(&ldmSeqStore,
-                                       ms, &zc->seqStore,
-                                       zc->blockState.nextCBlock->rep,
-                                       zc->appliedParams.useRowMatchFinder,
-                                       src, srcSize);
-            assert(ldmSeqStore.pos == ldmSeqStore.size);
-        } else if (ZSTD_hasExtSeqProd(&zc->appliedParams)) {
-            assert(
-                zc->extSeqBufCapacity >= ZSTD_sequenceBound(srcSize)
-            );
-            assert(zc->appliedParams.extSeqProdFunc != NULL);
-
-            {   U32 const windowSize = (U32)1 << zc->appliedParams.cParams.windowLog;
-
-                size_t const nbExternalSeqs = (zc->appliedParams.extSeqProdFunc)(
-                    zc->appliedParams.extSeqProdState,
-                    zc->extSeqBuf,
-                    zc->extSeqBufCapacity,
-                    src, srcSize,
-                    NULL, 0,  /* dict and dictSize, currently not supported */
-                    zc->appliedParams.compressionLevel,
-                    windowSize
-                );
-
-                size_t const nbPostProcessedSeqs = ZSTD_postProcessSequenceProducerResult(
-                    zc->extSeqBuf,
-                    nbExternalSeqs,
-                    zc->extSeqBufCapacity,
-                    srcSize
-                );
-
-                /* Return early if there is no error, since we don't need to worry about last literals */
-                if (!ZSTD_isError(nbPostProcessedSeqs)) {
-                    ZSTD_sequencePosition seqPos = {0,0,0};
-                    size_t const seqLenSum = ZSTD_fastSequenceLengthSum(zc->extSeqBuf, nbPostProcessedSeqs);
-                    RETURN_ERROR_IF(seqLenSum > srcSize, externalSequences_invalid, "External sequences imply too large a block!");
-                    FORWARD_IF_ERROR(
-                        ZSTD_copySequencesToSeqStoreExplicitBlockDelim(
-                            zc, &seqPos,
-                            zc->extSeqBuf, nbPostProcessedSeqs,
-                            src, srcSize,
-                            zc->appliedParams.searchForExternalRepcodes
-                        ),
-                        "Failed to copy external sequences to seqStore!"
-                    );
-                    ms->ldmSeqStore = NULL;
-                    DEBUGLOG(5, "Copied %lu sequences from external sequence producer to internal seqStore.", (unsigned long)nbExternalSeqs);
-                    return ZSTDbss_compress;
-                }
-
-                /* Propagate the error if fallback is disabled */
-                if (!zc->appliedParams.enableMatchFinderFallback) {
-                    return nbPostProcessedSeqs;
-                }
-
-                /* Fallback to software matchfinder */
-                {   ZSTD_blockCompressor const blockCompressor =
-                        ZSTD_selectBlockCompressor(
-                            zc->appliedParams.cParams.strategy,
-                            zc->appliedParams.useRowMatchFinder,
-                            dictMode);
-                    ms->ldmSeqStore = NULL;
-                    DEBUGLOG(
-                        5,
-                        "External sequence producer returned error code %lu. Falling back to internal parser.",
-                        (unsigned long)nbExternalSeqs
-                    );
-                    lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
-            }   }
-        } else {   /* not long range mode and no external matchfinder */
-            ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(
-                    zc->appliedParams.cParams.strategy,
-                    zc->appliedParams.useRowMatchFinder,
-                    dictMode);
-            ms->ldmSeqStore = NULL;
-            lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
-        }
-        {   const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;
-            ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
-    }   }
-    return ZSTDbss_compress;
-}
-
-static size_t ZSTD_copyBlockSequences(SeqCollector* seqCollector, const seqStore_t* seqStore, const U32 prevRepcodes[ZSTD_REP_NUM])
-{
-    const seqDef* inSeqs = seqStore->sequencesStart;
-    const size_t nbInSequences = seqStore->sequences - inSeqs;
-    const size_t nbInLiterals = (size_t)(seqStore->lit - seqStore->litStart);
-
-    ZSTD_Sequence* outSeqs = seqCollector->seqIndex == 0 ? seqCollector->seqStart : seqCollector->seqStart + seqCollector->seqIndex;
-    const size_t nbOutSequences = nbInSequences + 1;
-    size_t nbOutLiterals = 0;
-    repcodes_t repcodes;
-    size_t i;
-
-    /* Bounds check that we have enough space for every input sequence
-     * and the block delimiter
-     */
-    assert(seqCollector->seqIndex <= seqCollector->maxSequences);
-    RETURN_ERROR_IF(
-        nbOutSequences > (size_t)(seqCollector->maxSequences - seqCollector->seqIndex),
-        dstSize_tooSmall,
-        "Not enough space to copy sequences");
-
-    ZSTD_memcpy(&repcodes, prevRepcodes, sizeof(repcodes));
-    for (i = 0; i < nbInSequences; ++i) {
-        U32 rawOffset;
-        outSeqs[i].litLength = inSeqs[i].litLength;
-        outSeqs[i].matchLength = inSeqs[i].mlBase + MINMATCH;
-        outSeqs[i].rep = 0;
-
-        /* Handle the possible single length >= 64K
-         * There can only be one because we add MINMATCH to every match length,
-         * and blocks are at most 128K.
-         */
-        if (i == seqStore->longLengthPos) {
-            if (seqStore->longLengthType == ZSTD_llt_literalLength) {
-                outSeqs[i].litLength += 0x10000;
-            } else if (seqStore->longLengthType == ZSTD_llt_matchLength) {
-                outSeqs[i].matchLength += 0x10000;
-            }
-        }
-
-        /* Determine the raw offset given the offBase, which may be a repcode. */
-        if (OFFBASE_IS_REPCODE(inSeqs[i].offBase)) {
-            const U32 repcode = OFFBASE_TO_REPCODE(inSeqs[i].offBase);
-            assert(repcode > 0);
-            outSeqs[i].rep = repcode;
-            if (outSeqs[i].litLength != 0) {
-                rawOffset = repcodes.rep[repcode - 1];
-            } else {
-                if (repcode == 3) {
-                    assert(repcodes.rep[0] > 1);
-                    rawOffset = repcodes.rep[0] - 1;
-                } else {
-                    rawOffset = repcodes.rep[repcode];
-                }
-            }
-        } else {
-            rawOffset = OFFBASE_TO_OFFSET(inSeqs[i].offBase);
-        }
-        outSeqs[i].offset = rawOffset;
-
-        /* Update repcode history for the sequence */
-        ZSTD_updateRep(repcodes.rep,
-                       inSeqs[i].offBase,
-                       inSeqs[i].litLength == 0);
-
-        nbOutLiterals += outSeqs[i].litLength;
-    }
-    /* Insert last literals (if any exist) in the block as a sequence with ml == off == 0.
-     * If there are no last literals, then we'll emit (of: 0, ml: 0, ll: 0), which is a marker
-     * for the block boundary, according to the API.
-     */
-    assert(nbInLiterals >= nbOutLiterals);
-    {
-        const size_t lastLLSize = nbInLiterals - nbOutLiterals;
-        outSeqs[nbInSequences].litLength = (U32)lastLLSize;
-        outSeqs[nbInSequences].matchLength = 0;
-        outSeqs[nbInSequences].offset = 0;
-        assert(nbOutSequences == nbInSequences + 1);
-    }
-    seqCollector->seqIndex += nbOutSequences;
-    assert(seqCollector->seqIndex <= seqCollector->maxSequences);
-
-    return 0;
-}
-
-size_t ZSTD_sequenceBound(size_t srcSize) {
-    const size_t maxNbSeq = (srcSize / ZSTD_MINMATCH_MIN) + 1;
-    const size_t maxNbDelims = (srcSize / ZSTD_BLOCKSIZE_MAX_MIN) + 1;
-    return maxNbSeq + maxNbDelims;
-}
-
-size_t ZSTD_generateSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,
-                              size_t outSeqsSize, const void* src, size_t srcSize)
-{
-    const size_t dstCapacity = ZSTD_compressBound(srcSize);
-    void* dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem);
-    SeqCollector seqCollector;
-    {
-        int targetCBlockSize;
-        FORWARD_IF_ERROR(ZSTD_CCtx_getParameter(zc, ZSTD_c_targetCBlockSize, &targetCBlockSize), "");
-        RETURN_ERROR_IF(targetCBlockSize != 0, parameter_unsupported, "targetCBlockSize != 0");
-    }
-    {
-        int nbWorkers;
-        FORWARD_IF_ERROR(ZSTD_CCtx_getParameter(zc, ZSTD_c_nbWorkers, &nbWorkers), "");
-        RETURN_ERROR_IF(nbWorkers != 0, parameter_unsupported, "nbWorkers != 0");
-    }
-
-    RETURN_ERROR_IF(dst == NULL, memory_allocation, "NULL pointer!");
-
-    seqCollector.collectSequences = 1;
-    seqCollector.seqStart = outSeqs;
-    seqCollector.seqIndex = 0;
-    seqCollector.maxSequences = outSeqsSize;
-    zc->seqCollector = seqCollector;
-
-    {
-        const size_t ret = ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);
-        ZSTD_customFree(dst, ZSTD_defaultCMem);
-        FORWARD_IF_ERROR(ret, "ZSTD_compress2 failed");
-    }
-    assert(zc->seqCollector.seqIndex <= ZSTD_sequenceBound(srcSize));
-    return zc->seqCollector.seqIndex;
-}
-
-size_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, size_t seqsSize) {
-    size_t in = 0;
-    size_t out = 0;
-    for (; in < seqsSize; ++in) {
-        if (sequences[in].offset == 0 && sequences[in].matchLength == 0) {
-            if (in != seqsSize - 1) {
-                sequences[in+1].litLength += sequences[in].litLength;
-            }
-        } else {
-            sequences[out] = sequences[in];
-            ++out;
-        }
-    }
-    return out;
-}
-
-/* Unrolled loop to read four size_ts of input at a time. Returns 1 if is RLE, 0 if not. */
-static int ZSTD_isRLE(const BYTE* src, size_t length) {
-    const BYTE* ip = src;
-    const BYTE value = ip[0];
-    const size_t valueST = (size_t)((U64)value * 0x0101010101010101ULL);
-    const size_t unrollSize = sizeof(size_t) * 4;
-    const size_t unrollMask = unrollSize - 1;
-    const size_t prefixLength = length & unrollMask;
-    size_t i;
-    if (length == 1) return 1;
-    /* Check if prefix is RLE first before using unrolled loop */
-    if (prefixLength && ZSTD_count(ip+1, ip, ip+prefixLength) != prefixLength-1) {
-        return 0;
-    }
-    for (i = prefixLength; i != length; i += unrollSize) {
-        size_t u;
-        for (u = 0; u < unrollSize; u += sizeof(size_t)) {
-            if (MEM_readST(ip + i + u) != valueST) {
-                return 0;
-    }   }   }
-    return 1;
-}
-
-/* Returns true if the given block may be RLE.
- * This is just a heuristic based on the compressibility.
- * It may return both false positives and false negatives.
- */
-static int ZSTD_maybeRLE(seqStore_t const* seqStore)
-{
-    size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);
-    size_t const nbLits = (size_t)(seqStore->lit - seqStore->litStart);
-
-    return nbSeqs < 4 && nbLits < 10;
-}
-
-static void
-ZSTD_blockState_confirmRepcodesAndEntropyTables(ZSTD_blockState_t* const bs)
-{
-    ZSTD_compressedBlockState_t* const tmp = bs->prevCBlock;
-    bs->prevCBlock = bs->nextCBlock;
-    bs->nextCBlock = tmp;
-}
-
-/* Writes the block header */
-static void
-writeBlockHeader(void* op, size_t cSize, size_t blockSize, U32 lastBlock)
-{
-    U32 const cBlockHeader = cSize == 1 ?
-                        lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :
-                        lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
-    MEM_writeLE24(op, cBlockHeader);
-    DEBUGLOG(3, "writeBlockHeader: cSize: %zu blockSize: %zu lastBlock: %u", cSize, blockSize, lastBlock);
-}
-
-/** ZSTD_buildBlockEntropyStats_literals() :
- *  Builds entropy for the literals.
- *  Stores literals block type (raw, rle, compressed, repeat) and
- *  huffman description table to hufMetadata.
- *  Requires ENTROPY_WORKSPACE_SIZE workspace
- * @return : size of huffman description table, or an error code
- */
-static size_t
-ZSTD_buildBlockEntropyStats_literals(void* const src, size_t srcSize,
-                               const ZSTD_hufCTables_t* prevHuf,
-                                     ZSTD_hufCTables_t* nextHuf,
-                                     ZSTD_hufCTablesMetadata_t* hufMetadata,
-                               const int literalsCompressionIsDisabled,
-                                     void* workspace, size_t wkspSize,
-                                     int hufFlags)
-{
-    BYTE* const wkspStart = (BYTE*)workspace;
-    BYTE* const wkspEnd = wkspStart + wkspSize;
-    BYTE* const countWkspStart = wkspStart;
-    unsigned* const countWksp = (unsigned*)workspace;
-    const size_t countWkspSize = (HUF_SYMBOLVALUE_MAX + 1) * sizeof(unsigned);
-    BYTE* const nodeWksp = countWkspStart + countWkspSize;
-    const size_t nodeWkspSize = (size_t)(wkspEnd - nodeWksp);
-    unsigned maxSymbolValue = HUF_SYMBOLVALUE_MAX;
-    unsigned huffLog = LitHufLog;
-    HUF_repeat repeat = prevHuf->repeatMode;
-    DEBUGLOG(5, "ZSTD_buildBlockEntropyStats_literals (srcSize=%zu)", srcSize);
-
-    /* Prepare nextEntropy assuming reusing the existing table */
-    ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-
-    if (literalsCompressionIsDisabled) {
-        DEBUGLOG(5, "set_basic - disabled");
-        hufMetadata->hType = set_basic;
-        return 0;
-    }
-
-    /* small ? don't even attempt compression (speed opt) */
-#ifndef COMPRESS_LITERALS_SIZE_MIN
-# define COMPRESS_LITERALS_SIZE_MIN 63  /* heuristic */
-#endif
-    {   size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
-        if (srcSize <= minLitSize) {
-            DEBUGLOG(5, "set_basic - too small");
-            hufMetadata->hType = set_basic;
-            return 0;
-    }   }
-
-    /* Scan input and build symbol stats */
-    {   size_t const largest =
-            HIST_count_wksp (countWksp, &maxSymbolValue,
-                            (const BYTE*)src, srcSize,
-                            workspace, wkspSize);
-        FORWARD_IF_ERROR(largest, "HIST_count_wksp failed");
-        if (largest == srcSize) {
-            /* only one literal symbol */
-            DEBUGLOG(5, "set_rle");
-            hufMetadata->hType = set_rle;
-            return 0;
-        }
-        if (largest <= (srcSize >> 7)+4) {
-            /* heuristic: likely not compressible */
-            DEBUGLOG(5, "set_basic - no gain");
-            hufMetadata->hType = set_basic;
-            return 0;
-    }   }
-
-    /* Validate the previous Huffman table */
-    if (repeat == HUF_repeat_check
-      && !HUF_validateCTable((HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue)) {
-        repeat = HUF_repeat_none;
-    }
-
-    /* Build Huffman Tree */
-    ZSTD_memset(nextHuf->CTable, 0, sizeof(nextHuf->CTable));
-    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue, nodeWksp, nodeWkspSize, nextHuf->CTable, countWksp, hufFlags);
-    assert(huffLog <= LitHufLog);
-    {   size_t const maxBits = HUF_buildCTable_wksp((HUF_CElt*)nextHuf->CTable, countWksp,
-                                                    maxSymbolValue, huffLog,
-                                                    nodeWksp, nodeWkspSize);
-        FORWARD_IF_ERROR(maxBits, "HUF_buildCTable_wksp");
-        huffLog = (U32)maxBits;
-    }
-    {   /* Build and write the CTable */
-        size_t const newCSize = HUF_estimateCompressedSize(
-                (HUF_CElt*)nextHuf->CTable, countWksp, maxSymbolValue);
-        size_t const hSize = HUF_writeCTable_wksp(
-                hufMetadata->hufDesBuffer, sizeof(hufMetadata->hufDesBuffer),
-                (HUF_CElt*)nextHuf->CTable, maxSymbolValue, huffLog,
-                nodeWksp, nodeWkspSize);
-        /* Check against repeating the previous CTable */
-        if (repeat != HUF_repeat_none) {
-            size_t const oldCSize = HUF_estimateCompressedSize(
-                    (HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue);
-            if (oldCSize < srcSize && (oldCSize <= hSize + newCSize || hSize + 12 >= srcSize)) {
-                DEBUGLOG(5, "set_repeat - smaller");
-                ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-                hufMetadata->hType = set_repeat;
-                return 0;
-        }   }
-        if (newCSize + hSize >= srcSize) {
-            DEBUGLOG(5, "set_basic - no gains");
-            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-            hufMetadata->hType = set_basic;
-            return 0;
-        }
-        DEBUGLOG(5, "set_compressed (hSize=%u)", (U32)hSize);
-        hufMetadata->hType = set_compressed;
-        nextHuf->repeatMode = HUF_repeat_check;
-        return hSize;
-    }
-}
-
-
-/* ZSTD_buildDummySequencesStatistics():
- * Returns a ZSTD_symbolEncodingTypeStats_t with all encoding types as set_basic,
- * and updates nextEntropy to the appropriate repeatMode.
- */
-static ZSTD_symbolEncodingTypeStats_t
-ZSTD_buildDummySequencesStatistics(ZSTD_fseCTables_t* nextEntropy)
-{
-    ZSTD_symbolEncodingTypeStats_t stats = {set_basic, set_basic, set_basic, 0, 0, 0};
-    nextEntropy->litlength_repeatMode = FSE_repeat_none;
-    nextEntropy->offcode_repeatMode = FSE_repeat_none;
-    nextEntropy->matchlength_repeatMode = FSE_repeat_none;
-    return stats;
-}
-
-/** ZSTD_buildBlockEntropyStats_sequences() :
- *  Builds entropy for the sequences.
- *  Stores symbol compression modes and fse table to fseMetadata.
- *  Requires ENTROPY_WORKSPACE_SIZE wksp.
- * @return : size of fse tables or error code */
-static size_t
-ZSTD_buildBlockEntropyStats_sequences(
-                const seqStore_t* seqStorePtr,
-                const ZSTD_fseCTables_t* prevEntropy,
-                      ZSTD_fseCTables_t* nextEntropy,
-                const ZSTD_CCtx_params* cctxParams,
-                      ZSTD_fseCTablesMetadata_t* fseMetadata,
-                      void* workspace, size_t wkspSize)
-{
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
-    size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    BYTE* const ostart = fseMetadata->fseTablesBuffer;
-    BYTE* const oend = ostart + sizeof(fseMetadata->fseTablesBuffer);
-    BYTE* op = ostart;
-    unsigned* countWorkspace = (unsigned*)workspace;
-    unsigned* entropyWorkspace = countWorkspace + (MaxSeq + 1);
-    size_t entropyWorkspaceSize = wkspSize - (MaxSeq + 1) * sizeof(*countWorkspace);
-    ZSTD_symbolEncodingTypeStats_t stats;
-
-    DEBUGLOG(5, "ZSTD_buildBlockEntropyStats_sequences (nbSeq=%zu)", nbSeq);
-    stats = nbSeq != 0 ? ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,
-                                          prevEntropy, nextEntropy, op, oend,
-                                          strategy, countWorkspace,
-                                          entropyWorkspace, entropyWorkspaceSize)
-                       : ZSTD_buildDummySequencesStatistics(nextEntropy);
-    FORWARD_IF_ERROR(stats.size, "ZSTD_buildSequencesStatistics failed!");
-    fseMetadata->llType = (symbolEncodingType_e) stats.LLtype;
-    fseMetadata->ofType = (symbolEncodingType_e) stats.Offtype;
-    fseMetadata->mlType = (symbolEncodingType_e) stats.MLtype;
-    fseMetadata->lastCountSize = stats.lastCountSize;
-    return stats.size;
-}
-
-
-/** ZSTD_buildBlockEntropyStats() :
- *  Builds entropy for the block.
- *  Requires workspace size ENTROPY_WORKSPACE_SIZE
- * @return : 0 on success, or an error code
- *  Note : also employed in superblock
- */
-size_t ZSTD_buildBlockEntropyStats(
-            const seqStore_t* seqStorePtr,
-            const ZSTD_entropyCTables_t* prevEntropy,
-                  ZSTD_entropyCTables_t* nextEntropy,
-            const ZSTD_CCtx_params* cctxParams,
-                  ZSTD_entropyCTablesMetadata_t* entropyMetadata,
-                  void* workspace, size_t wkspSize)
-{
-    size_t const litSize = (size_t)(seqStorePtr->lit - seqStorePtr->litStart);
-    int const huf_useOptDepth = (cctxParams->cParams.strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD);
-    int const hufFlags = huf_useOptDepth ? HUF_flags_optimalDepth : 0;
-
-    entropyMetadata->hufMetadata.hufDesSize =
-        ZSTD_buildBlockEntropyStats_literals(seqStorePtr->litStart, litSize,
-                                            &prevEntropy->huf, &nextEntropy->huf,
-                                            &entropyMetadata->hufMetadata,
-                                            ZSTD_literalsCompressionIsDisabled(cctxParams),
-                                            workspace, wkspSize, hufFlags);
-
-    FORWARD_IF_ERROR(entropyMetadata->hufMetadata.hufDesSize, "ZSTD_buildBlockEntropyStats_literals failed");
-    entropyMetadata->fseMetadata.fseTablesSize =
-        ZSTD_buildBlockEntropyStats_sequences(seqStorePtr,
-                                              &prevEntropy->fse, &nextEntropy->fse,
-                                              cctxParams,
-                                              &entropyMetadata->fseMetadata,
-                                              workspace, wkspSize);
-    FORWARD_IF_ERROR(entropyMetadata->fseMetadata.fseTablesSize, "ZSTD_buildBlockEntropyStats_sequences failed");
-    return 0;
-}
-
-/* Returns the size estimate for the literals section (header + content) of a block */
-static size_t
-ZSTD_estimateBlockSize_literal(const BYTE* literals, size_t litSize,
-                               const ZSTD_hufCTables_t* huf,
-                               const ZSTD_hufCTablesMetadata_t* hufMetadata,
-                               void* workspace, size_t wkspSize,
-                               int writeEntropy)
-{
-    unsigned* const countWksp = (unsigned*)workspace;
-    unsigned maxSymbolValue = HUF_SYMBOLVALUE_MAX;
-    size_t literalSectionHeaderSize = 3 + (litSize >= 1 KB) + (litSize >= 16 KB);
-    U32 singleStream = litSize < 256;
-
-    if (hufMetadata->hType == set_basic) return litSize;
-    else if (hufMetadata->hType == set_rle) return 1;
-    else if (hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat) {
-        size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);
-        if (ZSTD_isError(largest)) return litSize;
-        {   size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);
-            if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;
-            if (!singleStream) cLitSizeEstimate += 6; /* multi-stream huffman uses 6-byte jump table */
-            return cLitSizeEstimate + literalSectionHeaderSize;
-    }   }
-    assert(0); /* impossible */
-    return 0;
-}
-
-/* Returns the size estimate for the FSE-compressed symbols (of, ml, ll) of a block */
-static size_t
-ZSTD_estimateBlockSize_symbolType(symbolEncodingType_e type,
-                    const BYTE* codeTable, size_t nbSeq, unsigned maxCode,
-                    const FSE_CTable* fseCTable,
-                    const U8* additionalBits,
-                    short const* defaultNorm, U32 defaultNormLog, U32 defaultMax,
-                    void* workspace, size_t wkspSize)
-{
-    unsigned* const countWksp = (unsigned*)workspace;
-    const BYTE* ctp = codeTable;
-    const BYTE* const ctStart = ctp;
-    const BYTE* const ctEnd = ctStart + nbSeq;
-    size_t cSymbolTypeSizeEstimateInBits = 0;
-    unsigned max = maxCode;
-
-    HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize);  /* can't fail */
-    if (type == set_basic) {
-        /* We selected this encoding type, so it must be valid. */
-        assert(max <= defaultMax);
-        (void)defaultMax;
-        cSymbolTypeSizeEstimateInBits = ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max);
-    } else if (type == set_rle) {
-        cSymbolTypeSizeEstimateInBits = 0;
-    } else if (type == set_compressed || type == set_repeat) {
-        cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);
-    }
-    if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) {
-        return nbSeq * 10;
-    }
-    while (ctp < ctEnd) {
-        if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];
-        else cSymbolTypeSizeEstimateInBits += *ctp; /* for offset, offset code is also the number of additional bits */
-        ctp++;
-    }
-    return cSymbolTypeSizeEstimateInBits >> 3;
-}
-
-/* Returns the size estimate for the sequences section (header + content) of a block */
-static size_t
-ZSTD_estimateBlockSize_sequences(const BYTE* ofCodeTable,
-                                 const BYTE* llCodeTable,
-                                 const BYTE* mlCodeTable,
-                                 size_t nbSeq,
-                                 const ZSTD_fseCTables_t* fseTables,
-                                 const ZSTD_fseCTablesMetadata_t* fseMetadata,
-                                 void* workspace, size_t wkspSize,
-                                 int writeEntropy)
-{
-    size_t sequencesSectionHeaderSize = 1 /* seqHead */ + 1 /* min seqSize size */ + (nbSeq >= 128) + (nbSeq >= LONGNBSEQ);
-    size_t cSeqSizeEstimate = 0;
-    cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, nbSeq, MaxOff,
-                                    fseTables->offcodeCTable, NULL,
-                                    OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
-                                    workspace, wkspSize);
-    cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType(fseMetadata->llType, llCodeTable, nbSeq, MaxLL,
-                                    fseTables->litlengthCTable, LL_bits,
-                                    LL_defaultNorm, LL_defaultNormLog, MaxLL,
-                                    workspace, wkspSize);
-    cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, nbSeq, MaxML,
-                                    fseTables->matchlengthCTable, ML_bits,
-                                    ML_defaultNorm, ML_defaultNormLog, MaxML,
-                                    workspace, wkspSize);
-    if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;
-    return cSeqSizeEstimate + sequencesSectionHeaderSize;
-}
-
-/* Returns the size estimate for a given stream of literals, of, ll, ml */
-static size_t
-ZSTD_estimateBlockSize(const BYTE* literals, size_t litSize,
-                       const BYTE* ofCodeTable,
-                       const BYTE* llCodeTable,
-                       const BYTE* mlCodeTable,
-                       size_t nbSeq,
-                       const ZSTD_entropyCTables_t* entropy,
-                       const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
-                       void* workspace, size_t wkspSize,
-                       int writeLitEntropy, int writeSeqEntropy)
-{
-    size_t const literalsSize = ZSTD_estimateBlockSize_literal(literals, litSize,
-                                    &entropy->huf, &entropyMetadata->hufMetadata,
-                                    workspace, wkspSize, writeLitEntropy);
-    size_t const seqSize = ZSTD_estimateBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,
-                                    nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,
-                                    workspace, wkspSize, writeSeqEntropy);
-    return seqSize + literalsSize + ZSTD_blockHeaderSize;
-}
-
-/* Builds entropy statistics and uses them for blocksize estimation.
- *
- * @return: estimated compressed size of the seqStore, or a zstd error.
- */
-static size_t
-ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(seqStore_t* seqStore, ZSTD_CCtx* zc)
-{
-    ZSTD_entropyCTablesMetadata_t* const entropyMetadata = &zc->blockSplitCtx.entropyMetadata;
-    DEBUGLOG(6, "ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize()");
-    FORWARD_IF_ERROR(ZSTD_buildBlockEntropyStats(seqStore,
-                    &zc->blockState.prevCBlock->entropy,
-                    &zc->blockState.nextCBlock->entropy,
-                    &zc->appliedParams,
-                    entropyMetadata,
-                    zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE), "");
-    return ZSTD_estimateBlockSize(
-                    seqStore->litStart, (size_t)(seqStore->lit - seqStore->litStart),
-                    seqStore->ofCode, seqStore->llCode, seqStore->mlCode,
-                    (size_t)(seqStore->sequences - seqStore->sequencesStart),
-                    &zc->blockState.nextCBlock->entropy,
-                    entropyMetadata,
-                    zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE,
-                    (int)(entropyMetadata->hufMetadata.hType == set_compressed), 1);
-}
-
-/* Returns literals bytes represented in a seqStore */
-static size_t ZSTD_countSeqStoreLiteralsBytes(const seqStore_t* const seqStore)
-{
-    size_t literalsBytes = 0;
-    size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);
-    size_t i;
-    for (i = 0; i < nbSeqs; ++i) {
-        seqDef const seq = seqStore->sequencesStart[i];
-        literalsBytes += seq.litLength;
-        if (i == seqStore->longLengthPos && seqStore->longLengthType == ZSTD_llt_literalLength) {
-            literalsBytes += 0x10000;
-    }   }
-    return literalsBytes;
-}
-
-/* Returns match bytes represented in a seqStore */
-static size_t ZSTD_countSeqStoreMatchBytes(const seqStore_t* const seqStore)
-{
-    size_t matchBytes = 0;
-    size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);
-    size_t i;
-    for (i = 0; i < nbSeqs; ++i) {
-        seqDef seq = seqStore->sequencesStart[i];
-        matchBytes += seq.mlBase + MINMATCH;
-        if (i == seqStore->longLengthPos && seqStore->longLengthType == ZSTD_llt_matchLength) {
-            matchBytes += 0x10000;
-    }   }
-    return matchBytes;
-}
-
-/* Derives the seqStore that is a chunk of the originalSeqStore from [startIdx, endIdx).
- * Stores the result in resultSeqStore.
- */
-static void ZSTD_deriveSeqStoreChunk(seqStore_t* resultSeqStore,
-                               const seqStore_t* originalSeqStore,
-                                     size_t startIdx, size_t endIdx)
-{
-    *resultSeqStore = *originalSeqStore;
-    if (startIdx > 0) {
-        resultSeqStore->sequences = originalSeqStore->sequencesStart + startIdx;
-        resultSeqStore->litStart += ZSTD_countSeqStoreLiteralsBytes(resultSeqStore);
-    }
-
-    /* Move longLengthPos into the correct position if necessary */
-    if (originalSeqStore->longLengthType != ZSTD_llt_none) {
-        if (originalSeqStore->longLengthPos < startIdx || originalSeqStore->longLengthPos > endIdx) {
-            resultSeqStore->longLengthType = ZSTD_llt_none;
-        } else {
-            resultSeqStore->longLengthPos -= (U32)startIdx;
-        }
-    }
-    resultSeqStore->sequencesStart = originalSeqStore->sequencesStart + startIdx;
-    resultSeqStore->sequences = originalSeqStore->sequencesStart + endIdx;
-    if (endIdx == (size_t)(originalSeqStore->sequences - originalSeqStore->sequencesStart)) {
-        /* This accounts for possible last literals if the derived chunk reaches the end of the block */
-        assert(resultSeqStore->lit == originalSeqStore->lit);
-    } else {
-        size_t const literalsBytes = ZSTD_countSeqStoreLiteralsBytes(resultSeqStore);
-        resultSeqStore->lit = resultSeqStore->litStart + literalsBytes;
-    }
-    resultSeqStore->llCode += startIdx;
-    resultSeqStore->mlCode += startIdx;
-    resultSeqStore->ofCode += startIdx;
-}
-
-/**
- * Returns the raw offset represented by the combination of offBase, ll0, and repcode history.
- * offBase must represent a repcode in the numeric representation of ZSTD_storeSeq().
- */
-static U32
-ZSTD_resolveRepcodeToRawOffset(const U32 rep[ZSTD_REP_NUM], const U32 offBase, const U32 ll0)
-{
-    U32 const adjustedRepCode = OFFBASE_TO_REPCODE(offBase) - 1 + ll0;  /* [ 0 - 3 ] */
-    assert(OFFBASE_IS_REPCODE(offBase));
-    if (adjustedRepCode == ZSTD_REP_NUM) {
-        assert(ll0);
-        /* litlength == 0 and offCode == 2 implies selection of first repcode - 1
-         * This is only valid if it results in a valid offset value, aka > 0.
-         * Note : it may happen that `rep[0]==1` in exceptional circumstances.
-         * In which case this function will return 0, which is an invalid offset.
-         * It's not an issue though, since this value will be
-         * compared and discarded within ZSTD_seqStore_resolveOffCodes().
-         */
-        return rep[0] - 1;
-    }
-    return rep[adjustedRepCode];
-}
-
-/**
- * ZSTD_seqStore_resolveOffCodes() reconciles any possible divergences in offset history that may arise
- * due to emission of RLE/raw blocks that disturb the offset history,
- * and replaces any repcodes within the seqStore that may be invalid.
- *
- * dRepcodes are updated as would be on the decompression side.
- * cRepcodes are updated exactly in accordance with the seqStore.
- *
- * Note : this function assumes seq->offBase respects the following numbering scheme :
- *        0 : invalid
- *        1-3 : repcode 1-3
- *        4+ : real_offset+3
- */
-static void
-ZSTD_seqStore_resolveOffCodes(repcodes_t* const dRepcodes, repcodes_t* const cRepcodes,
-                        const seqStore_t* const seqStore, U32 const nbSeq)
-{
-    U32 idx = 0;
-    U32 const longLitLenIdx = seqStore->longLengthType == ZSTD_llt_literalLength ? seqStore->longLengthPos : nbSeq;
-    for (; idx < nbSeq; ++idx) {
-        seqDef* const seq = seqStore->sequencesStart + idx;
-        U32 const ll0 = (seq->litLength == 0) && (idx != longLitLenIdx);
-        U32 const offBase = seq->offBase;
-        assert(offBase > 0);
-        if (OFFBASE_IS_REPCODE(offBase)) {
-            U32 const dRawOffset = ZSTD_resolveRepcodeToRawOffset(dRepcodes->rep, offBase, ll0);
-            U32 const cRawOffset = ZSTD_resolveRepcodeToRawOffset(cRepcodes->rep, offBase, ll0);
-            /* Adjust simulated decompression repcode history if we come across a mismatch. Replace
-             * the repcode with the offset it actually references, determined by the compression
-             * repcode history.
-             */
-            if (dRawOffset != cRawOffset) {
-                seq->offBase = OFFSET_TO_OFFBASE(cRawOffset);
-            }
-        }
-        /* Compression repcode history is always updated with values directly from the unmodified seqStore.
-         * Decompression repcode history may use modified seq->offset value taken from compression repcode history.
-         */
-        ZSTD_updateRep(dRepcodes->rep, seq->offBase, ll0);
-        ZSTD_updateRep(cRepcodes->rep, offBase, ll0);
-    }
-}
-
-/* ZSTD_compressSeqStore_singleBlock():
- * Compresses a seqStore into a block with a block header, into the buffer dst.
- *
- * Returns the total size of that block (including header) or a ZSTD error code.
- */
-static size_t
-ZSTD_compressSeqStore_singleBlock(ZSTD_CCtx* zc,
-                            const seqStore_t* const seqStore,
-                                  repcodes_t* const dRep, repcodes_t* const cRep,
-                                  void* dst, size_t dstCapacity,
-                            const void* src, size_t srcSize,
-                                  U32 lastBlock, U32 isPartition)
-{
-    const U32 rleMaxLength = 25;
-    BYTE* op = (BYTE*)dst;
-    const BYTE* ip = (const BYTE*)src;
-    size_t cSize;
-    size_t cSeqsSize;
-
-    /* In case of an RLE or raw block, the simulated decompression repcode history must be reset */
-    repcodes_t const dRepOriginal = *dRep;
-    DEBUGLOG(5, "ZSTD_compressSeqStore_singleBlock");
-    if (isPartition)
-        ZSTD_seqStore_resolveOffCodes(dRep, cRep, seqStore, (U32)(seqStore->sequences - seqStore->sequencesStart));
-
-    RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall, "Block header doesn't fit");
-    cSeqsSize = ZSTD_entropyCompressSeqStore(seqStore,
-                &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
-                &zc->appliedParams,
-                op + ZSTD_blockHeaderSize, dstCapacity - ZSTD_blockHeaderSize,
-                srcSize,
-                zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
-                zc->bmi2);
-    FORWARD_IF_ERROR(cSeqsSize, "ZSTD_entropyCompressSeqStore failed!");
-
-    if (!zc->isFirstBlock &&
-        cSeqsSize < rleMaxLength &&
-        ZSTD_isRLE((BYTE const*)src, srcSize)) {
-        /* We don't want to emit our first block as a RLE even if it qualifies because
-        * doing so will cause the decoder (cli only) to throw a "should consume all input error."
-        * This is only an issue for zstd <= v1.4.3
-        */
-        cSeqsSize = 1;
-    }
-
-    /* Sequence collection not supported when block splitting */
-    if (zc->seqCollector.collectSequences) {
-        FORWARD_IF_ERROR(ZSTD_copyBlockSequences(&zc->seqCollector, seqStore, dRepOriginal.rep), "copyBlockSequences failed");
-        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
-        return 0;
-    }
-
-    if (cSeqsSize == 0) {
-        cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, srcSize, lastBlock);
-        FORWARD_IF_ERROR(cSize, "Nocompress block failed");
-        DEBUGLOG(4, "Writing out nocompress block, size: %zu", cSize);
-        *dRep = dRepOriginal; /* reset simulated decompression repcode history */
-    } else if (cSeqsSize == 1) {
-        cSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, srcSize, lastBlock);
-        FORWARD_IF_ERROR(cSize, "RLE compress block failed");
-        DEBUGLOG(4, "Writing out RLE block, size: %zu", cSize);
-        *dRep = dRepOriginal; /* reset simulated decompression repcode history */
-    } else {
-        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
-        writeBlockHeader(op, cSeqsSize, srcSize, lastBlock);
-        cSize = ZSTD_blockHeaderSize + cSeqsSize;
-        DEBUGLOG(4, "Writing out compressed block, size: %zu", cSize);
-    }
-
-    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
-        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
-
-    return cSize;
-}
-
-/* Struct to keep track of where we are in our recursive calls. */
-typedef struct {
-    U32* splitLocations;    /* Array of split indices */
-    size_t idx;             /* The current index within splitLocations being worked on */
-} seqStoreSplits;
-
-#define MIN_SEQUENCES_BLOCK_SPLITTING 300
-
-/* Helper function to perform the recursive search for block splits.
- * Estimates the cost of seqStore prior to split, and estimates the cost of splitting the sequences in half.
- * If advantageous to split, then we recurse down the two sub-blocks.
- * If not, or if an error occurred in estimation, then we do not recurse.
- *
- * Note: The recursion depth is capped by a heuristic minimum number of sequences,
- * defined by MIN_SEQUENCES_BLOCK_SPLITTING.
- * In theory, this means the absolute largest recursion depth is 10 == log2(maxNbSeqInBlock/MIN_SEQUENCES_BLOCK_SPLITTING).
- * In practice, recursion depth usually doesn't go beyond 4.
- *
- * Furthermore, the number of splits is capped by ZSTD_MAX_NB_BLOCK_SPLITS.
- * At ZSTD_MAX_NB_BLOCK_SPLITS == 196 with the current existing blockSize
- * maximum of 128 KB, this value is actually impossible to reach.
- */
-static void
-ZSTD_deriveBlockSplitsHelper(seqStoreSplits* splits, size_t startIdx, size_t endIdx,
-                             ZSTD_CCtx* zc, const seqStore_t* origSeqStore)
-{
-    seqStore_t* const fullSeqStoreChunk = &zc->blockSplitCtx.fullSeqStoreChunk;
-    seqStore_t* const firstHalfSeqStore = &zc->blockSplitCtx.firstHalfSeqStore;
-    seqStore_t* const secondHalfSeqStore = &zc->blockSplitCtx.secondHalfSeqStore;
-    size_t estimatedOriginalSize;
-    size_t estimatedFirstHalfSize;
-    size_t estimatedSecondHalfSize;
-    size_t midIdx = (startIdx + endIdx)/2;
-
-    DEBUGLOG(5, "ZSTD_deriveBlockSplitsHelper: startIdx=%zu endIdx=%zu", startIdx, endIdx);
-    assert(endIdx >= startIdx);
-    if (endIdx - startIdx < MIN_SEQUENCES_BLOCK_SPLITTING || splits->idx >= ZSTD_MAX_NB_BLOCK_SPLITS) {
-        DEBUGLOG(6, "ZSTD_deriveBlockSplitsHelper: Too few sequences (%zu)", endIdx - startIdx);
-        return;
-    }
-    ZSTD_deriveSeqStoreChunk(fullSeqStoreChunk, origSeqStore, startIdx, endIdx);
-    ZSTD_deriveSeqStoreChunk(firstHalfSeqStore, origSeqStore, startIdx, midIdx);
-    ZSTD_deriveSeqStoreChunk(secondHalfSeqStore, origSeqStore, midIdx, endIdx);
-    estimatedOriginalSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(fullSeqStoreChunk, zc);
-    estimatedFirstHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(firstHalfSeqStore, zc);
-    estimatedSecondHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(secondHalfSeqStore, zc);
-    DEBUGLOG(5, "Estimated original block size: %zu -- First half split: %zu -- Second half split: %zu",
-             estimatedOriginalSize, estimatedFirstHalfSize, estimatedSecondHalfSize);
-    if (ZSTD_isError(estimatedOriginalSize) || ZSTD_isError(estimatedFirstHalfSize) || ZSTD_isError(estimatedSecondHalfSize)) {
-        return;
-    }
-    if (estimatedFirstHalfSize + estimatedSecondHalfSize < estimatedOriginalSize) {
-        DEBUGLOG(5, "split decided at seqNb:%zu", midIdx);
-        ZSTD_deriveBlockSplitsHelper(splits, startIdx, midIdx, zc, origSeqStore);
-        splits->splitLocations[splits->idx] = (U32)midIdx;
-        splits->idx++;
-        ZSTD_deriveBlockSplitsHelper(splits, midIdx, endIdx, zc, origSeqStore);
-    }
-}
-
-/* Base recursive function.
- * Populates a table with intra-block partition indices that can improve compression ratio.
- *
- * @return: number of splits made (which equals the size of the partition table - 1).
- */
-static size_t ZSTD_deriveBlockSplits(ZSTD_CCtx* zc, U32 partitions[], U32 nbSeq)
-{
-    seqStoreSplits splits;
-    splits.splitLocations = partitions;
-    splits.idx = 0;
-    if (nbSeq <= 4) {
-        DEBUGLOG(5, "ZSTD_deriveBlockSplits: Too few sequences to split (%u <= 4)", nbSeq);
-        /* Refuse to try and split anything with less than 4 sequences */
-        return 0;
-    }
-    ZSTD_deriveBlockSplitsHelper(&splits, 0, nbSeq, zc, &zc->seqStore);
-    splits.splitLocations[splits.idx] = nbSeq;
-    DEBUGLOG(5, "ZSTD_deriveBlockSplits: final nb partitions: %zu", splits.idx+1);
-    return splits.idx;
-}
-
-/* ZSTD_compressBlock_splitBlock():
- * Attempts to split a given block into multiple blocks to improve compression ratio.
- *
- * Returns combined size of all blocks (which includes headers), or a ZSTD error code.
- */
-static size_t
-ZSTD_compressBlock_splitBlock_internal(ZSTD_CCtx* zc,
-                                    void* dst, size_t dstCapacity,
-                              const void* src, size_t blockSize,
-                                    U32 lastBlock, U32 nbSeq)
-{
-    size_t cSize = 0;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    size_t i = 0;
-    size_t srcBytesTotal = 0;
-    U32* const partitions = zc->blockSplitCtx.partitions; /* size == ZSTD_MAX_NB_BLOCK_SPLITS */
-    seqStore_t* const nextSeqStore = &zc->blockSplitCtx.nextSeqStore;
-    seqStore_t* const currSeqStore = &zc->blockSplitCtx.currSeqStore;
-    size_t const numSplits = ZSTD_deriveBlockSplits(zc, partitions, nbSeq);
-
-    /* If a block is split and some partitions are emitted as RLE/uncompressed, then repcode history
-     * may become invalid. In order to reconcile potentially invalid repcodes, we keep track of two
-     * separate repcode histories that simulate repcode history on compression and decompression side,
-     * and use the histories to determine whether we must replace a particular repcode with its raw offset.
-     *
-     * 1) cRep gets updated for each partition, regardless of whether the block was emitted as uncompressed
-     *    or RLE. This allows us to retrieve the offset value that an invalid repcode references within
-     *    a nocompress/RLE block.
-     * 2) dRep gets updated only for compressed partitions, and when a repcode gets replaced, will use
-     *    the replacement offset value rather than the original repcode to update the repcode history.
-     *    dRep also will be the final repcode history sent to the next block.
-     *
-     * See ZSTD_seqStore_resolveOffCodes() for more details.
-     */
-    repcodes_t dRep;
-    repcodes_t cRep;
-    ZSTD_memcpy(dRep.rep, zc->blockState.prevCBlock->rep, sizeof(repcodes_t));
-    ZSTD_memcpy(cRep.rep, zc->blockState.prevCBlock->rep, sizeof(repcodes_t));
-    ZSTD_memset(nextSeqStore, 0, sizeof(seqStore_t));
-
-    DEBUGLOG(5, "ZSTD_compressBlock_splitBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
-                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
-                (unsigned)zc->blockState.matchState.nextToUpdate);
-
-    if (numSplits == 0) {
-        size_t cSizeSingleBlock =
-            ZSTD_compressSeqStore_singleBlock(zc, &zc->seqStore,
-                                            &dRep, &cRep,
-                                            op, dstCapacity,
-                                            ip, blockSize,
-                                            lastBlock, 0 /* isPartition */);
-        FORWARD_IF_ERROR(cSizeSingleBlock, "Compressing single block from splitBlock_internal() failed!");
-        DEBUGLOG(5, "ZSTD_compressBlock_splitBlock_internal: No splits");
-        assert(zc->blockSize <= ZSTD_BLOCKSIZE_MAX);
-        assert(cSizeSingleBlock <= zc->blockSize + ZSTD_blockHeaderSize);
-        return cSizeSingleBlock;
-    }
-
-    ZSTD_deriveSeqStoreChunk(currSeqStore, &zc->seqStore, 0, partitions[0]);
-    for (i = 0; i <= numSplits; ++i) {
-        size_t cSizeChunk;
-        U32 const lastPartition = (i == numSplits);
-        U32 lastBlockEntireSrc = 0;
-
-        size_t srcBytes = ZSTD_countSeqStoreLiteralsBytes(currSeqStore) + ZSTD_countSeqStoreMatchBytes(currSeqStore);
-        srcBytesTotal += srcBytes;
-        if (lastPartition) {
-            /* This is the final partition, need to account for possible last literals */
-            srcBytes += blockSize - srcBytesTotal;
-            lastBlockEntireSrc = lastBlock;
-        } else {
-            ZSTD_deriveSeqStoreChunk(nextSeqStore, &zc->seqStore, partitions[i], partitions[i+1]);
-        }
-
-        cSizeChunk = ZSTD_compressSeqStore_singleBlock(zc, currSeqStore,
-                                                      &dRep, &cRep,
-                                                       op, dstCapacity,
-                                                       ip, srcBytes,
-                                                       lastBlockEntireSrc, 1 /* isPartition */);
-        DEBUGLOG(5, "Estimated size: %zu vs %zu : actual size",
-                    ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(currSeqStore, zc), cSizeChunk);
-        FORWARD_IF_ERROR(cSizeChunk, "Compressing chunk failed!");
-
-        ip += srcBytes;
-        op += cSizeChunk;
-        dstCapacity -= cSizeChunk;
-        cSize += cSizeChunk;
-        *currSeqStore = *nextSeqStore;
-        assert(cSizeChunk <= zc->blockSize + ZSTD_blockHeaderSize);
-    }
-    /* cRep and dRep may have diverged during the compression.
-     * If so, we use the dRep repcodes for the next block.
-     */
-    ZSTD_memcpy(zc->blockState.prevCBlock->rep, dRep.rep, sizeof(repcodes_t));
-    return cSize;
-}
-
-static size_t
-ZSTD_compressBlock_splitBlock(ZSTD_CCtx* zc,
-                              void* dst, size_t dstCapacity,
-                              const void* src, size_t srcSize, U32 lastBlock)
-{
-    U32 nbSeq;
-    size_t cSize;
-    DEBUGLOG(4, "ZSTD_compressBlock_splitBlock");
-    assert(zc->appliedParams.useBlockSplitter == ZSTD_ps_enable);
-
-    {   const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
-        FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");
-        if (bss == ZSTDbss_noCompress) {
-            if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
-                zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
-            RETURN_ERROR_IF(zc->seqCollector.collectSequences, sequenceProducer_failed, "Uncompressible block");
-            cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);
-            FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
-            DEBUGLOG(4, "ZSTD_compressBlock_splitBlock: Nocompress block");
-            return cSize;
-        }
-        nbSeq = (U32)(zc->seqStore.sequences - zc->seqStore.sequencesStart);
-    }
-
-    cSize = ZSTD_compressBlock_splitBlock_internal(zc, dst, dstCapacity, src, srcSize, lastBlock, nbSeq);
-    FORWARD_IF_ERROR(cSize, "Splitting blocks failed!");
-    return cSize;
-}
-
-static size_t
-ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
-                            void* dst, size_t dstCapacity,
-                            const void* src, size_t srcSize, U32 frame)
-{
-    /* This is an estimated upper bound for the length of an rle block.
-     * This isn't the actual upper bound.
-     * Finding the real threshold needs further investigation.
-     */
-    const U32 rleMaxLength = 25;
-    size_t cSize;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
-                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
-                (unsigned)zc->blockState.matchState.nextToUpdate);
-
-    {   const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
-        FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");
-        if (bss == ZSTDbss_noCompress) {
-            RETURN_ERROR_IF(zc->seqCollector.collectSequences, sequenceProducer_failed, "Uncompressible block");
-            cSize = 0;
-            goto out;
-        }
-    }
-
-    if (zc->seqCollector.collectSequences) {
-        FORWARD_IF_ERROR(ZSTD_copyBlockSequences(&zc->seqCollector, ZSTD_getSeqStore(zc), zc->blockState.prevCBlock->rep), "copyBlockSequences failed");
-        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
-        return 0;
-    }
-
-    /* encode sequences and literals */
-    cSize = ZSTD_entropyCompressSeqStore(&zc->seqStore,
-            &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
-            &zc->appliedParams,
-            dst, dstCapacity,
-            srcSize,
-            zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
-            zc->bmi2);
-
-    if (frame &&
-        /* We don't want to emit our first block as a RLE even if it qualifies because
-         * doing so will cause the decoder (cli only) to throw a "should consume all input error."
-         * This is only an issue for zstd <= v1.4.3
-         */
-        !zc->isFirstBlock &&
-        cSize < rleMaxLength &&
-        ZSTD_isRLE(ip, srcSize))
-    {
-        cSize = 1;
-        op[0] = ip[0];
-    }
-
-out:
-    if (!ZSTD_isError(cSize) && cSize > 1) {
-        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
-    }
-    /* We check that dictionaries have offset codes available for the first
-     * block. After the first block, the offcode table might not have large
-     * enough codes to represent the offsets in the data.
-     */
-    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
-        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
-
-    return cSize;
-}
-
-static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,
-                               void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                               const size_t bss, U32 lastBlock)
-{
-    DEBUGLOG(6, "Attempting ZSTD_compressSuperBlock()");
-    if (bss == ZSTDbss_compress) {
-        if (/* We don't want to emit our first block as a RLE even if it qualifies because
-            * doing so will cause the decoder (cli only) to throw a "should consume all input error."
-            * This is only an issue for zstd <= v1.4.3
-            */
-            !zc->isFirstBlock &&
-            ZSTD_maybeRLE(&zc->seqStore) &&
-            ZSTD_isRLE((BYTE const*)src, srcSize))
-        {
-            return ZSTD_rleCompressBlock(dst, dstCapacity, *(BYTE const*)src, srcSize, lastBlock);
-        }
-        /* Attempt superblock compression.
-         *
-         * Note that compressed size of ZSTD_compressSuperBlock() is not bound by the
-         * standard ZSTD_compressBound(). This is a problem, because even if we have
-         * space now, taking an extra byte now could cause us to run out of space later
-         * and violate ZSTD_compressBound().
-         *
-         * Define blockBound(blockSize) = blockSize + ZSTD_blockHeaderSize.
-         *
-         * In order to respect ZSTD_compressBound() we must attempt to emit a raw
-         * uncompressed block in these cases:
-         *   * cSize == 0: Return code for an uncompressed block.
-         *   * cSize == dstSize_tooSmall: We may have expanded beyond blockBound(srcSize).
-         *     ZSTD_noCompressBlock() will return dstSize_tooSmall if we are really out of
-         *     output space.
-         *   * cSize >= blockBound(srcSize): We have expanded the block too much so
-         *     emit an uncompressed block.
-         */
-        {   size_t const cSize =
-                ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);
-            if (cSize != ERROR(dstSize_tooSmall)) {
-                size_t const maxCSize =
-                    srcSize - ZSTD_minGain(srcSize, zc->appliedParams.cParams.strategy);
-                FORWARD_IF_ERROR(cSize, "ZSTD_compressSuperBlock failed");
-                if (cSize != 0 && cSize < maxCSize + ZSTD_blockHeaderSize) {
-                    ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
-                    return cSize;
-                }
-            }
-        }
-    } /* if (bss == ZSTDbss_compress)*/
-
-    DEBUGLOG(6, "Resorting to ZSTD_noCompressBlock()");
-    /* Superblock compression failed, attempt to emit a single no compress block.
-     * The decoder will be able to stream this block since it is uncompressed.
-     */
-    return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);
-}
-
-static size_t ZSTD_compressBlock_targetCBlockSize(ZSTD_CCtx* zc,
-                               void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                               U32 lastBlock)
-{
-    size_t cSize = 0;
-    const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
-    DEBUGLOG(5, "ZSTD_compressBlock_targetCBlockSize (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u, srcSize=%zu)",
-                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit, (unsigned)zc->blockState.matchState.nextToUpdate, srcSize);
-    FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");
-
-    cSize = ZSTD_compressBlock_targetCBlockSize_body(zc, dst, dstCapacity, src, srcSize, bss, lastBlock);
-    FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_targetCBlockSize_body failed");
-
-    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
-        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
-
-    return cSize;
-}
-
-static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms,
-                                         ZSTD_cwksp* ws,
-                                         ZSTD_CCtx_params const* params,
-                                         void const* ip,
-                                         void const* iend)
-{
-    U32 const cycleLog = ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy);
-    U32 const maxDist = (U32)1 << params->cParams.windowLog;
-    if (ZSTD_window_needOverflowCorrection(ms->window, cycleLog, maxDist, ms->loadedDictEnd, ip, iend)) {
-        U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip);
-        ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);
-        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);
-        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
-        ZSTD_cwksp_mark_tables_dirty(ws);
-        ZSTD_reduceIndex(ms, params, correction);
-        ZSTD_cwksp_mark_tables_clean(ws);
-        if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
-        else ms->nextToUpdate -= correction;
-        /* invalidate dictionaries on overflow correction */
-        ms->loadedDictEnd = 0;
-        ms->dictMatchState = NULL;
-    }
-}
-
-/*! ZSTD_compress_frameChunk() :
-*   Compress a chunk of data into one or multiple blocks.
-*   All blocks will be terminated, all input will be consumed.
-*   Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.
-*   Frame is supposed already started (header already produced)
-*  @return : compressed size, or an error code
-*/
-static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
-                                     void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                                     U32 lastFrameChunk)
-{
-    size_t blockSize = cctx->blockSize;
-    size_t remaining = srcSize;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
-    U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
-
-    assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);
-
-    DEBUGLOG(4, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
-    if (cctx->appliedParams.fParams.checksumFlag && srcSize)
-        XXH64_update(&cctx->xxhState, src, srcSize);
-
-    while (remaining) {
-        ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
-        U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
-
-        /* TODO: See 3090. We reduced MIN_CBLOCK_SIZE from 3 to 2 so to compensate we are adding
-         * additional 1. We need to revisit and change this logic to be more consistent */
-        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE + 1,
-                        dstSize_tooSmall,
-                        "not enough space to store compressed block");
-        if (remaining < blockSize) blockSize = remaining;
-
-        ZSTD_overflowCorrectIfNeeded(
-            ms, &cctx->workspace, &cctx->appliedParams, ip, ip + blockSize);
-        ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
-        ZSTD_window_enforceMaxDist(&ms->window, ip, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
-
-        /* Ensure hash/chain table insertion resumes no sooner than lowlimit */
-        if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;
-
-        {   size_t cSize;
-            if (ZSTD_useTargetCBlockSize(&cctx->appliedParams)) {
-                cSize = ZSTD_compressBlock_targetCBlockSize(cctx, op, dstCapacity, ip, blockSize, lastBlock);
-                FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_targetCBlockSize failed");
-                assert(cSize > 0);
-                assert(cSize <= blockSize + ZSTD_blockHeaderSize);
-            } else if (ZSTD_blockSplitterEnabled(&cctx->appliedParams)) {
-                cSize = ZSTD_compressBlock_splitBlock(cctx, op, dstCapacity, ip, blockSize, lastBlock);
-                FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_splitBlock failed");
-                assert(cSize > 0 || cctx->seqCollector.collectSequences == 1);
-            } else {
-                cSize = ZSTD_compressBlock_internal(cctx,
-                                        op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
-                                        ip, blockSize, 1 /* frame */);
-                FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_internal failed");
-
-                if (cSize == 0) {  /* block is not compressible */
-                    cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
-                    FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
-                } else {
-                    U32 const cBlockHeader = cSize == 1 ?
-                        lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :
-                        lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
-                    MEM_writeLE24(op, cBlockHeader);
-                    cSize += ZSTD_blockHeaderSize;
-                }
-            }  /* if (ZSTD_useTargetCBlockSize(&cctx->appliedParams))*/
-
-
-            ip += blockSize;
-            assert(remaining >= blockSize);
-            remaining -= blockSize;
-            op += cSize;
-            assert(dstCapacity >= cSize);
-            dstCapacity -= cSize;
-            cctx->isFirstBlock = 0;
-            DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
-                        (unsigned)cSize);
-    }   }
-
-    if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
-    return (size_t)(op-ostart);
-}
-
-
-static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
-                                    const ZSTD_CCtx_params* params, U64 pledgedSrcSize, U32 dictID)
-{   BYTE* const op = (BYTE*)dst;
-    U32   const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536);   /* 0-3 */
-    U32   const dictIDSizeCode = params->fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength;   /* 0-3 */
-    U32   const checksumFlag = params->fParams.checksumFlag>0;
-    U32   const windowSize = (U32)1 << params->cParams.windowLog;
-    U32   const singleSegment = params->fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);
-    BYTE  const windowLogByte = (BYTE)((params->cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
-    U32   const fcsCode = params->fParams.contentSizeFlag ?
-                     (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0;  /* 0-3 */
-    BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
-    size_t pos=0;
-
-    assert(!(params->fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
-    RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall,
-                    "dst buf is too small to fit worst-case frame header size.");
-    DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u",
-                !params->fParams.noDictIDFlag, (unsigned)dictID, (unsigned)dictIDSizeCode);
-    if (params->format == ZSTD_f_zstd1) {
-        MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
-        pos = 4;
-    }
-    op[pos++] = frameHeaderDescriptionByte;
-    if (!singleSegment) op[pos++] = windowLogByte;
-    switch(dictIDSizeCode)
-    {
-        default:
-            assert(0); /* impossible */
-            ZSTD_FALLTHROUGH;
-        case 0 : break;
-        case 1 : op[pos] = (BYTE)(dictID); pos++; break;
-        case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break;
-        case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break;
-    }
-    switch(fcsCode)
-    {
-        default:
-            assert(0); /* impossible */
-            ZSTD_FALLTHROUGH;
-        case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break;
-        case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break;
-        case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break;
-        case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break;
-    }
-    return pos;
-}
-
-/* ZSTD_writeSkippableFrame_advanced() :
- * Writes out a skippable frame with the specified magic number variant (16 are supported),
- * from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15, and the desired source data.
- *
- * Returns the total number of bytes written, or a ZSTD error code.
- */
-size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,
-                                const void* src, size_t srcSize, unsigned magicVariant) {
-    BYTE* op = (BYTE*)dst;
-    RETURN_ERROR_IF(dstCapacity < srcSize + ZSTD_SKIPPABLEHEADERSIZE /* Skippable frame overhead */,
-                    dstSize_tooSmall, "Not enough room for skippable frame");
-    RETURN_ERROR_IF(srcSize > (unsigned)0xFFFFFFFF, srcSize_wrong, "Src size too large for skippable frame");
-    RETURN_ERROR_IF(magicVariant > 15, parameter_outOfBound, "Skippable frame magic number variant not supported");
-
-    MEM_writeLE32(op, (U32)(ZSTD_MAGIC_SKIPPABLE_START + magicVariant));
-    MEM_writeLE32(op+4, (U32)srcSize);
-    ZSTD_memcpy(op+8, src, srcSize);
-    return srcSize + ZSTD_SKIPPABLEHEADERSIZE;
-}
-
-/* ZSTD_writeLastEmptyBlock() :
- * output an empty Block with end-of-frame mark to complete a frame
- * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
- *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
- */
-size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
-{
-    RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall,
-                    "dst buf is too small to write frame trailer empty block.");
-    {   U32 const cBlockHeader24 = 1 /*lastBlock*/ + (((U32)bt_raw)<<1);  /* 0 size */
-        MEM_writeLE24(dst, cBlockHeader24);
-        return ZSTD_blockHeaderSize;
-    }
-}
-
-void ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq)
-{
-    assert(cctx->stage == ZSTDcs_init);
-    assert(nbSeq == 0 || cctx->appliedParams.ldmParams.enableLdm != ZSTD_ps_enable);
-    cctx->externSeqStore.seq = seq;
-    cctx->externSeqStore.size = nbSeq;
-    cctx->externSeqStore.capacity = nbSeq;
-    cctx->externSeqStore.pos = 0;
-    cctx->externSeqStore.posInSequence = 0;
-}
-
-
-static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize,
-                               U32 frame, U32 lastFrameChunk)
-{
-    ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
-    size_t fhSize = 0;
-
-    DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
-                cctx->stage, (unsigned)srcSize);
-    RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
-                    "missing init (ZSTD_compressBegin)");
-
-    if (frame && (cctx->stage==ZSTDcs_init)) {
-        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,
-                                       cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
-        FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
-        assert(fhSize <= dstCapacity);
-        dstCapacity -= fhSize;
-        dst = (char*)dst + fhSize;
-        cctx->stage = ZSTDcs_ongoing;
-    }
-
-    if (!srcSize) return fhSize;  /* do not generate an empty block if no input */
-
-    if (!ZSTD_window_update(&ms->window, src, srcSize, ms->forceNonContiguous)) {
-        ms->forceNonContiguous = 0;
-        ms->nextToUpdate = ms->window.dictLimit;
-    }
-    if (cctx->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {
-        ZSTD_window_update(&cctx->ldmState.window, src, srcSize, /* forceNonContiguous */ 0);
-    }
-
-    if (!frame) {
-        /* overflow check and correction for block mode */
-        ZSTD_overflowCorrectIfNeeded(
-            ms, &cctx->workspace, &cctx->appliedParams,
-            src, (BYTE const*)src + srcSize);
-    }
-
-    DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
-    {   size_t const cSize = frame ?
-                             ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
-                             ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);
-        FORWARD_IF_ERROR(cSize, "%s", frame ? "ZSTD_compress_frameChunk failed" : "ZSTD_compressBlock_internal failed");
-        cctx->consumedSrcSize += srcSize;
-        cctx->producedCSize += (cSize + fhSize);
-        assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
-        if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
-            ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
-            RETURN_ERROR_IF(
-                cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,
-                srcSize_wrong,
-                "error : pledgedSrcSize = %u, while realSrcSize >= %u",
-                (unsigned)cctx->pledgedSrcSizePlusOne-1,
-                (unsigned)cctx->consumedSrcSize);
-        }
-        return cSize + fhSize;
-    }
-}
-
-size_t ZSTD_compressContinue_public(ZSTD_CCtx* cctx,
-                                        void* dst, size_t dstCapacity,
-                                  const void* src, size_t srcSize)
-{
-    DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
-    return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
-}
-
-/* NOTE: Must just wrap ZSTD_compressContinue_public() */
-size_t ZSTD_compressContinue(ZSTD_CCtx* cctx,
-                             void* dst, size_t dstCapacity,
-                       const void* src, size_t srcSize)
-{
-    return ZSTD_compressContinue_public(cctx, dst, dstCapacity, src, srcSize);
-}
-
-static size_t ZSTD_getBlockSize_deprecated(const ZSTD_CCtx* cctx)
-{
-    ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
-    assert(!ZSTD_checkCParams(cParams));
-    return MIN(cctx->appliedParams.maxBlockSize, (size_t)1 << cParams.windowLog);
-}
-
-/* NOTE: Must just wrap ZSTD_getBlockSize_deprecated() */
-size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
-{
-    return ZSTD_getBlockSize_deprecated(cctx);
-}
-
-/* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */
-size_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
-    { size_t const blockSizeMax = ZSTD_getBlockSize_deprecated(cctx);
-      RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, "input is larger than a block"); }
-
-    return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
-}
-
-/* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */
-size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_deprecated(cctx, dst, dstCapacity, src, srcSize);
-}
-
-/*! ZSTD_loadDictionaryContent() :
- *  @return : 0, or an error code
- */
-static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
-                                         ldmState_t* ls,
-                                         ZSTD_cwksp* ws,
-                                         ZSTD_CCtx_params const* params,
-                                         const void* src, size_t srcSize,
-                                         ZSTD_dictTableLoadMethod_e dtlm,
-                                         ZSTD_tableFillPurpose_e tfp)
-{
-    const BYTE* ip = (const BYTE*) src;
-    const BYTE* const iend = ip + srcSize;
-    int const loadLdmDict = params->ldmParams.enableLdm == ZSTD_ps_enable && ls != NULL;
-
-    /* Assert that the ms params match the params we're being given */
-    ZSTD_assertEqualCParams(params->cParams, ms->cParams);
-
-    {   /* Ensure large dictionaries can't cause index overflow */
-
-        /* Allow the dictionary to set indices up to exactly ZSTD_CURRENT_MAX.
-         * Dictionaries right at the edge will immediately trigger overflow
-         * correction, but I don't want to insert extra constraints here.
-         */
-        U32 maxDictSize = ZSTD_CURRENT_MAX - ZSTD_WINDOW_START_INDEX;
-
-        int const CDictTaggedIndices = ZSTD_CDictIndicesAreTagged(&params->cParams);
-        if (CDictTaggedIndices && tfp == ZSTD_tfp_forCDict) {
-            /* Some dictionary matchfinders in zstd use "short cache",
-             * which treats the lower ZSTD_SHORT_CACHE_TAG_BITS of each
-             * CDict hashtable entry as a tag rather than as part of an index.
-             * When short cache is used, we need to truncate the dictionary
-             * so that its indices don't overlap with the tag. */
-            U32 const shortCacheMaxDictSize = (1u << (32 - ZSTD_SHORT_CACHE_TAG_BITS)) - ZSTD_WINDOW_START_INDEX;
-            maxDictSize = MIN(maxDictSize, shortCacheMaxDictSize);
-            assert(!loadLdmDict);
-        }
-
-        /* If the dictionary is too large, only load the suffix of the dictionary. */
-        if (srcSize > maxDictSize) {
-            ip = iend - maxDictSize;
-            src = ip;
-            srcSize = maxDictSize;
-        }
-    }
-
-    if (srcSize > ZSTD_CHUNKSIZE_MAX) {
-        /* We must have cleared our windows when our source is this large. */
-        assert(ZSTD_window_isEmpty(ms->window));
-        if (loadLdmDict) assert(ZSTD_window_isEmpty(ls->window));
-    }
-    ZSTD_window_update(&ms->window, src, srcSize, /* forceNonContiguous */ 0);
-
-    DEBUGLOG(4, "ZSTD_loadDictionaryContent(): useRowMatchFinder=%d", (int)params->useRowMatchFinder);
-
-    if (loadLdmDict) { /* Load the entire dict into LDM matchfinders. */
-        ZSTD_window_update(&ls->window, src, srcSize, /* forceNonContiguous */ 0);
-        ls->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ls->window.base);
-        ZSTD_ldm_fillHashTable(ls, ip, iend, &params->ldmParams);
-    }
-
-    /* If the dict is larger than we can reasonably index in our tables, only load the suffix. */
-    if (params->cParams.strategy < ZSTD_btultra) {
-        U32 maxDictSize = 8U << MIN(MAX(params->cParams.hashLog, params->cParams.chainLog), 28);
-        if (srcSize > maxDictSize) {
-            ip = iend - maxDictSize;
-            src = ip;
-            srcSize = maxDictSize;
-        }
-    }
-
-    ms->nextToUpdate = (U32)(ip - ms->window.base);
-    ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);
-    ms->forceNonContiguous = params->deterministicRefPrefix;
-
-    if (srcSize <= HASH_READ_SIZE) return 0;
-
-    ZSTD_overflowCorrectIfNeeded(ms, ws, params, ip, iend);
-
-    switch(params->cParams.strategy)
-    {
-    case ZSTD_fast:
-        ZSTD_fillHashTable(ms, iend, dtlm, tfp);
-        break;
-    case ZSTD_dfast:
-#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR
-        ZSTD_fillDoubleHashTable(ms, iend, dtlm, tfp);
-#else
-        assert(0); /* shouldn't be called: cparams should've been adjusted. */
-#endif
-        break;
-
-    case ZSTD_greedy:
-    case ZSTD_lazy:
-    case ZSTD_lazy2:
-#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR)
-        assert(srcSize >= HASH_READ_SIZE);
-        if (ms->dedicatedDictSearch) {
-            assert(ms->chainTable != NULL);
-            ZSTD_dedicatedDictSearch_lazy_loadDictionary(ms, iend-HASH_READ_SIZE);
-        } else {
-            assert(params->useRowMatchFinder != ZSTD_ps_auto);
-            if (params->useRowMatchFinder == ZSTD_ps_enable) {
-                size_t const tagTableSize = ((size_t)1 << params->cParams.hashLog);
-                ZSTD_memset(ms->tagTable, 0, tagTableSize);
-                ZSTD_row_update(ms, iend-HASH_READ_SIZE);
-                DEBUGLOG(4, "Using row-based hash table for lazy dict");
-            } else {
-                ZSTD_insertAndFindFirstIndex(ms, iend-HASH_READ_SIZE);
-                DEBUGLOG(4, "Using chain-based hash table for lazy dict");
-            }
-        }
-#else
-        assert(0); /* shouldn't be called: cparams should've been adjusted. */
-#endif
-        break;
-
-    case ZSTD_btlazy2:   /* we want the dictionary table fully sorted */
-    case ZSTD_btopt:
-    case ZSTD_btultra:
-    case ZSTD_btultra2:
-#if !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)
-        assert(srcSize >= HASH_READ_SIZE);
-        ZSTD_updateTree(ms, iend-HASH_READ_SIZE, iend);
-#else
-        assert(0); /* shouldn't be called: cparams should've been adjusted. */
-#endif
-        break;
-
-    default:
-        assert(0);  /* not possible : not a valid strategy id */
-    }
-
-    ms->nextToUpdate = (U32)(iend - ms->window.base);
-    return 0;
-}
-
-
-/* Dictionaries that assign zero probability to symbols that show up causes problems
- * when FSE encoding. Mark dictionaries with zero probability symbols as FSE_repeat_check
- * and only dictionaries with 100% valid symbols can be assumed valid.
- */
-static FSE_repeat ZSTD_dictNCountRepeat(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue)
-{
-    U32 s;
-    if (dictMaxSymbolValue < maxSymbolValue) {
-        return FSE_repeat_check;
-    }
-    for (s = 0; s <= maxSymbolValue; ++s) {
-        if (normalizedCounter[s] == 0) {
-            return FSE_repeat_check;
-        }
-    }
-    return FSE_repeat_valid;
-}
-
-size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
-                         const void* const dict, size_t dictSize)
-{
-    short offcodeNCount[MaxOff+1];
-    unsigned offcodeMaxValue = MaxOff;
-    const BYTE* dictPtr = (const BYTE*)dict;    /* skip magic num and dict ID */
-    const BYTE* const dictEnd = dictPtr + dictSize;
-    dictPtr += 8;
-    bs->entropy.huf.repeatMode = HUF_repeat_check;
-
-    {   unsigned maxSymbolValue = 255;
-        unsigned hasZeroWeights = 1;
-        size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.huf.CTable, &maxSymbolValue, dictPtr,
-            dictEnd-dictPtr, &hasZeroWeights);
-
-        /* We only set the loaded table as valid if it contains all non-zero
-         * weights. Otherwise, we set it to check */
-        if (!hasZeroWeights && maxSymbolValue == 255)
-            bs->entropy.huf.repeatMode = HUF_repeat_valid;
-
-        RETURN_ERROR_IF(HUF_isError(hufHeaderSize), dictionary_corrupted, "");
-        dictPtr += hufHeaderSize;
-    }
-
-    {   unsigned offcodeLog;
-        size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
-        RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
-        RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
-        /* fill all offset symbols to avoid garbage at end of table */
-        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-                bs->entropy.fse.offcodeCTable,
-                offcodeNCount, MaxOff, offcodeLog,
-                workspace, HUF_WORKSPACE_SIZE)),
-            dictionary_corrupted, "");
-        /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
-        dictPtr += offcodeHeaderSize;
-    }
-
-    {   short matchlengthNCount[MaxML+1];
-        unsigned matchlengthMaxValue = MaxML, matchlengthLog;
-        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
-        RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
-        RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
-        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-                bs->entropy.fse.matchlengthCTable,
-                matchlengthNCount, matchlengthMaxValue, matchlengthLog,
-                workspace, HUF_WORKSPACE_SIZE)),
-            dictionary_corrupted, "");
-        bs->entropy.fse.matchlength_repeatMode = ZSTD_dictNCountRepeat(matchlengthNCount, matchlengthMaxValue, MaxML);
-        dictPtr += matchlengthHeaderSize;
-    }
-
-    {   short litlengthNCount[MaxLL+1];
-        unsigned litlengthMaxValue = MaxLL, litlengthLog;
-        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
-        RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
-        RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
-        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-                bs->entropy.fse.litlengthCTable,
-                litlengthNCount, litlengthMaxValue, litlengthLog,
-                workspace, HUF_WORKSPACE_SIZE)),
-            dictionary_corrupted, "");
-        bs->entropy.fse.litlength_repeatMode = ZSTD_dictNCountRepeat(litlengthNCount, litlengthMaxValue, MaxLL);
-        dictPtr += litlengthHeaderSize;
-    }
-
-    RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
-    bs->rep[0] = MEM_readLE32(dictPtr+0);
-    bs->rep[1] = MEM_readLE32(dictPtr+4);
-    bs->rep[2] = MEM_readLE32(dictPtr+8);
-    dictPtr += 12;
-
-    {   size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
-        U32 offcodeMax = MaxOff;
-        if (dictContentSize <= ((U32)-1) - 128 KB) {
-            U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */
-            offcodeMax = ZSTD_highbit32(maxOffset); /* Calculate minimum offset code required to represent maxOffset */
-        }
-        /* All offset values <= dictContentSize + 128 KB must be representable for a valid table */
-        bs->entropy.fse.offcode_repeatMode = ZSTD_dictNCountRepeat(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff));
-
-        /* All repCodes must be <= dictContentSize and != 0 */
-        {   U32 u;
-            for (u=0; u<3; u++) {
-                RETURN_ERROR_IF(bs->rep[u] == 0, dictionary_corrupted, "");
-                RETURN_ERROR_IF(bs->rep[u] > dictContentSize, dictionary_corrupted, "");
-    }   }   }
-
-    return dictPtr - (const BYTE*)dict;
-}
-
-/* Dictionary format :
- * See :
- * https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#dictionary-format
- */
-/*! ZSTD_loadZstdDictionary() :
- * @return : dictID, or an error code
- *  assumptions : magic number supposed already checked
- *                dictSize supposed >= 8
- */
-static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,
-                                      ZSTD_matchState_t* ms,
-                                      ZSTD_cwksp* ws,
-                                      ZSTD_CCtx_params const* params,
-                                      const void* dict, size_t dictSize,
-                                      ZSTD_dictTableLoadMethod_e dtlm,
-                                      ZSTD_tableFillPurpose_e tfp,
-                                      void* workspace)
-{
-    const BYTE* dictPtr = (const BYTE*)dict;
-    const BYTE* const dictEnd = dictPtr + dictSize;
-    size_t dictID;
-    size_t eSize;
-    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
-    assert(dictSize >= 8);
-    assert(MEM_readLE32(dictPtr) == ZSTD_MAGIC_DICTIONARY);
-
-    dictID = params->fParams.noDictIDFlag ? 0 :  MEM_readLE32(dictPtr + 4 /* skip magic number */ );
-    eSize = ZSTD_loadCEntropy(bs, workspace, dict, dictSize);
-    FORWARD_IF_ERROR(eSize, "ZSTD_loadCEntropy failed");
-    dictPtr += eSize;
-
-    {
-        size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
-        FORWARD_IF_ERROR(ZSTD_loadDictionaryContent(
-            ms, NULL, ws, params, dictPtr, dictContentSize, dtlm, tfp), "");
-    }
-    return dictID;
-}
-
-/** ZSTD_compress_insertDictionary() :
-*   @return : dictID, or an error code */
-static size_t
-ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
-                               ZSTD_matchState_t* ms,
-                               ldmState_t* ls,
-                               ZSTD_cwksp* ws,
-                         const ZSTD_CCtx_params* params,
-                         const void* dict, size_t dictSize,
-                               ZSTD_dictContentType_e dictContentType,
-                               ZSTD_dictTableLoadMethod_e dtlm,
-                               ZSTD_tableFillPurpose_e tfp,
-                               void* workspace)
-{
-    DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
-    if ((dict==NULL) || (dictSize<8)) {
-        RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
-        return 0;
-    }
-
-    ZSTD_reset_compressedBlockState(bs);
-
-    /* dict restricted modes */
-    if (dictContentType == ZSTD_dct_rawContent)
-        return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm, tfp);
-
-    if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {
-        if (dictContentType == ZSTD_dct_auto) {
-            DEBUGLOG(4, "raw content dictionary detected");
-            return ZSTD_loadDictionaryContent(
-                ms, ls, ws, params, dict, dictSize, dtlm, tfp);
-        }
-        RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
-        assert(0);   /* impossible */
-    }
-
-    /* dict as full zstd dictionary */
-    return ZSTD_loadZstdDictionary(
-        bs, ms, ws, params, dict, dictSize, dtlm, tfp, workspace);
-}
-
-#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF (128 KB)
-#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER (6ULL)
-
-/*! ZSTD_compressBegin_internal() :
- * Assumption : either @dict OR @cdict (or none) is non-NULL, never both
- * @return : 0, or an error code */
-static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
-                                    const void* dict, size_t dictSize,
-                                    ZSTD_dictContentType_e dictContentType,
-                                    ZSTD_dictTableLoadMethod_e dtlm,
-                                    const ZSTD_CDict* cdict,
-                                    const ZSTD_CCtx_params* params, U64 pledgedSrcSize,
-                                    ZSTD_buffered_policy_e zbuff)
-{
-    size_t const dictContentSize = cdict ? cdict->dictContentSize : dictSize;
-#if ZSTD_TRACE
-    cctx->traceCtx = (ZSTD_trace_compress_begin != NULL) ? ZSTD_trace_compress_begin(cctx) : 0;
-#endif
-    DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params->cParams.windowLog);
-    /* params are supposed to be fully validated at this point */
-    assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
-    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
-    if ( (cdict)
-      && (cdict->dictContentSize > 0)
-      && ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
-        || pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
-        || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
-        || cdict->compressionLevel == 0)
-      && (params->attachDictPref != ZSTD_dictForceLoad) ) {
-        return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
-    }
-
-    FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
-                                     dictContentSize,
-                                     ZSTDcrp_makeClean, zbuff) , "");
-    {   size_t const dictID = cdict ?
-                ZSTD_compress_insertDictionary(
-                        cctx->blockState.prevCBlock, &cctx->blockState.matchState,
-                        &cctx->ldmState, &cctx->workspace, &cctx->appliedParams, cdict->dictContent,
-                        cdict->dictContentSize, cdict->dictContentType, dtlm,
-                        ZSTD_tfp_forCCtx, cctx->entropyWorkspace)
-              : ZSTD_compress_insertDictionary(
-                        cctx->blockState.prevCBlock, &cctx->blockState.matchState,
-                        &cctx->ldmState, &cctx->workspace, &cctx->appliedParams, dict, dictSize,
-                        dictContentType, dtlm, ZSTD_tfp_forCCtx, cctx->entropyWorkspace);
-        FORWARD_IF_ERROR(dictID, "ZSTD_compress_insertDictionary failed");
-        assert(dictID <= UINT_MAX);
-        cctx->dictID = (U32)dictID;
-        cctx->dictContentSize = dictContentSize;
-    }
-    return 0;
-}
-
-size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
-                                    const void* dict, size_t dictSize,
-                                    ZSTD_dictContentType_e dictContentType,
-                                    ZSTD_dictTableLoadMethod_e dtlm,
-                                    const ZSTD_CDict* cdict,
-                                    const ZSTD_CCtx_params* params,
-                                    unsigned long long pledgedSrcSize)
-{
-    DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params->cParams.windowLog);
-    /* compression parameters verification and optimization */
-    FORWARD_IF_ERROR( ZSTD_checkCParams(params->cParams) , "");
-    return ZSTD_compressBegin_internal(cctx,
-                                       dict, dictSize, dictContentType, dtlm,
-                                       cdict,
-                                       params, pledgedSrcSize,
-                                       ZSTDb_not_buffered);
-}
-
-/*! ZSTD_compressBegin_advanced() :
-*   @return : 0, or an error code */
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
-                             const void* dict, size_t dictSize,
-                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)
-{
-    ZSTD_CCtx_params cctxParams;
-    ZSTD_CCtxParams_init_internal(&cctxParams, &params, ZSTD_NO_CLEVEL);
-    return ZSTD_compressBegin_advanced_internal(cctx,
-                                            dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,
-                                            NULL /*cdict*/,
-                                            &cctxParams, pledgedSrcSize);
-}
-
-static size_t
-ZSTD_compressBegin_usingDict_deprecated(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
-{
-    ZSTD_CCtx_params cctxParams;
-    {   ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_noAttachDict);
-        ZSTD_CCtxParams_init_internal(&cctxParams, &params, (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel);
-    }
-    DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
-    return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
-                                       &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
-}
-
-size_t
-ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
-{
-    return ZSTD_compressBegin_usingDict_deprecated(cctx, dict, dictSize, compressionLevel);
-}
-
-size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
-{
-    return ZSTD_compressBegin_usingDict_deprecated(cctx, NULL, 0, compressionLevel);
-}
-
-
-/*! ZSTD_writeEpilogue() :
-*   Ends a frame.
-*   @return : nb of bytes written into dst (or an error code) */
-static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
-
-    DEBUGLOG(4, "ZSTD_writeEpilogue");
-    RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");
-
-    /* special case : empty frame */
-    if (cctx->stage == ZSTDcs_init) {
-        size_t fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0);
-        FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
-        dstCapacity -= fhSize;
-        op += fhSize;
-        cctx->stage = ZSTDcs_ongoing;
-    }
-
-    if (cctx->stage != ZSTDcs_ending) {
-        /* write one last empty block, make it the "last" block */
-        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0;
-        ZSTD_STATIC_ASSERT(ZSTD_BLOCKHEADERSIZE == 3);
-        RETURN_ERROR_IF(dstCapacity<3, dstSize_tooSmall, "no room for epilogue");
-        MEM_writeLE24(op, cBlockHeader24);
-        op += ZSTD_blockHeaderSize;
-        dstCapacity -= ZSTD_blockHeaderSize;
-    }
-
-    if (cctx->appliedParams.fParams.checksumFlag) {
-        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
-        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");
-        DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
-        MEM_writeLE32(op, checksum);
-        op += 4;
-    }
-
-    cctx->stage = ZSTDcs_created;  /* return to "created but no init" status */
-    return op-ostart;
-}
-
-void ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize)
-{
-#if ZSTD_TRACE
-    if (cctx->traceCtx && ZSTD_trace_compress_end != NULL) {
-        int const streaming = cctx->inBuffSize > 0 || cctx->outBuffSize > 0 || cctx->appliedParams.nbWorkers > 0;
-        ZSTD_Trace trace;
-        ZSTD_memset(&trace, 0, sizeof(trace));
-        trace.version = ZSTD_VERSION_NUMBER;
-        trace.streaming = streaming;
-        trace.dictionaryID = cctx->dictID;
-        trace.dictionarySize = cctx->dictContentSize;
-        trace.uncompressedSize = cctx->consumedSrcSize;
-        trace.compressedSize = cctx->producedCSize + extraCSize;
-        trace.params = &cctx->appliedParams;
-        trace.cctx = cctx;
-        ZSTD_trace_compress_end(cctx->traceCtx, &trace);
-    }
-    cctx->traceCtx = 0;
-#else
-    (void)cctx;
-    (void)extraCSize;
-#endif
-}
-
-size_t ZSTD_compressEnd_public(ZSTD_CCtx* cctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize)
-{
-    size_t endResult;
-    size_t const cSize = ZSTD_compressContinue_internal(cctx,
-                                dst, dstCapacity, src, srcSize,
-                                1 /* frame mode */, 1 /* last chunk */);
-    FORWARD_IF_ERROR(cSize, "ZSTD_compressContinue_internal failed");
-    endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
-    FORWARD_IF_ERROR(endResult, "ZSTD_writeEpilogue failed");
-    assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
-    if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
-        ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
-        DEBUGLOG(4, "end of frame : controlling src size");
-        RETURN_ERROR_IF(
-            cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,
-            srcSize_wrong,
-             "error : pledgedSrcSize = %u, while realSrcSize = %u",
-            (unsigned)cctx->pledgedSrcSizePlusOne-1,
-            (unsigned)cctx->consumedSrcSize);
-    }
-    ZSTD_CCtx_trace(cctx, endResult);
-    return cSize + endResult;
-}
-
-/* NOTE: Must just wrap ZSTD_compressEnd_public() */
-size_t ZSTD_compressEnd(ZSTD_CCtx* cctx,
-                        void* dst, size_t dstCapacity,
-                  const void* src, size_t srcSize)
-{
-    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);
-}
-
-size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize,
-                         const void* dict,size_t dictSize,
-                               ZSTD_parameters params)
-{
-    DEBUGLOG(4, "ZSTD_compress_advanced");
-    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
-    ZSTD_CCtxParams_init_internal(&cctx->simpleApiParams, &params, ZSTD_NO_CLEVEL);
-    return ZSTD_compress_advanced_internal(cctx,
-                                           dst, dstCapacity,
-                                           src, srcSize,
-                                           dict, dictSize,
-                                           &cctx->simpleApiParams);
-}
-
-/* Internal */
-size_t ZSTD_compress_advanced_internal(
-        ZSTD_CCtx* cctx,
-        void* dst, size_t dstCapacity,
-        const void* src, size_t srcSize,
-        const void* dict,size_t dictSize,
-        const ZSTD_CCtx_params* params)
-{
-    DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
-    FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
-                         dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
-                         params, srcSize, ZSTDb_not_buffered) , "");
-    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);
-}
-
-size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize,
-                         const void* dict, size_t dictSize,
-                               int compressionLevel)
-{
-    {
-        ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, srcSize, dict ? dictSize : 0, ZSTD_cpm_noAttachDict);
-        assert(params.fParams.contentSizeFlag == 1);
-        ZSTD_CCtxParams_init_internal(&cctx->simpleApiParams, &params, (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT: compressionLevel);
-    }
-    DEBUGLOG(4, "ZSTD_compress_usingDict (srcSize=%u)", (unsigned)srcSize);
-    return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctx->simpleApiParams);
-}
-
-size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
-                         void* dst, size_t dstCapacity,
-                   const void* src, size_t srcSize,
-                         int compressionLevel)
-{
-    DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize);
-    assert(cctx != NULL);
-    return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
-}
-
-size_t ZSTD_compress(void* dst, size_t dstCapacity,
-               const void* src, size_t srcSize,
-                     int compressionLevel)
-{
-    size_t result;
-#if ZSTD_COMPRESS_HEAPMODE
-    ZSTD_CCtx* cctx = ZSTD_createCCtx();
-    RETURN_ERROR_IF(!cctx, memory_allocation, "ZSTD_createCCtx failed");
-    result = ZSTD_compressCCtx(cctx, dst, dstCapacity, src, srcSize, compressionLevel);
-    ZSTD_freeCCtx(cctx);
-#else
-    ZSTD_CCtx ctxBody;
-    ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);
-    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
-    ZSTD_freeCCtxContent(&ctxBody);   /* can't free ctxBody itself, as it's on stack; free only heap content */
-#endif
-    return result;
-}
-
-
-/* =====  Dictionary API  ===== */
-
-/*! ZSTD_estimateCDictSize_advanced() :
- *  Estimate amount of memory that will be needed to create a dictionary with following arguments */
-size_t ZSTD_estimateCDictSize_advanced(
-        size_t dictSize, ZSTD_compressionParameters cParams,
-        ZSTD_dictLoadMethod_e dictLoadMethod)
-{
-    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
-    return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
-         + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
-         /* enableDedicatedDictSearch == 1 ensures that CDict estimation will not be too small
-          * in case we are using DDS with row-hash. */
-         + ZSTD_sizeof_matchState(&cParams, ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),
-                                  /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0)
-         + (dictLoadMethod == ZSTD_dlm_byRef ? 0
-            : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));
-}
-
-size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
-{
-    ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
-    return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy);
-}
-
-size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict)
-{
-    if (cdict==NULL) return 0;   /* support sizeof on NULL */
-    DEBUGLOG(5, "sizeof(*cdict) : %u", (unsigned)sizeof(*cdict));
-    /* cdict may be in the workspace */
-    return (cdict->workspace.workspace == cdict ? 0 : sizeof(*cdict))
-        + ZSTD_cwksp_sizeof(&cdict->workspace);
-}
-
-static size_t ZSTD_initCDict_internal(
-                    ZSTD_CDict* cdict,
-              const void* dictBuffer, size_t dictSize,
-                    ZSTD_dictLoadMethod_e dictLoadMethod,
-                    ZSTD_dictContentType_e dictContentType,
-                    ZSTD_CCtx_params params)
-{
-    DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType);
-    assert(!ZSTD_checkCParams(params.cParams));
-    cdict->matchState.cParams = params.cParams;
-    cdict->matchState.dedicatedDictSearch = params.enableDedicatedDictSearch;
-    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
-        cdict->dictContent = dictBuffer;
-    } else {
-         void *internalBuffer = ZSTD_cwksp_reserve_object(&cdict->workspace, ZSTD_cwksp_align(dictSize, sizeof(void*)));
-        RETURN_ERROR_IF(!internalBuffer, memory_allocation, "NULL pointer!");
-        cdict->dictContent = internalBuffer;
-        ZSTD_memcpy(internalBuffer, dictBuffer, dictSize);
-    }
-    cdict->dictContentSize = dictSize;
-    cdict->dictContentType = dictContentType;
-
-    cdict->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cdict->workspace, HUF_WORKSPACE_SIZE);
-
-
-    /* Reset the state to no dictionary */
-    ZSTD_reset_compressedBlockState(&cdict->cBlockState);
-    FORWARD_IF_ERROR(ZSTD_reset_matchState(
-        &cdict->matchState,
-        &cdict->workspace,
-        &params.cParams,
-        params.useRowMatchFinder,
-        ZSTDcrp_makeClean,
-        ZSTDirp_reset,
-        ZSTD_resetTarget_CDict), "");
-    /* (Maybe) load the dictionary
-     * Skips loading the dictionary if it is < 8 bytes.
-     */
-    {   params.compressionLevel = ZSTD_CLEVEL_DEFAULT;
-        params.fParams.contentSizeFlag = 1;
-        {   size_t const dictID = ZSTD_compress_insertDictionary(
-                    &cdict->cBlockState, &cdict->matchState, NULL, &cdict->workspace,
-                    &params, cdict->dictContent, cdict->dictContentSize,
-                    dictContentType, ZSTD_dtlm_full, ZSTD_tfp_forCDict, cdict->entropyWorkspace);
-            FORWARD_IF_ERROR(dictID, "ZSTD_compress_insertDictionary failed");
-            assert(dictID <= (size_t)(U32)-1);
-            cdict->dictID = (U32)dictID;
-        }
-    }
-
-    return 0;
-}
-
-static ZSTD_CDict* ZSTD_createCDict_advanced_internal(size_t dictSize,
-                                      ZSTD_dictLoadMethod_e dictLoadMethod,
-                                      ZSTD_compressionParameters cParams,
-                                      ZSTD_paramSwitch_e useRowMatchFinder,
-                                      U32 enableDedicatedDictSearch,
-                                      ZSTD_customMem customMem)
-{
-    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
-
-    {   size_t const workspaceSize =
-            ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict)) +
-            ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE) +
-            ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, enableDedicatedDictSearch, /* forCCtx */ 0) +
-            (dictLoadMethod == ZSTD_dlm_byRef ? 0
-             : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))));
-        void* const workspace = ZSTD_customMalloc(workspaceSize, customMem);
-        ZSTD_cwksp ws;
-        ZSTD_CDict* cdict;
-
-        if (!workspace) {
-            ZSTD_customFree(workspace, customMem);
-            return NULL;
-        }
-
-        ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_dynamic_alloc);
-
-        cdict = (ZSTD_CDict*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CDict));
-        assert(cdict != NULL);
-        ZSTD_cwksp_move(&cdict->workspace, &ws);
-        cdict->customMem = customMem;
-        cdict->compressionLevel = ZSTD_NO_CLEVEL; /* signals advanced API usage */
-        cdict->useRowMatchFinder = useRowMatchFinder;
-        return cdict;
-    }
-}
-
-ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
-                                      ZSTD_dictLoadMethod_e dictLoadMethod,
-                                      ZSTD_dictContentType_e dictContentType,
-                                      ZSTD_compressionParameters cParams,
-                                      ZSTD_customMem customMem)
-{
-    ZSTD_CCtx_params cctxParams;
-    ZSTD_memset(&cctxParams, 0, sizeof(cctxParams));
-    ZSTD_CCtxParams_init(&cctxParams, 0);
-    cctxParams.cParams = cParams;
-    cctxParams.customMem = customMem;
-    return ZSTD_createCDict_advanced2(
-        dictBuffer, dictSize,
-        dictLoadMethod, dictContentType,
-        &cctxParams, customMem);
-}
-
-ZSTD_CDict* ZSTD_createCDict_advanced2(
-        const void* dict, size_t dictSize,
-        ZSTD_dictLoadMethod_e dictLoadMethod,
-        ZSTD_dictContentType_e dictContentType,
-        const ZSTD_CCtx_params* originalCctxParams,
-        ZSTD_customMem customMem)
-{
-    ZSTD_CCtx_params cctxParams = *originalCctxParams;
-    ZSTD_compressionParameters cParams;
-    ZSTD_CDict* cdict;
-
-    DEBUGLOG(3, "ZSTD_createCDict_advanced2, mode %u", (unsigned)dictContentType);
-    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
-
-    if (cctxParams.enableDedicatedDictSearch) {
-        cParams = ZSTD_dedicatedDictSearch_getCParams(
-            cctxParams.compressionLevel, dictSize);
-        ZSTD_overrideCParams(&cParams, &cctxParams.cParams);
-    } else {
-        cParams = ZSTD_getCParamsFromCCtxParams(
-            &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
-    }
-
-    if (!ZSTD_dedicatedDictSearch_isSupported(&cParams)) {
-        /* Fall back to non-DDSS params */
-        cctxParams.enableDedicatedDictSearch = 0;
-        cParams = ZSTD_getCParamsFromCCtxParams(
-            &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
-    }
-
-    DEBUGLOG(3, "ZSTD_createCDict_advanced2: DDS: %u", cctxParams.enableDedicatedDictSearch);
-    cctxParams.cParams = cParams;
-    cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);
-
-    cdict = ZSTD_createCDict_advanced_internal(dictSize,
-                        dictLoadMethod, cctxParams.cParams,
-                        cctxParams.useRowMatchFinder, cctxParams.enableDedicatedDictSearch,
-                        customMem);
-
-    if (!cdict || ZSTD_isError( ZSTD_initCDict_internal(cdict,
-                                    dict, dictSize,
-                                    dictLoadMethod, dictContentType,
-                                    cctxParams) )) {
-        ZSTD_freeCDict(cdict);
-        return NULL;
-    }
-
-    return cdict;
-}
-
-ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel)
-{
-    ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
-    ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,
-                                                  ZSTD_dlm_byCopy, ZSTD_dct_auto,
-                                                  cParams, ZSTD_defaultCMem);
-    if (cdict)
-        cdict->compressionLevel = (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel;
-    return cdict;
-}
-
-ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel)
-{
-    ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
-    ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,
-                                     ZSTD_dlm_byRef, ZSTD_dct_auto,
-                                     cParams, ZSTD_defaultCMem);
-    if (cdict)
-        cdict->compressionLevel = (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel;
-    return cdict;
-}
-
-size_t ZSTD_freeCDict(ZSTD_CDict* cdict)
-{
-    if (cdict==NULL) return 0;   /* support free on NULL */
-    {   ZSTD_customMem const cMem = cdict->customMem;
-        int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict);
-        ZSTD_cwksp_free(&cdict->workspace, cMem);
-        if (!cdictInWorkspace) {
-            ZSTD_customFree(cdict, cMem);
-        }
-        return 0;
-    }
-}
-
-/*! ZSTD_initStaticCDict_advanced() :
- *  Generate a digested dictionary in provided memory area.
- *  workspace: The memory area to emplace the dictionary into.
- *             Provided pointer must 8-bytes aligned.
- *             It must outlive dictionary usage.
- *  workspaceSize: Use ZSTD_estimateCDictSize()
- *                 to determine how large workspace must be.
- *  cParams : use ZSTD_getCParams() to transform a compression level
- *            into its relevants cParams.
- * @return : pointer to ZSTD_CDict*, or NULL if error (size too small)
- *  Note : there is no corresponding "free" function.
- *         Since workspace was allocated externally, it must be freed externally.
- */
-const ZSTD_CDict* ZSTD_initStaticCDict(
-                                 void* workspace, size_t workspaceSize,
-                           const void* dict, size_t dictSize,
-                                 ZSTD_dictLoadMethod_e dictLoadMethod,
-                                 ZSTD_dictContentType_e dictContentType,
-                                 ZSTD_compressionParameters cParams)
-{
-    ZSTD_paramSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams);
-    /* enableDedicatedDictSearch == 1 ensures matchstate is not too small in case this CDict will be used for DDS + row hash */
-    size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0);
-    size_t const neededSize = ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
-                            + (dictLoadMethod == ZSTD_dlm_byRef ? 0
-                               : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))))
-                            + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
-                            + matchStateSize;
-    ZSTD_CDict* cdict;
-    ZSTD_CCtx_params params;
-
-    if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
-
-    {
-        ZSTD_cwksp ws;
-        ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc);
-        cdict = (ZSTD_CDict*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CDict));
-        if (cdict == NULL) return NULL;
-        ZSTD_cwksp_move(&cdict->workspace, &ws);
-    }
-
-    DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u",
-        (unsigned)workspaceSize, (unsigned)neededSize, (unsigned)(workspaceSize < neededSize));
-    if (workspaceSize < neededSize) return NULL;
-
-    ZSTD_CCtxParams_init(&params, 0);
-    params.cParams = cParams;
-    params.useRowMatchFinder = useRowMatchFinder;
-    cdict->useRowMatchFinder = useRowMatchFinder;
-    cdict->compressionLevel = ZSTD_NO_CLEVEL;
-
-    if (ZSTD_isError( ZSTD_initCDict_internal(cdict,
-                                              dict, dictSize,
-                                              dictLoadMethod, dictContentType,
-                                              params) ))
-        return NULL;
-
-    return cdict;
-}
-
-ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict)
-{
-    assert(cdict != NULL);
-    return cdict->matchState.cParams;
-}
-
-/*! ZSTD_getDictID_fromCDict() :
- *  Provides the dictID of the dictionary loaded into `cdict`.
- *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
- *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
-unsigned ZSTD_getDictID_fromCDict(const ZSTD_CDict* cdict)
-{
-    if (cdict==NULL) return 0;
-    return cdict->dictID;
-}
-
-/* ZSTD_compressBegin_usingCDict_internal() :
- * Implementation of various ZSTD_compressBegin_usingCDict* functions.
- */
-static size_t ZSTD_compressBegin_usingCDict_internal(
-    ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
-    ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
-{
-    ZSTD_CCtx_params cctxParams;
-    DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_internal");
-    RETURN_ERROR_IF(cdict==NULL, dictionary_wrong, "NULL pointer!");
-    /* Initialize the cctxParams from the cdict */
-    {
-        ZSTD_parameters params;
-        params.fParams = fParams;
-        params.cParams = ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
-                        || pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
-                        || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
-                        || cdict->compressionLevel == 0 ) ?
-                ZSTD_getCParamsFromCDict(cdict)
-              : ZSTD_getCParams(cdict->compressionLevel,
-                                pledgedSrcSize,
-                                cdict->dictContentSize);
-        ZSTD_CCtxParams_init_internal(&cctxParams, &params, cdict->compressionLevel);
-    }
-    /* Increase window log to fit the entire dictionary and source if the
-     * source size is known. Limit the increase to 19, which is the
-     * window log for compression level 1 with the largest source size.
-     */
-    if (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-        U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19);
-        U32 const limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1;
-        cctxParams.cParams.windowLog = MAX(cctxParams.cParams.windowLog, limitedSrcLog);
-    }
-    return ZSTD_compressBegin_internal(cctx,
-                                        NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast,
-                                        cdict,
-                                        &cctxParams, pledgedSrcSize,
-                                        ZSTDb_not_buffered);
-}
-
-
-/* ZSTD_compressBegin_usingCDict_advanced() :
- * This function is DEPRECATED.
- * cdict must be != NULL */
-size_t ZSTD_compressBegin_usingCDict_advanced(
-    ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
-    ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
-{
-    return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, pledgedSrcSize);
-}
-
-/* ZSTD_compressBegin_usingCDict() :
- * cdict must be != NULL */
-size_t ZSTD_compressBegin_usingCDict_deprecated(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
-{
-    ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
-    return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);
-}
-
-size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
-{
-    return ZSTD_compressBegin_usingCDict_deprecated(cctx, cdict);
-}
-
-/*! ZSTD_compress_usingCDict_internal():
- * Implementation of various ZSTD_compress_usingCDict* functions.
- */
-static size_t ZSTD_compress_usingCDict_internal(ZSTD_CCtx* cctx,
-                                void* dst, size_t dstCapacity,
-                                const void* src, size_t srcSize,
-                                const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)
-{
-    FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, srcSize), ""); /* will check if cdict != NULL */
-    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);
-}
-
-/*! ZSTD_compress_usingCDict_advanced():
- * This function is DEPRECATED.
- */
-size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
-                                void* dst, size_t dstCapacity,
-                                const void* src, size_t srcSize,
-                                const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)
-{
-    return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
-}
-
-/*! ZSTD_compress_usingCDict() :
- *  Compression using a digested Dictionary.
- *  Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times.
- *  Note that compression parameters are decided at CDict creation time
- *  while frame parameters are hardcoded */
-size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
-                                void* dst, size_t dstCapacity,
-                                const void* src, size_t srcSize,
-                                const ZSTD_CDict* cdict)
-{
-    ZSTD_frameParameters const fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
-    return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
-}
-
-
-
-/* ******************************************************************
-*  Streaming
-********************************************************************/
-
-ZSTD_CStream* ZSTD_createCStream(void)
-{
-    DEBUGLOG(3, "ZSTD_createCStream");
-    return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
-}
-
-ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
-{
-    return ZSTD_initStaticCCtx(workspace, workspaceSize);
-}
-
-ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
-{   /* CStream and CCtx are now same object */
-    return ZSTD_createCCtx_advanced(customMem);
-}
-
-size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
-{
-    return ZSTD_freeCCtx(zcs);   /* same object */
-}
-
-
-
-/*======   Initialization   ======*/
-
-size_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }
-
-size_t ZSTD_CStreamOutSize(void)
-{
-    return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 /* 32-bits hash */ ;
-}
-
-static ZSTD_cParamMode_e ZSTD_getCParamMode(ZSTD_CDict const* cdict, ZSTD_CCtx_params const* params, U64 pledgedSrcSize)
-{
-    if (cdict != NULL && ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize))
-        return ZSTD_cpm_attachDict;
-    else
-        return ZSTD_cpm_noAttachDict;
-}
-
-/* ZSTD_resetCStream():
- * pledgedSrcSize == 0 means "unknown" */
-size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
-{
-    /* temporary : 0 interpreted as "unknown" during transition period.
-     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
-     * 0 will be interpreted as "empty" in the future.
-     */
-    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
-    DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    return 0;
-}
-
-/*! ZSTD_initCStream_internal() :
- *  Note : for lib/compress only. Used by zstdmt_compress.c.
- *  Assumption 1 : params are valid
- *  Assumption 2 : either dict, or cdict, is defined, not both */
-size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
-                    const void* dict, size_t dictSize, const ZSTD_CDict* cdict,
-                    const ZSTD_CCtx_params* params,
-                    unsigned long long pledgedSrcSize)
-{
-    DEBUGLOG(4, "ZSTD_initCStream_internal");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
-    zcs->requestedParams = *params;
-    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
-    if (dict) {
-        FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
-    } else {
-        /* Dictionary is cleared if !cdict */
-        FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
-    }
-    return 0;
-}
-
-/* ZSTD_initCStream_usingCDict_advanced() :
- * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
-size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
-                                            const ZSTD_CDict* cdict,
-                                            ZSTD_frameParameters fParams,
-                                            unsigned long long pledgedSrcSize)
-{
-    DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    zcs->requestedParams.fParams = fParams;
-    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
-    return 0;
-}
-
-/* note : cdict must outlive compression session */
-size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
-{
-    DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
-    return 0;
-}
-
-
-/* ZSTD_initCStream_advanced() :
- * pledgedSrcSize must be exact.
- * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
- * dict is loaded with default parameters ZSTD_dct_auto and ZSTD_dlm_byCopy. */
-size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
-                                 const void* dict, size_t dictSize,
-                                 ZSTD_parameters params, unsigned long long pss)
-{
-    /* for compatibility with older programs relying on this behavior.
-     * Users should now specify ZSTD_CONTENTSIZE_UNKNOWN.
-     * This line will be removed in the future.
-     */
-    U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
-    DEBUGLOG(4, "ZSTD_initCStream_advanced");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
-    ZSTD_CCtxParams_setZstdParams(&zcs->requestedParams, &params);
-    FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
-    return 0;
-}
-
-size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
-{
-    DEBUGLOG(4, "ZSTD_initCStream_usingDict");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
-    return 0;
-}
-
-size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
-{
-    /* temporary : 0 interpreted as "unknown" during transition period.
-     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
-     * 0 will be interpreted as "empty" in the future.
-     */
-    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
-    DEBUGLOG(4, "ZSTD_initCStream_srcSize");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    return 0;
-}
-
-size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
-{
-    DEBUGLOG(4, "ZSTD_initCStream");
-    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , "");
-    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
-    return 0;
-}
-
-/*======   Compression   ======*/
-
-static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)
-{
-    if (cctx->appliedParams.inBufferMode == ZSTD_bm_stable) {
-        return cctx->blockSize - cctx->stableIn_notConsumed;
-    }
-    assert(cctx->appliedParams.inBufferMode == ZSTD_bm_buffered);
-    {   size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos;
-        if (hintInSize==0) hintInSize = cctx->blockSize;
-        return hintInSize;
-    }
-}
-
-/** ZSTD_compressStream_generic():
- *  internal function for all *compressStream*() variants
- * @return : hint size for next input to complete ongoing block */
-static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
-                                          ZSTD_outBuffer* output,
-                                          ZSTD_inBuffer* input,
-                                          ZSTD_EndDirective const flushMode)
-{
-    const char* const istart = (assert(input != NULL), (const char*)input->src);
-    const char* const iend = (istart != NULL) ? istart + input->size : istart;
-    const char* ip = (istart != NULL) ? istart + input->pos : istart;
-    char* const ostart = (assert(output != NULL), (char*)output->dst);
-    char* const oend = (ostart != NULL) ? ostart + output->size : ostart;
-    char* op = (ostart != NULL) ? ostart + output->pos : ostart;
-    U32 someMoreWork = 1;
-
-    /* check expectations */
-    DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%i, srcSize = %zu", (int)flushMode, input->size - input->pos);
-    assert(zcs != NULL);
-    if (zcs->appliedParams.inBufferMode == ZSTD_bm_stable) {
-        assert(input->pos >= zcs->stableIn_notConsumed);
-        input->pos -= zcs->stableIn_notConsumed;
-        if (ip) ip -= zcs->stableIn_notConsumed;
-        zcs->stableIn_notConsumed = 0;
-    }
-    if (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered) {
-        assert(zcs->inBuff != NULL);
-        assert(zcs->inBuffSize > 0);
-    }
-    if (zcs->appliedParams.outBufferMode == ZSTD_bm_buffered) {
-        assert(zcs->outBuff !=  NULL);
-        assert(zcs->outBuffSize > 0);
-    }
-    if (input->src == NULL) assert(input->size == 0);
-    assert(input->pos <= input->size);
-    if (output->dst == NULL) assert(output->size == 0);
-    assert(output->pos <= output->size);
-    assert((U32)flushMode <= (U32)ZSTD_e_end);
-
-    while (someMoreWork) {
-        switch(zcs->streamStage)
-        {
-        case zcss_init:
-            RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
-
-        case zcss_load:
-            if ( (flushMode == ZSTD_e_end)
-              && ( (size_t)(oend-op) >= ZSTD_compressBound(iend-ip)     /* Enough output space */
-                || zcs->appliedParams.outBufferMode == ZSTD_bm_stable)  /* OR we are allowed to return dstSizeTooSmall */
-              && (zcs->inBuffPos == 0) ) {
-                /* shortcut to compression pass directly into output buffer */
-                size_t const cSize = ZSTD_compressEnd_public(zcs,
-                                                op, oend-op, ip, iend-ip);
-                DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
-                FORWARD_IF_ERROR(cSize, "ZSTD_compressEnd failed");
-                ip = iend;
-                op += cSize;
-                zcs->frameEnded = 1;
-                ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
-                someMoreWork = 0; break;
-            }
-            /* complete loading into inBuffer in buffered mode */
-            if (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered) {
-                size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
-                size_t const loaded = ZSTD_limitCopy(
-                                        zcs->inBuff + zcs->inBuffPos, toLoad,
-                                        ip, iend-ip);
-                zcs->inBuffPos += loaded;
-                if (ip) ip += loaded;
-                if ( (flushMode == ZSTD_e_continue)
-                  && (zcs->inBuffPos < zcs->inBuffTarget) ) {
-                    /* not enough input to fill full block : stop here */
-                    someMoreWork = 0; break;
-                }
-                if ( (flushMode == ZSTD_e_flush)
-                  && (zcs->inBuffPos == zcs->inToCompress) ) {
-                    /* empty */
-                    someMoreWork = 0; break;
-                }
-            } else {
-                assert(zcs->appliedParams.inBufferMode == ZSTD_bm_stable);
-                if ( (flushMode == ZSTD_e_continue)
-                  && ( (size_t)(iend - ip) < zcs->blockSize) ) {
-                    /* can't compress a full block : stop here */
-                    zcs->stableIn_notConsumed = (size_t)(iend - ip);
-                    ip = iend;  /* pretend to have consumed input */
-                    someMoreWork = 0; break;
-                }
-                if ( (flushMode == ZSTD_e_flush)
-                  && (ip == iend) ) {
-                    /* empty */
-                    someMoreWork = 0; break;
-                }
-            }
-            /* compress current block (note : this stage cannot be stopped in the middle) */
-            DEBUGLOG(5, "stream compression stage (flushMode==%u)", flushMode);
-            {   int const inputBuffered = (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered);
-                void* cDst;
-                size_t cSize;
-                size_t oSize = oend-op;
-                size_t const iSize = inputBuffered ? zcs->inBuffPos - zcs->inToCompress
-                                                   : MIN((size_t)(iend - ip), zcs->blockSize);
-                if (oSize >= ZSTD_compressBound(iSize) || zcs->appliedParams.outBufferMode == ZSTD_bm_stable)
-                    cDst = op;   /* compress into output buffer, to skip flush stage */
-                else
-                    cDst = zcs->outBuff, oSize = zcs->outBuffSize;
-                if (inputBuffered) {
-                    unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);
-                    cSize = lastBlock ?
-                            ZSTD_compressEnd_public(zcs, cDst, oSize,
-                                        zcs->inBuff + zcs->inToCompress, iSize) :
-                            ZSTD_compressContinue_public(zcs, cDst, oSize,
-                                        zcs->inBuff + zcs->inToCompress, iSize);
-                    FORWARD_IF_ERROR(cSize, "%s", lastBlock ? "ZSTD_compressEnd failed" : "ZSTD_compressContinue failed");
-                    zcs->frameEnded = lastBlock;
-                    /* prepare next block */
-                    zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
-                    if (zcs->inBuffTarget > zcs->inBuffSize)
-                        zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
-                    DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u",
-                            (unsigned)zcs->inBuffTarget, (unsigned)zcs->inBuffSize);
-                    if (!lastBlock)
-                        assert(zcs->inBuffTarget <= zcs->inBuffSize);
-                    zcs->inToCompress = zcs->inBuffPos;
-                } else { /* !inputBuffered, hence ZSTD_bm_stable */
-                    unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip + iSize == iend);
-                    cSize = lastBlock ?
-                            ZSTD_compressEnd_public(zcs, cDst, oSize, ip, iSize) :
-                            ZSTD_compressContinue_public(zcs, cDst, oSize, ip, iSize);
-                    /* Consume the input prior to error checking to mirror buffered mode. */
-                    if (ip) ip += iSize;
-                    FORWARD_IF_ERROR(cSize, "%s", lastBlock ? "ZSTD_compressEnd failed" : "ZSTD_compressContinue failed");
-                    zcs->frameEnded = lastBlock;
-                    if (lastBlock) assert(ip == iend);
-                }
-                if (cDst == op) {  /* no need to flush */
-                    op += cSize;
-                    if (zcs->frameEnded) {
-                        DEBUGLOG(5, "Frame completed directly in outBuffer");
-                        someMoreWork = 0;
-                        ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
-                    }
-                    break;
-                }
-                zcs->outBuffContentSize = cSize;
-                zcs->outBuffFlushedSize = 0;
-                zcs->streamStage = zcss_flush; /* pass-through to flush stage */
-            }
-	    ZSTD_FALLTHROUGH;
-        case zcss_flush:
-            DEBUGLOG(5, "flush stage");
-            assert(zcs->appliedParams.outBufferMode == ZSTD_bm_buffered);
-            {   size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
-                size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),
-                            zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
-                DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
-                            (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
-                if (flushed)
-                    op += flushed;
-                zcs->outBuffFlushedSize += flushed;
-                if (toFlush!=flushed) {
-                    /* flush not fully completed, presumably because dst is too small */
-                    assert(op==oend);
-                    someMoreWork = 0;
-                    break;
-                }
-                zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
-                if (zcs->frameEnded) {
-                    DEBUGLOG(5, "Frame completed on flush");
-                    someMoreWork = 0;
-                    ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
-                    break;
-                }
-                zcs->streamStage = zcss_load;
-                break;
-            }
-
-        default: /* impossible */
-            assert(0);
-        }
-    }
-
-    input->pos = ip - istart;
-    output->pos = op - ostart;
-    if (zcs->frameEnded) return 0;
-    return ZSTD_nextInputSizeHint(zcs);
-}
-
-static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)
-{
-#ifdef ZSTD_MULTITHREAD
-    if (cctx->appliedParams.nbWorkers >= 1) {
-        assert(cctx->mtctx != NULL);
-        return ZSTDMT_nextInputSizeHint(cctx->mtctx);
-    }
-#endif
-    return ZSTD_nextInputSizeHint(cctx);
-
-}
-
-size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
-{
-    FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
-    return ZSTD_nextInputSizeHint_MTorST(zcs);
-}
-
-/* After a compression call set the expected input/output buffer.
- * This is validated at the start of the next compression call.
- */
-static void
-ZSTD_setBufferExpectations(ZSTD_CCtx* cctx, const ZSTD_outBuffer* output, const ZSTD_inBuffer* input)
-{
-    DEBUGLOG(5, "ZSTD_setBufferExpectations (for advanced stable in/out modes)");
-    if (cctx->appliedParams.inBufferMode == ZSTD_bm_stable) {
-        cctx->expectedInBuffer = *input;
-    }
-    if (cctx->appliedParams.outBufferMode == ZSTD_bm_stable) {
-        cctx->expectedOutBufferSize = output->size - output->pos;
-    }
-}
-
-/* Validate that the input/output buffers match the expectations set by
- * ZSTD_setBufferExpectations.
- */
-static size_t ZSTD_checkBufferStability(ZSTD_CCtx const* cctx,
-                                        ZSTD_outBuffer const* output,
-                                        ZSTD_inBuffer const* input,
-                                        ZSTD_EndDirective endOp)
-{
-    if (cctx->appliedParams.inBufferMode == ZSTD_bm_stable) {
-        ZSTD_inBuffer const expect = cctx->expectedInBuffer;
-        if (expect.src != input->src || expect.pos != input->pos)
-            RETURN_ERROR(stabilityCondition_notRespected, "ZSTD_c_stableInBuffer enabled but input differs!");
-    }
-    (void)endOp;
-    if (cctx->appliedParams.outBufferMode == ZSTD_bm_stable) {
-        size_t const outBufferSize = output->size - output->pos;
-        if (cctx->expectedOutBufferSize != outBufferSize)
-            RETURN_ERROR(stabilityCondition_notRespected, "ZSTD_c_stableOutBuffer enabled but output size differs!");
-    }
-    return 0;
-}
-
-static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,
-                                             ZSTD_EndDirective endOp,
-                                             size_t inSize)
-{
-    ZSTD_CCtx_params params = cctx->requestedParams;
-    ZSTD_prefixDict const prefixDict = cctx->prefixDict;
-    FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) , ""); /* Init the local dict if present. */
-    ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));   /* single usage */
-    assert(prefixDict.dict==NULL || cctx->cdict==NULL);    /* only one can be set */
-    if (cctx->cdict && !cctx->localDict.cdict) {
-        /* Let the cdict's compression level take priority over the requested params.
-         * But do not take the cdict's compression level if the "cdict" is actually a localDict
-         * generated from ZSTD_initLocalDict().
-         */
-        params.compressionLevel = cctx->cdict->compressionLevel;
-    }
-    DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
-    if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = inSize + 1;  /* auto-determine pledgedSrcSize */
-
-    {   size_t const dictSize = prefixDict.dict
-                ? prefixDict.dictSize
-                : (cctx->cdict ? cctx->cdict->dictContentSize : 0);
-        ZSTD_cParamMode_e const mode = ZSTD_getCParamMode(cctx->cdict, &params, cctx->pledgedSrcSizePlusOne - 1);
-        params.cParams = ZSTD_getCParamsFromCCtxParams(
-                &params, cctx->pledgedSrcSizePlusOne-1,
-                dictSize, mode);
-    }
-
-    params.useBlockSplitter = ZSTD_resolveBlockSplitterMode(params.useBlockSplitter, &params.cParams);
-    params.ldmParams.enableLdm = ZSTD_resolveEnableLdm(params.ldmParams.enableLdm, &params.cParams);
-    params.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params.useRowMatchFinder, &params.cParams);
-    params.validateSequences = ZSTD_resolveExternalSequenceValidation(params.validateSequences);
-    params.maxBlockSize = ZSTD_resolveMaxBlockSize(params.maxBlockSize);
-    params.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(params.searchForExternalRepcodes, params.compressionLevel);
-
-#ifdef ZSTD_MULTITHREAD
-    /* If external matchfinder is enabled, make sure to fail before checking job size (for consistency) */
-    RETURN_ERROR_IF(
-        ZSTD_hasExtSeqProd(&params) && params.nbWorkers >= 1,
-        parameter_combination_unsupported,
-        "External sequence producer isn't supported with nbWorkers >= 1"
-    );
-
-    if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {
-        params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */
-    }
-    if (params.nbWorkers > 0) {
-#if ZSTD_TRACE
-        cctx->traceCtx = (ZSTD_trace_compress_begin != NULL) ? ZSTD_trace_compress_begin(cctx) : 0;
-#endif
-        /* mt context creation */
-        if (cctx->mtctx == NULL) {
-            DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
-                        params.nbWorkers);
-            cctx->mtctx = ZSTDMT_createCCtx_advanced((U32)params.nbWorkers, cctx->customMem, cctx->pool);
-            RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation, "NULL pointer!");
-        }
-        /* mt compression */
-        DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
-        FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
-                    cctx->mtctx,
-                    prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
-                    cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) , "");
-        cctx->dictID = cctx->cdict ? cctx->cdict->dictID : 0;
-        cctx->dictContentSize = cctx->cdict ? cctx->cdict->dictContentSize : prefixDict.dictSize;
-        cctx->consumedSrcSize = 0;
-        cctx->producedCSize = 0;
-        cctx->streamStage = zcss_load;
-        cctx->appliedParams = params;
-    } else
-#endif  /* ZSTD_MULTITHREAD */
-    {   U64 const pledgedSrcSize = cctx->pledgedSrcSizePlusOne - 1;
-        assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
-        FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
-                prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType, ZSTD_dtlm_fast,
-                cctx->cdict,
-                &params, pledgedSrcSize,
-                ZSTDb_buffered) , "");
-        assert(cctx->appliedParams.nbWorkers == 0);
-        cctx->inToCompress = 0;
-        cctx->inBuffPos = 0;
-        if (cctx->appliedParams.inBufferMode == ZSTD_bm_buffered) {
-            /* for small input: avoid automatic flush on reaching end of block, since
-            * it would require to add a 3-bytes null block to end frame
-            */
-            cctx->inBuffTarget = cctx->blockSize + (cctx->blockSize == pledgedSrcSize);
-        } else {
-            cctx->inBuffTarget = 0;
-        }
-        cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0;
-        cctx->streamStage = zcss_load;
-        cctx->frameEnded = 0;
-    }
-    return 0;
-}
-
-/* @return provides a minimum amount of data remaining to be flushed from internal buffers
- */
-size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
-                             ZSTD_outBuffer* output,
-                             ZSTD_inBuffer* input,
-                             ZSTD_EndDirective endOp)
-{
-    DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
-    /* check conditions */
-    RETURN_ERROR_IF(output->pos > output->size, dstSize_tooSmall, "invalid output buffer");
-    RETURN_ERROR_IF(input->pos  > input->size, srcSize_wrong, "invalid input buffer");
-    RETURN_ERROR_IF((U32)endOp > (U32)ZSTD_e_end, parameter_outOfBound, "invalid endDirective");
-    assert(cctx != NULL);
-
-    /* transparent initialization stage */
-    if (cctx->streamStage == zcss_init) {
-        size_t const inputSize = input->size - input->pos;  /* no obligation to start from pos==0 */
-        size_t const totalInputSize = inputSize + cctx->stableIn_notConsumed;
-        if ( (cctx->requestedParams.inBufferMode == ZSTD_bm_stable) /* input is presumed stable, across invocations */
-          && (endOp == ZSTD_e_continue)                             /* no flush requested, more input to come */
-          && (totalInputSize < ZSTD_BLOCKSIZE_MAX) ) {              /* not even reached one block yet */
-            if (cctx->stableIn_notConsumed) {  /* not the first time */
-                /* check stable source guarantees */
-                RETURN_ERROR_IF(input->src != cctx->expectedInBuffer.src, stabilityCondition_notRespected, "stableInBuffer condition not respected: wrong src pointer");
-                RETURN_ERROR_IF(input->pos != cctx->expectedInBuffer.size, stabilityCondition_notRespected, "stableInBuffer condition not respected: externally modified pos");
-            }
-            /* pretend input was consumed, to give a sense forward progress */
-            input->pos = input->size;
-            /* save stable inBuffer, for later control, and flush/end */
-            cctx->expectedInBuffer = *input;
-            /* but actually input wasn't consumed, so keep track of position from where compression shall resume */
-            cctx->stableIn_notConsumed += inputSize;
-            /* don't initialize yet, wait for the first block of flush() order, for better parameters adaptation */
-            return ZSTD_FRAMEHEADERSIZE_MIN(cctx->requestedParams.format);  /* at least some header to produce */
-        }
-        FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize), "compressStream2 initialization failed");
-        ZSTD_setBufferExpectations(cctx, output, input);   /* Set initial buffer expectations now that we've initialized */
-    }
-    /* end of transparent initialization stage */
-
-    FORWARD_IF_ERROR(ZSTD_checkBufferStability(cctx, output, input, endOp), "invalid buffers");
-    /* compression stage */
-#ifdef ZSTD_MULTITHREAD
-    if (cctx->appliedParams.nbWorkers > 0) {
-        size_t flushMin;
-        if (cctx->cParamsChanged) {
-            ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
-            cctx->cParamsChanged = 0;
-        }
-        if (cctx->stableIn_notConsumed) {
-            assert(cctx->appliedParams.inBufferMode == ZSTD_bm_stable);
-            /* some early data was skipped - make it available for consumption */
-            assert(input->pos >= cctx->stableIn_notConsumed);
-            input->pos -= cctx->stableIn_notConsumed;
-            cctx->stableIn_notConsumed = 0;
-        }
-        for (;;) {
-            size_t const ipos = input->pos;
-            size_t const opos = output->pos;
-            flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
-            cctx->consumedSrcSize += (U64)(input->pos - ipos);
-            cctx->producedCSize += (U64)(output->pos - opos);
-            if ( ZSTD_isError(flushMin)
-              || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
-                if (flushMin == 0)
-                    ZSTD_CCtx_trace(cctx, 0);
-                ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
-            }
-            FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
-
-            if (endOp == ZSTD_e_continue) {
-                /* We only require some progress with ZSTD_e_continue, not maximal progress.
-                 * We're done if we've consumed or produced any bytes, or either buffer is
-                 * full.
-                 */
-                if (input->pos != ipos || output->pos != opos || input->pos == input->size || output->pos == output->size)
-                    break;
-            } else {
-                assert(endOp == ZSTD_e_flush || endOp == ZSTD_e_end);
-                /* We require maximal progress. We're done when the flush is complete or the
-                 * output buffer is full.
-                 */
-                if (flushMin == 0 || output->pos == output->size)
-                    break;
-            }
-        }
-        DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
-        /* Either we don't require maximum forward progress, we've finished the
-         * flush, or we are out of output space.
-         */
-        assert(endOp == ZSTD_e_continue || flushMin == 0 || output->pos == output->size);
-        ZSTD_setBufferExpectations(cctx, output, input);
-        return flushMin;
-    }
-#endif /* ZSTD_MULTITHREAD */
-    FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
-    DEBUGLOG(5, "completed ZSTD_compressStream2");
-    ZSTD_setBufferExpectations(cctx, output, input);
-    return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
-}
-
-size_t ZSTD_compressStream2_simpleArgs (
-                            ZSTD_CCtx* cctx,
-                            void* dst, size_t dstCapacity, size_t* dstPos,
-                      const void* src, size_t srcSize, size_t* srcPos,
-                            ZSTD_EndDirective endOp)
-{
-    ZSTD_outBuffer output;
-    ZSTD_inBuffer  input;
-    output.dst = dst;
-    output.size = dstCapacity;
-    output.pos = *dstPos;
-    input.src = src;
-    input.size = srcSize;
-    input.pos = *srcPos;
-    /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
-    {   size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
-        *dstPos = output.pos;
-        *srcPos = input.pos;
-        return cErr;
-    }
-}
-
-size_t ZSTD_compress2(ZSTD_CCtx* cctx,
-                      void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
-    ZSTD_bufferMode_e const originalInBufferMode = cctx->requestedParams.inBufferMode;
-    ZSTD_bufferMode_e const originalOutBufferMode = cctx->requestedParams.outBufferMode;
-    DEBUGLOG(4, "ZSTD_compress2 (srcSize=%u)", (unsigned)srcSize);
-    ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
-    /* Enable stable input/output buffers. */
-    cctx->requestedParams.inBufferMode = ZSTD_bm_stable;
-    cctx->requestedParams.outBufferMode = ZSTD_bm_stable;
-    {   size_t oPos = 0;
-        size_t iPos = 0;
-        size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
-                                        dst, dstCapacity, &oPos,
-                                        src, srcSize, &iPos,
-                                        ZSTD_e_end);
-        /* Reset to the original values. */
-        cctx->requestedParams.inBufferMode = originalInBufferMode;
-        cctx->requestedParams.outBufferMode = originalOutBufferMode;
-
-        FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
-        if (result != 0) {  /* compression not completed, due to lack of output space */
-            assert(oPos == dstCapacity);
-            RETURN_ERROR(dstSize_tooSmall, "");
-        }
-        assert(iPos == srcSize);   /* all input is expected consumed */
-        return oPos;
-    }
-}
-
-/* ZSTD_validateSequence() :
- * @offCode : is presumed to follow format required by ZSTD_storeSeq()
- * @returns a ZSTD error code if sequence is not valid
- */
-static size_t
-ZSTD_validateSequence(U32 offCode, U32 matchLength, U32 minMatch,
-                      size_t posInSrc, U32 windowLog, size_t dictSize, int useSequenceProducer)
-{
-    U32 const windowSize = 1u << windowLog;
-    /* posInSrc represents the amount of data the decoder would decode up to this point.
-     * As long as the amount of data decoded is less than or equal to window size, offsets may be
-     * larger than the total length of output decoded in order to reference the dict, even larger than
-     * window size. After output surpasses windowSize, we're limited to windowSize offsets again.
-     */
-    size_t const offsetBound = posInSrc > windowSize ? (size_t)windowSize : posInSrc + (size_t)dictSize;
-    size_t const matchLenLowerBound = (minMatch == 3 || useSequenceProducer) ? 3 : 4;
-    RETURN_ERROR_IF(offCode > OFFSET_TO_OFFBASE(offsetBound), externalSequences_invalid, "Offset too large!");
-    /* Validate maxNbSeq is large enough for the given matchLength and minMatch */
-    RETURN_ERROR_IF(matchLength < matchLenLowerBound, externalSequences_invalid, "Matchlength too small for the minMatch");
-    return 0;
-}
-
-/* Returns an offset code, given a sequence's raw offset, the ongoing repcode array, and whether litLength == 0 */
-static U32 ZSTD_finalizeOffBase(U32 rawOffset, const U32 rep[ZSTD_REP_NUM], U32 ll0)
-{
-    U32 offBase = OFFSET_TO_OFFBASE(rawOffset);
-
-    if (!ll0 && rawOffset == rep[0]) {
-        offBase = REPCODE1_TO_OFFBASE;
-    } else if (rawOffset == rep[1]) {
-        offBase = REPCODE_TO_OFFBASE(2 - ll0);
-    } else if (rawOffset == rep[2]) {
-        offBase = REPCODE_TO_OFFBASE(3 - ll0);
-    } else if (ll0 && rawOffset == rep[0] - 1) {
-        offBase = REPCODE3_TO_OFFBASE;
-    }
-    return offBase;
-}
-
-size_t
-ZSTD_copySequencesToSeqStoreExplicitBlockDelim(ZSTD_CCtx* cctx,
-                                              ZSTD_sequencePosition* seqPos,
-                                        const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
-                                        const void* src, size_t blockSize,
-                                        ZSTD_paramSwitch_e externalRepSearch)
-{
-    U32 idx = seqPos->idx;
-    U32 const startIdx = idx;
-    BYTE const* ip = (BYTE const*)(src);
-    const BYTE* const iend = ip + blockSize;
-    repcodes_t updatedRepcodes;
-    U32 dictSize;
-
-    DEBUGLOG(5, "ZSTD_copySequencesToSeqStoreExplicitBlockDelim (blockSize = %zu)", blockSize);
-
-    if (cctx->cdict) {
-        dictSize = (U32)cctx->cdict->dictContentSize;
-    } else if (cctx->prefixDict.dict) {
-        dictSize = (U32)cctx->prefixDict.dictSize;
-    } else {
-        dictSize = 0;
-    }
-    ZSTD_memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, sizeof(repcodes_t));
-    for (; idx < inSeqsSize && (inSeqs[idx].matchLength != 0 || inSeqs[idx].offset != 0); ++idx) {
-        U32 const litLength = inSeqs[idx].litLength;
-        U32 const matchLength = inSeqs[idx].matchLength;
-        U32 offBase;
-
-        if (externalRepSearch == ZSTD_ps_disable) {
-            offBase = OFFSET_TO_OFFBASE(inSeqs[idx].offset);
-        } else {
-            U32 const ll0 = (litLength == 0);
-            offBase = ZSTD_finalizeOffBase(inSeqs[idx].offset, updatedRepcodes.rep, ll0);
-            ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0);
-        }
-
-        DEBUGLOG(6, "Storing sequence: (of: %u, ml: %u, ll: %u)", offBase, matchLength, litLength);
-        if (cctx->appliedParams.validateSequences) {
-            seqPos->posInSrc += litLength + matchLength;
-            FORWARD_IF_ERROR(ZSTD_validateSequence(offBase, matchLength, cctx->appliedParams.cParams.minMatch, seqPos->posInSrc,
-                                                cctx->appliedParams.cParams.windowLog, dictSize, ZSTD_hasExtSeqProd(&cctx->appliedParams)),
-                                                "Sequence validation failed");
-        }
-        RETURN_ERROR_IF(idx - seqPos->idx >= cctx->seqStore.maxNbSeq, externalSequences_invalid,
-                        "Not enough memory allocated. Try adjusting ZSTD_c_minMatch.");
-        ZSTD_storeSeq(&cctx->seqStore, litLength, ip, iend, offBase, matchLength);
-        ip += matchLength + litLength;
-    }
-
-    /* If we skipped repcode search while parsing, we need to update repcodes now */
-    assert(externalRepSearch != ZSTD_ps_auto);
-    assert(idx >= startIdx);
-    if (externalRepSearch == ZSTD_ps_disable && idx != startIdx) {
-        U32* const rep = updatedRepcodes.rep;
-        U32 lastSeqIdx = idx - 1; /* index of last non-block-delimiter sequence */
-
-        if (lastSeqIdx >= startIdx + 2) {
-            rep[2] = inSeqs[lastSeqIdx - 2].offset;
-            rep[1] = inSeqs[lastSeqIdx - 1].offset;
-            rep[0] = inSeqs[lastSeqIdx].offset;
-        } else if (lastSeqIdx == startIdx + 1) {
-            rep[2] = rep[0];
-            rep[1] = inSeqs[lastSeqIdx - 1].offset;
-            rep[0] = inSeqs[lastSeqIdx].offset;
-        } else {
-            assert(lastSeqIdx == startIdx);
-            rep[2] = rep[1];
-            rep[1] = rep[0];
-            rep[0] = inSeqs[lastSeqIdx].offset;
-        }
-    }
-
-    ZSTD_memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, sizeof(repcodes_t));
-
-    if (inSeqs[idx].litLength) {
-        DEBUGLOG(6, "Storing last literals of size: %u", inSeqs[idx].litLength);
-        ZSTD_storeLastLiterals(&cctx->seqStore, ip, inSeqs[idx].litLength);
-        ip += inSeqs[idx].litLength;
-        seqPos->posInSrc += inSeqs[idx].litLength;
-    }
-    RETURN_ERROR_IF(ip != iend, externalSequences_invalid, "Blocksize doesn't agree with block delimiter!");
-    seqPos->idx = idx+1;
-    return 0;
-}
-
-size_t
-ZSTD_copySequencesToSeqStoreNoBlockDelim(ZSTD_CCtx* cctx, ZSTD_sequencePosition* seqPos,
-                                   const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
-                                   const void* src, size_t blockSize, ZSTD_paramSwitch_e externalRepSearch)
-{
-    U32 idx = seqPos->idx;
-    U32 startPosInSequence = seqPos->posInSequence;
-    U32 endPosInSequence = seqPos->posInSequence + (U32)blockSize;
-    size_t dictSize;
-    BYTE const* ip = (BYTE const*)(src);
-    BYTE const* iend = ip + blockSize;  /* May be adjusted if we decide to process fewer than blockSize bytes */
-    repcodes_t updatedRepcodes;
-    U32 bytesAdjustment = 0;
-    U32 finalMatchSplit = 0;
-
-    /* TODO(embg) support fast parsing mode in noBlockDelim mode */
-    (void)externalRepSearch;
-
-    if (cctx->cdict) {
-        dictSize = cctx->cdict->dictContentSize;
-    } else if (cctx->prefixDict.dict) {
-        dictSize = cctx->prefixDict.dictSize;
-    } else {
-        dictSize = 0;
-    }
-    DEBUGLOG(5, "ZSTD_copySequencesToSeqStoreNoBlockDelim: idx: %u PIS: %u blockSize: %zu", idx, startPosInSequence, blockSize);
-    DEBUGLOG(5, "Start seq: idx: %u (of: %u ml: %u ll: %u)", idx, inSeqs[idx].offset, inSeqs[idx].matchLength, inSeqs[idx].litLength);
-    ZSTD_memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, sizeof(repcodes_t));
-    while (endPosInSequence && idx < inSeqsSize && !finalMatchSplit) {
-        const ZSTD_Sequence currSeq = inSeqs[idx];
-        U32 litLength = currSeq.litLength;
-        U32 matchLength = currSeq.matchLength;
-        U32 const rawOffset = currSeq.offset;
-        U32 offBase;
-
-        /* Modify the sequence depending on where endPosInSequence lies */
-        if (endPosInSequence >= currSeq.litLength + currSeq.matchLength) {
-            if (startPosInSequence >= litLength) {
-                startPosInSequence -= litLength;
-                litLength = 0;
-                matchLength -= startPosInSequence;
-            } else {
-                litLength -= startPosInSequence;
-            }
-            /* Move to the next sequence */
-            endPosInSequence -= currSeq.litLength + currSeq.matchLength;
-            startPosInSequence = 0;
-        } else {
-            /* This is the final (partial) sequence we're adding from inSeqs, and endPosInSequence
-               does not reach the end of the match. So, we have to split the sequence */
-            DEBUGLOG(6, "Require a split: diff: %u, idx: %u PIS: %u",
-                     currSeq.litLength + currSeq.matchLength - endPosInSequence, idx, endPosInSequence);
-            if (endPosInSequence > litLength) {
-                U32 firstHalfMatchLength;
-                litLength = startPosInSequence >= litLength ? 0 : litLength - startPosInSequence;
-                firstHalfMatchLength = endPosInSequence - startPosInSequence - litLength;
-                if (matchLength > blockSize && firstHalfMatchLength >= cctx->appliedParams.cParams.minMatch) {
-                    /* Only ever split the match if it is larger than the block size */
-                    U32 secondHalfMatchLength = currSeq.matchLength + currSeq.litLength - endPosInSequence;
-                    if (secondHalfMatchLength < cctx->appliedParams.cParams.minMatch) {
-                        /* Move the endPosInSequence backward so that it creates match of minMatch length */
-                        endPosInSequence -= cctx->appliedParams.cParams.minMatch - secondHalfMatchLength;
-                        bytesAdjustment = cctx->appliedParams.cParams.minMatch - secondHalfMatchLength;
-                        firstHalfMatchLength -= bytesAdjustment;
-                    }
-                    matchLength = firstHalfMatchLength;
-                    /* Flag that we split the last match - after storing the sequence, exit the loop,
-                       but keep the value of endPosInSequence */
-                    finalMatchSplit = 1;
-                } else {
-                    /* Move the position in sequence backwards so that we don't split match, and break to store
-                     * the last literals. We use the original currSeq.litLength as a marker for where endPosInSequence
-                     * should go. We prefer to do this whenever it is not necessary to split the match, or if doing so
-                     * would cause the first half of the match to be too small
-                     */
-                    bytesAdjustment = endPosInSequence - currSeq.litLength;
-                    endPosInSequence = currSeq.litLength;
-                    break;
-                }
-            } else {
-                /* This sequence ends inside the literals, break to store the last literals */
-                break;
-            }
-        }
-        /* Check if this offset can be represented with a repcode */
-        {   U32 const ll0 = (litLength == 0);
-            offBase = ZSTD_finalizeOffBase(rawOffset, updatedRepcodes.rep, ll0);
-            ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0);
-        }
-
-        if (cctx->appliedParams.validateSequences) {
-            seqPos->posInSrc += litLength + matchLength;
-            FORWARD_IF_ERROR(ZSTD_validateSequence(offBase, matchLength, cctx->appliedParams.cParams.minMatch, seqPos->posInSrc,
-                                                   cctx->appliedParams.cParams.windowLog, dictSize, ZSTD_hasExtSeqProd(&cctx->appliedParams)),
-                                                   "Sequence validation failed");
-        }
-        DEBUGLOG(6, "Storing sequence: (of: %u, ml: %u, ll: %u)", offBase, matchLength, litLength);
-        RETURN_ERROR_IF(idx - seqPos->idx >= cctx->seqStore.maxNbSeq, externalSequences_invalid,
-                        "Not enough memory allocated. Try adjusting ZSTD_c_minMatch.");
-        ZSTD_storeSeq(&cctx->seqStore, litLength, ip, iend, offBase, matchLength);
-        ip += matchLength + litLength;
-        if (!finalMatchSplit)
-            idx++; /* Next Sequence */
-    }
-    DEBUGLOG(5, "Ending seq: idx: %u (of: %u ml: %u ll: %u)", idx, inSeqs[idx].offset, inSeqs[idx].matchLength, inSeqs[idx].litLength);
-    assert(idx == inSeqsSize || endPosInSequence <= inSeqs[idx].litLength + inSeqs[idx].matchLength);
-    seqPos->idx = idx;
-    seqPos->posInSequence = endPosInSequence;
-    ZSTD_memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, sizeof(repcodes_t));
-
-    iend -= bytesAdjustment;
-    if (ip != iend) {
-        /* Store any last literals */
-        U32 lastLLSize = (U32)(iend - ip);
-        assert(ip <= iend);
-        DEBUGLOG(6, "Storing last literals of size: %u", lastLLSize);
-        ZSTD_storeLastLiterals(&cctx->seqStore, ip, lastLLSize);
-        seqPos->posInSrc += lastLLSize;
-    }
-
-    return bytesAdjustment;
-}
-
-typedef size_t (*ZSTD_sequenceCopier) (ZSTD_CCtx* cctx, ZSTD_sequencePosition* seqPos,
-                                       const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
-                                       const void* src, size_t blockSize, ZSTD_paramSwitch_e externalRepSearch);
-static ZSTD_sequenceCopier ZSTD_selectSequenceCopier(ZSTD_sequenceFormat_e mode)
-{
-    ZSTD_sequenceCopier sequenceCopier = NULL;
-    assert(ZSTD_cParam_withinBounds(ZSTD_c_blockDelimiters, mode));
-    if (mode == ZSTD_sf_explicitBlockDelimiters) {
-        return ZSTD_copySequencesToSeqStoreExplicitBlockDelim;
-    } else if (mode == ZSTD_sf_noBlockDelimiters) {
-        return ZSTD_copySequencesToSeqStoreNoBlockDelim;
-    }
-    assert(sequenceCopier != NULL);
-    return sequenceCopier;
-}
-
-/* Discover the size of next block by searching for the delimiter.
- * Note that a block delimiter **must** exist in this mode,
- * otherwise it's an input error.
- * The block size retrieved will be later compared to ensure it remains within bounds */
-static size_t
-blockSize_explicitDelimiter(const ZSTD_Sequence* inSeqs, size_t inSeqsSize, ZSTD_sequencePosition seqPos)
-{
-    int end = 0;
-    size_t blockSize = 0;
-    size_t spos = seqPos.idx;
-    DEBUGLOG(6, "blockSize_explicitDelimiter : seq %zu / %zu", spos, inSeqsSize);
-    assert(spos <= inSeqsSize);
-    while (spos < inSeqsSize) {
-        end = (inSeqs[spos].offset == 0);
-        blockSize += inSeqs[spos].litLength + inSeqs[spos].matchLength;
-        if (end) {
-            if (inSeqs[spos].matchLength != 0)
-                RETURN_ERROR(externalSequences_invalid, "delimiter format error : both matchlength and offset must be == 0");
-            break;
-        }
-        spos++;
-    }
-    if (!end)
-        RETURN_ERROR(externalSequences_invalid, "Reached end of sequences without finding a block delimiter");
-    return blockSize;
-}
-
-/* More a "target" block size */
-static size_t blockSize_noDelimiter(size_t blockSize, size_t remaining)
-{
-    int const lastBlock = (remaining <= blockSize);
-    return lastBlock ? remaining : blockSize;
-}
-
-static size_t determine_blockSize(ZSTD_sequenceFormat_e mode,
-                           size_t blockSize, size_t remaining,
-                     const ZSTD_Sequence* inSeqs, size_t inSeqsSize, ZSTD_sequencePosition seqPos)
-{
-    DEBUGLOG(6, "determine_blockSize : remainingSize = %zu", remaining);
-    if (mode == ZSTD_sf_noBlockDelimiters)
-        return blockSize_noDelimiter(blockSize, remaining);
-    {   size_t const explicitBlockSize = blockSize_explicitDelimiter(inSeqs, inSeqsSize, seqPos);
-        FORWARD_IF_ERROR(explicitBlockSize, "Error while determining block size with explicit delimiters");
-        if (explicitBlockSize > blockSize)
-            RETURN_ERROR(externalSequences_invalid, "sequences incorrectly define a too large block");
-        if (explicitBlockSize > remaining)
-            RETURN_ERROR(externalSequences_invalid, "sequences define a frame longer than source");
-        return explicitBlockSize;
-    }
-}
-
-/* Compress, block-by-block, all of the sequences given.
- *
- * Returns the cumulative size of all compressed blocks (including their headers),
- * otherwise a ZSTD error.
- */
-static size_t
-ZSTD_compressSequences_internal(ZSTD_CCtx* cctx,
-                                void* dst, size_t dstCapacity,
-                          const ZSTD_Sequence* inSeqs, size_t inSeqsSize,
-                          const void* src, size_t srcSize)
-{
-    size_t cSize = 0;
-    size_t remaining = srcSize;
-    ZSTD_sequencePosition seqPos = {0, 0, 0};
-
-    BYTE const* ip = (BYTE const*)src;
-    BYTE* op = (BYTE*)dst;
-    ZSTD_sequenceCopier const sequenceCopier = ZSTD_selectSequenceCopier(cctx->appliedParams.blockDelimiters);
-
-    DEBUGLOG(4, "ZSTD_compressSequences_internal srcSize: %zu, inSeqsSize: %zu", srcSize, inSeqsSize);
-    /* Special case: empty frame */
-    if (remaining == 0) {
-        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1);
-        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "No room for empty frame block header");
-        MEM_writeLE32(op, cBlockHeader24);
-        op += ZSTD_blockHeaderSize;
-        dstCapacity -= ZSTD_blockHeaderSize;
-        cSize += ZSTD_blockHeaderSize;
-    }
-
-    while (remaining) {
-        size_t compressedSeqsSize;
-        size_t cBlockSize;
-        size_t additionalByteAdjustment;
-        size_t blockSize = determine_blockSize(cctx->appliedParams.blockDelimiters,
-                                        cctx->blockSize, remaining,
-                                        inSeqs, inSeqsSize, seqPos);
-        U32 const lastBlock = (blockSize == remaining);
-        FORWARD_IF_ERROR(blockSize, "Error while trying to determine block size");
-        assert(blockSize <= remaining);
-        ZSTD_resetSeqStore(&cctx->seqStore);
-        DEBUGLOG(5, "Working on new block. Blocksize: %zu (total:%zu)", blockSize, (ip - (const BYTE*)src) + blockSize);
-
-        additionalByteAdjustment = sequenceCopier(cctx, &seqPos, inSeqs, inSeqsSize, ip, blockSize, cctx->appliedParams.searchForExternalRepcodes);
-        FORWARD_IF_ERROR(additionalByteAdjustment, "Bad sequence copy");
-        blockSize -= additionalByteAdjustment;
-
-        /* If blocks are too small, emit as a nocompress block */
-        /* TODO: See 3090. We reduced MIN_CBLOCK_SIZE from 3 to 2 so to compensate we are adding
-         * additional 1. We need to revisit and change this logic to be more consistent */
-        if (blockSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1+1) {
-            cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
-            FORWARD_IF_ERROR(cBlockSize, "Nocompress block failed");
-            DEBUGLOG(5, "Block too small, writing out nocompress block: cSize: %zu", cBlockSize);
-            cSize += cBlockSize;
-            ip += blockSize;
-            op += cBlockSize;
-            remaining -= blockSize;
-            dstCapacity -= cBlockSize;
-            continue;
-        }
-
-        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall, "not enough dstCapacity to write a new compressed block");
-        compressedSeqsSize = ZSTD_entropyCompressSeqStore(&cctx->seqStore,
-                                &cctx->blockState.prevCBlock->entropy, &cctx->blockState.nextCBlock->entropy,
-                                &cctx->appliedParams,
-                                op + ZSTD_blockHeaderSize /* Leave space for block header */, dstCapacity - ZSTD_blockHeaderSize,
-                                blockSize,
-                                cctx->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
-                                cctx->bmi2);
-        FORWARD_IF_ERROR(compressedSeqsSize, "Compressing sequences of block failed");
-        DEBUGLOG(5, "Compressed sequences size: %zu", compressedSeqsSize);
-
-        if (!cctx->isFirstBlock &&
-            ZSTD_maybeRLE(&cctx->seqStore) &&
-            ZSTD_isRLE(ip, blockSize)) {
-            /* We don't want to emit our first block as a RLE even if it qualifies because
-            * doing so will cause the decoder (cli only) to throw a "should consume all input error."
-            * This is only an issue for zstd <= v1.4.3
-            */
-            compressedSeqsSize = 1;
-        }
-
-        if (compressedSeqsSize == 0) {
-            /* ZSTD_noCompressBlock writes the block header as well */
-            cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
-            FORWARD_IF_ERROR(cBlockSize, "ZSTD_noCompressBlock failed");
-            DEBUGLOG(5, "Writing out nocompress block, size: %zu", cBlockSize);
-        } else if (compressedSeqsSize == 1) {
-            cBlockSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, blockSize, lastBlock);
-            FORWARD_IF_ERROR(cBlockSize, "ZSTD_rleCompressBlock failed");
-            DEBUGLOG(5, "Writing out RLE block, size: %zu", cBlockSize);
-        } else {
-            U32 cBlockHeader;
-            /* Error checking and repcodes update */
-            ZSTD_blockState_confirmRepcodesAndEntropyTables(&cctx->blockState);
-            if (cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
-                cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
-
-            /* Write block header into beginning of block*/
-            cBlockHeader = lastBlock + (((U32)bt_compressed)<<1) + (U32)(compressedSeqsSize << 3);
-            MEM_writeLE24(op, cBlockHeader);
-            cBlockSize = ZSTD_blockHeaderSize + compressedSeqsSize;
-            DEBUGLOG(5, "Writing out compressed block, size: %zu", cBlockSize);
-        }
-
-        cSize += cBlockSize;
-
-        if (lastBlock) {
-            break;
-        } else {
-            ip += blockSize;
-            op += cBlockSize;
-            remaining -= blockSize;
-            dstCapacity -= cBlockSize;
-            cctx->isFirstBlock = 0;
-        }
-        DEBUGLOG(5, "cSize running total: %zu (remaining dstCapacity=%zu)", cSize, dstCapacity);
-    }
-
-    DEBUGLOG(4, "cSize final total: %zu", cSize);
-    return cSize;
-}
-
-size_t ZSTD_compressSequences(ZSTD_CCtx* cctx,
-                              void* dst, size_t dstCapacity,
-                              const ZSTD_Sequence* inSeqs, size_t inSeqsSize,
-                              const void* src, size_t srcSize)
-{
-    BYTE* op = (BYTE*)dst;
-    size_t cSize = 0;
-    size_t compressedBlocksSize = 0;
-    size_t frameHeaderSize = 0;
-
-    /* Transparent initialization stage, same as compressStream2() */
-    DEBUGLOG(4, "ZSTD_compressSequences (dstCapacity=%zu)", dstCapacity);
-    assert(cctx != NULL);
-    FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, srcSize), "CCtx initialization failed");
-    /* Begin writing output, starting with frame header */
-    frameHeaderSize = ZSTD_writeFrameHeader(op, dstCapacity, &cctx->appliedParams, srcSize, cctx->dictID);
-    op += frameHeaderSize;
-    dstCapacity -= frameHeaderSize;
-    cSize += frameHeaderSize;
-    if (cctx->appliedParams.fParams.checksumFlag && srcSize) {
-        XXH64_update(&cctx->xxhState, src, srcSize);
-    }
-    /* cSize includes block header size and compressed sequences size */
-    compressedBlocksSize = ZSTD_compressSequences_internal(cctx,
-                                                           op, dstCapacity,
-                                                           inSeqs, inSeqsSize,
-                                                           src, srcSize);
-    FORWARD_IF_ERROR(compressedBlocksSize, "Compressing blocks failed!");
-    cSize += compressedBlocksSize;
-    dstCapacity -= compressedBlocksSize;
-
-    if (cctx->appliedParams.fParams.checksumFlag) {
-        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
-        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");
-        DEBUGLOG(4, "Write checksum : %08X", (unsigned)checksum);
-        MEM_writeLE32((char*)dst + cSize, checksum);
-        cSize += 4;
-    }
-
-    DEBUGLOG(4, "Final compressed size: %zu", cSize);
-    return cSize;
-}
-
-/*======   Finalize   ======*/
-
-static ZSTD_inBuffer inBuffer_forEndFlush(const ZSTD_CStream* zcs)
-{
-    const ZSTD_inBuffer nullInput = { NULL, 0, 0 };
-    const int stableInput = (zcs->appliedParams.inBufferMode == ZSTD_bm_stable);
-    return stableInput ? zcs->expectedInBuffer : nullInput;
-}
-
-/*! ZSTD_flushStream() :
- * @return : amount of data remaining to flush */
-size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
-{
-    ZSTD_inBuffer input = inBuffer_forEndFlush(zcs);
-    input.size = input.pos; /* do not ingest more input during flush */
-    return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
-}
-
-
-size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
-{
-    ZSTD_inBuffer input = inBuffer_forEndFlush(zcs);
-    size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
-    FORWARD_IF_ERROR(remainingToFlush , "ZSTD_compressStream2(,,ZSTD_e_end) failed");
-    if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush;   /* minimal estimation */
-    /* single thread mode : attempt to calculate remaining to flush more precisely */
-    {   size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
-        size_t const checksumSize = (size_t)(zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4);
-        size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;
-        DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
-        return toFlush;
-    }
-}
-
-} // namespace duckdb_zstd
-
-/*-=====  Pre-defined compression levels  =====-*/
-#include "zstd/compress/clevels.h"
-
-namespace duckdb_zstd {
-
-int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
-int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
-int ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }
-
-static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
-{
-    ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, 0, dictSize, ZSTD_cpm_createCDict);
-    switch (cParams.strategy) {
-        case ZSTD_fast:
-        case ZSTD_dfast:
-            break;
-        case ZSTD_greedy:
-        case ZSTD_lazy:
-        case ZSTD_lazy2:
-            cParams.hashLog += ZSTD_LAZY_DDSS_BUCKET_LOG;
-            break;
-        case ZSTD_btlazy2:
-        case ZSTD_btopt:
-        case ZSTD_btultra:
-        case ZSTD_btultra2:
-            break;
-    }
-    return cParams;
-}
-
-static int ZSTD_dedicatedDictSearch_isSupported(
-        ZSTD_compressionParameters const* cParams)
-{
-    return (cParams->strategy >= ZSTD_greedy)
-        && (cParams->strategy <= ZSTD_lazy2)
-        && (cParams->hashLog > cParams->chainLog)
-        && (cParams->chainLog <= 24);
-}
-
-/**
- * Reverses the adjustment applied to cparams when enabling dedicated dict
- * search. This is used to recover the params set to be used in the working
- * context. (Otherwise, those tables would also grow.)
- */
-static void ZSTD_dedicatedDictSearch_revertCParams(
-        ZSTD_compressionParameters* cParams) {
-    switch (cParams->strategy) {
-        case ZSTD_fast:
-        case ZSTD_dfast:
-            break;
-        case ZSTD_greedy:
-        case ZSTD_lazy:
-        case ZSTD_lazy2:
-            cParams->hashLog -= ZSTD_LAZY_DDSS_BUCKET_LOG;
-            if (cParams->hashLog < ZSTD_HASHLOG_MIN) {
-                cParams->hashLog = ZSTD_HASHLOG_MIN;
-            }
-            break;
-        case ZSTD_btlazy2:
-        case ZSTD_btopt:
-        case ZSTD_btultra:
-        case ZSTD_btultra2:
-            break;
-    }
-}
-
-static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
-{
-    switch (mode) {
-    case ZSTD_cpm_unknown:
-    case ZSTD_cpm_noAttachDict:
-    case ZSTD_cpm_createCDict:
-        break;
-    case ZSTD_cpm_attachDict:
-        dictSize = 0;
-        break;
-    default:
-        assert(0);
-        break;
-    }
-    {   int const unknown = srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN;
-        size_t const addedSize = unknown && dictSize > 0 ? 500 : 0;
-        return unknown && dictSize == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : srcSizeHint+dictSize+addedSize;
-    }
-}
-
-/*! ZSTD_getCParams_internal() :
- * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
- *  Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.
- *        Use dictSize == 0 for unknown or unused.
- *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_cParamMode_e`. */
-static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
-{
-    U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
-    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
-    int row;
-    DEBUGLOG(5, "ZSTD_getCParams_internal (cLevel=%i)", compressionLevel);
-
-    /* row */
-    if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */
-    else if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */
-    else if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
-    else row = compressionLevel;
-
-    {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
-        DEBUGLOG(5, "ZSTD_getCParams_internal selected tableID: %u row: %u strat: %u", tableID, row, (U32)cp.strategy);
-        /* acceleration factor */
-        if (compressionLevel < 0) {
-            int const clampedCompressionLevel = MAX(ZSTD_minCLevel(), compressionLevel);
-            cp.targetLength = (unsigned)(-clampedCompressionLevel);
-        }
-        /* refine parameters based on srcSize & dictSize */
-        return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
-    }
-}
-
-/*! ZSTD_getCParams() :
- * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
- *  Size values are optional, provide 0 if not known or unused */
-ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
-{
-    if (srcSizeHint == 0) srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;
-    return ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown);
-}
-
-/*! ZSTD_getParams() :
- *  same idea as ZSTD_getCParams()
- * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
- *  Fields of `ZSTD_frameParameters` are set to default values */
-static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode) {
-    ZSTD_parameters params;
-    ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
-    DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
-    ZSTD_memset(&params, 0, sizeof(params));
-    params.cParams = cParams;
-    params.fParams.contentSizeFlag = 1;
-    return params;
-}
-
-/*! ZSTD_getParams() :
- *  same idea as ZSTD_getCParams()
- * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
- *  Fields of `ZSTD_frameParameters` are set to default values */
-ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) {
-    if (srcSizeHint == 0) srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;
-    return ZSTD_getParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown);
-}
-
-void ZSTD_registerSequenceProducer(
-    ZSTD_CCtx* zc,
-    void* extSeqProdState,
-    ZSTD_sequenceProducer_F extSeqProdFunc
-) {
-    assert(zc != NULL);
-    ZSTD_CCtxParams_registerSequenceProducer(
-        &zc->requestedParams, extSeqProdState, extSeqProdFunc
-    );
-}
-
-void ZSTD_CCtxParams_registerSequenceProducer(
-  ZSTD_CCtx_params* params,
-  void* extSeqProdState,
-  ZSTD_sequenceProducer_F extSeqProdFunc
-) {
-    assert(params != NULL);
-    if (extSeqProdFunc != NULL) {
-        params->extSeqProdFunc = extSeqProdFunc;
-        params->extSeqProdState = extSeqProdState;
-    } else {
-        params->extSeqProdFunc = NULL;
-        params->extSeqProdState = NULL;
-    }
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp b/src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp
deleted file mode 100644
index b68340da7..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
- /*-*************************************
- *  Dependencies
- ***************************************/
-#include "zstd/compress/zstd_compress_literals.h"
-
-namespace duckdb_zstd {
-
-/* **************************************************************
-*  Debug Traces
-****************************************************************/
-#if DEBUGLEVEL >= 2
-
-static size_t showHexa(const void* src, size_t srcSize)
-{
-    const BYTE* const ip = (const BYTE*)src;
-    size_t u;
-    for (u=0; u<srcSize; u++) {
-        RAWLOG(5, " %02X", ip[u]); (void)ip;
-    }
-    RAWLOG(5, " \n");
-    return srcSize;
-}
-
-#endif
-
-
-/* **************************************************************
-*  Literals compression - special cases
-****************************************************************/
-size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);
-
-    DEBUGLOG(5, "ZSTD_noCompressLiterals: srcSize=%zu, dstCapacity=%zu", srcSize, dstCapacity);
-
-    RETURN_ERROR_IF(srcSize + flSize > dstCapacity, dstSize_tooSmall, "");
-
-    switch(flSize)
-    {
-        case 1: /* 2 - 1 - 5 */
-            ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));
-            break;
-        case 2: /* 2 - 2 - 12 */
-            MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));
-            break;
-        case 3: /* 2 - 2 - 20 */
-            MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));
-            break;
-        default:   /* not necessary : flSize is {1,2,3} */
-            assert(0);
-    }
-
-    ZSTD_memcpy(ostart + flSize, src, srcSize);
-    DEBUGLOG(5, "Raw (uncompressed) literals: %u -> %u", (U32)srcSize, (U32)(srcSize + flSize));
-    return srcSize + flSize;
-}
-
-static int allBytesIdentical(const void* src, size_t srcSize)
-{
-    assert(srcSize >= 1);
-    assert(src != NULL);
-    {   const BYTE b = ((const BYTE*)src)[0];
-        size_t p;
-        for (p=1; p<srcSize; p++) {
-            if (((const BYTE*)src)[p] != b) return 0;
-        }
-        return 1;
-    }
-}
-
-size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);
-
-    assert(dstCapacity >= 4); (void)dstCapacity;
-    assert(allBytesIdentical(src, srcSize));
-
-    switch(flSize)
-    {
-        case 1: /* 2 - 1 - 5 */
-            ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));
-            break;
-        case 2: /* 2 - 2 - 12 */
-            MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));
-            break;
-        case 3: /* 2 - 2 - 20 */
-            MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));
-            break;
-        default:   /* not necessary : flSize is {1,2,3} */
-            assert(0);
-    }
-
-    ostart[flSize] = *(const BYTE*)src;
-    DEBUGLOG(5, "RLE : Repeated Literal (%02X: %u times) -> %u bytes encoded", ((const BYTE*)src)[0], (U32)srcSize, (U32)flSize + 1);
-    return flSize+1;
-}
-
-/* ZSTD_minLiteralsToCompress() :
- * returns minimal amount of literals
- * for literal compression to even be attempted.
- * Minimum is made tighter as compression strategy increases.
- */
-static size_t
-ZSTD_minLiteralsToCompress(ZSTD_strategy strategy, HUF_repeat huf_repeat)
-{
-    assert((int)strategy >= 0);
-    assert((int)strategy <= 9);
-    /* btultra2 : min 8 bytes;
-     * then 2x larger for each successive compression strategy
-     * max threshold 64 bytes */
-    {   int const shift = MIN(9-(int)strategy, 3);
-        size_t const mintc = (huf_repeat == HUF_repeat_valid) ? 6 : (size_t)8 << shift;
-        DEBUGLOG(7, "minLiteralsToCompress = %zu", mintc);
-        return mintc;
-    }
-}
-
-size_t ZSTD_compressLiterals (
-                  void* dst, size_t dstCapacity,
-            const void* src, size_t srcSize,
-                  void* entropyWorkspace, size_t entropyWorkspaceSize,
-            const ZSTD_hufCTables_t* prevHuf,
-                  ZSTD_hufCTables_t* nextHuf,
-                  ZSTD_strategy strategy,
-                  int disableLiteralCompression,
-                  int suspectUncompressible,
-                  int bmi2)
-{
-    size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
-    BYTE*  const ostart = (BYTE*)dst;
-    U32 singleStream = srcSize < 256;
-    symbolEncodingType_e hType = set_compressed;
-    size_t cLitSize;
-
-    DEBUGLOG(5,"ZSTD_compressLiterals (disableLiteralCompression=%i, srcSize=%u, dstCapacity=%zu)",
-                disableLiteralCompression, (U32)srcSize, dstCapacity);
-
-    DEBUGLOG(6, "Completed literals listing (%zu bytes)", showHexa(src, srcSize));
-
-    /* Prepare nextEntropy assuming reusing the existing table */
-    ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-
-    if (disableLiteralCompression)
-        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-
-    /* if too small, don't even attempt compression (speed opt) */
-    if (srcSize < ZSTD_minLiteralsToCompress(strategy, prevHuf->repeatMode))
-        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-
-    RETURN_ERROR_IF(dstCapacity < lhSize+1, dstSize_tooSmall, "not enough space for compression");
-    {   HUF_repeat repeat = prevHuf->repeatMode;
-        int const flags = 0
-            | (bmi2 ? HUF_flags_bmi2 : 0)
-            | (strategy < ZSTD_lazy && srcSize <= 1024 ? HUF_flags_preferRepeat : 0)
-            | (strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD ? HUF_flags_optimalDepth : 0)
-            | (suspectUncompressible ? HUF_flags_suspectUncompressible : 0);
-
-        typedef size_t (*huf_compress_f)(void*, size_t, const void*, size_t, unsigned, unsigned, void*, size_t, HUF_CElt*, HUF_repeat*, int);
-        huf_compress_f huf_compress;
-        if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
-        huf_compress = singleStream ? HUF_compress1X_repeat : HUF_compress4X_repeat;
-        cLitSize = huf_compress(ostart+lhSize, dstCapacity-lhSize,
-                                src, srcSize,
-                                HUF_SYMBOLVALUE_MAX, LitHufLog,
-                                entropyWorkspace, entropyWorkspaceSize,
-                                (HUF_CElt*)nextHuf->CTable,
-                                &repeat, flags);
-        DEBUGLOG(5, "%zu literals compressed into %zu bytes (before header)", srcSize, cLitSize);
-        if (repeat != HUF_repeat_none) {
-            /* reused the existing table */
-            DEBUGLOG(5, "reusing statistics from previous huffman block");
-            hType = set_repeat;
-        }
-    }
-
-    {   size_t const minGain = ZSTD_minGain(srcSize, strategy);
-        if ((cLitSize==0) || (cLitSize >= srcSize - minGain) || ERR_isError(cLitSize)) {
-            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-            return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-    }   }
-    if (cLitSize==1) {
-        /* A return value of 1 signals that the alphabet consists of a single symbol.
-         * However, in some rare circumstances, it could be the compressed size (a single byte).
-         * For that outcome to have a chance to happen, it's necessary that `srcSize < 8`.
-         * (it's also necessary to not generate statistics).
-         * Therefore, in such a case, actively check that all bytes are identical. */
-        if ((srcSize >= 8) || allBytesIdentical(src, srcSize)) {
-            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-            return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);
-    }   }
-
-    if (hType == set_compressed) {
-        /* using a newly constructed table */
-        nextHuf->repeatMode = HUF_repeat_check;
-    }
-
-    /* Build header */
-    switch(lhSize)
-    {
-    case 3: /* 2 - 2 - 10 - 10 */
-        if (!singleStream) assert(srcSize >= MIN_LITERALS_FOR_4_STREAMS);
-        {   U32 const lhc = hType + ((U32)(!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);
-            MEM_writeLE24(ostart, lhc);
-            break;
-        }
-    case 4: /* 2 - 2 - 14 - 14 */
-        assert(srcSize >= MIN_LITERALS_FOR_4_STREAMS);
-        {   U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);
-            MEM_writeLE32(ostart, lhc);
-            break;
-        }
-    case 5: /* 2 - 2 - 18 - 18 */
-        assert(srcSize >= MIN_LITERALS_FOR_4_STREAMS);
-        {   U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);
-            MEM_writeLE32(ostart, lhc);
-            ostart[4] = (BYTE)(cLitSize >> 10);
-            break;
-        }
-    default:  /* not possible : lhSize is {3,4,5} */
-        assert(0);
-    }
-    DEBUGLOG(5, "Compressed literals: %u -> %u", (U32)srcSize, (U32)(lhSize+cLitSize));
-    return lhSize+cLitSize;
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp b/src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp
deleted file mode 100644
index 0ab822622..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
- /*-*************************************
- *  Dependencies
- ***************************************/
-#include "zstd/compress/zstd_compress_sequences.h"
-
-namespace duckdb_zstd {
-
-/**
- * -log2(x / 256) lookup table for x in [0, 256).
- * If x == 0: Return 0
- * Else: Return floor(-log2(x / 256) * 256)
- */
-static unsigned const kInverseProbabilityLog256[256] = {
-    0,    2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 1236, 1197, 1162,
-    1130, 1100, 1073, 1047, 1024, 1001, 980,  960,  941,  923,  906,  889,
-    874,  859,  844,  830,  817,  804,  791,  779,  768,  756,  745,  734,
-    724,  714,  704,  694,  685,  676,  667,  658,  650,  642,  633,  626,
-    618,  610,  603,  595,  588,  581,  574,  567,  561,  554,  548,  542,
-    535,  529,  523,  517,  512,  506,  500,  495,  489,  484,  478,  473,
-    468,  463,  458,  453,  448,  443,  438,  434,  429,  424,  420,  415,
-    411,  407,  402,  398,  394,  390,  386,  382,  377,  373,  370,  366,
-    362,  358,  354,  350,  347,  343,  339,  336,  332,  329,  325,  322,
-    318,  315,  311,  308,  305,  302,  298,  295,  292,  289,  286,  282,
-    279,  276,  273,  270,  267,  264,  261,  258,  256,  253,  250,  247,
-    244,  241,  239,  236,  233,  230,  228,  225,  222,  220,  217,  215,
-    212,  209,  207,  204,  202,  199,  197,  194,  192,  190,  187,  185,
-    182,  180,  178,  175,  173,  171,  168,  166,  164,  162,  159,  157,
-    155,  153,  151,  149,  146,  144,  142,  140,  138,  136,  134,  132,
-    130,  128,  126,  123,  121,  119,  117,  115,  114,  112,  110,  108,
-    106,  104,  102,  100,  98,   96,   94,   93,   91,   89,   87,   85,
-    83,   82,   80,   78,   76,   74,   73,   71,   69,   67,   66,   64,
-    62,   61,   59,   57,   55,   54,   52,   50,   49,   47,   46,   44,
-    42,   41,   39,   37,   36,   34,   33,   31,   30,   28,   26,   25,
-    23,   22,   20,   19,   17,   16,   14,   13,   11,   10,   8,    7,
-    5,    4,    2,    1,
-};
-
-static unsigned ZSTD_getFSEMaxSymbolValue(FSE_CTable const* ctable) {
-  void const* ptr = ctable;
-  U16 const* u16ptr = (U16 const*)ptr;
-  U32 const maxSymbolValue = MEM_read16(u16ptr + 1);
-  return maxSymbolValue;
-}
-
-/**
- * Returns true if we should use ncount=-1 else we should
- * use ncount=1 for low probability symbols instead.
- */
-static unsigned ZSTD_useLowProbCount(size_t const nbSeq)
-{
-    /* Heuristic: This should cover most blocks <= 16K and
-     * start to fade out after 16K to about 32K depending on
-     * compressibility.
-     */
-    return nbSeq >= 2048;
-}
-
-/**
- * Returns the cost in bytes of encoding the normalized count header.
- * Returns an error if any of the helper functions return an error.
- */
-static size_t ZSTD_NCountCost(unsigned const* count, unsigned const max,
-                              size_t const nbSeq, unsigned const FSELog)
-{
-    BYTE wksp[FSE_NCOUNTBOUND];
-    S16 norm[MaxSeq + 1];
-    const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
-    FORWARD_IF_ERROR(FSE_normalizeCount(norm, tableLog, count, nbSeq, max, ZSTD_useLowProbCount(nbSeq)), "");
-    return FSE_writeNCount(wksp, sizeof(wksp), norm, max, tableLog);
-}
-
-/**
- * Returns the cost in bits of encoding the distribution described by count
- * using the entropy bound.
- */
-static size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t const total)
-{
-    unsigned cost = 0;
-    unsigned s;
-
-    assert(total > 0);
-    for (s = 0; s <= max; ++s) {
-        unsigned norm = (unsigned)((256 * count[s]) / total);
-        if (count[s] != 0 && norm == 0)
-            norm = 1;
-        assert(count[s] < total);
-        cost += count[s] * kInverseProbabilityLog256[norm];
-    }
-    return cost >> 8;
-}
-
-/**
- * Returns the cost in bits of encoding the distribution in count using ctable.
- * Returns an error if ctable cannot represent all the symbols in count.
- */
-size_t ZSTD_fseBitCost(
-    FSE_CTable const* ctable,
-    unsigned const* count,
-    unsigned const max)
-{
-    unsigned const kAccuracyLog = 8;
-    size_t cost = 0;
-    unsigned s;
-    FSE_CState_t cstate;
-    FSE_initCState(&cstate, ctable);
-    if (ZSTD_getFSEMaxSymbolValue(ctable) < max) {
-        DEBUGLOG(5, "Repeat FSE_CTable has maxSymbolValue %u < %u",
-                    ZSTD_getFSEMaxSymbolValue(ctable), max);
-        return ERROR(GENERIC);
-    }
-    for (s = 0; s <= max; ++s) {
-        unsigned const tableLog = cstate.stateLog;
-        unsigned const badCost = (tableLog + 1) << kAccuracyLog;
-        unsigned const bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog);
-        if (count[s] == 0)
-            continue;
-        if (bitCost >= badCost) {
-            DEBUGLOG(5, "Repeat FSE_CTable has Prob[%u] == 0", s);
-            return ERROR(GENERIC);
-        }
-        cost += (size_t)count[s] * bitCost;
-    }
-    return cost >> kAccuracyLog;
-}
-
-/**
- * Returns the cost in bits of encoding the distribution in count using the
- * table described by norm. The max symbol support by norm is assumed >= max.
- * norm must be valid for every symbol with non-zero probability in count.
- */
-size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
-                             unsigned const* count, unsigned const max)
-{
-    unsigned const shift = 8 - accuracyLog;
-    size_t cost = 0;
-    unsigned s;
-    assert(accuracyLog <= 8);
-    for (s = 0; s <= max; ++s) {
-        unsigned const normAcc = (norm[s] != -1) ? (unsigned)norm[s] : 1;
-        unsigned const norm256 = normAcc << shift;
-        assert(norm256 > 0);
-        assert(norm256 < 256);
-        cost += count[s] * kInverseProbabilityLog256[norm256];
-    }
-    return cost >> 8;
-}
-
-symbolEncodingType_e
-ZSTD_selectEncodingType(
-        FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
-        size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
-        FSE_CTable const* prevCTable,
-        short const* defaultNorm, U32 defaultNormLog,
-        ZSTD_defaultPolicy_e const isDefaultAllowed,
-        ZSTD_strategy const strategy)
-{
-    ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);
-    if (mostFrequent == nbSeq) {
-        *repeatMode = FSE_repeat_none;
-        if (isDefaultAllowed && nbSeq <= 2) {
-            /* Prefer set_basic over set_rle when there are 2 or fewer symbols,
-             * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
-             * If basic encoding isn't possible, always choose RLE.
-             */
-            DEBUGLOG(5, "Selected set_basic");
-            return set_basic;
-        }
-        DEBUGLOG(5, "Selected set_rle");
-        return set_rle;
-    }
-    if (strategy < ZSTD_lazy) {
-        if (isDefaultAllowed) {
-            size_t const staticFse_nbSeq_max = 1000;
-            size_t const mult = 10 - strategy;
-            size_t const baseLog = 3;
-            size_t const dynamicFse_nbSeq_min = (((size_t)1 << defaultNormLog) * mult) >> baseLog;  /* 28-36 for offset, 56-72 for lengths */
-            assert(defaultNormLog >= 5 && defaultNormLog <= 6);  /* xx_DEFAULTNORMLOG */
-            assert(mult <= 9 && mult >= 7);
-            if ( (*repeatMode == FSE_repeat_valid)
-              && (nbSeq < staticFse_nbSeq_max) ) {
-                DEBUGLOG(5, "Selected set_repeat");
-                return set_repeat;
-            }
-            if ( (nbSeq < dynamicFse_nbSeq_min)
-              || (mostFrequent < (nbSeq >> (defaultNormLog-1))) ) {
-                DEBUGLOG(5, "Selected set_basic");
-                /* The format allows default tables to be repeated, but it isn't useful.
-                 * When using simple heuristics to select encoding type, we don't want
-                 * to confuse these tables with dictionaries. When running more careful
-                 * analysis, we don't need to waste time checking both repeating tables
-                 * and default tables.
-                 */
-                *repeatMode = FSE_repeat_none;
-                return set_basic;
-            }
-        }
-    } else {
-        size_t const basicCost = isDefaultAllowed ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max) : ERROR(GENERIC);
-        size_t const repeatCost = *repeatMode != FSE_repeat_none ? ZSTD_fseBitCost(prevCTable, count, max) : ERROR(GENERIC);
-        size_t const NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog);
-        size_t const compressedCost = (NCountCost << 3) + ZSTD_entropyCost(count, max, nbSeq);
-
-        if (isDefaultAllowed) {
-            assert(!ZSTD_isError(basicCost));
-            assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost)));
-        }
-        assert(!ZSTD_isError(NCountCost));
-        assert(compressedCost < ERROR(maxCode));
-        DEBUGLOG(5, "Estimated bit costs: basic=%u\trepeat=%u\tcompressed=%u",
-                    (unsigned)basicCost, (unsigned)repeatCost, (unsigned)compressedCost);
-        if (basicCost <= repeatCost && basicCost <= compressedCost) {
-            DEBUGLOG(5, "Selected set_basic");
-            assert(isDefaultAllowed);
-            *repeatMode = FSE_repeat_none;
-            return set_basic;
-        }
-        if (repeatCost <= compressedCost) {
-            DEBUGLOG(5, "Selected set_repeat");
-            assert(!ZSTD_isError(repeatCost));
-            return set_repeat;
-        }
-        assert(compressedCost < basicCost && compressedCost < repeatCost);
-    }
-    DEBUGLOG(5, "Selected set_compressed");
-    *repeatMode = FSE_repeat_check;
-    return set_compressed;
-}
-
-typedef struct {
-    S16 norm[MaxSeq + 1];
-    U32 wksp[FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(MaxSeq, MaxFSELog)];
-} ZSTD_BuildCTableWksp;
-
-size_t
-ZSTD_buildCTable(void* dst, size_t dstCapacity,
-                FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
-                unsigned* count, U32 max,
-                const BYTE* codeTable, size_t nbSeq,
-                const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
-                const FSE_CTable* prevCTable, size_t prevCTableSize,
-                void* entropyWorkspace, size_t entropyWorkspaceSize)
-{
-    BYTE* op = (BYTE*)dst;
-    const BYTE* const oend = op + dstCapacity;
-    DEBUGLOG(6, "ZSTD_buildCTable (dstCapacity=%u)", (unsigned)dstCapacity);
-
-    switch (type) {
-    case set_rle:
-        FORWARD_IF_ERROR(FSE_buildCTable_rle(nextCTable, (BYTE)max), "");
-        RETURN_ERROR_IF(dstCapacity==0, dstSize_tooSmall, "not enough space");
-        *op = codeTable[0];
-        return 1;
-    case set_repeat:
-        ZSTD_memcpy(nextCTable, prevCTable, prevCTableSize);
-        return 0;
-    case set_basic:
-        FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, entropyWorkspace, entropyWorkspaceSize), "");  /* note : could be pre-calculated */
-        return 0;
-    case set_compressed: {
-        ZSTD_BuildCTableWksp* wksp = (ZSTD_BuildCTableWksp*)entropyWorkspace;
-        size_t nbSeq_1 = nbSeq;
-        const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
-        if (count[codeTable[nbSeq-1]] > 1) {
-            count[codeTable[nbSeq-1]]--;
-            nbSeq_1--;
-        }
-        assert(nbSeq_1 > 1);
-        assert(entropyWorkspaceSize >= sizeof(ZSTD_BuildCTableWksp));
-        (void)entropyWorkspaceSize;
-        FORWARD_IF_ERROR(FSE_normalizeCount(wksp->norm, tableLog, count, nbSeq_1, max, ZSTD_useLowProbCount(nbSeq_1)), "FSE_normalizeCount failed");
-        assert(oend >= op);
-        {   size_t const NCountSize = FSE_writeNCount(op, (size_t)(oend - op), wksp->norm, max, tableLog);   /* overflow protected */
-            FORWARD_IF_ERROR(NCountSize, "FSE_writeNCount failed");
-            FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, wksp->norm, max, tableLog, wksp->wksp, sizeof(wksp->wksp)), "FSE_buildCTable_wksp failed");
-            return NCountSize;
-        }
-    }
-    default: assert(0); RETURN_ERROR(GENERIC, "impossible to reach");
-    }
-}
-
-FORCE_INLINE_TEMPLATE size_t
-ZSTD_encodeSequences_body(
-            void* dst, size_t dstCapacity,
-            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
-            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
-            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
-            seqDef const* sequences, size_t nbSeq, int longOffsets)
-{
-    BIT_CStream_t blockStream;
-    FSE_CState_t  stateMatchLength;
-    FSE_CState_t  stateOffsetBits;
-    FSE_CState_t  stateLitLength;
-
-    RETURN_ERROR_IF(
-        ERR_isError(BIT_initCStream(&blockStream, dst, dstCapacity)),
-        dstSize_tooSmall, "not enough space remaining");
-    DEBUGLOG(6, "available space for bitstream : %i  (dstCapacity=%u)",
-                (int)(blockStream.endPtr - blockStream.startPtr),
-                (unsigned)dstCapacity);
-
-    /* first symbols */
-    FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
-    FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);
-    FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
-    BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
-    if (MEM_32bits()) BIT_flushBits(&blockStream);
-    BIT_addBits(&blockStream, sequences[nbSeq-1].mlBase, ML_bits[mlCodeTable[nbSeq-1]]);
-    if (MEM_32bits()) BIT_flushBits(&blockStream);
-    if (longOffsets) {
-        U32 const ofBits = ofCodeTable[nbSeq-1];
-        unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
-        if (extraBits) {
-            BIT_addBits(&blockStream, sequences[nbSeq-1].offBase, extraBits);
-            BIT_flushBits(&blockStream);
-        }
-        BIT_addBits(&blockStream, sequences[nbSeq-1].offBase >> extraBits,
-                    ofBits - extraBits);
-    } else {
-        BIT_addBits(&blockStream, sequences[nbSeq-1].offBase, ofCodeTable[nbSeq-1]);
-    }
-    BIT_flushBits(&blockStream);
-
-    {   size_t n;
-        for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */
-            BYTE const llCode = llCodeTable[n];
-            BYTE const ofCode = ofCodeTable[n];
-            BYTE const mlCode = mlCodeTable[n];
-            U32  const llBits = LL_bits[llCode];
-            U32  const ofBits = ofCode;
-            U32  const mlBits = ML_bits[mlCode];
-            DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u",
-                        (unsigned)sequences[n].litLength,
-                        (unsigned)sequences[n].mlBase + MINMATCH,
-                        (unsigned)sequences[n].offBase);
-                                                                            /* 32b*/  /* 64b*/
-                                                                            /* (7)*/  /* (7)*/
-            FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
-            FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
-            if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
-            FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
-            if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
-                BIT_flushBits(&blockStream);                                /* (7)*/
-            BIT_addBits(&blockStream, sequences[n].litLength, llBits);
-            if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
-            BIT_addBits(&blockStream, sequences[n].mlBase, mlBits);
-            if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream);
-            if (longOffsets) {
-                unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
-                if (extraBits) {
-                    BIT_addBits(&blockStream, sequences[n].offBase, extraBits);
-                    BIT_flushBits(&blockStream);                            /* (7)*/
-                }
-                BIT_addBits(&blockStream, sequences[n].offBase >> extraBits,
-                            ofBits - extraBits);                            /* 31 */
-            } else {
-                BIT_addBits(&blockStream, sequences[n].offBase, ofBits);     /* 31 */
-            }
-            BIT_flushBits(&blockStream);                                    /* (7)*/
-            DEBUGLOG(7, "remaining space : %i", (int)(blockStream.endPtr - blockStream.ptr));
-    }   }
-
-    DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog);
-    FSE_flushCState(&blockStream, &stateMatchLength);
-    DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog);
-    FSE_flushCState(&blockStream, &stateOffsetBits);
-    DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog);
-    FSE_flushCState(&blockStream, &stateLitLength);
-
-    {   size_t const streamSize = BIT_closeCStream(&blockStream);
-        RETURN_ERROR_IF(streamSize==0, dstSize_tooSmall, "not enough space");
-        return streamSize;
-    }
-}
-
-static size_t
-ZSTD_encodeSequences_default(
-            void* dst, size_t dstCapacity,
-            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
-            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
-            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
-            seqDef const* sequences, size_t nbSeq, int longOffsets)
-{
-    return ZSTD_encodeSequences_body(dst, dstCapacity,
-                                    CTable_MatchLength, mlCodeTable,
-                                    CTable_OffsetBits, ofCodeTable,
-                                    CTable_LitLength, llCodeTable,
-                                    sequences, nbSeq, longOffsets);
-}
-
-
-#if DYNAMIC_BMI2
-
-static BMI2_TARGET_ATTRIBUTE size_t
-ZSTD_encodeSequences_bmi2(
-            void* dst, size_t dstCapacity,
-            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
-            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
-            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
-            seqDef const* sequences, size_t nbSeq, int longOffsets)
-{
-    return ZSTD_encodeSequences_body(dst, dstCapacity,
-                                    CTable_MatchLength, mlCodeTable,
-                                    CTable_OffsetBits, ofCodeTable,
-                                    CTable_LitLength, llCodeTable,
-                                    sequences, nbSeq, longOffsets);
-}
-
-#endif
-
-size_t ZSTD_encodeSequences(
-            void* dst, size_t dstCapacity,
-            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
-            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
-            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
-            seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2)
-{
-    DEBUGLOG(5, "ZSTD_encodeSequences: dstCapacity = %u", (unsigned)dstCapacity);
-#if DYNAMIC_BMI2
-    if (bmi2) {
-        return ZSTD_encodeSequences_bmi2(dst, dstCapacity,
-                                         CTable_MatchLength, mlCodeTable,
-                                         CTable_OffsetBits, ofCodeTable,
-                                         CTable_LitLength, llCodeTable,
-                                         sequences, nbSeq, longOffsets);
-    }
-#endif
-    (void)bmi2;
-    return ZSTD_encodeSequences_default(dst, dstCapacity,
-                                        CTable_MatchLength, mlCodeTable,
-                                        CTable_OffsetBits, ofCodeTable,
-                                        CTable_LitLength, llCodeTable,
-                                        sequences, nbSeq, longOffsets);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp b/src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp
deleted file mode 100644
index 1ad0d3aa0..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp
+++ /dev/null
@@ -1,692 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
- /*-*************************************
- *  Dependencies
- ***************************************/
-#include "zstd/compress/zstd_compress_superblock.h"
-
-#include "zstd/common/zstd_internal.h"  /* ZSTD_getSequenceLength */
-#include "zstd/compress/hist.h"                     /* HIST_countFast_wksp */
-#include "zstd/compress/zstd_compress_internal.h"   /* ZSTD_[huf|fse|entropy]CTablesMetadata_t */
-#include "zstd/compress/zstd_compress_sequences.h"
-#include "zstd/compress/zstd_compress_literals.h"
-
-namespace duckdb_zstd {
-
-/** ZSTD_compressSubBlock_literal() :
- *  Compresses literals section for a sub-block.
- *  When we have to write the Huffman table we will sometimes choose a header
- *  size larger than necessary. This is because we have to pick the header size
- *  before we know the table size + compressed size, so we have a bound on the
- *  table size. If we guessed incorrectly, we fall back to uncompressed literals.
- *
- *  We write the header when writeEntropy=1 and set entropyWritten=1 when we succeeded
- *  in writing the header, otherwise it is set to 0.
- *
- *  hufMetadata->hType has literals block type info.
- *      If it is set_basic, all sub-blocks literals section will be Raw_Literals_Block.
- *      If it is set_rle, all sub-blocks literals section will be RLE_Literals_Block.
- *      If it is set_compressed, first sub-block's literals section will be Compressed_Literals_Block
- *      If it is set_compressed, first sub-block's literals section will be Treeless_Literals_Block
- *      and the following sub-blocks' literals sections will be Treeless_Literals_Block.
- *  @return : compressed size of literals section of a sub-block
- *            Or 0 if unable to compress.
- *            Or error code */
-static size_t
-ZSTD_compressSubBlock_literal(const HUF_CElt* hufTable,
-                              const ZSTD_hufCTablesMetadata_t* hufMetadata,
-                              const BYTE* literals, size_t litSize,
-                              void* dst, size_t dstSize,
-                              const int bmi2, int writeEntropy, int* entropyWritten)
-{
-    size_t const header = writeEntropy ? 200 : 0;
-    size_t const lhSize = 3 + (litSize >= (1 KB - header)) + (litSize >= (16 KB - header));
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart + lhSize;
-    U32 const singleStream = lhSize == 3;
-    symbolEncodingType_e hType = writeEntropy ? hufMetadata->hType : set_repeat;
-    size_t cLitSize = 0;
-
-    DEBUGLOG(5, "ZSTD_compressSubBlock_literal (litSize=%zu, lhSize=%zu, writeEntropy=%d)", litSize, lhSize, writeEntropy);
-
-    *entropyWritten = 0;
-    if (litSize == 0 || hufMetadata->hType == set_basic) {
-      DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal");
-      return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
-    } else if (hufMetadata->hType == set_rle) {
-      DEBUGLOG(5, "ZSTD_compressSubBlock_literal using rle literal");
-      return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize);
-    }
-
-    assert(litSize > 0);
-    assert(hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat);
-
-    if (writeEntropy && hufMetadata->hType == set_compressed) {
-        ZSTD_memcpy(op, hufMetadata->hufDesBuffer, hufMetadata->hufDesSize);
-        op += hufMetadata->hufDesSize;
-        cLitSize += hufMetadata->hufDesSize;
-        DEBUGLOG(5, "ZSTD_compressSubBlock_literal (hSize=%zu)", hufMetadata->hufDesSize);
-    }
-
-    {   int const flags = bmi2 ? HUF_flags_bmi2 : 0;
-        const size_t cSize = singleStream ? HUF_compress1X_usingCTable(op, (size_t)(oend-op), literals, litSize, hufTable, flags)
-                                          : HUF_compress4X_usingCTable(op, (size_t)(oend-op), literals, litSize, hufTable, flags);
-        op += cSize;
-        cLitSize += cSize;
-        if (cSize == 0 || ERR_isError(cSize)) {
-            DEBUGLOG(5, "Failed to write entropy tables %s", ZSTD_getErrorName(cSize));
-            return 0;
-        }
-        /* If we expand and we aren't writing a header then emit uncompressed */
-        if (!writeEntropy && cLitSize >= litSize) {
-            DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal because uncompressible");
-            return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
-        }
-        /* If we are writing headers then allow expansion that doesn't change our header size. */
-        if (lhSize < (size_t)(3 + (cLitSize >= 1 KB) + (cLitSize >= 16 KB))) {
-            assert(cLitSize > litSize);
-            DEBUGLOG(5, "Literals expanded beyond allowed header size");
-            return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
-        }
-        DEBUGLOG(5, "ZSTD_compressSubBlock_literal (cSize=%zu)", cSize);
-    }
-
-    /* Build header */
-    switch(lhSize)
-    {
-    case 3: /* 2 - 2 - 10 - 10 */
-        {   U32 const lhc = hType + ((U32)(!singleStream) << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<14);
-            MEM_writeLE24(ostart, lhc);
-            break;
-        }
-    case 4: /* 2 - 2 - 14 - 14 */
-        {   U32 const lhc = hType + (2 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<18);
-            MEM_writeLE32(ostart, lhc);
-            break;
-        }
-    case 5: /* 2 - 2 - 18 - 18 */
-        {   U32 const lhc = hType + (3 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<22);
-            MEM_writeLE32(ostart, lhc);
-            ostart[4] = (BYTE)(cLitSize >> 10);
-            break;
-        }
-    default:  /* not possible : lhSize is {3,4,5} */
-        assert(0);
-    }
-    *entropyWritten = 1;
-    DEBUGLOG(5, "Compressed literals: %u -> %u", (U32)litSize, (U32)(op-ostart));
-    return (size_t)(op-ostart);
-}
-
-static size_t
-ZSTD_seqDecompressedSize(seqStore_t const* seqStore,
-                   const seqDef* sequences, size_t nbSeqs,
-                         size_t litSize, int lastSubBlock)
-{
-    size_t matchLengthSum = 0;
-    size_t litLengthSum = 0;
-    size_t n;
-    for (n=0; n<nbSeqs; n++) {
-        const ZSTD_sequenceLength seqLen = ZSTD_getSequenceLength(seqStore, sequences+n);
-        litLengthSum += seqLen.litLength;
-        matchLengthSum += seqLen.matchLength;
-    }
-    DEBUGLOG(5, "ZSTD_seqDecompressedSize: %u sequences from %p: %u literals + %u matchlength",
-                (unsigned)nbSeqs, (const void*)sequences,
-                (unsigned)litLengthSum, (unsigned)matchLengthSum);
-    if (!lastSubBlock)
-        assert(litLengthSum == litSize);
-    else
-        assert(litLengthSum <= litSize);
-    (void)litLengthSum;
-    return matchLengthSum + litSize;
-}
-
-/** ZSTD_compressSubBlock_sequences() :
- *  Compresses sequences section for a sub-block.
- *  fseMetadata->llType, fseMetadata->ofType, and fseMetadata->mlType have
- *  symbol compression modes for the super-block.
- *  The first successfully compressed block will have these in its header.
- *  We set entropyWritten=1 when we succeed in compressing the sequences.
- *  The following sub-blocks will always have repeat mode.
- *  @return : compressed size of sequences section of a sub-block
- *            Or 0 if it is unable to compress
- *            Or error code. */
-static size_t
-ZSTD_compressSubBlock_sequences(const ZSTD_fseCTables_t* fseTables,
-                                const ZSTD_fseCTablesMetadata_t* fseMetadata,
-                                const seqDef* sequences, size_t nbSeq,
-                                const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
-                                const ZSTD_CCtx_params* cctxParams,
-                                void* dst, size_t dstCapacity,
-                                const int bmi2, int writeEntropy, int* entropyWritten)
-{
-    const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    BYTE* seqHead;
-
-    DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (nbSeq=%zu, writeEntropy=%d, longOffsets=%d)", nbSeq, writeEntropy, longOffsets);
-
-    *entropyWritten = 0;
-    /* Sequences Header */
-    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
-                    dstSize_tooSmall, "");
-    if (nbSeq < 128)
-        *op++ = (BYTE)nbSeq;
-    else if (nbSeq < LONGNBSEQ)
-        op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
-    else
-        op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
-    if (nbSeq==0) {
-        return (size_t)(op - ostart);
-    }
-
-    /* seqHead : flags for FSE encoding type */
-    seqHead = op++;
-
-    DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (seqHeadSize=%u)", (unsigned)(op-ostart));
-
-    if (writeEntropy) {
-        const U32 LLtype = fseMetadata->llType;
-        const U32 Offtype = fseMetadata->ofType;
-        const U32 MLtype = fseMetadata->mlType;
-        DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (fseTablesSize=%zu)", fseMetadata->fseTablesSize);
-        *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
-        ZSTD_memcpy(op, fseMetadata->fseTablesBuffer, fseMetadata->fseTablesSize);
-        op += fseMetadata->fseTablesSize;
-    } else {
-        const U32 repeat = set_repeat;
-        *seqHead = (BYTE)((repeat<<6) + (repeat<<4) + (repeat<<2));
-    }
-
-    {   size_t const bitstreamSize = ZSTD_encodeSequences(
-                                        op, (size_t)(oend - op),
-                                        fseTables->matchlengthCTable, mlCode,
-                                        fseTables->offcodeCTable, ofCode,
-                                        fseTables->litlengthCTable, llCode,
-                                        sequences, nbSeq,
-                                        longOffsets, bmi2);
-        FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
-        op += bitstreamSize;
-        /* zstd versions <= 1.3.4 mistakenly report corruption when
-         * FSE_readNCount() receives a buffer < 4 bytes.
-         * Fixed by https://github.com/facebook/zstd/pull/1146.
-         * This can happen when the last set_compressed table present is 2
-         * bytes and the bitstream is only one byte.
-         * In this exceedingly rare case, we will simply emit an uncompressed
-         * block, since it isn't worth optimizing.
-         */
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-        if (writeEntropy && fseMetadata->lastCountSize && fseMetadata->lastCountSize + bitstreamSize < 4) {
-            /* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
-            assert(fseMetadata->lastCountSize + bitstreamSize == 3);
-            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
-                        "emitting an uncompressed block.");
-            return 0;
-        }
-#endif
-        DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (bitstreamSize=%zu)", bitstreamSize);
-    }
-
-    /* zstd versions <= 1.4.0 mistakenly report error when
-     * sequences section body size is less than 3 bytes.
-     * Fixed by https://github.com/facebook/zstd/pull/1664.
-     * This can happen when the previous sequences section block is compressed
-     * with rle mode and the current block's sequences section is compressed
-     * with repeat mode where sequences section body size can be 1 byte.
-     */
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    if (op-seqHead < 4) {
-        DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.4.0 by emitting "
-                    "an uncompressed block when sequences are < 4 bytes");
-        return 0;
-    }
-#endif
-
-    *entropyWritten = 1;
-    return (size_t)(op - ostart);
-}
-
-/** ZSTD_compressSubBlock() :
- *  Compresses a single sub-block.
- *  @return : compressed size of the sub-block
- *            Or 0 if it failed to compress. */
-static size_t ZSTD_compressSubBlock(const ZSTD_entropyCTables_t* entropy,
-                                    const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
-                                    const seqDef* sequences, size_t nbSeq,
-                                    const BYTE* literals, size_t litSize,
-                                    const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
-                                    const ZSTD_CCtx_params* cctxParams,
-                                    void* dst, size_t dstCapacity,
-                                    const int bmi2,
-                                    int writeLitEntropy, int writeSeqEntropy,
-                                    int* litEntropyWritten, int* seqEntropyWritten,
-                                    U32 lastBlock)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart + ZSTD_blockHeaderSize;
-    DEBUGLOG(5, "ZSTD_compressSubBlock (litSize=%zu, nbSeq=%zu, writeLitEntropy=%d, writeSeqEntropy=%d, lastBlock=%d)",
-                litSize, nbSeq, writeLitEntropy, writeSeqEntropy, lastBlock);
-    {   size_t cLitSize = ZSTD_compressSubBlock_literal((const HUF_CElt*)entropy->huf.CTable,
-                                                        &entropyMetadata->hufMetadata, literals, litSize,
-                                                        op, (size_t)(oend-op),
-                                                        bmi2, writeLitEntropy, litEntropyWritten);
-        FORWARD_IF_ERROR(cLitSize, "ZSTD_compressSubBlock_literal failed");
-        if (cLitSize == 0) return 0;
-        op += cLitSize;
-    }
-    {   size_t cSeqSize = ZSTD_compressSubBlock_sequences(&entropy->fse,
-                                                  &entropyMetadata->fseMetadata,
-                                                  sequences, nbSeq,
-                                                  llCode, mlCode, ofCode,
-                                                  cctxParams,
-                                                  op, (size_t)(oend-op),
-                                                  bmi2, writeSeqEntropy, seqEntropyWritten);
-        FORWARD_IF_ERROR(cSeqSize, "ZSTD_compressSubBlock_sequences failed");
-        if (cSeqSize == 0) return 0;
-        op += cSeqSize;
-    }
-    /* Write block header */
-    {   size_t cSize = (size_t)(op-ostart) - ZSTD_blockHeaderSize;
-        U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
-        MEM_writeLE24(ostart, cBlockHeader24);
-    }
-    return (size_t)(op-ostart);
-}
-
-static size_t ZSTD_estimateSubBlockSize_literal(const BYTE* literals, size_t litSize,
-                                                const ZSTD_hufCTables_t* huf,
-                                                const ZSTD_hufCTablesMetadata_t* hufMetadata,
-                                                void* workspace, size_t wkspSize,
-                                                int writeEntropy)
-{
-    unsigned* const countWksp = (unsigned*)workspace;
-    unsigned maxSymbolValue = 255;
-    size_t literalSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
-
-    if (hufMetadata->hType == set_basic) return litSize;
-    else if (hufMetadata->hType == set_rle) return 1;
-    else if (hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat) {
-        size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);
-        if (ZSTD_isError(largest)) return litSize;
-        {   size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);
-            if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;
-            return cLitSizeEstimate + literalSectionHeaderSize;
-    }   }
-    assert(0); /* impossible */
-    return 0;
-}
-
-static size_t ZSTD_estimateSubBlockSize_symbolType(symbolEncodingType_e type,
-                        const BYTE* codeTable, unsigned maxCode,
-                        size_t nbSeq, const FSE_CTable* fseCTable,
-                        const U8* additionalBits,
-                        short const* defaultNorm, U32 defaultNormLog, U32 defaultMax,
-                        void* workspace, size_t wkspSize)
-{
-    unsigned* const countWksp = (unsigned*)workspace;
-    const BYTE* ctp = codeTable;
-    const BYTE* const ctStart = ctp;
-    const BYTE* const ctEnd = ctStart + nbSeq;
-    size_t cSymbolTypeSizeEstimateInBits = 0;
-    unsigned max = maxCode;
-
-    HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize);  /* can't fail */
-    if (type == set_basic) {
-        /* We selected this encoding type, so it must be valid. */
-        assert(max <= defaultMax);
-        cSymbolTypeSizeEstimateInBits = max <= defaultMax
-                ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max)
-                : ERROR(GENERIC);
-    } else if (type == set_rle) {
-        cSymbolTypeSizeEstimateInBits = 0;
-    } else if (type == set_compressed || type == set_repeat) {
-        cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);
-    }
-    if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) return nbSeq * 10;
-    while (ctp < ctEnd) {
-        if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];
-        else cSymbolTypeSizeEstimateInBits += *ctp; /* for offset, offset code is also the number of additional bits */
-        ctp++;
-    }
-    return cSymbolTypeSizeEstimateInBits / 8;
-}
-
-static size_t ZSTD_estimateSubBlockSize_sequences(const BYTE* ofCodeTable,
-                                                  const BYTE* llCodeTable,
-                                                  const BYTE* mlCodeTable,
-                                                  size_t nbSeq,
-                                                  const ZSTD_fseCTables_t* fseTables,
-                                                  const ZSTD_fseCTablesMetadata_t* fseMetadata,
-                                                  void* workspace, size_t wkspSize,
-                                                  int writeEntropy)
-{
-    size_t const sequencesSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
-    size_t cSeqSizeEstimate = 0;
-    if (nbSeq == 0) return sequencesSectionHeaderSize;
-    cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, MaxOff,
-                                         nbSeq, fseTables->offcodeCTable, NULL,
-                                         OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
-                                         workspace, wkspSize);
-    cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->llType, llCodeTable, MaxLL,
-                                         nbSeq, fseTables->litlengthCTable, LL_bits,
-                                         LL_defaultNorm, LL_defaultNormLog, MaxLL,
-                                         workspace, wkspSize);
-    cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, MaxML,
-                                         nbSeq, fseTables->matchlengthCTable, ML_bits,
-                                         ML_defaultNorm, ML_defaultNormLog, MaxML,
-                                         workspace, wkspSize);
-    if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;
-    return cSeqSizeEstimate + sequencesSectionHeaderSize;
-}
-
-typedef struct {
-    size_t estLitSize;
-    size_t estBlockSize;
-} EstimatedBlockSize;
-static EstimatedBlockSize ZSTD_estimateSubBlockSize(const BYTE* literals, size_t litSize,
-                                        const BYTE* ofCodeTable,
-                                        const BYTE* llCodeTable,
-                                        const BYTE* mlCodeTable,
-                                        size_t nbSeq,
-                                        const ZSTD_entropyCTables_t* entropy,
-                                        const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
-                                        void* workspace, size_t wkspSize,
-                                        int writeLitEntropy, int writeSeqEntropy)
-{
-    EstimatedBlockSize ebs;
-    ebs.estLitSize = ZSTD_estimateSubBlockSize_literal(literals, litSize,
-                                                        &entropy->huf, &entropyMetadata->hufMetadata,
-                                                        workspace, wkspSize, writeLitEntropy);
-    ebs.estBlockSize = ZSTD_estimateSubBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,
-                                                         nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,
-                                                         workspace, wkspSize, writeSeqEntropy);
-    ebs.estBlockSize += ebs.estLitSize + ZSTD_blockHeaderSize;
-    return ebs;
-}
-
-static int ZSTD_needSequenceEntropyTables(ZSTD_fseCTablesMetadata_t const* fseMetadata)
-{
-    if (fseMetadata->llType == set_compressed || fseMetadata->llType == set_rle)
-        return 1;
-    if (fseMetadata->mlType == set_compressed || fseMetadata->mlType == set_rle)
-        return 1;
-    if (fseMetadata->ofType == set_compressed || fseMetadata->ofType == set_rle)
-        return 1;
-    return 0;
-}
-
-static size_t countLiterals(seqStore_t const* seqStore, const seqDef* sp, size_t seqCount)
-{
-    size_t n, total = 0;
-    assert(sp != NULL);
-    for (n=0; n<seqCount; n++) {
-        total += ZSTD_getSequenceLength(seqStore, sp+n).litLength;
-    }
-    DEBUGLOG(6, "countLiterals for %zu sequences from %p => %zu bytes", seqCount, (const void*)sp, total);
-    return total;
-}
-
-#define BYTESCALE 256
-
-static size_t sizeBlockSequences(const seqDef* sp, size_t nbSeqs,
-                size_t targetBudget, size_t avgLitCost, size_t avgSeqCost,
-                int firstSubBlock)
-{
-    size_t n, budget = 0, inSize=0;
-    /* entropy headers */
-    size_t const headerSize = (size_t)firstSubBlock * 120 * BYTESCALE; /* generous estimate */
-    assert(firstSubBlock==0 || firstSubBlock==1);
-    budget += headerSize;
-
-    /* first sequence => at least one sequence*/
-    budget += sp[0].litLength * avgLitCost + avgSeqCost;
-    if (budget > targetBudget) return 1;
-    inSize = sp[0].litLength + (sp[0].mlBase+MINMATCH);
-
-    /* loop over sequences */
-    for (n=1; n<nbSeqs; n++) {
-        size_t currentCost = sp[n].litLength * avgLitCost + avgSeqCost;
-        budget += currentCost;
-        inSize += sp[n].litLength + (sp[n].mlBase+MINMATCH);
-        /* stop when sub-block budget is reached */
-        if ( (budget > targetBudget)
-            /* though continue to expand until the sub-block is deemed compressible */
-          && (budget < inSize * BYTESCALE) )
-            break;
-    }
-
-    return n;
-}
-
-/** ZSTD_compressSubBlock_multi() :
- *  Breaks super-block into multiple sub-blocks and compresses them.
- *  Entropy will be written into the first block.
- *  The following blocks use repeat_mode to compress.
- *  Sub-blocks are all compressed, except the last one when beneficial.
- *  @return : compressed size of the super block (which features multiple ZSTD blocks)
- *            or 0 if it failed to compress. */
-static size_t ZSTD_compressSubBlock_multi(const seqStore_t* seqStorePtr,
-                            const ZSTD_compressedBlockState_t* prevCBlock,
-                            ZSTD_compressedBlockState_t* nextCBlock,
-                            const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
-                            const ZSTD_CCtx_params* cctxParams,
-                                  void* dst, size_t dstCapacity,
-                            const void* src, size_t srcSize,
-                            const int bmi2, U32 lastBlock,
-                            void* workspace, size_t wkspSize)
-{
-    const seqDef* const sstart = seqStorePtr->sequencesStart;
-    const seqDef* const send = seqStorePtr->sequences;
-    const seqDef* sp = sstart; /* tracks progresses within seqStorePtr->sequences */
-    size_t const nbSeqs = (size_t)(send - sstart);
-    const BYTE* const lstart = seqStorePtr->litStart;
-    const BYTE* const lend = seqStorePtr->lit;
-    const BYTE* lp = lstart;
-    size_t const nbLiterals = (size_t)(lend - lstart);
-    BYTE const* ip = (BYTE const*)src;
-    BYTE const* const iend = ip + srcSize;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    const BYTE* llCodePtr = seqStorePtr->llCode;
-    const BYTE* mlCodePtr = seqStorePtr->mlCode;
-    const BYTE* ofCodePtr = seqStorePtr->ofCode;
-    size_t const minTarget = ZSTD_TARGETCBLOCKSIZE_MIN; /* enforce minimum size, to reduce undesirable side effects */
-    size_t const targetCBlockSize = MAX(minTarget, cctxParams->targetCBlockSize);
-    int writeLitEntropy = (entropyMetadata->hufMetadata.hType == set_compressed);
-    int writeSeqEntropy = 1;
-
-    DEBUGLOG(5, "ZSTD_compressSubBlock_multi (srcSize=%u, litSize=%u, nbSeq=%u)",
-               (unsigned)srcSize, (unsigned)(lend-lstart), (unsigned)(send-sstart));
-
-        /* let's start by a general estimation for the full block */
-    if (nbSeqs > 0) {
-        EstimatedBlockSize const ebs =
-                ZSTD_estimateSubBlockSize(lp, nbLiterals,
-                                        ofCodePtr, llCodePtr, mlCodePtr, nbSeqs,
-                                        &nextCBlock->entropy, entropyMetadata,
-                                        workspace, wkspSize,
-                                        writeLitEntropy, writeSeqEntropy);
-        /* quick estimation */
-        size_t const avgLitCost = nbLiterals ? (ebs.estLitSize * BYTESCALE) / nbLiterals : BYTESCALE;
-        size_t const avgSeqCost = ((ebs.estBlockSize - ebs.estLitSize) * BYTESCALE) / nbSeqs;
-        const size_t nbSubBlocks = MAX((ebs.estBlockSize + (targetCBlockSize/2)) / targetCBlockSize, 1);
-        size_t n, avgBlockBudget, blockBudgetSupp=0;
-        avgBlockBudget = (ebs.estBlockSize * BYTESCALE) / nbSubBlocks;
-        DEBUGLOG(5, "estimated fullblock size=%u bytes ; avgLitCost=%.2f ; avgSeqCost=%.2f ; targetCBlockSize=%u, nbSubBlocks=%u ; avgBlockBudget=%.0f bytes",
-                    (unsigned)ebs.estBlockSize, (double)avgLitCost/BYTESCALE, (double)avgSeqCost/BYTESCALE,
-                    (unsigned)targetCBlockSize, (unsigned)nbSubBlocks, (double)avgBlockBudget/BYTESCALE);
-        /* simplification: if estimates states that the full superblock doesn't compress, just bail out immediately
-         * this will result in the production of a single uncompressed block covering @srcSize.*/
-        if (ebs.estBlockSize > srcSize) return 0;
-
-        /* compress and write sub-blocks */
-        assert(nbSubBlocks>0);
-        for (n=0; n < nbSubBlocks-1; n++) {
-            /* determine nb of sequences for current sub-block + nbLiterals from next sequence */
-            size_t const seqCount = sizeBlockSequences(sp, (size_t)(send-sp),
-                                        avgBlockBudget + blockBudgetSupp, avgLitCost, avgSeqCost, n==0);
-            /* if reached last sequence : break to last sub-block (simplification) */
-            assert(seqCount <= (size_t)(send-sp));
-            if (sp + seqCount == send) break;
-            assert(seqCount > 0);
-            /* compress sub-block */
-            {   int litEntropyWritten = 0;
-                int seqEntropyWritten = 0;
-                size_t litSize = countLiterals(seqStorePtr, sp, seqCount);
-                const size_t decompressedSize =
-                        ZSTD_seqDecompressedSize(seqStorePtr, sp, seqCount, litSize, 0);
-                size_t const cSize = ZSTD_compressSubBlock(&nextCBlock->entropy, entropyMetadata,
-                                                sp, seqCount,
-                                                lp, litSize,
-                                                llCodePtr, mlCodePtr, ofCodePtr,
-                                                cctxParams,
-                                                op, (size_t)(oend-op),
-                                                bmi2, writeLitEntropy, writeSeqEntropy,
-                                                &litEntropyWritten, &seqEntropyWritten,
-                                                0);
-                FORWARD_IF_ERROR(cSize, "ZSTD_compressSubBlock failed");
-
-                /* check compressibility, update state components */
-                if (cSize > 0 && cSize < decompressedSize) {
-                    DEBUGLOG(5, "Committed sub-block compressing %u bytes => %u bytes",
-                                (unsigned)decompressedSize, (unsigned)cSize);
-                    assert(ip + decompressedSize <= iend);
-                    ip += decompressedSize;
-                    lp += litSize;
-                    op += cSize;
-                    llCodePtr += seqCount;
-                    mlCodePtr += seqCount;
-                    ofCodePtr += seqCount;
-                    /* Entropy only needs to be written once */
-                    if (litEntropyWritten) {
-                        writeLitEntropy = 0;
-                    }
-                    if (seqEntropyWritten) {
-                        writeSeqEntropy = 0;
-                    }
-                    sp += seqCount;
-                    blockBudgetSupp = 0;
-            }   }
-            /* otherwise : do not compress yet, coalesce current sub-block with following one */
-        }
-    } /* if (nbSeqs > 0) */
-
-    /* write last block */
-    DEBUGLOG(5, "Generate last sub-block: %u sequences remaining", (unsigned)(send - sp));
-    {   int litEntropyWritten = 0;
-        int seqEntropyWritten = 0;
-        size_t litSize = (size_t)(lend - lp);
-        size_t seqCount = (size_t)(send - sp);
-        const size_t decompressedSize =
-                ZSTD_seqDecompressedSize(seqStorePtr, sp, seqCount, litSize, 1);
-        size_t const cSize = ZSTD_compressSubBlock(&nextCBlock->entropy, entropyMetadata,
-                                            sp, seqCount,
-                                            lp, litSize,
-                                            llCodePtr, mlCodePtr, ofCodePtr,
-                                            cctxParams,
-                                            op, (size_t)(oend-op),
-                                            bmi2, writeLitEntropy, writeSeqEntropy,
-                                            &litEntropyWritten, &seqEntropyWritten,
-                                            lastBlock);
-        FORWARD_IF_ERROR(cSize, "ZSTD_compressSubBlock failed");
-
-        /* update pointers, the nb of literals borrowed from next sequence must be preserved */
-        if (cSize > 0 && cSize < decompressedSize) {
-            DEBUGLOG(5, "Last sub-block compressed %u bytes => %u bytes",
-                        (unsigned)decompressedSize, (unsigned)cSize);
-            assert(ip + decompressedSize <= iend);
-            ip += decompressedSize;
-            lp += litSize;
-            op += cSize;
-            llCodePtr += seqCount;
-            mlCodePtr += seqCount;
-            ofCodePtr += seqCount;
-            /* Entropy only needs to be written once */
-            if (litEntropyWritten) {
-                writeLitEntropy = 0;
-            }
-            if (seqEntropyWritten) {
-                writeSeqEntropy = 0;
-            }
-            sp += seqCount;
-        }
-    }
-
-
-    if (writeLitEntropy) {
-        DEBUGLOG(5, "Literal entropy tables were never written");
-        ZSTD_memcpy(&nextCBlock->entropy.huf, &prevCBlock->entropy.huf, sizeof(prevCBlock->entropy.huf));
-    }
-    if (writeSeqEntropy && ZSTD_needSequenceEntropyTables(&entropyMetadata->fseMetadata)) {
-        /* If we haven't written our entropy tables, then we've violated our contract and
-         * must emit an uncompressed block.
-         */
-        DEBUGLOG(5, "Sequence entropy tables were never written => cancel, emit an uncompressed block");
-        return 0;
-    }
-
-    if (ip < iend) {
-        /* some data left : last part of the block sent uncompressed */
-        size_t const rSize = (size_t)((iend - ip));
-        size_t const cSize = ZSTD_noCompressBlock(op, (size_t)(oend - op), ip, rSize, lastBlock);
-        DEBUGLOG(5, "Generate last uncompressed sub-block of %u bytes", (unsigned)(rSize));
-        FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
-        assert(cSize != 0);
-        op += cSize;
-        /* We have to regenerate the repcodes because we've skipped some sequences */
-        if (sp < send) {
-            const seqDef* seq;
-            repcodes_t rep;
-            ZSTD_memcpy(&rep, prevCBlock->rep, sizeof(rep));
-            for (seq = sstart; seq < sp; ++seq) {
-                ZSTD_updateRep(rep.rep, seq->offBase, ZSTD_getSequenceLength(seqStorePtr, seq).litLength == 0);
-            }
-            ZSTD_memcpy(nextCBlock->rep, &rep, sizeof(rep));
-        }
-    }
-
-    DEBUGLOG(5, "ZSTD_compressSubBlock_multi compressed all subBlocks: total compressed size = %u",
-                (unsigned)(op-ostart));
-    return (size_t)(op-ostart);
-}
-
-size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
-                               void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                               unsigned lastBlock)
-{
-    ZSTD_entropyCTablesMetadata_t entropyMetadata;
-
-    FORWARD_IF_ERROR(ZSTD_buildBlockEntropyStats(&zc->seqStore,
-          &zc->blockState.prevCBlock->entropy,
-          &zc->blockState.nextCBlock->entropy,
-          &zc->appliedParams,
-          &entropyMetadata,
-          zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */), "");
-
-    return ZSTD_compressSubBlock_multi(&zc->seqStore,
-            zc->blockState.prevCBlock,
-            zc->blockState.nextCBlock,
-            &entropyMetadata,
-            &zc->appliedParams,
-            dst, dstCapacity,
-            src, srcSize,
-            zc->bmi2, lastBlock,
-            zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp b/src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp
deleted file mode 100644
index d791b724b..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp
+++ /dev/null
@@ -1,774 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd/compress/zstd_compress_internal.h"
-#include "zstd/compress/zstd_double_fast.h"
-
-namespace duckdb_zstd {
-
-#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_fillDoubleHashTableForCDict(ZSTD_matchState_t* ms,
-                              void const* end, ZSTD_dictTableLoadMethod_e dtlm)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashLarge = ms->hashTable;
-    U32  const hBitsL = cParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;
-    U32  const mls = cParams->minMatch;
-    U32* const hashSmall = ms->chainTable;
-    U32  const hBitsS = cParams->chainLog + ZSTD_SHORT_CACHE_TAG_BITS;
-    const BYTE* const base = ms->window.base;
-    const BYTE* ip = base + ms->nextToUpdate;
-    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
-    const U32 fastHashFillStep = 3;
-
-    /* Always insert every fastHashFillStep position into the hash tables.
-     * Insert the other positions into the large hash table if their entry
-     * is empty.
-     */
-    for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) {
-        U32 const curr = (U32)(ip - base);
-        U32 i;
-        for (i = 0; i < fastHashFillStep; ++i) {
-            size_t const smHashAndTag = ZSTD_hashPtr(ip + i, hBitsS, mls);
-            size_t const lgHashAndTag = ZSTD_hashPtr(ip + i, hBitsL, 8);
-            if (i == 0) {
-                ZSTD_writeTaggedIndex(hashSmall, smHashAndTag, curr + i);
-            }
-            if (i == 0 || hashLarge[lgHashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS] == 0) {
-                ZSTD_writeTaggedIndex(hashLarge, lgHashAndTag, curr + i);
-            }
-            /* Only load extra positions for ZSTD_dtlm_full */
-            if (dtlm == ZSTD_dtlm_fast)
-                break;
-    }   }
-}
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_fillDoubleHashTableForCCtx(ZSTD_matchState_t* ms,
-                              void const* end, ZSTD_dictTableLoadMethod_e dtlm)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashLarge = ms->hashTable;
-    U32  const hBitsL = cParams->hashLog;
-    U32  const mls = cParams->minMatch;
-    U32* const hashSmall = ms->chainTable;
-    U32  const hBitsS = cParams->chainLog;
-    const BYTE* const base = ms->window.base;
-    const BYTE* ip = base + ms->nextToUpdate;
-    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
-    const U32 fastHashFillStep = 3;
-
-    /* Always insert every fastHashFillStep position into the hash tables.
-     * Insert the other positions into the large hash table if their entry
-     * is empty.
-     */
-    for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) {
-        U32 const curr = (U32)(ip - base);
-        U32 i;
-        for (i = 0; i < fastHashFillStep; ++i) {
-            size_t const smHash = ZSTD_hashPtr(ip + i, hBitsS, mls);
-            size_t const lgHash = ZSTD_hashPtr(ip + i, hBitsL, 8);
-            if (i == 0)
-                hashSmall[smHash] = curr + i;
-            if (i == 0 || hashLarge[lgHash] == 0)
-                hashLarge[lgHash] = curr + i;
-            /* Only load extra positions for ZSTD_dtlm_full */
-            if (dtlm == ZSTD_dtlm_fast)
-                break;
-        }   }
-}
-
-void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
-                        const void* const end,
-                        ZSTD_dictTableLoadMethod_e dtlm,
-                        ZSTD_tableFillPurpose_e tfp)
-{
-    if (tfp == ZSTD_tfp_forCDict) {
-        ZSTD_fillDoubleHashTableForCDict(ms, end, dtlm);
-    } else {
-        ZSTD_fillDoubleHashTableForCCtx(ms, end, dtlm);
-    }
-}
-
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_doubleFast_noDict_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize, U32 const mls /* template */)
-{
-    ZSTD_compressionParameters const* cParams = &ms->cParams;
-    U32* const hashLong = ms->hashTable;
-    const U32 hBitsL = cParams->hashLog;
-    U32* const hashSmall = ms->chainTable;
-    const U32 hBitsS = cParams->chainLog;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* anchor = istart;
-    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
-    /* presumes that, if there is a dictionary, it must be using Attach mode */
-    const U32 prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
-    const BYTE* const prefixLowest = base + prefixLowestIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - HASH_READ_SIZE;
-    U32 offset_1=rep[0], offset_2=rep[1];
-    U32 offsetSaved1 = 0, offsetSaved2 = 0;
-
-    size_t mLength;
-    U32 offset;
-    U32 curr;
-
-    /* how many positions to search before increasing step size */
-    const size_t kStepIncr = 1 << kSearchStrength;
-    /* the position at which to increment the step size if no match is found */
-    const BYTE* nextStep;
-    size_t step; /* the current step size */
-
-    size_t hl0; /* the long hash at ip */
-    size_t hl1; /* the long hash at ip1 */
-
-    U32 idxl0; /* the long match index for ip */
-    U32 idxl1; /* the long match index for ip1 */
-
-    const BYTE* matchl0; /* the long match for ip */
-    const BYTE* matchs0; /* the short match for ip */
-    const BYTE* matchl1; /* the long match for ip1 */
-
-    const BYTE* ip = istart; /* the current position */
-    const BYTE* ip1; /* the next position */
-
-    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_noDict_generic");
-
-    /* init */
-    ip += ((ip - prefixLowest) == 0);
-    {
-        U32 const current = (U32)(ip - base);
-        U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, current, cParams->windowLog);
-        U32 const maxRep = current - windowLow;
-        if (offset_2 > maxRep) offsetSaved2 = offset_2, offset_2 = 0;
-        if (offset_1 > maxRep) offsetSaved1 = offset_1, offset_1 = 0;
-    }
-
-    /* Outer Loop: one iteration per match found and stored */
-    while (1) {
-        step = 1;
-        nextStep = ip + kStepIncr;
-        ip1 = ip + step;
-
-        if (ip1 > ilimit) {
-            goto _cleanup;
-        }
-
-        hl0 = ZSTD_hashPtr(ip, hBitsL, 8);
-        idxl0 = hashLong[hl0];
-        matchl0 = base + idxl0;
-
-        /* Inner Loop: one iteration per search / position */
-        do {
-            const size_t hs0 = ZSTD_hashPtr(ip, hBitsS, mls);
-            const U32 idxs0 = hashSmall[hs0];
-            curr = (U32)(ip-base);
-            matchs0 = base + idxs0;
-
-            hashLong[hl0] = hashSmall[hs0] = curr;   /* update hash tables */
-
-            /* check noDict repcode */
-            if ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1))) {
-                mLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
-                ip++;
-                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);
-                goto _match_stored;
-            }
-
-            hl1 = ZSTD_hashPtr(ip1, hBitsL, 8);
-
-            if (idxl0 > prefixLowestIndex) {
-                /* check prefix long match */
-                if (MEM_read64(matchl0) == MEM_read64(ip)) {
-                    mLength = ZSTD_count(ip+8, matchl0+8, iend) + 8;
-                    offset = (U32)(ip-matchl0);
-                    while (((ip>anchor) & (matchl0>prefixLowest)) && (ip[-1] == matchl0[-1])) { ip--; matchl0--; mLength++; } /* catch up */
-                    goto _match_found;
-                }
-            }
-
-            idxl1 = hashLong[hl1];
-            matchl1 = base + idxl1;
-
-            if (idxs0 > prefixLowestIndex) {
-                /* check prefix short match */
-                if (MEM_read32(matchs0) == MEM_read32(ip)) {
-                    goto _search_next_long;
-                }
-            }
-
-            if (ip1 >= nextStep) {
-                PREFETCH_L1(ip1 + 64);
-                PREFETCH_L1(ip1 + 128);
-                step++;
-                nextStep += kStepIncr;
-            }
-            ip = ip1;
-            ip1 += step;
-
-            hl0 = hl1;
-            idxl0 = idxl1;
-            matchl0 = matchl1;
-    #if defined(__aarch64__)
-            PREFETCH_L1(ip+256);
-    #endif
-        } while (ip1 <= ilimit);
-
-_cleanup:
-        /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0),
-         * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */
-        offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2;
-
-        /* save reps for next block */
-        rep[0] = offset_1 ? offset_1 : offsetSaved1;
-        rep[1] = offset_2 ? offset_2 : offsetSaved2;
-
-        /* Return the last literals size */
-        return (size_t)(iend - anchor);
-
-_search_next_long:
-
-        /* check prefix long +1 match */
-        if (idxl1 > prefixLowestIndex) {
-            if (MEM_read64(matchl1) == MEM_read64(ip1)) {
-                ip = ip1;
-                mLength = ZSTD_count(ip+8, matchl1+8, iend) + 8;
-                offset = (U32)(ip-matchl1);
-                while (((ip>anchor) & (matchl1>prefixLowest)) && (ip[-1] == matchl1[-1])) { ip--; matchl1--; mLength++; } /* catch up */
-                goto _match_found;
-            }
-        }
-
-        /* if no long +1 match, explore the short match we found */
-        mLength = ZSTD_count(ip+4, matchs0+4, iend) + 4;
-        offset = (U32)(ip - matchs0);
-        while (((ip>anchor) & (matchs0>prefixLowest)) && (ip[-1] == matchs0[-1])) { ip--; matchs0--; mLength++; } /* catch up */
-
-        /* fall-through */
-
-_match_found: /* requires ip, offset, mLength */
-        offset_2 = offset_1;
-        offset_1 = offset;
-
-        if (step < 4) {
-            /* It is unsafe to write this value back to the hashtable when ip1 is
-             * greater than or equal to the new ip we will have after we're done
-             * processing this match. Rather than perform that test directly
-             * (ip1 >= ip + mLength), which costs speed in practice, we do a simpler
-             * more predictable test. The minmatch even if we take a short match is
-             * 4 bytes, so as long as step, the distance between ip and ip1
-             * (initially) is less than 4, we know ip1 < new ip. */
-            hashLong[hl1] = (U32)(ip1 - base);
-        }
-
-        ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);
-
-_match_stored:
-        /* match found */
-        ip += mLength;
-        anchor = ip;
-
-        if (ip <= ilimit) {
-            /* Complementary insertion */
-            /* done after iLimit test, as candidates could be > iend-8 */
-            {   U32 const indexToInsert = curr+2;
-                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
-                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
-                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
-                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
-            }
-
-            /* check immediate repcode */
-            while ( (ip <= ilimit)
-                 && ( (offset_2>0)
-                    & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
-                /* store sequence */
-                size_t const rLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
-                U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff;  /* swap offset_2 <=> offset_1 */
-                hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (U32)(ip-base);
-                hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (U32)(ip-base);
-                ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, rLength);
-                ip += rLength;
-                anchor = ip;
-                continue;   /* faster when present ... (?) */
-            }
-        }
-    }
-}
-
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_doubleFast_dictMatchState_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize,
-        U32 const mls /* template */)
-{
-    ZSTD_compressionParameters const* cParams = &ms->cParams;
-    U32* const hashLong = ms->hashTable;
-    const U32 hBitsL = cParams->hashLog;
-    U32* const hashSmall = ms->chainTable;
-    const U32 hBitsS = cParams->chainLog;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
-    /* presumes that, if there is a dictionary, it must be using Attach mode */
-    const U32 prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
-    const BYTE* const prefixLowest = base + prefixLowestIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - HASH_READ_SIZE;
-    U32 offset_1=rep[0], offset_2=rep[1];
-
-    const ZSTD_matchState_t* const dms = ms->dictMatchState;
-    const ZSTD_compressionParameters* const dictCParams = &dms->cParams;
-    const U32* const dictHashLong  = dms->hashTable;
-    const U32* const dictHashSmall = dms->chainTable;
-    const U32 dictStartIndex       = dms->window.dictLimit;
-    const BYTE* const dictBase     = dms->window.base;
-    const BYTE* const dictStart    = dictBase + dictStartIndex;
-    const BYTE* const dictEnd      = dms->window.nextSrc;
-    const U32 dictIndexDelta       = prefixLowestIndex - (U32)(dictEnd - dictBase);
-    const U32 dictHBitsL           = dictCParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;
-    const U32 dictHBitsS           = dictCParams->chainLog + ZSTD_SHORT_CACHE_TAG_BITS;
-    const U32 dictAndPrefixLength  = (U32)((ip - prefixLowest) + (dictEnd - dictStart));
-
-    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_dictMatchState_generic");
-
-    /* if a dictionary is attached, it must be within window range */
-    assert(ms->window.dictLimit + (1U << cParams->windowLog) >= endIndex);
-
-    if (ms->prefetchCDictTables) {
-        size_t const hashTableBytes = (((size_t)1) << dictCParams->hashLog) * sizeof(U32);
-        size_t const chainTableBytes = (((size_t)1) << dictCParams->chainLog) * sizeof(U32);
-        PREFETCH_AREA(dictHashLong, hashTableBytes);
-        PREFETCH_AREA(dictHashSmall, chainTableBytes);
-    }
-
-    /* init */
-    ip += (dictAndPrefixLength == 0);
-
-    /* dictMatchState repCode checks don't currently handle repCode == 0
-     * disabling. */
-    assert(offset_1 <= dictAndPrefixLength);
-    assert(offset_2 <= dictAndPrefixLength);
-
-    /* Main Search Loop */
-    while (ip < ilimit) {   /* < instead of <=, because repcode check at (ip+1) */
-        size_t mLength;
-        U32 offset;
-        size_t const h2 = ZSTD_hashPtr(ip, hBitsL, 8);
-        size_t const h = ZSTD_hashPtr(ip, hBitsS, mls);
-        size_t const dictHashAndTagL = ZSTD_hashPtr(ip, dictHBitsL, 8);
-        size_t const dictHashAndTagS = ZSTD_hashPtr(ip, dictHBitsS, mls);
-        U32 const dictMatchIndexAndTagL = dictHashLong[dictHashAndTagL >> ZSTD_SHORT_CACHE_TAG_BITS];
-        U32 const dictMatchIndexAndTagS = dictHashSmall[dictHashAndTagS >> ZSTD_SHORT_CACHE_TAG_BITS];
-        int const dictTagsMatchL = ZSTD_comparePackedTags(dictMatchIndexAndTagL, dictHashAndTagL);
-        int const dictTagsMatchS = ZSTD_comparePackedTags(dictMatchIndexAndTagS, dictHashAndTagS);
-        U32 const curr = (U32)(ip-base);
-        U32 const matchIndexL = hashLong[h2];
-        U32 matchIndexS = hashSmall[h];
-        const BYTE* matchLong = base + matchIndexL;
-        const BYTE* match = base + matchIndexS;
-        const U32 repIndex = curr + 1 - offset_1;
-        const BYTE* repMatch = (repIndex < prefixLowestIndex) ?
-                               dictBase + (repIndex - dictIndexDelta) :
-                               base + repIndex;
-        hashLong[h2] = hashSmall[h] = curr;   /* update hash tables */
-
-        /* check repcode */
-        if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
-            && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-            const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
-            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
-            ip++;
-            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);
-            goto _match_stored;
-        }
-
-        if (matchIndexL > prefixLowestIndex) {
-            /* check prefix long match */
-            if (MEM_read64(matchLong) == MEM_read64(ip)) {
-                mLength = ZSTD_count(ip+8, matchLong+8, iend) + 8;
-                offset = (U32)(ip-matchLong);
-                while (((ip>anchor) & (matchLong>prefixLowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */
-                goto _match_found;
-            }
-        } else if (dictTagsMatchL) {
-            /* check dictMatchState long match */
-            U32 const dictMatchIndexL = dictMatchIndexAndTagL >> ZSTD_SHORT_CACHE_TAG_BITS;
-            const BYTE* dictMatchL = dictBase + dictMatchIndexL;
-            assert(dictMatchL < dictEnd);
-
-            if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) {
-                mLength = ZSTD_count_2segments(ip+8, dictMatchL+8, iend, dictEnd, prefixLowest) + 8;
-                offset = (U32)(curr - dictMatchIndexL - dictIndexDelta);
-                while (((ip>anchor) & (dictMatchL>dictStart)) && (ip[-1] == dictMatchL[-1])) { ip--; dictMatchL--; mLength++; } /* catch up */
-                goto _match_found;
-        }   }
-
-        if (matchIndexS > prefixLowestIndex) {
-            /* check prefix short match */
-            if (MEM_read32(match) == MEM_read32(ip)) {
-                goto _search_next_long;
-            }
-        } else if (dictTagsMatchS) {
-            /* check dictMatchState short match */
-            U32 const dictMatchIndexS = dictMatchIndexAndTagS >> ZSTD_SHORT_CACHE_TAG_BITS;
-            match = dictBase + dictMatchIndexS;
-            matchIndexS = dictMatchIndexS + dictIndexDelta;
-
-            if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) {
-                goto _search_next_long;
-        }   }
-
-        ip += ((ip-anchor) >> kSearchStrength) + 1;
-#if defined(__aarch64__)
-        PREFETCH_L1(ip+256);
-#endif
-        continue;
-
-_search_next_long:
-        {   size_t const hl3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
-            size_t const dictHashAndTagL3 = ZSTD_hashPtr(ip+1, dictHBitsL, 8);
-            U32 const matchIndexL3 = hashLong[hl3];
-            U32 const dictMatchIndexAndTagL3 = dictHashLong[dictHashAndTagL3 >> ZSTD_SHORT_CACHE_TAG_BITS];
-            int const dictTagsMatchL3 = ZSTD_comparePackedTags(dictMatchIndexAndTagL3, dictHashAndTagL3);
-            const BYTE* matchL3 = base + matchIndexL3;
-            hashLong[hl3] = curr + 1;
-
-            /* check prefix long +1 match */
-            if (matchIndexL3 > prefixLowestIndex) {
-                if (MEM_read64(matchL3) == MEM_read64(ip+1)) {
-                    mLength = ZSTD_count(ip+9, matchL3+8, iend) + 8;
-                    ip++;
-                    offset = (U32)(ip-matchL3);
-                    while (((ip>anchor) & (matchL3>prefixLowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */
-                    goto _match_found;
-                }
-            } else if (dictTagsMatchL3) {
-                /* check dict long +1 match */
-                U32 const dictMatchIndexL3 = dictMatchIndexAndTagL3 >> ZSTD_SHORT_CACHE_TAG_BITS;
-                const BYTE* dictMatchL3 = dictBase + dictMatchIndexL3;
-                assert(dictMatchL3 < dictEnd);
-                if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip+1)) {
-                    mLength = ZSTD_count_2segments(ip+1+8, dictMatchL3+8, iend, dictEnd, prefixLowest) + 8;
-                    ip++;
-                    offset = (U32)(curr + 1 - dictMatchIndexL3 - dictIndexDelta);
-                    while (((ip>anchor) & (dictMatchL3>dictStart)) && (ip[-1] == dictMatchL3[-1])) { ip--; dictMatchL3--; mLength++; } /* catch up */
-                    goto _match_found;
-        }   }   }
-
-        /* if no long +1 match, explore the short match we found */
-        if (matchIndexS < prefixLowestIndex) {
-            mLength = ZSTD_count_2segments(ip+4, match+4, iend, dictEnd, prefixLowest) + 4;
-            offset = (U32)(curr - matchIndexS);
-            while (((ip>anchor) & (match>dictStart)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
-        } else {
-            mLength = ZSTD_count(ip+4, match+4, iend) + 4;
-            offset = (U32)(ip - match);
-            while (((ip>anchor) & (match>prefixLowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
-        }
-
-_match_found:
-        offset_2 = offset_1;
-        offset_1 = offset;
-
-        ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);
-
-_match_stored:
-        /* match found */
-        ip += mLength;
-        anchor = ip;
-
-        if (ip <= ilimit) {
-            /* Complementary insertion */
-            /* done after iLimit test, as candidates could be > iend-8 */
-            {   U32 const indexToInsert = curr+2;
-                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
-                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
-                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
-                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
-            }
-
-            /* check immediate repcode */
-            while (ip <= ilimit) {
-                U32 const current2 = (U32)(ip-base);
-                U32 const repIndex2 = current2 - offset_2;
-                const BYTE* repMatch2 = repIndex2 < prefixLowestIndex ?
-                        dictBase + repIndex2 - dictIndexDelta :
-                        base + repIndex2;
-                if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
-                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
-                    const BYTE* const repEnd2 = repIndex2 < prefixLowestIndex ? dictEnd : iend;
-                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixLowest) + 4;
-                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
-                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);
-                    hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
-                    hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
-                    ip += repLength2;
-                    anchor = ip;
-                    continue;
-                }
-                break;
-            }
-        }
-    }   /* while (ip < ilimit) */
-
-    /* save reps for next block */
-    rep[0] = offset_1;
-    rep[1] = offset_2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-}
-
-#define ZSTD_GEN_DFAST_FN(dictMode, mls)                                                                 \
-    static size_t ZSTD_compressBlock_doubleFast_##dictMode##_##mls(                                      \
-            ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],                          \
-            void const* src, size_t srcSize)                                                             \
-    {                                                                                                    \
-        return ZSTD_compressBlock_doubleFast_##dictMode##_generic(ms, seqStore, rep, src, srcSize, mls); \
-    }
-
-ZSTD_GEN_DFAST_FN(noDict, 4)
-ZSTD_GEN_DFAST_FN(noDict, 5)
-ZSTD_GEN_DFAST_FN(noDict, 6)
-ZSTD_GEN_DFAST_FN(noDict, 7)
-
-ZSTD_GEN_DFAST_FN(dictMatchState, 4)
-ZSTD_GEN_DFAST_FN(dictMatchState, 5)
-ZSTD_GEN_DFAST_FN(dictMatchState, 6)
-ZSTD_GEN_DFAST_FN(dictMatchState, 7)
-
-
-size_t ZSTD_compressBlock_doubleFast(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    const U32 mls = ms->cParams.minMatch;
-    switch(mls)
-    {
-    default: /* includes case 3 */
-    case 4 :
-        return ZSTD_compressBlock_doubleFast_noDict_4(ms, seqStore, rep, src, srcSize);
-    case 5 :
-        return ZSTD_compressBlock_doubleFast_noDict_5(ms, seqStore, rep, src, srcSize);
-    case 6 :
-        return ZSTD_compressBlock_doubleFast_noDict_6(ms, seqStore, rep, src, srcSize);
-    case 7 :
-        return ZSTD_compressBlock_doubleFast_noDict_7(ms, seqStore, rep, src, srcSize);
-    }
-}
-
-
-size_t ZSTD_compressBlock_doubleFast_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    const U32 mls = ms->cParams.minMatch;
-    switch(mls)
-    {
-    default: /* includes case 3 */
-    case 4 :
-        return ZSTD_compressBlock_doubleFast_dictMatchState_4(ms, seqStore, rep, src, srcSize);
-    case 5 :
-        return ZSTD_compressBlock_doubleFast_dictMatchState_5(ms, seqStore, rep, src, srcSize);
-    case 6 :
-        return ZSTD_compressBlock_doubleFast_dictMatchState_6(ms, seqStore, rep, src, srcSize);
-    case 7 :
-        return ZSTD_compressBlock_doubleFast_dictMatchState_7(ms, seqStore, rep, src, srcSize);
-    }
-}
-
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_doubleFast_extDict_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize,
-        U32 const mls /* template */)
-{
-    ZSTD_compressionParameters const* cParams = &ms->cParams;
-    U32* const hashLong = ms->hashTable;
-    U32  const hBitsL = cParams->hashLog;
-    U32* const hashSmall = ms->chainTable;
-    U32  const hBitsS = cParams->chainLog;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ms->window.base;
-    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
-    const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
-    const U32   dictStartIndex = lowLimit;
-    const U32   dictLimit = ms->window.dictLimit;
-    const U32   prefixStartIndex = (dictLimit > lowLimit) ? dictLimit : lowLimit;
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const BYTE* const dictStart = dictBase + dictStartIndex;
-    const BYTE* const dictEnd = dictBase + prefixStartIndex;
-    U32 offset_1=rep[0], offset_2=rep[1];
-
-    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_extDict_generic (srcSize=%zu)", srcSize);
-
-    /* if extDict is invalidated due to maxDistance, switch to "regular" variant */
-    if (prefixStartIndex == dictStartIndex)
-        return ZSTD_compressBlock_doubleFast(ms, seqStore, rep, src, srcSize);
-
-    /* Search Loop */
-    while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
-        const size_t hSmall = ZSTD_hashPtr(ip, hBitsS, mls);
-        const U32 matchIndex = hashSmall[hSmall];
-        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
-        const BYTE* match = matchBase + matchIndex;
-
-        const size_t hLong = ZSTD_hashPtr(ip, hBitsL, 8);
-        const U32 matchLongIndex = hashLong[hLong];
-        const BYTE* const matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : base;
-        const BYTE* matchLong = matchLongBase + matchLongIndex;
-
-        const U32 curr = (U32)(ip-base);
-        const U32 repIndex = curr + 1 - offset_1;   /* offset_1 expected <= curr +1 */
-        const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
-        const BYTE* const repMatch = repBase + repIndex;
-        size_t mLength;
-        hashSmall[hSmall] = hashLong[hLong] = curr;   /* update hash table */
-
-        if ((((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex doesn't overlap dict + prefix */
-            & (offset_1 <= curr+1 - dictStartIndex)) /* note: we are searching at curr+1 */
-          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-            const BYTE* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
-            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
-            ip++;
-            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);
-        } else {
-            if ((matchLongIndex > dictStartIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {
-                const BYTE* const matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend;
-                const BYTE* const lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart;
-                U32 offset;
-                mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, prefixStart) + 8;
-                offset = curr - matchLongIndex;
-                while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; }   /* catch up */
-                offset_2 = offset_1;
-                offset_1 = offset;
-                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);
-
-            } else if ((matchIndex > dictStartIndex) && (MEM_read32(match) == MEM_read32(ip))) {
-                size_t const h3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
-                U32 const matchIndex3 = hashLong[h3];
-                const BYTE* const match3Base = matchIndex3 < prefixStartIndex ? dictBase : base;
-                const BYTE* match3 = match3Base + matchIndex3;
-                U32 offset;
-                hashLong[h3] = curr + 1;
-                if ( (matchIndex3 > dictStartIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {
-                    const BYTE* const matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend;
-                    const BYTE* const lowMatchPtr = matchIndex3 < prefixStartIndex ? dictStart : prefixStart;
-                    mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, prefixStart) + 8;
-                    ip++;
-                    offset = curr+1 - matchIndex3;
-                    while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */
-                } else {
-                    const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;
-                    const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;
-                    mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;
-                    offset = curr - matchIndex;
-                    while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */
-                }
-                offset_2 = offset_1;
-                offset_1 = offset;
-                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);
-
-            } else {
-                ip += ((ip-anchor) >> kSearchStrength) + 1;
-                continue;
-        }   }
-
-        /* move to next sequence start */
-        ip += mLength;
-        anchor = ip;
-
-        if (ip <= ilimit) {
-            /* Complementary insertion */
-            /* done after iLimit test, as candidates could be > iend-8 */
-            {   U32 const indexToInsert = curr+2;
-                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
-                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
-                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
-                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
-            }
-
-            /* check immediate repcode */
-            while (ip <= ilimit) {
-                U32 const current2 = (U32)(ip-base);
-                U32 const repIndex2 = current2 - offset_2;
-                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
-                if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3)   /* intentional overflow : ensure repIndex2 doesn't overlap dict + prefix */
-                    & (offset_2 <= current2 - dictStartIndex))
-                  && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
-                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
-                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
-                    U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
-                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);
-                    hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
-                    hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
-                    ip += repLength2;
-                    anchor = ip;
-                    continue;
-                }
-                break;
-    }   }   }
-
-    /* save reps for next block */
-    rep[0] = offset_1;
-    rep[1] = offset_2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-}
-
-ZSTD_GEN_DFAST_FN(extDict, 4)
-ZSTD_GEN_DFAST_FN(extDict, 5)
-ZSTD_GEN_DFAST_FN(extDict, 6)
-ZSTD_GEN_DFAST_FN(extDict, 7)
-
-size_t ZSTD_compressBlock_doubleFast_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    U32 const mls = ms->cParams.minMatch;
-    switch(mls)
-    {
-    default: /* includes case 3 */
-    case 4 :
-        return ZSTD_compressBlock_doubleFast_extDict_4(ms, seqStore, rep, src, srcSize);
-    case 5 :
-        return ZSTD_compressBlock_doubleFast_extDict_5(ms, seqStore, rep, src, srcSize);
-    case 6 :
-        return ZSTD_compressBlock_doubleFast_extDict_6(ms, seqStore, rep, src, srcSize);
-    case 7 :
-        return ZSTD_compressBlock_doubleFast_extDict_7(ms, seqStore, rep, src, srcSize);
-    }
-}
-
-#endif /* ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR */
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_fast.cpp b/src/duckdb/third_party/zstd/compress/zstd_fast.cpp
deleted file mode 100644
index f45c4d8e1..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_fast.cpp
+++ /dev/null
@@ -1,972 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd/compress/zstd_compress_internal.h"  /* ZSTD_hashPtr, ZSTD_count, ZSTD_storeSeq */
-#include "zstd/compress/zstd_fast.h"
-
-namespace duckdb_zstd {
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_fillHashTableForCDict(ZSTD_matchState_t* ms,
-                        const void* const end,
-                        ZSTD_dictTableLoadMethod_e dtlm)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32  const hBits = cParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;
-    U32  const mls = cParams->minMatch;
-    const BYTE* const base = ms->window.base;
-    const BYTE* ip = base + ms->nextToUpdate;
-    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
-    const U32 fastHashFillStep = 3;
-
-    /* Currently, we always use ZSTD_dtlm_full for filling CDict tables.
-     * Feel free to remove this assert if there's a good reason! */
-    assert(dtlm == ZSTD_dtlm_full);
-
-    /* Always insert every fastHashFillStep position into the hash table.
-     * Insert the other positions if their hash entry is empty.
-     */
-    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {
-        U32 const curr = (U32)(ip - base);
-        {   size_t const hashAndTag = ZSTD_hashPtr(ip, hBits, mls);
-            ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr);   }
-
-        if (dtlm == ZSTD_dtlm_fast) continue;
-        /* Only load extra positions for ZSTD_dtlm_full */
-        {   U32 p;
-            for (p = 1; p < fastHashFillStep; ++p) {
-                size_t const hashAndTag = ZSTD_hashPtr(ip + p, hBits, mls);
-                if (hashTable[hashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS] == 0) {  /* not yet filled */
-                    ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr + p);
-                }   }   }   }
-}
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_fillHashTableForCCtx(ZSTD_matchState_t* ms,
-                        const void* const end,
-                        ZSTD_dictTableLoadMethod_e dtlm)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32  const hBits = cParams->hashLog;
-    U32  const mls = cParams->minMatch;
-    const BYTE* const base = ms->window.base;
-    const BYTE* ip = base + ms->nextToUpdate;
-    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
-    const U32 fastHashFillStep = 3;
-
-    /* Currently, we always use ZSTD_dtlm_fast for filling CCtx tables.
-     * Feel free to remove this assert if there's a good reason! */
-    assert(dtlm == ZSTD_dtlm_fast);
-
-    /* Always insert every fastHashFillStep position into the hash table.
-     * Insert the other positions if their hash entry is empty.
-     */
-    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {
-        U32 const curr = (U32)(ip - base);
-        size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls);
-        hashTable[hash0] = curr;
-        if (dtlm == ZSTD_dtlm_fast) continue;
-        /* Only load extra positions for ZSTD_dtlm_full */
-        {   U32 p;
-            for (p = 1; p < fastHashFillStep; ++p) {
-                size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls);
-                if (hashTable[hash] == 0) {  /* not yet filled */
-                    hashTable[hash] = curr + p;
-    }   }   }   }
-}
-
-void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
-                        const void* const end,
-                        ZSTD_dictTableLoadMethod_e dtlm,
-                        ZSTD_tableFillPurpose_e tfp)
-{
-    if (tfp == ZSTD_tfp_forCDict) {
-        ZSTD_fillHashTableForCDict(ms, end, dtlm);
-    } else {
-        ZSTD_fillHashTableForCCtx(ms, end, dtlm);
-    }
-}
-
-
-/**
- * If you squint hard enough (and ignore repcodes), the search operation at any
- * given position is broken into 4 stages:
- *
- * 1. Hash   (map position to hash value via input read)
- * 2. Lookup (map hash val to index via hashtable read)
- * 3. Load   (map index to value at that position via input read)
- * 4. Compare
- *
- * Each of these steps involves a memory read at an address which is computed
- * from the previous step. This means these steps must be sequenced and their
- * latencies are cumulative.
- *
- * Rather than do 1->2->3->4 sequentially for a single position before moving
- * onto the next, this implementation interleaves these operations across the
- * next few positions:
- *
- * R = Repcode Read & Compare
- * H = Hash
- * T = Table Lookup
- * M = Match Read & Compare
- *
- * Pos | Time -->
- * ----+-------------------
- * N   | ... M
- * N+1 | ...   TM
- * N+2 |    R H   T M
- * N+3 |         H    TM
- * N+4 |           R H   T M
- * N+5 |                H   ...
- * N+6 |                  R ...
- *
- * This is very much analogous to the pipelining of execution in a CPU. And just
- * like a CPU, we have to dump the pipeline when we find a match (i.e., take a
- * branch).
- *
- * When this happens, we throw away our current state, and do the following prep
- * to re-enter the loop:
- *
- * Pos | Time -->
- * ----+-------------------
- * N   | H T
- * N+1 |  H
- *
- * This is also the work we do at the beginning to enter the loop initially.
- */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_fast_noDict_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize,
-        U32 const mls, U32 const hasStep)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32 const hlog = cParams->hashLog;
-    /* support stepSize of 0 */
-    size_t const stepSize = hasStep ? (cParams->targetLength + !(cParams->targetLength) + 1) : 2;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const istart = (const BYTE*)src;
-    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
-    const U32   prefixStartIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - HASH_READ_SIZE;
-
-    const BYTE* anchor = istart;
-    const BYTE* ip0 = istart;
-    const BYTE* ip1;
-    const BYTE* ip2;
-    const BYTE* ip3;
-    U32 current0;
-
-    U32 rep_offset1 = rep[0];
-    U32 rep_offset2 = rep[1];
-    U32 offsetSaved1 = 0, offsetSaved2 = 0;
-
-    size_t hash0; /* hash for ip0 */
-    size_t hash1; /* hash for ip1 */
-    U32 idx; /* match idx for ip0 */
-    U32 mval; /* src value at match idx */
-
-    U32 offcode;
-    const BYTE* match0;
-    size_t mLength;
-
-    /* ip0 and ip1 are always adjacent. The targetLength skipping and
-     * uncompressibility acceleration is applied to every other position,
-     * matching the behavior of #1562. step therefore represents the gap
-     * between pairs of positions, from ip0 to ip2 or ip1 to ip3. */
-    size_t step;
-    const BYTE* nextStep;
-    const size_t kStepIncr = (1 << (kSearchStrength - 1));
-
-    DEBUGLOG(5, "ZSTD_compressBlock_fast_generic");
-    ip0 += (ip0 == prefixStart);
-    {   U32 const curr = (U32)(ip0 - base);
-        U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, cParams->windowLog);
-        U32 const maxRep = curr - windowLow;
-        if (rep_offset2 > maxRep) offsetSaved2 = rep_offset2, rep_offset2 = 0;
-        if (rep_offset1 > maxRep) offsetSaved1 = rep_offset1, rep_offset1 = 0;
-    }
-
-    /* start each op */
-_start: /* Requires: ip0 */
-
-    step = stepSize;
-    nextStep = ip0 + kStepIncr;
-
-    /* calculate positions, ip0 - anchor == 0, so we skip step calc */
-    ip1 = ip0 + 1;
-    ip2 = ip0 + step;
-    ip3 = ip2 + 1;
-
-    if (ip3 >= ilimit) {
-        goto _cleanup;
-    }
-
-    hash0 = ZSTD_hashPtr(ip0, hlog, mls);
-    hash1 = ZSTD_hashPtr(ip1, hlog, mls);
-
-    idx = hashTable[hash0];
-
-    do {
-        /* load repcode match for ip[2]*/
-        const U32 rval = MEM_read32(ip2 - rep_offset1);
-
-        /* write back hash table entry */
-        current0 = (U32)(ip0 - base);
-        hashTable[hash0] = current0;
-
-        /* check repcode at ip[2] */
-        if ((MEM_read32(ip2) == rval) & (rep_offset1 > 0)) {
-            ip0 = ip2;
-            match0 = ip0 - rep_offset1;
-            mLength = ip0[-1] == match0[-1];
-            ip0 -= mLength;
-            match0 -= mLength;
-            offcode = REPCODE1_TO_OFFBASE;
-            mLength += 4;
-
-            /* First write next hash table entry; we've already calculated it.
-             * This write is known to be safe because the ip1 is before the
-             * repcode (ip2). */
-            hashTable[hash1] = (U32)(ip1 - base);
-
-            goto _match;
-        }
-
-        /* load match for ip[0] */
-        if (idx >= prefixStartIndex) {
-            mval = MEM_read32(base + idx);
-        } else {
-            mval = MEM_read32(ip0) ^ 1; /* guaranteed to not match. */
-        }
-
-        /* check match at ip[0] */
-        if (MEM_read32(ip0) == mval) {
-            /* found a match! */
-
-            /* First write next hash table entry; we've already calculated it.
-             * This write is known to be safe because the ip1 == ip0 + 1, so
-             * we know we will resume searching after ip1 */
-            hashTable[hash1] = (U32)(ip1 - base);
-
-            goto _offset;
-        }
-
-        /* lookup ip[1] */
-        idx = hashTable[hash1];
-
-        /* hash ip[2] */
-        hash0 = hash1;
-        hash1 = ZSTD_hashPtr(ip2, hlog, mls);
-
-        /* advance to next positions */
-        ip0 = ip1;
-        ip1 = ip2;
-        ip2 = ip3;
-
-        /* write back hash table entry */
-        current0 = (U32)(ip0 - base);
-        hashTable[hash0] = current0;
-
-        /* load match for ip[0] */
-        if (idx >= prefixStartIndex) {
-            mval = MEM_read32(base + idx);
-        } else {
-            mval = MEM_read32(ip0) ^ 1; /* guaranteed to not match. */
-        }
-
-        /* check match at ip[0] */
-        if (MEM_read32(ip0) == mval) {
-            /* found a match! */
-
-            /* first write next hash table entry; we've already calculated it */
-            if (step <= 4) {
-                /* We need to avoid writing an index into the hash table >= the
-                 * position at which we will pick up our searching after we've
-                 * taken this match.
-                 *
-                 * The minimum possible match has length 4, so the earliest ip0
-                 * can be after we take this match will be the current ip0 + 4.
-                 * ip1 is ip0 + step - 1. If ip1 is >= ip0 + 4, we can't safely
-                 * write this position.
-                 */
-                hashTable[hash1] = (U32)(ip1 - base);
-            }
-
-            goto _offset;
-        }
-
-        /* lookup ip[1] */
-        idx = hashTable[hash1];
-
-        /* hash ip[2] */
-        hash0 = hash1;
-        hash1 = ZSTD_hashPtr(ip2, hlog, mls);
-
-        /* advance to next positions */
-        ip0 = ip1;
-        ip1 = ip2;
-        ip2 = ip0 + step;
-        ip3 = ip1 + step;
-
-        /* calculate step */
-        if (ip2 >= nextStep) {
-            step++;
-            PREFETCH_L1(ip1 + 64);
-            PREFETCH_L1(ip1 + 128);
-            nextStep += kStepIncr;
-        }
-    } while (ip3 < ilimit);
-
-_cleanup:
-    /* Note that there are probably still a couple positions we could search.
-     * However, it seems to be a meaningful performance hit to try to search
-     * them. So let's not. */
-
-    /* When the repcodes are outside of the prefix, we set them to zero before the loop.
-     * When the offsets are still zero, we need to restore them after the block to have a correct
-     * repcode history. If only one offset was invalid, it is easy. The tricky case is when both
-     * offsets were invalid. We need to figure out which offset to refill with.
-     *     - If both offsets are zero they are in the same order.
-     *     - If both offsets are non-zero, we won't restore the offsets from `offsetSaved[12]`.
-     *     - If only one is zero, we need to decide which offset to restore.
-     *         - If rep_offset1 is non-zero, then rep_offset2 must be offsetSaved1.
-     *         - It is impossible for rep_offset2 to be non-zero.
-     *
-     * So if rep_offset1 started invalid (offsetSaved1 != 0) and became valid (rep_offset1 != 0), then
-     * set rep[0] = rep_offset1 and rep[1] = offsetSaved1.
-     */
-    offsetSaved2 = ((offsetSaved1 != 0) && (rep_offset1 != 0)) ? offsetSaved1 : offsetSaved2;
-
-    /* save reps for next block */
-    rep[0] = rep_offset1 ? rep_offset1 : offsetSaved1;
-    rep[1] = rep_offset2 ? rep_offset2 : offsetSaved2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-
-_offset: /* Requires: ip0, idx */
-
-    /* Compute the offset code. */
-    match0 = base + idx;
-    rep_offset2 = rep_offset1;
-    rep_offset1 = (U32)(ip0-match0);
-    offcode = OFFSET_TO_OFFBASE(rep_offset1);
-    mLength = 4;
-
-    /* Count the backwards match length. */
-    while (((ip0>anchor) & (match0>prefixStart)) && (ip0[-1] == match0[-1])) {
-        ip0--;
-        match0--;
-        mLength++;
-    }
-
-_match: /* Requires: ip0, match0, offcode */
-
-    /* Count the forward length. */
-    mLength += ZSTD_count(ip0 + mLength, match0 + mLength, iend);
-
-    ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength);
-
-    ip0 += mLength;
-    anchor = ip0;
-
-    /* Fill table and check for immediate repcode. */
-    if (ip0 <= ilimit) {
-        /* Fill Table */
-        assert(base+current0+2 > istart);  /* check base overflow */
-        hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2;  /* here because current+2 could be > iend-8 */
-        hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);
-
-        if (rep_offset2 > 0) { /* rep_offset2==0 means rep_offset2 is invalidated */
-            while ( (ip0 <= ilimit) && (MEM_read32(ip0) == MEM_read32(ip0 - rep_offset2)) ) {
-                /* store sequence */
-                size_t const rLength = ZSTD_count(ip0+4, ip0+4-rep_offset2, iend) + 4;
-                { U32 const tmpOff = rep_offset2; rep_offset2 = rep_offset1; rep_offset1 = tmpOff; } /* swap rep_offset2 <=> rep_offset1 */
-                hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);
-                ip0 += rLength;
-                ZSTD_storeSeq(seqStore, 0 /*litLen*/, anchor, iend, REPCODE1_TO_OFFBASE, rLength);
-                anchor = ip0;
-                continue;   /* faster when present (confirmed on gcc-8) ... (?) */
-    }   }   }
-
-    goto _start;
-}
-
-#define ZSTD_GEN_FAST_FN(dictMode, mls, step)                                                            \
-    static size_t ZSTD_compressBlock_fast_##dictMode##_##mls##_##step(                                      \
-            ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],                    \
-            void const* src, size_t srcSize)                                                       \
-    {                                                                                              \
-        return ZSTD_compressBlock_fast_##dictMode##_generic(ms, seqStore, rep, src, srcSize, mls, step); \
-    }
-
-ZSTD_GEN_FAST_FN(noDict, 4, 1)
-ZSTD_GEN_FAST_FN(noDict, 5, 1)
-ZSTD_GEN_FAST_FN(noDict, 6, 1)
-ZSTD_GEN_FAST_FN(noDict, 7, 1)
-
-ZSTD_GEN_FAST_FN(noDict, 4, 0)
-ZSTD_GEN_FAST_FN(noDict, 5, 0)
-ZSTD_GEN_FAST_FN(noDict, 6, 0)
-ZSTD_GEN_FAST_FN(noDict, 7, 0)
-
-size_t ZSTD_compressBlock_fast(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    U32 const mls = ms->cParams.minMatch;
-    assert(ms->dictMatchState == NULL);
-    if (ms->cParams.targetLength > 1) {
-        switch(mls)
-        {
-        default: /* includes case 3 */
-        case 4 :
-            return ZSTD_compressBlock_fast_noDict_4_1(ms, seqStore, rep, src, srcSize);
-        case 5 :
-            return ZSTD_compressBlock_fast_noDict_5_1(ms, seqStore, rep, src, srcSize);
-        case 6 :
-            return ZSTD_compressBlock_fast_noDict_6_1(ms, seqStore, rep, src, srcSize);
-        case 7 :
-            return ZSTD_compressBlock_fast_noDict_7_1(ms, seqStore, rep, src, srcSize);
-        }
-    } else {
-        switch(mls)
-        {
-        default: /* includes case 3 */
-        case 4 :
-            return ZSTD_compressBlock_fast_noDict_4_0(ms, seqStore, rep, src, srcSize);
-        case 5 :
-            return ZSTD_compressBlock_fast_noDict_5_0(ms, seqStore, rep, src, srcSize);
-        case 6 :
-            return ZSTD_compressBlock_fast_noDict_6_0(ms, seqStore, rep, src, srcSize);
-        case 7 :
-            return ZSTD_compressBlock_fast_noDict_7_0(ms, seqStore, rep, src, srcSize);
-        }
-
-    }
-}
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_fast_dictMatchState_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize, U32 const mls, U32 const hasStep)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32 const hlog = cParams->hashLog;
-    /* support stepSize of 0 */
-    U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
-    const BYTE* const base = ms->window.base;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip0 = istart;
-    const BYTE* ip1 = ip0 + stepSize; /* we assert below that stepSize >= 1 */
-    const BYTE* anchor = istart;
-    const U32   prefixStartIndex = ms->window.dictLimit;
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - HASH_READ_SIZE;
-    U32 offset_1=rep[0], offset_2=rep[1];
-
-    const ZSTD_matchState_t* const dms = ms->dictMatchState;
-    const ZSTD_compressionParameters* const dictCParams = &dms->cParams ;
-    const U32* const dictHashTable = dms->hashTable;
-    const U32 dictStartIndex       = dms->window.dictLimit;
-    const BYTE* const dictBase     = dms->window.base;
-    const BYTE* const dictStart    = dictBase + dictStartIndex;
-    const BYTE* const dictEnd      = dms->window.nextSrc;
-    const U32 dictIndexDelta       = prefixStartIndex - (U32)(dictEnd - dictBase);
-    const U32 dictAndPrefixLength  = (U32)(istart - prefixStart + dictEnd - dictStart);
-    const U32 dictHBits            = dictCParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;
-
-    /* if a dictionary is still attached, it necessarily means that
-     * it is within window size. So we just check it. */
-    const U32 maxDistance = 1U << cParams->windowLog;
-    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
-    assert(endIndex - prefixStartIndex <= maxDistance);
-    (void)maxDistance; (void)endIndex;   /* these variables are not used when assert() is disabled */
-
-    (void)hasStep; /* not currently specialized on whether it's accelerated */
-
-    /* ensure there will be no underflow
-     * when translating a dict index into a local index */
-    assert(prefixStartIndex >= (U32)(dictEnd - dictBase));
-
-    if (ms->prefetchCDictTables) {
-        size_t const hashTableBytes = (((size_t)1) << dictCParams->hashLog) * sizeof(U32);
-        PREFETCH_AREA(dictHashTable, hashTableBytes);
-    }
-
-    /* init */
-    DEBUGLOG(5, "ZSTD_compressBlock_fast_dictMatchState_generic");
-    ip0 += (dictAndPrefixLength == 0);
-    /* dictMatchState repCode checks don't currently handle repCode == 0
-     * disabling. */
-    assert(offset_1 <= dictAndPrefixLength);
-    assert(offset_2 <= dictAndPrefixLength);
-
-    /* Outer search loop */
-    assert(stepSize >= 1);
-    while (ip1 <= ilimit) {   /* repcode check at (ip0 + 1) is safe because ip0 < ip1 */
-        size_t mLength;
-        size_t hash0 = ZSTD_hashPtr(ip0, hlog, mls);
-
-        size_t const dictHashAndTag0 = ZSTD_hashPtr(ip0, dictHBits, mls);
-        U32 dictMatchIndexAndTag = dictHashTable[dictHashAndTag0 >> ZSTD_SHORT_CACHE_TAG_BITS];
-        int dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag0);
-
-        U32 matchIndex = hashTable[hash0];
-        U32 curr = (U32)(ip0 - base);
-        size_t step = stepSize;
-        const size_t kStepIncr = 1 << kSearchStrength;
-        const BYTE* nextStep = ip0 + kStepIncr;
-
-        /* Inner search loop */
-        while (1) {
-            const BYTE* match = base + matchIndex;
-            const U32 repIndex = curr + 1 - offset_1;
-            const BYTE* repMatch = (repIndex < prefixStartIndex) ?
-                                   dictBase + (repIndex - dictIndexDelta) :
-                                   base + repIndex;
-            const size_t hash1 = ZSTD_hashPtr(ip1, hlog, mls);
-            size_t const dictHashAndTag1 = ZSTD_hashPtr(ip1, dictHBits, mls);
-            hashTable[hash0] = curr;   /* update hash table */
-
-            if (((U32) ((prefixStartIndex - 1) - repIndex) >=
-                 3) /* intentional underflow : ensure repIndex isn't overlapping dict + prefix */
-                && (MEM_read32(repMatch) == MEM_read32(ip0 + 1))) {
-                const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
-                mLength = ZSTD_count_2segments(ip0 + 1 + 4, repMatch + 4, iend, repMatchEnd, prefixStart) + 4;
-                ip0++;
-                ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);
-                break;
-            }
-
-            if (dictTagsMatch) {
-                /* Found a possible dict match */
-                const U32 dictMatchIndex = dictMatchIndexAndTag >> ZSTD_SHORT_CACHE_TAG_BITS;
-                const BYTE* dictMatch = dictBase + dictMatchIndex;
-                if (dictMatchIndex > dictStartIndex &&
-                    MEM_read32(dictMatch) == MEM_read32(ip0)) {
-                    /* To replicate extDict parse behavior, we only use dict matches when the normal matchIndex is invalid */
-                    if (matchIndex <= prefixStartIndex) {
-                        U32 const offset = (U32) (curr - dictMatchIndex - dictIndexDelta);
-                        mLength = ZSTD_count_2segments(ip0 + 4, dictMatch + 4, iend, dictEnd, prefixStart) + 4;
-                        while (((ip0 > anchor) & (dictMatch > dictStart))
-                            && (ip0[-1] == dictMatch[-1])) {
-                            ip0--;
-                            dictMatch--;
-                            mLength++;
-                        } /* catch up */
-                        offset_2 = offset_1;
-                        offset_1 = offset;
-                        ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);
-                        break;
-                    }
-                }
-            }
-
-            if (matchIndex > prefixStartIndex && MEM_read32(match) == MEM_read32(ip0)) {
-                /* found a regular match */
-                U32 const offset = (U32) (ip0 - match);
-                mLength = ZSTD_count(ip0 + 4, match + 4, iend) + 4;
-                while (((ip0 > anchor) & (match > prefixStart))
-                       && (ip0[-1] == match[-1])) {
-                    ip0--;
-                    match--;
-                    mLength++;
-                } /* catch up */
-                offset_2 = offset_1;
-                offset_1 = offset;
-                ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);
-                break;
-            }
-
-            /* Prepare for next iteration */
-            dictMatchIndexAndTag = dictHashTable[dictHashAndTag1 >> ZSTD_SHORT_CACHE_TAG_BITS];
-            dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag1);
-            matchIndex = hashTable[hash1];
-
-            if (ip1 >= nextStep) {
-                step++;
-                nextStep += kStepIncr;
-            }
-            ip0 = ip1;
-            ip1 = ip1 + step;
-            if (ip1 > ilimit) goto _cleanup;
-
-            curr = (U32)(ip0 - base);
-            hash0 = hash1;
-        }   /* end inner search loop */
-
-        /* match found */
-        assert(mLength);
-        ip0 += mLength;
-        anchor = ip0;
-
-        if (ip0 <= ilimit) {
-            /* Fill Table */
-            assert(base+curr+2 > istart);  /* check base overflow */
-            hashTable[ZSTD_hashPtr(base+curr+2, hlog, mls)] = curr+2;  /* here because curr+2 could be > iend-8 */
-            hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);
-
-            /* check immediate repcode */
-            while (ip0 <= ilimit) {
-                U32 const current2 = (U32)(ip0-base);
-                U32 const repIndex2 = current2 - offset_2;
-                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ?
-                        dictBase - dictIndexDelta + repIndex2 :
-                        base + repIndex2;
-                if ( ((U32)((prefixStartIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
-                   && (MEM_read32(repMatch2) == MEM_read32(ip0))) {
-                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
-                    size_t const repLength2 = ZSTD_count_2segments(ip0+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
-                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
-                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);
-                    hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = current2;
-                    ip0 += repLength2;
-                    anchor = ip0;
-                    continue;
-                }
-                break;
-            }
-        }
-
-        /* Prepare for next iteration */
-        assert(ip0 == anchor);
-        ip1 = ip0 + stepSize;
-    }
-
-_cleanup:
-    /* save reps for next block */
-    rep[0] = offset_1;
-    rep[1] = offset_2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-}
-
-
-ZSTD_GEN_FAST_FN(dictMatchState, 4, 0)
-ZSTD_GEN_FAST_FN(dictMatchState, 5, 0)
-ZSTD_GEN_FAST_FN(dictMatchState, 6, 0)
-ZSTD_GEN_FAST_FN(dictMatchState, 7, 0)
-
-size_t ZSTD_compressBlock_fast_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    U32 const mls = ms->cParams.minMatch;
-    assert(ms->dictMatchState != NULL);
-    switch(mls)
-    {
-    default: /* includes case 3 */
-    case 4 :
-        return ZSTD_compressBlock_fast_dictMatchState_4_0(ms, seqStore, rep, src, srcSize);
-    case 5 :
-        return ZSTD_compressBlock_fast_dictMatchState_5_0(ms, seqStore, rep, src, srcSize);
-    case 6 :
-        return ZSTD_compressBlock_fast_dictMatchState_6_0(ms, seqStore, rep, src, srcSize);
-    case 7 :
-        return ZSTD_compressBlock_fast_dictMatchState_7_0(ms, seqStore, rep, src, srcSize);
-    }
-}
-
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_fast_extDict_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize, U32 const mls, U32 const hasStep)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32 const hlog = cParams->hashLog;
-    /* support stepSize of 0 */
-    size_t const stepSize = cParams->targetLength + !(cParams->targetLength) + 1;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* anchor = istart;
-    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
-    const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
-    const U32   dictStartIndex = lowLimit;
-    const BYTE* const dictStart = dictBase + dictStartIndex;
-    const U32   dictLimit = ms->window.dictLimit;
-    const U32   prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit;
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const dictEnd = dictBase + prefixStartIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    U32 offset_1=rep[0], offset_2=rep[1];
-    U32 offsetSaved1 = 0, offsetSaved2 = 0;
-
-    const BYTE* ip0 = istart;
-    const BYTE* ip1;
-    const BYTE* ip2;
-    const BYTE* ip3;
-    U32 current0;
-
-
-    size_t hash0; /* hash for ip0 */
-    size_t hash1; /* hash for ip1 */
-    U32 idx; /* match idx for ip0 */
-    const BYTE* idxBase; /* base pointer for idx */
-
-    U32 offcode;
-    const BYTE* match0;
-    size_t mLength;
-    const BYTE* matchEnd = 0; /* initialize to avoid warning, assert != 0 later */
-
-    size_t step;
-    const BYTE* nextStep;
-    const size_t kStepIncr = (1 << (kSearchStrength - 1));
-
-    (void)hasStep; /* not currently specialized on whether it's accelerated */
-
-    DEBUGLOG(5, "ZSTD_compressBlock_fast_extDict_generic (offset_1=%u)", offset_1);
-
-    /* switch to "regular" variant if extDict is invalidated due to maxDistance */
-    if (prefixStartIndex == dictStartIndex)
-        return ZSTD_compressBlock_fast(ms, seqStore, rep, src, srcSize);
-
-    {   U32 const curr = (U32)(ip0 - base);
-        U32 const maxRep = curr - dictStartIndex;
-        if (offset_2 >= maxRep) offsetSaved2 = offset_2, offset_2 = 0;
-        if (offset_1 >= maxRep) offsetSaved1 = offset_1, offset_1 = 0;
-    }
-
-    /* start each op */
-_start: /* Requires: ip0 */
-
-    step = stepSize;
-    nextStep = ip0 + kStepIncr;
-
-    /* calculate positions, ip0 - anchor == 0, so we skip step calc */
-    ip1 = ip0 + 1;
-    ip2 = ip0 + step;
-    ip3 = ip2 + 1;
-
-    if (ip3 >= ilimit) {
-        goto _cleanup;
-    }
-
-    hash0 = ZSTD_hashPtr(ip0, hlog, mls);
-    hash1 = ZSTD_hashPtr(ip1, hlog, mls);
-
-    idx = hashTable[hash0];
-    idxBase = idx < prefixStartIndex ? dictBase : base;
-
-    do {
-        {   /* load repcode match for ip[2] */
-            U32 const current2 = (U32)(ip2 - base);
-            U32 const repIndex = current2 - offset_1;
-            const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
-            U32 rval;
-            if ( ((U32)(prefixStartIndex - repIndex) >= 4) /* intentional underflow */
-                 & (offset_1 > 0) ) {
-                rval = MEM_read32(repBase + repIndex);
-            } else {
-                rval = MEM_read32(ip2) ^ 1; /* guaranteed to not match. */
-            }
-
-            /* write back hash table entry */
-            current0 = (U32)(ip0 - base);
-            hashTable[hash0] = current0;
-
-            /* check repcode at ip[2] */
-            if (MEM_read32(ip2) == rval) {
-                ip0 = ip2;
-                match0 = repBase + repIndex;
-                matchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
-                assert((match0 != prefixStart) & (match0 != dictStart));
-                mLength = ip0[-1] == match0[-1];
-                ip0 -= mLength;
-                match0 -= mLength;
-                offcode = REPCODE1_TO_OFFBASE;
-                mLength += 4;
-                goto _match;
-        }   }
-
-        {   /* load match for ip[0] */
-            U32 const mval = idx >= dictStartIndex ?
-                    MEM_read32(idxBase + idx) :
-                    MEM_read32(ip0) ^ 1; /* guaranteed not to match */
-
-            /* check match at ip[0] */
-            if (MEM_read32(ip0) == mval) {
-                /* found a match! */
-                goto _offset;
-        }   }
-
-        /* lookup ip[1] */
-        idx = hashTable[hash1];
-        idxBase = idx < prefixStartIndex ? dictBase : base;
-
-        /* hash ip[2] */
-        hash0 = hash1;
-        hash1 = ZSTD_hashPtr(ip2, hlog, mls);
-
-        /* advance to next positions */
-        ip0 = ip1;
-        ip1 = ip2;
-        ip2 = ip3;
-
-        /* write back hash table entry */
-        current0 = (U32)(ip0 - base);
-        hashTable[hash0] = current0;
-
-        {   /* load match for ip[0] */
-            U32 const mval = idx >= dictStartIndex ?
-                    MEM_read32(idxBase + idx) :
-                    MEM_read32(ip0) ^ 1; /* guaranteed not to match */
-
-            /* check match at ip[0] */
-            if (MEM_read32(ip0) == mval) {
-                /* found a match! */
-                goto _offset;
-        }   }
-
-        /* lookup ip[1] */
-        idx = hashTable[hash1];
-        idxBase = idx < prefixStartIndex ? dictBase : base;
-
-        /* hash ip[2] */
-        hash0 = hash1;
-        hash1 = ZSTD_hashPtr(ip2, hlog, mls);
-
-        /* advance to next positions */
-        ip0 = ip1;
-        ip1 = ip2;
-        ip2 = ip0 + step;
-        ip3 = ip1 + step;
-
-        /* calculate step */
-        if (ip2 >= nextStep) {
-            step++;
-            PREFETCH_L1(ip1 + 64);
-            PREFETCH_L1(ip1 + 128);
-            nextStep += kStepIncr;
-        }
-    } while (ip3 < ilimit);
-
-_cleanup:
-    /* Note that there are probably still a couple positions we could search.
-     * However, it seems to be a meaningful performance hit to try to search
-     * them. So let's not. */
-
-    /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0),
-     * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */
-    offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2;
-
-    /* save reps for next block */
-    rep[0] = offset_1 ? offset_1 : offsetSaved1;
-    rep[1] = offset_2 ? offset_2 : offsetSaved2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-
-_offset: /* Requires: ip0, idx, idxBase */
-
-    /* Compute the offset code. */
-    {   U32 const offset = current0 - idx;
-        const BYTE* const lowMatchPtr = idx < prefixStartIndex ? dictStart : prefixStart;
-        matchEnd = idx < prefixStartIndex ? dictEnd : iend;
-        match0 = idxBase + idx;
-        offset_2 = offset_1;
-        offset_1 = offset;
-        offcode = OFFSET_TO_OFFBASE(offset);
-        mLength = 4;
-
-        /* Count the backwards match length. */
-        while (((ip0>anchor) & (match0>lowMatchPtr)) && (ip0[-1] == match0[-1])) {
-            ip0--;
-            match0--;
-            mLength++;
-    }   }
-
-_match: /* Requires: ip0, match0, offcode, matchEnd */
-
-    /* Count the forward length. */
-    assert(matchEnd != 0);
-    mLength += ZSTD_count_2segments(ip0 + mLength, match0 + mLength, iend, matchEnd, prefixStart);
-
-    ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength);
-
-    ip0 += mLength;
-    anchor = ip0;
-
-    /* write next hash table entry */
-    if (ip1 < ip0) {
-        hashTable[hash1] = (U32)(ip1 - base);
-    }
-
-    /* Fill table and check for immediate repcode. */
-    if (ip0 <= ilimit) {
-        /* Fill Table */
-        assert(base+current0+2 > istart);  /* check base overflow */
-        hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2;  /* here because current+2 could be > iend-8 */
-        hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);
-
-        while (ip0 <= ilimit) {
-            U32 const repIndex2 = (U32)(ip0-base) - offset_2;
-            const BYTE* const repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
-            if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3) & (offset_2 > 0))  /* intentional underflow */
-                 && (MEM_read32(repMatch2) == MEM_read32(ip0)) ) {
-                const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
-                size_t const repLength2 = ZSTD_count_2segments(ip0+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
-                { U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; }  /* swap offset_2 <=> offset_1 */
-                ZSTD_storeSeq(seqStore, 0 /*litlen*/, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);
-                hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);
-                ip0 += repLength2;
-                anchor = ip0;
-                continue;
-            }
-            break;
-    }   }
-
-    goto _start;
-}
-
-ZSTD_GEN_FAST_FN(extDict, 4, 0)
-ZSTD_GEN_FAST_FN(extDict, 5, 0)
-ZSTD_GEN_FAST_FN(extDict, 6, 0)
-ZSTD_GEN_FAST_FN(extDict, 7, 0)
-
-size_t ZSTD_compressBlock_fast_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    U32 const mls = ms->cParams.minMatch;
-    assert(ms->dictMatchState == NULL);
-    switch(mls)
-    {
-    default: /* includes case 3 */
-    case 4 :
-        return ZSTD_compressBlock_fast_extDict_4_0(ms, seqStore, rep, src, srcSize);
-    case 5 :
-        return ZSTD_compressBlock_fast_extDict_5_0(ms, seqStore, rep, src, srcSize);
-    case 6 :
-        return ZSTD_compressBlock_fast_extDict_6_0(ms, seqStore, rep, src, srcSize);
-    case 7 :
-        return ZSTD_compressBlock_fast_extDict_7_0(ms, seqStore, rep, src, srcSize);
-    }
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_lazy.cpp b/src/duckdb/third_party/zstd/compress/zstd_lazy.cpp
deleted file mode 100644
index 1e9152823..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_lazy.cpp
+++ /dev/null
@@ -1,2203 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd/compress/zstd_compress_internal.h"
-#include "zstd/compress/zstd_lazy.h"
-#include "zstd/common/bits.h" /* ZSTD_countTrailingZeros64 */
-
-namespace duckdb_zstd {
-
-#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR)
-
-#define kLazySkippingStep 8
-
-
-/*-*************************************
-*  Binary Tree search
-***************************************/
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_updateDUBT(ZSTD_matchState_t* ms,
-                const BYTE* ip, const BYTE* iend,
-                U32 mls)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32  const hashLog = cParams->hashLog;
-
-    U32* const bt = ms->chainTable;
-    U32  const btLog  = cParams->chainLog - 1;
-    U32  const btMask = (1 << btLog) - 1;
-
-    const BYTE* const base = ms->window.base;
-    U32 const target = (U32)(ip - base);
-    U32 idx = ms->nextToUpdate;
-
-    if (idx != target)
-        DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)",
-                    idx, target, ms->window.dictLimit);
-    assert(ip + 8 <= iend);   /* condition for ZSTD_hashPtr */
-    (void)iend;
-
-    assert(idx >= ms->window.dictLimit);   /* condition for valid base+idx */
-    for ( ; idx < target ; idx++) {
-        size_t const h  = ZSTD_hashPtr(base + idx, hashLog, mls);   /* assumption : ip + 8 <= iend */
-        U32    const matchIndex = hashTable[h];
-
-        U32*   const nextCandidatePtr = bt + 2*(idx&btMask);
-        U32*   const sortMarkPtr  = nextCandidatePtr + 1;
-
-        DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx);
-        hashTable[h] = idx;   /* Update Hash Table */
-        *nextCandidatePtr = matchIndex;   /* update BT like a chain */
-        *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK;
-    }
-    ms->nextToUpdate = target;
-}
-
-
-/** ZSTD_insertDUBT1() :
- *  sort one already inserted but unsorted position
- *  assumption : curr >= btlow == (curr - btmask)
- *  doesn't fail */
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
-                 U32 curr, const BYTE* inputEnd,
-                 U32 nbCompares, U32 btLow,
-                 const ZSTD_dictMode_e dictMode)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const bt = ms->chainTable;
-    U32  const btLog  = cParams->chainLog - 1;
-    U32  const btMask = (1 << btLog) - 1;
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const U32 dictLimit = ms->window.dictLimit;
-    const BYTE* const ip = (curr>=dictLimit) ? base + curr : dictBase + curr;
-    const BYTE* const iend = (curr>=dictLimit) ? inputEnd : dictBase + dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* match;
-    U32* smallerPtr = bt + 2*(curr&btMask);
-    U32* largerPtr  = smallerPtr + 1;
-    U32 matchIndex = *smallerPtr;   /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */
-    U32 dummy32;   /* to be nullified at the end */
-    U32 const windowValid = ms->window.lowLimit;
-    U32 const maxDistance = 1U << cParams->windowLog;
-    U32 const windowLow = (curr - windowValid > maxDistance) ? curr - maxDistance : windowValid;
-
-
-    DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",
-                curr, dictLimit, windowLow);
-    assert(curr >= btLow);
-    assert(ip < iend);   /* condition for ZSTD_count */
-
-    for (; nbCompares && (matchIndex > windowLow); --nbCompares) {
-        U32* const nextPtr = bt + 2*(matchIndex & btMask);
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-        assert(matchIndex < curr);
-        /* note : all candidates are now supposed sorted,
-         * but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK
-         * when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */
-
-        if ( (dictMode != ZSTD_extDict)
-          || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/
-          || (curr < dictLimit) /* both in extDict */) {
-            const BYTE* const mBase = ( (dictMode != ZSTD_extDict)
-                                     || (matchIndex+matchLength >= dictLimit)) ?
-                                        base : dictBase;
-            assert( (matchIndex+matchLength >= dictLimit)   /* might be wrong if extDict is incorrectly set to 0 */
-                 || (curr < dictLimit) );
-            match = mBase + matchIndex;
-            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
-        } else {
-            match = dictBase + matchIndex;
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
-            if (matchIndex+matchLength >= dictLimit)
-                match = base + matchIndex;   /* preparation for next read of match[matchLength] */
-        }
-
-        DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
-                    curr, matchIndex, (U32)matchLength);
-
-        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
-            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
-        }
-
-        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
-            /* match is smaller than current */
-            *smallerPtr = matchIndex;             /* update smaller idx */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
-            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u",
-                        matchIndex, btLow, nextPtr[1]);
-            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */
-            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */
-        } else {
-            /* match is larger than current */
-            *largerPtr = matchIndex;
-            commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
-            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u",
-                        matchIndex, btLow, nextPtr[0]);
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-    }   }
-
-    *smallerPtr = *largerPtr = 0;
-}
-
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_DUBT_findBetterDictMatch (
-        const ZSTD_matchState_t* ms,
-        const BYTE* const ip, const BYTE* const iend,
-        size_t* offsetPtr,
-        size_t bestLength,
-        U32 nbCompares,
-        U32 const mls,
-        const ZSTD_dictMode_e dictMode)
-{
-    const ZSTD_matchState_t * const dms = ms->dictMatchState;
-    const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;
-    const U32 * const dictHashTable = dms->hashTable;
-    U32         const hashLog = dmsCParams->hashLog;
-    size_t      const h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32               dictMatchIndex = dictHashTable[h];
-
-    const BYTE* const base = ms->window.base;
-    const BYTE* const prefixStart = base + ms->window.dictLimit;
-    U32         const curr = (U32)(ip-base);
-    const BYTE* const dictBase = dms->window.base;
-    const BYTE* const dictEnd = dms->window.nextSrc;
-    U32         const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base);
-    U32         const dictLowLimit = dms->window.lowLimit;
-    U32         const dictIndexDelta = ms->window.lowLimit - dictHighLimit;
-
-    U32*        const dictBt = dms->chainTable;
-    U32         const btLog  = dmsCParams->chainLog - 1;
-    U32         const btMask = (1 << btLog) - 1;
-    U32         const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;
-
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-
-    (void)dictMode;
-    assert(dictMode == ZSTD_dictMatchState);
-
-    for (; nbCompares && (dictMatchIndex > dictLowLimit); --nbCompares) {
-        U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-        const BYTE* match = dictBase + dictMatchIndex;
-        matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
-        if (dictMatchIndex+matchLength >= dictHighLimit)
-            match = base + dictMatchIndex + dictIndexDelta;   /* to prepare for next usage of match[matchLength] */
-
-        if (matchLength > bestLength) {
-            U32 matchIndex = dictMatchIndex + dictIndexDelta;
-            if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {
-                DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",
-                    curr, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, OFFSET_TO_OFFBASE(curr - matchIndex), dictMatchIndex, matchIndex);
-                bestLength = matchLength, *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);
-            }
-            if (ip+matchLength == iend) {   /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */
-                break;   /* drop, to guarantee consistency (miss a little bit of compression) */
-            }
-        }
-
-        if (match[matchLength] < ip[matchLength]) {
-            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-        } else {
-            /* match is larger than current */
-            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */
-            commonLengthLarger = matchLength;
-            dictMatchIndex = nextPtr[0];
-        }
-    }
-
-    if (bestLength >= MINMATCH) {
-        U32 const mIndex = curr - (U32)OFFBASE_TO_OFFSET(*offsetPtr); (void)mIndex;
-        DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
-                    curr, (U32)bestLength, (U32)*offsetPtr, mIndex);
-    }
-    return bestLength;
-
-}
-
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
-                        const BYTE* const ip, const BYTE* const iend,
-                        size_t* offBasePtr,
-                        U32 const mls,
-                        const ZSTD_dictMode_e dictMode)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32*   const hashTable = ms->hashTable;
-    U32    const hashLog = cParams->hashLog;
-    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32          matchIndex  = hashTable[h];
-
-    const BYTE* const base = ms->window.base;
-    U32    const curr = (U32)(ip-base);
-    U32    const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);
-
-    U32*   const bt = ms->chainTable;
-    U32    const btLog  = cParams->chainLog - 1;
-    U32    const btMask = (1 << btLog) - 1;
-    U32    const btLow = (btMask >= curr) ? 0 : curr - btMask;
-    U32    const unsortLimit = MAX(btLow, windowLow);
-
-    U32*         nextCandidate = bt + 2*(matchIndex&btMask);
-    U32*         unsortedMark = bt + 2*(matchIndex&btMask) + 1;
-    U32          nbCompares = 1U << cParams->searchLog;
-    U32          nbCandidates = nbCompares;
-    U32          previousCandidate = 0;
-
-    DEBUGLOG(7, "ZSTD_DUBT_findBestMatch (%u) ", curr);
-    assert(ip <= iend-8);   /* required for h calculation */
-    assert(dictMode != ZSTD_dedicatedDictSearch);
-
-    /* reach end of unsorted candidates list */
-    while ( (matchIndex > unsortLimit)
-         && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)
-         && (nbCandidates > 1) ) {
-        DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted",
-                    matchIndex);
-        *unsortedMark = previousCandidate;  /* the unsortedMark becomes a reversed chain, to move up back to original position */
-        previousCandidate = matchIndex;
-        matchIndex = *nextCandidate;
-        nextCandidate = bt + 2*(matchIndex&btMask);
-        unsortedMark = bt + 2*(matchIndex&btMask) + 1;
-        nbCandidates --;
-    }
-
-    /* nullify last candidate if it's still unsorted
-     * simplification, detrimental to compression ratio, beneficial for speed */
-    if ( (matchIndex > unsortLimit)
-      && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {
-        DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
-                    matchIndex);
-        *nextCandidate = *unsortedMark = 0;
-    }
-
-    /* batch sort stacked candidates */
-    matchIndex = previousCandidate;
-    while (matchIndex) {  /* will end on matchIndex == 0 */
-        U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;
-        U32 const nextCandidateIdx = *nextCandidateIdxPtr;
-        ZSTD_insertDUBT1(ms, matchIndex, iend,
-                         nbCandidates, unsortLimit, dictMode);
-        matchIndex = nextCandidateIdx;
-        nbCandidates++;
-    }
-
-    /* find longest match */
-    {   size_t commonLengthSmaller = 0, commonLengthLarger = 0;
-        const BYTE* const dictBase = ms->window.dictBase;
-        const U32 dictLimit = ms->window.dictLimit;
-        const BYTE* const dictEnd = dictBase + dictLimit;
-        const BYTE* const prefixStart = base + dictLimit;
-        U32* smallerPtr = bt + 2*(curr&btMask);
-        U32* largerPtr  = bt + 2*(curr&btMask) + 1;
-        U32 matchEndIdx = curr + 8 + 1;
-        U32 dummy32;   /* to be nullified at the end */
-        size_t bestLength = 0;
-
-        matchIndex  = hashTable[h];
-        hashTable[h] = curr;   /* Update Hash Table */
-
-        for (; nbCompares && (matchIndex > windowLow); --nbCompares) {
-            U32* const nextPtr = bt + 2*(matchIndex & btMask);
-            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-            const BYTE* match;
-
-            if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {
-                match = base + matchIndex;
-                matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
-            } else {
-                match = dictBase + matchIndex;
-                matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
-                if (matchIndex+matchLength >= dictLimit)
-                    match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
-            }
-
-            if (matchLength > bestLength) {
-                if (matchLength > matchEndIdx - matchIndex)
-                    matchEndIdx = matchIndex + (U32)matchLength;
-                if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr - matchIndex + 1) - ZSTD_highbit32((U32)*offBasePtr)) )
-                    bestLength = matchLength, *offBasePtr = OFFSET_TO_OFFBASE(curr - matchIndex);
-                if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
-                    if (dictMode == ZSTD_dictMatchState) {
-                        nbCompares = 0; /* in addition to avoiding checking any
-                                         * further in this loop, make sure we
-                                         * skip checking in the dictionary. */
-                    }
-                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */
-                }
-            }
-
-            if (match[matchLength] < ip[matchLength]) {
-                /* match is smaller than current */
-                *smallerPtr = matchIndex;             /* update smaller idx */
-                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-                if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-                smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-                matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-            } else {
-                /* match is larger than current */
-                *largerPtr = matchIndex;
-                commonLengthLarger = matchLength;
-                if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-                largerPtr = nextPtr;
-                matchIndex = nextPtr[0];
-        }   }
-
-        *smallerPtr = *largerPtr = 0;
-
-        assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
-        if (dictMode == ZSTD_dictMatchState && nbCompares) {
-            bestLength = ZSTD_DUBT_findBetterDictMatch(
-                    ms, ip, iend,
-                    offBasePtr, bestLength, nbCompares,
-                    mls, dictMode);
-        }
-
-        assert(matchEndIdx > curr+8); /* ensure nextToUpdate is increased */
-        ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */
-        if (bestLength >= MINMATCH) {
-            U32 const mIndex = curr - (U32)OFFBASE_TO_OFFSET(*offBasePtr); (void)mIndex;
-            DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
-                        curr, (U32)bestLength, (U32)*offBasePtr, mIndex);
-        }
-        return bestLength;
-    }
-}
-
-
-/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_BtFindBestMatch( ZSTD_matchState_t* ms,
-                const BYTE* const ip, const BYTE* const iLimit,
-                      size_t* offBasePtr,
-                const U32 mls /* template */,
-                const ZSTD_dictMode_e dictMode)
-{
-    DEBUGLOG(7, "ZSTD_BtFindBestMatch");
-    if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateDUBT(ms, ip, iLimit, mls);
-    return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offBasePtr, mls, dictMode);
-}
-
-/***********************************
-* Dedicated dict search
-***********************************/
-
-void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const BYTE* const ip)
-{
-    const BYTE* const base = ms->window.base;
-    U32 const target = (U32)(ip - base);
-    U32* const hashTable = ms->hashTable;
-    U32* const chainTable = ms->chainTable;
-    U32 const chainSize = 1 << ms->cParams.chainLog;
-    U32 idx = ms->nextToUpdate;
-    U32 const minChain = chainSize < target - idx ? target - chainSize : idx;
-    U32 const bucketSize = 1 << ZSTD_LAZY_DDSS_BUCKET_LOG;
-    U32 const cacheSize = bucketSize - 1;
-    U32 const chainAttempts = (1 << ms->cParams.searchLog) - cacheSize;
-    U32 const chainLimit = chainAttempts > 255 ? 255 : chainAttempts;
-
-    /* We know the hashtable is oversized by a factor of `bucketSize`.
-     * We are going to temporarily pretend `bucketSize == 1`, keeping only a
-     * single entry. We will use the rest of the space to construct a temporary
-     * chaintable.
-     */
-    U32 const hashLog = ms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG;
-    U32* const tmpHashTable = hashTable;
-    U32* const tmpChainTable = hashTable + ((size_t)1 << hashLog);
-    U32 const tmpChainSize = (U32)((1 << ZSTD_LAZY_DDSS_BUCKET_LOG) - 1) << hashLog;
-    U32 const tmpMinChain = tmpChainSize < target ? target - tmpChainSize : idx;
-    U32 hashIdx;
-
-    assert(ms->cParams.chainLog <= 24);
-    assert(ms->cParams.hashLog > ms->cParams.chainLog);
-    assert(idx != 0);
-    assert(tmpMinChain <= minChain);
-
-    /* fill conventional hash table and conventional chain table */
-    for ( ; idx < target; idx++) {
-        U32 const h = (U32)ZSTD_hashPtr(base + idx, hashLog, ms->cParams.minMatch);
-        if (idx >= tmpMinChain) {
-            tmpChainTable[idx - tmpMinChain] = hashTable[h];
-        }
-        tmpHashTable[h] = idx;
-    }
-
-    /* sort chains into ddss chain table */
-    {
-        U32 chainPos = 0;
-        for (hashIdx = 0; hashIdx < (1U << hashLog); hashIdx++) {
-            U32 count;
-            U32 countBeyondMinChain = 0;
-            U32 i = tmpHashTable[hashIdx];
-            for (count = 0; i >= tmpMinChain && count < cacheSize; count++) {
-                /* skip through the chain to the first position that won't be
-                 * in the hash cache bucket */
-                if (i < minChain) {
-                    countBeyondMinChain++;
-                }
-                i = tmpChainTable[i - tmpMinChain];
-            }
-            if (count == cacheSize) {
-                for (count = 0; count < chainLimit;) {
-                    if (i < minChain) {
-                        if (!i || ++countBeyondMinChain > cacheSize) {
-                            /* only allow pulling `cacheSize` number of entries
-                             * into the cache or chainTable beyond `minChain`,
-                             * to replace the entries pulled out of the
-                             * chainTable into the cache. This lets us reach
-                             * back further without increasing the total number
-                             * of entries in the chainTable, guaranteeing the
-                             * DDSS chain table will fit into the space
-                             * allocated for the regular one. */
-                            break;
-                        }
-                    }
-                    chainTable[chainPos++] = i;
-                    count++;
-                    if (i < tmpMinChain) {
-                        break;
-                    }
-                    i = tmpChainTable[i - tmpMinChain];
-                }
-            } else {
-                count = 0;
-            }
-            if (count) {
-                tmpHashTable[hashIdx] = ((chainPos - count) << 8) + count;
-            } else {
-                tmpHashTable[hashIdx] = 0;
-            }
-        }
-        assert(chainPos <= chainSize); /* I believe this is guaranteed... */
-    }
-
-    /* move chain pointers into the last entry of each hash bucket */
-    for (hashIdx = (1 << hashLog); hashIdx; ) {
-        U32 const bucketIdx = --hashIdx << ZSTD_LAZY_DDSS_BUCKET_LOG;
-        U32 const chainPackedPointer = tmpHashTable[hashIdx];
-        U32 i;
-        for (i = 0; i < cacheSize; i++) {
-            hashTable[bucketIdx + i] = 0;
-        }
-        hashTable[bucketIdx + bucketSize - 1] = chainPackedPointer;
-    }
-
-    /* fill the buckets of the hash table */
-    for (idx = ms->nextToUpdate; idx < target; idx++) {
-        U32 const h = (U32)ZSTD_hashPtr(base + idx, hashLog, ms->cParams.minMatch)
-                   << ZSTD_LAZY_DDSS_BUCKET_LOG;
-        U32 i;
-        /* Shift hash cache down 1. */
-        for (i = cacheSize - 1; i; i--)
-            hashTable[h + i] = hashTable[h + i - 1];
-        hashTable[h] = idx;
-    }
-
-    ms->nextToUpdate = target;
-}
-
-/* Returns the longest match length found in the dedicated dict search structure.
- * If none are longer than the argument ml, then ml will be returned.
- */
-FORCE_INLINE_TEMPLATE
-size_t ZSTD_dedicatedDictSearch_lazy_search(size_t* offsetPtr, size_t ml, U32 nbAttempts,
-                                            const ZSTD_matchState_t* const dms,
-                                            const BYTE* const ip, const BYTE* const iLimit,
-                                            const BYTE* const prefixStart, const U32 curr,
-                                            const U32 dictLimit, const size_t ddsIdx) {
-    const U32 ddsLowestIndex  = dms->window.dictLimit;
-    const BYTE* const ddsBase = dms->window.base;
-    const BYTE* const ddsEnd  = dms->window.nextSrc;
-    const U32 ddsSize         = (U32)(ddsEnd - ddsBase);
-    const U32 ddsIndexDelta   = dictLimit - ddsSize;
-    const U32 bucketSize      = (1 << ZSTD_LAZY_DDSS_BUCKET_LOG);
-    const U32 bucketLimit     = nbAttempts < bucketSize - 1 ? nbAttempts : bucketSize - 1;
-    U32 ddsAttempt;
-    U32 matchIndex;
-
-    for (ddsAttempt = 0; ddsAttempt < bucketSize - 1; ddsAttempt++) {
-        PREFETCH_L1(ddsBase + dms->hashTable[ddsIdx + ddsAttempt]);
-    }
-
-    {
-        U32 const chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1];
-        U32 const chainIndex = chainPackedPointer >> 8;
-
-        PREFETCH_L1(&dms->chainTable[chainIndex]);
-    }
-
-    for (ddsAttempt = 0; ddsAttempt < bucketLimit; ddsAttempt++) {
-        size_t currentMl=0;
-        const BYTE* match;
-        matchIndex = dms->hashTable[ddsIdx + ddsAttempt];
-        match = ddsBase + matchIndex;
-
-        if (!matchIndex) {
-            return ml;
-        }
-
-        /* guaranteed by table construction */
-        (void)ddsLowestIndex;
-        assert(matchIndex >= ddsLowestIndex);
-        assert(match+4 <= ddsEnd);
-        if (MEM_read32(match) == MEM_read32(ip)) {
-            /* assumption : matchIndex <= dictLimit-4 (by table construction) */
-            currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, ddsEnd, prefixStart) + 4;
-        }
-
-        /* save best solution */
-        if (currentMl > ml) {
-            ml = currentMl;
-            *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + ddsIndexDelta));
-            if (ip+currentMl == iLimit) {
-                /* best possible, avoids read overflow on next attempt */
-                return ml;
-            }
-        }
-    }
-
-    {
-        U32 const chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1];
-        U32 chainIndex = chainPackedPointer >> 8;
-        U32 const chainLength = chainPackedPointer & 0xFF;
-        U32 const chainAttempts = nbAttempts - ddsAttempt;
-        U32 const chainLimit = chainAttempts > chainLength ? chainLength : chainAttempts;
-        U32 chainAttempt;
-
-        for (chainAttempt = 0 ; chainAttempt < chainLimit; chainAttempt++) {
-            PREFETCH_L1(ddsBase + dms->chainTable[chainIndex + chainAttempt]);
-        }
-
-        for (chainAttempt = 0 ; chainAttempt < chainLimit; chainAttempt++, chainIndex++) {
-            size_t currentMl=0;
-            const BYTE* match;
-            matchIndex = dms->chainTable[chainIndex];
-            match = ddsBase + matchIndex;
-
-            /* guaranteed by table construction */
-            assert(matchIndex >= ddsLowestIndex);
-            assert(match+4 <= ddsEnd);
-            if (MEM_read32(match) == MEM_read32(ip)) {
-                /* assumption : matchIndex <= dictLimit-4 (by table construction) */
-                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, ddsEnd, prefixStart) + 4;
-            }
-
-            /* save best solution */
-            if (currentMl > ml) {
-                ml = currentMl;
-                *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + ddsIndexDelta));
-                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
-            }
-        }
-    }
-    return ml;
-}
-
-
-/* *********************************
-*  Hash Chain
-***********************************/
-#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & (mask)]
-
-/* Update chains up to ip (excluded)
-   Assumption : always within prefix (i.e. not within extDict) */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_insertAndFindFirstIndex_internal(
-                        ZSTD_matchState_t* ms,
-                        const ZSTD_compressionParameters* const cParams,
-                        const BYTE* ip, U32 const mls, U32 const lazySkipping)
-{
-    U32* const hashTable  = ms->hashTable;
-    const U32 hashLog = cParams->hashLog;
-    U32* const chainTable = ms->chainTable;
-    const U32 chainMask = (1 << cParams->chainLog) - 1;
-    const BYTE* const base = ms->window.base;
-    const U32 target = (U32)(ip - base);
-    U32 idx = ms->nextToUpdate;
-
-    while(idx < target) { /* catch up */
-        size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls);
-        NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];
-        hashTable[h] = idx;
-        idx++;
-        /* Stop inserting every position when in the lazy skipping mode. */
-        if (lazySkipping)
-            break;
-    }
-
-    ms->nextToUpdate = target;
-    return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];
-}
-
-U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch, /* lazySkipping*/ 0);
-}
-
-/* inlining is important to hardwire a hot branch (template emulation) */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_HcFindBestMatch(
-                        ZSTD_matchState_t* ms,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 mls, const ZSTD_dictMode_e dictMode)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const chainTable = ms->chainTable;
-    const U32 chainSize = (1 << cParams->chainLog);
-    const U32 chainMask = chainSize-1;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const U32 dictLimit = ms->window.dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const U32 curr = (U32)(ip-base);
-    const U32 maxDistance = 1U << cParams->windowLog;
-    const U32 lowestValid = ms->window.lowLimit;
-    const U32 withinMaxDistance = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
-    const U32 isDictionary = (ms->loadedDictEnd != 0);
-    const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;
-    const U32 minChain = curr > chainSize ? curr - chainSize : 0;
-    U32 nbAttempts = 1U << cParams->searchLog;
-    size_t ml=4-1;
-
-    const ZSTD_matchState_t* const dms = ms->dictMatchState;
-    const U32 ddsHashLog = dictMode == ZSTD_dedicatedDictSearch
-                         ? dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG : 0;
-    const size_t ddsIdx = dictMode == ZSTD_dedicatedDictSearch
-                        ? ZSTD_hashPtr(ip, ddsHashLog, mls) << ZSTD_LAZY_DDSS_BUCKET_LOG : 0;
-
-    U32 matchIndex;
-
-    if (dictMode == ZSTD_dedicatedDictSearch) {
-        const U32* entry = &dms->hashTable[ddsIdx];
-        PREFETCH_L1(entry);
-    }
-
-    /* HC4 match finder */
-    matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls, ms->lazySkipping);
-
-    for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {
-        size_t currentMl=0;
-        if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
-            const BYTE* const match = base + matchIndex;
-            assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */
-            /* read 4B starting from (match + ml + 1 - sizeof(U32)) */
-            if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3))   /* potentially better */
-                currentMl = ZSTD_count(ip, match, iLimit);
-        } else {
-            const BYTE* const match = dictBase + matchIndex;
-            assert(match+4 <= dictEnd);
-            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
-                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
-        }
-
-        /* save best solution */
-        if (currentMl > ml) {
-            ml = currentMl;
-            *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);
-            if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
-        }
-
-        if (matchIndex <= minChain) break;
-        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);
-    }
-
-    assert(nbAttempts <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
-    if (dictMode == ZSTD_dedicatedDictSearch) {
-        ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts, dms,
-                                                  ip, iLimit, prefixStart, curr, dictLimit, ddsIdx);
-    } else if (dictMode == ZSTD_dictMatchState) {
-        const U32* const dmsChainTable = dms->chainTable;
-        const U32 dmsChainSize         = (1 << dms->cParams.chainLog);
-        const U32 dmsChainMask         = dmsChainSize - 1;
-        const U32 dmsLowestIndex       = dms->window.dictLimit;
-        const BYTE* const dmsBase      = dms->window.base;
-        const BYTE* const dmsEnd       = dms->window.nextSrc;
-        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);
-        const U32 dmsIndexDelta        = dictLimit - dmsSize;
-        const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;
-
-        matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)];
-
-        for ( ; (matchIndex>=dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {
-            size_t currentMl=0;
-            const BYTE* const match = dmsBase + matchIndex;
-            assert(match+4 <= dmsEnd);
-            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
-                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;
-
-            /* save best solution */
-            if (currentMl > ml) {
-                ml = currentMl;
-                assert(curr > matchIndex + dmsIndexDelta);
-                *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + dmsIndexDelta));
-                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
-            }
-
-            if (matchIndex <= dmsMinChain) break;
-
-            matchIndex = dmsChainTable[matchIndex & dmsChainMask];
-        }
-    }
-
-    return ml;
-}
-
-/* *********************************
-* (SIMD) Row-based matchfinder
-***********************************/
-/* Constants for row-based hash */
-#define ZSTD_ROW_HASH_TAG_MASK ((1u << ZSTD_ROW_HASH_TAG_BITS) - 1)
-#define ZSTD_ROW_HASH_MAX_ENTRIES 64    /* absolute maximum number of entries per row, for all configurations */
-
-#define ZSTD_ROW_HASH_CACHE_MASK (ZSTD_ROW_HASH_CACHE_SIZE - 1)
-
-typedef U64 ZSTD_VecMask;   /* Clarifies when we are interacting with a U64 representing a mask of matches */
-
-/* ZSTD_VecMask_next():
- * Starting from the LSB, returns the idx of the next non-zero bit.
- * Basically counting the nb of trailing zeroes.
- */
-MEM_STATIC U32 ZSTD_VecMask_next(ZSTD_VecMask val) {
-    return ZSTD_countTrailingZeros64(val);
-}
-
-/* ZSTD_row_nextIndex():
- * Returns the next index to insert at within a tagTable row, and updates the "head"
- * value to reflect the update. Essentially cycles backwards from [1, {entries per row})
- */
-FORCE_INLINE_TEMPLATE U32 ZSTD_row_nextIndex(BYTE* const tagRow, U32 const rowMask) {
-    U32 next = (*tagRow-1) & rowMask;
-    next += (next == 0) ? rowMask : 0; /* skip first position */
-    *tagRow = (BYTE)next;
-    return next;
-}
-
-/* ZSTD_isAligned():
- * Checks that a pointer is aligned to "align" bytes which must be a power of 2.
- */
-MEM_STATIC int ZSTD_isAligned(void const* ptr, size_t align) {
-    assert((align & (align - 1)) == 0);
-    return (((size_t)ptr) & (align - 1)) == 0;
-}
-
-/* ZSTD_row_prefetch():
- * Performs prefetching for the hashTable and tagTable at a given row.
- */
-FORCE_INLINE_TEMPLATE void ZSTD_row_prefetch(U32 const* hashTable, BYTE const* tagTable, U32 const relRow, U32 const rowLog) {
-    PREFETCH_L1(hashTable + relRow);
-    if (rowLog >= 5) {
-        PREFETCH_L1(hashTable + relRow + 16);
-        /* Note: prefetching more of the hash table does not appear to be beneficial for 128-entry rows */
-    }
-    PREFETCH_L1(tagTable + relRow);
-    if (rowLog == 6) {
-        PREFETCH_L1(tagTable + relRow + 32);
-    }
-    assert(rowLog == 4 || rowLog == 5 || rowLog == 6);
-    assert(ZSTD_isAligned(hashTable + relRow, 64));                 /* prefetched hash row always 64-byte aligned */
-    assert(ZSTD_isAligned(tagTable + relRow, (size_t)1 << rowLog)); /* prefetched tagRow sits on correct multiple of bytes (32,64,128) */
-}
-
-/* ZSTD_row_fillHashCache():
- * Fill up the hash cache starting at idx, prefetching up to ZSTD_ROW_HASH_CACHE_SIZE entries,
- * but not beyond iLimit.
- */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_row_fillHashCache(ZSTD_matchState_t* ms, const BYTE* base,
-                                   U32 const rowLog, U32 const mls,
-                                   U32 idx, const BYTE* const iLimit)
-{
-    U32 const* const hashTable = ms->hashTable;
-    BYTE const* const tagTable = ms->tagTable;
-    U32 const hashLog = ms->rowHashLog;
-    U32 const maxElemsToPrefetch = (base + idx) > iLimit ? 0 : (U32)(iLimit - (base + idx) + 1);
-    U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);
-
-    for (; idx < lim; ++idx) {
-        U32 const hash = (U32)ZSTD_hashPtrSalted(base + idx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);
-        U32 const row = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
-        ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);
-        ms->hashCache[idx & ZSTD_ROW_HASH_CACHE_MASK] = hash;
-    }
-
-    DEBUGLOG(6, "ZSTD_row_fillHashCache(): [%u %u %u %u %u %u %u %u]", ms->hashCache[0], ms->hashCache[1],
-                                                     ms->hashCache[2], ms->hashCache[3], ms->hashCache[4],
-                                                     ms->hashCache[5], ms->hashCache[6], ms->hashCache[7]);
-}
-
-/* ZSTD_row_nextCachedHash():
- * Returns the hash of base + idx, and replaces the hash in the hash cache with the byte at
- * base + idx + ZSTD_ROW_HASH_CACHE_SIZE. Also prefetches the appropriate rows from hashTable and tagTable.
- */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_row_nextCachedHash(U32* cache, U32 const* hashTable,
-                                                  BYTE const* tagTable, BYTE const* base,
-                                                  U32 idx, U32 const hashLog,
-                                                  U32 const rowLog, U32 const mls,
-                                                  U64 const hashSalt)
-{
-    U32 const newHash = (U32)ZSTD_hashPtrSalted(base+idx+ZSTD_ROW_HASH_CACHE_SIZE, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);
-    U32 const row = (newHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
-    ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);
-    {   U32 const hash = cache[idx & ZSTD_ROW_HASH_CACHE_MASK];
-        cache[idx & ZSTD_ROW_HASH_CACHE_MASK] = newHash;
-        return hash;
-    }
-}
-
-/* ZSTD_row_update_internalImpl():
- * Updates the hash table with positions starting from updateStartIdx until updateEndIdx.
- */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_row_update_internalImpl(ZSTD_matchState_t* ms,
-                                  U32 updateStartIdx, U32 const updateEndIdx,
-                                  U32 const mls, U32 const rowLog,
-                                  U32 const rowMask, U32 const useCache)
-{
-    U32* const hashTable = ms->hashTable;
-    BYTE* const tagTable = ms->tagTable;
-    U32 const hashLog = ms->rowHashLog;
-    const BYTE* const base = ms->window.base;
-
-    DEBUGLOG(6, "ZSTD_row_update_internalImpl(): updateStartIdx=%u, updateEndIdx=%u", updateStartIdx, updateEndIdx);
-    for (; updateStartIdx < updateEndIdx; ++updateStartIdx) {
-        U32 const hash = useCache ? ZSTD_row_nextCachedHash(ms->hashCache, hashTable, tagTable, base, updateStartIdx, hashLog, rowLog, mls, ms->hashSalt)
-                                  : (U32)ZSTD_hashPtrSalted(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);
-        U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
-        U32* const row = hashTable + relRow;
-        BYTE* tagRow = tagTable + relRow;
-        U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);
-
-        assert(hash == ZSTD_hashPtrSalted(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt));
-        tagRow[pos] = hash & ZSTD_ROW_HASH_TAG_MASK;
-        row[pos] = updateStartIdx;
-    }
-}
-
-/* ZSTD_row_update_internal():
- * Inserts the byte at ip into the appropriate position in the hash table, and updates ms->nextToUpdate.
- * Skips sections of long matches as is necessary.
- */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_row_update_internal(ZSTD_matchState_t* ms, const BYTE* ip,
-                              U32 const mls, U32 const rowLog,
-                              U32 const rowMask, U32 const useCache)
-{
-    U32 idx = ms->nextToUpdate;
-    const BYTE* const base = ms->window.base;
-    const U32 target = (U32)(ip - base);
-    const U32 kSkipThreshold = 384;
-    const U32 kMaxMatchStartPositionsToUpdate = 96;
-    const U32 kMaxMatchEndPositionsToUpdate = 32;
-
-    if (useCache) {
-        /* Only skip positions when using hash cache, i.e.
-         * if we are loading a dict, don't skip anything.
-         * If we decide to skip, then we only update a set number
-         * of positions at the beginning and end of the match.
-         */
-        if (UNLIKELY(target - idx > kSkipThreshold)) {
-            U32 const bound = idx + kMaxMatchStartPositionsToUpdate;
-            ZSTD_row_update_internalImpl(ms, idx, bound, mls, rowLog, rowMask, useCache);
-            idx = target - kMaxMatchEndPositionsToUpdate;
-            ZSTD_row_fillHashCache(ms, base, rowLog, mls, idx, ip+1);
-        }
-    }
-    assert(target >= idx);
-    ZSTD_row_update_internalImpl(ms, idx, target, mls, rowLog, rowMask, useCache);
-    ms->nextToUpdate = target;
-}
-
-/* ZSTD_row_update():
- * External wrapper for ZSTD_row_update_internal(). Used for filling the hashtable during dictionary
- * processing.
- */
-void ZSTD_row_update(ZSTD_matchState_t* const ms, const BYTE* ip) {
-    const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);
-    const U32 rowMask = (1u << rowLog) - 1;
-    const U32 mls = MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */);
-
-    DEBUGLOG(5, "ZSTD_row_update(), rowLog=%u", rowLog);
-    ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 0 /* don't use cache */);
-}
-
-/* Returns the mask width of bits group of which will be set to 1. Given not all
- * architectures have easy movemask instruction, this helps to iterate over
- * groups of bits easier and faster.
- */
-FORCE_INLINE_TEMPLATE U32
-ZSTD_row_matchMaskGroupWidth(const U32 rowEntries)
-{
-    assert((rowEntries == 16) || (rowEntries == 32) || rowEntries == 64);
-    assert(rowEntries <= ZSTD_ROW_HASH_MAX_ENTRIES);
-    (void)rowEntries;
-#if defined(ZSTD_ARCH_ARM_NEON)
-    /* NEON path only works for little endian */
-    if (!MEM_isLittleEndian()) {
-        return 1;
-    }
-    if (rowEntries == 16) {
-        return 4;
-    }
-    if (rowEntries == 32) {
-        return 2;
-    }
-    if (rowEntries == 64) {
-        return 1;
-    }
-#endif
-    return 1;
-}
-
-#if defined(ZSTD_ARCH_X86_SSE2)
-FORCE_INLINE_TEMPLATE ZSTD_VecMask
-ZSTD_row_getSSEMask(int nbChunks, const BYTE* const src, const BYTE tag, const U32 head)
-{
-    const __m128i comparisonMask = _mm_set1_epi8((char)tag);
-    int matches[4] = {0};
-    int i;
-    assert(nbChunks == 1 || nbChunks == 2 || nbChunks == 4);
-    for (i=0; i<nbChunks; i++) {
-        const __m128i chunk = _mm_loadu_si128((const __m128i*)(const void*)(src + 16*i));
-        const __m128i equalMask = _mm_cmpeq_epi8(chunk, comparisonMask);
-        matches[i] = _mm_movemask_epi8(equalMask);
-    }
-    if (nbChunks == 1) return ZSTD_rotateRight_U16((U16)matches[0], head);
-    if (nbChunks == 2) return ZSTD_rotateRight_U32((U32)matches[1] << 16 | (U32)matches[0], head);
-    assert(nbChunks == 4);
-    return ZSTD_rotateRight_U64((U64)matches[3] << 48 | (U64)matches[2] << 32 | (U64)matches[1] << 16 | (U64)matches[0], head);
-}
-#endif
-
-#if defined(ZSTD_ARCH_ARM_NEON)
-FORCE_INLINE_TEMPLATE ZSTD_VecMask
-ZSTD_row_getNEONMask(const U32 rowEntries, const BYTE* const src, const BYTE tag, const U32 headGrouped)
-{
-    assert((rowEntries == 16) || (rowEntries == 32) || rowEntries == 64);
-    if (rowEntries == 16) {
-        /* vshrn_n_u16 shifts by 4 every u16 and narrows to 8 lower bits.
-         * After that groups of 4 bits represent the equalMask. We lower
-         * all bits except the highest in these groups by doing AND with
-         * 0x88 = 0b10001000.
-         */
-        const uint8x16_t chunk = vld1q_u8(src);
-        const uint16x8_t equalMask = vreinterpretq_u16_u8(vceqq_u8(chunk, vdupq_n_u8(tag)));
-        const uint8x8_t res = vshrn_n_u16(equalMask, 4);
-        const U64 matches = vget_lane_u64(vreinterpret_u64_u8(res), 0);
-        return ZSTD_rotateRight_U64(matches, headGrouped) & 0x8888888888888888ull;
-    } else if (rowEntries == 32) {
-        /* Same idea as with rowEntries == 16 but doing AND with
-         * 0x55 = 0b01010101.
-         */
-        const uint16x8x2_t chunk = vld2q_u16((const uint16_t*)(const void*)src);
-        const uint8x16_t chunk0 = vreinterpretq_u8_u16(chunk.val[0]);
-        const uint8x16_t chunk1 = vreinterpretq_u8_u16(chunk.val[1]);
-        const uint8x16_t dup = vdupq_n_u8(tag);
-        const uint8x8_t t0 = vshrn_n_u16(vreinterpretq_u16_u8(vceqq_u8(chunk0, dup)), 6);
-        const uint8x8_t t1 = vshrn_n_u16(vreinterpretq_u16_u8(vceqq_u8(chunk1, dup)), 6);
-        const uint8x8_t res = vsli_n_u8(t0, t1, 4);
-        const U64 matches = vget_lane_u64(vreinterpret_u64_u8(res), 0) ;
-        return ZSTD_rotateRight_U64(matches, headGrouped) & 0x5555555555555555ull;
-    } else { /* rowEntries == 64 */
-        const uint8x16x4_t chunk = vld4q_u8(src);
-        const uint8x16_t dup = vdupq_n_u8(tag);
-        const uint8x16_t cmp0 = vceqq_u8(chunk.val[0], dup);
-        const uint8x16_t cmp1 = vceqq_u8(chunk.val[1], dup);
-        const uint8x16_t cmp2 = vceqq_u8(chunk.val[2], dup);
-        const uint8x16_t cmp3 = vceqq_u8(chunk.val[3], dup);
-
-        const uint8x16_t t0 = vsriq_n_u8(cmp1, cmp0, 1);
-        const uint8x16_t t1 = vsriq_n_u8(cmp3, cmp2, 1);
-        const uint8x16_t t2 = vsriq_n_u8(t1, t0, 2);
-        const uint8x16_t t3 = vsriq_n_u8(t2, t2, 4);
-        const uint8x8_t t4 = vshrn_n_u16(vreinterpretq_u16_u8(t3), 4);
-        const U64 matches = vget_lane_u64(vreinterpret_u64_u8(t4), 0);
-        return ZSTD_rotateRight_U64(matches, headGrouped);
-    }
-}
-#endif
-
-/* Returns a ZSTD_VecMask (U64) that has the nth group (determined by
- * ZSTD_row_matchMaskGroupWidth) of bits set to 1 if the newly-computed "tag"
- * matches the hash at the nth position in a row of the tagTable.
- * Each row is a circular buffer beginning at the value of "headGrouped". So we
- * must rotate the "matches" bitfield to match up with the actual layout of the
- * entries within the hashTable */
-FORCE_INLINE_TEMPLATE ZSTD_VecMask
-ZSTD_row_getMatchMask(const BYTE* const tagRow, const BYTE tag, const U32 headGrouped, const U32 rowEntries)
-{
-    const BYTE* const src = tagRow;
-    assert((rowEntries == 16) || (rowEntries == 32) || rowEntries == 64);
-    assert(rowEntries <= ZSTD_ROW_HASH_MAX_ENTRIES);
-    assert(ZSTD_row_matchMaskGroupWidth(rowEntries) * rowEntries <= sizeof(ZSTD_VecMask) * 8);
-
-#if defined(ZSTD_ARCH_X86_SSE2)
-
-    return ZSTD_row_getSSEMask(rowEntries / 16, src, tag, headGrouped);
-
-#else /* SW or NEON-LE */
-
-# if defined(ZSTD_ARCH_ARM_NEON)
-  /* This NEON path only works for little endian - otherwise use SWAR below */
-    if (MEM_isLittleEndian()) {
-        return ZSTD_row_getNEONMask(rowEntries, src, tag, headGrouped);
-    }
-# endif /* ZSTD_ARCH_ARM_NEON */
-    /* SWAR */
-    {   const int chunkSize = sizeof(size_t);
-        const size_t shiftAmount = ((chunkSize * 8) - chunkSize);
-        const size_t xFF = ~((size_t)0);
-        const size_t x01 = xFF / 0xFF;
-        const size_t x80 = x01 << 7;
-        const size_t splatChar = tag * x01;
-        ZSTD_VecMask matches = 0;
-        int i = rowEntries - chunkSize;
-        assert((sizeof(size_t) == 4) || (sizeof(size_t) == 8));
-        if (MEM_isLittleEndian()) { /* runtime check so have two loops */
-            const size_t extractMagic = (xFF / 0x7F) >> chunkSize;
-            do {
-                size_t chunk = MEM_readST(&src[i]);
-                chunk ^= splatChar;
-                chunk = (((chunk | x80) - x01) | chunk) & x80;
-                matches <<= chunkSize;
-                matches |= (chunk * extractMagic) >> shiftAmount;
-                i -= chunkSize;
-            } while (i >= 0);
-        } else { /* big endian: reverse bits during extraction */
-            const size_t msb = xFF ^ (xFF >> 1);
-            const size_t extractMagic = (msb / 0x1FF) | msb;
-            do {
-                size_t chunk = MEM_readST(&src[i]);
-                chunk ^= splatChar;
-                chunk = (((chunk | x80) - x01) | chunk) & x80;
-                matches <<= chunkSize;
-                matches |= ((chunk >> 7) * extractMagic) >> shiftAmount;
-                i -= chunkSize;
-            } while (i >= 0);
-        }
-        matches = ~matches;
-        if (rowEntries == 16) {
-            return ZSTD_rotateRight_U16((U16)matches, headGrouped);
-        } else if (rowEntries == 32) {
-            return ZSTD_rotateRight_U32((U32)matches, headGrouped);
-        } else {
-            return ZSTD_rotateRight_U64((U64)matches, headGrouped);
-        }
-    }
-#endif
-}
-
-/* The high-level approach of the SIMD row based match finder is as follows:
- * - Figure out where to insert the new entry:
- *      - Generate a hash for current input posistion and split it into a one byte of tag and `rowHashLog` bits of index.
- *           - The hash is salted by a value that changes on every contex reset, so when the same table is used
- *             we will avoid collisions that would otherwise slow us down by intorducing phantom matches.
- *      - The hashTable is effectively split into groups or "rows" of 15 or 31 entries of U32, and the index determines
- *        which row to insert into.
- *      - Determine the correct position within the row to insert the entry into. Each row of 15 or 31 can
- *        be considered as a circular buffer with a "head" index that resides in the tagTable (overall 16 or 32 bytes
- *        per row).
- * - Use SIMD to efficiently compare the tags in the tagTable to the 1-byte tag calculated for the position and
- *   generate a bitfield that we can cycle through to check the collisions in the hash table.
- * - Pick the longest match.
- * - Insert the tag into the equivalent row and position in the tagTable.
- */
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_RowFindBestMatch(
-                        ZSTD_matchState_t* ms,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 mls, const ZSTD_dictMode_e dictMode,
-                        const U32 rowLog)
-{
-    U32* const hashTable = ms->hashTable;
-    BYTE* const tagTable = ms->tagTable;
-    U32* const hashCache = ms->hashCache;
-    const U32 hashLog = ms->rowHashLog;
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const U32 dictLimit = ms->window.dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const U32 curr = (U32)(ip-base);
-    const U32 maxDistance = 1U << cParams->windowLog;
-    const U32 lowestValid = ms->window.lowLimit;
-    const U32 withinMaxDistance = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
-    const U32 isDictionary = (ms->loadedDictEnd != 0);
-    const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;
-    const U32 rowEntries = (1U << rowLog);
-    const U32 rowMask = rowEntries - 1;
-    const U32 cappedSearchLog = MIN(cParams->searchLog, rowLog); /* nb of searches is capped at nb entries per row */
-    const U32 groupWidth = ZSTD_row_matchMaskGroupWidth(rowEntries);
-    const U64 hashSalt = ms->hashSalt;
-    U32 nbAttempts = 1U << cappedSearchLog;
-    size_t ml=4-1;
-    U32 hash;
-
-    /* DMS/DDS variables that may be referenced laster */
-    const ZSTD_matchState_t* const dms = ms->dictMatchState;
-
-    /* Initialize the following variables to satisfy static analyzer */
-    size_t ddsIdx = 0;
-    U32 ddsExtraAttempts = 0; /* cctx hash tables are limited in searches, but allow extra searches into DDS */
-    U32 dmsTag = 0;
-    U32* dmsRow = NULL;
-    BYTE* dmsTagRow = NULL;
-
-    if (dictMode == ZSTD_dedicatedDictSearch) {
-        const U32 ddsHashLog = dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG;
-        {   /* Prefetch DDS hashtable entry */
-            ddsIdx = ZSTD_hashPtr(ip, ddsHashLog, mls) << ZSTD_LAZY_DDSS_BUCKET_LOG;
-            PREFETCH_L1(&dms->hashTable[ddsIdx]);
-        }
-        ddsExtraAttempts = cParams->searchLog > rowLog ? 1U << (cParams->searchLog - rowLog) : 0;
-    }
-
-    if (dictMode == ZSTD_dictMatchState) {
-        /* Prefetch DMS rows */
-        U32* const dmsHashTable = dms->hashTable;
-        BYTE* const dmsTagTable = dms->tagTable;
-        U32 const dmsHash = (U32)ZSTD_hashPtr(ip, dms->rowHashLog + ZSTD_ROW_HASH_TAG_BITS, mls);
-        U32 const dmsRelRow = (dmsHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
-        dmsTag = dmsHash & ZSTD_ROW_HASH_TAG_MASK;
-        dmsTagRow = (BYTE*)(dmsTagTable + dmsRelRow);
-        dmsRow = dmsHashTable + dmsRelRow;
-        ZSTD_row_prefetch(dmsHashTable, dmsTagTable, dmsRelRow, rowLog);
-    }
-
-    /* Update the hashTable and tagTable up to (but not including) ip */
-    if (!ms->lazySkipping) {
-        ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 1 /* useCache */);
-        hash = ZSTD_row_nextCachedHash(hashCache, hashTable, tagTable, base, curr, hashLog, rowLog, mls, hashSalt);
-    } else {
-        /* Stop inserting every position when in the lazy skipping mode.
-         * The hash cache is also not kept up to date in this mode.
-         */
-        hash = (U32)ZSTD_hashPtrSalted(ip, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);
-        ms->nextToUpdate = curr;
-    }
-    ms->hashSaltEntropy += hash; /* collect salt entropy */
-
-    {   /* Get the hash for ip, compute the appropriate row */
-        U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
-        U32 const tag = hash & ZSTD_ROW_HASH_TAG_MASK;
-        U32* const row = hashTable + relRow;
-        BYTE* tagRow = (BYTE*)(tagTable + relRow);
-        U32 const headGrouped = (*tagRow & rowMask) * groupWidth;
-        U32 matchBuffer[ZSTD_ROW_HASH_MAX_ENTRIES];
-        size_t numMatches = 0;
-        size_t currMatch = 0;
-        ZSTD_VecMask matches = ZSTD_row_getMatchMask(tagRow, (BYTE)tag, headGrouped, rowEntries);
-
-        /* Cycle through the matches and prefetch */
-        for (; (matches > 0) && (nbAttempts > 0); matches &= (matches - 1)) {
-            U32 const matchPos = ((headGrouped + ZSTD_VecMask_next(matches)) / groupWidth) & rowMask;
-            U32 const matchIndex = row[matchPos];
-            if(matchPos == 0) continue;
-            assert(numMatches < rowEntries);
-            if (matchIndex < lowLimit)
-                break;
-            if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
-                PREFETCH_L1(base + matchIndex);
-            } else {
-                PREFETCH_L1(dictBase + matchIndex);
-            }
-            matchBuffer[numMatches++] = matchIndex;
-            --nbAttempts;
-        }
-
-        /* Speed opt: insert current byte into hashtable too. This allows us to avoid one iteration of the loop
-           in ZSTD_row_update_internal() at the next search. */
-        {
-            U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);
-            tagRow[pos] = (BYTE)tag;
-            row[pos] = ms->nextToUpdate++;
-        }
-
-        /* Return the longest match */
-        for (; currMatch < numMatches; ++currMatch) {
-            U32 const matchIndex = matchBuffer[currMatch];
-            size_t currentMl=0;
-            assert(matchIndex < curr);
-            assert(matchIndex >= lowLimit);
-
-            if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
-                const BYTE* const match = base + matchIndex;
-                assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */
-                /* read 4B starting from (match + ml + 1 - sizeof(U32)) */
-                if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3))   /* potentially better */
-                    currentMl = ZSTD_count(ip, match, iLimit);
-            } else {
-                const BYTE* const match = dictBase + matchIndex;
-                assert(match+4 <= dictEnd);
-                if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
-                    currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
-            }
-
-            /* Save best solution */
-            if (currentMl > ml) {
-                ml = currentMl;
-                *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);
-                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
-            }
-        }
-    }
-
-    assert(nbAttempts <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
-    if (dictMode == ZSTD_dedicatedDictSearch) {
-        ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts + ddsExtraAttempts, dms,
-                                                  ip, iLimit, prefixStart, curr, dictLimit, ddsIdx);
-    } else if (dictMode == ZSTD_dictMatchState) {
-        /* TODO: Measure and potentially add prefetching to DMS */
-        const U32 dmsLowestIndex       = dms->window.dictLimit;
-        const BYTE* const dmsBase      = dms->window.base;
-        const BYTE* const dmsEnd       = dms->window.nextSrc;
-        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);
-        const U32 dmsIndexDelta        = dictLimit - dmsSize;
-
-        {   U32 const headGrouped = (*dmsTagRow & rowMask) * groupWidth;
-            U32 matchBuffer[ZSTD_ROW_HASH_MAX_ENTRIES];
-            size_t numMatches = 0;
-            size_t currMatch = 0;
-            ZSTD_VecMask matches = ZSTD_row_getMatchMask(dmsTagRow, (BYTE)dmsTag, headGrouped, rowEntries);
-
-            for (; (matches > 0) && (nbAttempts > 0); matches &= (matches - 1)) {
-                U32 const matchPos = ((headGrouped + ZSTD_VecMask_next(matches)) / groupWidth) & rowMask;
-                U32 const matchIndex = dmsRow[matchPos];
-                if(matchPos == 0) continue;
-                if (matchIndex < dmsLowestIndex)
-                    break;
-                PREFETCH_L1(dmsBase + matchIndex);
-                matchBuffer[numMatches++] = matchIndex;
-                --nbAttempts;
-            }
-
-            /* Return the longest match */
-            for (; currMatch < numMatches; ++currMatch) {
-                U32 const matchIndex = matchBuffer[currMatch];
-                size_t currentMl=0;
-                assert(matchIndex >= dmsLowestIndex);
-                assert(matchIndex < curr);
-
-                {   const BYTE* const match = dmsBase + matchIndex;
-                    assert(match+4 <= dmsEnd);
-                    if (MEM_read32(match) == MEM_read32(ip))
-                        currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;
-                }
-
-                if (currentMl > ml) {
-                    ml = currentMl;
-                    assert(curr > matchIndex + dmsIndexDelta);
-                    *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + dmsIndexDelta));
-                    if (ip+currentMl == iLimit) break;
-                }
-            }
-        }
-    }
-    return ml;
-}
-
-
-/**
- * Generate search functions templated on (dictMode, mls, rowLog).
- * These functions are outlined for code size & compilation time.
- * ZSTD_searchMax() dispatches to the correct implementation function.
- *
- * TODO: The start of the search function involves loading and calculating a
- * bunch of constants from the ZSTD_matchState_t. These computations could be
- * done in an initialization function, and saved somewhere in the match state.
- * Then we could pass a pointer to the saved state instead of the match state,
- * and avoid duplicate computations.
- *
- * TODO: Move the match re-winding into searchMax. This improves compression
- * ratio, and unlocks further simplifications with the next TODO.
- *
- * TODO: Try moving the repcode search into searchMax. After the re-winding
- * and repcode search are in searchMax, there is no more logic in the match
- * finder loop that requires knowledge about the dictMode. So we should be
- * able to avoid force inlining it, and we can join the extDict loop with
- * the single segment loop. It should go in searchMax instead of its own
- * function to avoid having multiple virtual function calls per search.
- */
-
-#define ZSTD_BT_SEARCH_FN(dictMode, mls) ZSTD_BtFindBestMatch_##dictMode##_##mls
-#define ZSTD_HC_SEARCH_FN(dictMode, mls) ZSTD_HcFindBestMatch_##dictMode##_##mls
-#define ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog) ZSTD_RowFindBestMatch_##dictMode##_##mls##_##rowLog
-
-#define ZSTD_SEARCH_FN_ATTRS FORCE_NOINLINE
-
-#define GEN_ZSTD_BT_SEARCH_FN(dictMode, mls)                                           \
-    ZSTD_SEARCH_FN_ATTRS size_t ZSTD_BT_SEARCH_FN(dictMode, mls)(                      \
-            ZSTD_matchState_t* ms,                                                     \
-            const BYTE* ip, const BYTE* const iLimit,                                  \
-            size_t* offBasePtr)                                                        \
-    {                                                                                  \
-        assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls);                           \
-        return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, mls, ZSTD_##dictMode); \
-    }                                                                                  \
-
-#define GEN_ZSTD_HC_SEARCH_FN(dictMode, mls)                                          \
-    ZSTD_SEARCH_FN_ATTRS size_t ZSTD_HC_SEARCH_FN(dictMode, mls)(                     \
-            ZSTD_matchState_t* ms,                                                    \
-            const BYTE* ip, const BYTE* const iLimit,                                 \
-            size_t* offsetPtr)                                                        \
-    {                                                                                 \
-        assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls);                          \
-        return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, mls, ZSTD_##dictMode); \
-    }                                                                                 \
-
-#define GEN_ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)                                          \
-    ZSTD_SEARCH_FN_ATTRS size_t ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)(                     \
-            ZSTD_matchState_t* ms,                                                             \
-            const BYTE* ip, const BYTE* const iLimit,                                          \
-            size_t* offsetPtr)                                                                 \
-    {                                                                                          \
-        assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls);                                   \
-        assert(MAX(4, MIN(6, ms->cParams.searchLog)) == rowLog);                               \
-        return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, mls, ZSTD_##dictMode, rowLog); \
-    }                                                                                          \
-
-#define ZSTD_FOR_EACH_ROWLOG(X, dictMode, mls) \
-    X(dictMode, mls, 4)                        \
-    X(dictMode, mls, 5)                        \
-    X(dictMode, mls, 6)
-
-#define ZSTD_FOR_EACH_MLS_ROWLOG(X, dictMode) \
-    ZSTD_FOR_EACH_ROWLOG(X, dictMode, 4)      \
-    ZSTD_FOR_EACH_ROWLOG(X, dictMode, 5)      \
-    ZSTD_FOR_EACH_ROWLOG(X, dictMode, 6)
-
-#define ZSTD_FOR_EACH_MLS(X, dictMode) \
-    X(dictMode, 4)                     \
-    X(dictMode, 5)                     \
-    X(dictMode, 6)
-
-#define ZSTD_FOR_EACH_DICT_MODE(X, ...) \
-    X(__VA_ARGS__, noDict)              \
-    X(__VA_ARGS__, extDict)             \
-    X(__VA_ARGS__, dictMatchState)      \
-    X(__VA_ARGS__, dedicatedDictSearch)
-
-/* Generate row search fns for each combination of (dictMode, mls, rowLog) */
-ZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS_ROWLOG, GEN_ZSTD_ROW_SEARCH_FN)
-/* Generate binary Tree search fns for each combination of (dictMode, mls) */
-ZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS, GEN_ZSTD_BT_SEARCH_FN)
-/* Generate hash chain search fns for each combination of (dictMode, mls) */
-ZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS, GEN_ZSTD_HC_SEARCH_FN)
-
-typedef enum { search_hashChain=0, search_binaryTree=1, search_rowHash=2 } searchMethod_e;
-
-#define GEN_ZSTD_CALL_BT_SEARCH_FN(dictMode, mls)                         \
-    case mls:                                                             \
-        return ZSTD_BT_SEARCH_FN(dictMode, mls)(ms, ip, iend, offsetPtr);
-#define GEN_ZSTD_CALL_HC_SEARCH_FN(dictMode, mls)                         \
-    case mls:                                                             \
-        return ZSTD_HC_SEARCH_FN(dictMode, mls)(ms, ip, iend, offsetPtr);
-#define GEN_ZSTD_CALL_ROW_SEARCH_FN(dictMode, mls, rowLog)                         \
-    case rowLog:                                                                   \
-        return ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)(ms, ip, iend, offsetPtr);
-
-#define ZSTD_SWITCH_MLS(X, dictMode)   \
-    switch (mls) {                     \
-        ZSTD_FOR_EACH_MLS(X, dictMode) \
-    }
-
-#define ZSTD_SWITCH_ROWLOG(dictMode, mls)                                    \
-    case mls:                                                                \
-        switch (rowLog) {                                                    \
-            ZSTD_FOR_EACH_ROWLOG(GEN_ZSTD_CALL_ROW_SEARCH_FN, dictMode, mls) \
-        }                                                                    \
-        ZSTD_UNREACHABLE;                                                    \
-        break;
-
-#define ZSTD_SWITCH_SEARCH_METHOD(dictMode)                       \
-    switch (searchMethod) {                                       \
-        case search_hashChain:                                    \
-            ZSTD_SWITCH_MLS(GEN_ZSTD_CALL_HC_SEARCH_FN, dictMode) \
-            break;                                                \
-        case search_binaryTree:                                   \
-            ZSTD_SWITCH_MLS(GEN_ZSTD_CALL_BT_SEARCH_FN, dictMode) \
-            break;                                                \
-        case search_rowHash:                                      \
-            ZSTD_SWITCH_MLS(ZSTD_SWITCH_ROWLOG, dictMode)         \
-            break;                                                \
-    }                                                             \
-    ZSTD_UNREACHABLE;
-
-/**
- * Searches for the longest match at @p ip.
- * Dispatches to the correct implementation function based on the
- * (searchMethod, dictMode, mls, rowLog). We use switch statements
- * here instead of using an indirect function call through a function
- * pointer because after Spectre and Meltdown mitigations, indirect
- * function calls can be very costly, especially in the kernel.
- *
- * NOTE: dictMode and searchMethod should be templated, so those switch
- * statements should be optimized out. Only the mls & rowLog switches
- * should be left.
- *
- * @param ms The match state.
- * @param ip The position to search at.
- * @param iend The end of the input data.
- * @param[out] offsetPtr Stores the match offset into this pointer.
- * @param mls The minimum search length, in the range [4, 6].
- * @param rowLog The row log (if applicable), in the range [4, 6].
- * @param searchMethod The search method to use (templated).
- * @param dictMode The dictMode (templated).
- *
- * @returns The length of the longest match found, or < mls if no match is found.
- * If a match is found its offset is stored in @p offsetPtr.
- */
-FORCE_INLINE_TEMPLATE size_t ZSTD_searchMax(
-    ZSTD_matchState_t* ms,
-    const BYTE* ip,
-    const BYTE* iend,
-    size_t* offsetPtr,
-    U32 const mls,
-    U32 const rowLog,
-    searchMethod_e const searchMethod,
-    ZSTD_dictMode_e const dictMode)
-{
-    if (dictMode == ZSTD_noDict) {
-        ZSTD_SWITCH_SEARCH_METHOD(noDict)
-    } else if (dictMode == ZSTD_extDict) {
-        ZSTD_SWITCH_SEARCH_METHOD(extDict)
-    } else if (dictMode == ZSTD_dictMatchState) {
-        ZSTD_SWITCH_SEARCH_METHOD(dictMatchState)
-    } else if (dictMode == ZSTD_dedicatedDictSearch) {
-        ZSTD_SWITCH_SEARCH_METHOD(dedicatedDictSearch)
-    }
-    ZSTD_UNREACHABLE;
-    return 0;
-}
-
-/* *******************************
-*  Common parser - lazy strategy
-*********************************/
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_lazy_generic(
-                        ZSTD_matchState_t* ms, seqStore_t* seqStore,
-                        U32 rep[ZSTD_REP_NUM],
-                        const void* src, size_t srcSize,
-                        const searchMethod_e searchMethod, const U32 depth,
-                        ZSTD_dictMode_e const dictMode)
-{
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = (searchMethod == search_rowHash) ? iend - 8 - ZSTD_ROW_HASH_CACHE_SIZE : iend - 8;
-    const BYTE* const base = ms->window.base;
-    const U32 prefixLowestIndex = ms->window.dictLimit;
-    const BYTE* const prefixLowest = base + prefixLowestIndex;
-    const U32 mls = BOUNDED(4, ms->cParams.minMatch, 6);
-    const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);
-
-    U32 offset_1 = rep[0], offset_2 = rep[1];
-    U32 offsetSaved1 = 0, offsetSaved2 = 0;
-
-    const int isDMS = dictMode == ZSTD_dictMatchState;
-    const int isDDS = dictMode == ZSTD_dedicatedDictSearch;
-    const int isDxS = isDMS || isDDS;
-    const ZSTD_matchState_t* const dms = ms->dictMatchState;
-    const U32 dictLowestIndex      = isDxS ? dms->window.dictLimit : 0;
-    const BYTE* const dictBase     = isDxS ? dms->window.base : NULL;
-    const BYTE* const dictLowest   = isDxS ? dictBase + dictLowestIndex : NULL;
-    const BYTE* const dictEnd      = isDxS ? dms->window.nextSrc : NULL;
-    const U32 dictIndexDelta       = isDxS ?
-                                     prefixLowestIndex - (U32)(dictEnd - dictBase) :
-                                     0;
-    const U32 dictAndPrefixLength = (U32)((ip - prefixLowest) + (dictEnd - dictLowest));
-
-    DEBUGLOG(5, "ZSTD_compressBlock_lazy_generic (dictMode=%u) (searchFunc=%u)", (U32)dictMode, (U32)searchMethod);
-    ip += (dictAndPrefixLength == 0);
-    if (dictMode == ZSTD_noDict) {
-        U32 const curr = (U32)(ip - base);
-        U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, ms->cParams.windowLog);
-        U32 const maxRep = curr - windowLow;
-        if (offset_2 > maxRep) offsetSaved2 = offset_2, offset_2 = 0;
-        if (offset_1 > maxRep) offsetSaved1 = offset_1, offset_1 = 0;
-    }
-    if (isDxS) {
-        /* dictMatchState repCode checks don't currently handle repCode == 0
-         * disabling. */
-        assert(offset_1 <= dictAndPrefixLength);
-        assert(offset_2 <= dictAndPrefixLength);
-    }
-
-    /* Reset the lazy skipping state */
-    ms->lazySkipping = 0;
-
-    if (searchMethod == search_rowHash) {
-        ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
-    }
-
-    /* Match Loop */
-#if defined(__GNUC__) && defined(__x86_64__)
-    /* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the
-     * code alignment is perturbed. To fix the instability align the loop on 32-bytes.
-     */
-    __asm__(".p2align 5");
-#endif
-    while (ip < ilimit) {
-        size_t matchLength=0;
-        size_t offBase = REPCODE1_TO_OFFBASE;
-        const BYTE* start=ip+1;
-        DEBUGLOG(7, "search baseline (depth 0)");
-
-        /* check repCode */
-        if (isDxS) {
-            const U32 repIndex = (U32)(ip - base) + 1 - offset_1;
-            const BYTE* repMatch = ((dictMode == ZSTD_dictMatchState || dictMode == ZSTD_dedicatedDictSearch)
-                                && repIndex < prefixLowestIndex) ?
-                                   dictBase + (repIndex - dictIndexDelta) :
-                                   base + repIndex;
-            if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
-                && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-                const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
-                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
-                if (depth==0) goto _storeSequence;
-            }
-        }
-        if ( dictMode == ZSTD_noDict
-          && ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {
-            matchLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
-            if (depth==0) goto _storeSequence;
-        }
-
-        /* first search (depth 0) */
-        {   size_t offbaseFound = 999999999;
-            size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &offbaseFound, mls, rowLog, searchMethod, dictMode);
-            if (ml2 > matchLength)
-                matchLength = ml2, start = ip, offBase = offbaseFound;
-        }
-
-        if (matchLength < 4) {
-            size_t const step = ((size_t)(ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */;
-            ip += step;
-            /* Enter the lazy skipping mode once we are skipping more than 8 bytes at a time.
-             * In this mode we stop inserting every position into our tables, and only insert
-             * positions that we search, which is one in step positions.
-             * The exact cutoff is flexible, I've just chosen a number that is reasonably high,
-             * so we minimize the compression ratio loss in "normal" scenarios. This mode gets
-             * triggered once we've gone 2KB without finding any matches.
-             */
-            ms->lazySkipping = step > kLazySkippingStep;
-            continue;
-        }
-
-        /* let's try to find a better solution */
-        if (depth>=1)
-        while (ip<ilimit) {
-            DEBUGLOG(7, "search depth 1");
-            ip ++;
-            if ( (dictMode == ZSTD_noDict)
-              && (offBase) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
-                size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
-                int const gain2 = (int)(mlRep * 3);
-                int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offBase) + 1);
-                if ((mlRep >= 4) && (gain2 > gain1))
-                    matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;
-            }
-            if (isDxS) {
-                const U32 repIndex = (U32)(ip - base) - offset_1;
-                const BYTE* repMatch = repIndex < prefixLowestIndex ?
-                               dictBase + (repIndex - dictIndexDelta) :
-                               base + repIndex;
-                if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
-                    && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
-                    const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
-                    size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
-                    int const gain2 = (int)(mlRep * 3);
-                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offBase) + 1);
-                    if ((mlRep >= 4) && (gain2 > gain1))
-                        matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;
-                }
-            }
-            {   size_t ofbCandidate=999999999;
-                size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, dictMode);
-                int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */
-                int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 4);
-                if ((ml2 >= 4) && (gain2 > gain1)) {
-                    matchLength = ml2, offBase = ofbCandidate, start = ip;
-                    continue;   /* search a better one */
-            }   }
-
-            /* let's find an even better one */
-            if ((depth==2) && (ip<ilimit)) {
-                DEBUGLOG(7, "search depth 2");
-                ip ++;
-                if ( (dictMode == ZSTD_noDict)
-                  && (offBase) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
-                    size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
-                    int const gain2 = (int)(mlRep * 4);
-                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 1);
-                    if ((mlRep >= 4) && (gain2 > gain1))
-                        matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;
-                }
-                if (isDxS) {
-                    const U32 repIndex = (U32)(ip - base) - offset_1;
-                    const BYTE* repMatch = repIndex < prefixLowestIndex ?
-                                   dictBase + (repIndex - dictIndexDelta) :
-                                   base + repIndex;
-                    if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
-                        && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
-                        const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
-                        size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
-                        int const gain2 = (int)(mlRep * 4);
-                        int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 1);
-                        if ((mlRep >= 4) && (gain2 > gain1))
-                            matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;
-                    }
-                }
-                {   size_t ofbCandidate=999999999;
-                    size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, dictMode);
-                    int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */
-                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 7);
-                    if ((ml2 >= 4) && (gain2 > gain1)) {
-                        matchLength = ml2, offBase = ofbCandidate, start = ip;
-                        continue;
-            }   }   }
-            break;  /* nothing found : store previous solution */
-        }
-
-        /* NOTE:
-         * Pay attention that `start[-value]` can lead to strange undefined behavior
-         * notably if `value` is unsigned, resulting in a large positive `-value`.
-         */
-        /* catch up */
-        if (OFFBASE_IS_OFFSET(offBase)) {
-            if (dictMode == ZSTD_noDict) {
-                while ( ((start > anchor) & (start - OFFBASE_TO_OFFSET(offBase) > prefixLowest))
-                     && (start[-1] == (start-OFFBASE_TO_OFFSET(offBase))[-1]) )  /* only search for offset within prefix */
-                    { start--; matchLength++; }
-            }
-            if (isDxS) {
-                U32 const matchIndex = (U32)((size_t)(start-base) - OFFBASE_TO_OFFSET(offBase));
-                const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex;
-                const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;
-                while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
-            }
-            offset_2 = offset_1; offset_1 = (U32)OFFBASE_TO_OFFSET(offBase);
-        }
-        /* store sequence */
-_storeSequence:
-        {   size_t const litLength = (size_t)(start - anchor);
-            ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offBase, matchLength);
-            anchor = ip = start + matchLength;
-        }
-        if (ms->lazySkipping) {
-            /* We've found a match, disable lazy skipping mode, and refill the hash cache. */
-            if (searchMethod == search_rowHash) {
-                ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
-            }
-            ms->lazySkipping = 0;
-        }
-
-        /* check immediate repcode */
-        if (isDxS) {
-            while (ip <= ilimit) {
-                U32 const current2 = (U32)(ip-base);
-                U32 const repIndex = current2 - offset_2;
-                const BYTE* repMatch = repIndex < prefixLowestIndex ?
-                        dictBase - dictIndexDelta + repIndex :
-                        base + repIndex;
-                if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex) >= 3 /* intentional overflow */)
-                   && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
-                    const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;
-                    matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4;
-                    offBase = offset_2; offset_2 = offset_1; offset_1 = (U32)offBase;   /* swap offset_2 <=> offset_1 */
-                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, matchLength);
-                    ip += matchLength;
-                    anchor = ip;
-                    continue;
-                }
-                break;
-            }
-        }
-
-        if (dictMode == ZSTD_noDict) {
-            while ( ((ip <= ilimit) & (offset_2>0))
-                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
-                /* store sequence */
-                matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
-                offBase = offset_2; offset_2 = offset_1; offset_1 = (U32)offBase; /* swap repcodes */
-                ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, matchLength);
-                ip += matchLength;
-                anchor = ip;
-                continue;   /* faster when present ... (?) */
-    }   }   }
-
-    /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0),
-     * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */
-    offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2;
-
-    /* save reps for next block */
-    rep[0] = offset_1 ? offset_1 : offsetSaved1;
-    rep[1] = offset_2 ? offset_2 : offsetSaved2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-}
-#endif /* build exclusions */
-
-
-#ifndef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_greedy(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_greedy_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_greedy_dedicatedDictSearch(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dedicatedDictSearch);
-}
-
-size_t ZSTD_compressBlock_greedy_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_greedy_dictMatchState_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_greedy_dedicatedDictSearch_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_dedicatedDictSearch);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_lazy(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_lazy_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_lazy_dedicatedDictSearch(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dedicatedDictSearch);
-}
-
-size_t ZSTD_compressBlock_lazy_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_lazy_dictMatchState_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_lazy_dedicatedDictSearch_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1, ZSTD_dedicatedDictSearch);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_lazy2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_lazy2_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dedicatedDictSearch);
-}
-
-size_t ZSTD_compressBlock_lazy2_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_lazy2_dictMatchState_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_dedicatedDictSearch);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btlazy2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_btlazy2_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_dictMatchState);
-}
-#endif
-
-#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR)
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_compressBlock_lazy_extDict_generic(
-                        ZSTD_matchState_t* ms, seqStore_t* seqStore,
-                        U32 rep[ZSTD_REP_NUM],
-                        const void* src, size_t srcSize,
-                        const searchMethod_e searchMethod, const U32 depth)
-{
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = searchMethod == search_rowHash ? iend - 8 - ZSTD_ROW_HASH_CACHE_SIZE : iend - 8;
-    const BYTE* const base = ms->window.base;
-    const U32 dictLimit = ms->window.dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const BYTE* const dictEnd  = dictBase + dictLimit;
-    const BYTE* const dictStart  = dictBase + ms->window.lowLimit;
-    const U32 windowLog = ms->cParams.windowLog;
-    const U32 mls = BOUNDED(4, ms->cParams.minMatch, 6);
-    const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);
-
-    U32 offset_1 = rep[0], offset_2 = rep[1];
-
-    DEBUGLOG(5, "ZSTD_compressBlock_lazy_extDict_generic (searchFunc=%u)", (U32)searchMethod);
-
-    /* Reset the lazy skipping state */
-    ms->lazySkipping = 0;
-
-    /* init */
-    ip += (ip == prefixStart);
-    if (searchMethod == search_rowHash) {
-        ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
-    }
-
-    /* Match Loop */
-#if defined(__GNUC__) && defined(__x86_64__)
-    /* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the
-     * code alignment is perturbed. To fix the instability align the loop on 32-bytes.
-     */
-    __asm__(".p2align 5");
-#endif
-    while (ip < ilimit) {
-        size_t matchLength=0;
-        size_t offBase = REPCODE1_TO_OFFBASE;
-        const BYTE* start=ip+1;
-        U32 curr = (U32)(ip-base);
-
-        /* check repCode */
-        {   const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr+1, windowLog);
-            const U32 repIndex = (U32)(curr+1 - offset_1);
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-            const BYTE* const repMatch = repBase + repIndex;
-            if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow */
-               & (offset_1 <= curr+1 - windowLow) ) /* note: we are searching at curr+1 */
-            if (MEM_read32(ip+1) == MEM_read32(repMatch)) {
-                /* repcode detected we should take it */
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4;
-                if (depth==0) goto _storeSequence;
-        }   }
-
-        /* first search (depth 0) */
-        {   size_t ofbCandidate = 999999999;
-            size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, ZSTD_extDict);
-            if (ml2 > matchLength)
-                matchLength = ml2, start = ip, offBase = ofbCandidate;
-        }
-
-        if (matchLength < 4) {
-            size_t const step = ((size_t)(ip-anchor) >> kSearchStrength);
-            ip += step + 1;   /* jump faster over incompressible sections */
-            /* Enter the lazy skipping mode once we are skipping more than 8 bytes at a time.
-             * In this mode we stop inserting every position into our tables, and only insert
-             * positions that we search, which is one in step positions.
-             * The exact cutoff is flexible, I've just chosen a number that is reasonably high,
-             * so we minimize the compression ratio loss in "normal" scenarios. This mode gets
-             * triggered once we've gone 2KB without finding any matches.
-             */
-            ms->lazySkipping = step > kLazySkippingStep;
-            continue;
-        }
-
-        /* let's try to find a better solution */
-        if (depth>=1)
-        while (ip<ilimit) {
-            ip ++;
-            curr++;
-            /* check repCode */
-            if (offBase) {
-                const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog);
-                const U32 repIndex = (U32)(curr - offset_1);
-                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                const BYTE* const repMatch = repBase + repIndex;
-                if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow : do not test positions overlapping 2 memory segments  */
-                   & (offset_1 <= curr - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */
-                if (MEM_read32(ip) == MEM_read32(repMatch)) {
-                    /* repcode detected */
-                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                    size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
-                    int const gain2 = (int)(repLength * 3);
-                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offBase) + 1);
-                    if ((repLength >= 4) && (gain2 > gain1))
-                        matchLength = repLength, offBase = REPCODE1_TO_OFFBASE, start = ip;
-            }   }
-
-            /* search match, depth 1 */
-            {   size_t ofbCandidate = 999999999;
-                size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, ZSTD_extDict);
-                int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */
-                int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 4);
-                if ((ml2 >= 4) && (gain2 > gain1)) {
-                    matchLength = ml2, offBase = ofbCandidate, start = ip;
-                    continue;   /* search a better one */
-            }   }
-
-            /* let's find an even better one */
-            if ((depth==2) && (ip<ilimit)) {
-                ip ++;
-                curr++;
-                /* check repCode */
-                if (offBase) {
-                    const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog);
-                    const U32 repIndex = (U32)(curr - offset_1);
-                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                    const BYTE* const repMatch = repBase + repIndex;
-                    if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow : do not test positions overlapping 2 memory segments  */
-                       & (offset_1 <= curr - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */
-                    if (MEM_read32(ip) == MEM_read32(repMatch)) {
-                        /* repcode detected */
-                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                        size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
-                        int const gain2 = (int)(repLength * 4);
-                        int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 1);
-                        if ((repLength >= 4) && (gain2 > gain1))
-                            matchLength = repLength, offBase = REPCODE1_TO_OFFBASE, start = ip;
-                }   }
-
-                /* search match, depth 2 */
-                {   size_t ofbCandidate = 999999999;
-                    size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, ZSTD_extDict);
-                    int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */
-                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 7);
-                    if ((ml2 >= 4) && (gain2 > gain1)) {
-                        matchLength = ml2, offBase = ofbCandidate, start = ip;
-                        continue;
-            }   }   }
-            break;  /* nothing found : store previous solution */
-        }
-
-        /* catch up */
-        if (OFFBASE_IS_OFFSET(offBase)) {
-            U32 const matchIndex = (U32)((size_t)(start-base) - OFFBASE_TO_OFFSET(offBase));
-            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
-            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
-            while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
-            offset_2 = offset_1; offset_1 = (U32)OFFBASE_TO_OFFSET(offBase);
-        }
-
-        /* store sequence */
-_storeSequence:
-        {   size_t const litLength = (size_t)(start - anchor);
-            ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offBase, matchLength);
-            anchor = ip = start + matchLength;
-        }
-        if (ms->lazySkipping) {
-            /* We've found a match, disable lazy skipping mode, and refill the hash cache. */
-            if (searchMethod == search_rowHash) {
-                ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
-            }
-            ms->lazySkipping = 0;
-        }
-
-        /* check immediate repcode */
-        while (ip <= ilimit) {
-            const U32 repCurrent = (U32)(ip-base);
-            const U32 windowLow = ZSTD_getLowestMatchIndex(ms, repCurrent, windowLog);
-            const U32 repIndex = repCurrent - offset_2;
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-            const BYTE* const repMatch = repBase + repIndex;
-            if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow : do not test positions overlapping 2 memory segments  */
-               & (offset_2 <= repCurrent - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */
-            if (MEM_read32(ip) == MEM_read32(repMatch)) {
-                /* repcode detected we should take it */
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
-                offBase = offset_2; offset_2 = offset_1; offset_1 = (U32)offBase;   /* swap offset history */
-                ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, matchLength);
-                ip += matchLength;
-                anchor = ip;
-                continue;   /* faster when present ... (?) */
-            }
-            break;
-    }   }
-
-    /* Save reps for next block */
-    rep[0] = offset_1;
-    rep[1] = offset_2;
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-}
-#endif /* build exclusions */
-
-#ifndef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_greedy_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0);
-}
-
-size_t ZSTD_compressBlock_greedy_extDict_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_lazy_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);
-}
-
-size_t ZSTD_compressBlock_lazy_extDict_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_lazy2_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);
-}
-
-size_t ZSTD_compressBlock_lazy2_extDict_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btlazy2_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-
-{
-    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);
-}
-#endif
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_ldm.cpp b/src/duckdb/third_party/zstd/compress/zstd_ldm.cpp
deleted file mode 100644
index a83bf7415..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_ldm.cpp
+++ /dev/null
@@ -1,735 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd/compress/zstd_ldm.h"
-
-#include "zstd/common/debug.h"
-#include "zstd/common/xxhash.hpp"
-#include "zstd/common/xxhash_static.hpp"
-#include "zstd/compress/zstd_fast.h"          /* ZSTD_fillHashTable() */
-#include "zstd/compress/zstd_double_fast.h"   /* ZSTD_fillDoubleHashTable() */
-#include "zstd/compress/zstd_ldm_geartab.h"
-
-#define LDM_BUCKET_SIZE_LOG 3
-#define LDM_MIN_MATCH_LENGTH 64
-#define LDM_HASH_RLOG 7
-
-namespace duckdb_zstd {
-
-typedef struct {
-    U64 rolling;
-    U64 stopMask;
-} ldmRollingHashState_t;
-
-/** ZSTD_ldm_gear_init():
- *
- * Initializes the rolling hash state such that it will honor the
- * settings in params. */
-static void ZSTD_ldm_gear_init(ldmRollingHashState_t* state, ldmParams_t const* params)
-{
-    unsigned maxBitsInMask = MIN(params->minMatchLength, 64);
-    unsigned hashRateLog = params->hashRateLog;
-
-    state->rolling = ~(U32)0;
-
-    /* The choice of the splitting criterion is subject to two conditions:
-     *   1. it has to trigger on average every 2^(hashRateLog) bytes;
-     *   2. ideally, it has to depend on a window of minMatchLength bytes.
-     *
-     * In the gear hash algorithm, bit n depends on the last n bytes;
-     * so in order to obtain a good quality splitting criterion it is
-     * preferable to use bits with high weight.
-     *
-     * To match condition 1 we use a mask with hashRateLog bits set
-     * and, because of the previous remark, we make sure these bits
-     * have the highest possible weight while still respecting
-     * condition 2.
-     */
-    if (hashRateLog > 0 && hashRateLog <= maxBitsInMask) {
-        state->stopMask = (((U64)1 << hashRateLog) - 1) << (maxBitsInMask - hashRateLog);
-    } else {
-        /* In this degenerate case we simply honor the hash rate. */
-        state->stopMask = ((U64)1 << hashRateLog) - 1;
-    }
-}
-
-/** ZSTD_ldm_gear_reset()
- * Feeds [data, data + minMatchLength) into the hash without registering any
- * splits. This effectively resets the hash state. This is used when skipping
- * over data, either at the beginning of a block, or skipping sections.
- */
-static void ZSTD_ldm_gear_reset(ldmRollingHashState_t* state,
-                                BYTE const* data, size_t minMatchLength)
-{
-    U64 hash = state->rolling;
-    size_t n = 0;
-
-#define GEAR_ITER_ONCE() do {                                  \
-        hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; \
-        n += 1;                                                \
-    } while (0)
-    while (n + 3 < minMatchLength) {
-        GEAR_ITER_ONCE();
-        GEAR_ITER_ONCE();
-        GEAR_ITER_ONCE();
-        GEAR_ITER_ONCE();
-    }
-    while (n < minMatchLength) {
-        GEAR_ITER_ONCE();
-    }
-#undef GEAR_ITER_ONCE
-}
-
-/** ZSTD_ldm_gear_feed():
- *
- * Registers in the splits array all the split points found in the first
- * size bytes following the data pointer. This function terminates when
- * either all the data has been processed or LDM_BATCH_SIZE splits are
- * present in the splits array.
- *
- * Precondition: The splits array must not be full.
- * Returns: The number of bytes processed. */
-static size_t ZSTD_ldm_gear_feed(ldmRollingHashState_t* state,
-                                 BYTE const* data, size_t size,
-                                 size_t* splits, unsigned* numSplits)
-{
-    size_t n;
-    U64 hash, mask;
-
-    hash = state->rolling;
-    mask = state->stopMask;
-    n = 0;
-
-#define GEAR_ITER_ONCE() do { \
-        hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; \
-        n += 1; \
-        if (UNLIKELY((hash & mask) == 0)) { \
-            splits[*numSplits] = n; \
-            *numSplits += 1; \
-            if (*numSplits == LDM_BATCH_SIZE) \
-                goto done; \
-        } \
-    } while (0)
-
-    while (n + 3 < size) {
-        GEAR_ITER_ONCE();
-        GEAR_ITER_ONCE();
-        GEAR_ITER_ONCE();
-        GEAR_ITER_ONCE();
-    }
-    while (n < size) {
-        GEAR_ITER_ONCE();
-    }
-
-#undef GEAR_ITER_ONCE
-
-done:
-    state->rolling = hash;
-    return n;
-}
-
-void ZSTD_ldm_adjustParameters(ldmParams_t* params,
-                               ZSTD_compressionParameters const* cParams)
-{
-    params->windowLog = cParams->windowLog;
-    ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX);
-    DEBUGLOG(4, "ZSTD_ldm_adjustParameters");
-    if (!params->bucketSizeLog) params->bucketSizeLog = LDM_BUCKET_SIZE_LOG;
-    if (!params->minMatchLength) params->minMatchLength = LDM_MIN_MATCH_LENGTH;
-    if (params->hashLog == 0) {
-        params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG);
-        assert(params->hashLog <= ZSTD_HASHLOG_MAX);
-    }
-    if (params->hashRateLog == 0) {
-        params->hashRateLog = params->windowLog < params->hashLog
-                                   ? 0
-                                   : params->windowLog - params->hashLog;
-    }
-    params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);
-}
-
-size_t ZSTD_ldm_getTableSize(ldmParams_t params)
-{
-    size_t const ldmHSize = ((size_t)1) << params.hashLog;
-    size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);
-    size_t const ldmBucketSize = ((size_t)1) << (params.hashLog - ldmBucketSizeLog);
-    size_t const totalSize = ZSTD_cwksp_alloc_size(ldmBucketSize)
-                           + ZSTD_cwksp_alloc_size(ldmHSize * sizeof(ldmEntry_t));
-    return params.enableLdm == ZSTD_ps_enable ? totalSize : 0;
-}
-
-size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize)
-{
-    return params.enableLdm == ZSTD_ps_enable ? (maxChunkSize / params.minMatchLength) : 0;
-}
-
-/** ZSTD_ldm_getBucket() :
- *  Returns a pointer to the start of the bucket associated with hash. */
-static ldmEntry_t* ZSTD_ldm_getBucket(
-        ldmState_t* ldmState, size_t hash, ldmParams_t const ldmParams)
-{
-    return ldmState->hashTable + (hash << ldmParams.bucketSizeLog);
-}
-
-/** ZSTD_ldm_insertEntry() :
- *  Insert the entry with corresponding hash into the hash table */
-static void ZSTD_ldm_insertEntry(ldmState_t* ldmState,
-                                 size_t const hash, const ldmEntry_t entry,
-                                 ldmParams_t const ldmParams)
-{
-    BYTE* const pOffset = ldmState->bucketOffsets + hash;
-    unsigned const offset = *pOffset;
-
-    *(ZSTD_ldm_getBucket(ldmState, hash, ldmParams) + offset) = entry;
-    *pOffset = (BYTE)((offset + 1) & ((1u << ldmParams.bucketSizeLog) - 1));
-
-}
-
-/** ZSTD_ldm_countBackwardsMatch() :
- *  Returns the number of bytes that match backwards before pIn and pMatch.
- *
- *  We count only bytes where pMatch >= pBase and pIn >= pAnchor. */
-static size_t ZSTD_ldm_countBackwardsMatch(
-            const BYTE* pIn, const BYTE* pAnchor,
-            const BYTE* pMatch, const BYTE* pMatchBase)
-{
-    size_t matchLength = 0;
-    while (pIn > pAnchor && pMatch > pMatchBase && pIn[-1] == pMatch[-1]) {
-        pIn--;
-        pMatch--;
-        matchLength++;
-    }
-    return matchLength;
-}
-
-/** ZSTD_ldm_countBackwardsMatch_2segments() :
- *  Returns the number of bytes that match backwards from pMatch,
- *  even with the backwards match spanning 2 different segments.
- *
- *  On reaching `pMatchBase`, start counting from mEnd */
-static size_t ZSTD_ldm_countBackwardsMatch_2segments(
-                    const BYTE* pIn, const BYTE* pAnchor,
-                    const BYTE* pMatch, const BYTE* pMatchBase,
-                    const BYTE* pExtDictStart, const BYTE* pExtDictEnd)
-{
-    size_t matchLength = ZSTD_ldm_countBackwardsMatch(pIn, pAnchor, pMatch, pMatchBase);
-    if (pMatch - matchLength != pMatchBase || pMatchBase == pExtDictStart) {
-        /* If backwards match is entirely in the extDict or prefix, immediately return */
-        return matchLength;
-    }
-    DEBUGLOG(7, "ZSTD_ldm_countBackwardsMatch_2segments: found 2-parts backwards match (length in prefix==%zu)", matchLength);
-    matchLength += ZSTD_ldm_countBackwardsMatch(pIn - matchLength, pAnchor, pExtDictEnd, pExtDictStart);
-    DEBUGLOG(7, "final backwards match length = %zu", matchLength);
-    return matchLength;
-}
-
-/** ZSTD_ldm_fillFastTables() :
- *
- *  Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies.
- *  This is similar to ZSTD_loadDictionaryContent.
- *
- *  The tables for the other strategies are filled within their
- *  block compressors. */
-static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
-                                      void const* end)
-{
-    const BYTE* const iend = (const BYTE*)end;
-
-    switch(ms->cParams.strategy)
-    {
-    case ZSTD_fast:
-        ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast, ZSTD_tfp_forCCtx);
-        break;
-
-    case ZSTD_dfast:
-#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR
-        ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast, ZSTD_tfp_forCCtx);
-#else
-        assert(0); /* shouldn't be called: cparams should've been adjusted. */
-#endif
-        break;
-
-    case ZSTD_greedy:
-    case ZSTD_lazy:
-    case ZSTD_lazy2:
-    case ZSTD_btlazy2:
-    case ZSTD_btopt:
-    case ZSTD_btultra:
-    case ZSTD_btultra2:
-        break;
-    default:
-        assert(0);  /* not possible : not a valid strategy id */
-    }
-
-    return 0;
-}
-
-void ZSTD_ldm_fillHashTable(
-            ldmState_t* ldmState, const BYTE* ip,
-            const BYTE* iend, ldmParams_t const* params)
-{
-    U32 const minMatchLength = params->minMatchLength;
-    U32 const hBits = params->hashLog - params->bucketSizeLog;
-    BYTE const* const base = ldmState->window.base;
-    BYTE const* const istart = ip;
-    ldmRollingHashState_t hashState;
-    size_t* const splits = ldmState->splitIndices;
-    unsigned numSplits;
-
-    DEBUGLOG(5, "ZSTD_ldm_fillHashTable");
-
-    ZSTD_ldm_gear_init(&hashState, params);
-    while (ip < iend) {
-        size_t hashed;
-        unsigned n;
-
-        numSplits = 0;
-        hashed = ZSTD_ldm_gear_feed(&hashState, ip, iend - ip, splits, &numSplits);
-
-        for (n = 0; n < numSplits; n++) {
-            if (ip + splits[n] >= istart + minMatchLength) {
-                BYTE const* const split = ip + splits[n] - minMatchLength;
-                U64 const xxhash = XXH64(split, minMatchLength, 0);
-                U32 const hash = (U32)(xxhash & (((U32)1 << hBits) - 1));
-                ldmEntry_t entry;
-
-                entry.offset = (U32)(split - base);
-                entry.checksum = (U32)(xxhash >> 32);
-                ZSTD_ldm_insertEntry(ldmState, hash, entry, *params);
-            }
-        }
-
-        ip += hashed;
-    }
-}
-
-
-/** ZSTD_ldm_limitTableUpdate() :
- *
- *  Sets cctx->nextToUpdate to a position corresponding closer to anchor
- *  if it is far way
- *  (after a long match, only update tables a limited amount). */
-static void ZSTD_ldm_limitTableUpdate(ZSTD_matchState_t* ms, const BYTE* anchor)
-{
-    U32 const curr = (U32)(anchor - ms->window.base);
-    if (curr > ms->nextToUpdate + 1024) {
-        ms->nextToUpdate =
-            curr - MIN(512, curr - ms->nextToUpdate - 1024);
-    }
-}
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_ldm_generateSequences_internal(
-        ldmState_t* ldmState, rawSeqStore_t* rawSeqStore,
-        ldmParams_t const* params, void const* src, size_t srcSize)
-{
-    /* LDM parameters */
-    int const extDict = ZSTD_window_hasExtDict(ldmState->window);
-    U32 const minMatchLength = params->minMatchLength;
-    U32 const entsPerBucket = 1U << params->bucketSizeLog;
-    U32 const hBits = params->hashLog - params->bucketSizeLog;
-    /* Prefix and extDict parameters */
-    U32 const dictLimit = ldmState->window.dictLimit;
-    U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit;
-    BYTE const* const base = ldmState->window.base;
-    BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL;
-    BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL;
-    BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL;
-    BYTE const* const lowPrefixPtr = base + dictLimit;
-    /* Input bounds */
-    BYTE const* const istart = (BYTE const*)src;
-    BYTE const* const iend = istart + srcSize;
-    BYTE const* const ilimit = iend - HASH_READ_SIZE;
-    /* Input positions */
-    BYTE const* anchor = istart;
-    BYTE const* ip = istart;
-    /* Rolling hash state */
-    ldmRollingHashState_t hashState;
-    /* Arrays for staged-processing */
-    size_t* const splits = ldmState->splitIndices;
-    ldmMatchCandidate_t* const candidates = ldmState->matchCandidates;
-    unsigned numSplits;
-
-    if (srcSize < minMatchLength)
-        return iend - anchor;
-
-    /* Initialize the rolling hash state with the first minMatchLength bytes */
-    ZSTD_ldm_gear_init(&hashState, params);
-    ZSTD_ldm_gear_reset(&hashState, ip, minMatchLength);
-    ip += minMatchLength;
-
-    while (ip < ilimit) {
-        size_t hashed;
-        unsigned n;
-
-        numSplits = 0;
-        hashed = ZSTD_ldm_gear_feed(&hashState, ip, ilimit - ip,
-                                    splits, &numSplits);
-
-        for (n = 0; n < numSplits; n++) {
-            BYTE const* const split = ip + splits[n] - minMatchLength;
-            U64 const xxhash = XXH64(split, minMatchLength, 0);
-            U32 const hash = (U32)(xxhash & (((U32)1 << hBits) - 1));
-
-            candidates[n].split = split;
-            candidates[n].hash = hash;
-            candidates[n].checksum = (U32)(xxhash >> 32);
-            candidates[n].bucket = ZSTD_ldm_getBucket(ldmState, hash, *params);
-            PREFETCH_L1(candidates[n].bucket);
-        }
-
-        for (n = 0; n < numSplits; n++) {
-            size_t forwardMatchLength = 0, backwardMatchLength = 0,
-                   bestMatchLength = 0, mLength;
-            U32 offset;
-            BYTE const* const split = candidates[n].split;
-            U32 const checksum = candidates[n].checksum;
-            U32 const hash = candidates[n].hash;
-            ldmEntry_t* const bucket = candidates[n].bucket;
-            ldmEntry_t const* cur;
-            ldmEntry_t const* bestEntry = NULL;
-            ldmEntry_t newEntry;
-
-            newEntry.offset = (U32)(split - base);
-            newEntry.checksum = checksum;
-
-            /* If a split point would generate a sequence overlapping with
-             * the previous one, we merely register it in the hash table and
-             * move on */
-            if (split < anchor) {
-                ZSTD_ldm_insertEntry(ldmState, hash, newEntry, *params);
-                continue;
-            }
-
-            for (cur = bucket; cur < bucket + entsPerBucket; cur++) {
-                size_t curForwardMatchLength, curBackwardMatchLength,
-                       curTotalMatchLength;
-                if (cur->checksum != checksum || cur->offset <= lowestIndex) {
-                    continue;
-                }
-                if (extDict) {
-                    BYTE const* const curMatchBase =
-                        cur->offset < dictLimit ? dictBase : base;
-                    BYTE const* const pMatch = curMatchBase + cur->offset;
-                    BYTE const* const matchEnd =
-                        cur->offset < dictLimit ? dictEnd : iend;
-                    BYTE const* const lowMatchPtr =
-                        cur->offset < dictLimit ? dictStart : lowPrefixPtr;
-                    curForwardMatchLength =
-                        ZSTD_count_2segments(split, pMatch, iend, matchEnd, lowPrefixPtr);
-                    if (curForwardMatchLength < minMatchLength) {
-                        continue;
-                    }
-                    curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch_2segments(
-                            split, anchor, pMatch, lowMatchPtr, dictStart, dictEnd);
-                } else { /* !extDict */
-                    BYTE const* const pMatch = base + cur->offset;
-                    curForwardMatchLength = ZSTD_count(split, pMatch, iend);
-                    if (curForwardMatchLength < minMatchLength) {
-                        continue;
-                    }
-                    curBackwardMatchLength =
-                        ZSTD_ldm_countBackwardsMatch(split, anchor, pMatch, lowPrefixPtr);
-                }
-                curTotalMatchLength = curForwardMatchLength + curBackwardMatchLength;
-
-                if (curTotalMatchLength > bestMatchLength) {
-                    bestMatchLength = curTotalMatchLength;
-                    forwardMatchLength = curForwardMatchLength;
-                    backwardMatchLength = curBackwardMatchLength;
-                    bestEntry = cur;
-                }
-            }
-
-            /* No match found -- insert an entry into the hash table
-             * and process the next candidate match */
-            if (bestEntry == NULL) {
-                ZSTD_ldm_insertEntry(ldmState, hash, newEntry, *params);
-                continue;
-            }
-
-            /* Match found */
-            offset = (U32)(split - base) - bestEntry->offset;
-            mLength = forwardMatchLength + backwardMatchLength;
-            {
-                rawSeq* const seq = rawSeqStore->seq + rawSeqStore->size;
-
-                /* Out of sequence storage */
-                if (rawSeqStore->size == rawSeqStore->capacity)
-                    return ERROR(dstSize_tooSmall);
-                seq->litLength = (U32)(split - backwardMatchLength - anchor);
-                seq->matchLength = (U32)mLength;
-                seq->offset = offset;
-                rawSeqStore->size++;
-            }
-
-            /* Insert the current entry into the hash table --- it must be
-             * done after the previous block to avoid clobbering bestEntry */
-            ZSTD_ldm_insertEntry(ldmState, hash, newEntry, *params);
-
-            anchor = split + forwardMatchLength;
-
-            /* If we find a match that ends after the data that we've hashed
-             * then we have a repeating, overlapping, pattern. E.g. all zeros.
-             * If one repetition of the pattern matches our `stopMask` then all
-             * repetitions will. We don't need to insert them all into out table,
-             * only the first one. So skip over overlapping matches.
-             * This is a major speed boost (20x) for compressing a single byte
-             * repeated, when that byte ends up in the table.
-             */
-            if (anchor > ip + hashed) {
-                ZSTD_ldm_gear_reset(&hashState, anchor - minMatchLength, minMatchLength);
-                /* Continue the outer loop at anchor (ip + hashed == anchor). */
-                ip = anchor - hashed;
-                break;
-            }
-        }
-
-        ip += hashed;
-    }
-
-    return iend - anchor;
-}
-
-/*! ZSTD_ldm_reduceTable() :
- *  reduce table indexes by `reducerValue` */
-static void ZSTD_ldm_reduceTable(ldmEntry_t* const table, U32 const size,
-                                 U32 const reducerValue)
-{
-    U32 u;
-    for (u = 0; u < size; u++) {
-        if (table[u].offset < reducerValue) table[u].offset = 0;
-        else table[u].offset -= reducerValue;
-    }
-}
-
-size_t ZSTD_ldm_generateSequences(
-        ldmState_t* ldmState, rawSeqStore_t* sequences,
-        ldmParams_t const* params, void const* src, size_t srcSize)
-{
-    U32 const maxDist = 1U << params->windowLog;
-    BYTE const* const istart = (BYTE const*)src;
-    BYTE const* const iend = istart + srcSize;
-    size_t const kMaxChunkSize = 1 << 20;
-    size_t const nbChunks = (srcSize / kMaxChunkSize) + ((srcSize % kMaxChunkSize) != 0);
-    size_t chunk;
-    size_t leftoverSize = 0;
-
-    assert(ZSTD_CHUNKSIZE_MAX >= kMaxChunkSize);
-    /* Check that ZSTD_window_update() has been called for this chunk prior
-     * to passing it to this function.
-     */
-    assert(ldmState->window.nextSrc >= (BYTE const*)src + srcSize);
-    /* The input could be very large (in zstdmt), so it must be broken up into
-     * chunks to enforce the maximum distance and handle overflow correction.
-     */
-    assert(sequences->pos <= sequences->size);
-    assert(sequences->size <= sequences->capacity);
-    for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) {
-        BYTE const* const chunkStart = istart + chunk * kMaxChunkSize;
-        size_t const remaining = (size_t)(iend - chunkStart);
-        BYTE const *const chunkEnd =
-            (remaining < kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize;
-        size_t const chunkSize = chunkEnd - chunkStart;
-        size_t newLeftoverSize;
-        size_t const prevSize = sequences->size;
-
-        assert(chunkStart < iend);
-        /* 1. Perform overflow correction if necessary. */
-        if (ZSTD_window_needOverflowCorrection(ldmState->window, 0, maxDist, ldmState->loadedDictEnd, chunkStart, chunkEnd)) {
-            U32 const ldmHSize = 1U << params->hashLog;
-            U32 const correction = ZSTD_window_correctOverflow(
-                &ldmState->window, /* cycleLog */ 0, maxDist, chunkStart);
-            ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction);
-            /* invalidate dictionaries on overflow correction */
-            ldmState->loadedDictEnd = 0;
-        }
-        /* 2. We enforce the maximum offset allowed.
-         *
-         * kMaxChunkSize should be small enough that we don't lose too much of
-         * the window through early invalidation.
-         * TODO: * Test the chunk size.
-         *       * Try invalidation after the sequence generation and test the
-         *         offset against maxDist directly.
-         *
-         * NOTE: Because of dictionaries + sequence splitting we MUST make sure
-         * that any offset used is valid at the END of the sequence, since it may
-         * be split into two sequences. This condition holds when using
-         * ZSTD_window_enforceMaxDist(), but if we move to checking offsets
-         * against maxDist directly, we'll have to carefully handle that case.
-         */
-        ZSTD_window_enforceMaxDist(&ldmState->window, chunkEnd, maxDist, &ldmState->loadedDictEnd, NULL);
-        /* 3. Generate the sequences for the chunk, and get newLeftoverSize. */
-        newLeftoverSize = ZSTD_ldm_generateSequences_internal(
-            ldmState, sequences, params, chunkStart, chunkSize);
-        if (ZSTD_isError(newLeftoverSize))
-            return newLeftoverSize;
-        /* 4. We add the leftover literals from previous iterations to the first
-         *    newly generated sequence, or add the `newLeftoverSize` if none are
-         *    generated.
-         */
-        /* Prepend the leftover literals from the last call */
-        if (prevSize < sequences->size) {
-            sequences->seq[prevSize].litLength += (U32)leftoverSize;
-            leftoverSize = newLeftoverSize;
-        } else {
-            assert(newLeftoverSize == chunkSize);
-            leftoverSize += chunkSize;
-        }
-    }
-    return 0;
-}
-
-void
-ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch)
-{
-    while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) {
-        rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos;
-        if (srcSize <= seq->litLength) {
-            /* Skip past srcSize literals */
-            seq->litLength -= (U32)srcSize;
-            return;
-        }
-        srcSize -= seq->litLength;
-        seq->litLength = 0;
-        if (srcSize < seq->matchLength) {
-            /* Skip past the first srcSize of the match */
-            seq->matchLength -= (U32)srcSize;
-            if (seq->matchLength < minMatch) {
-                /* The match is too short, omit it */
-                if (rawSeqStore->pos + 1 < rawSeqStore->size) {
-                    seq[1].litLength += seq[0].matchLength;
-                }
-                rawSeqStore->pos++;
-            }
-            return;
-        }
-        srcSize -= seq->matchLength;
-        seq->matchLength = 0;
-        rawSeqStore->pos++;
-    }
-}
-
-/**
- * If the sequence length is longer than remaining then the sequence is split
- * between this block and the next.
- *
- * Returns the current sequence to handle, or if the rest of the block should
- * be literals, it returns a sequence with offset == 0.
- */
-static rawSeq maybeSplitSequence(rawSeqStore_t* rawSeqStore,
-                                 U32 const remaining, U32 const minMatch)
-{
-    rawSeq sequence = rawSeqStore->seq[rawSeqStore->pos];
-    assert(sequence.offset > 0);
-    /* Likely: No partial sequence */
-    if (remaining >= sequence.litLength + sequence.matchLength) {
-        rawSeqStore->pos++;
-        return sequence;
-    }
-    /* Cut the sequence short (offset == 0 ==> rest is literals). */
-    if (remaining <= sequence.litLength) {
-        sequence.offset = 0;
-    } else if (remaining < sequence.litLength + sequence.matchLength) {
-        sequence.matchLength = remaining - sequence.litLength;
-        if (sequence.matchLength < minMatch) {
-            sequence.offset = 0;
-        }
-    }
-    /* Skip past `remaining` bytes for the future sequences. */
-    ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch);
-    return sequence;
-}
-
-void ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore_t* rawSeqStore, size_t nbBytes) {
-    U32 currPos = (U32)(rawSeqStore->posInSequence + nbBytes);
-    while (currPos && rawSeqStore->pos < rawSeqStore->size) {
-        rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos];
-        if (currPos >= currSeq.litLength + currSeq.matchLength) {
-            currPos -= currSeq.litLength + currSeq.matchLength;
-            rawSeqStore->pos++;
-        } else {
-            rawSeqStore->posInSequence = currPos;
-            break;
-        }
-    }
-    if (currPos == 0 || rawSeqStore->pos == rawSeqStore->size) {
-        rawSeqStore->posInSequence = 0;
-    }
-}
-
-size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
-    ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-    ZSTD_paramSwitch_e useRowMatchFinder,
-    void const* src, size_t srcSize)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    unsigned const minMatch = cParams->minMatch;
-    ZSTD_blockCompressor const blockCompressor =
-        ZSTD_selectBlockCompressor(cParams->strategy, useRowMatchFinder, ZSTD_matchState_dictMode(ms));
-    /* Input bounds */
-    BYTE const* const istart = (BYTE const*)src;
-    BYTE const* const iend = istart + srcSize;
-    /* Input positions */
-    BYTE const* ip = istart;
-
-    DEBUGLOG(5, "ZSTD_ldm_blockCompress: srcSize=%zu", srcSize);
-    /* If using opt parser, use LDMs only as candidates rather than always accepting them */
-    if (cParams->strategy >= ZSTD_btopt) {
-        size_t lastLLSize;
-        ms->ldmSeqStore = rawSeqStore;
-        lastLLSize = blockCompressor(ms, seqStore, rep, src, srcSize);
-        ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore, srcSize);
-        return lastLLSize;
-    }
-
-    assert(rawSeqStore->pos <= rawSeqStore->size);
-    assert(rawSeqStore->size <= rawSeqStore->capacity);
-    /* Loop through each sequence and apply the block compressor to the literals */
-    while (rawSeqStore->pos < rawSeqStore->size && ip < iend) {
-        /* maybeSplitSequence updates rawSeqStore->pos */
-        rawSeq const sequence = maybeSplitSequence(rawSeqStore,
-                                                   (U32)(iend - ip), minMatch);
-        /* End signal */
-        if (sequence.offset == 0)
-            break;
-
-        assert(ip + sequence.litLength + sequence.matchLength <= iend);
-
-        /* Fill tables for block compressor */
-        ZSTD_ldm_limitTableUpdate(ms, ip);
-        ZSTD_ldm_fillFastTables(ms, ip);
-        /* Run the block compressor */
-        DEBUGLOG(5, "pos %u : calling block compressor on segment of size %u", (unsigned)(ip-istart), sequence.litLength);
-        {
-            int i;
-            size_t const newLitLength =
-                blockCompressor(ms, seqStore, rep, ip, sequence.litLength);
-            ip += sequence.litLength;
-            /* Update the repcodes */
-            for (i = ZSTD_REP_NUM - 1; i > 0; i--)
-                rep[i] = rep[i-1];
-            rep[0] = sequence.offset;
-            /* Store the sequence */
-            ZSTD_storeSeq(seqStore, newLitLength, ip - newLitLength, iend,
-                          OFFSET_TO_OFFBASE(sequence.offset),
-                          sequence.matchLength);
-            ip += sequence.matchLength;
-        }
-    }
-    /* Fill the tables for the block compressor */
-    ZSTD_ldm_limitTableUpdate(ms, ip);
-    ZSTD_ldm_fillFastTables(ms, ip);
-    /* Compress the last literals */
-    return blockCompressor(ms, seqStore, rep, ip, iend - ip);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstd_opt.cpp b/src/duckdb/third_party/zstd/compress/zstd_opt.cpp
deleted file mode 100644
index 12cf55793..000000000
--- a/src/duckdb/third_party/zstd/compress/zstd_opt.cpp
+++ /dev/null
@@ -1,1580 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd/compress/zstd_compress_internal.h"
-#include "zstd/compress/hist.h"
-#include "zstd/compress/zstd_opt.h"
-
-namespace duckdb_zstd {
-
-#if !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)
-
-#define ZSTD_LITFREQ_ADD    2   /* scaling factor for litFreq, so that frequencies adapt faster to new stats */
-#define ZSTD_MAX_PRICE     (1<<30)
-
-#define ZSTD_PREDEF_THRESHOLD 8   /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */
-
-
-/*-*************************************
-*  Price functions for optimal parser
-***************************************/
-
-#if 0    /* approximation at bit level (for tests) */
-#  define BITCOST_ACCURACY 0
-#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
-#  define WEIGHT(stat, opt) ((void)(opt), ZSTD_bitWeight(stat))
-#elif 0  /* fractional bit accuracy (for tests) */
-#  define BITCOST_ACCURACY 8
-#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
-#  define WEIGHT(stat,opt) ((void)(opt), ZSTD_fracWeight(stat))
-#else    /* opt==approx, ultra==accurate */
-#  define BITCOST_ACCURACY 8
-#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
-#  define WEIGHT(stat,opt) ((opt) ? ZSTD_fracWeight(stat) : ZSTD_bitWeight(stat))
-#endif
-
-/* ZSTD_bitWeight() :
- * provide estimated "cost" of a stat in full bits only */
-MEM_STATIC U32 ZSTD_bitWeight(U32 stat)
-{
-    return (ZSTD_highbit32(stat+1) * BITCOST_MULTIPLIER);
-}
-
-/* ZSTD_fracWeight() :
- * provide fractional-bit "cost" of a stat,
- * using linear interpolation approximation */
-MEM_STATIC U32 ZSTD_fracWeight(U32 rawStat)
-{
-    U32 const stat = rawStat + 1;
-    U32 const hb = ZSTD_highbit32(stat);
-    U32 const BWeight = hb * BITCOST_MULTIPLIER;
-    /* Fweight was meant for "Fractional weight"
-     * but it's effectively a value between 1 and 2
-     * using fixed point arithmetic */
-    U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;
-    U32 const weight = BWeight + FWeight;
-    assert(hb + BITCOST_ACCURACY < 31);
-    return weight;
-}
-
-#if (DEBUGLEVEL>=2)
-/* debugging function,
- * @return price in bytes as fractional value
- * for debug messages only */
-MEM_STATIC double ZSTD_fCost(int price)
-{
-    return (double)price / (BITCOST_MULTIPLIER*8);
-}
-#endif
-
-static int ZSTD_compressedLiterals(optState_t const* const optPtr)
-{
-    return optPtr->literalCompressionMode != ZSTD_ps_disable;
-}
-
-static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel)
-{
-    if (ZSTD_compressedLiterals(optPtr))
-        optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel);
-    optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel);
-    optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel);
-    optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel);
-}
-
-
-static U32 sum_u32(const unsigned table[], size_t nbElts)
-{
-    size_t n;
-    U32 total = 0;
-    for (n=0; n<nbElts; n++) {
-        total += table[n];
-    }
-    return total;
-}
-
-typedef enum { base_0possible=0, base_1guaranteed=1 } base_directive_e;
-
-static U32
-ZSTD_downscaleStats(unsigned* table, U32 lastEltIndex, U32 shift, base_directive_e base1)
-{
-    U32 s, sum=0;
-    DEBUGLOG(5, "ZSTD_downscaleStats (nbElts=%u, shift=%u)",
-            (unsigned)lastEltIndex+1, (unsigned)shift );
-    assert(shift < 30);
-    for (s=0; s<lastEltIndex+1; s++) {
-        unsigned const base = base1 ? 1 : (table[s]>0);
-        unsigned const newStat = base + (table[s] >> shift);
-        sum += newStat;
-        table[s] = newStat;
-    }
-    return sum;
-}
-
-/* ZSTD_scaleStats() :
- * reduce all elt frequencies in table if sum too large
- * return the resulting sum of elements */
-static U32 ZSTD_scaleStats(unsigned* table, U32 lastEltIndex, U32 logTarget)
-{
-    U32 const prevsum = sum_u32(table, lastEltIndex+1);
-    U32 const factor = prevsum >> logTarget;
-    DEBUGLOG(5, "ZSTD_scaleStats (nbElts=%u, target=%u)", (unsigned)lastEltIndex+1, (unsigned)logTarget);
-    assert(logTarget < 30);
-    if (factor <= 1) return prevsum;
-    return ZSTD_downscaleStats(table, lastEltIndex, ZSTD_highbit32(factor), base_1guaranteed);
-}
-
-/* ZSTD_rescaleFreqs() :
- * if first block (detected by optPtr->litLengthSum == 0) : init statistics
- *    take hints from dictionary if there is one
- *    and init from zero if there is none,
- *    using src for literals stats, and baseline stats for sequence symbols
- * otherwise downscale existing stats, to be used as seed for next block.
- */
-static void
-ZSTD_rescaleFreqs(optState_t* const optPtr,
-            const BYTE* const src, size_t const srcSize,
-                  int const optLevel)
-{
-    int const compressedLiterals = ZSTD_compressedLiterals(optPtr);
-    DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
-    optPtr->priceType = zop_dynamic;
-
-    if (optPtr->litLengthSum == 0) {  /* no literals stats collected -> first block assumed -> init */
-
-        /* heuristic: use pre-defined stats for too small inputs */
-        if (srcSize <= ZSTD_PREDEF_THRESHOLD) {
-            DEBUGLOG(5, "srcSize <= %i : use predefined stats", ZSTD_PREDEF_THRESHOLD);
-            optPtr->priceType = zop_predef;
-        }
-
-        assert(optPtr->symbolCosts != NULL);
-        if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) {
-
-            /* huffman stats covering the full value set : table presumed generated by dictionary */
-            optPtr->priceType = zop_dynamic;
-
-            if (compressedLiterals) {
-                /* generate literals statistics from huffman table */
-                unsigned lit;
-                assert(optPtr->litFreq != NULL);
-                optPtr->litSum = 0;
-                for (lit=0; lit<=MaxLit; lit++) {
-                    U32 const scaleLog = 11;   /* scale to 2K */
-                    U32 const bitCost = HUF_getNbBitsFromCTable(optPtr->symbolCosts->huf.CTable, lit);
-                    assert(bitCost <= scaleLog);
-                    optPtr->litFreq[lit] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->litSum += optPtr->litFreq[lit];
-            }   }
-
-            {   unsigned ll;
-                FSE_CState_t llstate;
-                FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable);
-                optPtr->litLengthSum = 0;
-                for (ll=0; ll<=MaxLL; ll++) {
-                    U32 const scaleLog = 10;   /* scale to 1K */
-                    U32 const bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll);
-                    assert(bitCost < scaleLog);
-                    optPtr->litLengthFreq[ll] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->litLengthSum += optPtr->litLengthFreq[ll];
-            }   }
-
-            {   unsigned ml;
-                FSE_CState_t mlstate;
-                FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable);
-                optPtr->matchLengthSum = 0;
-                for (ml=0; ml<=MaxML; ml++) {
-                    U32 const scaleLog = 10;
-                    U32 const bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml);
-                    assert(bitCost < scaleLog);
-                    optPtr->matchLengthFreq[ml] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->matchLengthSum += optPtr->matchLengthFreq[ml];
-            }   }
-
-            {   unsigned of;
-                FSE_CState_t ofstate;
-                FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable);
-                optPtr->offCodeSum = 0;
-                for (of=0; of<=MaxOff; of++) {
-                    U32 const scaleLog = 10;
-                    U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of);
-                    assert(bitCost < scaleLog);
-                    optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->offCodeSum += optPtr->offCodeFreq[of];
-            }   }
-
-        } else {  /* first block, no dictionary */
-
-            assert(optPtr->litFreq != NULL);
-            if (compressedLiterals) {
-                /* base initial cost of literals on direct frequency within src */
-                unsigned lit = MaxLit;
-                HIST_count_simple(optPtr->litFreq, &lit, src, srcSize);   /* use raw first block to init statistics */
-                optPtr->litSum = ZSTD_downscaleStats(optPtr->litFreq, MaxLit, 8, base_0possible);
-            }
-
-            {   unsigned const baseLLfreqs[MaxLL+1] = {
-                    4, 2, 1, 1, 1, 1, 1, 1,
-                    1, 1, 1, 1, 1, 1, 1, 1,
-                    1, 1, 1, 1, 1, 1, 1, 1,
-                    1, 1, 1, 1, 1, 1, 1, 1,
-                    1, 1, 1, 1
-                };
-                ZSTD_memcpy(optPtr->litLengthFreq, baseLLfreqs, sizeof(baseLLfreqs));
-                optPtr->litLengthSum = sum_u32(baseLLfreqs, MaxLL+1);
-            }
-
-            {   unsigned ml;
-                for (ml=0; ml<=MaxML; ml++)
-                    optPtr->matchLengthFreq[ml] = 1;
-            }
-            optPtr->matchLengthSum = MaxML+1;
-
-            {   unsigned const baseOFCfreqs[MaxOff+1] = {
-                    6, 2, 1, 1, 2, 3, 4, 4,
-                    4, 3, 2, 1, 1, 1, 1, 1,
-                    1, 1, 1, 1, 1, 1, 1, 1,
-                    1, 1, 1, 1, 1, 1, 1, 1
-                };
-                ZSTD_memcpy(optPtr->offCodeFreq, baseOFCfreqs, sizeof(baseOFCfreqs));
-                optPtr->offCodeSum = sum_u32(baseOFCfreqs, MaxOff+1);
-            }
-
-        }
-
-    } else {   /* new block : scale down accumulated statistics */
-
-        if (compressedLiterals)
-            optPtr->litSum = ZSTD_scaleStats(optPtr->litFreq, MaxLit, 12);
-        optPtr->litLengthSum = ZSTD_scaleStats(optPtr->litLengthFreq, MaxLL, 11);
-        optPtr->matchLengthSum = ZSTD_scaleStats(optPtr->matchLengthFreq, MaxML, 11);
-        optPtr->offCodeSum = ZSTD_scaleStats(optPtr->offCodeFreq, MaxOff, 11);
-    }
-
-    ZSTD_setBasePrices(optPtr, optLevel);
-}
-
-/* ZSTD_rawLiteralsCost() :
- * price of literals (only) in specified segment (which length can be 0).
- * does not include price of literalLength symbol */
-static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
-                                const optState_t* const optPtr,
-                                int optLevel)
-{
-    DEBUGLOG(8, "ZSTD_rawLiteralsCost (%u literals)", litLength);
-    if (litLength == 0) return 0;
-
-    if (!ZSTD_compressedLiterals(optPtr))
-        return (litLength << 3) * BITCOST_MULTIPLIER;  /* Uncompressed - 8 bytes per literal. */
-
-    if (optPtr->priceType == zop_predef)
-        return (litLength*6) * BITCOST_MULTIPLIER;  /* 6 bit per literal - no statistic used */
-
-    /* dynamic statistics */
-    {   U32 price = optPtr->litSumBasePrice * litLength;
-        U32 const litPriceMax = optPtr->litSumBasePrice - BITCOST_MULTIPLIER;
-        U32 u;
-        assert(optPtr->litSumBasePrice >= BITCOST_MULTIPLIER);
-        for (u=0; u < litLength; u++) {
-            U32 litPrice = WEIGHT(optPtr->litFreq[literals[u]], optLevel);
-            if (UNLIKELY(litPrice > litPriceMax)) litPrice = litPriceMax;
-            price -= litPrice;
-        }
-        return price;
-    }
-}
-
-/* ZSTD_litLengthPrice() :
- * cost of literalLength symbol */
-static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)
-{
-    assert(litLength <= ZSTD_BLOCKSIZE_MAX);
-    if (optPtr->priceType == zop_predef)
-        return WEIGHT(litLength, optLevel);
-
-    /* ZSTD_LLcode() can't compute litLength price for sizes >= ZSTD_BLOCKSIZE_MAX
-     * because it isn't representable in the zstd format.
-     * So instead just pretend it would cost 1 bit more than ZSTD_BLOCKSIZE_MAX - 1.
-     * In such a case, the block would be all literals.
-     */
-    if (litLength == ZSTD_BLOCKSIZE_MAX)
-        return BITCOST_MULTIPLIER + ZSTD_litLengthPrice(ZSTD_BLOCKSIZE_MAX - 1, optPtr, optLevel);
-
-    /* dynamic statistics */
-    {   U32 const llCode = ZSTD_LLcode(litLength);
-        return (LL_bits[llCode] * BITCOST_MULTIPLIER)
-             + optPtr->litLengthSumBasePrice
-             - WEIGHT(optPtr->litLengthFreq[llCode], optLevel);
-    }
-}
-
-/* ZSTD_getMatchPrice() :
- * Provides the cost of the match part (offset + matchLength) of a sequence.
- * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.
- * @offBase : sumtype, representing an offset or a repcode, and using numeric representation of ZSTD_storeSeq()
- * @optLevel: when <2, favors small offset for decompression speed (improved cache efficiency)
- */
-FORCE_INLINE_TEMPLATE U32
-ZSTD_getMatchPrice(U32 const offBase,
-                   U32 const matchLength,
-             const optState_t* const optPtr,
-                   int const optLevel)
-{
-    U32 price;
-    U32 const offCode = ZSTD_highbit32(offBase);
-    U32 const mlBase = matchLength - MINMATCH;
-    assert(matchLength >= MINMATCH);
-
-    if (optPtr->priceType == zop_predef)  /* fixed scheme, does not use statistics */
-        return WEIGHT(mlBase, optLevel)
-             + ((16 + offCode) * BITCOST_MULTIPLIER); /* emulated offset cost */
-
-    /* dynamic statistics */
-    price = (offCode * BITCOST_MULTIPLIER) + (optPtr->offCodeSumBasePrice - WEIGHT(optPtr->offCodeFreq[offCode], optLevel));
-    if ((optLevel<2) /*static*/ && offCode >= 20)
-        price += (offCode-19)*2 * BITCOST_MULTIPLIER; /* handicap for long distance offsets, favor decompression speed */
-
-    /* match Length */
-    {   U32 const mlCode = ZSTD_MLcode(mlBase);
-        price += (ML_bits[mlCode] * BITCOST_MULTIPLIER) + (optPtr->matchLengthSumBasePrice - WEIGHT(optPtr->matchLengthFreq[mlCode], optLevel));
-    }
-
-    price += BITCOST_MULTIPLIER / 5;   /* heuristic : make matches a bit more costly to favor less sequences -> faster decompression speed */
-
-    DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
-    return price;
-}
-
-/* ZSTD_updateStats() :
- * assumption : literals + litLength <= iend */
-static void ZSTD_updateStats(optState_t* const optPtr,
-                             U32 litLength, const BYTE* literals,
-                             U32 offBase, U32 matchLength)
-{
-    /* literals */
-    if (ZSTD_compressedLiterals(optPtr)) {
-        U32 u;
-        for (u=0; u < litLength; u++)
-            optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
-        optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
-    }
-
-    /* literal Length */
-    {   U32 const llCode = ZSTD_LLcode(litLength);
-        optPtr->litLengthFreq[llCode]++;
-        optPtr->litLengthSum++;
-    }
-
-    /* offset code : follows storeSeq() numeric representation */
-    {   U32 const offCode = ZSTD_highbit32(offBase);
-        assert(offCode <= MaxOff);
-        optPtr->offCodeFreq[offCode]++;
-        optPtr->offCodeSum++;
-    }
-
-    /* match Length */
-    {   U32 const mlBase = matchLength - MINMATCH;
-        U32 const mlCode = ZSTD_MLcode(mlBase);
-        optPtr->matchLengthFreq[mlCode]++;
-        optPtr->matchLengthSum++;
-    }
-}
-
-
-/* ZSTD_readMINMATCH() :
- * function safe only for comparisons
- * assumption : memPtr must be at least 4 bytes before end of buffer */
-MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
-{
-    switch (length)
-    {
-    default :
-    case 4 : return MEM_read32(memPtr);
-    case 3 : if (MEM_isLittleEndian())
-                return MEM_read32(memPtr)<<8;
-             else
-                return MEM_read32(memPtr)>>8;
-    }
-}
-
-
-/* Update hashTable3 up to ip (excluded)
-   Assumption : always within prefix (i.e. not within extDict) */
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_insertAndFindFirstIndexHash3 (const ZSTD_matchState_t* ms,
-                                       U32* nextToUpdate3,
-                                       const BYTE* const ip)
-{
-    U32* const hashTable3 = ms->hashTable3;
-    U32 const hashLog3 = ms->hashLog3;
-    const BYTE* const base = ms->window.base;
-    U32 idx = *nextToUpdate3;
-    U32 const target = (U32)(ip - base);
-    size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3);
-    assert(hashLog3 > 0);
-
-    while(idx < target) {
-        hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
-        idx++;
-    }
-
-    *nextToUpdate3 = target;
-    return hashTable3[hash3];
-}
-
-
-/*-*************************************
-*  Binary Tree search
-***************************************/
-/** ZSTD_insertBt1() : add one or multiple positions to tree.
- * @param ip assumed <= iend-8 .
- * @param target The target of ZSTD_updateTree_internal() - we are filling to this position
- * @return : nb of positions added */
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_insertBt1(
-                const ZSTD_matchState_t* ms,
-                const BYTE* const ip, const BYTE* const iend,
-                U32 const target,
-                U32 const mls, const int extDict)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32*   const hashTable = ms->hashTable;
-    U32    const hashLog = cParams->hashLog;
-    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32*   const bt = ms->chainTable;
-    U32    const btLog  = cParams->chainLog - 1;
-    U32    const btMask = (1 << btLog) - 1;
-    U32 matchIndex = hashTable[h];
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const U32 dictLimit = ms->window.dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* match;
-    const U32 curr = (U32)(ip-base);
-    const U32 btLow = btMask >= curr ? 0 : curr - btMask;
-    U32* smallerPtr = bt + 2*(curr&btMask);
-    U32* largerPtr  = smallerPtr + 1;
-    U32 dummy32;   /* to be nullified at the end */
-    /* windowLow is based on target because
-     * we only need positions that will be in the window at the end of the tree update.
-     */
-    U32 const windowLow = ZSTD_getLowestMatchIndex(ms, target, cParams->windowLog);
-    U32 matchEndIdx = curr+8+1;
-    size_t bestLength = 8;
-    U32 nbCompares = 1U << cParams->searchLog;
-#ifdef ZSTD_C_PREDICT
-    U32 predictedSmall = *(bt + 2*((curr-1)&btMask) + 0);
-    U32 predictedLarge = *(bt + 2*((curr-1)&btMask) + 1);
-    predictedSmall += (predictedSmall>0);
-    predictedLarge += (predictedLarge>0);
-#endif /* ZSTD_C_PREDICT */
-
-    DEBUGLOG(8, "ZSTD_insertBt1 (%u)", curr);
-
-    assert(curr <= target);
-    assert(ip <= iend-8);   /* required for h calculation */
-    hashTable[h] = curr;   /* Update Hash Table */
-
-    assert(windowLow > 0);
-    for (; nbCompares && (matchIndex >= windowLow); --nbCompares) {
-        U32* const nextPtr = bt + 2*(matchIndex & btMask);
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-        assert(matchIndex < curr);
-
-#ifdef ZSTD_C_PREDICT   /* note : can create issues when hlog small <= 11 */
-        const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */
-        if (matchIndex == predictedSmall) {
-            /* no need to check length, result known */
-            *smallerPtr = matchIndex;
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-            predictedSmall = predictPtr[1] + (predictPtr[1]>0);
-            continue;
-        }
-        if (matchIndex == predictedLarge) {
-            *largerPtr = matchIndex;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-            predictedLarge = predictPtr[0] + (predictPtr[0]>0);
-            continue;
-        }
-#endif
-
-        if (!extDict || (matchIndex+matchLength >= dictLimit)) {
-            assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if actually extDict */
-            match = base + matchIndex;
-            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
-        } else {
-            match = dictBase + matchIndex;
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
-            if (matchIndex+matchLength >= dictLimit)
-                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
-        }
-
-        if (matchLength > bestLength) {
-            bestLength = matchLength;
-            if (matchLength > matchEndIdx - matchIndex)
-                matchEndIdx = matchIndex + (U32)matchLength;
-        }
-
-        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
-            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
-        }
-
-        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
-            /* match is smaller than current */
-            *smallerPtr = matchIndex;             /* update smaller idx */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
-            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */
-            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */
-        } else {
-            /* match is larger than current */
-            *largerPtr = matchIndex;
-            commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-    }   }
-
-    *smallerPtr = *largerPtr = 0;
-    {   U32 positions = 0;
-        if (bestLength > 384) positions = MIN(192, (U32)(bestLength - 384));   /* speed optimization */
-        assert(matchEndIdx > curr + 8);
-        return MAX(positions, matchEndIdx - (curr + 8));
-    }
-}
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_updateTree_internal(
-                ZSTD_matchState_t* ms,
-                const BYTE* const ip, const BYTE* const iend,
-                const U32 mls, const ZSTD_dictMode_e dictMode)
-{
-    const BYTE* const base = ms->window.base;
-    U32 const target = (U32)(ip - base);
-    U32 idx = ms->nextToUpdate;
-    DEBUGLOG(7, "ZSTD_updateTree_internal, from %u to %u  (dictMode:%u)",
-                idx, target, dictMode);
-
-    while(idx < target) {
-        U32 const forward = ZSTD_insertBt1(ms, base+idx, iend, target, mls, dictMode == ZSTD_extDict);
-        assert(idx < (U32)(idx + forward));
-        idx += forward;
-    }
-    assert((size_t)(ip - base) <= (size_t)(U32)(-1));
-    assert((size_t)(iend - base) <= (size_t)(U32)(-1));
-    ms->nextToUpdate = target;
-}
-
-void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) {
-    ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);
-}
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32
-ZSTD_insertBtAndGetAllMatches (
-                ZSTD_match_t* matches,  /* store result (found matches) in this table (presumed large enough) */
-                ZSTD_matchState_t* ms,
-                U32* nextToUpdate3,
-                const BYTE* const ip, const BYTE* const iLimit,
-                const ZSTD_dictMode_e dictMode,
-                const U32 rep[ZSTD_REP_NUM],
-                const U32 ll0,  /* tells if associated literal length is 0 or not. This value must be 0 or 1 */
-                const U32 lengthToBeat,
-                const U32 mls /* template */)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
-    const BYTE* const base = ms->window.base;
-    U32 const curr = (U32)(ip-base);
-    U32 const hashLog = cParams->hashLog;
-    U32 const minMatch = (mls==3) ? 3 : 4;
-    U32* const hashTable = ms->hashTable;
-    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32 matchIndex  = hashTable[h];
-    U32* const bt   = ms->chainTable;
-    U32 const btLog = cParams->chainLog - 1;
-    U32 const btMask= (1U << btLog) - 1;
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-    const BYTE* const dictBase = ms->window.dictBase;
-    U32 const dictLimit = ms->window.dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    U32 const btLow = (btMask >= curr) ? 0 : curr - btMask;
-    U32 const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);
-    U32 const matchLow = windowLow ? windowLow : 1;
-    U32* smallerPtr = bt + 2*(curr&btMask);
-    U32* largerPtr  = bt + 2*(curr&btMask) + 1;
-    U32 matchEndIdx = curr+8+1;   /* farthest referenced position of any match => detects repetitive patterns */
-    U32 dummy32;   /* to be nullified at the end */
-    U32 mnum = 0;
-    U32 nbCompares = 1U << cParams->searchLog;
-
-    const ZSTD_matchState_t* dms    = dictMode == ZSTD_dictMatchState ? ms->dictMatchState : NULL;
-    const ZSTD_compressionParameters* const dmsCParams =
-                                      dictMode == ZSTD_dictMatchState ? &dms->cParams : NULL;
-    const BYTE* const dmsBase       = dictMode == ZSTD_dictMatchState ? dms->window.base : NULL;
-    const BYTE* const dmsEnd        = dictMode == ZSTD_dictMatchState ? dms->window.nextSrc : NULL;
-    U32         const dmsHighLimit  = dictMode == ZSTD_dictMatchState ? (U32)(dmsEnd - dmsBase) : 0;
-    U32         const dmsLowLimit   = dictMode == ZSTD_dictMatchState ? dms->window.lowLimit : 0;
-    U32         const dmsIndexDelta = dictMode == ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0;
-    U32         const dmsHashLog    = dictMode == ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog;
-    U32         const dmsBtLog      = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog;
-    U32         const dmsBtMask     = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0;
-    U32         const dmsBtLow      = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit;
-
-    size_t bestLength = lengthToBeat-1;
-    DEBUGLOG(8, "ZSTD_insertBtAndGetAllMatches: current=%u", curr);
-
-    /* check repCode */
-    assert(ll0 <= 1);   /* necessarily 1 or 0 */
-    {   U32 const lastR = ZSTD_REP_NUM + ll0;
-        U32 repCode;
-        for (repCode = ll0; repCode < lastR; repCode++) {
-            U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
-            U32 const repIndex = curr - repOffset;
-            U32 repLen = 0;
-            assert(curr >= dictLimit);
-            if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < curr-dictLimit) {  /* equivalent to `curr > repIndex >= dictLimit` */
-                /* We must validate the repcode offset because when we're using a dictionary the
-                 * valid offset range shrinks when the dictionary goes out of bounds.
-                 */
-                if ((repIndex >= windowLow) & (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
-                    repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
-                }
-            } else {  /* repIndex < dictLimit || repIndex >= curr */
-                const BYTE* const repMatch = dictMode == ZSTD_dictMatchState ?
-                                             dmsBase + repIndex - dmsIndexDelta :
-                                             dictBase + repIndex;
-                assert(curr >= windowLow);
-                if ( dictMode == ZSTD_extDict
-                  && ( ((repOffset-1) /*intentional overflow*/ < curr - windowLow)  /* equivalent to `curr > repIndex >= windowLow` */
-                     & (((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */)
-                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
-                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
-                }
-                if (dictMode == ZSTD_dictMatchState
-                  && ( ((repOffset-1) /*intentional overflow*/ < curr - (dmsLowLimit + dmsIndexDelta))  /* equivalent to `curr > repIndex >= dmsLowLimit` */
-                     & ((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */
-                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
-                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dmsEnd, prefixStart) + minMatch;
-            }   }
-            /* save longer solution */
-            if (repLen > bestLength) {
-                DEBUGLOG(8, "found repCode %u (ll0:%u, offset:%u) of length %u",
-                            repCode, ll0, repOffset, repLen);
-                bestLength = repLen;
-                matches[mnum].off = REPCODE_TO_OFFBASE(repCode - ll0 + 1);  /* expect value between 1 and 3 */
-                matches[mnum].len = (U32)repLen;
-                mnum++;
-                if ( (repLen > sufficient_len)
-                   | (ip+repLen == iLimit) ) {  /* best possible */
-                    return mnum;
-    }   }   }   }
-
-    /* HC3 match finder */
-    if ((mls == 3) /*static*/ && (bestLength < mls)) {
-        U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, nextToUpdate3, ip);
-        if ((matchIndex3 >= matchLow)
-          & (curr - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) {
-            size_t mlen;
-            if ((dictMode == ZSTD_noDict) /*static*/ || (dictMode == ZSTD_dictMatchState) /*static*/ || (matchIndex3 >= dictLimit)) {
-                const BYTE* const match = base + matchIndex3;
-                mlen = ZSTD_count(ip, match, iLimit);
-            } else {
-                const BYTE* const match = dictBase + matchIndex3;
-                mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);
-            }
-
-            /* save best solution */
-            if (mlen >= mls /* == 3 > bestLength */) {
-                DEBUGLOG(8, "found small match with hlog3, of length %u",
-                            (U32)mlen);
-                bestLength = mlen;
-                assert(curr > matchIndex3);
-                assert(mnum==0);  /* no prior solution */
-                matches[0].off = OFFSET_TO_OFFBASE(curr - matchIndex3);
-                matches[0].len = (U32)mlen;
-                mnum = 1;
-                if ( (mlen > sufficient_len) |
-                     (ip+mlen == iLimit) ) {  /* best possible length */
-                    ms->nextToUpdate = curr+1;  /* skip insertion */
-                    return 1;
-        }   }   }
-        /* no dictMatchState lookup: dicts don't have a populated HC3 table */
-    }  /* if (mls == 3) */
-
-    hashTable[h] = curr;   /* Update Hash Table */
-
-    for (; nbCompares && (matchIndex >= matchLow); --nbCompares) {
-        U32* const nextPtr = bt + 2*(matchIndex & btMask);
-        const BYTE* match;
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-        assert(curr > matchIndex);
-
-        if ((dictMode == ZSTD_noDict) || (dictMode == ZSTD_dictMatchState) || (matchIndex+matchLength >= dictLimit)) {
-            assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */
-            match = base + matchIndex;
-            if (matchIndex >= dictLimit) assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
-            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit);
-        } else {
-            match = dictBase + matchIndex;
-            assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
-            if (matchIndex+matchLength >= dictLimit)
-                match = base + matchIndex;   /* prepare for match[matchLength] read */
-        }
-
-        if (matchLength > bestLength) {
-            DEBUGLOG(8, "found match of length %u at distance %u (offBase=%u)",
-                    (U32)matchLength, curr - matchIndex, OFFSET_TO_OFFBASE(curr - matchIndex));
-            assert(matchEndIdx > matchIndex);
-            if (matchLength > matchEndIdx - matchIndex)
-                matchEndIdx = matchIndex + (U32)matchLength;
-            bestLength = matchLength;
-            matches[mnum].off = OFFSET_TO_OFFBASE(curr - matchIndex);
-            matches[mnum].len = (U32)matchLength;
-            mnum++;
-            if ( (matchLength > ZSTD_OPT_NUM)
-               | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
-                if (dictMode == ZSTD_dictMatchState) nbCompares = 0; /* break should also skip searching dms */
-                break; /* drop, to preserve bt consistency (miss a little bit of compression) */
-        }   }
-
-        if (match[matchLength] < ip[matchLength]) {
-            /* match smaller than current */
-            *smallerPtr = matchIndex;             /* update smaller idx */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new candidate => larger than match, which was smaller than current */
-            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous, closer to current */
-        } else {
-            *largerPtr = matchIndex;
-            commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-    }   }
-
-    *smallerPtr = *largerPtr = 0;
-
-    assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
-    if (dictMode == ZSTD_dictMatchState && nbCompares) {
-        size_t const dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls);
-        U32 dictMatchIndex = dms->hashTable[dmsH];
-        const U32* const dmsBt = dms->chainTable;
-        commonLengthSmaller = commonLengthLarger = 0;
-        for (; nbCompares && (dictMatchIndex > dmsLowLimit); --nbCompares) {
-            const U32* const nextPtr = dmsBt + 2*(dictMatchIndex & dmsBtMask);
-            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-            const BYTE* match = dmsBase + dictMatchIndex;
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dmsEnd, prefixStart);
-            if (dictMatchIndex+matchLength >= dmsHighLimit)
-                match = base + dictMatchIndex + dmsIndexDelta;   /* to prepare for next usage of match[matchLength] */
-
-            if (matchLength > bestLength) {
-                matchIndex = dictMatchIndex + dmsIndexDelta;
-                DEBUGLOG(8, "found dms match of length %u at distance %u (offBase=%u)",
-                        (U32)matchLength, curr - matchIndex, OFFSET_TO_OFFBASE(curr - matchIndex));
-                if (matchLength > matchEndIdx - matchIndex)
-                    matchEndIdx = matchIndex + (U32)matchLength;
-                bestLength = matchLength;
-                matches[mnum].off = OFFSET_TO_OFFBASE(curr - matchIndex);
-                matches[mnum].len = (U32)matchLength;
-                mnum++;
-                if ( (matchLength > ZSTD_OPT_NUM)
-                   | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
-                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */
-            }   }
-
-            if (dictMatchIndex <= dmsBtLow) { break; }   /* beyond tree size, stop the search */
-            if (match[matchLength] < ip[matchLength]) {
-                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-                dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-            } else {
-                /* match is larger than current */
-                commonLengthLarger = matchLength;
-                dictMatchIndex = nextPtr[0];
-    }   }   }  /* if (dictMode == ZSTD_dictMatchState) */
-
-    assert(matchEndIdx > curr+8);
-    ms->nextToUpdate = matchEndIdx - 8;  /* skip repetitive patterns */
-    return mnum;
-}
-
-typedef U32 (*ZSTD_getAllMatchesFn)(
-    ZSTD_match_t*,
-    ZSTD_matchState_t*,
-    U32*,
-    const BYTE*,
-    const BYTE*,
-    const U32 rep[ZSTD_REP_NUM],
-    U32 const ll0,
-    U32 const lengthToBeat);
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_btGetAllMatches_internal(
-        ZSTD_match_t* matches,
-        ZSTD_matchState_t* ms,
-        U32* nextToUpdate3,
-        const BYTE* ip,
-        const BYTE* const iHighLimit,
-        const U32 rep[ZSTD_REP_NUM],
-        U32 const ll0,
-        U32 const lengthToBeat,
-        const ZSTD_dictMode_e dictMode,
-        const U32 mls)
-{
-    assert(BOUNDED(3, ms->cParams.minMatch, 6) == mls);
-    DEBUGLOG(8, "ZSTD_BtGetAllMatches(dictMode=%d, mls=%u)", (int)dictMode, mls);
-    if (ip < ms->window.base + ms->nextToUpdate)
-        return 0;   /* skipped area */
-    ZSTD_updateTree_internal(ms, ip, iHighLimit, mls, dictMode);
-    return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, mls);
-}
-
-#define ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, mls) ZSTD_btGetAllMatches_##dictMode##_##mls
-
-#define GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, mls)            \
-    static U32 ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, mls)(      \
-            ZSTD_match_t* matches,                             \
-            ZSTD_matchState_t* ms,                             \
-            U32* nextToUpdate3,                                \
-            const BYTE* ip,                                    \
-            const BYTE* const iHighLimit,                      \
-            const U32 rep[ZSTD_REP_NUM],                       \
-            U32 const ll0,                                     \
-            U32 const lengthToBeat)                            \
-    {                                                          \
-        return ZSTD_btGetAllMatches_internal(                  \
-                matches, ms, nextToUpdate3, ip, iHighLimit,    \
-                rep, ll0, lengthToBeat, ZSTD_##dictMode, mls); \
-    }
-
-#define GEN_ZSTD_BT_GET_ALL_MATCHES(dictMode)  \
-    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 3)  \
-    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 4)  \
-    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 5)  \
-    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 6)
-
-GEN_ZSTD_BT_GET_ALL_MATCHES(noDict)
-GEN_ZSTD_BT_GET_ALL_MATCHES(extDict)
-GEN_ZSTD_BT_GET_ALL_MATCHES(dictMatchState)
-
-#define ZSTD_BT_GET_ALL_MATCHES_ARRAY(dictMode)  \
-    {                                            \
-        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 3), \
-        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 4), \
-        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 5), \
-        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 6)  \
-    }
-
-static ZSTD_getAllMatchesFn
-ZSTD_selectBtGetAllMatches(ZSTD_matchState_t const* ms, ZSTD_dictMode_e const dictMode)
-{
-    ZSTD_getAllMatchesFn const getAllMatchesFns[3][4] = {
-        ZSTD_BT_GET_ALL_MATCHES_ARRAY(noDict),
-        ZSTD_BT_GET_ALL_MATCHES_ARRAY(extDict),
-        ZSTD_BT_GET_ALL_MATCHES_ARRAY(dictMatchState)
-    };
-    U32 const mls = BOUNDED(3, ms->cParams.minMatch, 6);
-    assert((U32)dictMode < 3);
-    assert(mls - 3 < 4);
-    return getAllMatchesFns[(int)dictMode][mls - 3];
-}
-
-/*************************
-*  LDM helper functions  *
-*************************/
-
-/* Struct containing info needed to make decision about ldm inclusion */
-typedef struct {
-    rawSeqStore_t seqStore;   /* External match candidates store for this block */
-    U32 startPosInBlock;      /* Start position of the current match candidate */
-    U32 endPosInBlock;        /* End position of the current match candidate */
-    U32 offset;               /* Offset of the match candidate */
-} ZSTD_optLdm_t;
-
-/* ZSTD_optLdm_skipRawSeqStoreBytes():
- * Moves forward in @rawSeqStore by @nbBytes,
- * which will update the fields 'pos' and 'posInSequence'.
- */
-static void ZSTD_optLdm_skipRawSeqStoreBytes(rawSeqStore_t* rawSeqStore, size_t nbBytes)
-{
-    U32 currPos = (U32)(rawSeqStore->posInSequence + nbBytes);
-    while (currPos && rawSeqStore->pos < rawSeqStore->size) {
-        rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos];
-        if (currPos >= currSeq.litLength + currSeq.matchLength) {
-            currPos -= currSeq.litLength + currSeq.matchLength;
-            rawSeqStore->pos++;
-        } else {
-            rawSeqStore->posInSequence = currPos;
-            break;
-        }
-    }
-    if (currPos == 0 || rawSeqStore->pos == rawSeqStore->size) {
-        rawSeqStore->posInSequence = 0;
-    }
-}
-
-/* ZSTD_opt_getNextMatchAndUpdateSeqStore():
- * Calculates the beginning and end of the next match in the current block.
- * Updates 'pos' and 'posInSequence' of the ldmSeqStore.
- */
-static void
-ZSTD_opt_getNextMatchAndUpdateSeqStore(ZSTD_optLdm_t* optLdm, U32 currPosInBlock,
-                                       U32 blockBytesRemaining)
-{
-    rawSeq currSeq;
-    U32 currBlockEndPos;
-    U32 literalsBytesRemaining;
-    U32 matchBytesRemaining;
-
-    /* Setting match end position to MAX to ensure we never use an LDM during this block */
-    if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) {
-        optLdm->startPosInBlock = UINT_MAX;
-        optLdm->endPosInBlock = UINT_MAX;
-        return;
-    }
-    /* Calculate appropriate bytes left in matchLength and litLength
-     * after adjusting based on ldmSeqStore->posInSequence */
-    currSeq = optLdm->seqStore.seq[optLdm->seqStore.pos];
-    assert(optLdm->seqStore.posInSequence <= currSeq.litLength + currSeq.matchLength);
-    currBlockEndPos = currPosInBlock + blockBytesRemaining;
-    literalsBytesRemaining = (optLdm->seqStore.posInSequence < currSeq.litLength) ?
-            currSeq.litLength - (U32)optLdm->seqStore.posInSequence :
-            0;
-    matchBytesRemaining = (literalsBytesRemaining == 0) ?
-            currSeq.matchLength - ((U32)optLdm->seqStore.posInSequence - currSeq.litLength) :
-            currSeq.matchLength;
-
-    /* If there are more literal bytes than bytes remaining in block, no ldm is possible */
-    if (literalsBytesRemaining >= blockBytesRemaining) {
-        optLdm->startPosInBlock = UINT_MAX;
-        optLdm->endPosInBlock = UINT_MAX;
-        ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, blockBytesRemaining);
-        return;
-    }
-
-    /* Matches may be < MINMATCH by this process. In that case, we will reject them
-       when we are deciding whether or not to add the ldm */
-    optLdm->startPosInBlock = currPosInBlock + literalsBytesRemaining;
-    optLdm->endPosInBlock = optLdm->startPosInBlock + matchBytesRemaining;
-    optLdm->offset = currSeq.offset;
-
-    if (optLdm->endPosInBlock > currBlockEndPos) {
-        /* Match ends after the block ends, we can't use the whole match */
-        optLdm->endPosInBlock = currBlockEndPos;
-        ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, currBlockEndPos - currPosInBlock);
-    } else {
-        /* Consume nb of bytes equal to size of sequence left */
-        ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, literalsBytesRemaining + matchBytesRemaining);
-    }
-}
-
-/* ZSTD_optLdm_maybeAddMatch():
- * Adds a match if it's long enough,
- * based on it's 'matchStartPosInBlock' and 'matchEndPosInBlock',
- * into 'matches'. Maintains the correct ordering of 'matches'.
- */
-static void ZSTD_optLdm_maybeAddMatch(ZSTD_match_t* matches, U32* nbMatches,
-                                      const ZSTD_optLdm_t* optLdm, U32 currPosInBlock)
-{
-    U32 const posDiff = currPosInBlock - optLdm->startPosInBlock;
-    /* Note: ZSTD_match_t actually contains offBase and matchLength (before subtracting MINMATCH) */
-    U32 const candidateMatchLength = optLdm->endPosInBlock - optLdm->startPosInBlock - posDiff;
-
-    /* Ensure that current block position is not outside of the match */
-    if (currPosInBlock < optLdm->startPosInBlock
-      || currPosInBlock >= optLdm->endPosInBlock
-      || candidateMatchLength < MINMATCH) {
-        return;
-    }
-
-    if (*nbMatches == 0 || ((candidateMatchLength > matches[*nbMatches-1].len) && *nbMatches < ZSTD_OPT_NUM)) {
-        U32 const candidateOffBase = OFFSET_TO_OFFBASE(optLdm->offset);
-        DEBUGLOG(6, "ZSTD_optLdm_maybeAddMatch(): Adding ldm candidate match (offBase: %u matchLength %u) at block position=%u",
-                 candidateOffBase, candidateMatchLength, currPosInBlock);
-        matches[*nbMatches].len = candidateMatchLength;
-        matches[*nbMatches].off = candidateOffBase;
-        (*nbMatches)++;
-    }
-}
-
-/* ZSTD_optLdm_processMatchCandidate():
- * Wrapper function to update ldm seq store and call ldm functions as necessary.
- */
-static void
-ZSTD_optLdm_processMatchCandidate(ZSTD_optLdm_t* optLdm,
-                                  ZSTD_match_t* matches, U32* nbMatches,
-                                  U32 currPosInBlock, U32 remainingBytes)
-{
-    if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) {
-        return;
-    }
-
-    if (currPosInBlock >= optLdm->endPosInBlock) {
-        if (currPosInBlock > optLdm->endPosInBlock) {
-            /* The position at which ZSTD_optLdm_processMatchCandidate() is called is not necessarily
-             * at the end of a match from the ldm seq store, and will often be some bytes
-             * over beyond matchEndPosInBlock. As such, we need to correct for these "overshoots"
-             */
-            U32 const posOvershoot = currPosInBlock - optLdm->endPosInBlock;
-            ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, posOvershoot);
-        }
-        ZSTD_opt_getNextMatchAndUpdateSeqStore(optLdm, currPosInBlock, remainingBytes);
-    }
-    ZSTD_optLdm_maybeAddMatch(matches, nbMatches, optLdm, currPosInBlock);
-}
-
-
-/*-*******************************
-*  Optimal parser
-*********************************/
-
-#if 0 /* debug */
-
-static void
-listStats(const U32* table, int lastEltID)
-{
-    int const nbElts = lastEltID + 1;
-    int enb;
-    for (enb=0; enb < nbElts; enb++) {
-        (void)table;
-        /* RAWLOG(2, "%3i:%3i,  ", enb, table[enb]); */
-        RAWLOG(2, "%4i,", table[enb]);
-    }
-    RAWLOG(2, " \n");
-}
-
-#endif
-
-#define LIT_PRICE(_p) (int)ZSTD_rawLiteralsCost(_p, 1, optStatePtr, optLevel)
-#define LL_PRICE(_l) (int)ZSTD_litLengthPrice(_l, optStatePtr, optLevel)
-#define LL_INCPRICE(_l) (LL_PRICE(_l) - LL_PRICE(_l-1))
-
-FORCE_INLINE_TEMPLATE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t
-ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
-                               seqStore_t* seqStore,
-                               U32 rep[ZSTD_REP_NUM],
-                         const void* src, size_t srcSize,
-                         const int optLevel,
-                         const ZSTD_dictMode_e dictMode)
-{
-    optState_t* const optStatePtr = &ms->opt;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ms->window.base;
-    const BYTE* const prefixStart = base + ms->window.dictLimit;
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-
-    ZSTD_getAllMatchesFn getAllMatches = ZSTD_selectBtGetAllMatches(ms, dictMode);
-
-    U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
-    U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;
-    U32 nextToUpdate3 = ms->nextToUpdate;
-
-    ZSTD_optimal_t* const opt = optStatePtr->priceTable;
-    ZSTD_match_t* const matches = optStatePtr->matchTable;
-    ZSTD_optimal_t lastStretch;
-    ZSTD_optLdm_t optLdm;
-
-    ZSTD_memset(&lastStretch, 0, sizeof(ZSTD_optimal_t));
-
-    optLdm.seqStore = ms->ldmSeqStore ? *ms->ldmSeqStore : kNullRawSeqStore;
-    optLdm.endPosInBlock = optLdm.startPosInBlock = optLdm.offset = 0;
-    ZSTD_opt_getNextMatchAndUpdateSeqStore(&optLdm, (U32)(ip-istart), (U32)(iend-ip));
-
-    /* init */
-    DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u",
-                (U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);
-    assert(optLevel <= 2);
-    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);
-    ip += (ip==prefixStart);
-
-    /* Match Loop */
-    while (ip < ilimit) {
-        U32 cur, last_pos = 0;
-
-        /* find first match */
-        {   U32 const litlen = (U32)(ip - anchor);
-            U32 const ll0 = !litlen;
-            U32 nbMatches = getAllMatches(matches, ms, &nextToUpdate3, ip, iend, rep, ll0, minMatch);
-            ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,
-                                              (U32)(ip-istart), (U32)(iend-ip));
-            if (!nbMatches) {
-                DEBUGLOG(8, "no match found at cPos %u", (unsigned)(ip-istart));
-                ip++;
-                continue;
-            }
-
-            /* Match found: let's store this solution, and eventually find more candidates.
-             * During this forward pass, @opt is used to store stretches,
-             * defined as "a match followed by N literals".
-             * Note how this is different from a Sequence, which is "N literals followed by a match".
-             * Storing stretches allows us to store different match predecessors
-             * for each literal position part of a literals run. */
-
-            /* initialize opt[0] */
-            opt[0].mlen = 0;  /* there are only literals so far */
-            opt[0].litlen = litlen;
-            /* No need to include the actual price of the literals before the first match
-             * because it is static for the duration of the forward pass, and is included
-             * in every subsequent price. But, we include the literal length because
-             * the cost variation of litlen depends on the value of litlen.
-             */
-            opt[0].price = LL_PRICE(litlen);
-            ZSTD_STATIC_ASSERT(sizeof(opt[0].rep[0]) == sizeof(rep[0]));
-            ZSTD_memcpy(&opt[0].rep, rep, sizeof(opt[0].rep));
-
-            /* large match -> immediate encoding */
-            {   U32 const maxML = matches[nbMatches-1].len;
-                U32 const maxOffBase = matches[nbMatches-1].off;
-                DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffBase=%u at cPos=%u => start new series",
-                            nbMatches, maxML, maxOffBase, (U32)(ip-prefixStart));
-
-                if (maxML > sufficient_len) {
-                    lastStretch.litlen = 0;
-                    lastStretch.mlen = maxML;
-                    lastStretch.off = maxOffBase;
-                    DEBUGLOG(6, "large match (%u>%u) => immediate encoding",
-                                maxML, sufficient_len);
-                    cur = 0;
-                    last_pos = maxML;
-                    goto _shortestPath;
-            }   }
-
-            /* set prices for first matches starting position == 0 */
-            assert(opt[0].price >= 0);
-            {   U32 pos;
-                U32 matchNb;
-                for (pos = 1; pos < minMatch; pos++) {
-                    opt[pos].price = ZSTD_MAX_PRICE;
-                    opt[pos].mlen = 0;
-                    opt[pos].litlen = litlen + pos;
-                }
-                for (matchNb = 0; matchNb < nbMatches; matchNb++) {
-                    U32 const offBase = matches[matchNb].off;
-                    U32 const end = matches[matchNb].len;
-                    for ( ; pos <= end ; pos++ ) {
-                        int const matchPrice = (int)ZSTD_getMatchPrice(offBase, pos, optStatePtr, optLevel);
-                        int const sequencePrice = opt[0].price + matchPrice;
-                        DEBUGLOG(7, "rPos:%u => set initial price : %.2f",
-                                    pos, ZSTD_fCost(sequencePrice));
-                        opt[pos].mlen = pos;
-                        opt[pos].off = offBase;
-                        opt[pos].litlen = 0; /* end of match */
-                        opt[pos].price = sequencePrice + LL_PRICE(0);
-                    }
-                }
-                last_pos = pos-1;
-                opt[pos].price = ZSTD_MAX_PRICE;
-            }
-        }
-
-        /* check further positions */
-        for (cur = 1; cur <= last_pos; cur++) {
-            const BYTE* const inr = ip + cur;
-            assert(cur <= ZSTD_OPT_NUM);
-            DEBUGLOG(7, "cPos:%zi==rPos:%u", inr-istart, cur);
-
-            /* Fix current position with one literal if cheaper */
-            {   U32 const litlen = opt[cur-1].litlen + 1;
-                int const price = opt[cur-1].price
-                                + LIT_PRICE(ip+cur-1)
-                                + LL_INCPRICE(litlen);
-                assert(price < 1000000000); /* overflow check */
-                if (price <= opt[cur].price) {
-                    ZSTD_optimal_t const prevMatch = opt[cur];
-                    DEBUGLOG(7, "cPos:%zi==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)",
-                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen,
-                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
-                    opt[cur] = opt[cur-1];
-                    opt[cur].litlen = litlen;
-                    opt[cur].price = price;
-                    if ( (optLevel >= 1) /* additional check only for higher modes */
-                      && (prevMatch.litlen == 0) /* replace a match */
-                      && (LL_INCPRICE(1) < 0) /* ll1 is cheaper than ll0 */
-                      && LIKELY(ip + cur < iend)
-                    ) {
-                        /* check next position, in case it would be cheaper */
-                        int with1literal = prevMatch.price + LIT_PRICE(ip+cur) + LL_INCPRICE(1);
-                        int withMoreLiterals = price + LIT_PRICE(ip+cur) + LL_INCPRICE(litlen+1);
-                        DEBUGLOG(7, "then at next rPos %u : match+1lit %.2f vs %ulits %.2f",
-                                cur+1, ZSTD_fCost(with1literal), litlen+1, ZSTD_fCost(withMoreLiterals));
-                        if ( (with1literal < withMoreLiterals)
-                          && (with1literal < opt[cur+1].price) ) {
-                            /* update offset history - before it disappears */
-                            U32 const prev = cur - prevMatch.mlen;
-                            repcodes_t const newReps = ZSTD_newRep(opt[prev].rep, prevMatch.off, opt[prev].litlen==0);
-                            assert(cur >= prevMatch.mlen);
-                            DEBUGLOG(7, "==> match+1lit is cheaper (%.2f < %.2f) (hist:%u,%u,%u) !",
-                                        ZSTD_fCost(with1literal), ZSTD_fCost(withMoreLiterals),
-                                        newReps.rep[0], newReps.rep[1], newReps.rep[2] );
-                            opt[cur+1] = prevMatch;  /* mlen & offbase */
-                            ZSTD_memcpy(opt[cur+1].rep, &newReps, sizeof(repcodes_t));
-                            opt[cur+1].litlen = 1;
-                            opt[cur+1].price = with1literal;
-                            if (last_pos < cur+1) last_pos = cur+1;
-                        }
-                    }
-                } else {
-                    DEBUGLOG(7, "cPos:%zi==rPos:%u : literal would cost more (%.2f>%.2f)",
-                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price));
-                }
-            }
-
-            /* Offset history is not updated during match comparison.
-             * Do it here, now that the match is selected and confirmed.
-             */
-            ZSTD_STATIC_ASSERT(sizeof(opt[cur].rep) == sizeof(repcodes_t));
-            assert(cur >= opt[cur].mlen);
-            if (opt[cur].litlen == 0) {
-                /* just finished a match => alter offset history */
-                U32 const prev = cur - opt[cur].mlen;
-                repcodes_t const newReps = ZSTD_newRep(opt[prev].rep, opt[cur].off, opt[prev].litlen==0);
-                ZSTD_memcpy(opt[cur].rep, &newReps, sizeof(repcodes_t));
-            }
-
-            /* last match must start at a minimum distance of 8 from oend */
-            if (inr > ilimit) continue;
-
-            if (cur == last_pos) break;
-
-            if ( (optLevel==0) /*static_test*/
-              && (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) {
-                DEBUGLOG(7, "skip current position : next rPos(%u) price is cheaper", cur+1);
-                continue;  /* skip unpromising positions; about ~+6% speed, -0.01 ratio */
-            }
-
-            assert(opt[cur].price >= 0);
-            {   U32 const ll0 = (opt[cur].litlen == 0);
-                int const previousPrice = opt[cur].price;
-                int const basePrice = previousPrice + LL_PRICE(0);
-                U32 nbMatches = getAllMatches(matches, ms, &nextToUpdate3, inr, iend, opt[cur].rep, ll0, minMatch);
-                U32 matchNb;
-
-                ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,
-                                                  (U32)(inr-istart), (U32)(iend-inr));
-
-                if (!nbMatches) {
-                    DEBUGLOG(7, "rPos:%u : no match found", cur);
-                    continue;
-                }
-
-                {   U32 const longestML = matches[nbMatches-1].len;
-                    DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of longest ML=%u",
-                                inr-istart, cur, nbMatches, longestML);
-
-                    if ( (longestML > sufficient_len)
-                      || (cur + longestML >= ZSTD_OPT_NUM)
-                      || (ip + cur + longestML >= iend) ) {
-                        lastStretch.mlen = longestML;
-                        lastStretch.off = matches[nbMatches-1].off;
-                        lastStretch.litlen = 0;
-                        last_pos = cur + longestML;
-                        goto _shortestPath;
-                }   }
-
-                /* set prices using matches found at position == cur */
-                for (matchNb = 0; matchNb < nbMatches; matchNb++) {
-                    U32 const offset = matches[matchNb].off;
-                    U32 const lastML = matches[matchNb].len;
-                    U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
-                    U32 mlen;
-
-                    DEBUGLOG(7, "testing match %u => offBase=%4u, mlen=%2u, llen=%2u",
-                                matchNb, matches[matchNb].off, lastML, opt[cur].litlen);
-
-                    for (mlen = lastML; mlen >= startML; mlen--) {  /* scan downward */
-                        U32 const pos = cur + mlen;
-                        int const price = basePrice + (int)ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);
-
-                        if ((pos > last_pos) || (price < opt[pos].price)) {
-                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new better price (%.2f<%.2f)",
-                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
-                            while (last_pos < pos) {
-                                /* fill empty positions, for future comparisons */
-                                last_pos++;
-                                opt[last_pos].price = ZSTD_MAX_PRICE;
-                                opt[last_pos].litlen = !0;  /* just needs to be != 0, to mean "not an end of match" */
-                            }
-                            opt[pos].mlen = mlen;
-                            opt[pos].off = offset;
-                            opt[pos].litlen = 0;
-                            opt[pos].price = price;
-                        } else {
-                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)",
-                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
-                            if (optLevel==0) break;  /* early update abort; gets ~+10% speed for about -0.01 ratio loss */
-                        }
-            }   }   }
-            opt[last_pos+1].price = ZSTD_MAX_PRICE;
-        }  /* for (cur = 1; cur <= last_pos; cur++) */
-
-        lastStretch = opt[last_pos];
-        assert(cur >= lastStretch.mlen);
-        cur = last_pos - lastStretch.mlen;
-
-_shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
-        assert(opt[0].mlen == 0);
-        assert(last_pos >= lastStretch.mlen);
-        assert(cur == last_pos - lastStretch.mlen);
-
-        if (lastStretch.mlen==0) {
-            /* no solution : all matches have been converted into literals */
-            assert(lastStretch.litlen == (ip - anchor) + last_pos);
-            ip += last_pos;
-            continue;
-        }
-        assert(lastStretch.off > 0);
-
-        /* Update offset history */
-        if (lastStretch.litlen == 0) {
-            /* finishing on a match : update offset history */
-            repcodes_t const reps = ZSTD_newRep(opt[cur].rep, lastStretch.off, opt[cur].litlen==0);
-            ZSTD_memcpy(rep, &reps, sizeof(repcodes_t));
-        } else {
-            ZSTD_memcpy(rep, lastStretch.rep, sizeof(repcodes_t));
-            assert(cur >= lastStretch.litlen);
-            cur -= lastStretch.litlen;
-        }
-
-        /* Let's write the shortest path solution.
-         * It is stored in @opt in reverse order,
-         * starting from @storeEnd (==cur+2),
-         * effectively partially @opt overwriting.
-         * Content is changed too:
-         * - So far, @opt stored stretches, aka a match followed by literals
-         * - Now, it will store sequences, aka literals followed by a match
-         */
-        {   U32 const storeEnd = cur + 2;
-            U32 storeStart = storeEnd;
-            U32 stretchPos = cur;
-
-            DEBUGLOG(6, "start reverse traversal (last_pos:%u, cur:%u)",
-                        last_pos, cur); (void)last_pos;
-            assert(storeEnd < ZSTD_OPT_SIZE);
-            DEBUGLOG(6, "last stretch copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
-                        storeEnd, lastStretch.litlen, lastStretch.mlen, lastStretch.off);
-            if (lastStretch.litlen > 0) {
-                /* last "sequence" is unfinished: just a bunch of literals */
-                opt[storeEnd].litlen = lastStretch.litlen;
-                opt[storeEnd].mlen = 0;
-                storeStart = storeEnd-1;
-                opt[storeStart] = lastStretch;
-            } {
-                opt[storeEnd] = lastStretch;  /* note: litlen will be fixed */
-                storeStart = storeEnd;
-            }
-            while (1) {
-                ZSTD_optimal_t nextStretch = opt[stretchPos];
-                opt[storeStart].litlen = nextStretch.litlen;
-                DEBUGLOG(6, "selected sequence (llen=%u,mlen=%u,ofc=%u)",
-                            opt[storeStart].litlen, opt[storeStart].mlen, opt[storeStart].off);
-                if (nextStretch.mlen == 0) {
-                    /* reaching beginning of segment */
-                    break;
-                }
-                storeStart--;
-                opt[storeStart] = nextStretch; /* note: litlen will be fixed */
-                assert(nextStretch.litlen + nextStretch.mlen <= stretchPos);
-                stretchPos -= nextStretch.litlen + nextStretch.mlen;
-            }
-
-            /* save sequences */
-            DEBUGLOG(6, "sending selected sequences into seqStore");
-            {   U32 storePos;
-                for (storePos=storeStart; storePos <= storeEnd; storePos++) {
-                    U32 const llen = opt[storePos].litlen;
-                    U32 const mlen = opt[storePos].mlen;
-                    U32 const offBase = opt[storePos].off;
-                    U32 const advance = llen + mlen;
-                    DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u",
-                                anchor - istart, (unsigned)llen, (unsigned)mlen);
-
-                    if (mlen==0) {  /* only literals => must be last "sequence", actually starting a new stream of sequences */
-                        assert(storePos == storeEnd);   /* must be last sequence */
-                        ip = anchor + llen;     /* last "sequence" is a bunch of literals => don't progress anchor */
-                        continue;   /* will finish */
-                    }
-
-                    assert(anchor + llen <= iend);
-                    ZSTD_updateStats(optStatePtr, llen, anchor, offBase, mlen);
-                    ZSTD_storeSeq(seqStore, llen, anchor, iend, offBase, mlen);
-                    anchor += advance;
-                    ip = anchor;
-            }   }
-            DEBUGLOG(7, "new offset history : %u, %u, %u", rep[0], rep[1], rep[2]);
-
-            /* update all costs */
-            ZSTD_setBasePrices(optStatePtr, optLevel);
-        }
-    }   /* while (ip < ilimit) */
-
-    /* Return the last literals size */
-    return (size_t)(iend - anchor);
-}
-#endif /* build exclusions */
-
-#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR
-static size_t ZSTD_compressBlock_opt0(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize, const ZSTD_dictMode_e dictMode)
-{
-    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /* optLevel */, dictMode);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR
-static size_t ZSTD_compressBlock_opt2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize, const ZSTD_dictMode_e dictMode)
-{
-    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /* optLevel */, dictMode);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btopt(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    DEBUGLOG(5, "ZSTD_compressBlock_btopt");
-    return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_noDict);
-}
-#endif
-
-
-
-
-#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR
-/* ZSTD_initStats_ultra():
- * make a first compression pass, just to seed stats with more accurate starting values.
- * only works on first block, with no dictionary and no ldm.
- * this function cannot error out, its narrow contract must be respected.
- */
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_initStats_ultra(ZSTD_matchState_t* ms,
-                          seqStore_t* seqStore,
-                          U32 rep[ZSTD_REP_NUM],
-                    const void* src, size_t srcSize)
-{
-    U32 tmpRep[ZSTD_REP_NUM];  /* updated rep codes will sink here */
-    ZSTD_memcpy(tmpRep, rep, sizeof(tmpRep));
-
-    DEBUGLOG(4, "ZSTD_initStats_ultra (srcSize=%zu)", srcSize);
-    assert(ms->opt.litLengthSum == 0);    /* first block */
-    assert(seqStore->sequences == seqStore->sequencesStart);   /* no ldm */
-    assert(ms->window.dictLimit == ms->window.lowLimit);   /* no dictionary */
-    assert(ms->window.dictLimit - ms->nextToUpdate <= 1);  /* no prefix (note: intentional overflow, defined as 2-complement) */
-
-    ZSTD_compressBlock_opt2(ms, seqStore, tmpRep, src, srcSize, ZSTD_noDict);   /* generate stats into ms->opt*/
-
-    /* invalidate first scan from history, only keep entropy stats */
-    ZSTD_resetSeqStore(seqStore);
-    ms->window.base -= srcSize;
-    ms->window.dictLimit += (U32)srcSize;
-    ms->window.lowLimit = ms->window.dictLimit;
-    ms->nextToUpdate = ms->window.dictLimit;
-
-}
-
-size_t ZSTD_compressBlock_btultra(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize);
-    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_btultra2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    U32 const curr = (U32)((const BYTE*)src - ms->window.base);
-    DEBUGLOG(5, "ZSTD_compressBlock_btultra2 (srcSize=%zu)", srcSize);
-
-    /* 2-passes strategy:
-     * this strategy makes a first pass over first block to collect statistics
-     * in order to seed next round's statistics with it.
-     * After 1st pass, function forgets history, and starts a new block.
-     * Consequently, this can only work if no data has been previously loaded in tables,
-     * aka, no dictionary, no prefix, no ldm preprocessing.
-     * The compression ratio gain is generally small (~0.5% on first block),
-     * the cost is 2x cpu time on first block. */
-    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
-    if ( (ms->opt.litLengthSum==0)   /* first block */
-      && (seqStore->sequences == seqStore->sequencesStart)  /* no ldm */
-      && (ms->window.dictLimit == ms->window.lowLimit)   /* no dictionary */
-      && (curr == ms->window.dictLimit)    /* start of frame, nothing already loaded nor skipped */
-      && (srcSize > ZSTD_PREDEF_THRESHOLD) /* input large enough to not employ default stats */
-      ) {
-        ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize);
-    }
-
-    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_noDict);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btopt_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_btopt_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_extDict);
-}
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btultra_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_btultra_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
-    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_extDict);
-}
-#endif
-
-/* note : no btultra2 variant for extDict nor dictMatchState,
- * because btultra2 is not meant to work with dictionaries
- * and is only specific for the first block (no prefix) */
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/compress/zstdmt_compress.cpp b/src/duckdb/third_party/zstd/compress/zstdmt_compress.cpp
deleted file mode 100644
index f0522c8ff..000000000
--- a/src/duckdb/third_party/zstd/compress/zstdmt_compress.cpp
+++ /dev/null
@@ -1,1885 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-/* ======   Compiler specifics   ====== */
-#if defined(_MSC_VER)
-#  pragma warning(disable : 4204)   /* disable: C4204: non-constant aggregate initializer */
-#endif
-
-
-/* ======   Dependencies   ====== */
-#include "zstd/common/allocations.h" /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
-#include "zstd/common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memset, INT_MAX, UINT_MAX */
-#include "zstd/common/mem.h"         /* MEM_STATIC */
-#include "zstd/common/pool.h"        /* threadpool */
-#include "zstd/common/threading.h"   /* mutex */
-#include "zstd/compress/zstd_compress_internal.h" /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
-#include "zstd/compress/zstd_ldm.h"
-#include "zstd/compress/zstdmt_compress.h"
-
-/* Guards code to support resizing the SeqPool.
- * We will want to resize the SeqPool to save memory in the future.
- * Until then, comment the code out since it is unused.
- */
-#define ZSTD_RESIZE_SEQPOOL 0
-
-/* ======   Debug   ====== */
-#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=2) \
-    && !defined(_MSC_VER) \
-    && !defined(__MINGW32__)
-
-#  include <stdio.h>
-#  include <unistd.h>
-#  include <sys/times.h>
-
-#  define DEBUG_PRINTHEX(l,p,n)                                       \
-    do {                                                              \
-        unsigned debug_u;                                             \
-        for (debug_u=0; debug_u<(n); debug_u++)                       \
-            RAWLOG(l, "%02X ", ((const unsigned char*)(p))[debug_u]); \
-        RAWLOG(l, " \n");                                             \
-    } while (0)
-
-static unsigned long long GetCurrentClockTimeMicroseconds(void)
-{
-   static clock_t _ticksPerSecond = 0;
-   if (_ticksPerSecond <= 0) _ticksPerSecond = sysconf(_SC_CLK_TCK);
-
-   {   struct tms junk; clock_t newTicks = (clock_t) times(&junk);
-       return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond);
-}  }
-
-#define MUTEX_WAIT_TIME_DLEVEL 6
-#define ZSTD_PTHREAD_MUTEX_LOCK(mutex)                                                  \
-    do {                                                                                \
-        if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) {                                     \
-            unsigned long long const beforeTime = GetCurrentClockTimeMicroseconds();    \
-            ZSTD_pthread_mutex_lock(mutex);                                             \
-            {   unsigned long long const afterTime = GetCurrentClockTimeMicroseconds(); \
-                unsigned long long const elapsedTime = (afterTime-beforeTime);          \
-                if (elapsedTime > 1000) {                                               \
-                    /* or whatever threshold you like; I'm using 1 millisecond here */  \
-                    DEBUGLOG(MUTEX_WAIT_TIME_DLEVEL,                                    \
-                        "Thread took %llu microseconds to acquire mutex %s \n",         \
-                        elapsedTime, #mutex);                                           \
-            }   }                                                                       \
-        } else {                                                                        \
-            ZSTD_pthread_mutex_lock(mutex);                                             \
-        }                                                                               \
-    } while (0)
-
-#else
-
-#  define ZSTD_PTHREAD_MUTEX_LOCK(m) ZSTD_pthread_mutex_lock(m)
-#  define DEBUG_PRINTHEX(l,p,n) do { } while (0)
-
-#endif
-
-namespace duckdb_zstd {
-
-/* =====   Buffer Pool   ===== */
-/* a single Buffer Pool can be invoked from multiple threads in parallel */
-
-typedef struct buffer_s {
-    void* start;
-    size_t capacity;
-} buffer_t;
-
-static const buffer_t g_nullBuffer = { NULL, 0 };
-
-typedef struct ZSTDMT_bufferPool_s {
-    ZSTD_pthread_mutex_t poolMutex;
-    size_t bufferSize;
-    unsigned totalBuffers;
-    unsigned nbBuffers;
-    ZSTD_customMem cMem;
-    buffer_t* buffers;
-} ZSTDMT_bufferPool;
-
-static void ZSTDMT_freeBufferPool(ZSTDMT_bufferPool* bufPool)
-{
-    DEBUGLOG(3, "ZSTDMT_freeBufferPool (address:%08X)", (U32)(size_t)bufPool);
-    if (!bufPool) return;   /* compatibility with free on NULL */
-    if (bufPool->buffers) {
-        unsigned u;
-        for (u=0; u<bufPool->totalBuffers; u++) {
-            DEBUGLOG(4, "free buffer %2u (address:%08X)", u, (U32)(size_t)bufPool->buffers[u].start);
-            ZSTD_customFree(bufPool->buffers[u].start, bufPool->cMem);
-        }
-        ZSTD_customFree(bufPool->buffers, bufPool->cMem);
-    }
-    ZSTD_pthread_mutex_destroy(&bufPool->poolMutex);
-    ZSTD_customFree(bufPool, bufPool->cMem);
-}
-
-static ZSTDMT_bufferPool* ZSTDMT_createBufferPool(unsigned maxNbBuffers, ZSTD_customMem cMem)
-{
-    ZSTDMT_bufferPool* const bufPool =
-        (ZSTDMT_bufferPool*)ZSTD_customCalloc(sizeof(ZSTDMT_bufferPool), cMem);
-    if (bufPool==NULL) return NULL;
-    if (ZSTD_pthread_mutex_init(&bufPool->poolMutex, NULL)) {
-        ZSTD_customFree(bufPool, cMem);
-        return NULL;
-    }
-    bufPool->buffers = (buffer_t*)ZSTD_customCalloc(maxNbBuffers * sizeof(buffer_t), cMem);
-    if (bufPool->buffers==NULL) {
-        ZSTDMT_freeBufferPool(bufPool);
-        return NULL;
-    }
-    bufPool->bufferSize = 64 KB;
-    bufPool->totalBuffers = maxNbBuffers;
-    bufPool->nbBuffers = 0;
-    bufPool->cMem = cMem;
-    return bufPool;
-}
-
-/* only works at initialization, not during compression */
-static size_t ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool* bufPool)
-{
-    size_t const poolSize = sizeof(*bufPool);
-    size_t const arraySize = bufPool->totalBuffers * sizeof(buffer_t);
-    unsigned u;
-    size_t totalBufferSize = 0;
-    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
-    for (u=0; u<bufPool->totalBuffers; u++)
-        totalBufferSize += bufPool->buffers[u].capacity;
-    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
-
-    return poolSize + arraySize + totalBufferSize;
-}
-
-/* ZSTDMT_setBufferSize() :
- * all future buffers provided by this buffer pool will have _at least_ this size
- * note : it's better for all buffers to have same size,
- * as they become freely interchangeable, reducing malloc/free usages and memory fragmentation */
-static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* const bufPool, size_t const bSize)
-{
-    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
-    DEBUGLOG(4, "ZSTDMT_setBufferSize: bSize = %u", (U32)bSize);
-    bufPool->bufferSize = bSize;
-    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
-}
-
-
-static ZSTDMT_bufferPool* ZSTDMT_expandBufferPool(ZSTDMT_bufferPool* srcBufPool, unsigned maxNbBuffers)
-{
-    if (srcBufPool==NULL) return NULL;
-    if (srcBufPool->totalBuffers >= maxNbBuffers) /* good enough */
-        return srcBufPool;
-    /* need a larger buffer pool */
-    {   ZSTD_customMem const cMem = srcBufPool->cMem;
-        size_t const bSize = srcBufPool->bufferSize;   /* forward parameters */
-        ZSTDMT_bufferPool* newBufPool;
-        ZSTDMT_freeBufferPool(srcBufPool);
-        newBufPool = ZSTDMT_createBufferPool(maxNbBuffers, cMem);
-        if (newBufPool==NULL) return newBufPool;
-        ZSTDMT_setBufferSize(newBufPool, bSize);
-        return newBufPool;
-    }
-}
-
-/** ZSTDMT_getBuffer() :
- *  assumption : bufPool must be valid
- * @return : a buffer, with start pointer and size
- *  note: allocation may fail, in this case, start==NULL and size==0 */
-static buffer_t ZSTDMT_getBuffer(ZSTDMT_bufferPool* bufPool)
-{
-    size_t const bSize = bufPool->bufferSize;
-    DEBUGLOG(5, "ZSTDMT_getBuffer: bSize = %u", (U32)bufPool->bufferSize);
-    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
-    if (bufPool->nbBuffers) {   /* try to use an existing buffer */
-        buffer_t const buf = bufPool->buffers[--(bufPool->nbBuffers)];
-        size_t const availBufferSize = buf.capacity;
-        bufPool->buffers[bufPool->nbBuffers] = g_nullBuffer;
-        if ((availBufferSize >= bSize) & ((availBufferSize>>3) <= bSize)) {
-            /* large enough, but not too much */
-            DEBUGLOG(5, "ZSTDMT_getBuffer: provide buffer %u of size %u",
-                        bufPool->nbBuffers, (U32)buf.capacity);
-            ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
-            return buf;
-        }
-        /* size conditions not respected : scratch this buffer, create new one */
-        DEBUGLOG(5, "ZSTDMT_getBuffer: existing buffer does not meet size conditions => freeing");
-        ZSTD_customFree(buf.start, bufPool->cMem);
-    }
-    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
-    /* create new buffer */
-    DEBUGLOG(5, "ZSTDMT_getBuffer: create a new buffer");
-    {   buffer_t buffer;
-        void* const start = ZSTD_customMalloc(bSize, bufPool->cMem);
-        buffer.start = start;   /* note : start can be NULL if malloc fails ! */
-        buffer.capacity = (start==NULL) ? 0 : bSize;
-        if (start==NULL) {
-            DEBUGLOG(5, "ZSTDMT_getBuffer: buffer allocation failure !!");
-        } else {
-            DEBUGLOG(5, "ZSTDMT_getBuffer: created buffer of size %u", (U32)bSize);
-        }
-        return buffer;
-    }
-}
-
-#if ZSTD_RESIZE_SEQPOOL
-/** ZSTDMT_resizeBuffer() :
- * assumption : bufPool must be valid
- * @return : a buffer that is at least the buffer pool buffer size.
- *           If a reallocation happens, the data in the input buffer is copied.
- */
-static buffer_t ZSTDMT_resizeBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buffer)
-{
-    size_t const bSize = bufPool->bufferSize;
-    if (buffer.capacity < bSize) {
-        void* const start = ZSTD_customMalloc(bSize, bufPool->cMem);
-        buffer_t newBuffer;
-        newBuffer.start = start;
-        newBuffer.capacity = start == NULL ? 0 : bSize;
-        if (start != NULL) {
-            assert(newBuffer.capacity >= buffer.capacity);
-            ZSTD_memcpy(newBuffer.start, buffer.start, buffer.capacity);
-            DEBUGLOG(5, "ZSTDMT_resizeBuffer: created buffer of size %u", (U32)bSize);
-            return newBuffer;
-        }
-        DEBUGLOG(5, "ZSTDMT_resizeBuffer: buffer allocation failure !!");
-    }
-    return buffer;
-}
-#endif
-
-/* store buffer for later re-use, up to pool capacity */
-static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf)
-{
-    DEBUGLOG(5, "ZSTDMT_releaseBuffer");
-    if (buf.start == NULL) return;   /* compatible with release on NULL */
-    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
-    if (bufPool->nbBuffers < bufPool->totalBuffers) {
-        bufPool->buffers[bufPool->nbBuffers++] = buf;  /* stored for later use */
-        DEBUGLOG(5, "ZSTDMT_releaseBuffer: stored buffer of size %u in slot %u",
-                    (U32)buf.capacity, (U32)(bufPool->nbBuffers-1));
-        ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
-        return;
-    }
-    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
-    /* Reached bufferPool capacity (note: should not happen) */
-    DEBUGLOG(5, "ZSTDMT_releaseBuffer: pool capacity reached => freeing ");
-    ZSTD_customFree(buf.start, bufPool->cMem);
-}
-
-/* We need 2 output buffers per worker since each dstBuff must be flushed after it is released.
- * The 3 additional buffers are as follows:
- *   1 buffer for input loading
- *   1 buffer for "next input" when submitting current one
- *   1 buffer stuck in queue */
-#define BUF_POOL_MAX_NB_BUFFERS(nbWorkers) (2*(nbWorkers) + 3)
-
-/* After a worker releases its rawSeqStore, it is immediately ready for reuse.
- * So we only need one seq buffer per worker. */
-#define SEQ_POOL_MAX_NB_BUFFERS(nbWorkers) (nbWorkers)
-
-/* =====   Seq Pool Wrapper   ====== */
-
-typedef ZSTDMT_bufferPool ZSTDMT_seqPool;
-
-static size_t ZSTDMT_sizeof_seqPool(ZSTDMT_seqPool* seqPool)
-{
-    return ZSTDMT_sizeof_bufferPool(seqPool);
-}
-
-static rawSeqStore_t bufferToSeq(buffer_t buffer)
-{
-    rawSeqStore_t seq = kNullRawSeqStore;
-    seq.seq = (rawSeq*)buffer.start;
-    seq.capacity = buffer.capacity / sizeof(rawSeq);
-    return seq;
-}
-
-static buffer_t seqToBuffer(rawSeqStore_t seq)
-{
-    buffer_t buffer;
-    buffer.start = seq.seq;
-    buffer.capacity = seq.capacity * sizeof(rawSeq);
-    return buffer;
-}
-
-static rawSeqStore_t ZSTDMT_getSeq(ZSTDMT_seqPool* seqPool)
-{
-    if (seqPool->bufferSize == 0) {
-        return kNullRawSeqStore;
-    }
-    return bufferToSeq(ZSTDMT_getBuffer(seqPool));
-}
-
-#if ZSTD_RESIZE_SEQPOOL
-static rawSeqStore_t ZSTDMT_resizeSeq(ZSTDMT_seqPool* seqPool, rawSeqStore_t seq)
-{
-  return bufferToSeq(ZSTDMT_resizeBuffer(seqPool, seqToBuffer(seq)));
-}
-#endif
-
-static void ZSTDMT_releaseSeq(ZSTDMT_seqPool* seqPool, rawSeqStore_t seq)
-{
-  ZSTDMT_releaseBuffer(seqPool, seqToBuffer(seq));
-}
-
-static void ZSTDMT_setNbSeq(ZSTDMT_seqPool* const seqPool, size_t const nbSeq)
-{
-  ZSTDMT_setBufferSize(seqPool, nbSeq * sizeof(rawSeq));
-}
-
-static ZSTDMT_seqPool* ZSTDMT_createSeqPool(unsigned nbWorkers, ZSTD_customMem cMem)
-{
-    ZSTDMT_seqPool* const seqPool = ZSTDMT_createBufferPool(SEQ_POOL_MAX_NB_BUFFERS(nbWorkers), cMem);
-    if (seqPool == NULL) return NULL;
-    ZSTDMT_setNbSeq(seqPool, 0);
-    return seqPool;
-}
-
-static void ZSTDMT_freeSeqPool(ZSTDMT_seqPool* seqPool)
-{
-    ZSTDMT_freeBufferPool(seqPool);
-}
-
-static ZSTDMT_seqPool* ZSTDMT_expandSeqPool(ZSTDMT_seqPool* pool, U32 nbWorkers)
-{
-    return ZSTDMT_expandBufferPool(pool, SEQ_POOL_MAX_NB_BUFFERS(nbWorkers));
-}
-
-
-/* =====   CCtx Pool   ===== */
-/* a single CCtx Pool can be invoked from multiple threads in parallel */
-
-typedef struct {
-    ZSTD_pthread_mutex_t poolMutex;
-    int totalCCtx;
-    int availCCtx;
-    ZSTD_customMem cMem;
-    ZSTD_CCtx** cctxs;
-} ZSTDMT_CCtxPool;
-
-/* note : all CCtx borrowed from the pool must be reverted back to the pool _before_ freeing the pool */
-static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
-{
-    if (!pool) return;
-    ZSTD_pthread_mutex_destroy(&pool->poolMutex);
-    if (pool->cctxs) {
-        int cid;
-        for (cid=0; cid<pool->totalCCtx; cid++)
-            ZSTD_freeCCtx(pool->cctxs[cid]);  /* free compatible with NULL */
-        ZSTD_customFree(pool->cctxs, pool->cMem);
-    }
-    ZSTD_customFree(pool, pool->cMem);
-}
-
-/* ZSTDMT_createCCtxPool() :
- * implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */
-static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,
-                                              ZSTD_customMem cMem)
-{
-    ZSTDMT_CCtxPool* const cctxPool =
-        (ZSTDMT_CCtxPool*) ZSTD_customCalloc(sizeof(ZSTDMT_CCtxPool), cMem);
-    assert(nbWorkers > 0);
-    if (!cctxPool) return NULL;
-    if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) {
-        ZSTD_customFree(cctxPool, cMem);
-        return NULL;
-    }
-    cctxPool->totalCCtx = nbWorkers;
-    cctxPool->cctxs = (ZSTD_CCtx**)ZSTD_customCalloc(nbWorkers * sizeof(ZSTD_CCtx*), cMem);
-    if (!cctxPool->cctxs) {
-        ZSTDMT_freeCCtxPool(cctxPool);
-        return NULL;
-    }
-    cctxPool->cMem = cMem;
-    cctxPool->cctxs[0] = ZSTD_createCCtx_advanced(cMem);
-    if (!cctxPool->cctxs[0]) { ZSTDMT_freeCCtxPool(cctxPool); return NULL; }
-    cctxPool->availCCtx = 1;   /* at least one cctx for single-thread mode */
-    DEBUGLOG(3, "cctxPool created, with %u workers", nbWorkers);
-    return cctxPool;
-}
-
-static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool,
-                                              int nbWorkers)
-{
-    if (srcPool==NULL) return NULL;
-    if (nbWorkers <= srcPool->totalCCtx) return srcPool;   /* good enough */
-    /* need a larger cctx pool */
-    {   ZSTD_customMem const cMem = srcPool->cMem;
-        ZSTDMT_freeCCtxPool(srcPool);
-        return ZSTDMT_createCCtxPool(nbWorkers, cMem);
-    }
-}
-
-/* only works during initialization phase, not during compression */
-static size_t ZSTDMT_sizeof_CCtxPool(ZSTDMT_CCtxPool* cctxPool)
-{
-    ZSTD_pthread_mutex_lock(&cctxPool->poolMutex);
-    {   unsigned const nbWorkers = cctxPool->totalCCtx;
-        size_t const poolSize = sizeof(*cctxPool);
-        size_t const arraySize = cctxPool->totalCCtx * sizeof(ZSTD_CCtx*);
-        size_t totalCCtxSize = 0;
-        unsigned u;
-        for (u=0; u<nbWorkers; u++) {
-            totalCCtxSize += ZSTD_sizeof_CCtx(cctxPool->cctxs[u]);
-        }
-        ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);
-        assert(nbWorkers > 0);
-        return poolSize + arraySize + totalCCtxSize;
-    }
-}
-
-static ZSTD_CCtx* ZSTDMT_getCCtx(ZSTDMT_CCtxPool* cctxPool)
-{
-    DEBUGLOG(5, "ZSTDMT_getCCtx");
-    ZSTD_pthread_mutex_lock(&cctxPool->poolMutex);
-    if (cctxPool->availCCtx) {
-        cctxPool->availCCtx--;
-        {   ZSTD_CCtx* const cctx = cctxPool->cctxs[cctxPool->availCCtx];
-            ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);
-            return cctx;
-    }   }
-    ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);
-    DEBUGLOG(5, "create one more CCtx");
-    return ZSTD_createCCtx_advanced(cctxPool->cMem);   /* note : can be NULL, when creation fails ! */
-}
-
-static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)
-{
-    if (cctx==NULL) return;   /* compatibility with release on NULL */
-    ZSTD_pthread_mutex_lock(&pool->poolMutex);
-    if (pool->availCCtx < pool->totalCCtx)
-        pool->cctxs[pool->availCCtx++] = cctx;
-    else {
-        /* pool overflow : should not happen, since totalCCtx==nbWorkers */
-        DEBUGLOG(4, "CCtx pool overflow : free cctx");
-        ZSTD_freeCCtx(cctx);
-    }
-    ZSTD_pthread_mutex_unlock(&pool->poolMutex);
-}
-
-/* ====   Serial State   ==== */
-
-typedef struct {
-    void const* start;
-    size_t size;
-} range_t;
-
-typedef struct {
-    /* All variables in the struct are protected by mutex. */
-    ZSTD_pthread_mutex_t mutex;
-    ZSTD_pthread_cond_t cond;
-    ZSTD_CCtx_params params;
-    ldmState_t ldmState;
-    XXH64_state_t xxhState;
-    unsigned nextJobID;
-    /* Protects ldmWindow.
-     * Must be acquired after the main mutex when acquiring both.
-     */
-    ZSTD_pthread_mutex_t ldmWindowMutex;
-    ZSTD_pthread_cond_t ldmWindowCond;  /* Signaled when ldmWindow is updated */
-    ZSTD_window_t ldmWindow;  /* A thread-safe copy of ldmState.window */
-} serialState_t;
-
-static int
-ZSTDMT_serialState_reset(serialState_t* serialState,
-                         ZSTDMT_seqPool* seqPool,
-                         ZSTD_CCtx_params params,
-                         size_t jobSize,
-                         const void* dict, size_t const dictSize,
-                         ZSTD_dictContentType_e dictContentType)
-{
-    /* Adjust parameters */
-    if (params.ldmParams.enableLdm == ZSTD_ps_enable) {
-        DEBUGLOG(4, "LDM window size = %u KB", (1U << params.cParams.windowLog) >> 10);
-        ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
-        assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
-        assert(params.ldmParams.hashRateLog < 32);
-    } else {
-        ZSTD_memset(&params.ldmParams, 0, sizeof(params.ldmParams));
-    }
-    serialState->nextJobID = 0;
-    if (params.fParams.checksumFlag)
-        XXH64_reset(&serialState->xxhState, 0);
-    if (params.ldmParams.enableLdm == ZSTD_ps_enable) {
-        ZSTD_customMem cMem = params.customMem;
-        unsigned const hashLog = params.ldmParams.hashLog;
-        size_t const hashSize = ((size_t)1 << hashLog) * sizeof(ldmEntry_t);
-        unsigned const bucketLog =
-            params.ldmParams.hashLog - params.ldmParams.bucketSizeLog;
-        unsigned const prevBucketLog =
-            serialState->params.ldmParams.hashLog -
-            serialState->params.ldmParams.bucketSizeLog;
-        size_t const numBuckets = (size_t)1 << bucketLog;
-        /* Size the seq pool tables */
-        ZSTDMT_setNbSeq(seqPool, ZSTD_ldm_getMaxNbSeq(params.ldmParams, jobSize));
-        /* Reset the window */
-        ZSTD_window_init(&serialState->ldmState.window);
-        /* Resize tables and output space if necessary. */
-        if (serialState->ldmState.hashTable == NULL || serialState->params.ldmParams.hashLog < hashLog) {
-            ZSTD_customFree(serialState->ldmState.hashTable, cMem);
-            serialState->ldmState.hashTable = (ldmEntry_t*)ZSTD_customMalloc(hashSize, cMem);
-        }
-        if (serialState->ldmState.bucketOffsets == NULL || prevBucketLog < bucketLog) {
-            ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem);
-            serialState->ldmState.bucketOffsets = (BYTE*)ZSTD_customMalloc(numBuckets, cMem);
-        }
-        if (!serialState->ldmState.hashTable || !serialState->ldmState.bucketOffsets)
-            return 1;
-        /* Zero the tables */
-        ZSTD_memset(serialState->ldmState.hashTable, 0, hashSize);
-        ZSTD_memset(serialState->ldmState.bucketOffsets, 0, numBuckets);
-
-        /* Update window state and fill hash table with dict */
-        serialState->ldmState.loadedDictEnd = 0;
-        if (dictSize > 0) {
-            if (dictContentType == ZSTD_dct_rawContent) {
-                BYTE const* const dictEnd = (const BYTE*)dict + dictSize;
-                ZSTD_window_update(&serialState->ldmState.window, dict, dictSize, /* forceNonContiguous */ 0);
-                ZSTD_ldm_fillHashTable(&serialState->ldmState, (const BYTE*)dict, dictEnd, &params.ldmParams);
-                serialState->ldmState.loadedDictEnd = params.forceWindow ? 0 : (U32)(dictEnd - serialState->ldmState.window.base);
-            } else {
-                /* don't even load anything */
-            }
-        }
-
-        /* Initialize serialState's copy of ldmWindow. */
-        serialState->ldmWindow = serialState->ldmState.window;
-    }
-
-    serialState->params = params;
-    serialState->params.jobSize = (U32)jobSize;
-    return 0;
-}
-
-static int ZSTDMT_serialState_init(serialState_t* serialState)
-{
-    int initError = 0;
-    ZSTD_memset(serialState, 0, sizeof(*serialState));
-    initError |= ZSTD_pthread_mutex_init(&serialState->mutex, NULL);
-    initError |= ZSTD_pthread_cond_init(&serialState->cond, NULL);
-    initError |= ZSTD_pthread_mutex_init(&serialState->ldmWindowMutex, NULL);
-    initError |= ZSTD_pthread_cond_init(&serialState->ldmWindowCond, NULL);
-    return initError;
-}
-
-static void ZSTDMT_serialState_free(serialState_t* serialState)
-{
-    ZSTD_customMem cMem = serialState->params.customMem;
-    ZSTD_pthread_mutex_destroy(&serialState->mutex);
-    ZSTD_pthread_cond_destroy(&serialState->cond);
-    ZSTD_pthread_mutex_destroy(&serialState->ldmWindowMutex);
-    ZSTD_pthread_cond_destroy(&serialState->ldmWindowCond);
-    ZSTD_customFree(serialState->ldmState.hashTable, cMem);
-    ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem);
-}
-
-static void ZSTDMT_serialState_update(serialState_t* serialState,
-                                      ZSTD_CCtx* jobCCtx, rawSeqStore_t seqStore,
-                                      range_t src, unsigned jobID)
-{
-    /* Wait for our turn */
-    ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);
-    while (serialState->nextJobID < jobID) {
-        DEBUGLOG(5, "wait for serialState->cond");
-        ZSTD_pthread_cond_wait(&serialState->cond, &serialState->mutex);
-    }
-    /* A future job may error and skip our job */
-    if (serialState->nextJobID == jobID) {
-        /* It is now our turn, do any processing necessary */
-        if (serialState->params.ldmParams.enableLdm == ZSTD_ps_enable) {
-            size_t error;
-            assert(seqStore.seq != NULL && seqStore.pos == 0 &&
-                   seqStore.size == 0 && seqStore.capacity > 0);
-            assert(src.size <= serialState->params.jobSize);
-            ZSTD_window_update(&serialState->ldmState.window, src.start, src.size, /* forceNonContiguous */ 0);
-            error = ZSTD_ldm_generateSequences(
-                &serialState->ldmState, &seqStore,
-                &serialState->params.ldmParams, src.start, src.size);
-            /* We provide a large enough buffer to never fail. */
-            assert(!ZSTD_isError(error)); (void)error;
-            /* Update ldmWindow to match the ldmState.window and signal the main
-             * thread if it is waiting for a buffer.
-             */
-            ZSTD_PTHREAD_MUTEX_LOCK(&serialState->ldmWindowMutex);
-            serialState->ldmWindow = serialState->ldmState.window;
-            ZSTD_pthread_cond_signal(&serialState->ldmWindowCond);
-            ZSTD_pthread_mutex_unlock(&serialState->ldmWindowMutex);
-        }
-        if (serialState->params.fParams.checksumFlag && src.size > 0)
-            XXH64_update(&serialState->xxhState, src.start, src.size);
-    }
-    /* Now it is the next jobs turn */
-    serialState->nextJobID++;
-    ZSTD_pthread_cond_broadcast(&serialState->cond);
-    ZSTD_pthread_mutex_unlock(&serialState->mutex);
-
-    if (seqStore.size > 0) {
-        ZSTD_referenceExternalSequences(jobCCtx, seqStore.seq, seqStore.size);
-        assert(serialState->params.ldmParams.enableLdm == ZSTD_ps_enable);
-    }
-}
-
-static void ZSTDMT_serialState_ensureFinished(serialState_t* serialState,
-                                              unsigned jobID, size_t cSize)
-{
-    ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);
-    if (serialState->nextJobID <= jobID) {
-        assert(ZSTD_isError(cSize)); (void)cSize;
-        DEBUGLOG(5, "Skipping past job %u because of error", jobID);
-        serialState->nextJobID = jobID + 1;
-        ZSTD_pthread_cond_broadcast(&serialState->cond);
-
-        ZSTD_PTHREAD_MUTEX_LOCK(&serialState->ldmWindowMutex);
-        ZSTD_window_clear(&serialState->ldmWindow);
-        ZSTD_pthread_cond_signal(&serialState->ldmWindowCond);
-        ZSTD_pthread_mutex_unlock(&serialState->ldmWindowMutex);
-    }
-    ZSTD_pthread_mutex_unlock(&serialState->mutex);
-
-}
-
-
-/* ------------------------------------------ */
-/* =====          Worker thread         ===== */
-/* ------------------------------------------ */
-
-static const range_t kNullRange = { NULL, 0 };
-
-typedef struct {
-    size_t   consumed;                   /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx */
-    size_t   cSize;                      /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx, then set0 by mtctx */
-    ZSTD_pthread_mutex_t job_mutex;      /* Thread-safe - used by mtctx and worker */
-    ZSTD_pthread_cond_t job_cond;        /* Thread-safe - used by mtctx and worker */
-    ZSTDMT_CCtxPool* cctxPool;           /* Thread-safe - used by mtctx and (all) workers */
-    ZSTDMT_bufferPool* bufPool;          /* Thread-safe - used by mtctx and (all) workers */
-    ZSTDMT_seqPool* seqPool;             /* Thread-safe - used by mtctx and (all) workers */
-    serialState_t* serial;               /* Thread-safe - used by mtctx and (all) workers */
-    buffer_t dstBuff;                    /* set by worker (or mtctx), then read by worker & mtctx, then modified by mtctx => no barrier */
-    range_t prefix;                      /* set by mtctx, then read by worker & mtctx => no barrier */
-    range_t src;                         /* set by mtctx, then read by worker & mtctx => no barrier */
-    unsigned jobID;                      /* set by mtctx, then read by worker => no barrier */
-    unsigned firstJob;                   /* set by mtctx, then read by worker => no barrier */
-    unsigned lastJob;                    /* set by mtctx, then read by worker => no barrier */
-    ZSTD_CCtx_params params;             /* set by mtctx, then read by worker => no barrier */
-    const ZSTD_CDict* cdict;             /* set by mtctx, then read by worker => no barrier */
-    unsigned long long fullFrameSize;    /* set by mtctx, then read by worker => no barrier */
-    size_t   dstFlushed;                 /* used only by mtctx */
-    unsigned frameChecksumNeeded;        /* used only by mtctx */
-} ZSTDMT_jobDescription;
-
-#define JOB_ERROR(e)                                \
-    do {                                            \
-        ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);   \
-        job->cSize = e;                             \
-        ZSTD_pthread_mutex_unlock(&job->job_mutex); \
-        goto _endJob;                               \
-    } while (0)
-
-/* ZSTDMT_compressionJob() is a POOL_function type */
-static void ZSTDMT_compressionJob(void* jobDescription)
-{
-    ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
-    ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
-    ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
-    rawSeqStore_t rawSeqStore = ZSTDMT_getSeq(job->seqPool);
-    buffer_t dstBuff = job->dstBuff;
-    size_t lastCBlockSize = 0;
-
-    /* resources */
-    if (cctx==NULL) JOB_ERROR(ERROR(memory_allocation));
-    if (dstBuff.start == NULL) {   /* streaming job : doesn't provide a dstBuffer */
-        dstBuff = ZSTDMT_getBuffer(job->bufPool);
-        if (dstBuff.start==NULL) JOB_ERROR(ERROR(memory_allocation));
-        job->dstBuff = dstBuff;   /* this value can be read in ZSTDMT_flush, when it copies the whole job */
-    }
-    if (jobParams.ldmParams.enableLdm == ZSTD_ps_enable && rawSeqStore.seq == NULL)
-        JOB_ERROR(ERROR(memory_allocation));
-
-    /* Don't compute the checksum for chunks, since we compute it externally,
-     * but write it in the header.
-     */
-    if (job->jobID != 0) jobParams.fParams.checksumFlag = 0;
-    /* Don't run LDM for the chunks, since we handle it externally */
-    jobParams.ldmParams.enableLdm = ZSTD_ps_disable;
-    /* Correct nbWorkers to 0. */
-    jobParams.nbWorkers = 0;
-
-
-    /* init */
-    if (job->cdict) {
-        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast, job->cdict, &jobParams, job->fullFrameSize);
-        assert(job->firstJob);  /* only allowed for first job */
-        if (ZSTD_isError(initError)) JOB_ERROR(initError);
-    } else {  /* srcStart points at reloaded section */
-        U64 const pledgedSrcSize = job->firstJob ? job->fullFrameSize : job->src.size;
-        {   size_t const forceWindowError = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_forceMaxWindow, !job->firstJob);
-            if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError);
-        }
-        if (!job->firstJob) {
-            size_t const err = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_deterministicRefPrefix, 0);
-            if (ZSTD_isError(err)) JOB_ERROR(err);
-        }
-        {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx,
-                                        job->prefix.start, job->prefix.size, ZSTD_dct_rawContent, /* load dictionary in "content-only" mode (no header analysis) */
-                                        ZSTD_dtlm_fast,
-                                        NULL, /*cdict*/
-                                        &jobParams, pledgedSrcSize);
-            if (ZSTD_isError(initError)) JOB_ERROR(initError);
-    }   }
-
-    /* Perform serial step as early as possible, but after CCtx initialization */
-    ZSTDMT_serialState_update(job->serial, cctx, rawSeqStore, job->src, job->jobID);
-
-    if (!job->firstJob) {  /* flush and overwrite frame header when it's not first job */
-        size_t const hSize = ZSTD_compressContinue_public(cctx, dstBuff.start, dstBuff.capacity, job->src.start, 0);
-        if (ZSTD_isError(hSize)) JOB_ERROR(hSize);
-        DEBUGLOG(5, "ZSTDMT_compressionJob: flush and overwrite %u bytes of frame header (not first job)", (U32)hSize);
-        ZSTD_invalidateRepCodes(cctx);
-    }
-
-    /* compress */
-    {   size_t const chunkSize = 4*ZSTD_BLOCKSIZE_MAX;
-        int const nbChunks = (int)((job->src.size + (chunkSize-1)) / chunkSize);
-        const BYTE* ip = (const BYTE*) job->src.start;
-        BYTE* const ostart = (BYTE*)dstBuff.start;
-        BYTE* op = ostart;
-        BYTE* oend = op + dstBuff.capacity;
-        int chunkNb;
-        if (sizeof(size_t) > sizeof(int)) assert(job->src.size < ((size_t)INT_MAX) * chunkSize);   /* check overflow */
-        DEBUGLOG(5, "ZSTDMT_compressionJob: compress %u bytes in %i blocks", (U32)job->src.size, nbChunks);
-        assert(job->cSize == 0);
-        for (chunkNb = 1; chunkNb < nbChunks; chunkNb++) {
-            size_t const cSize = ZSTD_compressContinue_public(cctx, op, oend-op, ip, chunkSize);
-            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
-            ip += chunkSize;
-            op += cSize; assert(op < oend);
-            /* stats */
-            ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);
-            job->cSize += cSize;
-            job->consumed = chunkSize * chunkNb;
-            DEBUGLOG(5, "ZSTDMT_compressionJob: compress new block : cSize==%u bytes (total: %u)",
-                        (U32)cSize, (U32)job->cSize);
-            ZSTD_pthread_cond_signal(&job->job_cond);   /* warns some more data is ready to be flushed */
-            ZSTD_pthread_mutex_unlock(&job->job_mutex);
-        }
-        /* last block */
-        assert(chunkSize > 0);
-        assert((chunkSize & (chunkSize - 1)) == 0);  /* chunkSize must be power of 2 for mask==(chunkSize-1) to work */
-        if ((nbChunks > 0) | job->lastJob /*must output a "last block" flag*/ ) {
-            size_t const lastBlockSize1 = job->src.size & (chunkSize-1);
-            size_t const lastBlockSize = ((lastBlockSize1==0) & (job->src.size>=chunkSize)) ? chunkSize : lastBlockSize1;
-            size_t const cSize = (job->lastJob) ?
-                 ZSTD_compressEnd_public(cctx, op, oend-op, ip, lastBlockSize) :
-                 ZSTD_compressContinue_public(cctx, op, oend-op, ip, lastBlockSize);
-            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
-            lastCBlockSize = cSize;
-    }   }
-    if (!job->firstJob) {
-        /* Double check that we don't have an ext-dict, because then our
-         * repcode invalidation doesn't work.
-         */
-        assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
-    }
-    ZSTD_CCtx_trace(cctx, 0);
-
-_endJob:
-    ZSTDMT_serialState_ensureFinished(job->serial, job->jobID, job->cSize);
-    if (job->prefix.size > 0)
-        DEBUGLOG(5, "Finished with prefix: %zx", (size_t)job->prefix.start);
-    DEBUGLOG(5, "Finished with source: %zx", (size_t)job->src.start);
-    /* release resources */
-    ZSTDMT_releaseSeq(job->seqPool, rawSeqStore);
-    ZSTDMT_releaseCCtx(job->cctxPool, cctx);
-    /* report */
-    ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);
-    if (ZSTD_isError(job->cSize)) assert(lastCBlockSize == 0);
-    job->cSize += lastCBlockSize;
-    job->consumed = job->src.size;  /* when job->consumed == job->src.size , compression job is presumed completed */
-    ZSTD_pthread_cond_signal(&job->job_cond);
-    ZSTD_pthread_mutex_unlock(&job->job_mutex);
-}
-
-
-/* ------------------------------------------ */
-/* =====   Multi-threaded compression   ===== */
-/* ------------------------------------------ */
-
-typedef struct {
-    range_t prefix;         /* read-only non-owned prefix buffer */
-    buffer_t buffer;
-    size_t filled;
-} inBuff_t;
-
-typedef struct {
-  BYTE* buffer;     /* The round input buffer. All jobs get references
-                     * to pieces of the buffer. ZSTDMT_tryGetInputRange()
-                     * handles handing out job input buffers, and makes
-                     * sure it doesn't overlap with any pieces still in use.
-                     */
-  size_t capacity;  /* The capacity of buffer. */
-  size_t pos;       /* The position of the current inBuff in the round
-                     * buffer. Updated past the end if the inBuff once
-                     * the inBuff is sent to the worker thread.
-                     * pos <= capacity.
-                     */
-} roundBuff_t;
-
-static const roundBuff_t kNullRoundBuff = {NULL, 0, 0};
-
-#define RSYNC_LENGTH 32
-/* Don't create chunks smaller than the zstd block size.
- * This stops us from regressing compression ratio too much,
- * and ensures our output fits in ZSTD_compressBound().
- *
- * If this is shrunk < ZSTD_BLOCKSIZELOG_MIN then
- * ZSTD_COMPRESSBOUND() will need to be updated.
- */
-#define RSYNC_MIN_BLOCK_LOG ZSTD_BLOCKSIZELOG_MAX
-#define RSYNC_MIN_BLOCK_SIZE (1<<RSYNC_MIN_BLOCK_LOG)
-
-typedef struct {
-  U64 hash;
-  U64 hitMask;
-  U64 primePower;
-} rsyncState_t;
-
-struct ZSTDMT_CCtx_s {
-    POOL_ctx* factory;
-    ZSTDMT_jobDescription* jobs;
-    ZSTDMT_bufferPool* bufPool;
-    ZSTDMT_CCtxPool* cctxPool;
-    ZSTDMT_seqPool* seqPool;
-    ZSTD_CCtx_params params;
-    size_t targetSectionSize;
-    size_t targetPrefixSize;
-    int jobReady;        /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */
-    inBuff_t inBuff;
-    roundBuff_t roundBuff;
-    serialState_t serial;
-    rsyncState_t rsync;
-    unsigned jobIDMask;
-    unsigned doneJobID;
-    unsigned nextJobID;
-    unsigned frameEnded;
-    unsigned allJobsCompleted;
-    unsigned long long frameContentSize;
-    unsigned long long consumed;
-    unsigned long long produced;
-    ZSTD_customMem cMem;
-    ZSTD_CDict* cdictLocal;
-    const ZSTD_CDict* cdict;
-    unsigned providedFactory: 1;
-};
-
-static void ZSTDMT_freeJobsTable(ZSTDMT_jobDescription* jobTable, U32 nbJobs, ZSTD_customMem cMem)
-{
-    U32 jobNb;
-    if (jobTable == NULL) return;
-    for (jobNb=0; jobNb<nbJobs; jobNb++) {
-        ZSTD_pthread_mutex_destroy(&jobTable[jobNb].job_mutex);
-        ZSTD_pthread_cond_destroy(&jobTable[jobNb].job_cond);
-    }
-    ZSTD_customFree(jobTable, cMem);
-}
-
-/* ZSTDMT_allocJobsTable()
- * allocate and init a job table.
- * update *nbJobsPtr to next power of 2 value, as size of table */
-static ZSTDMT_jobDescription* ZSTDMT_createJobsTable(U32* nbJobsPtr, ZSTD_customMem cMem)
-{
-    U32 const nbJobsLog2 = ZSTD_highbit32(*nbJobsPtr) + 1;
-    U32 const nbJobs = 1 << nbJobsLog2;
-    U32 jobNb;
-    ZSTDMT_jobDescription* const jobTable = (ZSTDMT_jobDescription*)
-                ZSTD_customCalloc(nbJobs * sizeof(ZSTDMT_jobDescription), cMem);
-    int initError = 0;
-    if (jobTable==NULL) return NULL;
-    *nbJobsPtr = nbJobs;
-    for (jobNb=0; jobNb<nbJobs; jobNb++) {
-        initError |= ZSTD_pthread_mutex_init(&jobTable[jobNb].job_mutex, NULL);
-        initError |= ZSTD_pthread_cond_init(&jobTable[jobNb].job_cond, NULL);
-    }
-    if (initError != 0) {
-        ZSTDMT_freeJobsTable(jobTable, nbJobs, cMem);
-        return NULL;
-    }
-    return jobTable;
-}
-
-static size_t ZSTDMT_expandJobsTable (ZSTDMT_CCtx* mtctx, U32 nbWorkers) {
-    U32 nbJobs = nbWorkers + 2;
-    if (nbJobs > mtctx->jobIDMask+1) {  /* need more job capacity */
-        ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);
-        mtctx->jobIDMask = 0;
-        mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, mtctx->cMem);
-        if (mtctx->jobs==NULL) return ERROR(memory_allocation);
-        assert((nbJobs != 0) && ((nbJobs & (nbJobs - 1)) == 0));  /* ensure nbJobs is a power of 2 */
-        mtctx->jobIDMask = nbJobs - 1;
-    }
-    return 0;
-}
-
-
-/* ZSTDMT_CCtxParam_setNbWorkers():
- * Internal use only */
-static size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers)
-{
-    return ZSTD_CCtxParams_setParameter(params, ZSTD_c_nbWorkers, (int)nbWorkers);
-}
-
-MEM_STATIC ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced_internal(unsigned nbWorkers, ZSTD_customMem cMem, ZSTD_threadPool* pool)
-{
-    ZSTDMT_CCtx* mtctx;
-    U32 nbJobs = nbWorkers + 2;
-    int initError;
-    DEBUGLOG(3, "ZSTDMT_createCCtx_advanced (nbWorkers = %u)", nbWorkers);
-
-    if (nbWorkers < 1) return NULL;
-    nbWorkers = MIN(nbWorkers , ZSTDMT_NBWORKERS_MAX);
-    if ((cMem.customAlloc!=NULL) ^ (cMem.customFree!=NULL))
-        /* invalid custom allocator */
-        return NULL;
-
-    mtctx = (ZSTDMT_CCtx*) ZSTD_customCalloc(sizeof(ZSTDMT_CCtx), cMem);
-    if (!mtctx) return NULL;
-    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);
-    mtctx->cMem = cMem;
-    mtctx->allJobsCompleted = 1;
-    if (pool != NULL) {
-      mtctx->factory = pool;
-      mtctx->providedFactory = 1;
-    }
-    else {
-      mtctx->factory = POOL_create_advanced(nbWorkers, 0, cMem);
-      mtctx->providedFactory = 0;
-    }
-    mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, cMem);
-    assert(nbJobs > 0); assert((nbJobs & (nbJobs - 1)) == 0);  /* ensure nbJobs is a power of 2 */
-    mtctx->jobIDMask = nbJobs - 1;
-    mtctx->bufPool = ZSTDMT_createBufferPool(BUF_POOL_MAX_NB_BUFFERS(nbWorkers), cMem);
-    mtctx->cctxPool = ZSTDMT_createCCtxPool(nbWorkers, cMem);
-    mtctx->seqPool = ZSTDMT_createSeqPool(nbWorkers, cMem);
-    initError = ZSTDMT_serialState_init(&mtctx->serial);
-    mtctx->roundBuff = kNullRoundBuff;
-    if (!mtctx->factory | !mtctx->jobs | !mtctx->bufPool | !mtctx->cctxPool | !mtctx->seqPool | initError) {
-        ZSTDMT_freeCCtx(mtctx);
-        return NULL;
-    }
-    DEBUGLOG(3, "mt_cctx created, for %u threads", nbWorkers);
-    return mtctx;
-}
-
-ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTD_customMem cMem, ZSTD_threadPool* pool)
-{
-#ifdef ZSTD_MULTITHREAD
-    return ZSTDMT_createCCtx_advanced_internal(nbWorkers, cMem, pool);
-#else
-    (void)nbWorkers;
-    (void)cMem;
-    (void)pool;
-    return NULL;
-#endif
-}
-
-
-/* ZSTDMT_releaseAllJobResources() :
- * note : ensure all workers are killed first ! */
-static void ZSTDMT_releaseAllJobResources(ZSTDMT_CCtx* mtctx)
-{
-    unsigned jobID;
-    DEBUGLOG(3, "ZSTDMT_releaseAllJobResources");
-    for (jobID=0; jobID <= mtctx->jobIDMask; jobID++) {
-        /* Copy the mutex/cond out */
-        ZSTD_pthread_mutex_t const mutex = mtctx->jobs[jobID].job_mutex;
-        ZSTD_pthread_cond_t const cond = mtctx->jobs[jobID].job_cond;
-
-        DEBUGLOG(4, "job%02u: release dst address %08X", jobID, (U32)(size_t)mtctx->jobs[jobID].dstBuff.start);
-        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);
-
-        /* Clear the job description, but keep the mutex/cond */
-        ZSTD_memset(&mtctx->jobs[jobID], 0, sizeof(mtctx->jobs[jobID]));
-        mtctx->jobs[jobID].job_mutex = mutex;
-        mtctx->jobs[jobID].job_cond = cond;
-    }
-    mtctx->inBuff.buffer = g_nullBuffer;
-    mtctx->inBuff.filled = 0;
-    mtctx->allJobsCompleted = 1;
-}
-
-static void ZSTDMT_waitForAllJobsCompleted(ZSTDMT_CCtx* mtctx)
-{
-    DEBUGLOG(4, "ZSTDMT_waitForAllJobsCompleted");
-    while (mtctx->doneJobID < mtctx->nextJobID) {
-        unsigned const jobID = mtctx->doneJobID & mtctx->jobIDMask;
-        ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[jobID].job_mutex);
-        while (mtctx->jobs[jobID].consumed < mtctx->jobs[jobID].src.size) {
-            DEBUGLOG(4, "waiting for jobCompleted signal from job %u", mtctx->doneJobID);   /* we want to block when waiting for data to flush */
-            ZSTD_pthread_cond_wait(&mtctx->jobs[jobID].job_cond, &mtctx->jobs[jobID].job_mutex);
-        }
-        ZSTD_pthread_mutex_unlock(&mtctx->jobs[jobID].job_mutex);
-        mtctx->doneJobID++;
-    }
-}
-
-size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx)
-{
-    if (mtctx==NULL) return 0;   /* compatible with free on NULL */
-    if (!mtctx->providedFactory)
-        POOL_free(mtctx->factory);   /* stop and free worker threads */
-    ZSTDMT_releaseAllJobResources(mtctx);  /* release job resources into pools first */
-    ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);
-    ZSTDMT_freeBufferPool(mtctx->bufPool);
-    ZSTDMT_freeCCtxPool(mtctx->cctxPool);
-    ZSTDMT_freeSeqPool(mtctx->seqPool);
-    ZSTDMT_serialState_free(&mtctx->serial);
-    ZSTD_freeCDict(mtctx->cdictLocal);
-    if (mtctx->roundBuff.buffer)
-        ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem);
-    ZSTD_customFree(mtctx, mtctx->cMem);
-    return 0;
-}
-
-size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx)
-{
-    if (mtctx == NULL) return 0;   /* supports sizeof NULL */
-    return sizeof(*mtctx)
-            + POOL_sizeof(mtctx->factory)
-            + ZSTDMT_sizeof_bufferPool(mtctx->bufPool)
-            + (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription)
-            + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool)
-            + ZSTDMT_sizeof_seqPool(mtctx->seqPool)
-            + ZSTD_sizeof_CDict(mtctx->cdictLocal)
-            + mtctx->roundBuff.capacity;
-}
-
-
-/* ZSTDMT_resize() :
- * @return : error code if fails, 0 on success */
-static size_t ZSTDMT_resize(ZSTDMT_CCtx* mtctx, unsigned nbWorkers)
-{
-    if (POOL_resize(mtctx->factory, nbWorkers)) return ERROR(memory_allocation);
-    FORWARD_IF_ERROR( ZSTDMT_expandJobsTable(mtctx, nbWorkers) , "");
-    mtctx->bufPool = ZSTDMT_expandBufferPool(mtctx->bufPool, BUF_POOL_MAX_NB_BUFFERS(nbWorkers));
-    if (mtctx->bufPool == NULL) return ERROR(memory_allocation);
-    mtctx->cctxPool = ZSTDMT_expandCCtxPool(mtctx->cctxPool, nbWorkers);
-    if (mtctx->cctxPool == NULL) return ERROR(memory_allocation);
-    mtctx->seqPool = ZSTDMT_expandSeqPool(mtctx->seqPool, nbWorkers);
-    if (mtctx->seqPool == NULL) return ERROR(memory_allocation);
-    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);
-    return 0;
-}
-
-
-/*! ZSTDMT_updateCParams_whileCompressing() :
- *  Updates a selected set of compression parameters, remaining compatible with currently active frame.
- *  New parameters will be applied to next compression job. */
-void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams)
-{
-    U32 const saved_wlog = mtctx->params.cParams.windowLog;   /* Do not modify windowLog while compressing */
-    int const compressionLevel = cctxParams->compressionLevel;
-    DEBUGLOG(5, "ZSTDMT_updateCParams_whileCompressing (level:%i)",
-                compressionLevel);
-    mtctx->params.compressionLevel = compressionLevel;
-    {   ZSTD_compressionParameters cParams = ZSTD_getCParamsFromCCtxParams(cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
-        cParams.windowLog = saved_wlog;
-        mtctx->params.cParams = cParams;
-    }
-}
-
-/* ZSTDMT_getFrameProgression():
- * tells how much data has been consumed (input) and produced (output) for current frame.
- * able to count progression inside worker threads.
- * Note : mutex will be acquired during statistics collection inside workers. */
-ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx)
-{
-    ZSTD_frameProgression fps;
-    DEBUGLOG(5, "ZSTDMT_getFrameProgression");
-    fps.ingested = mtctx->consumed + mtctx->inBuff.filled;
-    fps.consumed = mtctx->consumed;
-    fps.produced = fps.flushed = mtctx->produced;
-    fps.currentJobID = mtctx->nextJobID;
-    fps.nbActiveWorkers = 0;
-    {   unsigned jobNb;
-        unsigned lastJobNb = mtctx->nextJobID + mtctx->jobReady; assert(mtctx->jobReady <= 1);
-        DEBUGLOG(6, "ZSTDMT_getFrameProgression: jobs: from %u to <%u (jobReady:%u)",
-                    mtctx->doneJobID, lastJobNb, mtctx->jobReady);
-        for (jobNb = mtctx->doneJobID ; jobNb < lastJobNb ; jobNb++) {
-            unsigned const wJobID = jobNb & mtctx->jobIDMask;
-            ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID];
-            ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);
-            {   size_t const cResult = jobPtr->cSize;
-                size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;
-                size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;
-                assert(flushed <= produced);
-                fps.ingested += jobPtr->src.size;
-                fps.consumed += jobPtr->consumed;
-                fps.produced += produced;
-                fps.flushed  += flushed;
-                fps.nbActiveWorkers += (jobPtr->consumed < jobPtr->src.size);
-            }
-            ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
-        }
-    }
-    return fps;
-}
-
-
-size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx)
-{
-    size_t toFlush;
-    unsigned const jobID = mtctx->doneJobID;
-    assert(jobID <= mtctx->nextJobID);
-    if (jobID == mtctx->nextJobID) return 0;   /* no active job => nothing to flush */
-
-    /* look into oldest non-fully-flushed job */
-    {   unsigned const wJobID = jobID & mtctx->jobIDMask;
-        ZSTDMT_jobDescription* const jobPtr = &mtctx->jobs[wJobID];
-        ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);
-        {   size_t const cResult = jobPtr->cSize;
-            size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;
-            size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;
-            assert(flushed <= produced);
-            assert(jobPtr->consumed <= jobPtr->src.size);
-            toFlush = produced - flushed;
-            /* if toFlush==0, nothing is available to flush.
-             * However, jobID is expected to still be active:
-             * if jobID was already completed and fully flushed,
-             * ZSTDMT_flushProduced() should have already moved onto next job.
-             * Therefore, some input has not yet been consumed. */
-            if (toFlush==0) {
-                assert(jobPtr->consumed < jobPtr->src.size);
-            }
-        }
-        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
-    }
-
-    return toFlush;
-}
-
-
-/* ------------------------------------------ */
-/* =====   Multi-threaded compression   ===== */
-/* ------------------------------------------ */
-
-static unsigned ZSTDMT_computeTargetJobLog(const ZSTD_CCtx_params* params)
-{
-    unsigned jobLog;
-    if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-        /* In Long Range Mode, the windowLog is typically oversized.
-         * In which case, it's preferable to determine the jobSize
-         * based on cycleLog instead. */
-        jobLog = MAX(21, ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy) + 3);
-    } else {
-        jobLog = MAX(20, params->cParams.windowLog + 2);
-    }
-    return MIN(jobLog, (unsigned)ZSTDMT_JOBLOG_MAX);
-}
-
-static int ZSTDMT_overlapLog_default(ZSTD_strategy strat)
-{
-    switch(strat)
-    {
-        case ZSTD_btultra2:
-            return 9;
-        case ZSTD_btultra:
-        case ZSTD_btopt:
-            return 8;
-        case ZSTD_btlazy2:
-        case ZSTD_lazy2:
-            return 7;
-        case ZSTD_lazy:
-        case ZSTD_greedy:
-        case ZSTD_dfast:
-        case ZSTD_fast:
-        default:;
-    }
-    return 6;
-}
-
-static int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat)
-{
-    assert(0 <= ovlog && ovlog <= 9);
-    if (ovlog == 0) return ZSTDMT_overlapLog_default(strat);
-    return ovlog;
-}
-
-static size_t ZSTDMT_computeOverlapSize(const ZSTD_CCtx_params* params)
-{
-    int const overlapRLog = 9 - ZSTDMT_overlapLog(params->overlapLog, params->cParams.strategy);
-    int ovLog = (overlapRLog >= 8) ? 0 : (params->cParams.windowLog - overlapRLog);
-    assert(0 <= overlapRLog && overlapRLog <= 8);
-    if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-        /* In Long Range Mode, the windowLog is typically oversized.
-         * In which case, it's preferable to determine the jobSize
-         * based on chainLog instead.
-         * Then, ovLog becomes a fraction of the jobSize, rather than windowSize */
-        ovLog = MIN(params->cParams.windowLog, ZSTDMT_computeTargetJobLog(params) - 2)
-                - overlapRLog;
-    }
-    assert(0 <= ovLog && ovLog <= ZSTD_WINDOWLOG_MAX);
-    DEBUGLOG(4, "overlapLog : %i", params->overlapLog);
-    DEBUGLOG(4, "overlap size : %i", 1 << ovLog);
-    return (ovLog==0) ? 0 : (size_t)1 << ovLog;
-}
-
-/* ====================================== */
-/* =======      Streaming API     ======= */
-/* ====================================== */
-
-size_t ZSTDMT_initCStream_internal(
-        ZSTDMT_CCtx* mtctx,
-        const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,
-        const ZSTD_CDict* cdict, ZSTD_CCtx_params params,
-        unsigned long long pledgedSrcSize)
-{
-    DEBUGLOG(4, "ZSTDMT_initCStream_internal (pledgedSrcSize=%u, nbWorkers=%u, cctxPool=%u)",
-                (U32)pledgedSrcSize, params.nbWorkers, mtctx->cctxPool->totalCCtx);
-
-    /* params supposed partially fully validated at this point */
-    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
-    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
-
-    /* init */
-    if (params.nbWorkers != mtctx->params.nbWorkers)
-        FORWARD_IF_ERROR( ZSTDMT_resize(mtctx, params.nbWorkers) , "");
-
-    if (params.jobSize != 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN;
-    if (params.jobSize > (size_t)ZSTDMT_JOBSIZE_MAX) params.jobSize = (size_t)ZSTDMT_JOBSIZE_MAX;
-
-    DEBUGLOG(4, "ZSTDMT_initCStream_internal: %u workers", params.nbWorkers);
-
-    if (mtctx->allJobsCompleted == 0) {   /* previous compression not correctly finished */
-        ZSTDMT_waitForAllJobsCompleted(mtctx);
-        ZSTDMT_releaseAllJobResources(mtctx);
-        mtctx->allJobsCompleted = 1;
-    }
-
-    mtctx->params = params;
-    mtctx->frameContentSize = pledgedSrcSize;
-    if (dict) {
-        ZSTD_freeCDict(mtctx->cdictLocal);
-        mtctx->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,
-                                                    ZSTD_dlm_byCopy, dictContentType, /* note : a loadPrefix becomes an internal CDict */
-                                                    params.cParams, mtctx->cMem);
-        mtctx->cdict = mtctx->cdictLocal;
-        if (mtctx->cdictLocal == NULL) return ERROR(memory_allocation);
-    } else {
-        ZSTD_freeCDict(mtctx->cdictLocal);
-        mtctx->cdictLocal = NULL;
-        mtctx->cdict = cdict;
-    }
-
-    mtctx->targetPrefixSize = ZSTDMT_computeOverlapSize(&params);
-    DEBUGLOG(4, "overlapLog=%i => %u KB", params.overlapLog, (U32)(mtctx->targetPrefixSize>>10));
-    mtctx->targetSectionSize = params.jobSize;
-    if (mtctx->targetSectionSize == 0) {
-        mtctx->targetSectionSize = 1ULL << ZSTDMT_computeTargetJobLog(&params);
-    }
-    assert(mtctx->targetSectionSize <= (size_t)ZSTDMT_JOBSIZE_MAX);
-
-    if (params.rsyncable) {
-        /* Aim for the targetsectionSize as the average job size. */
-        U32 const jobSizeKB = (U32)(mtctx->targetSectionSize >> 10);
-        U32 const rsyncBits = (assert(jobSizeKB >= 1), ZSTD_highbit32(jobSizeKB) + 10);
-        /* We refuse to create jobs < RSYNC_MIN_BLOCK_SIZE bytes, so make sure our
-         * expected job size is at least 4x larger. */
-        assert(rsyncBits >= RSYNC_MIN_BLOCK_LOG + 2);
-        DEBUGLOG(4, "rsyncLog = %u", rsyncBits);
-        mtctx->rsync.hash = 0;
-        mtctx->rsync.hitMask = (1ULL << rsyncBits) - 1;
-        mtctx->rsync.primePower = ZSTD_rollingHash_primePower(RSYNC_LENGTH);
-    }
-    if (mtctx->targetSectionSize < mtctx->targetPrefixSize) mtctx->targetSectionSize = mtctx->targetPrefixSize;  /* job size must be >= overlap size */
-    DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(mtctx->targetSectionSize>>10), (U32)params.jobSize);
-    DEBUGLOG(4, "inBuff Size : %u KB", (U32)(mtctx->targetSectionSize>>10));
-    ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize));
-    {
-        /* If ldm is enabled we need windowSize space. */
-        size_t const windowSize = mtctx->params.ldmParams.enableLdm == ZSTD_ps_enable ? (1U << mtctx->params.cParams.windowLog) : 0;
-        /* Two buffers of slack, plus extra space for the overlap
-         * This is the minimum slack that LDM works with. One extra because
-         * flush might waste up to targetSectionSize-1 bytes. Another extra
-         * for the overlap (if > 0), then one to fill which doesn't overlap
-         * with the LDM window.
-         */
-        size_t const nbSlackBuffers = 2 + (mtctx->targetPrefixSize > 0);
-        size_t const slackSize = mtctx->targetSectionSize * nbSlackBuffers;
-        /* Compute the total size, and always have enough slack */
-        size_t const nbWorkers = MAX(mtctx->params.nbWorkers, 1);
-        size_t const sectionsSize = mtctx->targetSectionSize * nbWorkers;
-        size_t const capacity = MAX(windowSize, sectionsSize) + slackSize;
-        if (mtctx->roundBuff.capacity < capacity) {
-            if (mtctx->roundBuff.buffer)
-                ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem);
-            mtctx->roundBuff.buffer = (BYTE*)ZSTD_customMalloc(capacity, mtctx->cMem);
-            if (mtctx->roundBuff.buffer == NULL) {
-                mtctx->roundBuff.capacity = 0;
-                return ERROR(memory_allocation);
-            }
-            mtctx->roundBuff.capacity = capacity;
-        }
-    }
-    DEBUGLOG(4, "roundBuff capacity : %u KB", (U32)(mtctx->roundBuff.capacity>>10));
-    mtctx->roundBuff.pos = 0;
-    mtctx->inBuff.buffer = g_nullBuffer;
-    mtctx->inBuff.filled = 0;
-    mtctx->inBuff.prefix = kNullRange;
-    mtctx->doneJobID = 0;
-    mtctx->nextJobID = 0;
-    mtctx->frameEnded = 0;
-    mtctx->allJobsCompleted = 0;
-    mtctx->consumed = 0;
-    mtctx->produced = 0;
-    if (ZSTDMT_serialState_reset(&mtctx->serial, mtctx->seqPool, params, mtctx->targetSectionSize,
-                                 dict, dictSize, dictContentType))
-        return ERROR(memory_allocation);
-    return 0;
-}
-
-
-/* ZSTDMT_writeLastEmptyBlock()
- * Write a single empty block with an end-of-frame to finish a frame.
- * Job must be created from streaming variant.
- * This function is always successful if expected conditions are fulfilled.
- */
-static void ZSTDMT_writeLastEmptyBlock(ZSTDMT_jobDescription* job)
-{
-    assert(job->lastJob == 1);
-    assert(job->src.size == 0);   /* last job is empty -> will be simplified into a last empty block */
-    assert(job->firstJob == 0);   /* cannot be first job, as it also needs to create frame header */
-    assert(job->dstBuff.start == NULL);   /* invoked from streaming variant only (otherwise, dstBuff might be user's output) */
-    job->dstBuff = ZSTDMT_getBuffer(job->bufPool);
-    if (job->dstBuff.start == NULL) {
-      job->cSize = ERROR(memory_allocation);
-      return;
-    }
-    assert(job->dstBuff.capacity >= ZSTD_blockHeaderSize);   /* no buffer should ever be that small */
-    job->src = kNullRange;
-    job->cSize = ZSTD_writeLastEmptyBlock(job->dstBuff.start, job->dstBuff.capacity);
-    assert(!ZSTD_isError(job->cSize));
-    assert(job->consumed == 0);
-}
-
-static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* mtctx, size_t srcSize, ZSTD_EndDirective endOp)
-{
-    unsigned const jobID = mtctx->nextJobID & mtctx->jobIDMask;
-    int const endFrame = (endOp == ZSTD_e_end);
-
-    if (mtctx->nextJobID > mtctx->doneJobID + mtctx->jobIDMask) {
-        DEBUGLOG(5, "ZSTDMT_createCompressionJob: will not create new job : table is full");
-        assert((mtctx->nextJobID & mtctx->jobIDMask) == (mtctx->doneJobID & mtctx->jobIDMask));
-        return 0;
-    }
-
-    if (!mtctx->jobReady) {
-        BYTE const* src = (BYTE const*)mtctx->inBuff.buffer.start;
-        DEBUGLOG(5, "ZSTDMT_createCompressionJob: preparing job %u to compress %u bytes with %u preload ",
-                    mtctx->nextJobID, (U32)srcSize, (U32)mtctx->inBuff.prefix.size);
-        mtctx->jobs[jobID].src.start = src;
-        mtctx->jobs[jobID].src.size = srcSize;
-        assert(mtctx->inBuff.filled >= srcSize);
-        mtctx->jobs[jobID].prefix = mtctx->inBuff.prefix;
-        mtctx->jobs[jobID].consumed = 0;
-        mtctx->jobs[jobID].cSize = 0;
-        mtctx->jobs[jobID].params = mtctx->params;
-        mtctx->jobs[jobID].cdict = mtctx->nextJobID==0 ? mtctx->cdict : NULL;
-        mtctx->jobs[jobID].fullFrameSize = mtctx->frameContentSize;
-        mtctx->jobs[jobID].dstBuff = g_nullBuffer;
-        mtctx->jobs[jobID].cctxPool = mtctx->cctxPool;
-        mtctx->jobs[jobID].bufPool = mtctx->bufPool;
-        mtctx->jobs[jobID].seqPool = mtctx->seqPool;
-        mtctx->jobs[jobID].serial = &mtctx->serial;
-        mtctx->jobs[jobID].jobID = mtctx->nextJobID;
-        mtctx->jobs[jobID].firstJob = (mtctx->nextJobID==0);
-        mtctx->jobs[jobID].lastJob = endFrame;
-        mtctx->jobs[jobID].frameChecksumNeeded = mtctx->params.fParams.checksumFlag && endFrame && (mtctx->nextJobID>0);
-        mtctx->jobs[jobID].dstFlushed = 0;
-
-        /* Update the round buffer pos and clear the input buffer to be reset */
-        mtctx->roundBuff.pos += srcSize;
-        mtctx->inBuff.buffer = g_nullBuffer;
-        mtctx->inBuff.filled = 0;
-        /* Set the prefix */
-        if (!endFrame) {
-            size_t const newPrefixSize = MIN(srcSize, mtctx->targetPrefixSize);
-            mtctx->inBuff.prefix.start = src + srcSize - newPrefixSize;
-            mtctx->inBuff.prefix.size = newPrefixSize;
-        } else {   /* endFrame==1 => no need for another input buffer */
-            mtctx->inBuff.prefix = kNullRange;
-            mtctx->frameEnded = endFrame;
-            if (mtctx->nextJobID == 0) {
-                /* single job exception : checksum is already calculated directly within worker thread */
-                mtctx->params.fParams.checksumFlag = 0;
-        }   }
-
-        if ( (srcSize == 0)
-          && (mtctx->nextJobID>0)/*single job must also write frame header*/ ) {
-            DEBUGLOG(5, "ZSTDMT_createCompressionJob: creating a last empty block to end frame");
-            assert(endOp == ZSTD_e_end);  /* only possible case : need to end the frame with an empty last block */
-            ZSTDMT_writeLastEmptyBlock(mtctx->jobs + jobID);
-            mtctx->nextJobID++;
-            return 0;
-        }
-    }
-
-    DEBUGLOG(5, "ZSTDMT_createCompressionJob: posting job %u : %u bytes  (end:%u, jobNb == %u (mod:%u))",
-                mtctx->nextJobID,
-                (U32)mtctx->jobs[jobID].src.size,
-                mtctx->jobs[jobID].lastJob,
-                mtctx->nextJobID,
-                jobID);
-    if (POOL_tryAdd(mtctx->factory, ZSTDMT_compressionJob, &mtctx->jobs[jobID])) {
-        mtctx->nextJobID++;
-        mtctx->jobReady = 0;
-    } else {
-        DEBUGLOG(5, "ZSTDMT_createCompressionJob: no worker available for job %u", mtctx->nextJobID);
-        mtctx->jobReady = 1;
-    }
-    return 0;
-}
-
-
-/*! ZSTDMT_flushProduced() :
- *  flush whatever data has been produced but not yet flushed in current job.
- *  move to next job if current one is fully flushed.
- * `output` : `pos` will be updated with amount of data flushed .
- * `blockToFlush` : if >0, the function will block and wait if there is no data available to flush .
- * @return : amount of data remaining within internal buffer, 0 if no more, 1 if unknown but > 0, or an error code */
-static size_t ZSTDMT_flushProduced(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, unsigned blockToFlush, ZSTD_EndDirective end)
-{
-    unsigned const wJobID = mtctx->doneJobID & mtctx->jobIDMask;
-    DEBUGLOG(5, "ZSTDMT_flushProduced (blocking:%u , job %u <= %u)",
-                blockToFlush, mtctx->doneJobID, mtctx->nextJobID);
-    assert(output->size >= output->pos);
-
-    ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[wJobID].job_mutex);
-    if (  blockToFlush
-      && (mtctx->doneJobID < mtctx->nextJobID) ) {
-        assert(mtctx->jobs[wJobID].dstFlushed <= mtctx->jobs[wJobID].cSize);
-        while (mtctx->jobs[wJobID].dstFlushed == mtctx->jobs[wJobID].cSize) {  /* nothing to flush */
-            if (mtctx->jobs[wJobID].consumed == mtctx->jobs[wJobID].src.size) {
-                DEBUGLOG(5, "job %u is completely consumed (%u == %u) => don't wait for cond, there will be none",
-                            mtctx->doneJobID, (U32)mtctx->jobs[wJobID].consumed, (U32)mtctx->jobs[wJobID].src.size);
-                break;
-            }
-            DEBUGLOG(5, "waiting for something to flush from job %u (currently flushed: %u bytes)",
-                        mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);
-            ZSTD_pthread_cond_wait(&mtctx->jobs[wJobID].job_cond, &mtctx->jobs[wJobID].job_mutex);  /* block when nothing to flush but some to come */
-    }   }
-
-    /* try to flush something */
-    {   size_t cSize = mtctx->jobs[wJobID].cSize;                  /* shared */
-        size_t const srcConsumed = mtctx->jobs[wJobID].consumed;   /* shared */
-        size_t const srcSize = mtctx->jobs[wJobID].src.size;       /* read-only, could be done after mutex lock, but no-declaration-after-statement */
-        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
-        if (ZSTD_isError(cSize)) {
-            DEBUGLOG(5, "ZSTDMT_flushProduced: job %u : compression error detected : %s",
-                        mtctx->doneJobID, ZSTD_getErrorName(cSize));
-            ZSTDMT_waitForAllJobsCompleted(mtctx);
-            ZSTDMT_releaseAllJobResources(mtctx);
-            return cSize;
-        }
-        /* add frame checksum if necessary (can only happen once) */
-        assert(srcConsumed <= srcSize);
-        if ( (srcConsumed == srcSize)   /* job completed -> worker no longer active */
-          && mtctx->jobs[wJobID].frameChecksumNeeded ) {
-            U32 const checksum = (U32)XXH64_digest(&mtctx->serial.xxhState);
-            DEBUGLOG(4, "ZSTDMT_flushProduced: writing checksum : %08X \n", checksum);
-            MEM_writeLE32((char*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].cSize, checksum);
-            cSize += 4;
-            mtctx->jobs[wJobID].cSize += 4;  /* can write this shared value, as worker is no longer active */
-            mtctx->jobs[wJobID].frameChecksumNeeded = 0;
-        }
-
-        if (cSize > 0) {   /* compression is ongoing or completed */
-            size_t const toFlush = MIN(cSize - mtctx->jobs[wJobID].dstFlushed, output->size - output->pos);
-            DEBUGLOG(5, "ZSTDMT_flushProduced: Flushing %u bytes from job %u (completion:%u/%u, generated:%u)",
-                        (U32)toFlush, mtctx->doneJobID, (U32)srcConsumed, (U32)srcSize, (U32)cSize);
-            assert(mtctx->doneJobID < mtctx->nextJobID);
-            assert(cSize >= mtctx->jobs[wJobID].dstFlushed);
-            assert(mtctx->jobs[wJobID].dstBuff.start != NULL);
-            if (toFlush > 0) {
-                ZSTD_memcpy((char*)output->dst + output->pos,
-                    (const char*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].dstFlushed,
-                    toFlush);
-            }
-            output->pos += toFlush;
-            mtctx->jobs[wJobID].dstFlushed += toFlush;  /* can write : this value is only used by mtctx */
-
-            if ( (srcConsumed == srcSize)    /* job is completed */
-              && (mtctx->jobs[wJobID].dstFlushed == cSize) ) {   /* output buffer fully flushed => free this job position */
-                DEBUGLOG(5, "Job %u completed (%u bytes), moving to next one",
-                        mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);
-                ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[wJobID].dstBuff);
-                DEBUGLOG(5, "dstBuffer released");
-                mtctx->jobs[wJobID].dstBuff = g_nullBuffer;
-                mtctx->jobs[wJobID].cSize = 0;   /* ensure this job slot is considered "not started" in future check */
-                mtctx->consumed += srcSize;
-                mtctx->produced += cSize;
-                mtctx->doneJobID++;
-        }   }
-
-        /* return value : how many bytes left in buffer ; fake it to 1 when unknown but >0 */
-        if (cSize > mtctx->jobs[wJobID].dstFlushed) return (cSize - mtctx->jobs[wJobID].dstFlushed);
-        if (srcSize > srcConsumed) return 1;   /* current job not completely compressed */
-    }
-    if (mtctx->doneJobID < mtctx->nextJobID) return 1;   /* some more jobs ongoing */
-    if (mtctx->jobReady) return 1;      /* one job is ready to push, just not yet in the list */
-    if (mtctx->inBuff.filled > 0) return 1;   /* input is not empty, and still needs to be converted into a job */
-    mtctx->allJobsCompleted = mtctx->frameEnded;   /* all jobs are entirely flushed => if this one is last one, frame is completed */
-    if (end == ZSTD_e_end) return !mtctx->frameEnded;  /* for ZSTD_e_end, question becomes : is frame completed ? instead of : are internal buffers fully flushed ? */
-    return 0;   /* internal buffers fully flushed */
-}
-
-/**
- * Returns the range of data used by the earliest job that is not yet complete.
- * If the data of the first job is broken up into two segments, we cover both
- * sections.
- */
-static range_t ZSTDMT_getInputDataInUse(ZSTDMT_CCtx* mtctx)
-{
-    unsigned const firstJobID = mtctx->doneJobID;
-    unsigned const lastJobID = mtctx->nextJobID;
-    unsigned jobID;
-
-    for (jobID = firstJobID; jobID < lastJobID; ++jobID) {
-        unsigned const wJobID = jobID & mtctx->jobIDMask;
-        size_t consumed;
-
-        ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[wJobID].job_mutex);
-        consumed = mtctx->jobs[wJobID].consumed;
-        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
-
-        if (consumed < mtctx->jobs[wJobID].src.size) {
-            range_t range = mtctx->jobs[wJobID].prefix;
-            if (range.size == 0) {
-                /* Empty prefix */
-                range = mtctx->jobs[wJobID].src;
-            }
-            /* Job source in multiple segments not supported yet */
-            assert(range.start <= mtctx->jobs[wJobID].src.start);
-            return range;
-        }
-    }
-    return kNullRange;
-}
-
-/**
- * Returns non-zero iff buffer and range overlap.
- */
-static int ZSTDMT_isOverlapped(buffer_t buffer, range_t range)
-{
-    BYTE const* const bufferStart = (BYTE const*)buffer.start;
-    BYTE const* const rangeStart = (BYTE const*)range.start;
-
-    if (rangeStart == NULL || bufferStart == NULL)
-        return 0;
-
-    {
-        BYTE const* const bufferEnd = bufferStart + buffer.capacity;
-        BYTE const* const rangeEnd = rangeStart + range.size;
-
-        /* Empty ranges cannot overlap */
-        if (bufferStart == bufferEnd || rangeStart == rangeEnd)
-            return 0;
-
-        return bufferStart < rangeEnd && rangeStart < bufferEnd;
-    }
-}
-
-static int ZSTDMT_doesOverlapWindow(buffer_t buffer, ZSTD_window_t window)
-{
-    range_t extDict;
-    range_t prefix;
-
-    DEBUGLOG(5, "ZSTDMT_doesOverlapWindow");
-    extDict.start = window.dictBase + window.lowLimit;
-    extDict.size = window.dictLimit - window.lowLimit;
-
-    prefix.start = window.base + window.dictLimit;
-    prefix.size = window.nextSrc - (window.base + window.dictLimit);
-    DEBUGLOG(5, "extDict [0x%zx, 0x%zx)",
-                (size_t)extDict.start,
-                (size_t)extDict.start + extDict.size);
-    DEBUGLOG(5, "prefix  [0x%zx, 0x%zx)",
-                (size_t)prefix.start,
-                (size_t)prefix.start + prefix.size);
-
-    return ZSTDMT_isOverlapped(buffer, extDict)
-        || ZSTDMT_isOverlapped(buffer, prefix);
-}
-
-static void ZSTDMT_waitForLdmComplete(ZSTDMT_CCtx* mtctx, buffer_t buffer)
-{
-    if (mtctx->params.ldmParams.enableLdm == ZSTD_ps_enable) {
-        ZSTD_pthread_mutex_t* mutex = &mtctx->serial.ldmWindowMutex;
-        DEBUGLOG(5, "ZSTDMT_waitForLdmComplete");
-        DEBUGLOG(5, "source  [0x%zx, 0x%zx)",
-                    (size_t)buffer.start,
-                    (size_t)buffer.start + buffer.capacity);
-        ZSTD_PTHREAD_MUTEX_LOCK(mutex);
-        while (ZSTDMT_doesOverlapWindow(buffer, mtctx->serial.ldmWindow)) {
-            DEBUGLOG(5, "Waiting for LDM to finish...");
-            ZSTD_pthread_cond_wait(&mtctx->serial.ldmWindowCond, mutex);
-        }
-        DEBUGLOG(6, "Done waiting for LDM to finish");
-        ZSTD_pthread_mutex_unlock(mutex);
-    }
-}
-
-/**
- * Attempts to set the inBuff to the next section to fill.
- * If any part of the new section is still in use we give up.
- * Returns non-zero if the buffer is filled.
- */
-static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)
-{
-    range_t const inUse = ZSTDMT_getInputDataInUse(mtctx);
-    size_t const spaceLeft = mtctx->roundBuff.capacity - mtctx->roundBuff.pos;
-    size_t const target = mtctx->targetSectionSize;
-    buffer_t buffer;
-
-    DEBUGLOG(5, "ZSTDMT_tryGetInputRange");
-    assert(mtctx->inBuff.buffer.start == NULL);
-    assert(mtctx->roundBuff.capacity >= target);
-
-    if (spaceLeft < target) {
-        /* ZSTD_invalidateRepCodes() doesn't work for extDict variants.
-         * Simply copy the prefix to the beginning in that case.
-         */
-        BYTE* const start = (BYTE*)mtctx->roundBuff.buffer;
-        size_t const prefixSize = mtctx->inBuff.prefix.size;
-
-        buffer.start = start;
-        buffer.capacity = prefixSize;
-        if (ZSTDMT_isOverlapped(buffer, inUse)) {
-            DEBUGLOG(5, "Waiting for buffer...");
-            return 0;
-        }
-        ZSTDMT_waitForLdmComplete(mtctx, buffer);
-        ZSTD_memmove(start, mtctx->inBuff.prefix.start, prefixSize);
-        mtctx->inBuff.prefix.start = start;
-        mtctx->roundBuff.pos = prefixSize;
-    }
-    buffer.start = mtctx->roundBuff.buffer + mtctx->roundBuff.pos;
-    buffer.capacity = target;
-
-    if (ZSTDMT_isOverlapped(buffer, inUse)) {
-        DEBUGLOG(5, "Waiting for buffer...");
-        return 0;
-    }
-    assert(!ZSTDMT_isOverlapped(buffer, mtctx->inBuff.prefix));
-
-    ZSTDMT_waitForLdmComplete(mtctx, buffer);
-
-    DEBUGLOG(5, "Using prefix range [%zx, %zx)",
-                (size_t)mtctx->inBuff.prefix.start,
-                (size_t)mtctx->inBuff.prefix.start + mtctx->inBuff.prefix.size);
-    DEBUGLOG(5, "Using source range [%zx, %zx)",
-                (size_t)buffer.start,
-                (size_t)buffer.start + buffer.capacity);
-
-
-    mtctx->inBuff.buffer = buffer;
-    mtctx->inBuff.filled = 0;
-    assert(mtctx->roundBuff.pos + buffer.capacity <= mtctx->roundBuff.capacity);
-    return 1;
-}
-
-typedef struct {
-  size_t toLoad;  /* The number of bytes to load from the input. */
-  int flush;      /* Boolean declaring if we must flush because we found a synchronization point. */
-} syncPoint_t;
-
-/**
- * Searches through the input for a synchronization point. If one is found, we
- * will instruct the caller to flush, and return the number of bytes to load.
- * Otherwise, we will load as many bytes as possible and instruct the caller
- * to continue as normal.
- */
-static syncPoint_t
-findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)
-{
-    BYTE const* const istart = (BYTE const*)input.src + input.pos;
-    U64 const primePower = mtctx->rsync.primePower;
-    U64 const hitMask = mtctx->rsync.hitMask;
-
-    syncPoint_t syncPoint;
-    U64 hash;
-    BYTE const* prev;
-    size_t pos;
-
-    syncPoint.toLoad = MIN(input.size - input.pos, mtctx->targetSectionSize - mtctx->inBuff.filled);
-    syncPoint.flush = 0;
-    if (!mtctx->params.rsyncable)
-        /* Rsync is disabled. */
-        return syncPoint;
-    if (mtctx->inBuff.filled + input.size - input.pos < RSYNC_MIN_BLOCK_SIZE)
-        /* We don't emit synchronization points if it would produce too small blocks.
-         * We don't have enough input to find a synchronization point, so don't look.
-         */
-        return syncPoint;
-    if (mtctx->inBuff.filled + syncPoint.toLoad < RSYNC_LENGTH)
-        /* Not enough to compute the hash.
-         * We will miss any synchronization points in this RSYNC_LENGTH byte
-         * window. However, since it depends only in the internal buffers, if the
-         * state is already synchronized, we will remain synchronized.
-         * Additionally, the probability that we miss a synchronization point is
-         * low: RSYNC_LENGTH / targetSectionSize.
-         */
-        return syncPoint;
-    /* Initialize the loop variables. */
-    if (mtctx->inBuff.filled < RSYNC_MIN_BLOCK_SIZE) {
-        /* We don't need to scan the first RSYNC_MIN_BLOCK_SIZE positions
-         * because they can't possibly be a sync point. So we can start
-         * part way through the input buffer.
-         */
-        pos = RSYNC_MIN_BLOCK_SIZE - mtctx->inBuff.filled;
-        if (pos >= RSYNC_LENGTH) {
-            prev = istart + pos - RSYNC_LENGTH;
-            hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);
-        } else {
-            assert(mtctx->inBuff.filled >= RSYNC_LENGTH);
-            prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;
-            hash = ZSTD_rollingHash_compute(prev + pos, (RSYNC_LENGTH - pos));
-            hash = ZSTD_rollingHash_append(hash, istart, pos);
-        }
-    } else {
-        /* We have enough bytes buffered to initialize the hash,
-         * and have processed enough bytes to find a sync point.
-         * Start scanning at the beginning of the input.
-         */
-        assert(mtctx->inBuff.filled >= RSYNC_MIN_BLOCK_SIZE);
-        assert(RSYNC_MIN_BLOCK_SIZE >= RSYNC_LENGTH);
-        pos = 0;
-        prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;
-        hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);
-        if ((hash & hitMask) == hitMask) {
-            /* We're already at a sync point so don't load any more until
-             * we're able to flush this sync point.
-             * This likely happened because the job table was full so we
-             * couldn't add our job.
-             */
-            syncPoint.toLoad = 0;
-            syncPoint.flush = 1;
-            return syncPoint;
-        }
-    }
-    /* Starting with the hash of the previous RSYNC_LENGTH bytes, roll
-     * through the input. If we hit a synchronization point, then cut the
-     * job off, and tell the compressor to flush the job. Otherwise, load
-     * all the bytes and continue as normal.
-     * If we go too long without a synchronization point (targetSectionSize)
-     * then a block will be emitted anyways, but this is okay, since if we
-     * are already synchronized we will remain synchronized.
-     */
-    assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);
-    for (; pos < syncPoint.toLoad; ++pos) {
-        BYTE const toRemove = pos < RSYNC_LENGTH ? prev[pos] : istart[pos - RSYNC_LENGTH];
-        /* This assert is very expensive, and Debian compiles with asserts enabled.
-         * So disable it for now. We can get similar coverage by checking it at the
-         * beginning & end of the loop.
-         * assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);
-         */
-        hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower);
-        assert(mtctx->inBuff.filled + pos >= RSYNC_MIN_BLOCK_SIZE);
-        if ((hash & hitMask) == hitMask) {
-            syncPoint.toLoad = pos + 1;
-            syncPoint.flush = 1;
-            ++pos; /* for assert */
-            break;
-        }
-    }
-    assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);
-    return syncPoint;
-}
-
-size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx)
-{
-    size_t hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled;
-    if (hintInSize==0) hintInSize = mtctx->targetSectionSize;
-    return hintInSize;
-}
-
-/** ZSTDMT_compressStream_generic() :
- *  internal use only - exposed to be invoked from zstd_compress.c
- *  assumption : output and input are valid (pos <= size)
- * @return : minimum amount of data remaining to flush, 0 if none */
-size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
-                                     ZSTD_outBuffer* output,
-                                     ZSTD_inBuffer* input,
-                                     ZSTD_EndDirective endOp)
-{
-    unsigned forwardInputProgress = 0;
-    DEBUGLOG(5, "ZSTDMT_compressStream_generic (endOp=%u, srcSize=%u)",
-                (U32)endOp, (U32)(input->size - input->pos));
-    assert(output->pos <= output->size);
-    assert(input->pos  <= input->size);
-
-    if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {
-        /* current frame being ended. Only flush/end are allowed */
-        return ERROR(stage_wrong);
-    }
-
-    /* fill input buffer */
-    if ( (!mtctx->jobReady)
-      && (input->size > input->pos) ) {   /* support NULL input */
-        if (mtctx->inBuff.buffer.start == NULL) {
-            assert(mtctx->inBuff.filled == 0); /* Can't fill an empty buffer */
-            if (!ZSTDMT_tryGetInputRange(mtctx)) {
-                /* It is only possible for this operation to fail if there are
-                 * still compression jobs ongoing.
-                 */
-                DEBUGLOG(5, "ZSTDMT_tryGetInputRange failed");
-                assert(mtctx->doneJobID != mtctx->nextJobID);
-            } else
-                DEBUGLOG(5, "ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p", mtctx->inBuff.buffer.start);
-        }
-        if (mtctx->inBuff.buffer.start != NULL) {
-            syncPoint_t const syncPoint = findSynchronizationPoint(mtctx, *input);
-            if (syncPoint.flush && endOp == ZSTD_e_continue) {
-                endOp = ZSTD_e_flush;
-            }
-            assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize);
-            DEBUGLOG(5, "ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u",
-                        (U32)syncPoint.toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize);
-            ZSTD_memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, syncPoint.toLoad);
-            input->pos += syncPoint.toLoad;
-            mtctx->inBuff.filled += syncPoint.toLoad;
-            forwardInputProgress = syncPoint.toLoad>0;
-        }
-    }
-    if ((input->pos < input->size) && (endOp == ZSTD_e_end)) {
-        /* Can't end yet because the input is not fully consumed.
-            * We are in one of these cases:
-            * - mtctx->inBuff is NULL & empty: we couldn't get an input buffer so don't create a new job.
-            * - We filled the input buffer: flush this job but don't end the frame.
-            * - We hit a synchronization point: flush this job but don't end the frame.
-            */
-        assert(mtctx->inBuff.filled == 0 || mtctx->inBuff.filled == mtctx->targetSectionSize || mtctx->params.rsyncable);
-        endOp = ZSTD_e_flush;
-    }
-
-    if ( (mtctx->jobReady)
-      || (mtctx->inBuff.filled >= mtctx->targetSectionSize)  /* filled enough : let's compress */
-      || ((endOp != ZSTD_e_continue) && (mtctx->inBuff.filled > 0))  /* something to flush : let's go */
-      || ((endOp == ZSTD_e_end) && (!mtctx->frameEnded)) ) {   /* must finish the frame with a zero-size block */
-        size_t const jobSize = mtctx->inBuff.filled;
-        assert(mtctx->inBuff.filled <= mtctx->targetSectionSize);
-        FORWARD_IF_ERROR( ZSTDMT_createCompressionJob(mtctx, jobSize, endOp) , "");
-    }
-
-    /* check for potential compressed data ready to be flushed */
-    {   size_t const remainingToFlush = ZSTDMT_flushProduced(mtctx, output, !forwardInputProgress, endOp); /* block if there was no forward input progress */
-        if (input->pos < input->size) return MAX(remainingToFlush, 1);  /* input not consumed : do not end flush yet */
-        DEBUGLOG(5, "end of ZSTDMT_compressStream_generic: remainingToFlush = %u", (U32)remainingToFlush);
-        return remainingToFlush;
-    }
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/decompress/huf_decompress.cpp b/src/duckdb/third_party/zstd/decompress/huf_decompress.cpp
deleted file mode 100644
index 736e2f06d..000000000
--- a/src/duckdb/third_party/zstd/decompress/huf_decompress.cpp
+++ /dev/null
@@ -1,1912 +0,0 @@
-/* ******************************************************************
- * huff0 huffman decoder,
- * part of Finite State Entropy library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* **************************************************************
-*  Dependencies
-****************************************************************/
-#include "zstd/common/zstd_deps.h"  /* ZSTD_memcpy, ZSTD_memset */
-#include "zstd/common/compiler.h"
-#include "zstd/common/bitstream.h"  /* BIT_* */
-#include "zstd/common/fse.h"        /* to compress headers */
-#include "zstd/common/huf.h"
-#include "zstd/common/error_private.h"
-#include "zstd/common/zstd_internal.h"
-#include "zstd/common/bits.h"       /* ZSTD_highbit32, ZSTD_countTrailingZeros64 */
-
-/* **************************************************************
-*  Constants
-****************************************************************/
-
-#define HUF_DECODER_FAST_TABLELOG 11
-
-/* **************************************************************
-*  Macros
-****************************************************************/
-
-#ifdef HUF_DISABLE_FAST_DECODE
-# define HUF_ENABLE_FAST_DECODE 0
-#else
-# define HUF_ENABLE_FAST_DECODE 1
-#endif
-
-/* These two optional macros force the use one way or another of the two
- * Huffman decompression implementations. You can't force in both directions
- * at the same time.
- */
-#if defined(HUF_FORCE_DECOMPRESS_X1) && \
-    defined(HUF_FORCE_DECOMPRESS_X2)
-#error "Cannot force the use of the X1 and X2 decoders at the same time!"
-#endif
-
-/* When DYNAMIC_BMI2 is enabled, fast decoders are only called when bmi2 is
- * supported at runtime, so we can add the BMI2 target attribute.
- * When it is disabled, we will still get BMI2 if it is enabled statically.
- */
-#if DYNAMIC_BMI2
-# define HUF_FAST_BMI2_ATTRS BMI2_TARGET_ATTRIBUTE
-#else
-# define HUF_FAST_BMI2_ATTRS
-#endif
-
-#ifdef __cplusplus
-# define HUF_EXTERN_C extern "C"
-#else
-# define HUF_EXTERN_C
-#endif
-#define HUF_ASM_DECL HUF_EXTERN_C
-
-#if DYNAMIC_BMI2
-# define HUF_NEED_BMI2_FUNCTION 1
-#else
-# define HUF_NEED_BMI2_FUNCTION 0
-#endif
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define HUF_isError ERR_isError
-
-
-/* **************************************************************
-*  Byte alignment for workSpace management
-****************************************************************/
-#define HUF_ALIGN(x, a)         HUF_ALIGN_MASK((x), (a) - 1)
-#define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
-
-namespace duckdb_zstd {
-
-/* **************************************************************
-*  BMI2 Variant Wrappers
-****************************************************************/
-typedef size_t (*HUF_DecompressUsingDTableFn)(void *dst, size_t dstSize,
-                                              const void *cSrc,
-                                              size_t cSrcSize,
-                                              const HUF_DTable *DTable);
-
-#if DYNAMIC_BMI2
-
-#define HUF_DGEN(fn)                                                        \
-                                                                            \
-    static size_t fn##_default(                                             \
-                  void* dst,  size_t dstSize,                               \
-            const void* cSrc, size_t cSrcSize,                              \
-            const HUF_DTable* DTable)                                       \
-    {                                                                       \
-        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
-    }                                                                       \
-                                                                            \
-    static BMI2_TARGET_ATTRIBUTE size_t fn##_bmi2(                          \
-                  void* dst,  size_t dstSize,                               \
-            const void* cSrc, size_t cSrcSize,                              \
-            const HUF_DTable* DTable)                                       \
-    {                                                                       \
-        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
-    }                                                                       \
-                                                                            \
-    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
-                     size_t cSrcSize, HUF_DTable const* DTable, int flags)  \
-    {                                                                       \
-        if (flags & HUF_flags_bmi2) {                                       \
-            return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);         \
-        }                                                                   \
-        return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable);          \
-    }
-
-#else
-
-#define HUF_DGEN(fn)                                                        \
-    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
-                     size_t cSrcSize, HUF_DTable const* DTable, int flags)  \
-    {                                                                       \
-        (void)flags;                                                        \
-        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
-    }
-
-#endif
-
-
-/*-***************************/
-/*  generic DTableDesc       */
-/*-***************************/
-typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
-
-static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
-{
-    DTableDesc dtd;
-    ZSTD_memcpy(&dtd, table, sizeof(dtd));
-    return dtd;
-}
-
-static size_t HUF_initFastDStream(BYTE const* ip) {
-    BYTE const lastByte = ip[7];
-    size_t const bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
-    size_t const value = MEM_readLEST(ip) | 1;
-    assert(bitsConsumed <= 8);
-    assert(sizeof(size_t) == 8);
-    return value << bitsConsumed;
-}
-
-
-/**
- * The input/output arguments to the Huffman fast decoding loop:
- *
- * ip [in/out] - The input pointers, must be updated to reflect what is consumed.
- * op [in/out] - The output pointers, must be updated to reflect what is written.
- * bits [in/out] - The bitstream containers, must be updated to reflect the current state.
- * dt [in] - The decoding table.
- * ilowest [in] - The beginning of the valid range of the input. Decoders may read
- *                down to this pointer. It may be below iend[0].
- * oend [in] - The end of the output stream. op[3] must not cross oend.
- * iend [in] - The end of each input stream. ip[i] may cross iend[i],
- *             as long as it is above ilowest, but that indicates corruption.
- */
-typedef struct {
-    BYTE const* ip[4];
-    BYTE* op[4];
-    U64 bits[4];
-    void const* dt;
-    BYTE const* ilowest;
-    BYTE* oend;
-    BYTE const* iend[4];
-} HUF_DecompressFastArgs;
-
-typedef void (*HUF_DecompressFastLoopFn)(HUF_DecompressFastArgs*);
-
-/**
- * Initializes args for the fast decoding loop.
- * @returns 1 on success
- *          0 if the fallback implementation should be used.
- *          Or an error code on failure.
- */
-static size_t HUF_DecompressFastArgs_init(HUF_DecompressFastArgs* args, void* dst, size_t dstSize, void const* src, size_t srcSize, const HUF_DTable* DTable)
-{
-    void const* dt = DTable + 1;
-    U32 const dtLog = HUF_getDTableDesc(DTable).tableLog;
-
-    const BYTE* const istart = (const BYTE*)src;
-
-    BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);
-
-    /* The fast decoding loop assumes 64-bit little-endian.
-     * This condition is false on x32.
-     */
-    if (!MEM_isLittleEndian() || MEM_32bits())
-        return 0;
-
-    /* Avoid nullptr addition */
-    if (dstSize == 0)
-        return 0;
-    assert(dst != NULL);
-
-    /* strict minimum : jump table + 1 byte per stream */
-    if (srcSize < 10)
-        return ERROR(corruption_detected);
-
-    /* Must have at least 8 bytes per stream because we don't handle initializing smaller bit containers.
-     * If table log is not correct at this point, fallback to the old decoder.
-     * On small inputs we don't have enough data to trigger the fast loop, so use the old decoder.
-     */
-    if (dtLog != HUF_DECODER_FAST_TABLELOG)
-        return 0;
-
-    /* Read the jump table. */
-    {
-        size_t const length1 = MEM_readLE16(istart);
-        size_t const length2 = MEM_readLE16(istart+2);
-        size_t const length3 = MEM_readLE16(istart+4);
-        size_t const length4 = srcSize - (length1 + length2 + length3 + 6);
-        args->iend[0] = istart + 6;  /* jumpTable */
-        args->iend[1] = args->iend[0] + length1;
-        args->iend[2] = args->iend[1] + length2;
-        args->iend[3] = args->iend[2] + length3;
-
-        /* HUF_initFastDStream() requires this, and this small of an input
-         * won't benefit from the ASM loop anyways.
-         */
-        if (length1 < 8 || length2 < 8 || length3 < 8 || length4 < 8)
-            return 0;
-        if (length4 > srcSize) return ERROR(corruption_detected);   /* overflow */
-    }
-    /* ip[] contains the position that is currently loaded into bits[]. */
-    args->ip[0] = args->iend[1] - sizeof(U64);
-    args->ip[1] = args->iend[2] - sizeof(U64);
-    args->ip[2] = args->iend[3] - sizeof(U64);
-    args->ip[3] = (BYTE const*)src + srcSize - sizeof(U64);
-
-    /* op[] contains the output pointers. */
-    args->op[0] = (BYTE*)dst;
-    args->op[1] = args->op[0] + (dstSize+3)/4;
-    args->op[2] = args->op[1] + (dstSize+3)/4;
-    args->op[3] = args->op[2] + (dstSize+3)/4;
-
-    /* No point to call the ASM loop for tiny outputs. */
-    if (args->op[3] >= oend)
-        return 0;
-
-    /* bits[] is the bit container.
-        * It is read from the MSB down to the LSB.
-        * It is shifted left as it is read, and zeros are
-        * shifted in. After the lowest valid bit a 1 is
-        * set, so that CountTrailingZeros(bits[]) can be used
-        * to count how many bits we've consumed.
-        */
-    args->bits[0] = HUF_initFastDStream(args->ip[0]);
-    args->bits[1] = HUF_initFastDStream(args->ip[1]);
-    args->bits[2] = HUF_initFastDStream(args->ip[2]);
-    args->bits[3] = HUF_initFastDStream(args->ip[3]);
-
-    /* The decoders must be sure to never read beyond ilowest.
-     * This is lower than iend[0], but allowing decoders to read
-     * down to ilowest can allow an extra iteration or two in the
-     * fast loop.
-     */
-    args->ilowest = istart;
-
-    args->oend = oend;
-    args->dt = dt;
-
-    return 1;
-}
-
-static size_t HUF_initRemainingDStream(BIT_DStream_t* bit, HUF_DecompressFastArgs const* args, int stream, BYTE* segmentEnd)
-{
-    /* Validate that we haven't overwritten. */
-    if (args->op[stream] > segmentEnd)
-        return ERROR(corruption_detected);
-    /* Validate that we haven't read beyond iend[].
-        * Note that ip[] may be < iend[] because the MSB is
-        * the next bit to read, and we may have consumed 100%
-        * of the stream, so down to iend[i] - 8 is valid.
-        */
-    if (args->ip[stream] < args->iend[stream] - 8)
-        return ERROR(corruption_detected);
-
-    /* Construct the BIT_DStream_t. */
-    assert(sizeof(size_t) == 8);
-    bit->bitContainer = MEM_readLEST(args->ip[stream]);
-    bit->bitsConsumed = ZSTD_countTrailingZeros64(args->bits[stream]);
-    bit->start = (const char*)args->ilowest;
-    bit->limitPtr = bit->start + sizeof(size_t);
-    bit->ptr = (const char*)args->ip[stream];
-
-    return 0;
-}
-
-/* Calls X(N) for each stream 0, 1, 2, 3. */
-#define HUF_4X_FOR_EACH_STREAM(X) \
-    do {                          \
-        X(0);                     \
-        X(1);                     \
-        X(2);                     \
-        X(3);                     \
-    } while (0)
-
-/* Calls X(N, var) for each stream 0, 1, 2, 3. */
-#define HUF_4X_FOR_EACH_STREAM_WITH_VAR(X, var) \
-    do {                                        \
-        X(0, (var));                            \
-        X(1, (var));                            \
-        X(2, (var));                            \
-        X(3, (var));                            \
-    } while (0)
-
-
-#ifndef HUF_FORCE_DECOMPRESS_X2
-
-/*-***************************/
-/*  single-symbol decoding   */
-/*-***************************/
-typedef struct { BYTE nbBits; BYTE byte; } HUF_DEltX1;   /* single-symbol decoding */
-
-/**
- * Packs 4 HUF_DEltX1 structs into a U64. This is used to lay down 4 entries at
- * a time.
- */
-static U64 HUF_DEltX1_set4(BYTE symbol, BYTE nbBits) {
-    U64 D4;
-    if (MEM_isLittleEndian()) {
-        D4 = (U64)((symbol << 8) + nbBits);
-    } else {
-        D4 = (U64)(symbol + (nbBits << 8));
-    }
-    assert(D4 < (1U << 16));
-    D4 *= 0x0001000100010001ULL;
-    return D4;
-}
-
-/**
- * Increase the tableLog to targetTableLog and rescales the stats.
- * If tableLog > targetTableLog this is a no-op.
- * @returns New tableLog
- */
-static U32 HUF_rescaleStats(BYTE* huffWeight, U32* rankVal, U32 nbSymbols, U32 tableLog, U32 targetTableLog)
-{
-    if (tableLog > targetTableLog)
-        return tableLog;
-    if (tableLog < targetTableLog) {
-        U32 const scale = targetTableLog - tableLog;
-        U32 s;
-        /* Increase the weight for all non-zero probability symbols by scale. */
-        for (s = 0; s < nbSymbols; ++s) {
-            huffWeight[s] += (BYTE)((huffWeight[s] == 0) ? 0 : scale);
-        }
-        /* Update rankVal to reflect the new weights.
-         * All weights except 0 get moved to weight + scale.
-         * Weights [1, scale] are empty.
-         */
-        for (s = targetTableLog; s > scale; --s) {
-            rankVal[s] = rankVal[s - scale];
-        }
-        for (s = scale; s > 0; --s) {
-            rankVal[s] = 0;
-        }
-    }
-    return targetTableLog;
-}
-
-typedef struct {
-        U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];
-        U32 rankStart[HUF_TABLELOG_ABSOLUTEMAX + 1];
-        U32 statsWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
-        BYTE symbols[HUF_SYMBOLVALUE_MAX + 1];
-        BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];
-} HUF_ReadDTableX1_Workspace;
-
-size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int flags)
-{
-    U32 tableLog = 0;
-    U32 nbSymbols = 0;
-    size_t iSize;
-    void* const dtPtr = DTable + 1;
-    HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
-    HUF_ReadDTableX1_Workspace* wksp = (HUF_ReadDTableX1_Workspace*)workSpace;
-
-    DEBUG_STATIC_ASSERT(HUF_DECOMPRESS_WORKSPACE_SIZE >= sizeof(*wksp));
-    if (sizeof(*wksp) > wkspSize) return ERROR(tableLog_tooLarge);
-
-    DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
-    /* ZSTD_memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), flags);
-    if (HUF_isError(iSize)) return iSize;
-
-
-    /* Table header */
-    {   DTableDesc dtd = HUF_getDTableDesc(DTable);
-        U32 const maxTableLog = dtd.maxTableLog + 1;
-        U32 const targetTableLog = MIN(maxTableLog, HUF_DECODER_FAST_TABLELOG);
-        tableLog = HUF_rescaleStats(wksp->huffWeight, wksp->rankVal, nbSymbols, tableLog, targetTableLog);
-        if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */
-        dtd.tableType = 0;
-        dtd.tableLog = (BYTE)tableLog;
-        ZSTD_memcpy(DTable, &dtd, sizeof(dtd));
-    }
-
-    /* Compute symbols and rankStart given rankVal:
-     *
-     * rankVal already contains the number of values of each weight.
-     *
-     * symbols contains the symbols ordered by weight. First are the rankVal[0]
-     * weight 0 symbols, followed by the rankVal[1] weight 1 symbols, and so on.
-     * symbols[0] is filled (but unused) to avoid a branch.
-     *
-     * rankStart contains the offset where each rank belongs in the DTable.
-     * rankStart[0] is not filled because there are no entries in the table for
-     * weight 0.
-     */
-    {   int n;
-        U32 nextRankStart = 0;
-        int const unroll = 4;
-        int const nLimit = (int)nbSymbols - unroll + 1;
-        for (n=0; n<(int)tableLog+1; n++) {
-            U32 const curr = nextRankStart;
-            nextRankStart += wksp->rankVal[n];
-            wksp->rankStart[n] = curr;
-        }
-        for (n=0; n < nLimit; n += unroll) {
-            int u;
-            for (u=0; u < unroll; ++u) {
-                size_t const w = wksp->huffWeight[n+u];
-                wksp->symbols[wksp->rankStart[w]++] = (BYTE)(n+u);
-            }
-        }
-        for (; n < (int)nbSymbols; ++n) {
-            size_t const w = wksp->huffWeight[n];
-            wksp->symbols[wksp->rankStart[w]++] = (BYTE)n;
-        }
-    }
-
-    /* fill DTable
-     * We fill all entries of each weight in order.
-     * That way length is a constant for each iteration of the outer loop.
-     * We can switch based on the length to a different inner loop which is
-     * optimized for that particular case.
-     */
-    {   U32 w;
-        int symbol = wksp->rankVal[0];
-        int rankStart = 0;
-        for (w=1; w<tableLog+1; ++w) {
-            int const symbolCount = wksp->rankVal[w];
-            int const length = (1 << w) >> 1;
-            int uStart = rankStart;
-            BYTE const nbBits = (BYTE)(tableLog + 1 - w);
-            int s;
-            int u;
-            switch (length) {
-            case 1:
-                for (s=0; s<symbolCount; ++s) {
-                    HUF_DEltX1 D;
-                    D.byte = wksp->symbols[symbol + s];
-                    D.nbBits = nbBits;
-                    dt[uStart] = D;
-                    uStart += 1;
-                }
-                break;
-            case 2:
-                for (s=0; s<symbolCount; ++s) {
-                    HUF_DEltX1 D;
-                    D.byte = wksp->symbols[symbol + s];
-                    D.nbBits = nbBits;
-                    dt[uStart+0] = D;
-                    dt[uStart+1] = D;
-                    uStart += 2;
-                }
-                break;
-            case 4:
-                for (s=0; s<symbolCount; ++s) {
-                    U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits);
-                    MEM_write64(dt + uStart, D4);
-                    uStart += 4;
-                }
-                break;
-            case 8:
-                for (s=0; s<symbolCount; ++s) {
-                    U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits);
-                    MEM_write64(dt + uStart, D4);
-                    MEM_write64(dt + uStart + 4, D4);
-                    uStart += 8;
-                }
-                break;
-            default:
-                for (s=0; s<symbolCount; ++s) {
-                    U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits);
-                    for (u=0; u < length; u += 16) {
-                        MEM_write64(dt + uStart + u + 0, D4);
-                        MEM_write64(dt + uStart + u + 4, D4);
-                        MEM_write64(dt + uStart + u + 8, D4);
-                        MEM_write64(dt + uStart + u + 12, D4);
-                    }
-                    assert(u == length);
-                    uStart += length;
-                }
-                break;
-            }
-            symbol += symbolCount;
-            rankStart += symbolCount * length;
-        }
-    }
-    return iSize;
-}
-
-FORCE_INLINE_TEMPLATE BYTE
-HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
-{
-    size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-    BYTE const c = dt[val].byte;
-    BIT_skipBits(Dstream, dt[val].nbBits);
-    return c;
-}
-
-#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
-    do { *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog); } while (0)
-
-#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)      \
-    do {                                            \
-        if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
-            HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr); \
-    } while (0)
-
-#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr)      \
-    do {                                            \
-        if (MEM_64bits())                           \
-            HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr); \
-    } while (0)
-
-HINT_INLINE size_t
-HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    if ((pEnd - p) > 3) {
-        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
-            HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
-            HUF_DECODE_SYMBOLX1_1(p, bitDPtr);
-            HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
-            HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
-        }
-    } else {
-        BIT_reloadDStream(bitDPtr);
-    }
-
-    /* [0-3] symbols remaining */
-    if (MEM_32bits())
-        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
-            HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, no need to reload */
-    while (p < pEnd)
-        HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
-
-    return (size_t)(pEnd-pStart);
-}
-
-FORCE_INLINE_TEMPLATE size_t
-HUF_decompress1X1_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = ZSTD_maybeNullPtrAdd(op, dstSize);
-    const void* dtPtr = DTable + 1;
-    const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
-    BIT_DStream_t bitD;
-    DTableDesc const dtd = HUF_getDTableDesc(DTable);
-    U32 const dtLog = dtd.tableLog;
-
-    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
-
-    HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
-
-    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    return dstSize;
-}
-
-/* HUF_decompress4X1_usingDTable_internal_body():
- * Conditions :
- * @dstSize >= 6
- */
-FORCE_INLINE_TEMPLATE size_t
-HUF_decompress4X1_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    /* Check */
-    if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */
-    if (dstSize < 6) return ERROR(corruption_detected);         /* stream 4-split doesn't work */
-
-    {   const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        BYTE* const olimit = oend - 3;
-        const void* const dtPtr = DTable + 1;
-        const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        size_t const length1 = MEM_readLE16(istart);
-        size_t const length2 = MEM_readLE16(istart+2);
-        size_t const length3 = MEM_readLE16(istart+4);
-        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        DTableDesc const dtd = HUF_getDTableDesc(DTable);
-        U32 const dtLog = dtd.tableLog;
-        U32 endSignal = 1;
-
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        if (opStart4 > oend) return ERROR(corruption_detected);      /* overflow */
-        assert(dstSize >= 6); /* validated above */
-        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
-        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
-        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
-        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
-
-        /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */
-        if ((size_t)(oend - op4) >= sizeof(size_t)) {
-            for ( ; (endSignal) & (op4 < olimit) ; ) {
-                HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
-                HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
-                HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
-                HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
-                HUF_DECODE_SYMBOLX1_1(op1, &bitD1);
-                HUF_DECODE_SYMBOLX1_1(op2, &bitD2);
-                HUF_DECODE_SYMBOLX1_1(op3, &bitD3);
-                HUF_DECODE_SYMBOLX1_1(op4, &bitD4);
-                HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
-                HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
-                HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
-                HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
-                HUF_DECODE_SYMBOLX1_0(op1, &bitD1);
-                HUF_DECODE_SYMBOLX1_0(op2, &bitD2);
-                HUF_DECODE_SYMBOLX1_0(op3, &bitD3);
-                HUF_DECODE_SYMBOLX1_0(op4, &bitD4);
-                endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
-                endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
-                endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
-                endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
-            }
-        }
-
-        /* check corruption */
-        /* note : should not be necessary : op# advance in lock step, and we control op4.
-         *        but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-          if (!endCheck) return ERROR(corruption_detected); }
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-#if HUF_NEED_BMI2_FUNCTION
-static BMI2_TARGET_ATTRIBUTE
-size_t HUF_decompress4X1_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,
-                    size_t cSrcSize, HUF_DTable const* DTable) {
-    return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-#endif
-
-static
-size_t HUF_decompress4X1_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,
-                    size_t cSrcSize, HUF_DTable const* DTable) {
-    return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-static HUF_FAST_BMI2_ATTRS
-void HUF_decompress4X1_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs* args)
-{
-    U64 bits[4];
-    BYTE const* ip[4];
-    BYTE* op[4];
-    U16 const* const dtable = (U16 const*)args->dt;
-    BYTE* const oend = args->oend;
-    BYTE const* const ilowest = args->ilowest;
-
-    /* Copy the arguments to local variables */
-    ZSTD_memcpy(&bits, &args->bits, sizeof(bits));
-    ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip));
-    ZSTD_memcpy(&op, &args->op, sizeof(op));
-
-    assert(MEM_isLittleEndian());
-    assert(!MEM_32bits());
-
-    for (;;) {
-        BYTE* olimit;
-        int stream;
-
-        /* Assert loop preconditions */
-#ifndef NDEBUG
-        for (stream = 0; stream < 4; ++stream) {
-            assert(op[stream] <= (stream == 3 ? oend : op[stream + 1]));
-            assert(ip[stream] >= ilowest);
-        }
-#endif
-        /* Compute olimit */
-        {
-            /* Each iteration produces 5 output symbols per stream */
-            size_t const oiters = (size_t)(oend - op[3]) / 5;
-            /* Each iteration consumes up to 11 bits * 5 = 55 bits < 7 bytes
-             * per stream.
-             */
-            size_t const iiters = (size_t)(ip[0] - ilowest) / 7;
-            /* We can safely run iters iterations before running bounds checks */
-            size_t const iters = MIN(oiters, iiters);
-            size_t const symbols = iters * 5;
-
-            /* We can simply check that op[3] < olimit, instead of checking all
-             * of our bounds, since we can't hit the other bounds until we've run
-             * iters iterations, which only happens when op[3] == olimit.
-             */
-            olimit = op[3] + symbols;
-
-            /* Exit fast decoding loop once we reach the end. */
-            if (op[3] == olimit)
-                break;
-
-            /* Exit the decoding loop if any input pointer has crossed the
-             * previous one. This indicates corruption, and a precondition
-             * to our loop is that ip[i] >= ip[0].
-             */
-            for (stream = 1; stream < 4; ++stream) {
-                if (ip[stream] < ip[stream - 1])
-                    goto _out;
-            }
-        }
-
-#ifndef NDEBUG
-        for (stream = 1; stream < 4; ++stream) {
-            assert(ip[stream] >= ip[stream - 1]);
-        }
-#endif
-
-#define HUF_4X1_DECODE_SYMBOL(_stream, _symbol)                 \
-    do {                                                        \
-        int const index = (int)(bits[(_stream)] >> 53);         \
-        int const entry = (int)dtable[index];                   \
-        bits[(_stream)] <<= (entry & 0x3F);                     \
-        op[(_stream)][(_symbol)] = (BYTE)((entry >> 8) & 0xFF); \
-    } while (0)
-
-#define HUF_4X1_RELOAD_STREAM(_stream)                              \
-    do {                                                            \
-        int const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \
-        int const nbBits = ctz & 7;                                 \
-        int const nbBytes = ctz >> 3;                               \
-        op[(_stream)] += 5;                                         \
-        ip[(_stream)] -= nbBytes;                                   \
-        bits[(_stream)] = MEM_read64(ip[(_stream)]) | 1;            \
-        bits[(_stream)] <<= nbBits;                                 \
-    } while (0)
-
-        /* Manually unroll the loop because compilers don't consistently
-         * unroll the inner loops, which destroys performance.
-         */
-        do {
-            /* Decode 5 symbols in each of the 4 streams */
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 0);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 1);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 2);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 3);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 4);
-
-            /* Reload each of the 4 the bitstreams */
-            HUF_4X_FOR_EACH_STREAM(HUF_4X1_RELOAD_STREAM);
-        } while (op[3] < olimit);
-
-#undef HUF_4X1_DECODE_SYMBOL
-#undef HUF_4X1_RELOAD_STREAM
-    }
-
-_out:
-
-    /* Save the final values of each of the state variables back to args. */
-    ZSTD_memcpy(&args->bits, &bits, sizeof(bits));
-    ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip));
-    ZSTD_memcpy(&args->op, &op, sizeof(op));
-}
-
-/**
- * @returns @p dstSize on success (>= 6)
- *          0 if the fallback implementation should be used
- *          An error if an error occurred
- */
-static HUF_FAST_BMI2_ATTRS
-size_t
-HUF_decompress4X1_usingDTable_internal_fast(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable,
-    HUF_DecompressFastLoopFn loopFn)
-{
-    void const* dt = DTable + 1;
-    BYTE const* const ilowest = (BYTE const*)cSrc;
-    BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);
-    HUF_DecompressFastArgs args;
-    {   size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);
-        FORWARD_IF_ERROR(ret, "Failed to init fast loop args");
-        if (ret == 0)
-            return 0;
-    }
-
-    assert(args.ip[0] >= args.ilowest);
-    loopFn(&args);
-
-    /* Our loop guarantees that ip[] >= ilowest and that we haven't
-    * overwritten any op[].
-    */
-    assert(args.ip[0] >= ilowest);
-    assert(args.ip[0] >= ilowest);
-    assert(args.ip[1] >= ilowest);
-    assert(args.ip[2] >= ilowest);
-    assert(args.ip[3] >= ilowest);
-    assert(args.op[3] <= oend);
-
-    assert(ilowest == args.ilowest);
-    assert(ilowest + 6 == args.iend[0]);
-    (void)ilowest;
-
-    /* finish bit streams one by one. */
-    {   size_t const segmentSize = (dstSize+3) / 4;
-        BYTE* segmentEnd = (BYTE*)dst;
-        int i;
-        for (i = 0; i < 4; ++i) {
-            BIT_DStream_t bit;
-            if (segmentSize <= (size_t)(oend - segmentEnd))
-                segmentEnd += segmentSize;
-            else
-                segmentEnd = oend;
-            FORWARD_IF_ERROR(HUF_initRemainingDStream(&bit, &args, i, segmentEnd), "corruption");
-            /* Decompress and validate that we've produced exactly the expected length. */
-            args.op[i] += HUF_decodeStreamX1(args.op[i], &bit, segmentEnd, (HUF_DEltX1 const*)dt, HUF_DECODER_FAST_TABLELOG);
-            if (args.op[i] != segmentEnd) return ERROR(corruption_detected);
-        }
-    }
-
-    /* decoded size */
-    assert(dstSize != 0);
-    return dstSize;
-}
-
-HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
-
-static size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,
-                    size_t cSrcSize, HUF_DTable const* DTable, int flags)
-{
-    HUF_DecompressUsingDTableFn fallbackFn = HUF_decompress4X1_usingDTable_internal_default;
-    HUF_DecompressFastLoopFn loopFn = HUF_decompress4X1_usingDTable_internal_fast_c_loop;
-
-#if DYNAMIC_BMI2
-    if (flags & HUF_flags_bmi2) {
-        fallbackFn = HUF_decompress4X1_usingDTable_internal_bmi2;
-    } else {
-        return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);
-    }
-#endif
-    if (HUF_ENABLE_FAST_DECODE && !(flags & HUF_flags_disableFast)) {
-        size_t const ret = HUF_decompress4X1_usingDTable_internal_fast(dst, dstSize, cSrc, cSrcSize, DTable, loopFn);
-        if (ret != 0)
-            return ret;
-    }
-    return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-static size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
-                                   const void* cSrc, size_t cSrcSize,
-                                   void* workSpace, size_t wkspSize, int flags)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);
-}
-
-#endif /* HUF_FORCE_DECOMPRESS_X2 */
-
-
-#ifndef HUF_FORCE_DECOMPRESS_X1
-
-/* *************************/
-/* double-symbols decoding */
-/* *************************/
-
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */
-typedef struct { BYTE symbol; } sortedSymbol_t;
-typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
-typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];
-
-/**
- * Constructs a HUF_DEltX2 in a U32.
- */
-static U32 HUF_buildDEltX2U32(U32 symbol, U32 nbBits, U32 baseSeq, int level)
-{
-    U32 seq;
-    DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, sequence) == 0);
-    DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, nbBits) == 2);
-    DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, length) == 3);
-    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U32));
-    if (MEM_isLittleEndian()) {
-        seq = level == 1 ? symbol : (baseSeq + (symbol << 8));
-        return seq + (nbBits << 16) + ((U32)level << 24);
-    } else {
-        seq = level == 1 ? (symbol << 8) : ((baseSeq << 8) + symbol);
-        return (seq << 16) + (nbBits << 8) + (U32)level;
-    }
-}
-
-/**
- * Constructs a HUF_DEltX2.
- */
-static HUF_DEltX2 HUF_buildDEltX2(U32 symbol, U32 nbBits, U32 baseSeq, int level)
-{
-    HUF_DEltX2 DElt;
-    U32 const val = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
-    DEBUG_STATIC_ASSERT(sizeof(DElt) == sizeof(val));
-    ZSTD_memcpy(&DElt, &val, sizeof(val));
-    return DElt;
-}
-
-/**
- * Constructs 2 HUF_DEltX2s and packs them into a U64.
- */
-static U64 HUF_buildDEltX2U64(U32 symbol, U32 nbBits, U16 baseSeq, int level)
-{
-    U32 DElt = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
-    return (U64)DElt + ((U64)DElt << 32);
-}
-
-/**
- * Fills the DTable rank with all the symbols from [begin, end) that are each
- * nbBits long.
- *
- * @param DTableRank The start of the rank in the DTable.
- * @param begin The first symbol to fill (inclusive).
- * @param end The last symbol to fill (exclusive).
- * @param nbBits Each symbol is nbBits long.
- * @param tableLog The table log.
- * @param baseSeq If level == 1 { 0 } else { the first level symbol }
- * @param level The level in the table. Must be 1 or 2.
- */
-static void HUF_fillDTableX2ForWeight(
-    HUF_DEltX2* DTableRank,
-    sortedSymbol_t const* begin, sortedSymbol_t const* end,
-    U32 nbBits, U32 tableLog,
-    U16 baseSeq, int const level)
-{
-    U32 const length = 1U << ((tableLog - nbBits) & 0x1F /* quiet static-analyzer */);
-    const sortedSymbol_t* ptr;
-    assert(level >= 1 && level <= 2);
-    switch (length) {
-    case 1:
-        for (ptr = begin; ptr != end; ++ptr) {
-            HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level);
-            *DTableRank++ = DElt;
-        }
-        break;
-    case 2:
-        for (ptr = begin; ptr != end; ++ptr) {
-            HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level);
-            DTableRank[0] = DElt;
-            DTableRank[1] = DElt;
-            DTableRank += 2;
-        }
-        break;
-    case 4:
-        for (ptr = begin; ptr != end; ++ptr) {
-            U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);
-            ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));
-            ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));
-            DTableRank += 4;
-        }
-        break;
-    case 8:
-        for (ptr = begin; ptr != end; ++ptr) {
-            U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);
-            ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));
-            ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));
-            ZSTD_memcpy(DTableRank + 4, &DEltX2, sizeof(DEltX2));
-            ZSTD_memcpy(DTableRank + 6, &DEltX2, sizeof(DEltX2));
-            DTableRank += 8;
-        }
-        break;
-    default:
-        for (ptr = begin; ptr != end; ++ptr) {
-            U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);
-            HUF_DEltX2* const DTableRankEnd = DTableRank + length;
-            for (; DTableRank != DTableRankEnd; DTableRank += 8) {
-                ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));
-                ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));
-                ZSTD_memcpy(DTableRank + 4, &DEltX2, sizeof(DEltX2));
-                ZSTD_memcpy(DTableRank + 6, &DEltX2, sizeof(DEltX2));
-            }
-        }
-        break;
-    }
-}
-
-/* HUF_fillDTableX2Level2() :
- * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */
-static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32 consumedBits,
-                           const U32* rankVal, const int minWeight, const int maxWeight1,
-                           const sortedSymbol_t* sortedSymbols, U32 const* rankStart,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    /* Fill skipped values (all positions up to rankVal[minWeight]).
-     * These are positions only get a single symbol because the combined weight
-     * is too large.
-     */
-    if (minWeight>1) {
-        U32 const length = 1U << ((targetLog - consumedBits) & 0x1F /* quiet static-analyzer */);
-        U64 const DEltX2 = HUF_buildDEltX2U64(baseSeq, consumedBits, /* baseSeq */ 0, /* level */ 1);
-        int const skipSize = rankVal[minWeight];
-        assert(length > 1);
-        assert((U32)skipSize < length);
-        switch (length) {
-        case 2:
-            assert(skipSize == 1);
-            ZSTD_memcpy(DTable, &DEltX2, sizeof(DEltX2));
-            break;
-        case 4:
-            assert(skipSize <= 4);
-            ZSTD_memcpy(DTable + 0, &DEltX2, sizeof(DEltX2));
-            ZSTD_memcpy(DTable + 2, &DEltX2, sizeof(DEltX2));
-            break;
-        default:
-            {
-                int i;
-                for (i = 0; i < skipSize; i += 8) {
-                    ZSTD_memcpy(DTable + i + 0, &DEltX2, sizeof(DEltX2));
-                    ZSTD_memcpy(DTable + i + 2, &DEltX2, sizeof(DEltX2));
-                    ZSTD_memcpy(DTable + i + 4, &DEltX2, sizeof(DEltX2));
-                    ZSTD_memcpy(DTable + i + 6, &DEltX2, sizeof(DEltX2));
-                }
-            }
-        }
-    }
-
-    /* Fill each of the second level symbols by weight. */
-    {
-        int w;
-        for (w = minWeight; w < maxWeight1; ++w) {
-            int const begin = rankStart[w];
-            int const end = rankStart[w+1];
-            U32 const nbBits = nbBitsBaseline - w;
-            U32 const totalBits = nbBits + consumedBits;
-            HUF_fillDTableX2ForWeight(
-                DTable + rankVal[w],
-                sortedSymbols + begin, sortedSymbols + end,
-                totalBits, targetLog,
-                baseSeq, /* level */ 2);
-        }
-    }
-}
-
-static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
-                           const sortedSymbol_t* sortedList,
-                           const U32* rankStart, rankValCol_t* rankValOrigin, const U32 maxWeight,
-                           const U32 nbBitsBaseline)
-{
-    U32* const rankVal = rankValOrigin[0];
-    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
-    const U32 minBits  = nbBitsBaseline - maxWeight;
-    int w;
-    int const wEnd = (int)maxWeight + 1;
-
-    /* Fill DTable in order of weight. */
-    for (w = 1; w < wEnd; ++w) {
-        int const begin = (int)rankStart[w];
-        int const end = (int)rankStart[w+1];
-        U32 const nbBits = nbBitsBaseline - w;
-
-        if (targetLog-nbBits >= minBits) {
-            /* Enough room for a second symbol. */
-            int start = rankVal[w];
-            U32 const length = 1U << ((targetLog - nbBits) & 0x1F /* quiet static-analyzer */);
-            int minWeight = nbBits + scaleLog;
-            int s;
-            if (minWeight < 1) minWeight = 1;
-            /* Fill the DTable for every symbol of weight w.
-             * These symbols get at least 1 second symbol.
-             */
-            for (s = begin; s != end; ++s) {
-                HUF_fillDTableX2Level2(
-                    DTable + start, targetLog, nbBits,
-                    rankValOrigin[nbBits], minWeight, wEnd,
-                    sortedList, rankStart,
-                    nbBitsBaseline, sortedList[s].symbol);
-                start += length;
-            }
-        } else {
-            /* Only a single symbol. */
-            HUF_fillDTableX2ForWeight(
-                DTable + rankVal[w],
-                sortedList + begin, sortedList + end,
-                nbBits, targetLog,
-                /* baseSeq */ 0, /* level */ 1);
-        }
-    }
-}
-
-typedef struct {
-    rankValCol_t rankVal[HUF_TABLELOG_MAX];
-    U32 rankStats[HUF_TABLELOG_MAX + 1];
-    U32 rankStart0[HUF_TABLELOG_MAX + 3];
-    sortedSymbol_t sortedSymbol[HUF_SYMBOLVALUE_MAX + 1];
-    BYTE weightList[HUF_SYMBOLVALUE_MAX + 1];
-    U32 calleeWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
-} HUF_ReadDTableX2_Workspace;
-
-size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
-                       const void* src, size_t srcSize,
-                             void* workSpace, size_t wkspSize, int flags)
-{
-    U32 tableLog, maxW, nbSymbols;
-    DTableDesc dtd = HUF_getDTableDesc(DTable);
-    U32 maxTableLog = dtd.maxTableLog;
-    size_t iSize;
-    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
-    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
-    U32 *rankStart;
-
-    HUF_ReadDTableX2_Workspace* const wksp = (HUF_ReadDTableX2_Workspace*)workSpace;
-
-    if (sizeof(*wksp) > wkspSize) return ERROR(GENERIC);
-
-    rankStart = wksp->rankStart0 + 1;
-    ZSTD_memset(wksp->rankStats, 0, sizeof(wksp->rankStats));
-    ZSTD_memset(wksp->rankStart0, 0, sizeof(wksp->rankStart0));
-
-    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */
-    if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
-    /* ZSTD_memset(weightList, 0, sizeof(weightList)); */  /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats_wksp(wksp->weightList, HUF_SYMBOLVALUE_MAX + 1, wksp->rankStats, &nbSymbols, &tableLog, src, srcSize, wksp->calleeWksp, sizeof(wksp->calleeWksp), flags);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
-    if (tableLog <= HUF_DECODER_FAST_TABLELOG && maxTableLog > HUF_DECODER_FAST_TABLELOG) maxTableLog = HUF_DECODER_FAST_TABLELOG;
-
-    /* find maxWeight */
-    for (maxW = tableLog; wksp->rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
-
-    /* Get start index of each weight */
-    {   U32 w, nextRankStart = 0;
-        for (w=1; w<maxW+1; w++) {
-            U32 curr = nextRankStart;
-            nextRankStart += wksp->rankStats[w];
-            rankStart[w] = curr;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
-        rankStart[maxW+1] = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {   U32 s;
-        for (s=0; s<nbSymbols; s++) {
-            U32 const w = wksp->weightList[s];
-            U32 const r = rankStart[w]++;
-            wksp->sortedSymbol[r].symbol = (BYTE)s;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-    /* Build rankVal */
-    {   U32* const rankVal0 = wksp->rankVal[0];
-        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
-            U32 nextRankVal = 0;
-            U32 w;
-            for (w=1; w<maxW+1; w++) {
-                U32 curr = nextRankVal;
-                nextRankVal += wksp->rankStats[w] << (w+rescale);
-                rankVal0[w] = curr;
-        }   }
-        {   U32 const minBits = tableLog+1 - maxW;
-            U32 consumed;
-            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
-                U32* const rankValPtr = wksp->rankVal[consumed];
-                U32 w;
-                for (w = 1; w < maxW+1; w++) {
-                    rankValPtr[w] = rankVal0[w] >> consumed;
-    }   }   }   }
-
-    HUF_fillDTableX2(dt, maxTableLog,
-                   wksp->sortedSymbol,
-                   wksp->rankStart0, wksp->rankVal, maxW,
-                   tableLog+1);
-
-    dtd.tableLog = (BYTE)maxTableLog;
-    dtd.tableType = 1;
-    ZSTD_memcpy(DTable, &dtd, sizeof(dtd));
-    return iSize;
-}
-
-
-FORCE_INLINE_TEMPLATE U32
-HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
-{
-    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    ZSTD_memcpy(op, &dt[val].sequence, 2);
-    BIT_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-FORCE_INLINE_TEMPLATE U32
-HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
-{
-    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    ZSTD_memcpy(op, &dt[val].sequence, 1);
-    if (dt[val].length==1) {
-        BIT_skipBits(DStream, dt[val].nbBits);
-    } else {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
-            BIT_skipBits(DStream, dt[val].nbBits);
-            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
-                /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
-                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
-        }
-    }
-    return 1;
-}
-
-#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    do { ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog); } while (0)
-
-#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr)                     \
-    do {                                                           \
-        if (MEM_64bits() || (HUF_TABLELOG_MAX<=12))                \
-            ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog); \
-    } while (0)
-
-#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr)                     \
-    do {                                                           \
-        if (MEM_64bits())                                          \
-            ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog); \
-    } while (0)
-
-HINT_INLINE size_t
-HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
-                const HUF_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    if ((size_t)(pEnd - p) >= sizeof(bitDPtr->bitContainer)) {
-        if (dtLog <= 11 && MEM_64bits()) {
-            /* up to 10 symbols at a time */
-            while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-9)) {
-                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-            }
-        } else {
-            /* up to 8 symbols at a time */
-            while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {
-                HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-            }
-        }
-    } else {
-        BIT_reloadDStream(bitDPtr);
-    }
-
-    /* closer to end : up to 2 symbols at a time */
-    if ((size_t)(pEnd - p) >= 2) {
-        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
-            HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-        while (p <= pEnd-2)
-            HUF_DECODE_SYMBOLX2_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-    }
-
-    if (p < pEnd)
-        p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-FORCE_INLINE_TEMPLATE size_t
-HUF_decompress1X2_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    BIT_DStream_t bitD;
-
-    /* Init */
-    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
-
-    /* decode */
-    {   BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ZSTD_maybeNullPtrAdd(ostart, dstSize);
-        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
-        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
-        DTableDesc const dtd = HUF_getDTableDesc(DTable);
-        HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
-    }
-
-    /* check */
-    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    /* decoded size */
-    return dstSize;
-}
-
-/* HUF_decompress4X2_usingDTable_internal_body():
- * Conditions:
- * @dstSize >= 6
- */
-FORCE_INLINE_TEMPLATE size_t
-HUF_decompress4X2_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-    if (dstSize < 6) return ERROR(corruption_detected);         /* stream 4-split doesn't work */
-
-    {   const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        BYTE* const olimit = oend - (sizeof(size_t)-1);
-        const void* const dtPtr = DTable+1;
-        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        size_t const length1 = MEM_readLE16(istart);
-        size_t const length2 = MEM_readLE16(istart+2);
-        size_t const length3 = MEM_readLE16(istart+4);
-        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        size_t const segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal = 1;
-        DTableDesc const dtd = HUF_getDTableDesc(DTable);
-        U32 const dtLog = dtd.tableLog;
-
-        if (length4 > cSrcSize) return ERROR(corruption_detected);  /* overflow */
-        if (opStart4 > oend) return ERROR(corruption_detected);     /* overflow */
-        assert(dstSize >= 6 /* validated above */);
-        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
-        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
-        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
-        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        if ((size_t)(oend - op4) >= sizeof(size_t)) {
-            for ( ; (endSignal) & (op4 < olimit); ) {
-#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
-                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
-                endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
-                endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
-                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-                HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
-                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-                HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
-                endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
-                endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
-#else
-                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-                HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
-                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-                HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
-                HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
-                HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
-                HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
-                endSignal = (U32)LIKELY((U32)
-                            (BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished)
-                        & (BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished)
-                        & (BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished)
-                        & (BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished));
-#endif
-            }
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-          if (!endCheck) return ERROR(corruption_detected); }
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-#if HUF_NEED_BMI2_FUNCTION
-static BMI2_TARGET_ATTRIBUTE
-size_t HUF_decompress4X2_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,
-                    size_t cSrcSize, HUF_DTable const* DTable) {
-    return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-#endif
-
-static
-size_t HUF_decompress4X2_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,
-                    size_t cSrcSize, HUF_DTable const* DTable) {
-    return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-static HUF_FAST_BMI2_ATTRS
-void HUF_decompress4X2_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs* args)
-{
-    U64 bits[4];
-    BYTE const* ip[4];
-    BYTE* op[4];
-    BYTE* oend[4];
-    HUF_DEltX2 const* const dtable = (HUF_DEltX2 const*)args->dt;
-    BYTE const* const ilowest = args->ilowest;
-
-    /* Copy the arguments to local registers. */
-    ZSTD_memcpy(&bits, &args->bits, sizeof(bits));
-    ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip));
-    ZSTD_memcpy(&op, &args->op, sizeof(op));
-
-    oend[0] = op[1];
-    oend[1] = op[2];
-    oend[2] = op[3];
-    oend[3] = args->oend;
-
-    assert(MEM_isLittleEndian());
-    assert(!MEM_32bits());
-
-    for (;;) {
-        BYTE* olimit;
-        int stream;
-
-        /* Assert loop preconditions */
-#ifndef NDEBUG
-        for (stream = 0; stream < 4; ++stream) {
-            assert(op[stream] <= oend[stream]);
-            assert(ip[stream] >= ilowest);
-        }
-#endif
-        /* Compute olimit */
-        {
-            /* Each loop does 5 table lookups for each of the 4 streams.
-             * Each table lookup consumes up to 11 bits of input, and produces
-             * up to 2 bytes of output.
-             */
-            /* We can consume up to 7 bytes of input per iteration per stream.
-             * We also know that each input pointer is >= ip[0]. So we can run
-             * iters loops before running out of input.
-             */
-            size_t iters = (size_t)(ip[0] - ilowest) / 7;
-            /* Each iteration can produce up to 10 bytes of output per stream.
-             * Each output stream my advance at different rates. So take the
-             * minimum number of safe iterations among all the output streams.
-             */
-            for (stream = 0; stream < 4; ++stream) {
-                size_t const oiters = (size_t)(oend[stream] - op[stream]) / 10;
-                iters = MIN(iters, oiters);
-            }
-
-            /* Each iteration produces at least 5 output symbols. So until
-             * op[3] crosses olimit, we know we haven't executed iters
-             * iterations yet. This saves us maintaining an iters counter,
-             * at the expense of computing the remaining # of iterations
-             * more frequently.
-             */
-            olimit = op[3] + (iters * 5);
-
-            /* Exit the fast decoding loop once we reach the end. */
-            if (op[3] == olimit)
-                break;
-
-            /* Exit the decoding loop if any input pointer has crossed the
-             * previous one. This indicates corruption, and a precondition
-             * to our loop is that ip[i] >= ip[0].
-             */
-            for (stream = 1; stream < 4; ++stream) {
-                if (ip[stream] < ip[stream - 1])
-                    goto _out;
-            }
-        }
-
-#ifndef NDEBUG
-        for (stream = 1; stream < 4; ++stream) {
-            assert(ip[stream] >= ip[stream - 1]);
-        }
-#endif
-
-#define HUF_4X2_DECODE_SYMBOL(_stream, _decode3)                      \
-    do {                                                              \
-        if ((_decode3) || (_stream) != 3) {                           \
-            int const index = (int)(bits[(_stream)] >> 53);           \
-            HUF_DEltX2 const entry = dtable[index];                   \
-            MEM_write16(op[(_stream)], entry.sequence); \
-            bits[(_stream)] <<= (entry.nbBits) & 0x3F;                \
-            op[(_stream)] += (entry.length);                          \
-        }                                                             \
-    } while (0)
-
-#define HUF_4X2_RELOAD_STREAM(_stream)                                  \
-    do {                                                                \
-        HUF_4X2_DECODE_SYMBOL(3, 1);                                    \
-        {                                                               \
-            int const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \
-            int const nbBits = ctz & 7;                                 \
-            int const nbBytes = ctz >> 3;                               \
-            ip[(_stream)] -= nbBytes;                                   \
-            bits[(_stream)] = MEM_read64(ip[(_stream)]) | 1;            \
-            bits[(_stream)] <<= nbBits;                                 \
-        }                                                               \
-    } while (0)
-
-        /* Manually unroll the loop because compilers don't consistently
-         * unroll the inner loops, which destroys performance.
-         */
-        do {
-            /* Decode 5 symbols from each of the first 3 streams.
-             * The final stream will be decoded during the reload phase
-             * to reduce register pressure.
-             */
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
-            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, 0);
-
-            /* Decode one symbol from the final stream */
-            HUF_4X2_DECODE_SYMBOL(3, 1);
-
-            /* Decode 4 symbols from the final stream & reload bitstreams.
-             * The final stream is reloaded last, meaning that all 5 symbols
-             * are decoded from the final stream before it is reloaded.
-             */
-            HUF_4X_FOR_EACH_STREAM(HUF_4X2_RELOAD_STREAM);
-        } while (op[3] < olimit);
-    }
-
-#undef HUF_4X2_DECODE_SYMBOL
-#undef HUF_4X2_RELOAD_STREAM
-
-_out:
-
-    /* Save the final values of each of the state variables back to args. */
-    ZSTD_memcpy(&args->bits, &bits, sizeof(bits));
-    ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip));
-    ZSTD_memcpy(&args->op, &op, sizeof(op));
-}
-
-
-static HUF_FAST_BMI2_ATTRS size_t
-HUF_decompress4X2_usingDTable_internal_fast(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable,
-    HUF_DecompressFastLoopFn loopFn) {
-    void const* dt = DTable + 1;
-    const BYTE* const ilowest = (const BYTE*)cSrc;
-    BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);
-    HUF_DecompressFastArgs args;
-    {
-        size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);
-        FORWARD_IF_ERROR(ret, "Failed to init asm args");
-        if (ret == 0)
-            return 0;
-    }
-
-    assert(args.ip[0] >= args.ilowest);
-    loopFn(&args);
-
-    /* note : op4 already verified within main loop */
-    assert(args.ip[0] >= ilowest);
-    assert(args.ip[1] >= ilowest);
-    assert(args.ip[2] >= ilowest);
-    assert(args.ip[3] >= ilowest);
-    assert(args.op[3] <= oend);
-
-    assert(ilowest == args.ilowest);
-    assert(ilowest + 6 == args.iend[0]);
-    (void)ilowest;
-
-    /* finish bitStreams one by one */
-    {
-        size_t const segmentSize = (dstSize+3) / 4;
-        BYTE* segmentEnd = (BYTE*)dst;
-        int i;
-        for (i = 0; i < 4; ++i) {
-            BIT_DStream_t bit;
-            if (segmentSize <= (size_t)(oend - segmentEnd))
-                segmentEnd += segmentSize;
-            else
-                segmentEnd = oend;
-            FORWARD_IF_ERROR(HUF_initRemainingDStream(&bit, &args, i, segmentEnd), "corruption");
-            args.op[i] += HUF_decodeStreamX2(args.op[i], &bit, segmentEnd, (HUF_DEltX2 const*)dt, HUF_DECODER_FAST_TABLELOG);
-            if (args.op[i] != segmentEnd)
-                return ERROR(corruption_detected);
-        }
-    }
-
-    /* decoded size */
-    return dstSize;
-}
-
-static size_t HUF_decompress4X2_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,
-                    size_t cSrcSize, HUF_DTable const* DTable, int flags)
-{
-    HUF_DecompressUsingDTableFn fallbackFn = HUF_decompress4X2_usingDTable_internal_default;
-    HUF_DecompressFastLoopFn loopFn = HUF_decompress4X2_usingDTable_internal_fast_c_loop;
-
-#if DYNAMIC_BMI2
-    if (flags & HUF_flags_bmi2) {
-        fallbackFn = HUF_decompress4X2_usingDTable_internal_bmi2;
-    } else {
-        return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);
-    }
-#endif
-
-    if (HUF_ENABLE_FAST_DECODE && !(flags & HUF_flags_disableFast)) {
-        size_t const ret = HUF_decompress4X2_usingDTable_internal_fast(dst, dstSize, cSrc, cSrcSize, DTable, loopFn);
-        if (ret != 0)
-            return ret;
-    }
-    return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
-
-size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
-                                   const void* cSrc, size_t cSrcSize,
-                                   void* workSpace, size_t wkspSize, int flags)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
-                                               workSpace, wkspSize, flags);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, flags);
-}
-
-static size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
-                                   const void* cSrc, size_t cSrcSize,
-                                   void* workSpace, size_t wkspSize, int flags)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
-                                         workSpace, wkspSize, flags);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);
-}
-
-#endif /* HUF_FORCE_DECOMPRESS_X1 */
-
-
-/* ***********************************/
-/* Universal decompression selectors */
-/* ***********************************/
-
-
-#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
-typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
-static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] =
-{
-    /* single, double, quad */
-    {{0,0}, {1,1}},  /* Q==0 : impossible */
-    {{0,0}, {1,1}},  /* Q==1 : impossible */
-    {{ 150,216}, { 381,119}},   /* Q == 2 : 12-18% */
-    {{ 170,205}, { 514,112}},   /* Q == 3 : 18-25% */
-    {{ 177,199}, { 539,110}},   /* Q == 4 : 25-32% */
-    {{ 197,194}, { 644,107}},   /* Q == 5 : 32-38% */
-    {{ 221,192}, { 735,107}},   /* Q == 6 : 38-44% */
-    {{ 256,189}, { 881,106}},   /* Q == 7 : 44-50% */
-    {{ 359,188}, {1167,109}},   /* Q == 8 : 50-56% */
-    {{ 582,187}, {1570,114}},   /* Q == 9 : 56-62% */
-    {{ 688,187}, {1712,122}},   /* Q ==10 : 62-69% */
-    {{ 825,186}, {1965,136}},   /* Q ==11 : 69-75% */
-    {{ 976,185}, {2131,150}},   /* Q ==12 : 75-81% */
-    {{1180,186}, {2070,175}},   /* Q ==13 : 81-87% */
-    {{1377,185}, {1731,202}},   /* Q ==14 : 87-93% */
-    {{1412,185}, {1695,202}},   /* Q ==15 : 93-99% */
-};
-#endif
-
-/** HUF_selectDecoder() :
- *  Tells which decoder is likely to decode faster,
- *  based on a set of pre-computed metrics.
- * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
- *  Assumption : 0 < dstSize <= 128 KB */
-U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
-{
-    assert(dstSize > 0);
-    assert(dstSize <= 128*1024);
-#if defined(HUF_FORCE_DECOMPRESS_X1)
-    (void)dstSize;
-    (void)cSrcSize;
-    return 0;
-#elif defined(HUF_FORCE_DECOMPRESS_X2)
-    (void)dstSize;
-    (void)cSrcSize;
-    return 1;
-#else
-    /* decoder timing evaluation */
-    {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
-        U32 const D256 = (U32)(dstSize >> 8);
-        U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
-        U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
-        DTime1 += DTime1 >> 5;  /* small advantage to algorithm using less memory, to reduce cache eviction */
-        return DTime1 < DTime0;
-    }
-#endif
-}
-
-size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
-                                  const void* cSrc, size_t cSrcSize,
-                                  void* workSpace, size_t wkspSize, int flags)
-{
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
-    if (cSrcSize == dstSize) { ZSTD_memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
-    if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
-
-    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-#if defined(HUF_FORCE_DECOMPRESS_X1)
-        (void)algoNb;
-        assert(algoNb == 0);
-        return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
-                                cSrcSize, workSpace, wkspSize, flags);
-#elif defined(HUF_FORCE_DECOMPRESS_X2)
-        (void)algoNb;
-        assert(algoNb == 1);
-        return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
-                                cSrcSize, workSpace, wkspSize, flags);
-#else
-        return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
-                                cSrcSize, workSpace, wkspSize, flags):
-                        HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
-                                cSrcSize, workSpace, wkspSize, flags);
-#endif
-    }
-}
-
-
-size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags)
-{
-    DTableDesc const dtd = HUF_getDTableDesc(DTable);
-#if defined(HUF_FORCE_DECOMPRESS_X1)
-    (void)dtd;
-    assert(dtd.tableType == 0);
-    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);
-#elif defined(HUF_FORCE_DECOMPRESS_X2)
-    (void)dtd;
-    assert(dtd.tableType == 1);
-    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);
-#else
-    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) :
-                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);
-#endif
-}
-
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);
-}
-#endif
-
-size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags)
-{
-    DTableDesc const dtd = HUF_getDTableDesc(DTable);
-#if defined(HUF_FORCE_DECOMPRESS_X1)
-    (void)dtd;
-    assert(dtd.tableType == 0);
-    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);
-#elif defined(HUF_FORCE_DECOMPRESS_X2)
-    (void)dtd;
-    assert(dtd.tableType == 1);
-    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);
-#else
-    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) :
-                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);
-#endif
-}
-
-size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags)
-{
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if (cSrcSize == 0) return ERROR(corruption_detected);
-
-    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-#if defined(HUF_FORCE_DECOMPRESS_X1)
-        (void)algoNb;
-        assert(algoNb == 0);
-        return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);
-#elif defined(HUF_FORCE_DECOMPRESS_X2)
-        (void)algoNb;
-        assert(algoNb == 1);
-        return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);
-#else
-        return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags) :
-                        HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);
-#endif
-    }
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp b/src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp
deleted file mode 100644
index 2c6c0ded6..000000000
--- a/src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* zstd_ddict.c :
- * concentrates all logic that needs to know the internals of ZSTD_DDict object */
-
-/*-*******************************************************
-*  Dependencies
-*********************************************************/
-#include "zstd/common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customFree */
-#include "zstd/common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
-#include "zstd/common/cpu.h"         /* bmi2 */
-#include "zstd/common/mem.h"         /* low level memory routines */
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-#include "zstd/common/huf.h"
-#include "zstd/decompress/zstd_decompress_internal.h"
-#include "zstd/decompress/zstd_ddict.h"
-
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-// #  include "zstd/legacy/zstd_legacy.h" // DuckDB: comment out otherwise amalgamation won't be happy
-#endif
-
-namespace duckdb_zstd {
-
-/*-*******************************************************
-*  Types
-*********************************************************/
-struct ZSTD_DDict_s {
-    void* dictBuffer;
-    const void* dictContent;
-    size_t dictSize;
-    ZSTD_entropyDTables_t entropy;
-    U32 dictID;
-    U32 entropyPresent;
-    ZSTD_customMem cMem;
-};  /* typedef'd to ZSTD_DDict within "zstd.h" */
-
-const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)
-{
-    assert(ddict != NULL);
-    return ddict->dictContent;
-}
-
-size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)
-{
-    assert(ddict != NULL);
-    return ddict->dictSize;
-}
-
-void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
-{
-    DEBUGLOG(4, "ZSTD_copyDDictParameters");
-    assert(dctx != NULL);
-    assert(ddict != NULL);
-    dctx->dictID = ddict->dictID;
-    dctx->prefixStart = ddict->dictContent;
-    dctx->virtualStart = ddict->dictContent;
-    dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
-    dctx->previousDstEnd = dctx->dictEnd;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    dctx->dictContentBeginForFuzzing = dctx->prefixStart;
-    dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
-#endif
-    if (ddict->entropyPresent) {
-        dctx->litEntropy = 1;
-        dctx->fseEntropy = 1;
-        dctx->LLTptr = ddict->entropy.LLTable;
-        dctx->MLTptr = ddict->entropy.MLTable;
-        dctx->OFTptr = ddict->entropy.OFTable;
-        dctx->HUFptr = ddict->entropy.hufTable;
-        dctx->entropy.rep[0] = ddict->entropy.rep[0];
-        dctx->entropy.rep[1] = ddict->entropy.rep[1];
-        dctx->entropy.rep[2] = ddict->entropy.rep[2];
-    } else {
-        dctx->litEntropy = 0;
-        dctx->fseEntropy = 0;
-    }
-}
-
-
-static size_t
-ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
-                           ZSTD_dictContentType_e dictContentType)
-{
-    ddict->dictID = 0;
-    ddict->entropyPresent = 0;
-    if (dictContentType == ZSTD_dct_rawContent) return 0;
-
-    if (ddict->dictSize < 8) {
-        if (dictContentType == ZSTD_dct_fullDict)
-            return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */
-        return 0;   /* pure content mode */
-    }
-    {   U32 const magic = MEM_readLE32(ddict->dictContent);
-        if (magic != ZSTD_MAGIC_DICTIONARY) {
-            if (dictContentType == ZSTD_dct_fullDict)
-                return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */
-            return 0;   /* pure content mode */
-        }
-    }
-    ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);
-
-    /* load entropy tables */
-    RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy(
-            &ddict->entropy, ddict->dictContent, ddict->dictSize)),
-        dictionary_corrupted, "");
-    ddict->entropyPresent = 1;
-    return 0;
-}
-
-
-static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
-                                      const void* dict, size_t dictSize,
-                                      ZSTD_dictLoadMethod_e dictLoadMethod,
-                                      ZSTD_dictContentType_e dictContentType)
-{
-    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
-        ddict->dictBuffer = NULL;
-        ddict->dictContent = dict;
-        if (!dict) dictSize = 0;
-    } else {
-        void* const internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem);
-        ddict->dictBuffer = internalBuffer;
-        ddict->dictContent = internalBuffer;
-        if (!internalBuffer) return ERROR(memory_allocation);
-        ZSTD_memcpy(internalBuffer, dict, dictSize);
-    }
-    ddict->dictSize = dictSize;
-    ddict->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001);  /* cover both little and big endian */
-
-    /* parse dictionary content */
-    FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) , "");
-
-    return 0;
-}
-
-ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
-                                      ZSTD_dictLoadMethod_e dictLoadMethod,
-                                      ZSTD_dictContentType_e dictContentType,
-                                      ZSTD_customMem customMem)
-{
-    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
-
-    {   ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_customMalloc(sizeof(ZSTD_DDict), customMem);
-        if (ddict == NULL) return NULL;
-        ddict->cMem = customMem;
-        {   size_t const initResult = ZSTD_initDDict_internal(ddict,
-                                            dict, dictSize,
-                                            dictLoadMethod, dictContentType);
-            if (ZSTD_isError(initResult)) {
-                ZSTD_freeDDict(ddict);
-                return NULL;
-        }   }
-        return ddict;
-    }
-}
-
-/*! ZSTD_createDDict() :
-*   Create a digested dictionary, to start decompression without startup delay.
-*   `dict` content is copied inside DDict.
-*   Consequently, `dict` can be released after `ZSTD_DDict` creation */
-ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
-{
-    ZSTD_customMem const allocator = { NULL, NULL, NULL };
-    return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
-}
-
-/*! ZSTD_createDDict_byReference() :
- *  Create a digested dictionary, to start decompression without startup delay.
- *  Dictionary content is simply referenced, it will be accessed during decompression.
- *  Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
-ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
-{
-    ZSTD_customMem const allocator = { NULL, NULL, NULL };
-    return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
-}
-
-
-const ZSTD_DDict* ZSTD_initStaticDDict(
-                                void* sBuffer, size_t sBufferSize,
-                                const void* dict, size_t dictSize,
-                                ZSTD_dictLoadMethod_e dictLoadMethod,
-                                ZSTD_dictContentType_e dictContentType)
-{
-    size_t const neededSpace = sizeof(ZSTD_DDict)
-                             + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
-    ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
-    assert(sBuffer != NULL);
-    assert(dict != NULL);
-    if ((size_t)sBuffer & 7) return NULL;   /* 8-aligned */
-    if (sBufferSize < neededSpace) return NULL;
-    if (dictLoadMethod == ZSTD_dlm_byCopy) {
-        ZSTD_memcpy(ddict+1, dict, dictSize);  /* local copy */
-        dict = ddict+1;
-    }
-    if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
-                                              dict, dictSize,
-                                              ZSTD_dlm_byRef, dictContentType) ))
-        return NULL;
-    return ddict;
-}
-
-
-size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
-{
-    if (ddict==NULL) return 0;   /* support free on NULL */
-    {   ZSTD_customMem const cMem = ddict->cMem;
-        ZSTD_customFree(ddict->dictBuffer, cMem);
-        ZSTD_customFree(ddict, cMem);
-        return 0;
-    }
-}
-
-/*! ZSTD_estimateDDictSize() :
- *  Estimate amount of memory that will be needed to create a dictionary for decompression.
- *  Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
-size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
-{
-    return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
-}
-
-size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
-{
-    if (ddict==NULL) return 0;   /* support sizeof on NULL */
-    return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
-}
-
-/*! ZSTD_getDictID_fromDDict() :
- *  Provides the dictID of the dictionary loaded into `ddict`.
- *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
- *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
-unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
-{
-    if (ddict==NULL) return 0;
-    return ddict->dictID;
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp b/src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp
deleted file mode 100644
index 1a10de56d..000000000
--- a/src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp
+++ /dev/null
@@ -1,2411 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-/* ***************************************************************
-*  Tuning parameters
-*****************************************************************/
-/*!
- * HEAPMODE :
- * Select how default decompression function ZSTD_decompress() allocates its context,
- * on stack (0), or into heap (1, default; requires malloc()).
- * Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.
- */
-#ifndef ZSTD_HEAPMODE
-#  define ZSTD_HEAPMODE 1
-#endif
-
-/*!
-*  LEGACY_SUPPORT :
-*  if set to 1+, ZSTD_decompress() can decode older formats (v0.1+)
-*/
-#ifndef ZSTD_LEGACY_SUPPORT
-#  define ZSTD_LEGACY_SUPPORT 0
-#endif
-
-/*!
- *  MAXWINDOWSIZE_DEFAULT :
- *  maximum window size accepted by DStream __by default__.
- *  Frames requiring more memory will be rejected.
- *  It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
- */
-#ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
-#  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
-#endif
-
-/*!
- *  NO_FORWARD_PROGRESS_MAX :
- *  maximum allowed nb of calls to ZSTD_decompressStream()
- *  without any forward progress
- *  (defined as: no byte read from input, and no byte flushed to output)
- *  before triggering an error.
- */
-#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
-#  define ZSTD_NO_FORWARD_PROGRESS_MAX 16
-#endif
-
-
-/*-*******************************************************
-*  Dependencies
-*********************************************************/
-#include "zstd/common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
-#include "zstd/common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
-#include "zstd/common/error_private.h"
-#include "zstd/common/zstd_internal.h"  /* blockProperties_t */
-#include "zstd/common/mem.h"         /* low level memory routines */
-#include "zstd/common/bits.h"  /* ZSTD_highbit32 */
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-#include "zstd/common/huf.h"
-#include "zstd/common/xxhash.hpp" /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */
-#include "zstd/common/xxhash_static.hpp" /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */
-#include "zstd/decompress/zstd_decompress_internal.h"   /* ZSTD_DCtx */
-#include "zstd/decompress/zstd_ddict.h"  /* ZSTD_DDictDictContent */
-#include "zstd/decompress/zstd_decompress_block.h"   /* ZSTD_decompressBlock_internal */
-
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-// #  include "zstd/legacy/zstd_legacy.h" // DuckDB: comment out otherwise amalgamation won't be happy
-#endif
-
-
-
-/*************************************
- * Multiple DDicts Hashset internals *
- *************************************/
-
-#define DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT 4
-#define DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT 3  /* These two constants represent SIZE_MULT/COUNT_MULT load factor without using a float. */
-                                                   /* Currently, that means a 0.75 load factor. */
-                                                   /* So, if count * COUNT_MULT / size * SIZE_MULT != 0, then we've exceeded */
-                                                   /* the load factor of the ddict hash set. */
-
-#define DDICT_HASHSET_TABLE_BASE_SIZE 64
-#define DDICT_HASHSET_RESIZE_FACTOR 2
-
-namespace duckdb_zstd {
-
-/* Hash function to determine starting position of dict insertion within the table
- * Returns an index between [0, hashSet->ddictPtrTableSize]
- */
-static size_t ZSTD_DDictHashSet_getIndex(const ZSTD_DDictHashSet* hashSet, U32 dictID) {
-    const U64 hash = XXH64(&dictID, sizeof(U32), 0);
-    /* DDict ptr table size is a multiple of 2, use size - 1 as mask to get index within [0, hashSet->ddictPtrTableSize) */
-    return hash & (hashSet->ddictPtrTableSize - 1);
-}
-
-/* Adds DDict to a hashset without resizing it.
- * If inserting a DDict with a dictID that already exists in the set, replaces the one in the set.
- * Returns 0 if successful, or a zstd error code if something went wrong.
- */
-static size_t ZSTD_DDictHashSet_emplaceDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict) {
-    const U32 dictID = ZSTD_getDictID_fromDDict(ddict);
-    size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
-    const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
-    RETURN_ERROR_IF(hashSet->ddictPtrCount == hashSet->ddictPtrTableSize, GENERIC, "Hash set is full!");
-    DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx);
-    while (hashSet->ddictPtrTable[idx] != NULL) {
-        /* Replace existing ddict if inserting ddict with same dictID */
-        if (ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]) == dictID) {
-            DEBUGLOG(4, "DictID already exists, replacing rather than adding");
-            hashSet->ddictPtrTable[idx] = ddict;
-            return 0;
-        }
-        idx &= idxRangeMask;
-        idx++;
-    }
-    DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx);
-    hashSet->ddictPtrTable[idx] = ddict;
-    hashSet->ddictPtrCount++;
-    return 0;
-}
-
-/* Expands hash table by factor of DDICT_HASHSET_RESIZE_FACTOR and
- * rehashes all values, allocates new table, frees old table.
- * Returns 0 on success, otherwise a zstd error code.
- */
-static size_t ZSTD_DDictHashSet_expand(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {
-    size_t newTableSize = hashSet->ddictPtrTableSize * DDICT_HASHSET_RESIZE_FACTOR;
-    const ZSTD_DDict** newTable = (const ZSTD_DDict**)ZSTD_customCalloc(sizeof(ZSTD_DDict*) * newTableSize, customMem);
-    const ZSTD_DDict** oldTable = hashSet->ddictPtrTable;
-    size_t oldTableSize = hashSet->ddictPtrTableSize;
-    size_t i;
-
-    DEBUGLOG(4, "Expanding DDict hash table! Old size: %zu new size: %zu", oldTableSize, newTableSize);
-    RETURN_ERROR_IF(!newTable, memory_allocation, "Expanded hashset allocation failed!");
-    hashSet->ddictPtrTable = newTable;
-    hashSet->ddictPtrTableSize = newTableSize;
-    hashSet->ddictPtrCount = 0;
-    for (i = 0; i < oldTableSize; ++i) {
-        if (oldTable[i] != NULL) {
-            FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, oldTable[i]), "");
-        }
-    }
-    ZSTD_customFree((void*)oldTable, customMem);
-    DEBUGLOG(4, "Finished re-hash");
-    return 0;
-}
-
-/* Fetches a DDict with the given dictID
- * Returns the ZSTD_DDict* with the requested dictID. If it doesn't exist, then returns NULL.
- */
-static const ZSTD_DDict* ZSTD_DDictHashSet_getDDict(ZSTD_DDictHashSet* hashSet, U32 dictID) {
-    size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
-    const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
-    DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx);
-    for (;;) {
-        size_t currDictID = ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]);
-        if (currDictID == dictID || currDictID == 0) {
-            /* currDictID == 0 implies a NULL ddict entry */
-            break;
-        } else {
-            idx &= idxRangeMask;    /* Goes to start of table when we reach the end */
-            idx++;
-        }
-    }
-    DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx);
-    return hashSet->ddictPtrTable[idx];
-}
-
-/* Allocates space for and returns a ddict hash set
- * The hash set's ZSTD_DDict* table has all values automatically set to NULL to begin with.
- * Returns NULL if allocation failed.
- */
-static ZSTD_DDictHashSet* ZSTD_createDDictHashSet(ZSTD_customMem customMem) {
-    ZSTD_DDictHashSet* ret = (ZSTD_DDictHashSet*)ZSTD_customMalloc(sizeof(ZSTD_DDictHashSet), customMem);
-    DEBUGLOG(4, "Allocating new hash set");
-    if (!ret)
-        return NULL;
-    ret->ddictPtrTable = (const ZSTD_DDict**)ZSTD_customCalloc(DDICT_HASHSET_TABLE_BASE_SIZE * sizeof(ZSTD_DDict*), customMem);
-    if (!ret->ddictPtrTable) {
-        ZSTD_customFree(ret, customMem);
-        return NULL;
-    }
-    ret->ddictPtrTableSize = DDICT_HASHSET_TABLE_BASE_SIZE;
-    ret->ddictPtrCount = 0;
-    return ret;
-}
-
-/* Frees the table of ZSTD_DDict* within a hashset, then frees the hashset itself.
- * Note: The ZSTD_DDict* within the table are NOT freed.
- */
-static void ZSTD_freeDDictHashSet(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {
-    DEBUGLOG(4, "Freeing ddict hash set");
-    if (hashSet && hashSet->ddictPtrTable) {
-        ZSTD_customFree((void*)hashSet->ddictPtrTable, customMem);
-    }
-    if (hashSet) {
-        ZSTD_customFree(hashSet, customMem);
-    }
-}
-
-/* Public function: Adds a DDict into the ZSTD_DDictHashSet, possibly triggering a resize of the hash set.
- * Returns 0 on success, or a ZSTD error.
- */
-static size_t ZSTD_DDictHashSet_addDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict, ZSTD_customMem customMem) {
-    DEBUGLOG(4, "Adding dict ID: %u to hashset with - Count: %zu Tablesize: %zu", ZSTD_getDictID_fromDDict(ddict), hashSet->ddictPtrCount, hashSet->ddictPtrTableSize);
-    if (hashSet->ddictPtrCount * DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT / hashSet->ddictPtrTableSize * DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT != 0) {
-        FORWARD_IF_ERROR(ZSTD_DDictHashSet_expand(hashSet, customMem), "");
-    }
-    FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, ddict), "");
-    return 0;
-}
-
-/*-*************************************************************
-*   Context management
-***************************************************************/
-size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
-{
-    if (dctx==NULL) return 0;   /* support sizeof NULL */
-    return sizeof(*dctx)
-           + ZSTD_sizeof_DDict(dctx->ddictLocal)
-           + dctx->inBuffSize + dctx->outBuffSize;
-}
-
-size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
-
-
-static size_t ZSTD_startingInputLength(ZSTD_format_e format)
-{
-    size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);
-    /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
-    assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );
-    return startingInputLength;
-}
-
-static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)
-{
-    assert(dctx->streamStage == zdss_init);
-    dctx->format = ZSTD_f_zstd1;
-    dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
-    dctx->outBufferMode = ZSTD_bm_buffered;
-    dctx->forceIgnoreChecksum = ZSTD_d_validateChecksum;
-    dctx->refMultipleDDicts = ZSTD_rmd_refSingleDDict;
-    dctx->disableHufAsm = 0;
-    dctx->maxBlockSizeParam = 0;
-}
-
-static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
-{
-    dctx->staticSize  = 0;
-    dctx->ddict       = NULL;
-    dctx->ddictLocal  = NULL;
-    dctx->dictEnd     = NULL;
-    dctx->ddictIsCold = 0;
-    dctx->dictUses = ZSTD_dont_use;
-    dctx->inBuff      = NULL;
-    dctx->inBuffSize  = 0;
-    dctx->outBuffSize = 0;
-    dctx->streamStage = zdss_init;
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-    dctx->legacyContext = NULL;
-    dctx->previousLegacyVersion = 0;
-#endif
-    dctx->noForwardProgress = 0;
-    dctx->oversizedDuration = 0;
-    dctx->isFrameDecompression = 1;
-#if DYNAMIC_BMI2
-    dctx->bmi2 = ZSTD_cpuSupportsBmi2();
-#endif
-    dctx->ddictSet = NULL;
-    ZSTD_DCtx_resetParameters(dctx);
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    dctx->dictContentEndForFuzzing = NULL;
-#endif
-}
-
-ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
-{
-    ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
-
-    if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
-    if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL;  /* minimum size */
-
-    ZSTD_initDCtx_internal(dctx);
-    dctx->staticSize = workspaceSize;
-    dctx->inBuff = (char*)(dctx+1);
-    return dctx;
-}
-
-static ZSTD_DCtx* ZSTD_createDCtx_internal(ZSTD_customMem customMem) {
-    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
-
-    {   ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem);
-        if (!dctx) return NULL;
-        dctx->customMem = customMem;
-        ZSTD_initDCtx_internal(dctx);
-        return dctx;
-    }
-}
-
-ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
-{
-    return ZSTD_createDCtx_internal(customMem);
-}
-
-ZSTD_DCtx* ZSTD_createDCtx(void)
-{
-    DEBUGLOG(3, "ZSTD_createDCtx");
-    return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
-}
-
-static void ZSTD_clearDict(ZSTD_DCtx* dctx)
-{
-    ZSTD_freeDDict(dctx->ddictLocal);
-    dctx->ddictLocal = NULL;
-    dctx->ddict = NULL;
-    dctx->dictUses = ZSTD_dont_use;
-}
-
-size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
-{
-    if (dctx==NULL) return 0;   /* support free on NULL */
-    RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
-    {   ZSTD_customMem const cMem = dctx->customMem;
-        ZSTD_clearDict(dctx);
-        ZSTD_customFree(dctx->inBuff, cMem);
-        dctx->inBuff = NULL;
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
-        if (dctx->legacyContext)
-            ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);
-#endif
-        if (dctx->ddictSet) {
-            ZSTD_freeDDictHashSet(dctx->ddictSet, cMem);
-            dctx->ddictSet = NULL;
-        }
-        ZSTD_customFree(dctx, cMem);
-        return 0;
-    }
-}
-
-/* no longer useful */
-void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
-{
-    size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx);
-    ZSTD_memcpy(dstDCtx, srcDCtx, toCopy);  /* no need to copy workspace */
-}
-
-/* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on
- * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then
- * accordingly sets the ddict to be used to decompress the frame.
- *
- * If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is.
- *
- * ZSTD_d_refMultipleDDicts must be enabled for this function to be called.
- */
-static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
-    assert(dctx->refMultipleDDicts && dctx->ddictSet);
-    DEBUGLOG(4, "Adjusting DDict based on requested dict ID from frame");
-    if (dctx->ddict) {
-        const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(dctx->ddictSet, dctx->fParams.dictID);
-        if (frameDDict) {
-            DEBUGLOG(4, "DDict found!");
-            ZSTD_clearDict(dctx);
-            dctx->dictID = dctx->fParams.dictID;
-            dctx->ddict = frameDDict;
-            dctx->dictUses = ZSTD_use_indefinitely;
-        }
-    }
-}
-
-
-/*-*************************************************************
- *   Frame header decoding
- ***************************************************************/
-
-/*! ZSTD_isFrame() :
- *  Tells if the content of `buffer` starts with a valid Frame Identifier.
- *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
- *  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
- *  Note 3 : Skippable Frame Identifiers are considered valid. */
-unsigned ZSTD_isFrame(const void* buffer, size_t size)
-{
-    if (size < ZSTD_FRAMEIDSIZE) return 0;
-    {   U32 const magic = MEM_readLE32(buffer);
-        if (magic == ZSTD_MAGICNUMBER) return 1;
-        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
-    }
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
-    if (ZSTD_isLegacy(buffer, size)) return 1;
-#endif
-    return 0;
-}
-
-/*! ZSTD_isSkippableFrame() :
- *  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.
- *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
- */
-unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size)
-{
-    if (size < ZSTD_FRAMEIDSIZE) return 0;
-    {   U32 const magic = MEM_readLE32(buffer);
-        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
-    }
-    return 0;
-}
-
-/** ZSTD_frameHeaderSize_internal() :
- *  srcSize must be large enough to reach header size fields.
- *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless.
- * @return : size of the Frame Header
- *           or an error code, which can be tested with ZSTD_isError() */
-static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)
-{
-    size_t const minInputSize = ZSTD_startingInputLength(format);
-    RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, "");
-
-    {   BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
-        U32 const dictID= fhd & 3;
-        U32 const singleSegment = (fhd >> 5) & 1;
-        U32 const fcsId = fhd >> 6;
-        return minInputSize + !singleSegment
-             + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
-             + (singleSegment && !fcsId);
-    }
-}
-
-/** ZSTD_frameHeaderSize() :
- *  srcSize must be >= ZSTD_frameHeaderSize_prefix.
- * @return : size of the Frame Header,
- *           or an error code (if srcSize is too small) */
-size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
-{
-    return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
-}
-
-
-/** ZSTD_getFrameHeader_advanced() :
- *  decode Frame Header, or require larger `srcSize`.
- *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
- * @return : 0, `zfhPtr` is correctly filled,
- *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
-**           or an error code, which can be tested using ZSTD_isError() */
-size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
-{
-    const BYTE* ip = (const BYTE*)src;
-    size_t const minInputSize = ZSTD_startingInputLength(format);
-
-    DEBUGLOG(5, "ZSTD_getFrameHeader_advanced: minInputSize = %zu, srcSize = %zu", minInputSize, srcSize);
-
-    if (srcSize > 0) {
-        /* note : technically could be considered an assert(), since it's an invalid entry */
-        RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter : src==NULL, but srcSize>0");
-    }
-    if (srcSize < minInputSize) {
-        if (srcSize > 0 && format != ZSTD_f_zstd1_magicless) {
-            /* when receiving less than @minInputSize bytes,
-             * control these bytes at least correspond to a supported magic number
-             * in order to error out early if they don't.
-            **/
-            size_t const toCopy = MIN(4, srcSize);
-            unsigned char hbuf[4]; MEM_writeLE32(hbuf, ZSTD_MAGICNUMBER);
-            assert(src != NULL);
-            ZSTD_memcpy(hbuf, src, toCopy);
-            if ( MEM_readLE32(hbuf) != ZSTD_MAGICNUMBER ) {
-                /* not a zstd frame : let's check if it's a skippable frame */
-                MEM_writeLE32(hbuf, ZSTD_MAGIC_SKIPPABLE_START);
-                ZSTD_memcpy(hbuf, src, toCopy);
-                if ((MEM_readLE32(hbuf) & ZSTD_MAGIC_SKIPPABLE_MASK) != ZSTD_MAGIC_SKIPPABLE_START) {
-                    RETURN_ERROR(prefix_unknown,
-                                "first bytes don't correspond to any supported magic number");
-        }   }   }
-        return minInputSize;
-    }
-
-    ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));   /* not strictly necessary, but static analyzers may not understand that zfhPtr will be read only if return value is zero, since they are 2 different signals */
-    if ( (format != ZSTD_f_zstd1_magicless)
-      && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {
-        if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
-            /* skippable frame */
-            if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
-                return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
-            ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));
-            zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
-            zfhPtr->frameType = ZSTD_skippableFrame;
-            return 0;
-        }
-        RETURN_ERROR(prefix_unknown, "");
-    }
-
-    /* ensure there is enough `srcSize` to fully read/decode frame header */
-    {   size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);
-        if (srcSize < fhsize) return fhsize;
-        zfhPtr->headerSize = (U32)fhsize;
-    }
-
-    {   BYTE const fhdByte = ip[minInputSize-1];
-        size_t pos = minInputSize;
-        U32 const dictIDSizeCode = fhdByte&3;
-        U32 const checksumFlag = (fhdByte>>2)&1;
-        U32 const singleSegment = (fhdByte>>5)&1;
-        U32 const fcsID = fhdByte>>6;
-        U64 windowSize = 0;
-        U32 dictID = 0;
-        U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
-        RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
-                        "reserved bits, must be zero");
-
-        if (!singleSegment) {
-            BYTE const wlByte = ip[pos++];
-            U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
-            RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, "");
-            windowSize = (1ULL << windowLog);
-            windowSize += (windowSize >> 3) * (wlByte&7);
-        }
-        switch(dictIDSizeCode)
-        {
-            default:
-                assert(0);  /* impossible */
-                ZSTD_FALLTHROUGH;
-            case 0 : break;
-            case 1 : dictID = ip[pos]; pos++; break;
-            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
-            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
-        }
-        switch(fcsID)
-        {
-            default:
-                assert(0);  /* impossible */
-                ZSTD_FALLTHROUGH;
-            case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
-            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
-            case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
-            case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
-        }
-        if (singleSegment) windowSize = frameContentSize;
-
-        zfhPtr->frameType = ZSTD_frame;
-        zfhPtr->frameContentSize = frameContentSize;
-        zfhPtr->windowSize = windowSize;
-        zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
-        zfhPtr->dictID = dictID;
-        zfhPtr->checksumFlag = checksumFlag;
-    }
-    return 0;
-}
-
-/** ZSTD_getFrameHeader() :
- *  decode Frame Header, or require larger `srcSize`.
- *  note : this function does not consume input, it only reads it.
- * @return : 0, `zfhPtr` is correctly filled,
- *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
- *           or an error code, which can be tested using ZSTD_isError() */
-size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize)
-{
-    return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);
-}
-
-/** ZSTD_getFrameContentSize() :
- *  compatible with legacy mode
- * @return : decompressed size of the single frame pointed to be `src` if known, otherwise
- *         - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
- *         - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
-unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
-{
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
-    if (ZSTD_isLegacy(src, srcSize)) {
-        unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize);
-        return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret;
-    }
-#endif
-    {   ZSTD_frameHeader zfh;
-        if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0)
-            return ZSTD_CONTENTSIZE_ERROR;
-        if (zfh.frameType == ZSTD_skippableFrame) {
-            return 0;
-        } else {
-            return zfh.frameContentSize;
-    }   }
-}
-
-static size_t readSkippableFrameSize(void const* src, size_t srcSize)
-{
-    size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
-    U32 sizeU32;
-
-    RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
-
-    sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
-    RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,
-                    frameParameter_unsupported, "");
-    {   size_t const skippableSize = skippableHeaderSize + sizeU32;
-        RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, "");
-        return skippableSize;
-    }
-}
-
-/*! ZSTD_readSkippableFrame() :
- * Retrieves content of a skippable frame, and writes it to dst buffer.
- *
- * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written,
- * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START.  This can be NULL if the caller is not interested
- * in the magicVariant.
- *
- * Returns an error if destination buffer is not large enough, or if this is not a valid skippable frame.
- *
- * @return : number of bytes written or a ZSTD error.
- */
-size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity,
-                               unsigned* magicVariant,  /* optional, can be NULL */
-                         const void* src, size_t srcSize)
-{
-    RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
-
-    {   U32 const magicNumber = MEM_readLE32(src);
-        size_t skippableFrameSize = readSkippableFrameSize(src, srcSize);
-        size_t skippableContentSize = skippableFrameSize - ZSTD_SKIPPABLEHEADERSIZE;
-
-        /* check input validity */
-        RETURN_ERROR_IF(!ZSTD_isSkippableFrame(src, srcSize), frameParameter_unsupported, "");
-        RETURN_ERROR_IF(skippableFrameSize < ZSTD_SKIPPABLEHEADERSIZE || skippableFrameSize > srcSize, srcSize_wrong, "");
-        RETURN_ERROR_IF(skippableContentSize > dstCapacity, dstSize_tooSmall, "");
-
-        /* deliver payload */
-        if (skippableContentSize > 0  && dst != NULL)
-            ZSTD_memcpy(dst, (const BYTE *)src + ZSTD_SKIPPABLEHEADERSIZE, skippableContentSize);
-        if (magicVariant != NULL)
-            *magicVariant = magicNumber - ZSTD_MAGIC_SKIPPABLE_START;
-        return skippableContentSize;
-    }
-}
-
-/** ZSTD_findDecompressedSize() :
- *  `srcSize` must be the exact length of some number of ZSTD compressed and/or
- *      skippable frames
- *  note: compatible with legacy mode
- * @return : decompressed size of the frames contained */
-unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
-{
-    unsigned long long totalDstSize = 0;
-
-    while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) {
-        U32 const magicNumber = MEM_readLE32(src);
-
-        if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
-            size_t const skippableSize = readSkippableFrameSize(src, srcSize);
-            if (ZSTD_isError(skippableSize)) return ZSTD_CONTENTSIZE_ERROR;
-            assert(skippableSize <= srcSize);
-
-            src = (const BYTE *)src + skippableSize;
-            srcSize -= skippableSize;
-            continue;
-        }
-
-        {   unsigned long long const fcs = ZSTD_getFrameContentSize(src, srcSize);
-            if (fcs >= ZSTD_CONTENTSIZE_ERROR) return fcs;
-
-            if (totalDstSize + fcs < totalDstSize)
-                return ZSTD_CONTENTSIZE_ERROR; /* check for overflow */
-            totalDstSize += fcs;
-        }
-        /* skip to next frame */
-        {   size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize);
-            if (ZSTD_isError(frameSrcSize)) return ZSTD_CONTENTSIZE_ERROR;
-            assert(frameSrcSize <= srcSize);
-
-            src = (const BYTE *)src + frameSrcSize;
-            srcSize -= frameSrcSize;
-        }
-    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
-
-    if (srcSize) return ZSTD_CONTENTSIZE_ERROR;
-
-    return totalDstSize;
-}
-
-/** ZSTD_getDecompressedSize() :
- *  compatible with legacy mode
- * @return : decompressed size if known, 0 otherwise
-             note : 0 can mean any of the following :
-                   - frame content is empty
-                   - decompressed size field is not present in frame header
-                   - frame header unknown / not supported
-                   - frame header not complete (`srcSize` too small) */
-unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
-{
-    unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
-    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
-    return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
-}
-
-
-/** ZSTD_decodeFrameHeader() :
- * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
- * If multiple DDict references are enabled, also will choose the correct DDict to use.
- * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
-static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
-{
-    size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
-    if (ZSTD_isError(result)) return result;    /* invalid header */
-    RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
-
-    /* Reference DDict requested by frame if dctx references multiple ddicts */
-    if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) {
-        ZSTD_DCtx_selectFrameDDict(dctx);
-    }
-
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    /* Skip the dictID check in fuzzing mode, because it makes the search
-     * harder.
-     */
-    RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
-                    dictionary_wrong, "");
-#endif
-    dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0;
-    if (dctx->validateChecksum) XXH64_reset(&dctx->xxhState, 0);
-    dctx->processedCSize += headerSize;
-    return 0;
-}
-
-static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
-{
-    ZSTD_frameSizeInfo frameSizeInfo;
-    frameSizeInfo.compressedSize = ret;
-    frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
-    return frameSizeInfo;
-}
-
-static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize, ZSTD_format_e format)
-{
-    ZSTD_frameSizeInfo frameSizeInfo;
-    ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
-
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
-    if (format == ZSTD_f_zstd1 && ZSTD_isLegacy(src, srcSize))
-        return ZSTD_findFrameSizeInfoLegacy(src, srcSize);
-#endif
-
-    if (format == ZSTD_f_zstd1 && (srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
-        && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
-        frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
-        assert(ZSTD_isError(frameSizeInfo.compressedSize) ||
-               frameSizeInfo.compressedSize <= srcSize);
-        return frameSizeInfo;
-    } else {
-        const BYTE* ip = (const BYTE*)src;
-        const BYTE* const ipstart = ip;
-        size_t remainingSize = srcSize;
-        size_t nbBlocks = 0;
-        ZSTD_frameHeader zfh;
-
-        /* Extract Frame Header */
-        {   size_t const ret = ZSTD_getFrameHeader_advanced(&zfh, src, srcSize, format);
-            if (ZSTD_isError(ret))
-                return ZSTD_errorFrameSizeInfo(ret);
-            if (ret > 0)
-                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
-        }
-
-        ip += zfh.headerSize;
-        remainingSize -= zfh.headerSize;
-
-        /* Iterate over each block */
-        while (1) {
-            blockProperties_t blockProperties;
-            size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
-            if (ZSTD_isError(cBlockSize))
-                return ZSTD_errorFrameSizeInfo(cBlockSize);
-
-            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
-                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
-
-            ip += ZSTD_blockHeaderSize + cBlockSize;
-            remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
-            nbBlocks++;
-
-            if (blockProperties.lastBlock) break;
-        }
-
-        /* Final frame content checksum */
-        if (zfh.checksumFlag) {
-            if (remainingSize < 4)
-                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
-            ip += 4;
-        }
-
-        frameSizeInfo.nbBlocks = nbBlocks;
-        frameSizeInfo.compressedSize = (size_t)(ip - ipstart);
-        frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
-                                        ? zfh.frameContentSize
-                                        : (unsigned long long)nbBlocks * zfh.blockSizeMax;
-        return frameSizeInfo;
-    }
-}
-
-static size_t ZSTD_findFrameCompressedSize_advanced(const void *src, size_t srcSize, ZSTD_format_e format) {
-    ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, format);
-    return frameSizeInfo.compressedSize;
-}
-
-/** ZSTD_findFrameCompressedSize() :
- * See docs in zstd.h
- * Note: compatible with legacy mode */
-size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
-{
-    return ZSTD_findFrameCompressedSize_advanced(src, srcSize, ZSTD_f_zstd1);
-}
-
-/** ZSTD_decompressBound() :
- *  compatible with legacy mode
- *  `src` must point to the start of a ZSTD frame or a skippeable frame
- *  `srcSize` must be at least as large as the frame contained
- *  @return : the maximum decompressed size of the compressed source
- */
-unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
-{
-    unsigned long long bound = 0;
-    /* Iterate over each frame */
-    while (srcSize > 0) {
-        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, ZSTD_f_zstd1);
-        size_t const compressedSize = frameSizeInfo.compressedSize;
-        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
-        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
-            return ZSTD_CONTENTSIZE_ERROR;
-        assert(srcSize >= compressedSize);
-        src = (const BYTE*)src + compressedSize;
-        srcSize -= compressedSize;
-        bound += decompressedBound;
-    }
-    return bound;
-}
-
-size_t ZSTD_decompressionMargin(void const* src, size_t srcSize)
-{
-    size_t margin = 0;
-    unsigned maxBlockSize = 0;
-
-    /* Iterate over each frame */
-    while (srcSize > 0) {
-        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, ZSTD_f_zstd1);
-        size_t const compressedSize = frameSizeInfo.compressedSize;
-        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
-        ZSTD_frameHeader zfh;
-
-        FORWARD_IF_ERROR(ZSTD_getFrameHeader(&zfh, src, srcSize), "");
-        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
-            return ERROR(corruption_detected);
-
-        if (zfh.frameType == ZSTD_frame) {
-            /* Add the frame header to our margin */
-            margin += zfh.headerSize;
-            /* Add the checksum to our margin */
-            margin += zfh.checksumFlag ? 4 : 0;
-            /* Add 3 bytes per block */
-            margin += 3 * frameSizeInfo.nbBlocks;
-
-            /* Compute the max block size */
-            maxBlockSize = MAX(maxBlockSize, zfh.blockSizeMax);
-        } else {
-            assert(zfh.frameType == ZSTD_skippableFrame);
-            /* Add the entire skippable frame size to our margin. */
-            margin += compressedSize;
-        }
-
-        assert(srcSize >= compressedSize);
-        src = (const BYTE*)src + compressedSize;
-        srcSize -= compressedSize;
-    }
-
-    /* Add the max block size back to the margin. */
-    margin += maxBlockSize;
-
-    return margin;
-}
-
-/*-*************************************************************
- *   Frame decoding
- ***************************************************************/
-
-/** ZSTD_insertBlock() :
- *  insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
-size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
-{
-    DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
-    ZSTD_checkContinuity(dctx, blockStart, blockSize);
-    dctx->previousDstEnd = (const char*)blockStart + blockSize;
-    return blockSize;
-}
-
-
-static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
-                          const void* src, size_t srcSize)
-{
-    DEBUGLOG(5, "ZSTD_copyRawBlock");
-    RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
-    if (dst == NULL) {
-        if (srcSize == 0) return 0;
-        RETURN_ERROR(dstBuffer_null, "");
-    }
-    ZSTD_memmove(dst, src, srcSize);
-    return srcSize;
-}
-
-static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
-                               BYTE b,
-                               size_t regenSize)
-{
-    RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, "");
-    if (dst == NULL) {
-        if (regenSize == 0) return 0;
-        RETURN_ERROR(dstBuffer_null, "");
-    }
-    ZSTD_memset(dst, b, regenSize);
-    return regenSize;
-}
-
-static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming)
-{
-#if ZSTD_TRACE
-    if (dctx->traceCtx && ZSTD_trace_decompress_end != NULL) {
-        ZSTD_Trace trace;
-        ZSTD_memset(&trace, 0, sizeof(trace));
-        trace.version = ZSTD_VERSION_NUMBER;
-        trace.streaming = streaming;
-        if (dctx->ddict) {
-            trace.dictionaryID = ZSTD_getDictID_fromDDict(dctx->ddict);
-            trace.dictionarySize = ZSTD_DDict_dictSize(dctx->ddict);
-            trace.dictionaryIsCold = dctx->ddictIsCold;
-        }
-        trace.uncompressedSize = (size_t)uncompressedSize;
-        trace.compressedSize = (size_t)compressedSize;
-        trace.dctx = dctx;
-        ZSTD_trace_decompress_end(dctx->traceCtx, &trace);
-    }
-#else
-    (void)dctx;
-    (void)uncompressedSize;
-    (void)compressedSize;
-    (void)streaming;
-#endif
-}
-
-
-/*! ZSTD_decompressFrame() :
- * @dctx must be properly initialized
- *  will update *srcPtr and *srcSizePtr,
- *  to make *srcPtr progress by one frame. */
-static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
-                                   void* dst, size_t dstCapacity,
-                             const void** srcPtr, size_t *srcSizePtr)
-{
-    const BYTE* const istart = (const BYTE*)(*srcPtr);
-    const BYTE* ip = istart;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;
-    BYTE* op = ostart;
-    size_t remainingSrcSize = *srcSizePtr;
-
-    DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
-
-    /* check */
-    RETURN_ERROR_IF(
-        remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
-        srcSize_wrong, "");
-
-    /* Frame Header */
-    {   size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(
-                ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);
-        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
-        RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
-                        srcSize_wrong, "");
-        FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
-        ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
-    }
-
-    /* Shrink the blockSizeMax if enabled */
-    if (dctx->maxBlockSizeParam != 0)
-        dctx->fParams.blockSizeMax = MIN(dctx->fParams.blockSizeMax, (unsigned)dctx->maxBlockSizeParam);
-
-    /* Loop on each block */
-    while (1) {
-        BYTE* oBlockEnd = oend;
-        size_t decodedSize;
-        blockProperties_t blockProperties;
-        size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
-        if (ZSTD_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSrcSize -= ZSTD_blockHeaderSize;
-        RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");
-
-        if (ip >= op && ip < oBlockEnd) {
-            /* We are decompressing in-place. Limit the output pointer so that we
-             * don't overwrite the block that we are currently reading. This will
-             * fail decompression if the input & output pointers aren't spaced
-             * far enough apart.
-             *
-             * This is important to set, even when the pointers are far enough
-             * apart, because ZSTD_decompressBlock_internal() can decide to store
-             * literals in the output buffer, after the block it is decompressing.
-             * Since we don't want anything to overwrite our input, we have to tell
-             * ZSTD_decompressBlock_internal to never write past ip.
-             *
-             * See ZSTD_allocateLiteralsBuffer() for reference.
-             */
-            oBlockEnd = op + (ip - op);
-        }
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            assert(dctx->isFrameDecompression == 1);
-            decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oBlockEnd-op), ip, cBlockSize, not_streaming);
-            break;
-        case bt_raw :
-            /* Use oend instead of oBlockEnd because this function is safe to overlap. It uses memmove. */
-            decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize);
-            break;
-        case bt_rle :
-            decodedSize = ZSTD_setRleBlock(op, (size_t)(oBlockEnd-op), *ip, blockProperties.origSize);
-            break;
-        case bt_reserved :
-        default:
-            RETURN_ERROR(corruption_detected, "invalid block type");
-        }
-        FORWARD_IF_ERROR(decodedSize, "Block decompression failure");
-        DEBUGLOG(5, "Decompressed block of dSize = %u", (unsigned)decodedSize);
-        if (dctx->validateChecksum) {
-            XXH64_update(&dctx->xxhState, op, decodedSize);
-        }
-        if (decodedSize) /* support dst = NULL,0 */ {
-            op += decodedSize;
-        }
-        assert(ip != NULL);
-        ip += cBlockSize;
-        remainingSrcSize -= cBlockSize;
-        if (blockProperties.lastBlock) break;
-    }
-
-    if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-        RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
-                        corruption_detected, "");
-    }
-    if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
-        RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, "");
-        if (!dctx->forceIgnoreChecksum) {
-            U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);
-            U32 checkRead;
-            checkRead = MEM_readLE32(ip);
-            RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, "");
-        }
-        ip += 4;
-        remainingSrcSize -= 4;
-    }
-    ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);
-    /* Allow caller to get size read */
-    DEBUGLOG(4, "ZSTD_decompressFrame: decompressed frame of size %zi, consuming %zi bytes of input", op-ostart, ip - (const BYTE*)*srcPtr);
-    *srcPtr = ip;
-    *srcSizePtr = remainingSrcSize;
-    return (size_t)(op-ostart);
-}
-
-static
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
-                                        void* dst, size_t dstCapacity,
-                                  const void* src, size_t srcSize,
-                                  const void* dict, size_t dictSize,
-                                  const ZSTD_DDict* ddict)
-{
-    void* const dststart = dst;
-    int moreThan1Frame = 0;
-
-    DEBUGLOG(5, "ZSTD_decompressMultiFrame");
-    assert(dict==NULL || ddict==NULL);  /* either dict or ddict set, not both */
-
-    if (ddict) {
-        dict = ZSTD_DDict_dictContent(ddict);
-        dictSize = ZSTD_DDict_dictSize(ddict);
-    }
-
-    while (srcSize >= ZSTD_startingInputLength(dctx->format)) {
-
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
-        if (dctx->format == ZSTD_f_zstd1 && ZSTD_isLegacy(src, srcSize)) {
-            size_t decodedSize;
-            size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
-            if (ZSTD_isError(frameSize)) return frameSize;
-            RETURN_ERROR_IF(dctx->staticSize, memory_allocation,
-                "legacy support is not compatible with static dctx");
-
-            decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
-            if (ZSTD_isError(decodedSize)) return decodedSize;
-
-            {
-                unsigned long long const expectedSize = ZSTD_getFrameContentSize(src, srcSize);
-                RETURN_ERROR_IF(expectedSize == ZSTD_CONTENTSIZE_ERROR, corruption_detected, "Corrupted frame header!");
-                if (expectedSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-                    RETURN_ERROR_IF(expectedSize != decodedSize, corruption_detected,
-                        "Frame header size does not match decoded size!");
-                }
-            }
-
-            assert(decodedSize <= dstCapacity);
-            dst = (BYTE*)dst + decodedSize;
-            dstCapacity -= decodedSize;
-
-            src = (const BYTE*)src + frameSize;
-            srcSize -= frameSize;
-
-            continue;
-        }
-#endif
-
-        if (dctx->format == ZSTD_f_zstd1 && srcSize >= 4) {
-            U32 const magicNumber = MEM_readLE32(src);
-            DEBUGLOG(5, "reading magic number %08X", (unsigned)magicNumber);
-            if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
-                /* skippable frame detected : skip it */
-                size_t const skippableSize = readSkippableFrameSize(src, srcSize);
-                FORWARD_IF_ERROR(skippableSize, "invalid skippable frame");
-                assert(skippableSize <= srcSize);
-
-                src = (const BYTE *)src + skippableSize;
-                srcSize -= skippableSize;
-                continue; /* check next frame */
-        }   }
-
-        if (ddict) {
-            /* we were called from ZSTD_decompress_usingDDict */
-            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), "");
-        } else {
-            /* this will initialize correctly with no dict if dict == NULL, so
-             * use this in all cases but ddict */
-            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), "");
-        }
-        ZSTD_checkContinuity(dctx, dst, dstCapacity);
-
-        {   const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
-                                                    &src, &srcSize);
-            RETURN_ERROR_IF(
-                (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
-             && (moreThan1Frame==1),
-                srcSize_wrong,
-                "At least one frame successfully completed, "
-                "but following bytes are garbage: "
-                "it's more likely to be a srcSize error, "
-                "specifying more input bytes than size of frame(s). "
-                "Note: one could be unlucky, it might be a corruption error instead, "
-                "happening right at the place where we expect zstd magic bytes. "
-                "But this is _much_ less likely than a srcSize field error.");
-            if (ZSTD_isError(res)) return res;
-            assert(res <= dstCapacity);
-            if (res != 0)
-                dst = (BYTE*)dst + res;
-            dstCapacity -= res;
-        }
-        moreThan1Frame = 1;
-    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
-
-    RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");
-
-    return (size_t)((BYTE*)dst - (BYTE*)dststart);
-}
-
-size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
-                           const void* src, size_t srcSize,
-                           const void* dict, size_t dictSize)
-{
-    return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
-}
-
-
-static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
-{
-    switch (dctx->dictUses) {
-    default:
-        assert(0 /* Impossible */);
-        ZSTD_FALLTHROUGH;
-    case ZSTD_dont_use:
-        ZSTD_clearDict(dctx);
-        return NULL;
-    case ZSTD_use_indefinitely:
-        return dctx->ddict;
-    case ZSTD_use_once:
-        dctx->dictUses = ZSTD_dont_use;
-        return dctx->ddict;
-    }
-}
-
-size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
-}
-
-
-size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
-    size_t regenSize;
-    ZSTD_DCtx* const dctx =  ZSTD_createDCtx_internal(ZSTD_defaultCMem);
-    RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
-    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
-    ZSTD_freeDCtx(dctx);
-    return regenSize;
-#else   /* stack mode */
-    ZSTD_DCtx dctx;
-    ZSTD_initDCtx_internal(&dctx);
-    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
-#endif
-}
-
-
-/*-**************************************
-*   Advanced Streaming Decompression API
-*   Bufferless and synchronous
-****************************************/
-size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
-
-/**
- * Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed, we
- * allow taking a partial block as the input. Currently only raw uncompressed blocks can
- * be streamed.
- *
- * For blocks that can be streamed, this allows us to reduce the latency until we produce
- * output, and avoid copying the input.
- *
- * @param inputSize - The total amount of input that the caller currently has.
- */
-static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {
-    if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock))
-        return dctx->expected;
-    if (dctx->bType != bt_raw)
-        return dctx->expected;
-    return BOUNDED(1, inputSize, dctx->expected);
-}
-
-ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
-    switch(dctx->stage)
-    {
-    default:   /* should not happen */
-        assert(0);
-        ZSTD_FALLTHROUGH;
-    case ZSTDds_getFrameHeaderSize:
-        ZSTD_FALLTHROUGH;
-    case ZSTDds_decodeFrameHeader:
-        return ZSTDnit_frameHeader;
-    case ZSTDds_decodeBlockHeader:
-        return ZSTDnit_blockHeader;
-    case ZSTDds_decompressBlock:
-        return ZSTDnit_block;
-    case ZSTDds_decompressLastBlock:
-        return ZSTDnit_lastBlock;
-    case ZSTDds_checkChecksum:
-        return ZSTDnit_checksum;
-    case ZSTDds_decodeSkippableHeader:
-        ZSTD_FALLTHROUGH;
-    case ZSTDds_skipFrame:
-        return ZSTDnit_skippableFrame;
-    }
-}
-
-static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
-
-/** ZSTD_decompressContinue() :
- *  srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
- *  @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
- *            or an error code, which can be tested using ZSTD_isError() */
-size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
-    /* Sanity check */
-    RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
-    ZSTD_checkContinuity(dctx, dst, dstCapacity);
-
-    dctx->processedCSize += srcSize;
-
-    switch (dctx->stage)
-    {
-    case ZSTDds_getFrameHeaderSize :
-        assert(src != NULL);
-        if (dctx->format == ZSTD_f_zstd1) {  /* allows header */
-            assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */
-            if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */
-                ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
-                dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize;  /* remaining to load to get full skippable frame header */
-                dctx->stage = ZSTDds_decodeSkippableHeader;
-                return 0;
-        }   }
-        dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
-        if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
-        ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
-        dctx->expected = dctx->headerSize - srcSize;
-        dctx->stage = ZSTDds_decodeFrameHeader;
-        return 0;
-
-    case ZSTDds_decodeFrameHeader:
-        assert(src != NULL);
-        ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
-        FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), "");
-        dctx->expected = ZSTD_blockHeaderSize;
-        dctx->stage = ZSTDds_decodeBlockHeader;
-        return 0;
-
-    case ZSTDds_decodeBlockHeader:
-        {   blockProperties_t bp;
-            size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-            if (ZSTD_isError(cBlockSize)) return cBlockSize;
-            RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
-            dctx->expected = cBlockSize;
-            dctx->bType = bp.blockType;
-            dctx->rleSize = bp.origSize;
-            if (cBlockSize) {
-                dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
-                return 0;
-            }
-            /* empty block */
-            if (bp.lastBlock) {
-                if (dctx->fParams.checksumFlag) {
-                    dctx->expected = 4;
-                    dctx->stage = ZSTDds_checkChecksum;
-                } else {
-                    dctx->expected = 0; /* end of frame */
-                    dctx->stage = ZSTDds_getFrameHeaderSize;
-                }
-            } else {
-                dctx->expected = ZSTD_blockHeaderSize;  /* jump to next header */
-                dctx->stage = ZSTDds_decodeBlockHeader;
-            }
-            return 0;
-        }
-
-    case ZSTDds_decompressLastBlock:
-    case ZSTDds_decompressBlock:
-        DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
-        {   size_t rSize;
-            switch(dctx->bType)
-            {
-            case bt_compressed:
-                DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
-                assert(dctx->isFrameDecompression == 1);
-                rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, is_streaming);
-                dctx->expected = 0;  /* Streaming not supported */
-                break;
-            case bt_raw :
-                assert(srcSize <= dctx->expected);
-                rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
-                FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed");
-                assert(rSize == srcSize);
-                dctx->expected -= rSize;
-                break;
-            case bt_rle :
-                rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
-                dctx->expected = 0;  /* Streaming not supported */
-                break;
-            case bt_reserved :   /* should never happen */
-            default:
-                RETURN_ERROR(corruption_detected, "invalid block type");
-            }
-            FORWARD_IF_ERROR(rSize, "");
-            RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
-            DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
-            dctx->decodedSize += rSize;
-            if (dctx->validateChecksum) XXH64_update(&dctx->xxhState, dst, rSize);
-            dctx->previousDstEnd = (char*)dst + rSize;
-
-            /* Stay on the same stage until we are finished streaming the block. */
-            if (dctx->expected > 0) {
-                return rSize;
-            }
-
-            if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */
-                DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
-                RETURN_ERROR_IF(
-                    dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
-                 && dctx->decodedSize != dctx->fParams.frameContentSize,
-                    corruption_detected, "");
-                if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */
-                    dctx->expected = 4;
-                    dctx->stage = ZSTDds_checkChecksum;
-                } else {
-                    ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
-                    dctx->expected = 0;   /* ends here */
-                    dctx->stage = ZSTDds_getFrameHeaderSize;
-                }
-            } else {
-                dctx->stage = ZSTDds_decodeBlockHeader;
-                dctx->expected = ZSTD_blockHeaderSize;
-            }
-            return rSize;
-        }
-
-    case ZSTDds_checkChecksum:
-        assert(srcSize == 4);  /* guaranteed by dctx->expected */
-        {
-            if (dctx->validateChecksum) {
-                U32 const h32 = (U32)XXH64_digest(&dctx->xxhState);
-                U32 const check32 = MEM_readLE32(src);
-                DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
-                RETURN_ERROR_IF(check32 != h32, checksum_wrong, "");
-            }
-            ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
-            dctx->expected = 0;
-            dctx->stage = ZSTDds_getFrameHeaderSize;
-            return 0;
-        }
-
-    case ZSTDds_decodeSkippableHeader:
-        assert(src != NULL);
-        assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
-        assert(dctx->format != ZSTD_f_zstd1_magicless);
-        ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize);   /* complete skippable header */
-        dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE);   /* note : dctx->expected can grow seriously large, beyond local buffer size */
-        dctx->stage = ZSTDds_skipFrame;
-        return 0;
-
-    case ZSTDds_skipFrame:
-        dctx->expected = 0;
-        dctx->stage = ZSTDds_getFrameHeaderSize;
-        return 0;
-
-    default:
-        assert(0);   /* impossible */
-        RETURN_ERROR(GENERIC, "impossible to reach");   /* some compilers require default to do something */
-    }
-}
-
-
-static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    dctx->dictEnd = dctx->previousDstEnd;
-    dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
-    dctx->prefixStart = dict;
-    dctx->previousDstEnd = (const char*)dict + dictSize;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    dctx->dictContentBeginForFuzzing = dctx->prefixStart;
-    dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
-#endif
-    return 0;
-}
-
-/*! ZSTD_loadDEntropy() :
- *  dict : must point at beginning of a valid zstd dictionary.
- * @return : size of entropy tables read */
-size_t
-ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
-                  const void* const dict, size_t const dictSize)
-{
-    const BYTE* dictPtr = (const BYTE*)dict;
-    const BYTE* const dictEnd = dictPtr + dictSize;
-
-    RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
-    assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */
-    dictPtr += 8;   /* skip header = magic + dictID */
-
-    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
-    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
-    ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
-    {   void* const workspace = &entropy->LLTable;   /* use fse tables as temporary workspace; implies fse tables are grouped together */
-        size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
-#ifdef HUF_FORCE_DECOMPRESS_X1
-        /* in minimal huffman, we always use X1 variants */
-        size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
-                                                dictPtr, dictEnd - dictPtr,
-                                                workspace, workspaceSize, /* flags */ 0);
-#else
-        size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
-                                                dictPtr, (size_t)(dictEnd - dictPtr),
-                                                workspace, workspaceSize, /* flags */ 0);
-#endif
-        RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
-        dictPtr += hSize;
-    }
-
-    {   short offcodeNCount[MaxOff+1];
-        unsigned offcodeMaxValue = MaxOff, offcodeLog;
-        size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));
-        RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
-        RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, "");
-        RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
-        ZSTD_buildFSETable( entropy->OFTable,
-                            offcodeNCount, offcodeMaxValue,
-                            OF_base, OF_bits,
-                            offcodeLog,
-                            entropy->workspace, sizeof(entropy->workspace),
-                            /* bmi2 */0);
-        dictPtr += offcodeHeaderSize;
-    }
-
-    {   short matchlengthNCount[MaxML+1];
-        unsigned matchlengthMaxValue = MaxML, matchlengthLog;
-        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
-        RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
-        RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, "");
-        RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
-        ZSTD_buildFSETable( entropy->MLTable,
-                            matchlengthNCount, matchlengthMaxValue,
-                            ML_base, ML_bits,
-                            matchlengthLog,
-                            entropy->workspace, sizeof(entropy->workspace),
-                            /* bmi2 */ 0);
-        dictPtr += matchlengthHeaderSize;
-    }
-
-    {   short litlengthNCount[MaxLL+1];
-        unsigned litlengthMaxValue = MaxLL, litlengthLog;
-        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
-        RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
-        RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, "");
-        RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
-        ZSTD_buildFSETable( entropy->LLTable,
-                            litlengthNCount, litlengthMaxValue,
-                            LL_base, LL_bits,
-                            litlengthLog,
-                            entropy->workspace, sizeof(entropy->workspace),
-                            /* bmi2 */ 0);
-        dictPtr += litlengthHeaderSize;
-    }
-
-    RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
-    {   int i;
-        size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
-        for (i=0; i<3; i++) {
-            U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;
-            RETURN_ERROR_IF(rep==0 || rep > dictContentSize,
-                            dictionary_corrupted, "");
-            entropy->rep[i] = rep;
-    }   }
-
-    return (size_t)(dictPtr - (const BYTE*)dict);
-}
-
-static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
-    {   U32 const magic = MEM_readLE32(dict);
-        if (magic != ZSTD_MAGIC_DICTIONARY) {
-            return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */
-    }   }
-    dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
-
-    /* load entropy tables */
-    {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
-        RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
-        dict = (const char*)dict + eSize;
-        dictSize -= eSize;
-    }
-    dctx->litEntropy = dctx->fseEntropy = 1;
-
-    /* reference dictionary content */
-    return ZSTD_refDictContent(dctx, dict, dictSize);
-}
-
-size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
-{
-    assert(dctx != NULL);
-#if ZSTD_TRACE
-    dctx->traceCtx = (ZSTD_trace_decompress_begin != NULL) ? ZSTD_trace_decompress_begin(dctx) : 0;
-#endif
-    dctx->expected = ZSTD_startingInputLength(dctx->format);  /* dctx->format must be properly set */
-    dctx->stage = ZSTDds_getFrameHeaderSize;
-    dctx->processedCSize = 0;
-    dctx->decodedSize = 0;
-    dctx->previousDstEnd = NULL;
-    dctx->prefixStart = NULL;
-    dctx->virtualStart = NULL;
-    dctx->dictEnd = NULL;
-    dctx->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001);  /* cover both little and big endian */
-    dctx->litEntropy = dctx->fseEntropy = 0;
-    dctx->dictID = 0;
-    dctx->bType = bt_reserved;
-    dctx->isFrameDecompression = 1;
-    ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
-    ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue));  /* initial repcodes */
-    dctx->LLTptr = dctx->entropy.LLTable;
-    dctx->MLTptr = dctx->entropy.MLTable;
-    dctx->OFTptr = dctx->entropy.OFTable;
-    dctx->HUFptr = dctx->entropy.hufTable;
-    return 0;
-}
-
-size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
-    if (dict && dictSize)
-        RETURN_ERROR_IF(
-            ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
-            dictionary_corrupted, "");
-    return 0;
-}
-
-
-/* ======   ZSTD_DDict   ====== */
-
-size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
-{
-    DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
-    assert(dctx != NULL);
-    if (ddict) {
-        const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
-        size_t const dictSize = ZSTD_DDict_dictSize(ddict);
-        const void* const dictEnd = dictStart + dictSize;
-        dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
-        DEBUGLOG(4, "DDict is %s",
-                    dctx->ddictIsCold ? "~cold~" : "hot!");
-    }
-    FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
-    if (ddict) {   /* NULL ddict is equivalent to no dictionary */
-        ZSTD_copyDDictParameters(dctx, ddict);
-    }
-    return 0;
-}
-
-/*! ZSTD_getDictID_fromDict() :
- *  Provides the dictID stored within dictionary.
- *  if @return == 0, the dictionary is not conformant with Zstandard specification.
- *  It can still be loaded, but as a content-only dictionary. */
-unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
-{
-    if (dictSize < 8) return 0;
-    if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
-    return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
-}
-
-/*! ZSTD_getDictID_fromFrame() :
- *  Provides the dictID required to decompress frame stored within `src`.
- *  If @return == 0, the dictID could not be decoded.
- *  This could for one of the following reasons :
- *  - The frame does not require a dictionary (most common case).
- *  - The frame was built with dictID intentionally removed.
- *    Needed dictionary is a hidden piece of information.
- *    Note : this use case also happens when using a non-conformant dictionary.
- *  - `srcSize` is too small, and as a result, frame header could not be decoded.
- *    Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.
- *  - This is not a Zstandard frame.
- *  When identifying the exact failure cause, it's possible to use
- *  ZSTD_getFrameHeader(), which will provide a more precise error code. */
-unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
-{
-    ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0, 0, 0 };
-    size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);
-    if (ZSTD_isError(hError)) return 0;
-    return zfp.dictID;
-}
-
-
-/*! ZSTD_decompress_usingDDict() :
-*   Decompression using a pre-digested Dictionary
-*   Use dictionary without significant overhead. */
-size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
-                                  void* dst, size_t dstCapacity,
-                            const void* src, size_t srcSize,
-                            const ZSTD_DDict* ddict)
-{
-    /* pass content and size in case legacy frames are encountered */
-    return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
-                                     NULL, 0,
-                                     ddict);
-}
-
-
-/*=====================================
-*   Streaming decompression
-*====================================*/
-
-ZSTD_DStream* ZSTD_createDStream(void)
-{
-    DEBUGLOG(3, "ZSTD_createDStream");
-    return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
-}
-
-ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
-{
-    return ZSTD_initStaticDCtx(workspace, workspaceSize);
-}
-
-ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
-{
-    return ZSTD_createDCtx_internal(customMem);
-}
-
-size_t ZSTD_freeDStream(ZSTD_DStream* zds)
-{
-    return ZSTD_freeDCtx(zds);
-}
-
-
-/* ***  Initialization  *** */
-
-size_t ZSTD_DStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
-size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
-
-size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
-                                   const void* dict, size_t dictSize,
-                                         ZSTD_dictLoadMethod_e dictLoadMethod,
-                                         ZSTD_dictContentType_e dictContentType)
-{
-    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    ZSTD_clearDict(dctx);
-    if (dict && dictSize != 0) {
-        dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
-        RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
-        dctx->ddict = dctx->ddictLocal;
-        dctx->dictUses = ZSTD_use_indefinitely;
-    }
-    return 0;
-}
-
-size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
-}
-
-size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
-}
-
-size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
-{
-    FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
-    dctx->dictUses = ZSTD_use_once;
-    return 0;
-}
-
-size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
-{
-    return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
-}
-
-
-/* ZSTD_initDStream_usingDict() :
- * return : expected size, aka ZSTD_startingInputLength().
- * this function cannot fail */
-size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
-{
-    DEBUGLOG(4, "ZSTD_initDStream_usingDict");
-    FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , "");
-    return ZSTD_startingInputLength(zds->format);
-}
-
-/* note : this variant can't fail */
-size_t ZSTD_initDStream(ZSTD_DStream* zds)
-{
-    DEBUGLOG(4, "ZSTD_initDStream");
-    FORWARD_IF_ERROR(ZSTD_DCtx_reset(zds, ZSTD_reset_session_only), "");
-    FORWARD_IF_ERROR(ZSTD_DCtx_refDDict(zds, NULL), "");
-    return ZSTD_startingInputLength(zds->format);
-}
-
-/* ZSTD_initDStream_usingDDict() :
- * ddict will just be referenced, and must outlive decompression session
- * this function cannot fail */
-size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
-{
-    DEBUGLOG(4, "ZSTD_initDStream_usingDDict");
-    FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , "");
-    FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , "");
-    return ZSTD_startingInputLength(dctx->format);
-}
-
-/* ZSTD_resetDStream() :
- * return : expected size, aka ZSTD_startingInputLength().
- * this function cannot fail */
-size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
-{
-    DEBUGLOG(4, "ZSTD_resetDStream");
-    FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), "");
-    return ZSTD_startingInputLength(dctx->format);
-}
-
-
-size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
-{
-    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    ZSTD_clearDict(dctx);
-    if (ddict) {
-        dctx->ddict = ddict;
-        dctx->dictUses = ZSTD_use_indefinitely;
-        if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) {
-            if (dctx->ddictSet == NULL) {
-                dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem);
-                if (!dctx->ddictSet) {
-                    RETURN_ERROR(memory_allocation, "Failed to allocate memory for hash set!");
-                }
-            }
-            assert(!dctx->staticSize);  /* Impossible: ddictSet cannot have been allocated if static dctx */
-            FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), "");
-        }
-    }
-    return 0;
-}
-
-/* ZSTD_DCtx_setMaxWindowSize() :
- * note : no direct equivalence in ZSTD_DCtx_setParameter,
- * since this version sets windowSize, and the other sets windowLog */
-size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
-{
-    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
-    size_t const min = (size_t)1 << bounds.lowerBound;
-    size_t const max = (size_t)1 << bounds.upperBound;
-    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, "");
-    RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, "");
-    dctx->maxWindowSize = maxWindowSize;
-    return 0;
-}
-
-size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
-{
-    return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);
-}
-
-ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
-{
-    ZSTD_bounds bounds = { 0, 0, 0 };
-    switch(dParam) {
-        case ZSTD_d_windowLogMax:
-            bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
-            bounds.upperBound = ZSTD_WINDOWLOG_MAX;
-            return bounds;
-        case ZSTD_d_format:
-            bounds.lowerBound = (int)ZSTD_f_zstd1;
-            bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
-            ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
-            return bounds;
-        case ZSTD_d_stableOutBuffer:
-            bounds.lowerBound = (int)ZSTD_bm_buffered;
-            bounds.upperBound = (int)ZSTD_bm_stable;
-            return bounds;
-        case ZSTD_d_forceIgnoreChecksum:
-            bounds.lowerBound = (int)ZSTD_d_validateChecksum;
-            bounds.upperBound = (int)ZSTD_d_ignoreChecksum;
-            return bounds;
-        case ZSTD_d_refMultipleDDicts:
-            bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict;
-            bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts;
-            return bounds;
-        case ZSTD_d_disableHuffmanAssembly:
-            bounds.lowerBound = 0;
-            bounds.upperBound = 1;
-            return bounds;
-        case ZSTD_d_maxBlockSize:
-            bounds.lowerBound = ZSTD_BLOCKSIZE_MAX_MIN;
-            bounds.upperBound = ZSTD_BLOCKSIZE_MAX;
-            return bounds;
-
-        default:;
-    }
-    bounds.error = ERROR(parameter_unsupported);
-    return bounds;
-}
-
-/* ZSTD_dParam_withinBounds:
- * @return 1 if value is within dParam bounds,
- * 0 otherwise */
-static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
-{
-    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
-    if (ZSTD_isError(bounds.error)) return 0;
-    if (value < bounds.lowerBound) return 0;
-    if (value > bounds.upperBound) return 0;
-    return 1;
-}
-
-#define CHECK_DBOUNDS(p,v) {                \
-    RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \
-}
-
-size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
-{
-    switch (param) {
-        case ZSTD_d_windowLogMax:
-            *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize);
-            return 0;
-        case ZSTD_d_format:
-            *value = (int)dctx->format;
-            return 0;
-        case ZSTD_d_stableOutBuffer:
-            *value = (int)dctx->outBufferMode;
-            return 0;
-        case ZSTD_d_forceIgnoreChecksum:
-            *value = (int)dctx->forceIgnoreChecksum;
-            return 0;
-        case ZSTD_d_refMultipleDDicts:
-            *value = (int)dctx->refMultipleDDicts;
-            return 0;
-        case ZSTD_d_disableHuffmanAssembly:
-            *value = (int)dctx->disableHufAsm;
-            return 0;
-        case ZSTD_d_maxBlockSize:
-            *value = dctx->maxBlockSizeParam;
-            return 0;
-        default:;
-    }
-    RETURN_ERROR(parameter_unsupported, "");
-}
-
-size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
-{
-    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    switch(dParam) {
-        case ZSTD_d_windowLogMax:
-            if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
-            CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
-            dctx->maxWindowSize = ((size_t)1) << value;
-            return 0;
-        case ZSTD_d_format:
-            CHECK_DBOUNDS(ZSTD_d_format, value);
-            dctx->format = (ZSTD_format_e)value;
-            return 0;
-        case ZSTD_d_stableOutBuffer:
-            CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);
-            dctx->outBufferMode = (ZSTD_bufferMode_e)value;
-            return 0;
-        case ZSTD_d_forceIgnoreChecksum:
-            CHECK_DBOUNDS(ZSTD_d_forceIgnoreChecksum, value);
-            dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value;
-            return 0;
-        case ZSTD_d_refMultipleDDicts:
-            CHECK_DBOUNDS(ZSTD_d_refMultipleDDicts, value);
-            if (dctx->staticSize != 0) {
-                RETURN_ERROR(parameter_unsupported, "Static dctx does not support multiple DDicts!");
-            }
-            dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;
-            return 0;
-        case ZSTD_d_disableHuffmanAssembly:
-            CHECK_DBOUNDS(ZSTD_d_disableHuffmanAssembly, value);
-            dctx->disableHufAsm = value != 0;
-            return 0;
-        case ZSTD_d_maxBlockSize:
-            if (value != 0) CHECK_DBOUNDS(ZSTD_d_maxBlockSize, value);
-            dctx->maxBlockSizeParam = value;
-            return 0;
-        default:;
-    }
-    RETURN_ERROR(parameter_unsupported, "");
-}
-
-size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
-{
-    if ( (reset == ZSTD_reset_session_only)
-      || (reset == ZSTD_reset_session_and_parameters) ) {
-        dctx->streamStage = zdss_init;
-        dctx->noForwardProgress = 0;
-        dctx->isFrameDecompression = 1;
-    }
-    if ( (reset == ZSTD_reset_parameters)
-      || (reset == ZSTD_reset_session_and_parameters) ) {
-        RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-        ZSTD_clearDict(dctx);
-        ZSTD_DCtx_resetParameters(dctx);
-    }
-    return 0;
-}
-
-
-size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
-{
-    return ZSTD_sizeof_DCtx(dctx);
-}
-
-static size_t ZSTD_decodingBufferSize_internal(unsigned long long windowSize, unsigned long long frameContentSize, size_t blockSizeMax)
-{
-    size_t const blockSize = MIN((size_t)MIN(windowSize, ZSTD_BLOCKSIZE_MAX), blockSizeMax);
-    /* We need blockSize + WILDCOPY_OVERLENGTH worth of buffer so that if a block
-     * ends at windowSize + WILDCOPY_OVERLENGTH + 1 bytes, we can start writing
-     * the block at the beginning of the output buffer, and maintain a full window.
-     *
-     * We need another blockSize worth of buffer so that we can store split
-     * literals at the end of the block without overwriting the extDict window.
-     */
-    unsigned long long const neededRBSize = windowSize + (blockSize * 2) + (WILDCOPY_OVERLENGTH * 2);
-    unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
-    size_t const minRBSize = (size_t) neededSize;
-    RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
-                    frameParameter_windowTooLarge, "");
-    return minRBSize;
-}
-
-size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)
-{
-    return ZSTD_decodingBufferSize_internal(windowSize, frameContentSize, ZSTD_BLOCKSIZE_MAX);
-}
-
-size_t ZSTD_estimateDStreamSize(size_t windowSize)
-{
-    size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
-    size_t const inBuffSize = blockSize;  /* no block can be larger */
-    size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
-    return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
-}
-
-size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
-{
-    U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;   /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
-    ZSTD_frameHeader zfh;
-    size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
-    if (ZSTD_isError(err)) return err;
-    RETURN_ERROR_IF(err>0, srcSize_wrong, "");
-    RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
-                    frameParameter_windowTooLarge, "");
-    return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
-}
-
-
-/* *****   Decompression   ***** */
-
-static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
-{
-    return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;
-}
-
-static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
-{
-    if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))
-        zds->oversizedDuration++;
-    else
-        zds->oversizedDuration = 0;
-}
-
-static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
-{
-    return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;
-}
-
-/* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */
-static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
-{
-    ZSTD_outBuffer const expect = zds->expectedOutBuffer;
-    /* No requirement when ZSTD_obm_stable is not enabled. */
-    if (zds->outBufferMode != ZSTD_bm_stable)
-        return 0;
-    /* Any buffer is allowed in zdss_init, this must be the same for every other call until
-     * the context is reset.
-     */
-    if (zds->streamStage == zdss_init)
-        return 0;
-    /* The buffer must match our expectation exactly. */
-    if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)
-        return 0;
-    RETURN_ERROR(dstBuffer_wrong, "ZSTD_d_stableOutBuffer enabled but output differs!");
-}
-
-/* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()
- * and updates the stage and the output buffer state. This call is extracted so it can be
- * used both when reading directly from the ZSTD_inBuffer, and in buffered input mode.
- * NOTE: You must break after calling this function since the streamStage is modified.
- */
-static size_t ZSTD_decompressContinueStream(
-            ZSTD_DStream* zds, char** op, char* oend,
-            void const* src, size_t srcSize) {
-    int const isSkipFrame = ZSTD_isSkipFrame(zds);
-    if (zds->outBufferMode == ZSTD_bm_buffered) {
-        size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart;
-        size_t const decodedSize = ZSTD_decompressContinue(zds,
-                zds->outBuff + zds->outStart, dstSize, src, srcSize);
-        FORWARD_IF_ERROR(decodedSize, "");
-        if (!decodedSize && !isSkipFrame) {
-            zds->streamStage = zdss_read;
-        } else {
-            zds->outEnd = zds->outStart + decodedSize;
-            zds->streamStage = zdss_flush;
-        }
-    } else {
-        /* Write directly into the output buffer */
-        size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op);
-        size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize);
-        FORWARD_IF_ERROR(decodedSize, "");
-        *op += decodedSize;
-        /* Flushing is not needed. */
-        zds->streamStage = zdss_read;
-        assert(*op <= oend);
-        assert(zds->outBufferMode == ZSTD_bm_stable);
-    }
-    return 0;
-}
-
-size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
-{
-    const char* const src = (const char*)input->src;
-    const char* const istart = input->pos != 0 ? src + input->pos : src;
-    const char* const iend = input->size != 0 ? src + input->size : src;
-    const char* ip = istart;
-    char* const dst = (char*)output->dst;
-    char* const ostart = output->pos != 0 ? dst + output->pos : dst;
-    char* const oend = output->size != 0 ? dst + output->size : dst;
-    char* op = ostart;
-    U32 someMoreWork = 1;
-
-    DEBUGLOG(5, "ZSTD_decompressStream");
-    RETURN_ERROR_IF(
-        input->pos > input->size,
-        srcSize_wrong,
-        "forbidden. in: pos: %u   vs size: %u",
-        (U32)input->pos, (U32)input->size);
-    RETURN_ERROR_IF(
-        output->pos > output->size,
-        dstSize_tooSmall,
-        "forbidden. out: pos: %u   vs size: %u",
-        (U32)output->pos, (U32)output->size);
-    DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
-    FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");
-
-    while (someMoreWork) {
-        switch(zds->streamStage)
-        {
-        case zdss_init :
-            DEBUGLOG(5, "stage zdss_init => transparent reset ");
-            zds->streamStage = zdss_loadHeader;
-            zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-            zds->legacyVersion = 0;
-#endif
-            zds->hostageByte = 0;
-            zds->expectedOutBuffer = *output;
-            ZSTD_FALLTHROUGH;
-
-        case zdss_loadHeader :
-            DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-            if (zds->legacyVersion) {
-                RETURN_ERROR_IF(zds->staticSize, memory_allocation,
-                    "legacy support is incompatible with static dctx");
-                {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
-                    if (hint==0) zds->streamStage = zdss_init;
-                    return hint;
-            }   }
-#endif
-            {   size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
-                if (zds->refMultipleDDicts && zds->ddictSet) {
-                    ZSTD_DCtx_selectFrameDDict(zds);
-                }
-                if (ZSTD_isError(hSize)) {
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-                    U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);
-                    if (legacyVersion) {
-                        ZSTD_DDict const* const ddict = ZSTD_getDDict(zds);
-                        const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL;
-                        size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0;
-                        DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
-                        RETURN_ERROR_IF(zds->staticSize, memory_allocation,
-                            "legacy support is incompatible with static dctx");
-                        FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,
-                                    zds->previousLegacyVersion, legacyVersion,
-                                    dict, dictSize), "");
-                        zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
-                        {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
-                            if (hint==0) zds->streamStage = zdss_init;   /* or stay in stage zdss_loadHeader */
-                            return hint;
-                    }   }
-#endif
-                    return hSize;   /* error */
-                }
-                if (hSize != 0) {   /* need more input */
-                    size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
-                    size_t const remainingInput = (size_t)(iend-ip);
-                    assert(iend >= ip);
-                    if (toLoad > remainingInput) {   /* not enough input to load full header */
-                        if (remainingInput > 0) {
-                            ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
-                            zds->lhSize += remainingInput;
-                        }
-                        input->pos = input->size;
-                        /* check first few bytes */
-                        FORWARD_IF_ERROR(
-                            ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format),
-                            "First few bytes detected incorrect" );
-                        /* return hint input size */
-                        return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
-                    }
-                    assert(ip != NULL);
-                    ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
-                    break;
-            }   }
-
-            /* check for single-pass mode opportunity */
-            if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
-                && zds->fParams.frameType != ZSTD_skippableFrame
-                && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
-                size_t const cSize = ZSTD_findFrameCompressedSize_advanced(istart, (size_t)(iend-istart), zds->format);
-                if (cSize <= (size_t)(iend-istart)) {
-                    /* shortcut : using single-pass mode */
-                    size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, ZSTD_getDDict(zds));
-                    if (ZSTD_isError(decompressedSize)) return decompressedSize;
-                    DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()");
-                    assert(istart != NULL);
-                    ip = istart + cSize;
-                    op = op ? op + decompressedSize : op; /* can occur if frameContentSize = 0 (empty frame) */
-                    zds->expected = 0;
-                    zds->streamStage = zdss_init;
-                    someMoreWork = 0;
-                    break;
-            }   }
-
-            /* Check output buffer is large enough for ZSTD_odm_stable. */
-            if (zds->outBufferMode == ZSTD_bm_stable
-                && zds->fParams.frameType != ZSTD_skippableFrame
-                && zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
-                && (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) {
-                RETURN_ERROR(dstSize_tooSmall, "ZSTD_obm_stable passed but ZSTD_outBuffer is too small");
-            }
-
-            /* Consume header (see ZSTDds_decodeFrameHeader) */
-            DEBUGLOG(4, "Consume header");
-            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");
-
-            if (zds->format == ZSTD_f_zstd1
-                && (MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {  /* skippable frame */
-                zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
-                zds->stage = ZSTDds_skipFrame;
-            } else {
-                FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
-                zds->expected = ZSTD_blockHeaderSize;
-                zds->stage = ZSTDds_decodeBlockHeader;
-            }
-
-            /* control buffer memory usage */
-            DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
-                        (U32)(zds->fParams.windowSize >>10),
-                        (U32)(zds->maxWindowSize >> 10) );
-            zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
-            RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
-                            frameParameter_windowTooLarge, "");
-            if (zds->maxBlockSizeParam != 0)
-                zds->fParams.blockSizeMax = MIN(zds->fParams.blockSizeMax, (unsigned)zds->maxBlockSizeParam);
-
-            /* Adapt buffer sizes to frame header instructions */
-            {   size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);
-                size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered
-                        ? ZSTD_decodingBufferSize_internal(zds->fParams.windowSize, zds->fParams.frameContentSize, zds->fParams.blockSizeMax)
-                        : 0;
-
-                ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);
-
-                {   int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize);
-                    int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);
-
-                    if (tooSmall || tooLarge) {
-                        size_t const bufferSize = neededInBuffSize + neededOutBuffSize;
-                        DEBUGLOG(4, "inBuff  : from %u to %u",
-                                    (U32)zds->inBuffSize, (U32)neededInBuffSize);
-                        DEBUGLOG(4, "outBuff : from %u to %u",
-                                    (U32)zds->outBuffSize, (U32)neededOutBuffSize);
-                        if (zds->staticSize) {  /* static DCtx */
-                            DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize);
-                            assert(zds->staticSize >= sizeof(ZSTD_DCtx));  /* controlled at init */
-                            RETURN_ERROR_IF(
-                                bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
-                                memory_allocation, "");
-                        } else {
-                            ZSTD_customFree(zds->inBuff, zds->customMem);
-                            zds->inBuffSize = 0;
-                            zds->outBuffSize = 0;
-                            zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem);
-                            RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
-                        }
-                        zds->inBuffSize = neededInBuffSize;
-                        zds->outBuff = zds->inBuff + zds->inBuffSize;
-                        zds->outBuffSize = neededOutBuffSize;
-            }   }   }
-            zds->streamStage = zdss_read;
-            ZSTD_FALLTHROUGH;
-
-        case zdss_read:
-            DEBUGLOG(5, "stage zdss_read");
-            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip));
-                DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize);
-                if (neededInSize==0) {  /* end of frame */
-                    zds->streamStage = zdss_init;
-                    someMoreWork = 0;
-                    break;
-                }
-                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
-                    FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
-                    assert(ip != NULL);
-                    ip += neededInSize;
-                    /* Function modifies the stage so we must break */
-                    break;
-            }   }
-            if (ip==iend) { someMoreWork = 0; break; }   /* no more input */
-            zds->streamStage = zdss_load;
-            ZSTD_FALLTHROUGH;
-
-        case zdss_load:
-            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
-                size_t const toLoad = neededInSize - zds->inPos;
-                int const isSkipFrame = ZSTD_isSkipFrame(zds);
-                size_t loadedSize;
-                /* At this point we shouldn't be decompressing a block that we can stream. */
-                assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip)));
-                if (isSkipFrame) {
-                    loadedSize = MIN(toLoad, (size_t)(iend-ip));
-                } else {
-                    RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
-                                    corruption_detected,
-                                    "should never happen");
-                    loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip));
-                }
-                if (loadedSize != 0) {
-                    /* ip may be NULL */
-                    ip += loadedSize;
-                    zds->inPos += loadedSize;
-                }
-                if (loadedSize < toLoad) { someMoreWork = 0; break; }   /* not enough input, wait for more */
-
-                /* decode loaded input */
-                zds->inPos = 0;   /* input is consumed */
-                FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
-                /* Function modifies the stage so we must break */
-                break;
-            }
-        case zdss_flush:
-            {
-                size_t const toFlushSize = zds->outEnd - zds->outStart;
-                size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toFlushSize);
-
-                op = op ? op + flushedSize : op;
-
-                zds->outStart += flushedSize;
-                if (flushedSize == toFlushSize) {  /* flush completed */
-                    zds->streamStage = zdss_read;
-                    if ( (zds->outBuffSize < zds->fParams.frameContentSize)
-                        && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
-                        DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)",
-                                (int)(zds->outBuffSize - zds->outStart),
-                                (U32)zds->fParams.blockSizeMax);
-                        zds->outStart = zds->outEnd = 0;
-                    }
-                    break;
-            }   }
-            /* cannot complete flush */
-            someMoreWork = 0;
-            break;
-
-        default:
-            assert(0);    /* impossible */
-            RETURN_ERROR(GENERIC, "impossible to reach");   /* some compilers require default to do something */
-    }   }
-
-    /* result */
-    input->pos = (size_t)(ip - (const char*)(input->src));
-    output->pos = (size_t)(op - (char*)(output->dst));
-
-    /* Update the expected output buffer for ZSTD_obm_stable. */
-    zds->expectedOutBuffer = *output;
-
-    if ((ip==istart) && (op==ostart)) {  /* no forward progress */
-        zds->noForwardProgress ++;
-        if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
-            RETURN_ERROR_IF(op==oend, noForwardProgress_destFull, "");
-            RETURN_ERROR_IF(ip==iend, noForwardProgress_inputEmpty, "");
-            assert(0);
-        }
-    } else {
-        zds->noForwardProgress = 0;
-    }
-    {   size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
-        if (!nextSrcSizeHint) {   /* frame fully decoded */
-            if (zds->outEnd == zds->outStart) {  /* output fully flushed */
-                if (zds->hostageByte) {
-                    if (input->pos >= input->size) {
-                        /* can't release hostage (not present) */
-                        zds->streamStage = zdss_read;
-                        return 1;
-                    }
-                    input->pos++;  /* release hostage */
-                }   /* zds->hostageByte */
-                return 0;
-            }  /* zds->outEnd == zds->outStart */
-            if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */
-                input->pos--;   /* note : pos > 0, otherwise, impossible to finish reading last block */
-                zds->hostageByte=1;
-            }
-            return 1;
-        }  /* nextSrcSizeHint==0 */
-        nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block);   /* preload header of next block */
-        assert(zds->inPos <= nextSrcSizeHint);
-        nextSrcSizeHint -= zds->inPos;   /* part already loaded*/
-        return nextSrcSizeHint;
-    }
-}
-
-size_t ZSTD_decompressStream_simpleArgs (
-                            ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity, size_t* dstPos,
-                      const void* src, size_t srcSize, size_t* srcPos)
-{
-    ZSTD_outBuffer output;
-    ZSTD_inBuffer  input;
-    output.dst = dst;
-    output.size = dstCapacity;
-    output.pos = *dstPos;
-    input.src = src;
-    input.size = srcSize;
-    input.pos = *srcPos;
-    {   size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
-        *dstPos = output.pos;
-        *srcPos = input.pos;
-        return cErr;
-    }
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp b/src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp
deleted file mode 100644
index 75955fdef..000000000
--- a/src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp
+++ /dev/null
@@ -1,2218 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* zstd_decompress_block :
- * this module takes care of decompressing _compressed_ block */
-
-/*-*******************************************************
-*  Dependencies
-*********************************************************/
-#include "zstd/common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
-#include "zstd/common/compiler.h"    /* prefetch */
-#include "zstd/common/cpu.h"         /* bmi2 */
-#include "zstd/common/mem.h"         /* low level memory routines */
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-#include "zstd/common/huf.h"
-#include "zstd/common/zstd_internal.h"
-#include "zstd/decompress/zstd_decompress_internal.h"   /* ZSTD_DCtx */
-#include "zstd/decompress/zstd_ddict.h"  /* ZSTD_DDictDictContent */
-#include "zstd/decompress/zstd_decompress_block.h"
-#include "zstd/common/bits.h"  /* ZSTD_highbit32 */
-
-/*_*******************************************************
-*  Macros
-**********************************************************/
-
-/* These two optional macros force the use one way or another of the two
- * ZSTD_decompressSequences implementations. You can't force in both directions
- * at the same time.
- */
-#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
-    defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
-#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!"
-#endif
-
-namespace duckdb_zstd {
-
-/*_*******************************************************
-*  Memory operations
-**********************************************************/
-static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
-
-
-/*-*************************************************************
- *   Block decoding
- ***************************************************************/
-
-static size_t ZSTD_blockSizeMax(ZSTD_DCtx const* dctx)
-{
-    size_t const blockSizeMax = dctx->isFrameDecompression ? dctx->fParams.blockSizeMax : ZSTD_BLOCKSIZE_MAX;
-    assert(blockSizeMax <= ZSTD_BLOCKSIZE_MAX);
-    return blockSizeMax;
-}
-
-/*! ZSTD_getcBlockSize() :
- *  Provides the size of compressed block from block header `src` */
-size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
-                          blockProperties_t* bpPtr)
-{
-    RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, "");
-
-    {   U32 const cBlockHeader = MEM_readLE24(src);
-        U32 const cSize = cBlockHeader >> 3;
-        bpPtr->lastBlock = cBlockHeader & 1;
-        bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
-        bpPtr->origSize = cSize;   /* only useful for RLE */
-        if (bpPtr->blockType == bt_rle) return 1;
-        RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected, "");
-        return cSize;
-    }
-}
-
-/* Allocate buffer for literals, either overlapping current dst, or split between dst and litExtraBuffer, or stored entirely within litExtraBuffer */
-static void ZSTD_allocateLiteralsBuffer(ZSTD_DCtx* dctx, void* const dst, const size_t dstCapacity, const size_t litSize,
-    const streaming_operation streaming, const size_t expectedWriteSize, const unsigned splitImmediately)
-{
-    size_t const blockSizeMax = ZSTD_blockSizeMax(dctx);
-    assert(litSize <= blockSizeMax);
-    assert(dctx->isFrameDecompression || streaming == not_streaming);
-    assert(expectedWriteSize <= blockSizeMax);
-    if (streaming == not_streaming && dstCapacity > blockSizeMax + WILDCOPY_OVERLENGTH + litSize + WILDCOPY_OVERLENGTH) {
-        /* If we aren't streaming, we can just put the literals after the output
-         * of the current block. We don't need to worry about overwriting the
-         * extDict of our window, because it doesn't exist.
-         * So if we have space after the end of the block, just put it there.
-         */
-        dctx->litBuffer = (BYTE*)dst + blockSizeMax + WILDCOPY_OVERLENGTH;
-        dctx->litBufferEnd = dctx->litBuffer + litSize;
-        dctx->litBufferLocation = ZSTD_in_dst;
-    } else if (litSize <= ZSTD_LITBUFFEREXTRASIZE) {
-        /* Literals fit entirely within the extra buffer, put them there to avoid
-         * having to split the literals.
-         */
-        dctx->litBuffer = dctx->litExtraBuffer;
-        dctx->litBufferEnd = dctx->litBuffer + litSize;
-        dctx->litBufferLocation = ZSTD_not_in_dst;
-    } else {
-        assert(blockSizeMax > ZSTD_LITBUFFEREXTRASIZE);
-        /* Literals must be split between the output block and the extra lit
-         * buffer. We fill the extra lit buffer with the tail of the literals,
-         * and put the rest of the literals at the end of the block, with
-         * WILDCOPY_OVERLENGTH of buffer room to allow for overreads.
-         * This MUST not write more than our maxBlockSize beyond dst, because in
-         * streaming mode, that could overwrite part of our extDict window.
-         */
-        if (splitImmediately) {
-            /* won't fit in litExtraBuffer, so it will be split between end of dst and extra buffer */
-            dctx->litBuffer = (BYTE*)dst + expectedWriteSize - litSize + ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH;
-            dctx->litBufferEnd = dctx->litBuffer + litSize - ZSTD_LITBUFFEREXTRASIZE;
-        } else {
-            /* initially this will be stored entirely in dst during huffman decoding, it will partially be shifted to litExtraBuffer after */
-            dctx->litBuffer = (BYTE*)dst + expectedWriteSize - litSize;
-            dctx->litBufferEnd = (BYTE*)dst + expectedWriteSize;
-        }
-        dctx->litBufferLocation = ZSTD_split;
-        assert(dctx->litBufferEnd <= (BYTE*)dst + expectedWriteSize);
-    }
-}
-
-/*! ZSTD_decodeLiteralsBlock() :
- * Where it is possible to do so without being stomped by the output during decompression, the literals block will be stored
- * in the dstBuffer.  If there is room to do so, it will be stored in full in the excess dst space after where the current
- * block will be output.  Otherwise it will be stored at the end of the current dst blockspace, with a small portion being
- * stored in dctx->litExtraBuffer to help keep it "ahead" of the current output write.
- *
- * @return : nb of bytes read from src (< srcSize )
- *  note : symbol not declared but exposed for fullbench */
-static size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
-                          const void* src, size_t srcSize,   /* note : srcSize < BLOCKSIZE */
-                          void* dst, size_t dstCapacity, const streaming_operation streaming)
-{
-    DEBUGLOG(5, "ZSTD_decodeLiteralsBlock");
-    RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, "");
-
-    {   const BYTE* const istart = (const BYTE*) src;
-        symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
-        size_t const blockSizeMax = ZSTD_blockSizeMax(dctx);
-
-        switch(litEncType)
-        {
-        case set_repeat:
-            DEBUGLOG(5, "set_repeat flag : re-using stats from previous compressed literals block");
-            RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, "");
-            ZSTD_FALLTHROUGH;
-
-        case set_compressed:
-            RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 2; here we need up to 5 for case 3");
-            {   size_t lhSize, litSize, litCSize;
-                U32 singleStream=0;
-                U32 const lhlCode = (istart[0] >> 2) & 3;
-                U32 const lhc = MEM_readLE32(istart);
-                size_t hufSuccess;
-                size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);
-                int const flags = 0
-                    | (ZSTD_DCtx_get_bmi2(dctx) ? HUF_flags_bmi2 : 0)
-                    | (dctx->disableHufAsm ? HUF_flags_disableAsm : 0);
-                switch(lhlCode)
-                {
-                case 0: case 1: default:   /* note : default is impossible, since lhlCode into [0..3] */
-                    /* 2 - 2 - 10 - 10 */
-                    singleStream = !lhlCode;
-                    lhSize = 3;
-                    litSize  = (lhc >> 4) & 0x3FF;
-                    litCSize = (lhc >> 14) & 0x3FF;
-                    break;
-                case 2:
-                    /* 2 - 2 - 14 - 14 */
-                    lhSize = 4;
-                    litSize  = (lhc >> 4) & 0x3FFF;
-                    litCSize = lhc >> 18;
-                    break;
-                case 3:
-                    /* 2 - 2 - 18 - 18 */
-                    lhSize = 5;
-                    litSize  = (lhc >> 4) & 0x3FFFF;
-                    litCSize = (lhc >> 22) + ((size_t)istart[4] << 10);
-                    break;
-                }
-                RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");
-                RETURN_ERROR_IF(litSize > blockSizeMax, corruption_detected, "");
-                if (!singleStream)
-                    RETURN_ERROR_IF(litSize < MIN_LITERALS_FOR_4_STREAMS, literals_headerWrong,
-                        "Not enough literals (%zu) for the 4-streams mode (min %u)",
-                        litSize, MIN_LITERALS_FOR_4_STREAMS);
-                RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, "");
-                RETURN_ERROR_IF(expectedWriteSize < litSize , dstSize_tooSmall, "");
-                ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 0);
-
-                /* prefetch huffman table if cold */
-                if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
-                    PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
-                }
-
-                if (litEncType==set_repeat) {
-                    if (singleStream) {
-                        hufSuccess = HUF_decompress1X_usingDTable(
-                            dctx->litBuffer, litSize, istart+lhSize, litCSize,
-                            dctx->HUFptr, flags);
-                    } else {
-                        assert(litSize >= MIN_LITERALS_FOR_4_STREAMS);
-                        hufSuccess = HUF_decompress4X_usingDTable(
-                            dctx->litBuffer, litSize, istart+lhSize, litCSize,
-                            dctx->HUFptr, flags);
-                    }
-                } else {
-                    if (singleStream) {
-#if defined(HUF_FORCE_DECOMPRESS_X2)
-                        hufSuccess = HUF_decompress1X_DCtx_wksp(
-                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
-                            istart+lhSize, litCSize, dctx->workspace,
-                            sizeof(dctx->workspace), flags);
-#else
-                        hufSuccess = HUF_decompress1X1_DCtx_wksp(
-                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
-                            istart+lhSize, litCSize, dctx->workspace,
-                            sizeof(dctx->workspace), flags);
-#endif
-                    } else {
-                        hufSuccess = HUF_decompress4X_hufOnly_wksp(
-                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
-                            istart+lhSize, litCSize, dctx->workspace,
-                            sizeof(dctx->workspace), flags);
-                    }
-                }
-                if (dctx->litBufferLocation == ZSTD_split)
-                {
-                    assert(litSize > ZSTD_LITBUFFEREXTRASIZE);
-                    ZSTD_memcpy(dctx->litExtraBuffer, dctx->litBufferEnd - ZSTD_LITBUFFEREXTRASIZE, ZSTD_LITBUFFEREXTRASIZE);
-                    ZSTD_memmove(dctx->litBuffer + ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH, dctx->litBuffer, litSize - ZSTD_LITBUFFEREXTRASIZE);
-                    dctx->litBuffer += ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH;
-                    dctx->litBufferEnd -= WILDCOPY_OVERLENGTH;
-                    assert(dctx->litBufferEnd <= (BYTE*)dst + blockSizeMax);
-                }
-
-                RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, "");
-
-                dctx->litPtr = dctx->litBuffer;
-                dctx->litSize = litSize;
-                dctx->litEntropy = 1;
-                if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
-                return litCSize + lhSize;
-            }
-
-        case set_basic:
-            {   size_t litSize, lhSize;
-                U32 const lhlCode = ((istart[0]) >> 2) & 3;
-                size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);
-                switch(lhlCode)
-                {
-                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
-                    lhSize = 1;
-                    litSize = istart[0] >> 3;
-                    break;
-                case 1:
-                    lhSize = 2;
-                    litSize = MEM_readLE16(istart) >> 4;
-                    break;
-                case 3:
-                    lhSize = 3;
-                    RETURN_ERROR_IF(srcSize<3, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 2; here we need lhSize = 3");
-                    litSize = MEM_readLE24(istart) >> 4;
-                    break;
-                }
-
-                RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");
-                RETURN_ERROR_IF(litSize > blockSizeMax, corruption_detected, "");
-                RETURN_ERROR_IF(expectedWriteSize < litSize, dstSize_tooSmall, "");
-                ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);
-                if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
-                    RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, "");
-                    if (dctx->litBufferLocation == ZSTD_split)
-                    {
-                        ZSTD_memcpy(dctx->litBuffer, istart + lhSize, litSize - ZSTD_LITBUFFEREXTRASIZE);
-                        ZSTD_memcpy(dctx->litExtraBuffer, istart + lhSize + litSize - ZSTD_LITBUFFEREXTRASIZE, ZSTD_LITBUFFEREXTRASIZE);
-                    }
-                    else
-                    {
-                        ZSTD_memcpy(dctx->litBuffer, istart + lhSize, litSize);
-                    }
-                    dctx->litPtr = dctx->litBuffer;
-                    dctx->litSize = litSize;
-                    return lhSize+litSize;
-                }
-                /* direct reference into compressed stream */
-                dctx->litPtr = istart+lhSize;
-                dctx->litSize = litSize;
-                dctx->litBufferEnd = dctx->litPtr + litSize;
-                dctx->litBufferLocation = ZSTD_not_in_dst;
-                return lhSize+litSize;
-            }
-
-        case set_rle:
-            {   U32 const lhlCode = ((istart[0]) >> 2) & 3;
-                size_t litSize, lhSize;
-                size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);
-                switch(lhlCode)
-                {
-                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
-                    lhSize = 1;
-                    litSize = istart[0] >> 3;
-                    break;
-                case 1:
-                    lhSize = 2;
-                    RETURN_ERROR_IF(srcSize<3, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 2; here we need lhSize+1 = 3");
-                    litSize = MEM_readLE16(istart) >> 4;
-                    break;
-                case 3:
-                    lhSize = 3;
-                    RETURN_ERROR_IF(srcSize<4, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 2; here we need lhSize+1 = 4");
-                    litSize = MEM_readLE24(istart) >> 4;
-                    break;
-                }
-                RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");
-                RETURN_ERROR_IF(litSize > blockSizeMax, corruption_detected, "");
-                RETURN_ERROR_IF(expectedWriteSize < litSize, dstSize_tooSmall, "");
-                ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);
-                if (dctx->litBufferLocation == ZSTD_split)
-                {
-                    ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize - ZSTD_LITBUFFEREXTRASIZE);
-                    ZSTD_memset(dctx->litExtraBuffer, istart[lhSize], ZSTD_LITBUFFEREXTRASIZE);
-                }
-                else
-                {
-                    ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize);
-                }
-                dctx->litPtr = dctx->litBuffer;
-                dctx->litSize = litSize;
-                return lhSize+1;
-            }
-        default:
-            RETURN_ERROR(corruption_detected, "impossible");
-        }
-    }
-}
-
-/* Hidden declaration for fullbench */
-size_t ZSTD_decodeLiteralsBlock_wrapper(ZSTD_DCtx* dctx,
-                          const void* src, size_t srcSize,
-                          void* dst, size_t dstCapacity);
-size_t ZSTD_decodeLiteralsBlock_wrapper(ZSTD_DCtx* dctx,
-                          const void* src, size_t srcSize,
-                          void* dst, size_t dstCapacity)
-{
-    dctx->isFrameDecompression = 0;
-    return ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, not_streaming);
-}
-
-/* Default FSE distribution tables.
- * These are pre-calculated FSE decoding tables using default distributions as defined in specification :
- * https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#default-distributions
- * They were generated programmatically with following method :
- * - start from default distributions, present in /lib/common/zstd_internal.h
- * - generate tables normally, using ZSTD_buildFSETable()
- * - printout the content of tables
- * - pretify output, report below, test with fuzzer to ensure it's correct */
-
-/* Default FSE distribution table for Literal Lengths */
-static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = {
-     {  1,  1,  1, LL_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
-     /* nextState, nbAddBits, nbBits, baseVal */
-     {  0,  0,  4,    0},  { 16,  0,  4,    0},
-     { 32,  0,  5,    1},  {  0,  0,  5,    3},
-     {  0,  0,  5,    4},  {  0,  0,  5,    6},
-     {  0,  0,  5,    7},  {  0,  0,  5,    9},
-     {  0,  0,  5,   10},  {  0,  0,  5,   12},
-     {  0,  0,  6,   14},  {  0,  1,  5,   16},
-     {  0,  1,  5,   20},  {  0,  1,  5,   22},
-     {  0,  2,  5,   28},  {  0,  3,  5,   32},
-     {  0,  4,  5,   48},  { 32,  6,  5,   64},
-     {  0,  7,  5,  128},  {  0,  8,  6,  256},
-     {  0, 10,  6, 1024},  {  0, 12,  6, 4096},
-     { 32,  0,  4,    0},  {  0,  0,  4,    1},
-     {  0,  0,  5,    2},  { 32,  0,  5,    4},
-     {  0,  0,  5,    5},  { 32,  0,  5,    7},
-     {  0,  0,  5,    8},  { 32,  0,  5,   10},
-     {  0,  0,  5,   11},  {  0,  0,  6,   13},
-     { 32,  1,  5,   16},  {  0,  1,  5,   18},
-     { 32,  1,  5,   22},  {  0,  2,  5,   24},
-     { 32,  3,  5,   32},  {  0,  3,  5,   40},
-     {  0,  6,  4,   64},  { 16,  6,  4,   64},
-     { 32,  7,  5,  128},  {  0,  9,  6,  512},
-     {  0, 11,  6, 2048},  { 48,  0,  4,    0},
-     { 16,  0,  4,    1},  { 32,  0,  5,    2},
-     { 32,  0,  5,    3},  { 32,  0,  5,    5},
-     { 32,  0,  5,    6},  { 32,  0,  5,    8},
-     { 32,  0,  5,    9},  { 32,  0,  5,   11},
-     { 32,  0,  5,   12},  {  0,  0,  6,   15},
-     { 32,  1,  5,   18},  { 32,  1,  5,   20},
-     { 32,  2,  5,   24},  { 32,  2,  5,   28},
-     { 32,  3,  5,   40},  { 32,  4,  5,   48},
-     {  0, 16,  6,65536},  {  0, 15,  6,32768},
-     {  0, 14,  6,16384},  {  0, 13,  6, 8192},
-};   /* LL_defaultDTable */
-
-/* Default FSE distribution table for Offset Codes */
-static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
-    {  1,  1,  1, OF_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
-    /* nextState, nbAddBits, nbBits, baseVal */
-    {  0,  0,  5,    0},     {  0,  6,  4,   61},
-    {  0,  9,  5,  509},     {  0, 15,  5,32765},
-    {  0, 21,  5,2097149},   {  0,  3,  5,    5},
-    {  0,  7,  4,  125},     {  0, 12,  5, 4093},
-    {  0, 18,  5,262141},    {  0, 23,  5,8388605},
-    {  0,  5,  5,   29},     {  0,  8,  4,  253},
-    {  0, 14,  5,16381},     {  0, 20,  5,1048573},
-    {  0,  2,  5,    1},     { 16,  7,  4,  125},
-    {  0, 11,  5, 2045},     {  0, 17,  5,131069},
-    {  0, 22,  5,4194301},   {  0,  4,  5,   13},
-    { 16,  8,  4,  253},     {  0, 13,  5, 8189},
-    {  0, 19,  5,524285},    {  0,  1,  5,    1},
-    { 16,  6,  4,   61},     {  0, 10,  5, 1021},
-    {  0, 16,  5,65533},     {  0, 28,  5,268435453},
-    {  0, 27,  5,134217725}, {  0, 26,  5,67108861},
-    {  0, 25,  5,33554429},  {  0, 24,  5,16777213},
-};   /* OF_defaultDTable */
-
-
-/* Default FSE distribution table for Match Lengths */
-static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
-    {  1,  1,  1, ML_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
-    /* nextState, nbAddBits, nbBits, baseVal */
-    {  0,  0,  6,    3},  {  0,  0,  4,    4},
-    { 32,  0,  5,    5},  {  0,  0,  5,    6},
-    {  0,  0,  5,    8},  {  0,  0,  5,    9},
-    {  0,  0,  5,   11},  {  0,  0,  6,   13},
-    {  0,  0,  6,   16},  {  0,  0,  6,   19},
-    {  0,  0,  6,   22},  {  0,  0,  6,   25},
-    {  0,  0,  6,   28},  {  0,  0,  6,   31},
-    {  0,  0,  6,   34},  {  0,  1,  6,   37},
-    {  0,  1,  6,   41},  {  0,  2,  6,   47},
-    {  0,  3,  6,   59},  {  0,  4,  6,   83},
-    {  0,  7,  6,  131},  {  0,  9,  6,  515},
-    { 16,  0,  4,    4},  {  0,  0,  4,    5},
-    { 32,  0,  5,    6},  {  0,  0,  5,    7},
-    { 32,  0,  5,    9},  {  0,  0,  5,   10},
-    {  0,  0,  6,   12},  {  0,  0,  6,   15},
-    {  0,  0,  6,   18},  {  0,  0,  6,   21},
-    {  0,  0,  6,   24},  {  0,  0,  6,   27},
-    {  0,  0,  6,   30},  {  0,  0,  6,   33},
-    {  0,  1,  6,   35},  {  0,  1,  6,   39},
-    {  0,  2,  6,   43},  {  0,  3,  6,   51},
-    {  0,  4,  6,   67},  {  0,  5,  6,   99},
-    {  0,  8,  6,  259},  { 32,  0,  4,    4},
-    { 48,  0,  4,    4},  { 16,  0,  4,    5},
-    { 32,  0,  5,    7},  { 32,  0,  5,    8},
-    { 32,  0,  5,   10},  { 32,  0,  5,   11},
-    {  0,  0,  6,   14},  {  0,  0,  6,   17},
-    {  0,  0,  6,   20},  {  0,  0,  6,   23},
-    {  0,  0,  6,   26},  {  0,  0,  6,   29},
-    {  0,  0,  6,   32},  {  0, 16,  6,65539},
-    {  0, 15,  6,32771},  {  0, 14,  6,16387},
-    {  0, 13,  6, 8195},  {  0, 12,  6, 4099},
-    {  0, 11,  6, 2051},  {  0, 10,  6, 1027},
-};   /* ML_defaultDTable */
-
-
-static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U8 nbAddBits)
-{
-    void* ptr = dt;
-    ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr;
-    ZSTD_seqSymbol* const cell = dt + 1;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->nbBits = 0;
-    cell->nextState = 0;
-    assert(nbAddBits < 255);
-    cell->nbAdditionalBits = nbAddBits;
-    cell->baseValue = baseValue;
-}
-
-
-/* ZSTD_buildFSETable() :
- * generate FSE decoding table for one symbol (ll, ml or off)
- * cannot fail if input is valid =>
- * all inputs are presumed validated at this stage */
-FORCE_INLINE_TEMPLATE
-void ZSTD_buildFSETable_body(ZSTD_seqSymbol* dt,
-            const short* normalizedCounter, unsigned maxSymbolValue,
-            const U32* baseValue, const U8* nbAdditionalBits,
-            unsigned tableLog, void* wksp, size_t wkspSize)
-{
-    ZSTD_seqSymbol* const tableDecode = dt+1;
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-
-    U16* symbolNext = (U16*)wksp;
-    BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1);
-    U32 highThreshold = tableSize - 1;
-
-
-    /* Sanity Checks */
-    assert(maxSymbolValue <= MaxSeq);
-    assert(tableLog <= MaxFSELog);
-    assert(wkspSize >= ZSTD_BUILD_FSE_TABLE_WKSP_SIZE);
-    (void)wkspSize;
-    /* Init, lay down lowprob symbols */
-    {   ZSTD_seqSymbol_header DTableH;
-        DTableH.tableLog = tableLog;
-        DTableH.fastMode = 1;
-        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
-            U32 s;
-            for (s=0; s<maxSV1; s++) {
-                if (normalizedCounter[s]==-1) {
-                    tableDecode[highThreshold--].baseValue = s;
-                    symbolNext[s] = 1;
-                } else {
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
-                    assert(normalizedCounter[s]>=0);
-                    symbolNext[s] = (U16)normalizedCounter[s];
-        }   }   }
-        ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
-    assert(tableSize <= 512);
-    /* Specialized symbol spreading for the case when there are
-     * no low probability (-1 count) symbols. When compressing
-     * small blocks we avoid low probability symbols to hit this
-     * case, since header decoding speed matters more.
-     */
-    if (highThreshold == tableSize - 1) {
-        size_t const tableMask = tableSize-1;
-        size_t const step = FSE_TABLESTEP(tableSize);
-        /* First lay down the symbols in order.
-         * We use a uint64_t to lay down 8 bytes at a time. This reduces branch
-         * misses since small blocks generally have small table logs, so nearly
-         * all symbols have counts <= 8. We ensure we have 8 bytes at the end of
-         * our buffer to handle the over-write.
-         */
-        {
-            U64 const add = 0x0101010101010101ull;
-            size_t pos = 0;
-            U64 sv = 0;
-            U32 s;
-            for (s=0; s<maxSV1; ++s, sv += add) {
-                int i;
-                int const n = normalizedCounter[s];
-                MEM_write64(spread + pos, sv);
-                for (i = 8; i < n; i += 8) {
-                    MEM_write64(spread + pos + i, sv);
-                }
-                assert(n>=0);
-                pos += (size_t)n;
-            }
-        }
-        /* Now we spread those positions across the table.
-         * The benefit of doing it in two stages is that we avoid the
-         * variable size inner loop, which caused lots of branch misses.
-         * Now we can run through all the positions without any branch misses.
-         * We unroll the loop twice, since that is what empirically worked best.
-         */
-        {
-            size_t position = 0;
-            size_t s;
-            size_t const unroll = 2;
-            assert(tableSize % unroll == 0); /* FSE_MIN_TABLELOG is 5 */
-            for (s = 0; s < (size_t)tableSize; s += unroll) {
-                size_t u;
-                for (u = 0; u < unroll; ++u) {
-                    size_t const uPosition = (position + (u * step)) & tableMask;
-                    tableDecode[uPosition].baseValue = spread[s + u];
-                }
-                position = (position + (unroll * step)) & tableMask;
-            }
-            assert(position == 0);
-        }
-    } else {
-        U32 const tableMask = tableSize-1;
-        U32 const step = FSE_TABLESTEP(tableSize);
-        U32 s, position = 0;
-        for (s=0; s<maxSV1; s++) {
-            int i;
-            int const n = normalizedCounter[s];
-            for (i=0; i<n; i++) {
-                tableDecode[position].baseValue = s;
-                position = (position + step) & tableMask;
-                while (UNLIKELY(position > highThreshold)) position = (position + step) & tableMask;   /* lowprob area */
-        }   }
-        assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-    }
-
-    /* Build Decoding table */
-    {
-        U32 u;
-        for (u=0; u<tableSize; u++) {
-            U32 const symbol = tableDecode[u].baseValue;
-            U32 const nextState = symbolNext[symbol]++;
-            tableDecode[u].nbBits = (BYTE) (tableLog - ZSTD_highbit32(nextState) );
-            tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-            assert(nbAdditionalBits[symbol] < 255);
-            tableDecode[u].nbAdditionalBits = nbAdditionalBits[symbol];
-            tableDecode[u].baseValue = baseValue[symbol];
-        }
-    }
-}
-
-/* Avoids the FORCE_INLINE of the _body() function. */
-static void ZSTD_buildFSETable_body_default(ZSTD_seqSymbol* dt,
-            const short* normalizedCounter, unsigned maxSymbolValue,
-            const U32* baseValue, const U8* nbAdditionalBits,
-            unsigned tableLog, void* wksp, size_t wkspSize)
-{
-    ZSTD_buildFSETable_body(dt, normalizedCounter, maxSymbolValue,
-            baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
-}
-
-#if DYNAMIC_BMI2
-BMI2_TARGET_ATTRIBUTE static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt,
-            const short* normalizedCounter, unsigned maxSymbolValue,
-            const U32* baseValue, const U8* nbAdditionalBits,
-            unsigned tableLog, void* wksp, size_t wkspSize)
-{
-    ZSTD_buildFSETable_body(dt, normalizedCounter, maxSymbolValue,
-            baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
-}
-#endif
-
-void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
-            const short* normalizedCounter, unsigned maxSymbolValue,
-            const U32* baseValue, const U8* nbAdditionalBits,
-            unsigned tableLog, void* wksp, size_t wkspSize, int bmi2)
-{
-#if DYNAMIC_BMI2
-    if (bmi2) {
-        ZSTD_buildFSETable_body_bmi2(dt, normalizedCounter, maxSymbolValue,
-                baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
-        return;
-    }
-#endif
-    (void)bmi2;
-    ZSTD_buildFSETable_body_default(dt, normalizedCounter, maxSymbolValue,
-            baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
-}
-
-
-/*! ZSTD_buildSeqTable() :
- * @return : nb bytes read from src,
- *           or an error code if it fails */
-static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr,
-                                 symbolEncodingType_e type, unsigned max, U32 maxLog,
-                                 const void* src, size_t srcSize,
-                                 const U32* baseValue, const U8* nbAdditionalBits,
-                                 const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable,
-                                 int ddictIsCold, int nbSeq, U32* wksp, size_t wkspSize,
-                                 int bmi2)
-{
-    switch(type)
-    {
-    case set_rle :
-        RETURN_ERROR_IF(!srcSize, srcSize_wrong, "");
-        RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, "");
-        {   U32 const symbol = *(const BYTE*)src;
-            U32 const baseline = baseValue[symbol];
-            U8 const nbBits = nbAdditionalBits[symbol];
-            ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);
-        }
-        *DTablePtr = DTableSpace;
-        return 1;
-    case set_basic :
-        *DTablePtr = defaultTable;
-        return 0;
-    case set_repeat:
-        RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, "");
-        /* prefetch FSE table if used */
-        if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
-            const void* const pStart = *DTablePtr;
-            size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
-            PREFETCH_AREA(pStart, pSize);
-        }
-        return 0;
-    case set_compressed :
-        {   unsigned tableLog;
-            S16 norm[MaxSeq+1];
-            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
-            RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, "");
-            RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, "");
-            ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2);
-            *DTablePtr = DTableSpace;
-            return headerSize;
-        }
-    default :
-        assert(0);
-        RETURN_ERROR(GENERIC, "impossible");
-    }
-}
-
-size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
-                             const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* ip = istart;
-    int nbSeq;
-    DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
-
-    /* check */
-    RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, "");
-
-    /* SeqHead */
-    nbSeq = *ip++;
-    if (nbSeq > 0x7F) {
-        if (nbSeq == 0xFF) {
-            RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, "");
-            nbSeq = MEM_readLE16(ip) + LONGNBSEQ;
-            ip+=2;
-        } else {
-            RETURN_ERROR_IF(ip >= iend, srcSize_wrong, "");
-            nbSeq = ((nbSeq-0x80)<<8) + *ip++;
-        }
-    }
-    *nbSeqPtr = nbSeq;
-
-    if (nbSeq == 0) {
-        /* No sequence : section ends immediately */
-        RETURN_ERROR_IF(ip != iend, corruption_detected,
-            "extraneous data present in the Sequences section");
-        return (size_t)(ip - istart);
-    }
-
-    /* FSE table descriptors */
-    RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */
-    RETURN_ERROR_IF(*ip & 3, corruption_detected, ""); /* The last field, Reserved, must be all-zeroes. */
-    {   symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
-        symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
-        symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
-        ip++;
-
-        /* Build DTables */
-        {   size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
-                                                      LLtype, MaxLL, LLFSELog,
-                                                      ip, iend-ip,
-                                                      LL_base, LL_bits,
-                                                      LL_defaultDTable, dctx->fseEntropy,
-                                                      dctx->ddictIsCold, nbSeq,
-                                                      dctx->workspace, sizeof(dctx->workspace),
-                                                      ZSTD_DCtx_get_bmi2(dctx));
-            RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected, "ZSTD_buildSeqTable failed");
-            ip += llhSize;
-        }
-
-        {   size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
-                                                      OFtype, MaxOff, OffFSELog,
-                                                      ip, iend-ip,
-                                                      OF_base, OF_bits,
-                                                      OF_defaultDTable, dctx->fseEntropy,
-                                                      dctx->ddictIsCold, nbSeq,
-                                                      dctx->workspace, sizeof(dctx->workspace),
-                                                      ZSTD_DCtx_get_bmi2(dctx));
-            RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed");
-            ip += ofhSize;
-        }
-
-        {   size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
-                                                      MLtype, MaxML, MLFSELog,
-                                                      ip, iend-ip,
-                                                      ML_base, ML_bits,
-                                                      ML_defaultDTable, dctx->fseEntropy,
-                                                      dctx->ddictIsCold, nbSeq,
-                                                      dctx->workspace, sizeof(dctx->workspace),
-                                                      ZSTD_DCtx_get_bmi2(dctx));
-            RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed");
-            ip += mlhSize;
-        }
-    }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t matchLength;
-    size_t offset;
-} seq_t;
-
-typedef struct {
-    size_t state;
-    const ZSTD_seqSymbol* table;
-} ZSTD_fseState;
-
-typedef struct {
-    BIT_DStream_t DStream;
-    ZSTD_fseState stateLL;
-    ZSTD_fseState stateOffb;
-    ZSTD_fseState stateML;
-    size_t prevOffset[ZSTD_REP_NUM];
-} seqState_t;
-
-/*! ZSTD_overlapCopy8() :
- *  Copies 8 bytes from ip to op and updates op and ip where ip <= op.
- *  If the offset is < 8 then the offset is spread to at least 8 bytes.
- *
- *  Precondition: *ip <= *op
- *  Postcondition: *op - *op >= 8
- */
-HINT_INLINE void ZSTD_overlapCopy8(BYTE** op, BYTE const** ip, size_t offset) {
-    assert(*ip <= *op);
-    if (offset < 8) {
-        /* close range match, overlap */
-        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
-        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
-        int const sub2 = dec64table[offset];
-        (*op)[0] = (*ip)[0];
-        (*op)[1] = (*ip)[1];
-        (*op)[2] = (*ip)[2];
-        (*op)[3] = (*ip)[3];
-        *ip += dec32table[offset];
-        ZSTD_copy4(*op+4, *ip);
-        *ip -= sub2;
-    } else {
-        ZSTD_copy8(*op, *ip);
-    }
-    *ip += 8;
-    *op += 8;
-    assert(*op - *ip >= 8);
-}
-
-/*! ZSTD_safecopy() :
- *  Specialized version of memcpy() that is allowed to READ up to WILDCOPY_OVERLENGTH past the input buffer
- *  and write up to 16 bytes past oend_w (op >= oend_w is allowed).
- *  This function is only called in the uncommon case where the sequence is near the end of the block. It
- *  should be fast for a single long sequence, but can be slow for several short sequences.
- *
- *  @param ovtype controls the overlap detection
- *         - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart.
- *         - ZSTD_overlap_src_before_dst: The src and dst may overlap and may be any distance apart.
- *           The src buffer must be before the dst buffer.
- */
-static void ZSTD_safecopy(BYTE* op, const BYTE* const oend_w, BYTE const* ip, ptrdiff_t length, ZSTD_overlap_e ovtype) {
-    ptrdiff_t const diff = op - ip;
-    BYTE* const oend = op + length;
-
-    assert((ovtype == ZSTD_no_overlap && (diff <= -8 || diff >= 8 || op >= oend_w)) ||
-           (ovtype == ZSTD_overlap_src_before_dst && diff >= 0));
-
-    if (length < 8) {
-        /* Handle short lengths. */
-        while (op < oend) *op++ = *ip++;
-        return;
-    }
-    if (ovtype == ZSTD_overlap_src_before_dst) {
-        /* Copy 8 bytes and ensure the offset >= 8 when there can be overlap. */
-        assert(length >= 8);
-        ZSTD_overlapCopy8(&op, &ip, diff);
-        length -= 8;
-        assert(op - ip >= 8);
-        assert(op <= oend);
-    }
-
-    if (oend <= oend_w) {
-        /* No risk of overwrite. */
-        ZSTD_wildcopy(op, ip, length, ovtype);
-        return;
-    }
-    if (op <= oend_w) {
-        /* Wildcopy until we get close to the end. */
-        assert(oend > oend_w);
-        ZSTD_wildcopy(op, ip, oend_w - op, ovtype);
-        ip += oend_w - op;
-        op += oend_w - op;
-    }
-    /* Handle the leftovers. */
-    while (op < oend) *op++ = *ip++;
-}
-
-/* ZSTD_safecopyDstBeforeSrc():
- * This version allows overlap with dst before src, or handles the non-overlap case with dst after src
- * Kept separate from more common ZSTD_safecopy case to avoid performance impact to the safecopy common case */
-static void ZSTD_safecopyDstBeforeSrc(BYTE* op, const BYTE* ip, ptrdiff_t length) {
-    ptrdiff_t const diff = op - ip;
-    BYTE* const oend = op + length;
-
-    if (length < 8 || diff > -8) {
-        /* Handle short lengths, close overlaps, and dst not before src. */
-        while (op < oend) *op++ = *ip++;
-        return;
-    }
-
-    if (op <= oend - WILDCOPY_OVERLENGTH && diff < -WILDCOPY_VECLEN) {
-        ZSTD_wildcopy(op, ip, oend - WILDCOPY_OVERLENGTH - op, ZSTD_no_overlap);
-        ip += oend - WILDCOPY_OVERLENGTH - op;
-        op += oend - WILDCOPY_OVERLENGTH - op;
-    }
-
-    /* Handle the leftovers. */
-    while (op < oend) *op++ = *ip++;
-}
-
-/* ZSTD_execSequenceEnd():
- * This version handles cases that are near the end of the output buffer. It requires
- * more careful checks to make sure there is no overflow. By separating out these hard
- * and unlikely cases, we can speed up the common cases.
- *
- * NOTE: This function needs to be fast for a single long sequence, but doesn't need
- * to be optimized for many small sequences, since those fall into ZSTD_execSequence().
- */
-FORCE_NOINLINE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_execSequenceEnd(BYTE* op,
-    BYTE* const oend, seq_t sequence,
-    const BYTE** litPtr, const BYTE* const litLimit,
-    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
-{
-    BYTE* const oLitEnd = op + sequence.litLength;
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-    BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
-
-    /* bounds checks : careful of address space overflow in 32-bit mode */
-    RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer");
-    RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer");
-    assert(op < op + sequenceLength);
-    assert(oLitEnd < op + sequenceLength);
-
-    /* copy literals */
-    ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap);
-    op = oLitEnd;
-    *litPtr = iLitEnd;
-
-    /* copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
-        /* offset beyond prefix */
-        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, "");
-        match = dictEnd - (prefixStart - match);
-        if (match + sequence.matchLength <= dictEnd) {
-            ZSTD_memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {   size_t const length1 = dictEnd - match;
-        ZSTD_memmove(oLitEnd, match, length1);
-        op = oLitEnd + length1;
-        sequence.matchLength -= length1;
-        match = prefixStart;
-        }
-    }
-    ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst);
-    return sequenceLength;
-}
-
-/* ZSTD_execSequenceEndSplitLitBuffer():
- * This version is intended to be used during instances where the litBuffer is still split.  It is kept separate to avoid performance impact for the good case.
- */
-FORCE_NOINLINE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_execSequenceEndSplitLitBuffer(BYTE* op,
-    BYTE* const oend, const BYTE* const oend_w, seq_t sequence,
-    const BYTE** litPtr, const BYTE* const litLimit,
-    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
-{
-    BYTE* const oLitEnd = op + sequence.litLength;
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-
-    /* bounds checks : careful of address space overflow in 32-bit mode */
-    RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer");
-    RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer");
-    assert(op < op + sequenceLength);
-    assert(oLitEnd < op + sequenceLength);
-
-    /* copy literals */
-    RETURN_ERROR_IF(op > *litPtr && op < *litPtr + sequence.litLength, dstSize_tooSmall, "output should not catch up to and overwrite literal buffer");
-    ZSTD_safecopyDstBeforeSrc(op, *litPtr, sequence.litLength);
-    op = oLitEnd;
-    *litPtr = iLitEnd;
-
-    /* copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
-        /* offset beyond prefix */
-        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, "");
-        match = dictEnd - (prefixStart - match);
-        if (match + sequence.matchLength <= dictEnd) {
-            ZSTD_memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {   size_t const length1 = dictEnd - match;
-        ZSTD_memmove(oLitEnd, match, length1);
-        op = oLitEnd + length1;
-        sequence.matchLength -= length1;
-        match = prefixStart;
-        }
-    }
-    ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst);
-    return sequenceLength;
-}
-
-HINT_INLINE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_execSequence(BYTE* op,
-    BYTE* const oend, seq_t sequence,
-    const BYTE** litPtr, const BYTE* const litLimit,
-    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
-{
-    BYTE* const oLitEnd = op + sequence.litLength;
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
-    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
-    BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;   /* risk : address space underflow on oend=NULL */
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-    assert(op != NULL /* Precondition */);
-    assert(oend_w < oend /* No underflow */);
-
-#if defined(__aarch64__)
-    /* prefetch sequence starting from match that will be used for copy later */
-    PREFETCH_L1(match);
-#endif
-    /* Handle edge cases in a slow path:
-     *   - Read beyond end of literals
-     *   - Match end is within WILDCOPY_OVERLIMIT of oend
-     *   - 32-bit mode and the match length overflows
-     */
-    if (UNLIKELY(
-        iLitEnd > litLimit ||
-        oMatchEnd > oend_w ||
-        (MEM_32bits() && (size_t)(oend - op) < sequenceLength + WILDCOPY_OVERLENGTH)))
-        return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
-
-    /* Assumptions (everything else goes into ZSTD_execSequenceEnd()) */
-    assert(op <= oLitEnd /* No overflow */);
-    assert(oLitEnd < oMatchEnd /* Non-zero match & no overflow */);
-    assert(oMatchEnd <= oend /* No underflow */);
-    assert(iLitEnd <= litLimit /* Literal length is in bounds */);
-    assert(oLitEnd <= oend_w /* Can wildcopy literals */);
-    assert(oMatchEnd <= oend_w /* Can wildcopy matches */);
-
-    /* Copy Literals:
-     * Split out litLength <= 16 since it is nearly always true. +1.6% on gcc-9.
-     * We likely don't need the full 32-byte wildcopy.
-     */
-    assert(WILDCOPY_OVERLENGTH >= 16);
-    ZSTD_copy16(op, (*litPtr));
-    if (UNLIKELY(sequence.litLength > 16)) {
-        ZSTD_wildcopy(op + 16, (*litPtr) + 16, sequence.litLength - 16, ZSTD_no_overlap);
-    }
-    op = oLitEnd;
-    *litPtr = iLitEnd;   /* update for next sequence */
-
-    /* Copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
-        /* offset beyond prefix -> go into extDict */
-        RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
-        match = dictEnd + (match - prefixStart);
-        if (match + sequence.matchLength <= dictEnd) {
-            ZSTD_memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {   size_t const length1 = dictEnd - match;
-        ZSTD_memmove(oLitEnd, match, length1);
-        op = oLitEnd + length1;
-        sequence.matchLength -= length1;
-        match = prefixStart;
-        }
-    }
-    /* Match within prefix of 1 or more bytes */
-    assert(op <= oMatchEnd);
-    assert(oMatchEnd <= oend_w);
-    assert(match >= prefixStart);
-    assert(sequence.matchLength >= 1);
-
-    /* Nearly all offsets are >= WILDCOPY_VECLEN bytes, which means we can use wildcopy
-     * without overlap checking.
-     */
-    if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
-        /* We bet on a full wildcopy for matches, since we expect matches to be
-         * longer than literals (in general). In silesia, ~10% of matches are longer
-         * than 16 bytes.
-         */
-        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength, ZSTD_no_overlap);
-        return sequenceLength;
-    }
-    assert(sequence.offset < WILDCOPY_VECLEN);
-
-    /* Copy 8 bytes and spread the offset to be >= 8. */
-    ZSTD_overlapCopy8(&op, &match, sequence.offset);
-
-    /* If the match length is > 8 bytes, then continue with the wildcopy. */
-    if (sequence.matchLength > 8) {
-        assert(op < oMatchEnd);
-        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength - 8, ZSTD_overlap_src_before_dst);
-    }
-    return sequenceLength;
-}
-
-HINT_INLINE
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-size_t ZSTD_execSequenceSplitLitBuffer(BYTE* op,
-    BYTE* const oend, const BYTE* const oend_w, seq_t sequence,
-    const BYTE** litPtr, const BYTE* const litLimit,
-    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
-{
-    BYTE* const oLitEnd = op + sequence.litLength;
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
-    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-    assert(op != NULL /* Precondition */);
-    assert(oend_w < oend /* No underflow */);
-    /* Handle edge cases in a slow path:
-     *   - Read beyond end of literals
-     *   - Match end is within WILDCOPY_OVERLIMIT of oend
-     *   - 32-bit mode and the match length overflows
-     */
-    if (UNLIKELY(
-            iLitEnd > litLimit ||
-            oMatchEnd > oend_w ||
-            (MEM_32bits() && (size_t)(oend - op) < sequenceLength + WILDCOPY_OVERLENGTH)))
-        return ZSTD_execSequenceEndSplitLitBuffer(op, oend, oend_w, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
-
-    /* Assumptions (everything else goes into ZSTD_execSequenceEnd()) */
-    assert(op <= oLitEnd /* No overflow */);
-    assert(oLitEnd < oMatchEnd /* Non-zero match & no overflow */);
-    assert(oMatchEnd <= oend /* No underflow */);
-    assert(iLitEnd <= litLimit /* Literal length is in bounds */);
-    assert(oLitEnd <= oend_w /* Can wildcopy literals */);
-    assert(oMatchEnd <= oend_w /* Can wildcopy matches */);
-
-    /* Copy Literals:
-     * Split out litLength <= 16 since it is nearly always true. +1.6% on gcc-9.
-     * We likely don't need the full 32-byte wildcopy.
-     */
-    assert(WILDCOPY_OVERLENGTH >= 16);
-    ZSTD_copy16(op, (*litPtr));
-    if (UNLIKELY(sequence.litLength > 16)) {
-        ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
-    }
-    op = oLitEnd;
-    *litPtr = iLitEnd;   /* update for next sequence */
-
-    /* Copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
-        /* offset beyond prefix -> go into extDict */
-        RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
-        match = dictEnd + (match - prefixStart);
-        if (match + sequence.matchLength <= dictEnd) {
-            ZSTD_memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {   size_t const length1 = dictEnd - match;
-            ZSTD_memmove(oLitEnd, match, length1);
-            op = oLitEnd + length1;
-            sequence.matchLength -= length1;
-            match = prefixStart;
-    }   }
-    /* Match within prefix of 1 or more bytes */
-    assert(op <= oMatchEnd);
-    assert(oMatchEnd <= oend_w);
-    assert(match >= prefixStart);
-    assert(sequence.matchLength >= 1);
-
-    /* Nearly all offsets are >= WILDCOPY_VECLEN bytes, which means we can use wildcopy
-     * without overlap checking.
-     */
-    if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
-        /* We bet on a full wildcopy for matches, since we expect matches to be
-         * longer than literals (in general). In silesia, ~10% of matches are longer
-         * than 16 bytes.
-         */
-        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength, ZSTD_no_overlap);
-        return sequenceLength;
-    }
-    assert(sequence.offset < WILDCOPY_VECLEN);
-
-    /* Copy 8 bytes and spread the offset to be >= 8. */
-    ZSTD_overlapCopy8(&op, &match, sequence.offset);
-
-    /* If the match length is > 8 bytes, then continue with the wildcopy. */
-    if (sequence.matchLength > 8) {
-        assert(op < oMatchEnd);
-        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8, ZSTD_overlap_src_before_dst);
-    }
-    return sequenceLength;
-}
-
-
-static void
-ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
-{
-    const void* ptr = dt;
-    const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
-    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
-    DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits",
-                (U32)DStatePtr->state, DTableH->tableLog);
-    BIT_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-FORCE_INLINE_TEMPLATE void
-ZSTD_updateFseStateWithDInfo(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, U16 nextState, U32 nbBits)
-{
-    size_t const lowBits = BIT_readBits(bitD, nbBits);
-    DStatePtr->state = nextState + lowBits;
-}
-
-/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum
- * offset bits. But we can only read at most STREAM_ACCUMULATOR_MIN_32
- * bits before reloading. This value is the maximum number of bytes we read
- * after reloading when we are decoding long offsets.
- */
-#define LONG_OFFSETS_MAX_EXTRA_BITS_32                       \
-    (ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32       \
-        ? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32  \
-        : 0)
-
-typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;
-
-/**
- * ZSTD_decodeSequence():
- * @p longOffsets : tells the decoder to reload more bit while decoding large offsets
- *                  only used in 32-bit mode
- * @return : Sequence (litL + matchL + offset)
- */
-FORCE_INLINE_TEMPLATE seq_t
-ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets, const int isLastSeq)
-{
-    seq_t seq;
-    /*
-     * ZSTD_seqSymbol is a 64 bits wide structure.
-     * It can be loaded in one operation
-     * and its fields extracted by simply shifting or bit-extracting on aarch64.
-     * GCC doesn't recognize this and generates more unnecessary ldr/ldrb/ldrh
-     * operations that cause performance drop. This can be avoided by using this
-     * ZSTD_memcpy hack.
-     */
-#if defined(__aarch64__) && (defined(__GNUC__) && !defined(__clang__))
-    ZSTD_seqSymbol llDInfoS, mlDInfoS, ofDInfoS;
-    ZSTD_seqSymbol* const llDInfo = &llDInfoS;
-    ZSTD_seqSymbol* const mlDInfo = &mlDInfoS;
-    ZSTD_seqSymbol* const ofDInfo = &ofDInfoS;
-    ZSTD_memcpy(llDInfo, seqState->stateLL.table + seqState->stateLL.state, sizeof(ZSTD_seqSymbol));
-    ZSTD_memcpy(mlDInfo, seqState->stateML.table + seqState->stateML.state, sizeof(ZSTD_seqSymbol));
-    ZSTD_memcpy(ofDInfo, seqState->stateOffb.table + seqState->stateOffb.state, sizeof(ZSTD_seqSymbol));
-#else
-    const ZSTD_seqSymbol* const llDInfo = seqState->stateLL.table + seqState->stateLL.state;
-    const ZSTD_seqSymbol* const mlDInfo = seqState->stateML.table + seqState->stateML.state;
-    const ZSTD_seqSymbol* const ofDInfo = seqState->stateOffb.table + seqState->stateOffb.state;
-#endif
-    seq.matchLength = mlDInfo->baseValue;
-    seq.litLength = llDInfo->baseValue;
-    {   U32 const ofBase = ofDInfo->baseValue;
-        BYTE const llBits = llDInfo->nbAdditionalBits;
-        BYTE const mlBits = mlDInfo->nbAdditionalBits;
-        BYTE const ofBits = ofDInfo->nbAdditionalBits;
-        BYTE const totalBits = llBits+mlBits+ofBits;
-
-        U16 const llNext = llDInfo->nextState;
-        U16 const mlNext = mlDInfo->nextState;
-        U16 const ofNext = ofDInfo->nextState;
-        U32 const llnbBits = llDInfo->nbBits;
-        U32 const mlnbBits = mlDInfo->nbBits;
-        U32 const ofnbBits = ofDInfo->nbBits;
-
-        assert(llBits <= MaxLLBits);
-        assert(mlBits <= MaxMLBits);
-        assert(ofBits <= MaxOff);
-        /*
-         * As gcc has better branch and block analyzers, sometimes it is only
-         * valuable to mark likeliness for clang, it gives around 3-4% of
-         * performance.
-         */
-
-        /* sequence */
-        {   size_t offset;
-            if (ofBits > 1) {
-                ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
-                ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
-                ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 > LONG_OFFSETS_MAX_EXTRA_BITS_32);
-                ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 - LONG_OFFSETS_MAX_EXTRA_BITS_32 >= MaxMLBits);
-                if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) {
-                    /* Always read extra bits, this keeps the logic simple,
-                     * avoids branches, and avoids accidentally reading 0 bits.
-                     */
-                    U32 const extraBits = LONG_OFFSETS_MAX_EXTRA_BITS_32;
-                    offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
-                    BIT_reloadDStream(&seqState->DStream);
-                    offset += BIT_readBitsFast(&seqState->DStream, extraBits);
-                } else {
-                    offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/);   /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */
-                    if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
-                }
-                seqState->prevOffset[2] = seqState->prevOffset[1];
-                seqState->prevOffset[1] = seqState->prevOffset[0];
-                seqState->prevOffset[0] = offset;
-            } else {
-                U32 const ll0 = (llDInfo->baseValue == 0);
-                if (LIKELY((ofBits == 0))) {
-                    offset = seqState->prevOffset[ll0];
-                    seqState->prevOffset[1] = seqState->prevOffset[!ll0];
-                    seqState->prevOffset[0] = offset;
-                } else {
-                    offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
-                    {   size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
-                        temp -= !temp; /* 0 is not valid: input corrupted => force offset to -1 => corruption detected at execSequence */
-                        if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
-                        seqState->prevOffset[1] = seqState->prevOffset[0];
-                        seqState->prevOffset[0] = offset = temp;
-            }   }   }
-            seq.offset = offset;
-        }
-
-        if (mlBits > 0)
-            seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
-
-        if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
-            BIT_reloadDStream(&seqState->DStream);
-        if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
-            BIT_reloadDStream(&seqState->DStream);
-        /* Ensure there are enough bits to read the rest of data in 64-bit mode. */
-        ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
-
-        if (llBits > 0)
-            seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
-
-        if (MEM_32bits())
-            BIT_reloadDStream(&seqState->DStream);
-
-        DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u",
-                    (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
-
-        if (!isLastSeq) {
-            /* don't update FSE state for last Sequence */
-            ZSTD_updateFseStateWithDInfo(&seqState->stateLL, &seqState->DStream, llNext, llnbBits);    /* <=  9 bits */
-            ZSTD_updateFseStateWithDInfo(&seqState->stateML, &seqState->DStream, mlNext, mlnbBits);    /* <=  9 bits */
-            if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
-            ZSTD_updateFseStateWithDInfo(&seqState->stateOffb, &seqState->DStream, ofNext, ofnbBits);  /* <=  8 bits */
-            BIT_reloadDStream(&seqState->DStream);
-        }
-    }
-
-    return seq;
-}
-
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-#if DEBUGLEVEL >= 1
-static int ZSTD_dictionaryIsActive(ZSTD_DCtx const* dctx, BYTE const* prefixStart, BYTE const* oLitEnd)
-{
-    size_t const windowSize = dctx->fParams.windowSize;
-    /* No dictionary used. */
-    if (dctx->dictContentEndForFuzzing == NULL) return 0;
-    /* Dictionary is our prefix. */
-    if (prefixStart == dctx->dictContentBeginForFuzzing) return 1;
-    /* Dictionary is not our ext-dict. */
-    if (dctx->dictEnd != dctx->dictContentEndForFuzzing) return 0;
-    /* Dictionary is not within our window size. */
-    if ((size_t)(oLitEnd - prefixStart) >= windowSize) return 0;
-    /* Dictionary is active. */
-    return 1;
-}
-#endif
-
-static void ZSTD_assertValidSequence(
-        ZSTD_DCtx const* dctx,
-        BYTE const* op, BYTE const* oend,
-        seq_t const seq,
-        BYTE const* prefixStart, BYTE const* virtualStart)
-{
-#if DEBUGLEVEL >= 1
-    if (dctx->isFrameDecompression) {
-        size_t const windowSize = dctx->fParams.windowSize;
-        size_t const sequenceSize = seq.litLength + seq.matchLength;
-        BYTE const* const oLitEnd = op + seq.litLength;
-        DEBUGLOG(6, "Checking sequence: litL=%u matchL=%u offset=%u",
-                (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
-        assert(op <= oend);
-        assert((size_t)(oend - op) >= sequenceSize);
-        assert(sequenceSize <= ZSTD_blockSizeMax(dctx));
-        if (ZSTD_dictionaryIsActive(dctx, prefixStart, oLitEnd)) {
-            size_t const dictSize = (size_t)((char const*)dctx->dictContentEndForFuzzing - (char const*)dctx->dictContentBeginForFuzzing);
-            /* Offset must be within the dictionary. */
-            assert(seq.offset <= (size_t)(oLitEnd - virtualStart));
-            assert(seq.offset <= windowSize + dictSize);
-        } else {
-            /* Offset must be within our window. */
-            assert(seq.offset <= windowSize);
-        }
-    }
-#else
-    (void)dctx, (void)op, (void)oend, (void)seq, (void)prefixStart, (void)virtualStart;
-#endif
-}
-#endif
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
-
-
-FORCE_INLINE_TEMPLATE size_t
-DONT_VECTORIZE
-ZSTD_decompressSequences_bodySplitLitBuffer( ZSTD_DCtx* dctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize, int nbSeq,
-                         const ZSTD_longOffset_e isLongOffset)
-{
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ZSTD_maybeNullPtrAdd(ostart, maxDstSize);
-    BYTE* op = ostart;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* litBufferEnd = dctx->litBufferEnd;
-    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
-    const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
-    DEBUGLOG(5, "ZSTD_decompressSequences_bodySplitLitBuffer (%i seqs)", nbSeq);
-
-    /* Literals are split between internal buffer & output buffer */
-    if (nbSeq) {
-        seqState_t seqState;
-        dctx->fseEntropy = 1;
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
-        RETURN_ERROR_IF(
-            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
-            corruption_detected, "");
-        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
-        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
-        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
-        assert(dst != NULL);
-
-        ZSTD_STATIC_ASSERT(
-                BIT_DStream_unfinished < BIT_DStream_completed &&
-                BIT_DStream_endOfBuffer < BIT_DStream_completed &&
-                BIT_DStream_completed < BIT_DStream_overflow);
-
-        /* decompress without overrunning litPtr begins */
-        {   seq_t sequence = {0,0,0};  /* some static analyzer believe that @sequence is not initialized (it necessarily is, since for(;;) loop as at least one iteration) */
-            /* Align the decompression loop to 32 + 16 bytes.
-                *
-                * zstd compiled with gcc-9 on an Intel i9-9900k shows 10% decompression
-                * speed swings based on the alignment of the decompression loop. This
-                * performance swing is caused by parts of the decompression loop falling
-                * out of the DSB. The entire decompression loop should fit in the DSB,
-                * when it can't we get much worse performance. You can measure if you've
-                * hit the good case or the bad case with this perf command for some
-                * compressed file test.zst:
-                *
-                *   perf stat -e cycles -e instructions -e idq.all_dsb_cycles_any_uops \
-                *             -e idq.all_mite_cycles_any_uops -- ./zstd -tq test.zst
-                *
-                * If you see most cycles served out of the MITE you've hit the bad case.
-                * If you see most cycles served out of the DSB you've hit the good case.
-                * If it is pretty even then you may be in an okay case.
-                *
-                * This issue has been reproduced on the following CPUs:
-                *   - Kabylake: Macbook Pro (15-inch, 2019) 2.4 GHz Intel Core i9
-                *               Use Instruments->Counters to get DSB/MITE cycles.
-                *               I never got performance swings, but I was able to
-                *               go from the good case of mostly DSB to half of the
-                *               cycles served from MITE.
-                *   - Coffeelake: Intel i9-9900k
-                *   - Coffeelake: Intel i7-9700k
-                *
-                * I haven't been able to reproduce the instability or DSB misses on any
-                * of the following CPUS:
-                *   - Haswell
-                *   - Broadwell: Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GH
-                *   - Skylake
-                *
-                * Alignment is done for each of the three major decompression loops:
-                *   - ZSTD_decompressSequences_bodySplitLitBuffer - presplit section of the literal buffer
-                *   - ZSTD_decompressSequences_bodySplitLitBuffer - postsplit section of the literal buffer
-                *   - ZSTD_decompressSequences_body
-                * Alignment choices are made to minimize large swings on bad cases and influence on performance
-                * from changes external to this code, rather than to overoptimize on the current commit.
-                *
-                * If you are seeing performance stability this script can help test.
-                * It tests on 4 commits in zstd where I saw performance change.
-                *
-                *   https://gist.github.com/terrelln/9889fc06a423fd5ca6e99351564473f4
-                */
-#if defined(__GNUC__) && defined(__x86_64__)
-            __asm__(".p2align 6");
-#  if __GNUC__ >= 7
-	    /* good for gcc-7, gcc-9, and gcc-11 */
-            __asm__("nop");
-            __asm__(".p2align 5");
-            __asm__("nop");
-            __asm__(".p2align 4");
-#    if __GNUC__ == 8 || __GNUC__ == 10
-	    /* good for gcc-8 and gcc-10 */
-            __asm__("nop");
-            __asm__(".p2align 3");
-#    endif
-#  endif
-#endif
-
-            /* Handle the initial state where litBuffer is currently split between dst and litExtraBuffer */
-            for ( ; nbSeq; nbSeq--) {
-                sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq==1);
-                if (litPtr + sequence.litLength > dctx->litBufferEnd) break;
-                {   size_t const oneSeqSize = ZSTD_execSequenceSplitLitBuffer(op, oend, litPtr + sequence.litLength - WILDCOPY_OVERLENGTH, sequence, &litPtr, litBufferEnd, prefixStart, vBase, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                    assert(!ZSTD_isError(oneSeqSize));
-                    ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);
-#endif
-                    if (UNLIKELY(ZSTD_isError(oneSeqSize)))
-                        return oneSeqSize;
-                    DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
-                    op += oneSeqSize;
-            }   }
-            DEBUGLOG(6, "reached: (litPtr + sequence.litLength > dctx->litBufferEnd)");
-
-            /* If there are more sequences, they will need to read literals from litExtraBuffer; copy over the remainder from dst and update litPtr and litEnd */
-            if (nbSeq > 0) {
-                const size_t leftoverLit = dctx->litBufferEnd - litPtr;
-                DEBUGLOG(6, "There are %i sequences left, and %zu/%zu literals left in buffer", nbSeq, leftoverLit, sequence.litLength);
-                if (leftoverLit) {
-                    RETURN_ERROR_IF(leftoverLit > (size_t)(oend - op), dstSize_tooSmall, "remaining lit must fit within dstBuffer");
-                    ZSTD_safecopyDstBeforeSrc(op, litPtr, leftoverLit);
-                    sequence.litLength -= leftoverLit;
-                    op += leftoverLit;
-                }
-                litPtr = dctx->litExtraBuffer;
-                litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;
-                dctx->litBufferLocation = ZSTD_not_in_dst;
-                {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litBufferEnd, prefixStart, vBase, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                    assert(!ZSTD_isError(oneSeqSize));
-                    ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);
-#endif
-                    if (UNLIKELY(ZSTD_isError(oneSeqSize)))
-                        return oneSeqSize;
-                    DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
-                    op += oneSeqSize;
-                }
-                nbSeq--;
-            }
-        }
-
-        if (nbSeq > 0) {
-            /* there is remaining lit from extra buffer */
-
-#if defined(__GNUC__) && defined(__x86_64__)
-            __asm__(".p2align 6");
-            __asm__("nop");
-#  if __GNUC__ != 7
-            /* worse for gcc-7 better for gcc-8, gcc-9, and gcc-10 and clang */
-            __asm__(".p2align 4");
-            __asm__("nop");
-            __asm__(".p2align 3");
-#  elif __GNUC__ >= 11
-            __asm__(".p2align 3");
-#  else
-            __asm__(".p2align 5");
-            __asm__("nop");
-            __asm__(".p2align 3");
-#  endif
-#endif
-
-            for ( ; nbSeq ; nbSeq--) {
-                seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq==1);
-                size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litBufferEnd, prefixStart, vBase, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                assert(!ZSTD_isError(oneSeqSize));
-                ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);
-#endif
-                if (UNLIKELY(ZSTD_isError(oneSeqSize)))
-                    return oneSeqSize;
-                DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
-                op += oneSeqSize;
-            }
-        }
-
-        /* check if reached exact end */
-        DEBUGLOG(5, "ZSTD_decompressSequences_bodySplitLitBuffer: after decode loop, remaining nbSeq : %i", nbSeq);
-        RETURN_ERROR_IF(nbSeq, corruption_detected, "");
-        DEBUGLOG(5, "bitStream : start=%p, ptr=%p, bitsConsumed=%u", seqState.DStream.start, seqState.DStream.ptr, seqState.DStream.bitsConsumed);
-        RETURN_ERROR_IF(!BIT_endOfDStream(&seqState.DStream), corruption_detected, "");
-        /* save reps for next block */
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
-    }
-
-    /* last literal segment */
-    if (dctx->litBufferLocation == ZSTD_split) {
-        /* split hasn't been reached yet, first get dst then copy litExtraBuffer */
-        size_t const lastLLSize = (size_t)(litBufferEnd - litPtr);
-        DEBUGLOG(6, "copy last literals from segment : %u", (U32)lastLLSize);
-        RETURN_ERROR_IF(lastLLSize > (size_t)(oend - op), dstSize_tooSmall, "");
-        if (op != NULL) {
-            ZSTD_memmove(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-        litPtr = dctx->litExtraBuffer;
-        litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;
-        dctx->litBufferLocation = ZSTD_not_in_dst;
-    }
-    /* copy last literals from internal buffer */
-    {   size_t const lastLLSize = (size_t)(litBufferEnd - litPtr);
-        DEBUGLOG(6, "copy last literals from internal buffer : %u", (U32)lastLLSize);
-        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
-        if (op != NULL) {
-            ZSTD_memcpy(op, litPtr, lastLLSize);
-            op += lastLLSize;
-    }   }
-
-    DEBUGLOG(6, "decoded block of size %u bytes", (U32)(op - ostart));
-    return (size_t)(op - ostart);
-}
-
-FORCE_INLINE_TEMPLATE size_t
-DONT_VECTORIZE
-ZSTD_decompressSequences_body(ZSTD_DCtx* dctx,
-    void* dst, size_t maxDstSize,
-    const void* seqStart, size_t seqSize, int nbSeq,
-    const ZSTD_longOffset_e isLongOffset)
-{
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = dctx->litBufferLocation == ZSTD_not_in_dst ? ZSTD_maybeNullPtrAdd(ostart, maxDstSize) : dctx->litBuffer;
-    BYTE* op = ostart;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    const BYTE* const prefixStart = (const BYTE*)(dctx->prefixStart);
-    const BYTE* const vBase = (const BYTE*)(dctx->virtualStart);
-    const BYTE* const dictEnd = (const BYTE*)(dctx->dictEnd);
-    DEBUGLOG(5, "ZSTD_decompressSequences_body: nbSeq = %d", nbSeq);
-
-    /* Regen sequences */
-    if (nbSeq) {
-        seqState_t seqState;
-        dctx->fseEntropy = 1;
-        { U32 i; for (i = 0; i < ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
-        RETURN_ERROR_IF(
-            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend - ip)),
-            corruption_detected, "");
-        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
-        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
-        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
-        assert(dst != NULL);
-
-#if defined(__GNUC__) && defined(__x86_64__)
-            __asm__(".p2align 6");
-            __asm__("nop");
-#  if __GNUC__ >= 7
-            __asm__(".p2align 5");
-            __asm__("nop");
-            __asm__(".p2align 3");
-#  else
-            __asm__(".p2align 4");
-            __asm__("nop");
-            __asm__(".p2align 3");
-#  endif
-#endif
-
-        for ( ; nbSeq ; nbSeq--) {
-            seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq==1);
-            size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, prefixStart, vBase, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-            assert(!ZSTD_isError(oneSeqSize));
-            ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);
-#endif
-            if (UNLIKELY(ZSTD_isError(oneSeqSize)))
-                return oneSeqSize;
-            DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
-        assert(nbSeq == 0);
-        RETURN_ERROR_IF(!BIT_endOfDStream(&seqState.DStream), corruption_detected, "");
-        /* save reps for next block */
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
-    }
-
-    /* last literal segment */
-    {   size_t const lastLLSize = (size_t)(litEnd - litPtr);
-        DEBUGLOG(6, "copy last literals : %u", (U32)lastLLSize);
-        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
-        if (op != NULL) {
-            ZSTD_memcpy(op, litPtr, lastLLSize);
-            op += lastLLSize;
-    }   }
-
-    DEBUGLOG(6, "decoded block of size %u bytes", (U32)(op - ostart));
-    return (size_t)(op - ostart);
-}
-
-static size_t
-ZSTD_decompressSequences_default(ZSTD_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                           const void* seqStart, size_t seqSize, int nbSeq,
-                           const ZSTD_longOffset_e isLongOffset)
-{
-    return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-
-static size_t
-ZSTD_decompressSequencesSplitLitBuffer_default(ZSTD_DCtx* dctx,
-                                               void* dst, size_t maxDstSize,
-                                         const void* seqStart, size_t seqSize, int nbSeq,
-                                         const ZSTD_longOffset_e isLongOffset)
-{
-    return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
-
-FORCE_INLINE_TEMPLATE
-
-size_t ZSTD_prefetchMatch(size_t prefetchPos, seq_t const sequence,
-                   const BYTE* const prefixStart, const BYTE* const dictEnd)
-{
-    prefetchPos += sequence.litLength;
-    {   const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart;
-        /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.
-         * No consequence though : memory address is only used for prefetching, not for dereferencing */
-        const BYTE* const match = ZSTD_wrappedPtrSub(ZSTD_wrappedPtrAdd(matchBase, prefetchPos), sequence.offset);
-        PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE);   /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
-    }
-    return prefetchPos + sequence.matchLength;
-}
-
-/* This decoding function employs prefetching
- * to reduce latency impact of cache misses.
- * It's generally employed when block contains a significant portion of long-distance matches
- * or when coupled with a "cold" dictionary */
-FORCE_INLINE_TEMPLATE size_t
-ZSTD_decompressSequencesLong_body(
-                               ZSTD_DCtx* dctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize, int nbSeq,
-                         const ZSTD_longOffset_e isLongOffset)
-{
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = dctx->litBufferLocation == ZSTD_in_dst ? dctx->litBuffer : ZSTD_maybeNullPtrAdd(ostart, maxDstSize);
-    BYTE* op = ostart;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* litBufferEnd = dctx->litBufferEnd;
-    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
-    const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
-
-    /* Regen sequences */
-    if (nbSeq) {
-#define STORED_SEQS 8
-#define STORED_SEQS_MASK (STORED_SEQS-1)
-#define ADVANCED_SEQS STORED_SEQS
-        seq_t sequences[STORED_SEQS];
-        int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
-        seqState_t seqState;
-        int seqNb;
-        size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */
-
-        dctx->fseEntropy = 1;
-        { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
-        assert(dst != NULL);
-        assert(iend >= ip);
-        RETURN_ERROR_IF(
-            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
-            corruption_detected, "");
-        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
-        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
-        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
-
-        /* prepare in advance */
-        for (seqNb=0; seqNb<seqAdvance; seqNb++) {
-            seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, seqNb == nbSeq-1);
-            prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd);
-            sequences[seqNb] = sequence;
-        }
-
-        /* decompress without stomping litBuffer */
-        for (; seqNb < nbSeq; seqNb++) {
-            seq_t sequence = ZSTD_decodeSequence(&seqState, isLongOffset, seqNb == nbSeq-1);
-
-            if (dctx->litBufferLocation == ZSTD_split && litPtr + sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK].litLength > dctx->litBufferEnd) {
-                /* lit buffer is reaching split point, empty out the first buffer and transition to litExtraBuffer */
-                const size_t leftoverLit = dctx->litBufferEnd - litPtr;
-                if (leftoverLit)
-                {
-                    RETURN_ERROR_IF(leftoverLit > (size_t)(oend - op), dstSize_tooSmall, "remaining lit must fit within dstBuffer");
-                    ZSTD_safecopyDstBeforeSrc(op, litPtr, leftoverLit);
-                    sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK].litLength -= leftoverLit;
-                    op += leftoverLit;
-                }
-                litPtr = dctx->litExtraBuffer;
-                litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;
-                dctx->litBufferLocation = ZSTD_not_in_dst;
-                {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                    assert(!ZSTD_isError(oneSeqSize));
-                    ZSTD_assertValidSequence(dctx, op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], prefixStart, dictStart);
-#endif
-                    if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-
-                    prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd);
-                    sequences[seqNb & STORED_SEQS_MASK] = sequence;
-                    op += oneSeqSize;
-            }   }
-            else
-            {
-                /* lit buffer is either wholly contained in first or second split, or not split at all*/
-                size_t const oneSeqSize = dctx->litBufferLocation == ZSTD_split ?
-                    ZSTD_execSequenceSplitLitBuffer(op, oend, litPtr + sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK].litLength - WILDCOPY_OVERLENGTH, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd) :
-                    ZSTD_execSequence(op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                assert(!ZSTD_isError(oneSeqSize));
-                ZSTD_assertValidSequence(dctx, op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], prefixStart, dictStart);
-#endif
-                if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-
-                prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd);
-                sequences[seqNb & STORED_SEQS_MASK] = sequence;
-                op += oneSeqSize;
-            }
-        }
-        RETURN_ERROR_IF(!BIT_endOfDStream(&seqState.DStream), corruption_detected, "");
-
-        /* finish queue */
-        seqNb -= seqAdvance;
-        for ( ; seqNb<nbSeq ; seqNb++) {
-            seq_t *sequence = &(sequences[seqNb&STORED_SEQS_MASK]);
-            if (dctx->litBufferLocation == ZSTD_split && litPtr + sequence->litLength > dctx->litBufferEnd) {
-                const size_t leftoverLit = dctx->litBufferEnd - litPtr;
-                if (leftoverLit) {
-                    RETURN_ERROR_IF(leftoverLit > (size_t)(oend - op), dstSize_tooSmall, "remaining lit must fit within dstBuffer");
-                    ZSTD_safecopyDstBeforeSrc(op, litPtr, leftoverLit);
-                    sequence->litLength -= leftoverLit;
-                    op += leftoverLit;
-                }
-                litPtr = dctx->litExtraBuffer;
-                litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;
-                dctx->litBufferLocation = ZSTD_not_in_dst;
-                {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, *sequence, &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                    assert(!ZSTD_isError(oneSeqSize));
-                    ZSTD_assertValidSequence(dctx, op, oend, sequences[seqNb&STORED_SEQS_MASK], prefixStart, dictStart);
-#endif
-                    if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-                    op += oneSeqSize;
-                }
-            }
-            else
-            {
-                size_t const oneSeqSize = dctx->litBufferLocation == ZSTD_split ?
-                    ZSTD_execSequenceSplitLitBuffer(op, oend, litPtr + sequence->litLength - WILDCOPY_OVERLENGTH, *sequence, &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd) :
-                    ZSTD_execSequence(op, oend, *sequence, &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
-                assert(!ZSTD_isError(oneSeqSize));
-                ZSTD_assertValidSequence(dctx, op, oend, sequences[seqNb&STORED_SEQS_MASK], prefixStart, dictStart);
-#endif
-                if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-                op += oneSeqSize;
-            }
-        }
-
-        /* save reps for next block */
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
-    }
-
-    /* last literal segment */
-    if (dctx->litBufferLocation == ZSTD_split) { /* first deplete literal buffer in dst, then copy litExtraBuffer */
-        size_t const lastLLSize = litBufferEnd - litPtr;
-        RETURN_ERROR_IF(lastLLSize > (size_t)(oend - op), dstSize_tooSmall, "");
-        if (op != NULL) {
-            ZSTD_memmove(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-        litPtr = dctx->litExtraBuffer;
-        litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;
-    }
-    {   size_t const lastLLSize = litBufferEnd - litPtr;
-        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
-        if (op != NULL) {
-            ZSTD_memmove(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-    }
-
-    return (size_t)(op - ostart);
-}
-
-static size_t
-ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                           const void* seqStart, size_t seqSize, int nbSeq,
-                           const ZSTD_longOffset_e isLongOffset)
-{
-    return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
-
-
-
-#if DYNAMIC_BMI2
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
-static BMI2_TARGET_ATTRIBUTE size_t
-DONT_VECTORIZE
-ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                           const void* seqStart, size_t seqSize, int nbSeq,
-                           const ZSTD_longOffset_e isLongOffset)
-{
-    return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-static BMI2_TARGET_ATTRIBUTE size_t
-DONT_VECTORIZE
-ZSTD_decompressSequencesSplitLitBuffer_bmi2(ZSTD_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                           const void* seqStart, size_t seqSize, int nbSeq,
-                           const ZSTD_longOffset_e isLongOffset)
-{
-    return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
-static BMI2_TARGET_ATTRIBUTE size_t
-ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                           const void* seqStart, size_t seqSize, int nbSeq,
-                           const ZSTD_longOffset_e isLongOffset)
-{
-    return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
-
-#endif /* DYNAMIC_BMI2 */
-
-typedef size_t (*ZSTD_decompressSequences_t)(
-                            ZSTD_DCtx* dctx,
-                            void* dst, size_t maxDstSize,
-                            const void* seqStart, size_t seqSize, int nbSeq,
-                            const ZSTD_longOffset_e isLongOffset);
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
-static size_t
-ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
-                   const void* seqStart, size_t seqSize, int nbSeq,
-                   const ZSTD_longOffset_e isLongOffset)
-{
-    DEBUGLOG(5, "ZSTD_decompressSequences");
-#if DYNAMIC_BMI2
-    if (ZSTD_DCtx_get_bmi2(dctx)) {
-        return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-    }
-#endif
-    return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-static size_t
-ZSTD_decompressSequencesSplitLitBuffer(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
-                                 const void* seqStart, size_t seqSize, int nbSeq,
-                                 const ZSTD_longOffset_e isLongOffset)
-{
-    DEBUGLOG(5, "ZSTD_decompressSequencesSplitLitBuffer");
-#if DYNAMIC_BMI2
-    if (ZSTD_DCtx_get_bmi2(dctx)) {
-        return ZSTD_decompressSequencesSplitLitBuffer_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-    }
-#endif
-    return ZSTD_decompressSequencesSplitLitBuffer_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
-
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
-/* ZSTD_decompressSequencesLong() :
- * decompression function triggered when a minimum share of offsets is considered "long",
- * aka out of cache.
- * note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes meaning "farther than memory cache distance".
- * This function will try to mitigate main memory latency through the use of prefetching */
-static size_t
-ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
-                             void* dst, size_t maxDstSize,
-                             const void* seqStart, size_t seqSize, int nbSeq,
-                             const ZSTD_longOffset_e isLongOffset)
-{
-    DEBUGLOG(5, "ZSTD_decompressSequencesLong");
-#if DYNAMIC_BMI2
-    if (ZSTD_DCtx_get_bmi2(dctx)) {
-        return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-    }
-#endif
-  return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
-}
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
-
-
-/**
- * @returns The total size of the history referenceable by zstd, including
- * both the prefix and the extDict. At @p op any offset larger than this
- * is invalid.
- */
-static size_t ZSTD_totalHistorySize(BYTE* op, BYTE const* virtualStart)
-{
-    return (size_t)(op - virtualStart);
-}
-
-typedef struct {
-    unsigned longOffsetShare;
-    unsigned maxNbAdditionalBits;
-} ZSTD_OffsetInfo;
-
-/* ZSTD_getOffsetInfo() :
- * condition : offTable must be valid
- * @return : "share" of long offsets (arbitrarily defined as > (1<<23))
- *           compared to maximum possible of (1<<OffFSELog),
- *           as well as the maximum number additional bits required.
- */
-static ZSTD_OffsetInfo
-ZSTD_getOffsetInfo(const ZSTD_seqSymbol* offTable, int nbSeq)
-{
-    ZSTD_OffsetInfo info = {0, 0};
-    /* If nbSeq == 0, then the offTable is uninitialized, but we have
-     * no sequences, so both values should be 0.
-     */
-    if (nbSeq != 0) {
-        const void* ptr = offTable;
-        U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
-        const ZSTD_seqSymbol* table = offTable + 1;
-        U32 const max = 1 << tableLog;
-        U32 u;
-        DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog);
-
-        assert(max <= (1 << OffFSELog));  /* max not too large */
-        for (u=0; u<max; u++) {
-            info.maxNbAdditionalBits = MAX(info.maxNbAdditionalBits, table[u].nbAdditionalBits);
-            if (table[u].nbAdditionalBits > 22) info.longOffsetShare += 1;
-        }
-
-        assert(tableLog <= OffFSELog);
-        info.longOffsetShare <<= (OffFSELog - tableLog);  /* scale to OffFSELog */
-    }
-
-    return info;
-}
-
-/**
- * @returns The maximum offset we can decode in one read of our bitstream, without
- * reloading more bits in the middle of the offset bits read. Any offsets larger
- * than this must use the long offset decoder.
- */
-static size_t ZSTD_maxShortOffset(void)
-{
-    if (MEM_64bits()) {
-        /* We can decode any offset without reloading bits.
-         * This might change if the max window size grows.
-         */
-        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
-        return (size_t)-1;
-    } else {
-        /* The maximum offBase is (1 << (STREAM_ACCUMULATOR_MIN + 1)) - 1.
-         * This offBase would require STREAM_ACCUMULATOR_MIN extra bits.
-         * Then we have to subtract ZSTD_REP_NUM to get the maximum possible offset.
-         */
-        size_t const maxOffbase = ((size_t)1 << (STREAM_ACCUMULATOR_MIN + 1)) - 1;
-        size_t const maxOffset = maxOffbase - ZSTD_REP_NUM;
-        assert(ZSTD_highbit32((U32)maxOffbase) == STREAM_ACCUMULATOR_MIN);
-        return maxOffset;
-    }
-}
-
-size_t
-ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize, const streaming_operation streaming)
-{   /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-    DEBUGLOG(5, "ZSTD_decompressBlock_internal (cSize : %u)", (unsigned)srcSize);
-
-    /* Note : the wording of the specification
-     * allows compressed block to be sized exactly ZSTD_blockSizeMax(dctx).
-     * This generally does not happen, as it makes little sense,
-     * since an uncompressed block would feature same size and have no decompression cost.
-     * Also, note that decoder from reference libzstd before < v1.5.4
-     * would consider this edge case as an error.
-     * As a consequence, avoid generating compressed blocks of size ZSTD_blockSizeMax(dctx)
-     * for broader compatibility with the deployed ecosystem of zstd decoders */
-    RETURN_ERROR_IF(srcSize > ZSTD_blockSizeMax(dctx), srcSize_wrong, "");
-
-    /* Decode literals section */
-    {   size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, streaming);
-        DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : cSize=%u, nbLiterals=%zu", (U32)litCSize, dctx->litSize);
-        if (ZSTD_isError(litCSize)) return litCSize;
-        ip += litCSize;
-        srcSize -= litCSize;
-    }
-
-    /* Build Decoding Tables */
-    {
-        /* Compute the maximum block size, which must also work when !frame and fParams are unset.
-         * Additionally, take the min with dstCapacity to ensure that the totalHistorySize fits in a size_t.
-         */
-        size_t const blockSizeMax = MIN(dstCapacity, ZSTD_blockSizeMax(dctx));
-        size_t const totalHistorySize = ZSTD_totalHistorySize(ZSTD_maybeNullPtrAdd((BYTE*)dst, blockSizeMax), (BYTE const*)dctx->virtualStart);
-        /* isLongOffset must be true if there are long offsets.
-         * Offsets are long if they are larger than ZSTD_maxShortOffset().
-         * We don't expect that to be the case in 64-bit mode.
-         *
-         * We check here to see if our history is large enough to allow long offsets.
-         * If it isn't, then we can't possible have (valid) long offsets. If the offset
-         * is invalid, then it is okay to read it incorrectly.
-         *
-         * If isLongOffsets is true, then we will later check our decoding table to see
-         * if it is even possible to generate long offsets.
-         */
-        ZSTD_longOffset_e isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (totalHistorySize > ZSTD_maxShortOffset()));
-        /* These macros control at build-time which decompressor implementation
-         * we use. If neither is defined, we do some inspection and dispatch at
-         * runtime.
-         */
-#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
-    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
-        int usePrefetchDecoder = dctx->ddictIsCold;
-#else
-        /* Set to 1 to avoid computing offset info if we don't need to.
-         * Otherwise this value is ignored.
-         */
-        int usePrefetchDecoder = 1;
-#endif
-        int nbSeq;
-        size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
-        if (ZSTD_isError(seqHSize)) return seqHSize;
-        ip += seqHSize;
-        srcSize -= seqHSize;
-
-        RETURN_ERROR_IF((dst == NULL || dstCapacity == 0) && nbSeq > 0, dstSize_tooSmall, "NULL not handled");
-        RETURN_ERROR_IF(MEM_64bits() && sizeof(size_t) == sizeof(void*) && (size_t)(-1) - (size_t)dst < (size_t)(1 << 20), dstSize_tooSmall,
-                "invalid dst");
-
-        /* If we could potentially have long offsets, or we might want to use the prefetch decoder,
-         * compute information about the share of long offsets, and the maximum nbAdditionalBits.
-         * NOTE: could probably use a larger nbSeq limit
-         */
-        if (isLongOffset || (!usePrefetchDecoder && (totalHistorySize > (1u << 24)) && (nbSeq > 8))) {
-            ZSTD_OffsetInfo const info = ZSTD_getOffsetInfo(dctx->OFTptr, nbSeq);
-            if (isLongOffset && info.maxNbAdditionalBits <= STREAM_ACCUMULATOR_MIN) {
-                /* If isLongOffset, but the maximum number of additional bits that we see in our table is small
-                 * enough, then we know it is impossible to have too long an offset in this block, so we can
-                 * use the regular offset decoder.
-                 */
-                isLongOffset = ZSTD_lo_isRegularOffset;
-            }
-            if (!usePrefetchDecoder) {
-                U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
-                usePrefetchDecoder = (info.longOffsetShare >= minShare);
-            }
-        }
-
-        dctx->ddictIsCold = 0;
-
-#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
-    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
-        if (usePrefetchDecoder) {
-#else
-        (void)usePrefetchDecoder;
-        {
-#endif
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
-            return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
-#endif
-        }
-
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
-        /* else */
-        if (dctx->litBufferLocation == ZSTD_split)
-            return ZSTD_decompressSequencesSplitLitBuffer(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
-        else
-            return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
-#endif
-    }
-}
-
-
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
-{
-    if (dst != dctx->previousDstEnd && dstSize > 0) {   /* not contiguous */
-        dctx->dictEnd = dctx->previousDstEnd;
-        dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
-        dctx->prefixStart = dst;
-        dctx->previousDstEnd = dst;
-    }
-}
-
-
-size_t ZSTD_decompressBlock_deprecated(ZSTD_DCtx* dctx,
-                                       void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize)
-{
-    size_t dSize;
-    dctx->isFrameDecompression = 0;
-    ZSTD_checkContinuity(dctx, dst, dstCapacity);
-    dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, not_streaming);
-    FORWARD_IF_ERROR(dSize, "");
-    dctx->previousDstEnd = (char*)dst + dSize;
-    return dSize;
-}
-
-
-/* NOTE: Must just wrap ZSTD_decompressBlock_deprecated() */
-size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
-    return ZSTD_decompressBlock_deprecated(dctx, dst, dstCapacity, src, srcSize);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/deprecated/zbuff_common.cpp b/src/duckdb/third_party/zstd/deprecated/zbuff_common.cpp
deleted file mode 100644
index 489498ce4..000000000
--- a/src/duckdb/third_party/zstd/deprecated/zbuff_common.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zstd/common/error_private.h"
-#include "zstd/deprecated/zbuff.h"
-
-namespace duckdb_zstd {
-
-/*-****************************************
-*  ZBUFF Error Management  (deprecated)
-******************************************/
-
-/*! ZBUFF_isError() :
-*   tells if a return value is an error code */
-unsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); }
-/*! ZBUFF_getErrorName() :
-*   provides error code string from function result (useful for debugging) */
-const char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/deprecated/zbuff_compress.cpp b/src/duckdb/third_party/zstd/deprecated/zbuff_compress.cpp
deleted file mode 100644
index 5c63dac49..000000000
--- a/src/duckdb/third_party/zstd/deprecated/zbuff_compress.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-
-/* *************************************
-*  Dependencies
-***************************************/
-#define ZBUFF_STATIC_LINKING_ONLY
-#include "zstd/deprecated/zbuff.h"
-#include "zstd/common/error_private.h"
-
-
-/*-***********************************************************
-*  Streaming compression
-*
-*  A ZBUFF_CCtx object is required to track streaming operation.
-*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
-*  Use ZBUFF_compressInit() to start a new compression operation.
-*  ZBUFF_CCtx objects can be reused multiple times.
-*
-*  Use ZBUFF_compressContinue() repetitively to consume your input.
-*  *srcSizePtr and *dstCapacityPtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
-*  The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst .
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer.
-*  Note that it will not output more than *dstCapacityPtr.
-*  Therefore, some content might still be left into its internal buffer if dst buffer is too small.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  ZBUFF_compressEnd() instructs to finish a frame.
-*  It will perform a flush and write frame epilogue.
-*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory)
-*  input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value.
-*  output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed.
-* ***********************************************************/
-
-namespace duckdb_zstd {
-
-ZBUFF_CCtx* ZBUFF_createCCtx(void)
-{
-    return ZSTD_createCStream();
-}
-
-ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)
-{
-    return ZSTD_createCStream_advanced(customMem);
-}
-
-size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)
-{
-    return ZSTD_freeCStream(zbc);
-}
-
-
-/* ======   Initialization   ====== */
-
-size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
-                                   const void* dict, size_t dictSize,
-                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)
-{
-    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* preserve "0 == unknown" behavior */
-    FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setPledgedSrcSize(zbc, pledgedSrcSize), "");
-
-    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_windowLog, params.cParams.windowLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_hashLog, params.cParams.hashLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_chainLog, params.cParams.chainLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_searchLog, params.cParams.searchLog), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_minMatch, params.cParams.minMatch), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_targetLength, params.cParams.targetLength), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_strategy, params.cParams.strategy), "");
-
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_contentSizeFlag, params.fParams.contentSizeFlag), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_checksumFlag, params.fParams.checksumFlag), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_dictIDFlag, params.fParams.noDictIDFlag), "");
-
-    FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), "");
-    return 0;
-}
-
-size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)
-{
-    FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_compressionLevel, compressionLevel), "");
-    FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), "");
-    return 0;
-}
-
-size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
-{
-    return ZSTD_initCStream(zbc, compressionLevel);
-}
-
-/* ======   Compression   ====== */
-
-
-size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc,
-                              void* dst, size_t* dstCapacityPtr,
-                        const void* src, size_t* srcSizePtr)
-{
-    size_t result;
-    ZSTD_outBuffer outBuff;
-    ZSTD_inBuffer inBuff;
-    outBuff.dst = dst;
-    outBuff.pos = 0;
-    outBuff.size = *dstCapacityPtr;
-    inBuff.src = src;
-    inBuff.pos = 0;
-    inBuff.size = *srcSizePtr;
-    result = ZSTD_compressStream(zbc, &outBuff, &inBuff);
-    *dstCapacityPtr = outBuff.pos;
-    *srcSizePtr = inBuff.pos;
-    return result;
-}
-
-
-
-/* ======   Finalize   ====== */
-
-size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
-{
-    size_t result;
-    ZSTD_outBuffer outBuff;
-    outBuff.dst = dst;
-    outBuff.pos = 0;
-    outBuff.size = *dstCapacityPtr;
-    result = ZSTD_flushStream(zbc, &outBuff);
-    *dstCapacityPtr = outBuff.pos;
-    return result;
-}
-
-
-size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
-{
-    size_t result;
-    ZSTD_outBuffer outBuff;
-    outBuff.dst = dst;
-    outBuff.pos = 0;
-    outBuff.size = *dstCapacityPtr;
-    result = ZSTD_endStream(zbc, &outBuff);
-    *dstCapacityPtr = outBuff.pos;
-    return result;
-}
-
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-size_t ZBUFF_recommendedCInSize(void)  { return ZSTD_CStreamInSize(); }
-size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); }
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/deprecated/zbuff_decompress.cpp b/src/duckdb/third_party/zstd/deprecated/zbuff_decompress.cpp
deleted file mode 100644
index c55fd5690..000000000
--- a/src/duckdb/third_party/zstd/deprecated/zbuff_decompress.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-
-/* *************************************
-*  Dependencies
-***************************************/
-#define ZSTD_DISABLE_DEPRECATE_WARNINGS  /* suppress warning on ZSTD_initDStream_usingDict */
-#include "zstd.h"        /* ZSTD_CStream, ZSTD_DStream, ZSTDLIB_API */
-#define ZBUFF_STATIC_LINKING_ONLY
-#include "zstd/deprecated/zbuff.h"
-
-namespace duckdb_zstd {
-
-ZBUFF_DCtx* ZBUFF_createDCtx(void)
-{
-    return ZSTD_createDStream();
-}
-
-ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem)
-{
-    return ZSTD_createDStream_advanced(customMem);
-}
-
-size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbd)
-{
-    return ZSTD_freeDStream(zbd);
-}
-
-
-/* *** Initialization *** */
-
-size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* zbd, const void* dict, size_t dictSize)
-{
-    return ZSTD_initDStream_usingDict(zbd, dict, dictSize);
-}
-
-size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbd)
-{
-    return ZSTD_initDStream(zbd);
-}
-
-
-/* *** Decompression *** */
-
-size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbd,
-                                void* dst, size_t* dstCapacityPtr,
-                          const void* src, size_t* srcSizePtr)
-{
-    ZSTD_outBuffer outBuff;
-    ZSTD_inBuffer inBuff;
-    size_t result;
-    outBuff.dst  = dst;
-    outBuff.pos  = 0;
-    outBuff.size = *dstCapacityPtr;
-    inBuff.src  = src;
-    inBuff.pos  = 0;
-    inBuff.size = *srcSizePtr;
-    result = ZSTD_decompressStream(zbd, &outBuff, &inBuff);
-    *dstCapacityPtr = outBuff.pos;
-    *srcSizePtr = inBuff.pos;
-    return result;
-}
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-size_t ZBUFF_recommendedDInSize(void)  { return ZSTD_DStreamInSize(); }
-size_t ZBUFF_recommendedDOutSize(void) { return ZSTD_DStreamOutSize(); }
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/dict/cover.cpp b/src/duckdb/third_party/zstd/dict/cover.cpp
deleted file mode 100644
index 28f4e0909..000000000
--- a/src/duckdb/third_party/zstd/dict/cover.cpp
+++ /dev/null
@@ -1,1270 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* *****************************************************************************
- * Constructs a dictionary using a heuristic based on the following paper:
- *
- * Liao, Petri, Moffat, Wirth
- * Effective Construction of Relative Lempel-Ziv Dictionaries
- * Published in WWW 2016.
- *
- * Adapted from code originally written by @ot (Giuseppe Ottaviano).
- ******************************************************************************/
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stdio.h>  /* fprintf */
-#include <stdlib.h> /* malloc, free, qsort */
-#include <string.h> /* memset */
-#include <time.h>   /* clock */
-
-#ifndef ZDICT_STATIC_LINKING_ONLY
-#  define ZDICT_STATIC_LINKING_ONLY
-#endif
-
-#include "zstd/common/mem.h" /* read */
-#include "zstd/common/pool.h" /* POOL_ctx */
-#include "zstd/common/threading.h" /* ZSTD_pthread_mutex_t */
-#include "zstd/common/zstd_internal.h" /* includes zstd.h */
-#include "zstd/common/bits.h" /* ZSTD_highbit32 */
-#include "zdict.h"
-#include "zstd/dict/cover.h"
-
-/*-*************************************
-*  Constants
-***************************************/
-/**
-* There are 32bit indexes used to ref samples, so limit samples size to 4GB
-* on 64bit builds.
-* For 32bit builds we choose 1 GB.
-* Most 32bit platforms have 2GB user-mode addressable space and we allocate a large
-* contiguous buffer, so 1GB is already a high limit.
-*/
-#define COVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))
-#define COVER_DEFAULT_SPLITPOINT 1.0
-
-/*-*************************************
-*  Console display
-***************************************/
-#ifndef LOCALDISPLAYLEVEL
-static int g_displayLevel = 0;
-#endif
-#undef  DISPLAY
-// CRAN does not allow stderr references
-#define DISPLAY(...)                                                           \
-  {                                                                            \
-  }
-#undef  LOCALDISPLAYLEVEL
-#define LOCALDISPLAYLEVEL(displayLevel, l, ...)                                \
-  if (displayLevel >= l) {                                                     \
-    DISPLAY(__VA_ARGS__);                                                      \
-  } /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
-#undef  DISPLAYLEVEL
-#define DISPLAYLEVEL(l, ...) LOCALDISPLAYLEVEL(g_displayLevel, l, __VA_ARGS__)
-
-#ifndef LOCALDISPLAYUPDATE
-static const clock_t g_refreshRate = CLOCKS_PER_SEC * 15 / 100;
-static clock_t g_time = 0;
-#endif
-#undef  LOCALDISPLAYUPDATE
-#define LOCALDISPLAYUPDATE(displayLevel, l, ...)                               \
-  if (displayLevel >= l) {                                                     \
-    if ((clock() - g_time > g_refreshRate) || (displayLevel >= 4)) {           \
-      g_time = clock();                                                        \
-      DISPLAY(__VA_ARGS__);                                                    \
-    }                                                                          \
-  }
-#undef  DISPLAYUPDATE
-#define DISPLAYUPDATE(l, ...) LOCALDISPLAYUPDATE(g_displayLevel, l, __VA_ARGS__)
-
-namespace duckdb_zstd {
-
-/*-*************************************
-* Hash table
-***************************************
-* A small specialized hash map for storing activeDmers.
-* The map does not resize, so if it becomes full it will loop forever.
-* Thus, the map must be large enough to store every value.
-* The map implements linear probing and keeps its load less than 0.5.
-*/
-
-#define MAP_EMPTY_VALUE ((U32)-1)
-typedef struct COVER_map_pair_t_s {
-  U32 key;
-  U32 value;
-} COVER_map_pair_t;
-
-typedef struct COVER_map_s {
-  COVER_map_pair_t *data;
-  U32 sizeLog;
-  U32 size;
-  U32 sizeMask;
-} COVER_map_t;
-
-/**
- * Clear the map.
- */
-static void COVER_map_clear(COVER_map_t *map) {
-  memset(map->data, MAP_EMPTY_VALUE, map->size * sizeof(COVER_map_pair_t));
-}
-
-/**
- * Initializes a map of the given size.
- * Returns 1 on success and 0 on failure.
- * The map must be destroyed with COVER_map_destroy().
- * The map is only guaranteed to be large enough to hold size elements.
- */
-static int COVER_map_init(COVER_map_t *map, U32 size) {
-  map->sizeLog = ZSTD_highbit32(size) + 2;
-  map->size = (U32)1 << map->sizeLog;
-  map->sizeMask = map->size - 1;
-  map->data = (COVER_map_pair_t *)malloc(map->size * sizeof(COVER_map_pair_t));
-  if (!map->data) {
-    map->sizeLog = 0;
-    map->size = 0;
-    return 0;
-  }
-  COVER_map_clear(map);
-  return 1;
-}
-
-/**
- * Internal hash function
- */
-static const U32 COVER_prime4bytes = 2654435761U;
-static U32 COVER_map_hash(COVER_map_t *map, U32 key) {
-  return (key * COVER_prime4bytes) >> (32 - map->sizeLog);
-}
-
-/**
- * Helper function that returns the index that a key should be placed into.
- */
-static U32 COVER_map_index(COVER_map_t *map, U32 key) {
-  const U32 hash = COVER_map_hash(map, key);
-  U32 i;
-  for (i = hash;; i = (i + 1) & map->sizeMask) {
-    COVER_map_pair_t *pos = &map->data[i];
-    if (pos->value == MAP_EMPTY_VALUE) {
-      return i;
-    }
-    if (pos->key == key) {
-      return i;
-    }
-  }
-}
-
-/**
- * Returns the pointer to the value for key.
- * If key is not in the map, it is inserted and the value is set to 0.
- * The map must not be full.
- */
-static U32 *COVER_map_at(COVER_map_t *map, U32 key) {
-  COVER_map_pair_t *pos = &map->data[COVER_map_index(map, key)];
-  if (pos->value == MAP_EMPTY_VALUE) {
-    pos->key = key;
-    pos->value = 0;
-  }
-  return &pos->value;
-}
-
-/**
- * Deletes key from the map if present.
- */
-static void COVER_map_remove(COVER_map_t *map, U32 key) {
-  U32 i = COVER_map_index(map, key);
-  COVER_map_pair_t *del = &map->data[i];
-  U32 shift = 1;
-  if (del->value == MAP_EMPTY_VALUE) {
-    return;
-  }
-  for (i = (i + 1) & map->sizeMask;; i = (i + 1) & map->sizeMask) {
-    COVER_map_pair_t *const pos = &map->data[i];
-    /* If the position is empty we are done */
-    if (pos->value == MAP_EMPTY_VALUE) {
-      del->value = MAP_EMPTY_VALUE;
-      return;
-    }
-    /* If pos can be moved to del do so */
-    if (((i - COVER_map_hash(map, pos->key)) & map->sizeMask) >= shift) {
-      del->key = pos->key;
-      del->value = pos->value;
-      del = pos;
-      shift = 1;
-    } else {
-      ++shift;
-    }
-  }
-}
-
-/**
- * Destroys a map that is inited with COVER_map_init().
- */
-static void COVER_map_destroy(COVER_map_t *map) {
-  if (map->data) {
-    free(map->data);
-  }
-  map->data = NULL;
-  map->size = 0;
-}
-
-/*-*************************************
-* Context
-***************************************/
-
-typedef struct {
-  const BYTE *samples;
-  size_t *offsets;
-  const size_t *samplesSizes;
-  size_t nbSamples;
-  size_t nbTrainSamples;
-  size_t nbTestSamples;
-  U32 *suffix;
-  size_t suffixSize;
-  U32 *freqs;
-  U32 *dmerAt;
-  unsigned d;
-} COVER_ctx_t;
-
-/* We need a global context for qsort... */
-static COVER_ctx_t *g_coverCtx = NULL;
-
-/*-*************************************
-*  Helper functions
-***************************************/
-
-/**
- * Returns the sum of the sample sizes.
- */
-size_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) {
-  size_t sum = 0;
-  unsigned i;
-  for (i = 0; i < nbSamples; ++i) {
-    sum += samplesSizes[i];
-  }
-  return sum;
-}
-
-/**
- * Returns -1 if the dmer at lp is less than the dmer at rp.
- * Return 0 if the dmers at lp and rp are equal.
- * Returns 1 if the dmer at lp is greater than the dmer at rp.
- */
-static int COVER_cmp(COVER_ctx_t *ctx, const void *lp, const void *rp) {
-  U32 const lhs = *(U32 const *)lp;
-  U32 const rhs = *(U32 const *)rp;
-  return memcmp(ctx->samples + lhs, ctx->samples + rhs, ctx->d);
-}
-/**
- * Faster version for d <= 8.
- */
-static int COVER_cmp8(COVER_ctx_t *ctx, const void *lp, const void *rp) {
-  U64 const mask = (ctx->d == 8) ? (U64)-1 : (((U64)1 << (8 * ctx->d)) - 1);
-  U64 const lhs = MEM_readLE64(ctx->samples + *(U32 const *)lp) & mask;
-  U64 const rhs = MEM_readLE64(ctx->samples + *(U32 const *)rp) & mask;
-  if (lhs < rhs) {
-    return -1;
-  }
-  return (lhs > rhs);
-}
-
-/**
- * Same as COVER_cmp() except ties are broken by pointer value
- * NOTE: g_coverCtx must be set to call this function.  A global is required because
- * qsort doesn't take an opaque pointer.
- */
-static int WIN_CDECL COVER_strict_cmp(const void *lp, const void *rp) {
-  int result = COVER_cmp(g_coverCtx, lp, rp);
-  if (result == 0) {
-    result = lp < rp ? -1 : 1;
-  }
-  return result;
-}
-/**
- * Faster version for d <= 8.
- */
-static int WIN_CDECL COVER_strict_cmp8(const void *lp, const void *rp) {
-  int result = COVER_cmp8(g_coverCtx, lp, rp);
-  if (result == 0) {
-    result = lp < rp ? -1 : 1;
-  }
-  return result;
-}
-
-/**
- * Returns the first pointer in [first, last) whose element does not compare
- * less than value.  If no such element exists it returns last.
- */
-static const size_t *COVER_lower_bound(const size_t* first, const size_t* last,
-                                       size_t value) {
-  size_t count = (size_t)(last - first);
-  assert(last >= first);
-  while (count != 0) {
-    size_t step = count / 2;
-    const size_t *ptr = first;
-    ptr += step;
-    if (*ptr < value) {
-      first = ++ptr;
-      count -= step + 1;
-    } else {
-      count = step;
-    }
-  }
-  return first;
-}
-
-/**
- * Generic groupBy function.
- * Groups an array sorted by cmp into groups with equivalent values.
- * Calls grp for each group.
- */
-static void
-COVER_groupBy(const void *data, size_t count, size_t size, COVER_ctx_t *ctx,
-              int (*cmp)(COVER_ctx_t *, const void *, const void *),
-              void (*grp)(COVER_ctx_t *, const void *, const void *)) {
-  const BYTE *ptr = (const BYTE *)data;
-  size_t num = 0;
-  while (num < count) {
-    const BYTE *grpEnd = ptr + size;
-    ++num;
-    while (num < count && cmp(ctx, ptr, grpEnd) == 0) {
-      grpEnd += size;
-      ++num;
-    }
-    grp(ctx, ptr, grpEnd);
-    ptr = grpEnd;
-  }
-}
-
-/*-*************************************
-*  Cover functions
-***************************************/
-
-/**
- * Called on each group of positions with the same dmer.
- * Counts the frequency of each dmer and saves it in the suffix array.
- * Fills `ctx->dmerAt`.
- */
-static void COVER_group(COVER_ctx_t *ctx, const void *group,
-                        const void *groupEnd) {
-  /* The group consists of all the positions with the same first d bytes. */
-  const U32 *grpPtr = (const U32 *)group;
-  const U32 *grpEnd = (const U32 *)groupEnd;
-  /* The dmerId is how we will reference this dmer.
-   * This allows us to map the whole dmer space to a much smaller space, the
-   * size of the suffix array.
-   */
-  const U32 dmerId = (U32)(grpPtr - ctx->suffix);
-  /* Count the number of samples this dmer shows up in */
-  U32 freq = 0;
-  /* Details */
-  const size_t *curOffsetPtr = ctx->offsets;
-  const size_t *offsetsEnd = ctx->offsets + ctx->nbSamples;
-  /* Once *grpPtr >= curSampleEnd this occurrence of the dmer is in a
-   * different sample than the last.
-   */
-  size_t curSampleEnd = ctx->offsets[0];
-  for (; grpPtr != grpEnd; ++grpPtr) {
-    /* Save the dmerId for this position so we can get back to it. */
-    ctx->dmerAt[*grpPtr] = dmerId;
-    /* Dictionaries only help for the first reference to the dmer.
-     * After that zstd can reference the match from the previous reference.
-     * So only count each dmer once for each sample it is in.
-     */
-    if (*grpPtr < curSampleEnd) {
-      continue;
-    }
-    freq += 1;
-    /* Binary search to find the end of the sample *grpPtr is in.
-     * In the common case that grpPtr + 1 == grpEnd we can skip the binary
-     * search because the loop is over.
-     */
-    if (grpPtr + 1 != grpEnd) {
-      const size_t *sampleEndPtr =
-          COVER_lower_bound(curOffsetPtr, offsetsEnd, *grpPtr);
-      curSampleEnd = *sampleEndPtr;
-      curOffsetPtr = sampleEndPtr + 1;
-    }
-  }
-  /* At this point we are never going to look at this segment of the suffix
-   * array again.  We take advantage of this fact to save memory.
-   * We store the frequency of the dmer in the first position of the group,
-   * which is dmerId.
-   */
-  ctx->suffix[dmerId] = freq;
-}
-
-
-/**
- * Selects the best segment in an epoch.
- * Segments of are scored according to the function:
- *
- * Let F(d) be the frequency of dmer d.
- * Let S_i be the dmer at position i of segment S which has length k.
- *
- *     Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1})
- *
- * Once the dmer d is in the dictionary we set F(d) = 0.
- */
-static COVER_segment_t COVER_selectSegment(const COVER_ctx_t *ctx, U32 *freqs,
-                                           COVER_map_t *activeDmers, U32 begin,
-                                           U32 end,
-                                           ZDICT_cover_params_t parameters) {
-  /* Constants */
-  const U32 k = parameters.k;
-  const U32 d = parameters.d;
-  const U32 dmersInK = k - d + 1;
-  /* Try each segment (activeSegment) and save the best (bestSegment) */
-  COVER_segment_t bestSegment = {0, 0, 0};
-  COVER_segment_t activeSegment;
-  /* Reset the activeDmers in the segment */
-  COVER_map_clear(activeDmers);
-  /* The activeSegment starts at the beginning of the epoch. */
-  activeSegment.begin = begin;
-  activeSegment.end = begin;
-  activeSegment.score = 0;
-  /* Slide the activeSegment through the whole epoch.
-   * Save the best segment in bestSegment.
-   */
-  while (activeSegment.end < end) {
-    /* The dmerId for the dmer at the next position */
-    U32 newDmer = ctx->dmerAt[activeSegment.end];
-    /* The entry in activeDmers for this dmerId */
-    U32 *newDmerOcc = COVER_map_at(activeDmers, newDmer);
-    /* If the dmer isn't already present in the segment add its score. */
-    if (*newDmerOcc == 0) {
-      /* The paper suggest using the L-0.5 norm, but experiments show that it
-       * doesn't help.
-       */
-      activeSegment.score += freqs[newDmer];
-    }
-    /* Add the dmer to the segment */
-    activeSegment.end += 1;
-    *newDmerOcc += 1;
-
-    /* If the window is now too large, drop the first position */
-    if (activeSegment.end - activeSegment.begin == dmersInK + 1) {
-      U32 delDmer = ctx->dmerAt[activeSegment.begin];
-      U32 *delDmerOcc = COVER_map_at(activeDmers, delDmer);
-      activeSegment.begin += 1;
-      *delDmerOcc -= 1;
-      /* If this is the last occurrence of the dmer, subtract its score */
-      if (*delDmerOcc == 0) {
-        COVER_map_remove(activeDmers, delDmer);
-        activeSegment.score -= freqs[delDmer];
-      }
-    }
-
-    /* If this segment is the best so far save it */
-    if (activeSegment.score > bestSegment.score) {
-      bestSegment = activeSegment;
-    }
-  }
-  {
-    /* Trim off the zero frequency head and tail from the segment. */
-    U32 newBegin = bestSegment.end;
-    U32 newEnd = bestSegment.begin;
-    U32 pos;
-    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {
-      U32 freq = freqs[ctx->dmerAt[pos]];
-      if (freq != 0) {
-        newBegin = MIN(newBegin, pos);
-        newEnd = pos + 1;
-      }
-    }
-    bestSegment.begin = newBegin;
-    bestSegment.end = newEnd;
-  }
-  {
-    /* Zero out the frequency of each dmer covered by the chosen segment. */
-    U32 pos;
-    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {
-      freqs[ctx->dmerAt[pos]] = 0;
-    }
-  }
-  return bestSegment;
-}
-
-/**
- * Check the validity of the parameters.
- * Returns non-zero if the parameters are valid and 0 otherwise.
- */
-static int COVER_checkParameters(ZDICT_cover_params_t parameters,
-                                 size_t maxDictSize) {
-  /* k and d are required parameters */
-  if (parameters.d == 0 || parameters.k == 0) {
-    return 0;
-  }
-  /* k <= maxDictSize */
-  if (parameters.k > maxDictSize) {
-    return 0;
-  }
-  /* d <= k */
-  if (parameters.d > parameters.k) {
-    return 0;
-  }
-  /* 0 < splitPoint <= 1 */
-  if (parameters.splitPoint <= 0 || parameters.splitPoint > 1){
-    return 0;
-  }
-  return 1;
-}
-
-/**
- * Clean up a context initialized with `COVER_ctx_init()`.
- */
-static void COVER_ctx_destroy(COVER_ctx_t *ctx) {
-  if (!ctx) {
-    return;
-  }
-  if (ctx->suffix) {
-    free(ctx->suffix);
-    ctx->suffix = NULL;
-  }
-  if (ctx->freqs) {
-    free(ctx->freqs);
-    ctx->freqs = NULL;
-  }
-  if (ctx->dmerAt) {
-    free(ctx->dmerAt);
-    ctx->dmerAt = NULL;
-  }
-  if (ctx->offsets) {
-    free(ctx->offsets);
-    ctx->offsets = NULL;
-  }
-}
-
-/**
- * Prepare a context for dictionary building.
- * The context is only dependent on the parameter `d` and can be used multiple
- * times.
- * Returns 0 on success or error code on error.
- * The context must be destroyed with `COVER_ctx_destroy()`.
- */
-static size_t COVER_ctx_init(COVER_ctx_t *ctx, const void *samplesBuffer,
-                          const size_t *samplesSizes, unsigned nbSamples,
-                          unsigned d, double splitPoint)
-{
-  const BYTE *const samples = (const BYTE *)samplesBuffer;
-  const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples);
-  /* Split samples into testing and training sets */
-  const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;
-  const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;
-  const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;
-  const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;
-
-  (void) testSamplesSize;
-
-  /* Checks */
-  if (totalSamplesSize < MAX(d, sizeof(U64)) ||
-      totalSamplesSize >= (size_t)COVER_MAX_SAMPLES_SIZE) {
-    DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n",
-                 (unsigned)(totalSamplesSize>>20), (COVER_MAX_SAMPLES_SIZE >> 20));
-    return ERROR(srcSize_wrong);
-  }
-  /* Check if there are at least 5 training samples */
-  if (nbTrainSamples < 5) {
-    DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid.", nbTrainSamples);
-    return ERROR(srcSize_wrong);
-  }
-  /* Check if there's testing sample */
-  if (nbTestSamples < 1) {
-    DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.", nbTestSamples);
-    return ERROR(srcSize_wrong);
-  }
-  /* Zero the context */
-  memset(ctx, 0, sizeof(*ctx));
-  DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples,
-               (unsigned)trainingSamplesSize);
-  DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples,
-               (unsigned)testSamplesSize);
-  ctx->samples = samples;
-  ctx->samplesSizes = samplesSizes;
-  ctx->nbSamples = nbSamples;
-  ctx->nbTrainSamples = nbTrainSamples;
-  ctx->nbTestSamples = nbTestSamples;
-  /* Partial suffix array */
-  ctx->suffixSize = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;
-  ctx->suffix = (U32 *)malloc(ctx->suffixSize * sizeof(U32));
-  /* Maps index to the dmerID */
-  ctx->dmerAt = (U32 *)malloc(ctx->suffixSize * sizeof(U32));
-  /* The offsets of each file */
-  ctx->offsets = (size_t *)malloc((nbSamples + 1) * sizeof(size_t));
-  if (!ctx->suffix || !ctx->dmerAt || !ctx->offsets) {
-    DISPLAYLEVEL(1, "Failed to allocate scratch buffers\n");
-    COVER_ctx_destroy(ctx);
-    return ERROR(memory_allocation);
-  }
-  ctx->freqs = NULL;
-  ctx->d = d;
-
-  /* Fill offsets from the samplesSizes */
-  {
-    U32 i;
-    ctx->offsets[0] = 0;
-    for (i = 1; i <= nbSamples; ++i) {
-      ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1];
-    }
-  }
-  DISPLAYLEVEL(2, "Constructing partial suffix array\n");
-  {
-    /* suffix is a partial suffix array.
-     * It only sorts suffixes by their first parameters.d bytes.
-     * The sort is stable, so each dmer group is sorted by position in input.
-     */
-    U32 i;
-    for (i = 0; i < ctx->suffixSize; ++i) {
-      ctx->suffix[i] = i;
-    }
-    /* qsort doesn't take an opaque pointer, so pass as a global.
-     * On OpenBSD qsort() is not guaranteed to be stable, their mergesort() is.
-     */
-    g_coverCtx = ctx;
-#if defined(__OpenBSD__)
-    mergesort(ctx->suffix, ctx->suffixSize, sizeof(U32),
-          (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
-#else
-    qsort(ctx->suffix, ctx->suffixSize, sizeof(U32),
-          (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
-#endif
-  }
-  DISPLAYLEVEL(2, "Computing frequencies\n");
-  /* For each dmer group (group of positions with the same first d bytes):
-   * 1. For each position we set dmerAt[position] = dmerID.  The dmerID is
-   *    (groupBeginPtr - suffix).  This allows us to go from position to
-   *    dmerID so we can look up values in freq.
-   * 2. We calculate how many samples the dmer occurs in and save it in
-   *    freqs[dmerId].
-   */
-  COVER_groupBy(ctx->suffix, ctx->suffixSize, sizeof(U32), ctx,
-                (ctx->d <= 8 ? &COVER_cmp8 : &COVER_cmp), &COVER_group);
-  ctx->freqs = ctx->suffix;
-  ctx->suffix = NULL;
-  return 0;
-}
-
-void COVER_warnOnSmallCorpus(size_t maxDictSize, size_t nbDmers, int displayLevel)
-{
-  const double ratio = (double)nbDmers / (double)maxDictSize;
-  if (ratio >= 10) {
-      return;
-  }
-  LOCALDISPLAYLEVEL(displayLevel, 1,
-                    "WARNING: The maximum dictionary size %u is too large "
-                    "compared to the source size %u! "
-                    "size(source)/size(dictionary) = %f, but it should be >= "
-                    "10! This may lead to a subpar dictionary! We recommend "
-                    "training on sources at least 10x, and preferably 100x "
-                    "the size of the dictionary! \n", (U32)maxDictSize,
-                    (U32)nbDmers, ratio);
-}
-
-COVER_epoch_info_t COVER_computeEpochs(U32 maxDictSize,
-                                       U32 nbDmers, U32 k, U32 passes)
-{
-  const U32 minEpochSize = k * 10;
-  COVER_epoch_info_t epochs;
-  epochs.num = MAX(1, maxDictSize / k / passes);
-  epochs.size = nbDmers / epochs.num;
-  if (epochs.size >= minEpochSize) {
-      assert(epochs.size * epochs.num <= nbDmers);
-      return epochs;
-  }
-  epochs.size = MIN(minEpochSize, nbDmers);
-  epochs.num = nbDmers / epochs.size;
-  assert(epochs.size * epochs.num <= nbDmers);
-  return epochs;
-}
-
-/**
- * Given the prepared context build the dictionary.
- */
-static size_t COVER_buildDictionary(const COVER_ctx_t *ctx, U32 *freqs,
-                                    COVER_map_t *activeDmers, void *dictBuffer,
-                                    size_t dictBufferCapacity,
-                                    ZDICT_cover_params_t parameters) {
-  BYTE *const dict = (BYTE *)dictBuffer;
-  size_t tail = dictBufferCapacity;
-  /* Divide the data into epochs. We will select one segment from each epoch. */
-  const COVER_epoch_info_t epochs = COVER_computeEpochs(
-      (U32)dictBufferCapacity, (U32)ctx->suffixSize, parameters.k, 4);
-  const size_t maxZeroScoreRun = MAX(10, MIN(100, epochs.num >> 3));
-  size_t zeroScoreRun = 0;
-  size_t epoch;
-  DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n",
-                (U32)epochs.num, (U32)epochs.size);
-  /* Loop through the epochs until there are no more segments or the dictionary
-   * is full.
-   */
-  for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) {
-    const U32 epochBegin = (U32)(epoch * epochs.size);
-    const U32 epochEnd = epochBegin + epochs.size;
-    size_t segmentSize;
-    /* Select a segment */
-    COVER_segment_t segment = COVER_selectSegment(
-        ctx, freqs, activeDmers, epochBegin, epochEnd, parameters);
-    /* If the segment covers no dmers, then we are out of content.
-     * There may be new content in other epochs, for continue for some time.
-     */
-    if (segment.score == 0) {
-      if (++zeroScoreRun >= maxZeroScoreRun) {
-          break;
-      }
-      continue;
-    }
-    zeroScoreRun = 0;
-    /* Trim the segment if necessary and if it is too small then we are done */
-    segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail);
-    if (segmentSize < parameters.d) {
-      break;
-    }
-    /* We fill the dictionary from the back to allow the best segments to be
-     * referenced with the smallest offsets.
-     */
-    tail -= segmentSize;
-    memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);
-    DISPLAYUPDATE(
-        2, "\r%u%%       ",
-        (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));
-  }
-  DISPLAYLEVEL(2, "\r%79s\r", "");
-  return tail;
-}
-
-ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_cover(
-    void *dictBuffer, size_t dictBufferCapacity,
-    const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,
-    ZDICT_cover_params_t parameters)
-{
-  BYTE* const dict = (BYTE*)dictBuffer;
-  COVER_ctx_t ctx;
-  COVER_map_t activeDmers;
-  parameters.splitPoint = 1.0;
-  /* Initialize global data */
-  g_displayLevel = (int)parameters.zParams.notificationLevel;
-  /* Checks */
-  if (!COVER_checkParameters(parameters, dictBufferCapacity)) {
-    DISPLAYLEVEL(1, "Cover parameters incorrect\n");
-    return ERROR(parameter_outOfBound);
-  }
-  if (nbSamples == 0) {
-    DISPLAYLEVEL(1, "Cover must have at least one input file\n");
-    return ERROR(srcSize_wrong);
-  }
-  if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
-    DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n",
-                 ZDICT_DICTSIZE_MIN);
-    return ERROR(dstSize_tooSmall);
-  }
-  /* Initialize context and activeDmers */
-  {
-    size_t const initVal = COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples,
-                      parameters.d, parameters.splitPoint);
-    if (ZSTD_isError(initVal)) {
-      return initVal;
-    }
-  }
-  COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.suffixSize, g_displayLevel);
-  if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) {
-    DISPLAYLEVEL(1, "Failed to allocate dmer map: out of memory\n");
-    COVER_ctx_destroy(&ctx);
-    return ERROR(memory_allocation);
-  }
-
-  DISPLAYLEVEL(2, "Building dictionary\n");
-  {
-    const size_t tail =
-        COVER_buildDictionary(&ctx, ctx.freqs, &activeDmers, dictBuffer,
-                              dictBufferCapacity, parameters);
-    const size_t dictionarySize = ZDICT_finalizeDictionary(
-        dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,
-        samplesBuffer, samplesSizes, nbSamples, parameters.zParams);
-    if (!ZSTD_isError(dictionarySize)) {
-      DISPLAYLEVEL(2, "Constructed dictionary of size %u\n",
-                   (unsigned)dictionarySize);
-    }
-    COVER_ctx_destroy(&ctx);
-    COVER_map_destroy(&activeDmers);
-    return dictionarySize;
-  }
-}
-
-
-
-size_t COVER_checkTotalCompressedSize(const ZDICT_cover_params_t parameters,
-                                    const size_t *samplesSizes, const BYTE *samples,
-                                    size_t *offsets,
-                                    size_t nbTrainSamples, size_t nbSamples,
-                                    BYTE *const dict, size_t dictBufferCapacity) {
-  size_t totalCompressedSize = ERROR(GENERIC);
-  /* Pointers */
-  ZSTD_CCtx *cctx;
-  ZSTD_CDict *cdict;
-  void *dst;
-  /* Local variables */
-  size_t dstCapacity;
-  size_t i;
-  /* Allocate dst with enough space to compress the maximum sized sample */
-  {
-    size_t maxSampleSize = 0;
-    i = parameters.splitPoint < 1.0 ? nbTrainSamples : 0;
-    for (; i < nbSamples; ++i) {
-      maxSampleSize = MAX(samplesSizes[i], maxSampleSize);
-    }
-    dstCapacity = ZSTD_compressBound(maxSampleSize);
-    dst = malloc(dstCapacity);
-  }
-  /* Create the cctx and cdict */
-  cctx = ZSTD_createCCtx();
-  cdict = ZSTD_createCDict(dict, dictBufferCapacity,
-                           parameters.zParams.compressionLevel);
-  if (!dst || !cctx || !cdict) {
-    goto _compressCleanup;
-  }
-  /* Compress each sample and sum their sizes (or error) */
-  totalCompressedSize = dictBufferCapacity;
-  i = parameters.splitPoint < 1.0 ? nbTrainSamples : 0;
-  for (; i < nbSamples; ++i) {
-    const size_t size = ZSTD_compress_usingCDict(
-        cctx, dst, dstCapacity, samples + offsets[i],
-        samplesSizes[i], cdict);
-    if (ZSTD_isError(size)) {
-      totalCompressedSize = size;
-      goto _compressCleanup;
-    }
-    totalCompressedSize += size;
-  }
-_compressCleanup:
-  ZSTD_freeCCtx(cctx);
-  ZSTD_freeCDict(cdict);
-  if (dst) {
-    free(dst);
-  }
-  return totalCompressedSize;
-}
-
-
-/**
- * Initialize the `COVER_best_t`.
- */
-void COVER_best_init(COVER_best_t *best) {
-  if (best==NULL) return; /* compatible with init on NULL */
-  (void)ZSTD_pthread_mutex_init(&best->mutex, NULL);
-  (void)ZSTD_pthread_cond_init(&best->cond, NULL);
-  best->liveJobs = 0;
-  best->dict = NULL;
-  best->dictSize = 0;
-  best->compressedSize = (size_t)-1;
-  memset(&best->parameters, 0, sizeof(best->parameters));
-}
-
-/**
- * Wait until liveJobs == 0.
- */
-void COVER_best_wait(COVER_best_t *best) {
-  if (!best) {
-    return;
-  }
-  ZSTD_pthread_mutex_lock(&best->mutex);
-  while (best->liveJobs != 0) {
-    ZSTD_pthread_cond_wait(&best->cond, &best->mutex);
-  }
-  ZSTD_pthread_mutex_unlock(&best->mutex);
-}
-
-/**
- * Call COVER_best_wait() and then destroy the COVER_best_t.
- */
-void COVER_best_destroy(COVER_best_t *best) {
-  if (!best) {
-    return;
-  }
-  COVER_best_wait(best);
-  if (best->dict) {
-    free(best->dict);
-  }
-  ZSTD_pthread_mutex_destroy(&best->mutex);
-  ZSTD_pthread_cond_destroy(&best->cond);
-}
-
-/**
- * Called when a thread is about to be launched.
- * Increments liveJobs.
- */
-void COVER_best_start(COVER_best_t *best) {
-  if (!best) {
-    return;
-  }
-  ZSTD_pthread_mutex_lock(&best->mutex);
-  ++best->liveJobs;
-  ZSTD_pthread_mutex_unlock(&best->mutex);
-}
-
-/**
- * Called when a thread finishes executing, both on error or success.
- * Decrements liveJobs and signals any waiting threads if liveJobs == 0.
- * If this dictionary is the best so far save it and its parameters.
- */
-void COVER_best_finish(COVER_best_t* best,
-                      ZDICT_cover_params_t parameters,
-                      COVER_dictSelection_t selection)
-{
-  void* dict = selection.dictContent;
-  size_t compressedSize = selection.totalCompressedSize;
-  size_t dictSize = selection.dictSize;
-  if (!best) {
-    return;
-  }
-  {
-    size_t liveJobs;
-    ZSTD_pthread_mutex_lock(&best->mutex);
-    --best->liveJobs;
-    liveJobs = best->liveJobs;
-    /* If the new dictionary is better */
-    if (compressedSize < best->compressedSize) {
-      /* Allocate space if necessary */
-      if (!best->dict || best->dictSize < dictSize) {
-        if (best->dict) {
-          free(best->dict);
-        }
-        best->dict = malloc(dictSize);
-        if (!best->dict) {
-          best->compressedSize = ERROR(GENERIC);
-          best->dictSize = 0;
-          ZSTD_pthread_cond_signal(&best->cond);
-          ZSTD_pthread_mutex_unlock(&best->mutex);
-          return;
-        }
-      }
-      /* Save the dictionary, parameters, and size */
-      if (dict) {
-        memcpy(best->dict, dict, dictSize);
-        best->dictSize = dictSize;
-        best->parameters = parameters;
-        best->compressedSize = compressedSize;
-      }
-    }
-    if (liveJobs == 0) {
-      ZSTD_pthread_cond_broadcast(&best->cond);
-    }
-    ZSTD_pthread_mutex_unlock(&best->mutex);
-  }
-}
-
-static COVER_dictSelection_t setDictSelection(BYTE* buf, size_t s, size_t csz)
-{
-    COVER_dictSelection_t ds;
-    ds.dictContent = buf;
-    ds.dictSize = s;
-    ds.totalCompressedSize = csz;
-    return ds;
-}
-
-COVER_dictSelection_t COVER_dictSelectionError(size_t error) {
-    return setDictSelection(NULL, 0, error);
-}
-
-unsigned COVER_dictSelectionIsError(COVER_dictSelection_t selection) {
-  return (ZSTD_isError(selection.totalCompressedSize) || !selection.dictContent);
-}
-
-void COVER_dictSelectionFree(COVER_dictSelection_t selection){
-  free(selection.dictContent);
-}
-
-COVER_dictSelection_t COVER_selectDict(BYTE* customDictContent, size_t dictBufferCapacity,
-        size_t dictContentSize, const BYTE* samplesBuffer, const size_t* samplesSizes, unsigned nbFinalizeSamples,
-        size_t nbCheckSamples, size_t nbSamples, ZDICT_cover_params_t params, size_t* offsets, size_t totalCompressedSize) {
-
-  size_t largestDict = 0;
-  size_t largestCompressed = 0;
-  BYTE* customDictContentEnd = customDictContent + dictContentSize;
-
-  BYTE* largestDictbuffer = (BYTE*)malloc(dictBufferCapacity);
-  BYTE* candidateDictBuffer = (BYTE*)malloc(dictBufferCapacity);
-  double regressionTolerance = ((double)params.shrinkDictMaxRegression / 100.0) + 1.00;
-
-  if (!largestDictbuffer || !candidateDictBuffer) {
-    free(largestDictbuffer);
-    free(candidateDictBuffer);
-    return COVER_dictSelectionError(dictContentSize);
-  }
-
-  /* Initial dictionary size and compressed size */
-  memcpy(largestDictbuffer, customDictContent, dictContentSize);
-  dictContentSize = ZDICT_finalizeDictionary(
-    largestDictbuffer, dictBufferCapacity, customDictContent, dictContentSize,
-    samplesBuffer, samplesSizes, nbFinalizeSamples, params.zParams);
-
-  if (ZDICT_isError(dictContentSize)) {
-    free(largestDictbuffer);
-    free(candidateDictBuffer);
-    return COVER_dictSelectionError(dictContentSize);
-  }
-
-  totalCompressedSize = COVER_checkTotalCompressedSize(params, samplesSizes,
-                                                       samplesBuffer, offsets,
-                                                       nbCheckSamples, nbSamples,
-                                                       largestDictbuffer, dictContentSize);
-
-  if (ZSTD_isError(totalCompressedSize)) {
-    free(largestDictbuffer);
-    free(candidateDictBuffer);
-    return COVER_dictSelectionError(totalCompressedSize);
-  }
-
-  if (params.shrinkDict == 0) {
-    free(candidateDictBuffer);
-    return setDictSelection(largestDictbuffer, dictContentSize, totalCompressedSize);
-  }
-
-  largestDict = dictContentSize;
-  largestCompressed = totalCompressedSize;
-  dictContentSize = ZDICT_DICTSIZE_MIN;
-
-  /* Largest dict is initially at least ZDICT_DICTSIZE_MIN */
-  while (dictContentSize < largestDict) {
-    memcpy(candidateDictBuffer, largestDictbuffer, largestDict);
-    dictContentSize = ZDICT_finalizeDictionary(
-      candidateDictBuffer, dictBufferCapacity, customDictContentEnd - dictContentSize, dictContentSize,
-      samplesBuffer, samplesSizes, nbFinalizeSamples, params.zParams);
-
-    if (ZDICT_isError(dictContentSize)) {
-      free(largestDictbuffer);
-      free(candidateDictBuffer);
-      return COVER_dictSelectionError(dictContentSize);
-
-    }
-
-    totalCompressedSize = COVER_checkTotalCompressedSize(params, samplesSizes,
-                                                         samplesBuffer, offsets,
-                                                         nbCheckSamples, nbSamples,
-                                                         candidateDictBuffer, dictContentSize);
-
-    if (ZSTD_isError(totalCompressedSize)) {
-      free(largestDictbuffer);
-      free(candidateDictBuffer);
-      return COVER_dictSelectionError(totalCompressedSize);
-    }
-
-    if ((double)totalCompressedSize <= (double)largestCompressed * regressionTolerance) {
-      free(largestDictbuffer);
-      return setDictSelection( candidateDictBuffer, dictContentSize, totalCompressedSize );
-    }
-    dictContentSize *= 2;
-  }
-  dictContentSize = largestDict;
-  totalCompressedSize = largestCompressed;
-  free(candidateDictBuffer);
-  return setDictSelection( largestDictbuffer, dictContentSize, totalCompressedSize );
-}
-
-/**
- * Parameters for COVER_tryParameters().
- */
-typedef struct COVER_tryParameters_data_s {
-  const COVER_ctx_t *ctx;
-  COVER_best_t *best;
-  size_t dictBufferCapacity;
-  ZDICT_cover_params_t parameters;
-} COVER_tryParameters_data_t;
-
-/**
- * Tries a set of parameters and updates the COVER_best_t with the results.
- * This function is thread safe if zstd is compiled with multithreaded support.
- * It takes its parameters as an *OWNING* opaque pointer to support threading.
- */
-static void COVER_tryParameters(void *opaque)
-{
-  /* Save parameters as local variables */
-  COVER_tryParameters_data_t *const data = (COVER_tryParameters_data_t*)opaque;
-  const COVER_ctx_t *const ctx = data->ctx;
-  const ZDICT_cover_params_t parameters = data->parameters;
-  size_t dictBufferCapacity = data->dictBufferCapacity;
-  size_t totalCompressedSize = ERROR(GENERIC);
-  /* Allocate space for hash table, dict, and freqs */
-  COVER_map_t activeDmers;
-  BYTE* const dict = (BYTE*)malloc(dictBufferCapacity);
-  COVER_dictSelection_t selection = COVER_dictSelectionError(ERROR(GENERIC));
-  U32* const freqs = (U32*)malloc(ctx->suffixSize * sizeof(U32));
-  if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) {
-    DISPLAYLEVEL(1, "Failed to allocate dmer map: out of memory\n");
-    goto _cleanup;
-  }
-  if (!dict || !freqs) {
-    DISPLAYLEVEL(1, "Failed to allocate buffers: out of memory\n");
-    goto _cleanup;
-  }
-  /* Copy the frequencies because we need to modify them */
-  memcpy(freqs, ctx->freqs, ctx->suffixSize * sizeof(U32));
-  /* Build the dictionary */
-  {
-    const size_t tail = COVER_buildDictionary(ctx, freqs, &activeDmers, dict,
-                                              dictBufferCapacity, parameters);
-    selection = COVER_selectDict(dict + tail, dictBufferCapacity, dictBufferCapacity - tail,
-        ctx->samples, ctx->samplesSizes, (unsigned)ctx->nbTrainSamples, ctx->nbTrainSamples, ctx->nbSamples, parameters, ctx->offsets,
-        totalCompressedSize);
-
-    if (COVER_dictSelectionIsError(selection)) {
-      DISPLAYLEVEL(1, "Failed to select dictionary\n");
-      goto _cleanup;
-    }
-  }
-_cleanup:
-  free(dict);
-  COVER_best_finish(data->best, parameters, selection);
-  free(data);
-  COVER_map_destroy(&activeDmers);
-  COVER_dictSelectionFree(selection);
-  free(freqs);
-}
-
-ZDICTLIB_STATIC_API size_t ZDICT_optimizeTrainFromBuffer_cover(
-    void* dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer,
-    const size_t* samplesSizes, unsigned nbSamples,
-    ZDICT_cover_params_t* parameters)
-{
-  /* constants */
-  const unsigned nbThreads = parameters->nbThreads;
-  const double splitPoint =
-      parameters->splitPoint <= 0.0 ? COVER_DEFAULT_SPLITPOINT : parameters->splitPoint;
-  const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d;
-  const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d;
-  const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k;
-  const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k;
-  const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps;
-  const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1);
-  const unsigned kIterations =
-      (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize);
-  const unsigned shrinkDict = 0;
-  /* Local variables */
-  const int displayLevel = parameters->zParams.notificationLevel;
-  unsigned iteration = 1;
-  unsigned d;
-  unsigned k;
-  COVER_best_t best;
-  POOL_ctx *pool = NULL;
-  int warned = 0;
-
-  (void) kIterations;
-  (void) iteration;
-
-  /* Checks */
-  if (splitPoint <= 0 || splitPoint > 1) {
-    LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect parameters\n");
-    return ERROR(parameter_outOfBound);
-  }
-  if (kMinK < kMaxD || kMaxK < kMinK) {
-    LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect parameters\n");
-    return ERROR(parameter_outOfBound);
-  }
-  if (nbSamples == 0) {
-    DISPLAYLEVEL(1, "Cover must have at least one input file\n");
-    return ERROR(srcSize_wrong);
-  }
-  if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
-    DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n",
-                 ZDICT_DICTSIZE_MIN);
-    return ERROR(dstSize_tooSmall);
-  }
-  if (nbThreads > 1) {
-    pool = POOL_create(nbThreads, 1);
-    if (!pool) {
-      return ERROR(memory_allocation);
-    }
-  }
-  /* Initialization */
-  COVER_best_init(&best);
-  /* Turn down global display level to clean up display at level 2 and below */
-  g_displayLevel = displayLevel == 0 ? 0 : displayLevel - 1;
-  /* Loop through d first because each new value needs a new context */
-  LOCALDISPLAYLEVEL(displayLevel, 2, "Trying %u different sets of parameters\n",
-                    kIterations);
-  for (d = kMinD; d <= kMaxD; d += 2) {
-    /* Initialize the context for this value of d */
-    COVER_ctx_t ctx;
-    LOCALDISPLAYLEVEL(displayLevel, 3, "d=%u\n", d);
-    {
-      const size_t initVal = COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d, splitPoint);
-      if (ZSTD_isError(initVal)) {
-        LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to initialize context\n");
-        COVER_best_destroy(&best);
-        POOL_free(pool);
-        return initVal;
-      }
-    }
-    if (!warned) {
-      COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.suffixSize, displayLevel);
-      warned = 1;
-    }
-    /* Loop through k reusing the same context */
-    for (k = kMinK; k <= kMaxK; k += kStepSize) {
-      /* Prepare the arguments */
-      COVER_tryParameters_data_t *data = (COVER_tryParameters_data_t *)malloc(
-          sizeof(COVER_tryParameters_data_t));
-      LOCALDISPLAYLEVEL(displayLevel, 3, "k=%u\n", k);
-      if (!data) {
-        LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to allocate parameters\n");
-        COVER_best_destroy(&best);
-        COVER_ctx_destroy(&ctx);
-        POOL_free(pool);
-        return ERROR(memory_allocation);
-      }
-      data->ctx = &ctx;
-      data->best = &best;
-      data->dictBufferCapacity = dictBufferCapacity;
-      data->parameters = *parameters;
-      data->parameters.k = k;
-      data->parameters.d = d;
-      data->parameters.splitPoint = splitPoint;
-      data->parameters.steps = kSteps;
-      data->parameters.shrinkDict = shrinkDict;
-      data->parameters.zParams.notificationLevel = g_displayLevel;
-      /* Check the parameters */
-      if (!COVER_checkParameters(data->parameters, dictBufferCapacity)) {
-        DISPLAYLEVEL(1, "Cover parameters incorrect\n");
-        free(data);
-        continue;
-      }
-      /* Call the function and pass ownership of data to it */
-      COVER_best_start(&best);
-      if (pool) {
-        POOL_add(pool, &COVER_tryParameters, data);
-      } else {
-        COVER_tryParameters(data);
-      }
-      /* Print status */
-      LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%%       ",
-                         (unsigned)((iteration * 100) / kIterations));
-      ++iteration;
-    }
-    COVER_best_wait(&best);
-    COVER_ctx_destroy(&ctx);
-  }
-  LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", "");
-  /* Fill the output buffer and parameters with output of the best parameters */
-  {
-    const size_t dictSize = best.dictSize;
-    if (ZSTD_isError(best.compressedSize)) {
-      const size_t compressedSize = best.compressedSize;
-      COVER_best_destroy(&best);
-      POOL_free(pool);
-      return compressedSize;
-    }
-    *parameters = best.parameters;
-    memcpy(dictBuffer, best.dict, dictSize);
-    COVER_best_destroy(&best);
-    POOL_free(pool);
-    return dictSize;
-  }
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/dict/divsufsort.cpp b/src/duckdb/third_party/zstd/dict/divsufsort.cpp
deleted file mode 100644
index d0d00f8ca..000000000
--- a/src/duckdb/third_party/zstd/dict/divsufsort.cpp
+++ /dev/null
@@ -1,1916 +0,0 @@
-/*
- * divsufsort.c for libdivsufsort-lite
- * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*- Compiler specifics -*/
-#ifdef __clang__
-// CRAN does not allow pragmas
-#endif
-
-#if defined(_MSC_VER)
-#  pragma warning(disable : 4244)
-#  pragma warning(disable : 4127)    /* C4127 : Condition expression is constant */
-#endif
-
-
-/*- Dependencies -*/
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "zstd/dict/divsufsort.h"
-
-/*- Constants -*/
-#if defined(INLINE)
-# undef INLINE
-#endif
-#if !defined(INLINE)
-# define INLINE __inline
-#endif
-#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1)
-# undef ALPHABET_SIZE
-#endif
-#if !defined(ALPHABET_SIZE)
-# define ALPHABET_SIZE (256)
-#endif
-#define BUCKET_A_SIZE (ALPHABET_SIZE)
-#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)
-#if defined(SS_INSERTIONSORT_THRESHOLD)
-# if SS_INSERTIONSORT_THRESHOLD < 1
-#  undef SS_INSERTIONSORT_THRESHOLD
-#  define SS_INSERTIONSORT_THRESHOLD (1)
-# endif
-#else
-# define SS_INSERTIONSORT_THRESHOLD (8)
-#endif
-#if defined(SS_BLOCKSIZE)
-# if SS_BLOCKSIZE < 0
-#  undef SS_BLOCKSIZE
-#  define SS_BLOCKSIZE (0)
-# elif 32768 <= SS_BLOCKSIZE
-#  undef SS_BLOCKSIZE
-#  define SS_BLOCKSIZE (32767)
-# endif
-#else
-# define SS_BLOCKSIZE (1024)
-#endif
-/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */
-#if SS_BLOCKSIZE == 0
-# define SS_MISORT_STACKSIZE (96)
-#elif SS_BLOCKSIZE <= 4096
-# define SS_MISORT_STACKSIZE (16)
-#else
-# define SS_MISORT_STACKSIZE (24)
-#endif
-#define SS_SMERGE_STACKSIZE (32)
-#define TR_INSERTIONSORT_THRESHOLD (8)
-#define TR_STACKSIZE (64)
-
-
-/*- Macros -*/
-#ifndef SWAP
-# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0)
-#endif /* SWAP */
-#ifndef MIN
-# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b))
-#endif /* MIN */
-#ifndef MAX
-# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b))
-#endif /* MAX */
-#define STACK_PUSH(_a, _b, _c, _d)\
-  do {\
-    assert(ssize < STACK_SIZE);\
-    stack[ssize].a = (_a), stack[ssize].b = (_b),\
-    stack[ssize].c = (_c), stack[ssize++].d = (_d);\
-  } while(0)
-#define STACK_PUSH5(_a, _b, _c, _d, _e)\
-  do {\
-    assert(ssize < STACK_SIZE);\
-    stack[ssize].a = (_a), stack[ssize].b = (_b),\
-    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\
-  } while(0)
-#define STACK_POP(_a, _b, _c, _d)\
-  do {\
-    assert(0 <= ssize);\
-    if(ssize == 0) { return; }\
-    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
-    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\
-  } while(0)
-#define STACK_POP5(_a, _b, _c, _d, _e)\
-  do {\
-    assert(0 <= ssize);\
-    if(ssize == 0) { return; }\
-    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
-    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\
-  } while(0)
-#define BUCKET_A(_c0) bucket_A[(_c0)]
-#if ALPHABET_SIZE == 256
-#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])
-#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])
-#else
-#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)])
-#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)])
-#endif
-
-namespace duckdb_zstd {
-
-/*- Private Functions -*/
-
-static const int lg_table[256]= {
- -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
-};
-
-#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
-
-static INLINE
-int
-ss_ilg(int n) {
-#if SS_BLOCKSIZE == 0
-  return (n & 0xffff0000) ?
-          ((n & 0xff000000) ?
-            24 + lg_table[(n >> 24) & 0xff] :
-            16 + lg_table[(n >> 16) & 0xff]) :
-          ((n & 0x0000ff00) ?
-             8 + lg_table[(n >>  8) & 0xff] :
-             0 + lg_table[(n >>  0) & 0xff]);
-#elif SS_BLOCKSIZE < 256
-  return lg_table[n];
-#else
-  return (n & 0xff00) ?
-          8 + lg_table[(n >> 8) & 0xff] :
-          0 + lg_table[(n >> 0) & 0xff];
-#endif
-}
-
-#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
-
-#if SS_BLOCKSIZE != 0
-
-static const int sqq_table[256] = {
-  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61,
- 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89,
- 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109,
-110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
-128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
-143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,
-156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168,
-169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180,
-181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191,
-192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201,
-202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211,
-212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221,
-221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230,
-230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238,
-239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247,
-247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255
-};
-
-static INLINE
-int
-ss_isqrt(int x) {
-  int y, e;
-
-  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; }
-  e = (x & 0xffff0000) ?
-        ((x & 0xff000000) ?
-          24 + lg_table[(x >> 24) & 0xff] :
-          16 + lg_table[(x >> 16) & 0xff]) :
-        ((x & 0x0000ff00) ?
-           8 + lg_table[(x >>  8) & 0xff] :
-           0 + lg_table[(x >>  0) & 0xff]);
-
-  if(e >= 16) {
-    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7);
-    if(e >= 24) { y = (y + 1 + x / y) >> 1; }
-    y = (y + 1 + x / y) >> 1;
-  } else if(e >= 8) {
-    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1;
-  } else {
-    return sqq_table[x] >> 4;
-  }
-
-  return (x < (y * y)) ? y - 1 : y;
-}
-
-#endif /* SS_BLOCKSIZE != 0 */
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Compares two suffixes. */
-static INLINE
-int
-ss_compare(const unsigned char *T,
-           const int *p1, const int *p2,
-           int depth) {
-  const unsigned char *U1, *U2, *U1n, *U2n;
-
-  for(U1 = T + depth + *p1,
-      U2 = T + depth + *p2,
-      U1n = T + *(p1 + 1) + 2,
-      U2n = T + *(p2 + 1) + 2;
-      (U1 < U1n) && (U2 < U2n) && (*U1 == *U2);
-      ++U1, ++U2) {
-  }
-
-  return U1 < U1n ?
-        (U2 < U2n ? *U1 - *U2 : 1) :
-        (U2 < U2n ? -1 : 0);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1)
-
-/* Insertionsort for small size groups */
-static
-void
-ss_insertionsort(const unsigned char *T, const int *PA,
-                 int *first, int *last, int depth) {
-  int *i, *j;
-  int t;
-  int r;
-
-  for(i = last - 2; first <= i; --i) {
-    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) {
-      do { *(j - 1) = *j; } while((++j < last) && (*j < 0));
-      if(last <= j) { break; }
-    }
-    if(r == 0) { *j = ~*j; }
-    *(j - 1) = t;
-  }
-}
-
-#endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */
-
-
-/*---------------------------------------------------------------------------*/
-
-#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
-
-static INLINE
-void
-ss_fixdown(const unsigned char *Td, const int *PA,
-           int *SA, int i, int size) {
-  int j, k;
-  int v;
-  int c, d, e;
-
-  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
-    d = Td[PA[SA[k = j++]]];
-    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; }
-    if(d <= c) { break; }
-  }
-  SA[i] = v;
-}
-
-/* Simple top-down heapsort. */
-static
-void
-ss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) {
-  int i, m;
-  int t;
-
-  m = size;
-  if((size % 2) == 0) {
-    m--;
-    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); }
-  }
-
-  for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); }
-  if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); }
-  for(i = m - 1; 0 < i; --i) {
-    t = SA[0], SA[0] = SA[i];
-    ss_fixdown(Td, PA, SA, 0, i);
-    SA[i] = t;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Returns the median of three elements. */
-static INLINE
-int *
-ss_median3(const unsigned char *Td, const int *PA,
-           int *v1, int *v2, int *v3) {
-  int *t;
-  if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); }
-  if(Td[PA[*v2]] > Td[PA[*v3]]) {
-    if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; }
-    else { return v3; }
-  }
-  return v2;
-}
-
-/* Returns the median of five elements. */
-static INLINE
-int *
-ss_median5(const unsigned char *Td, const int *PA,
-           int *v1, int *v2, int *v3, int *v4, int *v5) {
-  int *t;
-  if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); }
-  if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); }
-  if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); }
-  if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); }
-  if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); }
-  if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; }
-  return v3;
-}
-
-/* Returns the pivot element. */
-static INLINE
-int *
-ss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) {
-  int *middle;
-  int t;
-
-  t = last - first;
-  middle = first + t / 2;
-
-  if(t <= 512) {
-    if(t <= 32) {
-      return ss_median3(Td, PA, first, middle, last - 1);
-    } else {
-      t >>= 2;
-      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1);
-    }
-  }
-  t >>= 3;
-  first  = ss_median3(Td, PA, first, first + t, first + (t << 1));
-  middle = ss_median3(Td, PA, middle - t, middle, middle + t);
-  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1);
-  return ss_median3(Td, PA, first, middle, last);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Binary partition for substrings. */
-static INLINE
-int *
-ss_partition(const int *PA,
-                    int *first, int *last, int depth) {
-  int *a, *b;
-  int t;
-  for(a = first - 1, b = last;;) {
-    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; }
-    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1));) { }
-    if(b <= a) { break; }
-    t = ~*b;
-    *b = *a;
-    *a = t;
-  }
-  if(first < a) { *first = ~*first; }
-  return a;
-}
-
-/* Multikey introsort for medium size groups. */
-static
-void
-ss_mintrosort(const unsigned char *T, const int *PA,
-              int *first, int *last,
-              int depth) {
-#define STACK_SIZE SS_MISORT_STACKSIZE
-  struct { int *a, *b, c; int d; } stack[STACK_SIZE];
-  const unsigned char *Td;
-  int *a, *b, *c, *d, *e, *f;
-  int s, t;
-  int ssize;
-  int limit;
-  int v, x = 0;
-
-  for(ssize = 0, limit = ss_ilg(last - first);;) {
-
-    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) {
-#if 1 < SS_INSERTIONSORT_THRESHOLD
-      if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); }
-#endif
-      STACK_POP(first, last, depth, limit);
-      continue;
-    }
-
-    Td = T + depth;
-    if(limit-- == 0) { ss_heapsort(Td, PA, first, last - first); }
-    if(limit < 0) {
-      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
-        if((x = Td[PA[*a]]) != v) {
-          if(1 < (a - first)) { break; }
-          v = x;
-          first = a;
-        }
-      }
-      if(Td[PA[*first] - 1] < v) {
-        first = ss_partition(PA, first, a, depth);
-      }
-      if((a - first) <= (last - a)) {
-        if(1 < (a - first)) {
-          STACK_PUSH(a, last, depth, -1);
-          last = a, depth += 1, limit = ss_ilg(a - first);
-        } else {
-          first = a, limit = -1;
-        }
-      } else {
-        if(1 < (last - a)) {
-          STACK_PUSH(first, a, depth + 1, ss_ilg(a - first));
-          first = a, limit = -1;
-        } else {
-          last = a, depth += 1, limit = ss_ilg(a - first);
-        }
-      }
-      continue;
-    }
-
-    /* choose pivot */
-    a = ss_pivot(Td, PA, first, last);
-    v = Td[PA[*a]];
-    SWAP(*first, *a);
-
-    /* partition */
-    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { }
-    if(((a = b) < last) && (x < v)) {
-      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
-        if(x == v) { SWAP(*b, *a); ++a; }
-      }
-    }
-    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { }
-    if((b < (d = c)) && (x > v)) {
-      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
-        if(x == v) { SWAP(*c, *d); --d; }
-      }
-    }
-    for(; b < c;) {
-      SWAP(*b, *c);
-      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
-        if(x == v) { SWAP(*b, *a); ++a; }
-      }
-      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
-        if(x == v) { SWAP(*c, *d); --d; }
-      }
-    }
-
-    if(a <= d) {
-      c = b - 1;
-
-      if((s = a - first) > (t = b - a)) { s = t; }
-      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-      if((s = d - c) > (t = last - d - 1)) { s = t; }
-      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-
-      a = first + (b - a), c = last - (d - c);
-      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
-
-      if((a - first) <= (last - c)) {
-        if((last - c) <= (c - b)) {
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          STACK_PUSH(c, last, depth, limit);
-          last = a;
-        } else if((a - first) <= (c - b)) {
-          STACK_PUSH(c, last, depth, limit);
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          last = a;
-        } else {
-          STACK_PUSH(c, last, depth, limit);
-          STACK_PUSH(first, a, depth, limit);
-          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
-        }
-      } else {
-        if((a - first) <= (c - b)) {
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          STACK_PUSH(first, a, depth, limit);
-          first = c;
-        } else if((last - c) <= (c - b)) {
-          STACK_PUSH(first, a, depth, limit);
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          first = c;
-        } else {
-          STACK_PUSH(first, a, depth, limit);
-          STACK_PUSH(c, last, depth, limit);
-          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
-        }
-      }
-    } else {
-      limit += 1;
-      if(Td[PA[*first] - 1] < v) {
-        first = ss_partition(PA, first, last, depth);
-        limit = ss_ilg(last - first);
-      }
-      depth += 1;
-    }
-  }
-#undef STACK_SIZE
-}
-
-#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
-
-
-/*---------------------------------------------------------------------------*/
-
-#if SS_BLOCKSIZE != 0
-
-static INLINE
-void
-ss_blockswap(int *a, int *b, int n) {
-  int t;
-  for(; 0 < n; --n, ++a, ++b) {
-    t = *a, *a = *b, *b = t;
-  }
-}
-
-static INLINE
-void
-ss_rotate(int *first, int *middle, int *last) {
-  int *a, *b, t;
-  int l, r;
-  l = middle - first, r = last - middle;
-  for(; (0 < l) && (0 < r);) {
-    if(l == r) { ss_blockswap(first, middle, l); break; }
-    if(l < r) {
-      a = last - 1, b = middle - 1;
-      t = *a;
-      do {
-        *a-- = *b, *b-- = *a;
-        if(b < first) {
-          *a = t;
-          last = a;
-          if((r -= l + 1) <= l) { break; }
-          a -= 1, b = middle - 1;
-          t = *a;
-        }
-      } while(1);
-    } else {
-      a = first, b = middle;
-      t = *a;
-      do {
-        *a++ = *b, *b++ = *a;
-        if(last <= b) {
-          *a = t;
-          first = a + 1;
-          if((l -= r + 1) <= r) { break; }
-          a += 1, b = middle;
-          t = *a;
-        }
-      } while(1);
-    }
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static
-void
-ss_inplacemerge(const unsigned char *T, const int *PA,
-                int *first, int *middle, int *last,
-                int depth) {
-  const int *p;
-  int *a, *b;
-  int len, half;
-  int q, r;
-  int x;
-
-  for(;;) {
-    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); }
-    else                { x = 0; p = PA +  *(last - 1); }
-    for(a = first, len = middle - first, half = len >> 1, r = -1;
-        0 < len;
-        len = half, half >>= 1) {
-      b = a + half;
-      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth);
-      if(q < 0) {
-        a = b + 1;
-        half -= (len & 1) ^ 1;
-      } else {
-        r = q;
-      }
-    }
-    if(a < middle) {
-      if(r == 0) { *a = ~*a; }
-      ss_rotate(a, middle, last);
-      last -= middle - a;
-      middle = a;
-      if(first == middle) { break; }
-    }
-    --last;
-    if(x != 0) { while(*--last < 0) { } }
-    if(middle == last) { break; }
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Merge-forward with internal buffer. */
-static
-void
-ss_mergeforward(const unsigned char *T, const int *PA,
-                int *first, int *middle, int *last,
-                int *buf, int depth) {
-  int *a, *b, *c, *bufend;
-  int t;
-  int r;
-
-  bufend = buf + (middle - first) - 1;
-  ss_blockswap(buf, first, middle - first);
-
-  for(t = *(a = first), b = buf, c = middle;;) {
-    r = ss_compare(T, PA + *b, PA + *c, depth);
-    if(r < 0) {
-      do {
-        *a++ = *b;
-        if(bufend <= b) { *bufend = t; return; }
-        *b++ = *a;
-      } while(*b < 0);
-    } else if(r > 0) {
-      do {
-        *a++ = *c, *c++ = *a;
-        if(last <= c) {
-          while(b < bufend) { *a++ = *b, *b++ = *a; }
-          *a = *b, *b = t;
-          return;
-        }
-      } while(*c < 0);
-    } else {
-      *c = ~*c;
-      do {
-        *a++ = *b;
-        if(bufend <= b) { *bufend = t; return; }
-        *b++ = *a;
-      } while(*b < 0);
-
-      do {
-        *a++ = *c, *c++ = *a;
-        if(last <= c) {
-          while(b < bufend) { *a++ = *b, *b++ = *a; }
-          *a = *b, *b = t;
-          return;
-        }
-      } while(*c < 0);
-    }
-  }
-}
-
-/* Merge-backward with internal buffer. */
-static
-void
-ss_mergebackward(const unsigned char *T, const int *PA,
-                 int *first, int *middle, int *last,
-                 int *buf, int depth) {
-  const int *p1, *p2;
-  int *a, *b, *c, *bufend;
-  int t;
-  int r;
-  int x;
-
-  bufend = buf + (last - middle) - 1;
-  ss_blockswap(buf, middle, last - middle);
-
-  x = 0;
-  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; }
-  else                  { p1 = PA +  *bufend; }
-  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; }
-  else                  { p2 = PA +  *(middle - 1); }
-  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) {
-    r = ss_compare(T, p1, p2, depth);
-    if(0 < r) {
-      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
-      *a-- = *b;
-      if(b <= buf) { *buf = t; break; }
-      *b-- = *a;
-      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
-      else       { p1 = PA +  *b; }
-    } else if(r < 0) {
-      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
-      *a-- = *c, *c-- = *a;
-      if(c < first) {
-        while(buf < b) { *a-- = *b, *b-- = *a; }
-        *a = *b, *b = t;
-        break;
-      }
-      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
-      else       { p2 = PA +  *c; }
-    } else {
-      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
-      *a-- = ~*b;
-      if(b <= buf) { *buf = t; break; }
-      *b-- = *a;
-      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
-      *a-- = *c, *c-- = *a;
-      if(c < first) {
-        while(buf < b) { *a-- = *b, *b-- = *a; }
-        *a = *b, *b = t;
-        break;
-      }
-      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
-      else       { p1 = PA +  *b; }
-      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
-      else       { p2 = PA +  *c; }
-    }
-  }
-}
-
-/* D&C based merge. */
-static
-void
-ss_swapmerge(const unsigned char *T, const int *PA,
-             int *first, int *middle, int *last,
-             int *buf, int bufsize, int depth) {
-#define STACK_SIZE SS_SMERGE_STACKSIZE
-#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))
-#define MERGE_CHECK(a, b, c)\
-  do {\
-    if(((c) & 1) ||\
-       (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\
-      *(a) = ~*(a);\
-    }\
-    if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\
-      *(b) = ~*(b);\
-    }\
-  } while(0)
-  struct { int *a, *b, *c; int d; } stack[STACK_SIZE];
-  int *l, *r, *lm, *rm;
-  int m, len, half;
-  int ssize;
-  int check, next;
-
-  for(check = 0, ssize = 0;;) {
-    if((last - middle) <= bufsize) {
-      if((first < middle) && (middle < last)) {
-        ss_mergebackward(T, PA, first, middle, last, buf, depth);
-      }
-      MERGE_CHECK(first, last, check);
-      STACK_POP(first, middle, last, check);
-      continue;
-    }
-
-    if((middle - first) <= bufsize) {
-      if(first < middle) {
-        ss_mergeforward(T, PA, first, middle, last, buf, depth);
-      }
-      MERGE_CHECK(first, last, check);
-      STACK_POP(first, middle, last, check);
-      continue;
-    }
-
-    for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1;
-        0 < len;
-        len = half, half >>= 1) {
-      if(ss_compare(T, PA + GETIDX(*(middle + m + half)),
-                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0) {
-        m += half + 1;
-        half -= (len & 1) ^ 1;
-      }
-    }
-
-    if(0 < m) {
-      lm = middle - m, rm = middle + m;
-      ss_blockswap(lm, middle, m);
-      l = r = middle, next = 0;
-      if(rm < last) {
-        if(*rm < 0) {
-          *rm = ~*rm;
-          if(first < lm) { for(; *--l < 0;) { } next |= 4; }
-          next |= 1;
-        } else if(first < lm) {
-          for(; *r < 0; ++r) { }
-          next |= 2;
-        }
-      }
-
-      if((l - first) <= (last - r)) {
-        STACK_PUSH(r, rm, last, (next & 3) | (check & 4));
-        middle = lm, last = l, check = (check & 3) | (next & 4);
-      } else {
-        if((next & 2) && (r == middle)) { next ^= 6; }
-        STACK_PUSH(first, lm, l, (check & 3) | (next & 4));
-        first = r, middle = rm, check = (next & 3) | (check & 4);
-      }
-    } else {
-      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) {
-        *middle = ~*middle;
-      }
-      MERGE_CHECK(first, last, check);
-      STACK_POP(first, middle, last, check);
-    }
-  }
-#undef STACK_SIZE
-}
-
-#endif /* SS_BLOCKSIZE != 0 */
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Substring sort */
-static
-void
-sssort(const unsigned char *T, const int *PA,
-       int *first, int *last,
-       int *buf, int bufsize,
-       int depth, int n, int lastsuffix) {
-  int *a;
-#if SS_BLOCKSIZE != 0
-  int *b, *middle, *curbuf;
-  int j, k, curbufsize, limit;
-#endif
-  int i;
-
-  if(lastsuffix != 0) { ++first; }
-
-#if SS_BLOCKSIZE == 0
-  ss_mintrosort(T, PA, first, last, depth);
-#else
-  if((bufsize < SS_BLOCKSIZE) &&
-      (bufsize < (last - first)) &&
-      (bufsize < (limit = ss_isqrt(last - first)))) {
-    if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; }
-    buf = middle = last - limit, bufsize = limit;
-  } else {
-    middle = last, limit = 0;
-  }
-  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) {
-#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
-    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth);
-#elif 1 < SS_BLOCKSIZE
-    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth);
-#endif
-    curbufsize = last - (a + SS_BLOCKSIZE);
-    curbuf = a + SS_BLOCKSIZE;
-    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; }
-    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {
-      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);
-    }
-  }
-#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
-  ss_mintrosort(T, PA, a, middle, depth);
-#elif 1 < SS_BLOCKSIZE
-  ss_insertionsort(T, PA, a, middle, depth);
-#endif
-  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {
-    if(i & 1) {
-      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth);
-      a -= k;
-    }
-  }
-  if(limit != 0) {
-#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
-    ss_mintrosort(T, PA, middle, last, depth);
-#elif 1 < SS_BLOCKSIZE
-    ss_insertionsort(T, PA, middle, last, depth);
-#endif
-    ss_inplacemerge(T, PA, first, middle, last, depth);
-  }
-#endif
-
-  if(lastsuffix != 0) {
-    /* Insert last type B* suffix. */
-    int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2;
-    for(a = first, i = *(first - 1);
-        (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth)));
-        ++a) {
-      *(a - 1) = *a;
-    }
-    *(a - 1) = i;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static INLINE
-int
-tr_ilg(int n) {
-  return (n & 0xffff0000) ?
-          ((n & 0xff000000) ?
-            24 + lg_table[(n >> 24) & 0xff] :
-            16 + lg_table[(n >> 16) & 0xff]) :
-          ((n & 0x0000ff00) ?
-             8 + lg_table[(n >>  8) & 0xff] :
-             0 + lg_table[(n >>  0) & 0xff]);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Simple insertionsort for small size groups. */
-static
-void
-tr_insertionsort(const int *ISAd, int *first, int *last) {
-  int *a, *b;
-  int t, r;
-
-  for(a = first + 1; a < last; ++a) {
-    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) {
-      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0));
-      if(b < first) { break; }
-    }
-    if(r == 0) { *b = ~*b; }
-    *(b + 1) = t;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static INLINE
-void
-tr_fixdown(const int *ISAd, int *SA, int i, int size) {
-  int j, k;
-  int v;
-  int c, d, e;
-
-  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
-    d = ISAd[SA[k = j++]];
-    if(d < (e = ISAd[SA[j]])) { k = j; d = e; }
-    if(d <= c) { break; }
-  }
-  SA[i] = v;
-}
-
-/* Simple top-down heapsort. */
-static
-void
-tr_heapsort(const int *ISAd, int *SA, int size) {
-  int i, m;
-  int t;
-
-  m = size;
-  if((size % 2) == 0) {
-    m--;
-    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); }
-  }
-
-  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); }
-  if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); }
-  for(i = m - 1; 0 < i; --i) {
-    t = SA[0], SA[0] = SA[i];
-    tr_fixdown(ISAd, SA, 0, i);
-    SA[i] = t;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Returns the median of three elements. */
-static INLINE
-int *
-tr_median3(const int *ISAd, int *v1, int *v2, int *v3) {
-  int *t;
-  if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); }
-  if(ISAd[*v2] > ISAd[*v3]) {
-    if(ISAd[*v1] > ISAd[*v3]) { return v1; }
-    else { return v3; }
-  }
-  return v2;
-}
-
-/* Returns the median of five elements. */
-static INLINE
-int *
-tr_median5(const int *ISAd,
-           int *v1, int *v2, int *v3, int *v4, int *v5) {
-  int *t;
-  if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); }
-  if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); }
-  if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); }
-  if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); }
-  if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); }
-  if(ISAd[*v3] > ISAd[*v4]) { return v4; }
-  return v3;
-}
-
-/* Returns the pivot element. */
-static INLINE
-int *
-tr_pivot(const int *ISAd, int *first, int *last) {
-  int *middle;
-  int t;
-
-  t = last - first;
-  middle = first + t / 2;
-
-  if(t <= 512) {
-    if(t <= 32) {
-      return tr_median3(ISAd, first, middle, last - 1);
-    } else {
-      t >>= 2;
-      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1);
-    }
-  }
-  t >>= 3;
-  first  = tr_median3(ISAd, first, first + t, first + (t << 1));
-  middle = tr_median3(ISAd, middle - t, middle, middle + t);
-  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1);
-  return tr_median3(ISAd, first, middle, last);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-typedef struct _trbudget_t trbudget_t;
-struct _trbudget_t {
-  int chance;
-  int remain;
-  int incval;
-  int count;
-};
-
-static INLINE
-void
-trbudget_init(trbudget_t *budget, int chance, int incval) {
-  budget->chance = chance;
-  budget->remain = budget->incval = incval;
-}
-
-static INLINE
-int
-trbudget_check(trbudget_t *budget, int size) {
-  if(size <= budget->remain) { budget->remain -= size; return 1; }
-  if(budget->chance == 0) { budget->count += size; return 0; }
-  budget->remain += budget->incval - size;
-  budget->chance -= 1;
-  return 1;
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static INLINE
-void
-tr_partition(const int *ISAd,
-             int *first, int *middle, int *last,
-             int **pa, int **pb, int v) {
-  int *a, *b, *c, *d, *e, *f;
-  int t, s;
-  int x = 0;
-
-  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { }
-  if(((a = b) < last) && (x < v)) {
-    for(; (++b < last) && ((x = ISAd[*b]) <= v);) {
-      if(x == v) { SWAP(*b, *a); ++a; }
-    }
-  }
-  for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { }
-  if((b < (d = c)) && (x > v)) {
-    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
-      if(x == v) { SWAP(*c, *d); --d; }
-    }
-  }
-  for(; b < c;) {
-    SWAP(*b, *c);
-    for(; (++b < c) && ((x = ISAd[*b]) <= v);) {
-      if(x == v) { SWAP(*b, *a); ++a; }
-    }
-    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
-      if(x == v) { SWAP(*c, *d); --d; }
-    }
-  }
-
-  if(a <= d) {
-    c = b - 1;
-    if((s = a - first) > (t = b - a)) { s = t; }
-    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-    if((s = d - c) > (t = last - d - 1)) { s = t; }
-    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-    first += (b - a), last -= (d - c);
-  }
-  *pa = first, *pb = last;
-}
-
-static
-void
-tr_copy(int *ISA, const int *SA,
-        int *first, int *a, int *b, int *last,
-        int depth) {
-  /* sort suffixes of middle partition
-     by using sorted order of suffixes of left and right partition. */
-  int *c, *d, *e;
-  int s, v;
-
-  v = b - SA - 1;
-  for(c = first, d = a - 1; c <= d; ++c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *++d = s;
-      ISA[s] = d - SA;
-    }
-  }
-  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *--d = s;
-      ISA[s] = d - SA;
-    }
-  }
-}
-
-static
-void
-tr_partialcopy(int *ISA, const int *SA,
-               int *first, int *a, int *b, int *last,
-               int depth) {
-  int *c, *d, *e;
-  int s, v;
-  int rank, lastrank, newrank = -1;
-
-  v = b - SA - 1;
-  lastrank = -1;
-  for(c = first, d = a - 1; c <= d; ++c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *++d = s;
-      rank = ISA[s + depth];
-      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
-      ISA[s] = newrank;
-    }
-  }
-
-  lastrank = -1;
-  for(e = d; first <= e; --e) {
-    rank = ISA[*e];
-    if(lastrank != rank) { lastrank = rank; newrank = e - SA; }
-    if(newrank != rank) { ISA[*e] = newrank; }
-  }
-
-  lastrank = -1;
-  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *--d = s;
-      rank = ISA[s + depth];
-      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
-      ISA[s] = newrank;
-    }
-  }
-}
-
-static
-void
-tr_introsort(int *ISA, const int *ISAd,
-             int *SA, int *first, int *last,
-             trbudget_t *budget) {
-#define STACK_SIZE TR_STACKSIZE
-  struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE];
-  int *a, *b, *c;
-  int t;
-  int v, x = 0;
-  int incr = ISAd - ISA;
-  int limit, next;
-  int ssize, trlink = -1;
-
-  for(ssize = 0, limit = tr_ilg(last - first);;) {
-
-    if(limit < 0) {
-      if(limit == -1) {
-        /* tandem repeat partition */
-        tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1);
-
-        /* update ranks */
-        if(a < last) {
-          for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
-        }
-        if(b < last) {
-          for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; }
-        }
-
-        /* push */
-        if(1 < (b - a)) {
-          STACK_PUSH5(NULL, a, b, 0, 0);
-          STACK_PUSH5(ISAd - incr, first, last, -2, trlink);
-          trlink = ssize - 2;
-        }
-        if((a - first) <= (last - b)) {
-          if(1 < (a - first)) {
-            STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink);
-            last = a, limit = tr_ilg(a - first);
-          } else if(1 < (last - b)) {
-            first = b, limit = tr_ilg(last - b);
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        } else {
-          if(1 < (last - b)) {
-            STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink);
-            first = b, limit = tr_ilg(last - b);
-          } else if(1 < (a - first)) {
-            last = a, limit = tr_ilg(a - first);
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        }
-      } else if(limit == -2) {
-        /* tandem repeat copy */
-        a = stack[--ssize].b, b = stack[ssize].c;
-        if(stack[ssize].d == 0) {
-          tr_copy(ISA, SA, first, a, b, last, ISAd - ISA);
-        } else {
-          if(0 <= trlink) { stack[trlink].d = -1; }
-          tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA);
-        }
-        STACK_POP5(ISAd, first, last, limit, trlink);
-      } else {
-        /* sorted partition */
-        if(0 <= *first) {
-          a = first;
-          do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a));
-          first = a;
-        }
-        if(first < last) {
-          a = first; do { *a = ~*a; } while(*++a < 0);
-          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1;
-          if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } }
-
-          /* push */
-          if(trbudget_check(budget, a - first)) {
-            if((a - first) <= (last - a)) {
-              STACK_PUSH5(ISAd, a, last, -3, trlink);
-              ISAd += incr, last = a, limit = next;
-            } else {
-              if(1 < (last - a)) {
-                STACK_PUSH5(ISAd + incr, first, a, next, trlink);
-                first = a, limit = -3;
-              } else {
-                ISAd += incr, last = a, limit = next;
-              }
-            }
-          } else {
-            if(0 <= trlink) { stack[trlink].d = -1; }
-            if(1 < (last - a)) {
-              first = a, limit = -3;
-            } else {
-              STACK_POP5(ISAd, first, last, limit, trlink);
-            }
-          }
-        } else {
-          STACK_POP5(ISAd, first, last, limit, trlink);
-        }
-      }
-      continue;
-    }
-
-    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) {
-      tr_insertionsort(ISAd, first, last);
-      limit = -3;
-      continue;
-    }
-
-    if(limit-- == 0) {
-      tr_heapsort(ISAd, first, last - first);
-      for(a = last - 1; first < a; a = b) {
-        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; }
-      }
-      limit = -3;
-      continue;
-    }
-
-    /* choose pivot */
-    a = tr_pivot(ISAd, first, last);
-    SWAP(*first, *a);
-    v = ISAd[*first];
-
-    /* partition */
-    tr_partition(ISAd, first, first + 1, last, &a, &b, v);
-    if((last - first) != (b - a)) {
-      next = (ISA[*a] != v) ? tr_ilg(b - a) : -1;
-
-      /* update ranks */
-      for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
-      if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } }
-
-      /* push */
-      if((1 < (b - a)) && (trbudget_check(budget, b - a))) {
-        if((a - first) <= (last - b)) {
-          if((last - b) <= (b - a)) {
-            if(1 < (a - first)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              STACK_PUSH5(ISAd, b, last, limit, trlink);
-              last = a;
-            } else if(1 < (last - b)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              first = b;
-            } else {
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else if((a - first) <= (b - a)) {
-            if(1 < (a - first)) {
-              STACK_PUSH5(ISAd, b, last, limit, trlink);
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              last = a;
-            } else {
-              STACK_PUSH5(ISAd, b, last, limit, trlink);
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else {
-            STACK_PUSH5(ISAd, b, last, limit, trlink);
-            STACK_PUSH5(ISAd, first, a, limit, trlink);
-            ISAd += incr, first = a, last = b, limit = next;
-          }
-        } else {
-          if((a - first) <= (b - a)) {
-            if(1 < (last - b)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              STACK_PUSH5(ISAd, first, a, limit, trlink);
-              first = b;
-            } else if(1 < (a - first)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              last = a;
-            } else {
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else if((last - b) <= (b - a)) {
-            if(1 < (last - b)) {
-              STACK_PUSH5(ISAd, first, a, limit, trlink);
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              first = b;
-            } else {
-              STACK_PUSH5(ISAd, first, a, limit, trlink);
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else {
-            STACK_PUSH5(ISAd, first, a, limit, trlink);
-            STACK_PUSH5(ISAd, b, last, limit, trlink);
-            ISAd += incr, first = a, last = b, limit = next;
-          }
-        }
-      } else {
-        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; }
-        if((a - first) <= (last - b)) {
-          if(1 < (a - first)) {
-            STACK_PUSH5(ISAd, b, last, limit, trlink);
-            last = a;
-          } else if(1 < (last - b)) {
-            first = b;
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        } else {
-          if(1 < (last - b)) {
-            STACK_PUSH5(ISAd, first, a, limit, trlink);
-            first = b;
-          } else if(1 < (a - first)) {
-            last = a;
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        }
-      }
-    } else {
-      if(trbudget_check(budget, last - first)) {
-        limit = tr_ilg(last - first), ISAd += incr;
-      } else {
-        if(0 <= trlink) { stack[trlink].d = -1; }
-        STACK_POP5(ISAd, first, last, limit, trlink);
-      }
-    }
-  }
-#undef STACK_SIZE
-}
-
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Tandem repeat sort */
-static
-void
-trsort(int *ISA, int *SA, int n, int depth) {
-  int *ISAd;
-  int *first, *last;
-  trbudget_t budget;
-  int t, skip, unsorted;
-
-  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n);
-/*  trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */
-  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) {
-    first = SA;
-    skip = 0;
-    unsorted = 0;
-    do {
-      if((t = *first) < 0) { first -= t; skip += t; }
-      else {
-        if(skip != 0) { *(first + skip) = skip; skip = 0; }
-        last = SA + ISA[t] + 1;
-        if(1 < (last - first)) {
-          budget.count = 0;
-          tr_introsort(ISA, ISAd, SA, first, last, &budget);
-          if(budget.count != 0) { unsorted += budget.count; }
-          else { skip = first - last; }
-        } else if((last - first) == 1) {
-          skip = -1;
-        }
-        first = last;
-      }
-    } while(first < (SA + n));
-    if(skip != 0) { *(first + skip) = skip; }
-    if(unsorted == 0) { break; }
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Sorts suffixes of type B*. */
-static
-int
-sort_typeBstar(const unsigned char *T, int *SA,
-               int *bucket_A, int *bucket_B,
-               int n, int openMP) {
-  int *PAb, *ISAb, *buf;
-#ifdef LIBBSC_OPENMP
-  int *curbuf;
-  int l;
-#endif
-  int i, j, k, t, m, bufsize;
-  int c0, c1;
-#ifdef LIBBSC_OPENMP
-  int d0, d1;
-#endif
-  (void)openMP;
-
-  /* Initialize bucket arrays. */
-  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }
-  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }
-
-  /* Count the number of occurrences of the first one or two characters of each
-     type A, B and B* suffix. Moreover, store the beginning position of all
-     type B* suffixes into the array SA. */
-  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {
-    /* type A suffix. */
-    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1));
-    if(0 <= i) {
-      /* type B* suffix. */
-      ++BUCKET_BSTAR(c0, c1);
-      SA[--m] = i;
-      /* type B suffix. */
-      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
-        ++BUCKET_B(c0, c1);
-      }
-    }
-  }
-  m = n - m;
-/*
-note:
-  A type B* suffix is lexicographically smaller than a type B suffix that
-  begins with the same first two characters.
-*/
-
-  /* Calculate the index of start/end point of each bucket. */
-  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {
-    t = i + BUCKET_A(c0);
-    BUCKET_A(c0) = i + j; /* start point */
-    i = t + BUCKET_B(c0, c0);
-    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {
-      j += BUCKET_BSTAR(c0, c1);
-      BUCKET_BSTAR(c0, c1) = j; /* end point */
-      i += BUCKET_B(c0, c1);
-    }
-  }
-
-  if(0 < m) {
-    /* Sort the type B* suffixes by their first two characters. */
-    PAb = SA + n - m; ISAb = SA + m;
-    for(i = m - 2; 0 <= i; --i) {
-      t = PAb[i], c0 = T[t], c1 = T[t + 1];
-      SA[--BUCKET_BSTAR(c0, c1)] = i;
-    }
-    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];
-    SA[--BUCKET_BSTAR(c0, c1)] = m - 1;
-
-    /* Sort the type B* substrings using sssort. */
-#ifdef LIBBSC_OPENMP
-    if (openMP)
-    {
-        buf = SA + m;
-        c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m;
-#pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1)
-        {
-          bufsize = (n - (2 * m)) / omp_get_num_threads();
-          curbuf = buf + omp_get_thread_num() * bufsize;
-          k = 0;
-          for(;;) {
-            #pragma omp critical(sssort_lock)
-            {
-              if(0 < (l = j)) {
-                d0 = c0, d1 = c1;
-                do {
-                  k = BUCKET_BSTAR(d0, d1);
-                  if(--d1 <= d0) {
-                    d1 = ALPHABET_SIZE - 1;
-                    if(--d0 < 0) { break; }
-                  }
-                } while(((l - k) <= 1) && (0 < (l = k)));
-                c0 = d0, c1 = d1, j = k;
-              }
-            }
-            if(l == 0) { break; }
-            sssort(T, PAb, SA + k, SA + l,
-                   curbuf, bufsize, 2, n, *(SA + k) == (m - 1));
-          }
-        }
-    }
-    else
-    {
-        buf = SA + m, bufsize = n - (2 * m);
-        for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
-          for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
-            i = BUCKET_BSTAR(c0, c1);
-            if(1 < (j - i)) {
-              sssort(T, PAb, SA + i, SA + j,
-                     buf, bufsize, 2, n, *(SA + i) == (m - 1));
-            }
-          }
-        }
-    }
-#else
-    buf = SA + m, bufsize = n - (2 * m);
-    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
-      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
-        i = BUCKET_BSTAR(c0, c1);
-        if(1 < (j - i)) {
-          sssort(T, PAb, SA + i, SA + j,
-                 buf, bufsize, 2, n, *(SA + i) == (m - 1));
-        }
-      }
-    }
-#endif
-
-    /* Compute ranks of type B* substrings. */
-    for(i = m - 1; 0 <= i; --i) {
-      if(0 <= SA[i]) {
-        j = i;
-        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i]));
-        SA[i + 1] = i - j;
-        if(i <= 0) { break; }
-      }
-      j = i;
-      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0);
-      ISAb[SA[i]] = j;
-    }
-
-    /* Construct the inverse suffix array of type B* suffixes using trsort. */
-    trsort(ISAb, SA, m, 1);
-
-    /* Set the sorted order of type B* suffixes. */
-    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {
-      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { }
-      if(0 <= i) {
-        t = i;
-        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { }
-        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;
-      }
-    }
-
-    /* Calculate the index of start/end point of each bucket. */
-    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */
-    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) {
-      i = BUCKET_A(c0 + 1) - 1;
-      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) {
-        t = i - BUCKET_B(c0, c1);
-        BUCKET_B(c0, c1) = i; /* end point */
-
-        /* Move all type B* suffixes to the correct position. */
-        for(i = t, j = BUCKET_BSTAR(c0, c1);
-            j <= k;
-            --i, --k) { SA[i] = SA[k]; }
-      }
-      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */
-      BUCKET_B(c0, c0) = i; /* end point */
-    }
-  }
-
-  return m;
-}
-
-/* Constructs the suffix array by using the sorted order of type B* suffixes. */
-static
-void
-construct_SA(const unsigned char *T, int *SA,
-             int *bucket_A, int *bucket_B,
-             int n, int m) {
-  int *i, *j, *k;
-  int s;
-  int c0, c1, c2;
-
-  if(0 < m) {
-    /* Construct the sorted order of type B suffixes by using
-       the sorted order of type B* suffixes. */
-    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
-      /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
-        if(0 < (s = *j)) {
-          assert(T[s] == c1);
-          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
-          assert(T[s - 1] <= T[s]);
-          *j = ~s;
-          c0 = T[--s];
-          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
-          if(c0 != c2) {
-            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
-            k = SA + BUCKET_B(c2 = c0, c1);
-          }
-          assert(k < j); assert(k != NULL);
-          *k-- = s;
-        } else {
-          assert(((s == 0) && (T[s] == c1)) || (s < 0));
-          *j = ~s;
-        }
-      }
-    }
-  }
-
-  /* Construct the suffix array by using
-     the sorted order of type B suffixes. */
-  k = SA + BUCKET_A(c2 = T[n - 1]);
-  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1);
-  /* Scan the suffix array from left to right. */
-  for(i = SA, j = SA + n; i < j; ++i) {
-    if(0 < (s = *i)) {
-      assert(T[s - 1] >= T[s]);
-      c0 = T[--s];
-      if((s == 0) || (T[s - 1] < c0)) { s = ~s; }
-      if(c0 != c2) {
-        BUCKET_A(c2) = k - SA;
-        k = SA + BUCKET_A(c2 = c0);
-      }
-      assert(i < k);
-      *k++ = s;
-    } else {
-      assert(s < 0);
-      *i = ~s;
-    }
-  }
-}
-
-/* Constructs the burrows-wheeler transformed string directly
-   by using the sorted order of type B* suffixes. */
-static
-int
-construct_BWT(const unsigned char *T, int *SA,
-              int *bucket_A, int *bucket_B,
-              int n, int m) {
-  int *i, *j, *k, *orig;
-  int s;
-  int c0, c1, c2;
-
-  if(0 < m) {
-    /* Construct the sorted order of type B suffixes by using
-       the sorted order of type B* suffixes. */
-    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
-      /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
-        if(0 < (s = *j)) {
-          assert(T[s] == c1);
-          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
-          assert(T[s - 1] <= T[s]);
-          c0 = T[--s];
-          *j = ~((int)c0);
-          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
-          if(c0 != c2) {
-            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
-            k = SA + BUCKET_B(c2 = c0, c1);
-          }
-          assert(k < j); assert(k != NULL);
-          *k-- = s;
-        } else if(s != 0) {
-          *j = ~s;
-#ifndef NDEBUG
-        } else {
-          assert(T[s] == c1);
-#endif
-        }
-      }
-    }
-  }
-
-  /* Construct the BWTed string by using
-     the sorted order of type B suffixes. */
-  k = SA + BUCKET_A(c2 = T[n - 1]);
-  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1);
-  /* Scan the suffix array from left to right. */
-  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
-    if(0 < (s = *i)) {
-      assert(T[s - 1] >= T[s]);
-      c0 = T[--s];
-      *i = c0;
-      if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); }
-      if(c0 != c2) {
-        BUCKET_A(c2) = k - SA;
-        k = SA + BUCKET_A(c2 = c0);
-      }
-      assert(i < k);
-      *k++ = s;
-    } else if(s != 0) {
-      *i = ~s;
-    } else {
-      orig = i;
-    }
-  }
-
-  return orig - SA;
-}
-
-/* Constructs the burrows-wheeler transformed string directly
-   by using the sorted order of type B* suffixes. */
-static
-int
-construct_BWT_indexes(const unsigned char *T, int *SA,
-                      int *bucket_A, int *bucket_B,
-                      int n, int m,
-                      unsigned char * num_indexes, int * indexes) {
-  int *i, *j, *k, *orig;
-  int s;
-  int c0, c1, c2;
-
-  int mod = n / 8;
-  {
-      mod |= mod >> 1;  mod |= mod >> 2;
-      mod |= mod >> 4;  mod |= mod >> 8;
-      mod |= mod >> 16; mod >>= 1;
-
-      *num_indexes = (unsigned char)((n - 1) / (mod + 1));
-  }
-
-  if(0 < m) {
-    /* Construct the sorted order of type B suffixes by using
-       the sorted order of type B* suffixes. */
-    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
-      /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
-        if(0 < (s = *j)) {
-          assert(T[s] == c1);
-          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
-          assert(T[s - 1] <= T[s]);
-
-          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = j - SA;
-
-          c0 = T[--s];
-          *j = ~((int)c0);
-          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
-          if(c0 != c2) {
-            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
-            k = SA + BUCKET_B(c2 = c0, c1);
-          }
-          assert(k < j); assert(k != NULL);
-          *k-- = s;
-        } else if(s != 0) {
-          *j = ~s;
-#ifndef NDEBUG
-        } else {
-          assert(T[s] == c1);
-#endif
-        }
-      }
-    }
-  }
-
-  /* Construct the BWTed string by using
-     the sorted order of type B suffixes. */
-  k = SA + BUCKET_A(c2 = T[n - 1]);
-  if (T[n - 2] < c2) {
-    if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = k - SA;
-    *k++ = ~((int)T[n - 2]);
-  }
-  else {
-    *k++ = n - 1;
-  }
-
-  /* Scan the suffix array from left to right. */
-  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
-    if(0 < (s = *i)) {
-      assert(T[s - 1] >= T[s]);
-
-      if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = i - SA;
-
-      c0 = T[--s];
-      *i = c0;
-      if(c0 != c2) {
-        BUCKET_A(c2) = k - SA;
-        k = SA + BUCKET_A(c2 = c0);
-      }
-      assert(i < k);
-      if((0 < s) && (T[s - 1] < c0)) {
-          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = k - SA;
-          *k++ = ~((int)T[s - 1]);
-      } else
-        *k++ = s;
-    } else if(s != 0) {
-      *i = ~s;
-    } else {
-      orig = i;
-    }
-  }
-
-  return orig - SA;
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/*- Function -*/
-
-int
-divsufsort(const unsigned char *T, int *SA, int n, int openMP) {
-  int *bucket_A, *bucket_B;
-  int m;
-  int err = 0;
-
-  /* Check arguments. */
-  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; }
-  else if(n == 0) { return 0; }
-  else if(n == 1) { SA[0] = 0; return 0; }
-  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; }
-
-  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
-  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
-
-  /* Suffixsort. */
-  if((bucket_A != NULL) && (bucket_B != NULL)) {
-    m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP);
-    construct_SA(T, SA, bucket_A, bucket_B, n, m);
-  } else {
-    err = -2;
-  }
-
-  free(bucket_B);
-  free(bucket_A);
-
-  return err;
-}
-
-int
-divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) {
-  int *B;
-  int *bucket_A, *bucket_B;
-  int m, pidx, i;
-
-  /* Check arguments. */
-  if((T == NULL) || (U == NULL) || (n < 0)) { return -1; }
-  else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
-
-  if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); }
-  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
-  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
-
-  /* Burrows-Wheeler Transform. */
-  if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) {
-    m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP);
-
-    if (num_indexes == NULL || indexes == NULL) {
-        pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m);
-    } else {
-        pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes);
-    }
-
-    /* Copy to output string. */
-    U[0] = T[n - 1];
-    for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; }
-    for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; }
-    pidx += 1;
-  } else {
-    pidx = -2;
-  }
-
-  free(bucket_B);
-  free(bucket_A);
-  if(A == NULL) { free(B); }
-
-  return pidx;
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/dict/fastcover.cpp b/src/duckdb/third_party/zstd/dict/fastcover.cpp
deleted file mode 100644
index 53e8b7c19..000000000
--- a/src/duckdb/third_party/zstd/dict/fastcover.cpp
+++ /dev/null
@@ -1,774 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stdio.h>  /* fprintf */
-#include <stdlib.h> /* malloc, free, qsort */
-#include <string.h> /* memset */
-#include <time.h>   /* clock */
-
-#ifndef ZDICT_STATIC_LINKING_ONLY
-#  define ZDICT_STATIC_LINKING_ONLY
-#endif
-
-#include "zstd/common/mem.h" /* read */
-#include "zstd/common/pool.h"
-#include "zstd/common/threading.h"
-#include "zstd/common/zstd_internal.h" /* includes zstd.h */
-#include "zstd/compress/zstd_compress_internal.h" /* ZSTD_hash*() */
-#include "zdict.h"
-#include "zstd/dict/cover.h"
-
-
-/*-*************************************
-*  Constants
-***************************************/
-/**
-* There are 32bit indexes used to ref samples, so limit samples size to 4GB
-* on 64bit builds.
-* For 32bit builds we choose 1 GB.
-* Most 32bit platforms have 2GB user-mode addressable space and we allocate a large
-* contiguous buffer, so 1GB is already a high limit.
-*/
-#define FASTCOVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))
-#define FASTCOVER_MAX_F 31
-#define FASTCOVER_MAX_ACCEL 10
-#define FASTCOVER_DEFAULT_SPLITPOINT 0.75
-#define DEFAULT_F 20
-#define DEFAULT_ACCEL 1
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Console display
-***************************************/
-#ifndef LOCALDISPLAYLEVEL
-static int g_displayLevel = 0;
-#endif
-#undef  DISPLAY
-// CRAN does not allow stderr references
-#define DISPLAY(...)                                                           \
-  {                                                                            \
-  }
-#undef  LOCALDISPLAYLEVEL
-#define LOCALDISPLAYLEVEL(displayLevel, l, ...)                                \
-  if (displayLevel >= l) {                                                     \
-    DISPLAY(__VA_ARGS__);                                                      \
-  } /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
-#undef  DISPLAYLEVEL
-#define DISPLAYLEVEL(l, ...) LOCALDISPLAYLEVEL(g_displayLevel, l, __VA_ARGS__)
-
-#ifndef LOCALDISPLAYUPDATE
-static const clock_t g_refreshRate = CLOCKS_PER_SEC * 15 / 100;
-static clock_t g_time = 0;
-#endif
-#undef  LOCALDISPLAYUPDATE
-#define LOCALDISPLAYUPDATE(displayLevel, l, ...)                               \
-  if (displayLevel >= l) {                                                     \
-    if ((clock() - g_time > g_refreshRate) || (displayLevel >= 4)) {             \
-      g_time = clock();                                                        \
-      DISPLAY(__VA_ARGS__);                                                    \
-    }                                                                          \
-  }
-#undef  DISPLAYUPDATE
-#define DISPLAYUPDATE(l, ...) LOCALDISPLAYUPDATE(g_displayLevel, l, __VA_ARGS__)
-
-
-/*-*************************************
-* Hash Functions
-***************************************/
-/**
- * Hash the d-byte value pointed to by p and mod 2^f into the frequency vector
- */
-static size_t FASTCOVER_hashPtrToIndex(const void* p, U32 f, unsigned d) {
-  if (d == 6) {
-    return ZSTD_hash6Ptr(p, f);
-  }
-  return ZSTD_hash8Ptr(p, f);
-}
-
-
-/*-*************************************
-* Acceleration
-***************************************/
-typedef struct {
-  unsigned finalize;    /* Percentage of training samples used for ZDICT_finalizeDictionary */
-  unsigned skip;        /* Number of dmer skipped between each dmer counted in computeFrequency */
-} FASTCOVER_accel_t;
-
-
-static const FASTCOVER_accel_t FASTCOVER_defaultAccelParameters[FASTCOVER_MAX_ACCEL+1] = {
-  { 100, 0 },   /* accel = 0, should not happen because accel = 0 defaults to accel = 1 */
-  { 100, 0 },   /* accel = 1 */
-  { 50, 1 },   /* accel = 2 */
-  { 34, 2 },   /* accel = 3 */
-  { 25, 3 },   /* accel = 4 */
-  { 20, 4 },   /* accel = 5 */
-  { 17, 5 },   /* accel = 6 */
-  { 14, 6 },   /* accel = 7 */
-  { 13, 7 },   /* accel = 8 */
-  { 11, 8 },   /* accel = 9 */
-  { 10, 9 },   /* accel = 10 */
-};
-
-
-/*-*************************************
-* Context
-***************************************/
-typedef struct {
-  const BYTE *samples;
-  size_t *offsets;
-  const size_t *samplesSizes;
-  size_t nbSamples;
-  size_t nbTrainSamples;
-  size_t nbTestSamples;
-  size_t nbDmers;
-  U32 *freqs;
-  unsigned d;
-  unsigned f;
-  FASTCOVER_accel_t accelParams;
-} FASTCOVER_ctx_t;
-
-
-/*-*************************************
-*  Helper functions
-***************************************/
-/**
- * Selects the best segment in an epoch.
- * Segments of are scored according to the function:
- *
- * Let F(d) be the frequency of all dmers with hash value d.
- * Let S_i be hash value of the dmer at position i of segment S which has length k.
- *
- *     Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1})
- *
- * Once the dmer with hash value d is in the dictionary we set F(d) = 0.
- */
-static COVER_segment_t FASTCOVER_selectSegment(const FASTCOVER_ctx_t *ctx,
-                                              U32 *freqs, U32 begin, U32 end,
-                                              ZDICT_cover_params_t parameters,
-                                              U16* segmentFreqs) {
-  /* Constants */
-  const U32 k = parameters.k;
-  const U32 d = parameters.d;
-  const U32 f = ctx->f;
-  const U32 dmersInK = k - d + 1;
-
-  /* Try each segment (activeSegment) and save the best (bestSegment) */
-  COVER_segment_t bestSegment = {0, 0, 0};
-  COVER_segment_t activeSegment;
-
-  /* Reset the activeDmers in the segment */
-  /* The activeSegment starts at the beginning of the epoch. */
-  activeSegment.begin = begin;
-  activeSegment.end = begin;
-  activeSegment.score = 0;
-
-  /* Slide the activeSegment through the whole epoch.
-   * Save the best segment in bestSegment.
-   */
-  while (activeSegment.end < end) {
-    /* Get hash value of current dmer */
-    const size_t idx = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.end, f, d);
-
-    /* Add frequency of this index to score if this is the first occurrence of index in active segment */
-    if (segmentFreqs[idx] == 0) {
-      activeSegment.score += freqs[idx];
-    }
-    /* Increment end of segment and segmentFreqs*/
-    activeSegment.end += 1;
-    segmentFreqs[idx] += 1;
-    /* If the window is now too large, drop the first position */
-    if (activeSegment.end - activeSegment.begin == dmersInK + 1) {
-      /* Get hash value of the dmer to be eliminated from active segment */
-      const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);
-      segmentFreqs[delIndex] -= 1;
-      /* Subtract frequency of this index from score if this is the last occurrence of this index in active segment */
-      if (segmentFreqs[delIndex] == 0) {
-        activeSegment.score -= freqs[delIndex];
-      }
-      /* Increment start of segment */
-      activeSegment.begin += 1;
-    }
-
-    /* If this segment is the best so far save it */
-    if (activeSegment.score > bestSegment.score) {
-      bestSegment = activeSegment;
-    }
-  }
-
-  /* Zero out rest of segmentFreqs array */
-  while (activeSegment.begin < end) {
-    const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);
-    segmentFreqs[delIndex] -= 1;
-    activeSegment.begin += 1;
-  }
-
-  {
-    /*  Zero the frequency of hash value of each dmer covered by the chosen segment. */
-    U32 pos;
-    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {
-      const size_t i = FASTCOVER_hashPtrToIndex(ctx->samples + pos, f, d);
-      freqs[i] = 0;
-    }
-  }
-
-  return bestSegment;
-}
-
-
-static int FASTCOVER_checkParameters(ZDICT_cover_params_t parameters,
-                                     size_t maxDictSize, unsigned f,
-                                     unsigned accel) {
-  /* k, d, and f are required parameters */
-  if (parameters.d == 0 || parameters.k == 0) {
-    return 0;
-  }
-  /* d has to be 6 or 8 */
-  if (parameters.d != 6 && parameters.d != 8) {
-    return 0;
-  }
-  /* k <= maxDictSize */
-  if (parameters.k > maxDictSize) {
-    return 0;
-  }
-  /* d <= k */
-  if (parameters.d > parameters.k) {
-    return 0;
-  }
-  /* 0 < f <= FASTCOVER_MAX_F*/
-  if (f > FASTCOVER_MAX_F || f == 0) {
-    return 0;
-  }
-  /* 0 < splitPoint <= 1 */
-  if (parameters.splitPoint <= 0 || parameters.splitPoint > 1) {
-    return 0;
-  }
-  /* 0 < accel <= 10 */
-  if (accel > 10 || accel == 0) {
-    return 0;
-  }
-  return 1;
-}
-
-
-/**
- * Clean up a context initialized with `FASTCOVER_ctx_init()`.
- */
-static void
-FASTCOVER_ctx_destroy(FASTCOVER_ctx_t* ctx)
-{
-    if (!ctx) return;
-
-    free(ctx->freqs);
-    ctx->freqs = NULL;
-
-    free(ctx->offsets);
-    ctx->offsets = NULL;
-}
-
-
-/**
- * Calculate for frequency of hash value of each dmer in ctx->samples
- */
-static void
-FASTCOVER_computeFrequency(U32* freqs, const FASTCOVER_ctx_t* ctx)
-{
-    const unsigned f = ctx->f;
-    const unsigned d = ctx->d;
-    const unsigned skip = ctx->accelParams.skip;
-    const unsigned readLength = MAX(d, 8);
-    size_t i;
-    assert(ctx->nbTrainSamples >= 5);
-    assert(ctx->nbTrainSamples <= ctx->nbSamples);
-    for (i = 0; i < ctx->nbTrainSamples; i++) {
-        size_t start = ctx->offsets[i];  /* start of current dmer */
-        size_t const currSampleEnd = ctx->offsets[i+1];
-        while (start + readLength <= currSampleEnd) {
-            const size_t dmerIndex = FASTCOVER_hashPtrToIndex(ctx->samples + start, f, d);
-            freqs[dmerIndex]++;
-            start = start + skip + 1;
-        }
-    }
-}
-
-
-/**
- * Prepare a context for dictionary building.
- * The context is only dependent on the parameter `d` and can be used multiple
- * times.
- * Returns 0 on success or error code on error.
- * The context must be destroyed with `FASTCOVER_ctx_destroy()`.
- */
-static size_t
-FASTCOVER_ctx_init(FASTCOVER_ctx_t* ctx,
-                   const void* samplesBuffer,
-                   const size_t* samplesSizes, unsigned nbSamples,
-                   unsigned d, double splitPoint, unsigned f,
-                   FASTCOVER_accel_t accelParams)
-{
-    const BYTE* const samples = (const BYTE*)samplesBuffer;
-    const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples);
-    /* Split samples into testing and training sets */
-    const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;
-    const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;
-    const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;
-    const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;
-
-	(void) testSamplesSize;
-
-    /* Checks */
-    if (totalSamplesSize < MAX(d, sizeof(U64)) ||
-        totalSamplesSize >= (size_t)FASTCOVER_MAX_SAMPLES_SIZE) {
-        DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n",
-                    (unsigned)(totalSamplesSize >> 20), (FASTCOVER_MAX_SAMPLES_SIZE >> 20));
-        return ERROR(srcSize_wrong);
-    }
-
-    /* Check if there are at least 5 training samples */
-    if (nbTrainSamples < 5) {
-        DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid\n", nbTrainSamples);
-        return ERROR(srcSize_wrong);
-    }
-
-    /* Check if there's testing sample */
-    if (nbTestSamples < 1) {
-        DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.\n", nbTestSamples);
-        return ERROR(srcSize_wrong);
-    }
-
-    /* Zero the context */
-    memset(ctx, 0, sizeof(*ctx));
-    DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples,
-                    (unsigned)trainingSamplesSize);
-    DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples,
-                    (unsigned)testSamplesSize);
-
-    ctx->samples = samples;
-    ctx->samplesSizes = samplesSizes;
-    ctx->nbSamples = nbSamples;
-    ctx->nbTrainSamples = nbTrainSamples;
-    ctx->nbTestSamples = nbTestSamples;
-    ctx->nbDmers = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;
-    ctx->d = d;
-    ctx->f = f;
-    ctx->accelParams = accelParams;
-
-    /* The offsets of each file */
-    ctx->offsets = (size_t*)calloc((nbSamples + 1), sizeof(size_t));
-    if (ctx->offsets == NULL) {
-        DISPLAYLEVEL(1, "Failed to allocate scratch buffers \n");
-        FASTCOVER_ctx_destroy(ctx);
-        return ERROR(memory_allocation);
-    }
-
-    /* Fill offsets from the samplesSizes */
-    {   U32 i;
-        ctx->offsets[0] = 0;
-        assert(nbSamples >= 5);
-        for (i = 1; i <= nbSamples; ++i) {
-            ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1];
-        }
-    }
-
-    /* Initialize frequency array of size 2^f */
-    ctx->freqs = (U32*)calloc(((U64)1 << f), sizeof(U32));
-    if (ctx->freqs == NULL) {
-        DISPLAYLEVEL(1, "Failed to allocate frequency table \n");
-        FASTCOVER_ctx_destroy(ctx);
-        return ERROR(memory_allocation);
-    }
-
-    DISPLAYLEVEL(2, "Computing frequencies\n");
-    FASTCOVER_computeFrequency(ctx->freqs, ctx);
-
-    return 0;
-}
-
-
-/**
- * Given the prepared context build the dictionary.
- */
-static size_t
-FASTCOVER_buildDictionary(const FASTCOVER_ctx_t* ctx,
-                          U32* freqs,
-                          void* dictBuffer, size_t dictBufferCapacity,
-                          ZDICT_cover_params_t parameters,
-                          U16* segmentFreqs)
-{
-  BYTE *const dict = (BYTE *)dictBuffer;
-  size_t tail = dictBufferCapacity;
-  /* Divide the data into epochs. We will select one segment from each epoch. */
-  const COVER_epoch_info_t epochs = COVER_computeEpochs(
-      (U32)dictBufferCapacity, (U32)ctx->nbDmers, parameters.k, 1);
-  const size_t maxZeroScoreRun = 10;
-  size_t zeroScoreRun = 0;
-  size_t epoch;
-  DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n",
-                (U32)epochs.num, (U32)epochs.size);
-  /* Loop through the epochs until there are no more segments or the dictionary
-   * is full.
-   */
-  for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) {
-    const U32 epochBegin = (U32)(epoch * epochs.size);
-    const U32 epochEnd = epochBegin + epochs.size;
-    size_t segmentSize;
-    /* Select a segment */
-    COVER_segment_t segment = FASTCOVER_selectSegment(
-        ctx, freqs, epochBegin, epochEnd, parameters, segmentFreqs);
-
-    /* If the segment covers no dmers, then we are out of content.
-     * There may be new content in other epochs, for continue for some time.
-     */
-    if (segment.score == 0) {
-      if (++zeroScoreRun >= maxZeroScoreRun) {
-          break;
-      }
-      continue;
-    }
-    zeroScoreRun = 0;
-
-    /* Trim the segment if necessary and if it is too small then we are done */
-    segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail);
-    if (segmentSize < parameters.d) {
-      break;
-    }
-
-    /* We fill the dictionary from the back to allow the best segments to be
-     * referenced with the smallest offsets.
-     */
-    tail -= segmentSize;
-    memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);
-    DISPLAYUPDATE(
-        2, "\r%u%%       ",
-        (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));
-  }
-  DISPLAYLEVEL(2, "\r%79s\r", "");
-  return tail;
-}
-
-/**
- * Parameters for FASTCOVER_tryParameters().
- */
-typedef struct FASTCOVER_tryParameters_data_s {
-    const FASTCOVER_ctx_t* ctx;
-    COVER_best_t* best;
-    size_t dictBufferCapacity;
-    ZDICT_cover_params_t parameters;
-} FASTCOVER_tryParameters_data_t;
-
-
-/**
- * Tries a set of parameters and updates the COVER_best_t with the results.
- * This function is thread safe if zstd is compiled with multithreaded support.
- * It takes its parameters as an *OWNING* opaque pointer to support threading.
- */
-static void FASTCOVER_tryParameters(void* opaque)
-{
-  /* Save parameters as local variables */
-  FASTCOVER_tryParameters_data_t *const data = (FASTCOVER_tryParameters_data_t*)opaque;
-  const FASTCOVER_ctx_t *const ctx = data->ctx;
-  const ZDICT_cover_params_t parameters = data->parameters;
-  size_t dictBufferCapacity = data->dictBufferCapacity;
-  size_t totalCompressedSize = ERROR(GENERIC);
-  /* Initialize array to keep track of frequency of dmer within activeSegment */
-  U16* segmentFreqs = (U16*)calloc(((U64)1 << ctx->f), sizeof(U16));
-  /* Allocate space for hash table, dict, and freqs */
-  BYTE *const dict = (BYTE*)malloc(dictBufferCapacity);
-  COVER_dictSelection_t selection = COVER_dictSelectionError(ERROR(GENERIC));
-  U32* freqs = (U32*) malloc(((U64)1 << ctx->f) * sizeof(U32));
-  if (!segmentFreqs || !dict || !freqs) {
-    DISPLAYLEVEL(1, "Failed to allocate buffers: out of memory\n");
-    goto _cleanup;
-  }
-  /* Copy the frequencies because we need to modify them */
-  memcpy(freqs, ctx->freqs, ((U64)1 << ctx->f) * sizeof(U32));
-  /* Build the dictionary */
-  { const size_t tail = FASTCOVER_buildDictionary(ctx, freqs, dict, dictBufferCapacity,
-                                                    parameters, segmentFreqs);
-
-    const unsigned nbFinalizeSamples = (unsigned)(ctx->nbTrainSamples * ctx->accelParams.finalize / 100);
-    selection = COVER_selectDict(dict + tail, dictBufferCapacity, dictBufferCapacity - tail,
-         ctx->samples, ctx->samplesSizes, nbFinalizeSamples, ctx->nbTrainSamples, ctx->nbSamples, parameters, ctx->offsets,
-         totalCompressedSize);
-
-    if (COVER_dictSelectionIsError(selection)) {
-      DISPLAYLEVEL(1, "Failed to select dictionary\n");
-      goto _cleanup;
-    }
-  }
-_cleanup:
-  free(dict);
-  COVER_best_finish(data->best, parameters, selection);
-  free(data);
-  free(segmentFreqs);
-  COVER_dictSelectionFree(selection);
-  free(freqs);
-}
-
-
-static void
-FASTCOVER_convertToCoverParams(ZDICT_fastCover_params_t fastCoverParams,
-                               ZDICT_cover_params_t* coverParams)
-{
-    coverParams->k = fastCoverParams.k;
-    coverParams->d = fastCoverParams.d;
-    coverParams->steps = fastCoverParams.steps;
-    coverParams->nbThreads = fastCoverParams.nbThreads;
-    coverParams->splitPoint = fastCoverParams.splitPoint;
-    coverParams->zParams = fastCoverParams.zParams;
-    coverParams->shrinkDict = fastCoverParams.shrinkDict;
-}
-
-
-static void
-FASTCOVER_convertToFastCoverParams(ZDICT_cover_params_t coverParams,
-                                   ZDICT_fastCover_params_t* fastCoverParams,
-                                   unsigned f, unsigned accel)
-{
-    fastCoverParams->k = coverParams.k;
-    fastCoverParams->d = coverParams.d;
-    fastCoverParams->steps = coverParams.steps;
-    fastCoverParams->nbThreads = coverParams.nbThreads;
-    fastCoverParams->splitPoint = coverParams.splitPoint;
-    fastCoverParams->f = f;
-    fastCoverParams->accel = accel;
-    fastCoverParams->zParams = coverParams.zParams;
-    fastCoverParams->shrinkDict = coverParams.shrinkDict;
-}
-
-
-ZDICTLIB_STATIC_API size_t
-ZDICT_trainFromBuffer_fastCover(void* dictBuffer, size_t dictBufferCapacity,
-                                const void* samplesBuffer,
-                                const size_t* samplesSizes, unsigned nbSamples,
-                                ZDICT_fastCover_params_t parameters)
-{
-    BYTE* const dict = (BYTE*)dictBuffer;
-    FASTCOVER_ctx_t ctx;
-    ZDICT_cover_params_t coverParams;
-    FASTCOVER_accel_t accelParams;
-    /* Initialize global data */
-    g_displayLevel = (int)parameters.zParams.notificationLevel;
-    /* Assign splitPoint and f if not provided */
-    parameters.splitPoint = 1.0;
-    parameters.f = parameters.f == 0 ? DEFAULT_F : parameters.f;
-    parameters.accel = parameters.accel == 0 ? DEFAULT_ACCEL : parameters.accel;
-    /* Convert to cover parameter */
-    memset(&coverParams, 0 , sizeof(coverParams));
-    FASTCOVER_convertToCoverParams(parameters, &coverParams);
-    /* Checks */
-    if (!FASTCOVER_checkParameters(coverParams, dictBufferCapacity, parameters.f,
-                                   parameters.accel)) {
-      DISPLAYLEVEL(1, "FASTCOVER parameters incorrect\n");
-      return ERROR(parameter_outOfBound);
-    }
-    if (nbSamples == 0) {
-      DISPLAYLEVEL(1, "FASTCOVER must have at least one input file\n");
-      return ERROR(srcSize_wrong);
-    }
-    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
-      DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n",
-                   ZDICT_DICTSIZE_MIN);
-      return ERROR(dstSize_tooSmall);
-    }
-    /* Assign corresponding FASTCOVER_accel_t to accelParams*/
-    accelParams = FASTCOVER_defaultAccelParameters[parameters.accel];
-    /* Initialize context */
-    {
-      size_t const initVal = FASTCOVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples,
-                            coverParams.d, parameters.splitPoint, parameters.f,
-                            accelParams);
-      if (ZSTD_isError(initVal)) {
-        DISPLAYLEVEL(1, "Failed to initialize context\n");
-        return initVal;
-      }
-    }
-    COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, g_displayLevel);
-    /* Build the dictionary */
-    DISPLAYLEVEL(2, "Building dictionary\n");
-    {
-      /* Initialize array to keep track of frequency of dmer within activeSegment */
-      U16* segmentFreqs = (U16 *)calloc(((U64)1 << parameters.f), sizeof(U16));
-      const size_t tail = FASTCOVER_buildDictionary(&ctx, ctx.freqs, dictBuffer,
-                                                dictBufferCapacity, coverParams, segmentFreqs);
-      const unsigned nbFinalizeSamples = (unsigned)(ctx.nbTrainSamples * ctx.accelParams.finalize / 100);
-      const size_t dictionarySize = ZDICT_finalizeDictionary(
-          dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,
-          samplesBuffer, samplesSizes, nbFinalizeSamples, coverParams.zParams);
-      if (!ZSTD_isError(dictionarySize)) {
-          DISPLAYLEVEL(2, "Constructed dictionary of size %u\n",
-                      (unsigned)dictionarySize);
-      }
-      FASTCOVER_ctx_destroy(&ctx);
-      free(segmentFreqs);
-      return dictionarySize;
-    }
-}
-
-
-ZDICTLIB_STATIC_API size_t
-ZDICT_optimizeTrainFromBuffer_fastCover(
-                    void* dictBuffer, size_t dictBufferCapacity,
-                    const void* samplesBuffer,
-                    const size_t* samplesSizes, unsigned nbSamples,
-                    ZDICT_fastCover_params_t* parameters)
-{
-    ZDICT_cover_params_t coverParams;
-    FASTCOVER_accel_t accelParams;
-    /* constants */
-    const unsigned nbThreads = parameters->nbThreads;
-    const double splitPoint =
-        parameters->splitPoint <= 0.0 ? FASTCOVER_DEFAULT_SPLITPOINT : parameters->splitPoint;
-    const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d;
-    const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d;
-    const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k;
-    const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k;
-    const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps;
-    const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1);
-    const unsigned kIterations =
-        (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize);
-    const unsigned f = parameters->f == 0 ? DEFAULT_F : parameters->f;
-    const unsigned accel = parameters->accel == 0 ? DEFAULT_ACCEL : parameters->accel;
-    const unsigned shrinkDict = 0;
-    /* Local variables */
-    const int displayLevel = (int)parameters->zParams.notificationLevel;
-    unsigned iteration = 1;
-    unsigned d;
-    unsigned k;
-    COVER_best_t best;
-    POOL_ctx *pool = NULL;
-    int warned = 0;
-
-	(void) kIterations;
-	(void) iteration;
-
-    /* Checks */
-    if (splitPoint <= 0 || splitPoint > 1) {
-      LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect splitPoint\n");
-      return ERROR(parameter_outOfBound);
-    }
-    if (accel == 0 || accel > FASTCOVER_MAX_ACCEL) {
-      LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect accel\n");
-      return ERROR(parameter_outOfBound);
-    }
-    if (kMinK < kMaxD || kMaxK < kMinK) {
-      LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect k\n");
-      return ERROR(parameter_outOfBound);
-    }
-    if (nbSamples == 0) {
-      LOCALDISPLAYLEVEL(displayLevel, 1, "FASTCOVER must have at least one input file\n");
-      return ERROR(srcSize_wrong);
-    }
-    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
-      LOCALDISPLAYLEVEL(displayLevel, 1, "dictBufferCapacity must be at least %u\n",
-                   ZDICT_DICTSIZE_MIN);
-      return ERROR(dstSize_tooSmall);
-    }
-    if (nbThreads > 1) {
-      pool = POOL_create(nbThreads, 1);
-      if (!pool) {
-        return ERROR(memory_allocation);
-      }
-    }
-    /* Initialization */
-    COVER_best_init(&best);
-    memset(&coverParams, 0 , sizeof(coverParams));
-    FASTCOVER_convertToCoverParams(*parameters, &coverParams);
-    accelParams = FASTCOVER_defaultAccelParameters[accel];
-    /* Turn down global display level to clean up display at level 2 and below */
-    g_displayLevel = displayLevel == 0 ? 0 : displayLevel - 1;
-    /* Loop through d first because each new value needs a new context */
-    LOCALDISPLAYLEVEL(displayLevel, 2, "Trying %u different sets of parameters\n",
-                      kIterations);
-    for (d = kMinD; d <= kMaxD; d += 2) {
-      /* Initialize the context for this value of d */
-      FASTCOVER_ctx_t ctx;
-      LOCALDISPLAYLEVEL(displayLevel, 3, "d=%u\n", d);
-      {
-        size_t const initVal = FASTCOVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d, splitPoint, f, accelParams);
-        if (ZSTD_isError(initVal)) {
-          LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to initialize context\n");
-          COVER_best_destroy(&best);
-          POOL_free(pool);
-          return initVal;
-        }
-      }
-      if (!warned) {
-        COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, displayLevel);
-        warned = 1;
-      }
-      /* Loop through k reusing the same context */
-      for (k = kMinK; k <= kMaxK; k += kStepSize) {
-        /* Prepare the arguments */
-        FASTCOVER_tryParameters_data_t *data = (FASTCOVER_tryParameters_data_t *)malloc(
-            sizeof(FASTCOVER_tryParameters_data_t));
-        LOCALDISPLAYLEVEL(displayLevel, 3, "k=%u\n", k);
-        if (!data) {
-          LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to allocate parameters\n");
-          COVER_best_destroy(&best);
-          FASTCOVER_ctx_destroy(&ctx);
-          POOL_free(pool);
-          return ERROR(memory_allocation);
-        }
-        data->ctx = &ctx;
-        data->best = &best;
-        data->dictBufferCapacity = dictBufferCapacity;
-        data->parameters = coverParams;
-        data->parameters.k = k;
-        data->parameters.d = d;
-        data->parameters.splitPoint = splitPoint;
-        data->parameters.steps = kSteps;
-        data->parameters.shrinkDict = shrinkDict;
-        data->parameters.zParams.notificationLevel = (unsigned)g_displayLevel;
-        /* Check the parameters */
-        if (!FASTCOVER_checkParameters(data->parameters, dictBufferCapacity,
-                                       data->ctx->f, accel)) {
-          DISPLAYLEVEL(1, "FASTCOVER parameters incorrect\n");
-          free(data);
-          continue;
-        }
-        /* Call the function and pass ownership of data to it */
-        COVER_best_start(&best);
-        if (pool) {
-          POOL_add(pool, &FASTCOVER_tryParameters, data);
-        } else {
-          FASTCOVER_tryParameters(data);
-        }
-        /* Print status */
-        LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%%       ",
-                           (unsigned)((iteration * 100) / kIterations));
-        ++iteration;
-      }
-      COVER_best_wait(&best);
-      FASTCOVER_ctx_destroy(&ctx);
-    }
-    LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", "");
-    /* Fill the output buffer and parameters with output of the best parameters */
-    {
-      const size_t dictSize = best.dictSize;
-      if (ZSTD_isError(best.compressedSize)) {
-        const size_t compressedSize = best.compressedSize;
-        COVER_best_destroy(&best);
-        POOL_free(pool);
-        return compressedSize;
-      }
-      FASTCOVER_convertToFastCoverParams(best.parameters, parameters, f, accel);
-      memcpy(dictBuffer, best.dict, dictSize);
-      COVER_best_destroy(&best);
-      POOL_free(pool);
-      return dictSize;
-    }
-
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/dict/zdict.cpp b/src/duckdb/third_party/zstd/dict/zdict.cpp
deleted file mode 100644
index cfa829578..000000000
--- a/src/duckdb/third_party/zstd/dict/zdict.cpp
+++ /dev/null
@@ -1,1134 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-/*-**************************************
-*  Tuning parameters
-****************************************/
-#define MINRATIO 4   /* minimum nb of apparition to be selected in dictionary */
-#define ZDICT_MAX_SAMPLES_SIZE (2000U << 20)
-#define ZDICT_MIN_SAMPLES_SIZE (ZDICT_CONTENTSIZE_MIN * MINRATIO)
-
-
-/*-**************************************
-*  Compiler Options
-****************************************/
-/* Unix Large Files support (>4GB) */
-#define _FILE_OFFSET_BITS 64
-#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
-#  ifndef _LARGEFILE_SOURCE
-#  define _LARGEFILE_SOURCE
-#  endif
-#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
-#  ifndef _LARGEFILE64_SOURCE
-#  define _LARGEFILE64_SOURCE
-#  endif
-#endif
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stdlib.h>        /* malloc, free */
-#include <string.h>        /* memset */
-#include <stdio.h>         /* fprintf, fopen, ftello64 */
-#include <time.h>          /* clock */
-
-#ifndef ZDICT_STATIC_LINKING_ONLY
-#  define ZDICT_STATIC_LINKING_ONLY
-#endif
-
-#include "zstd/common/mem.h"           /* read */
-#include "zstd/common/fse.h"           /* FSE_normalizeCount, FSE_writeNCount */
-#include "zstd/common/huf.h"           /* HUF_buildCTable, HUF_writeCTable */
-#include "zstd/common/zstd_internal.h" /* includes zstd.h */
-#include "zstd/common/xxhash.hpp"      /* XXH64 */
-#include "zstd/compress/zstd_compress_internal.h" /* ZSTD_loadCEntropy() */
-#include "zdict.h"
-#include "zstd/dict/divsufsort.h"
-#include "zstd/common/bits.h"          /* ZSTD_NbCommonBytes */
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Constants
-***************************************/
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define DICTLISTSIZE_DEFAULT 10000
-
-#define NOISELENGTH 32
-
-static const U32 g_selectivity_default = 9;
-
-
-/*-*************************************
-*  Console display
-***************************************/
-#undef  DISPLAY
-// CRAN does not allow stderr references
-#define DISPLAY(...)         do { } while (0)
-#undef  DISPLAYLEVEL
-#define DISPLAYLEVEL(l, ...) do { if (notificationLevel>=l) { DISPLAY(__VA_ARGS__); } } while (0)    /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
-
-static clock_t ZDICT_clockSpan(clock_t nPrevious) { return clock() - nPrevious; }
-
-static void ZDICT_printHex(const void* ptr, size_t length)
-{
-    const BYTE* const b = (const BYTE*)ptr;
-    size_t u;
-    for (u=0; u<length; u++) {
-        BYTE c = b[u];
-        if (c<32 || c>126) c = '.';   /* non-printable char */
-        DISPLAY("%c", c);
-    }
-}
-
-
-/*-********************************************************
-*  Helper functions
-**********************************************************/
-unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); }
-
-const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
-unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize)
-{
-    if (dictSize < 8) return 0;
-    if (MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return 0;
-    return MEM_readLE32((const char*)dictBuffer + 4);
-}
-
-size_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize)
-{
-    size_t headerSize;
-    if (dictSize <= 8 || MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return ERROR(dictionary_corrupted);
-
-    {   ZSTD_compressedBlockState_t* bs = (ZSTD_compressedBlockState_t*)malloc(sizeof(ZSTD_compressedBlockState_t));
-        U32* wksp = (U32*)malloc(HUF_WORKSPACE_SIZE);
-        if (!bs || !wksp) {
-            headerSize = ERROR(memory_allocation);
-        } else {
-            ZSTD_reset_compressedBlockState(bs);
-            headerSize = ZSTD_loadCEntropy(bs, wksp, dictBuffer, dictSize);
-        }
-
-        free(bs);
-        free(wksp);
-    }
-
-    return headerSize;
-}
-
-/*-********************************************************
-*  Dictionary training functions
-**********************************************************/
-/*! ZDICT_count() :
-    Count the nb of common bytes between 2 pointers.
-    Note : this function presumes end of buffer followed by noisy guard band.
-*/
-static size_t ZDICT_count(const void* pIn, const void* pMatch)
-{
-    const char* const pStart = (const char*)pIn;
-    for (;;) {
-        size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
-        if (!diff) {
-            pIn = (const char*)pIn+sizeof(size_t);
-            pMatch = (const char*)pMatch+sizeof(size_t);
-            continue;
-        }
-        pIn = (const char*)pIn+ZSTD_NbCommonBytes(diff);
-        return (size_t)((const char*)pIn - pStart);
-    }
-}
-
-
-typedef struct {
-    U32 pos;
-    U32 length;
-    U32 savings;
-} dictItem;
-
-static void ZDICT_initDictItem(dictItem* d)
-{
-    d->pos = 1;
-    d->length = 0;
-    d->savings = (U32)(-1);
-}
-
-
-#define LLIMIT 64          /* heuristic determined experimentally */
-#define MINMATCHLENGTH 7   /* heuristic determined experimentally */
-static dictItem ZDICT_analyzePos(
-                       BYTE* doneMarks,
-                       const int* suffix, U32 start,
-                       const void* buffer, U32 minRatio, U32 notificationLevel)
-{
-    U32 lengthList[LLIMIT] = {0};
-    U32 cumulLength[LLIMIT] = {0};
-    U32 savings[LLIMIT] = {0};
-    const BYTE* b = (const BYTE*)buffer;
-    size_t maxLength = LLIMIT;
-    size_t pos = (size_t)suffix[start];
-    U32 end = start;
-    dictItem solution;
-
-    /* init */
-    memset(&solution, 0, sizeof(solution));
-    doneMarks[pos] = 1;
-
-    /* trivial repetition cases */
-    if ( (MEM_read16(b+pos+0) == MEM_read16(b+pos+2))
-       ||(MEM_read16(b+pos+1) == MEM_read16(b+pos+3))
-       ||(MEM_read16(b+pos+2) == MEM_read16(b+pos+4)) ) {
-        /* skip and mark segment */
-        U16 const pattern16 = MEM_read16(b+pos+4);
-        U32 u, patternEnd = 6;
-        while (MEM_read16(b+pos+patternEnd) == pattern16) patternEnd+=2 ;
-        if (b[pos+patternEnd] == b[pos+patternEnd-1]) patternEnd++;
-        for (u=1; u<patternEnd; u++)
-            doneMarks[pos+u] = 1;
-        return solution;
-    }
-
-    /* look forward */
-    {   size_t length;
-        do {
-            end++;
-            length = ZDICT_count(b + pos, b + suffix[end]);
-        } while (length >= MINMATCHLENGTH);
-    }
-
-    /* look backward */
-    {   size_t length;
-        do {
-            length = ZDICT_count(b + pos, b + *(suffix+start-1));
-            if (length >=MINMATCHLENGTH) start--;
-        } while(length >= MINMATCHLENGTH);
-    }
-
-    /* exit if not found a minimum nb of repetitions */
-    if (end-start < minRatio) {
-        U32 idx;
-        for(idx=start; idx<end; idx++)
-            doneMarks[suffix[idx]] = 1;
-        return solution;
-    }
-
-    {   int i;
-        U32 mml;
-        U32 refinedStart = start;
-        U32 refinedEnd = end;
-
-        DISPLAYLEVEL(4, "\n");
-        DISPLAYLEVEL(4, "found %3u matches of length >= %i at pos %7u  ", (unsigned)(end-start), MINMATCHLENGTH, (unsigned)pos);
-        DISPLAYLEVEL(4, "\n");
-
-        for (mml = MINMATCHLENGTH ; ; mml++) {
-            BYTE currentChar = 0;
-            U32 currentCount = 0;
-            U32 currentID = refinedStart;
-            U32 id;
-            U32 selectedCount = 0;
-            U32 selectedID = currentID;
-            for (id =refinedStart; id < refinedEnd; id++) {
-                if (b[suffix[id] + mml] != currentChar) {
-                    if (currentCount > selectedCount) {
-                        selectedCount = currentCount;
-                        selectedID = currentID;
-                    }
-                    currentID = id;
-                    currentChar = b[ suffix[id] + mml];
-                    currentCount = 0;
-                }
-                currentCount ++;
-            }
-            if (currentCount > selectedCount) {  /* for last */
-                selectedCount = currentCount;
-                selectedID = currentID;
-            }
-
-            if (selectedCount < minRatio)
-                break;
-            refinedStart = selectedID;
-            refinedEnd = refinedStart + selectedCount;
-        }
-
-        /* evaluate gain based on new dict */
-        start = refinedStart;
-        pos = suffix[refinedStart];
-        end = start;
-        memset(lengthList, 0, sizeof(lengthList));
-
-        /* look forward */
-        {   size_t length;
-            do {
-                end++;
-                length = ZDICT_count(b + pos, b + suffix[end]);
-                if (length >= LLIMIT) length = LLIMIT-1;
-                lengthList[length]++;
-            } while (length >=MINMATCHLENGTH);
-        }
-
-        /* look backward */
-        {   size_t length = MINMATCHLENGTH;
-            while ((length >= MINMATCHLENGTH) & (start > 0)) {
-                length = ZDICT_count(b + pos, b + suffix[start - 1]);
-                if (length >= LLIMIT) length = LLIMIT - 1;
-                lengthList[length]++;
-                if (length >= MINMATCHLENGTH) start--;
-            }
-        }
-
-        /* largest useful length */
-        memset(cumulLength, 0, sizeof(cumulLength));
-        cumulLength[maxLength-1] = lengthList[maxLength-1];
-        for (i=(int)(maxLength-2); i>=0; i--)
-            cumulLength[i] = cumulLength[i+1] + lengthList[i];
-
-        for (i=LLIMIT-1; i>=MINMATCHLENGTH; i--) if (cumulLength[i]>=minRatio) break;
-        maxLength = i;
-
-        /* reduce maxLength in case of final into repetitive data */
-        {   U32 l = (U32)maxLength;
-            BYTE const c = b[pos + maxLength-1];
-            while (b[pos+l-2]==c) l--;
-            maxLength = l;
-        }
-        if (maxLength < MINMATCHLENGTH) return solution;   /* skip : no long-enough solution */
-
-        /* calculate savings */
-        savings[5] = 0;
-        for (i=MINMATCHLENGTH; i<=(int)maxLength; i++)
-            savings[i] = savings[i-1] + (lengthList[i] * (i-3));
-
-        DISPLAYLEVEL(4, "Selected dict at position %u, of length %u : saves %u (ratio: %.2f)  \n",
-                     (unsigned)pos, (unsigned)maxLength, (unsigned)savings[maxLength], (double)savings[maxLength] / (double)maxLength);
-
-        solution.pos = (U32)pos;
-        solution.length = (U32)maxLength;
-        solution.savings = savings[maxLength];
-
-        /* mark positions done */
-        {   U32 id;
-            for (id=start; id<end; id++) {
-                U32 p, pEnd, length;
-                U32 const testedPos = (U32)suffix[id];
-                if (testedPos == pos)
-                    length = solution.length;
-                else {
-                    length = (U32)ZDICT_count(b+pos, b+testedPos);
-                    if (length > solution.length) length = solution.length;
-                }
-                pEnd = (U32)(testedPos + length);
-                for (p=testedPos; p<pEnd; p++)
-                    doneMarks[p] = 1;
-    }   }   }
-
-    return solution;
-}
-
-
-static int isIncluded(const void* in, const void* container, size_t length)
-{
-    const char* const ip = (const char*) in;
-    const char* const into = (const char*) container;
-    size_t u;
-
-    for (u=0; u<length; u++) {  /* works because end of buffer is a noisy guard band */
-        if (ip[u] != into[u]) break;
-    }
-
-    return u==length;
-}
-
-/*! ZDICT_tryMerge() :
-    check if dictItem can be merged, do it if possible
-    @return : id of destination elt, 0 if not merged
-*/
-static U32 ZDICT_tryMerge(dictItem* table, dictItem elt, U32 eltNbToSkip, const void* buffer)
-{
-    const U32 tableSize = table->pos;
-    const U32 eltEnd = elt.pos + elt.length;
-    const char* const buf = (const char*) buffer;
-
-    /* tail overlap */
-    U32 u; for (u=1; u<tableSize; u++) {
-        if (u==eltNbToSkip) continue;
-        if ((table[u].pos > elt.pos) && (table[u].pos <= eltEnd)) {  /* overlap, existing > new */
-            /* append */
-            U32 const addedLength = table[u].pos - elt.pos;
-            table[u].length += addedLength;
-            table[u].pos = elt.pos;
-            table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
-            table[u].savings += elt.length / 8;    /* rough approx bonus */
-            elt = table[u];
-            /* sort : improve rank */
-            while ((u>1) && (table[u-1].savings < elt.savings))
-                table[u] = table[u-1], u--;
-            table[u] = elt;
-            return u;
-    }   }
-
-    /* front overlap */
-    for (u=1; u<tableSize; u++) {
-        if (u==eltNbToSkip) continue;
-
-        if ((table[u].pos + table[u].length >= elt.pos) && (table[u].pos < elt.pos)) {  /* overlap, existing < new */
-            /* append */
-            int const addedLength = (int)eltEnd - (int)(table[u].pos + table[u].length);
-            table[u].savings += elt.length / 8;    /* rough approx bonus */
-            if (addedLength > 0) {   /* otherwise, elt fully included into existing */
-                table[u].length += addedLength;
-                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
-            }
-            /* sort : improve rank */
-            elt = table[u];
-            while ((u>1) && (table[u-1].savings < elt.savings))
-                table[u] = table[u-1], u--;
-            table[u] = elt;
-            return u;
-        }
-
-        if (MEM_read64(buf + table[u].pos) == MEM_read64(buf + elt.pos + 1)) {
-            if (isIncluded(buf + table[u].pos, buf + elt.pos + 1, table[u].length)) {
-                size_t const addedLength = MAX( (int)elt.length - (int)table[u].length , 1 );
-                table[u].pos = elt.pos;
-                table[u].savings += (U32)(elt.savings * addedLength / elt.length);
-                table[u].length = MIN(elt.length, table[u].length + 1);
-                return u;
-            }
-        }
-    }
-
-    return 0;
-}
-
-
-static void ZDICT_removeDictItem(dictItem* table, U32 id)
-{
-    /* convention : table[0].pos stores nb of elts */
-    U32 const max = table[0].pos;
-    U32 u;
-    if (!id) return;   /* protection, should never happen */
-    for (u=id; u<max-1; u++)
-        table[u] = table[u+1];
-    table->pos--;
-}
-
-
-static void ZDICT_insertDictItem(dictItem* table, U32 maxSize, dictItem elt, const void* buffer)
-{
-    /* merge if possible */
-    U32 mergeId = ZDICT_tryMerge(table, elt, 0, buffer);
-    if (mergeId) {
-        U32 newMerge = 1;
-        while (newMerge) {
-            newMerge = ZDICT_tryMerge(table, table[mergeId], mergeId, buffer);
-            if (newMerge) ZDICT_removeDictItem(table, mergeId);
-            mergeId = newMerge;
-        }
-        return;
-    }
-
-    /* insert */
-    {   U32 current;
-        U32 nextElt = table->pos;
-        if (nextElt >= maxSize) nextElt = maxSize-1;
-        current = nextElt-1;
-        while (table[current].savings < elt.savings) {
-            table[current+1] = table[current];
-            current--;
-        }
-        table[current+1] = elt;
-        table->pos = nextElt+1;
-    }
-}
-
-
-static U32 ZDICT_dictSize(const dictItem* dictList)
-{
-    U32 u, dictSize = 0;
-    for (u=1; u<dictList[0].pos; u++)
-        dictSize += dictList[u].length;
-    return dictSize;
-}
-
-
-static size_t ZDICT_trainBuffer_legacy(dictItem* dictList, U32 dictListSize,
-                            const void* const buffer, size_t bufferSize,   /* buffer must end with noisy guard band */
-                            const size_t* fileSizes, unsigned nbFiles,
-                            unsigned minRatio, U32 notificationLevel)
-{
-    int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0));
-    int* const suffix = suffix0+1;
-    U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix));
-    BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks));   /* +16 for overflow security */
-    U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos));
-    size_t result = 0;
-    clock_t displayClock = 0;
-    clock_t const refreshRate = CLOCKS_PER_SEC * 3 / 10;
-
-#   undef  DISPLAYUPDATE
-// CRAN does not allow stderr references
-#   define DISPLAYUPDATE(l, ...)                                   \
-        do {                                                       \
-        } while (0)
-
-    /* init */
-    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
-    if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) {
-        result = ERROR(memory_allocation);
-        goto _cleanup;
-    }
-    if (minRatio < MINRATIO) minRatio = MINRATIO;
-    memset(doneMarks, 0, bufferSize+16);
-
-    /* limit sample set size (divsufsort limitation)*/
-    if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, "sample set too large : reduced to %u MB ...\n", (unsigned)(ZDICT_MAX_SAMPLES_SIZE>>20));
-    while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles];
-
-    /* sort */
-    DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (unsigned)(bufferSize>>20));
-    {   int const divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0);
-        if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; }
-    }
-    suffix[bufferSize] = (int)bufferSize;   /* leads into noise */
-    suffix0[0] = (int)bufferSize;           /* leads into noise */
-    /* build reverse suffix sort */
-    {   size_t pos;
-        for (pos=0; pos < bufferSize; pos++)
-            reverseSuffix[suffix[pos]] = (U32)pos;
-        /* note filePos tracks borders between samples.
-           It's not used at this stage, but planned to become useful in a later update */
-        filePos[0] = 0;
-        for (pos=1; pos<nbFiles; pos++)
-            filePos[pos] = (U32)(filePos[pos-1] + fileSizes[pos-1]);
-    }
-
-    DISPLAYLEVEL(2, "finding patterns ... \n");
-    DISPLAYLEVEL(3, "minimum ratio : %u \n", minRatio);
-
-    {   U32 cursor; for (cursor=0; cursor < bufferSize; ) {
-            dictItem solution;
-            if (doneMarks[cursor]) { cursor++; continue; }
-            solution = ZDICT_analyzePos(doneMarks, suffix, reverseSuffix[cursor], buffer, minRatio, notificationLevel);
-            if (solution.length==0) { cursor++; continue; }
-            ZDICT_insertDictItem(dictList, dictListSize, solution, buffer);
-            cursor += solution.length;
-            DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / (double)bufferSize * 100.0);
-    }   }
-
-_cleanup:
-    free(suffix0);
-    free(reverseSuffix);
-    free(doneMarks);
-    free(filePos);
-    return result;
-}
-
-
-static void ZDICT_fillNoise(void* buffer, size_t length)
-{
-    unsigned const prime1 = 2654435761U;
-    unsigned const prime2 = 2246822519U;
-    unsigned acc = prime1;
-    size_t p=0;
-    for (p=0; p<length; p++) {
-        acc *= prime2;
-        ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21);
-    }
-}
-
-
-typedef struct
-{
-    ZSTD_CDict* dict;    /* dictionary */
-    ZSTD_CCtx* zc;     /* working context */
-    void* workPlace;   /* must be ZSTD_BLOCKSIZE_MAX allocated */
-} EStats_ress_t;
-
-#define MAXREPOFFSET 1024
-
-static void ZDICT_countEStats(EStats_ress_t esr, const ZSTD_parameters* params,
-                              unsigned* countLit, unsigned* offsetcodeCount, unsigned* matchlengthCount, unsigned* litlengthCount, U32* repOffsets,
-                              const void* src, size_t srcSize,
-                              U32 notificationLevel)
-{
-    size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params->cParams.windowLog);
-    size_t cSize;
-
-    if (srcSize > blockSizeMax) srcSize = blockSizeMax;   /* protection vs large samples */
-    {   size_t const errorCode = ZSTD_compressBegin_usingCDict_deprecated(esr.zc, esr.dict);
-        if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_compressBegin_usingCDict failed \n"); return; }
-
-    }
-    cSize = ZSTD_compressBlock_deprecated(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
-    if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (unsigned)srcSize); return; }
-
-    if (cSize) {  /* if == 0; block is not compressible */
-        const seqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc);
-
-        /* literals stats */
-        {   const BYTE* bytePtr;
-            for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++)
-                countLit[*bytePtr]++;
-        }
-
-        /* seqStats */
-        {   U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-            ZSTD_seqToCodes(seqStorePtr);
-
-            {   const BYTE* codePtr = seqStorePtr->ofCode;
-                U32 u;
-                for (u=0; u<nbSeq; u++) offsetcodeCount[codePtr[u]]++;
-            }
-
-            {   const BYTE* codePtr = seqStorePtr->mlCode;
-                U32 u;
-                for (u=0; u<nbSeq; u++) matchlengthCount[codePtr[u]]++;
-            }
-
-            {   const BYTE* codePtr = seqStorePtr->llCode;
-                U32 u;
-                for (u=0; u<nbSeq; u++) litlengthCount[codePtr[u]]++;
-            }
-
-            if (nbSeq >= 2) { /* rep offsets */
-                const seqDef* const seq = seqStorePtr->sequencesStart;
-                U32 offset1 = seq[0].offBase - ZSTD_REP_NUM;
-                U32 offset2 = seq[1].offBase - ZSTD_REP_NUM;
-                if (offset1 >= MAXREPOFFSET) offset1 = 0;
-                if (offset2 >= MAXREPOFFSET) offset2 = 0;
-                repOffsets[offset1] += 3;
-                repOffsets[offset2] += 1;
-    }   }   }
-}
-
-static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles)
-{
-    size_t total=0;
-    unsigned u;
-    for (u=0; u<nbFiles; u++) total += fileSizes[u];
-    return total;
-}
-
-typedef struct { U32 offset; U32 count; } offsetCount_t;
-
-static void ZDICT_insertSortCount(offsetCount_t table[ZSTD_REP_NUM+1], U32 val, U32 count)
-{
-    U32 u;
-    table[ZSTD_REP_NUM].offset = val;
-    table[ZSTD_REP_NUM].count = count;
-    for (u=ZSTD_REP_NUM; u>0; u--) {
-        offsetCount_t tmp;
-        if (table[u-1].count >= table[u].count) break;
-        tmp = table[u-1];
-        table[u-1] = table[u];
-        table[u] = tmp;
-    }
-}
-
-/* ZDICT_flatLit() :
- * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals.
- * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode.
- */
-static void ZDICT_flatLit(unsigned* countLit)
-{
-    int u;
-    for (u=1; u<256; u++) countLit[u] = 2;
-    countLit[0]   = 4;
-    countLit[253] = 1;
-    countLit[254] = 1;
-}
-
-#define OFFCODE_MAX 30  /* only applicable to first block */
-static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
-                                   int compressionLevel,
-                             const void*  srcBuffer, const size_t* fileSizes, unsigned nbFiles,
-                             const void* dictBuffer, size_t  dictBufferSize,
-                                   unsigned notificationLevel)
-{
-    unsigned countLit[256];
-    HUF_CREATE_STATIC_CTABLE(hufTable, 255);
-    unsigned offcodeCount[OFFCODE_MAX+1];
-    short offcodeNCount[OFFCODE_MAX+1];
-    U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB));
-    unsigned matchLengthCount[MaxML+1];
-    short matchLengthNCount[MaxML+1];
-    unsigned litLengthCount[MaxLL+1];
-    short litLengthNCount[MaxLL+1];
-    U32 repOffset[MAXREPOFFSET];
-    offsetCount_t bestRepOffset[ZSTD_REP_NUM+1];
-    EStats_ress_t esr = { NULL, NULL, NULL };
-    ZSTD_parameters params;
-    U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total;
-    size_t pos = 0, errorCode;
-    size_t eSize = 0;
-    size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles);
-    size_t const averageSampleSize = totalSrcSize / (nbFiles + !nbFiles);
-    BYTE* dstPtr = (BYTE*)dstBuffer;
-    U32 wksp[HUF_CTABLE_WORKSPACE_SIZE_U32];
-
-    /* init */
-    DEBUGLOG(4, "ZDICT_analyzeEntropy");
-    if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionaryCreation_failed); goto _cleanup; }   /* too large dictionary */
-    for (u=0; u<256; u++) countLit[u] = 1;   /* any character must be described */
-    for (u=0; u<=offcodeMax; u++) offcodeCount[u] = 1;
-    for (u=0; u<=MaxML; u++) matchLengthCount[u] = 1;
-    for (u=0; u<=MaxLL; u++) litLengthCount[u] = 1;
-    memset(repOffset, 0, sizeof(repOffset));
-    repOffset[1] = repOffset[4] = repOffset[8] = 1;
-    memset(bestRepOffset, 0, sizeof(bestRepOffset));
-    if (compressionLevel==0) compressionLevel = ZSTD_CLEVEL_DEFAULT;
-    params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize);
-
-    esr.dict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, ZSTD_dlm_byRef, ZSTD_dct_rawContent, params.cParams, ZSTD_defaultCMem);
-    esr.zc = ZSTD_createCCtx();
-    esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX);
-    if (!esr.dict || !esr.zc || !esr.workPlace) {
-        eSize = ERROR(memory_allocation);
-        DISPLAYLEVEL(1, "Not enough memory \n");
-        goto _cleanup;
-    }
-
-    /* collect stats on all samples */
-    for (u=0; u<nbFiles; u++) {
-        ZDICT_countEStats(esr, &params,
-                          countLit, offcodeCount, matchLengthCount, litLengthCount, repOffset,
-                         (const char*)srcBuffer + pos, fileSizes[u],
-                          notificationLevel);
-        pos += fileSizes[u];
-    }
-
-    if (notificationLevel >= 4) {
-        /* writeStats */
-        DISPLAYLEVEL(4, "Offset Code Frequencies : \n");
-        for (u=0; u<=offcodeMax; u++) {
-            DISPLAYLEVEL(4, "%2u :%7u \n", u, offcodeCount[u]);
-    }   }
-
-    /* analyze, build stats, starting with literals */
-    {   size_t maxNbBits = HUF_buildCTable_wksp(hufTable, countLit, 255, huffLog, wksp, sizeof(wksp));
-        if (HUF_isError(maxNbBits)) {
-            eSize = maxNbBits;
-            DISPLAYLEVEL(1, " HUF_buildCTable error \n");
-            goto _cleanup;
-        }
-        if (maxNbBits==8) {  /* not compressible : will fail on HUF_writeCTable() */
-            DISPLAYLEVEL(2, "warning : pathological dataset : literals are not compressible : samples are noisy or too regular \n");
-            ZDICT_flatLit(countLit);  /* replace distribution by a fake "mostly flat but still compressible" distribution, that HUF_writeCTable() can encode */
-            maxNbBits = HUF_buildCTable_wksp(hufTable, countLit, 255, huffLog, wksp, sizeof(wksp));
-            assert(maxNbBits==9);
-        }
-        huffLog = (U32)maxNbBits;
-    }
-
-    /* looking for most common first offsets */
-    {   U32 offset;
-        for (offset=1; offset<MAXREPOFFSET; offset++)
-            ZDICT_insertSortCount(bestRepOffset, offset, repOffset[offset]);
-    }
-    /* note : the result of this phase should be used to better appreciate the impact on statistics */
-
-    total=0; for (u=0; u<=offcodeMax; u++) total+=offcodeCount[u];
-    errorCode = FSE_normalizeCount(offcodeNCount, Offlog, offcodeCount, total, offcodeMax, /* useLowProbCount */ 1);
-    if (FSE_isError(errorCode)) {
-        eSize = errorCode;
-        DISPLAYLEVEL(1, "FSE_normalizeCount error with offcodeCount \n");
-        goto _cleanup;
-    }
-    Offlog = (U32)errorCode;
-
-    total=0; for (u=0; u<=MaxML; u++) total+=matchLengthCount[u];
-    errorCode = FSE_normalizeCount(matchLengthNCount, mlLog, matchLengthCount, total, MaxML, /* useLowProbCount */ 1);
-    if (FSE_isError(errorCode)) {
-        eSize = errorCode;
-        DISPLAYLEVEL(1, "FSE_normalizeCount error with matchLengthCount \n");
-        goto _cleanup;
-    }
-    mlLog = (U32)errorCode;
-
-    total=0; for (u=0; u<=MaxLL; u++) total+=litLengthCount[u];
-    errorCode = FSE_normalizeCount(litLengthNCount, llLog, litLengthCount, total, MaxLL, /* useLowProbCount */ 1);
-    if (FSE_isError(errorCode)) {
-        eSize = errorCode;
-        DISPLAYLEVEL(1, "FSE_normalizeCount error with litLengthCount \n");
-        goto _cleanup;
-    }
-    llLog = (U32)errorCode;
-
-    /* write result to buffer */
-    {   size_t const hhSize = HUF_writeCTable_wksp(dstPtr, maxDstSize, hufTable, 255, huffLog, wksp, sizeof(wksp));
-        if (HUF_isError(hhSize)) {
-            eSize = hhSize;
-            DISPLAYLEVEL(1, "HUF_writeCTable error \n");
-            goto _cleanup;
-        }
-        dstPtr += hhSize;
-        maxDstSize -= hhSize;
-        eSize += hhSize;
-    }
-
-    {   size_t const ohSize = FSE_writeNCount(dstPtr, maxDstSize, offcodeNCount, OFFCODE_MAX, Offlog);
-        if (FSE_isError(ohSize)) {
-            eSize = ohSize;
-            DISPLAYLEVEL(1, "FSE_writeNCount error with offcodeNCount \n");
-            goto _cleanup;
-        }
-        dstPtr += ohSize;
-        maxDstSize -= ohSize;
-        eSize += ohSize;
-    }
-
-    {   size_t const mhSize = FSE_writeNCount(dstPtr, maxDstSize, matchLengthNCount, MaxML, mlLog);
-        if (FSE_isError(mhSize)) {
-            eSize = mhSize;
-            DISPLAYLEVEL(1, "FSE_writeNCount error with matchLengthNCount \n");
-            goto _cleanup;
-        }
-        dstPtr += mhSize;
-        maxDstSize -= mhSize;
-        eSize += mhSize;
-    }
-
-    {   size_t const lhSize = FSE_writeNCount(dstPtr, maxDstSize, litLengthNCount, MaxLL, llLog);
-        if (FSE_isError(lhSize)) {
-            eSize = lhSize;
-            DISPLAYLEVEL(1, "FSE_writeNCount error with litlengthNCount \n");
-            goto _cleanup;
-        }
-        dstPtr += lhSize;
-        maxDstSize -= lhSize;
-        eSize += lhSize;
-    }
-
-    if (maxDstSize<12) {
-        eSize = ERROR(dstSize_tooSmall);
-        DISPLAYLEVEL(1, "not enough space to write RepOffsets \n");
-        goto _cleanup;
-    }
-# if 0
-    MEM_writeLE32(dstPtr+0, bestRepOffset[0].offset);
-    MEM_writeLE32(dstPtr+4, bestRepOffset[1].offset);
-    MEM_writeLE32(dstPtr+8, bestRepOffset[2].offset);
-#else
-    /* at this stage, we don't use the result of "most common first offset",
-     * as the impact of statistics is not properly evaluated */
-    MEM_writeLE32(dstPtr+0, repStartValue[0]);
-    MEM_writeLE32(dstPtr+4, repStartValue[1]);
-    MEM_writeLE32(dstPtr+8, repStartValue[2]);
-#endif
-    eSize += 12;
-
-_cleanup:
-    ZSTD_freeCDict(esr.dict);
-    ZSTD_freeCCtx(esr.zc);
-    free(esr.workPlace);
-
-    return eSize;
-}
-
-
-/**
- * @returns the maximum repcode value
- */
-static U32 ZDICT_maxRep(U32 const reps[ZSTD_REP_NUM])
-{
-    U32 maxRep = reps[0];
-    int r;
-    for (r = 1; r < ZSTD_REP_NUM; ++r)
-        maxRep = MAX(maxRep, reps[r]);
-    return maxRep;
-}
-
-size_t ZDICT_finalizeDictionary(void* dictBuffer, size_t dictBufferCapacity,
-                          const void* customDictContent, size_t dictContentSize,
-                          const void* samplesBuffer, const size_t* samplesSizes,
-                          unsigned nbSamples, ZDICT_params_t params)
-{
-    size_t hSize;
-#define HBUFFSIZE 256   /* should prove large enough for all entropy headers */
-    BYTE header[HBUFFSIZE];
-    int const compressionLevel = (params.compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : params.compressionLevel;
-    U32 const notificationLevel = params.notificationLevel;
-    /* The final dictionary content must be at least as large as the largest repcode */
-    size_t const minContentSize = (size_t)ZDICT_maxRep(repStartValue);
-    size_t paddingSize;
-
-    /* check conditions */
-    DEBUGLOG(4, "ZDICT_finalizeDictionary");
-    if (dictBufferCapacity < dictContentSize) return ERROR(dstSize_tooSmall);
-    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) return ERROR(dstSize_tooSmall);
-
-    /* dictionary header */
-    MEM_writeLE32(header, ZSTD_MAGIC_DICTIONARY);
-    {   U64 const randomID = XXH64(customDictContent, dictContentSize, 0);
-        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768;
-        U32 const dictID = params.dictID ? params.dictID : compliantID;
-        MEM_writeLE32(header+4, dictID);
-    }
-    hSize = 8;
-
-    /* entropy tables */
-    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
-    DISPLAYLEVEL(2, "statistics ... \n");
-    {   size_t const eSize = ZDICT_analyzeEntropy(header+hSize, HBUFFSIZE-hSize,
-                                  compressionLevel,
-                                  samplesBuffer, samplesSizes, nbSamples,
-                                  customDictContent, dictContentSize,
-                                  notificationLevel);
-        if (ZDICT_isError(eSize)) return eSize;
-        hSize += eSize;
-    }
-
-    /* Shrink the content size if it doesn't fit in the buffer */
-    if (hSize + dictContentSize > dictBufferCapacity) {
-        dictContentSize = dictBufferCapacity - hSize;
-    }
-
-    /* Pad the dictionary content with zeros if it is too small */
-    if (dictContentSize < minContentSize) {
-        RETURN_ERROR_IF(hSize + minContentSize > dictBufferCapacity, dstSize_tooSmall,
-                        "dictBufferCapacity too small to fit max repcode");
-        paddingSize = minContentSize - dictContentSize;
-    } else {
-        paddingSize = 0;
-    }
-
-    {
-        size_t const dictSize = hSize + paddingSize + dictContentSize;
-
-        /* The dictionary consists of the header, optional padding, and the content.
-         * The padding comes before the content because the "best" position in the
-         * dictionary is the last byte.
-         */
-        BYTE* const outDictHeader = (BYTE*)dictBuffer;
-        BYTE* const outDictPadding = outDictHeader + hSize;
-        BYTE* const outDictContent = outDictPadding + paddingSize;
-
-        assert(dictSize <= dictBufferCapacity);
-        assert(outDictContent + dictContentSize == (BYTE*)dictBuffer + dictSize);
-
-        /* First copy the customDictContent into its final location.
-         * `customDictContent` and `dictBuffer` may overlap, so we must
-         * do this before any other writes into the output buffer.
-         * Then copy the header & padding into the output buffer.
-         */
-        memmove(outDictContent, customDictContent, dictContentSize);
-        memcpy(outDictHeader, header, hSize);
-        memset(outDictPadding, 0, paddingSize);
-
-        return dictSize;
-    }
-}
-
-
-static size_t ZDICT_addEntropyTablesFromBuffer_advanced(
-        void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
-        const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-        ZDICT_params_t params)
-{
-    int const compressionLevel = (params.compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : params.compressionLevel;
-    U32 const notificationLevel = params.notificationLevel;
-    size_t hSize = 8;
-
-    /* calculate entropy tables */
-    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
-    DISPLAYLEVEL(2, "statistics ... \n");
-    {   size_t const eSize = ZDICT_analyzeEntropy((char*)dictBuffer+hSize, dictBufferCapacity-hSize,
-                                  compressionLevel,
-                                  samplesBuffer, samplesSizes, nbSamples,
-                                  (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize,
-                                  notificationLevel);
-        if (ZDICT_isError(eSize)) return eSize;
-        hSize += eSize;
-    }
-
-    /* add dictionary header (after entropy tables) */
-    MEM_writeLE32(dictBuffer, ZSTD_MAGIC_DICTIONARY);
-    {   U64 const randomID = XXH64((char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize, 0);
-        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768;
-        U32 const dictID = params.dictID ? params.dictID : compliantID;
-        MEM_writeLE32((char*)dictBuffer+4, dictID);
-    }
-
-    if (hSize + dictContentSize < dictBufferCapacity)
-        memmove((char*)dictBuffer + hSize, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize);
-    return MIN(dictBufferCapacity, hSize+dictContentSize);
-}
-
-/*! ZDICT_trainFromBuffer_unsafe_legacy() :
-*   Warning : `samplesBuffer` must be followed by noisy guard band !!!
-*   @return : size of dictionary, or an error code which can be tested with ZDICT_isError()
-*/
-static size_t ZDICT_trainFromBuffer_unsafe_legacy(
-                            void* dictBuffer, size_t maxDictSize,
-                            const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-                            ZDICT_legacy_params_t params)
-{
-    U32 const dictListSize = MAX(MAX(DICTLISTSIZE_DEFAULT, nbSamples), (U32)(maxDictSize/16));
-    dictItem* const dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList));
-    unsigned const selectivity = params.selectivityLevel == 0 ? g_selectivity_default : params.selectivityLevel;
-    unsigned const minRep = (selectivity > 30) ? MINRATIO : nbSamples >> selectivity;
-    size_t const targetDictSize = maxDictSize;
-    size_t const samplesBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);
-    size_t dictSize = 0;
-    U32 const notificationLevel = params.zParams.notificationLevel;
-
-    /* checks */
-    if (!dictList) return ERROR(memory_allocation);
-    if (maxDictSize < ZDICT_DICTSIZE_MIN) { free(dictList); return ERROR(dstSize_tooSmall); }   /* requested dictionary size is too small */
-    if (samplesBuffSize < ZDICT_MIN_SAMPLES_SIZE) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* not enough source to create dictionary */
-
-    /* init */
-    ZDICT_initDictItem(dictList);
-
-    /* build dictionary */
-    ZDICT_trainBuffer_legacy(dictList, dictListSize,
-                       samplesBuffer, samplesBuffSize,
-                       samplesSizes, nbSamples,
-                       minRep, notificationLevel);
-
-    /* display best matches */
-    if (params.zParams.notificationLevel>= 3) {
-        unsigned const nb = MIN(25, dictList[0].pos);
-        unsigned const dictContentSize = ZDICT_dictSize(dictList);
-        unsigned u;
-
-        (void) dictContentSize;
-
-        DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", (unsigned)dictList[0].pos-1, dictContentSize);
-        DISPLAYLEVEL(3, "list %u best segments \n", nb-1);
-        for (u=1; u<nb; u++) {
-            unsigned const pos = dictList[u].pos;
-            unsigned const length = dictList[u].length;
-            U32 const printedLength = MIN(40, length);
-            if ((pos > samplesBuffSize) || ((pos + length) > samplesBuffSize)) {
-                free(dictList);
-                return ERROR(GENERIC);   /* should never happen */
-            }
-            DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |",
-                         u, length, pos, (unsigned)dictList[u].savings);
-            ZDICT_printHex((const char*)samplesBuffer+pos, printedLength);
-            DISPLAYLEVEL(3, "| \n");
-    }   }
-
-
-    /* create dictionary */
-    {   unsigned dictContentSize = ZDICT_dictSize(dictList);
-        if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* dictionary content too small */
-        if (dictContentSize < targetDictSize/4) {
-            DISPLAYLEVEL(2, "!  warning : selected content significantly smaller than requested (%u < %u) \n", dictContentSize, (unsigned)maxDictSize);
-            if (samplesBuffSize < 10 * targetDictSize)
-                DISPLAYLEVEL(2, "!  consider increasing the number of samples (total size : %u MB)\n", (unsigned)(samplesBuffSize>>20));
-            if (minRep > MINRATIO) {
-                DISPLAYLEVEL(2, "!  consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1);
-                DISPLAYLEVEL(2, "!  note : larger dictionaries are not necessarily better, test its efficiency on samples \n");
-            }
-        }
-
-        if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) {
-            unsigned proposedSelectivity = selectivity-1;
-            while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; }
-            DISPLAYLEVEL(2, "!  note : calculated dictionary significantly larger than requested (%u > %u) \n", dictContentSize, (unsigned)maxDictSize);
-            DISPLAYLEVEL(2, "!  consider increasing dictionary size, or produce denser dictionary (-s%u) \n", proposedSelectivity);
-            DISPLAYLEVEL(2, "!  always test dictionary efficiency on real samples \n");
-        }
-
-        /* limit dictionary size */
-        {   U32 const max = dictList->pos;   /* convention : nb of useful elts within dictList */
-            U32 currentSize = 0;
-            U32 n; for (n=1; n<max; n++) {
-                currentSize += dictList[n].length;
-                if (currentSize > targetDictSize) { currentSize -= dictList[n].length; break; }
-            }
-            dictList->pos = n;
-            dictContentSize = currentSize;
-        }
-
-        /* build dict content */
-        {   U32 u;
-            BYTE* ptr = (BYTE*)dictBuffer + maxDictSize;
-            for (u=1; u<dictList->pos; u++) {
-                U32 l = dictList[u].length;
-                ptr -= l;
-                if (ptr<(BYTE*)dictBuffer) { free(dictList); return ERROR(GENERIC); }   /* should not happen */
-                memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l);
-        }   }
-
-        dictSize = ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, maxDictSize,
-                                                             samplesBuffer, samplesSizes, nbSamples,
-                                                             params.zParams);
-    }
-
-    /* clean up */
-    free(dictList);
-    return dictSize;
-}
-
-
-/* ZDICT_trainFromBuffer_legacy() :
- * issue : samplesBuffer need to be followed by a noisy guard band.
- * work around : duplicate the buffer, and add the noise */
-size_t ZDICT_trainFromBuffer_legacy(void* dictBuffer, size_t dictBufferCapacity,
-                              const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-                              ZDICT_legacy_params_t params)
-{
-    size_t result;
-    void* newBuff;
-    size_t const sBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);
-    if (sBuffSize < ZDICT_MIN_SAMPLES_SIZE) return 0;   /* not enough content => no dictionary */
-
-    newBuff = malloc(sBuffSize + NOISELENGTH);
-    if (!newBuff) return ERROR(memory_allocation);
-
-    memcpy(newBuff, samplesBuffer, sBuffSize);
-    ZDICT_fillNoise((char*)newBuff + sBuffSize, NOISELENGTH);   /* guard band, for end of buffer condition */
-
-    result =
-        ZDICT_trainFromBuffer_unsafe_legacy(dictBuffer, dictBufferCapacity, newBuff,
-                                            samplesSizes, nbSamples, params);
-    free(newBuff);
-    return result;
-}
-
-
-size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
-                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)
-{
-    ZDICT_fastCover_params_t params;
-    DEBUGLOG(3, "ZDICT_trainFromBuffer");
-    memset(&params, 0, sizeof(params));
-    params.d = 8;
-    params.steps = 4;
-    /* Use default level since no compression level information is available */
-    params.zParams.compressionLevel = ZSTD_CLEVEL_DEFAULT;
-#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=1)
-    params.zParams.notificationLevel = DEBUGLEVEL;
-#endif
-    return ZDICT_optimizeTrainFromBuffer_fastCover(dictBuffer, dictBufferCapacity,
-                                               samplesBuffer, samplesSizes, nbSamples,
-                                               &params);
-}
-
-size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
-                                  const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)
-{
-    ZDICT_params_t params;
-    memset(&params, 0, sizeof(params));
-    return ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity,
-                                                     samplesBuffer, samplesSizes, nbSamples,
-                                                     params);
-}
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/include/zdict.h b/src/duckdb/third_party/zstd/include/zdict.h
deleted file mode 100644
index eaf877270..000000000
--- a/src/duckdb/third_party/zstd/include/zdict.h
+++ /dev/null
@@ -1,473 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-#ifndef ZSTD_ZDICT_H
-#define ZSTD_ZDICT_H
-
-/*======  Dependencies  ======*/
-#include <stddef.h>  /* size_t */
-
-namespace duckdb_zstd {
-
-/* =====   ZDICTLIB_API : control library symbols visibility   ===== */
-#ifndef ZDICTLIB_VISIBLE
-   /* Backwards compatibility with old macro name */
-#  ifdef ZDICTLIB_VISIBILITY
-#    define ZDICTLIB_VISIBLE ZDICTLIB_VISIBILITY
-#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
-#    define ZDICTLIB_VISIBLE __attribute__ ((visibility ("default")))
-#  else
-#    define ZDICTLIB_VISIBLE
-#  endif
-#endif
-
-#ifndef ZDICTLIB_HIDDEN
-#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
-#    define ZDICTLIB_HIDDEN __attribute__ ((visibility ("hidden")))
-#  else
-#    define ZDICTLIB_HIDDEN
-#  endif
-#endif
-
-#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#  define ZDICTLIB_API __declspec(dllexport) ZDICTLIB_VISIBLE
-#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
-#  define ZDICTLIB_API __declspec(dllimport) ZDICTLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define ZDICTLIB_API ZDICTLIB_VISIBLE
-#endif
-
-/*******************************************************************************
- * Zstd dictionary builder
- *
- * FAQ
- * ===
- * Why should I use a dictionary?
- * ------------------------------
- *
- * Zstd can use dictionaries to improve compression ratio of small data.
- * Traditionally small files don't compress well because there is very little
- * repetition in a single sample, since it is small. But, if you are compressing
- * many similar files, like a bunch of JSON records that share the same
- * structure, you can train a dictionary on ahead of time on some samples of
- * these files. Then, zstd can use the dictionary to find repetitions that are
- * present across samples. This can vastly improve compression ratio.
- *
- * When is a dictionary useful?
- * ----------------------------
- *
- * Dictionaries are useful when compressing many small files that are similar.
- * The larger a file is, the less benefit a dictionary will have. Generally,
- * we don't expect dictionary compression to be effective past 100KB. And the
- * smaller a file is, the more we would expect the dictionary to help.
- *
- * How do I use a dictionary?
- * --------------------------
- *
- * Simply pass the dictionary to the zstd compressor with
- * `ZSTD_CCtx_loadDictionary()`. The same dictionary must then be passed to
- * the decompressor, using `ZSTD_DCtx_loadDictionary()`. There are other
- * more advanced functions that allow selecting some options, see zstd.h for
- * complete documentation.
- *
- * What is a zstd dictionary?
- * --------------------------
- *
- * A zstd dictionary has two pieces: Its header, and its content. The header
- * contains a magic number, the dictionary ID, and entropy tables. These
- * entropy tables allow zstd to save on header costs in the compressed file,
- * which really matters for small data. The content is just bytes, which are
- * repeated content that is common across many samples.
- *
- * What is a raw content dictionary?
- * ---------------------------------
- *
- * A raw content dictionary is just bytes. It doesn't have a zstd dictionary
- * header, a dictionary ID, or entropy tables. Any buffer is a valid raw
- * content dictionary.
- *
- * How do I train a dictionary?
- * ----------------------------
- *
- * Gather samples from your use case. These samples should be similar to each
- * other. If you have several use cases, you could try to train one dictionary
- * per use case.
- *
- * Pass those samples to `ZDICT_trainFromBuffer()` and that will train your
- * dictionary. There are a few advanced versions of this function, but this
- * is a great starting point. If you want to further tune your dictionary
- * you could try `ZDICT_optimizeTrainFromBuffer_cover()`. If that is too slow
- * you can try `ZDICT_optimizeTrainFromBuffer_fastCover()`.
- *
- * If the dictionary training function fails, that is likely because you
- * either passed too few samples, or a dictionary would not be effective
- * for your data. Look at the messages that the dictionary trainer printed,
- * if it doesn't say too few samples, then a dictionary would not be effective.
- *
- * How large should my dictionary be?
- * ----------------------------------
- *
- * A reasonable dictionary size, the `dictBufferCapacity`, is about 100KB.
- * The zstd CLI defaults to a 110KB dictionary. You likely don't need a
- * dictionary larger than that. But, most use cases can get away with a
- * smaller dictionary. The advanced dictionary builders can automatically
- * shrink the dictionary for you, and select the smallest size that doesn't
- * hurt compression ratio too much. See the `shrinkDict` parameter.
- * A smaller dictionary can save memory, and potentially speed up
- * compression.
- *
- * How many samples should I provide to the dictionary builder?
- * ------------------------------------------------------------
- *
- * We generally recommend passing ~100x the size of the dictionary
- * in samples. A few thousand should suffice. Having too few samples
- * can hurt the dictionaries effectiveness. Having more samples will
- * only improve the dictionaries effectiveness. But having too many
- * samples can slow down the dictionary builder.
- *
- * How do I determine if a dictionary will be effective?
- * -----------------------------------------------------
- *
- * Simply train a dictionary and try it out. You can use zstd's built in
- * benchmarking tool to test the dictionary effectiveness.
- *
- *   # Benchmark levels 1-3 without a dictionary
- *   zstd -b1e3 -r /path/to/my/files
- *   # Benchmark levels 1-3 with a dictionary
- *   zstd -b1e3 -r /path/to/my/files -D /path/to/my/dictionary
- *
- * When should I retrain a dictionary?
- * -----------------------------------
- *
- * You should retrain a dictionary when its effectiveness drops. Dictionary
- * effectiveness drops as the data you are compressing changes. Generally, we do
- * expect dictionaries to "decay" over time, as your data changes, but the rate
- * at which they decay depends on your use case. Internally, we regularly
- * retrain dictionaries, and if the new dictionary performs significantly
- * better than the old dictionary, we will ship the new dictionary.
- *
- * I have a raw content dictionary, how do I turn it into a zstd dictionary?
- * -------------------------------------------------------------------------
- *
- * If you have a raw content dictionary, e.g. by manually constructing it, or
- * using a third-party dictionary builder, you can turn it into a zstd
- * dictionary by using `ZDICT_finalizeDictionary()`. You'll also have to
- * provide some samples of the data. It will add the zstd header to the
- * raw content, which contains a dictionary ID and entropy tables, which
- * will improve compression ratio, and allow zstd to write the dictionary ID
- * into the frame, if you so choose.
- *
- * Do I have to use zstd's dictionary builder?
- * -------------------------------------------
- *
- * No! You can construct dictionary content however you please, it is just
- * bytes. It will always be valid as a raw content dictionary. If you want
- * a zstd dictionary, which can improve compression ratio, use
- * `ZDICT_finalizeDictionary()`.
- *
- * What is the attack surface of a zstd dictionary?
- * ------------------------------------------------
- *
- * Zstd is heavily fuzz tested, including loading fuzzed dictionaries, so
- * zstd should never crash, or access out-of-bounds memory no matter what
- * the dictionary is. However, if an attacker can control the dictionary
- * during decompression, they can cause zstd to generate arbitrary bytes,
- * just like if they controlled the compressed data.
- *
- ******************************************************************************/
-
-
-/*! ZDICT_trainFromBuffer():
- *  Train a dictionary from an array of samples.
- *  Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4,
- *  f=20, and accel=1.
- *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
- *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
- *  The resulting dictionary will be saved into `dictBuffer`.
- * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
- *          or an error code, which can be tested with ZDICT_isError().
- *  Note:  Dictionary training will fail if there are not enough samples to construct a
- *         dictionary, or if most of the samples are too small (< 8 bytes being the lower limit).
- *         If dictionary training fails, you should use zstd without a dictionary, as the dictionary
- *         would've been ineffective anyways. If you believe your samples would benefit from a dictionary
- *         please open an issue with details, and we can look into it.
- *  Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB.
- *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
- *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
- *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
- *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
- */
-ZDICTLIB_API size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
-                                    const void* samplesBuffer,
-                                    const size_t* samplesSizes, unsigned nbSamples);
-
-typedef struct {
-    int      compressionLevel;   /**< optimize for a specific zstd compression level; 0 means default */
-    unsigned notificationLevel;  /**< Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */
-    unsigned dictID;             /**< force dictID value; 0 means auto mode (32-bits random value)
-                                  *   NOTE: The zstd format reserves some dictionary IDs for future use.
-                                  *         You may use them in private settings, but be warned that they
-                                  *         may be used by zstd in a public dictionary registry in the future.
-                                  *         These dictionary IDs are:
-                                  *           - low range  : <= 32767
-                                  *           - high range : >= (2^31)
-                                  */
-} ZDICT_params_t;
-
-/*! ZDICT_finalizeDictionary():
- * Given a custom content as a basis for dictionary, and a set of samples,
- * finalize dictionary by adding headers and statistics according to the zstd
- * dictionary format.
- *
- * Samples must be stored concatenated in a flat buffer `samplesBuffer`,
- * supplied with an array of sizes `samplesSizes`, providing the size of each
- * sample in order. The samples are used to construct the statistics, so they
- * should be representative of what you will compress with this dictionary.
- *
- * The compression level can be set in `parameters`. You should pass the
- * compression level you expect to use in production. The statistics for each
- * compression level differ, so tuning the dictionary for the compression level
- * can help quite a bit.
- *
- * You can set an explicit dictionary ID in `parameters`, or allow us to pick
- * a random dictionary ID for you, but we can't guarantee no collisions.
- *
- * The dstDictBuffer and the dictContent may overlap, and the content will be
- * appended to the end of the header. If the header + the content doesn't fit in
- * maxDictSize the beginning of the content is truncated to make room, since it
- * is presumed that the most profitable content is at the end of the dictionary,
- * since that is the cheapest to reference.
- *
- * `maxDictSize` must be >= max(dictContentSize, ZSTD_DICTSIZE_MIN).
- *
- * @return: size of dictionary stored into `dstDictBuffer` (<= `maxDictSize`),
- *          or an error code, which can be tested by ZDICT_isError().
- * Note: ZDICT_finalizeDictionary() will push notifications into stderr if
- *       instructed to, using notificationLevel>0.
- * NOTE: This function currently may fail in several edge cases including:
- *         * Not enough samples
- *         * Samples are uncompressible
- *         * Samples are all exactly the same
- */
-ZDICTLIB_API size_t ZDICT_finalizeDictionary(void* dstDictBuffer, size_t maxDictSize,
-                                const void* dictContent, size_t dictContentSize,
-                                const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-                                ZDICT_params_t parameters);
-
-
-/*======   Helper functions   ======*/
-ZDICTLIB_API unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize);  /**< extracts dictID; @return zero if error (not a valid dictionary) */
-ZDICTLIB_API size_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize);  /* returns dict header size; returns a ZSTD error code on failure */
-ZDICTLIB_API unsigned ZDICT_isError(size_t errorCode);
-ZDICTLIB_API const char* ZDICT_getErrorName(size_t errorCode);
-
-} // namespace duckdb_zstd
-
-#endif   /* ZSTD_ZDICT_H */
-
-#if defined(ZDICT_STATIC_LINKING_ONLY) && !defined(ZSTD_ZDICT_H_STATIC)
-#define ZSTD_ZDICT_H_STATIC
-
-namespace duckdb_zstd {
-
-/* This can be overridden externally to hide static symbols. */
-#ifndef ZDICTLIB_STATIC_API
-#  if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#    define ZDICTLIB_STATIC_API __declspec(dllexport) ZDICTLIB_VISIBLE
-#  elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
-#    define ZDICTLIB_STATIC_API __declspec(dllimport) ZDICTLIB_VISIBLE
-#  else
-#    define ZDICTLIB_STATIC_API ZDICTLIB_VISIBLE
-#  endif
-#endif
-
-/* ====================================================================================
- * The definitions in this section are considered experimental.
- * They should never be used with a dynamic library, as they may change in the future.
- * They are provided for advanced usages.
- * Use them only in association with static linking.
- * ==================================================================================== */
-
-#define ZDICT_DICTSIZE_MIN    256
-/* Deprecated: Remove in v1.6.0 */
-#define ZDICT_CONTENTSIZE_MIN 128
-
-/*! ZDICT_cover_params_t:
- *  k and d are the only required parameters.
- *  For others, value 0 means default.
- */
-typedef struct {
-    unsigned k;                  /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */
-    unsigned d;                  /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */
-    unsigned steps;              /* Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked */
-    unsigned nbThreads;          /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */
-    double splitPoint;           /* Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (1.0), 1.0 when all samples are used for both training and testing */
-    unsigned shrinkDict;         /* Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking  */
-    unsigned shrinkDictMaxRegression; /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */
-    ZDICT_params_t zParams;
-} ZDICT_cover_params_t;
-
-typedef struct {
-    unsigned k;                  /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */
-    unsigned d;                  /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */
-    unsigned f;                  /* log of size of frequency array : constraint: 0 < f <= 31 : 1 means default(20)*/
-    unsigned steps;              /* Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked */
-    unsigned nbThreads;          /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */
-    double splitPoint;           /* Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (0.75), 1.0 when all samples are used for both training and testing */
-    unsigned accel;              /* Acceleration level: constraint: 0 < accel <= 10, higher means faster and less accurate, 0 means default(1) */
-    unsigned shrinkDict;         /* Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking  */
-    unsigned shrinkDictMaxRegression; /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */
-
-    ZDICT_params_t zParams;
-} ZDICT_fastCover_params_t;
-
-/*! ZDICT_trainFromBuffer_cover():
- *  Train a dictionary from an array of samples using the COVER algorithm.
- *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
- *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
- *  The resulting dictionary will be saved into `dictBuffer`.
- * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
- *          or an error code, which can be tested with ZDICT_isError().
- *          See ZDICT_trainFromBuffer() for details on failure modes.
- *  Note: ZDICT_trainFromBuffer_cover() requires about 9 bytes of memory for each input byte.
- *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
- *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
- *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
- *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
- */
-ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_cover(
-          void *dictBuffer, size_t dictBufferCapacity,
-    const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,
-          ZDICT_cover_params_t parameters);
-
-/*! ZDICT_optimizeTrainFromBuffer_cover():
- * The same requirements as above hold for all the parameters except `parameters`.
- * This function tries many parameter combinations and picks the best parameters.
- * `*parameters` is filled with the best parameters found,
- * dictionary constructed with those parameters is stored in `dictBuffer`.
- *
- * All of the parameters d, k, steps are optional.
- * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}.
- * if steps is zero it defaults to its default value.
- * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000].
- *
- * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
- *          or an error code, which can be tested with ZDICT_isError().
- *          On success `*parameters` contains the parameters selected.
- *          See ZDICT_trainFromBuffer() for details on failure modes.
- * Note: ZDICT_optimizeTrainFromBuffer_cover() requires about 8 bytes of memory for each input byte and additionally another 5 bytes of memory for each byte of memory for each thread.
- */
-ZDICTLIB_STATIC_API size_t ZDICT_optimizeTrainFromBuffer_cover(
-          void* dictBuffer, size_t dictBufferCapacity,
-    const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-          ZDICT_cover_params_t* parameters);
-
-/*! ZDICT_trainFromBuffer_fastCover():
- *  Train a dictionary from an array of samples using a modified version of COVER algorithm.
- *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
- *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
- *  d and k are required.
- *  All other parameters are optional, will use default values if not provided
- *  The resulting dictionary will be saved into `dictBuffer`.
- * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
- *          or an error code, which can be tested with ZDICT_isError().
- *          See ZDICT_trainFromBuffer() for details on failure modes.
- *  Note: ZDICT_trainFromBuffer_fastCover() requires 6 * 2^f bytes of memory.
- *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
- *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
- *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
- *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
- */
-ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_fastCover(void *dictBuffer,
-                    size_t dictBufferCapacity, const void *samplesBuffer,
-                    const size_t *samplesSizes, unsigned nbSamples,
-                    ZDICT_fastCover_params_t parameters);
-
-/*! ZDICT_optimizeTrainFromBuffer_fastCover():
- * The same requirements as above hold for all the parameters except `parameters`.
- * This function tries many parameter combinations (specifically, k and d combinations)
- * and picks the best parameters. `*parameters` is filled with the best parameters found,
- * dictionary constructed with those parameters is stored in `dictBuffer`.
- * All of the parameters d, k, steps, f, and accel are optional.
- * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}.
- * if steps is zero it defaults to its default value.
- * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000].
- * If f is zero, default value of 20 is used.
- * If accel is zero, default value of 1 is used.
- *
- * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
- *          or an error code, which can be tested with ZDICT_isError().
- *          On success `*parameters` contains the parameters selected.
- *          See ZDICT_trainFromBuffer() for details on failure modes.
- * Note: ZDICT_optimizeTrainFromBuffer_fastCover() requires about 6 * 2^f bytes of memory for each thread.
- */
-ZDICTLIB_STATIC_API size_t ZDICT_optimizeTrainFromBuffer_fastCover(void* dictBuffer,
-                    size_t dictBufferCapacity, const void* samplesBuffer,
-                    const size_t* samplesSizes, unsigned nbSamples,
-                    ZDICT_fastCover_params_t* parameters);
-
-typedef struct {
-    unsigned selectivityLevel;   /* 0 means default; larger => select more => larger dictionary */
-    ZDICT_params_t zParams;
-} ZDICT_legacy_params_t;
-
-/*! ZDICT_trainFromBuffer_legacy():
- *  Train a dictionary from an array of samples.
- *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
- *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
- *  The resulting dictionary will be saved into `dictBuffer`.
- * `parameters` is optional and can be provided with values set to 0 to mean "default".
- * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
- *          or an error code, which can be tested with ZDICT_isError().
- *          See ZDICT_trainFromBuffer() for details on failure modes.
- *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
- *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
- *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
- *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
- *  Note: ZDICT_trainFromBuffer_legacy() will send notifications into stderr if instructed to, using notificationLevel>0.
- */
-ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_legacy(
-    void* dictBuffer, size_t dictBufferCapacity,
-    const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-    ZDICT_legacy_params_t parameters);
-
-
-/* Deprecation warnings */
-/* It is generally possible to disable deprecation warnings from compiler,
-   for example with -Wno-deprecated-declarations for gcc
-   or _CRT_SECURE_NO_WARNINGS in Visual.
-   Otherwise, it's also possible to manually define ZDICT_DISABLE_DEPRECATE_WARNINGS */
-#ifdef ZDICT_DISABLE_DEPRECATE_WARNINGS
-#  define ZDICT_DEPRECATED(message) /* disable deprecation warnings */
-#else
-#  define ZDICT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-#    define ZDICT_DEPRECATED(message) [[deprecated(message)]]
-#  elif defined(__clang__) || (ZDICT_GCC_VERSION >= 405)
-#    define ZDICT_DEPRECATED(message) __attribute__((deprecated(message)))
-#  elif (ZDICT_GCC_VERSION >= 301)
-#    define ZDICT_DEPRECATED(message) __attribute__((deprecated))
-#  elif defined(_MSC_VER)
-#    define ZDICT_DEPRECATED(message) __declspec(deprecated(message))
-#  else
-#    pragma message("WARNING: You need to implement ZDICT_DEPRECATED for this compiler")
-#    define ZDICT_DEPRECATED(message)
-#  endif
-#endif /* ZDICT_DISABLE_DEPRECATE_WARNINGS */
-
-ZDICT_DEPRECATED("use ZDICT_finalizeDictionary() instead")
-ZDICTLIB_STATIC_API
-size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
-                                  const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples);
-
-} // namespace duckdb_zstd
-
-#endif   /* ZSTD_ZDICT_H_STATIC */
diff --git a/src/duckdb/third_party/zstd/include/zstd.h b/src/duckdb/third_party/zstd/include/zstd.h
deleted file mode 100644
index 8b40c366e..000000000
--- a/src/duckdb/third_party/zstd/include/zstd.h
+++ /dev/null
@@ -1,3093 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_H_235446
-#define ZSTD_H_235446
-
-// DuckDB: just enable everything for amalgamation
-#ifdef DUCKDB_AMALGAMATION
-#define ZSTD_STATIC_LINKING_ONLY
-#endif
-
-/* ======   Dependencies   ======*/
-#include <limits.h>   /* INT_MAX */
-#include <stddef.h>   /* size_t */
-
-namespace duckdb_zstd {
-
-/* =====   ZSTDLIB_API : control library symbols visibility   ===== */
-#ifndef ZSTDLIB_VISIBLE
-   /* Backwards compatibility with old macro name */
-#  ifdef ZSTDLIB_VISIBILITY
-#    define ZSTDLIB_VISIBLE ZSTDLIB_VISIBILITY
-#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
-#    define ZSTDLIB_VISIBLE __attribute__ ((visibility ("default")))
-#  else
-#    define ZSTDLIB_VISIBLE
-#  endif
-#endif
-
-#ifndef ZSTDLIB_HIDDEN
-#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
-#    define ZSTDLIB_HIDDEN __attribute__ ((visibility ("hidden")))
-#  else
-#    define ZSTDLIB_HIDDEN
-#  endif
-#endif
-
-#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#  define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBLE
-#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
-#  define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define ZSTDLIB_API ZSTDLIB_VISIBLE
-#endif
-
-/* Deprecation warnings :
- * Should these warnings be a problem, it is generally possible to disable them,
- * typically with -Wno-deprecated-declarations for gcc or _CRT_SECURE_NO_WARNINGS in Visual.
- * Otherwise, it's also possible to define ZSTD_DISABLE_DEPRECATE_WARNINGS.
- */
-#ifdef ZSTD_DISABLE_DEPRECATE_WARNINGS
-#  define ZSTD_DEPRECATED(message) /* disable deprecation warnings */
-#else
-#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-#    define ZSTD_DEPRECATED(message) [[deprecated(message)]]
-#  elif (defined(GNUC) && (GNUC > 4 || (GNUC == 4 && GNUC_MINOR >= 5))) || defined(__clang__)
-#    define ZSTD_DEPRECATED(message) __attribute__((deprecated(message)))
-#  elif defined(__GNUC__) && (__GNUC__ >= 3)
-#    define ZSTD_DEPRECATED(message) __attribute__((deprecated))
-#  elif defined(_MSC_VER)
-#    define ZSTD_DEPRECATED(message) __declspec(deprecated(message))
-#  else
-#    pragma message("WARNING: You need to implement ZSTD_DEPRECATED for this compiler")
-#    define ZSTD_DEPRECATED(message)
-#  endif
-#endif /* ZSTD_DISABLE_DEPRECATE_WARNINGS */
-
-
-/*******************************************************************************
-  Introduction
-
-  zstd, short for Zstandard, is a fast lossless compression algorithm, targeting
-  real-time compression scenarios at zlib-level and better compression ratios.
-  The zstd compression library provides in-memory compression and decompression
-  functions.
-
-  The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),
-  which is currently 22. Levels >= 20, labeled `--ultra`, should be used with
-  caution, as they require more memory. The library also offers negative
-  compression levels, which extend the range of speed vs. ratio preferences.
-  The lower the level, the faster the speed (at the cost of compression).
-
-  Compression can be done in:
-    - a single step (described as Simple API)
-    - a single step, reusing a context (described as Explicit context)
-    - unbounded multiple steps (described as Streaming compression)
-
-  The compression ratio achievable on small data can be highly improved using
-  a dictionary. Dictionary compression can be performed in:
-    - a single step (described as Simple dictionary API)
-    - a single step, reusing a dictionary (described as Bulk-processing
-      dictionary API)
-
-  Advanced experimental functions can be accessed using
-  `#define ZSTD_STATIC_LINKING_ONLY` before including zstd.h.
-
-  Advanced experimental APIs should never be used with a dynamically-linked
-  library. They are not "stable"; their definitions or signatures may change in
-  the future. Only static linking is allowed.
-*******************************************************************************/
-
-/*------   Version   ------*/
-#define ZSTD_VERSION_MAJOR    1
-#define ZSTD_VERSION_MINOR    5
-#define ZSTD_VERSION_RELEASE  6
-#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
-
-/*! ZSTD_versionNumber() :
- *  Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE). */
-ZSTDLIB_API unsigned ZSTD_versionNumber(void);
-
-#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE
-#define ZSTD_QUOTE(str) #str
-#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)
-#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)
-
-/*! ZSTD_versionString() :
- *  Return runtime library version, like "1.4.5". Requires v1.3.0+. */
-ZSTDLIB_API const char* ZSTD_versionString(void);
-
-/* *************************************
- *  Default constant
- ***************************************/
-#ifndef ZSTD_CLEVEL_DEFAULT
-#  define ZSTD_CLEVEL_DEFAULT 3
-#endif
-
-/* *************************************
- *  Constants
- ***************************************/
-
-/* All magic numbers are supposed read/written to/from files/memory using little-endian convention */
-#define ZSTD_MAGICNUMBER            0xFD2FB528    /* valid since v0.8.0 */
-#define ZSTD_MAGIC_DICTIONARY       0xEC30A437    /* valid since v0.7.0 */
-#define ZSTD_MAGIC_SKIPPABLE_START  0x184D2A50    /* all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame */
-#define ZSTD_MAGIC_SKIPPABLE_MASK   0xFFFFFFF0
-
-#define ZSTD_BLOCKSIZELOG_MAX  17
-#define ZSTD_BLOCKSIZE_MAX     (1<<ZSTD_BLOCKSIZELOG_MAX)
-
-
-/***************************************
-*  Simple API
-***************************************/
-/*! ZSTD_compress() :
- *  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.
- *  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have
- *        enough space to successfully compress the data.
- *  @return : compressed size written into `dst` (<= `dstCapacity),
- *            or an error code if it fails (which can be tested using ZSTD_isError()). */
-ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,
-                            const void* src, size_t srcSize,
-                                  int compressionLevel);
-
-/*! ZSTD_decompress() :
- *  `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.
- *  `dstCapacity` is an upper bound of originalSize to regenerate.
- *  If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.
- *  @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
- *            or an errorCode if it fails (which can be tested using ZSTD_isError()). */
-ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
-                              const void* src, size_t compressedSize);
-
-/*! ZSTD_getFrameContentSize() : requires v1.3.0+
- *  `src` should point to the start of a ZSTD encoded frame.
- *  `srcSize` must be at least as large as the frame header.
- *            hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.
- *  @return : - decompressed size of `src` frame content, if known
- *            - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
- *            - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)
- *   note 1 : a 0 return value means the frame is valid but "empty".
- *   note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode.
- *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *            Optionally, application can rely on some implicit limit,
- *            as ZSTD_decompress() only needs an upper bound of decompressed size.
- *            (For example, data could be necessarily cut into blocks <= 16 KB).
- *   note 3 : decompressed size is always present when compression is completed using single-pass functions,
- *            such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict().
- *   note 4 : decompressed size can be very large (64-bits value),
- *            potentially larger than what local system can handle as a single memory segment.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *   note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified.
- *            Always ensure return value fits within application's authorized limits.
- *            Each application can set its own limits.
- *   note 6 : This function replaces ZSTD_getDecompressedSize() */
-#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)
-#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
-ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);
-
-/*! ZSTD_getDecompressedSize() :
- *  NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize().
- *  Both functions work the same way, but ZSTD_getDecompressedSize() blends
- *  "empty", "unknown" and "error" results to the same return value (0),
- *  while ZSTD_getFrameContentSize() gives them separate return values.
- * @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. */
-ZSTD_DEPRECATED("Replaced by ZSTD_getFrameContentSize")
-ZSTDLIB_API
-unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);
-
-/*! ZSTD_findFrameCompressedSize() : Requires v1.4.0+
- * `src` should point to the start of a ZSTD frame or skippable frame.
- * `srcSize` must be >= first frame size
- * @return : the compressed size of the first frame starting at `src`,
- *           suitable to pass as `srcSize` to `ZSTD_decompress` or similar,
- *        or an error code if input is invalid */
-ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);
-
-
-/*======  Helper functions  ======*/
-/* ZSTD_compressBound() :
- * maximum compressed size in worst case single-pass scenario.
- * When invoking `ZSTD_compress()` or any other one-pass compression function,
- * it's recommended to provide @dstCapacity >= ZSTD_compressBound(srcSize)
- * as it eliminates one potential failure scenario,
- * aka not enough room in dst buffer to write the compressed frame.
- * Note : ZSTD_compressBound() itself can fail, if @srcSize > ZSTD_MAX_INPUT_SIZE .
- *        In which case, ZSTD_compressBound() will return an error code
- *        which can be tested using ZSTD_isError().
- *
- * ZSTD_COMPRESSBOUND() :
- * same as ZSTD_compressBound(), but as a macro.
- * It can be used to produce constants, which can be useful for static allocation,
- * for example to size a static array on stack.
- * Will produce constant value 0 if srcSize too large.
- */
-#define ZSTD_MAX_INPUT_SIZE ((sizeof(size_t)==8) ? 0xFF00FF00FF00FF00ULL : 0xFF00FF00U)
-#define ZSTD_COMPRESSBOUND(srcSize)   (((size_t)(srcSize) >= ZSTD_MAX_INPUT_SIZE) ? 0 : (srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
-ZSTDLIB_API size_t ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */
-/* ZSTD_isError() :
- * Most ZSTD_* functions returning a size_t value can be tested for error,
- * using ZSTD_isError().
- * @return 1 if error, 0 otherwise
- */
-ZSTDLIB_API unsigned    ZSTD_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
-ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);     /*!< provides readable string from an error code */
-ZSTDLIB_API int         ZSTD_minCLevel(void);               /*!< minimum negative compression level allowed, requires v1.4.0+ */
-ZSTDLIB_API int         ZSTD_maxCLevel(void);               /*!< maximum compression level available */
-ZSTDLIB_API int         ZSTD_defaultCLevel(void);           /*!< default compression level, specified by ZSTD_CLEVEL_DEFAULT, requires v1.5.0+ */
-
-
-/***************************************
-*  Explicit context
-***************************************/
-/*= Compression context
- *  When compressing many times,
- *  it is recommended to allocate a context just once,
- *  and reuse it for each successive compression operation.
- *  This will make workload friendlier for system's memory.
- *  Note : re-using context is just a speed / resource optimization.
- *         It doesn't change the compression ratio, which remains identical.
- *  Note 2 : In multi-threaded environments,
- *         use one different context per thread for parallel execution.
- */
-typedef struct ZSTD_CCtx_s ZSTD_CCtx;
-ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
-ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);  /* accept NULL pointer */
-
-/*! ZSTD_compressCCtx() :
- *  Same as ZSTD_compress(), using an explicit ZSTD_CCtx.
- *  Important : in order to mirror `ZSTD_compress()` behavior,
- *  this function compresses at the requested compression level,
- *  __ignoring any other advanced parameter__ .
- *  If any advanced parameter was set using the advanced API,
- *  they will all be reset. Only `compressionLevel` remains.
- */
-ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
-                                     void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                                     int compressionLevel);
-
-/*= Decompression context
- *  When decompressing many times,
- *  it is recommended to allocate a context only once,
- *  and reuse it for each successive compression operation.
- *  This will make workload friendlier for system's memory.
- *  Use one context per thread for parallel execution. */
-typedef struct ZSTD_DCtx_s ZSTD_DCtx;
-ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
-ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);  /* accept NULL pointer */
-
-/*! ZSTD_decompressDCtx() :
- *  Same as ZSTD_decompress(),
- *  requires an allocated ZSTD_DCtx.
- *  Compatible with sticky parameters (see below).
- */
-ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
-                                       void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize);
-
-
-/*********************************************
-*  Advanced compression API (Requires v1.4.0+)
-**********************************************/
-
-/* API design :
- *   Parameters are pushed one by one into an existing context,
- *   using ZSTD_CCtx_set*() functions.
- *   Pushed parameters are sticky : they are valid for next compressed frame, and any subsequent frame.
- *   "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
- *   __They do not apply to one-shot variants such as ZSTD_compressCCtx()__ .
- *
- *   It's possible to reset all parameters to "default" using ZSTD_CCtx_reset().
- *
- *   This API supersedes all other "advanced" API entry points in the experimental section.
- *   In the future, we expect to remove API entry points from experimental which are redundant with this API.
- */
-
-
-/* Compression strategies, listed from fastest to strongest */
-typedef enum { ZSTD_fast=1,
-               ZSTD_dfast=2,
-               ZSTD_greedy=3,
-               ZSTD_lazy=4,
-               ZSTD_lazy2=5,
-               ZSTD_btlazy2=6,
-               ZSTD_btopt=7,
-               ZSTD_btultra=8,
-               ZSTD_btultra2=9
-               /* note : new strategies _might_ be added in the future.
-                         Only the order (from fast to strong) is guaranteed */
-} ZSTD_strategy;
-
-typedef enum {
-
-    /* compression parameters
-     * Note: When compressing with a ZSTD_CDict these parameters are superseded
-     * by the parameters used to construct the ZSTD_CDict.
-     * See ZSTD_CCtx_refCDict() for more info (superseded-by-cdict). */
-    ZSTD_c_compressionLevel=100, /* Set compression parameters according to pre-defined cLevel table.
-                              * Note that exact compression parameters are dynamically determined,
-                              * depending on both compression level and srcSize (when known).
-                              * Default level is ZSTD_CLEVEL_DEFAULT==3.
-                              * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT.
-                              * Note 1 : it's possible to pass a negative compression level.
-                              * Note 2 : setting a level does not automatically set all other compression parameters
-                              *   to default. Setting this will however eventually dynamically impact the compression
-                              *   parameters which have not been manually set. The manually set
-                              *   ones will 'stick'. */
-    /* Advanced compression parameters :
-     * It's possible to pin down compression parameters to some specific values.
-     * In which case, these values are no longer dynamically selected by the compressor */
-    ZSTD_c_windowLog=101,    /* Maximum allowed back-reference distance, expressed as power of 2.
-                              * This will set a memory budget for streaming decompression,
-                              * with larger values requiring more memory
-                              * and typically compressing more.
-                              * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX.
-                              * Special: value 0 means "use default windowLog".
-                              * Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT
-                              *       requires explicitly allowing such size at streaming decompression stage. */
-    ZSTD_c_hashLog=102,      /* Size of the initial probe table, as a power of 2.
-                              * Resulting memory usage is (1 << (hashLog+2)).
-                              * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX.
-                              * Larger tables improve compression ratio of strategies <= dFast,
-                              * and improve speed of strategies > dFast.
-                              * Special: value 0 means "use default hashLog". */
-    ZSTD_c_chainLog=103,     /* Size of the multi-probe search table, as a power of 2.
-                              * Resulting memory usage is (1 << (chainLog+2)).
-                              * Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX.
-                              * Larger tables result in better and slower compression.
-                              * This parameter is useless for "fast" strategy.
-                              * It's still useful when using "dfast" strategy,
-                              * in which case it defines a secondary probe table.
-                              * Special: value 0 means "use default chainLog". */
-    ZSTD_c_searchLog=104,    /* Number of search attempts, as a power of 2.
-                              * More attempts result in better and slower compression.
-                              * This parameter is useless for "fast" and "dFast" strategies.
-                              * Special: value 0 means "use default searchLog". */
-    ZSTD_c_minMatch=105,     /* Minimum size of searched matches.
-                              * Note that Zstandard can still find matches of smaller size,
-                              * it just tweaks its search algorithm to look for this size and larger.
-                              * Larger values increase compression and decompression speed, but decrease ratio.
-                              * Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX.
-                              * Note that currently, for all strategies < btopt, effective minimum is 4.
-                              *                    , for all strategies > fast, effective maximum is 6.
-                              * Special: value 0 means "use default minMatchLength". */
-    ZSTD_c_targetLength=106, /* Impact of this field depends on strategy.
-                              * For strategies btopt, btultra & btultra2:
-                              *     Length of Match considered "good enough" to stop search.
-                              *     Larger values make compression stronger, and slower.
-                              * For strategy fast:
-                              *     Distance between match sampling.
-                              *     Larger values make compression faster, and weaker.
-                              * Special: value 0 means "use default targetLength". */
-    ZSTD_c_strategy=107,     /* See ZSTD_strategy enum definition.
-                              * The higher the value of selected strategy, the more complex it is,
-                              * resulting in stronger and slower compression.
-                              * Special: value 0 means "use default strategy". */
-
-    ZSTD_c_targetCBlockSize=130, /* v1.5.6+
-                                  * Attempts to fit compressed block size into approximatively targetCBlockSize.
-                                  * Bound by ZSTD_TARGETCBLOCKSIZE_MIN and ZSTD_TARGETCBLOCKSIZE_MAX.
-                                  * Note that it's not a guarantee, just a convergence target (default:0).
-                                  * No target when targetCBlockSize == 0.
-                                  * This is helpful in low bandwidth streaming environments to improve end-to-end latency,
-                                  * when a client can make use of partial documents (a prominent example being Chrome).
-                                  * Note: this parameter is stable since v1.5.6.
-                                  * It was present as an experimental parameter in earlier versions,
-                                  * but it's not recommended using it with earlier library versions
-                                  * due to massive performance regressions.
-                                  */
-    /* LDM mode parameters */
-    ZSTD_c_enableLongDistanceMatching=160, /* Enable long distance matching.
-                                     * This parameter is designed to improve compression ratio
-                                     * for large inputs, by finding large matches at long distance.
-                                     * It increases memory usage and window size.
-                                     * Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB
-                                     * except when expressly set to a different value.
-                                     * Note: will be enabled by default if ZSTD_c_windowLog >= 128 MB and
-                                     * compression strategy >= ZSTD_btopt (== compression level 16+) */
-    ZSTD_c_ldmHashLog=161,   /* Size of the table for long distance matching, as a power of 2.
-                              * Larger values increase memory usage and compression ratio,
-                              * but decrease compression speed.
-                              * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX
-                              * default: windowlog - 7.
-                              * Special: value 0 means "automatically determine hashlog". */
-    ZSTD_c_ldmMinMatch=162,  /* Minimum match size for long distance matcher.
-                              * Larger/too small values usually decrease compression ratio.
-                              * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX.
-                              * Special: value 0 means "use default value" (default: 64). */
-    ZSTD_c_ldmBucketSizeLog=163, /* Log size of each bucket in the LDM hash table for collision resolution.
-                              * Larger values improve collision resolution but decrease compression speed.
-                              * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX.
-                              * Special: value 0 means "use default value" (default: 3). */
-    ZSTD_c_ldmHashRateLog=164, /* Frequency of inserting/looking up entries into the LDM hash table.
-                              * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN).
-                              * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage.
-                              * Larger values improve compression speed.
-                              * Deviating far from default value will likely result in a compression ratio decrease.
-                              * Special: value 0 means "automatically determine hashRateLog". */
-
-    /* frame parameters */
-    ZSTD_c_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)
-                              * Content size must be known at the beginning of compression.
-                              * This is automatically the case when using ZSTD_compress2(),
-                              * For streaming scenarios, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */
-    ZSTD_c_checksumFlag=201, /* A 32-bits checksum of content is written at end of frame (default:0) */
-    ZSTD_c_dictIDFlag=202,   /* When applicable, dictionary's ID is written into frame header (default:1) */
-
-    /* multi-threading parameters */
-    /* These parameters are only active if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD).
-     * Otherwise, trying to set any other value than default (0) will be a no-op and return an error.
-     * In a situation where it's unknown if the linked library supports multi-threading or not,
-     * setting ZSTD_c_nbWorkers to any value >= 1 and consulting the return value provides a quick way to check this property.
-     */
-    ZSTD_c_nbWorkers=400,    /* Select how many threads will be spawned to compress in parallel.
-                              * When nbWorkers >= 1, triggers asynchronous mode when invoking ZSTD_compressStream*() :
-                              * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
-                              * while compression is performed in parallel, within worker thread(s).
-                              * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
-                              *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
-                              * More workers improve speed, but also increase memory usage.
-                              * Default value is `0`, aka "single-threaded mode" : no worker is spawned,
-                              * compression is performed inside Caller's thread, and all invocations are blocking */
-    ZSTD_c_jobSize=401,      /* Size of a compression job. This value is enforced only when nbWorkers >= 1.
-                              * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.
-                              * 0 means default, which is dynamically determined based on compression parameters.
-                              * Job size must be a minimum of overlap size, or ZSTDMT_JOBSIZE_MIN (= 512 KB), whichever is largest.
-                              * The minimum size is automatically and transparently enforced. */
-    ZSTD_c_overlapLog=402,   /* Control the overlap size, as a fraction of window size.
-                              * The overlap size is an amount of data reloaded from previous job at the beginning of a new job.
-                              * It helps preserve compression ratio, while each job is compressed in parallel.
-                              * This value is enforced only when nbWorkers >= 1.
-                              * Larger values increase compression ratio, but decrease speed.
-                              * Possible values range from 0 to 9 :
-                              * - 0 means "default" : value will be determined by the library, depending on strategy
-                              * - 1 means "no overlap"
-                              * - 9 means "full overlap", using a full window size.
-                              * Each intermediate rank increases/decreases load size by a factor 2 :
-                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:no overlap;  0:default
-                              * default value varies between 6 and 9, depending on strategy */
-
-    /* note : additional experimental parameters are also available
-     * within the experimental section of the API.
-     * At the time of this writing, they include :
-     * ZSTD_c_rsyncable
-     * ZSTD_c_format
-     * ZSTD_c_forceMaxWindow
-     * ZSTD_c_forceAttachDict
-     * ZSTD_c_literalCompressionMode
-     * ZSTD_c_srcSizeHint
-     * ZSTD_c_enableDedicatedDictSearch
-     * ZSTD_c_stableInBuffer
-     * ZSTD_c_stableOutBuffer
-     * ZSTD_c_blockDelimiters
-     * ZSTD_c_validateSequences
-     * ZSTD_c_useBlockSplitter
-     * ZSTD_c_useRowMatchFinder
-     * ZSTD_c_prefetchCDictTables
-     * ZSTD_c_enableSeqProducerFallback
-     * ZSTD_c_maxBlockSize
-     * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
-     * note : never ever use experimentalParam? names directly;
-     *        also, the enums values themselves are unstable and can still change.
-     */
-     ZSTD_c_experimentalParam1=500,
-     ZSTD_c_experimentalParam2=10,
-     ZSTD_c_experimentalParam3=1000,
-     ZSTD_c_experimentalParam4=1001,
-     ZSTD_c_experimentalParam5=1002,
-     /* was ZSTD_c_experimentalParam6=1003; is now ZSTD_c_targetCBlockSize */
-     ZSTD_c_experimentalParam7=1004,
-     ZSTD_c_experimentalParam8=1005,
-     ZSTD_c_experimentalParam9=1006,
-     ZSTD_c_experimentalParam10=1007,
-     ZSTD_c_experimentalParam11=1008,
-     ZSTD_c_experimentalParam12=1009,
-     ZSTD_c_experimentalParam13=1010,
-     ZSTD_c_experimentalParam14=1011,
-     ZSTD_c_experimentalParam15=1012,
-     ZSTD_c_experimentalParam16=1013,
-     ZSTD_c_experimentalParam17=1014,
-     ZSTD_c_experimentalParam18=1015,
-     ZSTD_c_experimentalParam19=1016
-} ZSTD_cParameter;
-
-typedef struct {
-    size_t error;
-    int lowerBound;
-    int upperBound;
-} ZSTD_bounds;
-
-/*! ZSTD_cParam_getBounds() :
- *  All parameters must belong to an interval with lower and upper bounds,
- *  otherwise they will either trigger an error or be automatically clamped.
- * @return : a structure, ZSTD_bounds, which contains
- *         - an error status field, which must be tested using ZSTD_isError()
- *         - lower and upper bounds, both inclusive
- */
-ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);
-
-/*! ZSTD_CCtx_setParameter() :
- *  Set one compression parameter, selected by enum ZSTD_cParameter.
- *  All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().
- *  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
- *  Setting a parameter is generally only possible during frame initialization (before starting compression).
- *  Exception : when using multi-threading mode (nbWorkers >= 1),
- *              the following parameters can be updated _during_ compression (within same frame):
- *              => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy.
- *              new parameters will be active for next job only (after a flush()).
- * @return : an error code (which can be tested using ZSTD_isError()).
- */
-ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);
-
-/*! ZSTD_CCtx_setPledgedSrcSize() :
- *  Total input data size to be compressed as a single frame.
- *  Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag.
- *  This value will also be controlled at end of frame, and trigger an error if not respected.
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame.
- *           In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN.
- *           ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame.
- *  Note 2 : pledgedSrcSize is only valid once, for the next frame.
- *           It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.
- *  Note 3 : Whenever all input data is provided and consumed in a single round,
- *           for example with ZSTD_compress2(),
- *           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
- *           this value is automatically overridden by srcSize instead.
- */
-ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);
-
-typedef enum {
-    ZSTD_reset_session_only = 1,
-    ZSTD_reset_parameters = 2,
-    ZSTD_reset_session_and_parameters = 3
-} ZSTD_ResetDirective;
-
-/*! ZSTD_CCtx_reset() :
- *  There are 2 different things that can be reset, independently or jointly :
- *  - The session : will stop compressing current frame, and make CCtx ready to start a new one.
- *                  Useful after an error, or to interrupt any ongoing compression.
- *                  Any internal data not yet flushed is cancelled.
- *                  Compression parameters and dictionary remain unchanged.
- *                  They will be used to compress next frame.
- *                  Resetting session never fails.
- *  - The parameters : changes all parameters back to "default".
- *                  This also removes any reference to any dictionary or external sequence producer.
- *                  Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)
- *                  otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())
- *  - Both : similar to resetting the session, followed by resetting parameters.
- */
-ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);
-
-/*! ZSTD_compress2() :
- *  Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.
- *  (note that this entry point doesn't even expose a compression level parameter).
- *  ZSTD_compress2() always starts a new frame.
- *  Should cctx hold data from a previously unfinished frame, everything about it is forgotten.
- *  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
- *  - The function is always blocking, returns when compression is completed.
- *  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have
- *        enough space to successfully compress the data, though it is possible it fails for other reasons.
- * @return : compressed size written into `dst` (<= `dstCapacity),
- *           or an error code if it fails (which can be tested using ZSTD_isError()).
- */
-ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx* cctx,
-                                   void* dst, size_t dstCapacity,
-                             const void* src, size_t srcSize);
-
-
-/***********************************************
-*  Advanced decompression API (Requires v1.4.0+)
-************************************************/
-
-/* The advanced API pushes parameters one by one into an existing DCtx context.
- * Parameters are sticky, and remain valid for all following frames
- * using the same DCtx context.
- * It's possible to reset parameters to default values using ZSTD_DCtx_reset().
- * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
- *        Therefore, no new decompression function is necessary.
- */
-
-typedef enum {
-
-    ZSTD_d_windowLogMax=100, /* Select a size limit (in power of 2) beyond which
-                              * the streaming API will refuse to allocate memory buffer
-                              * in order to protect the host from unreasonable memory requirements.
-                              * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
-                              * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT).
-                              * Special: value 0 means "use default maximum windowLog". */
-
-    /* note : additional experimental parameters are also available
-     * within the experimental section of the API.
-     * At the time of this writing, they include :
-     * ZSTD_d_format
-     * ZSTD_d_stableOutBuffer
-     * ZSTD_d_forceIgnoreChecksum
-     * ZSTD_d_refMultipleDDicts
-     * ZSTD_d_disableHuffmanAssembly
-     * ZSTD_d_maxBlockSize
-     * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
-     * note : never ever use experimentalParam? names directly
-     */
-     ZSTD_d_experimentalParam1=1000,
-     ZSTD_d_experimentalParam2=1001,
-     ZSTD_d_experimentalParam3=1002,
-     ZSTD_d_experimentalParam4=1003,
-     ZSTD_d_experimentalParam5=1004,
-     ZSTD_d_experimentalParam6=1005
-
-} ZSTD_dParameter;
-
-/*! ZSTD_dParam_getBounds() :
- *  All parameters must belong to an interval with lower and upper bounds,
- *  otherwise they will either trigger an error or be automatically clamped.
- * @return : a structure, ZSTD_bounds, which contains
- *         - an error status field, which must be tested using ZSTD_isError()
- *         - both lower and upper bounds, inclusive
- */
-ZSTDLIB_API ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam);
-
-/*! ZSTD_DCtx_setParameter() :
- *  Set one compression parameter, selected by enum ZSTD_dParameter.
- *  All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds().
- *  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
- *  Setting a parameter is only possible during frame initialization (before starting decompression).
- * @return : 0, or an error code (which can be tested using ZSTD_isError()).
- */
-ZSTDLIB_API size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);
-
-/*! ZSTD_DCtx_reset() :
- *  Return a DCtx to clean state.
- *  Session and parameters can be reset jointly or separately.
- *  Parameters can only be reset when no active frame is being decompressed.
- * @return : 0, or an error code, which can be tested with ZSTD_isError()
- */
-ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);
-
-
-/****************************
-*  Streaming
-****************************/
-
-typedef struct ZSTD_inBuffer_s {
-  const void* src;    /**< start of input buffer */
-  size_t size;        /**< size of input buffer */
-  size_t pos;         /**< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size */
-} ZSTD_inBuffer;
-
-typedef struct ZSTD_outBuffer_s {
-  void*  dst;         /**< start of output buffer */
-  size_t size;        /**< size of output buffer */
-  size_t pos;         /**< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size */
-} ZSTD_outBuffer;
-
-
-
-/*-***********************************************************************
-*  Streaming compression - HowTo
-*
-*  A ZSTD_CStream object is required to track streaming operation.
-*  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
-*  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
-*  It is recommended to reuse ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
-*
-*  For parallel execution, use one separate ZSTD_CStream per thread.
-*
-*  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
-*
-*  Parameters are sticky : when starting a new compression on the same context,
-*  it will reuse the same sticky parameters as previous compression session.
-*  When in doubt, it's recommended to fully initialize the context before usage.
-*  Use ZSTD_CCtx_reset() to reset the context and ZSTD_CCtx_setParameter(),
-*  ZSTD_CCtx_setPledgedSrcSize(), or ZSTD_CCtx_loadDictionary() and friends to
-*  set more specific parameters, the pledged source size, or load a dictionary.
-*
-*  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
-*  consume input stream. The function will automatically update both `pos`
-*  fields within `input` and `output`.
-*  Note that the function may not consume the entire input, for example, because
-*  the output buffer is already full, in which case `input.pos < input.size`.
-*  The caller must check if input has been entirely consumed.
-*  If not, the caller must make some room to receive more compressed data,
-*  and then present again remaining input data.
-*  note: ZSTD_e_continue is guaranteed to make some forward progress when called,
-*        but doesn't guarantee maximal forward progress. This is especially relevant
-*        when compressing with multiple threads. The call won't block if it can
-*        consume some input, but if it can't it will wait for some, but not all,
-*        output to be flushed.
-* @return : provides a minimum amount of data remaining to be flushed from internal buffers
-*           or an error code, which can be tested using ZSTD_isError().
-*
-*  At any moment, it's possible to flush whatever data might remain stuck within internal buffer,
-*  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
-*  Note that, if `output->size` is too small, a single invocation with ZSTD_e_flush might not be enough (return code > 0).
-*  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
-*  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
-*  operation.
-*  note: ZSTD_e_flush will flush as much output as possible, meaning when compressing with multiple threads, it will
-*        block until the flush is complete or the output buffer is full.
-*  @return : 0 if internal buffers are entirely flushed,
-*            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
-*            or an error code, which can be tested using ZSTD_isError().
-*
-*  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
-*  It will perform a flush and write frame epilogue.
-*  The epilogue is required for decoders to consider a frame completed.
-*  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
-*  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
-*  start a new frame.
-*  note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will
-*        block until the flush is complete or the output buffer is full.
-*  @return : 0 if frame fully completed and fully flushed,
-*            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
-*            or an error code, which can be tested using ZSTD_isError().
-*
-* *******************************************************************/
-
-typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
-                                 /* Continue to distinguish them for compatibility with older versions <= v1.2.0 */
-/*===== ZSTD_CStream management functions =====*/
-ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
-ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);  /* accept NULL pointer */
-
-/*===== Streaming compression functions =====*/
-typedef enum {
-    ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */
-    ZSTD_e_flush=1,    /* flush any data provided so far,
-                        * it creates (at least) one new block, that can be decoded immediately on reception;
-                        * frame will continue: any future data can still reference previously compressed data, improving compression.
-                        * note : multithreaded compression will block to flush as much output as possible. */
-    ZSTD_e_end=2       /* flush any remaining data _and_ close current frame.
-                        * note that frame is only closed after compressed data is fully flushed (return value == 0).
-                        * After that point, any additional data starts a new frame.
-                        * note : each frame is independent (does not reference any content from previous frame).
-                        : note : multithreaded compression will block to flush as much output as possible. */
-} ZSTD_EndDirective;
-
-/*! ZSTD_compressStream2() : Requires v1.4.0+
- *  Behaves about the same as ZSTD_compressStream, with additional control on end directive.
- *  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
- *  - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)
- *  - output->pos must be <= dstCapacity, input->pos must be <= srcSize
- *  - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
- *  - endOp must be a valid directive
- *  - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.
- *  - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available,
- *                                                  and then immediately returns, just indicating that there is some data remaining to be flushed.
- *                                                  The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
- *  - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.
- *  - @return provides a minimum amount of data remaining to be flushed from internal buffers
- *            or an error code, which can be tested using ZSTD_isError().
- *            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
- *            This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.
- *            For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.
- *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
- *            only ZSTD_e_end or ZSTD_e_flush operations are allowed.
- *            Before starting a new compression job, or changing compression parameters,
- *            it is required to fully flush internal buffers.
- *  - note: if an operation ends with an error, it may leave @cctx in an undefined state.
- *          Therefore, it's UB to invoke ZSTD_compressStream2() of ZSTD_compressStream() on such a state.
- *          In order to be re-employed after an error, a state must be reset,
- *          which can be done explicitly (ZSTD_CCtx_reset()),
- *          or is sometimes implied by methods starting a new compression job (ZSTD_initCStream(), ZSTD_compressCCtx())
- */
-ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
-                                         ZSTD_outBuffer* output,
-                                         ZSTD_inBuffer* input,
-                                         ZSTD_EndDirective endOp);
-
-
-/* These buffer sizes are softly recommended.
- * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
- * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
- * reducing the amount of memory shuffling and buffering, resulting in minor performance savings.
- *
- * However, note that these recommendations are from the perspective of a C caller program.
- * If the streaming interface is invoked from some other language,
- * especially managed ones such as Java or Go, through a foreign function interface such as jni or cgo,
- * a major performance rule is to reduce crossing such interface to an absolute minimum.
- * It's not rare that performance ends being spent more into the interface, rather than compression itself.
- * In which cases, prefer using large buffers, as large as practical,
- * for both input and output, to reduce the nb of roundtrips.
- */
-ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */
-ZSTDLIB_API size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block. */
-
-
-/* *****************************************************************************
- * This following is a legacy streaming API, available since v1.0+ .
- * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
- * It is redundant, but remains fully supported.
- ******************************************************************************/
-
-/*!
- * Equivalent to:
- *
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)
- *     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
- *
- * Note that ZSTD_initCStream() clears any previously set dictionary. Use the new API
- * to compress with a dictionary.
- */
-ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
-/*!
- * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
- * NOTE: The return value is different. ZSTD_compressStream() returns a hint for
- * the next read size (if non-zero and not an error). ZSTD_compressStream2()
- * returns the minimum nb of bytes left to flush (if non-zero and not an error).
- */
-ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
-/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */
-ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
-/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */
-ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
-
-
-/*-***************************************************************************
-*  Streaming decompression - HowTo
-*
-*  A ZSTD_DStream object is required to track streaming operations.
-*  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
-*  ZSTD_DStream objects can be reused multiple times.
-*
-*  Use ZSTD_initDStream() to start a new decompression operation.
-* @return : recommended first input size
-*  Alternatively, use advanced API to set specific properties.
-*
-*  Use ZSTD_decompressStream() repetitively to consume your input.
-*  The function will update both `pos` fields.
-*  If `input.pos < input.size`, some input has not been consumed.
-*  It's up to the caller to present again remaining data.
-*  The function tries to flush all data decoded immediately, respecting output buffer size.
-*  If `output.pos < output.size`, decoder has flushed everything it could.
-*  But if `output.pos == output.size`, there might be some data left within internal buffers.,
-*  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
-*  Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX.
-* @return : 0 when a frame is completely decoded and fully flushed,
-*        or an error code, which can be tested using ZSTD_isError(),
-*        or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :
-*                                the return value is a suggested next input size (just a hint for better latency)
-*                                that will never request more than the remaining frame size.
-* *******************************************************************************/
-
-typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
-                                 /* For compatibility with versions <= v1.2.0, prefer differentiating them. */
-/*===== ZSTD_DStream management functions =====*/
-ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
-ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);  /* accept NULL pointer */
-
-/*===== Streaming decompression functions =====*/
-
-/*! ZSTD_initDStream() :
- * Initialize/reset DStream state for new decompression operation.
- * Call before new decompression operation using same DStream.
- *
- * Note : This function is redundant with the advanced API and equivalent to:
- *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
- *     ZSTD_DCtx_refDDict(zds, NULL);
- */
-ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
-
-/*! ZSTD_decompressStream() :
- * Streaming decompression function.
- * Call repetitively to consume full input updating it as necessary.
- * Function will update both input and output `pos` fields exposing current state via these fields:
- * - `input.pos < input.size`, some input remaining and caller should provide remaining input
- *   on the next call.
- * - `output.pos < output.size`, decoder finished and flushed all remaining buffers.
- * - `output.pos == output.size`, potentially uncflushed data present in the internal buffers,
- *   call ZSTD_decompressStream() again to flush remaining data to output.
- * Note : with no additional input, amount of data flushed <= ZSTD_BLOCKSIZE_MAX.
- *
- * @return : 0 when a frame is completely decoded and fully flushed,
- *           or an error code, which can be tested using ZSTD_isError(),
- *           or any other value > 0, which means there is some decoding or flushing to do to complete current frame.
- *
- * Note: when an operation returns with an error code, the @zds state may be left in undefined state.
- *       It's UB to invoke `ZSTD_decompressStream()` on such a state.
- *       In order to re-use such a state, it must be first reset,
- *       which can be done explicitly (`ZSTD_DCtx_reset()`),
- *       or is implied for operations starting some new decompression job (`ZSTD_initDStream`, `ZSTD_decompressDCtx()`, `ZSTD_decompress_usingDict()`)
- */
-ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
-
-ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */
-ZSTDLIB_API size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */
-
-
-/**************************
-*  Simple dictionary API
-***************************/
-/*! ZSTD_compress_usingDict() :
- *  Compression at an explicit compression level using a Dictionary.
- *  A dictionary can be any arbitrary data segment (also called a prefix),
- *  or a buffer with specified information (see zdict.h).
- *  Note : This function loads the dictionary, resulting in significant startup delay.
- *         It's intended for a dictionary used only once.
- *  Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used. */
-ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize,
-                                     const void* dict,size_t dictSize,
-                                           int compressionLevel);
-
-/*! ZSTD_decompress_usingDict() :
- *  Decompression using a known Dictionary.
- *  Dictionary must be identical to the one used during compression.
- *  Note : This function loads the dictionary, resulting in significant startup delay.
- *         It's intended for a dictionary used only once.
- *  Note : When `dict == NULL || dictSize < 8` no dictionary is used. */
-ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
-                                             void* dst, size_t dstCapacity,
-                                       const void* src, size_t srcSize,
-                                       const void* dict,size_t dictSize);
-
-
-/***********************************
- *  Bulk processing dictionary API
- **********************************/
-typedef struct ZSTD_CDict_s ZSTD_CDict;
-
-/*! ZSTD_createCDict() :
- *  When compressing multiple messages or blocks using the same dictionary,
- *  it's recommended to digest the dictionary only once, since it's a costly operation.
- *  ZSTD_createCDict() will create a state from digesting a dictionary.
- *  The resulting state can be used for future compression operations with very limited startup cost.
- *  ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
- * @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict.
- *  Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content.
- *  Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer,
- *      in which case the only thing that it transports is the @compressionLevel.
- *      This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively,
- *      expecting a ZSTD_CDict parameter with any data, including those without a known dictionary. */
-ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize,
-                                         int compressionLevel);
-
-/*! ZSTD_freeCDict() :
- *  Function frees memory allocated by ZSTD_createCDict().
- *  If a NULL pointer is passed, no operation is performed. */
-ZSTDLIB_API size_t      ZSTD_freeCDict(ZSTD_CDict* CDict);
-
-/*! ZSTD_compress_usingCDict() :
- *  Compression using a digested Dictionary.
- *  Recommended when same dictionary is used multiple times.
- *  Note : compression level is _decided at dictionary creation time_,
- *     and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) */
-ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
-                                            void* dst, size_t dstCapacity,
-                                      const void* src, size_t srcSize,
-                                      const ZSTD_CDict* cdict);
-
-
-typedef struct ZSTD_DDict_s ZSTD_DDict;
-
-/*! ZSTD_createDDict() :
- *  Create a digested dictionary, ready to start decompression operation without startup delay.
- *  dictBuffer can be released after DDict creation, as its content is copied inside DDict. */
-ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize);
-
-/*! ZSTD_freeDDict() :
- *  Function frees memory allocated with ZSTD_createDDict()
- *  If a NULL pointer is passed, no operation is performed. */
-ZSTDLIB_API size_t      ZSTD_freeDDict(ZSTD_DDict* ddict);
-
-/*! ZSTD_decompress_usingDDict() :
- *  Decompression using a digested Dictionary.
- *  Recommended when same dictionary is used multiple times. */
-ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
-                                              void* dst, size_t dstCapacity,
-                                        const void* src, size_t srcSize,
-                                        const ZSTD_DDict* ddict);
-
-
-/********************************
- *  Dictionary helper functions
- *******************************/
-
-/*! ZSTD_getDictID_fromDict() : Requires v1.4.0+
- *  Provides the dictID stored within dictionary.
- *  if @return == 0, the dictionary is not conformant with Zstandard specification.
- *  It can still be loaded, but as a content-only dictionary. */
-ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize);
-
-/*! ZSTD_getDictID_fromCDict() : Requires v1.5.0+
- *  Provides the dictID of the dictionary loaded into `cdict`.
- *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
- *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
-ZSTDLIB_API unsigned ZSTD_getDictID_fromCDict(const ZSTD_CDict* cdict);
-
-/*! ZSTD_getDictID_fromDDict() : Requires v1.4.0+
- *  Provides the dictID of the dictionary loaded into `ddict`.
- *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
- *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
-ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);
-
-/*! ZSTD_getDictID_fromFrame() : Requires v1.4.0+
- *  Provides the dictID required to decompressed the frame stored within `src`.
- *  If @return == 0, the dictID could not be decoded.
- *  This could for one of the following reasons :
- *  - The frame does not require a dictionary to be decoded (most common case).
- *  - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden piece of information.
- *    Note : this use case also happens when using a non-conformant dictionary.
- *  - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).
- *  - This is not a Zstandard frame.
- *  When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */
-ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
-
-
-/*******************************************************************************
- * Advanced dictionary and prefix API (Requires v1.4.0+)
- *
- * This API allows dictionaries to be used with ZSTD_compress2(),
- * ZSTD_compressStream2(), and ZSTD_decompressDCtx().
- * Dictionaries are sticky, they remain valid when same context is reused,
- * they only reset when the context is reset
- * with ZSTD_reset_parameters or ZSTD_reset_session_and_parameters.
- * In contrast, Prefixes are single-use.
- ******************************************************************************/
-
-
-/*! ZSTD_CCtx_loadDictionary() : Requires v1.4.0+
- *  Create an internal CDict from `dict` buffer.
- *  Decompression will have to use same dictionary.
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,
- *           meaning "return to no-dictionary mode".
- *  Note 1 : Dictionary is sticky, it will be used for all future compressed frames,
- *           until parameters are reset, a new dictionary is loaded, or the dictionary
- *           is explicitly invalidated by loading a NULL dictionary.
- *  Note 2 : Loading a dictionary involves building tables.
- *           It's also a CPU consuming operation, with non-negligible impact on latency.
- *           Tables are dependent on compression parameters, and for this reason,
- *           compression parameters can no longer be changed after loading a dictionary.
- *  Note 3 :`dict` content will be copied internally.
- *           Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.
- *           In such a case, dictionary buffer must outlive its users.
- *  Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()
- *           to precisely select how dictionary content must be interpreted.
- *  Note 5 : This method does not benefit from LDM (long distance mode).
- *           If you want to employ LDM on some large dictionary content,
- *           prefer employing ZSTD_CCtx_refPrefix() described below.
- */
-ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
-
-/*! ZSTD_CCtx_refCDict() : Requires v1.4.0+
- *  Reference a prepared dictionary, to be used for all future compressed frames.
- *  Note that compression parameters are enforced from within CDict,
- *  and supersede any compression parameter previously set within CCtx.
- *  The parameters ignored are labelled as "superseded-by-cdict" in the ZSTD_cParameter enum docs.
- *  The ignored parameters will be used again if the CCtx is returned to no-dictionary mode.
- *  The dictionary will remain valid for future compressed frames using same CCtx.
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Special : Referencing a NULL CDict means "return to no-dictionary mode".
- *  Note 1 : Currently, only one dictionary can be managed.
- *           Referencing a new dictionary effectively "discards" any previous one.
- *  Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. */
-ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
-
-/*! ZSTD_CCtx_refPrefix() : Requires v1.4.0+
- *  Reference a prefix (single-usage dictionary) for next compressed frame.
- *  A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end).
- *  Decompression will need same prefix to properly regenerate data.
- *  Compressing with a prefix is similar in outcome as performing a diff and compressing it,
- *  but performs much faster, especially during decompression (compression speed is tunable with compression level).
- *  This method is compatible with LDM (long distance mode).
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary
- *  Note 1 : Prefix buffer is referenced. It **must** outlive compression.
- *           Its content must remain unmodified during compression.
- *  Note 2 : If the intention is to diff some large src data blob with some prior version of itself,
- *           ensure that the window size is large enough to contain the entire source.
- *           See ZSTD_c_windowLog.
- *  Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.
- *           It's a CPU consuming operation, with non-negligible impact on latency.
- *           If there is a need to use the same prefix multiple times, consider loadDictionary instead.
- *  Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent).
- *           Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. */
-ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,
-                                 const void* prefix, size_t prefixSize);
-
-/*! ZSTD_DCtx_loadDictionary() : Requires v1.4.0+
- *  Create an internal DDict from dict buffer, to be used to decompress all future frames.
- *  The dictionary remains valid for all future frames, until explicitly invalidated, or
- *  a new dictionary is loaded.
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,
- *            meaning "return to no-dictionary mode".
- *  Note 1 : Loading a dictionary involves building tables,
- *           which has a non-negligible impact on CPU usage and latency.
- *           It's recommended to "load once, use many times", to amortize the cost
- *  Note 2 :`dict` content will be copied internally, so `dict` can be released after loading.
- *           Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead.
- *  Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of
- *           how dictionary content is loaded and interpreted.
- */
-ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
-
-/*! ZSTD_DCtx_refDDict() : Requires v1.4.0+
- *  Reference a prepared dictionary, to be used to decompress next frames.
- *  The dictionary remains active for decompression of future frames using same DCtx.
- *
- *  If called with ZSTD_d_refMultipleDDicts enabled, repeated calls of this function
- *  will store the DDict references in a table, and the DDict used for decompression
- *  will be determined at decompression time, as per the dict ID in the frame.
- *  The memory for the table is allocated on the first call to refDDict, and can be
- *  freed with ZSTD_freeDCtx().
- *
- *  If called with ZSTD_d_refMultipleDDicts disabled (the default), only one dictionary
- *  will be managed, and referencing a dictionary effectively "discards" any previous one.
- *
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Special: referencing a NULL DDict means "return to no-dictionary mode".
- *  Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx.
- */
-ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
-
-/*! ZSTD_DCtx_refPrefix() : Requires v1.4.0+
- *  Reference a prefix (single-usage dictionary) to decompress next frame.
- *  This is the reverse operation of ZSTD_CCtx_refPrefix(),
- *  and must use the same prefix as the one used during compression.
- *  Prefix is **only used once**. Reference is discarded at end of frame.
- *  End of frame is reached when ZSTD_decompressStream() returns 0.
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- *  Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary
- *  Note 2 : Prefix buffer is referenced. It **must** outlive decompression.
- *           Prefix buffer must remain unmodified up to the end of frame,
- *           reached when ZSTD_decompressStream() returns 0.
- *  Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent).
- *           Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)
- *  Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.
- *           A full dictionary is more costly, as it requires building tables.
- */
-ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,
-                                 const void* prefix, size_t prefixSize);
-
-/* ===   Memory management   === */
-
-/*! ZSTD_sizeof_*() : Requires v1.4.0+
- *  These functions give the _current_ memory usage of selected object.
- *  Note that object memory usage can evolve (increase or decrease) over time. */
-ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);
-ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);
-ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
-ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
-ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict);
-ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
-
-} // namespace duckdb_zstd
-
-#endif  /* ZSTD_H_235446 */
-
-namespace duckdb_zstd {
-
-/* **************************************************************************************
- *   ADVANCED AND EXPERIMENTAL FUNCTIONS
- ****************************************************************************************
- * The definitions in the following section are considered experimental.
- * They are provided for advanced scenarios.
- * They should never be used with a dynamic library, as prototypes may change in the future.
- * Use them only in association with static linking.
- * ***************************************************************************************/
-
-#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
-#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY
-
-/* This can be overridden externally to hide static symbols. */
-#ifndef ZSTDLIB_STATIC_API
-#  if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#    define ZSTDLIB_STATIC_API __declspec(dllexport) ZSTDLIB_VISIBLE
-#  elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
-#    define ZSTDLIB_STATIC_API __declspec(dllimport) ZSTDLIB_VISIBLE
-#  else
-#    define ZSTDLIB_STATIC_API ZSTDLIB_VISIBLE
-#  endif
-#endif
-
-/****************************************************************************************
- *   experimental API (static linking only)
- ****************************************************************************************
- * The following symbols and constants
- * are not planned to join "stable API" status in the near future.
- * They can still change in future versions.
- * Some of them are planned to remain in the static_only section indefinitely.
- * Some of them might be removed in the future (especially when redundant with existing stable functions)
- * ***************************************************************************************/
-
-#define ZSTD_FRAMEHEADERSIZE_PREFIX(format) ((format) == ZSTD_f_zstd1 ? 5 : 1)   /* minimum input size required to query frame header size */
-#define ZSTD_FRAMEHEADERSIZE_MIN(format)    ((format) == ZSTD_f_zstd1 ? 6 : 2)
-#define ZSTD_FRAMEHEADERSIZE_MAX   18   /* can be useful for static allocation */
-#define ZSTD_SKIPPABLEHEADERSIZE    8
-
-/* compression parameter bounds */
-#define ZSTD_WINDOWLOG_MAX_32    30
-#define ZSTD_WINDOWLOG_MAX_64    31
-#define ZSTD_WINDOWLOG_MAX     ((int)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64))
-#define ZSTD_WINDOWLOG_MIN       10
-#define ZSTD_HASHLOG_MAX       ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30)
-#define ZSTD_HASHLOG_MIN          6
-#define ZSTD_CHAINLOG_MAX_32     29
-#define ZSTD_CHAINLOG_MAX_64     30
-#define ZSTD_CHAINLOG_MAX      ((int)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64))
-#define ZSTD_CHAINLOG_MIN        ZSTD_HASHLOG_MIN
-#define ZSTD_SEARCHLOG_MAX      (ZSTD_WINDOWLOG_MAX-1)
-#define ZSTD_SEARCHLOG_MIN        1
-#define ZSTD_MINMATCH_MAX         7   /* only for ZSTD_fast, other strategies are limited to 6 */
-#define ZSTD_MINMATCH_MIN         3   /* only for ZSTD_btopt+, faster strategies are limited to 4 */
-#define ZSTD_TARGETLENGTH_MAX    ZSTD_BLOCKSIZE_MAX
-#define ZSTD_TARGETLENGTH_MIN     0   /* note : comparing this constant to an unsigned results in a tautological test */
-#define ZSTD_STRATEGY_MIN        ZSTD_fast
-#define ZSTD_STRATEGY_MAX        ZSTD_btultra2
-#define ZSTD_BLOCKSIZE_MAX_MIN (1 << 10) /* The minimum valid max blocksize. Maximum blocksizes smaller than this make compressBound() inaccurate. */
-
-
-#define ZSTD_OVERLAPLOG_MIN       0
-#define ZSTD_OVERLAPLOG_MAX       9
-
-#define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27   /* by default, the streaming decoder will refuse any frame */
-                                           /* requiring larger than (1<<ZSTD_WINDOWLOG_LIMIT_DEFAULT) window size, */
-                                           /* to preserve host's memory from unreasonable requirements. */
-                                           /* This limit can be overridden using ZSTD_DCtx_setParameter(,ZSTD_d_windowLogMax,). */
-                                           /* The limit does not apply for one-pass decoders (such as ZSTD_decompress()), since no additional memory is allocated */
-
-
-/* LDM parameter bounds */
-#define ZSTD_LDM_HASHLOG_MIN      ZSTD_HASHLOG_MIN
-#define ZSTD_LDM_HASHLOG_MAX      ZSTD_HASHLOG_MAX
-#define ZSTD_LDM_MINMATCH_MIN        4
-#define ZSTD_LDM_MINMATCH_MAX     4096
-#define ZSTD_LDM_BUCKETSIZELOG_MIN   1
-#define ZSTD_LDM_BUCKETSIZELOG_MAX   8
-#define ZSTD_LDM_HASHRATELOG_MIN     0
-#define ZSTD_LDM_HASHRATELOG_MAX (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)
-
-/* Advanced parameter bounds */
-#define ZSTD_TARGETCBLOCKSIZE_MIN   1340 /* suitable to fit into an ethernet / wifi / 4G transport frame */
-#define ZSTD_TARGETCBLOCKSIZE_MAX   ZSTD_BLOCKSIZE_MAX
-#define ZSTD_SRCSIZEHINT_MIN        0
-#define ZSTD_SRCSIZEHINT_MAX        INT_MAX
-
-
-/* ---  Advanced types  --- */
-
-typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;
-
-typedef struct {
-    unsigned int offset;      /* The offset of the match. (NOT the same as the offset code)
-                               * If offset == 0 and matchLength == 0, this sequence represents the last
-                               * literals in the block of litLength size.
-                               */
-
-    unsigned int litLength;   /* Literal length of the sequence. */
-    unsigned int matchLength; /* Match length of the sequence. */
-
-                              /* Note: Users of this API may provide a sequence with matchLength == litLength == offset == 0.
-                               * In this case, we will treat the sequence as a marker for a block boundary.
-                               */
-
-    unsigned int rep;         /* Represents which repeat offset is represented by the field 'offset'.
-                               * Ranges from [0, 3].
-                               *
-                               * Repeat offsets are essentially previous offsets from previous sequences sorted in
-                               * recency order. For more detail, see doc/zstd_compression_format.md
-                               *
-                               * If rep == 0, then 'offset' does not contain a repeat offset.
-                               * If rep > 0:
-                               *  If litLength != 0:
-                               *      rep == 1 --> offset == repeat_offset_1
-                               *      rep == 2 --> offset == repeat_offset_2
-                               *      rep == 3 --> offset == repeat_offset_3
-                               *  If litLength == 0:
-                               *      rep == 1 --> offset == repeat_offset_2
-                               *      rep == 2 --> offset == repeat_offset_3
-                               *      rep == 3 --> offset == repeat_offset_1 - 1
-                               *
-                               * Note: This field is optional. ZSTD_generateSequences() will calculate the value of
-                               * 'rep', but repeat offsets do not necessarily need to be calculated from an external
-                               * sequence provider's perspective. For example, ZSTD_compressSequences() does not
-                               * use this 'rep' field at all (as of now).
-                               */
-} ZSTD_Sequence;
-
-typedef struct {
-    unsigned windowLog;       /**< largest match distance : larger == more compression, more memory needed during decompression */
-    unsigned chainLog;        /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */
-    unsigned hashLog;         /**< dispatch table : larger == faster, more memory */
-    unsigned searchLog;       /**< nb of searches : larger == more compression, slower */
-    unsigned minMatch;        /**< match length searched : larger == faster decompression, sometimes less compression */
-    unsigned targetLength;    /**< acceptable match size for optimal parser (only) : larger == more compression, slower */
-    ZSTD_strategy strategy;   /**< see ZSTD_strategy definition above */
-} ZSTD_compressionParameters;
-
-typedef struct {
-    int contentSizeFlag; /**< 1: content size will be in frame header (when known) */
-    int checksumFlag;    /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */
-    int noDictIDFlag;    /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */
-} ZSTD_frameParameters;
-
-typedef struct {
-    ZSTD_compressionParameters cParams;
-    ZSTD_frameParameters fParams;
-} ZSTD_parameters;
-
-typedef enum {
-    ZSTD_dct_auto = 0,       /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
-    ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
-    ZSTD_dct_fullDict = 2    /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */
-} ZSTD_dictContentType_e;
-
-typedef enum {
-    ZSTD_dlm_byCopy = 0,  /**< Copy dictionary content internally */
-    ZSTD_dlm_byRef = 1    /**< Reference dictionary content -- the dictionary buffer must outlive its users. */
-} ZSTD_dictLoadMethod_e;
-
-typedef enum {
-    ZSTD_f_zstd1 = 0,           /* zstd frame format, specified in zstd_compression_format.md (default) */
-    ZSTD_f_zstd1_magicless = 1  /* Variant of zstd frame format, without initial 4-bytes magic number.
-                                 * Useful to save 4 bytes per generated frame.
-                                 * Decoder cannot recognise automatically this format, requiring this instruction. */
-} ZSTD_format_e;
-
-typedef enum {
-    /* Note: this enum controls ZSTD_d_forceIgnoreChecksum */
-    ZSTD_d_validateChecksum = 0,
-    ZSTD_d_ignoreChecksum = 1
-} ZSTD_forceIgnoreChecksum_e;
-
-typedef enum {
-    /* Note: this enum controls ZSTD_d_refMultipleDDicts */
-    ZSTD_rmd_refSingleDDict = 0,
-    ZSTD_rmd_refMultipleDDicts = 1
-} ZSTD_refMultipleDDicts_e;
-
-typedef enum {
-    /* Note: this enum and the behavior it controls are effectively internal
-     * implementation details of the compressor. They are expected to continue
-     * to evolve and should be considered only in the context of extremely
-     * advanced performance tuning.
-     *
-     * Zstd currently supports the use of a CDict in three ways:
-     *
-     * - The contents of the CDict can be copied into the working context. This
-     *   means that the compression can search both the dictionary and input
-     *   while operating on a single set of internal tables. This makes
-     *   the compression faster per-byte of input. However, the initial copy of
-     *   the CDict's tables incurs a fixed cost at the beginning of the
-     *   compression. For small compressions (< 8 KB), that copy can dominate
-     *   the cost of the compression.
-     *
-     * - The CDict's tables can be used in-place. In this model, compression is
-     *   slower per input byte, because the compressor has to search two sets of
-     *   tables. However, this model incurs no start-up cost (as long as the
-     *   working context's tables can be reused). For small inputs, this can be
-     *   faster than copying the CDict's tables.
-     *
-     * - The CDict's tables are not used at all, and instead we use the working
-     *   context alone to reload the dictionary and use params based on the source
-     *   size. See ZSTD_compress_insertDictionary() and ZSTD_compress_usingDict().
-     *   This method is effective when the dictionary sizes are very small relative
-     *   to the input size, and the input size is fairly large to begin with.
-     *
-     * Zstd has a simple internal heuristic that selects which strategy to use
-     * at the beginning of a compression. However, if experimentation shows that
-     * Zstd is making poor choices, it is possible to override that choice with
-     * this enum.
-     */
-    ZSTD_dictDefaultAttach = 0, /* Use the default heuristic. */
-    ZSTD_dictForceAttach   = 1, /* Never copy the dictionary. */
-    ZSTD_dictForceCopy     = 2, /* Always copy the dictionary. */
-    ZSTD_dictForceLoad     = 3  /* Always reload the dictionary */
-} ZSTD_dictAttachPref_e;
-
-typedef enum {
-  ZSTD_lcm_auto = 0,          /**< Automatically determine the compression mode based on the compression level.
-                               *   Negative compression levels will be uncompressed, and positive compression
-                               *   levels will be compressed. */
-  ZSTD_lcm_huffman = 1,       /**< Always attempt Huffman compression. Uncompressed literals will still be
-                               *   emitted if Huffman compression is not profitable. */
-  ZSTD_lcm_uncompressed = 2   /**< Always emit uncompressed literals. */
-} ZSTD_literalCompressionMode_e;
-
-typedef enum {
-  /* Note: This enum controls features which are conditionally beneficial. Zstd typically will make a final
-   * decision on whether or not to enable the feature (ZSTD_ps_auto), but setting the switch to ZSTD_ps_enable
-   * or ZSTD_ps_disable allow for a force enable/disable the feature.
-   */
-  ZSTD_ps_auto = 0,         /* Let the library automatically determine whether the feature shall be enabled */
-  ZSTD_ps_enable = 1,       /* Force-enable the feature */
-  ZSTD_ps_disable = 2       /* Do not use the feature */
-} ZSTD_paramSwitch_e;
-
-/***************************************
-*  Frame header and size functions
-***************************************/
-
-/*! ZSTD_findDecompressedSize() :
- *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
- *  `srcSize` must be the _exact_ size of this series
- *       (i.e. there should be a frame boundary at `src + srcSize`)
- *  @return : - decompressed size of all data in all successive frames
- *            - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN
- *            - if an error occurred: ZSTD_CONTENTSIZE_ERROR
- *
- *   note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.
- *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *   note 2 : decompressed size is always present when compression is done with ZSTD_compress()
- *   note 3 : decompressed size can be very large (64-bits value),
- *            potentially larger than what local system can handle as a single memory segment.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *   note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.
- *            Always ensure result fits within application's authorized limits.
- *            Each application can set its own limits.
- *   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
- *            read each contained frame header.  This is fast as most of the data is skipped,
- *            however it does mean that all frame data must be present and valid. */
-ZSTDLIB_STATIC_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);
-
-/*! ZSTD_decompressBound() :
- *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
- *  `srcSize` must be the _exact_ size of this series
- *       (i.e. there should be a frame boundary at `src + srcSize`)
- *  @return : - upper-bound for the decompressed size of all data in all successive frames
- *            - if an error occurred: ZSTD_CONTENTSIZE_ERROR
- *
- *  note 1  : an error can occur if `src` contains an invalid or incorrectly formatted frame.
- *  note 2  : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`.
- *            in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value.
- *  note 3  : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:
- *              upper-bound = # blocks * min(128 KB, Window_Size)
- */
-ZSTDLIB_STATIC_API unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize);
-
-/*! ZSTD_frameHeaderSize() :
- *  srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX.
- * @return : size of the Frame Header,
- *           or an error code (if srcSize is too small) */
-ZSTDLIB_STATIC_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);
-
-typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
-typedef struct {
-    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
-    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */
-    unsigned blockSizeMax;
-    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
-    unsigned headerSize;
-    unsigned dictID;
-    unsigned checksumFlag;
-    unsigned _reserved1;
-    unsigned _reserved2;
-} ZSTD_frameHeader;
-
-/*! ZSTD_getFrameHeader() :
- *  decode Frame Header, or requires larger `srcSize`.
- * @return : 0, `zfhPtr` is correctly filled,
- *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
- *           or an error code, which can be tested using ZSTD_isError() */
-ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
-/*! ZSTD_getFrameHeader_advanced() :
- *  same as ZSTD_getFrameHeader(),
- *  with added capability to select a format (like ZSTD_f_zstd1_magicless) */
-ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
-
-/*! ZSTD_decompressionMargin() :
- * Zstd supports in-place decompression, where the input and output buffers overlap.
- * In this case, the output buffer must be at least (Margin + Output_Size) bytes large,
- * and the input buffer must be at the end of the output buffer.
- *
- *  _______________________ Output Buffer ________________________
- * |                                                              |
- * |                                        ____ Input Buffer ____|
- * |                                       |                      |
- * v                                       v                      v
- * |---------------------------------------|-----------|----------|
- * ^                                                   ^          ^
- * |___________________ Output_Size ___________________|_ Margin _|
- *
- * NOTE: See also ZSTD_DECOMPRESSION_MARGIN().
- * NOTE: This applies only to single-pass decompression through ZSTD_decompress() or
- * ZSTD_decompressDCtx().
- * NOTE: This function supports multi-frame input.
- *
- * @param src The compressed frame(s)
- * @param srcSize The size of the compressed frame(s)
- * @returns The decompression margin or an error that can be checked with ZSTD_isError().
- */
-ZSTDLIB_STATIC_API size_t ZSTD_decompressionMargin(const void* src, size_t srcSize);
-
-/*! ZSTD_DECOMPRESS_MARGIN() :
- * Similar to ZSTD_decompressionMargin(), but instead of computing the margin from
- * the compressed frame, compute it from the original size and the blockSizeLog.
- * See ZSTD_decompressionMargin() for details.
- *
- * WARNING: This macro does not support multi-frame input, the input must be a single
- * zstd frame. If you need that support use the function, or implement it yourself.
- *
- * @param originalSize The original uncompressed size of the data.
- * @param blockSize    The block size == MIN(windowSize, ZSTD_BLOCKSIZE_MAX).
- *                     Unless you explicitly set the windowLog smaller than
- *                     ZSTD_BLOCKSIZELOG_MAX you can just use ZSTD_BLOCKSIZE_MAX.
- */
-#define ZSTD_DECOMPRESSION_MARGIN(originalSize, blockSize) ((size_t)(                                              \
-        ZSTD_FRAMEHEADERSIZE_MAX                                                              /* Frame header */ + \
-        4                                                                                         /* checksum */ + \
-        ((originalSize) == 0 ? 0 : 3 * (((originalSize) + (blockSize) - 1) / blockSize)) /* 3 bytes per block */ + \
-        (blockSize)                                                                    /* One block of margin */   \
-    ))
-
-typedef enum {
-  ZSTD_sf_noBlockDelimiters = 0,         /* Representation of ZSTD_Sequence has no block delimiters, sequences only */
-  ZSTD_sf_explicitBlockDelimiters = 1    /* Representation of ZSTD_Sequence contains explicit block delimiters */
-} ZSTD_sequenceFormat_e;
-
-/*! ZSTD_sequenceBound() :
- * `srcSize` : size of the input buffer
- *  @return : upper-bound for the number of sequences that can be generated
- *            from a buffer of srcSize bytes
- *
- *  note : returns number of sequences - to get bytes, multiply by sizeof(ZSTD_Sequence).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_sequenceBound(size_t srcSize);
-
-/*! ZSTD_generateSequences() :
- * WARNING: This function is meant for debugging and informational purposes ONLY!
- * Its implementation is flawed, and it will be deleted in a future version.
- * It is not guaranteed to succeed, as there are several cases where it will give
- * up and fail. You should NOT use this function in production code.
- *
- * This function is deprecated, and will be removed in a future version.
- *
- * Generate sequences using ZSTD_compress2(), given a source buffer.
- *
- * @param zc The compression context to be used for ZSTD_compress2(). Set any
- *           compression parameters you need on this context.
- * @param outSeqs The output sequences buffer of size @p outSeqsSize
- * @param outSeqsSize The size of the output sequences buffer.
- *                    ZSTD_sequenceBound(srcSize) is an upper bound on the number
- *                    of sequences that can be generated.
- * @param src The source buffer to generate sequences from of size @p srcSize.
- * @param srcSize The size of the source buffer.
- *
- * Each block will end with a dummy sequence
- * with offset == 0, matchLength == 0, and litLength == length of last literals.
- * litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0)
- * simply acts as a block delimiter.
- *
- * @returns The number of sequences generated, necessarily less than
- *          ZSTD_sequenceBound(srcSize), or an error code that can be checked
- *          with ZSTD_isError().
- */
-ZSTD_DEPRECATED("For debugging only, will be replaced by ZSTD_extractSequences()")
-ZSTDLIB_STATIC_API size_t
-ZSTD_generateSequences(ZSTD_CCtx* zc,
-                       ZSTD_Sequence* outSeqs, size_t outSeqsSize,
-                       const void* src, size_t srcSize);
-
-/*! ZSTD_mergeBlockDelimiters() :
- * Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals
- * by merging them into the literals of the next sequence.
- *
- * As such, the final generated result has no explicit representation of block boundaries,
- * and the final last literals segment is not represented in the sequences.
- *
- * The output of this function can be fed into ZSTD_compressSequences() with CCtx
- * setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters
- * @return : number of sequences left after merging
- */
-ZSTDLIB_STATIC_API size_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, size_t seqsSize);
-
-/*! ZSTD_compressSequences() :
- * Compress an array of ZSTD_Sequence, associated with @src buffer, into dst.
- * @src contains the entire input (not just the literals).
- * If @srcSize > sum(sequence.length), the remaining bytes are considered all literals
- * If a dictionary is included, then the cctx should reference the dict. (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.)
- * The entire source is compressed into a single frame.
- *
- * The compression behavior changes based on cctx params. In particular:
- *    If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain
- *    no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on
- *    the block size derived from the cctx, and sequences may be split. This is the default setting.
- *
- *    If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain
- *    block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided.
- *
- *    If ZSTD_c_validateSequences == 0, this function will blindly accept the sequences provided. Invalid sequences cause undefined
- *    behavior. If ZSTD_c_validateSequences == 1, then if sequence is invalid (see doc/zstd_compression_format.md for
- *    specifics regarding offset/matchlength requirements) then the function will bail out and return an error.
- *
- *    In addition to the two adjustable experimental params, there are other important cctx params.
- *    - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN.
- *    - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression.
- *    - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset
- *      is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md
- *
- * Note: Repcodes are, as of now, always re-calculated within this function, so ZSTD_Sequence::rep is unused.
- * Note 2: Once we integrate ability to ingest repcodes, the explicit block delims mode must respect those repcodes exactly,
- *         and cannot emit an RLE block that disagrees with the repcode history
- * @return : final compressed size, or a ZSTD error code.
- */
-ZSTDLIB_STATIC_API size_t
-ZSTD_compressSequences( ZSTD_CCtx* cctx, void* dst, size_t dstSize,
-                        const ZSTD_Sequence* inSeqs, size_t inSeqsSize,
-                        const void* src, size_t srcSize);
-
-
-/*! ZSTD_writeSkippableFrame() :
- * Generates a zstd skippable frame containing data given by src, and writes it to dst buffer.
- *
- * Skippable frames begin with a 4-byte magic number. There are 16 possible choices of magic number,
- * ranging from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15.
- * As such, the parameter magicVariant controls the exact skippable frame magic number variant used, so
- * the magic number used will be ZSTD_MAGIC_SKIPPABLE_START + magicVariant.
- *
- * Returns an error if destination buffer is not large enough, if the source size is not representable
- * with a 4-byte unsigned int, or if the parameter magicVariant is greater than 15 (and therefore invalid).
- *
- * @return : number of bytes written or a ZSTD error.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,
-                                            const void* src, size_t srcSize, unsigned magicVariant);
-
-/*! ZSTD_readSkippableFrame() :
- * Retrieves a zstd skippable frame containing data given by src, and writes it to dst buffer.
- *
- * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written,
- * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START.  This can be NULL if the caller is not interested
- * in the magicVariant.
- *
- * Returns an error if destination buffer is not large enough, or if the frame is not skippable.
- *
- * @return : number of bytes written or a ZSTD error.
- */
-ZSTDLIB_API size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity, unsigned* magicVariant,
-                                            const void* src, size_t srcSize);
-
-/*! ZSTD_isSkippableFrame() :
- *  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.
- */
-ZSTDLIB_API unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size);
-
-
-
-/***************************************
-*  Memory management
-***************************************/
-
-/*! ZSTD_estimate*() :
- *  These functions make it possible to estimate memory usage
- *  of a future {D,C}Ctx, before its creation.
- *  This is useful in combination with ZSTD_initStatic(),
- *  which makes it possible to employ a static buffer for ZSTD_CCtx* state.
- *
- *  ZSTD_estimateCCtxSize() will provide a memory budget large enough
- *  to compress data of any size using one-shot compression ZSTD_compressCCtx() or ZSTD_compress2()
- *  associated with any compression level up to max specified one.
- *  The estimate will assume the input may be arbitrarily large,
- *  which is the worst case.
- *
- *  Note that the size estimation is specific for one-shot compression,
- *  it is not valid for streaming (see ZSTD_estimateCStreamSize*())
- *  nor other potential ways of using a ZSTD_CCtx* state.
- *
- *  When srcSize can be bound by a known and rather "small" value,
- *  this knowledge can be used to provide a tighter budget estimation
- *  because the ZSTD_CCtx* state will need less memory for small inputs.
- *  This tighter estimation can be provided by employing more advanced functions
- *  ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),
- *  and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter().
- *  Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits.
- *
- *  Note : only single-threaded compression is supported.
- *  ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize(int maxCompressionLevel);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateDCtxSize(void);
-
-/*! ZSTD_estimateCStreamSize() :
- *  ZSTD_estimateCStreamSize() will provide a memory budget large enough for streaming compression
- *  using any compression level up to the max specified one.
- *  It will also consider src size to be arbitrarily "large", which is a worst case scenario.
- *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
- *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
- *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
- *  Note : CStream size estimation is only correct for single-threaded compression.
- *  ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.
- *  Note 2 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time.
- *  Size estimates assume that no external sequence producer is registered.
- *
- *  ZSTD_DStream memory budget depends on frame's window Size.
- *  This information can be passed manually, using ZSTD_estimateDStreamSize,
- *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
- *  Any frame requesting a window size larger than max specified one will be rejected.
- *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
- *         an internal ?Dict will be created, which additional size is not estimated here.
- *         In this case, get total size by adding ZSTD_estimate?DictSize
- */
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize(int maxCompressionLevel);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize(size_t maxWindowSize);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
-
-/*! ZSTD_estimate?DictSize() :
- *  ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict().
- *  ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().
- *  Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);
-ZSTDLIB_STATIC_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);
-
-/*! ZSTD_initStatic*() :
- *  Initialize an object using a pre-allocated fixed-size buffer.
- *  workspace: The memory area to emplace the object into.
- *             Provided pointer *must be 8-bytes aligned*.
- *             Buffer must outlive object.
- *  workspaceSize: Use ZSTD_estimate*Size() to determine
- *                 how large workspace must be to support target scenario.
- * @return : pointer to object (same address as workspace, just different type),
- *           or NULL if error (size too small, incorrect alignment, etc.)
- *  Note : zstd will never resize nor malloc() when using a static buffer.
- *         If the object requires more memory than available,
- *         zstd will just error out (typically ZSTD_error_memory_allocation).
- *  Note 2 : there is no corresponding "free" function.
- *           Since workspace is allocated externally, it must be freed externally too.
- *  Note 3 : cParams : use ZSTD_getCParams() to convert a compression level
- *           into its associated cParams.
- *  Limitation 1 : currently not compatible with internal dictionary creation, triggered by
- *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
- *  Limitation 2 : static cctx currently not compatible with multi-threading.
- *  Limitation 3 : static dctx is incompatible with legacy support.
- */
-ZSTDLIB_STATIC_API ZSTD_CCtx*    ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);
-ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
-
-ZSTDLIB_STATIC_API ZSTD_DCtx*    ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize);
-ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */
-
-ZSTDLIB_STATIC_API const ZSTD_CDict* ZSTD_initStaticCDict(
-                                        void* workspace, size_t workspaceSize,
-                                        const void* dict, size_t dictSize,
-                                        ZSTD_dictLoadMethod_e dictLoadMethod,
-                                        ZSTD_dictContentType_e dictContentType,
-                                        ZSTD_compressionParameters cParams);
-
-ZSTDLIB_STATIC_API const ZSTD_DDict* ZSTD_initStaticDDict(
-                                        void* workspace, size_t workspaceSize,
-                                        const void* dict, size_t dictSize,
-                                        ZSTD_dictLoadMethod_e dictLoadMethod,
-                                        ZSTD_dictContentType_e dictContentType);
-
-
-/*! Custom memory allocation :
- *  These prototypes make it possible to pass your own allocation/free functions.
- *  ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.
- *  All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones.
- */
-typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
-typedef void  (*ZSTD_freeFunction) (void* opaque, void* address);
-typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
-static
-#ifdef __GNUC__
-__attribute__((__unused__))
-#endif
-ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL };  /**< this constant defers to stdlib's functions */
-
-ZSTDLIB_STATIC_API ZSTD_CCtx*    ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
-ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
-ZSTDLIB_STATIC_API ZSTD_DCtx*    ZSTD_createDCtx_advanced(ZSTD_customMem customMem);
-ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
-
-ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize,
-                                                  ZSTD_dictLoadMethod_e dictLoadMethod,
-                                                  ZSTD_dictContentType_e dictContentType,
-                                                  ZSTD_compressionParameters cParams,
-                                                  ZSTD_customMem customMem);
-
-/*! Thread pool :
- *  These prototypes make it possible to share a thread pool among multiple compression contexts.
- *  This can limit resources for applications with multiple threads where each one uses
- *  a threaded compression mode (via ZSTD_c_nbWorkers parameter).
- *  ZSTD_createThreadPool creates a new thread pool with a given number of threads.
- *  Note that the lifetime of such pool must exist while being used.
- *  ZSTD_CCtx_refThreadPool assigns a thread pool to a context (use NULL argument value
- *  to use an internal thread pool).
- *  ZSTD_freeThreadPool frees a thread pool, accepts NULL pointer.
- */
-typedef struct POOL_ctx_s ZSTD_threadPool;
-ZSTDLIB_STATIC_API ZSTD_threadPool* ZSTD_createThreadPool(size_t numThreads);
-ZSTDLIB_STATIC_API void ZSTD_freeThreadPool (ZSTD_threadPool* pool);  /* accept NULL pointer */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_refThreadPool(ZSTD_CCtx* cctx, ZSTD_threadPool* pool);
-
-
-/*
- * This API is temporary and is expected to change or disappear in the future!
- */
-ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_advanced2(
-    const void* dict, size_t dictSize,
-    ZSTD_dictLoadMethod_e dictLoadMethod,
-    ZSTD_dictContentType_e dictContentType,
-    const ZSTD_CCtx_params* cctxParams,
-    ZSTD_customMem customMem);
-
-ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_advanced(
-    const void* dict, size_t dictSize,
-    ZSTD_dictLoadMethod_e dictLoadMethod,
-    ZSTD_dictContentType_e dictContentType,
-    ZSTD_customMem customMem);
-
-
-/***************************************
-*  Advanced compression functions
-***************************************/
-
-/*! ZSTD_createCDict_byReference() :
- *  Create a digested dictionary for compression
- *  Dictionary content is just referenced, not duplicated.
- *  As a consequence, `dictBuffer` **must** outlive CDict,
- *  and its content must remain unmodified throughout the lifetime of CDict.
- *  note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef */
-ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);
-
-/*! ZSTD_getCParams() :
- * @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.
- * `estimatedSrcSize` value is optional, select 0 if not known */
-ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
-
-/*! ZSTD_getParams() :
- *  same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
- *  All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */
-ZSTDLIB_STATIC_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
-
-/*! ZSTD_checkCParams() :
- *  Ensure param values remain within authorized range.
- * @return 0 on success, or an error code (can be checked with ZSTD_isError()) */
-ZSTDLIB_STATIC_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
-
-/*! ZSTD_adjustCParams() :
- *  optimize params for a given `srcSize` and `dictSize`.
- * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.
- * `dictSize` must be `0` when there is no dictionary.
- *  cPar can be invalid : all parameters will be clamped within valid range in the @return struct.
- *  This function never fails (wide contract) */
-ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);
-
-/*! ZSTD_CCtx_setCParams() :
- *  Set all parameters provided within @p cparams into the working @p cctx.
- *  Note : if modifying parameters during compression (MT mode only),
- *         note that changes to the .windowLog parameter will be ignored.
- * @return 0 on success, or an error code (can be checked with ZSTD_isError()).
- *         On failure, no parameters are updated.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setCParams(ZSTD_CCtx* cctx, ZSTD_compressionParameters cparams);
-
-/*! ZSTD_CCtx_setFParams() :
- *  Set all parameters provided within @p fparams into the working @p cctx.
- * @return 0 on success, or an error code (can be checked with ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams);
-
-/*! ZSTD_CCtx_setParams() :
- *  Set all parameters provided within @p params into the working @p cctx.
- * @return 0 on success, or an error code (can be checked with ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParams(ZSTD_CCtx* cctx, ZSTD_parameters params);
-
-/*! ZSTD_compress_advanced() :
- *  Note : this function is now DEPRECATED.
- *         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters.
- *  This prototype will generate compilation warnings. */
-ZSTD_DEPRECATED("use ZSTD_compress2")
-ZSTDLIB_STATIC_API
-size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize,
-                        const void* dict,size_t dictSize,
-                              ZSTD_parameters params);
-
-/*! ZSTD_compress_usingCDict_advanced() :
- *  Note : this function is now DEPRECATED.
- *         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters.
- *  This prototype will generate compilation warnings. */
-ZSTD_DEPRECATED("use ZSTD_compress2 with ZSTD_CCtx_loadDictionary")
-ZSTDLIB_STATIC_API
-size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
-                                              void* dst, size_t dstCapacity,
-                                        const void* src, size_t srcSize,
-                                        const ZSTD_CDict* cdict,
-                                              ZSTD_frameParameters fParams);
-
-
-/*! ZSTD_CCtx_loadDictionary_byReference() :
- *  Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.
- *  It saves some memory, but also requires that `dict` outlives its usage within `cctx` */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
-
-/*! ZSTD_CCtx_loadDictionary_advanced() :
- *  Same as ZSTD_CCtx_loadDictionary(), but gives finer control over
- *  how to load the dictionary (by copy ? by reference ?)
- *  and how to interpret it (automatic ? force raw mode ? full mode only ?) */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
-
-/*! ZSTD_CCtx_refPrefix_advanced() :
- *  Same as ZSTD_CCtx_refPrefix(), but gives finer control over
- *  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);
-
-/* ===   experimental parameters   === */
-/* these parameters can be used with ZSTD_setParameter()
- * they are not guaranteed to remain supported in the future */
-
- /* Enables rsyncable mode,
-  * which makes compressed files more rsync friendly
-  * by adding periodic synchronization points to the compressed data.
-  * The target average block size is ZSTD_c_jobSize / 2.
-  * It's possible to modify the job size to increase or decrease
-  * the granularity of the synchronization point.
-  * Once the jobSize is smaller than the window size,
-  * it will result in compression ratio degradation.
-  * NOTE 1: rsyncable mode only works when multithreading is enabled.
-  * NOTE 2: rsyncable performs poorly in combination with long range mode,
-  * since it will decrease the effectiveness of synchronization points,
-  * though mileage may vary.
-  * NOTE 3: Rsyncable mode limits maximum compression speed to ~400 MB/s.
-  * If the selected compression level is already running significantly slower,
-  * the overall speed won't be significantly impacted.
-  */
- #define ZSTD_c_rsyncable ZSTD_c_experimentalParam1
-
-/* Select a compression format.
- * The value must be of type ZSTD_format_e.
- * See ZSTD_format_e enum definition for details */
-#define ZSTD_c_format ZSTD_c_experimentalParam2
-
-/* Force back-reference distances to remain < windowSize,
- * even when referencing into Dictionary content (default:0) */
-#define ZSTD_c_forceMaxWindow ZSTD_c_experimentalParam3
-
-/* Controls whether the contents of a CDict
- * are used in place, or copied into the working context.
- * Accepts values from the ZSTD_dictAttachPref_e enum.
- * See the comments on that enum for an explanation of the feature. */
-#define ZSTD_c_forceAttachDict ZSTD_c_experimentalParam4
-
-/* Controlled with ZSTD_paramSwitch_e enum.
- * Default is ZSTD_ps_auto.
- * Set to ZSTD_ps_disable to never compress literals.
- * Set to ZSTD_ps_enable to always compress literals. (Note: uncompressed literals
- * may still be emitted if huffman is not beneficial to use.)
- *
- * By default, in ZSTD_ps_auto, the library will decide at runtime whether to use
- * literals compression based on the compression parameters - specifically,
- * negative compression levels do not use literal compression.
- */
-#define ZSTD_c_literalCompressionMode ZSTD_c_experimentalParam5
-
-/* User's best guess of source size.
- * Hint is not valid when srcSizeHint == 0.
- * There is no guarantee that hint is close to actual source size,
- * but compression ratio may regress significantly if guess considerably underestimates */
-#define ZSTD_c_srcSizeHint ZSTD_c_experimentalParam7
-
-/* Controls whether the new and experimental "dedicated dictionary search
- * structure" can be used. This feature is still rough around the edges, be
- * prepared for surprising behavior!
- *
- * How to use it:
- *
- * When using a CDict, whether to use this feature or not is controlled at
- * CDict creation, and it must be set in a CCtxParams set passed into that
- * construction (via ZSTD_createCDict_advanced2()). A compression will then
- * use the feature or not based on how the CDict was constructed; the value of
- * this param, set in the CCtx, will have no effect.
- *
- * However, when a dictionary buffer is passed into a CCtx, such as via
- * ZSTD_CCtx_loadDictionary(), this param can be set on the CCtx to control
- * whether the CDict that is created internally can use the feature or not.
- *
- * What it does:
- *
- * Normally, the internal data structures of the CDict are analogous to what
- * would be stored in a CCtx after compressing the contents of a dictionary.
- * To an approximation, a compression using a dictionary can then use those
- * data structures to simply continue what is effectively a streaming
- * compression where the simulated compression of the dictionary left off.
- * Which is to say, the search structures in the CDict are normally the same
- * format as in the CCtx.
- *
- * It is possible to do better, since the CDict is not like a CCtx: the search
- * structures are written once during CDict creation, and then are only read
- * after that, while the search structures in the CCtx are both read and
- * written as the compression goes along. This means we can choose a search
- * structure for the dictionary that is read-optimized.
- *
- * This feature enables the use of that different structure.
- *
- * Note that some of the members of the ZSTD_compressionParameters struct have
- * different semantics and constraints in the dedicated search structure. It is
- * highly recommended that you simply set a compression level in the CCtxParams
- * you pass into the CDict creation call, and avoid messing with the cParams
- * directly.
- *
- * Effects:
- *
- * This will only have any effect when the selected ZSTD_strategy
- * implementation supports this feature. Currently, that's limited to
- * ZSTD_greedy, ZSTD_lazy, and ZSTD_lazy2.
- *
- * Note that this means that the CDict tables can no longer be copied into the
- * CCtx, so the dict attachment mode ZSTD_dictForceCopy will no longer be
- * usable. The dictionary can only be attached or reloaded.
- *
- * In general, you should expect compression to be faster--sometimes very much
- * so--and CDict creation to be slightly slower. Eventually, we will probably
- * make this mode the default.
- */
-#define ZSTD_c_enableDedicatedDictSearch ZSTD_c_experimentalParam8
-
-/* ZSTD_c_stableInBuffer
- * Experimental parameter.
- * Default is 0 == disabled. Set to 1 to enable.
- *
- * Tells the compressor that input data presented with ZSTD_inBuffer
- * will ALWAYS be the same between calls.
- * Technically, the @src pointer must never be changed,
- * and the @pos field can only be updated by zstd.
- * However, it's possible to increase the @size field,
- * allowing scenarios where more data can be appended after compressions starts.
- * These conditions are checked by the compressor,
- * and compression will fail if they are not respected.
- * Also, data in the ZSTD_inBuffer within the range [src, src + pos)
- * MUST not be modified during compression or it will result in data corruption.
- *
- * When this flag is enabled zstd won't allocate an input window buffer,
- * because the user guarantees it can reference the ZSTD_inBuffer until
- * the frame is complete. But, it will still allocate an output buffer
- * large enough to fit a block (see ZSTD_c_stableOutBuffer). This will also
- * avoid the memcpy() from the input buffer to the input window buffer.
- *
- * NOTE: So long as the ZSTD_inBuffer always points to valid memory, using
- * this flag is ALWAYS memory safe, and will never access out-of-bounds
- * memory. However, compression WILL fail if conditions are not respected.
- *
- * WARNING: The data in the ZSTD_inBuffer in the range [src, src + pos) MUST
- * not be modified during compression or it will result in data corruption.
- * This is because zstd needs to reference data in the ZSTD_inBuffer to find
- * matches. Normally zstd maintains its own window buffer for this purpose,
- * but passing this flag tells zstd to rely on user provided buffer instead.
- */
-#define ZSTD_c_stableInBuffer ZSTD_c_experimentalParam9
-
-/* ZSTD_c_stableOutBuffer
- * Experimental parameter.
- * Default is 0 == disabled. Set to 1 to enable.
- *
- * Tells he compressor that the ZSTD_outBuffer will not be resized between
- * calls. Specifically: (out.size - out.pos) will never grow. This gives the
- * compressor the freedom to say: If the compressed data doesn't fit in the
- * output buffer then return ZSTD_error_dstSizeTooSmall. This allows us to
- * always decompress directly into the output buffer, instead of decompressing
- * into an internal buffer and copying to the output buffer.
- *
- * When this flag is enabled zstd won't allocate an output buffer, because
- * it can write directly to the ZSTD_outBuffer. It will still allocate the
- * input window buffer (see ZSTD_c_stableInBuffer).
- *
- * Zstd will check that (out.size - out.pos) never grows and return an error
- * if it does. While not strictly necessary, this should prevent surprises.
- */
-#define ZSTD_c_stableOutBuffer ZSTD_c_experimentalParam10
-
-/* ZSTD_c_blockDelimiters
- * Default is 0 == ZSTD_sf_noBlockDelimiters.
- *
- * For use with sequence compression API: ZSTD_compressSequences().
- *
- * Designates whether or not the given array of ZSTD_Sequence contains block delimiters
- * and last literals, which are defined as sequences with offset == 0 and matchLength == 0.
- * See the definition of ZSTD_Sequence for more specifics.
- */
-#define ZSTD_c_blockDelimiters ZSTD_c_experimentalParam11
-
-/* ZSTD_c_validateSequences
- * Default is 0 == disabled. Set to 1 to enable sequence validation.
- *
- * For use with sequence compression API: ZSTD_compressSequences().
- * Designates whether or not we validate sequences provided to ZSTD_compressSequences()
- * during function execution.
- *
- * Without validation, providing a sequence that does not conform to the zstd spec will cause
- * undefined behavior, and may produce a corrupted block.
- *
- * With validation enabled, if sequence is invalid (see doc/zstd_compression_format.md for
- * specifics regarding offset/matchlength requirements) then the function will bail out and
- * return an error.
- *
- */
-#define ZSTD_c_validateSequences ZSTD_c_experimentalParam12
-
-/* ZSTD_c_useBlockSplitter
- * Controlled with ZSTD_paramSwitch_e enum.
- * Default is ZSTD_ps_auto.
- * Set to ZSTD_ps_disable to never use block splitter.
- * Set to ZSTD_ps_enable to always use block splitter.
- *
- * By default, in ZSTD_ps_auto, the library will decide at runtime whether to use
- * block splitting based on the compression parameters.
- */
-#define ZSTD_c_useBlockSplitter ZSTD_c_experimentalParam13
-
-/* ZSTD_c_useRowMatchFinder
- * Controlled with ZSTD_paramSwitch_e enum.
- * Default is ZSTD_ps_auto.
- * Set to ZSTD_ps_disable to never use row-based matchfinder.
- * Set to ZSTD_ps_enable to force usage of row-based matchfinder.
- *
- * By default, in ZSTD_ps_auto, the library will decide at runtime whether to use
- * the row-based matchfinder based on support for SIMD instructions and the window log.
- * Note that this only pertains to compression strategies: greedy, lazy, and lazy2
- */
-#define ZSTD_c_useRowMatchFinder ZSTD_c_experimentalParam14
-
-/* ZSTD_c_deterministicRefPrefix
- * Default is 0 == disabled. Set to 1 to enable.
- *
- * Zstd produces different results for prefix compression when the prefix is
- * directly adjacent to the data about to be compressed vs. when it isn't.
- * This is because zstd detects that the two buffers are contiguous and it can
- * use a more efficient match finding algorithm. However, this produces different
- * results than when the two buffers are non-contiguous. This flag forces zstd
- * to always load the prefix in non-contiguous mode, even if it happens to be
- * adjacent to the data, to guarantee determinism.
- *
- * If you really care about determinism when using a dictionary or prefix,
- * like when doing delta compression, you should select this option. It comes
- * at a speed penalty of about ~2.5% if the dictionary and data happened to be
- * contiguous, and is free if they weren't contiguous. We don't expect that
- * intentionally making the dictionary and data contiguous will be worth the
- * cost to memcpy() the data.
- */
-#define ZSTD_c_deterministicRefPrefix ZSTD_c_experimentalParam15
-
-/* ZSTD_c_prefetchCDictTables
- * Controlled with ZSTD_paramSwitch_e enum. Default is ZSTD_ps_auto.
- *
- * In some situations, zstd uses CDict tables in-place rather than copying them
- * into the working context. (See docs on ZSTD_dictAttachPref_e above for details).
- * In such situations, compression speed is seriously impacted when CDict tables are
- * "cold" (outside CPU cache). This parameter instructs zstd to prefetch CDict tables
- * when they are used in-place.
- *
- * For sufficiently small inputs, the cost of the prefetch will outweigh the benefit.
- * For sufficiently large inputs, zstd will by default memcpy() CDict tables
- * into the working context, so there is no need to prefetch. This parameter is
- * targeted at a middle range of input sizes, where a prefetch is cheap enough to be
- * useful but memcpy() is too expensive. The exact range of input sizes where this
- * makes sense is best determined by careful experimentation.
- *
- * Note: for this parameter, ZSTD_ps_auto is currently equivalent to ZSTD_ps_disable,
- * but in the future zstd may conditionally enable this feature via an auto-detection
- * heuristic for cold CDicts.
- * Use ZSTD_ps_disable to opt out of prefetching under any circumstances.
- */
-#define ZSTD_c_prefetchCDictTables ZSTD_c_experimentalParam16
-
-/* ZSTD_c_enableSeqProducerFallback
- * Allowed values are 0 (disable) and 1 (enable). The default setting is 0.
- *
- * Controls whether zstd will fall back to an internal sequence producer if an
- * external sequence producer is registered and returns an error code. This fallback
- * is block-by-block: the internal sequence producer will only be called for blocks
- * where the external sequence producer returns an error code. Fallback parsing will
- * follow any other cParam settings, such as compression level, the same as in a
- * normal (fully-internal) compression operation.
- *
- * The user is strongly encouraged to read the full Block-Level Sequence Producer API
- * documentation (below) before setting this parameter. */
-#define ZSTD_c_enableSeqProducerFallback ZSTD_c_experimentalParam17
-
-/* ZSTD_c_maxBlockSize
- * Allowed values are between 1KB and ZSTD_BLOCKSIZE_MAX (128KB).
- * The default is ZSTD_BLOCKSIZE_MAX, and setting to 0 will set to the default.
- *
- * This parameter can be used to set an upper bound on the blocksize
- * that overrides the default ZSTD_BLOCKSIZE_MAX. It cannot be used to set upper
- * bounds greater than ZSTD_BLOCKSIZE_MAX or bounds lower than 1KB (will make
- * compressBound() inaccurate). Only currently meant to be used for testing.
- *
- */
-#define ZSTD_c_maxBlockSize ZSTD_c_experimentalParam18
-
-/* ZSTD_c_searchForExternalRepcodes
- * This parameter affects how zstd parses external sequences, such as sequences
- * provided through the compressSequences() API or from an external block-level
- * sequence producer.
- *
- * If set to ZSTD_ps_enable, the library will check for repeated offsets in
- * external sequences, even if those repcodes are not explicitly indicated in
- * the "rep" field. Note that this is the only way to exploit repcode matches
- * while using compressSequences() or an external sequence producer, since zstd
- * currently ignores the "rep" field of external sequences.
- *
- * If set to ZSTD_ps_disable, the library will not exploit repeated offsets in
- * external sequences, regardless of whether the "rep" field has been set. This
- * reduces sequence compression overhead by about 25% while sacrificing some
- * compression ratio.
- *
- * The default value is ZSTD_ps_auto, for which the library will enable/disable
- * based on compression level.
- *
- * Note: for now, this param only has an effect if ZSTD_c_blockDelimiters is
- * set to ZSTD_sf_explicitBlockDelimiters. That may change in the future.
- */
-#define ZSTD_c_searchForExternalRepcodes ZSTD_c_experimentalParam19
-
-/*! ZSTD_CCtx_getParameter() :
- *  Get the requested compression parameter value, selected by enum ZSTD_cParameter,
- *  and store it into int* value.
- * @return : 0, or an error code (which can be tested with ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_getParameter(const ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value);
-
-
-/*! ZSTD_CCtx_params :
- *  Quick howto :
- *  - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure
- *  - ZSTD_CCtxParams_setParameter() : Push parameters one by one into
- *                                     an existing ZSTD_CCtx_params structure.
- *                                     This is similar to
- *                                     ZSTD_CCtx_setParameter().
- *  - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to
- *                                    an existing CCtx.
- *                                    These parameters will be applied to
- *                                    all subsequent frames.
- *  - ZSTD_compressStream2() : Do compression using the CCtx.
- *  - ZSTD_freeCCtxParams() : Free the memory, accept NULL pointer.
- *
- *  This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()
- *  for static allocation of CCtx for single-threaded compression.
- */
-ZSTDLIB_STATIC_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void);
-ZSTDLIB_STATIC_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);  /* accept NULL pointer */
-
-/*! ZSTD_CCtxParams_reset() :
- *  Reset params to default values.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);
-
-/*! ZSTD_CCtxParams_init() :
- *  Initializes the compression parameters of cctxParams according to
- *  compression level. All other parameters are reset to their default values.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);
-
-/*! ZSTD_CCtxParams_init_advanced() :
- *  Initializes the compression and frame parameters of cctxParams according to
- *  params. All other parameters are reset to their default values.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params);
-
-/*! ZSTD_CCtxParams_setParameter() : Requires v1.4.0+
- *  Similar to ZSTD_CCtx_setParameter.
- *  Set one compression parameter, selected by enum ZSTD_cParameter.
- *  Parameters must be applied to a ZSTD_CCtx using
- *  ZSTD_CCtx_setParametersUsingCCtxParams().
- * @result : a code representing success or failure (which can be tested with
- *           ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);
-
-/*! ZSTD_CCtxParams_getParameter() :
- * Similar to ZSTD_CCtx_getParameter.
- * Get the requested value of one compression parameter, selected by enum ZSTD_cParameter.
- * @result : 0, or an error code (which can be tested with ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_getParameter(const ZSTD_CCtx_params* params, ZSTD_cParameter param, int* value);
-
-/*! ZSTD_CCtx_setParametersUsingCCtxParams() :
- *  Apply a set of ZSTD_CCtx_params to the compression context.
- *  This can be done even after compression is started,
- *    if nbWorkers==0, this will have no impact until a new compression is started.
- *    if nbWorkers>=1, new parameters will be picked up at next job,
- *       with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParametersUsingCCtxParams(
-        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);
-
-/*! ZSTD_compressStream2_simpleArgs() :
- *  Same as ZSTD_compressStream2(),
- *  but using only integral types as arguments.
- *  This variant might be helpful for binders from dynamic languages
- *  which have troubles handling structures containing memory pointers.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_compressStream2_simpleArgs (
-                            ZSTD_CCtx* cctx,
-                            void* dst, size_t dstCapacity, size_t* dstPos,
-                      const void* src, size_t srcSize, size_t* srcPos,
-                            ZSTD_EndDirective endOp);
-
-
-/***************************************
-*  Advanced decompression functions
-***************************************/
-
-/*! ZSTD_isFrame() :
- *  Tells if the content of `buffer` starts with a valid Frame Identifier.
- *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
- *  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
- *  Note 3 : Skippable Frame Identifiers are considered valid. */
-ZSTDLIB_STATIC_API unsigned ZSTD_isFrame(const void* buffer, size_t size);
-
-/*! ZSTD_createDDict_byReference() :
- *  Create a digested dictionary, ready to start decompression operation without startup delay.
- *  Dictionary content is referenced, and therefore stays in dictBuffer.
- *  It is important that dictBuffer outlives DDict,
- *  it must remain read accessible throughout the lifetime of DDict */
-ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);
-
-/*! ZSTD_DCtx_loadDictionary_byReference() :
- *  Same as ZSTD_DCtx_loadDictionary(),
- *  but references `dict` content instead of copying it into `dctx`.
- *  This saves memory if `dict` remains around.,
- *  However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */
-ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
-
-/*! ZSTD_DCtx_loadDictionary_advanced() :
- *  Same as ZSTD_DCtx_loadDictionary(),
- *  but gives direct control over
- *  how to load the dictionary (by copy ? by reference ?)
- *  and how to interpret it (automatic ? force raw mode ? full mode only ?). */
-ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
-
-/*! ZSTD_DCtx_refPrefix_advanced() :
- *  Same as ZSTD_DCtx_refPrefix(), but gives finer control over
- *  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
-ZSTDLIB_STATIC_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);
-
-/*! ZSTD_DCtx_setMaxWindowSize() :
- *  Refuses allocating internal buffers for frames requiring a window size larger than provided limit.
- *  This protects a decoder context from reserving too much memory for itself (potential attack scenario).
- *  This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
- *  By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)
- * @return : 0, or an error code (which can be tested using ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);
-
-/*! ZSTD_DCtx_getParameter() :
- *  Get the requested decompression parameter value, selected by enum ZSTD_dParameter,
- *  and store it into int* value.
- * @return : 0, or an error code (which can be tested with ZSTD_isError()).
- */
-ZSTDLIB_STATIC_API size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value);
-
-/* ZSTD_d_format
- * experimental parameter,
- * allowing selection between ZSTD_format_e input compression formats
- */
-#define ZSTD_d_format ZSTD_d_experimentalParam1
-/* ZSTD_d_stableOutBuffer
- * Experimental parameter.
- * Default is 0 == disabled. Set to 1 to enable.
- *
- * Tells the decompressor that the ZSTD_outBuffer will ALWAYS be the same
- * between calls, except for the modifications that zstd makes to pos (the
- * caller must not modify pos). This is checked by the decompressor, and
- * decompression will fail if it ever changes. Therefore the ZSTD_outBuffer
- * MUST be large enough to fit the entire decompressed frame. This will be
- * checked when the frame content size is known. The data in the ZSTD_outBuffer
- * in the range [dst, dst + pos) MUST not be modified during decompression
- * or you will get data corruption.
- *
- * When this flag is enabled zstd won't allocate an output buffer, because
- * it can write directly to the ZSTD_outBuffer, but it will still allocate
- * an input buffer large enough to fit any compressed block. This will also
- * avoid the memcpy() from the internal output buffer to the ZSTD_outBuffer.
- * If you need to avoid the input buffer allocation use the buffer-less
- * streaming API.
- *
- * NOTE: So long as the ZSTD_outBuffer always points to valid memory, using
- * this flag is ALWAYS memory safe, and will never access out-of-bounds
- * memory. However, decompression WILL fail if you violate the preconditions.
- *
- * WARNING: The data in the ZSTD_outBuffer in the range [dst, dst + pos) MUST
- * not be modified during decompression or you will get data corruption. This
- * is because zstd needs to reference data in the ZSTD_outBuffer to regenerate
- * matches. Normally zstd maintains its own buffer for this purpose, but passing
- * this flag tells zstd to use the user provided buffer.
- */
-#define ZSTD_d_stableOutBuffer ZSTD_d_experimentalParam2
-
-/* ZSTD_d_forceIgnoreChecksum
- * Experimental parameter.
- * Default is 0 == disabled. Set to 1 to enable
- *
- * Tells the decompressor to skip checksum validation during decompression, regardless
- * of whether checksumming was specified during compression. This offers some
- * slight performance benefits, and may be useful for debugging.
- * Param has values of type ZSTD_forceIgnoreChecksum_e
- */
-#define ZSTD_d_forceIgnoreChecksum ZSTD_d_experimentalParam3
-
-/* ZSTD_d_refMultipleDDicts
- * Experimental parameter.
- * Default is 0 == disabled. Set to 1 to enable
- *
- * If enabled and dctx is allocated on the heap, then additional memory will be allocated
- * to store references to multiple ZSTD_DDict. That is, multiple calls of ZSTD_refDDict()
- * using a given ZSTD_DCtx, rather than overwriting the previous DDict reference, will instead
- * store all references. At decompression time, the appropriate dictID is selected
- * from the set of DDicts based on the dictID in the frame.
- *
- * Usage is simply calling ZSTD_refDDict() on multiple dict buffers.
- *
- * Param has values of byte ZSTD_refMultipleDDicts_e
- *
- * WARNING: Enabling this parameter and calling ZSTD_DCtx_refDDict(), will trigger memory
- * allocation for the hash table. ZSTD_freeDCtx() also frees this memory.
- * Memory is allocated as per ZSTD_DCtx::customMem.
- *
- * Although this function allocates memory for the table, the user is still responsible for
- * memory management of the underlying ZSTD_DDict* themselves.
- */
-#define ZSTD_d_refMultipleDDicts ZSTD_d_experimentalParam4
-
-/* ZSTD_d_disableHuffmanAssembly
- * Set to 1 to disable the Huffman assembly implementation.
- * The default value is 0, which allows zstd to use the Huffman assembly
- * implementation if available.
- *
- * This parameter can be used to disable Huffman assembly at runtime.
- * If you want to disable it at compile time you can define the macro
- * ZSTD_DISABLE_ASM.
- */
-#define ZSTD_d_disableHuffmanAssembly ZSTD_d_experimentalParam5
-
-/* ZSTD_d_maxBlockSize
- * Allowed values are between 1KB and ZSTD_BLOCKSIZE_MAX (128KB).
- * The default is ZSTD_BLOCKSIZE_MAX, and setting to 0 will set to the default.
- *
- * Forces the decompressor to reject blocks whose content size is
- * larger than the configured maxBlockSize. When maxBlockSize is
- * larger than the windowSize, the windowSize is used instead.
- * This saves memory on the decoder when you know all blocks are small.
- *
- * This option is typically used in conjunction with ZSTD_c_maxBlockSize.
- *
- * WARNING: This causes the decoder to reject otherwise valid frames
- * that have block sizes larger than the configured maxBlockSize.
- */
-#define ZSTD_d_maxBlockSize ZSTD_d_experimentalParam6
-
-
-/*! ZSTD_DCtx_setFormat() :
- *  This function is REDUNDANT. Prefer ZSTD_DCtx_setParameter().
- *  Instruct the decoder context about what kind of data to decode next.
- *  This instruction is mandatory to decode data without a fully-formed header,
- *  such ZSTD_f_zstd1_magicless for example.
- * @return : 0, or an error code (which can be tested using ZSTD_isError()). */
-ZSTD_DEPRECATED("use ZSTD_DCtx_setParameter() instead")
-ZSTDLIB_STATIC_API
-size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);
-
-/*! ZSTD_decompressStream_simpleArgs() :
- *  Same as ZSTD_decompressStream(),
- *  but using only integral types as arguments.
- *  This can be helpful for binders from dynamic languages
- *  which have troubles handling structures containing memory pointers.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_decompressStream_simpleArgs (
-                            ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity, size_t* dstPos,
-                      const void* src, size_t srcSize, size_t* srcPos);
-
-
-/********************************************************************
-*  Advanced streaming functions
-*  Warning : most of these functions are now redundant with the Advanced API.
-*  Once Advanced API reaches "stable" status,
-*  redundant functions will be deprecated, and then at some point removed.
-********************************************************************/
-
-/*=====   Advanced Streaming compression functions  =====*/
-
-/*! ZSTD_initCStream_srcSize() :
- * This function is DEPRECATED, and equivalent to:
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)
- *     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
- *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
- *
- * pledgedSrcSize must be correct. If it is not known at init time, use
- * ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,
- * "0" also disables frame content size field. It may be enabled in the future.
- * This prototype will generate compilation warnings.
- */
-ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API
-size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,
-                         int compressionLevel,
-                         unsigned long long pledgedSrcSize);
-
-/*! ZSTD_initCStream_usingDict() :
- * This function is DEPRECATED, and is equivalent to:
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
- *     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
- *
- * Creates of an internal CDict (incompatible with static CCtx), except if
- * dict == NULL or dictSize < 8, in which case no dict is used.
- * Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if
- * it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.
- * This prototype will generate compilation warnings.
- */
-ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API
-size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
-                     const void* dict, size_t dictSize,
-                           int compressionLevel);
-
-/*! ZSTD_initCStream_advanced() :
- * This function is DEPRECATED, and is equivalent to:
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_setParams(zcs, params);
- *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
- *     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
- *
- * dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy.
- * pledgedSrcSize must be correct.
- * If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
- * This prototype will generate compilation warnings.
- */
-ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API
-size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
-                    const void* dict, size_t dictSize,
-                          ZSTD_parameters params,
-                          unsigned long long pledgedSrcSize);
-
-/*! ZSTD_initCStream_usingCDict() :
- * This function is DEPRECATED, and equivalent to:
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_refCDict(zcs, cdict);
- *
- * note : cdict will just be referenced, and must outlive compression session
- * This prototype will generate compilation warnings.
- */
-ZSTD_DEPRECATED("use ZSTD_CCtx_reset and ZSTD_CCtx_refCDict, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API
-size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
-
-/*! ZSTD_initCStream_usingCDict_advanced() :
- *   This function is DEPRECATED, and is equivalent to:
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_setFParams(zcs, fParams);
- *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
- *     ZSTD_CCtx_refCDict(zcs, cdict);
- *
- * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
- * pledgedSrcSize must be correct. If srcSize is not known at init time, use
- * value ZSTD_CONTENTSIZE_UNKNOWN.
- * This prototype will generate compilation warnings.
- */
-ZSTD_DEPRECATED("use ZSTD_CCtx_reset and ZSTD_CCtx_refCDict, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API
-size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
-                               const ZSTD_CDict* cdict,
-                                     ZSTD_frameParameters fParams,
-                                     unsigned long long pledgedSrcSize);
-
-/*! ZSTD_resetCStream() :
- * This function is DEPRECATED, and is equivalent to:
- *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
- * Note: ZSTD_resetCStream() interprets pledgedSrcSize == 0 as ZSTD_CONTENTSIZE_UNKNOWN, but
- *       ZSTD_CCtx_setPledgedSrcSize() does not do the same, so ZSTD_CONTENTSIZE_UNKNOWN must be
- *       explicitly specified.
- *
- *  start a new frame, using same parameters from previous frame.
- *  This is typically useful to skip dictionary loading stage, since it will reuse it in-place.
- *  Note that zcs must be init at least once before using ZSTD_resetCStream().
- *  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
- *  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
- *  For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
- *  but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.
- * @return : 0, or an error code (which can be tested using ZSTD_isError())
- *  This prototype will generate compilation warnings.
- */
-ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API
-size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
-
-
-typedef struct {
-    unsigned long long ingested;   /* nb input bytes read and buffered */
-    unsigned long long consumed;   /* nb input bytes actually compressed */
-    unsigned long long produced;   /* nb of compressed bytes generated and buffered */
-    unsigned long long flushed;    /* nb of compressed bytes flushed : not provided; can be tracked from caller side */
-    unsigned currentJobID;         /* MT only : latest started job nb */
-    unsigned nbActiveWorkers;      /* MT only : nb of workers actively compressing at probe time */
-} ZSTD_frameProgression;
-
-/* ZSTD_getFrameProgression() :
- * tells how much data has been ingested (read from input)
- * consumed (input actually compressed) and produced (output) for current frame.
- * Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed.
- * Aggregates progression inside active worker threads.
- */
-ZSTDLIB_STATIC_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx);
-
-/*! ZSTD_toFlushNow() :
- *  Tell how many bytes are ready to be flushed immediately.
- *  Useful for multithreading scenarios (nbWorkers >= 1).
- *  Probe the oldest active job, defined as oldest job not yet entirely flushed,
- *  and check its output buffer.
- * @return : amount of data stored in oldest job and ready to be flushed immediately.
- *  if @return == 0, it means either :
- *  + there is no active job (could be checked with ZSTD_frameProgression()), or
- *  + oldest job is still actively compressing data,
- *    but everything it has produced has also been flushed so far,
- *    therefore flush speed is limited by production speed of oldest job
- *    irrespective of the speed of concurrent (and newer) jobs.
- */
-ZSTDLIB_STATIC_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);
-
-
-/*=====   Advanced Streaming decompression functions  =====*/
-
-/*!
- * This function is deprecated, and is equivalent to:
- *
- *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
- *     ZSTD_DCtx_loadDictionary(zds, dict, dictSize);
- *
- * note: no dictionary will be used if dict == NULL or dictSize < 8
- */
-ZSTD_DEPRECATED("use ZSTD_DCtx_reset + ZSTD_DCtx_loadDictionary, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
-
-/*!
- * This function is deprecated, and is equivalent to:
- *
- *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
- *     ZSTD_DCtx_refDDict(zds, ddict);
- *
- * note : ddict is referenced, it must outlive decompression session
- */
-ZSTD_DEPRECATED("use ZSTD_DCtx_reset + ZSTD_DCtx_refDDict, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);
-
-/*!
- * This function is deprecated, and is equivalent to:
- *
- *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
- *
- * reuse decompression parameters from previous init; saves dictionary loading
- */
-ZSTD_DEPRECATED("use ZSTD_DCtx_reset, see zstd.h for detailed instructions")
-ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
-
-
-/* ********************* BLOCK-LEVEL SEQUENCE PRODUCER API *********************
- *
- * *** OVERVIEW ***
- * The Block-Level Sequence Producer API allows users to provide their own custom
- * sequence producer which libzstd invokes to process each block. The produced list
- * of sequences (literals and matches) is then post-processed by libzstd to produce
- * valid compressed blocks.
- *
- * This block-level offload API is a more granular complement of the existing
- * frame-level offload API compressSequences() (introduced in v1.5.1). It offers
- * an easier migration story for applications already integrated with libzstd: the
- * user application continues to invoke the same compression functions
- * ZSTD_compress2() or ZSTD_compressStream2() as usual, and transparently benefits
- * from the specific advantages of the external sequence producer. For example,
- * the sequence producer could be tuned to take advantage of known characteristics
- * of the input, to offer better speed / ratio, or could leverage hardware
- * acceleration not available within libzstd itself.
- *
- * See contrib/externalSequenceProducer for an example program employing the
- * Block-Level Sequence Producer API.
- *
- * *** USAGE ***
- * The user is responsible for implementing a function of type
- * ZSTD_sequenceProducer_F. For each block, zstd will pass the following
- * arguments to the user-provided function:
- *
- *   - sequenceProducerState: a pointer to a user-managed state for the sequence
- *     producer.
- *
- *   - outSeqs, outSeqsCapacity: an output buffer for the sequence producer.
- *     outSeqsCapacity is guaranteed >= ZSTD_sequenceBound(srcSize). The memory
- *     backing outSeqs is managed by the CCtx.
- *
- *   - src, srcSize: an input buffer for the sequence producer to parse.
- *     srcSize is guaranteed to be <= ZSTD_BLOCKSIZE_MAX.
- *
- *   - dict, dictSize: a history buffer, which may be empty, which the sequence
- *     producer may reference as it parses the src buffer. Currently, zstd will
- *     always pass dictSize == 0 into external sequence producers, but this will
- *     change in the future.
- *
- *   - compressionLevel: a signed integer representing the zstd compression level
- *     set by the user for the current operation. The sequence producer may choose
- *     to use this information to change its compression strategy and speed/ratio
- *     tradeoff. Note: the compression level does not reflect zstd parameters set
- *     through the advanced API.
- *
- *   - windowSize: a size_t representing the maximum allowed offset for external
- *     sequences. Note that sequence offsets are sometimes allowed to exceed the
- *     windowSize if a dictionary is present, see doc/zstd_compression_format.md
- *     for details.
- *
- * The user-provided function shall return a size_t representing the number of
- * sequences written to outSeqs. This return value will be treated as an error
- * code if it is greater than outSeqsCapacity. The return value must be non-zero
- * if srcSize is non-zero. The ZSTD_SEQUENCE_PRODUCER_ERROR macro is provided
- * for convenience, but any value greater than outSeqsCapacity will be treated as
- * an error code.
- *
- * If the user-provided function does not return an error code, the sequences
- * written to outSeqs must be a valid parse of the src buffer. Data corruption may
- * occur if the parse is not valid. A parse is defined to be valid if the
- * following conditions hold:
- *   - The sum of matchLengths and literalLengths must equal srcSize.
- *   - All sequences in the parse, except for the final sequence, must have
- *     matchLength >= ZSTD_MINMATCH_MIN. The final sequence must have
- *     matchLength >= ZSTD_MINMATCH_MIN or matchLength == 0.
- *   - All offsets must respect the windowSize parameter as specified in
- *     doc/zstd_compression_format.md.
- *   - If the final sequence has matchLength == 0, it must also have offset == 0.
- *
- * zstd will only validate these conditions (and fail compression if they do not
- * hold) if the ZSTD_c_validateSequences cParam is enabled. Note that sequence
- * validation has a performance cost.
- *
- * If the user-provided function returns an error, zstd will either fall back
- * to an internal sequence producer or fail the compression operation. The user can
- * choose between the two behaviors by setting the ZSTD_c_enableSeqProducerFallback
- * cParam. Fallback compression will follow any other cParam settings, such as
- * compression level, the same as in a normal compression operation.
- *
- * The user shall instruct zstd to use a particular ZSTD_sequenceProducer_F
- * function by calling
- *         ZSTD_registerSequenceProducer(cctx,
- *                                       sequenceProducerState,
- *                                       sequenceProducer)
- * This setting will persist until the next parameter reset of the CCtx.
- *
- * The sequenceProducerState must be initialized by the user before calling
- * ZSTD_registerSequenceProducer(). The user is responsible for destroying the
- * sequenceProducerState.
- *
- * *** LIMITATIONS ***
- * This API is compatible with all zstd compression APIs which respect advanced parameters.
- * However, there are three limitations:
- *
- * First, the ZSTD_c_enableLongDistanceMatching cParam is not currently supported.
- * COMPRESSION WILL FAIL if it is enabled and the user tries to compress with a block-level
- * external sequence producer.
- *   - Note that ZSTD_c_enableLongDistanceMatching is auto-enabled by default in some
- *     cases (see its documentation for details). Users must explicitly set
- *     ZSTD_c_enableLongDistanceMatching to ZSTD_ps_disable in such cases if an external
- *     sequence producer is registered.
- *   - As of this writing, ZSTD_c_enableLongDistanceMatching is disabled by default
- *     whenever ZSTD_c_windowLog < 128MB, but that's subject to change. Users should
- *     check the docs on ZSTD_c_enableLongDistanceMatching whenever the Block-Level Sequence
- *     Producer API is used in conjunction with advanced settings (like ZSTD_c_windowLog).
- *
- * Second, history buffers are not currently supported. Concretely, zstd will always pass
- * dictSize == 0 to the external sequence producer (for now). This has two implications:
- *   - Dictionaries are not currently supported. Compression will *not* fail if the user
- *     references a dictionary, but the dictionary won't have any effect.
- *   - Stream history is not currently supported. All advanced compression APIs, including
- *     streaming APIs, work with external sequence producers, but each block is treated as
- *     an independent chunk without history from previous blocks.
- *
- * Third, multi-threading within a single compression is not currently supported. In other words,
- * COMPRESSION WILL FAIL if ZSTD_c_nbWorkers > 0 and an external sequence producer is registered.
- * Multi-threading across compressions is fine: simply create one CCtx per thread.
- *
- * Long-term, we plan to overcome all three limitations. There is no technical blocker to
- * overcoming them. It is purely a question of engineering effort.
- */
-
-#define ZSTD_SEQUENCE_PRODUCER_ERROR ((size_t)(-1))
-
-typedef size_t (*ZSTD_sequenceProducer_F) (
-  void* sequenceProducerState,
-  ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,
-  const void* src, size_t srcSize,
-  const void* dict, size_t dictSize,
-  int compressionLevel,
-  size_t windowSize
-);
-
-/*! ZSTD_registerSequenceProducer() :
- * Instruct zstd to use a block-level external sequence producer function.
- *
- * The sequenceProducerState must be initialized by the caller, and the caller is
- * responsible for managing its lifetime. This parameter is sticky across
- * compressions. It will remain set until the user explicitly resets compression
- * parameters.
- *
- * Sequence producer registration is considered to be an "advanced parameter",
- * part of the "advanced API". This means it will only have an effect on compression
- * APIs which respect advanced parameters, such as compress2() and compressStream2().
- * Older compression APIs such as compressCCtx(), which predate the introduction of
- * "advanced parameters", will ignore any external sequence producer setting.
- *
- * The sequence producer can be "cleared" by registering a NULL function pointer. This
- * removes all limitations described above in the "LIMITATIONS" section of the API docs.
- *
- * The user is strongly encouraged to read the full API documentation (above) before
- * calling this function. */
-ZSTDLIB_STATIC_API void
-ZSTD_registerSequenceProducer(
-  ZSTD_CCtx* cctx,
-  void* sequenceProducerState,
-  ZSTD_sequenceProducer_F sequenceProducer
-);
-
-/*! ZSTD_CCtxParams_registerSequenceProducer() :
- * Same as ZSTD_registerSequenceProducer(), but operates on ZSTD_CCtx_params.
- * This is used for accurate size estimation with ZSTD_estimateCCtxSize_usingCCtxParams(),
- * which is needed when creating a ZSTD_CCtx with ZSTD_initStaticCCtx().
- *
- * If you are using the external sequence producer API in a scenario where ZSTD_initStaticCCtx()
- * is required, then this function is for you. Otherwise, you probably don't need it.
- *
- * See tests/zstreamtest.c for example usage. */
-ZSTDLIB_STATIC_API void
-ZSTD_CCtxParams_registerSequenceProducer(
-  ZSTD_CCtx_params* params,
-  void* sequenceProducerState,
-  ZSTD_sequenceProducer_F sequenceProducer
-);
-
-
-/*********************************************************************
-*  Buffer-less and synchronous inner streaming functions (DEPRECATED)
-*
-*  This API is deprecated, and will be removed in a future version.
-*  It allows streaming (de)compression with user allocated buffers.
-*  However, it is hard to use, and not as well tested as the rest of
-*  our API.
-*
-*  Please use the normal streaming API instead: ZSTD_compressStream2,
-*  and ZSTD_decompressStream.
-*  If there is functionality that you need, but it doesn't provide,
-*  please open an issue on our GitHub.
-********************************************************************* */
-
-/**
-  Buffer-less streaming compression (synchronous mode)
-
-  A ZSTD_CCtx object is required to track streaming operations.
-  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
-  ZSTD_CCtx object can be reused multiple times within successive compression operations.
-
-  Start by initializing a context.
-  Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression.
-
-  Then, consume your input using ZSTD_compressContinue().
-  There are some important considerations to keep in mind when using this advanced function :
-  - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.
-  - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
-  - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.
-    Worst case evaluation is provided by ZSTD_compressBound().
-    ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
-  - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).
-    It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)
-  - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
-    In which case, it will "discard" the relevant memory section from its history.
-
-  Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
-  It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
-  Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.
-
-  `ZSTD_CCtx` object can be reused (ZSTD_compressBegin()) to compress again.
-*/
-
-/*=====   Buffer-less streaming compression functions  =====*/
-ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
-ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
-ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
-
-ZSTD_DEPRECATED("This function will likely be removed in a future release. It is misleading and has very limited utility.")
-ZSTDLIB_STATIC_API
-size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
-
-ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/* The ZSTD_compressBegin_advanced() and ZSTD_compressBegin_usingCDict_advanced() are now DEPRECATED and will generate a compiler warning */
-ZSTD_DEPRECATED("use advanced API to access custom parameters")
-ZSTDLIB_STATIC_API
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */
-ZSTD_DEPRECATED("use advanced API to access custom parameters")
-ZSTDLIB_STATIC_API
-size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
-/**
-  Buffer-less streaming decompression (synchronous mode)
-
-  A ZSTD_DCtx object is required to track streaming operations.
-  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
-  A ZSTD_DCtx object can be reused multiple times.
-
-  First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
-  Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
-  Data fragment must be large enough to ensure successful decoding.
- `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
-  result  : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
-           >0 : `srcSize` is too small, please provide at least result bytes on next attempt.
-           errorCode, which can be tested using ZSTD_isError().
-
-  It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
-  such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
-  Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
-  As a consequence, check that values remain within valid application range.
-  For example, do not allocate memory blindly, check that `windowSize` is within expectation.
-  Each application can set its own limits, depending on local restrictions.
-  For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.
-
-  ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
-  ZSTD_decompressContinue() is very sensitive to contiguity,
-  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
-  or that previous contiguous segment is large enough to properly handle maximum back-reference distance.
-  There are multiple ways to guarantee this condition.
-
-  The most memory efficient way is to use a round buffer of sufficient size.
-  Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),
-  which can return an error code if required value is too large for current system (in 32-bits mode).
-  In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,
-  up to the moment there is not enough room left in the buffer to guarantee decoding another full block,
-  which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.
-  At which point, decoding can resume from the beginning of the buffer.
-  Note that already decoded data stored in the buffer should be flushed before being overwritten.
-
-  There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.
-
-  Finally, if you control the compression process, you can also ignore all buffer size rules,
-  as long as the encoder and decoder progress in "lock-step",
-  aka use exactly the same buffer sizes, break contiguity at the same place, etc.
-
-  Once buffers are setup, start decompression, with ZSTD_decompressBegin().
-  If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().
-
-  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.
-
-  result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
-  It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.
-  It can also be an error code, which can be tested with ZSTD_isError().
-
-  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
-  Context can then be reset to start a new decompression.
-
-  Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
-  This information is not required to properly decode a frame.
-
-  == Special case : skippable frames ==
-
-  Skippable frames allow integration of user-defined data into a flow of concatenated frames.
-  Skippable frames will be ignored (skipped) by decompressor.
-  The format of skippable frames is as follows :
-  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
-  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
-  c) Frame Content - any content (User Data) of length equal to Frame Size
-  For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
-  For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
-*/
-
-/*=====   Buffer-less streaming decompression functions  =====*/
-
-ZSTDLIB_STATIC_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize);  /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */
-
-ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
-ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
-ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
-
-ZSTDLIB_STATIC_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
-ZSTDLIB_STATIC_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/* misc */
-ZSTD_DEPRECATED("This function will likely be removed in the next minor release. It is misleading and has very limited utility.")
-ZSTDLIB_STATIC_API void   ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
-typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
-ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
-
-
-
-
-/* ========================================= */
-/**       Block level API (DEPRECATED)       */
-/* ========================================= */
-
-/*!
-
-    This API is deprecated in favor of the regular compression API.
-    You can get the frame header down to 2 bytes by setting:
-      - ZSTD_c_format = ZSTD_f_zstd1_magicless
-      - ZSTD_c_contentSizeFlag = 0
-      - ZSTD_c_checksumFlag = 0
-      - ZSTD_c_dictIDFlag = 0
-
-    This API is not as well tested as our normal API, so we recommend not using it.
-    We will be removing it in a future version. If the normal API doesn't provide
-    the functionality you need, please open a GitHub issue.
-
-    Block functions produce and decode raw zstd blocks, without frame metadata.
-    Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).
-    But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.
-
-    A few rules to respect :
-    - Compressing and decompressing require a context structure
-      + Use ZSTD_createCCtx() and ZSTD_createDCtx()
-    - It is necessary to init context before starting
-      + compression : any ZSTD_compressBegin*() variant, including with dictionary
-      + decompression : any ZSTD_decompressBegin*() variant, including with dictionary
-    - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB
-      + If input is larger than a block size, it's necessary to split input data into multiple blocks
-      + For inputs larger than a single block, consider using regular ZSTD_compress() instead.
-        Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block.
-    - When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !
-      ===> In which case, nothing is produced into `dst` !
-      + User __must__ test for such outcome and deal directly with uncompressed data
-      + A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0.
-        Doing so would mess up with statistics history, leading to potential data corruption.
-      + ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!
-      + In case of multiple successive blocks, should some of them be uncompressed,
-        decoder must be informed of their existence in order to follow proper history.
-        Use ZSTD_insertBlock() for such a case.
-*/
-
-/*=====   Raw zstd block functions  =====*/
-ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_getBlockSize   (const ZSTD_CCtx* cctx);
-ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
-ZSTDLIB_STATIC_API size_t ZSTD_insertBlock    (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. */
-
-#endif   /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/allocations.h b/src/duckdb/third_party/zstd/include/zstd/common/allocations.h
deleted file mode 100644
index 0bb1506b9..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/allocations.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* This file provides custom allocation primitives
- */
-#ifndef ZSTD_ALLOCATIONS_H
-#define ZSTD_ALLOCATIONS_H
-
-#define ZSTD_DEPS_NEED_MALLOC
-#include "zstd/common/zstd_deps.h"   /* ZSTD_malloc, ZSTD_calloc, ZSTD_free, ZSTD_memset */
-
-#include "zstd/common/compiler.h" /* MEM_STATIC */
-#define ZSTD_STATIC_LINKING_ONLY
-#include "zstd.h" /* ZSTD_customMem */
-
-namespace duckdb_zstd {
-
-/* custom memory allocation functions */
-
-MEM_STATIC void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem)
-{
-    if (customMem.customAlloc)
-        return customMem.customAlloc(customMem.opaque, size);
-    return ZSTD_malloc(size);
-}
-
-MEM_STATIC void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)
-{
-    if (customMem.customAlloc) {
-        /* calloc implemented as malloc+memset;
-         * not as efficient as calloc, but next best guess for custom malloc */
-        void* const ptr = customMem.customAlloc(customMem.opaque, size);
-        ZSTD_memset(ptr, 0, size);
-        return ptr;
-    }
-    return ZSTD_calloc(1, size);
-}
-
-MEM_STATIC void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)
-{
-    if (ptr!=NULL) {
-        if (customMem.customFree)
-            customMem.customFree(customMem.opaque, ptr);
-        else
-            ZSTD_free(ptr);
-    }
-}
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_ALLOCATIONS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/bits.h b/src/duckdb/third_party/zstd/include/zstd/common/bits.h
deleted file mode 100644
index ecdf916dc..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/bits.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_BITS_H
-#define ZSTD_BITS_H
-
-#include "zstd/common/mem.h"
-
-namespace duckdb_zstd {
-
-MEM_STATIC unsigned ZSTD_countTrailingZeros32_fallback(U32 val)
-{
-    assert(val != 0);
-    {
-        static const U32 DeBruijnBytePos[32] = {0, 1, 28, 2, 29, 14, 24, 3,
-                                                30, 22, 20, 15, 25, 17, 4, 8,
-                                                31, 27, 13, 23, 21, 19, 16, 7,
-                                                26, 12, 18, 6, 11, 5, 10, 9};
-        return DeBruijnBytePos[((U32) ((val & -(S32) val) * 0x077CB531U)) >> 27];
-    }
-}
-
-MEM_STATIC unsigned ZSTD_countTrailingZeros32(U32 val)
-{
-    assert(val != 0);
-#   if defined(_MSC_VER)
-#       if STATIC_BMI2 == 1
-            return (unsigned)_tzcnt_u32(val);
-#       else
-            if (val != 0) {
-                unsigned long r;
-                _BitScanForward(&r, val);
-                return (unsigned)r;
-            } else {
-                /* Should not reach this code path */
-                __assume(0);
-            }
-#       endif
-#   elif defined(__GNUC__) && (__GNUC__ >= 4)
-        return (unsigned)__builtin_ctz(val);
-#   else
-        return ZSTD_countTrailingZeros32_fallback(val);
-#   endif
-}
-
-MEM_STATIC unsigned ZSTD_countLeadingZeros32_fallback(U32 val) {
-    assert(val != 0);
-    {
-        static const U32 DeBruijnClz[32] = {0, 9, 1, 10, 13, 21, 2, 29,
-                                            11, 14, 16, 18, 22, 25, 3, 30,
-                                            8, 12, 20, 28, 15, 17, 24, 7,
-                                            19, 27, 23, 6, 26, 5, 4, 31};
-        val |= val >> 1;
-        val |= val >> 2;
-        val |= val >> 4;
-        val |= val >> 8;
-        val |= val >> 16;
-        return 31 - DeBruijnClz[(val * 0x07C4ACDDU) >> 27];
-    }
-}
-
-MEM_STATIC unsigned ZSTD_countLeadingZeros32(U32 val)
-{
-    assert(val != 0);
-#   if defined(_MSC_VER)
-#       if STATIC_BMI2 == 1
-            return (unsigned)_lzcnt_u32(val);
-#       else
-            if (val != 0) {
-                unsigned long r;
-                _BitScanReverse(&r, val);
-                return (unsigned)(31 - r);
-            } else {
-                /* Should not reach this code path */
-                __assume(0);
-            }
-#       endif
-#   elif defined(__GNUC__) && (__GNUC__ >= 4)
-        return (unsigned)__builtin_clz(val);
-#   else
-        return ZSTD_countLeadingZeros32_fallback(val);
-#   endif
-}
-
-MEM_STATIC unsigned ZSTD_countTrailingZeros64(U64 val)
-{
-    assert(val != 0);
-#   if defined(_MSC_VER) && defined(_WIN64)
-#       if STATIC_BMI2 == 1
-            return (unsigned)_tzcnt_u64(val);
-#       else
-            if (val != 0) {
-                unsigned long r;
-                _BitScanForward64(&r, val);
-                return (unsigned)r;
-            } else {
-                /* Should not reach this code path */
-                __assume(0);
-            }
-#       endif
-#   elif defined(__GNUC__) && (__GNUC__ >= 4) && defined(__LP64__)
-        return (unsigned)__builtin_ctzll(val);
-#   else
-        {
-            U32 mostSignificantWord = (U32)(val >> 32);
-            U32 leastSignificantWord = (U32)val;
-            if (leastSignificantWord == 0) {
-                return 32 + ZSTD_countTrailingZeros32(mostSignificantWord);
-            } else {
-                return ZSTD_countTrailingZeros32(leastSignificantWord);
-            }
-        }
-#   endif
-}
-
-MEM_STATIC unsigned ZSTD_countLeadingZeros64(U64 val)
-{
-    assert(val != 0);
-#   if defined(_MSC_VER) && defined(_WIN64)
-#       if STATIC_BMI2 == 1
-            return (unsigned)_lzcnt_u64(val);
-#       else
-            if (val != 0) {
-                unsigned long r;
-                _BitScanReverse64(&r, val);
-                return (unsigned)(63 - r);
-            } else {
-                /* Should not reach this code path */
-                __assume(0);
-            }
-#       endif
-#   elif defined(__GNUC__) && (__GNUC__ >= 4)
-        return (unsigned)(__builtin_clzll(val));
-#   else
-        {
-            U32 mostSignificantWord = (U32)(val >> 32);
-            U32 leastSignificantWord = (U32)val;
-            if (mostSignificantWord == 0) {
-                return 32 + ZSTD_countLeadingZeros32(leastSignificantWord);
-            } else {
-                return ZSTD_countLeadingZeros32(mostSignificantWord);
-            }
-        }
-#   endif
-}
-
-MEM_STATIC unsigned ZSTD_NbCommonBytes(size_t val)
-{
-    if (MEM_isLittleEndian()) {
-        if (MEM_64bits()) {
-            return ZSTD_countTrailingZeros64((U64)val) >> 3;
-        } else {
-            return ZSTD_countTrailingZeros32((U32)val) >> 3;
-        }
-    } else {  /* Big Endian CPU */
-        if (MEM_64bits()) {
-            return ZSTD_countLeadingZeros64((U64)val) >> 3;
-        } else {
-            return ZSTD_countLeadingZeros32((U32)val) >> 3;
-        }
-    }
-}
-
-MEM_STATIC unsigned ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus */
-{
-    assert(val != 0);
-    return 31 - ZSTD_countLeadingZeros32(val);
-}
-
-/* ZSTD_rotateRight_*():
- * Rotates a bitfield to the right by "count" bits.
- * https://en.wikipedia.org/w/index.php?title=Circular_shift&oldid=991635599#Implementing_circular_shifts
- */
-MEM_STATIC
-U64 ZSTD_rotateRight_U64(U64 const value, U32 count) {
-    assert(count < 64);
-    count &= 0x3F; /* for fickle pattern recognition */
-    return (value >> count) | (U64)(value << ((0U - count) & 0x3F));
-}
-
-MEM_STATIC
-U32 ZSTD_rotateRight_U32(U32 const value, U32 count) {
-    assert(count < 32);
-    count &= 0x1F; /* for fickle pattern recognition */
-    return (value >> count) | (U32)(value << ((0U - count) & 0x1F));
-}
-
-MEM_STATIC
-U16 ZSTD_rotateRight_U16(U16 const value, U32 count) {
-    assert(count < 16);
-    count &= 0x0F; /* for fickle pattern recognition */
-    return (value >> count) | (U16)(value << ((0U - count) & 0x0F));
-}
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_BITS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/bitstream.h b/src/duckdb/third_party/zstd/include/zstd/common/bitstream.h
deleted file mode 100644
index 2b1624295..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/bitstream.h
+++ /dev/null
@@ -1,452 +0,0 @@
-/* ******************************************************************
- * bitstream
- * Part of FSE library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * You can contact the author at :
- * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-#ifndef BITSTREAM_H_MODULE
-#define BITSTREAM_H_MODULE
-
-/*
-*  This API consists of small unitary functions, which must be inlined for best performance.
-*  Since link-time-optimization is not available for all compilers,
-*  these functions are defined into a .h to be included.
-*/
-
-/*-****************************************
-*  Dependencies
-******************************************/
-#include "zstd/common/mem.h"            /* unaligned access routines */
-#include "zstd/common/compiler.h"       /* UNLIKELY() */
-#include "zstd/common/debug.h"          /* assert(), DEBUGLOG(), RAWLOG() */
-#include "zstd/common/error_private.h"  /* error codes and messages */
-#include "zstd/common/bits.h"           /* ZSTD_highbit32 */
-
-/*=========================================
-*  Target specific
-=========================================*/
-#ifndef ZSTD_NO_INTRINSICS
-#  if (defined(__BMI__) || defined(__BMI2__)) && defined(__GNUC__)
-#    include <immintrin.h>   /* support for bextr (experimental)/bzhi */
-#  elif defined(__ICCARM__)
-#    include <intrinsics.h>
-#  endif
-#endif
-
-#define STREAM_ACCUMULATOR_MIN_32  25
-#define STREAM_ACCUMULATOR_MIN_64  57
-#define STREAM_ACCUMULATOR_MIN    ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
-
-namespace duckdb_zstd {
-
-/*-******************************************
-*  bitStream encoding API (write forward)
-********************************************/
-/* bitStream can mix input from multiple sources.
- * A critical property of these streams is that they encode and decode in **reverse** direction.
- * So the first bit sequence you add will be the last to be read, like a LIFO stack.
- */
-typedef struct {
-    size_t bitContainer;
-    unsigned bitPos;
-    char*  startPtr;
-    char*  ptr;
-    char*  endPtr;
-} BIT_CStream_t;
-
-MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
-MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
-MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);
-MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
-
-/* Start with initCStream, providing the size of buffer to write into.
-*  bitStream will never write outside of this buffer.
-*  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
-*
-*  bits are first added to a local register.
-*  Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
-*  Writing data into memory is an explicit operation, performed by the flushBits function.
-*  Hence keep track how many bits are potentially stored into local register to avoid register overflow.
-*  After a flushBits, a maximum of 7 bits might still be stored into local register.
-*
-*  Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers.
-*
-*  Last operation is to close the bitStream.
-*  The function returns the final size of CStream in bytes.
-*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
-*/
-
-
-/*-********************************************
-*  bitStream decoding API (read backward)
-**********************************************/
-typedef size_t BitContainerType;
-typedef struct {
-    BitContainerType bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-    const char* limitPtr;
-} BIT_DStream_t;
-
-typedef enum { BIT_DStream_unfinished = 0,  /* fully refilled */
-               BIT_DStream_endOfBuffer = 1, /* still some bits left in bitstream */
-               BIT_DStream_completed = 2,   /* bitstream entirely consumed, bit-exact */
-               BIT_DStream_overflow = 3     /* user requested more bits than present in bitstream */
-    } BIT_DStream_status;  /* result of BIT_reloadDStream() */
-
-MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
-
-
-/* Start by invoking BIT_initDStream().
-*  A chunk of the bitStream is then stored into a local register.
-*  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (BitContainerType).
-*  You can then retrieve bitFields stored into the local register, **in reverse order**.
-*  Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.
-*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
-*  Otherwise, it can be less than that, so proceed accordingly.
-*  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
-*/
-
-
-/*-****************************************
-*  unsafe API
-******************************************/
-MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
-/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
-
-MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
-/* unsafe version; does not check buffer overflow */
-
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-/*=====    Local Constants   =====*/
-static const unsigned BIT_mask[] = {
-    0,          1,         3,         7,         0xF,       0x1F,
-    0x3F,       0x7F,      0xFF,      0x1FF,     0x3FF,     0x7FF,
-    0xFFF,      0x1FFF,    0x3FFF,    0x7FFF,    0xFFFF,    0x1FFFF,
-    0x3FFFF,    0x7FFFF,   0xFFFFF,   0x1FFFFF,  0x3FFFFF,  0x7FFFFF,
-    0xFFFFFF,   0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF,
-    0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */
-#define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0]))
-
-/*-**************************************************************
-*  bitStream encoding
-****************************************************************/
-/*! BIT_initCStream() :
- *  `dstCapacity` must be > sizeof(size_t)
- *  @return : 0 if success,
- *            otherwise an error code (can be tested using ERR_isError()) */
-MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
-                                  void* startPtr, size_t dstCapacity)
-{
-    bitC->bitContainer = 0;
-    bitC->bitPos = 0;
-    bitC->startPtr = (char*)startPtr;
-    bitC->ptr = bitC->startPtr;
-    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);
-    if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);
-    return 0;
-}
-
-FORCE_INLINE_TEMPLATE size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
-{
-#if defined(STATIC_BMI2) && STATIC_BMI2 == 1 && !defined(ZSTD_NO_INTRINSICS)
-    return  _bzhi_u64(bitContainer, nbBits);
-#else
-    assert(nbBits < BIT_MASK_SIZE);
-    return bitContainer & BIT_mask[nbBits];
-#endif
-}
-
-/*! BIT_addBits() :
- *  can add up to 31 bits into `bitC`.
- *  Note : does not check for register overflow ! */
-MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
-                            size_t value, unsigned nbBits)
-{
-    DEBUG_STATIC_ASSERT(BIT_MASK_SIZE == 32);
-    assert(nbBits < BIT_MASK_SIZE);
-    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
-    bitC->bitContainer |= BIT_getLowerBits(value, nbBits) << bitC->bitPos;
-    bitC->bitPos += nbBits;
-}
-
-/*! BIT_addBitsFast() :
- *  works only if `value` is _clean_,
- *  meaning all high bits above nbBits are 0 */
-MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,
-                                size_t value, unsigned nbBits)
-{
-    assert((value>>nbBits) == 0);
-    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
-    bitC->bitContainer |= value << bitC->bitPos;
-    bitC->bitPos += nbBits;
-}
-
-/*! BIT_flushBitsFast() :
- *  assumption : bitContainer has not overflowed
- *  unsafe version; does not check buffer overflow */
-MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
-{
-    size_t const nbBytes = bitC->bitPos >> 3;
-    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
-    assert(bitC->ptr <= bitC->endPtr);
-    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
-    bitC->ptr += nbBytes;
-    bitC->bitPos &= 7;
-    bitC->bitContainer >>= nbBytes*8;
-}
-
-/*! BIT_flushBits() :
- *  assumption : bitContainer has not overflowed
- *  safe version; check for buffer overflow, and prevents it.
- *  note : does not signal buffer overflow.
- *  overflow will be revealed later on using BIT_closeCStream() */
-MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
-{
-    size_t const nbBytes = bitC->bitPos >> 3;
-    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
-    assert(bitC->ptr <= bitC->endPtr);
-    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
-    bitC->ptr += nbBytes;
-    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
-    bitC->bitPos &= 7;
-    bitC->bitContainer >>= nbBytes*8;
-}
-
-/*! BIT_closeCStream() :
- *  @return : size of CStream, in bytes,
- *            or 0 if it could not fit into dstBuffer */
-MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
-{
-    BIT_addBitsFast(bitC, 1, 1);   /* endMark */
-    BIT_flushBits(bitC);
-    if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */
-    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
-}
-
-
-/*-********************************************************
-*  bitStream decoding
-**********************************************************/
-/*! BIT_initDStream() :
- *  Initialize a BIT_DStream_t.
- * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
- * `srcSize` must be the *exact* size of the bitStream, in bytes.
- * @return : size of stream (== srcSize), or an errorCode if a problem is detected
- */
-MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
-    bitD->start = (const char*)srcBuffer;
-    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
-
-    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-          bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
-          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
-    } else {
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
-        case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
-                ZSTD_FALLTHROUGH;
-
-        case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
-                ZSTD_FALLTHROUGH;
-
-        case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
-                ZSTD_FALLTHROUGH;
-
-        case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;
-                ZSTD_FALLTHROUGH;
-
-        case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;
-                ZSTD_FALLTHROUGH;
-
-        case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;
-                ZSTD_FALLTHROUGH;
-
-        default: break;
-        }
-        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-            bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
-            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
-        }
-        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-FORCE_INLINE_TEMPLATE size_t BIT_getUpperBits(BitContainerType bitContainer, U32 const start)
-{
-    return bitContainer >> start;
-}
-
-FORCE_INLINE_TEMPLATE size_t BIT_getMiddleBits(BitContainerType bitContainer, U32 const start, U32 const nbBits)
-{
-    U32 const regMask = sizeof(bitContainer)*8 - 1;
-    /* if start > regMask, bitstream is corrupted, and result is undefined */
-    assert(nbBits < BIT_MASK_SIZE);
-    /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better
-     * than accessing memory. When bmi2 instruction is not present, we consider
-     * such cpus old (pre-Haswell, 2013) and their performance is not of that
-     * importance.
-     */
-#if defined(__x86_64__) || defined(_M_X86)
-    return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
-#else
-    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
-#endif
-}
-
-/*! BIT_lookBits() :
- *  Provides next n bits from local register.
- *  local register is not modified.
- *  On 32-bits, maxNbBits==24.
- *  On 64-bits, maxNbBits==56.
- * @return : value extracted */
-FORCE_INLINE_TEMPLATE size_t BIT_lookBits(const BIT_DStream_t*  bitD, U32 nbBits)
-{
-    /* arbitrate between double-shift and shift+mask */
-#if 1
-    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
-     * bitstream is likely corrupted, and result is undefined */
-    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
-#else
-    /* this code path is slower on my os-x laptop */
-    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
-#endif
-}
-
-/*! BIT_lookBitsFast() :
- *  unsafe version; only works if nbBits >= 1 */
-MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
-{
-    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
-    assert(nbBits >= 1);
-    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
-}
-
-FORCE_INLINE_TEMPLATE void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-/*! BIT_readBits() :
- *  Read (consume) next n bits from local register and update.
- *  Pay attention to not read more than nbBits contained into local register.
- * @return : extracted value. */
-FORCE_INLINE_TEMPLATE size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
-{
-    size_t const value = BIT_lookBits(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BIT_readBitsFast() :
- *  unsafe version; only works if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
-{
-    size_t const value = BIT_lookBitsFast(bitD, nbBits);
-    assert(nbBits >= 1);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BIT_reloadDStream_internal() :
- *  Simple variant of BIT_reloadDStream(), with two conditions:
- *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
- *  2. look window is valid after shifted down : bitD->ptr >= bitD->start
- */
-MEM_STATIC BIT_DStream_status BIT_reloadDStream_internal(BIT_DStream_t* bitD)
-{
-    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
-    bitD->ptr -= bitD->bitsConsumed >> 3;
-    assert(bitD->ptr >= bitD->start);
-    bitD->bitsConsumed &= 7;
-    bitD->bitContainer = MEM_readLEST(bitD->ptr);
-    return BIT_DStream_unfinished;
-}
-
-/*! BIT_reloadDStreamFast() :
- *  Similar to BIT_reloadDStream(), but with two differences:
- *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
- *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
- *     point you must use BIT_reloadDStream() to reload.
- */
-MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
-{
-    if (UNLIKELY(bitD->ptr < bitD->limitPtr))
-        return BIT_DStream_overflow;
-    return BIT_reloadDStream_internal(bitD);
-}
-
-/*! BIT_reloadDStream() :
- *  Refill `bitD` from buffer previously set in BIT_initDStream() .
- *  This function is safe, it guarantees it will not never beyond src buffer.
- * @return : status of `BIT_DStream_t` internal register.
- *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
-FORCE_INLINE_TEMPLATE BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-{
-    /* note : once in overflow mode, a bitstream remains in this mode until it's reset */
-    if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
-        static const BitContainerType zeroFilled = 0;
-        bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */
-        /* overflow detected, erroneous scenario or end of stream: no update */
-        return BIT_DStream_overflow;
-    }
-
-    assert(bitD->ptr >= bitD->start);
-
-    if (bitD->ptr >= bitD->limitPtr) {
-        return BIT_reloadDStream_internal(bitD);
-    }
-    if (bitD->ptr == bitD->start) {
-        /* reached end of bitStream => no update */
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
-        return BIT_DStream_completed;
-    }
-    /* start < ptr < limitPtr => cautious update */
-    {   U32 nbBytes = bitD->bitsConsumed >> 3;
-        BIT_DStream_status result = BIT_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start) {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BIT_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
-        return result;
-    }
-}
-
-/*! BIT_endOfDStream() :
- * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
- */
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
-{
-    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
-}
-
-} // namespace duckdb_zstd
-
-#endif /* BITSTREAM_H_MODULE */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/compiler.h b/src/duckdb/third_party/zstd/include/zstd/common/compiler.h
deleted file mode 100644
index f880f0b11..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/compiler.h
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_COMPILER_H
-#define ZSTD_COMPILER_H
-
-#include <stddef.h>
-
-#include "zstd/common/portability_macros.h"
-
-/*-*******************************************************
-*  Compiler specifics
-*********************************************************/
-/* force inlining */
-
-#if !defined(ZSTD_NO_INLINE)
-#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#  define INLINE_KEYWORD inline
-#else
-#  define INLINE_KEYWORD
-#endif
-
-#if defined(__GNUC__) || defined(__ICCARM__)
-#  define FORCE_INLINE_ATTR __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#  define FORCE_INLINE_ATTR __forceinline
-#else
-#  define FORCE_INLINE_ATTR
-#endif
-
-#else
-
-#define INLINE_KEYWORD
-#define FORCE_INLINE_ATTR
-
-#endif
-
-/**
-  On MSVC qsort requires that functions passed into it use the __cdecl calling conversion(CC).
-  This explicitly marks such functions as __cdecl so that the code will still compile
-  if a CC other than __cdecl has been made the default.
-*/
-#if  defined(_MSC_VER)
-#  define WIN_CDECL __cdecl
-#else
-#  define WIN_CDECL
-#endif
-
-/* UNUSED_ATTR tells the compiler it is okay if the function is unused. */
-#if defined(__GNUC__)
-#  define UNUSED_ATTR __attribute__((unused))
-#else
-#  define UNUSED_ATTR
-#endif
-
-/**
- * FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
- * parameters. They must be inlined for the compiler to eliminate the constant
- * branches.
- */
-#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR UNUSED_ATTR
-/**
- * HINT_INLINE is used to help the compiler generate better code. It is *not*
- * used for "templates", so it can be tweaked based on the compilers
- * performance.
- *
- * gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the
- * always_inline attribute.
- *
- * clang up to 5.0.0 (trunk) benefit tremendously from the always_inline
- * attribute.
- */
-#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5
-#  define HINT_INLINE static INLINE_KEYWORD
-#else
-#  define HINT_INLINE FORCE_INLINE_TEMPLATE
-#endif
-
-/* "soft" inline :
- * The compiler is free to select if it's a good idea to inline or not.
- * The main objective is to silence compiler warnings
- * when a defined function in included but not used.
- *
- * Note : this macro is prefixed `MEM_` because it used to be provided by `mem.h` unit.
- * Updating the prefix is probably preferable, but requires a fairly large codemod,
- * since this name is used everywhere.
- */
-#ifndef MEM_STATIC  /* already defined in Linux Kernel mem.h */
-#if defined(__GNUC__)
-#  define MEM_STATIC static __inline UNUSED_ATTR
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define MEM_STATIC static inline
-#elif defined(_MSC_VER)
-#  define MEM_STATIC static __inline
-#else
-#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-#endif
-
-/* force no inlining */
-#ifdef _MSC_VER
-#  define FORCE_NOINLINE static __declspec(noinline)
-#else
-#  if defined(__GNUC__) || defined(__ICCARM__)
-#    define FORCE_NOINLINE static __attribute__((__noinline__))
-#  else
-#    define FORCE_NOINLINE static
-#  endif
-#endif
-
-
-/* target attribute */
-#if defined(__GNUC__) || defined(__ICCARM__)
-#  define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))
-#else
-#  define TARGET_ATTRIBUTE(target)
-#endif
-
-/* Target attribute for BMI2 dynamic dispatch.
- * Enable lzcnt, bmi, and bmi2.
- * We test for bmi1 & bmi2. lzcnt is included in bmi1.
- */
-#define BMI2_TARGET_ATTRIBUTE TARGET_ATTRIBUTE("lzcnt,bmi,bmi2")
-
-/* prefetch
- * can be disabled, by declaring NO_PREFETCH build macro */
-#if defined(NO_PREFETCH)
-#  define PREFETCH_L1(ptr)  do { (void)(ptr); } while (0)  /* disabled */
-#  define PREFETCH_L2(ptr)  do { (void)(ptr); } while (0)  /* disabled */
-#else
-#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) && !defined(_M_ARM64EC)  /* _mm_prefetch() is not defined outside of x86/x64 */
-#    include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
-#    define PREFETCH_L1(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
-#    define PREFETCH_L2(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
-#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
-#    define PREFETCH_L1(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)
-#    define PREFETCH_L2(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */)
-#  elif defined(__aarch64__)
-#    define PREFETCH_L1(ptr)  do { __asm__ __volatile__("prfm pldl1keep, %0" ::"Q"(*(ptr))); } while (0)
-#    define PREFETCH_L2(ptr)  do { __asm__ __volatile__("prfm pldl2keep, %0" ::"Q"(*(ptr))); } while (0)
-#  else
-#    define PREFETCH_L1(ptr) do { (void)(ptr); } while (0)  /* disabled */
-#    define PREFETCH_L2(ptr) do { (void)(ptr); } while (0)  /* disabled */
-#  endif
-#endif  /* NO_PREFETCH */
-
-#define CACHELINE_SIZE 64
-
-#define PREFETCH_AREA(p, s)                              \
-    do {                                                 \
-        const char* const _ptr = (const char*)(p);       \
-        size_t const _size = (size_t)(s);                \
-        size_t _pos;                                     \
-        for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \
-            PREFETCH_L2(_ptr + _pos);                    \
-        }                                                \
-    } while (0)
-
-/* vectorization
- * older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax,
- * and some compilers, like Intel ICC and MCST LCC, do not support it at all. */
-#if !defined(__INTEL_COMPILER) && !defined(__clang__) && defined(__GNUC__) && !defined(__LCC__)
-#  if (__GNUC__ == 4 && __GNUC_MINOR__ > 3) || (__GNUC__ >= 5)
-#    define DONT_VECTORIZE __attribute__((optimize("no-tree-vectorize")))
-#  else
-#    define DONT_VECTORIZE _Pragma("GCC optimize(\"no-tree-vectorize\")")
-#  endif
-#else
-#  define DONT_VECTORIZE
-#endif
-
-/* Tell the compiler that a branch is likely or unlikely.
- * Only use these macros if it causes the compiler to generate better code.
- * If you can remove a LIKELY/UNLIKELY annotation without speed changes in gcc
- * and clang, please do.
- */
-#if defined(__GNUC__)
-#define LIKELY(x) (__builtin_expect((x), 1))
-#define UNLIKELY(x) (__builtin_expect((x), 0))
-#else
-#define LIKELY(x) (x)
-#define UNLIKELY(x) (x)
-#endif
-
-#if __has_builtin(__builtin_unreachable) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)))
-#  define ZSTD_UNREACHABLE do { assert(0), __builtin_unreachable(); } while (0)
-#else
-#  define ZSTD_UNREACHABLE do { assert(0); } while (0)
-#endif
-
-/* disable warnings */
-#ifdef _MSC_VER    /* Visual Studio */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#endif
-
-/*Like DYNAMIC_BMI2 but for compile time determination of BMI2 support*/
-#ifndef STATIC_BMI2
-#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))
-#    ifdef __AVX2__  //MSVC does not have a BMI2 specific flag, but every CPU that supports AVX2 also supports BMI2
-#       define STATIC_BMI2 1
-#    endif
-#  elif defined(__BMI2__) && defined(__x86_64__) && defined(__GNUC__)
-#    define STATIC_BMI2 1
-#  endif
-#endif
-
-#ifndef STATIC_BMI2
-    #define STATIC_BMI2 0
-#endif
-
-/* compile time determination of SIMD support */
-#if !defined(ZSTD_NO_INTRINSICS)
-#  if defined(__SSE2__) || defined(_M_AMD64) || (defined (_M_IX86) && defined(_M_IX86_FP) && (_M_IX86_FP >= 2))
-#    define ZSTD_ARCH_X86_SSE2
-#  endif
-#  if defined(__ARM_NEON) || defined(_M_ARM64)
-#    define ZSTD_ARCH_ARM_NEON
-#  endif
-#
-#  if defined(ZSTD_ARCH_X86_SSE2)
-#    include <emmintrin.h>
-#  elif defined(ZSTD_ARCH_ARM_NEON)
-#    include <arm_neon.h>
-#  endif
-#endif
-
-/* C-language Attributes are added in C23. */
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201710L) && defined(__has_c_attribute)
-# define ZSTD_HAS_C_ATTRIBUTE(x) __has_c_attribute(x)
-#else
-# define ZSTD_HAS_C_ATTRIBUTE(x) 0
-#endif
-
-/* Only use C++ attributes in C++. Some compilers report support for C++
- * attributes when compiling with C.
- */
-#if defined(__cplusplus) && defined(__has_cpp_attribute)
-# define ZSTD_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-# define ZSTD_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-/* Define ZSTD_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute.
- * - C23: https://en.cppreference.com/w/c/language/attributes/fallthrough
- * - CPP17: https://en.cppreference.com/w/cpp/language/attributes/fallthrough
- * - Else: __attribute__((__fallthrough__))
- */
-#ifndef ZSTD_FALLTHROUGH
-# define ZSTD_FALLTHROUGH
-#endif
-
-/*-**************************************************************
-*  Alignment check
-*****************************************************************/
-
-/* this test was initially positioned in mem.h,
- * but this file is removed (or replaced) for linux kernel
- * so it's now hosted in compiler.h,
- * which remains valid for both user & kernel spaces.
- */
-
-#ifndef ZSTD_ALIGNOF
-# if defined(__GNUC__) || defined(_MSC_VER)
-/* covers gcc, clang & MSVC */
-/* note : this section must come first, before C11,
- * due to a limitation in the kernel source generator */
-#  define ZSTD_ALIGNOF(T) __alignof(T)
-
-# elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
-/* C11 support */
-#  include <stdalign.h>
-#  define ZSTD_ALIGNOF(T) alignof(T)
-
-# else
-/* No known support for alignof() - imperfect backup */
-#  define ZSTD_ALIGNOF(T) (sizeof(void*) < sizeof(T) ? sizeof(void*) : sizeof(T))
-
-# endif
-#endif /* ZSTD_ALIGNOF */
-
-/*-**************************************************************
-*  Sanitizer
-*****************************************************************/
-
-/**
- * Zstd relies on pointer overflow in its decompressor.
- * We add this attribute to functions that rely on pointer overflow.
- */
-#ifndef ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-#  if __has_attribute(no_sanitize)
-#    if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 8
-       /* gcc < 8 only has signed-integer-overlow which triggers on pointer overflow */
-#      define ZSTD_ALLOW_POINTER_OVERFLOW_ATTR __attribute__((no_sanitize("signed-integer-overflow")))
-#    else
-       /* older versions of clang [3.7, 5.0) will warn that pointer-overflow is ignored. */
-#      define ZSTD_ALLOW_POINTER_OVERFLOW_ATTR __attribute__((no_sanitize("pointer-overflow")))
-#    endif
-#  else
-#    define ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-#  endif
-#endif
-
-namespace duckdb_zstd {
-
-/**
- * Helper function to perform a wrapped pointer difference without trigging
- * UBSAN.
- *
- * @returns lhs - rhs with wrapping
- */
-MEM_STATIC
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-ptrdiff_t ZSTD_wrappedPtrDiff(unsigned char const* lhs, unsigned char const* rhs)
-{
-    return lhs - rhs;
-}
-
-/**
- * Helper function to perform a wrapped pointer add without triggering UBSAN.
- *
- * @return ptr + add with wrapping
- */
-MEM_STATIC
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-unsigned char const* ZSTD_wrappedPtrAdd(unsigned char const* ptr, ptrdiff_t add)
-{
-    return ptr + add;
-}
-
-/**
- * Helper function to perform a wrapped pointer subtraction without triggering
- * UBSAN.
- *
- * @return ptr - sub with wrapping
- */
-MEM_STATIC
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-unsigned char const* ZSTD_wrappedPtrSub(unsigned char const* ptr, ptrdiff_t sub)
-{
-    return ptr - sub;
-}
-
-/**
- * Helper function to add to a pointer that works around C's undefined behavior
- * of adding 0 to NULL.
- *
- * @returns `ptr + add` except it defines `NULL + 0 == NULL`.
- */
-MEM_STATIC
-unsigned char* ZSTD_maybeNullPtrAdd(unsigned char* ptr, ptrdiff_t add)
-{
-    return add > 0 ? ptr + add : ptr;
-}
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_COMPILER_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/cpu.h b/src/duckdb/third_party/zstd/include/zstd/common/cpu.h
deleted file mode 100644
index 892f9851d..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/cpu.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_COMMON_CPU_H
-#define ZSTD_COMMON_CPU_H
-
-/**
- * Implementation taken from folly/CpuId.h
- * https://github.com/facebook/folly/blob/master/folly/CpuId.h
- */
-
-#include "zstd/common/mem.h"
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-namespace duckdb_zstd {
-
-typedef struct {
-    U32 f1c;
-    U32 f1d;
-    U32 f7b;
-    U32 f7c;
-} ZSTD_cpuid_t;
-
-MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {
-    U32 f1c = 0;
-    U32 f1d = 0;
-    U32 f7b = 0;
-    U32 f7c = 0;
-#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
-#if !defined(__clang__)
-    int reg[4];
-    __cpuid((int*)reg, 0);
-    {
-        int const n = reg[0];
-        if (n >= 1) {
-            __cpuid((int*)reg, 1);
-            f1c = (U32)reg[2];
-            f1d = (U32)reg[3];
-        }
-        if (n >= 7) {
-            __cpuidex((int*)reg, 7, 0);
-            f7b = (U32)reg[1];
-            f7c = (U32)reg[2];
-        }
-    }
-#else
-    /* Clang compiler has a bug (fixed in https://reviews.llvm.org/D101338) in
-     * which the `__cpuid` intrinsic does not save and restore `rbx` as it needs
-     * to due to being a reserved register. So in that case, do the `cpuid`
-     * ourselves. Clang supports inline assembly anyway.
-     */
-    U32 n;
-    __asm__(
-        "pushq %%rbx\n\t"
-        "cpuid\n\t"
-        "popq %%rbx\n\t"
-        : "=a"(n)
-        : "a"(0)
-        : "rcx", "rdx");
-    if (n >= 1) {
-      U32 f1a;
-      __asm__(
-          "pushq %%rbx\n\t"
-          "cpuid\n\t"
-          "popq %%rbx\n\t"
-          : "=a"(f1a), "=c"(f1c), "=d"(f1d)
-          : "a"(1)
-          :);
-    }
-    if (n >= 7) {
-      __asm__(
-          "pushq %%rbx\n\t"
-          "cpuid\n\t"
-          "movq %%rbx, %%rax\n\t"
-          "popq %%rbx"
-          : "=a"(f7b), "=c"(f7c)
-          : "a"(7), "c"(0)
-          : "rdx");
-    }
-#endif
-#elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && defined(__GNUC__)
-    /* The following block like the normal cpuid branch below, but gcc
-     * reserves ebx for use of its pic register so we must specially
-     * handle the save and restore to avoid clobbering the register
-     */
-    U32 n;
-    __asm__(
-        "pushl %%ebx\n\t"
-        "cpuid\n\t"
-        "popl %%ebx\n\t"
-        : "=a"(n)
-        : "a"(0)
-        : "ecx", "edx");
-    if (n >= 1) {
-      U32 f1a;
-      __asm__(
-          "pushl %%ebx\n\t"
-          "cpuid\n\t"
-          "popl %%ebx\n\t"
-          : "=a"(f1a), "=c"(f1c), "=d"(f1d)
-          : "a"(1));
-    }
-    if (n >= 7) {
-      __asm__(
-          "pushl %%ebx\n\t"
-          "cpuid\n\t"
-          "movl %%ebx, %%eax\n\t"
-          "popl %%ebx"
-          : "=a"(f7b), "=c"(f7c)
-          : "a"(7), "c"(0)
-          : "edx");
-    }
-#elif defined(__x86_64__) || defined(_M_X64) || defined(__i386__)
-    U32 n;
-    __asm__("cpuid" : "=a"(n) : "a"(0) : "ebx", "ecx", "edx");
-    if (n >= 1) {
-      U32 f1a;
-      __asm__("cpuid" : "=a"(f1a), "=c"(f1c), "=d"(f1d) : "a"(1) : "ebx");
-    }
-    if (n >= 7) {
-      U32 f7a;
-      __asm__("cpuid"
-              : "=a"(f7a), "=b"(f7b), "=c"(f7c)
-              : "a"(7), "c"(0)
-              : "edx");
-    }
-#endif
-    {
-        ZSTD_cpuid_t cpuid;
-        cpuid.f1c = f1c;
-        cpuid.f1d = f1d;
-        cpuid.f7b = f7b;
-        cpuid.f7c = f7c;
-        return cpuid;
-    }
-}
-
-#define X(name, r, bit)                                                        \
-  MEM_STATIC int ZSTD_cpuid_##name(ZSTD_cpuid_t const cpuid) {                 \
-    return ((cpuid.r) & (1U << bit)) != 0;                                     \
-  }
-
-/* cpuid(1): Processor Info and Feature Bits. */
-#define C(name, bit) X(name, f1c, bit)
-  C(sse3, 0)
-  C(pclmuldq, 1)
-  C(dtes64, 2)
-  C(monitor, 3)
-  C(dscpl, 4)
-  C(vmx, 5)
-  C(smx, 6)
-  C(eist, 7)
-  C(tm2, 8)
-  C(ssse3, 9)
-  C(cnxtid, 10)
-  C(fma, 12)
-  C(cx16, 13)
-  C(xtpr, 14)
-  C(pdcm, 15)
-  C(pcid, 17)
-  C(dca, 18)
-  C(sse41, 19)
-  C(sse42, 20)
-  C(x2apic, 21)
-  C(movbe, 22)
-  C(popcnt, 23)
-  C(tscdeadline, 24)
-  C(aes, 25)
-  C(xsave, 26)
-  C(osxsave, 27)
-  C(avx, 28)
-  C(f16c, 29)
-  C(rdrand, 30)
-#undef C
-#define D(name, bit) X(name, f1d, bit)
-  D(fpu, 0)
-  D(vme, 1)
-  D(de, 2)
-  D(pse, 3)
-  D(tsc, 4)
-  D(msr, 5)
-  D(pae, 6)
-  D(mce, 7)
-  D(cx8, 8)
-  D(apic, 9)
-  D(sep, 11)
-  D(mtrr, 12)
-  D(pge, 13)
-  D(mca, 14)
-  D(cmov, 15)
-  D(pat, 16)
-  D(pse36, 17)
-  D(psn, 18)
-  D(clfsh, 19)
-  D(ds, 21)
-  D(acpi, 22)
-  D(mmx, 23)
-  D(fxsr, 24)
-  D(sse, 25)
-  D(sse2, 26)
-  D(ss, 27)
-  D(htt, 28)
-  D(tm, 29)
-  D(pbe, 31)
-#undef D
-
-/* cpuid(7): Extended Features. */
-#define B(name, bit) X(name, f7b, bit)
-  B(bmi1, 3)
-  B(hle, 4)
-  B(avx2, 5)
-  B(smep, 7)
-  B(bmi2, 8)
-  B(erms, 9)
-  B(invpcid, 10)
-  B(rtm, 11)
-  B(mpx, 14)
-  B(avx512f, 16)
-  B(avx512dq, 17)
-  B(rdseed, 18)
-  B(adx, 19)
-  B(smap, 20)
-  B(avx512ifma, 21)
-  B(pcommit, 22)
-  B(clflushopt, 23)
-  B(clwb, 24)
-  B(avx512pf, 26)
-  B(avx512er, 27)
-  B(avx512cd, 28)
-  B(sha, 29)
-  B(avx512bw, 30)
-  B(avx512vl, 31)
-#undef B
-#define C(name, bit) X(name, f7c, bit)
-  C(prefetchwt1, 0)
-  C(avx512vbmi, 1)
-#undef C
-
-#undef X
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_COMMON_CPU_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/debug.h b/src/duckdb/third_party/zstd/include/zstd/common/debug.h
deleted file mode 100644
index 559897771..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/debug.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/* ******************************************************************
- * debug
- * Part of FSE library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * You can contact the author at :
- * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-
-/*
- * The purpose of this header is to enable debug functions.
- * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,
- * and DEBUG_STATIC_ASSERT() for compile-time.
- *
- * By default, DEBUGLEVEL==0, which means run-time debug is disabled.
- *
- * Level 1 enables assert() only.
- * Starting level 2, traces can be generated and pushed to stderr.
- * The higher the level, the more verbose the traces.
- *
- * It's possible to dynamically adjust level using variable g_debug_level,
- * which is only declared if DEBUGLEVEL>=2,
- * and is a global variable, not multi-thread protected (use with care)
- */
-
-#ifndef DEBUG_H_12987983217
-#define DEBUG_H_12987983217
-
-#include "zstd/common/zstd_deps.h" // DuckDB: added here
-
-/* static assert is triggered at compile time, leaving no runtime artefact.
- * static assert only works with compile-time constants.
- * Also, this variant can only be used inside a function. */
-#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])
-
-
-/* DEBUGLEVEL is expected to be defined externally,
- * typically through compiler command line.
- * Value must be a number. */
-#ifndef DEBUGLEVEL
-#  define DEBUGLEVEL 0
-#endif
-
-
-/* recommended values for DEBUGLEVEL :
- * 0 : release mode, no debug, all run-time checks disabled
- * 1 : enables assert() only, no display
- * 2 : reserved, for currently active debug path
- * 3 : events once per object lifetime (CCtx, CDict, etc.)
- * 4 : events once per frame
- * 5 : events once per block
- * 6 : events once per sequence (verbose)
- * 7+: events at every position (*very* verbose)
- *
- * It's generally inconvenient to output traces > 5.
- * In which case, it's possible to selectively trigger high verbosity levels
- * by modifying g_debug_level.
- */
-
-#if (DEBUGLEVEL>=1)
-#  define ZSTD_DEPS_NEED_ASSERT
-// #  include "zstd/common/zstd_deps.h" // DuckDB: comment out otherwise amalgamation won't be happy
-#else
-#  ifndef assert   /* assert may be already defined, due to prior #include <assert.h> */
-#    define assert(condition) ((void)0)   /* disable assert (default) */
-#  endif
-#endif
-
-#if (DEBUGLEVEL>=2)
-#  define ZSTD_DEPS_NEED_IO
-// #  include "zstd/common/zstd_deps.h" // DuckDB: comment out otherwise amalgamation won't be happy
-
-namespace duckdb_zstd {
-
-extern int g_debuglevel; /* the variable is only declared,
-                            it actually lives in debug.c,
-                            and is shared by the whole process.
-                            It's not thread-safe.
-                            It's useful when enabling very verbose levels
-                            on selective conditions (such as position in src) */
-
-#  define RAWLOG(l, ...)                   \
-    do {                                   \
-        if (l<=g_debuglevel) {             \
-            ZSTD_DEBUG_PRINT(__VA_ARGS__); \
-        }                                  \
-    } while (0)
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-#define LINE_AS_STRING TOSTRING(__LINE__)
-
-#  define DEBUGLOG(l, ...)                               \
-    do {                                                 \
-        if (l<=g_debuglevel) {                           \
-            ZSTD_DEBUG_PRINT(__FILE__ ":" LINE_AS_STRING ": " __VA_ARGS__); \
-            ZSTD_DEBUG_PRINT(" \n");                     \
-        }                                                \
-    } while (0)
-
-} // namespace duckdb_zstd
-
-#else
-#  define RAWLOG(l, ...)   do { } while (0)    /* disabled */
-#  define DEBUGLOG(l, ...) do { } while (0)    /* disabled */
-#endif
-
-#endif /* DEBUG_H_12987983217 */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/error_private.h b/src/duckdb/third_party/zstd/include/zstd/common/error_private.h
deleted file mode 100644
index 7fe7701de..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/error_private.h
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* Note : this module is expected to remain private, do not expose it */
-
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-/* ****************************************
-*  Dependencies
-******************************************/
-#include "zstd_errors.h"  /* enum list */
-#include "zstd/common/compiler.h"
-#include "zstd/common/debug.h"
-#include "zstd/common/zstd_deps.h"       /* size_t */
-
-namespace duckdb_zstd {
-
-/* ****************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-/*-****************************************
-*  Customization (error_public.h)
-******************************************/
-typedef ZSTD_ErrorCode ERR_enum;
-#define PREFIX(name) ZSTD_error_##name
-
-
-/*-****************************************
-*  Error codes handling
-******************************************/
-#undef ERROR   /* already defined on Visual Studio */
-#define ERROR(name) ZSTD_ERROR(name)
-#define ZSTD_ERROR(name) ((size_t)-PREFIX(name))
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }
-
-/* check and forward error code */
-#define CHECK_V_F(e, f)     \
-    size_t const e = f;     \
-    do {                    \
-        if (ERR_isError(e)) \
-            return e;       \
-    } while (0)
-#define CHECK_F(f)   do { CHECK_V_F(_var_err__, f); } while (0)
-
-
-/*-****************************************
-*  Error Strings
-******************************************/
-
-const char* ERR_getErrorString(ERR_enum code);   /* error_private.c */
-
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    return ERR_getErrorString(ERR_getErrorCode(code));
-}
-
-/**
- * Ignore: this is an internal helper.
- *
- * This is a helper function to help force C99-correctness during compilation.
- * Under strict compilation modes, variadic macro arguments can't be empty.
- * However, variadic function arguments can be. Using a function therefore lets
- * us statically check that at least one (string) argument was passed,
- * independent of the compilation flags.
- */
-static INLINE_KEYWORD UNUSED_ATTR
-void _force_has_format_string(const char *format, ...) {
-  (void)format;
-}
-
-/**
- * Ignore: this is an internal helper.
- *
- * We want to force this function invocation to be syntactically correct, but
- * we don't want to force runtime evaluation of its arguments.
- */
-#define _FORCE_HAS_FORMAT_STRING(...)              \
-    do {                                           \
-        if (0) {                                   \
-            _force_has_format_string(__VA_ARGS__); \
-        }                                          \
-    } while (0)
-
-#define ERR_QUOTE(str) #str
-
-/**
- * Return the specified error if the condition evaluates to true.
- *
- * In debug modes, prints additional information.
- * In order to do that (particularly, printing the conditional that failed),
- * this can't just wrap RETURN_ERROR().
- */
-#define RETURN_ERROR_IF(cond, err, ...)                                        \
-    do {                                                                       \
-        if (cond) {                                                            \
-            RAWLOG(3, "%s:%d: ERROR!: check %s failed, returning %s",          \
-                  __FILE__, __LINE__, ERR_QUOTE(cond), ERR_QUOTE(ERROR(err))); \
-            _FORCE_HAS_FORMAT_STRING(__VA_ARGS__);                             \
-            RAWLOG(3, ": " __VA_ARGS__);                                       \
-            RAWLOG(3, "\n");                                                   \
-            return ERROR(err);                                                 \
-        }                                                                      \
-    } while (0)
-
-/**
- * Unconditionally return the specified error.
- *
- * In debug modes, prints additional information.
- */
-#define RETURN_ERROR(err, ...)                                               \
-    do {                                                                     \
-        RAWLOG(3, "%s:%d: ERROR!: unconditional check failed, returning %s", \
-              __FILE__, __LINE__, ERR_QUOTE(ERROR(err)));                    \
-        _FORCE_HAS_FORMAT_STRING(__VA_ARGS__);                               \
-        RAWLOG(3, ": " __VA_ARGS__);                                         \
-        RAWLOG(3, "\n");                                                     \
-        return ERROR(err);                                                   \
-    } while(0)
-
-/**
- * If the provided expression evaluates to an error code, returns that error code.
- *
- * In debug modes, prints additional information.
- */
-#define FORWARD_IF_ERROR(err, ...)                                                 \
-    do {                                                                           \
-        size_t const err_code = (err);                                             \
-        if (ERR_isError(err_code)) {                                               \
-            RAWLOG(3, "%s:%d: ERROR!: forwarding error in %s: %s",                 \
-                  __FILE__, __LINE__, ERR_QUOTE(err), ERR_getErrorName(err_code)); \
-            _FORCE_HAS_FORMAT_STRING(__VA_ARGS__);                                 \
-            RAWLOG(3, ": " __VA_ARGS__);                                           \
-            RAWLOG(3, "\n");                                                       \
-            return err_code;                                                       \
-        }                                                                          \
-    } while(0)
-
-} // namespace duckdb_zstd
-
-#endif /* ERROR_H_MODULE */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/fse.h b/src/duckdb/third_party/zstd/include/zstd/common/fse.h
deleted file mode 100644
index 9df59ff14..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/fse.h
+++ /dev/null
@@ -1,637 +0,0 @@
-/* ******************************************************************
- * FSE : Finite State Entropy codec
- * Public Prototypes declaration
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * You can contact the author at :
- * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-
-#ifndef FSE_H
-#define FSE_H
-
-
-/*-*****************************************
-*  Dependencies
-******************************************/
-
-#include "zstd/common/zstd_deps.h"    /* size_t, ptrdiff_t */
-
-namespace duckdb_zstd {
-
-/*-*****************************************
-*  FSE_PUBLIC_API : control library symbols visibility
-******************************************/
-#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
-#  define FSE_PUBLIC_API __attribute__ ((visibility ("default")))
-#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1)   /* Visual expected */
-#  define FSE_PUBLIC_API __declspec(dllexport)
-#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
-#  define FSE_PUBLIC_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define FSE_PUBLIC_API
-#endif
-
-/*------   Version   ------*/
-#define FSE_VERSION_MAJOR    0
-#define FSE_VERSION_MINOR    9
-#define FSE_VERSION_RELEASE  0
-
-#define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE
-#define FSE_QUOTE(str) #str
-#define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str)
-#define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION)
-
-#define FSE_VERSION_NUMBER  (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
-FSE_PUBLIC_API unsigned FSE_versionNumber(void);   /**< library version number; to be used when checking dll version */
-
-
-/*-*****************************************
-*  Tool functions
-******************************************/
-FSE_PUBLIC_API size_t FSE_compressBound(size_t size);       /* maximum compressed size */
-
-/* Error Management */
-FSE_PUBLIC_API unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */
-FSE_PUBLIC_API const char* FSE_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
-
-
-/*-*****************************************
-*  FSE detailed API
-******************************************/
-/*!
-FSE_compress() does the following:
-1. count symbol occurrence from source[] into table count[] (see hist.h)
-2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
-3. save normalized counters to memory buffer using writeNCount()
-4. build encoding table 'CTable' from normalized counters
-5. encode the data stream using encoding table 'CTable'
-
-FSE_decompress() does the following:
-1. read normalized counters with readNCount()
-2. build decoding table 'DTable' from normalized counters
-3. decode the data stream using decoding table 'DTable'
-
-The following API allows targeting specific sub-functions for advanced tasks.
-For example, it's possible to compress several blocks using the same 'CTable',
-or to save and provide normalized distribution using external method.
-*/
-
-/* *** COMPRESSION *** */
-
-/*! FSE_optimalTableLog():
-    dynamically downsize 'tableLog' when conditions are met.
-    It saves CPU time, by using smaller tables, while preserving or even improving compression ratio.
-    @return : recommended tableLog (necessarily <= 'maxTableLog') */
-FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
-
-/*! FSE_normalizeCount():
-    normalize counts so that sum(count[]) == Power_of_2 (2^tableLog)
-    'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1).
-    useLowProbCount is a boolean parameter which trades off compressed size for
-    faster header decoding. When it is set to 1, the compressed data will be slightly
-    smaller. And when it is set to 0, FSE_readNCount() and FSE_buildDTable() will be
-    faster. If you are compressing a small amount of data (< 2 KB) then useLowProbCount=0
-    is a good default, since header deserialization makes a big speed difference.
-    Otherwise, useLowProbCount=1 is a good default, since the speed difference is small.
-    @return : tableLog,
-              or an errorCode, which can be tested using FSE_isError() */
-FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
-                    const unsigned* count, size_t srcSize, unsigned maxSymbolValue, unsigned useLowProbCount);
-
-/*! FSE_NCountWriteBound():
-    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.
-    Typically useful for allocation purpose. */
-FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSE_writeNCount():
-    Compactly save 'normalizedCounter' into 'buffer'.
-    @return : size of the compressed table,
-              or an errorCode, which can be tested using FSE_isError(). */
-FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
-                                 const short* normalizedCounter,
-                                 unsigned maxSymbolValue, unsigned tableLog);
-
-/*! Constructor and Destructor of FSE_CTable.
-    Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
-typedef unsigned FSE_CTable;   /* don't allocate that. It's only meant to be more restrictive than void* */
-
-/*! FSE_buildCTable():
-    Builds `ct`, which must be already allocated, using FSE_createCTable().
-    @return : 0, or an errorCode, which can be tested using FSE_isError() */
-FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSE_compress_usingCTable():
-    Compress `src` using `ct` into `dst` which must be already allocated.
-    @return : size of compressed data (<= `dstCapacity`),
-              or 0 if compressed data could not fit into `dst`,
-              or an errorCode, which can be tested using FSE_isError() */
-FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);
-
-/*!
-Tutorial :
-----------
-The first step is to count all symbols. FSE_count() does this job very fast.
-Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells.
-'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0]
-maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value)
-FSE_count() will return the number of occurrence of the most frequent symbol.
-This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility.
-If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
-
-The next step is to normalize the frequencies.
-FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'.
-It also guarantees a minimum of 1 to any Symbol with frequency >= 1.
-You can use 'tableLog'==0 to mean "use default tableLog value".
-If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(),
-which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default").
-
-The result of FSE_normalizeCount() will be saved into a table,
-called 'normalizedCounter', which is a table of signed short.
-'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells.
-The return value is tableLog if everything proceeded as expected.
-It is 0 if there is a single symbol within distribution.
-If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()).
-
-'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount().
-'buffer' must be already allocated.
-For guaranteed success, buffer size must be at least FSE_headerBound().
-The result of the function is the number of bytes written into 'buffer'.
-If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small).
-
-'normalizedCounter' can then be used to create the compression table 'CTable'.
-The space required by 'CTable' must be already allocated, using FSE_createCTable().
-You can then use FSE_buildCTable() to fill 'CTable'.
-If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()).
-
-'CTable' can then be used to compress 'src', with FSE_compress_usingCTable().
-Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize'
-The function returns the size of compressed data (without header), necessarily <= `dstCapacity`.
-If it returns '0', compressed data could not fit into 'dst'.
-If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
-*/
-
-
-/* *** DECOMPRESSION *** */
-
-/*! FSE_readNCount():
-    Read compactly saved 'normalizedCounter' from 'rBuffer'.
-    @return : size read from 'rBuffer',
-              or an errorCode, which can be tested using FSE_isError().
-              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
-                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
-                           const void* rBuffer, size_t rBuffSize);
-
-/*! FSE_readNCount_bmi2():
- * Same as FSE_readNCount() but pass bmi2=1 when your CPU supports BMI2 and 0 otherwise.
- */
-FSE_PUBLIC_API size_t FSE_readNCount_bmi2(short* normalizedCounter,
-                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
-                           const void* rBuffer, size_t rBuffSize, int bmi2);
-
-typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-
-/*!
-Tutorial :
-----------
-(Note : these functions only decompress FSE-compressed blocks.
- If block is uncompressed, use memcpy() instead
- If block is a single repeated byte, use memset() instead )
-
-The first step is to obtain the normalized frequencies of symbols.
-This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
-'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
-In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
-or size the table to handle worst case situations (typically 256).
-FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
-The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
-Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
-If there is an error, the function will return an error code, which can be tested using FSE_isError().
-
-The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
-This is performed by the function FSE_buildDTable().
-The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
-If there is an error, the function will return an error code, which can be tested using FSE_isError().
-
-`FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable().
-`cSrcSize` must be strictly correct, otherwise decompression will fail.
-FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
-If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
-*/
-
-} // namespace duckdb_zstd
-
-#endif  /* FSE_H */
-
-#if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
-#define FSE_H_FSE_STATIC_LINKING_ONLY
-
-/* *** Dependency *** */
-#include "zstd/common/bitstream.h"
-
-namespace duckdb_zstd {
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* FSE buffer bounds */
-#define FSE_NCOUNTBOUND 512
-#define FSE_BLOCKBOUND(size) ((size) + ((size)>>7) + 4 /* fse states */ + sizeof(size_t) /* bitContainer */)
-#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */
-#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<((maxTableLog)-1)) + (((maxSymbolValue)+1)*2))
-#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<(maxTableLog)))
-
-/* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
-#define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue)   (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
-#define FSE_DTABLE_SIZE(maxTableLog)                   (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
-
-
-/* *****************************************
- *  FSE advanced API
- ***************************************** */
-
-unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
-/**< same as FSE_optimalTableLog(), which used `minus==2` */
-
-size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
-/**< build a fake FSE_CTable, designed to compress always the same symbolValue */
-
-/* FSE_buildCTable_wksp() :
- * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
- * `wkspSize` must be >= `FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog)` of `unsigned`.
- * See FSE_buildCTable_wksp() for breakdown of workspace usage.
- */
-#define FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog) (((maxSymbolValue + 2) + (1ull << (tableLog)))/2 + sizeof(U64)/sizeof(U32) /* additional 8 bytes for potential table overwrite */)
-#define FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSymbolValue, tableLog) (sizeof(unsigned) * FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog))
-size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
-
-#define FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog, maxSymbolValue) (sizeof(short) * (maxSymbolValue + 1) + (1ULL << maxTableLog) + 8)
-#define FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ((FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog, maxSymbolValue) + sizeof(unsigned) - 1) / sizeof(unsigned))
-FSE_PUBLIC_API size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
-/**< Same as FSE_buildDTable(), using an externally allocated `workspace` produced with `FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxSymbolValue)` */
-
-#define FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) (FSE_DTABLE_SIZE_U32(maxTableLog) + 1 + FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) + (FSE_MAX_SYMBOL_VALUE + 1) / 2 + 1)
-#define FSE_DECOMPRESS_WKSP_SIZE(maxTableLog, maxSymbolValue) (FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(unsigned))
-size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2);
-/**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DECOMPRESS_WKSP_SIZE_U32(maxLog, maxSymbolValue)`.
- * Set bmi2 to 1 if your CPU supports BMI2 or 0 if it doesn't */
-
-typedef enum {
-   FSE_repeat_none,  /**< Cannot use the previous table */
-   FSE_repeat_check, /**< Can use the previous table but it must be checked */
-   FSE_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
- } FSE_repeat;
-
-/* *****************************************
-*  FSE symbol compression API
-*******************************************/
-/*!
-   This API consists of small unitary functions, which highly benefit from being inlined.
-   Hence their body are included in next section.
-*/
-typedef struct {
-    ptrdiff_t   value;
-    const void* stateTable;
-    const void* symbolTT;
-    unsigned    stateLog;
-} FSE_CState_t;
-
-static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
-
-static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
-
-static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
-
-/**<
-These functions are inner components of FSE_compress_usingCTable().
-They allow the creation of custom streams, mixing multiple tables and bit sources.
-
-A key property to keep in mind is that encoding and decoding are done **in reverse direction**.
-So the first symbol you will encode is the last you will decode, like a LIFO stack.
-
-You will need a few variables to track your CStream. They are :
-
-FSE_CTable    ct;         // Provided by FSE_buildCTable()
-BIT_CStream_t bitStream;  // bitStream tracking structure
-FSE_CState_t  state;      // State tracking structure (can have several)
-
-
-The first thing to do is to init bitStream and state.
-    size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);
-    FSE_initCState(&state, ct);
-
-Note that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError();
-You can then encode your input data, byte after byte.
-FSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time.
-Remember decoding will be done in reverse direction.
-    FSE_encodeByte(&bitStream, &state, symbol);
-
-At any time, you can also add any bit sequence.
-Note : maximum allowed nbBits is 25, for compatibility with 32-bits decoders
-    BIT_addBits(&bitStream, bitField, nbBits);
-
-The above methods don't commit data to memory, they just store it into local register, for speed.
-Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-Writing data to memory is a manual operation, performed by the flushBits function.
-    BIT_flushBits(&bitStream);
-
-Your last FSE encoding operation shall be to flush your last state value(s).
-    FSE_flushState(&bitStream, &state);
-
-Finally, you must close the bitStream.
-The function returns the size of CStream in bytes.
-If data couldn't fit into dstBuffer, it will return a 0 ( == not compressible)
-If there is an error, it returns an errorCode (which can be tested using FSE_isError()).
-    size_t size = BIT_closeCStream(&bitStream);
-*/
-
-
-/* *****************************************
-*  FSE symbol decompression API
-*******************************************/
-typedef struct {
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSE_DState_t;
-
-
-static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
-
-static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-
-static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
-
-/**<
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
-
-/* *****************************************
-*  FSE unsafe API
-*******************************************/
-static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/* *****************************************
-*  Implementation of inlined functions
-*******************************************/
-typedef struct {
-    int deltaFindState;
-    U32 deltaNbBits;
-} FSE_symbolCompressionTransform; /* total 8 bytes */
-
-MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
-{
-    const void* ptr = ct;
-    const U16* u16ptr = (const U16*) ptr;
-    const U32 tableLog = MEM_read16(ptr);
-    statePtr->value = (ptrdiff_t)1<<tableLog;
-    statePtr->stateTable = u16ptr+2;
-    statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
-    statePtr->stateLog = tableLog;
-}
-
-
-/*! FSE_initCState2() :
-*   Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
-*   uses the smallest state value possible, saving the cost of this symbol */
-MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
-{
-    FSE_initCState(statePtr, ct);
-    {   const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
-        const U16* stateTable = (const U16*)(statePtr->stateTable);
-        U32 nbBitsOut  = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
-        statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
-        statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
-    }
-}
-
-MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
-{
-    FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
-    const U16* const stateTable = (const U16*)(statePtr->stateTable);
-    U32 const nbBitsOut  = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
-    BIT_addBits(bitC,  (size_t)statePtr->value, nbBitsOut);
-    statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
-}
-
-MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
-{
-    BIT_addBits(bitC, (size_t)statePtr->value, statePtr->stateLog);
-    BIT_flushBits(bitC);
-}
-
-
-/* FSE_getMaxNbBits() :
- * Approximate maximum cost of a symbol, in bits.
- * Fractional get rounded up (i.e. a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
- * note 1 : assume symbolValue is valid (<= maxSymbolValue)
- * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
-MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
-{
-    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
-    return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
-}
-
-/* FSE_bitCost() :
- * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
- * note 1 : assume symbolValue is valid (<= maxSymbolValue)
- * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
-MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
-{
-    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
-    U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
-    U32 const threshold = (minNbBits+1) << 16;
-    assert(tableLog < 16);
-    assert(accuracyLog < 31-tableLog);  /* ensure enough room for renormalization double shift */
-    {   U32 const tableSize = 1 << tableLog;
-        U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
-        U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog;   /* linear interpolation (very approximate) */
-        U32 const bitMultiplier = 1 << accuracyLog;
-        assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
-        assert(normalizedDeltaFromThreshold <= bitMultiplier);
-        return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
-    }
-}
-
-
-/* ======    Decompression    ====== */
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSE_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSE_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
-    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
-    BIT_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    return DInfo.symbol;
-}
-
-MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    size_t const lowBits = BIT_readBits(bitD, nbBits);
-    DStatePtr->state = DInfo.newState + lowBits;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BIT_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-/*! FSE_decodeSymbolFast() :
-    unsafe, only works if no symbol has a probability > 50% */
-MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BIT_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 0;
-}
-
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/* **************************************************************
-*  Tuning parameters
-****************************************************************/
-/*!MEMORY_USAGE :
-*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
-*  Increasing memory usage improves compression ratio
-*  Reduced memory usage can improve speed, due to cache effect
-*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
-#ifndef FSE_MAX_MEMORY_USAGE
-#  define FSE_MAX_MEMORY_USAGE 14
-#endif
-#ifndef FSE_DEFAULT_MEMORY_USAGE
-#  define FSE_DEFAULT_MEMORY_USAGE 13
-#endif
-#if (FSE_DEFAULT_MEMORY_USAGE > FSE_MAX_MEMORY_USAGE)
-#  error "FSE_DEFAULT_MEMORY_USAGE must be <= FSE_MAX_MEMORY_USAGE"
-#endif
-
-/*!FSE_MAX_SYMBOL_VALUE :
-*  Maximum symbol value authorized.
-*  Required for proper stack allocation */
-#ifndef FSE_MAX_SYMBOL_VALUE
-#  define FSE_MAX_SYMBOL_VALUE 255
-#endif
-
-/* **************************************************************
-*  template functions type & suffix
-****************************************************************/
-#define FSE_FUNCTION_TYPE BYTE
-#define FSE_FUNCTION_EXTENSION
-#define FSE_DECODE_TYPE FSE_decode_t
-
-
-#endif   /* !FSE_COMMONDEFS_ONLY */
-
-
-/* ***************************************************************
-*  Constants
-*****************************************************************/
-#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
-#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
-#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
-#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
-#define FSE_MIN_TABLELOG 5
-
-#define FSE_TABLELOG_ABSOLUTE_MAX 15
-#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
-#  error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
-#endif
-
-#define FSE_TABLESTEP(tableSize) (((tableSize)>>1) + ((tableSize)>>3) + 3)
-
-} // namespace duckdb_zstd
-
-#endif /* FSE_STATIC_LINKING_ONLY */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/huf.h b/src/duckdb/third_party/zstd/include/zstd/common/huf.h
deleted file mode 100644
index a28595ce6..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/huf.h
+++ /dev/null
@@ -1,282 +0,0 @@
-/* ******************************************************************
- * huff0 huffman codec,
- * part of Finite State Entropy library
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * You can contact the author at :
- * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-
-#ifndef HUF_H_298734234
-#define HUF_H_298734234
-
-/* *** Dependencies *** */
-#include "zstd/common/zstd_deps.h"    /* size_t */
-#include "zstd/common/mem.h"          /* U32 */
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-
-namespace duckdb_zstd {
-
-/* ***   Tool functions *** */
-#define HUF_BLOCKSIZE_MAX (128 * 1024)   /**< maximum input size for a single block compressed with HUF_compress */
-size_t HUF_compressBound(size_t size);   /**< maximum compressed size (worst case) */
-
-/* Error Management */
-unsigned    HUF_isError(size_t code);       /**< tells if a return value is an error code */
-const char* HUF_getErrorName(size_t code);  /**< provides error code string (useful for debugging) */
-
-
-#define HUF_WORKSPACE_SIZE ((8 << 10) + 512 /* sorting scratch space */)
-#define HUF_WORKSPACE_SIZE_U64 (HUF_WORKSPACE_SIZE / sizeof(U64))
-
-/* *** Constants *** */
-#define HUF_TABLELOG_MAX      12      /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_TABLELOG_ABSOLUTEMAX */
-#define HUF_TABLELOG_DEFAULT  11      /* default tableLog value when none specified */
-#define HUF_SYMBOLVALUE_MAX  255
-
-#define HUF_TABLELOG_ABSOLUTEMAX  12  /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
-#if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)
-#  error "HUF_TABLELOG_MAX is too large !"
-#endif
-
-
-/* ****************************************
-*  Static allocation
-******************************************/
-/* HUF buffer bounds */
-#define HUF_CTABLEBOUND 129
-#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true when incompressible is pre-filtered with fast heuristic */
-#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* static allocation of HUF's Compression Table */
-/* this is a private definition, just exposed for allocation and strict aliasing purpose. never EVER access its members directly */
-typedef size_t HUF_CElt;   /* consider it an incomplete type */
-#define HUF_CTABLE_SIZE_ST(maxSymbolValue)   ((maxSymbolValue)+2)   /* Use tables of size_t, for proper alignment */
-#define HUF_CTABLE_SIZE(maxSymbolValue)       (HUF_CTABLE_SIZE_ST(maxSymbolValue) * sizeof(size_t))
-#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
-    HUF_CElt name[HUF_CTABLE_SIZE_ST(maxSymbolValue)] /* no final ; */
-
-/* static allocation of HUF's DTable */
-typedef U32 HUF_DTable;
-#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
-#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
-        HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
-#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
-        HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
-
-
-/* ****************************************
-*  Advanced decompression functions
-******************************************/
-
-/**
- * Huffman flags bitset.
- * For all flags, 0 is the default value.
- */
-typedef enum {
-    /**
-     * If compiled with DYNAMIC_BMI2: Set flag only if the CPU supports BMI2 at runtime.
-     * Otherwise: Ignored.
-     */
-    HUF_flags_bmi2 = (1 << 0),
-    /**
-     * If set: Test possible table depths to find the one that produces the smallest header + encoded size.
-     * If unset: Use heuristic to find the table depth.
-     */
-    HUF_flags_optimalDepth = (1 << 1),
-    /**
-     * If set: If the previous table can encode the input, always reuse the previous table.
-     * If unset: If the previous table can encode the input, reuse the previous table if it results in a smaller output.
-     */
-    HUF_flags_preferRepeat = (1 << 2),
-    /**
-     * If set: Sample the input and check if the sample is uncompressible, if it is then don't attempt to compress.
-     * If unset: Always histogram the entire input.
-     */
-    HUF_flags_suspectUncompressible = (1 << 3),
-    /**
-     * If set: Don't use assembly implementations
-     * If unset: Allow using assembly implementations
-     */
-    HUF_flags_disableAsm = (1 << 4),
-    /**
-     * If set: Don't use the fast decoding loop, always use the fallback decoding loop.
-     * If unset: Use the fast decoding loop when possible.
-     */
-    HUF_flags_disableFast = (1 << 5)
-} HUF_flags_e;
-
-
-/* ****************************************
- *  HUF detailed API
- * ****************************************/
-#define HUF_OPTIMAL_DEPTH_THRESHOLD ZSTD_btultra
-
-/*! HUF_compress() does the following:
- *  1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h")
- *  2. (optional) refine tableLog using HUF_optimalTableLog()
- *  3. build Huffman table from count using HUF_buildCTable()
- *  4. save Huffman table to memory buffer using HUF_writeCTable()
- *  5. encode the data stream using HUF_compress4X_usingCTable()
- *
- *  The following API allows targeting specific sub-functions for advanced tasks.
- *  For example, it's possible to compress several blocks using the same 'CTable',
- *  or to save and regenerate 'CTable' using external methods.
- */
-unsigned HUF_minTableLog(unsigned symbolCardinality);
-unsigned HUF_cardinality(const unsigned* count, unsigned maxSymbolValue);
-unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, void* workSpace,
- size_t wkspSize, HUF_CElt* table, const unsigned* count, int flags); /* table is used as scratch space for building and testing tables, not a return value */
-size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog, void* workspace, size_t workspaceSize);
-size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags);
-size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
-int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
-
-typedef enum {
-   HUF_repeat_none,  /**< Cannot use the previous table */
-   HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */
-   HUF_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
- } HUF_repeat;
-
-/** HUF_compress4X_repeat() :
- *  Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
- *  If it uses hufTable it does not modify hufTable or repeat.
- *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
- *  If preferRepeat then the old table will always be used if valid.
- *  If suspectUncompressible then some sampling checks will be run to potentially skip huffman coding */
-size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
-                       const void* src, size_t srcSize,
-                       unsigned maxSymbolValue, unsigned tableLog,
-                       void* workSpace, size_t wkspSize,    /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
-                       HUF_CElt* hufTable, HUF_repeat* repeat, int flags);
-
-/** HUF_buildCTable_wksp() :
- *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
- * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.
- */
-#define HUF_CTABLE_WORKSPACE_SIZE_U32 ((4 * (HUF_SYMBOLVALUE_MAX + 1)) + 192)
-#define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
-size_t HUF_buildCTable_wksp (HUF_CElt* tree,
-                       const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
-                             void* workSpace, size_t wkspSize);
-
-/*! HUF_readStats() :
- *  Read compact Huffman tree, saved by HUF_writeCTable().
- * `huffWeight` is destination buffer.
- * @return : size read from `src` , or an error Code .
- *  Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
-size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
-                     U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize);
-
-/*! HUF_readStats_wksp() :
- * Same as HUF_readStats() but takes an external workspace which must be
- * 4-byte aligned and its size must be >= HUF_READ_STATS_WORKSPACE_SIZE.
- * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
- */
-#define HUF_READ_STATS_WORKSPACE_SIZE_U32 FSE_DECOMPRESS_WKSP_SIZE_U32(6, HUF_TABLELOG_MAX-1)
-#define HUF_READ_STATS_WORKSPACE_SIZE (HUF_READ_STATS_WORKSPACE_SIZE_U32 * sizeof(unsigned))
-size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize,
-                          U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
-                          const void* src, size_t srcSize,
-                          void* workspace, size_t wkspSize,
-                          int flags);
-
-/** HUF_readCTable() :
- *  Loading a CTable saved with HUF_writeCTable() */
-size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned *hasZeroWeights);
-
-/** HUF_getNbBitsFromCTable() :
- *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX
- *  Note 1 : If symbolValue > HUF_readCTableHeader(symbolTable).maxSymbolValue, returns 0
- *  Note 2 : is not inlined, as HUF_CElt definition is private
- */
-U32 HUF_getNbBitsFromCTable(const HUF_CElt* symbolTable, U32 symbolValue);
-
-typedef struct {
-    BYTE tableLog;
-    BYTE maxSymbolValue;
-    BYTE unused[sizeof(size_t) - 2];
-} HUF_CTableHeader;
-
-/** HUF_readCTableHeader() :
- *  @returns The header from the CTable specifying the tableLog and the maxSymbolValue.
- */
-HUF_CTableHeader HUF_readCTableHeader(HUF_CElt const* ctable);
-
-/*
- * HUF_decompress() does the following:
- * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics
- * 2. build Huffman table from save, using HUF_readDTableX?()
- * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()
- */
-
-/** HUF_selectDecoder() :
- *  Tells which decoder is likely to decode faster,
- *  based on a set of pre-computed metrics.
- * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
- *  Assumption : 0 < dstSize <= 128 KB */
-U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
-
-/**
- *  The minimum workspace size for the `workSpace` used in
- *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().
- *
- *  The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when
- *  HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.
- *  Buffer overflow errors may potentially occur if code modifications result in
- *  a required workspace size greater than that specified in the following
- *  macro.
- */
-#define HUF_DECOMPRESS_WORKSPACE_SIZE ((2 << 10) + (1 << 9))
-#define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
-
-
-/* ====================== */
-/* single stream variants */
-/* ====================== */
-
-size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags);
-/** HUF_compress1X_repeat() :
- *  Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
- *  If it uses hufTable it does not modify hufTable or repeat.
- *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
- *  If preferRepeat then the old table will always be used if valid.
- *  If suspectUncompressible then some sampling checks will be run to potentially skip huffman coding */
-size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
-                       const void* src, size_t srcSize,
-                       unsigned maxSymbolValue, unsigned tableLog,
-                       void* workSpace, size_t wkspSize,   /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
-                       HUF_CElt* hufTable, HUF_repeat* repeat, int flags);
-
-size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);
-#ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);   /**< double-symbols decoder */
-#endif
-
-/* BMI2 variants.
- * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
- */
-size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags);
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);
-#endif
-size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags);
-size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int flags);
-#endif
-#ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_readDTableX2_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int flags);
-#endif
-
-} // namespace duckdb_zstd
-
-#endif   /* HUF_H_298734234 */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/mem.h b/src/duckdb/third_party/zstd/include/zstd/common/mem.h
deleted file mode 100644
index 4d36251d4..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/mem.h
+++ /dev/null
@@ -1,420 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-/*-****************************************
-*  Dependencies
-******************************************/
-#include <stddef.h>  /* size_t, ptrdiff_t */
-#include "zstd/common/compiler.h"  /* __has_builtin */
-#include "zstd/common/debug.h"  /* DEBUG_STATIC_ASSERT */
-#include "zstd/common/zstd_deps.h"  /* ZSTD_memcpy */
-
-
-/*-****************************************
-*  Compiler specifics
-******************************************/
-#if defined(_MSC_VER)   /* Visual Studio */
-#   include <stdlib.h>  /* _byteswap_ulong */
-#   include <intrin.h>  /* _byteswap_* */
-#endif
-
-/*-**************************************************************
-*  Basic Types
-*****************************************************************/
-#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#  if defined(_AIX)
-#    include <inttypes.h>
-#  else
-#    include <stdint.h> /* intptr_t */
-#  endif
-  typedef   uint8_t BYTE;
-  typedef   uint8_t U8;
-  typedef    int8_t S8;
-  typedef  uint16_t U16;
-  typedef   int16_t S16;
-  typedef  uint32_t U32;
-  typedef   int32_t S32;
-  typedef  uint64_t U64;
-  typedef   int64_t S64;
-#else
-# include <limits.h>
-#if CHAR_BIT != 8
-#  error "this implementation requires char to be exactly 8-bit type"
-#endif
-  typedef unsigned char      BYTE;
-  typedef unsigned char      U8;
-  typedef   signed char      S8;
-#if USHRT_MAX != 65535
-#  error "this implementation requires short to be exactly 16-bit type"
-#endif
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
-#if UINT_MAX != 4294967295
-#  error "this implementation requires int to be exactly 32-bit type"
-#endif
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-/* note : there are no limits defined for long long type in C90.
- * limits exist in C99, however, in such case, <stdint.h> is preferred */
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-namespace duckdb_zstd {
-
-/*-**************************************************************
-*  Memory I/O API
-*****************************************************************/
-/*=== Static platform detection ===*/
-MEM_STATIC unsigned MEM_32bits(void);
-MEM_STATIC unsigned MEM_64bits(void);
-MEM_STATIC unsigned MEM_isLittleEndian(void);
-
-/*=== Native unaligned read/write ===*/
-MEM_STATIC U16 MEM_read16(const void* memPtr);
-MEM_STATIC U32 MEM_read32(const void* memPtr);
-MEM_STATIC U64 MEM_read64(const void* memPtr);
-MEM_STATIC size_t MEM_readST(const void* memPtr);
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value);
-MEM_STATIC void MEM_write32(void* memPtr, U32 value);
-MEM_STATIC void MEM_write64(void* memPtr, U64 value);
-
-/*=== Little endian unaligned read/write ===*/
-MEM_STATIC U16 MEM_readLE16(const void* memPtr);
-MEM_STATIC U32 MEM_readLE24(const void* memPtr);
-MEM_STATIC U32 MEM_readLE32(const void* memPtr);
-MEM_STATIC U64 MEM_readLE64(const void* memPtr);
-MEM_STATIC size_t MEM_readLEST(const void* memPtr);
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val);
-MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val);
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32);
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64);
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val);
-
-/*=== Big endian unaligned read/write ===*/
-MEM_STATIC U32 MEM_readBE32(const void* memPtr);
-MEM_STATIC U64 MEM_readBE64(const void* memPtr);
-MEM_STATIC size_t MEM_readBEST(const void* memPtr);
-
-MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32);
-MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64);
-MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val);
-
-/*=== Byteswap ===*/
-MEM_STATIC U32 MEM_swap32(U32 in);
-MEM_STATIC U64 MEM_swap64(U64 in);
-MEM_STATIC size_t MEM_swapST(size_t in);
-
-
-/*-**************************************************************
-*  Memory I/O Implementation
-*****************************************************************/
-/* MEM_FORCE_MEMORY_ACCESS : For accessing unaligned memory:
- * Method 0 : always use `memcpy()`. Safe and portable.
- * Method 1 : Use compiler extension to set unaligned access.
- * Method 2 : direct access. This method is portable but violate C standard.
- *            It can generate buggy code on targets depending on alignment.
- * Default  : method 1 if supported, else method 0
- */
-#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-#  ifdef __GNUC__
-#    define MEM_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
-
-MEM_STATIC unsigned MEM_isLittleEndian(void)
-{
-#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-    return 1;
-#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-    return 0;
-#elif defined(__clang__) && __LITTLE_ENDIAN__
-    return 1;
-#elif defined(__clang__) && __BIG_ENDIAN__
-    return 0;
-#elif defined(_MSC_VER) && (_M_AMD64 || _M_IX86)
-    return 1;
-#elif defined(__DMC__) && defined(_M_IX86)
-    return 1;
-#else
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-#endif
-}
-
-#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
-
-/* violates C standard, by lying on structure alignment.
-Only use if no other choice to achieve best performance on target platform */
-MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
-MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
-MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-MEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
-
-#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
-
-typedef __attribute__((aligned(1))) U16 unalign16;
-typedef __attribute__((aligned(1))) U32 unalign32;
-typedef __attribute__((aligned(1))) U64 unalign64;
-typedef __attribute__((aligned(1))) size_t unalignArch;
-
-MEM_STATIC U16 MEM_read16(const void* ptr) { return *(const unalign16*)ptr; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return *(const unalign32*)ptr; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return *(const unalign64*)ptr; }
-MEM_STATIC size_t MEM_readST(const void* ptr) { return *(const unalignArch*)ptr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(unalign16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(unalign32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(unalign64*)memPtr = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
-    U16 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
-    U32 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
-    U64 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC size_t MEM_readST(const void* memPtr)
-{
-    size_t val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
-    ZSTD_memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
-    ZSTD_memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
-    ZSTD_memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* MEM_FORCE_MEMORY_ACCESS */
-
-MEM_STATIC U32 MEM_swap32_fallback(U32 in)
-{
-    return  ((in << 24) & 0xff000000 ) |
-            ((in <<  8) & 0x00ff0000 ) |
-            ((in >>  8) & 0x0000ff00 ) |
-            ((in >> 24) & 0x000000ff );
-}
-
-MEM_STATIC U32 MEM_swap32(U32 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_ulong(in);
-#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
-  || (defined(__clang__) && __has_builtin(__builtin_bswap32))
-    return __builtin_bswap32(in);
-#else
-    return MEM_swap32_fallback(in);
-#endif
-}
-
-MEM_STATIC U64 MEM_swap64_fallback(U64 in)
-{
-     return  ((in << 56) & 0xff00000000000000ULL) |
-            ((in << 40) & 0x00ff000000000000ULL) |
-            ((in << 24) & 0x0000ff0000000000ULL) |
-            ((in << 8)  & 0x000000ff00000000ULL) |
-            ((in >> 8)  & 0x00000000ff000000ULL) |
-            ((in >> 24) & 0x0000000000ff0000ULL) |
-            ((in >> 40) & 0x000000000000ff00ULL) |
-            ((in >> 56) & 0x00000000000000ffULL);
-}
-
-MEM_STATIC U64 MEM_swap64(U64 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_uint64(in);
-#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
-  || (defined(__clang__) && __has_builtin(__builtin_bswap64))
-    return __builtin_bswap64(in);
-#else
-    return MEM_swap64_fallback(in);
-#endif
-}
-
-MEM_STATIC size_t MEM_swapST(size_t in)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_swap32((U32)in);
-    else
-        return (size_t)MEM_swap64((U64)in);
-}
-
-/*=== Little endian r/w ===*/
-
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read16(memPtr);
-    else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
-{
-    if (MEM_isLittleEndian()) {
-        MEM_write16(memPtr, val);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val;
-        p[1] = (BYTE)(val>>8);
-    }
-}
-
-MEM_STATIC U32 MEM_readLE24(const void* memPtr)
-{
-    return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);
-}
-
-MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
-{
-    MEM_writeLE16(memPtr, (U16)val);
-    ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
-}
-
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-        return MEM_swap32(MEM_read32(memPtr));
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-        MEM_write32(memPtr, val32);
-    else
-        MEM_write32(memPtr, MEM_swap32(val32));
-}
-
-MEM_STATIC U64 MEM_readLE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read64(memPtr);
-    else
-        return MEM_swap64(MEM_read64(memPtr));
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-        MEM_write64(memPtr, val64);
-    else
-        MEM_write64(memPtr, MEM_swap64(val64));
-}
-
-MEM_STATIC size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeLE32(memPtr, (U32)val);
-    else
-        MEM_writeLE64(memPtr, (U64)val);
-}
-
-/*=== Big endian r/w ===*/
-
-MEM_STATIC U32 MEM_readBE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap32(MEM_read32(memPtr));
-    else
-        return MEM_read32(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-        MEM_write32(memPtr, MEM_swap32(val32));
-    else
-        MEM_write32(memPtr, val32);
-}
-
-MEM_STATIC U64 MEM_readBE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap64(MEM_read64(memPtr));
-    else
-        return MEM_read64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-        MEM_write64(memPtr, MEM_swap64(val64));
-    else
-        MEM_write64(memPtr, val64);
-}
-
-MEM_STATIC size_t MEM_readBEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readBE32(memPtr);
-    else
-        return (size_t)MEM_readBE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeBE32(memPtr, (U32)val);
-    else
-        MEM_writeBE64(memPtr, (U64)val);
-}
-
-/* code only tested on 32 and 64 bits systems */
-MEM_STATIC void MEM_check(void) { DEBUG_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
-
-} // namespace duckdb_zstd
-
-#endif /* MEM_H_MODULE */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/pool.h b/src/duckdb/third_party/zstd/include/zstd/common/pool.h
deleted file mode 100644
index e85948f05..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/pool.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef POOL_H
-#define POOL_H
-
-#include "zstd/common/zstd_deps.h"
-#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_customMem */
-#include "zstd.h"
-
-namespace duckdb_zstd {
-
-typedef struct POOL_ctx_s POOL_ctx;
-
-/*! POOL_create() :
- *  Create a thread pool with at most `numThreads` threads.
- * `numThreads` must be at least 1.
- *  The maximum number of queued jobs before blocking is `queueSize`.
- * @return : POOL_ctx pointer on success, else NULL.
-*/
-POOL_ctx* POOL_create(size_t numThreads, size_t queueSize);
-
-POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
-                               ZSTD_customMem customMem);
-
-/*! POOL_free() :
- *  Free a thread pool returned by POOL_create().
- */
-void POOL_free(POOL_ctx* ctx);
-
-
-/*! POOL_joinJobs() :
- *  Waits for all queued jobs to finish executing.
- */
-void POOL_joinJobs(POOL_ctx* ctx);
-
-/*! POOL_resize() :
- *  Expands or shrinks pool's number of threads.
- *  This is more efficient than releasing + creating a new context,
- *  since it tries to preserve and reuse existing threads.
- * `numThreads` must be at least 1.
- * @return : 0 when resize was successful,
- *           !0 (typically 1) if there is an error.
- *    note : only numThreads can be resized, queueSize remains unchanged.
- */
-int POOL_resize(POOL_ctx* ctx, size_t numThreads);
-
-/*! POOL_sizeof() :
- * @return threadpool memory usage
- *  note : compatible with NULL (returns 0 in this case)
- */
-size_t POOL_sizeof(const POOL_ctx* ctx);
-
-/*! POOL_function :
- *  The function type that can be added to a thread pool.
- */
-typedef void (*POOL_function)(void*);
-
-/*! POOL_add() :
- *  Add the job `function(opaque)` to the thread pool. `ctx` must be valid.
- *  Possibly blocks until there is room in the queue.
- *  Note : The function may be executed asynchronously,
- *         therefore, `opaque` must live until function has been completed.
- */
-void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque);
-
-
-/*! POOL_tryAdd() :
- *  Add the job `function(opaque)` to thread pool _if_ a queue slot is available.
- *  Returns immediately even if not (does not block).
- * @return : 1 if successful, 0 if not.
- */
-int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque);
-
-} // namespace duckdb_zstd
-
-#endif
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/portability_macros.h b/src/duckdb/third_party/zstd/include/zstd/common/portability_macros.h
deleted file mode 100644
index e50314a78..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/portability_macros.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_PORTABILITY_MACROS_H
-#define ZSTD_PORTABILITY_MACROS_H
-
-/**
- * This header file contains macro definitions to support portability.
- * This header is shared between C and ASM code, so it MUST only
- * contain macro definitions. It MUST not contain any C code.
- *
- * This header ONLY defines macros to detect platforms/feature support.
- *
- */
-
-
-/* compat. with non-clang compilers */
-#ifndef __has_attribute
-  #define __has_attribute(x) 0
-#endif
-
-/* compat. with non-clang compilers */
-#ifndef __has_builtin
-#  define __has_builtin(x) 0
-#endif
-
-/* compat. with non-clang compilers */
-#ifndef __has_feature
-#  define __has_feature(x) 0
-#endif
-
-/* detects whether we are being compiled under msan */
-#ifndef ZSTD_MEMORY_SANITIZER
-#  if __has_feature(memory_sanitizer)
-#    define ZSTD_MEMORY_SANITIZER 1
-#  else
-#    define ZSTD_MEMORY_SANITIZER 0
-#  endif
-#endif
-
-/* detects whether we are being compiled under asan */
-#ifndef ZSTD_ADDRESS_SANITIZER
-#  if __has_feature(address_sanitizer)
-#    define ZSTD_ADDRESS_SANITIZER 1
-#  elif defined(__SANITIZE_ADDRESS__)
-#    define ZSTD_ADDRESS_SANITIZER 1
-#  else
-#    define ZSTD_ADDRESS_SANITIZER 0
-#  endif
-#endif
-
-/* detects whether we are being compiled under dfsan */
-#ifndef ZSTD_DATAFLOW_SANITIZER
-# if __has_feature(dataflow_sanitizer)
-#  define ZSTD_DATAFLOW_SANITIZER 1
-# else
-#  define ZSTD_DATAFLOW_SANITIZER 0
-# endif
-#endif
-
-/* Mark the internal assembly functions as hidden  */
-#ifdef __ELF__
-# define ZSTD_HIDE_ASM_FUNCTION(func) .hidden func
-#elif defined(__APPLE__)
-# define ZSTD_HIDE_ASM_FUNCTION(func) .private_extern func
-#else
-# define ZSTD_HIDE_ASM_FUNCTION(func)
-#endif
-
-/* Enable runtime BMI2 dispatch based on the CPU.
- * Enabled for clang & gcc >=4.8 on x86 when BMI2 isn't enabled by default.
- */
-#ifndef DYNAMIC_BMI2
-  #if ((defined(__clang__) && __has_attribute(__target__)) \
-      || (defined(__GNUC__) \
-          && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))) \
-      && (defined(__x86_64__) || defined(_M_X64)) \
-      && !defined(__BMI2__)
-  #  define DYNAMIC_BMI2 1
-  #else
-  #  define DYNAMIC_BMI2 0
-  #endif
-#endif
-
-/**
- * Only enable assembly for GNUC compatible compilers,
- * because other platforms may not support GAS assembly syntax.
- *
- * Only enable assembly for Linux / MacOS, other platforms may
- * work, but they haven't been tested. This could likely be
- * extended to BSD systems.
- *
- * Disable assembly when MSAN is enabled, because MSAN requires
- * 100% of code to be instrumented to work.
- */
-#if defined(__GNUC__)
-#  if defined(__linux__) || defined(__linux) || defined(__APPLE__)
-#    if ZSTD_MEMORY_SANITIZER
-#      define ZSTD_ASM_SUPPORTED 0
-#    elif ZSTD_DATAFLOW_SANITIZER
-#      define ZSTD_ASM_SUPPORTED 0
-#    else
-#      define ZSTD_ASM_SUPPORTED 1
-#    endif
-#  else
-#    define ZSTD_ASM_SUPPORTED 0
-#  endif
-#else
-#  define ZSTD_ASM_SUPPORTED 0
-#endif
-
-/**
- * Determines whether we should enable assembly for x86-64
- * with BMI2.
- *
- * Enable if all of the following conditions hold:
- * - ASM hasn't been explicitly disabled by defining ZSTD_DISABLE_ASM
- * - Assembly is supported
- * - We are compiling for x86-64 and either:
- *   - DYNAMIC_BMI2 is enabled
- *   - BMI2 is supported at compile time
- */
-#if !defined(ZSTD_DISABLE_ASM) &&                                 \
-    ZSTD_ASM_SUPPORTED &&                                         \
-    defined(__x86_64__) &&                                        \
-    (DYNAMIC_BMI2 || defined(__BMI2__))
-# define ZSTD_ENABLE_ASM_X86_64_BMI2 1
-#else
-# define ZSTD_ENABLE_ASM_X86_64_BMI2 0
-#endif
-
-/*
- * For x86 ELF targets, add .note.gnu.property section for Intel CET in
- * assembly sources when CET is enabled.
- *
- * Additionally, any function that may be called indirectly must begin
- * with ZSTD_CET_ENDBRANCH.
- */
-#if defined(__ELF__) && (defined(__x86_64__) || defined(__i386__)) \
-    && defined(__has_include)
-# if __has_include(<cet.h>)
-#  include <cet.h>
-#  define ZSTD_CET_ENDBRANCH _CET_ENDBR
-# endif
-#endif
-
-#ifndef ZSTD_CET_ENDBRANCH
-# define ZSTD_CET_ENDBRANCH
-#endif
-
-#endif /* ZSTD_PORTABILITY_MACROS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/threading.h b/src/duckdb/third_party/zstd/include/zstd/common/threading.h
deleted file mode 100644
index fc13da1bf..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/threading.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * Copyright (c) 2016 Tino Reichardt
- * All rights reserved.
- *
- * You can contact the author at:
- * - zstdmt source repository: https://github.com/mcmilk/zstdmt
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef THREADING_H_938743
-#define THREADING_H_938743
-
-#include "zstd/common/debug.h"
-
-#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
-
-/**
- * Windows minimalist Pthread Wrapper
- */
-#ifdef WINVER
-#  undef WINVER
-#endif
-#define WINVER       0x0600
-
-#ifdef _WIN32_WINNT
-#  undef _WIN32_WINNT
-#endif
-#define _WIN32_WINNT 0x0600
-
-#ifndef WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */
-#include <windows.h>
-#undef ERROR
-#define ERROR(name) ZSTD_ERROR(name)
-
-/* mutex */
-#define ZSTD_pthread_mutex_t           CRITICAL_SECTION
-#define ZSTD_pthread_mutex_init(a, b)  ((void)(b), InitializeCriticalSection((a)), 0)
-#define ZSTD_pthread_mutex_destroy(a)  DeleteCriticalSection((a))
-#define ZSTD_pthread_mutex_lock(a)     EnterCriticalSection((a))
-#define ZSTD_pthread_mutex_unlock(a)   LeaveCriticalSection((a))
-
-/* condition variable */
-#define ZSTD_pthread_cond_t             CONDITION_VARIABLE
-#define ZSTD_pthread_cond_init(a, b)    ((void)(b), InitializeConditionVariable((a)), 0)
-#define ZSTD_pthread_cond_destroy(a)    ((void)(a))
-#define ZSTD_pthread_cond_wait(a, b)    SleepConditionVariableCS((a), (b), INFINITE)
-#define ZSTD_pthread_cond_signal(a)     WakeConditionVariable((a))
-#define ZSTD_pthread_cond_broadcast(a)  WakeAllConditionVariable((a))
-
-namespace duckdb_zstd {
-
-/* ZSTD_pthread_create() and ZSTD_pthread_join() */
-typedef HANDLE ZSTD_pthread_t;
-
-int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
-                   void* (*start_routine) (void*), void* arg);
-
-int ZSTD_pthread_join(ZSTD_pthread_t thread);
-
-} // namespace duckdb_zstd
-
-/**
- * add here more wrappers as required
- */
-
-
-#elif defined(ZSTD_MULTITHREAD)    /* posix assumed ; need a better detection method */
-/* ===   POSIX Systems   === */
-#  include <pthread.h>
-
-# if DEBUGLEVEL < 1
-
-#define ZSTD_pthread_mutex_t            pthread_mutex_t
-#define ZSTD_pthread_mutex_init(a, b)   pthread_mutex_init((a), (b))
-#define ZSTD_pthread_mutex_destroy(a)   pthread_mutex_destroy((a))
-#define ZSTD_pthread_mutex_lock(a)      pthread_mutex_lock((a))
-#define ZSTD_pthread_mutex_unlock(a)    pthread_mutex_unlock((a))
-
-#define ZSTD_pthread_cond_t             pthread_cond_t
-#define ZSTD_pthread_cond_init(a, b)    pthread_cond_init((a), (b))
-#define ZSTD_pthread_cond_destroy(a)    pthread_cond_destroy((a))
-#define ZSTD_pthread_cond_wait(a, b)    pthread_cond_wait((a), (b))
-#define ZSTD_pthread_cond_signal(a)     pthread_cond_signal((a))
-#define ZSTD_pthread_cond_broadcast(a)  pthread_cond_broadcast((a))
-
-#define ZSTD_pthread_t                  pthread_t
-#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
-#define ZSTD_pthread_join(a)         pthread_join((a),NULL)
-
-# else /* DEBUGLEVEL >= 1 */
-
-/* Debug implementation of threading.
- * In this implementation we use pointers for mutexes and condition variables.
- * This way, if we forget to init/destroy them the program will crash or ASAN
- * will report leaks.
- */
-
-namespace duckdb_zstd {
-
-#define ZSTD_pthread_mutex_t            pthread_mutex_t*
-int ZSTD_pthread_mutex_init(ZSTD_pthread_mutex_t* mutex, pthread_mutexattr_t const* attr);
-int ZSTD_pthread_mutex_destroy(ZSTD_pthread_mutex_t* mutex);
-#define ZSTD_pthread_mutex_lock(a)      pthread_mutex_lock(*(a))
-#define ZSTD_pthread_mutex_unlock(a)    pthread_mutex_unlock(*(a))
-
-#define ZSTD_pthread_cond_t             pthread_cond_t*
-int ZSTD_pthread_cond_init(ZSTD_pthread_cond_t* cond, pthread_condattr_t const* attr);
-int ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond);
-#define ZSTD_pthread_cond_wait(a, b)    pthread_cond_wait(*(a), *(b))
-#define ZSTD_pthread_cond_signal(a)     pthread_cond_signal(*(a))
-#define ZSTD_pthread_cond_broadcast(a)  pthread_cond_broadcast(*(a))
-
-#define ZSTD_pthread_t                  pthread_t
-#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
-#define ZSTD_pthread_join(a)         pthread_join((a),NULL)
-
-} // namespace duckdb_zstd
-
-# endif
-
-#else  /* ZSTD_MULTITHREAD not defined */
-/* No multithreading support */
-
-namespace duckdb_zstd {
-
-typedef int ZSTD_pthread_mutex_t;
-#define ZSTD_pthread_mutex_init(a, b)   ((void)(a), (void)(b), 0)
-#define ZSTD_pthread_mutex_destroy(a)   ((void)(a))
-#define ZSTD_pthread_mutex_lock(a)      ((void)(a))
-#define ZSTD_pthread_mutex_unlock(a)    ((void)(a))
-
-typedef int ZSTD_pthread_cond_t;
-#define ZSTD_pthread_cond_init(a, b)    ((void)(a), (void)(b), 0)
-#define ZSTD_pthread_cond_destroy(a)    ((void)(a))
-#define ZSTD_pthread_cond_wait(a, b)    ((void)(a), (void)(b))
-#define ZSTD_pthread_cond_signal(a)     ((void)(a))
-#define ZSTD_pthread_cond_broadcast(a)  ((void)(a))
-
-/* do not use ZSTD_pthread_t */
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_MULTITHREAD */
-#endif /* THREADING_H_938743 */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/xxhash.hpp b/src/duckdb/third_party/zstd/include/zstd/common/xxhash.hpp
deleted file mode 100644
index 1ebadc466..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/xxhash.hpp
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * xxHash - Extremely Fast Hash algorithm
- * Header File
- * Copyright (c) 2012-2020, Yann Collet, Facebook, Inc.
- *
- * You can contact the author at :
- * - xxHash source repository : https://github.com/Cyan4973/xxHash
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-*/
-
-/* Notice extracted from xxHash homepage :
-
-xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
-It also successfully passes all tests from the SMHasher suite.
-
-Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
-
-Name            Speed       Q.Score   Author
-xxHash          5.4 GB/s     10
-CrapWow         3.2 GB/s      2       Andrew
-MumurHash 3a    2.7 GB/s     10       Austin Appleby
-SpookyHash      2.0 GB/s     10       Bob Jenkins
-SBox            1.4 GB/s      9       Bret Mulvey
-Lookup3         1.2 GB/s      9       Bob Jenkins
-SuperFastHash   1.2 GB/s      1       Paul Hsieh
-CityHash64      1.05 GB/s    10       Pike & Alakuijala
-FNV             0.55 GB/s     5       Fowler, Noll, Vo
-CRC32           0.43 GB/s     9
-MD5-32          0.33 GB/s    10       Ronald L. Rivest
-SHA1-32         0.28 GB/s    10
-
-Q.Score is a measure of quality of the hash function.
-It depends on successfully passing SMHasher test set.
-10 is a perfect score.
-
-A 64-bits version, named XXH64, is available since r35.
-It offers much better speed, but for 64-bits applications only.
-Name     Speed on 64 bits    Speed on 32 bits
-XXH64       13.8 GB/s            1.9 GB/s
-XXH32        6.8 GB/s            6.0 GB/s
-*/
-
-#ifndef XXHASH_H_5627135585666179
-#define XXHASH_H_5627135585666179 1
-
-
-/* ****************************
-*  Definitions
-******************************/
-#include <stddef.h>   /* size_t */
-namespace duckdb_zstd {
-typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
-
-
-/* ****************************
-*  API modifier
-******************************/
-/** XXH_PRIVATE_API
-*   This is useful if you want to include xxhash functions in `static` mode
-*   in order to inline them, and remove their symbol from the public list.
-*   Methodology :
-*     #define XXH_PRIVATE_API
-*     #include "zstd/common/xxhash.h"
-*   `xxhash.c` is automatically included.
-*   It's not useful to compile and link it as a separate module anymore.
-*/
-#ifdef XXH_PRIVATE_API
-#  ifndef XXH_STATIC_LINKING_ONLY
-#    define XXH_STATIC_LINKING_ONLY
-#  endif
-#  if defined(__GNUC__)
-#    define XXH_PUBLIC_API static __inline __attribute__((unused))
-#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#    define XXH_PUBLIC_API static inline
-#  elif defined(_MSC_VER)
-#    define XXH_PUBLIC_API static __inline
-#  else
-#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */
-#  endif
-#else
-#  define XXH_PUBLIC_API   /* do nothing */
-#endif /* XXH_PRIVATE_API */
-
-/*!XXH_NAMESPACE, aka Namespace Emulation :
-
-If you want to include _and expose_ xxHash functions from within your own library,
-but also want to avoid symbol collisions with another library which also includes xxHash,
-
-you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
-with the value of XXH_NAMESPACE (so avoid to keep it NULL and avoid numeric values).
-
-Note that no change is required within the calling program as long as it includes `xxhash.h` :
-regular symbol name will be automatically translated by this header.
-*/
-#ifdef XXH_NAMESPACE
-#  define XXH_CAT(A,B) A##B
-#  define XXH_NAME2(A,B) XXH_CAT(A,B)
-#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
-#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
-#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
-#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
-#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
-#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
-#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
-#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
-#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
-#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
-#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
-#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
-#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
-#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
-#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
-#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
-#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
-#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
-#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
-#endif
-
-
-/* *************************************
-*  Version
-***************************************/
-#define XXH_VERSION_MAJOR    0
-#define XXH_VERSION_MINOR    6
-#define XXH_VERSION_RELEASE  2
-#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
-XXH_PUBLIC_API unsigned XXH_versionNumber (void);
-
-
-/* ****************************
-*  Simple Hash Functions
-******************************/
-typedef unsigned int       XXH32_hash_t;
-typedef unsigned long long XXH64_hash_t;
-
-XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
-XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
-
-/*!
-XXH32() :
-    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
-    The memory between input & input+length must be valid (allocated and read-accessible).
-    "seed" can be used to alter the result predictably.
-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
-XXH64() :
-    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
-    "seed" can be used to alter the result predictably.
-    This function runs 2x faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
-*/
-
-
-/* ****************************
-*  Streaming Hash Functions
-******************************/
-typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
-typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
-
-/*! State allocation, compatible with dynamic libraries */
-
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
-
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-
-
-/* hash streaming */
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
-
-/*
-These functions generate the xxHash of an input provided in multiple segments.
-Note that, for small input, they are slower than single-call functions, due to state management.
-For small input, prefer `XXH32()` and `XXH64()` .
-
-XXH state must first be allocated, using XXH*_createState() .
-
-Start a new hash by initializing state with a seed, using XXH*_reset().
-
-Then, feed the hash state by calling XXH*_update() as many times as necessary.
-Obviously, input must be allocated and read accessible.
-The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
-
-Finally, a hash value can be produced anytime, by using XXH*_digest().
-This function returns the nn-bits hash as an int or long long.
-
-It's still possible to continue inserting input into the hash state after a digest,
-and generate some new hashes later on, by calling again XXH*_digest().
-
-When done, free XXH state space if it was allocated dynamically.
-*/
-
-
-/* **************************
-*  Utils
-****************************/
-#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))   /* ! C99 */
-#  define __restrict   /* disable restrict */
-#endif
-
-XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* __restrict dst_state, const XXH32_state_t* __restrict src_state);
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* __restrict dst_state, const XXH64_state_t* __restrict src_state);
-
-
-/* **************************
-*  Canonical representation
-****************************/
-/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
-*  The canonical representation uses human-readable write convention, aka big-endian (large digits first).
-*  These functions allow transformation of hash result into and from its canonical format.
-*  This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
-*/
-typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
-typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
-
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
-
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
-
-}
-
-#endif /* XXHASH_H_5627135585666179 */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/xxhash_static.hpp b/src/duckdb/third_party/zstd/include/zstd/common/xxhash_static.hpp
deleted file mode 100644
index b8a8f2a72..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/xxhash_static.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-
-/* ================================================================================================
-   This section contains definitions which are not guaranteed to remain stable.
-   They may change in future versions, becoming incompatible with a different version of the library.
-   They shall only be used with static linking.
-   Never use these definitions in association with dynamic linking !
-=================================================================================================== */
-#ifndef XXH_STATIC_H_3543687687345
-#define XXH_STATIC_H_3543687687345
-
-namespace duckdb_zstd {
-
-/* These definitions are only meant to allow allocation of XXH state
-   statically, on stack, or in a struct for example.
-   Do not use members directly. */
-
-   struct XXH32_state_s {
-       unsigned total_len_32;
-       unsigned large_len;
-       unsigned v1;
-       unsigned v2;
-       unsigned v3;
-       unsigned v4;
-       unsigned mem32[4];   /* buffer defined as U32 for alignment */
-       unsigned memsize;
-       unsigned reserved;   /* never read nor write, will be removed in a future version */
-   };   /* typedef'd to XXH32_state_t */
-
-   struct XXH64_state_s {
-       unsigned long long total_len;
-       unsigned long long v1;
-       unsigned long long v2;
-       unsigned long long v3;
-       unsigned long long v4;
-       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */
-       unsigned memsize;
-       unsigned reserved[2];          /* never read nor write, will be removed in a future version */
-   };   /* typedef'd to XXH64_state_t */
-
-}
-// #  ifdef XXH_PRIVATE_API
-// #    include "xxhash.cpp"   /* include xxhash functions as `static`, for inlining */
-// #  endif
-
-#endif /* XXH_STATIC_LINKING_ONLY && XXH_STATIC_H_3543687687345 */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/zstd_deps.h b/src/duckdb/third_party/zstd/include/zstd/common/zstd_deps.h
deleted file mode 100644
index 0be68bbb1..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/zstd_deps.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* This file provides common libc dependencies that zstd requires.
- * The purpose is to allow replacing this file with a custom implementation
- * to compile zstd without libc support.
- */
-
-/* Need:
- * NULL
- * INT_MAX
- * UINT_MAX
- * ZSTD_memcpy()
- * ZSTD_memset()
- * ZSTD_memmove()
- */
-#ifndef ZSTD_DEPS_COMMON
-#define ZSTD_DEPS_COMMON
-
-#include <limits.h>
-#include <stddef.h>
-#include <string.h>
-
-// DuckDB: just enable everything for amalgamation
-#ifdef DUCKDB_AMALGAMATION
-#define ZSTD_DEPS_NEED_MALLOC
-#define ZSTD_DEPS_NEED_MATH64
-#define ZSTD_DEPS_NEED_ASSERT
-#define ZSTD_DEPS_NEED_IO
-#define ZSTD_DEPS_NEED_STDINT
-#define ZSTD_MULTITHREAD
-#define FSE_STATIC_LINKING_ONLY
-#endif
-
-#if defined(__GNUC__) && __GNUC__ >= 4
-# define ZSTD_memcpy(d,s,l) __builtin_memcpy((d),(s),(l))
-# define ZSTD_memmove(d,s,l) __builtin_memmove((d),(s),(l))
-# define ZSTD_memset(p,v,l) __builtin_memset((p),(v),(l))
-#else
-# define ZSTD_memcpy(d,s,l) memcpy((d),(s),(l))
-# define ZSTD_memmove(d,s,l) memmove((d),(s),(l))
-# define ZSTD_memset(p,v,l) memset((p),(v),(l))
-#endif
-
-#endif /* ZSTD_DEPS_COMMON */
-
-/* Need:
- * ZSTD_malloc()
- * ZSTD_free()
- * ZSTD_calloc()
- */
-#ifdef ZSTD_DEPS_NEED_MALLOC
-#ifndef ZSTD_DEPS_MALLOC
-#define ZSTD_DEPS_MALLOC
-
-#include <stdlib.h>
-
-#define ZSTD_malloc(s) malloc(s)
-#define ZSTD_calloc(n,s) calloc((n), (s))
-#define ZSTD_free(p) free((p))
-
-#endif /* ZSTD_DEPS_MALLOC */
-#endif /* ZSTD_DEPS_NEED_MALLOC */
-
-/*
- * Provides 64-bit math support.
- * Need:
- * U64 ZSTD_div64(U64 dividend, U32 divisor)
- */
-#ifdef ZSTD_DEPS_NEED_MATH64
-#ifndef ZSTD_DEPS_MATH64
-#define ZSTD_DEPS_MATH64
-
-#define ZSTD_div64(dividend, divisor) ((dividend) / (divisor))
-
-#endif /* ZSTD_DEPS_MATH64 */
-#endif /* ZSTD_DEPS_NEED_MATH64 */
-
-/* Need:
- * assert()
- */
-#ifdef ZSTD_DEPS_NEED_ASSERT
-#ifndef ZSTD_DEPS_ASSERT
-#define ZSTD_DEPS_ASSERT
-
-#include <assert.h>
-
-#endif /* ZSTD_DEPS_ASSERT */
-#endif /* ZSTD_DEPS_NEED_ASSERT */
-
-/* Need:
- * ZSTD_DEBUG_PRINT()
- */
-#ifdef ZSTD_DEPS_NEED_IO
-#ifndef ZSTD_DEPS_IO
-#define ZSTD_DEPS_IO
-
-#include <stdio.h>
-#define ZSTD_DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__)
-
-#endif /* ZSTD_DEPS_IO */
-#endif /* ZSTD_DEPS_NEED_IO */
-
-/* Only requested when <stdint.h> is known to be present.
- * Need:
- * intptr_t
- */
-#ifdef ZSTD_DEPS_NEED_STDINT
-#ifndef ZSTD_DEPS_STDINT
-#define ZSTD_DEPS_STDINT
-
-#include <stdint.h>
-
-#endif /* ZSTD_DEPS_STDINT */
-#endif /* ZSTD_DEPS_NEED_STDINT */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/zstd_internal.h b/src/duckdb/third_party/zstd/include/zstd/common/zstd_internal.h
deleted file mode 100644
index 3e800e3dc..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/zstd_internal.h
+++ /dev/null
@@ -1,389 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_CCOMMON_H_MODULE
-#define ZSTD_CCOMMON_H_MODULE
-
-/* this module contains definitions which must be identical
- * across compression, decompression and dictBuilder.
- * It also contains a few functions useful to at least 2 of them
- * and which benefit from being inlined */
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zstd/common/compiler.h"
-#include "zstd/common/cpu.h"
-#include "zstd/common/mem.h"
-#include "zstd/common/debug.h"                 /* assert, DEBUGLOG, RAWLOG, g_debuglevel */
-#include "zstd/common/error_private.h"
-#define ZSTD_STATIC_LINKING_ONLY
-#include "zstd.h"
-#define FSE_STATIC_LINKING_ONLY
-#include "zstd/common/fse.h"
-#include "zstd/common/huf.h"
-#ifndef XXH_STATIC_LINKING_ONLY
-#  define XXH_STATIC_LINKING_ONLY  /* XXH64_state_t */
-#endif
-#include "zstd/common/xxhash.hpp"                /* XXH_reset, update, digest */
-#include "zstd/common/xxhash_static.hpp"
-#ifndef ZSTD_NO_TRACE
-#  include "zstd/common/zstd_trace.h"
-#else
-#  define ZSTD_TRACE 0
-#endif
-
-namespace duckdb_zstd {
-
-/* ---- static assert (debug) --- */
-#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)
-#define ZSTD_isError ERR_isError   /* for inlining */
-#define FSE_isError  ERR_isError
-#define HUF_isError  ERR_isError
-
-
-/*-*************************************
-*  shared macros
-***************************************/
-#undef MIN
-#undef MAX
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
-#define BOUNDED(min,val,max) (MAX(min,MIN(val,max)))
-
-
-/*-*************************************
-*  Common constants
-***************************************/
-#define ZSTD_OPT_NUM    (1<<12)
-
-#define ZSTD_REP_NUM      3                 /* number of repcodes */
-static UNUSED_ATTR const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BIT7 128
-#define BIT6  64
-#define BIT5  32
-#define BIT4  16
-#define BIT1   2
-#define BIT0   1
-
-#define ZSTD_WINDOWLOG_ABSOLUTEMIN 10
-static UNUSED_ATTR const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };
-static UNUSED_ATTR const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };
-
-#define ZSTD_FRAMEIDSIZE 4   /* magic number size */
-
-#define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
-static UNUSED_ATTR const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
-typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;
-
-#define ZSTD_FRAMECHECKSUMSIZE 4
-
-#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
-#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */)   /* for a non-null block */
-#define MIN_LITERALS_FOR_4_STREAMS 6
-
-typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e;
-
-#define LONGNBSEQ 0x7F00
-
-#define MINMATCH 3
-
-#define Litbits  8
-#define LitHufLog 11
-#define MaxLit ((1<<Litbits) - 1)
-#define MaxML   52
-#define MaxLL   35
-#define DefaultMaxOff 28
-#define MaxOff  31
-#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */
-#define MLFSELog    9
-#define LLFSELog    9
-#define OffFSELog   8
-#define MaxFSELog  MAX(MAX(MLFSELog, LLFSELog), OffFSELog)
-#define MaxMLBits 16
-#define MaxLLBits 16
-
-#define ZSTD_MAX_HUF_HEADER_SIZE 128 /* header + <= 127 byte tree description */
-/* Each table cannot take more than #symbols * FSELog bits */
-#define ZSTD_MAX_FSE_HEADERS_SIZE (((MaxML + 1) * MLFSELog + (MaxLL + 1) * LLFSELog + (MaxOff + 1) * OffFSELog + 7) / 8)
-
-static UNUSED_ATTR const U8 LL_bits[MaxLL+1] = {
-     0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0,
-     1, 1, 1, 1, 2, 2, 3, 3,
-     4, 6, 7, 8, 9,10,11,12,
-    13,14,15,16
-};
-static UNUSED_ATTR const S16 LL_defaultNorm[MaxLL+1] = {
-     4, 3, 2, 2, 2, 2, 2, 2,
-     2, 2, 2, 2, 2, 1, 1, 1,
-     2, 2, 2, 2, 2, 2, 2, 2,
-     2, 3, 2, 1, 1, 1, 1, 1,
-    -1,-1,-1,-1
-};
-#define LL_DEFAULTNORMLOG 6  /* for static allocation */
-static UNUSED_ATTR const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG;
-
-static UNUSED_ATTR const U8 ML_bits[MaxML+1] = {
-     0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0,
-     1, 1, 1, 1, 2, 2, 3, 3,
-     4, 4, 5, 7, 8, 9,10,11,
-    12,13,14,15,16
-};
-static UNUSED_ATTR const S16 ML_defaultNorm[MaxML+1] = {
-     1, 4, 3, 2, 2, 2, 2, 2,
-     2, 1, 1, 1, 1, 1, 1, 1,
-     1, 1, 1, 1, 1, 1, 1, 1,
-     1, 1, 1, 1, 1, 1, 1, 1,
-     1, 1, 1, 1, 1, 1, 1, 1,
-     1, 1, 1, 1, 1, 1,-1,-1,
-    -1,-1,-1,-1,-1
-};
-#define ML_DEFAULTNORMLOG 6  /* for static allocation */
-static UNUSED_ATTR const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG;
-
-static UNUSED_ATTR const S16 OF_defaultNorm[DefaultMaxOff+1] = {
-     1, 1, 1, 1, 1, 1, 2, 2,
-     2, 1, 1, 1, 1, 1, 1, 1,
-     1, 1, 1, 1, 1, 1, 1, 1,
-    -1,-1,-1,-1,-1
-};
-#define OF_DEFAULTNORMLOG 5  /* for static allocation */
-static UNUSED_ATTR const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;
-
-
-/*-*******************************************
-*  Shared functions to include for inlining
-*********************************************/
-static void ZSTD_copy8(void* dst, const void* src) {
-#if defined(ZSTD_ARCH_ARM_NEON)
-    vst1_u8((uint8_t*)dst, vld1_u8((const uint8_t*)src));
-#else
-    ZSTD_memcpy(dst, src, 8);
-#endif
-}
-#define COPY8(d,s) do { ZSTD_copy8(d,s); d+=8; s+=8; } while (0)
-
-/* Need to use memmove here since the literal buffer can now be located within
-   the dst buffer. In circumstances where the op "catches up" to where the
-   literal buffer is, there can be partial overlaps in this call on the final
-   copy if the literal is being shifted by less than 16 bytes. */
-static void ZSTD_copy16(void* dst, const void* src) {
-#if defined(ZSTD_ARCH_ARM_NEON)
-    vst1q_u8((uint8_t*)dst, vld1q_u8((const uint8_t*)src));
-#elif defined(ZSTD_ARCH_X86_SSE2)
-    _mm_storeu_si128((__m128i*)dst, _mm_loadu_si128((const __m128i*)src));
-#elif defined(__clang__)
-    ZSTD_memmove(dst, src, 16);
-#else
-    /* ZSTD_memmove is not inlined properly by gcc */
-    BYTE copy16_buf[16];
-    ZSTD_memcpy(copy16_buf, src, 16);
-    ZSTD_memcpy(dst, copy16_buf, 16);
-#endif
-}
-#define COPY16(d,s) do { ZSTD_copy16(d,s); d+=16; s+=16; } while (0)
-
-#define WILDCOPY_OVERLENGTH 32
-#define WILDCOPY_VECLEN 16
-
-typedef enum {
-    ZSTD_no_overlap,
-    ZSTD_overlap_src_before_dst
-    /*  ZSTD_overlap_dst_before_src, */
-} ZSTD_overlap_e;
-
-/*! ZSTD_wildcopy() :
- *  Custom version of ZSTD_memcpy(), can over read/write up to WILDCOPY_OVERLENGTH bytes (if length==0)
- *  @param ovtype controls the overlap detection
- *         - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart.
- *         - ZSTD_overlap_src_before_dst: The src and dst may overlap, but they MUST be at least 8 bytes apart.
- *           The src buffer must be before the dst buffer.
- */
-MEM_STATIC FORCE_INLINE_ATTR
-void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e const ovtype)
-{
-    ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-
-    if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
-        /* Handle short offset copies. */
-        do {
-            COPY8(op, ip);
-        } while (op < oend);
-    } else {
-        assert(diff >= WILDCOPY_VECLEN || diff <= -WILDCOPY_VECLEN);
-        /* Separate out the first COPY16() call because the copy length is
-         * almost certain to be short, so the branches have different
-         * probabilities. Since it is almost certain to be short, only do
-         * one COPY16() in the first call. Then, do two calls per loop since
-         * at that point it is more likely to have a high trip count.
-         */
-        ZSTD_copy16(op, ip);
-        if (16 >= length) return;
-        op += 16;
-        ip += 16;
-        do {
-            COPY16(op, ip);
-            COPY16(op, ip);
-        }
-        while (op < oend);
-    }
-}
-
-MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    size_t const length = MIN(dstCapacity, srcSize);
-    if (length > 0) {
-        ZSTD_memcpy(dst, src, length);
-    }
-    return length;
-}
-
-/* define "workspace is too large" as this number of times larger than needed */
-#define ZSTD_WORKSPACETOOLARGE_FACTOR 3
-
-/* when workspace is continuously too large
- * during at least this number of times,
- * context's memory usage is considered wasteful,
- * because it's sized to handle a worst case scenario which rarely happens.
- * In which case, resize it down to free some memory */
-#define ZSTD_WORKSPACETOOLARGE_MAXDURATION 128
-
-/* Controls whether the input/output buffer is buffered or stable. */
-typedef enum {
-    ZSTD_bm_buffered = 0,  /* Buffer the input/output */
-    ZSTD_bm_stable = 1     /* ZSTD_inBuffer/ZSTD_outBuffer is stable */
-} ZSTD_bufferMode_e;
-
-
-/*-*******************************************
-*  Private declarations
-*********************************************/
-typedef struct seqDef_s {
-    U32 offBase;   /* offBase == Offset + ZSTD_REP_NUM, or repcode 1,2,3 */
-    U16 litLength;
-    U16 mlBase;    /* mlBase == matchLength - MINMATCH */
-} seqDef;
-
-/* Controls whether seqStore has a single "long" litLength or matchLength. See seqStore_t. */
-typedef enum {
-    ZSTD_llt_none = 0,             /* no longLengthType */
-    ZSTD_llt_literalLength = 1,    /* represents a long literal */
-    ZSTD_llt_matchLength = 2       /* represents a long match */
-} ZSTD_longLengthType_e;
-
-typedef struct {
-    seqDef* sequencesStart;
-    seqDef* sequences;      /* ptr to end of sequences */
-    BYTE*  litStart;
-    BYTE*  lit;             /* ptr to end of literals */
-    BYTE*  llCode;
-    BYTE*  mlCode;
-    BYTE*  ofCode;
-    size_t maxNbSeq;
-    size_t maxNbLit;
-
-    /* longLengthPos and longLengthType to allow us to represent either a single litLength or matchLength
-     * in the seqStore that has a value larger than U16 (if it exists). To do so, we increment
-     * the existing value of the litLength or matchLength by 0x10000.
-     */
-    ZSTD_longLengthType_e longLengthType;
-    U32                   longLengthPos;  /* Index of the sequence to apply long length modification to */
-} seqStore_t;
-
-typedef struct {
-    U32 litLength;
-    U32 matchLength;
-} ZSTD_sequenceLength;
-
-/**
- * Returns the ZSTD_sequenceLength for the given sequences. It handles the decoding of long sequences
- * indicated by longLengthPos and longLengthType, and adds MINMATCH back to matchLength.
- */
-MEM_STATIC ZSTD_sequenceLength ZSTD_getSequenceLength(seqStore_t const* seqStore, seqDef const* seq)
-{
-    ZSTD_sequenceLength seqLen;
-    seqLen.litLength = seq->litLength;
-    seqLen.matchLength = seq->mlBase + MINMATCH;
-    if (seqStore->longLengthPos == (U32)(seq - seqStore->sequencesStart)) {
-        if (seqStore->longLengthType == ZSTD_llt_literalLength) {
-            seqLen.litLength += 0x10000;
-        }
-        if (seqStore->longLengthType == ZSTD_llt_matchLength) {
-            seqLen.matchLength += 0x10000;
-        }
-    }
-    return seqLen;
-}
-
-/**
- * Contains the compressed frame size and an upper-bound for the decompressed frame size.
- * Note: before using `compressedSize`, check for errors using ZSTD_isError().
- *       similarly, before using `decompressedBound`, check for errors using:
- *          `decompressedBound != ZSTD_CONTENTSIZE_ERROR`
- */
-typedef struct {
-    size_t nbBlocks;
-    size_t compressedSize;
-    unsigned long long decompressedBound;
-} ZSTD_frameSizeInfo;   /* decompress & legacy */
-
-const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */
-int ZSTD_seqToCodes(const seqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
-
-
-/* ZSTD_invalidateRepCodes() :
- * ensures next compression will not use repcodes from previous block.
- * Note : only works with regular variant;
- *        do not use with extDict variant ! */
-void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx);   /* zstdmt, adaptive_compression (shouldn't get this definition from here) */
-
-
-typedef struct {
-    blockType_e blockType;
-    U32 lastBlock;
-    U32 origSize;
-} blockProperties_t;   /* declared here for decompress and fullbench */
-
-/*! ZSTD_getcBlockSize() :
- *  Provides the size of compressed block from block header `src` */
-/*  Used by: decompress, fullbench */
-size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
-                          blockProperties_t* bpPtr);
-
-/*! ZSTD_decodeSeqHeaders() :
- *  decode sequence header from src */
-/*  Used by: zstd_decompress_block, fullbench */
-size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
-                       const void* src, size_t srcSize);
-
-/**
- * @returns true iff the CPU supports dynamic BMI2 dispatch.
- */
-MEM_STATIC int ZSTD_cpuSupportsBmi2(void)
-{
-    ZSTD_cpuid_t cpuid = ZSTD_cpuid();
-    return ZSTD_cpuid_bmi1(cpuid) && ZSTD_cpuid_bmi2(cpuid);
-}
-
-} // namespace duckdb_zstd
-
-#endif   /* ZSTD_CCOMMON_H_MODULE */
diff --git a/src/duckdb/third_party/zstd/include/zstd/common/zstd_trace.h b/src/duckdb/third_party/zstd/include/zstd/common/zstd_trace.h
deleted file mode 100644
index 045ce9067..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/common/zstd_trace.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_TRACE_H
-#define ZSTD_TRACE_H
-
-#include <stddef.h>
-
-namespace duckdb_zstd {
-
-/* weak symbol support
- * For now, enable conservatively:
- * - Only GNUC
- * - Only ELF
- * - Only x86-64, i386 and aarch64
- * Also, explicitly disable on platforms known not to work so they aren't
- * forgotten in the future.
- */
-#if !defined(ZSTD_HAVE_WEAK_SYMBOLS) && \
-    defined(__GNUC__) && defined(__ELF__) && \
-    (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86) || defined(__aarch64__)) && \
-    !defined(__APPLE__) && !defined(_WIN32) && !defined(__MINGW32__) && \
-    !defined(__CYGWIN__) && !defined(_AIX)
-#  define ZSTD_HAVE_WEAK_SYMBOLS 1
-#else
-#  define ZSTD_HAVE_WEAK_SYMBOLS 0
-#endif
-#if ZSTD_HAVE_WEAK_SYMBOLS
-#  define ZSTD_WEAK_ATTR __attribute__((__weak__))
-#else
-#  define ZSTD_WEAK_ATTR
-#endif
-
-/* Only enable tracing when weak symbols are available. */
-#ifndef ZSTD_TRACE
-#  define ZSTD_TRACE ZSTD_HAVE_WEAK_SYMBOLS
-#endif
-
-#if ZSTD_TRACE
-
-struct ZSTD_CCtx_s;
-struct ZSTD_DCtx_s;
-struct ZSTD_CCtx_params_s;
-
-typedef struct {
-    /**
-     * ZSTD_VERSION_NUMBER
-     *
-     * This is guaranteed to be the first member of ZSTD_trace.
-     * Otherwise, this struct is not stable between versions. If
-     * the version number does not match your expectation, you
-     * should not interpret the rest of the struct.
-     */
-    unsigned version;
-    /**
-     * Non-zero if streaming (de)compression is used.
-     */
-    unsigned streaming;
-    /**
-     * The dictionary ID.
-     */
-    unsigned dictionaryID;
-    /**
-     * Is the dictionary cold?
-     * Only set on decompression.
-     */
-    unsigned dictionaryIsCold;
-    /**
-     * The dictionary size or zero if no dictionary.
-     */
-    size_t dictionarySize;
-    /**
-     * The uncompressed size of the data.
-     */
-    size_t uncompressedSize;
-    /**
-     * The compressed size of the data.
-     */
-    size_t compressedSize;
-    /**
-     * The fully resolved CCtx parameters (NULL on decompression).
-     */
-    struct ZSTD_CCtx_params_s const* params;
-    /**
-     * The ZSTD_CCtx pointer (NULL on decompression).
-     */
-    struct ZSTD_CCtx_s const* cctx;
-    /**
-     * The ZSTD_DCtx pointer (NULL on compression).
-     */
-    struct ZSTD_DCtx_s const* dctx;
-} ZSTD_Trace;
-
-/**
- * A tracing context. It must be 0 when tracing is disabled.
- * Otherwise, any non-zero value returned by a tracing begin()
- * function is presented to any subsequent calls to end().
- *
- * Any non-zero value is treated as tracing is enabled and not
- * interpreted by the library.
- *
- * Two possible uses are:
- * * A timestamp for when the begin() function was called.
- * * A unique key identifying the (de)compression, like the
- *   address of the [dc]ctx pointer if you need to track
- *   more information than just a timestamp.
- */
-typedef unsigned long long ZSTD_TraceCtx;
-
-/**
- * Trace the beginning of a compression call.
- * @param cctx The dctx pointer for the compression.
- *             It can be used as a key to map begin() to end().
- * @returns Non-zero if tracing is enabled. The return value is
- *          passed to ZSTD_trace_compress_end().
- */
-ZSTD_WEAK_ATTR ZSTD_TraceCtx ZSTD_trace_compress_begin(
-    struct ZSTD_CCtx_s const* cctx);
-
-/**
- * Trace the end of a compression call.
- * @param ctx The return value of ZSTD_trace_compress_begin().
- * @param trace The zstd tracing info.
- */
-ZSTD_WEAK_ATTR void ZSTD_trace_compress_end(
-    ZSTD_TraceCtx ctx,
-    ZSTD_Trace const* trace);
-
-/**
- * Trace the beginning of a decompression call.
- * @param dctx The dctx pointer for the decompression.
- *             It can be used as a key to map begin() to end().
- * @returns Non-zero if tracing is enabled. The return value is
- *          passed to ZSTD_trace_compress_end().
- */
-ZSTD_WEAK_ATTR ZSTD_TraceCtx ZSTD_trace_decompress_begin(
-    struct ZSTD_DCtx_s const* dctx);
-
-/**
- * Trace the end of a decompression call.
- * @param ctx The return value of ZSTD_trace_decompress_begin().
- * @param trace The zstd tracing info.
- */
-ZSTD_WEAK_ATTR void ZSTD_trace_decompress_end(
-    ZSTD_TraceCtx ctx,
-    ZSTD_Trace const* trace);
-
-#endif /* ZSTD_TRACE */
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_TRACE_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/clevels.h b/src/duckdb/third_party/zstd/include/zstd/compress/clevels.h
deleted file mode 100644
index be9424b13..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/clevels.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_CLEVELS_H
-#define ZSTD_CLEVELS_H
-
-#define ZSTD_STATIC_LINKING_ONLY  /* ZSTD_compressionParameters  */
-#include "zstd.h"
-
-namespace duckdb_zstd {
-
-/*-=====  Pre-defined compression levels  =====-*/
-
-#define ZSTD_MAX_CLEVEL     22
-
-#ifdef __GNUC__
-__attribute__((__unused__))
-#endif
-
-static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
-{   /* "default" - for any srcSize > 256 KB */
-    /* W,  C,  H,  S,  L, TL, strat */
-    { 19, 12, 13,  1,  6,  1, ZSTD_fast    },  /* base for negative levels */
-    { 19, 13, 14,  1,  7,  0, ZSTD_fast    },  /* level  1 */
-    { 20, 15, 16,  1,  6,  0, ZSTD_fast    },  /* level  2 */
-    { 21, 16, 17,  1,  5,  0, ZSTD_dfast   },  /* level  3 */
-    { 21, 18, 18,  1,  5,  0, ZSTD_dfast   },  /* level  4 */
-    { 21, 18, 19,  3,  5,  2, ZSTD_greedy  },  /* level  5 */
-    { 21, 18, 19,  3,  5,  4, ZSTD_lazy    },  /* level  6 */
-    { 21, 19, 20,  4,  5,  8, ZSTD_lazy    },  /* level  7 */
-    { 21, 19, 20,  4,  5, 16, ZSTD_lazy2   },  /* level  8 */
-    { 22, 20, 21,  4,  5, 16, ZSTD_lazy2   },  /* level  9 */
-    { 22, 21, 22,  5,  5, 16, ZSTD_lazy2   },  /* level 10 */
-    { 22, 21, 22,  6,  5, 16, ZSTD_lazy2   },  /* level 11 */
-    { 22, 22, 23,  6,  5, 32, ZSTD_lazy2   },  /* level 12 */
-    { 22, 22, 22,  4,  5, 32, ZSTD_btlazy2 },  /* level 13 */
-    { 22, 22, 23,  5,  5, 32, ZSTD_btlazy2 },  /* level 14 */
-    { 22, 23, 23,  6,  5, 32, ZSTD_btlazy2 },  /* level 15 */
-    { 22, 22, 22,  5,  5, 48, ZSTD_btopt   },  /* level 16 */
-    { 23, 23, 22,  5,  4, 64, ZSTD_btopt   },  /* level 17 */
-    { 23, 23, 22,  6,  3, 64, ZSTD_btultra },  /* level 18 */
-    { 23, 24, 22,  7,  3,256, ZSTD_btultra2},  /* level 19 */
-    { 25, 25, 23,  7,  3,256, ZSTD_btultra2},  /* level 20 */
-    { 26, 26, 24,  7,  3,512, ZSTD_btultra2},  /* level 21 */
-    { 27, 27, 25,  9,  3,999, ZSTD_btultra2},  /* level 22 */
-},
-{   /* for srcSize <= 256 KB */
-    /* W,  C,  H,  S,  L,  T, strat */
-    { 18, 12, 13,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */
-    { 18, 13, 14,  1,  6,  0, ZSTD_fast    },  /* level  1 */
-    { 18, 14, 14,  1,  5,  0, ZSTD_dfast   },  /* level  2 */
-    { 18, 16, 16,  1,  4,  0, ZSTD_dfast   },  /* level  3 */
-    { 18, 16, 17,  3,  5,  2, ZSTD_greedy  },  /* level  4.*/
-    { 18, 17, 18,  5,  5,  2, ZSTD_greedy  },  /* level  5.*/
-    { 18, 18, 19,  3,  5,  4, ZSTD_lazy    },  /* level  6.*/
-    { 18, 18, 19,  4,  4,  4, ZSTD_lazy    },  /* level  7 */
-    { 18, 18, 19,  4,  4,  8, ZSTD_lazy2   },  /* level  8 */
-    { 18, 18, 19,  5,  4,  8, ZSTD_lazy2   },  /* level  9 */
-    { 18, 18, 19,  6,  4,  8, ZSTD_lazy2   },  /* level 10 */
-    { 18, 18, 19,  5,  4, 12, ZSTD_btlazy2 },  /* level 11.*/
-    { 18, 19, 19,  7,  4, 12, ZSTD_btlazy2 },  /* level 12.*/
-    { 18, 18, 19,  4,  4, 16, ZSTD_btopt   },  /* level 13 */
-    { 18, 18, 19,  4,  3, 32, ZSTD_btopt   },  /* level 14.*/
-    { 18, 18, 19,  6,  3,128, ZSTD_btopt   },  /* level 15.*/
-    { 18, 19, 19,  6,  3,128, ZSTD_btultra },  /* level 16.*/
-    { 18, 19, 19,  8,  3,256, ZSTD_btultra },  /* level 17.*/
-    { 18, 19, 19,  6,  3,128, ZSTD_btultra2},  /* level 18.*/
-    { 18, 19, 19,  8,  3,256, ZSTD_btultra2},  /* level 19.*/
-    { 18, 19, 19, 10,  3,512, ZSTD_btultra2},  /* level 20.*/
-    { 18, 19, 19, 12,  3,512, ZSTD_btultra2},  /* level 21.*/
-    { 18, 19, 19, 13,  3,999, ZSTD_btultra2},  /* level 22.*/
-},
-{   /* for srcSize <= 128 KB */
-    /* W,  C,  H,  S,  L,  T, strat */
-    { 17, 12, 12,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */
-    { 17, 12, 13,  1,  6,  0, ZSTD_fast    },  /* level  1 */
-    { 17, 13, 15,  1,  5,  0, ZSTD_fast    },  /* level  2 */
-    { 17, 15, 16,  2,  5,  0, ZSTD_dfast   },  /* level  3 */
-    { 17, 17, 17,  2,  4,  0, ZSTD_dfast   },  /* level  4 */
-    { 17, 16, 17,  3,  4,  2, ZSTD_greedy  },  /* level  5 */
-    { 17, 16, 17,  3,  4,  4, ZSTD_lazy    },  /* level  6 */
-    { 17, 16, 17,  3,  4,  8, ZSTD_lazy2   },  /* level  7 */
-    { 17, 16, 17,  4,  4,  8, ZSTD_lazy2   },  /* level  8 */
-    { 17, 16, 17,  5,  4,  8, ZSTD_lazy2   },  /* level  9 */
-    { 17, 16, 17,  6,  4,  8, ZSTD_lazy2   },  /* level 10 */
-    { 17, 17, 17,  5,  4,  8, ZSTD_btlazy2 },  /* level 11 */
-    { 17, 18, 17,  7,  4, 12, ZSTD_btlazy2 },  /* level 12 */
-    { 17, 18, 17,  3,  4, 12, ZSTD_btopt   },  /* level 13.*/
-    { 17, 18, 17,  4,  3, 32, ZSTD_btopt   },  /* level 14.*/
-    { 17, 18, 17,  6,  3,256, ZSTD_btopt   },  /* level 15.*/
-    { 17, 18, 17,  6,  3,128, ZSTD_btultra },  /* level 16.*/
-    { 17, 18, 17,  8,  3,256, ZSTD_btultra },  /* level 17.*/
-    { 17, 18, 17, 10,  3,512, ZSTD_btultra },  /* level 18.*/
-    { 17, 18, 17,  5,  3,256, ZSTD_btultra2},  /* level 19.*/
-    { 17, 18, 17,  7,  3,512, ZSTD_btultra2},  /* level 20.*/
-    { 17, 18, 17,  9,  3,512, ZSTD_btultra2},  /* level 21.*/
-    { 17, 18, 17, 11,  3,999, ZSTD_btultra2},  /* level 22.*/
-},
-{   /* for srcSize <= 16 KB */
-    /* W,  C,  H,  S,  L,  T, strat */
-    { 14, 12, 13,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */
-    { 14, 14, 15,  1,  5,  0, ZSTD_fast    },  /* level  1 */
-    { 14, 14, 15,  1,  4,  0, ZSTD_fast    },  /* level  2 */
-    { 14, 14, 15,  2,  4,  0, ZSTD_dfast   },  /* level  3 */
-    { 14, 14, 14,  4,  4,  2, ZSTD_greedy  },  /* level  4 */
-    { 14, 14, 14,  3,  4,  4, ZSTD_lazy    },  /* level  5.*/
-    { 14, 14, 14,  4,  4,  8, ZSTD_lazy2   },  /* level  6 */
-    { 14, 14, 14,  6,  4,  8, ZSTD_lazy2   },  /* level  7 */
-    { 14, 14, 14,  8,  4,  8, ZSTD_lazy2   },  /* level  8.*/
-    { 14, 15, 14,  5,  4,  8, ZSTD_btlazy2 },  /* level  9.*/
-    { 14, 15, 14,  9,  4,  8, ZSTD_btlazy2 },  /* level 10.*/
-    { 14, 15, 14,  3,  4, 12, ZSTD_btopt   },  /* level 11.*/
-    { 14, 15, 14,  4,  3, 24, ZSTD_btopt   },  /* level 12.*/
-    { 14, 15, 14,  5,  3, 32, ZSTD_btultra },  /* level 13.*/
-    { 14, 15, 15,  6,  3, 64, ZSTD_btultra },  /* level 14.*/
-    { 14, 15, 15,  7,  3,256, ZSTD_btultra },  /* level 15.*/
-    { 14, 15, 15,  5,  3, 48, ZSTD_btultra2},  /* level 16.*/
-    { 14, 15, 15,  6,  3,128, ZSTD_btultra2},  /* level 17.*/
-    { 14, 15, 15,  7,  3,256, ZSTD_btultra2},  /* level 18.*/
-    { 14, 15, 15,  8,  3,256, ZSTD_btultra2},  /* level 19.*/
-    { 14, 15, 15,  8,  3,512, ZSTD_btultra2},  /* level 20.*/
-    { 14, 15, 15,  9,  3,512, ZSTD_btultra2},  /* level 21.*/
-    { 14, 15, 15, 10,  3,999, ZSTD_btultra2},  /* level 22.*/
-},
-};
-
-} // namespace duckdb_zstd
-
-#endif  /* ZSTD_CLEVELS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/hist.h b/src/duckdb/third_party/zstd/include/zstd/compress/hist.h
deleted file mode 100644
index 083af82c1..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/hist.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/* ******************************************************************
- * hist : Histogram functions
- * part of Finite State Entropy project
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- *  You can contact the author at :
- *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* --- dependencies --- */
-#include "zstd/common/zstd_deps.h"   /* size_t */
-
-namespace duckdb_zstd {
-
-/* --- simple histogram functions --- */
-
-/*! HIST_count():
- *  Provides the precise count of each byte within a table 'count'.
- * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
- *  Updates *maxSymbolValuePtr with actual largest symbol value detected.
- * @return : count of the most frequent symbol (which isn't identified).
- *           or an error code, which can be tested using HIST_isError().
- *           note : if return == srcSize, there is only one symbol.
- */
-size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
-                  const void* src, size_t srcSize);
-
-unsigned HIST_isError(size_t code);  /**< tells if a return value is an error code */
-
-
-/* --- advanced histogram functions --- */
-
-#define HIST_WKSP_SIZE_U32 1024
-#define HIST_WKSP_SIZE    (HIST_WKSP_SIZE_U32 * sizeof(unsigned))
-/** HIST_count_wksp() :
- *  Same as HIST_count(), but using an externally provided scratch buffer.
- *  Benefit is this function will use very little stack space.
- * `workSpace` is a writable buffer which must be 4-bytes aligned,
- * `workSpaceSize` must be >= HIST_WKSP_SIZE
- */
-size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                       const void* src, size_t srcSize,
-                       void* workSpace, size_t workSpaceSize);
-
-/** HIST_countFast() :
- *  same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr.
- *  This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr`
- */
-size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
-                      const void* src, size_t srcSize);
-
-/** HIST_countFast_wksp() :
- *  Same as HIST_countFast(), but using an externally provided scratch buffer.
- * `workSpace` is a writable buffer which must be 4-bytes aligned,
- * `workSpaceSize` must be >= HIST_WKSP_SIZE
- */
-size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                           const void* src, size_t srcSize,
-                           void* workSpace, size_t workSpaceSize);
-
-/*! HIST_count_simple() :
- *  Same as HIST_countFast(), this function is unsafe,
- *  and will segfault if any value within `src` is `> *maxSymbolValuePtr`.
- *  It is also a bit slower for large inputs.
- *  However, it does not need any additional memory (not even on stack).
- * @return : count of the most frequent symbol.
- *  Note this function doesn't produce any error (i.e. it must succeed).
- */
-unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
-                           const void* src, size_t srcSize);
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_internal.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_internal.h
deleted file mode 100644
index 1f55ab1bc..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_internal.h
+++ /dev/null
@@ -1,1529 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* This header contains definitions
- * that shall **only** be used by modules within lib/compress.
- */
-
-#ifndef ZSTD_COMPRESS_H
-#define ZSTD_COMPRESS_H
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zstd/common/zstd_internal.h"
-#include "zstd/compress/zstd_cwksp.h"
-#ifdef ZSTD_MULTITHREAD
-#  include "zstd/compress/zstdmt_compress.h"
-#endif
-#include "zstd/common/bits.h" /* ZSTD_highbit32, ZSTD_NbCommonBytes */
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Constants
-***************************************/
-#define kSearchStrength      8
-#define HASH_READ_SIZE       8
-#define ZSTD_DUBT_UNSORTED_MARK 1   /* For btlazy2 strategy, index ZSTD_DUBT_UNSORTED_MARK==1 means "unsorted".
-                                       It could be confused for a real successor at index "1", if sorted as larger than its predecessor.
-                                       It's not a big deal though : candidate will just be sorted again.
-                                       Additionally, candidate position 1 will be lost.
-                                       But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.
-                                       The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be mishandled after table reuse with a different strategy.
-                                       This constant is required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */
-
-
-/*-*************************************
-*  Context memory management
-***************************************/
-typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
-typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
-
-typedef struct ZSTD_prefixDict_s {
-    const void* dict;
-    size_t dictSize;
-    ZSTD_dictContentType_e dictContentType;
-} ZSTD_prefixDict;
-
-typedef struct {
-    void* dictBuffer;
-    void const* dict;
-    size_t dictSize;
-    ZSTD_dictContentType_e dictContentType;
-    ZSTD_CDict* cdict;
-} ZSTD_localDict;
-
-typedef struct {
-    HUF_CElt CTable[HUF_CTABLE_SIZE_ST(255)];
-    HUF_repeat repeatMode;
-} ZSTD_hufCTables_t;
-
-typedef struct {
-    FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
-    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
-    FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
-    FSE_repeat offcode_repeatMode;
-    FSE_repeat matchlength_repeatMode;
-    FSE_repeat litlength_repeatMode;
-} ZSTD_fseCTables_t;
-
-typedef struct {
-    ZSTD_hufCTables_t huf;
-    ZSTD_fseCTables_t fse;
-} ZSTD_entropyCTables_t;
-
-/***********************************************
-*  Entropy buffer statistics structs and funcs *
-***********************************************/
-/** ZSTD_hufCTablesMetadata_t :
- *  Stores Literals Block Type for a super-block in hType, and
- *  huffman tree description in hufDesBuffer.
- *  hufDesSize refers to the size of huffman tree description in bytes.
- *  This metadata is populated in ZSTD_buildBlockEntropyStats_literals() */
-typedef struct {
-    symbolEncodingType_e hType;
-    BYTE hufDesBuffer[ZSTD_MAX_HUF_HEADER_SIZE];
-    size_t hufDesSize;
-} ZSTD_hufCTablesMetadata_t;
-
-/** ZSTD_fseCTablesMetadata_t :
- *  Stores symbol compression modes for a super-block in {ll, ol, ml}Type, and
- *  fse tables in fseTablesBuffer.
- *  fseTablesSize refers to the size of fse tables in bytes.
- *  This metadata is populated in ZSTD_buildBlockEntropyStats_sequences() */
-typedef struct {
-    symbolEncodingType_e llType;
-    symbolEncodingType_e ofType;
-    symbolEncodingType_e mlType;
-    BYTE fseTablesBuffer[ZSTD_MAX_FSE_HEADERS_SIZE];
-    size_t fseTablesSize;
-    size_t lastCountSize; /* This is to account for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */
-} ZSTD_fseCTablesMetadata_t;
-
-typedef struct {
-    ZSTD_hufCTablesMetadata_t hufMetadata;
-    ZSTD_fseCTablesMetadata_t fseMetadata;
-} ZSTD_entropyCTablesMetadata_t;
-
-/** ZSTD_buildBlockEntropyStats() :
- *  Builds entropy for the block.
- *  @return : 0 on success or error code */
-size_t ZSTD_buildBlockEntropyStats(
-                    const seqStore_t* seqStorePtr,
-                    const ZSTD_entropyCTables_t* prevEntropy,
-                          ZSTD_entropyCTables_t* nextEntropy,
-                    const ZSTD_CCtx_params* cctxParams,
-                          ZSTD_entropyCTablesMetadata_t* entropyMetadata,
-                          void* workspace, size_t wkspSize);
-
-/*********************************
-*  Compression internals structs *
-*********************************/
-
-typedef struct {
-    U32 off;            /* Offset sumtype code for the match, using ZSTD_storeSeq() format */
-    U32 len;            /* Raw length of match */
-} ZSTD_match_t;
-
-typedef struct {
-    U32 offset;         /* Offset of sequence */
-    U32 litLength;      /* Length of literals prior to match */
-    U32 matchLength;    /* Raw length of match */
-} rawSeq;
-
-typedef struct {
-  rawSeq* seq;          /* The start of the sequences */
-  size_t pos;           /* The index in seq where reading stopped. pos <= size. */
-  size_t posInSequence; /* The position within the sequence at seq[pos] where reading
-                           stopped. posInSequence <= seq[pos].litLength + seq[pos].matchLength */
-  size_t size;          /* The number of sequences. <= capacity. */
-  size_t capacity;      /* The capacity starting from `seq` pointer */
-} rawSeqStore_t;
-
-typedef struct {
-    U32 idx;            /* Index in array of ZSTD_Sequence */
-    U32 posInSequence;  /* Position within sequence at idx */
-    size_t posInSrc;    /* Number of bytes given by sequences provided so far */
-} ZSTD_sequencePosition;
-
-UNUSED_ATTR static const rawSeqStore_t kNullRawSeqStore = {NULL, 0, 0, 0, 0};
-
-typedef struct {
-    int price;  /* price from beginning of segment to this position */
-    U32 off;    /* offset of previous match */
-    U32 mlen;   /* length of previous match */
-    U32 litlen; /* nb of literals since previous match */
-    U32 rep[ZSTD_REP_NUM];  /* offset history after previous match */
-} ZSTD_optimal_t;
-
-typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;
-
-#define ZSTD_OPT_SIZE (ZSTD_OPT_NUM+3)
-typedef struct {
-    /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
-    unsigned* litFreq;           /* table of literals statistics, of size 256 */
-    unsigned* litLengthFreq;     /* table of litLength statistics, of size (MaxLL+1) */
-    unsigned* matchLengthFreq;   /* table of matchLength statistics, of size (MaxML+1) */
-    unsigned* offCodeFreq;       /* table of offCode statistics, of size (MaxOff+1) */
-    ZSTD_match_t* matchTable;    /* list of found matches, of size ZSTD_OPT_SIZE */
-    ZSTD_optimal_t* priceTable;  /* All positions tracked by optimal parser, of size ZSTD_OPT_SIZE */
-
-    U32  litSum;                 /* nb of literals */
-    U32  litLengthSum;           /* nb of litLength codes */
-    U32  matchLengthSum;         /* nb of matchLength codes */
-    U32  offCodeSum;             /* nb of offset codes */
-    U32  litSumBasePrice;        /* to compare to log2(litfreq) */
-    U32  litLengthSumBasePrice;  /* to compare to log2(llfreq)  */
-    U32  matchLengthSumBasePrice;/* to compare to log2(mlfreq)  */
-    U32  offCodeSumBasePrice;    /* to compare to log2(offreq)  */
-    ZSTD_OptPrice_e priceType;   /* prices can be determined dynamically, or follow a pre-defined cost structure */
-    const ZSTD_entropyCTables_t* symbolCosts;  /* pre-calculated dictionary statistics */
-    ZSTD_paramSwitch_e literalCompressionMode;
-} optState_t;
-
-typedef struct {
-  ZSTD_entropyCTables_t entropy;
-  U32 rep[ZSTD_REP_NUM];
-} ZSTD_compressedBlockState_t;
-
-typedef struct {
-    BYTE const* nextSrc;       /* next block here to continue on current prefix */
-    BYTE const* base;          /* All regular indexes relative to this position */
-    BYTE const* dictBase;      /* extDict indexes relative to this position */
-    U32 dictLimit;             /* below that point, need extDict */
-    U32 lowLimit;              /* below that point, no more valid data */
-    U32 nbOverflowCorrections; /* Number of times overflow correction has run since
-                                * ZSTD_window_init(). Useful for debugging coredumps
-                                * and for ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY.
-                                */
-} ZSTD_window_t;
-
-#define ZSTD_WINDOW_START_INDEX 2
-
-typedef struct ZSTD_matchState_t ZSTD_matchState_t;
-
-#define ZSTD_ROW_HASH_CACHE_SIZE 8       /* Size of prefetching hash cache for row-based matchfinder */
-
-struct ZSTD_matchState_t {
-    ZSTD_window_t window;   /* State for window round buffer management */
-    U32 loadedDictEnd;      /* index of end of dictionary, within context's referential.
-                             * When loadedDictEnd != 0, a dictionary is in use, and still valid.
-                             * This relies on a mechanism to set loadedDictEnd=0 when dictionary is no longer within distance.
-                             * Such mechanism is provided within ZSTD_window_enforceMaxDist() and ZSTD_checkDictValidity().
-                             * When dict referential is copied into active context (i.e. not attached),
-                             * loadedDictEnd == dictSize, since referential starts from zero.
-                             */
-    U32 nextToUpdate;       /* index from which to continue table update */
-    U32 hashLog3;           /* dispatch table for matches of len==3 : larger == faster, more memory */
-
-    U32 rowHashLog;                          /* For row-based matchfinder: Hashlog based on nb of rows in the hashTable.*/
-    BYTE* tagTable;                          /* For row-based matchFinder: A row-based table containing the hashes and head index. */
-    U32 hashCache[ZSTD_ROW_HASH_CACHE_SIZE]; /* For row-based matchFinder: a cache of hashes to improve speed */
-    U64 hashSalt;                            /* For row-based matchFinder: salts the hash for reuse of tag table */
-    U32 hashSaltEntropy;                     /* For row-based matchFinder: collects entropy for salt generation */
-
-    U32* hashTable;
-    U32* hashTable3;
-    U32* chainTable;
-
-    U32 forceNonContiguous; /* Non-zero if we should force non-contiguous load for the next window update. */
-
-    int dedicatedDictSearch;  /* Indicates whether this matchState is using the
-                               * dedicated dictionary search structure.
-                               */
-    optState_t opt;         /* optimal parser state */
-    const ZSTD_matchState_t* dictMatchState;
-    ZSTD_compressionParameters cParams;
-    const rawSeqStore_t* ldmSeqStore;
-
-    /* Controls prefetching in some dictMatchState matchfinders.
-     * This behavior is controlled from the cctx ms.
-     * This parameter has no effect in the cdict ms. */
-    int prefetchCDictTables;
-
-    /* When == 0, lazy match finders insert every position.
-     * When != 0, lazy match finders only insert positions they search.
-     * This allows them to skip much faster over incompressible data,
-     * at a small cost to compression ratio.
-     */
-    int lazySkipping;
-};
-
-typedef struct {
-    ZSTD_compressedBlockState_t* prevCBlock;
-    ZSTD_compressedBlockState_t* nextCBlock;
-    ZSTD_matchState_t matchState;
-} ZSTD_blockState_t;
-
-typedef struct {
-    U32 offset;
-    U32 checksum;
-} ldmEntry_t;
-
-typedef struct {
-    BYTE const* split;
-    U32 hash;
-    U32 checksum;
-    ldmEntry_t* bucket;
-} ldmMatchCandidate_t;
-
-#define LDM_BATCH_SIZE 64
-
-typedef struct {
-    ZSTD_window_t window;   /* State for the window round buffer management */
-    ldmEntry_t* hashTable;
-    U32 loadedDictEnd;
-    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */
-    size_t splitIndices[LDM_BATCH_SIZE];
-    ldmMatchCandidate_t matchCandidates[LDM_BATCH_SIZE];
-} ldmState_t;
-
-typedef struct {
-    ZSTD_paramSwitch_e enableLdm; /* ZSTD_ps_enable to enable LDM. ZSTD_ps_auto by default */
-    U32 hashLog;            /* Log size of hashTable */
-    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */
-    U32 minMatchLength;     /* Minimum match length */
-    U32 hashRateLog;       /* Log number of entries to skip */
-    U32 windowLog;          /* Window log for the LDM */
-} ldmParams_t;
-
-typedef struct {
-    int collectSequences;
-    ZSTD_Sequence* seqStart;
-    size_t seqIndex;
-    size_t maxSequences;
-} SeqCollector;
-
-struct ZSTD_CCtx_params_s {
-    ZSTD_format_e format;
-    ZSTD_compressionParameters cParams;
-    ZSTD_frameParameters fParams;
-
-    int compressionLevel;
-    int forceWindow;           /* force back-references to respect limit of
-                                * 1<<wLog, even for dictionary */
-    size_t targetCBlockSize;   /* Tries to fit compressed block size to be around targetCBlockSize.
-                                * No target when targetCBlockSize == 0.
-                                * There is no guarantee on compressed block size */
-    int srcSizeHint;           /* User's best guess of source size.
-                                * Hint is not valid when srcSizeHint == 0.
-                                * There is no guarantee that hint is close to actual source size */
-
-    ZSTD_dictAttachPref_e attachDictPref;
-    ZSTD_paramSwitch_e literalCompressionMode;
-
-    /* Multithreading: used to pass parameters to mtctx */
-    int nbWorkers;
-    size_t jobSize;
-    int overlapLog;
-    int rsyncable;
-
-    /* Long distance matching parameters */
-    ldmParams_t ldmParams;
-
-    /* Dedicated dict search algorithm trigger */
-    int enableDedicatedDictSearch;
-
-    /* Input/output buffer modes */
-    ZSTD_bufferMode_e inBufferMode;
-    ZSTD_bufferMode_e outBufferMode;
-
-    /* Sequence compression API */
-    ZSTD_sequenceFormat_e blockDelimiters;
-    int validateSequences;
-
-    /* Block splitting */
-    ZSTD_paramSwitch_e useBlockSplitter;
-
-    /* Param for deciding whether to use row-based matchfinder */
-    ZSTD_paramSwitch_e useRowMatchFinder;
-
-    /* Always load a dictionary in ext-dict mode (not prefix mode)? */
-    int deterministicRefPrefix;
-
-    /* Internal use, for createCCtxParams() and freeCCtxParams() only */
-    ZSTD_customMem customMem;
-
-    /* Controls prefetching in some dictMatchState matchfinders */
-    ZSTD_paramSwitch_e prefetchCDictTables;
-
-    /* Controls whether zstd will fall back to an internal matchfinder
-     * if the external matchfinder returns an error code. */
-    int enableMatchFinderFallback;
-
-    /* Parameters for the external sequence producer API.
-     * Users set these parameters through ZSTD_registerSequenceProducer().
-     * It is not possible to set these parameters individually through the public API. */
-    void* extSeqProdState;
-    ZSTD_sequenceProducer_F extSeqProdFunc;
-
-    /* Adjust the max block size*/
-    size_t maxBlockSize;
-
-    /* Controls repcode search in external sequence parsing */
-    ZSTD_paramSwitch_e searchForExternalRepcodes;
-};  /* typedef'd to ZSTD_CCtx_params within "zstd.h" */
-
-#define COMPRESS_SEQUENCES_WORKSPACE_SIZE (sizeof(unsigned) * (MaxSeq + 2))
-#define ENTROPY_WORKSPACE_SIZE (HUF_WORKSPACE_SIZE + COMPRESS_SEQUENCES_WORKSPACE_SIZE)
-
-/**
- * Indicates whether this compression proceeds directly from user-provided
- * source buffer to user-provided destination buffer (ZSTDb_not_buffered), or
- * whether the context needs to buffer the input/output (ZSTDb_buffered).
- */
-typedef enum {
-    ZSTDb_not_buffered,
-    ZSTDb_buffered
-} ZSTD_buffered_policy_e;
-
-/**
- * Struct that contains all elements of block splitter that should be allocated
- * in a wksp.
- */
-#define ZSTD_MAX_NB_BLOCK_SPLITS 196
-typedef struct {
-    seqStore_t fullSeqStoreChunk;
-    seqStore_t firstHalfSeqStore;
-    seqStore_t secondHalfSeqStore;
-    seqStore_t currSeqStore;
-    seqStore_t nextSeqStore;
-
-    U32 partitions[ZSTD_MAX_NB_BLOCK_SPLITS];
-    ZSTD_entropyCTablesMetadata_t entropyMetadata;
-} ZSTD_blockSplitCtx;
-
-struct ZSTD_CCtx_s {
-    ZSTD_compressionStage_e stage;
-    int cParamsChanged;                  /* == 1 if cParams(except wlog) or compression level are changed in requestedParams. Triggers transmission of new params to ZSTDMT (if available) then reset to 0. */
-    int bmi2;                            /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
-    ZSTD_CCtx_params requestedParams;
-    ZSTD_CCtx_params appliedParams;
-    ZSTD_CCtx_params simpleApiParams;    /* Param storage used by the simple API - not sticky. Must only be used in top-level simple API functions for storage. */
-    U32   dictID;
-    size_t dictContentSize;
-
-    ZSTD_cwksp workspace; /* manages buffer for dynamic allocations */
-    size_t blockSize;
-    unsigned long long pledgedSrcSizePlusOne;  /* this way, 0 (default) == unknown */
-    unsigned long long consumedSrcSize;
-    unsigned long long producedCSize;
-    XXH64_state_t xxhState;
-    ZSTD_customMem customMem;
-    ZSTD_threadPool* pool;
-    size_t staticSize;
-    SeqCollector seqCollector;
-    int isFirstBlock;
-    int initialized;
-
-    seqStore_t seqStore;      /* sequences storage ptrs */
-    ldmState_t ldmState;      /* long distance matching state */
-    rawSeq* ldmSequences;     /* Storage for the ldm output sequences */
-    size_t maxNbLdmSequences;
-    rawSeqStore_t externSeqStore; /* Mutable reference to external sequences */
-    ZSTD_blockState_t blockState;
-    U32* entropyWorkspace;  /* entropy workspace of ENTROPY_WORKSPACE_SIZE bytes */
-
-    /* Whether we are streaming or not */
-    ZSTD_buffered_policy_e bufferedPolicy;
-
-    /* streaming */
-    char*  inBuff;
-    size_t inBuffSize;
-    size_t inToCompress;
-    size_t inBuffPos;
-    size_t inBuffTarget;
-    char*  outBuff;
-    size_t outBuffSize;
-    size_t outBuffContentSize;
-    size_t outBuffFlushedSize;
-    ZSTD_cStreamStage streamStage;
-    U32    frameEnded;
-
-    /* Stable in/out buffer verification */
-    ZSTD_inBuffer expectedInBuffer;
-    size_t stableIn_notConsumed; /* nb bytes within stable input buffer that are said to be consumed but are not */
-    size_t expectedOutBufferSize;
-
-    /* Dictionary */
-    ZSTD_localDict localDict;
-    const ZSTD_CDict* cdict;
-    ZSTD_prefixDict prefixDict;   /* single-usage dictionary */
-
-    /* Multi-threading */
-#ifdef ZSTD_MULTITHREAD
-    ZSTDMT_CCtx* mtctx;
-#endif
-
-    /* Tracing */
-#if ZSTD_TRACE
-    ZSTD_TraceCtx traceCtx;
-#endif
-
-    /* Workspace for block splitter */
-    ZSTD_blockSplitCtx blockSplitCtx;
-
-    /* Buffer for output from external sequence producer */
-    ZSTD_Sequence* extSeqBuf;
-    size_t extSeqBufCapacity;
-};
-
-typedef enum { ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e;
-typedef enum { ZSTD_tfp_forCCtx, ZSTD_tfp_forCDict } ZSTD_tableFillPurpose_e;
-
-typedef enum {
-    ZSTD_noDict = 0,
-    ZSTD_extDict = 1,
-    ZSTD_dictMatchState = 2,
-    ZSTD_dedicatedDictSearch = 3
-} ZSTD_dictMode_e;
-
-typedef enum {
-    ZSTD_cpm_noAttachDict = 0,  /* Compression with ZSTD_noDict or ZSTD_extDict.
-                                 * In this mode we use both the srcSize and the dictSize
-                                 * when selecting and adjusting parameters.
-                                 */
-    ZSTD_cpm_attachDict = 1,    /* Compression with ZSTD_dictMatchState or ZSTD_dedicatedDictSearch.
-                                 * In this mode we only take the srcSize into account when selecting
-                                 * and adjusting parameters.
-                                 */
-    ZSTD_cpm_createCDict = 2,   /* Creating a CDict.
-                                 * In this mode we take both the source size and the dictionary size
-                                 * into account when selecting and adjusting the parameters.
-                                 */
-    ZSTD_cpm_unknown = 3        /* ZSTD_getCParams, ZSTD_getParams, ZSTD_adjustParams.
-                                 * We don't know what these parameters are for. We default to the legacy
-                                 * behavior of taking both the source size and the dict size into account
-                                 * when selecting and adjusting parameters.
-                                 */
-} ZSTD_cParamMode_e;
-
-typedef size_t (*ZSTD_blockCompressor) (
-        ZSTD_matchState_t* bs, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramSwitch_e rowMatchfinderMode, ZSTD_dictMode_e dictMode);
-
-
-MEM_STATIC U32 ZSTD_LLcode(U32 litLength)
-{
-    static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
-                                       8,  9, 10, 11, 12, 13, 14, 15,
-                                      16, 16, 17, 17, 18, 18, 19, 19,
-                                      20, 20, 20, 20, 21, 21, 21, 21,
-                                      22, 22, 22, 22, 22, 22, 22, 22,
-                                      23, 23, 23, 23, 23, 23, 23, 23,
-                                      24, 24, 24, 24, 24, 24, 24, 24,
-                                      24, 24, 24, 24, 24, 24, 24, 24 };
-    static const U32 LL_deltaCode = 19;
-    return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
-}
-
-/* ZSTD_MLcode() :
- * note : mlBase = matchLength - MINMATCH;
- *        because it's the format it's stored in seqStore->sequences */
-MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
-{
-    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
-                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
-                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
-                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
-                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
-    static const U32 ML_deltaCode = 36;
-    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
-}
-
-/* ZSTD_cParam_withinBounds:
- * @return 1 if value is within cParam bounds,
- * 0 otherwise */
-MEM_STATIC int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
-{
-    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
-    if (ZSTD_isError(bounds.error)) return 0;
-    if (value < bounds.lowerBound) return 0;
-    if (value > bounds.upperBound) return 0;
-    return 1;
-}
-
-/* ZSTD_noCompressBlock() :
- * Writes uncompressed block to dst buffer from given src.
- * Returns the size of the block */
-MEM_STATIC size_t
-ZSTD_noCompressBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
-{
-    U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
-    DEBUGLOG(5, "ZSTD_noCompressBlock (srcSize=%zu, dstCapacity=%zu)", srcSize, dstCapacity);
-    RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
-                    dstSize_tooSmall, "dst buf too small for uncompressed block");
-    MEM_writeLE24(dst, cBlockHeader24);
-    ZSTD_memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);
-    return ZSTD_blockHeaderSize + srcSize;
-}
-
-MEM_STATIC size_t
-ZSTD_rleCompressBlock(void* dst, size_t dstCapacity, BYTE src, size_t srcSize, U32 lastBlock)
-{
-    BYTE* const op = (BYTE*)dst;
-    U32 const cBlockHeader = lastBlock + (((U32)bt_rle)<<1) + (U32)(srcSize << 3);
-    RETURN_ERROR_IF(dstCapacity < 4, dstSize_tooSmall, "");
-    MEM_writeLE24(op, cBlockHeader);
-    op[3] = src;
-    return 4;
-}
-
-
-/* ZSTD_minGain() :
- * minimum compression required
- * to generate a compress block or a compressed literals section.
- * note : use same formula for both situations */
-MEM_STATIC size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
-{
-    U32 const minlog = (strat>=ZSTD_btultra) ? (U32)(strat) - 1 : 6;
-    ZSTD_STATIC_ASSERT(ZSTD_btultra == 8);
-    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, (int)strat));
-    return (srcSize >> minlog) + 2;
-}
-
-MEM_STATIC int ZSTD_literalsCompressionIsDisabled(const ZSTD_CCtx_params* cctxParams)
-{
-    switch (cctxParams->literalCompressionMode) {
-    case ZSTD_ps_enable:
-        return 0;
-    case ZSTD_ps_disable:
-        return 1;
-    default:
-        assert(0 /* impossible: pre-validated */);
-        ZSTD_FALLTHROUGH;
-    case ZSTD_ps_auto:
-        return (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);
-    }
-}
-
-/*! ZSTD_safecopyLiterals() :
- *  memcpy() function that won't read beyond more than WILDCOPY_OVERLENGTH bytes past ilimit_w.
- *  Only called when the sequence ends past ilimit_w, so it only needs to be optimized for single
- *  large copies.
- */
-static void
-ZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE const* ilimit_w)
-{
-    assert(iend > ilimit_w);
-    if (ip <= ilimit_w) {
-        ZSTD_wildcopy(op, ip, ilimit_w - ip, ZSTD_no_overlap);
-        op += ilimit_w - ip;
-        ip = ilimit_w;
-    }
-    while (ip < iend) *op++ = *ip++;
-}
-
-
-#define REPCODE1_TO_OFFBASE REPCODE_TO_OFFBASE(1)
-#define REPCODE2_TO_OFFBASE REPCODE_TO_OFFBASE(2)
-#define REPCODE3_TO_OFFBASE REPCODE_TO_OFFBASE(3)
-#define REPCODE_TO_OFFBASE(r) (assert((r)>=1), assert((r)<=ZSTD_REP_NUM), (r)) /* accepts IDs 1,2,3 */
-#define OFFSET_TO_OFFBASE(o)  (assert((o)>0), o + ZSTD_REP_NUM)
-#define OFFBASE_IS_OFFSET(o)  ((o) > ZSTD_REP_NUM)
-#define OFFBASE_IS_REPCODE(o) ( 1 <= (o) && (o) <= ZSTD_REP_NUM)
-#define OFFBASE_TO_OFFSET(o)  (assert(OFFBASE_IS_OFFSET(o)), (o) - ZSTD_REP_NUM)
-#define OFFBASE_TO_REPCODE(o) (assert(OFFBASE_IS_REPCODE(o)), (o))  /* returns ID 1,2,3 */
-
-/*! ZSTD_storeSeq() :
- *  Store a sequence (litlen, litPtr, offBase and matchLength) into seqStore_t.
- *  @offBase : Users should employ macros REPCODE_TO_OFFBASE() and OFFSET_TO_OFFBASE().
- *  @matchLength : must be >= MINMATCH
- *  Allowed to over-read literals up to litLimit.
-*/
-HINT_INLINE UNUSED_ATTR void
-ZSTD_storeSeq(seqStore_t* seqStorePtr,
-              size_t litLength, const BYTE* literals, const BYTE* litLimit,
-              U32 offBase,
-              size_t matchLength)
-{
-    BYTE const* const litLimit_w = litLimit - WILDCOPY_OVERLENGTH;
-    BYTE const* const litEnd = literals + litLength;
-#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)
-    static const BYTE* g_start = NULL;
-    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
-    {   U32 const pos = (U32)((const BYTE*)literals - g_start);
-        DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offBase%7u",
-               pos, (U32)litLength, (U32)matchLength, (U32)offBase);
-    }
-#endif
-    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);
-    /* copy Literals */
-    assert(seqStorePtr->maxNbLit <= 128 KB);
-    assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);
-    assert(literals + litLength <= litLimit);
-    if (litEnd <= litLimit_w) {
-        /* Common case we can use wildcopy.
-         * First copy 16 bytes, because literals are likely short.
-         */
-        ZSTD_STATIC_ASSERT(WILDCOPY_OVERLENGTH >= 16);
-        ZSTD_copy16(seqStorePtr->lit, literals);
-        if (litLength > 16) {
-            ZSTD_wildcopy(seqStorePtr->lit+16, literals+16, (ptrdiff_t)litLength-16, ZSTD_no_overlap);
-        }
-    } else {
-        ZSTD_safecopyLiterals(seqStorePtr->lit, literals, litEnd, litLimit_w);
-    }
-    seqStorePtr->lit += litLength;
-
-    /* literal Length */
-    if (litLength>0xFFFF) {
-        assert(seqStorePtr->longLengthType == ZSTD_llt_none); /* there can only be a single long length */
-        seqStorePtr->longLengthType = ZSTD_llt_literalLength;
-        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    }
-    seqStorePtr->sequences[0].litLength = (U16)litLength;
-
-    /* match offset */
-    seqStorePtr->sequences[0].offBase = offBase;
-
-    /* match Length */
-    assert(matchLength >= MINMATCH);
-    {   size_t const mlBase = matchLength - MINMATCH;
-        if (mlBase>0xFFFF) {
-            assert(seqStorePtr->longLengthType == ZSTD_llt_none); /* there can only be a single long length */
-            seqStorePtr->longLengthType = ZSTD_llt_matchLength;
-            seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-        }
-        seqStorePtr->sequences[0].mlBase = (U16)mlBase;
-    }
-
-    seqStorePtr->sequences++;
-}
-
-/* ZSTD_updateRep() :
- * updates in-place @rep (array of repeat offsets)
- * @offBase : sum-type, using numeric representation of ZSTD_storeSeq()
- */
-MEM_STATIC void
-ZSTD_updateRep(U32 rep[ZSTD_REP_NUM], U32 const offBase, U32 const ll0)
-{
-    if (OFFBASE_IS_OFFSET(offBase)) {  /* full offset */
-        rep[2] = rep[1];
-        rep[1] = rep[0];
-        rep[0] = OFFBASE_TO_OFFSET(offBase);
-    } else {   /* repcode */
-        U32 const repCode = OFFBASE_TO_REPCODE(offBase) - 1 + ll0;
-        if (repCode > 0) {  /* note : if repCode==0, no change */
-            U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
-            rep[2] = (repCode >= 2) ? rep[1] : rep[2];
-            rep[1] = rep[0];
-            rep[0] = currentOffset;
-        } else {   /* repCode == 0 */
-            /* nothing to do */
-        }
-    }
-}
-
-typedef struct repcodes_s {
-    U32 rep[3];
-} repcodes_t;
-
-MEM_STATIC repcodes_t
-ZSTD_newRep(U32 const rep[ZSTD_REP_NUM], U32 const offBase, U32 const ll0)
-{
-    repcodes_t newReps;
-    ZSTD_memcpy(&newReps, rep, sizeof(newReps));
-    ZSTD_updateRep(newReps.rep, offBase, ll0);
-    return newReps;
-}
-
-
-/*-*************************************
-*  Match length counter
-***************************************/
-MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)
-{
-    const BYTE* const pStart = pIn;
-    const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);
-
-    if (pIn < pInLoopLimit) {
-        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
-          if (diff) return ZSTD_NbCommonBytes(diff); }
-        pIn+=sizeof(size_t); pMatch+=sizeof(size_t);
-        while (pIn < pInLoopLimit) {
-            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
-            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
-            pIn += ZSTD_NbCommonBytes(diff);
-            return (size_t)(pIn - pStart);
-    }   }
-    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (size_t)(pIn - pStart);
-}
-
-/** ZSTD_count_2segments() :
- *  can count match length with `ip` & `match` in 2 different segments.
- *  convention : on reaching mEnd, match count continue starting from iStart
- */
-MEM_STATIC size_t
-ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
-                     const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
-{
-    const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
-    size_t const matchLength = ZSTD_count(ip, match, vEnd);
-    if (match + matchLength != mEnd) return matchLength;
-    DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength);
-    DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match);
-    DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip);
-    DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart);
-    DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd));
-    return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd);
-}
-
-
-/*-*************************************
- *  Hashes
- ***************************************/
-static const U32 prime3bytes = 506832829U;
-static U32    ZSTD_hash3(U32 u, U32 h, U32 s) { assert(h <= 32); return (((u << (32-24)) * prime3bytes) ^ s)  >> (32-h) ; }
-MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h, 0); } /* only in zstd_opt.h */
-MEM_STATIC size_t ZSTD_hash3PtrS(const void* ptr, U32 h, U32 s) { return ZSTD_hash3(MEM_readLE32(ptr), h, s); }
-
-static const U32 prime4bytes = 2654435761U;
-static U32    ZSTD_hash4(U32 u, U32 h, U32 s) { assert(h <= 32); return ((u * prime4bytes) ^ s) >> (32-h) ; }
-static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_readLE32(ptr), h, 0); }
-static size_t ZSTD_hash4PtrS(const void* ptr, U32 h, U32 s) { return ZSTD_hash4(MEM_readLE32(ptr), h, s); }
-
-static const U64 prime5bytes = 889523592379ULL;
-static size_t ZSTD_hash5(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-40)) * prime5bytes) ^ s) >> (64-h)) ; }
-static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h, 0); }
-static size_t ZSTD_hash5PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash5(MEM_readLE64(p), h, s); }
-
-static const U64 prime6bytes = 227718039650203ULL;
-static size_t ZSTD_hash6(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-48)) * prime6bytes) ^ s) >> (64-h)) ; }
-static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h, 0); }
-static size_t ZSTD_hash6PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash6(MEM_readLE64(p), h, s); }
-
-static const U64 prime7bytes = 58295818150454627ULL;
-static size_t ZSTD_hash7(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-56)) * prime7bytes) ^ s) >> (64-h)) ; }
-static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h, 0); }
-static size_t ZSTD_hash7PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash7(MEM_readLE64(p), h, s); }
-
-static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
-static size_t ZSTD_hash8(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u) * prime8bytes)  ^ s) >> (64-h)) ; }
-static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h, 0); }
-static size_t ZSTD_hash8PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash8(MEM_readLE64(p), h, s); }
-
-
-MEM_STATIC FORCE_INLINE_ATTR
-size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
-{
-    /* Although some of these hashes do support hBits up to 64, some do not.
-     * To be on the safe side, always avoid hBits > 32. */
-    assert(hBits <= 32);
-
-    switch(mls)
-    {
-    default:
-    case 4: return ZSTD_hash4Ptr(p, hBits);
-    case 5: return ZSTD_hash5Ptr(p, hBits);
-    case 6: return ZSTD_hash6Ptr(p, hBits);
-    case 7: return ZSTD_hash7Ptr(p, hBits);
-    case 8: return ZSTD_hash8Ptr(p, hBits);
-    }
-}
-
-MEM_STATIC FORCE_INLINE_ATTR
-size_t ZSTD_hashPtrSalted(const void* p, U32 hBits, U32 mls, const U64 hashSalt) {
-    /* Although some of these hashes do support hBits up to 64, some do not.
-     * To be on the safe side, always avoid hBits > 32. */
-    assert(hBits <= 32);
-
-    switch(mls)
-    {
-        default:
-        case 4: return ZSTD_hash4PtrS(p, hBits, (U32)hashSalt);
-        case 5: return ZSTD_hash5PtrS(p, hBits, hashSalt);
-        case 6: return ZSTD_hash6PtrS(p, hBits, hashSalt);
-        case 7: return ZSTD_hash7PtrS(p, hBits, hashSalt);
-        case 8: return ZSTD_hash8PtrS(p, hBits, hashSalt);
-    }
-}
-
-
-/** ZSTD_ipow() :
- * Return base^exponent.
- */
-static U64 ZSTD_ipow(U64 base, U64 exponent)
-{
-    U64 power = 1;
-    while (exponent) {
-      if (exponent & 1) power *= base;
-      exponent >>= 1;
-      base *= base;
-    }
-    return power;
-}
-
-#define ZSTD_ROLL_HASH_CHAR_OFFSET 10
-
-/** ZSTD_rollingHash_append() :
- * Add the buffer to the hash value.
- */
-static U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size)
-{
-    BYTE const* istart = (BYTE const*)buf;
-    size_t pos;
-    for (pos = 0; pos < size; ++pos) {
-        hash *= prime8bytes;
-        hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET;
-    }
-    return hash;
-}
-
-/** ZSTD_rollingHash_compute() :
- * Compute the rolling hash value of the buffer.
- */
-MEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size)
-{
-    return ZSTD_rollingHash_append(0, buf, size);
-}
-
-/** ZSTD_rollingHash_primePower() :
- * Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash
- * over a window of length bytes.
- */
-MEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length)
-{
-    return ZSTD_ipow(prime8bytes, length - 1);
-}
-
-/** ZSTD_rollingHash_rotate() :
- * Rotate the rolling hash by one byte.
- */
-MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower)
-{
-    hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower;
-    hash *= prime8bytes;
-    hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET;
-    return hash;
-}
-
-/*-*************************************
-*  Round buffer management
-***************************************/
-#if (ZSTD_WINDOWLOG_MAX_64 > 31)
-# error "ZSTD_WINDOWLOG_MAX is too large : would overflow ZSTD_CURRENT_MAX"
-#endif
-/* Max current allowed */
-#define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))
-/* Maximum chunk size before overflow correction needs to be called again */
-#define ZSTD_CHUNKSIZE_MAX                                                     \
-    ( ((U32)-1)                  /* Maximum ending current index */            \
-    - ZSTD_CURRENT_MAX)          /* Maximum beginning lowLimit */
-
-/**
- * ZSTD_window_clear():
- * Clears the window containing the history by simply setting it to empty.
- */
-MEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window)
-{
-    size_t const endT = (size_t)(window->nextSrc - window->base);
-    U32 const end = (U32)endT;
-
-    window->lowLimit = end;
-    window->dictLimit = end;
-}
-
-MEM_STATIC U32 ZSTD_window_isEmpty(ZSTD_window_t const window)
-{
-    return window.dictLimit == ZSTD_WINDOW_START_INDEX &&
-           window.lowLimit == ZSTD_WINDOW_START_INDEX &&
-           (window.nextSrc - window.base) == ZSTD_WINDOW_START_INDEX;
-}
-
-/**
- * ZSTD_window_hasExtDict():
- * Returns non-zero if the window has a non-empty extDict.
- */
-MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window)
-{
-    return window.lowLimit < window.dictLimit;
-}
-
-/**
- * ZSTD_matchState_dictMode():
- * Inspects the provided matchState and figures out what dictMode should be
- * passed to the compressor.
- */
-MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms)
-{
-    return ZSTD_window_hasExtDict(ms->window) ?
-        ZSTD_extDict :
-        ms->dictMatchState != NULL ?
-            (ms->dictMatchState->dedicatedDictSearch ? ZSTD_dedicatedDictSearch : ZSTD_dictMatchState) :
-            ZSTD_noDict;
-}
-
-/* Defining this macro to non-zero tells zstd to run the overflow correction
- * code much more frequently. This is very inefficient, and should only be
- * used for tests and fuzzers.
- */
-#ifndef ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY
-#  ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-#    define ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY 1
-#  else
-#    define ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY 0
-#  endif
-#endif
-
-/**
- * ZSTD_window_canOverflowCorrect():
- * Returns non-zero if the indices are large enough for overflow correction
- * to work correctly without impacting compression ratio.
- */
-MEM_STATIC U32 ZSTD_window_canOverflowCorrect(ZSTD_window_t const window,
-                                              U32 cycleLog,
-                                              U32 maxDist,
-                                              U32 loadedDictEnd,
-                                              void const* src)
-{
-    U32 const cycleSize = 1u << cycleLog;
-    U32 const curr = (U32)((BYTE const*)src - window.base);
-    U32 const minIndexToOverflowCorrect = cycleSize
-                                        + MAX(maxDist, cycleSize)
-                                        + ZSTD_WINDOW_START_INDEX;
-
-    /* Adjust the min index to backoff the overflow correction frequency,
-     * so we don't waste too much CPU in overflow correction. If this
-     * computation overflows we don't really care, we just need to make
-     * sure it is at least minIndexToOverflowCorrect.
-     */
-    U32 const adjustment = window.nbOverflowCorrections + 1;
-    U32 const adjustedIndex = MAX(minIndexToOverflowCorrect * adjustment,
-                                  minIndexToOverflowCorrect);
-    U32 const indexLargeEnough = curr > adjustedIndex;
-
-    /* Only overflow correct early if the dictionary is invalidated already,
-     * so we don't hurt compression ratio.
-     */
-    U32 const dictionaryInvalidated = curr > maxDist + loadedDictEnd;
-
-    return indexLargeEnough && dictionaryInvalidated;
-}
-
-/**
- * ZSTD_window_needOverflowCorrection():
- * Returns non-zero if the indices are getting too large and need overflow
- * protection.
- */
-MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window,
-                                                  U32 cycleLog,
-                                                  U32 maxDist,
-                                                  U32 loadedDictEnd,
-                                                  void const* src,
-                                                  void const* srcEnd)
-{
-    U32 const curr = (U32)((BYTE const*)srcEnd - window.base);
-    if (ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY) {
-        if (ZSTD_window_canOverflowCorrect(window, cycleLog, maxDist, loadedDictEnd, src)) {
-            return 1;
-        }
-    }
-    return curr > ZSTD_CURRENT_MAX;
-}
-
-/**
- * ZSTD_window_correctOverflow():
- * Reduces the indices to protect from index overflow.
- * Returns the correction made to the indices, which must be applied to every
- * stored index.
- *
- * The least significant cycleLog bits of the indices must remain the same,
- * which may be 0. Every index up to maxDist in the past must be valid.
- */
-MEM_STATIC
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
-                                           U32 maxDist, void const* src)
-{
-    /* preemptive overflow correction:
-     * 1. correction is large enough:
-     *    lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog
-     *    1<<windowLog <= newCurrent < 1<<chainLog + 1<<windowLog
-     *
-     *    current - newCurrent
-     *    > (3<<29 + 1<<windowLog) - (1<<windowLog + 1<<chainLog)
-     *    > (3<<29) - (1<<chainLog)
-     *    > (3<<29) - (1<<30)             (NOTE: chainLog <= 30)
-     *    > 1<<29
-     *
-     * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow:
-     *    After correction, current is less than (1<<chainLog + 1<<windowLog).
-     *    In 64-bit mode we are safe, because we have 64-bit ptrdiff_t.
-     *    In 32-bit mode we are safe, because (chainLog <= 29), so
-     *    ip+ZSTD_CHUNKSIZE_MAX - cctx->base < 1<<32.
-     * 3. (cctx->lowLimit + 1<<windowLog) < 1<<32:
-     *    windowLog <= 31 ==> 3<<29 + 1<<windowLog < 7<<29 < 1<<32.
-     */
-    U32 const cycleSize = 1u << cycleLog;
-    U32 const cycleMask = cycleSize - 1;
-    U32 const curr = (U32)((BYTE const*)src - window->base);
-    U32 const currentCycle = curr & cycleMask;
-    /* Ensure newCurrent - maxDist >= ZSTD_WINDOW_START_INDEX. */
-    U32 const currentCycleCorrection = currentCycle < ZSTD_WINDOW_START_INDEX
-                                     ? MAX(cycleSize, ZSTD_WINDOW_START_INDEX)
-                                     : 0;
-    U32 const newCurrent = currentCycle
-                         + currentCycleCorrection
-                         + MAX(maxDist, cycleSize);
-    U32 const correction = curr - newCurrent;
-    /* maxDist must be a power of two so that:
-     *   (newCurrent & cycleMask) == (curr & cycleMask)
-     * This is required to not corrupt the chains / binary tree.
-     */
-    assert((maxDist & (maxDist - 1)) == 0);
-    assert((curr & cycleMask) == (newCurrent & cycleMask));
-    assert(curr > newCurrent);
-    if (!ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY) {
-        /* Loose bound, should be around 1<<29 (see above) */
-        assert(correction > 1<<28);
-    }
-
-    window->base += correction;
-    window->dictBase += correction;
-    if (window->lowLimit < correction + ZSTD_WINDOW_START_INDEX) {
-        window->lowLimit = ZSTD_WINDOW_START_INDEX;
-    } else {
-        window->lowLimit -= correction;
-    }
-    if (window->dictLimit < correction + ZSTD_WINDOW_START_INDEX) {
-        window->dictLimit = ZSTD_WINDOW_START_INDEX;
-    } else {
-        window->dictLimit -= correction;
-    }
-
-    /* Ensure we can still reference the full window. */
-    assert(newCurrent >= maxDist);
-    assert(newCurrent - maxDist >= ZSTD_WINDOW_START_INDEX);
-    /* Ensure that lowLimit and dictLimit didn't underflow. */
-    assert(window->lowLimit <= newCurrent);
-    assert(window->dictLimit <= newCurrent);
-
-    ++window->nbOverflowCorrections;
-
-    DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction,
-             window->lowLimit);
-    return correction;
-}
-
-/**
- * ZSTD_window_enforceMaxDist():
- * Updates lowLimit so that:
- *    (srcEnd - base) - lowLimit == maxDist + loadedDictEnd
- *
- * It ensures index is valid as long as index >= lowLimit.
- * This must be called before a block compression call.
- *
- * loadedDictEnd is only defined if a dictionary is in use for current compression.
- * As the name implies, loadedDictEnd represents the index at end of dictionary.
- * The value lies within context's referential, it can be directly compared to blockEndIdx.
- *
- * If loadedDictEndPtr is NULL, no dictionary is in use, and we use loadedDictEnd == 0.
- * If loadedDictEndPtr is not NULL, we set it to zero after updating lowLimit.
- * This is because dictionaries are allowed to be referenced fully
- * as long as the last byte of the dictionary is in the window.
- * Once input has progressed beyond window size, dictionary cannot be referenced anymore.
- *
- * In normal dict mode, the dictionary lies between lowLimit and dictLimit.
- * In dictMatchState mode, lowLimit and dictLimit are the same,
- * and the dictionary is below them.
- * forceWindow and dictMatchState are therefore incompatible.
- */
-MEM_STATIC void
-ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
-                     const void* blockEnd,
-                           U32   maxDist,
-                           U32*  loadedDictEndPtr,
-                     const ZSTD_matchState_t** dictMatchStatePtr)
-{
-    U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
-    U32 const loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;
-    DEBUGLOG(5, "ZSTD_window_enforceMaxDist: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
-                (unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);
-
-    /* - When there is no dictionary : loadedDictEnd == 0.
-         In which case, the test (blockEndIdx > maxDist) is merely to avoid
-         overflowing next operation `newLowLimit = blockEndIdx - maxDist`.
-       - When there is a standard dictionary :
-         Index referential is copied from the dictionary,
-         which means it starts from 0.
-         In which case, loadedDictEnd == dictSize,
-         and it makes sense to compare `blockEndIdx > maxDist + dictSize`
-         since `blockEndIdx` also starts from zero.
-       - When there is an attached dictionary :
-         loadedDictEnd is expressed within the referential of the context,
-         so it can be directly compared against blockEndIdx.
-    */
-    if (blockEndIdx > maxDist + loadedDictEnd) {
-        U32 const newLowLimit = blockEndIdx - maxDist;
-        if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
-        if (window->dictLimit < window->lowLimit) {
-            DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
-                        (unsigned)window->dictLimit, (unsigned)window->lowLimit);
-            window->dictLimit = window->lowLimit;
-        }
-        /* On reaching window size, dictionaries are invalidated */
-        if (loadedDictEndPtr) *loadedDictEndPtr = 0;
-        if (dictMatchStatePtr) *dictMatchStatePtr = NULL;
-    }
-}
-
-/* Similar to ZSTD_window_enforceMaxDist(),
- * but only invalidates dictionary
- * when input progresses beyond window size.
- * assumption : loadedDictEndPtr and dictMatchStatePtr are valid (non NULL)
- *              loadedDictEnd uses same referential as window->base
- *              maxDist is the window size */
-MEM_STATIC void
-ZSTD_checkDictValidity(const ZSTD_window_t* window,
-                       const void* blockEnd,
-                             U32   maxDist,
-                             U32*  loadedDictEndPtr,
-                       const ZSTD_matchState_t** dictMatchStatePtr)
-{
-    assert(loadedDictEndPtr != NULL);
-    assert(dictMatchStatePtr != NULL);
-    {   U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
-        U32 const loadedDictEnd = *loadedDictEndPtr;
-        DEBUGLOG(5, "ZSTD_checkDictValidity: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
-                    (unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);
-        assert(blockEndIdx >= loadedDictEnd);
-
-        if (blockEndIdx > loadedDictEnd + maxDist || loadedDictEnd != window->dictLimit) {
-            /* On reaching window size, dictionaries are invalidated.
-             * For simplification, if window size is reached anywhere within next block,
-             * the dictionary is invalidated for the full block.
-             *
-             * We also have to invalidate the dictionary if ZSTD_window_update() has detected
-             * non-contiguous segments, which means that loadedDictEnd != window->dictLimit.
-             * loadedDictEnd may be 0, if forceWindow is true, but in that case we never use
-             * dictMatchState, so setting it to NULL is not a problem.
-             */
-            DEBUGLOG(6, "invalidating dictionary for current block (distance > windowSize)");
-            *loadedDictEndPtr = 0;
-            *dictMatchStatePtr = NULL;
-        } else {
-            if (*loadedDictEndPtr != 0) {
-                DEBUGLOG(6, "dictionary considered valid for current block");
-    }   }   }
-}
-
-MEM_STATIC void ZSTD_window_init(ZSTD_window_t* window) {
-    ZSTD_memset(window, 0, sizeof(*window));
-    window->base = (BYTE const*)" ";
-    window->dictBase = (BYTE const*)" ";
-    ZSTD_STATIC_ASSERT(ZSTD_DUBT_UNSORTED_MARK < ZSTD_WINDOW_START_INDEX); /* Start above ZSTD_DUBT_UNSORTED_MARK */
-    window->dictLimit = ZSTD_WINDOW_START_INDEX;    /* start from >0, so that 1st position is valid */
-    window->lowLimit = ZSTD_WINDOW_START_INDEX;     /* it ensures first and later CCtx usages compress the same */
-    window->nextSrc = window->base + ZSTD_WINDOW_START_INDEX;   /* see issue #1241 */
-    window->nbOverflowCorrections = 0;
-}
-
-/**
- * ZSTD_window_update():
- * Updates the window by appending [src, src + srcSize) to the window.
- * If it is not contiguous, the current prefix becomes the extDict, and we
- * forget about the extDict. Handles overlap of the prefix and extDict.
- * Returns non-zero if the segment is contiguous.
- */
-MEM_STATIC
-ZSTD_ALLOW_POINTER_OVERFLOW_ATTR
-U32 ZSTD_window_update(ZSTD_window_t* window,
-                                  void const* src, size_t srcSize,
-                                  int forceNonContiguous)
-{
-    BYTE const* const ip = (BYTE const*)src;
-    U32 contiguous = 1;
-    DEBUGLOG(5, "ZSTD_window_update");
-    if (srcSize == 0)
-        return contiguous;
-    assert(window->base != NULL);
-    assert(window->dictBase != NULL);
-    /* Check if blocks follow each other */
-    if (src != window->nextSrc || forceNonContiguous) {
-        /* not contiguous */
-        size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);
-        DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit);
-        window->lowLimit = window->dictLimit;
-        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */
-        window->dictLimit = (U32)distanceFromBase;
-        window->dictBase = window->base;
-        window->base = ip - distanceFromBase;
-        /* ms->nextToUpdate = window->dictLimit; */
-        if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit;   /* too small extDict */
-        contiguous = 0;
-    }
-    window->nextSrc = ip + srcSize;
-    /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
-    if ( (ip+srcSize > window->dictBase + window->lowLimit)
-       & (ip < window->dictBase + window->dictLimit)) {
-        ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase;
-        U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;
-        window->lowLimit = lowLimitMax;
-        DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
-    }
-    return contiguous;
-}
-
-/**
- * Returns the lowest allowed match index. It may either be in the ext-dict or the prefix.
- */
-MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
-{
-    U32 const maxDistance = 1U << windowLog;
-    U32 const lowestValid = ms->window.lowLimit;
-    U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
-    U32 const isDictionary = (ms->loadedDictEnd != 0);
-    /* When using a dictionary the entire dictionary is valid if a single byte of the dictionary
-     * is within the window. We invalidate the dictionary (and set loadedDictEnd to 0) when it isn't
-     * valid for the entire block. So this check is sufficient to find the lowest valid match index.
-     */
-    U32 const matchLowest = isDictionary ? lowestValid : withinWindow;
-    return matchLowest;
-}
-
-/**
- * Returns the lowest allowed match index in the prefix.
- */
-MEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
-{
-    U32    const maxDistance = 1U << windowLog;
-    U32    const lowestValid = ms->window.dictLimit;
-    U32    const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
-    U32    const isDictionary = (ms->loadedDictEnd != 0);
-    /* When computing the lowest prefix index we need to take the dictionary into account to handle
-     * the edge case where the dictionary and the source are contiguous in memory.
-     */
-    U32    const matchLowest = isDictionary ? lowestValid : withinWindow;
-    return matchLowest;
-}
-
-
-
-/* debug functions */
-#if (DEBUGLEVEL>=2)
-
-MEM_STATIC double ZSTD_fWeight(U32 rawStat)
-{
-    U32 const fp_accuracy = 8;
-    U32 const fp_multiplier = (1 << fp_accuracy);
-    U32 const newStat = rawStat + 1;
-    U32 const hb = ZSTD_highbit32(newStat);
-    U32 const BWeight = hb * fp_multiplier;
-    U32 const FWeight = (newStat << fp_accuracy) >> hb;
-    U32 const weight = BWeight + FWeight;
-    assert(hb + fp_accuracy < 31);
-    return (double)weight / fp_multiplier;
-}
-
-/* display a table content,
- * listing each element, its frequency, and its predicted bit cost */
-MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)
-{
-    unsigned u, sum;
-    for (u=0, sum=0; u<=max; u++) sum += table[u];
-    DEBUGLOG(2, "total nb elts: %u", sum);
-    for (u=0; u<=max; u++) {
-        DEBUGLOG(2, "%2u: %5u  (%.2f)",
-                u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );
-    }
-}
-
-#endif
-
-/* Short Cache */
-
-/* Normally, zstd matchfinders follow this flow:
- *     1. Compute hash at ip
- *     2. Load index from hashTable[hash]
- *     3. Check if *ip == *(base + index)
- * In dictionary compression, loading *(base + index) is often an L2 or even L3 miss.
- *
- * Short cache is an optimization which allows us to avoid step 3 most of the time
- * when the data doesn't actually match. With short cache, the flow becomes:
- *     1. Compute (hash, currentTag) at ip. currentTag is an 8-bit independent hash at ip.
- *     2. Load (index, matchTag) from hashTable[hash]. See ZSTD_writeTaggedIndex to understand how this works.
- *     3. Only if currentTag == matchTag, check *ip == *(base + index). Otherwise, continue.
- *
- * Currently, short cache is only implemented in CDict hashtables. Thus, its use is limited to
- * dictMatchState matchfinders.
- */
-#define ZSTD_SHORT_CACHE_TAG_BITS 8
-#define ZSTD_SHORT_CACHE_TAG_MASK ((1u << ZSTD_SHORT_CACHE_TAG_BITS) - 1)
-
-/* Helper function for ZSTD_fillHashTable and ZSTD_fillDoubleHashTable.
- * Unpacks hashAndTag into (hash, tag), then packs (index, tag) into hashTable[hash]. */
-MEM_STATIC void ZSTD_writeTaggedIndex(U32* const hashTable, size_t hashAndTag, U32 index) {
-    size_t const hash = hashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS;
-    U32 const tag = (U32)(hashAndTag & ZSTD_SHORT_CACHE_TAG_MASK);
-    assert(index >> (32 - ZSTD_SHORT_CACHE_TAG_BITS) == 0);
-    hashTable[hash] = (index << ZSTD_SHORT_CACHE_TAG_BITS) | tag;
-}
-
-/* Helper function for short cache matchfinders.
- * Unpacks tag1 and tag2 from lower bits of packedTag1 and packedTag2, then checks if the tags match. */
-MEM_STATIC int ZSTD_comparePackedTags(size_t packedTag1, size_t packedTag2) {
-    U32 const tag1 = packedTag1 & ZSTD_SHORT_CACHE_TAG_MASK;
-    U32 const tag2 = packedTag2 & ZSTD_SHORT_CACHE_TAG_MASK;
-    return tag1 == tag2;
-}
-
-/* ===============================================================
- * Shared internal declarations
- * These prototypes may be called from sources not in lib/compress
- * =============================================================== */
-
-/* ZSTD_loadCEntropy() :
- * dict : must point at beginning of a valid zstd dictionary.
- * return : size of dictionary header (size of magic number + dict ID + entropy tables)
- * assumptions : magic number supposed already checked
- *               and dictSize >= 8 */
-size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
-                         const void* const dict, size_t dictSize);
-
-void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs);
-
-/* ==============================================================
- * Private declarations
- * These prototypes shall only be called from within lib/compress
- * ============================================================== */
-
-/* ZSTD_getCParamsFromCCtxParams() :
- * cParams are built depending on compressionLevel, src size hints,
- * LDM and manually set compression parameters.
- * Note: srcSizeHint == 0 means 0!
- */
-ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
-        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode);
-
-/*! ZSTD_initCStream_internal() :
- *  Private use only. Init streaming operation.
- *  expects params to be valid.
- *  must receive dict, or cdict, or none, but not both.
- *  @return : 0, or an error code */
-size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
-                     const void* dict, size_t dictSize,
-                     const ZSTD_CDict* cdict,
-                     const ZSTD_CCtx_params* params, unsigned long long pledgedSrcSize);
-
-void ZSTD_resetSeqStore(seqStore_t* ssPtr);
-
-/*! ZSTD_getCParamsFromCDict() :
- *  as the name implies */
-ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
-
-/* ZSTD_compressBegin_advanced_internal() :
- * Private use only. To be called from zstdmt_compress.c. */
-size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
-                                    const void* dict, size_t dictSize,
-                                    ZSTD_dictContentType_e dictContentType,
-                                    ZSTD_dictTableLoadMethod_e dtlm,
-                                    const ZSTD_CDict* cdict,
-                                    const ZSTD_CCtx_params* params,
-                                    unsigned long long pledgedSrcSize);
-
-/* ZSTD_compress_advanced_internal() :
- * Private use only. To be called from zstdmt_compress.c. */
-size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
-                                       void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize,
-                                 const void* dict,size_t dictSize,
-                                 const ZSTD_CCtx_params* params);
-
-
-/* ZSTD_writeLastEmptyBlock() :
- * output an empty Block with end-of-frame mark to complete a frame
- * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
- *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
- */
-size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity);
-
-
-/* ZSTD_referenceExternalSequences() :
- * Must be called before starting a compression operation.
- * seqs must parse a prefix of the source.
- * This cannot be used when long range matching is enabled.
- * Zstd will use these sequences, and pass the literals to a secondary block
- * compressor.
- * NOTE: seqs are not verified! Invalid sequences can cause out-of-bounds memory
- * access and data corruption.
- */
-void ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq);
-
-/** ZSTD_cycleLog() :
- *  condition for correct operation : hashLog > 1 */
-U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat);
-
-/** ZSTD_CCtx_trace() :
- *  Trace the end of a compression call.
- */
-void ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize);
-
-/* Returns 0 on success, and a ZSTD_error otherwise. This function scans through an array of
- * ZSTD_Sequence, storing the sequences it finds, until it reaches a block delimiter.
- * Note that the block delimiter must include the last literals of the block.
- */
-size_t
-ZSTD_copySequencesToSeqStoreExplicitBlockDelim(ZSTD_CCtx* cctx,
-                                              ZSTD_sequencePosition* seqPos,
-                                        const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
-                                        const void* src, size_t blockSize, ZSTD_paramSwitch_e externalRepSearch);
-
-/* Returns the number of bytes to move the current read position back by.
- * Only non-zero if we ended up splitting a sequence.
- * Otherwise, it may return a ZSTD error if something went wrong.
- *
- * This function will attempt to scan through blockSize bytes
- * represented by the sequences in @inSeqs,
- * storing any (partial) sequences.
- *
- * Occasionally, we may want to change the actual number of bytes we consumed from inSeqs to
- * avoid splitting a match, or to avoid splitting a match such that it would produce a match
- * smaller than MINMATCH. In this case, we return the number of bytes that we didn't read from this block.
- */
-size_t
-ZSTD_copySequencesToSeqStoreNoBlockDelim(ZSTD_CCtx* cctx, ZSTD_sequencePosition* seqPos,
-                                   const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
-                                   const void* src, size_t blockSize, ZSTD_paramSwitch_e externalRepSearch);
-
-/* Returns 1 if an external sequence producer is registered, otherwise returns 0. */
-MEM_STATIC int ZSTD_hasExtSeqProd(const ZSTD_CCtx_params* params) {
-    return params->extSeqProdFunc != NULL;
-}
-
-/* ===============================================================
- * Deprecated definitions that are still used internally to avoid
- * deprecation warnings. These functions are exactly equivalent to
- * their public variants, but avoid the deprecation warnings.
- * =============================================================== */
-
-size_t ZSTD_compressBegin_usingCDict_deprecated(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
-
-size_t ZSTD_compressContinue_public(ZSTD_CCtx* cctx,
-                                    void* dst, size_t dstCapacity,
-                              const void* src, size_t srcSize);
-
-size_t ZSTD_compressEnd_public(ZSTD_CCtx* cctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize);
-
-size_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_COMPRESS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_literals.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_literals.h
deleted file mode 100644
index a8fc05ba7..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_literals.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_COMPRESS_LITERALS_H
-#define ZSTD_COMPRESS_LITERALS_H
-
-#include "zstd/compress/zstd_compress_internal.h" /* ZSTD_hufCTables_t, ZSTD_minGain() */
-
-namespace duckdb_zstd {
-
-size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/* ZSTD_compressRleLiteralsBlock() :
- * Conditions :
- * - All bytes in @src are identical
- * - dstCapacity >= 4 */
-size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/* ZSTD_compressLiterals():
- * @entropyWorkspace: must be aligned on 4-bytes boundaries
- * @entropyWorkspaceSize : must be >= HUF_WORKSPACE_SIZE
- * @suspectUncompressible: sampling checks, to potentially skip huffman coding
- */
-size_t ZSTD_compressLiterals (void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize,
-                              void* entropyWorkspace, size_t entropyWorkspaceSize,
-                        const ZSTD_hufCTables_t* prevHuf,
-                              ZSTD_hufCTables_t* nextHuf,
-                              ZSTD_strategy strategy, int disableLiteralCompression,
-                              int suspectUncompressible,
-                              int bmi2);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_COMPRESS_LITERALS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_sequences.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_sequences.h
deleted file mode 100644
index 885663f2e..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_sequences.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_COMPRESS_SEQUENCES_H
-#define ZSTD_COMPRESS_SEQUENCES_H
-
-#include "zstd/common/fse.h" /* FSE_repeat, FSE_CTable */
-#include "zstd/common/zstd_internal.h" /* symbolEncodingType_e, ZSTD_strategy */
-
-namespace duckdb_zstd {
-
-typedef enum {
-    ZSTD_defaultDisallowed = 0,
-    ZSTD_defaultAllowed = 1
-} ZSTD_defaultPolicy_e;
-
-symbolEncodingType_e
-ZSTD_selectEncodingType(
-        FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
-        size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
-        FSE_CTable const* prevCTable,
-        short const* defaultNorm, U32 defaultNormLog,
-        ZSTD_defaultPolicy_e const isDefaultAllowed,
-        ZSTD_strategy const strategy);
-
-size_t
-ZSTD_buildCTable(void* dst, size_t dstCapacity,
-                FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
-                unsigned* count, U32 max,
-                const BYTE* codeTable, size_t nbSeq,
-                const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
-                const FSE_CTable* prevCTable, size_t prevCTableSize,
-                void* entropyWorkspace, size_t entropyWorkspaceSize);
-
-size_t ZSTD_encodeSequences(
-            void* dst, size_t dstCapacity,
-            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
-            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
-            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
-            seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2);
-
-size_t ZSTD_fseBitCost(
-    FSE_CTable const* ctable,
-    unsigned const* count,
-    unsigned const max);
-
-size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
-                             unsigned const* count, unsigned const max);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_COMPRESS_SEQUENCES_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_superblock.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_superblock.h
deleted file mode 100644
index 34b7a3bf2..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_compress_superblock.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_COMPRESS_ADVANCED_H
-#define ZSTD_COMPRESS_ADVANCED_H
-
-/*-*************************************
-*  Dependencies
-***************************************/
-
-#include "zstd.h" /* ZSTD_CCtx */
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Target Compressed Block Size
-***************************************/
-
-/* ZSTD_compressSuperBlock() :
- * Used to compress a super block when targetCBlockSize is being used.
- * The given block will be compressed into multiple sub blocks that are around targetCBlockSize. */
-size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
-                               void* dst, size_t dstCapacity,
-                               void const* src, size_t srcSize,
-                               unsigned lastBlock);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_COMPRESS_ADVANCED_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_cwksp.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_cwksp.h
deleted file mode 100644
index bb1c62cee..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_cwksp.h
+++ /dev/null
@@ -1,628 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_CWKSP_H
-#define ZSTD_CWKSP_H
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zstd/common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customFree */
-#include "zstd/common/zstd_internal.h"
-#include "zstd/common/portability_macros.h"
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Constants
-***************************************/
-
-/* Since the workspace is effectively its own little malloc implementation /
- * arena, when we run under ASAN, we should similarly insert redzones between
- * each internal element of the workspace, so ASAN will catch overruns that
- * reach outside an object but that stay inside the workspace.
- *
- * This defines the size of that redzone.
- */
-#ifndef ZSTD_CWKSP_ASAN_REDZONE_SIZE
-#define ZSTD_CWKSP_ASAN_REDZONE_SIZE 128
-#endif
-
-
-/* Set our tables and aligneds to align by 64 bytes */
-#define ZSTD_CWKSP_ALIGNMENT_BYTES 64
-
-/*-*************************************
-*  Structures
-***************************************/
-typedef enum {
-    ZSTD_cwksp_alloc_objects,
-    ZSTD_cwksp_alloc_aligned_init_once,
-    ZSTD_cwksp_alloc_aligned,
-    ZSTD_cwksp_alloc_buffers
-} ZSTD_cwksp_alloc_phase_e;
-
-/**
- * Used to describe whether the workspace is statically allocated (and will not
- * necessarily ever be freed), or if it's dynamically allocated and we can
- * expect a well-formed caller to free this.
- */
-typedef enum {
-    ZSTD_cwksp_dynamic_alloc,
-    ZSTD_cwksp_static_alloc
-} ZSTD_cwksp_static_alloc_e;
-
-/**
- * Zstd fits all its internal datastructures into a single continuous buffer,
- * so that it only needs to perform a single OS allocation (or so that a buffer
- * can be provided to it and it can perform no allocations at all). This buffer
- * is called the workspace.
- *
- * Several optimizations complicate that process of allocating memory ranges
- * from this workspace for each internal datastructure:
- *
- * - These different internal datastructures have different setup requirements:
- *
- *   - The static objects need to be cleared once and can then be trivially
- *     reused for each compression.
- *
- *   - Various buffers don't need to be initialized at all--they are always
- *     written into before they're read.
- *
- *   - The matchstate tables have a unique requirement that they don't need
- *     their memory to be totally cleared, but they do need the memory to have
- *     some bound, i.e., a guarantee that all values in the memory they've been
- *     allocated is less than some maximum value (which is the starting value
- *     for the indices that they will then use for compression). When this
- *     guarantee is provided to them, they can use the memory without any setup
- *     work. When it can't, they have to clear the area.
- *
- * - These buffers also have different alignment requirements.
- *
- * - We would like to reuse the objects in the workspace for multiple
- *   compressions without having to perform any expensive reallocation or
- *   reinitialization work.
- *
- * - We would like to be able to efficiently reuse the workspace across
- *   multiple compressions **even when the compression parameters change** and
- *   we need to resize some of the objects (where possible).
- *
- * To attempt to manage this buffer, given these constraints, the ZSTD_cwksp
- * abstraction was created. It works as follows:
- *
- * Workspace Layout:
- *
- * [                        ... workspace ...                           ]
- * [objects][tables ->] free space [<- buffers][<- aligned][<- init once]
- *
- * The various objects that live in the workspace are divided into the
- * following categories, and are allocated separately:
- *
- * - Static objects: this is optionally the enclosing ZSTD_CCtx or ZSTD_CDict,
- *   so that literally everything fits in a single buffer. Note: if present,
- *   this must be the first object in the workspace, since ZSTD_customFree{CCtx,
- *   CDict}() rely on a pointer comparison to see whether one or two frees are
- *   required.
- *
- * - Fixed size objects: these are fixed-size, fixed-count objects that are
- *   nonetheless "dynamically" allocated in the workspace so that we can
- *   control how they're initialized separately from the broader ZSTD_CCtx.
- *   Examples:
- *   - Entropy Workspace
- *   - 2 x ZSTD_compressedBlockState_t
- *   - CDict dictionary contents
- *
- * - Tables: these are any of several different datastructures (hash tables,
- *   chain tables, binary trees) that all respect a common format: they are
- *   uint32_t arrays, all of whose values are between 0 and (nextSrc - base).
- *   Their sizes depend on the cparams. These tables are 64-byte aligned.
- *
- * - Init once: these buffers require to be initialized at least once before
- *   use. They should be used when we want to skip memory initialization
- *   while not triggering memory checkers (like Valgrind) when reading from
- *   from this memory without writing to it first.
- *   These buffers should be used carefully as they might contain data
- *   from previous compressions.
- *   Buffers are aligned to 64 bytes.
- *
- * - Aligned: these buffers don't require any initialization before they're
- *   used. The user of the buffer should make sure they write into a buffer
- *   location before reading from it.
- *   Buffers are aligned to 64 bytes.
- *
- * - Buffers: these buffers are used for various purposes that don't require
- *   any alignment or initialization before they're used. This means they can
- *   be moved around at no cost for a new compression.
- *
- * Allocating Memory:
- *
- * The various types of objects must be allocated in order, so they can be
- * correctly packed into the workspace buffer. That order is:
- *
- * 1. Objects
- * 2. Init once / Tables
- * 3. Aligned / Tables
- * 4. Buffers / Tables
- *
- * Attempts to reserve objects of different types out of order will fail.
- */
-typedef struct {
-    void* workspace;
-    void* workspaceEnd;
-
-    void* objectEnd;
-    void* tableEnd;
-    void* tableValidEnd;
-    void* allocStart;
-    void* initOnceStart;
-
-    BYTE allocFailed;
-    int workspaceOversizedDuration;
-    ZSTD_cwksp_alloc_phase_e phase;
-    ZSTD_cwksp_static_alloc_e isStatic;
-} ZSTD_cwksp;
-
-/*-*************************************
-*  Functions
-***************************************/
-
-MEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws);
-MEM_STATIC void*  ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws);
-
-MEM_STATIC void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) {
-    (void)ws;
-    assert(ws->workspace <= ws->objectEnd);
-    assert(ws->objectEnd <= ws->tableEnd);
-    assert(ws->objectEnd <= ws->tableValidEnd);
-    assert(ws->tableEnd <= ws->allocStart);
-    assert(ws->tableValidEnd <= ws->allocStart);
-    assert(ws->allocStart <= ws->workspaceEnd);
-    assert(ws->initOnceStart <= ZSTD_cwksp_initialAllocStart(ws));
-    assert(ws->workspace <= ws->initOnceStart);
-}
-
-/**
- * Align must be a power of 2.
- */
-MEM_STATIC size_t ZSTD_cwksp_align(size_t size, size_t const align) {
-    size_t const mask = align - 1;
-    assert((align & mask) == 0);
-    return (size + mask) & ~mask;
-}
-
-/**
- * Use this to determine how much space in the workspace we will consume to
- * allocate this object. (Normally it should be exactly the size of the object,
- * but under special conditions, like ASAN, where we pad each object, it might
- * be larger.)
- *
- * Since tables aren't currently redzoned, you don't need to call through this
- * to figure out how much space you need for the matchState tables. Everything
- * else is though.
- *
- * Do not use for sizing aligned buffers. Instead, use ZSTD_cwksp_aligned_alloc_size().
- */
-MEM_STATIC size_t ZSTD_cwksp_alloc_size(size_t size) {
-    if (size == 0)
-        return 0;
-    return size;
-}
-
-/**
- * Returns an adjusted alloc size that is the nearest larger multiple of 64 bytes.
- * Used to determine the number of bytes required for a given "aligned".
- */
-MEM_STATIC size_t ZSTD_cwksp_aligned_alloc_size(size_t size) {
-    return ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(size, ZSTD_CWKSP_ALIGNMENT_BYTES));
-}
-
-/**
- * Returns the amount of additional space the cwksp must allocate
- * for internal purposes (currently only alignment).
- */
-MEM_STATIC size_t ZSTD_cwksp_slack_space_required(void) {
-    /* For alignment, the wksp will always allocate an additional 2*ZSTD_CWKSP_ALIGNMENT_BYTES
-     * bytes to align the beginning of tables section and end of buffers;
-     */
-    size_t const slackSpace = ZSTD_CWKSP_ALIGNMENT_BYTES * 2;
-    return slackSpace;
-}
-
-
-/**
- * Return the number of additional bytes required to align a pointer to the given number of bytes.
- * alignBytes must be a power of two.
- */
-MEM_STATIC size_t ZSTD_cwksp_bytes_to_align_ptr(void* ptr, const size_t alignBytes) {
-    size_t const alignBytesMask = alignBytes - 1;
-    size_t const bytes = (alignBytes - ((size_t)ptr & (alignBytesMask))) & alignBytesMask;
-    assert((alignBytes & alignBytesMask) == 0);
-    assert(bytes < alignBytes);
-    return bytes;
-}
-
-/**
- * Returns the initial value for allocStart which is used to determine the position from
- * which we can allocate from the end of the workspace.
- */
-MEM_STATIC void*  ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws) {
-    return (void*)((size_t)ws->workspaceEnd & ~(ZSTD_CWKSP_ALIGNMENT_BYTES-1));
-}
-
-/**
- * Internal function. Do not use directly.
- * Reserves the given number of bytes within the aligned/buffer segment of the wksp,
- * which counts from the end of the wksp (as opposed to the object/table segment).
- *
- * Returns a pointer to the beginning of that space.
- */
-MEM_STATIC void*
-ZSTD_cwksp_reserve_internal_buffer_space(ZSTD_cwksp* ws, size_t const bytes)
-{
-    void* const alloc = (BYTE*)ws->allocStart - bytes;
-    void* const bottom = ws->tableEnd;
-    DEBUGLOG(5, "cwksp: reserving %p %zd bytes, %zd bytes remaining",
-        alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);
-    ZSTD_cwksp_assert_internal_consistency(ws);
-    assert(alloc >= bottom);
-    if (alloc < bottom) {
-        DEBUGLOG(4, "cwksp: alloc failed!");
-        ws->allocFailed = 1;
-        return NULL;
-    }
-    /* the area is reserved from the end of wksp.
-     * If it overlaps with tableValidEnd, it voids guarantees on values' range */
-    if (alloc < ws->tableValidEnd) {
-        ws->tableValidEnd = alloc;
-    }
-    ws->allocStart = alloc;
-    return alloc;
-}
-
-/**
- * Moves the cwksp to the next phase, and does any necessary allocations.
- * cwksp initialization must necessarily go through each phase in order.
- * Returns a 0 on success, or zstd error
- */
-MEM_STATIC size_t
-ZSTD_cwksp_internal_advance_phase(ZSTD_cwksp* ws, ZSTD_cwksp_alloc_phase_e phase)
-{
-    assert(phase >= ws->phase);
-    if (phase > ws->phase) {
-        /* Going from allocating objects to allocating initOnce / tables */
-        if (ws->phase < ZSTD_cwksp_alloc_aligned_init_once &&
-            phase >= ZSTD_cwksp_alloc_aligned_init_once) {
-            ws->tableValidEnd = ws->objectEnd;
-            ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws);
-
-            {   /* Align the start of the tables to 64 bytes. Use [0, 63] bytes */
-                void *const alloc = ws->objectEnd;
-                size_t const bytesToAlign = ZSTD_cwksp_bytes_to_align_ptr(alloc, ZSTD_CWKSP_ALIGNMENT_BYTES);
-                void *const objectEnd = (BYTE *) alloc + bytesToAlign;
-                DEBUGLOG(5, "reserving table alignment addtl space: %zu", bytesToAlign);
-                RETURN_ERROR_IF(objectEnd > ws->workspaceEnd, memory_allocation,
-                                "table phase - alignment initial allocation failed!");
-                ws->objectEnd = objectEnd;
-                ws->tableEnd = objectEnd;  /* table area starts being empty */
-                if (ws->tableValidEnd < ws->tableEnd) {
-                    ws->tableValidEnd = ws->tableEnd;
-                }
-            }
-        }
-        ws->phase = phase;
-        ZSTD_cwksp_assert_internal_consistency(ws);
-    }
-    return 0;
-}
-
-/**
- * Returns whether this object/buffer/etc was allocated in this workspace.
- */
-MEM_STATIC int ZSTD_cwksp_owns_buffer(const ZSTD_cwksp* ws, const void* ptr)
-{
-    return (ptr != NULL) && (ws->workspace <= ptr) && (ptr < ws->workspaceEnd);
-}
-
-/**
- * Internal function. Do not use directly.
- */
-MEM_STATIC void*
-ZSTD_cwksp_reserve_internal(ZSTD_cwksp* ws, size_t bytes, ZSTD_cwksp_alloc_phase_e phase)
-{
-    void* alloc;
-    if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) || bytes == 0) {
-        return NULL;
-    }
-
-    alloc = ZSTD_cwksp_reserve_internal_buffer_space(ws, bytes);
-    return alloc;
-}
-
-/**
- * Reserves and returns unaligned memory.
- */
-MEM_STATIC BYTE* ZSTD_cwksp_reserve_buffer(ZSTD_cwksp* ws, size_t bytes)
-{
-    return (BYTE*)ZSTD_cwksp_reserve_internal(ws, bytes, ZSTD_cwksp_alloc_buffers);
-}
-
-/**
- * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes).
- * This memory has been initialized at least once in the past.
- * This doesn't mean it has been initialized this time, and it might contain data from previous
- * operations.
- * The main usage is for algorithms that might need read access into uninitialized memory.
- * The algorithm must maintain safety under these conditions and must make sure it doesn't
- * leak any of the past data (directly or in side channels).
- */
-MEM_STATIC void* ZSTD_cwksp_reserve_aligned_init_once(ZSTD_cwksp* ws, size_t bytes)
-{
-    size_t const alignedBytes = ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES);
-    void* ptr = ZSTD_cwksp_reserve_internal(ws, alignedBytes, ZSTD_cwksp_alloc_aligned_init_once);
-    assert(((size_t)ptr & (ZSTD_CWKSP_ALIGNMENT_BYTES-1))== 0);
-    if(ptr && ptr < ws->initOnceStart) {
-        /* We assume the memory following the current allocation is either:
-         * 1. Not usable as initOnce memory (end of workspace)
-         * 2. Another initOnce buffer that has been allocated before (and so was previously memset)
-         * 3. An ASAN redzone, in which case we don't want to write on it
-         * For these reasons it should be fine to not explicitly zero every byte up to ws->initOnceStart.
-         * Note that we assume here that MSAN and ASAN cannot run in the same time. */
-        ZSTD_memset(ptr, 0, MIN((size_t)((U8*)ws->initOnceStart - (U8*)ptr), alignedBytes));
-        ws->initOnceStart = ptr;
-    }
-#if ZSTD_MEMORY_SANITIZER
-    assert(__msan_test_shadow(ptr, bytes) == -1);
-#endif
-    return ptr;
-}
-
-/**
- * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes).
- */
-MEM_STATIC void* ZSTD_cwksp_reserve_aligned(ZSTD_cwksp* ws, size_t bytes)
-{
-    void* ptr = ZSTD_cwksp_reserve_internal(ws, ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES),
-                                            ZSTD_cwksp_alloc_aligned);
-    assert(((size_t)ptr & (ZSTD_CWKSP_ALIGNMENT_BYTES-1))== 0);
-    return ptr;
-}
-
-/**
- * Aligned on 64 bytes. These buffers have the special property that
- * their values remain constrained, allowing us to reuse them without
- * memset()-ing them.
- */
-MEM_STATIC void* ZSTD_cwksp_reserve_table(ZSTD_cwksp* ws, size_t bytes)
-{
-    const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned_init_once;
-    void* alloc;
-    void* end;
-    void* top;
-
-    /* We can only start allocating tables after we are done reserving space for objects at the
-     * start of the workspace */
-    if(ws->phase < phase) {
-        if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))) {
-            return NULL;
-        }
-    }
-    alloc = ws->tableEnd;
-    end = (BYTE *)alloc + bytes;
-    top = ws->allocStart;
-
-    DEBUGLOG(5, "cwksp: reserving %p table %zd bytes, %zd bytes remaining",
-        alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);
-    assert((bytes & (sizeof(U32)-1)) == 0);
-    ZSTD_cwksp_assert_internal_consistency(ws);
-    assert(end <= top);
-    if (end > top) {
-        DEBUGLOG(4, "cwksp: table alloc failed!");
-        ws->allocFailed = 1;
-        return NULL;
-    }
-    ws->tableEnd = end;
-
-    assert((bytes & (ZSTD_CWKSP_ALIGNMENT_BYTES-1)) == 0);
-    assert(((size_t)alloc & (ZSTD_CWKSP_ALIGNMENT_BYTES-1))== 0);
-    return alloc;
-}
-
-/**
- * Aligned on sizeof(void*).
- * Note : should happen only once, at workspace first initialization
- */
-MEM_STATIC void* ZSTD_cwksp_reserve_object(ZSTD_cwksp* ws, size_t bytes)
-{
-    size_t const roundedBytes = ZSTD_cwksp_align(bytes, sizeof(void*));
-    void* alloc = ws->objectEnd;
-    void* end = (BYTE*)alloc + roundedBytes;
-
-    DEBUGLOG(4,
-        "cwksp: reserving %p object %zd bytes (rounded to %zd), %zd bytes remaining",
-        alloc, bytes, roundedBytes, ZSTD_cwksp_available_space(ws) - roundedBytes);
-    assert((size_t)alloc % ZSTD_ALIGNOF(void*) == 0);
-    assert(bytes % ZSTD_ALIGNOF(void*) == 0);
-    ZSTD_cwksp_assert_internal_consistency(ws);
-    /* we must be in the first phase, no advance is possible */
-    if (ws->phase != ZSTD_cwksp_alloc_objects || end > ws->workspaceEnd) {
-        DEBUGLOG(3, "cwksp: object alloc failed!");
-        ws->allocFailed = 1;
-        return NULL;
-    }
-    ws->objectEnd = end;
-    ws->tableEnd = end;
-    ws->tableValidEnd = end;
-
-    return alloc;
-}
-
-MEM_STATIC void ZSTD_cwksp_mark_tables_dirty(ZSTD_cwksp* ws)
-{
-    DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_dirty");
-
-    assert(ws->tableValidEnd >= ws->objectEnd);
-    assert(ws->tableValidEnd <= ws->allocStart);
-    ws->tableValidEnd = ws->objectEnd;
-    ZSTD_cwksp_assert_internal_consistency(ws);
-}
-
-MEM_STATIC void ZSTD_cwksp_mark_tables_clean(ZSTD_cwksp* ws) {
-    DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_clean");
-    assert(ws->tableValidEnd >= ws->objectEnd);
-    assert(ws->tableValidEnd <= ws->allocStart);
-    if (ws->tableValidEnd < ws->tableEnd) {
-        ws->tableValidEnd = ws->tableEnd;
-    }
-    ZSTD_cwksp_assert_internal_consistency(ws);
-}
-
-/**
- * Zero the part of the allocated tables not already marked clean.
- */
-MEM_STATIC void ZSTD_cwksp_clean_tables(ZSTD_cwksp* ws) {
-    DEBUGLOG(4, "cwksp: ZSTD_cwksp_clean_tables");
-    assert(ws->tableValidEnd >= ws->objectEnd);
-    assert(ws->tableValidEnd <= ws->allocStart);
-    if (ws->tableValidEnd < ws->tableEnd) {
-        ZSTD_memset(ws->tableValidEnd, 0, (size_t)((BYTE*)ws->tableEnd - (BYTE*)ws->tableValidEnd));
-    }
-    ZSTD_cwksp_mark_tables_clean(ws);
-}
-
-/**
- * Invalidates table allocations.
- * All other allocations remain valid.
- */
-MEM_STATIC void ZSTD_cwksp_clear_tables(ZSTD_cwksp* ws) {
-    DEBUGLOG(4, "cwksp: clearing tables!");
-
-    ws->tableEnd = ws->objectEnd;
-    ZSTD_cwksp_assert_internal_consistency(ws);
-}
-
-/**
- * Invalidates all buffer, aligned, and table allocations.
- * Object allocations remain valid.
- */
-MEM_STATIC void ZSTD_cwksp_clear(ZSTD_cwksp* ws) {
-    DEBUGLOG(4, "cwksp: clearing!");
-
-    ws->tableEnd = ws->objectEnd;
-    ws->allocStart = ZSTD_cwksp_initialAllocStart(ws);
-    ws->allocFailed = 0;
-    if (ws->phase > ZSTD_cwksp_alloc_aligned_init_once) {
-        ws->phase = ZSTD_cwksp_alloc_aligned_init_once;
-    }
-    ZSTD_cwksp_assert_internal_consistency(ws);
-}
-
-MEM_STATIC size_t ZSTD_cwksp_sizeof(const ZSTD_cwksp* ws) {
-    return (size_t)((BYTE*)ws->workspaceEnd - (BYTE*)ws->workspace);
-}
-
-MEM_STATIC size_t ZSTD_cwksp_used(const ZSTD_cwksp* ws) {
-    return (size_t)((BYTE*)ws->tableEnd - (BYTE*)ws->workspace)
-         + (size_t)((BYTE*)ws->workspaceEnd - (BYTE*)ws->allocStart);
-}
-
-/**
- * The provided workspace takes ownership of the buffer [start, start+size).
- * Any existing values in the workspace are ignored (the previously managed
- * buffer, if present, must be separately freed).
- */
-MEM_STATIC void ZSTD_cwksp_init(ZSTD_cwksp* ws, void* start, size_t size, ZSTD_cwksp_static_alloc_e isStatic) {
-    DEBUGLOG(4, "cwksp: init'ing workspace with %zd bytes", size);
-    assert(((size_t)start & (sizeof(void*)-1)) == 0); /* ensure correct alignment */
-    ws->workspace = start;
-    ws->workspaceEnd = (BYTE*)start + size;
-    ws->objectEnd = ws->workspace;
-    ws->tableValidEnd = ws->objectEnd;
-    ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws);
-    ws->phase = ZSTD_cwksp_alloc_objects;
-    ws->isStatic = isStatic;
-    ZSTD_cwksp_clear(ws);
-    ws->workspaceOversizedDuration = 0;
-    ZSTD_cwksp_assert_internal_consistency(ws);
-}
-
-MEM_STATIC size_t ZSTD_cwksp_create(ZSTD_cwksp* ws, size_t size, ZSTD_customMem customMem) {
-    void* workspace = ZSTD_customMalloc(size, customMem);
-    DEBUGLOG(4, "cwksp: creating new workspace with %zd bytes", size);
-    RETURN_ERROR_IF(workspace == NULL, memory_allocation, "NULL pointer!");
-    ZSTD_cwksp_init(ws, workspace, size, ZSTD_cwksp_dynamic_alloc);
-    return 0;
-}
-
-MEM_STATIC void ZSTD_cwksp_free(ZSTD_cwksp* ws, ZSTD_customMem customMem) {
-    void *ptr = ws->workspace;
-    DEBUGLOG(4, "cwksp: freeing workspace");
-    ZSTD_memset(ws, 0, sizeof(ZSTD_cwksp));
-    ZSTD_customFree(ptr, customMem);
-}
-
-/**
- * Moves the management of a workspace from one cwksp to another. The src cwksp
- * is left in an invalid state (src must be re-init()'ed before it's used again).
- */
-MEM_STATIC void ZSTD_cwksp_move(ZSTD_cwksp* dst, ZSTD_cwksp* src) {
-    *dst = *src;
-    ZSTD_memset(src, 0, sizeof(ZSTD_cwksp));
-}
-
-MEM_STATIC int ZSTD_cwksp_reserve_failed(const ZSTD_cwksp* ws) {
-    return ws->allocFailed;
-}
-
-/*-*************************************
-*  Functions Checking Free Space
-***************************************/
-
-/* ZSTD_alignmentSpaceWithinBounds() :
- * Returns if the estimated space needed for a wksp is within an acceptable limit of the
- * actual amount of space used.
- */
-MEM_STATIC int ZSTD_cwksp_estimated_space_within_bounds(const ZSTD_cwksp *const ws, size_t const estimatedSpace) {
-    /* We have an alignment space between objects and tables between tables and buffers, so we can have up to twice
-     * the alignment bytes difference between estimation and actual usage */
-    return (estimatedSpace - ZSTD_cwksp_slack_space_required()) <= ZSTD_cwksp_used(ws) &&
-           ZSTD_cwksp_used(ws) <= estimatedSpace;
-}
-
-
-MEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws) {
-    return (size_t)((BYTE*)ws->allocStart - (BYTE*)ws->tableEnd);
-}
-
-MEM_STATIC int ZSTD_cwksp_check_available(ZSTD_cwksp* ws, size_t additionalNeededSpace) {
-    return ZSTD_cwksp_available_space(ws) >= additionalNeededSpace;
-}
-
-MEM_STATIC int ZSTD_cwksp_check_too_large(ZSTD_cwksp* ws, size_t additionalNeededSpace) {
-    return ZSTD_cwksp_check_available(
-        ws, additionalNeededSpace * ZSTD_WORKSPACETOOLARGE_FACTOR);
-}
-
-MEM_STATIC int ZSTD_cwksp_check_wasteful(ZSTD_cwksp* ws, size_t additionalNeededSpace) {
-    return ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)
-        && ws->workspaceOversizedDuration > ZSTD_WORKSPACETOOLARGE_MAXDURATION;
-}
-
-MEM_STATIC void ZSTD_cwksp_bump_oversized_duration(
-        ZSTD_cwksp* ws, size_t additionalNeededSpace) {
-    if (ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)) {
-        ws->workspaceOversizedDuration++;
-    } else {
-        ws->workspaceOversizedDuration = 0;
-    }
-}
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_CWKSP_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_double_fast.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_double_fast.h
deleted file mode 100644
index c91680abc..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_double_fast.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_DOUBLE_FAST_H
-#define ZSTD_DOUBLE_FAST_H
-
-#include "zstd/common/mem.h"      /* U32 */
-#include "zstd/compress/zstd_compress_internal.h"     /* ZSTD_CCtx, size_t */
-
-namespace duckdb_zstd {
-
-#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR
-
-void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
-                              void const* end, ZSTD_dictTableLoadMethod_e dtlm,
-                              ZSTD_tableFillPurpose_e tfp);
-
-size_t ZSTD_compressBlock_doubleFast(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_doubleFast_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_doubleFast_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_DOUBLEFAST ZSTD_compressBlock_doubleFast
-#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE ZSTD_compressBlock_doubleFast_dictMatchState
-#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT ZSTD_compressBlock_doubleFast_extDict
-#else
-#define ZSTD_COMPRESSBLOCK_DOUBLEFAST NULL
-#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT NULL
-#endif /* ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR */
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_DOUBLE_FAST_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_fast.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_fast.h
deleted file mode 100644
index 2f7ee5b64..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_fast.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_FAST_H
-#define ZSTD_FAST_H
-
-#include "zstd/common/mem.h"      /* U32 */
-#include "zstd/compress/zstd_compress_internal.h"
-
-namespace duckdb_zstd {
-
-void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
-                        void const* end, ZSTD_dictTableLoadMethod_e dtlm,
-                        ZSTD_tableFillPurpose_e tfp);
-size_t ZSTD_compressBlock_fast(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_fast_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_fast_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_FAST_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_lazy.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_lazy.h
deleted file mode 100644
index d43882c46..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_lazy.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_LAZY_H
-#define ZSTD_LAZY_H
-
-#include "zstd/compress/zstd_compress_internal.h"
-
-namespace duckdb_zstd {
-
-/**
- * Dedicated Dictionary Search Structure bucket log. In the
- * ZSTD_dedicatedDictSearch mode, the hashTable has
- * 2 ** ZSTD_LAZY_DDSS_BUCKET_LOG entries in each bucket, rather than just
- * one.
- */
-#define ZSTD_LAZY_DDSS_BUCKET_LOG 2
-
-#define ZSTD_ROW_HASH_TAG_BITS 8        /* nb bits to use for the tag */
-
-#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR)
-U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip);
-void ZSTD_row_update(ZSTD_matchState_t* const ms, const BYTE* ip);
-
-void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const BYTE* const ip);
-
-void ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue);  /*! used in ZSTD_reduceIndex(). preemptively increase value of ZSTD_DUBT_UNSORTED_MARK */
-#endif
-
-#ifndef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_greedy(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_dictMatchState_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_dedicatedDictSearch(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_dedicatedDictSearch_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_greedy_extDict_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_GREEDY ZSTD_compressBlock_greedy
-#define ZSTD_COMPRESSBLOCK_GREEDY_ROW ZSTD_compressBlock_greedy_row
-#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE ZSTD_compressBlock_greedy_dictMatchState
-#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW ZSTD_compressBlock_greedy_dictMatchState_row
-#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH ZSTD_compressBlock_greedy_dedicatedDictSearch
-#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW ZSTD_compressBlock_greedy_dedicatedDictSearch_row
-#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT ZSTD_compressBlock_greedy_extDict
-#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW ZSTD_compressBlock_greedy_extDict_row
-#else
-#define ZSTD_COMPRESSBLOCK_GREEDY NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_ROW NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT NULL
-#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW NULL
-#endif
-
-#ifndef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_lazy(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_dictMatchState_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_dedicatedDictSearch(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_dedicatedDictSearch_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy_extDict_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_LAZY ZSTD_compressBlock_lazy
-#define ZSTD_COMPRESSBLOCK_LAZY_ROW ZSTD_compressBlock_lazy_row
-#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE ZSTD_compressBlock_lazy_dictMatchState
-#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW ZSTD_compressBlock_lazy_dictMatchState_row
-#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH ZSTD_compressBlock_lazy_dedicatedDictSearch
-#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW ZSTD_compressBlock_lazy_dedicatedDictSearch_row
-#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT ZSTD_compressBlock_lazy_extDict
-#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW ZSTD_compressBlock_lazy_extDict_row
-#else
-#define ZSTD_COMPRESSBLOCK_LAZY NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_ROW NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT NULL
-#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW NULL
-#endif
-
-#ifndef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_lazy2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_dictMatchState_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_lazy2_extDict_row(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_LAZY2 ZSTD_compressBlock_lazy2
-#define ZSTD_COMPRESSBLOCK_LAZY2_ROW ZSTD_compressBlock_lazy2_row
-#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE ZSTD_compressBlock_lazy2_dictMatchState
-#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW ZSTD_compressBlock_lazy2_dictMatchState_row
-#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH ZSTD_compressBlock_lazy2_dedicatedDictSearch
-#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW ZSTD_compressBlock_lazy2_dedicatedDictSearch_row
-#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT ZSTD_compressBlock_lazy2_extDict
-#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW ZSTD_compressBlock_lazy2_extDict_row
-#else
-#define ZSTD_COMPRESSBLOCK_LAZY2 NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_ROW NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT NULL
-#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW NULL
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btlazy2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btlazy2_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btlazy2_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_BTLAZY2 ZSTD_compressBlock_btlazy2
-#define ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE ZSTD_compressBlock_btlazy2_dictMatchState
-#define ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT ZSTD_compressBlock_btlazy2_extDict
-#else
-#define ZSTD_COMPRESSBLOCK_BTLAZY2 NULL
-#define ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT NULL
-#endif
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_LAZY_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_ldm.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_ldm.h
deleted file mode 100644
index a389c64f2..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_ldm.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_LDM_H
-#define ZSTD_LDM_H
-
-
-#include "zstd/compress/zstd_compress_internal.h"   /* ldmParams_t, U32 */
-#include "zstd.h"   /* ZSTD_CCtx, size_t */
-
-namespace duckdb_zstd {
-
-/*-*************************************
-*  Long distance matching
-***************************************/
-
-#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT
-
-void ZSTD_ldm_fillHashTable(
-            ldmState_t* state, const BYTE* ip,
-            const BYTE* iend, ldmParams_t const* params);
-
-/**
- * ZSTD_ldm_generateSequences():
- *
- * Generates the sequences using the long distance match finder.
- * Generates long range matching sequences in `sequences`, which parse a prefix
- * of the source. `sequences` must be large enough to store every sequence,
- * which can be checked with `ZSTD_ldm_getMaxNbSeq()`.
- * @returns 0 or an error code.
- *
- * NOTE: The user must have called ZSTD_window_update() for all of the input
- * they have, even if they pass it to ZSTD_ldm_generateSequences() in chunks.
- * NOTE: This function returns an error if it runs out of space to store
- *       sequences.
- */
-size_t ZSTD_ldm_generateSequences(
-            ldmState_t* ldms, rawSeqStore_t* sequences,
-            ldmParams_t const* params, void const* src, size_t srcSize);
-
-/**
- * ZSTD_ldm_blockCompress():
- *
- * Compresses a block using the predefined sequences, along with a secondary
- * block compressor. The literals section of every sequence is passed to the
- * secondary block compressor, and those sequences are interspersed with the
- * predefined sequences. Returns the length of the last literals.
- * Updates `rawSeqStore.pos` to indicate how many sequences have been consumed.
- * `rawSeqStore.seq` may also be updated to split the last sequence between two
- * blocks.
- * @return The length of the last literals.
- *
- * NOTE: The source must be at most the maximum block size, but the predefined
- * sequences can be any size, and may be longer than the block. In the case that
- * they are longer than the block, the last sequences may need to be split into
- * two. We handle that case correctly, and update `rawSeqStore` appropriately.
- * NOTE: This function does not return any errors.
- */
-size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
-            ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-            ZSTD_paramSwitch_e useRowMatchFinder,
-            void const* src, size_t srcSize);
-
-/**
- * ZSTD_ldm_skipSequences():
- *
- * Skip past `srcSize` bytes worth of sequences in `rawSeqStore`.
- * Avoids emitting matches less than `minMatch` bytes.
- * Must be called for data that is not passed to ZSTD_ldm_blockCompress().
- */
-void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize,
-    U32 const minMatch);
-
-/* ZSTD_ldm_skipRawSeqStoreBytes():
- * Moves forward in rawSeqStore by nbBytes, updating fields 'pos' and 'posInSequence'.
- * Not to be used in conjunction with ZSTD_ldm_skipSequences().
- * Must be called for data with is not passed to ZSTD_ldm_blockCompress().
- */
-void ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore_t* rawSeqStore, size_t nbBytes);
-
-/** ZSTD_ldm_getTableSize() :
- *  Estimate the space needed for long distance matching tables or 0 if LDM is
- *  disabled.
- */
-size_t ZSTD_ldm_getTableSize(ldmParams_t params);
-
-/** ZSTD_ldm_getSeqSpace() :
- *  Return an upper bound on the number of sequences that can be produced by
- *  the long distance matcher, or 0 if LDM is disabled.
- */
-size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize);
-
-/** ZSTD_ldm_adjustParameters() :
- *  If the params->hashRateLog is not set, set it to its default value based on
- *  windowLog and params->hashLog.
- *
- *  Ensures that params->bucketSizeLog is <= params->hashLog (setting it to
- *  params->hashLog if it is not).
- *
- *  Ensures that the minMatchLength >= targetLength during optimal parsing.
- */
-void ZSTD_ldm_adjustParameters(ldmParams_t* params,
-                               ZSTD_compressionParameters const* cParams);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_LDM_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_ldm_geartab.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_ldm_geartab.h
deleted file mode 100644
index 3d4b1daa1..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_ldm_geartab.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_LDM_GEARTAB_H
-#define ZSTD_LDM_GEARTAB_H
-
-#include "zstd/common/compiler.h" /* UNUSED_ATTR */
-#include "zstd/common/mem.h"      /* U64 */
-
-namespace duckdb_zstd {
-
-static UNUSED_ATTR const U64 ZSTD_ldm_gearTab[256] = {
-    0xf5b8f72c5f77775c, 0x84935f266b7ac412, 0xb647ada9ca730ccc,
-    0xb065bb4b114fb1de, 0x34584e7e8c3a9fd0, 0x4e97e17c6ae26b05,
-    0x3a03d743bc99a604, 0xcecd042422c4044f, 0x76de76c58524259e,
-    0x9c8528f65badeaca, 0x86563706e2097529, 0x2902475fa375d889,
-    0xafb32a9739a5ebe6, 0xce2714da3883e639, 0x21eaf821722e69e,
-    0x37b628620b628,    0x49a8d455d88caf5,  0x8556d711e6958140,
-    0x4f7ae74fc605c1f,  0x829f0c3468bd3a20, 0x4ffdc885c625179e,
-    0x8473de048a3daf1b, 0x51008822b05646b2, 0x69d75d12b2d1cc5f,
-    0x8c9d4a19159154bc, 0xc3cc10f4abbd4003, 0xd06ddc1cecb97391,
-    0xbe48e6e7ed80302e, 0x3481db31cee03547, 0xacc3f67cdaa1d210,
-    0x65cb771d8c7f96cc, 0x8eb27177055723dd, 0xc789950d44cd94be,
-    0x934feadc3700b12b, 0x5e485f11edbdf182, 0x1e2e2a46fd64767a,
-    0x2969ca71d82efa7c, 0x9d46e9935ebbba2e, 0xe056b67e05e6822b,
-    0x94d73f55739d03a0, 0xcd7010bdb69b5a03, 0x455ef9fcd79b82f4,
-    0x869cb54a8749c161, 0x38d1a4fa6185d225, 0xb475166f94bbe9bb,
-    0xa4143548720959f1, 0x7aed4780ba6b26ba, 0xd0ce264439e02312,
-    0x84366d746078d508, 0xa8ce973c72ed17be, 0x21c323a29a430b01,
-    0x9962d617e3af80ee, 0xab0ce91d9c8cf75b, 0x530e8ee6d19a4dbc,
-    0x2ef68c0cf53f5d72, 0xc03a681640a85506, 0x496e4e9f9c310967,
-    0x78580472b59b14a0, 0x273824c23b388577, 0x66bf923ad45cb553,
-    0x47ae1a5a2492ba86, 0x35e304569e229659, 0x4765182a46870b6f,
-    0x6cbab625e9099412, 0xddac9a2e598522c1, 0x7172086e666624f2,
-    0xdf5003ca503b7837, 0x88c0c1db78563d09, 0x58d51865acfc289d,
-    0x177671aec65224f1, 0xfb79d8a241e967d7, 0x2be1e101cad9a49a,
-    0x6625682f6e29186b, 0x399553457ac06e50, 0x35dffb4c23abb74,
-    0x429db2591f54aade, 0xc52802a8037d1009, 0x6acb27381f0b25f3,
-    0xf45e2551ee4f823b, 0x8b0ea2d99580c2f7, 0x3bed519cbcb4e1e1,
-    0xff452823dbb010a,  0x9d42ed614f3dd267, 0x5b9313c06257c57b,
-    0xa114b8008b5e1442, 0xc1fe311c11c13d4b, 0x66e8763ea34c5568,
-    0x8b982af1c262f05d, 0xee8876faaa75fbb7, 0x8a62a4d0d172bb2a,
-    0xc13d94a3b7449a97, 0x6dbbba9dc15d037c, 0xc786101f1d92e0f1,
-    0xd78681a907a0b79b, 0xf61aaf2962c9abb9, 0x2cfd16fcd3cb7ad9,
-    0x868c5b6744624d21, 0x25e650899c74ddd7, 0xba042af4a7c37463,
-    0x4eb1a539465a3eca, 0xbe09dbf03b05d5ca, 0x774e5a362b5472ba,
-    0x47a1221229d183cd, 0x504b0ca18ef5a2df, 0xdffbdfbde2456eb9,
-    0x46cd2b2fbee34634, 0xf2aef8fe819d98c3, 0x357f5276d4599d61,
-    0x24a5483879c453e3, 0x88026889192b4b9,  0x28da96671782dbec,
-    0x4ef37c40588e9aaa, 0x8837b90651bc9fb3, 0xc164f741d3f0e5d6,
-    0xbc135a0a704b70ba, 0x69cd868f7622ada,  0xbc37ba89e0b9c0ab,
-    0x47c14a01323552f6, 0x4f00794bacee98bb, 0x7107de7d637a69d5,
-    0x88af793bb6f2255e, 0xf3c6466b8799b598, 0xc288c616aa7f3b59,
-    0x81ca63cf42fca3fd, 0x88d85ace36a2674b, 0xd056bd3792389e7,
-    0xe55c396c4e9dd32d, 0xbefb504571e6c0a6, 0x96ab32115e91e8cc,
-    0xbf8acb18de8f38d1, 0x66dae58801672606, 0x833b6017872317fb,
-    0xb87c16f2d1c92864, 0xdb766a74e58b669c, 0x89659f85c61417be,
-    0xc8daad856011ea0c, 0x76a4b565b6fe7eae, 0xa469d085f6237312,
-    0xaaf0365683a3e96c, 0x4dbb746f8424f7b8, 0x638755af4e4acc1,
-    0x3d7807f5bde64486, 0x17be6d8f5bbb7639, 0x903f0cd44dc35dc,
-    0x67b672eafdf1196c, 0xa676ff93ed4c82f1, 0x521d1004c5053d9d,
-    0x37ba9ad09ccc9202, 0x84e54d297aacfb51, 0xa0b4b776a143445,
-    0x820d471e20b348e,  0x1874383cb83d46dc, 0x97edeec7a1efe11c,
-    0xb330e50b1bdc42aa, 0x1dd91955ce70e032, 0xa514cdb88f2939d5,
-    0x2791233fd90db9d3, 0x7b670a4cc50f7a9b, 0x77c07d2a05c6dfa5,
-    0xe3778b6646d0a6fa, 0xb39c8eda47b56749, 0x933ed448addbef28,
-    0xaf846af6ab7d0bf4, 0xe5af208eb666e49,  0x5e6622f73534cd6a,
-    0x297daeca42ef5b6e, 0x862daef3d35539a6, 0xe68722498f8e1ea9,
-    0x981c53093dc0d572, 0xfa09b0bfbf86fbf5, 0x30b1e96166219f15,
-    0x70e7d466bdc4fb83, 0x5a66736e35f2a8e9, 0xcddb59d2b7c1baef,
-    0xd6c7d247d26d8996, 0xea4e39eac8de1ba3, 0x539c8bb19fa3aff2,
-    0x9f90e4c5fd508d8,  0xa34e5956fbaf3385, 0x2e2f8e151d3ef375,
-    0x173691e9b83faec1, 0xb85a8d56bf016379, 0x8382381267408ae3,
-    0xb90f901bbdc0096d, 0x7c6ad32933bcec65, 0x76bb5e2f2c8ad595,
-    0x390f851a6cf46d28, 0xc3e6064da1c2da72, 0xc52a0c101cfa5389,
-    0xd78eaf84a3fbc530, 0x3781b9e2288b997e, 0x73c2f6dea83d05c4,
-    0x4228e364c5b5ed7,  0x9d7a3edf0da43911, 0x8edcfeda24686756,
-    0x5e7667a7b7a9b3a1, 0x4c4f389fa143791d, 0xb08bc1023da7cddc,
-    0x7ab4be3ae529b1cc, 0x754e6132dbe74ff9, 0x71635442a839df45,
-    0x2f6fb1643fbe52de, 0x961e0a42cf7a8177, 0xf3b45d83d89ef2ea,
-    0xee3de4cf4a6e3e9b, 0xcd6848542c3295e7, 0xe4cee1664c78662f,
-    0x9947548b474c68c4, 0x25d73777a5ed8b0b, 0xc915b1d636b7fc,
-    0x21c2ba75d9b0d2da, 0x5f6b5dcf608a64a1, 0xdcf333255ff9570c,
-    0x633b922418ced4ee, 0xc136dde0b004b34a, 0x58cc83b05d4b2f5a,
-    0x5eb424dda28e42d2, 0x62df47369739cd98, 0xb4e0b42485e4ce17,
-    0x16e1f0c1f9a8d1e7, 0x8ec3916707560ebf, 0x62ba6e2df2cc9db3,
-    0xcbf9f4ff77d83a16, 0x78d9d7d07d2bbcc4, 0xef554ce1e02c41f4,
-    0x8d7581127eccf94d, 0xa9b53336cb3c8a05, 0x38c42c0bf45c4f91,
-    0x640893cdf4488863, 0x80ec34bc575ea568, 0x39f324f5b48eaa40,
-    0xe9d9ed1f8eff527f, 0x9224fc058cc5a214, 0xbaba00b04cfe7741,
-    0x309a9f120fcf52af, 0xa558f3ec65626212, 0x424bec8b7adabe2f,
-    0x41622513a6aea433, 0xb88da2d5324ca798, 0xd287733b245528a4,
-    0x9a44697e6d68aec3, 0x7b1093be2f49bb28, 0x50bbec632e3d8aad,
-    0x6cd90723e1ea8283, 0x897b9e7431b02bf3, 0x219efdcb338a7047,
-    0x3b0311f0a27c0656, 0xdb17bf91c0db96e7, 0x8cd4fd6b4e85a5b2,
-    0xfab071054ba6409d, 0x40d6fe831fa9dfd9, 0xaf358debad7d791e,
-    0xeb8d0e25a65e3e58, 0xbbcbd3df14e08580, 0xcf751f27ecdab2b,
-    0x2b4da14f2613d8f4
-};
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_LDM_GEARTAB_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_opt.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstd_opt.h
deleted file mode 100644
index e2d45826f..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstd_opt.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_OPT_H
-#define ZSTD_OPT_H
-
-#include "zstd/compress/zstd_compress_internal.h"
-
-namespace duckdb_zstd {
-
-#if !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \
- || !defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)
-/* used in ZSTD_loadDictionaryContent() */
-void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend);
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btopt(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btopt_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btopt_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_BTOPT ZSTD_compressBlock_btopt
-#define ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE ZSTD_compressBlock_btopt_dictMatchState
-#define ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT ZSTD_compressBlock_btopt_extDict
-#else
-#define ZSTD_COMPRESSBLOCK_BTOPT NULL
-#define ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT NULL
-#endif
-
-#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR
-size_t ZSTD_compressBlock_btultra(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btultra_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btultra_extDict(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-        /* note : no btultra2 variant for extDict nor dictMatchState,
-         * because btultra2 is not meant to work with dictionaries
-         * and is only specific for the first block (no prefix) */
-size_t ZSTD_compressBlock_btultra2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-#define ZSTD_COMPRESSBLOCK_BTULTRA ZSTD_compressBlock_btultra
-#define ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE ZSTD_compressBlock_btultra_dictMatchState
-#define ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT ZSTD_compressBlock_btultra_extDict
-#define ZSTD_COMPRESSBLOCK_BTULTRA2 ZSTD_compressBlock_btultra2
-#else
-#define ZSTD_COMPRESSBLOCK_BTULTRA NULL
-#define ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE NULL
-#define ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT NULL
-#define ZSTD_COMPRESSBLOCK_BTULTRA2 NULL
-#endif
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_OPT_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/compress/zstdmt_compress.h b/src/duckdb/third_party/zstd/include/zstd/compress/zstdmt_compress.h
deleted file mode 100644
index 99f7757dd..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/compress/zstdmt_compress.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
- #ifndef ZSTDMT_COMPRESS_H
- #define ZSTDMT_COMPRESS_H
-
-/* Note : This is an internal API.
- *        These APIs used to be exposed with ZSTDLIB_API,
- *        because it used to be the only way to invoke MT compression.
- *        Now, you must use ZSTD_compress2 and ZSTD_compressStream2() instead.
- *
- *        This API requires ZSTD_MULTITHREAD to be defined during compilation,
- *        otherwise ZSTDMT_createCCtx*() will fail.
- */
-
-/* ===   Dependencies   === */
-#include "zstd/common/zstd_deps.h"   /* size_t */
-#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters */
-#include "zstd.h"            /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */
-
-namespace duckdb_zstd {
-
-/* ===   Constants   === */
-#ifndef ZSTDMT_NBWORKERS_MAX /* a different value can be selected at compile time */
-#  define ZSTDMT_NBWORKERS_MAX ((sizeof(void*)==4) /*32-bit*/ ? 64 : 256)
-#endif
-#ifndef ZSTDMT_JOBSIZE_MIN   /* a different value can be selected at compile time */
-#  define ZSTDMT_JOBSIZE_MIN (512 KB)
-#endif
-#define ZSTDMT_JOBLOG_MAX   (MEM_32bits() ? 29 : 30)
-#define ZSTDMT_JOBSIZE_MAX  (MEM_32bits() ? (512 MB) : (1024 MB))
-
-
-/* ========================================================
- * ===  Private interface, for use by ZSTD_compress.c   ===
- * ===  Not exposed in libzstd. Never invoke directly   ===
- * ======================================================== */
-
-/* ===   Memory management   === */
-typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;
-/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */
-ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,
-                                        ZSTD_customMem cMem,
-					ZSTD_threadPool *pool);
-size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx);
-
-size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx);
-
-/* ===   Streaming functions   === */
-
-size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx);
-
-/*! ZSTDMT_initCStream_internal() :
- *  Private use only. Init streaming operation.
- *  expects params to be valid.
- *  must receive dict, or cdict, or none, but not both.
- *  mtctx can be freshly constructed or reused from a prior compression.
- *  If mtctx is reused, memory allocations from the prior compression may not be freed,
- *  even if they are not needed for the current compression.
- *  @return : 0, or an error code */
-size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* mtctx,
-                    const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,
-                    const ZSTD_CDict* cdict,
-                    ZSTD_CCtx_params params, unsigned long long pledgedSrcSize);
-
-/*! ZSTDMT_compressStream_generic() :
- *  Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()
- *  depending on flush directive.
- * @return : minimum amount of data still to be flushed
- *           0 if fully flushed
- *           or an error code
- *  note : needs to be init using any ZSTD_initCStream*() variant */
-size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
-                                     ZSTD_outBuffer* output,
-                                     ZSTD_inBuffer* input,
-                                     ZSTD_EndDirective endOp);
-
- /*! ZSTDMT_toFlushNow()
-  *  Tell how many bytes are ready to be flushed immediately.
-  *  Probe the oldest active job (not yet entirely flushed) and check its output buffer.
-  *  If return 0, it means there is no active job,
-  *  or, it means oldest job is still active, but everything produced has been flushed so far,
-  *  therefore flushing is limited by speed of oldest job. */
-size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx);
-
-/*! ZSTDMT_updateCParams_whileCompressing() :
- *  Updates only a selected set of compression parameters, to remain compatible with current frame.
- *  New parameters will be applied to next compression job. */
-void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams);
-
-/*! ZSTDMT_getFrameProgression():
- *  tells how much data has been consumed (input) and produced (output) for current frame.
- *  able to count progression inside worker threads.
- */
-ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx);
-
-
-} // namespace duckdb_zstd
-
-#endif   /* ZSTDMT_COMPRESS_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_ddict.h b/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_ddict.h
deleted file mode 100644
index 7dc647936..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_ddict.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-#ifndef ZSTD_DDICT_H
-#define ZSTD_DDICT_H
-
-/*-*******************************************************
- *  Dependencies
- *********************************************************/
-#include "zstd/common/zstd_deps.h"   /* size_t */
-#include "zstd.h"     /* ZSTD_DDict, and several public functions */
-
-namespace duckdb_zstd {
-
-/*-*******************************************************
- *  Interface
- *********************************************************/
-
-/* note: several prototypes are already published in `zstd.h` :
- * ZSTD_createDDict()
- * ZSTD_createDDict_byReference()
- * ZSTD_createDDict_advanced()
- * ZSTD_freeDDict()
- * ZSTD_initStaticDDict()
- * ZSTD_sizeof_DDict()
- * ZSTD_estimateDDictSize()
- * ZSTD_getDictID_fromDict()
- */
-
-const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict);
-size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);
-
-void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_DDICT_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_decompress_block.h b/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_decompress_block.h
deleted file mode 100644
index 7131a0d95..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_decompress_block.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-#ifndef ZSTD_DEC_BLOCK_H
-#define ZSTD_DEC_BLOCK_H
-
-/*-*******************************************************
- *  Dependencies
- *********************************************************/
-#include "zstd/common/zstd_deps.h"   /* size_t */
-#include "zstd.h"    /* DCtx, and some public functions */
-#include "zstd/common/zstd_internal.h"  /* blockProperties_t, and some public functions */
-#include "zstd/decompress/zstd_decompress_internal.h"  /* ZSTD_seqSymbol */
-
-namespace duckdb_zstd {
-
-/* ===   Prototypes   === */
-
-/* note: prototypes already published within `zstd.h` :
- * ZSTD_decompressBlock()
- */
-
-/* note: prototypes already published within `zstd_internal.h` :
- * ZSTD_getcBlockSize()
- * ZSTD_decodeSeqHeaders()
- */
-
-
- /* Streaming state is used to inform allocation of the literal buffer */
-typedef enum {
-    not_streaming = 0,
-    is_streaming = 1
-} streaming_operation;
-
-/* ZSTD_decompressBlock_internal() :
- * decompress block, starting at `src`,
- * into destination buffer `dst`.
- * @return : decompressed block size,
- *           or an error code (which can be tested using ZSTD_isError())
- */
-size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize, const streaming_operation streaming);
-
-/* ZSTD_buildFSETable() :
- * generate FSE decoding table for one symbol (ll, ml or off)
- * this function must be called with valid parameters only
- * (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.)
- * in which case it cannot fail.
- * The workspace must be 4-byte aligned and at least ZSTD_BUILD_FSE_TABLE_WKSP_SIZE bytes, which is
- * defined in zstd_decompress_internal.h.
- * Internal use only.
- */
-void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
-             const short* normalizedCounter, unsigned maxSymbolValue,
-             const U32* baseValue, const U8* nbAdditionalBits,
-                   unsigned tableLog, void* wksp, size_t wkspSize,
-                   int bmi2);
-
-/* Internal definition of ZSTD_decompressBlock() to avoid deprecation warnings. */
-size_t ZSTD_decompressBlock_deprecated(ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_DEC_BLOCK_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_decompress_internal.h b/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_decompress_internal.h
deleted file mode 100644
index 0f7e198e1..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/decompress/zstd_decompress_internal.h
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-
-/* zstd_decompress_internal:
- * objects and definitions shared within lib/decompress modules */
-
- #ifndef ZSTD_DECOMPRESS_INTERNAL_H
- #define ZSTD_DECOMPRESS_INTERNAL_H
-
-
-/*-*******************************************************
- *  Dependencies
- *********************************************************/
-#include "zstd/common/mem.h"             /* BYTE, U16, U32 */
-#include "zstd/common/zstd_internal.h"   /* constants : MaxLL, MaxML, MaxOff, LLFSELog, etc. */
-
-namespace duckdb_zstd {
-
-/*-*******************************************************
- *  Constants
- *********************************************************/
-static UNUSED_ATTR const U32 LL_base[MaxLL+1] = {
-                 0,    1,    2,     3,     4,     5,     6,      7,
-                 8,    9,   10,    11,    12,    13,    14,     15,
-                16,   18,   20,    22,    24,    28,    32,     40,
-                48,   64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
-                0x2000, 0x4000, 0x8000, 0x10000 };
-
-static UNUSED_ATTR const U32 OF_base[MaxOff+1] = {
-                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
-                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
-                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
-                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };
-
-static UNUSED_ATTR const U8 OF_bits[MaxOff+1] = {
-                     0,  1,  2,  3,  4,  5,  6,  7,
-                     8,  9, 10, 11, 12, 13, 14, 15,
-                    16, 17, 18, 19, 20, 21, 22, 23,
-                    24, 25, 26, 27, 28, 29, 30, 31 };
-
-static UNUSED_ATTR const U32 ML_base[MaxML+1] = {
-                     3,  4,  5,    6,     7,     8,     9,    10,
-                    11, 12, 13,   14,    15,    16,    17,    18,
-                    19, 20, 21,   22,    23,    24,    25,    26,
-                    27, 28, 29,   30,    31,    32,    33,    34,
-                    35, 37, 39,   41,    43,    47,    51,    59,
-                    67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
-                    0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
-
-
-/*-*******************************************************
- *  Decompression types
- *********************************************************/
- typedef struct {
-     U32 fastMode;
-     U32 tableLog;
- } ZSTD_seqSymbol_header;
-
- typedef struct {
-     U16  nextState;
-     BYTE nbAdditionalBits;
-     BYTE nbBits;
-     U32  baseValue;
- } ZSTD_seqSymbol;
-
- #define SEQSYMBOL_TABLE_SIZE(log)   (1 + (1 << (log)))
-
-#define ZSTD_BUILD_FSE_TABLE_WKSP_SIZE (sizeof(S16) * (MaxSeq + 1) + (1u << MaxFSELog) + sizeof(U64))
-#define ZSTD_BUILD_FSE_TABLE_WKSP_SIZE_U32 ((ZSTD_BUILD_FSE_TABLE_WKSP_SIZE + sizeof(U32) - 1) / sizeof(U32))
-#define ZSTD_HUFFDTABLE_CAPACITY_LOG 12
-
-typedef struct {
-    ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)];    /* Note : Space reserved for FSE Tables */
-    ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)];   /* is also used as temporary workspace while building hufTable during DDict creation */
-    ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)];    /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */
-    HUF_DTable hufTable[HUF_DTABLE_SIZE(ZSTD_HUFFDTABLE_CAPACITY_LOG)];  /* can accommodate HUF_decompress4X */
-    U32 rep[ZSTD_REP_NUM];
-    U32 workspace[ZSTD_BUILD_FSE_TABLE_WKSP_SIZE_U32];
-} ZSTD_entropyDTables_t;
-
-typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
-               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
-               ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
-               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;
-
-typedef enum { zdss_init=0, zdss_loadHeader,
-               zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
-
-typedef enum {
-    ZSTD_use_indefinitely = -1,  /* Use the dictionary indefinitely */
-    ZSTD_dont_use = 0,           /* Do not use the dictionary (if one exists free it) */
-    ZSTD_use_once = 1            /* Use the dictionary once and set to ZSTD_dont_use */
-} ZSTD_dictUses_e;
-
-/* Hashset for storing references to multiple ZSTD_DDict within ZSTD_DCtx */
-typedef struct {
-    const ZSTD_DDict** ddictPtrTable;
-    size_t ddictPtrTableSize;
-    size_t ddictPtrCount;
-} ZSTD_DDictHashSet;
-
-#ifndef ZSTD_DECODER_INTERNAL_BUFFER
-#  define ZSTD_DECODER_INTERNAL_BUFFER  (1 << 16)
-#endif
-
-#define ZSTD_LBMIN 64
-#define ZSTD_LBMAX (128 << 10)
-
-/* extra buffer, compensates when dst is not large enough to store litBuffer */
-#define ZSTD_LITBUFFEREXTRASIZE  BOUNDED(ZSTD_LBMIN, ZSTD_DECODER_INTERNAL_BUFFER, ZSTD_LBMAX)
-
-typedef enum {
-    ZSTD_not_in_dst = 0,  /* Stored entirely within litExtraBuffer */
-    ZSTD_in_dst = 1,           /* Stored entirely within dst (in memory after current output write) */
-    ZSTD_split = 2            /* Split between litExtraBuffer and dst */
-} ZSTD_litLocation_e;
-
-struct ZSTD_DCtx_s
-{
-    const ZSTD_seqSymbol* LLTptr;
-    const ZSTD_seqSymbol* MLTptr;
-    const ZSTD_seqSymbol* OFTptr;
-    const HUF_DTable* HUFptr;
-    ZSTD_entropyDTables_t entropy;
-    U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];   /* space needed when building huffman tables */
-    const void* previousDstEnd;   /* detect continuity */
-    const void* prefixStart;      /* start of current segment */
-    const void* virtualStart;     /* virtual start of previous segment if it was just before current one */
-    const void* dictEnd;          /* end of previous segment */
-    size_t expected;
-    ZSTD_frameHeader fParams;
-    U64 processedCSize;
-    U64 decodedSize;
-    blockType_e bType;            /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */
-    ZSTD_dStage stage;
-    U32 litEntropy;
-    U32 fseEntropy;
-    XXH64_state_t xxhState;
-    size_t headerSize;
-    ZSTD_format_e format;
-    ZSTD_forceIgnoreChecksum_e forceIgnoreChecksum;   /* User specified: if == 1, will ignore checksums in compressed frame. Default == 0 */
-    U32 validateChecksum;         /* if == 1, will validate checksum. Is == 1 if (fParams.checksumFlag == 1) and (forceIgnoreChecksum == 0). */
-    const BYTE* litPtr;
-    ZSTD_customMem customMem;
-    size_t litSize;
-    size_t rleSize;
-    size_t staticSize;
-    int isFrameDecompression;
-#if DYNAMIC_BMI2 != 0
-    int bmi2;                     /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
-#endif
-
-    /* dictionary */
-    ZSTD_DDict* ddictLocal;
-    const ZSTD_DDict* ddict;     /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
-    U32 dictID;
-    int ddictIsCold;             /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */
-    ZSTD_dictUses_e dictUses;
-    ZSTD_DDictHashSet* ddictSet;                    /* Hash set for multiple ddicts */
-    ZSTD_refMultipleDDicts_e refMultipleDDicts;     /* User specified: if == 1, will allow references to multiple DDicts. Default == 0 (disabled) */
-    int disableHufAsm;
-    int maxBlockSizeParam;
-
-    /* streaming */
-    ZSTD_dStreamStage streamStage;
-    char*  inBuff;
-    size_t inBuffSize;
-    size_t inPos;
-    size_t maxWindowSize;
-    char*  outBuff;
-    size_t outBuffSize;
-    size_t outStart;
-    size_t outEnd;
-    size_t lhSize;
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-    void* legacyContext;
-    U32 previousLegacyVersion;
-    U32 legacyVersion;
-#endif
-    U32 hostageByte;
-    int noForwardProgress;
-    ZSTD_bufferMode_e outBufferMode;
-    ZSTD_outBuffer expectedOutBuffer;
-
-    /* workspace */
-    BYTE* litBuffer;
-    const BYTE* litBufferEnd;
-    ZSTD_litLocation_e litBufferLocation;
-    BYTE litExtraBuffer[ZSTD_LITBUFFEREXTRASIZE + WILDCOPY_OVERLENGTH]; /* literal buffer can be split between storage within dst and within this scratch buffer */
-    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
-
-    size_t oversizedDuration;
-
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    void const* dictContentBeginForFuzzing;
-    void const* dictContentEndForFuzzing;
-#endif
-
-    /* Tracing */
-#if ZSTD_TRACE
-    ZSTD_TraceCtx traceCtx;
-#endif
-};  /* typedef'd to ZSTD_DCtx within "zstd.h" */
-
-MEM_STATIC int ZSTD_DCtx_get_bmi2(const struct ZSTD_DCtx_s *dctx) {
-#if DYNAMIC_BMI2 != 0
-	return dctx->bmi2;
-#else
-    (void)dctx;
-	return 0;
-#endif
-}
-
-/*-*******************************************************
- *  Shared internal functions
- *********************************************************/
-
-/*! ZSTD_loadDEntropy() :
- *  dict : must point at beginning of a valid zstd dictionary.
- * @return : size of dictionary header (size of magic number + dict ID + entropy tables) */
-size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
-                   const void* const dict, size_t const dictSize);
-
-/*! ZSTD_checkContinuity() :
- *  check if next `dst` follows previous position, where decompression ended.
- *  If yes, do nothing (continue on current segment).
- *  If not, classify previous segment as "external dictionary", and start a new segment.
- *  This function cannot fail. */
-void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize);
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_DECOMPRESS_INTERNAL_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd/deprecated/zbuff.h b/src/duckdb/third_party/zstd/include/zstd/deprecated/zbuff.h
deleted file mode 100644
index 04c75ef1a..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/deprecated/zbuff.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* ***************************************************************
-*  NOTES/WARNINGS
-******************************************************************/
-/* The streaming API defined here is deprecated.
- * Consider migrating towards ZSTD_compressStream() API in `zstd.h`
- * See 'lib/README.md'.
- *****************************************************************/
-
-#ifndef ZSTD_BUFFERED_H_23987
-#define ZSTD_BUFFERED_H_23987
-
-/* *************************************
-*  Dependencies
-***************************************/
-// DuckDB: just enable everything
-#define ZSTD_STATIC_LINKING_ONLY
-
-#include <stddef.h>      /* size_t */
-#include "zstd.h"        /* ZSTD_CStream, ZSTD_DStream, ZSTDLIB_API */
-
-namespace duckdb_zstd {
-
-/* ***************************************************************
-*  Compiler specifics
-*****************************************************************/
-/* Deprecation warnings */
-/* Should these warnings be a problem,
- * it is generally possible to disable them,
- * typically with -Wno-deprecated-declarations for gcc
- * or _CRT_SECURE_NO_WARNINGS in Visual.
- * Otherwise, it's also possible to define ZBUFF_DISABLE_DEPRECATE_WARNINGS
- */
-#ifdef ZBUFF_DISABLE_DEPRECATE_WARNINGS
-#  define ZBUFF_DEPRECATED(message) ZSTDLIB_API  /* disable deprecation warnings */
-#else
-#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-#    define ZBUFF_DEPRECATED(message) [[deprecated(message)]] ZSTDLIB_API
-#  elif (defined(GNUC) && (GNUC > 4 || (GNUC == 4 && GNUC_MINOR >= 5))) || defined(__clang__)
-#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated(message)))
-#  elif defined(__GNUC__) && (__GNUC__ >= 3)
-#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated))
-#  elif defined(_MSC_VER)
-#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __declspec(deprecated(message))
-#  else
-#    pragma message("WARNING: You need to implement ZBUFF_DEPRECATED for this compiler")
-#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API
-#  endif
-#endif /* ZBUFF_DISABLE_DEPRECATE_WARNINGS */
-
-
-/* *************************************
-*  Streaming functions
-***************************************/
-/* This is the easier "buffered" streaming API,
-*  using an internal buffer to lift all restrictions on user-provided buffers
-*  which can be any size, any place, for both input and output.
-*  ZBUFF and ZSTD are 100% interoperable,
-*  frames created by one can be decoded by the other one */
-
-typedef ZSTD_CStream ZBUFF_CCtx;
-ZBUFF_DEPRECATED("use ZSTD_createCStream") ZBUFF_CCtx* ZBUFF_createCCtx(void);
-ZBUFF_DEPRECATED("use ZSTD_freeCStream")   size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx);
-
-ZBUFF_DEPRECATED("use ZSTD_initCStream")           size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel);
-ZBUFF_DEPRECATED("use ZSTD_initCStream_usingDict") size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
-
-ZBUFF_DEPRECATED("use ZSTD_compressStream") size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr);
-ZBUFF_DEPRECATED("use ZSTD_flushStream")    size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);
-ZBUFF_DEPRECATED("use ZSTD_endStream")      size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);
-
-/*-*************************************************
-*  Streaming compression - howto
-*
-*  A ZBUFF_CCtx object is required to track streaming operation.
-*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
-*  ZBUFF_CCtx objects can be reused multiple times.
-*
-*  Start by initializing ZBUF_CCtx.
-*  Use ZBUFF_compressInit() to start a new compression operation.
-*  Use ZBUFF_compressInitDictionary() for a compression which requires a dictionary.
-*
-*  Use ZBUFF_compressContinue() repetitively to consume input stream.
-*  *srcSizePtr and *dstCapacityPtr can be any size.
-*  The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data.
-*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst .
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush().
-*  The nb of bytes written into `dst` will be reported into *dstCapacityPtr.
-*  Note that the function cannot output more than *dstCapacityPtr,
-*  therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  ZBUFF_compressEnd() instructs to finish a frame.
-*  It will perform a flush and write frame epilogue.
-*  The epilogue is required for decoders to consider a frame completed.
-*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
-*  In which case, call again ZBUFF_compressFlush() to complete the flush.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : _recommended buffer_ sizes (not compulsory) : ZBUFF_recommendedCInSize() / ZBUFF_recommendedCOutSize()
-*  input : ZBUFF_recommendedCInSize==128 KB block size is the internal unit, use this value to reduce intermediate stages (better latency)
-*  output : ZBUFF_recommendedCOutSize==ZSTD_compressBound(128 KB) + 3 + 3 : ensures it's always possible to write/flush/end a full block. Skip some buffering.
-*  By using both, it ensures that input will be entirely consumed, and output will always contain the result, reducing intermediate buffering.
-* **************************************************/
-
-
-typedef ZSTD_DStream ZBUFF_DCtx;
-ZBUFF_DEPRECATED("use ZSTD_createDStream") ZBUFF_DCtx* ZBUFF_createDCtx(void);
-ZBUFF_DEPRECATED("use ZSTD_freeDStream")   size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx);
-
-ZBUFF_DEPRECATED("use ZSTD_initDStream")           size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx);
-ZBUFF_DEPRECATED("use ZSTD_initDStream_usingDict") size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize);
-
-ZBUFF_DEPRECATED("use ZSTD_decompressStream") size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx,
-                                            void* dst, size_t* dstCapacityPtr,
-                                      const void* src, size_t* srcSizePtr);
-
-/*-***************************************************************************
-*  Streaming decompression howto
-*
-*  A ZBUFF_DCtx object is required to track streaming operations.
-*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
-*  Use ZBUFF_decompressInit() to start a new decompression operation,
-*   or ZBUFF_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFF_DCtx objects can be re-init multiple times.
-*
-*  Use ZBUFF_decompressContinue() repetitively to consume your input.
-*  *srcSizePtr and *dstCapacityPtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
-*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
-*  @return : 0 when a frame is completely decoded and fully flushed,
-*            1 when there is still some data left within internal buffer to flush,
-*            >1 when more data is expected, with value being a suggested next input size (it's just a hint, which helps latency),
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize()
-*  output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFF_recommendedDInSize == 128KB + 3;
-*           just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-ZBUFF_DEPRECATED("use ZSTD_isError")      unsigned ZBUFF_isError(size_t errorCode);
-ZBUFF_DEPRECATED("use ZSTD_getErrorName") const char* ZBUFF_getErrorName(size_t errorCode);
-
-/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
-*   These sizes are just hints, they tend to offer better latency */
-ZBUFF_DEPRECATED("use ZSTD_CStreamInSize")  size_t ZBUFF_recommendedCInSize(void);
-ZBUFF_DEPRECATED("use ZSTD_CStreamOutSize") size_t ZBUFF_recommendedCOutSize(void);
-ZBUFF_DEPRECATED("use ZSTD_DStreamInSize")  size_t ZBUFF_recommendedDInSize(void);
-ZBUFF_DEPRECATED("use ZSTD_DStreamOutSize") size_t ZBUFF_recommendedDOutSize(void);
-
-} // namespace duckdb_zstd
-
-#endif  /* ZSTD_BUFFERED_H_23987 */
-
-#ifdef ZBUFF_STATIC_LINKING_ONLY
-# ifndef ZBUFF_STATIC_H_30298098432
-#  define ZBUFF_STATIC_H_30298098432
-
-/* ====================================================================================
- * The definitions in this section are considered experimental.
- * They should never be used in association with a dynamic library, as they may change in the future.
- * They are provided for advanced usages.
- * Use them only in association with static linking.
- * ==================================================================================== */
-
-
-/*--- Dependency ---*/
-// DuckDB: comment out otherwise amalgamation won't be happy
-// #  define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters, ZSTD_customMem */
-// #include "zstd.h"
-
-namespace duckdb_zstd {
-
-/*--- Custom memory allocator ---*/
-/*! ZBUFF_createCCtx_advanced() :
- *  Create a ZBUFF compression context using external alloc and free functions */
-ZBUFF_DEPRECATED("use ZSTD_createCStream_advanced") ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem);
-
-/*! ZBUFF_createDCtx_advanced() :
- *  Create a ZBUFF decompression context using external alloc and free functions */
-ZBUFF_DEPRECATED("use ZSTD_createDStream_advanced") ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem);
-
-
-/*--- Advanced Streaming Initialization ---*/
-ZBUFF_DEPRECATED("use ZSTD_initDStream_usingDict") size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
-                                               const void* dict, size_t dictSize,
-                                               ZSTD_parameters params, unsigned long long pledgedSrcSize);
-
-} // namespace duckdb_zstd
-
-# endif    /* ZBUFF_STATIC_H_30298098432 */
-#endif    /* ZBUFF_STATIC_LINKING_ONLY */
-
diff --git a/src/duckdb/third_party/zstd/include/zstd/dict/cover.h b/src/duckdb/third_party/zstd/include/zstd/dict/cover.h
deleted file mode 100644
index dd458ce58..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/dict/cover.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZDICT_STATIC_LINKING_ONLY
-#  define ZDICT_STATIC_LINKING_ONLY
-#endif
-
-#include "zstd/common/threading.h" /* ZSTD_pthread_mutex_t */
-#include "zstd/common/mem.h"   /* U32, BYTE */
-#include "zdict.h"
-
-namespace duckdb_zstd {
-
-/**
- * COVER_best_t is used for two purposes:
- * 1. Synchronizing threads.
- * 2. Saving the best parameters and dictionary.
- *
- * All of the methods except COVER_best_init() are thread safe if zstd is
- * compiled with multithreaded support.
- */
-typedef struct COVER_best_s {
-  ZSTD_pthread_mutex_t mutex;
-  ZSTD_pthread_cond_t cond;
-  size_t liveJobs;
-  void *dict;
-  size_t dictSize;
-  ZDICT_cover_params_t parameters;
-  size_t compressedSize;
-} COVER_best_t;
-
-/**
- * A segment is a range in the source as well as the score of the segment.
- */
-typedef struct {
-  U32 begin;
-  U32 end;
-  U32 score;
-} COVER_segment_t;
-
-/**
- *Number of epochs and size of each epoch.
- */
-typedef struct {
-  U32 num;
-  U32 size;
-} COVER_epoch_info_t;
-
-/**
- * Struct used for the dictionary selection function.
- */
-typedef struct COVER_dictSelection {
-  BYTE* dictContent;
-  size_t dictSize;
-  size_t totalCompressedSize;
-} COVER_dictSelection_t;
-
-/**
- * Computes the number of epochs and the size of each epoch.
- * We will make sure that each epoch gets at least 10 * k bytes.
- *
- * The COVER algorithms divide the data up into epochs of equal size and
- * select one segment from each epoch.
- *
- * @param maxDictSize The maximum allowed dictionary size.
- * @param nbDmers     The number of dmers we are training on.
- * @param k           The parameter k (segment size).
- * @param passes      The target number of passes over the dmer corpus.
- *                    More passes means a better dictionary.
- */
-COVER_epoch_info_t COVER_computeEpochs(U32 maxDictSize, U32 nbDmers,
-                                       U32 k, U32 passes);
-
-/**
- * Warns the user when their corpus is too small.
- */
-void COVER_warnOnSmallCorpus(size_t maxDictSize, size_t nbDmers, int displayLevel);
-
-/**
- *  Checks total compressed size of a dictionary
- */
-size_t COVER_checkTotalCompressedSize(const ZDICT_cover_params_t parameters,
-                                      const size_t *samplesSizes, const BYTE *samples,
-                                      size_t *offsets,
-                                      size_t nbTrainSamples, size_t nbSamples,
-                                      BYTE *const dict, size_t dictBufferCapacity);
-
-/**
- * Returns the sum of the sample sizes.
- */
-size_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) ;
-
-/**
- * Initialize the `COVER_best_t`.
- */
-void COVER_best_init(COVER_best_t *best);
-
-/**
- * Wait until liveJobs == 0.
- */
-void COVER_best_wait(COVER_best_t *best);
-
-/**
- * Call COVER_best_wait() and then destroy the COVER_best_t.
- */
-void COVER_best_destroy(COVER_best_t *best);
-
-/**
- * Called when a thread is about to be launched.
- * Increments liveJobs.
- */
-void COVER_best_start(COVER_best_t *best);
-
-/**
- * Called when a thread finishes executing, both on error or success.
- * Decrements liveJobs and signals any waiting threads if liveJobs == 0.
- * If this dictionary is the best so far save it and its parameters.
- */
-void COVER_best_finish(COVER_best_t *best, ZDICT_cover_params_t parameters,
-                       COVER_dictSelection_t selection);
-/**
- * Error function for COVER_selectDict function. Checks if the return
- * value is an error.
- */
-unsigned COVER_dictSelectionIsError(COVER_dictSelection_t selection);
-
- /**
-  * Error function for COVER_selectDict function. Returns a struct where
-  * return.totalCompressedSize is a ZSTD error.
-  */
-COVER_dictSelection_t COVER_dictSelectionError(size_t error);
-
-/**
- * Always call after selectDict is called to free up used memory from
- * newly created dictionary.
- */
-void COVER_dictSelectionFree(COVER_dictSelection_t selection);
-
-/**
- * Called to finalize the dictionary and select one based on whether or not
- * the shrink-dict flag was enabled. If enabled the dictionary used is the
- * smallest dictionary within a specified regression of the compressed size
- * from the largest dictionary.
- */
- COVER_dictSelection_t COVER_selectDict(BYTE* customDictContent, size_t dictBufferCapacity,
-                       size_t dictContentSize, const BYTE* samplesBuffer, const size_t* samplesSizes, unsigned nbFinalizeSamples,
-                       size_t nbCheckSamples, size_t nbSamples, ZDICT_cover_params_t params, size_t* offsets, size_t totalCompressedSize);
-
-} // namespace duckdb_zstd
diff --git a/src/duckdb/third_party/zstd/include/zstd/dict/divsufsort.h b/src/duckdb/third_party/zstd/include/zstd/dict/divsufsort.h
deleted file mode 100644
index 4f7cbdee8..000000000
--- a/src/duckdb/third_party/zstd/include/zstd/dict/divsufsort.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * divsufsort.h for libdivsufsort-lite
- * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef _DIVSUFSORT_H
-#define _DIVSUFSORT_H 1
-
-namespace duckdb_zstd {
-
-/*- Prototypes -*/
-
-/**
- * Constructs the suffix array of a given string.
- * @param T [0..n-1] The input string.
- * @param SA [0..n-1] The output array of suffixes.
- * @param n The length of the given string.
- * @param openMP enables OpenMP optimization.
- * @return 0 if no error occurred, -1 or -2 otherwise.
- */
-int
-divsufsort(const unsigned char *T, int *SA, int n, int openMP);
-
-/**
- * Constructs the burrows-wheeler transformed string of a given string.
- * @param T [0..n-1] The input string.
- * @param U [0..n-1] The output string. (can be T)
- * @param A [0..n-1] The temporary array. (can be NULL)
- * @param n The length of the given string.
- * @param num_indexes The length of secondary indexes array. (can be NULL)
- * @param indexes The secondary indexes array. (can be NULL)
- * @param openMP enables OpenMP optimization.
- * @return The primary index if no error occurred, -1 or -2 otherwise.
- */
-int
-divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP);
-
-
-} // namespace duckdb_zstd
-
-#endif /* _DIVSUFSORT_H */
diff --git a/src/duckdb/third_party/zstd/include/zstd_errors.h b/src/duckdb/third_party/zstd/include/zstd_errors.h
deleted file mode 100644
index 401f67004..000000000
--- a/src/duckdb/third_party/zstd/include/zstd_errors.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef ZSTD_ERRORS_H_398273423
-#define ZSTD_ERRORS_H_398273423
-
-/*===== dependency =====*/
-#include <stddef.h>   /* size_t */
-
-namespace duckdb_zstd {
-
-/* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
-#ifndef ZSTDERRORLIB_VISIBLE
-   /* Backwards compatibility with old macro name */
-#  ifdef ZSTDERRORLIB_VISIBILITY
-#    define ZSTDERRORLIB_VISIBLE ZSTDERRORLIB_VISIBILITY
-#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
-#    define ZSTDERRORLIB_VISIBLE __attribute__ ((visibility ("default")))
-#  else
-#    define ZSTDERRORLIB_VISIBLE
-#  endif
-#endif
-
-#ifndef ZSTDERRORLIB_HIDDEN
-#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
-#    define ZSTDERRORLIB_HIDDEN __attribute__ ((visibility ("hidden")))
-#  else
-#    define ZSTDERRORLIB_HIDDEN
-#  endif
-#endif
-
-#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBLE
-#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
-#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBLE
-#endif
-
-/*-*********************************************
- *  Error codes list
- *-*********************************************
- *  Error codes _values_ are pinned down since v1.3.1 only.
- *  Therefore, don't rely on values if you may link to any version < v1.3.1.
- *
- *  Only values < 100 are considered stable.
- *
- *  note 1 : this API shall be used with static linking only.
- *           dynamic linking is not yet officially supported.
- *  note 2 : Prefer relying on the enum than on its value whenever possible
- *           This is the only supported way to use the error list < v1.3.1
- *  note 3 : ZSTD_isError() is always correct, whatever the library version.
- **********************************************/
-typedef enum {
-  ZSTD_error_no_error = 0,
-  ZSTD_error_GENERIC  = 1,
-  ZSTD_error_prefix_unknown                = 10,
-  ZSTD_error_version_unsupported           = 12,
-  ZSTD_error_frameParameter_unsupported    = 14,
-  ZSTD_error_frameParameter_windowTooLarge = 16,
-  ZSTD_error_corruption_detected = 20,
-  ZSTD_error_checksum_wrong      = 22,
-  ZSTD_error_literals_headerWrong = 24,
-  ZSTD_error_dictionary_corrupted      = 30,
-  ZSTD_error_dictionary_wrong          = 32,
-  ZSTD_error_dictionaryCreation_failed = 34,
-  ZSTD_error_parameter_unsupported   = 40,
-  ZSTD_error_parameter_combination_unsupported = 41,
-  ZSTD_error_parameter_outOfBound    = 42,
-  ZSTD_error_tableLog_tooLarge       = 44,
-  ZSTD_error_maxSymbolValue_tooLarge = 46,
-  ZSTD_error_maxSymbolValue_tooSmall = 48,
-  ZSTD_error_stabilityCondition_notRespected = 50,
-  ZSTD_error_stage_wrong       = 60,
-  ZSTD_error_init_missing      = 62,
-  ZSTD_error_memory_allocation = 64,
-  ZSTD_error_workSpace_tooSmall= 66,
-  ZSTD_error_dstSize_tooSmall = 70,
-  ZSTD_error_srcSize_wrong    = 72,
-  ZSTD_error_dstBuffer_null   = 74,
-  ZSTD_error_noForwardProgress_destFull = 80,
-  ZSTD_error_noForwardProgress_inputEmpty = 82,
-  /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
-  ZSTD_error_frameIndex_tooLarge = 100,
-  ZSTD_error_seekableIO          = 102,
-  ZSTD_error_dstBuffer_wrong     = 104,
-  ZSTD_error_srcBuffer_wrong     = 105,
-  ZSTD_error_sequenceProducer_failed = 106,
-  ZSTD_error_externalSequences_invalid = 107,
-  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
-} ZSTD_ErrorCode;
-
-/*! ZSTD_getErrorCode() :
-    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
-    which can be used to compare with enum list published above */
-ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
-ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
-
-
-} // namespace duckdb_zstd
-
-#endif /* ZSTD_ERRORS_H_398273423 */
diff --git a/src/duckdb/ub_extension_core_functions_aggregate_algebraic.cpp b/src/duckdb/ub_extension_core_functions_aggregate_algebraic.cpp
deleted file mode 100644
index ac1532ac1..000000000
--- a/src/duckdb/ub_extension_core_functions_aggregate_algebraic.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "extension/core_functions/aggregate/algebraic/corr.cpp"
-
-#include "extension/core_functions/aggregate/algebraic/stddev.cpp"
-
-#include "extension/core_functions/aggregate/algebraic/avg.cpp"
-
-#include "extension/core_functions/aggregate/algebraic/covar.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp b/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp
deleted file mode 100644
index f8c552db1..000000000
--- a/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "extension/core_functions/aggregate/distributive/skew.cpp"
-
-#include "extension/core_functions/aggregate/distributive/bool.cpp"
-
-#include "extension/core_functions/aggregate/distributive/bitstring_agg.cpp"
-
-#include "extension/core_functions/aggregate/distributive/bitagg.cpp"
-
-#include "extension/core_functions/aggregate/distributive/kurtosis.cpp"
-
-#include "extension/core_functions/aggregate/distributive/sum.cpp"
-
-#include "extension/core_functions/aggregate/distributive/arg_min_max.cpp"
-
-#include "extension/core_functions/aggregate/distributive/product.cpp"
-
-#include "extension/core_functions/aggregate/distributive/string_agg.cpp"
-
-#include "extension/core_functions/aggregate/distributive/approx_count.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp b/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp
deleted file mode 100644
index 2e18fa37e..000000000
--- a/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "extension/core_functions/aggregate/holistic/mad.cpp"
-
-#include "extension/core_functions/aggregate/holistic/quantile.cpp"
-
-#include "extension/core_functions/aggregate/holistic/reservoir_quantile.cpp"
-
-#include "extension/core_functions/aggregate/holistic/approximate_quantile.cpp"
-
-#include "extension/core_functions/aggregate/holistic/approx_top_k.cpp"
-
-#include "extension/core_functions/aggregate/holistic/mode.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp b/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp
deleted file mode 100644
index 8f3f5452f..000000000
--- a/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "extension/core_functions/aggregate/nested/binned_histogram.cpp"
-
-#include "extension/core_functions/aggregate/nested/histogram.cpp"
-
-#include "extension/core_functions/aggregate/nested/list.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp b/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp
deleted file mode 100644
index 3b2713788..000000000
--- a/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "extension/core_functions/aggregate/regression/regr_avg.cpp"
-
-#include "extension/core_functions/aggregate/regression/regr_intercept.cpp"
-
-#include "extension/core_functions/aggregate/regression/regr_sxx_syy.cpp"
-
-#include "extension/core_functions/aggregate/regression/regr_count.cpp"
-
-#include "extension/core_functions/aggregate/regression/regr_slope.cpp"
-
-#include "extension/core_functions/aggregate/regression/regr_r2.cpp"
-
-#include "extension/core_functions/aggregate/regression/regr_sxy.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_array.cpp b/src/duckdb/ub_extension_core_functions_scalar_array.cpp
deleted file mode 100644
index 9b9a475b4..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_array.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "extension/core_functions/scalar/array/array_value.cpp"
-
-#include "extension/core_functions/scalar/array/array_functions.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_bit.cpp b/src/duckdb/ub_extension_core_functions_scalar_bit.cpp
deleted file mode 100644
index 0e48db861..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_bit.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "extension/core_functions/scalar/bit/bitstring.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_blob.cpp b/src/duckdb/ub_extension_core_functions_scalar_blob.cpp
deleted file mode 100644
index 1eda3bad1..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_blob.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "extension/core_functions/scalar/blob/base64.cpp"
-
-#include "extension/core_functions/scalar/blob/encode.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_date.cpp b/src/duckdb/ub_extension_core_functions_scalar_date.cpp
deleted file mode 100644
index 11b7e8756..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_date.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "extension/core_functions/scalar/date/make_date.cpp"
-
-#include "extension/core_functions/scalar/date/date_trunc.cpp"
-
-#include "extension/core_functions/scalar/date/date_part.cpp"
-
-#include "extension/core_functions/scalar/date/date_diff.cpp"
-
-#include "extension/core_functions/scalar/date/age.cpp"
-
-#include "extension/core_functions/scalar/date/time_bucket.cpp"
-
-#include "extension/core_functions/scalar/date/date_sub.cpp"
-
-#include "extension/core_functions/scalar/date/current.cpp"
-
-#include "extension/core_functions/scalar/date/to_interval.cpp"
-
-#include "extension/core_functions/scalar/date/epoch.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_debug.cpp b/src/duckdb/ub_extension_core_functions_scalar_debug.cpp
deleted file mode 100644
index f1c3fa82e..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_debug.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "extension/core_functions/scalar/debug/vector_type.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_enum.cpp b/src/duckdb/ub_extension_core_functions_scalar_enum.cpp
deleted file mode 100644
index 74e9bf3f7..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_enum.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "extension/core_functions/scalar/enum/enum_functions.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_generic.cpp b/src/duckdb/ub_extension_core_functions_scalar_generic.cpp
deleted file mode 100644
index d24580892..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_generic.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "extension/core_functions/scalar/generic/alias.cpp"
-
-#include "extension/core_functions/scalar/generic/binning.cpp"
-
-#include "extension/core_functions/scalar/generic/can_implicitly_cast.cpp"
-
-#include "extension/core_functions/scalar/generic/current_setting.cpp"
-
-#include "extension/core_functions/scalar/generic/hash.cpp"
-
-#include "extension/core_functions/scalar/generic/least.cpp"
-
-#include "extension/core_functions/scalar/generic/stats.cpp"
-
-#include "extension/core_functions/scalar/generic/typeof.cpp"
-
-#include "extension/core_functions/scalar/generic/system_functions.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_list.cpp b/src/duckdb/ub_extension_core_functions_scalar_list.cpp
deleted file mode 100644
index 87d225f95..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_list.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "extension/core_functions/scalar/list/flatten.cpp"
-
-#include "extension/core_functions/scalar/list/list_distance.cpp"
-
-#include "extension/core_functions/scalar/list/array_slice.cpp"
-
-#include "extension/core_functions/scalar/list/list_transform.cpp"
-
-#include "extension/core_functions/scalar/list/list_filter.cpp"
-
-#include "extension/core_functions/scalar/list/list_reduce.cpp"
-
-#include "extension/core_functions/scalar/list/list_sort.cpp"
-
-#include "extension/core_functions/scalar/list/list_aggregates.cpp"
-
-#include "extension/core_functions/scalar/list/list_has_any_or_all.cpp"
-
-#include "extension/core_functions/scalar/list/range.cpp"
-
-#include "extension/core_functions/scalar/list/list_value.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_map.cpp b/src/duckdb/ub_extension_core_functions_scalar_map.cpp
deleted file mode 100644
index b191443c0..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_map.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "extension/core_functions/scalar/map/map_keys_values.cpp"
-
-#include "extension/core_functions/scalar/map/cardinality.cpp"
-
-#include "extension/core_functions/scalar/map/map_concat.cpp"
-
-#include "extension/core_functions/scalar/map/map_extract.cpp"
-
-#include "extension/core_functions/scalar/map/map_from_entries.cpp"
-
-#include "extension/core_functions/scalar/map/map.cpp"
-
-#include "extension/core_functions/scalar/map/map_entries.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_math.cpp b/src/duckdb/ub_extension_core_functions_scalar_math.cpp
deleted file mode 100644
index 27320ea9f..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_math.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "extension/core_functions/scalar/math/numeric.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_operators.cpp b/src/duckdb/ub_extension_core_functions_scalar_operators.cpp
deleted file mode 100644
index 47383d4eb..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_operators.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "extension/core_functions/scalar/operators/bitwise.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_random.cpp b/src/duckdb/ub_extension_core_functions_scalar_random.cpp
deleted file mode 100644
index f71b7b4cd..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_random.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "extension/core_functions/scalar/random/random.cpp"
-
-#include "extension/core_functions/scalar/random/setseed.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_string.cpp b/src/duckdb/ub_extension_core_functions_scalar_string.cpp
deleted file mode 100644
index b57063a4b..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_string.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "extension/core_functions/scalar/string/hex.cpp"
-
-#include "extension/core_functions/scalar/string/unicode.cpp"
-
-#include "extension/core_functions/scalar/string/translate.cpp"
-
-#include "extension/core_functions/scalar/string/left_right.cpp"
-
-#include "extension/core_functions/scalar/string/hamming.cpp"
-
-#include "extension/core_functions/scalar/string/damerau_levenshtein.cpp"
-
-#include "extension/core_functions/scalar/string/ascii.cpp"
-
-#include "extension/core_functions/scalar/string/starts_with.cpp"
-
-#include "extension/core_functions/scalar/string/repeat.cpp"
-
-#include "extension/core_functions/scalar/string/chr.cpp"
-
-#include "extension/core_functions/scalar/string/levenshtein.cpp"
-
-#include "extension/core_functions/scalar/string/pad.cpp"
-
-#include "extension/core_functions/scalar/string/bar.cpp"
-
-#include "extension/core_functions/scalar/string/replace.cpp"
-
-#include "extension/core_functions/scalar/string/to_base.cpp"
-
-#include "extension/core_functions/scalar/string/printf.cpp"
-
-#include "extension/core_functions/scalar/string/format_bytes.cpp"
-
-#include "extension/core_functions/scalar/string/instr.cpp"
-
-#include "extension/core_functions/scalar/string/url_encode.cpp"
-
-#include "extension/core_functions/scalar/string/jaccard.cpp"
-
-#include "extension/core_functions/scalar/string/reverse.cpp"
-
-#include "extension/core_functions/scalar/string/trim.cpp"
-
-#include "extension/core_functions/scalar/string/parse_path.cpp"
-
-#include "extension/core_functions/scalar/string/jaro_winkler.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_struct.cpp b/src/duckdb/ub_extension_core_functions_scalar_struct.cpp
deleted file mode 100644
index 8d52b2f9c..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_struct.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "extension/core_functions/scalar/struct/struct_insert.cpp"
-
diff --git a/src/duckdb/ub_extension_core_functions_scalar_union.cpp b/src/duckdb/ub_extension_core_functions_scalar_union.cpp
deleted file mode 100644
index c23d6ebff..000000000
--- a/src/duckdb/ub_extension_core_functions_scalar_union.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "extension/core_functions/scalar/union/union_value.cpp"
-
-#include "extension/core_functions/scalar/union/union_extract.cpp"
-
-#include "extension/core_functions/scalar/union/union_tag.cpp"
-
diff --git a/src/duckdb/ub_src_catalog.cpp b/src/duckdb/ub_src_catalog.cpp
deleted file mode 100644
index 5578f46ab..000000000
--- a/src/duckdb/ub_src_catalog.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "src/catalog/catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry_retriever.cpp"
-
-#include "src/catalog/catalog.cpp"
-
-#include "src/catalog/catalog_search_path.cpp"
-
-#include "src/catalog/catalog_set.cpp"
-
-#include "src/catalog/catalog_transaction.cpp"
-
-#include "src/catalog/duck_catalog.cpp"
-
-#include "src/catalog/dependency_manager.cpp"
-
-#include "src/catalog/dependency_list.cpp"
-
-#include "src/catalog/dependency_catalog_set.cpp"
-
-#include "src/catalog/similar_catalog_entry.cpp"
-
diff --git a/src/duckdb/ub_src_catalog_catalog_entry.cpp b/src/duckdb/ub_src_catalog_catalog_entry.cpp
deleted file mode 100644
index 2e11f6d71..000000000
--- a/src/duckdb/ub_src_catalog_catalog_entry.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "src/catalog/catalog_entry/copy_function_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/duck_index_entry.cpp"
-
-#include "src/catalog/catalog_entry/duck_schema_entry.cpp"
-
-#include "src/catalog/catalog_entry/duck_table_entry.cpp"
-
-#include "src/catalog/catalog_entry/type_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/index_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/macro_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/pragma_function_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/schema_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/sequence_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/table_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/column_dependency_manager.cpp"
-
-#include "src/catalog/catalog_entry/scalar_function_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/table_function_catalog_entry.cpp"
-
-#include "src/catalog/catalog_entry/view_catalog_entry.cpp"
-
diff --git a/src/duckdb/ub_src_catalog_catalog_entry_dependency.cpp b/src/duckdb/ub_src_catalog_catalog_entry_dependency.cpp
deleted file mode 100644
index 9c479b5f6..000000000
--- a/src/duckdb/ub_src_catalog_catalog_entry_dependency.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/catalog/catalog_entry/dependency/dependency_entry.cpp"
-
-#include "src/catalog/catalog_entry/dependency/dependency_subject_entry.cpp"
-
-#include "src/catalog/catalog_entry/dependency/dependency_dependent_entry.cpp"
-
diff --git a/src/duckdb/ub_src_catalog_default.cpp b/src/duckdb/ub_src_catalog_default.cpp
deleted file mode 100644
index 7aeb3e3f0..000000000
--- a/src/duckdb/ub_src_catalog_default.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "src/catalog/default/default_functions.cpp"
-
-#include "src/catalog/default/default_generator.cpp"
-
-#include "src/catalog/default/default_schemas.cpp"
-
-#include "src/catalog/default/default_table_functions.cpp"
-
-#include "src/catalog/default/default_types.cpp"
-
-#include "src/catalog/default/default_views.cpp"
-
diff --git a/src/duckdb/ub_src_common.cpp b/src/duckdb/ub_src_common.cpp
deleted file mode 100644
index 2632a1276..000000000
--- a/src/duckdb/ub_src_common.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "src/common/allocator.cpp"
-
-#include "src/common/assert.cpp"
-
-#include "src/common/bind_helpers.cpp"
-
-#include "src/common/box_renderer.cpp"
-
-#include "src/common/cgroups.cpp"
-
-#include "src/common/compressed_file_system.cpp"
-
-#include "src/common/constants.cpp"
-
-#include "src/common/checksum.cpp"
-
-#include "src/common/encryption_state.cpp"
-
-#include "src/common/exception.cpp"
-
-#include "src/common/exception_format_value.cpp"
-
-#include "src/common/extra_type_info.cpp"
-
-#include "src/common/file_buffer.cpp"
-
-#include "src/common/file_system.cpp"
-
-#include "src/common/filename_pattern.cpp"
-
-#include "src/common/fsst.cpp"
-
-#include "src/common/gzip_file_system.cpp"
-
-#include "src/common/hive_partitioning.cpp"
-
-#include "src/common/http_util.cpp"
-
-#include "src/common/pipe_file_system.cpp"
-
-#include "src/common/local_file_system.cpp"
-
-#include "src/common/multi_file_list.cpp"
-
-#include "src/common/multi_file_reader.cpp"
-
-#include "src/common/error_data.cpp"
-
-#include "src/common/opener_file_system.cpp"
-
-#include "src/common/printer.cpp"
-
-#include "src/common/radix_partitioning.cpp"
-
-#include "src/common/re2_regex.cpp"
-
-#include "src/common/random_engine.cpp"
-
-#include "src/common/stacktrace.cpp"
-
-#include "src/common/string_util.cpp"
-
-#include "src/common/enum_util.cpp"
-
-#include "src/common/render_tree.cpp"
-
-#include "src/common/tree_renderer.cpp"
-
-#include "src/common/types.cpp"
-
-#include "src/common/virtual_file_system.cpp"
-
-#include "src/common/windows_util.cpp"
-
diff --git a/src/duckdb/ub_src_common_adbc.cpp b/src/duckdb/ub_src_common_adbc.cpp
deleted file mode 100644
index 43aee83e9..000000000
--- a/src/duckdb/ub_src_common_adbc.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/common/adbc/adbc.cpp"
-
-#include "src/common/adbc/driver_manager.cpp"
-
diff --git a/src/duckdb/ub_src_common_adbc_nanoarrow.cpp b/src/duckdb/ub_src_common_adbc_nanoarrow.cpp
deleted file mode 100644
index 3dda12b0a..000000000
--- a/src/duckdb/ub_src_common_adbc_nanoarrow.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/common/adbc/nanoarrow/metadata.cpp"
-
-#include "src/common/adbc/nanoarrow/schema.cpp"
-
-#include "src/common/adbc/nanoarrow/allocator.cpp"
-
-#include "src/common/adbc/nanoarrow/single_batch_array_stream.cpp"
-
diff --git a/src/duckdb/ub_src_common_arrow.cpp b/src/duckdb/ub_src_common_arrow.cpp
deleted file mode 100644
index 9c8e239da..000000000
--- a/src/duckdb/ub_src_common_arrow.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "src/common/arrow/arrow_appender.cpp"
-
-#include "src/common/arrow/arrow_converter.cpp"
-
-#include "src/common/arrow/arrow_util.cpp"
-
-#include "src/common/arrow/arrow_merge_event.cpp"
-
-#include "src/common/arrow/arrow_query_result.cpp"
-
-#include "src/common/arrow/arrow_wrapper.cpp"
-
-#include "src/common/arrow/physical_arrow_collector.cpp"
-
-#include "src/common/arrow/physical_arrow_batch_collector.cpp"
-
-#include "src/common/arrow/schema_metadata.cpp"
-
diff --git a/src/duckdb/ub_src_common_arrow_appender.cpp b/src/duckdb/ub_src_common_arrow_appender.cpp
deleted file mode 100644
index 4055bc6bd..000000000
--- a/src/duckdb/ub_src_common_arrow_appender.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/common/arrow/appender/bool_data.cpp"
-
-#include "src/common/arrow/appender/struct_data.cpp"
-
-#include "src/common/arrow/appender/union_data.cpp"
-
-#include "src/common/arrow/appender/fixed_size_list_data.cpp"
-
diff --git a/src/duckdb/ub_src_common_crypto.cpp b/src/duckdb/ub_src_common_crypto.cpp
deleted file mode 100644
index 37f51b193..000000000
--- a/src/duckdb/ub_src_common_crypto.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/common/crypto/md5.cpp"
-
diff --git a/src/duckdb/ub_src_common_enums.cpp b/src/duckdb/ub_src_common_enums.cpp
deleted file mode 100644
index ab6fac005..000000000
--- a/src/duckdb/ub_src_common_enums.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "src/common/enums/catalog_type.cpp"
-
-#include "src/common/enums/compression_type.cpp"
-
-#include "src/common/enums/date_part_specifier.cpp"
-
-#include "src/common/enums/expression_type.cpp"
-
-#include "src/common/enums/file_compression_type.cpp"
-
-#include "src/common/enums/join_type.cpp"
-
-#include "src/common/enums/logical_operator_type.cpp"
-
-#include "src/common/enums/metric_type.cpp"
-
-#include "src/common/enums/optimizer_type.cpp"
-
-#include "src/common/enums/physical_operator_type.cpp"
-
-#include "src/common/enums/statement_type.cpp"
-
-#include "src/common/enums/relation_type.cpp"
-
diff --git a/src/duckdb/ub_src_common_exception.cpp b/src/duckdb/ub_src_common_exception.cpp
deleted file mode 100644
index 31a12adb1..000000000
--- a/src/duckdb/ub_src_common_exception.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/common/exception/binder_exception.cpp"
-
-#include "src/common/exception/catalog_exception.cpp"
-
-#include "src/common/exception/conversion_exception.cpp"
-
-#include "src/common/exception/parser_exception.cpp"
-
diff --git a/src/duckdb/ub_src_common_operator.cpp b/src/duckdb/ub_src_common_operator.cpp
deleted file mode 100644
index 672390f04..000000000
--- a/src/duckdb/ub_src_common_operator.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/common/operator/cast_operators.cpp"
-
-#include "src/common/operator/convert_to_string.cpp"
-
-#include "src/common/operator/string_cast.cpp"
-
diff --git a/src/duckdb/ub_src_common_progress_bar.cpp b/src/duckdb/ub_src_common_progress_bar.cpp
deleted file mode 100644
index e3e21119d..000000000
--- a/src/duckdb/ub_src_common_progress_bar.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/common/progress_bar/progress_bar.cpp"
-
-#include "src/common/progress_bar/terminal_progress_bar_display.cpp"
-
diff --git a/src/duckdb/ub_src_common_row_operations.cpp b/src/duckdb/ub_src_common_row_operations.cpp
deleted file mode 100644
index f1ac77f8e..000000000
--- a/src/duckdb/ub_src_common_row_operations.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "src/common/row_operations/row_aggregate.cpp"
-
-#include "src/common/row_operations/row_scatter.cpp"
-
-#include "src/common/row_operations/row_gather.cpp"
-
-#include "src/common/row_operations/row_matcher.cpp"
-
-#include "src/common/row_operations/row_external.cpp"
-
-#include "src/common/row_operations/row_radix_scatter.cpp"
-
-#include "src/common/row_operations/row_heap_scatter.cpp"
-
-#include "src/common/row_operations/row_heap_gather.cpp"
-
diff --git a/src/duckdb/ub_src_common_serializer.cpp b/src/duckdb/ub_src_common_serializer.cpp
deleted file mode 100644
index ab0d14731..000000000
--- a/src/duckdb/ub_src_common_serializer.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "src/common/serializer/binary_serializer.cpp"
-
-#include "src/common/serializer/binary_deserializer.cpp"
-
-#include "src/common/serializer/buffered_file_reader.cpp"
-
-#include "src/common/serializer/buffered_file_writer.cpp"
-
-#include "src/common/serializer/memory_stream.cpp"
-
-#include "src/common/serializer/serializer.cpp"
-
diff --git a/src/duckdb/ub_src_common_sort.cpp b/src/duckdb/ub_src_common_sort.cpp
deleted file mode 100644
index e472e71ff..000000000
--- a/src/duckdb/ub_src_common_sort.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "src/common/sort/comparators.cpp"
-
-#include "src/common/sort/merge_sorter.cpp"
-
-#include "src/common/sort/partition_state.cpp"
-
-#include "src/common/sort/radix_sort.cpp"
-
-#include "src/common/sort/sort_state.cpp"
-
-#include "src/common/sort/sorted_block.cpp"
-
diff --git a/src/duckdb/ub_src_common_tree_renderer.cpp b/src/duckdb/ub_src_common_tree_renderer.cpp
deleted file mode 100644
index e3a540033..000000000
--- a/src/duckdb/ub_src_common_tree_renderer.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/common/tree_renderer/json_tree_renderer.cpp"
-
-#include "src/common/tree_renderer/html_tree_renderer.cpp"
-
-#include "src/common/tree_renderer/graphviz_tree_renderer.cpp"
-
-#include "src/common/tree_renderer/text_tree_renderer.cpp"
-
-#include "src/common/tree_renderer/tree_renderer.cpp"
-
diff --git a/src/duckdb/ub_src_common_types.cpp b/src/duckdb/ub_src_common_types.cpp
deleted file mode 100644
index 475a2d820..000000000
--- a/src/duckdb/ub_src_common_types.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "src/common/types/batched_data_collection.cpp"
-
-#include "src/common/types/bit.cpp"
-
-#include "src/common/types/blob.cpp"
-
-#include "src/common/types/cast_helpers.cpp"
-
-#include "src/common/types/conflict_manager.cpp"
-
-#include "src/common/types/conflict_info.cpp"
-
-#include "src/common/types/data_chunk.cpp"
-
-#include "src/common/types/date.cpp"
-
-#include "src/common/types/decimal.cpp"
-
-#include "src/common/types/hash.cpp"
-
-#include "src/common/types/hugeint.cpp"
-
-#include "src/common/types/uhugeint.cpp"
-
-#include "src/common/types/uuid.cpp"
-
-#include "src/common/types/hyperloglog.cpp"
-
-#include "src/common/types/interval.cpp"
-
-#include "src/common/types/list_segment.cpp"
-
-#include "src/common/types/selection_vector.cpp"
-
-#include "src/common/types/string_heap.cpp"
-
-#include "src/common/types/string_type.cpp"
-
-#include "src/common/types/timestamp.cpp"
-
-#include "src/common/types/time.cpp"
-
-#include "src/common/types/validity_mask.cpp"
-
-#include "src/common/types/value.cpp"
-
-#include "src/common/types/varint.cpp"
-
-#include "src/common/types/vector_buffer.cpp"
-
-#include "src/common/types/vector.cpp"
-
-#include "src/common/types/vector_cache.cpp"
-
-#include "src/common/types/vector_constants.cpp"
-
diff --git a/src/duckdb/ub_src_common_types_column.cpp b/src/duckdb/ub_src_common_types_column.cpp
deleted file mode 100644
index ddd7f663d..000000000
--- a/src/duckdb/ub_src_common_types_column.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/common/types/column/column_data_allocator.cpp"
-
-#include "src/common/types/column/column_data_collection.cpp"
-
-#include "src/common/types/column/column_data_collection_segment.cpp"
-
-#include "src/common/types/column/column_data_consumer.cpp"
-
-#include "src/common/types/column/partitioned_column_data.cpp"
-
diff --git a/src/duckdb/ub_src_common_types_row.cpp b/src/duckdb/ub_src_common_types_row.cpp
deleted file mode 100644
index 24bfa5fd4..000000000
--- a/src/duckdb/ub_src_common_types_row.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "src/common/types/row/partitioned_tuple_data.cpp"
-
-#include "src/common/types/row/row_data_collection.cpp"
-
-#include "src/common/types/row/row_data_collection_scanner.cpp"
-
-#include "src/common/types/row/row_layout.cpp"
-
-#include "src/common/types/row/tuple_data_allocator.cpp"
-
-#include "src/common/types/row/tuple_data_collection.cpp"
-
-#include "src/common/types/row/tuple_data_iterator.cpp"
-
-#include "src/common/types/row/tuple_data_layout.cpp"
-
-#include "src/common/types/row/tuple_data_scatter_gather.cpp"
-
-#include "src/common/types/row/tuple_data_segment.cpp"
-
diff --git a/src/duckdb/ub_src_common_value_operations.cpp b/src/duckdb/ub_src_common_value_operations.cpp
deleted file mode 100644
index 429b02ab2..000000000
--- a/src/duckdb/ub_src_common_value_operations.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/common/value_operations/comparison_operations.cpp"
-
diff --git a/src/duckdb/ub_src_execution.cpp b/src/duckdb/ub_src_execution.cpp
deleted file mode 100644
index 1acd5651c..000000000
--- a/src/duckdb/ub_src_execution.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "src/execution/adaptive_filter.cpp"
-
-#include "src/execution/aggregate_hashtable.cpp"
-
-#include "src/execution/base_aggregate_hashtable.cpp"
-
-#include "src/execution/column_binding_resolver.cpp"
-
-#include "src/execution/expression_executor.cpp"
-
-#include "src/execution/expression_executor_state.cpp"
-
-#include "src/execution/join_hashtable.cpp"
-
-#include "src/execution/perfect_aggregate_hashtable.cpp"
-
-#include "src/execution/physical_operator.cpp"
-
-#include "src/execution/physical_plan_generator.cpp"
-
-#include "src/execution/radix_partitioned_hashtable.cpp"
-
diff --git a/src/duckdb/ub_src_execution_expression_executor.cpp b/src/duckdb/ub_src_execution_expression_executor.cpp
deleted file mode 100644
index 7ca878ae6..000000000
--- a/src/duckdb/ub_src_execution_expression_executor.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "src/execution/expression_executor/execute_between.cpp"
-
-#include "src/execution/expression_executor/execute_case.cpp"
-
-#include "src/execution/expression_executor/execute_cast.cpp"
-
-#include "src/execution/expression_executor/execute_comparison.cpp"
-
-#include "src/execution/expression_executor/execute_conjunction.cpp"
-
-#include "src/execution/expression_executor/execute_constant.cpp"
-
-#include "src/execution/expression_executor/execute_function.cpp"
-
-#include "src/execution/expression_executor/execute_operator.cpp"
-
-#include "src/execution/expression_executor/execute_parameter.cpp"
-
-#include "src/execution/expression_executor/execute_reference.cpp"
-
diff --git a/src/duckdb/ub_src_execution_index.cpp b/src/duckdb/ub_src_execution_index.cpp
deleted file mode 100644
index 3e02d30a6..000000000
--- a/src/duckdb/ub_src_execution_index.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/execution/index/fixed_size_allocator.cpp"
-
-#include "src/execution/index/fixed_size_buffer.cpp"
-
-#include "src/execution/index/unbound_index.cpp"
-
-#include "src/execution/index/index_type_set.cpp"
-
-#include "src/execution/index/bound_index.cpp"
-
diff --git a/src/duckdb/ub_src_execution_index_art.cpp b/src/duckdb/ub_src_execution_index_art.cpp
deleted file mode 100644
index 2f700eb09..000000000
--- a/src/duckdb/ub_src_execution_index_art.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "src/execution/index/art/art_key.cpp"
-
-#include "src/execution/index/art/node.cpp"
-
-#include "src/execution/index/art/iterator.cpp"
-
-#include "src/execution/index/art/leaf.cpp"
-
-#include "src/execution/index/art/base_node.cpp"
-
-#include "src/execution/index/art/node48.cpp"
-
-#include "src/execution/index/art/node256.cpp"
-
-#include "src/execution/index/art/prefix.cpp"
-
-#include "src/execution/index/art/base_leaf.cpp"
-
-#include "src/execution/index/art/node256_leaf.cpp"
-
-#include "src/execution/index/art/art.cpp"
-
-#include "src/execution/index/art/plan_art.cpp"
-
diff --git a/src/duckdb/ub_src_execution_nested_loop_join.cpp b/src/duckdb/ub_src_execution_nested_loop_join.cpp
deleted file mode 100644
index 84bb0921c..000000000
--- a/src/duckdb/ub_src_execution_nested_loop_join.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/execution/nested_loop_join/nested_loop_join_inner.cpp"
-
-#include "src/execution/nested_loop_join/nested_loop_join_mark.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_aggregate.cpp b/src/duckdb/ub_src_execution_operator_aggregate.cpp
deleted file mode 100644
index f8555ee93..000000000
--- a/src/duckdb/ub_src_execution_operator_aggregate.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "src/execution/operator/aggregate/aggregate_object.cpp"
-
-#include "src/execution/operator/aggregate/distinct_aggregate_data.cpp"
-
-#include "src/execution/operator/aggregate/physical_hash_aggregate.cpp"
-
-#include "src/execution/operator/aggregate/grouped_aggregate_data.cpp"
-
-#include "src/execution/operator/aggregate/physical_partitioned_aggregate.cpp"
-
-#include "src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp"
-
-#include "src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp"
-
-#include "src/execution/operator/aggregate/physical_window.cpp"
-
-#include "src/execution/operator/aggregate/physical_streaming_window.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp
deleted file mode 100644
index 707472b8e..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp"
-
-#include "src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp"
-
-#include "src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_encode.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_encode.cpp
deleted file mode 100644
index f1db7c41a..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_encode.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/execution/operator/csv_scanner/encode/csv_encoder.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp
deleted file mode 100644
index dd1ac8f38..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "src/execution/operator/csv_scanner/scanner/base_scanner.cpp"
-
-#include "src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp"
-
-#include "src/execution/operator/csv_scanner/scanner/csv_schema.cpp"
-
-#include "src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp"
-
-#include "src/execution/operator/csv_scanner/scanner/skip_scanner.cpp"
-
-#include "src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp
deleted file mode 100644
index 61cfd4912..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp"
-
-#include "src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp"
-
-#include "src/execution/operator/csv_scanner/sniffer/header_detection.cpp"
-
-#include "src/execution/operator/csv_scanner/sniffer/type_detection.cpp"
-
-#include "src/execution/operator/csv_scanner/sniffer/type_refinement.cpp"
-
-#include "src/execution/operator/csv_scanner/sniffer/type_replacement.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp
deleted file mode 100644
index fd9d3fece..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/execution/operator/csv_scanner/state_machine/csv_state_machine.cpp"
-
-#include "src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp
deleted file mode 100644
index b5215a21d..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp"
-
-#include "src/execution/operator/csv_scanner/table_function/global_csv_state.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_csv_scanner_util.cpp b/src/duckdb/ub_src_execution_operator_csv_scanner_util.cpp
deleted file mode 100644
index 5fd16fb67..000000000
--- a/src/duckdb/ub_src_execution_operator_csv_scanner_util.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/execution/operator/csv_scanner/util/csv_error.cpp"
-
-#include "src/execution/operator/csv_scanner/util/csv_reader_options.cpp"
-
-#include "src/execution/operator/csv_scanner/util/csv_validator.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_filter.cpp b/src/duckdb/ub_src_execution_operator_filter.cpp
deleted file mode 100644
index 03631c0cd..000000000
--- a/src/duckdb/ub_src_execution_operator_filter.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/execution/operator/filter/physical_filter.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_helper.cpp b/src/duckdb/ub_src_execution_operator_helper.cpp
deleted file mode 100644
index f28d503c8..000000000
--- a/src/duckdb/ub_src_execution_operator_helper.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "src/execution/operator/helper/physical_batch_collector.cpp"
-
-#include "src/execution/operator/helper/physical_buffered_collector.cpp"
-
-#include "src/execution/operator/helper/physical_buffered_batch_collector.cpp"
-
-#include "src/execution/operator/helper/physical_create_secret.cpp"
-
-#include "src/execution/operator/helper/physical_execute.cpp"
-
-#include "src/execution/operator/helper/physical_explain_analyze.cpp"
-
-#include "src/execution/operator/helper/physical_limit.cpp"
-
-#include "src/execution/operator/helper/physical_limit_percent.cpp"
-
-#include "src/execution/operator/helper/physical_load.cpp"
-
-#include "src/execution/operator/helper/physical_materialized_collector.cpp"
-
-#include "src/execution/operator/helper/physical_pragma.cpp"
-
-#include "src/execution/operator/helper/physical_prepare.cpp"
-
-#include "src/execution/operator/helper/physical_reservoir_sample.cpp"
-
-#include "src/execution/operator/helper/physical_result_collector.cpp"
-
-#include "src/execution/operator/helper/physical_set.cpp"
-
-#include "src/execution/operator/helper/physical_set_variable.cpp"
-
-#include "src/execution/operator/helper/physical_reset.cpp"
-
-#include "src/execution/operator/helper/physical_streaming_limit.cpp"
-
-#include "src/execution/operator/helper/physical_streaming_sample.cpp"
-
-#include "src/execution/operator/helper/physical_transaction.cpp"
-
-#include "src/execution/operator/helper/physical_update_extensions.cpp"
-
-#include "src/execution/operator/helper/physical_vacuum.cpp"
-
-#include "src/execution/operator/helper/physical_verify_vector.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_join.cpp b/src/duckdb/ub_src_execution_operator_join.cpp
deleted file mode 100644
index d7003bd86..000000000
--- a/src/duckdb/ub_src_execution_operator_join.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "src/execution/operator/join/outer_join_marker.cpp"
-
-#include "src/execution/operator/join/physical_asof_join.cpp"
-
-#include "src/execution/operator/join/physical_blockwise_nl_join.cpp"
-
-#include "src/execution/operator/join/physical_comparison_join.cpp"
-
-#include "src/execution/operator/join/physical_cross_product.cpp"
-
-#include "src/execution/operator/join/physical_delim_join.cpp"
-
-#include "src/execution/operator/join/physical_left_delim_join.cpp"
-
-#include "src/execution/operator/join/physical_hash_join.cpp"
-
-#include "src/execution/operator/join/physical_iejoin.cpp"
-
-#include "src/execution/operator/join/physical_join.cpp"
-
-#include "src/execution/operator/join/physical_nested_loop_join.cpp"
-
-#include "src/execution/operator/join/perfect_hash_join_executor.cpp"
-
-#include "src/execution/operator/join/physical_piecewise_merge_join.cpp"
-
-#include "src/execution/operator/join/physical_positional_join.cpp"
-
-#include "src/execution/operator/join/physical_range_join.cpp"
-
-#include "src/execution/operator/join/physical_right_delim_join.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_order.cpp b/src/duckdb/ub_src_execution_operator_order.cpp
deleted file mode 100644
index 3952bbec7..000000000
--- a/src/duckdb/ub_src_execution_operator_order.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/execution/operator/order/physical_order.cpp"
-
-#include "src/execution/operator/order/physical_top_n.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_persistent.cpp b/src/duckdb/ub_src_execution_operator_persistent.cpp
deleted file mode 100644
index 95a0c1bf3..000000000
--- a/src/duckdb/ub_src_execution_operator_persistent.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "src/execution/operator/persistent/csv_rejects_table.cpp"
-
-#include "src/execution/operator/persistent/physical_batch_copy_to_file.cpp"
-
-#include "src/execution/operator/persistent/physical_batch_insert.cpp"
-
-#include "src/execution/operator/persistent/physical_copy_database.cpp"
-
-#include "src/execution/operator/persistent/physical_copy_to_file.cpp"
-
-#include "src/execution/operator/persistent/physical_delete.cpp"
-
-#include "src/execution/operator/persistent/physical_export.cpp"
-
-#include "src/execution/operator/persistent/physical_insert.cpp"
-
-#include "src/execution/operator/persistent/physical_update.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_projection.cpp b/src/duckdb/ub_src_execution_operator_projection.cpp
deleted file mode 100644
index f954bf732..000000000
--- a/src/duckdb/ub_src_execution_operator_projection.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/execution/operator/projection/physical_projection.cpp"
-
-#include "src/execution/operator/projection/physical_tableinout_function.cpp"
-
-#include "src/execution/operator/projection/physical_pivot.cpp"
-
-#include "src/execution/operator/projection/physical_unnest.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_scan.cpp b/src/duckdb/ub_src_execution_operator_scan.cpp
deleted file mode 100644
index 725fa701e..000000000
--- a/src/duckdb/ub_src_execution_operator_scan.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "src/execution/operator/scan/physical_column_data_scan.cpp"
-
-#include "src/execution/operator/scan/physical_dummy_scan.cpp"
-
-#include "src/execution/operator/scan/physical_empty_result.cpp"
-
-#include "src/execution/operator/scan/physical_expression_scan.cpp"
-
-#include "src/execution/operator/scan/physical_positional_scan.cpp"
-
-#include "src/execution/operator/scan/physical_table_scan.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_schema.cpp b/src/duckdb/ub_src_execution_operator_schema.cpp
deleted file mode 100644
index fce1529a2..000000000
--- a/src/duckdb/ub_src_execution_operator_schema.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "src/execution/operator/schema/physical_alter.cpp"
-
-#include "src/execution/operator/schema/physical_attach.cpp"
-
-#include "src/execution/operator/schema/physical_create_art_index.cpp"
-
-#include "src/execution/operator/schema/physical_create_schema.cpp"
-
-#include "src/execution/operator/schema/physical_create_type.cpp"
-
-#include "src/execution/operator/schema/physical_create_sequence.cpp"
-
-#include "src/execution/operator/schema/physical_create_table.cpp"
-
-#include "src/execution/operator/schema/physical_create_view.cpp"
-
-#include "src/execution/operator/schema/physical_create_function.cpp"
-
-#include "src/execution/operator/schema/physical_detach.cpp"
-
-#include "src/execution/operator/schema/physical_drop.cpp"
-
diff --git a/src/duckdb/ub_src_execution_operator_set.cpp b/src/duckdb/ub_src_execution_operator_set.cpp
deleted file mode 100644
index 11372efc0..000000000
--- a/src/duckdb/ub_src_execution_operator_set.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/execution/operator/set/physical_union.cpp"
-
-#include "src/execution/operator/set/physical_recursive_cte.cpp"
-
-#include "src/execution/operator/set/physical_cte.cpp"
-
diff --git a/src/duckdb/ub_src_execution_physical_plan.cpp b/src/duckdb/ub_src_execution_physical_plan.cpp
deleted file mode 100644
index e7f6016de..000000000
--- a/src/duckdb/ub_src_execution_physical_plan.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "src/execution/physical_plan/plan_aggregate.cpp"
-
-#include "src/execution/physical_plan/plan_any_join.cpp"
-
-#include "src/execution/physical_plan/plan_asof_join.cpp"
-
-#include "src/execution/physical_plan/plan_column_data_get.cpp"
-
-#include "src/execution/physical_plan/plan_comparison_join.cpp"
-
-#include "src/execution/physical_plan/plan_copy_database.cpp"
-
-#include "src/execution/physical_plan/plan_copy_to_file.cpp"
-
-#include "src/execution/physical_plan/plan_create.cpp"
-
-#include "src/execution/physical_plan/plan_create_index.cpp"
-
-#include "src/execution/physical_plan/plan_create_table.cpp"
-
-#include "src/execution/physical_plan/plan_create_secret.cpp"
-
-#include "src/execution/physical_plan/plan_cross_product.cpp"
-
-#include "src/execution/physical_plan/plan_delete.cpp"
-
-#include "src/execution/physical_plan/plan_delim_get.cpp"
-
-#include "src/execution/physical_plan/plan_delim_join.cpp"
-
-#include "src/execution/physical_plan/plan_distinct.cpp"
-
-#include "src/execution/physical_plan/plan_dummy_scan.cpp"
-
-#include "src/execution/physical_plan/plan_empty_result.cpp"
-
-#include "src/execution/physical_plan/plan_execute.cpp"
-
-#include "src/execution/physical_plan/plan_explain.cpp"
-
-#include "src/execution/physical_plan/plan_export.cpp"
-
-#include "src/execution/physical_plan/plan_filter.cpp"
-
-#include "src/execution/physical_plan/plan_get.cpp"
-
-#include "src/execution/physical_plan/plan_insert.cpp"
-
-#include "src/execution/physical_plan/plan_limit.cpp"
-
-#include "src/execution/physical_plan/plan_order.cpp"
-
-#include "src/execution/physical_plan/plan_pivot.cpp"
-
-#include "src/execution/physical_plan/plan_positional_join.cpp"
-
-#include "src/execution/physical_plan/plan_pragma.cpp"
-
-#include "src/execution/physical_plan/plan_prepare.cpp"
-
-#include "src/execution/physical_plan/plan_projection.cpp"
-
-#include "src/execution/physical_plan/plan_set_operation.cpp"
-
-#include "src/execution/physical_plan/plan_set.cpp"
-
-#include "src/execution/physical_plan/plan_reset.cpp"
-
-#include "src/execution/physical_plan/plan_sample.cpp"
-
-#include "src/execution/physical_plan/plan_simple.cpp"
-
-#include "src/execution/physical_plan/plan_top_n.cpp"
-
-#include "src/execution/physical_plan/plan_update.cpp"
-
-#include "src/execution/physical_plan/plan_window.cpp"
-
-#include "src/execution/physical_plan/plan_vacuum.cpp"
-
-#include "src/execution/physical_plan/plan_unnest.cpp"
-
-#include "src/execution/physical_plan/plan_expression_get.cpp"
-
-#include "src/execution/physical_plan/plan_recursive_cte.cpp"
-
-#include "src/execution/physical_plan/plan_cte.cpp"
-
diff --git a/src/duckdb/ub_src_execution_sample.cpp b/src/duckdb/ub_src_execution_sample.cpp
deleted file mode 100644
index 32d9b85ce..000000000
--- a/src/duckdb/ub_src_execution_sample.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/execution/sample/base_reservoir_sample.cpp"
-
-#include "src/execution/sample/reservoir_sample.cpp"
-
diff --git a/src/duckdb/ub_src_function.cpp b/src/duckdb/ub_src_function.cpp
deleted file mode 100644
index 06938e55b..000000000
--- a/src/duckdb/ub_src_function.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "src/function/aggregate_function.cpp"
-
-#include "src/function/built_in_functions.cpp"
-
-#include "src/function/cast_rules.cpp"
-
-#include "src/function/compression_config.cpp"
-
-#include "src/function/copy_function.cpp"
-
-#include "src/function/encoding_function.cpp"
-
-#include "src/function/function.cpp"
-
-#include "src/function/function_binder.cpp"
-
-#include "src/function/function_list.cpp"
-
-#include "src/function/function_set.cpp"
-
-#include "src/function/pragma_function.cpp"
-
-#include "src/function/macro_function.cpp"
-
-#include "src/function/register_function_list.cpp"
-
-#include "src/function/scalar_macro_function.cpp"
-
-#include "src/function/table_macro_function.cpp"
-
-#include "src/function/scalar_function.cpp"
-
-#include "src/function/table_function.cpp"
-
-#include "src/function/udf_function.cpp"
-
diff --git a/src/duckdb/ub_src_function_aggregate.cpp b/src/duckdb/ub_src_function_aggregate.cpp
deleted file mode 100644
index 6bfe0ba85..000000000
--- a/src/duckdb/ub_src_function_aggregate.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/aggregate/sorted_aggregate_function.cpp"
-
diff --git a/src/duckdb/ub_src_function_aggregate_distributive.cpp b/src/duckdb/ub_src_function_aggregate_distributive.cpp
deleted file mode 100644
index 92bcd6c50..000000000
--- a/src/duckdb/ub_src_function_aggregate_distributive.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/function/aggregate/distributive/count.cpp"
-
-#include "src/function/aggregate/distributive/first_last_any.cpp"
-
-#include "src/function/aggregate/distributive/minmax.cpp"
-
diff --git a/src/duckdb/ub_src_function_cast.cpp b/src/duckdb/ub_src_function_cast.cpp
deleted file mode 100644
index 2be5a82fd..000000000
--- a/src/duckdb/ub_src_function_cast.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "src/function/cast/array_casts.cpp"
-
-#include "src/function/cast/blob_cast.cpp"
-
-#include "src/function/cast/bit_cast.cpp"
-
-#include "src/function/cast/cast_function_set.cpp"
-
-#include "src/function/cast/decimal_cast.cpp"
-
-#include "src/function/cast/default_casts.cpp"
-
-#include "src/function/cast/enum_casts.cpp"
-
-#include "src/function/cast/list_casts.cpp"
-
-#include "src/function/cast/map_cast.cpp"
-
-#include "src/function/cast/numeric_casts.cpp"
-
-#include "src/function/cast/pointer_cast.cpp"
-
-#include "src/function/cast/string_cast.cpp"
-
-#include "src/function/cast/struct_cast.cpp"
-
-#include "src/function/cast/time_casts.cpp"
-
-#include "src/function/cast/union_casts.cpp"
-
-#include "src/function/cast/uuid_casts.cpp"
-
-#include "src/function/cast/varint_casts.cpp"
-
-#include "src/function/cast/vector_cast_helpers.cpp"
-
diff --git a/src/duckdb/ub_src_function_cast_union.cpp b/src/duckdb/ub_src_function_cast_union.cpp
deleted file mode 100644
index 016863ea2..000000000
--- a/src/duckdb/ub_src_function_cast_union.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/cast/union/from_struct.cpp"
-
diff --git a/src/duckdb/ub_src_function_pragma.cpp b/src/duckdb/ub_src_function_pragma.cpp
deleted file mode 100644
index 0d61ef896..000000000
--- a/src/duckdb/ub_src_function_pragma.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/function/pragma/pragma_functions.cpp"
-
-#include "src/function/pragma/pragma_queries.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar.cpp b/src/duckdb/ub_src_function_scalar.cpp
deleted file mode 100644
index a0da28dc6..000000000
--- a/src/duckdb/ub_src_function_scalar.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/function/scalar/compressed_materialization_utils.cpp"
-
-#include "src/function/scalar/create_sort_key.cpp"
-
-#include "src/function/scalar/strftime_format.cpp"
-
-#include "src/function/scalar/nested_functions.cpp"
-
-#include "src/function/scalar/pragma_functions.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_compressed_materialization.cpp b/src/duckdb/ub_src_function_scalar_compressed_materialization.cpp
deleted file mode 100644
index a160a1843..000000000
--- a/src/duckdb/ub_src_function_scalar_compressed_materialization.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/function/scalar/compressed_materialization/compress_integral.cpp"
-
-#include "src/function/scalar/compressed_materialization/compress_string.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_date.cpp b/src/duckdb/ub_src_function_scalar_date.cpp
deleted file mode 100644
index 81e2c26c1..000000000
--- a/src/duckdb/ub_src_function_scalar_date.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/scalar/date/strftime.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_generic.cpp b/src/duckdb/ub_src_function_scalar_generic.cpp
deleted file mode 100644
index 926f394d3..000000000
--- a/src/duckdb/ub_src_function_scalar_generic.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/function/scalar/generic/constant_or_null.cpp"
-
-#include "src/function/scalar/generic/error.cpp"
-
-#include "src/function/scalar/generic/getvariable.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_list.cpp b/src/duckdb/ub_src_function_scalar_list.cpp
deleted file mode 100644
index 70726caaf..000000000
--- a/src/duckdb/ub_src_function_scalar_list.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/function/scalar/list/contains_or_position.cpp"
-
-#include "src/function/scalar/list/list_extract.cpp"
-
-#include "src/function/scalar/list/list_resize.cpp"
-
-#include "src/function/scalar/list/list_zip.cpp"
-
-#include "src/function/scalar/list/list_select.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_map.cpp b/src/duckdb/ub_src_function_scalar_map.cpp
deleted file mode 100644
index 0978d7e0e..000000000
--- a/src/duckdb/ub_src_function_scalar_map.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/scalar/map/map_contains.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_operator.cpp b/src/duckdb/ub_src_function_scalar_operator.cpp
deleted file mode 100644
index f31f65916..000000000
--- a/src/duckdb/ub_src_function_scalar_operator.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/function/scalar/operator/add.cpp"
-
-#include "src/function/scalar/operator/arithmetic.cpp"
-
-#include "src/function/scalar/operator/multiply.cpp"
-
-#include "src/function/scalar/operator/subtract.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_sequence.cpp b/src/duckdb/ub_src_function_scalar_sequence.cpp
deleted file mode 100644
index 13127fe1d..000000000
--- a/src/duckdb/ub_src_function_scalar_sequence.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/scalar/sequence/nextval.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_string.cpp b/src/duckdb/ub_src_function_scalar_string.cpp
deleted file mode 100644
index c39a28ea1..000000000
--- a/src/duckdb/ub_src_function_scalar_string.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "src/function/scalar/string/caseconvert.cpp"
-
-#include "src/function/scalar/string/concat.cpp"
-
-#include "src/function/scalar/string/concat_ws.cpp"
-
-#include "src/function/scalar/string/length.cpp"
-
-#include "src/function/scalar/string/like.cpp"
-
-#include "src/function/scalar/string/md5.cpp"
-
-#include "src/function/scalar/string/nfc_normalize.cpp"
-
-#include "src/function/scalar/string/regexp.cpp"
-
-#include "src/function/scalar/string/substring.cpp"
-
-#include "src/function/scalar/string/prefix.cpp"
-
-#include "src/function/scalar/string/regexp_escape.cpp"
-
-#include "src/function/scalar/string/sha1.cpp"
-
-#include "src/function/scalar/string/sha256.cpp"
-
-#include "src/function/scalar/string/strip_accents.cpp"
-
-#include "src/function/scalar/string/string_split.cpp"
-
-#include "src/function/scalar/string/suffix.cpp"
-
-#include "src/function/scalar/string/contains.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_string_regexp.cpp b/src/duckdb/ub_src_function_scalar_string_regexp.cpp
deleted file mode 100644
index 02d2d3536..000000000
--- a/src/duckdb/ub_src_function_scalar_string_regexp.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/function/scalar/string/regexp/regexp_util.cpp"
-
-#include "src/function/scalar/string/regexp/regexp_extract_all.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_struct.cpp b/src/duckdb/ub_src_function_scalar_struct.cpp
deleted file mode 100644
index 67f447661..000000000
--- a/src/duckdb/ub_src_function_scalar_struct.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/function/scalar/struct/struct_extract.cpp"
-
-#include "src/function/scalar/struct/struct_pack.cpp"
-
-#include "src/function/scalar/struct/struct_concat.cpp"
-
diff --git a/src/duckdb/ub_src_function_scalar_system.cpp b/src/duckdb/ub_src_function_scalar_system.cpp
deleted file mode 100644
index 58c4a1fda..000000000
--- a/src/duckdb/ub_src_function_scalar_system.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/scalar/system/aggregate_export.cpp"
-
diff --git a/src/duckdb/ub_src_function_table.cpp b/src/duckdb/ub_src_function_table.cpp
deleted file mode 100644
index b8ba90515..000000000
--- a/src/duckdb/ub_src_function_table.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "src/function/table/arrow.cpp"
-
-#include "src/function/table/arrow_conversion.cpp"
-
-#include "src/function/table/checkpoint.cpp"
-
-#include "src/function/table/glob.cpp"
-
-#include "src/function/table/query_function.cpp"
-
-#include "src/function/table/range.cpp"
-
-#include "src/function/table/repeat.cpp"
-
-#include "src/function/table/repeat_row.cpp"
-
-#include "src/function/table/copy_csv.cpp"
-
-#include "src/function/table/read_csv.cpp"
-
-#include "src/function/table/sniff_csv.cpp"
-
-#include "src/function/table/read_file.cpp"
-
-#include "src/function/table/system_functions.cpp"
-
-#include "src/function/table/summary.cpp"
-
-#include "src/function/table/table_scan.cpp"
-
-#include "src/function/table/unnest.cpp"
-
diff --git a/src/duckdb/ub_src_function_table_arrow.cpp b/src/duckdb/ub_src_function_table_arrow.cpp
deleted file mode 100644
index bb7438a18..000000000
--- a/src/duckdb/ub_src_function_table_arrow.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/function/table/arrow/arrow_duck_schema.cpp"
-
-#include "src/function/table/arrow/arrow_array_scan_state.cpp"
-
-#include "src/function/table/arrow/arrow_type_info.cpp"
-
diff --git a/src/duckdb/ub_src_function_table_system.cpp b/src/duckdb/ub_src_function_table_system.cpp
deleted file mode 100644
index 4ab6fdaf7..000000000
--- a/src/duckdb/ub_src_function_table_system.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "src/function/table/system/duckdb_columns.cpp"
-
-#include "src/function/table/system/duckdb_constraints.cpp"
-
-#include "src/function/table/system/duckdb_databases.cpp"
-
-#include "src/function/table/system/duckdb_dependencies.cpp"
-
-#include "src/function/table/system/duckdb_extensions.cpp"
-
-#include "src/function/table/system/duckdb_functions.cpp"
-
-#include "src/function/table/system/duckdb_keywords.cpp"
-
-#include "src/function/table/system/duckdb_indexes.cpp"
-
-#include "src/function/table/system/duckdb_memory.cpp"
-
-#include "src/function/table/system/duckdb_optimizers.cpp"
-
-#include "src/function/table/system/duckdb_schemas.cpp"
-
-#include "src/function/table/system/duckdb_secrets.cpp"
-
-#include "src/function/table/system/duckdb_which_secret.cpp"
-
-#include "src/function/table/system/duckdb_sequences.cpp"
-
-#include "src/function/table/system/duckdb_settings.cpp"
-
-#include "src/function/table/system/duckdb_tables.cpp"
-
-#include "src/function/table/system/duckdb_temporary_files.cpp"
-
-#include "src/function/table/system/duckdb_types.cpp"
-
-#include "src/function/table/system/duckdb_variables.cpp"
-
-#include "src/function/table/system/duckdb_views.cpp"
-
-#include "src/function/table/system/pragma_collations.cpp"
-
-#include "src/function/table/system/pragma_database_size.cpp"
-
-#include "src/function/table/system/pragma_metadata_info.cpp"
-
-#include "src/function/table/system/pragma_storage_info.cpp"
-
-#include "src/function/table/system/pragma_table_info.cpp"
-
-#include "src/function/table/system/pragma_table_sample.cpp"
-
-#include "src/function/table/system/pragma_user_agent.cpp"
-
-#include "src/function/table/system/test_all_types.cpp"
-
-#include "src/function/table/system/test_vector_types.cpp"
-
diff --git a/src/duckdb/ub_src_function_table_version.cpp b/src/duckdb/ub_src_function_table_version.cpp
deleted file mode 100644
index 6131c2a6a..000000000
--- a/src/duckdb/ub_src_function_table_version.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/function/table/version/pragma_version.cpp"
-
diff --git a/src/duckdb/ub_src_function_window.cpp b/src/duckdb/ub_src_function_window.cpp
deleted file mode 100644
index fbd3fc960..000000000
--- a/src/duckdb/ub_src_function_window.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "src/function/window/window_aggregate_function.cpp"
-
-#include "src/function/window/window_aggregate_states.cpp"
-
-#include "src/function/window/window_aggregator.cpp"
-
-#include "src/function/window/window_boundaries_state.cpp"
-
-#include "src/function/window/window_collection.cpp"
-
-#include "src/function/window/window_constant_aggregator.cpp"
-
-#include "src/function/window/window_custom_aggregator.cpp"
-
-#include "src/function/window/window_distinct_aggregator.cpp"
-
-#include "src/function/window/window_executor.cpp"
-
-#include "src/function/window/window_index_tree.cpp"
-
-#include "src/function/window/window_merge_sort_tree.cpp"
-
-#include "src/function/window/window_naive_aggregator.cpp"
-
-#include "src/function/window/window_rank_function.cpp"
-
-#include "src/function/window/window_rownumber_function.cpp"
-
-#include "src/function/window/window_segment_tree.cpp"
-
-#include "src/function/window/window_shared_expressions.cpp"
-
-#include "src/function/window/window_token_tree.cpp"
-
-#include "src/function/window/window_value_function.cpp"
-
diff --git a/src/duckdb/ub_src_main.cpp b/src/duckdb/ub_src_main.cpp
deleted file mode 100644
index 0ad1d75be..000000000
--- a/src/duckdb/ub_src_main.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "src/main/appender.cpp"
-
-#include "src/main/attached_database.cpp"
-
-#include "src/main/client_config.cpp"
-
-#include "src/main/client_context_file_opener.cpp"
-
-#include "src/main/client_context.cpp"
-
-#include "src/main/client_context_wrapper.cpp"
-
-#include "src/main/client_data.cpp"
-
-#include "src/main/client_verify.cpp"
-
-#include "src/main/connection_manager.cpp"
-
-#include "src/main/chunk_scan_state.cpp"
-
-#include "src/main/config.cpp"
-
-#include "src/main/connection.cpp"
-
-#include "src/main/database.cpp"
-
-#include "src/main/database_path_and_type.cpp"
-
-#include "src/main/database_manager.cpp"
-
-#include "src/main/db_instance_cache.cpp"
-
-#include "src/main/error_manager.cpp"
-
-#include "src/main/extension.cpp"
-
-#include "src/main/extension_install_info.cpp"
-
-#include "src/main/materialized_query_result.cpp"
-
-#include "src/main/pending_query_result.cpp"
-
-#include "src/main/prepared_statement.cpp"
-
-#include "src/main/prepared_statement_data.cpp"
-
-#include "src/main/profiling_info.cpp"
-
-#include "src/main/relation.cpp"
-
-#include "src/main/query_profiler.cpp"
-
-#include "src/main/query_result.cpp"
-
-#include "src/main/stream_query_result.cpp"
-
-#include "src/main/valid_checker.cpp"
-
diff --git a/src/duckdb/ub_src_main_buffered_data.cpp b/src/duckdb/ub_src_main_buffered_data.cpp
deleted file mode 100644
index cfa31f718..000000000
--- a/src/duckdb/ub_src_main_buffered_data.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/main/buffered_data/buffered_data.cpp"
-
-#include "src/main/buffered_data/simple_buffered_data.cpp"
-
-#include "src/main/buffered_data/batched_buffered_data.cpp"
-
diff --git a/src/duckdb/ub_src_main_capi.cpp b/src/duckdb/ub_src_main_capi.cpp
deleted file mode 100644
index c64516e0a..000000000
--- a/src/duckdb/ub_src_main_capi.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "src/main/capi/aggregate_function-c.cpp"
-
-#include "src/main/capi/appender-c.cpp"
-
-#include "src/main/capi/arrow-c.cpp"
-
-#include "src/main/capi/cast_function-c.cpp"
-
-#include "src/main/capi/config-c.cpp"
-
-#include "src/main/capi/data_chunk-c.cpp"
-
-#include "src/main/capi/datetime-c.cpp"
-
-#include "src/main/capi/duckdb-c.cpp"
-
-#include "src/main/capi/duckdb_value-c.cpp"
-
-#include "src/main/capi/helper-c.cpp"
-
-#include "src/main/capi/hugeint-c.cpp"
-
-#include "src/main/capi/logical_types-c.cpp"
-
-#include "src/main/capi/pending-c.cpp"
-
-#include "src/main/capi/prepared-c.cpp"
-
-#include "src/main/capi/profiling_info-c.cpp"
-
-#include "src/main/capi/replacement_scan-c.cpp"
-
-#include "src/main/capi/result-c.cpp"
-
-#include "src/main/capi/scalar_function-c.cpp"
-
-#include "src/main/capi/stream-c.cpp"
-
-#include "src/main/capi/table_description-c.cpp"
-
-#include "src/main/capi/table_function-c.cpp"
-
-#include "src/main/capi/threading-c.cpp"
-
-#include "src/main/capi/value-c.cpp"
-
diff --git a/src/duckdb/ub_src_main_capi_cast.cpp b/src/duckdb/ub_src_main_capi_cast.cpp
deleted file mode 100644
index 6f7255401..000000000
--- a/src/duckdb/ub_src_main_capi_cast.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/main/capi/cast/from_decimal-c.cpp"
-
-#include "src/main/capi/cast/utils-c.cpp"
-
diff --git a/src/duckdb/ub_src_main_chunk_scan_state.cpp b/src/duckdb/ub_src_main_chunk_scan_state.cpp
deleted file mode 100644
index 9ca6b5ddb..000000000
--- a/src/duckdb/ub_src_main_chunk_scan_state.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/main/chunk_scan_state/query_result.cpp"
-
-#include "src/main/chunk_scan_state/batched_data_collection.cpp"
-
diff --git a/src/duckdb/ub_src_main_extension.cpp b/src/duckdb/ub_src_main_extension.cpp
deleted file mode 100644
index 565c8f9f5..000000000
--- a/src/duckdb/ub_src_main_extension.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/main/extension/extension_alias.cpp"
-
-#include "src/main/extension/extension_helper.cpp"
-
-#include "src/main/extension/extension_install.cpp"
-
-#include "src/main/extension/extension_load.cpp"
-
-#include "src/main/extension/extension_util.cpp"
-
diff --git a/src/duckdb/ub_src_main_relation.cpp b/src/duckdb/ub_src_main_relation.cpp
deleted file mode 100644
index 635de2cc0..000000000
--- a/src/duckdb/ub_src_main_relation.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "src/main/relation/aggregate_relation.cpp"
-
-#include "src/main/relation/create_table_relation.cpp"
-
-#include "src/main/relation/create_view_relation.cpp"
-
-#include "src/main/relation/cross_product_relation.cpp"
-
-#include "src/main/relation/delete_relation.cpp"
-
-#include "src/main/relation/delim_get_relation.cpp"
-
-#include "src/main/relation/distinct_relation.cpp"
-
-#include "src/main/relation/explain_relation.cpp"
-
-#include "src/main/relation/filter_relation.cpp"
-
-#include "src/main/relation/insert_relation.cpp"
-
-#include "src/main/relation/join_relation.cpp"
-
-#include "src/main/relation/limit_relation.cpp"
-
-#include "src/main/relation/order_relation.cpp"
-
-#include "src/main/relation/update_relation.cpp"
-
-#include "src/main/relation/projection_relation.cpp"
-
-#include "src/main/relation/query_relation.cpp"
-
-#include "src/main/relation/read_csv_relation.cpp"
-
-#include "src/main/relation/read_json_relation.cpp"
-
-#include "src/main/relation/setop_relation.cpp"
-
-#include "src/main/relation/subquery_relation.cpp"
-
-#include "src/main/relation/table_function_relation.cpp"
-
-#include "src/main/relation/table_relation.cpp"
-
-#include "src/main/relation/value_relation.cpp"
-
-#include "src/main/relation/materialized_relation.cpp"
-
-#include "src/main/relation/view_relation.cpp"
-
-#include "src/main/relation/write_parquet_relation.cpp"
-
-#include "src/main/relation/write_csv_relation.cpp"
-
diff --git a/src/duckdb/ub_src_main_secret.cpp b/src/duckdb/ub_src_main_secret.cpp
deleted file mode 100644
index 6fe1c045c..000000000
--- a/src/duckdb/ub_src_main_secret.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/main/secret/secret.cpp"
-
-#include "src/main/secret/secret_manager.cpp"
-
-#include "src/main/secret/secret_storage.cpp"
-
-#include "src/main/secret/default_secrets.cpp"
-
diff --git a/src/duckdb/ub_src_main_settings.cpp b/src/duckdb/ub_src_main_settings.cpp
deleted file mode 100644
index 6dbcd419e..000000000
--- a/src/duckdb/ub_src_main_settings.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/main/settings/custom_settings.cpp"
-
-#include "src/main/settings/autogenerated_settings.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer.cpp b/src/duckdb/ub_src_optimizer.cpp
deleted file mode 100644
index 26f4abe53..000000000
--- a/src/duckdb/ub_src_optimizer.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "src/optimizer/build_probe_side_optimizer.cpp"
-
-#include "src/optimizer/column_binding_replacer.cpp"
-
-#include "src/optimizer/column_lifetime_analyzer.cpp"
-
-#include "src/optimizer/empty_result_pullup.cpp"
-
-#include "src/optimizer/common_aggregate_optimizer.cpp"
-
-#include "src/optimizer/compressed_materialization.cpp"
-
-#include "src/optimizer/cse_optimizer.cpp"
-
-#include "src/optimizer/cte_filter_pusher.cpp"
-
-#include "src/optimizer/deliminator.cpp"
-
-#include "src/optimizer/expression_heuristics.cpp"
-
-#include "src/optimizer/expression_rewriter.cpp"
-
-#include "src/optimizer/filter_combiner.cpp"
-
-#include "src/optimizer/filter_pullup.cpp"
-
-#include "src/optimizer/filter_pushdown.cpp"
-
-#include "src/optimizer/in_clause_rewriter.cpp"
-
-#include "src/optimizer/join_filter_pushdown_optimizer.cpp"
-
-#include "src/optimizer/optimizer.cpp"
-
-#include "src/optimizer/regex_range_filter.cpp"
-
-#include "src/optimizer/remove_duplicate_groups.cpp"
-
-#include "src/optimizer/remove_unused_columns.cpp"
-
-#include "src/optimizer/statistics_propagator.cpp"
-
-#include "src/optimizer/limit_pushdown.cpp"
-
-#include "src/optimizer/topn_optimizer.cpp"
-
-#include "src/optimizer/unnest_rewriter.cpp"
-
-#include "src/optimizer/sampling_pushdown.cpp"
-
-#include "src/optimizer/sum_rewriter.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_compressed_materialization.cpp b/src/duckdb/ub_src_optimizer_compressed_materialization.cpp
deleted file mode 100644
index 880ae8986..000000000
--- a/src/duckdb/ub_src_optimizer_compressed_materialization.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/optimizer/compressed_materialization/compress_aggregate.cpp"
-
-#include "src/optimizer/compressed_materialization/compress_comparison_join.cpp"
-
-#include "src/optimizer/compressed_materialization/compress_distinct.cpp"
-
-#include "src/optimizer/compressed_materialization/compress_order.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_join_order.cpp b/src/duckdb/ub_src_optimizer_join_order.cpp
deleted file mode 100644
index dd3f77530..000000000
--- a/src/duckdb/ub_src_optimizer_join_order.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "src/optimizer/join_order/query_graph.cpp"
-
-#include "src/optimizer/join_order/join_relation_set.cpp"
-
-#include "src/optimizer/join_order/join_node.cpp"
-
-#include "src/optimizer/join_order/join_order_optimizer.cpp"
-
-#include "src/optimizer/join_order/cardinality_estimator.cpp"
-
-#include "src/optimizer/join_order/cost_model.cpp"
-
-#include "src/optimizer/join_order/plan_enumerator.cpp"
-
-#include "src/optimizer/join_order/relation_manager.cpp"
-
-#include "src/optimizer/join_order/query_graph_manager.cpp"
-
-#include "src/optimizer/join_order/relation_statistics_helper.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_matcher.cpp b/src/duckdb/ub_src_optimizer_matcher.cpp
deleted file mode 100644
index 5967c3773..000000000
--- a/src/duckdb/ub_src_optimizer_matcher.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/optimizer/matcher/expression_matcher.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_pullup.cpp b/src/duckdb/ub_src_optimizer_pullup.cpp
deleted file mode 100644
index 0a86fae6f..000000000
--- a/src/duckdb/ub_src_optimizer_pullup.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/optimizer/pullup/pullup_filter.cpp"
-
-#include "src/optimizer/pullup/pullup_projection.cpp"
-
-#include "src/optimizer/pullup/pullup_from_left.cpp"
-
-#include "src/optimizer/pullup/pullup_both_side.cpp"
-
-#include "src/optimizer/pullup/pullup_set_operation.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_pushdown.cpp b/src/duckdb/ub_src_optimizer_pushdown.cpp
deleted file mode 100644
index 26f3d9c43..000000000
--- a/src/duckdb/ub_src_optimizer_pushdown.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "src/optimizer/pushdown/pushdown_aggregate.cpp"
-
-#include "src/optimizer/pushdown/pushdown_cross_product.cpp"
-
-#include "src/optimizer/pushdown/pushdown_distinct.cpp"
-
-#include "src/optimizer/pushdown/pushdown_filter.cpp"
-
-#include "src/optimizer/pushdown/pushdown_get.cpp"
-
-#include "src/optimizer/pushdown/pushdown_inner_join.cpp"
-
-#include "src/optimizer/pushdown/pushdown_limit.cpp"
-
-#include "src/optimizer/pushdown/pushdown_left_join.cpp"
-
-#include "src/optimizer/pushdown/pushdown_mark_join.cpp"
-
-#include "src/optimizer/pushdown/pushdown_projection.cpp"
-
-#include "src/optimizer/pushdown/pushdown_semi_anti_join.cpp"
-
-#include "src/optimizer/pushdown/pushdown_set_operation.cpp"
-
-#include "src/optimizer/pushdown/pushdown_single_join.cpp"
-
-#include "src/optimizer/pushdown/pushdown_window.cpp"
-
-#include "src/optimizer/pushdown/pushdown_unnest.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_rule.cpp b/src/duckdb/ub_src_optimizer_rule.cpp
deleted file mode 100644
index ee39a8864..000000000
--- a/src/duckdb/ub_src_optimizer_rule.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "src/optimizer/rule/arithmetic_simplification.cpp"
-
-#include "src/optimizer/rule/case_simplification.cpp"
-
-#include "src/optimizer/rule/comparison_simplification.cpp"
-
-#include "src/optimizer/rule/conjunction_simplification.cpp"
-
-#include "src/optimizer/rule/constant_folding.cpp"
-
-#include "src/optimizer/rule/date_part_simplification.cpp"
-
-#include "src/optimizer/rule/distinct_aggregate_optimizer.cpp"
-
-#include "src/optimizer/rule/distributivity.cpp"
-
-#include "src/optimizer/rule/empty_needle_removal.cpp"
-
-#include "src/optimizer/rule/enum_comparison.cpp"
-
-#include "src/optimizer/rule/equal_or_null_simplification.cpp"
-
-#include "src/optimizer/rule/in_clause_simplification_rule.cpp"
-
-#include "src/optimizer/rule/join_dependent_filter.cpp"
-
-#include "src/optimizer/rule/like_optimizations.cpp"
-
-#include "src/optimizer/rule/move_constants.cpp"
-
-#include "src/optimizer/rule/ordered_aggregate_optimizer.cpp"
-
-#include "src/optimizer/rule/regex_optimizations.cpp"
-
-#include "src/optimizer/rule/timestamp_comparison.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_statistics_expression.cpp b/src/duckdb/ub_src_optimizer_statistics_expression.cpp
deleted file mode 100644
index 66ba10160..000000000
--- a/src/duckdb/ub_src_optimizer_statistics_expression.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "src/optimizer/statistics/expression/propagate_aggregate.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_between.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_case.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_cast.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_comparison.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_conjunction.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_constant.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_columnref.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_function.cpp"
-
-#include "src/optimizer/statistics/expression/propagate_operator.cpp"
-
diff --git a/src/duckdb/ub_src_optimizer_statistics_operator.cpp b/src/duckdb/ub_src_optimizer_statistics_operator.cpp
deleted file mode 100644
index 5e28a9997..000000000
--- a/src/duckdb/ub_src_optimizer_statistics_operator.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "src/optimizer/statistics/operator/propagate_aggregate.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_cross_product.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_filter.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_get.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_limit.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_join.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_order.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_projection.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_set_operation.cpp"
-
-#include "src/optimizer/statistics/operator/propagate_window.cpp"
-
diff --git a/src/duckdb/ub_src_parallel.cpp b/src/duckdb/ub_src_parallel.cpp
deleted file mode 100644
index 76a934b87..000000000
--- a/src/duckdb/ub_src_parallel.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "src/parallel/base_pipeline_event.cpp"
-
-#include "src/parallel/meta_pipeline.cpp"
-
-#include "src/parallel/executor_task.cpp"
-
-#include "src/parallel/executor.cpp"
-
-#include "src/parallel/event.cpp"
-
-#include "src/parallel/interrupt.cpp"
-
-#include "src/parallel/pipeline.cpp"
-
-#include "src/parallel/pipeline_complete_event.cpp"
-
-#include "src/parallel/pipeline_event.cpp"
-
-#include "src/parallel/pipeline_executor.cpp"
-
-#include "src/parallel/pipeline_finish_event.cpp"
-
-#include "src/parallel/pipeline_initialize_event.cpp"
-
-#include "src/parallel/pipeline_prepare_finish_event.cpp"
-
-#include "src/parallel/task_executor.cpp"
-
-#include "src/parallel/task_scheduler.cpp"
-
-#include "src/parallel/thread_context.cpp"
-
diff --git a/src/duckdb/ub_src_parser.cpp b/src/duckdb/ub_src_parser.cpp
deleted file mode 100644
index 39c2c8368..000000000
--- a/src/duckdb/ub_src_parser.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "src/parser/base_expression.cpp"
-
-#include "src/parser/column_definition.cpp"
-
-#include "src/parser/column_list.cpp"
-
-#include "src/parser/constraint.cpp"
-
-#include "src/parser/expression_util.cpp"
-
-#include "src/parser/keyword_helper.cpp"
-
-#include "src/parser/parsed_expression.cpp"
-
-#include "src/parser/parsed_expression_iterator.cpp"
-
-#include "src/parser/parser.cpp"
-
-#include "src/parser/qualified_name.cpp"
-
-#include "src/parser/query_error_context.cpp"
-
-#include "src/parser/query_node.cpp"
-
-#include "src/parser/result_modifier.cpp"
-
-#include "src/parser/tableref.cpp"
-
-#include "src/parser/transformer.cpp"
-
diff --git a/src/duckdb/ub_src_parser_constraints.cpp b/src/duckdb/ub_src_parser_constraints.cpp
deleted file mode 100644
index d90d6c071..000000000
--- a/src/duckdb/ub_src_parser_constraints.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/parser/constraints/check_constraint.cpp"
-
-#include "src/parser/constraints/not_null_constraint.cpp"
-
-#include "src/parser/constraints/unique_constraint.cpp"
-
-#include "src/parser/constraints/foreign_key_constraint.cpp"
-
diff --git a/src/duckdb/ub_src_parser_expression.cpp b/src/duckdb/ub_src_parser_expression.cpp
deleted file mode 100644
index 1d9ba299b..000000000
--- a/src/duckdb/ub_src_parser_expression.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "src/parser/expression/between_expression.cpp"
-
-#include "src/parser/expression/case_expression.cpp"
-
-#include "src/parser/expression/cast_expression.cpp"
-
-#include "src/parser/expression/collate_expression.cpp"
-
-#include "src/parser/expression/conjunction_expression.cpp"
-
-#include "src/parser/expression/columnref_expression.cpp"
-
-#include "src/parser/expression/comparison_expression.cpp"
-
-#include "src/parser/expression/constant_expression.cpp"
-
-#include "src/parser/expression/default_expression.cpp"
-
-#include "src/parser/expression/function_expression.cpp"
-
-#include "src/parser/expression/lambda_expression.cpp"
-
-#include "src/parser/expression/lambdaref_expression.cpp"
-
-#include "src/parser/expression/operator_expression.cpp"
-
-#include "src/parser/expression/parameter_expression.cpp"
-
-#include "src/parser/expression/positional_reference_expression.cpp"
-
-#include "src/parser/expression/star_expression.cpp"
-
-#include "src/parser/expression/subquery_expression.cpp"
-
-#include "src/parser/expression/window_expression.cpp"
-
diff --git a/src/duckdb/ub_src_parser_parsed_data.cpp b/src/duckdb/ub_src_parser_parsed_data.cpp
deleted file mode 100644
index b5bc65914..000000000
--- a/src/duckdb/ub_src_parser_parsed_data.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "src/parser/parsed_data/alter_info.cpp"
-
-#include "src/parser/parsed_data/alter_scalar_function_info.cpp"
-
-#include "src/parser/parsed_data/alter_table_function_info.cpp"
-
-#include "src/parser/parsed_data/alter_table_info.cpp"
-
-#include "src/parser/parsed_data/attach_info.cpp"
-
-#include "src/parser/parsed_data/comment_on_column_info.cpp"
-
-#include "src/parser/parsed_data/copy_info.cpp"
-
-#include "src/parser/parsed_data/create_info.cpp"
-
-#include "src/parser/parsed_data/create_function_info.cpp"
-
-#include "src/parser/parsed_data/create_index_info.cpp"
-
-#include "src/parser/parsed_data/create_aggregate_function_info.cpp"
-
-#include "src/parser/parsed_data/create_collation_info.cpp"
-
-#include "src/parser/parsed_data/create_copy_function_info.cpp"
-
-#include "src/parser/parsed_data/create_macro_info.cpp"
-
-#include "src/parser/parsed_data/create_pragma_function_info.cpp"
-
-#include "src/parser/parsed_data/create_secret_info.cpp"
-
-#include "src/parser/parsed_data/create_sequence_info.cpp"
-
-#include "src/parser/parsed_data/create_schema_info.cpp"
-
-#include "src/parser/parsed_data/create_scalar_function_info.cpp"
-
-#include "src/parser/parsed_data/create_table_function_info.cpp"
-
-#include "src/parser/parsed_data/create_table_info.cpp"
-
-#include "src/parser/parsed_data/create_type_info.cpp"
-
-#include "src/parser/parsed_data/create_view_info.cpp"
-
-#include "src/parser/parsed_data/detach_info.cpp"
-
-#include "src/parser/parsed_data/drop_info.cpp"
-
-#include "src/parser/parsed_data/exported_table_data.cpp"
-
-#include "src/parser/parsed_data/extra_drop_info.cpp"
-
-#include "src/parser/parsed_data/load_info.cpp"
-
-#include "src/parser/parsed_data/sample_options.cpp"
-
-#include "src/parser/parsed_data/parse_info.cpp"
-
-#include "src/parser/parsed_data/transaction_info.cpp"
-
-#include "src/parser/parsed_data/pragma_info.cpp"
-
-#include "src/parser/parsed_data/vacuum_info.cpp"
-
diff --git a/src/duckdb/ub_src_parser_query_node.cpp b/src/duckdb/ub_src_parser_query_node.cpp
deleted file mode 100644
index f0fefe80e..000000000
--- a/src/duckdb/ub_src_parser_query_node.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/parser/query_node/recursive_cte_node.cpp"
-
-#include "src/parser/query_node/cte_node.cpp"
-
-#include "src/parser/query_node/select_node.cpp"
-
-#include "src/parser/query_node/set_operation_node.cpp"
-
diff --git a/src/duckdb/ub_src_parser_statement.cpp b/src/duckdb/ub_src_parser_statement.cpp
deleted file mode 100644
index b6230e85c..000000000
--- a/src/duckdb/ub_src_parser_statement.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "src/parser/statement/alter_statement.cpp"
-
-#include "src/parser/statement/attach_statement.cpp"
-
-#include "src/parser/statement/call_statement.cpp"
-
-#include "src/parser/statement/copy_statement.cpp"
-
-#include "src/parser/statement/copy_database_statement.cpp"
-
-#include "src/parser/statement/create_statement.cpp"
-
-#include "src/parser/statement/detach_statement.cpp"
-
-#include "src/parser/statement/delete_statement.cpp"
-
-#include "src/parser/statement/drop_statement.cpp"
-
-#include "src/parser/statement/execute_statement.cpp"
-
-#include "src/parser/statement/explain_statement.cpp"
-
-#include "src/parser/statement/export_statement.cpp"
-
-#include "src/parser/statement/extension_statement.cpp"
-
-#include "src/parser/statement/insert_statement.cpp"
-
-#include "src/parser/statement/load_statement.cpp"
-
-#include "src/parser/statement/multi_statement.cpp"
-
-#include "src/parser/statement/pragma_statement.cpp"
-
-#include "src/parser/statement/prepare_statement.cpp"
-
-#include "src/parser/statement/relation_statement.cpp"
-
-#include "src/parser/statement/select_statement.cpp"
-
-#include "src/parser/statement/set_statement.cpp"
-
-#include "src/parser/statement/transaction_statement.cpp"
-
-#include "src/parser/statement/update_statement.cpp"
-
-#include "src/parser/statement/update_extensions_statement.cpp"
-
-#include "src/parser/statement/vacuum_statement.cpp"
-
diff --git a/src/duckdb/ub_src_parser_tableref.cpp b/src/duckdb/ub_src_parser_tableref.cpp
deleted file mode 100644
index 56aab8800..000000000
--- a/src/duckdb/ub_src_parser_tableref.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "src/parser/tableref/basetableref.cpp"
-
-#include "src/parser/tableref/delimgetref.cpp"
-
-#include "src/parser/tableref/emptytableref.cpp"
-
-#include "src/parser/tableref/expressionlistref.cpp"
-
-#include "src/parser/tableref/column_data_ref.cpp"
-
-#include "src/parser/tableref/joinref.cpp"
-
-#include "src/parser/tableref/pivotref.cpp"
-
-#include "src/parser/tableref/showref.cpp"
-
-#include "src/parser/tableref/subqueryref.cpp"
-
-#include "src/parser/tableref/table_function.cpp"
-
diff --git a/src/duckdb/ub_src_parser_transform_constraint.cpp b/src/duckdb/ub_src_parser_transform_constraint.cpp
deleted file mode 100644
index 3d74683a3..000000000
--- a/src/duckdb/ub_src_parser_transform_constraint.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "src/parser/transform/constraint/transform_constraint.cpp"
-
diff --git a/src/duckdb/ub_src_parser_transform_expression.cpp b/src/duckdb/ub_src_parser_transform_expression.cpp
deleted file mode 100644
index b4067fa22..000000000
--- a/src/duckdb/ub_src_parser_transform_expression.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "src/parser/transform/expression/transform_array_access.cpp"
-
-#include "src/parser/transform/expression/transform_bool_expr.cpp"
-
-#include "src/parser/transform/expression/transform_boolean_test.cpp"
-
-#include "src/parser/transform/expression/transform_case.cpp"
-
-#include "src/parser/transform/expression/transform_cast.cpp"
-
-#include "src/parser/transform/expression/transform_coalesce.cpp"
-
-#include "src/parser/transform/expression/transform_columnref.cpp"
-
-#include "src/parser/transform/expression/transform_constant.cpp"
-
-#include "src/parser/transform/expression/transform_expression.cpp"
-
-#include "src/parser/transform/expression/transform_function.cpp"
-
-#include "src/parser/transform/expression/transform_grouping_function.cpp"
-
-#include "src/parser/transform/expression/transform_lambda.cpp"
-
-#include "src/parser/transform/expression/transform_interval.cpp"
-
-#include "src/parser/transform/expression/transform_is_null.cpp"
-
-#include "src/parser/transform/expression/transform_operator.cpp"
-
-#include "src/parser/transform/expression/transform_param_ref.cpp"
-
-#include "src/parser/transform/expression/transform_positional_reference.cpp"
-
-#include "src/parser/transform/expression/transform_subquery.cpp"
-
-#include "src/parser/transform/expression/transform_multi_assign_reference.cpp"
-
diff --git a/src/duckdb/ub_src_parser_transform_helpers.cpp b/src/duckdb/ub_src_parser_transform_helpers.cpp
deleted file mode 100644
index c0a1bf8e4..000000000
--- a/src/duckdb/ub_src_parser_transform_helpers.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "src/parser/transform/helpers/transform_alias.cpp"
-
-#include "src/parser/transform/helpers/transform_cte.cpp"
-
-#include "src/parser/transform/helpers/transform_groupby.cpp"
-
-#include "src/parser/transform/helpers/transform_orderby.cpp"
-
-#include "src/parser/transform/helpers/transform_sample.cpp"
-
-#include "src/parser/transform/helpers/transform_typename.cpp"
-
-#include "src/parser/transform/helpers/nodetype_to_string.cpp"
-
diff --git a/src/duckdb/ub_src_parser_transform_statement.cpp b/src/duckdb/ub_src_parser_transform_statement.cpp
deleted file mode 100644
index 83df9d167..000000000
--- a/src/duckdb/ub_src_parser_transform_statement.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "src/parser/transform/statement/transform_alter_table.cpp"
-
-#include "src/parser/transform/statement/transform_attach.cpp"
-
-#include "src/parser/transform/statement/transform_detach.cpp"
-
-#include "src/parser/transform/statement/transform_call.cpp"
-
-#include "src/parser/transform/statement/transform_checkpoint.cpp"
-
-#include "src/parser/transform/statement/transform_create_function.cpp"
-
-#include "src/parser/transform/statement/transform_comment_on.cpp"
-
-#include "src/parser/transform/statement/transform_copy.cpp"
-
-#include "src/parser/transform/statement/transform_copy_database.cpp"
-
-#include "src/parser/transform/statement/transform_create_table_as.cpp"
-
-#include "src/parser/transform/statement/transform_create_index.cpp"
-
-#include "src/parser/transform/statement/transform_create_schema.cpp"
-
-#include "src/parser/transform/statement/transform_create_table.cpp"
-
-#include "src/parser/transform/statement/transform_create_view.cpp"
-
-#include "src/parser/transform/statement/transform_create_type.cpp"
-
-#include "src/parser/transform/statement/transform_delete.cpp"
-
-#include "src/parser/transform/statement/transform_explain.cpp"
-
-#include "src/parser/transform/statement/transform_export.cpp"
-
-#include "src/parser/transform/statement/transform_drop.cpp"
-
-#include "src/parser/transform/statement/transform_import.cpp"
-
-#include "src/parser/transform/statement/transform_insert.cpp"
-
-#include "src/parser/transform/statement/transform_load.cpp"
-
-#include "src/parser/transform/statement/transform_pragma.cpp"
-
-#include "src/parser/transform/statement/transform_rename.cpp"
-
-#include "src/parser/transform/statement/transform_secret.cpp"
-
-#include "src/parser/transform/statement/transform_select.cpp"
-
-#include "src/parser/transform/statement/transform_select_node.cpp"
-
-#include "src/parser/transform/statement/transform_set.cpp"
-
-#include "src/parser/transform/statement/transform_pivot_stmt.cpp"
-
-#include "src/parser/transform/statement/transform_prepare.cpp"
-
-#include "src/parser/transform/statement/transform_show.cpp"
-
-#include "src/parser/transform/statement/transform_show_select.cpp"
-
-#include "src/parser/transform/statement/transform_transaction.cpp"
-
-#include "src/parser/transform/statement/transform_update.cpp"
-
-#include "src/parser/transform/statement/transform_upsert.cpp"
-
-#include "src/parser/transform/statement/transform_use.cpp"
-
-#include "src/parser/transform/statement/transform_create_sequence.cpp"
-
-#include "src/parser/transform/statement/transform_vacuum.cpp"
-
-#include "src/parser/transform/statement/transform_alter_sequence.cpp"
-
diff --git a/src/duckdb/ub_src_parser_transform_tableref.cpp b/src/duckdb/ub_src_parser_transform_tableref.cpp
deleted file mode 100644
index 96de9c47c..000000000
--- a/src/duckdb/ub_src_parser_transform_tableref.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "src/parser/transform/tableref/transform_base_tableref.cpp"
-
-#include "src/parser/transform/tableref/transform_join.cpp"
-
-#include "src/parser/transform/tableref/transform_from.cpp"
-
-#include "src/parser/transform/tableref/transform_pivot.cpp"
-
-#include "src/parser/transform/tableref/transform_subquery.cpp"
-
-#include "src/parser/transform/tableref/transform_table_function.cpp"
-
-#include "src/parser/transform/tableref/transform_tableref.cpp"
-
diff --git a/src/duckdb/ub_src_planner.cpp b/src/duckdb/ub_src_planner.cpp
deleted file mode 100644
index 450ea623c..000000000
--- a/src/duckdb/ub_src_planner.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "src/planner/binding_alias.cpp"
-
-#include "src/planner/bound_result_modifier.cpp"
-
-#include "src/planner/bound_parameter_map.cpp"
-
-#include "src/planner/collation_binding.cpp"
-
-#include "src/planner/expression_iterator.cpp"
-
-#include "src/planner/expression.cpp"
-
-#include "src/planner/table_binding.cpp"
-
-#include "src/planner/expression_binder.cpp"
-
-#include "src/planner/joinside.cpp"
-
-#include "src/planner/logical_operator.cpp"
-
-#include "src/planner/binder.cpp"
-
-#include "src/planner/bind_context.cpp"
-
-#include "src/planner/planner.cpp"
-
-#include "src/planner/pragma_handler.cpp"
-
-#include "src/planner/logical_operator_visitor.cpp"
-
-#include "src/planner/table_filter.cpp"
-
diff --git a/src/duckdb/ub_src_planner_binder_expression.cpp b/src/duckdb/ub_src_planner_binder_expression.cpp
deleted file mode 100644
index 86a595025..000000000
--- a/src/duckdb/ub_src_planner_binder_expression.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "src/planner/binder/expression/bind_aggregate_expression.cpp"
-
-#include "src/planner/binder/expression/bind_between_expression.cpp"
-
-#include "src/planner/binder/expression/bind_case_expression.cpp"
-
-#include "src/planner/binder/expression/bind_cast_expression.cpp"
-
-#include "src/planner/binder/expression/bind_collate_expression.cpp"
-
-#include "src/planner/binder/expression/bind_columnref_expression.cpp"
-
-#include "src/planner/binder/expression/bind_comparison_expression.cpp"
-
-#include "src/planner/binder/expression/bind_conjunction_expression.cpp"
-
-#include "src/planner/binder/expression/bind_constant_expression.cpp"
-
-#include "src/planner/binder/expression/bind_function_expression.cpp"
-
-#include "src/planner/binder/expression/bind_lambda.cpp"
-
-#include "src/planner/binder/expression/bind_macro_expression.cpp"
-
-#include "src/planner/binder/expression/bind_operator_expression.cpp"
-
-#include "src/planner/binder/expression/bind_parameter_expression.cpp"
-
-#include "src/planner/binder/expression/bind_positional_reference_expression.cpp"
-
-#include "src/planner/binder/expression/bind_unpacked_star_expression.cpp"
-
-#include "src/planner/binder/expression/bind_star_expression.cpp"
-
-#include "src/planner/binder/expression/bind_subquery_expression.cpp"
-
-#include "src/planner/binder/expression/bind_unnest_expression.cpp"
-
-#include "src/planner/binder/expression/bind_window_expression.cpp"
-
diff --git a/src/duckdb/ub_src_planner_binder_query_node.cpp b/src/duckdb/ub_src_planner_binder_query_node.cpp
deleted file mode 100644
index 2250c80ca..000000000
--- a/src/duckdb/ub_src_planner_binder_query_node.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "src/planner/binder/query_node/bind_select_node.cpp"
-
-#include "src/planner/binder/query_node/bind_setop_node.cpp"
-
-#include "src/planner/binder/query_node/bind_recursive_cte_node.cpp"
-
-#include "src/planner/binder/query_node/bind_cte_node.cpp"
-
-#include "src/planner/binder/query_node/bind_table_macro_node.cpp"
-
-#include "src/planner/binder/query_node/plan_query_node.cpp"
-
-#include "src/planner/binder/query_node/plan_recursive_cte_node.cpp"
-
-#include "src/planner/binder/query_node/plan_cte_node.cpp"
-
-#include "src/planner/binder/query_node/plan_select_node.cpp"
-
-#include "src/planner/binder/query_node/plan_setop.cpp"
-
-#include "src/planner/binder/query_node/plan_subquery.cpp"
-
diff --git a/src/duckdb/ub_src_planner_binder_statement.cpp b/src/duckdb/ub_src_planner_binder_statement.cpp
deleted file mode 100644
index 2abfc423a..000000000
--- a/src/duckdb/ub_src_planner_binder_statement.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "src/planner/binder/statement/bind_attach.cpp"
-
-#include "src/planner/binder/statement/bind_call.cpp"
-
-#include "src/planner/binder/statement/bind_copy.cpp"
-
-#include "src/planner/binder/statement/bind_copy_database.cpp"
-
-#include "src/planner/binder/statement/bind_create.cpp"
-
-#include "src/planner/binder/statement/bind_create_table.cpp"
-
-#include "src/planner/binder/statement/bind_delete.cpp"
-
-#include "src/planner/binder/statement/bind_detach.cpp"
-
-#include "src/planner/binder/statement/bind_drop.cpp"
-
-#include "src/planner/binder/statement/bind_execute.cpp"
-
-#include "src/planner/binder/statement/bind_explain.cpp"
-
-#include "src/planner/binder/statement/bind_export.cpp"
-
-#include "src/planner/binder/statement/bind_extension.cpp"
-
-#include "src/planner/binder/statement/bind_insert.cpp"
-
-#include "src/planner/binder/statement/bind_load.cpp"
-
-#include "src/planner/binder/statement/bind_logical_plan.cpp"
-
-#include "src/planner/binder/statement/bind_pragma.cpp"
-
-#include "src/planner/binder/statement/bind_prepare.cpp"
-
-#include "src/planner/binder/statement/bind_relation.cpp"
-
-#include "src/planner/binder/statement/bind_select.cpp"
-
-#include "src/planner/binder/statement/bind_set.cpp"
-
-#include "src/planner/binder/statement/bind_simple.cpp"
-
-#include "src/planner/binder/statement/bind_summarize.cpp"
-
-#include "src/planner/binder/statement/bind_update.cpp"
-
-#include "src/planner/binder/statement/bind_update_extensions.cpp"
-
-#include "src/planner/binder/statement/bind_vacuum.cpp"
-
diff --git a/src/duckdb/ub_src_planner_binder_tableref.cpp b/src/duckdb/ub_src_planner_binder_tableref.cpp
deleted file mode 100644
index baa71596a..000000000
--- a/src/duckdb/ub_src_planner_binder_tableref.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "src/planner/binder/tableref/bind_basetableref.cpp"
-
-#include "src/planner/binder/tableref/bind_delimgetref.cpp"
-
-#include "src/planner/binder/tableref/bind_emptytableref.cpp"
-
-#include "src/planner/binder/tableref/bind_expressionlistref.cpp"
-
-#include "src/planner/binder/tableref/bind_column_data_ref.cpp"
-
-#include "src/planner/binder/tableref/bind_joinref.cpp"
-
-#include "src/planner/binder/tableref/bind_pivot.cpp"
-
-#include "src/planner/binder/tableref/bind_showref.cpp"
-
-#include "src/planner/binder/tableref/bind_subqueryref.cpp"
-
-#include "src/planner/binder/tableref/bind_table_function.cpp"
-
-#include "src/planner/binder/tableref/bind_named_parameters.cpp"
-
-#include "src/planner/binder/tableref/plan_basetableref.cpp"
-
-#include "src/planner/binder/tableref/plan_delimgetref.cpp"
-
-#include "src/planner/binder/tableref/plan_dummytableref.cpp"
-
-#include "src/planner/binder/tableref/plan_expressionlistref.cpp"
-
-#include "src/planner/binder/tableref/plan_column_data_ref.cpp"
-
-#include "src/planner/binder/tableref/plan_joinref.cpp"
-
-#include "src/planner/binder/tableref/plan_subqueryref.cpp"
-
-#include "src/planner/binder/tableref/plan_table_function.cpp"
-
-#include "src/planner/binder/tableref/plan_cteref.cpp"
-
-#include "src/planner/binder/tableref/plan_pivotref.cpp"
-
diff --git a/src/duckdb/ub_src_planner_expression.cpp b/src/duckdb/ub_src_planner_expression.cpp
deleted file mode 100644
index 48fe05573..000000000
--- a/src/duckdb/ub_src_planner_expression.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "src/planner/expression/bound_expression.cpp"
-
-#include "src/planner/expression/bound_aggregate_expression.cpp"
-
-#include "src/planner/expression/bound_between_expression.cpp"
-
-#include "src/planner/expression/bound_case_expression.cpp"
-
-#include "src/planner/expression/bound_cast_expression.cpp"
-
-#include "src/planner/expression/bound_columnref_expression.cpp"
-
-#include "src/planner/expression/bound_comparison_expression.cpp"
-
-#include "src/planner/expression/bound_conjunction_expression.cpp"
-
-#include "src/planner/expression/bound_constant_expression.cpp"
-
-#include "src/planner/expression/bound_expanded_expression.cpp"
-
-#include "src/planner/expression/bound_function_expression.cpp"
-
-#include "src/planner/expression/bound_lambda_expression.cpp"
-
-#include "src/planner/expression/bound_lambdaref_expression.cpp"
-
-#include "src/planner/expression/bound_operator_expression.cpp"
-
-#include "src/planner/expression/bound_parameter_expression.cpp"
-
-#include "src/planner/expression/bound_reference_expression.cpp"
-
-#include "src/planner/expression/bound_subquery_expression.cpp"
-
-#include "src/planner/expression/bound_unnest_expression.cpp"
-
-#include "src/planner/expression/bound_window_expression.cpp"
-
diff --git a/src/duckdb/ub_src_planner_expression_binder.cpp b/src/duckdb/ub_src_planner_expression_binder.cpp
deleted file mode 100644
index 982e30149..000000000
--- a/src/duckdb/ub_src_planner_expression_binder.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "src/planner/expression_binder/aggregate_binder.cpp"
-
-#include "src/planner/expression_binder/alter_binder.cpp"
-
-#include "src/planner/expression_binder/base_select_binder.cpp"
-
-#include "src/planner/expression_binder/check_binder.cpp"
-
-#include "src/planner/expression_binder/column_alias_binder.cpp"
-
-#include "src/planner/expression_binder/constant_binder.cpp"
-
-#include "src/planner/expression_binder/group_binder.cpp"
-
-#include "src/planner/expression_binder/having_binder.cpp"
-
-#include "src/planner/expression_binder/lateral_binder.cpp"
-
-#include "src/planner/expression_binder/qualify_binder.cpp"
-
-#include "src/planner/expression_binder/index_binder.cpp"
-
-#include "src/planner/expression_binder/insert_binder.cpp"
-
-#include "src/planner/expression_binder/order_binder.cpp"
-
-#include "src/planner/expression_binder/relation_binder.cpp"
-
-#include "src/planner/expression_binder/returning_binder.cpp"
-
-#include "src/planner/expression_binder/select_binder.cpp"
-
-#include "src/planner/expression_binder/select_bind_state.cpp"
-
-#include "src/planner/expression_binder/table_function_binder.cpp"
-
-#include "src/planner/expression_binder/update_binder.cpp"
-
-#include "src/planner/expression_binder/where_binder.cpp"
-
diff --git a/src/duckdb/ub_src_planner_filter.cpp b/src/duckdb/ub_src_planner_filter.cpp
deleted file mode 100644
index a7f44ee8b..000000000
--- a/src/duckdb/ub_src_planner_filter.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "src/planner/filter/conjunction_filter.cpp"
-
-#include "src/planner/filter/constant_filter.cpp"
-
-#include "src/planner/filter/dynamic_filter.cpp"
-
-#include "src/planner/filter/in_filter.cpp"
-
-#include "src/planner/filter/null_filter.cpp"
-
-#include "src/planner/filter/struct_filter.cpp"
-
-#include "src/planner/filter/optional_filter.cpp"
-
diff --git a/src/duckdb/ub_src_planner_operator.cpp b/src/duckdb/ub_src_planner_operator.cpp
deleted file mode 100644
index 88b3bc637..000000000
--- a/src/duckdb/ub_src_planner_operator.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "src/planner/operator/logical_aggregate.cpp"
-
-#include "src/planner/operator/logical_any_join.cpp"
-
-#include "src/planner/operator/logical_column_data_get.cpp"
-
-#include "src/planner/operator/logical_comparison_join.cpp"
-
-#include "src/planner/operator/logical_copy_to_file.cpp"
-
-#include "src/planner/operator/logical_copy_database.cpp"
-
-#include "src/planner/operator/logical_create.cpp"
-
-#include "src/planner/operator/logical_create_index.cpp"
-
-#include "src/planner/operator/logical_create_table.cpp"
-
-#include "src/planner/operator/logical_cross_product.cpp"
-
-#include "src/planner/operator/logical_cteref.cpp"
-
-#include "src/planner/operator/logical_delete.cpp"
-
-#include "src/planner/operator/logical_delim_get.cpp"
-
-#include "src/planner/operator/logical_dependent_join.cpp"
-
-#include "src/planner/operator/logical_distinct.cpp"
-
-#include "src/planner/operator/logical_dummy_scan.cpp"
-
-#include "src/planner/operator/logical_empty_result.cpp"
-
-#include "src/planner/operator/logical_export.cpp"
-
-#include "src/planner/operator/logical_expression_get.cpp"
-
-#include "src/planner/operator/logical_extension_operator.cpp"
-
-#include "src/planner/operator/logical_filter.cpp"
-
-#include "src/planner/operator/logical_get.cpp"
-
-#include "src/planner/operator/logical_insert.cpp"
-
-#include "src/planner/operator/logical_join.cpp"
-
-#include "src/planner/operator/logical_limit.cpp"
-
-#include "src/planner/operator/logical_order.cpp"
-
-#include "src/planner/operator/logical_pivot.cpp"
-
-#include "src/planner/operator/logical_positional_join.cpp"
-
-#include "src/planner/operator/logical_pragma.cpp"
-
-#include "src/planner/operator/logical_prepare.cpp"
-
-#include "src/planner/operator/logical_projection.cpp"
-
-#include "src/planner/operator/logical_recursive_cte.cpp"
-
-#include "src/planner/operator/logical_materialized_cte.cpp"
-
-#include "src/planner/operator/logical_sample.cpp"
-
-#include "src/planner/operator/logical_set.cpp"
-
-#include "src/planner/operator/logical_reset.cpp"
-
-#include "src/planner/operator/logical_set_operation.cpp"
-
-#include "src/planner/operator/logical_simple.cpp"
-
-#include "src/planner/operator/logical_top_n.cpp"
-
-#include "src/planner/operator/logical_unconditional_join.cpp"
-
-#include "src/planner/operator/logical_unnest.cpp"
-
-#include "src/planner/operator/logical_update.cpp"
-
-#include "src/planner/operator/logical_vacuum.cpp"
-
-#include "src/planner/operator/logical_window.cpp"
-
diff --git a/src/duckdb/ub_src_planner_subquery.cpp b/src/duckdb/ub_src_planner_subquery.cpp
deleted file mode 100644
index d3713024f..000000000
--- a/src/duckdb/ub_src_planner_subquery.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/planner/subquery/flatten_dependent_join.cpp"
-
-#include "src/planner/subquery/has_correlated_expressions.cpp"
-
-#include "src/planner/subquery/rewrite_correlated_expressions.cpp"
-
-#include "src/planner/subquery/rewrite_cte_scan.cpp"
-
diff --git a/src/duckdb/ub_src_storage.cpp b/src/duckdb/ub_src_storage.cpp
deleted file mode 100644
index 8c7b41043..000000000
--- a/src/duckdb/ub_src_storage.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "src/storage/arena_allocator.cpp"
-
-#include "src/storage/buffer_manager.cpp"
-
-#include "src/storage/checkpoint_manager.cpp"
-
-#include "src/storage/temporary_memory_manager.cpp"
-
-#include "src/storage/block.cpp"
-
-#include "src/storage/data_pointer.cpp"
-
-#include "src/storage/data_table.cpp"
-
-#include "src/storage/index.cpp"
-
-#include "src/storage/local_storage.cpp"
-
-#include "src/storage/magic_bytes.cpp"
-
-#include "src/storage/storage_manager.cpp"
-
-#include "src/storage/standard_buffer_manager.cpp"
-
-#include "src/storage/temporary_file_manager.cpp"
-
-#include "src/storage/table_index_list.cpp"
-
-#include "src/storage/write_ahead_log.cpp"
-
-#include "src/storage/optimistic_data_writer.cpp"
-
-#include "src/storage/partial_block_manager.cpp"
-
-#include "src/storage/single_file_block_manager.cpp"
-
-#include "src/storage/storage_info.cpp"
-
-#include "src/storage/storage_lock.cpp"
-
-#include "src/storage/wal_replay.cpp"
-
diff --git a/src/duckdb/ub_src_storage_buffer.cpp b/src/duckdb/ub_src_storage_buffer.cpp
deleted file mode 100644
index 1b839a710..000000000
--- a/src/duckdb/ub_src_storage_buffer.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/storage/buffer/buffer_handle.cpp"
-
-#include "src/storage/buffer/block_handle.cpp"
-
-#include "src/storage/buffer/block_manager.cpp"
-
-#include "src/storage/buffer/buffer_pool.cpp"
-
-#include "src/storage/buffer/buffer_pool_reservation.cpp"
-
diff --git a/src/duckdb/ub_src_storage_checkpoint.cpp b/src/duckdb/ub_src_storage_checkpoint.cpp
deleted file mode 100644
index 6e525736d..000000000
--- a/src/duckdb/ub_src_storage_checkpoint.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/storage/checkpoint/row_group_writer.cpp"
-
-#include "src/storage/checkpoint/table_data_writer.cpp"
-
-#include "src/storage/checkpoint/table_data_reader.cpp"
-
-#include "src/storage/checkpoint/write_overflow_strings_to_disk.cpp"
-
diff --git a/src/duckdb/ub_src_storage_compression.cpp b/src/duckdb/ub_src_storage_compression.cpp
deleted file mode 100644
index 491801cd7..000000000
--- a/src/duckdb/ub_src_storage_compression.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "src/storage/compression/numeric_constant.cpp"
-
-#include "src/storage/compression/fixed_size_uncompressed.cpp"
-
-#include "src/storage/compression/rle.cpp"
-
-#include "src/storage/compression/dictionary_compression.cpp"
-
-#include "src/storage/compression/string_uncompressed.cpp"
-
-#include "src/storage/compression/uncompressed.cpp"
-
-#include "src/storage/compression/validity_uncompressed.cpp"
-
-#include "src/storage/compression/bitpacking.cpp"
-
-#include "src/storage/compression/bitpacking_hugeint.cpp"
-
-#include "src/storage/compression/patas.cpp"
-
-#include "src/storage/compression/zstd.cpp"
-
-#include "src/storage/compression/alprd.cpp"
-
-#include "src/storage/compression/fsst.cpp"
-
-#include "src/storage/compression/empty_validity.cpp"
-
diff --git a/src/duckdb/ub_src_storage_compression_alp.cpp b/src/duckdb/ub_src_storage_compression_alp.cpp
deleted file mode 100644
index 7c4a9ceab..000000000
--- a/src/duckdb/ub_src_storage_compression_alp.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "src/storage/compression/alp/alp_constants.cpp"
-
-#include "src/storage/compression/alp/alp.cpp"
-
diff --git a/src/duckdb/ub_src_storage_compression_chimp.cpp b/src/duckdb/ub_src_storage_compression_chimp.cpp
deleted file mode 100644
index 0fd9302f7..000000000
--- a/src/duckdb/ub_src_storage_compression_chimp.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/storage/compression/chimp/bit_reader.cpp"
-
-#include "src/storage/compression/chimp/chimp_constants.cpp"
-
-#include "src/storage/compression/chimp/flag_buffer.cpp"
-
-#include "src/storage/compression/chimp/leading_zero_buffer.cpp"
-
-#include "src/storage/compression/chimp/chimp.cpp"
-
diff --git a/src/duckdb/ub_src_storage_compression_dictionary.cpp b/src/duckdb/ub_src_storage_compression_dictionary.cpp
deleted file mode 100644
index abfb3b323..000000000
--- a/src/duckdb/ub_src_storage_compression_dictionary.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "src/storage/compression/dictionary/common.cpp"
-
-#include "src/storage/compression/dictionary/analyze.cpp"
-
-#include "src/storage/compression/dictionary/compression.cpp"
-
-#include "src/storage/compression/dictionary/decompression.cpp"
-
diff --git a/src/duckdb/ub_src_storage_compression_roaring.cpp b/src/duckdb/ub_src_storage_compression_roaring.cpp
deleted file mode 100644
index cef83799e..000000000
--- a/src/duckdb/ub_src_storage_compression_roaring.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "src/storage/compression/roaring/common.cpp"
-
-#include "src/storage/compression/roaring/metadata.cpp"
-
-#include "src/storage/compression/roaring/analyze.cpp"
-
-#include "src/storage/compression/roaring/compress.cpp"
-
-#include "src/storage/compression/roaring/scan.cpp"
-
diff --git a/src/duckdb/ub_src_storage_metadata.cpp b/src/duckdb/ub_src_storage_metadata.cpp
deleted file mode 100644
index 3faaae0c0..000000000
--- a/src/duckdb/ub_src_storage_metadata.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "src/storage/metadata/metadata_manager.cpp"
-
-#include "src/storage/metadata/metadata_reader.cpp"
-
-#include "src/storage/metadata/metadata_writer.cpp"
-
diff --git a/src/duckdb/ub_src_storage_serialization.cpp b/src/duckdb/ub_src_storage_serialization.cpp
deleted file mode 100644
index 93c3e4455..000000000
--- a/src/duckdb/ub_src_storage_serialization.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "src/storage/serialization/serialize_constraint.cpp"
-
-#include "src/storage/serialization/serialize_create_info.cpp"
-
-#include "src/storage/serialization/serialize_dependency.cpp"
-
-#include "src/storage/serialization/serialize_expression.cpp"
-
-#include "src/storage/serialization/serialize_extension_install_info.cpp"
-
-#include "src/storage/serialization/serialize_extra_drop_info.cpp"
-
-#include "src/storage/serialization/serialize_logical_operator.cpp"
-
-#include "src/storage/serialization/serialize_macro_function.cpp"
-
-#include "src/storage/serialization/serialize_nodes.cpp"
-
-#include "src/storage/serialization/serialize_parsed_expression.cpp"
-
-#include "src/storage/serialization/serialize_parse_info.cpp"
-
-#include "src/storage/serialization/serialize_query_node.cpp"
-
-#include "src/storage/serialization/serialize_result_modifier.cpp"
-
-#include "src/storage/serialization/serialize_statement.cpp"
-
-#include "src/storage/serialization/serialize_table_filter.cpp"
-
-#include "src/storage/serialization/serialize_tableref.cpp"
-
-#include "src/storage/serialization/serialize_types.cpp"
-
-#include "src/storage/serialization/serialize_storage.cpp"
-
diff --git a/src/duckdb/ub_src_storage_statistics.cpp b/src/duckdb/ub_src_storage_statistics.cpp
deleted file mode 100644
index 637a311d7..000000000
--- a/src/duckdb/ub_src_storage_statistics.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "src/storage/statistics/base_statistics.cpp"
-
-#include "src/storage/statistics/column_statistics.cpp"
-
-#include "src/storage/statistics/distinct_statistics.cpp"
-
-#include "src/storage/statistics/array_stats.cpp"
-
-#include "src/storage/statistics/list_stats.cpp"
-
-#include "src/storage/statistics/numeric_stats.cpp"
-
-#include "src/storage/statistics/segment_statistics.cpp"
-
-#include "src/storage/statistics/string_stats.cpp"
-
-#include "src/storage/statistics/struct_stats.cpp"
-
diff --git a/src/duckdb/ub_src_storage_table.cpp b/src/duckdb/ub_src_storage_table.cpp
deleted file mode 100644
index c7f69ecd0..000000000
--- a/src/duckdb/ub_src_storage_table.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "src/storage/table/chunk_info.cpp"
-
-#include "src/storage/table/column_checkpoint_state.cpp"
-
-#include "src/storage/table/column_data_checkpointer.cpp"
-
-#include "src/storage/table/column_data.cpp"
-
-#include "src/storage/table/column_segment.cpp"
-
-#include "src/storage/table/array_column_data.cpp"
-
-#include "src/storage/table/list_column_data.cpp"
-
-#include "src/storage/table/update_segment.cpp"
-
-#include "src/storage/table/persistent_table_data.cpp"
-
-#include "src/storage/table/row_group.cpp"
-
-#include "src/storage/table/row_group_collection.cpp"
-
-#include "src/storage/table/row_version_manager.cpp"
-
-#include "src/storage/table/scan_state.cpp"
-
-#include "src/storage/table/standard_column_data.cpp"
-
-#include "src/storage/table/struct_column_data.cpp"
-
-#include "src/storage/table/table_statistics.cpp"
-
-#include "src/storage/table/validity_column_data.cpp"
-
diff --git a/src/duckdb/ub_src_transaction.cpp b/src/duckdb/ub_src_transaction.cpp
deleted file mode 100644
index c2b15db55..000000000
--- a/src/duckdb/ub_src_transaction.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "src/transaction/duck_transaction_manager.cpp"
-
-#include "src/transaction/duck_transaction.cpp"
-
-#include "src/transaction/meta_transaction.cpp"
-
-#include "src/transaction/undo_buffer_allocator.cpp"
-
-#include "src/transaction/undo_buffer.cpp"
-
-#include "src/transaction/transaction_context.cpp"
-
-#include "src/transaction/transaction.cpp"
-
-#include "src/transaction/transaction_manager.cpp"
-
-#include "src/transaction/commit_state.cpp"
-
-#include "src/transaction/rollback_state.cpp"
-
-#include "src/transaction/cleanup_state.cpp"
-
-#include "src/transaction/wal_write_state.cpp"
-